Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrimeNumberGenerator pg=new PrimeNumberGenerator();
    while(true){
      int n=Integer.parseInt(br.readLine());
      if(n==0){
        break ;
      }
      if(pg.isPrime(n)){
        System.out.println(0);
        continue ;
      }
      int begin=-1 ;
      int end=-1 ;
      for(int i=n-1 ; i>=0 ; i--){
        if(pg.isPrime(i)){
          begin=i ;
          break ;
        }
      }
      for(int i=n+1 ; i<2000000 ; i++){
        if(pg.isPrime(i)){
          end=i ;
          break ;
        }
      }
      System.out.println(end-begin);
    }
  }
}
class PrimeNumberGenerator {
  private final int N=2000000 ;
  private boolean[] isPrime=new boolean[N+1];
  public PrimeNumberGenerator(){
    Arrays.fill(isPrime,true);
    isPrime[0]=false ;
    isPrime[1]=false ;
    int limit=(int)Math.sqrt(N);
    for(int i=2 ; i<=limit ; i++){
      if(isPrime[i]==false){
        continue ;
      }
      for(int j=i*2 ; j<=N ; j+=i){
        isPrime[j]=false ;
      }
    }
  }
  public boolean isPrime(int index){
    return isPrime[index];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pg : PrimeNumberGenerator ; pg := PrimeNumberGenerator.newPrimeNumberGenerator() ;
     while (true) do (     var n : int ; n := (br.readLine())->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    if (pg.isPrime(n)) then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
    var begin : int ; begin := -1 ;
    var end : int ; end := -1 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (pg.isPrime(i)) then (     begin := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
        var i : int ; i := n + 1 ; while i < 2000000 do ( (     if (pg.isPrime(i)) then (     end := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(end - begin) ; 
 ) );
}
class PrimeNumberGenerator {
   attribute N : int := 2000000;
   attribute isPrime : Sequence(boolean) := Integer.subrange(1,N + 1)->collect(false);
   static operation newPrimeNumberGenerator() : PrimeNumberGenerator
  pre: true
  post: true
  activity:
  ( var self : PrimeNumberGenerator ;
    self := createPrimeNumberGenerator();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     isPrime := isPrime->collect(true) ; 
     isPrime[0+1] := false ; 
    isPrime[1+1] := false ; 
    var limit : int ; limit := (N)->sqrt()->oclAsType(int) ;
        var i : int ; i := 2 ; while i <= limit do ( (     if (isPrime[i+1] = false) then (     continue ) else skip ; 
         var j : int ; j := i * 2 ; while j <= N do ( (     isPrime[j+1] := false )  ;     j := j+(i) ) )  ;     i := i + 1 ) ; 
 );
   operation isPrime( index : int) : boolean
  pre: true
  post: true
  activity: (     return isPrime[index+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long start=sc.nextLong();
    long ratio=sc.nextLong();
    long max=sc.nextLong();
    int m=sc.nextInt();
    ArrayList<Long>bad=new ArrayList<Long>();
    for(int i=0 ; i<m ; i++){
      bad.add(sc.nextLong());
    }
    if(Math.abs(start)>max){
      System.out.println("0");
      return ;
    }
    if(start==0){
      if(bad.contains(start)){
        System.out.println("0");
        return ;
      }
      else {
        System.out.println("inf");
        return ;
      }
    }
    if(ratio==1){
      if(bad.contains(start)){
        System.out.println("0");
        return ;
      }
      else {
        System.out.println("inf");
        return ;
      }
    }
    if(ratio==-1){
      if(bad.contains(start)&& bad.contains(start*(-1))){
        System.out.println("0");
        return ;
      }
      else {
        System.out.println("inf");
        return ;
      }
    }
    if(ratio==0){
      if(bad.contains(ratio)==false){
        System.out.println("inf");
        return ;
      }
      else if(bad.contains(start)){
        System.out.println("0");
        return ;
      }
      else {
        System.out.println("1");
        return ;
      }
    }
    int cnt=0 ;
    while(Math.abs(start)<=max){
      if(bad.contains(start)==false){
        cnt++;
      }
      start*=ratio ;
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var start : long ; start := sc.getCurrent()->toLong() ;
    var ratio : long ; ratio := sc.getCurrent()->toLong() ;
    var max : long ; max := sc.getCurrent()->toLong() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var bad : Sequence(long) ; bad := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     bad := bad->including(sc.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    if (if start < 0 then -(start) else start endif > max) then (     OclFile["System.out"].println("0") ; 
     return ) else skip ; 
    if (start = 0) then (     if (bad->includes(start)) then (     OclFile["System.out"].println("0") ; 
     return ) else (     OclFile["System.out"].println("inf") ; 
     return ) ) else skip ; 
    if (ratio = 1) then (     if (bad->includes(start)) then (     OclFile["System.out"].println("0") ; 
     return ) else (     OclFile["System.out"].println("inf") ; 
     return ) ) else skip ; 
    if (ratio = -1) then (     if (bad->includes(start) & bad->includes(start * (-1))) then (     OclFile["System.out"].println("0") ; 
     return ) else (     OclFile["System.out"].println("inf") ; 
     return ) ) else skip ; 
    if (ratio = 0) then (     if (bad->includes(ratio) = false) then (     OclFile["System.out"].println("inf") ; 
     return ) else     if (bad->includes(start)) then (     OclFile["System.out"].println("0") ; 
     return ) else (     OclFile["System.out"].println("1") ; 
     return ) ;  ) else skip ; 
    var cnt : int ; cnt := 0 ;
    while (if start < 0 then -(start) else start endif <= max) do (     if (bad->includes(start) = false) then (     cnt := cnt + 1 ) else skip ; 
     start := start*(ratio) ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void maxProductSum(String str,int m){
    int n=str.length();
    int maxProd=Integer.MIN_VALUE,maxSum=Integer.MIN_VALUE ;
    for(int i=0 ; i<n-m ; i++){
      int product=1,sum=0 ;
      for(int j=i ; j<m+i ; j++){
        product=product*(str.charAt(j)-'0');
        sum=sum+(str.charAt(j)-'0');
      }
      maxProd=Math.max(maxProd,product);
      maxSum=Math.max(maxSum,sum);
    }
    System.out.println("Maximum Product="+maxProd);
    System.out.print("\nMaximum Sum="+maxSum);
  }
  public static void main(String[] args){
    String str="3675356291" ;
    int m=5 ;
    maxProductSum(str,m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxProductSum( str : String, m : int) : void
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var maxProd : int ; maxProd := -2147483648 ;
    var maxSum : int ; maxSum := -2147483648 ;
        var i : int ; i := 0 ; while i < n - m do ( (     var product : int ; product := 1 ;
    var sum : int ; sum := 0 ;
         var j : int ; j := i ; while j < m + i do ( (     product := product * (str->at(j+1) - ('0')->char2byte()) ; 
     sum := sum + (str->at(j+1) - ('0')->char2byte()) )  ;     j := j + 1 ) ; 
     maxProd := Set{maxProd, product}->max() ; 
     maxSum := Set{maxSum, sum}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Maximum Product=" + maxProd) ; 
    OclFile["System.out"].print("\nMaximum Sum=" + maxSum) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "3675356291" ;
     var m : int ; m := 5 ;
     execute maxProductSum(str, m) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static int solve(int a,int b){
    int count=0 ;
    while(a>=b){
      count+=a/b ;
      a=(a % b)+(a/b);
    }
    return count ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a,b ;
    a=sc.nextInt();
    b=sc.nextInt();
    System.out.println(a+solve(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (a >= b) do (     count := count+(a / b) ; 
     a := (a mod b) + (a / b) ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ;
    var b : int ;
    a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    OclFile["System.out"].println(a + solve(a, b)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(true){
      String a=stdIn.next();
      if(a.equals("#"))break ;
      if(a.length()==5){
        System.out.println(0);
        continue ;
      }
      if(a.length()==4){
        System.out.println(90);
        continue ;
      }
      int b=0 ;
      int c=1 ;
      int d=a.length()-1 ;
      if(a.charAt(d)=='h'){
        d-=5 ;
      }
      else {
        d-=4 ;
        b=90 ;
      }
      while(true){
        if(d<=0)break ;
        c=c<<1 ;
        if(a.charAt(d)=='h'){
          d-=5 ;
          b=2*b-90 ;
          continue ;
        }
        else {
          d-=4 ;
          b=2*b+90 ;
          continue ;
        }
      }
      int gcd=gcd(b,c);
      if(b % c==0){
        System.out.println(b/c);
      }
      else {
        System.out.println(b/gcd+"/"+c/gcd);
      }
    }
  }
  public static int gcd(int b,int c){
    if(c==0)return b ;
    return gcd(c,b % c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var a : String ; a := stdIn.getCurrent() ;
     if (a = "#") then     break else skip ; 
    if (a->size() = 5) then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
    if (a->size() = 4) then (     OclFile["System.out"].println(90) ; 
     continue ) else skip ; 
    var b : int ; b := 0 ;
    var c : int ; c := 1 ;
    var d : int ; d := a->size() - 1 ;
    if (a->at(d+1) = 'h') then (     d := d-(5) ) else (     d := d-(4) ; 
     b := 90 ) ;  
    while (true) do (     if (d <= 0) then     break else skip ; 
     c := (c*(2->pow(1)))->oclAsType(long) ; 
     if (a->at(d+1) = 'h') then (     d := d-(5) ; 
     b := 2 * b - 90 ; 
     continue ) else (     d := d-(4) ; 
     b := 2 * b + 90 ; 
     continue ) ) ; 
    var gcd : int ; gcd := gcd(b, c) ;
    if (b mod c = 0) then (     OclFile["System.out"].println(b / c) ) else (     OclFile["System.out"].println(b / gcd + "/" + c / gcd) ) ;  
 ) );
  static   operation gcd( b : int, c : int) : int
  pre: true
  post: true
  activity: (     if (c = 0) then     return b else skip ; 
     return gcd(c, b mod c) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static boolean solve(){
    String s=in.next();
    if("#".equals(s))return false ;
    int pos=s.length(),cnt=0 ;
    double d=-1 ;
    while(pos>=0){
      while(s.charAt(--pos)!='w' && s.charAt(pos)!='n');
      if(s.charAt(pos)=='n'){
        if(cnt==0)d=0 ;
        else d-=90.0/(1<<cnt);
      }
      else {
        if(cnt==0)d=90 ;
        else d+=90.0/(1<<cnt);
      }
      cnt++;
      pos--;
    }
    int div=1 ;
    while((int)d!=d){
      d*=2 ;
      div*=2 ;
    }
    int ans=(int)d ;
    out.println(ans+(div==1 ? "" :("/"+div)));
    return true ;
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    while(solve());
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : boolean
  pre: true
  post: true
  activity: (     var s : String ; s := in.getCurrent() ;
     if ("#" = s) then     return false else skip ; 
    var pos : int ; pos := s->size() ;
    var cnt : int ; cnt := 0 ;
    var d : double ; d := -1 ;
    while (pos >= 0) do (     while (s->at((pos - 1)+1) /= 'w' & s->at(pos+1) /= 'n') do  ; 
     if (s->at(pos+1) = 'n') then (     if (cnt = 0) then     d := 0 ; else     d := d-(90.0 / ((1*(2->pow(cnt)))->oclAsType(long))) ; ) else (     if (cnt = 0) then     d := 90 ; else     d := d+(90.0 / ((1*(2->pow(cnt)))->oclAsType(long))) ; ) ;  
     cnt := cnt + 1 ; 
     pos := pos - 1 ) ; 
    var div : int ; div := 1 ;
    while (d->oclAsType(int) /= d) do (     d := d*(2) ; 
     div := div*(2) ) ; 
    var ans : int ; ans := d->oclAsType(int) ;
    skip ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    while (solve()) do  ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static String input ;
  static int pos ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      input=sc.next();
      if(input.equals("#"))break ;
      pos=0 ;
      int n=0 ;
      List<String>dirList=new ArrayList<String>();
      List<Rational>list=new ArrayList<Rational>();
      while(pos<input.length()){
        if(input.charAt(pos)=='n'){
          dirList.add("north");
          pos+=5 ;
        }
        else {
          dirList.add("west");
          pos+=4 ;
        }
        n++;
      }
      Collections.reverse(dirList);
      for(int i=0 ; i<n ; i++){
        String dir=dirList.get(i);
        if(dir.equals("north"))list.add(new Rational(-90,(long)Math.pow(2,i)));
        else list.add(new Rational(90,(long)Math.pow(2,i)));
      }
      Rational result=new Rational(0,1);
      for(Rational rat : list){
        result.add(rat);
      }
      System.out.println(result);
    }
    sc.close();
  }
  static class Rational {
    long child,base ;
    Rational(long c,long b){
      child=c ;
      base=b ;
    }
    public String toString(){
      if(base==1)return Long.toString(child);
      return child+"/"+base ;
    }
    public void add(Rational anotherRational){
      long r=anotherRational.base/base ;
      child*=r ;
      base*=r ;
      child+=anotherRational.child ;
      child=Math.max(child,0);
      child=Math.min(child,base*90);
      while(child % 2==0 && base % 2==0){
        child/=2 ;
        base/=2 ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute input : String;
  static   attribute pos : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     input := sc.getCurrent() ; 
     if (input = "#") then     break else skip ; 
    pos := 0 ; 
    var n : int ; n := 0 ;
    var dirList : Sequence(String) ; dirList := Sequence{} ;
    var list : Sequence(Rational) ; list := Sequence{} ;
    while (pos < input->size()) do (     if (input->at(pos+1) = 'n') then (     dirList := dirList->including("north") ; 
     pos := pos+(5) ) else (     dirList := dirList->including("west") ; 
     pos := pos+(4) ) ;  
     n := n + 1 ) ; 
    dirList := dirList->reverse() ; 
        var i : int ; i := 0 ; while i < n do ( (     var dir : String ; dir := dirList->at(i+1) ;
     if (dir = "north") then     list := list->including(Rational.newRational(-90, 2->pow(i)->oclAsType(long))) ; else     list := list->including(Rational.newRational(90, 2->pow(i)->oclAsType(long))) ; )  ;     i := i + 1 ) ; 
    var result : Rational ; result := Rational.newRational(0, 1) ;
    for (rat : list) do ( (     result->excludes(rat) )  ) ; 
    OclFile["System.out"].println(result) ; 
 ) ; 
     skip );
  static class Rational {
   attribute child : long;
   static operation newRational( c : long, b : long) : Rational
  pre: true
  post: true
  activity:
  ( var self : Rational ;
    self := createRational();
    self.initialise(c, b);
    return self );
  operation initialise( c : long, b : long) : void
  pre: true  post: true
  activity: (     child := c ; 
     base := b );
   operation toString() : String
  pre: true
  post: true
  activity: (     if (base = 1) then     return ((child) + "") else skip ; 
     return child + "/" + base );
   operation add( anotherRational : Rational) : void
  pre: true
  post: true
  activity: (     var r : long ; r := anotherRational.base / base ;
     child := child*(r) ; 
    base := base*(r) ; 
    child := child+(anotherRational.child) ; 
    child := Set{child, 0}->max() ; 
    child := Set{child, base * 90}->min() ; 
    while (child mod 2 = 0 & base mod 2 = 0) do (     child := child/(2) ; 
     base := base/(2) ) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public void run(){
    while(true){
      String s=sc.next();
      if(s.equals("#"))break ;
      calc(s);
    }
  }
  public void calc(String s){
    int[] north=new int[20];
    int n=0 ;
    String check=s ;
    while(check.length()!=0){
      String part=check.substring(0,4);
      if(part.equals("west")){
        north[n]=-1 ;
        check=check.substring(4);
      }
      else {
        north[n]=1 ;
        check=check.substring(5);
      }
      n++;
    }
    int ans=0 ;
    int ansd=1 ;
    if(north[n-1]==-1)ans=90 ;
    for(int i=n-2 ; i>=0 ; i--){
      if(north[i]==1){
        ans=2*ans-90 ;
        ansd=2*ansd ;
        if(ans<0){
          ans=0 ;
          ansd=1 ;
        }
      }
      else if(north[i]==-1){
        ans=2*ans+90 ;
        ansd=2*ansd ;
      }
    }
    while(ans % 2==0 && ansd % 2==0){
      ans=ans/2 ;
      ansd=ansd/2 ;
    }
    System.out.print(ans);
    if(ansd!=1)System.out.print("/"+ansd);
    System.out.println();
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     while (true) do (     var s : String ; s := sc.getCurrent() ;
     if (s = "#") then     break else skip ; 
     execute calc(s) ) );
   operation calc( s : String) : void
  pre: true
  post: true
  activity: (     var north : Sequence(int) ; north := Integer.subrange(1,20)->collect(0) ;
     var n : int ; n := 0 ;
    var check : String ; check := s ;
    while (check->size() /= 0) do (     var part : String ; part := check.subrange(0+1,4) ;
     if (part = "west") then (     north[n+1] := -1 ; 
     check := check.subrange(4+1,4) ) else (     north[n+1] := 1 ; 
     check := check.subrange(5+1,5) ) ;  
     n := n + 1 ) ; 
    var ans : int ; ans := 0 ;
    var ansd : int ; ansd := 1 ;
    if (north[n - 1+1] = -1) then     ans := 90 ; else skip ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (north[i+1] = 1) then (     ans := 2 * ans - 90 ; 
     ansd := 2 * ansd ; 
     if (ans < 0) then (     ans := 0 ; 
     ansd := 1 ) else skip ) else     if (north[i+1] = -1) then (     ans := 2 * ans + 90 ; 
     ansd := 2 * ansd ) else skip ; )  ;     i := i - 1 ) ; 
    while (ans mod 2 = 0 & ansd mod 2 = 0) do (     ans := ans / 2 ; 
     ansd := ansd / 2 ) ; 
    OclFile["System.out"].print(ans) ; 
    if (ansd /= 1) then     OclFile["System.out"].print("/" + ansd) ; else skip ; 
    OclFile["System.out"].println() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int x=0 ;
      int[] idx=new int[n];
      int[] arr=new int[n];
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        arr[i]=s.nextInt();
      }
      int c=0 ;
      for(int i=0 ; i<n ; i++){
        if(arr[i] % 2==0){
          c++;
          idx[x++]=i+1 ;
          sum+=arr[i];
        }
      }
      int y=0 ;
      for(int i=0 ; i<n ; i++){
        if(arr[i] % 2!=0 && y==0)y=i+1 ;
        else if(arr[i] % 2!=0 && y!=0){
          c+=2 ;
          idx[x++]=y ;
          idx[x++]=i+1 ;
          sum+=arr[y-1]+arr[i];
          y=0 ;
        }
      }
      if(y!=0){
        sum+=arr[y-1];
        if(! isPrime(sum)){
          c++;
          idx[x]=y ;
        }
      }
      System.out.println(c);
      for(int i=0 ; i<c ; i++){
        System.out.print(idx[i]+" ");
      }
      System.out.println();
    }
  }
  static boolean isPrime(int num){
    if(num<=1)return false ;
    for(int i=2 ; i<=num/2 ; i++){
      if(num % i==0)return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var x : int ; x := 0 ;
    var idx : Sequence(int) ; idx := Integer.subrange(1,n)->collect(0) ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 = 0) then (     c := c + 1 ; 
      idx[x+1] := i + 1  ; x := x + 1 ; 
     sum := sum+(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    var y : int ; y := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 /= 0 & y = 0) then     y := i + 1 ; else     if (arr[i+1] mod 2 /= 0 & y /= 0) then (     c := c+(2) ; 
      idx[x+1] := y  ; x := x + 1 ; 
     idx[x+1] := i + 1  ; x := x + 1 ; 
    sum := sum+(arr[y - 1+1] + arr[i+1]) ; 
    y := 0 ; 
 ) else skip ; )  ;     i := i + 1 ) ; 
    if (y /= 0) then (     sum := sum+(arr[y - 1+1]) ; 
     if (not(isPrime(sum))) then (     c := c + 1 ; 
     idx[x+1] := y ) else skip ) else skip ; 
    OclFile["System.out"].println(c) ; 
        var i : int ; i := 0 ; while i < c do ( (     OclFile["System.out"].print(idx[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
  static   operation isPrime( num : int) : boolean
  pre: true
  post: true
  activity: (     if (num <= 1) then     return false else skip ; 
         var i : int ; i := 2 ; while i <= num / 2 do ( (     if (num mod i = 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int counDivisors(int X){
    int count=0 ;
    for(int i=1 ; i<=X ; ++i){
      if(X % i==0){
        count++;
      }
    }
    return count ;
  }
  static int countDivisorsMult(int arr[],int n){
    int mul=1 ;
    for(int i=0 ; i<n ; ++i)mul*=arr[i];
    return counDivisors(mul);
  }
  public static void main(String[] args){
    int arr[]={
      2,4,6 };
      int n=arr.length ;
      System.out.println(countDivisorsMult(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation counDivisors( X : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i <= X do ( (     if (X mod i = 0) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation countDivisorsMult( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var mul : int ; mul := 1 ;
         var i : int ; i := 0 ; while i < n do (     mul := mul*(arr[i+1]) ;  ;     i := i + 1 ) ; 
     return counDivisors(mul) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countDivisorsMult(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printRepeating(int arr[],int n){
    for(int i=0 ; i<n ; i++){
      int index=arr[i] % n ;
      arr[index]+=n ;
    }
    for(int i=0 ; i<n ; i++){
      if((arr[i]/n)>1)System.out.println(i+" ");
    }
  }
  public static void main(String args[]){
    int arr[]={
      1,6,3,1,3,6,6 };
      int arr_size=arr.length ;
      System.out.println("The repeating elements are: ");
      printRepeating(arr,arr_size);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printRepeating( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var index : int ; index := arr[i+1] mod n ;
     arr[index+1] := arr[index+1]+(n) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if ((arr[i+1] / n) > 1) then     OclFile["System.out"].println(i + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,6,3,1,3,6,6} ;
     var arr_size : int ; arr_size := arr->size() ;
     OclFile["System.out"].println("The repeating elements are: ") ; 
     execute printRepeating(arr, arr_size) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int gcd(int a,int b){
    if(a==0)return b ;
    else return gcd(b % a,a);
  }
  public static void solve(int n,int m,int x,int y,int a,int b){
    int k,g ;
    int x1,y1,x2,y2 ;
    g=gcd(a,b);
    a/=g ;
    b/=g ;
    k=Math.min(n/a,m/b);
    x1=x-(k*a-k*a/2);
    x2=x+k*a/2 ;
    y1=y-(k*b-k*b/2);
    y2=y+k*b/2 ;
    if(x1<0){
      x2-=x1 ;
      x1=0 ;
    }
    if(x2>n){
      x1-=x2-n ;
      x2=n ;
    }
    if(y1<0){
      y2-=y1 ;
      y1=0 ;
    }
    if(y2>m){
      y1-=y2-m ;
      y2=m ;
    }
    System.out.println(x1+" "+y1+" "+x2+" "+y2);
  }
  public static void main(String args[]){
    int n=70,m=10 ;
    int x=20,y=5 ;
    int a=5,b=3 ;
    solve(n,m,x,y,a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else     return gcd(b mod a, a) );
  static   operation solve( n : int, m : int, x : int, y : int, a : int, b : int) : void
  pre: true
  post: true
  activity: (     var k : int ;
    var g : int ;
     var x1 : int ;
    var y1 : int ;
    var x2 : int ;
    var y2 : int ;
    g := gcd(a, b) ; 
    a := a/(g) ; 
    b := b/(g) ; 
    k := Set{n / a, m / b}->min() ; 
    x1 := x - (k * a - k * a / 2) ; 
    x2 := x + k * a / 2 ; 
    y1 := y - (k * b - k * b / 2) ; 
    y2 := y + k * b / 2 ; 
    if (x1 < 0) then (     x2 := x2-(x1) ; 
     x1 := 0 ) else skip ; 
    if (x2 > n) then (     x1 := x1-(x2 - n) ; 
     x2 := n ) else skip ; 
    if (y1 < 0) then (     y2 := y2-(y1) ; 
     y1 := 0 ) else skip ; 
    if (y2 > m) then (     y1 := y1-(y2 - m) ; 
     y2 := m ) else skip ; 
    OclFile["System.out"].println(x1 + " " + y1 + " " + x2 + " " + y2) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 70 ;
    var m : int ; m := 10 ;
     var x : int ; x := 20 ;
    var y : int ; y := 5 ;
     var a : int ; a := 5 ;
    var b : int ; b := 3 ;
     execute solve(n, m, x, y, a, b) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.pow ;
class GFG {
  static double sum(int x,int n){
    double i,total=1.0 ;
    for(i=1 ; i<=n ; i++)total=total+(Math.pow(x,i)/i);
    return total ;
  }
  public static void main(String[] args){
    int x=2 ;
    int n=5 ;
    System.out.printf("%.2f",sum(x,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sum( x : int, n : int) : double
  pre: true
  post: true
  activity: (     var i : double ;
    var total : double ; total := 1.0 ;
         i := 1 ; while i <= n do (     total := total + (x->pow(i) / i) ;  ;     i := i + 1 ) ; 
     return total );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 2 ;
     var n : int ; n := 5 ;
     OclFile["System.out"].printf("%.2f", sum(x, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class close_to_n_divisible_m {
  static int closestNumber(int n,int m){
    int q=n/m ;
    int n1=m*q ;
    int n2=(n*m)>0 ?(m*(q+1)):(m*(q-1));
    if(Math.abs(n-n1)<Math.abs(n-n2))return n1 ;
    return n2 ;
  }
  public static void main(String args[]){
    int n=13,m=4 ;
    System.out.println(closestNumber(n,m));
    n=-15 ;
    m=6 ;
    System.out.println(closestNumber(n,m));
    n=0 ;
    m=8 ;
    System.out.println(closestNumber(n,m));
    n=18 ;
    m=-7 ;
    System.out.println(closestNumber(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class close_to_n_divisible_m {
  static   operation closestNumber( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var q : int ; q := n / m ;
     var n1 : int ; n1 := m * q ;
    var n2 : int ; n2 := if (n * m) > 0 then (m * (q + 1)) else (m * (q - 1)) endif ;
    if (if n - n1 < 0 then -(n - n1) else n - n1 endif < if n - n2 < 0 then -(n - n2) else n - n2 endif) then     return n1 else skip ; 
    return n2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 13 ;
    var m : int ; m := 4 ;
     OclFile["System.out"].println(closestNumber(n, m)) ; 
    n := -15 ; 
    m := 6 ; 
    OclFile["System.out"].println(closestNumber(n, m)) ; 
    n := 0 ; 
    m := 8 ; 
    OclFile["System.out"].println(closestNumber(n, m)) ; 
    n := 18 ; 
    m := -7 ; 
    OclFile["System.out"].println(closestNumber(n, m)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.util.Arrays.*;
public class Main {
  int[] as ;
  void run(){
    Scanner in=new Scanner(System.in);
    ArrayList<Integer>arr=new ArrayList<Integer>();
    for(int i=1 ; i<=1111 ; i++){
      for(int j=i ; j<=1111 ; j++){
        arr.add(i*i*i+j*j*j);
      }
    }
    as=new int[arr.size()];
    for(int i=0 ; i<as.length ; i++)as[i]=arr.get(i);
    sort(as);
    for(; ; ){
      int n=in.nextInt();
      if(n==0)return ;
      System.out.println(solve(n));
    }
  }
  int solve(int z){
    int id=-2-binarySearch(as,z*z*z);
    return z*z*z-as[id];
  }
  public static void main(String args[]){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute as : Sequence(int);
   operation run() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(int) ; arr := Sequence{} ;
        var i : int ; i := 1 ; while i <= 1111 do ( (         var j : int ; j := i ; while j <= 1111 do ( (     arr := arr->including(i * i * i + j * j * j) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    as := Integer.subrange(1,arr->size())->collect(0) ; 
        var i : int ; i := 0 ; while i < as->size() do (     as[i+1] := arr->at(i+1) ;  ;     i := i + 1 ) ; 
    execute sort(as) ; 
      while true do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
     OclFile["System.out"].println(solve(n)) )  ) ; 
 );
   operation solve( z : int) : int
  pre: true
  post: true
  activity: (     var id : int ; id := -2 - binarySearch(as, z * z * z) ;
     return z * z * z - as[id+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.IOException ;
class Main {
  public static void main(String[] args)throws IOException {
    int z,n=3 ;
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextInt()){
      z=sc.nextInt();
      if(z==0){
        break ;
      }
      System.out.println(calc(z,n));
    }
  }
  private static long calc(int z,int n){
    long min=Long.MAX_VALUE,tmp ;
    for(int x=1 ; mypower(x,n)<=mypower(z,n); x++){
      for(int y=x ; mypower(x,n)+mypower(y,n)<=mypower(z,n); y++){
        tmp=mypower(z,n)-mypower(x,n)-mypower(y,n);
        if(tmp<min){
          min=tmp ;
        }
      }
    }
    return min ;
  }
  private static long mypower(int base,int exp){
    long p=1 ;
    for(int i=0 ; i<exp ; i++){
      p*=base ;
    }
    return p ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var z : int ;
    var n : int ; n := 3 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextInt()) do (     z := sc.getCurrent()->toInteger() ; 
     if (z = 0) then (     break ) else skip ; 
     OclFile["System.out"].println(calc(z, n)) ) );
  static   operation calc( z : int, n : int) : long
  pre: true
  post: true
  activity: (     var min : long ; min := "9223372036854775807"->toLong() ;
    var tmp : long ;
         var x : int ; x := 1 ; while mypower(x, n) <= mypower(z, n) do ( (         var y : int ; y := x ; while mypower(x, n) + mypower(y, n) <= mypower(z, n) do ( (     tmp := mypower(z, n) - mypower(x, n) - mypower(y, n) ; 
     if (tmp < min) then (     min := tmp ) else skip )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
     return min );
  static   operation mypower( base : int, exp : int) : long
  pre: true
  post: true
  activity: (     var p : long ; p := 1 ;
         var i : int ; i := 0 ; while i < exp do ( (     p := p*(base) )  ;     i := i + 1 ) ; 
     return p );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    long[] p=new long[1111];
    for(int i=0 ; i<1111 ; i++)p[i]=(long)Math.pow(i,3);
    Scanner sc=new Scanner(System.in);
    while(true){
      int z=sc.nextInt();
      if(z==0)break ;
      int i=1,j=z ;
      long max=0 ;
      while(i<=j){
        long val=p[i]+p[j];
        if(val<=p[z]){
          i++;
          max=Math.max(max,val);
        }
        else j--;
      }
      System.out.println(p[z]-max);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var p : Sequence(long) ; p := Integer.subrange(1,1111)->collect(0) ;
         var i : int ; i := 0 ; while i < 1111 do (     p[i+1] := i->pow(3)->oclAsType(long) ;  ;     i := i + 1 ) ; 
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var z : int ; z := sc.getCurrent()->toInteger() ;
     if (z = 0) then     break else skip ; 
    var i : int ; i := 1 ;
    var j : int ; j := z ;
    var max : long ; max := 0 ;
    while (i <= j) do (     var val : long ; val := p[i+1] + p[j+1] ;
     if (val <= p[z+1]) then (     i := i + 1 ; 
     max := Set{max, val}->max() ) else     j := j - 1 ; ) ; 
    OclFile["System.out"].println(p[z+1] - max) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.LinkedList ;
import java.util.ListIterator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long[] pre=new long[1112];
    for(int i=0 ; i<1112 ; i++){
      long l=i ;
      l=l*l*l ;
      pre[i]=l ;
    }
    while(true){
      final int z=sc.nextInt();
      if(z==0){
        break ;
      }
      long max=0 ;
      for(int x=1 ; ; x++){
        if(pre[z]<pre[x]){
          break ;
        }
        for(int y=1 ; y<=x ; y++){
          if(pre[z]>=(pre[x]+pre[y])){
            max=Math.max(max,pre[x]+pre[y]);
          }
        }
      }
      System.out.println(pre[z]-max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pre : Sequence(long) ; pre := Integer.subrange(1,1112)->collect(0) ;
         var i : int ; i := 0 ; while i < 1112 do ( (     var l : long ; l := i ;
     l := l * l * l ; 
     pre[i+1] := l )  ;     i := i + 1 ) ; 
     while (true) do (     var z : int ; z := sc.getCurrent()->toInteger() ;
     if (z = 0) then (     break ) else skip ; 
    var max : long ; max := 0 ;
        var x : int ; x := 1 ; while true do ( (     if (pre[z+1] < pre[x+1]) then (     break ) else skip ; 
         var y : int ; y := 1 ; while y <= x do ( (     if (pre[z+1] >= (pre[x+1] + pre[y+1])) then (     max := Set{max, pre[x+1] + pre[y+1]}->max() ) else skip )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println(pre[z+1] - max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  public static void main(String[] args)throws IOException {
    int end=Integer.parseInt(br.readLine());
    while(end!=0){
      new Main().cal(end);
      end=Integer.parseInt(br.readLine());
    }
  }
  int[] thr ;
  private void cal(int end)throws IOException {
    int z=end ;
    int limit=z*z*z ;
    int tmp ;
    int max ;
    thr=new int[z];
    for(int i=1 ; i<z ; i++){
      thr[i]=i*i*i ;
    }
    max=thr[1]+thr[1];
    for(int i=1 ; i<z ; i++){
      for(int j=1 ; j<z ; j++){
        tmp=thr[i]+thr[j];
        if(tmp<=limit && tmp>max){
          max=tmp ;
        }
        if(tmp>=limit){
          break ;
        }
      }
    }
    System.out.println(limit-max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var end : int ; end := (br.readLine())->toInteger() ;
     while (end /= 0) do (     Main.newMain().cal(end) ; 
     end := (br.readLine())->toInteger() ) );
   attribute thr : Sequence(int);
   operation cal( end : int) : void
  pre: true
  post: true
  activity: (     var z : int ; z := end ;
     var limit : int ; limit := z * z * z ;
    var tmp : int ;
    var max : int ;
    thr := Integer.subrange(1,z)->collect(0) ; 
        var i : int ; i := 1 ; while i < z do ( (     thr[i+1] := i * i * i )  ;     i := i + 1 ) ; 
    max := thr[1+1] + thr[1+1] ; 
        var i : int ; i := 1 ; while i < z do ( (         var j : int ; j := 1 ; while j < z do ( (     tmp := thr[i+1] + thr[j+1] ; 
     if (tmp <= limit & tmp > max) then (     max := tmp ) else skip ; 
     if (tmp >= limit) then (     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(limit - max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class B1602 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      int[] A=new int[N];
      for(int n=0 ; n<N ; n++){
        A[n]=in.nextInt();
      }
      List<int[]>list=new ArrayList<>();
      boolean change ;
      do {
        change=false ;
        list.add(A);
        int[] stat=new int[N+1];
        for(int a : A){
          stat[a]++;
        }
        int[] newA=new int[N];
        for(int n=0 ; n<N ; n++){
          int a=A[n];
          int na=stat[a];
          newA[n]=na ;
          if(na!=a){
            change=true ;
          }
        }
        A=newA ;
      }
      while(change);
      StringBuilder output=new StringBuilder();
      int Q=in.nextInt();
      for(int q=0 ; q<Q ; q++){
        int idx=in.nextInt();
        int listIdx=in.nextInt();
        int answer=list.get(Math.min(listIdx,list.size()-1))[idx-1];
        output.append(answer).append('\n');
      }
      System.out.print(output);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1602 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var list : Sequence(Sequence(int)) ; list := Sequence{} ;
    var change : boolean ;
  while true do ((     change := false ; 
     list := list->including(A) ; 
    var stat : Sequence(int) ; stat := Integer.subrange(1,N + 1)->collect(0) ;
    for (a : A) do ( (     stat[a+1] := stat[a+1] + 1 )  ) ; 
    var newA : Sequence(int) ; newA := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     var a : int ; a := A[n+1] ;
     var na : int ; na := stat[a+1] ;
     newA[n+1] := na ; 
     if (na /= a) then (     change := true ) else skip )  ;     n := n + 1 ) ; 
    A := newA ; 
 ) ;
    if (change) then skip else break) ; 
    var output : String ; output := StringLib.newString() ;
    var Q : int ; Q := in.getCurrent()->toInteger() ;
        var q : int ; q := 0 ; while q < Q do ( (     var idx : int ; idx := in.getCurrent()->toInteger() ;
     var listIdx : int ; listIdx := in.getCurrent()->toInteger() ;
     var answer : int ; answer := list->at(Set{listIdx, list->size() - 1}->min()+1)[idx - 1+1] ;
     output := output + StringLib.newString(answer) + StringLib.newString('
') )  ;     q := q + 1 ) ; 
    OclFile["System.out"].print(output) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int find(int a[],int b[],int k,int n1,int n2){
    LinkedHashSet<Integer>s=new LinkedHashSet<>();
    for(int i=0 ; i<n2 ; i++)s.add(b[i]);
    int missing=0 ;
    for(int i=0 ; i<n1 ; i++){
      if(! s.contains(a[i]))missing++;
      if(missing==k)return a[i];
    }
    return-1 ;
  }
  public static void main(String[] args){
    int a[]={
      0,2,4,6,8,10,12,14,15 };
      int b[]={
        4,10,6,8,12 };
        int n1=a.length ;
        int n2=b.length ;
        int k=3 ;
        System.out.println(find(a,b,k,n1,n2));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation find( a : Sequence(int), b : Sequence(int), k : int, n1 : int, n2 : int) : int
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
         var i : int ; i := 0 ; while i < n2 do (     s := s->including(b[i+1]) ;  ;     i := i + 1 ) ; 
    var missing : int ; missing := 0 ;
        var i : int ; i := 0 ; while i < n1 do ( (     if (not(s->includes(a[i+1]))) then     missing := missing + 1 ; else skip ; 
     if (missing = k) then     return a[i+1] else skip )  ;     i := i + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{0,2,4,6,8,10,12,14,15} ;
     var b : Sequence(int) ; b := Sequence{4,10,6,8,12} ;
    var n1 : int ; n1 := a->size() ;
    var n2 : int ; n2 := b->size() ;
    var k : int ; k := 3 ;
    OclFile["System.out"].println(find(a, b, k, n1, n2)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int[] s=new int[4];
    int[] t=new int[2];
    t[0]=sc.nextInt();
    s[0]=sc.nextInt();
    s[3]=sc.nextInt();
    s[1]=sc.nextInt();
    s[2]=sc.nextInt();
    t[1]=sc.nextInt();
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      int qt=sc.nextInt();
      int qf=sc.nextInt();
      for(int is=0 ; is<4 ; is++){
        if(s[is]==qt){
          if(s[(is+1)% 4]==qf){
            System.out.println(t[1]);
          }
          else if(s[(is+3)% 4]==qf){
            System.out.println(t[0]);
          }
          else if(t[0]==qf){
            System.out.println(s[(is+1)% 4]);
          }
          else {
            System.out.println(s[(is+3)% 4]);
          }
        }
      }
      for(int is=0 ; is<4 ; is++){
        if(s[is]==qf){
          if(t[0]==qt){
            System.out.println(s[(is+3)% 4]);
          }
          else if(t[1]==qt){
            System.out.println(s[(is+1)% 4]);
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(int) ; s := Integer.subrange(1,4)->collect(0) ;
    var t : Sequence(int) ; t := Integer.subrange(1,2)->collect(0) ;
    t[0+1] := sc.getCurrent()->toInteger() ; 
    s[0+1] := sc.getCurrent()->toInteger() ; 
    s[3+1] := sc.getCurrent()->toInteger() ; 
    s[1+1] := sc.getCurrent()->toInteger() ; 
    s[2+1] := sc.getCurrent()->toInteger() ; 
    t[1+1] := sc.getCurrent()->toInteger() ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var qt : int ; qt := sc.getCurrent()->toInteger() ;
     var qf : int ; qf := sc.getCurrent()->toInteger() ;
         var is : int ; is := 0 ; while is < 4 do ( (     if (s[is+1] = qt) then (     if (s[(is + 1) mod 4+1] = qf) then (     OclFile["System.out"].println(t[1+1]) ) else     if (s[(is + 3) mod 4+1] = qf) then (     OclFile["System.out"].println(t[0+1]) ) else     if (t[0+1] = qf) then (     OclFile["System.out"].println(s[(is + 1) mod 4+1]) ) else (     OclFile["System.out"].println(s[(is + 3) mod 4+1]) ) ;  ;  ) else skip )  ;     is := is + 1 ) ; 
         var is : int ; is := 0 ; while is < 4 do ( (     if (s[is+1] = qf) then (     if (t[0+1] = qt) then (     OclFile["System.out"].println(s[(is + 3) mod 4+1]) ) else     if (t[1+1] = qt) then (     OclFile["System.out"].println(s[(is + 1) mod 4+1]) ) else skip ; ) else skip )  ;     is := is + 1 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Random ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int[] d=new int[6];
    Dice dice=new Dice();
    for(int i=0 ; i<6 ; i++){
      d[i]=scanner.nextInt();
      dice.num[i]=d[i];
    }
    int q=scanner.nextInt();
    for(int i=0 ; i<q ; i++){
      int head=scanner.nextInt();
      int flont=scanner.nextInt();
      dice.Roll(head,flont);
      System.out.println(dice.num[2]);
    }
    scanner.close();
  }
}
class Dice {
  Random rand=new Random();
  int num[];
  Dice(){
    num=new int[6];
  }
  int box=0 ;
  public void Roll(int head,int flont){
    while(true){
      if((head==num[0])&&(flont==num[1])){
        break ;
      }
      int random=rand.nextInt(4);
      switch(random){
        case 0 : box=num[0];
        num[0]=num[4];
        num[4]=num[5];
        num[5]=num[1];
        num[1]=box ;
        break ;
        case 1 : box=num[0];
        num[0]=num[1];
        num[1]=num[5];
        num[5]=num[4];
        num[4]=box ;
        break ;
        case 2 : box=num[0];
        num[0]=num[2];
        num[2]=num[5];
        num[5]=num[3];
        num[3]=box ;
        break ;
        case 3 : box=num[0];
        num[0]=num[3];
        num[3]=num[5];
        num[5]=num[2];
        num[2]=box ;
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : Sequence(int) ; d := Integer.subrange(1,6)->collect(0) ;
    var dice : Dice ; dice := Dice.newDice() ;
        var i : int ; i := 0 ; while i < 6 do ( (     d[i+1] := scanner.getCurrent()->toInteger() ; 
     dice.num[i+1] := d[i+1] )  ;     i := i + 1 ) ; 
    var q : int ; q := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var head : int ; head := scanner.getCurrent()->toInteger() ;
     var flont : int ; flont := scanner.getCurrent()->toInteger() ;
     dice.Roll(head, flont) ; 
     OclFile["System.out"].println(dice.num[2+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
class Dice {
   attribute rand : OclRandom := OclRandom.newOclRandom();
   attribute num : Sequence(int);
   static operation newDice() : Dice
  pre: true
  post: true
  activity:
  ( var self : Dice ;
    self := createDice();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     num := Integer.subrange(1,6)->collect(0) );
   attribute box : int := 0;
   operation Roll( head : int, flont : int) : void
  pre: true
  post: true
  activity: (     while (true) do (     if ((head = num[0+1]) & (flont = num[1+1])) then (     break ) else skip ; 
     var random : int ; random := rand.nextInt(4) ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (random) ; 
       if _switchval = 0 then
     box := num[0+1] ; 
    num[0+1] := num[4+1] ; 
    num[4+1] := num[5+1] ; 
    num[5+1] := num[1+1] ; 
    num[1+1] := box ; 
    break 
   else skip ;
       if _switchval = 1 then
     box := num[0+1] ; 
    num[0+1] := num[1+1] ; 
    num[1+1] := num[5+1] ; 
    num[5+1] := num[4+1] ; 
    num[4+1] := box ; 
    break 
   else skip ;
       if _switchval = 2 then
     box := num[0+1] ; 
    num[0+1] := num[2+1] ; 
    num[2+1] := num[5+1] ; 
    num[5+1] := num[3+1] ; 
    num[3+1] := box ; 
    break 
   else skip ;
       if _switchval = 3 then
     box := num[0+1] ; 
    num[0+1] := num[3+1] ; 
    num[3+1] := num[5+1] ; 
    num[5+1] := num[2+1] ; 
    num[2+1] := box ; 
    break 
   else skip ;
 )
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String[] line=scanner.nextLine().split(" ");
    int a1=Integer.parseInt(line[0]);
    int a2=Integer.parseInt(line[1]);
    int a3=Integer.parseInt(line[2]);
    int a4=Integer.parseInt(line[3]);
    int a5=Integer.parseInt(line[4]);
    int a6=Integer.parseInt(line[5]);
    int b=Integer.parseInt(scanner.nextLine());
    for(int i=0 ; i<b ; i++){
      int c=scanner.nextInt();
      int d=scanner.nextInt();
      int result=0 ;
      if(c==a1 || c==a6)if(d==a2)result=3 ;
      else if(d==a3)result=5 ;
      else if(d==a4)result=2 ;
      else result=4 ;
      else if(c==a2 || c==a5)if(d==a1)result=4 ;
      else if(d==a3)result=1 ;
      else if(d==a4)result=6 ;
      else result=3 ;
      else {
        if(d==a1)result=2 ;
        else if(d==a2)result=6 ;
        else if(d==a5)result=1 ;
        else result=5 ;
      }
      if(c==a4 || c==a5 || c==a6)result=7-result ;
      System.out.println(line[result-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : Sequence(String) ; line := scanner.nextLine()->split(" ") ;
    var a1 : int ; a1 := (line[0+1])->toInteger() ;
    var a2 : int ; a2 := (line[1+1])->toInteger() ;
    var a3 : int ; a3 := (line[2+1])->toInteger() ;
    var a4 : int ; a4 := (line[3+1])->toInteger() ;
    var a5 : int ; a5 := (line[4+1])->toInteger() ;
    var a6 : int ; a6 := (line[5+1])->toInteger() ;
    var b : int ; b := (scanner.nextLine())->toInteger() ;
        var i : int ; i := 0 ; while i < b do ( (     var c : int ; c := scanner.getCurrent()->toInteger() ;
     var d : int ; d := scanner.getCurrent()->toInteger() ;
    var result : int ; result := 0 ;
    if (c = a1 or c = a6) then     if (d = a2) then     result := 3 ; else     if (d = a3) then     result := 5 else     if (d = a4) then     result := 2 else     result := 4 ; ;  ;  else     if (c = a2 or c = a5) then     if (d = a1) then     result := 4 ; else     if (d = a3) then     result := 1 else     if (d = a4) then     result := 6 else     result := 3 ; ;  ;  else (     if (d = a1) then     result := 2 ; else     if (d = a2) then     result := 6 else     if (d = a5) then     result := 1 else     result := 5 ; ;  ;  ) ;  ;  
    if (c = a4 or c = a5 or c = a6) then     result := 7 - result ; else skip ; 
    OclFile["System.out"].println(line[result - 1+1]) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
class Main {
  static int N,M ;
  static ArrayList<ArrayList<Integer>>s=new ArrayList<>();
  static ArrayList<Integer>p=new ArrayList<>();
  static int[] a ;
  static int ans=0 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    M=sc.nextInt();
    for(int i=0 ; i<M ; i++){
      int k=sc.nextInt();
      ArrayList<Integer>si=new ArrayList<>();
      for(int j=0 ; j<k ; j++){
        si.add(sc.nextInt());
      }
      s.add(si);
    }
    for(int i=0 ; i<M ; i++){
      p.add(sc.nextInt());
    }
    sc.close();
    a=new int[N];
    dfs(0);
    System.out.println(ans);
  }
  public static void dfs(int pos){
    if(pos==N){
      func();
    }
    else {
      a[pos]=0 ;
      dfs(pos+1);
      a[pos]=1 ;
      dfs(pos+1);
    }
  }
  public static void func(){
    int count=0 ;
    for(int i=0 ; i<s.size(); i++){
      int cnt1=0 ;
      for(Integer si : s.get(i)){
        if(a[si-1]==1){
          cnt1++;
        }
      }
      if(cnt1 % 2==p.get(i)){
        count++;
      }
    }
    if(count==M){
      ans++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute s : Sequence(Sequence(int)) := Sequence{};
  static   attribute p : Sequence(int) := Sequence{};
  static   attribute a : Sequence(int);
  static   attribute ans : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
    M := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < M do ( (     var k : int ; k := sc.getCurrent()->toInteger() ;
     var si : Sequence(int) ; si := Sequence{} ;
         var j : int ; j := 0 ; while j < k do ( (     si := si->including(sc.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
     s := s->including(si) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     p := p->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    skip ; 
    a := Integer.subrange(1,N)->collect(0) ; 
    execute dfs(0) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation dfs( pos : int) : void
  pre: true
  post: true
  activity: (     if (pos = N) then (     execute func() ) else (     a[pos+1] := 0 ; 
     execute dfs(pos + 1) ; 
     a[pos+1] := 1 ; 
     execute dfs(pos + 1) ) );
  static   operation func() : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     var cnt1 : int ; cnt1 := 0 ;
     for (si : s->at(i+1)) do ( (     if (a[si - 1+1] = 1) then (     cnt1 := cnt1 + 1 ) else skip )  ) ; 
     if (cnt1 mod 2 = p->at(i+1)) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (count = M) then (     ans := ans + 1 ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static void pattern(int n){
    int p,k=1 ;
    for(int i=1 ; i<=n ; i++){
      p=k ;
      for(int j=1 ; j<=i ; j++){
        System.out.print(p);
        System.out.print(" ");
        p=p-(n+j-i);
      }
      System.out.println();
      k=k+1+n-i ;
    }
  }
  public static void main(String[] args){
    int n=5 ;
    pattern(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation pattern( n : int) : void
  pre: true
  post: true
  activity: (     var p : int ;
    var k : int ; k := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (     p := k ; 
         var j : int ; j := 1 ; while j <= i do ( (     OclFile["System.out"].print(p) ; 
     OclFile["System.out"].print(" ") ; 
     p := p - (n + j - i) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() ; 
     k := k + 1 + n - i )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute pattern(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] z){
    String r ;
    int n,v,i ;
    for(Scanner s=new Scanner(System.in); s.hasNext(); System.out.println(r)){
      char[] c=s.next().toCharArray(),k={
        46,63,33,32 };
        r="" ;
        if((n=c.length)% 2>0)r="NA" ;
        else for(i=0 ;
        i<n ;
        r+=v<26 ?(char)(97+v): k[v-26])if((v=c[i++]*5+c[i]-294)<0 || 29<v || c[i]<49 || c[i++]>53){
          r="NA" ;
          break ;
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : String ;
     var n : int ;
    var v : int ;
    var i : int ;
         var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ; while s.hasNext() do ( (     var c : Sequence(String) ; c := s.getCurrent()->characters() ;
    var k : Sequence(String) ; k := Sequence{46,63,33,32} ;
     r := "" ; 
     if ((n) mod 2 > 0) then     r := "NA" ; else         i := 0 ; while i < n do (     if ((v) < 0 or 29 < v or c[i+1] < 49 or c[i+1] > 53) then (     r := "NA" ; 
     break ) else skip ;  ;     r := r+(if v < 26 then (97 + v)->oclAsType(String) else k[(v)->char2byte() - 26+1] endif) ) ; )  ;     OclFile["System.out"].println(r) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    String s ;
    char[] c,r ;
    int i ;
    for(; sc.hasNext(); ){
      s=sc.next();
      if(s.length()% 2==1)out.println("NA");
      else {
        c=new char[s.length()];
        r=new char[s.length()/2];
        for(i=0 ; i<s.length(); i++)c[i]=s.charAt(i);
        for(i=0 ; i<s.length(); i+=2){
          if(c[i]>'6' || c[i]<'1' || c[i+1]>'5' || c[i+1]<'1')break ;
          r[i/2]=(char)('a'+(c[i]-'1')*5+(c[i+1]-'1'));
          if(r[i/2]==(char)('a'+26))r[i/2]='.' ;
          else if(r[i/2]==(char)('a'+27))r[i/2]='?' ;
          else if(r[i/2]==(char)('a'+28))r[i/2]='!' ;
          else if(r[i/2]==(char)('a'+29))r[i/2]=' ' ;
        }
        if(i<s.length())out.println("NA");
        else {
          for(i=0 ; i<s.length()/2 ; i++)out.print(r[i]);
          out.println();
        }
      }
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var s : String ;
    var c : Sequence(String) ;
    var r : Sequence(String) ;
    var i : int ;
      while sc.hasNext() do ( (     s := sc.next() ; 
     if (s->size() mod 2 = 1) then     out.println("NA") ; else (     c := Integer.subrange(1,s->size())->collect(0) ; 
     r := Integer.subrange(1,s->size() / 2)->collect(0) ; 
        i := 0 ; while i < s->size() do (     c[i+1] := s->at(i+1) ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < s->size() do ( (     if (c[i+1] > '6' or c[i+1] < '1' or c[i + 1+1] > '5' or c[i + 1+1] < '1') then     break else skip ; 
     r[i / 2+1] := ('a' + (c[i+1] - ('1')->char2byte()) * 5 + (c[i + 1+1] - ('1')->char2byte()))->oclAsType(String) ; 
     if (r[i / 2+1] = ('a' + 26)->oclAsType(String)) then     r[i / 2+1] := '.' ; else     if (r[i / 2+1] = ('a' + 27)->oclAsType(String)) then     r[i / 2+1] := '?' else     if (r[i / 2+1] = ('a' + 28)->oclAsType(String)) then     r[i / 2+1] := '!' else     if (r[i / 2+1] = ('a' + 29)->oclAsType(String)) then     r[i / 2+1] := ' ' ; else skip ; ;  ;  )  ;     i := i+(2) ) ; 
    if (i < s->size()) then     out.println("NA") else (         i := 0 ; while i < s->size() / 2 do (     out.print(r[i+1]) ;  ;     i := i + 1 ) ; 
     out.println() ) ;  
 ) )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    String[][] encode=new String[][] {
      {
        "11","a" },{
          "12","b" },{
            "13","c" },{
              "14","d" },{
                "15","e" },{
                  "21","f" },{
                    "22","g" },{
                      "23","h" },{
                        "24","i" },{
                          "25","j" },{
                            "31","k" },{
                              "32","l" },{
                                "33","m" },{
                                  "34","n" },{
                                    "35","o" },{
                                      "41","p" },{
                                        "42","q" },{
                                          "43","r" },{
                                            "44","s" },{
                                              "45","t" },{
                                                "51","u" },{
                                                  "52","v" },{
                                                    "53","w" },{
                                                      "54","x" },{
                                                        "55","y" },{
                                                          "61","z" },{
                                                            "62","." },{
                                                              "63","?" },{
                                                                "64","!" },{
                                                                  "65"," " }
                                                                };
                                                                Scanner sc=new Scanner(System.in);
                                                                while(sc.hasNext()){
                                                                  String in=sc.nextLine();
                                                                  boolean na ;
                                                                  if(in.length()% 2==1){
                                                                    System.out.println("NA");
                                                                  }
                                                                  else {
                                                                    na=true ;
                                                                    int index=0,i=0 ;
                                                                    StringBuilder sb=new StringBuilder();
                                                                    while(index<in.length()){
                                                                      String enc=in.substring(index,index+2).replace(encode[i][0],encode[i][1]);
                                                                      if(enc.length()==1){
                                                                        i=0 ;
                                                                        sb.append(enc);
                                                                        index+=2 ;
                                                                      }
                                                                      else {
                                                                        if(i+1<encode.length){
                                                                          i++;
                                                                        }
                                                                        else {
                                                                          System.out.println("NA");
                                                                          na=false ;
                                                                          break ;
                                                                        }
                                                                      }
                                                                    }
                                                                    if(na){
                                                                      System.out.println(sb.toString());
                                                                    }
                                                                    else {
                                                                      na=true ;
                                                                    }
                                                                  }
                                                                }
                                                              }
                                                            }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var encode : Sequence(Sequence(String)) ; encode := Sequence{Sequence{"11","a"},Sequence{"12","b"},Sequence{"13","c"},Sequence{"14","d"},Sequence{"15","e"},Sequence{"21","f"},Sequence{"22","g"},Sequence{"23","h"},Sequence{"24","i"},Sequence{"25","j"},Sequence{"31","k"},Sequence{"32","l"},Sequence{"33","m"},Sequence{"34","n"},Sequence{"35","o"},Sequence{"41","p"},Sequence{"42","q"},Sequence{"43","r"},Sequence{"44","s"},Sequence{"45","t"},Sequence{"51","u"},Sequence{"52","v"},Sequence{"53","w"},Sequence{"54","x"},Sequence{"55","y"},Sequence{"61","z"},Sequence{"62","."},Sequence{"63","?"},Sequence{"64","!"},Sequence{"65"," "}} ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var in : String ; in := sc.nextLine() ;
     var na : boolean ;
     if (in->size() mod 2 = 1) then (     OclFile["System.out"].println("NA") ) else (     na := true ; 
     var index : int ; index := 0 ;
    var i : int ; i := 0 ;
    var sb : String ; sb := StringLib.newString() ;
    while (index < in->size()) do (     var enc : String ; enc := in.subrange(index+1,index + 2).replace(encode[i+1][0+1], encode[i+1][1+1]) ;
     if (enc->size() = 1) then (     i := 0 ; 
     sb := sb + StringLib.newString(enc) ; 
     index := index+(2) ) else (     if (i + 1 < encode->size()) then (     i := i + 1 ) else (     OclFile["System.out"].println("NA") ; 
     na := false ; 
     break ) ) ) ; 
    if (na) then (     OclFile["System.out"].println(sb+"") ) else (     na := true ) ;  
 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  void run(){
    sc=new Scanner(System.in);
    char[][] table={
      {
        'a','f','k','p','u','z' },{
          'b','g','l','q','v','.' },{
            'c','h','m','r','w','?' },{
              'd','i','n','s','x','!' },{
                'e','j','o','t','y',' ' },};
                for(; sc.hasNext(); ){
                  String s=sc.next();
                  if(s.length()% 2==1){
                    println("NA");
                    continue ;
                  }
                  String ans="" ;
                  for(int i=0 ; i<s.length()/2 ; i++){
                    int m=s.charAt(i*2)-'0' ;
                    int n=s.charAt(i*2+1)-'0' ;
                    m--;
                    n--;
                    if(m<0 || m>=6 || m<0 || n>=5 || ! Character.isDigit(s.charAt(i*2))|| ! Character.isDigit(s.charAt(i*2+1))){
                      ans="NA" ;
                      break ;
                    }
                    ans+=table[n][m];
                  }
                  println(ans);
                }
                sc.close();
              }
              void print(String s){
                System.out.print(s);
              }
              void println(String s){
                System.out.println(s);
              }
              public static void main(String[] args){
                new Main().run();
              }
            }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var table : Sequence(Sequence(String)) ; table := Sequence{Sequence{'a','f','k','p','u','z'},Sequence{'b','g','l','q','v','.'},Sequence{'c','h','m','r','w','?'},Sequence{'d','i','n','s','x','!'},Sequence{'e','j','o','t','y',' '},} ;
       while sc.hasNext() do ( (     var s : String ; s := sc.getCurrent() ;
     if (s->size() mod 2 = 1) then (     execute println("NA") ; 
     continue ) else skip ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < s->size() / 2 do ( (     var m : int ; m := s->at(i * 2+1) - ('0')->char2byte() ;
     var n : int ; n := s->at(i * 2 + 1+1) - ('0')->char2byte() ;
    m := m - 1 ; 
    n := n - 1 ; 
    if (m < 0 or m >= 6 or m < 0 or n >= 5 or not((s->at(i * 2+1) + "")->isMatch("[0-9]")) or not((s->at(i * 2 + 1+1) + "")->isMatch("[0-9]"))) then (     ans := "NA" ; 
     break ) else skip ; 
    ans := ans+(table[n+1][m+1]) ; 
 )  ;     i := i + 1 ) ; 
    execute println(ans) ; 
 )  ) ; 
     skip );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public char[][] code={
    {
      'a','f','k','p','u','z' },{
        'b','g','l','q','v','.' },{
          'c','h','m','r','w','?' },{
            'd','i','n','s','x','!' },{
              'e','j','o','t','y',' ' }
            };
            public boolean judge(String str){
              if(str.length()% 2!=0){
                return false ;
              }
              for(int i=0 ; i<str.length(); i+=2){
                if(str.charAt(i)-'0'>6 || str.charAt(i)-'0'<1){
                  return false ;
                }
              }
              for(int i=1 ; i<str.length(); i+=2){
                if(str.charAt(i)-'0'>5 || str.charAt(i)-'0'<1){
                  return false ;
                }
              }
              return true ;
            }
            public void solve()throws IOException {
              while(stdIn.hasNext()){
                String str=stdIn.next();
                if(! judge(str)){
                  writer.println("NA");
                }
                else {
                  for(int i=0 ; i<str.length(); i+=2){
                    int x=str.charAt(i)-'1' ;
                    int y=str.charAt(i+1)-'1' ;
                    writer.print(code[y][x]);
                  }
                  writer.println();
                }
              }
              writer.flush();
            }
            public static void main(String args[])throws IOException {
              new Main().run();
            }
            Scanner stdIn ;
            PrintWriter writer ;
            public void run()throws IOException {
              stdIn=null ;
              try {
                stdIn=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
                writer=new PrintWriter(System.out);
                solve();
                stdIn.close();
                writer.close();
              }
              catch(Exception e){
                e.printStackTrace();
                System.exit(1);
              }
            }
          }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute code : Sequence(Sequence(String)) := Sequence{Sequence{'a','f','k','p','u','z'},Sequence{'b','g','l','q','v','.'},Sequence{'c','h','m','r','w','?'},Sequence{'d','i','n','s','x','!'},Sequence{'e','j','o','t','y',' '}};
   operation judge( str : String) : boolean
  pre: true
  post: true
  activity: (     if (str->size() mod 2 /= 0) then (     return false ) else skip ; 
         var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) - ('0')->char2byte() > 6 or str->at(i+1) - ('0')->char2byte() < 1) then (     return false ) else skip )  ;     i := i+(2) ) ; 
         var i : int ; i := 1 ; while i < str->size() do ( (     if (str->at(i+1) - ('0')->char2byte() > 5 or str->at(i+1) - ('0')->char2byte() < 1) then (     return false ) else skip )  ;     i := i+(2) ) ; 
     return true );
   operation solve() : void
  pre: true
  post: true
  activity: (     while (stdIn.hasNext()) do (     var str : String ; str := stdIn.next() ;
     if (not(judge(str))) then (     writer.println("NA") ) else (         var i : int ; i := 0 ; while i < str->size() do ( (     var x : int ; x := str->at(i+1) - ('1')->char2byte() ;
     var y : int ; y := str->at(i + 1+1) - ('1')->char2byte() ;
     writer.print(code[y+1][x+1]) )  ;     i := i+(2) ) ; 
     writer.println() ) ) ; 
     writer.flush() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute stdIn : OclFile;
   attribute writer : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     stdIn := null ; 
     try (     stdIn := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
     writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long s=sc.nextLong();
    long mod=s %((long)Math.pow(10,9));
    long x3=(long)Math.pow(10,9)-mod ;
    if(mod==0)x3=0 ;
    long y3=(s+x3)/(long)(Math.pow(10,9));
    long x1=0 ;
    long y1=0 ;
    long x2=(long)Math.pow(10,9);
    long y2=1 ;
    System.out.println(x1+" "+y1+" "+x2+" "+y2+" "+x3+" "+y3);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : long ; s := sc.getCurrent()->toLong() ;
    var mod : long ; mod := s mod (10->pow(9)->oclAsType(long)) ;
    var x3 : long ; x3 := 10->pow(9)->oclAsType(long) - mod ;
    if (mod = 0) then     x3 := 0 ; else skip ; 
    var y3 : long ; y3 := (s + x3) / (10->pow(9))->oclAsType(long) ;
    var x1 : long ; x1 := 0 ;
    var y1 : long ; y1 := 0 ;
    var x2 : long ; x2 := 10->pow(9)->oclAsType(long) ;
    var y2 : long ; y2 := 1 ;
    OclFile["System.out"].println(x1 + " " + y1 + " " + x2 + " " + y2 + " " + x3 + " " + y3) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    long S=scan.nextLong();
    long x=1000000000 ;
    long y=1 ;
    long m=S/x ;
    if(S % x!=0){
      m+=1 ;
    }
    long l=m*x-S ;
    System.out.println("0 0 "+x+" "+y+" "+l+" "+m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var S : long ; S := scan.getCurrent()->toLong() ;
    var x : long ; x := 1000000000 ;
    var y : long ; y := 1 ;
    var m : long ; m := S / x ;
    if (S mod x /= 0) then (     m := m+(1) ) else skip ; 
    var l : long ; l := m * x - S ;
    OclFile["System.out"].println("0 0 " + x + " " + y + " " + l + " " + m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long S=sc.nextLong();
    if(S==1000000000000000000L){
      System.out.println("0 0 1000000000 0 0 1000000000");
      return ;
    }
    if(S<=1000000000){
      System.out.println("0 0 1 0 0 "+String.valueOf(S));
    }
    else {
      int x1=0 ;
      int y1=0 ;
      int x2=1 ;
      int y2=1000000000 ;
      long a=S/1000000000L ;
      long b=S % 1000000000L ;
      int x3=(int)a+1 ;
      int y3=(int)(1000000000-b);
      System.out.println(x1+" "+y1+" "+x2+" "+y2+" "+x3+" "+y3);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : long ; S := sc.getCurrent()->toLong() ;
     if (S = 1000000000000000000L) then (     OclFile["System.out"].println("0 0 1000000000 0 0 1000000000") ; 
     return ) else skip ; 
     if (S <= 1000000000) then (     OclFile["System.out"].println("0 0 1 0 0 " + ((S) + "")) ) else (     var x1 : int ; x1 := 0 ;
     var y1 : int ; y1 := 0 ;
    var x2 : int ; x2 := 1 ;
    var y2 : int ; y2 := 1000000000 ;
    var a : long ; a := S / 1000000000L ;
    var b : long ; b := S mod 1000000000L ;
    var x3 : int ; x3 := a->oclAsType(int) + 1 ;
    var y3 : int ; y3 := (1000000000 - b)->oclAsType(int) ;
    OclFile["System.out"].println(x1 + " " + y1 + " " + x2 + " " + y2 + " " + x3 + " " + y3) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] i){
    long s=Long.parseLong(new Scanner(System.in).next());
    int a=1000000000 ;
    System.out.println("0 0 "+a+" 1 "+(a-s % a)% a+" "+((s-1)/a+1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( i : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : long ; s := (OclFile.newOclFile_Read(OclFile["System.in"]).next())->toLong() ;
     var a : int ; a := 1000000000 ;
     OclFile["System.out"].println("0 0 " + a + " 1 " + (a - s mod a) mod a + " " + ((s - 1) / a + 1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int res=a ;
    while(a>=b){
      int j=a/b ;
      res+=j ;
      a=j+(a % b);
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var res : int ; res := a ;
    while (a >= b) do (     var j : int ; j := a / b ;
     res := res+(j) ; 
     a := j + (a mod b) ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long s=sc.nextLong();
    long x1=0 ;
    long y1=0 ;
    long x2=1000000000 ;
    long y2=1 ;
    long start=s/x2 ;
    for(long i=start ; i<=x2 ; i++){
      long x3=i*x2-s ;
      if(x3>=0 && x3<=x2){
        System.out.print(x1+" "+y1+" "+x2+" "+y2+" "+x3+" "+i);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : long ; s := sc.getCurrent()->toLong() ;
    var x1 : long ; x1 := 0 ;
    var y1 : long ; y1 := 0 ;
    var x2 : long ; x2 := 1000000000 ;
    var y2 : long ; y2 := 1 ;
    var start : long ; start := s / x2 ;
        var i : long ; i := start ; while i <= x2 do ( (     var x3 : long ; x3 := i * x2 - s ;
     if (x3 >= 0 & x3 <= x2) then (     OclFile["System.out"].print(x1 + " " + y1 + " " + x2 + " " + y2 + " " + x3 + " " + i) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import com.sun.org.apache.bcel.internal.generic.AALOAD ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.math.BigInteger ;
import java.util.*;
import java.util.stream.IntStream ;
import javafx.util.Pair ;
public class Main {
  static void sort(double a[]){
    Random ran=new Random();
    for(int i=0 ; i<a.length ; i++){
      int r=ran.nextInt(a.length);
      double temp=a[r];
      a[r]=a[i];
      a[i]=temp ;
    }
    Arrays.sort(a);
  }
  public static void main(String[] args)throws IOException {
    Scanner input=new Scanner(System.in);
    long extraA=0,extraB=0,extraC=0,NeedA=0,NeedB=0,NeedC=0 ;
    long a=input.nextLong();
    long b=input.nextLong();
    long c=input.nextLong();
    long x=input.nextLong();
    long y=input.nextLong();
    long z=input.nextLong();
    if((a+b+c)<(x+y+z)){
      System.out.println("NO");
    }
    else {
      if(a>x){
        extraA=a-x ;
        extraA/=2 ;
      }
      if(b>y){
        extraB=b-y ;
        extraB/=2 ;
      }
      if(c>z){
        extraC=c-z ;
        extraC/=2 ;
      }
      if(a<x){
        NeedA=x-a ;
      }
      if(b<y){
        NeedB=y-b ;
      }
      if(c<z){
        NeedC=z-c ;
      }
      if((NeedA+NeedB+NeedC)<=(extraA+extraB+extraC)){
        System.out.println("YES");
      }
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation sort( a : Sequence(double)) : void
  pre: true
  post: true
  activity: (     var ran : OclRandom ; ran := OclRandom.newOclRandom() ;
         var i : int ; i := 0 ; while i < a->size() do ( (     var r : int ; r := ran.nextInt(a->size()) ;
     var temp : double ; temp := a[r+1] ;
     a[r+1] := a[i+1] ; 
     a[i+1] := temp )  ;     i := i + 1 ) ; 
     a := a->sort() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var extraA : long ; extraA := 0 ;
    var extraB : long ; extraB := 0 ;
    var extraC : long ; extraC := 0 ;
    var NeedA : long ; NeedA := 0 ;
    var NeedB : long ; NeedB := 0 ;
    var NeedC : long ; NeedC := 0 ;
    var a : long ; a := input.getCurrent()->toLong() ;
    var b : long ; b := input.getCurrent()->toLong() ;
    var c : long ; c := input.getCurrent()->toLong() ;
    var x : long ; x := input.getCurrent()->toLong() ;
    var y : long ; y := input.getCurrent()->toLong() ;
    var z : long ; z := input.getCurrent()->toLong() ;
    if ((a + b + c) < (x + y + z)) then (     OclFile["System.out"].println("NO") ) else (     if (a > x) then (     extraA := a - x ; 
     extraA := extraA/(2) ) else skip ; 
     if (b > y) then (     extraB := b - y ; 
     extraB := extraB/(2) ) else skip ; 
    if (c > z) then (     extraC := c - z ; 
     extraC := extraC/(2) ) else skip ; 
    if (a < x) then (     NeedA := x - a ) else skip ; 
    if (b < y) then (     NeedB := y - b ) else skip ; 
    if (c < z) then (     NeedC := z - c ) else skip ; 
    if ((NeedA + NeedB + NeedC) <= (extraA + extraB + extraC)) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static void maxPerimeter(int arr[],int n){
    arr=arrRevSort(arr);
    int maxi=0 ;
    for(int i=0 ; i<n-2 ; i++){
      if(arr[i]<arr[i+1]+arr[i+2]){
        maxi=Math.max(maxi,arr[i]+arr[i+1]+arr[i+2]);
        break ;
      }
    }
    if(maxi>0){
      System.out.println("Maximum Perimeter is: "+maxi);
    }
    else {
      System.out.println("Triangle formation is not possible.");
    }
  }
  static int[] arrRevSort(int[] arr){
    Arrays.sort(arr,0,arr.length);
    int j=arr.length-1 ;
    for(int i=0 ; i<arr.length/2 ; i++,j--){
      int temp=arr[i];
      arr[i]=arr[j];
      arr[j]=temp ;
    }
    return arr ;
  }
  public static void main(String[] args){
    int arr1[]={
      6,1,6,5,8,4 };
      maxPerimeter(arr1,6);
      int arr2[]={
        2,20,7,55,1,33,12,4 };
        maxPerimeter(arr2,8);
        int arr3[]={
          33,6,20,1,8,12,5,55,4,9 };
          maxPerimeter(arr3,10);
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxPerimeter( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     arr := arrRevSort(arr) ; 
     var maxi : int ; maxi := 0 ;
         var i : int ; i := 0 ; while i < n - 2 do ( (     if (arr[i+1] < arr[i + 1+1] + arr[i + 2+1]) then (     maxi := Set{maxi, arr[i+1] + arr[i + 1+1] + arr[i + 2+1]}->max() ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (maxi > 0) then (     OclFile["System.out"].println("Maximum Perimeter is: " + maxi) ) else (     OclFile["System.out"].println("Triangle formation is not possible.") ) );
  static   operation arrRevSort( arr : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     arr := arr.subrange(1,0)^(arr.subrange(0+1,arr->size())->sort())^arr.subrange(arr->size()+1,arr.size) ; 
     var j : int ; j := arr->size() - 1 ;
         var i : int ; i := 0 ; while i < arr->size() / 2 do ( (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := arr[j+1] ; 
     arr[j+1] := temp )  ;     i := i + 1 ;     j := j - 1 ) ; 
     return arr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{6,1,6,5,8,4} ;
     execute maxPerimeter(arr1, 6) ; 
    var arr2 : Sequence(int) ; arr2 := Sequence{2,20,7,55,1,33,12,4} ;
    execute maxPerimeter(arr2, 8) ; 
    var arr3 : Sequence(int) ; arr3 := Sequence{33,6,20,1,8,12,5,55,4,9} ;
    execute maxPerimeter(arr3, 10) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int area_fun(int side){
    int area=side*side ;
    return area ;
  }
  public static void main(String arg[]){
    int side=4 ;
    int area=area_fun(side);
    System.out.println(area);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation area_fun( side : int) : int
  pre: true
  post: true
  activity: (     var area : int ; area := side * side ;
     return area );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var side : int ; side := 4 ;
     var area : int ; area := area_fun(side) ;
     OclFile["System.out"].println(area) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Criminals {
  public static void main(String[] arg){
    Scanner input=new Scanner(System.in);
    String gogol=input.nextLine();
    String pineapple=input.nextLine();
    int gLength=gogol.length();
    int aLength=pineapple.length();
    int count=0 ;
    if(aLength>gLength)System.out.println(count);
    else {
      int test=gLength-aLength+1 ;
      for(int i=0 ; i<test ; i++){
        if(pineapple.equals(gogol.substring(i,aLength+i))){
          count++;
          i+=aLength-1 ;
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Criminals {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var gogol : String ; gogol := input.nextLine() ;
    var pineapple : String ; pineapple := input.nextLine() ;
    var gLength : int ; gLength := gogol->size() ;
    var aLength : int ; aLength := pineapple->size() ;
    var count : int ; count := 0 ;
    if (aLength > gLength) then     OclFile["System.out"].println(count) else (     var test : int ; test := (gLength)->char2byte() - aLength + 1 ;
         var i : int ; i := 0 ; while i < test do ( (     if (pineapple = gogol.subrange(i+1,aLength + i)) then (     count := count + 1 ; 
     i := i+(aLength - 1) ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class warOfTheCooperations {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s1=sc.next();
    String s2=sc.next();
    if(s2.length()>s1.length()){
      System.out.println("0");
    }
    else {
      int count=0 ;
      int i=s1.indexOf(s2);
      if(i==-1){
        System.out.println("0");
      }
      else {
        int k=0 ;
        count++;
        while(true){
          k=s1.indexOf(s2,i+s2.length());
          if(k==-1){
            break ;
          }
          count++;
          i=k ;
        }
        System.out.println(count);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class warOfTheCooperations {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := sc.getCurrent() ;
     var s2 : String ; s2 := sc.getCurrent() ;
     if (s2->size() > s1->size()) then (     OclFile["System.out"].println("0") ) else (     var count : int ; count := 0 ;
     var i : int ; i := s1->indexOf(s2)-1 ;
     if (i = -1) then (     OclFile["System.out"].println("0") ) else (     var k : int ; k := 0 ;
     count := count + 1 ; 
     while (true) do (     k := s1.subrange(i + s2->size()+1)->indexOf(s2+"") + i + s2->size() - 1  ; 
     if (k = -1) then (     break ) else skip ; 
     count := count + 1 ; 
     i := k ) ; 
     OclFile["System.out"].println(count) ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
public class CF625B {
  public static void main(String[] args){
    FastReader input=new FastReader();
    PrintWriter pw=new PrintWriter(System.out);
    String s1=input.nextLine();
    String s2=input.nextLine();
    char[] arr=s1.toCharArray();
    char[] arr2=s2.toCharArray();
    int start=0 ;
    int ans=0 ;
    while(start<arr.length){
      boolean con=false ;
      int temp=start ;
      for(int i=0 ; i<arr2.length ; i++){
        if(temp<arr.length && arr2[i]==arr[temp]){
          temp++;
        }
        else {
          con=true ;
          break ;
        }
      }
      if(! con){
        ans++;
        start=temp ;
      }
      else {
        start++;
      }
    }
    pw.println(ans);
    pw.flush();
    pw.close();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF625B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastReader ; input := FastReader.newFastReader() ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s1 : String ; s1 := input.nextLine() ;
    var s2 : String ; s2 := input.nextLine() ;
    var arr : Sequence(String) ; arr := s1->characters() ;
    var arr2 : Sequence(String) ; arr2 := s2->characters() ;
    var start : int ; start := 0 ;
    var ans : int ; ans := 0 ;
    while (start < arr->size()) do (     var con : boolean ; con := false ;
     var temp : int ; temp := start ;
         var i : int ; i := 0 ; while i < arr2->size() do ( (     if (temp < arr->size() & arr2[i+1] = arr[temp+1]) then (     temp := temp + 1 ) else (     con := true ; 
     break ) )  ;     i := i + 1 ) ; 
     if (not(con)) then (     ans := ans + 1 ; 
     start := temp ) else (     start := start + 1 ) ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String s1=sc.nextLine(),s2=sc.nextLine();
    int replace=0 ;
    for(int i=0 ; i<=s1.length()-s2.length(); i++){
      boolean isMatched=true ;
      if(s1.charAt(i)==s2.charAt(0)){
        for(int j=1,k=i+1 ; j<s2.length(); j++,k++){
          if(s1.charAt(k)!=s2.charAt(j)){
            isMatched=false ;
            break ;
          }
        }
      }
      else isMatched=false ;
      if(isMatched){
        replace++;
        i=s2.length()+i-1 ;
      }
    }
    System.out.println(replace);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := sc.nextLine() ;
    var s2 : String ; s2 := sc.nextLine() ;
    var replace : int ; replace := 0 ;
        var i : int ; i := 0 ; while i <= s1->size() - s2->size() do ( (     var isMatched : boolean ; isMatched := true ;
     if (s1->at(i+1) = s2->at(0+1)) then (         var j : int ; j := 1 ;
    var k : int ; k := i + 1 ; while j < s2->size() do ( (     if (s1->at(k+1) /= s2->at(j+1)) then (     isMatched := false ; 
     break ) else skip )  ;     j := j + 1 ;     k := k + 1 ) ) else     isMatched := false ; ;  
     if (isMatched) then (     replace := replace + 1 ; 
     i := s2->size() + i - 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(replace) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  int n,m ;
  int[][] cost ;
  int[] p ;
  void solve(){
    Scanner sc=new Scanner(System.in);
    while(true){
      n=sc.nextInt();
      m=sc.nextInt();
      if(n==0 && m==0)break ;
      cost=new int[m][3];
      for(int i=0 ; i<m ; i++)for(int j=0 ; j<3 ; j++)cost[i][j]=sc.nextInt();
      init();
      Arrays.sort(cost,new Comparator<int[]>(){
        public int compare(int[] a,int[] b){
          return a[2]-b[2];
        }
      }
);
      int ans=0 ;
      for(int i=0 ; i<m ; i++){
        int a=cost[i][0],b=cost[i][1];
        a=root(a);
        b=root(b);
        if(a==b)continue ;
        merge(a,b);
        ans+=cost[i][2];
      }
      System.out.println(ans);
    }
  }
  void init(){
    p=new int[n];
    for(int i=0 ; i<n ; i++)p[i]=i ;
  }
  int root(int a){
    if(a==p[a])return a ;
    else return p[a]=root(p[a]);
  }
  void merge(int a,int b){
    a=root(a);
    b=root(b);
    p[a]=b ;
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute cost : Sequence(Sequence(int));
   attribute p : Sequence(int);
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     n := sc.getCurrent()->toInteger() ; 
     m := sc.getCurrent()->toInteger() ; 
    if (n = 0 & m = 0) then     break else skip ; 
    cost := Integer.subrange(1,m)->collect(Integer.subrange(1,3)->collect(0)) ; 
        var i : int ; i := 0 ; while i < m do (         var j : int ; j := 0 ; while j < 3 do (     cost[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    execute init() ; 
    cost := OclComparator.sortWith(cost, OclComparator<Sequence(int)>.newOclComparator()) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := cost[i+1][0+1] ;
    var b : int ; b := cost[i+1][1+1] ;
     a := root(a) ; 
    b := root(b) ; 
    if (a = b) then     continue else skip ; 
    execute merge(a, b) ; 
    ans := ans+(cost[i+1][2+1]) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
   operation init() : void
  pre: true
  post: true
  activity: (     p := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do (     p[i+1] := i ;  ;     i := i + 1 ) );
   operation root( a : int) : int
  pre: true
  post: true
  activity: (     if (a = p[a+1]) then     return a else     return p[a+1] );
   operation merge( a : int, b : int) : void
  pre: true
  post: true
  activity: (     a := root(a) ; 
     b := root(b) ; 
     p[a+1] := b );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int n,m ;
  static int[][] cost ;
  static int[] mincost ;
  static boolean[] used ;
  public static void main(String[] args){
    while(read()){
      solve();
    }
  }
  static boolean read(){
    n=sc.nextInt();
    m=sc.nextInt();
    if(n==0 && m==0)return false ;
    cost=new int[n][n];
    mincost=new int[n];
    used=new boolean[n];
    for(int[] formatting : cost)Arrays.fill(formatting,1<<29);
    Arrays.fill(mincost,1<<29);
    Arrays.fill(used,false);
    for(int i=0 ; i<m ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      cost[a][b]=c ;
      cost[b][a]=c ;
    }
    return true ;
  }
  static void solve(){
    mincost[0]=0 ;
    int res=0 ;
    while(true){
      int v=-1 ;
      for(int i=0 ; i<n ; i++){
        if(! used[i] &&(v==-1 || mincost[i]<mincost[v]))v=i ;
      }
      if(v==-1)break ;
      used[v]=true ;
      res+=mincost[v];
      for(int i=0 ; i<n ; i++){
        mincost[i]=Math.min(mincost[i],cost[v][i]);
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   attribute cost : Sequence(Sequence(int));
  static   attribute mincost : Sequence(int);
  static   attribute used : Sequence(boolean);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (read()) do (     execute solve() ) );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
     m := sc.getCurrent()->toInteger() ; 
    if (n = 0 & m = 0) then     return false else skip ; 
    cost := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
    mincost := Integer.subrange(1,n)->collect(0) ; 
    used := Integer.subrange(1,n)->collect(false) ; 
    for (formatting : cost) do (     formatting := formatting->collect((1*(2->pow(29)))->oclAsType(long)) ;  ) ; 
    mincost := mincost->collect((1*(2->pow(29)))->oclAsType(long)) ; 
    used := used->collect(false) ; 
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    cost[a+1][b+1] := c ; 
    cost[b+1][a+1] := c ; 
 )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     mincost[0+1] := 0 ; 
     var res : int ; res := 0 ;
     while (true) do (     var v : int ; v := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (not(used[i+1]) & (v = -1 or mincost[i+1] < mincost[v+1])) then     v := i ; else skip )  ;     i := i + 1 ) ; 
    if (v = -1) then     break else skip ; 
    used[v+1] := true ; 
    res := res+(mincost[v+1]) ; 
        var i : int ; i := 0 ; while i < n do ( (     mincost[i+1] := Set{mincost[i+1], cost[v+1][i+1]}->min() )  ;     i := i + 1 ) ; 
 ) ; 
     OclFile["System.out"].println(res) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static int getSum(int n){
    int sum=0 ;
    while(n!=0){
      sum=sum+n % 10 ;
      n=n/10 ;
    }
    return sum ;
  }
  static int largestDigitSumdivisior(int n){
    int res=0 ;
    for(int i=1 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        res=Math.max(res,getSum(i));
        res=Math.max(res,getSum(n/i));
      }
    }
    return res ;
  }
  public static void main(String args[]){
    int n=14 ;
    System.out.println(largestDigitSumdivisior(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n /= 0) do (     sum := sum + n mod 10 ; 
     n := n / 10 ) ; 
     return sum );
  static   operation largestDigitSumdivisior( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 1 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     res := Set{res, getSum(i)}->max() ; 
     res := Set{res, getSum(n / i)}->max() ) else skip )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 14 ;
     OclFile["System.out"].println(largestDigitSumdivisior(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class465 {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int x=sc.nextInt();
    int y=sc.nextInt();
    int z=sc.nextInt();
    int r=0,f=0 ;
    if(a>x){
      f+=(a-x)/2 ;
    }
    else {
      r+=x-a ;
    }
    if(b>y){
      f+=(b-y)/2 ;
    }
    else {
      r+=y-b ;
    }
    if(c>z){
      f+=(c-z)/2 ;
    }
    else {
      r+=z-c ;
    }
    if(r<=f){
      System.out.println("YES");
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class class465 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var z : int ; z := sc.getCurrent()->toInteger() ;
    var r : int ; r := 0 ;
    var f : int ; f := 0 ;
    if (a > x) then (     f := f+((a - x) / 2) ) else (     r := r+(x - a) ) ;  
    if (b > y) then (     f := f+((b - y) / 2) ) else (     r := r+(y - b) ) ;  
    if (c > z) then (     f := f+((c - z) / 2) ) else (     r := r+(z - c) ) ;  
    if (r <= f) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int M=10000 ;
    for(; ; ){
      int n=in.nextInt(),m=in.nextInt();
      if((n | m)==0)return ;
      int cost[][]=new int[n][n];
      int mincost[]=new int[n];
      boolean use[]=new boolean[n];
      int total=0 ;
      for(int i=0 ; i<n ; i++)Arrays.fill(cost[i],M);
      Arrays.fill(mincost,M);
      Arrays.fill(use,false);
      for(int i=0 ; i<n ; i++)cost[i][i]=0 ;
      for(int i=0 ; i<m ; i++){
        int s=in.nextInt();
        int t=in.nextInt();
        int c=in.nextInt();
        cost[s][t]=c ;
        cost[t][s]=c ;
      }
      mincost[0]=0 ;
      for(; ; ){
        int v=-1 ;
        for(int j=0 ; j<n ; j++)if(! use[j] &&(v==-1 || mincost[v]>mincost[j]))v=j ;
        if(v==-1)break ;
        total+=mincost[v];
        use[v]=true ;
        for(int j=0 ; j<n ; j++){
          if(! use[j] && mincost[j]>cost[v][j])mincost[j]=cost[v][j];
        }
      }
      System.out.println(total);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var M : int ; M := 10000 ;
       while true do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseOr(n,m)) = 0) then     return else skip ; 
    var cost : Sequence(Sequence(int)) ; cost := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var mincost : Sequence(int) ; mincost := Integer.subrange(1,n)->collect(0) ;
    var use : Sequence(boolean) ; use := Integer.subrange(1,n)->collect(false) ;
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < n do (     cost[i+1] := cost[i+1]->collect(M) ;  ;     i := i + 1 ) ; 
    mincost := mincost->collect(M) ; 
    use := use->collect(false) ; 
        var i : int ; i := 0 ; while i < n do (     cost[i+1][i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var s : int ; s := in.getCurrent()->toInteger() ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    cost[s+1][t+1] := c ; 
    cost[t+1][s+1] := c ; 
 )  ;     i := i + 1 ) ; 
    mincost[0+1] := 0 ; 
      while true do ( (     var v : int ; v := -1 ;
         var j : int ; j := 0 ; while j < n do (     if (not(use[j+1]) & (v = -1 or mincost[v+1] > mincost[j+1])) then     v := j ; else skip ;  ;     j := j + 1 ) ; 
    if (v = -1) then     break else skip ; 
    total := total+(mincost[v+1]) ; 
    use[v+1] := true ; 
        var j : int ; j := 0 ; while j < n do ( (     if (not(use[j+1]) & mincost[j+1] > cost[v+1][j+1]) then     mincost[j+1] := cost[v+1][j+1] ; else skip )  ;     j := j + 1 ) ; 
 )  ) ; 
    OclFile["System.out"].println(total) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    int M=Integer.parseInt(sc.next());
    int[] a=new int[M];
    int[] b=new int[M];
    int[] c=new int[M];
    for(int i=0 ; i<M ; i++){
      a[i]=Integer.parseInt(sc.next())-1 ;
      b[i]=Integer.parseInt(sc.next())-1 ;
      c[i]=-Integer.parseInt(sc.next());
    }
    long[] dist=new long[N];
    for(int i=1 ; i<N ; i++){
      dist[i]=Long.MAX_VALUE ;
    }
    boolean flag=true ;
    int ans_flag=0 ;
    int cnt=0 ;
    long ans_tmp=0 ;
    while(flag){
      flag=false ;
      for(int i=0 ; i<M ; i++){
        if(dist[a[i] ]!=Long.MAX_VALUE && dist[b[i] ]>dist[a[i] ]+c[i]){
          dist[b[i] ]=dist[a[i] ]+c[i];
          flag=true ;
        }
      }
      if(cnt==N-1){
        ans_tmp=dist[N-1];
      }
      if(cnt==2*N){
        if(dist[N-1]<ans_tmp){
          ans_flag=1 ;
        }
        break ;
      }
      cnt++;
    }
    if(ans_flag==0){
      System.out.println(-dist[N-1]);
    }
    else if(ans_flag==1){
      System.out.println("inf");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var M : int ; M := (sc.getCurrent())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,M)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,M)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     a[i+1] := (sc.getCurrent())->toInteger() - 1 ; 
     b[i+1] := (sc.getCurrent())->toInteger() - 1 ; 
     c[i+1] := -(sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var dist : Sequence(long) ; dist := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 1 ; while i < N do ( (     dist[i+1] := "9223372036854775807"->toLong() )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := true ;
    var ans_flag : int ; ans_flag := 0 ;
    var cnt : int ; cnt := 0 ;
    var ans_tmp : long ; ans_tmp := 0 ;
    while (flag) do (     flag := false ; 
         var i : int ; i := 0 ; while i < M do ( (     if (dist[a[i+1]+1] /= "9223372036854775807"->toLong() & dist[b[i+1]+1] > dist[a[i+1]+1] + c[i+1]) then (     dist[b[i+1]+1] := dist[a[i+1]+1] + c[i+1] ; 
     flag := true ) else skip )  ;     i := i + 1 ) ; 
    if (cnt = N - 1) then (     ans_tmp := dist[N - 1+1] ) else skip ; 
    if (cnt = 2 * N) then (     if (dist[N - 1+1] < ans_tmp) then (     ans_flag := 1 ) else skip ; 
     break ) else skip ; 
    cnt := cnt + 1 ; 
 ) ; 
    if (ans_flag = 0) then (     OclFile["System.out"].println(-dist[N - 1+1]) ) else     if (ans_flag = 1) then (     OclFile["System.out"].println("inf") ) else skip ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int modP=1000000007 ;
  static long inf=Long.MAX_VALUE ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    List<E>edges=new ArrayList<>();
    for(int i=0 ; i<m ; i++){
      int a=in.nextInt()-1 ;
      int b=in.nextInt()-1 ;
      long c=-in.nextInt();
      E e=new E(a,b,c);
      edges.add(e);
    }
    long[] dist=new long[n];
    Arrays.fill(dist,inf);
    dist[0]=0 ;
    for(int i=0 ; i<n-1 ; i++){
      for(E e : edges){
        if(dist[e.from]!=inf && dist[e.from]+e.w<dist[e.to]){
          dist[e.to]=dist[e.from]+e.w ;
        }
      }
    }
    long ans=-dist[n-1];
    for(int i=0 ; i<n ; i++){
      for(E e : edges){
        if(dist[e.from]!=inf && dist[e.from]+e.w<dist[e.to]){
          dist[e.to]=dist[e.from]+e.w ;
        }
      }
    }
    if(ans<-dist[n-1]){
      print("inf");
    }
    else {
      print(ans);
    }
  }
  static void print(String s){
    System.out.println(s);
  }
  static void print(int i){
    System.out.println(i);
  }
  static void print(long i){
    System.out.println(i);
  }
}
class E {
  int from,to ;
  long w ;
  E(int from,int to,long w){
    this.from=from ;
    this.to=to ;
    this.w=w ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute modP : int := 1000000007;
  static   attribute inf : long := "9223372036854775807"->toLong();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var edges : Sequence(E) ; edges := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := in.getCurrent()->toInteger() - 1 ;
     var b : int ; b := in.getCurrent()->toInteger() - 1 ;
    var c : long ; c := -in.getCurrent()->toInteger() ;
    var e : E ; e := E.newE(a, b, c) ;
    edges := edges->including(e) ; 
 )  ;     i := i + 1 ) ; 
    var dist : Sequence(long) ; dist := Integer.subrange(1,n)->collect(0) ;
    dist := dist->collect(inf) ; 
    dist[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     for (e : edges) do ( (     if (dist[e.from+1] /= inf & dist[e.from+1] + e.w < dist[e.to+1]) then (     dist[e.to+1] := dist[e.from+1] + e.w ) else skip )  ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := -dist[n - 1+1] ;
        var i : int ; i := 0 ; while i < n do ( (     for (e : edges) do ( (     if (dist[e.from+1] /= inf & dist[e.from+1] + e.w < dist[e.to+1]) then (     dist[e.to+1] := dist[e.from+1] + e.w ) else skip )  ) )  ;     i := i + 1 ) ; 
    if (ans < -dist[n - 1+1]) then (     execute print("inf") ) else (     execute print(ans) ) ;  
 );
  static   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation print( i : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(i) );
  static   operation print( i : long) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(i) );
}
class E {
   attribute from : int;
   attribute w : long;
   static operation newE( from : int, to : int, w : long) : E
  pre: true
  post: true
  activity:
  ( var self : E ;
    self := createE();
    self.initialise(from, to,w);
    return self );
  operation initialise( from : int, to : int, w : long) : void
  pre: true  post: true
  activity: (     self.from := from ; 
     self.to := to ; 
     self.w := w );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  static int n ;
  static int m ;
  static Edge[] e ;
  static long dis[];
  static final long inf=1000000000000000l ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    m=sc.nextInt();
    e=new Edge[m];
    dis=new long[n];
    Arrays.fill(dis,inf);
    dis[0]=0 ;
    for(int i=0 ; i<m ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      e[i]=new Edge(a-1,b-1,-c);
    }
    sc.close();
    if(bellmanFord()){
      System.out.print("inf");
    }
    else {
      System.out.println(-dis[n-1]);
    }
  }
  public static boolean bellmanFord(){
    for(int i=0 ; i<n+1 ; i++){
      for(int j=0 ; j<m ; j++){
        if(dis[e[j] .from]!=inf && dis[e[j] .to]>dis[e[j] .from]+e[j] .cost){
          dis[e[j] .to]=dis[e[j] .from]+e[j] .cost ;
          if(i==n && e[j] .to==n-1){
            return true ;
          }
        }
      }
    }
    return false ;
  }
}
class Edge {
  int from ;
  int to ;
  long cost ;
  Edge(int from,int to,long cost){
    this.from=from ;
    this.to=to ;
    this.cost=cost ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute m : int;
  static   attribute e : Sequence(Edge);
  static   attribute dis : Sequence(long);
  static    attribute inf : long := 1000000000000000l;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
    e := Integer.subrange(1,m)->collect(null) ; 
    dis := Integer.subrange(1,n)->collect(0) ; 
    dis := dis->collect(inf) ; 
    dis[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
     e[i+1] := Edge.newEdge(a - 1, b - 1, -c) )  ;     i := i + 1 ) ; 
    skip ; 
    if (bellmanFord()) then (     OclFile["System.out"].print("inf") ) else (     OclFile["System.out"].println(-dis[n - 1+1]) ) ;  
 );
  static   operation bellmanFord() : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n + 1 do ( (         var j : int ; j := 0 ; while j < m do ( (     if (dis[e[j+1].from+1] /= inf & dis[e[j+1].to+1] > dis[e[j+1].from+1] + e[j+1].cost) then (     dis[e[j+1].to+1] := dis[e[j+1].from+1] + e[j+1].cost ; 
     if (i = n & e[j+1].to = n - 1) then (     return true ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return false );
}
class Edge {
   attribute from : int;
   attribute to : int;
   attribute cost : long;
   static operation newEdge( from : int, to : int, cost : long) : Edge
  pre: true
  post: true
  activity:
  ( var self : Edge ;
    self := createEdge();
    self.initialise(from, to,cost);
    return self );
  operation initialise( from : int, to : int, cost : long) : void
  pre: true  post: true
  activity: (     self.from := from ; 
     self.to := to ; 
     self.cost := cost );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static class edge {
    int from,to ;
    long cost ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int m=Integer.parseInt(str[1]);
    edge[] es=new edge[m];
    for(int i=0 ; i<m ; i++){
      str=br.readLine().split(" ");
      edge ed=new edge();
      ed.from=Integer.parseInt(str[0])-1 ;
      ed.to=Integer.parseInt(str[1])-1 ;
      ed.cost=-Long.parseLong(str[2]);
      es[i]=ed ;
    }
    long[] dist=new long[n];
    Arrays.fill(dist,Long.MAX_VALUE/2);
    dist[0]=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        edge ed=es[j];
        if(dist[ed.from]<Long.MAX_VALUE/3)dist[ed.to]=Long.min(dist[ed.to],dist[ed.from]+ed.cost);
      }
    }
    long ans=dist[n-1];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        edge ed=es[j];
        if(dist[ed.from]<Long.MAX_VALUE/3)dist[ed.to]=Long.min(dist[ed.to],dist[ed.from]+ed.cost);
      }
    }
    if(ans!=dist[n-1])System.out.println("inf");
    else System.out.println(-ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class edge {
   attribute from : int;
   attribute cost : long;
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var m : int ; m := (str[1+1])->toInteger() ;
    var es : Sequence(edge) ; es := Integer.subrange(1,m)->collect(null) ;
        var i : int ; i := 0 ; while i < m do ( (     str := br.readLine()->split(" ") ; 
     var ed : edge ; ed := edge.newedge() ;
    ed.from := (str[0+1])->toInteger() - 1 ; 
    ed.to := (str[1+1])->toInteger() - 1 ; 
    ed.cost := -(str[2+1])->toLong() ; 
    es[i+1] := ed ; 
 )  ;     i := i + 1 ) ; 
    var dist : Sequence(long) ; dist := Integer.subrange(1,n)->collect(0) ;
    dist := dist->collect("9223372036854775807"->toLong() / 2) ; 
    dist[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     var ed : edge ; ed := es[j+1] ;
     if (dist[ed.from+1] < "9223372036854775807"->toLong() / 3) then     dist[ed.to+1] := Set{dist[ed.to+1], dist[ed.from+1] + ed.cost}->min() ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := dist[n - 1+1] ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     var ed : edge ; ed := es[j+1] ;
     if (dist[ed.from+1] < "9223372036854775807"->toLong() / 3) then     dist[ed.to+1] := Set{dist[ed.to+1], dist[ed.from+1] + ed.cost}->min() ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (ans /= dist[n - 1+1]) then     OclFile["System.out"].println("inf") else     OclFile["System.out"].println(-ans) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int M=scanner.nextInt();
    final long INF=-1_000_000_000_000_000L ;
    long[] dist=new long[N];
    for(int i=1 ; i<N ; i++)dist[i]=INF ;
    int[][] edges=new int[M][2];
    int[] costs=new int[M];
    for(int i=0 ; i<M ; i++){
      edges[i]=new int[] {
        scanner.nextInt()-1,scanner.nextInt()-1 };
        costs[i]=scanner.nextInt();
      }
      for(int i=0 ; i<N-1 ; i++){
        for(int j=0 ; j<M ; j++){
          int from=edges[j][0];
          int to=edges[j][1];
          int cost=costs[j];
          if(dist[from]>INF){
            long newValue=dist[from]+cost ;
            if(newValue>dist[to])dist[to]=newValue ;
          }
        }
      }
      boolean[] negative=new boolean[N];
      for(int i=0 ; i<N ; i++){
        for(int j=0 ; j<M ; j++){
          int from=edges[j][0];
          int to=edges[j][1];
          int cost=costs[j];
          if(dist[from]>INF && dist[from]+cost>dist[to])negative[from]=true ;
          if(negative[from])negative[to]=true ;
        }
      }
      if(negative[N-1])System.out.println("inf");
      else System.out.println(dist[N-1]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var M : int ; M := scanner.getCurrent()->toInteger() ;
    var INF : long ; INF := -1_000_000_000_000_000L ;
    var dist : Sequence(long) ; dist := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 1 ; while i < N do (     dist[i+1] := INF ;  ;     i := i + 1 ) ; 
    var edges : Sequence(Sequence(int)) ; edges := Integer.subrange(1,M)->collect(Integer.subrange(1,2)->collect(0)) ;
    var costs : Sequence(int) ; costs := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     edges[i+1] := Sequence{scanner.getCurrent()->toInteger() - 1,scanner.getCurrent()->toInteger() - 1} ; 
     costs[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (         var j : int ; j := 0 ; while j < M do ( (     var from : int ; from := edges[j+1][0+1] ;
     var to : int ; to := edges[j+1][1+1] ;
     var cost : int ; cost := costs[j+1] ;
     if (dist[from+1] > INF) then (     var newValue : long ; newValue := dist[from+1] + cost ;
     if (newValue > dist[to+1]) then     dist[to+1] := newValue ; else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var negative : Sequence(boolean) ; negative := Integer.subrange(1,N)->collect(false) ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < M do ( (     var from : int ; from := edges[j+1][0+1] ;
     var to : int ; to := edges[j+1][1+1] ;
    var cost : int ; cost := costs[j+1] ;
    if (dist[from+1] > INF & dist[from+1] + cost > dist[to+1]) then     negative[from+1] := true ; else skip ; 
    if (negative[from+1]) then     negative[to+1] := true ; else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (negative[N - 1+1]) then     OclFile["System.out"].println("inf") else     OclFile["System.out"].println(dist[N - 1+1]) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void MinSteps(int SourceX,int SourceY,int DestX,int DestY){
    System.out.println(Math.max(Math.abs(SourceX-DestX),Math.abs(SourceY-DestY)));
    while((SourceX!=DestX)||(SourceY!=DestY)){
      if(SourceX<DestX){
        System.out.print('U');
        SourceX++;
      }
      if(SourceX>DestX){
        System.out.println('D');
        SourceX--;
      }
      if(SourceY>DestY){
        System.out.print('L');
        SourceY--;
      }
      if(SourceY<DestY){
        System.out.print('R');
        SourceY++;
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    int sourceX=4,sourceY=4 ;
    int destinationX=7,destinationY=0 ;
    MinSteps(sourceX,sourceY,destinationX,destinationY);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MinSteps( SourceX : int, SourceY : int, DestX : int, DestY : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(Set{if SourceX - DestX < 0 then -(SourceX - DestX) else SourceX - DestX endif, if SourceY - DestY < 0 then -(SourceY - DestY) else SourceY - DestY endif}->max()) ; 
     while ((SourceX /= DestX) or (SourceY /= DestY)) do (     if (SourceX < DestX) then (     OclFile["System.out"].print('U') ; 
     SourceX := SourceX + 1 ) else skip ; 
     if (SourceX > DestX) then (     OclFile["System.out"].println('D') ; 
     SourceX := SourceX - 1 ) else skip ; 
    if (SourceY > DestY) then (     OclFile["System.out"].print('L') ; 
     SourceY := SourceY - 1 ) else skip ; 
    if (SourceY < DestY) then (     OclFile["System.out"].print('R') ; 
     SourceY := SourceY + 1 ) else skip ; 
    OclFile["System.out"].println() ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sourceX : int ; sourceX := 4 ;
    var sourceY : int ; sourceY := 4 ;
     var destinationX : int ; destinationX := 7 ;
    var destinationY : int ; destinationY := 0 ;
     execute MinSteps(sourceX, sourceY, destinationX, destinationY) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B744 {
  public static void main(String[] args){
    List[] L=new List[29];
    int[] ans=new int[1009];
    Arrays.fill(ans,1000000000);
    for(int i=0 ; i<20 ; i++)L[i]=new ArrayList();
    for(int i=0 ; i<10 ; i++){
      int tmp=1<<i ;
      for(int j=1 ; j<1024 ; j++){
        if((tmp & j)==0)L[i] .add(j);
        else L[i+10] .add(j);
      }
    }
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    for(int i=0 ; i<20 ; i++){
      List query=new ArrayList();
      int[] have=new int[1009];
      Arrays.fill(have,0);
      for(int j=0 ; j<L[i] .size(); j++)if((int)L[i] .get(j)<=n)query.add(L[i] .get(j));
      if(query.size()==0)continue ;
      System.out.println(query.size());
      for(int j=0 ; j<query.size(); j++)if((int)query.get(j)<=n){
        System.out.print(query.get(j)+" ");
        have[(int)query.get(j)]=1 ;
      }
      for(int j=1 ; j<=n ; j++){
        int tmp=in.nextInt();
        if(have[j]==0)ans[j]=Math.min(ans[j],tmp);
      }
    }
    System.out.println(-1);
    for(int i=1 ; i<=n ; i++)System.out.print(ans[i]+" ");
    System.out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B744 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : Sequence(Sequence) ; L := Integer.subrange(1,29)->collect(null) ;
     var ans : Sequence(int) ; ans := Integer.subrange(1,1009)->collect(0) ;
    ans := ans->collect(1000000000) ; 
        var i : int ; i := 0 ; while i < 20 do (     L[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 10 do ( (     var tmp : int ; tmp := (1*(2->pow(i)))->oclAsType(long) ;
         var j : int ; j := 1 ; while j < 1024 do ( (     if ((MathLib.bitwiseAnd(tmp,j)) = 0) then     L[i+1]->excludes(j) ; else     L[i + 10+1]->excludes(j) ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < 20 do ( (     var query : Sequence ; query := Sequence{} ;
     var have : Sequence(int) ; have := Integer.subrange(1,1009)->collect(0) ;
    have := have->collect(0) ; 
        var j : int ; j := 0 ; while j < L[i+1]->size() do (     if (L[i+1]->at(j+1)->oclAsType(int) <= n) then     query := query->including(L[i+1]->at(j+1)) ; else skip ;  ;     j := j + 1 ) ; 
    if (query->size() = 0) then     continue else skip ; 
    OclFile["System.out"].println(query->size()) ; 
        var j : int ; j := 0 ; while j < query->size() do (     if (query->at(j+1)->oclAsType(int) <= n) then (     OclFile["System.out"].print(query->at(j+1) + " ") ; 
     have[query->at(j+1)->oclAsType(int)+1] := 1 ) else skip ;  ;     j := j + 1 ) ; 
        var j : int ; j := 1 ; while j <= n do ( (     var tmp : int ; tmp := in.getCurrent()->toInteger() ;
     if (have[j+1] = 0) then     ans[j+1] := Set{ans[j+1], tmp}->min() ; else skip )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
        var i : int ; i := 1 ; while i <= n do (     OclFile["System.out"].print(ans[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].flush() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt(),m=scanner.nextInt(),k=scanner.nextInt();
    scanner.nextLine();
    int[][][] planets=new int[n][m][3];
    for(int i=0 ; i<n ; ++i){
      int[][] planet=planets[i];
      scanner.nextLine();
      for(int j=0 ; j<m ; ++j){
        planet[j][0]=scanner.nextInt();
        planet[j][1]=scanner.nextInt();
        planet[j][2]=scanner.nextInt();
        scanner.nextLine();
      }
    }
    int maxProfit=0 ;
    for(int i=0 ; i<planets.length ; ++i){
      for(int j=0 ; j<planets.length ; ++j){
        if(i==j)continue ;
        maxProfit=calProfit(planets[i],planets[j],maxProfit,k);
      }
    }
    System.out.println(maxProfit);
  }
  private static int calProfit(int[][] planetI,int[][] planetJ,int maxProfit,int k){
    boolean[] flag=new boolean[planetI.length];
    int sum=0 ;
    while(k>0){
      int max=0 ;
      int maxIndex=-1 ;
      for(int i=0 ; i<planetI.length ; ++i){
        if(flag[i])continue ;
        if(planetJ[i][1]-planetI[i][0]>max){
          max=planetJ[i][1]-planetI[i][0];
          maxIndex=i ;
        }
      }
      if(maxIndex<0)break ;
      flag[maxIndex]=true ;
      int num=Math.min(planetI[maxIndex][2],k);
      k-=num ;
      sum+=num*max ;
    }
    return Math.max(sum,maxProfit);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
    skip ; 
    var planets : Sequence(Sequence(Sequence(int))) ; planets := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(Integer.subrange(1,3)->collect(0))) ;
        var i : int ; i := 0 ; while i < n do ( (     var planet : Sequence(Sequence(int)) ; planet := planets[i+1] ;
     skip ; 
         var j : int ; j := 0 ; while j < m do ( (     planet[j+1][0+1] := scanner.getCurrent()->toInteger() ; 
     planet[j+1][1+1] := scanner.getCurrent()->toInteger() ; 
     planet[j+1][2+1] := scanner.getCurrent()->toInteger() ; 
     skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var maxProfit : int ; maxProfit := 0 ;
        var i : int ; i := 0 ; while i < planets->size() do ( (         var j : int ; j := 0 ; while j < planets->size() do ( (     if (i = j) then     continue else skip ; 
     maxProfit := calProfit(planets[i+1], planets[j+1], maxProfit, k) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(maxProfit) ; 
 );
  static   operation calProfit( planetI : Sequence(Sequence(int)), planetJ : Sequence(Sequence(int)), maxProfit : int, k : int) : int
  pre: true
  post: true
  activity: (     var flag : Sequence(boolean) ; flag := Integer.subrange(1,planetI->size())->collect(false) ;
     var sum : int ; sum := 0 ;
     while (k > 0) do (     var max : int ; max := 0 ;
     var maxIndex : int ; maxIndex := -1 ;
        var i : int ; i := 0 ; while i < planetI->size() do ( (     if (flag[i+1]) then     continue else skip ; 
     if (planetJ[i+1][1+1] - planetI[i+1][0+1] > max) then (     max := planetJ[i+1][1+1] - planetI[i+1][0+1] ; 
     maxIndex := i ) else skip )  ;     i := i + 1 ) ; 
    if (maxIndex < 0) then     break else skip ; 
    flag[maxIndex+1] := true ; 
    var num : int ; num := Set{planetI[maxIndex+1][2+1], k}->min() ;
    k := k-(num) ; 
    sum := sum+(num * max) ; 
 ) ; 
     return Set{sum, maxProfit}->max() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static int k ;
  public static int[][] a=new int[1005][1005];
  public static int[][] b=new int[1005][1005];
  public static int[][] c=new int[1005][1005];
  public static int n ;
  public static int m ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    n=scanner.nextInt();
    m=scanner.nextInt();
    k=scanner.nextInt();
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      scanner.nextLine();
      String name=scanner.nextLine();
      for(int j=0 ; j<m ; j++){
        a[i][j]=scanner.nextInt();
        b[i][j]=scanner.nextInt();
        c[i][j]=scanner.nextInt();
      }
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        ans=Math.max(ans,cal(i,j));
      }
    }
    System.out.println(ans);
  }
  static int cal(int x,int y){
    int[] vis=new int[1005];
    int last=k,ans=0 ;
    while(last>0){
      int flag=0 ;
      int maxv=0,maxp=0 ;
      for(int i=0 ; i<m ; i++){
        if(vis[i]>0)continue ;
        if(b[y][i]-a[x][i]>maxv){
          maxv=b[y][i]-a[x][i];
          maxp=i ;
          flag=1 ;
        }
      }
      if(flag==0)break ;
      int num=Math.min(last,c[x][maxp]);
      ans+=num*maxv ;
      vis[maxp]=1 ;
      last-=num ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute k : int;
  static   attribute a : Sequence(Sequence(int)) := Integer.subrange(1,1005)->collect(Integer.subrange(1,1005)->collect(0));
  static   attribute b : Sequence(Sequence(int)) := Integer.subrange(1,1005)->collect(Integer.subrange(1,1005)->collect(0));
  static   attribute c : Sequence(Sequence(int)) := Integer.subrange(1,1005)->collect(Integer.subrange(1,1005)->collect(0));
  static   attribute n : int;
  static   attribute m : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := scanner.getCurrent()->toInteger() ; 
    m := scanner.getCurrent()->toInteger() ; 
    k := scanner.getCurrent()->toInteger() ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     skip ; 
     var name : String ; name := scanner.nextLine() ;
         var j : int ; j := 0 ; while j < m do ( (     a[i+1][j+1] := scanner.getCurrent()->toInteger() ; 
     b[i+1][j+1] := scanner.getCurrent()->toInteger() ; 
     c[i+1][j+1] := scanner.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     ans := Set{ans, cal(i, j)}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation cal( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var vis : Sequence(int) ; vis := Integer.subrange(1,1005)->collect(0) ;
     var last : int ; last := k ;
    var ans : int ; ans := 0 ;
     while (last > 0) do (     var flag : int ; flag := 0 ;
     var maxv : int ; maxv := 0 ;
    var maxp : int ; maxp := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     if (vis[i+1] > 0) then     continue else skip ; 
     if (b[y+1][i+1] - a[x+1][i+1] > maxv) then (     maxv := b[y+1][i+1] - a[x+1][i+1] ; 
     maxp := i ; 
     flag := 1 ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 0) then     break else skip ; 
    var num : int ; num := Set{last, c[x+1][maxp+1]}->min() ;
    ans := ans+(num * maxv) ; 
    vis[maxp+1] := 1 ; 
    last := last-(num) ; 
 ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public String toLowerCase(String str){
    return str.toLowerCase();
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation toLowerCase( str : String) : String
  pre: true
  post: true
  activity: (     return str->toLowerCase() );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int OR(int a[],int n){
    int ans=a[0];
    int i ;
    for(i=1 ; i<n ; i++){
      ans |=a[i];
    }
    return ans ;
  }
  public static void main(String args[]){
    int a[]={
      1,4,6 };
      int n=a.length ;
      System.out.println(OR(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation OR( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := a[0+1] ;
     var i : int ;
         i := 1 ; while i < n do ( (     ans := MathLib.bitwiseOr(ans, a[i+1]) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,4,6} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(OR(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    long A=sc.nextLong();
    long B=sc.nextLong();
    long C=sc.nextLong();
    long D=sc.nextLong();
    long t=Math.abs(A-B);
    String ans="NO" ;
    for(long i=0 ; i<=N-1 ; i++){
      if((t<=i*D-(N-1-i)*C)&&(t>=i*C-(N-1-i)*D))ans="YES" ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    var A : long ; A := sc.getCurrent()->toLong() ;
    var B : long ; B := sc.getCurrent()->toLong() ;
    var C : long ; C := sc.getCurrent()->toLong() ;
    var D : long ; D := sc.getCurrent()->toLong() ;
    var t : long ; t := if A - B < 0 then -(A - B) else A - B endif ;
    var ans : String ; ans := "NO" ;
        var i : long ; i := 0 ; while i <= N - 1 do ( (     if ((t <= i * D - (N - 1 - (i)->char2byte()) * C) & (t >= i * C - (N - 1 - (i)->char2byte()) * D)) then     ans := "YES" ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=true ;
  private static PrintWriter _out=new PrintWriter(System.out);
  private static PrintWriter _err=new PrintWriter(System.err);
  private void solve(Scanner sc){
    int N=sc.nextInt();
    long A=sc.nextInt();
    long B=sc.nextInt();
    long C=sc.nextInt();
    long D=sc.nextInt();
    for(int m=0 ; m<=N ; ++m){
      long left=C*(N-1-m)-D*m ;
      long right=-C*m+(N-1-m)*D ;
      if(left<=B-A && B-A<=right){
        _out.println("YES");
        return ;
      }
    }
    _out.println("NO");
  }
  private static BigInteger C(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    for(long i=r ; i>1 ; --i){
      res=res.divide(BigInteger.valueOf(i));
    }
    return res ;
  }
  private static BigInteger P(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    return res ;
  }
  public static void main(String[] args){
    long S=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    new Main().solve(sc);
    _out.flush();
    long G=System.currentTimeMillis();
    if(elapsed){
      _err.println((G-S)+"ms");
    }
    _err.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := true;
  static   attribute _out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute _err : OclFile := OclFile.newOclFile_Write(OclFile["System.err"]);
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.nextInt() ;
     var A : long ; A := sc.nextInt() ;
    var B : long ; B := sc.nextInt() ;
    var C : long ; C := sc.nextInt() ;
    var D : long ; D := sc.nextInt() ;
        var m : int ; m := 0 ; while m <= N do ( (     var left : long ; left := C * (N - 1 - m) - D * m ;
     var right : long ; right := -C * m + (N - 1 - m) * D ;
     if (left <= B - A & B - A <= right) then (     skip ; 
     return ) else skip )  ;     m := m + 1 ) ; 
    skip ; 
 );
  static   operation C( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
         var i : long ; i := r ; while i > 1 do ( (     res := res.divide((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation P( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    Main.newMain().solve(sc) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solveB();
  }
  private void solveB(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long A=sc.nextLong();
    long B=sc.nextLong();
    long C=sc.nextLong();
    long D=sc.nextLong();
    if(judge(N,A,B,C,D)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
  private boolean judge(int N,long A,long B,long C,long D){
    for(int minus=0 ; minus<N ; minus++){
      long min=-D*minus+C*(N-1-minus);
      long max=-C*minus+D*(N-1-minus);
      if(min<=B-A && B-A<=max){
        return true ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solveB() );
   operation solveB() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : long ; A := sc.getCurrent()->toLong() ;
    var B : long ; B := sc.getCurrent()->toLong() ;
    var C : long ; C := sc.getCurrent()->toLong() ;
    var D : long ; D := sc.getCurrent()->toLong() ;
    if (judge(N, A, B, C, D)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
   operation judge( N : int, A : long, B : long, C : long, D : long) : boolean
  pre: true
  post: true
  activity: (         var minus : int ; minus := 0 ; while minus < N do ( (     var min : long ; min := -D * minus + C * (N - 1 - minus) ;
     var max : long ; max := -C * minus + D * (N - 1 - minus) ;
     if (min <= B - A & B - A <= max) then (     return true ) else skip )  ;     minus := minus + 1 ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    long n=Integer.parseInt(sa[0]);
    long a=Integer.parseInt(sa[1]);
    long b=Integer.parseInt(sa[2]);
    long c=Integer.parseInt(sa[3]);
    long d=Integer.parseInt(sa[4]);
    br.close();
    long ba=b-a ;
    for(int i=0 ; i<n ; i++){
      if(c*i-d*(n-1-i)<=ba && ba<=d*i-c*(n-1-i)){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var n : long ; n := (sa[0+1])->toInteger() ;
    var a : long ; a := (sa[1+1])->toInteger() ;
    var b : long ; b := (sa[2+1])->toInteger() ;
    var c : long ; c := (sa[3+1])->toInteger() ;
    var d : long ; d := (sa[4+1])->toInteger() ;
    skip ; 
    var ba : long ; ba := b - a ;
        var i : int ; i := 0 ; while i < n do ( (     if (c * i - d * (n - 1 - i) <= ba & ba <= d * i - c * (n - 1 - i)) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public void exec()throws IOException {
    Scanner input=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    long n=input.nextInt();
    long a=input.nextInt();
    long b=input.nextInt();
    long c=input.nextInt();
    long d=input.nextInt();
    boolean ret=false ;
    for(long m=0 ; m<n ; m++){
      if(c*(n-1-m)-d*m<=b-a && b-a<=d*(n-1-m)-c*m){
        ret=true ;
        break ;
      }
    }
    out.println(ret ? "YES" : "NO");
    out.flush();
    input.close();
  }
  public static void main(String[] args)throws IOException {
    new Main().exec();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation exec() : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := input.getCurrent()->toInteger() ;
    var a : long ; a := input.getCurrent()->toInteger() ;
    var b : long ; b := input.getCurrent()->toInteger() ;
    var c : long ; c := input.getCurrent()->toInteger() ;
    var d : long ; d := input.getCurrent()->toInteger() ;
    var ret : boolean ; ret := false ;
        var m : long ; m := 0 ; while m < n do ( (     if (c * (n - 1 - m) - d * m <= b - a & b - a <= d * (n - 1 - m) - c * m) then (     ret := true ; 
     break ) else skip )  ;     m := m + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().exec() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.System.out ;
public class pre125 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int n=obj.nextInt(),d=obj.nextInt();
    int k=obj.nextInt();
    while(k--!=0){
      int x=obj.nextInt(),y=obj.nextInt();
      boolean ans=true ;
      ans &=(x-y<=d);
      ans &=(x+y<=2*n-d);
      ans &=(x-y>=-d);
      ans &=(x+y>=d);
      out.println(ans ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre125 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var n : int ; n := obj.nextInt() ;
    var d : int ; d := obj.nextInt() ;
     var k : int ; k := obj.nextInt() ;
         while (k /= 0) do (    skip ; (     var x : int ; x := obj.nextInt() ;
    var y : int ; y := obj.nextInt() ;
     var ans : boolean ; ans := true ;
    ans := MathLib.bitwiseAnd(ans, (x - y <= d)) ; 
    ans := MathLib.bitwiseAnd(ans, (x + y <= 2 * n - d)) ; 
    ans := MathLib.bitwiseAnd(ans, (x - y >= -d)) ; 
    ans := MathLib.bitwiseAnd(ans, (x + y >= d)) ; 
    out.println(if ans then "YES" else "NO" endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class C {
  static final int INF=Integer.MAX_VALUE ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[][][] value=new int[10][2][n+1];
    List<Integer>l=new ArrayList<>();
    for(int bitpos=0 ; bitpos<value.length ; ++bitpos)for(int bitval=0 ; bitval<2 ; ++bitval){
      l.clear();
      for(int i=1 ; i<=n ; ++i){
        if((1 &(i>>bitpos))==bitval)l.add(i);
      }
      if(l.isEmpty()){
        for(int i=1 ; i<=n ; ++i)value[bitpos][bitval][i]=INF ;
      }
      else {
        System.out.println(l.size());
        for(int i : l)System.out.print(i+" ");
        System.out.println();
        for(int i=1 ; i<=n ; ++i)value[bitpos][bitval][i]=in.nextInt();
      }
    }
    System.out.println(-1);
    for(int i=1 ; i<=n ; ++i){
      int result=INF ;
      for(int bitpos=0 ; bitpos<value.length ; ++bitpos)result=Math.min(result,value[bitpos][1 & ~(i>>bitpos)][i]);
      System.out.print(result+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static    attribute INF : int := 2147483647;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var value : Sequence(Sequence(Sequence(int))) ; value := Integer.subrange(1,10)->collect(Integer.subrange(1,2)->collect(Integer.subrange(1,n + 1)->collect(0))) ;
    var l : Sequence(int) ; l := Sequence{} ;
        var bitpos : int ; bitpos := 0 ; while bitpos < value->size() do (         var bitval : int ; bitval := 0 ; while bitval < 2 do ( (     l := l->intersection(Set{}) ; 
         var i : int ; i := 1 ; while i <= n do ( (     if ((MathLib.bitwiseAnd(1,((i/(2->pow(bitpos)))->oclAsType(long)))) = bitval) then     l := l->including(i) ; else skip )  ;     i := i + 1 ) ; 
     if (l->isEmpty()) then (         var i : int ; i := 1 ; while i <= n do (     value[bitpos+1][bitval+1][i+1] := INF ;  ;     i := i + 1 ) ) else (     OclFile["System.out"].println(l->size()) ; 
     for (i : l) do (     OclFile["System.out"].print(i + " ") ;  ) ; 
     OclFile["System.out"].println() ; 
         var i : int ; i := 1 ; while i <= n do (     value[bitpos+1][bitval+1][i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ) )  ;     bitval := bitval + 1 ) ;  ;     bitpos := bitpos + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
        var i : int ; i := 1 ; while i <= n do ( (     var result : int ; result := INF ;
         var bitpos : int ; bitpos := 0 ; while bitpos < value->size() do (     result := Set{result, value[bitpos+1][MathLib.bitwiseAnd(1,-(((i/(2->pow(bitpos)))->oclAsType(long)) + 1))+1][i+1]}->min() ;  ;     bitpos := bitpos + 1 ) ; 
     OclFile["System.out"].print(result + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class main {
  public static void main(String[] args){
    Scanner c=new Scanner(System.in);
    double n=c.nextDouble();
    double d=c.nextDouble();
    double m=c.nextDouble();
    double area=Math.abs((Math.sqrt(2)*Math.sqrt(2)*(n-d)*(d)));
    for(int i=0 ; i<m ; i++){
      double x=c.nextDouble();
      double y=c.nextDouble();
      double area1=(Math.abs((-(d*x)+(d*d)-(d*y))))/2 ;
      double area2=(Math.abs((x*(d-n)+d*(n-d-y)+n*y)))/2 ;
      double area3=(Math.abs(x*(-d)+n*(n-y)+(n-d)*(y+d-n)))/2 ;
      double area4=(Math.abs(x*(d-n)+(n-d)*(y-d)))/2 ;
      if((area1+area2+area3+area4)<=area){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var c : OclFile ; c := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : double ; n := c.getCurrent()->toReal() ;
    var d : double ; d := c.getCurrent()->toReal() ;
    var m : double ; m := c.getCurrent()->toReal() ;
    var area : double ; area := if ((2)->sqrt() * (2)->sqrt() * (n - d) * (d)) < 0 then -(((2)->sqrt() * (2)->sqrt() * (n - d) * (d))) else ((2)->sqrt() * (2)->sqrt() * (n - d) * (d)) endif ;
        var i : int ; i := 0 ; while i < m do ( (     var x : double ; x := c.getCurrent()->toReal() ;
     var y : double ; y := c.getCurrent()->toReal() ;
    var area1 : double ; area1 := (if (-(d * x) + (d * d) - (d * y)) < 0 then -((-(d * x) + (d * d) - (d * y))) else (-(d * x) + (d * d) - (d * y)) endif) / 2 ;
    var area2 : double ; area2 := (if (x * (d - n) + d * (n - d - y) + n * y) < 0 then -((x * (d - n) + d * (n - d - y) + n * y)) else (x * (d - n) + d * (n - d - y) + n * y) endif) / 2 ;
    var area3 : double ; area3 := (if x * (-d) + n * (n - y) + (n - d) * (y + d - n) < 0 then -(x * (-d) + n * (n - y) + (n - d) * (y + d - n)) else x * (-d) + n * (n - y) + (n - d) * (y + d - n) endif) / 2 ;
    var area4 : double ; area4 := (if x * (d - n) + (n - d) * (y - d) < 0 then -(x * (d - n) + (n - d) * (y - d)) else x * (d - n) + (n - d) * (y - d) endif) / 2 ;
    if ((area1 + area2 + area3 + area4) <= area) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class CF_VasyaAndCornfield {
  static BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter out=new PrintWriter(System.out);
  static void solve()throws Exception {
    StringTokenizer st=new StringTokenizer(bf.readLine());
    int n=Integer.parseInt(st.nextToken());
    int d=Integer.parseInt(st.nextToken());
    int m=Integer.parseInt(bf.readLine());
    for(int i=0 ; i<m ; i++){
      st=new StringTokenizer(bf.readLine());
      int x=Integer.parseInt(st.nextToken());
      int y=Integer.parseInt(st.nextToken());
      if(x-y>=-d && x-y<=d && x+y>=d && x+y<=2*n-d){
        out.println("YES");
      }
      else {
        out.println("NO");
      }
    }
  }
  public static void main(String[] args)throws Exception {
    int tc=1 ;
    while(tc-->0){
      solve();
    }
    out.flush();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF_VasyaAndCornfield {
  static   attribute bf : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var st : OclIterator ; st := OclIterator.newOclIterator_String(bf.readLine()) ;
     var n : int ; n := (st.next())->toInteger() ;
    var d : int ; d := (st.next())->toInteger() ;
    var m : int ; m := (bf.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     st := OclIterator.newOclIterator_String(bf.readLine()) ; 
     var x : int ; x := (st.next())->toInteger() ;
     var y : int ; y := (st.next())->toInteger() ;
     if (x - y >= -d & x - y <= d & x + y >= d & x + y <= 2 * n - d) then (     skip ) else (     skip ) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var tc : int ; tc := 1 ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     execute solve() ) ;  ) ;  
     skip ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countDigit(long n){
    if(n==0)return 0 ;
    return 1+countDigit(n/10);
  }
  public static void main(String[] args){
    long n=345289467 ;
    System.out.print("Number of digits : "+countDigit(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDigit( n : long) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else skip ; 
     return 1 + countDigit(n / 10) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 345289467 ;
     OclFile["System.out"].print("Number of digits : " + countDigit(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countDigit(long n){
    int count=0 ;
    while(n!=0){
      n=n/10 ;
++count ;
    }
    return count ;
  }
  public static void main(String[] args){
    long n=345289467 ;
    System.out.print("Number of digits : "+countDigit(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countDigit( n : long) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n /= 0) do (     n := n / 10 ; 
     count := count + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 345289467 ;
     OclFile["System.out"].print("Number of digits : " + countDigit(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1032A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),k=sc.nextInt();
    HashMap<Integer,Integer>m=new HashMap<>();
    int maxVal=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      int v=sc.nextInt();
      if(m.containsKey(v)){
        m.put(v,m.get(v)+1);
      }
      else {
        m.put(v,1);
      }
      maxVal=Math.max(maxVal,m.get(v));
    }
    int count=k*((maxVal+k-1)/k)*m.size();
    System.out.println(count-n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1032A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var m : Map(int,int) ; m := Map{} ;
    var maxVal : int ; maxVal := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := sc.getCurrent()->toInteger() ;
     if (m->keys()->includes(v)) then (     m := m->union(Map{v |-> m->at(v) + 1}) ) else (     m := m->union(Map{v |-> 1}) ) ;  
     maxVal := Set{maxVal, m->at(v)}->max() )  ;     i := i + 1 ) ; 
    var count : int ; count := k * ((maxVal + k - 1) / k) * m.size() ;
    OclFile["System.out"].println(count - n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class CountDistinctWindow {
  static void countDistinct(int arr[],int k){
    HashMap<Integer,Integer>hM=new HashMap<Integer,Integer>();
    int dist_count=0 ;
    for(int i=0 ; i<k ; i++){
      if(hM.get(arr[i])==null){
        hM.put(arr[i],1);
        dist_count++;
      }
      else {
        int count=hM.get(arr[i]);
        hM.put(arr[i],count+1);
      }
    }
    System.out.println(dist_count);
    for(int i=k ; i<arr.length ; i++){
      if(hM.get(arr[i-k])==1){
        hM.remove(arr[i-k]);
        dist_count--;
      }
      else {
        int count=hM.get(arr[i-k]);
        hM.put(arr[i-k],count-1);
      }
      if(hM.get(arr[i])==null){
        hM.put(arr[i],1);
        dist_count++;
      }
      else {
        int count=hM.get(arr[i]);
        hM.put(arr[i],count+1);
      }
      System.out.println(dist_count);
    }
  }
  public static void main(String arg[]){
    int arr[]={
      1,2,1,3,4,2,3 };
      int k=4 ;
      countDistinct(arr,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class CountDistinctWindow {
  static   operation countDistinct( arr : Sequence(int), k : int) : void
  pre: true
  post: true
  activity: (     var hM : Map(int,int) ; hM := Map{} ;
     var dist_count : int ; dist_count := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     if (hM->at(arr[i+1]) = null) then (     hM := hM->union(Map{arr[i+1] |-> 1}) ; 
     dist_count := dist_count + 1 ) else (     var count : int ; count := hM->at(arr[i+1]) ;
     hM := hM->union(Map{arr[i+1] |-> count + 1}) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dist_count) ; 
        var i : int ; i := k ; while i < arr->size() do ( (     if (hM->at(arr[i - k+1]) = 1) then (     hM := hM->antirestrict(Set{arr[i - k+1]}) ; 
     dist_count := dist_count - 1 ) else (     var count : int ; count := hM->at(arr[i - k+1]) ;
     hM := hM->union(Map{arr[i - k+1] |-> count - 1}) ) ;  
     if (hM->at(arr[i+1]) = null) then (     hM := hM->union(Map{arr[i+1] |-> 1}) ; 
     dist_count := dist_count + 1 ) else (     var count : int ; count := hM->at(arr[i+1]) ;
     hM := hM->union(Map{arr[i+1] |-> count + 1}) ) ;  
     OclFile["System.out"].println(dist_count) )  ;     i := i + 1 ) ; 
 );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,1,3,4,2,3} ;
     var k : int ; k := 4 ;
     execute countDistinct(arr, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countDigit(long n){
    return(int)Math.floor(Math.log10(n)+1);
  }
  public static void main(String[] args){
    long n=345289467 ;
    System.out.print("Number of digits : "+countDigit(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDigit( n : long) : int
  pre: true
  post: true
  activity: (     return ((n)->log10() + 1)->floor()->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 345289467 ;
     OclFile["System.out"].print("Number of digits : " + countDigit(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A1310 {
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    TreeMap<Integer,ArrayList<Integer>>map=new TreeMap<>();
    int a[][]=new int[2][n];
    for(int i=0 ; i<n ; i++){
      a[0][i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      a[1][i]=sc.nextInt();
      if(! map.containsKey(a[0][i])){
        map.put(a[0][i],new ArrayList<>());
      }
      map.get(a[0][i]).add(a[1][i]);
    }
    HashMap<Integer,Integer>freq=new HashMap<>();
    TreeSet<Integer>set=new TreeSet<>();
    long time=0,sum=0 ;
    int curr=0,size=map.size();
    while(! set.isEmpty()|| size>0){
      if(set.isEmpty()){
        curr=map.firstKey();
      }
      else {
        int max=set.last();
        sum-=max ;
        if(freq.get(max)==1){
          set.remove(max);
          freq.remove(max);
        }
        else {
          freq.put(max,freq.get(max)-1);
        }
        time+=sum ;
      }
      if(map.containsKey(curr)){
        for(int i : map.get(curr)){
          set.add(i);
          sum+=i ;
          if(! freq.containsKey(i)){
            freq.put(i,0);
          }
          freq.put(i,freq.get(i)+1);
        }
        map.remove(curr);
        size--;
      }
      curr++;
    }
    System.out.println(time);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1310 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var map : Map(int,Sequence(int)) ; map := Map{} ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,2)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     a[0+1][i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[1+1][i+1] := sc.getCurrent()->toInteger() ; 
     if (not(map->keys()->includes(a[0+1][i+1]))) then (     map := map->union(Map{a[0+1][i+1] |-> Sequence{}}) ) else skip ; 
     map->at(a[0+1][i+1])->excludes(a[1+1][i+1]) )  ;     i := i + 1 ) ; 
    var freq : Map(int,int) ; freq := Map{} ;
    var set : Set(int) ; set := Set{} ;
    var time : long ; time := 0 ;
    var sum : long ; sum := 0 ;
    var curr : int ; curr := 0 ;
    var size : int ; size := map.size() ;
    while (not(set->isEmpty()) or size > 0) do (     if (set->isEmpty()) then (     curr := map->keys()->min() ) else (     var max : int ; max := set->last() ;
     sum := sum-(max) ; 
     if (freq->at(max) = 1) then (     set := set->excludingAt(max+1) ; 
     freq := freq->antirestrict(Set{max}) ) else (     freq := freq->union(Map{max |-> freq->at(max) - 1}) ) ;  
     time := time+(sum) ) ;  
     if (map->keys()->includes(curr)) then (     for (i : map->at(curr)) do ( (     set := set->including(i) ; 
     sum := sum+(i) ; 
     if (not(freq->keys()->includes(i))) then (     freq := freq->union(Map{i |-> 0}) ) else skip ; 
     freq := freq->union(Map{i |-> freq->at(i) + 1}) )  ) ; 
     map := map->antirestrict(Set{curr}) ; 
     size := size - 1 ) else skip ; 
     curr := curr + 1 ) ; 
    OclFile["System.out"].println(time) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class reccommendations {
  public static void main(String[] args){
    Scanner x=new Scanner(System.in);
    int n=x.nextInt();
    int[] arr=new int[n];
    News[] newsarr=new News[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=x.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      newsarr[i]=new News(arr[i],x.nextInt());
    }
    Arrays.sort(newsarr);
    long total=0 ;
    PriorityQueue<Integer>values=new PriorityQueue<Integer>();
    int val=0 ;
    long sum=0 ;
    for(int i=0 ; i<=n ; i++){
      while(! values.isEmpty()&&(i==n || newsarr[i] .num>val)){
        int max=-values.poll();
        total-=max ;
        sum+=total ;
        val++;
      }
      if(i==n)break ;
      val=newsarr[i] .num ;
      values.add(-newsarr[i] .cost);
      total+=newsarr[i] .cost ;
    }
    System.out.println(sum);
  }
}
class News implements Comparable<News>{
  public int num ;
  public int cost ;
  public News(int a,int b){
    num=a ;
    cost=b ;
  }
  public int compareTo(News other){
    return this.num-other.num ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class reccommendations {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : OclFile ; x := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := x.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var newsarr : Sequence(News) ; newsarr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := x.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     newsarr[i+1] := News.newNews(arr[i+1], x.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    newsarr := newsarr->sort() ; 
    var total : long ; total := 0 ;
    var values : Sequence(int) ; values := Sequence{} ;
    var val : int ; val := 0 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i <= n do ( (     while (not(values->isEmpty()) & (i = n or newsarr[i+1].num > val)) do (     var max : int ; max := -values->min() ;
     total := total-(max) ; 
     sum := sum+(total) ; 
     val := val + 1 ) ; 
     if (i = n) then     break else skip ; 
    val := newsarr[i+1].num ; 
    values := values->including(-newsarr[i+1].cost) ; 
    total := total+(newsarr[i+1].cost) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}
class News implements Comparable<News> {
   attribute num : int;
   attribute cost : int;
   static operation newNews( a : int, b : int) : News
  pre: true
  post: true
  activity:
  ( var self : News ;
    self := createNews();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     num := a ; 
     cost := b );
   operation compareTo( other : News) : int
  pre: true
  post: true
  activity: (     return self.num - other.num );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class A {
  public static int power(Long a){
    int res=0 ;
    while(a>0){
      res++;
      a=a/10 ;
    }
    return res ;
  }
  public static long mult(Long a){
    int pow=power(a);
    long max=0 ;
    for(int j=0 ; j<pow ; ++j){
      max=max*10+9 ;
    }
    return a*(max-a);
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long l=in.nextLong();
    long r=in.nextLong();
    long res=0 ;
    long[] maxxes=new long[10];
    long temp=0 ;
    for(int i=0 ; i<10 ; ++i){
      temp=temp*10+9 ;
      maxxes[i]=temp/2*(temp-temp/2);
    }
    res=Math.max(mult(l),res);
    res=Math.max(mult(r),res);
    temp=0 ;
    for(int i=0 ; i<10 ; ++i){
      temp=temp*10+9 ;
      if(l<=temp/2 && temp/2<=r)res=Math.max(maxxes[i],res);
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation power( a : long) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     while (a > 0) do (     res := res + 1 ; 
     a := a / 10 ) ; 
     return res );
  static   operation mult( a : long) : long
  pre: true
  post: true
  activity: (     var pow : int ; pow := power(a) ;
     var max : long ; max := 0 ;
         var j : int ; j := 0 ; while j < pow do ( (     max := max * 10 + 9 )  ;     j := j + 1 ) ; 
     return a * (max - a) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : long ; l := in.getCurrent()->toLong() ;
    var r : long ; r := in.getCurrent()->toLong() ;
    var res : long ; res := 0 ;
    var maxxes : Sequence(long) ; maxxes := Integer.subrange(1,10)->collect(0) ;
    var temp : long ; temp := 0 ;
        var i : int ; i := 0 ; while i < 10 do ( (     temp := temp * 10 + 9 ; 
     maxxes[i+1] := temp / 2 * (temp - temp / 2) )  ;     i := i + 1 ) ; 
    res := Set{mult(l), res}->max() ; 
    res := Set{mult(r), res}->max() ; 
    temp := 0 ; 
        var i : int ; i := 0 ; while i < 10 do ( (     temp := temp * 10 + 9 ; 
     if (l <= temp / 2 & temp / 2 <= r) then     res := Set{maxxes[i+1], res}->max() ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    AizuFIbo solver=new AizuFIbo();
    solver.solve(1,in,out);
    out.close();
  }
  static class AizuFIbo {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      if(n==0 || n==1){
        out.println("1");
      }
      else {
        long[] a=new long[n+1];
        a[0]=1 ;
        a[1]=1 ;
        for(int i=2 ; i<=n ; i++){
          a[i]=a[i-1]+a[i-2];
        }
        out.printf("%d\n",a[n]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : AizuFIbo ; solver := AizuFIbo.newAizuFIbo() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class AizuFIbo {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0 or n = 1) then (     skip ) else (     var a : Sequence(long) ; a := Integer.subrange(1,n + 1)->collect(0) ;
     a[0+1] := 1 ; 
    a[1+1] := 1 ; 
        var i : int ; i := 2 ; while i <= n do ( (     a[i+1] := a[i - 1+1] + a[i - 2+1] )  ;     i := i + 1 ) ; 
    skip ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  private static HashMap<Integer,Integer>fibs=new HashMap<>();
  public static void main(String[] args){
    fibs.put(0,1);
    fibs.put(1,1);
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    System.out.println(fibonacci(n));
    in.close();
  }
  private static int fibonacci(int n){
    if(! fibs.containsKey(n)){
      fibs.put(n,fibonacci(n-1)+fibonacci(n-2));
    }
    return fibs.get(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute fibs : Map(int,int) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     fibs := fibs->union(Map{0 |-> 1}) ; 
     fibs := fibs->union(Map{1 |-> 1}) ; 
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    OclFile["System.out"].println(fibonacci(n)) ; 
    skip ; 
 );
  static   operation fibonacci( n : int) : int
  pre: true
  post: true
  activity: (     if (not(fibs->keys()->includes(n))) then (     fibs := fibs->union(Map{n |-> fibonacci(n - 1) + fibonacci(n - 2)}) ) else skip ; 
     return fibs->at(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  InputStream in=System.in ;
  PrintStream out=System.out ;
  public void _main(String[] args){
    Scanner sc=new Scanner(in);
    int n=sc.nextInt();
    sc.close();
    long[] dp=new long[100];
    dp[0]=1 ;
    dp[1]=1 ;
    for(int i=2 ; i<dp.length ; i++){
      dp[i]=dp[i-1]+dp[i-2];
    }
    out.println(dp[n]);
  }
  public static void main(String[] args){
    new Main()._main(args);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile["System.in"];
   attribute out : OclFile := OclFile["System.out"];
   operation _main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
    var dp : Sequence(long) ; dp := Integer.subrange(1,100)->collect(0) ;
    dp[0+1] := 1 ; 
    dp[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < dp->size() do ( (     dp[i+1] := dp[i - 1+1] + dp[i - 2+1] )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain()._main(args) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  static long fib(int n){
    if(n==0)return 1 ;
    else if(n==1)return 1 ;
    long val=2 ;
    long val_pre=1 ;
    long val_prepre=1 ;
    for(int i=2 ; i<n ; i++){
      val_prepre=val_pre ;
      val_pre=val ;
      val=val_pre+val_prepre ;
    }
    return val ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    System.out.println(fib(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation fib( n : int) : long
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else     if (n = 1) then     return 1 else skip ; ;  
     var val : long ; val := 2 ;
    var val_pre : long ; val_pre := 1 ;
    var val_prepre : long ; val_prepre := 1 ;
        var i : int ; i := 2 ; while i < n do ( (     val_prepre := val_pre ; 
     val_pre := val ; 
     val := val_pre + val_prepre )  ;     i := i + 1 ) ; 
    return val 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
     OclFile["System.out"].println(fib(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minDiff(int n,int x,int A[]){
    int mn=A[0],mx=A[0];
    for(int i=0 ; i<n ; ++i){
      mn=Math.min(mn,A[i]);
      mx=Math.max(mx,A[i]);
    }
    return Math.max(0,mx-mn-2*x);
  }
  public static void main(String[] args){
    int n=3,x=3 ;
    int A[]={1,3,6};
      System.out.println(minDiff(n,x,A));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minDiff( n : int, x : int, A : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var mn : int ; mn := A[0+1] ;
    var mx : int ; mx := A[0+1] ;
         var i : int ; i := 0 ; while i < n do ( (     mn := Set{mn, A[i+1]}->min() ; 
     mx := Set{mx, A[i+1]}->max() )  ;     i := i + 1 ) ; 
     return Set{0, mx - mn - 2 * x}->max() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
    var x : int ; x := 3 ;
     var A : Sequence(int) ; A := Sequence{1,3,6} ;
     OclFile["System.out"].println(minDiff(n, x, A)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findNthNum(int N){
    int bit_L=1,last_num=0 ;
    while(bit_L*(bit_L+1)/2<N){
      last_num=last_num+bit_L ;
      bit_L++;
    }
    int bit_R=N-last_num-1 ;
    System.out.print((1<<bit_L)+(1<<bit_R)+"\n");
  }
  public static void main(String[] args){
    int N=13 ;
    findNthNum(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNthNum( N : int) : void
  pre: true
  post: true
  activity: (     var bit_L : int ; bit_L := 1 ;
    var last_num : int ; last_num := 0 ;
     while (bit_L * (bit_L + 1) / 2 < N) do (     last_num := last_num + bit_L ; 
     bit_L := bit_L + 1 ) ; 
     var bit_R : int ; bit_R := N - last_num - 1 ;
     OclFile["System.out"].print(((1*(2->pow(bit_L)))->oclAsType(long)) + ((1*(2->pow(bit_R)))->oclAsType(long)) + "\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 13 ;
     execute findNthNum(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p036 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p036().run());
  }
  public String run(){
    long sum=0 ;
    for(int i=1 ; i<1000000 ; i++){
      if(Library.isPalindrome(Integer.toString(i,10))&& Library.isPalindrome(Integer.toString(i,2)))sum+=i ;
    }
    return Long.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
class p036 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p036.newp036().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var i : int ; i := 1 ; while i < 1000000 do ( (     if (Library.isPalindrome(((i) + "")) & Library.isPalindrome(((i) + ""))) then     sum := sum+(i) ; else skip )  ;     i := i + 1 ) ; 
     return ((sum) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    BigInteger MOD=new BigInteger("4294967311");
    while(sc.hasNextInt()){
      int n=sc.nextInt();
      BigInteger ans=BigInteger.ZERO ;
      for(int i=0 ; i<n ; i++){
        int o=sc.nextInt();
        BigInteger y=sc.nextBigInteger();
        if(o==1){
          ans=ans.add(y).mod(MOD);
        }
        else if(o==2){
          ans=ans.add(MOD).subtract(y).mod(MOD);
        }
        else if(o==3){
          ans=ans.multiply(y).mod(MOD);
        }
        else if(o==4){
          ans=ans.multiply(y.modInverse(MOD)).mod(MOD);
        }
      }
      BigInteger tmp=new BigInteger(Long.toString(1L<<31));
      if(ans.compareTo(tmp)>=0){
        ans=ans.subtract(MOD);
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var MOD : long ; MOD := long("4294967311") ;
     while (sc.hasNextInt()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var o : int ; o := sc.getCurrent()->toInteger() ;
     var y : long ; y := sc.nextBigInteger() ;
     if (o = 1) then (     ans := ans->excludes(y).mod(MOD) ) else     if (o = 2) then (     ans := ans->excludes(MOD).subtract(y).mod(MOD) ) else     if (o = 3) then (     ans := ans.multiply(y).mod(MOD) ) else     if (o = 4) then (     ans := ans.multiply(y.modInverse(MOD)).mod(MOD) ) else skip ; ;  ;  )  ;     i := i + 1 ) ; 
    var tmp : long ; tmp := long((((1L*(2->pow(31)))->oclAsType(long)) + "")) ;
    if (ans->compareTo(tmp) >= 0) then (     ans := ans.subtract(MOD) ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] o=new int[n];
    int[] y=new int[n];
    BigInteger x=new BigInteger("0");
    BigInteger p=new BigInteger("4294967311");
    BigInteger d=new BigInteger("2147483648");
    for(int i=0 ; i<n ; ++i){
      o[i]=in.nextInt();
      y[i]=in.nextInt();
    }
    for(int i=0 ; i<n ; ++i){
      int oo=o[i];
      BigInteger yy=new BigInteger(String.valueOf(y[i]));
      if(oo==1){
        x=x.add(yy);
      }
      else if(oo==2){
        x=x.subtract(yy);
      }
      else if(oo==3){
        x=x.multiply(yy);
      }
      else if(oo==4){
        x=x.multiply(yy.modInverse(p));
      }
      x=x.mod(p);
    }
    if(x.compareTo(d)==-1)System.out.println(x);
    else System.out.println(x.subtract(p));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var o : Sequence(int) ; o := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
    var x : long ; x := long("0") ;
    var p : long ; p := long("4294967311") ;
    var d : long ; d := long("2147483648") ;
        var i : int ; i := 0 ; while i < n do ( (     o[i+1] := in.getCurrent()->toInteger() ; 
     y[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var oo : int ; oo := o[i+1] ;
     var yy : long ; yy := long(((y[i+1]) + "")) ;
     if (oo = 1) then (     x := x->excludes(yy) ) else     if (oo = 2) then (     x := x.subtract(yy) ) else     if (oo = 3) then (     x := x.multiply(yy) ) else     if (oo = 4) then (     x := x.multiply(yy.modInverse(p)) ) else skip ; ;  ;  ;  
     x := x.mod(p) )  ;     i := i + 1 ) ; 
    if (x->compareTo(d) = -1) then     OclFile["System.out"].println(x) else     OclFile["System.out"].println(x.subtract(p)) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  static boolean checkPerfectcube(int n){
    int d=(int)Math.cbrt(n);
    if(d*d*d==n)return true ;
    return false ;
  }
  static int largestPerfectcubeNumber(int a[],int n){
    int maxi=-1 ;
    for(int i=0 ; i<n ; i++){
      if(checkPerfectcube(a[i]))maxi=Math.max(a[i],maxi);
    }
    return maxi ;
  }
  public static void main(String args[]){
    int a[]={
      16,64,25,2,3,10 };
      int n=a.length ;
      System.out.print(largestPerfectcubeNumber(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class Solution {
  static   operation checkPerfectcube( n : int) : boolean
  pre: true
  post: true
  activity: (     var d : int ; d := (n)->cbrt()->oclAsType(int) ;
     if (d * d * d = n) then     return true else skip ; 
     return false );
  static   operation largestPerfectcubeNumber( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var maxi : int ; maxi := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (checkPerfectcube(a[i+1])) then     maxi := Set{a[i+1], maxi}->max() ; else skip )  ;     i := i + 1 ) ; 
     return maxi );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{16,64,25,2,3,10} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(largestPerfectcubeNumber(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String...args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    printArray(a);
    for(int i=1 ; i<n ; i++){
      int key=a[i];
      int j=i-1 ;
      while(j>=0 && a[j]>key){
        a[j+1]=a[j];
        j--;
      }
      a[j+1]=key ;
      printArray(a);
    }
  }
  public static void printArray(int[] a){
    for(int i=0 ; i<a.length-1 ; i++){
      System.out.print(a[i]+" ");
    }
    System.out.println(a[a.length-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute printArray(a) ; 
        var i : int ; i := 1 ; while i < n do ( (     var key : int ; key := a[i+1] ;
     var j : int ; j := i - 1 ;
    while (j >= 0 & a[j+1] > key) do (     a[j + 1+1] := a[j+1] ; 
     j := j - 1 ) ; 
    a[j + 1+1] := key ; 
    execute printArray(a) ; 
 )  ;     i := i + 1 ) ; 
 );
  static   operation printArray( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < a->size() - 1 do ( (     OclFile["System.out"].print(a[i+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(a[a->size() - 1+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int N=scn.nextInt();
    int M=scn.nextInt();
    boolean[] exists1toi=new boolean[N+1];
    Arrays.fill(exists1toi,false);
    boolean[] existsitoN=new boolean[N+1];
    Arrays.fill(existsitoN,false);
    for(int i=0 ; i<M ; i++){
      int a=scn.nextInt();
      int b=scn.nextInt();
      if(a==1){
        exists1toi[b]=true ;
      }
      if(b==1){
        exists1toi[a]=true ;
      }
      if(a==N){
        existsitoN[b]=true ;
      }
      if(b==N){
        existsitoN[a]=true ;
      }
    }
    boolean ans=false ;
    for(int i=1 ; i<=N ; i++){
      if(exists1toi[i] && existsitoN[i]){
        ans=true ;
      }
    }
    if(ans){
      System.out.println("POSSIBLE");
    }
    else {
      System.out.println("IMPOSSIBLE");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scn.getCurrent()->toInteger() ;
    var M : int ; M := scn.getCurrent()->toInteger() ;
    var exists1toi : Sequence(boolean) ; exists1toi := Integer.subrange(1,N + 1)->collect(false) ;
    exists1toi := exists1toi->collect(false) ; 
    var existsitoN : Sequence(boolean) ; existsitoN := Integer.subrange(1,N + 1)->collect(false) ;
    existsitoN := existsitoN->collect(false) ; 
        var i : int ; i := 0 ; while i < M do ( (     var a : int ; a := scn.getCurrent()->toInteger() ;
     var b : int ; b := scn.getCurrent()->toInteger() ;
    if (a = 1) then (     exists1toi[b+1] := true ) else skip ; 
    if (b = 1) then (     exists1toi[a+1] := true ) else skip ; 
    if (a = N) then (     existsitoN[b+1] := true ) else skip ; 
    if (b = N) then (     existsitoN[a+1] := true ) else skip ; 
 )  ;     i := i + 1 ) ; 
    var ans : boolean ; ans := false ;
        var i : int ; i := 1 ; while i <= N do ( (     if (exists1toi[i+1] & existsitoN[i+1]) then (     ans := true ) else skip )  ;     i := i + 1 ) ; 
    if (ans) then (     OclFile["System.out"].println("POSSIBLE") ) else (     OclFile["System.out"].println("IMPOSSIBLE") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  private static final String POSSIBLE="POSSIBLE" ;
  private static final String IMPOSSSIBLE="IMPOSSIBLE" ;
  public static void main(String[] args){
    new Main().execute();
  }
  public void execute(){
    Scanner sc=new Scanner(System.in);
    final int N=sc.nextInt();
    final int M=sc.nextInt();
    HashSet<Integer>fromOne=new HashSet<>();
    HashSet<Integer>toN=new HashSet<>();
    for(int i=0 ; i<M ; i++){
      int ai=sc.nextInt();
      int bi=sc.nextInt();
      if(ai==1){
        fromOne.add(bi);
      }
      if(bi==N){
        toN.add(ai);
      }
    }
    sc.close();
    for(Integer n : fromOne){
      if(toN.contains(n)){
        System.out.println(POSSIBLE);
        return ;
      }
    }
    System.out.println(IMPOSSSIBLE);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute POSSIBLE : String := "POSSIBLE";
  static    attribute IMPOSSSIBLE : String := "IMPOSSIBLE";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().execute() );
   operation execute() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var fromOne : Set(int) ; fromOne := Set{} ;
    var toN : Set(int) ; toN := Set{} ;
        var i : int ; i := 0 ; while i < M do ( (     var ai : int ; ai := sc.getCurrent()->toInteger() ;
     var bi : int ; bi := sc.getCurrent()->toInteger() ;
     if (ai = 1) then (     fromOne := fromOne->including(bi) ) else skip ; 
     if (bi = N) then (     toN := toN->including(ai) ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    for (n : fromOne) do ( (     if (toN->includes(n)) then (     OclFile["System.out"].println(POSSIBLE) ; 
     return ) else skip )  ) ; 
    OclFile["System.out"].println(IMPOSSSIBLE) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int target,num ;
    String str=br.readLine();
    StringTokenizer st=new StringTokenizer(str);
    target=Integer.parseInt(st.nextToken());
    num=Integer.parseInt(st.nextToken());
    boolean A[]=new boolean[200001];
    boolean B[]=new boolean[200001];
    Arrays.fill(A,false);
    Arrays.fill(B,false);
    for(int i=0 ; i<num ; i++){
      int tmp1,tmp2 ;
      str=br.readLine();
      st=new StringTokenizer(str);
      tmp1=Integer.parseInt(st.nextToken());
      tmp2=Integer.parseInt(st.nextToken());
      if(tmp1==1){
        A[tmp2]=true ;
      }
      else if(tmp2==target){
        B[tmp1]=true ;
      }
    }
    for(int i=0 ; i<=200000 ; i++){
      if(A[i] && B[i]){
        System.out.println("POSSIBLE");
        return ;
      }
    }
    System.out.println("IMPOSSIBLE");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var target : int ;
    var num : int ;
    var str : String ; str := br.readLine() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(str) ;
    target := (st.next())->toInteger() ; 
    num := (st.next())->toInteger() ; 
    var A : Sequence(boolean) ; A := Integer.subrange(1,200001)->collect(false) ;
    var B : Sequence(boolean) ; B := Integer.subrange(1,200001)->collect(false) ;
    A := A->collect(false) ; 
    B := B->collect(false) ; 
        var i : int ; i := 0 ; while i < num do ( (     var tmp1 : int ;
    var tmp2 : int ;
     str := br.readLine() ; 
    st := OclIterator.newOclIterator_String(str) ; 
    tmp1 := (st.next())->toInteger() ; 
    tmp2 := (st.next())->toInteger() ; 
    if (tmp1 = 1) then (     A[tmp2+1] := true ) else     if (tmp2 = target) then (     B[tmp1+1] := true ) else skip ; ;  
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= 200000 do ( (     if (A[i+1] & B[i+1]) then (     OclFile["System.out"].println("POSSIBLE") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("IMPOSSIBLE") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int m=Integer.parseInt(sc.next());
    HashMap<Integer,Boolean>map=new HashMap<Integer,Boolean>();
    boolean flg=false ;
    for(int i=0 ; i<m ; i++){
      int a=Integer.parseInt(sc.next());
      int b=Integer.parseInt(sc.next());
      if(a==1){
        if(map.containsKey(b)){
          flg=true ;
          break ;
        }
        map.put(b,true);
      }
      if(b==n){
        if(map.containsKey(a)){
          flg=true ;
          break ;
        }
        map.put(a,true);
      }
    }
    System.out.println(flg ? "POSSIBLE" : "IMPOSSIBLE");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var m : int ; m := (sc.getCurrent())->toInteger() ;
    var map : Map(int,Boolean) ; map := Map{} ;
    var flg : boolean ; flg := false ;
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := (sc.getCurrent())->toInteger() ;
     var b : int ; b := (sc.getCurrent())->toInteger() ;
     if (a = 1) then (     if (map->keys()->includes(b)) then (     flg := true ; 
     break ) else skip ; 
     map := map->union(Map{b |-> true}) ) else skip ; 
     if (b = n) then (     if (map->keys()->includes(a)) then (     flg := true ; 
     break ) else skip ; 
     map := map->union(Map{a |-> true}) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if flg then "POSSIBLE" else "IMPOSSIBLE" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int a ;
    int b ;
    HashSet<Integer>hashFirstTo=new HashSet<Integer>();
    HashSet<Integer>hashSecondFrom=new HashSet<Integer>();
    boolean possible=false ;
    for(int i=0 ; i<M ; i++){
      a=sc.nextInt();
      b=sc.nextInt();
      if(a==1){
        hashFirstTo.add(b);
      }
      else if(b==N){
        hashSecondFrom.add(a);
      }
    }
    for(int firstTo : hashFirstTo){
      if(hashSecondFrom.contains(firstTo)){
        possible=true ;
        break ;
      }
    }
    if(possible==true){
      System.out.println("POSSIBLE");
    }
    else {
      System.out.println("IMPOSSIBLE");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var a : int ;
    var b : int ;
    var hashFirstTo : Set(int) ; hashFirstTo := Set{} ;
    var hashSecondFrom : Set(int) ; hashSecondFrom := Set{} ;
    var possible : boolean ; possible := false ;
        var i : int ; i := 0 ; while i < M do ( (     a := sc.getCurrent()->toInteger() ; 
     b := sc.getCurrent()->toInteger() ; 
     if (a = 1) then (     hashFirstTo := hashFirstTo->including(b) ) else     if (b = N) then (     hashSecondFrom := hashSecondFrom->including(a) ) else skip ; )  ;     i := i + 1 ) ; 
    for (firstTo : hashFirstTo) do ( (     if (hashSecondFrom->includes(firstTo)) then (     possible := true ; 
     break ) else skip )  ) ; 
    if (possible = true) then (     OclFile["System.out"].println("POSSIBLE") ) else (     OclFile["System.out"].println("IMPOSSIBLE") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int MinimumCost(int cost[],int n,int W){
    Vector<Integer>val=new Vector<Integer>();
    Vector<Integer>wt=new Vector<Integer>();
    int size=0 ;
    for(int i=0 ; i<n ; i++){
      if(cost[i]!=-1){
        val.add(cost[i]);
        wt.add(i+1);
        size++;
      }
    }
    n=size ;
    int min_cost[][]=new int[n+1][W+1];
    for(int i=0 ; i<=W ; i++)min_cost[0][i]=Integer.MAX_VALUE ;
    for(int i=1 ; i<=n ; i++)min_cost[i][0]=0 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=W ; j++){
        if(wt.get(i-1)>j)min_cost[i][j]=min_cost[i-1][j];
        else min_cost[i][j]=Math.min(min_cost[i-1][j],min_cost[i][j-wt.get(i-1)]+val.get(i-1));
      }
    }
    return(min_cost[n][W]==Integer.MAX_VALUE)?-1 : min_cost[n][W];
  }
  public static void main(String[] args){
    int cost[]={
      1,2,3,4,5 },W=5 ;
      int n=cost.length ;
      System.out.println(MinimumCost(cost,n,W));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MinimumCost( cost : Sequence(int), n : int, W : int) : int
  pre: true
  post: true
  activity: (     var val : Sequence(int) ; val := Sequence{} ;
     var wt : Sequence(int) ; wt := Sequence{} ;
    var size : int ; size := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (cost[i+1] /= -1) then (     val := val->including(cost[i+1]) ; 
     wt := wt->including(i + 1) ; 
     size := size + 1 ) else skip )  ;     i := i + 1 ) ; 
    n := size ; 
    var min_cost : Sequence(Sequence(int)) ; min_cost := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,W + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i <= W do (     min_cost[0+1][i+1] := 2147483647 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (     min_cost[i+1][0+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= W do ( (     if (wt->at(i - 1+1) > j) then     min_cost[i+1][j+1] := min_cost[i - 1+1][j+1] ; else     min_cost[i+1][j+1] := Set{min_cost[i - 1+1][j+1], min_cost[i+1][j - wt->at(i - 1+1)+1] + val->at(i - 1+1)}->min() ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return if (min_cost[n+1][W+1] = 2147483647) then -1 else min_cost[n+1][W+1] endif 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cost : Sequence(int) ; cost := Sequence{1,2,3,4,5} ;
    var W : int ; W := 5 ;
     var n : int ; n := cost->size() ;
     OclFile["System.out"].println(MinimumCost(cost, n, W)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import static java.lang.Math.*;
class Quadratic {
  void findRoots(int a,int b,int c){
    if(a==0){
      System.out.println("Invalid");
      return ;
    }
    int d=b*b-4*a*c ;
    double sqrt_val=sqrt(abs(d));
    if(d>0){
      System.out.println("Roots are real and different \n");
      System.out.println((double)(-b+sqrt_val)/(2*a)+"\n"+(double)(-b-sqrt_val)/(2*a));
    }
    else {
      System.out.println("Roots are complex \n");
      System.out.println(-(double)b/(2*a)+"+i"+sqrt_val+"\n"+-(double)b/(2*a)+"-i"+sqrt_val);
    }
  }
  public static void main(String args[]){
    Quadratic obj=new Quadratic();
    int a=1,b=-7,c=12 ;
    obj.findRoots(a,b,c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Quadratic {
   operation findRoots( a : int, b : int, c : int) : void
  pre: true
  post: true
  activity: (     if (a = 0) then (     OclFile["System.out"].println("Invalid") ; 
     return ) else skip ; 
     var d : int ; d := b * b - 4 * a * c ;
     var sqrt_val : double ; sqrt_val := sqrt(abs(d)) ;
     if (d > 0) then (     OclFile["System.out"].println("Roots are real and different \n") ; 
     OclFile["System.out"].println((-b + sqrt_val)->oclAsType(double) / (2 * a) + "\n" + (-b - sqrt_val)->oclAsType(double) / (2 * a)) ) else (     OclFile["System.out"].println("Roots are complex \n") ; 
     OclFile["System.out"].println(-b->oclAsType(double) / (2 * a) + "+i" + sqrt_val + "\n" + -b->oclAsType(double) / (2 * a) + "-i" + sqrt_val) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Quadratic ; obj := Quadratic.newQuadratic() ;
     var a : int ; a := 1 ;
    var b : int ; b := -7 ;
    var c : int ; c := 12 ;
     obj.findRoots(a, b, c) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Card {
  String mark ;
  int num,flag ;
  public Card(String str,int n,int f){
    mark=str ;
    num=n ;
    flag=f ;
  }
  public void Show(){
    System.out.println(mark+" "+num);
  }
}
public class Main {
  static Card[] card=new Card[100001];
  static Card swap ;
  public static int partation(int p,int r){
    int x=card[r] .num ;
    int i=p-1 ;
    for(int j=p ; j<r ; j++){
      if(card[j] .num<=x){
        i=i+1 ;
        swap=card[i];
        card[i]=card[j];
        card[j]=swap ;
      }
    }
    swap=card[i+1];
    card[i+1]=card[r];
    card[r]=swap ;
    return i+1 ;
  }
  public static void quicksort(int p,int r){
    int q ;
    if(p<r){
      q=partation(p,r);
      quicksort(p,q-1);
      quicksort(q+1,r);
    }
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int i,n,f=0 ;
    n=scan.nextInt();
    for(i=0 ; i<n ; i++){
      card[i]=new Card(scan.next(),scan.nextInt(),i);
    }
    quicksort(0,n-1);
    for(i=0 ; i<n-1 ; i++){
      if(card[i] .num==card[i+1] .num && card[i] .flag>card[i+1] .flag){
        f=1 ;
        break ;
      }
    }
    if(f==0){
      System.out.println("Stable");
    }
    else {
      System.out.println("Not stable");
    }
    for(i=0 ; i<n ; i++){
      card[i] .Show();
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Card {
   attribute mark : String;
   attribute num : int;
   static operation newCard( str : String, n : int, f : int) : Card
  pre: true
  post: true
  activity:
  ( var self : Card ;
    self := createCard();
    self.initialise(str, n,f);
    return self );
  operation initialise( str : String, n : int, f : int) : void
  pre: true  post: true
  activity: (     mark := str ; 
     num := n ; 
     flag := f );
   operation Show() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(mark + " " + num) );
}
class Main {
  static   attribute card : Sequence(Card) := Integer.subrange(1,100001)->collect(null);
  static   attribute swap : Card;
  static   operation partation( p : int, r : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := card[r+1].num ;
     var i : int ; i := p - 1 ;
        var j : int ; j := p ; while j < r do ( (     if (card[j+1].num <= x) then (     i := i + 1 ; 
     swap := card[i+1] ; 
     card[i+1] := card[j+1] ; 
     card[j+1] := swap ) else skip )  ;     j := j + 1 ) ; 
    swap := card[i + 1+1] ; 
    card[i + 1+1] := card[r+1] ; 
    card[r+1] := swap ; 
    return i + 1 
 );
  static   operation quicksort( p : int, r : int) : void
  pre: true
  post: true
  activity: (     var q : int ;
     if (p < r) then (     q := partation(p, r) ; 
     execute quicksort(p, q - 1) ; 
     execute quicksort(q + 1, r) ) else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ;
    var n : int ;
    var f : int ; f := 0 ;
    n := scan.getCurrent()->toInteger() ; 
        i := 0 ; while i < n do ( (     card[i+1] := Card.newCard(scan.getCurrent(), scan.getCurrent()->toInteger(), i) )  ;     i := i + 1 ) ; 
    execute quicksort(0, n - 1) ; 
        i := 0 ; while i < n - 1 do ( (     if (card[i+1].num = card[i + 1+1].num & card[i+1].flag > card[i + 1+1].flag) then (     f := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (f = 0) then (     OclFile["System.out"].println("Stable") ) else (     OclFile["System.out"].println("Not stable") ) ;  
        i := 0 ; while i < n do ( (     card[i+1].Show() )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Round0B {
  int cases ;
  int count(String stack){
    int flips=0 ;
    for(int n=1 ; n<stack.length(); n++){
      if(stack.charAt(n-1)!=stack.charAt(n))flips++;
    }
    return flips ;
  }
  void process(Scanner scanner,PrintStream out)throws IOException {
    cases=scanner.nextInt();
    scanner.nextLine();
    for(int curCase=0 ; curCase<cases ; curCase++){
      String stack=scanner.nextLine().trim();
      out.println("Case #"+(curCase+1)+": "+count(stack+"+"));
    }
  }
  Round0B()throws IOException {
    Scanner in=new Scanner(new File("C:\\Users\\Olaf\\Downloads\\B-large.in"));
    PrintStream out=new PrintStream("out-B-large.txt");
    process(in,out);
    in.close();
    out.close();
  }
  public static void main(String[] args)throws IOException {
    new Round0B();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Round0B {
   attribute cases : int;
   operation count( stack : String) : int
  pre: true
  post: true
  activity: (     var flips : int ; flips := 0 ;
         var n : int ; n := 1 ; while n < stack->size() do ( (     if (stack->at(n - 1+1) /= stack->at(n+1)) then     flips := flips + 1 ; else skip )  ;     n := n + 1 ) ; 
     return flips );
   operation process( scanner : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     cases := scanner.nextInt() ; 
     scanner.nextLine() ; 
         var curCase : int ; curCase := 0 ; while curCase < cases do ( (     var stack : String ; stack := scanner.nextLine()->trim() ;
     out.println("Case #" + (curCase + 1) + ": " + count(stack + "+")) )  ;     curCase := curCase + 1 ) );
   static operation newRound0B() : Round0B
  pre: true
  post: true
  activity:
  ( var self : Round0B ;
    self := createRound0B();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("C:\\Users\\Olaf\\Downloads\\B-large.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("out-B-large.txt")) ;
    execute process(in, out) ; 
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Round0B.newRound0B() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package lab6zp ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Lab6ZP {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    Scanner sin=new Scanner(System.in);
    int n=Integer.parseInt(sin.next());
    for(int i=0 ; i<n ; i++){
      String s=sin.next();
      s+='+' ;
      int counter=0 ;
      for(int j=0 ; j<s.length()-1 ; j++){
        if(s.charAt(j)!=s.charAt(j+1)){
          counter++;
        }
      }
      System.out.println("Case #"+(i+1)+": "+counter);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Lab6ZP {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sin : OclFile ; sin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sin.getCurrent())->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sin.getCurrent() ;
     s := s+('+') ; 
    var counter : int ; counter := 0 ;
        var j : int ; j := 0 ; while j < s->size() - 1 do ( (     if (s->at(j+1) /= s->at(j + 1+1)) then (     counter := counter + 1 ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println("Case #" + (i + 1) + ": " + counter) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static final int BIG_NUM=2000000000 ;
  public static final int MOD=1000000007 ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int array[]=new int[N];
    for(int i=0 ; i<N ; i++){
      array[i]=scanner.nextInt();
    }
    out_put(array);
    int base,loc ;
    for(int i=1 ; i<N ; i++){
      base=array[i];
      loc=i-1 ;
      while(loc>=0 && array[loc]>base){
        array[loc+1]=array[loc];
        loc--;
      }
      array[loc+1]=base ;
      out_put(array);
    }
  }
  private static void out_put(int array[]){
    int i ;
    for(i=0 ; i<array.length-1 ; i++){
      System.out.print(array[i]+" ");
    }
    System.out.println(array[i]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BIG_NUM : int := 2000000000;
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     array[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute out_put(array) ; 
    var base : int ;
    var loc : int ;
        var i : int ; i := 1 ; while i < N do ( (     base := array[i+1] ; 
     loc := i - 1 ; 
    while (loc >= 0 & array[loc+1] > base) do (     array[loc + 1+1] := array[loc+1] ; 
     loc := loc - 1 ) ; 
    array[loc + 1+1] := base ; 
    execute out_put(array) ; 
 )  ;     i := i + 1 ) ; 
 );
  static   operation out_put( array : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var i : int ;
         i := 0 ; while i < array->size() - 1 do ( (     OclFile["System.out"].print(array[i+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(array[i+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package gcj2016.qualif ;
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.logging.Level ;
import java.util.logging.Logger ;
public class ExoB {
  public static void main(final String[] args){
    final String base="/home/jfortin/workspace-gcj/Codejam2016/q/ExoB/" ;
    final String input=base+"b1.in" ;
    final String output=base+"b1.out" ;
    try {
      final Scanner sc=new Scanner(new FileReader(input));
      final PrintWriter pw=new PrintWriter(output);
      final int n=sc.nextInt();
      sc.nextLine();
      for(int c=0 ; c<n ; c++){
        System.out.println("Test case "+(c+1)+"...");
        pw.print("Case #"+(c+1)+": ");
        test(sc,pw);
        pw.println();
      }
      pw.println();
      pw.flush();
      pw.close();
      sc.close();
    }
    catch(final FileNotFoundException ex){
      Logger.getLogger(ExoB.class.getName()).log(Level.SEVERE,null,ex);
    }
  }
  private static void test(final Scanner sc,final PrintWriter pw){
    String in=sc.next();
    System.out.println(in);
    int i=count(in,in.length(),'+');
    pw.print(i);
  }
  private static int count(final String in,final int length,final char c){
    if(length==0){
      return 0 ;
    }
    if(in.charAt(length-1)==c){
      return count(in,length-1,c);
    }
    else {
      return 1+count(in,length-1,c=='+' ? '-' : '+');
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ExoB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var base : String ; base := "/home/jfortin/workspace-gcj/Codejam2016/q/ExoB/" ;
     var input : String ; input := base + "b1.in" ;
     var output : String ; output := base + "b1.out" ;
     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(input))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile(output)) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
        var c : int ; c := 0 ; while c < n do ( (     OclFile["System.out"].println("Test case " + (c + 1) + "...") ; 
     skip ; 
     execute test(sc, pw) ; 
     skip )  ;     c := c + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 )   catch (ex : FileNotFoundException) do (     Logger.getLogger(OclType["ExoB"].getName()).log(Level.SEVERE, null, ex) )
 );
  static   operation test( sc : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var in : String ; in := sc.getCurrent() ;
     OclFile["System.out"].println(in) ; 
     var i : int ; i := count(in, in->size(), '+') ;
     skip );
  static   operation count( in : String, length : int, c : String) : int
  pre: true
  post: true
  activity: (     if (length = 0) then (     return 0 ) else skip ; 
     if (in->at(length - 1+1) = c) then (     return count(in, length - 1, c) ) else (     return 1 + count(in, length - 1, if c = '+' then '-' else '+' endif) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
public class B {
  static BufferedReader br ;
  static StringTokenizer st ;
  static PrintWriter pw ;
  public static void main(String[] args)throws Exception {
    br=new BufferedReader(new InputStreamReader(System.in));
    pw=new PrintWriter(new BufferedWriter(new FileWriter("b.out")));
    final int MAX_CASES=readInt();
    for(int casenum=1 ; casenum<=MAX_CASES ; casenum++){
      pw.printf("Case #%d: ",casenum);
      String s=nextToken();
      boolean[] good=new boolean[s.length()];
      int ret=0 ;
      boolean last=true ;
      for(int i=0 ; i<good.length ; i++){
        good[i]=s.charAt(i)=='+' ;
        if(i>0 && last!=good[i]){
          ret++;
        }
        last=good[i];
      }
      if(! last)ret++;
      pw.println(ret);
    }
    pw.close();
  }
  public static int readInt(){
    return Integer.parseInt(nextToken());
  }
  public static long readLong(){
    return Long.parseLong(nextToken());
  }
  public static double readDouble(){
    return Double.parseDouble(nextToken());
  }
  public static String nextToken(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        if(! br.ready()){
          pw.close();
          System.exit(0);
        }
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        System.err.println(e);
        System.exit(1);
      }
    }
    return st.nextToken();
  }
  public static String readLine(){
    st=null ;
    try {
      return br.readLine();
    }
    catch(IOException e){
      System.err.println(e);
      System.exit(1);
      return null ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute br : OclFile;
  static   attribute st : OclIterator;
  static   attribute pw : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("b.out")))) ; 
    var MAX_CASES : int ; MAX_CASES := readInt() ;
        var casenum : int ; casenum := 1 ; while casenum <= MAX_CASES do ( (     skip ; 
     var s : String ; s := nextToken() ;
    var good : Sequence(boolean) ; good := Integer.subrange(1,s->size())->collect(false) ;
    var ret : int ; ret := 0 ;
    var last : boolean ; last := true ;
        var i : int ; i := 0 ; while i < good->size() do ( (     good[i+1] := s->at(i+1) = '+' ; 
     if (i > 0 & last /= good[i+1]) then (     ret := ret + 1 ) else skip ; 
     last := good[i+1] )  ;     i := i + 1 ) ; 
    if (not(last)) then     ret := ret + 1 ; else skip ; 
    skip ; 
 )  ;     casenum := casenum + 1 ) ; 
    skip ; 
 );
  static   operation readInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
  static   operation readLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
  static   operation readDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
  static   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     if (not(br.canRead())) then (     skip ; 
 OclProcess.exit(0) ) else skip ; 
     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     OclFile["System.err"].println(e) ; 
 OclProcess.exit(1) )
 ) ; 
     return st.next() );
  static   operation readLine() : String
  pre: true
  post: true
  activity: (     st := null ; 
     try (     return br.readLine() )   catch (e : IOException) do (     OclFile["System.err"].println(e) ; 
 OclProcess.exit(1) ; 
     return null )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class revengepancake {
  private static InputReader in ;
  private static PrintWriter out ;
  public static boolean SUBMIT=true ;
  public static final String NAME="B-large" ;
  private static void main2()throws IOException {
    char[] s=in.next().toCharArray();
    int n=s.length ;
    int count=0 ;
    for(int i=1 ; i<n ; i++){
      if(s[i]!=s[i-1])count++;
    }
    if(s[n-1]=='-')count++;
    out.println(count);
  }
  public static void main(String[] args)throws IOException {
    if(SUBMIT){
      in=new InputReader(new FileInputStream(new File(NAME+".in")));
      out=new PrintWriter(new BufferedWriter(new FileWriter(NAME+".out")));
    }
    else {
      in=new InputReader(System.in);
      out=new PrintWriter(System.out,true);
    }
    int numCases=in.nextInt();
    for(int test=1 ; test<=numCases ; test++){
      out.print("Case #"+test+": ");
      main2();
    }
    out.close();
    System.exit(0);
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class revengepancake {
  static   attribute in : InputReader;
  static   attribute out : OclFile;
  static   attribute SUBMIT : boolean := true;
  static    attribute NAME : String := "B-large";
  static   operation main2() : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := in.next()->characters() ;
     var n : int ; n := s->size() ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (s[i+1] /= s[i - 1+1]) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (s[n - 1+1] = '-') then     count := count + 1 ; else skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (SUBMIT) then (     in := InputReader.newInputReader(OclFile.newOclFile_Read(OclFile(NAME + ".in"))) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(NAME + ".out"))) ) else (     in := InputReader.newInputReader(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"], true) ) ;  
     var numCases : int ; numCases := in.nextInt() ;
        var test : int ; test := 1 ; while test <= numCases do ( (     skip ; 
     execute main2() )  ;     test := test + 1 ) ; 
    skip ; 
OclProcess.exit(0) ; 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printCombination(int n){
    System.out.print(1+" ");
    if((n-2)% 3==0)System.out.print(2+" "+(n-3));
    else System.out.print(1+" "+(n-2));
  }
  public static void main(String[] args){
    int n=233 ;
    printCombination(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printCombination( n : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(1 + " ") ; 
     if ((n - 2) mod 3 = 0) then     OclFile["System.out"].print(2 + " " + (n - 3)) ; else     OclFile["System.out"].print(1 + " " + (n - 2)) ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 233 ;
     execute printCombination(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Node {
  static boolean checkUnimodal(int arr[],int n){
    int i=1 ;
    while(i<n && arr[i]>arr[i-1])++i ;
    while(i<n && arr[i]==arr[i-1])++i ;
    while(i<n && arr[i]<arr[i-1])++i ;
    return(i==n);
  }
  public static void main(String[] args){
    int arr[]={
      1,5,5,5,4,2 };
      int n=arr.length ;
      if(checkUnimodal(arr,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Node {
  static   operation checkUnimodal( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ; i := 1 ;
     while (i < n & arr[i+1] > arr[i - 1+1]) do     i := i + 1 ; ; 
    while (i < n & arr[i+1] = arr[i - 1+1]) do     i := i + 1 ; ; 
    while (i < n & arr[i+1] < arr[i - 1+1]) do     i := i + 1 ; ; 
    return (i = n) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,5,5,4,2} ;
     var n : int ; n := arr->size() ;
     if (checkUnimodal(arr, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] a=new long[n+1];
    for(int i=1 ; i<=n ; i++){
      a[i]=a[i-1]+sc.nextLong();
    }
    long min=Long.MAX_VALUE ;
    for(int i=1 ; i<n ; i++){
      min=Math.min(Math.abs(a[i]-a[0]-a[n]+a[i]),min);
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := a[i - 1+1] + sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var min : long ; min := "9223372036854775807"->toLong() ;
        var i : int ; i := 1 ; while i < n do ( (     min := Set{if a[i+1] - a[0+1] - a[n+1] + a[i+1] < 0 then -(a[i+1] - a[0+1] - a[n+1] + a[i+1]) else a[i+1] - a[0+1] - a[n+1] + a[i+1] endif, min}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String args[]){
    ConsoleScanner cin=new ConsoleScanner();
    PrintWriter cout=new PrintWriter(System.out);
    solve(cin,cout);
    cout.flush();
  }
  private static void solve(ConsoleScanner cin,PrintWriter cout){
    int n=cin.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<a.length ; i++)a[i]=cin.nextInt();
    long ans=solve(n,a);
    cout.println(ans);
  }
  private static long solve(int n,long[] a){
    long ans=Long.MAX_VALUE ;
    long sum=Arrays.stream(a).sum();
    long x=0 ;
    long y=sum ;
    for(int i=0 ; i<a.length-1 ; i++){
      x+=a[i];
      y-=a[i];
      ans=Math.min(ans,Math.abs(x-y));
    }
    return ans ;
  }
  static class ConsoleScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      try {
        while(! st.hasMoreElements())st=new StringTokenizer(br.readLine());
        return st.nextToken();
      }
      catch(IOException e){
        throw new AssertionError(e);
      }
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : ConsoleScanner ; cin := ConsoleScanner.newConsoleScanner() ;
     var cout : OclFile ; cout := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     execute solve(cin, cout) ; 
     skip );
  static   operation solve( cin : ConsoleScanner, cout : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := cin.nextInt() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := cin.nextInt() ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := solve(n, a) ;
    skip ; 
 );
  static   operation solve( n : int, a : Sequence(long)) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := "9223372036854775807"->toLong() ;
     var sum : long ; sum := stream(a)->sum() ;
    var x : long ; x := 0 ;
    var y : long ; y := sum ;
        var i : int ; i := 0 ; while i < a->size() - 1 do ( (     x := x+(a[i+1]) ; 
     y := y-(a[i+1]) ; 
     ans := Set{ans, if x - y < 0 then -(x - y) else x - y endif}->min() )  ;     i := i + 1 ) ; 
    return ans 
 );
  static class ConsoleScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() )   catch (e : IOException) do (     error AssertionException(e) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int N=stdIn.nextInt();
    int[] a=new int[N];
    long sumh=0 ;
    long[] sum=new long[N];
    for(int i=0 ; i<N ; i++){
      a[i]=stdIn.nextInt();
      sum[i]=sumh+a[i];
      sumh+=a[i];
    }
    long min=Math.abs(sum[0]*2-sumh);
    for(int i=1 ; i<N-1 ; i++){
      if(Math.abs(sum[i]*2-sumh)<min){
        min=Math.abs(sum[i]*2-sumh);
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := stdIn.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var sumh : long ; sumh := 0 ;
    var sum : Sequence(long) ; sum := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := stdIn.getCurrent()->toInteger() ; 
     sum[i+1] := sumh + a[i+1] ; 
     sumh := sumh+(a[i+1]) )  ;     i := i + 1 ) ; 
    var min : long ; min := if sum[0+1] * 2 - sumh < 0 then -(sum[0+1] * 2 - sumh) else sum[0+1] * 2 - sumh endif ;
        var i : int ; i := 1 ; while i < N - 1 do ( (     if (if sum[i+1] * 2 - sumh < 0 then -(sum[i+1] * 2 - sumh) else sum[i+1] * 2 - sumh endif < min) then (     min := if sum[i+1] * 2 - sumh < 0 then -(sum[i+1] * 2 - sumh) else sum[i+1] * 2 - sumh endif ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test285 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      long x=in.nextLong();
      if(x % 2050==0){
        long y=x/2050 ;
        int sum=0 ;
        while(y>0){
          sum+=y % 10 ;
          y/=10 ;
        }
        System.out.println(sum);
      }
      else {
        System.out.println(-1);
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test285 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var x : long ; x := in.getCurrent()->toLong() ;
     if (x mod 2050 = 0) then (     var y : long ; y := x / 2050 ;
     var sum : int ; sum := 0 ;
     while (y > 0) do (     sum := sum+(y mod 10) ; 
     y := y/(10) ) ; 
     OclFile["System.out"].println(sum) ) else (     OclFile["System.out"].println(-1) ) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    C solver=new C();
    solver.solve(1,in,out);
    out.close();
  }
  static class C {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=Integer.parseInt(in.next());
      int[] a=new int[n];
      long total=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=Integer.parseInt(in.next());
        total+=a[i];
      }
      long ans=Long.MAX_VALUE ;
      long x=0 ;
      for(int i=0 ; i<n ; i++){
        x+=a[i];
        if(i+1<n)ans=Math.min(ans,Math.abs(total-2*x));
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : C ; solver := C.newC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class C {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (in.getCurrent())->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var total : long ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (in.getCurrent())->toInteger() ; 
     total := total+(a[i+1]) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := "9223372036854775807"->toLong() ;
    var x : long ; x := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x := x+(a[i+1]) ; 
     if (i + 1 < n) then     ans := Set{ans, if total - 2 * x < 0 then -(total - 2 * x) else total - 2 * x endif}->min() ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Map.Entry ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=1 ;
    main : while(t-->0){
      int n=sc.nextInt();
      TreeMap<Integer,Integer>map=new TreeMap<>();
      for(int i=0 ; i<1<<n ; i++){
        final int num=sc.nextInt();
        map.put(num,map.getOrDefault(num,0)+1);
      }
      List<Integer>slime=new ArrayList<>();
      slime.add(map.lastKey());
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<1<<i ; j++){
          final Entry<Integer,Integer>integerIntegerEntry=map.lowerEntry(slime.get(j));
          if(integerIntegerEntry==null){
            System.out.println("No");
            continue main ;
          }
          final Integer value=integerIntegerEntry.getValue();
          final Integer key=integerIntegerEntry.getKey();
          if(value==1){
            map.remove(key);
          }
          else {
            map.replace(key,value-1);
          }
          slime.add(key);
        }
      }
      System.out.println("Yes");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < (1*(2->pow(n)))->oclAsType(long) do ( (     var num : int ; num := sc.getCurrent()->toInteger() ;
     map := map->union(Map{num |-> (if map->keys()->contains(num) then map->at(num) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var slime : Sequence(int) ; slime := Sequence{} ;
    slime := slime->including(map->keys()->max()) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < (1*(2->pow(i)))->oclAsType(long) do ( (     var integerIntegerEntry : Entry<int,int> ; integerIntegerEntry := map.lowerEntry(slime->at(j+1)) ;
     if (integerIntegerEntry = null) then (     OclFile["System.out"].println("No") ; 
     continue ) else skip ; 
    var value : int ; value := integerIntegerEntry.getValue() ;
    var key : int ; key := integerIntegerEntry.getKey() ;
    if (value = 1) then (     map := map->antirestrict(Set{key}) ) else (     map := map.replace(key, value - 1) ) ;  
    slime := slime->including(key) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Yes") ; 
 ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int len=Integer.parseInt(br.readLine());
    StringTokenizer tokenizer=new StringTokenizer(br.readLine()," ");
    int[] arr=new int[len];
    int i=0 ;
    while(tokenizer.hasMoreElements()){
      arr[i++]=Integer.parseInt((String)tokenizer.nextElement());
    }
    sort(arr);
  }
  public static void sort(int[] arr){
    printArr(arr);
    for(int i=1 ; i<arr.length ; i++){
      for(int j=i ; j>=1 ; j--){
        int current=arr[j];
        int prev=arr[j-1];
        if(current<prev){
          swap(arr,j-1,j);
        }
        else {
          break ;
        }
      }
      printArr(arr);
    }
  }
  public static void swap(int[] arr,int from,int to){
    int temp=arr[from];
    arr[from]=arr[to];
    arr[to]=temp ;
  }
  public static void printArr(int[] arr){
    String msg="" ;
    for(int i=0 ; i<arr.length ; i++){
      msg+=arr[i];
      if(i==arr.length-1){
        break ;
      }
      msg+=" " ;
    }
    System.out.println(msg);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var len : int ; len := (br.readLine())->toInteger() ;
    var tokenizer : OclIterator ; tokenizer := OclIterator.newOclIterator_String_String(br.readLine(), " ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,len)->collect(0) ;
    var i : int ; i := 0 ;
    while (tokenizer.hasNext()) do (      arr[i+1] := (tokenizer.next()->oclAsType(String))->toInteger()  ; i := i + 1 ) ; 
    execute sort(arr) ; 
 );
  static   operation sort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     execute printArr(arr) ; 
         var i : int ; i := 1 ; while i < arr->size() do ( (         var j : int ; j := i ; while j >= 1 do ( (     var current : int ; current := arr[j+1] ;
     var prev : int ; prev := arr[j - 1+1] ;
     if (current < prev) then (     execute swap(arr, j - 1, j) ) else (     break ) )  ;     j := j - 1 ) ; 
     execute printArr(arr) )  ;     i := i + 1 ) );
  static   operation swap( arr : Sequence(int), from : int, to : int) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := arr[from+1] ;
     arr[from+1] := arr[to+1] ; 
     arr[to+1] := temp );
  static   operation printArr( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var msg : String ; msg := "" ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     msg := msg+(arr[i+1]) ; 
     if (i = arr->size() - 1) then (     break ) else skip ; 
     msg := msg+(" ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(msg) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    Long[] a=new Long[N];
    long t=0 ;
    for(int i=0 ; i<N ; i++){
      a[i]=Long.parseLong(sc.next());
      t+=a[i];
    }
    long inf=2147000009 ;
    long x=0 ;
    long y=t ;
    long min=inf ;
    for(int i=0 ; i<N ; i++){
      x+=a[i];
      y-=a[i];
      if(i<N-1)min=Math.min(min,Math.abs(x-y));
    }
    System.out.print(min);
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,N)->collect(null) ;
    var t : long ; t := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := (sc.getCurrent())->toLong() ; 
     t := t+(a[i+1]) )  ;     i := i + 1 ) ; 
    var inf : long ; inf := 2147000009 ;
    var x : long ; x := 0 ;
    var y : long ; y := t ;
    var min : long ; min := inf ;
        var i : int ; i := 0 ; while i < N do ( (     x := x+(a[i+1]) ; 
     y := y-(a[i+1]) ; 
     if (i < N - 1) then     min := Set{min, if x - y < 0 then -(x - y) else x - y endif}->min() ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(min) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Comparator ;
import java.util.Collections ;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      ArrayList<Data>list=new ArrayList<>();
      int count=Integer.parseInt(reader.readLine());
      int duplicate=0 ;
      for(int i=0 ; i<count ; i++){
        String str=reader.readLine();
        String s[]=str.split(" ");
        int w=Integer.parseInt(s[0]);
        int h=Integer.parseInt(s[1]);
        int c=Integer.parseInt(s[2]);
        Data data=new Data(w,h,c);
        for(int j=0 ; j<list.size(); j++){
          if(list.get(j).search(data)){
            duplicate++;
            break ;
          }
        }
        list.add(data);
      }
      System.out.println(duplicate);
      reader.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  static class Data {
    int num[]=new int[3];
    public Data(int a,int b,int c){
      num[0]=a ;
      num[1]=b ;
      num[2]=c ;
    }
    public boolean search(Data d){
      int tr=0 ;
      for(int i=0 ; i<3 ; i++){
        for(int j=0 ; j<3 ; j++){
          if(d.num[i]==num[j]){
            tr++;
          }
        }
      }
      if(tr==3){
        return true ;
      }
      return false ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var list : Sequence(Data) ; list := Sequence{} ;
     var count : int ; count := (reader.readLine())->toInteger() ;
    var duplicate : int ; duplicate := 0 ;
        var i : int ; i := 0 ; while i < count do ( (     var str : String ; str := reader.readLine() ;
     var s : Sequence(String) ; s := str->split(" ") ;
    var w : int ; w := (s[0+1])->toInteger() ;
    var h : int ; h := (s[1+1])->toInteger() ;
    var c : int ; c := (s[2+1])->toInteger() ;
    var data : Data ; data := Data.newData(w, h, c) ;
        var j : int ; j := 0 ; while j < list->size() do ( (     if (list->at(j+1)->reverse()->indexOf(data)-1) then (     duplicate := duplicate + 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    list := list->including(data) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(duplicate) ; 
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
  static class Data {
   attribute num : int := Integer.subrange(1,3)->collect(0);
   static operation newData( a : int, b : int, c : int) : Data
  pre: true
  post: true
  activity:
  ( var self : Data ;
    self := createData();
    self.initialise(a, b,c);
    return self );
  operation initialise( a : int, b : int, c : int) : void
  pre: true  post: true
  activity: (     num[0+1] := a ; 
     num[1+1] := b ; 
     num[2+1] := c );
   operation search( d : Data) : boolean
  pre: true
  post: true
  activity: (     var tr : int ; tr := 0 ;
         var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     if (d.num[i+1] = num[j+1]) then (     tr := tr + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (tr = 3) then (     return true ) else skip ; 
     return false );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
import java.util.HashSet ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner s=new Scanner(System.in);
    int N=s.nextInt();
    int[] n=new int[3];
    HashSet<String>set=new HashSet<String>();
    for(int i=0 ; i<N ; i++){
      n[0]=s.nextInt();
      n[1]=s.nextInt();
      n[2]=s.nextInt();
      Arrays.sort(n);
      String s1=String.valueOf(n[0]);
      String s2=String.valueOf(n[1]);
      String s3=String.valueOf(n[2]);
      String str=s1+s2+s3 ;
      set.add(str);
    }
    System.out.println(N-set.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := s.getCurrent()->toInteger() ;
    var n : Sequence(int) ; n := Integer.subrange(1,3)->collect(0) ;
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := 0 ; while i < N do ( (     n[0+1] := s.getCurrent()->toInteger() ; 
     n[1+1] := s.getCurrent()->toInteger() ; 
    n[2+1] := s.getCurrent()->toInteger() ; 
    n := n->sort() ; 
    var s1 : String ; s1 := ((n[0+1]) + "") ;
    var s2 : String ; s2 := ((n[1+1]) + "") ;
    var s3 : String ; s3 := ((n[2+1]) + "") ;
    var str : String ; str := s1 + s2 + s3 ;
    set := set->including(str) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(N - set->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  static final int BASE=1009 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] p=new int[3];
    Set<Long>set=new HashSet<>();
    int count=0 ;
    for(int i=0 ; i<N ; i++){
      p[0]=sc.nextInt();
      p[1]=sc.nextInt();
      p[2]=sc.nextInt();
      Arrays.sort(p);
      long hash=0 ;
      hash+=p[0]*BASE*BASE ;
      hash+=p[1]*BASE ;
      hash+=p[2];
      if(set.contains(hash)){
        count++;
        continue ;
      }
      set.add(hash);
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BASE : int := 1009;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,3)->collect(0) ;
    var set : Set(long) ; set := Set{} ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     p[0+1] := sc.getCurrent()->toInteger() ; 
     p[1+1] := sc.getCurrent()->toInteger() ; 
    p[2+1] := sc.getCurrent()->toInteger() ; 
    p := p->sort() ; 
    var hash : long ; hash := 0 ;
    hash := hash+(p[0+1] * BASE * BASE) ; 
    hash := hash+(p[1+1] * BASE) ; 
    hash := hash+(p[2+1]) ; 
    if (set->includes(hash)) then (     count := count + 1 ; 
     continue ) else skip ; 
    set := set->including(hash) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      sc.nextInt();
      String[] originals=new String[n];
      for(int i=0 ; i<originals.length ; ++i){
        originals[i]=sc.next();
      }
      String[] rests=new String[n-1];
      for(int i=0 ; i<rests.length ; ++i){
        rests[i]=sc.next();
      }
      System.out.println(solve(originals,rests));
      System.out.flush();
    }
    sc.close();
  }
  static String solve(String[] originals,String[] rests){
    int m=originals[0] .length();
    int[][] counts=new int[m][26];
    for(String original : originals){
      for(int i=0 ; i<original.length(); ++i){
++counts[i][original.charAt(i)-'a'];
      }
    }
    for(String rest : rests){
      for(int i=0 ; i<rest.length(); ++i){
--counts[i][rest.charAt(i)-'a'];
      }
    }
    return Arrays.stream(counts).map(c->String.valueOf((char)('a'+IntStream.range(0,c.length).filter(i->c[i]==1).findAny().getAsInt()))).collect(Collectors.joining());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     skip ; 
    var originals : Sequence(String) ; originals := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < originals->size() do ( (     originals[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    var rests : Sequence(String) ; rests := Integer.subrange(1,n - 1)->collect(null) ;
        var i : int ; i := 0 ; while i < rests->size() do ( (     rests[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(originals, rests)) ; 
    OclFile["System.out"].flush() ; 
 )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( originals : Sequence(String), rests : Sequence(String)) : String
  pre: true
  post: true
  activity: (     var m : int ; m := originals[0+1]->size() ;
     var counts : Sequence(Sequence(int)) ; counts := Integer.subrange(1,m)->collect(Integer.subrange(1,26)->collect(0)) ;
    for (original : originals) do ( (         var i : int ; i := 0 ; while i < original->size() do ( (     counts[i+1][original->at(i+1) - ('a')->char2byte()+1] := counts[i+1][original->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) )  ) ; 
    for (rest : rests) do ( (         var i : int ; i := 0 ; while i < rest->size() do ( (     counts[i+1][rest->at(i+1) - ('a')->char2byte()+1] := counts[i+1][rest->at(i+1) - ('a')->char2byte()+1] - 1 )  ;     i := i + 1 ) )  ) ; 
    return stream(counts)->collect( _x1 | (lambda c : OclAny in ((('a' + Integer.subrange(0, c->size()-1)->select( _x1 | (lambda i : OclAny in c[i+1] = 1)->apply(_x1) )->any(true).getAsInt())->oclAsType(String)) + ""))->apply(_x1) ).collect(Collectors.joining()) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSquares(int m,int n){
    if(n<m){
      int temp=m ;
      m=n ;
      n=temp ;
    }
    return m*(m+1)*(2*m+1)/6+(n-m)*m*(m+1)/2 ;
  }
  public static void main(String[] args){
    int m=4,n=3 ;
    System.out.println("Count of squares is "+countSquares(m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSquares( m : int, n : int) : int
  pre: true
  post: true
  activity: (     if (n < m) then (     var temp : int ; temp := m ;
     m := n ; 
     n := temp ) else skip ; 
     return m * (m + 1) * (2 * m + 1) / 6 + (n - m) * m * (m + 1) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 4 ;
    var n : int ; n := 3 ;
     OclFile["System.out"].println("Count of squares is " + countSquares(m, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int logicOfSequence(int N){
    if(N % 2==0)N=N*N ;
    else N=N*N*N ;
    return N ;
  }
  public static void main(String args[]){
    int N=6 ;
    System.out.println(logicOfSequence(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation logicOfSequence( N : int) : int
  pre: true
  post: true
  activity: (     if (N mod 2 = 0) then     N := N * N else     N := N * N * N ; ;  
     return N );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 6 ;
     OclFile["System.out"].println(logicOfSequence(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
class GFG {
  static boolean check_char(String st,char ch){
    int l=st.length();
    for(int i=0 ; i<l ; i++){
      if(st.charAt(i)==ch)return true ;
    }
    return false ;
  }
  static char find_avg(String st){
    int i,sm=0 ;
    int l=st.length();
    char ch ;
    for(i=0 ; i<l ; i++){
      ch=st.charAt(i);
      sm=sm+(int)(ch);
    }
    int avg=(int)(Math.floor(sm/l));
    return((char)(avg));
  }
  public static void main(String[] args){
    String st="ag23sdfa" ;
    char ch=find_avg(st);
    System.out.println(ch);
    if(check_char(st,ch)==true)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check_char( st : String, ch : String) : boolean
  pre: true
  post: true
  activity: (     var l : int ; l := st->size() ;
         var i : int ; i := 0 ; while i < l do ( (     if (st->at(i+1) = ch) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation find_avg( st : String) : String
  pre: true
  post: true
  activity: (     var i : int ;
    var sm : int ; sm := 0 ;
     var l : int ; l := st->size() ;
    var ch : String ;
        i := 0 ; while i < l do ( (     ch := st->at(i+1) ; 
     sm := sm + (ch)->oclAsType(int) )  ;     i := i + 1 ) ; 
    var avg : int ; avg := ((sm / l)->floor())->oclAsType(int) ;
    return ((avg)->oclAsType(String)) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var st : String ; st := "ag23sdfa" ;
     var ch : String ; ch := find_avg(st) ;
     OclFile["System.out"].println(ch) ; 
     if (check_char(st, ch) = true) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SumMulti {
  int number ;
  public SumMulti(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  public void input(long number){
    int count=0 ;
    boolean b=true ;
    while(true){
      count++;
      String sNumber=""+number ;
      if(Long.parseLong(sNumber)<2050){
        b=false ;
        break ;
      }
      long num=2050*(long)(java.lang.Math.pow(10,sNumber.length()-4));
      if(num>number){
        num=2050*(long)(java.lang.Math.pow(10,sNumber.length()-5));
      }
      number-=num ;
      if(number==0){
        break ;
      }
    }
    if(b==true){
      System.out.println(count);
    }
    else {
      System.out.println(-1);
    }
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    SumMulti instance=new SumMulti(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      long num=input.nextLong();
      instance.input(num);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SumMulti {
   attribute number : int;
   static operation newSumMulti( number : int) : SumMulti
  pre: true
  post: true
  activity:
  ( var self : SumMulti ;
    self := createSumMulti();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
   operation input( number : long) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var b : boolean ; b := true ;
     while (true) do (     count := count + 1 ; 
     var sNumber : String ; sNumber := "" + number ;
    if ((sNumber)->toLong() < 2050) then (     b := false ; 
     break ) else skip ; 
    var num : long ; num := 2050 * (java.lang.Math.pow(10, sNumber->size() - 4))->oclAsType(long) ;
    if (num > number) then (     num := 2050 * (java.lang.Math.pow(10, sNumber->size() - 5))->oclAsType(long) ) else skip ; 
    number := number-(num) ; 
    if (number = 0) then (     break ) else skip ; 
 ) ; 
     if (b = true) then (     OclFile["System.out"].println(count) ) else (     OclFile["System.out"].println(-1) ) );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
     var instance : SumMulti ; instance := SumMulti.newSumMulti(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var num : long ; num := input.getCurrent()->toLong() ;
     instance.input(num) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args){
    BufferedReader kb=new BufferedReader(new InputStreamReader(System.in));
    try {
      int n=Integer.parseInt(kb.readLine());
      String[] nums=kb.readLine().split(" ");
      int len=nums.length ;
      int[] A=new int[len];
      int i,len2=len-1 ;
      StringBuilder output=new StringBuilder(100+1);
      for(i=0 ; i<len ; i++){
        A[i]=Integer.parseInt(nums[i]);
        output.append(A[i]+" ");
      }
      output.deleteCharAt(output.lastIndexOf(" "));
      output.append("\n");
      int key ;
      int j,k ;
      for(i=1 ; i<len ; i++){
        key=A[i];
        j=i-1 ;
        while(0<=j && key<A[j]){
          A[j+1]=A[j];
          j--;
        }
        A[j+1]=key ;
        for(k=0 ; k<len ; k++){
          output.append(A[k]+" ");
        }
        output.deleteCharAt(output.lastIndexOf(" "));
        output.append("\n");
      }
      System.out.print(output);
      kb.close();
    }
    catch(IOException e){
      System.err.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var kb : OclFile ; kb := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var n : int ; n := (kb.readLine())->toInteger() ;
     var nums : Sequence(String) ; nums := kb.readLine()->split(" ") ;
    var len : int ; len := nums->size() ;
    var A : Sequence(int) ; A := Integer.subrange(1,len)->collect(0) ;
    var i : int ;
    var len2 : int ; len2 := len - 1 ;
    var output : String ; output := StringLib.newString(100 + 1) ;
        i := 0 ; while i < len do ( (     A[i+1] := (nums[i+1])->toInteger() ; 
     output := output + StringLib.newString(A[i+1] + " ") )  ;     i := i + 1 ) ; 
    output := output->excludingAt(output->lastIndexOf(" ")-1+1) ; 
    output := output + StringLib.newString("\n") ; 
    var key : int ;
    var j : int ;
    var k : int ;
        i := 1 ; while i < len do ( (     key := A[i+1] ; 
     j := i - 1 ; 
    while (0 <= j & key < A[j+1]) do (     A[j + 1+1] := A[j+1] ; 
     j := j - 1 ) ; 
    A[j + 1+1] := key ; 
        k := 0 ; while k < len do ( (     output := output + StringLib.newString(A[k+1] + " ") )  ;     k := k + 1 ) ; 
    output := output->excludingAt(output->lastIndexOf(" ")-1+1) ; 
    output := output + StringLib.newString("\n") ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(output) ; 
    skip ; 
 )   catch (e : IOException) do (     OclFile["System.err"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=100000 ;
  static int[] divisors=new int[MAX];
  static void generateDivisors(int n){
    for(int i=1 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        if(n/i==i){
          divisors[i]++;
        }
        else {
          divisors[i]++;
          divisors[n/i]++;
        }
      }
    }
  }
  static int findMaxMultiples(int[] arr,int n){
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      ans=Math.max(divisors[arr[i] ],ans);
      generateDivisors(arr[i]);
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      8,1,28,4,2,6,7 };
      int n=arr.length ;
      System.out.print(findMaxMultiples(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100000;
  static   attribute divisors : Sequence(int) := Integer.subrange(1,MAX)->collect(0);
  static   operation generateDivisors( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     if (n / i = i) then (     divisors[i+1] := divisors[i+1] + 1 ) else (     divisors[i+1] := divisors[i+1] + 1 ; 
     divisors[n / i+1] := divisors[n / i+1] + 1 ) ) else skip )  ;     i := i + 1 ) );
  static   operation findMaxMultiples( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     ans := Set{divisors[arr[i+1]+1], ans}->max() ; 
     execute generateDivisors(arr[i+1]) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,1,28,4,2,6,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(findMaxMultiples(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  static int maxProfit(int n,int a,int b,int x,int y){
    int res=x*(n/a);
    res+=y*(n/b);
    res-=Math.min(x,y)*(n/((a*b)/__gcd(a,b)));
    return res ;
  }
  public static void main(String[] args){
    int n=6,a=6,b=2,x=8,y=2 ;
    System.out.println(maxProfit(n,a,b,x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation maxProfit( n : int, a : int, b : int, x : int, y : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := x * (n / a) ;
     res := res+(y * (n / b)) ; 
     res := res-(Set{x, y}->min() * (n / ((a * b) / __gcd(a, b)))) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
    var a : int ; a := 6 ;
    var b : int ; b := 2 ;
    var x : int ; x := 8 ;
    var y : int ; y := 2 ;
     OclFile["System.out"].println(maxProfit(n, a, b, x, y)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Vector<Integer>Diffs(int[] a,int k){
    Vector<Integer>out=new Vector<Integer>();
    int[] inc,dec ;
    inc=new int[a.length];
    dec=new int[a.length];
    int inc_sum=0 ;
    int dec_sum=0 ;
    for(int i=0 ; i<a.length ; ++i){
      for(int j=i-1 ; j>=0 && j>i-k && a[j+1]>a[j]; --j){
++inc[j];
++inc_sum ;
      }
      for(int j=i-1 ; j>=0 && j>i-k && a[j+1]<a[j]; --j){
++dec[j];
++dec_sum ;
      }
      if(i>=k-1){
        if(i>=k){
          inc_sum-=inc[i-k];
          dec_sum-=dec[i-k];
        }
        out.add(inc_sum-dec_sum);
      }
    }
    return out ;
  }
  public static void main(String[] args){
    int[] arr={
      10,20,30,15,15 };
      Vector<Integer>out=Diffs(arr,3);
      for(int n : out)System.out.print(n+",");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Diffs( a : Sequence(int), k : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var out : Sequence(int) ; out := Sequence{} ;
     var inc : Sequence(int) ;
    var dec : Sequence(int) ;
    inc := Integer.subrange(1,a->size())->collect(0) ; 
    dec := Integer.subrange(1,a->size())->collect(0) ; 
    var inc_sum : int ; inc_sum := 0 ;
    var dec_sum : int ; dec_sum := 0 ;
        var i : int ; i := 0 ; while i < a->size() do ( (         var j : int ; j := i - 1 ; while j >= 0 & j > i - k & a[j + 1+1] > a[j+1] do ( (     inc[j+1] := inc[j+1] + 1 ; 
     inc_sum := inc_sum + 1 )  ;     j := j - 1 ) ; 
         var j : int ; j := i - 1 ; while j >= 0 & j > i - k & a[j + 1+1] < a[j+1] do ( (     dec[j+1] := dec[j+1] + 1 ; 
     dec_sum := dec_sum + 1 )  ;     j := j - 1 ) ; 
     if (i >= k - 1) then (     if (i >= k) then (     inc_sum := inc_sum-(inc[i - k+1]) ; 
     dec_sum := dec_sum-(dec[i - k+1]) ) else skip ; 
     out := out->including(inc_sum - dec_sum) ) else skip )  ;     i := i + 1 ) ; 
    return out 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,20,30,15,15} ;
     var out : Sequence(int) ; out := Diffs(arr, 3) ;
     for (n : out) do (     OclFile["System.out"].print(n + ",") ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static final long MOD=1000000007 ;
  static int n ;
  static int m ;
  static int[] b ;
  static long[] dp ;
  private static long rec(int current){
    if(current==n)return 1 ;
    if(current>n)return 0 ;
    if(b[current]==1)return 0 ;
    if(dp[current]==MOD){
      dp[current]=(rec(current+1)+rec(current+2))% MOD ;
    }
    return dp[current];
  }
  public static void main(String[] args){
    java.util.Scanner input=new Scanner(System.in);
    n=input.nextInt();
    m=input.nextInt();
    b=new int[n];
    dp=new long[n];
    for(int i=0 ; i<n ; i++)dp[i]=MOD ;
    for(int i=0 ; i<m ; i++)b[input.nextInt()]=1 ;
    long r=rec(0);
    System.out.println(r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 1000000007;
  static   attribute n : int;
  static   attribute m : int;
  static   attribute b : Sequence(int);
  static   attribute dp : Sequence(long);
  static   operation rec( current : int) : long
  pre: true
  post: true
  activity: (     if (current = n) then     return 1 else skip ; 
     if (current > n) then     return 0 else skip ; 
    if (b[current+1] = 1) then     return 0 else skip ; 
    if (dp[current+1] = MOD) then (     dp[current+1] := (rec(current + 1) + rec(current + 2)) mod MOD ) else skip ; 
    return dp[current+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : Scanner ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := input.nextInt() ; 
    m := input.nextInt() ; 
    b := Integer.subrange(1,n)->collect(0) ; 
    dp := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     dp[i+1] := MOD ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     b[input.nextInt()+1] := 1 ;  ;     i := i + 1 ) ; 
    var r : long ; r := rec(0) ;
    OclFile["System.out"].println(r) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int m=Integer.parseInt(sc.next());
    Integer[] a=new Integer[m];
    Arrays.setAll(a,i->Integer.parseInt(sc.next()));
    sc.close();
    List<Integer>list=new ArrayList<>();
    int index=0 ;
    for(int i=0 ; i<a.length ; i++){
      int num=a[i]-index ;
      index=a[i]+1 ;
      list.add(num);
    }
    list.add(n-index+1);
    long[] fibonacci=new long[100001];
    final long MOD=1000000007 ;
    fibonacci[0]=1 ;
    fibonacci[1]=1 ;
    for(int i=2 ; i<100001 ; i++){
      fibonacci[i]=(fibonacci[i-1]+fibonacci[i-2])% MOD ;
    }
    long result=1 ;
    if(list.contains(0)){
      result=0 ;
    }
    else {
      for(int num : list){
        result*=fibonacci[num-1];
        result %=MOD ;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var m : int ; m := (sc.getCurrent())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(null) ;
setAll(a, lambda i : OclAny in (sc.getCurrent())->toInteger()) ; 
    skip ; 
    var list : Sequence(int) ; list := Sequence{} ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < a->size() do ( (     var num : int ; num := a[i+1] - index ;
     index := a[i+1] + 1 ; 
     list := list->including(num) )  ;     i := i + 1 ) ; 
    list := list->including(n - index + 1) ; 
    var fibonacci : Sequence(long) ; fibonacci := Integer.subrange(1,100001)->collect(0) ;
    var MOD : long ; MOD := 1000000007 ;
    fibonacci[0+1] := 1 ; 
    fibonacci[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < 100001 do ( (     fibonacci[i+1] := (fibonacci[i - 1+1] + fibonacci[i - 2+1]) mod MOD )  ;     i := i + 1 ) ; 
    var result : long ; result := 1 ;
    if (list->includes(0)) then (     result := 0 ) else (     for (num : list) do ( (     result := result*(fibonacci[num - 1+1]) ; 
     result := result mod MOD )  ) ) ;  
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Integer steps[];
  Long results[];
  public Main(int n,Integer a[]){
    steps=new Integer[n];
    results=new Long[n];
    for(int i=0 ; i<steps.length ; i++){
      steps[i]=1 ;
      results[i]=-1L ;
    }
    for(int e : a){
      steps[e]=0 ;
    }
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int m=s.nextInt();
    Integer a[]=new Integer[m];
    for(int i=0 ; i<m ; i++){
      a[i]=s.nextInt();
    }
    System.out.println(new Main(n,a).calc(0));
  }
  public long calc(int prefix){
    Long shortcut=results[prefix];
    long result ;
    if(shortcut!=-1L){
      return shortcut ;
    }
    if(prefix>=steps.length){
      result=0 ;
    }
    else if(prefix==steps.length-1){
      result=1 ;
    }
    else if(prefix==steps.length-2){
      result=1+(((steps[prefix+1]==1)? 1 : 0));
    }
    else {
      result=(((steps[prefix+1]==1)? calc(prefix+1): 0)+((steps[prefix+2]==1)? calc(prefix+2): 0));
      result %=1_000_000_007L ;
    }
    results[prefix]=result ;
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute steps : Sequence(int);
   attribute results : Sequence(long);
   static operation newMain( n : int, a : Sequence(int)) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(n, a);
    return self );
  operation initialise( n : int, a : Sequence(int)) : void
  pre: true  post: true
  activity: (     steps := Integer.subrange(1,n)->collect(null) ; 
     results := Integer.subrange(1,n)->collect(null) ; 
         var i : int ; i := 0 ; while i < steps->size() do ( (     steps[i+1] := 1 ; 
     results[i+1] := -1L )  ;     i := i + 1 ) ; 
     for (e : a) do ( (     steps[e+1] := 0 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var m : int ; m := s.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(null) ;
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Main.newMain(n, a).calc(0)) ; 
 );
   operation calc( prefix : int) : long
  pre: true
  post: true
  activity: (     var shortcut : long ; shortcut := results[prefix+1] ;
     var result : long ;
    if (shortcut /= -1L) then (     return shortcut ) else skip ; 
    if (prefix >= steps->size()) then (     result := 0 ) else     if (prefix = steps->size() - 1) then (     result := 1 ) else     if (prefix = steps->size() - 2) then (     result := 1 + ((if (steps[prefix + 1+1] = 1) then 1 else 0 endif)) ) else (     result := ((if (steps[prefix + 1+1] = 1) then calc(prefix + 1) else 0 endif) + (if (steps[prefix + 2+1] = 1) then calc(prefix + 2) else 0 endif)) ; 
     result := result mod 1_000_000_007L ) ;  ;  ;  
    results[prefix+1] := result ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] a=new int[m];
    int mod=1000000007 ;
    for(int i=0 ; i<m ; i++){
      a[i]=sc.nextInt();
    }
    int[] dp=new int[n+1];
    dp[0]=1 ;
    for(int i=0 ; i<m ; i++){
      dp[a[i] ]=-1 ;
    }
    for(int i=0 ; i<=n ; i++){
      if(dp[i]>=0){
        if(i+1<=n && dp[i+1]>=0){
          dp[i+1]+=dp[i] % mod ;
        }
        if(i+2<=n && dp[i+2]>=0){
          dp[i+2]+=dp[i] % mod ;
        }
      }
    }
    System.out.print(dp[n] % mod);
  }
  static boolean checkswitch(int bit,int[] k,ArrayList<ArrayList<Integer>>list,int[] p,int m){
    for(int i=0 ; i<m ; i++){
      ArrayList<Integer>sub=list.get(i);
      int onnum=0 ;
      for(int j=0 ; j<sub.size(); j++){
        if((bit &(1<<sub.get(j)))!=0){
          onnum++;
        }
      }
      if(onnum % 2!=p[i]){
        return false ;
      }
    }
    return true ;
  }
  static int gcd(int a,int b){
    if(b==0){
      return a ;
    }
    else {
      return gcd(b,a % b);
    }
  }
}
class Pair implements Comparable {
  int from ;
  int end ;
  @ Override public int compareTo(Object other){
    Pair otherpair=(Pair)other ;
    return otherpair.end-end ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
    var mod : int ; mod := 1000000007 ;
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
    dp[0+1] := 1 ; 
        var i : int ; i := 0 ; while i < m do ( (     dp[a[i+1]+1] := -1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= n do ( (     if (dp[i+1] >= 0) then (     if (i + 1 <= n & dp[i + 1+1] >= 0) then (     dp[i + 1+1] := dp[i + 1+1]+(dp[i+1] mod mod) ) else skip ; 
     if (i + 2 <= n & dp[i + 2+1] >= 0) then (     dp[i + 2+1] := dp[i + 2+1]+(dp[i+1] mod mod) ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(dp[n+1] mod mod) ; 
 );
  static   operation checkswitch( bit : int, k : Sequence(int), list : Sequence(Sequence(int)), p : Sequence(int), m : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < m do ( (     var sub : Sequence(int) ; sub := list->at(i+1) ;
     var onnum : int ; onnum := 0 ;
         var j : int ; j := 0 ; while j < sub->size() do ( (     if ((bit & ((1*(2->pow(sub->at(j+1))))->oclAsType(long))) /= 0) then (     onnum := onnum + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (onnum mod 2 /= p[i+1]) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else (     return gcd(b, a mod b) ) );
}
class Pair implements OclAny {
   attribute from : int;
   attribute end : int;
      operation compareTo( other : OclAny) : int
  pre: true
  post: true
  activity: (     var otherpair : Map ; otherpair := other->oclAsType(Map) ;
     return otherpair.end - end );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  private static final int MOD=1_000_000_007 ;
  private static int N ;
  private static int M ;
  private static boolean[] a ;
  private static int[] dp ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt()+1 ;
    M=sc.nextInt();
    a=new boolean[N];
    Arrays.fill(a,true);
    for(int i=0 ; i<M ; i++){
      a[sc.nextInt()]=false ;
    }
    dp=new int[N];
    dp[0]=1 ;
    for(int i=0 ; i<N ; i++){
      if(! a[i])continue ;
      if(i+1<N){
        dp[i+1]=(dp[i+1]+dp[i])% MOD ;
      }
      if(i+2<N){
        dp[i+2]=(dp[i+2]+dp[i])% MOD ;
      }
    }
    System.out.println(dp[N-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1_000_000_007;
  static   attribute N : int;
  static   attribute M : int;
  static   attribute a : Sequence(boolean);
  static   attribute dp : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() + 1 ; 
    M := sc.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,N)->collect(false) ; 
    a := a->collect(true) ; 
        var i : int ; i := 0 ; while i < M do ( (     a[sc.getCurrent()->toInteger()+1] := false )  ;     i := i + 1 ) ; 
    dp := Integer.subrange(1,N)->collect(0) ; 
    dp[0+1] := 1 ; 
        var i : int ; i := 0 ; while i < N do ( (     if (not(a[i+1])) then     continue else skip ; 
     if (i + 1 < N) then (     dp[i + 1+1] := (dp[i + 1+1] + dp[i+1]) mod MOD ) else skip ; 
     if (i + 2 < N) then (     dp[i + 2+1] := (dp[i + 2+1] + dp[i+1]) mod MOD ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[N - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int c=sc.nextInt();
    int max=0 ;
    int t[]=new int[n];
    for(int i=0 ; i<n ; i++)t[i]=sc.nextInt();
    for(int i=0 ; i<n-1 ; i++)max=Math.max(max,t[i]-t[i+1]-c);
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var max : int ; max := 0 ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     t[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do (     max := Set{max, t[i+1] - t[i + 1+1] - c}->max() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class practice2 {
  static long mod=(int)1e9+7 ;
  static boolean isPalindrome(String s){
    int i=0 ;
    int j=s.length()-1 ;
    while(i<j){
      if(s.charAt(i)!=s.charAt(j))return false ;
      i++;
      j--;
    }
    return true ;
  }
  static boolean IsPalindrome(int arr[],int n,int ele){
    int i=0 ;
    int j=n-1 ;
    while(i<j){
      if(arr[i]==ele){
        i++;
      }
      else if(arr[j]==ele){
        j--;
      }
      else if(arr[i]!=arr[j])return false ;
      else {
        i++;
        j--;
      }
    }
    return true ;
  }
  static long gcd(long a,long b){
    if(b>a){
      return gcd(b,a);
    }
    if(b==0){
      return a ;
    }
    return gcd(b,a % b);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int c=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    int maxi=0 ;
    for(int i=1 ; i<n ; i++){
      maxi=Math.max(maxi,arr[i-1]-arr[i]);
    }
    if(maxi>c)System.out.println(maxi-c);
    else System.out.println(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice2 {
  static   attribute mod : long := 1e9->oclAsType(int) + 7;
  static   operation isPalindrome( s : String) : boolean
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var j : int ; j := s->size() - 1 ;
     while (i < j) do (     if (s->at(i+1) /= s->at(j+1)) then     return false else skip ; 
     i := i + 1 ; 
     j := j - 1 ) ; 
     return true );
  static   operation IsPalindrome( arr : Sequence(int), n : int, ele : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var j : int ; j := n - 1 ;
     while (i < j) do (     if (arr[i+1] = ele) then (     i := i + 1 ) else     if (arr[j+1] = ele) then (     j := j - 1 ) else     if (arr[i+1] /= arr[j+1]) then     return false else (     i := i + 1 ; 
     j := j - 1 ) ;  ;  ) ; 
     return true );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b > a) then (     return gcd(b, a) ) else skip ; 
     if (b = 0) then (     return a ) else skip ; 
     return gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var maxi : int ; maxi := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     maxi := Set{maxi, arr[i - 1+1] - arr[i+1]}->max() )  ;     i := i + 1 ) ; 
    if (maxi > c) then     OclFile["System.out"].println(maxi - c) else     OclFile["System.out"].println(0) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int arrayLeng=sc.nextInt();
    int[] insSort=new int[arrayLeng];
    for(int i=0 ; i<insSort.length ; i++){
      insSort[i]=sc.nextInt();
    }
    InsertionSort is=new InsertionSort(insSort);
    is.insSortOutPut();
    is.numOfChange();
  }
}
class InsertionSort {
  int[] insSort ;
  public InsertionSort(int[] insSort){
    this.insSort=insSort ;
  }
  public void numOfChange(){
    int minNum=0 ;
    for(int i=0,j ; i<insSort.length ; i++){
      if(i==0){
        continue ;
      }
      minNum=insSort[i];
      j=i-1 ;
      while(j>=0 && insSort[j]>minNum){
        insSort[j+1]=insSort[j];
        j--;
      }
      insSort[j+1]=minNum ;
      insSortOutPut();
    }
  }
  public void insSortOutPut(){
    System.out.print(insSort[0]);
    for(int i=1 ; i<insSort.length ; i++){
      System.out.print(" "+insSort[i]);
    }
    System.out.print("\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arrayLeng : int ; arrayLeng := sc.getCurrent()->toInteger() ;
    var insSort : Sequence(int) ; insSort := Integer.subrange(1,arrayLeng)->collect(0) ;
        var i : int ; i := 0 ; while i < insSort->size() do ( (     insSort[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var is : InsertionSort ; is := InsertionSort.newInsertionSort(insSort) ;
    is.insSortOutPut() ; 
    is.numOfChange() ; 
 );
}
class InsertionSort {
   attribute insSort : Sequence(int);
   static operation newInsertionSort( insSort : Sequence(int)) : InsertionSort
  pre: true
  post: true
  activity:
  ( var self : InsertionSort ;
    self := createInsertionSort();
    self.initialise(insSort);
    return self );
  operation initialise( insSort : Sequence(int)) : void
  pre: true  post: true
  activity: (     self.insSort := insSort );
   operation numOfChange() : void
  pre: true
  post: true
  activity: (     var minNum : int ; minNum := 0 ;
         var i : int ; i := 0 ;
    var j : int ; while i < insSort->size() do ( (     if (i = 0) then (     continue ) else skip ; 
     minNum := insSort[i+1] ; 
    j := i - 1 ; 
    while (j >= 0 & insSort[j+1] > minNum) do (     insSort[j + 1+1] := insSort[j+1] ; 
     j := j - 1 ) ; 
    insSort[j + 1+1] := minNum ; 
    execute insSortOutPut() ; 
 )  ;     i := i + 1 ) );
   operation insSortOutPut() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(insSort[0+1]) ; 
         var i : int ; i := 1 ; while i < insSort->size() do ( (     OclFile["System.out"].print(" " + insSort[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SumOf2050 {
  public static void main(String[] args){
    Scanner S=new Scanner(System.in);
    int n=S.nextInt();
    while(n-->0){
      long ip=S.nextLong();
      if(ip % 2050!=0){
        System.out.println(-1);
      }
      else {
        int l=(ip+"").length()-4 ;
        long div=2050L*(long)Math.pow(10,l);
        int count=0 ;
        while(ip>=2050){
          count+=ip/div ;
          ip=ip % div ;
          div/=10 ;
        }
        System.out.println(count);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SumOf2050 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : OclFile ; S := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := S.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var ip : long ; ip := S.getCurrent()->toLong() ;
     if (ip mod 2050 /= 0) then (     OclFile["System.out"].println(-1) ) else (     var l : int ; l := (ip + "")->size() - 4 ;
     var div : long ; div := 2050L * 10->pow(l)->oclAsType(long) ;
    var count : int ; count := 0 ;
    while (ip >= 2050) do (     count := count+(ip / div) ; 
     ip := ip mod div ; 
     div := div/(10) ) ; 
    OclFile["System.out"].println(count) ; 
 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int c=sc.nextInt();
    int maxjoy=Integer.MIN_VALUE ;
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    for(int i=0 ; i<n-1 ; i++){
      maxjoy=Math.max(maxjoy,arr[i]-arr[i+1]);
    }
    System.out.println(maxjoy-c>0 ? maxjoy-c : 0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var maxjoy : int ; maxjoy := -2147483648 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     maxjoy := Set{maxjoy, arr[i+1] - arr[i + 1+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if maxjoy - c > 0 then maxjoy - c else 0 endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int c=sc.nextInt();
    int[] lst=new int[n];
    for(int i=0 ; i<n ; i++)lst[i]=sc.nextInt();
    int res=0 ;
    for(int i=0 ; i<n-1 ; i++)res=Math.max(res,lst[i]-lst[i+1]-c);
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var lst : Sequence(int) ; lst := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     lst[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do (     res := Set{res, lst[i+1] - lst[i + 1+1] - c}->max() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    FastReader fr=new FastReader();
    int n=fr.nextInt();
    if(n<3){
      System.out.println(0);
    }
    else {
      int result=n/3 ;
      System.out.println(result);
    }
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  FastReader(){
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  String next(){
    while(st==null || ! st.hasMoreTokens()){
      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 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fr : FastReader ; fr := FastReader.newFastReader() ;
     var n : int ; n := fr.nextInt() ;
     if (n < 3) then (     OclFile["System.out"].println(0) ) else (     var result : int ; result := n / 3 ;
     OclFile["System.out"].println(result) ) );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
import java.util.ArrayDeque ;
import java.util.Queue ;
import java.util.LinkedList ;
public class Main {
  public static void main(String[] args){
    new Main().solve();
  }
  void solve(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println(N/3);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N / 3) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.InputMismatchException ;
import java.io.IOException ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.i();
      if(n<=2){
        out.println(0);
        return ;
      }
      out.println((n-3)/3+1);
    }
  }
  static class InputReader {
    InputStream is ;
    private byte[] inbuf=new byte[1024];
    public int lenbuf=0 ;
    public int ptrbuf=0 ;
    public InputReader(InputStream is){
      this.is=is ;
    }
    private int readByte(){
      if(lenbuf==-1)throw new InputMismatchException();
      if(ptrbuf>=lenbuf){
        ptrbuf=0 ;
        try {
          lenbuf=is.read(inbuf);
        }
        catch(IOException e){
          throw new InputMismatchException();
        }
        if(lenbuf<=0)return-1 ;
      }
      return inbuf[ptrbuf++];
    }
    public int i(){
      int num=0,b ;
      boolean minus=false ;
      while((b=readByte())!=-1 && !((b>='0' && b<='9')|| b=='-'));
      if(b=='-'){
        minus=true ;
        b=readByte();
      }
      while(true){
        if(b>='0' && b<='9'){
          num=num*10+(b-'0');
        }
        else {
          return minus ?-num : num ;
        }
        b=readByte();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.i() ;
     if (n <= 2) then (     skip ; 
     return ) else skip ; 
     skip );
}
  static class InputReader {
   attribute is : OclFile;
   attribute inbuf : Sequence(int) := Integer.subrange(1,1024)->collect(0);
   attribute lenbuf : int := 0;
   attribute ptrbuf : int := 0;
   static operation newInputReader( is : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     self.is := is );
   operation readByte() : int
  pre: true
  post: true
  activity: (     if (lenbuf = -1) then     error IncorrectElementException() ; else skip ; 
     if (ptrbuf >= lenbuf) then (     ptrbuf := 0 ; 
     try (     lenbuf := is.read(inbuf) )   catch (e : IOException) do (     error IncorrectElementException() )
     if (lenbuf <= 0) then     return -1 else skip ) else skip ; 
     return inbuf[ptrbuf+1] );
   operation i() : int
  pre: true
  post: true
  activity: (     var num : int ; num := 0 ;
    var b : int ;
     var minus : boolean ; minus := false ;
        b := readByte() ;
    while ((b) /= -1 & not(((b >= '0' & b <= '9') or b = '-'))) do (    skip ;  ;     b := readByte() ;
 ) ;  
    if (b = '-') then (     minus := true ; 
     b := readByte() ) else skip ; 
    while (true) do (     if (b >= '0' & b <= '9') then (     num := num * 10 + (b - ('0')->char2byte()) ) else (     return if minus then -num else num endif ) ;  
     b := readByte() ) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    System.out.println(problem089a(n));
  }
  private static int problem089a(int n){
    return n/3 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
     OclFile["System.out"].println(problem089a(n)) );
  static   operation problem089a( n : int) : int
  pre: true
  post: true
  activity: (     return n / 3 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int cnt=0 ;
    if(n % 3==0){
      cnt=n/3 ;
    }
    else {
      while(true){
        if(n<3)break ;
        if(n-3>=3){
          n-=3 ;
          cnt++;
        }
        else {
          cnt++;
          break ;
        }
      }
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var cnt : int ; cnt := 0 ;
    if (n mod 3 = 0) then (     cnt := n / 3 ) else (     while (true) do (     if (n < 3) then     break else skip ; 
     if (n - 3 >= 3) then (     n := n-(3) ; 
     cnt := cnt + 1 ) else (     cnt := cnt + 1 ; 
     break ) ) ) ;  
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private Scanner sc=new Scanner(System.in);
  private void run(){
    int N=Integer.parseInt(sc.next());
    boolean approved=true ;
    for(int i=0 ; i<N ; i++){
      int num=Integer.parseInt(sc.next());
      if(num % 2==0){
        if(!(num % 3==0 || num % 5==0)){
          approved=false ;
          break ;
        }
      }
    }
    if(approved){
      System.out.println("APPROVED");
    }
    else {
      System.out.println("DENIED");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var N : int ; N := (sc.getCurrent())->toInteger() ;
     var approved : boolean ; approved := true ;
         var i : int ; i := 0 ; while i < N do ( (     var num : int ; num := (sc.getCurrent())->toInteger() ;
     if (num mod 2 = 0) then (     if (not((num mod 3 = 0 or num mod 5 = 0))) then (     approved := false ; 
     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
     if (approved) then (     OclFile["System.out"].println("APPROVED") ) else (     OclFile["System.out"].println("DENIED") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int A[]=new int[N];
    String str="APPROVED" ;
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
      if(A[i] % 2==0){
        if(A[i] % 3!=0 && A[i] % 5!=0){
          str="DENIED" ;
        }
      }
    }
    sc.close();
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var str : String ; str := "APPROVED" ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() ; 
     if (A[i+1] mod 2 = 0) then (     if (A[i+1] mod 3 /= 0 & A[i+1] mod 5 /= 0) then (     str := "DENIED" ) else skip ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[] k=new int[M];
    List<Integer>[] S=new ArrayList[M];
    int[] p=new int[M];
    for(int i=0 ; i<M ; i++){
      k[i]=sc.nextInt();
      S[i]=new ArrayList<>();
      for(int j=0 ; j<k[i]; j++){
        S[i] .add(sc.nextInt());
      }
    }
    for(int i=0 ; i<M ; i++){
      p[i]=sc.nextInt();
    }
    System.out.println(solve(N,M,k,S,p));
  }
  public static int solve(int N,int M,int[] k,List<Integer>[] s,int[] p){
    int count=0 ;
    for(int i=0 ; i<Math.pow(2,N); i++){
      boolean on=true ;
      for(int j=0 ; j<M ; j++){
        if(! isOn(N,i,k[j],s[j],p[j])){
          on=false ;
          break ;
        }
      }
      if(on)count++;
    }
    return count ;
  }
  private static boolean isOn(int N,int state,int k,List<Integer>s,int p){
    int count=0 ;
    for(int i=0 ; i<k ; i++){
      count+=getStatus(state,s.get(i));
    }
    return count % 2==p ;
  }
  private static int getStatus(int status,int idx){
    return(status>>(idx-1))% 2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var k : Sequence(int) ; k := Integer.subrange(1,M)->collect(0) ;
    var S : Sequence(Sequence(int)) ; S := Integer.subrange(1,M)->collect(null) ;
    var p : Sequence(int) ; p := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     k[i+1] := sc.getCurrent()->toInteger() ; 
     S[i+1] := Sequence{} ; 
         var j : int ; j := 0 ; while j < k[i+1] do ( (     S[i+1]->excludes(sc.getCurrent()->toInteger()) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     p[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(N, M, k, S, p)) ; 
 );
  static   operation solve( N : int, M : int, k : Sequence(int), s : Sequence(Sequence(int)), p : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < 2->pow(N) do ( (     var on : boolean ; on := true ;
         var j : int ; j := 0 ; while j < M do ( (     if (not(isOn(N, i, k[j+1], s[j+1], p[j+1]))) then (     on := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (on) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation isOn( N : int, state : int, k : int, s : Sequence(int), p : int) : boolean
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < k do ( (     count := count+(getStatus(state, s->at(i+1))) )  ;     i := i + 1 ) ; 
     return count mod 2 = p );
  static   operation getStatus( status : int, idx : int) : int
  pre: true
  post: true
  activity: (     return ((status/(2->pow((idx - 1))))->oclAsType(long)) mod 2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    boolean approved=true ;
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      if(a % 2==0){
        if(!(a % 3==0)&& !(a % 5==0)){
          System.out.println("DENIED");
          return ;
        }
      }
    }
    System.out.println("APPROVED");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var approved : boolean ; approved := true ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (a mod 2 = 0) then (     if (not((a mod 3 = 0)) & not((a mod 5 = 0))) then (     OclFile["System.out"].println("DENIED") ; 
     return ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("APPROVED") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(bf.readLine());
    while(t-->0){
      long n=Long.parseLong(bf.readLine());
      int sum=0 ;
      if(n % 2050==0){
        n/=2050 ;
        while(n>0){
          sum+=n % 10 ;
          n/=10 ;
        }
        System.out.println(sum);
      }
      else {
        System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (bf.readLine())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := (bf.readLine())->toLong() ;
     var sum : int ; sum := 0 ;
     if (n mod 2050 = 0) then (     n := n/(2050) ; 
     while (n > 0) do (     sum := sum+(n mod 10) ; 
     n := n/(10) ) ; 
     OclFile["System.out"].println(sum) ) else (     OclFile["System.out"].println(-1) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    while(0<N){
      int n=in.nextInt();
      if(n % 2==0 &&(n % 3!=0 && n % 5!=0))break ;
      N--;
    }
    System.out.println(0<N ? "DENIED" : "APPROVED");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
     while (0 < N) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n mod 2 = 0 & (n mod 3 /= 0 & n mod 5 /= 0)) then     break else skip ; 
     N := N - 1 ) ; 
     OclFile["System.out"].println(if 0 < N then "DENIED" else "APPROVED" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    int[] h=new int[n];
    for(int i=0 ; i<n ; i++){
      h[i]=stdIn.nextInt();
    }
    int i ;
    for(i=0 ; i<n ; i++){
      if(h[i] % 2==0){
        if((h[i] % 3==0 || h[i] % 5==0)){
        }
        else {
          break ;
        }
      }
    }
    if(i==n)System.out.println("APPROVED");
    else System.out.println("DENIED");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var h : Sequence(int) ; h := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     h[i+1] := stdIn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var i : int ;
        i := 0 ; while i < n do ( (     if (h[i+1] mod 2 = 0) then (     if ((h[i+1] mod 3 = 0 or h[i+1] mod 5 = 0)) then skip else (     break ) ) else skip )  ;     i := i + 1 ) ; 
    if (i = n) then     OclFile["System.out"].println("APPROVED") else     OclFile["System.out"].println("DENIED") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int totalOperations(String str,int len){
    HashMap<Character,Integer>h=new HashMap<Character,Integer>();
    for(int i=0 ; i<len ; i++){
      if(h.containsKey(str.charAt(i)))h.put(str.charAt(i),h.get(str.charAt(i))+1);
      else h.put(str.charAt(i),1);
    }
    Set<Map.Entry<Character,Integer>>set=h.entrySet();
    HashSet<Integer>hs=new HashSet<Integer>();
    for(Map.Entry<Character,Integer>me : set)hs.add(me.getValue());
    return hs.size();
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    int len=str.length();
    System.out.println(totalOperations(str,len));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation totalOperations( str : String, len : int) : int
  pre: true
  post: true
  activity: (     var h : Map(String,int) ; h := Map{} ;
         var i : int ; i := 0 ; while i < len do ( (     if (h->keys()->includes(str->at(i+1))) then     h := h->union(Map{str->at(i+1) |-> h->at(str->at(i+1)) + 1}) ; else     h := h->union(Map{str->at(i+1) |-> 1}) ; )  ;     i := i + 1 ) ; 
    var set : Set(Map(String,int)) ; set := h->asSet() ;
    var hs : Set(int) ; hs := Set{} ;
    for (me : set) do (     hs := hs->including(me.getValue()) ;  ) ; 
    return hs->size() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var len : int ; len := str->size() ;
     OclFile["System.out"].println(totalOperations(str, len)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int count(String s,int k){
    int n=s.length();
    int d=0,i ;
    int count=0 ;
    for(i=0 ; i<n ; i++)d+=s.charAt(i);
    if(d % k==0)count+=1 ;
    for(i=k ; i<n ; i++){
      int prev=s.charAt(i-k);
      d-=prev ;
      d+=s.charAt(i);
      if(d % k==0)count+=1 ;
    }
    return count ;
  }
  public static void main(String[] args){
    String s="bcgabc" ;
    int k=3 ;
    int ans=count(s,k);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation count( s : String, k : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var d : int ; d := 0 ;
    var i : int ;
    var count : int ; count := 0 ;
        i := 0 ; while i < n do (     d := d+(s->at(i+1)) ;  ;     i := i + 1 ) ; 
    if (d mod k = 0) then     count := count+(1) ; else skip ; 
        i := k ; while i < n do ( (     var prev : int ; prev := s->at(i - k+1) ;
     d := d-(prev) ; 
     d := d+(s->at(i+1)) ; 
     if (d mod k = 0) then     count := count+(1) ; else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "bcgabc" ;
     var k : int ; k := 3 ;
     var ans : int ; ans := count(s, k) ;
     OclFile["System.out"].println(ans) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int Xor_Sum(int[] arr,int n){
    int sum=0,index=-1 ;
    int left_xor=0,right_xor=0 ;
    for(int i=0 ; i<n ; i++){
      left_xor=left_xor ^ arr[i];
      right_xor=0 ;
      for(int j=i+1 ; j<n ; j++){
        right_xor=right_xor ^ arr[j];
      }
      if(left_xor+right_xor>sum){
        sum=left_xor+right_xor ;
        index=i ;
      }
    }
    return index+1 ;
  }
  public static void main(String[] args){
    int[] arr={
      1,4,6,3,8,13,34,2,21,10 };
      int n=arr.length ;
      System.out.println(Xor_Sum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Xor_Sum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
    var index : int ; index := -1 ;
     var left_xor : int ; left_xor := 0 ;
    var right_xor : int ; right_xor := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     left_xor := MathLib.bitwiseXor(left_xor,arr[i+1]) ; 
     right_xor := 0 ; 
         var j : int ; j := i + 1 ; while j < n do ( (     right_xor := MathLib.bitwiseXor(right_xor,arr[j+1]) )  ;     j := j + 1 ) ; 
     if (left_xor + right_xor > sum) then (     sum := left_xor + right_xor ; 
     index := i ) else skip )  ;     i := i + 1 ) ; 
     return index + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,4,6,3,8,13,34,2,21,10} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(Xor_Sum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static double getMaxMedian(int[] arr,int n,int k){
    int size=n+k ;
    Arrays.sort(arr);
    if(size % 2==0){
      double median=(double)(arr[(size/2)-1]+arr[size/2])/2 ;
      return median ;
    }
    double median1=arr[size/2];
    return median1 ;
  }
  public static void main(String[] args){
    int[] arr={
      3,2,3,4,2 };
      int n=arr.length ;
      int k=2 ;
      System.out.print((int)getMaxMedian(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getMaxMedian( arr : Sequence(int), n : int, k : int) : double
  pre: true
  post: true
  activity: (     var size : int ; size := n + k ;
     arr := arr->sort() ; 
    if (size mod 2 = 0) then (     var median : double ; median := (arr[(size / 2) - 1+1] + arr[size / 2+1])->oclAsType(double) / 2 ;
     return median ) else skip ; 
    var median1 : double ; median1 := arr[size / 2+1] ;
    return median1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,2,3,4,2} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].print(getMaxMedian(arr, n, k)->oclAsType(int)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),a=0,d=0 ;
    String s=in.next();
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='A')a++;
      else d++;
    }
    System.out.println(a>d ? "Anton" :(a<d)? "Danik" : "Friendship");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : int ; a := 0 ;
    var d : int ; d := 0 ;
    var s : String ; s := in.getCurrent() ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = 'A') then     a := a + 1 ; else     d := d + 1 ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if a > d then "Anton" else if (a < d) then "Danik" else "Friendship" endif endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class scratch {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String st=br.readLine();
    int a=0,b=0 ;
    for(int i=0 ; i<st.length(); i++){
      char ch=st.charAt(i);
      if(ch=='A')a+=1 ;
      else b+=1 ;
    }
    if(a>b)System.out.println("Anton");
    else if(b>a)System.out.println("Danik");
    else System.out.println("Friendship");
  }
}
------------------------------------------------------------
OCL File:
---------
 class scratch {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var st : String ; st := br.readLine() ;
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
        var i : int ; i := 0 ; while i < st->size() do ( (     var ch : String ; ch := st->at(i+1) ;
     if (ch = 'A') then     a := a+(1) ; else     b := b+(1) ; )  ;     i := i + 1 ) ; 
    if (a > b) then     OclFile["System.out"].println("Anton") else     if (b > a) then     OclFile["System.out"].println("Danik") else     OclFile["System.out"].println("Friendship") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayList<Integer>ar=new ArrayList<>();
    int plus[][]=new int[5][2];
    for(int i=0 ; i<5 ; i++){
      int set=sc.nextInt();
      ar.add(set);
      plus[i][0]=set ;
      plus[i][1]=plus[i][0] % 10 ;
    }
    Arrays.sort(plus,(a,b)->Integer.compare(a[1],b[1]));
    int ans=0 ;
    for(int i=0 ; i<5 ; i++){
      if(plus[i][1]==0){
        ans+=plus[i][0];
        ar.remove(ar.indexOf(plus[i][0]));
      }
    }
    Arrays.sort(plus,(a,b)->Integer.compare(b[1],a[1]));
    for(int i=0 ; i<ar.size(); i++){
      if(ans % 10==0){
        ans+=plus[i][0];
      }
      else {
        while(ans % 10!=0){
          ans+=1 ;
        }
        ans+=plus[i][0];
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ar : Sequence(int) ; ar := Sequence{} ;
    var plus : Sequence(Sequence(int)) ; plus := Integer.subrange(1,5)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < 5 do ( (     var set : int ; set := sc.getCurrent()->toInteger() ;
     ar := ar->including(set) ; 
     plus[i+1][0+1] := set ; 
     plus[i+1][1+1] := plus[i+1][0+1] mod 10 )  ;     i := i + 1 ) ; 
    plus := OclComparator.sortWith(plus, lambda (a , b) : OclAny in compare(a[1+1], b[1+1])) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 5 do ( (     if (plus[i+1][1+1] = 0) then (     ans := ans+(plus[i+1][0+1]) ; 
     ar := ar->excludingFirst(ar->indexOf(plus[i+1][0+1])-1) ) else skip )  ;     i := i + 1 ) ; 
    plus := OclComparator.sortWith(plus, lambda (a , b) : OclAny in compare(b[1+1], a[1+1])) ; 
        var i : int ; i := 0 ; while i < ar->size() do ( (     if (ans mod 10 = 0) then (     ans := ans+(plus[i+1][0+1]) ) else (     while (ans mod 10 /= 0) do (     ans := ans+(1) ) ; 
     ans := ans+(plus[i+1][0+1]) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char arr[]=sc.next().toCharArray();
    int a=0,b=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]=='A')a++;
      else b++;
    }
    if(a>b)System.out.println("Anton");
    else if(a<b)System.out.println("Danik");
    else System.out.println("Friendship");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 'A') then     a := a + 1 ; else     b := b + 1 ; )  ;     i := i + 1 ) ; 
    if (a > b) then     OclFile["System.out"].println("Anton") else     if (a < b) then     OclFile["System.out"].println("Danik") else     OclFile["System.out"].println("Friendship") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Eleven {
  public static void main(String[] args){
    Scanner inp=new Scanner(System.in);
    int a=0 ;
    int d=0 ;
    int n=inp.nextInt();
    String str=inp.next();
    for(int i=0 ; i<n ; i++){
      if(str.charAt(i)=='A'){
        a++;
      }
      else if(str.charAt(i)=='D'){
        d++;
      }
    }
    if(a>d){
      System.out.println("Anton");
    }
    else if(d>a){
      System.out.println("Danik");
    }
    else if(a==d){
      System.out.println("Friendship");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Eleven {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inp : OclFile ; inp := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := 0 ;
    var d : int ; d := 0 ;
    var n : int ; n := inp.getCurrent()->toInteger() ;
    var str : String ; str := inp.getCurrent() ;
        var i : int ; i := 0 ; while i < n do ( (     if (str->at(i+1) = 'A') then (     a := a + 1 ) else     if (str->at(i+1) = 'D') then (     d := d + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    if (a > d) then (     OclFile["System.out"].println("Anton") ) else     if (d > a) then (     OclFile["System.out"].println("Danik") ) else     if (a = d) then (     OclFile["System.out"].println("Friendship") ) else skip ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DisplayTheNumber {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    while(test-->0){
      int n=sc.nextInt();
      if(n % 2==1){
        System.out.print(7);
        n-=3 ;
      }
      while(n>0){
        System.out.print(1);
        n-=2 ;
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DisplayTheNumber {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n mod 2 = 1) then (     OclFile["System.out"].print(7) ; 
     n := n-(3) ) else skip ; 
     while (n > 0) do (     OclFile["System.out"].print(1) ; 
     n := n-(2) ) ; 
     OclFile["System.out"].println() ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int size=in.nextInt();
    String str=in.next();
    int anton=0 ;
    int danik=0 ;
    for(int i=0 ; i<size ; i++){
      if(str.charAt(i)=='A')anton++;
      else danik++;
    }
    if(anton>danik)out.println("Anton");
    else if(anton<danik){
      out.println("Danik");
    }
    else {
      out.println("Friendship");
    }
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new FileReader("sub.in"));
      }
      catch(FileNotFoundException ex){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException ex){
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException ex){
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var size : int ; size := in.nextInt() ;
    var str : String ; str := in.next() ;
    var anton : int ; anton := 0 ;
    var danik : int ; danik := 0 ;
        var i : int ; i := 0 ; while i < size do ( (     if (str->at(i+1) = 'A') then     anton := anton + 1 ; else     danik := danik + 1 ; )  ;     i := i + 1 ) ; 
    if (anton > danik) then     skip else     if (anton < danik) then (     skip ) else (     skip ) ;  ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("sub.in"))) )   catch (ex : FileNotFoundException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (ex : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (ex : IOException) do skip
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int c=sc.nextInt();
      int sum=0,finalSum1=0,finalSum2=0 ;
      int p[]=new int[n];
      int t[]=new int[n];
      for(int i=0 ; i<n ; i++){
        p[i]=sc.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        t[i]=sc.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        sum+=t[i];
        int ans1=Math.max(0,(p[i]-(sum*c)));
        finalSum1+=ans1 ;
      }
      int j=0 ;
      sum=0 ;
      for(int i=n-1 ; i>=0 ; i--){
        sum+=t[i];
        int ans=Math.max(0,(p[i]-(sum*c)));
        finalSum2+=ans ;
      }
      if(finalSum1>finalSum2){
        System.out.println("Limak");
      }
      else if(finalSum1<finalSum2){
        System.out.println("Radewoosh");
      }
      else if(finalSum1==finalSum2){
        System.out.println("Tie");
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var finalSum1 : int ; finalSum1 := 0 ;
    var finalSum2 : int ; finalSum2 := 0 ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     t[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(t[i+1]) ; 
     var ans1 : int ; ans1 := Set{0, (p[i+1] - (sum * c))}->max() ;
     finalSum1 := finalSum1+(ans1) )  ;     i := i + 1 ) ; 
    var j : int ; j := 0 ;
    sum := 0 ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     sum := sum+(t[i+1]) ; 
     var ans : int ; ans := Set{0, (p[i+1] - (sum * c))}->max() ;
     finalSum2 := finalSum2+(ans) )  ;     i := i - 1 ) ; 
    if (finalSum1 > finalSum2) then (     OclFile["System.out"].println("Limak") ) else     if (finalSum1 < finalSum2) then (     OclFile["System.out"].println("Radewoosh") ) else     if (finalSum1 = finalSum2) then (     OclFile["System.out"].println("Tie") ) else skip ; ;  ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class P658A_BearAndReverseRadewoosh {
  public static void main(String[] subhani)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken()),c=Integer.parseInt(st.nextToken());
    int[] points=new int[n];
    st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<n ; ++i)points[i]=Integer.parseInt(st.nextToken());
    int[] time=new int[n];
    st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<n ; ++i)time[i]=Integer.parseInt(st.nextToken());
    solve(n,c,points,time);
  }
  public static void solve(int n,int c,int[] points,int[] time){
    int limak=0 ;
    int radewoosh=0 ;
    int t=0 ;
    for(int i=0 ; i<n ; ++i){
      t+=time[i];
      limak+=Math.max(0,points[i]-c*t);
    }
    t=0 ;
    for(int i=n-1 ; i>=0 ; --i){
      t+=time[i];
      radewoosh+=Math.max(0,points[i]-c*t);
    }
    if(limak>radewoosh)System.out.println("Limak");
    else if(limak<radewoosh)System.out.println("Radewoosh");
    else System.out.println("Tie");
  }
}
------------------------------------------------------------
OCL File:
---------
 class P658A_BearAndReverseRadewoosh {
  static   operation main( subhani : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var c : int ; c := (st.next())->toInteger() ;
    var points : Sequence(int) ; points := Integer.subrange(1,n)->collect(0) ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < n do (     points[i+1] := (st.next())->toInteger() ;  ;     i := i + 1 ) ; 
    var time : Sequence(int) ; time := Integer.subrange(1,n)->collect(0) ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < n do (     time[i+1] := (st.next())->toInteger() ;  ;     i := i + 1 ) ; 
    execute solve(n, c, points, time) ; 
 );
  static   operation solve( n : int, c : int, points : Sequence(int), time : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var limak : int ; limak := 0 ;
     var radewoosh : int ; radewoosh := 0 ;
    var t : int ; t := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     t := t+(time[i+1]) ; 
     limak := limak+(Set{0, points[i+1] - c * t}->max()) )  ;     i := i + 1 ) ; 
    t := 0 ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     t := t+(time[i+1]) ; 
     radewoosh := radewoosh+(Set{0, points[i+1] - c * t}->max()) )  ;     i := i - 1 ) ; 
    if (limak > radewoosh) then     OclFile["System.out"].println("Limak") else     if (limak < radewoosh) then     OclFile["System.out"].println("Radewoosh") else     OclFile["System.out"].println("Tie") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A658 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt(),c=scanner.nextInt();
    int[] p=new int[n],t=new int[n];
    for(int i=0 ; i<n ; i++){
      p[i]=scanner.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      t[i]=scanner.nextInt();
    }
    int sumLimak=0,sumRadewoosh=0,tLimak=0,tRade=0 ;
    for(int i=0 ; i<n ; i++){
      tLimak+=t[i];
      sumLimak+=Math.max(0,(p[i]-(c*tLimak)));
    }
    for(int i=n-1 ; i>=0 ; i--){
      tRade+=t[i];
      sumRadewoosh+=Math.max(0,(p[i]-(c*tRade)));
    }
    System.out.println(sumLimak>sumRadewoosh ? "Limak" : sumLimak<sumRadewoosh ? "Radewoosh" : "Tie");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A658 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     t[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sumLimak : int ; sumLimak := 0 ;
    var sumRadewoosh : int ; sumRadewoosh := 0 ;
    var tLimak : int ; tLimak := 0 ;
    var tRade : int ; tRade := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     tLimak := tLimak+(t[i+1]) ; 
     sumLimak := sumLimak+(Set{0, (p[i+1] - (c * tLimak))}->max()) )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     tRade := tRade+(t[i+1]) ; 
     sumRadewoosh := sumRadewoosh+(Set{0, (p[i+1] - (c * tRade))}->max()) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(if sumLimak > sumRadewoosh then "Limak" else if sumLimak < sumRadewoosh then "Radewoosh" else "Tie" endif endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int c=sc.nextInt();
      int sum=0,sum1=0,finalSum1=0,finalSum2=0 ;
      int p[]=new int[n];
      int t[]=new int[n];
      for(int i=0 ; i<n ; i++){
        p[i]=sc.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        t[i]=sc.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        sum+=t[i];
        sum1+=t[n-i-1];
        int ans1=Math.max(0,(p[i]-(sum*c)));
        int ans2=Math.max(0,(p[n-i-1]-(sum1*c)));
        finalSum1+=ans1 ;
        finalSum2+=ans2 ;
      }
      if(finalSum1>finalSum2){
        System.out.println("Limak");
      }
      else if(finalSum1<finalSum2){
        System.out.println("Radewoosh");
      }
      else if(finalSum1==finalSum2){
        System.out.println("Tie");
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var sum1 : int ; sum1 := 0 ;
    var finalSum1 : int ; finalSum1 := 0 ;
    var finalSum2 : int ; finalSum2 := 0 ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     t[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(t[i+1]) ; 
     sum1 := sum1+(t[n - i - 1+1]) ; 
    var ans1 : int ; ans1 := Set{0, (p[i+1] - (sum * c))}->max() ;
    var ans2 : int ; ans2 := Set{0, (p[n - i - 1+1] - (sum1 * c))}->max() ;
    finalSum1 := finalSum1+(ans1) ; 
    finalSum2 := finalSum2+(ans2) ; 
 )  ;     i := i + 1 ) ; 
    if (finalSum1 > finalSum2) then (     OclFile["System.out"].println("Limak") ) else     if (finalSum1 < finalSum2) then (     OclFile["System.out"].println("Radewoosh") ) else     if (finalSum1 = finalSum2) then (     OclFile["System.out"].println("Tie") ) else skip ; ;  ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=11 ;
  static boolean isMultipleof5(int n){
    char str[]=new char[MAX];
    int len=str.length ;
    if(str[len-1]=='5' || str[len-1]=='0')return true ;
    return false ;
  }
  public static void main(String[] args){
    int n=19 ;
    if(isMultipleof5(n)==true)System.out.println(n+" is multiple "+"of 5");
    else System.out.println(n+" is not a "+"multiple of 5");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 11;
  static   operation isMultipleof5( n : int) : boolean
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := Integer.subrange(1,MAX)->collect(0) ;
     var len : int ; len := str->size() ;
     if (str[(len)->char2byte() - 1+1] = '5' or str[(len)->char2byte() - 1+1] = '0') then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 19 ;
     if (isMultipleof5(n) = true) then     OclFile["System.out"].println(n + " is multiple " + "of 5") ; else     OclFile["System.out"].println(n + " is not a " + "multiple of 5") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Map ;
import java.util.HashMap ;
import java.util.List ;
import java.util.ArrayList ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int n,m ;
  static Map<String,Integer>costMap ;
  static Map<String,List<String>>itemMap ;
  public static void main(String args[]){
    while(true){
      n=sc.nextInt();
      if(n==0)break ;
      costMap=new HashMap<String,Integer>();
      itemMap=new HashMap<String,List<String>>();
      for(int i=0 ; i<n ; i++){
        String item=sc.next();
        int cost=sc.nextInt();
        costMap.put(item,cost);
      }
      m=sc.nextInt();
      for(int j=0 ; j<m ; j++){
        String product=sc.next();
        int materialNum=sc.nextInt();
        List<String>al=new ArrayList<String>();
        for(int k=0 ; k<materialNum ; k++){
          al.add(sc.next());
        }
        itemMap.put(product,al);
      }
      String target=sc.next();
      int answer=search(target);
      System.out.println(answer);
    }
  }
  static int search(String target){
    if(itemMap.containsKey(target)){
      int sum=0 ;
      for(String item : itemMap.get(target)){
        sum+=search(item);
      }
      return Math.min(costMap.get(target),sum);
    }
    else {
      return costMap.get(target);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   attribute costMap : Map(String,int);
  static   attribute itemMap : Map(String,Sequence(String));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
    costMap := Map{} ; 
    itemMap := Map{} ; 
        var i : int ; i := 0 ; while i < n do ( (     var item : String ; item := sc.getCurrent() ;
     var cost : int ; cost := sc.getCurrent()->toInteger() ;
     costMap := costMap->union(Map{item |-> cost}) )  ;     i := i + 1 ) ; 
    m := sc.getCurrent()->toInteger() ; 
        var j : int ; j := 0 ; while j < m do ( (     var product : String ; product := sc.getCurrent() ;
     var materialNum : int ; materialNum := sc.getCurrent()->toInteger() ;
    var al : Sequence(String) ; al := Sequence{} ;
        var k : int ; k := 0 ; while k < materialNum do ( (     al := al->including(sc.getCurrent()) )  ;     k := k + 1 ) ; 
    itemMap := itemMap->union(Map{product |-> al}) ; 
 )  ;     j := j + 1 ) ; 
    var target : String ; target := sc.getCurrent() ;
    var answer : int ; answer := search(target) ;
    OclFile["System.out"].println(answer) ; 
 ) );
  static   operation search( target : String) : int
  pre: true
  post: true
  activity: (     if (itemMap->keys()->includes(target)) then (     var sum : int ; sum := 0 ;
     for (item : itemMap->at(target)) do ( (     sum := sum+(search(item)) )  ) ; 
     return Set{costMap->at(target), sum}->min() ) else (     return costMap->at(target) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int A=stdIn.nextInt();
    int B=stdIn.nextInt();
    int C=stdIn.nextInt();
    int D=stdIn.nextInt();
    int E=stdIn.nextInt();
    int a=(A/10+1)*10-A,b=(B/10+1)*10-B,c=(C/10+1)*10-C,d=(D/10+1)*10-D,e=(E/10+1)*10-E ;
    int max=0 ;
    if(a>max && a!=10)max=a ;
    if(a==10)a=0 ;
    if(b>max && b!=10)max=b ;
    if(b==10)b=0 ;
    if(c>max && c!=10)max=c ;
    if(c==10)c=0 ;
    if(d>max && d!=10)max=d ;
    if(d==10)d=0 ;
    if(e>max && e!=10)max=e ;
    if(e==10)e=0 ;
    System.out.println(A+B+C+D+E+a+b+c+d+e-max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := stdIn.getCurrent()->toInteger() ;
    var B : int ; B := stdIn.getCurrent()->toInteger() ;
    var C : int ; C := stdIn.getCurrent()->toInteger() ;
    var D : int ; D := stdIn.getCurrent()->toInteger() ;
    var E : int ; E := stdIn.getCurrent()->toInteger() ;
    var a : int ; a := (A / 10 + 1) * 10 - A ;
    var b : int ; b := (B / 10 + 1) * 10 - B ;
    var c : int ; c := (C / 10 + 1) * 10 - C ;
    var d : int ; d := (D / 10 + 1) * 10 - D ;
    var e : int ; e := (E / 10 + 1) * 10 - E ;
    var max : int ; max := 0 ;
    if (a > max & a /= 10) then     max := a ; else skip ; 
    if (a = 10) then     a := 0 ; else skip ; 
    if (b > max & b /= 10) then     max := b ; else skip ; 
    if (b = 10) then     b := 0 ; else skip ; 
    if (c > max & c /= 10) then     max := c ; else skip ; 
    if (c = 10) then     c := 0 ; else skip ; 
    if (d > max & d /= 10) then     max := d ; else skip ; 
    if (d = 10) then     d := 0 ; else skip ; 
    if (e > max & e /= 10) then     max := e ; else skip ; 
    if (e = 10) then     e := 0 ; else skip ; 
    OclFile["System.out"].println(A + B + C + D + E + a + b + c + d + e - max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader reader=new BufferedReader(isr);
    String string,str[];
    int n,m,sum ;
    while(!(string=reader.readLine()).equals("0")){
      n=Integer.valueOf(string);
      HashMap<String,Integer>map=new HashMap<String,Integer>();
      for(int i=0 ; i<n ; i++){
        str=reader.readLine().split(" ");
        map.put(str[0],Integer.valueOf(str[1]));
      }
      n=Integer.valueOf(reader.readLine());
      for(int i=0 ; i<n ; i++){
        str=reader.readLine().split(" ");
        m=Integer.valueOf(str[1]);
        sum=0 ;
        for(int j=0 ; j<m ; j++){
          sum+=map.get(str[j+2]);
        }
        if(map.get(str[0])>sum)map.put(str[0],sum);
      }
      System.out.println(map.get(reader.readLine()));
    }
    reader.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(isr) ;
    var string : String ;
    var str : Sequence(void) ;
    var n : int ;
    var m : int ;
    var sum : int ;
    while (not((string) = "0")) do (     n := (string)->toInteger() ; 
     var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     str := reader.readLine()->split(" ") ; 
     map := map->union(Map{str[0+1] |-> (str[1+1])->toInteger()}) )  ;     i := i + 1 ) ; 
    n := (reader.readLine())->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     str := reader.readLine()->split(" ") ; 
     m := (str[1+1])->toInteger() ; 
    sum := 0 ; 
        var j : int ; j := 0 ; while j < m do ( (     sum := sum+(map->at(str[j + 2+1])) )  ;     j := j + 1 ) ; 
    if (map->at(str[0+1]) > sum) then     map := map->union(Map{str[0+1] |-> sum}) ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(map->at(reader.readLine())) ; 
 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static HashMap<String,Integer>dat ;
  static HashMap<String,Integer>memo ;
  static String table[][];
  static String k[];
  static int size[];
  static int b ;
  static int solve(String a){
    if(memo.containsKey(a))return memo.get(a);
    if(! dat.containsKey(a))return 999999999 ;
    int ret=dat.get(a);
    for(int i=0 ; i<b ; i++){
      if(k[i] .equals(a)){
        int val=0 ;
        for(int j=0 ; j<size[i]; j++){
          val+=solve(table[i][j]);
        }
        ret=Math.min(ret,val);
        break ;
      }
    }
    memo.put(a,ret);
    return ret ;
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int a ;
    k=new String[100];
    table=new String[100][100];
    size=new int[100];
    dat=new HashMap<String,Integer>();
    memo=new HashMap<String,Integer>();
    while(true){
      a=s.nextInt();
      dat.clear();
      memo.clear();
      if(a==0)System.exit(0);
      for(int i=0 ; i<a ; i++){
        String str=s.next();
        int p=s.nextInt();
        dat.put(str,p);
      }
      b=s.nextInt();
      for(int i=0 ; i<b ; i++){
        k[i]=s.next();
        size[i]=s.nextInt();
        for(int j=0 ; j<size[i]; j++)table[i][j]=s.next();
      }
      String m=s.next();
      System.out.println(solve(m));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dat : Map(String,int);
  static   attribute memo : Map(String,int);
  static   attribute table : Sequence(Sequence(String));
  static   attribute k : Sequence(String);
  static   attribute size : Sequence(int);
  static   attribute b : int;
  static   operation solve( a : String) : int
  pre: true
  post: true
  activity: (     if (memo->keys()->includes(a)) then     return memo->at(a) else skip ; 
     if (not(dat->keys()->includes(a))) then     return 999999999 else skip ; 
    var ret : int ; ret := dat->at(a) ;
        var i : int ; i := 0 ; while i < b do ( (     if (k[i+1] = a) then (     var val : int ; val := 0 ;
         var j : int ; j := 0 ; while j < size[i+1] do ( (     val := val+(solve(table[i+1][j+1])) )  ;     j := j + 1 ) ; 
     ret := Set{ret, val}->min() ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    memo := memo->union(Map{a |-> ret}) ; 
    return ret 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ;
    k := Integer.subrange(1,100)->collect(null) ; 
    table := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(null)) ; 
    size := Integer.subrange(1,100)->collect(0) ; 
    dat := Map{} ; 
    memo := Map{} ; 
    while (true) do (     a := s.getCurrent()->toInteger() ; 
     dat := dat->intersection(Map{}) ; 
    memo := memo->intersection(Map{}) ; 
    if (a = 0) then OclProcess.exit(0) ; else skip ; 
        var i : int ; i := 0 ; while i < a do ( (     var str : String ; str := s.getCurrent() ;
     var p : int ; p := s.getCurrent()->toInteger() ;
     dat := dat->union(Map{str |-> p}) )  ;     i := i + 1 ) ; 
    b := s.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < b do ( (     k[i+1] := s.getCurrent() ; 
     size[i+1] := s.getCurrent()->toInteger() ; 
         var j : int ; j := 0 ; while j < size[i+1] do (     table[i+1][j+1] := s.getCurrent() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var m : String ; m := s.getCurrent() ;
    OclFile["System.out"].println(solve(m)) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
class Alchemy {
  public static void input_data(int n){
    for(int i=0 ; i<n ; i++){
      String[] name_cost=Main.sc.nextLine().split(" ");
      String name=name_cost[0];
      int cost=Integer.parseInt(name_cost[1]);
      Main.item_data.put(name,cost);
    }
  }
  public static void input_recipe(int m){
    for(int i=0 ; i<m ; i++){
      String[] recipe=Main.sc.nextLine().split(" ");
      String output=recipe[0];
      int prod_fee=0 ;
      int k=Integer.parseInt(recipe[1]);
      for(int j=0 ; j<k ; j++){
        prod_fee+=Main.item_data.get(recipe[2+j]);
      }
      Main.item_data.put(output,Math.min(prod_fee,Main.item_data.get(output)));
    }
  }
}
public class Main {
  static Scanner sc=new Scanner(System.in);
  static Map<String,Integer>item_data=new HashMap<String,Integer>();
  public static void main(String[] args){
    while(sc.hasNext()){
      int n=Integer.parseInt(sc.nextLine());
      if(n==0){
        break ;
      }
      Alchemy.input_data(n);
      int m=Integer.parseInt(sc.nextLine());
      Alchemy.input_recipe(m);
      System.out.println(item_data.get(sc.nextLine()));
      item_data.clear();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Alchemy {
  static   operation input_data( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var name_cost : Sequence(String) ; name_cost := Main.sc.nextLine()->split(" ") ;
     var name : String ; name := name_cost[0+1] ;
     var cost : int ; cost := (name_cost[1+1])->toInteger() ;
     Main := Main.item_data->union(Map{name |-> cost}) )  ;     i := i + 1 ) );
  static   operation input_recipe( m : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < m do ( (     var recipe : Sequence(String) ; recipe := Main.sc.nextLine()->split(" ") ;
     var output : String ; output := recipe[0+1] ;
    var prod_fee : int ; prod_fee := 0 ;
    var k : int ; k := (recipe[1+1])->toInteger() ;
        var j : int ; j := 0 ; while j < k do ( (     prod_fee := prod_fee+(Main.item_data->at(recipe[2 + j+1]+1)) )  ;     j := j + 1 ) ; 
    Main := Main.item_data->union(Map{output |-> Set{prod_fee, Main.item_data->at(output+1)}->min()}) ; 
 )  ;     i := i + 1 ) );
}
class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute item_data : Map(String,int) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     var n : int ; n := (sc.nextLine())->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    Alchemy.input_data(n) ; 
    var m : int ; m := (sc.nextLine())->toInteger() ;
    Alchemy.input_recipe(m) ; 
    OclFile["System.out"].println(item_data->at(sc.nextLine())) ; 
    item_data := item_data->intersection(Map{}) ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF1295A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    while(t-->0){
      int n=scan.nextInt();
      if(n % 2==1){
        System.out.print("7");
        n-=3 ;
      }
      while(n>0){
        System.out.print("1");
        n-=2 ;
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF1295A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scan.getCurrent()->toInteger() ;
     if (n mod 2 = 1) then (     OclFile["System.out"].print("7") ; 
     n := n-(3) ) else skip ; 
     while (n > 0) do (     OclFile["System.out"].print("1") ; 
     n := n-(2) ) ; 
     OclFile["System.out"].println() ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new AOJ0201();
  }
  class AOJ0201 {
    HashMap<String,ArrayList<String>>map ;
    HashMap<String,Integer>price ;
    int bfs(String target){
      int a=Integer.MAX_VALUE ;
      int b=0 ;
      if(price.containsKey(target))a=price.get(target);
      if(map.containsKey(target)==false)return a ;
      ArrayList<String>list=map.get(target);
      for(int i=0 ; i<list.size(); i++)if(map.containsKey(list.get(i))|| price.containsKey(list.get(i))){
        b+=bfs(list.get(i));
      }
      return Math.min(a,b);
    }
    public AOJ0201(){
      while(true){
        map=new HashMap<String,ArrayList<String>>();
        price=new HashMap<String,Integer>();
        int n=in.nextInt();
        if(n==0)break ;
        for(int i=0 ; i<n ; i++)price.put(in.next(),in.nextInt());
        int list_n=in.nextInt();
        for(int i=0 ; i<list_n ; i++){
          String name=in.next();
          ArrayList<String>list ;
          if(! map.containsKey(name))list=new ArrayList<String>();
          else list=map.get(name);
          int a=in.nextInt();
          for(int s=0 ; s<a ; s++)list.add(in.next());
          map.put(name,list);
        }
        System.out.println(bfs(in.next()));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: ( AOJ0201.newAOJ0201() );
 class AOJ0201 {
   attribute map : Map(String,Sequence(String));
   attribute price : Map(String,int);
   operation bfs( target : String) : int
  pre: true
  post: true
  activity: (     var a : int ; a := 2147483647 ;
     var b : int ; b := 0 ;
    if (price->keys()->includes(target)) then     a := price->at(target) ; else skip ; 
    if (map->keys()->includes(target) = false) then     return a else skip ; 
    var list : Sequence(String) ; list := map->at(target) ;
        var i : int ; i := 0 ; while i < list->size() do (     if (map->keys()->includes(list->at(i+1)) or price->keys()->includes(list->at(i+1))) then (     b := b+(bfs(list->at(i+1))) ) else skip ;  ;     i := i + 1 ) ; 
    return Set{a, b}->min() 
 );
   static operation newAOJ0201() : AOJ0201
  pre: true
  post: true
  activity:
  ( var self : AOJ0201 ;
    self := createAOJ0201();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     while (true) do (     map := Map{} ; 
     price := Map{} ; 
    var n : int ; n := in.getCurrent()->toInteger() ;
    if (n = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < n do (     price := price->union(Map{in.getCurrent() |-> in.getCurrent()->toInteger()}) ;  ;     i := i + 1 ) ; 
    var list_n : int ; list_n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < list_n do ( (     var name : String ; name := in.getCurrent() ;
     var list : Sequence(String) ;
    if (not(map->keys()->includes(name))) then     list := Sequence{} else     list := map->at(name) ; ;  
    var a : int ; a := in.getCurrent()->toInteger() ;
        var s : int ; s := 0 ; while s < a do (     list := list->including(in.getCurrent()) ;  ;     s := s + 1 ) ; 
    map := map->union(Map{name |-> list}) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(bfs(in.getCurrent())) ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static boolean pd(String s){
    if(s.charAt(0)=='@' || s.charAt(s.length()-1)=='@')return false ;
    for(int i=0 ; i<s.length()-1 ; i++){
      if(s.charAt(i)=='@' && s.charAt(i+1)=='@')return false ;
    }
    for(int i=0 ; i<s.length()-2 ; i++){
      if(s.charAt(i)=='@' && s.charAt(i+2)=='@')return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    boolean t=pd(str);
    int sum=0 ;
    int num=0 ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)=='@')sum++;
    }
    if(sum==0)System.out.println("No solution");
    if(t){
      String s="" ;
      for(int i=0 ; i<str.length(); i++){
        if(str.charAt(i)=='@'){
          num++;
          if(num<sum){
            System.out.print(s+'@'+str.charAt(i+1));
            System.out.print(',');
            i++;
          }
          else if(num==sum){
            System.out.print(s+'@');
            for(int j=i+1 ; j<str.length(); j++){
              System.out.print(str.charAt(j));
            }
          }
          s="" ;
          continue ;
        }
        s+=str.charAt(i);
      }
    }
    else {
      System.out.println("No solution");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation pd( s : String) : boolean
  pre: true
  post: true
  activity: (     if (s->at(0+1) = '@' or s->at(s->size() - 1+1) = '@') then     return false else skip ; 
         var i : int ; i := 0 ; while i < s->size() - 1 do ( (     if (s->at(i+1) = '@' & s->at(i + 1+1) = '@') then     return false else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < s->size() - 2 do ( (     if (s->at(i+1) = '@' & s->at(i + 2+1) = '@') then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var t : boolean ; t := pd(str) ;
    var sum : int ; sum := 0 ;
    var num : int ; num := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '@') then     sum := sum + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (sum = 0) then     OclFile["System.out"].println("No solution") ; else skip ; 
    if (t) then (     var s : String ; s := "" ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '@') then (     num := num + 1 ; 
     if (num < sum) then (     OclFile["System.out"].print(s + '@' + str->at(i + 1+1)) ; 
     OclFile["System.out"].print(',') ; 
     i := i + 1 ) else     if (num = sum) then (     OclFile["System.out"].print(s + '@') ; 
         var j : int ; j := i + 1 ; while j < str->size() do ( (     OclFile["System.out"].print(str->at(j+1)) )  ;     j := j + 1 ) ) else skip ; ;  
     s := "" ; 
     continue ) else skip ; 
     s := s+(str->at(i+1)) )  ;     i := i + 1 ) ) else (     OclFile["System.out"].println("No solution") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class B31 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String S=in.next();
    boolean ok=! S.startsWith("@")&& ! S.endsWith("@");
    List<String>parts=new ArrayList<>();
    if(ok){
      int last=-1 ;
      while(true){
        int current=S.indexOf('@',last+1);
        if(current==-1){
          if(parts.isEmpty()){
            ok=false ;
            break ;
          }
          parts.add(S.substring(last+1));
          break ;
        }
        else {
          String part=S.substring(last+1,current);
          if(part.length()<2 && ! parts.isEmpty()){
            ok=false ;
            break ;
          }
          parts.add(part);
          last=current ;
        }
      }
    }
    if(ok){
      StringBuilder out=new StringBuilder();
      boolean first=true ;
      for(int i=1 ; i<parts.size(); i++){
        if(first){
          first=false ;
        }
        else {
          out.append(',');
        }
        String name=(i==1)? parts.get(0): parts.get(i-1).substring(1);
        String domain=(i==parts.size()-1)? parts.get(i): parts.get(i).substring(0,1);
        out.append(name).append('@').append(domain);
      }
      System.out.println(out);
    }
    else {
      System.out.println("No solution");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B31 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := in.getCurrent() ;
    var ok : boolean ; ok := not(S->hasPrefix("@")) & not(S->hasSuffix("@")) ;
    var parts : Sequence(String) ; parts := Sequence{} ;
    if (ok) then (     var last : int ; last := -1 ;
     while (true) do (     var current : int ; current := S.subrange(last + 1+1)->indexOf('@'+"") + last + 1 - 1  ;
     if (current = -1) then (     if (parts->isEmpty()) then (     ok := false ; 
     break ) else skip ; 
     parts := parts->including(S.subrange(last + 1+1,last + 1)) ; 
     break ) else (     var part : String ; part := S.subrange(last + 1+1,current) ;
     if (part->size() < 2 & not(parts->isEmpty())) then (     ok := false ; 
     break ) else skip ; 
     parts := parts->including(part) ; 
     last := current ) ) ) else skip ; 
    if (ok) then (     var out : String ; out := StringLib.newString() ;
     var first : boolean ; first := true ;
         var i : int ; i := 1 ; while i < parts->size() do ( (     if (first) then (     first := false ) else (     out := out + StringLib.newString(',') ) ;  
     var name : String ; name := if (i = 1) then parts->at(0+1) else parts->at(i - 1+1).subrange(1+1,1) endif ;
     var domain : String ; domain := if (i = parts->size() - 1) then parts->at(i+1) else parts->at(i+1).subrange(0+1,1) endif ;
     out := out + StringLib.newString(name) + StringLib.newString('@') + StringLib.newString(domain) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(out) ) else (     OclFile["System.out"].println("No solution") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int countPairs(int arr[],int n){
    HashMap<Integer,Integer>hm=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(hm.containsKey(arr[i]))hm.put(arr[i],hm.get(arr[i])+1);
      else hm.put(arr[i],1);
    }
    int ans=0 ;
    for(Map.Entry<Integer,Integer>it : hm.entrySet()){
      int count=it.getValue();
      ans+=(count*(count-1))/2 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]=new int[] {
      1,2,3,1 };
      System.out.println(countPairs(arr,arr.length));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var hm : Map(int,int) ; hm := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (hm->keys()->includes(arr[i+1])) then     hm := hm->union(Map{arr[i+1] |-> hm->at(arr[i+1]) + 1}) ; else     hm := hm->union(Map{arr[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (it : hm->asSet()) do ( (     var count : int ; count := it.getValue() ;
     ans := ans+((count * (count - 1)) / 2) )  ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,1} ;
     OclFile["System.out"].println(countPairs(arr, arr->size())) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class CodeforcesSubsequences {
  public static void main(String[] args)throws IOException {
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
    long k=Long.parseLong(r.readLine());
    String s="codeforces" ;
    long[] charCount=new long[] {
      1,1,1,1,1,1,1,1,1,1 };
      long prod=1 ;
      int i=0 ;
      while(prod<k){
        prod/=charCount[i];
        charCount[i]++;
        prod*=charCount[i];
        i=(i+1)% 10 ;
      }
      StringBuilder b=new StringBuilder();
      for(int t=0 ; t<10 ; t++){
        char c=s.charAt(t);
        while(charCount[t]-->0){
          b.append(c);
        }
      }
      System.out.println(b);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class CodeforcesSubsequences {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var k : long ; k := (r.readLine())->toLong() ;
    var s : String ; s := "codeforces" ;
    var charCount : Sequence(long) ; charCount := Sequence{1,1,1,1,1,1,1,1,1,1} ;
    var prod : long ; prod := 1 ;
    var i : int ; i := 0 ;
    while (prod < k) do (     prod := prod/(charCount[i+1]) ; 
     charCount[i+1] := charCount[i+1] + 1 ; 
     prod := prod*(charCount[i+1]) ; 
     i := (i + 1) mod 10 ) ; 
    var b : String ; b := StringLib.newString() ;
        var t : int ; t := 0 ; while t < 10 do ( (     var c : String ; c := s->at(t+1) ;
         while (charCount[t+1] > 0) do (        charCount[t+1] := charCount[t+1] - 1 ;     skip ; (     b := b + StringLib.newString(c) ) ;  ) )  ;     t := t + 1 ) ; 
    OclFile["System.out"].println(b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long k=sc.nextLong();
    long cur=1 ;
    int curMul=1,nextCnt=0 ;
    while(cur<k){
      cur=cur/curMul*(curMul+1);
      if(++nextCnt==10){
++curMul ;
        nextCnt=0 ;
      }
    }
    for(int i=0 ; i<10 ; i++){
      for(int j=0,l=i<nextCnt ? curMul+1 : curMul ; j<l ; j++){
        System.out.print("codeforces".charAt(i));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : long ; k := sc.getCurrent()->toLong() ;
    var cur : long ; cur := 1 ;
    var curMul : int ; curMul := 1 ;
    var nextCnt : int ; nextCnt := 0 ;
    while (cur < k) do (     cur := cur / curMul * (curMul + 1) ; 
     if ((nextCnt + 1) = 10) then (     curMul := curMul + 1 ; 
     nextCnt := 0 ) else skip ) ; 
        var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ;
    var l : int ; l := if i < nextCnt then curMul + 1 else curMul endif ; while j < l do ( (     OclFile["System.out"].print("codeforces"->at(i+1)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int a[]=new int[5];
    int r[]=new int[5];
    TreeMap<Integer,Integer>map=new TreeMap();
    for(int i=0 ; i<a.length ; i++){
      a[i]=sc.nextInt();
      r[i]=a[i] % 10 ;
      int b=10 ;
      if(r[i]!=0){
        b=10-r[i];
        map.put(b,a[i]);
      }
    }
    int ans=0 ;
    if(map.size()==0){
      for(int i=0 ; i<a.length ; i++){
        ans+=a[i];
      }
      System.out.println(ans);
      return ;
    }
    int last=map.get(map.lastKey());
    int idx=0 ;
    for(int i=0 ; i<a.length ; i++){
      if(a[i]==last){
        idx=i ;
      }
    }
    for(int i=0 ; i<a.length ; i++){
      if(i!=idx){
        if(a[i] % 10==0){
          ans+=a[i];
        }
        else {
          ans+=a[i]+(10-r[i]);
        }
      }
    }
    ans+=last ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,5)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,5)->collect(0) ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     r[i+1] := a[i+1] mod 10 ; 
     var b : int ; b := 10 ;
     if (r[i+1] /= 0) then (     b := 10 - r[i+1] ; 
     map := map->union(Map{b |-> a[i+1]}) ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    if (map.size() = 0) then (         var i : int ; i := 0 ; while i < a->size() do ( (     ans := ans+(a[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) ; 
     return ) else skip ; 
    var last : int ; last := map->at(map->keys()->max()) ;
    var idx : int ; idx := 0 ;
        var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] = last) then (     idx := i ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     if (i /= idx) then (     if (a[i+1] mod 10 = 0) then (     ans := ans+(a[i+1]) ) else (     ans := ans+(a[i+1] + (10 - r[i+1])) ) ) else skip )  ;     i := i + 1 ) ; 
    ans := ans+(last) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void decToOctal(int n){
    int[] octalNum=new int[100];
    int i=0 ;
    while(n!=0){
      octalNum[i]=n % 8 ;
      n=n/8 ;
      i++;
    }
    for(int j=i-1 ; j>=0 ; j--)System.out.print(octalNum[j]);
  }
  public static void main(String[] args){
    int n=33 ;
    decToOctal(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation decToOctal( n : int) : void
  pre: true
  post: true
  activity: (     var octalNum : Sequence(int) ; octalNum := Integer.subrange(1,100)->collect(0) ;
     var i : int ; i := 0 ;
     while (n /= 0) do (     octalNum[i+1] := n mod 8 ; 
     n := n / 8 ; 
     i := i + 1 ) ; 
         var j : int ; j := i - 1 ; while j >= 0 do (     OclFile["System.out"].print(octalNum[j+1]) ;  ;     j := j - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 33 ;
     execute decToOctal(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printPermutation(int n,int k){
    if(k>=n ||(n % 2==0 && k==0)){
      System.out.print(-1);
      return ;
    }
    int per[]=new int[n+1],i ;
    for(i=1 ; i<=n ; i++){
      per[i]=i ;
    }
    int cnt=n-1 ;
    i=2 ;
    while(i<n){
      if(cnt-1>k){
        swap(per,i,i+1);
        cnt-=2 ;
      }
      else if(cnt-1==k){
        swap(per,1,i);
        cnt--;
      }
      else {
        break ;
      }
      i+=2 ;
    }
    for(i=1 ; i<=n ; i++){
      System.out.print(per[i]+" ");
    }
  }
  static int[] swap(int[] arr,int i,int j){
    int temp=arr[i];
    arr[i]=arr[j];
    arr[j]=temp ;
    return arr ;
  }
  public static void main(String[] args){
    int n=4,k=3 ;
    printPermutation(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printPermutation( n : int, k : int) : void
  pre: true
  post: true
  activity: (     if (k >= n or (n mod 2 = 0 & k = 0)) then (     OclFile["System.out"].print(-1) ; 
     return ) else skip ; 
     var per : Sequence(int) ; per := Integer.subrange(1,n + 1)->collect(0) ;
    var i : int ;
        i := 1 ; while i <= n do ( (     per[i+1] := i )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := n - 1 ;
    i := 2 ; 
    while (i < n) do (     if (cnt - 1 > k) then (     execute swap(per, i, i + 1) ; 
     cnt := cnt-(2) ) else     if (cnt - 1 = k) then (     execute swap(per, 1, i) ; 
     cnt := cnt - 1 ) else (     break ) ;  ;  
     i := i+(2) ) ; 
        i := 1 ; while i <= n do ( (     OclFile["System.out"].print(per[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation swap( arr : Sequence(int), i : int, j : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := arr[j+1] ; 
     arr[j+1] := temp ; 
     return arr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
    var k : int ; k := 3 ;
     execute printPermutation(n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void checkSolution(int a,int b,int c){
    if(((b*b)-(4*a*c))>0)System.out.println("2 solutions");
    else if(((b*b)-(4*a*c))==0)System.out.println("1 solution");
    else System.out.println("No solutions");
  }
  public static void main(String[] args){
    int a=2,b=5,c=2 ;
    checkSolution(a,b,c);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkSolution( a : int, b : int, c : int) : void
  pre: true
  post: true
  activity: (     if (((b * b) - (4 * a * c)) > 0) then     OclFile["System.out"].println("2 solutions") ; else     if (((b * b) - (4 * a * c)) = 0) then     OclFile["System.out"].println("1 solution") else     OclFile["System.out"].println("No solutions") ; ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2 ;
    var b : int ; b := 5 ;
    var c : int ; c := 2 ;
     execute checkSolution(a, b, c) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf1295 {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=scan.nextInt();
      StringBuilder output=new StringBuilder();
      if(n % 2==1){
        output.append('7');
        n-=3 ;
      }
      while(n>0){
        output.append('1');
        n-=2 ;
      }
      System.out.println(output);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1295 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var output : String ; output := StringLib.newString() ;
    if (n mod 2 = 1) then (     output := output + StringLib.newString('7') ; 
     n := n-(3) ) else skip ; 
    while (n > 0) do (     output := output + StringLib.newString('1') ; 
     n := n-(2) ) ; 
    OclFile["System.out"].println(output) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      int[] a=IntStream.range(0,n).map(i->scanner.nextInt()).toArray();
      int[] b=IntStream.range(0,n).map(i->scanner.nextInt()).toArray();
      int[] na=new int[n],nb=new int[n];
      int answer=0 ;
      for(int k=0 ; k<30 ; k++){
        int mask=(1<<(k+1))-1 ;
        for(int i=0 ; i<n ; i++){
          na[i]=a[i] & mask ;
          nb[i]=b[i] & mask ;
        }
        Arrays.sort(nb);
        int count=0 ;
        for(int i=0 ; i<n ; i++){
          count+=lowerBound(nb,(2<<k)-na[i])-lowerBound(nb,(1<<k)-na[i]);
          count+=n-lowerBound(nb,(3<<k)-na[i]);
          count &=1 ;
        }
        if(1==(count & 1)){
          answer |=1<<k ;
        }
      }
      System.out.println(answer);
    }
  }
  private static int lowerBound(int a[],int v){
    int l=0,r=a.length-1 ;
    while(r-l>=0){
      int c=(l+r)/2 ;
      if(v<=a[c]){
        r=c-1 ;
      }
      else {
        l=c+1 ;
      }
    }
    return l ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(0, n-1)->collect( _x1 | (lambda i : OclAny in scanner.getCurrent()->toInteger())->apply(_x1) )->asSequence() ;
    var b : Sequence(int) ; b := Integer.subrange(0, n-1)->collect( _x1 | (lambda i : OclAny in scanner.getCurrent()->toInteger())->apply(_x1) )->asSequence() ;
    var na : Sequence(int) ; na := Integer.subrange(1,n)->collect(0) ;
    var nb : Sequence(int) ; nb := Integer.subrange(1,n)->collect(0) ;
    var answer : int ; answer := 0 ;
        var k : int ; k := 0 ; while k < 30 do ( (     var mask : int ; mask := ((1*(2->pow((k + 1))))->oclAsType(long)) - 1 ;
         var i : int ; i := 0 ; while i < n do ( (     na[i+1] := a[i+1] & mask ; 
     nb[i+1] := b[i+1] & mask )  ;     i := i + 1 ) ; 
    nb := nb->sort() ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     count := count+(lowerBound(nb, ((2*(2->pow(k)))->oclAsType(long)) - na[i+1]) - lowerBound(nb, ((1*(2->pow(k)))->oclAsType(long)) - na[i+1])) ; 
     count := count+(n - lowerBound(nb, ((3*(2->pow(k)))->oclAsType(long)) - na[i+1])) ; 
     count := MathLib.bitwiseAnd(count, 1) )  ;     i := i + 1 ) ; 
    if (1 = (MathLib.bitwiseAnd(count,1))) then (     answer := MathLib.bitwiseOr(answer, (1*(2->pow(k)))->oclAsType(long)) ) else skip ; 
 )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 ))  );
  static   operation lowerBound( a : Sequence(int), v : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
    var r : int ; r := a->size() - 1 ;
     while (r - l >= 0) do (     var c : int ; c := (l + r) / 2 ;
     if (v <= a[c+1]) then (     r := c - 1 ) else (     l := c + 1 ) ) ; 
     return l );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.run();
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    int b[]=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    for(int i=0 ; i<n ; i++)b[i]=sc.nextInt();
    long ans=0 ;
    for(int k=0 ; k<29 ; k++){
      int am[]=new int[n];
      int bm[]=new int[n];
      int t=1<<(k+1);
      for(int i=0 ; i<n ; i++){
        am[i]=a[i] % t ;
        bm[i]=b[i] % t ;
      }
      Arrays.sort(am);
      int cnt=0 ;
      t>>=1 ;
      for(int i=0 ; i<n ; i++){
        cnt+=lowerBound(am,2*t-bm[i])-lowerBound(am,t-bm[i]);
        cnt+=lowerBound(am,4*t-bm[i])-lowerBound(am,3*t-bm[i]);
      }
      if(cnt % 2!=0){
        ans |=(1<<k);
      }
    }
    System.out.println(ans);
    sc.close();
  }
  private int lowerBound(int a[],int v){
    int l=-1 ;
    int r=a.length ;
    while(l+1<r){
      int m=(l+r)/2 ;
      if(a[m]<v){
        l=m ;
      }
      else {
        r=m ;
      }
    }
    return r ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     b[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var k : int ; k := 0 ; while k < 29 do ( (     var am : Sequence(int) ; am := Integer.subrange(1,n)->collect(0) ;
     var bm : Sequence(int) ; bm := Integer.subrange(1,n)->collect(0) ;
    var t : int ; t := (1*(2->pow((k + 1))))->oclAsType(long) ;
        var i : int ; i := 0 ; while i < n do ( (     am[i+1] := a[i+1] mod t ; 
     bm[i+1] := b[i+1] mod t )  ;     i := i + 1 ) ; 
    am := am->sort() ; 
    var cnt : int ; cnt := 0 ;
    t := t/(2->pow(1)) ; 
        var i : int ; i := 0 ; while i < n do ( (     cnt := cnt+(lowerBound(am, 2 * t - bm[i+1]) - lowerBound(am, t - bm[i+1])) ; 
     cnt := cnt+(lowerBound(am, 4 * t - bm[i+1]) - lowerBound(am, 3 * t - bm[i+1])) )  ;     i := i + 1 ) ; 
    if (cnt mod 2 /= 0) then (     ans := MathLib.bitwiseOr(ans, ((1*(2->pow(k)))->oclAsType(long))) ) else skip ; 
 )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
   operation lowerBound( a : Sequence(int), v : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := -1 ;
     var r : int ; r := a->size() ;
     while (l + 1 < r) do (     var m : int ; m := (l + r) / 2 ;
     if (a[m+1] < v) then (     l := m ) else (     r := m ) ) ; 
     return r );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      int[] a=new int[n],b=new int[n];
      int[] na=new int[n],nb=new int[n];
      IntStream.range(0,n).forEach(i->a[i]=scanner.nextInt());
      IntStream.range(0,n).forEach(i->b[i]=scanner.nextInt());
      int answer=0 ;
      for(int k=0 ; k<30 ; k++){
        int mask=(1<<(k+1))-1 ;
        for(int i=0 ; i<n ; i++){
          na[i]=a[i] & mask ;
          nb[i]=b[i] & mask ;
        }
        Arrays.sort(nb);
        int count=0 ;
        for(int i=0 ; i<n ; i++){
          count+=lowerBound(nb,(2<<k)-na[i])-lowerBound(nb,(1<<k)-na[i]);
          count+=n-lowerBound(nb,(3<<k)-na[i]);
          count &=1 ;
        }
        if(1==(count & 1)){
          answer |=1<<k ;
        }
      }
      System.out.println(answer);
    }
  }
  private static int lowerBound(int a[],int v){
    int l=0,r=a.length-1 ;
    while(r-l>=0){
      int c=(l+r)/2 ;
      if(v<=a[c]){
        r=c-1 ;
      }
      else {
        l=c+1 ;
      }
    }
    return l ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var na : Sequence(int) ; na := Integer.subrange(1,n)->collect(0) ;
    var nb : Sequence(int) ; nb := Integer.subrange(1,n)->collect(0) ;
    for i : Integer.subrange(0, n-1) do
    (    a[i+1] := scanner.getCurrent()->toInteger()) ; 
    for i : Integer.subrange(0, n-1) do
    (    b[i+1] := scanner.getCurrent()->toInteger()) ; 
    var answer : int ; answer := 0 ;
        var k : int ; k := 0 ; while k < 30 do ( (     var mask : int ; mask := ((1*(2->pow((k + 1))))->oclAsType(long)) - 1 ;
         var i : int ; i := 0 ; while i < n do ( (     na[i+1] := a[i+1] & mask ; 
     nb[i+1] := b[i+1] & mask )  ;     i := i + 1 ) ; 
    nb := nb->sort() ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     count := count+(lowerBound(nb, ((2*(2->pow(k)))->oclAsType(long)) - na[i+1]) - lowerBound(nb, ((1*(2->pow(k)))->oclAsType(long)) - na[i+1])) ; 
     count := count+(n - lowerBound(nb, ((3*(2->pow(k)))->oclAsType(long)) - na[i+1])) ; 
     count := MathLib.bitwiseAnd(count, 1) )  ;     i := i + 1 ) ; 
    if (1 = (MathLib.bitwiseAnd(count,1))) then (     answer := MathLib.bitwiseOr(answer, (1*(2->pow(k)))->oclAsType(long)) ) else skip ; 
 )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 ))  );
  static   operation lowerBound( a : Sequence(int), v : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
    var r : int ; r := a->size() - 1 ;
     while (r - l >= 0) do (     var c : int ; c := (l + r) / 2 ;
     if (v <= a[c+1]) then (     r := c - 1 ) else (     l := c + 1 ) ) ; 
     return l );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int lowerBound(int a[],int v){
    int l=0,r=a.length-1 ;
    while(r-l>=0){
      int c=(l+r)/2 ;
      if(v<=a[c]){
        r=c-1 ;
      }
      else {
        l=c+1 ;
      }
    }
    return l ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int A[]=new int[N],B[]=new int[N];
    for(int n=0 ; n<N ; n++){
      A[n]=sc.nextInt();
    }
    for(int n=0 ; n<N ; n++){
      B[n]=sc.nextInt();
    }
    int ans=0 ;
    for(int k=0 ; k<30 ; k++){
      int[] a=Arrays.copyOf(A,N);
      int[] b=Arrays.copyOf(B,N);
      for(int i=0 ; i<N ; i++){
        a[i] &=(1<<(k+1))-1 ;
        b[i] &=(1<<(k+1))-1 ;
      }
      int count=0 ;
      Arrays.sort(b);
      for(int i=0 ; i<N ; i++){
        int k1=lowerBound(b,(1<<k)-a[i]);
        int k2=lowerBound(b,(1<<(k+1))-a[i]);
        count+=k2-k1 ;
        if(k>=1){
          int k3=lowerBound(b,(3<<k)-a[i]);
          count+=N-k3 ;
        }
        count %=2 ;
      }
      if(count % 2==1){
        ans |=1<<k ;
      }
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation lowerBound( a : Sequence(int), v : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
    var r : int ; r := a->size() - 1 ;
     while (r - l >= 0) do (     var c : int ; c := (l + r) / 2 ;
     if (v <= a[c+1]) then (     r := c - 1 ) else (     l := c + 1 ) ) ; 
     return l );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var B : Sequence(void) ; B := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := sc.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
        var n : int ; n := 0 ; while n < N do ( (     B[n+1] := sc.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var ans : int ; ans := 0 ;
        var k : int ; k := 0 ; while k < 30 do ( (     var a : Sequence(int) ; a := A.subrange(1,N) ;
     var b : Sequence(int) ; b := B.subrange(1,N) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := MathLib.bitwiseAnd(a[i+1], ((1*(2->pow((k + 1))))->oclAsType(long)) - 1) ; 
     b[i+1] := MathLib.bitwiseAnd(b[i+1], ((1*(2->pow((k + 1))))->oclAsType(long)) - 1) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    b := b->sort() ; 
        var i : int ; i := 0 ; while i < N do ( (     var k1 : int ; k1 := lowerBound(b, ((1*(2->pow(k)))->oclAsType(long)) - a[i+1]) ;
     var k2 : int ; k2 := lowerBound(b, ((1*(2->pow((k + 1))))->oclAsType(long)) - a[i+1]) ;
    count := count+(k2 - k1) ; 
    if (k >= 1) then (     var k3 : int ; k3 := lowerBound(b, ((3*(2->pow(k)))->oclAsType(long)) - a[i+1]) ;
     count := count+(N - k3) ) else skip ; 
    count := count mod 2 ; 
 )  ;     i := i + 1 ) ; 
    if (count mod 2 = 1) then (     ans := MathLib.bitwiseOr(ans, (1*(2->pow(k)))->oclAsType(long)) ) else skip ; 
 )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int[] a=new int[N];
    int[] b=new int[N];
    for(int i=0 ; i<N ; i++)a[i]=scanner.nextInt();
    for(int i=0 ; i<N ; i++)b[i]=scanner.nextInt();
    int res=0 ;
    for(int k=0 ; k<30 ; k++){
      int m=1<<(k+1);
      int[] br=new int[N];
      for(int i=0 ; i<N ; i++)br[i]=b[i] % m ;
      Arrays.sort(br);
      int[] br2=new int[N*2];
      System.arraycopy(br,0,br2,0,N);
      for(int i=0 ; i<N ; i++)br2[i+N]=br[i]+m ;
      int t=1<<k ;
      long count=0 ;
      for(int i=0 ; i<N ; i++){
        int ar=a[i] % m ;
        int left=find(br2,t*3-ar);
        int right=find(br2,t*4-ar);
        count+=right-left ;
      }
      if(count % 2==1)res+=1<<k ;
    }
    System.out.println(res);
  }
  private static int find(int[] b,int t){
    int left=-1 ;
    int right=b.length ;
    while(right-left>1){
      int mid=(left+right)/2 ;
      if(b[mid]<t){
        left=mid ;
      }
      else {
        right=mid ;
      }
    }
    return left ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     a[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do (     b[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var k : int ; k := 0 ; while k < 30 do ( (     var m : int ; m := (1*(2->pow((k + 1))))->oclAsType(long) ;
     var br : Sequence(int) ; br := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     br[i+1] := b[i+1] mod m ;  ;     i := i + 1 ) ; 
    br := br->sort() ; 
    var br2 : Sequence(int) ; br2 := Integer.subrange(1,N * 2)->collect(0) ;
    for _x : Integer.subrange(1,N) do br2[0 + _x] := br[0 + _x] ; 
        var i : int ; i := 0 ; while i < N do (     br2[i + N+1] := br[i+1] + m ;  ;     i := i + 1 ) ; 
    var t : int ; t := (1*(2->pow(k)))->oclAsType(long) ;
    var count : long ; count := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var ar : int ; ar := a[i+1] mod m ;
     var left : int ; left := find(br2, t * 3 - ar) ;
     var right : int ; right := find(br2, t * 4 - ar) ;
     count := count+(right - left) )  ;     i := i + 1 ) ; 
    if (count mod 2 = 1) then     res := res+((1*(2->pow(k)))->oclAsType(long)) ; else skip ; 
 )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static   operation find( b : Sequence(int), t : int) : int
  pre: true
  post: true
  activity: (     var left : int ; left := -1 ;
     var right : int ; right := b->size() ;
     while (right - left > 1) do (     var mid : int ; mid := (left + right) / 2 ;
     if (b[mid+1] < t) then (     left := mid ) else (     right := mid ) ) ; 
     return left );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int amtTime=0 ;
    int maxLoss=10 ;
    int maxLossNum=0 ;
    boolean a=true ;
    List<Integer>Array=new ArrayList<>();
    while(sc.hasNextInt()){
      Array.add((Integer)sc.nextInt());
    }
    for(int i=0 ; i<Array.size(); i++){
      if(Array.get(i)% 10!=0 && maxLoss>Array.get(i)% 10){
        maxLoss=Array.get(i)% 10 ;
        maxLossNum=Array.get(i);
      };
    }
    for(int j=0 ; j<Array.size(); j++){
      if(Array.get(j)==maxLossNum && a){
        a=false ;
        continue ;
      }
      else {
        int t=Array.get(j);
        int rt=t % 10 ;
        int adj=0 ;
        if(rt>0){
          adj=10-rt ;
        }
        amtTime+=t+adj ;
      }
    }
    System.out.println(amtTime+maxLossNum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var amtTime : int ; amtTime := 0 ;
    var maxLoss : int ; maxLoss := 10 ;
    var maxLossNum : int ; maxLossNum := 0 ;
    var a : boolean ; a := true ;
    var Array : Sequence(int) ; Array := Sequence{} ;
    while (sc.hasNextInt()) do (     Array := Array->including(sc.getCurrent()->toInteger()->oclAsType(int)) ) ; 
        var i : int ; i := 0 ; while i < (methodCall size ( )) do ( (     if (i[i+1] mod 10 /= 0 & maxLoss > i[i+1] mod 10) then (     maxLoss := i[i+1] mod 10 ; 
     maxLossNum := i[i+1] ) else skip ; 
  )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < (methodCall size ( )) do ( (     if (j[j+1] = maxLossNum & a) then (     a := false ; 
     continue ) else (     var t : int ; t := j[j+1] ;
     var rt : int ; rt := t mod 10 ;
    var adj : int ; adj := 0 ;
    if (rt > 0) then (     adj := 10 - rt ) else skip ; 
    amtTime := amtTime+(t + adj) ; 
 ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(amtTime + maxLossNum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static void vowelOrConsonant(char x){
    if(x=='a' || x=='e' || x=='i' || x=='o' || x=='u')System.out.println("Vowel");
    else System.out.println("Consonant");
  }
  static public void main(String[] args){
    vowelOrConsonant('c');
    vowelOrConsonant('e');
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation vowelOrConsonant( x : String) : void
  pre: true
  post: true
  activity: (     if (x = 'a' or x = 'e' or x = 'i' or x = 'o' or x = 'u') then     OclFile["System.out"].println("Vowel") ; else     OclFile["System.out"].println("Consonant") ; );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute vowelOrConsonant('c') ; 
     execute vowelOrConsonant('e') );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printGroups(int n){
    int x=1 ;
    int y=n*n ;
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=n/2 ; j++){
        System.out.print("{ "+x+","+y+"} ");
        x++;
        y--;
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    int n=4 ;
    printGroups(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printGroups( n : int) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 1 ;
     var y : int ; y := n * n ;
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n / 2 do ( (     OclFile["System.out"].print("{ " + x + "," + y + "} ") ; 
     x := x + 1 ; 
     y := y - 1 )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     execute printGroups(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findRealAndImag(String s){
    int l=s.length();
    int i ;
    if(s.indexOf('+')!=-1){
      i=s.indexOf('+');
    }
    else {
      i=s.indexOf('-');
    }
    String real=s.substring(0,i);
    String imaginary=s.substring(i+1,l-1);
    System.out.println("Real part: "+real);
    System.out.println("Imaginary part: "+imaginary);
  }
  public static void main(String[] args){
    String s="3+4i" ;
    findRealAndImag(s);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findRealAndImag( s : String) : void
  pre: true
  post: true
  activity: (     var l : int ; l := s->size() ;
     var i : int ;
    if (s->indexOf('+')-1 /= -1) then (     i := s->indexOf('+')-1 ) else (     i := s->indexOf('-')-1 ) ;  
    var real : String ; real := s.subrange(0+1,i) ;
    var imaginary : String ; imaginary := s.subrange(i + 1+1,l - 1) ;
    OclFile["System.out"].println("Real part: " + real) ; 
    OclFile["System.out"].println("Imaginary part: " + imaginary) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "3+4i" ;
     execute findRealAndImag(s) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int arr[]=new int[n];
    int max=-1 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=s.nextInt();
      max=Math.max(max,arr[i]);
    }
    int count=0,ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==max){
        count++;
      }
      else {
        ans=Math.max(ans,count);
        count=0 ;
      }
    }
    System.out.println(Math.max(ans,count));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() ; 
     max := Set{max, arr[i+1]}->max() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = max) then (     count := count + 1 ) else (     ans := Set{ans, count}->max() ; 
     count := 0 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{ans, count}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  PrintWriter out=new PrintWriter(System.out);
  BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer tok=new StringTokenizer("");
  String next()throws IOException {
    if(! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  int ni()throws IOException {
    return Integer.parseInt(next());
  }
  long nl()throws IOException {
    return Long.parseLong(next());
  }
  long mod=1000000007 ;
  void solve()throws IOException {
    int n=ni();
    int prev=ni();
    int max=prev ;
    int ct=1 ;
    int maxct=1 ;
    for(int i=1 ; i<n ; i++){
      int u=ni();
      if(u<max){
        ct=0 ;
        continue ;
      }
      if(u==max){
        ct++;
        maxct=Math.max(maxct,ct);
        continue ;
      }
      max=u ;
      ct=1 ;
      maxct=1 ;
    }
    out.println(maxct);
    out.flush();
  }
  int gcd(int a,int b){
    return(b==0 ? a : gcd(b,a % b));
  }
  long gcd(long a,long b){
    return(b==0 ? a : gcd(b,a % b));
  }
  long mp(long a,long p){
    long r=1 ;
    while(p>0){
      if((p & 1)==1)r=(r*a)% mod ;
      p>>=1 ;
      a=(a*a)% mod ;
    }
    return r ;
  }
  public static void main(String[] args)throws IOException {
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute tok : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     if (not(tok.hasNext())) then (     tok := OclIterator.newOclIterator_String(in.readLine()) ) else skip ; 
     return tok.next() );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nl() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   attribute mod : long := 1000000007;
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := ni() ;
     var prev : int ; prev := ni() ;
    var max : int ; max := prev ;
    var ct : int ; ct := 1 ;
    var maxct : int ; maxct := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     var u : int ; u := ni() ;
     if (u < max) then (     ct := 0 ; 
     continue ) else skip ; 
    if (u = max) then (     ct := ct + 1 ; 
     maxct := Set{maxct, ct}->max() ; 
     continue ) else skip ; 
    max := u ; 
    ct := 1 ; 
    maxct := 1 ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return (if b = 0 then a else gcd(b, a mod b) endif) );
   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (if b = 0 then a else gcd(b, a mod b) endif) );
   operation mp( a : long, p : long) : long
  pre: true
  post: true
  activity: (     var r : long ; r := 1 ;
     while (p > 0) do (     if ((p & 1) = 1) then     r := (r * a) mod mod ; else skip ; 
     p := p/(2->pow(1)) ; 
     a := (a * a) mod mod ) ; 
     return r );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.TreeSet ;
class GFG {
  static void printPrevGreater(int[] arr,int n){
    TreeSet<Integer>ts=new TreeSet<>();
    for(int i=0 ; i<n ; i++){
      Integer c=ts.ceiling(arr[i]);
      if(c==null)System.out.print(-1+" ");
      else System.out.print(c+" ");
      ts.add(arr[i]);
    }
  }
  public static void main(String[] args){
    int[] arr={
      10,5,11,10,20,12 };
      int n=arr.length ;
      printPrevGreater(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printPrevGreater( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var ts : Set(int) ; ts := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     var c : int ; c := ts.ceiling(arr[i+1]) ;
     if (c = null) then     OclFile["System.out"].print(-1 + " ") else     OclFile["System.out"].print(c + " ") ; ;  
     ts := ts->including(arr[i+1]) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,5,11,10,20,12} ;
     var n : int ; n := arr->size() ;
     execute printPrevGreater(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
public class esep {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n-->0){
      int x=sc.nextInt();
      if(x % 2!=0){
        System.out.print(7);
        x-=3 ;
      }
      for(int i=0 ; i<x/2 ; i++){
        System.out.print(1);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class esep {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x mod 2 /= 0) then (     OclFile["System.out"].print(7) ; 
     x := x-(3) ) else skip ; 
         var i : int ; i := 0 ; while i < x / 2 do ( (     OclFile["System.out"].print(1) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long mod=(long)(1e9+7);
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int a[]=new int[n];
    ArrayList<Integer>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
      list.add(a[i]);
    }
    Collections.sort(list);
    int max=list.get(n-1);
    int c=1 ;
    int max_sub=0 ;
    if(n==1){
      max_sub=1 ;
    }
    else {
      for(int i=0 ; i<n-1 ; i++){
        if(a[i]==max && a[i+1]==max){
          c++;
        }
        else {
          c=1 ;
        }
        max_sub=Math.max(max_sub,c);
      }
    }
    pw.println(max_sub);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := (1e9 + 7)->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     list := list->including(a[i+1]) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var max : int ; max := list->at(n - 1+1) ;
    var c : int ; c := 1 ;
    var max_sub : int ; max_sub := 0 ;
    if (n = 1) then (     max_sub := 1 ) else (         var i : int ; i := 0 ; while i < n - 1 do ( (     if (a[i+1] = max & a[i + 1+1] = max) then (     c := c + 1 ) else (     c := 1 ) ;  
     max_sub := Set{max_sub, c}->max() )  ;     i := i + 1 ) ) ;  
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    Scanner sc=new Scanner(systemin);
    int N=sc.nextInt();
    int M=sc.nextInt();
    sc.nextLine();
    String[] s=new String[N];
    int cnt=0 ;
    for(int i=0 ; i<N ; i++){
      s[i]=sc.nextLine();
      log.printf("%s\n",s[i]);
    }
    for(int i=0 ; i<N ; i++){
      String t=sc.nextLine();
      log.printf("%s\n",t);
      for(int j=0 ; j<M ; j++){
        if(s[i] .charAt(j)!=t.charAt(j)){
          cnt++;
        }
      }
    }
    System.out.printf("%d\n",cnt);
    sc.close();
    return false ;
  }
  PrintStream log ;
  PrintStream result=System.out ;
  BufferedReader systemin ;
  static Main instance=new Main();
  Main(){
    systemin=new BufferedReader(new InputStreamReader(System.in));
    log=new PrintStream(new OutputStream(){
      public void write(int b){
      }
    }
);
  }
  public static void main(String[] args)throws IOException {
    instance.main();
    instance.systemin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(systemin) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    skip ; 
    var s : Sequence(String) ; s := Integer.subrange(1,N)->collect(null) ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     s[i+1] := sc.nextLine() ; 
     log.printf("%s\n", s[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var t : String ; t := sc.nextLine() ;
     log.printf("%s\n", t) ; 
         var j : int ; j := 0 ; while j < M do ( (     if (s[i+1]->at(j+1) /= t->at(j+1)) then (     cnt := cnt + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%d\n", cnt) ; 
    skip ; 
    return false 
 );
   attribute log : OclFile;
   attribute result : OclFile := OclFile["System.out"];
   attribute systemin : OclFile;
  static   attribute instance : Main := Main.newMain();
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     systemin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     log := OclFile.newOclFile_Write(OclFile()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     instance.main() ; 
     instance.systemin.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    char[][] field=new char[n][];
    for(int i=0 ; i<n ; i++){
      field[i]=sc.next().toCharArray();
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      char[] arr=sc.next().toCharArray();
      for(int j=0 ; j<m ; j++){
        if(arr[j]!=field[i][j]){
          count++;
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var field : Sequence(Sequence(String)) ; field := Integer.subrange(1,n)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < n do ( (     field[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
         var j : int ; j := 0 ; while j < m do ( (     if (arr[j+1] /= field[i+1][j+1]) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static void solve(){
    Scanner sc=new Scanner(System.in);
    int array[]=new int[5];
    int plus=0 ;
    int max=0 ;
    for(int i=0 ; i<array.length ; i++){
      array[i]=sc.nextInt();
      if(array[i] % 10!=0){
        plus=10-array[i] % 10 ;
        array[i]+=plus ;
        max=Math.max(max,plus);
      }
    }
    System.out.println(array[0]+array[1]+array[2]+array[3]+array[4]-max);
    sc.close();
  }
  public static void main(String[] args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var array : Sequence(int) ; array := Integer.subrange(1,5)->collect(0) ;
    var plus : int ; plus := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < array->size() do ( (     array[i+1] := sc.getCurrent()->toInteger() ; 
     if (array[i+1] mod 10 /= 0) then (     plus := 10 - array[i+1] mod 10 ; 
     array[i+1] := array[i+1]+(plus) ; 
     max := Set{max, plus}->max() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(array[0+1] + array[1+1] + array[2+1] + array[3+1] + array[4+1] - max) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CodeForces1536A {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int s=input.nextInt();
    int d=input.nextInt();
    int c=s ;
    int ans=s ;
    int m=0 ;
    for(int i=1 ; i<n ; i++){
      s=input.nextInt();
      d=input.nextInt();
      if(s>c){
        ans+=s-c ;
        c=s ;
      }
      else {
        m=(c-s+d-1)/d+1 ;
        ans+=(m-1)*d+s-c ;
        if((m-1)*d+s-c==0){
          ans+=d ;
          c=m*d+s ;
        }
        else {
          c=(m-1)*d+s ;
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces1536A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var s : int ; s := input.getCurrent()->toInteger() ;
    var d : int ; d := input.getCurrent()->toInteger() ;
    var c : int ; c := s ;
    var ans : int ; ans := s ;
    var m : int ; m := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     s := input.getCurrent()->toInteger() ; 
     d := input.getCurrent()->toInteger() ; 
     if (s > c) then (     ans := ans+(s - c) ; 
     c := s ) else (     m := (c - s + d - 1) / d + 1 ; 
     ans := ans+((m - 1) * d + s - c) ; 
     if ((m - 1) * d + s - c = 0) then (     ans := ans+(d) ; 
     c := m * d + s ) else (     c := (m - 1) * d + s ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class div_2_443_a {
  public static void main(String args[]){
    FScanner in=new FScanner();
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt();
    int s[]=new int[n];
    int d[]=new int[n];
    for(int i=0 ; i<n ; i++){
      s[i]=in.nextInt();
      d[i]=in.nextInt();
    }
    int ans=s[0];
    for(int i=1 ; i<n ; i++){
      while(s[i]<=s[i-1]){
        s[i]+=d[i];
      }
    }
    out.println(s[n-1]);
    out.close();
  }
  static class FScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer sb=new StringTokenizer("");
    String next(){
      while(! sb.hasMoreTokens()){
        try {
          sb=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
        }
      }
      return sb.nextToken();
    }
    String nextLine(){
      try {
        return br.readLine();
      }
      catch(IOException e){
      }
      return "" ;
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    int[] readArray(int n){
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    float nextFloat(){
      return Float.parseFloat(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class div{
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FScanner ; in := FScanner.newFScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.nextInt() ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := in.nextInt() ; 
     d[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := s[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     while (s[i+1] <= s[i - 1+1]) do (     s[i+1] := s[i+1]+(d[i+1]) ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute sb : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(sb.hasNext())) do (     try (     sb := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ) ; 
     return sb.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do skip
     return "" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}
_443_a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FScanner ; in := FScanner.newFScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.nextInt() ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := in.nextInt() ; 
     d[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := s[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     while (s[i+1] <= s[i - 1+1]) do (     s[i+1] := s[i+1]+(d[i+1]) ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute sb : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(sb.hasNext())) do (     try (     sb := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ) ; 
     return sb.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do skip
     return "" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Diagnoz {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int nDoctors=in.nextInt();
    int nDay=0 ;
    for(int i=0 ; i<nDoctors ; i++){
      int startWork=in.nextInt();
      int days=in.nextInt();
      while(startWork<=nDay)startWork+=days ;
      nDay=startWork ;
    }
    System.out.println(nDay);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Diagnoz {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var nDoctors : int ; nDoctors := in.getCurrent()->toInteger() ;
    var nDay : int ; nDay := 0 ;
        var i : int ; i := 0 ; while i < nDoctors do ( (     var startWork : int ; startWork := in.getCurrent()->toInteger() ;
     var days : int ; days := in.getCurrent()->toInteger() ;
     while (startWork <= nDay) do     startWork := startWork+(days) ; ; 
     nDay := startWork )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(nDay) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication168<T>{
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=0 ;
    int b=0 ;
    int ck=0 ;
    for(int i=0 ; i<n ; i++){
      a=sc.nextInt();
      b=sc.nextInt();
      while(a<=ck){
        a+=b ;
      }
      ck=a ;
    }
    System.out.println(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication168<T> {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
    var ck : int ; ck := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a := sc.getCurrent()->toInteger() ; 
     b := sc.getCurrent()->toInteger() ; 
     while (a <= ck) do (     a := a+(b) ) ; 
     ck := a )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findX(int A,int B){
    int j=0,x=0 ;
    while(A!=0 || B!=0){
      if((A % 2==1)&&(B % 2==1)){
        x+=(1<<j);
      }
      A>>=1 ;
      B>>=1 ;
      j+=1 ;
    }
    return x ;
  }
  public static void main(String[] args){
    int A=2,B=3 ;
    int X=findX(A,B);
    System.out.println("X="+X+",Sum="+((A ^ X)+(B ^ X)));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findX( A : int, B : int) : int
  pre: true
  post: true
  activity: (     var j : int ; j := 0 ;
    var x : int ; x := 0 ;
     while (A /= 0 or B /= 0) do (     if ((A mod 2 = 1) & (B mod 2 = 1)) then (     x := x+(((1*(2->pow(j)))->oclAsType(long))) ) else skip ; 
     A := A/(2->pow(1)) ; 
     B := B/(2->pow(1)) ; 
     j := j+(1) ) ; 
     return x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 2 ;
    var B : int ; B := 3 ;
     var X : int ; X := findX(A, B) ;
     OclFile["System.out"].println("X=" + X + ",Sum=" + ((MathLib.bitwiseXor(A,X)) + (MathLib.bitwiseXor(B,X)))) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Vector<String>splitStrings(String str,char dl){
    String word="" ;
    int num=0 ;
    str=str+dl ;
    int l=str.length();
    Vector<String>substr_list=new Vector<String>();
    for(int i=0 ; i<l ; i++){
      if(str.charAt(i)!=dl){
        word=word+str.charAt(i);
      }
      else {
        if((int)word.length()!=0){
          substr_list.add(word);
        }
        word="" ;
      }
    }
    return substr_list ;
  }
  public static void main(String[] args){
    String str="geeks;for;geeks" ;
    char dl=';' ;
    Vector<String>res=splitStrings(str,dl);
    for(String x : res){
      System.out.println(x);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation splitStrings( str : String, dl : String) : Sequence(String)
  pre: true
  post: true
  activity: (     var word : String ; word := "" ;
     var num : int ; num := 0 ;
    str := str + dl ; 
    var l : int ; l := str->size() ;
    var substr_list : Sequence(String) ; substr_list := Sequence{} ;
        var i : int ; i := 0 ; while i < l do ( (     if (str->at(i+1) /= dl) then (     word := word + str->at(i+1) ) else (     if (word->size()->oclAsType(int) /= 0) then (     substr_list := substr_list->including(word) ) else skip ; 
     word := "" ) )  ;     i := i + 1 ) ; 
    return substr_list 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeks;for;geeks" ;
     var dl : String ; dl := ';' ;
     var res : Sequence(String) ; res := splitStrings(str, dl) ;
     for (x : res) do ( (     OclFile["System.out"].println(x) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Test {
  public static int floorSqrt(int x){
    if(x==0 || x==1)return x ;
    int start=1,end=x,ans=0 ;
    while(start<=end){
      int mid=(start+end)/2 ;
      if(mid*mid==x)return mid ;
      if(mid*mid<x){
        start=mid+1 ;
        ans=mid ;
      }
      else end=mid-1 ;
    }
    return ans ;
  }
  public static void main(String args[]){
    int x=11 ;
    System.out.println(floorSqrt(x));
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation floorSqrt( x : int) : int
  pre: true
  post: true
  activity: (     if (x = 0 or x = 1) then     return x else skip ; 
     var start : int ; start := 1 ;
    var end : int ; end := x ;
    var ans : int ; ans := 0 ;
     while (start <= end) do (     var mid : int ; mid := (start + end) / 2 ;
     if (mid * mid = x) then     return mid else skip ; 
     if (mid * mid < x) then (     start := mid + 1 ; 
     ans := mid ) else     end := mid - 1 ; ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 11 ;
     OclFile["System.out"].println(floorSqrt(x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long getSum(long n,int d){
    if(n<d)return 0 ;
    while(n % 10!=d)n--;
    long k=n/10 ;
    return(k+1)*d+(k*10+10*k*k)/2 ;
  }
  public static void main(String[] args){
    long n=30 ;
    int d=3 ;
    System.out.println(getSum(n,d));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getSum( n : long, d : int) : long
  pre: true
  post: true
  activity: (     if (n < d) then     return 0 else skip ; 
     while (n mod 10 /= d) do     n := n - 1 ; ; 
     var k : long ; k := n / 10 ;
     return (k + 1) * d + (k * 10 + 10 * k * k) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 30 ;
     var d : int ; d := 3 ;
     OclFile["System.out"].println(getSum(n, d)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static int bubble_sort(int[] dat){
    int num=0 ;
    for(int i=0 ; i<dat.length ; ++i){
      for(int j=1 ; j<dat.length-i ; ++j){
        if(dat[j-1]>dat[j]){
++num ;
          int t=dat[j-1];
          dat[j-1]=dat[j];
          dat[j]=t ;
        }
      }
    }
    return num ;
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    while(s.hasNext()){
      int n=s.nextInt();
      if(n==0)break ;
      int[] dat=new int[n];
      for(int i=0 ; i<n ; ++i){
        dat[i]=s.nextInt();
      }
      System.out.println(bubble_sort(dat));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation bubble_sort( dat : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var num : int ; num := 0 ;
         var i : int ; i := 0 ; while i < dat->size() do ( (         var j : int ; j := 1 ; while j < dat->size() - i do ( (     if (dat[j - 1+1] > dat[j+1]) then (     num := num + 1 ; 
     var t : int ; t := dat[j - 1+1] ;
     dat[j - 1+1] := dat[j+1] ; 
     dat[j+1] := t ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return num );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (s.hasNext()) do (     var n : int ; n := s.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var dat : Sequence(int) ; dat := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     dat[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(bubble_sort(dat)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,i,j,count,tmp ;
    int[] a ;
    for(; ; ){
      n=sc.nextInt();
      if(n==0)break ;
      a=new int[n];
      for(i=0 ; i<n ; i++)a[i]=sc.nextInt();
      count=0 ;
      for(i=0 ; i<n-1 ; i++)for(j=0 ; j<n-1-i ; j++)if(a[j]>a[j+1]){
        tmp=a[j];
        a[j]=a[j+1];
        a[j+1]=tmp ;
        count++;
      }
      out.println(count);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var i : int ;
    var j : int ;
    var count : int ;
    var tmp : int ;
    var a : Sequence(int) ;
      while true do ( (     n := sc.nextInt() ; 
     if (n = 0) then     break else skip ; 
    a := Integer.subrange(1,n)->collect(0) ; 
        i := 0 ; while i < n do (     a[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
    count := 0 ; 
        i := 0 ; while i < n - 1 do (         j := 0 ; while j < n - 1 - i do (     if (a[j+1] > a[j + 1+1]) then (     tmp := a[j+1] ; 
     a[j+1] := a[j + 1+1] ; 
     a[j + 1+1] := tmp ; 
     count := count + 1 ) else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    out.println(count) ; 
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPerfectSquare(double x){
    double sr=Math.sqrt(x);
    return((sr-Math.floor(sr))==0);
  }
  static boolean isProduct(int num){
    int cnt=0 ;
    for(int i=2 ; cnt<2 && i*i<=num ; ++i){
      while(num % i==0){
        num/=i ;
++cnt ;
      }
    }
    if(num>1)++cnt ;
    return cnt==2 ;
  }
  static void findNumbers(int N){
    Vector<Integer>vec=new Vector<Integer>();
    for(int i=1 ; i<=N ; i++){
      if(isProduct(i)&& ! isPerfectSquare(i)){
        vec.add(i);
      }
    }
    Iterator<Integer>itr=vec.iterator();
    while(itr.hasNext()){
      System.out.print(itr.next()+" ");
    }
  }
  public static void main(String[] args){
    int N=30 ;
    findNumbers(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPerfectSquare( x : double) : boolean
  pre: true
  post: true
  activity: (     var sr : double ; sr := (x)->sqrt() ;
     return ((sr - (sr)->floor()) = 0) );
  static   operation isProduct( num : int) : boolean
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 2 ; while cnt < 2 & i * i <= num do ( (     while (num mod i = 0) do (     num := num/(i) ; 
     cnt := cnt + 1 ) )  ;     i := i + 1 ) ; 
     if (num > 1) then     cnt := cnt + 1 ; else skip ; 
     return cnt = 2 );
  static   operation findNumbers( N : int) : void
  pre: true
  post: true
  activity: (     var vec : Sequence(int) ; vec := Sequence{} ;
         var i : int ; i := 1 ; while i <= N do ( (     if (isProduct(i) & not(isPerfectSquare(i))) then (     vec := vec->including(i) ) else skip )  ;     i := i + 1 ) ; 
     var itr : OclIterator ; itr := vec->iterator() ;
     while (itr.hasNext()) do (     OclFile["System.out"].print(itr.next() + " ") ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 30 ;
     execute findNumbers(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import static java.util.Arrays.fill ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      int res=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=i+1 ; j<n ; j++){
          if(a[i]>a[j])res++;
        }
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (a[i+1] > a[j+1]) then     res := res + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=Integer.parseInt(line);
      if(n==0){
        break ;
      }
      int[] array=new int[n];
      for(int i=0 ; i<n ; i++){
        array[i]=Integer.parseInt(br.readLine());
      }
      int count=0 ;
      for(int i=n-1 ; i>0 ; i--){
        for(int j=0 ; j<i ; j++){
          if(array[j]>array[j+1]){
            int swap=array[j];
            array[j]=array[j+1];
            array[j+1]=swap ;
            count++;
          }
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := (line)->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := (n)->char2byte() - 1 ; while i > 0 do ( (         var j : int ; j := 0 ; while j < i do ( (     if (array[j+1] > array[j + 1+1]) then (     var swap : int ; swap := array[j+1] ;
     array[j+1] := array[j + 1+1] ; 
     array[j + 1+1] := swap ; 
     count := count + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int mergecount(ArrayList<Integer>a){
    int count=0 ;
    int n=a.size();
    if(n>1){
      ArrayList<Integer>b=new ArrayList<Integer>();
      for(int i=0 ; i<n/2 ; i++)b.add(a.get(i));
      ArrayList<Integer>c=new ArrayList<Integer>();
      for(int i=n/2 ; i<n ; i++)c.add(a.get(i));
      count+=mergecount(b);
      count+=mergecount(c);
      for(int i=0,j=0,k=0 ; i<n ; i++){
        if(k==c.size())a.set(i,b.get(j++));
        else if(j==b.size())a.set(i,c.get(k++));
        else if(b.get(j)<=c.get(k))a.set(i,b.get(j++));
        else {
          a.set(i,c.get(k++));
          count+=n/2-j ;
        }
      }
    }
    return count ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      ArrayList<Integer>al=new ArrayList<Integer>();
      for(int i=0 ; i<n ; i++){
        al.add(sc.nextInt());
      }
      System.out.println(mergecount(al));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation mergecount( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var n : int ; n := a->size() ;
     if (n > 1) then (     var b : Sequence(int) ; b := Sequence{} ;
         var i : int ; i := 0 ; while i < n / 2 do (     b := b->including(a->at(i+1)) ;  ;     i := i + 1 ) ; 
    var c : Sequence(int) ; c := Sequence{} ;
        var i : int ; i := n / 2 ; while i < n do (     c := c->including(a->at(i+1)) ;  ;     i := i + 1 ) ; 
    count := count+(mergecount(b)) ; 
    count := count+(mergecount(c)) ; 
        var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    var k : int ; k := 0 ; while i < n do ( (     if (k = c->size()) then     a := a.setAt(i+1, b->at(j+1)) ; else     if (j = b->size()) then     a := a.setAt(i+1, c->at(k+1)) else     if (b->at(j+1) <= c->at(k+1)) then     a := a.setAt(i+1, b->at(j+1)) else (     a := a.setAt(i+1, c->at(k+1)) ; 
     count := count+(n / 2 - j) ) ;  ;  )  ;     i := i + 1 ) ; 
 ) else skip ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var al : Sequence(int) ; al := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     al := al->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(mergecount(al)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
public class Main {
  public static final int BIG_NUM=2000000000 ;
  public static final int MOD=1000000007 ;
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String input[]=br.readLine().split("\\s+");
      BigInteger A=new BigInteger(input[0]);
      BigInteger B=new BigInteger(input[1]);
      BigInteger ans[]=A.divideAndRemainder(B);
      System.out.println(ans[1]);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BIG_NUM : int := 2000000000;
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var input : Sequence(String) ; input := br.readLine()->split("\\s+") ;
     var A : long ; A := long(input[0+1]) ;
    var B : long ; B := long(input[1+1]) ;
    var ans : Sequence(long) ; ans := A.divideAndRemainder(B) ;
    OclFile["System.out"].println(ans[1+1]) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    BigInteger a,b ;
    Scanner cin=new Scanner(System.in);
    a=cin.nextBigInteger();
    b=cin.nextBigInteger();
    System.out.println(a.remainder(b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ;
    var b : long ;
     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    a := cin.nextBigInteger() ; 
    b := cin.nextBigInteger() ; 
    OclFile["System.out"].println(a.remainder(b)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(new BufferedInputStream(System.in));
    while(in.hasNext()){
      BigInteger a=in.nextBigInteger(),b=in.nextBigInteger();
      System.out.println(a.remainder(b));
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (in.hasNext()) do (     var a : long ; a := in.nextBigInteger() ;
    var b : long ; b := in.nextBigInteger() ;
     OclFile["System.out"].println(a.remainder(b)) ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    BigInteger a=new BigInteger(str);
    str=sc.next();
    BigInteger b=new BigInteger(str);
    System.out.println(a.remainder(b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var a : long ; a := long(str) ;
    str := sc.getCurrent() ; 
    var b : long ; b := long(str) ;
    OclFile["System.out"].println(a.remainder(b)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    String s ;
    Scanner reader=new Scanner(System.in);
    s=reader.nextLine();
    String[] str ;
    str=s.split(" ");
    BigInteger a=new BigInteger(str[0]);
    BigInteger b=new BigInteger(str[1]);
    BigInteger c=a.mod(b);
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    s := reader.nextLine() ; 
    var str : Sequence(String) ;
    str := s->split(" ") ; 
    var a : long ; a := long(str[0+1]) ;
    var b : long ; b := long(str[1+1]) ;
    var c : long ; c := a.mod(b) ;
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
public class Main {
  public static final int BIG_NUM=2000000000 ;
  public static final int MOD=1000000007 ;
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String input[]=br.readLine().split("\\s+");
      String str_A=input[0],str_B=input[1];
      BigInteger A=new BigInteger(input[0]);
      BigInteger B=new BigInteger(input[1]);
      BigInteger ans ;
      ans=A.add(B);
      System.out.println(ans);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BIG_NUM : int := 2000000000;
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var input : Sequence(String) ; input := br.readLine()->split("\\s+") ;
     var str_A : String ; str_A := input[0+1] ;
    var str_B : String ; str_B := input[1+1] ;
    var A : long ; A := long(input[0+1]) ;
    var B : long ; B := long(input[1+1]) ;
    var ans : long ;
    ans := A->excludes(B) ; 
    OclFile["System.out"].println(ans) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int OddDivCount(int a,int b){
    int res=0 ;
    for(int i=a ; i<=b ; ++i){
      int divCount=0 ;
      for(int j=1 ; j<=i ; ++j){
        if(i % j==0){
++divCount ;
        }
      }
      if((divCount % 2)!=0){
++res ;
      }
    }
    return res ;
  }
  public static void main(String[] args){
    int a=1,b=10 ;
    System.out.println(OddDivCount(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation OddDivCount( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := a ; while i <= b do ( (     var divCount : int ; divCount := 0 ;
         var j : int ; j := 1 ; while j <= i do ( (     if (i mod j = 0) then (     divCount := divCount + 1 ) else skip )  ;     j := j + 1 ) ; 
     if ((divCount mod 2) /= 0) then (     res := res + 1 ) else skip )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 1 ;
    var b : int ; b := 10 ;
     OclFile["System.out"].println(OddDivCount(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Test {
  public static void main(String[] args){
    String s="111111101010101111100101001111111 100000100000000001010110001000001 101110100110110000011010001011101 101110101011001001111101001011101 101110101100011000111100101011101 100000101010101011010000101000001 111111101010101010101010101111111 000000001111101111100111100000000 100010111100100001011110111111001 110111001111111100100001000101100 011100111010000101000111010001010 011110000110001111110101100000011 111111111111111000111001001011000 111000010111010011010011010100100 101010100010110010110101010000010 101100000101010001111101000000000 000010100011001101000111101011010 101001001111101111000101010001110 101101111111000100100001110001000 000010011000100110000011010000010 001101101001101110010010011011000 011101011010001000111101010100110 111010100110011101001101000001110 110001010010101111000101111111000 001000111011100001010110111110000 000000001110010110100010100010110 111111101000101111000110101011010 100000100111010101111100100011011 101110101001010000101000111111000 101110100011010010010111111011010 101110100100011011110110101110000 100000100110011001111100111100000 111111101101000101001101110010001" ;
    String[] array=s.split(" ");
    Scanner input=new Scanner(System.in);
    int x=input.nextInt();
    int y=input.nextInt();
    System.out.print(array[x] .charAt(y));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "111111101010101111100101001111111 100000100000000001010110001000001 101110100110110000011010001011101 101110101011001001111101001011101 101110101100011000111100101011101 100000101010101011010000101000001 111111101010101010101010101111111 000000001111101111100111100000000 100010111100100001011110111111001 110111001111111100100001000101100 011100111010000101000111010001010 011110000110001111110101100000011 111111111111111000111001001011000 111000010111010011010011010100100 101010100010110010110101010000010 101100000101010001111101000000000 000010100011001101000111101011010 101001001111101111000101010001110 101101111111000100100001110001000 000010011000100110000011010000010 001101101001101110010010011011000 011101011010001000111101010100110 111010100110011101001101000001110 110001010010101111000101111111000 001000111011100001010110111110000 000000001110010110100010100010110 111111101000101111000110101011010 100000100111010101111100100011011 101110101001010000101000111111000 101110100011010010010111111011010 101110100100011011110110101110000 100000100110011001111100111100000 111111101101000101001101110010001" ;
     var array : Sequence(String) ; array := s->split(" ") ;
    var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var x : int ; x := input.getCurrent()->toInteger() ;
    var y : int ; y := input.getCurrent()->toInteger() ;
    OclFile["System.out"].print(array[x+1]->at(y+1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    BigInteger a,b ;
    Scanner cin=new Scanner(System.in);
    a=cin.nextBigInteger();
    b=cin.nextBigInteger();
    System.out.println(a.add(b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ;
    var b : long ;
     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    a := cin.nextBigInteger() ; 
    b := cin.nextBigInteger() ; 
    OclFile["System.out"].println(a->excludes(b)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(new BufferedInputStream(System.in));
    while(in.hasNext()){
      BigInteger a=in.nextBigInteger(),b=in.nextBigInteger();
      System.out.println(a.add(b));
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (in.hasNext()) do (     var a : long ; a := in.nextBigInteger() ;
    var b : long ; b := in.nextBigInteger() ;
     OclFile["System.out"].println(a->excludes(b)) ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    BigInteger a=new BigInteger(str);
    str=sc.next();
    BigInteger b=new BigInteger(str);
    System.out.println(a.add(b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var a : long ; a := long(str) ;
    str := sc.getCurrent() ; 
    var b : long ; b := long(str) ;
    OclFile["System.out"].println(a->excludes(b)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    String s ;
    Scanner reader=new Scanner(System.in);
    s=reader.nextLine();
    String[] str ;
    str=s.split(" ");
    BigInteger a=new BigInteger(str[0]);
    BigInteger b=new BigInteger(str[1]);
    BigInteger c=a.add(b);
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    s := reader.nextLine() ; 
    var str : Sequence(String) ;
    str := s->split(" ") ; 
    var a : long ; a := long(str[0+1]) ;
    var b : long ; b := long(str[1+1]) ;
    var c : long ; c := a->excludes(b) ;
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int N=(int)1E6 ;
  static boolean[] fourDiv=new boolean[N+1];
  static void fourDistinctFactors(){
    boolean[] primeAll=new boolean[N+1];
    for(int p=2 ; p*p<=N ; p++){
      if(primeAll[p]==false){
        for(int i=p*2 ; i<=N ; i+=p)primeAll[i]=true ;
      }
    }
    ArrayList<Integer>prime=new ArrayList<Integer>();
    for(int p=2 ; p<=N ; p++)if(! primeAll[p])prime.add(p);
    for(int i=0 ; i<prime.size(); ++i){
      int p=prime.get(i);
      if(1L*p*p*p<=N)fourDiv[p*p*p]=true ;
      for(int j=i+1 ; j<prime.size(); ++j){
        int q=prime.get(j);
        if(1L*p*q>N)break ;
        fourDiv[p*q]=true ;
      }
    }
  }
  public static void main(String[] args){
    fourDistinctFactors();
    int num=10 ;
    if(fourDiv[num])System.out.println("Yes");
    else System.out.println("No");
    num=12 ;
    if(fourDiv[num])System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 1E6->oclAsType(int);
  static   attribute fourDiv : Sequence(boolean) := Integer.subrange(1,N + 1)->collect(false);
  static   operation fourDistinctFactors() : void
  pre: true
  post: true
  activity: (     var primeAll : Sequence(boolean) ; primeAll := Integer.subrange(1,N + 1)->collect(false) ;
         var p : int ; p := 2 ; while p * p <= N do ( (     if (primeAll[p+1] = false) then (         var i : int ; i := p * 2 ; while i <= N do (     primeAll[i+1] := true ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var prime : Sequence(int) ; prime := Sequence{} ;
        var p : int ; p := 2 ; while p <= N do (     if (not(primeAll[p+1])) then     prime := prime->including(p) ; else skip ;  ;     p := p + 1 ) ; 
        var i : int ; i := 0 ; while i < prime->size() do ( (     var p : int ; p := prime->at(i+1) ;
     if (1L * p * p * p <= N) then     fourDiv[p * p * p+1] := true ; else skip ; 
         var j : int ; j := i + 1 ; while j < prime->size() do ( (     var q : int ; q := prime->at(j+1) ;
     if (1L * p * q > N) then     break else skip ; 
     fourDiv[p * q+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute fourDistinctFactors() ; 
     var num : int ; num := 10 ;
    if (fourDiv[num+1]) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
    num := 12 ; 
    if (fourDiv[num+1]) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Scanner ;
public class FullBinaryTree {
  public final static String INPUT_FILE_NAME="B-large(1).in" ;
  public final static String OUTPUT_FILE_NAME="FullBinaryTree.out" ;
  public static void main(String[] args){
    try(Scanner in=new Scanner(new FileReader(INPUT_FILE_NAME));
    PrintWriter out=new PrintWriter(new FileWriter(OUTPUT_FILE_NAME))){
      int numT=in.nextInt();
      for(int t=1 ; t<=numT ; t++){
        System.out.println("Case "+t);
        int numNode=in.nextInt();
        ArrayList<Node>nodes=new ArrayList<>();
        for(int i=0 ; i<numNode ; i++){
          nodes.add(new Node());
        }
        for(int i=0 ; i<numNode-1 ; i++){
          int a=in.nextInt()-1 ;
          int b=in.nextInt()-1 ;
          nodes.get(a).addChild(nodes.get(b));
          nodes.get(b).addChild(nodes.get(a));
        }
        int best=0 ;
        for(Node n : nodes){
          best=Math.max(best,n.maxChildren(null));
        }
        int res=numNode-best ;
        out.println("Case #"+t+": "+res);
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  public static class Node {
    ArrayList<Node>children ;
    public Node(){
      children=new ArrayList<>();
    }
    public void addChild(Node n){
      children.add(n);
    }
    public int maxChildren(Node parent){
      int best=0 ;
      int best2=0 ;
      for(Node n : children){
        if(n!=parent){
          int nv=n.maxChildren(this);
          if(nv>best){
            best2=best ;
            best=nv ;
          }
          else if(nv>best2){
            best2=nv ;
          }
        }
      }
      if(best2==0)return 1 ;
      return best+best2+1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class FullBinaryTree {
  static   attribute INPUT_FILE_NAME : String := "B-large(1).in";
  static   attribute OUTPUT_FILE_NAME : String := "FullBinaryTree.out";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(INPUT_FILE_NAME))) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile(OUTPUT_FILE_NAME))) ;
 (     var numT : int ; numT := in.getCurrent()->toInteger() ;
         var t : int ; t := 1 ; while t <= numT do ( (     OclFile["System.out"].println("Case " + t) ; 
     var numNode : int ; numNode := in.getCurrent()->toInteger() ;
    var nodes : Sequence(Node) ; nodes := Sequence{} ;
        var i : int ; i := 0 ; while i < numNode do ( (     nodes := nodes->including(Node.newNode()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < numNode - 1 do ( (     var a : int ; a := in.getCurrent()->toInteger() - 1 ;
     var b : int ; b := in.getCurrent()->toInteger() - 1 ;
     nodes->at(a+1).addChild(nodes->at(b+1)) ; 
     nodes->at(b+1).addChild(nodes->at(a+1)) )  ;     i := i + 1 ) ; 
    var best : int ; best := 0 ;
    for (n : nodes) do ( (     best := Set{best, n.maxChildren(null)}->max() )  ) ; 
    var res : int ; res := numNode - best ;
    skip ; 
 )  ;     t := t + 1 ) ))   catch (e : IOException) do (     e.printStackTrace() )
  );
  static class Node {
   attribute children : Sequence(Node);
   static operation newNode() : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     children := Sequence{} );
   operation addChild( n : Node) : void
  pre: true
  post: true
  activity: (     children := children->including(n) );
   operation maxChildren( parent : Node) : int
  pre: true
  post: true
  activity: (     var best : int ; best := 0 ;
     var best2 : int ; best2 := 0 ;
    for (n : children) do ( (     if (n /= parent) then (     var nv : int ; nv := n.maxChildren(self) ;
     if (nv > best) then (     best2 := best ; 
     best := nv ) else     if (nv > best2) then (     best2 := nv ) else skip ; ) else skip )  ) ; 
    if (best2 = 0) then     return 1 else skip ; 
    return best + best2 + 1 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashSet ;
import java.util.Scanner ;
public class FullBinaryTree {
  public static int ans ;
  public static int tans ;
  public static boolean[] vis ;
  public static ArrayList<Integer>[] adj ;
  public static void main(String[] Args)throws FileNotFoundException {
    Scanner sc=new Scanner(new File("B-large(2).in"));
    PrintWriter out=new PrintWriter(new File("things.out"));
    int t=sc.nextInt(),cc=0 ;
    while(t-->0){
      int n=sc.nextInt();
      adj=new ArrayList[n];
      for(int k=0 ; k<n ; k++)adj[k]=new ArrayList<Integer>();
      for(int k=0 ; k<n-1 ; k++){
        int a=sc.nextInt()-1 ;
        int b=sc.nextInt()-1 ;
        adj[a] .add(b);
        adj[b] .add(a);
      }
      vis=new boolean[n];
      ans=n ;
      for(int k=0 ; k<n ; k++){
        Arrays.fill(vis,false);
        ans=Math.min(n-dfs(k),ans);
      }
      out.printf("Case #%d: %d%n",++cc,ans);
    }
    out.close();
  }
  private static int dfs(int k){
    vis[k]=true ;
    ArrayList<Integer>al=new ArrayList<Integer>();
    for(Integer i : adj[k])if(! vis[i])al.add(dfs(i));
    if(al.size()<2)return 1 ;
    Collections.sort(al);
    return 1+al.get(al.size()-1)+al.get(al.size()-2);
  }
  private static long make(String s){
    return Long.parseLong(s,2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class FullBinaryTree {
  static   attribute ans : int;
  static   attribute tans : int;
  static   attribute vis : Sequence(boolean);
  static   attribute adj : Sequence(Sequence(int));
  static   operation main( Args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile("B-large(2).in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("things.out")) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var cc : int ; cc := 0 ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     adj := Integer.subrange(1,n)->collect(null) ; 
        var k : int ; k := 0 ; while k < n do (     adj[k+1] := Sequence{} ;  ;     k := k + 1 ) ; 
        var k : int ; k := 0 ; while k < n - 1 do ( (     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
     var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
     adj[a+1]->excludes(b) ; 
     adj[b+1]->excludes(a) )  ;     k := k + 1 ) ; 
    vis := Integer.subrange(1,n)->collect(false) ; 
    ans := n ; 
        var k : int ; k := 0 ; while k < n do ( (     vis := vis->collect(false) ; 
     ans := Set{n - dfs(k), ans}->min() )  ;     k := k + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static   operation dfs( k : int) : int
  pre: true
  post: true
  activity: (     vis[k+1] := true ; 
     var al : Sequence(int) ; al := Sequence{} ;
    for (i : adj[k+1]) do (     if (not(vis[i+1])) then     al := al->including(dfs(i)) ; else skip ;  ) ; 
    if (al->size() < 2) then     return 1 else skip ; 
    al := al->sort() ; 
    return 1 + al->at(al->size() - 1+1) + al->at(al->size() - 2+1) 
 );
  static   operation make( s : String) : long
  pre: true
  post: true
  activity: (     return (s)->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printArr(float arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  static void replaceMax(float arr[],int n){
    float max=arr[0];
    for(int i=0 ; i<n ; i++){
      if(arr[i]>max)max=arr[i];
    }
    float min=arr[0];
    for(int i=0 ; i<n ; i++){
      if(arr[i]<min)min=arr[i];
    }
    float range=max-min ;
    float coeffOfRange=range/(max+min);
    for(int i=0 ; i<n ; i++){
      if(arr[i]==max){
        arr[i]=coeffOfRange ;
        break ;
      }
    }
    printArr(arr,n);
  }
  public static void main(String args[]){
    float arr[]={
      15,16,10,9,6,7,17 };
      int n=arr.length ;
      replaceMax(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printArr( arr : Sequence(double), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation replaceMax( arr : Sequence(double), n : int) : void
  pre: true
  post: true
  activity: (     var max : double ; max := arr[0+1] ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] > max) then     max := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
    var min : double ; min := arr[0+1] ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] < min) then     min := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
    var range : double ; range := max - min ;
    var coeffOfRange : double ; coeffOfRange := range / (max + min) ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = max) then (     arr[i+1] := coeffOfRange ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    execute printArr(arr, n) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(double) ; arr := Sequence{15,16,10,9,6,7,17} ;
     var n : int ; n := arr->size() ;
     execute replaceMax(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class Codechef3 {
  public static void main(String[] args){
    Scanner h=new Scanner(System.in);
    int x=h.nextInt();
    for(int i=0 ; i<x ; i++){
      int n=h.nextInt();
      ArrayList l1=new ArrayList<>();
      for(int j=0 ; j<(2*n); j++){
        l1.add(h.nextInt());
      }
      Collections.sort(l1);
      for(int j=0 ; j<n ; j++){
        System.out.print(l1.get(j)+" "+l1.get(j+n)+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var h : OclFile ; h := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := h.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < x do ( (     var n : int ; n := h.getCurrent()->toInteger() ;
     var l1 : Sequence ; l1 := Sequence{} ;
        var j : int ; j := 0 ; while j < (2 * n) do ( (     l1 := l1->including(h.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
    l1 := l1->sort() ; 
        var j : int ; j := 0 ; while j < n do ( (     OclFile["System.out"].print(l1->at(j+1) + " " + l1->at(j + n+1) + " ") )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int n,u ;
  int[] c,r ;
  int ans ;
  boolean[] v ;
  void dfs(int s,int sum,int depth){
    if(u<=sum)ans=depth ;
    if(ans<=depth)return ;
    for(int i=0 ; i<n ; i++){
      if((s &(1<<i))>0)continue ;
      if((r[i] & s)!=r[i])continue ;
      int x=s | 1<<i ;
      if(v[x])continue ;
      v[x]=true ;
      dfs(x,sum+c[i],depth+1);
    }
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      n=sc.nextInt();
      u=sc.nextInt();
      if((n | u)==0)break ;
      c=new int[n];
      r=new int[n];
      for(int i=0 ; i<n ; i++){
        c[i]=sc.nextInt();
        int x=0 ;
        int k=sc.nextInt();
        for(int j=0 ; j<k ; j++)x |=1<<sc.nextInt();
        r[i]=x ;
      }
      ans=n ;
      v=new boolean[1<<n];
      for(int i=0 ; i<n ; i++)if(r[i]==0){
        v[1<<i]=true ;
        dfs(1<<i,c[i],1);
      }
      System.out.println(ans);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute c : Sequence(int);
   attribute ans : int;
   attribute v : Sequence(boolean);
   operation dfs( s : int, sum : int, depth : int) : void
  pre: true
  post: true
  activity: (     if (u <= sum) then     ans := depth ; else skip ; 
     if (ans <= depth) then     return else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     if ((s & ((1*(2->pow(i)))->oclAsType(long))) > 0) then     continue else skip ; 
     if ((r[i+1] & s) /= r[i+1]) then     continue else skip ; 
    var x : int ; x := MathLib.bitwiseOr(s,(1*(2->pow(i)))->oclAsType(long)) ;
    if (v[x+1]) then     continue else skip ; 
    v[x+1] := true ; 
    execute dfs(x, sum + c[i+1], depth + 1) ; 
 )  ;     i := i + 1 ) );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     n := sc.getCurrent()->toInteger() ; 
     u := sc.getCurrent()->toInteger() ; 
    if ((MathLib.bitwiseOr(n,u)) = 0) then     break else skip ; 
    c := Integer.subrange(1,n)->collect(0) ; 
    r := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := sc.getCurrent()->toInteger() ; 
     var x : int ; x := 0 ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
        var j : int ; j := 0 ; while j < k do (     x := MathLib.bitwiseOr(x, (1*(2->pow(sc.getCurrent()->toInteger())))->oclAsType(long)) ;  ;     j := j + 1 ) ; 
    r[i+1] := x ; 
 )  ;     i := i + 1 ) ; 
    ans := n ; 
    v := Integer.subrange(1,(1*(2->pow(n)))->oclAsType(long))->collect(false) ; 
        var i : int ; i := 0 ; while i < n do (     if (r[i+1] = 0) then (     v[(1*(2->pow(i)))->oclAsType(long)+1] := true ; 
     execute dfs((1*(2->pow(i)))->oclAsType(long), c[i+1], 1) ) else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B290 {
  public static void main(String[] args){
    String code="111111101010101111100101001111111\n"+"100000100000000001010110001000001\n"+"101110100110110000011010001011101\n"+"101110101011001001111101001011101\n"+"101110101100011000111100101011101\n"+"100000101010101011010000101000001\n"+"111111101010101010101010101111111\n"+"000000001111101111100111100000000\n"+"100010111100100001011110111111001\n"+"110111001111111100100001000101100\n"+"011100111010000101000111010001010\n"+"011110000110001111110101100000011\n"+"111111111111111000111001001011000\n"+"111000010111010011010011010100100\n"+"101010100010110010110101010000010\n"+"101100000101010001111101000000000\n"+"000010100011001101000111101011010\n"+"101001001111101111000101010001110\n"+"101101111111000100100001110001000\n"+"000010011000100110000011010000010\n"+"001101101001101110010010011011000\n"+"011101011010001000111101010100110\n"+"111010100110011101001101000001110\n"+"110001010010101111000101111111000\n"+"001000111011100001010110111110000\n"+"000000001110010110100010100010110\n"+"111111101000101111000110101011010\n"+"100000100111010101111100100011011\n"+"101110101001010000101000111111000\n"+"101110100011010010010111111011010\n"+"101110100100011011110110101110000\n"+"100000100110011001111100111100000\n"+"111111101101000101001101110010001" ;
    Scanner in=new Scanner(System.in);
    int row=in.nextInt();
    int column=in.nextInt();
    char answer=code.split("\n")[row] .charAt(column);
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B290 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var code : String ; code := "111111101010101111100101001111111\n" + "100000100000000001010110001000001\n" + "101110100110110000011010001011101\n" + "101110101011001001111101001011101\n" + "101110101100011000111100101011101\n" + "100000101010101011010000101000001\n" + "111111101010101010101010101111111\n" + "000000001111101111100111100000000\n" + "100010111100100001011110111111001\n" + "110111001111111100100001000101100\n" + "011100111010000101000111010001010\n" + "011110000110001111110101100000011\n" + "111111111111111000111001001011000\n" + "111000010111010011010011010100100\n" + "101010100010110010110101010000010\n" + "101100000101010001111101000000000\n" + "000010100011001101000111101011010\n" + "101001001111101111000101010001110\n" + "101101111111000100100001110001000\n" + "000010011000100110000011010000010\n" + "001101101001101110010010011011000\n" + "011101011010001000111101010100110\n" + "111010100110011101001101000001110\n" + "110001010010101111000101111111000\n" + "001000111011100001010110111110000\n" + "000000001110010110100010100010110\n" + "111111101000101111000110101011010\n" + "100000100111010101111100100011011\n" + "101110101001010000101000111111000\n" + "101110100011010010010111111011010\n" + "101110100100011011110110101110000\n" + "100000100110011001111100111100000\n" + "111111101101000101001101110010001" ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var row : int ; row := in.getCurrent()->toInteger() ;
    var column : int ; column := in.getCurrent()->toInteger() ;
    var answer : String ; answer := code->split("\n")[row+1]->at(column+1) ;
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n,t=in.nextInt(),a[]=new int[100];
    while(t-->0){
      n=in.nextInt();
      for(int i=1 ; i<=2*n ; i++)a[i]=in.nextInt();
      Arrays.sort(a,1,2*n+1);
      for(int i=2 ; i<=n ; i++)System.out.printf("%d %d ",a[i],a[i+n]);
      System.out.printf("%d %d \n",a[1],a[1+n]);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var t : int ; t := in.getCurrent()->toInteger() ;
    var a : Sequence(void) ; a := Integer.subrange(1,100)->collect(0) ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     n := in.getCurrent()->toInteger() ; 
         var i : int ; i := 1 ; while i <= 2 * n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a.subrange(1,1)^(a.subrange(1+1,2 * n + 1)->sort())^a.subrange(2 * n + 1+1,a.size) ; 
        var i : int ; i := 2 ; while i <= n do (     OclFile["System.out"].printf("%d %d ", a[i+1], a[i + n+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%d %d \n", a[1+1], a[1 + n+1]) ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class test303 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int a[]=new int[2*n];
      for(int i=0 ; i<2*n ; i++){
        a[i]=in.nextInt();
      }
      Arrays.sort(a);
      for(int i=0,k=2*n-1,l=1 ; i<n ; l*=-1){
        if(l==1){
          System.out.print(a[i++]+" ");
        }
        else {
          System.out.print(a[k--]+" ");
        }
      }
      System.out.println(a[n]);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test303 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,2 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
        var i : int ; i := 0 ;
    var k : int ; k := 2 * n - 1 ;
    var l : int ; l := 1 ; while i < n do ( (     if (l = 1) then (     OclFile["System.out"].print(a[i+1] + " ") ) else (     OclFile["System.out"].print(a[k+1] + " ") ) )  ;     l := l*(-1) ) ; 
    OclFile["System.out"].println(a[n+1]) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static final int TEN=10 ;
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      System.out.println((0==n % s(n))? "Yes" : "No");
    }
  }
  private static int s(int n){
    int answer=0 ;
    while(n>0){
      answer+=n % TEN ;
      n/=TEN ;
    }
    return answer ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute TEN : int := 10;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if (0 = n mod s(n)) then "Yes" else "No" endif) ))  );
  static   operation s( n : int) : int
  pre: true
  post: true
  activity: (     var answer : int ; answer := 0 ;
     while (n > 0) do (     answer := answer+(n mod TEN) ; 
     n := n/(TEN) ) ; 
     return answer );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.io.*;
import java.util.*;
class Main {
  public static void main(String args[])throws FileNotFoundException {
    Scanner sc=new Scanner(System.in);
    String buf ;
    buf=sc.nextLine();
    String[] sbuf=buf.split("");
    int sn=0 ;
    int n=Integer.parseInt(buf);
    for(int i=0 ; i<sbuf.length ; i++){
      sn+=Integer.parseInt(sbuf[i]);
    }
    System.out.println((n % sn==0)? "Yes" : "No");
  }
  static void disp(long[] data){
    for(int i=0 ; i<data.length ; i++){
      System.out.printf("%d ",data[i]);
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var buf : String ;
    buf := sc.nextLine() ; 
    var sbuf : Sequence(String) ; sbuf := buf->split("") ;
    var sn : int ; sn := 0 ;
    var n : int ; n := (buf)->toInteger() ;
        var i : int ; i := 0 ; while i < sbuf->size() do ( (     sn := sn+((sbuf[i+1])->toInteger()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if (n mod sn = 0) then "Yes" else "No" endif) ; 
 );
  static   operation disp( data : Sequence(long)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < data->size() do ( (     OclFile["System.out"].printf("%d ", data[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int X=sc.nextInt();
    int n=X ;
    int a=0 ;
    int sum=0 ;
    while(n>0){
      a=n % 10 ;
      n=n/10 ;
      sum=sum+a ;
    }
    if(X % sum==0){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : int ; X := sc.getCurrent()->toInteger() ;
    var n : int ; n := X ;
    var a : int ; a := 0 ;
    var sum : int ; sum := 0 ;
    while (n > 0) do (     a := n mod 10 ; 
     n := n / 10 ; 
     sum := sum + a ) ; 
    if (X mod sum = 0) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new java.util.Scanner(System.in);
    int N=in.nextInt();
    int num=0 ;
    int tmp=N ;
    while(N>=10){
      num+=N % 10 ;
      N=N/10 ;
    }
    num+=N ;
    if(tmp % num==0){
      System.out.print("Yes");
    }
    else {
      System.out.print("No");
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := Scanner.newScanner(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var num : int ; num := 0 ;
    var tmp : int ; tmp := N ;
    while (N >= 10) do (     num := num+(N mod 10) ; 
     N := N / 10 ) ; 
    num := num+(N) ; 
    if (tmp mod num = 0) then (     OclFile["System.out"].print("Yes") ) else (     OclFile["System.out"].print("No") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
import java.util.Random ;
import java.util.Collections ;
import java.util.ArrayDeque ;
import java.util.Queue ;
import java.util.Deque ;
public class Main {
  public static void main(String args[]){
    Scanner first=new Scanner(System.in);
    int first_word=first.nextInt();
    int hundred=first_word/100 ;
    first_word=first_word-hundred*100 ;
    int ten=(first_word)/10 ;
    first_word=first_word-ten*10 ;
    int one=first_word ;
    if(hundred==one){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var first : OclFile ; first := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var first_word : int ; first_word := first.getCurrent()->toInteger() ;
    var hundred : int ; hundred := first_word / 100 ;
    first_word := first_word - hundred * 100 ; 
    var ten : int ; ten := (first_word) / 10 ;
    first_word := first_word - ten * 10 ; 
    var one : int ; one := first_word ;
    if (hundred = one) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String args[]){
    ConsoleScanner cin=new ConsoleScanner();
    PrintWriter cout=new PrintWriter(System.out);
    solve(cin,cout);
    cout.flush();
  }
  static long now(){
    return System.currentTimeMillis();
  }
  static void trace(Object...objects){
    assert null!=System.out.format("trace:%s\n",Arrays.deepToString(objects));
  }
  private static void solve(ConsoleScanner cin,PrintWriter cout){
    int n=cin.nextInt();
    long start=now();
    boolean ans=solve(n);
    if(ans)cout.println("Yes");
    else cout.println("No");
    trace("elapsed",now()-start);
  }
  private static boolean solve(int n){
    return n/100==n % 10 ;
  }
  static class ConsoleScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      try {
        while(! st.hasMoreElements())st=new StringTokenizer(br.readLine());
        return st.nextToken();
      }
      catch(IOException e){
        throw new AssertionError(e);
      }
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : ConsoleScanner ; cin := ConsoleScanner.newConsoleScanner() ;
     var cout : OclFile ; cout := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     execute solve(cin, cout) ; 
     skip );
  static   operation now() : long
  pre: true
  post: true
  activity: (     return OclDate.getSystemTime() );
  static   operation trace( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     assert null /= OclFile["System.out"].format("trace:%s\n", (objects + "")) );
  static   operation solve( cin : ConsoleScanner, cout : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := cin.nextInt() ;
     var start : long ; start := now() ;
    var ans : boolean ; ans := solve(n) ;
    if (ans) then     skip else     skip ; ;  
    execute trace("elapsed", now() - start) ; 
 );
  static   operation solve( n : int) : boolean
  pre: true
  post: true
  activity: (     return n / 100 = n mod 10 );
  static class ConsoleScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() )   catch (e : IOException) do (     error AssertionException(e) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    String s=sc.next();
    if(s.charAt(0)==s.charAt(2)){
      out.println("Yes");
    }
    else {
      out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var s : String ; s := sc.getCurrent() ;
     if (s->at(0+1) = s->at(2+1)) then (     out.println("Yes") ) else (     out.println("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewClass37 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    int p=1 ;
    while(t-->0){
      int n=in.nextInt();
      int count=0 ;
      int x=n ;
      if(n<10){
        System.out.println(n);
        continue ;
      }
      while(x>0){
        count++;
        x/=10 ;
      }
      int first=0 ;
      while(count>0){
        first=first*10+1 ;
        count--;
      }
      int sum=0 ;
      if(first<=n){
        sum+=n/first ;
      }
      first/=10 ;
      while(first>0){
        sum+=9 ;
        first/=10 ;
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass37 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
     var p : int ; p := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var count : int ; count := 0 ;
    var x : int ; x := n ;
    if (n < 10) then (     OclFile["System.out"].println(n) ; 
     continue ) else skip ; 
    while (x > 0) do (     count := count + 1 ; 
     x := x/(10) ) ; 
    var first : int ; first := 0 ;
    while (count > 0) do (     first := first * 10 + 1 ; 
     count := count - 1 ) ; 
    var sum : int ; sum := 0 ;
    if (first <= n) then (     sum := sum+(n / first) ) else skip ; 
    first := first/(10) ; 
    while (first > 0) do (     sum := sum+(9) ; 
     first := first/(10) ) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static final int INF=Integer.MAX_VALUE/2-1 ;
  public static final int MAX=20 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] req_bit=new int[MAX];
    int[] amounts=new int[MAX];
    int[] DP=new int[1<<MAX];
    while(true){
      final int n=sc.nextInt();
      final int U=sc.nextInt();
      if(n==0 && U==0){
        break ;
      }
      for(int i=0 ; i<n ; i++){
        amounts[i]=sc.nextInt();
        final int k=sc.nextInt();
        int bit=0 ;
        for(int j=0 ; j<k ; j++){
          bit |=1<<(sc.nextInt());
        }
        req_bit[i]=bit ;
      }
      Arrays.fill(DP,INF);
      DP[0]=0 ;
      final int bit_size=1<<n ;
      for(int bit=0 ; bit<bit_size ; bit++){
        if(DP[bit]>=U){
          continue ;
        }
        for(int next=0 ; next<n ; next++){
          if((bit &(1<<next))!=0){
            continue ;
          }
          else if((bit &(req_bit[next]))!=req_bit[next]){
            continue ;
          }
          DP[bit |(1<<next)]=Math.min(DP[bit |(1<<next)],DP[bit]+amounts[next]);
        }
      }
      int min=INF ;
      for(int i=0 ; i<bit_size ; i++){
        if(DP[i]>=U && DP[i]<INF){
          min=Math.min(min,Integer.bitCount(i));
        }
      }
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := 2147483647 / 2 - 1;
  static    attribute MAX : int := 20;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var req_bit : Sequence(int) ; req_bit := Integer.subrange(1,MAX)->collect(0) ;
    var amounts : Sequence(int) ; amounts := Integer.subrange(1,MAX)->collect(0) ;
    var DP : Sequence(int) ; DP := Integer.subrange(1,(1*(2->pow(MAX)))->oclAsType(long))->collect(0) ;
    while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var U : int ; U := sc.getCurrent()->toInteger() ;
    if (n = 0 & U = 0) then (     break ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     amounts[i+1] := sc.getCurrent()->toInteger() ; 
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var bit : int ; bit := 0 ;
        var j : int ; j := 0 ; while j < k do ( (     bit := MathLib.bitwiseOr(bit, (1*(2->pow((sc.getCurrent()->toInteger()))))->oclAsType(long)) )  ;     j := j + 1 ) ; 
    req_bit[i+1] := bit ; 
 )  ;     i := i + 1 ) ; 
    DP := DP->collect(INF) ; 
    DP[0+1] := 0 ; 
    var bit_size : int ; bit_size := (1*(2->pow(n)))->oclAsType(long) ;
        var bit : int ; bit := 0 ; while bit < bit_size do ( (     if (DP[bit+1] >= U) then (     continue ) else skip ; 
         var next : int ; next := 0 ; while next < n do ( (     if ((MathLib.bitwiseAnd(bit,((1*(2->pow(next)))->oclAsType(long)))) /= 0) then (     continue ) else     if ((MathLib.bitwiseAnd(bit,(req_bit[next+1]))) /= req_bit[next+1]) then (     continue ) else skip ; ;  
     DP[MathLib.bitwiseOr(bit,((1*(2->pow(next)))->oclAsType(long)))+1] := Set{DP[MathLib.bitwiseOr(bit,((1*(2->pow(next)))->oclAsType(long)))+1], DP[bit+1] + amounts[next+1]}->min() )  ;     next := next + 1 ) )  ;     bit := bit + 1 ) ; 
    var min : int ; min := INF ;
        var i : int ; i := 0 ; while i < bit_size do ( (     if (DP[i+1] >= U & DP[i+1] < INF) then (     min := Set{min, bitCount(i)}->min() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String in=br.readLine();
      String chr[]=in.split("");
      int a=Integer.parseInt(chr[0]);
      int c=Integer.parseInt(chr[2]);
      System.out.println(a==c ? "Yes" : "No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var in : String ; in := br.readLine() ;
     var chr : Sequence(String) ; chr := in->split("") ;
    var a : int ; a := (chr[0+1])->toInteger() ;
    var c : int ; c := (chr[2+1])->toInteger() ;
    OclFile["System.out"].println(if a = c then "Yes" else "No" endif) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner sc=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    String N=sc.next();
    if(N.charAt(0)==N.charAt(2)){
      out.print("Yes");
    }
    else {
      out.print("No");
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var N : String ; N := sc.getCurrent() ;
    if (N->at(0+1) = N->at(2+1)) then (     skip ) else (     skip ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printCount(int a[][],int n,int m,int z[],int l){
    for(int i=0 ; i<n ; i++){
      Map<Integer,Integer>mp=new HashMap<>();
      for(int j=0 ; j<m ; j++)mp.put(a[i][j],1);
      int count=0 ;
      for(int j=0 ; j<l ; j++){
        if(mp.containsKey(z[j]))count+=1 ;
      }
      System.out.println("row"+(i+1)+"="+count);
    }
  }
  public static void main(String[] args){
    int a[][]={
      {
        8,27,39,589,23 },{
          23,34,589,12,45 },{
            939,32,27,12,78 },{
              23,349,48,21,32 }
            };
            int arr[]={
              589,39,27 };
              int n=a.length ;
              int m=5 ;
              int l=arr.length ;
              printCount(a,n,m,arr,l);
            }
          }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printCount( a : Sequence(Sequence(int)), n : int, m : int, z : Sequence(int), l : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var mp : Map(int,int) ; mp := Map{} ;
         var j : int ; j := 0 ; while j < m do (     mp := mp->union(Map{a[i+1][j+1] |-> 1}) ;  ;     j := j + 1 ) ; 
    var count : int ; count := 0 ;
        var j : int ; j := 0 ; while j < l do ( (     if (mp->keys()->includes(z[j+1])) then     count := count+(1) ; else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println("row" + (i + 1) + "=" + count) ; 
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(Sequence(int)) ; a := Sequence{Sequence{8,27,39,589,23},Sequence{23,34,589,12,45},Sequence{939,32,27,12,78},Sequence{23,349,48,21,32}} ;
     var arr : Sequence(int) ; arr := Sequence{589,39,27} ;
    var n : int ; n := a->size() ;
    var m : int ; m := 5 ;
    var l : int ; l := arr->size() ;
    execute printCount(a, n, m, arr, l) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int R,C ;
  public static class Terminal {
    int d ;
    int idx ;
    public Terminal(int d,int idx){
      this.d=d ;
      this.idx=idx ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    R=sc.nextInt();
    C=sc.nextInt();
    int N=sc.nextInt();
    ArrayList<Terminal>list=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      int x1=sc.nextInt();
      int y1=sc.nextInt();
      int x2=sc.nextInt();
      int y2=sc.nextInt();
      if(isOnEdge(x1,y1)&& isOnEdge(x2,y2)){
        list.add(new Terminal(convert(x1,y1),i));
        list.add(new Terminal(convert(x2,y2),i));
      }
    }
    Collections.sort(list,new Comparator<Terminal>(){
      public int compare(Terminal t1,Terminal t2){
        return t1.d-t2.d ;
      }
    }
);
    LinkedList<Terminal>stack=new LinkedList<>();
    for(Terminal t : list){
      if(! stack.isEmpty()&& stack.peek().idx==t.idx)stack.pop();
      else stack.push(t);
    }
    System.out.println(stack.isEmpty()? "YES" : "NO");
    sc.close();
  }
  static boolean isOnEdge(int x,int y){
    return x==0 || x==R || y==0 || y==C ;
  }
  static int convert(int x,int y){
    if(x==0)return y ;
    else if(y==C)return C+x ;
    else if(x==R)return C+R+(C-y);
    else return C+R+C+(R-x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute R : int;
  static class Terminal {
   attribute d : int;
   attribute idx : int;
   static operation newTerminal( d : int, idx : int) : Terminal
  pre: true
  post: true
  activity:
  ( var self : Terminal ;
    self := createTerminal();
    self.initialise(d, idx);
    return self );
  operation initialise( d : int, idx : int) : void
  pre: true  post: true
  activity: (     self.d := d ; 
     self.idx := idx );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     R := sc.getCurrent()->toInteger() ; 
    C := sc.getCurrent()->toInteger() ; 
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var list : Sequence(Terminal) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var x1 : int ; x1 := sc.getCurrent()->toInteger() ;
     var y1 : int ; y1 := sc.getCurrent()->toInteger() ;
    var x2 : int ; x2 := sc.getCurrent()->toInteger() ;
    var y2 : int ; y2 := sc.getCurrent()->toInteger() ;
    if (isOnEdge(x1, y1) & isOnEdge(x2, y2)) then (     list := list->including(Terminal.newTerminal(convert(x1, y1), i)) ; 
     list := list->including(Terminal.newTerminal(convert(x2, y2), i)) ) else skip ; 
 )  ;     i := i + 1 ) ; 
    list, OclComparator<Terminal>.newOclComparator() := list, OclComparator<Terminal>.newOclComparator()->sort() ; 
    var stack : Sequence(Terminal) ; stack := Sequence{} ;
    for (t : list) do ( (     if (not(stack->isEmpty()) & stack->min().idx = t.idx) then     stack := stack->front() ; else     stack := stack->append(t) ; )  ) ; 
    OclFile["System.out"].println(if stack->isEmpty() then "YES" else "NO" endif) ; 
    skip ; 
 );
  static   operation isOnEdge( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return x = 0 or x = R or y = 0 or y = C );
  static   operation convert( x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (x = 0) then     return y else     if (y = C) then     return C + x else     if (x = R) then     return C + R + (C - y) else     return C + R + C + (R - x) ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(a>=b){
      System.out.println(1);
    }
    if(a<b){
      if(a==1){
        System.out.println(b);
      }
      else {
        if(b % a==0){
          System.out.println(b/a);
        }
        else {
          System.out.println(b/a+1);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    if (a >= b) then (     OclFile["System.out"].println(1) ) else skip ; 
    if (a < b) then (     if (a = 1) then (     OclFile["System.out"].println(b) ) else (     if (b mod a = 0) then (     OclFile["System.out"].println(b / a) ) else (     OclFile["System.out"].println(b / a + 1) ) ) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws Exception {
    try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in))){
      String[] data=reader.readLine().split(" ");
      Integer numDress=Integer.parseInt(data[0]);
      Integer numParty=Integer.parseInt(data[1]);
      Integer result=numParty/numDress ;
      if(numParty % numDress>0)result+=1 ;
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var data : Sequence(String) ; data := reader.readLine()->split(" ") ;
     var numDress : int ; numDress := (data[0+1])->toInteger() ;
    var numParty : int ; numParty := (data[1+1])->toInteger() ;
    var result : int ; result := numParty / numDress ;
    if (numParty mod numDress > 0) then     result := result+(1) ; else skip ; 
    OclFile["System.out"].println(result) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      while(sc.hasNext()){
        final int A=sc.nextInt();
        final int B=sc.nextInt();
        int ans=B/A ;
        if(B % A!=0){
          ans++;
        }
        System.out.println(ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (sc.hasNext()) do (     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := B / A ;
    if (B mod A /= 0) then (     ans := ans + 1 ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int a=sc.nextInt();
    int b=sc.nextInt();
    for(int i=1 ; i<=100000 ; i++){
      if(i*a>=b){
        System.out.println(i);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= 100000 do ( (     if (i * a >= b) then (     OclFile["System.out"].println(i) ; 
     break ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A,B ;
    A=sc.nextInt();
    B=sc.nextInt();
    int ans=0 ;
    if(A>=B){
      ans=1 ;
    }
    else if(B % A==0){
      ans=B/A ;
    }
    else {
      ans=B/A+1 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ;
    var B : int ;
    A := sc.getCurrent()->toInteger() ; 
    B := sc.getCurrent()->toInteger() ; 
    var ans : int ; ans := 0 ;
    if (A >= B) then (     ans := 1 ) else     if (B mod A = 0) then (     ans := B / A ) else (     ans := B / A + 1 ) ;  ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class OrdinaryNumbers {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=input.nextInt();
      int j=1 ;
      int count=0 ;
      while(j<=n){
        if(j*9<=n){
          count+=9 ;
        }
        else {
          count+=n/j ;
        }
        j=j*10+1 ;
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class OrdinaryNumbers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var j : int ; j := 1 ;
    var count : int ; count := 0 ;
    while (j <= n) do (     if (j * 9 <= n) then (     count := count+(9) ) else (     count := count+(n / j) ) ;  
     j := j * 10 + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BaiB {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    int[] h=new int[n];
    for(int x=0 ; x<n ; x++){
      h[x]=scan.nextInt();
    }
    int res=0 ;
    for(int i=0 ; i<k ; i++){
      res+=h[i];
    }
    int min=res ;
    int index=1 ;
    for(int i=k ; i<n ; i++){
      res+=h[i]-h[i-k];
      if(res<min){
        min=res ;
        index=i-k+2 ;
      }
    }
    System.out.println(index);
  }
}
------------------------------------------------------------
OCL File:
---------
 class BaiB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var h : Sequence(int) ; h := Integer.subrange(1,n)->collect(0) ;
        var x : int ; x := 0 ; while x < n do ( (     h[x+1] := scan.getCurrent()->toInteger() )  ;     x := x + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     res := res+(h[i+1]) )  ;     i := i + 1 ) ; 
    var min : int ; min := res ;
    var index : int ; index := 1 ;
        var i : int ; i := k ; while i < n do ( (     res := res+(h[i+1] - h[i - k+1]) ; 
     if (res < min) then (     min := res ; 
     index := i - k + 2 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(index) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Fence {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int num=in.nextInt();
    int width=in.nextInt();
    int[] arr=new int[num];
    for(int i=0 ; i<num ; i++){
      arr[i]=in.nextInt();
    }
    int sum=Integer.MAX_VALUE ;
    int index=0 ;
    int temp=0 ;
    for(int j=0 ; j<width ; j++){
      temp+=arr[j];
    }
    for(int i=0 ; i+width<num+1 ; i++){
      if(temp<sum){
        sum=temp ;
        index=i ;
      }
      if(i+width<num){
        temp-=arr[i];
        temp+=arr[i+width];
      }
    }
    out.append(index+1+"\n");
    out.flush();
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new FileReader("sub.in"));
      }
      catch(FileNotFoundException ex){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException ex){
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException ex){
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Fence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var num : int ; num := in.nextInt() ;
    var width : int ; width := in.nextInt() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,num)->collect(0) ;
        var i : int ; i := 0 ; while i < num do ( (     arr[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 2147483647 ;
    var index : int ; index := 0 ;
    var temp : int ; temp := 0 ;
        var j : int ; j := 0 ; while j < width do ( (     temp := temp+(arr[j+1]) )  ;     j := j + 1 ) ; 
        var i : int ; i := 0 ; while i + width < num + 1 do ( (     if (temp < sum) then (     sum := temp ; 
     index := i ) else skip ; 
     if (i + width < num) then (     temp := temp-(arr[i+1]) ; 
     temp := temp+(arr[i + width+1]) ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("sub.in"))) )   catch (ex : FileNotFoundException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (ex : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (ex : IOException) do skip
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n ;
    int p=2000,j=2000 ;
    for(int i=0 ; i<3 ; i++){
      n=scan.nextInt();
      if(n<p)p=n ;
    }
    for(int i=0 ; i<2 ; i++){
      n=scan.nextInt();
      if(n<j)j=n ;
    }
    System.out.println((p+j-50));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var p : int ; p := 2000 ;
    var j : int ; j := 2000 ;
        var i : int ; i := 0 ; while i < 3 do ( (     n := scan.getCurrent()->toInteger() ; 
     if (n < p) then     p := n ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 2 do ( (     n := scan.getCurrent()->toInteger() ; 
     if (n < j) then     j := n ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((p + j - 50)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public static void main(String[] args){
    java.util.Scanner in=new java.util.Scanner(System.in);
    String[] str=new String[5];
    int[] prs=new int[5];
    for(int i=0 ; i<5 ; i++){
      str[i]=in.next();
      prs[i]=java.lang.Integer.parseInt(str[i]);
    }
    int tmp1=2000,tmp2=2000 ;
    for(int i=0 ; i<5 ; i++){
      if(i<3){
        if(prs[i]<tmp1)tmp1=prs[i];
      }
      else if(i<5){
        if(prs[i]<tmp2)tmp2=prs[i];
      }
    }
    System.out.println(tmp1+tmp2-50);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : Scanner ; in := Scanner.newScanner(OclFile["System.in"]) ;
     var str : Sequence(String) ; str := Integer.subrange(1,5)->collect(null) ;
    var prs : Sequence(int) ; prs := Integer.subrange(1,5)->collect(0) ;
        var i : int ; i := 0 ; while i < 5 do ( (     str[i+1] := in.next() ; 
     prs[i+1] := java.lang.Integer.parseInt(str[i+1]) )  ;     i := i + 1 ) ; 
    var tmp1 : int ; tmp1 := 2000 ;
    var tmp2 : int ; tmp2 := 2000 ;
        var i : int ; i := 0 ; while i < 5 do ( (     if (i < 3) then (     if (prs[i+1] < tmp1) then     tmp1 := prs[i+1] ; else skip ) else     if (i < 5) then (     if (prs[i+1] < tmp2) then     tmp2 := prs[i+1] ; else skip ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(tmp1 + tmp2 - 50) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  public int pasta(){
    int ans=0 ;
    for(int i=0 ; i<3 ; i++){
      int input=sc.nextInt();
      if(i==0 || ans>input)ans=input ;
    }
    return ans ;
  }
  public int juice(){
    int ans=0 ;
    for(int i=0 ; i<2 ; i++){
      int input=sc.nextInt();
      if(i==0 || ans>input)ans=input ;
    }
    return ans ;
  }
  public void set(){
    int p=pasta();
    int j=juice();
    int ans=p+j-50 ;
    System.out.println(ans);
  }
  public static void main(String[] args){
    new Main().set();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation pasta() : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < 3 do ( (     var input : int ; input := sc.getCurrent()->toInteger() ;
     if (i = 0 or ans > input) then     ans := input ; else skip )  ;     i := i + 1 ) ; 
     return ans );
   operation juice() : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < 2 do ( (     var input : int ; input := sc.getCurrent()->toInteger() ;
     if (i = 0 or ans > input) then     ans := input ; else skip )  ;     i := i + 1 ) ; 
     return ans );
   operation set() : void
  pre: true
  post: true
  activity: (     var p : int ; p := pasta() ;
     var j : int ; j := juice() ;
     var ans : int ; ans := p + j - 50 ;
     OclFile["System.out"].println(ans) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain() := Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Collections ;
import java.util.LinkedList ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.lunchMinimumValueCalculation();
    return ;
  }
  private void lunchMinimumValueCalculation(){
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    LinkedList<Integer>pastaPriceList=new LinkedList<Integer>();
    LinkedList<Integer>juicePriceList=new LinkedList<Integer>();
    try {
      for(int i=0 ; i<3 ; i++){
        String inputStr=bufferedReader.readLine();
        pastaPriceList.add(Integer.parseInt(inputStr));
      }
      for(int i=0 ; i<2 ; i++){
        String inputStr=bufferedReader.readLine();
        juicePriceList.add(Integer.parseInt(inputStr));
      }
      Collections.sort(pastaPriceList);
      Collections.sort(juicePriceList);
      int pastaPriceNum=pastaPriceList.get(0);
      int juicePriceNum=juicePriceList.get(0);
      System.out.println((pastaPriceNum+juicePriceNum)-50);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.lunchMinimumValueCalculation() ; 
     return );
   operation lunchMinimumValueCalculation() : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pastaPriceList : Sequence(int) ; pastaPriceList := Sequence{} ;
     var juicePriceList : Sequence(int) ; juicePriceList := Sequence{} ;
     try (         var i : int ; i := 0 ; while i < 3 do ( (     var inputStr : String ; inputStr := bufferedReader.readLine() ;
     pastaPriceList := pastaPriceList->including((inputStr)->toInteger()) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < 2 do ( (     var inputStr : String ; inputStr := bufferedReader.readLine() ;
     juicePriceList := juicePriceList->including((inputStr)->toInteger()) )  ;     i := i + 1 ) ; 
    pastaPriceList := pastaPriceList->sort() ; 
    juicePriceList := juicePriceList->sort() ; 
    var pastaPriceNum : int ; pastaPriceNum := pastaPriceList->at(0+1) ;
    var juicePriceNum : int ; juicePriceNum := juicePriceList->at(0+1) ;
    OclFile["System.out"].println((pastaPriceNum + juicePriceNum) - 50) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Round0D {
  int cases ;
  void process(Scanner scanner,PrintStream out)throws IOException {
    cases=scanner.nextInt();
    scanner.nextLine();
    for(int curCase=0 ; curCase<cases ; curCase++){
      long K=scanner.nextLong();
      long C=scanner.nextLong();
      long S=scanner.nextLong();
      if(C*S<K){
        out.println("Case #"+(curCase+1)+": IMPOSSIBLE");
      }
      else {
        out.print("Case #"+(curCase+1)+":");
        long k=0 ;
        for(long s=0 ; s<S && k<K ; s++){
          long num=0 ;
          for(int i=0 ; i<C ; i++){
            num=num*K+(k % K);
            k++;
          }
          out.print(' ');
          out.print(num+1);
        }
        out.println();
      }
    }
  }
  Round0D()throws IOException {
    Scanner in=new Scanner(new File("C:\\Users\\Olaf\\Downloads\\D-large.in"));
    PrintStream out=new PrintStream("out-D-large.txt");
    process(in,out);
    in.close();
    out.close();
  }
  public static void main(String[] args)throws IOException {
    new Round0D();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Round0D {
   attribute cases : int;
   operation process( scanner : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     cases := scanner.nextInt() ; 
     scanner.nextLine() ; 
         var curCase : int ; curCase := 0 ; while curCase < cases do ( (     var K : long ; K := scanner.nextLong() ;
     var C : long ; C := scanner.nextLong() ;
     var S : long ; S := scanner.nextLong() ;
     if (C * S < K) then (     out.println("Case #" + (curCase + 1) + ": IMPOSSIBLE") ) else (     out.print("Case #" + (curCase + 1) + ":") ; 
     var k : long ; k := 0 ;
         var s : long ; s := 0 ; while s < S & k < K do ( (     var num : long ; num := 0 ;
         var i : int ; i := 0 ; while i < C do ( (     num := num * K + (k mod K) ; 
     k := k + 1 )  ;     i := i + 1 ) ; 
     out.print(' ') ; 
     out.print(num + 1) )  ;     s := s + 1 ) ; 
     out.println() ) )  ;     curCase := curCase + 1 ) );
   static operation newRound0D() : Round0D
  pre: true
  post: true
  activity:
  ( var self : Round0D ;
    self := createRound0D();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("C:\\Users\\Olaf\\Downloads\\D-large.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("out-D-large.txt")) ;
    execute process(in, out) ; 
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Round0D.newRound0D() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.run();
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    ArrayList<Integer>a=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      a.add(0);
    }
    for(int i=0 ; i<M ; i++){
      int k=sc.nextInt();
      for(int j=0 ; j<k ; j++){
        int s=sc.nextInt();
        s--;
        a.set(s,a.get(s)|(1<<i));
      }
    }
    int p=0 ;
    for(int i=0 ; i<M ; i++){
      int x=sc.nextInt();
      p |=(x<<i);
    }
    int ans=0 ;
    for(int s=0 ; s<(1<<N); s++){
      int t=0 ;
      for(int i=0 ; i<N ; i++){
        if(((s>>i)& 1)==1){
          t ^=a.get(i);
        }
      }
      if(p==t){
        ans++;
      }
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     a := a->including(0) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var k : int ; k := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < k do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     s := s - 1 ; 
     a := a.setAt(s+1,a->at(s+1) or ((1*(2->pow(i)))->oclAsType(long))) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var p : int ; p := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     p := MathLib.bitwiseOr(p, ((x*(2->pow(i)))->oclAsType(long))) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var s : int ; s := 0 ; while s < ((1*(2->pow(N)))->oclAsType(long)) do ( (     var t : int ; t := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     if ((((s/(2->pow(i)))->oclAsType(long)) & 1) = 1) then (     t := MathLib.bitwiseXor(t,a->at(i+1)) ) else skip )  ;     i := i + 1 ) ; 
     if (p = t) then (     ans := ans + 1 ) else skip )  ;     s := s + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package lab6zp ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Lab6ZP {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      long k=in.nextInt();
      long c=in.nextInt();
      int s=in.nextInt();
      System.out.print("Case #"+(i+1)+": ");
      if(c*s<k){
        System.out.println("IMPOSSIBLE");
      }
      else {
        long val=0 ;
        while(s>0){
          long exp=1 ;
          long total=0 ;
          while(exp<Math.pow(k,c)){
            total+=val*exp ;
            exp*=k ;
            if(val<k-1){
              val++;
            }
          }
          s--;
          System.out.print(total+1);
          if(total+1==Math.pow(k,c)){
            s=0 ;
          }
          if(s!=0){
            System.out.print(" ");
          }
          else {
            System.out.println();
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Lab6ZP {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var k : long ; k := in.getCurrent()->toInteger() ;
     var c : long ; c := in.getCurrent()->toInteger() ;
    var s : int ; s := in.getCurrent()->toInteger() ;
    OclFile["System.out"].print("Case #" + (i + 1) + ": ") ; 
    if (c * s < k) then (     OclFile["System.out"].println("IMPOSSIBLE") ) else (     var val : long ; val := 0 ;
     while (s > 0) do (     var exp : long ; exp := 1 ;
     var total : long ; total := 0 ;
    while (exp < k->pow(c)) do (     total := total+(val * exp) ; 
     exp := exp*(k) ; 
     if (val < k - 1) then (     val := val + 1 ) else skip ) ; 
    s := s - 1 ; 
    OclFile["System.out"].print(total + 1) ; 
    if (total + 1 = k->pow(c)) then (     s := 0 ) else skip ; 
    if (s /= 0) then (     OclFile["System.out"].print(" ") ) else (     OclFile["System.out"].println() ) ;  
 ) ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      n=scanner.nextInt();
      u=scanner.nextInt();
      if((n | u)==0)break ;
      need=new int[n];
      int all=0 ;
      unit=new int[n];
      for(int i=0 ; i<n ; i++){
        unit[i]=scanner.nextInt();
        all+=unit[i];
        int k=scanner.nextInt();
        for(int j=0 ; j<k ; j++){
          int x=scanner.nextInt();
          need[i] |=(1<<x);
        }
      }
      if(all==u){
        System.out.println(n);
        continue ;
      }
      ans=n ;
      v=new boolean[1<<n];
      slove(0,0,0);
      System.out.println(ans);
    }
  }
  private void slove(int bit,int one,int have){
    if(ans==one)return ;
    if(have>=u){
      ans=one ;
      return ;
    }
    if(ans-1==one)return ;
    for(int i=0 ; i<n ; i++){
      int a=bit |(1<<i);
      if(v[a] ||(bit | need[i])!=bit)continue ;
      v[a]=true ;
      slove(a,one+1,have+unit[i]);
    }
  }
  int n,u ;
  int[] need,unit ;
  int ans ;
  boolean[] v ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     n := scanner.getCurrent()->toInteger() ; 
     u := scanner.getCurrent()->toInteger() ; 
    if ((n or u) = 0) then     break else skip ; 
    need := Integer.subrange(1,n)->collect(0) ; 
    var all : int ; all := 0 ;
    unit := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     unit[i+1] := scanner.getCurrent()->toInteger() ; 
     all := all+(unit[i+1]) ; 
     var k : int ; k := scanner.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < k do ( (     var x : int ; x := scanner.getCurrent()->toInteger() ;
     need[i+1] := MathLib.bitwiseOr(need[i+1], ((1*(2->pow(x)))->oclAsType(long))) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (all = u) then (     OclFile["System.out"].println(n) ; 
     continue ) else skip ; 
    ans := n ; 
    v := Integer.subrange(1,(1*(2->pow(n)))->oclAsType(long))->collect(false) ; 
    execute slove(0, 0, 0) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
   operation slove( bit : int, one : int, have : int) : void
  pre: true
  post: true
  activity: (     if (ans = one) then     return else skip ; 
     if (have >= u) then (     ans := one ; 
     return ) else skip ; 
     if (ans - 1 = one) then     return else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := MathLib.bitwiseOr(bit,((1*(2->pow(i)))->oclAsType(long))) ;
     if (v[a+1] or (bit or need[i+1]) /= bit) then     continue else skip ; 
     v[a+1] := true ; 
     execute slove(a, one + 1, have + unit[i+1]) )  ;     i := i + 1 ) );
   attribute n : int;
   attribute need : Sequence(int);
   attribute ans : int;
   attribute v : Sequence(boolean);
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class D {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(new FileInputStream("src/D-large.in"))));
    String output="" ;
    int t=sc.nextInt();
    for(int i=1 ; i<=t ; i++){
      int k=sc.nextInt();
      int c=sc.nextInt();
      int s=sc.nextInt();
      if(s*c<k){
        output+="Case #"+i+": IMPOSSIBLE\n" ;
        continue ;
      }
      ArrayList<Long>nums=new ArrayList<Long>();
      for(int j=0 ; j<s ; j++){
        if(j*c>=k)break ;
        long next=0 ;
        long mult=1 ;
        for(int m=0 ; m<c ; m++){
          if(j*c+m>=k)break ;
          next+=(j*c+m)*mult ;
          mult*=k ;
        }
        next++;
        nums.add(next);
      }
      String toAdd="" ;
      for(int j=0 ; j<nums.size(); j++){
        toAdd+=" "+nums.get(j);
      }
      output+="Case #"+i+":"+toAdd+"\n" ;
    }
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/D-large.out"),"utf-8"));
    bw.write(output);
    bw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("src/D-large.in"))))) ;
     var output : String ; output := "" ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= t do ( (     var k : int ; k := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    if (s * c < k) then (     output := output+("Case #" + i + ": IMPOSSIBLE\n") ; 
     continue ) else skip ; 
    var nums : Sequence(long) ; nums := Sequence{} ;
        var j : int ; j := 0 ; while j < s do ( (     if (j * c >= k) then     break else skip ; 
     var next : long ; next := 0 ;
    var mult : long ; mult := 1 ;
        var m : int ; m := 0 ; while m < c do ( (     if (j * c + m >= k) then     break else skip ; 
     next := next+((j * c + m) * mult) ; 
     mult := mult*(k) )  ;     m := m + 1 ) ; 
    next := next + 1 ; 
    nums := nums->including(next) ; 
 )  ;     j := j + 1 ) ; 
    var toAdd : String ; toAdd := "" ;
        var j : int ; j := 0 ; while j < nums->size() do ( (     toAdd := toAdd+(" " + nums->at(j+1)) )  ;     j := j + 1 ) ; 
    output := output+("Case #" + i + ":" + toAdd + "\n") ; 
 )  ;     i := i + 1 ) ; 
    var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("src/D-large.out")), "utf-8")) ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.nextLine());
    char[] arr=sc.nextLine().toCharArray();
    boolean prev=arr[0]=='T' ;
    for(int i=2 ; i<arr.length ; i+=2){
      prev=check(prev,arr[i]=='T');
    }
    String ans ;
    if(prev){
      ans="T" ;
    }
    else {
      ans="F" ;
    }
    System.out.println(ans);
  }
  static boolean check(boolean a,boolean b){
    if(a && ! b){
      return false ;
    }
    else {
      return true ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.nextLine())->toInteger() ;
    var arr : Sequence(String) ; arr := sc.nextLine()->characters() ;
    var prev : boolean ; prev := arr[0+1] = 'T' ;
        var i : int ; i := 2 ; while i < arr->size() do ( (     prev := check(prev, arr[i+1] = 'T') )  ;     i := i+(2) ) ; 
    var ans : String ;
    if (prev) then (     ans := "T" ) else (     ans := "F" ) ;  
    OclFile["System.out"].println(ans) ; 
 );
  static   operation check( a : boolean, b : boolean) : boolean
  pre: true
  post: true
  activity: (     if (a & not(b)) then (     return false ) else (     return true ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),f=sc.nextInt(),c=0 ;
    Map<String,Integer>mp=new TreeMap<>();
    for(int i=0 ; i<n ; i++){
      int m=sc.nextInt();
      String[] v=new String[m];
      for(int j=0 ; j<m ; j++){
        v[j]=sc.next();
        for(int k=0 ; k<j ; k++){
          String[] t={
            v[j],v[k] };
            Arrays.sort(t);
            String tt=t[0]+" "+t[1];
            if(mp.containsKey(tt)){
              mp.put(tt,mp.get(tt)+1);
              if(mp.get(tt)==f){
                c++;
              }
            }
            else {
              mp.put(tt,1);
              if(f==1)c++;
            }
          }
        }
      }
      System.out.println(c);
      for(Map.Entry<String,Integer>m : mp.entrySet()){
        if(m.getValue()>=f){
          System.out.println(m.getKey());
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var f : int ; f := sc.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
    var mp : Map(String,int) ; mp := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var m : int ; m := sc.getCurrent()->toInteger() ;
     var v : Sequence(String) ; v := Integer.subrange(1,m)->collect(null) ;
         var j : int ; j := 0 ; while j < m do ( (     v[j+1] := sc.getCurrent() ; 
         var k : int ; k := 0 ; while k < j do ( (     var t : Sequence(String) ; t := Sequence{v[j+1],v[k+1]} ;
     t := t->sort() ; 
     var tt : String ; tt := t[0+1] + " " + t[1+1] ;
     if (mp->keys()->includes(tt)) then (     mp := mp->union(Map{tt |-> mp->at(tt) + 1}) ; 
     if (mp->at(tt) = f) then (     c := c + 1 ) else skip ) else (     mp := mp->union(Map{tt |-> 1}) ; 
     if (f = 1) then     c := c + 1 ; else skip ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
    for (m : mp->asSet()) do ( (     if (m.getValue() >= f) then (     OclFile["System.out"].println(m.getKey()) ) else skip )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int a[][]=new int[n][m];
    int i,j ;
    for(i=0 ; i<n ; i++){
      for(j=0 ; j<m ; j++){
        a[i][j]=sc.nextInt();
      }
    }
    boolean vis[][]=new boolean[n][m];
    ArrayList<mine>arr=new ArrayList<>();
    boolean res=true ;
    for(i=0 ; i<n-1 ; i++){
      for(j=0 ; j<m-1 ; j++){
        if(a[i][j]*a[i+1][j]*a[i+1][j+1]*a[i][j+1]>0){
          arr.add(new mine(i,j));
          a[i][j]=3 ;
          a[i][j+1]=3 ;
          a[i+1][j+1]=3 ;
          a[i+1][j]=3 ;
        }
      }
    }
    for(i=0 ; i<n ; i++){
      for(j=0 ; j<m ; j++){
        if(a[i][j]==1)res=false ;
      }
    }
    if(res==false)System.out.println("-1");
    else {
      System.out.println(arr.size());
      for(mine h : arr){
        System.out.println((h.x+1)+" "+(h.y+1));
      }
    }
  }
}
class mine {
  int x ;
  int y ;
  public mine(int a,int b){
    x=a ;
    y=b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var i : int ;
    var j : int ;
        i := 0 ; while i < n do ( (         j := 0 ; while j < m do ( (     a[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var vis : Sequence(Sequence(boolean)) ; vis := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(false)) ;
    var arr : Sequence(mine) ; arr := Sequence{} ;
    var res : boolean ; res := true ;
        i := 0 ; while i < n - 1 do ( (         j := 0 ; while j < m - 1 do ( (     if (a[i+1][j+1] * a[i + 1+1][j+1] * a[i + 1+1][j + 1+1] * a[i+1][j + 1+1] > 0) then (     arr := arr->including(mine.newmine(i, j)) ; 
     a[i+1][j+1] := 3 ; 
    a[i+1][j + 1+1] := 3 ; 
    a[i + 1+1][j + 1+1] := 3 ; 
    a[i + 1+1][j+1] := 3 ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (         j := 0 ; while j < m do ( (     if (a[i+1][j+1] = 1) then     res := false ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (res = false) then     OclFile["System.out"].println("-1") else (     OclFile["System.out"].println(arr->size()) ; 
     for (h : arr) do ( (     OclFile["System.out"].println((h.x + 1) + " " + (h.y + 1)) )  ) ) ;  
 );
}
class mine {
   attribute x : int;
   attribute y : int;
   static operation newmine( a : int, b : int) : mine
  pre: true
  post: true
  activity:
  ( var self : mine ;
    self := createmine();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     x := a ; 
     y := b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int countPrimes(int n){
    boolean[] isPrime=new boolean[n];
    int count=0 ;
    Arrays.fill(isPrime,true);
    for(int i=2 ; i<n ; i++){
      if(i*i>=n)break ;
      if(! isPrime[i])continue ;
      for(int j=i*i ; j<n ; j+=i)isPrime[j]=false ;
    }
    for(int i=2 ; i<n ; i++)if(isPrime[i])count++;
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation countPrimes( n : int) : int
  pre: true
  post: true
  activity: (     var isPrime : Sequence(boolean) ; isPrime := Integer.subrange(1,n)->collect(false) ;
     var count : int ; count := 0 ;
    isPrime := isPrime->collect(true) ; 
        var i : int ; i := 2 ; while i < n do ( (     if (i * i >= n) then     break else skip ; 
     if (not(isPrime[i+1])) then     continue else skip ; 
         var j : int ; j := i * i ; while j < n do (     isPrime[j+1] := false ;  ;     j := j+(i) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i < n do (     if (isPrime[i+1]) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
    return count 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  static long[][] res ;
  static Scanner sc=new Scanner(System.in);
  static int vn ;
  static int en ;
  static int[] parent ;
  static boolean BFS(){
    boolean[] visited=new boolean[vn];
    int pos=0 ;
    LinkedList<Integer>q=new LinkedList<Integer>();
    q.add(0);
    while(! q.isEmpty()){
      pos=q.pop();
      if(pos==vn-1)return true ;
      for(int i=0 ; i<vn ; i++){
        if(res[pos][i]>0 && ! visited[i]){
          visited[i]=true ;
          parent[i]=pos ;
          q.push(i);
        }
      }
    }
    return false ;
  }
  public static void main(String[] args){
    int ans=0 ;
    vn=sc.nextInt();
    en=sc.nextInt();
    res=new long[vn][vn];
    parent=new int[vn];
    for(int i=0 ; i<en ; i++){
      int v1=sc.nextInt();
      int v2=sc.nextInt();
      int cap=sc.nextInt();
      res[v1][v2]=cap ;
    }
    while(BFS()==true){
      long minflow=9999999999l ;
      int backtrackpos=vn-1 ;
      while(backtrackpos!=0){
        minflow=Math.min(minflow,res[parent[backtrackpos] ][backtrackpos]);
        if(backtrackpos==0)break ;
        backtrackpos=parent[backtrackpos];
      }
      ans+=minflow ;
      backtrackpos=vn-1 ;
      while(backtrackpos!=0){
        res[parent[backtrackpos] ][backtrackpos]-=minflow ;
        res[backtrackpos][parent[backtrackpos] ]+=minflow ;
        backtrackpos=parent[backtrackpos];
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute res : Sequence(Sequence(long));
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute vn : int;
  static   attribute en : int;
  static   attribute parent : Sequence(int);
  static   operation BFS() : boolean
  pre: true
  post: true
  activity: (     var visited : Sequence(boolean) ; visited := Integer.subrange(1,vn)->collect(false) ;
     var pos : int ; pos := 0 ;
    var q : Sequence(int) ; q := Sequence{} ;
    q := q->including(0) ; 
    while (not(q->isEmpty())) do (     pos := q->last() ;     q := q->front() ; 
     if (pos = vn - 1) then     return true else skip ; 
         var i : int ; i := 0 ; while i < vn do ( (     if (res[pos+1][i+1] > 0 & not(visited[i+1])) then (     visited[i+1] := true ; 
     parent[i+1] := pos ; 
     q := q->append(i) ) else skip )  ;     i := i + 1 ) ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     vn := sc.getCurrent()->toInteger() ; 
    en := sc.getCurrent()->toInteger() ; 
    res := Integer.subrange(1,vn)->collect(Integer.subrange(1,vn)->collect(0)) ; 
    parent := Integer.subrange(1,vn)->collect(0) ; 
        var i : int ; i := 0 ; while i < en do ( (     var v1 : int ; v1 := sc.getCurrent()->toInteger() ;
     var v2 : int ; v2 := sc.getCurrent()->toInteger() ;
     var cap : int ; cap := sc.getCurrent()->toInteger() ;
     res[v1+1][v2+1] := cap )  ;     i := i + 1 ) ; 
    while (BFS() = true) do (     var minflow : long ; minflow := 9999999999l ;
     var backtrackpos : int ; backtrackpos := vn - 1 ;
    while (backtrackpos /= 0) do (     minflow := Set{minflow, res[parent[backtrackpos+1]+1][backtrackpos+1]}->min() ; 
     if (backtrackpos = 0) then     break else skip ; 
     backtrackpos := parent[backtrackpos+1] ) ; 
    ans := ans+(minflow) ; 
    backtrackpos := vn - 1 ; 
    while (backtrackpos /= 0) do (     res[parent[backtrackpos+1]+1][backtrackpos+1] := res[parent[backtrackpos+1]+1][backtrackpos+1]-(minflow) ; 
     res[backtrackpos+1][parent[backtrackpos+1]+1] := res[backtrackpos+1][parent[backtrackpos+1]+1]+(minflow) ; 
     backtrackpos := parent[backtrackpos+1] ) ; 
 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMinSwaps(String s,int k){
    int ans=0 ;
    int c_one=0,c_zero=0 ;
    for(int i=s.length()-1 ; i>=0 ; i--){
      if(s.charAt(i)=='1')c_one++;
      if(s.charAt(i)=='0'){
        c_zero++;
        ans+=c_one ;
      }
      if(c_zero==k)break ;
    }
    if(c_zero<k)return-1 ;
    return ans ;
  }
  public static void main(String[] args){
    String s="100111" ;
    int k=2 ;
    System.out.println(findMinSwaps(s,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMinSwaps( s : String, k : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var c_one : int ; c_one := 0 ;
    var c_zero : int ; c_zero := 0 ;
        var i : int ; i := s->size() - 1 ; while i >= 0 do ( (     if (s->at(i+1) = '1') then     c_one := c_one + 1 ; else skip ; 
     if (s->at(i+1) = '0') then (     c_zero := c_zero + 1 ; 
     ans := ans+(c_one) ) else skip ; 
     if (c_zero = k) then     break else skip )  ;     i := i - 1 ) ; 
    if (c_zero < k) then     return -1 else skip ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "100111" ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(findMinSwaps(s, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Ordinary_Numbers {
  public static void main(String[] args){
    long testcase ;
    Scanner sc=new Scanner(System.in);
    testcase=sc.nextLong();
    for(long i=0 ; i<testcase ; i++){
      long n,nearest_leftmost,nearest_digit,ordinary=0,near_num ;
      n=sc.nextLong();
      nearest_leftmost=(n/(long)Math.pow(10,(double)digit(n)-1));
      nearest_digit=digit(n);
      near_num=nearest_ordinary_num(nearest_digit,nearest_leftmost);
      if(nearest_leftmost-1==0 && n<near_num){
        nearest_leftmost=9 ;
        nearest_digit--;
      }
      else if(n<near_num)nearest_leftmost--;
      while(nearest_digit!=1){
        ordinary+=9 ;
        nearest_digit--;
      }
      ordinary+=nearest_leftmost ;
      System.out.print(ordinary);
      if(i<testcase-1)System.out.print("\n");
    }
    sc.close();
  }
  public static long digit(long x){
    long count=0 ;
    while(x!=0){
      x/=10 ;
      count++;
    }
    return count ;
  }
  public static long nearest_ordinary_num(long digit,long leftmost_num){
    long sum=0 ;
    while(true){
      digit--;
      sum+=Math.pow(10,(double)digit)*leftmost_num ;
      if(digit==0)break ;
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ordinary_Numbers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var testcase : long ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    testcase := sc.getCurrent()->toLong() ; 
        var i : long ; i := 0 ; while i < testcase do ( (     var n : long ;
    var nearest_leftmost : long ;
    var nearest_digit : long ;
    var ordinary : long ; ordinary := 0 ;
    var near_num : long ;
     n := sc.getCurrent()->toLong() ; 
    nearest_leftmost := (n / 10->pow(digit(n)->oclAsType(double) - 1)->oclAsType(long)) ; 
    nearest_digit := digit(n) ; 
    near_num := nearest_ordinary_num(nearest_digit, nearest_leftmost) ; 
    if (nearest_leftmost - 1 = 0 & n < near_num) then (     nearest_leftmost := 9 ; 
     nearest_digit := nearest_digit - 1 ) else     if (n < near_num) then     nearest_leftmost := nearest_leftmost - 1 ; else skip ; ;  
    while (nearest_digit /= 1) do (     ordinary := ordinary+(9) ; 
     nearest_digit := nearest_digit - 1 ) ; 
    ordinary := ordinary+(nearest_leftmost) ; 
    OclFile["System.out"].print(ordinary) ; 
    if (i < testcase - 1) then     OclFile["System.out"].print("\n") ; else skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation digit( x : long) : long
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
     while (x /= 0) do (     x := x/(10) ; 
     count := count + 1 ) ; 
     return count );
  static   operation nearest_ordinary_num( digit : long, leftmost_num : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     while (true) do (     digit := digit - 1 ; 
     sum := sum+(10->pow(digit->oclAsType(double)) * leftmost_num) ; 
     if (digit = 0) then     break else skip ) ; 
     return sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class tennis {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),d=in.nextInt();
    int sum=0 ;
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    Arrays.sort(a);
    int m=in.nextInt();
    for(int i=0 ; i<n ; i++){
      sum+=a[i];
      if(i==m-1)break ;
    }
    System.out.println((n>=m)? sum : sum+(n-m)*d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class tennis {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var m : int ; m := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(a[i+1]) ; 
     if (i = m - 1) then     break else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if (n >= m) then sum else sum + (n - m) * d endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import org.w3c.dom.ls.LSOutput ;
import java.util.*;
import java.util.function.IntBinaryOperator ;
public class Example {
  static long[][] dp ;
  static int mod=1000000000+7 ;
  static long[] ans=new long[100000+1];
  static List<List<Integer>>adj ;
  static int[] vis ;
  static int[] dis ;
  static int row ;
  static boolean[] chosen ;
  static List<Integer>permutation ;
  static int k ;
  static int count ;
  static int[][] arr ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int d=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr);
    int m=sc.nextInt();
    int profit=0 ;
    for(int i=0 ; i<m ; i++){
      if(i<n){
        profit+=arr[i];
      }
      else {
        profit-=d ;
      }
    }
    System.out.println(profit);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Example {
  static   attribute dp : Sequence(Sequence(long));
  static   attribute mod : int := 1000000000 + 7;
  static   attribute ans : Sequence(long) := Integer.subrange(1,100000 + 1)->collect(0);
  static   attribute adj : Sequence(Sequence(int));
  static   attribute vis : Sequence(int);
  static   attribute dis : Sequence(int);
  static   attribute row : int;
  static   attribute chosen : Sequence(boolean);
  static   attribute permutation : Sequence(int);
  static   attribute k : int;
  static   attribute count : int;
  static   attribute arr : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var profit : int ; profit := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     if (i < n) then (     profit := profit+(arr[i+1]) ) else (     profit := profit-(d) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(profit) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int N=3,M=3 ;
  static boolean check(int a[][],int b[][]){
    for(int i=1 ; i<N ; i++){
      for(int j=1 ; j<M ; j++){
        if(a[i][j]!=b[i][j]){
          a[i][j] ^=1 ;
          a[0][0] ^=1 ;
          a[0][j] ^=1 ;
          a[i][0] ^=1 ;
        }
      }
    }
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<M ; j++){
        if(a[i][j]!=b[i][j])return false ;
      }
    }
    return true ;
  }
  public static void main(String args[]){
    int a[][]={
      {
        0,1,0 },{
          0,1,0 },{
            1,0,0 }
          };
          int b[][]={
            {
              1,0,0 },{
                1,0,0 },{
                  1,0,0 }
                };
                if(check(a,b))System.out.print("Yes");
                else System.out.print("No");
              }
            }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute N : int := 3;
  static   operation check( a : Sequence(Sequence(int)), b : Sequence(Sequence(int))) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < N do ( (         var j : int ; j := 1 ; while j < M do ( (     if (a[i+1][j+1] /= b[i+1][j+1]) then (     a[i+1][j+1] := MathLib.bitwiseXor(a[i+1][j+1],1) ; 
     a[0+1][0+1] := MathLib.bitwiseXor(a[0+1][0+1],1) ; 
     a[0+1][j+1] := MathLib.bitwiseXor(a[0+1][j+1],1) ; 
     a[i+1][0+1] := MathLib.bitwiseXor(a[i+1][0+1],1) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < M do ( (     if (a[i+1][j+1] /= b[i+1][j+1]) then     return false else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(Sequence(int)) ; a := Sequence{Sequence{0,1,0},Sequence{0,1,0},Sequence{1,0,0}} ;
     var b : Sequence(Sequence(int)) ; b := Sequence{Sequence{1,0,0},Sequence{1,0,0},Sequence{1,0,0}} ;
     if (check(a, b)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int N ;
  static int W ;
  static int w0 ;
  static ArrayList<Integer>[] v=new ArrayList[4];
  static {
    for(int i=0 ; i<v.length ; ++i){
      v[i]=new ArrayList<Integer>(N);
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    W=sc.nextInt();
    w0=sc.nextInt();
    v[0] .add(sc.nextInt());
    for(int i=1 ; i<N ; ++i){
      int w=sc.nextInt();
      v[w-w0] .add(sc.nextInt());
    }
    for(int i=0 ; i<v.length ; ++i){
      v[i] .sort(Comparator.reverseOrder());
    }
    System.out.println(solve(0,N,0));
  }
  static int solve(int startIndex,int numLeft,int totalW){
    if(startIndex>=v.length){
      return 0 ;
    }
    int vi=0 ;
    int wi=totalW ;
    int max_v=0 ;
    for(int n=0 ; n<=numLeft && n<=v[startIndex] .size(); ++n){
      if(n>=1){
        vi+=v[startIndex] .get(n-1);
        wi+=w0+startIndex ;
      }
      if(wi>W){
        break ;
      }
      max_v=Integer.max(max_v,vi+solve(startIndex+1,numLeft-n,wi));
    }
    return max_v ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute W : int;
  static   attribute w0 : int;
  static   attribute v : Sequence(Sequence(int)) := Integer.subrange(1,4)->collect(null);
  static operation initialiseClass()
  pre: true post: true
  activity:         var i : int ; i := 0 ; while i < v->size() do ( (     v[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
    W := sc.getCurrent()->toInteger() ; 
    w0 := sc.getCurrent()->toInteger() ; 
    v[0+1]->excludes(sc.getCurrent()->toInteger()) ; 
        var i : int ; i := 1 ; while i < N do ( (     var w : int ; w := sc.getCurrent()->toInteger() ;
     v[w - w0+1]->excludes(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < v->size() do ( (     v[i+1].sort(Comparator.reverseOrder()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(0, N, 0)) ; 
 );
  static   operation solve( startIndex : int, numLeft : int, totalW : int) : int
  pre: true
  post: true
  activity: (     if (startIndex >= v->size()) then (     return 0 ) else skip ; 
     var vi : int ; vi := 0 ;
    var wi : int ; wi := totalW ;
    var max_v : int ; max_v := 0 ;
        var n : int ; n := 0 ; while n <= numLeft & n <= v[startIndex+1]->size() do ( (     if (n >= 1) then (     vi := vi+(v[startIndex+1]->at(n - 1+1)) ; 
     wi := wi+(w0 + startIndex) ) else skip ; 
     if (wi > W) then (     break ) else skip ; 
     max_v := Set{max_v, vi + solve(startIndex + 1, numLeft - n, wi)}->max() )  ;     n := n + 1 ) ; 
    return max_v 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    SimpleKnapsack solver=new SimpleKnapsack();
    solver.solve(1,in,out);
    out.close();
  }
  static class SimpleKnapsack {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      long w=in.nextLong();
      long[] weights=new long[n];
      long[] values=new long[n];
      long[][] dp=new long[n+1][3*n+1];
      for(int i=0 ; i<n ; i++){
        weights[i]=Long.parseLong(in.next());
        values[i]=Long.parseLong(in.next());
      }
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        int diff=(int)(weights[i]-weights[0]);
        for(int j=i ; 0<=j ; j--){
          for(int k=sum ; 0<=k ; k--){
            dp[j+1][k+diff]=Math.max(dp[j+1][k+diff],dp[j][k]+values[i]);
          }
        }
        sum+=diff ;
      }
      long result=0 ;
      for(int i=0 ; i<=n ; i++){
        for(int j=0 ; j<=sum ; j++){
          if(w<i*weights[0]+j){
            continue ;
          }
          result=Math.max(result,dp[i][j]);
        }
      }
      out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : SimpleKnapsack ; solver := SimpleKnapsack.newSimpleKnapsack() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class SimpleKnapsack {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var w : long ; w := in.getCurrent()->toLong() ;
    var weights : Sequence(long) ; weights := Integer.subrange(1,n)->collect(0) ;
    var values : Sequence(long) ; values := Integer.subrange(1,n)->collect(0) ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,3 * n + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     weights[i+1] := (in.getCurrent())->toLong() ; 
     values[i+1] := (in.getCurrent())->toLong() )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var diff : int ; diff := (weights[i+1] - weights[0+1])->oclAsType(int) ;
         var j : int ; j := i ; while 0 <= j do ( (         var k : int ; k := sum ; while 0 <= k do ( (     dp[j + 1+1][k + diff+1] := Set{dp[j + 1+1][k + diff+1], dp[j+1][k+1] + values[i+1]}->max() )  ;     k := k - 1 ) )  ;     j := j - 1 ) ; 
     sum := sum+(diff) )  ;     i := i + 1 ) ; 
    var result : long ; result := 0 ;
        var i : int ; i := 0 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= sum do ( (     if (w < i * weights[0+1] + j) then (     continue ) else skip ; 
     result := Set{result, dp[i+1][j+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static int calculateSum(String arr[],int n){
    if(n==0)return 0 ;
    String s=arr[0];
    int value=Integer.parseInt(s);
    int sum=value ;
    for(int i=2 ; i<n ; i=i+2){
      s=arr[i];
      value=Integer.parseInt(s);
      char operation=arr[i-1] .charAt(0);
      if(operation=='+')sum+=value ;
      else sum-=value ;
    }
    return sum ;
  }
  public static void main(String[] args){
    String arr[]={
      "3","+","4","-","7","+","13" };
      int n=arr.length ;
      System.out.println(calculateSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculateSum( arr : Sequence(String), n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else skip ; 
     var s : String ; s := arr[0+1] ;
    var value : int ; value := (s)->toInteger() ;
    var sum : int ; sum := value ;
        var i : int ; i := 2 ; while i < n do ( (     s := arr[i+1] ; 
     value := (s)->toInteger() ; 
     var operation : String ; operation := arr[i - 1+1]->at(0+1) ;
     if (operation = '+') then     sum := sum+(value) ; else     sum := sum-(value) ; )  ;     i := i + 2 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"3","+","4","-","7","+","13"} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(calculateSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  public static boolean isFascinating(int num){
    int[] freq=new int[10];
    String val=""+num+num*2+num*3 ;
    for(int i=0 ; i<val.length(); i++){
      int digit=val.charAt(i)-'0' ;
      if(freq[digit]>0)return false ;
      else freq[digit]++;
    }
    for(int i=1 ; i<freq.length ; i++){
      if(freq[i]==0)return false ;
    }
    return true ;
  }
  public static void main(String args[]){
    int num=192 ;
    if(num<100)System.out.println("No");
    else {
      boolean ans=isFascinating(num);
      if(ans)System.out.println("Yes");
      else System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isFascinating( num : int) : boolean
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,10)->collect(0) ;
     var val : String ; val := "" + num + num * 2 + num * 3 ;
        var i : int ; i := 0 ; while i < val->size() do ( (     var digit : int ; digit := val->at(i+1) - ('0')->char2byte() ;
     if (freq[digit+1] > 0) then     return false else     freq[digit+1] := freq[digit+1] + 1 ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < freq->size() do ( (     if (freq[i+1] = 0) then     return false else skip )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 192 ;
     if (num < 100) then     OclFile["System.out"].println("No") ; else (     var ans : boolean ; ans := isFascinating(num) ;
     if (ans) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    int[][] price=new int[3][26];
    for(int i=0 ; i<3 ; i++){
      for(int j=1 ; j<26 ; j++){
        switch(i){
          case 0 : price[i][j]=price[i][j-1]+380 ;
          if(j % 5==0){
            price[i][j]-=380 ;
          }
          break ;
          case 1 : price[i][j]=price[i][j-1]+550 ;
          if(j % 4==0){
            price[i][j]-=330 ;
          }
          break ;
          case 2 : price[i][j]=price[i][j-1]+850 ;
          if(j % 3==0){
            price[i][j]-=306 ;
          }
          break ;
        }
      }
    }
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=Integer.parseInt(line);
      if(n==0){
        break ;
      }
      int min=Integer.MAX_VALUE ;
      for(int i=0 ; i<n/200+1 ; i++){
        for(int j=0 ; j<n/300+1 ; j++){
          for(int k=0 ; k<n/500+1 ; k++){
            if(i*200+j*300+k*500==n){
              int sum=price[0][i]+price[1][j]+price[2][k];
              if(sum<min){
                min=sum ;
              }
            }
          }
        }
      }
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
    var price : Sequence(Sequence(int)) ; price := Integer.subrange(1,3)->collect(Integer.subrange(1,26)->collect(0)) ;
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 1 ; while j < 26 do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (i) ; 
       if _switchval = 0 then
     price[i+1][j+1] := price[i+1][j - 1+1] + 380 ; 
    if (j mod 5 = 0) then (     price[i+1][j+1] := price[i+1][j+1]-(380) ) else skip ; 
    break 
   else skip ;
       if _switchval = 1 then
     price[i+1][j+1] := price[i+1][j - 1+1] + 550 ; 
    if (j mod 4 = 0) then (     price[i+1][j+1] := price[i+1][j+1]-(330) ) else skip ; 
    break 
   else skip ;
       if _switchval = 2 then
     price[i+1][j+1] := price[i+1][j - 1+1] + 850 ; 
    if (j mod 3 = 0) then (     price[i+1][j+1] := price[i+1][j+1]-(306) ) else skip ; 
    break 
   else skip ;
 )
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := (line)->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < n / 200 + 1 do ( (         var j : int ; j := 0 ; while j < n / 300 + 1 do ( (         var k : int ; k := 0 ; while k < n / 500 + 1 do ( (     if (i * 200 + j * 300 + k * 500 = n) then (     var sum : int ; sum := price[0+1][i+1] + price[1+1][j+1] + price[2+1][k+1] ;
     if (sum < min) then (     min := sum ) else skip ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 ) ;     line := br.readLine() ;
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int[] c ;
    int y,i ;
    c=new int[51];
    for(i=0 ; i<51 ; i++)c[i]=850*200 ;
    c[0]=0 ;
    for(i=0 ; i<51 ; i++){
      if(i+2<51 && c[i]+380<c[i+2])c[i+2]=c[i]+380 ;
      if(i+3<51 && c[i]+550<c[i+3])c[i+3]=c[i]+550 ;
      if(i+5<51 && c[i]+850<c[i+5])c[i+5]=c[i]+850 ;
      if(i+10<51 && c[i]+1900*8/10<c[i+10])c[i+10]=c[i]+1900*8/10 ;
      if(i+12<51 && c[i]+2200*85/100<c[i+12])c[i+12]=c[i]+2200*85/100 ;
      if(i+15<51 && c[i]+2550*88/100<c[i+15])c[i+15]=c[i]+2550*88/100 ;
    }
    for(; ; ){
      y=sc.nextInt();
      if(y==0)break ;
      out.println(c[y/100]);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var c : Sequence(int) ;
    var y : int ;
    var i : int ;
    c := Integer.subrange(1,51)->collect(0) ; 
        i := 0 ; while i < 51 do (     c[i+1] := 850 * 200 ;  ;     i := i + 1 ) ; 
    c[0+1] := 0 ; 
        i := 0 ; while i < 51 do ( (     if (i + 2 < 51 & c[i+1] + 380 < c[i + 2+1]) then     c[i + 2+1] := c[i+1] + 380 ; else skip ; 
     if (i + 3 < 51 & c[i+1] + 550 < c[i + 3+1]) then     c[i + 3+1] := c[i+1] + 550 ; else skip ; 
    if (i + 5 < 51 & c[i+1] + 850 < c[i + 5+1]) then     c[i + 5+1] := c[i+1] + 850 ; else skip ; 
    if (i + 10 < 51 & c[i+1] + 1900 * 8 / 10 < c[i + 10+1]) then     c[i + 10+1] := c[i+1] + 1900 * 8 / 10 ; else skip ; 
    if (i + 12 < 51 & c[i+1] + 2200 * 85 / 100 < c[i + 12+1]) then     c[i + 12+1] := c[i+1] + 2200 * 85 / 100 ; else skip ; 
    if (i + 15 < 51 & c[i+1] + 2550 * 88 / 100 < c[i + 15+1]) then     c[i + 15+1] := c[i+1] + 2550 * 88 / 100 ; else skip ; 
 )  ;     i := i + 1 ) ; 
      while true do ( (     y := sc.nextInt() ; 
     if (y = 0) then     break else skip ; 
     out.println(c[y / 100+1]) )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.*;
public class ques {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int count=1 ;
      int qou=n/10 ;
      while(qou>0){
        count++;
        qou=qou/10 ;
      }
      int zeroes=1 ;
      double ones=1 ;
      for(double j=1 ; j<count ; j++){
        zeroes=10*zeroes ;
        ones=ones+Math.pow(10,j);
      }
      int firstDigit=n/(zeroes);
      int ans=(count-1)*9+firstDigit-1 ;
      if(n>=ones*firstDigit){
        ans=ans+1 ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ques {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var count : int ; count := 1 ;
    var qou : int ; qou := n / 10 ;
    while (qou > 0) do (     count := count + 1 ; 
     qou := qou / 10 ) ; 
    var zeroes : int ; zeroes := 1 ;
    var ones : double ; ones := 1 ;
        var j : double ; j := 1 ; while j < count do ( (     zeroes := 10 * zeroes ; 
     ones := ones + 10->pow(j) )  ;     j := j + 1 ) ; 
    var firstDigit : int ; firstDigit := n / (zeroes) ;
    var ans : int ; ans := (count - 1) * 9 + firstDigit - 1 ;
    if (n >= ones * firstDigit) then (     ans := ans + 1 ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    int[] a=new int[51];
    Arrays.fill(a,INF);
    for(int k=0 ; toGramme(0,0,k)<=50 ; k++){
      for(int j=0 ; toGramme(0,j,k)<=50 ; j++){
        for(int i=0 ; toGramme(i,j,k)<=50 ; i++){
          int g=toGramme(i,j,k);
          a[g]=Math.min(a[g],toMoney(i,j,k));
        }
      }
    }
    for(; ; ){
      int g=sc.nextInt()/100 ;
      if(g==0){
        break ;
      }
      println(a[g]+"");
    }
  }
  int toGramme(int i,int j,int k){
    return i*2+j*3+k*5 ;
  }
  int toMoney(int i,int j,int k){
    int sum=0 ;
    sum+=380*(i-i % 5)*80/100+380*(i % 5);
    sum+=550*(j-j % 4)*85/100+550*(j % 4);
    sum+=850*(k-k % 3)*88/100+850*(k % 3);
    return sum ;
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,51)->collect(0) ;
     a := a->collect(INF) ; 
         var k : int ; k := 0 ; while toGramme(0, 0, k) <= 50 do ( (         var j : int ; j := 0 ; while toGramme(0, j, k) <= 50 do ( (         var i : int ; i := 0 ; while toGramme(i, j, k) <= 50 do ( (     var g : int ; g := toGramme(i, j, k) ;
     a[g+1] := Set{a[g+1], toMoney(i, j, k)}->min() )  ;     i := i + 1 ) )  ;     j := j + 1 ) )  ;     k := k + 1 ) ; 
       while true do ( (     var g : int ; g := sc.getCurrent()->toInteger() / 100 ;
     if (g = 0) then (     break ) else skip ; 
     execute println(a[g+1] + "") )  ) );
   operation toGramme( i : int, j : int, k : int) : int
  pre: true
  post: true
  activity: (     return i * 2 + j * 3 + k * 5 );
   operation toMoney( i : int, j : int, k : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     sum := sum+(380 * (i - i mod 5) * 80 / 100 + 380 * (i mod 5)) ; 
    sum := sum+(550 * (j - j mod 4) * 85 / 100 + 550 * (j mod 4)) ; 
    sum := sum+(850 * (k - k mod 3) * 88 / 100 + 850 * (k mod 3)) ; 
    return sum 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int min=Integer.MAX_VALUE ;
  static int w[]={
    200,300,500 };
    static int p[]={
      380,550,850 };
      static int e[]={
        5,4,3 };
        static double r[]={
          0.8,0.85,0.88 };
          public static void main(String[] args)throws Exception {
            Scanner sc=new Scanner(System.in);
            while(true){
              int n=sc.nextInt();
              if(n==0)break ;
              min=Integer.MAX_VALUE ;
              solve(0,n,0);
              System.out.println((int)min);
            }
          }
          public static void solve(int k,int rest,int cost){
            if(rest==0){
              min=Math.min(min,cost);
              return ;
            }
            if(k==3 || rest<0)return ;
            for(int i=0 ; i<=5000/w[k]; i++){
              solve(k+1,rest-w[k]*i,cost+(int)((i-i % e[k])*r[k]*p[k]+i % e[k]*p[k]));
            }
          }
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute min : int := 2147483647;
  static   attribute w : int := Sequence{200,300,500};
  static   attribute p : int := Sequence{380,550,850};
  static   attribute e : int := Sequence{5,4,3};
  static   attribute r : double := Sequence{0.8,0.85,0.88};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    min := 2147483647 ; 
    execute solve(0, n, 0) ; 
    OclFile["System.out"].println(min->oclAsType(int)) ; 
 ) );
  static   operation solve( k : int, rest : int, cost : int) : void
  pre: true
  post: true
  activity: (     if (rest = 0) then (     min := Set{min, cost}->min() ; 
     return ) else skip ; 
     if (k = 3 or rest < 0) then     return else skip ; 
         var i : int ; i := 0 ; while i <= 5000 / w[k+1] do ( (     execute solve(k + 1, rest - w[k+1] * i, cost + ((i - i mod e[k+1]) * r[k+1] * p[k+1] + i mod e[k+1] * p[k+1])->oclAsType(int)) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n!=0){
      System.out.println(min(n));
      n=sc.nextInt();
    }
    sc.close();
  }
  static int min(int n){
    int min=Integer.MAX_VALUE ;
    for(int c=n/500 ; c>=0 ; c--){
      for(int b=(n-c*500)/300 ; b>=0 ; b--){
        if((n-c*500-b*300)% 200==0){
          int a=(n-c*500-b*300)/200 ;
          int cost=cost(a,b,c);
          if(cost<min){
            min=cost ;
          }
        }
      }
    }
    return min ;
  }
  static int cost(int a,int b,int c){
    return(a % 5)*380+(a/5)*5*380*8/10+(b % 4)*550+(b/4)*4*550*85/100+(c % 3)*850+(c/3)*3*850*88/100 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     while (n /= 0) do (     OclFile["System.out"].println(Set{n}->min()) ; 
     n := sc.getCurrent()->toInteger() ) ; 
     skip );
  static   operation min( n : int) : int
  pre: true
  post: true
  activity: (     var min : int ; min := 2147483647 ;
         var c : int ; c := n / 500 ; while c >= 0 do ( (         var b : int ; b := (n - c * 500) / 300 ; while b >= 0 do ( (     if ((n - c * 500 - b * 300) mod 200 = 0) then (     var a : int ; a := (n - c * 500 - b * 300) / 200 ;
     var cost : int ; cost := cost(a, b, c) ;
     if (cost < min) then (     min := cost ) else skip ) else skip )  ;     b := b - 1 ) )  ;     c := c - 1 ) ; 
     return min );
  static   operation cost( a : int, b : int, c : int) : int
  pre: true
  post: true
  activity: (     return (a mod 5) * 380 + (a / 5) * 5 * 380 * 8 / 10 + (b mod 4) * 550 + (b / 4) * 4 * 550 * 85 / 100 + (c mod 3) * 850 + (c / 3) * 3 * 850 * 88 / 100 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    System.out.println("0.00000 0.00000");
    kochCalc(0,0,100,0,n);
    System.out.println("100.00000 0.00000");
  }
  public static void kochCalc(double x1,double y1,double x2,double y2,int n){
    if(n==0)return ;
    double dis=Math.pow(Math.pow(x1-x2,2)+Math.pow(y1-y2,2),.5);
    double true_dis=dis/3 ;
    double ang=Math.atan2(y2-y1,x2-x1);
    double sx=x1+Math.cos(ang)*true_dis ;
    double sy=y1+Math.sin(ang)*true_dis ;
    double tx=sx+Math.cos(ang)*true_dis ;
    double ty=sy+Math.sin(ang)*true_dis ;
    double ux=sx+Math.cos(ang+Math.PI/3)*true_dis ;
    double uy=sy+Math.sin(ang+Math.PI/3)*true_dis ;
    kochCalc(x1,y1,sx,sy,n-1);
    System.out.printf("%.5f %.5f\n",sx,sy);
    kochCalc(sx,sy,ux,uy,n-1);
    System.out.printf("%.5f %.5f\n",ux,uy);
    kochCalc(ux,uy,tx,ty,n-1);
    System.out.printf("%.5f %.5f\n",tx,ty);
    kochCalc(tx,ty,x2,y2,n-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println("0.00000 0.00000") ; 
    execute kochCalc(0, 0, 100, 0, n) ; 
    OclFile["System.out"].println("100.00000 0.00000") ; 
 );
  static   operation kochCalc( x1 : double, y1 : double, x2 : double, y2 : double, n : int) : void
  pre: true
  post: true
  activity: (     if (n = 0) then     return else skip ; 
     var dis : double ; dis := x1 - x2->pow(2) + y1 - y2->pow(2)->pow(.5) ;
    var true_dis : double ; true_dis := dis / 3 ;
    var ang : double ; ang := atan2(y2 - y1, x2 - x1) ;
    var sx : double ; sx := x1 + (ang)->cos() * true_dis ;
    var sy : double ; sy := y1 + (ang)->sin() * true_dis ;
    var tx : double ; tx := sx + (ang)->cos() * true_dis ;
    var ty : double ; ty := sy + (ang)->sin() * true_dis ;
    var ux : double ; ux := sx + (ang + 3.141592653589793 / 3)->cos() * true_dis ;
    var uy : double ; uy := sy + (ang + 3.141592653589793 / 3)->sin() * true_dis ;
    execute kochCalc(x1, y1, sx, sy, n - 1) ; 
    OclFile["System.out"].printf("%.5f %.5f\n", sx, sy) ; 
    execute kochCalc(sx, sy, ux, uy, n - 1) ; 
    OclFile["System.out"].printf("%.5f %.5f\n", ux, uy) ; 
    execute kochCalc(ux, uy, tx, ty, n - 1) ; 
    OclFile["System.out"].printf("%.5f %.5f\n", tx, ty) ; 
    execute kochCalc(tx, ty, x2, y2, n - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getMinimumOps(int ar[],int k){
    int n=ar.length ;
    int dp[][]=new int[n][k+1];
    dp[0][1]=0 ;
    for(int i=1 ; i<n ; i++){
      int maxGroups=Math.min(k,i+1);
      for(int j=1 ; j<=maxGroups ; j++){
        dp[i][j]=Integer.MAX_VALUE ;
        if(j==1){
          int freq[]=new int[100000];
          int freqOfMode=0 ;
          for(int it=0 ; it<=i ; it++){
            freq[ar[it] ]++;
            int newElementFreq=freq[ar[it] ];
            if(newElementFreq>freqOfMode)freqOfMode=newElementFreq ;
          }
          dp[i][1]=(i+1)-freqOfMode ;
        }
        else {
          int freq[]=new int[100000];
          int freqOfMode=0 ;
          for(int it=i ; it>=j-1 ; it--){
            freq[ar[it] ]++;
            int newElementFreq=freq[ar[it] ];
            if(newElementFreq>freqOfMode)freqOfMode=newElementFreq ;
            int elementsToChange=i-it+1 ;
            elementsToChange-=freqOfMode ;
            dp[i][j]=Math.min(dp[it-1][j-1]+elementsToChange,dp[i][j]);
          }
        }
      }
    }
    return dp[n-1][k];
  }
  public static void main(String args[]){
    int k=3 ;
    int ar[]={
      3,1,3,3,2,1,8,5 };
      System.out.println(getMinimumOps(ar,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getMinimumOps( ar : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := ar->size() ;
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,k + 1)->collect(0)) ;
    dp[0+1][1+1] := 0 ; 
        var i : int ; i := 1 ; while i < n do ( (     var maxGroups : int ; maxGroups := Set{k, i + 1}->min() ;
         var j : int ; j := 1 ; while j <= maxGroups do ( (     dp[i+1][j+1] := 2147483647 ; 
     if (j = 1) then (     var freq : Sequence(int) ; freq := Integer.subrange(1,100000)->collect(0) ;
     var freqOfMode : int ; freqOfMode := 0 ;
         var it : int ; it := 0 ; while it <= i do ( (     freq[ar[it+1]+1] := freq[ar[it+1]+1] + 1 ; 
     var newElementFreq : int ; newElementFreq := freq[ar[it+1]+1] ;
     if (newElementFreq > freqOfMode) then     freqOfMode := newElementFreq ; else skip )  ;     it := it + 1 ) ; 
     dp[i+1][1+1] := (i + 1) - freqOfMode ) else (     var freq : Sequence(int) ; freq := Integer.subrange(1,100000)->collect(0) ;
     var freqOfMode : int ; freqOfMode := 0 ;
         var it : int ; it := i ; while it >= j - 1 do ( (     freq[ar[it+1]+1] := freq[ar[it+1]+1] + 1 ; 
     var newElementFreq : int ; newElementFreq := freq[ar[it+1]+1] ;
    if (newElementFreq > freqOfMode) then     freqOfMode := newElementFreq ; else skip ; 
    var elementsToChange : int ; elementsToChange := i - it + 1 ;
    elementsToChange := elementsToChange-(freqOfMode) ; 
    dp[i+1][j+1] := Set{dp[it - 1+1][j - 1+1] + elementsToChange, dp[i+1][j+1]}->min() ; 
 )  ;     it := it - 1 ) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return dp[n - 1+1][k+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 3 ;
     var ar : Sequence(int) ; ar := Sequence{3,1,3,3,2,1,8,5} ;
     OclFile["System.out"].println(getMinimumOps(ar, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static class Point {
    double x ;
    double y ;
    public Point(double x,double y){
      this.x=x ;
      this.y=y ;
    }
    public String toString(){
      return x+" "+y ;
    }
  }
  static int n ;
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    n=scan.nextInt();
    Point start=new Point(0.0,0.0);
    Point end=new Point(100.0,0.0);
    System.out.println(start);
    make(start,end,0);
    System.out.println(end);
    scan.close();
  }
  public static void make(Point start,Point end,int i){
    if(n<=i){
      return ;
    }
    Point s=new Point((2.0*start.x+1.0*end.x)/3.0,(2.0*start.y+1.0*end.y)/3.0);
    Point t=new Point((1.0*start.x+2.0*end.x)/3.0,(1.0*start.y+2.0*end.y)/3.0);
    double ux=(t.x-s.x)*Math.cos(Math.toRadians(60))-(t.y-s.y)*Math.sin(Math.toRadians(60))+s.x ;
    double uy=(t.x-s.x)*Math.sin(Math.toRadians(60))+(t.y-s.y)*Math.cos(Math.toRadians(60))+s.y ;
    Point u=new Point(ux,uy);
    make(start,s,i+1);
    System.out.println(s);
    make(s,u,i+1);
    System.out.println(u);
    make(u,t,i+1);
    System.out.println(t);
    make(t,end,i+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Point {
   attribute x : double;
   attribute y : double;
   static operation newPoint( x : double, y : double) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation toString() : String
  pre: true
  post: true
  activity: (     return x + " " + y );
}
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := scan.getCurrent()->toInteger() ; 
    var start : Point ; start := Point.newPoint(0.0, 0.0) ;
    var end : Point ; end := Point.newPoint(100.0, 0.0) ;
    OclFile["System.out"].println(start) ; 
    execute make(start, end, 0) ; 
    OclFile["System.out"].println(end) ; 
    skip ; 
 );
  static   operation make( start : Point, end : Point, i : int) : void
  pre: true
  post: true
  activity: (     if (n <= i) then (     return ) else skip ; 
     var s : Point ; s := Point.newPoint((2.0 * start.x + 1.0 * end.x) / 3.0, (2.0 * start.y + 1.0 * end.y) / 3.0) ;
    var t : Point ; t := Point.newPoint((1.0 * start.x + 2.0 * end.x) / 3.0, (1.0 * start.y + 2.0 * end.y) / 3.0) ;
    var ux : double ; ux := (t.x - s.x) * ((0.017453292519943295*(60)))->cos() - (t.y - s.y) * ((0.017453292519943295*(60)))->sin() + s.x ;
    var uy : double ; uy := (t.x - s.x) * ((0.017453292519943295*(60)))->sin() + (t.y - s.y) * ((0.017453292519943295*(60)))->cos() + s.y ;
    var u : Point ; u := Point.newPoint(ux, uy) ;
    execute make(start, s, i + 1) ; 
    OclFile["System.out"].println(s) ; 
    execute make(s, u, i + 1) ; 
    OclFile["System.out"].println(u) ; 
    execute make(u, t, i + 1) ; 
    OclFile["System.out"].println(t) ; 
    execute make(t, end, i + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javax.xml.crypto.Data ;
import java.util.*;
import java.io.*;
public class Main {
  static int n ;
  static int[] A=new int[50];
  static double th=Math.PI*60.0/180.0 ;
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    Point P1=new Point(0,0);
    Point P2=new Point(100,0);
    System.out.printf("%.8f %.8f\n",P1.x,P1.y);
    koch(n,P1,P2);
    System.out.printf("%.8f %.8f\n",P2.x,P2.y);
  }
  public static void koch(int d,Point P1,Point P2){
    if(d==0)return ;
    double x1=P1.x ;
    double y1=P1.y ;
    double x2=P2.x ;
    double y2=P2.y ;
    double sx=(2*x1+x2)/3 ;
    double sy=(2*y1+y2)/3 ;
    double tx=(x1+2*x2)/3 ;
    double ty=(y1+2*y2)/3 ;
    double ux=sx+(tx-sx)*Math.cos(th)-(ty-sy)*Math.sin(th);
    double uy=sy+(tx-sx)*Math.sin(th)+(ty-sy)*Math.cos(th);
    Point S=new Point(sx,sy);
    Point T=new Point(tx,ty);
    Point U=new Point(ux,uy);
    koch(d-1,P1,S);
    System.out.printf("%.8f %.8f\n",sx,sy);
    koch(d-1,S,U);
    System.out.printf("%.8f %.8f\n",ux,uy);
    koch(d-1,U,T);
    System.out.printf("%.8f %.8f\n",tx,ty);
    koch(d-1,T,P2);
  }
}
class Point {
  double x ;
  double y ;
  Point(double a,double b){
    x=a ;
    y=b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute A : Sequence(int) := Integer.subrange(1,50)->collect(0);
  static   attribute th : double := 3.141592653589793 * 60.0 / 180.0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    var P1 : Point ; P1 := Point.newPoint(0, 0) ;
    var P2 : Point ; P2 := Point.newPoint(100, 0) ;
    OclFile["System.out"].printf("%.8f %.8f\n", P1.x, P1.y) ; 
    execute koch(n, P1, P2) ; 
    OclFile["System.out"].printf("%.8f %.8f\n", P2.x, P2.y) ; 
 );
  static   operation koch( d : int, P1 : Point, P2 : Point) : void
  pre: true
  post: true
  activity: (     if (d = 0) then     return else skip ; 
     var x1 : double ; x1 := P1.x ;
    var y1 : double ; y1 := P1.y ;
    var x2 : double ; x2 := P2.x ;
    var y2 : double ; y2 := P2.y ;
    var sx : double ; sx := (2 * x1 + x2) / 3 ;
    var sy : double ; sy := (2 * y1 + y2) / 3 ;
    var tx : double ; tx := (x1 + 2 * x2) / 3 ;
    var ty : double ; ty := (y1 + 2 * y2) / 3 ;
    var ux : double ; ux := sx + (tx - sx) * (th)->cos() - (ty - sy) * (th)->sin() ;
    var uy : double ; uy := sy + (tx - sx) * (th)->sin() + (ty - sy) * (th)->cos() ;
    var S : Point ; S := Point.newPoint(sx, sy) ;
    var T : Point ; T := Point.newPoint(tx, ty) ;
    var U : Point ; U := Point.newPoint(ux, uy) ;
    execute koch(d - 1, P1, S) ; 
    OclFile["System.out"].printf("%.8f %.8f\n", sx, sy) ; 
    execute koch(d - 1, S, U) ; 
    OclFile["System.out"].printf("%.8f %.8f\n", ux, uy) ; 
    execute koch(d - 1, U, T) ; 
    OclFile["System.out"].printf("%.8f %.8f\n", tx, ty) ; 
    execute koch(d - 1, T, P2) ; 
 );
}
class Point {
   attribute x : double;
   attribute y : double;
   static operation newPoint( a : double, b : double) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(a, b);
    return self );
  operation initialise( a : double, b : double) : void
  pre: true  post: true
  activity: (     x := a ; 
     y := b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.text.DecimalFormat ;
class Main {
  private static final DecimalFormat fmt=new DecimalFormat("0.########");
  private static final StringBuilder sb=new StringBuilder();
  public static void main(String[] args)throws IOException {
    final BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    final int n=Integer.parseInt(br.readLine());
    sb.append("0 0\n");
    koch(0,0,100,0,n);
    sb.append("100 0\n");
    System.out.print(sb);
  }
  private static void koch(double x0,double y0,double x1,double y1,int n){
    if(n==0)return ;
    n--;
    final double sx=(x0+x0+x1)/3 ;
    final double sy=(y0+y0+y1)/3 ;
    final double ux=(x0+x1)/2-(y1-y0)*Math.sqrt(3)/6 ;
    final double uy=(y0+y1)/2+(x1-x0)*Math.sqrt(3)/6 ;
    final double tx=(x0+x1+x1)/3 ;
    final double ty=(y0+y1+y1)/3 ;
    koch(x0,y0,sx,sy,n);
    sb.append(fmt.format(sx)).append(' ').append(fmt.format(sy)).append('\n');
    koch(sx,sy,ux,uy,n);
    sb.append(fmt.format(ux)).append(' ').append(fmt.format(uy)).append('\n');
    koch(ux,uy,tx,ty,n);
    sb.append(fmt.format(tx)).append(' ').append(fmt.format(ty)).append('\n');
    koch(tx,ty,x1,y1,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute fmt : DecimalFormat := DecimalFormat.newDecimalFormat("0.########");
  static    attribute sb : String := StringLib.newString();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    sb := sb + StringLib.newString("0 0\n") ; 
    execute koch(0, 0, 100, 0, n) ; 
    sb := sb + StringLib.newString("100 0\n") ; 
    OclFile["System.out"].print(sb) ; 
 );
  static   operation koch( x0 : double, y0 : double, x1 : double, y1 : double, n : int) : void
  pre: true
  post: true
  activity: (     if (n = 0) then     return else skip ; 
     n := n - 1 ; 
    var sx : double ; sx := (x0 + x0 + x1) / 3 ;
    var sy : double ; sy := (y0 + y0 + y1) / 3 ;
    var ux : double ; ux := (x0 + x1) / 2 - (y1 - y0) * (3)->sqrt() / 6 ;
    var uy : double ; uy := (y0 + y1) / 2 + (x1 - x0) * (3)->sqrt() / 6 ;
    var tx : double ; tx := (x0 + x1 + x1) / 3 ;
    var ty : double ; ty := (y0 + y1 + y1) / 3 ;
    execute koch(x0, y0, sx, sy, n) ; 
    sb := sb + StringLib.newString(fmt.format(sx)) + StringLib.newString(' ') + StringLib.newString(fmt.format(sy)) + StringLib.newString('
') ; 
    execute koch(sx, sy, ux, uy, n) ; 
    sb := sb + StringLib.newString(fmt.format(ux)) + StringLib.newString(' ') + StringLib.newString(fmt.format(uy)) + StringLib.newString('
') ; 
    execute koch(ux, uy, tx, ty, n) ; 
    sb := sb + StringLib.newString(fmt.format(tx)) + StringLib.newString(' ') + StringLib.newString(fmt.format(ty)) + StringLib.newString('
') ; 
    execute koch(tx, ty, x1, y1, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.Math ;
public class Main {
  void kochCurve(int n,Point p1,Point p2){
    if(n!=0){
      Point s=new Point((2*p1.x+p2.x)/3,(2*p1.y+p2.y)/3);
      Point t=new Point((p1.x+2*p2.x)/3,(p1.y+2*p2.y)/3);
      Point u=new Point((t.x-s.x)*Math.cos(Math.toRadians(60))-(t.y-s.y)*Math.sin(Math.toRadians(60))+s.x,(t.x-s.x)*Math.sin(Math.toRadians(60))+(t.y-s.y)*Math.cos(Math.toRadians(60))+s.y);
      kochCurve(n-1,p1,s);
      s.print();
      kochCurve(n-1,s,u);
      u.print();
      kochCurve(n-1,u,t);
      t.print();
      kochCurve(n-1,t,p2);
    }
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Point p1=new Point(0,0);
    Point p2=new Point(100,0);
    p1.print();
    kochCurve(n,p1,p2);
    p2.print();
    sc.close();
  }
  public static void main(String[] args){
    new Main().run();
  }
}
class Point {
  double x ;
  double y ;
  Point(double x,double y){
    this.x=x ;
    this.y=y ;
  }
  void print(){
    System.out.printf("%.8f %.8f\n",x,y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation kochCurve( n : int, p1 : Point, p2 : Point) : void
  pre: true
  post: true
  activity: (     if (n /= 0) then (     var s : Point ; s := Point.newPoint((2 * p1.x + p2.x) / 3, (2 * p1.y + p2.y) / 3) ;
     var t : Point ; t := Point.newPoint((p1.x + 2 * p2.x) / 3, (p1.y + 2 * p2.y) / 3) ;
    var u : Point ; u := Point.newPoint((t.x - s.x) * ((0.017453292519943295*(60)))->cos() - (t.y - s.y) * ((0.017453292519943295*(60)))->sin() + s.x, (t.x - s.x) * ((0.017453292519943295*(60)))->sin() + (t.y - s.y) * ((0.017453292519943295*(60)))->cos() + s.y) ;
    execute kochCurve(n - 1, p1, s) ; 
    s.print() ; 
    execute kochCurve(n - 1, s, u) ; 
    u.print() ; 
    execute kochCurve(n - 1, u, t) ; 
    t.print() ; 
    execute kochCurve(n - 1, t, p2) ; 
 ) else skip );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var p1 : Point ; p1 := Point.newPoint(0, 0) ;
    var p2 : Point ; p2 := Point.newPoint(100, 0) ;
    p1.print() ; 
    execute kochCurve(n, p1, p2) ; 
    p2.print() ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}
class Point {
   attribute x : double;
   attribute y : double;
   static operation newPoint( x : double, y : double) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation print() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].printf("%.8f %.8f\n", x, y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Gfg {
  public static int composite_factors(int n){
    int count=0 ;
    int i,j ;
    int[] a=new int[n+1];
    for(i=0 ; i<n ; i++){
      a[i]=0 ;
    }
    for(i=1 ; i<=n ; ++i){
      if(n % i==0){
        a[i]=i ;
      }
    }
    for(i=2 ; i<=n ; i++){
      j=2 ;
      int p=1 ;
      while(j<a[i]){
        if(a[i] % j==0){
          p=0 ;
          break ;
        }
        j++;
      }
      if(p==0 && a[i]!=0){
        count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int n=100 ;
    System.out.println(composite_factors(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Gfg {
  static   operation composite_factors( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var i : int ;
    var j : int ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        i := 0 ; while i < n do ( (     a[i+1] := 0 )  ;     i := i + 1 ) ; 
        i := 1 ; while i <= n do ( (     if (n mod i = 0) then (     a[i+1] := i ) else skip )  ;     i := i + 1 ) ; 
        i := 2 ; while i <= n do ( (     j := 2 ; 
     var p : int ; p := 1 ;
     while (j < a[i+1]) do (     if (a[i+1] mod j = 0) then (     p := 0 ; 
     break ) else skip ; 
     j := j + 1 ) ; 
     if (p = 0 & a[i+1] /= 0) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 100 ;
     OclFile["System.out"].println(composite_factors(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
class GFG {
  static int divSum(int n){
    int sum=1 ;
    for(int i=2 ; i*i<=n ; i++)if(n % i==0)sum=sum+i+n/i ;
    return sum ;
  }
  static boolean areEquivalent(int num1,int num2){
    return divSum(num1)==divSum(num2);
  }
  public static void main(String[] args){
    int num1=559 ;
    int num2=703 ;
    if(areEquivalent(num1,num2))System.out.println("Equivalent");
    else System.out.println("Not Equivalent");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation divSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 1 ;
         var i : int ; i := 2 ; while i * i <= n do (     if (n mod i = 0) then     sum := sum + i + n / i ; else skip ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation areEquivalent( num1 : int, num2 : int) : boolean
  pre: true
  post: true
  activity: (     return divSum(num1) = divSum(num2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num1 : int ; num1 := 559 ;
     var num2 : int ; num2 := 703 ;
     if (areEquivalent(num1, num2)) then     OclFile["System.out"].println("Equivalent") ; else     OclFile["System.out"].println("Not Equivalent") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
public class GfG {
  static int findSubarraySum(int arr[],int n,int sum){
    HashMap<Integer,Integer>prevSum=new HashMap<>();
    int res=0 ;
    int currsum=0 ;
    for(int i=0 ; i<n ; i++){
      currsum+=arr[i];
      if(currsum==sum)res++;
      if(prevSum.containsKey(currsum-sum))res+=prevSum.get(currsum-sum);
      Integer count=prevSum.get(currsum);
      if(count==null)prevSum.put(currsum,1);
      else prevSum.put(currsum,count+1);
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      10,2,-2,-20,10 };
      int sum=-10 ;
      int n=arr.length ;
      System.out.println(findSubarraySum(arr,n,sum));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation findSubarraySum( arr : Sequence(int), n : int, sum : int) : int
  pre: true
  post: true
  activity: (     var prevSum : Map(int,int) ; prevSum := Map{} ;
     var res : int ; res := 0 ;
    var currsum : int ; currsum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     currsum := currsum+(arr[i+1]) ; 
     if (currsum = sum) then     res := res + 1 ; else skip ; 
    if (prevSum->keys()->includes(currsum - sum)) then     res := res+(prevSum->at(currsum - sum)) ; else skip ; 
    var count : int ; count := prevSum->at(currsum) ;
    if (count = null) then     prevSum := prevSum->union(Map{currsum |-> 1}) else     prevSum := prevSum->union(Map{currsum |-> count + 1}) ; ;  
 )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,2,-2,-20,10} ;
     var sum : int ; sum := -10 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findSubarraySum(arr, n, sum)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1279_NewYearGarland_math_Round79 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int rows ;
    rows=sc.nextInt();
    int[][] a=new int[rows][3];
    for(int i=0 ; i<rows ; i++){
      for(int j=0 ; j<3 ; j++){
        a[i][j]=sc.nextInt();
      }
    }
    sc.close();
    for(int i=0 ; i<rows ; i++){
      if((a[i][0]+a[i][1]<a[i][2]-1)||(a[i][0]+a[i][2]<a[i][1]-1)||(a[i][1]+a[i][2]<a[i][0]-1)){
        System.out.println("No");
      }
      else {
        System.out.println("Yes");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1279_NewYearGarland_math_Round79 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var rows : int ;
    rows := sc.getCurrent()->toInteger() ; 
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,rows)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < rows do ( (         var j : int ; j := 0 ; while j < 3 do ( (     a[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < rows do ( (     if ((a[i+1][0+1] + a[i+1][1+1] < a[i+1][2+1] - 1) or (a[i+1][0+1] + a[i+1][2+1] < a[i+1][1+1] - 1) or (a[i+1][1+1] + a[i+1][2+1] < a[i+1][0+1] - 1)) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int q=sc.nextInt();
      while(q-->0){
        int r=sc.nextInt();
        int g=sc.nextInt();
        int b=sc.nextInt();
        if(r==g && g==b && b==r)System.out.println("YES");
        else if((b>=g && b>=r &&(b<=r+g+1))||(g>=r && g>=b &&(g<=r+b+1))||(r>=g && r>=b &&(r<=g+b+1)))System.out.println("YES");
        else System.out.println("NO");
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
         while (q > 0) do (        q := q - 1 ;     skip ; (     var r : int ; r := sc.getCurrent()->toInteger() ;
     var g : int ; g := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (r = g & g = b & b = r) then     OclFile["System.out"].println("YES") ; else     if ((b >= g & b >= r & (b <= r + g + 1)) or (g >= r & g >= b & (g <= r + b + 1)) or (r >= g & r >= b & (r <= g + b + 1))) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int arr[]=new int[3];
      for(int i=0 ; i<3 ; i++){
        arr[i]=sc.nextInt();
      }
      Arrays.sort(arr);
      if(arr[0]+arr[1]>=(arr[2]-1))System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var arr : Sequence(int) ; arr := Integer.subrange(1,3)->collect(0) ;
         var i : int ; i := 0 ; while i < 3 do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     arr := arr->sort() ; 
     if (arr[0+1] + arr[1+1] >= (arr[2+1] - 1)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static boolean primeTable[]=new boolean[10001];
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    makePrimeCheckTable(10000);
    while(in.hasNext()){
      int n=in.nextInt();
      int cnt=0 ;
      for(int i=1 ; i<=n ; i++){
        if(isPrime(i)&& isPrime(n-i+1))cnt++;
      }
      System.out.println(cnt);
    }
  }
  private static void makePrimeCheckTable(int n){
    for(int i=2 ; i<=n ; i++)primeTable[i]=true ;
    for(int i=2 ; i*i<=n ; i++){
      if(primeTable[i]){
        for(int j=i*2 ; j<=n ; j+=i){
          primeTable[j]=false ;
        }
      }
    }
  }
  private static boolean isPrime(int n){
    return primeTable[n];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute primeTable : boolean := Integer.subrange(1,10001)->collect(false);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute makePrimeCheckTable(10000) ; 
     while (in.hasNext()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var cnt : int ; cnt := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     if (isPrime(i) & isPrime(n - i + 1)) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(cnt) ) );
  static   operation makePrimeCheckTable( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i <= n do (     primeTable[i+1] := true ;  ;     i := i + 1 ) ; 
         var i : int ; i := 2 ; while i * i <= n do ( (     if (primeTable[i+1]) then (         var j : int ; j := i * 2 ; while j <= n do ( (     primeTable[j+1] := false )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     return primeTable[n+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int CntcontSubs(int a[],int n){
    int c=0,d=0,i,sum=1,j ;
    for(i=0 ; i<n ; i++){
      if(a[i] % 2!=0 || a[i] % 4==0)d++;
      sum=a[i];
      for(j=i+1 ; j<n ; j++){
        sum=sum*a[j];
        if(sum % 2!=0 || sum % 4==0)c++;
      }
      sum=1 ;
    }
    return c+d ;
  }
  public static void main(String[] args){
    int arr[]={
      5,4,2,9,8 };
      int n=arr.length ;
      System.out.print(CntcontSubs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation CntcontSubs( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
    var d : int ; d := 0 ;
    var i : int ;
    var sum : int ; sum := 1 ;
    var j : int ;
         i := 0 ; while i < n do ( (     if (a[i+1] mod 2 /= 0 or a[i+1] mod 4 = 0) then     d := d + 1 ; else skip ; 
     sum := a[i+1] ; 
         j := i + 1 ; while j < n do ( (     sum := sum * a[j+1] ; 
     if (sum mod 2 /= 0 or sum mod 4 = 0) then     c := c + 1 ; else skip )  ;     j := j + 1 ) ; 
     sum := 1 )  ;     i := i + 1 ) ; 
     return c + d );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,4,2,9,8} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(CntcontSubs(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n ;
    int i,count ;
    for(; sc.hasNextInt(); ){
      n=sc.nextInt();
      count=0 ;
      for(i=1 ; i<=n ; i++)if(isprime(i)&& isprime(n+1-i))count++;
      System.out.println(count);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
  private static boolean isprime(int p){
    int i ;
    if(p==1)return false ;
    for(i=2 ; i*i<=p ; i++)if(p % i==0)return false ;
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var i : int ;
    var count : int ;
      while sc.hasNextInt() do ( (     n := sc.nextInt() ; 
     count := 0 ; 
         i := 1 ; while i <= n do (     if (isprime(i) & isprime(n + 1 - i)) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
  static   operation isprime( p : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ;
     if (p = 1) then     return false else skip ; 
         i := 2 ; while i * i <= p do (     if (p mod i = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int N=parseInt(line);
      boolean[] primes=primeB(N);
      int count=0 ;
      for(int i=1,j=N ; i<=N ; i++,j--){
        if(primes[i] && primes[j])count++;
      }
      System.out.println(count);
    }
  }
  static boolean[] primeB(int n){
    boolean[] ret=new boolean[n+1];
    int _n=(int)Math.sqrt(ret.length);
    Arrays.fill(ret,2,ret.length,true);
    for(int i=2 ; i<=_n ; i++){
      if(ret[i]){
        for(int j=i+i ; j<ret.length ; j+=i){
          if(ret[j])ret[j]=false ;
        }
      }
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var N : int ; N := parseInt(line) ;
     var primes : Sequence(boolean) ; primes := primeB(N) ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ;
    var j : int ; j := N ; while i <= N do ( (     if (primes[i+1] & primes[j+1]) then     count := count + 1 ; else skip )  ;     i := i + 1 ;     j := j - 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;     line := br.readLine() ;
 ) );
  static   operation primeB( n : int) : Sequence(boolean)
  pre: true
  post: true
  activity: (     var ret : Sequence(boolean) ; ret := Integer.subrange(1,n + 1)->collect(false) ;
     var _n : int ; _n := (ret->size())->sqrt()->oclAsType(int) ;
    ret := ret->collect(true) ; 
        var i : int ; i := 2 ; while i <= _n do ( (     if (ret[i+1]) then (         var j : int ; j := i + i ; while j < ret->size() do ( (     if (ret[j+1]) then     ret[j+1] := false ; else skip )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  boolean dp[];
  Main(){
    dp=new boolean[10001];
    Arrays.fill(dp,true);
    dp[0]=false ;
    dp[1]=false ;
    for(int i=2 ; i<100 ; i++){
      if(dp[i]){
        for(int j=i+i ; j<10001 ; j=j+i){
          dp[j]=false ;
        }
      }
    }
  }
  void run(){
    for(; sc.hasNextInt(); ){
      int n=sc.nextInt();
      int ans=0 ;
      for(int i=1 ; i<n ; i++){
        if(dp[i]){
          if(dp[n-i+1]){
            ans++;
          }
        }
      }
      System.out.println(ans);
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute dp : Sequence(boolean);
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     dp := Integer.subrange(1,10001)->collect(false) ; 
     dp := dp->collect(true) ; 
    dp[0+1] := false ; 
    dp[1+1] := false ; 
        var i : int ; i := 2 ; while i < 100 do ( (     if (dp[i+1]) then (         var j : int ; j := i + i ; while j < 10001 do ( (     dp[j+1] := false )  ;     j := j + i ) ) else skip )  ;     i := i + 1 ) ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNextInt() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     if (dp[i+1]) then (     if (dp[n - i + 1+1]) then (     ans := ans + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static HashSet<Integer>hs=new HashSet<>();
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int count=0 ;
      int n=in.nextInt();
      int a[]=new int[n];
      int b[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=i+1 ;
        b[i]=n-i ;
      }
      sieveOfEratosthenes(n);
      for(int i=0 ; i<n ; i++)if(hs.contains(a[i])&& hs.contains(b[i]))count++;
      System.out.println(count);
    }
  }
  static void sieveOfEratosthenes(int n){
    long prime[]=new long[n+1];
    for(int p=2 ; p*p<=n ; p++)if(prime[p]==0)for(int i=p*2 ; i<=n ; i+=p)prime[i]=1 ;
    for(int i=2 ; i<=n ; i++)if(prime[i]==0)hs.add(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute hs : Set(int) := Set{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var count : int ; count := 0 ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := i + 1 ; 
     b[i+1] := n - i )  ;     i := i + 1 ) ; 
    execute sieveOfEratosthenes(n) ; 
        var i : int ; i := 0 ; while i < n do (     if (hs->includes(a[i+1]) & hs->includes(b[i+1])) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
  static   operation sieveOfEratosthenes( n : int) : void
  pre: true
  post: true
  activity: (     var prime : Sequence(long) ; prime := Integer.subrange(1,n + 1)->collect(0) ;
         var p : int ; p := 2 ; while p * p <= n do (     if (prime[p+1] = 0) then         var i : int ; i := p * 2 ; while i <= n do (     prime[i+1] := 1 ;  ;     i := i+(p) ) ; else skip ;  ;     p := p + 1 ) ; 
         var i : int ; i := 2 ; while i <= n do (     if (prime[i+1] = 0) then     hs := hs->including(i) ; else skip ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int findY(int x){
    if(x>2)return x-2 ;
    return x+2 ;
  }
  public static void main(String[] args){
    int x=5 ;
    System.out.println(findY(x));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findY( x : int) : int
  pre: true
  post: true
  activity: (     if (x > 2) then     return x - 2 else skip ; 
     return x + 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 5 ;
     OclFile["System.out"].println(findY(x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int M=30000 ;
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      Set<Integer>set=new HashSet<Integer>();
      int[][] p=new int[n][2];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<2 ; j++)p[i][j]=sc.nextInt()+10000 ;
        set.add(p[i][1]*M+p[i][0]);
      }
      int max=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=i+1 ; j<n ; j++){
          int dx=p[j][0]-p[i][0];
          int dy=p[j][1]-p[i][1];
          if(set.contains((p[i][1]+dx)*M+p[i][0]-dy)&& set.contains((p[j][1]+dx)*M+p[j][0]-dy)|| set.contains((p[i][1]-dx)*M+p[i][0]+dy)&& set.contains((p[j][1]-dx)*M+p[j][0]+dy)){
            max=Math.max(max,dx*dx+dy*dy);
          }
        }
      }
      System.out.println(max);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var M : int ; M := 30000 ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var set : Set(int) ; set := Set{} ;
    var p : Sequence(Sequence(int)) ; p := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 2 do (     p[i+1][j+1] := sc.getCurrent()->toInteger() + 10000 ;  ;     j := j + 1 ) ; 
     set := set->including(p[i+1][1+1] * M + p[i+1][0+1]) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var dx : int ; dx := p[j+1][0+1] - p[i+1][0+1] ;
     var dy : int ; dy := p[j+1][1+1] - p[i+1][1+1] ;
     if (set->includes((p[i+1][1+1] + dx) * M + p[i+1][0+1] - dy) & set->includes((p[j+1][1+1] + dx) * M + p[j+1][0+1] - dy) or set->includes((p[i+1][1+1] - dx) * M + p[i+1][0+1] + dy) & set->includes((p[j+1][1+1] - dx) * M + p[j+1][0+1] + dy)) then (     max := Set{max, dx * dx + dy * dy}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      int n=in.nextInt();
      if(n==0)return ;
      Point p[]=new Point[n];
      boolean exist[][]=new boolean[5001][5001];
      int max=0 ;
      for(int i=0 ; i<n ; i++){
        int x=in.nextInt(),y=in.nextInt();
        p[i]=new Point(x,y);
        exist[x][y]=true ;
      }
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++){
        if(i==j)continue ;
        int x1=p[i] .x,y1=p[i] .y ;
        int x2=p[j] .x,y2=p[j] .y ;
        if(x2-y2+y1>=0 && y2+x2-x1>=0 && x1+y1-y2>=0 && y1+x2-x1>=0)if(x2-y2+y1<=5000 && y2+x2-x1<=5000 && x1+y1-y2<=5000 && y1+x2-x1<=5000)if(exist[x2-y2+y1][y2+x2-x1] && exist[x1+y1-y2][y1+x2-x1])max=Math.max(max,(x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
      }
      System.out.println(max);
    }
  }
  static public void debug(Object...o){
    System.err.println(Arrays.deepToString(o));
  }
}
class Point {
  int x ;
  int y ;
  Point(int x,int y){
    this.x=x ;
    this.y=y ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var p : Sequence(Point) ; p := Integer.subrange(1,n)->collect(null) ;
    var exist : Sequence(Sequence(boolean)) ; exist := Integer.subrange(1,5001)->collect(Integer.subrange(1,5001)->collect(false)) ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
    var y : int ; y := in.getCurrent()->toInteger() ;
     p[i+1] := Point.newPoint(x, y) ; 
     exist[x+1][y+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do ( (     if (i = j) then     continue else skip ; 
     var x1 : int ; x1 := p[i+1].x ;
    var y1 : int ; y1 := p[i+1].y ;
     var x2 : int ; x2 := p[j+1].x ;
    var y2 : int ; y2 := p[j+1].y ;
     if (x2 - y2 + y1 >= 0 & y2 + x2 - x1 >= 0 & x1 + y1 - y2 >= 0 & y1 + x2 - x1 >= 0) then     if (x2 - y2 + y1 <= 5000 & y2 + x2 - x1 <= 5000 & x1 + y1 - y2 <= 5000 & y1 + x2 - x1 <= 5000) then     if (exist[x2 - y2 + y1+1][y2 + x2 - x1+1] & exist[x1 + y1 - y2+1][y1 + x2 - x1+1]) then     max := Set{max, (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)}->max() ; else skip ; else skip ; else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 )  ) );
  static    operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((o + "")) );
}
class Point {
   attribute x : int;
   attribute y : int;
   static operation newPoint( x : int, y : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static final int MAX=5000 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    boolean[][] is_point=new boolean[MAX+1][MAX+1];
    int[] x_pos=new int[3001];
    int[] y_pos=new int[3001];
    while(true){
      final int n=sc.nextInt();
      if(n==0){
        break ;
      }
      for(int i=0 ; i<=MAX ; i++){
        Arrays.fill(is_point[i],false);
      }
      for(int i=0 ; i<n ; i++){
        final int x=sc.nextInt();
        final int y=sc.nextInt();
        is_point[y][x]=true ;
        x_pos[i]=x ;
        y_pos[i]=y ;
      }
      int max_size=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=i+1 ; j<n ; j++){
          final int x1=x_pos[i];
          final int y1=y_pos[i];
          final int x2=x_pos[j];
          final int y2=y_pos[j];
          int diff_x=x2-x1 ;
          int diff_y=y2-y1 ;
          int pt_1_x=x1+diff_y ;
          int pt_1_y=y1-diff_x ;
          if(pt_1_x<0 || pt_1_x>MAX || pt_1_y<0 || pt_1_y>MAX){
            continue ;
          }
          else if(! is_point[pt_1_y][pt_1_x]){
            continue ;
          }
          int pt_2_x=pt_1_x+diff_x ;
          int pt_2_y=pt_1_y+diff_y ;
          if(pt_2_x<0 || pt_2_x>MAX || pt_2_y<0 || pt_2_y>MAX){
            continue ;
          }
          else if(! is_point[pt_2_y][pt_2_x]){
            continue ;
          }
          max_size=Math.max(max_size,diff_x*diff_x+diff_y*diff_y);
        }
      }
      System.out.println(max_size);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 5000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var is_point : Sequence(Sequence(boolean)) ; is_point := Integer.subrange(1,MAX + 1)->collect(Integer.subrange(1,MAX + 1)->collect(false)) ;
    var x_pos : Sequence(int) ; x_pos := Integer.subrange(1,3001)->collect(0) ;
    var y_pos : Sequence(int) ; y_pos := Integer.subrange(1,3001)->collect(0) ;
    while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
        var i : int ; i := 0 ; while i <= MAX do ( (     is_point[i+1] := is_point[i+1]->collect(false) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    is_point[y+1][x+1] := true ; 
    x_pos[i+1] := x ; 
    y_pos[i+1] := y ; 
 )  ;     i := i + 1 ) ; 
    var max_size : int ; max_size := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_x < 0 or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_x > MAX or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_y < 0 or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_y > MAX) then (     continue ) else     if (not(is_point[pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_y+1][pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ;_x < 0 or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_x < 0 or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_x > MAX or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_y < 0 or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_y > MAX) then (     continue ) else     if (not(is_point[pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_y+1][pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ;_x > MAX or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_x < 0 or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_x > MAX or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_y < 0 or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_y > MAX) then (     continue ) else     if (not(is_point[pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_y+1][pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ;_y < 0 or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_x < 0 or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_x > MAX or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_y < 0 or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_y > MAX) then (     continue ) else     if (not(is_point[pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_y+1][pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ;_y > MAX) then (     continue ) else     if (not(is_point[pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_x < 0 or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_x > MAX or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_y < 0 or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_y > MAX) then (     continue ) else     if (not(is_point[pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_y+1][pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ;_y+1][pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_x < 0 or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_x > MAX or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_y < 0 or pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_y > MAX) then (     continue ) else     if (not(is_point[pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_y+1][pt        var j : int ; j := i + 1 ; while j < n do ( (     var x1 : int ; x1 := x_pos[i+1] ;
     var y1 : int ; y1 := y_pos[i+1] ;
    var x2 : int ; x2 := x_pos[j+1] ;
    var y2 : int ; y2 := y_pos[j+1] ;
    var diff_x : int ; diff_x := x2 - x1 ;
    var diff_y : int ; diff_y := y2 - y1 ;
    var pt    var ptint_x : int ; ptint_x := x1 + diff_y_x : int ; pt    var ptint_x : int ; ptint_x := x1 + diff_y_x := x1 + diff_y ;
    var pt    var ptint_y : int ; ptint_y := y1 - diff_x_y : int ; pt    var ptint_y : int ; ptint_y := y1 - diff_x_y := y1 - diff_x ;
    if (pt_1_x < 0 or pt_1_x > MAX or pt_1_y < 0 or pt_1_y > MAX) then (     continue ) else     if (not(is_point[pt_1_y+1][pt_1_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ; 
_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) ;_x+1])) then (     continue ) else skip ; ;  
    var ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x : int ; ptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x := ptptptptpt    var ptptint_x + diff_x_x : int ; ptptint_x + diff_x_x := ptptptptptint_x + diff_x_x_x + diff_x_x_x + diff_x_x + diff_x_x_x + diff_x_x_x + diff_x ;
    var ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y : int ; ptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y := ptptptptpt    var ptptint_y + diff_y_y : int ; ptptint_y + diff_y_y := ptptptptptint_y + diff_y_y_y + diff_y_y_y + diff_y_y + diff_y_y_y + diff_y_y_y + diff_y ;
    if (pt0_x < 0 or ptMAX_x > MAX or pt0_y < 0 or ptMAX_y > MAX) then (     continue ) else     if (not(is_point[ptpt(     continue )_x_y+1][pt(     continue )_x+1])) then (     continue ) else skip ; ;  
    max_size := Set{max_size, diff_x * diff_x + diff_y * diff_y}->max() ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max_size) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      int[] x=new int[n];
      int[] y=new int[n];
      boolean[][] p=new boolean[5001][5001];
      for(int i=0 ; i<n ; i++){
        int a=sc.nextInt();
        int b=sc.nextInt();
        x[i]=a ;
        y[i]=b ;
        p[a][b]=true ;
      }
      int ans=0 ;
      for(int i=0 ; i<n-1 ; i++){
        for(int j=i+1 ; j<n ; j++){
          int vx=x[j]-x[i];
          int vy=y[j]-y[i];
          int dist=vx*vx+vy*vy ;
          if(dist<ans){
            continue ;
          }
          if((check(p,x[i]+vy,y[i]-vx)&& check(p,x[j]+vy,y[j]-vx))||(check(p,x[i]-vy,y[i]+vx)&& check(p,x[j]-vy,y[j]+vx))){
            ans=dist ;
          }
        }
      }
      System.out.println(ans);
    }
  }
  private static boolean check(boolean[][] p,int x,int y){
    if(x>=0 && x<=5000 && y>=0 && y<=5000){
      return p[x][y];
    }
    else {
      return false ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
    var p : Sequence(Sequence(boolean)) ; p := Integer.subrange(1,5001)->collect(Integer.subrange(1,5001)->collect(false)) ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    x[i+1] := a ; 
    y[i+1] := b ; 
    p[a+1][b+1] := true ; 
 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var vx : int ; vx := x[j+1] - x[i+1] ;
     var vy : int ; vy := y[j+1] - y[i+1] ;
    var dist : int ; dist := vx * vx + vy * vy ;
    if (dist < ans) then (     continue ) else skip ; 
    if ((check(p, x[i+1] + vy, y[i+1] - vx) & check(p, x[j+1] + vy, y[j+1] - vx)) or (check(p, x[i+1] - vy, y[i+1] + vx) & check(p, x[j+1] - vy, y[j+1] + vx))) then (     ans := dist ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation check( p : Sequence(Sequence(boolean)), x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     if (x >= 0 & x <= 5000 & y >= 0 & y <= 5000) then (     return p[x+1][y+1] ) else (     return false ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] x=new int[n];
      int[] y=new int[n];
      boolean[][] map=new boolean[5001][5001];
      for(int i=0 ; i<n ; i++){
        x[i]=sc.nextInt();
        y[i]=sc.nextInt();
        map[y[i] ][x[i] ]=true ;
      }
      int max=0 ;
      int p,q,a,b,c,d ;
      for(int i=0 ; i<n ; i++){
        for(int j=i+1 ; j<n ; j++){
          p=x[i]-x[j];
          q=y[i]-y[j];
          a=y[i]+p ;
          b=x[i]-q ;
          c=y[j]+p ;
          d=x[j]-q ;
          for(int k=0 ; k<2 ; k++){
            if(0<=a && a<=5000 && 0<=b && b<=5000 && 0<=c && c<=5000 && 0<=d && d<=5000){
              if(map[a][b]==true && map[c][d]==true){
                max=Math.max(max,p*p+q*q);
                break ;
              }
            }
            a-=2*p ;
            b+=2*q ;
            c-=2*p ;
            d+=2*q ;
          }
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
    var map : Sequence(Sequence(boolean)) ; map := Integer.subrange(1,5001)->collect(Integer.subrange(1,5001)->collect(false)) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     y[i+1] := sc.getCurrent()->toInteger() ; 
     map[y[i+1]+1][x[i+1]+1] := true )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var p : int ;
    var q : int ;
    var a : int ;
    var b : int ;
    var c : int ;
    var d : int ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     p := x[i+1] - x[j+1] ; 
     q := y[i+1] - y[j+1] ; 
    a := y[i+1] + p ; 
    b := x[i+1] - q ; 
    c := y[j+1] + p ; 
    d := x[j+1] - q ; 
        var k : int ; k := 0 ; while k < 2 do ( (     if (0 <= a & a <= 5000 & 0 <= b & b <= 5000 & 0 <= c & c <= 5000 & 0 <= d & d <= 5000) then (     if (map[a+1][b+1] = true & map[c+1][d+1] = true) then (     max := Set{max, p * p + q * q}->max() ; 
     break ) else skip ) else skip ; 
     a := a-(2 * p) ; 
    b := b+(2 * q) ; 
    c := c-(2 * p) ; 
    d := d+(2 * q) ; 
 )  ;     k := k + 1 ) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class LychrelNumberTest {
  private static int MAX_ITERATIONS=20 ;
  private static boolean isLychrel(long number){
    for(int i=0 ; i<MAX_ITERATIONS ; i++){
      number=number+reverse(number);
      if(isPalindrome(number))return false ;
    }
    return true ;
  }
  private static boolean isPalindrome(final long number){
    return number==reverse(number);
  }
  private static long reverse(long number){
    long reverse=0 ;
    while(number>0){
      long remainder=number % 10 ;
      reverse=(reverse*10)+remainder ;
      number=number/10 ;
    }
    return reverse ;
  }
  public static void main(String[] args){
    long number=295 ;
    System.out.println(number+" is lychrel? "+isLychrel(number));
  }
}
------------------------------------------------------------
OCL File:
---------
 class LychrelNumberTest {
  static   attribute MAX_ITERATIONS : int := 20;
  static   operation isLychrel( number : long) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < MAX_ITERATIONS do ( (     number := number + reverse(number) ; 
     if (isPalindrome(number)) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation isPalindrome( number : long) : boolean
  pre: true
  post: true
  activity: (     return number = reverse(number) );
  static   operation reverse( number : long) : long
  pre: true
  post: true
  activity: (     var reverse : long ; reverse := 0 ;
     while (number > 0) do (     var remainder : long ; remainder := number mod 10 ;
     reverse := (reverse * 10) + remainder ; 
     number := number / 10 ) ; 
     return reverse );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var number : long ; number := 295 ;
     OclFile["System.out"].println(number + " is lychrel? " + isLychrel(number)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printDiamond(int n){
    int space=n-1 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<space ; j++)System.out.print(" ");
      for(int j=0 ; j<=i ; j++)System.out.print("*");
      System.out.print("\n");
      space--;
    }
    space=0 ;
    for(int i=n ; i>0 ; i--){
      for(int j=0 ; j<space ; j++)System.out.print(" ");
      for(int j=0 ; j<i ; j++)System.out.print("*");
      System.out.print("\n");
      space++;
    }
  }
  public static void main(String[] args){
    printDiamond(5);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printDiamond( n : int) : void
  pre: true
  post: true
  activity: (     var space : int ; space := n - 1 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < space do (     OclFile["System.out"].print(" ") ;  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j <= i do (     OclFile["System.out"].print("*") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].print("\n") ; 
     space := space - 1 )  ;     i := i + 1 ) ; 
     space := 0 ; 
         var i : int ; i := n ; while i > 0 do ( (         var j : int ; j := 0 ; while j < space do (     OclFile["System.out"].print(" ") ;  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < i do (     OclFile["System.out"].print("*") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].print("\n") ; 
     space := space + 1 )  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute printDiamond(5) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    String str=s.nextLine();
    int max=0 ;
    boolean containsDiff=false ;
    for(int i=0 ; i+1<str.length(); i++){
      if(str.charAt(i)!=str.charAt(i+1)){
        containsDiff=true ;
        break ;
      }
    }
    if(! containsDiff){
      System.out.println(max);
      return ;
    }
    int start=0,end=str.length()-1 ;
    boolean isPali=true ;
    while(start<=end){
      if(str.charAt(start)!=str.charAt(end)){
        isPali=false ;
        break ;
      }
      start++;
      end--;
    }
    System.out.println(isPali ? str.length()-1 : str.length());
  }
  public static boolean isPalindrome(String str){
    int start=0,end=str.length()-1 ;
    while(start<=end){
      if(str.charAt(start)!=str.charAt(end))return false ;
      start+=1 ;
      end--;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := s.nextLine() ;
    var max : int ; max := 0 ;
    var containsDiff : boolean ; containsDiff := false ;
        var i : int ; i := 0 ; while i + 1 < str->size() do ( (     if (str->at(i+1) /= str->at(i + 1+1)) then (     containsDiff := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (not(containsDiff)) then (     OclFile["System.out"].println(max) ; 
     return ) else skip ; 
    var start : int ; start := 0 ;
    var end : int ; end := str->size() - 1 ;
    var isPali : boolean ; isPali := true ;
    while (start <= end) do (     if (str->at(start+1) /= str->at(end+1)) then (     isPali := false ; 
     break ) else skip ; 
     start := start + 1 ; 
     end := end - 1 ) ; 
    OclFile["System.out"].println(if isPali then str->size() - 1 else str->size() endif) ; 
 );
  static   operation isPalindrome( str : String) : boolean
  pre: true
  post: true
  activity: (     var start : int ; start := 0 ;
    var end : int ; end := str->size() - 1 ;
     while (start <= end) do (     if (str->at(start+1) /= str->at(end+1)) then     return false else skip ; 
     start := start+(1) ; 
     end := end - 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minCost(int[][] graph,int n){
    int cost1=0,cost2=0 ;
    boolean[] start=new boolean[n+1];
    boolean[] end=new boolean[n+1];
    for(int i=0 ; i<n ; i++){
      int a=graph[i][0];
      int b=graph[i][1];
      int c=graph[i][2];
      if(start[a] || end[b]){
        cost2+=c ;
        start[b]=true ;
        end[a]=true ;
      }
      else {
        cost1+=c ;
        start[a]=true ;
        end[b]=true ;
      }
    }
    return Math.min(cost1,cost2);
  }
  public static void main(String[] args){
    int n=5 ;
    int[][] graph={
      {
        1,2,7 },{
          5,1,8 },{
            5,4,5 },{
              3,4,1 },{
                3,2,10 }
              };
              int ans=minCost(graph,n);
              System.out.println(ans);
            }
          }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minCost( graph : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     var cost1 : int ; cost1 := 0 ;
    var cost2 : int ; cost2 := 0 ;
     var start : Sequence(boolean) ; start := Integer.subrange(1,n + 1)->collect(false) ;
    var end : Sequence(boolean) ; end := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := graph[i+1][0+1] ;
     var b : int ; b := graph[i+1][1+1] ;
     var c : int ; c := graph[i+1][2+1] ;
     if (start[a+1] or end[b+1]) then (     cost2 := cost2+(c) ; 
     start[b+1] := true ; 
     end[a+1] := true ) else (     cost1 := cost1+(c) ; 
     start[a+1] := true ; 
     end[b+1] := true ) )  ;     i := i + 1 ) ; 
    return Set{cost1, cost2}->min() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var graph : Sequence(Sequence(int)) ; graph := Sequence{Sequence{1,2,7},Sequence{5,1,8},Sequence{5,4,5},Sequence{3,4,1},Sequence{3,2,10}} ;
     var ans : int ; ans := minCost(graph, n) ;
     OclFile["System.out"].println(ans) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static StreamTokenizer in ;
  static int next()throws Exception {
    in.nextToken();
    return(int)in.nval ;
  }
  static PrintWriter out ;
  static String NAME="a" ;
  public static void main(String[] args)throws Exception {
    out=new PrintWriter(new File(NAME+".out"));
    in=new StreamTokenizer(new BufferedReader(new FileReader(new File(NAME+".in"))));
    int tests=next();
    for(int test=1 ; test<=tests ; test++){
      int x=next();
      int s=next();
      int r=next();
      double t=next();
      int n=next();
      int m=101 ;
      int[] l=new int[m];
      l[0]=x ;
      for(int i=0 ; i<n ; i++){
        int b=next();
        int e=next();
        l[next()]+=e-b ;
        l[0]-=e-b ;
      }
      double answ=0 ;
      for(int i=0 ; i<m ; i++){
        double tt=Math.min(t,(double)l[i]/(i+r));
        t-=tt ;
        answ-=tt*(r-s)/(i+s);
      }
      for(int i=0 ; i<m ; i++)answ+=(double)l[i]/(i+s);
      out.println("Case #"+test+": "+answ);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : StreamTokenizer;
  static   operation next() : int
  pre: true
  post: true
  activity: (     in.next() ; 
     return in.nval->oclAsType(int) );
  static   attribute out : OclFile;
  static   attribute NAME : String := "a";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     out := OclFile.newOclFile_Write(OclFile(NAME + ".out")) ; 
     in := StreamTokenizer.newStreamTokenizer(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(NAME + ".in")))) ; 
    var tests : int ; tests := next() ;
        var test : int ; test := 1 ; while test <= tests do ( (     var x : int ; x := next() ;
     var s : int ; s := next() ;
    var r : int ; r := next() ;
    var t : double ; t := next() ;
    var n : int ; n := next() ;
    var m : int ; m := 101 ;
    var l : Sequence(int) ; l := Integer.subrange(1,m)->collect(0) ;
    l[0+1] := x ; 
        var i : int ; i := 0 ; while i < n do ( (     var b : int ; b := next() ;
     var e : int ; e := next() ;
     l[next()+1] := l[next()+1]+(e - b) ; 
     l[0+1] := l[0+1]-(e - b) )  ;     i := i + 1 ) ; 
    var answ : double ; answ := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var tt : double ; tt := Set{t, l[i+1]->oclAsType(double) / (i + r)}->min() ;
     t := t-(tt) ; 
     answ := answ-(tt * (r - s) / (i + s)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     answ := answ+(l[i+1]->oclAsType(double) / (i + s)) ;  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     test := test + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MOD=1000000007 ;
  static int modFact(int n,int m){
    int result=1 ;
    for(int i=1 ; i<=m ; i++)result=(result*i)% MOD ;
    return result ;
  }
  public static void main(String[] args){
    int n=3,m=2 ;
    System.out.println(modFact(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MOD : int := 1000000007;
  static   operation modFact( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 1 ;
         var i : int ; i := 1 ; while i <= m do (     result := (result * i) mod MOD ;  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
    var m : int ; m := 2 ;
     OclFile["System.out"].println(modFact(n, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int zz=1 ; zz<=T ; zz++){
      int X=in.nextInt();
      int S=in.nextInt();
      int R=in.nextInt();
      int t=in.nextInt();
      int N=in.nextInt();
      int[] length=new int[1000];
      int total=X ;
      for(int i=0 ; i<N ; i++){
        int begin=in.nextInt();
        int end=in.nextInt();
        int speed=in.nextInt();
        length[speed+S]+=end-begin ;
        total-=end-begin ;
      }
      length[S]+=total ;
      double left=t ;
      double ans=0 ;
      for(int i=0 ; i<length.length ; i++){
        double v=i ;
        double nv=v+(R-S);
        double len=length[i];
        if(len/nv<=left){
          left-=len/nv ;
          ans+=len/nv ;
        }
        else {
          ans+=(len-(R-S)*left)/v ;
          left=0 ;
        }
      }
      System.out.format("Case #%d: %.09f\n",zz,ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var zz : int ; zz := 1 ; while zz <= T do ( (     var X : int ; X := in.getCurrent()->toInteger() ;
     var S : int ; S := in.getCurrent()->toInteger() ;
    var R : int ; R := in.getCurrent()->toInteger() ;
    var t : int ; t := in.getCurrent()->toInteger() ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var length : Sequence(int) ; length := Integer.subrange(1,1000)->collect(0) ;
    var total : int ; total := X ;
        var i : int ; i := 0 ; while i < N do ( (     var begin : int ; begin := in.getCurrent()->toInteger() ;
     var end : int ; end := in.getCurrent()->toInteger() ;
    var speed : int ; speed := in.getCurrent()->toInteger() ;
    length[speed + S+1] := length[speed + S+1]+(end - begin) ; 
    total := total-(end - begin) ; 
 )  ;     i := i + 1 ) ; 
    length[S+1] := length[S+1]+(total) ; 
    var left : double ; left := t ;
    var ans : double ; ans := 0 ;
        var i : int ; i := 0 ; while i < length->size() do ( (     var v : double ; v := i ;
     var nv : double ; nv := v + (R - S) ;
     var len : double ; len := length[i+1] ;
     if (len / nv <= left) then (     left := left-(len / nv) ; 
     ans := ans+(len / nv) ) else (     ans := ans+((len - (R - S) * left) / v) ; 
     left := 0 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].format("Case #%d: %.09f\n", zz, ans) ; 
 )  ;     zz := zz + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  class Road implements Comparable<Road>{
    int add ;
    int len ;
    public Road(int len,int add){
      this.len=len ;
      this.add=add ;
    }
    public int compareTo(Road other){
      return this.add-other.add ;
    }
  }
  public void go()throws Exception {
    Scanner sc=new Scanner(new FileReader("input.txt"));
    PrintWriter pw=new PrintWriter(new FileWriter("output.txt"));
    int caseCnt=sc.nextInt();
    for(int caseNum=1 ; caseNum<=caseCnt ; caseNum++){
      int X=sc.nextInt();
      int S=sc.nextInt();
      int R=sc.nextInt();
      double t=sc.nextInt();
      int N=sc.nextInt();
      Road[] r=new Road[N+1];
      for(int i=0 ; i<N ; i++){
        int B=sc.nextInt();
        int E=sc.nextInt();
        int w=sc.nextInt();
        r[i]=new Road(E-B,w);
        X-=r[i] .len ;
      }
      r[N]=new Road(X,0);
      Arrays.sort(r);
      double res=0.0 ;
      for(int i=0 ; i<r.length ; i++){
        double need=r[i] .len/(double)(R+r[i] .add);
        if(need<t){
          t-=need ;
          res+=need ;
        }
        else {
          double dist=r[i] .len-(R+r[i] .add)*t ;
          res+=t ;
          t=0 ;
          res+=dist/(double)(S+r[i] .add);
        }
      }
      pw.println("Case #"+caseNum+": "+res);
    }
    pw.flush();
    pw.close();
    sc.close();
  }
  public static void main(String[] args)throws Exception {
(new Solution()).go();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
 class Road implements Comparable<Road> {
   attribute add : int;
   attribute len : int;
   static operation newRoad( len : int, add : int) : Road
  pre: true
  post: true
  activity:
  ( var self : Road ;
    self := createRoad();
    self.initialise(len, add);
    return self );
  operation initialise( len : int, add : int) : void
  pre: true  post: true
  activity: (     self.len := len ; 
     self.add := add );
   operation compareTo( other : Road) : int
  pre: true
  post: true
  activity: (     return self.add - other.add );
}
   operation go() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt"))) ;
    var caseCnt : int ; caseCnt := sc.getCurrent()->toInteger() ;
        var caseNum : int ; caseNum := 1 ; while caseNum <= caseCnt do ( (     var X : int ; X := sc.getCurrent()->toInteger() ;
     var S : int ; S := sc.getCurrent()->toInteger() ;
    var R : int ; R := sc.getCurrent()->toInteger() ;
    var t : double ; t := sc.getCurrent()->toInteger() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var r : Sequence(Road) ; r := Integer.subrange(1,N + 1)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     var B : int ; B := sc.getCurrent()->toInteger() ;
     var E : int ; E := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    r[i+1] := Road.newRoad(E - B, w) ; 
    X := X-(r[i+1].len) ; 
 )  ;     i := i + 1 ) ; 
    r[N+1] := Road.newRoad(X, 0) ; 
    r := r->sort() ; 
    var res : double ; res := 0.0 ;
        var i : int ; i := 0 ; while i < r->size() do ( (     var need : double ; need := r[i+1].len / (R + r[i+1].add)->oclAsType(double) ;
     if (need < t) then (     t := t-(need) ; 
     res := res+(need) ) else (     var dist : double ; dist := r[i+1].len - (R + r[i+1].add) * t ;
     res := res+(t) ; 
     t := 0 ; 
     res := res+(dist / (S + r[i+1].add)->oclAsType(double)) ) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     caseNum := caseNum + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Solution.newSolution()).go() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
import java.text.*;
public class a {
  private static class W implements Comparable<W>{
    public int l ;
    public int w ;
    public W(int l,int w){
      this.l=l ;
      this.w=w ;
    }
    public int compareTo(W o){
      return w-o.w ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(new BufferedInputStream(System.in));
    int T=sc.nextInt();
    for(int c=1 ; c<=T ; ++c){
      int x=sc.nextInt();
      double s=sc.nextInt();
      double r=sc.nextInt();
      int t=sc.nextInt();
      int n=sc.nextInt();
      W[] ws=new W[n+1];
      int sum=0 ;
      for(int i=0 ; i<n ; ++i){
        int b=sc.nextInt();
        int e=sc.nextInt();
        int w=sc.nextInt();
        ws[i]=new W(e-b,w);
        sum+=e-b ;
      }
      ws[n]=new W(x-sum,0);
      Arrays.sort(ws);
      double time=0 ;
      double remaining_running=t ;
      for(int i=0 ; i<=n ; ++i){
        W w=ws[i];
        if(remaining_running>0){
          double tt=w.l/(w.w+r);
          if(tt<remaining_running){
            remaining_running-=tt ;
            time+=tt ;
          }
          else {
            time+=remaining_running ;
            time+=(w.l-(w.w+r)*remaining_running)/(w.w+s);
            remaining_running=0 ;
          }
        }
        else {
          time+=w.l/(w.w+s);
        }
      }
      System.out.format("Case #%d: %.6f%n",c,time);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class a {
  static class W implements Comparable<W> {
   attribute l : int;
   attribute w : int;
   static operation newW( l : int, w : int) : W
  pre: true
  post: true
  activity:
  ( var self : W ;
    self := createW();
    self.initialise(l, w);
    return self );
  operation initialise( l : int, w : int) : void
  pre: true  post: true
  activity: (     self.l := l ; 
     self.w := w );
   operation compareTo( o : W) : int
  pre: true
  post: true
  activity: (     return w - o.w );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var c : int ; c := 1 ; while c <= T do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var s : double ; s := sc.getCurrent()->toInteger() ;
    var r : double ; r := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var ws : Sequence(W) ; ws := Integer.subrange(1,n + 1)->collect(null) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var b : int ; b := sc.getCurrent()->toInteger() ;
     var e : int ; e := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    ws[i+1] := W.newW(e - b, w) ; 
    sum := sum+(e - b) ; 
 )  ;     i := i + 1 ) ; 
    ws[n+1] := W.newW(x - sum, 0) ; 
    ws := ws->sort() ; 
    var time : double ; time := 0 ;
    var remaining_running : double ; remaining_running := t ;
        var i : int ; i := 0 ; while i <= n do ( (     var w : W ; w := ws[i+1] ;
     if (remaining_running > 0) then (     var tt : double ; tt := w.l / (w.w + r) ;
     if (tt < remaining_running) then (     remaining_running := remaining_running-(tt) ; 
     time := time+(tt) ) else (     time := time+(remaining_running) ; 
     time := time+((w.l - (w.w + r) * remaining_running) / (w.w + s)) ; 
     remaining_running := 0 ) ) else (     time := time+(w.l / (w.w + s)) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].format("Case #%d: %.6f%n", c, time) ; 
 )  ;     c := c + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class GeeksforGeeks {
  public static void StarPattern(int height){
    for(int i=0 ; i<height ; i++){
      for(int j=height-1 ; j>i ; j--){
        System.out.print("*");
      }
      boolean printChar=false ;
      for(int j=0 ; j<((i*2)+1); j++){
        if(printChar){
          System.out.print("*");
        }
        else {
          System.out.print(i+1);
        }
        printChar=! printChar ;
      }
      for(int j=height-1 ; j>i ; j--){
        System.out.print("*");
      }
      System.out.println();
    }
  }
  public static void main(String args[]){
    int height=7 ;
    StarPattern(height);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GeeksforGeeks {
  static   operation StarPattern( height : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < height do ( (         var j : int ; j := height - 1 ; while j > i do ( (     OclFile["System.out"].print("*") )  ;     j := j - 1 ) ; 
     var printChar : boolean ; printChar := false ;
        var j : int ; j := 0 ; while j < ((i * 2) + 1) do ( (     if (printChar) then (     OclFile["System.out"].print("*") ) else (     OclFile["System.out"].print(i + 1) ) ;  
     printChar := not(printChar) )  ;     j := j + 1 ) ; 
        var j : int ; j := height - 1 ; while j > i do ( (     OclFile["System.out"].print("*") )  ;     j := j - 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var height : int ; height := 7 ;
     execute StarPattern(height) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isPresent(int arr[],int low,int high,int value){
    while(low<=high){
      int mid=(low+high)/2 ;
      if(arr[mid]==value)return true ;
      else if(arr[mid]>value)high=mid-1 ;
      else low=mid+1 ;
    }
    return false ;
  }
  static int countPairs(int arr1[],int arr2[],int m,int n,int x){
    int count=0 ;
    for(int i=0 ; i<m ; i++){
      int value=x-arr1[i];
      if(isPresent(arr2,0,n-1,value))count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int arr1[]={
      1,3,5,7 };
      int arr2[]={
        2,3,5,8 };
        int m=arr1.length ;
        int n=arr2.length ;
        int x=10 ;
        System.out.println("Count="+countPairs(arr1,arr2,m,n,x));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPresent( arr : Sequence(int), low : int, high : int, value : int) : boolean
  pre: true
  post: true
  activity: (     while (low <= high) do (     var mid : int ; mid := (low + high) / 2 ;
     if (arr[mid+1] = value) then     return true else     if (arr[mid+1] > value) then     high := mid - 1 else     low := mid + 1 ; ;  ) ; 
     return false );
  static   operation countPairs( arr1 : Sequence(int), arr2 : Sequence(int), m : int, n : int, x : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < m do ( (     var value : int ; value := x - arr1[i+1] ;
     if (isPresent(arr2, 0, n - 1, value)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{1,3,5,7} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{2,3,5,8} ;
    var m : int ; m := arr1->size() ;
    var n : int ; n := arr2->size() ;
    var x : int ; x := 10 ;
    OclFile["System.out"].println("Count=" + countPairs(arr1, arr2, m, n, x)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int M=3 ;
  static int N=2 ;
  static void getIndex(int n,int shuffle[][]){
    for(int i=0 ; i<3 ; i++){
      if(shuffle[i][0]==n)n=shuffle[i][1];
      else if(shuffle[i][1]==n)n=shuffle[i][0];
    }
    System.out.println(n);
  }
  public static void main(String[] args){
    int n=3 ;
    int shuffle[][]={
      {
        3,1 },{
          2,1 },{
            1,2 }
          };
          getIndex(n,shuffle);
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute M : int := 3;
  static   attribute N : int := 2;
  static   operation getIndex( n : int, shuffle : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 3 do ( (     if (shuffle[i+1][0+1] = n) then     n := shuffle[i+1][1+1] ; else     if (shuffle[i+1][1+1] = n) then     n := shuffle[i+1][0+1] ; else skip ; )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var shuffle : Sequence(Sequence(int)) ; shuffle := Sequence{Sequence{3,1},Sequence{2,1},Sequence{1,2}} ;
     execute getIndex(n, shuffle) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    String str=s.nextLine();
    int max=0 ;
    for(int i=0 ; i<str.length(); i++){
      for(int j=i ; j<=str.length(); j++){
        if(! isPalindrome(str.substring(i,j))){
          max=Math.max(max,j-i);
        }
      }
    }
    System.out.println(max);
  }
  public static boolean isPalindrome(String str){
    int start=0,end=str.length()-1 ;
    while(start<=end){
      if(str.charAt(start)!=str.charAt(end))return false ;
      start+=1 ;
      end--;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := s.nextLine() ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (         var j : int ; j := i ; while j <= str->size() do ( (     if (not(isPalindrome(str.subrange(i+1,j)))) then (     max := Set{max, j - i}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static   operation isPalindrome( str : String) : boolean
  pre: true
  post: true
  activity: (     var start : int ; start := 0 ;
    var end : int ; end := str->size() - 1 ;
     while (start <= end) do (     if (str->at(start+1) /= str->at(end+1)) then     return false else skip ; 
     start := start+(1) ; 
     end := end - 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int size=(1<<N);
    int[] S=new int[size];
    boolean[] spawned=new boolean[size];
    spawned[size-1]=true ;
    for(int i=0 ; i<size ; i++)S[i]=sc.nextInt();
    Arrays.sort(S);
    List<Integer>active=new ArrayList<>();
    active.add(S[size-1]);
    spawned[size-1]=true ;
    for(int i=0 ; i<N ; i++){
      active.sort(Collections.reverseOrder());
      List<Integer>activated=new ArrayList<>();
      int next=size-1 ;
      for(int slime : active){
        while(next>=0 &&(S[next]>=slime || spawned[next])){
          next--;
        }
        if(next<0){
          System.out.println("No");
          return ;
        }
        spawned[next]=true ;
        activated.add(S[next]);
      }
      active.addAll(activated);
    }
    System.out.println("Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var size : int ; size := ((1*(2->pow(N)))->oclAsType(long)) ;
    var S : Sequence(int) ; S := Integer.subrange(1,size)->collect(0) ;
    var spawned : Sequence(boolean) ; spawned := Integer.subrange(1,size)->collect(false) ;
    spawned[size - 1+1] := true ; 
        var i : int ; i := 0 ; while i < size do (     S[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    S := S->sort() ; 
    var active : Sequence(int) ; active := Sequence{} ;
    active := active->including(S[size - 1+1]) ; 
    spawned[size - 1+1] := true ; 
        var i : int ; i := 0 ; while i < N do ( (     active := active.sort(reverseOrder()) ; 
     var activated : Sequence(int) ; activated := Sequence{} ;
    var next : int ; next := size - 1 ;
    for (slime : active) do ( (     while (next >= 0 & (S[next+1] >= slime or spawned[next+1])) do (     next := next - 1 ) ; 
     if (next < 0) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
     spawned[next+1] := true ; 
     activated := activated->including(S[next+1]) )  ) ; 
    active := active->union(activated) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Yes") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner a=new Scanner(System.in);
    int n=a.nextInt();
    int A[]=new int[n];
    for(int i=0 ; i<n ; i++){
      A[i]=a.nextInt();
    }
    int minj ;
    int count=0 ;
    for(int i=0 ; i<=n-2 ; i++){
      minj=i ;
      int c=0 ;
      for(int j=i+1 ; j<=n-1 ; j++){
        if(A[j]<A[minj]){
          minj=j ;
          c=1 ;
        }
      }
      if(c==1){
        int x=A[i];
        A[i]=A[minj];
        A[minj]=x ;
        count++;
      }
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(A[i]);
      if(i<n-1){
        System.out.print(" ");
      }
    }
    System.out.println();
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : OclFile ; a := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := a.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := a.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var minj : int ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i <= n - 2 do ( (     minj := i ; 
     var c : int ; c := 0 ;
         var j : int ; j := i + 1 ; while j <= n - 1 do ( (     if (A[j+1] < A[minj+1]) then (     minj := j ; 
     c := 1 ) else skip )  ;     j := j + 1 ) ; 
     if (c = 1) then (     var x : int ; x := A[i+1] ;
     A[i+1] := A[minj+1] ; 
     A[minj+1] := x ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(A[i+1]) ; 
     if (i < n - 1) then (     OclFile["System.out"].print(" ") ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static final int maximum=1000 ;
  static int lcs(String X,String Y,int m,int n,int dp[][]){
    if(m==0 || n==0){
      return 0 ;
    }
    if(dp[m-1][n-1]!=-1){
      return dp[m-1][n-1];
    }
    if(X.charAt(m-1)==Y.charAt(n-1)){
      dp[m-1][n-1]=1+lcs(X,Y,m-1,n-1,dp);
      return dp[m-1][n-1];
    }
    else {
      dp[m-1][n-1]=Math.max(lcs(X,Y,m,n-1,dp),lcs(X,Y,m-1,n,dp));
      return dp[m-1][n-1];
    }
  }
  public static void main(String[] args){
    String X="AGGTAB" ;
    String Y="GXTXAYB" ;
    int m=X.length();
    int n=Y.length();
    int dp[][]=new int[m][maximum];
    for(int[] row : dp){
      Arrays.fill(row,-1);
    }
    System.out.println("Length of LCS: "+lcs(X,Y,m,n,dp));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute maximum : int := 1000;
  static   operation lcs( X : String, Y : String, m : int, n : int, dp : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     if (m = 0 or n = 0) then (     return 0 ) else skip ; 
     if (dp[m - 1+1][n - 1+1] /= -1) then (     return dp[m - 1+1][n - 1+1] ) else skip ; 
     if (X->at(m - 1+1) = Y->at(n - 1+1)) then (     dp[m - 1+1][n - 1+1] := 1 + lcs(X, Y, m - 1, n - 1, dp) ; 
     return dp[m - 1+1][n - 1+1] ) else (     dp[m - 1+1][n - 1+1] := Set{lcs(X, Y, m, n - 1, dp), lcs(X, Y, m - 1, n, dp)}->max() ; 
     return dp[m - 1+1][n - 1+1] ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : String ; X := "AGGTAB" ;
     var Y : String ; Y := "GXTXAYB" ;
    var m : int ; m := X->size() ;
    var n : int ; n := Y->size() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,m)->collect(Integer.subrange(1,maximum)->collect(0)) ;
    for (row : dp) do ( (     row := row->collect(-1) )  ) ; 
    OclFile["System.out"].println("Length of LCS: " + lcs(X, Y, m, n, dp)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.io.*;
class GFG {
  static int N=20 ;
  static int[] fact=new int[N];
  static void pre(){
    fact[0]=1 ;
    for(int i=1 ; i<N ; i++){
      fact[i]=i*fact[i-1];
    }
  }
  static int CountPermutation(int a[],int n){
    int ways=1 ;
    Arrays.sort(a);
    int size=1 ;
    for(int i=1 ; i<n ; i++){
      if(a[i]==a[i-1]){
        size++;
      }
      else {
        ways*=fact[size];
        size=1 ;
      }
    }
    ways*=fact[size];
    return ways ;
  }
  public static void main(String[] args){
    int a[]={
      1,2,4,4,2,4 };
      int n=a.length ;
      pre();
      System.out.println(CountPermutation(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 20;
  static   attribute fact : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static   operation pre() : void
  pre: true
  post: true
  activity: (     fact[0+1] := 1 ; 
         var i : int ; i := 1 ; while i < N do ( (     fact[i+1] := i * fact[i - 1+1] )  ;     i := i + 1 ) );
  static   operation CountPermutation( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ways : int ; ways := 1 ;
     a := a->sort() ; 
    var size : int ; size := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] = a[i - 1+1]) then (     size := size + 1 ) else (     ways := ways*(fact[size+1]) ; 
     size := 1 ) )  ;     i := i + 1 ) ; 
    ways := ways*(fact[size+1]) ; 
    return ways 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,4,4,2,4} ;
     var n : int ; n := a->size() ;
     execute pre() ; 
     OclFile["System.out"].println(CountPermutation(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  final int MAX=1000000 ;
  static int breakSum(int n){
    int dp[]=new int[n+1];
    dp[0]=0 ;
    dp[1]=1 ;
    for(int i=2 ; i<=n ; i++)dp[i]=Math.max(dp[i/2]+dp[i/3]+dp[i/4],i);
    return dp[n];
  }
  public static void main(String[] args){
    int n=24 ;
    System.out.println(breakSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
   attribute MAX : int := 1000000;
  static   operation breakSum( n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
     dp[0+1] := 0 ; 
    dp[1+1] := 1 ; 
        var i : int ; i := 2 ; while i <= n do (     dp[i+1] := Set{dp[i / 2+1] + dp[i / 3+1] + dp[i / 4+1], i}->max() ;  ;     i := i + 1 ) ; 
    return dp[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 24 ;
     OclFile["System.out"].println(breakSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long countPairs(int arr[],int n){
    int countZero=0 ;
    int countTwo=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==0)countZero++;
      else if(arr[i]==2)countTwo++;
    }
    long pair0=(countZero*(countZero-1))/2 ;
    long pair2=(countTwo*(countTwo-1))/2 ;
    return pair0+pair2 ;
  }
  public static void main(String[] args){
    int arr[]={
      2,0,3,2,0 };
      int n=arr.length ;
      System.out.println(countPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countPairs( arr : Sequence(int), n : int) : long
  pre: true
  post: true
  activity: (     var countZero : int ; countZero := 0 ;
     var countTwo : int ; countTwo := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 0) then     countZero := countZero + 1 ; else     if (arr[i+1] = 2) then     countTwo := countTwo + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    var pair0 : long ; pair0 := (countZero * (countZero - 1)) / 2 ;
    var pair2 : long ; pair2 := (countTwo * (countTwo - 1)) / 2 ;
    return pair0 + pair2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,0,3,2,0} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countPairs(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    line=br.readLine();
    int H,W ;
    H=parseInt(line.substring(0,line.indexOf(' ')));
    W=parseInt(line.substring(line.indexOf(' ')+1));
    int[][] forecast=new int[H][W];
    for(int i=0 ; i<H ; i++){
      line=br.readLine();
      for(int j=0 ; j<W ; j++){
        if(line.charAt(j)=='c'){
          forecast[i][j]=0 ;
        }
        else {
          if(j==0){
            forecast[i][j]=-1 ;
          }
          else {
            if(forecast[i][j-1]==-1){
              forecast[i][j]=-1 ;
            }
            else {
              forecast[i][j]=forecast[i][j-1]+1 ;
            }
          }
        }
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        if(j==0){
          sb.append(forecast[i][j]);
        }
        else {
          sb.append(" "+forecast[i][j]);
        }
      }
      sb.append("\n");
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    line := br.readLine() ; 
    var H : int ;
    var W : int ;
    H := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    W := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var forecast : Sequence(Sequence(int)) ; forecast := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var i : int ; i := 0 ; while i < H do ( (     line := br.readLine() ; 
         var j : int ; j := 0 ; while j < W do ( (     if (line->at(j+1) = 'c') then (     forecast[i+1][j+1] := 0 ) else (     if (j = 0) then (     forecast[i+1][j+1] := -1 ) else (     if (forecast[i+1][j - 1+1] = -1) then (     forecast[i+1][j+1] := -1 ) else (     forecast[i+1][j+1] := forecast[i+1][j - 1+1] + 1 ) ) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (j = 0) then (     sb := sb + StringLib.newString(forecast[i+1][j+1]) ) else (     sb := sb + StringLib.newString(" " + forecast[i+1][j+1]) ) )  ;     j := j + 1 ) ; 
     sb := sb + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int width ;
  int height ;
  void printData(int crowd[][]){
    for(int i=0 ; i<height ; i++){
      for(int j=0 ; j<width ; j++){
        if(j<width-1){
          System.out.print(crowd[j][i]+" ");
        }
        else {
          System.out.print(crowd[j][i]);
        }
      }
      System.out.println();
    }
  }
  void calcCrowd(int crowd[][]){
    for(int i=0 ; i<height ; i++){
      for(int j=0 ; j<width ; j++){
        for(int k=width-1 ; k>=0 ; k--){
          if(crowd[k][i]==0 && crowd[j][i]==-1 && k<j){
            crowd[j][i]=j-k ;
          }
        }
      }
    }
  }
  void doIt(){
    Scanner sc=new Scanner(System.in);
    this.height=sc.nextInt();
    this.width=sc.nextInt();
    String c[]=new String[height];
    int crowd[][]=new int[width][height];
    for(int i=0 ; i<height ; i++){
      c[i]=sc.next();
    }
    for(int i=0 ; i<height ; i++){
      for(int j=0 ; j<width ; j++){
        if(c[i] .charAt(j)=='c'){
          crowd[j][i]=0 ;
        }
        else {
          crowd[j][i]=-1 ;
        }
      }
    }
    calcCrowd(crowd);
    printData(crowd);
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute width : int;
   attribute height : int;
   operation printData( crowd : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < height do ( (         var j : int ; j := 0 ; while j < width do ( (     if (j < width - 1) then (     OclFile["System.out"].print(crowd[j+1][i+1] + " ") ) else (     OclFile["System.out"].print(crowd[j+1][i+1]) ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
   operation calcCrowd( crowd : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < height do ( (         var j : int ; j := 0 ; while j < width do ( (         var k : int ; k := width - 1 ; while k >= 0 do ( (     if (crowd[k+1][i+1] = 0 & crowd[j+1][i+1] = -1 & k < j) then (     crowd[j+1][i+1] := j - k ) else skip )  ;     k := k - 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     self.height := sc.getCurrent()->toInteger() ; 
    self.width := sc.getCurrent()->toInteger() ; 
    var c : Sequence(String) ; c := Integer.subrange(1,height)->collect(null) ;
    var crowd : Sequence(Sequence(int)) ; crowd := Integer.subrange(1,width)->collect(Integer.subrange(1,height)->collect(0)) ;
        var i : int ; i := 0 ; while i < height do ( (     c[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < height do ( (         var j : int ; j := 0 ; while j < width do ( (     if (c[i+1]->at(j+1) = 'c') then (     crowd[j+1][i+1] := 0 ) else (     crowd[j+1][i+1] := -1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    execute calcCrowd(crowd) ; 
    execute printData(crowd) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static int[][] Forec(int h,int w,char[][] wea){
    int cnt=-1 ;
    int forec[][]=new int[h][w];
    boolean flag ;
    for(int i=0 ; i<h ; i++){
      flag=false ;
      cnt=-1 ;
      for(int k=0 ; k<w ; k++){
        if(wea[i][k]=='c'){
          cnt=0 ;
          flag=true ;
        }
        else if(flag==true && wea[i][k]=='.')cnt++;
        else if(wea[i][k]=='.')cnt=-1 ;
        forec[i][k]=cnt ;
      }
    }
    return forec ;
  }
  void dolt(){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    char[][] str=new char[h][w];
    int[][] forec=new int[h][w];
    for(int i=0 ; i<h ; i++){
      str[i]=sc.next().toCharArray();
    }
    forec=Forec(h,w,str);
    for(int i=0 ; i<h ; i++){
      for(int k=0 ; k<w ; k++){
        System.out.print(forec[i][k]);
        if(k+1!=w)System.out.print(" ");
      }
      System.out.println("");
    }
  }
  public static void main(String[] args){
    new Main().dolt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation Forec( h : int, w : int, wea : Sequence(Sequence(String))) : Sequence(Sequence(int))
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := -1 ;
     var forec : Sequence(Sequence(int)) ; forec := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    var flag : boolean ;
        var i : int ; i := 0 ; while i < h do ( (     flag := false ; 
     cnt := -1 ; 
         var k : int ; k := 0 ; while k < w do ( (     if (wea[i+1][k+1] = 'c') then (     cnt := 0 ; 
     flag := true ) else     if (flag = true & wea[i+1][k+1] = '.') then     cnt := cnt + 1 else     if (wea[i+1][k+1] = '.') then     cnt := -1 ; else skip ; ;  ;  
     forec[i+1][k+1] := cnt )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    return forec 
 );
   operation dolt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var str : Sequence(Sequence(String)) ; str := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    var forec : Sequence(Sequence(int)) ; forec := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (     str[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    forec := Forec(h, w, str) ; 
        var i : int ; i := 0 ; while i < h do ( (         var k : int ; k := 0 ; while k < w do ( (     OclFile["System.out"].print(forec[i+1][k+1]) ; 
     if (k + 1 /= w) then     OclFile["System.out"].print(" ") ; else skip )  ;     k := k + 1 ) ; 
     OclFile["System.out"].println("") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().dolt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
class Main {
  static final PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      StringTokenizer st=new StringTokenizer(line);
      int h=Integer.parseInt(st.nextToken());
      int w=Integer.parseInt(st.nextToken());
      int[] wf=new int[w];
      for(int i=0 ; i<h ; i++){
        boolean flag=false ;
        char[] map=br.readLine().toCharArray();
        for(int j=0 ; j<w ; j++){
          if(map[j]=='c'){
            wf[j]=0 ;
            flag=true ;
          }
          else {
            if(! flag)wf[j]=-1 ;
            else wf[j]=wf[j-1]+1 ;
          }
          if(j==w-1)out.println(wf[j]);
          else out.print(wf[j]+" ");
        }
      }
      out.flush();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var st : OclIterator ; st := OclIterator.newOclIterator_String(line) ;
     var h : int ; h := (st.next())->toInteger() ;
    var w : int ; w := (st.next())->toInteger() ;
    var wf : Sequence(int) ; wf := Integer.subrange(1,w)->collect(0) ;
        var i : int ; i := 0 ; while i < h do ( (     var flag : boolean ; flag := false ;
     var map : Sequence(String) ; map := br.readLine()->characters() ;
         var j : int ; j := 0 ; while j < w do ( (     if (map[j+1] = 'c') then (     wf[j+1] := 0 ; 
     flag := true ) else (     if (not(flag)) then     wf[j+1] := -1 ; else     wf[j+1] := wf[j - 1+1] + 1 ; ) ;  
     if (j = w - 1) then     skip ; else     skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int[][] judge(int x,int y,char[][] c){
    int h=x ;
    int w=y ;
    int[][] ret=new int[h][w];
    for(int i=0 ; i<h ; i++){
      int cloud=-1 ;
      for(int k=0 ; k<w ; k++){
        if(c[i][k]=='c'){
          cloud=k ;
          ret[i][k]=0 ;
        }
        else if(cloud==-1 && c[i][k]=='.'){
          ret[i][k]=-1 ;
        }
        else {
          int d=k-cloud ;
          ret[i][k]=d ;
        }
      }
    }
    return ret ;
  }
  void doIt(){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int p=0 ;
    char weather[][]=new char[h][];
    int ans[][]=new int[h][w];
    for(int i=0 ; i<h ; i++){
      weather[i]=sc.next().toCharArray();
    }
    ans=judge(h,w,weather);
    for(int i=0 ; i<h ; i++){
      p=0 ;
      for(int k=0 ; k<w ; k++){
        if(p==w-1){
          System.out.println(ans[i][k]);
        }
        else {
          System.out.print(ans[i][k]);
          System.out.print(" ");
          p++;
        }
      }
    }
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation judge( x : int, y : int, c : Sequence(Sequence(String))) : Sequence(Sequence(int))
  pre: true
  post: true
  activity: (     var h : int ; h := x ;
     var w : int ; w := y ;
    var ret : Sequence(Sequence(int)) ; ret := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (     var cloud : int ; cloud := -1 ;
         var k : int ; k := 0 ; while k < w do ( (     if (c[i+1][k+1] = 'c') then (     cloud := k ; 
     ret[i+1][k+1] := 0 ) else     if (cloud = -1 & c[i+1][k+1] = '.') then (     ret[i+1][k+1] := -1 ) else (     var d : int ; d := k - cloud ;
     ret[i+1][k+1] := d ) ;  )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    return ret 
 );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var p : int ; p := 0 ;
    var weather : Sequence(Sequence(String)) ; weather := Integer.subrange(1,h)->collect(Sequence{}) ;
    var ans : Sequence(Sequence(int)) ; ans := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (     weather[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    ans := judge(h, w, weather) ; 
        var i : int ; i := 0 ; while i < h do ( (     p := 0 ; 
         var k : int ; k := 0 ; while k < w do ( (     if (p = w - 1) then (     OclFile["System.out"].println(ans[i+1][k+1]) ) else (     OclFile["System.out"].print(ans[i+1][k+1]) ; 
     OclFile["System.out"].print(" ") ; 
     p := p + 1 ) )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  static boolean pali(String s){
    for(int i=0 ; i<s.length(); i++){
      int j=s.length()-i-1 ;
      if(s.charAt(i)!=s.charAt(j)){
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      String s=sc.next();
      if(pali(s)==false){
        System.out.println(s.length());
      }
      else {
        String sh=s.substring(0,s.length()-1);
        if(pali(sh)==false){
          System.out.println(s.length()-1);
        }
        else {
          System.out.println(0);
        }
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation pali( s : String) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() do ( (     var j : int ; j := s->size() - i - 1 ;
     if (s->at(i+1) /= s->at(j+1)) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
     if (pali(s) = false) then (     OclFile["System.out"].println(s->size()) ) else (     var sh : String ; sh := s.subrange(0+1,s->size() - 1) ;
     if (pali(sh) = false) then (     OclFile["System.out"].println(s->size() - 1) ) else (     OclFile["System.out"].println(0) ) ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void printArray(int[] A){
    int n=A.length ;
    for(int i=0 ; i<n-1 ; i++){
      System.out.print(A[i]+" ");
    }
    System.out.print(A[n-1]+"\n");
  }
  public static void selectionSort(int[] A){
    int minPos ;
    int swapTimes=0 ;
    for(int i=0 ; i<A.length ; i++){
      minPos=i ;
      for(int j=i+1 ; j<A.length ; j++){
        if(A[j]<A[minPos])minPos=j ;
      }
      if(i!=minPos){
        swap(A,i,minPos);
        swapTimes++;
      }
    }
    printArray(A);
    System.out.println(swapTimes);
  }
  public static void swap(int[] A,int a,int b){
    int t=A[a];
    A[a]=A[b];
    A[b]=t ;
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[] A=new int[n];
    for(int i=0 ; i<n ; i++){
      A[i]=scan.nextInt();
    }
    scan.close();
    selectionSort(A);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation printArray( A : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := A->size() ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     OclFile["System.out"].print(A[i+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(A[n - 1+1] + "\n") );
  static   operation selectionSort( A : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var minPos : int ;
     var swapTimes : int ; swapTimes := 0 ;
        var i : int ; i := 0 ; while i < A->size() do ( (     minPos := i ; 
         var j : int ; j := i + 1 ; while j < A->size() do ( (     if (A[j+1] < A[minPos+1]) then     minPos := j ; else skip )  ;     j := j + 1 ) ; 
     if (i /= minPos) then (     execute swap(A, i, minPos) ; 
     swapTimes := swapTimes + 1 ) else skip )  ;     i := i + 1 ) ; 
    execute printArray(A) ; 
    OclFile["System.out"].println(swapTimes) ; 
 );
  static   operation swap( A : Sequence(int), a : int, b : int) : void
  pre: true
  post: true
  activity: (     var t : int ; t := A[a+1] ;
     A[a+1] := A[b+1] ; 
     A[b+1] := t );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    execute selectionSort(A) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class B817 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    Integer[] A=new Integer[N];
    for(int n=0 ; n<N ; n++){
      A[n]=in.nextInt();
    }
    Arrays.sort(A);
    int first=1 ;
    long answer ;
    while(first<N && A[first]==A[0] .intValue())first++;
    if(first>=3){
      answer=first*(long)(first-1)*(first-2)/6 ;
    }
    else {
      int second=first+1 ;
      while(second<N && A[second]==A[first] .intValue())second++;
      if(first==2){
        answer=second-first ;
      }
      else {
        if(second>=3){
          answer=(second-first)*(long)(second-first-1)/2 ;
        }
        else {
          int third=second+1 ;
          while(third<N && A[third]==A[second] .intValue())third++;
          answer=third-second ;
        }
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B817 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(null) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    A := A->sort() ; 
    var first : int ; first := 1 ;
    var answer : long ;
    while (first < N & A[first+1] = A[0+1]->oclAsType(int)) do     first := first + 1 ; ; 
    if (first >= 3) then (     answer := first * (first - 1)->oclAsType(long) * (first - 2) / 6 ) else (     var second : int ; second := first + 1 ;
     while (second < N & A[second+1] = A[first+1]->oclAsType(int)) do     second := second + 1 ; ; 
     if (first = 2) then (     answer := second - first ) else (     if (second >= 3) then (     answer := (second - first) * (second - first - 1)->oclAsType(long) / 2 ) else (     var third : int ; third := second + 1 ;
     while (third < N & A[third+1] = A[second+1]->oclAsType(int)) do     third := third + 1 ; ; 
     answer := third - second ) ) ) ;  
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int w=parseInt(line);
      String base3="" ;
      while(w!=0){
        int r=w % 3 ;
        if(r==0){
          base3="0"+base3 ;
          w/=3 ;
        }
        else if(r==1){
          base3="+"+base3 ;
          w/=3 ;
        }
        else if(r==2){
          base3="-"+base3 ;
          w/=3 ;
          w++;
        }
      }
      System.out.println(base3);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var w : int ; w := parseInt(line) ;
     var base3 : String ; base3 := "" ;
     while (w /= 0) do (     var r : int ; r := w mod 3 ;
     if (r = 0) then (     base3 := "0" + base3 ; 
     w := w/(3) ) else     if (r = 1) then (     base3 := "+" + base3 ; 
     w := w/(3) ) else     if (r = 2) then (     base3 := "-" + base3 ; 
     w := w/(3) ; 
     w := w + 1 ) else skip ; ;  ) ; 
     OclFile["System.out"].println(base3) ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int w=scan.nextInt();
    String ans="" ;
    while(w!=0){
      int tmp=w % 3 ;
      if(tmp==0){
        ans="0"+ans ;
        w/=3 ;
      }
      else if(tmp==1){
        ans="+"+ans ;
        w/=3 ;
      }
      else if(tmp==2){
        ans="-"+ans ;
        w/=3 ;
        w++;
      }
    }
    System.out.println(ans);
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := scan.getCurrent()->toInteger() ;
    var ans : String ; ans := "" ;
    while (w /= 0) do (     var tmp : int ; tmp := w mod 3 ;
     if (tmp = 0) then (     ans := "0" + ans ; 
     w := w/(3) ) else     if (tmp = 1) then (     ans := "+" + ans ; 
     w := w/(3) ) else     if (tmp = 2) then (     ans := "-" + ans ; 
     w := w/(3) ; 
     w := w + 1 ) else skip ; ;  ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),a[]=new int[15],i=0 ;
    while(n>0){
      a[i++]=(n+1)% 3-1 ;
      n=(n-a[i-1])/3 ;
    }
    while(i-->0)System.out.print((a[i]==0 ? "0" : a[i]>0 ? "+" : "-")+(i==0 ? "\n" : ""));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(void) ; a := Integer.subrange(1,15)->collect(0) ;
    var i : int ; i := 0 ;
     while (n > 0) do (      a[i+1] := (n + 1) mod 3 - 1  ; i := i + 1 ; 
     n := (n - a[i - 1+1]) / 3 ) ; 
         while (i > 0) do (        i := i - 1 ;     skip ;     OclFile["System.out"].print((if a[i+1] = 0 then "0" else if a[i+1] > 0 then "+" else "-" endif endif) + (if i = 0 then "\n" else "" endif)) ; ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s="" ;
    while(n>0){
      s=(n % 3==0 ? "0" : n % 3==1 ? "+" : "-")+s ;
      n=n % 3==2 ? n/3+1 : n/3 ;
    }
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := "" ;
    while (n > 0) do (     s := (if n mod 3 = 0 then "0" else if n mod 3 = 1 then "+" else "-" endif endif) + s ; 
     n := if n mod 3 = 2 then n / 3 + 1 else n / 3 endif ) ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int w=sc.nextInt();
    StringBuilder res=new StringBuilder();
    while(w>0){
      switch(w % 3){
        case 0 : res.insert(0,'0');
        w/=3 ;
        break ;
        case 1 : res.insert(0,'+');
        w/=3 ;
        break ;
        case 2 : res.insert(0,'-');
        w=w/3+1 ;
        break ;
      }
    }
    System.out.println(res.toString());
  }
  public static void main(String[] a){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    var res : String ; res := StringLib.newString() ;
    while (w > 0) do ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (w mod 3) ; 
       if _switchval = 0 then
     res := res.insertAt(0+1, StringLib.newString('0')) ; 
    w := w/(3) ; 
    break 
   else skip ;
       if _switchval = 1 then
     res := res.insertAt(0+1, StringLib.newString('+')) ; 
    w := w/(3) ; 
    break 
   else skip ;
       if _switchval = 2 then
     res := res.insertAt(0+1, StringLib.newString('-')) ; 
    w := w / 3 + 1 ; 
    break 
   else skip ;
 )
 ) ; 
    OclFile["System.out"].println(res+"") ; 
 );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int T=1 ;
      while(T-->0){
        solveOne(in,out);
      }
    }
    private void solveOne(Scanner in,PrintWriter out){
      int N=in.nextInt(),X=in.nextInt(),T=in.nextInt();
      out.println((int)(Math.ceil((double)N/X)*T));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var T : int ; T := 1 ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     execute solveOne(in, out) ) ;  ) );
   operation solveOne( in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
    var X : int ; X := in.getCurrent()->toInteger() ;
    var T : int ; T := in.getCurrent()->toInteger() ;
     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static Scanner inp=new Scanner(System.in);
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String args[]){
    Main g=new Main();
    g.main();
    out.close();
  }
  void main(){
    int n=inp.nextInt();
    int x=inp.nextInt();
    int t=inp.nextInt();
    System.out.println((((n+x-1))/x)*t);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute inp : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : Main ; g := Main.newMain() ;
     g.main() ; 
     skip );
   operation main() : void
  pre: true
  post: true
  activity: (     var n : int ; n := inp.getCurrent()->toInteger() ;
     var x : int ; x := inp.getCurrent()->toInteger() ;
     var t : int ; t := inp.getCurrent()->toInteger() ;
     OclFile["System.out"].println((((n + x - 1)) / x) * t) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.System.*;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  static void solve()throws Exception {
    int n=scanInt(),x=scanInt(),t=scanInt();
    out.print(n % x!=0 ?(n/x+1)*t :(n/x)*t);
  }
  static int scanInt()throws IOException {
    return parseInt(scanString());
  }
  static long scanLong()throws IOException {
    return parseLong(scanString());
  }
  static String scanString()throws IOException {
    while(tok==null || ! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  public static void main(String[] args){
    try {
      in=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(System.out);
      solve();
      in.close();
      out.close();
    }
    catch(Throwable e){
      e.printStackTrace();
      exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanInt() ;
    var x : int ; x := scanInt() ;
    var t : int ; t := scanInt() ;
     out.print(if n mod x /= 0 then (n / x + 1) * t else (n / x) * t endif) );
  static   operation scanInt() : int
  pre: true
  post: true
  activity: (     return (scanString() + "")->toInteger() );
  static   operation scanLong() : long
  pre: true
  post: true
  activity: (     return parseLong(scanString()) );
  static   operation scanString() : String
  pre: true
  post: true
  activity: (     while (tok = null or not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return tok.next() );
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
     execute exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ATakoyaki solver=new ATakoyaki();
    solver.solve(1,in,out);
    out.close();
  }
  static class ATakoyaki {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt(),x=in.nextInt(),t=in.nextInt();
      out.println((((n+x)-1)/x)*t);
    }
  }
  static class InputReader {
    public final BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ATakoyaki ; solver := ATakoyaki.newATakoyaki() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ATakoyaki {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
    var x : int ; x := in.nextInt() ;
    var t : int ; t := in.nextInt() ;
     skip );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=Integer.parseInt(scanner.nextLine());
    int[] a=scanIntArray(scanner);
    int length=a.length ;
    int swapCount=0 ;
    for(int i=0 ; i<length ; i++){
      int minIndex=i ;
      for(int j=i ; j<length ; j++){
        if(a[j]<a[minIndex]){
          minIndex=j ;
        }
      }
      if(a[i]>a[minIndex]){
        swap(a,i,minIndex);
        swapCount++;
      }
    }
    printIntArray(a," ");
    System.out.println(swapCount);
  }
  private static void printIntArray(int[] array,String delimeter){
    System.out.println(Arrays.stream(array).mapToObj(String :: valueOf).collect(Collectors.joining(delimeter)));
  }
  private static int[] scanIntArray(Scanner scanner){
    return Arrays.stream(scanner.nextLine().split(" ",0)).mapToInt(Integer :: parseInt).toArray();
  }
  private static void swap(int[] array,int index1,int index2){
    int tmp=array[index1];
    array[index1]=array[index2];
    array[index2]=tmp ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (scanner.nextLine())->toInteger() ;
    var a : Sequence(int) ; a := scanIntArray(scanner) ;
    var length : int ; length := a->size() ;
    var swapCount : int ; swapCount := 0 ;
        var i : int ; i := 0 ; while i < length do ( (     var minIndex : int ; minIndex := i ;
         var j : int ; j := i ; while j < length do ( (     if (a[j+1] < a[minIndex+1]) then (     minIndex := j ) else skip )  ;     j := j + 1 ) ; 
     if (a[i+1] > a[minIndex+1]) then (     execute swap(a, i, minIndex) ; 
     swapCount := swapCount + 1 ) else skip )  ;     i := i + 1 ) ; 
    execute printIntArray(a, " ") ; 
    OclFile["System.out"].println(swapCount) ; 
 );
  static   operation printIntArray( array : Sequence(int), delimeter : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(stream(array).mapToObj(lambda _pars : OclAny in String.newString().valueOf(_pars)).collect(Collectors.joining(delimeter))) );
  static   operation scanIntArray( scanner : OclFile) : Sequence(int)
  pre: true
  post: true
  activity: (     return stream(scanner.nextLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() );
  static   operation swap( array : Sequence(int), index1 : int, index2 : int) : void
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := array[index1+1] ;
     array[index1+1] := array[index2+1] ; 
     array[index2+1] := tmp );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    Solution solution=new Solution();
    String s=scanner.nextLine();
    System.out.println(solution.run(s));
  }
  public static class Solution {
    private final int[][] DP=new int[1001][1001];
    {
      for(int[] ints : DP){
        Arrays.fill(ints,-1);
      }
    }
    public int run(String s){
      int n=s.length();
      int max=-1 ;
      for(int i=0 ; i<n ; i++){
        for(int j=i+1 ; j<n ; j++){
          if(isPal(s,i,j)<1){
            if(j-i>max){
              max=j-i ;
            }
          }
        }
      }
      return max+1 ;
    }
    public int isPal(String s,int i,int j){
      if(i>j)return 1 ;
      if(DP[i][j]!=-1)return DP[i][j];
      if(s.charAt(i)!=s.charAt(j)){
        return DP[i][j]=0 ;
      }
      return DP[i][j]=isPal(s,i+1,j-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var solution : Solution ; solution := Solution.newSolution() ;
     var s : String ; s := scanner.nextLine() ;
     OclFile["System.out"].println(solution.run(s)) );
  static class Solution {
   attribute DP : Sequence(Sequence(int)) := Integer.subrange(1,1001)->collect(Integer.subrange(1,1001)->collect(0));
  operation initialiseInstance()
  pre: true post: true
  activity:     for (ints : DP) do ( (     ints := ints->collect(-1) )  ) ; 
;
   operation run( s : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var max : int ; max := -1 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (isPal(s, i, j) < 1) then (     if (j - i > max) then (     max := j - i ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return max + 1 );
   operation isPal( s : String, i : int, j : int) : int
  pre: true
  post: true
  activity: (     if (i > j) then     return 1 else skip ; 
     if (DP[i+1][j+1] /= -1) then     return DP[i+1][j+1] else skip ; 
     if (s->at(i+1) /= s->at(j+1)) then (     return DP[i+1][j+1] ) else skip ; 
     return DP[i+1][j+1] );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void solve(int n,int x,int t){
    int joyo=n % x ;
    int ans=n/x ;
    System.out.println((ans*t)+(joyo!=0 ? t : 0));
  }
  public static void main(String[] args){
    long start=System.currentTimeMillis();
    Scanner scanner=new Scanner(System.in);
    try {
      int n=scanner.nextInt();
      int x=scanner.nextInt();
      int t=scanner.nextInt();
      scanner.nextLine();
      solve(n,x,t);
    }
    finally {
      scanner.close();
    }
    long end=System.currentTimeMillis();
  }
  private static final int[] changeArrayStringToInt(String line){
    String[] strArray=line.split(" ");
    int[] intArray=new int[strArray.length];
    for(int i=0 ; i<intArray.length ; i++){
      intArray[i]=Integer.parseInt(strArray[i]);
    }
    return intArray ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( n : int, x : int, t : int) : void
  pre: true
  post: true
  activity: (     var joyo : int ; joyo := n mod x ;
     var ans : int ; ans := n / x ;
     OclFile["System.out"].println((ans * t) + (if joyo /= 0 then t else 0 endif)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : long ; start := OclDate.getSystemTime() ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     try (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var x : int ; x := scanner.getCurrent()->toInteger() ;
    var t : int ; t := scanner.getCurrent()->toInteger() ;
    skip ; 
    execute solve(n, x, t) ; 
 )   finally (     skip )
     var end : long ; end := OclDate.getSystemTime() );
  static    operation changeArrayStringToInt( line : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var strArray : Sequence(String) ; strArray := line->split(" ") ;
     var intArray : Sequence(int) ; intArray := Integer.subrange(1,strArray->size())->collect(0) ;
         var i : int ; i := 0 ; while i < intArray->size() do ( (     intArray[i+1] := (strArray[i+1])->toInteger() )  ;     i := i + 1 ) ; 
     return intArray );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A_Crossmarket {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    for(int i=1 ; i<=test ; i++){
      int n=sc.nextInt();
      int m=sc.nextInt();
      System.out.println(n+m+Math.min(n,m)-3+Math.min(Math.max(n,m)-1,1));
    }
  }
  static void readArray(int a[]){
    Scanner in=new Scanner(System.in);
    for(int i=0 ; i<a.length ; i++){
      a[i]=in.nextInt();
    }
  }
  static void printArray(int a[]){
    for(int x : a){
      System.out.print(x+" ");
    }
  }
  static int[] listToArray(ArrayList<Integer>a1){
    int[] arr=a1.stream().mapToInt(i->i).toArray();
    return arr ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Crossmarket {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= test do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(n + m + Set{n, m}->min() - 3 + Set{Set{n, m}->max() - 1, 1}->min()) )  ;     i := i + 1 ) );
  static   operation readArray( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) );
  static   operation printArray( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     for (x : a) do ( (     OclFile["System.out"].print(x + " ") )  ) );
  static   operation listToArray( a1 : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := a1->collect( _x1 | (lambda i : OclAny in i)->apply(_x1) )->asSequence() ;
     return arr );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Solution {
  static PrintWriter pw ;
  static FastScanner s ;
  public static void main(String[] args)throws Exception {
    pw=new PrintWriter(System.out);
    s=new FastScanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int m=s.nextInt();
      if(n<m){
        int temp=n ;
        n=m ;
        m=temp ;
      }
      if(n==1 && m==1)pw.println(0);
      else pw.println(n+2*m-2);
    }
    pw.flush();
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public FastScanner(String s)throws Exception {
    br=new BufferedReader(new FileReader(new File(s)));
  }
  public String next()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(next());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute pw : OclFile;
  static   attribute s : FastScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     pw := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     s := FastScanner.newFastScanner(OclFile["System.in"]) ; 
    var t : int ; t := s.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.nextInt() ;
     var m : int ; m := s.nextInt() ;
     if (n < m) then (     var temp : int ; temp := n ;
     n := m ; 
     m := temp ) else skip ; 
     if (n = 1 & m = 1) then     skip ; else     skip ; ) ;  ) ;  
    skip ; 
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CrossMarket {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if(n==1 && m==1){
        System.out.println("0");
      }
      else if(m==1 && n!=1){
        System.out.println(n);
      }
      else if(m!=1 && n==1){
        System.out.println(m);
      }
      else if(n>m){
        if(m!=1 && n!=1){
          System.out.println((m-1)+(n-1)+m);
        }
      }
      else if(m>n || m==n){
        if(m!=1 && n!=1){
          System.out.println((m-1)+(n-1)+n);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CrossMarket {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     if (n = 1 & m = 1) then (     OclFile["System.out"].println("0") ) else     if (m = 1 & n /= 1) then (     OclFile["System.out"].println(n) ) else     if (m /= 1 & n = 1) then (     OclFile["System.out"].println(m) ) else     if (n > m) then (     if (m /= 1 & n /= 1) then (     OclFile["System.out"].println((m - 1) + (n - 1) + m) ) else skip ) else     if (m > n or m = n) then (     if (m /= 1 & n /= 1) then (     OclFile["System.out"].println((m - 1) + (n - 1) + n) ) else skip ) else skip ; ;  ;  ;  )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1715 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      int M=in.nextInt();
      int answer=N-1+M-1+Math.min(N,M)-1+Math.min(1,Math.max(N,M)-1);
      System.out.println(answer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1715 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var M : int ; M := in.getCurrent()->toInteger() ;
     var answer : int ; answer := N - 1 + M - 1 + Set{N, M}->min() - 1 + Set{1, Set{N, M}->max() - 1}->min() ;
     OclFile["System.out"].println(answer) )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    pw.println(solve(in.nextLong()));
    pw.close();
  }
  public static int solve(long n){
    long sum=(n*(n+1))/2 ;
    if(sum % 2==0){
      return 0 ;
    }
    else {
      return 1 ;
    }
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     skip ; 
     skip );
  static   operation solve( n : long) : int
  pre: true
  post: true
  activity: (     var sum : long ; sum := (n * (n + 1)) / 2 ;
     if (sum mod 2 = 0) then (     return 0 ) else (     return 1 ) );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long m=n*(n+1);
    m/=2 ;
    System.out.println(m % 2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var m : long ; m := n * (n + 1) ;
    m := m/(2) ; 
    OclFile["System.out"].println(m mod 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class ProblemA {
  static HashSet<Character>set[];
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    System.out.println((n*(n+1)/2)% 2==0 ? 0 : 1);
  }
  public static void sort(int arr[]){
    ArrayList<Integer>list=new ArrayList<>();
    for(int it : arr)list.add(it);
    Collections.sort(list);
    for(int i=0 ; i<list.size(); i++)arr[i]=list.get(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
  static   attribute set : Sequence(Set(String));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
     var n : int ; n := (br.readLine())->toInteger() ;
     OclFile["System.out"].println(if (n * (n + 1) / 2) mod 2 = 0 then 0 else 1 endif) );
  static   operation sort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     for (it : arr) do (     list := list->including(it) ;  ) ; 
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < list->size() do (     arr[i+1] := list->at(i+1) ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigDecimal ;
import java.math.RoundingMode ;
import java.util.*;
public class ProblemC {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    long n=Integer.parseInt(br.readLine());
    if(((n*(n+1))/2)% 2==0)System.out.println(0);
    else System.out.println(1);
  }
  public static void swap(int i,int j,int builder[]){
    int t=builder[i];
    builder[i]=builder[j];
    builder[j]=t ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemC {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
     var n : long ; n := (br.readLine())->toInteger() ;
     if (((n * (n + 1)) / 2) mod 2 = 0) then     OclFile["System.out"].println(0) ; else     OclFile["System.out"].println(1) ; );
  static   operation swap( i : int, j : int, builder : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := builder[i+1] ;
     builder[i+1] := builder[j+1] ; 
     builder[j+1] := t );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void printArr(int[] arr){
    String[] ss=new String[arr.length];
    for(int i=0 ; i<arr.length ; i++){
      ss[i]=String.valueOf(arr[i]);
    }
    System.out.println(String.join(" ",ss));
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] inputs=new int[n];
    for(int i=0 ; i<n ; i++){
      inputs[i]=sc.nextInt();
    }
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      int minj=i ;
      for(int j=i ; j<n ; j++){
        if(inputs[j]<inputs[minj]){
          minj=j ;
        }
      }
      if(minj!=i){
        int tmp=inputs[minj];
        inputs[minj]=inputs[i];
        inputs[i]=tmp ;
        cnt++;
      }
    }
    printArr(inputs);
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation printArr( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := Integer.subrange(1,arr->size())->collect(null) ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     ss[i+1] := ((arr[i+1]) + "") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(join(" ", ss)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var inputs : Sequence(int) ; inputs := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     inputs[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var minj : int ; minj := i ;
         var j : int ; j := i ; while j < n do ( (     if (inputs[j+1] < inputs[minj+1]) then (     minj := j ) else skip )  ;     j := j + 1 ) ; 
     if (minj /= i) then (     var tmp : int ; tmp := inputs[minj+1] ;
     inputs[minj+1] := inputs[i+1] ; 
     inputs[i+1] := tmp ; 
     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    execute printArr(inputs) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    pw.println(solve(in.nextLong()));
    pw.close();
  }
  public static int solve(long n){
    long sum=(n*(n+1))/2 ;
    if(sum % 2==0){
      return 0 ;
    }
    else {
      return 1 ;
    }
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     skip ; 
     skip );
  static   operation solve( n : long) : int
  pre: true
  post: true
  activity: (     var sum : long ; sum := (n * (n + 1)) / 2 ;
     if (sum mod 2 = 0) then (     return 0 ) else (     return 1 ) );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class antiPalindrome {
  static String word ;
  public static boolean checkAntiPalindrome(char[] str){
    boolean flag=true ;
    int i=0 ;
    for(int j=str.length-1 ; i<=j ; j--){
      if(str[i]!=str[j]){
        flag=false ;
      }
      i++;
    }
    return flag ;
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    word=scan.nextLine();
    boolean flag1=true ;
    char[] str=word.toCharArray();
    if(checkAntiPalindrome(str)){
      for(int k=0 ; k+1<str.length ; k++){
        if(str[k]!=str[k+1]){
          flag1=false ;
        }
      }
      if(flag1){
        System.out.println("0");
      }
      else {
        int n=str.length-1 ;
        System.out.println(n);
      }
    }
    else {
      System.out.println(str.length);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class antiPalindrome {
  static   attribute word : String;
  static   operation checkAntiPalindrome( str : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     var flag : boolean ; flag := true ;
     var i : int ; i := 0 ;
         var j : int ; j := str->size() - 1 ; while i <= j do ( (     if (str[i+1] /= str[j+1]) then (     flag := false ) else skip ; 
     i := i + 1 )  ;     j := j - 1 ) ; 
     return flag );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     word := scan.nextLine() ; 
    var flag1 : boolean ; flag1 := true ;
    var str : Sequence(String) ; str := word->characters() ;
    if (checkAntiPalindrome(str)) then (         var k : int ; k := 0 ; while k + 1 < str->size() do ( (     if (str[k+1] /= str[k + 1+1]) then (     flag1 := false ) else skip )  ;     k := k + 1 ) ; 
     if (flag1) then (     OclFile["System.out"].println("0") ) else (     var n : int ; n := str->size() - 1 ;
     OclFile["System.out"].println(n) ) ) else (     OclFile["System.out"].println(str->size()) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long andOperator(long a,long b){
    while(a<b){
      b-=(b &-b);
    }
    return b ;
  }
  public static void main(String[] args){
    long a,b ;
    a=10 ;
    b=15 ;
    System.out.println(andOperator(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation andOperator( a : long, b : long) : long
  pre: true
  post: true
  activity: (     while (a < b) do (     b := b-((b & -b)) ) ; 
     return b );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ;
    var b : long ;
     a := 10 ; 
     b := 15 ; 
     OclFile["System.out"].println(andOperator(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean checking(String s){
    int c=0 ;
    int n=s.length();
    for(int i=n-1 ; i>=0 ; i--){
      if(s.charAt(i)=='0')c++;
      if(c>=6 && s.charAt(i)=='1')return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    String s="100010001" ;
    if(checking(s))System.out.println("Possible");
    else System.out.println("Not possible");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checking( s : String) : boolean
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
     var n : int ; n := s->size() ;
         var i : int ; i := n - 1 ; while i >= 0 do ( (     if (s->at(i+1) = '0') then     c := c + 1 ; else skip ; 
     if (c >= 6 & s->at(i+1) = '1') then     return true else skip )  ;     i := i - 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "100010001" ;
     if (checking(s)) then     OclFile["System.out"].println("Possible") ; else     OclFile["System.out"].println("Not possible") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class AA {
  @ SuppressWarnings("resource")public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long k=sc.nextLong();
    if(k==1){
      System.out.print(n);
      return ;
    }
    int u=0 ;
    while(n>0){
      n=n>>1 ;
      u++;
    }
    u--;
    long sum=1 ;
    for(int i=0 ; i<u ; i++){
      sum=sum<<1 ;
      sum+=1 ;
    }
    System.out.print(sum);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class AA {
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    if (k = 1) then (     OclFile["System.out"].print(n) ; 
     return ) else skip ; 
    var u : int ; u := 0 ;
    while (n > 0) do (     n := (n/(2->pow(1)))->oclAsType(long) ; 
     u := u + 1 ) ; 
    u := u - 1 ; 
    var sum : long ; sum := 1 ;
        var i : int ; i := 0 ; while i < u do ( (     sum := (sum*(2->pow(1)))->oclAsType(long) ; 
     sum := sum+(1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sum) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication33 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long k=sc.nextLong();
    if(k==1){
      System.out.println(n);
      return ;
    }
    long res=1 ;
    while(res<=n){
      res=res<<1 ;
    }
    System.out.println(res-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication33 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    if (k = 1) then (     OclFile["System.out"].println(n) ; 
     return ) else skip ; 
    var res : long ; res := 1 ;
    while (res <= n) do (     res := (res*(2->pow(1)))->oclAsType(long) ) ; 
    OclFile["System.out"].println(res - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MyClass {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s[]=br.readLine().split(" ");
    long n=Long.parseLong(s[0]);
    long k=Long.parseLong(s[1]);
    if(k==1){
      System.out.println(n);
      return ;
    }
    long ans=1 ;
    while(ans<n){
      ans=ans*2+1 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
    var n : long ; n := (s[0+1])->toLong() ;
    var k : long ; k := (s[1+1])->toLong() ;
    if (k = 1) then (     OclFile["System.out"].println(n) ; 
     return ) else skip ; 
    var ans : long ; ans := 1 ;
    while (ans < n) do (     ans := ans * 2 + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Long n=sc.nextLong();
    Long k=sc.nextLong();
    if(k==1){
      System.out.println(n);
      return ;
    }
    ArrayList<Long>al=new ArrayList<>();
    Long v=1L ;
    while(v<=n){
      al.add(v);
      v*=2 ;
    }
    Long pre=al.get(al.size()-1);
    Long ans=pre ^(pre-1);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    if (k = 1) then (     OclFile["System.out"].println(n) ; 
     return ) else skip ; 
    var al : Sequence(long) ; al := Sequence{} ;
    var v : long ; v := 1L ;
    while (v <= n) do (     al := al->including(v) ; 
     v := v*(2) ) ; 
    var pre : long ; pre := al->at(al->size() - 1+1) ;
    var ans : long ; ans := MathLib.bitwiseXor(pre,(pre - 1)) ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int pairs(int n){
    int[][] c=new int[10][10];
    int tmp=1 ;
    for(int i=1 ; i<=n ; i++){
      if(i>=tmp*10)tmp*=10 ;
      c[i/tmp][i % 10]++;
    }
    int ans=0 ;
    for(int i=1 ; i<10 ; i++)for(int j=1 ; j<10 ; j++)ans+=c[i][j]*c[j][i];
    return ans ;
  }
  public static void main(String[] args){
    int n=25 ;
    System.out.print(pairs(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation pairs( n : int) : int
  pre: true
  post: true
  activity: (     var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,10)->collect(Integer.subrange(1,10)->collect(0)) ;
     var tmp : int ; tmp := 1 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (i >= tmp * 10) then     tmp := tmp*(10) ; else skip ; 
     c[i / tmp+1][i mod 10+1] := c[i / tmp+1][i mod 10+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < 10 do (         var j : int ; j := 1 ; while j < 10 do (     ans := ans+(c[i+1][j+1] * c[j+1][i+1]) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 25 ;
     OclFile["System.out"].print(pairs(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
public final class p151 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p151().run());
  }
  public String run(){
    List<Integer>startState=Arrays.asList(1);
    return String.format("%.6f",getExpectedSingles(startState)-2);
  }
  private Map<List<Integer>,Double>expectedSingles=new HashMap<>();
  private double getExpectedSingles(List<Integer>state){
    if(expectedSingles.containsKey(state))return expectedSingles.get(state);
    double result=0 ;
    if(! state.isEmpty()){
      for(int i=0 ; i<state.size(); i++){
        List<Integer>newState=new ArrayList<>(state);
        int sheet=state.get(i);
        newState.remove(i);
        for(int j=sheet+1 ; j<=5 ; j++)newState.add(j);
        Collections.sort(newState);
        result+=getExpectedSingles(newState);
      }
      result/=state.size();
      if(state.size()==1)result++;
    }
    expectedSingles.put(state,result);
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class p151 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p151.newp151().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var startState : Sequence(int) ; startState := 1 ;
     return StringLib.format("%.6f",Sequence{getExpectedSingles(startState) - 2}) );
   attribute expectedSingles : Map(Sequence(int),double) := Map{};
   operation getExpectedSingles( state : Sequence(int)) : double
  pre: true
  post: true
  activity: (     if (expectedSingles->keys()->includes(state)) then     return expectedSingles->at(state) else skip ; 
     var result : double ; result := 0 ;
    if (not(state->isEmpty())) then (         var i : int ; i := 0 ; while i < state->size() do ( (     var newState : Sequence(int) ; newState := Sequence{}->union(state) ;
     var sheet : int ; sheet := state->at(i+1) ;
    newState := newState->excludingAt(i+1) ; 
        var j : int ; j := sheet + 1 ; while j <= 5 do (     newState := newState->including(j) ;  ;     j := j + 1 ) ; 
    newState := newState->sort() ; 
    result := result+(getExpectedSingles(newState)) ; 
 )  ;     i := i + 1 ) ; 
     result := result/(state->size()) ; 
     if (state->size() = 1) then     result := result + 1 ; else skip ) else skip ; 
    expectedSingles := expectedSingles->union(Map{state |-> result}) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int N ;
  int[] A ;
  int minj,key ;
  int count=0 ;
  public void input(){
    N=sc.nextInt();
    A=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
    }
  }
  public void selectionsort(){
    for(int i=0 ; i<N-1 ; i++){
      minj=i ;
      for(int j=i ; j<=N-1 ; j++){
        if(A[j]<A[minj]){
          minj=j ;
        }
      }
      key=A[i];
      A[i]=A[minj];
      A[minj]=key ;
      if(i!=minj)count++;
    }
  }
  public void output(){
    System.out.print(A[0]);
    for(int i=1 ; i<N ; i++){
      System.out.print(" "+A[i]);
    }
    System.out.println("\n"+count);
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.input();
    obj.selectionsort();
    obj.output();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute N : int;
   attribute A : Sequence(int);
   attribute minj : int;
   attribute count : int := 0;
   operation input() : void
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     A := Integer.subrange(1,N)->collect(0) ; 
         var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) );
   operation selectionsort() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N - 1 do ( (     minj := i ; 
         var j : int ; j := i ; while j <= N - 1 do ( (     if (A[j+1] < A[minj+1]) then (     minj := j ) else skip )  ;     j := j + 1 ) ; 
    key := A[i+1] ; 
    A[i+1] := A[minj+1] ; 
    A[minj+1] := key ; 
    if (i /= minj) then     count := count + 1 ; else skip ; 
 )  ;     i := i + 1 ) );
   operation output() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(A[0+1]) ; 
         var i : int ; i := 1 ; while i < N do ( (     OclFile["System.out"].print(" " + A[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("\n" + count) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.input() ; 
     obj.selectionsort() ; 
     obj.output() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class GFG {
  static int getMax(int arr[],int n){
    int max=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++)if(arr[i]>max)max=arr[i];
    return max ;
  }
  static int getSum(int arr[],int n){
    int total=0 ;
    for(int i=0 ; i<n ; i++)total+=arr[i];
    return total ;
  }
  static int numberOfPainters(int arr[],int n,int maxLen){
    int total=0,numPainters=1 ;
    for(int i=0 ; i<n ; i++){
      total+=arr[i];
      if(total>maxLen){
        total=arr[i];
        numPainters++;
      }
    }
    return numPainters ;
  }
  static int partition(int arr[],int n,int k){
    int lo=getMax(arr,n);
    int hi=getSum(arr,n);
    while(lo<hi){
      int mid=lo+(hi-lo)/2 ;
      int requiredPainters=numberOfPainters(arr,n,mid);
      if(requiredPainters<=k)hi=mid ;
      else lo=mid+1 ;
    }
    return lo ;
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3,4,5,6,7,8,9 };
      int n=arr.length ;
      int k=3 ;
      System.out.println(partition(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getMax( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max : int ; max := -2147483648 ;
         var i : int ; i := 0 ; while i < n do (     if (arr[i+1] > max) then     max := arr[i+1] ; else skip ;  ;     i := i + 1 ) ; 
     return max );
  static   operation getSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var total : int ; total := 0 ;
         var i : int ; i := 0 ; while i < n do (     total := total+(arr[i+1]) ;  ;     i := i + 1 ) ; 
     return total );
  static   operation numberOfPainters( arr : Sequence(int), n : int, maxLen : int) : int
  pre: true
  post: true
  activity: (     var total : int ; total := 0 ;
    var numPainters : int ; numPainters := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     total := total+(arr[i+1]) ; 
     if (total > maxLen) then (     total := arr[i+1] ; 
     numPainters := numPainters + 1 ) else skip )  ;     i := i + 1 ) ; 
     return numPainters );
  static   operation partition( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var lo : int ; lo := getMax(arr, n) ;
     var hi : int ; hi := getSum(arr, n) ;
     while (lo < hi) do (     var mid : int ; mid := lo + (hi - lo) / 2 ;
     var requiredPainters : int ; requiredPainters := numberOfPainters(arr, n, mid) ;
     if (requiredPainters <= k) then     hi := mid ; else     lo := mid + 1 ; ) ; 
     return lo );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6,7,8,9} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println(partition(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean checkForElement(int array[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=array[i];
    if(sum % 2>0)return false ;
    sum/=2 ;
    int start=0 ;
    int end=n-1 ;
    while(start<=end){
      int mid=start+(end-start)/2 ;
      if(array[mid]==sum)return true ;
      else if(array[mid]>sum)end=mid-1 ;
      else start=mid+1 ;
    }
    return false ;
  }
  public static void main(String[] args){
    int array[]={
      1,2,3 };
      int n=array.length ;
      if(checkForElement(array,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkForElement( array : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+(array[i+1]) ;  ;     i := i + 1 ) ; 
    if (sum mod 2 > 0) then     return false else skip ; 
    sum := sum/(2) ; 
    var start : int ; start := 0 ;
    var end : int ; end := n - 1 ;
    while (start <= end) do (     var mid : int ; mid := start + (end - start) / 2 ;
     if (array[mid+1] = sum) then     return true else     if (array[mid+1] > sum) then     end := mid - 1 else     start := mid + 1 ; ;  ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Sequence{1,2,3} ;
     var n : int ; n := array->size() ;
     if (checkForElement(array, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.security.spec.RSAOtherPrimeInfo ;
import java.util.*;
import java.lang.*;
public class solve {
  static Scanner sc ;
  public static void main(String[] args){
    sc=new Scanner(System.in);
    int testCases=sc.nextInt();
    while(testCases>0){
      justDoIt();
      testCases--;
    }
  }
  static void justDoIt(){
    int x=sc.nextInt(),y=sc.nextInt();
    if(y % x!=0){
      System.out.println("0 0");
      return ;
    }
    System.out.println("1 "+(y/x));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solve {
  static   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var testCases : int ; testCases := sc.getCurrent()->toInteger() ;
     while (testCases > 0) do (     execute justDoIt() ; 
     testCases := testCases - 1 ) );
  static   operation justDoIt() : void
  pre: true
  post: true
  activity: (     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
     if (y mod x /= 0) then (     OclFile["System.out"].println("0 0") ; 
     return ) else skip ; 
     OclFile["System.out"].println("1 " + (y / x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String[] str=br.readLine().split(" ");
      int num0=Integer.parseInt(str[0]);
      int num1=Integer.parseInt(str[1]);
      int num2=Integer.parseInt(str[2]);
      if(num0<num1 && num1<num2){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
    catch(IOException e){
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var num0 : int ; num0 := (str[0+1])->toInteger() ;
    var num1 : int ; num1 := (str[1+1])->toInteger() ;
    var num2 : int ; num2 := (str[2+1])->toInteger() ;
    if (num0 < num1 & num1 < num2) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 )   catch (e : IOException) do (     OclFile["System.out"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tk=new StringTokenizer(br.readLine());
    int num=Integer.parseInt(tk.nextToken());
    int num2=Integer.parseInt(tk.nextToken());
    int num3=Integer.parseInt(tk.nextToken());
    A AAA=(int a,int b,int c)->{
      if(a<b && b<c){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      };
    };
    AAA.Judgment(num,num2,num3);
  }
}
interface A {
  void Judgment(int a,int b,int c);
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tk : OclIterator ; tk := OclIterator.newOclIterator_String(br.readLine()) ;
    var num : int ; num := (tk.next())->toInteger() ;
    var num2 : int ; num2 := (tk.next())->toInteger() ;
    var num3 : int ; num3 := (tk.next())->toInteger() ;
    var AAA : A ; AAA := lambda  a : int, b : int, c : int : OclAny in (     if (a < b & b < c) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
  ) ;
    AAA.Judgment(num, num2, num3) ; 
 );
}
interface A {
   operation Judgment( a : int, b : int, c : int) : void
  pre: true
  post: true;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args){
    String line=new java.util.Scanner(System.in).nextLine();
    String[] number=line.split(" ",0);
    String ans=Range(parseInt(number[0]),parseInt(number[1]),parseInt(number[2]));
    System.out.println(ans);
  }
  public static String Range(int x,int y,int z){
    if(x<y && y<z){
      return "Yes" ;
    }
    else {
      return "No" ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var line : String ; line := Scanner.newScanner(OclFile["System.in"]).nextLine() ;
     var number : Sequence(String) ; number := line->split(" ") ;
     var ans : String ; ans := Range((number[0+1] + "")->toInteger(), (number[1+1] + "")->toInteger(), (number[2+1] + "")->toInteger()) ;
     OclFile["System.out"].println(ans) );
  static   operation Range( x : int, y : int, z : int) : String
  pre: true
  post: true
  activity: (     if (x < y & y < z) then (     return "Yes" ) else (     return "No" ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      StringTokenizer st=new StringTokenizer(br.readLine());
      int a=Integer.parseInt(st.nextToken());
      int b=Integer.parseInt(st.nextToken());
      int c=Integer.parseInt(st.nextToken());
      if(a<b && b<c){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var a : int ; a := (st.next())->toInteger() ;
    var b : int ; b := (st.next())->toInteger() ;
    var c : int ; c := (st.next())->toInteger() ;
    if (a < b & b < c) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    if(a<b){
      if(b<c){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    if (a < b) then (     if (b < c) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Set ;
public class KoalaAndLights {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    Set<Integer>[] toggleTimes=new HashSet[n];
    for(int i=0 ; i<n ; i++){
      toggleTimes[i]=new HashSet<>();
    }
    boolean[] status=new boolean[n];
    char[] temp=br.readLine().toCharArray();
    for(int i=0 ; i<n ; i++){
      status[i]=(temp[i]=='1' ? true : false);
    }
    for(int i=0 ; i<n ; i++){
      String[] time=br.readLine().split(" ");
      int a=Integer.parseInt(time[0]);
      int b=Integer.parseInt(time[1]);
      for(int j=0 ; j<1000 ; j++){
        if(b+j*a>700){
          break ;
        }
        toggleTimes[i] .add(b+j*a);
      }
    }
    int res=0 ;
    for(int time=0 ; time<=700 ; time++){
      int countOn=0 ;
      for(int i=0 ; i<n ; i++){
        if(toggleTimes[i] .contains(time)){
          status[i]=! status[i];
        }
        if(status[i]){
          countOn++;
        }
      }
      res=Math.max(res,countOn);
    }
    pr.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class KoalaAndLights {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var toggleTimes : Sequence(Set(int)) ; toggleTimes := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     toggleTimes[i+1] := Set{} )  ;     i := i + 1 ) ; 
    var status : Sequence(boolean) ; status := Integer.subrange(1,n)->collect(false) ;
    var temp : Sequence(String) ; temp := br.readLine()->characters() ;
        var i : int ; i := 0 ; while i < n do ( (     status[i+1] := (if temp[i+1] = '1' then true else false endif) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var time : Sequence(String) ; time := br.readLine()->split(" ") ;
     var a : int ; a := (time[0+1])->toInteger() ;
     var b : int ; b := (time[1+1])->toInteger() ;
         var j : int ; j := 0 ; while j < 1000 do ( (     if (b + j * a > 700) then (     break ) else skip ; 
     toggleTimes[i+1]->excludes(b + j * a) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var time : int ; time := 0 ; while time <= 700 do ( (     var countOn : int ; countOn := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (toggleTimes[i+1]->includes(time)) then (     status[i+1] := not(status[i+1]) ) else skip ; 
     if (status[i+1]) then (     countOn := countOn + 1 ) else skip )  ;     i := i + 1 ) ; 
     res := Set{res, countOn}->max() )  ;     time := time + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class B {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int n=sc.nextInt();
    String s=sc.next();
    boolean[][] oo=new boolean[241][n];
    int max=0 ;
    int[] a=new int[n];
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++){
      oo[0][i]=s.charAt(i)=='1' ;
      if(oo[0][i])max++;
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
    }
    for(int i=1 ; i<=240 ; i++){
      int num=0 ;
      for(int j=0 ; j<n ; j++){
        oo[i][j]=oo[i-1][j];
        if(i>=b[j] && i % a[j]==b[j] % a[j])oo[i][j]=! oo[i][j];
        if(oo[i][j])num++;
      }
      max=Math.max(num,max);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var oo : Sequence(Sequence(boolean)) ; oo := Integer.subrange(1,241)->collect(Integer.subrange(1,n)->collect(false)) ;
    var max : int ; max := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     oo[0+1][i+1] := s->at(i+1) = '1' ; 
     if (oo[0+1][i+1]) then     max := max + 1 ; else skip ; 
     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 240 do ( (     var num : int ; num := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     oo[i+1][j+1] := oo[i - 1+1][j+1] ; 
     if (i >= b[j+1] & i mod a[j+1] = b[j+1] mod a[j+1]) then     oo[i+1][j+1] := not(oo[i+1][j+1]) ; else skip ; 
     if (oo[i+1][j+1]) then     num := num + 1 ; else skip )  ;     j := j + 1 ) ; 
     max := Set{num, max}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static boolean[] bits ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    boolean[][] input=new boolean[m][n];
    bits=new boolean[n];
    int[] p=new int[m];
    int k ;
    for(int i=0 ; i<m ; i++){
      k=sc.nextInt();
      for(int j=0 ; j<k ; j++){
        input[i][sc.nextInt()-1]=true ;
      }
    }
    for(int i=0 ; i<m ; i++){
      p[i]=sc.nextInt();
    }
    int tmp1 ;
    boolean tmp2 ;
    int ans=0 ;
    for(int i=0 ; i<Math.pow(2,n); i++){
      tmp2=true ;
      for(int j=0 ; j<m ; j++){
        tmp1=0 ;
        for(int l=0 ; l<n ; l++){
          if(input[j][l] && bits[l])tmp1++;
        }
        tmp2 &=tmp1 % 2==p[j];
      }
      if(tmp2)ans++;
      if(i!=Math.pow(2,n)-1)update(0);
    }
    System.out.println(ans);
  }
  static void update(int pointer){
    if(! bits[pointer]){
      bits[pointer]=true ;
    }
    else {
      bits[pointer]=false ;
      update(pointer+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute bits : Sequence(boolean);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var input : Sequence(Sequence(boolean)) ; input := Integer.subrange(1,m)->collect(Integer.subrange(1,n)->collect(false)) ;
    bits := Integer.subrange(1,n)->collect(false) ; 
    var p : Sequence(int) ; p := Integer.subrange(1,m)->collect(0) ;
    var k : int ;
        var i : int ; i := 0 ; while i < m do ( (     k := sc.getCurrent()->toInteger() ; 
         var j : int ; j := 0 ; while j < k do ( (     input[i+1][sc.getCurrent()->toInteger() - 1+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     p[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var tmp1 : int ;
    var tmp2 : boolean ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 2->pow(n) do ( (     tmp2 := true ; 
         var j : int ; j := 0 ; while j < m do ( (     tmp1 := 0 ; 
         var l : int ; l := 0 ; while l < n do ( (     if (input[j+1][l+1] & bits[l+1]) then     tmp1 := tmp1 + 1 ; else skip )  ;     l := l + 1 ) ; 
     tmp2 := MathLib.bitwiseAnd(tmp2, tmp1 mod 2 = p[j+1]) )  ;     j := j + 1 ) ; 
     if (tmp2) then     ans := ans + 1 ; else skip ; 
     if (i /= 2->pow(n) - 1) then     execute update(0) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation update( pointer : int) : void
  pre: true
  post: true
  activity: (     if (not(bits[pointer+1])) then (     bits[pointer+1] := true ) else (     bits[pointer+1] := false ; 
     execute update(pointer + 1) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static final int BIG_NUM=2000000000 ;
  public static final int MOD=1000000007 ;
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String input[]=new String[2];
    try {
      input=br.readLine().split("\\s+");
      int N=Integer.parseInt(input[0]);
      int T=Integer.parseInt(input[1]);
      int table[]=new int[T+1];
      for(int i=0 ; i<table.length ; i++){
        table[i]=0 ;
      }
      int left,right ;
      for(int loop=0 ; loop<N ; loop++){
        input=br.readLine().split("\\s+");
        left=Integer.parseInt(input[0]);
        right=Integer.parseInt(input[1]);
        table[left]++;
        table[right]--;
      }
      int ans=table[0];
      for(int i=1 ; i<table.length ; i++){
        table[i]+=table[i-1];
        ans=Math.max(ans,table[i]);
      }
      System.out.println(ans);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BIG_NUM : int := 2000000000;
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : Sequence(String) ; input := Integer.subrange(1,2)->collect(null) ;
     try (     input := br.readLine()->split("\\s+") ; 
     var N : int ; N := (input[0+1])->toInteger() ;
    var T : int ; T := (input[1+1])->toInteger() ;
    var table : Sequence(int) ; table := Integer.subrange(1,T + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < table->size() do ( (     table[i+1] := 0 )  ;     i := i + 1 ) ; 
    var left : int ;
    var right : int ;
        var loop : int ; loop := 0 ; while loop < N do ( (     input := br.readLine()->split("\\s+") ; 
     left := (input[0+1])->toInteger() ; 
    right := (input[1+1])->toInteger() ; 
    table[left+1] := table[left+1] + 1 ; 
    table[right+1] := table[right+1] - 1 ; 
 )  ;     loop := loop + 1 ) ; 
    var ans : int ; ans := table[0+1] ;
        var i : int ; i := 1 ; while i < table->size() do ( (     table[i+1] := table[i+1]+(table[i - 1+1]) ; 
     ans := Set{ans, table[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int T=in.nextInt();
    int res[]=new int[T+1];
    int ini,fin ;
    for(int i=0 ; i<N ; i++){
      ini=in.nextInt();
      fin=in.nextInt();
      for(int j=ini ; j<fin ; j++){
        res[j]++;
      }
    }
    int max=0 ;
    for(int i=0 ; i<T ; i++){
      if(res[i]>max){
        max=res[i];
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var T : int ; T := in.getCurrent()->toInteger() ;
    var res : Sequence(int) ; res := Integer.subrange(1,T + 1)->collect(0) ;
    var ini : int ;
    var fin : int ;
        var i : int ; i := 0 ; while i < N do ( (     ini := in.getCurrent()->toInteger() ; 
     fin := in.getCurrent()->toInteger() ; 
         var j : int ; j := ini ; while j < fin do ( (     res[j+1] := res[j+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < T do ( (     if (res[i+1] > max) then (     max := res[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    int[] imos=new int[t+2];
    for(int i=0 ; i<n ; i++){
      imos[sc.nextInt()]++;
      imos[sc.nextInt()]--;
    }
    int max=imos[0];
    for(int i=1 ; i<=t ; i++){
      imos[i]+=imos[i-1];
      max=Math.max(max,imos[i]);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var imos : Sequence(int) ; imos := Integer.subrange(1,t + 2)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     imos[sc.getCurrent()->toInteger()+1] := imos[sc.getCurrent()->toInteger()+1] + 1 ; 
     imos[sc.getCurrent()->toInteger()+1] := imos[sc.getCurrent()->toInteger()+1] - 1 )  ;     i := i + 1 ) ; 
    var max : int ; max := imos[0+1] ;
        var i : int ; i := 1 ; while i <= t do ( (     imos[i+1] := imos[i+1]+(imos[i - 1+1]) ; 
     max := Set{max, imos[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.security.spec.RSAOtherPrimeInfo ;
import java.util.*;
import java.lang.*;
public class solve {
  static Scanner sc ;
  public static void main(String[] args){
    sc=new Scanner(System.in);
    int testCases=sc.nextInt();
    while(testCases>0){
      justDoIt();
      testCases--;
    }
  }
  static void justDoIt(){
    int x=sc.nextInt(),y=sc.nextInt();
    if(y % x!=0){
      System.out.println("0 0");
      return ;
    }
    if(y==x){
      System.out.println("1 1");
      return ;
    }
    Map<Integer,Integer>map=new HashMap<>();
    int num=(y/x);
    while(num % 2==0){
      map.put(2,map.getOrDefault(2,0)+1);
      num/=2 ;
    }
    for(int i=3 ; i<=Math.sqrt(num); i+=2){
      while(num % i==0){
        map.put(i,map.getOrDefault(i,0)+1);
        num/=i ;
      }
    }
    if(num>1)map.put(num,1);
    int count=-1,ans=1 ;
    for(Map.Entry<Integer,Integer>entry : map.entrySet()){
      if(count!=-1 && count!=entry.getValue()){
        count=1 ;
        ans=y/x ;
        break ;
      }
      if(count==-1)count=entry.getValue();
      ans*=entry.getKey();
    }
    System.out.println(count+" "+ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solve {
  static   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var testCases : int ; testCases := sc.getCurrent()->toInteger() ;
     while (testCases > 0) do (     execute justDoIt() ; 
     testCases := testCases - 1 ) );
  static   operation justDoIt() : void
  pre: true
  post: true
  activity: (     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
     if (y mod x /= 0) then (     OclFile["System.out"].println("0 0") ; 
     return ) else skip ; 
    if (y = x) then (     OclFile["System.out"].println("1 1") ; 
     return ) else skip ; 
    var map : Map(int,int) ; map := Map{} ;
    var num : int ; num := (y / x) ;
    while (num mod 2 = 0) do (     map := map->union(Map{2 |-> (if map->keys()->contains(2) then map->at(2) else 0 endif) + 1}) ; 
     num := num/(2) ) ; 
        var i : int ; i := 3 ; while i <= (num)->sqrt() do ( (     while (num mod i = 0) do (     map := map->union(Map{i |-> (if map->keys()->contains(i) then map->at(i) else 0 endif) + 1}) ; 
     num := num/(i) ) )  ;     i := i+(2) ) ; 
    if (num > 1) then     map := map->union(Map{num |-> 1}) ; else skip ; 
    var count : int ; count := -1 ;
    var ans : int ; ans := 1 ;
    for (entry : map->asSet()) do ( (     if (count /= -1 & count /= entry.getValue()) then (     count := 1 ; 
     ans := y / x ; 
     break ) else skip ; 
     if (count = -1) then     count := entry.getValue() ; else skip ; 
     ans := ans*(entry.getKey()) )  ) ; 
    OclFile["System.out"].println(count + " " + ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      HashMap<String,String>hp=new HashMap<>();
      hp.put("purple","Power");
      hp.put("green","Time");
      hp.put("blue","Space");
      hp.put("orange","Soul");
      hp.put("red","Reality");
      hp.put("yellow","Mind");
      List<String>targetList=new ArrayList<>(hp.values());
      ArrayList<String>arr=new ArrayList<>();
      ArrayList<String>al=new ArrayList<>();
      while(n-->0){
        String s1=sc.next();
        arr.add(hp.get(s1));
      }
      int total=hp.size();
      int occu=arr.size();
      System.out.println(total-occu);
      int iter=targetList.size();
      for(int i=0 ; i<iter ; i++){
        String lol=targetList.get(i);
        if(! arr.contains(lol))al.add(lol);
      }
      for(int i=0 ; i<al.size(); i++){
        System.out.println(al.get(i));
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var hp : Map(String,String) ; hp := Map{} ;
    hp := hp->union(Map{"purple" |-> "Power"}) ; 
    hp := hp->union(Map{"green" |-> "Time"}) ; 
    hp := hp->union(Map{"blue" |-> "Space"}) ; 
    hp := hp->union(Map{"orange" |-> "Soul"}) ; 
    hp := hp->union(Map{"red" |-> "Reality"}) ; 
    hp := hp->union(Map{"yellow" |-> "Mind"}) ; 
    var targetList : Sequence(String) ; targetList := Sequence{}->union(hp->values()) ;
    var arr : Sequence(String) ; arr := Sequence{} ;
    var al : Sequence(String) ; al := Sequence{} ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var s1 : String ; s1 := sc.getCurrent() ;
     arr := arr->including(hp->at(s1)) ) ;  ) ;  
    var total : int ; total := hp.size() ;
    var occu : int ; occu := arr->size() ;
    OclFile["System.out"].println((total)->char2byte() - occu) ; 
    var iter : int ; iter := targetList->size() ;
        var i : int ; i := 0 ; while i < iter do ( (     var lol : String ; lol := targetList->at(i+1) ;
     if (not(arr->includes(lol))) then     al := al->including(lol) ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < al->size() do ( (     OclFile["System.out"].println(al->at(i+1)) )  ;     i := i + 1 ) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class problem {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String[] c=new String[n];
    for(int i=0 ; i<n ; i++){
      c[i]=sc.next();
    }
    int m=6-n ;
    System.out.println(m);
    int p=0,r=0,g=0,b=0,o=0,y=0 ;
    String s1="purple",s2="green",s3="blue",s4="red",s5="orange" ;
    for(int i=0 ; i<n ; i++){
      if(c[i] .equals(s1))p++;
      else if(c[i] .equals(s2))g++;
      else if(c[i] .equals(s3))b++;
      else if(c[i] .equals(s4))r++;
      else if(c[i] .equals(s5))o++;
      else y++;
    }
    if(p==0)System.out.println("Power");
    if(g==0)System.out.println("Time");
    if(b==0)System.out.println("Space");
    if(r==0)System.out.println("Reality");
    if(o==0)System.out.println("Soul");
    if(y==0)System.out.println("Mind");
  }
}
------------------------------------------------------------
OCL File:
---------
 class problem {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : Sequence(String) ; c := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    var m : int ; m := 6 - n ;
    OclFile["System.out"].println(m) ; 
    var p : int ; p := 0 ;
    var r : int ; r := 0 ;
    var g : int ; g := 0 ;
    var b : int ; b := 0 ;
    var o : int ; o := 0 ;
    var y : int ; y := 0 ;
    var s1 : String ; s1 := "purple" ;
    var s2 : String ; s2 := "green" ;
    var s3 : String ; s3 := "blue" ;
    var s4 : String ; s4 := "red" ;
    var s5 : String ; s5 := "orange" ;
        var i : int ; i := 0 ; while i < n do ( (     if (c[i+1] = s1) then     p := p + 1 ; else     if (c[i+1] = s2) then     g := g + 1 else     if (c[i+1] = s3) then     b := b + 1 else     if (c[i+1] = s4) then     r := r + 1 else     if (c[i+1] = s5) then     o := o + 1 else     y := y + 1 ; ;  ;  ;  ;  )  ;     i := i + 1 ) ; 
    if (p = 0) then     OclFile["System.out"].println("Power") ; else skip ; 
    if (g = 0) then     OclFile["System.out"].println("Time") ; else skip ; 
    if (b = 0) then     OclFile["System.out"].println("Space") ; else skip ; 
    if (r = 0) then     OclFile["System.out"].println("Reality") ; else skip ; 
    if (o = 0) then     OclFile["System.out"].println("Soul") ; else skip ; 
    if (y = 0) then     OclFile["System.out"].println("Mind") ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long n,d ;
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    Map<String,String>map=new HashMap<>();
    map.put("purple","Power");
    map.put("green","Time");
    map.put("blue","Space");
    map.put("orange","Soul");
    map.put("red","Reality");
    map.put("yellow","Mind");
    ArrayList<String>list=new ArrayList<>();
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      String v=in.next();
      map.remove(v);
    }
    pw.println(6-n);
    for(String s : map.keySet()){
      pw.println(map.get(s));
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var map : Map(String,String) ; map := Map{} ;
    map := map->union(Map{"purple" |-> "Power"}) ; 
    map := map->union(Map{"green" |-> "Time"}) ; 
    map := map->union(Map{"blue" |-> "Space"}) ; 
    map := map->union(Map{"orange" |-> "Soul"}) ; 
    map := map->union(Map{"red" |-> "Reality"}) ; 
    map := map->union(Map{"yellow" |-> "Mind"}) ; 
    var list : Sequence(String) ; list := Sequence{} ;
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var v : String ; v := in.getCurrent() ;
     map := map->antirestrict(Set{v}) )  ;     i := i + 1 ) ; 
    skip ; 
    for (s : map->keys()) do ( (     skip )  ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
class GFG {
  public static int CountSpecialPalindrome(String str){
    int n=str.length();
    int result=0 ;
    int[] sameChar=new int[n];
    for(int v=0 ; v<n ; v++)sameChar[v]=0 ;
    int i=0 ;
    while(i<n){
      int sameCharCount=1 ;
      int j=i+1 ;
      while(j<n && str.charAt(i)==str.charAt(j)){
        sameCharCount++;
        j++;
      }
      result+=(sameCharCount*(sameCharCount+1)/2);
      sameChar[i]=sameCharCount ;
      i=j ;
    }
    for(int j=1 ; j<n ; j++){
      if(str.charAt(j)==str.charAt(j-1))sameChar[j]=sameChar[j-1];
      if(j>0 && j<(n-1)&&(str.charAt(j-1)==str.charAt(j+1)&& str.charAt(j)!=str.charAt(j-1)))result+=Math.min(sameChar[j-1],sameChar[j+1]);
    }
    return result-n ;
  }
  public static void main(String args[]){
    String str="abccba" ;
    System.out.print(CountSpecialPalindrome(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation CountSpecialPalindrome( str : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var result : int ; result := 0 ;
    var sameChar : Sequence(int) ; sameChar := Integer.subrange(1,n)->collect(0) ;
        var v : int ; v := 0 ; while v < n do (     sameChar[v+1] := 0 ;  ;     v := v + 1 ) ; 
    var i : int ; i := 0 ;
    while (i < n) do (     var sameCharCount : int ; sameCharCount := 1 ;
     var j : int ; j := i + 1 ;
    while (j < n & str->at(i+1) = str->at(j+1)) do (     sameCharCount := sameCharCount + 1 ; 
     j := j + 1 ) ; 
    result := result+((sameCharCount * (sameCharCount + 1) / 2)) ; 
    sameChar[i+1] := sameCharCount ; 
    i := j ; 
 ) ; 
        var j : int ; j := 1 ; while j < n do ( (     if (str->at(j+1) = str->at(j - 1+1)) then     sameChar[j+1] := sameChar[j - 1+1] ; else skip ; 
     if (j > 0 & j < (n - 1) & (str->at(j - 1+1) = str->at(j + 1+1) & str->at(j+1) /= str->at(j - 1+1))) then     result := result+(Set{sameChar[j - 1+1], sameChar[j + 1+1]}->min()) ; else skip )  ;     j := j + 1 ) ; 
    return result - n 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abccba" ;
     OclFile["System.out"].print(CountSpecialPalindrome(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isAMultipleOf4(int n){
    if((n & 3)==0)return true ;
    return false ;
  }
  public static void main(String[] args){
    int n=16 ;
    System.out.println(isAMultipleOf4(n)? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isAMultipleOf4( n : int) : boolean
  pre: true
  post: true
  activity: (     if ((n & 3) = 0) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 16 ;
     OclFile["System.out"].println(if isAMultipleOf4(n) then "Yes" else "No" endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minOperations(int n,int m,int k,int matrix[][]){
    int[] arr=new int[n*m];
    int mod=matrix[0][0] % k ;
    for(int i=0 ; i<n ; ++i){
      for(int j=0 ; j<m ; ++j){
        arr[i*m+j]=matrix[i][j];
        if(matrix[i][j] % k!=mod){
          return-1 ;
        }
      }
    }
    Arrays.sort(arr);
    int median=arr[(n*m)/2];
    int minOperations=0 ;
    for(int i=0 ; i<n*m ; ++i)minOperations+=Math.abs(arr[i]-median)/k ;
    if((n*m)% 2==0){
      int median2=arr[(n*m)/2];
      int minOperations2=0 ;
      for(int i=0 ; i<n*m ; ++i)minOperations2+=Math.abs(arr[i]-median2)/k ;
      minOperations=Math.min(minOperations,minOperations2);
    }
    return minOperations ;
  }
  public static void main(String[] args){
    int matrix[][]={
      {
        2,4,6 },{
          8,10,12 },{
            14,16,18 },{
              20,22,24 }
            };
            int n=matrix.length ;
            int m=matrix[0] .length ;
            int k=2 ;
            System.out.println(minOperations(n,m,k,matrix));
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minOperations( n : int, m : int, k : int, matrix : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n * m)->collect(0) ;
     var mod : int ; mod := matrix[0+1][0+1] mod k ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     arr[i * m + j+1] := matrix[i+1][j+1] ; 
     if (matrix[i+1][j+1] mod k /= mod) then (     return -1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var median : int ; median := arr[(n * m) / 2+1] ;
    var minOperations : int ; minOperations := 0 ;
        var i : int ; i := 0 ; while i < n * m do (     minOperations := minOperations+(if arr[i+1] - median < 0 then -(arr[i+1] - median) else arr[i+1] - median endif / k) ;  ;     i := i + 1 ) ; 
    if ((n * m) mod 2 = 0) then (     var median2 : int ; median2 := arr[(n * m) / 2+1] ;
     var minOperations2 : int ; minOperations2 := 0 ;
         var i : int ; i := 0 ; while i < n * m do (     minOperations2 := minOperations2+(if arr[i+1] - median2 < 0 then -(arr[i+1] - median2) else arr[i+1] - median2 endif / k) ;  ;     i := i + 1 ) ; 
     minOperations := Set{minOperations, minOperations2}->min() ) else skip ; 
    return minOperations 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var matrix : Sequence(Sequence(int)) ; matrix := Sequence{Sequence{2,4,6},Sequence{8,10,12},Sequence{14,16,18},Sequence{20,22,24}} ;
     var n : int ; n := matrix->size() ;
    var m : int ; m := matrix[0+1]->size() ;
    var k : int ; k := 2 ;
    OclFile["System.out"].println(minOperations(n, m, k, matrix)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    w=scanner.nextInt();
    h=scanner.nextInt();
    map=new boolean[h+2][w+2];
    v=new boolean[h+2][w+2];
    for(int i=1 ; i<=h ; i++)for(int j=1 ; j<=w ; j++)map[i][j]=scanner.nextInt()==1 ;
    System.out.println(slove(0,0));
  }
  private int slove(int y,int x){
    v[y][x]=true ;
    int res=0 ;
    for(int i=0 ; i<6 ; i++){
      int ny=y+dy[i];
      int nx=x+(y % 2==1 ? dx1[i] : dx2[i]);
      if(! isOK(ny,nx))continue ;
      if(map[ny][nx]){
        res++;
        continue ;
      }
      if(v[ny][nx])continue ;
      res+=slove(ny,nx);
    }
    return res ;
  }
  private boolean isOK(int ny,int nx){
    if(0<=ny && ny<=h+1 && 0<=nx && nx<=w+1)return true ;
    return false ;
  }
  int h,w ;
  boolean[][] map ;
  boolean[][] v ;
  int[] dy={
-1,-1,0,0,1,1 };
    int[] dx1={
      0,1,-1,1,0,1 };
      int[] dx2={
-1,0,-1,1,-1,0 };
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     w := scanner.getCurrent()->toInteger() ; 
    h := scanner.getCurrent()->toInteger() ; 
    map := Integer.subrange(1,h + 2)->collect(Integer.subrange(1,w + 2)->collect(false)) ; 
    v := Integer.subrange(1,h + 2)->collect(Integer.subrange(1,w + 2)->collect(false)) ; 
        var i : int ; i := 1 ; while i <= h do (         var j : int ; j := 1 ; while j <= w do (     map[i+1][j+1] := scanner.getCurrent()->toInteger() = 1 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(slove(0, 0)) ; 
 );
   operation slove( y : int, x : int) : int
  pre: true
  post: true
  activity: (     v[y+1][x+1] := true ; 
     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < 6 do ( (     var ny : int ; ny := y + dy[i+1] ;
     var nx : int ; nx := x + (if y mod 2 = 1 then dx1[i+1] else dx2[i+1] endif) ;
    if (not(isOK(ny, nx))) then     continue else skip ; 
    if (map[ny+1][nx+1]) then (     res := res + 1 ; 
     continue ) else skip ; 
    if (v[ny+1][nx+1]) then     continue else skip ; 
    res := res+(slove(ny, nx)) ; 
 )  ;     i := i + 1 ) ; 
     return res );
   operation isOK( ny : int, nx : int) : boolean
  pre: true
  post: true
  activity: (     if (0 <= ny & ny <= h + 1 & 0 <= nx & nx <= w + 1) then     return true else skip ; 
     return false );
   attribute h : int;
   attribute map : Sequence(Sequence(boolean));
   attribute v : Sequence(Sequence(boolean));
   attribute dy : Sequence(int) := Sequence{-1,-1,0,0,1,1};
   attribute dx1 : Sequence(int) := Sequence{0,1,-1,1,0,1};
   attribute dx2 : Sequence(int) := Sequence{-1,0,-1,1,-1,0};
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import javax.naming.InitialContext ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int h=sc.nextInt();
    System.out.println((a+b)*h/2);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println((a + b) * h / 2) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    try {
      InputStreamReader isr=new InputStreamReader(System.in);
      BufferedReader br=new BufferedReader(isr);
      int a=Integer.parseInt(br.readLine());
      int b=Integer.parseInt(br.readLine());
      int h=Integer.parseInt(br.readLine());
      System.out.println((a+b)*h/2);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
    var a : int ; a := (br.readLine())->toInteger() ;
    var b : int ; b := (br.readLine())->toInteger() ;
    var h : int ; h := (br.readLine())->toInteger() ;
    OclFile["System.out"].println((a + b) * h / 2) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int a=scanner.nextInt();
    int b=scanner.nextInt();
    int h=scanner.nextInt();
    System.out.println((a+b)*h/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var h : int ; h := scanner.getCurrent()->toInteger() ;
    OclFile["System.out"].println((a + b) * h / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] daikeihen=new int[3];
    for(int i=0 ; i<=2 ; i++){
      daikeihen[i]=sc.nextInt();
    }
    System.out.println((daikeihen[0]+daikeihen[1])*daikeihen[2]/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var daikeihen : Sequence(int) ; daikeihen := Integer.subrange(1,3)->collect(0) ;
         var i : int ; i := 0 ; while i <= 2 do ( (     daikeihen[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println((daikeihen[0+1] + daikeihen[1+1]) * daikeihen[2+1] / 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String args[]){
    FastScanner input=new FastScanner();
    int tc=input.nextInt();
    work : while(tc-->0){
      int x=input.nextInt();
      int y=input.nextInt();
      if(y % x!=0){
        System.out.println("0 0");
      }
      else {
        System.out.println("1 "+(y/x));
      }
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var tc : int ; tc := input.nextInt() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var x : int ; x := input.nextInt() ;
     var y : int ; y := input.nextInt() ;
     if (y mod x /= 0) then (     OclFile["System.out"].println("0 0") ) else (     OclFile["System.out"].println("1 " + (y / x)) ) ) ;  ) ;  );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in);
){
      solve(sc);
    }
  }
  public static void solve(Scanner sc){
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    System.out.println(((a+b)*c)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     execute solve(sc) ))  );
  static   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(((a + b) * c) / 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  final static long MOD=1000000007 ;
  public static String[] Ws=null ;
  public static int wsIndx=0 ;
  public static BufferedReader in=null ;
  public static long cnt=0 ;
  public static void main(String[] args)throws Exception {
    solution(args);
    if(in!=null){
      in.close();
    }
  }
  public static void solution(String[] args)throws Exception {
    long N=nextLong();
    long K=nextLong();
    System.out.println((long)(K*Math.pow(K-1,N-1)));
  }
  public static void check()throws Exception {
    if(in==null){
      in=new BufferedReader(new InputStreamReader(System.in));
    }
    if(Ws==null || Ws.length<=wsIndx){
      Ws=in.readLine().split(" ");
      wsIndx=0 ;
    }
  }
  public static int nextInt()throws Exception {
    check();
    return Integer.parseInt(Ws[wsIndx++]);
  }
  public static long nextLong()throws Exception {
    check();
    return Long.parseLong(Ws[wsIndx++]);
  }
  public static String nextString()throws Exception {
    check();
    return Ws[wsIndx++];
  }
  public static int[] nextInts()throws Exception {
    check();
    int[] tmp=new int[Ws.length];
    for(int i=0 ; i<tmp.length ; i++){
      tmp[i]=Integer.parseInt(Ws[i]);
    }
    wsIndx=Ws.length ;
    return tmp ;
  }
  public static long[] nextLongs()throws Exception {
    check();
    long[] tmp=new long[Ws.length];
    for(int i=0 ; i<tmp.length ; i++){
      tmp[i]=Long.parseLong(Ws[i]);
    }
    wsIndx=Ws.length ;
    return tmp ;
  }
  public static String[] nextStrings()throws Exception {
    check();
    wsIndx=Ws.length ;
    return Ws ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : long := 1000000007;
  static   attribute Ws : Sequence(String) := null;
  static   attribute wsIndx : int := 0;
  static   attribute in : OclFile := null;
  static   attribute cnt : long := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solution(args) ; 
     if (in /= null) then (     skip ) else skip );
  static   operation solution( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := nextLong() ;
     var K : long ; K := nextLong() ;
     OclFile["System.out"].println((K * K - 1->pow(N - 1))->oclAsType(long)) );
  static   operation check() : void
  pre: true
  post: true
  activity: (     if (in = null) then (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ) else skip ; 
     if (Ws = null or Ws->size() <= wsIndx) then (     Ws := in.readLine()->split(" ") ; 
     wsIndx := 0 ) else skip );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     execute check() ; 
     return (Ws[wsIndx+1])->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     execute check() ; 
     return (Ws[wsIndx+1])->toLong() );
  static   operation nextString() : String
  pre: true
  post: true
  activity: (     execute check() ; 
     return Ws[wsIndx+1] );
  static   operation nextInts() : Sequence(int)
  pre: true
  post: true
  activity: (     execute check() ; 
     var tmp : Sequence(int) ; tmp := Integer.subrange(1,Ws->size())->collect(0) ;
        var i : int ; i := 0 ; while i < tmp->size() do ( (     tmp[i+1] := (Ws[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    wsIndx := Ws->size() ; 
    return tmp 
 );
  static   operation nextLongs() : Sequence(long)
  pre: true
  post: true
  activity: (     execute check() ; 
     var tmp : Sequence(long) ; tmp := Integer.subrange(1,Ws->size())->collect(0) ;
        var i : int ; i := 0 ; while i < tmp->size() do ( (     tmp[i+1] := (Ws[i+1])->toLong() )  ;     i := i + 1 ) ; 
    wsIndx := Ws->size() ; 
    return tmp 
 );
  static   operation nextStrings() : Sequence(String)
  pre: true
  post: true
  activity: (     execute check() ; 
     wsIndx := Ws->size() ; 
     return Ws );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    long N=input.nextLong();
    long K=input.nextLong();
    long ans=K ;
    K--;
    N--;
    for(long ball=1 ; ball<=N ; ball++){
      ans*=K ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := input.getCurrent()->toLong() ;
    var K : long ; K := input.getCurrent()->toLong() ;
    var ans : long ; ans := K ;
    K := K - 1 ; 
    N := N - 1 ; 
        var ball : long ; ball := 1 ; while ball <= N do ( (     ans := ans*(K) )  ;     ball := ball + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    int n=sc.nextInt();
    int k=sc.nextInt();
    int result=0 ;
    result=((int)Math.pow(k-1,n-1))*k ;
    System.out.println(result);
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var result : int ; result := 0 ;
    result := (k - 1->pow(n - 1)->oclAsType(int)) * k ; 
    OclFile["System.out"].println(result) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public 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());
    }
  }
  public static void main(String[] args){
    FastReader ob=new FastReader();
    int n=ob.nextInt(),k=ob.nextInt();
    long ways=k ;
    n--;
    while(n>0){
      ways*=k-1 ;
      n--;
    }
    System.out.println(ways);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ob : FastReader ; ob := FastReader.newFastReader() ;
     var n : int ; n := ob.nextInt() ;
    var k : int ; k := ob.nextInt() ;
    var ways : long ; ways := k ;
    n := n - 1 ; 
    while (n > 0) do (     ways := ways*(k - 1) ; 
     n := n - 1 ) ; 
    OclFile["System.out"].println(ways) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static int gyo,retu ;
  public static int[][] dx={
    {
      1,0,-1,0,-1,-1 },{
        1,0,-1,0,1,1 }
      };
      public static int[][] dy={
        {
          0,1,0,-1,1,-1 },{
            0,1,0,-1,-1,1 }
          };
          public static int[][] map=new int[105][105];
          public static void main(String[] args){
            Scanner in=new Scanner(System.in);
            retu=in.nextInt();
            gyo=in.nextInt();
            for(int i=0 ; i<=gyo+1 ; i++){
              for(int j=0 ; j<=retu+1 ; j++)map[i][j]=0 ;
            }
            for(int i=1 ; i<=gyo ; i++){
              for(int j=1 ; j<=retu ; j++)map[i][j]=in.nextInt();
            }
            System.out.println(dfs(0,0));
          }
          public static int dfs(int x,int y){
            map[y][x]=9 ;
            int nx,ny,ans=0 ;
            for(int i=0 ; i<6 ; i++){
              nx=x+dx[y % 2][i];
              ny=y+dy[y % 2][i];
              if(nx>retu+1 || ny>gyo+1 || nx<0 || ny<0)continue ;
              if(map[ny][nx]==1)ans++;
              else if(map[ny][nx]==0)ans+=dfs(nx,ny);
            }
            return ans ;
          }
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute gyo : int;
  static   attribute dx : Sequence(Sequence(int)) := Sequence{Sequence{1,0,-1,0,-1,-1},Sequence{1,0,-1,0,1,1}};
  static   attribute dy : Sequence(Sequence(int)) := Sequence{Sequence{0,1,0,-1,1,-1},Sequence{0,1,0,-1,-1,1}};
  static   attribute map : Sequence(Sequence(int)) := Integer.subrange(1,105)->collect(Integer.subrange(1,105)->collect(0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     retu := in.getCurrent()->toInteger() ; 
    gyo := in.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i <= gyo + 1 do ( (         var j : int ; j := 0 ; while j <= retu + 1 do (     map[i+1][j+1] := 0 ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= gyo do ( (         var j : int ; j := 1 ; while j <= retu do (     map[i+1][j+1] := in.getCurrent()->toInteger() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dfs(0, 0)) ; 
 );
  static   operation dfs( x : int, y : int) : int
  pre: true
  post: true
  activity: (     map[y+1][x+1] := 9 ; 
     var nx : int ;
    var ny : int ;
    var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < 6 do ( (     nx := x + dx[y mod 2+1][i+1] ; 
     ny := y + dy[y mod 2+1][i+1] ; 
     if (nx > retu + 1 or ny > gyo + 1 or nx < 0 or ny < 0) then     continue else skip ; 
     if (map[ny+1][nx+1] = 1) then     ans := ans + 1 ; else     if (map[ny+1][nx+1] = 0) then     ans := ans+(dfs(nx, ny)) ; else skip ; )  ;     i := i + 1 ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    String[] inputs=input.readLine().split(" ");
    int N=Integer.parseInt(inputs[0]);
    int K=Integer.parseInt(inputs[1]);
    long answer=K ;
    for(int i=1 ; i<N ; i++){
      answer=answer*(K-1);
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var inputs : Sequence(String) ; inputs := input.readLine()->split(" ") ;
    var N : int ; N := (inputs[0+1])->toInteger() ;
    var K : int ; K := (inputs[1+1])->toInteger() ;
    var answer : long ; answer := K ;
        var i : int ; i := 1 ; while i < N do ( (     answer := answer * (K - 1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean ispower(long n){
    if(n<125){
      return(n==1 || n==5 || n==25);
    }
    if(n % 125!=0){
      return false ;
    }
    else {
      return ispower(n/125);
    }
  }
  static long number(String s,int i,int j){
    long ans=0 ;
    for(int x=i ; x<j ; x++){
      ans=ans*2+(s.charAt(x)-'0');
    }
    return ans ;
  }
  static int minCuts(String s,int n){
    int[] dp=new int[n+1];
    Arrays.fill(dp,n+1);
    dp[0]=0 ;
    for(int i=1 ; i<=n ; i++){
      if(s.charAt(i-1)=='0'){
        continue ;
      }
      for(int j=0 ; j<i ; j++){
        if(s.charAt(j)=='0'){
          continue ;
        }
        long num=number(s,j,i);
        if(! ispower(num)){
          continue ;
        }
        dp[i]=Math.min(dp[i],dp[j]+1);
      }
    }
    return((dp[n]<n+1)? dp[n] :-1);
  }
  public static void main(String[] args){
    String s="101101101" ;
    int n=s.length();
    System.out.println(minCuts(s,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation ispower( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n < 125) then (     return (n = 1 or n = 5 or n = 25) ) else skip ; 
     if (n mod 125 /= 0) then (     return false ) else (     return ispower(n / 125) ) );
  static   operation number( s : String, i : int, j : int) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
         var x : int ; x := i ; while x < j do ( (     ans := ans * 2 + (s->at(x+1) - ('0')->char2byte()) )  ;     x := x + 1 ) ; 
     return ans );
  static   operation minCuts( s : String, n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
     dp := dp->collect(n + 1) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (s->at(i - 1+1) = '0') then (     continue ) else skip ; 
         var j : int ; j := 0 ; while j < i do ( (     if (s->at(j+1) = '0') then (     continue ) else skip ; 
     var num : long ; num := number(s, j, i) ;
     if (not(ispower(num))) then (     continue ) else skip ; 
     dp[i+1] := Set{dp[i+1], dp[j+1] + 1}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return (if (dp[n+1] < n + 1) then dp[n+1] else -1 endif) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "101101101" ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].println(minCuts(s, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int gcd(int a,int b){
    if(b==0)return a ;
    return(gcd(b,a % b));
  }
  static void findSmallest(int a,int b){
    int lcm=(a*b)/gcd(a,b);
    System.out.print("x="+lcm/a+"\ny="+lcm/b);
  }
  public static void main(String[] args){
    int a=25,b=35 ;
    findSmallest(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return (gcd(b, a mod b)) );
  static   operation findSmallest( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var lcm : int ; lcm := (a * b) / gcd(a, b) ;
     OclFile["System.out"].print("x=" + lcm / a + "\ny=" + lcm / b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 25 ;
    var b : int ; b := 35 ;
     execute findSmallest(a, b) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    StringBuilder s=new StringBuilder(in.nextLine());
    StringBuilder s1=new StringBuilder();
    int len=s.length();
    for(int i=0 ; i<len ; i++){
      if(s.charAt(i)=='r'){
        s1.append(i+1+"\n");
      }
    }
    for(int i=len-1 ; i>=0 ; i--){
      if(s.charAt(i)=='l'){
        s1.append(i+1+"\n");
      }
    }
    System.out.print(s1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := StringLib.newString(in.nextLine()) ;
    var s1 : String ; s1 := StringLib.newString() ;
    var len : int ; len := s->size() ;
        var i : int ; i := 0 ; while i < len do ( (     if (s->at(i+1) = 'r') then (     s1 := s1 + StringLib.newString(i + 1 + "\n") ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := (len)->char2byte() - 1 ; while i >= 0 do ( (     if (s->at(i+1) = 'l') then (     s1 := s1 + StringLib.newString(i + 1 + "\n") ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].print(s1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] c=new int[n];
    for(int i=0 ; i<n ; i++)c[i]=sc.nextInt();
    int[] a=new int[m];
    for(int i=0 ; i<m ; i++)a[i]=sc.nextInt();
    int index=0 ;
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(index<m){
        if(a[index]>=c[i]){
          ans++;
          index++;
        }
      }
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     c[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var index : int ; index := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (index < m) then (     if (a[index+1] >= c[i+1]) then (     ans := ans + 1 ; 
     index := index + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class NumberTransformation {
  public static PrintWriter out ;
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner();
    out=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int x=sc.nextInt();
      int y=sc.nextInt();
      boolean ans=false ;
      if(y<x){
        out.println(0+" "+0);
        continue ;
      }
      else if(y==x){
        out.println(1+" "+1);
        continue ;
      }
      for(int i=2 ; i<=100 ; i++){
        int temp=x ;
        int count=0 ;
        while(temp<y){
          temp*=i ;
          count++;
        }
        if(temp==y){
          out.println(count+" "+i);
          ans=true ;
          break ;
        }
      }
      if(! ans){
        out.println(0+" "+0);
      }
    }
    out.close();
  }
  public static class Scanner {
    BufferedReader br ;
    StringTokenizer st ;
    public Scanner(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NumberTransformation {
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := (arguments ( )) ;
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var ans : boolean ; ans := false ;
    if (y < x) then (     skip ; 
     continue ) else     if (y = x) then (     skip ; 
     continue ) else skip ; ;  
        var i : int ; i := 2 ; while i <= 100 do ( (     var temp : int ; temp := x ;
     var count : int ; count := 0 ;
     while (temp < y) do (     temp := temp*(i) ; 
     count := count + 1 ) ; 
     if (temp = y) then (     skip ; 
     ans := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (not(ans)) then (     skip ) else skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newScanner() : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class GameShopping {
  public static void main(String[] args){
    Scanner sn=new Scanner(System.in);
    int n=sn.nextInt();
    int m=sn.nextInt();
    sn.nextLine();
    String costs[]=sn.nextLine().split(" ");
    String monies[]=sn.nextLine().split(" ");
    int c[]=new int[n];
    int w[]=new int[m];
    for(int i=0 ; i<costs.length ; i++){
      c[i]=Integer.parseInt(costs[i]);
    }
    for(int i=0 ; i<m ; i++){
      w[i]=Integer.parseInt(monies[i]);
    }
    int pointer=0 ;
    for(int i=0 ; i<n ; i++){
      if(w[pointer]>=c[i]){
        pointer++;
        if(pointer==m){
          break ;
        }
      }
    }
    System.out.println(pointer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GameShopping {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sn : OclFile ; sn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sn.getCurrent()->toInteger() ;
    var m : int ; m := sn.getCurrent()->toInteger() ;
    skip ; 
    var costs : Sequence(String) ; costs := sn.nextLine()->split(" ") ;
    var monies : Sequence(String) ; monies := sn.nextLine()->split(" ") ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    var w : Sequence(int) ; w := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < costs->size() do ( (     c[i+1] := (costs[i+1])->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     w[i+1] := (monies[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var pointer : int ; pointer := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (w[pointer+1] >= c[i+1]) then (     pointer := pointer + 1 ; 
     if (pointer = m) then (     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(pointer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] a=new int[n];
    int[] b=new int[m];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    for(int i=0 ; i<m ; i++){
      b[i]=sc.nextInt();
    }
    int x=0,count=0 ;
    for(int i=0 ; i<n ; i++){
      if(x<m && a[i]<=b[x]){
        count++;
        x++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var x : int ; x := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (x < m & a[i+1] <= b[x+1]) then (     count := count + 1 ; 
     x := x + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int productAtKthLevel(String tree,int k){
    int level=-1 ;
    int product=1 ;
    int n=tree.length();
    for(int i=0 ; i<n ; i++){
      if(tree.charAt(i)=='(')level++;
      else if(tree.charAt(i)==')')level--;
      else {
        if(level==k)product*=(tree.charAt(i)-'0');
      }
    }
    return product ;
  }
  public static void main(String[] args){
    String tree="(0(5(6()())(4()(9()())))(7(1()())(3()())))" ;
    int k=2 ;
    System.out.println(productAtKthLevel(tree,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation productAtKthLevel( tree : String, k : int) : int
  pre: true
  post: true
  activity: (     var level : int ; level := -1 ;
     var product : int ; product := 1 ;
    var n : int ; n := tree->size() ;
        var i : int ; i := 0 ; while i < n do ( (     if (tree->at(i+1) = '(') then     level := level + 1 ; else     if (tree->at(i+1) = ')') then     level := level - 1 else (     if (level = k) then     product := product*((tree->at(i+1) - ('0')->char2byte())) ; else skip ) ;  )  ;     i := i + 1 ) ; 
    return product 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var tree : String ; tree := "(0(5(6()())(4()(9()())))(7(1()())(3()())))" ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(productAtKthLevel(tree, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int factorial(int n){
    if(n==0)return 1 ;
    return n*factorial(n-1);
  }
  static int countNum(int n){
    if(n>10)return 0 ;
    return(9*factorial(9)/factorial(10-n));
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(countNum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation factorial( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     return n * factorial(n - 1) );
  static   operation countNum( n : int) : int
  pre: true
  post: true
  activity: (     if (n > 10) then     return 0 else skip ; 
     return (9 * factorial(9) / factorial(10 - n)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(countNum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static int gyo,retu ;
  public static int[][] dx={
    {
      1,0,-1,0,-1,-1 },{
        1,0,-1,0,1,1 }
      };
      public static int[][] dy={
        {
          0,1,0,-1,1,-1 },{
            0,1,0,-1,-1,1 }
          };
          public static int[][] map=new int[105][105];
          public static void main(String[] args){
            Scanner in=new Scanner(System.in);
            retu=in.nextInt();
            gyo=in.nextInt();
            for(int i=0 ; i<=gyo+1 ; i++){
              for(int j=0 ; j<=retu+1 ; j++)map[i][j]=0 ;
            }
            for(int i=1 ; i<=gyo ; i++){
              for(int j=1 ; j<=retu ; j++)map[i][j]=in.nextInt();
            }
            System.out.println(dfs(0,0));
          }
          public static int dfs(int x,int y){
            map[y][x]=9 ;
            int nx,ny,ans=0 ;
            for(int i=0 ; i<6 ; i++){
              nx=x+dx[y % 2][i];
              ny=y+dy[y % 2][i];
              if(nx>retu+1 || ny>gyo+1 || nx<0 || ny<0)continue ;
              if(map[ny][nx]==1)ans++;
              else if(map[ny][nx]==0)ans+=dfs(nx,ny);
            }
            return ans ;
          }
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute gyo : int;
  static   attribute dx : Sequence(Sequence(int)) := Sequence{Sequence{1,0,-1,0,-1,-1},Sequence{1,0,-1,0,1,1}};
  static   attribute dy : Sequence(Sequence(int)) := Sequence{Sequence{0,1,0,-1,1,-1},Sequence{0,1,0,-1,-1,1}};
  static   attribute map : Sequence(Sequence(int)) := Integer.subrange(1,105)->collect(Integer.subrange(1,105)->collect(0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     retu := in.getCurrent()->toInteger() ; 
    gyo := in.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i <= gyo + 1 do ( (         var j : int ; j := 0 ; while j <= retu + 1 do (     map[i+1][j+1] := 0 ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= gyo do ( (         var j : int ; j := 1 ; while j <= retu do (     map[i+1][j+1] := in.getCurrent()->toInteger() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dfs(0, 0)) ; 
 );
  static   operation dfs( x : int, y : int) : int
  pre: true
  post: true
  activity: (     map[y+1][x+1] := 9 ; 
     var nx : int ;
    var ny : int ;
    var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < 6 do ( (     nx := x + dx[y mod 2+1][i+1] ; 
     ny := y + dy[y mod 2+1][i+1] ; 
     if (nx > retu + 1 or ny > gyo + 1 or nx < 0 or ny < 0) then     continue else skip ; 
     if (map[ny+1][nx+1] = 1) then     ans := ans + 1 ; else     if (map[ny+1][nx+1] = 0) then     ans := ans+(dfs(nx, ny)) ; else skip ; )  ;     i := i + 1 ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    HashMap<Integer,Integer>A=new HashMap<Integer,Integer>();
    int N=stdIn.nextInt();
    int a[]=new int[N];
    int z=0,y=0,x=0,v=0,ans=0 ;
    while(z<N){
      y=stdIn.nextInt();
      if(A.containsKey(y))x=A.get(y);
      else {
        a[v]=y ;
        v++;
      }
      A.put(y,x+1);
      x=0 ;
      z++;
    }
    z=0 ;
    while(z<v){
      if(A.containsKey(a[z])){
        x=A.get(a[z]);
        if(x!=0 && x!=a[z])if(x>a[z])ans+=x-a[z];
        else ans+=x ;
      }
      z++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : Map(int,int) ; A := Map{} ;
    var N : int ; N := stdIn.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var z : int ; z := 0 ;
    var y : int ; y := 0 ;
    var x : int ; x := 0 ;
    var v : int ; v := 0 ;
    var ans : int ; ans := 0 ;
    while (z < N) do (     y := stdIn.getCurrent()->toInteger() ; 
     if (A->keys()->includes(y)) then     x := A->at(y) else (     a[v+1] := y ; 
     v := v + 1 ) ;  
    A := A->union(Map{y |-> x + 1}) ; 
    x := 0 ; 
    z := z + 1 ; 
 ) ; 
    z := 0 ; 
    while (z < v) do (     if (A->keys()->includes(a[z+1])) then (     x := A->at(a[z+1]) ; 
     if (x /= 0 & x /= a[z+1]) then     if (x > a[z+1]) then     ans := ans+(x - a[z+1]) else     ans := ans+(x) ; ;  else skip ) else skip ; 
     z := z + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  InputStream in=System.in ;
  PrintStream out=System.out ;
  public void _main(String[] args){
    Scanner sc=new Scanner(in);
    int N=sc.nextInt();
    int[] a=nextIntArray(sc,N);
    sc.close();
    Arrays.sort(a);
    int ans=0 ;
    int p=0 ;
    while(p<N){
      int x=a[p];
      int q=p+1 ;
      while(q<N && a[q]==x){
        q++;
      }
      if(q<0){
        q=(-q)-1 ;
      }
      if(x>q-p){
        ans+=(q-p);
      }
      else if(x<q-p){
        ans+=(q-p)-x ;
      }
      p=q ;
    }
    out.println(ans);
  }
  public static void main(String[] args){
    new Main()._main(args);
  }
  @ SuppressWarnings("unused")private int[] nextIntArray(Scanner sc,int n){
    int[] result=new int[n];
    for(int i=0 ; i<n ; i++){
      result[i]=sc.nextInt();
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile["System.in"];
   attribute out : OclFile := OclFile["System.out"];
   operation _main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := nextIntArray(sc, N) ;
    skip ; 
    a := a->sort() ; 
    var ans : int ; ans := 0 ;
    var p : int ; p := 0 ;
    while (p < N) do (     var x : int ; x := a[p+1] ;
     var q : int ; q := p + 1 ;
    while (q < N & a[q+1] = x) do (     q := q + 1 ) ; 
    if (q < 0) then (     q := (-q) - 1 ) else skip ; 
    if (x > q - p) then (     ans := ans+((q - p)) ) else     if (x < q - p) then (     ans := ans+((q - p) - x) ) else skip ; ;  
    p := q ; 
 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain()._main(args) );
      operation nextIntArray( sc : OclFile, n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var result : Sequence(int) ; result := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     result[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  static int N ;
  static HashMap<Integer,Integer>a ;
  private static void init(){
    Scanner scanner=new Scanner(System.in);
    N=scanner.nextInt();
    a=new HashMap<>();
    for(int i=0 ; i<N ; i++){
      int number=scanner.nextInt();
      if(a.containsKey(number)){
        Integer c=a.get(number);
        c++;
        a.put(number,c);
      }
      else {
        a.put(number,1);
      }
    }
    scanner.close();
  }
  public static void main(String args[]){
    init();
    int count=0 ;
    for(Integer i : a.keySet()){
      if(a.get(i)<i){
        count+=a.get(i);
      }
      else if(a.get(i)>i){
        count+=Math.abs(i-a.get(i));
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute a : Map(int,int);
  static   operation init() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := scanner.getCurrent()->toInteger() ; 
    a := Map{} ; 
        var i : int ; i := 0 ; while i < N do ( (     var number : int ; number := scanner.getCurrent()->toInteger() ;
     if (a->keys()->includes(number)) then (     var c : int ; c := a->at(number) ;
     c := c + 1 ; 
     a := a->union(Map{number |-> c}) ) else (     a := a->union(Map{number |-> 1}) ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute init() ; 
     var count : int ; count := 0 ;
     for (i : a->keys()) do ( (     if (a->at(i) < i) then (     count := count+(a->at(i)) ) else     if (a->at(i) > i) then (     count := count+(if i - a->at(i) < 0 then -(i - a->at(i)) else i - a->at(i) endif) ) else skip ; )  ) ; 
     OclFile["System.out"].println(count) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    Queue<Long>OVER=new LinkedList<Long>();
    PriorityQueue<Long>A=new PriorityQueue<Long>();
    for(int i=0 ; i<N ; i++){
      Long temp=sc.nextLong();
      if(temp<=Math.pow(10,5))A.add(temp);
      else OVER.add(temp);
    }
    sc.close();
    if(A.isEmpty())System.out.println(OVER.size());
    else {
      int size=A.size();
      long count=0 ;
      int ans=0 ;
      while(A.isEmpty()!=true){
        count=1 ;
        long temp=A.poll();
        while(A.isEmpty()!=true && A.peek()==temp){
          A.poll();
          count++;
        }
        if(temp>count)ans+=count ;
        else if(temp<count)ans+=(count-temp);
      }
      System.out.println(OVER.size()+ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var OVER : Sequence(long) ; OVER := Sequence{} ;
    var A : Sequence(long) ; A := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var temp : long ; temp := sc.getCurrent()->toLong() ;
     if (temp <= 10->pow(5)) then     A := A->including(temp) ; else     OVER := OVER->including(temp) ; )  ;     i := i + 1 ) ; 
    skip ; 
    if (A->isEmpty()) then     OclFile["System.out"].println(OVER->size()) else (     var size : int ; size := A->size() ;
     var count : long ; count := 0 ;
    var ans : int ; ans := 0 ;
    while (A->isEmpty() /= true) do (     count := 1 ; 
     var temp : long ; temp := A->min() ;
     while (A->isEmpty() /= true & A->min() = temp) do (     A := A->sort()->tail() ; 
     count := count + 1 ) ; 
     if (temp > count) then     ans := ans+(count) ; else     if (temp < count) then     ans := ans+((count - temp)) ; else skip ; ) ; 
    OclFile["System.out"].println(OVER->size() + ans) ; 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Map<Integer,Integer>map=new HashMap<Integer,Integer>();
    Scanner scanner=new Scanner(System.in);
    int len=Integer.parseInt(scanner.nextLine());
    for(int i=0 ; i<len ; i++){
      int n=scanner.nextInt();
      if(map.get(n)==null){
        map.put(n,1);
      }
      else {
        map.put(n,map.get(n)+1);
      }
    }
    int ans=0 ;
    java.util.List<Integer>list=map.keySet().stream().filter(key->map.get(key)-key!=0).collect(Collectors.toList());
    for(Integer i : list){
      int n=map.get(i);
      if(n>i){
        ans+=n-i ;
      }
      else {
        ans+=n ;
      }
    }
    System.out.println(ans);
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var map : Map(int,int) ; map := Map{} ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var len : int ; len := (scanner.nextLine())->toInteger() ;
        var i : int ; i := 0 ; while i < len do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (map->at(n) = null) then (     map := map->union(Map{n |-> 1}) ) else (     map := map->union(Map{n |-> map->at(n) + 1}) ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var list : List<int> ; list := map->keys()->select( _x1 | (lambda key : OclAny in map->at(key) - key /= 0)->apply(_x1) ).collect(Collectors.toList()) ;
    for (i : list) do ( (     var n : int ; n := map->at(i) ;
     if (n > i) then (     ans := ans+(n - i) ) else (     ans := ans+(n) ) )  ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    for(int i=0 ; i<n ; i++){
      String a=stdIn.next();
      char[] b=new char[10];
      b=a.toCharArray();
      Arrays.sort(b);
      String c=String.valueOf(b);
      int min=Integer.parseInt(c);
      int max=0 ;
      for(int j=0 ; j<8 ; j++){
        max*=10 ;
        max+=b[7-j]-'0' ;
      }
      System.out.println(max-min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : String ; a := stdIn.getCurrent() ;
     var b : Sequence(String) ; b := Integer.subrange(1,10)->collect(0) ;
    b := a->characters() ; 
    b := b->sort() ; 
    var c : String ; c := (b)->sum()  ;
    var min : int ; min := (c)->toInteger() ;
    var max : int ; max := 0 ;
        var j : int ; j := 0 ; while j < 8 do ( (     max := max*(10) ; 
     max := max+(b[7 - j+1] - ('0')->char2byte()) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(max - (min)->char2byte()) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      String s=input.next();
      long ans=n ;
      for(int i=1 ; i<s.length(); i++){
        if(s.charAt(i)!=s.charAt(i-1)){
          ans+=(i);
        }
      }
      System.out.println(ans);
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var tc : int ; tc := input.nextInt() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.nextInt() ;
     var s : String ; s := input.next() ;
    var ans : long ; ans := n ;
        var i : int ; i := 1 ; while i < s->size() do ( (     if (s->at(i+1) /= s->at(i - 1+1)) then (     ans := ans+((i)) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) ;  );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static List<Integer>henkan(String n){
    List<Integer>m=new ArrayList<Integer>();
    for(int i=0 ; i<n.length(); i++)m.add(Integer.parseInt(n.charAt(i)+""));
    return m ;
  }
  static int big(List<Integer>m){
    String a="" ;
    Collections.sort(m);
    for(int s=m.size()-1 ; s>=0 ; s--)a+=m.get(s);
    return Integer.parseInt(a);
  }
  static int small(List<Integer>m){
    String a="" ;
    Collections.sort(m);
    for(int s=0 ; s<m.size(); s++)a+=m.get(s);
    return Integer.parseInt(a);
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    for(int k=0 ; k<n ; k++){
      String input=in.next();
      List<Integer>m=henkan(input);
      System.out.println(big(m)-small(m));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation henkan( n : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var m : Sequence(int) ; m := Sequence{} ;
         var i : int ; i := 0 ; while i < n->size() do (     m := m->including((n->at(i+1) + "")->toInteger()) ;  ;     i := i + 1 ) ; 
     return m );
  static   operation big( m : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var a : String ; a := "" ;
     m := m->sort() ; 
         var s : int ; s := m->size() - 1 ; while s >= 0 do (     a := a+(m->at(s+1)) ;  ;     s := s - 1 ) ; 
     return (a)->toInteger() );
  static   operation small( m : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var a : String ; a := "" ;
     m := m->sort() ; 
         var s : int ; s := 0 ; while s < m->size() do (     a := a+(m->at(s+1)) ;  ;     s := s + 1 ) ; 
     return (a)->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         var k : int ; k := 0 ; while k < n do ( (     var input : String ; input := in.getCurrent() ;
     var m : Sequence(int) ; m := henkan(input) ;
     OclFile["System.out"].println(big(m) - small(m)) )  ;     k := k + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(input.readLine());
    for(int i=0 ; i<n ; i++){
      String str=input.readLine();
      int a[]=new int[8];
      int b[]=new int[8];
      for(int j=0 ; j<8 ; j++){
        a[j]=Integer.parseInt(str.charAt(j)+"");
        b[j]=Integer.parseInt(str.charAt(j)+"");
      }
      for(int j=0 ; j<8 ; j++){
        for(int k=7 ; j<k ; k--){
          if(a[k-1]>a[k]){
            int tmp=a[k-1];
            a[k-1]=a[k];
            a[k]=tmp ;
          }
          if(b[k-1]<b[k]){
            int tmp=b[k-1];
            b[k-1]=b[k];
            b[k]=tmp ;
          }
        }
      }
      long sumb=0,suma=0 ;
      for(int j=0 ; j<8 ; j++){
        sumb+=b[j]*((int)(Math.pow(10,7-j)));
        if(a[j]==0)continue ;
        suma+=a[j]*((int)(Math.pow(10,7-j)));
      }
      System.out.println(sumb-suma);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (input.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := input.readLine() ;
     var a : Sequence(int) ; a := Integer.subrange(1,8)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,8)->collect(0) ;
        var j : int ; j := 0 ; while j < 8 do ( (     a[j+1] := (str->at(j+1) + "")->toInteger() ; 
     b[j+1] := (str->at(j+1) + "")->toInteger() )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < 8 do ( (         var k : int ; k := 7 ; while j < k do ( (     if (a[k - 1+1] > a[k+1]) then (     var tmp : int ; tmp := a[k - 1+1] ;
     a[k - 1+1] := a[k+1] ; 
     a[k+1] := tmp ) else skip ; 
     if (b[k - 1+1] < b[k+1]) then (     var tmp : int ; tmp := b[k - 1+1] ;
     b[k - 1+1] := b[k+1] ; 
     b[k+1] := tmp ) else skip )  ;     k := k - 1 ) )  ;     j := j + 1 ) ; 
    var sumb : long ; sumb := 0 ;
    var suma : long ; suma := 0 ;
        var j : int ; j := 0 ; while j < 8 do ( (     sumb := sumb+(b[j+1] * ((10->pow(7 - j))->oclAsType(int))) ; 
     if (a[j+1] = 0) then     continue else skip ; 
     suma := suma+(a[j+1] * ((10->pow(7 - j))->oclAsType(int))) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(sumb - suma) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static char[] ns=new char[8];
  public static char[] perm=new char[8];
  public static boolean[] used=new boolean[8];
  public static int max,min ;
  public static void main(String[] args)throws java.io.IOException {
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    scan.nextLine();
    for(int i=0 ; i<n ; i++){
      ns=scan.nextLine().toCharArray();
      max=0 ;
      min=99999999 ;
      permutation(0,8);
      System.out.println(max-min);
    }
  }
  public static void permutation(int pos,int n){
    if(pos==n){
      StringBuilder sb=new StringBuilder();
      for(int i=0 ; i<n ; i++){
        sb.append(perm[i]);
      }
      max=Math.max(max,Integer.parseInt(sb.toString()));
      min=Math.min(min,Integer.parseInt(sb.toString()));
      return ;
    }
    for(int i=0 ; i<n ; i++){
      if(! used[i]){
        perm[pos]=ns[i];
        used[i]=true ;
        permutation(pos+1,n);
        used[i]=false ;
      }
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ns : Sequence(String) := Integer.subrange(1,8)->collect(0);
  static   attribute perm : Sequence(String) := Integer.subrange(1,8)->collect(0);
  static   attribute used : Sequence(boolean) := Integer.subrange(1,8)->collect(false);
  static   attribute max : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
     skip ; 
         var i : int ; i := 0 ; while i < n do ( (     ns := scan.nextLine()->characters() ; 
     max := 0 ; 
    min := 99999999 ; 
    execute permutation(0, 8) ; 
    OclFile["System.out"].println(max - min) ; 
 )  ;     i := i + 1 ) );
  static   operation permutation( pos : int, n : int) : void
  pre: true
  post: true
  activity: (     if (pos = n) then (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < n do ( (     sb := sb + StringLib.newString(perm[i+1]) )  ;     i := i + 1 ) ; 
    max := Set{max, (sb+"")->toInteger()}->max() ; 
    min := Set{min, (sb+"")->toInteger()}->min() ; 
    return 
 ) else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     if (not(used[i+1])) then (     perm[pos+1] := ns[i+1] ; 
     used[i+1] := true ; 
     execute permutation(pos + 1, n) ; 
     used[i+1] := false ) else skip )  ;     i := i + 1 ) ; 
     return );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.util.ArrayDeque ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int[] DX1=new int[] {
-1,1,0,1,0,1 };
    static int[] DX2=new int[] {
-1,1,0,-1,0,-1 };
      static int[] DY=new int[] {
        0,0,1,1,-1,-1 };
        public static void main(String[] args){
          int W=sc.nextInt();
          int H=sc.nextInt();
          boolean[][] m=new boolean[H+2][W+2];
          for(int i=0 ; i<H ; ++i){
            for(int j=0 ; j<W ; ++j){
              m[i+1][j+1]=sc.next().charAt(0)=='1' ;
            }
          }
          int ans=0 ;
          Queue<Point>q=new ArrayDeque<Point>();
          q.add(new Point(0,0));
          boolean[][] visited=new boolean[H+2][W+2];
          while(! q.isEmpty()){
            Point p=q.poll();
            int[] DX=p.y % 2!=0 ? DX1 : DX2 ;
            for(int i=0 ; i<6 ; ++i){
              int nx=p.x+DX[i];
              int ny=p.y+DY[i];
              if(nx<0 || W+1<nx || ny<0 || H+1<ny || visited[ny][nx])continue ;
              if(m[ny][nx]){
++ans ;
                continue ;
              }
              q.add(new Point(nx,ny));
              visited[ny][nx]=true ;
            }
          }
          System.out.println(ans);
        }
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute DX1 : Sequence(int) := Sequence{-1,1,0,1,0,1};
  static   attribute DX2 : Sequence(int) := Sequence{-1,1,0,-1,0,-1};
  static   attribute DY : Sequence(int) := Sequence{0,0,1,1,-1,-1};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var W : int ; W := sc.getCurrent()->toInteger() ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var m : Sequence(Sequence(boolean)) ; m := Integer.subrange(1,H + 2)->collect(Integer.subrange(1,W + 2)->collect(false)) ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     m[i + 1+1][j + 1+1] := sc.getCurrent()->at(0+1) = '1' )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var q : Sequence(Point) ; q := ArrayDeque<Point>.newArrayDeque() ;
    q := q->including(Point.newPoint(0, 0)) ; 
    var visited : Sequence(Sequence(boolean)) ; visited := Integer.subrange(1,H + 2)->collect(Integer.subrange(1,W + 2)->collect(false)) ;
    while (not(q->isEmpty())) do (     var p : Point ; p := q->min() ;
     var DX : Sequence(int) ; DX := if p.y mod 2 /= 0 then DX1 else DX2 endif ;
         var i : int ; i := 0 ; while i < 6 do ( (     var nx : int ; nx := p.x + DX[i+1] ;
     var ny : int ; ny := p.y + DY[i+1] ;
    if (nx < 0 or W + 1 < nx or ny < 0 or H + 1 < ny or visited[ny+1][nx+1]) then     continue else skip ; 
    if (m[ny+1][nx+1]) then (     ans := ans + 1 ; 
     continue ) else skip ; 
    q := q->including(Point.newPoint(nx, ny)) ; 
    visited[ny+1][nx+1] := true ; 
 )  ;     i := i + 1 ) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    String strIn=parseStdin();
    if(strIn!=null){
      int max=Integer.parseInt(strIn);
      for(int n=0 ; n<max ; n++){
        strIn=parseStdin();
        sub(strIn.toCharArray());
      }
    }
  }
  private static void sub(char[] strIn){
    String strMin=null ;
    String strMax=null ;
    Arrays.sort(strIn);
    strMin=String.valueOf(strIn);
    strMax=reverse(strMin);
    System.out.println(Long.parseLong(strMax)-Long.parseLong(strMin));
  }
  private static String reverse(String str){
    char[] buff=str.toCharArray();
    int nLen=str.length();
    char c=0 ;
    for(int n1=0,n2=nLen-1 ; n1<n2 ; n1++,n2--){
      c=buff[n1];
      buff[n1]=buff[n2];
      buff[n2]=c ;
    }
    return String.valueOf(buff);
  }
  private static String parseStdin(){
    String strNum=null ;
    try {
      String line=br.readLine();
      if(line!=null){
        if(! line.isEmpty()){
          strNum=line ;
        }
      }
    }
    catch(IOException e){
    }
    return strNum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var strIn : String ; strIn := parseStdin() ;
     if (strIn /= null) then (     var max : int ; max := (strIn)->toInteger() ;
         var n : int ; n := 0 ; while n < max do ( (     strIn := parseStdin() ; 
     execute sub(strIn->characters()) )  ;     n := n + 1 ) ) else skip );
  static   operation sub( strIn : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var strMin : String ; strMin := null ;
     var strMax : String ; strMax := null ;
    strIn := strIn->sort() ; 
    strMin := ((strIn) + "") ; 
    strMax := reverse(strMin) ; 
    OclFile["System.out"].println((strMax)->toLong() - (strMin)->toLong()) ; 
 );
  static   operation reverse( str : String) : String
  pre: true
  post: true
  activity: (     var buff : Sequence(String) ; buff := str->characters() ;
     var nLen : int ; nLen := str->size() ;
    var c : String ; c := 0 ;
        var n1 : int ; n1 := 0 ;
    var n2 : int ; n2 := nLen - 1 ; while n1 < n2 do ( (     c := buff[n1+1] ; 
     buff[n1+1] := buff[n2+1] ; 
     buff[n2+1] := c )  ;     n1 := n1 + 1 ;     n2 := n2 - 1 ) ; 
    return (buff)->sum()  
 );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var strNum : String ; strNum := null ;
     try (     var line : String ; line := br.readLine() ;
     if (line /= null) then (     if (not(line->isEmpty())) then (     strNum := line ) else skip ) else skip )   catch (e : IOException) do skip
     return strNum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class C {
  public static void main(String[] Z)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer stz ;
    int n=Integer.parseInt(br.readLine());
    stz=new StringTokenizer(br.readLine());
    int[] arr=new int[n+1];
    int sumOdd=0 ;
    int sumEve=0 ;
    for(int i=1 ; i<=n ; i++){
      arr[i]=Integer.parseInt(stz.nextToken());
      if(i % 2==0)sumEve+=arr[i];
      else sumOdd+=arr[i];
    }
    int prevOdd=0 ;
    int prevEve=0 ;
    int ans=0 ;
    for(int i=1 ; i<=n ; i++){
      int s1=0 ;
      int s2=0 ;
      if(i % 2==1){
        int nowOdd=sumOdd-arr[i];
        s1=prevOdd-prevEve+sumEve ;
        s2=prevEve-prevOdd+nowOdd ;
        prevOdd+=arr[i];
      }
      else {
        int nowEve=sumEve-arr[i];
        s1=prevOdd-prevEve+nowEve ;
        s2=prevEve-prevOdd+sumOdd ;
        prevEve+=arr[i];
      }
      if(s1==s2)++ans ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( Z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var stz : OclIterator ;
    var n : int ; n := (br.readLine())->toInteger() ;
    stz := OclIterator.newOclIterator_String(br.readLine()) ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
    var sumOdd : int ; sumOdd := 0 ;
    var sumEve : int ; sumEve := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := (stz.next())->toInteger() ; 
     if (i mod 2 = 0) then     sumEve := sumEve+(arr[i+1]) ; else     sumOdd := sumOdd+(arr[i+1]) ; )  ;     i := i + 1 ) ; 
    var prevOdd : int ; prevOdd := 0 ;
    var prevEve : int ; prevEve := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var s1 : int ; s1 := 0 ;
     var s2 : int ; s2 := 0 ;
     if (i mod 2 = 1) then (     var nowOdd : int ; nowOdd := sumOdd - arr[i+1] ;
     s1 := prevOdd - prevEve + sumEve ; 
     s2 := prevEve - prevOdd + nowOdd ; 
     prevOdd := prevOdd+(arr[i+1]) ) else (     var nowEve : int ; nowEve := sumEve - arr[i+1] ;
     s1 := prevOdd - prevEve + nowEve ; 
     s2 := prevEve - prevOdd + sumOdd ; 
     prevEve := prevEve+(arr[i+1]) ) ;  
     if (s1 = s2) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GFG {
  public static ArrayList<Integer>getPerfectSquares(int n){
    ArrayList<Integer>perfectSquares=new ArrayList<>();
    int current=1,i=1 ;
    while(current<=n){
      perfectSquares.add(current);
      current=(int)Math.pow(++i,2);
    }
    return perfectSquares ;
  }
  public static int countTriplets(int n){
    ArrayList<Integer>perfectSquares=getPerfectSquares((int)Math.pow(n,2));
    int count=0 ;
    for(int a=1 ; a<=n ; a++){
      int aSquare=(int)Math.pow(a,2);
      for(int i=0 ; i<perfectSquares.size(); i++){
        int cSquare=perfectSquares.get(i);
        int bSquare=cSquare-aSquare ;
        int b=(int)Math.sqrt(bSquare);
        int c=(int)Math.sqrt(cSquare);
        if(c<a || ! perfectSquares.contains(bSquare))continue ;
        if((b>=a)&&(b<=c)&&(aSquare+bSquare==cSquare))count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(countTriplets(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getPerfectSquares( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var perfectSquares : Sequence(int) ; perfectSquares := Sequence{} ;
     var current : int ; current := 1 ;
    var i : int ; i := 1 ;
     while (current <= n) do (     perfectSquares := perfectSquares->including(current) ; 
     current := (i + 1)->pow(2)->oclAsType(int) ) ; 
     return perfectSquares );
  static   operation countTriplets( n : int) : int
  pre: true
  post: true
  activity: (     var perfectSquares : Sequence(int) ; perfectSquares := getPerfectSquares(n->pow(2)->oclAsType(int)) ;
     var count : int ; count := 0 ;
         var a : int ; a := 1 ; while a <= n do ( (     var aSquare : int ; aSquare := a->pow(2)->oclAsType(int) ;
         var i : int ; i := 0 ; while i < perfectSquares->size() do ( (     var cSquare : int ; cSquare := perfectSquares->at(i+1) ;
     var bSquare : int ; bSquare := cSquare - aSquare ;
    var b : int ; b := (bSquare)->sqrt()->oclAsType(int) ;
    var c : int ; c := (cSquare)->sqrt()->oclAsType(int) ;
    if (c < a or not(perfectSquares->includes(bSquare))) then     continue else skip ; 
    if ((b >= a) & (b <= c) & (aSquare + bSquare = cSquare)) then     count := count + 1 ; else skip ; 
 )  ;     i := i + 1 ) )  ;     a := a + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(countTriplets(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    int T=sc.nextInt();
    int[][] time=new int[N][2];
    String[][] name=new String[N][2];
    for(int i=0 ; i<N ; ++i){
      time[i][0]=time(sc.next());
      name[i][0]=sc.next();
      time[i][1]=time(sc.next());
      name[i][1]=sc.next();
    }
    ArrayList<Integer>res=new ArrayList<Integer>();
    for(int i=0 ; i<N-1 ; ++i){
      if(time[i+1][0]-time[i][1]>=T)res.add(i);
    }
    System.out.println(res.size());
    for(int i : res){
      System.out.println(name[i][1]+" "+(time[i+1][0]-time[i][1]));
    }
  }
  static int time(String hhmm){
    int h=(hhmm.charAt(0)-'0')*10+hhmm.charAt(1)-'0' ;
    int m=(hhmm.charAt(3)-'0')*10+hhmm.charAt(4)-'0' ;
    return h*60+m ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
    var time : Sequence(Sequence(int)) ; time := Integer.subrange(1,N)->collect(Integer.subrange(1,2)->collect(0)) ;
    var name : Sequence(Sequence(String)) ; name := Integer.subrange(1,N)->collect(Integer.subrange(1,2)->collect(null)) ;
        var i : int ; i := 0 ; while i < N do ( (     time[i+1][0+1] := time(sc.getCurrent()) ; 
     name[i+1][0+1] := sc.getCurrent() ; 
     time[i+1][1+1] := time(sc.getCurrent()) ; 
     name[i+1][1+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    var res : Sequence(int) ; res := Sequence{} ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     if (time[i + 1+1][0+1] - time[i+1][1+1] >= T) then     res := res->including(i) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res->size()) ; 
    for (i : res) do ( (     OclFile["System.out"].println(name[i+1][1+1] + " " + (time[i + 1+1][0+1] - time[i+1][1+1])) )  ) ; 
 );
  static   operation time( hhmm : String) : int
  pre: true
  post: true
  activity: (     var h : int ; h := (hhmm->at(0+1) - ('0')->char2byte()) * 10 + hhmm->at(1+1) - ('0')->char2byte() ;
     var m : int ; m := (hhmm->at(3+1) - ('0')->char2byte()) * 10 + hhmm->at(4+1) - ('0')->char2byte() ;
     return h * 60 + m );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    line=br.readLine();
    int n=parseInt(line.substring(0,line.indexOf(' ')));
    int t=parseInt(line.substring(line.indexOf(' ')+1));
    List<String>stations=new ArrayList<String>();
    int[] opens=new int[n-1];
    for(int i=0 ; i<n ; i++){
      String[] tokens=br.readLine().split(" ");
      stations.add(tokens[3]);
      int arrive=minutes(tokens[2]);
      int leave=minutes(tokens[0]);
      if(i<n-1){
        opens[i]=arrive ;
      }
      if(i>0){
        opens[i-1]=leave-opens[i-1];
      }
    }
    int c=0 ;
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n-1 ; i++){
      if(opens[i]>=t){
        c++;
        sb.append(stations.get(i)+" "+opens[i]+"\n");
      }
    }
    System.out.println(c);
    System.out.print(sb.toString());
  }
  static int minutes(String time){
    int h=parseInt(time.substring(0,time.indexOf(':')));
    int m=parseInt(time.substring(time.indexOf(':')+1));
    return h*60+m ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    line := br.readLine() ; 
    var n : int ; n := parseInt(line.subrange(0+1,line->indexOf(' ')-1)) ;
    var t : int ; t := parseInt(line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1)) ;
    var stations : Sequence(String) ; stations := Sequence{} ;
    var opens : Sequence(int) ; opens := Integer.subrange(1,(n)->char2byte() - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var tokens : Sequence(String) ; tokens := br.readLine()->split(" ") ;
     stations := stations->including(tokens[3+1]) ; 
    var arrive : int ; arrive := minutes(tokens[2+1]) ;
    var leave : int ; leave := minutes(tokens[0+1]) ;
    if (i < (n)->char2byte() - 1) then (     opens[i+1] := arrive ) else skip ; 
    if (i > 0) then (     opens[i - 1+1] := leave - opens[i - 1+1] ) else skip ; 
 )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < (n)->char2byte() - 1 do ( (     if (opens[i+1] >= t) then (     c := c + 1 ; 
     sb := sb + StringLib.newString(stations->at(i+1) + " " + opens[i+1] + "\n") ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
  static   operation minutes( time : String) : int
  pre: true
  post: true
  activity: (     var h : int ; h := parseInt(time.subrange(0+1,time->indexOf(':')-1)) ;
     var m : int ; m := parseInt(time.subrange(time->indexOf(':')-1 + 1+1,time->indexOf(':')-1 + 1)) ;
     return h * 60 + m );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-12 ;
  void run(){
    int n=sc.nextInt(),t=sc.nextInt();
    sc.next();
    sc.next();
    int count=0 ;
    String line="" ;
    for(int i=0 ; i<n-1 ; i++){
      int time1=f(sc.next());
      String name=sc.next();
      int time2=f(sc.next());
      sc.next();
      if(time2-time1>=t){
        line+=name+" "+(time2-time1)+"\n" ;
        count++;
      }
    }
    line=count+"\n"+line ;
    print(line);
  }
  int f(String s){
    return Integer.parseInt(s.substring(0,2))*60+Integer.parseInt(s.substring(3,5));
  }
  void solve(){
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-12;
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
     skip ; 
    skip ; 
    var count : int ; count := 0 ;
    var line : String ; line := "" ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var time1 : int ; time1 := f(sc.getCurrent()) ;
     var name : String ; name := sc.getCurrent() ;
    var time2 : int ; time2 := f(sc.getCurrent()) ;
    skip ; 
    if ((time2)->char2byte() - time1 >= t) then (     line := line+(name + " " + ((time2)->char2byte() - time1) + "\n") ; 
     count := count + 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    line := count + "\n" + line ; 
    execute print(line) ; 
 );
   operation f( s : String) : int
  pre: true
  post: true
  activity: (     return (s.subrange(0+1,2))->toInteger() * 60 + (s.subrange(3+1,5))->toInteger() );
   operation solve() : void
  pre: true
  post: true
  activity: skip;
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.security.*;
import java.math.*;
import java.awt.geom.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws NoSuchAlgorithmException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    ArrayList<String>listA=new ArrayList<String>();
    ArrayList<Integer>listB=new ArrayList<Integer>();
    sc.next();
    sc.next();
    for(int i=0 ; i<n-1 ; i++){
      String[] tt=sc.next().split(":");
      int time1=Integer.parseInt(tt[0])*60+Integer.parseInt(tt[1]);
      String name1=sc.next();
      tt=sc.next().split(":");
      int time2=Integer.parseInt(tt[0])*60+Integer.parseInt(tt[1]);
      String name2=sc.next();
      if(time2-time1>=t){
        listA.add(name1);
        listB.add(time2-time1);
      }
    }
    sc.next();
    sc.next();
    System.out.println(listA.size());
    for(int i=0 ; i<listA.size(); i++){
      System.out.println(listA.get(i)+" "+listB.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var listA : Sequence(String) ; listA := Sequence{} ;
    var listB : Sequence(int) ; listB := Sequence{} ;
    skip ; 
    skip ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var tt : Sequence(String) ; tt := sc.getCurrent()->split(":") ;
     var time1 : int ; time1 := (tt[0+1])->toInteger() * 60 + (tt[1+1])->toInteger() ;
    var name1 : String ; name1 := sc.getCurrent() ;
    tt := sc.getCurrent()->split(":") ; 
    var time2 : int ; time2 := (tt[0+1])->toInteger() * 60 + (tt[1+1])->toInteger() ;
    var name2 : String ; name2 := sc.getCurrent() ;
    if ((time2)->char2byte() - time1 >= t) then (     listA := listA->including(name1) ; 
     listB := listB->including((time2)->char2byte() - time1) ) else skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    OclFile["System.out"].println(listA->size()) ; 
        var i : int ; i := 0 ; while i < listA->size() do ( (     OclFile["System.out"].println(listA->at(i+1) + " " + listB->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void substringConversions(String str,int k,int b){
    for(int i=0 ; i+k<=str.length(); i++){
      String sub=str.substring(i,i+k);
      int sum=0,counter=0 ;
      for(int j=sub.length()-1 ; j>=0 ; j--){
        sum=(int)(sum+((sub.charAt(j)-'0')*Math.pow(b,counter)));
        counter++;
      }
      System.out.print(sum+" ");
    }
  }
  public static void main(String[] args){
    String str="12212" ;
    int b=3,k=3 ;
    substringConversions(str,b,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation substringConversions( str : String, k : int, b : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i + k <= str->size() do ( (     var sub : String ; sub := str.subrange(i+1,i + k) ;
     var sum : int ; sum := 0 ;
    var counter : int ; counter := 0 ;
         var j : int ; j := sub->size() - 1 ; while j >= 0 do ( (     sum := (sum + ((sub->at(j+1) - ('0')->char2byte()) * b->pow(counter)))->oclAsType(int) ; 
     counter := counter + 1 )  ;     j := j - 1 ) ; 
     OclFile["System.out"].print(sum + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "12212" ;
     var b : int ; b := 3 ;
    var k : int ; k := 3 ;
     execute substringConversions(str, b, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    double m=sc.nextInt();
    System.out.println(m*m*m*4/3*Math.PI);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : double ; m := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(m * m * m * 4 / 3 * 3.141592653589793) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    String pre="" ;
    int rst=0 ;
    String[] s=new String[4];
    int[] u=new int[4];
    ArrayList<String>list=new ArrayList<String>();
    ArrayList<Integer>time=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<4 ; j++)s[j]=sc.next();
      if(i!=0){
        u[0]=Integer.valueOf(s[0] .substring(0,2));
        u[1]=Integer.valueOf(s[0] .substring(3,5));
        u[2]=Integer.valueOf(pre.substring(0,2));
        u[3]=Integer.valueOf(pre.substring(3,5));
        rst=(u[1]-u[3])+(u[0]-u[2])*60 ;
        if(rst>=t){
          list.add(s[1]);
          time.add(rst);
        }
      }
      pre=s[2];
    }
    System.out.println(list.size());
    for(int i=0 ; i<list.size(); i++)System.out.println(list.get(i)+" "+time.get(i));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var pre : String ; pre := "" ;
    var rst : int ; rst := 0 ;
    var s : Sequence(String) ; s := Integer.subrange(1,4)->collect(null) ;
    var u : Sequence(int) ; u := Integer.subrange(1,4)->collect(0) ;
    var list : Sequence(String) ; list := Sequence{} ;
    var time : Sequence(int) ; time := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 4 do (     s[j+1] := sc.getCurrent() ;  ;     j := j + 1 ) ; 
     if (i /= 0) then (     u[0+1] := (s[0+1].subrange(0+1,2))->toInteger() ; 
     u[1+1] := (s[0+1].subrange(3+1,5))->toInteger() ; 
    u[2+1] := (pre.subrange(0+1,2))->toInteger() ; 
    u[3+1] := (pre.subrange(3+1,5))->toInteger() ; 
    rst := (u[1+1] - u[3+1]) + (u[0+1] - u[2+1]) * 60 ; 
    if (rst >= t) then (     list := list->including(s[1+1]) ; 
     time := time->including(rst) ) else skip ; 
 ) else skip ; 
     pre := s[2+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(list->size()) ; 
        var i : int ; i := 0 ; while i < list->size() do (     OclFile["System.out"].println(list->at(i+1) + " " + time->at(i+1)) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int min(int x,int y,int z){
    if(x<y)return(x<z)? x : z ;
    else return(y<z)? y : z ;
  }
  static int minCost(int cost[][],int m,int n){
    if(n<0 || m<0)return Integer.MAX_VALUE ;
    else if(m==0 && n==0)return cost[m][n];
    else return cost[m][n]+min(minCost(cost,m-1,n-1),minCost(cost,m-1,n),minCost(cost,m,n-1));
  }
  public static void main(String args[]){
    int cost[][]={
      {
        1,2,3 },{
          4,8,2 },{
            1,5,3 }
          };
          System.out.print(minCost(cost,2,2));
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation min( x : int, y : int, z : int) : int
  pre: true
  post: true
  activity: (     if (x < y) then     return if (x < z) then x else z endif else     return if (y < z) then y else z endif );
  static   operation minCost( cost : Sequence(Sequence(int)), m : int, n : int) : int
  pre: true
  post: true
  activity: (     if (n < 0 or m < 0) then     return 2147483647 else     if (m = 0 & n = 0) then     return cost[m+1][n+1] else     return cost[m+1][n+1] + Set{minCost(cost, m - 1, n - 1), minCost(cost, m - 1, n), minCost(cost, m, n - 1)}->min() ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cost : Sequence(Sequence(int)) ; cost := Sequence{Sequence{1,2,3},Sequence{4,8,2},Sequence{1,5,3}} ;
     OclFile["System.out"].print(minCost(cost, 2, 2)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
public class prepformerge {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    ArrayList<ArrayList<Integer>>lists=new ArrayList<ArrayList<Integer>>();
    int[] a=new int[n+1];
    st=new StringTokenizer(br.readLine());
    for(int i=1 ; i<=n ; i++){
      a[i]=Integer.parseInt(st.nextToken());
    }
    for(int i=1 ; i<=n ; i++){
      if(i==1){
        ArrayList<Integer>start=new ArrayList<Integer>();
        start.add(a[i]);
        lists.add(start);
      }
      else {
        int lo=0 ;
        int hi=lists.size()-1 ;
        if(lists.get(hi).get(lists.get(hi).size()-1)>a[i]){
          ArrayList<Integer>start=new ArrayList<Integer>();
          start.add(a[i]);
          lists.add(start);
        }
        else {
          while(lo!=hi){
            int mid=(lo+hi)/2 ;
            if(lists.get(mid).get(lists.get(mid).size()-1)<a[i]){
              hi=mid ;
            }
            else {
              lo=mid+1 ;
            }
          }
          lists.get(lo).add(a[i]);
        }
      }
    }
    for(ArrayList<Integer>lis : lists){
      for(int i=0 ; i<lis.size(); i++){
        System.out.print(lis.get(i)+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class prepformerge {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var lists : Sequence(Sequence(int)) ; lists := Sequence{} ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (i = 1) then (     var start : Sequence(int) ; start := Sequence{} ;
     start := start->including(a[i+1]) ; 
     lists := lists->including(start) ) else (     var lo : int ; lo := 0 ;
     var hi : int ; hi := lists->size() - 1 ;
     if (lists->at(hi+1)->at(lists->at(hi+1)->size() - 1+1) > a[i+1]) then (     var start : Sequence(int) ; start := Sequence{} ;
     start := start->including(a[i+1]) ; 
     lists := lists->including(start) ) else (     while (lo /= hi) do (     var mid : int ; mid := (lo + hi) / 2 ;
     if (lists->at(mid+1)->at(lists->at(mid+1)->size() - 1+1) < a[i+1]) then (     hi := mid ) else (     lo := mid + 1 ) ) ; 
     lists->at(lo+1)->excludes(a[i+1]) ) ) )  ;     i := i + 1 ) ; 
    for (lis : lists) do ( (         var i : int ; i := 0 ; while i < lis->size() do ( (     OclFile["System.out"].print(lis->at(i+1) + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int findgcd(int a,int b){
    if(b==0)return a ;
    return findgcd(b,a % b);
  }
  static int minimumCuts(int a[],int n){
    Arrays.sort(a);
    int gcd=a[1]-a[0];
    int s=gcd ;
    for(int i=2 ; i<n ; i++){
      gcd=findgcd(gcd,a[i]-a[i-1]);
      s+=a[i]-a[i-1];
    }
    if(360-s>0)gcd=findgcd(gcd,360-s);
    return(360/gcd)-n ;
  }
  public static void main(String[] args){
    int[] arr=new int[] {
      30,60,180 };
      int n=arr.length ;
      System.out.println(minimumCuts(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findgcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return findgcd(b, a mod b) );
  static   operation minimumCuts( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var gcd : int ; gcd := a[1+1] - a[0+1] ;
    var s : int ; s := gcd ;
        var i : int ; i := 2 ; while i < n do ( (     gcd := findgcd(gcd, a[i+1] - a[i - 1+1]) ; 
     s := s+(a[i+1] - a[i - 1+1]) )  ;     i := i + 1 ) ; 
    if (360 - s > 0) then     gcd := findgcd(gcd, 360 - s) ; else skip ; 
    return (360 / gcd) - n 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{30,60,180} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minimumCuts(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isVowel(char ch){
    if(ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u')return true ;
    return false ;
  }
  static int lcs(String X,String Y,int m,int n){
    int L[][]=new int[m+1][n+1];
    int i,j ;
    for(i=0 ; i<=m ; i++){
      for(j=0 ; j<=n ; j++){
        if(i==0 || j==0)L[i][j]=0 ;
        else if((X.charAt(i-1)==Y.charAt(j-1))&& isVowel(X.charAt(i-1)))L[i][j]=L[i-1][j-1]+1 ;
        else L[i][j]=Math.max(L[i-1][j],L[i][j-1]);
      }
    }
    return L[m][n];
  }
  public static void main(String[] args){
    String X="aieef" ;
    String Y="klaief" ;
    int m=X.length();
    int n=Y.length();
    System.out.println("Length of LCS="+lcs(X,Y,m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isVowel( ch : String) : boolean
  pre: true
  post: true
  activity: (     if (ch = 'a' or ch = 'e' or ch = 'i' or ch = 'o' or ch = 'u') then     return true else skip ; 
     return false );
  static   operation lcs( X : String, Y : String, m : int, n : int) : int
  pre: true
  post: true
  activity: (     var L : Sequence(Sequence(int)) ; L := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
     var i : int ;
    var j : int ;
         i := 0 ; while i <= m do ( (         j := 0 ; while j <= n do ( (     if (i = 0 or j = 0) then     L[i+1][j+1] := 0 ; else     if ((X->at(i - 1+1) = Y->at(j - 1+1)) & isVowel(X->at(i - 1+1))) then     L[i+1][j+1] := L[i - 1+1][j - 1+1] + 1 else     L[i+1][j+1] := Set{L[i - 1+1][j+1], L[i+1][j - 1+1]}->max() ; ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return L[m+1][n+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : String ; X := "aieef" ;
     var Y : String ; Y := "klaief" ;
    var m : int ; m := X->size() ;
    var n : int ; n := Y->size() ;
    OclFile["System.out"].println("Length of LCS=" + lcs(X, Y, m, n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Solve s=new Solve();
    s.solve();
  }
}
class Solve {
  Solve(){
  }
  Scanner in=new Scanner(System.in);
  void solve(){
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      int a=in.nextInt(),b=in.nextInt();
      int c=(a % b==0 ? b : a % b);
      System.out.println(c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Solve ; s := Solve.newSolve() ;
     s.solve() );
}
class Solve {
   static operation newSolve() : Solve
  pre: true
  post: true
  activity:
  ( var self : Solve ;
    self := createSolve();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
     var c : int ; c := (if a mod b = 0 then b else a mod b endif) ;
     OclFile["System.out"].println(c) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,k,p ;
    n=sc.nextInt();
    for(; n>0 ; n--){
      k=sc.nextInt();
      p=sc.nextInt();
      k %=p ;
      if(k==0)k=p ;
      out.println(k);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var k : int ;
    var p : int ;
    n := sc.nextInt() ; 
      while n > 0 do ( (     k := sc.nextInt() ; 
     p := sc.nextInt() ; 
    k := k mod p ; 
    if (k = 0) then     k := p ; else skip ; 
    out.println(k) ; 
 )  ;     n := n - 1 ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    while(n-->0){
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      int ans=a % b ;
      System.out.println(ans==0 ? b : ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
     var ans : int ; ans := a mod b ;
     OclFile["System.out"].println(if ans = 0 then b else ans endif) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(is);
    Integer num=Integer.parseInt(br.readLine());
    for(int i=0 ; i<num ; i++){
      String str ;
      if((str=br.readLine())!=null){
        String[] sp=str.split(" ");
        int a=Integer.parseInt(sp[0]);
        int b=Integer.parseInt(sp[1]);
        if(a % b==0){
          System.out.println(b);
        }
        else {
          System.out.println(a % b);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(is) ;
     var num : int ; num := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < num do ( (     var str : String ;
     if ((str) /= null) then (     var sp : Sequence(String) ; sp := str->split(" ") ;
     var a : int ; a := (sp[0+1])->toInteger() ;
     var b : int ; b := (sp[1+1])->toInteger() ;
     if (a mod b = 0) then (     OclFile["System.out"].println(b) ) else (     OclFile["System.out"].println(a mod b) ) ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import javax.xml.crypto.Data ;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] k=new int[n];
    int[] p=new int[n];
    for(int i=0 ; i<n ; i++){
      k[i]=sc.nextInt();
      p[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      int s=k[i];
      int now=0 ;
      while(s!=0){
        now %=p[i];
        now++;
        s--;
      }
      System.out.println(now);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : Sequence(int) ; k := Integer.subrange(1,n)->collect(0) ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     k[i+1] := sc.getCurrent()->toInteger() ; 
     p[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var s : int ; s := k[i+1] ;
     var now : int ; now := 0 ;
     while (s /= 0) do (     now := now mod p[i+1] ; 
     now := now + 1 ; 
     s := s - 1 ) ; 
     OclFile["System.out"].println(now) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int q=scanner.nextInt();
    int[] member=new int[n];
    int m=0 ;
    int mn=0 ;
    for(int i=0 ; i<q ; i++){
      int a=scanner.nextInt();
      int v=scanner.nextInt();
      member[a-1]+=v ;
      if(i==0){
        m=member[a-1];
        mn=a-1 ;
      }
      else {
        if(v<0){
          mn=most(member);
          m=member[mn];
        }
        else if((member[a-1]==m)&&(mn>a-1)){
          mn=a-1 ;
        }
        else if(m<member[a-1]){
          m=member[a-1];
          mn=a-1 ;
        }
      }
      System.out.println((mn+1)+" "+m);
    }
  }
  static int most(int[] member){
    int m=member[0];
    int n=0 ;
    for(int i=1 ; i<member.length ; i++){
      if(m<member[i]){
        m=member[i];
        n=i ;
      }
    }
    return n ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var q : int ; q := scanner.getCurrent()->toInteger() ;
    var member : Sequence(int) ; member := Integer.subrange(1,n)->collect(0) ;
    var m : int ; m := 0 ;
    var mn : int ; mn := 0 ;
        var i : int ; i := 0 ; while i < q do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var v : int ; v := scanner.getCurrent()->toInteger() ;
    member[a - 1+1] := member[a - 1+1]+(v) ; 
    if (i = 0) then (     m := member[a - 1+1] ; 
     mn := a - 1 ) else (     if (v < 0) then (     mn := most(member) ; 
     m := member[mn+1] ) else     if ((member[a - 1+1] = m) & (mn > a - 1)) then (     mn := a - 1 ) else     if (m < member[a - 1+1]) then (     m := member[a - 1+1] ; 
     mn := a - 1 ) else skip ; ;  ) ;  
    OclFile["System.out"].println((mn + 1) + " " + m) ; 
 )  ;     i := i + 1 ) ; 
 );
  static   operation most( member : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var m : int ; m := member[0+1] ;
     var n : int ; n := 0 ;
         var i : int ; i := 1 ; while i < member->size() do ( (     if (m < member[i+1]) then (     m := member[i+1] ; 
     n := i ) else skip )  ;     i := i + 1 ) ; 
     return n );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    int n=sc.nextInt();
    int q=sc.nextInt();
    PriorityQueue<Pair>pq=new PriorityQueue<Pair>();
    HashMap<Integer,Pair>map=new HashMap<Integer,Pair>();
    StringBuilder sb=new StringBuilder();
    while(q-->0){
      int num=sc.nextInt();
      int get=sc.nextInt();
      if(! map.containsKey(num)){
        Pair p=new Pair(num,get);
        map.put(num,p);
        pq.add(p);
      }
      else {
        Pair del=map.get(num);
        map.remove(num);
        pq.remove(del);
        del.cnt+=get ;
        map.put(num,del);
        pq.add(del);
      }
      Pair max=pq.peek();
      sb.append(max.num+" "+max.cnt+"\n");
    }
    System.out.print(sb);
  }
  class Pair implements Comparable<Pair>{
    int num ;
    int cnt ;
    public Pair(int num,int cnt){
      super();
      this.num=num ;
      this.cnt=cnt ;
    }
    @ Override public int compareTo(Pair arg0){
      if(this.cnt==arg0.cnt)return this.num-arg0.num ;
      return arg0.cnt-this.cnt ;
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
    var pq : Sequence(Map) ; pq := Sequence{} ;
    var map : Map(int,Map) ; map := Map{} ;
    var sb : String ; sb := StringLib.newString() ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     var num : int ; num := sc.getCurrent()->toInteger() ;
     var get : int ; get := sc.getCurrent()->toInteger() ;
    if (not(map->keys()->includes(num))) then (     var p : Map ; p := Map(num, get) ;
     map := map->union(Map{num |-> p}) ; 
     pq := pq->including(p) ) else (     var del : Map ; del := map->at(num) ;
     map := map->antirestrict(Set{num}) ; 
    pq := pq->excludingFirst(del) ; 
    del.cnt := del.cnt+(get) ; 
    map := map->union(Map{num |-> del}) ; 
    pq := pq->including(del) ; 
 ) ;  
    var max : Map ; max := pq->min() ;
    sb := sb + StringLib.newString(max.num + " " + max.cnt + "\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].print(sb) ; 
 );
 class Pair implements Comparable<Map> {
   attribute num : int;
   attribute cnt : int;
   static operation newPair( num : int, cnt : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(num, cnt);
    return self );
  operation initialise( num : int, cnt : int) : void
  pre: true  post: true
  activity: (     execute super() ; 
     self.num := num ; 
     self.cnt := cnt );
      operation compareTo( arg0 : Map) : int
  pre: true
  post: true
  activity: (     if (self.cnt = arg0.cnt) then     return self.num - arg0.num else skip ; 
     return arg0.cnt - self.cnt );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextInt()){
      int A=sc.nextInt();
      int B=sc.nextInt();
      System.out.printf("%.10f\n",B*B*B*Math.PI/3.0*4.0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextInt()) do (     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].printf("%.10f\n", B * B * B * 3.141592653589793 / 3.0 * 4.0) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static float circlearea(double a,double b){
    if(a<0 || b<0)return-1 ;
    float A=(float)((3.14*Math.pow(a,2)*Math.pow(b,2))/(4*(Math.pow(a,2)+Math.pow(b,2))));
    return A ;
  }
  public static void main(String[] args){
    float a=8,b=10 ;
    System.out.println(circlearea(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation circlearea( a : double, b : double) : double
  pre: true
  post: true
  activity: (     if (a < 0 or b < 0) then     return -1 else skip ; 
     var A : double ; A := ((3.14 * a->pow(2) * b->pow(2)) / (4 * (a->pow(2) + b->pow(2))))->oclAsType(double) ;
     return A );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 8 ;
    var b : double ; b := 10 ;
     OclFile["System.out"].println(circlearea(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] P_E=br.readLine().split(" ");
    int PlayerNum=Integer.parseInt(P_E[0]);
    int EventNum=Integer.parseInt(P_E[1]);
    int[] Fishes=new int[PlayerNum+1];
    Arrays.fill(Fishes,0);
    int TopPlayerID=0 ;
    int TopPlayersFishes=0 ;
    for(int i=0 ; i<EventNum ; i++){
      String[] P_G=br.readLine().split(" ");
      int PlayerID=Integer.parseInt(P_G[0]);
      int GetFishNum=Integer.parseInt(P_G[1]);
      Fishes[PlayerID]+=GetFishNum ;
      if(TopPlayersFishes<Fishes[PlayerID]){
        TopPlayerID=PlayerID ;
        TopPlayersFishes=Fishes[PlayerID];
      }
      else if(TopPlayersFishes==Fishes[PlayerID]){
        TopPlayerID=PlayerID<TopPlayerID ? PlayerID : TopPlayerID ;
      }
      else {
        if(TopPlayerID==PlayerID){
          int MaxFishes=0 ;
          for(int p=0 ; p<Fishes.length ; p++){
            if(MaxFishes<Fishes[p]){
              MaxFishes=Fishes[p];
              TopPlayerID=p ;
            }
            else if(MaxFishes==Fishes[p]){
              TopPlayerID=p<TopPlayerID ? p : TopPlayerID ;
            }
          }
          TopPlayersFishes=MaxFishes ;
        }
      }
      System.out.println(TopPlayerID+" "+TopPlayersFishes);
    }
  }
}
class TopPlayer {
  public int PlayerID ;
  public int Fishes ;
  TopPlayer(int InputID,int InputFishes){
    PlayerID=InputID ;
    Fishes=InputFishes ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var P_E : Sequence(String) ; P_E := br.readLine()->split(" ") ;
    var PlayerNum : int ; PlayerNum := (P_E[0+1])->toInteger() ;
    var EventNum : int ; EventNum := (P_E[1+1])->toInteger() ;
    var Fishes : Sequence(int) ; Fishes := Integer.subrange(1,PlayerNum + 1)->collect(0) ;
    Fishes := Fishes->collect(0) ; 
    var TopPlayerID : int ; TopPlayerID := 0 ;
    var TopPlayersFishes : int ; TopPlayersFishes := 0 ;
        var i : int ; i := 0 ; while i < EventNum do ( (     var P_G : Sequence(String) ; P_G := br.readLine()->split(" ") ;
     var PlayerID : int ; PlayerID := (P_G[0+1])->toInteger() ;
    var GetFishNum : int ; GetFishNum := (P_G[1+1])->toInteger() ;
    Fishes[PlayerID+1] := Fishes[PlayerID+1]+(GetFishNum) ; 
    if (TopPlayersFishes < Fishes[PlayerID+1]) then (     TopPlayerID := PlayerID ; 
     TopPlayersFishes := Fishes[PlayerID+1] ) else     if (TopPlayersFishes = Fishes[PlayerID+1]) then (     TopPlayerID := if PlayerID < TopPlayerID then PlayerID else TopPlayerID endif ) else (     if (TopPlayerID = PlayerID) then (     var MaxFishes : int ; MaxFishes := 0 ;
         var p : int ; p := 0 ; while p < Fishes->size() do ( (     if (MaxFishes < Fishes[p+1]) then (     MaxFishes := Fishes[p+1] ; 
     TopPlayerID := p ) else     if (MaxFishes = Fishes[p+1]) then (     TopPlayerID := if p < TopPlayerID then p else TopPlayerID endif ) else skip ; )  ;     p := p + 1 ) ; 
     TopPlayersFishes := MaxFishes ) else skip ) ;  ;  
    OclFile["System.out"].println(TopPlayerID + " " + TopPlayersFishes) ; 
 )  ;     i := i + 1 ) ; 
 );
}
class TopPlayer {
   attribute PlayerID : int;
   attribute Fishes : int;
   static operation newTopPlayer( InputID : int, InputFishes : int) : TopPlayer
  pre: true
  post: true
  activity:
  ( var self : TopPlayer ;
    self := createTopPlayer();
    self.initialise(InputID, InputFishes);
    return self );
  operation initialise( InputID : int, InputFishes : int) : void
  pre: true  post: true
  activity: (     PlayerID := InputID ; 
     Fishes := InputFishes );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class FishingData implements Comparable<FishingData>{
  final int id ;
  int no ;
  FishingData(final int id){
    this.id=id ;
  }
  FishingData(final int id,final int no){
    this.id=id ;
    this.no=no ;
  }
  public int compareTo(FishingData fd){
    if(no!=fd.no){
      return no-fd.no ;
    }
    else {
      return fd.id-id ;
    }
  }
}
class MaxContainer {
  final TreeSet<FishingData>set ;
  final HashMap<Integer,FishingData>map ;
  public MaxContainer(){
    set=new TreeSet<FishingData>();
    map=new HashMap<Integer,FishingData>();
  }
  public FishingData getMaxData(){
    return set.last();
  }
  public void catchEvent(final int id,final int diff){
    if(map.containsKey(id)){
      final FishingData fd=map.get(id);
      set.remove(fd);
      fd.no+=diff ;
      set.add(fd);
    }
    else {
      final FishingData fd=new FishingData(id,diff);
      map.put(id,fd);
      set.add(fd);
    }
  }
}
class Main {
  public static void main(String[] args){
    final Scanner stdin=new Scanner(System.in);
    final int n=stdin.nextInt();
    final int q=stdin.nextInt();
    MaxContainer mc=new MaxContainer();
    for(int i=0 ; i<q ; i++){
      final int id=stdin.nextInt();
      final int vol=stdin.nextInt();
      mc.catchEvent(id,vol);
      final FishingData maxFd=mc.getMaxData();
      System.out.printf("%d %d\n",maxFd.id,maxFd.no);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class FishingData implements Comparable<FishingData> {
   attribute id : int;
   attribute no : int;
   static operation newFishingData( id : int) : FishingData
  pre: true
  post: true
  activity:
  ( var self : FishingData ;
    self := createFishingData();
    self.initialise(id);
    return self );
  operation initialise( id : int) : void
  pre: true  post: true
  activity: (     self.id := id );
   static operation newFishingData( id : int, no : int) : FishingData
  pre: true
  post: true
  activity:
  ( var self : FishingData ;
    self := createFishingData();
    self.initialise(id, no);
    return self );
  operation initialise( id : int, no : int) : void
  pre: true  post: true
  activity: (     self.id := id ; 
     self.no := no );
   operation compareTo( fd : FishingData) : int
  pre: true
  post: true
  activity: (     if (no /= fd.no) then (     return no - fd.no ) else (     return fd.id - id ) );
}
class MaxContainer {
   attribute set : Set(FishingData);
   attribute map : Map(int,FishingData);
   static operation newMaxContainer() : MaxContainer
  pre: true
  post: true
  activity:
  ( var self : MaxContainer ;
    self := createMaxContainer();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     set := Set{} ; 
     map := Map{} );
   operation getMaxData() : FishingData
  pre: true
  post: true
  activity: (     return set->last() );
   operation catchEvent( id : int, diff : int) : void
  pre: true
  post: true
  activity: (     if (map->keys()->includes(id)) then (     var fd : FishingData ; fd := map->at(id) ;
     set := set->excludingFirst(fd) ; 
     fd.no := fd.no+(diff) ; 
     set := set->including(fd) ) else (     var fd : FishingData ; fd := FishingData.newFishingData(id, diff) ;
     map := map->union(Map{id |-> fd}) ; 
     set := set->including(fd) ) );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdin.getCurrent()->toInteger() ;
    var q : int ; q := stdin.getCurrent()->toInteger() ;
    var mc : MaxContainer ; mc := MaxContainer.newMaxContainer() ;
        var i : int ; i := 0 ; while i < q do ( (     var id : int ; id := stdin.getCurrent()->toInteger() ;
     var vol : int ; vol := stdin.getCurrent()->toInteger() ;
    mc.catchEvent(id, vol) ; 
    var maxFd : FishingData ; maxFd := mc.getMaxData() ;
    OclFile["System.out"].printf("%d %d\n", maxFd.id, maxFd.no) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private Scanner sc ;
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    sc=new Scanner(System.in);
    String[] nico=sc.nextLine().split(" ");
    int n=Integer.parseInt(nico[0]);
    int q=Integer.parseInt(nico[1]);
    int[] list=new int[n+1];
    for(int i=0 ; i<list.length ; i++){
      list[i]=0 ;
    }
    int max=0 ;
    int no=1 ;
    for(int i=0 ; i<q ; i++){
      String[] set=sc.nextLine().split(" ");
      int[] data=new int[set.length];
      for(int j=0 ; j<set.length ; j++){
        data[j]=Integer.parseInt(set[j]);
      }
      list[data[0] ]=list[data[0] ]+data[1];
      if((no==data[0])&&(data[1]<0)){
        int tmp=list[data[0] ];
        int newno=data[0];
        for(int j=1 ; j<list.length ; j++){
          if(tmp<=list[j]){
            if(tmp==list[j]){
              if(newno>j)newno=j ;
            }
            else {
              tmp=list[j];
              newno=j ;
            }
          }
        }
        max=tmp ;
        no=newno ;
      }
      if(max<=list[data[0] ]){
        if(max==list[data[0] ]){
          if(no>data[0])no=data[0];
        }
        else {
          max=list[data[0] ];
          no=data[0];
        }
      }
      System.out.println(no+" "+max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var nico : Sequence(String) ; nico := sc.nextLine()->split(" ") ;
    var n : int ; n := (nico[0+1])->toInteger() ;
    var q : int ; q := (nico[1+1])->toInteger() ;
    var list : Sequence(int) ; list := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < list->size() do ( (     list[i+1] := 0 )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var no : int ; no := 1 ;
        var i : int ; i := 0 ; while i < q do ( (     var set : Sequence(String) ; set := sc.nextLine()->split(" ") ;
     var data : Sequence(int) ; data := Integer.subrange(1,set->size())->collect(0) ;
        var j : int ; j := 0 ; while j < set->size() do ( (     data[j+1] := (set[j+1])->toInteger() )  ;     j := j + 1 ) ; 
    list[data[0+1]+1] := list[data[0+1]+1] + data[1+1] ; 
    if ((no = data[0+1]) & (data[1+1] < 0)) then (     var tmp : int ; tmp := list[data[0+1]+1] ;
     var newno : int ; newno := data[0+1] ;
        var j : int ; j := 1 ; while j < list->size() do ( (     if (tmp <= list[j+1]) then (     if (tmp = list[j+1]) then (     if (newno > j) then     newno := j ; else skip ) else (     tmp := list[j+1] ; 
     newno := j ) ) else skip )  ;     j := j + 1 ) ; 
    max := tmp ; 
    no := newno ; 
 ) else skip ; 
    if (max <= list[data[0+1]+1]) then (     if (max = list[data[0+1]+1]) then (     if (no > data[0+1]) then     no := data[0+1] ; else skip ) else (     max := list[data[0+1]+1] ; 
     no := data[0+1] ) ) else skip ; 
    OclFile["System.out"].println(no + " " + max) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int avg_of_even_num(int n){
    int sum=0 ;
    for(int i=1 ; i<=n ; i++)sum+=2*i ;
    return(sum/n);
  }
  public static void main(String[] args){
    int n=9 ;
    System.out.print(avg_of_even_num(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation avg_of_even_num( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do (     sum := sum+(2 * i) ;  ;     i := i + 1 ) ; 
     return (sum / n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     OclFile["System.out"].print(avg_of_even_num(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GeeksforGeeks {
  static int sumOfDigits(long x){
    int sum=0 ;
    while(x>0){
      sum+=(x % 10);
      x/=10 ;
    }
    return sum ;
  }
  static void compute(long n){
    long answer[]=new long[100];
    int pos=0 ;
    for(int i=0 ; i<=100 ; i++){
      long valueOnLeft=Math.abs(n-i)+sumOfDigits(Math.abs(n-i));
      long valueOnRight=(n+i)+sumOfDigits(n+i);
      if(valueOnRight==n)answer[pos++]=(n+i);
      if(valueOnLeft==n)answer[pos++]=Math.abs(n-i);
    }
    if(pos==0)System.out.print(-1);
    else for(int i=0 ;
    i<pos ;
    i++)System.out.println("X="+answer[i]);
  }
  public static void main(String[] args){
    long N=100000001 ;
    compute(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GeeksforGeeks {
  static   operation sumOfDigits( x : long) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (x > 0) do (     sum := sum+((x mod 10)) ; 
     x := x/(10) ) ; 
     return sum );
  static   operation compute( n : long) : void
  pre: true
  post: true
  activity: (     var answer : Sequence(long) ; answer := Integer.subrange(1,100)->collect(0) ;
     var pos : int ; pos := 0 ;
         var i : int ; i := 0 ; while i <= 100 do ( (     var valueOnLeft : long ; valueOnLeft := if n - i < 0 then -(n - i) else n - i endif + sumOfDigits(if n - i < 0 then -(n - i) else n - i endif) ;
     var valueOnRight : long ; valueOnRight := (n + i) + sumOfDigits(n + i) ;
     if (valueOnRight = n) then      answer[pos+1] := (n + i)  ; pos := pos + 1 ; else skip ; 
     if (valueOnLeft = n) then      answer[pos+1] := if n - i < 0 then -(n - i) else n - i endif  ; pos := pos + 1 ; else skip )  ;     i := i + 1 ) ; 
     if (pos = 0) then     OclFile["System.out"].print(-1) ; else         var i : int ; i := 0 ; while i < pos do (     OclFile["System.out"].println("X=" + answer[i+1]) ;  ;     i := i + 1 ) ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := 100000001 ;
     execute compute(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class tp {
  public static void main(String[] args)throws IOException {
    BufferedReader bs=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(bs.readLine());
    while(t--!=0){
      int size=Integer.parseInt(bs.readLine());
      String[] ip=bs.readLine().split(" ");
      int[] d=new int[size];
      for(int i=0 ; i<size ; i++){
        d[i]=Integer.parseInt(ip[i]);
      }
      Arrays.sort(d);
      long count=0 ;
      for(int i : d){
        int ind=binarySearch(d,i);
        if(ind>=0){
          count++;
        }
      }
      System.out.println(count);
    }
  }
  public static int binarySearch(int[] nums,int get){
    int ret=-1 ;
    int i=0 ;
    int j=nums.length-1 ;
    while(i<=j){
      int c=(i+j)/2 ;
      if(nums[c]<get){
        ret=c ;
        i=c+1 ;
      }
      else {
        j=c-1 ;
      }
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class tp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bs : OclFile ; bs := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (bs.readLine())->toInteger() ;
         while (t /= 0) do (    skip ; (     var size : int ; size := (bs.readLine())->toInteger() ;
     var ip : Sequence(String) ; ip := bs.readLine()->split(" ") ;
    var d : Sequence(int) ; d := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < size do ( (     d[i+1] := (ip[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    d := d->sort() ; 
    var count : long ; count := 0 ;
    for (i : d) do ( (     var ind : int ; ind := binarySearch(d, i) ;
     if (ind >= 0) then (     count := count + 1 ) else skip )  ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;  ) );
  static   operation binarySearch( nums : Sequence(int), get : int) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := -1 ;
     var i : int ; i := 0 ;
    var j : int ; j := nums->size() - 1 ;
    while (i <= j) do (     var c : int ; c := (i + j) / 2 ;
     if (nums[c+1] < get) then (     ret := c ; 
     i := c + 1 ) else (     j := c - 1 ) ) ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public static void main(String[] args)throws Exception {
    Scanner scan=new Scanner(System.in);
    int T=scan.nextInt();
    while(T--!=0){
      int n=scan.nextInt();
      int freq[]=new int[101];
      int min=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; i++){
        int tmp=scan.nextInt();
        freq[tmp-1]++;
        min=Math.min(min,tmp);
      }
      int res=0 ;
      for(int i=0 ; i<=100 ; i++){
        if(min!=(i+1)){
          res+=freq[i];
        }
      }
      System.out.println(res);
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := scan.getCurrent()->toInteger() ;
         while (T /= 0) do (    skip ; (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var freq : Sequence(int) ; freq := Integer.subrange(1,101)->collect(0) ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     var tmp : int ; tmp := scan.getCurrent()->toInteger() ;
     freq[tmp - 1+1] := freq[tmp - 1+1] + 1 ; 
     min := Set{min, tmp}->min() )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i <= 100 do ( (     if (min /= (i + 1)) then (     res := res+(freq[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class test269 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      Arrays.sort(a);
      int sum=n-1 ;
      for(int i=1 ; i<n && a[i]==a[0]; i++){
        sum--;
      }
      System.out.println(sum);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test269 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var sum : int ; sum := n - 1 ;
        var i : int ; i := 1 ; while i < n & a[i+1] = a[0+1] do ( (     sum := sum - 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class test177 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int a[]=new int[n];
      int sum=1 ;
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      Arrays.sort(a);
      int p=a[0];
      for(int i=1 ; i<n ; i++){
        if(a[i]!=p){
          sum++;
        }
        p=a[i];
      }
      System.out.println(sum);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test177 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var p : int ; p := a[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] /= p) then (     sum := sum + 1 ) else skip ; 
     p := a[i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Copy {
  int number ;
  HashMap<Integer,Integer>map=new HashMap<>();
  public Copy(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  public void input(int number){
    if(map.get(number)==null){
      map.put(number,1);
    }
  }
  public void printResult(){
    System.out.println(map.size());
    map.clear();
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    Copy instance=new Copy(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      int num=input.nextInt();
      for(int k=0 ; k<num ; k++){
        int n=input.nextInt();
        instance.input(n);
      }
      instance.printResult();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Copy {
   attribute number : int;
   attribute map : Map(int,int) := Map{};
   static operation newCopy( number : int) : Copy
  pre: true
  post: true
  activity:
  ( var self : Copy ;
    self := createCopy();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
   operation input( number : int) : void
  pre: true
  post: true
  activity: (     if (map->at(number) = null) then (     map := map->union(Map{number |-> 1}) ) else skip );
   operation printResult() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(map.size()) ; 
     map := map->intersection(Map{}) );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
     var instance : Copy ; instance := Copy.newCopy(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
         var k : int ; k := 0 ; while k < num do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     instance.input(n) )  ;     k := k + 1 ) ; 
     instance.printResult() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void find(int[] arr,int length,int s){
    for(int i=1 ; i<=(Math.pow(2,length)); i++){
      int sum=0 ;
      for(int j=0 ; j<length ; j++)if(((i>>j)& 1)% 2==1)sum+=arr[j];
      if(sum==s){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
  public static void main(String[] args){
    int sum=5 ;
    int[] array={
-1,2,4,121 };
      int length=array.length ;
      find(array,length,sum);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find( arr : Sequence(int), length : int, s : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= (2->pow(length)) do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < length do (     if ((((i/(2->pow(j)))->oclAsType(long)) & 1) mod 2 = 1) then     sum := sum+(arr[j+1]) ; else skip ;  ;     j := j + 1 ) ; 
     if (sum = s) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("NO") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 5 ;
     var array : Sequence(int) ; array := Sequence{-1,2,4,121} ;
     var length : int ; length := array->size() ;
     execute find(array, length, sum) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CopyCopyCopy {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      HashSet<Integer>hash=new LinkedHashSet<Integer>();
      for(int i=0 ; i<n ; i++){
        hash.add(sc.nextInt());
      }
      System.out.println(hash.size());
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CopyCopyCopy {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var hash : Set(int) ; hash := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     hash := hash->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(hash->size()) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1325B_CopyCopyCopyCopy {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int amount=parseInt(input.nextLine());
      Set<Integer>set=new HashSet<>();
      for(int i=0 ; i<amount ; i++){
        set.add(input.nextInt());
      }
      input.nextLine();
      System.out.println(set.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1325B_CopyCopyCopyCopy {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var amount : int ; amount := parseInt(input.nextLine()) ;
     var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < amount do ( (     set := set->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(set->size()) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class NewClass56 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int a=in.nextInt();
      long x[]=new long[a];
      Set<Long>distinsitElement=new HashSet<>();
      for(int i=0 ; i<a ; i++){
        x[i]=in.nextInt();
        distinsitElement.add(x[i]);
      }
      System.out.println(distinsitElement.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass56 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := in.getCurrent()->toInteger() ;
     var x : Sequence(long) ; x := Integer.subrange(1,a)->collect(0) ;
    var distinsitElement : Set(long) ; distinsitElement := Set{} ;
        var i : int ; i := 0 ; while i < a do ( (     x[i+1] := in.getCurrent()->toInteger() ; 
     distinsitElement := distinsitElement->including(x[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(distinsitElement->size()) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=Integer.parseInt(in.next());
    List<Integer>A=new ArrayList<>();
    for(int i=0 ; i<n ; i++)A.add(Integer.parseInt(in.next()));
    int q=Integer.parseInt(in.next());
    Comparator<Integer>lower=(x,y)->x.compareTo(y)>=0 ? 1 :-1 ;
    Comparator<Integer>upper=(x,y)->x.compareTo(y)>0 ? 1 :-1 ;
    for(int i=0 ; i<q ; i++){
      int key=Integer.parseInt(in.next());
      out.println(~ Collections.binarySearch(A,key,lower)+" "+~ Collections.binarySearch(A,key,upper));
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (in.getCurrent())->toInteger() ;
    var A : Sequence(int) ; A := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     A := A->including((in.getCurrent())->toInteger()) ;  ;     i := i + 1 ) ; 
    var q : int ; q := (in.getCurrent())->toInteger() ;
    var lower : Function(<int>,(<int>,boolean)) ; lower := lambda (x , y) : OclAny in if x->compareTo(y) >= 0 then 1 else -1 endif ;
    var upper : Function(<int>,(<int>,boolean)) ; upper := lambda (x , y) : OclAny in if x->compareTo(y) > 0 then 1 else -1 endif ;
        var i : int ; i := 0 ; while i < q do ( (     var key : int ; key := (in.getCurrent())->toInteger() ;
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      long[] array=new long[n];
      for(int i=0 ; i<n ; i++)array[i]=sc.nextLong();
      int query=sc.nextInt();
      for(int i=0 ; i<query ; i++){
        Long k=sc.nextLong();
        if(k>array[n-1])System.out.println(n+" "+n);
        else {
          System.out.println(lowerBound(array,k)+" "+upperBound(array,k));
        }
      }
    }
  }
  static int lowerBound(long[] array,long target){
    int low=0 ;
    int high=array.length-1 ;
    while(low<high){
      int mid=(high+low)/2 ;
      if(array[mid]==target){
        while((mid!=0)&&(array[mid-1]==target))mid--;
        return mid ;
      }
      else if(array[mid]<target)low=mid+1 ;
      else high=mid ;
    }
    while((high!=0)&&(array[high-1]==array[high]))high--;
    return high ;
  }
  static int upperBound(long[] array,long target){
    int low=0 ;
    int high=array.length-1 ;
    if(array[high]<=target)return array.length ;
    while(low<high){
      int mid=(high+low)/2 ;
      if(array[mid]<=target)low=mid+1 ;
      else high=mid ;
    }
    while((high!=0)&&(array[high-1]==array[high]))high--;
    return high ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var array : Sequence(long) ; array := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     array[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var query : int ; query := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < query do ( (     var k : long ; k := sc.getCurrent()->toLong() ;
     if (k > array[n - 1+1]) then     OclFile["System.out"].println(n + " " + n) ; else (     OclFile["System.out"].println(lowerBound(array, k) + " " + upperBound(array, k)) ) )  ;     i := i + 1 ) ; 
 ))  );
  static   operation lowerBound( array : Sequence(long), target : long) : int
  pre: true
  post: true
  activity: (     var low : int ; low := 0 ;
     var high : int ; high := array->size() - 1 ;
    while (low < high) do (     var mid : int ; mid := (high + low) / 2 ;
     if (array[mid+1] = target) then (     while ((mid /= 0) & (array[mid - 1+1] = target)) do     mid := mid - 1 ; ; 
     return mid ) else     if (array[mid+1] < target) then     low := mid + 1 else     high := mid ; ;  ) ; 
    while ((high /= 0) & (array[high - 1+1] = array[high+1])) do     high := high - 1 ; ; 
    return high 
 );
  static   operation upperBound( array : Sequence(long), target : long) : int
  pre: true
  post: true
  activity: (     var low : int ; low := 0 ;
     var high : int ; high := array->size() - 1 ;
    if (array[high+1] <= target) then     return array->size() else skip ; 
    while (low < high) do (     var mid : int ; mid := (high + low) / 2 ;
     if (array[mid+1] <= target) then     low := mid + 1 ; else     high := mid ; ) ; 
    while ((high /= 0) & (array[high - 1+1] = array[high+1])) do     high := high - 1 ; ; 
    return high 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int i,j,n,q,k,lower_bound,upper_bound ;
    try(Scanner sc=new Scanner(System.in)){
      n=sc.nextInt();
      int[] a=new int[n+1];
      for(i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      q=sc.nextInt();
      for(i=0 ; i<q ; i++){
        k=sc.nextInt();
        lower_bound=Arrays.binarySearch(a,k);
        if(lower_bound<0){
          lower_bound=-lower_bound-1 ;
          if(lower_bound>n){
            lower_bound=n ;
          }
          upper_bound=lower_bound ;
        }
        else {
          upper_bound=lower_bound ;
          while(lower_bound>=1){
            if(a[lower_bound]!=a[lower_bound-1]){
              break ;
            }
            lower_bound--;
          }
          while(upper_bound<=n-1){
            if(a[upper_bound]!=a[upper_bound+1]){
              upper_bound++;
              break ;
            }
            upper_bound++;
          }
        }
        System.out.println(lower_bound+" "+upper_bound);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var n : int ;
    var q : int ;
    var k : int ;
    var lower_bound : int ;
    var upper_bound : int ;
     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     n := sc.getCurrent()->toInteger() ; 
     var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    q := sc.getCurrent()->toInteger() ; 
        i := 0 ; while i < q do ( (     k := sc.getCurrent()->toInteger() ; 
     lower_bound := (a->indexOf(k) - 1) ; 
     if (lower_bound < 0) then (     lower_bound := -lower_bound - 1 ; 
     if (lower_bound > n) then (     lower_bound := n ) else skip ; 
     upper_bound := lower_bound ) else (     upper_bound := lower_bound ; 
     while (lower_bound >= 1) do (     if (a[lower_bound+1] /= a[lower_bound - 1+1]) then (     break ) else skip ; 
     lower_bound := lower_bound - 1 ) ; 
     while (upper_bound <= n - 1) do (     if (a[upper_bound+1] /= a[upper_bound + 1+1]) then (     upper_bound := upper_bound + 1 ; 
     break ) else skip ; 
     upper_bound := upper_bound + 1 ) ) ;  
     OclFile["System.out"].println(lower_bound + " " + upper_bound) )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static StringBuilder sb ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sb=new StringBuilder();
    int num=sc.nextInt();
    ArrayList<Integer>array=new ArrayList<>();
    for(int i=0 ; i<num ; i++){
      array.add(sc.nextInt());
    }
    int query=sc.nextInt();
    for(int i=0 ; i<query ; i++){
      int key=sc.nextInt();
      int lower_bound=LowerBound(array,key);
      if(lower_bound<0)sb.append(num).append(" ");
      else sb.append(lower_bound).append(" ");
      int upper_bound=UpperBound(array,key);
      if(upper_bound<0)sb.append(num).append("\n");
      else sb.append(upper_bound).append("\n");
    }
    System.out.print(sb);
    sc.close();
  }
  public static int LowerBound(List<Integer>list,int key){
    int lower=-1 ;
    int middle=-1 ;
    int upper=list.size();
    while(upper>lower+1){
      middle=lower+(upper-lower)/2 ;
      if(list.get(middle)>key-1)upper=middle ;
      else lower=middle ;
    }
    return upper ;
  }
  public static int UpperBound(List<Integer>list,int key){
    int lower=-1 ;
    int middle=-1 ;
    int upper=list.size();
    while(upper>lower+1){
      middle=lower+(upper-lower)/2 ;
      if(list.get(middle)>key)upper=middle ;
      else lower=middle ;
    }
    return upper ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sb : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     sb := StringLib.newString() ; 
    var num : int ; num := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Sequence{} ;
        var i : int ; i := 0 ; while i < num do ( (     array := array->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var query : int ; query := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < query do ( (     var key : int ; key := sc.getCurrent()->toInteger() ;
     var lower_bound : int ; lower_bound := LowerBound(array, key) ;
    if (lower_bound < 0) then     sb := sb + StringLib.newString(num) + StringLib.newString(" ") else     sb := sb + StringLib.newString(lower_bound) + StringLib.newString(" ") ; ;  
    var upper_bound : int ; upper_bound := UpperBound(array, key) ;
    if (upper_bound < 0) then     sb := sb + StringLib.newString(num) + StringLib.newString("\n") else     sb := sb + StringLib.newString(upper_bound) + StringLib.newString("\n") ; ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
    skip ; 
 );
  static   operation LowerBound( list : Sequence(int), key : int) : int
  pre: true
  post: true
  activity: (     var lower : int ; lower := -1 ;
     var middle : int ; middle := -1 ;
    var upper : int ; upper := list->size() ;
    while (upper > lower + 1) do (     middle := lower + (upper - lower) / 2 ; 
     if (list->at(middle+1) > key - 1) then     upper := middle ; else     lower := middle ; ) ; 
    return upper 
 );
  static   operation UpperBound( list : Sequence(int), key : int) : int
  pre: true
  post: true
  activity: (     var lower : int ; lower := -1 ;
     var middle : int ; middle := -1 ;
    var upper : int ; upper := list->size() ;
    while (upper > lower + 1) do (     middle := lower + (upper - lower) / 2 ; 
     if (list->at(middle+1) > key) then     upper := middle ; else     lower := middle ; ) ; 
    return upper 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int[] a=new int[n+1];
    a[0]=-1000000001 ;
    str=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++)a[i+1]=Integer.parseInt(str[i]);
    str=br.readLine().split(" ");
    int q=Integer.parseInt(str[0]);
    for(int i=0 ; i<q ; i++){
      str=br.readLine().split(" ");
      int k=Integer.parseInt(str[0]);
      int lb=0 ;
      int ub=n+1 ;
      while(ub-lb>1){
        int mid=lb+(ub-lb)/2 ;
        if(a[mid]>=k)ub=mid ;
        else lb=mid ;
      }
      System.out.print((ub-1)+" ");
      lb=0 ;
      ub=n+1 ;
      while(ub-lb>1){
        int mid=lb+(ub-lb)/2 ;
        if(a[mid]>k)ub=mid ;
        else lb=mid ;
      }
      System.out.println(ub-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    a[0+1] := -1000000001 ; 
    str := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do (     a[i + 1+1] := (str[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    str := br.readLine()->split(" ") ; 
    var q : int ; q := (str[0+1])->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     str := br.readLine()->split(" ") ; 
     var k : int ; k := (str[0+1])->toInteger() ;
    var lb : int ; lb := 0 ;
    var ub : int ; ub := n + 1 ;
    while (ub - lb > 1) do (     var mid : int ; mid := lb + (ub - lb) / 2 ;
     if (a[mid+1] >= k) then     ub := mid ; else     lb := mid ; ) ; 
    OclFile["System.out"].print((ub - 1) + " ") ; 
    lb := 0 ; 
    ub := n + 1 ; 
    while (ub - lb > 1) do (     var mid : int ; mid := lb + (ub - lb) / 2 ;
     if (a[mid+1] > k) then     ub := mid ; else     lb := mid ; ) ; 
    OclFile["System.out"].println(ub - 1) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void countFreq(int[] a,int n){
    HashMap<Integer,Integer>hm=new HashMap<>();
    for(int i=0 ; i<n ; i++)hm.put(a[i],hm.get(a[i])==null ? 1 : hm.get(a[i])+1);
    SortedMap<Integer,Integer>st=new TreeMap<>();
    for(HashMap.Entry<Integer,Integer>x : hm.entrySet()){
      st.put(x.getKey(),x.getValue());
    }
    int cumul=0 ;
    for(SortedMap.Entry<Integer,Integer>x : st.entrySet()){
      cumul+=x.getValue();
      System.out.println(x.getKey()+" "+cumul);
    }
  }
  public static void main(String[] args){
    int[] a={
      1,3,2,4,2,1 };
      int n=a.length ;
      countFreq(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countFreq( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var hm : Map(int,int) ; hm := Map{} ;
         var i : int ; i := 0 ; while i < n do (     hm := hm->union(Map{a[i+1] |-> if hm->at(a[i+1]) = null then 1 else hm->at(a[i+1]) + 1 endif}) ;  ;     i := i + 1 ) ; 
    var st : Map(int,int) ; st := Map{} ;
    for (x : hm->asSet()) do ( (     st := st->union(Map{x.getKey() |-> x.getValue()}) )  ) ; 
    var cumul : int ; cumul := 0 ;
    for (x : st->asSet()) do ( (     cumul := cumul+(x.getValue()) ; 
     OclFile["System.out"].println(x.getKey() + " " + cumul) )  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,3,2,4,2,1} ;
     var n : int ; n := a->size() ;
     execute countFreq(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static String K_String(String s,int k){
    int n=s.length();
    int fre[]=new int[26];
    for(int i=0 ; i<n ; i++)fre[s.charAt(i)-'a']++;
    String str="" ;
    for(int i=0 ; i<26 ; i++){
      if(fre[i] % k==0){
        int x=fre[i]/k ;
        while(x!=0){
          str+=(char)(i+'a');
          x--;
        }
      }
      else {
        return "-1" ;
      }
    }
    return str ;
  }
  public static void main(String[] args){
    String s="aabb" ;
    int k=2 ;
    System.out.println(K_String(s,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation K_String( s : String, k : int) : String
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var fre : Sequence(int) ; fre := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     fre[s->at(i+1) - ('a')->char2byte()+1] := fre[s->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    var str : String ; str := "" ;
        var i : int ; i := 0 ; while i < 26 do ( (     if (fre[i+1] mod k = 0) then (     var x : int ; x := fre[i+1] / k ;
     while (x /= 0) do (     str := str+((i + 'a')->oclAsType(String)) ; 
     x := x - 1 ) ) else (     return "-1" ) )  ;     i := i + 1 ) ; 
    return str 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "aabb" ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(K_String(s, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] h=new int[n];
    for(int i=0 ; i<n ; i++){
      h[i]=sc.nextInt();
    }
    int count=0 ;
    int max=0 ;
    for(int i=n-1 ; i>0 ; i--){
      if(h[i-1]>=h[i]){
        count++;
      }
      else {
        if(count>max){
          max=count ;
        }
        count=0 ;
      }
    }
    if(count>max){
      max=count ;
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var h : Sequence(int) ; h := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     h[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := n - 1 ; while i > 0 do ( (     if (h[i - 1+1] >= h[i+1]) then (     count := count + 1 ) else (     if (count > max) then (     max := count ) else skip ; 
     count := 0 ) )  ;     i := i - 1 ) ; 
    if (count > max) then (     max := count ) else skip ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s1=sc.next();
    String s2=sc.next();
    String s3=sc.next();
    if(s1.equals("rock")&& s2.equals("scissors")&& s2.equals(s3)){
      System.out.println("F");
    }
    else if(s1.equals("paper")&& s2.equals("rock")&& s2.equals(s3)){
      System.out.println("F");
    }
    else if(s1.equals("scissors")&& s2.equals("paper")&& s2.equals(s3)){
      System.out.println("F");
    }
    else if(s2.equals("rock")&& s1.equals("scissors")&& s1.equals(s3)){
      System.out.println("M");
    }
    else if(s2.equals("paper")&& s1.equals("rock")&& s1.equals(s3)){
      System.out.println("M");
    }
    else if(s2.equals("scissors")&& s1.equals("paper")&& s1.equals(s3)){
      System.out.println("M");
    }
    else if(s3.equals("rock")&& s2.equals("scissors")&& s2.equals(s1)){
      System.out.println("S");
    }
    else if(s3.equals("paper")&& s2.equals("rock")&& s2.equals(s1)){
      System.out.println("S");
    }
    else if(s3.equals("scissors")&& s2.equals("paper")&& s2.equals(s1)){
      System.out.println("S");
    }
    else System.out.println("?");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := sc.getCurrent() ;
    var s2 : String ; s2 := sc.getCurrent() ;
    var s3 : String ; s3 := sc.getCurrent() ;
    if (s1 = "rock" & s2 = "scissors" & s2 = s3) then (     OclFile["System.out"].println("F") ) else     if (s1 = "paper" & s2 = "rock" & s2 = s3) then (     OclFile["System.out"].println("F") ) else     if (s1 = "scissors" & s2 = "paper" & s2 = s3) then (     OclFile["System.out"].println("F") ) else     if (s2 = "rock" & s1 = "scissors" & s1 = s3) then (     OclFile["System.out"].println("M") ) else     if (s2 = "paper" & s1 = "rock" & s1 = s3) then (     OclFile["System.out"].println("M") ) else     if (s2 = "scissors" & s1 = "paper" & s1 = s3) then (     OclFile["System.out"].println("M") ) else     if (s3 = "rock" & s2 = "scissors" & s2 = s1) then (     OclFile["System.out"].println("S") ) else     if (s3 = "paper" & s2 = "rock" & s2 = s1) then (     OclFile["System.out"].println("S") ) else     if (s3 = "scissors" & s2 = "paper" & s2 = s1) then (     OclFile["System.out"].println("S") ) else     OclFile["System.out"].println("?") ; ;  ;  ;  ;  ;  ;  ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdin=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int N=Integer.parseInt(stdin.next());
    int H[]=new int[N];
    int max=0 ;
    int cnt=0 ;
    for(int i=0 ; i<N ; i++){
      H[i]=Integer.parseInt(stdin.next());
    }
    for(int i=0 ; i<N-1 ; i++){
      if(H[i]>=H[i+1]){
        cnt+=1 ;
      }
      else if(H[i]<H[i+1]){
        if(max<cnt){
          max=cnt ;
        }
        cnt=0 ;
      }
    }
    if(max<cnt){
      max=cnt ;
    }
    System.out.println(max);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := (stdin.getCurrent())->toInteger() ;
    var H : Sequence(int) ; H := Integer.subrange(1,N)->collect(0) ;
    var max : int ; max := 0 ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     H[i+1] := (stdin.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     if (H[i+1] >= H[i + 1+1]) then (     cnt := cnt+(1) ) else     if (H[i+1] < H[i + 1+1]) then (     if (max < cnt) then (     max := cnt ) else skip ; 
     cnt := 0 ) else skip ; )  ;     i := i + 1 ) ; 
    if (max < cnt) then (     max := cnt ) else skip ; 
    OclFile["System.out"].println(max) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int ans=0 ;
    int N=sc.nextInt();
    long now=sc.nextLong();
    long next=0 ;
    int moveNow=0 ;
    int moveMax=0 ;
    for(int i=1 ; i<N ; i++){
      next=sc.nextLong();
      if(now>=next){
        moveNow++;
      }
      else {
        if(moveMax<moveNow){
          moveMax=moveNow ;
        }
        moveNow=0 ;
      }
      now=next ;
    }
    if(moveMax<moveNow){
      moveMax=moveNow ;
    }
    System.out.println(moveMax);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ans : int ; ans := 0 ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var now : long ; now := sc.getCurrent()->toLong() ;
    var next : long ; next := 0 ;
    var moveNow : int ; moveNow := 0 ;
    var moveMax : int ; moveMax := 0 ;
        var i : int ; i := 1 ; while i < N do ( (     next := sc.getCurrent()->toLong() ; 
     if (now >= next) then (     moveNow := moveNow + 1 ) else (     if (moveMax < moveNow) then (     moveMax := moveNow ) else skip ; 
     moveNow := 0 ) ;  
     now := next )  ;     i := i + 1 ) ; 
    if (moveMax < moveNow) then (     moveMax := moveNow ) else skip ; 
    OclFile["System.out"].println(moveMax) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int ans=0 ;
    int curH=-1 ;
    int curMax=0 ;
    while(N-->0){
      int nextH=sc.nextInt();
      if(curH>=nextH){
        ans++;
      }
      else {
        curMax=Math.max(curMax,ans);
        ans=0 ;
      }
      curH=nextH ;
    }
    curMax=Math.max(curMax,ans);
    System.out.println(curMax);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    var curH : int ; curH := -1 ;
    var curMax : int ; curMax := 0 ;
        while (N > 0) do (        N := N - 1 ;     skip ; (     var nextH : int ; nextH := sc.getCurrent()->toInteger() ;
     if (curH >= nextH) then (     ans := ans + 1 ) else (     curMax := Set{curMax, ans}->max() ; 
     ans := 0 ) ;  
     curH := nextH ) ;  ) ;  
    curMax := Set{curMax, ans}->max() ; 
    OclFile["System.out"].println(curMax) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  static int checkBit(int pattern,int arr[],int n){
    int count=0 ;
    for(int i=0 ; i<n ; i++)if((pattern & arr[i])==pattern)count++;
    return count ;
  }
  static int maxAND(int arr[],int n){
    int res=0,count ;
    for(int bit=31 ; bit>=0 ; bit--){
      count=checkBit(res |(1<<bit),arr,n);
      if(count>=2)res |=(1<<bit);
    }
    return res ;
  }
  public static void main(String argc[]){
    int arr[]={
      4,8,6,2 };
      int n=arr.length ;
      System.out.println("Maximum AND Value="+maxAND(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation checkBit( pattern : int, arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do (     if ((pattern & arr[i+1]) = pattern) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return count );
  static   operation maxAND( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
    var count : int ;
         var bit : int ; bit := 31 ; while bit >= 0 do ( (     count := checkBit(MathLib.bitwiseOr(res,((1*(2->pow(bit)))->oclAsType(long))), arr, n) ; 
     if (count >= 2) then     res := MathLib.bitwiseOr(res, ((1*(2->pow(bit)))->oclAsType(long))) ; else skip )  ;     bit := bit - 1 ) ; 
     return res );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,8,6,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Maximum AND Value=" + maxAND(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static boolean arePermutation(String str1,String str2){
    int n1=str1.length();
    int n2=str2.length();
    if(n1!=n2)return false ;
    char ch1[]=str1.toCharArray();
    char ch2[]=str2.toCharArray();
    Arrays.sort(ch1);
    Arrays.sort(ch2);
    for(int i=0 ; i<n1 ; i++)if(ch1[i]!=ch2[i])return false ;
    return true ;
  }
  public static void main(String[] args){
    String str1="test" ;
    String str2="ttew" ;
    if(arePermutation(str1,str2))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation arePermutation( str1 : String, str2 : String) : boolean
  pre: true
  post: true
  activity: (     var n1 : int ; n1 := str1->size() ;
     var n2 : int ; n2 := str2->size() ;
    if (n1 /= n2) then     return false else skip ; 
    var ch1 : Sequence(String) ; ch1 := str1->characters() ;
    var ch2 : Sequence(String) ; ch2 := str2->characters() ;
    ch1 := ch1->sort() ; 
    ch2 := ch2->sort() ; 
        var i : int ; i := 0 ; while i < n1 do (     if (ch1[i+1] /= ch2[i+1]) then     return false else skip ;  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "test" ;
     var str2 : String ; str2 := "ttew" ;
     if (arePermutation(str1, str2)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      int n=Integer.parseInt(br.readLine());
      if(n==0){
        break ;
      }
      String[] tmpArray=br.readLine().split(" ");
      final int OFF=0 ;
      final int ON=1 ;
      int position=OFF ;
      int right=OFF ;
      int left=OFF ;
      int count=0 ;
      for(int i=0 ; i<n ; i++){
        String com=tmpArray[i];
        if(com.equals("lu")){
          left=ON ;
        }
        if(com.equals("ld")){
          left=OFF ;
        }
        if(com.equals("ru")){
          right=ON ;
        }
        if(com.equals("rd")){
          right=OFF ;
        }
        if(left==right && left!=position){
          position=left ;
          count++;
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var n : int ; n := (br.readLine())->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
    var OFF : int ; OFF := 0 ;
    var ON : int ; ON := 1 ;
    var position : int ; position := OFF ;
    var right : int ; right := OFF ;
    var left : int ; left := OFF ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var com : String ; com := tmpArray[i+1] ;
     if (com = "lu") then (     left := ON ) else skip ; 
    if (com = "ld") then (     left := OFF ) else skip ; 
    if (com = "ru") then (     right := ON ) else skip ; 
    if (com = "rd") then (     right := OFF ) else skip ; 
    if (left = right & left /= position) then (     position := left ; 
     count := count + 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
import java.util.stream.Stream ;
public class Main {
  public enum pattern {
    lu,ru,ld,rd,;
  }
  static Scanner scan=new Scanner(System.in);
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine().trim())!=null && ! "0".equals(line)){
      int ans=0 ;
      String[] input=line.split(" ");
      if(Stream.of(pattern.values()).map(e->e.name()).anyMatch(code->code.equals(input[0]))){
        for(int i=0 ; i<input.length ; i++){
          if(i<input.length-1 && input[i] .substring(1).equals("u")==input[i+1] .substring(1).equals("u"))ans++;
          if(i<input.length-1 && input[i] .substring(1).equals("d")==input[i+1] .substring(1).equals("d"))ans++;
        }
        System.out.println(ans/2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   class pattern {     static attribute lu : SelfClass := SelfClass.newSelfClass();
    static attribute ru : SelfClass := SelfClass.newSelfClass();
    static attribute ld : SelfClass := SelfClass.newSelfClass();
    static attribute rd : SelfClass := SelfClass.newSelfClass();
  }
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine()->trim() ;
    while ((line) /= null & not("0" = line)) do (    skip ; (     var ans : int ; ans := 0 ;
     var input : Sequence(String) ; input := line->split(" ") ;
     if (Sequence{pattern.allInstances()}->collect( _x1 | (lambda e : OclAny in e.name())->apply(_x1) )->exists( _x2 | (lambda code : OclAny in code = input[0+1])->apply(_x2) )) then (         var i : int ; i := 0 ; while i < input->size() do ( (     if (i < input->size() - 1 & input[i+1].subrange(1+1,1) = "u" = input[i + 1+1].subrange(1+1,1) = "u") then     ans := ans + 1 ; else skip ; 
     if (i < input->size() - 1 & input[i+1].subrange(1+1,1) = "d" = input[i + 1+1].subrange(1+1,1) = "d") then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans / 2) ) else skip ) ;     line := br.readLine()->trim() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
import javax.xml.crypto.Data ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      double[][] dp=new double[n+1][25];
      dp[0][0]=1.0 ;
      double sum=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<24 ; j++){
          double pp=Math.pow(2.0,j);
          dp[i+1][j+1]+=dp[i][j]*1.0/pp ;
          dp[i+1][0]+=dp[i][j]*(1.0-(1.0/pp));
          sum+=j*dp[i][j]*(1.0-(1.0/pp));
        }
      }
      for(int j=0 ; j<25 ; j++){
        sum+=j*dp[n][j];
      }
      System.out.printf("%.20f\n",sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var dp : Sequence(Sequence(double)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,25)->collect(0.0)) ;
    dp[0+1][0+1] := 1.0 ; 
    var sum : double ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 24 do ( (     var pp : double ; pp := 2.0->pow(j) ;
     dp[i + 1+1][j + 1+1] := dp[i + 1+1][j + 1+1]+(dp[i+1][j+1] * 1.0 / pp) ; 
     dp[i + 1+1][0+1] := dp[i + 1+1][0+1]+(dp[i+1][j+1] * (1.0 - (1.0 / pp))) ; 
     sum := sum+(j * dp[i+1][j+1] * (1.0 - (1.0 / pp))) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < 25 do ( (     sum := sum+(j * dp[n+1][j+1]) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].printf("%.20f\n", sum) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int l,r,count,n,ud ;
    String f ;
    for(; ; ){
      n=sc.nextInt();
      if(n==0)break ;
      count=0 ;
      l=0 ;
      r=0 ;
      ud=0 ;
      for(; n-->0 ; ){
        f=sc.next();
        if("lu".equals(f)){
          if(ud==0 && l==0 && r==1){
            count++;
            ud=1 ;
          }
          l=1 ;
        }
        else if("ru".equals(f)){
          if(ud==0 && l==1 && r==0){
            count++;
            ud=1 ;
          }
          r=1 ;
        }
        else if("ld".equals(f)){
          if(ud==1 && l==1 && r==0){
            count++;
            ud=0 ;
          }
          l=0 ;
        }
        else {
          if(ud==1 && l==0 && r==1){
            count++;
            ud=0 ;
          }
          r=0 ;
        }
      }
      out.println(count);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var l : int ;
    var r : int ;
    var count : int ;
    var n : int ;
    var ud : int ;
    var f : String ;
      while true do ( (     n := sc.nextInt() ; 
     if (n = 0) then     break else skip ; 
    count := 0 ; 
    l := 0 ; 
    r := 0 ; 
    ud := 0 ; 
      while n > 0 do ( (     f := sc.next() ; 
     if ("lu" = f) then (     if (ud = 0 & l = 0 & r = 1) then (     count := count + 1 ; 
     ud := 1 ) else skip ; 
     l := 1 ) else     if ("ru" = f) then (     if (ud = 0 & l = 1 & r = 0) then (     count := count + 1 ; 
     ud := 1 ) else skip ; 
     r := 1 ) else     if ("ld" = f) then (     if (ud = 1 & l = 1 & r = 0) then (     count := count + 1 ; 
     ud := 0 ) else skip ; 
     l := 0 ) else (     if (ud = 1 & l = 0 & r = 1) then (     count := count + 1 ; 
     ud := 0 ) else skip ; 
     r := 0 ) ;  ;  )  ) ; 
    out.println(count) ; 
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Spliterator ;
import java.util.Spliterators ;
import java.util.concurrent.ThreadLocalRandom ;
import java.util.concurrent.atomic.AtomicInteger ;
import java.util.stream.IntStream ;
import java.util.stream.Stream ;
import java.util.stream.StreamSupport ;
public class Main {
  static final Scanner s=new Scanner(System.in);
  static final long[] fal_rnd(int size){
    AtomicInteger l=new AtomicInteger(-1),r=new AtomicInteger(size);
    long[] res=new long[size];
    INS(size).unordered().parallel().mapToLong(Long :: parseLong).forEach(v->res[ThreadLocalRandom.current().nextBoolean()? l.incrementAndGet(): r.decrementAndGet()]=v);
    return res ;
  }
  static final IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static final Stream<String>INS(long size){
    return StreamSupport.stream(Spliterators.spliterator(s,size,Spliterator.NONNULL & Spliterator.IMMUTABLE),false).limit(size);
  }
  public static void main(String __[]){
    int n ;
    while(true){
      n=s.nextInt();
      if(n==0)return ;
      s.nextLine();
      String in=s.nextLine().replaceAll("[rl] ","").replaceAll("(uu|dd)","#").replaceAll("[^#] ","");
      System.out.println(in.length());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    operation fal_rnd( size : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var l : int ; l := (-1) ;
    var r : int ; r := (size) ;
     var res : Sequence(long) ; res := Integer.subrange(1,size)->collect(0) ;
     for v : INS(size)->collect( _x1 | (lambda _s : String in _s->toLong())->apply(_x1) ) do
    (    res[if MathLib.nextBoolean() then l+1 else r-1 endif+1] := v) ; 
     return res );
  static    operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static    operation INS( size : long) : Stream<String>
  pre: true
  post: true
  activity: (     return (OclIterator.newOclIterator_Sequence(s)).elements.subrange(1,size) );
  static   operation main( __ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     while (true) do (     n := s.getCurrent()->toInteger() ; 
     if (n = 0) then     return else skip ; 
    skip ; 
    var in : String ; in := s.nextLine().replaceAllMatches("[rl] ", "" ).replaceAllMatches("(uu|dd)", "#" ).replaceAllMatches("[^#] ", "" ) ;
    OclFile["System.out"].println(in->size()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MyClass {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    String F=in.next();
    String M=in.next();
    String S=in.next();
    int rock=(F.equals("rock")? 1 : 0)+(M.equals("rock")? 1 : 0)+(S.equals("rock")? 1 : 0);
    int paper=(F.equals("paper")? 1 : 0)+(M.equals("paper")? 1 : 0)+(S.equals("paper")? 1 : 0);
    int scissors=(F.equals("scissors")? 1 : 0)+(M.equals("scissors")? 1 : 0)+(S.equals("scissors")? 1 : 0);
    String winner="?" ;
    if(rock==2 && paper==1){
      if(F.equals("paper")){
        winner="F" ;
      }
      else if(M.equals("paper")){
        winner="M" ;
      }
      else if(S.equals("paper")){
        winner="S" ;
      }
    }
    else if(paper==2 && scissors==1){
      if(F.equals("scissors")){
        winner="F" ;
      }
      else if(M.equals("scissors")){
        winner="M" ;
      }
      else if(S.equals("scissors")){
        winner="S" ;
      }
    }
    else if(scissors==2 && rock==1){
      if(F.equals("rock")){
        winner="F" ;
      }
      else if(M.equals("rock")){
        winner="M" ;
      }
      else if(S.equals("rock")){
        winner="S" ;
      }
    }
    System.out.println(winner);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var F : String ; F := in.getCurrent() ;
    var M : String ; M := in.getCurrent() ;
    var S : String ; S := in.getCurrent() ;
    var rock : int ; rock := (if F = "rock" then 1 else 0 endif) + (if M = "rock" then 1 else 0 endif) + (if S = "rock" then 1 else 0 endif) ;
    var paper : int ; paper := (if F = "paper" then 1 else 0 endif) + (if M = "paper" then 1 else 0 endif) + (if S = "paper" then 1 else 0 endif) ;
    var scissors : int ; scissors := (if F = "scissors" then 1 else 0 endif) + (if M = "scissors" then 1 else 0 endif) + (if S = "scissors" then 1 else 0 endif) ;
    var winner : String ; winner := "?" ;
    if (rock = 2 & paper = 1) then (     if (F = "paper") then (     winner := "F" ) else     if (M = "paper") then (     winner := "M" ) else     if (S = "paper") then (     winner := "S" ) else skip ; ;  ) else     if (paper = 2 & scissors = 1) then (     if (F = "scissors") then (     winner := "F" ) else     if (M = "scissors") then (     winner := "M" ) else     if (S = "scissors") then (     winner := "S" ) else skip ; ;  ) else     if (scissors = 2 & rock = 1) then (     if (F = "rock") then (     winner := "F" ) else     if (M = "rock") then (     winner := "M" ) else     if (S = "rock") then (     winner := "S" ) else skip ; ;  ) else skip ; ;  ;  
    OclFile["System.out"].println(winner) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int input_num=sc.nextInt();
      if(input_num==0)break ;
      int count=0 ;
      List<String>step_list=new ArrayList<String>();
      for(int i=0 ; i<input_num ; i++){
        step_list.add(sc.next());
      }
      for(int i=0 ; i<input_num-1 ; i++){
        String step=step_list.get(i);
        switch(step){
          case "lu" : if(step_list.get(i+1).equals("ru"))count++;
          break ;
          case "ru" : if(step_list.get(i+1).equals("lu"))count++;
          break ;
          case "ld" : if(step_list.get(i+1).equals("rd"))count++;
          break ;
          case "rd" : if(step_list.get(i+1).equals("ld"))count++;
          break ;
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var input_num : int ; input_num := sc.getCurrent()->toInteger() ;
     if (input_num = 0) then     break else skip ; 
    var count : int ; count := 0 ;
    var step_list : Sequence(String) ; step_list := Sequence{} ;
        var i : int ; i := 0 ; while i < input_num do ( (     step_list := step_list->including(sc.getCurrent()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < input_num - 1 do ( (     var step : String ; step := step_list->at(i+1) ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (step) ; 
       if _switchval = "lu" then
     if (step_list->at(i + 1+1) = "ru") then     count := count + 1 ; else skip ; 
    break 
   else skip ;
       if _switchval = "ru" then
     if (step_list->at(i + 1+1) = "lu") then     count := count + 1 ; else skip ; 
    break 
   else skip ;
       if _switchval = "ld" then
     if (step_list->at(i + 1+1) = "rd") then     count := count + 1 ; else skip ; 
    break 
   else skip ;
       if _switchval = "rd" then
     if (step_list->at(i + 1+1) = "ld") then     count := count + 1 ; else skip ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),w=sc.nextInt();
    int a[]=new int[2*n];
    for(int i=0 ; i<2*n ; ++i)a[i]=sc.nextInt();
    Arrays.sort(a);
    long ans=Math.min(3L*Math.min(a[0]*2,a[n])*n,2*w);
    System.out.printf("%.15g\n",ans/2.0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,2 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 * n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var ans : long ; ans := Set{3L * Set{a[0+1] * 2, a[n+1]}->min() * n, 2 * w}->min() ;
    OclFile["System.out"].printf("%.15g\n", ans / 2.0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import com.sun.org.apache.bcel.internal.generic.AALOAD ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
import java.util.stream.IntStream ;
import javafx.util.Pair ;
public class Main {
  static void sort(double a[]){
    Random ran=new Random();
    for(int i=0 ; i<a.length ; i++){
      int r=ran.nextInt(a.length);
      double temp=a[r];
      a[r]=a[i];
      a[i]=temp ;
    }
    Arrays.sort(a);
  }
  public static void main(String[] args)throws IOException {
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    double w=input.nextInt();
    double a[]=new double[n*2];
    for(int i=0 ; i<n*2 ; i++){
      a[i]=input.nextDouble();
    }
    sort(a);
    double min=Math.min(a[0],(a[n]/2.0));
    double total=((min*n)+(min*2)*n);
    if(total>w){
      System.out.printf("%.6f\n",w);
    }
    else {
      System.out.printf("%.6f\n",total);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation sort( a : Sequence(double)) : void
  pre: true
  post: true
  activity: (     var ran : OclRandom ; ran := OclRandom.newOclRandom() ;
         var i : int ; i := 0 ; while i < a->size() do ( (     var r : int ; r := ran.nextInt(a->size()) ;
     var temp : double ; temp := a[r+1] ;
     a[r+1] := a[i+1] ; 
     a[i+1] := temp )  ;     i := i + 1 ) ; 
     a := a->sort() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var w : double ; w := input.getCurrent()->toInteger() ;
    var a : Sequence(double) ; a := Integer.subrange(1,n * 2)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n * 2 do ( (     a[i+1] := input.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
    execute sort(a) ; 
    var min : double ; min := Set{a[0+1], (a[n+1] / 2.0)}->min() ;
    var total : double ; total := ((min * n) + (min * 2) * n) ;
    if (total > w) then (     OclFile["System.out"].printf("%.6f\n", w) ) else (     OclFile["System.out"].printf("%.6f\n", total) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class p021 {
  public static void main(String args[])throws Exception {
    StringTokenizer stok=new StringTokenizer(new Scanner(System.in).useDelimiter("\\A").next());
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(stok.nextToken());
    int w=Integer.parseInt(stok.nextToken());
    int[] a=new int[2*n];
    for(int i=0 ; i<2*n ; i++){
      a[i]=Integer.parseInt(stok.nextToken());
    }
    Arrays.sort(a);
    int v1=a[0],v2=a[n];
    double v=(v2>2*v1)?(double)v1 : v2/(double)2 ;
    v=v*3*n ;
    if(v>w)v=w ;
    System.out.println(v);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p021 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stok : OclIterator ; stok := OclIterator.newOclIterator_String(OclFile.newOclFile_Read(OclFile["System.in"]).useDelimiter("\\A").next()) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (stok.next())->toInteger() ;
    var w : int ; w := (stok.next())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,2 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     a[i+1] := (stok.next())->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var v1 : int ; v1 := a[0+1] ;
    var v2 : int ; v2 := a[n+1] ;
    var v : double ; v := if (v2 > 2 * v1) then v1->oclAsType(double) else v2 / 2->oclAsType(double) endif ;
    v := v * 3 * n ; 
    if (v > w) then     v := w ; else skip ; 
    OclFile["System.out"].println(v) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1207 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      int b=scanner.nextInt();
      int p=scanner.nextInt();
      int f=scanner.nextInt();
      int h=scanner.nextInt();
      int c=scanner.nextInt();
      int ans=0 ;
      int food1,food2,cost1,cost2 ;
      if(h>=c){
        food1=p ;
        food2=f ;
        cost1=h ;
        cost2=c ;
      }
      else {
        food1=f ;
        food2=p ;
        cost1=c ;
        cost2=h ;
      }
      if(b>=food1*2){
        ans+=food1*cost1 ;
        b-=2*food1 ;
      }
      else {
        ans+=(b/2)*cost1 ;
        b %=2 ;
      }
      if(b>=food2*2){
        ans+=food2*cost2 ;
        b-=2*food2 ;
      }
      else {
        ans+=(b/2)*cost2 ;
        b %=2 ;
      }
      System.out.println(ans);
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1207 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var b : int ; b := scanner.getCurrent()->toInteger() ;
     var p : int ; p := scanner.getCurrent()->toInteger() ;
    var f : int ; f := scanner.getCurrent()->toInteger() ;
    var h : int ; h := scanner.getCurrent()->toInteger() ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    var food1 : int ;
    var food2 : int ;
    var cost1 : int ;
    var cost2 : int ;
    if (h >= c) then (     food1 := p ; 
     food2 := f ; 
     cost1 := h ; 
     cost2 := c ) else (     food1 := f ; 
     food2 := p ; 
     cost1 := c ; 
     cost2 := h ) ;  
    if (b >= food1 * 2) then (     ans := ans+(food1 * cost1) ; 
     b := b-(2 * food1) ) else (     ans := ans+((b / 2) * cost1) ; 
     b := b mod 2 ) ;  
    if (b >= food2 * 2) then (     ans := ans+(food2 * cost2) ; 
     b := b-(2 * food2) ) else (     ans := ans+((b / 2) * cost2) ; 
     b := b mod 2 ) ;  
    OclFile["System.out"].println(ans) ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1207 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    while(sc.hasNext()){
      int b=sc.nextInt(),p=sc.nextInt(),f=sc.nextInt();
      int pa=sc.nextInt(),pb=sc.nextInt();
      int sum=0,c=0,d=0 ;
      b=b/2 ;
      if(pa>pb){
        c=Math.min(b,p);
        d=Math.min(b-c,f);
        sum=pa*c+d*pb ;
      }
      else {
        c=Math.min(b,f);
        d=Math.min(b-c,p);
        sum=pb*c+d*pa ;
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1207 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     while (sc.hasNext()) do (     var b : int ; b := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
    var f : int ; f := sc.getCurrent()->toInteger() ;
     var pa : int ; pa := sc.getCurrent()->toInteger() ;
    var pb : int ; pb := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var c : int ; c := 0 ;
    var d : int ; d := 0 ;
    b := b / 2 ; 
    if (pa > pb) then (     c := Set{b, p}->min() ; 
     d := Set{b - c, f}->min() ; 
     sum := pa * c + d * pb ) else (     c := Set{b, f}->min() ; 
     d := Set{b - c, p}->min() ; 
     sum := pb * c + d * pa ) ;  
    OclFile["System.out"].println(sum) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    Map<Character,int[]>memo=new HashMap<Character,int[]>();
    memo.put('N',new int[] {
      1,5,2,3,0,4 }
);
      memo.put('E',new int[] {
        3,1,0,5,4,2 }
);
        memo.put('W',new int[] {
          2,1,5,0,4,3 }
);
          memo.put('S',new int[] {
            4,0,2,3,5,1 }
);
            memo.put('R',new int[] {
              0,2,4,1,3,5 }
);
              memo.put('L',new int[] {
                0,3,1,4,2,5 }
);
                while(true){
                  int n=scanner.nextInt();
                  if(n==0)break ;
                  int[] dice=new int[6];
                  for(int i=0 ; i<6 ; i++)dice[i]=i+1 ;
                  int ans=1 ;
                  for(int i=0 ; i<n ; i++){
                    char c=scanner.next().charAt(0);
                    int[] tmp=new int[6];
                    for(int j=0 ; j<6 ; j++){
                      tmp[j]=dice[memo.get(c)[j] ];
                    }
                    dice=tmp ;
                    ans+=dice[0];
                  }
                  System.out.println(ans);
                }
              }
            }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var memo : Map(String,Sequence(int)) ; memo := Map{} ;
    memo := memo->union(Map{'N' |-> Sequence{1,5,2,3,0,4}}) ; 
    memo := memo->union(Map{'E' |-> Sequence{3,1,0,5,4,2}}) ; 
    memo := memo->union(Map{'W' |-> Sequence{2,1,5,0,4,3}}) ; 
    memo := memo->union(Map{'S' |-> Sequence{4,0,2,3,5,1}}) ; 
    memo := memo->union(Map{'R' |-> Sequence{0,2,4,1,3,5}}) ; 
    memo := memo->union(Map{'L' |-> Sequence{0,3,1,4,2,5}}) ; 
    while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var dice : Sequence(int) ; dice := Integer.subrange(1,6)->collect(0) ;
        var i : int ; i := 0 ; while i < 6 do (     dice[i+1] := i + 1 ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     var c : String ; c := scanner.getCurrent()->at(0+1) ;
     var tmp : Sequence(int) ; tmp := Integer.subrange(1,6)->collect(0) ;
        var j : int ; j := 0 ; while j < 6 do ( (     tmp[j+1] := dice[memo->at(c)[j+1]+1] )  ;     j := j + 1 ) ; 
    dice := tmp ; 
    ans := ans+(dice[0+1]) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  final int MAX_N=100009 ;
  final int MAX_DEPTH=20 ;
  double[][] dp=new double[MAX_N][MAX_DEPTH];
  double[][] prob=new double[MAX_N][MAX_DEPTH];
  void run(){
    Scanner in=new Scanner(System.in);
    init();
    for(; ; ){
      int n=in.nextInt();
      if(n==0)return ;
      System.out.printf("%.10f\n",solve(n));
    }
  }
  void init(){
    dp[1][1]=1.0 ;
    prob[1][1]=1.0 ;
    for(int i=2 ; i<MAX_N-1 ; i++){
      for(int j=0 ; j<MAX_DEPTH ; j++){
        if(j==0){
          for(int k=0 ; k<MAX_DEPTH ; k++){
            prob[i][j]+=prob[i-1][k]*(1.0-1.0/(1<<k));
          }
          for(int k=0 ; k<MAX_DEPTH ; k++){
            dp[i][j]+=prob[i-1][k]*(1.0-1.0/(1<<k))*dp[i-1][k]/prob[i][j];
          }
        }
        else {
          prob[i][j]+=prob[i-1][j-1]*(1.0/(1<<(j-1)));
          dp[i][j]+=(dp[i-1][j-1]+1.0);
        }
      }
    }
  }
  double solve(int n){
    double ret=0.0 ;
    for(int i=0 ; i<MAX_DEPTH ; i++){
      ret+=prob[n][i]*dp[n][i];
    }
    return ret ;
  }
  public static void main(String args[]){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute MAX_N : int := 100009;
   attribute MAX_DEPTH : int := 20;
   attribute dp : Sequence(Sequence(double)) := Integer.subrange(1,MAX_N)->collect(Integer.subrange(1,MAX_DEPTH)->collect(0.0));
   attribute prob : Sequence(Sequence(double)) := Integer.subrange(1,MAX_N)->collect(Integer.subrange(1,MAX_DEPTH)->collect(0.0));
   operation run() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute init() ; 
       while true do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
     OclFile["System.out"].printf("%.10f\n", solve(n)) )  ) );
   operation init() : void
  pre: true
  post: true
  activity: (     dp[1+1][1+1] := 1.0 ; 
     prob[1+1][1+1] := 1.0 ; 
         var i : int ; i := 2 ; while i < MAX_N - 1 do ( (         var j : int ; j := 0 ; while j < MAX_DEPTH do ( (     if (j = 0) then (         var k : int ; k := 0 ; while k < MAX_DEPTH do ( (     prob[i+1][j+1] := prob[i+1][j+1]+(prob[i - 1+1][k+1] * (1.0 - 1.0 / ((1*(2->pow(k)))->oclAsType(long)))) )  ;     k := k + 1 ) ; 
         var k : int ; k := 0 ; while k < MAX_DEPTH do ( (     dp[i+1][j+1] := dp[i+1][j+1]+(prob[i - 1+1][k+1] * (1.0 - 1.0 / ((1*(2->pow(k)))->oclAsType(long))) * dp[i - 1+1][k+1] / prob[i+1][j+1]) )  ;     k := k + 1 ) ) else (     prob[i+1][j+1] := prob[i+1][j+1]+(prob[i - 1+1][j - 1+1] * (1.0 / ((1*(2->pow((j - 1))))->oclAsType(long)))) ; 
     dp[i+1][j+1] := dp[i+1][j+1]+((dp[i - 1+1][j - 1+1] + 1.0)) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
   operation solve( n : int) : double
  pre: true
  post: true
  activity: (     var ret : double ; ret := 0.0 ;
         var i : int ; i := 0 ; while i < MAX_DEPTH do ( (     ret := ret+(prob[n+1][i+1] * dp[n+1][i+1]) )  ;     i := i + 1 ) ; 
     return ret );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int a ;
    while(true){
      a=s.nextInt();
      if(a==0)System.exit(0);
      int ret=1 ;
      int B=5 ;
      int U=1 ;
      int R=3 ;
      int L=4 ;
      int F=2 ;
      int D=6 ;
      for(int i=0 ; i<a ; i++){
        String str=s.next();
        if(str.equals("North")){
          int newB=U ;
          int newU=F ;
          int newD=B ;
          int newF=D ;
          B=newB ;
          U=newU ;
          F=newF ;
          D=newD ;
        }
        if(str.equals("East")){
          int newU=L ;
          int newL=D ;
          int newR=U ;
          int newD=R ;
          U=newU ;
          L=newL ;
          R=newR ;
          D=newD ;
        }
        if(str.equals("South")){
          int newB=D ;
          int newU=B ;
          int newD=F ;
          int newF=U ;
          B=newB ;
          U=newU ;
          F=newF ;
          D=newD ;
        }
        if(str.equals("West")){
          int newU=R ;
          int newL=U ;
          int newR=D ;
          int newD=L ;
          U=newU ;
          L=newL ;
          R=newR ;
          D=newD ;
        }
        if(str.equals("Right")){
          int newF=R ;
          int newB=L ;
          int newR=B ;
          int newL=F ;
          F=newF ;
          B=newB ;
          R=newR ;
          L=newL ;
        }
        if(str.equals("Left")){
          int newF=L ;
          int newB=R ;
          int newR=F ;
          int newL=B ;
          F=newF ;
          B=newB ;
          R=newR ;
          L=newL ;
        }
        ret+=U ;
      }
      System.out.println(ret);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ;
     while (true) do (     a := s.getCurrent()->toInteger() ; 
     if (a = 0) then OclProcess.exit(0) ; else skip ; 
    var ret : int ; ret := 1 ;
    var B : int ; B := 5 ;
    var U : int ; U := 1 ;
    var R : int ; R := 3 ;
    var L : int ; L := 4 ;
    var F : int ; F := 2 ;
    var D : int ; D := 6 ;
        var i : int ; i := 0 ; while i < a do ( (     var str : String ; str := s.getCurrent() ;
     if (str = "North") then (     var newB : int ; newB := U ;
     var newU : int ; newU := F ;
    var newD : int ; newD := B ;
    var newF : int ; newF := D ;
    B := newB ; 
    U := newU ; 
    F := newF ; 
    D := newD ; 
 ) else skip ; 
    if (str = "East") then (     var newU : int ; newU := L ;
     var newL : int ; newL := D ;
    var newR : int ; newR := U ;
    var newD : int ; newD := R ;
    U := newU ; 
    L := newL ; 
    R := newR ; 
    D := newD ; 
 ) else skip ; 
    if (str = "South") then (     var newB : int ; newB := D ;
     var newU : int ; newU := B ;
    var newD : int ; newD := F ;
    var newF : int ; newF := U ;
    B := newB ; 
    U := newU ; 
    F := newF ; 
    D := newD ; 
 ) else skip ; 
    if (str = "West") then (     var newU : int ; newU := R ;
     var newL : int ; newL := U ;
    var newR : int ; newR := D ;
    var newD : int ; newD := L ;
    U := newU ; 
    L := newL ; 
    R := newR ; 
    D := newD ; 
 ) else skip ; 
    if (str = "Right") then (     var newF : int ; newF := R ;
     var newB : int ; newB := L ;
    var newR : int ; newR := B ;
    var newL : int ; newL := F ;
    F := newF ; 
    B := newB ; 
    R := newR ; 
    L := newL ; 
 ) else skip ; 
    if (str = "Left") then (     var newF : int ; newF := L ;
     var newB : int ; newB := R ;
    var newR : int ; newR := F ;
    var newL : int ; newL := B ;
    F := newF ; 
    B := newB ; 
    R := newR ; 
    L := newL ; 
 ) else skip ; 
    ret := ret+(U) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ret) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=null ;
    try {
      scan=new Scanner(System.in);
      int n ;
      while((n=scan.nextInt())!=0){
        Dice dice=new Dice();
        int sum=1 ;
        for(int i=0 ; i<n ; i++){
          sum+=dice.Change(scan.next().charAt(0));
        }
        System.out.println(sum);
      }
    }
    finally {
      if(scan!=null)scan.close();
    }
  }
}
class Dice {
  int[] dice ;
  final int seven=7 ;
  Dice(){
    dice=new int[3];
    for(int i=0 ; i<dice.length ; i++){
      dice[i]=i+1 ;
    }
  }
  private void change(int i,int j){
    int tmp=dice[i];
    dice[i]=dice[j];
    dice[j]=seven-tmp ;
  }
  private int North(){
    change(0,1);
    return dice[0];
  }
  private int East(){
    change(2,0);
    return dice[0];
  }
  private int West(){
    change(0,2);
    return dice[0];
  }
  private int South(){
    change(1,0);
    return dice[0];
  }
  private int Right(){
    change(1,2);
    return dice[0];
  }
  private int Left(){
    change(2,1);
    return dice[0];
  }
  public int Change(char data){
    switch(data){
      case 'N' : return North();
      case 'E' : return East();
      case 'W' : return West();
      case 'S' : return South();
      case 'R' : return Right();
      case 'L' : return Left();
    }
    return 0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := null ;
     try (     scan := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ;
         n := scan.getCurrent()->toInteger() ;
    while ((n) /= 0) do (    skip ; (     var dice : Dice ; dice := Dice.newDice() ;
     var sum : int ; sum := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(dice.Change(scan.getCurrent()->at(0+1))) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sum) ) ;     n := scan.getCurrent()->toInteger() ;
 ) )   finally (     if (scan /= null) then     skip ; else skip )
 );
}
class Dice {
   attribute dice : Sequence(int);
   attribute seven : int := 7;
   static operation newDice() : Dice
  pre: true
  post: true
  activity:
  ( var self : Dice ;
    self := createDice();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     dice := Integer.subrange(1,3)->collect(0) ; 
         var i : int ; i := 0 ; while i < dice->size() do ( (     dice[i+1] := i + 1 )  ;     i := i + 1 ) );
   operation change( i : int, j : int) : void
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := dice[i+1] ;
     dice[i+1] := dice[j+1] ; 
     dice[j+1] := seven - tmp );
   operation North() : int
  pre: true
  post: true
  activity: (     execute change(0, 1) ; 
     return dice[0+1] );
   operation East() : int
  pre: true
  post: true
  activity: (     execute change(2, 0) ; 
     return dice[0+1] );
   operation West() : int
  pre: true
  post: true
  activity: (     execute change(0, 2) ; 
     return dice[0+1] );
   operation South() : int
  pre: true
  post: true
  activity: (     execute change(1, 0) ; 
     return dice[0+1] );
   operation Right() : int
  pre: true
  post: true
  activity: (     execute change(1, 2) ; 
     return dice[0+1] );
   operation Left() : int
  pre: true
  post: true
  activity: (     execute change(2, 1) ; 
     return dice[0+1] );
   operation Change( data : String) : int
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (data) ; 
       if _switchval = 'N' then
     return North() 
   else skip ;
       if _switchval = 'E' then
     return East() 
   else skip ;
       if _switchval = 'W' then
     return West() 
   else skip ;
       if _switchval = 'S' then
     return South() 
   else skip ;
       if _switchval = 'R' then
     return Right() 
   else skip ;
       if _switchval = 'L' then
     return Left() 
   else skip ;
 )
     return 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String[] s="North:South:East:West:Right:Left".split(":");
    int[][] l={
      {
        0,1,1,2,2,3 },{
          3,2,2,1,1,0 },{
            0,5,2,4,4,5 },{
              0,4,2,5,5,4 },{
                1,4,3,5,4,5 },{
                  1,5,3,4,4,5 }
                };
                Map<String,int[]>m=new HashMap<>();
                for(int i=0 ; i<6 ; i++){
                  m.put(s[i],l[i]);
                }
                for(; ; ){
                  int n=sc.nextInt();
                  if(n==0){
                    break ;
                  }
                  int sum=1 ;
                  int[] d={
                    1,2,6,5,3,4 };
                    while(n-->0){
                      int[] t=m.get(sc.next());
                      for(int i=0 ; i<t.length ; i+=2){
                        int p=d[t[i] ];
                        d[t[i] ]=d[t[i+1] ];
                        d[t[i+1] ]=p ;
                      }
                      sum+=d[0];
                    }
                    System.out.println(sum);
                  }
                }
              }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := "North:South:East:West:Right:Left"->split(":") ;
    var l : Sequence(Sequence(int)) ; l := Sequence{Sequence{0,1,1,2,2,3},Sequence{3,2,2,1,1,0},Sequence{0,5,2,4,4,5},Sequence{0,4,2,5,5,4},Sequence{1,4,3,5,4,5},Sequence{1,5,3,4,4,5}} ;
    var m : Map(String,Sequence(int)) ; m := Map{} ;
        var i : int ; i := 0 ; while i < 6 do ( (     m := m->union(Map{s[i+1] |-> l[i+1]}) )  ;     i := i + 1 ) ; 
      while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var sum : int ; sum := 1 ;
    var d : Sequence(int) ; d := Sequence{1,2,6,5,3,4} ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var t : Sequence(int) ; t := m->at(sc.getCurrent()) ;
         var i : int ; i := 0 ; while i < t->size() do ( (     var p : int ; p := d[t[i+1]+1] ;
     d[t[i+1]+1] := d[t[i + 1+1]+1] ; 
     d[t[i + 1+1]+1] := p )  ;     i := i+(2) ) ; 
     sum := sum+(d[0+1]) ) ;  ) ;  
    OclFile["System.out"].println(sum) ; 
 )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String rags[]){
    Scanner sc=new Scanner(System.in);
    String f=sc.nextLine();
    String m=sc.nextLine();
    String s=sc.nextLine();
    if(f.equals("rock")&& m.equals("scissors")&& s.equals("scissors"))System.out.println("F");
    else if(f.equals("paper")&& m.equals("rock")&& s.equals("rock"))System.out.println("F");
    else if(f.equals("scissors")&& m.equals("paper")&& s.equals("paper"))System.out.println("F");
    else if(f.equals("rock")&& m.equals("paper")&& s.equals("rock"))System.out.println("M");
    else if(f.equals("scissors")&& m.equals("rock")&& s.equals("scissors"))System.out.println("M");
    else if(f.equals("paper")&& m.equals("scissors")&& s.equals("paper"))System.out.println("M");
    else if(f.equals("rock")&& m.equals("rock")&& s.equals("paper"))System.out.println("S");
    else if(f.equals("scissors")&& m.equals("scissors")&& s.equals("rock"))System.out.println("S");
    else if(f.equals("paper")&& m.equals("paper")&& s.equals("scissors"))System.out.println("S");
    else System.out.println("?");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( rags : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var f : String ; f := sc.nextLine() ;
    var m : String ; m := sc.nextLine() ;
    var s : String ; s := sc.nextLine() ;
    if (f = "rock" & m = "scissors" & s = "scissors") then     OclFile["System.out"].println("F") else     if (f = "paper" & m = "rock" & s = "rock") then     OclFile["System.out"].println("F") else     if (f = "scissors" & m = "paper" & s = "paper") then     OclFile["System.out"].println("F") else     if (f = "rock" & m = "paper" & s = "rock") then     OclFile["System.out"].println("M") else     if (f = "scissors" & m = "rock" & s = "scissors") then     OclFile["System.out"].println("M") else     if (f = "paper" & m = "scissors" & s = "paper") then     OclFile["System.out"].println("M") else     if (f = "rock" & m = "rock" & s = "paper") then     OclFile["System.out"].println("S") else     if (f = "scissors" & m = "scissors" & s = "rock") then     OclFile["System.out"].println("S") else     if (f = "paper" & m = "paper" & s = "scissors") then     OclFile["System.out"].println("S") else     OclFile["System.out"].println("?") ; ;  ;  ;  ;  ;  ;  ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int cu=1 ;
  static int cd=6 ;
  static int n=5 ;
  static int s=2 ;
  static int e=4 ;
  static int w=3 ;
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(true){
      int k=stdIn.nextInt();
      if(k==0){
        break ;
      }
      cu=1 ;
      cd=6 ;
      n=5 ;
      s=2 ;
      e=4 ;
      w=3 ;
      int ans=1 ;
      for(int i=0 ; i<k ; i++){
        String tmp=stdIn.next();
        if(tmp.equals("North")){
          north();
        }
        if(tmp.equals("South")){
          south();
        }
        if(tmp.equals("East")){
          east();
        }
        if(tmp.equals("West")){
          west();
        }
        if(tmp.equals("Right")){
          right();
        }
        if(tmp.equals("Left")){
          left();
        }
        ans+=cu ;
      }
      System.out.println(ans);
    }
  }
  static void north(){
    int tmp=cu ;
    cu=s ;
    s=cd ;
    cd=n ;
    n=tmp ;
  }
  static void south(){
    int tmp=cu ;
    cu=n ;
    n=cd ;
    cd=s ;
    s=tmp ;
  }
  static void east(){
    int tmp=cu ;
    cu=e ;
    e=cd ;
    cd=w ;
    w=tmp ;
  }
  static void west(){
    int tmp=cu ;
    cu=w ;
    w=cd ;
    cd=e ;
    e=tmp ;
  }
  static void right(){
    int tmp=n ;
    n=e ;
    e=s ;
    s=w ;
    w=tmp ;
  }
  static void left(){
    int tmp=n ;
    n=w ;
    w=s ;
    s=e ;
    e=tmp ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute cu : int := 1;
  static   attribute cd : int := 6;
  static   attribute n : int := 5;
  static   attribute s : int := 2;
  static   attribute e : int := 4;
  static   attribute w : int := 3;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var k : int ; k := stdIn.getCurrent()->toInteger() ;
     if (k = 0) then (     break ) else skip ; 
    cu := 1 ; 
    cd := 6 ; 
    n := 5 ; 
    s := 2 ; 
    e := 4 ; 
    w := 3 ; 
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < k do ( (     var tmp : String ; tmp := stdIn.getCurrent() ;
     if (tmp = "North") then (     execute north() ) else skip ; 
    if (tmp = "South") then (     execute south() ) else skip ; 
    if (tmp = "East") then (     execute east() ) else skip ; 
    if (tmp = "West") then (     execute west() ) else skip ; 
    if (tmp = "Right") then (     execute right() ) else skip ; 
    if (tmp = "Left") then (     execute left() ) else skip ; 
    ans := ans+(cu) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation north() : void
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := cu ;
     cu := s ; 
    s := cd ; 
    cd := n ; 
    n := tmp ; 
 );
  static   operation south() : void
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := cu ;
     cu := n ; 
    n := cd ; 
    cd := s ; 
    s := tmp ; 
 );
  static   operation east() : void
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := cu ;
     cu := e ; 
    e := cd ; 
    cd := w ; 
    w := tmp ; 
 );
  static   operation west() : void
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := cu ;
     cu := w ; 
    w := cd ; 
    cd := e ; 
    e := tmp ; 
 );
  static   operation right() : void
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := n ;
     n := e ; 
    e := s ; 
    s := w ; 
    w := tmp ; 
 );
  static   operation left() : void
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := n ;
     n := w ; 
    w := s ; 
    s := e ; 
    e := tmp ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GfG {
  static boolean isPerfectSquare(int n){
    for(int i=1 ; i*i<=n ; i++){
      if((n % i==0)&&(n/i==i)){
        return true ;
      }
    }
    return false ;
  }
  public static void main(String[] args){
    int n=36 ;
    if(isPerfectSquare(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation isPerfectSquare( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i * i <= n do ( (     if ((n mod i = 0) & (n / i = i)) then (     return true ) else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 36 ;
     if (isPerfectSquare(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class prog1 {
  static int solve(int arr[],int n){
    int ans=Integer.MIN_VALUE ;
    if(n==1){
      return 0 ;
    }
    int max=Integer.MIN_VALUE,min=Integer.MAX_VALUE ;
    for(int i=1 ; i<n ; i++){
      if(arr[i]>max){
        max=arr[i];
      }
    }
    ans=Math.max(max-arr[0],ans);
    for(int i=0 ; i<n-1 ; i++){
      if(arr[i]<min){
        min=arr[i];
      }
    }
    ans=Math.max(ans,arr[n-1]-min);
    ans=Math.max(ans,arr[n-1]-arr[0]);
    for(int i=n-2 ; i>=0 ; i--){
      ans=Math.max(ans,arr[i]-arr[i+1]);
    }
    return ans ;
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=1 ; i<=t ; i++){
      int n=sc.nextInt();
      int arr[]=new int[n];
      for(int j=0 ; j<n ; j++){
        arr[j]=sc.nextInt();
      }
      int ans=solve(arr,n);
      System.out.println(ans);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class prog1 {
  static   operation solve( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := -2147483648 ;
     if (n = 1) then (     return 0 ) else skip ; 
    var max : int ; max := -2147483648 ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] > max) then (     max := arr[i+1] ) else skip )  ;     i := i + 1 ) ; 
    ans := Set{max - arr[0+1], ans}->max() ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] < min) then (     min := arr[i+1] ) else skip )  ;     i := i + 1 ) ; 
    ans := Set{ans, arr[n - 1+1] - min}->max() ; 
    ans := Set{ans, arr[n - 1+1] - arr[0+1]}->max() ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     ans := Set{ans, arr[i+1] - arr[i + 1+1]}->max() )  ;     i := i - 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     arr[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    var ans : int ; ans := solve(arr, n) ;
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.util.*;
public class A {
  public static void main(String[] args){
    FastReader fs=new FastReader();
    PrintWriter out=new PrintWriter(System.out);
    int N=fs.nextInt();
    for(int p=0 ; p<N ; p++){
      int n=fs.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=fs.nextInt();
      int ans=0 ;
      for(int i=0 ; i<n ; i++)ans=Math.max(arr[(i-1+n)% n]-arr[i],ans);
      for(int i=1 ; i<n ; i++)ans=Math.max(ans,arr[i]-arr[0]);
      for(int i=0 ; i<n-1 ; i++)ans=Math.max(ans,arr[n-1]-arr[i]);
      out.println(ans);
    }
    out.close();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastReader ; fs := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := fs.nextInt() ;
        var p : int ; p := 0 ; while p < N do ( (     var n : int ; n := fs.nextInt() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := fs.nextInt() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do (     ans := Set{arr[(i - 1 + n) mod n+1] - arr[i+1], ans}->max() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do (     ans := Set{ans, arr[i+1] - arr[0+1]}->max() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do (     ans := Set{ans, arr[n - 1+1] - arr[i+1]}->max() ;  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     p := p + 1 ) ; 
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Arrays ;
public class codeforce {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] array=new int[n];
      for(int i=0 ; i<n ; i++){
        array[i]=sc.nextInt();
      }
      int max=0 ;
      for(int i=0 ; i<n ; i++){
        max=Math.max(array[i]-array[0],max);
        max=Math.max(max,array[n-1]-array[i]);
        max=Math.max(max,array[i]-array[(i+1)% n]);
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforce {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     max := Set{array[i+1] - array[0+1], max}->max() ; 
     max := Set{max, array[n - 1+1] - array[i+1]}->max() ; 
     max := Set{max, array[i+1] - array[(i + 1) mod n+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.text.*;
class GFG {
  static double p=1,f=1 ;
  static double e(int x,int n){
    double r ;
    if(n==0)return 1 ;
    r=e(x,n-1);
    p=p*x ;
    f=f*n ;
    return(r+p/f);
  }
  public static void main(String[] args){
    int x=4,n=15 ;
    DecimalFormat df=new DecimalFormat("0.######");
    System.out.println(df.format(e(x,n)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute p : double := 1;
  static   operation e( x : int, n : int) : double
  pre: true
  post: true
  activity: (     var r : double ;
     if (n = 0) then     return 1 else skip ; 
    r := e(x, n - 1) ; 
    p := p * x ; 
    f := f * n ; 
    return (r + p / f) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 4 ;
    var n : int ; n := 15 ;
     var df : DecimalFormat ; df := DecimalFormat.newDecimalFormat("0.######") ;
     OclFile["System.out"].println(df.format(e(x, n))) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.run();
  }
  class P implements Comparable<P>{
    long x ;
    long y ;
    P(long x,long y){
      this.x=x ;
      this.y=y ;
    }
    @ Override public int compareTo(P arg0){
      return Long.compare(this.x,arg0.x);
    }
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    long x[]=new long[N];
    long y[]=new long[N];
    for(int i=0 ; i<N ; i++){
      x[i]=sc.nextLong();
      y[i]=sc.nextLong();
    }
    long ans=Long.MAX_VALUE ;
    for(int i=0 ; i<N ; i++){
      long x1=x[i];
      for(int j=0 ; j<N ; j++){
        long x2=x[j];
        if(x1>=x2)continue ;
        for(int k=0 ; k<N ; k++){
          long y1=y[k];
          for(int l=0 ; l<N ; l++){
            long y2=y[l];
            if(y1>=y2)continue ;
            int cnt=0 ;
            for(int m=0 ; m<N ; m++){
              if(x1<=x[m] && x[m]<=x2 && y1<=y[m] && y[m]<=y2){
                cnt++;
              }
            }
            if(cnt==K){
              ans=Math.min(ans,(x2-x1)*(y2-y1));
            }
          }
        }
      }
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.run() );
 class P implements Comparable<P> {
   attribute x : long;
   attribute y : long;
   static operation newP( x : long, y : long) : P
  pre: true
  post: true
  activity:
  ( var self : P ;
    self := createP();
    self.initialise(x, y);
    return self );
  operation initialise( x : long, y : long) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
      operation compareTo( arg0 : P) : int
  pre: true
  post: true
  activity: (     return compare(self.x, arg0.x) );
}
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var x : Sequence(long) ; x := Integer.subrange(1,N)->collect(0) ;
    var y : Sequence(long) ; y := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     x[i+1] := sc.getCurrent()->toLong() ; 
     y[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := "9223372036854775807"->toLong() ;
        var i : int ; i := 0 ; while i < N do ( (     var x1 : long ; x1 := x[i+1] ;
         var j : int ; j := 0 ; while j < N do ( (     var x2 : long ; x2 := x[j+1] ;
     if (x1 >= x2) then     continue else skip ; 
         var k : int ; k := 0 ; while k < N do ( (     var y1 : long ; y1 := y[k+1] ;
         var l : int ; l := 0 ; while l < N do ( (     var y2 : long ; y2 := y[l+1] ;
     if (y1 >= y2) then     continue else skip ; 
    var cnt : int ; cnt := 0 ;
        var m : int ; m := 0 ; while m < N do ( (     if (x1 <= x[m+1] & x[m+1] <= x2 & y1 <= y[m+1] & y[m+1] <= y2) then (     cnt := cnt + 1 ) else skip )  ;     m := m + 1 ) ; 
    if (cnt = K) then (     ans := Set{ans, (x2 - x1) * (y2 - y1)}->min() ) else skip ; 
 )  ;     l := l + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    HashMap<Integer,Integer>hash=new HashMap<>();
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int j=sc.nextInt();
      if(hash.containsKey(j))hash.put(j,2);
      else hash.put(j,1);
    }
    boolean b=true ;
    for(int a : hash.values()){
      if(a>1){
        b=false ;
        break ;
      }
    }
    if(b)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var hash : Map(int,int) ; hash := Map{} ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var j : int ; j := sc.getCurrent()->toInteger() ;
     if (hash->keys()->includes(j)) then     hash := hash->union(Map{j |-> 2}) ; else     hash := hash->union(Map{j |-> 1}) ; )  ;     i := i + 1 ) ; 
    var b : boolean ; b := true ;
    for (a : hash->values()) do ( (     if (a > 1) then (     b := false ; 
     break ) else skip )  ) ; 
    if (b) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Comparator ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String o="YES" ;
    int[] a=new int[n];
    BinarySearchTree t=new BinarySearchTree();
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      if(t.contains(a[i])){
        o="NO" ;
        System.out.println(o);
        return ;
      }
      else {
        t.add(a[i]);
      }
    }
    System.out.println(o);
  }
}
class Node {
  int data ;
  Node left ;
  Node right ;
}
class BinarySearchTree {
  private Node root ;
  public void add(int data){
    if(root==null){
      root=new Node();
      root.data=data ;
      return ;
    }
    Node current=root ;
    while(true){
      if(data<current.data){
        if(current.left==null){
          current.left=new Node();
          current.left.data=data ;
          return ;
        }
        current=current.left ;
      }
      else if(current.data<=data){
        if(current.right==null){
          current.right=new Node();
          current.right.data=data ;
          return ;
        }
        current=current.right ;
      }
    }
  }
  public boolean contains(int data){
    Node current=root ;
    while(current!=null){
      if(current.data==data){
        return true ;
      }
      else if(data<current.data){
        current=current.left ;
      }
      else if(current.data<data){
        current=current.right ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var o : String ; o := "YES" ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var t : BinarySearchTree ; t := BinarySearchTree.newBinarySearchTree() ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (t->includes(a[i+1])) then (     o := "NO" ; 
     OclFile["System.out"].println(o) ; 
     return ) else (     t->excludes(a[i+1]) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(o) ; 
 );
}
class Node {
   attribute data : int;
   attribute left : Node;
   attribute right : Node;
}
class BinarySearchTree {
   attribute root : Node;
   operation add( data : int) : void
  pre: true
  post: true
  activity: (     if (root = null) then (     root := Node.newNode() ; 
     root.data := data ; 
     return ) else skip ; 
     var current : Node ; current := root ;
     while (true) do (     if (data < current.data) then (     if (current.left = null) then (     current.left := Node.newNode() ; 
     current.left.data := data ; 
     return ) else skip ; 
     current := current.left ) else     if (current.data <= data) then (     if (current.right = null) then (     current.right := Node.newNode() ; 
     current.right.data := data ; 
     return ) else skip ; 
     current := current.right ) else skip ; ) );
   operation contains( data : int) : boolean
  pre: true
  post: true
  activity: (     var current : Node ; current := root ;
     while (current /= null) do (     if (current.data = data) then (     return true ) else     if (data < current.data) then (     current := current.left ) else     if (current.data < data) then (     current := current.right ) else skip ; ;  ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
import java.util.Set ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int numAll=Integer.parseInt(br.readLine());
    String[] numsStr=br.readLine().split(" ");
    Set<String>numSet=new HashSet<>();
    for(int i=0 ; i<numAll ; i++){
      numSet.add(numsStr[i]);
    }
    if(numAll==numSet.size()){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var numAll : int ; numAll := (br.readLine())->toInteger() ;
    var numsStr : Sequence(String) ; numsStr := br.readLine()->split(" ") ;
    var numSet : Set(String) ; numSet := Set{} ;
        var i : int ; i := 0 ; while i < numAll do ( (     numSet := numSet->including(numsStr[i+1]) )  ;     i := i + 1 ) ; 
    if (numAll = numSet->size()) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collection ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Map.Entry ;
import java.util.Scanner ;
public class Main {
  private static Scanner sc=new Scanner(System.in);
  static void p(String ans){
    System.out.println(ans);
  };
  static void p(int ans){
    System.out.println(ans);
  };
  static void p(long ans){
    System.out.println(ans);
  };
  public static void main(String[] args){
    int n=sc.nextInt();
    Map<Integer,Integer>map=new HashMap<Integer,Integer>(n);
    boolean a=true ;
    for(int i=0 ; i<n && a ; i++){
      int A=sc.nextInt();
      if(! map.containsKey(A)){
        map.put(A,1);
      }
      else {
        a=false ;
      }
    }
    if(a){
      p("YES");
    }
    else {
      p("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation p( ans : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : long) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var map : Map(int,int) ; map := Map{} ;
    var a : boolean ; a := true ;
        var i : int ; i := 0 ; while i < n & a do ( (     var A : int ; A := sc.getCurrent()->toInteger() ;
     if (not(map->keys()->includes(A))) then (     map := map->union(Map{A |-> 1}) ) else (     a := false ) )  ;     i := i + 1 ) ; 
    if (a) then (     execute p("YES") ) else (     execute p("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(final String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int n=scanner.nextInt();
    final Map<Integer,Boolean>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      final int a=scanner.nextInt();
      if(map.get(a)!=null){
        System.out.println("NO");
        return ;
      }
      else {
        map.put(a,true);
      }
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var map : Map(int,Boolean) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     if (map->at(a) /= null) then (     OclFile["System.out"].println("NO") ; 
     return ) else (     map := map->union(Map{a |-> true}) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float successiveChange(int arr[],int N){
    float var1,var2,result=0 ;
    var1=arr[0];
    var2=arr[1];
    result=var1+var2+((var1*var2)/100);
    for(int i=2 ; i<N ; i++)result=result+arr[i]+((result*arr[i])/100);
    return result ;
  }
  public static void main(String[] args){
    int[] arr={
      10,20,30,10 };
      int N=arr.length ;
      float result=successiveChange(arr,N);
      System.out.println("Percentage change is="+result+" %");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation successiveChange( arr : Sequence(int), N : int) : double
  pre: true
  post: true
  activity: (     var var1 : double ;
    var var2 : double ;
    var result : double ; result := 0 ;
     var1 := arr[0+1] ; 
    var2 := arr[1+1] ; 
    result := var1 + var2 + ((var1 * var2) / 100) ; 
        var i : int ; i := 2 ; while i < N do (     result := result + arr[i+1] + ((result * arr[i+1]) / 100) ;  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,20,30,10} ;
     var N : int ; N := arr->size() ;
     var result : double ; result := successiveChange(arr, N) ;
     OclFile["System.out"].println("Percentage change is=" + result + " %") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean checkPalindrome(String s){
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)!=s.charAt(s.length()-i-1))return false ;
    }
    return true ;
  }
  static boolean CheckOdd(String s){
    int n=s.length();
    for(int i=0 ; i<n ; i++){
      String x="" ;
      for(int j=i ; j<n ; j++){
        x+=s.charAt(j);
        if(x.length()% 2==0 && checkPalindrome(x)==true)return false ;
      }
    }
    return true ;
  }
  public static void main(String args[]){
    String s="geeksforgeeks" ;
    if(CheckOdd(s))System.out.print("YES");
    else System.out.print("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkPalindrome( s : String) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) /= s->at(s->size() - i - 1+1)) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation CheckOdd( s : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
         var i : int ; i := 0 ; while i < n do ( (     var x : String ; x := "" ;
         var j : int ; j := i ; while j < n do ( (     x := x+(s->at(j+1)) ; 
     if (x->size() mod 2 = 0 & checkPalindrome(x) = true) then     return false else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     if (CheckOdd(s)) then     OclFile["System.out"].print("YES") ; else     OclFile["System.out"].print("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countPairs(int a[],int n){
    int mn=Integer.MAX_VALUE ;
    int mx=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      mn=Math.min(mn,a[i]);
      mx=Math.max(mx,a[i]);
    }
    int c1=0 ;
    int c2=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]==mn)c1++;
      if(a[i]==mx)c2++;
    }
    if(mn==mx)return n*(n-1)/2 ;
    else return c1*c2 ;
  }
  public static void main(String[] args){
    int a[]={
      3,2,1,1,3 };
      int n=a.length ;
      System.out.print(countPairs(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPairs( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var mn : int ; mn := 2147483647 ;
     var mx : int ; mx := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     mn := Set{mn, a[i+1]}->min() ; 
     mx := Set{mx, a[i+1]}->max() )  ;     i := i + 1 ) ; 
    var c1 : int ; c1 := 0 ;
    var c2 : int ; c2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = mn) then     c1 := c1 + 1 ; else skip ; 
     if (a[i+1] = mx) then     c2 := c2 + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (mn = mx) then     return n * (n - 1) / 2 else     return c1 * c2 ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{3,2,1,1,3} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(countPairs(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int distinctCount(int arr[],int n){
    int count=n ;
    int i=0,j=n-1,sum=0 ;
    while(i<j){
      while(i!=j && arr[i]==arr[i+1]){
        count--;
        i++;
      }
      while(i!=j && arr[j]==arr[j-1]){
        count--;
        j--;
      }
      if(i==j)break ;
      sum=arr[i]+arr[j];
      if(sum==0){
        count--;
        i++;
        j--;
      }
      else if(sum<0)i++;
      else j--;
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
-2,-1,0,1,1 };
      int n=arr.length ;
      System.out.println("Count of absolute distinct values : "+distinctCount(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation distinctCount( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := n ;
     var i : int ; i := 0 ;
    var j : int ; j := n - 1 ;
    var sum : int ; sum := 0 ;
     while (i < j) do (     while (i /= j & arr[i+1] = arr[i + 1+1]) do (     count := count - 1 ; 
     i := i + 1 ) ; 
     while (i /= j & arr[j+1] = arr[j - 1+1]) do (     count := count - 1 ; 
     j := j - 1 ) ; 
    if (i = j) then     break else skip ; 
    sum := arr[i+1] + arr[j+1] ; 
    if (sum = 0) then (     count := count - 1 ; 
     i := i + 1 ; 
     j := j - 1 ) else     if (sum < 0) then     i := i + 1 else     j := j - 1 ; ;  ;  
 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-2,-1,0,1,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Count of absolute distinct values : " + distinctCount(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int N ;
  static double[] exp=new double[100001];
  public static void main(String[] args){
    precalc();
    while(true){
      N=sc.nextInt();
      if(N==0)break ;
      System.out.println(solve());
    }
  }
  static double solve(){
    return exp[N];
  }
  static void precalc(){
    int pos=0 ;
    double[][] prob=new double[2][101];
    double[][] v=new double[2][101];
    prob[pos][0]=1 ;
    double[] success=new double[101];
    success[0]=1 ;
    for(int i=1 ; i<success.length ; ++i){
      success[i]=success[i-1]/2 ;
    }
    for(int i=0 ; i<=100000 ; ++i){
      double sum=0 ;
      Arrays.fill(prob[1-pos],0);
      Arrays.fill(v[1-pos],0);
      for(int j=0 ; j<100 ; ++j){
        sum+=v[pos][j];
        prob[1-pos][j+1]+=prob[pos][j]*success[j];
        prob[1-pos][0]+=prob[pos][j]*(1-success[j]);
        v[1-pos][j+1]+=(v[pos][j]+prob[pos][j])*success[j];
        v[1-pos][0]+=v[pos][j]*(1-success[j]);
      }
      exp[i]=sum ;
      pos=1-pos ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int;
  static   attribute exp : Sequence(double) := Integer.subrange(1,100001)->collect(0.0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute precalc() ; 
     while (true) do (     N := sc.getCurrent()->toInteger() ; 
     if (N = 0) then     break else skip ; 
     OclFile["System.out"].println(solve()) ) );
  static   operation solve() : double
  pre: true
  post: true
  activity: (     return exp[N+1] );
  static   operation precalc() : void
  pre: true
  post: true
  activity: (     var pos : int ; pos := 0 ;
     var prob : Sequence(Sequence(double)) ; prob := Integer.subrange(1,2)->collect(Integer.subrange(1,101)->collect(0.0)) ;
    var v : Sequence(Sequence(double)) ; v := Integer.subrange(1,2)->collect(Integer.subrange(1,101)->collect(0.0)) ;
    prob[pos+1][0+1] := 1 ; 
    var success : Sequence(double) ; success := Integer.subrange(1,101)->collect(0.0) ;
    success[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < success->size() do ( (     success[i+1] := success[i - 1+1] / 2 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= 100000 do ( (     var sum : double ; sum := 0 ;
     prob[1 - pos+1] := prob[1 - pos+1]->collect(0) ; 
    v[1 - pos+1] := v[1 - pos+1]->collect(0) ; 
        var j : int ; j := 0 ; while j < 100 do ( (     sum := sum+(v[pos+1][j+1]) ; 
     prob[1 - pos+1][j + 1+1] := prob[1 - pos+1][j + 1+1]+(prob[pos+1][j+1] * success[j+1]) ; 
    prob[1 - pos+1][0+1] := prob[1 - pos+1][0+1]+(prob[pos+1][j+1] * (1 - success[j+1])) ; 
    v[1 - pos+1][j + 1+1] := v[1 - pos+1][j + 1+1]+((v[pos+1][j+1] + prob[pos+1][j+1]) * success[j+1]) ; 
    v[1 - pos+1][0+1] := v[1 - pos+1][0+1]+(v[pos+1][j+1] * (1 - success[j+1])) ; 
 )  ;     j := j + 1 ) ; 
    exp[i+1] := sum ; 
    pos := 1 - pos ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  private static final long MAX=(long)(2e10+1);
  public static void main(String[] args)throws Exception {
    Scanner scanner=new Scanner(System.in);
    int V=scanner.nextInt();
    int E=scanner.nextInt();
    long[][] dist=new long[V][V];
    for(int i=0 ; i<V ; ++i){
      Arrays.fill(dist[i],MAX);
      dist[i][i]=0 ;
    }
    for(int i=0 ; i<E ; ++i){
      int u=scanner.nextInt();
      int v=scanner.nextInt();
      int weight=scanner.nextInt();
      dist[u][v]=weight ;
    }
    for(int k=0 ; k<V ; ++k){
      for(int i=0 ; i<V ; ++i){
        for(int j=0 ; j<V ; ++j){
          if(dist[i][k]!=MAX && dist[k][j]!=MAX && dist[i][k]+dist[k][j]<dist[i][j]){
            dist[i][j]=dist[i][k]+dist[k][j];
          }
        }
      }
    }
    for(int i=0 ; i<V ; ++i){
      if(dist[i][i]<0){
        System.out.println("NEGATIVE CYCLE");
        return ;
      }
    }
    for(int i=0 ; i<V ; ++i){
      for(int j=0 ; j<V ; ++j){
        System.out.print(dist[i][j]==MAX ? "INF" : dist[i][j]);
        if(j!=V-1){
          System.out.print(" ");
        }
      }
      System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : long := (2e10 + 1)->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var V : int ; V := scanner.getCurrent()->toInteger() ;
    var E : int ; E := scanner.getCurrent()->toInteger() ;
    var dist : Sequence(Sequence(long)) ; dist := Integer.subrange(1,V)->collect(Integer.subrange(1,V)->collect(0)) ;
        var i : int ; i := 0 ; while i < V do ( (     dist[i+1] := dist[i+1]->collect(MAX) ; 
     dist[i+1][i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < E do ( (     var u : int ; u := scanner.getCurrent()->toInteger() ;
     var v : int ; v := scanner.getCurrent()->toInteger() ;
     var weight : int ; weight := scanner.getCurrent()->toInteger() ;
     dist[u+1][v+1] := weight )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < V do ( (         var i : int ; i := 0 ; while i < V do ( (         var j : int ; j := 0 ; while j < V do ( (     if (dist[i+1][k+1] /= MAX & dist[k+1][j+1] /= MAX & dist[i+1][k+1] + dist[k+1][j+1] < dist[i+1][j+1]) then (     dist[i+1][j+1] := dist[i+1][k+1] + dist[k+1][j+1] ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
        var i : int ; i := 0 ; while i < V do ( (     if (dist[i+1][i+1] < 0) then (     OclFile["System.out"].println("NEGATIVE CYCLE") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < V do ( (         var j : int ; j := 0 ; while j < V do ( (     OclFile["System.out"].print(if dist[i+1][j+1] = MAX then "INF" else dist[i+1][j+1] endif) ; 
     if (j /= V - 1) then (     OclFile["System.out"].print(" ") ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int v=sc.nextInt();
      int e=sc.nextInt();
      long[][] cost=new long[v][v];
      long INF=Long.MAX_VALUE/10 ;
      for(int i=0 ; i<v ; i++){
        for(int j=0 ; j<v ; j++){
          cost[i][j]=(i==j)? 0 : INF ;
        }
      }
      for(int i=0 ; i<e ; i++){
        int s=sc.nextInt();
        int t=sc.nextInt();
        long d=sc.nextLong();
        cost[s][t]=d ;
      }
      boolean minor=false ;
      for(int k=0 ; k<v ; k++){
        for(int i=0 ; i<v ; i++){
          for(int j=0 ; j<v ; j++){
            if(cost[i][j]>cost[i][k]+cost[k][j] && cost[i][k]!=INF && cost[k][j]!=INF)cost[i][j]=cost[i][k]+cost[k][j];
          }
          if(cost[i][i]<0)minor=true ;
        }
      }
      if(minor)System.out.println("NEGATIVE CYCLE");
      else {
        for(int i=0 ; i<v ; i++){
          for(int j=0 ; j<v ; j++){
            if(j>0)System.out.print(" ");
            System.out.print((cost[i][j]>=INF)? "INF" : cost[i][j]);
          }
          System.out.println();
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var v : int ; v := sc.getCurrent()->toInteger() ;
     var e : int ; e := sc.getCurrent()->toInteger() ;
    var cost : Sequence(Sequence(long)) ; cost := Integer.subrange(1,v)->collect(Integer.subrange(1,v)->collect(0)) ;
    var INF : long ; INF := "9223372036854775807"->toLong() / 10 ;
        var i : int ; i := 0 ; while i < v do ( (         var j : int ; j := 0 ; while j < v do ( (     cost[i+1][j+1] := if (i = j) then 0 else INF endif )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < e do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     var d : long ; d := sc.getCurrent()->toLong() ;
     cost[s+1][t+1] := d )  ;     i := i + 1 ) ; 
    var minor : boolean ; minor := false ;
        var k : int ; k := 0 ; while k < v do ( (         var i : int ; i := 0 ; while i < v do ( (         var j : int ; j := 0 ; while j < v do ( (     if (cost[i+1][j+1] > cost[i+1][k+1] + cost[k+1][j+1] & cost[i+1][k+1] /= INF & cost[k+1][j+1] /= INF) then     cost[i+1][j+1] := cost[i+1][k+1] + cost[k+1][j+1] ; else skip )  ;     j := j + 1 ) ; 
     if (cost[i+1][i+1] < 0) then     minor := true ; else skip )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    if (minor) then     OclFile["System.out"].println("NEGATIVE CYCLE") else (         var i : int ; i := 0 ; while i < v do ( (         var j : int ; j := 0 ; while j < v do ( (     if (j > 0) then     OclFile["System.out"].print(" ") ; else skip ; 
     OclFile["System.out"].print(if (cost[i+1][j+1] >= INF) then "INF" else cost[i+1][j+1] endif) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ) ;  
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static final int INF=Integer.MAX_VALUE ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int en=sc.nextInt();
    int[][] d=new int[n][n];
    for(int i=0 ; i<n ; i++){
      Arrays.fill(d[i],INF);
      d[i][i]=0 ;
    }
    for(int i=0 ; i<en ; i++){
      int s=sc.nextInt();
      int t=sc.nextInt();
      int dist=sc.nextInt();
      d[s][t]=dist ;
    }
    for(int k=0 ; k<n ; k++){
      for(int i=0 ; i<n ; i++){
        if(d[i][k]==INF){
          continue ;
        }
        for(int j=0 ; j<n ; j++){
          if(d[k][j]==INF){
            continue ;
          }
          d[i][j]=Math.min(d[i][j],d[i][k]+d[k][j]);
        }
      }
    }
    if(hasNegativeLoopWF(d)){
      System.out.println("NEGATIVE CYCLE");
      return ;
    }
    for(int i=0 ; i<n ; i++){
      String[] res=new String[n];
      for(int j=0 ; j<n ; j++){
        res[j]=d[i][j]==INF ? "INF" : String.valueOf(d[i][j]);
      }
      System.out.println(String.join(" ",res));
    }
  }
  public static boolean hasNegativeLoopWF(int[][] a){
    for(int i=0 ; i<a.length ; i++){
      if(a[i][i]<0){
        return true ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := 2147483647;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var en : int ; en := sc.getCurrent()->toInteger() ;
    var d : Sequence(Sequence(int)) ; d := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     d[i+1] := d[i+1]->collect(INF) ; 
     d[i+1][i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < en do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     var dist : int ; dist := sc.getCurrent()->toInteger() ;
     d[s+1][t+1] := dist )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < n do ( (         var i : int ; i := 0 ; while i < n do ( (     if (d[i+1][k+1] = INF) then (     continue ) else skip ; 
         var j : int ; j := 0 ; while j < n do ( (     if (d[k+1][j+1] = INF) then (     continue ) else skip ; 
     d[i+1][j+1] := Set{d[i+1][j+1], d[i+1][k+1] + d[k+1][j+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    if (hasNegativeLoopWF(d)) then (     OclFile["System.out"].println("NEGATIVE CYCLE") ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     var res : Sequence(String) ; res := Integer.subrange(1,n)->collect(null) ;
         var j : int ; j := 0 ; while j < n do ( (     res[j+1] := if d[i+1][j+1] = INF then "INF" else ((d[i+1][j+1]) + "") endif )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(join(" ", res)) )  ;     i := i + 1 ) ; 
 );
  static   operation hasNegativeLoopWF( a : Sequence(Sequence(int))) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1][i+1] < 0) then (     return true ) else skip )  ;     i := i + 1 ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    try(Scanner sc=new Scanner(System.in)){
      int V=sc.nextInt();
      int E=sc.nextInt();
      int INF=Integer.MAX_VALUE ;
      int[][] dis=new int[V][V];
      for(int i=0 ; i<V ; i++){
        for(int j=0 ; j<V ; j++){
          if(i==j)dis[i][j]=0 ;
          else dis[i][j]=INF ;
        }
      }
      for(int i=0 ; i<E ; i++){
        int s=sc.nextInt();
        int t=sc.nextInt();
        int d=sc.nextInt();
        dis[s][t]=d ;
      }
      boolean negative=false ;
      for(int k=0 ; k<V ; k++){
        for(int i=0 ; i<V ; i++){
          for(int j=0 ; j<V ; j++){
            if(dis[i][k]<INF && dis[k][j]<INF){
              dis[i][j]=Math.min(dis[i][j],dis[i][k]+dis[k][j]);
            }
          }
          if(dis[i][i]<0)negative=true ;
        }
      }
      if(negative){
        System.out.println("NEGATIVE CYCLE");
        return ;
      }
      for(int i=0 ; i<V ; i++){
        for(int j=0 ; j<V-1 ; j++){
          System.out.print((dis[i][j]>=INF ? "INF" : dis[i][j])+" ");
        }
        System.out.println(dis[i][V-1]>=INF ? "INF" : dis[i][V-1]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var V : int ; V := sc.getCurrent()->toInteger() ;
     var E : int ; E := sc.getCurrent()->toInteger() ;
    var INF : int ; INF := 2147483647 ;
    var dis : Sequence(Sequence(int)) ; dis := Integer.subrange(1,V)->collect(Integer.subrange(1,V)->collect(0)) ;
        var i : int ; i := 0 ; while i < V do ( (         var j : int ; j := 0 ; while j < V do ( (     if (i = j) then     dis[i+1][j+1] := 0 ; else     dis[i+1][j+1] := INF ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < E do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
     dis[s+1][t+1] := d )  ;     i := i + 1 ) ; 
    var negative : boolean ; negative := false ;
        var k : int ; k := 0 ; while k < V do ( (         var i : int ; i := 0 ; while i < V do ( (         var j : int ; j := 0 ; while j < V do ( (     if (dis[i+1][k+1] < INF & dis[k+1][j+1] < INF) then (     dis[i+1][j+1] := Set{dis[i+1][j+1], dis[i+1][k+1] + dis[k+1][j+1]}->min() ) else skip )  ;     j := j + 1 ) ; 
     if (dis[i+1][i+1] < 0) then     negative := true ; else skip )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    if (negative) then (     OclFile["System.out"].println("NEGATIVE CYCLE") ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < V do ( (         var j : int ; j := 0 ; while j < V - 1 do ( (     OclFile["System.out"].print((if dis[i+1][j+1] >= INF then "INF" else dis[i+1][j+1] endif) + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(if dis[i+1][V - 1+1] >= INF then "INF" else dis[i+1][V - 1+1] endif) )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    new Main().run();
  }
  long INF=Long.MAX_VALUE/10 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    int V=sc.nextInt();
    int E=sc.nextInt();
    long[][] D=new long[V][V];
    for(int i=0 ; i<V ; ++i){
      Arrays.fill(D[i],INF);
      D[i][i]=0 ;
    }
    for(int i=0 ; i<E ; ++i)D[sc.nextInt()][sc.nextInt()]=sc.nextLong();
    for(int t=1 ; t<V ; t*=2)for(int i=0 ; i<V ; ++i)for(int j=0 ; j<V ; ++j)for(int m=0 ; m<V ; ++m)if(Math.max(D[i][m],D[m][j])<INF)D[i][j]=Math.min(D[i][j],D[i][m]+D[m][j]);
    for(int i=0 ; i<V ; ++i)if(D[i][i]<0){
      System.out.println("NEGATIVE CYCLE");
      return ;
    }
    for(int i=0 ; i<V ; ++i)for(int j=0 ; j<V ; ++j)System.out.print((D[i][j]>=INF ? "INF" : D[i][j])+(j==V-1 ? "\n" : " "));
  }
  static void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute INF : long := "9223372036854775807"->toLong() / 10;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var V : int ; V := sc.getCurrent()->toInteger() ;
    var E : int ; E := sc.getCurrent()->toInteger() ;
    var D : Sequence(Sequence(long)) ; D := Integer.subrange(1,V)->collect(Integer.subrange(1,V)->collect(0)) ;
        var i : int ; i := 0 ; while i < V do ( (     D[i+1] := D[i+1]->collect(INF) ; 
     D[i+1][i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < E do (     D[sc.getCurrent()->toInteger()+1][sc.getCurrent()->toInteger()+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
        var t : int ; t := 1 ; while t < V do (         var i : int ; i := 0 ; while i < V do (         var j : int ; j := 0 ; while j < V do (         var m : int ; m := 0 ; while m < V do (     if (Set{D[i+1][m+1], D[m+1][j+1]}->max() < INF) then     D[i+1][j+1] := Set{D[i+1][j+1], D[i+1][m+1] + D[m+1][j+1]}->min() ; else skip ;  ;     m := m + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ;  ;     t := t*(2) ) ; 
        var i : int ; i := 0 ; while i < V do (     if (D[i+1][i+1] < 0) then (     OclFile["System.out"].println("NEGATIVE CYCLE") ; 
     return ) else skip ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < V do (         var j : int ; j := 0 ; while j < V do (     OclFile["System.out"].print((if D[i+1][j+1] >= INF then "INF" else D[i+1][j+1] endif) + (if j = V - 1 then "\n" else " " endif)) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
 );
  static   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    InputStream inputStream ;
    OutputStream outputStream ;
    inputStream=System.in ;
    outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(in,out);
    out.close();
  }
  static class Task {
    public void solve(InputReader in,PrintWriter out){
      int n ;
      n=in.nextInt();
      long ans=0 ;
      for(int i=1 ; i<=n ; ++i){
        ans+=(long)i*(long)(n-i+1);
      }
      for(int i=1 ; i<n ; ++i){
        int u,v ;
        u=in.nextInt();
        v=in.nextInt();
        if(u>v){
          int tmp=u ;
          u=v ;
          v=tmp ;
        }
        ans-=(long)u*(long)(n-v+1);
      }
      out.println(ans);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream));
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    String nextLine(){
      String str="" ;
      try {
        str=reader.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ;
     var outputStream : OclFile ;
    inputStream := OclFile["System.in"] ; 
    outputStream := OclFile["System.out"] ; 
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ;
     n := in.nextInt() ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     ans := ans+(i->oclAsType(long) * (n - i + 1)->oclAsType(long)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     var u : int ;
    var v : int ;
     u := in.nextInt() ; 
    v := in.nextInt() ; 
    if (u > v) then (     var tmp : int ; tmp := u ;
     u := v ; 
     v := tmp ) else skip ; 
    ans := ans-(u->oclAsType(long) * (n - v + 1)->oclAsType(long)) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := reader.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void minRange(int arr[],int n,int k){
    int l=0,r=n ;
    for(int i=0 ; i<n ; i++){
      Set<Integer>s=new HashSet<Integer>();
      int j ;
      for(j=i ; j<n ; j++){
        s.add(arr[j]);
        if(s.size()==k){
          if((j-i)<(r-l)){
            r=j ;
            l=i ;
          }
          break ;
        }
      }
      if(j==n)break ;
    }
    if(l==0 && r==n)System.out.println("Invalid k");
    else System.out.println(l+" "+r);
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3,4,5 };
      int n=arr.length ;
      int k=3 ;
      minRange(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minRange( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
    var r : int ; r := n ;
         var i : int ; i := 0 ; while i < n do ( (     var s : Set(int) ; s := Set{} ;
     var j : int ;
         j := i ; while j < n do ( (     s := s->including(arr[j+1]) ; 
     if (s->size() = k) then (     if ((j - i) < (r - l)) then (     r := j ; 
     l := i ) else skip ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (j = n) then     break else skip )  ;     i := i + 1 ) ; 
     if (l = 0 & r = n) then     OclFile["System.out"].println("Invalid k") ; else     OclFile["System.out"].println(l + " " + r) ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     execute minRange(arr, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static long calculate(int bit_cnt){
    long res=1 ;
    while(bit_cnt-->0){
      res=res*3 ;
    }
    return res ;
  }
  static int unset_bit_count(long n){
    int count=0 ;
    while(n>0){
      if((n & 1)==0)count++;
      n=n>>1 ;
    }
    return count ;
  }
  public static void main(String[] args){
    long n ;
    n=2 ;
    int count=unset_bit_count(n);
    long ans=calculate(count);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculate( bit_cnt : int) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         while (bit_cnt > 0) do (        bit_cnt := bit_cnt - 1 ;     skip ; (     res := res * 3 ) ;  ) ;  
     return res );
  static   operation unset_bit_count( n : long) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     if ((n & 1) = 0) then     count := count + 1 ; else skip ; 
     n := (n/(2->pow(1)))->oclAsType(long) ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ;
     n := 2 ; 
    var count : int ; count := unset_bit_count(n) ;
    var ans : long ; ans := calculate(count) ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countSubarray(int arr[],int n,int k){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int sum=0 ;
      for(int j=i ; j<n ; j++){
        if(sum+arr[j]<k){
          sum=arr[j]+sum ;
          count++;
        }
        else {
          break ;
        }
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int array[]={
      1,11,2,3,15 };
      int k=10 ;
      int size=array.length ;
      int count=countSubarray(array,size,k);
      System.out.println(count);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSubarray( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := i ; while j < n do ( (     if (sum + arr[j+1] < k) then (     sum := arr[j+1] + sum ; 
     count := count + 1 ) else (     break ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Sequence{1,11,2,3,15} ;
     var k : int ; k := 10 ;
    var size : int ; size := array->size() ;
    var count : int ; count := countSubarray(array, size, k) ;
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class modularEquations {
  public static void main(String[] args){
    Kattio io=new Kattio();
    int a=io.nextInt();
    int b=io.nextInt();
    int l=a-b ;
    if(l==0){
      io.println("infinity");
    }
    else {
      int num=0 ;
      for(int i=1 ; i<=Math.sqrt(l); i++){
        if(l % i==0){
          if((l/i)>b){
            num++;
          }
          if(i>b && i!=(l/i)){
            num++;
          }
        }
      }
      io.println(num);
    }
    io.close();
  }
  static class Kattio extends PrintWriter {
    private BufferedReader r ;
    private StringTokenizer st ;
    public Kattio(){
      this(System.in,System.out);
    }
    public Kattio(InputStream i,OutputStream o){
      super(o);
      r=new BufferedReader(new InputStreamReader(i));
    }
    public Kattio(String problemName)throws IOException {
      super(problemName+".out");
      r=new BufferedReader(new FileReader(problemName+".in"));
    }
    public String next(){
      try {
        while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(r.readLine());
        return st.nextToken();
      }
      catch(Exception e){
      }
      return null ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class modularEquations {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : Kattio ; io := Kattio.newKattio() ;
     var a : int ; a := io.nextInt() ;
    var b : int ; b := io.nextInt() ;
    var l : int ; l := a - b ;
    if (l = 0) then (     io.println("infinity") ) else (     var num : int ; num := 0 ;
         var i : int ; i := 1 ; while i <= (l)->sqrt() do ( (     if (l mod i = 0) then (     if ((l / i) > b) then (     num := num + 1 ) else skip ; 
     if (i > b & i /= (l / i)) then (     num := num + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
     io.println(num) ) ;  
    io.close() ; 
 );
  static class Kattio extends OclFile {
   attribute r : OclFile;
   attribute st : OclIterator;
   static operation newKattio() : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile["System.in"], OclFile["System.out"]) );
   static operation newKattio( i : OclFile, o : OclFile) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(i, o);
    return self );
  operation initialise( i : OclFile, o : OclFile) : void
  pre: true  post: true
  activity: (     execute super(o) ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(i)) );
   static operation newKattio( problemName : String) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(problemName);
    return self );
  operation initialise( problemName : String) : void
  pre: true  post: true
  activity: (     execute super(problemName + ".out") ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(problemName + ".in")) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(r.readLine()) ; ; 
     return st.next() )   catch (e : ProgramException) do skip
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    double EPS=1e-13 ;
    double[] res=new double[100001];
    res[1]=1 ;
    for(int n=2 ; n<=100000 ; n++){
      double p=1,win=0.5 ;
      int k=1 ;
      while(EPS<p && k<n){
        double not=p*(1-win);
        res[n]+=not*(k+res[Math.max(0,n-k-1)]);
        p*=win ;
        win/=2 ;
        k++;
      }
      res[n]+=n*p ;
    }
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      System.out.printf("%.8f\n",res[n]);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var EPS : double ; EPS := 1e-13 ;
     var res : Sequence(double) ; res := Integer.subrange(1,100001)->collect(0.0) ;
    res[1+1] := 1 ; 
        var n : int ; n := 2 ; while n <= 100000 do ( (     var p : double ; p := 1 ;
    var win : double ; win := 0.5 ;
     var k : int ; k := 1 ;
     while (EPS < p & k < n) do (     var not : double ; not := p * (1 - win) ;
     res[n+1] := res[n+1]+(not * (k + res[Set{0, n - k - 1}->max()+1])) ; 
    p := p*(win) ; 
    win := win/(2) ; 
    k := k + 1 ; 
 ) ; 
     res[n+1] := res[n+1]+(n * p) )  ;     n := n + 1 ) ; 
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
      while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
     OclFile["System.out"].printf("%.8f\n", res[n+1]) )  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.Scanner ;
public class ModerateModulo {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=1 ;
    while(t-->0){
      int x=sc.nextInt();
      int y=sc.nextInt();
      if(x==y){
        System.out.println("infinity");
      }
      else if(y>x){
        System.out.println(0);
      }
      else {
        int ans=x-y ;
        HashSet<Integer>set=new HashSet<>();
        set.add(ans);
        for(int i=1 ; i*i<=ans ; i++){
          if(ans % i==0){
            set.add(i);
            set.add(ans/i);
          }
        }
        int res=0 ;
        for(int val : set){
          int mod=x % val ;
          if(mod==y){
            res++;
          }
        }
        System.out.println(res);
      }
    }
  }
  public static long Find(int x,int y){
    long n=x ;
    if(x==y){
      return n ;
    }
    else if(y % x==0){
      return n ;
    }
    else {
      if(x>y){
      }
      else {
      }
    }
    return n ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ModerateModulo {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     if (x = y) then (     OclFile["System.out"].println("infinity") ) else     if (y > x) then (     OclFile["System.out"].println(0) ) else (     var ans : int ; ans := x - y ;
     var set : Set(int) ; set := Set{} ;
    set := set->including(ans) ; 
        var i : int ; i := 1 ; while i * i <= ans do ( (     if (ans mod i = 0) then (     set := set->including(i) ; 
     set := set->including(ans / i) ) else skip )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    for (val : set) do ( (     var mod : int ; mod := x mod val ;
     if (mod = y) then (     res := res + 1 ) else skip )  ) ; 
    OclFile["System.out"].println(res) ; 
 ) ;  ) ;  ) );
  static   operation Find( x : int, y : int) : long
  pre: true
  post: true
  activity: (     var n : long ; n := x ;
     if (x = y) then (     return n ) else     if (y mod x = 0) then (     return n ) else (     if (x > y) then skip else skip ) ;  ;  
     return n );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long a=sc.nextLong();
    long b=sc.nextLong();
    long k=a-b ;
    if(k==0)System.out.println("infinity");
    else if(k<b)System.out.println("0");
    else {
      long count=0 ;
      for(long i=1 ; i<=Math.sqrt(k); i++){
        if(k % i==0){
          if(i>b){
            if(k/i==i)count++;
            else count=count+2 ;
          }
          else {
            if((k/i!=i)&&(k/i>b))count++;
          }
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var k : long ; k := a - b ;
    if (k = 0) then     OclFile["System.out"].println("infinity") else     if (k < b) then     OclFile["System.out"].println("0") else (     var count : long ; count := 0 ;
         var i : long ; i := 1 ; while i <= (k)->sqrt() do ( (     if (k mod i = 0) then (     if (i > b) then (     if (k / i = i) then     count := count + 1 ; else     count := count + 2 ; ) else (     if ((k / i /= i) & (k / i > b)) then     count := count + 1 ; else skip ) ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int sum=0 ;
    int l[]=new int[n];
    for(int i=0 ; i<n ; i++){
      l[i]=sc.nextInt();
      sum+=l[i];
    }
    int ans=Integer.MAX_VALUE ;
    for(int left=0 ; left<n ; left++){
      int low=0 ;
      for(int right=left ; right<n ; right++){
        low+=l[right];
        int[] dp=new int[n+1];
        dp[0]=low ;
        for(int position=0 ; position<n ; position++){
          int length=0 ;
          dp[position+1]=Integer.MAX_VALUE ;
          for(int le=position ; le>=0 ; le--){
            length+=l[le];
            if(position==n-1 && le==0)continue ;
            if(length>=low)dp[position+1]=Math.min(dp[position+1],Math.max(length,dp[le]));
          }
        }
        ans=Math.min(ans,dp[n]-low);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var l : Sequence(int) ; l := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     l[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(l[i+1]) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
        var left : int ; left := 0 ; while left < n do ( (     var low : int ; low := 0 ;
         var right : int ; right := left ; while right < n do ( (     low := low+(l[right+1]) ; 
     var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
    dp[0+1] := low ; 
        var position : int ; position := 0 ; while position < n do ( (     var length : int ; length := 0 ;
     dp[position + 1+1] := 2147483647 ; 
         var le : int ; le := position ; while le >= 0 do ( (     length := length+(l[le+1]) ; 
     if (position = n - 1 & le = 0) then     continue else skip ; 
     if (length >= low) then     dp[position + 1+1] := Set{dp[position + 1+1], Set{length, dp[le+1]}->max()}->min() ; else skip )  ;     le := le - 1 ) )  ;     position := position + 1 ) ; 
    ans := Set{ans, dp[n+1] - low}->min() ; 
 )  ;     right := right + 1 ) )  ;     left := left + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int getMinVal(int p,int q){
    if(q % p==0)return p ;
    return-1 ;
  }
  public static void main(String[] args){
    int p=24,q=48 ;
    System.out.println(getMinVal(p,q));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getMinVal( p : int, q : int) : int
  pre: true
  post: true
  activity: (     if (q mod p = 0) then     return p else skip ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : int ; p := 24 ;
    var q : int ; q := 48 ;
     OclFile["System.out"].println(getMinVal(p, q)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String isEvenOrOdd(int L,int R){
    int oddCount=(R-L)/2 ;
    if(R % 2==1 || L % 2==1)oddCount++;
    if(oddCount % 2==0)return "Even" ;
    else return "Odd" ;
  }
  public static void main(String[] args){
    int L=5,R=15 ;
    System.out.println(isEvenOrOdd(L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isEvenOrOdd( L : int, R : int) : String
  pre: true
  post: true
  activity: (     var oddCount : int ; oddCount := (R - L) / 2 ;
     if (R mod 2 = 1 or L mod 2 = 1) then     oddCount := oddCount + 1 ; else skip ; 
     if (oddCount mod 2 = 0) then     return "Even" else     return "Odd" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 5 ;
    var R : int ; R := 15 ;
     OclFile["System.out"].println(isEvenOrOdd(L, R)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int ma=sc.nextInt();
    int mb=sc.nextInt();
    int[][] dp=new int[401][401];
    for(int i=0 ; i<401 ; i++){
      Arrays.fill(dp[i],Integer.MAX_VALUE);
    }
    dp[0][0]=0 ;
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      for(int j=400 ; j>=a ; j--){
        for(int k=400 ; k>=b ; k--){
          if(dp[j-a][k-b]!=Integer.MAX_VALUE){
            dp[j][k]=Math.min(dp[j][k],c+dp[j-a][k-b]);
          }
        }
      }
    }
    int ans=Integer.MAX_VALUE ;
    for(int i=1 ; 401>Math.max(ma,mb)*i ; i++){
      if(dp[ma*i][mb*i]!=Integer.MAX_VALUE){
        ans=Math.min(ans,dp[ma*i][mb*i]);
      }
    }
    if(ans==Integer.MAX_VALUE){
      System.out.println(-1);
    }
    else {
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ma : int ; ma := sc.getCurrent()->toInteger() ;
    var mb : int ; mb := sc.getCurrent()->toInteger() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,401)->collect(Integer.subrange(1,401)->collect(0)) ;
        var i : int ; i := 0 ; while i < 401 do ( (     dp[i+1] := dp[i+1]->collect(2147483647) )  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
         var j : int ; j := 400 ; while j >= a do ( (         var k : int ; k := 400 ; while k >= b do ( (     if (dp[j - a+1][k - b+1] /= 2147483647) then (     dp[j+1][k+1] := Set{dp[j+1][k+1], c + dp[j - a+1][k - b+1]}->min() ) else skip )  ;     k := k - 1 ) )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 1 ; while 401 > Set{ma, mb}->max() * i do ( (     if (dp[ma * i+1][mb * i+1] /= 2147483647) then (     ans := Set{ans, dp[ma * i+1][mb * i+1]}->min() ) else skip )  ;     i := i + 1 ) ; 
    if (ans = 2147483647) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(ans) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
interface Main {
  static void main(String[] $){
    var s=new java.util.Scanner(System.in);
    long n=s.nextInt(),a=n++*n++*n--/6,m=n ;
    while(m-->2){
      long u=s.nextInt(),v=s.nextInt();
      a-=(u<v ? u : v)*n-u*v ;
    }
    System.out.print(a);
  }
}
------------------------------------------------------------
OCL File:
---------
interface Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : var ; s := Scanner.newScanner(OclFile["System.in"]) ;
     var n : long ; n := s.nextInt() ;
    var a : long ; a := n * n * n / 6 ;
    var m : long ; m := n ;
         while (m > 2) do (        m := m - 1 ;     skip ; (     var u : long ; u := s.nextInt() ;
    var v : long ; v := s.nextInt() ;
     a := a-((if u < v then u else v endif) * n - u * v) ) ;  ) ;  
     OclFile["System.out"].print(a) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Comparator<int[]>comparator=new Comparator<int[]>(){
      @ Override public int compare(int[] o1,int[] o2){
        return Double.compare((double)o1[0]/o1[1],(double)o2[0]/o2[1]);
      }
    };
    Scanner sc=new Scanner(System.in);
    int INF=Integer.MAX_VALUE-500000 ;
    int N=Integer.parseInt(sc.next());
    int Ma=Integer.parseInt(sc.next());
    int Mb=Integer.parseInt(sc.next());
    int[][] dp=new int[401][401];
    for(int i=0 ; i<dp.length ; i++){
      for(int j=0 ; j<dp.length ; j++){
        dp[i][j]=INF ;
      }
    }
    dp[0][0]=0 ;
    for(int k=0 ; k<N ; k++){
      int a=Integer.parseInt(sc.next());
      int b=Integer.parseInt(sc.next());
      int c=Integer.parseInt(sc.next());
      for(int i=400 ; i>=0 ; i--){
        for(int j=400 ; j>=0 ; j--){
          if(dp[i][j]!=INF){
            dp[i+a][j+b]=Math.min(dp[i+a][j+b],dp[i][j]+c);
          }
        }
      }
    }
    int x=Ma ;
    int y=Mb ;
    int ans=INF ;
    while(x<400 && y<400){
      ans=Math.min(ans,dp[x][y]);
      x+=Ma ;
      y+=Mb ;
    }
    if(ans!=INF)System.out.println(ans);
    else System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var comparator : Function(<Sequence(int)>,(<Sequence(int)>,boolean)) ; comparator := OclComparator<Sequence(int)>.newOclComparator() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var INF : int ; INF := 2147483647 - 500000 ;
    var N : int ; N := (sc.getCurrent())->toInteger() ;
    var Ma : int ; Ma := (sc.getCurrent())->toInteger() ;
    var Mb : int ; Mb := (sc.getCurrent())->toInteger() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,401)->collect(Integer.subrange(1,401)->collect(0)) ;
        var i : int ; i := 0 ; while i < dp->size() do ( (         var j : int ; j := 0 ; while j < dp->size() do ( (     dp[i+1][j+1] := INF )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := 0 ; 
        var k : int ; k := 0 ; while k < N do ( (     var a : int ; a := (sc.getCurrent())->toInteger() ;
     var b : int ; b := (sc.getCurrent())->toInteger() ;
     var c : int ; c := (sc.getCurrent())->toInteger() ;
         var i : int ; i := 400 ; while i >= 0 do ( (         var j : int ; j := 400 ; while j >= 0 do ( (     if (dp[i+1][j+1] /= INF) then (     dp[i + a+1][j + b+1] := Set{dp[i + a+1][j + b+1], dp[i+1][j+1] + c}->min() ) else skip )  ;     j := j - 1 ) )  ;     i := i - 1 ) )  ;     k := k + 1 ) ; 
    var x : int ; x := Ma ;
    var y : int ; y := Mb ;
    var ans : int ; ans := INF ;
    while (x < 400 & y < 400) do (     ans := Set{ans, dp[x+1][y+1]}->min() ; 
     x := x+(Ma) ; 
     y := y+(Mb) ) ; 
    if (ans /= INF) then     OclFile["System.out"].println(ans) else     OclFile["System.out"].println(-1) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int gcd(int a,int b){
    if(a==0 || b==0)return 0 ;
    if(a==b)return a ;
    if(a>b)return gcd(a-b,b);
    return gcd(a,b-a);
  }
  static int cpFact(int x,int y){
    while(gcd(x,y)!=1){
      x=x/gcd(x,y);
    }
    return x ;
  }
  public static void main(String[] args){
    int x=15 ;
    int y=3 ;
    System.out.println(cpFact(x,y));
    x=14 ;
    y=28 ;
    System.out.println(cpFact(x,y));
    x=7 ;
    y=3 ;
    System.out.println(cpFact(x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0 or b = 0) then     return 0 else skip ; 
     if (a = b) then     return a else skip ; 
     if (a > b) then     return gcd(a - b, b) else skip ; 
     return gcd(a, b - a) );
  static   operation cpFact( x : int, y : int) : int
  pre: true
  post: true
  activity: (     while (gcd(x, y) /= 1) do (     x := x / gcd(x, y) ) ; 
     return x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 15 ;
     var y : int ; y := 3 ;
    OclFile["System.out"].println(cpFact(x, y)) ; 
    x := 14 ; 
    y := 28 ; 
    OclFile["System.out"].println(cpFact(x, y)) ; 
    x := 7 ; 
    y := 3 ; 
    OclFile["System.out"].println(cpFact(x, y)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    long ans=getCount(n,m);
    System.out.println(ans);
  }
  public static long getCount(int n,int m){
    int mod=1000000009 ;
    long max=myPow(2,m,mod)-1 ;
    if(n>max){
      return 0 ;
    }
    long ans=1 ;
    for(int i=0 ; i<n ; i++){
      ans=(((ans % mod)*(max % mod)% mod)+mod)% mod ;
      max--;
    }
    return ans ;
  }
  public static long myPow(long x,long n,int mod){
    long result=1 ;
    while(n!=0){
      if((n & 1)>0){
        result=result*x % mod ;
      }
      x=x*x % mod ;
      n>>=1 ;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var ans : long ; ans := getCount(n, m) ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation getCount( n : int, m : int) : long
  pre: true
  post: true
  activity: (     var mod : int ; mod := 1000000009 ;
     var max : long ; max := myPow(2, m, mod) - 1 ;
    if (n > max) then (     return 0 ) else skip ; 
    var ans : long ; ans := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     ans := (((ans mod mod) * (max mod mod) mod mod) + mod) mod mod ; 
     max := max - 1 )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation myPow( x : long, n : long, mod : int) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 1 ;
     while (n /= 0) do (     if ((MathLib.bitwiseAnd(n,1)) > 0) then (     result := result * x mod mod ) else skip ; 
     x := x * x mod mod ; 
     n := n/(2->pow(1)) ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Rectangle2D ;
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.ListIterator ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static final int MAX=100000 ;
  public static final int MAX_D=15 ;
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    double[][] DP=new double[MAX+1][MAX_D+1];
    double[] ans=new double[MAX];
    DP[0][0]=1 ;
    double sum=0 ;
    for(int day=0 ; day<MAX ; day++){
      for(int suc=0 ; suc<MAX_D ; suc++){
        if(DP[day][suc]<=0){
          continue ;
        }
        sum+=DP[day][suc]*Math.pow(0.5,suc);
        if(suc==0){
          DP[day+1][suc+1]+=DP[day][suc];
        }
        else {
          DP[day+1][0]+=DP[day][suc]*(1-Math.pow(0.5,suc));
          DP[day+1][suc+1]+=DP[day][suc]*Math.pow(0.5,suc);
        }
      }
      ans[day]=sum ;
    }
    while(true){
      final int n=sc.nextInt();
      if(n==0){
        break ;
      }
      System.out.println(ans[n-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 100000;
  static    attribute MAX_D : int := 15;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var DP : Sequence(Sequence(double)) ; DP := Integer.subrange(1,MAX + 1)->collect(Integer.subrange(1,MAX_D + 1)->collect(0.0)) ;
    var ans : Sequence(double) ; ans := Integer.subrange(1,MAX)->collect(0.0) ;
    DP[0+1][0+1] := 1 ; 
    var sum : double ; sum := 0 ;
        var day : int ; day := 0 ; while day < MAX do ( (         var suc : int ; suc := 0 ; while suc < MAX_D do ( (     if (DP[day+1][suc+1] <= 0) then (     continue ) else skip ; 
     sum := sum+(DP[day+1][suc+1] * 0.5->pow(suc)) ; 
     if (suc = 0) then (     DP[day + 1+1][suc + 1+1] := DP[day + 1+1][suc + 1+1]+(DP[day+1][suc+1]) ) else (     DP[day + 1+1][0+1] := DP[day + 1+1][0+1]+(DP[day+1][suc+1] * (1 - 0.5->pow(suc))) ; 
     DP[day + 1+1][suc + 1+1] := DP[day + 1+1][suc + 1+1]+(DP[day+1][suc+1] * 0.5->pow(suc)) ) )  ;     suc := suc + 1 ) ; 
     ans[day+1] := sum )  ;     day := day + 1 ) ; 
    while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
     OclFile["System.out"].println(ans[n - 1+1]) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static long n,m ;
  static long mod=(long)1e9+9 ;
  static StringBuffer str=new StringBuffer();
  static long mod_mul(long a,long b){
    a=a % mod ;
    b=b % mod ;
    return(((a*b)% mod)+mod)% mod ;
  }
  static long pow(long a,long b){
    long res=1 ;
    while(b>0){
      if(b % 2==1){
        res=(res*a)% mod ;
        b--;
      }
      else {
        a=(a*a)% mod ;
        b=b>>1 ;
      }
    }
    return res ;
  }
  static void solve(){
    long tot=pow(2,m)-1 ;
    if(n>tot){
      str.append(0);
      return ;
    }
    long ans=1 ;
    for(int i=1 ; i<=n ; i++)ans=mod_mul(ans,tot--)% mod ;
    str.append(ans).append("\n");
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    String st[]=bf.readLine().trim().split("\\s+");
    n=Long.parseLong(st[0]);
    m=Long.parseLong(st[1]);
    solve();
    pw.println(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute n : long;
  static   attribute mod : long := 1e9->oclAsType(long) + 9;
  static   attribute str : String := StringLib.newString();
  static   operation mod_mul( a : long, b : long) : long
  pre: true
  post: true
  activity: (     a := a mod mod ; 
     b := b mod mod ; 
     return (((a * b) mod mod) + mod) mod mod );
  static   operation pow( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     while (b > 0) do (     if (b mod 2 = 1) then (     res := (res * a) mod mod ; 
     b := b - 1 ) else (     a := (a * a) mod mod ; 
     b := (b/(2->pow(1)))->oclAsType(long) ) ) ; 
     return res );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var tot : long ; tot := pow(2, m) - 1 ;
     if (n > tot) then (     str := str + StringLib.newString(0) ; 
     return ) else skip ; 
    var ans : long ; ans := 1 ;
        var i : int ; i := 1 ; while i <= n do (     ans := mod_mul(ans, tot) mod mod ;  ;     i := i + 1 ) ; 
    str := str + StringLib.newString(ans) + StringLib.newString("\n") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var st : Sequence(String) ; st := bf.readLine()->trim()->split("\\s+") ;
    n := (st[0+1])->toLong() ; 
    m := (st[1+1])->toLong() ; 
    execute solve() ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A238 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int M=in.nextInt();
    long mod=1000000009 ;
    long next=1 ;
    for(int m=0 ; m<M ; m++){
      next*=2 ;
      next %=mod ;
    }
    long answer=1 ;
    for(int n=0 ; n<N ; n++){
      next--;
      answer*=next ;
      answer %=mod ;
    }
    if(answer<0){
      answer+=mod ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A238 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var M : int ; M := in.getCurrent()->toInteger() ;
    var mod : long ; mod := 1000000009 ;
    var next : long ; next := 1 ;
        var m : int ; m := 0 ; while m < M do ( (     next := next*(2) ; 
     next := next mod mod )  ;     m := m + 1 ) ; 
    var answer : long ; answer := 1 ;
        var n : int ; n := 0 ; while n < N do ( (     next := next - 1 ; 
     answer := answer*(next) ; 
     answer := answer mod mod )  ;     n := n + 1 ) ; 
    if (answer < 0) then (     answer := answer+(mod) ) else skip ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static BufferedReader bf ;
  static PrintWriter pw ;
  static int n,m ;
  static long mod=(long)1e9+9 ;
  static long pow(long a,long b){
    long res=1 ;
    while(b>0){
      if(b % 2==1)res=(res*a)% mod ;
      a=(a*a)% mod ;
      b=b>>1l ;
    }
    return res ;
  }
  static void solve(int te)throws Exception {
    long val=(pow(2,m)-n+mod)% mod ;
    long ans=val ;
    for(int i=2 ; i<=n ; i++){
      val=(val+1)% mod ;
      ans=(ans*val)% mod ;
    }
    str.append(ans).append("\n");
  }
  public static void main(String[] args)throws java.lang.Exception {
    boolean lenv=false ;
    int te=1 ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    String s[]=bf.readLine().trim().split("\\s+");
    n=Integer.parseInt(s[0]);
    m=Integer.parseInt(s[1]);
    solve(te);
    pw.print(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute bf : OclFile;
  static   attribute pw : OclFile;
  static   attribute n : int;
  static   attribute mod : long := 1e9->oclAsType(long) + 9;
  static   operation pow( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     while (b > 0) do (     if (b mod 2 = 1) then     res := (res * a) mod mod ; else skip ; 
     a := (a * a) mod mod ; 
     b := (b/(2->pow(1l)))->oclAsType(long) ) ; 
     return res );
  static   operation solve( te : int) : void
  pre: true
  post: true
  activity: (     var val : long ; val := (pow(2, m) - n + mod) mod mod ;
     var ans : long ; ans := val ;
         var i : int ; i := 2 ; while i <= n do ( (     val := (val + 1) mod mod ; 
     ans := (ans * val) mod mod )  ;     i := i + 1 ) ; 
     str := str + StringLib.newString(ans) + StringLib.newString("\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var lenv : boolean ; lenv := false ;
     var te : int ; te := 1 ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var s : Sequence(String) ; s := bf.readLine()->trim()->split("\\s+") ;
    n := (s[0+1])->toInteger() ; 
    m := (s[1+1])->toInteger() ; 
    execute solve(te) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class TaskB {
  static final int SIZE=(int)1e5+5 ;
  static long[] a=new long[SIZE];
  public static void solve(InputReader in,PrintWriter out){
    long w=in.nextLong(),h=in.nextLong();
    long res=0 ;
    long base=(h/2+1)*(h/2)/2 ;
    for(int i=2 ; i<=w ; i+=2){
      if(h % 2==0){
        res+=(w-i+1)*(base*2-h/2);
      }
      else {
        res+=(w-i+1)*(base*2);
      }
    }
    out.println(res);
  }
  private static class InputReader {
    private BufferedReader reader ;
    private StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=reader.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    InputReader in=new InputReader(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int T=1 ;
    for(int i=1 ; i<=T ; ++i){
      solve(in,out);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class TaskB {
  static    attribute SIZE : int := 1e5->oclAsType(int) + 5;
  static   attribute a : Sequence(long) := Integer.subrange(1,SIZE)->collect(0);
  static   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var w : long ; w := in.nextLong() ;
    var h : long ; h := in.nextLong() ;
     var res : long ; res := 0 ;
    var base : long ; base := (h / 2 + 1) * (h / 2) / 2 ;
        var i : int ; i := 2 ; while i <= w do ( (     if (h mod 2 = 0) then (     res := res+((w - i + 1) * (base * 2 - h / 2)) ) else (     res := res+((w - i + 1) * (base * 2)) ) )  ;     i := i+(2) ) ; 
    out.println(res) ; 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := reader.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : InputReader ; in := InputReader.newInputReader(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := 1 ;
        var i : int ; i := 1 ; while i <= T do ( (     execute solve(in, out) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  static double PI=3.14159265 ;
  public static double area_inscribed(double a){
    return(a*a*(PI/12));
  }
  public static double perm_inscribed(double a){
    return(PI*(a/Math.sqrt(3)));
  }
  public static void main(String[] args){
    double a=6.0 ;
    System.out.println("Area of inscribed circle is :"+area_inscribed(a));
    System.out.println("\nPerimeter of inscribed circle is :"+perm_inscribed(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute PI : double := 3.14159265;
  static   operation area_inscribed( a : double) : double
  pre: true
  post: true
  activity: (     return (a * a * (PI / 12)) );
  static   operation perm_inscribed( a : double) : double
  pre: true
  post: true
  activity: (     return (PI * (a / (3)->sqrt())) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 6.0 ;
     OclFile["System.out"].println("Area of inscribed circle is :" + area_inscribed(a)) ; 
     OclFile["System.out"].println("\nPerimeter of inscribed circle is :" + perm_inscribed(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static class Node {
    char data ;
    Node prev ;
    Node next ;
  }
  static Node head=null ;
  static void rotate(int N){
    if(N==0)return ;
    Node current=head ;
    int count=1 ;
    while(count<N && current!=null){
      current=current.next ;
      count++;
    }
    if(current==null)return ;
    Node NthNode=current ;
    while(current.next!=null)current=current.next ;
    current.next=head ;
(head).prev=current ;
    head=NthNode.next ;
(head).prev=null ;
    NthNode.next=null ;
  }
  static void push(char new_data){
    Node new_node=new Node();
    new_node.data=new_data ;
    new_node.prev=null ;
    new_node.next=(head);
    if((head)!=null)(head).prev=new_node ;
    head=new_node ;
  }
  static void printList(Node node){
    while(node!=null && node.next!=null){
      System.out.print(node.data+" ");
      node=node.next ;
    }
    if(node!=null)System.out.print(node.data);
  }
  public static void main(String[] args){
    push('e');
    push('d');
    push('c');
    push('b');
    push('a');
    int N=2 ;
    System.out.println("Given linked list ");
    printList(head);
    rotate(N);
    System.out.println();
    System.out.println("Rotated Linked list ");
    printList(head);
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static class Node {
   attribute data : String;
   attribute prev : Node;
   attribute next : Node;
}
  static   attribute head : Node := null;
  static   operation rotate( N : int) : void
  pre: true
  post: true
  activity: (     if (N = 0) then     return else skip ; 
     var current : Node ; current := head ;
    var count : int ; count := 1 ;
    while (count < N & current /= null) do (     current := current.next ; 
     count := count + 1 ) ; 
    if (current = null) then     return else skip ; 
    var NthNode : Node ; NthNode := current ;
    while (current.next /= null) do     current := current.next ; ; 
    current.next := head ; 
    (head).prev := current ; 
    head := NthNode.next ; 
    (head).prev := null ; 
    NthNode.next := null ; 
 );
  static   operation push( new_data : String) : void
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode() ;
     new_node.data := new_data ; 
    new_node.prev := null ; 
    new_node.next := (head) ; 
    if ((head) /= null) then     (head).prev := new_node ; else skip ; 
    head := new_node ; 
 );
  static   operation printList( node : Node) : void
  pre: true
  post: true
  activity: (     while (node /= null & node.next /= null) do (     OclFile["System.out"].print(node.data + " ") ; 
     node := node.next ) ; 
     if (node /= null) then     OclFile["System.out"].print(node.data) ; else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute push('e') ; 
     execute push('d') ; 
    execute push('c') ; 
    execute push('b') ; 
    execute push('a') ; 
    var N : int ; N := 2 ;
    OclFile["System.out"].println("Given linked list ") ; 
    execute printList(head) ; 
    execute rotate(N) ; 
    OclFile["System.out"].println() ; 
    OclFile["System.out"].println("Rotated Linked list ") ; 
    execute printList(head) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
public class BearAndPrime {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    List<Integer>primes=new ArrayList<>();
    Collections.addAll(primes,3,5,7,11,13,17,19,23,29,31,37,41,43,47);
    System.out.println(2);
    String response=br.readLine();
    if(response.equals("yes")){
      for(int p=2 ; p<=6 ; p++){
        System.out.println((int)Math.pow(2,p));
        response=br.readLine();
        if(response.equals("yes")){
          System.out.println("composite");
          return ;
        }
      }
      for(int num : primes){
        System.out.println(num);
        response=br.readLine();
        if(response.equals("yes")){
          System.out.println("composite");
          return ;
        }
      }
      System.out.println("prime");
      return ;
    }
    List<Integer>divisors=new ArrayList<>();
    for(int num : primes){
      System.out.println(num);
      response=br.readLine();
      if(response.equals("yes")){
        divisors.add(num);
      }
    }
    if(divisors.size()>=2){
      System.out.println("composite");
      return ;
    }
    if(divisors.size()==0){
      System.out.println("prime");
      return ;
    }
    int d=divisors.get(0);
    if(d>=3 && d<=7){
      System.out.println(d*d);
      response=br.readLine();
      if(response.equals("yes")){
        System.out.println("composite");
        return ;
      }
    }
    System.out.println("prime");
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class BearAndPrime {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var primes : Sequence(int) ; primes := Sequence{} ;
addAll(primes, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47) ; 
    OclFile["System.out"].println(2) ; 
    var response : String ; response := br.readLine() ;
    if (response = "yes") then (         var p : int ; p := 2 ; while p <= 6 do ( (     OclFile["System.out"].println(2->pow(p)->oclAsType(int)) ; 
     response := br.readLine() ; 
     if (response = "yes") then (     OclFile["System.out"].println("composite") ; 
     return ) else skip )  ;     p := p + 1 ) ; 
     for (num : primes) do ( (     OclFile["System.out"].println(num) ; 
     response := br.readLine() ; 
     if (response = "yes") then (     OclFile["System.out"].println("composite") ; 
     return ) else skip )  ) ; 
     OclFile["System.out"].println("prime") ; 
     return ) else skip ; 
    var divisors : Sequence(int) ; divisors := Sequence{} ;
    for (num : primes) do ( (     OclFile["System.out"].println(num) ; 
     response := br.readLine() ; 
     if (response = "yes") then (     divisors := divisors->including(num) ) else skip )  ) ; 
    if (divisors->size() >= 2) then (     OclFile["System.out"].println("composite") ; 
     return ) else skip ; 
    if (divisors->size() = 0) then (     OclFile["System.out"].println("prime") ; 
     return ) else skip ; 
    var d : int ; d := divisors->at(0+1) ;
    if (d >= 3 & d <= 7) then (     OclFile["System.out"].println(d * d) ; 
     response := br.readLine() ; 
     if (response = "yes") then (     OclFile["System.out"].println("composite") ; 
     return ) else skip ) else skip ; 
    OclFile["System.out"].println("prime") ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    MyScanner sc=new MyScanner();
    PrintWriter out=new PrintWriter(System.out);
    int N=sc.nextInt();
    long edges=0 ;
    for(int i=0 ; i<N-1 ; i++){
      long a=sc.nextLong();
      long b=sc.nextLong();
      long min=Math.min(a,b);
      long max=Math.max(a,b);
      edges+=min*(N+1-max);
    }
    long ans=0 ;
    for(long i=1 ; i<=N ; i++){
      ans+=(i*(i+1))/2 ;
    }
    ans-=edges ;
    out.println(ans);
    out.flush();
  }
  static class MyScanner {
    private BufferedReader br ;
    private StringTokenizer tokenizer ;
    public MyScanner(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := sc.nextInt() ;
    var edges : long ; edges := 0 ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     var a : long ; a := sc.nextLong() ;
     var b : long ; b := sc.nextLong() ;
    var min : long ; min := Set{a, b}->min() ;
    var max : long ; max := Set{a, b}->max() ;
    edges := edges+(min * (N + 1 - max)) ; 
 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : long ; i := 1 ; while i <= N do ( (     ans := ans+((i * (i + 1)) / 2) )  ;     i := i + 1 ) ; 
    ans := ans-(edges) ; 
    skip ; 
    skip ; 
 );
  static class MyScanner {
   attribute br : OclFile;
   attribute tokenizer : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String str=sc.next();
    for(int i=0 ; i<n ; i++){
      System.out.print(str.charAt(i));
      if(n % 2==0){
        if(i % 2==1 && i!=(n-1))System.out.print("-");
      }
      else if(i % 2==1 && i!=(n-2))System.out.print("-");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var str : String ; str := sc.getCurrent() ;
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(str->at(i+1)) ; 
     if (n mod 2 = 0) then (     if (i mod 2 = 1 & i /= (n - 1)) then     OclFile["System.out"].print("-") ; else skip ) else     if (i mod 2 = 1 & i /= (n - 2)) then     OclFile["System.out"].print("-") ; else skip ; )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    String str=scanner.next();
    int i=0 ;
    int v=(int)(Math.random()*114514)+114514 ;
    while(i<n){
      if(n-i==3){
        System.out.printf("%c%c%c",str.charAt(i),str.charAt(i+1),str.charAt(i+2));
      }
      else if(n-i==4){
        System.out.printf("%c%c-%c%c",str.charAt(i),str.charAt(i+1),str.charAt(i+2),str.charAt(i+3));
      }
      else if(n-i==2){
        System.out.printf("%c%c",str.charAt(i),str.charAt(i+1));
      }
      if(n-i<=4){
        break ;
      }
      int j=2+v % 2 ;
      for(int s=0 ; s<j ; s++){
        System.out.printf("%c",str.charAt(i+s));
      }
      System.out.printf("-");
      i+=j ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var str : String ; str := scanner.getCurrent() ;
    var i : int ; i := 0 ;
    var v : int ; v := (MathLib.random() * 114514)->oclAsType(int) + 114514 ;
    while (i < n) do (     if (n - (i)->char2byte() = 3) then (     OclFile["System.out"].printf("%c%c%c", str->at(i+1), str->at(i + 1+1), str->at(i + 2+1)) ) else     if (n - (i)->char2byte() = 4) then (     OclFile["System.out"].printf("%c%c-%c%c", str->at(i+1), str->at(i + 1+1), str->at(i + 2+1), str->at(i + 3+1)) ) else     if (n - (i)->char2byte() = 2) then (     OclFile["System.out"].printf("%c%c", str->at(i+1), str->at(i + 1+1)) ) else skip ; ;  ;  
     if (n - (i)->char2byte() <= 4) then (     break ) else skip ; 
    var j : int ; j := 2 + v mod 2 ;
        var s : int ; s := 0 ; while s < j do ( (     OclFile["System.out"].printf("%c", str->at(i + s+1)) )  ;     s := s + 1 ) ; 
    OclFile["System.out"].printf("-") ; 
    i := i+(j) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int x[]=new int[n+1];
    int ji[]=new int[n+1];
    int shu[]=new int[n/2];
    for(int i=0 ; i<n/2 ; i++){
      shu[i]=in.nextInt();
    }
    Arrays.sort(shu);
    int l1=0 ;
    int l2=0 ;
    for(int i=0 ; i<n/2 ; i++){
      int s1=i*2+1 ;
      int s2=i*2+2 ;
      int id=shu[i];
      if(id!=s1){
        l1=l1+Math.abs(s1-id);
      }
      if(id!=s2){
        l2=l2+Math.abs(s2-id);
      }
    }
    int min=Math.min(l1,l2);
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n + 1)->collect(0) ;
    var ji : Sequence(int) ; ji := Integer.subrange(1,n + 1)->collect(0) ;
    var shu : Sequence(int) ; shu := Integer.subrange(1,n / 2)->collect(0) ;
        var i : int ; i := 0 ; while i < n / 2 do ( (     shu[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    shu := shu->sort() ; 
    var l1 : int ; l1 := 0 ;
    var l2 : int ; l2 := 0 ;
        var i : int ; i := 0 ; while i < n / 2 do ( (     var s1 : int ; s1 := i * 2 + 1 ;
     var s2 : int ; s2 := i * 2 + 2 ;
    var id : int ; id := shu[i+1] ;
    if (id /= s1) then (     l1 := l1 + if s1 - id < 0 then -(s1 - id) else s1 - id endif ) else skip ; 
    if (id /= s2) then (     l2 := l2 + if s2 - id < 0 then -(s2 - id) else s2 - id endif ) else skip ; 
 )  ;     i := i + 1 ) ; 
    var min : int ; min := Set{l1, l2}->min() ;
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int N=stdIn.nextInt();
    int count=0 ;
    int temp=N ;
    int ans=0 ;
    while(temp>0){
      temp/=10 ;
      count++;
    }
    for(int i=1 ; i<=count ; i++){
      if(i==count){
        if(i % 2==1){
          ans+=(N-Math.pow(10,i-1)+1);
        }
      }
      else {
        if(i==1){
          ans+=9 ;
        }
        else if(i % 2==1){
          ans+=(Math.pow(10,i)-Math.pow(10,i-1));
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := stdIn.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var temp : int ; temp := N ;
    var ans : int ; ans := 0 ;
    while (temp > 0) do (     temp := temp/(10) ; 
     count := count + 1 ) ; 
        var i : int ; i := 1 ; while i <= count do ( (     if (i = count) then (     if (i mod 2 = 1) then (     ans := ans+((N - 10->pow(i - 1) + 1)) ) else skip ) else (     if (i = 1) then (     ans := ans+(9) ) else     if (i mod 2 = 1) then (     ans := ans+((10->pow(i) - 10->pow(i - 1))) ) else skip ; ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int k=sc.nextInt();
      String s=sc.next();
      String ans="" ;
      if(k % 2==0){
        for(int i=0 ; i<s.length(); i+=2){
          if(i+2==s.length()){
            System.out.print(s.charAt(i));
            System.out.print(s.charAt(i+1));
            break ;
          }
          else {
            System.out.print(s.charAt(i));
            System.out.print(s.charAt(i+1));
            System.out.print('-');
          }
        }
      }
      else if(k % 2!=0){
        for(int i=0 ; i<s.length(); i=i+2){
          if(i+2==s.length()-1){
            System.out.print(s.charAt(i));
            System.out.print(s.charAt(i+1));
            System.out.print(s.charAt(i+2));
            break ;
          }
          else {
            System.out.print(s.charAt(i));
            System.out.print(s.charAt(i+1));
            System.out.print('-');
          }
        }
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var ans : String ; ans := "" ;
    if (k mod 2 = 0) then (         var i : int ; i := 0 ; while i < s->size() do ( (     if (i + 2 = s->size()) then (     OclFile["System.out"].print(s->at(i+1)) ; 
     OclFile["System.out"].print(s->at(i + 1+1)) ; 
     break ) else (     OclFile["System.out"].print(s->at(i+1)) ; 
     OclFile["System.out"].print(s->at(i + 1+1)) ; 
     OclFile["System.out"].print('-') ) )  ;     i := i+(2) ) ) else     if (k mod 2 /= 0) then (         var i : int ; i := 0 ; while i < s->size() do ( (     if (i + 2 = s->size() - 1) then (     OclFile["System.out"].print(s->at(i+1)) ; 
     OclFile["System.out"].print(s->at(i + 1+1)) ; 
     OclFile["System.out"].print(s->at(i + 2+1)) ; 
     break ) else (     OclFile["System.out"].print(s->at(i+1)) ; 
     OclFile["System.out"].print(s->at(i + 1+1)) ; 
     OclFile["System.out"].print('-') ) )  ;     i := i + 2 ) ) else skip ; ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String str=sc.next();
    for(int i=0 ; i<n ; i++){
      System.out.print(str.charAt(i));
      if(n % 2==0){
        if(i % 2==1 && i!=(n-1))System.out.print("-");
      }
      else if(i % 2==1 && i!=(n-2))System.out.print("-");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var str : String ; str := sc.getCurrent() ;
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(str->at(i+1)) ; 
     if (n mod 2 = 0) then (     if (i mod 2 = 1 & i /= (n - 1)) then     OclFile["System.out"].print("-") ; else skip ) else     if (i mod 2 = 1 & i /= (n - 2)) then     OclFile["System.out"].print("-") ; else skip ; )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),q ;
    long sum=0 ;
    int[] a=new int[n],x=new int[100001];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      x[a[i] ]++;
      sum+=(long)a[i];
    }
    q=sc.nextInt();
    int[] b=new int[q],c=new int[q],d=new int[q];
    for(int i=0 ; i<q ; i++){
      b[i]=sc.nextInt();
      c[i]=sc.nextInt();
      d[i]=c[i]-b[i];
      sum=sum+(long)(x[b[i] ]*d[i]);
      System.out.println(sum);
      x[c[i] ]+=x[b[i] ];
      x[b[i] ]=0 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ;
    var sum : long ; sum := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var x : Sequence(int) ; x := Integer.subrange(1,100001)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     x[a[i+1]+1] := x[a[i+1]+1] + 1 ; 
     sum := sum+(a[i+1]->oclAsType(long)) )  ;     i := i + 1 ) ; 
    q := sc.getCurrent()->toInteger() ; 
    var b : Sequence(int) ; b := Integer.subrange(1,q)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,q)->collect(0) ;
    var d : Sequence(int) ; d := Integer.subrange(1,q)->collect(0) ;
        var i : int ; i := 0 ; while i < q do ( (     b[i+1] := sc.getCurrent()->toInteger() ; 
     c[i+1] := sc.getCurrent()->toInteger() ; 
    d[i+1] := c[i+1] - b[i+1] ; 
    sum := sum + (x[b[i+1]+1] * d[i+1])->oclAsType(long) ; 
    OclFile["System.out"].println(sum) ; 
    x[c[i+1]+1] := x[c[i+1]+1]+(x[b[i+1]+1]) ; 
    x[b[i+1]+1] := 0 ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  public static void main(String hi[])throws Exception {
    BufferedReader infile=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(infile.readLine());
    int N=Integer.parseInt(st.nextToken());
    int[] arr=new int[N];
    st=new StringTokenizer(infile.readLine());
    for(int i=0 ; i<N ; i++)arr[i]=Integer.parseInt(st.nextToken());
    long res=0L ;
    for(int x : arr)res+=x ;
    int[] freq=new int[100001];
    for(int x : arr)freq[x]++;
    StringBuilder sb=new StringBuilder();
    int Q=Integer.parseInt(infile.readLine());
    while(Q-->0){
      st=new StringTokenizer(infile.readLine());
      int B=Integer.parseInt(st.nextToken());
      int C=Integer.parseInt(st.nextToken());
      long lost=(long)B*freq[B];
      long gain=(long)C*freq[B];
      res+=gain-lost ;
      freq[C]+=freq[B];
      freq[B]=0 ;
      sb.append(res+"\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( hi : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var infile : OclFile ; infile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(infile.readLine()) ;
    var N : int ; N := (st.next())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
    st := OclIterator.newOclIterator_String(infile.readLine()) ; 
        var i : int ; i := 0 ; while i < N do (     arr[i+1] := (st.next())->toInteger() ;  ;     i := i + 1 ) ; 
    var res : long ; res := 0L ;
    for (x : arr) do (     res := res+(x) ;  ) ; 
    var freq : Sequence(int) ; freq := Integer.subrange(1,100001)->collect(0) ;
    for (x : arr) do (     freq[x+1] := freq[x+1] + 1 ;  ) ; 
    var sb : String ; sb := StringLib.newString() ;
    var Q : int ; Q := (infile.readLine())->toInteger() ;
        while (Q > 0) do (        Q := Q - 1 ;     skip ; (     st := OclIterator.newOclIterator_String(infile.readLine()) ; 
     var B : int ; B := (st.next())->toInteger() ;
    var C : int ; C := (st.next())->toInteger() ;
    var lost : long ; lost := B->oclAsType(long) * freq[B+1] ;
    var gain : long ; gain := C->oclAsType(long) * freq[B+1] ;
    res := res+(gain - lost) ; 
    freq[C+1] := freq[C+1]+(freq[B+1]) ; 
    freq[B+1] := 0 ; 
    sb := sb + StringLib.newString(res + "\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    int n=sc.nextInt();
    long[] cnt=new long[100100];
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      cnt[a]++;
      sum+=a ;
    }
    PrintWriter pw=new PrintWriter(System.out);
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      int b=sc.nextInt();
      int c=sc.nextInt();
      sum-=b*cnt[b];
      sum+=c*cnt[b];
      pw.println(sum);
      cnt[c]+=cnt[b];
      cnt[b]=0 ;
    }
    pw.flush();
  }
  static class MyScanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),1<<15);
    StringTokenizer tokenizer ;
    String next(){
      try {
        while(tokenizer==null || ! tokenizer.hasMoreTokens()){
          tokenizer=new StringTokenizer(reader.readLine());
        }
      }
      catch(IOException ignored){
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var n : int ; n := sc.nextInt() ;
    var cnt : Sequence(long) ; cnt := Integer.subrange(1,100100)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.nextInt() ;
     cnt[a+1] := cnt[a+1] + 1 ; 
     sum := sum+(a) )  ;     i := i + 1 ) ; 
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var q : int ; q := sc.nextInt() ;
        var i : int ; i := 0 ; while i < q do ( (     var b : int ; b := sc.nextInt() ;
     var c : int ; c := sc.nextInt() ;
    sum := sum-(b * cnt[b+1]) ; 
    sum := sum+(c * cnt[b+1]) ; 
    skip ; 
    cnt[c+1] := cnt[c+1]+(cnt[b+1]) ; 
    cnt[b+1] := 0 ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class MyScanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (1*(2->pow(15)))->oclAsType(long));
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (ignored : IOException) do skip
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public final class Main {
  public static void main(String[] args){
    final Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    final int n=Integer.parseInt(in.nextLine());
    Map<Integer,Integer>freq=new HashMap<>();
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      int curr=in.nextInt();
      sum+=curr ;
      freq.merge(curr,1,Integer :: sum);
    }
    in.nextLine();
    final int q=Integer.parseInt(in.nextLine());
    for(int i=0 ; i<q ; i++){
      final int num=in.nextInt();
      final int val=in.nextInt();
      if(freq.containsKey(num)){
        int count=freq.remove(num);
        sum+=(long)count*(val-num);
        freq.merge(val,count,Integer :: sum);
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var n : int ; n := (in.nextLine())->toInteger() ;
    var freq : Map(int,int) ; freq := Map{} ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var curr : int ; curr := in.getCurrent()->toInteger() ;
     sum := sum+(curr) ; 
     freq := freq.merge(curr, 1, lambda _pars : OclAny in Integer.newInteger().sum(_pars)) )  ;     i := i + 1 ) ; 
    skip ; 
    var q : int ; q := (in.nextLine())->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var num : int ; num := in.getCurrent()->toInteger() ;
     var val : int ; val := in.getCurrent()->toInteger() ;
     if (freq->keys()->includes(num)) then (     var count : int ; count := freq->at(num) ;
     sum := sum+(count->oclAsType(long) * (val - num)) ; 
     freq := freq.merge(val, count, lambda _pars : OclAny in Integer.newInteger().sum(_pars)) ) else skip ; 
     OclFile["System.out"].println(sum) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static StringTokenizer st ;
  static BufferedReader br ;
  static PrintWriter out ;
  static int parent[];
  public static void main(String[] args)throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    int N=nextInt();
    int[] A=new int[100000+1];
    long sum=0 ;
    for(int x=0 ; x<N ; x++){
      int temp=nextInt();
      A[temp]++;
      sum+=temp ;
    }
    int Q=nextInt();
    for(int x=0 ; x<Q ; x++){
      int B=nextInt();
      int C=nextInt();
      sum+=C*A[B]-B*A[B];
      A[C]+=A[B];
      A[B]=0 ;
      System.out.println(sum);
    }
  }
  public static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public static long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  static String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine().trim());
    return st.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute st : OclIterator;
  static   attribute br : OclFile;
  static   attribute out : OclFile;
  static   attribute parent : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     var N : int ; N := nextInt() ;
    var A : Sequence(int) ; A := Integer.subrange(1,100000 + 1)->collect(0) ;
    var sum : long ; sum := 0 ;
        var x : int ; x := 0 ; while x < N do ( (     var temp : int ; temp := nextInt() ;
     A[temp+1] := A[temp+1] + 1 ; 
     sum := sum+(temp) )  ;     x := x + 1 ) ; 
    var Q : int ; Q := nextInt() ;
        var x : int ; x := 0 ; while x < Q do ( (     var B : int ; B := nextInt() ;
     var C : int ; C := nextInt() ;
    sum := sum+(C * A[B+1] - B * A[B+1]) ; 
    A[C+1] := A[C+1]+(A[B+1]) ; 
    A[B+1] := 0 ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     x := x + 1 ) ; 
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()->trim()) ; ; 
     return st.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1542 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    StringBuilder out=new StringBuilder();
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      int A=in.nextInt();
      int B=in.nextInt();
      boolean found=false ;
      if(A==1){
        found=((N-1)% B)==0 ;
      }
      else {
        long number=1 ;
        while(number<=N){
          if((N-number)% B==0){
            found=true ;
            break ;
          }
          number*=A ;
        }
      }
      out.append(found ? "Yes\n" : "No\n");
    }
    System.out.print(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1542 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : String ; out := StringLib.newString() ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var A : int ; A := in.getCurrent()->toInteger() ;
    var B : int ; B := in.getCurrent()->toInteger() ;
    var found : boolean ; found := false ;
    if (A = 1) then (     found := ((N - 1) mod B) = 0 ) else (     var number : long ; number := 1 ;
     while (number <= N) do (     if ((N - number) mod B = 0) then (     found := true ; 
     break ) else skip ; 
     number := number*(A) ) ) ;  
    out := out + StringLib.newString(if found then "Yes\n" else "No\n" endif) ; 
 )  ;     t := t + 1 ) ; 
    OclFile["System.out"].print(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    char[] ch=sc.next().toCharArray();
    String ans="" ;
    for(int i=0 ; i<a ; i++){
      if(i==b-1){
        ans+=Character.toLowerCase(ch[i]);
      }
      else {
        ans+=ch[i];
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := (sc.getCurrent())->toInteger() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    var ch : Sequence(String) ; ch := sc.getCurrent()->characters() ;
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < a do ( (     if (i = b - 1) then (     ans := ans+((ch[i+1] + "")->toLowerCase()) ) else (     ans := ans+(ch[i+1]) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    int num=998244353 ;
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    int n=Integer.parseInt(bf.readLine());
    long sum=0 ;
    for(int i=1 ; i<=n ; i++){
      sum+=(long)(i)*(long)((n-i+1));
    }
    for(int i=0 ; i<n-1 ; i++){
      StringTokenizer st=new StringTokenizer(bf.readLine());
      int v1=Integer.parseInt(st.nextToken());
      int v2=Integer.parseInt(st.nextToken());
      int min=Math.min(v1,v2);
      int max=Math.max(v1,v2);
      sum-=(long)(min)*(long)((n-max+1));
    }
    out.println(sum);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 998244353 ;
     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (bf.readLine())->toInteger() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     sum := sum+((i)->oclAsType(long) * ((n - i + 1))->oclAsType(long)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(bf.readLine()) ;
     var v1 : int ; v1 := (st.next())->toInteger() ;
    var v2 : int ; v2 := (st.next())->toInteger() ;
    var min : int ; min := Set{v1, v2}->min() ;
    var max : int ; max := Set{v1, v2}->max() ;
    sum := sum-((min)->oclAsType(long) * ((n - max + 1))->oclAsType(long)) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    exec();
  }
  static void exec(){
    PrintWriter out=new PrintWriter(System.out);
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int length=String.valueOf(n).length();
    if(length % 2==0){
      StringBuilder sb=new StringBuilder();
      for(int i=length-1 ; i>0 ; i--){
        if(i % 2==0){
          sb.append("0");
        }
        else {
          sb.append("9");
        }
      }
      out.print(sb);
    }
    else if(length==1){
      out.print(n);
    }
    else {
      int count=0 ;
      int base=1 ;
      for(int i=0 ; i<length-1 ; i++){
        base=base*10 ;
      }
      count=count+(n-base)+1 ;
      StringBuilder sb=new StringBuilder();
      for(int i=length-2 ; i>0 ; i--){
        if(i % 2==0){
          sb.append("0");
        }
        else {
          sb.append("9");
        }
      }
      count=count+Integer.parseInt(sb.toString());
      out.print(count);
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute exec() );
  static   operation exec() : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := (sc.getCurrent())->toInteger() ;
    var length : int ; length := ((n) + "")->size() ;
    if (length mod 2 = 0) then (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := length - 1 ; while i > 0 do ( (     if (i mod 2 = 0) then (     sb := sb + StringLib.newString("0") ) else (     sb := sb + StringLib.newString("9") ) )  ;     i := i - 1 ) ; 
     skip ) else     if (length = 1) then (     skip ) else (     var count : int ; count := 0 ;
     var base : int ; base := 1 ;
        var i : int ; i := 0 ; while i < length - 1 do ( (     base := base * 10 )  ;     i := i + 1 ) ; 
    count := count + (n - base) + 1 ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := length - 2 ; while i > 0 do ( (     if (i mod 2 = 0) then (     sb := sb + StringLib.newString("0") ) else (     sb := sb + StringLib.newString("9") ) )  ;     i := i - 1 ) ; 
    count := count + (sb+"")->toInteger() ; 
    skip ; 
 ) ;  ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    for(int xix=0 ; xix<test ; xix++){
      int n=sc.nextInt();
      int a=sc.nextInt();
      int b=sc.nextInt();
      long val=1 ;
      while(val<n && val % b!=n % b && a!=1){
        val*=a ;
      }
      if(val % b==n % b && val<=n){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
         var xix : int ; xix := 0 ; while xix < test do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var val : long ; val := 1 ;
    while (val < n & val mod b /= n mod b & a /= 1) do (     val := val*(a) ) ; 
    if (val mod b = n mod b & val <= n) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 )  ;     xix := xix + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final long mod=1000000007 ;
  static final long max=1001 ;
  static long nCr[][]=new long[1003][1003];
  static void preComputeCoeff(){
    for(int i=0 ; i<max ; i++){
      for(int j=0 ; j<=i ; j++){
        if(j==0 || j==i)nCr[i][j]=1 ;
        else nCr[i][j]=(nCr[i-1][j-1]+nCr[i-1][j])% mod ;
      }
    }
  }
  static long computeStringCount(int N){
    int n=N/2 ;
    long ans=0 ;
    for(int i=2 ; i<=n ; i+=2)ans=(ans+((nCr[n][i]*nCr[n][i/2])% mod))% mod ;
    return ans ;
  }
  public static void main(String[] args){
    preComputeCoeff();
    int N=3 ;
    System.out.println(computeStringCount(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute mod : long := 1000000007;
  static    attribute max : long := 1001;
  static   attribute nCr : long := Integer.subrange(1,1003)->collect(Integer.subrange(1,1003)->collect(0));
  static   operation preComputeCoeff() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < max do ( (         var j : int ; j := 0 ; while j <= i do ( (     if (j = 0 or j = i) then     nCr[i+1][j+1] := 1 ; else     nCr[i+1][j+1] := (nCr[i - 1+1][j - 1+1] + nCr[i - 1+1][j+1]) mod mod ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation computeStringCount( N : int) : long
  pre: true
  post: true
  activity: (     var n : int ; n := N / 2 ;
     var ans : long ; ans := 0 ;
         var i : int ; i := 2 ; while i <= n do (     ans := (ans + ((nCr[n+1][i+1] * nCr[n+1][i / 2+1]) mod mod)) mod mod ;  ;     i := i+(2) ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute preComputeCoeff() ; 
     var N : int ; N := 3 ;
     OclFile["System.out"].println(computeStringCount(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int[] arr=new int[33];
  static void balTernary(int ter){
    int carry=0,base=10 ;
    int i=32 ;
    while(ter>0){
      int rem=ter % base ;
      rem=rem+carry ;
      if(rem==0){
        arr[i--]=0 ;
        carry=0 ;
      }
      else if(rem==1){
        arr[i--]=1 ;
        carry=0 ;
      }
      else if(rem==2){
        arr[i--]=-1 ;
        carry=1 ;
      }
      else if(rem==3){
        arr[i--]=0 ;
        carry=1 ;
      }
      ter=(int)(ter/base);
    }
    if(carry==1)arr[i]=1 ;
  }
  static int ternary(int number){
    int ans=0,rem=1,base=1 ;
    while(number>0){
      rem=number % 3 ;
      ans=ans+rem*base ;
      number=(int)(number/3);
      base=base*10 ;
    }
    return ans ;
  }
  public static void main(String args[]){
    int number=3056 ;
    int ter=ternary(number);
    Arrays.fill(arr,0);
    balTernary(ter);
    int i=0 ;
    while(arr[i]==0){
      i++;
    }
    for(int j=i ; j<=32 ; j++){
      if(arr[j]==-1)System.out.print('Z');
      else System.out.print(arr[j]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute arr : Sequence(int) := Integer.subrange(1,33)->collect(0);
  static   operation balTernary( ter : int) : void
  pre: true
  post: true
  activity: (     var carry : int ; carry := 0 ;
    var base : int ; base := 10 ;
     var i : int ; i := 32 ;
     while (ter > 0) do (     var rem : int ; rem := ter mod base ;
     rem := rem + carry ; 
     if (rem = 0) then (      arr[i+1] := 0  ; i := i - 1 ; 
     carry := 0 ) else     if (rem = 1) then (      arr[i+1] := 1  ; i := i - 1 ; 
     carry := 0 ) else     if (rem = 2) then (      arr[i+1] := -1  ; i := i - 1 ; 
     carry := 1 ) else     if (rem = 3) then (      arr[i+1] := 0  ; i := i - 1 ; 
     carry := 1 ) else skip ; ;  ;  ;  
     ter := (ter / base)->oclAsType(int) ) ; 
     if (carry = 1) then     arr[i+1] := 1 ; else skip );
  static   operation ternary( number : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
    var rem : int ; rem := 1 ;
    var base : int ; base := 1 ;
     while (number > 0) do (     rem := number mod 3 ; 
     ans := ans + rem * base ; 
     number := (number / 3)->oclAsType(int) ; 
     base := base * 10 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var number : int ; number := 3056 ;
     var ter : int ; ter := ternary(number) ;
    arr := arr->collect(0) ; 
    execute balTernary(ter) ; 
    var i : int ; i := 0 ;
    while (arr[i+1] = 0) do (     i := i + 1 ) ; 
        var j : int ; j := i ; while j <= 32 do ( (     if (arr[j+1] = -1) then     OclFile["System.out"].print('Z') ; else     OclFile["System.out"].print(arr[j+1]) ; )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Translation {
  static Scanner sr=new Scanner(System.in);
  public static void main(String args[]){
    String s1=sr.nextLine();
    String s2=sr.nextLine();
    if(s1.length()!=s2.length()){
      System.out.println("NO");
    }
    else {
      s1=new StringBuilder(s1).reverse().toString();
      ;
      if(s1.equals(s2)){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Translation {
  static   attribute sr : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := sr.nextLine() ;
     var s2 : String ; s2 := sr.nextLine() ;
     if (s1->size() /= s2->size()) then (     OclFile["System.out"].println("NO") ) else (     s1 := StringLib.newString(s1)->reverse()+"" ; 
     if (s1 = s2) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Codesolver {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String st,st1 ;
    st=sc.nextLine();
    st1=sc.nextLine();
    int len=st.length();
    int len1=st1.length();
    int as=0 ;
    if(len==len1){
      for(int i=0 ; i<len ; i++){
        if(st.charAt(i)==st1.charAt(len-i-1)){
          as++;
        }
        else break ;
      }
      if(as!=len){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
    }
    else {
      System.out.println("NO");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codesolver {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var st : String ;
    var st1 : String ;
    st := sc.nextLine() ; 
    st1 := sc.nextLine() ; 
    var len : int ; len := st->size() ;
    var len1 : int ; len1 := st1->size() ;
    var as : int ; as := 0 ;
    if (len = len1) then (         var i : int ; i := 0 ; while i < len do ( (     if (st->at(i+1) = st1->at((len)->char2byte() - i - 1+1)) then (     as := as + 1 ) else     break )  ;     i := i + 1 ) ; 
     if (as /= len) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ) else (     OclFile["System.out"].println("NO") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class code {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String t=sc.next();
    StringBuilder sb=new StringBuilder(s);
    StringBuilder rev=sb.reverse();
    String m=rev.toString();
    if(m.equals(t)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var sb : String ; sb := StringLib.newString(s) ;
    var rev : String ; rev := sb->reverse() ;
    var m : String ; m := rev+"" ;
    if (m = t) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CodeForces {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    try {
      String word=scan.next();
      String wordCheck=scan.next();
      String reverse_word="" ;
      for(int i=wordCheck.length()-1 ; i>=0 ; i--){
        reverse_word+=word.charAt(i);
      }
      if(reverse_word.equals(wordCheck))System.out.println("YES");
      else System.out.println("NO");
    }
    catch(Exception e){
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     try (     var word : String ; word := scan.getCurrent() ;
     var wordCheck : String ; wordCheck := scan.getCurrent() ;
    var reverse_word : String ; reverse_word := "" ;
        var i : int ; i := wordCheck->size() - 1 ; while i >= 0 do ( (     reverse_word := reverse_word+(word->at(i+1)) )  ;     i := i - 1 ) ; 
    if (reverse_word = wordCheck) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 )   catch (e : ProgramException) do (     OclFile["System.out"].println("NO") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Test3 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String st=sc.next();
    String st1=sc.next();
    String ts=new StringBuffer(st).reverse().toString();
    if(st1.equals(ts)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var st : String ; st := sc.getCurrent() ;
    var st1 : String ; st1 := sc.getCurrent() ;
    var ts : String ; ts := StringLib.newString(st)->reverse()+"" ;
    if (st1 = ts) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String replaceSpace(String str){
    String s="" ;
    for(int i=0 ; i<str.length(); ++i){
      if(str.charAt(i)==' ')s+='-' ;
      else s+=str.charAt(i);
    }
    return s ;
  }
  public static void main(String[] args){
    String str="A computer science portal for geeks" ;
    System.out.println(replaceSpace(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation replaceSpace( str : String) : String
  pre: true
  post: true
  activity: (     var s : String ; s := "" ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = ' ') then     s := s+('-') ; else     s := s+(str->at(i+1)) ; )  ;     i := i + 1 ) ; 
     return s );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "A computer science portal for geeks" ;
     OclFile["System.out"].println(replaceSpace(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maxCount(int A[],int N,int K){
    int maximum=0 ;
    int i=0,j=0 ;
    int start=0 ;
    int end=0 ;
    Arrays.sort(A);
    for(i=0 ; i<N ; i++){
      while(j<N && A[j]<=A[i]+K)j++;
      if(maximum<(j-i)){
        maximum=(j-i);
        start=i ;
        end=j ;
      }
    }
    return maximum ;
  }
  public static void main(String[] args){
    int A[]={
      1,26,17,12,15,2 };
      int N=A.length ;
      int K=5 ;
      System.out.println(maxCount(A,N,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxCount( A : Sequence(int), N : int, K : int) : int
  pre: true
  post: true
  activity: (     var maximum : int ; maximum := 0 ;
     var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    var start : int ; start := 0 ;
    var end : int ; end := 0 ;
    A := A->sort() ; 
        i := 0 ; while i < N do ( (     while (j < N & A[j+1] <= A[i+1] + K) do     j := j + 1 ; ; 
     if (maximum < (j - i)) then (     maximum := (j - i) ; 
     start := i ; 
     end := j ) else skip )  ;     i := i + 1 ) ; 
    return maximum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{1,26,17,12,15,2} ;
     var N : int ; N := A->size() ;
     var K : int ; K := 5 ;
     OclFile["System.out"].println(maxCount(A, N, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    B solver=new B();
    solver.solve(1,in,out);
    out.close();
  }
  static class B {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=Integer.parseInt(in.next());
      int ans=0 ;
      for(int i=1 ; i<=n ; i++){
        if(Integer.toString(i).length()% 2!=0)++ans ;
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : B ; solver := B.newB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class B {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (in.getCurrent())->toInteger() ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     if (((i) + "")->size() mod 2 /= 0) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Map.Entry ;
class Main {
  static int mod=(int)(Math.pow(10,9)+7);
  static List<ArrayList<Integer>>list=new ArrayList<ArrayList<Integer>>();
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long ans=0 ;
    long sum=0 ;
    for(int i=1 ; i<N ; i++){
      long a=sc.nextInt();
      long b=sc.nextInt();
      if(a>b){
        long t=b ;
        b=a ;
        a=t ;
      }
      sum=sum+i ;
      ans=ans+sum ;
      ans=ans-a*(N-b+1);
    }
    sum=sum+N ;
    ans=ans+sum ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := (10->pow(9) + 7)->oclAsType(int);
  static   attribute list : Sequence(Sequence(int)) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var ans : long ; ans := 0 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 1 ; while i < N do ( (     var a : long ; a := sc.getCurrent()->toInteger() ;
     var b : long ; b := sc.getCurrent()->toInteger() ;
    if (a > b) then (     var t : long ; t := b ;
     b := a ; 
     a := t ) else skip ; 
    sum := sum + i ; 
    ans := ans + sum ; 
    ans := ans - a * (N - b + 1) ; 
 )  ;     i := i + 1 ) ; 
    sum := sum + N ; 
    ans := ans + sum ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      sc.nextLine();
      char[][] ch=new char[n][n];
      for(int i=0 ; i<n ; i++){
        ch[i]=sc.nextLine().toCharArray();
      }
      int x1=0,y1=0,x2=0,y2=0 ;
      int key=0 ;
      for(int i=0 ; i<n ; i++){
        if(key==2)break ;
        for(int j=0 ; j<n ; j++){
          if(key==2)break ;
          if(ch[i][j]=='*'){
            if(key==0){
              key=1 ;
              x1=i ;
              y1=j ;
            }
            else {
              key=2 ;
              x2=i ;
              y2=j ;
            }
          }
        }
      }
      if(x1==x2){
        ch[x1>0 ? x1-1 : x1+1][y1]='*' ;
        ch[x1>0 ? x1-1 : x1+1][y2]='*' ;
      }
      else if(y1==y2){
        ch[x1][y1>0 ? y1-1 : y1+1]='*' ;
        ch[x2][y1>0 ? y1-1 : y1+1]='*' ;
      }
      else {
        ch[x1][y2]='*' ;
        ch[x2][y1]='*' ;
      }
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          System.out.print(ch[i][j]);
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     skip ; 
    var ch : Sequence(Sequence(String)) ; ch := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     ch[i+1] := sc.nextLine()->characters() )  ;     i := i + 1 ) ; 
    var x1 : int ; x1 := 0 ;
    var y1 : int ; y1 := 0 ;
    var x2 : int ; x2 := 0 ;
    var y2 : int ; y2 := 0 ;
    var key : int ; key := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (key = 2) then     break else skip ; 
         var j : int ; j := 0 ; while j < n do ( (     if (key = 2) then     break else skip ; 
     if (ch[i+1][j+1] = '*') then (     if (key = 0) then (     key := 1 ; 
     x1 := i ; 
     y1 := j ) else (     key := 2 ; 
     x2 := i ; 
     y2 := j ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (x1 = x2) then (     ch[if x1 > 0 then x1 - 1 else x1 + 1 endif+1][y1+1] := '*' ; 
     ch[if x1 > 0 then x1 - 1 else x1 + 1 endif+1][y2+1] := '*' ) else     if (y1 = y2) then (     ch[x1+1][if y1 > 0 then y1 - 1 else y1 + 1 endif+1] := '*' ; 
     ch[x2+1][if y1 > 0 then y1 - 1 else y1 + 1 endif+1] := '*' ) else (     ch[x1+1][y2+1] := '*' ; 
     ch[x2+1][y1+1] := '*' ) ;  ;  
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     OclFile["System.out"].print(ch[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      sc.nextLine();
      char[][] ch=new char[n][n];
      for(int i=0 ; i<n ; i++){
        ch[i]=sc.nextLine().toCharArray();
      }
      int x1=0,y1=0,x2=0,y2=0 ;
      int key=0 ;
      for(int i=0 ; i<n ; i++){
        if(key==2)break ;
        for(int j=0 ; j<n ; j++){
          if(key==2)break ;
          if(ch[i][j]=='*'){
            if(key==0){
              key=1 ;
              x1=i ;
              y1=j ;
            }
            else {
              key=2 ;
              x2=i ;
              y2=j ;
            }
          }
        }
      }
      if(x1==x2){
        ch[x1>0 ? x1-1 : x1+1][y1]='*' ;
        ch[x1>0 ? x1-1 : x1+1][y2]='*' ;
      }
      else if(y1==y2){
        ch[x1][y1>0 ? y1-1 : y1+1]='*' ;
        ch[x2][y1>0 ? y1-1 : y1+1]='*' ;
      }
      else {
        ch[x1][y2]='*' ;
        ch[x2][y1]='*' ;
      }
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          System.out.print(ch[i][j]);
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     skip ; 
    var ch : Sequence(Sequence(String)) ; ch := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     ch[i+1] := sc.nextLine()->characters() )  ;     i := i + 1 ) ; 
    var x1 : int ; x1 := 0 ;
    var y1 : int ; y1 := 0 ;
    var x2 : int ; x2 := 0 ;
    var y2 : int ; y2 := 0 ;
    var key : int ; key := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (key = 2) then     break else skip ; 
         var j : int ; j := 0 ; while j < n do ( (     if (key = 2) then     break else skip ; 
     if (ch[i+1][j+1] = '*') then (     if (key = 0) then (     key := 1 ; 
     x1 := i ; 
     y1 := j ) else (     key := 2 ; 
     x2 := i ; 
     y2 := j ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (x1 = x2) then (     ch[if x1 > 0 then x1 - 1 else x1 + 1 endif+1][y1+1] := '*' ; 
     ch[if x1 > 0 then x1 - 1 else x1 + 1 endif+1][y2+1] := '*' ) else     if (y1 = y2) then (     ch[x1+1][if y1 > 0 then y1 - 1 else y1 + 1 endif+1] := '*' ; 
     ch[x2+1][if y1 > 0 then y1 - 1 else y1 + 1 endif+1] := '*' ) else (     ch[x1+1][y2+1] := '*' ; 
     ch[x2+1][y1+1] := '*' ) ;  ;  
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     OclFile["System.out"].print(ch[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maxSubArraySum(int a[],int size){
    int max_so_far=Integer.MIN_VALUE,max_ending_here=0 ;
    for(int i=0 ; i<size ; i++){
      max_ending_here=max_ending_here+a[i];
      if(max_so_far<max_ending_here)max_so_far=max_ending_here ;
      if(max_ending_here<0)max_ending_here=0 ;
    }
    return max_so_far ;
  }
  static double minimizedSum(int a[],int n,int K){
    int sum=maxSubArraySum(a,n);
    double totalSum=0 ;
    for(int i=0 ; i<n ; i++)totalSum+=a[i];
    if(sum<0)return totalSum ;
    totalSum=totalSum-sum+(double)sum/(double)K ;
    return totalSum ;
  }
  public static void main(String[] args){
    int a[]={
      1,-2,3 };
      int n=a.length ;
      int K=2 ;
      System.out.println(minimizedSum(a,n,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSubArraySum( a : Sequence(int), size : int) : int
  pre: true
  post: true
  activity: (     var max_so_far : int ; max_so_far := -2147483648 ;
    var max_ending_here : int ; max_ending_here := 0 ;
         var i : int ; i := 0 ; while i < size do ( (     max_ending_here := max_ending_here + a[i+1] ; 
     if (max_so_far < max_ending_here) then     max_so_far := max_ending_here ; else skip ; 
     if (max_ending_here < 0) then     max_ending_here := 0 ; else skip )  ;     i := i + 1 ) ; 
     return max_so_far );
  static   operation minimizedSum( a : Sequence(int), n : int, K : int) : double
  pre: true
  post: true
  activity: (     var sum : int ; sum := maxSubArraySum(a, n) ;
     var totalSum : double ; totalSum := 0 ;
        var i : int ; i := 0 ; while i < n do (     totalSum := totalSum+(a[i+1]) ;  ;     i := i + 1 ) ; 
    if (sum < 0) then     return totalSum else skip ; 
    totalSum := totalSum - sum + sum->oclAsType(double) / K->oclAsType(double) ; 
    return totalSum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,-2,3} ;
     var n : int ; n := a->size() ;
     var K : int ; K := 2 ;
     OclFile["System.out"].println(minimizedSum(a, n, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  void run(){
    for(; ; ){
      int a=sc.nextInt();
      int b=sc.nextInt();
      if((a | b)==0){
        break ;
      }
      int memo[]=new int[b];
      int first=a ;
      int count=0 ;
      int v1=0 ;
      int vv=0 ;
      for(; ; ){
        count++;
        if(memo[first]!=0){
          v1=memo[first]-1 ;
          vv=count-memo[first];
          if(first==0){
            vv=0 ;
          }
          break ;
        }
        memo[first]=count ;
        first=first*10 ;
        int v=first/b ;
        int v2=first % b ;
        first=v2 ;
      }
      System.out.println(v1+" "+vv);
    }
  }
  Main(){
    sc=new Scanner(System.in);
    try {
      sc=new Scanner(new File(""));
    }
    catch(FileNotFoundException e){
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(a,b)) = 0) then (     break ) else skip ; 
    var memo : Sequence(int) ; memo := Integer.subrange(1,b)->collect(0) ;
    var first : int ; first := a ;
    var count : int ; count := 0 ;
    var v1 : int ; v1 := 0 ;
    var vv : int ; vv := 0 ;
      while true do ( (     count := count + 1 ; 
     if (memo[first+1] /= 0) then (     v1 := memo[first+1] - 1 ; 
     vv := count - memo[first+1] ; 
     if (first = 0) then (     vv := 0 ) else skip ; 
     break ) else skip ; 
    memo[first+1] := count ; 
    first := first * 10 ; 
    var v : int ; v := first / b ;
    var v2 : int ; v2 := first mod b ;
    first := v2 ; 
 )  ) ; 
    OclFile["System.out"].println(v1 + " " + vv) ; 
 )  ) );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     try (     sc := OclFile.newOclFile_Read(OclFile("")) )   catch (e : FileNotFoundException) do skip
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int x=sc.nextInt(),y=sc.nextInt();
      if((x | y)==0)break ;
      int[] a=new int[y];
      Arrays.fill(a,-1);
      a[x]=0 ;
      int p=0,q=0,r=1 ;
      for(; ; ){
        x=(x*10)% y ;
        if(x==0){
          p=r ;
          break ;
        }
        if(a[x]==-1){
          a[x]=r++;
        }
        else {
          p=a[x];
          q=r-a[x];
          break ;
        }
      }
      System.out.println(p+" "+q);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseOr(x,y)) = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,y)->collect(0) ;
    a := a->collect(-1) ; 
    a[x+1] := 0 ; 
    var p : int ; p := 0 ;
    var q : int ; q := 0 ;
    var r : int ; r := 1 ;
      while true do ( (     x := (x * 10) mod y ; 
     if (x = 0) then (     p := r ; 
     break ) else skip ; 
     if (a[x+1] = -1) then (      a[x+1] := r  ; r := r + 1 ) else (     p := a[x+1] ; 
     q := r - a[x+1] ; 
     break ) )  ) ; 
    OclFile["System.out"].println(p + " " + q) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int x=sc.nextInt();
      int y=sc.nextInt();
      if(x==0 && y==0)break ;
      int[] appear=new int[1000001];
      Arrays.fill(appear,-1);
      int a=0,b=0 ;
      for(int i=0 ; ; i++){
        x=x % y ;
        if(appear[x]!=-1){
          a=appear[x];
          b=i-appear[x];
          if(x==0)b=0 ;
          break ;
        }
        else {
          appear[x]=i ;
        }
        x*=10 ;
      }
      System.out.println(a+" "+b);
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    if (x = 0 & y = 0) then     break else skip ; 
    var appear : Sequence(int) ; appear := Integer.subrange(1,1000001)->collect(0) ;
    appear := appear->collect(-1) ; 
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
        var i : int ; i := 0 ; while true do ( (     x := x mod y ; 
     if (appear[x+1] /= -1) then (     a := appear[x+1] ; 
     b := i - appear[x+1] ; 
     if (x = 0) then     b := 0 ; else skip ; 
     break ) else (     appear[x+1] := i ) ;  
     x := x*(10) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a + " " + b) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    Scanner stdIn=new Scanner(System.in);
    while(true){
      int m=stdIn.nextInt();
      int n=stdIn.nextInt();
      if(m==0 && n==0)return ;
      int p=m ;
      int s=0 ;
      int t=0 ;
      int tmpP=m ;
      int cnt=0 ;
      while(true){
        cnt++;
        m=m*10 % n ;
        p=(p*10 % n)*10 % n ;
        if(m==p){
          break ;
        }
      }
      if(p!=0){
        p=tmpP % n ;
        s=1 ;
        while(m!=p){
          s++;
          m=m*10 % n ;
          p=p*10 % n ;
        }
        p=p*10 % n ;
        t=s ;
        while(m!=p){
          t++;
          p=p*10 % n ;
        }
      }
      if(s==0 && t==0){
        System.out.println(cnt+" "+t);
      }
      else System.out.println((s-1)+" "+(t-s+1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var m : int ; m := stdIn.getCurrent()->toInteger() ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    if (m = 0 & n = 0) then     return else skip ; 
    var p : int ; p := m ;
    var s : int ; s := 0 ;
    var t : int ; t := 0 ;
    var tmpP : int ; tmpP := m ;
    var cnt : int ; cnt := 0 ;
    while (true) do (     cnt := cnt + 1 ; 
     m := m * 10 mod n ; 
     p := (p * 10 mod n) * 10 mod n ; 
     if (m = p) then (     break ) else skip ) ; 
    if (p /= 0) then (     p := tmpP mod n ; 
     s := 1 ; 
    while (m /= p) do (     s := s + 1 ; 
     m := m * 10 mod n ; 
     p := p * 10 mod n ) ; 
    p := p * 10 mod n ; 
    t := s ; 
    while (m /= p) do (     t := t + 1 ; 
     p := p * 10 mod n ) ; 
 ) else skip ; 
    if (s = 0 & t = 0) then (     OclFile["System.out"].println(cnt + " " + t) ) else     OclFile["System.out"].println((s - 1) + " " + (t - s + 1)) ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void noOfMoves(int arr[],int n){
    int cnt=0 ;
    int maxCnt=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==1){
        cnt++;
      }
      else {
        if(cnt!=0){
          maxCnt=Math.max(maxCnt,cnt);
          cnt=0 ;
        }
      }
    }
    System.out.print(maxCnt+"\n");
  }
  public static void main(String[] args){
    int arr[]={
      0,1,1,1,1,0,0,1,1,0,0,1 };
      int N=arr.length ;
      noOfMoves(arr,N);
      int arr1[]={
        1,0,1,0,1,0,1,0 };
        N=arr1.length ;
        noOfMoves(arr1,N);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation noOfMoves( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var maxCnt : int ; maxCnt := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 1) then (     cnt := cnt + 1 ) else (     if (cnt /= 0) then (     maxCnt := Set{maxCnt, cnt}->max() ; 
     cnt := 0 ) else skip ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(maxCnt + "\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,1,1,1,1,0,0,1,1,0,0,1} ;
     var N : int ; N := arr->size() ;
    execute noOfMoves(arr, N) ; 
    var arr1 : Sequence(int) ; arr1 := Sequence{1,0,1,0,1,0,1,0} ;
    N := arr1->size() ; 
    execute noOfMoves(arr1, N) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minChanges(char[] str,int n){
    int count=0,zeros=0,ones=0 ;
    if(str[0]!='1'){
      count++;
      ones++;
    }
    for(int i=1 ; i<n ; i++){
      if(str[i]=='0')zeros++;
      else ones++;
      if(zeros>ones){
        zeros--;
        ones++;
        count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    char[] str="0000".toCharArray();
    int n=str.length ;
    System.out.print(minChanges(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minChanges( str : Sequence(String), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
    var zeros : int ; zeros := 0 ;
    var ones : int ; ones := 0 ;
     if (str[0+1] /= '1') then (     count := count + 1 ; 
     ones := ones + 1 ) else skip ; 
         var i : int ; i := 1 ; while i < n do ( (     if (str[i+1] = '0') then     zeros := zeros + 1 else     ones := ones + 1 ; ;  
     if (zeros > ones) then (     zeros := zeros - 1 ; 
     ones := ones + 1 ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := "0000"->characters() ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].print(minChanges(str, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.util.stream.IntStream ;
class Main {
  public static void main(String[] args){
    OriginScanner os=new OriginScanner();
    PrintWriter pw=new PrintWriter(System.out);
    int n=os.nextInt();
    long count=IntStream.rangeClosed(1,n).filter(i->String.valueOf(i).length()% 2==1).count();
    pw.println(count);
    pw.close();
  }
  static class OriginScanner {
    StringTokenizer token ;
    BufferedReader br ;
    public OriginScanner(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String nextLine(){
      String str=null ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        System.out.println(e);
      }
      return str ;
    }
    String next(){
      while(token==null || ! token.hasMoreElements()){
        token=new StringTokenizer(nextLine());
      }
      return token.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var os : OriginScanner ; os := OriginScanner.newOriginScanner() ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := os.nextInt() ;
    var count : long ; count := Integer.subrange(1, n)->select( _x1 | (lambda i : OclAny in ((i) + "")->size() mod 2 = 1)->apply(_x1) )->size() ;
    skip ; 
    skip ; 
 );
  static class OriginScanner {
   attribute token : OclIterator;
   attribute br : OclFile;
   static operation newOriginScanner() : OriginScanner
  pre: true
  post: true
  activity:
  ( var self : OriginScanner ;
    self := createOriginScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := null ;
     try (     str := br.readLine() )   catch (e : IOException) do (     OclFile["System.out"].println(e) )
     return str );
   operation next() : String
  pre: true
  post: true
  activity: (     while (token = null or not(token.hasNext())) do (     token := OclIterator.newOclIterator_String(nextLine()) ) ; 
     return token.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Stack ;
public class Main {
  static Scanner input=new Scanner(System.in);
  private static void solve(){
    int n=input.nextInt();
    int[] p=arrayInput(n);
    input.close();
    Stack<Integer>stack=new Stack<>();
    char[] ans=new char[n*2];
    int indexAns=0 ;
    int indexStack=0 ;
    for(int i=0 ; i<n ; i++){
      while(stack.isEmpty()|| stack.peek()<p[i]){
        ans[indexAns++]='(' ;
        stack.push(++indexStack);
      }
      if(stack.peek()!=p[i]){
        System.out.println(":(");
        return ;
      }
      stack.pop();
      ans[indexAns++]=')' ;
    }
    if(stack.size()>=1){
      System.out.println(":(");
      return ;
    }
    else {
      System.out.println(ans);
    }
  }
  public static void main(String[] args){
    solve();
  }
  private static int[] arrayInput(int n){
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=input.nextInt();
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute input : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := input.getCurrent()->toInteger() ;
     var p : Sequence(int) ; p := arrayInput(n) ;
    skip ; 
    var stack : Sequence(int) ; stack := Sequence{} ;
    var ans : Sequence(String) ; ans := Integer.subrange(1,n * 2)->collect(0) ;
    var indexAns : int ; indexAns := 0 ;
    var indexStack : int ; indexStack := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     while (stack->isEmpty() or stack->min() < p[i+1]) do (      ans[indexAns+1] := '('  ; indexAns := indexAns + 1 ; 
     stack := stack->append((indexStack + 1)) ) ; 
     if (stack->min() /= p[i+1]) then (     OclFile["System.out"].println(":(") ; 
     return ) else skip ; 
     stack := stack->front() ; 
      ans[indexAns+1] := ')'  ; indexAns := indexAns + 1 )  ;     i := i + 1 ) ; 
    if (stack->size() >= 1) then (     OclFile["System.out"].println(":(") ; 
     return ) else (     OclFile["System.out"].println(ans) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation arrayInput( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := input.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] arg){
    Scanner in=new Scanner(System.in).useDelimiter("(\\s|,)+");
    int case_=0 ;
    while(in.hasNext()){
      int w=in.nextInt();
      if(w!=0){
        System.out.print("Case ");
        System.out.print(++case_);
        System.out.println(":");
        int[] pack=new int[w+1];
        int n=in.nextInt();
        int maxNum=0 ;
        for(int j=0 ; j<n ; j++){
          int p=in.nextInt();
          int pw=in.nextInt();
          for(int i=w-pw ; i>=0 ; i--){
            pack[i+pw]=Math.max(pack[i+pw],pack[i]+p);
            if(pack[maxNum]<=pack[i+pw]){
              maxNum=i+pw ;
            }
          }
        }
        System.out.println(pack[maxNum]);
        System.out.println(maxNum);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]).useDelimiter("(\\s|,)+") ;
     var case_ : int ; case_ := 0 ;
     while (in.hasNext()) do (     var w : int ; w := in.getCurrent()->toInteger() ;
     if (w /= 0) then (     OclFile["System.out"].print("Case ") ; 
     OclFile["System.out"].print((case_ + 1)) ; 
    OclFile["System.out"].println(":") ; 
    var pack : Sequence(int) ; pack := Integer.subrange(1,w + 1)->collect(0) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var maxNum : int ; maxNum := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     var p : int ; p := in.getCurrent()->toInteger() ;
     var pw : int ; pw := in.getCurrent()->toInteger() ;
         var i : int ; i := w - pw ; while i >= 0 do ( (     pack[i + pw+1] := Set{pack[i + pw+1], pack[i+1] + p}->max() ; 
     if (pack[maxNum+1] <= pack[i + pw+1]) then (     maxNum := i + pw ) else skip )  ;     i := i - 1 ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(pack[maxNum+1]) ; 
    OclFile["System.out"].println(maxNum) ; 
 ) else skip ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int gcd(int a,int b){
    if(a==0 || b==0)return 0 ;
    if(a==b)return a ;
    if(a>b)return gcd(a-b,b);
    return gcd(a,b-a);
  }
  static int squarearea(int l,int b){
    if(l<0 || b<0)return-1 ;
    int n=(l*b)/gcd(l,b);
    return n*n ;
  }
  public static void main(String[] args){
    int l=6,b=4 ;
    System.out.println(squarearea(l,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0 or b = 0) then     return 0 else skip ; 
     if (a = b) then     return a else skip ; 
     if (a > b) then     return gcd(a - b, b) else skip ; 
     return gcd(a, b - a) );
  static   operation squarearea( l : int, b : int) : int
  pre: true
  post: true
  activity: (     if (l < 0 or b < 0) then     return -1 else skip ; 
     var n : int ; n := (l * b) / gcd(l, b) ;
     return n * n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 6 ;
    var b : int ; b := 4 ;
     OclFile["System.out"].println(squarearea(l, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MOD=1000000007 ;
  static int totalSubSets(int n,int l,int r){
    int zero=(int)Math.floor((double)r/3)-(int)Math.ceil((double)l/3)+1 ;
    int one=(int)Math.floor((double)(r-1)/3)-(int)Math.ceil((double)(l-1)/3)+1 ;
    int two=(int)Math.floor((double)(r-2)/3)-(int)Math.ceil((double)(l-2)/3)+1 ;
    int[][] dp=new int[n][3];
    dp[0][0]=zero ;
    dp[0][1]=one ;
    dp[0][2]=two ;
    for(int i=1 ; i<n ; ++i){
      dp[i][0]=((dp[i-1][0]*zero)+(dp[i-1][1]*two)+(dp[i-1][2]*one))% MOD ;
      dp[i][1]=((dp[i-1][0]*one)+(dp[i-1][1]*zero)+(dp[i-1][2]*two))% MOD ;
      dp[i][2]=((dp[i-1][0]*two)+(dp[i-1][1]*one)+(dp[i-1][2]*zero))% MOD ;
    }
    return dp[n-1][0];
  }
  public static void main(String[] args){
    int n=5 ;
    int l=10 ;
    int r=100 ;
    System.out.println(totalSubSets(n,l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MOD : int := 1000000007;
  static   operation totalSubSets( n : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     var zero : int ; zero := (r->oclAsType(double) / 3)->floor()->oclAsType(int) - (l->oclAsType(double) / 3)->ceil()->oclAsType(int) + 1 ;
     var one : int ; one := ((r - 1)->oclAsType(double) / 3)->floor()->oclAsType(int) - ((l - 1)->oclAsType(double) / 3)->ceil()->oclAsType(int) + 1 ;
    var two : int ; two := ((r - 2)->oclAsType(double) / 3)->floor()->oclAsType(int) - ((l - 2)->oclAsType(double) / 3)->ceil()->oclAsType(int) + 1 ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(0)) ;
    dp[0+1][0+1] := zero ; 
    dp[0+1][1+1] := one ; 
    dp[0+1][2+1] := two ; 
        var i : int ; i := 1 ; while i < n do ( (     dp[i+1][0+1] := ((dp[i - 1+1][0+1] * zero) + (dp[i - 1+1][1+1] * two) + (dp[i - 1+1][2+1] * one)) mod MOD ; 
     dp[i+1][1+1] := ((dp[i - 1+1][0+1] * one) + (dp[i - 1+1][1+1] * zero) + (dp[i - 1+1][2+1] * two)) mod MOD ; 
     dp[i+1][2+1] := ((dp[i - 1+1][0+1] * two) + (dp[i - 1+1][1+1] * one) + (dp[i - 1+1][2+1] * zero)) mod MOD )  ;     i := i + 1 ) ; 
    return dp[n - 1+1][0+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var l : int ; l := 10 ;
     var r : int ; r := 100 ;
     OclFile["System.out"].println(totalSubSets(n, l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findDimen(int H,int A){
    if(H*H<4*A){
      System.out.println("Not Possible");
      return ;
    }
    double apb=Math.sqrt(H*H+4*A);
    double asb=Math.sqrt(H*H-4*A);
    System.out.println("P="+Math.round(((apb-asb)/2.0)*100.0)/100.0);
    System.out.print("B="+Math.round(((apb+asb)/2.0)*100.0)/100.0);
  }
  public static void main(String[] args){
    int H=5 ;
    int A=6 ;
    findDimen(H,A);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findDimen( H : int, A : int) : void
  pre: true
  post: true
  activity: (     if (H * H < 4 * A) then (     OclFile["System.out"].println("Not Possible") ; 
     return ) else skip ; 
     var apb : double ; apb := (H * H + 4 * A)->sqrt() ;
    var asb : double ; asb := (H * H - 4 * A)->sqrt() ;
    OclFile["System.out"].println("P=" + (((apb - asb) / 2.0) * 100.0)->round() / 100.0) ; 
    OclFile["System.out"].print("B=" + (((apb + asb) / 2.0) * 100.0)->round() / 100.0) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var H : int ; H := 5 ;
     var A : int ; A := 6 ;
     execute findDimen(H, A) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int rangesum(int n,int l,int r){
    int[] arr=new int[n];
    int c=1,i=0 ;
    while(c<=n){
      arr[i++]=c ;
      c+=2 ;
    }
    c=2 ;
    while(c<=n){
      arr[i++]=c ;
      c+=2 ;
    }
    int sum=0 ;
    for(i=l-1 ; i<r ; i++){
      sum+=arr[i];
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=12 ;
    int l=1,r=11 ;
    System.out.println(rangesum(n,l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation rangesum( n : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
     var c : int ; c := 1 ;
    var i : int ; i := 0 ;
    while (c <= n) do (      arr[i+1] := c  ; i := i + 1 ; 
     c := c+(2) ) ; 
    c := 2 ; 
    while (c <= n) do (      arr[i+1] := c  ; i := i + 1 ; 
     c := c+(2) ) ; 
    var sum : int ; sum := 0 ;
        i := l - 1 ; while i < r do ( (     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     var l : int ; l := 1 ;
    var r : int ; r := 11 ;
     OclFile["System.out"].println(rangesum(n, l, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    int a[]=new int[m+1];
    for(int i=0 ; i<n ; i++){
      int l=sc.nextInt(),r=sc.nextInt();
      for(int j=l ; j<=r ; j++){
        a[j]++;
      }
    }
    int ans=0 ;
    ArrayList<Integer>list=new ArrayList<>();
    for(int i=1 ; i<=m ; i++){
      if(a[i]==0){
        ans++;
        list.add(i);
      }
    }
    System.out.println(ans);
    for(int i=0 ; i<ans ; i++){
      System.out.print(list.get(i)+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var l : int ; l := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
         var j : int ; j := l ; while j <= r do ( (     a[j+1] := a[j+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 1 ; while i <= m do ( (     if (a[i+1] = 0) then (     ans := ans + 1 ; 
     list := list->including(i) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
        var i : int ; i := 0 ; while i < ans do ( (     OclFile["System.out"].print(list->at(i+1) + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.System.*;
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static int[] freq=new int[101];
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    int rows=Integer.parseInt(sc.next());
    int end=Integer.parseInt(sc.next());
    int[][] arr=new int[rows][2];
    ArrayList<Integer>res_list=new ArrayList<>();
    for(int i=0 ; i<rows ; i++){
      for(int j=0 ; j<2 ; j++){
        arr[i][j]=Integer.parseInt(sc.next());
      }
    }
    for(int x=0 ; x<rows ; x++){
      for(int y=0 ; y<1 ; y++){
        if(arr[x][y]==arr[x][y+1])freq[arr[x][y] ]++;
        if(arr[x][y]<arr[x][y+1]){
          int num=arr[x][y];
          int num2=arr[x][y+1];
          while(num<=num2){
            freq[num]++;
            num++;
            if(num==num2){
              freq[num2]++;
              break ;
            }
          }
        }
      }
    }
    for(int n=1 ; n<=end ; n++){
      if(freq[n]==0)res_list.add(n);
    }
    if(res_list.size()==0){
      out.print(0);
    }
    else {
      out.println(res_list.size());
      for(int l=0 ; l<res_list.size(); l++){
        out.print(res_list.get(l));
        out.print(" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute freq : Sequence(int) := Integer.subrange(1,101)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var rows : int ; rows := (sc.getCurrent())->toInteger() ;
    var end : int ; end := (sc.getCurrent())->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,rows)->collect(Integer.subrange(1,2)->collect(0)) ;
    var res_list : Sequence(int) ; res_list := Sequence{} ;
        var i : int ; i := 0 ; while i < rows do ( (         var j : int ; j := 0 ; while j < 2 do ( (     arr[i+1][j+1] := (sc.getCurrent())->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var x : int ; x := 0 ; while x < rows do ( (         var y : int ; y := 0 ; while y < 1 do ( (     if (arr[x+1][y+1] = arr[x+1][y + 1+1]) then     freq[arr[x+1][y+1]+1] := freq[arr[x+1][y+1]+1] + 1 ; else skip ; 
     if (arr[x+1][y+1] < arr[x+1][y + 1+1]) then (     var num : int ; num := arr[x+1][y+1] ;
     var num2 : int ; num2 := arr[x+1][y + 1+1] ;
     while (num <= num2) do (     freq[num+1] := freq[num+1] + 1 ; 
     num := num + 1 ; 
     if (num = num2) then (     freq[num2+1] := freq[num2+1] + 1 ; 
     break ) else skip ) ) else skip )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
        var n : int ; n := 1 ; while n <= end do ( (     if (freq[n+1] = 0) then     res_list := res_list->including(n) ; else skip )  ;     n := n + 1 ) ; 
    if (res_list->size() = 0) then (     out.print(0) ) else (     out.println(res_list->size()) ; 
         var l : int ; l := 0 ; while l < res_list->size() do ( (     out.print(res_list->at(l+1)) ; 
     out.print(" ") )  ;     l := l + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class PointsInSegments {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    int[] A=new int[101];
    for(int i=0 ; i<n ; i++){
      scan.nextLine();
      int a=scan.nextInt();
      int b=scan.nextInt();
      for(int j=a ; j<=b ; j++){
        A[j]=1 ;
      }
    }
    ArrayList<Integer>list=new ArrayList<>();
    int x=0 ;
    for(int i=1 ; i<=m ; i++){
      if(A[i]==0){
        x++;
        list.add(i);
      }
    }
    System.out.println(x);
    for(int i=0 ; i<list.size(); i++){
      System.out.print(list.get(i)+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PointsInSegments {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,101)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     skip ; 
     var a : int ; a := scan.getCurrent()->toInteger() ;
     var b : int ; b := scan.getCurrent()->toInteger() ;
         var j : int ; j := a ; while j <= b do ( (     A[j+1] := 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var list : Sequence(int) ; list := Sequence{} ;
    var x : int ; x := 0 ;
        var i : int ; i := 1 ; while i <= m do ( (     if (A[i+1] = 0) then (     x := x + 1 ; 
     list := list->including(i) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(x) ; 
        var i : int ; i := 0 ; while i < list->size() do ( (     OclFile["System.out"].print(list->at(i+1) + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static int answer(int n){
    int count=0 ;
    count+=Math.min(n,9);
    if(n>=100){
      count+=Math.min(n,999)-99 ;
    }
    if(n>=10000){
      count+=Math.min(n,99999)-9999 ;
    }
    return count ;
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    scan.close();
    System.out.println(answer(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation answer( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     count := count+(Set{n, 9}->min()) ; 
    if (n >= 100) then (     count := count+(Set{n, 999}->min() - 99) ) else skip ; 
    if (n >= 10000) then (     count := count+(Set{n, 99999}->min() - 9999) ) else skip ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
     skip ; 
     OclFile["System.out"].println(answer(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1015A_PointsinSegments {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    final int n=input.nextInt();
    final int m=input.nextInt();
    Set<Integer>set=new LinkedHashSet<>();
    for(int i=1 ; i<=m ; i++){
      set.add(i);
    }
    for(int i=0 ; i<n ; i++){
      int first=input.nextInt();
      int last=input.nextInt();
      for(int k=first ; k<=last ; k++){
        set.remove(k);
      }
    }
    System.out.println(set.size());
    System.out.println(set.toString().replaceAll("[\\[\\],] ","").trim());
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1015A_PointsinSegments {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var m : int ; m := input.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 1 ; while i <= m do ( (     set := set->including(i) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var first : int ; first := input.getCurrent()->toInteger() ;
     var last : int ; last := input.getCurrent()->toInteger() ;
         var k : int ; k := first ; while k <= last do ( (     set := set->excludingAt(k+1) )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(set->size()) ; 
    OclFile["System.out"].println(set+"".replaceAllMatches("[\\[\\],] ", "" )->trim()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.stream.Collectors ;
public class B_Longest_Palindrome {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    sc.nextInt();
    String[] strings=new String[n];
    for(int i=0 ; i<strings.length ; ++i){
      strings[i]=sc.next();
    }
    System.out.println(solve(strings));
    sc.close();
  }
  static String solve(String[] strings){
    StringBuilder left=new StringBuilder();
    String center="" ;
    Set<String>rest=Arrays.stream(strings).collect(Collectors.toSet());
    while(! rest.isEmpty()){
      String s=rest.iterator().next();
      rest.remove(s);
      String reversed=new StringBuilder(s).reverse().toString();
      if(rest.contains(reversed)){
        left.append(s);
      }
      else if(reversed.equals(s)){
        center=s ;
      }
    }
    return String.format("%d\n%s%s%s",left.length()*2+center.length(),left,center,new StringBuilder(left).reverse().toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Longest_Palindrome {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
    var strings : Sequence(String) ; strings := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < strings->size() do ( (     strings[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(strings)) ; 
    skip ; 
 );
  static   operation solve( strings : Sequence(String)) : String
  pre: true
  post: true
  activity: (     var left : String ; left := StringLib.newString() ;
     var center : String ; center := "" ;
    var rest : Set(String) ; rest := stream(strings).collect(Collectors.toSet()) ;
    while (not(rest->isEmpty())) do (     var s : String ; s := rest->iterator().next() ;
     rest := rest->excludingFirst(s) ; 
     var reversed : String ; reversed := StringLib.newString(s)->reverse()+"" ;
     if (rest->includes(reversed)) then (     left := left + StringLib.newString(s) ) else     if (reversed = s) then (     center := s ) else skip ; ) ; 
    return StringLib.format("%d\n%s%s%s",Sequence{left->size() * 2 + center->size(),left,center,StringLib.newString(left)->reverse()+""}) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.lang.reflect.Array ;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    int cnt=1 ;
    while(true){
      int W=in.nextInt();
      if(W==0)return ;
      int N=in.nextInt();
      int v[]=new int[N+1];
      int w[]=new int[N+1];
      in.nextLine();
      for(int i=1 ; i<=N ; i++){
        String[] strs=in.nextLine().split(",");
        v[i]=Integer.parseInt(strs[0]);
        w[i]=Integer.parseInt(strs[1]);
      }
      System.out.println("Case "+cnt+":");
      solve(W,N,v,w);
      cnt++;
    }
  }
  public static void solve(int W,int N,int[] v,int[] w){
    int[][] dp=new int[N+2][W+2];
    for(int i=0 ; i<N+2 ; i++)dp[0][i]=0 ;
    for(int i=1 ; i<=N ; i++){
      for(int j=1 ; j<=W ; j++){
        dp[i][j]=dp[i-1][j];
        if(j-w[i]>=0){
          dp[i][j]=Math.max(dp[i-1][j-w[i] ]+v[i],dp[i-1][j]);
        }
      }
    }
    int ans_V=0 ;
    int ans_W=Integer.MAX_VALUE/2 ;
    for(int i=0 ; i<=W ; i++){
      if(ans_V<dp[N][i]){
        ans_V=dp[N][i];
        ans_W=i ;
      }
    }
    System.out.println(ans_V);
    System.out.println(ans_W);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cnt : int ; cnt := 1 ;
     while (true) do (     var W : int ; W := in.getCurrent()->toInteger() ;
     if (W = 0) then     return else skip ; 
    var N : int ; N := in.getCurrent()->toInteger() ;
    var v : Sequence(int) ; v := Integer.subrange(1,N + 1)->collect(0) ;
    var w : Sequence(int) ; w := Integer.subrange(1,N + 1)->collect(0) ;
    skip ; 
        var i : int ; i := 1 ; while i <= N do ( (     var strs : Sequence(String) ; strs := in.nextLine()->split(",") ;
     v[i+1] := (strs[0+1])->toInteger() ; 
     w[i+1] := (strs[1+1])->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Case " + cnt + ":") ; 
    execute solve(W, N, v, w) ; 
    cnt := cnt + 1 ; 
 ) );
  static   operation solve( W : int, N : int, v : Sequence(int), w : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,N + 2)->collect(Integer.subrange(1,W + 2)->collect(0)) ;
         var i : int ; i := 0 ; while i < N + 2 do (     dp[0+1][i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := 1 ; while j <= W do ( (     dp[i+1][j+1] := dp[i - 1+1][j+1] ; 
     if (j - w[i+1] >= 0) then (     dp[i+1][j+1] := Set{dp[i - 1+1][j - w[i+1]+1] + v[i+1], dp[i - 1+1][j+1]}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans_V : int ; ans_V := 0 ;
    var ans_W : int ; ans_W := 2147483647 / 2 ;
        var i : int ; i := 0 ; while i <= W do ( (     if (ans_V < dp[N+1][i+1]) then (     ans_V := dp[N+1][i+1] ; 
     ans_W := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans_V) ; 
    OclFile["System.out"].println(ans_W) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.stream.Collectors ;
public class B_Longest_Palindrome {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    sc.nextInt();
    String[] strings=new String[n];
    for(int i=0 ; i<strings.length ; ++i){
      strings[i]=sc.next();
    }
    System.out.println(solve(strings));
    sc.close();
  }
  static String solve(String[] strings){
    StringBuilder left=new StringBuilder();
    String center="" ;
    Set<String>rest=Arrays.stream(strings).collect(Collectors.toSet());
    while(! rest.isEmpty()){
      String s=rest.iterator().next();
      rest.remove(s);
      String reversed=new StringBuilder(s).reverse().toString();
      if(rest.contains(reversed)){
        left.append(s);
      }
      else if(reversed.equals(s)){
        center=s ;
      }
    }
    return String.format("%d\n%s%s%s",left.length()*2+center.length(),left,center,new StringBuilder(left).reverse().toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Longest_Palindrome {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
    var strings : Sequence(String) ; strings := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < strings->size() do ( (     strings[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(strings)) ; 
    skip ; 
 );
  static   operation solve( strings : Sequence(String)) : String
  pre: true
  post: true
  activity: (     var left : String ; left := StringLib.newString() ;
     var center : String ; center := "" ;
    var rest : Set(String) ; rest := stream(strings).collect(Collectors.toSet()) ;
    while (not(rest->isEmpty())) do (     var s : String ; s := rest->iterator().next() ;
     rest := rest->excludingFirst(s) ; 
     var reversed : String ; reversed := StringLib.newString(s)->reverse()+"" ;
     if (rest->includes(reversed)) then (     left := left + StringLib.newString(s) ) else     if (reversed = s) then (     center := s ) else skip ; ) ; 
    return StringLib.format("%d\n%s%s%s",Sequence{left->size() * 2 + center->size(),left,center,StringLib.newString(left)->reverse()+""}) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int m=in.nextInt();
    String str1[]=new String[n+10];
    String str2[]=new String[n+10];
    String ans="" ;
    for(int i=1 ; i<=n ; i++){
      String a=in.next();
      String b=new StringBuffer(a).reverse().toString();
      str1[i]=a ;
      str2[i]=b ;
      if(str1[i] .equals(str2[i]))ans=str1[i];
    }
    for(int i=1 ; i<=n ; i++){
      for(int j=i+1 ; j<=n ; j++){
        if(str2[i] .equals(str1[j]))ans=str1[i]+ans+str2[i];
      }
    }
    pw.println(ans.length());
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var str1 : Sequence(String) ; str1 := Integer.subrange(1,n + 10)->collect(null) ;
    var str2 : Sequence(String) ; str2 := Integer.subrange(1,n + 10)->collect(null) ;
    var ans : String ; ans := "" ;
        var i : int ; i := 1 ; while i <= n do ( (     var a : String ; a := in.getCurrent() ;
     var b : String ; b := StringLib.newString(a)->reverse()+"" ;
    str1[i+1] := a ; 
    str2[i+1] := b ; 
    if (str1[i+1] = str2[i+1]) then     ans := str1[i+1] ; else skip ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i + 1 ; while j <= n do ( (     if (str2[i+1] = str1[j+1]) then     ans := str1[i+1] + ans + str2[i+1] ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-10 ;
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    long M=sc.nextLong();
    long rd=sc.nextLong();
    long rr=sc.nextLong();
    long cd=sc.nextLong();
    long cr=sc.nextLong();
    long r=0 ;
    long l=1000L*1000L*1000L*1000L+1 ;
    for(int i=0 ; i<1000 ; i++){
      long mid=(r+l)/2 ;
      if(cd<=rd*mid/100){
        l=mid ;
      }
      else {
        r=mid ;
      }
    }
    long x=l ;
    r=0 ;
    l=M ;
    for(int i=0 ; i<1000 ; i++){
      long mid=(r+l)/2 ;
      if(cr<=rr*mid/100){
        l=mid ;
      }
      else {
        r=mid ;
      }
    }
    long y=l ;
    if(x+y>M){
      System.out.println(-1);
    }
    else {
      long D=rd*x/100 ;
      long R=rr*y/100 ;
      long ans=M-x-y ;
      if(D<cd || R<cr){
        System.out.println(-1);
      }
      else {
        ans+=100*(D-cd)/rd ;
        ans+=100*(R-cr)/rr ;
        System.out.println(ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var M : long ; M := sc.getCurrent()->toLong() ;
     var rd : long ; rd := sc.getCurrent()->toLong() ;
    var rr : long ; rr := sc.getCurrent()->toLong() ;
    var cd : long ; cd := sc.getCurrent()->toLong() ;
    var cr : long ; cr := sc.getCurrent()->toLong() ;
    var r : long ; r := 0 ;
    var l : long ; l := 1000L * 1000L * 1000L * 1000L + 1 ;
        var i : int ; i := 0 ; while i < 1000 do ( (     var mid : long ; mid := (r + l) / 2 ;
     if (cd <= rd * mid / 100) then (     l := mid ) else (     r := mid ) )  ;     i := i + 1 ) ; 
    var x : long ; x := l ;
    r := 0 ; 
    l := M ; 
        var i : int ; i := 0 ; while i < 1000 do ( (     var mid : long ; mid := (r + l) / 2 ;
     if (cr <= rr * mid / 100) then (     l := mid ) else (     r := mid ) )  ;     i := i + 1 ) ; 
    var y : long ; y := l ;
    if (x + y > M) then (     OclFile["System.out"].println(-1) ) else (     var D : long ; D := rd * x / 100 ;
     var R : long ; R := rr * y / 100 ;
     var ans : long ; ans := M - x - y ;
     if (D < cd or R < cr) then (     OclFile["System.out"].println(-1) ) else (     ans := ans+(100 * (D - cd) / rd) ; 
     ans := ans+(100 * (R - cr) / rr) ; 
     OclFile["System.out"].println(ans) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  long M ;
  int rD,rR ;
  long cD,cR ;
  void run(){
    M=sc.nextLong();
    rD=sc.nextInt();
    rR=sc.nextInt();
    cD=sc.nextLong();
    cR=sc.nextLong();
    solve();
  }
  void solve(){
    long max=-1 ;
    long D0=(100*cD+rD-1)/rD,C0=(100*cR+rR-1)/rR ;
    for(int i=0 ; i<100 ; i++){
      for(int j=0 ; j<100 ; j++){
        long changeD=D0+i,changeR=C0+j ;
        long jpn=M-changeD-changeR ;
        if(jpn<0){
          continue ;
        }
        long remD=changeD*rD/100-cD ;
        long remR=changeR*rR/100-cR ;
        jpn+=remD*100/rD+remR*100/rR ;
        max=max(max,jpn);
      }
    }
    println(max+"");
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute M : long;
   attribute rD : int;
   attribute cD : long;
   operation run() : void
  pre: true
  post: true
  activity: (     M := sc.getCurrent()->toLong() ; 
     rD := sc.getCurrent()->toInteger() ; 
    rR := sc.getCurrent()->toInteger() ; 
    cD := sc.getCurrent()->toLong() ; 
    cR := sc.getCurrent()->toLong() ; 
    execute solve() ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var max : long ; max := -1 ;
     var D0 : long ; D0 := (100 * cD + rD - 1) / rD ;
    var C0 : long ; C0 := (100 * cR + rR - 1) / rR ;
         var i : int ; i := 0 ; while i < 100 do ( (         var j : int ; j := 0 ; while j < 100 do ( (     var changeD : long ; changeD := D0 + i ;
    var changeR : long ; changeR := C0 + j ;
     var jpn : long ; jpn := M - changeD - changeR ;
    if (jpn < 0) then (     continue ) else skip ; 
    var remD : long ; remD := changeD * rD / 100 - cD ;
    var remR : long ; remR := changeR * rR / 100 - cR ;
    jpn := jpn+(remD * 100 / rD + remR * 100 / rR) ; 
    max := Set{max, jpn}->max() ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     execute println(max + "") );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long m=sc.nextLong();
    long rd=sc.nextLong();
    long rr=sc.nextLong();
    long cd=sc.nextLong();
    long cr=sc.nextLong();
    long d=(cd*100)/rd ;
    while((d*rd)/100!=cd)d++;
    long r=(cr*100)/rr ;
    while((r*rr)/100!=cr)r++;
    if(m-d-r<0)System.out.println(-1);
    else System.out.println(m-d-r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : long ; m := sc.getCurrent()->toLong() ;
    var rd : long ; rd := sc.getCurrent()->toLong() ;
    var rr : long ; rr := sc.getCurrent()->toLong() ;
    var cd : long ; cd := sc.getCurrent()->toLong() ;
    var cr : long ; cr := sc.getCurrent()->toLong() ;
    var d : long ; d := (cd * 100) / rd ;
    while ((d * rd) / 100 /= cd) do     d := d + 1 ; ; 
    var r : long ; r := (cr * 100) / rr ;
    while ((r * rr) / 100 /= cr) do     r := r + 1 ; ; 
    if (m - d - r < 0) then     OclFile["System.out"].println(-1) else     OclFile["System.out"].println(m - d - r) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    System.out.println(solve());
  }
  static long solve(){
    long M=sc.nextLong();
    int rd=sc.nextInt();
    int rr=sc.nextInt();
    long cd=sc.nextLong();
    long cr=sc.nextLong();
    long minD=(cd*100+rd-1)/rd ;
    long minR=(cr*100+rr-1)/rr ;
    if(M<minD+minR)return-1 ;
    long ans=0 ;
    for(int i=0 ; i<100 ; ++i){
      long yd=minD+i ;
      long md=yd*rd/100 ;
      for(int j=0 ; j<100 ; ++j){
        long yr=minR+j ;
        if(M<yd+yr)break ;
        long mc=yr*rr/100 ;
        long rem=M-yd-yr ;
        rem+=(md-cd)*100/rd ;
        rem+=(mc-cr)*100/rr ;
        ans=Math.max(ans,rem);
      }
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(solve()) );
  static   operation solve() : long
  pre: true
  post: true
  activity: (     var M : long ; M := sc.getCurrent()->toLong() ;
     var rd : int ; rd := sc.getCurrent()->toInteger() ;
    var rr : int ; rr := sc.getCurrent()->toInteger() ;
    var cd : long ; cd := sc.getCurrent()->toLong() ;
    var cr : long ; cr := sc.getCurrent()->toLong() ;
    var minD : long ; minD := (cd * 100 + rd - 1) / rd ;
    var minR : long ; minR := (cr * 100 + rr - 1) / rr ;
    if (M < minD + minR) then     return -1 else skip ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < 100 do ( (     var yd : long ; yd := minD + i ;
     var md : long ; md := yd * rd / 100 ;
         var j : int ; j := 0 ; while j < 100 do ( (     var yr : long ; yr := minR + j ;
     if (M < yd + yr) then     break else skip ; 
    var mc : long ; mc := yr * rr / 100 ;
    var rem : long ; rem := M - yd - yr ;
    rem := rem+((md - cd) * 100 / rd) ; 
    rem := rem+((mc - cr) * 100 / rr) ; 
    ans := Set{ans, rem}->max() ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Arrays ;
class GFG {
  static int getMin(int arr[],int n){
    return Arrays.stream(arr).min().getAsInt();
  }
  static int getMax(int arr[],int n){
    return Arrays.stream(arr).max().getAsInt();
  }
  public static void main(String[] args){
    int arr[]={
      12,1234,45,67,1 };
      int n=arr.length ;
      System.out.println("Minimum element of array: "+getMin(arr,n));
      System.out.println("Maximum element of array: "+getMax(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getMin( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     return stream(arr).min().getAsInt() );
  static   operation getMax( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     return stream(arr).max().getAsInt() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,1234,45,67,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Minimum element of array: " + getMin(arr, n)) ; 
     OclFile["System.out"].println("Maximum element of array: " + getMax(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import static java.util.Arrays.*;
import static java.lang.Math.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    while(sc.hasNextInt()){
      int a=sc.nextInt(),b=sc.nextInt(),n=sc.nextInt();
      String c=new Double((double)a/b).toString();
      int[] f=new int[200];
      int idx=c.indexOf(".");
      f[0]=new Integer(c.substring(idx-1,idx));
      for(int i=1 ; i<min(200,c.substring(idx+1).length()+1); i++){
        f[i]=new Integer(c.substring(idx+i,idx+i+1));
      }
      int res=0 ;
      for(int i=1 ; i<=n ; i++)res+=f[i];
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (sc.hasNextInt()) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
     var c : String ; c := ("" + (a->oclAsType(double) / b))->toReal()+"" ;
    var f : Sequence(int) ; f := Integer.subrange(1,200)->collect(0) ;
    var idx : int ; idx := c->indexOf(".")-1 ;
    f[0+1] := ("" + (c.subrange(idx - 1+1,idx)))->toInteger() ; 
        var i : int ; i := 1 ; while i < Set{200, c.subrange(idx + 1+1,idx + 1)->size() + 1}->min() do ( (     f[i+1] := ("" + (c.subrange(idx + i+1,idx + i + 1)))->toInteger() )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 1 ; while i <= n do (     res := res+(f[i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    char[] s=sc.next().toCharArray();
    int[] c=new int[4];
    for(int i=0 ; i<s.length ; i++){
      if(s[i]=='K')c[0]++;
      if(s[i]=='U')c[1]++;
      if(s[i]=='P')c[2]++;
      if(s[i]=='C')c[3]++;
    }
    System.out.println(Math.min(c[0],Math.min(c[1],Math.min(c[2],c[3]))));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var c : Sequence(int) ; c := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s[i+1] = 'K') then     c[0+1] := c[0+1] + 1 ; else skip ; 
     if (s[i+1] = 'U') then     c[1+1] := c[1+1] + 1 ; else skip ; 
     if (s[i+1] = 'P') then     c[2+1] := c[2+1] + 1 ; else skip ; 
     if (s[i+1] = 'C') then     c[3+1] := c[3+1] + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{c[0+1], Set{c[1+1], Set{c[2+1], c[3+1]}->min()}->min()}->min()) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int i,tmp ;
    int[] count=new int[4];
    String s=sc.nextLine();
    for(i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='K')count[0]++;
      else if(s.charAt(i)=='U')count[1]++;
      else if(s.charAt(i)=='P')count[2]++;
      else if(s.charAt(i)=='C')count[3]++;
    }
    for(i=0 ; i<3 ; i++)if(count[i]<count[i+1]){
      tmp=count[i];
      count[i]=count[i+1];
      count[i+1]=tmp ;
    }
    out.println(count[3]);
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var i : int ;
    var tmp : int ;
    var count : Sequence(int) ; count := Integer.subrange(1,4)->collect(0) ;
    var s : String ; s := sc.nextLine() ;
        i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'K') then     count[0+1] := count[0+1] + 1 ; else     if (s->at(i+1) = 'U') then     count[1+1] := count[1+1] + 1 else     if (s->at(i+1) = 'P') then     count[2+1] := count[2+1] + 1 else     if (s->at(i+1) = 'C') then     count[3+1] := count[3+1] + 1 ; else skip ; ;  ;  )  ;     i := i + 1 ) ; 
        i := 0 ; while i < 3 do (     if (count[i+1] < count[i + 1+1]) then (     tmp := count[i+1] ; 
     count[i+1] := count[i + 1+1] ; 
     count[i + 1+1] := tmp ) else skip ;  ;     i := i + 1 ) ; 
    out.println(count[3+1]) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    String inStr=scn.nextLine();
    char[] charList=new char[inStr.length()];
    for(int i=0 ; i<charList.length ; i++){
      charList[i]=inStr.charAt(i);
    }
    int cnt=0 ;
    while(true){
      boolean isCnt=false ;
      outside : for(int i=0 ;
      i<charList.length ;
      i++){
        if('K'==charList[i]){
          charList[i]='A' ;
          for(int j=0 ; j<charList.length ; j++){
            if('U'==charList[j]){
              charList[j]='A' ;
              for(int k=0 ; k<charList.length ; k++){
                if('P'==charList[k]){
                  charList[k]='A' ;
                  for(int l=0 ; l<charList.length ; l++){
                    if('C'==charList[l]){
                      charList[l]='A' ;
                      cnt++;
                      isCnt=true ;
                      break outside ;
                    }
                  }
                }
              }
            }
          }
        }
      }
      if(! isCnt)break ;
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inStr : String ; inStr := scn.nextLine() ;
    var charList : Sequence(String) ; charList := Integer.subrange(1,inStr->size())->collect(0) ;
        var i : int ; i := 0 ; while i < charList->size() do ( (     charList[i+1] := inStr->at(i+1) )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    while (true) do (     var isCnt : boolean ; isCnt := false ;
         var i : int ; i := 0 ; while i < charList->size() do ( (     if ('K' = charList[i+1]) then (     charList[i+1] := 'A' ; 
         var j : int ; j := 0 ; while j < charList->size() do ( (     if ('U' = charList[j+1]) then (     charList[j+1] := 'A' ; 
         var k : int ; k := 0 ; while k < charList->size() do ( (     if ('P' = charList[k+1]) then (     charList[k+1] := 'A' ; 
         var l : int ; l := 0 ; while l < charList->size() do ( (     if ('C' = charList[l+1]) then (     charList[l+1] := 'A' ; 
     cnt := cnt + 1 ; 
     isCnt := true ; 
     break ) else skip )  ;     l := l + 1 ) ) else skip )  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
     if (not(isCnt)) then     break else skip ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.*;
class Main {
  public static void main(String[] args){
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    try {
      for(int cnt=0 ; ; ++cnt){
        int w=Integer.parseInt(bf.readLine());
        if(w==0)break ;
        int n=Integer.parseInt(bf.readLine());
        int[] vs=new int[n];
        int[] ws=new int[n];
        for(int i=0 ; i<n ; ++i){
          String[] strs=bf.readLine().split(",");
          vs[i]=Integer.parseInt(strs[0]);
          ws[i]=Integer.parseInt(strs[1]);
        }
        int ansv=-1 ;
        int answ=0 ;
        int[][] dp=new int[n][w+1];
        for(int i=0 ; i<n ; ++i){
          for(int j=0 ; j<w+1 ; ++j){
            if(i==0)dp[i][j]=ws[i]<=j ? vs[i] : 0 ;
            else {
              dp[i][j]=dp[i-1][j];
              if(j-ws[i]>=0)dp[i][j]=Math.max(dp[i-1][j],dp[i-1][j-ws[i] ]+vs[i]);
            }
            if(ansv<dp[i][j] ||(ansv==dp[i][j] && answ>j)){
              ansv=dp[i][j];
              answ=j ;
            }
          }
        }
        System.out.println("Case "+(cnt+1)+":\n"+ansv+"\n"+answ);
      }
    }
    catch(IOException ex){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (         var cnt : int ; cnt := 0 ; while true do ( (     var w : int ; w := (bf.readLine())->toInteger() ;
     if (w = 0) then     break else skip ; 
    var n : int ; n := (bf.readLine())->toInteger() ;
    var vs : Sequence(int) ; vs := Integer.subrange(1,n)->collect(0) ;
    var ws : Sequence(int) ; ws := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var strs : Sequence(String) ; strs := bf.readLine()->split(",") ;
     vs[i+1] := (strs[0+1])->toInteger() ; 
     ws[i+1] := (strs[1+1])->toInteger() )  ;     i := i + 1 ) ; 
    var ansv : int ; ansv := -1 ;
    var answ : int ; answ := 0 ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,w + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < w + 1 do ( (     if (i = 0) then     dp[i+1][j+1] := if ws[i+1] <= j then vs[i+1] else 0 endif else (     dp[i+1][j+1] := dp[i - 1+1][j+1] ; 
     if (j - ws[i+1] >= 0) then     dp[i+1][j+1] := Set{dp[i - 1+1][j+1], dp[i - 1+1][j - ws[i+1]+1] + vs[i+1]}->max() ; else skip ) ;  
     if (ansv < dp[i+1][j+1] or (ansv = dp[i+1][j+1] & answ > j)) then (     ansv := dp[i+1][j+1] ; 
     answ := j ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Case " + (cnt + 1) + ":\n" + ansv + "\n" + answ) ; 
 )  ;     cnt := cnt + 1 ) )   catch (ex : IOException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
class Main {
  public static void main(String[] args){
    Solve s=new Solve();
    s.solve();
  }
}
class Solve {
  Solve(){
  }
  Scanner in=new Scanner(System.in);
  void solve(){
    String s=in.next();
    int k=0,u=0,p=0,c=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='K')k++;
      else if(s.charAt(i)=='U')u++;
      else if(s.charAt(i)=='P')p++;
      else if(s.charAt(i)=='C')c++;
    }
    System.out.println(Math.min(k,Math.min(u,Math.min(p,c))));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Solve ; s := Solve.newSolve() ;
     s.solve() );
}
class Solve {
   static operation newSolve() : Solve
  pre: true
  post: true
  activity:
  ( var self : Solve ;
    self := createSolve();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation solve() : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.getCurrent() ;
     var k : int ; k := 0 ;
    var u : int ; u := 0 ;
    var p : int ; p := 0 ;
    var c : int ; c := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'K') then     k := k + 1 ; else     if (s->at(i+1) = 'U') then     u := u + 1 else     if (s->at(i+1) = 'P') then     p := p + 1 else     if (s->at(i+1) = 'C') then     c := c + 1 ; else skip ; ;  ;  )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(Set{k, Set{u, Set{p, c}->min()}->min()}->min()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static String line ;
  public static void main(String[] args){
    while(read()){
      solve();
    }
  }
  static boolean read(){
    if(! sc.hasNext())return false ;
    line=sc.next();
    return true ;
  }
  static void solve(){
    int countK=0,countU=0,countP=0,countC=0 ;
    for(int i=0 ; i<line.length(); i++){
      char word=line.charAt(i);
      if(word=='K'){
        countK++;
      }
      else if(word=='U'){
        countU++;
      }
      else if(word=='P'){
        countP++;
      }
      else if(word=='C'){
        countC++;
      }
    }
    int res=Math.min(Math.min(countK,countU),Math.min(countP,countC));
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute line : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (read()) do (     execute solve() ) );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     if (not(sc.hasNext())) then     return false else skip ; 
     line := sc.getCurrent() ; 
     return true );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var countK : int ; countK := 0 ;
    var countU : int ; countU := 0 ;
    var countP : int ; countP := 0 ;
    var countC : int ; countC := 0 ;
         var i : int ; i := 0 ; while i < line->size() do ( (     var word : String ; word := line->at(i+1) ;
     if (word = 'K') then (     countK := countK + 1 ) else     if (word = 'U') then (     countU := countU + 1 ) else     if (word = 'P') then (     countP := countP + 1 ) else     if (word = 'C') then (     countC := countC + 1 ) else skip ; ;  ;  )  ;     i := i + 1 ) ; 
     var res : int ; res := Set{Set{countK, countU}->min(), Set{countP, countC}->min()}->min() ;
     OclFile["System.out"].println(res) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findTriplets(int arr[],int n,int sum){
    for(int i=0 ; i<n-1 ; i++){
      HashSet<Integer>s=new HashSet<>();
      for(int j=i+1 ; j<n ; j++){
        int x=sum-(arr[i]+arr[j]);
        if(s.contains(x))System.out.printf("%d %d %d\n",x,arr[i],arr[j]);
        else s.add(arr[j]);
      }
    }
  }
  public static void main(String[] args){
    int arr[]={
      0,-1,2,-3,1 };
      int sum=-2 ;
      int n=arr.length ;
      findTriplets(arr,n,sum);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findTriplets( arr : Sequence(int), n : int, sum : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n - 1 do ( (     var s : Set(int) ; s := Set{} ;
         var j : int ; j := i + 1 ; while j < n do ( (     var x : int ; x := sum - (arr[i+1] + arr[j+1]) ;
     if (s->includes(x)) then     OclFile["System.out"].printf("%d %d %d\n", x, arr[i+1], arr[j+1]) ; else     s := s->including(arr[j+1]) ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,-1,2,-3,1} ;
     var sum : int ; sum := -2 ;
     var n : int ; n := arr->size() ;
     execute findTriplets(arr, n, sum) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int a[]=new int[m+1];
    int b[]=new int[m+1];
    int answer=0 ;
    int maxb=-1 ;
    int maxidx=-1 ;
    int work=1 ;
    boolean flag=true ;
    boolean hflag=true ;
    for(int i=1 ; i<=m ; i++){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
    }
    if(n==1){
      for(int i=1 ; i<=m ; i++){
        if(a[i]==1 && b[i]==1){
          flag=false ;
          break ;
        }
      }
      if(! flag){
        System.out.println(1);
      }
      else {
        System.out.println("Impossible");
      }
    }
    else {
      while(work<n){
        maxb=-1 ;
        for(int i=1 ; i<=m ; i++){
          if(hflag){
            if(a[i]<=1){
              if(b[i]>maxb){
                maxb=b[i];
                maxidx=i ;
              }
            }
          }
          else {
            if(a[i]<=work+1){
              if(b[i]>maxb){
                maxb=b[i];
                maxidx=i ;
              }
            }
          }
        }
        if(maxb==-1){
          flag=false ;
          break ;
        }
        else {
          answer++;
          work=maxb ;
          a[maxidx]=101 ;
          b[maxidx]=101 ;
          hflag=false ;
        }
      }
      if(flag){
        System.out.println(answer);
      }
      else {
        System.out.println("Impossible");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m + 1)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m + 1)->collect(0) ;
    var answer : int ; answer := 0 ;
    var maxb : int ; maxb := -1 ;
    var maxidx : int ; maxidx := -1 ;
    var work : int ; work := 1 ;
    var flag : boolean ; flag := true ;
    var hflag : boolean ; hflag := true ;
        var i : int ; i := 1 ; while i <= m do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (n = 1) then (         var i : int ; i := 1 ; while i <= m do ( (     if (a[i+1] = 1 & b[i+1] = 1) then (     flag := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (not(flag)) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println("Impossible") ) ) else (     while (work < n) do (     maxb := -1 ; 
         var i : int ; i := 1 ; while i <= m do ( (     if (hflag) then (     if (a[i+1] <= 1) then (     if (b[i+1] > maxb) then (     maxb := b[i+1] ; 
     maxidx := i ) else skip ) else skip ) else (     if (a[i+1] <= work + 1) then (     if (b[i+1] > maxb) then (     maxb := b[i+1] ; 
     maxidx := i ) else skip ) else skip ) )  ;     i := i + 1 ) ; 
     if (maxb = -1) then (     flag := false ; 
     break ) else (     answer := answer + 1 ; 
     work := maxb ; 
    a[maxidx+1] := 101 ; 
    b[maxidx+1] := 101 ; 
    hflag := false ; 
 ) ) ; 
     if (flag) then (     OclFile["System.out"].println(answer) ) else (     OclFile["System.out"].println("Impossible") ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int N,M ;
  static Prof[] p ;
  static void solve(){
    final int INF=1<<30 ;
    int[] dp=new int[N+1];
    Arrays.fill(dp,INF);
    dp[0]=0 ;
    Arrays.sort(p);
    for(int i=0 ; i<M ; ++i){
      if(dp[p[i] .a-1]==INF){
        System.out.println("Impossible");
        return ;
      }
      int count=INF ;
      for(int j=p[i] .a-1 ; j<=p[i] .b ; ++j){
        count=Math.min(dp[j],count);
      }
      for(int j=p[i] .a ; j<=p[i] .b ; ++j){
        dp[j]=Math.min(dp[j],count+1);
      }
    }
    System.out.println(dp[N]==INF ? "Impossible" : dp[N]);
  }
  static class Prof implements Comparable<Prof>{
    int a,b ;
    Prof(int a,int b){
      this.a=a ;
      this.b=b ;
    }
    public int compareTo(Prof o){
      return this.a-o.a ;
    }
  }
  public static void main(String[] args){
    N=sc.nextInt();
    M=sc.nextInt();
    p=new Prof[M];
    for(int i=0 ; i<M ; ++i){
      int a=sc.nextInt();
      int b=sc.nextInt();
      p[i]=new Prof(a,b);
    }
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int;
  static   attribute p : Sequence(Prof);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var INF : int ; INF := (1*(2->pow(30)))->oclAsType(long) ;
     var dp : Sequence(int) ; dp := Integer.subrange(1,N + 1)->collect(0) ;
    dp := dp->collect(INF) ; 
    dp[0+1] := 0 ; 
    p := p->sort() ; 
        var i : int ; i := 0 ; while i < M do ( (     if (dp[p[i+1].a - 1+1] = INF) then (     OclFile["System.out"].println("Impossible") ; 
     return ) else skip ; 
     var count : int ; count := INF ;
         var j : int ; j := p[i+1].a - 1 ; while j <= p[i+1].b do ( (     count := Set{dp[j+1], count}->min() )  ;     j := j + 1 ) ; 
         var j : int ; j := p[i+1].a ; while j <= p[i+1].b do ( (     dp[j+1] := Set{dp[j+1], count + 1}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if dp[N+1] = INF then "Impossible" else dp[N+1] endif) ; 
 );
  static class Prof implements Comparable<Prof> {
   attribute a : int;
   static operation newProf( a : int, b : int) : Prof
  pre: true
  post: true
  activity:
  ( var self : Prof ;
    self := createProf();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
   operation compareTo( o : Prof) : int
  pre: true
  post: true
  activity: (     return self.a - o.a );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     M := sc.getCurrent()->toInteger() ; 
    p := Integer.subrange(1,M)->collect(null) ; 
        var i : int ; i := 0 ; while i < M do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     p[i+1] := Prof.newProf(a, b) )  ;     i := i + 1 ) ; 
    execute solve() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  class R implements Comparable<R>{
    int s,t ;
    public R(int s,int t){
      this.s=s ;
      this.t=t ;
    }
    public int compareTo(R o){
      return s-o.s ;
    }
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt(),M=sc.nextInt();
    PriorityQueue<R>q=new PriorityQueue<R>();
    while(M--!=0)q.add(new R(sc.nextInt(),sc.nextInt()));
    int res=0,f=0 ;
    while(! q.isEmpty()&& f<N){
      if(f+1<q.peek().s)break ;
      int max=q.poll().t ;
      while(! q.isEmpty()&& q.peek().s<=f+1)max=Math.max(max,q.poll().t);
      if(f<max){
        res++;
        f=max ;
      }
    }
    System.out.println(f==N ? res : "Impossible");
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class R implements Comparable<R> {
   attribute s : int;
   static operation newR( s : int, t : int) : R
  pre: true
  post: true
  activity:
  ( var self : R ;
    self := createR();
    self.initialise(s, t);
    return self );
  operation initialise( s : int, t : int) : void
  pre: true  post: true
  activity: (     self.s := s ; 
     self.t := t );
   operation compareTo( o : R) : int
  pre: true
  post: true
  activity: (     return s - o.s );
}
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var q : Sequence(R) ; q := Sequence{} ;
        while (M /= 0) do (    skip ;     q := q->including(R.newR(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) ; ;  ) ;  
    var res : int ; res := 0 ;
    var f : int ; f := 0 ;
    while (not(q->isEmpty()) & f < N) do (     if (f + 1 < q->min().s) then     break else skip ; 
     var max : int ; max := q->min().t ;
     while (not(q->isEmpty()) & q->min().s <= f + 1) do     max := Set{max, q->min().t}->max() ; ; 
     if (f < max) then (     res := res + 1 ; 
     f := max ) else skip ) ; 
    OclFile["System.out"].println(if f = N then res else "Impossible" endif) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    while(true){
      String line=reader.readLine();
      if(line==null || line.isEmpty()){
        break ;
      }
      String[] values=line.split(" ");
      int a=Integer.parseInt(values[0]);
      int b=Integer.parseInt(values[1]);
      int n=Integer.parseInt(values[2]);
      int q=Math.abs(b);
      int p=Math.abs(a)% q ;
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        p*=10 ;
        int f=p/q ;
        if(f==0){
          continue ;
        }
        sum+=f ;
        p %=q ;
      }
      out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     while (true) do (     var line : String ; line := reader.readLine() ;
     if (line = null or line->isEmpty()) then (     break ) else skip ; 
    var values : Sequence(String) ; values := line->split(" ") ;
    var a : int ; a := (values[0+1])->toInteger() ;
    var b : int ; b := (values[1+1])->toInteger() ;
    var n : int ; n := (values[2+1])->toInteger() ;
    var q : int ; q := if b < 0 then -(b) else b endif ;
    var p : int ; p := if a < 0 then -(a) else a endif mod q ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     p := p*(10) ; 
     var f : int ; f := p / q ;
    if (f = 0) then (     continue ) else skip ; 
    sum := sum+(f) ; 
    p := p mod q ; 
 )  ;     i := i + 1 ) ; 
    out.println(sum) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.Scanner ;
import java.util.TreeSet ;
import javax.print.attribute.standard.MediaSize.Other ;
import javax.xml.bind.ParseConversionEvent ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    final int N=sc.nextInt();
    final int M=sc.nextInt();
    int[][] data=new int[M][2];
    for(int i=0 ; i<M ; i++){
      for(int j=0 ; j<2 ; j++){
        data[i][j]=sc.nextInt();
      }
    }
    int limit=1 ;
    int count=0 ;
    while(limit<=N){
      int max=Integer.MIN_VALUE ;
      for(int i=0 ; i<M ; i++){
        if(data[i][0]<=limit && data[i][1]>=limit){
          max=Math.max(max,data[i][1]);
        }
      }
      if(max==Integer.MIN_VALUE){
        System.out.println("Impossible");
        return ;
      }
      else {
        limit=max+1 ;
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var data : Sequence(Sequence(int)) ; data := Integer.subrange(1,M)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < M do ( (         var j : int ; j := 0 ; while j < 2 do ( (     data[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var limit : int ; limit := 1 ;
    var count : int ; count := 0 ;
    while (limit <= N) do (     var max : int ; max := -2147483648 ;
         var i : int ; i := 0 ; while i < M do ( (     if (data[i+1][0+1] <= limit & data[i+1][1+1] >= limit) then (     max := Set{max, data[i+1][1+1]}->max() ) else skip )  ;     i := i + 1 ) ; 
     if (max = -2147483648) then (     OclFile["System.out"].println("Impossible") ; 
     return ) else (     limit := max + 1 ; 
     count := count + 1 ) ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getPairs(int a[]){
    int n=a.length ;
    int count=(n*(n-1))/2 ;
    return count ;
  }
  public static void main(String[] args){
    int a[]={
      2,4,3,1 };
      System.out.println(getPairs(a));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getPairs( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() ;
     var count : int ; count := (n * (n - 1)) / 2 ;
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,4,3,1} ;
     OclFile["System.out"].println(getPairs(a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=Integer.parseInt(in.next());
    List<Integer>A=new ArrayList<>();
    for(int i=0 ; i<n ; i++)A.add(Integer.parseInt(in.next()));
    int q=Integer.parseInt(in.next());
    Comparator<Integer>lower=(x,y)->x.compareTo(y)>=0 ? 1 :-1 ;
    for(int i=0 ; i<q ; i++){
      int key=Integer.parseInt(in.next());
      int p=~ Collections.binarySearch(A,key,lower);
      if(p>=0)System.out.println(p);
      else System.out.println(n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (in.getCurrent())->toInteger() ;
    var A : Sequence(int) ; A := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     A := A->including((in.getCurrent())->toInteger()) ;  ;     i := i + 1 ) ; 
    var q : int ; q := (in.getCurrent())->toInteger() ;
    var lower : Function(<int>,(<int>,boolean)) ; lower := lambda (x , y) : OclAny in if x->compareTo(y) >= 0 then 1 else -1 endif ;
        var i : int ; i := 0 ; while i < q do ( (     var key : int ; key := (in.getCurrent())->toInteger() ;
     var p : int ; p := -(.binarySearch(A, key, lower) + 1) ;
     if (p >= 0) then     OclFile["System.out"].println(p) ; else     OclFile["System.out"].println(n) ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private Scanner sc ;
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    sc=new Scanner(System.in);
    int counter=0 ;
    int maxw=Integer.parseInt(sc.nextLine());
    while(maxw!=0){
      counter++;
      int num=Integer.parseInt(sc.nextLine());
      int[][] table=new int[num+1][maxw+1];
      for(int i=0 ; i<table.length ; i++){
        for(int j=0 ; j<table[0] .length ; j++){
          table[i][j]=0 ;
        }
      }
      int value,w ;
      for(int i=0 ; i<num ; i++){
        String[] nico=sc.nextLine().split(",");
        value=Integer.parseInt(nico[0]);
        w=Integer.parseInt(nico[1]);
        for(int j=0 ; j<table[0] .length ; j++){
          if((j-w)>=0){
            if(table[i][j]>(table[i][j-w]+value))table[i+1][j]=table[i][j];
            else table[i+1][j]=table[i][j-w]+value ;
          }
          else {
            table[i+1][j]=table[i][j];
          }
        }
      }
      int max=0 ;
      int index=0 ;
      for(int i=0 ; i<table[0] .length ; i++){
        if(max<table[num][i]){
          max=table[num][i];
          index=i ;
        }
      }
      System.out.println("Case "+counter+":");
      System.out.println(max);
      System.out.println(index);
      maxw=Integer.parseInt(sc.nextLine());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var counter : int ; counter := 0 ;
     var maxw : int ; maxw := (sc.nextLine())->toInteger() ;
     while (maxw /= 0) do (     counter := counter + 1 ; 
     var num : int ; num := (sc.nextLine())->toInteger() ;
    var table : Sequence(Sequence(int)) ; table := Integer.subrange(1,num + 1)->collect(Integer.subrange(1,maxw + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < table->size() do ( (         var j : int ; j := 0 ; while j < table[0+1]->size() do ( (     table[i+1][j+1] := 0 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var value : int ;
    var w : int ;
        var i : int ; i := 0 ; while i < num do ( (     var nico : Sequence(String) ; nico := sc.nextLine()->split(",") ;
     value := (nico[0+1])->toInteger() ; 
     w := (nico[1+1])->toInteger() ; 
         var j : int ; j := 0 ; while j < table[0+1]->size() do ( (     if ((j - w) >= 0) then (     if (table[i+1][j+1] > (table[i+1][j - w+1] + value)) then     table[i + 1+1][j+1] := table[i+1][j+1] ; else     table[i + 1+1][j+1] := table[i+1][j - w+1] + value ; ) else (     table[i + 1+1][j+1] := table[i+1][j+1] ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < table[0+1]->size() do ( (     if (max < table[num+1][i+1]) then (     max := table[num+1][i+1] ; 
     index := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Case " + counter + ":") ; 
    OclFile["System.out"].println(max) ; 
    OclFile["System.out"].println(index) ; 
    maxw := (sc.nextLine())->toInteger() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int[] a=new int[n+1];
    a[0]=-1000000001 ;
    str=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++)a[i+1]=Integer.parseInt(str[i]);
    str=br.readLine().split(" ");
    int q=Integer.parseInt(str[0]);
    for(int i=0 ; i<q ; i++){
      str=br.readLine().split(" ");
      int k=Integer.parseInt(str[0]);
      int lb=0 ;
      int ub=n+1 ;
      while(ub-lb>1){
        int mid=lb+(ub-lb)/2 ;
        if(a[mid]>=k)ub=mid ;
        else lb=mid ;
      }
      System.out.println(ub-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    a[0+1] := -1000000001 ; 
    str := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do (     a[i + 1+1] := (str[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    str := br.readLine()->split(" ") ; 
    var q : int ; q := (str[0+1])->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     str := br.readLine()->split(" ") ; 
     var k : int ; k := (str[0+1])->toInteger() ;
    var lb : int ; lb := 0 ;
    var ub : int ; ub := n + 1 ;
    while (ub - lb > 1) do (     var mid : int ; mid := lb + (ub - lb) / 2 ;
     if (a[mid+1] >= k) then     ub := mid ; else     lb := mid ; ) ; 
    OclFile["System.out"].println(ub - 1) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void nibutan(int array[],int length,int num){
    int pos=-1 ;
    int lower=0 ;
    int upper=length-1 ;
    while(lower<=upper){
      int mid=(lower+upper)/2 ;
      if(array[mid]>=num){
        upper=mid ;
      }
      else if(array[mid]<num){
        lower=mid ;
      }
      if(upper-lower==1){
        if(array[lower]<num && array[upper]>=num){
          pos=upper ;
        }
        else if(array[lower]>=num){
          pos=0 ;
        }
        else {
          pos=length ;
        }
        break ;
      }
      if(upper==lower){
        if(array[0]<num){
          pos=length ;
        }
        else {
          pos=0 ;
        }
        break ;
      }
    }
    System.out.println(pos);
  }
  public static void main(String args[]){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=stdIn.nextInt();
    }
    int q=stdIn.nextInt();
    for(int i=0 ; i<q ; i++){
      int k=stdIn.nextInt();
      nibutan(a,n,k);
    }
    stdIn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation nibutan( array : Sequence(int), length : int, num : int) : void
  pre: true
  post: true
  activity: (     var pos : int ; pos := -1 ;
     var lower : int ; lower := 0 ;
    var upper : int ; upper := length - 1 ;
    while (lower <= upper) do (     var mid : int ; mid := (lower + upper) / 2 ;
     if (array[mid+1] >= num) then (     upper := mid ) else     if (array[mid+1] < num) then (     lower := mid ) else skip ; ;  
     if (upper - lower = 1) then (     if (array[lower+1] < num & array[upper+1] >= num) then (     pos := upper ) else     if (array[lower+1] >= num) then (     pos := 0 ) else (     pos := length ) ;  ;  
     break ) else skip ; 
     if (upper = lower) then (     if (array[0+1] < num) then (     pos := length ) else (     pos := 0 ) ;  
     break ) else skip ) ; 
    OclFile["System.out"].println(pos) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := stdIn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var q : int ; q := stdIn.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var k : int ; k := stdIn.getCurrent()->toInteger() ;
     execute nibutan(a, n, k) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static StringBuilder sb ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sb=new StringBuilder();
    int num=sc.nextInt();
    ArrayList<Integer>array=new ArrayList<>();
    for(int i=0 ; i<num ; i++){
      array.add(sc.nextInt());
    }
    int query=sc.nextInt();
    for(int i=0 ; i<query ; i++){
      int key=sc.nextInt();
      int tmp=BinarySearch(array,key);
      if(tmp<0)sb.append(num).append("\n");
      else sb.append(tmp).append("\n");
    }
    System.out.print(sb);
    sc.close();
  }
  public static int BinarySearch(List<Integer>list,int key){
    int lower=-1 ;
    int middle=-1 ;
    int upper=list.size();
    while(upper>lower+1){
      middle=lower+(upper-lower)/2 ;
      if(list.get(middle)>key-1)upper=middle ;
      else lower=middle ;
    }
    return upper ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sb : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     sb := StringLib.newString() ; 
    var num : int ; num := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Sequence{} ;
        var i : int ; i := 0 ; while i < num do ( (     array := array->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var query : int ; query := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < query do ( (     var key : int ; key := sc.getCurrent()->toInteger() ;
     var tmp : int ; tmp := BinarySearch(array, key) ;
     if (tmp < 0) then     sb := sb + StringLib.newString(num) + StringLib.newString("\n") ; else     sb := sb + StringLib.newString(tmp) + StringLib.newString("\n") ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
    skip ; 
 );
  static   operation BinarySearch( list : Sequence(int), key : int) : int
  pre: true
  post: true
  activity: (     var lower : int ; lower := -1 ;
     var middle : int ; middle := -1 ;
    var upper : int ; upper := list->size() ;
    while (upper > lower + 1) do (     middle := lower + (upper - lower) / 2 ; 
     if (list->at(middle+1) > key - 1) then     upper := middle ; else     lower := middle ; ) ; 
    return upper 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      long[] array=new long[n];
      for(int i=0 ; i<n ; i++)array[i]=sc.nextLong();
      boolean same=true ;
      int query=sc.nextInt();
      for(int i=0 ; i<query ; i++){
        Long k=sc.nextLong();
        if(k>array[n-1])System.out.println(n);
        else {
          System.out.println(lowerBound(array,k));
        }
      }
    }
  }
  static int lowerBound(long[] array,long target){
    int low=0 ;
    int high=array.length-1 ;
    while(low<high){
      int mid=(high+low)/2 ;
      if(array[mid]==target){
        while((mid!=0)&&(array[mid-1]==target))mid--;
        return mid ;
      }
      else if(array[mid]<target)low=mid+1 ;
      else high=mid ;
    }
    while((high!=0)&&(array[high-1]==array[high]))high--;
    return high ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var array : Sequence(long) ; array := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     array[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var same : boolean ; same := true ;
    var query : int ; query := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < query do ( (     var k : long ; k := sc.getCurrent()->toLong() ;
     if (k > array[n - 1+1]) then     OclFile["System.out"].println(n) ; else (     OclFile["System.out"].println(lowerBound(array, k)) ) )  ;     i := i + 1 ) ; 
 ))  );
  static   operation lowerBound( array : Sequence(long), target : long) : int
  pre: true
  post: true
  activity: (     var low : int ; low := 0 ;
     var high : int ; high := array->size() - 1 ;
    while (low < high) do (     var mid : int ; mid := (high + low) / 2 ;
     if (array[mid+1] = target) then (     while ((mid /= 0) & (array[mid - 1+1] = target)) do     mid := mid - 1 ; ; 
     return mid ) else     if (array[mid+1] < target) then     low := mid + 1 else     high := mid ; ;  ) ; 
    while ((high /= 0) & (array[high - 1+1] = array[high+1])) do     high := high - 1 ; ; 
    return high 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printPalindrome(Vector<String>left,String mid,Vector<String>right){
    for(String x : left)System.out.print(x);
    System.out.print(mid);
    Collections.reverse(right);
    for(String x : right)System.out.print(x);
    System.out.println();
  }
  static void findPalindrome(Vector<String>S,int N,int M){
    HashSet<String>dict=new HashSet<String>();
    for(int i=0 ; i<M ; i++){
      dict.add(S.get(i));
    }
    Vector<String>left=new Vector<String>(),right=new Vector<String>();
    String mid="" ;
    for(int i=0 ; i<N ; i++){
      String t=S.get(i);
      t=reverse(t);
      if(t==S.get(i))mid=t ;
      else if(dict.contains(t)){
        left.add(S.get(i));
        right.add(t);
        dict.remove(S.get(i));
        dict.remove(t);
      }
    }
    printPalindrome(left,mid,right);
  }
  static String reverse(String input){
    char[] a=input.toCharArray();
    int l,r=a.length-1 ;
    for(l=0 ; l<r ; l++,r--){
      char temp=a[l];
      a[l]=a[r];
      a[r]=temp ;
    }
    return String.valueOf(a);
  }
  public static void main(String[] args){
    String arr[]={
      "tab","one","bat" };
      Vector<String>S=new Vector<String>(Arrays.asList(arr));
      int M=3 ;
      int N=S.size();
      findPalindrome(S,N,M);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printPalindrome( left : Sequence(String), mid : String, right : Sequence(String)) : void
  pre: true
  post: true
  activity: (     for (x : left) do (     OclFile["System.out"].print(x) ;  ) ; 
     OclFile["System.out"].print(mid) ; 
    right := right->reverse() ; 
    for (x : right) do (     OclFile["System.out"].print(x) ;  ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation findPalindrome( S : Sequence(String), N : int, M : int) : void
  pre: true
  post: true
  activity: (     var dict : Set(String) ; dict := Set{} ;
         var i : int ; i := 0 ; while i < M do ( (     dict := dict->including(S->at(i+1)) )  ;     i := i + 1 ) ; 
    var left : Sequence(String) ; left := Sequence{} ;
    var right : Sequence(String) ; right := Sequence{} ;
    var mid : String ; mid := "" ;
        var i : int ; i := 0 ; while i < N do ( (     var t : String ; t := S->at(i+1) ;
     t := reverse(t) ; 
     if (t = S->at(i+1)) then     mid := t ; else     if (dict->includes(t)) then (     left := left->including(S->at(i+1)) ; 
     right->excludes(t) ; 
     dict := dict->excludingFirst(S->at(i+1)) ; 
     dict := dict->excludingFirst(t) ) else skip ; )  ;     i := i + 1 ) ; 
    execute printPalindrome(left, mid, right) ; 
 );
  static   operation reverse( input : String) : String
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := input->characters() ;
     var l : int ;
    var r : int ; r := a->size() - 1 ;
         l := 0 ; while l < r do ( (     var temp : String ; temp := a[l+1] ;
     a[l+1] := a[r+1] ; 
     a[r+1] := temp )  ;     l := l + 1 ;     r := r - 1 ) ; 
     return (a)->sum()  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"tab","one","bat"} ;
     var S : Sequence(String) ; S := Sequence{}->union(arr) ;
    var M : int ; M := 3 ;
    var N : int ; N := S->size() ;
    execute findPalindrome(S, N, M) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final int N=sc.nextInt();
    final int K=sc.nextInt();
    Point[] points=new Point[N];
    long[] xList=new long[N];
    long[] yList=new long[N];
    for(int i=0 ; i<N ; i++){
      points[i]=new Point(sc.nextLong(),sc.nextLong());
      xList[i]=points[i] .x ;
      yList[i]=points[i] .y ;
    }
    sc.close();
    long ans=Long.MAX_VALUE ;
    Arrays.sort(xList);
    Arrays.sort(yList);
    for(int xi=0 ; xi<N ; xi++){
      for(int xj=xi+1 ; xj<N ; xj++){
        for(int yi=0 ; yi<N ; yi++){
          for(int yj=yi+1 ; yj<N ; yj++){
            long xl=xList[xi];
            long xr=xList[xj];
            long yb=yList[yi];
            long yu=yList[yj];
            int num=0 ;
            for(Point p : points){
              if(xl<=p.x && p.x<=xr && yb<=p.y && p.y<=yu){
                num++;
              }
            }
            if(num>=K){
              ans=Math.min(ans,(xr-xl)*(yu-yb));
            }
          }
        }
      }
    }
    System.out.println(ans);
  }
  static class Point {
    public Point(long x,long y){
      this.x=x ;
      this.y=y ;
    }
    long x ;
    long y ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var points : Sequence(Point) ; points := Integer.subrange(1,N)->collect(null) ;
    var xList : Sequence(long) ; xList := Integer.subrange(1,N)->collect(0) ;
    var yList : Sequence(long) ; yList := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     points[i+1] := Point.newPoint(sc.getCurrent()->toLong(), sc.getCurrent()->toLong()) ; 
     xList[i+1] := points[i+1].x ; 
     yList[i+1] := points[i+1].y )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : long ; ans := "9223372036854775807"->toLong() ;
    xList := xList->sort() ; 
    yList := yList->sort() ; 
        var xi : int ; xi := 0 ; while xi < N do ( (         var xj : int ; xj := xi + 1 ; while xj < N do ( (         var yi : int ; yi := 0 ; while yi < N do ( (         var yj : int ; yj := yi + 1 ; while yj < N do ( (     var xl : long ; xl := xList[xi+1] ;
     var xr : long ; xr := xList[xj+1] ;
    var yb : long ; yb := yList[yi+1] ;
    var yu : long ; yu := yList[yj+1] ;
    var num : int ; num := 0 ;
    for (p : points) do ( (     if (xl <= p.x & p.x <= xr & yb <= p.y & p.y <= yu) then (     num := num + 1 ) else skip )  ) ; 
    if (num >= K) then (     ans := Set{ans, (xr - xl) * (yu - yb)}->min() ) else skip ; 
 )  ;     yj := yj + 1 ) )  ;     yi := yi + 1 ) )  ;     xj := xj + 1 ) )  ;     xi := xi + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class Point {
   static operation newPoint( x : long, y : long) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : long, y : long) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   attribute x : long;
   attribute y : long;
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findlargestAfterDel(int arr[],int m,int del[],int n){
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; ++i){
      if(mp.containsKey(del[i])){
        mp.put(del[i],mp.get(del[i])+1);
      }
      else {
        mp.put(del[i],1);
      }
    }
    int largestElement=Integer.MIN_VALUE ;
    for(int i=0 ; i<m ; i++){
      if(mp.containsKey(arr[i])){
        mp.put(arr[i],mp.get(arr[i])-1);
        if(mp.get(arr[i])==0)mp.remove(arr[i]);
      }
      else largestElement=Math.max(largestElement,arr[i]);
    }
    return largestElement ;
  }
  public static void main(String[] args){
    int array[]={
      5,12,33,4,56,12,20 };
      int m=array.length ;
      int del[]={
        12,33,56,5 };
        int n=del.length ;
        System.out.println(findlargestAfterDel(array,m,del,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findlargestAfterDel( arr : Sequence(int), m : int, del : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (mp->keys()->includes(del[i+1])) then (     mp := mp->union(Map{del[i+1] |-> mp->at(del[i+1]) + 1}) ) else (     mp := mp->union(Map{del[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var largestElement : int ; largestElement := -2147483648 ;
        var i : int ; i := 0 ; while i < m do ( (     if (mp->keys()->includes(arr[i+1])) then (     mp := mp->union(Map{arr[i+1] |-> mp->at(arr[i+1]) - 1}) ; 
     if (mp->at(arr[i+1]) = 0) then     mp := mp->antirestrict(Set{arr[i+1]}) ; else skip ) else     largestElement := Set{largestElement, arr[i+1]}->max() ; )  ;     i := i + 1 ) ; 
    return largestElement 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Sequence{5,12,33,4,56,12,20} ;
     var m : int ; m := array->size() ;
    var del : Sequence(int) ; del := Sequence{12,33,56,5} ;
    var n : int ; n := del->size() ;
    OclFile["System.out"].println(findlargestAfterDel(array, m, del, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p100 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p100().run());
  }
  public String run(){
    BigInteger x0=BigInteger.valueOf(3);
    BigInteger y0=BigInteger.valueOf(1);
    BigInteger x=x0 ;
    BigInteger y=y0 ;
    while(true){
      BigInteger sqrt=Library.sqrt(y.multiply(y).multiply(BigInteger.valueOf(8)).add(BigInteger.ONE));
      if(sqrt.testBit(0)){
        BigInteger blue=sqrt.add(BigInteger.ONE).divide(BigInteger.valueOf(2)).add(y);
        if(blue.add(y).compareTo(BigInteger.TEN.pow(12))>0)return blue.toString();
      }
      BigInteger nextx=x.multiply(x0).add(y.multiply(y0).multiply(BigInteger.valueOf(8)));
      BigInteger nexty=x.multiply(y0).add(y.multiply(x0));
      x=nextx ;
      y=nexty ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class p100 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p100.newp100().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var x0 : long ; x0 := (3 + "")->toLong() ;
     var y0 : long ; y0 := (1 + "")->toLong() ;
    var x : long ; x := x0 ;
    var y : long ; y := y0 ;
    while (true) do (     var sqrt : long ; sqrt := Library.sqrt(y.multiply(y).multiply((8 + "")->toLong())->excludes(1)) ;
     if (sqrt.testBit(0)) then (     var blue : long ; blue := sqrt->excludes(1).divide((2 + "")->toLong())->excludes(y) ;
     if (blue->excludes(y)->compareTo(10.pow(12)) > 0) then     return blue+"" else skip ) else skip ; 
    var nextx : long ; nextx := x.multiply(x0)->excludes(y.multiply(y0).multiply((8 + "")->toLong())) ;
    var nexty : long ; nexty := x.multiply(y0)->excludes(y.multiply(x0)) ;
    x := nextx ; 
    y := nexty ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class BHungarySequence {
  public static void main(String[] args)throws IOException {
    BufferedReader buf=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(buf.readLine());
    StringBuilder str=new StringBuilder();
    for(int i=t+1 ; i<=2*t ; i++)str.append(i+" ");
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class BHungarySequence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var buf : OclFile ; buf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (buf.readLine())->toInteger() ;
    var str : String ; str := StringLib.newString() ;
        var i : int ; i := t + 1 ; while i <= 2 * t do (     str := str + StringLib.newString(i + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HungrySequence1 {
  public static void main(String args[]){
    int i,j,k,t,n ;
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    boolean a[]=new boolean[10000001];
    for(i=2 ; i*i<=10000000 ; i++){
      if(a[i]==false){
        for(j=i*i ; j<=10000000 ; j+=i){
          a[j]=true ;
        }
      }
    }
    int count=0 ;
    for(i=2 ; ; i++){
      if(a[i]==false){
        System.out.print(i+" ");
        count++;
      }
      if(count==n){
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HungrySequence1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var k : int ;
    var t : int ;
    var n : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := sc.getCurrent()->toInteger() ; 
    var a : Sequence(boolean) ; a := Integer.subrange(1,10000001)->collect(false) ;
        i := 2 ; while i * i <= 10000000 do ( (     if (a[i+1] = false) then (         j := i * i ; while j <= 10000000 do ( (     a[j+1] := true )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        i := 2 ; while true do ( (     if (a[i+1] = false) then (     OclFile["System.out"].print(i + " ") ; 
     count := count + 1 ) else skip ; 
     if (count = n) then (     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=n ; i<2*n ; i++){
      System.out.print(i+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := n ; while i < 2 * n do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
import static java.lang.System.out ;
public class Main {
  public static void main(String args[]){
    new Main().run();
  }
  int toInt(String s){
    return Integer.parseInt(s);
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int caseNumber=1 ;
    while(true){
      int W=sc.nextInt();
      if(W==0)break ;
      int N=sc.nextInt();
      int[] value=new int[N];
      int[] weight=new int[N];
      sc.skip("\n");
      for(int i=0 ; i<N ; i++){
        String line=sc.nextLine();
        value[i]=toInt(line.split(",")[0]);
        weight[i]=toInt(line.split(",")[1]);
      }
      int[][] dp=new int[N+1][W+1];
      for(int i=0 ; i<N+1 ; i++)for(int j=0 ; j<W+1 ; j++)dp[i][j]=0 ;
      for(int item=0 ; item<N ; item++){
        for(int cur=0 ; cur<=W ; cur++){
          int v=value[item];
          int w=weight[item];
          if(w<=cur){
            dp[item+1][cur]=Math.max(dp[item][cur],dp[item][cur-w]+v);
          }
          else {
            dp[item+1][cur]=dp[item][cur];
          }
        }
      }
      int ansWeight=W ;
      int ansValue=dp[N][W];
      for(int j=W ; j>=0 ; --j){
        if(dp[N][j]==ansValue)ansWeight=j ;
      }
      out.println("Case "+caseNumber+":");
      caseNumber++;
      out.println(ansValue);
      out.println(ansWeight);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation toInt( s : String) : int
  pre: true
  post: true
  activity: (     return (s)->toInteger() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var caseNumber : int ; caseNumber := 1 ;
     while (true) do (     var W : int ; W := sc.getCurrent()->toInteger() ;
     if (W = 0) then     break else skip ; 
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var value : Sequence(int) ; value := Integer.subrange(1,N)->collect(0) ;
    var weight : Sequence(int) ; weight := Integer.subrange(1,N)->collect(0) ;
    skip ; 
        var i : int ; i := 0 ; while i < N do ( (     var line : String ; line := sc.nextLine() ;
     value[i+1] := toInt(line->split(",")[0+1]) ; 
     weight[i+1] := toInt(line->split(",")[1+1]) )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,W + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < N + 1 do (         var j : int ; j := 0 ; while j < W + 1 do (     dp[i+1][j+1] := 0 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var item : int ; item := 0 ; while item < N do ( (         var cur : int ; cur := 0 ; while cur <= W do ( (     var v : int ; v := value[item+1] ;
     var w : int ; w := weight[item+1] ;
     if (w <= cur) then (     dp[item + 1+1][cur+1] := Set{dp[item+1][cur+1], dp[item+1][cur - w+1] + v}->max() ) else (     dp[item + 1+1][cur+1] := dp[item+1][cur+1] ) )  ;     cur := cur + 1 ) )  ;     item := item + 1 ) ; 
    var ansWeight : int ; ansWeight := W ;
    var ansValue : int ; ansValue := dp[N+1][W+1] ;
        var j : int ; j := W ; while j >= 0 do ( (     if (dp[N+1][j+1] = ansValue) then     ansWeight := j ; else skip )  ;     j := j - 1 ) ; 
    out.println("Case " + caseNumber + ":") ; 
    caseNumber := caseNumber + 1 ; 
    out.println(ansValue) ; 
    out.println(ansWeight) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static boolean isPowerOfTwo(int x){
    return x!=0 &&((x &(x-1))==0);
  }
  static boolean differAtOneBitPos(int a,int b){
    return isPowerOfTwo(a ^ b);
  }
  public static void main(String args[]){
    int a=13,b=9 ;
    if(differAtOneBitPos(a,b)==true)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPowerOfTwo( x : int) : boolean
  pre: true
  post: true
  activity: (     return x /= 0 & ((x & (x - 1)) = 0) );
  static   operation differAtOneBitPos( a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     return isPowerOfTwo(a xor b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 13 ;
    var b : int ; b := 9 ;
     if (differAtOneBitPos(a, b) = true) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Round671A {
  public static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t-->0){
      int n=Integer.parseInt(br.readLine());
      String num=br.readLine();
      int ans=2 ;
      if(n==2){
        if((num.charAt(1)-'0')% 2!=0){
          ans=1 ;
        }
      }
      else {
        if(n>2 && n % 2==0){
          for(int i=1 ; i<num.length(); i+=2){
            if((num.charAt(i)-'0')% 2==0){
              ans=2 ;
              break ;
            }
            ans=1 ;
          }
        }
        else {
          for(int i=0 ; i<num.length(); i+=2){
            if((num.charAt(i)-'0')% 2!=0){
              ans=1 ;
              break ;
            }
          }
        }
      }
      pw.println(ans);
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Round671A {
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
     var num : String ; num := br.readLine() ;
    var ans : int ; ans := 2 ;
    if (n = 2) then (     if ((num->at(1+1) - ('0')->char2byte()) mod 2 /= 0) then (     ans := 1 ) else skip ) else (     if (n > 2 & n mod 2 = 0) then (         var i : int ; i := 1 ; while i < num->size() do ( (     if ((num->at(i+1) - ('0')->char2byte()) mod 2 = 0) then (     ans := 2 ; 
     break ) else skip ; 
     ans := 1 )  ;     i := i+(2) ) ) else (         var i : int ; i := 0 ; while i < num->size() do ( (     if ((num->at(i+1) - ('0')->char2byte()) mod 2 /= 0) then (     ans := 1 ; 
     break ) else skip )  ;     i := i+(2) ) ) ) ;  
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DigitGame {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    while(test-->0){
      int n=sc.nextInt();
      String s=sc.next();
      System.out.println(whoWins(s,n));
    }
  }
  private static char whoWins(String s,int n){
    if(n==1){
      return(s.charAt(0)-'0')% 2==0 ? '2' : '1' ;
    }
    boolean isOdd=false ;
    boolean isEven=false ;
    for(int i=1 ; i<=n ; i++){
      int num=s.charAt(i-1)-'0' ;
      if(i % 2==0){
        isEven |=(num % 2==0);
      }
      else {
        isOdd |=(num % 2==1);
      }
    }
    if(n % 2==0){
      return isEven ? '2' : '1' ;
    }
    return isOdd ? '1' : '2' ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class DigitGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
     OclFile["System.out"].println(whoWins(s, n)) ) ;  ) );
  static   operation whoWins( s : String, n : int) : String
  pre: true
  post: true
  activity: (     if (n = 1) then (     return if (s->at(0+1) - ('0')->char2byte()) mod 2 = 0 then '2' else '1' endif ) else skip ; 
     var isOdd : boolean ; isOdd := false ;
    var isEven : boolean ; isEven := false ;
        var i : int ; i := 1 ; while i <= n do ( (     var num : int ; num := s->at(i - 1+1) - ('0')->char2byte() ;
     if (i mod 2 = 0) then (     isEven := MathLib.bitwiseOr(isEven, (num mod 2 = 0)) ) else (     isOdd := MathLib.bitwiseOr(isOdd, (num mod 2 = 1)) ) )  ;     i := i + 1 ) ; 
    if (n mod 2 = 0) then (     return if isEven then '2' else '1' endif ) else skip ; 
    return if isOdd then '1' else '2' endif 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.math.RoundingMode ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=null ;
    int n=0 ;
    String s=null ;
    int result=0 ;
    try {
      sc=new Scanner(System.in);
      while(sc.hasNextBigDecimal()){
        BigDecimal a=sc.nextBigDecimal();
        BigDecimal b=sc.nextBigDecimal();
        n=sc.nextInt();
        s=String.valueOf(a.divide(b,n,RoundingMode.DOWN));
        String[] str=s.substring(s.indexOf(".")+1,s.indexOf(".")+(1+n)).split("(?<=.)");
        for(String sum : str){
          result+=Integer.parseInt(sum);
        }
        System.out.println(result);
        result=0 ;
      }
    }
    finally {
      sc.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := null ;
     var n : int ; n := 0 ;
    var s : String ; s := null ;
    var result : int ; result := 0 ;
    try (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     while (sc.hasNextBigDecimal()) do (     var a : double ; a := sc.nextBigDecimal() ;
     var b : double ; b := sc.nextBigDecimal() ;
    n := sc.getCurrent()->toInteger() ; 
    s := ((a.divide(b, n, RoundingMode.DOWN)) + "") ; 
    var str : Sequence(String) ; str := s.subrange(s->indexOf(".")-1 + 1+1,s->indexOf(".")-1 + (1 + n))->split("(?<=.)") ;
    for (sum : str) do ( (     result := result+((sum)->toInteger()) )  ) ; 
    OclFile["System.out"].println(result) ; 
    result := 0 ; 
 ) )   finally (     skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      String s=sc.next();
      int len=s.length();
      int evenrazecnt=0 ;
      int oddrazecnt=0 ;
      int evenbreachcnt=0 ;
      int oddbreachcnt=0 ;
      for(int i=0 ; i<n ; i=i+2){
        int num=s.charAt(i)-'0' ;
        if((num & 1)==0)evenrazecnt++;
        else oddrazecnt++;
      }
      for(int i=1 ; i<n ; i=i+2){
        int num=s.charAt(i)-'0' ;
        if((num & 1)==0)evenbreachcnt++;
        else oddbreachcnt++;
      }
      if((len & 1)==0){
        if(evenbreachcnt>0)System.out.println(2);
        else System.out.println(1);
      }
      else {
        if(oddrazecnt>0)System.out.println(1);
        else System.out.println(2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
    var len : int ; len := s->size() ;
    var evenrazecnt : int ; evenrazecnt := 0 ;
    var oddrazecnt : int ; oddrazecnt := 0 ;
    var evenbreachcnt : int ; evenbreachcnt := 0 ;
    var oddbreachcnt : int ; oddbreachcnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := s->at(i+1) - ('0')->char2byte() ;
     if ((MathLib.bitwiseAnd(num,1)) = 0) then     evenrazecnt := evenrazecnt + 1 ; else     oddrazecnt := oddrazecnt + 1 ; )  ;     i := i + 2 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     var num : int ; num := s->at(i+1) - ('0')->char2byte() ;
     if ((MathLib.bitwiseAnd(num,1)) = 0) then     evenbreachcnt := evenbreachcnt + 1 ; else     oddbreachcnt := oddbreachcnt + 1 ; )  ;     i := i + 2 ) ; 
    if ((MathLib.bitwiseAnd(len,1)) = 0) then (     if (evenbreachcnt > 0) then     OclFile["System.out"].println(2) ; else     OclFile["System.out"].println(1) ; ) else (     if (oddrazecnt > 0) then     OclFile["System.out"].println(1) ; else     OclFile["System.out"].println(2) ; ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static void main(String[] args){
    int a=5,b=7,c=10 ;
    if(a<=b && a<=c)System.out.println(a+" is the smallest");
    else if(b<=a && b<=c)System.out.println(b+" is the smallest");
    else System.out.println(c+" is the smallest");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 5 ;
    var b : int ; b := 7 ;
    var c : int ; c := 10 ;
     if (a <= b & a <= c) then     OclFile["System.out"].println(a + " is the smallest") ; else     if (b <= a & b <= c) then     OclFile["System.out"].println(b + " is the smallest") else     OclFile["System.out"].println(c + " is the smallest") ; ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int countNumbers(int N){
    return(int)Math.sqrt(N)-1 ;
  }
  public static void main(String args[]){
    int N=36 ;
    System.out.println(countNumbers(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation countNumbers( N : int) : int
  pre: true
  post: true
  activity: (     return (N)->sqrt()->oclAsType(int) - 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 36 ;
     OclFile["System.out"].println(countNumbers(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Dancing {
  public static void main(String[] args)throws Exception {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    int T=Integer.parseInt(in.readLine());
    for(int i=0 ; i<T ; i++){
      StringTokenizer st=new StringTokenizer(in.readLine());
      int N=Integer.parseInt(st.nextToken());
      int S=Integer.parseInt(st.nextToken());
      int p=Integer.parseInt(st.nextToken());
      int[] scores=new int[N];
      for(int j=0 ; j<N ; j++){
        scores[j]=Integer.parseInt(st.nextToken());
      }
      int ans=0 ;
      for(int j=0 ; j<N ; j++){
        if(p==0){
          ans++;
          continue ;
        }
        if(scores[j]==0)continue ;
        if(scores[j]/3>=p){
          ans++;
        }
        else if(scores[j]/3==p-1 && scores[j] % 3>0){
          ans++;
        }
        else if(scores[j]/3==p-1 && scores[j] % 3==0 && S>0){
          ans++;
          S--;
        }
        else if(scores[j]/3==p-2 && scores[j] % 3==2 && S>0){
          ans++;
          S--;
        }
      }
      System.out.println("Case #"+(i+1)+": "+ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Dancing {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var T : int ; T := (in.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < T do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(in.readLine()) ;
     var N : int ; N := (st.next())->toInteger() ;
    var S : int ; S := (st.next())->toInteger() ;
    var p : int ; p := (st.next())->toInteger() ;
    var scores : Sequence(int) ; scores := Integer.subrange(1,N)->collect(0) ;
        var j : int ; j := 0 ; while j < N do ( (     scores[j+1] := (st.next())->toInteger() )  ;     j := j + 1 ) ; 
    var ans : int ; ans := 0 ;
        var j : int ; j := 0 ; while j < N do ( (     if (p = 0) then (     ans := ans + 1 ; 
     continue ) else skip ; 
     if (scores[j+1] = 0) then     continue else skip ; 
     if (scores[j+1] / 3 >= p) then (     ans := ans + 1 ) else     if (scores[j+1] / 3 = p - 1 & scores[j+1] mod 3 > 0) then (     ans := ans + 1 ) else     if (scores[j+1] / 3 = p - 1 & scores[j+1] mod 3 = 0 & S > 0) then (     ans := ans + 1 ; 
     S := S - 1 ) else     if (scores[j+1] / 3 = p - 2 & scores[j+1] mod 3 = 2 & S > 0) then (     ans := ans + 1 ; 
     S := S - 1 ) else skip ; ;  ;  )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println("Case #" + (i + 1) + ": " + ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package j2012qualifier ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class B {
  public static String inputDirectory="src/j2012qualifier/" ;
  public static String inputFile="B.in" ;
  public static String outputFile="B.out" ;
  public static PrintWriter output ;
  public static void main(String[] args)throws FileNotFoundException {
    Scanner s=new Scanner(new File(inputDirectory+inputFile));
    output=new PrintWriter(new File(inputDirectory+outputFile));
    int cases=s.nextInt();
    for(int Case=1 ; Case<=cases ; Case++){
      s.nextLine();
      int googlers=s.nextInt();
      int maxSupriseScores=s.nextInt();
      int targetScore=s.nextInt();
      int normalScores=0 ;
      int surpriseScores=0 ;
      for(int i=0 ; i<googlers ; i++){
        int score=s.nextInt();
        if(targetScore>score){
          continue ;
        }
        int otherScore=(score-targetScore)/2 ;
        if(otherScore>=targetScore-1){
          normalScores++;
        }
        else if(otherScore>=targetScore-2){
          surpriseScores++;
        }
      }
      int answer=normalScores+Math.min(surpriseScores,maxSupriseScores);
      out("Case #"+Case+": "+answer);
    }
    output.flush();
  }
  public static void out(String s){
    output.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute inputDirectory : String := "src/j2012qualifier/";
  static   attribute inputFile : String := "B.in";
  static   attribute outputFile : String := "B.out";
  static   attribute output : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile(inputDirectory + inputFile)) ;
     output := OclFile.newOclFile_Write(OclFile(inputDirectory + outputFile)) ; 
    var cases : int ; cases := s.getCurrent()->toInteger() ;
        var Case : int ; Case := 1 ; while Case <= cases do ( (     skip ; 
     var googlers : int ; googlers := s.getCurrent()->toInteger() ;
    var maxSupriseScores : int ; maxSupriseScores := s.getCurrent()->toInteger() ;
    var targetScore : int ; targetScore := s.getCurrent()->toInteger() ;
    var normalScores : int ; normalScores := 0 ;
    var surpriseScores : int ; surpriseScores := 0 ;
        var i : int ; i := 0 ; while i < googlers do ( (     var score : int ; score := s.getCurrent()->toInteger() ;
     if (targetScore > score) then (     continue ) else skip ; 
     var otherScore : int ; otherScore := (score - targetScore) / 2 ;
     if (otherScore >= targetScore - 1) then (     normalScores := normalScores + 1 ) else     if (otherScore >= targetScore - 2) then (     surpriseScores := surpriseScores + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    var answer : int ; answer := normalScores + Set{surpriseScores, maxSupriseScores}->min() ;
    execute out("Case #" + Case + ": " + answer) ; 
 )  ;     Case := Case + 1 ) ; 
    skip ; 
 );
  static   operation out( s : String) : void
  pre: true
  post: true
  activity: (     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CodeJam2012_Q_B {
  public int calc(int N,int S,int p,int[] score){
    int cnt=0 ;
    for(int i=0 ; i<N ; i++){
      if(score[i]>=p+Math.max(p-1,0)*2){
        cnt++;
      }
      else if(score[i]>=p+Math.max(p-2,0)*2 && S>0){
        cnt++;
        S--;
      }
    }
    return cnt ;
  }
  public static void main(String[] args){
    try {
(new CodeJam2012_Q_B()).exec("B-large.in","2012_Q_B-large.out");
    }
    catch(Exception ex){
    }
  }
  public final void exec(String inFileName,String outFileName)throws Exception {
    BufferedReader inReader=new BufferedReader(new FileReader(inFileName));
    PrintWriter outWriter=new PrintWriter(new BufferedWriter(new FileWriter(outFileName)));
    int caseNums=0 ;
    caseNums=Integer.parseInt(inReader.readLine());
    for(int i=0 ; i<caseNums ; i++){
      String[] input=inReader.readLine().split(" ");
      int N=Integer.valueOf(input[0]);
      int S=Integer.valueOf(input[1]);
      int p=Integer.valueOf(input[2]);
      int[] score=new int[N];
      for(int j=0 ; j<N ; j++)score[j]=Integer.valueOf(input[j+3]);
      int outStr=calc(N,S,p,score);
      String fmtOutStr="Case #"+(i+1)+": "+outStr ;
      outWriter.println(fmtOutStr);
      System.out.println(fmtOutStr);
    }
    System.out.println(caseNums+" cases complete");
    outWriter.close();
    inReader.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeJam2012_Q_B {
   operation calc( N : int, S : int, p : int, score : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     if (score[i+1] >= p + Set{p - 1, 0}->max() * 2) then (     cnt := cnt + 1 ) else     if (score[i+1] >= p + Set{p - 2, 0}->max() * 2 & S > 0) then (     cnt := cnt + 1 ; 
     S := S - 1 ) else skip ; )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     (CodeJam2012_Q_B.newCodeJam2012_Q_B()).exec("B-large.in", "2012_Q_B-large.out") )   catch (ex : ProgramException) do skip
 );
   operation exec( inFileName : String, outFileName : String) : void
  pre: true
  post: true
  activity: (     var inReader : OclFile ; inReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inFileName)) ;
     var outWriter : OclFile ; outWriter := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(outFileName))) ;
    var caseNums : int ; caseNums := 0 ;
    caseNums := (inReader.readLine())->toInteger() ; 
        var i : int ; i := 0 ; while i < caseNums do ( (     var input : Sequence(String) ; input := inReader.readLine()->split(" ") ;
     var N : int ; N := (input[0+1])->toInteger() ;
    var S : int ; S := (input[1+1])->toInteger() ;
    var p : int ; p := (input[2+1])->toInteger() ;
    var score : Sequence(int) ; score := Integer.subrange(1,N)->collect(0) ;
        var j : int ; j := 0 ; while j < N do (     score[j+1] := (input[j + 3+1])->toInteger() ;  ;     j := j + 1 ) ; 
    var outStr : int ; outStr := calc(N, S, p, score) ;
    var fmtOutStr : String ; fmtOutStr := "Case #" + (i + 1) + ": " + outStr ;
    skip ; 
    OclFile["System.out"].println(fmtOutStr) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(caseNums + " cases complete") ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  class R {
    String s ;
    Set<R>adj ;
    boolean u ;
    public R(String s){
      this.s=s ;
      adj=new HashSet<R>();
    }
    int f(){
      if(u)return 0 ;
      u=true ;
      if(adj.isEmpty())return 1 ;
      int res=0 ;
      for(R r : adj)res+=r.f();
      return res ;
    }
  }
  Map<String,R>ref ;
  R get(String s){
    if(ref.containsKey(s))return ref.get(s);
    R r=new R(s);
    ref.put(s,r);
    return r ;
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      ref=new HashMap<String,R>();
      String g="" ;
      while(n--!=0){
        String t=sc.next();
        String[] s=t.substring(0,t.length()-1).split(":");
        if("".equals(g))g=s[0];
        R r=get(s[0]);
        for(String v : s[1] .split(","))r.adj.add(get(v));
      }
      System.out.println(get(g).f());
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class R {
   attribute s : String;
   attribute adj : Set(R);
   attribute u : boolean;
   static operation newR( s : String) : R
  pre: true
  post: true
  activity:
  ( var self : R ;
    self := createR();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     self.s := s ; 
     adj := Set{} );
   operation f() : int
  pre: true
  post: true
  activity: (     if (u) then     return 0 else skip ; 
     u := true ; 
    if (adj->isEmpty()) then     return 1 else skip ; 
    var res : int ; res := 0 ;
    for (r : adj) do (     res := res+(r.f()) ;  ) ; 
    return res 
 );
}
   attribute ref : Map(String,R);
   operation get( s : String) : R
  pre: true
  post: true
  activity: (     if (ref->keys()->includes(s)) then     return ref->at(s) else skip ; 
     var r : R ; r := R.newR(s) ;
     ref := ref->union(Map{s |-> r}) ; 
     return r );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    ref := Map{} ; 
    var g : String ; g := "" ;
        while (n /= 0) do (    skip ; (     var t : String ; t := sc.getCurrent() ;
     var s : Sequence(String) ; s := t.subrange(0+1,t->size() - 1)->split(":") ;
    if ("" = g) then     g := s[0+1] ; else skip ; 
    var r : R ; r := get(s[0+1]) ;
    for (v : s[1+1]->split(",")) do (     r.adj->excludes(at(v+1)) ;  ) ; 
 ) ;  ) ;  
    OclFile["System.out"].println(at(g+1).f()) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Double.parseDouble ;
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
import static java.lang.System.exit ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class B {
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  static int test ;
  static void solve()throws Exception {
    int n=nextInt();
    int s=nextInt();
    int p=nextInt();
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      int t=nextInt();
      if((t+2)/3>=p){
++ans ;
      }
      else if(s>0 && t>0 &&(t+4)/3>=p){
--s ;
++ans ;
      }
    }
    printCase();
    out.println(ans);
  }
  static void printCase(){
    out.print("Case #"+test+": ");
  }
  static void printlnCase(){
    out.println("Case #"+test+":");
  }
  static int nextInt()throws IOException {
    return parseInt(next());
  }
  static long nextLong()throws IOException {
    return parseLong(next());
  }
  static double nextDouble()throws IOException {
    return parseDouble(next());
  }
  static String next()throws IOException {
    while(tok==null || ! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  public static void main(String[] args){
    try {
      in=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(new OutputStreamWriter(System.out));
      int tests=nextInt();
      for(test=1 ; test<=tests ; test++){
        solve();
      }
      in.close();
      out.close();
    }
    catch(Throwable e){
      e.printStackTrace();
      exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
  static   attribute test : int;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var s : int ; s := nextInt() ;
    var p : int ; p := nextInt() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var t : int ; t := nextInt() ;
     if ((t + 2) / 3 >= p) then (     ans := ans + 1 ) else     if (s > 0 & t > 0 & (t + 4) / 3 >= p) then (     s := s - 1 ; 
     ans := ans + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    execute printCase() ; 
    skip ; 
 );
  static   operation printCase() : void
  pre: true
  post: true
  activity: (     skip );
  static   operation printlnCase() : void
  pre: true
  post: true
  activity: (     skip );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next() + "")->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return parseLong(next()) );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return parseDouble(next()) );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (tok = null or not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return tok.next() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var tests : int ; tests := nextInt() ;
        test := 1 ; while test <= tests do ( (     execute solve() )  ;     test := test + 1 ) ; 
    skip ; 
    skip ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
     execute exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
public class codejamp2 {
  public static char[] map ;
  public static void main(String[] args)throws IOException {
    readFile();
  }
  public static String getResult(String input){
    int resultInt=0 ;
    String[] splitResult=input.split(" ");
    int dancerCount=Integer.parseInt(splitResult[0]);
    int suprising=Integer.parseInt(splitResult[1]);
    int max=Integer.parseInt(splitResult[2]);
    for(int i=3 ; i<dancerCount+3 ; i++){
      int current=Integer.parseInt(splitResult[i]);
      int ave=current/3 ;
      int remain=current-3*ave ;
      int currentmax=ave+remain ;
      if(remain==0 &&(max-currentmax==1)&& current!=0){
        if(suprising>0){
          suprising--;
          resultInt++;
        }
      }
      if(currentmax>=max){
        if(remain<=1){
          resultInt++;
        }
        else if(remain==2){
          if(max-ave<=1){
            resultInt++;
          }
          else if(suprising>0){
            suprising--;
            resultInt++;
          }
        }
      }
    }
    return ""+resultInt ;
  }
  public static void readFile()throws IOException {
    FileWriter fstream=new FileWriter("out.txt");
    BufferedWriter out=new BufferedWriter(fstream);
    FileReader input=new FileReader("in.txt");
    BufferedReader bufRead=new BufferedReader(input);
    String line=bufRead.readLine();
    String current=getResult(line);
    int i=1 ;
    out.write("Case #"+i+": "+current);
    line=bufRead.readLine();
    while(line!=null){
      i++;
      System.out.println("Case #"+i+": "+getResult(line));
      out.write('\n'+"Case #"+i+": "+getResult(line));
      line=bufRead.readLine();
    }
    bufRead.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class codejamp2 {
  static   attribute map : Sequence(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute readFile() );
  static   operation getResult( input : String) : String
  pre: true
  post: true
  activity: (     var resultInt : int ; resultInt := 0 ;
     var splitResult : Sequence(String) ; splitResult := input->split(" ") ;
    var dancerCount : int ; dancerCount := (splitResult[0+1])->toInteger() ;
    var suprising : int ; suprising := (splitResult[1+1])->toInteger() ;
    var max : int ; max := (splitResult[2+1])->toInteger() ;
        var i : int ; i := 3 ; while i < dancerCount + 3 do ( (     var current : int ; current := (splitResult[i+1])->toInteger() ;
     var ave : int ; ave := current / 3 ;
    var remain : int ; remain := current - 3 * ave ;
    var currentmax : int ; currentmax := ave + remain ;
    if (remain = 0 & (max - currentmax = 1) & current /= 0) then (     if (suprising > 0) then (     suprising := suprising - 1 ; 
     resultInt := resultInt + 1 ) else skip ) else skip ; 
    if (currentmax >= max) then (     if (remain <= 1) then (     resultInt := resultInt + 1 ) else     if (remain = 2) then (     if (max - ave <= 1) then (     resultInt := resultInt + 1 ) else     if (suprising > 0) then (     suprising := suprising - 1 ; 
     resultInt := resultInt + 1 ) else skip ; ) else skip ; ) else skip ; 
 )  ;     i := i + 1 ) ; 
    return "" + resultInt 
 );
  static   operation readFile() : void
  pre: true
  post: true
  activity: (     var fstream : OclFile ; fstream := OclFile.newOclFile_Write(OclFile.newOclFile("out.txt")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(fstream) ;
    var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile("in.txt")) ;
    var bufRead : OclFile ; bufRead := OclFile.newOclFile_Read(input) ;
    var line : String ; line := bufRead.readLine() ;
    var current : String ; current := getResult(line) ;
    var i : int ; i := 1 ;
    skip ; 
    line := bufRead.readLine() ; 
    while (line /= null) do (     i := i + 1 ; 
     OclFile["System.out"].println("Case #" + i + ": " + getResult(line)) ; 
     skip ; 
     line := bufRead.readLine() ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class IsDivisible {
  static boolean check(String str){
    int n=str.length();
    int oddDigSum=0,evenDigSum=0 ;
    for(int i=0 ; i<n ; i++){
      if(i % 2==0)oddDigSum+=(str.charAt(i)-'0');
      else evenDigSum+=(str.charAt(i)-'0');
    }
    return((oddDigSum-evenDigSum)% 11==0);
  }
  public static void main(String[] args){
    String str="76945" ;
    if(check(str))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class IsDivisible {
  static   operation check( str : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var oddDigSum : int ; oddDigSum := 0 ;
    var evenDigSum : int ; evenDigSum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then     oddDigSum := oddDigSum+((str->at(i+1) - ('0')->char2byte())) ; else     evenDigSum := evenDigSum+((str->at(i+1) - ('0')->char2byte())) ; )  ;     i := i + 1 ) ; 
     return ((oddDigSum - evenDigSum) mod 11 = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "76945" ;
     if (check(str)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String line ;
      while((line=br.readLine())!=null){
        if(line.isEmpty())break ;
        String[] spl=line.split(" ");
        int a=Integer.parseInt(spl[0]);
        int b=Integer.parseInt(spl[1]);
        int n=Integer.parseInt(spl[2]);
        double d=a/(b+0.0);
        int s=0 ;
        for(int i=0 ; i<n ; i++){
          a*=10 ;
          s+=(a/b)% 10 ;
          a=a % b ;
        }
        System.out.println(s);
      }
      br.close();
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->isEmpty()) then     break else skip ; 
     var spl : Sequence(String) ; spl := line->split(" ") ;
    var a : int ; a := (spl[0+1])->toInteger() ;
    var b : int ; b := (spl[1+1])->toInteger() ;
    var n : int ; n := (spl[2+1])->toInteger() ;
    var d : double ; d := a / (b + 0.0) ;
    var s : int ; s := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a := a*(10) ; 
     s := s+((a / b) mod 10) ; 
     a := a mod b )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 ) ;     line := br.readLine() ;
 ) ;  
     skip )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class A45 {
  public static void main(String[] args)throws IOException {
    BufferedReader inp=new BufferedReader(new InputStreamReader(System.in));
    int size=Integer.parseInt(inp.readLine());
    String[] s1=inp.readLine().split(" ");
    long[] given=new long[size];
    long totalSum=0 ;
    for(int i=0 ; i<size ; i++){
      given[i]=Integer.parseInt(s1[i]);
      totalSum+=given[i];
    }
    long each=totalSum/size ;
    long[] diff=new long[size];
    for(int i=0 ; i<size ; i++){
      diff[i]=given[i]-each ;
    }
    long sum=Math.abs(diff[0]);
    long carry=diff[0];
    for(int i=1 ; i<size ; i++){
      sum+=Math.abs(diff[i]+carry);
      carry=carry+diff[i];
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A45 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inp : OclFile ; inp := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var size : int ; size := (inp.readLine())->toInteger() ;
    var s1 : Sequence(String) ; s1 := inp.readLine()->split(" ") ;
    var given : Sequence(long) ; given := Integer.subrange(1,size)->collect(0) ;
    var totalSum : long ; totalSum := 0 ;
        var i : int ; i := 0 ; while i < size do ( (     given[i+1] := (s1[i+1])->toInteger() ; 
     totalSum := totalSum+(given[i+1]) )  ;     i := i + 1 ) ; 
    var each : long ; each := totalSum / size ;
    var diff : Sequence(long) ; diff := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < size do ( (     diff[i+1] := given[i+1] - each )  ;     i := i + 1 ) ; 
    var sum : long ; sum := if diff[0+1] < 0 then -(diff[0+1]) else diff[0+1] endif ;
    var carry : long ; carry := diff[0+1] ;
        var i : int ; i := 1 ; while i < size do ( (     sum := sum+(if diff[i+1] + carry < 0 then -(diff[i+1] + carry) else diff[i+1] + carry endif) ; 
     carry := carry + diff[i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Matches {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(in.readLine());
    String[] temp=in.readLine().split(" ");
    long c=0 ;
    long[] pp=new long[n];
    for(int i=0 ; i<n ; i++){
      int u=Integer.parseInt(temp[i]);
      c+=u ;
      pp[i]=u ;
    }
    long h=c/n ;
    long y=0 ;
    for(int i=0 ; i<pp.length-1 ; i++){
      long u=pp[i]-h ;
      if(u>0){
        pp[i]-=u ;
        pp[i+1]+=u ;
        y+=u ;
      }
      else if(u<0){
        pp[i+1]=pp[i+1]-(h-pp[i]);
        y+=(h-pp[i]);
        pp[i]=h ;
      }
    }
    System.out.println(y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Matches {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (in.readLine())->toInteger() ;
    var temp : Sequence(String) ; temp := in.readLine()->split(" ") ;
    var c : long ; c := 0 ;
    var pp : Sequence(long) ; pp := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var u : int ; u := (temp[i+1])->toInteger() ;
     c := c+(u) ; 
     pp[i+1] := u )  ;     i := i + 1 ) ; 
    var h : long ; h := c / n ;
    var y : long ; y := 0 ;
        var i : int ; i := 0 ; while i < pp->size() - 1 do ( (     var u : long ; u := pp[i+1] - h ;
     if (u > 0) then (     pp[i+1] := pp[i+1]-(u) ; 
     pp[i + 1+1] := pp[i + 1+1]+(u) ; 
     y := y+(u) ) else     if (u < 0) then (     pp[i + 1+1] := pp[i + 1+1] - (h - pp[i+1]) ; 
     y := y+((h - pp[i+1])) ; 
     pp[i+1] := h ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(y) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class TheNumberOfProducts {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=in.nextInt();
    pw.println(solve(a,n));
    pw.close();
  }
  static String solve(int[] a,int n){
    long positiveEnd=0,negativeEnd=0 ;
    long posTot=0,negTot=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]>0)positiveEnd++;
      else {
        long temp=positiveEnd ;
        positiveEnd=negativeEnd ;
        negativeEnd=temp ;
        negativeEnd++;
      }
      posTot+=positiveEnd ;
      negTot+=negativeEnd ;
    }
    return negTot+" "+posTot ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class TheNumberOfProducts {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( a : Sequence(int), n : int) : String
  pre: true
  post: true
  activity: (     var positiveEnd : long ; positiveEnd := 0 ;
    var negativeEnd : long ; negativeEnd := 0 ;
     var posTot : long ; posTot := 0 ;
    var negTot : long ; negTot := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] > 0) then     positiveEnd := positiveEnd + 1 else (     var temp : long ; temp := positiveEnd ;
     positiveEnd := negativeEnd ; 
     negativeEnd := temp ; 
     negativeEnd := negativeEnd + 1 ) ;  
     posTot := posTot+(positiveEnd) ; 
     negTot := negTot+(negativeEnd) )  ;     i := i + 1 ) ; 
     return negTot + " " + posTot );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static int n ;
  static int a[];
  static void solve(){
    Map<Integer,Integer>map=new HashMap<>();
    int prod=1 ;
    long pos=0,neg=0 ;
    for(int i=0 ; i<n ; i++){
      prod*=a[i];
      if(prod>0)pos++;
      else neg++;
      if(prod<0){
        pos+=map.getOrDefault(-1,0);
        neg+=map.getOrDefault(1,0);
      }
      else {
        pos+=map.getOrDefault(1,0);
        neg+=map.getOrDefault(-1,0);
      }
      map.put(prod,map.getOrDefault(prod,0)+1);
    }
    str.append(neg+" "+pos);
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    n=Integer.parseInt(bf.readLine().trim());
    a=new int[n];
    String s[]=bf.readLine().trim().split("\\s+");
    for(int i=0 ; i<n ; i++)a[i]=Integer.parseInt(s[i])>0 ? 1 :-1 ;
    solve();
    pw.println(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute n : int;
  static   attribute a : Sequence(int);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var map : Map(int,int) ; map := Map{} ;
     var prod : int ; prod := 1 ;
    var pos : long ; pos := 0 ;
    var neg : long ; neg := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     prod := prod*(a[i+1]) ; 
     if (prod > 0) then     pos := pos + 1 else     neg := neg + 1 ; ;  
     if (prod < 0) then (     pos := pos+((if map->keys()->contains(-1) then map->at(-1) else 0 endif)) ; 
     neg := neg+((if map->keys()->contains(1) then map->at(1) else 0 endif)) ) else (     pos := pos+((if map->keys()->contains(1) then map->at(1) else 0 endif)) ; 
     neg := neg+((if map->keys()->contains(-1) then map->at(-1) else 0 endif)) ) ;  
     map := map->union(Map{prod |-> (if map->keys()->contains(prod) then map->at(prod) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    str := str + StringLib.newString(neg + " " + pos) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    n := (bf.readLine()->trim())->toInteger() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
    var s : Sequence(String) ; s := bf.readLine()->trim()->split("\\s+") ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := if (s[i+1])->toInteger() > 0 then 1 else -1 endif ;  ;     i := i + 1 ) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static int n ;
  static int a[];
  static void solve(){
    long pos=1,neg=0 ;
    long val=1 ;
    for(int i=0 ; i<n ; i++){
      val*=a[i]<0 ?-1 : 1 ;
      if(val<0)neg++;
      else pos++;
    }
    str.append(pos*neg).append(" ").append(n*1l*(n+1)/2-pos*neg).append("\n");
  }
  public static void main(String[] args)throws java.lang.Exception {
    boolean lenv=false ;
    BufferedReader bf ;
    PrintWriter pw ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    n=Integer.parseInt(bf.readLine().trim());
    a=new int[n];
    String s[]=bf.readLine().trim().split("\\s+");
    for(int i=0 ; i<n ; i++)a[i]=Integer.parseInt(s[i]);
    solve();
    pw.print(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute n : int;
  static   attribute a : Sequence(int);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var pos : long ; pos := 1 ;
    var neg : long ; neg := 0 ;
     var val : long ; val := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     val := val*(if a[i+1] < 0 then -1 else 1 endif) ; 
     if (val < 0) then     neg := neg + 1 ; else     pos := pos + 1 ; )  ;     i := i + 1 ) ; 
     str := str + StringLib.newString(pos * neg) + StringLib.newString(" ") + StringLib.newString(n * 1l * (n + 1) / 2 - pos * neg) + StringLib.newString("\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var lenv : boolean ; lenv := false ;
     var bf : OclFile ;
    var pw : OclFile ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    n := (bf.readLine()->trim())->toInteger() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
    var s : Sequence(String) ; s := bf.readLine()->trim()->split("\\s+") ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (s[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class TheNumberOfProducts {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    String[] temp=br.readLine().split(" ");
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=Integer.parseInt(temp[i]);
    }
    int[] preCount=new int[n+1];
    for(int i=0 ; i<n ; i++){
      preCount[i+1]=preCount[i]+(nums[i]<0 ? 1 : 0);
    }
    long countPositive=0 ;
    long countNegative=0 ;
    int countEven=1 ;
    int countOdd=0 ;
    for(int i=1 ; i<=n ; i++){
      if(preCount[i] % 2==0){
        countNegative+=countOdd ;
        countPositive+=countEven ;
        countEven++;
      }
      else {
        countNegative+=countEven ;
        countPositive+=countOdd ;
        countOdd++;
      }
    }
    pr.println(countNegative+" "+countPositive);
  }
}
------------------------------------------------------------
OCL File:
---------
 class TheNumberOfProducts {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := (temp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var preCount : Sequence(int) ; preCount := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     preCount[i + 1+1] := preCount[i+1] + (if nums[i+1] < 0 then 1 else 0 endif) )  ;     i := i + 1 ) ; 
    var countPositive : long ; countPositive := 0 ;
    var countNegative : long ; countNegative := 0 ;
    var countEven : int ; countEven := 1 ;
    var countOdd : int ; countOdd := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (preCount[i+1] mod 2 = 0) then (     countNegative := countNegative+(countOdd) ; 
     countPositive := countPositive+(countEven) ; 
     countEven := countEven + 1 ) else (     countNegative := countNegative+(countEven) ; 
     countPositive := countPositive+(countOdd) ; 
     countOdd := countOdd + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static boolean canBeSumofConsec(int n){
    return(((n &(n-1))!=0)&& n!=0);
  }
  public static void main(String[] args){
    int n=15 ;
    System.out.println(canBeSumofConsec(n)? "true" : "false");
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation canBeSumofConsec( n : int) : boolean
  pre: true
  post: true
  activity: (     return (((n & (n - 1)) /= 0) & n /= 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     OclFile["System.out"].println(if canBeSumofConsec(n) then "true" else "false" endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=parseInt(line);
      if(n==0)break ;
      Map<String,Set<String>>groups=new HashMap<>();
      String first="" ;
      for(int i=0 ; i<n ; i++){
        words=br.readLine().replaceAll("\\.","").split("[:,] ");
        groups.put(words[0],new HashSet<>());
        for(int j=1 ; j<words.length ; j++){
          groups.get(words[0]).add(words[j]);
        }
        if(i==0)first=words[0];
      }
      boolean changed ;
      do {
        changed=false ;
        for(String group : groups.keySet()){
          if(! group.equals(first)&& groups.get(first).contains(group)){
            groups.get(first).remove(group);
            for(String member : groups.get(group)){
              groups.get(first).add(member);
            }
            changed=true ;
          }
        }
      }
      while(changed);
      System.out.println(groups.get(first).size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := parseInt(line) ;
     if (n = 0) then     break else skip ; 
    var groups : Map(String,Set(String)) ; groups := Map{} ;
    var first : String ; first := "" ;
        var i : int ; i := 0 ; while i < n do ( (     words := br.readLine().replaceAllMatches("\\.", "" )->split("[:,] ") ; 
     groups := groups->union(Map{words[0+1] |-> Set{}}) ; 
         var j : int ; j := 1 ; while j < words->size() do ( (     groups->at(words[0+1])->excludes(words[j+1]) )  ;     j := j + 1 ) ; 
     if (i = 0) then     first := words[0+1] ; else skip )  ;     i := i + 1 ) ; 
    var changed : boolean ;
  while true do ((     changed := false ; 
     for (group : groups->keys()) do ( (     if (not(group = first) & groups->at(first)->includes(group)) then (     groups := groups->at(first)->excludingFirst(group) ; 
     for (member : groups->at(group)) do ( (     groups->at(first)->excludes(member) )  ) ; 
     changed := true ) else skip )  ) ) ;
    if (changed) then skip else break) ; 
    OclFile["System.out"].println(groups->at(first)->size()) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class a {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int T=input.nextInt();
    for(int t=0 ; t<T ; t++){
      System.out.printf("Case #%d: ",t+1);
      int n=input.nextInt();
      int p=input.nextInt(),q=input.nextInt(),r=input.nextInt(),s=input.nextInt();
      int[] data=new int[n];
      for(int i=0 ; i<n ; i++){
        data[i]=(int)(((long)i*p+q)% r+s);
      }
      long lo=1,hi=(long)1e13 ;
      while(lo<hi-1){
        long mid=(lo+hi)/2 ;
        if(canDo(data,mid))hi=mid ;
        else lo=mid ;
      }
      if(! canDo(data,lo))lo++;
      long sum=0 ;
      for(int i=0 ; i<n ; i++)sum+=data[i];
      double res=1.*lo/sum ;
      System.out.printf("%.9f\n",1-res);
    }
  }
  static boolean canDo(int[] data,long max){
    long count=1,sum=0 ;
    int n=data.length ;
    for(int i=0 ; i<n ; i++){
      if(data[i]>max)return false ;
      sum+=data[i];
      if(sum>max){
        count++;
        sum=data[i];
        if(count>3)return false ;
      }
    }
    return count<=3 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := input.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     OclFile["System.out"].printf("Case #%d: ", t + 1) ; 
     var n : int ; n := input.getCurrent()->toInteger() ;
    var p : int ; p := input.getCurrent()->toInteger() ;
    var q : int ; q := input.getCurrent()->toInteger() ;
    var r : int ; r := input.getCurrent()->toInteger() ;
    var s : int ; s := input.getCurrent()->toInteger() ;
    var data : Sequence(int) ; data := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     data[i+1] := ((i->oclAsType(long) * p + q) mod r + s)->oclAsType(int) )  ;     i := i + 1 ) ; 
    var lo : long ; lo := 1 ;
    var hi : long ; hi := 1e13->oclAsType(long) ;
    while (lo < hi - 1) do (     var mid : long ; mid := (lo + hi) / 2 ;
     if (canDo(data, mid)) then     hi := mid ; else     lo := mid ; ) ; 
    if (not(canDo(data, lo))) then     lo := lo + 1 ; else skip ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (     sum := sum+(data[i+1]) ;  ;     i := i + 1 ) ; 
    var res : double ; res := 1. * lo / sum ;
    OclFile["System.out"].printf("%.9f\n", 1 - res) ; 
 )  ;     t := t + 1 ) );
  static   operation canDo( data : Sequence(int), max : long) : boolean
  pre: true
  post: true
  activity: (     var count : long ; count := 1 ;
    var sum : long ; sum := 0 ;
     var n : int ; n := data->size() ;
         var i : int ; i := 0 ; while i < n do ( (     if (data[i+1] > max) then     return false else skip ; 
     sum := sum+(data[i+1]) ; 
     if (sum > max) then (     count := count + 1 ; 
     sum := data[i+1] ; 
     if (count > 3) then     return false else skip ) else skip )  ;     i := i + 1 ) ; 
     return count <= 3 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class TokitsukazeAndMahjong {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a[]=new int[3];
    for(int i=0 ; i<3 ; i++){
      String s=in.next();
      a[i]=(s.charAt(0)-'0')+(s.charAt(1)-'a')*10 ;
    }
    Arrays.sort(a);
    int t1=a[1]-a[0],t2=a[2]-a[1];
    if((t2==1 && t1==1)||(t2==0 && t1==0))System.out.println(0);
    else if(t1<=2 || t2<=2)System.out.println(1);
    else System.out.println(2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class TokitsukazeAndMahjong {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     var s : String ; s := in.getCurrent() ;
     a[i+1] := (s->at(0+1) - ('0')->char2byte()) + (s->at(1+1) - ('a')->char2byte()) * 10 )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var t1 : int ; t1 := a[1+1] - a[0+1] ;
    var t2 : int ; t2 := a[2+1] - a[1+1] ;
    if ((t2 = 1 & t1 = 1) or (t2 = 0 & t1 = 0)) then     OclFile["System.out"].println(0) else     if (t1 <= 2 or t2 <= 2) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println(2) ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.util.*;
class Main {
  static int[] parents ;
  static int[] weight ;
  static int[] rank ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int q=scanner.nextInt();
    parents=new int[n];
    weight=new int[n];
    rank=new int[n];
    for(int i=0 ; i<n ; i++){
      parents[i]=i ;
    }
    int type,x,y,z ;
    for(int i=0 ; i<q ; i++){
      type=scanner.nextInt();
      x=scanner.nextInt();
      y=scanner.nextInt();
      if(type==0){
        z=scanner.nextInt();
        relate(x,y,z);
      }
      else {
        diff(x,y);
      }
    }
  }
  static int find(int x){
    if(x==parents[x])return x ;
    else {
      int r=find(parents[x]);
      weight[x]+=weight[parents[x] ];
      return parents[x]=r ;
    }
  }
  static int weight(int x){
    find(x);
    return weight[x];
  }
  static void relate(int x,int y,int z){
    z+=weight(x);
    z-=weight(y);
    x=find(x);
    y=find(y);
    if(x==y)return ;
    if(rank[x]<rank[y]){
      int tmp=x ;
      x=y ;
      y=tmp ;
      z=-z ;
    }
    if(rank[x]==rank[y]){
      rank[x]++;
    }
    parents[y]=x ;
    weight[y]=z ;
  }
  static void diff(int x,int y){
    if(find(x)==find(y)){
      System.out.println(weight(y)-weight(x));
    }
    else {
      System.out.println("?");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute parents : Sequence(int);
  static   attribute weight : Sequence(int);
  static   attribute rank : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var q : int ; q := scanner.getCurrent()->toInteger() ;
    parents := Integer.subrange(1,n)->collect(0) ; 
    weight := Integer.subrange(1,n)->collect(0) ; 
    rank := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     parents[i+1] := i )  ;     i := i + 1 ) ; 
    var type : int ;
    var x : int ;
    var y : int ;
    var z : int ;
        var i : int ; i := 0 ; while i < q do ( (     type := scanner.getCurrent()->toInteger() ; 
     x := scanner.getCurrent()->toInteger() ; 
     y := scanner.getCurrent()->toInteger() ; 
     if (type = 0) then (     z := scanner.getCurrent()->toInteger() ; 
     execute relate(x, y, z) ) else (     execute diff(x, y) ) )  ;     i := i + 1 ) ; 
 );
  static   operation find( x : int) : int
  pre: true
  post: true
  activity: (     if (x = parents[x+1]) then     return x else (     var r : int ; r := find(parents[x+1]) ;
     weight[x+1] := weight[x+1]+(weight[parents[x+1]+1]) ; 
     return parents[x+1] ) );
  static   operation weight( x : int) : int
  pre: true
  post: true
  activity: (     execute find(x) ; 
     return weight[x+1] );
  static   operation relate( x : int, y : int, z : int) : void
  pre: true
  post: true
  activity: (     z := z+(weight(x)) ; 
     z := z-(weight(y)) ; 
    x := find(x) ; 
    y := find(y) ; 
    if (x = y) then     return else skip ; 
    if (rank[x+1] < rank[y+1]) then (     var tmp : int ; tmp := x ;
     x := y ; 
     y := tmp ; 
     z := -z ) else skip ; 
    if (rank[x+1] = rank[y+1]) then (     rank[x+1] := rank[x+1] + 1 ) else skip ; 
    parents[y+1] := x ; 
    weight[y+1] := z ; 
 );
  static   operation diff( x : int, y : int) : void
  pre: true
  post: true
  activity: (     if (find(x) = find(y)) then (     OclFile["System.out"].println(weight(y) - weight(x)) ) else (     OclFile["System.out"].println("?") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String str=br.readLine();
      if(str==null){
        break ;
      }
      String[] strArray=str.split(" ");
      int a=Integer.parseInt(strArray[0]);
      int b=Integer.parseInt(strArray[1]);
      int n=Integer.parseInt(strArray[2]);
      Decimal dc=new Decimal(a,b);
      System.out.println(dc.sumOfDecimal(n));
    }
  }
}
class Decimal {
  private int numerator ;
  private int denominator ;
  private int[] dplace=new int[101];
  public Decimal(int a,int b){
    numerator=a ;
    denominator=b ;
    initDplace();
  }
  private void initDplace(){
    int a=numerator ;
    int b=denominator ;
    for(int i=1 ; i<dplace.length ; i++){
      dplace[i]=(a*10/b)% 10 ;
      a=a*10 % b ;
    }
  }
  public int sumOfDecimal(int n){
    int result=0 ;
    for(int i=1 ; i<=n ; i++){
      result+=dplace[i];
    }
    return result ;
  }
  public void print(){
    for(int i=1 ; i<dplace.length ; i++){
      System.out.print(dplace[i]);
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var str : String ; str := br.readLine() ;
     if (str = null) then (     break ) else skip ; 
    var strArray : Sequence(String) ; strArray := str->split(" ") ;
    var a : int ; a := (strArray[0+1])->toInteger() ;
    var b : int ; b := (strArray[1+1])->toInteger() ;
    var n : int ; n := (strArray[2+1])->toInteger() ;
    var dc : Decimal ; dc := Decimal.newDecimal(a, b) ;
    OclFile["System.out"].println(dc.sumOfDecimal(n)) ; 
 ) );
}
class Decimal {
   attribute numerator : int;
   attribute denominator : int;
   attribute dplace : Sequence(int) := Integer.subrange(1,101)->collect(0);
   static operation newDecimal( a : int, b : int) : Decimal
  pre: true
  post: true
  activity:
  ( var self : Decimal ;
    self := createDecimal();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     numerator := a ; 
     denominator := b ; 
     execute initDplace() );
   operation initDplace() : void
  pre: true
  post: true
  activity: (     var a : int ; a := numerator ;
     var b : int ; b := denominator ;
         var i : int ; i := 1 ; while i < dplace->size() do ( (     dplace[i+1] := (a * 10 / b) mod 10 ; 
     a := a * 10 mod b )  ;     i := i + 1 ) );
   operation sumOfDecimal( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     result := result+(dplace[i+1]) )  ;     i := i + 1 ) ; 
     return result );
   operation print() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < dplace->size() do ( (     OclFile["System.out"].print(dplace[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class B_Tokitsukaze_and_Mahjong {
  static Scanner in=new Scanner(System.in);
  public static void main(String[] amit){
    int ans[]=new int[3];
    for(int i=0 ; i<3 ; ++i){
      String s=in.next();
      ans[i]=Integer.parseInt(s.charAt(0)+"")+Integer.parseInt((s.charAt(1)-'a')+"")*10 ;
    }
    Arrays.sort(ans);
    int first=ans[1]-ans[0],second=ans[2]-ans[1];
    int third=ans[2]-ans[0];
    if(ans[0]==ans[1] && ans[1]==ans[2]){
      System.out.print(0);
      return ;
    }
    if(first==second &&(second==1 || first==0)){
      System.out.print(0);
    }
    else if(first<=2 || second<=2){
      System.out.print(1);
    }
    else {
      System.out.print(2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Tokitsukaze_and_Mahjong {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( amit : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Integer.subrange(1,3)->collect(0) ;
         var i : int ; i := 0 ; while i < 3 do ( (     var s : String ; s := in.getCurrent() ;
     ans[i+1] := (s->at(0+1) + "")->toInteger() + ((s->at(1+1) - ('a')->char2byte()) + "")->toInteger() * 10 )  ;     i := i + 1 ) ; 
    ans := ans->sort() ; 
    var first : int ; first := ans[1+1] - ans[0+1] ;
    var second : int ; second := ans[2+1] - ans[1+1] ;
    var third : int ; third := ans[2+1] - ans[0+1] ;
    if (ans[0+1] = ans[1+1] & ans[1+1] = ans[2+1]) then (     OclFile["System.out"].print(0) ; 
     return ) else skip ; 
    if (first = second & (second = 1 or first = 0)) then (     OclFile["System.out"].print(0) ) else     if (first <= 2 or second <= 2) then (     OclFile["System.out"].print(1) ) else (     OclFile["System.out"].print(2) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public void exec(){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(a>b){
      System.out.println("a>b");
    }
    else if(a<b){
      System.out.println("a<b");
    }
    else {
      System.out.println("a==b");
    }
  }
  public static void main(String[] args){
    new Main().exec();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation exec() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (a > b) then (     OclFile["System.out"].println("a>b") ) else     if (a < b) then (     OclFile["System.out"].println("a<b") ) else (     OclFile["System.out"].println("a==b") ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().exec() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.*;
import java.io.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=br.readLine();
    String[] ab=str.split(" ",0);
    int a=Integer.parseInt(ab[0]);
    int b=Integer.parseInt(ab[1]);
    if(a<b){
      System.out.println("a<b");
    }
    else if(a>b){
      System.out.println("a>b");
    }
    else if(a==b){
      System.out.println("a==b");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := br.readLine() ;
    var ab : Sequence(String) ; ab := str->split(" ") ;
    var a : int ; a := (ab[0+1])->toInteger() ;
    var b : int ; b := (ab[1+1])->toInteger() ;
    if (a < b) then (     OclFile["System.out"].println("a<b") ) else     if (a > b) then (     OclFile["System.out"].println("a>b") ) else     if (a = b) then (     OclFile["System.out"].println("a==b") ) else skip ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args){
    InputStreamReader sr=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(sr);
    try {
      String[] str=br.readLine().split(" ");
      int a=Integer.parseInt(str[0]);
      int b=Integer.parseInt(str[1]);
      if(a<b){
        System.out.println("a<b");
      }
      else if(a>b){
        System.out.println("a>b");
      }
      else if(a==b){
        System.out.println("a==b");
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sr : OclFile ; sr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(sr) ;
     try (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     var a : int ; a := (str[0+1])->toInteger() ;
     var b : int ; b := (str[1+1])->toInteger() ;
     if (a < b) then (     OclFile["System.out"].println("a<b") ) else     if (a > b) then (     OclFile["System.out"].println("a>b") ) else     if (a = b) then (     OclFile["System.out"].println("a==b") ) else skip ; ;  )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] intArray=Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    int a=intArray[0];
    int b=intArray[1];
    if(a==b){
      System.out.printf("a==b\n");
    }
    else if(a<b){
      System.out.printf("a<b\n");
    }
    else {
      System.out.printf("a>b\n");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var intArray : Sequence(int) ; intArray := stream(sc.nextLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var a : int ; a := intArray[0+1] ;
    var b : int ; b := intArray[1+1] ;
    if (a = b) then (     OclFile["System.out"].printf("a==b\n") ) else     if (a < b) then (     OclFile["System.out"].printf("a<b\n") ) else (     OclFile["System.out"].printf("a>b\n") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    int x=in.nextInt();
    int y=in.nextInt();
    evaluation(x,y);
    in.close();
  }
  public static void evaluation(int a,int b){
    if(a<b){
      System.out.println("a<b");
    }
    else if(a>b){
      System.out.println("a>b");
    }
    else {
      System.out.println("a==b");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := in.getCurrent()->toInteger() ;
    var y : int ; y := in.getCurrent()->toInteger() ;
    execute evaluation(x, y) ; 
    skip ; 
 );
  static   operation evaluation( a : int, b : int) : void
  pre: true
  post: true
  activity: (     if (a < b) then (     OclFile["System.out"].println("a<b") ) else     if (a > b) then (     OclFile["System.out"].println("a>b") ) else (     OclFile["System.out"].println("a==b") ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Stack ;
class Main {
  public static void main(String[] args){
    new Main().compute();
  }
  void compute(){
    Scanner sc=new Scanner(System.in);
    sc.useDelimiter("[\\s]+");
    while(sc.hasNext()){
      int a[]=new int[4];
      for(int i=0 ; i<4 ; i++){
        a[i]=sc.nextInt();
      }
      int hit=0,blow=0 ;
      for(int i=0 ; i<4 ; i++){
        int b=sc.nextInt();
        for(int j=0 ; j<4 ; j++){
          if(a[j]==b){
            if(i==j){
              hit++;
            }
            else {
              blow++;
            }
            continue ;
          }
        }
      }
      System.out.println(hit+" "+blow);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().compute() );
   operation compute() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
     while (sc.hasNext()) do (     var a : Sequence(int) ; a := Integer.subrange(1,4)->collect(0) ;
         var i : int ; i := 0 ; while i < 4 do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var hit : int ; hit := 0 ;
    var blow : int ; blow := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     var b : int ; b := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < 4 do ( (     if (a[j+1] = b) then (     if (i = j) then (     hit := hit + 1 ) else (     blow := blow + 1 ) ;  
     continue ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(hit + " " + blow) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    String line=null ;
    while((line=reader.readLine())!=null && ! line.isEmpty()){
      String[] values=line.split(" ");
      int[] orders=new int[10];
      for(int i=0 ; i<4 ; i++){
        orders[Integer.parseInt(values[i])]=i+1 ;
      }
      values=reader.readLine().split(" ");
      int hit=0 ;
      int blow=0 ;
      for(int i=0 ; i<4 ; i++){
        int order=orders[Integer.parseInt(values[i])];
        if(order==i+1){
          hit++;
        }
        else if(order!=0){
          blow++;
        }
      }
      out.println(hit+" "+blow);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     var line : String ; line := null ;
         line := reader.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var values : Sequence(String) ; values := line->split(" ") ;
     var orders : Sequence(int) ; orders := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     orders[(values[i+1])->toInteger()+1] := i + 1 )  ;     i := i + 1 ) ; 
    values := reader.readLine()->split(" ") ; 
    var hit : int ; hit := 0 ;
    var blow : int ; blow := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     var order : int ; order := orders[(values[i+1])->toInteger()+1] ;
     if (order = i + 1) then (     hit := hit + 1 ) else     if (order /= 0) then (     blow := blow + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    out.println(hit + " " + blow) ; 
 ) ;     line := reader.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  Scanner sc ;
  public void run(){
    sc=new Scanner(System.in);
    while(sc.hasNextInt()){
      int n=sc.nextInt();
      if(n!=0){
        calc(n);
      }
      else {
        break ;
      }
    }
  }
  public void calc(int n){
    HashMap<String,String[]>groups=new HashMap<String,String[]>();
    HashMap<String,Integer>members=new HashMap<String,Integer>();
    int count=0 ;
    String first="" ;
    for(int i=0 ; i<n ; i++){
      String line=sc.next();
      String lines=line.substring(0,line.length()-1);
      String[] g=lines.split(":");
      String group=g[0];
      String[] member=g[1] .split(",");
      if(i==0)first=group ;
      groups.put(group,member);
    }
    ArrayList<String>list=new ArrayList<String>();
    list.add(first);
    while(list.size()!=0){
      String group=list.get(0);
      list.remove(0);
      String[] member=groups.get(group);
      for(int i=0 ; i<member.length ; i++){
        String m=member[i];
        if(groups.containsKey(m)){
          list.add(m);
        }
        else if(! members.containsKey(m)){
          members.put(m,1);
          count++;
        }
      }
      groups.put(group,new String[] {
      }
);
    }
    System.out.println(count);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     while (sc.hasNextInt()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n /= 0) then (     execute calc(n) ) else (     break ) ) );
   operation calc( n : int) : void
  pre: true
  post: true
  activity: (     var groups : Map(String,Sequence(String)) ; groups := Map{} ;
     var members : Map(String,int) ; members := Map{} ;
    var count : int ; count := 0 ;
    var first : String ; first := "" ;
        var i : int ; i := 0 ; while i < n do ( (     var line : String ; line := sc.getCurrent() ;
     var lines : String ; lines := line.subrange(0+1,line->size() - 1) ;
    var g : Sequence(String) ; g := lines->split(":") ;
    var group : String ; group := g[0+1] ;
    var member : Sequence(String) ; member := g[1+1]->split(",") ;
    if (i = 0) then     first := group ; else skip ; 
    groups := groups->union(Map{group |-> member}) ; 
 )  ;     i := i + 1 ) ; 
    var list : Sequence(String) ; list := Sequence{} ;
    list := list->including(first) ; 
    while (list->size() /= 0) do (     var group : String ; group := list->at(0+1) ;
     list := list->excludingAt(0+1) ; 
    var member : Sequence(String) ; member := groups->at(group) ;
        var i : int ; i := 0 ; while i < member->size() do ( (     var m : String ; m := member[i+1] ;
     if (groups->keys()->includes(m)) then (     list := list->including(m) ) else     if (not(members->keys()->includes(m))) then (     members := members->union(Map{m |-> 1}) ; 
     count := count + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    groups := groups->union(Map{group |-> Sequence{}}) ; 
 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  void run(){
    sc=new Scanner(System.in);
    for(; sc.hasNext(); ){
      LinkedList<Integer>a=new LinkedList<Integer>();
      LinkedList<Integer>b=new LinkedList<Integer>();
      for(int i=0 ; i<4 ; i++)a.add(sc.nextInt());
      for(int i=0 ; i<4 ; i++)b.add(sc.nextInt());
      int hit=0,brow=0 ;
      for(int i=0 ; i<4 ; i++){
        if(a.get(i)==b.get(i))hit++;
        else if(a.contains(b.get(i)))brow++;
      }
      println(hit+" "+brow);
    }
    sc.close();
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
       while sc.hasNext() do ( (     var a : Sequence(int) ; a := Sequence{} ;
     var b : Sequence(int) ; b := Sequence{} ;
        var i : int ; i := 0 ; while i < 4 do (     a := a->including(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 4 do (     b := b->including(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    var hit : int ; hit := 0 ;
    var brow : int ; brow := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     if (a->at(i+1) = b->at(i+1)) then     hit := hit + 1 ; else     if (a->includes(b->at(i+1))) then     brow := brow + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    execute println(hit + " " + brow) ; 
 )  ) ; 
     skip );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    sc.close();
    boolean nodec=true ;
    for(int i=1 ; i<n ; i++){
      if(a[i]<=a[i-1])nodec=false ;
    }
    if(nodec){
      System.out.println(1);
      return ;
    }
    int m=500 ;
    int l=1,r=210000 ;
    int mid=2 ;
    int[] dec=new int[m];
    out : while(r-l>1){
      mid=(l+r)/2 ;
      dec=new int[m];
      Arrays.fill(dec,1);
      nout : for(int i=1 ;
      i<n ;
      i++){
        if(a[i]<=a[i-1] && a[i]-1<m){
          if(dec[a[i]-1]<mid){
            dec[a[i]-1]++;
          }
          else {
            int pos=a[i]-1 ;
            while(pos>0){
              dec[pos-1]++;
              for(int j=pos ; j<m ; j++){
                dec[j]=1 ;
              }
              if(dec[pos-1]<=mid)continue nout ;
              pos--;
            }
            l=mid ;
            continue out ;
          }
        }
        else {
          for(int j=a[i]-1 ; j<m ; j++){
            dec[j]=1 ;
          }
        }
      }
      r=mid ;
    }
    System.out.println(r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var nodec : boolean ; nodec := true ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] <= a[i - 1+1]) then     nodec := false ; else skip )  ;     i := i + 1 ) ; 
    if (nodec) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    var m : int ; m := 500 ;
    var l : int ; l := 1 ;
    var r : int ; r := 210000 ;
    var mid : int ; mid := 2 ;
    var dec : Sequence(int) ; dec := Integer.subrange(1,m)->collect(0) ;
    while (r - l > 1) do (     mid := (l + r) / 2 ; 
     dec := Integer.subrange(1,m)->collect(0) ; 
    dec := dec->collect(1) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] <= a[i - 1+1] & a[i+1] - 1 < m) then (     if (dec[a[i+1] - 1+1] < mid) then (     dec[a[i+1] - 1+1] := dec[a[i+1] - 1+1] + 1 ) else (     var pos : int ; pos := a[i+1] - 1 ;
     while (pos > 0) do (     dec[pos - 1+1] := dec[pos - 1+1] + 1 ; 
         var j : int ; j := pos ; while j < m do ( (     dec[j+1] := 1 )  ;     j := j + 1 ) ; 
     if (dec[pos - 1+1] <= mid) then     continue else skip ; 
     pos := pos - 1 ) ; 
     l := mid ; 
     continue ) ) else (         var j : int ; j := a[i+1] - 1 ; while j < m do ( (     dec[j+1] := 1 )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
    r := mid ; 
 ) ; 
    OclFile["System.out"].println(r) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String s[]=new String[2];
      while((s[0]=br.readLine())!=null){
        s[1]=br.readLine();
        StringTokenizer st[]=new StringTokenizer[2];
        st[0]=new StringTokenizer(s[0]);
        st[1]=new StringTokenizer(s[1]);
        int a[]=new int[4];
        int b[]=new int[4];
        for(int i=0 ; i<4 ; i++){
          a[i]=Integer.parseInt(st[0] .nextToken());
          b[i]=Integer.parseInt(st[1] .nextToken());
        }
        int hit=0 ;
        int blow=0 ;
        for(int i=0 ; i<4 ; i++){
          for(int j=0 ; j<4 ; j++){
            if(a[i]==b[j]){
              if(i==j)hit++;
              else blow++;
            }
          }
        }
        System.out.println(hit+" "+blow);
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var s : Sequence(String) ; s := Integer.subrange(1,2)->collect(null) ;
         s[0+1] := br.readLine() ;
    while ((s[0+1]) /= null) do (    skip ; (     s[1+1] := br.readLine() ; 
     var st : Sequence(OclIterator) ; st := Integer.subrange(1,2)->collect(null) ;
    st[0+1] := OclIterator.newOclIterator_String(s[0+1]) ; 
    st[1+1] := OclIterator.newOclIterator_String(s[1+1]) ; 
    var a : Sequence(int) ; a := Integer.subrange(1,4)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     a[i+1] := (st[0+1].next())->toInteger() ; 
     b[i+1] := (st[1+1].next())->toInteger() )  ;     i := i + 1 ) ; 
    var hit : int ; hit := 0 ;
    var blow : int ; blow := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < 4 do ( (     if (a[i+1] = b[j+1]) then (     if (i = j) then     hit := hit + 1 ; else     blow := blow + 1 ; ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(hit + " " + blow) ; 
 ) ;     s[0+1] := br.readLine() ;
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static final int HIT=0 ;
  public static final int BLOW=1 ;
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    ArrayList<int[]>outList=new ArrayList<>();
    while(sc.hasNextLine()){
      int[] answer=getNumberArray(sc.nextLine().split(" "));
      int[] expected=getNumberArray(sc.nextLine().split(" "));
      int[] hitAndBlow=getHitAndBlow(answer,expected);
      outList.add(hitAndBlow);
    }
    for(int[] hitAndBlow : outList){
      System.out.println(hitAndBlow[HIT]+" "+hitAndBlow[BLOW]);
    }
    sc.close();
  }
  public static int[] getNumberArray(String[] input){
    int[] numbers=new int[10];
    Arrays.fill(numbers,0);
    for(int i=0 ; i<input.length ; i++){
      int num=Integer.parseInt(input[i]);
      for(int j=0 ; j<10 ; j++){
        if(num==j){
          numbers[j]=i+1 ;
        }
      }
    }
    return numbers ;
  }
  public static int[] getHitAndBlow(int[] answer,int[] expected){
    int[] hitAndBlow=new int[2];
    for(int i=0 ; i<10 ; i++){
      if(answer[i]==0){
        continue ;
      }
      if(answer[i]==expected[i]){
        hitAndBlow[HIT]++;
        continue ;
      }
      if(answer[i]!=0 && expected[i]!=0){
        hitAndBlow[BLOW]++;
        continue ;
      }
    }
    return hitAndBlow ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute HIT : int := 0;
  static    attribute BLOW : int := 1;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var outList : Sequence(Sequence(int)) ; outList := Sequence{} ;
    while (sc.hasNextLine()) do (     var answer : Sequence(int) ; answer := getNumberArray(sc.nextLine()->split(" ")) ;
     var expected : Sequence(int) ; expected := getNumberArray(sc.nextLine()->split(" ")) ;
     var hitAndBlow : Sequence(int) ; hitAndBlow := getHitAndBlow(answer, expected) ;
     outList := outList->including(hitAndBlow) ) ; 
    for (hitAndBlow : outList) do ( (     OclFile["System.out"].println(hitAndBlow[HIT+1] + " " + hitAndBlow[BLOW+1]) )  ) ; 
    skip ; 
 );
  static   operation getNumberArray( input : Sequence(String)) : Sequence(int)
  pre: true
  post: true
  activity: (     var numbers : Sequence(int) ; numbers := Integer.subrange(1,10)->collect(0) ;
     numbers := numbers->collect(0) ; 
         var i : int ; i := 0 ; while i < input->size() do ( (     var num : int ; num := (input[i+1])->toInteger() ;
         var j : int ; j := 0 ; while j < 10 do ( (     if (num = j) then (     numbers[j+1] := i + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return numbers );
  static   operation getHitAndBlow( answer : Sequence(int), expected : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var hitAndBlow : Sequence(int) ; hitAndBlow := Integer.subrange(1,2)->collect(0) ;
         var i : int ; i := 0 ; while i < 10 do ( (     if (answer[i+1] = 0) then (     continue ) else skip ; 
     if (answer[i+1] = expected[i+1]) then (     hitAndBlow[HIT+1] := hitAndBlow[HIT+1] + 1 ; 
     continue ) else skip ; 
     if (answer[i+1] /= 0 & expected[i+1] /= 0) then (     hitAndBlow[BLOW+1] := hitAndBlow[BLOW+1] + 1 ; 
     continue ) else skip )  ;     i := i + 1 ) ; 
     return hitAndBlow );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=Integer.parseInt(scan.nextLine());
    String str=scan.nextLine();
    String ans=check(n,str);
    System.out.println(ans);
  }
  public static String check(int n,String str){
    int[][] forward={
      {
        1,0,0,0 },{
          0,1,1,0 },{
            0,1,1,1 },{
              0,0,1,1 },{
                1,1,1,0 },{
                  1,1,1,1 },{
                    1,0,1,1 },{
                      1,1,0,0 },{
                        1,1,1,1 },{
                          1,0,0,1 }
                        };
                        char[] s=str.toCharArray();
                        for(int i=0 ; i<4 ; i++){
                          boolean flag=false ;
                          for(char c : s){
                            int idx=c-'0' ;
                            if(forward[idx][i]==0){
                              flag=true ;
                            }
                          }
                          if(! flag){
                            return "NO" ;
                          }
                        }
                        return "YES" ;
                      }
                    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (scan.nextLine())->toInteger() ;
    var str : String ; str := scan.nextLine() ;
    var ans : String ; ans := check(n, str) ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation check( n : int, str : String) : String
  pre: true
  post: true
  activity: (     var forward : Sequence(Sequence(int)) ; forward := Sequence{Sequence{1,0,0,0},Sequence{0,1,1,0},Sequence{0,1,1,1},Sequence{0,0,1,1},Sequence{1,1,1,0},Sequence{1,1,1,1},Sequence{1,0,1,1},Sequence{1,1,0,0},Sequence{1,1,1,1},Sequence{1,0,0,1}} ;
     var s : Sequence(String) ; s := str->characters() ;
         var i : int ; i := 0 ; while i < 4 do ( (     var flag : boolean ; flag := false ;
     for (c : s) do ( (     var idx : int ; idx := c - ('0')->char2byte() ;
     if (forward[idx+1][i+1] = 0) then (     flag := true ) else skip )  ) ; 
     if (not(flag)) then (     return "NO" ) else skip )  ;     i := i + 1 ) ; 
     return "YES" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class A_Mike_and_Cellphone {
  static BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter out=new PrintWriter(System.out);
  static final int[][] MOVES={
    {
      1,0,0,0 },{
        0,1,1,0 },{
          0,1,1,1 },{
            0,0,1,1 },{
              1,1,1,0 },{
                1,1,1,1 },{
                  1,0,1,1 },{
                    1,1,0,0 },{
                      1,1,1,1 },{
                        1,0,0,1 }
                      };
                      public static void main(String[] args)throws IOException {
                        boolean unique=true ;
                        in.readLine();
                        char[] n=in.readLine().toCharArray();
                        for(int i=0 ; i<4 ; i++){
                          boolean aux=false ;
                          for(char c : n){
                            if(MOVES[Character.getNumericValue(c)][i]==0){
                              aux=true ;
                            }
                          }
                          if(! aux){
                            unique=false ;
                          }
                        }
                        out.println(unique ? "YES" : "NO");
                        out.close();
                      }
                    }

------------------------------------------------------------
OCL File:
---------
 class A_Mike_and_Cellphone {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static    attribute MOVES : Sequence(Sequence(int)) := Sequence{Sequence{1,0,0,0},Sequence{0,1,1,0},Sequence{0,1,1,1},Sequence{0,0,1,1},Sequence{1,1,1,0},Sequence{1,1,1,1},Sequence{1,0,1,1},Sequence{1,1,0,0},Sequence{1,1,1,1},Sequence{1,0,0,1}};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var unique : boolean ; unique := true ;
     skip ; 
    var n : Sequence(String) ; n := in.readLine()->characters() ;
        var i : int ; i := 0 ; while i < 4 do ( (     var aux : boolean ; aux := false ;
     for (c : n) do ( (     if (MOVES[("" + c)->toInteger()+1][i+1] = 0) then (     aux := true ) else skip )  ) ; 
     if (not(aux)) then (     unique := false ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class A689 {
  public static void main(String[] args){
    Point[] P=new Point[10];
    P[0]=new Point(1,3);
    for(int r=0 ; r<3 ; r++){
      for(int c=0 ; c<3 ; c++){
        P[3*r+c+1]=new Point(c,r);
      }
    }
    Set<Point>all=new HashSet<>();
    all.addAll(Arrays.asList(P));
    Scanner in=new Scanner(System.in);
    in.nextInt();
    char[] S=in.next().toCharArray();
    Set<Point>set=new HashSet<>();
    for(char c : S){
      set.add(P[c-'0']);
    }
    boolean unique=true ;
    outer : for(int dx=-2 ;
    dx<=2 ;
    dx++){
      for(int dy=-3 ; dy<=3 ; dy++){
        if(dx!=0 || dy!=0){
          boolean valid=true ;
          for(Point p : set){
            if(! all.contains(new Point(p.x+dx,p.y+dy))){
              valid=false ;
              break ;
            }
          }
          if(valid){
            unique=false ;
            break outer ;
          }
        }
      }
    }
    System.out.println(unique ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A689 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var P : Sequence(Point) ; P := Integer.subrange(1,10)->collect(null) ;
     P[0+1] := Point.newPoint(1, 3) ; 
        var r : int ; r := 0 ; while r < 3 do ( (         var c : int ; c := 0 ; while c < 3 do ( (     P[3 * r + c + 1+1] := Point.newPoint(c, r) )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    var all : Set(Point) ; all := Set{} ;
    all := all->union(P) ; 
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    skip ; 
    var S : Sequence(String) ; S := in.getCurrent()->characters() ;
    var set : Set(Point) ; set := Set{} ;
    for (c : S) do ( (     set := set->including(P[c - ('0')->char2byte()+1]) )  ) ; 
    var unique : boolean ; unique := true ;
        var dx : int ; dx := -2 ; while dx <= 2 do ( (         var dy : int ; dy := -3 ; while dy <= 3 do ( (     if (dx /= 0 or dy /= 0) then (     var valid : boolean ; valid := true ;
     for (p : set) do ( (     if (not(all->includes(Point.newPoint(p.x + dx, p.y + dy)))) then (     valid := false ; 
     break ) else skip )  ) ; 
     if (valid) then (     unique := false ; 
     break ) else skip ) else skip )  ;     dy := dy + 1 ) )  ;     dx := dx + 1 ) ; 
    OclFile["System.out"].println(if unique then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int calculateSum(int n){
    return(n*((int)Math.pow(n,2)+3*n+5))/3 ;
  }
  public static void main(String arr[]){
    int n=25 ;
    System.out.println(calculateSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculateSum( n : int) : int
  pre: true
  post: true
  activity: (     return (n * (n->pow(2)->oclAsType(int) + 3 * n + 5)) / 3 );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 25 ;
     OclFile["System.out"].println(calculateSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int calculateSum(int n){
    return n*(int)(Math.pow(n,2)+3*n+5)/3 ;
  }
  public static void main(String arr[]){
    int n=3 ;
    System.out.println("Sum="+calculateSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation calculateSum( n : int) : int
  pre: true
  post: true
  activity: (     return n * (n->pow(2) + 3 * n + 5)->oclAsType(int) / 3 );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println("Sum=" + calculateSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int calculateSum(int n){
    return((int)Math.pow(10,n+1)*(9*n-1)+10)/(int)Math.pow(9,3)-n*(n+1)/18 ;
  }
  public static void main(String ar[]){
    int n=3 ;
    System.out.println("Sum="+calculateSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation calculateSum( n : int) : int
  pre: true
  post: true
  activity: (     return (10->pow(n + 1)->oclAsType(int) * (9 * n - 1) + 10) / 9->pow(3)->oclAsType(int) - n * (n + 1) / 18 );
  static   operation main( ar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println("Sum=" + calculateSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int log_a_to_base_b(int a,int b){
    return(int)(Math.log(a)/Math.log(b));
  }
  public static void main(String[] args){
    int a=3 ;
    int b=2 ;
    System.out.println(log_a_to_base_b(a,b));
    a=256 ;
    b=4 ;
    System.out.println(log_a_to_base_b(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation log_a_to_base_b( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return ((a)->log() / (b)->log())->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
     var b : int ; b := 2 ;
    OclFile["System.out"].println(log_a_to_base_b(a, b)) ; 
    a := 256 ; 
    b := 4 ; 
    OclFile["System.out"].println(log_a_to_base_b(a, b)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    int k=stdIn.nextInt();
    String s=stdIn.next();
    s=s.substring(0,k-1)+(s.substring(k-1,k)).toLowerCase()+s.substring(k,n);
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var k : int ; k := stdIn.getCurrent()->toInteger() ;
    var s : String ; s := stdIn.getCurrent() ;
    s := s.subrange(0+1,k - 1) + (s.subrange(k - 1+1,k))->toLowerCase() + s.subrange(k+1,n) ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
import java.util.Arrays ;
import java.util.TreeMap ;
public class Main {
  private int n ;
  private int[] a ;
  private TreeMap<Integer,Integer>s ;
  public static void main(String[] args){
    Main m=new Main();
    m.solve();
  }
  private void set(){
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      n=Integer.parseInt(br.readLine());
      a=Arrays.stream(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
      s=new TreeMap<>();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  private void solve(){
    set();
    int ng=0 ;
    int ok=n ;
    while(ok-ng>1){
      int k=(ng+ok)/2 ;
      if(isPossible(k)){
        ok=k ;
      }
      else {
        ng=k ;
      }
    }
    System.out.println(ok);
  }
  private boolean isPossible(int k){
    s.clear();
    int current=0 ;
    for(int ai : a){
      if(ai<=current){
        if(k==1)return false ;
        while(! s.isEmpty()&& s.lastKey()>=ai)s.pollLastEntry();
        int p=ai-1 ;
        while(true){
          if(p<0)return false ;
          int sp=s.getOrDefault(p,0)+1 ;
          s.put(p,sp);
          if(sp==k){
            s.remove(p);
            p--;
          }
          else {
            break ;
          }
        }
      }
      current=ai ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute a : Sequence(int);
   attribute s : Map(int,int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.solve() );
   operation set() : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     n := (br.readLine())->toInteger() ; 
     a := stream(br.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ; 
     s := Map{} ))   catch (e : IOException) do (     e.printStackTrace() )
  );
   operation solve() : void
  pre: true
  post: true
  activity: (     execute set() ; 
     var ng : int ; ng := 0 ;
    var ok : int ; ok := n ;
    while (ok - ng > 1) do (     var k : int ; k := (ng + ok) / 2 ;
     if (isPossible(k)) then (     ok := k ) else (     ng := k ) ) ; 
    OclFile["System.out"].println(ok) ; 
 );
   operation isPossible( k : int) : boolean
  pre: true
  post: true
  activity: (     s := s->intersection(Map{}) ; 
     var current : int ; current := 0 ;
     for (ai : a) do ( (     if (ai <= current) then (     if (k = 1) then     return false else skip ; 
     while (not(s->isEmpty()) & s->keys()->max() >= ai) do     s := s.pollLastEntry() ; ; 
     var p : int ; p := ai - 1 ;
     while (true) do (     if (p < 0) then     return false else skip ; 
     var sp : int ; sp := (if s->keys()->contains(p) then s->at(p) else 0 endif) + 1 ;
     s := s->union(Map{p |-> sp}) ; 
     if (sp = k) then (     s := s->antirestrict(Set{p}) ; 
     p := p - 1 ) else (     break ) ) ) else skip ; 
     current := ai )  ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  V[] G ;
  boolean[] used ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      G=new V[n*20];
      for(int i=0 ; i<n*20 ; i++)G[i]=new V();
      HashMap<String,Integer>map=new HashMap<String,Integer>();
      int ind=0 ;
      for(int i=0 ; i<n ; i++){
        String[] sp=sc.next().split("[:,.] ");
        if(! map.containsKey(sp[0]))map.put(sp[0],ind++);
        int f=map.get(sp[0]);
        for(int j=1 ; j<sp.length ; j++){
          if(! map.containsKey(sp[j]))map.put(sp[j],ind++);
          int t=map.get(sp[j]);
          G[f] .add(t);
        }
      }
      used=new boolean[n*20];
      cnt=0 ;
      dfs(0);
      System.out.println(cnt);
    }
  }
  int cnt ;
  void dfs(int p){
    used[p]=true ;
    if(G[p] .size()==0)cnt++;
    for(int i : G[p])if(! used[i])dfs(i);
  }
  class V extends ArrayList<Integer>{
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   attribute G : Sequence(V);
   attribute used : Sequence(boolean);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    G := Integer.subrange(1,n * 20)->collect(null) ; 
        var i : int ; i := 0 ; while i < n * 20 do (     G[i+1] := V.newV() ;  ;     i := i + 1 ) ; 
    var map : Map(String,int) ; map := Map{} ;
    var ind : int ; ind := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var sp : Sequence(String) ; sp := sc.getCurrent()->split("[:,.] ") ;
     if (not(map->keys()->includes(sp[0+1]))) then     map := map->union(Map{sp[0+1] |-> ind}) ; else skip ; 
     var f : int ; f := map->at(sp[0+1]) ;
         var j : int ; j := 1 ; while j < sp->size() do ( (     if (not(map->keys()->includes(sp[j+1]))) then     map := map->union(Map{sp[j+1] |-> ind}) ; else skip ; 
     var t : int ; t := map->at(sp[j+1]) ;
     G[f+1]->excludes(t) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    used := Integer.subrange(1,n * 20)->collect(false) ; 
    cnt := 0 ; 
    execute dfs(0) ; 
    OclFile["System.out"].println(cnt) ; 
 )  ) );
   attribute cnt : int;
   operation dfs( p : int) : void
  pre: true
  post: true
  activity: (     used[p+1] := true ; 
     if (G[p+1]->size() = 0) then     cnt := cnt + 1 ; else skip ; 
     for (i : G[p+1]) do (     if (not(used[i+1])) then     execute dfs(i) ; else skip ;  ) );
 class V extends Sequence(int) { }
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long K=scanner.nextLong();
    long n=1 ;
    double s=1.d ;
    for(long i=1 ; i<=K ; i++){
      long x=n ;
      long z=0 ;
      long y=1 ;
      while(x>0){
        x/=10 ;
        z=z*10+9 ;
        y*=10 ;
        long t=x*y+z ;
        double ts=sunuke(t);
        if(ts<s){
          n=t ;
          s=ts ;
        }
      }
      System.out.println(n);
      n++;
      s=sunuke(n);
    }
  }
  private static double sunuke(long n){
    return(double)n/sumDigits(n);
  }
  private static long sumDigits(long i){
    long sum=0 ;
    while(i>0){
      sum+=i % 10 ;
      i/=10 ;
    }
    return sum ;
  }
  private static long numDigits(long i){
    long d=0 ;
    while(i>0){
      d++;
      i/=10 ;
    }
    return d ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var K : long ; K := scanner.getCurrent()->toLong() ;
    var n : long ; n := 1 ;
    var s : double ; s := 1.d ;
        var i : long ; i := 1 ; while i <= K do ( (     var x : long ; x := n ;
     var z : long ; z := 0 ;
    var y : long ; y := 1 ;
    while (x > 0) do (     x := x/(10) ; 
     z := z * 10 + 9 ; 
    y := y*(10) ; 
    var t : long ; t := x * y + z ;
    var ts : double ; ts := sunuke(t) ;
    if (ts < s) then (     n := t ; 
     s := ts ) else skip ; 
 ) ; 
    OclFile["System.out"].println(n) ; 
    n := n + 1 ; 
    s := sunuke(n) ; 
 )  ;     i := i + 1 ) ; 
 );
  static   operation sunuke( n : long) : double
  pre: true
  post: true
  activity: (     return n->oclAsType(double) / sumDigits(n) );
  static   operation sumDigits( i : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     while (i > 0) do (     sum := sum+(i mod 10) ; 
     i := i/(10) ) ; 
     return sum );
  static   operation numDigits( i : long) : long
  pre: true
  post: true
  activity: (     var d : long ; d := 0 ;
     while (i > 0) do (     d := d + 1 ; 
     i := i/(10) ) ; 
     return d );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    long K=sc.nextLong();
    long ans=0 ;
    long add=1 ;
    PrintWriter pw=new PrintWriter(System.out);
    int cnt=0 ;
    while(cnt++<K){
      if((ans+add)*S(ans+add*10)>(ans+add*10)*S(ans+add))add=add*10 ;
      ans+=add ;
      pw.println(ans);
    }
    pw.close();
  }
  long S(long a){
    long ret=0 ;
    while(a>0){
      ret+=a % 10 ;
      a/=10 ;
    }
    return ret ;
  }
  static void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var K : long ; K := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
    var add : long ; add := 1 ;
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var cnt : int ; cnt := 0 ;
        while (cnt < K) do (        cnt := cnt + 1 ;     skip ; (     if ((ans + add) * S(ans + add * 10) > (ans + add * 10) * S(ans + add)) then     add := add * 10 ; else skip ; 
     ans := ans+(add) ; 
     skip ) ;  ) ;  
    skip ; 
 );
   operation S( a : long) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := 0 ;
     while (a > 0) do (     ret := ret+(a mod 10) ; 
     a := a/(10) ) ; 
     return ret );
  static   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public void main(Scanner sc){
    int k=sc.nextInt();
    long n=1 ;
    for(int i=0 ; i<k ; i++){
      System.out.println(n);
      n=next(n+1);
    }
  }
  private long next(long n){
    double min=Double.MAX_VALUE ;
    long minn=0 ;
    for(long tmp=1 ; tmp<=n ; tmp*=10){
      for(int i=(int)((n/tmp)% 10); i<=9 ; i++){
        long next=((n/tmp/10)*10+i)*tmp+(tmp-1);
        int s=s(next);
        if(min>(next*1.0/s)){
          min=(next*1.0/s);
          minn=next ;
        }
      }
    }
    return minn ;
  }
  private int s(long n){
    int wa=0 ;
    while(n!=0){
      wa+=n % 10 ;
      n/=10 ;
    }
    return wa ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    new Main().main(sc);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var k : int ; k := sc.nextInt() ;
     var n : long ; n := 1 ;
         var i : int ; i := 0 ; while i < k do ( (     OclFile["System.out"].println(n) ; 
     n := next(n + 1) )  ;     i := i + 1 ) );
   operation next( n : long) : long
  pre: true
  post: true
  activity: (     var min : double ; min := (2 - 2->pow(-52))*(2->pow(1023)) ;
     var minn : long ; minn := 0 ;
         var tmp : long ; tmp := 1 ; while tmp <= n do ( (         var i : int ; i := ((n / tmp) mod 10)->oclAsType(int) ; while i <= 9 do ( (     var next : long ; next := ((n / tmp / 10) * 10 + i) * tmp + (tmp - 1) ;
     var s : int ; s := s(next) ;
     if (min > (next * 1.0 / s)) then (     min := (next * 1.0 / s) ; 
     minn := next ) else skip )  ;     i := i + 1 ) )  ;     tmp := tmp*(10) ) ; 
     return minn );
   operation s( n : long) : int
  pre: true
  post: true
  activity: (     var wa : int ; wa := 0 ;
     while (n /= 0) do (     wa := wa+(n mod 10) ; 
     n := n/(10) ) ; 
     return wa );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Main.newMain().main(sc) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long K=Long.parseLong(sc.next());
    long ans=0 ;
    long ans1,ans2,s1,s2 ;
    long add=1 ;
    long count=0 ;
    boolean flag=true ;
    int times=9 ;
    while(count<K){
      ans1=ans+add ;
      s1=0 ;
      String a1=String.valueOf(ans1);
      for(int i=0 ; i<a1.length(); i++){
        s1+=Long.valueOf(String.valueOf(a1.charAt(i)));
      }
      ans2=ans1+add ;
      s2=0 ;
      String a2=String.valueOf(ans2);
      for(int i=0 ; i<a2.length(); i++){
        s2+=Long.valueOf(String.valueOf(a2.charAt(i)));
      }
      if(ans2*s1-ans1*s2<0){
        add*=10 ;
        flag=true ;
        continue ;
      }
      if(flag){
        times=9 ;
      }
      else {
        times=10 ;
      }
      String a=String.valueOf(ans+add);
      for(int i=0 ; i<times ; i++){
        ans+=add ;
        String ai=String.valueOf(ans);
        if(a.length()!=ai.length()){
          ans-=add ;
          break ;
        }
        System.out.println(ans);
        count++;
        if(count>=K){
          break ;
        }
      }
      flag=false ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var K : long ; K := (sc.getCurrent())->toLong() ;
    var ans : long ; ans := 0 ;
    var ans1 : long ;
    var ans2 : long ;
    var s1 : long ;
    var s2 : long ;
    var add : long ; add := 1 ;
    var count : long ; count := 0 ;
    var flag : boolean ; flag := true ;
    var times : int ; times := 9 ;
    while (count < K) do (     ans1 := ans + add ; 
     s1 := 0 ; 
    var a1 : String ; a1 := ((ans1) + "") ;
        var i : int ; i := 0 ; while i < a1->size() do ( (     s1 := s1+((((a1->at(i+1)) + ""))->toLong()) )  ;     i := i + 1 ) ; 
    ans2 := ans1 + add ; 
    s2 := 0 ; 
    var a2 : String ; a2 := ((ans2) + "") ;
        var i : int ; i := 0 ; while i < a2->size() do ( (     s2 := s2+((((a2->at(i+1)) + ""))->toLong()) )  ;     i := i + 1 ) ; 
    if (ans2 * s1 - ans1 * s2 < 0) then (     add := add*(10) ; 
     flag := true ; 
     continue ) else skip ; 
    if (flag) then (     times := 9 ) else (     times := 10 ) ;  
    var a : String ; a := ((ans + add) + "") ;
        var i : int ; i := 0 ; while i < times do ( (     ans := ans+(add) ; 
     var ai : String ; ai := ((ans) + "") ;
    if (a->size() /= ai->size()) then (     ans := ans-(add) ; 
     break ) else skip ; 
    OclFile["System.out"].println(ans) ; 
    count := count + 1 ; 
    if (count >= K) then (     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    flag := false ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedHashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long K=sc.nextLong();
    Set<Long>sunekeSet=new LinkedHashSet<>();
    for(long m=1 ; m<=10e15 ; m*=10){
      boolean sunukeCheckFlag=true ;
      for(int i=1 ; sunukeCheckFlag ; i++){
        long x=i*m+m-1 ;
        long y=(i+1)*m+m-1 ;
        if(x*Sn(y)<=y*Sn(x)){
          sunekeSet.add(x);
          if(K==sunekeSet.size()){
            sunekeSet.stream().forEach(System.out :: println);
            return ;
          }
        }
        else {
          sunukeCheckFlag=false ;
        }
      }
    }
  }
  public static long Sn(long num){
    long Sn=0 ;
    while(num!=0){
      Sn+=num % 10 ;
      num/=10 ;
    }
    return Sn ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var K : long ; K := sc.getCurrent()->toLong() ;
     var sunekeSet : Set(long) ; sunekeSet := Set{} ;
         var m : long ; m := 1 ; while m <= 10e15 do ( (     var sunukeCheckFlag : boolean ; sunukeCheckFlag := true ;
         var i : int ; i := 1 ; while sunukeCheckFlag do ( (     var x : long ; x := i * m + m - 1 ;
     var y : long ; y := (i + 1) * m + m - 1 ;
     if (x * Sn(y) <= y * Sn(x)) then (     sunekeSet := sunekeSet->including(x) ; 
     if (K = sunekeSet->size()) then (     for _forEach : sunekeSet do
    (    skip ;) ; 
     return ) else skip ) else (     sunukeCheckFlag := false ) )  ;     i := i + 1 ) )  ;     m := m*(10) ) );
  static   operation Sn( num : long) : long
  pre: true
  post: true
  activity: (     var Sn : long ; Sn := 0 ;
     while (num /= 0) do (     Sn := Sn+(num mod 10) ; 
     num := num/(10) ) ; 
     return Sn );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int t=1 ; t<=test ; t++){
      char ch[]=in.next().toCharArray();
      HashSet<Character>map=new HashSet<>();
      for(int i=0 ; i<ch.length ; i++){
        map.add(ch[i]);
      }
      if(ch.length!=map.size()){
        pw.println("No");
      }
      else {
        Arrays.sort(ch);
        boolean flag=true ;
        for(int i=1 ; i<ch.length ; i++){
          int sub=ch[i]-ch[i-1];
          if(sub!=1){
            flag=false ;
            break ;
          }
        }
        if(flag){
          pw.println("Yes");
        }
        else {
          pw.println("No");
        }
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= test do ( (     var ch : Sequence(String) ; ch := in.getCurrent()->characters() ;
     var map : Set(String) ; map := Set{} ;
         var i : int ; i := 0 ; while i < ch->size() do ( (     map := map->including(ch[i+1]) )  ;     i := i + 1 ) ; 
     if (ch->size() /= map->size()) then (     skip ) else (     ch := ch->sort() ; 
     var flag : boolean ; flag := true ;
         var i : int ; i := 1 ; while i < ch->size() do ( (     var sub : int ; sub := ch[i+1] - ch[i - 1+1] ;
     if (sub /= 1) then (     flag := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (flag) then (     skip ) else (     skip ) ) )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1144A_DiverseStrings {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=input.nextInt();
    while(test-->0){
      String str=input.next();
      LinkedList<Character>list=new LinkedList<>();
      for(char c : str.toCharArray()){
        list.add(c);
      }
      Collections.sort(list);
      char first=list.peekFirst();
      char last=list.peekLast();
      String sample="" ;
      for(char c=first ; c<=last ; c++){
        sample+=c ;
      }
      String real=list.toString().replaceAll("[\\[\\],] ","");
      if(sample.equals(real)){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1144A_DiverseStrings {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := input.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var str : String ; str := input.getCurrent() ;
     var list : Sequence(String) ; list := Sequence{} ;
    for (c : str->characters()) do ( (     list := list->including(c) )  ) ; 
    list := list->sort() ; 
    var first : String ; first := list.peekFirst() ;
    var last : String ; last := list.peekLast() ;
    var sample : String ; sample := "" ;
        var c : String ; c := first ; while c <= last do ( (     sample := sample+(c) )  ;     c := c + 1 ) ; 
    var real : String ; real := list+"".replaceAllMatches("[\\[\\],] ", "" ) ;
    if (sample = real) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t--!=0){
      int[] arr1=new int[26];
      String s=in.next();
      char[] arr=s.toCharArray();
      Arrays.sort(arr);
      int n=s.length();
      boolean flag=true ;
      for(int i=0 ; i<n ; i++){
        arr1[s.charAt(i)-'a']++;
        if(i>0){
          if(Math.abs(arr[i-1]-arr[i])!=1)flag=false ;
        }
      }
      for(int e : arr1){
        if(e>1){
          flag=false ;
          break ;
        }
      }
      System.out.println(flag ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,26)->collect(0) ;
     var s : String ; s := in.getCurrent() ;
    var arr : Sequence(String) ; arr := s->characters() ;
    arr := arr->sort() ; 
    var n : int ; n := s->size() ;
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < n do ( (     arr1[s->at(i+1) - ('a')->char2byte()+1] := arr1[s->at(i+1) - ('a')->char2byte()+1] + 1 ; 
     if (i > 0) then (     if (if arr[i - 1+1] - arr[i+1] < 0 then -(arr[i - 1+1] - arr[i+1]) else arr[i - 1+1] - arr[i+1] endif /= 1) then     flag := false ; else skip ) else skip )  ;     i := i + 1 ) ; 
    for (e : arr1) do ( (     if (e > 1) then (     flag := false ; 
     break ) else skip )  ) ; 
    OclFile["System.out"].println(if flag then "YES" else "NO" endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static int count(String s,char value){
    int cnt=0 ;
    for(int i=0 ; i<s.length(); i++)if(s.charAt(i)==value)cnt++;
    return cnt ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t1=sc.nextInt();
    while(t1-->0){
      String s=sc.next();
      char[] arr=s.toCharArray();
      Arrays.sort(arr);
      boolean check=true ;
      for(int i=1 ; i<arr.length ; i++){
        if(arr[i]!=arr[i-1]+1){
          check=false ;
          break ;
        }
      }
      if(check)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation count( s : String, value : String) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < s->size() do (     if (s->at(i+1) = value) then     cnt := cnt + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t1 : int ; t1 := sc.getCurrent()->toInteger() ;
         while (t1 > 0) do (        t1 := t1 - 1 ;     skip ; (     var s : String ; s := sc.getCurrent() ;
     var arr : Sequence(String) ; arr := s->characters() ;
    arr := arr->sort() ; 
    var check : boolean ; check := true ;
        var i : int ; i := 1 ; while i < arr->size() do ( (     if (arr[i+1] /= arr[i - 1+1] + 1) then (     check := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (check) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  private static BufferedReader br=null ;
  public static void main(String[] args){
    br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      try {
        String line=null ;
        String[] lines=null ;
        line=br.readLine();
        lines=line.split(" ");
        int N=Integer.parseInt(lines[0]);
        int K=Integer.parseInt(lines[1]);
        if(N==0 && K==0){
          return ;
        }
        line=br.readLine();
        lines=line.split(" ");
        int[] bloodAmt=new int[K];
        for(int i=0 ; i<K ; i++){
          bloodAmt[i]=Integer.parseInt(lines[i]);
        }
        for(int i=0 ; i<N ; i++){
          line=br.readLine();
          lines=line.split(" ");
          for(int j=0 ; j<K ; j++){
            bloodAmt[j]-=Integer.parseInt(lines[j]);
          }
        }
        for(int i=0 ; i<K ; i++){
          if(bloodAmt[i]<0){
            System.out.println("No");
            break ;
          }
          if(i==K-1){
            System.out.println("Yes");
          }
        }
      }
      catch(Exception e){
        e.printStackTrace();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     while (true) do (     try (     var line : String ; line := null ;
     var lines : Sequence(String) ; lines := null ;
    line := br.readLine() ; 
    lines := line->split(" ") ; 
    var N : int ; N := (lines[0+1])->toInteger() ;
    var K : int ; K := (lines[1+1])->toInteger() ;
    if (N = 0 & K = 0) then (     return ) else skip ; 
    line := br.readLine() ; 
    lines := line->split(" ") ; 
    var bloodAmt : Sequence(int) ; bloodAmt := Integer.subrange(1,K)->collect(0) ;
        var i : int ; i := 0 ; while i < K do ( (     bloodAmt[i+1] := (lines[i+1])->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     line := br.readLine() ; 
     lines := line->split(" ") ; 
         var j : int ; j := 0 ; while j < K do ( (     bloodAmt[j+1] := bloodAmt[j+1]-((lines[j+1])->toInteger()) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < K do ( (     if (bloodAmt[i+1] < 0) then (     OclFile["System.out"].println("No") ; 
     break ) else skip ; 
     if (i = K - 1) then (     OclFile["System.out"].println("Yes") ) else skip )  ;     i := i + 1 ) ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MainClass {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    st=new StringTokenizer(br.readLine());
    String t=st.nextToken();
    String s="" ;
    int i=0,j=0 ;
    while(i<t.length()){
      s+=t.charAt(i);
      j++;
      i+=j ;
    }
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    var t : String ; t := st.next() ;
    var s : String ; s := "" ;
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    while (i < t->size()) do (     s := s+(t->at(i+1)) ; 
     j := j + 1 ; 
     i := i+(j) ) ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static HashMap<String,ArrayList<String>>map ;
  static HashSet<String>done ;
  public static void main(String[] args){
    while(true){
      int N=sc.nextInt();
      if(N==0)break ;
      sc.nextLine();
      String firstGroup=null ;
      map=new HashMap<String,ArrayList<String>>();
      done=new HashSet<String>();
      for(int i=0 ; i<N ; ++i){
        String[] elems=sc.nextLine().split(":|,|\\.");
        ArrayList<String>member=new ArrayList<String>();
        for(int j=1 ; j<elems.length ; ++j){
          member.add(elems[j]);
        }
        map.put(elems[0],member);
        if(i==0)firstGroup=elems[0];
      }
      HashSet<String>set=new HashSet<String>();
      get(set,firstGroup);
      System.out.println(set.size());
    }
  }
  static void get(HashSet<String>set,String name){
    if(done.contains(name))return ;
    if(map.containsKey(name)){
      for(String c : map.get(name)){
        get(set,c);
      }
    }
    else {
      set.add(name);
    }
    done.add(name);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute map : Map(String,Sequence(String));
  static   attribute done : Set(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then     break else skip ; 
    skip ; 
    var firstGroup : String ; firstGroup := null ;
    map := Map{} ; 
    done := Set{} ; 
        var i : int ; i := 0 ; while i < N do ( (     var elems : Sequence(String) ; elems := sc.nextLine()->split(":|,|\\.") ;
     var member : Sequence(String) ; member := Sequence{} ;
        var j : int ; j := 1 ; while j < elems->size() do ( (     member := member->including(elems[j+1]) )  ;     j := j + 1 ) ; 
    map := map->union(Map{elems[0+1] |-> member}) ; 
    if (i = 0) then     firstGroup := elems[0+1] ; else skip ; 
 )  ;     i := i + 1 ) ; 
    var set : Set(String) ; set := Set{} ;
    execute get(set, firstGroup) ; 
    OclFile["System.out"].println(set->size()) ; 
 ) );
  static   operation get( set : Set(String), name : String) : void
  pre: true
  post: true
  activity: (     if (done->includes(name)) then     return else skip ; 
     if (map->keys()->includes(name)) then (     for (c : map->at(name)) do ( (     execute get(set, c) )  ) ) else (     set := set->including(name) ) ;  
     done := done->including(name) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String input=sc.next();
    String str="" ;
    int i=0 ;
    int m=1 ;
    while(i<n){
      str+=input.charAt(i);
      m++;
      i+=m ;
    }
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var input : String ; input := sc.getCurrent() ;
    var str : String ; str := "" ;
    var i : int ; i := 0 ;
    var m : int ; m := 1 ;
    while (i < n) do (     str := str+(input->at(i+1)) ; 
     m := m + 1 ; 
     i := i+(m) ) ; 
    OclFile["System.out"].println(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test266 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    char x[]=in.next().toCharArray();
    for(int i=0,a=1 ; i<n ; a+=1,i+=a){
      System.out.print(x[i]);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test266 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var x : Sequence(String) ; x := in.getCurrent()->characters() ;
        var i : int ; i := 0 ;
    var a : int ; a := 1 ; while i < n do ( (     OclFile["System.out"].print(x[i+1]) )  ;     a := a+(1) ;     i := i+(a) ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Repeating {
  int number ;
  public Repeating(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  public void input(String s){
    int count=1 ;
    for(int i=0 ; i<getNumber(); i+=count){
      System.out.print(s.charAt(i));
      count++;
    }
    System.out.println();
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    Repeating instance=new Repeating(number);
    String s=input.next();
    instance.input(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Repeating {
   attribute number : int;
   static operation newRepeating( number : int) : Repeating
  pre: true
  post: true
  activity:
  ( var self : Repeating ;
    self := createRepeating();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
   operation input( s : String) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 1 ;
         var i : int ; i := 0 ; while i < getNumber() do ( (     OclFile["System.out"].print(s->at(i+1)) ; 
     count := count + 1 )  ;     i := i+(count) ) ; 
     OclFile["System.out"].println() );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
    var instance : Repeating ; instance := Repeating.newRepeating(number) ;
    var s : String ; s := input.getCurrent() ;
    instance.input(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CP29 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    sc.nextLine();
    String l=sc.nextLine();
    String ans="" ;
    int k=0,j=0,i=0 ;
    while(i<l.length()){
      ans=ans+""+l.charAt(i);
      k=j+1 ;
      j++;
      i+=k ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CP29 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
    var l : String ; l := sc.nextLine() ;
    var ans : String ; ans := "" ;
    var k : int ; k := 0 ;
    var j : int ; j := 0 ;
    var i : int ; i := 0 ;
    while (i < l->size()) do (     ans := ans + "" + l->at(i+1) ; 
     k := j + 1 ; 
     j := j + 1 ; 
     i := i+(k) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    TreeSet<Integer>set=new TreeSet<>();
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      set.add(Integer.parseInt(in.next()));
    }
    int m=in.nextInt();
    for(int i=0 ; i<m ; i++){
      int obj=Integer.parseInt(in.next());
      if(set.contains(obj))set.remove(obj);
      else set.add(obj);
    }
    PrintWriter out=new PrintWriter(System.out);
    Iterator<Integer>itr=set.iterator();
    while(itr.hasNext()){
      out.println(itr.next());
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var set : Set(int) ; set := Set{} ;
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     set := set->including((in.getCurrent())->toInteger()) )  ;     i := i + 1 ) ; 
    var m : int ; m := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     var obj : int ; obj := (in.getCurrent())->toInteger() ;
     if (set->includes(obj)) then     set := set->excludingAt(obj+1) ; else     set := set->including(obj) ; )  ;     i := i + 1 ) ; 
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var itr : OclIterator ; itr := set->iterator() ;
    while (itr.hasNext()) do (     skip ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeSet ;
class Main {
  public static void main(String[] args){
    Set<Long>setA=new TreeSet<Long>();
    Set<Long>setB=new TreeSet<Long>();
    try(Scanner sc=new Scanner(System.in)){
      int times=sc.nextInt();
      for(int i=0 ; i<times ; i++)setA.add(sc.nextLong());
      times=sc.nextInt();
      for(int i=0 ; i<times ; i++)setB.add(sc.nextLong());
      ArrayList<Long>a=new ArrayList<Long>(setB);
      for(int i=0 ; i<times ; i++){
        Long l=a.get(i);
        boolean check=setA.contains(l);
        if(check)setA.remove(l);
        else setA.add(l);
      }
      a=new ArrayList<Long>(setA);
      for(int i=0 ; i<a.size(); i++)System.out.println(a.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var setA : Set(long) ; setA := Set{} ;
     var setB : Set(long) ; setB := Set{} ;
     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var times : int ; times := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < times do (     setA := setA->including(sc.getCurrent()->toLong()) ;  ;     i := i + 1 ) ; 
    times := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < times do (     setB := setB->including(sc.getCurrent()->toLong()) ;  ;     i := i + 1 ) ; 
    var a : Sequence(long) ; a := Sequence{}->union(setB) ;
        var i : int ; i := 0 ; while i < times do ( (     var l : long ; l := a->at(i+1) ;
     var check : boolean ; check := setA->includes(l) ;
     if (check) then     setA := setA->excludingAt(l+1) ; else     setA := setA->including(l) ; )  ;     i := i + 1 ) ; 
    a := Sequence{}->union(setA) ; 
        var i : int ; i := 0 ; while i < a->size() do (     OclFile["System.out"].println(a->at(i+1)) ;  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=stdIn.nextInt();
    }
    int m=stdIn.nextInt();
    int num[]=new int[n+m];
    for(int i=0 ; i<n+m ; i++){
      if(i<n){
        num[i]=a[i];
      }
      else {
        num[i]=stdIn.nextInt();
      }
    }
    Arrays.sort(num);
    for(int i=0 ; i<n+m ; i++){
      if(i==0){
        if(num[i]!=num[i+1]){
          System.out.println(num[i]);
        }
      }
      else if(i==n+m-1){
        if(num[i-1]!=num[i]){
          System.out.println(num[i]);
        }
      }
      else {
        if(num[i-1]!=num[i] && num[i]!=num[i+1]){
          System.out.println(num[i]);
        }
      }
    }
    stdIn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := stdIn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := stdIn.getCurrent()->toInteger() ;
    var num : Sequence(int) ; num := Integer.subrange(1,n + m)->collect(0) ;
        var i : int ; i := 0 ; while i < n + m do ( (     if (i < n) then (     num[i+1] := a[i+1] ) else (     num[i+1] := stdIn.getCurrent()->toInteger() ) )  ;     i := i + 1 ) ; 
    num := num->sort() ; 
        var i : int ; i := 0 ; while i < n + m do ( (     if (i = 0) then (     if (num[i+1] /= num[i + 1+1]) then (     OclFile["System.out"].println(num[i+1]) ) else skip ) else     if (i = n + m - 1) then (     if (num[i - 1+1] /= num[i+1]) then (     OclFile["System.out"].println(num[i+1]) ) else skip ) else (     if (num[i - 1+1] /= num[i+1] & num[i+1] /= num[i + 1+1]) then (     OclFile["System.out"].println(num[i+1]) ) else skip ) ;  )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    TreeSet<Integer>set=new TreeSet<>();
    int a=scan.nextInt();
    for(int i=0 ; i<a ; i++){
      int num=scan.nextInt();
      set.add(num);
    }
    TreeSet<Integer>set2=new TreeSet<>();
    int b=scan.nextInt();
    for(int i=0 ; i<b ; i++){
      int num=scan.nextInt();
      set2.add(num);
    }
    TreeSet<Integer>symDiff=new TreeSet<>(set);
    symDiff.addAll(set2);
    TreeSet<Integer>tmp=new TreeSet<>(set);
    tmp.retainAll(set2);
    symDiff.removeAll(tmp);
    for(int i : symDiff){
      System.out.println(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var set : Set(int) ; set := Set{} ;
    var a : int ; a := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < a do ( (     var num : int ; num := scan.getCurrent()->toInteger() ;
     set := set->including(num) )  ;     i := i + 1 ) ; 
    var set2 : Set(int) ; set2 := Set{} ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < b do ( (     var num : int ; num := scan.getCurrent()->toInteger() ;
     set2 := set2->including(num) )  ;     i := i + 1 ) ; 
    var symDiff : Set(int) ; symDiff := Set{}->union(set) ;
    symDiff := symDiff->union(set2) ; 
    var tmp : Set(int) ; tmp := Set{}->union(set) ;
    tmp := tmp->intersection(set2) ; 
    symDiff := symDiff - tmp ; 
    for (i : symDiff) do ( (     OclFile["System.out"].println(i) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      int k=scanner.nextInt();
      if((n | k)==0)break ;
      int[] num=new int[k];
      for(int i=0 ; i<k ; i++)num[i]=scanner.nextInt();
      String ans="Yes" ;
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<k ; j++){
        int a=scanner.nextInt();
        num[j]-=a ;
        if(num[j]<0)ans="No" ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var k : int ; k := scanner.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,k)) = 0) then     break else skip ; 
    var num : Sequence(int) ; num := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do (     num[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : String ; ans := "Yes" ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < k do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     num[j+1] := num[j+1]-(a) ; 
     if (num[j+1] < 0) then     ans := "No" ; else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] str=br.readLine().split(" ");
    Set<Integer>S=new TreeSet<Integer>();
    for(int i=0 ; i<n ; i++){
      S.add(Integer.parseInt(str[i]));
    }
    int m=Integer.parseInt(br.readLine());
    str=br.readLine().split(" ");
    for(int i=0 ; i<m ; i++){
      int b=Integer.parseInt(str[i]);
      if(S.contains(b))S.remove(b);
      else S.add(b);
    }
    for(Integer num : S)System.out.println(num);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var S : Set(int) ; S := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     S := S->including((str[i+1])->toInteger()) )  ;     i := i + 1 ) ; 
    var m : int ; m := (br.readLine())->toInteger() ;
    str := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < m do ( (     var b : int ; b := (str[i+1])->toInteger() ;
     if (S->includes(b)) then     S := S->excludingAt(b+1) ; else     S := S->including(b) ; )  ;     i := i + 1 ) ; 
    for (num : S) do (     OclFile["System.out"].println(num) ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int minimumChanges(int n,int a[]){
    int i ;
    int[] sf=new int[n+1];
    sf[n]=0 ;
    for(i=n-1 ; i>=0 ; i--){
      sf[i]=sf[i+1];
      if(a[i]<=0)sf[i]++;
    }
    int pos=0 ;
    int mn=n ;
    for(i=0 ; i<n-1 ; i++){
      if(a[i]>=0)pos++;
      mn=Math.min(mn,pos+sf[i+1]);
    }
    return mn ;
  }
  public static void main(String[] args){
    int[] a={
-1,-2,-3,3,-5,3,4 };
      int n=a.length ;
      System.out.println(minimumChanges(n,a));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumChanges( n : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var i : int ;
     var sf : Sequence(int) ; sf := Integer.subrange(1,n + 1)->collect(0) ;
    sf[n+1] := 0 ; 
        i := n - 1 ; while i >= 0 do ( (     sf[i+1] := sf[i + 1+1] ; 
     if (a[i+1] <= 0) then     sf[i+1] := sf[i+1] + 1 ; else skip )  ;     i := i - 1 ) ; 
    var pos : int ; pos := 0 ;
    var mn : int ; mn := n ;
        i := 0 ; while i < n - 1 do ( (     if (a[i+1] >= 0) then     pos := pos + 1 ; else skip ; 
     mn := Set{mn, pos + sf[i + 1+1]}->min() )  ;     i := i + 1 ) ; 
    return mn 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{-1,-2,-3,3,-5,3,4} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(minimumChanges(n, a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void decToBinary(int n){
    int[] binaryNum=new int[32];
    int i=0 ;
    while(n>0){
      binaryNum[i]=n % 2 ;
      n=n/2 ;
      i++;
    }
    for(int j=i-1 ; j>=0 ; j--)System.out.print(binaryNum[j]);
  }
  public static void main(String[] args){
    int n=17 ;
    decToBinary(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation decToBinary( n : int) : void
  pre: true
  post: true
  activity: (     var binaryNum : Sequence(int) ; binaryNum := Integer.subrange(1,32)->collect(0) ;
     var i : int ; i := 0 ;
     while (n > 0) do (     binaryNum[i+1] := n mod 2 ; 
     n := n / 2 ; 
     i := i + 1 ) ; 
         var j : int ; j := i - 1 ; while j >= 0 do (     OclFile["System.out"].print(binaryNum[j+1]) ;  ;     j := j - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 17 ;
     execute decToBinary(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printSubArray(int arr[],int start,int end){
    System.out.print("[");
    for(int i=start ; i<=end ; i++)System.out.print(arr[i]+" ");
    System.out.print("] ");
  }
  static boolean divideArray(int arr[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=arr[i];
    int sum_so_far=0 ;
    for(int i=0 ; i<n ; i++){
      if(2*sum_so_far+arr[i]==sum){
        System.out.print("The array can be divided into "+"two subarrays with equal sum\nThe"+" two subarrays are-");
        printSubArray(arr,0,i-1);
        printSubArray(arr,i+1,n-1);
        return true ;
      }
      sum_so_far+=arr[i];
    }
    System.out.println("The array cannot be divided into two "+"subarrays with equal sum");
    return false ;
  }
  public static void main(String[] args){
    int arr[]={
      6,2,3,2,1 };
      int n=arr.length ;
      divideArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printSubArray( arr : Sequence(int), start : int, end : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("[") ; 
         var i : int ; i := start ; while i <= end do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("] ") );
  static   operation divideArray( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    var sum_so_far : int ; sum_so_far := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (2 * sum_so_far + arr[i+1] = sum) then (     OclFile["System.out"].print("The array can be divided into " + "two subarrays with equal sum\nThe" + " two subarrays are-") ; 
     execute printSubArray(arr, 0, i - 1) ; 
     execute printSubArray(arr, i + 1, n - 1) ; 
     return true ) else skip ; 
     sum_so_far := sum_so_far+(arr[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("The array cannot be divided into two " + "subarrays with equal sum") ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,2,3,2,1} ;
     var n : int ; n := arr->size() ;
     execute divideArray(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DreamonAndRankingCollection {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    while(test-->0){
      int n=sc.nextInt();
      int x=sc.nextInt();
      int[] nums=new int[n];
      for(int i=0 ; i<n ; i++){
        nums[i]=sc.nextInt();
      }
      System.out.println(findLargestV(nums,n,x));
    }
  }
  private static int findLargestV(int[] nums,int n,int x){
    int max=findMax(nums);
    boolean[] visited=new boolean[max+x+1];
    int result=0 ;
    for(int num : nums){
      visited[num]=true ;
    }
    for(result=1 ; result<visited.length ; result++){
      if(visited[result]){
        continue ;
      }
      else if(! visited[result] && x>0){
        visited[result]=true ;
        x--;
      }
      else if(! visited[result] && x<=0){
        break ;
      }
    }
    return result-1 ;
  }
  private static int findMax(int[] nums){
    int max=Integer.MIN_VALUE ;
    for(int num : nums){
      max=Math.max(max,num);
    }
    return max ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class DreamonAndRankingCollection {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(findLargestV(nums, n, x)) ; 
 ) ;  ) );
  static   operation findLargestV( nums : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var max : int ; max := findMax(nums) ;
     var visited : Sequence(boolean) ; visited := Integer.subrange(1,max + x + 1)->collect(false) ;
    var result : int ; result := 0 ;
    for (num : nums) do ( (     visited[num+1] := true )  ) ; 
        result := 1 ; while result < visited->size() do ( (     if (visited[result+1]) then (     continue ) else     if (not(visited[result+1]) & x > 0) then (     visited[result+1] := true ; 
     x := x - 1 ) else     if (not(visited[result+1]) & x <= 0) then (     break ) else skip ; ;  )  ;     result := result + 1 ) ; 
    return result - 1 
 );
  static   operation findMax( nums : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var max : int ; max := -2147483648 ;
     for (num : nums) do ( (     max := Set{max, num}->max() )  ) ; 
     return max );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int x=sc.nextInt();
      boolean[] arr=new boolean[201];
      for(int i=1 ; i<=n+x ; i++)arr[i]=false ;
      for(int i=0 ; i<n ; i++){
        int rank=sc.nextInt();
        arr[rank]=true ;
      }
      for(int i=n+x ; i>0 ; i--){
        int v=0 ;
        for(int j=1 ; j<=i ; j++){
          if(! arr[j])v++;
        }
        if(v<=x){
          System.out.println(i);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var arr : Sequence(boolean) ; arr := Integer.subrange(1,201)->collect(false) ;
        var i : int ; i := 1 ; while i <= n + x do (     arr[i+1] := false ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var rank : int ; rank := sc.getCurrent()->toInteger() ;
     arr[rank+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := n + x ; while i > 0 do ( (     var v : int ; v := 0 ;
         var j : int ; j := 1 ; while j <= i do ( (     if (not(arr[j+1])) then     v := v + 1 ; else skip )  ;     j := j + 1 ) ; 
     if (v <= x) then (     OclFile["System.out"].println(i) ; 
     break ) else skip )  ;     i := i - 1 ) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      int a=sc.nextInt();
      Set<Integer>s=new HashSet<>();
      for(int i=0 ; i<n ; i++){
        s.add(sc.nextInt());
      }
      int cnt=1 ;
      while(a>=0){
        if(s.contains(cnt)){
          cnt++;
        }
        else {
          a--;
          if(a<0)break ;
          cnt++;
        }
      }
      System.out.println(cnt-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var s : Set(int) ; s := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     s := s->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 1 ;
    while (a >= 0) do (     if (s->includes(cnt)) then (     cnt := cnt + 1 ) else (     a := a - 1 ; 
     if (a < 0) then     break else skip ; 
     cnt := cnt + 1 ) ) ; 
    OclFile["System.out"].println(cnt - 1) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findGeometricTriplets(int arr[],int n){
    for(int j=1 ; j<n-1 ; j++){
      int i=j-1,k=j+1 ;
      while(i>=0 && k<=n-1){
        while(i>=0 && arr[j] % arr[i]==0 && arr[k] % arr[j]==0 && arr[j]/arr[i]==arr[k]/arr[j]){
          System.out.println(arr[i]+" "+arr[j]+" "+arr[k]);
          k++;
          i--;
        }
        if(i>=0 && arr[j] % arr[i]==0 && arr[k] % arr[j]==0){
          if(i>=0 && arr[j]/arr[i]<arr[k]/arr[j])i--;
          else k++;
        }
        else if(i>=0 && arr[j] % arr[i]==0)k++;
        else i--;
      }
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,2,4,16 };
      int n=arr.length ;
      findGeometricTriplets(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findGeometricTriplets( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var j : int ; j := 1 ; while j < n - 1 do ( (     var i : int ; i := j - 1 ;
    var k : int ; k := j + 1 ;
     while (i >= 0 & k <= n - 1) do (     while (i >= 0 & arr[j+1] mod arr[i+1] = 0 & arr[k+1] mod arr[j+1] = 0 & arr[j+1] / arr[i+1] = arr[k+1] / arr[j+1]) do (     OclFile["System.out"].println(arr[i+1] + " " + arr[j+1] + " " + arr[k+1]) ; 
     k := k + 1 ; 
     i := i - 1 ) ; 
     if (i >= 0 & arr[j+1] mod arr[i+1] = 0 & arr[k+1] mod arr[j+1] = 0) then (     if (i >= 0 & arr[j+1] / arr[i+1] < arr[k+1] / arr[j+1]) then     i := i - 1 ; else     k := k + 1 ; ) else     if (i >= 0 & arr[j+1] mod arr[i+1] = 0) then     k := k + 1 else     i := i - 1 ; ;  ) )  ;     j := j + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,4,16} ;
     var n : int ; n := arr->size() ;
     execute findGeometricTriplets(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class InnaAndAlarmClock {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] x=new int[101];
    int[] y=new int[101];
    for(int i=0 ; i<n ; i++){
      int tempX=sc.nextInt();
      int tempY=sc.nextInt();
      x[tempX]++;
      y[tempY]++;
    }
    int xCounter=0 ;
    int yCounter=0 ;
    for(int i=0 ; i<101 ; i++){
      if(x[i]>0)xCounter++;
      if(y[i]>0)yCounter++;
    }
    System.out.println(Math.min(xCounter,yCounter));
  }
}
------------------------------------------------------------
OCL File:
---------
 class InnaAndAlarmClock {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,101)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,101)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var tempX : int ; tempX := sc.getCurrent()->toInteger() ;
     var tempY : int ; tempY := sc.getCurrent()->toInteger() ;
     x[tempX+1] := x[tempX+1] + 1 ; 
     y[tempY+1] := y[tempY+1] + 1 )  ;     i := i + 1 ) ; 
    var xCounter : int ; xCounter := 0 ;
    var yCounter : int ; yCounter := 0 ;
        var i : int ; i := 0 ; while i < 101 do ( (     if (x[i+1] > 0) then     xCounter := xCounter + 1 ; else skip ; 
     if (y[i+1] > 0) then     yCounter := yCounter + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{xCounter, yCounter}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class InnaAndAlarmClock {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] x=new int[101];
    int[] y=new int[101];
    for(int i=0 ; i<n ; i++){
      int tempX=sc.nextInt();
      int tempY=sc.nextInt();
      x[tempX]++;
      y[tempY]++;
    }
    sc.close();
    int xCounter=0 ;
    int yCounter=0 ;
    for(int i=0 ; i<101 ; i++){
      if(x[i]>0)xCounter++;
      if(y[i]>0)yCounter++;
    }
    System.out.println(Math.min(xCounter,yCounter));
  }
}
------------------------------------------------------------
OCL File:
---------
 class InnaAndAlarmClock {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,101)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,101)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var tempX : int ; tempX := sc.getCurrent()->toInteger() ;
     var tempY : int ; tempY := sc.getCurrent()->toInteger() ;
     x[tempX+1] := x[tempX+1] + 1 ; 
     y[tempY+1] := y[tempY+1] + 1 )  ;     i := i + 1 ) ; 
    skip ; 
    var xCounter : int ; xCounter := 0 ;
    var yCounter : int ; yCounter := 0 ;
        var i : int ; i := 0 ; while i < 101 do ( (     if (x[i+1] > 0) then     xCounter := xCounter + 1 ; else skip ; 
     if (y[i+1] > 0) then     yCounter := yCounter + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{xCounter, yCounter}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  static Scanner s ;
  public static void main(String args[]){
    s=new Scanner(System.in);
    try {
      while(true){
        int n=s.nextInt();
        int k=s.nextInt();
        if(n+k==0)return ;
        System.out.println(solve(n,k));
      }
    }
    catch(Exception e){
      System.err.println(e);
    }
  }
  static String solve(int n,int k){
    int supply_array[]=new int[k];
    int demand_matrix[][]=new int[n][k];
    for(int i=0 ; i<k ; i++){
      supply_array[i]=s.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<k ; j++){
        demand_matrix[i][j]=s.nextInt();
      }
    }
    for(int i=0 ; i<k ; i++){
      int demand_sum=0 ;
      for(int j=0 ; j<n ; j++){
        demand_sum+=demand_matrix[j][i];
      }
      if(demand_sum>supply_array[i])return "No" ;
    }
    return "Yes" ;
  }
  static void print(int a[]){
    for(int i=0 ; i<a.length ; i++){
      System.out.print(a[i]+"\t");
    }
    System.out.println();
  }
  static void print(int m[][]){
    for(int i=0 ; i<m.length ; i++){
      for(int j=0 ; j<m[i] .length ; j++){
        System.out.print(m[i][j]+"\t");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     s := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     try (     while (true) do (     var n : int ; n := s.getCurrent()->toInteger() ;
     var k : int ; k := s.getCurrent()->toInteger() ;
     if (n + k = 0) then     return else skip ; 
     OclFile["System.out"].println(solve(n, k)) ) )   catch (e : ProgramException) do (     OclFile["System.err"].println(e) )
 );
  static   operation solve( n : int, k : int) : String
  pre: true
  post: true
  activity: (     var supply_array : Sequence(int) ; supply_array := Integer.subrange(1,k)->collect(0) ;
     var demand_matrix : Sequence(Sequence(int)) ; demand_matrix := Integer.subrange(1,n)->collect(Integer.subrange(1,k)->collect(0)) ;
        var i : int ; i := 0 ; while i < k do ( (     supply_array[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < k do ( (     demand_matrix[i+1][j+1] := s.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do ( (     var demand_sum : int ; demand_sum := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     demand_sum := demand_sum+(demand_matrix[j+1][i+1]) )  ;     j := j + 1 ) ; 
     if (demand_sum > supply_array[i+1]) then     return "No" else skip )  ;     i := i + 1 ) ; 
    return "Yes" 
 );
  static   operation print( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < a->size() do ( (     OclFile["System.out"].print(a[i+1] + "\t") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation print( m : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < m->size() do ( (         var j : int ; j := 0 ; while j < m[i+1]->size() do ( (     OclFile["System.out"].print(m[i+1][j+1] + "\t") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class cp {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    Set<Integer>x=new HashSet<Integer>();
    Set<Integer>y=new HashSet<Integer>();
    for(int i=0 ; i<n ; i++){
      int a=scn.nextInt();
      int b=scn.nextInt();
      x.add(a);
      y.add(b);
    }
    System.out.println(Math.min(x.size(),y.size()));
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var x : Set(int) ; x := Set{} ;
    var y : Set(int) ; y := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scn.getCurrent()->toInteger() ;
     var b : int ; b := scn.getCurrent()->toInteger() ;
     x := x->including(a) ; 
     y := y->including(b) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{x->size(), y->size()}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSubstrs(String str,int i,int j,int n){
    if(n==1)return 1 ;
    if(n<=0)return 0 ;
    int res=countSubstrs(str,i+1,j,n-1)+countSubstrs(str,i,j-1,n-1)-countSubstrs(str,i+1,j-1,n-2);
    if(str.charAt(i)==str.charAt(j))res++;
    return res ;
  }
  public static void main(String[] args){
    String str="abcab" ;
    int n=str.length();
    System.out.print(countSubstrs(str,0,n-1,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSubstrs( str : String, i : int, j : int, n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 1 else skip ; 
     if (n <= 0) then     return 0 else skip ; 
    var res : int ; res := countSubstrs(str, i + 1, j, n - 1) + countSubstrs(str, i, j - 1, n - 1) - countSubstrs(str, i + 1, j - 1, n - 2) ;
    if (str->at(i+1) = str->at(j+1)) then     res := res + 1 ; else skip ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abcab" ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].print(countSubstrs(str, 0, (n)->char2byte() - 1, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  static double PI=3.14159265 ;
  public static double area_cicumscribed(double a){
    return(a*a*(PI/3));
  }
  public static void main(String[] args){
    double a=6.0 ;
    System.out.println("Area of circumscribed circle is :"+area_cicumscribed(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute PI : double := 3.14159265;
  static   operation area_cicumscribed( a : double) : double
  pre: true
  post: true
  activity: (     return (a * a * (PI / 3)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 6.0 ;
     OclFile["System.out"].println("Area of circumscribed circle is :" + area_cicumscribed(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static void alternate(int a,int b,int x){
    x=a+b-x ;
    System.out.println("After change"+"\n"+" x is : "+x);
  }
  public static void main(String args[]){
    int a=-10 ;
    int b=15 ;
    int x=a ;
    System.out.println("x is : "+x);
    alternate(a,b,x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation alternate( a : int, b : int, x : int) : void
  pre: true
  post: true
  activity: (     x := a + b - x ; 
     OclFile["System.out"].println("After change" + "\n" + " x is : " + x) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := -10 ;
     var b : int ; b := 15 ;
    var x : int ; x := a ;
    OclFile["System.out"].println("x is : " + x) ; 
    execute alternate(a, b, x) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int __gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static int Parts(int Arr[],int N){
    int factor=Arr[1]-Arr[0];
    for(int i=2 ; i<N ; i++){
      factor=__gcd(factor,Arr[i]-Arr[i-1]);
    }
    factor=__gcd(factor,360-Arr[N-1]+Arr[0]);
    int cuts=(360/factor)-N ;
    return cuts ;
  }
  public static void main(String[] args){
    int Arr[]={
      0,1 };
      int N=Arr.length ;
      System.out.println(Parts(Arr,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
    if (a = b) then     return a else skip ; 
    if (a > b) then     return __gcd(a - b, b) else skip ; 
    return __gcd(a, b - a) 
 );
  static   operation Parts( Arr : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var factor : int ; factor := Arr[1+1] - Arr[0+1] ;
         var i : int ; i := 2 ; while i < N do ( (     factor := __gcd(factor, Arr[i+1] - Arr[i - 1+1]) )  ;     i := i + 1 ) ; 
    factor := __gcd(factor, 360 - Arr[N - 1+1] + Arr[0+1]) ; 
    var cuts : int ; cuts := (360 / factor) - N ;
    return cuts 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Arr : Sequence(int) ; Arr := Sequence{0,1} ;
     var N : int ; N := Arr->size() ;
     OclFile["System.out"].println(Parts(Arr, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    String t ;
    double[] p=new double[12];
    double s,r ;
    while((t=bf.readLine())!=null){
      String[] d=t.split(",");
      for(int i=0 ; i<8 ; i++)p[i]=Double.parseDouble(d[i]);
      for(int i=0 ; i<4 ; i++)p[i+8]=p[i];
      s=((p[3]-p[1])*(p[2]-p[4])-(p[2]-p[0])*(p[3]-p[5]));
      for(int i=4 ; i<=8 ; i+=2){
        r=((p[i+1]-p[i-1])*(p[i]-p[i+2])-(p[i]-p[i-2])*(p[i+1]-p[i+3]));
        if(s*r<0){
          System.out.println("NO");
          break ;
        }
        if(i==8)System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : String ;
    var p : Sequence(double) ; p := Integer.subrange(1,12)->collect(0.0) ;
    var s : double ;
    var r : double ;
        t := bf.readLine() ;
    while ((t) /= null) do (    skip ; (     var d : Sequence(String) ; d := t->split(",") ;
         var i : int ; i := 0 ; while i < 8 do (     p[i+1] := (d[i+1])->toReal() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 4 do (     p[i + 8+1] := p[i+1] ;  ;     i := i + 1 ) ; 
    s := ((p[3+1] - p[1+1]) * (p[2+1] - p[4+1]) - (p[2+1] - p[0+1]) * (p[3+1] - p[5+1])) ; 
        var i : int ; i := 4 ; while i <= 8 do ( (     r := ((p[i + 1+1] - p[i - 1+1]) * (p[i+1] - p[i + 2+1]) - (p[i+1] - p[i - 2+1]) * (p[i + 1+1] - p[i + 3+1])) ; 
     if (s * r < 0) then (     OclFile["System.out"].println("NO") ; 
     break ) else skip ; 
     if (i = 8) then     OclFile["System.out"].println("YES") ; else skip )  ;     i := i+(2) ) ; 
 ) ;     t := bf.readLine() ;
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  void run(){
    sc=new Scanner(System.in);
    for(; sc.hasNext(); ){
      String[] s=sc.nextLine().split(",");
      double[] x=new double[4];
      double[] y=new double[4];
      for(int i=0 ; i<4 ; i++){
        x[i]=Double.parseDouble(s[i*2]);
        y[i]=Double.parseDouble(s[i*2+1]);
      }
      boolean f=true ;
      int[] signs=new int[4];
      for(int k=0 ; k<4 ; k++){
        int i=(k+1)% 4 ;
        int j=(k+3)% 4 ;
        double vx1=x[i]-x[k];
        double vy1=y[i]-y[k];
        double vx2=x[j]-x[k];
        double vy2=y[j]-y[k];
        double det=vx1*vy2-vy1*vx2 ;
        if(det<-EPS){
          signs[i]=-1 ;
        }
        else signs[i]=1 ;
      }
      for(int i=0 ; i<3 ; i++)if(signs[i]!=signs[i+1]){
        f=false ;
        break ;
      }
      println(f ? "YES" : "NO");
    }
    sc.close();
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
       while sc.hasNext() do ( (     var s : Sequence(String) ; s := sc.nextLine()->split(",") ;
     var x : Sequence(double) ; x := Integer.subrange(1,4)->collect(0.0) ;
    var y : Sequence(double) ; y := Integer.subrange(1,4)->collect(0.0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     x[i+1] := (s[i * 2+1])->toReal() ; 
     y[i+1] := (s[i * 2 + 1+1])->toReal() )  ;     i := i + 1 ) ; 
    var f : boolean ; f := true ;
    var signs : Sequence(int) ; signs := Integer.subrange(1,4)->collect(0) ;
        var k : int ; k := 0 ; while k < 4 do ( (     var i : int ; i := (k + 1) mod 4 ;
     var j : int ; j := (k + 3) mod 4 ;
    var vx1 : double ; vx1 := x[i+1] - x[k+1] ;
    var vy1 : double ; vy1 := y[i+1] - y[k+1] ;
    var vx2 : double ; vx2 := x[j+1] - x[k+1] ;
    var vy2 : double ; vy2 := y[j+1] - y[k+1] ;
    var det : double ; det := vx1 * vy2 - vy1 * vx2 ;
    if (det < -EPS) then (     signs[i+1] := -1 ) else     signs[i+1] := 1 ; ;  
 )  ;     k := k + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do (     if (signs[i+1] /= signs[i + 1+1]) then (     f := false ; 
     break ) else skip ;  ;     i := i + 1 ) ; 
    execute println(if f then "YES" else "NO" endif) ; 
 )  ) ; 
     skip );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.awt.geom.Point2D ;
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    while(sc.hasNext()){
      new aoj0035().doIt();
    }
  }
  class aoj0035 {
    final double EPS=1.0e-08 ;
    Comparator<Point2D>com=new Comparator<Point2D>(){
      public int compare(Point2D o1,Point2D o2){
        if(o1.getX()<o2.getX())return-1 ;
        else if(o1.getX()>o2.getX())return 1 ;
        else if(o1.getY()<o2.getY())return-1 ;
        else if(o1.getY()>o2.getY())return 1 ;
        else return 0 ;
      }
    };
    int ccw(Line2D l,Point2D p){
      return l.relativeCCW(p);
    }
    void doIt(){
      int ans=0 ;
      String str[]=sc.nextLine().split(",");
      Point2D.Double a[]=new Point2D.Double[4];
      for(int i=0 ; i<4 ; i++){
        a[i]=new Point2D.Double(Double.parseDouble(str[i*2]),Double.parseDouble(str[i*2+1]));
      }
      Line2D.Double b[]=new Line2D.Double[4];
      for(int i=0 ; i<4 ; i++){
        b[i]=new Line2D.Double(a[i] .getX(),a[i] .getY(),a[(i+1)% 4] .getX(),a[(i+1)% 4] .getY());
        ans=ans+ccw(b[i],a[(i+2)% 4]);
      }
      if(ans==4 || ans==-4)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     while (sc.hasNext()) do (     aoj0035.newaoj0035().doIt() ) );
 class aoj0035 {
   attribute EPS : double := 1.0e-08;
   attribute com : Function(<Point2D>,(<Point2D>,boolean)) := OclComparator<Point2D>.newOclComparator();
   operation ccw( l : Line2D, p : Point2D) : int
  pre: true
  post: true
  activity: (     return l.relativeCCW(p) );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var str : Sequence(String) ; str := sc.nextLine()->split(",") ;
    var a : Sequence(double) ; a := Integer.subrange(1,4)->collect(null) ;
        var i : int ; i := 0 ; while i < 4 do ( (     a[i+1] := Double.newDouble((str[i * 2+1])->toReal(), (str[i * 2 + 1+1])->toReal()) )  ;     i := i + 1 ) ; 
    var b : Sequence(double) ; b := Integer.subrange(1,4)->collect(null) ;
        var i : int ; i := 0 ; while i < 4 do ( (     b[i+1] := Double.newDouble(a[i+1].getX(), a[i+1].getY(), a[(i + 1) mod 4+1].getX(), a[(i + 1) mod 4+1].getY()) ; 
     ans := ans + ccw(b[i+1], a[(i + 2) mod 4+1]) )  ;     i := i + 1 ) ; 
    if (ans = 4 or ans = -4) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] z){
    double[] b=new double[8];
    for(Scanner s=new Scanner(System.in); s.hasNext(); System.out.println((f(b[0],b[1],b[4],b[5],b[6],b[7])>0 && f(b[4],b[5],b[0],b[1],b[2],b[3])>0 && f(b[2],b[3],b[6],b[7],b[0],b[1])>0 && f(b[6],b[7],b[2],b[3],b[4],b[5])>0)||(f(b[0],b[1],b[4],b[5],b[6],b[7])<0 && f(b[4],b[5],b[0],b[1],b[2],b[3])<0 && f(b[2],b[3],b[6],b[7],b[0],b[1])<0 && f(b[6],b[7],b[2],b[3],b[4],b[5])<0)? "YES" : "NO")){
      z=s.next().split(",");
      for(int i=0 ; i<8 ; ++i)b[i]=new Double(z[i]);
    }
  }
  static double f(double a,double b,double c,double d,double e,double f){
    return((d-b)*e+(a-c)*f+c*b-a*d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var b : Sequence(double) ; b := Integer.subrange(1,8)->collect(0.0) ;
         var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ; while s.hasNext() do ( (     z := s.getCurrent()->split(",") ; 
         var i : int ; i := 0 ; while i < 8 do (     b[i+1] := ("" + (z[i+1]))->toReal() ;  ;     i := i + 1 ) )  ;     OclFile["System.out"].println(if (f(b[0+1], b[1+1], b[4+1], b[5+1], b[6+1], b[7+1]) > 0 & f(b[4+1], b[5+1], b[0+1], b[1+1], b[2+1], b[3+1]) > 0 & f(b[2+1], b[3+1], b[6+1], b[7+1], b[0+1], b[1+1]) > 0 & f(b[6+1], b[7+1], b[2+1], b[3+1], b[4+1], b[5+1]) > 0) or (f(b[0+1], b[1+1], b[4+1], b[5+1], b[6+1], b[7+1]) < 0 & f(b[4+1], b[5+1], b[0+1], b[1+1], b[2+1], b[3+1]) < 0 & f(b[2+1], b[3+1], b[6+1], b[7+1], b[0+1], b[1+1]) < 0 & f(b[6+1], b[7+1], b[2+1], b[3+1], b[4+1], b[5+1]) < 0) then "YES" else "NO" endif) ) );
  static   operation f( a : double, b : double, c : double, d : double, e : double, f : double) : double
  pre: true
  post: true
  activity: (     return ((d - b) * e + (a - c) * f + c * b - a * d) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    StringTokenizer st ;
    StringBuilder sb=new StringBuilder();
    int[] stock=new int[100];
    int[] needs=new int[100];
    next : while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=Integer.parseInt(line.substring(0,line.indexOf(' ')));
      int k=Integer.parseInt(line.substring(line.indexOf(' ')+1));
      if((n | k)==0){
        break ;
      }
      st=new StringTokenizer(br.readLine());
      for(int i=0 ; i<k ; i++){
        stock[i]=Integer.parseInt(st.nextToken());
        needs[i] ^=needs[i];
      }
      for(int i=0 ; i<n ; i++){
        st=new StringTokenizer(br.readLine());
        for(int j=0 ; j<k ; j++){
          needs[j]+=Integer.parseInt(st.nextToken());
        }
      }
      for(int i=0 ; i<k ; i++){
        if(stock[i]<needs[i]){
          sb.append("No\n");
          continue next ;
        }
      }
      sb.append("Yes\n");
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
    var st : OclIterator ;
    var sb : String ; sb := StringLib.newString() ;
    var stock : Sequence(int) ; stock := Integer.subrange(1,100)->collect(0) ;
    var needs : Sequence(int) ; needs := Integer.subrange(1,100)->collect(0) ;
        line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := (line.subrange(0+1,line->indexOf(' ')-1))->toInteger() ;
     var k : int ; k := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1))->toInteger() ;
    if ((MathLib.bitwiseOr(n,k)) = 0) then (     break ) else skip ; 
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < k do ( (     stock[i+1] := (st.next())->toInteger() ; 
     needs[i+1] := MathLib.bitwiseXor(needs[i+1],needs[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
         var j : int ; j := 0 ; while j < k do ( (     needs[j+1] := needs[j+1]+((st.next())->toInteger()) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do ( (     if (stock[i+1] < needs[i+1]) then (     sb := sb + StringLib.newString("No\n") ; 
     continue ) else skip )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString("Yes\n") ; 
 ) ;     line := br.readLine() ;
 ) ;  
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    long n=in.nextLong();
    long pow3=1 ;
    while(pow3<=3*n){
      if(n % pow3!=0){
        System.out.println(n/pow3+1);
        return ;
      }
      pow3=pow3*3 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toLong() ;
     var pow3 : long ; pow3 := 1 ;
     while (pow3 <= 3 * n) do (     if (n mod pow3 /= 0) then (     OclFile["System.out"].println(n / pow3 + 1) ; 
     return ) else skip ; 
     pow3 := pow3 * 3 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    long n=in.nextLong();
    long pow3=1 ;
    while(pow3<=n){
      if(n % pow3!=0){
        System.out.println(n/pow3+1);
        return ;
      }
      pow3=pow3*3 ;
    }
    System.out.println(1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toLong() ;
    var pow3 : long ; pow3 := 1 ;
    while (pow3 <= n) do (     if (n mod pow3 /= 0) then (     OclFile["System.out"].println(n / pow3 + 1) ; 
     return ) else skip ; 
     pow3 := pow3 * 3 ) ; 
    OclFile["System.out"].println(1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    long n=in.nextLong();
    long maxValue=Long.MAX_VALUE ;
    int cnt=0 ;
    while(maxValue>0){
      cnt++;
      maxValue=maxValue/3 ;
    }
    long max=0 ;
    long pow3=1 ;
    for(int i=1 ; i<=cnt-1 ; i++){
      pow3=pow3*3 ;
      if(n % pow3!=0){
        max=Math.max(max,n/pow3+1);
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toLong() ;
    var maxValue : long ; maxValue := "9223372036854775807"->toLong() ;
    var cnt : int ; cnt := 0 ;
    while (maxValue > 0) do (     cnt := cnt + 1 ; 
     maxValue := maxValue / 3 ) ; 
    var max : long ; max := 0 ;
    var pow3 : long ; pow3 := 1 ;
        var i : int ; i := 1 ; while i <= cnt - 1 do ( (     pow3 := pow3 * 3 ; 
     if (n mod pow3 /= 0) then (     max := Set{max, n / pow3 + 1}->max() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void drawPattern(int N){
    int n=N ;
    int row=1 ;
    int nst=1 ;
    int nsp1=n-1 ;
    int nsp2=-1 ;
    int val1=row ;
    int val2=1 ;
    while(row<=n){
      int csp1=1 ;
      while(csp1<=nsp1){
        System.out.print("  ");
        csp1=csp1+1 ;
      }
      int cst1=1 ;
      while(cst1<=nst){
        System.out.print(val1+" ");
        val1=val1-1 ;
        cst1=cst1+1 ;
      }
      int csp2=1 ;
      while(csp2<=nsp2){
        System.out.print("  ");
        csp2=csp2+1 ;
      }
      if(row!=1 && row!=n){
        int cst2=1 ;
        while(cst2<=nst){
          System.out.print(val2+" ");
          val2=val2+1 ;
          cst2=cst2+1 ;
        }
      }
      System.out.println();
      if(row<=n/2){
        nst=nst+1 ;
        nsp1=nsp1-2 ;
        nsp2=nsp2+2 ;
        val1=row+1 ;
        val2=1 ;
      }
      else {
        nst=nst-1 ;
        nsp1=nsp1+2 ;
        nsp2=nsp2-2 ;
        val1=n-row ;
        val2=1 ;
      }
      row=row+1 ;
    }
  }
  public static void main(String args[]){
    int N=7 ;
    drawPattern(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation drawPattern( N : int) : void
  pre: true
  post: true
  activity: (     var n : int ; n := N ;
     var row : int ; row := 1 ;
    var nst : int ; nst := 1 ;
    var nsp1 : int ; nsp1 := n - 1 ;
    var nsp2 : int ; nsp2 := -1 ;
    var val1 : int ; val1 := row ;
    var val2 : int ; val2 := 1 ;
    while (row <= n) do (     var csp1 : int ; csp1 := 1 ;
     while (csp1 <= nsp1) do (     OclFile["System.out"].print("  ") ; 
     csp1 := csp1 + 1 ) ; 
    var cst1 : int ; cst1 := 1 ;
    while (cst1 <= nst) do (     OclFile["System.out"].print(val1 + " ") ; 
     val1 := val1 - 1 ; 
     cst1 := cst1 + 1 ) ; 
    var csp2 : int ; csp2 := 1 ;
    while (csp2 <= nsp2) do (     OclFile["System.out"].print("  ") ; 
     csp2 := csp2 + 1 ) ; 
    if (row /= 1 & row /= n) then (     var cst2 : int ; cst2 := 1 ;
     while (cst2 <= nst) do (     OclFile["System.out"].print(val2 + " ") ; 
     val2 := val2 + 1 ; 
     cst2 := cst2 + 1 ) ) else skip ; 
    OclFile["System.out"].println() ; 
    if (row <= n / 2) then (     nst := nst + 1 ; 
     nsp1 := nsp1 - 2 ; 
    nsp2 := nsp2 + 2 ; 
    val1 := row + 1 ; 
    val2 := 1 ; 
 ) else (     nst := nst - 1 ; 
     nsp1 := nsp1 + 2 ; 
    nsp2 := nsp2 - 2 ; 
    val1 := n - row ; 
    val2 := 1 ; 
 ) ;  
    row := row + 1 ; 
 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 7 ;
     execute drawPattern(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class esep {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int cases=sc.nextInt();
    while(cases-->0){
      int days=sc.nextInt();
      int rost=1 ;
      int bust=0 ;
      int smert=0 ;
      for(int i=0 ; i<days ; i++){
        int x=sc.nextInt();
        if(rost==-1){
          continue ;
        }
        if(x==1){
          smert=0 ;
++bust ;
          if(bust<2){
++rost ;
          }
          if(bust>=2){
            rost+=5 ;
          }
        }
        else if(x==0){
++smert ;
          bust=0 ;
          if(smert==2){
            rost=-1 ;
          }
        }
      }
      System.out.println(rost);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class esep {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cases : int ; cases := sc.getCurrent()->toInteger() ;
         while (cases > 0) do (        cases := cases - 1 ;     skip ; (     var days : int ; days := sc.getCurrent()->toInteger() ;
     var rost : int ; rost := 1 ;
    var bust : int ; bust := 0 ;
    var smert : int ; smert := 0 ;
        var i : int ; i := 0 ; while i < days do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (rost = -1) then (     continue ) else skip ; 
     if (x = 1) then (     smert := 0 ; 
     bust := bust + 1 ; 
     if (bust < 2) then (     rost := rost + 1 ) else skip ; 
     if (bust >= 2) then (     rost := rost+(5) ) else skip ) else     if (x = 0) then (     smert := smert + 1 ; 
     bust := 0 ; 
     if (smert = 2) then (     rost := -1 ) else skip ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(rost) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  int binarySearch(int arr[],int l,int r,int x){
    if(r>=l){
      int mid=l+(r-l)/2 ;
      if(arr[mid]==x)return mid ;
      if(mid>l && arr[mid-1]==x)return(mid-1);
      if(mid<r && arr[mid+1]==x)return(mid+1);
      if(arr[mid]>x)return binarySearch(arr,l,mid-2,x);
      return binarySearch(arr,mid+2,r,x);
    }
    return-1 ;
  }
  public static void main(String args[]){
    GFG ob=new GFG();
    int arr[]={
      3,2,10,4,40 };
      int n=arr.length ;
      int x=4 ;
      int result=ob.binarySearch(arr,0,n-1,x);
      if(result==-1)System.out.println("Element is not present in array");
      else System.out.println("Element is present at index "+result);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
   operation binarySearch( arr : Sequence(int), l : int, r : int, x : int) : int
  pre: true
  post: true
  activity: (     if (r >= l) then (     var mid : int ; mid := l + (r - l) / 2 ;
     if (arr[mid+1] = x) then     return mid else skip ; 
    if (mid > l & arr[mid - 1+1] = x) then     return (mid - 1) else skip ; 
    if (mid < r & arr[mid + 1+1] = x) then     return (mid + 1) else skip ; 
    if (arr[mid+1] > x) then     return binarySearch(arr, l, mid - 2, x) else skip ; 
    return binarySearch(arr, mid + 2, r, x) 
 ) else skip ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ob : GFG ; ob := GFG.newGFG() ;
     var arr : Sequence(int) ; arr := Sequence{3,2,10,4,40} ;
    var n : int ; n := arr->size() ;
    var x : int ; x := 4 ;
    var result : int ; result := ob.binarySearch(arr, 0, n - 1, x) ;
    if (result = -1) then     OclFile["System.out"].println("Element is not present in array") else     OclFile["System.out"].println("Element is present at index " + result) ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static String solve(int[] arr){
    int n=arr.length ;
    int b1=arr[0];
    boolean foundZero=false ;
    for(int i=1 ; i<n ; i++){
      if(foundZero && arr[i]!=0){
        return "NO" ;
      }
      b1+=arr[i];
      if(b1<0){
        return "NO" ;
      }
      if(b1==0){
        foundZero=true ;
      }
    }
    return "YES" ;
  }
  public static void main(String[] str){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] a=new int[n];
      long preSum=0 ;
      boolean ok=true ;
      boolean flag=false ;
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
        if(flag && a[i]!=0)ok=false ;
        preSum+=a[i];
        if(preSum<0)ok=false ;
        if(preSum==0){
          flag=true ;
        }
      }
      if(preSum!=0)System.out.println("no");
      else {
        if(ok)System.out.println("yes");
        else System.out.println("no");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation solve( arr : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
     var b1 : int ; b1 := arr[0+1] ;
    var foundZero : boolean ; foundZero := false ;
        var i : int ; i := 1 ; while i < n do ( (     if (foundZero & arr[i+1] /= 0) then (     return "NO" ) else skip ; 
     b1 := b1+(arr[i+1]) ; 
     if (b1 < 0) then (     return "NO" ) else skip ; 
     if (b1 = 0) then (     foundZero := true ) else skip )  ;     i := i + 1 ) ; 
    return "YES" 
 );
  static   operation main( str : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var preSum : long ; preSum := 0 ;
    var ok : boolean ; ok := true ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (flag & a[i+1] /= 0) then     ok := false ; else skip ; 
    preSum := preSum+(a[i+1]) ; 
    if (preSum < 0) then     ok := false ; else skip ; 
    if (preSum = 0) then (     flag := true ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (preSum /= 0) then     OclFile["System.out"].println("no") else (     if (ok) then     OclFile["System.out"].println("yes") ; else     OclFile["System.out"].println("no") ; ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] a=new int[n];
      long preSum=0 ;
      boolean ok=true ;
      boolean flag=false ;
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
        if(flag && a[i]!=0)ok=false ;
        preSum+=a[i];
        if(preSum<0)ok=false ;
        if(preSum==0){
          flag=true ;
        }
      }
      if(preSum!=0)System.out.println("no");
      else {
        if(ok)System.out.println("yes");
        else System.out.println("no");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var preSum : long ; preSum := 0 ;
    var ok : boolean ; ok := true ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (flag & a[i+1] /= 0) then     ok := false ; else skip ; 
    preSum := preSum+(a[i+1]) ; 
    if (preSum < 0) then     ok := false ; else skip ; 
    if (preSum = 0) then (     flag := true ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (preSum /= 0) then     OclFile["System.out"].println("no") else (     if (ok) then     OclFile["System.out"].println("yes") ; else     OclFile["System.out"].println("no") ; ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class A1630 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    StringBuilder out=new StringBuilder();
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      int K=in.nextInt();
      if(N==4 && K==3){
        out.append("-1\n");
      }
      else {
        Map<Integer,Integer>map=new HashMap<>();
        for(int n=0 ; n<N/2 ; n++){
          map.put(n,N-1-n);
        }
        if(K!=0){
          int forLast=(K==N-1)?(N-2): K ;
          map.remove(forLast);
          map.remove(N-1-forLast);
          map.put(0,N-1-forLast);
          map.put(forLast,N-1);
          if(K==N-1){
            map.remove(3);
            map.put(0,N-4);
            map.put(1,3);
          }
        }
        for(Map.Entry<Integer,Integer>entry : map.entrySet()){
          out.append(entry.getKey()).append(' ').append(entry.getValue()).append('\n');
        }
      }
    }
    System.out.print(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1630 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : String ; out := StringLib.newString() ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var K : int ; K := in.getCurrent()->toInteger() ;
     if (N = 4 & K = 3) then (     out := out + StringLib.newString("-1\n") ) else (     var map : Map(int,int) ; map := Map{} ;
         var n : int ; n := 0 ; while n < N / 2 do ( (     map := map->union(Map{n |-> N - 1 - n}) )  ;     n := n + 1 ) ; 
     if (K /= 0) then (     var forLast : int ; forLast := if (K = N - 1) then (N - 2) else K endif ;
     map := map->antirestrict(Set{forLast}) ; 
    map := map->antirestrict(Set{N - 1 - forLast}) ; 
    map := map->union(Map{0 |-> N - 1 - forLast}) ; 
    map := map->union(Map{forLast |-> N - 1}) ; 
    if (K = N - 1) then (     map := map->antirestrict(Set{3}) ; 
     map := map->union(Map{0 |-> N - 4}) ; 
     map := map->union(Map{1 |-> 3}) ) else skip ; 
 ) else skip ; 
     for (entry : map->asSet()) do ( (     out := out + StringLib.newString(entry.getKey()) + StringLib.newString(' ') + StringLib.newString(entry.getValue()) + StringLib.newString('
') )  ) ) )  ;     t := t + 1 ) ; 
    OclFile["System.out"].print(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Node {
    int data ;
    Node next ;
  };
  static Node push(Node head_ref,int new_data){
    Node new_node=new Node();
    new_node.data=new_data ;
    new_node.next=(head_ref);
(head_ref)=new_node ;
    return head_ref ;
  }
  static int productOfNodes(Node head){
    Node ptr=head ;
    int product=1 ;
    while(ptr!=null){
      product*=ptr.data ;
      ptr=ptr.next ;
    }
    return product ;
  }
  public static void main(String args[]){
    Node head=null ;
    head=push(head,7);
    head=push(head,6);
    head=push(head,8);
    head=push(head,4);
    head=push(head,1);
    System.out.println("Product="+productOfNodes(head));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   operation push( head_ref : Node, new_data : int) : Node
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode() ;
     new_node.data := new_data ; 
    new_node.next := (head_ref) ; 
    (head_ref) := new_node ; 
    return head_ref 
 );
  static   operation productOfNodes( head : Node) : int
  pre: true
  post: true
  activity: (     var ptr : Node ; ptr := head ;
     var product : int ; product := 1 ;
     while (ptr /= null) do (     product := product*(ptr.data) ; 
     ptr := ptr.next ) ; 
     return product );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := null ;
     head := push(head, 7) ; 
    head := push(head, 6) ; 
    head := push(head, 8) ; 
    head := push(head, 4) ; 
    head := push(head, 1) ; 
    OclFile["System.out"].println("Product=" + productOfNodes(head)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static void solve(int n,int k,int[] needs,int[][] wants){
    for(int i=0 ; i<k ; i++){
      int sum=0 ;
      for(int j=0 ; j<n ; j++){
        sum+=wants[j][i];
      }
      if(sum>needs[i]){
        System.out.println("No");
        return ;
      }
    }
    System.out.println("Yes");
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      int k=sc.nextInt();
      if(n==0 && k==0)break ;
      int[] needs=new int[k];
      for(int i=0 ; i<k ; i++)needs[i]=sc.nextInt();
      int[][] wants=new int[n][k];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<k ; j++)wants[i][j]=sc.nextInt();
      }
      solve(n,k,needs,wants);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( n : int, k : int, needs : Sequence(int), wants : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < k do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     sum := sum+(wants[j+1][i+1]) )  ;     j := j + 1 ) ; 
     if (sum > needs[i+1]) then (     OclFile["System.out"].println("No") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Yes") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    if (n = 0 & k = 0) then     break else skip ; 
    var needs : Sequence(int) ; needs := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do (     needs[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var wants : Sequence(Sequence(int)) ; wants := Integer.subrange(1,n)->collect(Integer.subrange(1,k)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < k do (     wants[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    execute solve(n, k, needs, wants) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ExpansionCoefficient {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] values=new int[n];
    for(int i=0 ; i<n ; i++){
      values[i]=sc.nextInt();
    }
    int[] pos=new int[n];
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      pos[i]=values[i]/(Math.max(n-i-1,i));
      min=Math.min(min,pos[i]);
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ExpansionCoefficient {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var values : Sequence(int) ; values := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     values[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var pos : Sequence(int) ; pos := Integer.subrange(1,n)->collect(0) ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     pos[i+1] := values[i+1] / (Set{n - i - 1, i}->max()) ; 
     min := Set{min, pos[i+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class test {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Pair[] a=new Pair[sc.nextInt()];
    for(int i=0 ; i<a.length ; i++){
      a[i]=new Pair(sc.nextInt(),i);
    }
    Arrays.sort(a,new Comparator<Pair>(){
      public int compare(Pair p1,Pair p2){
        return(p1.val<p2.val)? 1 :-1 ;
      }
    }
);
    int k=Integer.MAX_VALUE ;
    int minIndex=a[0] .originalIndex ;
    int maxIndex=a[0] .originalIndex ;
    for(int i=1 ; i<a.length ; i++){
      int min=Math.min(a[i] .val/(Math.abs(a[i] .originalIndex-minIndex)),a[i] .val/(Math.abs(a[i] .originalIndex-maxIndex)));
      k=Math.min(k,min);
      minIndex=Math.min(minIndex,a[i] .originalIndex);
      maxIndex=Math.max(maxIndex,a[i] .originalIndex);
    }
    System.out.println(k);
  }
}
class Pair {
  int val,originalIndex ;
  Pair(int v,int oI){
    this.val=v ;
    this.originalIndex=oI ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(Map) ; a := Integer.subrange(1,sc.getCurrent()->toInteger())->collect(null) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := Map(sc.getCurrent()->toInteger(), i) )  ;     i := i + 1 ) ; 
    a := OclComparator.sortWith(a, OclComparator<Map>.newOclComparator()) ; 
    var k : int ; k := 2147483647 ;
    var minIndex : int ; minIndex := a[0+1].originalIndex ;
    var maxIndex : int ; maxIndex := a[0+1].originalIndex ;
        var i : int ; i := 1 ; while i < a->size() do ( (     var min : int ; min := Set{a[i+1].val / (if a[i+1].originalIndex - minIndex < 0 then -(a[i+1].originalIndex - minIndex) else a[i+1].originalIndex - minIndex endif), a[i+1].val / (if a[i+1].originalIndex - maxIndex < 0 then -(a[i+1].originalIndex - maxIndex) else a[i+1].originalIndex - maxIndex endif)}->min() ;
     k := Set{k, min}->min() ; 
     minIndex := Set{minIndex, a[i+1].originalIndex}->min() ; 
     maxIndex := Set{maxIndex, a[i+1].originalIndex}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(k) ; 
 );
}
class Pair {
   attribute val : int;
   static operation newPair( v : int, oI : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(v, oI);
    return self );
  operation initialise( v : int, oI : int) : void
  pre: true  post: true
  activity: (     self.val := v ; 
     self.originalIndex := oI );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  long INF=Long.MAX_VALUE ;
  public static void main(String[] args){
    new Main().solve();
  }
  void solve(){
    Scanner sc=new Scanner(System.in);
    String X=sc.next();
    char[] x=X.toCharArray();
    long ans=0 ;
    long c=0 ;
    for(int i=0 ; i<X.length(); i++){
      if(x[i]=='T'){
        c--;
        if(c<0){
          ans++;
          c=0 ;
        }
      }
      else {
        c++;
      }
    }
    System.out.println(ans+c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : long := "9223372036854775807"->toLong();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : String ; X := sc.getCurrent() ;
    var x : Sequence(String) ; x := X->characters() ;
    var ans : long ; ans := 0 ;
    var c : long ; c := 0 ;
        var i : int ; i := 0 ; while i < X->size() do ( (     if (x[i+1] = 'T') then (     c := c - 1 ; 
     if (c < 0) then (     ans := ans + 1 ; 
     c := 0 ) else skip ) else (     c := c + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans + c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Stack ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      Stack<Character>s=new Stack<>();
      String inp=in.next();
      int ans=inp.length();
      for(int i=0 ; i<inp.length(); i++){
        if(inp.charAt(i)=='S'){
          s.push(inp.charAt(i));
        }
        else if(! s.isEmpty()){
          s.pop();
          ans-=2 ;
        }
      }
      out.println(ans);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := Sequence{} ;
     var inp : String ; inp := in.next() ;
    var ans : int ; ans := inp->size() ;
        var i : int ; i := 0 ; while i < inp->size() do ( (     if (inp->at(i+1) = 'S') then (     s := s->append(inp->at(i+1)) ) else     if (not(s->isEmpty())) then (     s := s->front() ; 
     ans := ans-(2) ) else skip ; )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static boolean[][] used ;
  static int[] ans ;
  public static void main(String[] args)throws Exception {
    FastScanner sc=new FastScanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    char[] s=sc.next().toCharArray();
    int cnt=0 ;
    StringBuilder sb=new StringBuilder();
    for(char c : s){
      if(c=='T'){
        if(cnt==0){
          sb.append("T");
        }
        else {
          cnt--;
        }
      }
      else {
        cnt++;
      }
    }
    System.out.println(sb.length()+cnt);
  }
}
class FastScanner {
  private BufferedReader reader=null ;
  private StringTokenizer tokenizer=null ;
  public FastScanner(InputStream in){
    reader=new BufferedReader(new InputStreamReader(in));
    tokenizer=null ;
  }
  public String next(){
    if(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        tokenizer=new StringTokenizer(reader.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }
  public String nextLine(){
    if(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken("\n");
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public double nextDouble(){
    return Double.parseDouble(next());
  }
  public int[] nextIntArray(int n){
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public long[] nextLongArray(int n){
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=nextLong();
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute used : Sequence(Sequence(boolean));
  static   attribute ans : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : Sequence(String) ; s := sc.next()->characters() ;
    var cnt : int ; cnt := 0 ;
    var sb : String ; sb := StringLib.newString() ;
    for (c : s) do ( (     if (c = 'T') then (     if (cnt = 0) then (     sb := sb + StringLib.newString("T") ) else (     cnt := cnt - 1 ) ) else (     cnt := cnt + 1 ) )  ) ; 
    OclFile["System.out"].println(sb->size() + cnt) ; 
 );
}
class FastScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.nextToken("\n") );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder();
    int t=fs.nextInt();
    while(t-->0){
      int n=fs.nextInt();
      int[] a=fs.readArray(n);
      int chz=0,cho=0,s=1 ;
      for(int i=0 ; i<n ; i++){
        if(a[i]==0){
          cho=0 ;
          chz++;
        }
        else {
          chz=0 ;
          cho++;
        }
        if(chz==2){
          s=-1 ;
          break ;
        }
        if(cho==1)s+=1 ;
        if(cho>=2){
          s+=5 ;
        }
      }
      sb.append(s).append("\n");
    }
    System.out.print(sb);
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    var t : int ; t := fs.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := fs.nextInt() ;
     var a : Sequence(int) ; a := fs.readArray(n) ;
    var chz : int ; chz := 0 ;
    var cho : int ; cho := 0 ;
    var s : int ; s := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = 0) then (     cho := 0 ; 
     chz := chz + 1 ) else (     chz := 0 ; 
     cho := cho + 1 ) ;  
     if (chz = 2) then (     s := -1 ; 
     break ) else skip ; 
     if (cho = 1) then     s := s+(1) ; else skip ; 
     if (cho >= 2) then (     s := s+(5) ) else skip )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(s) + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].print(sb) ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayDeque ;
import java.util.Deque ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str[]=br.readLine().split("");
    Deque<String>stack=new ArrayDeque<>();
    for(int i=0 ; i<str.length ; i++){
      if(str[i] .equals("S")){
        stack.push(str[i]);
      }
      else if(str[i] .equals("T")){
        if(stack.isEmpty()){
          stack.push(str[i]);
        }
        else if(stack.peek().equals("T")){
          stack.push(str[i]);
        }
        else {
          stack.pop();
        }
      }
    }
    System.out.println(stack.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split("") ;
    var stack : Sequence(String) ; stack := ArrayDeque<OclAny>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str[i+1] = "S") then (     stack := stack->append(str[i+1]) ) else     if (str[i+1] = "T") then (     if (stack->isEmpty()) then (     stack := stack->append(str[i+1]) ) else     if (stack->min() = "T") then (     stack := stack->append(str[i+1]) ) else (     stack := stack->front() ) ;  ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(stack->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static final PrintStream so=System.out ;
  static final Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    char[] x=nsToChars();
    int len=x.length ;
    int countST=0 ;
    int countS=0 ;
    for(int i=0 ; i<len ; i++){
      if(x[i]=='S'){
        countS++;
      }
      else if(countS>0){
        countS--;
        countST++;
      }
    }
    so.println(len-countST*2);
  }
  static int ni(){
    return sc.nextInt();
  }
  static long nl(){
    return sc.nextLong();
  }
  static char[] nsToChars(){
    return sc.next().toCharArray();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute so : OclFile := OclFile["System.out"];
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : Sequence(String) ; x := nsToChars() ;
     var len : int ; len := x->size() ;
    var countST : int ; countST := 0 ;
    var countS : int ; countS := 0 ;
        var i : int ; i := 0 ; while i < len do ( (     if (x[i+1] = 'S') then (     countS := countS + 1 ) else     if (countS > 0) then (     countS := countS - 1 ; 
     countST := countST + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
  static   operation nl() : long
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toLong() );
  static   operation nsToChars() : Sequence(String)
  pre: true
  post: true
  activity: (     return sc.getCurrent()->characters() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int i=1 ;
    int x=1 ;
    while(true){
      x=sc.nextInt();
      if(x==0)break ;
      System.out.printf("Case %d: %d\n",i,x);
      i++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ; i := 1 ;
     var x : int ; x := 1 ;
     while (true) do (     x := sc.getCurrent()->toInteger() ; 
     if (x = 0) then     break else skip ; 
     OclFile["System.out"].printf("Case %d: %d\n", i, x) ; 
     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
class Main {
  public static void main(String[] args){
    int index=0 ;
    ArrayList<Integer>ar=new ArrayList<Integer>();
    java.util.Scanner scanner=new java.util.Scanner(System.in);
    while(true){
      int num=scanner.nextInt();
      ar.add(num);
      if(num==0){
        break ;
      }
      index++;
    }
    for(int i=0 ; i<index ; i++){
      int num=i+1 ;
      System.out.println("Case "+num+": "+ar.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var index : int ; index := 0 ;
     var ar : Sequence(int) ; ar := Sequence{} ;
    var scanner : Scanner ; scanner := Scanner.newScanner(OclFile["System.in"]) ;
    while (true) do (     var num : int ; num := scanner.nextInt() ;
     ar := ar->including(num) ; 
     if (num = 0) then (     break ) else skip ; 
     index := index + 1 ) ; 
        var i : int ; i := 0 ; while i < index do ( (     var num : int ; num := i + 1 ;
     OclFile["System.out"].println("Case " + num + ": " + ar->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    DAxisParallelRectangle solver=new DAxisParallelRectangle();
    solver.solve(1,in,out);
    out.close();
  }
  static class DAxisParallelRectangle {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int k=in.nextInt();
      long[] x=new long[n];
      long[] y=new long[n];
      for(int i=0 ; i<n ; i++){
        x[i]=in.nextLong();
        y[i]=in.nextLong();
      }
      long min=Long.MAX_VALUE ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          for(int l=0 ; l<n ; l++){
            for(int m=0 ; m<n ; m++){
              int cnt=0 ;
              for(int o=0 ; o<n ; o++){
                if(x[i]<=x[o] && x[o]<=x[m] && y[l]<=y[o] && y[o]<=y[j]){
                  cnt++;
                }
              }
              if(cnt>=k){
                long s=(x[m]-x[i])*(y[j]-y[l]);
                min=Math.min(min,s);
              }
            }
          }
        }
      }
      out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : DAxisParallelRectangle ; solver := DAxisParallelRectangle.newDAxisParallelRectangle() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class DAxisParallelRectangle {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var x : Sequence(long) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(long) ; y := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := in.getCurrent()->toLong() ; 
     y[i+1] := in.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var min : long ; min := "9223372036854775807"->toLong() ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (         var l : int ; l := 0 ; while l < n do ( (         var m : int ; m := 0 ; while m < n do ( (     var cnt : int ; cnt := 0 ;
         var o : int ; o := 0 ; while o < n do ( (     if (x[i+1] <= x[o+1] & x[o+1] <= x[m+1] & y[l+1] <= y[o+1] & y[o+1] <= y[j+1]) then (     cnt := cnt + 1 ) else skip )  ;     o := o + 1 ) ; 
     if (cnt >= k) then (     var s : long ; s := (x[m+1] - x[i+1]) * (y[j+1] - y[l+1]) ;
     min := Set{min, s}->min() ) else skip )  ;     m := m + 1 ) )  ;     l := l + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    String buf ;
    int i=1 ;
    try {
      while((buf=reader.readLine())!=null){
        int num=Integer.parseInt(buf);
        if(num==0){
          break ;
        }
        else {
          System.out.println("Case "+i+": "+num);
          i++;
        }
      }
    }
    catch(IOException e){
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var buf : String ;
     var i : int ; i := 1 ;
     try (         buf := reader.readLine() ;
    while ((buf) /= null) do (    skip ; (     var num : int ; num := (buf)->toInteger() ;
     if (num = 0) then (     break ) else (     OclFile["System.out"].println("Case " + i + ": " + num) ; 
     i := i + 1 ) ) ;     buf := reader.readLine() ;
 ) )   catch (e : IOException) do (     OclFile["System.out"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int i=1 ;
    for(; ; i++){
      String str=sc.next();
      if(str.equals("0"))break ;
      else System.out.printf("Case %d: %s\n",i,str);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ; i := 1 ;
       while true do ( (     var str : String ; str := sc.getCurrent() ;
     if (str = "0") then     break else     OclFile["System.out"].printf("Case %d: %s\n", i, str) ; )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int[] x=new int[10000000];
    int i=0 ;
    int j ;
    Scanner sc=new Scanner(System.in);
    x[0]=sc.nextInt();
    for(i=1 ; x[i-1]!=0 ; i++){
      x[i]=sc.nextInt();
      j=i+1 ;
    }
    int k ;
    for(k=0 ; k<i-1 ; k++){
      System.out.println("Case "+(k+1)+": "+x[k]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : Sequence(int) ; x := Integer.subrange(1,10000000)->collect(0) ;
     var i : int ; i := 0 ;
    var j : int ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    x[0+1] := sc.getCurrent()->toInteger() ; 
        i := 1 ; while x[i - 1+1] /= 0 do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     j := i + 1 )  ;     i := i + 1 ) ; 
    var k : int ;
        k := 0 ; while k < i - 1 do ( (     OclFile["System.out"].println("Case " + (k + 1) + ": " + x[k+1]) )  ;     k := k + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class amd {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      String str=s.next();
      HashMap<Character,Integer>hs=new HashMap();
      for(int i=0 ; i<str.length(); i++){
        char c=str.charAt(i);
        hs.put(c,hs.getOrDefault(c,0)+1);
      }
      for(int i=0 ; i<str.length(); i++){
        char c=str.charAt(i);
        int a=hs.get(c);
        if(a>1){
          hs.put(c,hs.get(c)-1);
        }
        else {
          System.out.println(str.substring(i));
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class amd {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var str : String ; str := s.getCurrent() ;
     var hs : Map(String,int) ; hs := Map{} ;
         var i : int ; i := 0 ; while i < str->size() do ( (     var c : String ; c := str->at(i+1) ;
     hs := hs->union(Map{c |-> (if hs->keys()->contains(c) then hs->at(c) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < str->size() do ( (     var c : String ; c := str->at(i+1) ;
     var a : int ; a := hs->at(c) ;
     if (a > 1) then (     hs := hs->union(Map{c |-> hs->at(c) - 1}) ) else (     OclFile["System.out"].println(str.subrange(i+1,i)) ; 
     break ) )  ;     i := i + 1 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1654 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      char[] S=in.next().toCharArray();
      int[] stat=new int[26];
      for(char c : S){
        stat[c-'a']++;
      }
      int i=0 ;
      while(stat[S[i]-'a']>1){
        stat[S[i]-'a']--;
        i++;
      }
      System.out.println(new String(S,i,S.length-i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1654 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var S : Sequence(String) ; S := in.getCurrent()->characters() ;
     var stat : Sequence(int) ; stat := Integer.subrange(1,26)->collect(0) ;
    for (c : S) do ( (     stat[c - ('a')->char2byte()+1] := stat[c - ('a')->char2byte()+1] + 1 )  ) ; 
    var i : int ; i := 0 ;
    while (stat[S[i+1] - ('a')->char2byte()+1] > 1) do (     stat[S[i+1] - ('a')->char2byte()+1] := stat[S[i+1] - ('a')->char2byte()+1] - 1 ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println(StringLib.newString(S, i, S->size() - i)) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.nio.ByteBuffer ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[][] f=new int[n][10];
    int[][] p=new int[n][11];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<10 ; j++){
        f[i][j]=sc.nextInt();
      }
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<11 ; j++){
        p[i][j]=sc.nextInt();
      }
    }
    sc.close();
    int ans=-1000000007 ;
    for(int i=1 ; i<1024 ; i++){
      int score=0 ;
      int num=0 ;
      int[] b=new int[10];
      int mi=i ;
      for(int j=9 ; j>=0 ; j--){
        b[j]=mi/(int)Math.pow(2,j);
        mi-=b[j]*(int)Math.pow(2,j);
      }
      for(int j=0 ; j<n ; j++){
        num=0 ;
        for(int k=0 ; k<10 ; k++){
          if(f[j][k]==1 && b[k]==1){
            num++;
          }
        }
        score+=p[j][num];
      }
      if(score>ans){
        ans=score ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var f : Sequence(Sequence(int)) ; f := Integer.subrange(1,n)->collect(Integer.subrange(1,10)->collect(0)) ;
    var p : Sequence(Sequence(int)) ; p := Integer.subrange(1,n)->collect(Integer.subrange(1,11)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 10 do ( (     f[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 11 do ( (     p[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : int ; ans := -1000000007 ;
        var i : int ; i := 1 ; while i < 1024 do ( (     var score : int ; score := 0 ;
     var num : int ; num := 0 ;
    var b : Sequence(int) ; b := Integer.subrange(1,10)->collect(0) ;
    var mi : int ; mi := i ;
        var j : int ; j := 9 ; while j >= 0 do ( (     b[j+1] := mi / 2->pow(j)->oclAsType(int) ; 
     mi := mi-(b[j+1] * 2->pow(j)->oclAsType(int)) )  ;     j := j - 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     num := 0 ; 
         var k : int ; k := 0 ; while k < 10 do ( (     if (f[j+1][k+1] = 1 & b[k+1] = 1) then (     num := num + 1 ) else skip )  ;     k := k + 1 ) ; 
     score := score+(p[j+1][num+1]) )  ;     j := j + 1 ) ; 
    if (score > ans) then (     ans := score ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      int len=1+a[0];
      for(int i=1 ; i<n ; i++){
        if(a[i]==1 && a[i-1]==1){
          len+=5 ;
        }
        else if(a[i]==1){
          len+=1 ;
        }
        else if(a[i]==0 && a[i-1]==0){
          len=-1 ;
          break ;
        }
      }
      System.out.println(len);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var len : int ; len := 1 + a[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] = 1 & a[i - 1+1] = 1) then (     len := len+(5) ) else     if (a[i+1] = 1) then (     len := len+(1) ) else     if (a[i+1] = 0 & a[i - 1+1] = 0) then (     len := -1 ; 
     break ) else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(len) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
class Main {
  public static final int MOD=1000000007 ;
  public static final int INF=1000000000 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    int N=sc.nextInt();
    Integer F[][]=new Integer[N][10];
    Integer P[][]=new Integer[N][11];
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<10 ; j++){
        F[i][j]=sc.nextInt();
      }
    }
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<11 ; j++){
        P[i][j]=sc.nextInt();
      }
    }
    int ans=-INF ;
    for(int i=1 ; i<(1<<10); i++){
      int tmp=0 ;
      for(int k=0 ; k<N ; k++){
        int count=0 ;
        for(int j=0 ; j<10 ; j++){
          count+=F[k][j] &(i>>j & 1);
        }
        tmp+=P[k][count];
      }
      ans=Math.max(ans,tmp);
    }
    out.println(ans);
  }
  public static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1000000007;
  static    attribute INF : int := 1000000000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var F : Sequence(Sequence(int)) ; F := Integer.subrange(1,N)->collect(Integer.subrange(1,10)->collect(null)) ;
    var P : Sequence(Sequence(int)) ; P := Integer.subrange(1,N)->collect(Integer.subrange(1,11)->collect(null)) ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < 10 do ( (     F[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < 11 do ( (     P[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -INF ;
        var i : int ; i := 1 ; while i < ((1*(2->pow(10)))->oclAsType(long)) do ( (     var tmp : int ; tmp := 0 ;
         var k : int ; k := 0 ; while k < N do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < 10 do ( (     count := count+(F[k+1][j+1] & (MathLib.bitwiseAnd((i/(2->pow(j)))->oclAsType(long),1))) )  ;     j := j + 1 ) ; 
     tmp := tmp+(P[k+1][count+1]) )  ;     k := k + 1 ) ; 
     ans := Set{ans, tmp}->max() )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      int N=Integer.parseInt(br.readLine());
      int[] F=new int[N];
      for(int i=0 ; i<N ; i++){
        F[i]=Integer.parseInt(br.readLine().replaceAll(" ",""),2);
      }
      int[][] P=new int[N][11];
      for(int i=0 ; i<N ; i++){
        P[i]=Arrays.stream(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
      }
      int max=Integer.MIN_VALUE ;
      for(int mask=1 ; mask<=0b11_1111_1111 ; mask++){
        int value=0 ;
        for(int i=0 ; i<N ; i++){
          int order=mask & F[i];
          value+=P[i][Integer.bitCount(order)];
        }
        max=Math.max(max,value);
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var N : int ; N := (br.readLine())->toInteger() ;
     var F : Sequence(int) ; F := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     F[i+1] := (br.readLine().replaceAllMatches(" ", "" ))->toInteger() )  ;     i := i + 1 ) ; 
    var P : Sequence(Sequence(int)) ; P := Integer.subrange(1,N)->collect(Integer.subrange(1,11)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     P[i+1] := stream(br.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
        var mask : int ; mask := 1 ; while mask <= 0b11    try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var N : int ; N := (br.readLine())->toInteger() ;
     var F : Sequence(int) ; F := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     F[i+1] := (br.readLine().replaceAllMatches(" ", "" ))->toInteger() )  ;     i := i + 1 ) ; 
    var P : Sequence(Sequence(int)) ; P := Integer.subrange(1,N)->collect(Integer.subrange(1,11)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     P[i+1] := stream(br.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
        var mask : int ; mask := 1 ; while mask <= 0b11    try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var N : int ; N := (br.readLine())->toInteger() ;
     var F : Sequence(int) ; F := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     F[i+1] := (br.readLine().replaceAllMatches(" ", "" ))->toInteger() )  ;     i := i + 1 ) ; 
    var P : Sequence(Sequence(int)) ; P := Integer.subrange(1,N)->collect(Integer.subrange(1,11)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     P[i+1] := stream(br.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
        var mask : int ; mask := 1 ; while mask <= 0b11_1111_1111 do ( (     var value : int ; value := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     var order : int ; order := MathLib.bitwiseAnd(mask,F[i+1]) ;
     value := value+(P[i+1][bitCount(order)+1]) )  ;     i := i + 1 ) ; 
     max := Set{max, value}->max() )  ;     mask := mask + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ))  
111    try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var N : int ; N := (br.readLine())->toInteger() ;
     var F : Sequence(int) ; F := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     F[i+1] := (br.readLine().replaceAllMatches(" ", "" ))->toInteger() )  ;     i := i + 1 ) ; 
    var P : Sequence(Sequence(int)) ; P := Integer.subrange(1,N)->collect(Integer.subrange(1,11)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     P[i+1] := stream(br.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
        var mask : int ; mask := 1 ; while mask <= 0b11_1111_1111 do ( (     var value : int ; value := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     var order : int ; order := MathLib.bitwiseAnd(mask,F[i+1]) ;
     value := value+(P[i+1][bitCount(order)+1]) )  ;     i := i + 1 ) ; 
     max := Set{max, value}->max() )  ;     mask := mask + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ))  
111 do ( (     var value : int ; value := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     var order : int ; order := MathLib.bitwiseAnd(mask,F[i+1]) ;
     value := value+(P[i+1][bitCount(order)+1]) )  ;     i := i + 1 ) ; 
     max := Set{max, value}->max() )  ;     mask := mask + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 )) 111    try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var N : int ; N := (br.readLine())->toInteger() ;
     var F : Sequence(int) ; F := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     F[i+1] := (br.readLine().replaceAllMatches(" ", "" ))->toInteger() )  ;     i := i + 1 ) ; 
    var P : Sequence(Sequence(int)) ; P := Integer.subrange(1,N)->collect(Integer.subrange(1,11)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     P[i+1] := stream(br.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
        var mask : int ; mask := 1 ; while mask <= 0b11    try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var N : int ; N := (br.readLine())->toInteger() ;
     var F : Sequence(int) ; F := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     F[i+1] := (br.readLine().replaceAllMatches(" ", "" ))->toInteger() )  ;     i := i + 1 ) ; 
    var P : Sequence(Sequence(int)) ; P := Integer.subrange(1,N)->collect(Integer.subrange(1,11)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     P[i+1] := stream(br.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
        var mask : int ; mask := 1 ; while mask <= 0b11_1111_1111 do ( (     var value : int ; value := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     var order : int ; order := MathLib.bitwiseAnd(mask,F[i+1]) ;
     value := value+(P[i+1][bitCount(order)+1]) )  ;     i := i + 1 ) ; 
     max := Set{max, value}->max() )  ;     mask := mask + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ))  
111    try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var N : int ; N := (br.readLine())->toInteger() ;
     var F : Sequence(int) ; F := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     F[i+1] := (br.readLine().replaceAllMatches(" ", "" ))->toInteger() )  ;     i := i + 1 ) ; 
    var P : Sequence(Sequence(int)) ; P := Integer.subrange(1,N)->collect(Integer.subrange(1,11)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     P[i+1] := stream(br.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
        var mask : int ; mask := 1 ; while mask <= 0b11_1111_1111 do ( (     var value : int ; value := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     var order : int ; order := MathLib.bitwiseAnd(mask,F[i+1]) ;
     value := value+(P[i+1][bitCount(order)+1]) )  ;     i := i + 1 ) ; 
     max := Set{max, value}->max() )  ;     mask := mask + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ))  
111 do ( (     var value : int ; value := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     var order : int ; order := MathLib.bitwiseAnd(mask,F[i+1]) ;
     value := value+(P[i+1][bitCount(order)+1]) )  ;     i := i + 1 ) ; 
     max := Set{max, value}->max() )  ;     mask := mask + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 )) 111 do ( (     var value : int ; value := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     var order : int ; order := MathLib.bitwiseAnd(mask,F[i+1]) ;
     value := value+(P[i+1][bitCount(order)+1]) )  ;     i := i + 1 ) ; 
     max := Set{max, value}->max() )  ;     mask := mask + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int DAYS=5 ;
    int TIME=2 ;
    int[][][] F=new int[N][DAYS][TIME];
    for(int n=0 ; n<N ; n++){
      for(int d=0 ; d<DAYS ; d++){
        for(int t=0 ; t<TIME ; t++){
          F[n][d][t]=sc.nextInt();
        }
      }
    }
    int TOGETHER_DAYTIME=11 ;
    long[][] P=new long[N][TOGETHER_DAYTIME];
    for(int n=0 ; n<N ; n++){
      for(int dt=0 ; dt<TOGETHER_DAYTIME ; dt++){
        P[n][dt]=sc.nextLong();
      }
    }
    long max=Long.MIN_VALUE ;
    for(int dt=0 ; dt<2<<DAYS*TIME ; dt++){
      long tmpMax=0 ;
      boolean haveTogetherShop=false ;
      for(int n=0 ; n<N ; n++){
        int cnt=0 ;
        for(int d1=0 ; d1<DAYS ; d1++){
          int timeBit=(dt>>d1*TIME)& 3 ;
          for(int t1=0 ; t1<TIME ; t1++){
            if(((timeBit>>t1)& 1)==1 && F[n][d1][t1]==1){
              cnt++;
              haveTogetherShop=true ;
            }
          }
        }
        tmpMax+=P[n][cnt];
      }
      if(haveTogetherShop){
        max=Math.max(max,tmpMax);
      }
    }
    out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var DAYS : int ; DAYS := 5 ;
    var TIME : int ; TIME := 2 ;
    var F : Sequence(Sequence(Sequence(int))) ; F := Integer.subrange(1,N)->collect(Integer.subrange(1,DAYS)->collect(Integer.subrange(1,TIME)->collect(0))) ;
        var n : int ; n := 0 ; while n < N do ( (         var d : int ; d := 0 ; while d < DAYS do ( (         var t : int ; t := 0 ; while t < TIME do ( (     F[n+1][d+1][t+1] := sc.getCurrent()->toInteger() )  ;     t := t + 1 ) )  ;     d := d + 1 ) )  ;     n := n + 1 ) ; 
    var TOGETHER_DAYTIME : int ; TOGETHER_DAYTIME := 11 ;
    var P : Sequence(Sequence(long)) ; P := Integer.subrange(1,N)->collect(Integer.subrange(1,TOGETHER_DAYTIME)->collect(0)) ;
        var n : int ; n := 0 ; while n < N do ( (         var dt : int ; dt := 0 ; while dt < TOGETHER_DAYTIME do ( (     P[n+1][dt+1] := sc.getCurrent()->toLong() )  ;     dt := dt + 1 ) )  ;     n := n + 1 ) ; 
    var max : long ; max := "-9223372036854775808"->toLong() ;
        var dt : int ; dt := 0 ; while dt < (2*(2->pow(DAYS * TIME)))->oclAsType(long) do ( (     var tmpMax : long ; tmpMax := 0 ;
     var haveTogetherShop : boolean ; haveTogetherShop := false ;
         var n : int ; n := 0 ; while n < N do ( (     var cnt : int ; cnt := 0 ;
         var d1 : int ; d1 := 0 ; while d1 < DAYS do ( (     var timeBit : int ; timeBit := MathLib.bitwiseAnd(((dt/(2->pow(d1 * TIME)))->oclAsType(long)),3) ;
         var t1 : int ; t1 := 0 ; while t1 < TIME do ( (     if ((((timeBit/(2->pow(t1)))->oclAsType(long)) & 1) = 1 & F[n+1][d1+1][t1+1] = 1) then (     cnt := cnt + 1 ; 
     haveTogetherShop := true ) else skip )  ;     t1 := t1 + 1 ) )  ;     d1 := d1 + 1 ) ; 
     tmpMax := tmpMax+(P[n+1][cnt+1]) )  ;     n := n + 1 ) ; 
     if (haveTogetherShop) then (     max := Set{max, tmpMax}->max() ) else skip )  ;     dt := dt + 1 ) ; 
    out.println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maxFreq(String s,int a,int b){
    int fre[]=new int[10];
    int n=s.length();
    if(a>b){
      int temp=a ;
      a=b ;
      b=temp ;
    }
    for(int i=0 ; i<n ; i++)fre[s.charAt(i)-'0']++;
    if(fre[a]==0 && fre[b]==0)return-1 ;
    else if(fre[a]>=fre[b])return a ;
    else return b ;
  }
  public static void main(String[] args){
    int a=4,b=7 ;
    String s="47744" ;
    System.out.print(maxFreq(s,a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxFreq( s : String, a : int, b : int) : int
  pre: true
  post: true
  activity: (     var fre : Sequence(int) ; fre := Integer.subrange(1,10)->collect(0) ;
     var n : int ; n := s->size() ;
    if (a > b) then (     var temp : int ; temp := a ;
     a := b ; 
     b := temp ) else skip ; 
        var i : int ; i := 0 ; while i < n do (     fre[s->at(i+1) - ('0')->char2byte()+1] := fre[s->at(i+1) - ('0')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    if (fre[a+1] = 0 & fre[b+1] = 0) then     return -1 else     if (fre[a+1] >= fre[b+1]) then     return a else     return b ;  ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 4 ;
    var b : int ; b := 7 ;
     var s : String ; s := "47744" ;
     OclFile["System.out"].print(maxFreq(s, a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static int n ;
  static int[][] f ;
  static int[][] p ;
  static int[] a ;
  static int ans ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    f=new int[n][10];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<10 ; j++){
        f[i][j]=sc.nextInt();
      }
    }
    p=new int[n][11];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<11 ; j++){
        p[i][j]=sc.nextInt();
      }
    }
    sc.close();
    a=new int[10];
    ans=Integer.MIN_VALUE ;
    dfs(0);
    System.out.println(ans);
  }
  static void dfs(int index){
    if(index==10){
      if(Arrays.toString(a).equals("[0,0,0,0,0,0,0,0,0,0] "))return ;
      memo();
      return ;
    }
    else {
      a[index]=0 ;
      dfs(index+1);
      a[index]=1 ;
      dfs(index+1);
    }
  }
  static void memo(){
    int partAns=0 ;
    for(int i=0 ; i<n ; i++){
      int count=0 ;
      for(int j=0 ; j<10 ; j++){
        if(a[j]==1 && f[i][j]==1){
          count++;
        }
      }
      partAns+=p[i][count];
    }
    ans=Math.max(partAns,ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute f : Sequence(Sequence(int));
  static   attribute p : Sequence(Sequence(int));
  static   attribute a : Sequence(int);
  static   attribute ans : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    f := Integer.subrange(1,n)->collect(Integer.subrange(1,10)->collect(0)) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 10 do ( (     f[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    p := Integer.subrange(1,n)->collect(Integer.subrange(1,11)->collect(0)) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 11 do ( (     p[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    a := Integer.subrange(1,10)->collect(0) ; 
    ans := -2147483648 ; 
    execute dfs(0) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation dfs( index : int) : void
  pre: true
  post: true
  activity: (     if (index = 10) then (     if ((a + "") = "[0,0,0,0,0,0,0,0,0,0] ") then     return else skip ; 
     execute memo() ; 
     return ) else (     a[index+1] := 0 ; 
     execute dfs(index + 1) ; 
     a[index+1] := 1 ; 
     execute dfs(index + 1) ) );
  static   operation memo() : void
  pre: true
  post: true
  activity: (     var partAns : int ; partAns := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < 10 do ( (     if (a[j+1] = 1 & f[i+1][j+1] = 1) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
     partAns := partAns+(p[i+1][count+1]) )  ;     i := i + 1 ) ; 
     ans := Set{partAns, ans}->max() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
import java.util.*;
class GFG {
  public static void findX(int[] a,int n){
    Collections.sort(Arrays.asList(a),null);
    int itr=a[n-1];
    int p=(int)(Math.log(itr)/Math.log(2))+1 ;
    int x=0 ;
    for(int i=0 ; i<p ; i++){
      int count=0 ;
      for(int j=0 ; j<n ; j++){
        if((a[j] &(1<<i))!=0)count++;
      }
      if(count>(n/2)){
        x+=1<<i ;
      }
    }
    long sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=(x ^ a[i]);
    System.out.println("X="+x+",Sum="+sum);
  }
  public static void main(String[] args){
    int[] a={
      2,3,4,5,6 };
      int n=a.length ;
      findX(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findX( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     a, null := a, null->sort() ; 
     var itr : int ; itr := a[n - 1+1] ;
    var p : int ; p := ((itr)->log() / (2)->log())->oclAsType(int) + 1 ;
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < p do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if ((a[j+1] & ((1*(2->pow(i)))->oclAsType(long))) /= 0) then     count := count + 1 ; else skip )  ;     j := j + 1 ) ; 
     if (count > (n / 2)) then (     x := x+((1*(2->pow(i)))->oclAsType(long)) ) else skip )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (     sum := sum+((MathLib.bitwiseXor(x,a[i+1]))) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("X=" + x + ",Sum=" + sum) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,3,4,5,6} ;
     var n : int ; n := a->size() ;
     execute findX(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int sum_series(int n){
    int nSquare=n*n ;
    return nSquare*(nSquare-1)/4 ;
  }
  public static void main(String[] args){
    int n=2 ;
    System.out.println(sum_series(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sum_series( n : int) : int
  pre: true
  post: true
  activity: (     var nSquare : int ; nSquare := n * n ;
     return nSquare * (nSquare - 1) / 4 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(sum_series(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.HashMap ;
import java.util.Map.Entry ;
import java.util.Map ;
import java.lang.*;
class GFG {
  static int maxlenAP(int a[],int n,int d){
    HashMap<Integer,Integer>m=new HashMap<Integer,Integer>();
    int maxt=1 ;
    for(int i=0 ; i<n ; i++){
      if(m.containsKey(a[i]-i*d)){
        int freq=m.get(a[i]-i*d);
        freq++;
        m.put(a[i]-i*d,freq);
      }
      else {
        m.put(a[i]-i*d,1);
      }
    }
    for(Entry<Integer,Integer>val : m.entrySet()){
      if(maxt<val.getValue())maxt=val.getValue();
    }
    return maxt ;
  }
  public static void main(String[] args){
    int n=10,d=3 ;
    int a[]=new int[] {
      1,4,2,5,20,11,56,100,20,23 };
      System.out.print(maxlenAP(a,n,d)+"\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxlenAP( a : Sequence(int), n : int, d : int) : int
  pre: true
  post: true
  activity: (     var m : Map(int,int) ; m := Map{} ;
     var maxt : int ; maxt := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (m->keys()->includes(a[i+1] - i * d)) then (     var freq : int ; freq := m->at(a[i+1] - i * d) ;
     freq := freq + 1 ; 
     m := m->union(Map{a[i+1] - i * d |-> freq}) ) else (     m := m->union(Map{a[i+1] - i * d |-> 1}) ) )  ;     i := i + 1 ) ; 
    for (val : m->asSet()) do ( (     if (maxt < val.getValue()) then     maxt := val.getValue() ; else skip )  ) ; 
    return maxt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
    var d : int ; d := 3 ;
     var a : Sequence(int) ; a := Sequence{1,4,2,5,20,11,56,100,20,23} ;
     OclFile["System.out"].print(maxlenAP(a, n, d) + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void type1(int[] arr,int start,int limit){
    for(int i=start ; i<=limit ; i++)arr[i]++;
  }
  static void type2(int[] arr,int[][] query,int start,int limit){
    for(int i=start ; i<=limit ; i++){
      if(query[i][0]==1)type1(arr,query[i][1],query[i][2]);
      else if(query[i][0]==2)type2(arr,query,query[i][1],query[i][2]);
    }
  }
  public static void main(String[] args){
    int n=5,m=5 ;
    int[] arr=new int[n+1];
    int[] temp={
      1,1,2,1,4,5,2,1,2,2,1,3,2,3,4 };
      int[][] query=new int[6][4];
      int j=0 ;
      for(int i=1 ; i<=m ; i++){
        query[i][0]=temp[j++];
        query[i][1]=temp[j++];
        query[i][2]=temp[j++];
      }
      for(int i=1 ; i<=m ; i++)if(query[i][0]==1)type1(arr,query[i][1],query[i][2]);
      else if(query[i][0]==2)type2(arr,query,query[i][1],query[i][2]);
      for(int i=1 ; i<=n ; i++)System.out.print(arr[i]+" ");
      System.out.println();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation type1( arr : Sequence(int), start : int, limit : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := start ; while i <= limit do (     arr[i+1] := arr[i+1] + 1 ;  ;     i := i + 1 ) );
  static   operation type2( arr : Sequence(int), query : Sequence(Sequence(int)), start : int, limit : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := start ; while i <= limit do ( (     if (query[i+1][0+1] = 1) then     execute type1(arr, query[i+1][1+1], query[i+1][2+1]) ; else     if (query[i+1][0+1] = 2) then     execute type2(arr, query, query[i+1][1+1], query[i+1][2+1]) ; else skip ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var m : int ; m := 5 ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
    var temp : Sequence(int) ; temp := Sequence{1,1,2,1,4,5,2,1,2,2,1,3,2,3,4} ;
    var query : Sequence(Sequence(int)) ; query := Integer.subrange(1,6)->collect(Integer.subrange(1,4)->collect(0)) ;
    var j : int ; j := 0 ;
        var i : int ; i := 1 ; while i <= m do ( (      query[i+1][0+1] := temp[j+1]  ; j := j + 1 ; 
      query[i+1][1+1] := temp[j+1]  ; j := j + 1 ; 
      query[i+1][2+1] := temp[j+1]  ; j := j + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= m do (     if (query[i+1][0+1] = 1) then     execute type1(arr, query[i+1][1+1], query[i+1][2+1]) else     if (query[i+1][0+1] = 2) then     execute type2(arr, query, query[i+1][1+1], query[i+1][2+1]) ; else skip ; ;   ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Odd_Selection {
  public static void main(String[] args)throws Exception {
    InputStreamReader r=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(r);
    PrintWriter p=new PrintWriter(System.out);
    int test=1 ;
    me146 : while(test-->0){
      String str[]=br.readLine().trim().split(" ");
      int n=Integer.parseInt(str[0]);
      str=br.readLine().trim().split(" ");
      int a[]=new int[n+1];
      for(int i=0 ; i<n ; i++){
        a[i+1]=Integer.parseInt(str[i]);
        a[i+1]+=a[i];
      }
      int answer=0 ;
      for(int i=n ; i>=0 ; i--){
        if(isPossible(a,i,n)){
          answer=i ;
          break ;
        }
      }
      p.print(answer);
    }
    p.flush();
  }
  static boolean isPossible(int a[],int target,int n){
    for(int i=0 ; i+target<=n ; i++){
      int val=a[i+target]-a[i];
      if(val>target*100){
        return true ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Odd_Selection {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(r) ;
    var p : OclFile ; p := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := 1 ;
        while (test > 0) do (        test := test - 1 ;     skip ; (     var str : Sequence(String) ; str := br.readLine()->trim()->split(" ") ;
     var n : int ; n := (str[0+1])->toInteger() ;
    str := br.readLine()->trim()->split(" ") ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i + 1+1] := (str[i+1])->toInteger() ; 
     a[i + 1+1] := a[i + 1+1]+(a[i+1]) )  ;     i := i + 1 ) ; 
    var answer : int ; answer := 0 ;
        var i : int ; i := n ; while i >= 0 do ( (     if (isPossible(a, i, n)) then (     answer := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static   operation isPossible( a : Sequence(int), target : int, n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i + target <= n do ( (     var val : int ; val := a[i + target+1] - a[i+1] ;
     if (val > target * 100) then (     return true ) else skip )  ;     i := i + 1 ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class DDoS {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    String[] temp=br.readLine().split(" ");
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=Integer.parseInt(temp[i]);
    }
    int[] preSum=new int[n+1];
    for(int i=0 ; i<n ; i++){
      preSum[i+1]=preSum[i]+nums[i];
    }
    for(int len=n ; len>=1 ; len--){
      if(check(preSum,len)){
        pr.println(len);
        return ;
      }
    }
    pr.println(0);
  }
  public static boolean check(int[] preSum,int len){
    int minRequired=len*100 ;
    int n=preSum.length-1 ;
    for(int i=0 ; i+len-1<n ; i++){
      int sum=preSum[i+len]-preSum[i];
      if(sum>minRequired){
        return true ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class DDoS {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := (temp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var preSum : Sequence(int) ; preSum := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     preSum[i + 1+1] := preSum[i+1] + nums[i+1] )  ;     i := i + 1 ) ; 
        var len : int ; len := n ; while len >= 1 do ( (     if (check(preSum, len)) then (     skip ; 
     return ) else skip )  ;     len := len - 1 ) ; 
    skip ; 
 );
  static   operation check( preSum : Sequence(int), len : int) : boolean
  pre: true
  post: true
  activity: (     var minRequired : int ; minRequired := len * 100 ;
     var n : int ; n := preSum->size() - 1 ;
         var i : int ; i := 0 ; while i + len - 1 < n do ( (     var sum : int ; sum := preSum[i + len+1] - preSum[i+1] ;
     if (sum > minRequired) then (     return true ) else skip )  ;     i := i + 1 ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    for(int i=0 ; i<T ; i++){
      int size=sc.nextInt();
      int[] arr=new int[size];
      for(int j=0 ; j<size ; j++){
        arr[j]=sc.nextInt();
      }
      int ans=1 ;
      if(arr[0]==1)ans+=1 ;
      boolean flag=false ;
      for(int j=1 ; j<size ; j++){
        if(arr[j]==1){
          if(arr[j-1]==1){
            ans+=5 ;
          }
          else {
            ans+=1 ;
          }
        }
        else {
          if(arr[j-1]==0){
            flag=true ;
            ans=-1 ;
            break ;
          }
          else {
          }
        }
      }
      if(flag){
        System.out.println(ans);
      }
      else {
        System.out.println(ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < T do ( (     var size : int ; size := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
        var j : int ; j := 0 ; while j < size do ( (     arr[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    var ans : int ; ans := 1 ;
    if (arr[0+1] = 1) then     ans := ans+(1) ; else skip ; 
    var flag : boolean ; flag := false ;
        var j : int ; j := 1 ; while j < size do ( (     if (arr[j+1] = 1) then (     if (arr[j - 1+1] = 1) then (     ans := ans+(5) ) else (     ans := ans+(1) ) ) else (     if (arr[j - 1+1] = 0) then (     flag := true ; 
     ans := -1 ; 
     break ) else skip ) )  ;     j := j + 1 ) ; 
    if (flag) then (     OclFile["System.out"].println(ans) ) else (     OclFile["System.out"].println(ans) ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      int c=scanner.nextInt();
      if((n | c)==0)break ;
      int[] a=new int[n];
      int[] b=new int[c];
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<16 ; j++)a[i] |=(scanner.nextInt()<<j);
      for(int i=0 ; i<c ; i++)for(int j=0 ; j<16 ; j++)b[i] |=(scanner.nextInt()<<j);
      int[][] dp=new int[n+1][1<<16];
      for(int i=0 ; i<=n ; i++)Arrays.fill(dp[i],-1);
      dp[0][0]=0 ;
      for(int i=0 ; i<n ; i++){
        for(int S=0 ; S<1<<16 ; S++){
          if(dp[i][S]==-1)continue ;
          int light=S | a[i];
          for(int j=0 ; j<c ; j++){
            int pushed=light & b[j];
            int point=Integer.bitCount(pushed);
            int nx=light & ~ b[j];
            if(dp[i+1][nx]<point+dp[i][S])dp[i+1][nx]=point+dp[i][S];
          }
        }
      }
      int max=0 ;
      for(int i=0 ; i<1<<16 ; i++)max=Math.max(max,dp[n][i]);
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var c : int ; c := scanner.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,c)) = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,c)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < 16 do (     a[i+1] := MathLib.bitwiseOr(a[i+1], ((scanner.getCurrent()->toInteger()*(2->pow(j)))->oclAsType(long))) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < c do (         var j : int ; j := 0 ; while j < 16 do (     b[i+1] := MathLib.bitwiseOr(b[i+1], ((scanner.getCurrent()->toInteger()*(2->pow(j)))->oclAsType(long))) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,(1*(2->pow(16)))->oclAsType(long))->collect(0)) ;
        var i : int ; i := 0 ; while i <= n do (     dp[i+1] := dp[i+1]->collect(-1) ;  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (         var S : int ; S := 0 ; while S < (1*(2->pow(16)))->oclAsType(long) do ( (     if (dp[i+1][S+1] = -1) then     continue else skip ; 
     var light : int ; light := MathLib.bitwiseOr(S,a[i+1]) ;
         var j : int ; j := 0 ; while j < c do ( (     var pushed : int ; pushed := MathLib.bitwiseAnd(light,b[j+1]) ;
     var point : int ; point := bitCount(pushed) ;
     var nx : int ; nx := MathLib.bitwiseAnd(light,-(b[j+1] + 1)) ;
     if (dp[i + 1+1][nx+1] < point + dp[i+1][S+1]) then     dp[i + 1+1][nx+1] := point + dp[i+1][S+1] ; else skip )  ;     j := j + 1 ) )  ;     S := S + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < (1*(2->pow(16)))->oclAsType(long) do (     max := Set{max, dp[n+1][i+1]}->max() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      int c=scanner.nextInt();
      if((n | c)==0)break ;
      int[] a=new int[n];
      int[] b=new int[c];
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<16 ; j++)a[i]+=(scanner.nextInt()<<j);
      for(int i=0 ; i<c ; i++)for(int j=0 ; j<16 ; j++)b[i]+=(scanner.nextInt()<<j);
      int[][] dp=new int[n+1][1<<16];
      for(int i=0 ; i<=n ; i++)Arrays.fill(dp[i],-1);
      dp[0][0]=0 ;
      for(int i=0 ; i<n ; i++){
        for(int S=0 ; S<1<<16 ; S++){
          if(dp[i][S]==-1)continue ;
          int light=S | a[i];
          for(int j=0 ; j<c ; j++){
            int pushed=light & b[j];
            int point=Integer.bitCount(pushed);
            int nx=light & ~ b[j];
            if(dp[i+1][nx]<point+dp[i][S])dp[i+1][nx]=point+dp[i][S];
          }
        }
      }
      int max=0 ;
      for(int i=0 ; i<1<<16 ; i++)max=Math.max(max,dp[n][i]);
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var c : int ; c := scanner.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,c)) = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,c)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < 16 do (     a[i+1] := a[i+1]+(((scanner.getCurrent()->toInteger()*(2->pow(j)))->oclAsType(long))) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < c do (         var j : int ; j := 0 ; while j < 16 do (     b[i+1] := b[i+1]+(((scanner.getCurrent()->toInteger()*(2->pow(j)))->oclAsType(long))) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,(1*(2->pow(16)))->oclAsType(long))->collect(0)) ;
        var i : int ; i := 0 ; while i <= n do (     dp[i+1] := dp[i+1]->collect(-1) ;  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (         var S : int ; S := 0 ; while S < (1*(2->pow(16)))->oclAsType(long) do ( (     if (dp[i+1][S+1] = -1) then     continue else skip ; 
     var light : int ; light := MathLib.bitwiseOr(S,a[i+1]) ;
         var j : int ; j := 0 ; while j < c do ( (     var pushed : int ; pushed := MathLib.bitwiseAnd(light,b[j+1]) ;
     var point : int ; point := bitCount(pushed) ;
     var nx : int ; nx := MathLib.bitwiseAnd(light,-(b[j+1] + 1)) ;
     if (dp[i + 1+1][nx+1] < point + dp[i+1][S+1]) then     dp[i + 1+1][nx+1] := point + dp[i+1][S+1] ; else skip )  ;     j := j + 1 ) )  ;     S := S + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < (1*(2->pow(16)))->oclAsType(long) do (     max := Set{max, dp[n+1][i+1]}->max() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.util.*;
class Main {
  static int[] parents ;
  static int[] weight ;
  static int[] rank ;
  static int find(int x){
    if(x==parents[x])return x ;
    else {
      int r=find(parents[x]);
      weight[x]+=weight[parents[x] ];
      return parents[x]=r ;
    }
  }
  static int weight(int x){
    find(x);
    return weight[x];
  }
  static void relate(int x,int y,int z){
    z+=weight(x);
    z-=weight(y);
    x=find(x);
    y=find(y);
    if(x==y)return ;
    if(rank[x]<rank[y]){
      int tmp=x ;
      x=y ;
      y=tmp ;
      z=-z ;
    }
    if(rank[x]==rank[y]){
      rank[x]++;
    }
    parents[y]=x ;
    weight[y]=z ;
  }
  static void diff(int x,int y){
    if(find(x)==find(y)){
      System.out.println(weight(y)-weight(x));
    }
    else {
      System.out.println("?");
    }
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int q=scanner.nextInt();
    parents=new int[n];
    weight=new int[n];
    rank=new int[n];
    for(int i=0 ; i<n ; i++){
      parents[i]=i ;
    }
    int type,x,y,z ;
    for(int i=0 ; i<q ; i++){
      type=scanner.nextInt();
      x=scanner.nextInt();
      y=scanner.nextInt();
      if(type==0){
        z=scanner.nextInt();
        relate(x,y,z);
      }
      else {
        diff(x,y);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute parents : Sequence(int);
  static   attribute weight : Sequence(int);
  static   attribute rank : Sequence(int);
  static   operation find( x : int) : int
  pre: true
  post: true
  activity: (     if (x = parents[x+1]) then     return x else (     var r : int ; r := find(parents[x+1]) ;
     weight[x+1] := weight[x+1]+(weight[parents[x+1]+1]) ; 
     return parents[x+1] ) );
  static   operation weight( x : int) : int
  pre: true
  post: true
  activity: (     execute find(x) ; 
     return weight[x+1] );
  static   operation relate( x : int, y : int, z : int) : void
  pre: true
  post: true
  activity: (     z := z+(weight(x)) ; 
     z := z-(weight(y)) ; 
    x := find(x) ; 
    y := find(y) ; 
    if (x = y) then     return else skip ; 
    if (rank[x+1] < rank[y+1]) then (     var tmp : int ; tmp := x ;
     x := y ; 
     y := tmp ; 
     z := -z ) else skip ; 
    if (rank[x+1] = rank[y+1]) then (     rank[x+1] := rank[x+1] + 1 ) else skip ; 
    parents[y+1] := x ; 
    weight[y+1] := z ; 
 );
  static   operation diff( x : int, y : int) : void
  pre: true
  post: true
  activity: (     if (find(x) = find(y)) then (     OclFile["System.out"].println(weight(y) - weight(x)) ) else (     OclFile["System.out"].println("?") ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var q : int ; q := scanner.getCurrent()->toInteger() ;
    parents := Integer.subrange(1,n)->collect(0) ; 
    weight := Integer.subrange(1,n)->collect(0) ; 
    rank := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     parents[i+1] := i )  ;     i := i + 1 ) ; 
    var type : int ;
    var x : int ;
    var y : int ;
    var z : int ;
        var i : int ; i := 0 ; while i < q do ( (     type := scanner.getCurrent()->toInteger() ; 
     x := scanner.getCurrent()->toInteger() ; 
     y := scanner.getCurrent()->toInteger() ; 
     if (type = 0) then (     z := scanner.getCurrent()->toInteger() ; 
     execute relate(x, y, z) ) else (     execute diff(x, y) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxZeros(int n){
    if(n==0 ||(n &(n-1))==0){
      return-1 ;
    }
    byte b=4 ;
    int setBit=1,prev=0,i ;
    for(i=1 ; i<=b*8 ; i++){
      prev++;
      if((n & setBit)==setBit){
        setBit=setBit<<1 ;
        break ;
      }
      setBit=setBit<<1 ;
    }
    int max0=Integer.MIN_VALUE,cur=prev ;
    for(int j=i+1 ; j<=b*8 ; j++){
      cur++;
      if((n & setBit)==setBit){
        if(max0<(cur-prev-1)){
          max0=cur-prev-1 ;
        }
        prev=cur ;
      }
      setBit=setBit<<1 ;
    }
    return max0 ;
  }
  static public void main(String[] args){
    int n=549 ;
    System.out.println(maxZeros(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxZeros( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0 or (n & (n - 1)) = 0) then (     return -1 ) else skip ; 
     var b : int ; b := 4 ;
    var setBit : int ; setBit := 1 ;
    var prev : int ; prev := 0 ;
    var i : int ;
        i := 1 ; while i <= b * 8 do ( (     prev := prev + 1 ; 
     if ((n & setBit) = setBit) then (     setBit := (setBit*(2->pow(1)))->oclAsType(long) ; 
     break ) else skip ; 
     setBit := (setBit*(2->pow(1)))->oclAsType(long) )  ;     i := i + 1 ) ; 
    var max0 : int ; max0 := -2147483648 ;
    var cur : int ; cur := prev ;
        var j : int ; j := i + 1 ; while j <= b * 8 do ( (     cur := cur + 1 ; 
     if ((n & setBit) = setBit) then (     if (max0 < (cur - prev - 1)) then (     max0 := cur - prev - 1 ) else skip ; 
     prev := cur ) else skip ; 
     setBit := (setBit*(2->pow(1)))->oclAsType(long) )  ;     j := j + 1 ) ; 
    return max0 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 549 ;
     OclFile["System.out"].println(maxZeros(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      int c=scanner.nextInt();
      if((n | c)==0)break ;
      int[] a=new int[n];
      int[] b=new int[c];
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<16 ; j++)a[i]+=(scanner.nextInt()<<j);
      for(int i=0 ; i<c ; i++)for(int j=0 ; j<16 ; j++)b[i]+=(scanner.nextInt()<<j);
      int[][] dp=new int[n+1][1<<16];
      for(int i=0 ; i<=n ; i++)Arrays.fill(dp[i],-1);
      dp[0][0]=0 ;
      for(int i=0 ; i<n ; i++){
        for(int S=0 ; S<1<<16 ; S++){
          if(dp[i][S]==-1)continue ;
          int light=S | a[i];
          for(int j=0 ; j<c ; j++){
            int pushed=light & b[j];
            int point=Integer.bitCount(pushed)+dp[i][S];
            int nx=light & ~ b[j];
            dp[i+1][nx]=Math.max(dp[i+1][nx],point);
          }
        }
      }
      int max=0 ;
      for(int i=0 ; i<1<<16 ; i++)max=Math.max(max,dp[n][i]);
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var c : int ; c := scanner.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,c)) = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,c)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < 16 do (     a[i+1] := a[i+1]+(((scanner.getCurrent()->toInteger()*(2->pow(j)))->oclAsType(long))) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < c do (         var j : int ; j := 0 ; while j < 16 do (     b[i+1] := b[i+1]+(((scanner.getCurrent()->toInteger()*(2->pow(j)))->oclAsType(long))) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,(1*(2->pow(16)))->oclAsType(long))->collect(0)) ;
        var i : int ; i := 0 ; while i <= n do (     dp[i+1] := dp[i+1]->collect(-1) ;  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (         var S : int ; S := 0 ; while S < (1*(2->pow(16)))->oclAsType(long) do ( (     if (dp[i+1][S+1] = -1) then     continue else skip ; 
     var light : int ; light := MathLib.bitwiseOr(S,a[i+1]) ;
         var j : int ; j := 0 ; while j < c do ( (     var pushed : int ; pushed := MathLib.bitwiseAnd(light,b[j+1]) ;
     var point : int ; point := bitCount(pushed) + dp[i+1][S+1] ;
     var nx : int ; nx := MathLib.bitwiseAnd(light,-(b[j+1] + 1)) ;
     dp[i + 1+1][nx+1] := Set{dp[i + 1+1][nx+1], point}->max() )  ;     j := j + 1 ) )  ;     S := S + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < (1*(2->pow(16)))->oclAsType(long) do (     max := Set{max, dp[n+1][i+1]}->max() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int[][] dp=new int[2][1<<16];
    for(; ; ){
      int n=sc.nextInt(),c=sc.nextInt();
      if(n+c==0)break ;
      int[] a=new int[n],b=new int[c];
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<16 ; j++)a[i]=(a[i]<<1)+sc.nextInt();
      for(int i=0 ; i<c ; i++)for(int j=0 ; j<16 ; j++)b[i]=(b[i]<<1)+sc.nextInt();
      Arrays.fill(dp[0],-1);
      dp[0][0]=0 ;
      int X=1 ;
      for(int i=0 ; i<n ; i++,X=1-X){
        Arrays.fill(dp[X],-1);
        for(int S=0 ; S<1<<16 ; S++)if(dp[1-X][S]!=-1){
          int light=S | a[i];
          for(int j=0 ; j<c ; j++){
            int pushed=light & b[j];
            int point=Integer.bitCount(pushed);
            int nx=light & ~ pushed ;
            dp[X][nx]=Math.max(dp[X][nx],dp[1-X][S]+point);
          }
        }
      }
      int res=0 ;
      for(int S=0 ; S<1<<16 ; S++)res=Math.max(res,dp[1-X][S]);
      System.out.println(res);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,(1*(2->pow(16)))->oclAsType(long))->collect(0)) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
     if (n + c = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,c)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < 16 do (     a[i+1] := ((a[i+1]*(2->pow(1)))->oclAsType(long)) + sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < c do (         var j : int ; j := 0 ; while j < 16 do (     b[i+1] := ((b[i+1]*(2->pow(1)))->oclAsType(long)) + sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    dp[0+1] := dp[0+1]->collect(-1) ; 
    dp[0+1][0+1] := 0 ; 
    var X : int ; X := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     dp[X+1] := dp[X+1]->collect(-1) ; 
         var S : int ; S := 0 ; while S < (1*(2->pow(16)))->oclAsType(long) do (     if (dp[1 - X+1][S+1] /= -1) then (     var light : int ; light := MathLib.bitwiseOr(S,a[i+1]) ;
         var j : int ; j := 0 ; while j < c do ( (     var pushed : int ; pushed := MathLib.bitwiseAnd(light,b[j+1]) ;
     var point : int ; point := bitCount(pushed) ;
     var nx : int ; nx := MathLib.bitwiseAnd(light,-(pushed + 1)) ;
     dp[X+1][nx+1] := Set{dp[X+1][nx+1], dp[1 - X+1][S+1] + point}->max() )  ;     j := j + 1 ) ) else skip ;  ;     S := S + 1 ) )  ;     i := i + 1 ;     X := 1 - X ) ; 
    var res : int ; res := 0 ;
        var S : int ; S := 0 ; while S < (1*(2->pow(16)))->oclAsType(long) do (     res := Set{res, dp[1 - X+1][S+1]}->max() ;  ;     S := S + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=1000001 ;
  static int factor[];
  static void generatePrimeFactors(){
    factor[1]=1 ;
    for(int i=2 ; i<MAX ; i++)factor[i]=i ;
    for(int i=4 ; i<MAX ; i+=2)factor[i]=2 ;
    for(int i=3 ; i*i<MAX ; i++){
      if(factor[i]==i){
        for(int j=i*i ; j<MAX ; j+=i){
          if(factor[j]==j)factor[j]=i ;
        }
      }
    }
  }
  static int calculateNoOFactors(int n){
    if(n==1)return 1 ;
    int ans=1 ;
    int dup=factor[n];
    int c=1 ;
    int j=n/factor[n];
    while(j!=1){
      if(factor[j]==dup)c+=1 ;
      else {
        dup=factor[j];
        ans=ans*(c+1);
        c=1 ;
      }
      j=j/factor[j];
    }
    ans=ans*(c+1);
    return ans ;
  }
  public static void main(String[] args){
    factor=new int[MAX];
    factor[0]=0 ;
    generatePrimeFactors();
    int a[]={
      10,30,100,450,987 };
      int q=a.length ;
      for(int i=0 ; i<q ; i++)System.out.print(calculateNoOFactors(a[i])+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 1000001;
  static   attribute factor : Sequence(int);
  static   operation generatePrimeFactors() : void
  pre: true
  post: true
  activity: (     factor[1+1] := 1 ; 
         var i : int ; i := 2 ; while i < MAX do (     factor[i+1] := i ;  ;     i := i + 1 ) ; 
         var i : int ; i := 4 ; while i < MAX do (     factor[i+1] := 2 ;  ;     i := i+(2) ) ; 
         var i : int ; i := 3 ; while i * i < MAX do ( (     if (factor[i+1] = i) then (         var j : int ; j := i * i ; while j < MAX do ( (     if (factor[j+1] = j) then     factor[j+1] := i ; else skip )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) );
  static   operation calculateNoOFactors( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 1 else skip ; 
     var ans : int ; ans := 1 ;
    var dup : int ; dup := factor[n+1] ;
    var c : int ; c := 1 ;
    var j : int ; j := n / factor[n+1] ;
    while (j /= 1) do (     if (factor[j+1] = dup) then     c := c+(1) else (     dup := factor[j+1] ; 
     ans := ans * (c + 1) ; 
     c := 1 ) ;  
     j := j / factor[j+1] ) ; 
    ans := ans * (c + 1) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     factor := Integer.subrange(1,MAX)->collect(0) ; 
     factor[0+1] := 0 ; 
    execute generatePrimeFactors() ; 
    var a : Sequence(int) ; a := Sequence{10,30,100,450,987} ;
    var q : int ; q := a->size() ;
        var i : int ; i := 0 ; while i < q do (     OclFile["System.out"].print(calculateNoOFactors(a[i+1]) + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class p1372B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int d=1 ;
      for(int i=2 ; i*i<=n ; i++)if(n % i==0)d=Math.max(d,n/i);
      System.out.println(d+" "+(n-d));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class p1372B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var d : int ; d := 1 ;
         var i : int ; i := 2 ; while i * i <= n do (     if (n mod i = 0) then     d := Set{d, n / i}->max() ; else skip ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(d + " " + (n - d)) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class vfe {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      int j=n ;
      for(int i=2 ; i*i<=n ; i++){
        if(n % i==0){
          j=i ;
          break ;
        }
      }
      out.println((n/j)+" "+(j-1)*(n/j));
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class vfe {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var j : int ; j := n ;
         var i : int ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     j := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     skip ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javafx.beans.property.IntegerProperty ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class LastClassofMath {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t!=0){
      solve(br,pr);
      t--;
    }
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    if(n % 2==0){
      pr.println(n/2+" "+n/2);
      return ;
    }
    else {
      int b=(int)Math.sqrt(n)+1 ;
      int largestFactor=1 ;
      while(b!=1){
        if(n % b==0){
          largestFactor=Math.max(largestFactor,Math.max(b,n/b));
        }
        b--;
      }
      pr.println(largestFactor+" "+(n-largestFactor));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class LastClassofMath {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
    while (t /= 0) do (     execute solve(br, pr) ; 
     t := t - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     if (n mod 2 = 0) then (     skip ; 
     return ) else (     var b : int ; b := (n)->sqrt()->oclAsType(int) + 1 ;
     var largestFactor : int ; largestFactor := 1 ;
     while (b /= 1) do (     if (n mod b = 0) then (     largestFactor := Set{largestFactor, Set{b, n / b}->max()}->max() ) else skip ; 
     b := b - 1 ) ; 
     skip ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double PI=3.14 ;
  static double circle_inscribed(int a){
    return PI*(a*a)/12 ;
  }
  public static void main(String[] args){
    int a=4 ;
    System.out.println(circle_inscribed(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute PI : double := 3.14;
  static   operation circle_inscribed( a : int) : double
  pre: true
  post: true
  activity: (     return PI * (a * a) / 12 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 4 ;
     OclFile["System.out"].println(circle_inscribed(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int r1=a,x1=1,y1=0,r2=b,x2=0,y2=1,r3,q,x3,y3 ;
    while(r2!=0){
      q=r1/r2 ;
      r3=r1 % r2 ;
      x3=x1-q*x2 ;
      y3=y1-q*y2 ;
      r1=r2 ;
      r2=r3 ;
      x1=x2 ;
      x2=x3 ;
      y1=y2 ;
      y2=y3 ;
    }
    System.out.println(x1+" "+y1);
  }
  static int gcd(int a,int b){
    if(a<b)return gcd(b,a);
    if(b==0)return a ;
    return gcd(a,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var r1 : int ; r1 := a ;
    var x1 : int ; x1 := 1 ;
    var y1 : int ; y1 := 0 ;
    var r2 : int ; r2 := b ;
    var x2 : int ; x2 := 0 ;
    var y2 : int ; y2 := 1 ;
    var r3 : int ;
    var q : int ;
    var x3 : int ;
    var y3 : int ;
    while (r2 /= 0) do (     q := r1 / r2 ; 
     r3 := r1 mod r2 ; 
    x3 := x1 - q * x2 ; 
    y3 := y1 - q * y2 ; 
    r1 := r2 ; 
    r2 := r3 ; 
    x1 := x2 ; 
    x2 := x3 ; 
    y1 := y2 ; 
    y2 := y3 ; 
 ) ; 
    OclFile["System.out"].println(x1 + " " + y1) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a < b) then     return gcd(b, a) else skip ; 
     if (b = 0) then     return a else skip ; 
     return gcd(a, a mod b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    loop : while(t-->0){
      int n=in.nextInt();
      int m=in.nextInt();
      int i=n,j=m ;
      int ans=0,l=0 ;
      if(n<m){
        System.out.println(m ^ n);
      }
      else {
        while((n>>l)!=0 &&(m>>l)!=0){
          if(((n>>l)& 1)==1 &&((n>>l)& 1)==1)ans=ans |(1<<l);
          l++;
        }
        System.out.println((n ^ ans)+(m ^ ans));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var i : int ; i := n ;
    var j : int ; j := m ;
    var ans : int ; ans := 0 ;
    var l : int ; l := 0 ;
    if (n < m) then (     OclFile["System.out"].println(MathLib.bitwiseXor(m,n)) ) else (     while (((n/(2->pow(l)))->oclAsType(long)) /= 0 & ((m/(2->pow(l)))->oclAsType(long)) /= 0) do (     if ((((n/(2->pow(l)))->oclAsType(long)) & 1) = 1 & (((n/(2->pow(l)))->oclAsType(long)) & 1) = 1) then     ans := MathLib.bitwiseOr(ans,((1*(2->pow(l)))->oclAsType(long))) ; else skip ; 
     l := l + 1 ) ; 
     OclFile["System.out"].println((MathLib.bitwiseXor(n,ans)) + (MathLib.bitwiseXor(m,ans))) ) ;  
 ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int a,b ;
    int[] x,y ;
    x=new int[1];
    y=new int[1];
    a=sc.nextInt();
    b=sc.nextInt();
    extgcd(a,b,x,y);
    out.println(x[0]+" "+y[0]);
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
  private static void extgcd(int a,int b,int[] x,int[] y){
    int tmp ;
    x[0]=1 ;
    y[0]=0 ;
    if(b!=0){
      extgcd(b,a % b,y,x);
      y[0]-=(a/b)*x[0];
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var a : int ;
    var b : int ;
    var x : Sequence(int) ;
    var y : Sequence(int) ;
    x := Integer.subrange(1,1)->collect(0) ; 
    y := Integer.subrange(1,1)->collect(0) ; 
    a := sc.nextInt() ; 
    b := sc.nextInt() ; 
    execute extgcd(a, b, x, y) ; 
    out.println(x[0+1] + " " + y[0+1]) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
  static   operation extgcd( a : int, b : int, x : Sequence(int), y : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var tmp : int ;
     x[0+1] := 1 ; 
    y[0+1] := 0 ; 
    if (b /= 0) then (     execute extgcd(b, a mod b, y, x) ; 
     y[0+1] := y[0+1]-((a / b) * x[0+1]) ) else skip ; 
    return 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long sumPowersK(long n,long k){
    long sum=0,num=1 ;
    while(num<=n){
      sum+=num ;
      num*=k ;
    }
    return sum ;
  }
  static long getSum(long n,long k){
    long pwrK=sumPowersK(n,k);
    long sumAll=(n*(n+1))/2 ;
    return(sumAll-pwrK);
  }
  public static void main(String[] args){
    long n=10,k=3 ;
    System.out.println(getSum(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumPowersK( n : long, k : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
    var num : long ; num := 1 ;
     while (num <= n) do (     sum := sum+(num) ; 
     num := num*(k) ) ; 
     return sum );
  static   operation getSum( n : long, k : long) : long
  pre: true
  post: true
  activity: (     var pwrK : long ; pwrK := sumPowersK(n, k) ;
     var sumAll : long ; sumAll := (n * (n + 1)) / 2 ;
     return (sumAll - pwrK) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 10 ;
    var k : long ; k := 3 ;
     OclFile["System.out"].println(getSum(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int a,b ;
      a=parseInt(line.substring(0,line.indexOf(' ')));
      b=parseInt(line.substring(line.indexOf(' ')+1));
      int[] res=egcd(a,b);
      System.out.println(res[0]+" "+res[1]);
    }
  }
  static int[] egcd(int a,int b){
    int x1=1,y1=0,r1=a ;
    int x2=0,y2=1,r2=b ;
    int x3,y3,r3 ;
    while(true){
      int q=r1/r2 ;
      r3=r1 % r2 ;
      x3=x1-q*x2 ;
      y3=y1-q*y2 ;
      if(r3==0)break ;
      x1=x2 ;
      y1=y2 ;
      r1=r2 ;
      x2=x3 ;
      y2=y3 ;
      r2=r3 ;
    }
    return new int[] {
      x2,y2 };
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var a : int ;
    var b : int ;
     a := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    b := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var res : Sequence(int) ; res := egcd(a, b) ;
    OclFile["System.out"].println(res[0+1] + " " + res[1+1]) ; 
 ) ;     line := br.readLine() ;
 ) );
  static   operation egcd( a : int, b : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var x1 : int ; x1 := 1 ;
    var y1 : int ; y1 := 0 ;
    var r1 : int ; r1 := a ;
     var x2 : int ; x2 := 0 ;
    var y2 : int ; y2 := 1 ;
    var r2 : int ; r2 := b ;
    var x3 : int ;
    var y3 : int ;
    var r3 : int ;
    while (true) do (     var q : int ; q := r1 / r2 ;
     r3 := r1 mod r2 ; 
    x3 := x1 - q * x2 ; 
    y3 := y1 - q * y2 ; 
    if (r3 = 0) then     break else skip ; 
    x1 := x2 ; 
    y1 := y2 ; 
    r1 := r2 ; 
    x2 := x3 ; 
    y2 := y3 ; 
    r2 := r3 ; 
 ) ; 
    return Sequence{x2,y2} 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    long a=scan.nextLong();
    long b=scan.nextLong();
    scan.close();
    long[] ans=extendedGCD(a,b);
    System.out.println(ans[0]+" "+ans[1]);
  }
  static long[] extendedGCD(long a,long b){
    long s=0,old_s=1 ;
    long t=1,old_t=0 ;
    long r=b,old_r=a ;
    while(r!=0){
      long q=old_r/r ;
      long old_s0=old_s,old_t0=old_t,old_r0=old_r ;
      old_s=s ;
      s=old_s0-q*s ;
      old_t=t ;
      t=old_t0-q*t ;
      old_r=r ;
      r=old_r0-q*r ;
    }
    return new long[] {
      old_s,old_t };
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := scan.getCurrent()->toLong() ;
    var b : long ; b := scan.getCurrent()->toLong() ;
    skip ; 
    var ans : Sequence(long) ; ans := extendedGCD(a, b) ;
    OclFile["System.out"].println(ans[0+1] + " " + ans[1+1]) ; 
 );
  static   operation extendedGCD( a : long, b : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var s : long ; s := 0 ;
    var old_s : long ; old_s := 1 ;
     var t : long ; t := 1 ;
    var old_t : long ; old_t := 0 ;
    var r : long ; r := b ;
    var old_r : long ; old_r := a ;
    while (r /= 0) do (     var q : long ; q := old_r / r ;
     var old_s0 : long ; old_s0 := old_s ;
    var old_t0 : long ; old_t0 := old_t ;
    var old_r0 : long ; old_r0 := old_r ;
    old_s := s ; 
    s := old_s0 - q * s ; 
    old_t := t ; 
    t := old_t0 - q * t ; 
    old_r := r ; 
    r := old_r0 - q * r ; 
 ) ; 
    return Sequence{old_s,old_t} 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int a=sc.nextInt();
    int b=sc.nextInt();
    solveEuclid(a,b);
  }
  public static void solveEuclid(int a,int b){
    int r_0=a,r_1=b ;
    int a_0=1,a_1=0 ;
    int b_0=0,b_1=1 ;
    while(r_1>0){
      int q_1=r_0/r_1 ;
      int r_2=r_0 % r_1 ;
      int a_2=a_0-q_1*a_1 ;
      int b_2=b_0-q_1*b_1 ;
      r_0=r_1 ;
      r_1=r_2 ;
      a_0=a_1 ;
      a_1=a_2 ;
      b_0=b_1 ;
      b_1=b_2 ;
    }
    System.out.println(a_0+" "+b_0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     execute solveEuclid(a, b) );
  static   operation solveEuclid( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var r_0 : int ; r_0 := a ;
    var r    var r    var r_0 : int ; r_0 := a : int ; r    var r_0 : int ; r_0 := a := b : int ; r    var r    var r_0 : int ; r_0 := a : int ; r    var r_0 : int ; r_0 := a := b := b ;
     var a_0 : int ; a_0 := 1 ;
    var a    var a    var a_0 : int ; a_0 := 1 : int ; a    var a_0 : int ; a_0 := 1 := 0 : int ; a    var a    var a_0 : int ; a_0 := 1 : int ; a    var a_0 : int ; a_0 := 1 := 0 := 0 ;
    var b_0 : int ; b_0 := 0 ;
    var b    var b    var b_0 : int ; b_0 := 0 : int ; b    var b_0 : int ; b_0 := 0 := 1 : int ; b    var b    var b_0 : int ; b_0 := 0 : int ; b    var b_0 : int ; b_0 := 0 := 1 := 1 ;
    while (r_1 > 0) do (     var q    var qint : int ; qint := r_0 / rr_0 : int ; q    var qint : int ; qint := r_0 / rr_0 := r_0 / rr_0 ;
     var rr_0 mod r    var rr_0 mod rint : int ; rr_0 mod rint := r_0 mod rr_0 : int ; rr_0 mod r    var rr_0 mod rint : int ; rr_0 mod rint := r_0 mod rr_0 := r_0 mod rr_0 ;
    var aa_0 - qqa_0 * aqa_0 : int ; aa_0 - qqa_0 * aqa_0 := a_0 - qqa_0 * aqa_0 ;
    var bb_0 - qqb_0 * bqb_0 : int ; bb_0 - qqb_0 * bqb_0 := b_0 - qqb_0 * bqb_0 ;
    r_0 := rr_0 ; 
    rr_1 := r_2 ; 
    a_0 := aa_0 ; 
    aa_1 := a_2 ; 
    b_0 := bb_0 ; 
    bb_1 := b_2 ; 
 ) ; 
    OclFile["System.out"].println(a_0 + " " + b_0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int res=0 ;
    while(n-->0){
      String s=in.next();
      int bef=in.nextInt(),aft=in.nextInt();
      if(bef>=2400 && bef<aft){
        res++;
        break ;
      }
    }
    System.out.println((res==0)? "NO" : "YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var s : String ; s := in.getCurrent() ;
     var bef : int ; bef := in.getCurrent()->toInteger() ;
    var aft : int ; aft := in.getCurrent()->toInteger() ;
     if (bef >= 2400 & bef < aft) then (     res := res + 1 ; 
     break ) else skip ) ;  ) ;  
    OclFile["System.out"].println(if (res = 0) then "NO" else "YES" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class P681A {
  public static void main(String[] args)throws IOException {
    BufferedReader io=new BufferedReader(new InputStreamReader(System.in));
    Integer cnt=Integer.valueOf(io.readLine());
    String rs="NO" ;
    while(cnt>0){
      cnt--;
      String[] input=io.readLine().split(" ");
      if(Integer.valueOf(input[1]).compareTo(2400)>=0 && Integer.valueOf(input[1]).compareTo(Integer.valueOf(input[2]))<0){
        rs="YES" ;
      }
    }
    System.out.println(rs);
  }
}
------------------------------------------------------------
OCL File:
---------
 class P681A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var cnt : int ; cnt := (io.readLine())->toInteger() ;
    var rs : String ; rs := "NO" ;
    while (cnt > 0) do (     cnt := cnt - 1 ; 
     var input : Sequence(String) ; input := io.readLine()->split(" ") ;
     if ((input[1+1])->toInteger()->compareTo(2400) >= 0 & (input[1+1])->toInteger()->compareTo((input[2+1])->toInteger()) < 0) then (     rs := "YES" ) else skip ) ; 
    OclFile["System.out"].println(rs) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      String name=sc.next();
      int before=sc.nextInt(),after=sc.nextInt();
      if(before>=2400 && after>before){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var name : String ; name := sc.getCurrent() ;
     var before : int ; before := sc.getCurrent()->toInteger() ;
    var after : int ; after := sc.getCurrent()->toInteger() ;
     if (before >= 2400 & after > before) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("NO") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _681A_GoodContest {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=input.nextInt();
    boolean flag=false ;
    while(test-->0){
      String userName=input.next();
      int before=input.nextInt();
      int after=input.nextInt();
      if(before>=2400 && after>before){
        flag=true ;
      }
    }
    System.out.println(flag ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class _681A_GoodContest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := input.getCurrent()->toInteger() ;
    var flag : boolean ; flag := false ;
        while (test > 0) do (        test := test - 1 ;     skip ; (     var userName : String ; userName := input.getCurrent() ;
     var before : int ; before := input.getCurrent()->toInteger() ;
     var after : int ; after := input.getCurrent()->toInteger() ;
     if (before >= 2400 & after > before) then (     flag := true ) else skip ) ;  ) ;  
    OclFile["System.out"].println(if flag then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Prog {
  static String s,s1 ;
  static int l1,l2 ;
  static boolean arr[];
  static int arr1[];
  static boolean isMatching(int index){
    Arrays.fill(arr,false);
    for(int i=0 ; i<=index ; i++)arr[arr1[i]-1]=true ;
    int j=0 ;
    for(int i=0 ; i<l1 && j<l2 ; i++){
      if(arr[i])continue ;
      if(s.charAt(i)==s1.charAt(j))j++;
    }
    if(j==l2)return true ;
    return false ;
  }
  static void answer(){
    int ans=0 ;
    arr=new boolean[l1];
    Arrays.fill(arr,false);
    int l=0,r=l1-1 ;
    while(l<=r){
      int m=(l+r)>>>1 ;
      if(isMatching(m)){
        ans=m+1 ;
        l=m+1 ;
      }
      else r=m-1 ;
    }
    System.out.println(ans);
  }
  public static void main(String[] args)throws Exception {
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    s=bf.readLine();
    s1=bf.readLine();
    String ss[]=bf.readLine().trim().split("\\s+");
    l1=s.length();
    l2=s1.length();
    arr1=new int[l1];
    for(int i=0 ; i<l1 ; i++)arr1[i]=Integer.parseInt(ss[i]);
    answer();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Prog {
  static   attribute s : String;
  static   attribute l1 : int;
  static   attribute arr : Sequence(boolean);
  static   attribute arr1 : Sequence(int);
  static   operation isMatching( index : int) : boolean
  pre: true
  post: true
  activity: (     arr := arr->collect(false) ; 
         var i : int ; i := 0 ; while i <= index do (     arr[arr1[i+1] - 1+1] := true ;  ;     i := i + 1 ) ; 
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < l1 & j < l2 do ( (     if (arr[i+1]) then     continue else skip ; 
     if (s->at(i+1) = s1->at(j+1)) then     j := j + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (j = l2) then     return true else skip ; 
    return false 
 );
  static   operation answer() : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     arr := Integer.subrange(1,l1)->collect(false) ; 
    arr := arr->collect(false) ; 
    var l : int ; l := 0 ;
    var r : int ; r := l1 - 1 ;
    while (l <= r) do (     var m : int ; m := ((l + r)/(2->pow(1)))->oclAsType(long) ;
     if (isMatching(m)) then (     ans := m + 1 ; 
     l := m + 1 ) else     r := m - 1 ; ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     s := bf.readLine() ; 
    s1 := bf.readLine() ; 
    var ss : Sequence(String) ; ss := bf.readLine()->trim()->split("\\s+") ;
    l1 := s->size() ; 
    l2 := s1->size() ; 
    arr1 := Integer.subrange(1,l1)->collect(0) ; 
        var i : int ; i := 0 ; while i < l1 do (     arr1[i+1] := (ss[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    execute answer() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class LevkoandTable {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=n ; j++){
        if(i==j){
          System.out.print(k+" ");
        }
        else {
          System.out.print("0 ");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class LevkoandTable {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     if (i = j) then (     OclFile["System.out"].print(k + " ") ) else (     OclFile["System.out"].print("0 ") ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class XORwice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testCase=sc.nextInt();
    while(testCase-->0){
      System.out.println(sc.nextInt()^ sc.nextInt());
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class XORwice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCase : int ; testCase := sc.getCurrent()->toInteger() ;
         while (testCase > 0) do (        testCase := testCase - 1 ;     skip ; (     OclFile["System.out"].println(sc.getCurrent()->toInteger() xor sc.getCurrent()->toInteger()) ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float[] XandYandZintercept(float A,float B,float C,float D){
    float rslt[]=new float[3];
    float x=-D/A ;
    float y=-D/B ;
    float z=-D/C ;
    rslt[0]=x ;
    rslt[1]=y ;
    rslt[2]=z ;
    return rslt ;
  }
  public static void main(String[] args){
    int A=2 ;
    int B=5 ;
    int C=7 ;
    int D=8 ;
    float rslt[]=XandYandZintercept(A,B,C,D);
    for(int i=0 ; i<3 ; i++){
      System.out.print(rslt[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation XandYandZintercept( A : double, B : double, C : double, D : double) : Sequence(double)
  pre: true
  post: true
  activity: (     var rslt : Sequence(double) ; rslt := Integer.subrange(1,3)->collect(0.0) ;
     var x : double ; x := -D / A ;
    var y : double ; y := -D / B ;
    var z : double ; z := -D / C ;
    rslt[0+1] := x ; 
    rslt[1+1] := y ; 
    rslt[2+1] := z ; 
    return rslt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 2 ;
     var B : int ; B := 5 ;
    var C : int ; C := 7 ;
    var D : int ; D := 8 ;
    var rslt : Sequence(double) ; rslt := XandYandZintercept(A, B, C, D) ;
        var i : int ; i := 0 ; while i < 3 do ( (     OclFile["System.out"].print(rslt[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class P2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(i==j)System.out.print(k+" ");
        else System.out.print(0+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (i = j) then     OclFile["System.out"].print(k + " ") ; else     OclFile["System.out"].print(0 + " ") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Levko_Table {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    int matrix[][]=new int[n][n];
    for(int i=0 ; i<n ; i++){
      matrix[i][i]=k ;
      for(int j=0 ; j<n ; j++){
        System.out.print(matrix[i][j]+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Levko_Table {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var matrix : Sequence(Sequence(int)) ; matrix := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     matrix[i+1][i+1] := k ; 
         var j : int ; j := 0 ; while j < n do ( (     OclFile["System.out"].print(matrix[i+1][j+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication133 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num1=sc.nextInt();
    int num2=sc.nextInt();
    for(int i=0 ; i<num1 ; i++){
      for(int j=0 ; j<num1 ; j++){
        if(i==j){
          System.out.print(num2+" ");
        }
        else {
          System.out.print(0+" ");
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication133 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num1 : int ; num1 := sc.getCurrent()->toInteger() ;
     var num2 : int ; num2 := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < num1 do ( (         var j : int ; j := 0 ; while j < num1 do ( (     if (i = j) then (     OclFile["System.out"].print(num2 + " ") ) else (     OclFile["System.out"].print(0 + " ") ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p072 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p072().run());
  }
  private static final int LIMIT=Library.pow(10,6);
  public String run(){
    long sum=0 ;
    int[] totients=Library.listTotients(LIMIT);
    for(int i=2 ; i<totients.length ; i++)sum+=totients[i];
    return Long.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
class p072 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p072.newp072().run()) );
  static    attribute LIMIT : int := Library.pow(10, 6);
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     var totients : Sequence(int) ; totients := Library.listTotients(LIMIT) ;
         var i : int ; i := 2 ; while i < totients->size() do (     sum := sum+(totients[i+1]) ;  ;     i := i + 1 ) ; 
     return ((sum) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int __gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static void Probability(int A,int B){
    int C=6-Math.max(A,B);
    int gcd=__gcd(C,6);
    System.out.print(C/gcd+"/"+6/gcd);
  }
  public static void main(String[] args){
    int A=2,B=4 ;
    Probability(A,B);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
    if (a = b) then     return a else skip ; 
    if (a > b) then     return __gcd(a - b, b) else skip ; 
    return __gcd(a, b - a) 
 );
  static   operation Probability( A : int, B : int) : void
  pre: true
  post: true
  activity: (     var C : int ; C := 6 - Set{A, B}->max() ;
     var gcd : int ; gcd := __gcd(C, 6) ;
     OclFile["System.out"].print(C / gcd + "/" + 6 / gcd) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 2 ;
    var B : int ; B := 4 ;
     execute Probability(A, B) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float Time(float arr[],int n,float Emptypipe){
    float fill=0 ;
    for(int i=0 ; i<n ; i++)fill+=1/arr[i];
    fill=fill-(1/(float)Emptypipe);
    return 1/fill ;
  }
  public static void main(String[] args){
    float arr[]={
      12,14 };
      float Emptypipe=30 ;
      int n=arr.length ;
      System.out.println((int)(Time(arr,n,Emptypipe))+" Hours");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Time( arr : Sequence(double), n : int, Emptypipe : double) : double
  pre: true
  post: true
  activity: (     var fill : double ; fill := 0 ;
         var i : int ; i := 0 ; while i < n do (     fill := fill+(1 / arr[i+1]) ;  ;     i := i + 1 ) ; 
     fill := fill - (1 / Emptypipe->oclAsType(double)) ; 
     return 1 / fill );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(double) ; arr := Sequence{12,14} ;
     var Emptypipe : double ; Emptypipe := 30 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println((Time(arr, n, Emptypipe))->oclAsType(int) + " Hours") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int numberOfMen(int D,int m,int d){
    int Men=(m*(D-d))/d ;
    return Men ;
  }
  public static void main(String args[]){
    int D=5,m=4,d=4 ;
    System.out.println(numberOfMen(D,m,d));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation numberOfMen( D : int, m : int, d : int) : int
  pre: true
  post: true
  activity: (     var Men : int ; Men := (m * (D - d)) / d ;
     return Men );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var D : int ; D := 5 ;
    var m : int ; m := 4 ;
    var d : int ; d := 4 ;
     OclFile["System.out"].println(numberOfMen(D, m, d)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    int[] array=new int[n];
    int[] x=new int[n];
    for(int i=0 ; i<n ; i++){
      array[i]=scan.nextInt();
      x[i]=array[i];
    }
    scan.close();
    Arrays.sort(x);
    int count=0 ;
    int total=0 ;
    for(int i=0 ; i<n ; i++){
      count+=x[i];
      if(count<=k){
        total++;
      }
    }
    System.out.println(total);
    for(int i=0 ; i<total ; i++){
      for(int j=0 ; j<n ; j++){
        if(x[i]==array[j]){
          System.out.print(j+1+" ");
          array[j]=-1 ;
          break ;
        }
      }
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := scan.getCurrent()->toInteger() ; 
     x[i+1] := array[i+1] )  ;     i := i + 1 ) ; 
    skip ; 
    x := x->sort() ; 
    var count : int ; count := 0 ;
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     count := count+(x[i+1]) ; 
     if (count <= k) then (     total := total + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
        var i : int ; i := 0 ; while i < total do ( (         var j : int ; j := 0 ; while j < n do ( (     if (x[i+1] = array[j+1]) then (     OclFile["System.out"].print(j + 1 + " ") ; 
     array[j+1] := -1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static int solve(int[] a,int k,List<Integer>mylist){
    Arrays.sort(a);
    int count=0 ;
    int i=0 ;
    while(i<a.length && a[i]<=k){
      k=k-a[i];
      mylist.add(a[i]);
      count++;
      i++;
    }
    return count ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,k ;
    n=sc.nextInt();
    k=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    List<Integer>ca=new ArrayList<>();
    List<Integer>mylist=new ArrayList<>();
    for(int j : a)ca.add(j);
    int ans=solve(a,k,mylist);
    List<Integer>res=new ArrayList<>();
    for(int i=0 ; i<mylist.size(); i++){
      for(int j=0 ; j<ca.size(); j++){
        if(mylist.get(i)==ca.get(j)&& ! res.contains(j)){
          res.add(j);
          break ;
        }
      }
    }
    System.out.println(ans);
    for(int i : res)System.out.print((i+1)+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( a : Sequence(int), k : int, mylist : Sequence(int)) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var count : int ; count := 0 ;
    var i : int ; i := 0 ;
    while (i < a->size() & a[i+1] <= k) do (     k := k - a[i+1] ; 
     mylist->excludes(a[i+1]) ; 
     count := count + 1 ; 
     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var k : int ;
    n := sc.getCurrent()->toInteger() ; 
    k := sc.getCurrent()->toInteger() ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ca : Sequence(int) ; ca := Sequence{} ;
    var mylist : Sequence(int) ; mylist := Sequence{} ;
    for (j : a) do (     ca := ca->including(j) ;  ) ; 
    var ans : int ; ans := solve(a, k, mylist) ;
    var res : Sequence(int) ; res := Sequence{} ;
        var i : int ; i := 0 ; while i < mylist->size() do ( (         var j : int ; j := 0 ; while j < ca->size() do ( (     if (mylist->at(i+1) = ca->at(j+1) & not(res->includes(j))) then (     res := res->including(j) ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    for (i : res) do (     OclFile["System.out"].print((i + 1) + " ") ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication144 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayList<Integer>arr=new ArrayList<>();
    ArrayList<Integer>arra=new ArrayList<>();
    ArrayList<Integer>arraa=new ArrayList<>();
    int num=sc.nextInt();
    int max=sc.nextInt();
    int counter=0 ;
    for(int i=0 ; i<num ; i++){
      int s=sc.nextInt();
      arr.add(s);
      arra.add(s);
    }
    Collections.sort(arra);
    for(int i=0 ; i<num ; i++){
      if(max-counter>=arra.get(i)){
        arraa.add(arr.indexOf(arra.get(i))+1);
        counter+=arra.get(i);
        arr.set(arr.indexOf(arra.get(i)),0);
      }
      else {
        break ;
      }
    }
    System.out.println(arraa.size());
    for(int i=0 ; i<arraa.size(); i++){
      System.out.print(arraa.get(i)+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication144 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(int) ; arr := Sequence{} ;
    var arra : Sequence(int) ; arra := Sequence{} ;
    var arraa : Sequence(int) ; arraa := Sequence{} ;
    var num : int ; num := sc.getCurrent()->toInteger() ;
    var max : int ; max := sc.getCurrent()->toInteger() ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < num do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     arr := arr->including(s) ; 
     arra := arra->including(s) )  ;     i := i + 1 ) ; 
    arra := arra->sort() ; 
        var i : int ; i := 0 ; while i < num do ( (     if (max - counter >= arra->at(i+1)) then (     arraa := arraa->including(arr->indexOf(arra->at(i+1))-1 + 1) ; 
     counter := counter+(arra->at(i+1)) ; 
     arr := arr.setAt(arr->indexOf(arra->at(i+1))-1+1,0) ) else (     break ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(arraa->size()) ; 
        var i : int ; i := 0 ; while i < arraa->size() do ( (     OclFile["System.out"].print(arraa->at(i+1) + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Solution sol=new Solution();
    sol.solve(in,out);
    out.close();
  }
  private static class Solution {
    private void solve(InputReader in,PrintWriter out){
      int n=in.nextInt(),k=in.nextInt();
      int[] logsLength=in.readArray(n);
      int min=1,max=(int)1e9+1000 ;
      while(min<max){
        int mid=(min+max)/2 ;
        if(nei(mid,logsLength,k))max=mid ;
        else min=mid+1 ;
      }
      out.println(min);
    }
    private boolean nei(int mid,int[] logsLength,int k){
      for(int log : logsLength)k-=(log+mid-1)/mid-1 ;
      return k>=0 ;
    }
  }
  private static class InputReader {
    private BufferedReader reader ;
    private StringTokenizer tokenizer ;
    private InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    private String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    private int nextInt(){
      return Integer.parseInt(next());
    }
    private int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; ++i)a[i]=nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var sol : Solution ; sol := Solution.newSolution() ;
    sol.solve(in, out) ; 
    skip ; 
 );
  static class Solution {
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
    var k : int ; k := in.nextInt() ;
     var logsLength : Sequence(int) ; logsLength := in.readArray(n) ;
    var min : int ; min := 1 ;
    var max : int ; max := 1e9->oclAsType(int) + 1000 ;
    while (min < max) do (     var mid : int ; mid := (min + max) / 2 ;
     if (nei(mid, logsLength, k)) then     max := mid ; else     min := mid + 1 ; ) ; 
    skip ; 
 );
   operation nei( mid : int, logsLength : Sequence(int), k : int) : boolean
  pre: true
  post: true
  activity: (     for (log : logsLength) do (     k := k-((log + mid - 1) / mid - 1) ;  ) ; 
     return k >= 0 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  static int N ;
  static double ans ;
  public static void main(String...orange)throws Exception {
    Scanner input=new Scanner(System.in);
    int numCases=input.nextInt();
    for(int n=0 ; n<numCases ; n++){
      N=input.nextInt();
      int K=input.nextInt();
      double[] ps=new double[N];
      for(int i=0 ; i<N ; i++)ps[i]=input.nextDouble();
      ans=0 ;
      solve(new ArrayList<Double>(),ps,K,0);
      System.out.printf("Case #%d: ",n+1);
      System.out.println(ans);
    }
  }
  static void solve(List<Double>keep,double[] ps,int K,int index){
    if(index==ps.length){
      if(keep.size()==K)check(keep,K);
      return ;
    }
    solve(keep,ps,K,index+1);
    keep.add(ps[index]);
    solve(keep,ps,K,index+1);
    keep.remove(keep.size()-1);
  }
  static void check(List<Double>keep,int K){
    double[][] table=new double[K+1][K+1];
    table[0][0]=1 ;
    for(int i=1 ; i<=K ; i++)for(int yes=0 ; yes<=i ; yes++){
      table[i][yes]=table[i-1][yes]*(1-keep.get(i-1));
      if(yes>0)table[i][yes]+=table[i-1][yes-1]*keep.get(i-1);
    }
    if(table[K][K/2]>ans)ans=table[K][K/2];
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute N : int;
  static   attribute ans : double;
  static   operation main( orange : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numCases : int ; numCases := input.getCurrent()->toInteger() ;
         var n : int ; n := 0 ; while n < numCases do ( (     N := input.getCurrent()->toInteger() ; 
     var K : int ; K := input.getCurrent()->toInteger() ;
    var ps : Sequence(double) ; ps := Integer.subrange(1,N)->collect(0.0) ;
        var i : int ; i := 0 ; while i < N do (     ps[i+1] := input.getCurrent()->toReal() ;  ;     i := i + 1 ) ; 
    ans := 0 ; 
    execute solve(Sequence{}, ps, K, 0) ; 
    OclFile["System.out"].printf("Case #%d: ", n + 1) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     n := n + 1 ) );
  static   operation solve( keep : Sequence(double), ps : Sequence(double), K : int, index : int) : void
  pre: true
  post: true
  activity: (     if (index = ps->size()) then (     if (keep->size() = K) then     execute check(keep, K) ; else skip ; 
     return ) else skip ; 
     execute solve(keep, ps, K, index + 1) ; 
    keep->excludes(ps[index+1]) ; 
    execute solve(keep, ps, K, index + 1) ; 
    keep := keep->excludingFirst(keep->size() - 1) ; 
 );
  static   operation check( keep : Sequence(double), K : int) : void
  pre: true
  post: true
  activity: (     var table : Sequence(Sequence(double)) ; table := Integer.subrange(1,K + 1)->collect(Integer.subrange(1,K + 1)->collect(0.0)) ;
     table[0+1][0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= K do (         var yes : int ; yes := 0 ; while yes <= i do ( (     table[i+1][yes+1] := table[i - 1+1][yes+1] * (1 - keep->at(i - 1+1)) ; 
     if (yes > 0) then     table[i+1][yes+1] := table[i+1][yes+1]+(table[i - 1+1][yes - 1+1] * keep->at(i - 1+1)) ; else skip )  ;     yes := yes + 1 ) ;  ;     i := i + 1 ) ; 
     if (table[K+1][K / 2+1] > ans) then     ans := table[K+1][K / 2+1] ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.String ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String vStr=sc.nextLine();
    Map<Integer,Integer>vList=str2List(vStr);
    int n=vList.get(0);
    int k=vList.get(1);
    String s=sc.nextLine();
    String sArr[]=s.split("");
    switch(sArr[k-1]){
      case "A" : sArr[k-1]="a" ;
      break ;
      case "B" : sArr[k-1]="b" ;
      break ;
      case "C" : sArr[k-1]="c" ;
      break ;
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(sArr[i]);
    }
  }
  static Map<Integer,Integer>str2List(String str){
    String[] vArrStr=str.split(" ");
    Map<Integer,Integer>ret=new HashMap<>();
    Integer key=0 ;
    for(String val : vArrStr){
      ret.put(key,Integer.valueOf(val));
      key++;
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var vStr : String ; vStr := sc.nextLine() ;
    var vList : Map(int,int) ; vList := str2List(vStr) ;
    var n : int ; n := vList->at(0) ;
    var k : int ; k := vList->at(1) ;
    var s : String ; s := sc.nextLine() ;
    var sArr : Sequence(String) ; sArr := s->split("") ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (sArr[k - 1+1]) ; 
       if _switchval = "A" then
     sArr[k - 1+1] := "a" ; 
    break 
   else skip ;
       if _switchval = "B" then
     sArr[k - 1+1] := "b" ; 
    break 
   else skip ;
       if _switchval = "C" then
     sArr[k - 1+1] := "c" ; 
    break 
   else skip ;
 )
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(sArr[i+1]) )  ;     i := i + 1 ) ; 
 );
  static   operation str2List( str : String) : Map(int,int)
  pre: true
  post: true
  activity: (     var vArrStr : Sequence(String) ; vArrStr := str->split(" ") ;
     var ret : Map(int,int) ; ret := Map{} ;
    var key : int ; key := 0 ;
    for (val : vArrStr) do ( (     ret := ret->union(Map{key |-> (val)->toInteger()}) ; 
     key := key + 1 )  ) ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class XORwice {
  public static void main(String Args[]){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int a=in.nextInt();
      int b=in.nextInt();
      int temp=a | b ;
      System.out.println((a ^ temp)+(b ^ temp));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class XORwice {
  static   operation main( Args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
     var temp : int ; temp := MathLib.bitwiseOr(a,b) ;
     OclFile["System.out"].println((MathLib.bitwiseXor(a,temp)) + (MathLib.bitwiseXor(b,temp))) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p043 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p043().run());
  }
  private static int[] DIVISIBILITY_TESTS={
    2,3,5,7,11,13,17 };
    public String run(){
      long sum=0 ;
      int[] digits={
        0,1,2,3,4,5,6,7,8,9 };
        outer : do {
          for(int i=0 ; i<DIVISIBILITY_TESTS.length ; i++){
            if(toInteger(digits,i+1,3)% DIVISIBILITY_TESTS[i]!=0)continue outer ;
          }
          sum+=toInteger(digits,0,digits.length);
        }
        while(Library.nextPermutation(digits));
        return Long.toString(sum);
      }
      private static long toInteger(int[] digits,int off,int len){
        long result=0 ;
        for(int i=off ; i<off+len ; i++)result=result*10+digits[i];
        return result ;
      }
    }

------------------------------------------------------------
OCL File:
---------
class p043 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p043.newp043().run()) );
  static   attribute DIVISIBILITY_TESTS : Sequence(int) := Sequence{2,3,5,7,11,13,17};
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     var digits : Sequence(int) ; digits := Sequence{0,1,2,3,4,5,6,7,8,9} ;
   while true do ((         var i : int ; i := 0 ; while i < DIVISIBILITY_TESTS->size() do ( (     if (toInteger(digits, i + 1, 3) mod DIVISIBILITY_TESTS[i+1] /= 0) then     continue else skip )  ;     i := i + 1 ) ; 
     sum := sum+(toInteger(digits, 0, digits->size())) ) ;
    if (Library.nextPermutation(digits)) then skip else break) ; 
     return ((sum) + "") );
  static   operation toInteger( digits : Sequence(int), off : int, len : int) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 0 ;
         var i : int ; i := off ; while i < off + len do (     result := result * 10 + digits[i+1] ;  ;     i := i + 1 ) ; 
     return result );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static byte longSize=8 ;
  static int ULL_SIZE=8*longSize ;
  static boolean bit_anagram_check(long a){
    return(Integer.bitCount((int)a)==(ULL_SIZE>>1));
  }
  public static void main(String[] args){
    long a=4294967295L ;
    System.out.println(bit_anagram_check(a));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute longSize : int := 8;
  static   attribute ULL_SIZE : int := 8 * longSize;
  static   operation bit_anagram_check( a : long) : boolean
  pre: true
  post: true
  activity: (     return (bitCount(a->oclAsType(int)) = ((ULL_SIZE/(2->pow(1)))->oclAsType(long))) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ; a := 4294967295L ;
     OclFile["System.out"].println(bit_anagram_check(a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    int[][] grid=new int[m][3];
    for(int i=0 ; i<m ; i++){
      for(int j=0 ; j<3 ; j++){
        grid[i][j]=scan.nextInt();
      }
    }
    int[] ans=getDancerColors(n,grid);
    StringBuilder sb=new StringBuilder();
    for(int num : ans){
      sb.append(num).append(" ");
    }
    System.out.println(sb);
  }
  public static int[] getDancerColors(int n,int[][] grid){
    int[] ans=new int[n];
    for(int[] dance : grid){
      int colors=6 ;
      int rest=3 ;
      for(int num : dance){
        if(ans[num-1]!=0){
          colors-=ans[num-1];
          rest--;
        }
      }
      for(int num : dance){
        if(ans[num-1]==0){
          int cur=rest==1 ? colors : colors>3 ? 3 : colors>2 ? 2 : 1 ;
          ans[num-1]=cur ;
          colors-=cur ;
          rest--;
        }
      }
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var grid : Sequence(Sequence(int)) ; grid := Integer.subrange(1,m)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j < 3 do ( (     grid[i+1][j+1] := scan.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := getDancerColors(n, grid) ;
    var sb : String ; sb := StringLib.newString() ;
    for (num : ans) do ( (     sb := sb + StringLib.newString(num) + StringLib.newString(" ") )  ) ; 
    OclFile["System.out"].println(sb) ; 
 );
  static   operation getDancerColors( n : int, grid : Sequence(Sequence(int))) : Sequence(int)
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
     for (dance : grid) do ( (     var colors : int ; colors := 6 ;
     var rest : int ; rest := 3 ;
     for (num : dance) do ( (     if (ans[num - 1+1] /= 0) then (     colors := colors-(ans[num - 1+1]) ; 
     rest := rest - 1 ) else skip )  ) ; 
     for (num : dance) do ( (     if (ans[num - 1+1] = 0) then (     var cur : int ; cur := if rest = 1 then colors else if colors > 3 then 3 else if colors > 2 then 2 else 1 endif endif endif ;
     ans[num - 1+1] := cur ; 
     colors := colors-(cur) ; 
     rest := rest - 1 ) else skip )  ) )  ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long a[]=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextLong();
    long last=a[0];
    System.out.print(last);
    for(int i=1 ; i<n ; i++){
      if(a[i]==last);
      else {
        last=a[i];
        System.out.print(" "+last);
      }
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var last : long ; last := a[0+1] ;
    OclFile["System.out"].print(last) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] = last) then  else (     last := a[i+1] ; 
     OclFile["System.out"].print(" " + last) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.regex.Matcher ;
import java.util.regex.Pattern ;
public class Main {
  public static final int BIG_NUM=2000000000 ;
  public static final int MOD=1000000007 ;
  public static final long HUGE_NUM=99999999999999999L ;
  public static final double EPS=0.000000001 ;
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      int N=Integer.parseInt(br.readLine());
      String input_str[]=br.readLine().split("\\s+");
      StringBuilder ans=new StringBuilder();
      ans.append(input_str[0]);
      String pre=input_str[0];
      for(int i=1 ; i<input_str.length ; i++){
        if(input_str[i] .equals(pre))continue ;
        ans.append(" ").append(input_str[i]);
        pre=input_str[i];
      }
      System.out.println(ans.toString());
    }
    catch(NumberFormatException e){
      e.printStackTrace();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
class UTIL {
  public static boolean isNumber(String tmp_str){
    if(tmp_str==null || tmp_str.length()==0){
      return false ;
    }
    Pattern pattern=Pattern.compile("\\A[0-9]+\\z");
    Matcher matcher=pattern.matcher(tmp_str);
    return matcher.matches();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BIG_NUM : int := 2000000000;
  static    attribute MOD : int := 1000000007;
  static    attribute HUGE_NUM : long := 99999999999999999L;
  static    attribute EPS : double := 0.000000001;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var N : int ; N := (br.readLine())->toInteger() ;
     var input_str : Sequence(String) ; input_str := br.readLine()->split("\\s+") ;
    var ans : String ; ans := StringLib.newString() ;
    ans := ans + StringLib.newString(input_str[0+1]) ; 
    var pre : String ; pre := input_str[0+1] ;
        var i : int ; i := 1 ; while i < input_str->size() do ( (     if (input_str[i+1] = pre) then     continue else skip ; 
     ans := ans + StringLib.newString(" ") + StringLib.newString(input_str[i+1]) ; 
     pre := input_str[i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans+"") ; 
 )   catch (e : IncorrectElementException) do (     e.printStackTrace() )
   catch (e : IOException) do (     e.printStackTrace() )
 );
}
class UTIL {
  static   operation isNumber( tmp_str : String) : boolean
  pre: true
  post: true
  activity: (     if (tmp_str = null or tmp_str->size() = 0) then (     return false ) else skip ; 
     var pattern : OclRegex ; pattern := OclRegex.compile("\\A[0-9]+\\z") ;
     var matcher : OclRegex ; matcher := pattern.matcher(tmp_str) ;
     return matcher.isMatch() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.ListIterator ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      ArrayList<Integer>A=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        A.add(sc.nextInt());
      }
      ListIterator<Integer>AI=A.listIterator();
      int prev=AI.next();
      while(AI.hasNext()){
        if(prev==AI.next()){
          AI.remove();
        }
        else {
          prev=AI.previous();
          AI.next();
        }
      }
      AI=A.listIterator();
      System.out.print(AI.next());
      while(AI.hasNext()){
        System.out.print(" "+AI.next());
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var A : Sequence(int) ; A := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     A := A->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var AI : ListIterator<int> ; AI := A->iterator() ;
    var prev : int ; prev := AI.next() ;
    while (AI.hasNext()) do (     if (prev = AI.next()) then (     AI := AI.remove() ) else (     prev := AI.previous() ; 
     AI.next() ) ) ; 
    AI := A->iterator() ; 
    OclFile["System.out"].print(AI.next()) ; 
    while (AI.hasNext()) do (     OclFile["System.out"].print(" " + AI.next()) ) ; 
    OclFile["System.out"].println() ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      long k=sc.nextLong();
      Long[] A=new Long[n];
      long tmp=0 ;
      for(int i=0 ; i<n ; i++){
        long next=sc.nextLong();
        A[i]=next ;
        tmp+=next ;
      }
      final long sum=tmp ;
      Arrays.sort(A,(x,y)->x/((x*k/sum)+1)>y/((y*k/sum)+1)? 1 :-1);
      if(k==0){
        System.out.println(A[n-1]);
        return ;
      }
      int[] cutCnt=new int[n];
      int cutCntSum=0 ;
      for(int i=0 ; i<n ; i++){
        long cnt=A[i]*k/sum ;
        cutCnt[i]=(int)cnt ;
        cutCntSum+=(int)cnt ;
      }
      long ans=0 ;
      for(int i=n-1 ; i>=0 ; i--){
        if(cutCntSum<k){
          cutCnt[i]++;
          cutCntSum++;
        }
        if(cutCnt[i]==0){
          ans=Math.max(ans,A[i]);
          continue ;
        }
        if(A[i] % cutCnt[i]==0){
          ans=Math.max(ans,A[i]/(cutCnt[i]+1));
        }
        else {
          ans=Math.max(ans,A[i]/(cutCnt[i]+1)+1);
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : long ; k := sc.getCurrent()->toLong() ;
    var A : Sequence(long) ; A := Integer.subrange(1,n)->collect(null) ;
    var tmp : long ; tmp := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var next : long ; next := sc.getCurrent()->toLong() ;
     A[i+1] := next ; 
     tmp := tmp+(next) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := tmp ;
    A := OclComparator.sortWith(A, lambda (x , y) : OclAny in if x / ((x * k / sum) + 1) > y / ((y * k / sum) + 1) then 1 else -1 endif) ; 
    if (k = 0) then (     OclFile["System.out"].println(A[n - 1+1]) ; 
     return ) else skip ; 
    var cutCnt : Sequence(int) ; cutCnt := Integer.subrange(1,n)->collect(0) ;
    var cutCntSum : int ; cutCntSum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var cnt : long ; cnt := A[i+1] * k / sum ;
     cutCnt[i+1] := cnt->oclAsType(int) ; 
     cutCntSum := cutCntSum+(cnt->oclAsType(int)) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (cutCntSum < k) then (     cutCnt[i+1] := cutCnt[i+1] + 1 ; 
     cutCntSum := cutCntSum + 1 ) else skip ; 
     if (cutCnt[i+1] = 0) then (     ans := Set{ans, A[i+1]}->max() ; 
     continue ) else skip ; 
     if (A[i+1] mod cutCnt[i+1] = 0) then (     ans := Set{ans, A[i+1] / (cutCnt[i+1] + 1)}->max() ) else (     ans := Set{ans, A[i+1] / (cutCnt[i+1] + 1) + 1}->max() ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int size=in.nextInt(),arr[]=new int[size];
    arr[0]=Integer.parseInt(in.next());
    int tail=0 ;
    for(int i=1 ; i<size ; i++){
      int x=Integer.parseInt(in.next());
      if(x!=arr[tail]){
        arr[++tail]=x ;
      }
    }
    for(int i=0 ; i<=tail ; i++){
      out.printf("%d%s",arr[i],(i<tail)? " " : "\n");
    }
    out.flush();
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var size : int ; size := in.getCurrent()->toInteger() ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,size)->collect(0) ;
    arr[0+1] := (in.getCurrent())->toInteger() ; 
    var tail : int ; tail := 0 ;
        var i : int ; i := 1 ; while i < size do ( (     var x : int ; x := (in.getCurrent())->toInteger() ;
     if (x /= arr[tail+1]) then (         tail := tail + 1 ;
 arr[tail+1] := x  ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= tail do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Set<Integer>set=new TreeSet<>();
    for(int i=0 ; i<n ; i++){
      set.add(sc.nextInt());
    }
    StringBuilder sb=new StringBuilder();
    for(int num : set){
      sb.append(num+" ");
    }
    String str=sb.toString();
    str=str.substring(0,str.length()-1);
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     set := set->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    for (num : set) do ( (     sb := sb + StringLib.newString(num + " ") )  ) ; 
    var str : String ; str := sb+"" ;
    str := str.subrange(0+1,str->size() - 1) ; 
    OclFile["System.out"].println(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Scanner ;
public class Nezzar {
  int number ;
  public Nezzar(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  LinkedList<Integer>list=new LinkedList<>();
  public void input(int number){
    list.add(number);
  }
  public int maxList(LinkedList<Integer>list){
    int max=list.get(0);
    for(int l : list){
      if(l>max){
        max=l ;
      }
    }
    return max ;
  }
  public void printResult(){
    int count=1 ;
    LinkedList<Integer>list1=new LinkedList<>();
    if(list.size()>1){
      for(int i=1 ; i<list.size(); i++){
        if(list.get(i)==list.get(i-1)){
          count++;
        }
        else {
          list1.add(count);
          count=1 ;
        }
        if(i==list.size()-1){
          list1.add(count);
        }
      }
    }
    else {
      list1.add(1);
    }
    System.out.println(maxList(list1));
    list.removeAll(list);
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    Nezzar instance=new Nezzar(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      int num=input.nextInt();
      for(int k=0 ; k<num ; k++){
        int n=input.nextInt();
        instance.input(n);
      }
      instance.printResult();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Nezzar {
   attribute number : int;
   static operation newNezzar( number : int) : Nezzar
  pre: true
  post: true
  activity:
  ( var self : Nezzar ;
    self := createNezzar();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
   attribute list : Sequence(int) := Sequence{};
   operation input( number : int) : void
  pre: true
  post: true
  activity: (     list := list->including(number) );
   operation maxList( list : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var max : int ; max := list->at(0+1) ;
     for (l : list) do ( (     if (l > max) then (     max := l ) else skip )  ) ; 
     return max );
   operation printResult() : void
  pre: true
  post: true
  activity: (     var count : int ; count := 1 ;
     var list1 : Sequence(int) ; list1 := Sequence{} ;
    if (list->size() > 1) then (         var i : int ; i := 1 ; while i < list->size() do ( (     if (list->at(i+1) = list->at(i - 1+1)) then (     count := count + 1 ) else (     list1 := list1->including(count) ; 
     count := 1 ) ;  
     if (i = list->size() - 1) then (     list1 := list1->including(count) ) else skip )  ;     i := i + 1 ) ) else (     list1 := list1->including(1) ) ;  
    OclFile["System.out"].println(maxList(list1)) ; 
    list := list - list ; 
 );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
     var instance : Nezzar ; instance := Nezzar.newNezzar(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
         var k : int ; k := 0 ; while k < num do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     instance.input(n) )  ;     k := k + 1 ) ; 
     instance.printResult() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test299 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      System.out.println(in.nextInt()^ in.nextInt());
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test299 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     OclFile["System.out"].println(in.getCurrent()->toInteger() xor in.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
import java.io.*;
public class codeHundredSixty {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=input.nextInt();
      int[] arrayOne=new int[n];
      int[] arrayTwo=new int[n+1];
      for(int i=0 ; i<n ; i++){
        arrayOne[i]=input.nextInt();
        arrayTwo[arrayOne[i] ]++;
      }
      int max=0 ;
      for(int i=0 ; i<n+1 ; i++){
        if(max<arrayTwo[i]){
          max=arrayTwo[i];
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var arrayOne : Sequence(int) ; arrayOne := Integer.subrange(1,n)->collect(0) ;
    var arrayTwo : Sequence(int) ; arrayTwo := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arrayOne[i+1] := input.getCurrent()->toInteger() ; 
     arrayTwo[arrayOne[i+1]+1] := arrayTwo[arrayOne[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n + 1 do ( (     if (max < arrayTwo[i+1]) then (     max := arrayTwo[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A {
  public static void main(String[] args){
    new A().solve();
  }
  Scanner in ;
  private void solve(){
    in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int max=0 ;
      int n=in.nextInt();
      List<Integer>list=new ArrayList<>(n);
      while(n-->0){
        list.add(in.nextInt());
      }
      Set<Integer>set=new HashSet<>(list);
      for(Integer element : set){
        int frequency=Collections.frequency(list,element);
        if(frequency>max){
          max=frequency ;
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     A.newA().solve() );
   attribute in : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var max : int ; max := 0 ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     list := list->including(in.getCurrent()->toInteger()) ) ;  ) ;  
    var set : Set(int) ; set := Set{}->union(list) ;
    for (element : set) do ( (     var frequency : int ; frequency := .frequency(list, element) ;
     if (frequency > max) then (     max := frequency ) else skip )  ) ; 
    OclFile["System.out"].println(max) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; ++i){
        a[i]=sc.nextInt();
      }
      System.out.println(solve(a));
    }
    sc.close();
  }
  static int solve(int[] a){
    int[] counts=new int[a.length+1];
    for(int ai : a){
++counts[ai];
    }
    return Arrays.stream(counts).max().getAsInt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(solve(a)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var counts : Sequence(int) ; counts := Integer.subrange(1,a->size() + 1)->collect(0) ;
     for (ai : a) do ( (     counts[ai+1] := counts[ai+1] + 1 )  ) ; 
     return stream(counts).max().getAsInt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test270 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int x=1,sum=1 ;
      int p=in.nextInt();
      for(int i=1 ; i<n ; i++){
        int a=in.nextInt();
        if(a==p){
          x++;
        }
        else {
          x=1 ;
        }
        if(x>sum){
          sum=x ;
        }
        p=a ;
      }
      System.out.println(sum);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test270 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var x : int ; x := 1 ;
    var sum : int ; sum := 1 ;
    var p : int ; p := in.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i < n do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     if (a = p) then (     x := x + 1 ) else (     x := 1 ) ;  
     if (x > sum) then (     sum := x ) else skip ; 
     p := a )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Scanner ;
public class Dense {
  private int number ;
  private LinkedList<Integer>listNumber=new LinkedList<>();
  public Dense(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  public void input(int number){
    listNumber.add(number);
  }
  public void printResul(){
    int count=0 ;
    for(int i=0 ; i<listNumber.size()-1 ; i++){
      double max=java.lang.Math.max(listNumber.get(i),listNumber.get(i+1));
      double min=java.lang.Math.min(listNumber.get(i),listNumber.get(i+1));
      if(max/min<=2){
        continue ;
      }
      else {
        min=min*2 ;
        count++;
        while(true){
          if(max/min<=2){
            break ;
          }
          else {
            min*=2 ;
            count++;
          }
        }
      }
    }
    System.out.println(count);
    listNumber.removeAll(listNumber);
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    Dense instance=new Dense(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      int num=input.nextInt();
      for(int k=0 ; k<num ; k++){
        int n=input.nextInt();
        instance.input(n);
      }
      instance.printResul();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Dense {
   attribute number : int;
   attribute listNumber : Sequence(int) := Sequence{};
   static operation newDense( number : int) : Dense
  pre: true
  post: true
  activity:
  ( var self : Dense ;
    self := createDense();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
   operation input( number : int) : void
  pre: true
  post: true
  activity: (     listNumber := listNumber->including(number) );
   operation printResul() : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < listNumber->size() - 1 do ( (     var max : double ; max := java.lang.Math->max() ;
     var min : double ; min := java.lang.Math->min() ;
     if (max / min <= 2) then (     continue ) else (     min := min * 2 ; 
     count := count + 1 ; 
     while (true) do (     if (max / min <= 2) then (     break ) else (     min := min*(2) ; 
     count := count + 1 ) ) ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) ; 
     listNumber := listNumber - listNumber );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
     var instance : Dense ; instance := Dense.newDense(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
         var k : int ; k := 0 ; while k < num do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     instance.input(n) )  ;     k := k + 1 ) ; 
     instance.printResul() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test198 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int p=in.nextInt();
      int sum=0 ;
      for(int i=0 ; i<n-1 ; i++){
        int a=in.nextInt();
        if(a>p){
          while(a>2*p){
            p*=2 ;
            sum++;
          }
        }
        else {
          int b=a ;
          while(p>2*b){
            b*=2 ;
            sum++;
          }
        }
        p=a ;
      }
      System.out.println(sum);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test198 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var p : int ; p := in.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     if (a > p) then (     while (a > 2 * p) do (     p := p*(2) ; 
     sum := sum + 1 ) ) else (     var b : int ; b := a ;
     while (p > 2 * b) do (     b := b*(2) ; 
     sum := sum + 1 ) ) ;  
     p := a )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import org.omg.CORBA.WrongTransaction ;
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),k=in.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
    }
    pw.println(binarySearch(n,k,arr));
    pw.close();
  }
  static boolean check(int n,int k,int[] arr,int lim){
    long cnt=0 ;
    for(int i : arr){
      if(i>lim)cnt+=(i-1)/lim ;
    }
    return cnt<=k ;
  }
  static int binarySearch(int n,int k,int[] arr){
    int l=1,r=(int)1e9+5,res=r ;
    while(l<=r){
      int mid=l+((r-l)>>1);
      if(check(n,k,arr,mid)){
        res=mid ;
        r=mid-1 ;
      }
      else {
        l=mid+1 ;
      }
    }
    return res ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation check( n : int, k : int, arr : Sequence(int), lim : int) : boolean
  pre: true
  post: true
  activity: (     var cnt : long ; cnt := 0 ;
     for (i : arr) do ( (     if (i > lim) then     cnt := cnt+((i - 1) / lim) ; else skip )  ) ; 
     return cnt <= k );
  static   operation binarySearch( n : int, k : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 1 ;
    var r : int ; r := 1e9->oclAsType(int) + 5 ;
    var res : int ; res := r ;
     while (l <= r) do (     var mid : int ; mid := l + (((r - l)/(2->pow(1)))->oclAsType(long)) ;
     if (check(n, k, arr, mid)) then (     res := mid ; 
     r := mid - 1 ) else (     l := mid + 1 ) ) ; 
     return res );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1490A_DenseArray {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int len=parseInt(input.nextLine());
      int first=input.nextInt();
      int result=0 ;
      for(int i=0 ; i<len-1 ; i++){
        final int second=input.nextInt();
        int max=Math.max(first,second);
        int min=Math.min(first,second);
        double scale=(double)max/min ;
        while(scale>2){
          min*=2 ;
          scale=(double)max/min ;
          result++;
        }
        first=second ;
      }
      input.nextLine();
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1490A_DenseArray {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var len : int ; len := parseInt(input.nextLine()) ;
     var first : int ; first := input.getCurrent()->toInteger() ;
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < len - 1 do ( (     var second : int ; second := input.getCurrent()->toInteger() ;
     var max : int ; max := Set{first, second}->max() ;
    var min : int ; min := Set{first, second}->min() ;
    var scale : double ; scale := max->oclAsType(double) / min ;
    while (scale > 2) do (     min := min*(2) ; 
     scale := max->oclAsType(double) / min ; 
     result := result + 1 ) ; 
    first := second ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(result) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Dense_Array {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testcase=sc.nextInt();
    while(testcase!=0){
      testcase--;
      int num=sc.nextInt(),insert=0,mul=0,loop=0,ma,mi ;
      int arr[]=new int[num];
      for(int i=0 ; i<num ; i++)arr[i]=sc.nextInt();
      for(int i=0 ; i<num-1 ; i++){
        loop=0 ;
        ma=max(arr[i],arr[i+1]);
        mi=min(arr[i],arr[i+1]);
        if(ma>2*mi){
          while(true){
            mi*=2 ;
            loop++;
            if(ma<=2*mi)break ;
          }
          insert+=loop ;
        }
      }
      System.out.print(insert);
      if(testcase>0)System.out.println();
    }
    sc.close();
  }
  public static int min(int x,int y){
    int m=x ;
    if(m>y)m=y ;
    return m ;
  }
  public static int max(int x,int y){
    int m=x ;
    if(m<y)m=y ;
    return m ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Dense_Array {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testcase : int ; testcase := sc.getCurrent()->toInteger() ;
     while (testcase /= 0) do (     testcase := testcase - 1 ; 
     var num : int ; num := sc.getCurrent()->toInteger() ;
    var insert : int ; insert := 0 ;
    var mul : int ; mul := 0 ;
    var loop : int ; loop := 0 ;
    var ma : int ;
    var mi : int ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,num)->collect(0) ;
        var i : int ; i := 0 ; while i < num do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < num - 1 do ( (     loop := 0 ; 
     ma := Set{arr[i+1], arr[i + 1+1]}->max() ; 
     mi := Set{arr[i+1], arr[i + 1+1]}->min() ; 
     if (ma > 2 * mi) then (     while (true) do (     mi := mi*(2) ; 
     loop := loop + 1 ; 
     if (ma <= 2 * mi) then     break else skip ) ; 
     insert := insert+(loop) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(insert) ; 
    if (testcase > 0) then     OclFile["System.out"].println() ; else skip ; 
 ) ; 
     skip );
  static   operation min( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var m : int ; m := x ;
     if (m > y) then     m := y ; else skip ; 
     return m );
  static   operation max( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var m : int ; m := x ;
     if (m < y) then     m := y ; else skip ; 
     return m );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class DenseArray {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      int[] a=new int[n];
      int count=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      for(int i=0 ; i<n-1 ; i++){
        int max=Math.max(a[i],a[i+1]);
        int min=Math.min(a[i],a[i+1]);
        if(max>min*2){
          while(min*2<max){
            min=min*2 ;
            count++;
          }
        }
      }
      System.out.println(count);
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DenseArray {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var max : int ; max := Set{a[i+1], a[i + 1+1]}->max() ;
     var min : int ; min := Set{a[i+1], a[i + 1+1]}->min() ;
     if (max > min * 2) then (     while (min * 2 < max) do (     min := min * 2 ; 
     count := count + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static public void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a1=sc.nextLong();
    long a2=sc.nextLong();
    long a3=sc.nextLong();
    long a4=sc.nextLong();
    long a5=sc.nextLong();
    long a6=sc.nextLong();
    long a7=sc.nextLong();
    long length=a2 ;
    if(a1 % 2+a4 % 2+a5 % 2>=2 && a1>0 & a4>0 & a5>0){
      length+=3 ;
      a1-=1 ;
      a4-=1 ;
      a5-=1 ;
    }
    length+=(a1/2)*2 ;
    length+=(a4/2)*2 ;
    length+=(a5/2)*2 ;
    System.out.println(length);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a1 : long ; a1 := sc.getCurrent()->toLong() ;
    var a2 : long ; a2 := sc.getCurrent()->toLong() ;
    var a3 : long ; a3 := sc.getCurrent()->toLong() ;
    var a4 : long ; a4 := sc.getCurrent()->toLong() ;
    var a5 : long ; a5 := sc.getCurrent()->toLong() ;
    var a6 : long ; a6 := sc.getCurrent()->toLong() ;
    var a7 : long ; a7 := sc.getCurrent()->toLong() ;
    var length : long ; length := a2 ;
    if (a1 mod 2 + a4 mod 2 + a5 mod 2 >= 2 & a1 > 0 & a4 > 0 & a5 > 0) then (     length := length+(3) ; 
     a1 := a1-(1) ; 
     a4 := a4-(1) ; 
     a5 := a5-(1) ) else skip ; 
    length := length+((a1 / 2) * 2) ; 
    length := length+((a4 / 2) * 2) ; 
    length := length+((a5 / 2) * 2) ; 
    OclFile["System.out"].println(length) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CXYetAnotherDieGame solver=new CXYetAnotherDieGame();
    solver.solve(1,in,out);
    out.close();
  }
  static class CXYetAnotherDieGame {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      long x=in.nextLong();
      out.println(Math.min(2*((x+10)/11),2*((x-6+10)/11)+1));
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CXYetAnotherDieGame ; solver := CXYetAnotherDieGame.newCXYetAnotherDieGame() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CXYetAnotherDieGame {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var x : long ; x := in.nextLong() ;
     skip );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args){
    SC sc=new SC(System.in);
    long I=sc.nextLong();
    long O=sc.nextLong();
    long T=sc.nextLong();
    long J=sc.nextLong();
    long L=sc.nextLong();
    long S=sc.nextLong();
    long Z=sc.nextLong();
    long ans=0 ;
    long tmp=0 ;
    if(I>0){
      ans+=((I-1)/2)*2 ;
    }
    ans+=O ;
    if(J>0){
      ans+=((J-1)/2)*2 ;
    }
    if(L>0){
      ans+=((L-1)/2)*2 ;
    }
    if(I>0 && J>0 && L>0){
      ans+=3 ;
    }
    tmp+=I/2*2 ;
    tmp+=O ;
    tmp+=J/2*2 ;
    tmp+=L/2*2 ;
    pl(Math.max(ans,tmp));
  }
  static class SC {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public SC(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
  public static void pl(Object o){
    System.out.println(o);
  }
  public static void pl(){
    System.out.println();
  }
  public static void p(Object o){
    System.out.print(o);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : SC ; sc := SC.newSC(OclFile["System.in"]) ;
     var I : long ; I := sc.nextLong() ;
    var O : long ; O := sc.nextLong() ;
    var T : long ; T := sc.nextLong() ;
    var J : long ; J := sc.nextLong() ;
    var L : long ; L := sc.nextLong() ;
    var S : long ; S := sc.nextLong() ;
    var Z : long ; Z := sc.nextLong() ;
    var ans : long ; ans := 0 ;
    var tmp : long ; tmp := 0 ;
    if (I > 0) then (     ans := ans+(((I - 1) / 2) * 2) ) else skip ; 
    ans := ans+(O) ; 
    if (J > 0) then (     ans := ans+(((J - 1) / 2) * 2) ) else skip ; 
    if (L > 0) then (     ans := ans+(((L - 1) / 2) * 2) ) else skip ; 
    if (I > 0 & J > 0 & L > 0) then (     ans := ans+(3) ) else skip ; 
    tmp := tmp+(I / 2 * 2) ; 
    tmp := tmp+(O) ; 
    tmp := tmp+(J / 2 * 2) ; 
    tmp := tmp+(L / 2 * 2) ; 
    execute pl(Set{ans, tmp}->max()) ; 
 );
  static class SC {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newSC( in : OclFile) : SC
  pre: true
  post: true
  activity:
  ( var self : SC ;
    self := createSC();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation pl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  BufferedReader br ;
  PrintWriter out ;
  StringTokenizer st ;
  boolean eof ;
  long go(long a,long b,long c){
    if(a<0 || b<0 || c<0){
      return Long.MIN_VALUE ;
    }
    return a+b+c-(a & 1)-(b & 1)-(c & 1);
  }
  void solve()throws IOException {
    long i=nextLong();
    long o=nextLong();
    long t=nextLong();
    long j=nextLong();
    long l=nextLong();
    long s=nextLong();
    long z=nextLong();
    long ans=o+Math.max(go(i,j,l),go(i-1,j-1,l-1)+3);
    out.println(ans);
  }
  Main()throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(System.out);
    solve();
    out.close();
  }
  public static void main(String[] args)throws IOException {
    new Main();
  }
  String nextToken(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
        eof=true ;
        return null ;
      }
    }
    return st.nextToken();
  }
  String nextString(){
    try {
      return br.readLine();
    }
    catch(IOException e){
      eof=true ;
      return null ;
    }
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute br : OclFile;
   attribute out : OclFile;
   attribute st : OclIterator;
   attribute eof : boolean;
   operation go( a : long, b : long, c : long) : long
  pre: true
  post: true
  activity: (     if (a < 0 or b < 0 or c < 0) then (     return "-9223372036854775808"->toLong() ) else skip ; 
     return a + b + c - (MathLib.bitwiseAnd(a,1)) - (MathLib.bitwiseAnd(b,1)) - (MathLib.bitwiseAnd(c,1)) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var i : long ; i := nextLong() ;
     var o : long ; o := nextLong() ;
    var t : long ; t := nextLong() ;
    var j : long ; j := nextLong() ;
    var l : long ; l := nextLong() ;
    var s : long ; s := nextLong() ;
    var z : long ; z := nextLong() ;
    var ans : long ; ans := o + Set{go(i, j, l), go(i - 1, j - 1, l - 1) + 3}->max() ;
    skip ; 
 );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     execute solve() ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     eof := true ; 
     return null )
 ) ; 
     return st.next() );
   operation nextString() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do (     eof := true ; 
     return null )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static void solve(){
    int[] a=new int[7];
    for(int i=0 ; i<7 ; i++){
      a[i]=in.nextInt();
    }
    long ans1=a[1]*2 ;
    long ans2=ans1 ;
    ans1+=a[0]/2*4 ;
    ans1+=a[3]/2*4 ;
    ans1+=a[4]/2*4 ;
    if(a[0]>0 && a[3]>0 && a[4]>0){
      a[0]--;
      a[3]--;
      a[4]--;
      ans2+=a[0]/2*4 ;
      ans2+=a[3]/2*4 ;
      ans2+=a[4]/2*4 ;
      ans2+=6 ;
    }
    out.println(Math.max(ans1,ans2)/2);
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    solve();
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,7)->collect(0) ;
         var i : int ; i := 0 ; while i < 7 do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans1 : long ; ans1 := a[1+1] * 2 ;
    var ans2 : long ; ans2 := ans1 ;
    ans1 := ans1+(a[0+1] / 2 * 4) ; 
    ans1 := ans1+(a[3+1] / 2 * 4) ; 
    ans1 := ans1+(a[4+1] / 2 * 4) ; 
    if (a[0+1] > 0 & a[3+1] > 0 & a[4+1] > 0) then (     a[0+1] := a[0+1] - 1 ; 
     a[3+1] := a[3+1] - 1 ; 
    a[4+1] := a[4+1] - 1 ; 
    ans2 := ans2+(a[0+1] / 2 * 4) ; 
    ans2 := ans2+(a[3+1] / 2 * 4) ; 
    ans2 := ans2+(a[4+1] / 2 * 4) ; 
    ans2 := ans2+(6) ; 
 ) else skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    execute solve() ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    int i=Integer.parseInt(sa[0]);
    int o=Integer.parseInt(sa[1]);
    int j=Integer.parseInt(sa[3]);
    int l=Integer.parseInt(sa[4]);
    br.close();
    long ans=o ;
    boolean x=(j!=0);
    boolean y=(l!=0);
    boolean z=(i!=0);
    while((j>0)&&(l>0)&&(i>0)){
      ans+=3 ;
      i--;
      j--;
      l--;
    }
    if(j==0 && l % 2==1 && i % 2==1 && x){
      ans+=1 ;
      j++;
      i--;
      l--;
    }
    if(l==0 && j % 2==1 && i % 2==1 && y){
      ans+=1 ;
      l++;
      i--;
      j--;
    }
    if(i==0 && l % 2==1 && j % 2==1 && z){
      ans+=1 ;
      i++;
      j--;
      l--;
    }
    ans+=i/2*2 ;
    ans+=j/2*2 ;
    ans+=l/2*2 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var i : int ; i := (sa[0+1])->toInteger() ;
    var o : int ; o := (sa[1+1])->toInteger() ;
    var j : int ; j := (sa[3+1])->toInteger() ;
    var l : int ; l := (sa[4+1])->toInteger() ;
    skip ; 
    var ans : long ; ans := o ;
    var x : boolean ; x := (j /= 0) ;
    var y : boolean ; y := (l /= 0) ;
    var z : boolean ; z := (i /= 0) ;
    while ((j > 0) & (l > 0) & (i > 0)) do (     ans := ans+(3) ; 
     i := i - 1 ; 
     j := j - 1 ; 
     l := l - 1 ) ; 
    if (j = 0 & l mod 2 = 1 & i mod 2 = 1 & x) then (     ans := ans+(1) ; 
     j := j + 1 ; 
     i := i - 1 ; 
     l := l - 1 ) else skip ; 
    if (l = 0 & j mod 2 = 1 & i mod 2 = 1 & y) then (     ans := ans+(1) ; 
     l := l + 1 ; 
     i := i - 1 ; 
     j := j - 1 ) else skip ; 
    if (i = 0 & l mod 2 = 1 & j mod 2 = 1 & z) then (     ans := ans+(1) ; 
     i := i + 1 ; 
     j := j - 1 ; 
     l := l - 1 ) else skip ; 
    ans := ans+(i / 2 * 2) ; 
    ans := ans+(j / 2 * 2) ; 
    ans := ans+(l / 2 * 2) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[])throws IOException {
    Scanner scan=new Scanner(System.in);
    int Ans=0 ;
    int N=scan.nextInt();
    int[] P=new int[N];
    for(int i=0 ; i<N ; i++){
      P[i]=scan.nextInt();
    }
    for(int i=0 ; i<=P[0]; i++){
      int ans=i ;
      int nextS=P[0]-i ;
      for(int cursor=0 ; cursor<N-1 ; cursor++){
        ans+=nextS*2 ;
        nextS=P[cursor+1]-nextS ;
        if(nextS<0){
          nextS=0 ;
        }
      }
      if(nextS>0){
        ans+=nextS ;
      }
      if(i==0 || Ans>ans){
        Ans=ans ;
      }
    }
    System.out.println(Ans);
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var Ans : int ; Ans := 0 ;
    var N : int ; N := scan.getCurrent()->toInteger() ;
    var P : Sequence(int) ; P := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     P[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= P[0+1] do ( (     var ans : int ; ans := i ;
     var nextS : int ; nextS := P[0+1] - i ;
        var cursor : int ; cursor := 0 ; while cursor < N - 1 do ( (     ans := ans+(nextS * 2) ; 
     nextS := P[cursor + 1+1] - nextS ; 
     if (nextS < 0) then (     nextS := 0 ) else skip )  ;     cursor := cursor + 1 ) ; 
    if (nextS > 0) then (     ans := ans+(nextS) ) else skip ; 
    if (i = 0 or Ans > ans) then (     Ans := ans ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public final class Main {
  public static void main(String[] args){
    final Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    final String[] line=in.nextLine().split(" ");
    final int n=Integer.parseInt(line[0]);
    final int k=Integer.parseInt(line[1]);
    final int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
    }
    in.nextLine();
    int low=1,high=(int)1e9 ;
    while(low<high){
      final int mid=low+high>>>1 ;
      int cnt=0 ;
      for(int i=0 ; i<n ; i++){
        cnt+=(arr[i]-1)/mid ;
      }
      if(k<cnt){
        low=mid+1 ;
      }
      else {
        high=mid ;
      }
    }
    System.out.println(low);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var line : Sequence(String) ; line := in.nextLine()->split(" ") ;
    var n : int ; n := (line[0+1])->toInteger() ;
    var k : int ; k := (line[1+1])->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var low : int ; low := 1 ;
    var high : int ; high := 1e9->oclAsType(int) ;
    while (low < high) do (     var mid : int ; mid := (low + high/(2->pow(1)))->oclAsType(long) ;
     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     cnt := cnt+((arr[i+1] - 1) / mid) )  ;     i := i + 1 ) ; 
     if (k < cnt) then (     low := mid + 1 ) else (     high := mid ) ) ; 
    OclFile["System.out"].println(low) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int[] height=new int[] {
    1,2,1,2 };
    public static int woodCollected(int n,int m){
      int sum=0 ;
      for(int i=n-1 ; i>=0 ; i--){
        if(height[i]-m<=0)break ;
        sum+=(height[i]-m);
      }
      return sum ;
    }
    public static int collectKWood(int n,int k){
      Arrays.sort(height);
      int low=0,high=height[n-1];
      while(low<=high){
        int mid=low+((high-low)/2);
        int collected=woodCollected(n,mid);
        if(collected==k)return mid ;
        if(collected>k)low=mid+1 ;
        else high=mid-1 ;
      }
      return-1 ;
    }
    public static void main(String[] args){
      int k=2 ;
      int n=height.length ;
      System.out.print(collectKWood(n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute height : Sequence(int) := Sequence{1,2,1,2};
  static   operation woodCollected( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := n - 1 ; while i >= 0 do ( (     if (height[i+1] - m <= 0) then     break else skip ; 
     sum := sum+((height[i+1] - m)) )  ;     i := i - 1 ) ; 
     return sum );
  static   operation collectKWood( n : int, k : int) : int
  pre: true
  post: true
  activity: (     height := height->sort() ; 
     var low : int ; low := 0 ;
    var high : int ; high := height[n - 1+1] ;
     while (low <= high) do (     var mid : int ; mid := low + ((high - low) / 2) ;
     var collected : int ; collected := woodCollected(n, mid) ;
     if (collected = k) then     return mid else skip ; 
     if (collected > k) then     low := mid + 1 ; else     high := mid - 1 ; ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 2 ;
     var n : int ; n := height->size() ;
     OclFile["System.out"].print(collectKWood(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static ArrayList<ArrayList<Integer>>graph=new ArrayList<>();
  ;
  static int[] values ;
  static int[] longest ;
  static int[] ans ;
  static boolean[] used ;
  static int n ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    values=new int[n];
    for(int i=0 ; i<n ; i++){
      values[i]=sc.nextInt();
      graph.add(new ArrayList<>());
    }
    longest=new int[n+1];
    Arrays.fill(longest,Integer.MAX_VALUE);
    longest[0]=0 ;
    ans=new int[n];
    used=new boolean[n];
    for(int i=0 ; i<n-1 ; i++){
      int a=sc.nextInt()-1 ;
      int b=sc.nextInt()-1 ;
      graph.get(a).add(b);
      graph.get(b).add(a);
    }
    search(0,0);
    StringBuilder sb=new StringBuilder();
    for(int x : ans){
      sb.append(x).append("\n");
    }
    System.out.print(sb);
  }
  static void search(int idx,int max){
    if(used[idx]){
      return ;
    }
    used[idx]=true ;
    int left=0 ;
    int right=n+1 ;
    while(right-left>1){
      int m=(left+right)/2 ;
      if(longest[m]<values[idx]){
        left=m ;
      }
      else {
        right=m ;
      }
    }
    int save=longest[left+1];
    max=Math.max(max,left+1);
    longest[left+1]=Math.min(longest[left+1],values[idx]);
    ans[idx]=max ;
    for(int x : graph.get(idx)){
      search(x,max);
    }
    longest[left+1]=save ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute graph : Sequence(Sequence(int)) := Sequence{};
  static   attribute values : Sequence(int);
  static   attribute longest : Sequence(int);
  static   attribute ans : Sequence(int);
  static   attribute used : Sequence(boolean);
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    values := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     values[i+1] := sc.getCurrent()->toInteger() ; 
     graph := graph->including(Sequence{}) )  ;     i := i + 1 ) ; 
    longest := Integer.subrange(1,n + 1)->collect(0) ; 
    longest := longest->collect(2147483647) ; 
    longest[0+1] := 0 ; 
    ans := Integer.subrange(1,n)->collect(0) ; 
    used := Integer.subrange(1,n)->collect(false) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
     var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
     graph->at(a+1)->excludes(b) ; 
     graph->at(b+1)->excludes(a) )  ;     i := i + 1 ) ; 
    execute search(0, 0) ; 
    var sb : String ; sb := StringLib.newString() ;
    for (x : ans) do ( (     sb := sb + StringLib.newString(x) + StringLib.newString("\n") )  ) ; 
    OclFile["System.out"].print(sb) ; 
 );
  static   operation search( idx : int, max : int) : void
  pre: true
  post: true
  activity: (     if (used[idx+1]) then (     return ) else skip ; 
     used[idx+1] := true ; 
    var left : int ; left := 0 ;
    var right : int ; right := n + 1 ;
    while (right - (left)->char2byte() > 1) do (     var m : int ; m := (left + right) / 2 ;
     if (longest[m+1] < values[idx+1]) then (     left := m ) else (     right := m ) ) ; 
    var save : int ; save := longest[left + 1+1] ;
    max := Set{max, left + 1}->max() ; 
    longest[left + 1+1] := Set{longest[left + 1+1], values[idx+1]}->min() ; 
    ans[idx+1] := max ; 
    for (x : graph->at(idx+1)) do ( (     execute search(x, max) )  ) ; 
    longest[left + 1+1] := save ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMinOperations(String S){
    S=reverse(S);
    int n=S.length();
    int dp[][]=new int[n+1][2];
    if(S.charAt(0)=='0'){
      dp[0][0]=0 ;
    }
    else {
      dp[0][0]=1 ;
    }
    dp[0][1]=1 ;
    for(int i=1 ; i<n ; i++){
      if(S.charAt(i)=='0'){
        dp[i][0]=dp[i-1][0];
        dp[i][1]=1+Math.min(dp[i-1][1],dp[i-1][0]);
      }
      else {
        dp[i][1]=dp[i-1][1];
        dp[i][0]=1+Math.min(dp[i-1][0],dp[i-1][1]);
      }
    }
    return dp[n-1][0];
  }
  static String reverse(String input){
    char[] temparray=input.toCharArray();
    int left,right=0 ;
    right=temparray.length-1 ;
    for(left=0 ; left<right ; left++,right--){
      char temp=temparray[left];
      temparray[left]=temparray[right];
      temparray[right]=temp ;
    }
    return String.valueOf(temparray);
  }
  public static void main(String[] args){
    String S="100" ;
    System.out.println(findMinOperations(S));
    S="111" ;
    System.out.println(findMinOperations(S));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMinOperations( S : String) : int
  pre: true
  post: true
  activity: (     S := reverse(S) ; 
     var n : int ; n := S->size() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,2)->collect(0)) ;
    if (S->at(0+1) = '0') then (     dp[0+1][0+1] := 0 ) else (     dp[0+1][0+1] := 1 ) ;  
    dp[0+1][1+1] := 1 ; 
        var i : int ; i := 1 ; while i < n do ( (     if (S->at(i+1) = '0') then (     dp[i+1][0+1] := dp[i - 1+1][0+1] ; 
     dp[i+1][1+1] := 1 + Set{dp[i - 1+1][1+1], dp[i - 1+1][0+1]}->min() ) else (     dp[i+1][1+1] := dp[i - 1+1][1+1] ; 
     dp[i+1][0+1] := 1 + Set{dp[i - 1+1][0+1], dp[i - 1+1][1+1]}->min() ) )  ;     i := i + 1 ) ; 
    return dp[n - 1+1][0+1] 
 );
  static   operation reverse( input : String) : String
  pre: true
  post: true
  activity: (     var temparray : Sequence(String) ; temparray := input->characters() ;
     var left : int ;
    var right : int ; right := 0 ;
    right := temparray->size() - 1 ; 
        left := 0 ; while left < right do ( (     var temp : String ; temp := temparray[left+1] ;
     temparray[left+1] := temparray[right+1] ; 
     temparray[right+1] := temp )  ;     left := left + 1 ;     right := right - 1 ) ; 
    return (temparray)->sum()  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := "100" ;
     OclFile["System.out"].println(findMinOperations(S)) ; 
     S := "111" ; 
     OclFile["System.out"].println(findMinOperations(S)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countNumbers(int n){
    if(n % 2==1)return 0 ;
    return(9*(int)Math.pow(10,n/2-1));
  }
  public static void main(String args[]){
    int n=2 ;
    System.out.print(countNumbers(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countNumbers( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 = 1) then     return 0 else skip ; 
     return (9 * 10->pow(n / 2 - 1)->oclAsType(int)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].print(countNumbers(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  public static int stopping_station(int p,int n){
    int num=1,dem=1,s=p ;
    while(p!=1){
      dem*=p ;
      p--;
    }
    int t=n-s+1 ;
    while(t!=(n-2*s+1)){
      num*=t ;
      t--;
    }
    if((n-s+1)>=s)System.out.print(num/dem);
    else System.out.print("not possible");
    return 0 ;
  }
  public static void main(String[] args){
    int n,s ;
    stopping_station(4,12);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation stopping_station( p : int, n : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := 1 ;
    var dem : int ; dem := 1 ;
    var s : int ; s := p ;
     while (p /= 1) do (     dem := dem*(p) ; 
     p := p - 1 ) ; 
    var t : int ; t := n - s + 1 ;
    while (t /= (n - 2 * s + 1)) do (     num := num*(t) ; 
     t := t - 1 ) ; 
    if ((n - s + 1) >= s) then     OclFile["System.out"].print(num / dem) else     OclFile["System.out"].print("not possible") ; ;  
    return 0 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var s : int ;
     execute stopping_station(4, 12) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    sc.close();
    long count=0 ;
    if(N % 11==0)count=N/11*2 ;
    else if(N % 11<=6)count=N/11*2+1 ;
    else count=N/11*2+2 ;
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    skip ; 
    var count : long ; count := 0 ;
    if (N mod 11 = 0) then     count := N / 11 * 2 else     if (N mod 11 <= 6) then     count := N / 11 * 2 + 1 else     count := N / 11 * 2 + 2 ; ;  ;  
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    while(k>0){
      System.out.print(n+" ");
      n--;
      k--;
    }
    for(int i=1 ; i<=n ; i++){
      if(i==n)System.out.print(i);
      else System.out.print(i+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    while (k > 0) do (     OclFile["System.out"].print(n + " ") ; 
     n := n - 1 ; 
     k := k - 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (i = n) then     OclFile["System.out"].print(i) ; else     OclFile["System.out"].print(i + " ") ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
import static java.lang.System.out ;
public class pre130 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int n=obj.nextInt(),k=obj.nextInt();
    if(k==0){
      for(int i=1 ; i<=n ; i++)out.print(i+" ");
    }
    else {
      int c=n ;
      for(int i=1 ; i<=n-k-1 ; i++)out.print(i+" ");
      for(int i=n ; i>n-k-1 ; i--)out.print(i+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre130 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var n : int ; n := obj.nextInt() ;
    var k : int ; k := obj.nextInt() ;
     if (k = 0) then (         var i : int ; i := 1 ; while i <= n do (     out.print(i + " ") ;  ;     i := i + 1 ) ) else (     var c : int ; c := n ;
         var i : int ; i := 1 ; while i <= n - k - 1 do (     out.print(i + " ") ;  ;     i := i + 1 ) ; 
         var i : int ; i := n ; while i > n - k - 1 do (     out.print(i + " ") ;  ;     i := i - 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Main ob=new Main();
    ob.run();
  }
  private void run(){
    int n=nextInt();
    int k=nextInt();
    for(int i=n ; i>n-k ; i--){
      out.print(i+" ");
    }
    for(int i=1 ; i<=n-k ; i++){
      out.print(i+" ");
    }
    out.close();
  }
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer st ;
  PrintWriter out=new PrintWriter(System.out);
  String nextLine(){
    try {
      return br.readLine();
    }
    catch(IOException ex){
      ex.printStackTrace();
    }
    return "" ;
  }
  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());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ob : Main ; ob := Main.newMain() ;
     ob.run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var k : int ; k := nextInt() ;
        var i : int ; i := n ; while i > n - k do ( (     out.print(i + " ") )  ;     i := i - 1 ) ; 
        var i : int ; i := 1 ; while i <= n - k do ( (     out.print(i + " ") )  ;     i := i + 1 ) ; 
    out.close() ; 
 );
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator;
   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (ex : IOException) do (     ex.printStackTrace() )
     return "" );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class level2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    for(int i=1 ; i<=n-(k+1); i++)System.out.print(i+" ");
    for(int i=0 ; i<k+1 ; i++){
      System.out.print((n--)+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class level2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= n - (k + 1) do (     OclFile["System.out"].print(i + " ") ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k + 1 do ( (     OclFile["System.out"].print((n) + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Map hs=new HashMap();
    PrintWriter ou=new PrintWriter(System.out);
    int n=Integer.parseInt(sc.next());
    int k=Integer.parseInt(sc.next());
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(sc.next());
    }
    sc.close();
    double le=0 ;
    double ri=Math.pow(10,9);
    while(ri-le>0.000001){
      double now=(le+ri)/2 ;
      int yono=0 ;
      for(int i=0 ; i<n ; i++){
        yono+=(int)(a[i]/now);
      }
      if(yono>k)le=now ;
      else ri=now ;
    }
    if(ri % 1<0.000001 || ri % 1>0.99999)ou.print((int)Math.round(ri)+"\n");
    else ou.print((int)Math.ceil(ri)+"\n");
    ou.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var hs : Map ; hs := Map{} ;
    var ou : OclFile ; ou := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (sc.getCurrent())->toInteger() ;
    var k : int ; k := (sc.getCurrent())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var le : double ; le := 0 ;
    var ri : double ; ri := 10->pow(9) ;
    while (ri - le > 0.000001) do (     var now : double ; now := (le + ri) / 2 ;
     var yono : int ; yono := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     yono := yono+((a[i+1] / now)->oclAsType(int)) )  ;     i := i + 1 ) ; 
     if (yono > k) then     le := now ; else     ri := now ; ) ; 
    if (ri mod 1 < 0.000001 or ri mod 1 > 0.99999) then     ou := ou.print((ri)->round()->oclAsType(int) + "\n") else     ou := ou.print((ri)->ceil()->oclAsType(int) + "\n") ; ;  
    ou := ou.flush() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Haversine {
  static double haversine(double lat1,double lon1,double lat2,double lon2){
    double dLat=Math.toRadians(lat2-lat1);
    double dLon=Math.toRadians(lon2-lon1);
    lat1=Math.toRadians(lat1);
    lat2=Math.toRadians(lat2);
    double a=Math.pow(Math.sin(dLat/2),2)+Math.pow(Math.sin(dLon/2),2)*Math.cos(lat1)*Math.cos(lat2);
    double rad=6371 ;
    double c=2*Math.asin(Math.sqrt(a));
    return rad*c ;
  }
  public static void main(String[] args){
    double lat1=51.5007 ;
    double lon1=0.1246 ;
    double lat2=40.6892 ;
    double lon2=74.0445 ;
    System.out.println(haversine(lat1,lon1,lat2,lon2)+" K.M.");
  }
}
------------------------------------------------------------
OCL File:
---------
class Haversine {
  static   operation haversine( lat1 : double, lon1 : double, lat2 : double, lon2 : double) : double
  pre: true
  post: true
  activity: (     var dLat : double ; dLat := (0.017453292519943295*(lat2 - lat1)) ;
     var dLon : double ; dLon := (0.017453292519943295*(lon2 - lon1)) ;
    lat1 := (0.017453292519943295*(lat1)) ; 
    lat2 := (0.017453292519943295*(lat2)) ; 
    var a : double ; a := (dLat / 2)->sin()->pow(2) + (dLon / 2)->sin()->pow(2) * (lat1)->cos() * (lat2)->cos() ;
    var rad : double ; rad := 6371 ;
    var c : double ; c := 2 * ((a)->sqrt())->asin() ;
    return rad * c 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var lat1 : double ; lat1 := 51.5007 ;
     var lon1 : double ; lon1 := 0.1246 ;
    var lat2 : double ; lat2 := 40.6892 ;
    var lon2 : double ; lon2 := 74.0445 ;
    OclFile["System.out"].println(haversine(lat1, lon1, lat2, lon2) + " K.M.") ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    try(Scanner in=new Scanner(System.in)){
      int M=in.nextInt();
      int K=in.nextInt();
      if(K==0){
        StringBuilder sb=new StringBuilder();
        for(int i=0,I=1<<(M); i<I ; i++){
          sb.append(" "+i+" "+i);
        }
        System.out.println(sb.toString().trim());
        return ;
      }
      int xor=0 ;
      for(int i=0,I=1<<(M); i<I ; i++){
        if(i==K){
          continue ;
        }
        xor ^=i ;
      }
      if(xor==K){
        StringBuilder sb=new StringBuilder();
        for(int i=0,I=1<<(M); i<I ; i++){
          if(i==K){
            continue ;
          }
          sb.append(" "+i);
        }
        sb.append(" "+K);
        for(int i=(1<<(M))-1 ; i>=0 ; i--){
          if(i==K){
            continue ;
          }
          sb.append(" "+i);
        }
        sb.append(" "+K);
        System.out.println(sb.toString().trim());
      }
      else {
        System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var M : int ; M := in.getCurrent()->toInteger() ;
     var K : int ; K := in.getCurrent()->toInteger() ;
    if (K = 0) then (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ;
    var I : int ; I := (1*(2->pow((M))))->oclAsType(long) ; while i < I do ( (     sb := sb + StringLib.newString(" " + i + " " + i) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sb+""->trim()) ; 
     return ) else skip ; 
    var xor : int ; xor := 0 ;
        var i : int ; i := 0 ;
    var I : int ; I := (1*(2->pow((M))))->oclAsType(long) ; while i < I do ( (     if (i = K) then (     continue ) else skip ; 
     xor := MathLib.bitwiseXor(xor,i) )  ;     i := i + 1 ) ; 
    if (xor = K) then (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ;
    var I : int ; I := (1*(2->pow((M))))->oclAsType(long) ; while i < I do ( (     if (i = K) then (     continue ) else skip ; 
     sb := sb + StringLib.newString(" " + i) )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(" " + K) ; 
        var i : int ; i := ((1*(2->pow((M))))->oclAsType(long)) - 1 ; while i >= 0 do ( (     if (i = K) then (     continue ) else skip ; 
     sb := sb + StringLib.newString(" " + i) )  ;     i := i - 1 ) ; 
    sb := sb + StringLib.newString(" " + K) ; 
    OclFile["System.out"].println(sb+""->trim()) ; 
 ) else (     OclFile["System.out"].println(-1) ) ;  
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  static void impossible(){
    System.out.println("-1");
    System.exit(0);
  }
  static void printList(List<Integer>l){
    int N=l.size();
    int n=0 ;
    for(int e : l){
      n++;
      System.out.print(e+(n<N ? " " : "\n"));
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int M=sc.nextInt();
    int N=1<<M ;
    int K=sc.nextInt();
    if(K>=N)impossible();
    if(M==1 && K==1)impossible();
    if(M==1 && K==0){
      System.out.println("0 0 1 1");
      System.exit(0);
    }
    LinkedList<Integer>list=new LinkedList<>();
    list.add(K);
    for(int n=0 ; n<N ; n++)if(n!=K){
      list.addFirst(n);
      list.addLast(n);
    }
    list.addLast(K);
    printList(list);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation impossible() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("-1") ; 
 OclProcess.exit(0) );
  static   operation printList( l : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := l->size() ;
     var n : int ; n := 0 ;
     for (e : l) do ( (     n := n + 1 ; 
     OclFile["System.out"].print(e + (if n < N then " " else "\n" endif)) )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var M : int ; M := sc.getCurrent()->toInteger() ;
    var N : int ; N := (1*(2->pow(M)))->oclAsType(long) ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    if (K >= N) then     execute impossible() ; else skip ; 
    if (M = 1 & K = 1) then     execute impossible() ; else skip ; 
    if (M = 1 & K = 0) then (     OclFile["System.out"].println("0 0 1 1") ; 
 OclProcess.exit(0) ) else skip ; 
    var list : Sequence(int) ; list := Sequence{} ;
    list := list->including(K) ; 
        var n : int ; n := 0 ; while n < N do (     if (n /= K) then (     list := list->prepend(n) ; 
     list := list->append(n) ) else skip ;  ;     n := n + 1 ) ; 
    list := list->append(K) ; 
    execute printList(list) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] $){
    Scanner s=new Scanner(System.in);
    int n=1<<s.nextInt(),k=s.nextInt();
    StringJoiner sb=new StringJoiner(" ");
    if(n==2){
      if(k==0)System.out.println("0 0 1 1");
      else System.out.println(-1);
      return ;
    }
    if(k>=n){
      System.out.println(-1);
      return ;
    }
    for(int i=0 ; i<n ; ++i){
      if(i!=k)sb.add(String.valueOf(i));
    }
    sb.add(String.valueOf(k));
    for(int i=n-1 ; i>=0 ; --i){
      if(i!=k)sb.add(String.valueOf(i));
    }
    sb.add(String.valueOf(k));
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (1*(2->pow(s.getCurrent()->toInteger())))->oclAsType(long) ;
    var k : int ; k := s.getCurrent()->toInteger() ;
    var sb : StringJoiner ; sb := StringJoiner.newStringJoiner(" ") ;
    if (n = 2) then (     if (k = 0) then     OclFile["System.out"].println("0 0 1 1") else     OclFile["System.out"].println(-1) ; ;  
     return ) else skip ; 
    if (k >= n) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i /= k) then     sb->excludes(((i) + "")) ; else skip )  ;     i := i + 1 ) ; 
    sb->excludes(((k) + "")) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (i /= k) then     sb->excludes(((i) + "")) ; else skip )  ;     i := i - 1 ) ; 
    sb->excludes(((k) + "")) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    BigInteger v=new BigInteger("11");
    BigInteger input=new BigInteger(sc.next());
    if(input.compareTo(v)<=0){
      if(input.compareTo(new BigInteger("6"))<=0){
        System.out.println(1);
      }
      else {
        System.out.println(2);
      }
    }
    else {
      BigInteger res=new BigInteger("0");
      res=input.divide(v).multiply(new BigInteger("2"));
      if(input.mod(v).equals(new BigInteger("0"))){
      }
      else if(input.mod(v).compareTo(new BigInteger("6"))<=0){
        res=res.add(new BigInteger("1"));
      }
      else {
        res=res.add(new BigInteger("2"));
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var v : long ; v := long("11") ;
     var input : long ; input := long(sc.getCurrent()) ;
     if (input->compareTo(v) <= 0) then (     if (input->compareTo(long("6")) <= 0) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(2) ) ) else (     var res : long ; res := long("0") ;
     res := input.divide(v).multiply(long("2")) ; 
     if (input.mod(v) = long("0")) then skip else     if (input.mod(v)->compareTo(long("6")) <= 0) then (     res := res->excludes(long("1")) ) else (     res := res->excludes(long("2")) ) ;  ;  
     OclFile["System.out"].println(res) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void CamelCase(ArrayList<String>words,String pattern){
    Map<String,List<String>>map=new HashMap<String,List<String>>();
    for(int i=0 ; i<words.size(); i++){
      String str="" ;
      int l=words.get(i).length();
      for(int j=0 ; j<l ; j++){
        if(words.get(i).charAt(j)>='A' && words.get(i).charAt(j)<='Z'){
          str+=words.get(i).charAt(j);
          map.put(str,list(map.get(str),words.get(i)));
        }
      }
    }
    boolean wordFound=false ;
    for(Map.Entry<String,List<String>>it : map.entrySet()){
      if(it.getKey().equals(pattern)){
        wordFound=true ;
        for(String s : it.getValue())System.out.print(s+"\n");
      }
    }
    if(! wordFound){
      System.out.print("No match found");
    }
  }
  private static List<String>list(List<String>list,String str){
    List<String>temp=new ArrayList<String>();
    if(list!=null)temp.addAll(list);
    temp.add(str);
    return temp ;
  }
  public static void main(String[] args){
    String arr[]={
      "Hi","Hello","HelloWorld","HiTech","HiGeek","HiTechWorld","HiTechCity","HiTechLab" };
      ArrayList<String>words=new ArrayList<String>(Arrays.asList(arr));
      String pattern="HT" ;
      CamelCase(words,pattern);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation CamelCase( words : Sequence(String), pattern : String) : void
  pre: true
  post: true
  activity: (     var map : Map(String,Sequence(String)) ; map := Map{} ;
         var i : int ; i := 0 ; while i < words->size() do ( (     var str : String ; str := "" ;
     var l : int ; l := words->at(i+1)->size() ;
         var j : int ; j := 0 ; while j < l do ( (     if (words->at(i+1)->at(j+1) >= 'A' & words->at(i+1)->at(j+1) <= 'Z') then (     str := str+(words->at(i+1)->at(j+1)) ; 
     map := map->union(Map{str |-> list(map->at(str), words->at(i+1))}) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var wordFound : boolean ; wordFound := false ;
    for (it : map->asSet()) do ( (     if (it.getKey() = pattern) then (     wordFound := true ; 
     for (s : it.getValue()) do (     OclFile["System.out"].print(s + "\n") ;  ) ) else skip )  ) ; 
    if (not(wordFound)) then (     OclFile["System.out"].print("No match found") ) else skip ; 
 );
  static   operation list( list : Sequence(String), str : String) : Sequence(String)
  pre: true
  post: true
  activity: (     var temp : Sequence(String) ; temp := Sequence{} ;
     if (list /= null) then     temp := temp->union(list) ; else skip ; 
     temp := temp->including(str) ; 
     return temp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"Hi","Hello","HelloWorld","HiTech","HiGeek","HiTechWorld","HiTechCity","HiTechLab"} ;
     var words : Sequence(String) ; words := Sequence{}->union(arr) ;
     var pattern : String ; pattern := "HT" ;
     execute CamelCase(words, pattern) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int summation(int n){
    int sum=0 ;
    for(int i=1 ; i<=n ; i++){
      if(i % 2==1)sum+=(i*i);
      else sum-=(i*i);
    }
    return sum ;
  }
  public static void main(String[] args){
    int N=2 ;
    System.out.println(summation(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation summation( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     if (i mod 2 = 1) then     sum := sum+((i * i)) ; else     sum := sum-((i * i)) ; )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 2 ;
     OclFile["System.out"].println(summation(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
class GFG {
  private static final int MAX=2147483647 ;
  static int[][] one=new int[100001][32];
  static void make_prefix(int A[],int n){
    for(int j=0 ; j<32 ; j++)one[0][j]=0 ;
    for(int i=1 ; i<=n ; i++){
      int a=A[i-1];
      for(int j=0 ; j<32 ; j++){
        int x=(int)Math.pow(2,j);
        if((a & x)!=0)one[i][j]=1+one[i-1][j];
        else one[i][j]=one[i-1][j];
      }
    }
  }
  static int Solve(int L,int R){
    int l=L,r=R ;
    int tot_bits=r-l+1 ;
    int X=MAX ;
    for(int i=0 ; i<31 ; i++){
      int x=one[r][i]-one[l-1][i];
      if(x>=tot_bits-x){
        int ith_bit=(int)Math.pow(2,i);
        X=X ^ ith_bit ;
      }
    }
    return X ;
  }
  public static void main(String[] args){
    int n=5,q=3 ;
    int A[]={
      210,11,48,22,133 };
      int L[]={
        1,4,2 },R[]={
          3,14,4 };
          make_prefix(A,n);
          for(int j=0 ; j<q ; j++)System.out.println(Solve(L[j],R[j]));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX : int := 2147483647;
  static   attribute one : Sequence(Sequence(int)) := Integer.subrange(1,100001)->collect(Integer.subrange(1,32)->collect(0));
  static   operation make_prefix( A : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var j : int ; j := 0 ; while j < 32 do (     one[0+1][j+1] := 0 ;  ;     j := j + 1 ) ; 
         var i : int ; i := 1 ; while i <= n do ( (     var a : int ; a := A[i - 1+1] ;
         var j : int ; j := 0 ; while j < 32 do ( (     var x : int ; x := 2->pow(j)->oclAsType(int) ;
     if ((MathLib.bitwiseAnd(a,x)) /= 0) then     one[i+1][j+1] := 1 + one[i - 1+1][j+1] ; else     one[i+1][j+1] := one[i - 1+1][j+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation Solve( L : int, R : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := L ;
    var r : int ; r := R ;
     var tot_bits : int ; tot_bits := r - l + 1 ;
    var X : int ; X := MAX ;
        var i : int ; i := 0 ; while i < 31 do ( (     var x : int ; x := one[r+1][i+1] - one[l - 1+1][i+1] ;
     if (x >= tot_bits - x) then (     var ith_bit : int ; ith_bit := 2->pow(i)->oclAsType(int) ;
     X := MathLib.bitwiseXor(X,ith_bit) ) else skip )  ;     i := i + 1 ) ; 
    return X 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var q : int ; q := 3 ;
     var A : Sequence(int) ; A := Sequence{210,11,48,22,133} ;
    var L : Sequence(int) ; L := Sequence{1,4,2} ;
    var R : Sequence(void) ; R := Sequence{3,14,4} ;
    execute make_prefix(A, n) ; 
        var j : int ; j := 0 ; while j < q do (     OclFile["System.out"].println(Solve(L[j+1], R[j+1])) ;  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void maxSum(int[] a,int n){
    Vector<Integer>l=new Vector<Integer>();
    int s=0 ;
    for(int i=0 ; i<n ; i++){
      s+=Math.abs(a[i]);
      if(a[i]>=0)continue ;
      if(i==0)l.add(i+1);
      else {
        l.add(i+1);
        l.add(i);
      }
    }
    System.out.println(s);
    for(int i=0 ; i<l.size(); i++)System.out.print(l.get(i)+" ");
  }
  public static void main(String[] args){
    int n=4 ;
    int a[]={
      1,-2,-3,4 };
      maxSum(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSum( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     var s : int ; s := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     s := s+(if a[i+1] < 0 then -(a[i+1]) else a[i+1] endif) ; 
     if (a[i+1] >= 0) then     continue else skip ; 
     if (i = 0) then     l := l->including(i + 1) ; else (     l := l->including(i + 1) ; 
     l := l->including(i) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
        var i : int ; i := 0 ; while i < l->size() do (     OclFile["System.out"].print(l->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var a : Sequence(int) ; a := Sequence{1,-2,-3,4} ;
     execute maxSum(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GfG {
  static void printArray(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  static void printMaxMean(int arr[],int n){
    int newArr[]=new int[n];
    Arrays.sort(arr,0,2*n);
    for(int i=0 ; i<n ; i++)newArr[i]=arr[i+n];
    printArray(newArr,n);
  }
  public static void main(String[] args){
    int arr[]={
      4,8,3,1,3,7,0,4 };
      int n=arr.length ;
      printMaxMean(arr,n/2);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation printArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation printMaxMean( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var newArr : Sequence(int) ; newArr := Integer.subrange(1,n)->collect(0) ;
     arr := arr.subrange(1,0)^(arr.subrange(0+1,2 * n)->sort())^arr.subrange(2 * n+1,arr.size) ; 
         var i : int ; i := 0 ; while i < n do (     newArr[i+1] := arr[i + n+1] ;  ;     i := i + 1 ) ; 
     execute printArray(newArr, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,8,3,1,3,7,0,4} ;
     var n : int ; n := arr->size() ;
     execute printMaxMean(arr, n / 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printCompositions(int arr[],int n,int i){
    int MAX_POINT=3 ;
    if(n==0){
      printArray(arr,i);
    }
    else if(n>0){
      for(int k=1 ; k<=MAX_POINT ; k++){
        arr[i]=k ;
        printCompositions(arr,n-k,i+1);
      }
    }
  }
  static void printArray(int arr[],int m){
    for(int i=0 ; i<m ; i++)System.out.print(arr[i]+" ");
    System.out.println();
  }
  public static void main(String[] args){
    int n=5 ;
    int size=100 ;
    int[] arr=new int[size];
    System.out.println("Different compositions formed by 1,2 and 3 of "+n+" are");
    printCompositions(arr,n,0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printCompositions( arr : Sequence(int), n : int, i : int) : void
  pre: true
  post: true
  activity: (     var MAX_POINT : int ; MAX_POINT := 3 ;
     if (n = 0) then (     execute printArray(arr, i) ) else     if (n > 0) then (         var k : int ; k := 1 ; while k <= MAX_POINT do ( (     arr[i+1] := k ; 
     execute printCompositions(arr, n - k, i + 1) )  ;     k := k + 1 ) ) else skip ; );
  static   operation printArray( arr : Sequence(int), m : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < m do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var size : int ; size := 100 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
    OclFile["System.out"].println("Different compositions formed by 1,2 and 3 of " + n + " are") ; 
    execute printCompositions(arr, n, 0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static String areAllBitsSet(int n){
    if(n==0)return "No" ;
    if(((n+1)& n)==0)return "Yes" ;
    return "No" ;
  }
  public static void main(String[] args){
    int n=7 ;
    System.out.println(areAllBitsSet(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation areAllBitsSet( n : int) : String
  pre: true
  post: true
  activity: (     if (n = 0) then     return "No" else skip ; 
     if (((n + 1) & n) = 0) then     return "Yes" else skip ; 
     return "No" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     OclFile["System.out"].println(areAllBitsSet(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static String areAllBitsSet(int n){
    if(n==0)return "No" ;
    while(n>0){
      if((n & 1)==0)return "No" ;
      n=n>>1 ;
    }
    return "Yes" ;
  }
  public static void main(String[] args){
    int n=7 ;
    System.out.println(areAllBitsSet(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation areAllBitsSet( n : int) : String
  pre: true
  post: true
  activity: (     if (n = 0) then     return "No" else skip ; 
     while (n > 0) do (     if ((n & 1) = 0) then     return "No" else skip ; 
     n := (n/(2->pow(1)))->oclAsType(long) ) ; 
     return "Yes" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     OclFile["System.out"].println(areAllBitsSet(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static int sumofFactors(int n){
    if(n % 2!=0)return 0 ;
    int res=1 ;
    for(int i=2 ; i<=Math.sqrt(n); i++){
      int count=0,curr_sum=1 ;
      int curr_term=1 ;
      while(n % i==0){
        count++;
        n=n/i ;
        if(i==2 && count==1)curr_sum=0 ;
        curr_term*=i ;
        curr_sum+=curr_term ;
      }
      res*=curr_sum ;
    }
    if(n>=2)res*=(1+n);
    return res ;
  }
  public static void main(String argc[]){
    int n=18 ;
    System.out.println(sumofFactors(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation sumofFactors( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 /= 0) then     return 0 else skip ; 
     var res : int ; res := 1 ;
        var i : int ; i := 2 ; while i <= (n)->sqrt() do ( (     var count : int ; count := 0 ;
    var curr_sum : int ; curr_sum := 1 ;
     var curr_term : int ; curr_term := 1 ;
     while (n mod i = 0) do (     count := count + 1 ; 
     n := n / i ; 
    if (i = 2 & count = 1) then     curr_sum := 0 ; else skip ; 
    curr_term := curr_term*(i) ; 
    curr_sum := curr_sum+(curr_term) ; 
 ) ; 
     res := res*(curr_sum) )  ;     i := i + 1 ) ; 
    if (n >= 2) then     res := res*((1 + n)) ; else skip ; 
    return res 
 );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 18 ;
     OclFile["System.out"].println(sumofFactors(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1474 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      int n=scanner.nextInt();
      String b=scanner.next();
      char tempCharD='0' ;
      StringBuilder a=new StringBuilder();
      for(int i=0 ; i<n ; i++){
        char charChecking=b.charAt(i);
        if(charChecking=='1'){
          if(tempCharD!='2'){
            a.append('1');
            tempCharD='2' ;
          }
          else {
            a.append('0');
            tempCharD='1' ;
          }
        }
        else {
          if(tempCharD!='1'){
            a.append('1');
            tempCharD='1' ;
          }
          else {
            a.append('0');
            tempCharD='0' ;
          }
        }
      }
      System.out.println(a);
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1474 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var b : String ; b := scanner.getCurrent() ;
    var tempCharD : String ; tempCharD := '0' ;
    var a : String ; a := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     var charChecking : String ; charChecking := b->at(i+1) ;
     if (charChecking = '1') then (     if (tempCharD /= '2') then (     a := a + StringLib.newString('1') ; 
     tempCharD := '2' ) else (     a := a + StringLib.newString('0') ; 
     tempCharD := '1' ) ) else (     if (tempCharD /= '1') then (     a := a + StringLib.newString('1') ; 
     tempCharD := '1' ) else (     a := a + StringLib.newString('0') ; 
     tempCharD := '0' ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a) ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A1474 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int z=0 ; z<t ; z++){
      int n=sc.nextInt();
      String s=sc.next();
      System.out.print(1);
      ;
      int last=s.charAt(0)-'0'+1 ;
      for(int i=1 ; i<n ; i++){
        if(s.charAt(i)-'0'+1!=last){
          System.out.print(1);
          last=s.charAt(i)-'0'+1 ;
        }
        else {
          System.out.print(0);
          last=s.charAt(i)-'0' ;
        }
      }
      System.out.println();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1474 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var z : int ; z := 0 ; while z < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
    OclFile["System.out"].print(1) ; 
    var last : int ; last := s->at(0+1) - ('0')->char2byte() + 1 ;
        var i : int ; i := 1 ; while i < n do ( (     if (s->at(i+1) - ('0')->char2byte() + 1 /= last) then (     OclFile["System.out"].print(1) ; 
     last := s->at(i+1) - ('0')->char2byte() + 1 ) else (     OclFile["System.out"].print(0) ; 
     last := s->at(i+1) - ('0')->char2byte() ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     z := z + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    long input=in.nextLong();
    long round=input/11 ;
    long mod=input % 11 ;
    long result=round*2 ;
    if(0<mod){
      result++;
    }
    if(6<mod){
      result++;
    }
    out.print(result);
  }
  public static final Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
  public static final PrintStream out=System.out ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : long ; input := in.nextLong() ;
     var round : long ; round := input / 11 ;
    var mod : long ; mod := input mod 11 ;
    var result : long ; result := round * 2 ;
    if (0 < mod) then (     result := result + 1 ) else skip ; 
    if (6 < mod) then (     result := result + 1 ) else skip ; 
    out.print(result) ; 
 );
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])));
  static    attribute out : OclFile := OclFile["System.out"];
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      String num=sc.next();
      int pre=0 ;
      int select=0 ;
      for(int i=0 ; i<n ; i++){
        if((num.charAt(i)-'0'+1)!=pre){
          System.out.print(1+"");
          select=1 ;
        }
        else {
          System.out.print(0+"");
          select=0 ;
        }
        pre=num.charAt(i)-'0'+select ;
      }
      System.out.println();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var num : String ; num := sc.getCurrent() ;
    var pre : int ; pre := 0 ;
    var select : int ; select := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if ((num->at(i+1) - ('0')->char2byte() + 1) /= pre) then (     OclFile["System.out"].print(1 + "") ; 
     select := 1 ) else (     OclFile["System.out"].print(0 + "") ; 
     select := 0 ) ;  
     pre := num->at(i+1) - ('0')->char2byte() + select )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    for(int i=0 ; i<x ; i++){
      int n=sc.nextInt();
      sc.nextLine();
      String s=sc.nextLine();
      int temp=s.charAt(0)-48+1 ;
      StringBuilder res=new StringBuilder("1");
      for(int i1=1 ; i1<s.length(); i1++){
        if((s.charAt(i1)-48+1)==temp){
          res.append("0");
          temp=s.charAt(i1)-48 ;
        }
        else {
          res.append("1");
          temp=s.charAt(i1)-48+1 ;
        }
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < x do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     skip ; 
    var s : String ; s := sc.nextLine() ;
    var temp : int ; temp := s->at(0+1) - 48 + 1 ;
    var res : String ; res := StringLib.newString("1") ;
        var i1 : int ; i1 := 1 ; while i1 < s->size() do ( (     if ((s->at(i1+1) - 48 + 1) = temp) then (     res := res + StringLib.newString("0") ; 
     temp := s->at(i1+1) - 48 ) else (     res := res + StringLib.newString("1") ; 
     temp := s->at(i1+1) - 48 + 1 ) )  ;     i1 := i1 + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      int k=scanner.nextInt();
      int[] x=new int[n],y=new int[n];
      IntStream.range(0,n).forEach(i->{
        x[i]=scanner.nextInt();
        y[i]=scanner.nextInt();
      }
);
      long answer=Long.MAX_VALUE ;
      int[] sortedX=x.clone();
      int[] sortedY=y.clone();
      Arrays.sort(sortedX);
      Arrays.sort(sortedY);
      for(int xi=0 ; xi<n ; xi++){
        for(int xj=xi+1 ; xj<n ; xj++){
          for(int yi=0 ; yi<n ; yi++){
            for(int yj=yi+1 ; yj<n ; yj++){
              int count=0 ;
              for(int i=0 ; i<n ; i++){
                if((sortedX[xi]<=x[i])&&(x[i]<=sortedX[xj])&&(sortedY[yi]<=y[i])&&(y[i]<=sortedY[yj])){
                  count++;
                }
              }
              if(count>=k){
                answer=Math.min(answer,1L*(sortedX[xj]-sortedX[xi])*(sortedY[yj]-sortedY[yi]));
              }
            }
          }
        }
      }
      System.out.println(answer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var k : int ; k := scanner.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
    for i : Integer.subrange(0, n-1) do
    (    skip) ; 
    var answer : long ; answer := "9223372036854775807"->toLong() ;
    var sortedX : Sequence(int) ; sortedX := x->copy() ;
    var sortedY : Sequence(int) ; sortedY := y->copy() ;
    sortedX := sortedX->sort() ; 
    sortedY := sortedY->sort() ; 
        var xi : int ; xi := 0 ; while xi < n do ( (         var xj : int ; xj := xi + 1 ; while xj < n do ( (         var yi : int ; yi := 0 ; while yi < n do ( (         var yj : int ; yj := yi + 1 ; while yj < n do ( (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if ((sortedX[xi+1] <= x[i+1]) & (x[i+1] <= sortedX[xj+1]) & (sortedY[yi+1] <= y[i+1]) & (y[i+1] <= sortedY[yj+1])) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (count >= k) then (     answer := Set{answer, 1L * (sortedX[xj+1] - sortedX[xi+1]) * (sortedY[yj+1] - sortedY[yi+1])}->min() ) else skip )  ;     yj := yj + 1 ) )  ;     yi := yi + 1 ) )  ;     xj := xj + 1 ) )  ;     xi := xi + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    int[] l=new int[q];
    int[] r=new int[q];
    for(int i=0 ; i<q ; i++){
      l[i]=sc.nextInt();
      r[i]=sc.nextInt();
    }
    boolean[] isPrimeNum=new boolean[100001];
    for(int i=1 ; i<=100000 ; i+=2){
      isPrimeNum[i]=true ;
    }
    isPrimeNum[0]=false ;
    isPrimeNum[1]=false ;
    isPrimeNum[2]=true ;
    for(int i=3 ; i*i<=100000 ; i+=2){
      if(isPrimeNum[i]==true){
        for(int j=i*i ; j<=100000 ; j+=i*2){
          isPrimeNum[j]=false ;
        }
      }
    }
    int[] numOfLikeNumber=new int[100001];
    numOfLikeNumber[1]=0 ;
    numOfLikeNumber[2]=0 ;
    numOfLikeNumber[3]=1 ;
    for(int i=4 ; i<=100000 ; i++){
      numOfLikeNumber[i]=numOfLikeNumber[i-1];
      if(i % 4==1){
        if(isPrimeNum[i] && isPrimeNum[(i+1)/2]){
          numOfLikeNumber[i]++;
        }
      }
    }
    for(int i=0 ; i<q ; i++){
      System.out.println(numOfLikeNumber[r[i] ]-numOfLikeNumber[l[i]-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Integer.subrange(1,q)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,q)->collect(0) ;
        var i : int ; i := 0 ; while i < q do ( (     l[i+1] := sc.getCurrent()->toInteger() ; 
     r[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var isPrimeNum : Sequence(boolean) ; isPrimeNum := Integer.subrange(1,100001)->collect(false) ;
        var i : int ; i := 1 ; while i <= 100000 do ( (     isPrimeNum[i+1] := true )  ;     i := i+(2) ) ; 
    isPrimeNum[0+1] := false ; 
    isPrimeNum[1+1] := false ; 
    isPrimeNum[2+1] := true ; 
        var i : int ; i := 3 ; while i * i <= 100000 do ( (     if (isPrimeNum[i+1] = true) then (         var j : int ; j := i * i ; while j <= 100000 do ( (     isPrimeNum[j+1] := false )  ;     j := j+(i * 2) ) ) else skip )  ;     i := i+(2) ) ; 
    var numOfLikeNumber : Sequence(int) ; numOfLikeNumber := Integer.subrange(1,100001)->collect(0) ;
    numOfLikeNumber[1+1] := 0 ; 
    numOfLikeNumber[2+1] := 0 ; 
    numOfLikeNumber[3+1] := 1 ; 
        var i : int ; i := 4 ; while i <= 100000 do ( (     numOfLikeNumber[i+1] := numOfLikeNumber[i - 1+1] ; 
     if (i mod 4 = 1) then (     if (isPrimeNum[i+1] & isPrimeNum[(i + 1) / 2+1]) then (     numOfLikeNumber[i+1] := numOfLikeNumber[i+1] + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     OclFile["System.out"].println(numOfLikeNumber[r[i+1]+1] - numOfLikeNumber[l[i+1] - 1+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    System.setOut(new PrintStream(new BufferedOutputStream(System.out)));
    List<Integer>numberList=new ArrayList<>();
    for(int i=1 ; i<=100000 ; i+=2){
      if(isPrime(i)&& isPrime((i+1)/2)){
        numberList.add(i);
      }
    }
    int[] numbers=numberList.stream().mapToInt(i->i).toArray();
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int q=Integer.parseInt(reader.readLine());
    for(int i=0 ; i<q ; i++){
      String[] words=reader.readLine().split(" ");
      int l=Integer.parseInt(words[0]);
      int r=Integer.parseInt(words[1]);
      int count=count(numbers,r)-count(numbers,l-1);
      System.out.println(count);
    }
    System.out.flush();
  }
  private static int count(int[] xs,int x){
    int returnValue=Arrays.binarySearch(xs,x);
    if(returnValue>=0){
      return returnValue+1 ;
    }
    else {
      return-returnValue-1 ;
    }
  }
  private static boolean isPrime(int x){
    return BigInteger.valueOf(x).isProbablePrime(100);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ; 
     var numberList : Sequence(int) ; numberList := Sequence{} ;
        var i : int ; i := 1 ; while i <= 100000 do ( (     if (isPrime(i) & isPrime((i + 1) / 2)) then (     numberList := numberList->including(i) ) else skip )  ;     i := i+(2) ) ; 
    var numbers : Sequence(int) ; numbers := numberList->collect( _x1 | (lambda i : OclAny in i)->apply(_x1) )->asSequence() ;
    var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var q : int ; q := (reader.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var words : Sequence(String) ; words := reader.readLine()->split(" ") ;
     var l : int ; l := (words[0+1])->toInteger() ;
    var r : int ; r := (words[1+1])->toInteger() ;
    var count : int ; count := count(numbers, r) - count(numbers, l - 1) ;
    OclFile["System.out"].println(count) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].flush() ; 
 );
  static   operation count( xs : Sequence(int), x : int) : int
  pre: true
  post: true
  activity: (     var returnValue : int ; returnValue := (xs->indexOf(x) - 1) ;
     if (returnValue >= 0) then (     return returnValue + 1 ) else (     return -returnValue - 1 ) );
  static   operation isPrime( x : int) : boolean
  pre: true
  post: true
  activity: (     return (x + "")->toLong().isProbablePrime(100) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    boolean prime[]=new boolean[100000];
    prime[0]=true ;
    for(int i=1 ; i<100000 ; i++){
      if(! prime[i]){
        for(int j=1 ; j<Math.ceil(100000/(i+1)); j++){
          prime[(i+1)*(j+1)-1]=true ;
        }
      }
    }
    int count[]=new int[100000];
    for(int i=1 ; i<100000 ; i++){
      if((!(prime[i-1]))&&(!(prime[(i+1)/2-1]))){
        count[i]+=count[i-1]+1 ;
      }
      else {
        count[i]=count[i-1];
      }
    }
    Scanner scan=new Scanner(System.in);
    int q=scan.nextInt();
    int l[]=new int[q];
    int r[]=new int[q];
    for(int i=0 ; i<q ; i++){
      l[i]=scan.nextInt();
      r[i]=scan.nextInt();
    }
    for(int i=0 ; i<q ; i++){
      System.out.println(count[r[i] ]-count[l[i]-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,100000)->collect(false) ;
     prime[0+1] := true ; 
        var i : int ; i := 1 ; while i < 100000 do ( (     if (not(prime[i+1])) then (         var j : int ; j := 1 ; while j < (100000 / (i + 1))->ceil() do ( (     prime[(i + 1) * (j + 1) - 1+1] := true )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    var count : Sequence(int) ; count := Integer.subrange(1,100000)->collect(0) ;
        var i : int ; i := 1 ; while i < 100000 do ( (     if ((not((prime[i - 1+1]))) & (not((prime[(i + 1) / 2 - 1+1])))) then (     count[i+1] := count[i+1]+(count[i - 1+1] + 1) ) else (     count[i+1] := count[i - 1+1] ) )  ;     i := i + 1 ) ; 
    var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var q : int ; q := scan.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Integer.subrange(1,q)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,q)->collect(0) ;
        var i : int ; i := 0 ; while i < q do ( (     l[i+1] := scan.getCurrent()->toInteger() ; 
     r[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     OclFile["System.out"].println(count[r[i+1]+1] - count[l[i+1] - 1+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Set ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int q=Integer.parseInt(br.readLine());
    List<Integer>sosuu=sosuuList(100000);
    Set<Integer>set=new HashSet<Integer>();
    set.addAll(sosuu);
    int[] sum=new int[1000001];
    int cnt=0 ;
    for(int i=1 ; i<sum.length ; i++){
      if(i % 2==1 && set.contains(i)&& set.contains((i+1)/2)){
        cnt++;
      }
      sum[i]=cnt ;
    }
    for(int i=0 ; i<q ; i++){
      String[] sa=br.readLine().split(" ");
      int l=Integer.parseInt(sa[0]);
      int r=Integer.parseInt(sa[1]);
      System.out.println(sum[r]-sum[l-1]);
    }
    br.close();
  }
  static List<Integer>sosuuList(int n){
    List<Integer>sosuu=new ArrayList<Integer>();
    for(int i=2 ; i<=n ; i++){
      int r=(int)Math.sqrt(i);
      boolean flg=false ;
      for(Integer o : sosuu){
        if(r<o){
          break ;
        }
        if(i % o==0){
          flg=true ;
          break ;
        }
      }
      if(! flg){
        sosuu.add(i);
      }
    }
    return sosuu ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var q : int ; q := (br.readLine())->toInteger() ;
    var sosuu : Sequence(int) ; sosuu := sosuuList(100000) ;
    var set : Set(int) ; set := Set{} ;
    set := set->union(sosuu) ; 
    var sum : Sequence(int) ; sum := Integer.subrange(1,1000001)->collect(0) ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 1 ; while i < sum->size() do ( (     if (i mod 2 = 1 & set->includes(i) & set->includes((i + 1) / 2)) then (     cnt := cnt + 1 ) else skip ; 
     sum[i+1] := cnt )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
     var l : int ; l := (sa[0+1])->toInteger() ;
     var r : int ; r := (sa[1+1])->toInteger() ;
     OclFile["System.out"].println(sum[r+1] - sum[l - 1+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation sosuuList( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var sosuu : Sequence(int) ; sosuu := Sequence{} ;
         var i : int ; i := 2 ; while i <= n do ( (     var r : int ; r := (i)->sqrt()->oclAsType(int) ;
     var flg : boolean ; flg := false ;
     for (o : sosuu) do ( (     if (r < o) then (     break ) else skip ; 
     if (i mod o = 0) then (     flg := true ; 
     break ) else skip )  ) ; 
     if (not(flg)) then (     sosuu := sosuu->including(i) ) else skip )  ;     i := i + 1 ) ; 
     return sosuu );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    boolean[] np=new boolean[100001];
    np[0]=true ;
    np[1]=true ;
    int[] pc=new int[100001];
    int c=0 ;
    for(int i=2 ; i<=100000 ; i++){
      if(! np[i]){
        ;
        if(! np[(i+1)/2])c++;
        for(int j=2 ; i*j<=100000 ; j++){
          np[i*j]=true ;
        }
      }
      pc[i]=c ;
    }
    int q=Integer.parseInt(sc.next());
    for(int i=0 ; i<q ; i++){
      out.println(-pc[Integer.parseInt(sc.next())-1]+pc[Integer.parseInt(sc.next())]);
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var np : Sequence(boolean) ; np := Integer.subrange(1,100001)->collect(false) ;
    np[0+1] := true ; 
    np[1+1] := true ; 
    var pc : Sequence(int) ; pc := Integer.subrange(1,100001)->collect(0) ;
    var c : int ; c := 0 ;
        var i : int ; i := 2 ; while i <= 100000 do ( (     if (not(np[i+1])) then (  
     if (not(np[(i + 1) / 2+1])) then     c := c + 1 ; else skip ; 
         var j : int ; j := 2 ; while i * j <= 100000 do ( (     np[i * j+1] := true )  ;     j := j + 1 ) ) else skip ; 
     pc[i+1] := c )  ;     i := i + 1 ) ; 
    var q : int ; q := (sc.getCurrent())->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int optimalStrategyOfGame(int arr[],int n){
    int table[][]=new int[n][n];
    int gap,i,j,x,y,z ;
    for(gap=0 ; gap<n ; ++gap){
      for(i=0,j=gap ; j<n ; ++i,++j){
        x=((i+2)<=j)? table[i+2][j] : 0 ;
        y=((i+1)<=(j-1))? table[i+1][j-1] : 0 ;
        z=(i<=(j-2))? table[i][j-2] : 0 ;
        table[i][j]=Math.max(arr[i]+Math.min(x,y),arr[j]+Math.min(y,z));
      }
    }
    return table[0][n-1];
  }
  public static void main(String[] args){
    int arr1[]={
      8,15,3,7 };
      int n=arr1.length ;
      System.out.println(""+optimalStrategyOfGame(arr1,n));
      int arr2[]={
        2,2,2,2 };
        n=arr2.length ;
        System.out.println(""+optimalStrategyOfGame(arr2,n));
        int arr3[]={
          20,30,2,2,2,10 };
          n=arr3.length ;
          System.out.println(""+optimalStrategyOfGame(arr3,n));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation optimalStrategyOfGame( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var table : Sequence(Sequence(int)) ; table := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
     var gap : int ;
    var i : int ;
    var j : int ;
    var x : int ;
    var y : int ;
    var z : int ;
         gap := 0 ; while gap < n do ( (         i := 0 ;     j := gap ; while j < n do ( (     x := if ((i + 2) <= j) then table[i + 2+1][j+1] else 0 endif ; 
     y := if ((i + 1) <= (j - 1)) then table[i + 1+1][j - 1+1] else 0 endif ; 
     z := if (i <= (j - 2)) then table[i+1][j - 2+1] else 0 endif ; 
     table[i+1][j+1] := Set{arr[i+1] + Set{x, y}->min(), arr[j+1] + Set{y, z}->min()}->max() )  ;     i := i + 1 ;     j := j + 1 ) )  ;     gap := gap + 1 ) ; 
     return table[0+1][n - 1+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{8,15,3,7} ;
     var n : int ; n := arr1->size() ;
    OclFile["System.out"].println("" + optimalStrategyOfGame(arr1, n)) ; 
    var arr2 : Sequence(int) ; arr2 := Sequence{2,2,2,2} ;
    n := arr2->size() ; 
    OclFile["System.out"].println("" + optimalStrategyOfGame(arr2, n)) ; 
    var arr3 : Sequence(int) ; arr3 := Sequence{20,30,2,2,2,10} ;
    n := arr3->size() ; 
    OclFile["System.out"].println("" + optimalStrategyOfGame(arr3, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Fibonacci {
  static int fibonacci(int n){
    int a=0 ;
    int b=1 ;
    int c=0 ;
    if(n<=1)return n ;
    for(int i=2 ; i<=n ; i++){
      c=a+b ;
      a=b ;
      b=c ;
    }
    return c ;
  }
  static boolean isMultipleOf10(int n){
    int f=fibonacci(30);
    return(f % 10==0);
  }
  public static void main(String[] args){
    int n=30 ;
    if(isMultipleOf10(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class Fibonacci {
  static   operation fibonacci( n : int) : int
  pre: true
  post: true
  activity: (     var a : int ; a := 0 ;
     var b : int ; b := 1 ;
    var c : int ; c := 0 ;
    if (n <= 1) then     return n else skip ; 
        var i : int ; i := 2 ; while i <= n do ( (     c := a + b ; 
     a := b ; 
     b := c )  ;     i := i + 1 ) ; 
    return c 
 );
  static   operation isMultipleOf10( n : int) : boolean
  pre: true
  post: true
  activity: (     var f : int ; f := fibonacci(30) ;
     return (f mod 10 = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 30 ;
     if (isMultipleOf10(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.regex.Pattern ;
import java.util.regex.Matcher ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    String postnumber=sc.next();
    Pattern pattern=Pattern.compile("^[0-9] {"+x+"}-[0-9] {"+y+"}$");
    Matcher matcher=pattern.matcher(postnumber);
    if(matcher.find()){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var postnumber : String ; postnumber := sc.getCurrent() ;
    var pattern : OclRegex ; pattern := OclRegex.compile("^[0-9] {" + x + "}-[0-9] {" + y + "}$") ;
    var matcher : OclRegex ; matcher := pattern.matcher(postnumber) ;
    if (matcher.nextMatch()) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Scanner ;
class Main {
  public static void main(String args[])throws IOException {
    @ SuppressWarnings("resource")Scanner cin=new Scanner(System.in);
    ArrayList<String>inLines=new ArrayList<String>();
    for(; cin.hasNext(); ){
      inLines.add(cin.nextLine());
    }
    Solver solver=new Solver();
    solver.solve(inLines);
  }
}
class Solver {
  public void solve(ArrayList<String>inLines){
    long x=Long.parseLong(inLines.get(0));
    long ans=(x/11)*2 ;
    if(x % 11!=0){
      if(x % 11<=6)ans+=1 ;
      else ans+=2 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inLines : Sequence(String) ; inLines := Sequence{} ;
      while cin.hasNext() do ( (     inLines := inLines->including(cin.nextLine()) )  ) ; 
    var solver : Solver ; solver := Solver.newSolver() ;
    solver.solve(inLines) ; 
 );
}
class Solver {
   operation solve( inLines : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : long ; x := (inLines->at(0+1))->toLong() ;
     var ans : long ; ans := (x / 11) * 2 ;
     if (x mod 11 /= 0) then (     if (x mod 11 <= 6) then     ans := ans+(1) ; else     ans := ans+(2) ; ) else skip ; 
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    String s=sc.next();
    sc.close();
    for(int i=0 ; i<s.length(); i++){
      if((i<a || i>a)&&(s.charAt(i)<'0' || s.charAt(i)>'9')){
        System.out.print("No");
        return ;
      }
      if(i==a && s.charAt(i)!='-'){
        System.out.print("No");
        return ;
      }
    }
    System.out.print("Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    skip ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     if ((i < a or i > a) & (s->at(i+1) < '0' or s->at(i+1) > '9')) then (     OclFile["System.out"].print("No") ; 
     return ) else skip ; 
     if (i = a & s->at(i+1) /= '-') then (     OclFile["System.out"].print("No") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("Yes") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int sumDivisibles(int A,int B,int M){
    int sum=0 ;
    for(int i=A ; i<=B ; i++)if(i % M==0)sum+=i ;
    return sum ;
  }
  public static void main(String[] args){
    int A=6,B=15,M=3 ;
    System.out.print(sumDivisibles(A,B,M)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumDivisibles( A : int, B : int, M : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := A ; while i <= B do (     if (i mod M = 0) then     sum := sum+(i) ; else skip ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 6 ;
    var B : int ; B := 15 ;
    var M : int ; M := 3 ;
     OclFile["System.out"].print(sumDivisibles(A, B, M) + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=1000 ;
  static char[] replaceSpaces(char[] str){
    int space_count=0,i=0 ;
    for(i=0 ; i<str.length ; i++)if(str[i]==' ')space_count++;
    while(str[i-1]==' '){
      space_count--;
      i--;
    }
    int new_length=i+space_count*2 ;
    if(new_length>MAX)return str ;
    int index=new_length-1 ;
    char[] new_str=str ;
    str=new char[new_length];
    for(int j=i-1 ; j>=0 ; j--){
      if(new_str[j]==' '){
        str[index]='0' ;
        str[index-1]='2' ;
        str[index-2]='%' ;
        index=index-3 ;
      }
      else {
        str[index]=new_str[j];
        index--;
      }
    }
    return str ;
  }
  public static void main(String[] args){
    char[] str="Mr John Smith ".toCharArray();
    str=replaceSpaces(str);
    for(int i=0 ; i<str.length ; i++)System.out.print(str[i]);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 1000;
  static   operation replaceSpaces( str : Sequence(String)) : Sequence(String)
  pre: true
  post: true
  activity: (     var space_count : int ; space_count := 0 ;
    var i : int ; i := 0 ;
         i := 0 ; while i < str->size() do (     if (str[i+1] = ' ') then     space_count := space_count + 1 ; else skip ;  ;     i := i + 1 ) ; 
    while (str[i - 1+1] = ' ') do (     space_count := space_count - 1 ; 
     i := i - 1 ) ; 
    var new_length : int ; new_length := i + space_count * 2 ;
    if (new_length > MAX) then     return str else skip ; 
    var index : int ; index := new_length - 1 ;
    var new_str : Sequence(String) ; new_str := str ;
    str := Integer.subrange(1,new_length)->collect(0) ; 
        var j : int ; j := i - 1 ; while j >= 0 do ( (     if (new_str[j+1] = ' ') then (     str[index+1] := '0' ; 
     str[index - 1+1] := '2' ; 
     str[index - 2+1] := '%' ; 
     index := index - 3 ) else (     str[index+1] := new_str[j+1] ; 
     index := index - 1 ) )  ;     j := j - 1 ) ; 
    return str 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := "Mr John Smith "->characters() ;
     str := replaceSpaces(str) ; 
         var i : int ; i := 0 ; while i < str->size() do (     OclFile["System.out"].print(str[i+1]) ;  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    System.out.println(getData(in.nextInt(),in.nextInt(),in.next()));
  }
  public static String getData(int a,int b,String s){
    for(int i=0 ; i<s.length(); i++){
      if(i<a){
        if(s.charAt(i)<48 || s.charAt(i)>57)return "No" ;
      }
      else if(i==a){
        if(s.charAt(i)!='-')return "No" ;
      }
      else {
        if(s.charAt(i)<48 || s.charAt(i)>57)return "No" ;
      }
    }
    return "Yes" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println(getData(in.getCurrent()->toInteger(), in.getCurrent()->toInteger(), in.getCurrent())) );
  static   operation getData( a : int, b : int, s : String) : String
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() do ( (     if (i < a) then (     if (s->at(i+1) < 48 or s->at(i+1) > 57) then     return "No" else skip ) else     if (i = a) then (     if (s->at(i+1) /= '-') then     return "No" else skip ) else (     if (s->at(i+1) < 48 or s->at(i+1) > 57) then     return "No" else skip ) ;  )  ;     i := i + 1 ) ; 
     return "Yes" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int flag=0 ;
    String s=sc.next();
    for(int i=0 ; i<a ; i++){
      if(s.substring(i,i+1).equals("-")){
        flag=1 ;
      }
    }
    if(! s.substring(a,a+1).equals("-")){
      flag=1 ;
    }
    for(int i=a+1 ; i<a+b+1 ; i++){
      if(s.substring(i,i+1).equals("-")){
        flag=1 ;
      }
    }
    if(flag==1){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
    }
  }
  public static int res(int n){
    if(n==1){
      return 1 ;
    }
    return n+res(n-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var flag : int ; flag := 0 ;
    var s : String ; s := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < a do ( (     if (s.subrange(i+1,i + 1) = "-") then (     flag := 1 ) else skip )  ;     i := i + 1 ) ; 
    if (not(s.subrange(a+1,a + 1) = "-")) then (     flag := 1 ) else skip ; 
        var i : int ; i := a + 1 ; while i < a + b + 1 do ( (     if (s.subrange(i+1,i + 1) = "-") then (     flag := 1 ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 1) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) ;  
 );
  static   operation res( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then (     return 1 ) else skip ; 
     return n + res(n - 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    String S=sc.next();
    String AS=S.substring(0,A);
    String haihun=S.substring(A,A+1);
    String BS=S.substring(A+1,A+B+1);
    if(! isNumber(AS)|| ! isNumber(BS)){
      System.out.println("No");
      return ;
    }
    if(! haihun.equals("-")){
      System.out.println("No");
      return ;
    }
    System.out.println("Yes");
  }
  public static boolean isNumber(String num){
    try {
      Integer.parseInt(num);
      return true ;
    }
    catch(NumberFormatException e){
      return false ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var S : String ; S := sc.getCurrent() ;
    var AS : String ; AS := S.subrange(0+1,A) ;
    var haihun : String ; haihun := S.subrange(A+1,A + 1) ;
    var BS : String ; BS := S.subrange(A + 1+1,A + B + 1) ;
    if (not(isNumber(AS)) or not(isNumber(BS))) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
    if (not(haihun = "-")) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
    OclFile["System.out"].println("Yes") ; 
 );
  static   operation isNumber( num : String) : boolean
  pre: true
  post: true
  activity: (     try (     Integer.parseInt(num) ; 
     return true )   catch (e : IncorrectElementException) do (     return false )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static boolean checkfact(int N,int countprime,int prime){
    int countfact=0 ;
    if(prime==2 || prime==3)countfact++;
    int divide=prime ;
    while(N/divide!=0){
      countfact+=N/divide ;
      divide=divide*divide ;
    }
    if(countfact>=countprime)return true ;
    else return false ;
  }
  static boolean check(int N){
    int sumsquares=(N+1)*(2*N+1);
    int countprime=0 ;
    for(int i=2 ; i<=Math.sqrt(sumsquares); i++){
      int flag=0 ;
      while(sumsquares % i==0){
        flag=1 ;
        countprime++;
        sumsquares/=i ;
      }
      if(flag==1){
        if(! checkfact(N-1,countprime,i))return false ;
        countprime=0 ;
      }
    }
    if(sumsquares!=1)if(! checkfact(N-1,1,sumsquares))return false ;
    return true ;
  }
  public static void main(String[] args){
    int N=5 ;
    if(check(N))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation checkfact( N : int, countprime : int, prime : int) : boolean
  pre: true
  post: true
  activity: (     var countfact : int ; countfact := 0 ;
     if (prime = 2 or prime = 3) then     countfact := countfact + 1 ; else skip ; 
    var divide : int ; divide := prime ;
    while (N / divide /= 0) do (     countfact := countfact+(N / divide) ; 
     divide := divide * divide ) ; 
    if (countfact >= countprime) then     return true else     return false ;  
 );
  static   operation check( N : int) : boolean
  pre: true
  post: true
  activity: (     var sumsquares : int ; sumsquares := (N + 1) * (2 * N + 1) ;
     var countprime : int ; countprime := 0 ;
        var i : int ; i := 2 ; while i <= (sumsquares)->sqrt() do ( (     var flag : int ; flag := 0 ;
     while (sumsquares mod i = 0) do (     flag := 1 ; 
     countprime := countprime + 1 ; 
     sumsquares := sumsquares/(i) ) ; 
     if (flag = 1) then (     if (not(checkfact(N - 1, countprime, i))) then     return false else skip ; 
     countprime := 0 ) else skip )  ;     i := i + 1 ) ; 
    if (sumsquares /= 1) then     if (not(checkfact(N - 1, 1, sumsquares))) then     return false else skip ; else skip ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     if (check(N)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int GCD(int a,int b){
    return b==0 ? a : GCD(b,a % b);
  }
  static boolean isSplittable(int n,int m){
    int total_sum=(n*(n+1))/2 ;
    int sum_s1=(total_sum+m)/2 ;
    int sum_s2=total_sum-sum_s1 ;
    if(total_sum<m)return false ;
    if(sum_s1+sum_s2==total_sum && sum_s1-sum_s2==m)return(GCD(sum_s1,sum_s2)==1);
    return false ;
  }
  public static void main(String args[]){
    int n=5,m=7 ;
    if(isSplittable(n,m))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation GCD( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else GCD(b, a mod b) endif );
  static   operation isSplittable( n : int, m : int) : boolean
  pre: true
  post: true
  activity: (     var total_sum : int ; total_sum := (n * (n + 1)) / 2 ;
     var sum_s1 : int ; sum_s1 := (total_sum + m) / 2 ;
    var sum_s2 : int ; sum_s2 := total_sum - sum_s1 ;
    if (total_sum < m) then     return false else skip ; 
    if (sum_s1 + sum_s2 = total_sum & sum_s1 - sum_s2 = m) then     return (GCD(sum_s1, sum_s2) = 1) else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var m : int ; m := 7 ;
     if (isSplittable(n, m)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void manipulateString(String str){
    char[] str1=str.toCharArray();
    for(int i=0 ; i<str.length(); i++){
      int asc=str1[i];
      int rem=asc-(26-(str1[i]-97));
      int m=rem % 26 ;
      str1[i]=(char)(m+'a');
    }
    String str2=String.valueOf(str1);
    System.out.println(str2);
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    manipulateString(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation manipulateString( str : String) : void
  pre: true
  post: true
  activity: (     var str1 : Sequence(String) ; str1 := str->characters() ;
         var i : int ; i := 0 ; while i < str->size() do ( (     var asc : int ; asc := str1[i+1] ;
     var rem : int ; rem := asc - (26 - (str1[i+1] - 97)) ;
     var m : int ; m := rem mod 26 ;
     str1[i+1] := (m + 'a')->oclAsType(String) )  ;     i := i + 1 ) ; 
     var str2 : String ; str2 := (str1)->sum()  ;
     OclFile["System.out"].println(str2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     execute manipulateString(str) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Despression {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int hr,min ;
    hr=Integer.parseInt(s.substring(0,2));
    min=Integer.parseInt(s.substring(3,5));
    if(hr>=12){
      hr=hr-12 ;
    }
    double ans1=30*hr+0.5*min ;
    int ans2=6*min ;
    int n=(int)ans1 ;
    if(ans1-n==0){
      System.out.println(n+" "+ans2);
    }
    else System.out.println(ans1+" "+ans2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Despression {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var hr : int ;
    var min : int ;
    hr := (s.subrange(0+1,2))->toInteger() ; 
    min := (s.subrange(3+1,5))->toInteger() ; 
    if (hr >= 12) then (     hr := (hr)->char2byte() - 12 ) else skip ; 
    var ans1 : double ; ans1 := 30 * hr + 0.5 * min ;
    var ans2 : int ; ans2 := 6 * min ;
    var n : int ; n := ans1->oclAsType(int) ;
    if (ans1 - n = 0) then (     OclFile["System.out"].println(n + " " + ans2) ) else     OclFile["System.out"].println(ans1 + " " + ans2) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Despression {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int hr,min ;
    hr=Integer.parseInt(s.substring(0,2));
    min=Integer.parseInt(s.substring(3,5));
    if(hr>=12){
      hr=hr-12 ;
    }
    double ans1=30*hr+0.5*min ;
    int ans2=6*min ;
    int n=(int)ans1 ;
    if(ans1-n==0){
      System.out.println(n+" "+ans2);
    }
    else System.out.println(ans1+" "+ans2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Despression {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var hr : int ;
    var min : int ;
    hr := (s.subrange(0+1,2))->toInteger() ; 
    min := (s.subrange(3+1,5))->toInteger() ; 
    if (hr >= 12) then (     hr := (hr)->char2byte() - 12 ) else skip ; 
    var ans1 : double ; ans1 := 30 * hr + 0.5 * min ;
    var ans2 : int ; ans2 := 6 * min ;
    var n : int ; n := ans1->oclAsType(int) ;
    if (ans1 - n = 0) then (     OclFile["System.out"].println(n + " " + ans2) ) else     OclFile["System.out"].println(ans1 + " " + ans2) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CF80B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String[] s=in.next().split(":");
    int h=Integer.parseInt(s[0]);
    int m=Integer.parseInt(s[1]);
    int nm=(6*m)% 360 ;
    double nh=(30*h)% 360 ;
    nh+=m/2.0 ;
    System.out.println(nh+" "+nm);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF80B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := in.getCurrent()->split(":") ;
    var h : int ; h := (s[0+1])->toInteger() ;
    var m : int ; m := (s[1+1])->toInteger() ;
    var nm : int ; nm := (6 * m) mod 360 ;
    var nh : double ; nh := (30 * h) mod 360 ;
    nh := nh+(m / 2.0) ; 
    OclFile["System.out"].println(nh + " " + nm) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int calgcd(int a,int b){
    if(b==0)return a ;
    return calgcd(b,a % b);
  }
  static int getCount(int[] a,int n){
    int gcd=0 ;
    for(int i=0 ; i<n ; i++)gcd=calgcd(gcd,a[i]);
    int cnt=0 ;
    for(int i=1 ; i*i<=gcd ; i++){
      if(gcd % i==0){
        if(i*i==gcd)cnt++;
        else cnt+=2 ;
      }
    }
    return cnt ;
  }
  public static void main(String[] args){
    int[] a={
      4,16,1024,48 };
      int n=a.length ;
      System.out.println(getCount(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation calgcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return calgcd(b, a mod b) );
  static   operation getCount( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var gcd : int ; gcd := 0 ;
         var i : int ; i := 0 ; while i < n do (     gcd := calgcd(gcd, a[i+1]) ;  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 1 ; while i * i <= gcd do ( (     if (gcd mod i = 0) then (     if (i * i = gcd) then     cnt := cnt + 1 ; else     cnt := cnt+(2) ; ) else skip )  ;     i := i + 1 ) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{4,16,1024,48} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(getCount(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new B().doIt();
  }
  class B {
    void doIt(){
      int n=sc.nextInt();
      String str=sc.next();
      char ctr[]=str.toCharArray();
      int m=sc.nextInt();
      int num=n ;
      StringBuilder sb=new StringBuilder();
      for(int i=0 ; i<n ; i++){
        if(m==0){
          sb.append(ctr[i]);
        }
        else if(m<num){
          if(ctr[i]=='0'){
            sb.append(1);
            m--;
          }
          else {
            sb.append(1);
          }
        }
        else {
          if(ctr[i]=='0')sb.append(1);
          else sb.append(0);
        }
        num--;
      }
      System.out.println(sb);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     B.newB().doIt() );
 class B {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var str : String ; str := sc.getCurrent() ;
    var ctr : Sequence(String) ; ctr := str->characters() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var num : int ; num := n ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     if (m = 0) then (     sb := sb + StringLib.newString(ctr[i+1]) ) else     if (m < num) then (     if (ctr[i+1] = '0') then (     sb := sb + StringLib.newString(1) ; 
     m := m - 1 ) else (     sb := sb + StringLib.newString(1) ) ) else (     if (ctr[i+1] = '0') then     sb := sb + StringLib.newString(1) ; else     sb := sb + StringLib.newString(0) ; ) ;  ;  
     num := num - 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CF80B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String[] s=in.next().split(":");
    int h=Integer.parseInt(s[0]);
    int m=Integer.parseInt(s[1]);
    int nm=(m*6)% 360 ;
    double nh=(h*30)% 360 ;
    nh+=m/2.0 ;
    System.out.println(nh+" "+nm);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF80B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := in.getCurrent()->split(":") ;
    var h : int ; h := (s[0+1])->toInteger() ;
    var m : int ; m := (s[1+1])->toInteger() ;
    var nm : int ; nm := (m * 6) mod 360 ;
    var nh : double ; nh := (h * 30) mod 360 ;
    nh := nh+(m / 2.0) ; 
    OclFile["System.out"].println(nh + " " + nm) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.awt.geom.Point2D ;
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    while(sc.hasNext()){
      new aoj0057().doIt();
    }
  }
  class aoj0057 {
    int a[]=new int[10001];
    void DP(){
      a[0]=1 ;
      for(int i=1 ; i<=10000 ; i++)a[i]=a[i-1]+i ;
    }
    void doIt(){
      DP();
      int n=sc.nextInt();
      System.out.println(a[n]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     while (sc.hasNext()) do (     aoj0057.newaoj0057().doIt() ) );
 class aoj0057 {
   attribute a : int := Integer.subrange(1,10001)->collect(0);
   operation DP() : void
  pre: true
  post: true
  activity: (     a[0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= 10000 do (     a[i+1] := a[i - 1+1] + i ;  ;     i := i + 1 ) );
   operation doIt() : void
  pre: true
  post: true
  activity: (     execute DP() ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(a[n+1]) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  static boolean[] notPrime=new boolean[51000];
  static int[] primes=new int[50000];
  static int primeNum=0 ;
  static void setP(){
    notPrime[0]=true ;
    notPrime[1]=true ;
    int count=0 ;
    for(int i=2 ; i<51000 ; i++){
      if(! notPrime[i]){
        primes[count]=i ;
        count++;
      }
      for(int j=2 ; j*i<5100 ; j++){
        notPrime[i*j]=true ;
      }
    }
    primeNum=count ;
  }
  static boolean isPrime(int n){
    return ! notPrime[n];
  }
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String line ;
      setP();
      while((line=br.readLine())!=null){
        if(line.isEmpty())break ;
        String[] spl=line.split(" ");
        int a=Integer.parseInt(spl[0]);
        if(a==0)break ;
        int cnt=2 ;
        for(int i=2 ; i<=a ; i++){
          cnt+=1 ;
          cnt+=i-1 ;
        }
        System.out.println(cnt);
      }
      br.close();
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute notPrime : Sequence(boolean) := Integer.subrange(1,51000)->collect(false);
  static   attribute primes : Sequence(int) := Integer.subrange(1,50000)->collect(0);
  static   attribute primeNum : int := 0;
  static   operation setP() : void
  pre: true
  post: true
  activity: (     notPrime[0+1] := true ; 
     notPrime[1+1] := true ; 
    var count : int ; count := 0 ;
        var i : int ; i := 2 ; while i < 51000 do ( (     if (not(notPrime[i+1])) then (     primes[count+1] := i ; 
     count := count + 1 ) else skip ; 
         var j : int ; j := 2 ; while j * i < 5100 do ( (     notPrime[i * j+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    primeNum := count ; 
 );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     return not(notPrime[n+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var line : String ;
     execute setP() ; 
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->isEmpty()) then     break else skip ; 
     var spl : Sequence(String) ; spl := line->split(" ") ;
    var a : int ; a := (spl[0+1])->toInteger() ;
    if (a = 0) then     break else skip ; 
    var cnt : int ; cnt := 2 ;
        var i : int ; i := 2 ; while i <= a do ( (     cnt := cnt+(1) ; 
     cnt := cnt+(i - 1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 ) ;     line := br.readLine() ;
 ) ;  
     skip )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String str=br.readLine();
      if(str==null){
        break ;
      }
      int n=Integer.parseInt(str);
      System.out.println(AreaDivider.maximumAreaNum(n));
    }
  }
}
class AreaDivider {
  static long maximumAreaNum(int n){
    long result=2 ;
    for(int i=2 ; i<=n ; i++){
      result+=i ;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var str : String ; str := br.readLine() ;
     if (str = null) then (     break ) else skip ; 
     var n : int ; n := (str)->toInteger() ;
     OclFile["System.out"].println(AreaDivider.maximumAreaNum(n)) ) );
}
class AreaDivider {
  static   operation maximumAreaNum( n : int) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 2 ;
         var i : int ; i := 2 ; while i <= n do ( (     result := result+(i) )  ;     i := i + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public void doIt(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int sum=1 ;
      for(int i=1 ; i<=n ; i++){
        sum+=i ;
      }
      System.out.println(sum);
    }
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var sum : int ; sum := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (     sum := sum+(i) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sum) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static int answer[];
  static void makeTable(){
    answer=new int[10001];
    answer[0]=1 ;
    for(int i=1 ; i<10001 ; i++){
      answer[i]=answer[i-1]+i ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    makeTable();
    while(sc.hasNext()){
      System.out.println(answer[sc.nextInt()]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute answer : Sequence(int);
  static   operation makeTable() : void
  pre: true
  post: true
  activity: (     answer := Integer.subrange(1,10001)->collect(0) ; 
     answer[0+1] := 1 ; 
         var i : int ; i := 1 ; while i < 10001 do ( (     answer[i+1] := answer[i - 1+1] + i )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute makeTable() ; 
     while (sc.hasNext()) do (     OclFile["System.out"].println(answer[sc.getCurrent()->toInteger()+1]) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int[] sortArrayByParity(int[] A){
    int lo=0,hi=A.length-1 ;
    while(lo<hi){
      if(A[lo] % 2>A[hi] % 2){
        int tmp=A[hi];
        A[hi]=A[lo];
        A[lo]=tmp ;
      }
      if(A[lo] % 2==0)lo++;
      if(A[hi] % 2==1)hi--;
    }
    return A ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation sortArrayByParity( A : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var lo : int ; lo := 0 ;
    var hi : int ; hi := A->size() - 1 ;
     while (lo < hi) do (     if (A[lo+1] mod 2 > A[hi+1] mod 2) then (     var tmp : int ; tmp := A[hi+1] ;
     A[hi+1] := A[lo+1] ; 
     A[lo+1] := tmp ) else skip ; 
     if (A[lo+1] mod 2 = 0) then     lo := lo + 1 ; else skip ; 
     if (A[hi+1] mod 2 = 1) then     hi := hi - 1 ; else skip ) ; 
     return A );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class pre1 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int n=obj.nextInt(),a[]=new int[n],b[]=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=obj.nextInt();
    for(int i=0 ; i<n ; i++)b[i]=obj.nextInt();
    Map<Integer,Integer>mp=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      mp.put(a[i],i);
    }
    TreeSet<Integer>set=new TreeSet<>();
    int ptr=0 ;
    for(int i=0 ; i<n ; i++){
      if(set.contains(b[i]))System.out.print("0 ");
      else {
        int idx=mp.get(b[i]),count=0 ;
        while(ptr<=idx){
          set.add(a[i]);
          ptr++;
          count++;
        }
        System.out.print(count+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre1 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var n : int ; n := obj.nextInt() ;
    var a : Sequence(void) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(void) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := obj.nextInt() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     b[i+1] := obj.nextInt() ;  ;     i := i + 1 ) ; 
    var mp : Map(int,int) ; mp := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     mp := mp->union(Map{a[i+1] |-> i}) )  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
    var ptr : int ; ptr := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (set->includes(b[i+1])) then     OclFile["System.out"].print("0 ") ; else (     var idx : int ; idx := mp->at(b[i+1]) ;
    var count : int ; count := 0 ;
     while (ptr <= idx) do (     set := set->including(a[i+1]) ; 
     ptr := ptr + 1 ; 
     count := count + 1 ) ; 
     OclFile["System.out"].print(count + " ") ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    boolean v[]=new boolean[n+1];
    Arrays.fill(v,true);
    ArrayDeque<Integer>dq=new ArrayDeque<>();
    for(int i=0 ; i<n ; i++){
      dq.addLast(in.nextInt());
    }
    for(int i=0 ; i<n ; i++){
      int count=0 ;
      int x=in.nextInt();
      if(v[x]){
        while(true){
          int val=dq.pollFirst();
          v[val]=false ;
          count++;
          if(x==val){
            break ;
          }
        }
      }
      pw.print(count+" ");
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var v : Sequence(boolean) ; v := Integer.subrange(1,n + 1)->collect(false) ;
    v := v->collect(true) ; 
    var dq : Sequence(int) ; dq := ArrayDeque<OclAny>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < n do ( (     dq := dq->append(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var count : int ; count := 0 ;
     var x : int ; x := in.getCurrent()->toInteger() ;
     if (v[x+1]) then (     while (true) do (     var val : int ; val := dq->first() ;
     v[val+1] := false ; 
     count := count + 1 ; 
     if (x = val) then (     break ) else skip ) ) else skip ; 
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isWordPresent(String sentence,String word){
    word=transform(word);
    sentence=transform(sentence);
    String[] s=sentence.split(" ");
    for(String temp : s){
      if(temp.compareTo(word)==0){
        return true ;
      }
    }
    return false ;
  }
  static String transform(String word){
    return word.toUpperCase();
  }
  public static void main(String[] args){
    String s="Geeks for Geeks" ;
    String word="geeks" ;
    if(isWordPresent(s,word))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isWordPresent( sentence : String, word : String) : boolean
  pre: true
  post: true
  activity: (     word := transform(word) ; 
     sentence := transform(sentence) ; 
    var s : Sequence(String) ; s := sentence->split(" ") ;
    for (temp : s) do ( (     if (temp->compareTo(word) = 0) then (     return true ) else skip )  ) ; 
    return false 
 );
  static   operation transform( word : String) : String
  pre: true
  post: true
  activity: (     return word->toUpperCase() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "Geeks for Geeks" ;
     var word : String ; word := "geeks" ;
     if (isWordPresent(s, word)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    char[] X=sc.next().toCharArray();
    char[] next=new char[N];
    int D=sc.nextInt();
    for(int i=0 ; i<N ; i++){
      if(D!=0 && X[i]=='0'){
        next[i]='1' ;
        D--;
      }
      else {
        next[i]=X[i];
      }
    }
    for(int i=N-1 ; i>=0 ; i--){
      if(D!=0 && X[i]=='1'){
        next[i]='0' ;
        D--;
      }
    }
    System.out.println(String.valueOf(next));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var X : Sequence(String) ; X := sc.getCurrent()->characters() ;
    var next : Sequence(String) ; next := Integer.subrange(1,N)->collect(0) ;
    var D : int ; D := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < N do ( (     if (D /= 0 & X[i+1] = '0') then (     next[i+1] := '1' ; 
     D := D - 1 ) else (     next[i+1] := X[i+1] ) )  ;     i := i + 1 ) ; 
        var i : int ; i := N - 1 ; while i >= 0 do ( (     if (D /= 0 & X[i+1] = '1') then (     next[i+1] := '0' ; 
     D := D - 1 ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println((next)->sum() ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void print(ArrayList<Integer>a,int n){
    for(int i=0 ; i<=n ; i++)System.out.print(a.get(i)+" ");
    System.out.println();
  }
  static void sort(ArrayList<Integer>a,int n){
    for(int i=n ; i>=0 ; i--)for(int j=n ; j>n-i ; j--)if(a.get(j)>a.get(j-1)){
      int tempswap=a.get(j);
      a.remove(j);
      a.add(j,a.get(j-1));
      a.remove(j-1);
      a.add(j-1,tempswap);
    }
    print(a,n);
  }
  public static void main(String[] args){
    int n=6 ;
    ArrayList<Integer>a=new ArrayList<Integer>();
    a.add(2);
    a.add(4);
    a.add(3);
    a.add(2);
    a.add(4);
    a.add(5);
    a.add(3);
    sort(a,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation print( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= n do (     OclFile["System.out"].print(a->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation sort( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := n ; while i >= 0 do (         var j : int ; j := n ; while j > n - i do (     if (a->at(j+1) > a->at(j - 1+1)) then (     var tempswap : int ; tempswap := a->at(j+1) ;
     a := a->excludingAt(j+1) ; 
    a->excludes(j, a->at(j - 1+1)) ; 
    a := a->excludingFirst(j - 1) ; 
    a->excludes(j - 1, tempswap) ; 
 ) else skip ;  ;     j := j - 1 ) ;  ;     i := i - 1 ) ; 
     execute print(a, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     var a : Sequence(int) ; a := Sequence{} ;
    a := a->including(2) ; 
    a := a->including(4) ; 
    a := a->including(3) ; 
    a := a->including(2) ; 
    a := a->including(4) ; 
    a := a->including(5) ; 
    a := a->including(3) ; 
    execute sort(a, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int getLeftmostBit(int n){
    int m=0 ;
    while(n>1){
      n=n>>1 ;
      m++;
    }
    return m ;
  }
  static int getNextLeftmostBit(int n,int m){
    int temp=1<<m ;
    while(n<temp){
      temp=temp>>1 ;
      m--;
    }
    return m ;
  }
  static int countSetBits(int n){
    int m=getLeftmostBit(n);
    return countSetBits(n,m);
  }
  static int countSetBits(int n,int m){
    if(n==0)return 0 ;
    m=getNextLeftmostBit(n,m);
    if(n==((int)1<<(m+1))-1)return(int)(m+1)*(1<<m);
    n=n-(1<<m);
    return(n+1)+countSetBits(n)+m*(1<<(m-1));
  }
  public static void main(String[] args){
    int n=17 ;
    System.out.println("Total set bit count is "+countSetBits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getLeftmostBit( n : int) : int
  pre: true
  post: true
  activity: (     var m : int ; m := 0 ;
     while (n > 1) do (     n := (n/(2->pow(1)))->oclAsType(long) ; 
     m := m + 1 ) ; 
     return m );
  static   operation getNextLeftmostBit( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var temp : int ; temp := (1*(2->pow(m)))->oclAsType(long) ;
     while (n < temp) do (     temp := (temp/(2->pow(1)))->oclAsType(long) ; 
     m := m - 1 ) ; 
     return m );
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     var m : int ; m := getLeftmostBit(n) ;
     return countSetBits(n, m) );
  static   operation countSetBits( n : int, m : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else skip ; 
     m := getNextLeftmostBit(n, m) ; 
    if (n = ((1->oclAsType(int)*(2->pow((m + 1))))->oclAsType(long)) - 1) then     return (m + 1)->oclAsType(int) * ((1*(2->pow(m)))->oclAsType(long)) else skip ; 
    n := n - ((1*(2->pow(m)))->oclAsType(long)) ; 
    return (n + 1) + countSetBits(n) + m * ((1*(2->pow((m - 1))))->oclAsType(long)) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 17 ;
     OclFile["System.out"].println("Total set bit count is " + countSetBits(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String getCount(int N){
    if(N % 2==1)return "0" ;
    String result="9" ;
    for(int i=1 ; i<=N/2-1 ; i++)result+="0" ;
    return result ;
  }
  public static void main(String[] args){
    int N=4 ;
    System.out.println(getCount(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getCount( N : int) : String
  pre: true
  post: true
  activity: (     if (N mod 2 = 1) then     return "0" else skip ; 
     var result : String ; result := "9" ;
         var i : int ; i := 1 ; while i <= N / 2 - 1 do (     result := result+("0") ;  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(getCount(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int minCoins(int coins[],int m,int V){
    int table[]=new int[V+1];
    table[0]=0 ;
    for(int i=1 ; i<=V ; i++)table[i]=Integer.MAX_VALUE ;
    for(int i=1 ; i<=V ; i++){
      for(int j=0 ; j<m ; j++)if(coins[j]<=i){
        int sub_res=table[i-coins[j] ];
        if(sub_res!=Integer.MAX_VALUE && sub_res+1<table[i])table[i]=sub_res+1 ;
      }
    }
    return table[V];
  }
  public static void main(String[] args){
    int coins[]={
      9,6,5,1 };
      int m=coins.length ;
      int V=11 ;
      System.out.println("Minimum coins required is "+minCoins(coins,m,V));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minCoins( coins : Sequence(int), m : int, V : int) : int
  pre: true
  post: true
  activity: (     var table : Sequence(int) ; table := Integer.subrange(1,V + 1)->collect(0) ;
     table[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= V do (     table[i+1] := 2147483647 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= V do ( (         var j : int ; j := 0 ; while j < m do (     if (coins[j+1] <= i) then (     var sub_res : int ; sub_res := table[i - coins[j+1]+1] ;
     if (sub_res /= 2147483647 & sub_res + 1 < table[i+1]) then     table[i+1] := sub_res + 1 ; else skip ) else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return table[V+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var coins : Sequence(int) ; coins := Sequence{9,6,5,1} ;
     var m : int ; m := coins->size() ;
     var V : int ; V := 11 ;
     OclFile["System.out"].println("Minimum coins required is " + minCoins(coins, m, V)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class at83 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long a[]=new long[n];
    long b[]=new long[n];
    int size=0 ;
    long sum=0,c ;
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      c=1 ;
      while(i<n-1 && a[i]==a[i+1]){
        c++;
        i++;
      }
      b[size++]=c ;
    }
    for(int j=0 ; j<size ; j++){
      sum+=(b[j]*(b[j]+1))/2 ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class at83 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
    var size : int ; size := 0 ;
    var sum : long ; sum := 0 ;
    var c : long ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     c := 1 ; 
     while (i < n - 1 & a[i+1] = a[i + 1+1]) do (     c := c + 1 ; 
     i := i + 1 ) ; 
      b[size+1] := c  ; size := size + 1 )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < size do ( (     sum := sum+((b[j+1] * (b[j+1] + 1)) / 2) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.StringTokenizer ;
import java.util.TreeMap ;
import java.util.TreeSet ;
import java.util.Vector ;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st ;
    int n=Integer.parseInt(br.readLine());
    long count=0 ;
    long ans=0 ;
    int a[]=new int[n];
    st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<n ; i++)a[i]=Integer.parseInt(st.nextToken());
    ans=(long)n ;
    for(int i=0 ; i<n-1 ; i++){
      if(a[i]==a[i+1]){
        count++;
        ans+=count ;
      }
      else count=0 ;
    }
    System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var count : long ; count := 0 ;
    var ans : long ; ans := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (st.next())->toInteger() ;  ;     i := i + 1 ) ; 
    ans := n->oclAsType(long) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (a[i+1] = a[i + 1+1]) then (     count := count + 1 ; 
     ans := ans+(count) ) else     count := 0 ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public final class magical_array {
  static Scanner sc=new Scanner(System.in);
  static PrintWriter out=new PrintWriter(System.out);
  static long sum=0 ;
  static void solve(long[] a,int n,int i){
    if(i<n){
      long count=1 ;
      while(i<n-1 && a[i]==a[i+1]){
        i++;
        count++;
      }
      sum=sum+((count*(count+1))/2);
      solve(a,n,i+1);
    }
    else {
      out.println(sum);
    }
  }
  public static void main(String args[])throws Exception {
    int n=sc.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    solve(a,n,0);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class magical_array {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute sum : long := 0;
  static   operation solve( a : Sequence(long), n : int, i : int) : void
  pre: true
  post: true
  activity: (     if (i < n) then (     var count : long ; count := 1 ;
     while (i < n - 1 & a[i+1] = a[i + 1+1]) do (     i := i + 1 ; 
     count := count + 1 ) ; 
     sum := sum + ((count * (count + 1)) / 2) ; 
     execute solve(a, n, i + 1) ) else (     skip ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute solve(a, n, 0) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int k=s.nextInt();
    int t=s.nextInt();
    int a=0 ;
    if(t>=n)a=k-(t-n);
    else if(t<=k)a=t ;
    else a=k ;
    System.out.println(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var k : int ; k := s.getCurrent()->toInteger() ;
    var t : int ; t := s.getCurrent()->toInteger() ;
    var a : int ; a := 0 ;
    if (t >= n) then     a := k - (t - n) else     if (t <= k) then     a := t else     a := k ; ;  ;  
    OclFile["System.out"].println(a) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int N,D ;
    char[] X ;
    N=parseInt(br.readLine());
    X=br.readLine().toCharArray();
    D=parseInt(br.readLine());
    char[] ans=Arrays.copyOf(X,N);
    for(int i=0 ; i<N ; i++){
      if(D==0)break ;
      if(D>0 && X[i]=='0'){
        ans[i]='1' ;
        D--;
      }
    }
    for(int i=N-1 ; i>=0 ; i--){
      if(D==0)break ;
      if(D>0 && X[i]=='1'){
        ans[i]='0' ;
        D--;
      }
    }
    System.out.println(String.valueOf(ans));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var N : int ;
    var D : int ;
    var X : Sequence(String) ;
    N := (br.readLine() + "")->toInteger() ; 
    X := br.readLine()->characters() ; 
    D := (br.readLine() + "")->toInteger() ; 
    var ans : Sequence(String) ; ans := X.subrange(1,N) ;
        var i : int ; i := 0 ; while i < N do ( (     if (D = 0) then     break else skip ; 
     if (D > 0 & X[i+1] = '0') then (     ans[i+1] := '1' ; 
     D := D - 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := N - 1 ; while i >= 0 do ( (     if (D = 0) then     break else skip ; 
     if (D > 0 & X[i+1] = '1') then (     ans[i+1] := '0' ; 
     D := D - 1 ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println((ans)->sum() ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Waves {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long k=sc.nextLong();
    long t=sc.nextLong();
    if(t<=k)System.out.println(t);
    else if(t>k && t<=n)System.out.println(k);
    else {
      t-=n ;
      System.out.println((k-t));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Waves {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var t : long ; t := sc.getCurrent()->toLong() ;
    if (t <= k) then     OclFile["System.out"].println(t) else     if (t > k & t <= n) then     OclFile["System.out"].println(k) else (     t := t-(n) ; 
     OclFile["System.out"].println((k - t)) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    int n=Integer.parseInt(f.readLine());
    StringTokenizer st=new StringTokenizer(f.readLine());
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(st.nextToken());
    }
    if(n==1){
      out.println(1);
    }
    else {
      int[] l=new int[n];
      l[1]=1 ;
      for(int i=1 ; i<n-1 ; i++){
        if(a[i]>a[i-1]){
          l[i+1]=l[i]+1 ;
        }
        else {
          l[i+1]=1 ;
        }
      }
      int[] r=new int[n];
      r[n-2]=1 ;
      for(int i=n-2 ; i>0 ; i--){
        if(a[i]<a[i+1]){
          r[i-1]=r[i]+1 ;
        }
        else {
          r[i-1]=1 ;
        }
      }
      int max=0 ;
      for(int i=0 ; i<n ; i++){
        max=Math.max(max,l[i]+1);
        max=Math.max(max,r[i]+1);
        if(i==0 || i==n-1 || a[i+1]>a[i-1]+1){
          max=Math.max(max,l[i]+r[i]+1);
        }
      }
      out.println(max);
    }
    f.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    var n : int ; n := (f.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    if (n = 1) then (     skip ) else (     var l : Sequence(int) ; l := Integer.subrange(1,n)->collect(0) ;
     l[1+1] := 1 ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     if (a[i+1] > a[i - 1+1]) then (     l[i + 1+1] := l[i+1] + 1 ) else (     l[i + 1+1] := 1 ) )  ;     i := i + 1 ) ; 
    var r : Sequence(int) ; r := Integer.subrange(1,n)->collect(0) ;
    r[n - 2+1] := 1 ; 
        var i : int ; i := n - 2 ; while i > 0 do ( (     if (a[i+1] < a[i + 1+1]) then (     r[i - 1+1] := r[i+1] + 1 ) else (     r[i - 1+1] := 1 ) )  ;     i := i - 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     max := Set{max, l[i+1] + 1}->max() ; 
     max := Set{max, r[i+1] + 1}->max() ; 
     if (i = 0 or i = n - 1 or a[i + 1+1] > a[i - 1+1] + 1) then (     max := Set{max, l[i+1] + r[i+1] + 1}->max() ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Iterator ;
import java.util.List ;
public class Algorithm {
  public static void main(String[] rgs)throws IOException {
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder stringBuilder=new StringBuilder();
    int t=Integer.parseInt(bufferedReader.readLine());
    for(int i=0 ; i<t ; i++){
      int lemn=Integer.parseInt(bufferedReader.readLine());
      String first=bufferedReader.readLine();
      String sec=bufferedReader.readLine();
      String ans="" ;
      int onecount=0 ;
      int zerocount=0 ;
      boolean isequal=true ;
      boolean brrok=false ;
      for(int j=0 ; j<first.length(); j++){
        char cur=first.charAt(j);
        if(isequal){
          if(cur==sec.charAt(j)){
            if(cur=='1')onecount+=1 ;
            else zerocount+=1 ;
          }
          else {
            if(onecount!=zerocount){
              stringBuilder.append("NO\n");
              brrok=true ;
              break ;
            }
            isequal=false ;
            onecount=0 ;
            zerocount=0 ;
            if(cur=='1')onecount=1 ;
            else zerocount=1 ;
          }
        }
        else {
          if(cur!=sec.charAt(j)){
            if(cur=='1')onecount+=1 ;
            else zerocount+=1 ;
          }
          else {
            if(onecount!=zerocount){
              stringBuilder.append("NO\n");
              brrok=true ;
              break ;
            }
            isequal=true ;
            onecount=0 ;
            zerocount=0 ;
            if(cur=='1')onecount=1 ;
            else zerocount=1 ;
          }
        }
      }
      if(brrok)continue ;
      if(! isequal && onecount!=zerocount){
        stringBuilder.append("NO\n");
        continue ;
      }
      stringBuilder.append("YES\n");
    }
    System.out.println(stringBuilder);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Algorithm {
  static   operation main( rgs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var stringBuilder : String ; stringBuilder := StringLib.newString() ;
    var t : int ; t := (bufferedReader.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < t do ( (     var lemn : int ; lemn := (bufferedReader.readLine())->toInteger() ;
     var first : String ; first := bufferedReader.readLine() ;
    var sec : String ; sec := bufferedReader.readLine() ;
    var ans : String ; ans := "" ;
    var onecount : int ; onecount := 0 ;
    var zerocount : int ; zerocount := 0 ;
    var isequal : boolean ; isequal := true ;
    var brrok : boolean ; brrok := false ;
        var j : int ; j := 0 ; while j < first->size() do ( (     var cur : String ; cur := first->at(j+1) ;
     if (isequal) then (     if (cur = sec->at(j+1)) then (     if (cur = '1') then     onecount := onecount+(1) ; else     zerocount := zerocount+(1) ; ) else (     if (onecount /= zerocount) then (     stringBuilder := stringBuilder + StringLib.newString("NO\n") ; 
     brrok := true ; 
     break ) else skip ; 
     isequal := false ; 
    onecount := 0 ; 
    zerocount := 0 ; 
    if (cur = '1') then     onecount := 1 else     zerocount := 1 ; ;  
 ) ) else (     if (cur /= sec->at(j+1)) then (     if (cur = '1') then     onecount := onecount+(1) ; else     zerocount := zerocount+(1) ; ) else (     if (onecount /= zerocount) then (     stringBuilder := stringBuilder + StringLib.newString("NO\n") ; 
     brrok := true ; 
     break ) else skip ; 
     isequal := true ; 
    onecount := 0 ; 
    zerocount := 0 ; 
    if (cur = '1') then     onecount := 1 else     zerocount := 1 ; ;  
 ) ) )  ;     j := j + 1 ) ; 
    if (brrok) then     continue else skip ; 
    if (not(isequal) & onecount /= zerocount) then (     stringBuilder := stringBuilder + StringLib.newString("NO\n") ; 
     continue ) else skip ; 
    stringBuilder := stringBuilder + StringLib.newString("YES\n") ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(stringBuilder) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class CF_604A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] points={
      500,1000,1500,2000,2500 };
      int[] times=new int[5];
      for(int i=0 ; i<5 ; i++)times[i]=sc.nextInt();
      sc.nextLine();
      int[] wrong=new int[5];
      for(int i=0 ; i<5 ; i++)wrong[i]=sc.nextInt();
      sc.nextLine();
      int h1=sc.nextInt();
      int h2=sc.nextInt();
      sc.nextLine();
      double score=h1*100.0-h2*50.0 ;
      for(int i=0 ; i<5 ; i++){
        double first=0.3*points[i];
        double second=(1.0-(times[i]/250.0))*points[i]-50.0*wrong[i];
        score+=Math.max(first,second);
      }
      System.out.println((int)score);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class CF_604A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var points : Sequence(int) ; points := Sequence{500,1000,1500,2000,2500} ;
    var times : Sequence(int) ; times := Integer.subrange(1,5)->collect(0) ;
        var i : int ; i := 0 ; while i < 5 do (     times[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    skip ; 
    var wrong : Sequence(int) ; wrong := Integer.subrange(1,5)->collect(0) ;
        var i : int ; i := 0 ; while i < 5 do (     wrong[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    skip ; 
    var h1 : int ; h1 := sc.getCurrent()->toInteger() ;
    var h2 : int ; h2 := sc.getCurrent()->toInteger() ;
    skip ; 
    var score : double ; score := h1 * 100.0 - h2 * 50.0 ;
        var i : int ; i := 0 ; while i < 5 do ( (     var first : double ; first := 0.3 * points[i+1] ;
     var second : double ; second := (1.0 - (times[i+1] / 250.0)) * points[i+1] - 50.0 * wrong[i+1] ;
     score := score+(Set{first, second}->max()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(score->oclAsType(int)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class uncowedfores {
  public static void main(String[] args){
    Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int[] min=new int[5];
    for(int i=0 ; i<5 ; i++){
      min[i]=sc.nextInt();
    }
    int[] wrong=new int[5];
    for(int i=0 ; i<5 ; i++){
      wrong[i]=sc.nextInt();
    }
    int[] max={
      500,1000,1500,2000,2500 };
      int hs=sc.nextInt();
      int hus=sc.nextInt();
      int total=100*hs-50*hus ;
      for(int i=0 ; i<5 ; i++){
        int m=min[i];
        int w=wrong[i];
        int x=max[i];
        total+=Math.max(3*x/10,x-x*m/250-50*w);
      }
      System.out.println(total);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class uncowedfores {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var min : Sequence(int) ; min := Integer.subrange(1,5)->collect(0) ;
        var i : int ; i := 0 ; while i < 5 do ( (     min[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var wrong : Sequence(int) ; wrong := Integer.subrange(1,5)->collect(0) ;
        var i : int ; i := 0 ; while i < 5 do ( (     wrong[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var max : Sequence(int) ; max := Sequence{500,1000,1500,2000,2500} ;
    var hs : int ; hs := sc.getCurrent()->toInteger() ;
    var hus : int ; hus := sc.getCurrent()->toInteger() ;
    var total : int ; total := 100 * hs - 50 * hus ;
        var i : int ; i := 0 ; while i < 5 do ( (     var m : int ; m := min[i+1] ;
     var w : int ; w := wrong[i+1] ;
     var x : int ; x := max[i+1] ;
     total := total+(Set{3 * x / 10, x - x * m / 250 - 50 * w}->max()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication94 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num1=sc.nextInt();
    int num2=sc.nextInt();
    int num3=sc.nextInt();
    int num4=sc.nextInt();
    int num5=sc.nextInt();
    int num6=sc.nextInt();
    int num7=sc.nextInt();
    int num8=sc.nextInt();
    int num9=sc.nextInt();
    int num10=sc.nextInt();
    int num11=sc.nextInt();
    int num12=sc.nextInt();
    float counter=(((Math.max((float).3*500,(1-((float)num1/250))*500-(50*num6))))+((Math.max((float).3*1000,(1-((float)num2/250))*1000-(50*num7))))+((Math.max((float).3*1500,(1-((float)num3/250))*1500-(50*num8))))+((Math.max((float).3*2000,(1-((float)num4/250))*2000-(50*num9))))+((Math.max((float).3*2500,(1-((float)num5/250))*2500-(50*num10))))+(100*num11)-(50*num12));
    System.out.println((int)counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication94 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num1 : int ; num1 := sc.getCurrent()->toInteger() ;
    var num2 : int ; num2 := sc.getCurrent()->toInteger() ;
    var num3 : int ; num3 := sc.getCurrent()->toInteger() ;
    var num4 : int ; num4 := sc.getCurrent()->toInteger() ;
    var num5 : int ; num5 := sc.getCurrent()->toInteger() ;
    var num6 : int ; num6 := sc.getCurrent()->toInteger() ;
    var num7 : int ; num7 := sc.getCurrent()->toInteger() ;
    var num8 : int ; num8 := sc.getCurrent()->toInteger() ;
    var num9 : int ; num9 := sc.getCurrent()->toInteger() ;
    var num10 : int ; num10 := sc.getCurrent()->toInteger() ;
    var num11 : int ; num11 := sc.getCurrent()->toInteger() ;
    var num12 : int ; num12 := sc.getCurrent()->toInteger() ;
    var counter : double ; counter := (((Set{.3->oclAsType(double) * 500, (1 - (num1->oclAsType(double) / 250)) * 500 - (50 * num6)}->max())) + ((Set{.3->oclAsType(double) * 1000, (1 - (num2->oclAsType(double) / 250)) * 1000 - (50 * num7)}->max())) + ((Set{.3->oclAsType(double) * 1500, (1 - (num3->oclAsType(double) / 250)) * 1500 - (50 * num8)}->max())) + ((Set{.3->oclAsType(double) * 2000, (1 - (num4->oclAsType(double) / 250)) * 2000 - (50 * num9)}->max())) + ((Set{.3->oclAsType(double) * 2500, (1 - (num5->oclAsType(double) / 250)) * 2500 - (50 * num10)}->max())) + (100 * num11) - (50 * num12)) ;
    OclFile["System.out"].println(counter->oclAsType(int)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int WHITE=0 ;
  static final int GRAY=1 ;
  static final int BLACK=2 ;
  static int v ;
  static Map<Integer,List<Integer>>adjList=new HashMap<Integer,List<Integer>>();
  static int color[];
  static boolean judge=false ;
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    v=scan.nextInt();
    int e=scan.nextInt();
    int start,end=0 ;
    for(int i=0 ; i<e ; i++){
      start=scan.nextInt();
      end=scan.nextInt();
      if(! adjList.containsKey(start)){
        adjList.put(start,new ArrayList<Integer>());
      }
      adjList.get(start).add(end);
    }
    color=new int[v];
    for(int i : adjList.keySet()){
      dfs(i);
    }
    if(judge){
      System.out.println(1);
    }
    else System.out.println(0);
  }
  static void dfs(int u){
    color[u]=GRAY ;
    if(adjList.containsKey(u)){
      for(int ne : adjList.get(u)){
        if(color[ne]==GRAY){
          judge=true ;
          break ;
        }
        if(color[ne]==WHITE)dfs(ne);
      }
    }
    color[u]=BLACK ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute WHITE : int := 0;
  static    attribute GRAY : int := 1;
  static    attribute BLACK : int := 2;
  static   attribute v : int;
  static   attribute adjList : Map(int,Sequence(int)) := Map{};
  static   attribute color : Sequence(int);
  static   attribute judge : boolean := false;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     v := scan.getCurrent()->toInteger() ; 
    var e : int ; e := scan.getCurrent()->toInteger() ;
    var start : int ;
    var end : int ; end := 0 ;
        var i : int ; i := 0 ; while i < e do ( (     start := scan.getCurrent()->toInteger() ; 
     end := scan.getCurrent()->toInteger() ; 
     if (not(adjList->keys()->includes(start))) then (     adjList := adjList->union(Map{start |-> Sequence{}}) ) else skip ; 
     adjList->at(start)->excludes(end) )  ;     i := i + 1 ) ; 
    color := Integer.subrange(1,v)->collect(0) ; 
    for (i : adjList->keys()) do ( (     execute dfs(i) )  ) ; 
    if (judge) then (     OclFile["System.out"].println(1) ) else     OclFile["System.out"].println(0) ; ;  
 );
  static   operation dfs( u : int) : void
  pre: true
  post: true
  activity: (     color[u+1] := GRAY ; 
     if (adjList->keys()->includes(u)) then (     for (ne : adjList->at(u)) do ( (     if (color[ne+1] = GRAY) then (     judge := true ; 
     break ) else skip ; 
     if (color[ne+1] = WHITE) then     execute dfs(ne) ; else skip )  ) ) else skip ; 
     color[u+1] := BLACK );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.*;
class Main {
  static class Graph {
    int vertices ;
    ArrayList<ArrayList<Integer>>adjList ;
    public Graph(int v){
      vertices=v ;
      adjList=new ArrayList<ArrayList<Integer>>();
      for(int i=0 ; i<vertices ; i++)adjList.add(new ArrayList<>());
    }
    public boolean addEdge(int start,int end){
      if(start>vertices)return false ;
      adjList.get(start).add(end);
      return true ;
    }
    public boolean isCycle(){
      boolean visited[]=new boolean[vertices];
      boolean recursiveArr[]=new boolean[vertices];
      for(int i=0 ; i<vertices ; i++){
        if(isCycleUtil(i,visited,recursiveArr))return true ;
      }
      return false ;
    }
    private boolean isCycleUtil(int vertex,boolean[] visited,boolean recursiveArr[]){
      visited[vertex]=true ;
      recursiveArr[vertex]=true ;
      for(int i=0 ; i<adjList.get(vertex).size(); i++){
        int adjVertex=adjList.get(vertex).get(i);
        if(! visited[adjVertex] && isCycleUtil(adjVertex,visited,recursiveArr)){
          return true ;
        }
        else if(recursiveArr[adjVertex]){
          return true ;
        }
      }
      recursiveArr[vertex]=false ;
      return false ;
    }
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int numV=scanner.nextInt();
    int numE=scanner.nextInt();
    Graph g=new Graph(numV);
    for(int i=0 ; i<numE ; i++){
      g.addEdge(scanner.nextInt(),scanner.nextInt());
    }
    System.out.println(g.isCycle()? 1 : 0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Graph {
   attribute vertices : int;
   attribute adjList : Sequence(Sequence(int));
   static operation newGraph( v : int) : Graph
  pre: true
  post: true
  activity:
  ( var self : Graph ;
    self := createGraph();
    self.initialise(v);
    return self );
  operation initialise( v : int) : void
  pre: true  post: true
  activity: (     vertices := v ; 
     adjList := Sequence{} ; 
         var i : int ; i := 0 ; while i < vertices do (     adjList := adjList->including(Sequence{}) ;  ;     i := i + 1 ) );
   operation addEdge( start : int, end : int) : boolean
  pre: true
  post: true
  activity: (     if (start > vertices) then     return false else skip ; 
     adjList->at(start+1)->excludes(end) ; 
     return true );
   operation isCycle() : boolean
  pre: true
  post: true
  activity: (     var visited : Sequence(boolean) ; visited := Integer.subrange(1,vertices)->collect(false) ;
     var recursiveArr : Sequence(boolean) ; recursiveArr := Integer.subrange(1,vertices)->collect(false) ;
         var i : int ; i := 0 ; while i < vertices do ( (     if (isCycleUtil(i, visited, recursiveArr)) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
   operation isCycleUtil( vertex : int, visited : Sequence(boolean), recursiveArr : Sequence(boolean)) : boolean
  pre: true
  post: true
  activity: (     visited[vertex+1] := true ; 
     recursiveArr[vertex+1] := true ; 
        var i : int ; i := 0 ; while i < adjList->at(vertex+1)->size() do ( (     var adjVertex : int ; adjVertex := adjList->at(vertex+1)->at(i+1) ;
     if (not(visited[adjVertex+1]) & isCycleUtil(adjVertex, visited, recursiveArr)) then (     return true ) else     if (recursiveArr[adjVertex+1]) then (     return true ) else skip ; )  ;     i := i + 1 ) ; 
    recursiveArr[vertex+1] := false ; 
    return false 
 );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numV : int ; numV := scanner.getCurrent()->toInteger() ;
    var numE : int ; numE := scanner.getCurrent()->toInteger() ;
    var g : Graph ; g := Graph.newGraph(numV) ;
        var i : int ; i := 0 ; while i < numE do ( (     g.addEdge(scanner.getCurrent()->toInteger(), scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if g.isCycle() then 1 else 0 endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  static int ar[][];
  static int nodes ;
  static String color[];
  static int lastCount ;
  static int parent[];
  static int breaker ;
  static String ans="" ;
  static void doDfs(int i){
    int source=i ;
    color[source]="grey" ;
    for(int ii=0 ; ii<nodes ; ii++){
      if(ar[i][ii]==1){
        if(color[ii]=="grey"){
          lastCount=ii ;
          breaker=1 ;
          parent[ii]=source ;
          break ;
        }
        else if(color[ii]=="white"){
          parent[ii]=source ;
          doDfs(ii);
        }
      }
    }
    color[source]="black" ;
  }
  static void printPath(int a){
    int source=parent[a];
    if(source==lastCount){
      System.out.println(ans+lastCount);
    }
    else {
      ans=ans+source+" " ;
      printPath(source);
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    nodes=sc.nextInt();
    int edges=sc.nextInt();
    ar=new int[nodes][nodes];
    for(int i=0 ; i<edges ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      ar[a][b]=1 ;
    }
    color=new String[nodes];
    parent=new int[nodes];
    for(int i=0 ; i<color.length ; i++){
      color[i]="white" ;
    }
    for(int i=0 ; i<color.length ; i++){
      if(color[i]=="white"){
        doDfs(i);
        if(breaker==1){
          break ;
        }
      }
    }
    if(breaker==1){
      System.out.println("1");
    }
    else {
      System.out.println("0");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ar : Sequence(Sequence(int));
  static   attribute nodes : int;
  static   attribute color : Sequence(String);
  static   attribute lastCount : int;
  static   attribute parent : Sequence(int);
  static   attribute breaker : int;
  static   attribute ans : String := "";
  static   operation doDfs( i : int) : void
  pre: true
  post: true
  activity: (     var source : int ; source := i ;
     color[source+1] := "grey" ; 
         var ii : int ; ii := 0 ; while ii < nodes do ( (     if (ar[i+1][ii+1] = 1) then (     if (color[ii+1] = "grey") then (     lastCount := ii ; 
     breaker := 1 ; 
     parent[ii+1] := source ; 
     break ) else     if (color[ii+1] = "white") then (     parent[ii+1] := source ; 
     execute doDfs(ii) ) else skip ; ) else skip )  ;     ii := ii + 1 ) ; 
     color[source+1] := "black" );
  static   operation printPath( a : int) : void
  pre: true
  post: true
  activity: (     var source : int ; source := parent[a+1] ;
     if (source = lastCount) then (     OclFile["System.out"].println(ans + lastCount) ) else (     ans := ans + source + " " ; 
     execute printPath(source) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     nodes := sc.getCurrent()->toInteger() ; 
    var edges : int ; edges := sc.getCurrent()->toInteger() ;
    ar := Integer.subrange(1,nodes)->collect(Integer.subrange(1,nodes)->collect(0)) ; 
        var i : int ; i := 0 ; while i < edges do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     ar[a+1][b+1] := 1 )  ;     i := i + 1 ) ; 
    color := Integer.subrange(1,nodes)->collect(null) ; 
    parent := Integer.subrange(1,nodes)->collect(0) ; 
        var i : int ; i := 0 ; while i < color->size() do ( (     color[i+1] := "white" )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < color->size() do ( (     if (color[i+1] = "white") then (     execute doDfs(i) ; 
     if (breaker = 1) then (     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (breaker = 1) then (     OclFile["System.out"].println("1") ) else (     OclFile["System.out"].println("0") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int N,D ;
    char[] X ;
    N=parseInt(br.readLine());
    X=br.readLine().toCharArray();
    D=parseInt(br.readLine());
    char[] ans=Arrays.copyOf(X,N);
    for(int i=0 ; i<N ; i++){
      if(D==0)break ;
      if(X[i]=='0'){
        ans[i]='1' ;
        D--;
      }
    }
    for(int i=N-1 ; i>=0 ; i--){
      if(D==0)break ;
      if(X[i]=='1'){
        ans[i]='0' ;
        D--;
      }
    }
    System.out.println(String.valueOf(ans));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var N : int ;
    var D : int ;
    var X : Sequence(String) ;
    N := (br.readLine() + "")->toInteger() ; 
    X := br.readLine()->characters() ; 
    D := (br.readLine() + "")->toInteger() ; 
    var ans : Sequence(String) ; ans := X.subrange(1,N) ;
        var i : int ; i := 0 ; while i < N do ( (     if (D = 0) then     break else skip ; 
     if (X[i+1] = '0') then (     ans[i+1] := '1' ; 
     D := D - 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := N - 1 ; while i >= 0 do ( (     if (D = 0) then     break else skip ; 
     if (X[i+1] = '1') then (     ans[i+1] := '0' ; 
     D := D - 1 ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println((ans)->sum() ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int v=Integer.parseInt(str[0]);
    int e=Integer.parseInt(str[1]);
    int[][] map=new int[v][v];
    for(int i=0 ; i<v ; i++)Arrays.fill(map[i],-Integer.MAX_VALUE/2);
    for(int i=0 ; i<v ; i++)map[i][i]=0 ;
    for(int i=0 ; i<e ; i++){
      str=br.readLine().split(" ");
      int s=Integer.parseInt(str[0]);
      int t=Integer.parseInt(str[1]);
      map[s][t]=1 ;
    }
    for(int k=0 ; k<v ; k++){
      for(int i=0 ; i<v ; i++){
        for(int j=0 ; j<v ; j++){
          if(map[i][j]<map[i][k]+map[k][j]){
            map[i][j]=map[i][k]+map[k][j];
          }
        }
      }
    }
    boolean closed=false ;
    for(int i=0 ; i<v ; i++){
      if(map[i][i]!=0){
        closed=true ;
        break ;
      }
    }
    if(! closed){
      System.out.println(0);
    }
    else {
      System.out.println(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var v : int ; v := (str[0+1])->toInteger() ;
    var e : int ; e := (str[1+1])->toInteger() ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,v)->collect(Integer.subrange(1,v)->collect(0)) ;
        var i : int ; i := 0 ; while i < v do (     map[i+1] := map[i+1]->collect(-2147483647 / 2) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < v do (     map[i+1][i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < e do ( (     str := br.readLine()->split(" ") ; 
     var s : int ; s := (str[0+1])->toInteger() ;
     var t : int ; t := (str[1+1])->toInteger() ;
     map[s+1][t+1] := 1 )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < v do ( (         var i : int ; i := 0 ; while i < v do ( (         var j : int ; j := 0 ; while j < v do ( (     if (map[i+1][j+1] < map[i+1][k+1] + map[k+1][j+1]) then (     map[i+1][j+1] := map[i+1][k+1] + map[k+1][j+1] ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    var closed : boolean ; closed := false ;
        var i : int ; i := 0 ; while i < v do ( (     if (map[i+1][i+1] /= 0) then (     closed := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (not(closed)) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int V=Integer.parseInt(sc.next());
    int E=Integer.parseInt(sc.next());
    ArrayList<ArrayList<Integer>>edge=new ArrayList<ArrayList<Integer>>();
    for(int i=0 ; i<V ; i++){
      ArrayList<Integer>add=new ArrayList<Integer>();
      edge.add(add);
    }
    int[] indegree=new int[V];
    for(int i=0 ; i<E ; i++){
      int s=Integer.parseInt(sc.next());
      int t=Integer.parseInt(sc.next());
      edge.get(s).add(t);
      indegree[t]++;
    }
    ArrayList<Integer>ans=new ArrayList<Integer>();
    ArrayDeque<Integer>queue=new ArrayDeque<Integer>();
    for(int i=0 ; i<V ; i++){
      if(indegree[i]==0){
        queue.add(i);
        ans.add(i);
      }
    }
    int flag=0 ;
    if(queue.isEmpty()){
      flag=1 ;
    }
    int cnt=0 ;
    while(! queue.isEmpty()){
      Integer rem=queue.remove();
      for(Integer i : edge.get(rem)){
        indegree[i]--;
        if(indegree[i]==0){
          queue.add(i);
          ans.add(i);
        }
      }
      cnt++;
      if(cnt>V){
        flag=1 ;
        break ;
      }
    }
    if(cnt!=V){
      flag=1 ;
    }
    System.out.println(flag);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var V : int ; V := (sc.getCurrent())->toInteger() ;
    var E : int ; E := (sc.getCurrent())->toInteger() ;
    var edge : Sequence(Sequence(int)) ; edge := Sequence{} ;
        var i : int ; i := 0 ; while i < V do ( (     var add : Sequence(int) ; add := Sequence{} ;
     edge := edge->including(add) )  ;     i := i + 1 ) ; 
    var indegree : Sequence(int) ; indegree := Integer.subrange(1,V)->collect(0) ;
        var i : int ; i := 0 ; while i < E do ( (     var s : int ; s := (sc.getCurrent())->toInteger() ;
     var t : int ; t := (sc.getCurrent())->toInteger() ;
     edge->at(s+1)->excludes(t) ; 
     indegree[t+1] := indegree[t+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Sequence{} ;
    var queue : Sequence(int) ; queue := ArrayDeque<int>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < V do ( (     if (indegree[i+1] = 0) then (     queue := queue->including(i) ; 
     ans := ans->including(i) ) else skip )  ;     i := i + 1 ) ; 
    var flag : int ; flag := 0 ;
    if (queue->isEmpty()) then (     flag := 1 ) else skip ; 
    var cnt : int ; cnt := 0 ;
    while (not(queue->isEmpty())) do (     var rem : int ; rem := queue.remove() ;
     for (i : edge->at(rem+1)) do ( (     indegree[i+1] := indegree[i+1] - 1 ; 
     if (indegree[i+1] = 0) then (     queue := queue->including(i) ; 
     ans := ans->including(i) ) else skip )  ) ; 
     cnt := cnt + 1 ; 
     if (cnt > V) then (     flag := 1 ; 
     break ) else skip ) ; 
    if (cnt /= V) then (     flag := 1 ) else skip ; 
    OclFile["System.out"].println(flag) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileNotFoundException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    String S=sc.next();
    char[] s=S.toCharArray();
    for(int i=0 ; i<S.length(); i++){
      if(i==K-1){
        s[i]=Character.toLowerCase(s[i]);
      }
    }
    S=new String(s);
    System.out.println(S);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var S : String ; S := sc.getCurrent() ;
    var s : Sequence(String) ; s := S->characters() ;
        var i : int ; i := 0 ; while i < S->size() do ( (     if (i = K - 1) then (     s[i+1] := (s[i+1] + "")->toLowerCase() ) else skip )  ;     i := i + 1 ) ; 
    S := StringLib.newString(s) ; 
    OclFile["System.out"].println(S) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
class Main {
  static class Edge {
    int to,dis ;
    Edge(int to,int dis){
      this.to=to ;
      this.dis=dis ;
    }
  }
  static int used[];
  static List<Edge>edgeList[];
  static boolean dfs(int v,int pos){
    if(used[v]>Integer.MIN_VALUE)return used[v]==pos ;
    used[v]=pos ;
    for(Edge e : edgeList[v]){
      if(! dfs(e.to,pos+e.dis))return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int M=scan.nextInt();
    edgeList=new ArrayList[N+1];
    for(int i=1 ; i<=N ; ++i)edgeList[i]=new ArrayList<>();
    used=new int[N+1];
    Arrays.fill(used,Integer.MIN_VALUE);
    for(int i=0 ; i<M ; ++i){
      int L=scan.nextInt();
      int R=scan.nextInt();
      int D=scan.nextInt();
      edgeList[L] .add(new Edge(R,D));
      edgeList[R] .add(new Edge(L,-D));
    }
    for(int i=1 ; i<=N ; ++i){
      if(used[i]>Integer.MIN_VALUE)continue ;
      if(! dfs(i,0)){
        System.out.println("No");
        return ;
      }
    }
    System.out.println("Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Edge {
   attribute to : int;
   static operation newEdge( to : int, dis : int) : Edge
  pre: true
  post: true
  activity:
  ( var self : Edge ;
    self := createEdge();
    self.initialise(to, dis);
    return self );
  operation initialise( to : int, dis : int) : void
  pre: true  post: true
  activity: (     self.to := to ; 
     self.dis := dis );
}
  static   attribute used : Sequence(int);
  static   attribute edgeList : Sequence(Sequence(Edge));
  static   operation dfs( v : int, pos : int) : boolean
  pre: true
  post: true
  activity: (     if (used[v+1] > -2147483648) then     return used[v+1] = pos else skip ; 
     used[v+1] := pos ; 
     for (e : edgeList[v+1]) do ( (     if (not(dfs(e.to, pos + e.dis))) then     return false else skip )  ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var M : int ; M := scan.getCurrent()->toInteger() ;
    edgeList := Integer.subrange(1,N + 1)->collect(null) ; 
        var i : int ; i := 1 ; while i <= N do (     edgeList[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
    used := Integer.subrange(1,N + 1)->collect(0) ; 
    used := used->collect(-2147483648) ; 
        var i : int ; i := 0 ; while i < M do ( (     var L : int ; L := scan.getCurrent()->toInteger() ;
     var R : int ; R := scan.getCurrent()->toInteger() ;
    var D : int ; D := scan.getCurrent()->toInteger() ;
    edgeList[L+1]->excludes(Edge.newEdge(R, D)) ; 
    edgeList[R+1]->excludes(Edge.newEdge(L, -D)) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (     if (used[i+1] > -2147483648) then     continue else skip ; 
     if (not(dfs(i, 0))) then (     OclFile["System.out"].println("No") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Yes") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.ArrayList ;
public class codforce {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int x=scan.nextInt();
    while(x-->0){
      int y=scan.nextInt();
      int q=scan.nextInt();
      int w=scan.nextInt();
      int k=0 ;
      if(y-10*w<=0){
        System.out.println("YES");
      }
      else {
        while(k<q){
          k++;
          y=y/2+10 ;
        }
        y=y-(w*10);
        if(y<=0){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codforce {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := scan.getCurrent()->toInteger() ;
         while (x > 0) do (        x := x - 1 ;     skip ; (     var y : int ; y := scan.getCurrent()->toInteger() ;
     var q : int ; q := scan.getCurrent()->toInteger() ;
    var w : int ; w := scan.getCurrent()->toInteger() ;
    var k : int ; k := 0 ;
    if (y - 10 * w <= 0) then (     OclFile["System.out"].println("YES") ) else (     while (k < q) do (     k := k + 1 ; 
     y := y / 2 + 10 ) ; 
     y := y - (w * 10) ; 
     if (y <= 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    while(n-->0){
      int x=0,y=0,z=0 ;
      x=scanner.nextInt();
      y=scanner.nextInt();
      z=scanner.nextInt();
      while(y>0 && x>20){
        y--;
        x=x/2+10 ;
      }
      if(x<=z*10){
        System.out.println("YES");
      }
      else {
        System.out.println("No");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var z : int ; z := 0 ;
     x := scanner.getCurrent()->toInteger() ; 
    y := scanner.getCurrent()->toInteger() ; 
    z := scanner.getCurrent()->toInteger() ; 
    while (y > 0 & x > 20) do (     y := y - 1 ; 
     x := x / 2 + 10 ) ; 
    if (x <= z * 10) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("No") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      int a=sc.nextInt();
      int b=sc.nextInt();
      if(n<=20){
        if((b*10)>=n){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
      else {
        while(n>20 && a>0){
          n/=2 ;
          n+=10 ;
          a--;
        }
        if(n<=(b*10)){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (n <= 20) then (     if ((b * 10) >= n) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else (     while (n > 20 & a > 0) do (     n := n/(2) ; 
     n := n+(10) ; 
     a := a - 1 ) ; 
     if (n <= (b * 10)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Scanner ;
public class Kana {
  int number ;
  LinkedList<String>sResult=new LinkedList<>();
  public Kana(int number){
    this.number=number ;
  }
  public void inputDataTest(int num1,int numb2,int number3){
    int number=num1 ;
    if(number<=10*number3){
      number-=(10*number3);
    }
    else {
      for(int i=0 ; i<numb2 ; i++){
        number/=2 ;
        number+=10 ;
      }
      number-=(10*number3);
    }
    if(number>0){
      sResult.add("NO");
    }
    else {
      sResult.add("YES");
    }
  }
  public void printResult(){
    for(String i : sResult){
      System.out.println(i);
    }
  }
  public int getNumber(){
    return number ;
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int numberTest=s.nextInt();
    Kana instance=new Kana(numberTest);
    for(int i=0 ; i<instance.getNumber(); i++){
      int numberOne=s.nextInt();
      int numberTwo=s.nextInt();
      int numberThree=s.nextInt();
      instance.inputDataTest(numberOne,numberTwo,numberThree);
    }
    instance.printResult();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Kana {
   attribute number : int;
   attribute sResult : Sequence(String) := Sequence{};
   static operation newKana( number : int) : Kana
  pre: true
  post: true
  activity:
  ( var self : Kana ;
    self := createKana();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation inputDataTest( num1 : int, numb2 : int, number3 : int) : void
  pre: true
  post: true
  activity: (     var number : int ; number := num1 ;
     if (number <= 10 * number3) then (     number := number-((10 * number3)) ) else (         var i : int ; i := 0 ; while i < numb2 do ( (     number := number/(2) ; 
     number := number+(10) )  ;     i := i + 1 ) ; 
     number := number-((10 * number3)) ) ;  
     if (number > 0) then (     sResult := sResult->including("NO") ) else (     sResult := sResult->including("YES") ) );
   operation printResult() : void
  pre: true
  post: true
  activity: (     for (i : sResult) do ( (     OclFile["System.out"].println(i) )  ) );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numberTest : int ; numberTest := s.getCurrent()->toInteger() ;
    var instance : Kana ; instance := Kana.newKana(numberTest) ;
        var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var numberOne : int ; numberOne := s.getCurrent()->toInteger() ;
     var numberTwo : int ; numberTwo := s.getCurrent()->toInteger() ;
     var numberThree : int ; numberThree := s.getCurrent()->toInteger() ;
     instance.inputDataTest(numberOne, numberTwo, numberThree) )  ;     i := i + 1 ) ; 
    instance.printResult() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Dragon {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int x=sc.nextInt();
      int n=sc.nextInt();
      int m=sc.nextInt();
      while(x>20 && n>0){
        x=x/2+10 ;
        n--;
      }
      if(x>0 && m>0){
        x=x-(m*10);
      }
      if(x<=0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Dragon {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    while (x > 20 & n > 0) do (     x := x / 2 + 10 ; 
     n := n - 1 ) ; 
    if (x > 0 & m > 0) then (     x := x - (m * 10) ) else skip ; 
    if (x <= 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B172 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int A=in.nextInt();
    int B=in.nextInt();
    int M=in.nextInt();
    int x=in.nextInt();
    int[] seen=new int[M];
    int index=1 ;
    while(seen[x]==0){
      seen[x]=index ;
      index++;
      x=(A*x+B)% M ;
    }
    int answer=index-seen[x];
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B172 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := in.getCurrent()->toInteger() ;
    var B : int ; B := in.getCurrent()->toInteger() ;
    var M : int ; M := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
    var seen : Sequence(int) ; seen := Integer.subrange(1,M)->collect(0) ;
    var index : int ; index := 1 ;
    while (seen[x+1] = 0) do (     seen[x+1] := index ; 
     index := index + 1 ; 
     x := (A * x + B) mod M ) ; 
    var answer : int ; answer := index - seen[x+1] ;
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] arr=sc.next().toCharArray();
    int d=sc.nextInt();
    int nd=n-d ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]=='1'){
        if(nd>0){
          nd--;
        }
        else {
          arr[i]='0' ;
          d--;
        }
      }
      else {
        if(d>0){
          d--;
          arr[i]='1' ;
        }
        else {
          nd--;
        }
      }
    }
    System.out.println(arr);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var nd : int ; nd := n - d ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = '1') then (     if (nd > 0) then (     nd := nd - 1 ) else (     arr[i+1] := '0' ; 
     d := d - 1 ) ) else (     if (d > 0) then (     d := d - 1 ; 
     arr[i+1] := '1' ) else (     nd := nd - 1 ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(arr) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Solution {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int a=Integer.parseInt(st.nextToken());
    int b=Integer.parseInt(st.nextToken());
    int m=Integer.parseInt(st.nextToken());
    int[] r=new int[1000000];
    r[0]=Integer.parseInt(st.nextToken());
    for(int i=1 ; i<1000000 ; i++){
      r[i]=a*r[i-1]+b ;
      r[i] %=m ;
    }
    int[] place=new int[m];
    for(int i=0 ; i<1000000-1 ; i++){
      place[r[i] ]=i ;
    }
    int rep=1000000-1-place[r[1000000-1] ];
    System.out.println(rep);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var a : int ; a := (st.next())->toInteger() ;
    var b : int ; b := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var r : Sequence(int) ; r := Integer.subrange(1,1000000)->collect(0) ;
    r[0+1] := (st.next())->toInteger() ; 
        var i : int ; i := 1 ; while i < 1000000 do ( (     r[i+1] := a * r[i - 1+1] + b ; 
     r[i+1] := r[i+1] mod m )  ;     i := i + 1 ) ; 
    var place : Sequence(int) ; place := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < 1000000 - 1 do ( (     place[r[i+1]+1] := i )  ;     i := i + 1 ) ; 
    var rep : int ; rep := 1000000 - 1 - place[r[1000000 - 1+1]+1] ;
    OclFile["System.out"].println(rep) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  final static int fact[]=new int[21];
  static void preCompute(){
    fact[0]=1 ;
    for(int i=1 ; i<18 ; i++)fact[i]=(fact[i-1]*i);
  }
  static void nextFactorial(int N){
    for(int i=0 ; i<21 ; i++){
      if(N<fact[i]){
        System.out.println(fact[i]);
        break ;
      }
    }
  }
  public static void main(String[] args){
    preCompute();
    int N=120 ;
    nextFactorial(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute fact : int := Integer.subrange(1,21)->collect(0);
  static   operation preCompute() : void
  pre: true
  post: true
  activity: (     fact[0+1] := 1 ; 
         var i : int ; i := 1 ; while i < 18 do (     fact[i+1] := (fact[i - 1+1] * i) ;  ;     i := i + 1 ) );
  static   operation nextFactorial( N : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 21 do ( (     if (N < fact[i+1]) then (     OclFile["System.out"].println(fact[i+1]) ; 
     break ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute preCompute() ; 
     var N : int ; N := 120 ;
     execute nextFactorial(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GeeksforGeeks {
  static double compute(int a,int b){
    double AM,GM,HM ;
    AM=(a+b)/2 ;
    GM=Math.sqrt(a*b);
    HM=(GM*GM)/AM ;
    return HM ;
  }
  public static void main(String args[]){
    int a=5,b=15 ;
    double HM=compute(a,b);
    String str="" ;
    str=str+HM ;
    System.out.print("Harmonic Mean between "+a+" and "+b+" is "+str.substring(0,5));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GeeksforGeeks {
  static   operation compute( a : int, b : int) : double
  pre: true
  post: true
  activity: (     var AM : double ;
    var GM : double ;
    var HM : double ;
     AM := (a + b) / 2 ; 
    GM := (a * b)->sqrt() ; 
    HM := (GM * GM) / AM ; 
    return HM 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 5 ;
    var b : int ; b := 15 ;
     var HM : double ; HM := compute(a, b) ;
    var str : String ; str := "" ;
    str := str + HM ; 
    OclFile["System.out"].print("Harmonic Mean between " + a + " and " + b + " is " + str.subrange(0+1,5)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int largest(int[] arr,int n){
    Arrays.sort(arr);
    return arr[n-1];
  }
  static public void main(String[] args){
    int[] arr={
      10,324,45,90,9808 };
      int n=arr.length ;
      System.out.println(largest(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation largest( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     return arr[n - 1+1] );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,324,45,90,9808} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(largest(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  static int getMedian(int ar1[],int ar2[],int n){
    int i=0 ;
    int j=0 ;
    int count ;
    int m1=-1,m2=-1 ;
    for(count=0 ; count<=n ; count++){
      if(i==n){
        m1=m2 ;
        m2=ar2[0];
        break ;
      }
      else if(j==n){
        m1=m2 ;
        m2=ar1[0];
        break ;
      }
      if(ar1[i]<ar2[j]){
        m1=m2 ;
        m2=ar1[i];
        i++;
      }
      else {
        m1=m2 ;
        m2=ar2[j];
        j++;
      }
    }
    return(m1+m2)/2 ;
  }
  public static void main(String[] args){
    int ar1[]={
      1,12,15,26,38 };
      int ar2[]={
        2,13,17,30,45 };
        int n1=ar1.length ;
        int n2=ar2.length ;
        if(n1==n2)System.out.println("Median is "+getMedian(ar1,ar2,n1));
        else System.out.println("arrays are of unequal size");
      }
    }

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation getMedian( ar1 : Sequence(int), ar2 : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var j : int ; j := 0 ;
    var count : int ;
    var m1 : int ; m1 := -1 ;
    var m2 : int ; m2 := -1 ;
        count := 0 ; while count <= n do ( (     if (i = n) then (     m1 := m2 ; 
     m2 := ar2[0+1] ; 
     break ) else     if (j = n) then (     m1 := m2 ; 
     m2 := ar1[0+1] ; 
     break ) else skip ; ;  
     if (ar1[i+1] < ar2[j+1]) then (     m1 := m2 ; 
     m2 := ar1[i+1] ; 
     i := i + 1 ) else (     m1 := m2 ; 
     m2 := ar2[j+1] ; 
     j := j + 1 ) )  ;     count := count + 1 ) ; 
    return (m1 + m2) / 2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ar1 : Sequence(int) ; ar1 := Sequence{1,12,15,26,38} ;
     var ar2 : Sequence(int) ; ar2 := Sequence{2,13,17,30,45} ;
    var n1 : int ; n1 := ar1->size() ;
    var n2 : int ; n2 := ar2->size() ;
    if (n1 = n2) then     OclFile["System.out"].println("Median is " + getMedian(ar1, ar2, n1)) else     OclFile["System.out"].println("arrays are of unequal size") ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static boolean validateStackSequence(int pushed[],int popped[],int len){
    int j=0 ;
    Stack<Integer>st=new Stack<>();
    for(int i=0 ; i<len ; i++){
      st.push(pushed[i]);
      while(! st.empty()&& j<len && st.peek()==popped[j]){
        st.pop();
        j++;
      }
    }
    return j==len ;
  }
  public static void main(String[] args){
    int pushed[]={
      1,2,3,4,5 };
      int popped[]={
        4,5,3,2,1 };
        int len=pushed.length ;
        System.out.println((validateStackSequence(pushed,popped,len)? "True" : "False"));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation validateStackSequence( pushed : Sequence(int), popped : Sequence(int), len : int) : boolean
  pre: true
  post: true
  activity: (     var j : int ; j := 0 ;
     var st : Sequence(int) ; st := Sequence{} ;
         var i : int ; i := 0 ; while i < len do ( (     st := st->append(pushed[i+1]) ; 
     while (not(st->isEmpty()) & j < len & st->min() = popped[j+1]) do (     st := st->front() ; 
     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return j = len );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var pushed : Sequence(int) ; pushed := Sequence{1,2,3,4,5} ;
     var popped : Sequence(int) ; popped := Sequence{4,5,3,2,1} ;
     var len : int ; len := pushed->size() ;
     OclFile["System.out"].println((if validateStackSequence(pushed, popped, len) then "True" else "False" endif)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test {
  public float computePrice(float h,float n,float c){
    int nbrBuns=(int)Math.ceil(h/n);
    return nbrBuns*c ;
  }
  public float computeNewHunger(float h,float d,float minutes){
    return(d*minutes)+h ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    float hh,mm ;
    hh=sc.nextInt();
    mm=sc.nextInt();
    float h,d,c,n ;
    h=sc.nextInt();
    d=sc.nextInt();
    c=sc.nextInt();
    n=sc.nextInt();
    Test test=new Test();
    float withoutDiscount,withDiscount ;
    if(hh>=20){
      withDiscount=test.computePrice(h,n,c)-((test.computePrice(h,n,c)*20)/100);
      System.out.println(withDiscount);
    }
    if(hh<20){
      float minutes=((20-hh-1)*60)+(60-mm);
      float newhunger=test.computeNewHunger(h,d,minutes);
      float discount=(test.computePrice(newhunger,n,c)*20)/100 ;
      withDiscount=test.computePrice(newhunger,n,c)-discount ;
      withoutDiscount=test.computePrice(h,n,c);
      System.out.println(withDiscount<withoutDiscount ? withDiscount : withoutDiscount);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
   operation computePrice( h : double, n : double, c : double) : double
  pre: true
  post: true
  activity: (     var nbrBuns : int ; nbrBuns := (h / n)->ceil()->oclAsType(int) ;
     return nbrBuns * c );
   operation computeNewHunger( h : double, d : double, minutes : double) : double
  pre: true
  post: true
  activity: (     return (d * minutes) + h );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var hh : double ;
    var mm : double ;
    hh := sc.getCurrent()->toInteger() ; 
    mm := sc.getCurrent()->toInteger() ; 
    var h : double ;
    var d : double ;
    var c : double ;
    var n : double ;
    h := sc.getCurrent()->toInteger() ; 
    d := sc.getCurrent()->toInteger() ; 
    c := sc.getCurrent()->toInteger() ; 
    n := sc.getCurrent()->toInteger() ; 
    var test : Test ; test := Test.newTest() ;
    var withoutDiscount : double ;
    var withDiscount : double ;
    if (hh >= 20) then (     withDiscount := test.computePrice(h, n, c) - ((test.computePrice(h, n, c) * 20) / 100) ; 
     OclFile["System.out"].println(withDiscount) ) else skip ; 
    if (hh < 20) then (     var minutes : double ; minutes := ((20 - hh - 1) * 60) + (60 - mm) ;
     var newhunger : double ; newhunger := test.computeNewHunger(h, d, minutes) ;
    var discount : double ; discount := (test.computePrice(newhunger, n, c) * 20) / 100 ;
    withDiscount := test.computePrice(newhunger, n, c) - discount ; 
    withoutDiscount := test.computePrice(h, n, c) ; 
    OclFile["System.out"].println(if withDiscount < withoutDiscount then withDiscount else withoutDiscount endif) ; 
 ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileInputStream ;
import java.io.FileNotFoundException ;
import java.util.Scanner ;
import java.lang.Math.*;
public class Oddness {
  private static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int hh=scanner.nextInt();
    int mm=scanner.nextInt();
    double inithunger=scanner.nextDouble();
    double increhunger=scanner.nextDouble();
    double cost=scanner.nextDouble();
    double discount=cost*0.8 ;
    double decrehunger=scanner.nextDouble();
    if(hh>=20)System.out.println(Math.ceil(inithunger/decrehunger)*discount);
    else {
      int min=(20-hh)*60-mm ;
      double finalhunger=min*increhunger+inithunger ;
      double finalcost=Math.ceil(finalhunger/decrehunger)*discount ;
      double initcost=Math.ceil(inithunger/decrehunger)*cost ;
      if(initcost<finalcost)System.out.println(initcost);
      else System.out.println(finalcost);
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Oddness {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var hh : int ; hh := scanner.getCurrent()->toInteger() ;
    var mm : int ; mm := scanner.getCurrent()->toInteger() ;
    var inithunger : double ; inithunger := scanner.getCurrent()->toReal() ;
    var increhunger : double ; increhunger := scanner.getCurrent()->toReal() ;
    var cost : double ; cost := scanner.getCurrent()->toReal() ;
    var discount : double ; discount := cost * 0.8 ;
    var decrehunger : double ; decrehunger := scanner.getCurrent()->toReal() ;
    if (hh >= 20) then     OclFile["System.out"].println((inithunger / decrehunger)->ceil() * discount) else (     var min : int ; min := (20 - hh) * 60 - mm ;
     var finalhunger : double ; finalhunger := min * increhunger + inithunger ;
    var finalcost : double ; finalcost := (finalhunger / decrehunger)->ceil() * discount ;
    var initcost : double ; initcost := (inithunger / decrehunger)->ceil() * cost ;
    if (initcost < finalcost) then     OclFile["System.out"].println(initcost) else     OclFile["System.out"].println(finalcost) ; ;  
 ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.text.DecimalFormat ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    FastReader reader=new FastReader();
    int hh=reader.nextInt(),mm=reader.nextInt();
    double h,d,c,n ;
    h=reader.nextInt();
    d=reader.nextInt();
    c=reader.nextInt();
    n=reader.nextInt();
    double fir=Math.ceil(h/n)*c ;
    double sec ;
    if(hh>=20){
      sec=Math.ceil(h/n)*c ;
    }
    else {
      int min=60-mm ;
      if(min<60){
        min+=(20-1-hh)*60 ;
      }
      else min+=(20-hh)*60-60 ;
      min*=d ;
      sec=Math.ceil((h+min)/n)*c ;
    }
    System.out.println(new DecimalFormat("#0.0000").format(Math.min(fir,sec*0.8)));
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var hh : int ; hh := reader.nextInt() ;
    var mm : int ; mm := reader.nextInt() ;
    var h : double ;
    var d : double ;
    var c : double ;
    var n : double ;
    h := reader.nextInt() ; 
    d := reader.nextInt() ; 
    c := reader.nextInt() ; 
    n := reader.nextInt() ; 
    var fir : double ; fir := (h / n)->ceil() * c ;
    var sec : double ;
    if (hh >= 20) then (     sec := (h / n)->ceil() * c ) else (     var min : int ; min := 60 - mm ;
     if (min < 60) then (     min := min+((20 - 1 - hh) * 60) ) else     min := min+((20 - hh) * 60 - 60) ; ;  
     min := min*(d) ; 
     sec := ((h + min) / n)->ceil() * c ) ;  
    OclFile["System.out"].println(DecimalFormat.newDecimalFormat("#0.0000").format(Set{fir, sec * 0.8}->min())) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean check(int n){
    int m=n ;
    while(n!=0){
      int r=n % 10 ;
      if(r>0)if((m % r)!=0)return false ;
      n/=10 ;
    }
    return true ;
  }
  static int count(int l,int r){
    int ans=0 ;
    for(int i=l ; i<=r ; i++)if(check(i))ans+=1 ;
    return ans ;
  }
  public static void main(String args[]){
    int l=10,r=20 ;
    System.out.println(count(10,20));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( n : int) : boolean
  pre: true
  post: true
  activity: (     var m : int ; m := n ;
     while (n /= 0) do (     var r : int ; r := n mod 10 ;
     if (r > 0) then     if ((m mod r) /= 0) then     return false else skip ; else skip ; 
     n := n/(10) ) ; 
     return true );
  static   operation count( l : int, r : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := l ; while i <= r do (     if (check(i)) then     ans := ans+(1) ; else skip ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 10 ;
    var r : int ; r := 20 ;
     OclFile["System.out"].println(count(10, 20)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class test {
  private static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int hh=sc.nextInt();
    int mm=sc.nextInt();
    int time=hh*60+mm ;
    int H=sc.nextInt();
    int D=sc.nextInt();
    int C=sc.nextInt();
    int N=sc.nextInt();
    if(time>=60*20){
      System.out.println((H+N-1)/N*C*0.8);
    }
    else {
      System.out.println(Math.min((H+N-1)/N*C,((60*20-time)*D+H+N-1)/N*C*0.8));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var hh : int ; hh := sc.getCurrent()->toInteger() ;
     var mm : int ; mm := sc.getCurrent()->toInteger() ;
    var time : int ; time := hh * 60 + mm ;
    var H : int ; H := sc.getCurrent()->toInteger() ;
    var D : int ; D := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    if (time >= 60 * 20) then (     OclFile["System.out"].println((H + N - 1) / N * C * 0.8) ) else (     OclFile["System.out"].println(Set{(H + N - 1) / N * C, ((60 * 20 - time) * D + H + N - 1) / N * C * 0.8}->min()) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
class GFG {
  public static double answer(double X,double K){
    double i=10 ;
    double MAX=Math.pow(i,K)-1 ;
    return(MAX-(MAX % X));
  }
  public static void main(String[] args){
    double X=30 ;
    double K=3 ;
    System.out.println((int)answer(X,K));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation answer( X : double, K : double) : double
  pre: true
  post: true
  activity: (     var i : double ; i := 10 ;
     var MAX : double ; MAX := i->pow(K) - 1 ;
     return (MAX - (MAX mod X)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : double ; X := 30 ;
     var K : double ; K := 3 ;
     OclFile["System.out"].println(answer(X, K)->oclAsType(int)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int INT_MAX=Integer.MAX_VALUE ;
  static int min_element(int[] A,int N){
    int min=A[0];
    int i ;
    for(i=1 ; i<N ; i++){
      if(min>A[i]){
        min=A[i];
      }
    }
    return min ;
  }
  static int countPartitions(int[] A,int N){
    int count=0 ;
    int i,j ;
    for(i=0 ; i<N ; i++){
      int min_elem=min_element(A,N);
      if(min_elem==INT_MAX)break ;
      count++;
      for(j=0 ; j<N ; j++){
        if(A[j] % min_elem==0)A[j]=INT_MAX ;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      7,6,5,4,3,2,2,3 };
      int N=arr.length ;
      System.out.println(countPartitions(arr,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute INT_MAX : int := 2147483647;
  static   operation min_element( A : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var min : int ; min := A[0+1] ;
     var i : int ;
         i := 1 ; while i < N do ( (     if (min > A[i+1]) then (     min := A[i+1] ) else skip )  ;     i := i + 1 ) ; 
     return min );
  static   operation countPartitions( A : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var i : int ;
    var j : int ;
         i := 0 ; while i < N do ( (     var min_elem : int ; min_elem := min_element(A, N) ;
     if (min_elem = INT_MAX) then     break else skip ; 
     count := count + 1 ; 
         j := 0 ; while j < N do ( (     if (A[j+1] mod min_elem = 0) then     A[j+1] := INT_MAX ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{7,6,5,4,3,2,2,3} ;
     var N : int ; N := arr->size() ;
     OclFile["System.out"].println(countPartitions(arr, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  int h=sc.nextInt();
  int w=sc.nextInt();
  int k=sc.nextInt();
  char[][] arr=new char[h][w];
  PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    for(int i=0 ; i<h ; i++){
      arr[i]=sc.next().toCharArray();
    }
    int ans=Integer.MAX_VALUE ;
    label : for(int i=0 ;
    i<1<<(h-1);
    i++){
      int[][] a=new int[h][w];
      int varH=0 ;
      int tmpAns=Integer.bitCount(i);
      for(int j=0 ; j<h ; j++){
        for(int l=0 ; l<w ; l++){
          a[varH][l]+=arr[j][l]-'0' ;
        }
        if((i>>j & 1)==1){
          varH++;
        }
      }
      int[] sum=new int[h];
      int front=0 ;
      for(int j=0 ; j<w ; j++){
        inner : for(int l=0 ;
        l<h ;
        l++){
          sum[l]+=a[l][j];
          if(sum[l]>k){
            if(j==front){
              continue label ;
            }
            front=j ;
            Arrays.fill(sum,0);
            tmpAns++;
            j--;
            break inner ;
          }
        }
      }
      ans=Math.min(ans,tmpAns);
    }
    out.println(ans);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute h : int := sc.getCurrent()->toInteger();
   attribute w : int := sc.getCurrent()->toInteger();
   attribute k : int := sc.getCurrent()->toInteger();
   attribute arr : Sequence(Sequence(String)) := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0));
   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < h do ( (     arr[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
     var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i < (1*(2->pow((h - 1))))->oclAsType(long) do ( (     var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
     var varH : int ; varH := 0 ;
    var tmpAns : int ; tmpAns := bitCount(i) ;
        var j : int ; j := 0 ; while j < h do ( (         var l : int ; l := 0 ; while l < w do ( (     a[varH+1][l+1] := a[varH+1][l+1]+(arr[j+1][l+1] - ('0')->char2byte()) )  ;     l := l + 1 ) ; 
     if ((MathLib.bitwiseAnd((i/(2->pow(j)))->oclAsType(long),1)) = 1) then (     varH := varH + 1 ) else skip )  ;     j := j + 1 ) ; 
    var sum : Sequence(int) ; sum := Integer.subrange(1,h)->collect(0) ;
    var front : int ; front := 0 ;
        var j : int ; j := 0 ; while j < w do ( (         var l : int ; l := 0 ; while l < h do ( (     sum[l+1] := sum[l+1]+(a[l+1][j+1]) ; 
     if (sum[l+1] > k) then (     if (j = front) then (     continue ) else skip ; 
     front := j ; 
    sum := sum->collect(0) ; 
    tmpAns := tmpAns + 1 ; 
    j := j - 1 ; 
    break 
 ) else skip )  ;     l := l + 1 ) ; )  ;     j := j + 1 ) ; 
    ans := Set{ans, tmpAns}->min() ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    int K=sc.nextInt();
    int[][] s=new int[H][W];
    for(int i=0 ; i<H ; i++){
      String S=sc.next();
      for(int j=0 ; j<W ; j++)s[i][j]=Character.getNumericValue(S.charAt(j));
    }
    int ans=100000 ;
    LOOP : for(int i=0 ;
    i<1<<H ;
    i++){
      int temp=0 ;
      int[][] x=new int[H][W];
      for(int j=0 ; j<H ; j++){
        for(int k=0 ; k<W ; k++)x[temp][k]+=s[j][k];
        if((1 & i>>j)==1)temp++;
      }
      int[] sum=new int[H];
      for(int j=0 ; j<W ; j++){
        for(int k=0 ; k<H ; k++){
          if(x[k][j]>K)continue LOOP ;
          sum[k]+=x[k][j];
          if(sum[k]>K){
            temp++;
            for(int l=0 ; l<H ; l++)sum[l]=x[l][j];
            break ;
          }
        }
      }
      ans=Math.min(ans,temp);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var s : Sequence(Sequence(int)) ; s := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var i : int ; i := 0 ; while i < H do ( (     var S : String ; S := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < W do (     s[i+1][j+1] := ("" + S->at(j+1))->toInteger() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 100000 ;
        var i : int ; i := 0 ; while i < (1*(2->pow(H)))->oclAsType(long) do ( (     var temp : int ; temp := 0 ;
     var x : Sequence(Sequence(int)) ; x := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var j : int ; j := 0 ; while j < H do ( (         var k : int ; k := 0 ; while k < W do (     x[temp+1][k+1] := x[temp+1][k+1]+(s[j+1][k+1]) ;  ;     k := k + 1 ) ; 
     if ((MathLib.bitwiseAnd(1,(i/(2->pow(j)))->oclAsType(long))) = 1) then     temp := temp + 1 ; else skip )  ;     j := j + 1 ) ; 
    var sum : Sequence(int) ; sum := Integer.subrange(1,H)->collect(0) ;
        var j : int ; j := 0 ; while j < W do ( (         var k : int ; k := 0 ; while k < H do ( (     if (x[k+1][j+1] > K) then     continue else skip ; 
     sum[k+1] := sum[k+1]+(x[k+1][j+1]) ; 
     if (sum[k+1] > K) then (     temp := temp + 1 ; 
         var l : int ; l := 0 ; while l < H do (     sum[l+1] := x[l+1][j+1] ;  ;     l := l + 1 ) ; 
     break ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    ans := Set{ans, temp}->min() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class Main {
  public static ArrayList<Integer>linkList[][];
  public static int dists[];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    linkList=new ArrayList[N+1][2];
    dists=new int[N+1];
    for(int i=0 ; i<N+1 ; i++){
      dists[i]=Integer.MIN_VALUE ;
      linkList[i][0]=new ArrayList<Integer>();
      linkList[i][1]=new ArrayList<Integer>();
    }
    for(int i=0 ; i<M ; i++){
      int l=sc.nextInt();
      int r=sc.nextInt();
      int d=sc.nextInt();
      linkList[l][0] .add(r);
      linkList[l][1] .add(d);
      linkList[r][0] .add(l);
      linkList[r][1] .add(-d);
    }
    for(int i=0 ; i<N ; i++){
      if(dists[i]!=Integer.MIN_VALUE)continue ;
      if(! dfs(i,0)){
        System.out.println("No");
        return ;
      }
    }
    System.out.println("Yes");
  }
  public static boolean dfs(int i,int dist){
    if(dists[i]!=Integer.MIN_VALUE)return dists[i]==dist ;
    dists[i]=dist ;
    for(int j=0 ; j<linkList[i][0] .size(); j++){
      if(! dfs(linkList[i][0] .get(j),dist+linkList[i][1] .get(j)))return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute linkList : Sequence(Sequence(Sequence(int)));
  static   attribute dists : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    linkList := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,2)->collect(null)) ; 
    dists := Integer.subrange(1,N + 1)->collect(0) ; 
        var i : int ; i := 0 ; while i < N + 1 do ( (     dists[i+1] := -2147483648 ; 
     linkList[i+1][0+1] := Sequence{} ; 
     linkList[i+1][1+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    linkList[l+1][0+1]->excludes(r) ; 
    linkList[l+1][1+1]->excludes(d) ; 
    linkList[r+1][0+1]->excludes(l) ; 
    linkList[r+1][1+1]->excludes(-d) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (dists[i+1] /= -2147483648) then     continue else skip ; 
     if (not(dfs(i, 0))) then (     OclFile["System.out"].println("No") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Yes") ; 
 );
  static   operation dfs( i : int, dist : int) : boolean
  pre: true
  post: true
  activity: (     if (dists[i+1] /= -2147483648) then     return dists[i+1] = dist else skip ; 
     dists[i+1] := dist ; 
         var j : int ; j := 0 ; while j < linkList[i+1][0+1]->size() do ( (     if (not(dfs(linkList[i+1][0+1]->at(j+1), dist + linkList[i+1][1+1]->at(j+1)))) then     return false else skip )  ;     j := j + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean checkSubarraySum(int[] arr,int n,int k,int sum){
    int curr_sum=0 ;
    for(int i=0 ; i<k ; i++)curr_sum+=arr[i];
    if(curr_sum==sum)return true ;
    for(int j=k ; j<n ; j++){
      curr_sum=curr_sum+arr[j]-arr[j-k];
      if(curr_sum==sum)return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    int[] arr=new int[] {
      1,4,2,10,2,3,1,0,20 };
      int k=4 ;
      int sum=18 ;
      int n=arr.length ;
      if(checkSubarraySum(arr,n,k,sum))System.out.println("YES");
      else System.out.println("NO");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkSubarraySum( arr : Sequence(int), n : int, k : int, sum : int) : boolean
  pre: true
  post: true
  activity: (     var curr_sum : int ; curr_sum := 0 ;
         var i : int ; i := 0 ; while i < k do (     curr_sum := curr_sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    if (curr_sum = sum) then     return true else skip ; 
        var j : int ; j := k ; while j < n do ( (     curr_sum := curr_sum + arr[j+1] - arr[j - k+1] ; 
     if (curr_sum = sum) then     return true else skip )  ;     j := j + 1 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,4,2,10,2,3,1,0,20} ;
     var k : int ; k := 4 ;
    var sum : int ; sum := 18 ;
    var n : int ; n := arr->size() ;
    if (checkSubarraySum(arr, n, k, sum)) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean checkSubarraySum(int arr[],int n,int k,int sum){
    for(int i=0 ; i<n-k+1 ; i++){
      int current_sum=0 ;
      for(int j=0 ; j<k ; j++)current_sum=current_sum+arr[i+j];
      if(current_sum==sum)return true ;
    }
    return false ;
  }
  public static void main(String args[]){
    int arr[]=new int[] {
      1,4,2,10,2,3,1,0,20 };
      int k=4 ;
      int sum=18 ;
      int n=arr.length ;
      if(checkSubarraySum(arr,n,k,sum))System.out.println("YES");
      else System.out.println("NO");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkSubarraySum( arr : Sequence(int), n : int, k : int, sum : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n - k + 1 do ( (     var current_sum : int ; current_sum := 0 ;
         var j : int ; j := 0 ; while j < k do (     current_sum := current_sum + arr[i + j+1] ;  ;     j := j + 1 ) ; 
     if (current_sum = sum) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,4,2,10,2,3,1,0,20} ;
     var k : int ; k := 4 ;
    var sum : int ; sum := 18 ;
    var n : int ; n := arr->size() ;
    if (checkSubarraySum(arr, n, k, sum)) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class C {
  void p(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    for(int zz=1 ; zz<=T ; zz++){
      C=sc.nextInt();
      N=sc.nextInt();
      dp=new double[C+1];
      Arrays.fill(dp,-1.0);
      System.out.println("Case #"+zz+": "+dp(0));
    }
  }
  static int C,N ;
  static double[] dp ;
  public static double dp(int numDiff){
    if(numDiff>=C)return 0.0 ;
    if(dp[numDiff]!=-1.0)return dp[numDiff];
    double pr0=((double)choose(numDiff,N))/choose(C,N);
    double ev=0.0 ;
    for(int i=1 ; i<=N ; i++){
      ev+=(1.0+dp(numDiff+i))*(((double)choose(numDiff,N-i)*choose(C-numDiff,i)))/(choose(C,N));
    }
    double ans=(pr0+ev)/(1-pr0);
    dp[numDiff]=ans ;
    return ans ;
  }
  public static long choose(int n,int k){
    long ans=1 ;
    ArrayList<Integer>toDiv=new ArrayList<Integer>();
    for(int i=2 ; i<=k ; i++)toDiv.add(i);
    for(int i=n ; i>=n-k+1 ; i--){
      ans*=i ;
      for(int j=0 ; j<toDiv.size(); j++){
        if(ans % toDiv.get(j)==0){
          ans/=toDiv.get(j);
          toDiv.remove(j);
          j--;
        }
      }
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
   operation p( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var zz : int ; zz := 1 ; while zz <= T do ( (     C := sc.getCurrent()->toInteger() ; 
     N := sc.getCurrent()->toInteger() ; 
    dp := Integer.subrange(1,C + 1)->collect(0.0) ; 
    dp := dp->collect(-1.0) ; 
    OclFile["System.out"].println("Case #" + zz + ": " + dp(0)) ; 
 )  ;     zz := zz + 1 ) );
  static   attribute C : int;
  static   attribute dp : Sequence(double);
  static   operation dp( numDiff : int) : double
  pre: true
  post: true
  activity: (     if (numDiff >= C) then     return 0.0 else skip ; 
     if (dp[numDiff+1] /= -1.0) then     return dp[numDiff+1] else skip ; 
    var pr0 : double ; pr0 := (choose(numDiff, N)->oclAsType(double)) / choose(C, N) ;
    var ev : double ; ev := 0.0 ;
        var i : int ; i := 1 ; while i <= N do ( (     ev := ev+((1.0 + dp(numDiff + i)) * ((choose(numDiff, N - i)->oclAsType(double) * choose(C - numDiff, i))) / (choose(C, N))) )  ;     i := i + 1 ) ; 
    var ans : double ; ans := (pr0 + ev) / (1 - pr0) ;
    dp[numDiff+1] := ans ; 
    return ans 
 );
  static   operation choose( n : int, k : int) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
     var toDiv : Sequence(int) ; toDiv := Sequence{} ;
        var i : int ; i := 2 ; while i <= k do (     toDiv := toDiv->including(i) ;  ;     i := i + 1 ) ; 
        var i : int ; i := n ; while i >= n - k + 1 do ( (     ans := ans*(i) ; 
         var j : int ; j := 0 ; while j < toDiv->size() do ( (     if (ans mod toDiv->at(j+1) = 0) then (     ans := ans/(toDiv->at(j+1)) ; 
     toDiv := toDiv->excludingAt(j+1) ; 
     j := j - 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class x {
  public static void main(String args[])throws Exception {
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    long[][] C=new long[41][41];
    for(int i=0 ; i<=40 ; i++){
      C[i][0]=1 ;
      for(int j=1 ; j<=i ; j++)C[i][j]=C[i-1][j]+C[i-1][j-1];
    }
    MathContext mc=new MathContext(50,RoundingMode.HALF_EVEN);
    for(int tt=1 ; tt<=t ; tt++){
      int A=in.nextInt(),N=in.nextInt();
      BigDecimal[] E=new BigDecimal[A+1];
      E[A]=new BigDecimal(0,mc);
      for(int i=A-1 ; i>=0 ; i--){
        E[i]=new BigDecimal(C[A][N],mc);
        for(int j=i+1 ; j<=Math.min(A,i+N); j++){
          BigDecimal P=new BigDecimal(C[A-i][j-i],mc);
          P=P.multiply(new BigDecimal(C[i][N-j+i],mc),mc);
          E[i]=E[i] .add(P.multiply(E[j],mc),mc);
        }
        BigDecimal D=new BigDecimal(C[A][N],mc).subtract(new BigDecimal(C[i][N],mc),mc);
        E[i]=E[i] .divide(D,mc);
      }
      System.out.println("Case #"+tt+": "+E[0]);
    };
  };
};
------------------------------------------------------------
OCL File:
---------
 class x {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var C : Sequence(Sequence(long)) ; C := Integer.subrange(1,41)->collect(Integer.subrange(1,41)->collect(0)) ;
        var i : int ; i := 0 ; while i <= 40 do ( (     C[i+1][0+1] := 1 ; 
         var j : int ; j := 1 ; while j <= i do (     C[i+1][j+1] := C[i - 1+1][j+1] + C[i - 1+1][j - 1+1] ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var mc : MathContext ; mc := MathContext.newMathContext(50, RoundingMode.HALF_EVEN) ;
        var tt : int ; tt := 1 ; while tt <= t do ( (     var A : int ; A := in.getCurrent()->toInteger() ;
    var N : int ; N := in.getCurrent()->toInteger() ;
     var E : Sequence(double) ; E := Integer.subrange(1,A + 1)->collect(null) ;
    E[A+1] := double(0, mc) ; 
        var i : int ; i := A - 1 ; while i >= 0 do ( (     E[i+1] := double(C[A+1][N+1], mc) ; 
         var j : int ; j := i + 1 ; while j <= Set{A, i + N}->min() do ( (     var P : double ; P := double(C[A - i+1][j - i+1], mc) ;
     P := P.multiply(double(C[i+1][N - j + i+1], mc), mc) ; 
     E[i+1] := E[i+1]->excludes(P.multiply(E[j+1], mc), mc) )  ;     j := j + 1 ) ; 
     var D : double ; D := double(C[A+1][N+1], mc).subtract(double(C[i+1][N+1], mc), mc) ;
     E[i+1] := E[i+1].divide(D, mc) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println("Case #" + tt + ": " + E[0+1]) ; 
 )  ;     tt := tt + 1 ) ; 
 );
}
;

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MainClass {
  public static void main(String[] agrs){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(a==b){
      System.out.println(a*10+1+" "+(a*10+2));
    }
    else if(a+1==b){
      System.out.println(a+" "+b);
    }
    else if(a+1==b*10)System.out.println(a+" "+b*10);
    else System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (a = b) then (     OclFile["System.out"].println(a * 10 + 1 + " " + (a * 10 + 2)) ) else     if (a + 1 = b) then (     OclFile["System.out"].println(a + " " + b) ) else     if (a + 1 = b * 10) then     OclFile["System.out"].println(a + " " + b * 10) else     OclFile["System.out"].println(-1) ; ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class C {
  public static void main(String[] args)throws Exception {
    new C();
  }
  final int oo=(int)1e9 ;
  double[][] choose=new double[50][50];
  int N,C ;
  double D ;
  double[] memo=new double[50];
  C()throws Exception {
    for(double[] c : choose)Arrays.fill(c,-1);
    Scanner in=new Scanner(System.in);
    for(int T=in.nextInt(),ds=1 ; T-->0 ; ++ds){
      C=in.nextInt();
      N=in.nextInt();
      D=choose(C,N);
      Arrays.fill(memo,-1);
      System.out.printf("Case #%d: %.9f%n",ds,go(0));
    }
  }
  double go(int X){
    if(X==C)return 0 ;
    if(memo[X]>-0.5)return memo[X];
    double exp=1 ;
    for(int i=1 ; i<=N ; ++i){
      if(X+i>C)break ;
      exp+=choose(X,N-i)*choose(C-X,i)/D*go(X+i);
    }
    exp/=(1-choose(X,N)*choose(C-X,0)/D);
    return memo[X]=exp ;
  }
  double choose(int n,int k){
    if(k==0 || n==k)return 1 ;
    if(n<k)return 0 ;
    if(choose[n][k]>-0.5)return choose[n][k];
    return choose[n][k]=choose(n-1,k-1)+choose(n-1,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( C.newC() );
   attribute oo : int := 1e9->oclAsType(int);
   attribute choose : Sequence(Sequence(double)) := Integer.subrange(1,50)->collect(Integer.subrange(1,50)->collect(0.0));
   attribute N : int;
   attribute D : double;
   attribute memo : Sequence(double) := Integer.subrange(1,50)->collect(0.0);
   static operation newC() : C
  pre: true
  post: true
  activity:
  ( var self : C ;
    self := createC();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     for (c : choose) do (     c := c->collect(-1) ;  ) ; 
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var T : int ; T := in.getCurrent()->toInteger() ;
    var ds : int ; ds := 1 ; while T > 0 do ( (     C := in.getCurrent()->toInteger() ; 
     N := in.getCurrent()->toInteger() ; 
    D := choose(C, N) ; 
    memo := memo->collect(-1) ; 
    OclFile["System.out"].printf("Case #%d: %.9f%n", ds, go(0)) ; 
 )  ;     ds := ds + 1 ) );
   operation go( X : int) : double
  pre: true
  post: true
  activity: (     if (X = C) then     return 0 else skip ; 
     if (memo[X+1] > -0.5) then     return memo[X+1] else skip ; 
    var exp : double ; exp := 1 ;
        var i : int ; i := 1 ; while i <= N do ( (     if (X + i > C) then     break else skip ; 
     exp := exp+(choose(X, N - i) * choose(C - X, i) / D * go(X + i)) )  ;     i := i + 1 ) ; 
    exp := exp/((1 - choose(X, N) * choose(C - X, 0) / D)) ; 
    return memo[X+1] 
 );
   operation choose( n : int, k : int) : double
  pre: true
  post: true
  activity: (     if (k = 0 or n = k) then     return 1 else skip ; 
     if (n < k) then     return 0 else skip ; 
     if (choose[n+1][k+1] > -0.5) then     return choose[n+1][k+1] else skip ; 
     return choose[n+1][k+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class C {
  private static String PNAME="C-large" ;
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new FileReader(PNAME+".in"));
    PrintStream out=new PrintStream(PNAME+".out");
    Scanner in=new Scanner(br);
    int TC=in.nextInt();
    for(int tc=1 ; tc<=TC ; tc++){
      int c=in.nextInt();
      int n=in.nextInt();
      out.println("Case #"+tc+": "+solve(c,n));
    }
    br.close();
    out.close();
  }
  private static double solve(int c,int n){
    for(int i=0 ; i<memo.length ; i++)memo[i]=-1 ;
    return calc(c,n,c);
  }
  private static double calc(int c,int n,int need){
    if(need==0)return 0 ;
    if(memo[need]!=-1)return memo[need];
    double ret=1 ;
    int have=c-need ;
    for(int good=1 ; good<=Math.min(n,need); good++){
      int bad=n-good ;
      double p=choose(need,good);
      p*=choose(have,bad);
      p/=choose(c,n);
      ret+=p*calc(c,n,need-good);
    }
    if(have>=n){
      double p=choose(have,n)*1.0/choose(c,n);
      ret/=1-p ;
    }
    memo[need]=ret ;
    return ret ;
  }
  private static long choose(int n,int k){
    long ret=1 ;
    for(int i=0 ; i<k ; i++){
      ret*=n-i ;
      ret/=i+1 ;
    }
    return ret ;
  }
  static double[] memo=new double[64];
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   attribute PNAME : String := "C-large";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(PNAME + ".in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(PNAME + ".out") ;
    var in : OclFile ; in := OclFile.newOclFile_Read(br) ;
    var TC : int ; TC := in.getCurrent()->toInteger() ;
        var tc : int ; tc := 1 ; while tc <= TC do ( (     var c : int ; c := in.getCurrent()->toInteger() ;
     var n : int ; n := in.getCurrent()->toInteger() ;
     skip )  ;     tc := tc + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( c : int, n : int) : double
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < memo->size() do (     memo[i+1] := -1 ;  ;     i := i + 1 ) ; 
     return calc(c, n, c) );
  static   operation calc( c : int, n : int, need : int) : double
  pre: true
  post: true
  activity: (     if (need = 0) then     return 0 else skip ; 
     if (memo[need+1] /= -1) then     return memo[need+1] else skip ; 
    var ret : double ; ret := 1 ;
    var have : int ; have := c - need ;
        var good : int ; good := 1 ; while good <= Set{n, need}->min() do ( (     var bad : int ; bad := n - good ;
     var p : double ; p := choose(need, good) ;
    p := p*(choose(have, bad)) ; 
    p := p/(choose(c, n)) ; 
    ret := ret+(p * calc(c, n, need - good)) ; 
 )  ;     good := good + 1 ) ; 
    if (have >= n) then (     var p : double ; p := choose(have, n) * 1.0 / choose(c, n) ;
     ret := ret/(1 - p) ) else skip ; 
    memo[need+1] := ret ; 
    return ret 
 );
  static   operation choose( n : int, k : int) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := 1 ;
         var i : int ; i := 0 ; while i < k do ( (     ret := ret*(n - i) ; 
     ret := ret/(i + 1) )  ;     i := i + 1 ) ; 
     return ret );
  static   attribute memo : Sequence(double) := Integer.subrange(1,64)->collect(0.0);
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAXN=100 ;
  static int maxValue(int n,int m,int x[],int y[],int a[]){
    int c[][]=new int[MAXN][MAXN];
    for(int i=0 ; i<m ; ++i){
      for(int p=0 ; p<n ; ++p){
        for(int q=0 ; q<n ; ++q){
          int dx=Math.abs(p-x[i]);
          int dy=Math.abs(q-y[i]);
          int d=Math.max(dx,dy);
          c[p][q]+=Math.max(0,a[i]-d);
        }
      }
    }
    int res=0 ;
    for(int i=0 ; i<n ; ++i){
      for(int j=0 ; j<n ; ++j){
        res=Math.max(res,c[i][j]);
      }
    }
    return res ;
  }
  public static void main(String[] args){
    int n=10 ;
    int m=2 ;
    int x[]={
      3,7 };
      int y[]={
        3,7 };
        int a[]={
          4,3 };
          System.out.println(maxValue(n,m,x,y,a));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAXN : int := 100;
  static   operation maxValue( n : int, m : int, x : Sequence(int), y : Sequence(int), a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,MAXN)->collect(Integer.subrange(1,MAXN)->collect(0)) ;
         var i : int ; i := 0 ; while i < m do ( (         var p : int ; p := 0 ; while p < n do ( (         var q : int ; q := 0 ; while q < n do ( (     var dx : int ; dx := if p - x[i+1] < 0 then -(p - x[i+1]) else p - x[i+1] endif ;
     var dy : int ; dy := if q - y[i+1] < 0 then -(q - y[i+1]) else q - y[i+1] endif ;
     var d : int ; d := Set{dx, dy}->max() ;
     c[p+1][q+1] := c[p+1][q+1]+(Set{0, a[i+1] - d}->max()) )  ;     q := q + 1 ) )  ;     p := p + 1 ) )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     res := Set{res, c[i+1][j+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     var m : int ; m := 2 ;
    var x : Sequence(int) ; x := Sequence{3,7} ;
    var y : Sequence(int) ; y := Sequence{3,7} ;
    var a : Sequence(int) ; a := Sequence{4,3} ;
    OclFile["System.out"].println(maxValue(n, m, x, y, a)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxSize=50 ;
  static double dp[]=new double[maxSize];
  static int v[]=new int[maxSize];
  static double expectedSteps(int x){
    if(x==0)return 0 ;
    if(x<=5)return 6 ;
    if(v[x]==1)return dp[x];
    v[x]=1 ;
    dp[x]=1+(expectedSteps(x-1)+expectedSteps(x-2)+expectedSteps(x-3)+expectedSteps(x-4)+expectedSteps(x-5)+expectedSteps(x-6))/6 ;
    return dp[x];
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(expectedSteps(n-1));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute maxSize : int := 50;
  static   attribute dp : double := Integer.subrange(1,maxSize)->collect(0.0);
  static   attribute v : int := Integer.subrange(1,maxSize)->collect(0);
  static   operation expectedSteps( x : int) : double
  pre: true
  post: true
  activity: (     if (x = 0) then     return 0 else skip ; 
     if (x <= 5) then     return 6 else skip ; 
    if (v[x+1] = 1) then     return dp[x+1] else skip ; 
    v[x+1] := 1 ; 
    dp[x+1] := 1 + (expectedSteps(x - 1) + expectedSteps(x - 2) + expectedSteps(x - 3) + expectedSteps(x - 4) + expectedSteps(x - 5) + expectedSteps(x - 6)) / 6 ; 
    return dp[x+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(expectedSteps(n - 1)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static FastReader sc=null ;
  public static void main(String[] args){
    sc=new FastReader();
    int n=sc.nextInt();
    int a[]=sc.readArray(n);
    int ans=0 ;
    for(int i=0 ; i+1<n ; i++){
      if(a[i]+a[i+1]==5){
        System.out.println("Infinite");
        return ;
      }
      if(i+2<n && a[i]!=a[i+2] && a[i]==3)ans--;
      ans+=Math.max(a[i],a[i+1])+1 ;
    }
    System.out.println("Finite");
    System.out.println(ans);
  }
  static int[] ruffleSort(int a[]){
    ArrayList<Integer>al=new ArrayList<>();
    for(int i : a)al.add(i);
    Collections.sort(al);
    for(int i=0 ; i<a.length ; i++)a[i]=al.get(i);
    return a ;
  }
  static void print(int a[]){
    for(int e : a){
      System.out.print(e+" ");
    }
    System.out.println();
  }
  static class FastReader {
    StringTokenizer st=new StringTokenizer("");
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String next(){
      while(! st.hasMoreTokens())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());
    }
    int[] readArray(int n){
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : FastReader := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := FastReader.newFastReader() ; 
     var n : int ; n := sc.nextInt() ;
    var a : Sequence(int) ; a := sc.readArray(n) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i + 1 < n do ( (     if (a[i+1] + a[i + 1+1] = 5) then (     OclFile["System.out"].println("Infinite") ; 
     return ) else skip ; 
     if (i + 2 < n & a[i+1] /= a[i + 2+1] & a[i+1] = 3) then     ans := ans - 1 ; else skip ; 
     ans := ans+(Set{a[i+1], a[i + 1+1]}->max() + 1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Finite") ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation ruffleSort( a : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var al : Sequence(int) ; al := Sequence{} ;
     for (i : a) do (     al := al->including(i) ;  ) ; 
    al := al->sort() ; 
        var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := al->at(i+1) ;  ;     i := i + 1 ) ; 
    return a 
 );
  static   operation print( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     for (e : a) do ( (     OclFile["System.out"].print(e + " ") )  ) ; 
     OclFile["System.out"].println() );
  static class FastReader {
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A1156 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    int sum=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if(arr[i]+arr[i+1]==5){
        System.out.println("Infinite");
        return ;
      }
      sum+=arr[i]+arr[i+1];
    }
    for(int i=0 ; i<n-2 ; i++){
      if(arr[i]==3 && arr[i+1]==1 && arr[i+2]==2)sum-=1 ;
    }
    System.out.println("Finite");
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1156 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] + arr[i + 1+1] = 5) then (     OclFile["System.out"].println("Infinite") ; 
     return ) else skip ; 
     sum := sum+(arr[i+1] + arr[i + 1+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 2 do ( (     if (arr[i+1] = 3 & arr[i + 1+1] = 1 & arr[i + 2+1] = 2) then     sum := sum-(1) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Finite") ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String reverse(String input){
    char[] a=input.toCharArray();
    int l,r=0 ;
    r=a.length-1 ;
    for(l=0 ; l<r ; l++,r--){
      char temp=a[l];
      a[l]=a[r];
      a[r]=temp ;
    }
    return String.valueOf(a);
  }
  static boolean isPalindrome(String r){
    String p=r ;
    p=reverse(p);
    return(r.equals(p));
  }
  static boolean CheckStr(String s){
    int l=s.length();
    int i ;
    for(i=2 ; i<=l ; i++){
      if(isPalindrome(s.substring(0,i))){
        break ;
      }
    }
    if(i==(l+1)){
      return false ;
    }
    i=2 ;
    for(i=2 ; i<=l ; i++){
      if(isPalindrome(s.substring(l-i,l))){
        return true ;
      }
    }
    return false ;
  }
  public static void main(String args[]){
    String s="abccbarfgdbd" ;
    if(CheckStr(s)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation reverse( input : String) : String
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := input->characters() ;
     var l : int ;
    var r : int ; r := 0 ;
    r := a->size() - 1 ; 
        l := 0 ; while l < r do ( (     var temp : String ; temp := a[l+1] ;
     a[l+1] := a[r+1] ; 
     a[r+1] := temp )  ;     l := l + 1 ;     r := r - 1 ) ; 
    return (a)->sum()  
 );
  static   operation isPalindrome( r : String) : boolean
  pre: true
  post: true
  activity: (     var p : String ; p := r ;
     p := reverse(p) ; 
     return (r = p) );
  static   operation CheckStr( s : String) : boolean
  pre: true
  post: true
  activity: (     var l : int ; l := s->size() ;
     var i : int ;
        i := 2 ; while i <= l do ( (     if (isPalindrome(s.subrange(0+1,i))) then (     break ) else skip )  ;     i := i + 1 ) ; 
    if (i = (l + 1)) then (     return false ) else skip ; 
    i := 2 ; 
        i := 2 ; while i <= l do ( (     if (isPalindrome(s.subrange((l)->char2byte() - i+1,l))) then (     return true ) else skip )  ;     i := i + 1 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abccbarfgdbd" ;
     if (CheckStr(s)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A1156 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    int sum=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if(arr[i]+arr[i+1]==5){
        System.out.println("Infinite");
        return ;
      }
      sum+=arr[i]+arr[i+1];
    }
    for(int i=0 ; i<n-2 ; i++){
      if(arr[i]==3 && arr[i+1]==1 && arr[i+2]==2)sum-=1 ;
    }
    System.out.println("Finite");
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1156 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] + arr[i + 1+1] = 5) then (     OclFile["System.out"].println("Infinite") ; 
     return ) else skip ; 
     sum := sum+(arr[i+1] + arr[i + 1+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 2 do ( (     if (arr[i+1] = 3 & arr[i + 1+1] = 1 & arr[i + 2+1] = 2) then     sum := sum-(1) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Finite") ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class InscribedFigures {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    String[] temp=br.readLine().split(" ");
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=Integer.parseInt(temp[i]);
    }
    int res=0 ;
    int countTriple=0 ;
    for(int i=2 ; i<n ; i++){
      if(i>=2 && nums[i]==2 && nums[i-1]==1 && nums[i-2]==3){
        countTriple++;
      }
    }
    for(int i=0 ; i<n-1 ; i++){
      int sum=nums[i]+nums[i+1];
      if(sum==5){
        pr.println("Infinite");
        return ;
      }
      else if(sum==4){
        res+=4 ;
      }
      else if(sum==3){
        res+=3 ;
      }
    }
    pr.println("Finite");
    pr.println(res-countTriple);
  }
}
------------------------------------------------------------
OCL File:
---------
 class InscribedFigures {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := (temp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    var countTriple : int ; countTriple := 0 ;
        var i : int ; i := 2 ; while i < n do ( (     if (i >= 2 & nums[i+1] = 2 & nums[i - 1+1] = 1 & nums[i - 2+1] = 3) then (     countTriple := countTriple + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var sum : int ; sum := nums[i+1] + nums[i + 1+1] ;
     if (sum = 5) then (     skip ; 
     return ) else     if (sum = 4) then (     res := res+(4) ) else     if (sum = 3) then (     res := res+(3) ) else skip ; ;  )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class B_822 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    sc.nextLine();
    String s=sc.nextLine();
    String t=sc.nextLine();
    int[] l=new int[m-n+1];
    String[] loc=new String[m-n+1];
    Arrays.fill(loc,"");
    for(int i=0 ; i<=m-n ; i++){
      int c=0 ;
      for(int j=i ; j<n+i ; j++){
        if(t.charAt(j)!=s.charAt(c)){
          l[i]++;
          loc[i]+=String.valueOf(c+1)+" " ;
        }
        c++;
      }
    }
    int min_ind=0 ;
    for(int i=0 ; i<=m-n ; i++){
      if(l[min_ind]>l[i])min_ind=i ;
    }
    System.out.println(l[min_ind]);
    System.out.println(loc[min_ind]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_822 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    skip ; 
    var s : String ; s := sc.nextLine() ;
    var t : String ; t := sc.nextLine() ;
    var l : Sequence(int) ; l := Integer.subrange(1,m - n + 1)->collect(0) ;
    var loc : Sequence(String) ; loc := Integer.subrange(1,m - n + 1)->collect(null) ;
    loc := loc->collect("") ; 
        var i : int ; i := 0 ; while i <= m - n do ( (     var c : int ; c := 0 ;
         var j : int ; j := i ; while j < n + i do ( (     if (t->at(j+1) /= s->at(c+1)) then (     l[i+1] := l[i+1] + 1 ; 
     loc[i+1] := loc[i+1]+(((c + 1) + "") + " ") ) else skip ; 
     c := c + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var min_ind : int ; min_ind := 0 ;
        var i : int ; i := 0 ; while i <= m - n do ( (     if (l[min_ind+1] > l[i+1]) then     min_ind := i ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(l[min_ind+1]) ; 
    OclFile["System.out"].println(loc[min_ind+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner input=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int da=input.nextInt();
    int db=input.nextInt();
    if((da>db && da!=9)||(db-da)>1){
      out.println(-1);
    }
    else if(da!=9){
      if((db-da)==1){
        out.println(da+" "+db);
      }
      else {
        out.println(da+"1 "+db+"2");
      }
    }
    if(da==9){
      if(db==1){
        out.println("9 10");
      }
      else if(db==9){
        out.println(da+"1 "+db+"2");
      }
      else {
        out.println(-1);
      }
    }
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var da : int ; da := input.getCurrent()->toInteger() ;
    var db : int ; db := input.getCurrent()->toInteger() ;
    if ((da > db & da /= 9) or (db - da) > 1) then (     skip ) else     if (da /= 9) then (     if ((db - da) = 1) then (     skip ) else (     skip ) ) else skip ; ;  
    if (da = 9) then (     if (db = 1) then (     skip ) else     if (db = 9) then (     skip ) else (     skip ) ;  ) else skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class trailzero {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    String s1=sc.next();
    String s2=sc.next();
    int msum=Integer.MAX_VALUE ;
    int index=0 ;
    for(int i=0 ; i<m-n+1 ; i++){
      int sum=0 ;
      for(int j=0 ; j<n ; j++){
        if(s2.charAt(j+i)!=s1.charAt(j)){
          sum++;
        }
      }
      if(sum<msum){
        msum=sum ;
        index=i ;
      }
    }
    System.out.println(msum);
    if(msum!=0){
      for(int j=0 ; j<n ; j++){
        if(s2.charAt(j+index)!=s1.charAt(j)){
          System.out.print((j+1)+" ");
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class trailzero {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var s1 : String ; s1 := sc.getCurrent() ;
    var s2 : String ; s2 := sc.getCurrent() ;
    var msum : int ; msum := 2147483647 ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < m - n + 1 do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (s2->at(j + i+1) /= s1->at(j+1)) then (     sum := sum + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (sum < msum) then (     msum := sum ; 
     index := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(msum) ; 
    if (msum /= 0) then (         var j : int ; j := 0 ; while j < n do ( (     if (s2->at(j + index+1) /= s1->at(j+1)) then (     OclFile["System.out"].print((j + 1) + " ") ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Objects ;
import java.util.Scanner ;
public class Main {
  public static void check(String[] a,String[] b){
    int flag=0 ;
    int k=0 ;
    int min=0 ;
    int Case=0 ;
    int mink=0 ;
    for(int i=0 ; i<b.length-a.length+1 ; i++){
      k=i ;
      for(int j=0 ; j<a.length ; j++){
        if(! Objects.equals(b[k],a[j])){
          flag++;
        }
        k++;
      }
      k=i ;
      if(Case==0){
        min=flag ;
        Case++;
      }
      if(flag<min){
        min=flag ;
        mink=k ;
      }
      flag=0 ;
    }
    System.out.println(min);
    for(int p=0 ; p<a.length ; p++){
      if(! Objects.equals(b[mink],a[p])){
        System.out.printf("%d ",p+1);
      }
      mink++;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    String a=sc.next();
    String b=sc.next();
    String[] A=a.split("");
    String[] B=b.split("");
    check(A,B);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation check( a : Sequence(String), b : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var flag : int ; flag := 0 ;
     var k : int ; k := 0 ;
    var min : int ; min := 0 ;
    var Case : int ; Case := 0 ;
    var mink : int ; mink := 0 ;
        var i : int ; i := 0 ; while i < b->size() - a->size() + 1 do ( (     k := i ; 
         var j : int ; j := 0 ; while j < a->size() do ( (     if (not(Objects = b[k+1], a[j+1])) then (     flag := flag + 1 ) else skip ; 
     k := k + 1 )  ;     j := j + 1 ) ; 
    k := i ; 
    if (Case = 0) then (     min := flag ; 
     Case := Case + 1 ) else skip ; 
    if (flag < min) then (     min := flag ; 
     mink := k ) else skip ; 
    flag := 0 ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
        var p : int ; p := 0 ; while p < a->size() do ( (     if (not(Objects = b[mink+1], a[p+1])) then (     OclFile["System.out"].printf("%d ", p + 1) ) else skip ; 
     mink := mink + 1 )  ;     p := p + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : String ; a := sc.getCurrent() ;
    var b : String ; b := sc.getCurrent() ;
    var A : Sequence(String) ; A := a->split("") ;
    var B : Sequence(String) ; B := b->split("") ;
    execute check(A, B) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Crossword822B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int s_size=in.nextInt();
    int t_size=in.nextInt();
    String s=in.next();
    String t=in.next();
    int size=t_size-s_size ;
    int max=0,index=0,arr[]=new int[s_size],x=0 ;
    for(int i=0 ; i<=size ; i++){
      int count=0 ;
      for(int j=0 ; j<s_size ; j++){
        if(t.charAt(i+j)==s.charAt(j))count++;
      }
      if(count>max){
        max=count ;
        index=i ;
      }
    }
    for(int i=0 ; i<s_size ; i++){
      if(t.charAt(index+i)!=s.charAt(i)){
        arr[x]=i+1 ;
        x++;
      }
    }
    System.out.println(s_size-max);
    for(int i=0 ; i<s_size-max ; i++){
      if(i==s_size-max-1)System.out.println(arr[i]);
      else System.out.print(arr[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Crossword822B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s_size : int ; s_size := in.getCurrent()->toInteger() ;
    var t_size : int ; t_size := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var t : String ; t := in.getCurrent() ;
    var size : int ; size := t_size - s_size ;
    var max : int ; max := 0 ;
    var index : int ; index := 0 ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,s_size)->collect(0) ;
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i <= size do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < s_size do ( (     if (t->at(i + j+1) = s->at(j+1)) then     count := count + 1 ; else skip )  ;     j := j + 1 ) ; 
     if (count > max) then (     max := count ; 
     index := i ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < s_size do ( (     if (t->at(index + i+1) /= s->at(i+1)) then (     arr[x+1] := i + 1 ; 
     x := x + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s_size - max) ; 
        var i : int ; i := 0 ; while i < s_size - max do ( (     if (i = s_size - max - 1) then     OclFile["System.out"].println(arr[i+1]) ; else     OclFile["System.out"].print(arr[i+1] + " ") ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int t=1 ; t<=test ; t++){
      int n=in.nextInt();
      ArrayList<Integer>list=new ArrayList<>();
      Map<Integer,Integer>map=new HashMap<>();
      for(int i=0 ; i<n ; i++){
        int v=in.nextInt();
        list.add(v);
        if(! map.containsKey(v)){
          map.put(v,1);
        }
        else {
          map.put(v,map.get(v)+1);
        }
      }
      boolean flag=false ;
      int ind=0 ;
      int min=Integer.MAX_VALUE ;
      for(Integer i : map.keySet()){
        int val=map.get(i);
        if(val==1){
          min=Math.min(i,min);
          flag=true ;
        }
      }
      if(flag){
        pw.println(list.indexOf(min)+1);
      }
      else {
        pw.println(-1);
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= test do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var list : Sequence(int) ; list := Sequence{} ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := in.getCurrent()->toInteger() ;
     list := list->including(v) ; 
     if (not(map->keys()->includes(v))) then (     map := map->union(Map{v |-> 1}) ) else (     map := map->union(Map{v |-> map->at(v) + 1}) ) )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := false ;
    var ind : int ; ind := 0 ;
    var min : int ; min := 2147483647 ;
    for (i : map->keys()) do ( (     var val : int ; val := map->at(i) ;
     if (val = 1) then (     min := Set{i, min}->min() ; 
     flag := true ) else skip )  ) ; 
    if (flag) then (     skip ) else (     skip ) ;  
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Unique_Bid_Auction_unsolved {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testcase=sc.nextInt();
    while(testcase!=0){
      testcase--;
      int len=sc.nextInt(),result=-1 ;
      int arr[]=new int[len+1],count[]=new int[len+1];
      for(int i=0 ; i<len ; i++){
        arr[i]=sc.nextInt();
        count[arr[i] ]++;
      }
      for(int i=1 ; i<=len ; i++){
        if(count[i]==1){
          result=i ;
          break ;
        }
      }
      if(result!=-1){
        for(int i=0 ; i<len ; i++){
          if(arr[i]==result){
            result=i+1 ;
            break ;
          }
        }
      }
      System.out.print(result);
      if(testcase>0)System.out.println();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Unique_Bid_Auction_unsolved {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testcase : int ; testcase := sc.getCurrent()->toInteger() ;
     while (testcase /= 0) do (     testcase := testcase - 1 ; 
     var len : int ; len := sc.getCurrent()->toInteger() ;
    var result : int ; result := -1 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,len + 1)->collect(0) ;
    var count : Sequence(void) ; count := Integer.subrange(1,len + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < len do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     count[arr[i+1]+1] := count[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= len do ( (     if (count[i+1] = 1) then (     result := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (result /= -1) then (         var i : int ; i := 0 ; while i < len do ( (     if (arr[i+1] = result) then (     result := i + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ) else skip ; 
    OclFile["System.out"].print(result) ; 
    if (testcase > 0) then     OclFile["System.out"].println() ; else skip ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class CF_1454B_UniqueBidAuction {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int count=scanner.nextInt();
    for(int i=0 ; i<count ; i++){
      int min=Integer.MAX_VALUE ;
      int length=scanner.nextInt();
      int[] arr=new int[length];
      int point=-1 ;
      HashMap<Integer,Boolean>map=new HashMap();
      for(int j=0 ; j<length ; j++){
        int number=scanner.nextInt();
        arr[j]=number ;
        if(map.get(number)==null){
          map.put(number,true);
        }
        else {
          map.remove(number);
          map.put(number,false);
        }
      }
      for(HashMap.Entry<Integer,Boolean>entry : map.entrySet()){
        if(entry.getValue()==false){
          continue ;
        }
        if(entry.getKey()<min){
          min=entry.getKey();
        }
      }
      for(int j=0 ; j<length ; j++){
        if(min==arr[j]){
          point=j+1 ;
        }
      }
      if(min==Integer.MAX_VALUE){
        System.out.println(-1);
      }
      else {
        System.out.println(point);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF_1454B_UniqueBidAuction {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < count do ( (     var min : int ; min := 2147483647 ;
     var length : int ; length := scanner.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,length)->collect(0) ;
    var point : int ; point := -1 ;
    var map : Map(int,Boolean) ; map := Map{} ;
        var j : int ; j := 0 ; while j < length do ( (     var number : int ; number := scanner.getCurrent()->toInteger() ;
     arr[j+1] := number ; 
     if (map->at(number) = null) then (     map := map->union(Map{number |-> true}) ) else (     map := map->antirestrict(Set{number}) ; 
     map := map->union(Map{number |-> false}) ) )  ;     j := j + 1 ) ; 
    for (entry : map->asSet()) do ( (     if (entry.getValue() = false) then (     continue ) else skip ; 
     if (entry.getKey() < min) then (     min := entry.getKey() ) else skip )  ) ; 
        var j : int ; j := 0 ; while j < length do ( (     if (min = arr[j+1]) then (     point := j + 1 ) else skip )  ;     j := j + 1 ) ; 
    if (min = 2147483647) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(point) ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder();
    int t=fs.nextInt();
    while(t-->0){
      int n=fs.nextInt();
      int[] a=fs.readArray(n);
      int[] b=new int[n+1];
      int min=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; i++){
        b[a[i] ]++;
      }
      for(int i=0 ; i<=n ; i++){
        if(b[i]==1 && min>i)min=i ;
      }
      int res=0,cnt=0 ;
      for(int i=0 ; i<n ; i++){
        if(min==a[i]){
          res=i+1 ;
          cnt++;
        }
      }
      sb.append(cnt>0 ? res : "-1").append("\n");
    }
    System.out.print(sb);
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    var t : int ; t := fs.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := fs.nextInt() ;
     var a : Sequence(int) ; a := fs.readArray(n) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n + 1)->collect(0) ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     b[a[i+1]+1] := b[a[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= n do ( (     if (b[i+1] = 1 & min > i) then     min := i ; else skip )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (min = a[i+1]) then (     res := i + 1 ; 
     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(if cnt > 0 then res else "-1" endif) + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].print(sb) ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int w=sc.nextInt();
    int h=sc.nextInt();
    boolean[] width=new boolean[w];
    boolean[] height=new boolean[h];
    Arrays.fill(width,false);
    Arrays.fill(height,false);
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      int wi=sc.nextInt();
      for(int j=Math.max(x-wi,0); j<Math.min(x+wi,w); j++)width[j]=true ;
      for(int j=Math.max(y-wi,0); j<Math.min(y+wi,h); j++)height[j]=true ;
    }
    if(isFilledWithTrue(width)|| isFilledWithTrue(height))System.out.println("Yes");
    else System.out.println("No");
    sc.close();
  }
  private static boolean isFilledWithTrue(boolean[] bool){
    for(boolean b : bool)if(! b)return false ;
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var width : Sequence(boolean) ; width := Integer.subrange(1,w)->collect(false) ;
    var height : Sequence(boolean) ; height := Integer.subrange(1,h)->collect(false) ;
    width := width->collect(false) ; 
    height := height->collect(false) ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var wi : int ; wi := sc.getCurrent()->toInteger() ;
        var j : int ; j := Set{x - wi, 0}->max() ; while j < Set{x + wi, w}->min() do (     width[j+1] := true ;  ;     j := j + 1 ) ; 
        var j : int ; j := Set{y - wi, 0}->max() ; while j < Set{y + wi, h}->min() do (     height[j+1] := true ;  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    if (isFilledWithTrue(width) or isFilledWithTrue(height)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
    skip ; 
 );
  static   operation isFilledWithTrue( bool : Sequence(boolean)) : boolean
  pre: true
  post: true
  activity: (     for (b : bool) do (     if (not(b)) then     return false else skip ;  ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test227 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int a[]=new int[n+1];
      int b[]=new int[n+1];
      for(int i=0 ; i<n ; i++){
        int x=in.nextInt();
        a[x]++;
        b[x]=i+1 ;
      }
      int c=-1 ;
      for(int i=1 ; i<=n ; i++){
        if(a[i]==1){
          c=b[i];
          break ;
        }
      }
      System.out.println(c);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test227 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     a[x+1] := a[x+1] + 1 ; 
     b[x+1] := i + 1 )  ;     i := i + 1 ) ; 
    var c : int ; c := -1 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (a[i+1] = 1) then (     c := b[i+1] ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=100002 ;
  static int f(int i,int m,char s[],int memoize[][]){
    if(i==s.length){
      return 0 ;
    }
    if(memoize[i][m]!=-1){
      return memoize[i][m];
    }
    int x=s[i]-'0' ;
    int ans=((x+m)% 3==0 && x % 2==0)? 1+f(i+1,(m+x)% 3,s,memoize): f(i+1,(m+x)% 3,s,memoize);
    memoize[i][m]=ans ;
    return memoize[i][m];
  }
  static int countDivBy6(char s[]){
    int n=s.length ;
    int[][] memoize=new int[n+1][3];
    for(int i=0 ; i<n+1 ; i++){
      for(int j=0 ; j<3 ; j++){
        memoize[i][j]=-1 ;
      }
    }
    int ans=0 ;
    for(int i=0 ; i<s.length ; i++){
      if(s[i]=='0'){
        ans++;
      }
      else {
        ans+=f(i,0,s,memoize);
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    char s[]="4806".toCharArray();
    System.out.println(countDivBy6(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100002;
  static   operation f( i : int, m : int, s : Sequence(String), memoize : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     if (i = s->size()) then (     return 0 ) else skip ; 
     if (memoize[i+1][m+1] /= -1) then (     return memoize[i+1][m+1] ) else skip ; 
    var x : int ; x := s[i+1] - ('0')->char2byte() ;
    var ans : int ; ans := if ((x + m) mod 3 = 0 & x mod 2 = 0) then 1 + f(i + 1, (m + x) mod 3, s, memoize) else f(i + 1, (m + x) mod 3, s, memoize) endif ;
    memoize[i+1][m+1] := ans ; 
    return memoize[i+1][m+1] 
 );
  static   operation countDivBy6( s : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var memoize : Sequence(Sequence(int)) ; memoize := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < n + 1 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     memoize[i+1][j+1] := -1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s[i+1] = '0') then (     ans := ans + 1 ) else (     ans := ans+(f(i, 0, s, memoize)) ) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := "4806"->characters() ;
     OclFile["System.out"].println(countDivBy6(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Random ;
import java.util.Scanner ;
public class A1225ForgettingThings {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long a=scanner.nextLong();
    long b=scanner.nextLong();
    if(b-a==1){
      System.out.println(((b*10)-1)+" "+(b*10));
    }
    else if(b-a==0){
      System.out.println(((b*10))+" "+((b*10)+1));
    }
    else if(a==9 & b==1){
      System.out.println(((b*10)-1)+" "+(b*10));
    }
    else {
      System.out.println("-1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1225ForgettingThings {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := scanner.getCurrent()->toLong() ;
     var b : long ; b := scanner.getCurrent()->toLong() ;
     if (b - a = 1) then (     OclFile["System.out"].println(((b * 10) - 1) + " " + (b * 10)) ) else     if (b - a = 0) then (     OclFile["System.out"].println(((b * 10)) + " " + ((b * 10) + 1)) ) else     if (a = 9 & b = 1) then (     OclFile["System.out"].println(((b * 10) - 1) + " " + (b * 10)) ) else (     OclFile["System.out"].println("-1") ) ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static double Min_glass(int n,int k,int[] a){
    int sum=0 ;
    for(int i=0 ; i<k ; i++)sum+=a[i];
    double ans=Math.ceil((double)sum/(double)100);
    return ans ;
  }
  public static void main(String[] args){
    int n=4 ;
    int k=3 ;
    int[] a={
      200,150,140,300 };
      Arrays.sort(a);
      System.out.println(Min_glass(n,k,a));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Min_glass( n : int, k : int, a : Sequence(int)) : double
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < k do (     sum := sum+(a[i+1]) ;  ;     i := i + 1 ) ; 
     var ans : double ; ans := (sum->oclAsType(double) / 100->oclAsType(double))->ceil() ;
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var k : int ; k := 3 ;
    var a : Sequence(int) ; a := Sequence{200,150,140,300} ;
    a := a->sort() ; 
    OclFile["System.out"].println(Min_glass(n, k, a)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static int n,m ;
  static boolean vis[];
  static List<List<Integer>>l=new ArrayList<>();
  static StringBuffer str=new StringBuffer();
  static void solve(){
    long ans=0 ;
    int dp[]=new int[n+1];
    for(int v=1 ; v<=n ; v++){
      dp[v]=1 ;
      for(int u : l.get(v)){
        if(u<v){
          dp[v]=Math.max(dp[v],dp[u]+1);
        }
      }
      ans=Math.max(ans,dp[v]*1l*l.get(v).size());
    }
    str.append(ans).append("\n");
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    String st[]=bf.readLine().trim().split("\\s+");
    n=Integer.parseInt(st[0]);
    m=Integer.parseInt(st[1]);
    for(int i=0 ; i<=n ; i++)l.add(new ArrayList<>());
    for(int i=0 ; i<m ; i++){
      st=bf.readLine().trim().split("\\s+");
      int u=Integer.parseInt(st[0]);
      int v=Integer.parseInt(st[1]);
      l.get(u).add(v);
      l.get(v).add(u);
    }
    solve();
    pw.print(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute n : int;
  static   attribute vis : Sequence(boolean);
  static   attribute l : Sequence(Sequence(int)) := Sequence{};
  static   attribute str : String := StringLib.newString();
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
     var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
         var v : int ; v := 1 ; while v <= n do ( (     dp[v+1] := 1 ; 
     for (u : l->at(v+1)) do ( (     if (u < v) then (     dp[v+1] := Set{dp[v+1], dp[u+1] + 1}->max() ) else skip )  ) ; 
     ans := Set{ans, dp[v+1] * 1l * l->at(v+1)->size()}->max() )  ;     v := v + 1 ) ; 
     str := str + StringLib.newString(ans) + StringLib.newString("\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var st : Sequence(String) ; st := bf.readLine()->trim()->split("\\s+") ;
    n := (st[0+1])->toInteger() ; 
    m := (st[1+1])->toInteger() ; 
        var i : int ; i := 0 ; while i <= n do (     l := l->including(Sequence{}) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     st := bf.readLine()->trim()->split("\\s+") ; 
     var u : int ; u := (st[0+1])->toInteger() ;
    var v : int ; v := (st[1+1])->toInteger() ;
    l->at(u+1)->excludes(v) ; 
    l->at(v+1)->excludes(u) ; 
 )  ;     i := i + 1 ) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GfG {
  static Boolean check(int n){
    int d=(int)Math.sqrt(n);
    if(d*d==n)return true ;
    return false ;
  }
  static int largestNonPerfectSquareNumber(int a[],int n){
    int maxi=-1 ;
    for(int i=0 ; i<n ; i++){
      if(! check(a[i]))maxi=Math.max(a[i],maxi);
    }
    return maxi ;
  }
  public static void main(String[] args){
    int a[]={
      16,20,25,2,3,10 };
      int n=a.length ;
      System.out.println(largestNonPerfectSquareNumber(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation check( n : int) : Boolean
  pre: true
  post: true
  activity: (     var d : int ; d := (n)->sqrt()->oclAsType(int) ;
     if (d * d = n) then     return true else skip ; 
     return false );
  static   operation largestNonPerfectSquareNumber( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var maxi : int ; maxi := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (not(check(a[i+1]))) then     maxi := Set{a[i+1], maxi}->max() ; else skip )  ;     i := i + 1 ) ; 
     return maxi );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{16,20,25,2,3,10} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(largestNonPerfectSquareNumber(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static int countDigits(int a,int b){
    int count=0 ;
    int p=Math.abs(a*b);
    if(p==0)return 1 ;
    while(p>0){
      count++;
      p=p/10 ;
    }
    return count ;
  }
  public static void main(String args[]){
    int a=33 ;
    int b=-24 ;
    System.out.println("Number of digits="+countDigits(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDigits( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var p : int ; p := if a * b < 0 then -(a * b) else a * b endif ;
    if (p = 0) then     return 1 else skip ; 
    while (p > 0) do (     count := count + 1 ; 
     p := p / 10 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 33 ;
     var b : int ; b := -24 ;
     OclFile["System.out"].println("Number of digits=" + countDigits(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int R=3 ;
  static final int C=3 ;
  static void swap(int mat[][],int row1,int row2,int col){
    for(int i=0 ; i<col ; i++){
      int temp=mat[row1][i];
      mat[row1][i]=mat[row2][i];
      mat[row2][i]=temp ;
    }
  }
  static void display(int mat[][],int row,int col){
    for(int i=0 ; i<row ; i++){
      for(int j=0 ; j<col ; j++)System.out.print(" "+mat[i][j]);
      System.out.print("\n");
    }
  }
  static int rankOfMatrix(int mat[][]){
    int rank=C ;
    for(int row=0 ; row<rank ; row++){
      if(mat[row][row]!=0){
        for(int col=0 ; col<R ; col++){
          if(col!=row){
            double mult=(double)mat[col][row]/mat[row][row];
            for(int i=0 ; i<rank ; i++)mat[col][i]-=mult*mat[row][i];
          }
        }
      }
      else {
        boolean reduce=true ;
        for(int i=row+1 ; i<R ; i++){
          if(mat[i][row]!=0){
            swap(mat,row,i,rank);
            reduce=false ;
            break ;
          }
        }
        if(reduce){
          rank--;
          for(int i=0 ; i<R ; i++)mat[i][row]=mat[i][rank];
        }
        row--;
      }
    }
    return rank ;
  }
  public static void main(String[] args){
    int mat[][]={
      {
        10,20,10 },{
-20,-30,10 },{
            30,50,0 }
          };
          System.out.print("Rank of the matrix is : "+rankOfMatrix(mat));
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute R : int := 3;
  static    attribute C : int := 3;
  static   operation swap( mat : Sequence(Sequence(int)), row1 : int, row2 : int, col : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < col do ( (     var temp : int ; temp := mat[row1+1][i+1] ;
     mat[row1+1][i+1] := mat[row2+1][i+1] ; 
     mat[row2+1][i+1] := temp )  ;     i := i + 1 ) );
  static   operation display( mat : Sequence(Sequence(int)), row : int, col : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < row do ( (         var j : int ; j := 0 ; while j < col do (     OclFile["System.out"].print(" " + mat[i+1][j+1]) ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) );
  static   operation rankOfMatrix( mat : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var rank : int ; rank := C ;
         var row : int ; row := 0 ; while row < rank do ( (     if (mat[row+1][row+1] /= 0) then (         var col : int ; col := 0 ; while col < R do ( (     if (col /= row) then (     var mult : double ; mult := mat[col+1][row+1]->oclAsType(double) / mat[row+1][row+1] ;
         var i : int ; i := 0 ; while i < rank do (     mat[col+1][i+1] := mat[col+1][i+1]-(mult * mat[row+1][i+1]) ;  ;     i := i + 1 ) ) else skip )  ;     col := col + 1 ) ) else (     var reduce : boolean ; reduce := true ;
         var i : int ; i := row + 1 ; while i < R do ( (     if (mat[i+1][row+1] /= 0) then (     execute swap(mat, row, i, rank) ; 
     reduce := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (reduce) then (     rank := rank - 1 ; 
         var i : int ; i := 0 ; while i < R do (     mat[i+1][row+1] := mat[i+1][rank+1] ;  ;     i := i + 1 ) ) else skip ; 
     row := row - 1 ) )  ;     row := row + 1 ) ; 
     return rank );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{10,20,10},Sequence{-20,-30,10},Sequence{30,50,0}} ;
     OclFile["System.out"].print("Rank of the matrix is : " + rankOfMatrix(mat)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new AOJ0655().doIt();
  }
  class AOJ0655 {
    void doIt(){
      int n=in.nextInt();
      Team team[]=new Team[n];
      for(int i=0 ; i<n ; i++)team[i]=new Team();
      int limit=(n*n-n)/2 ;
      for(int i=0 ; i<limit ; i++){
        int a=in.nextInt(),b=in.nextInt();
        int c=in.nextInt(),d=in.nextInt();
        if(c>d)team[a-1] .win+=3 ;
        else if(c<d)team[b-1] .win+=3 ;
        else {
          team[a-1] .win++;
          team[b-1] .win++;
        }
      }
      int result[]=new int[n];
      for(int i=0 ; i<n ; i++){
        int cnt=1 ;
        for(int s=0 ; s<n ; s++)if(team[i] .win<team[s] .win)cnt++;
        result[i]=cnt ;
      }
      for(int i=0 ; i<n ; i++)System.out.println(result[i]);
    }
    class Team {
      int win ;
      public Team(){
        this.win=0 ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     AOJ0655.newAOJ0655().doIt() );
 class AOJ0655 {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var team : Sequence(Team) ; team := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     team[i+1] := Team.newTeam() ;  ;     i := i + 1 ) ; 
    var limit : int ; limit := (n * n - n) / 2 ;
        var i : int ; i := 0 ; while i < limit do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
     var c : int ; c := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
     if (c > d) then     team[a - 1+1].win := team[a - 1+1].win+(3) ; else     if (c < d) then     team[b - 1+1].win := team[b - 1+1].win+(3) else (     team[a - 1+1].win := team[a - 1+1].win + 1 ; 
     team[b - 1+1].win := team[b - 1+1].win + 1 ) ;  )  ;     i := i + 1 ) ; 
    var result : Sequence(int) ; result := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var cnt : int ; cnt := 1 ;
         var s : int ; s := 0 ; while s < n do (     if (team[i+1].win < team[s+1].win) then     cnt := cnt + 1 ; else skip ;  ;     s := s + 1 ) ; 
     result[i+1] := cnt )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].println(result[i+1]) ;  ;     i := i + 1 ) ; 
 );
 class Team {
   attribute win : int;
   static operation newTeam() : Team
  pre: true
  post: true
  activity:
  ( var self : Team ;
    self := createTeam();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.win := 0 );
}
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int team=sc.nextInt();
      if(team==0)break ;
      int Maxgame=team*(team-1)/2 ;
      int[] indexA=new int[Maxgame];
      int[] indexB=new int[Maxgame];
      int[] pointA=new int[Maxgame];
      int[] pointB=new int[Maxgame];
      for(int i=0 ; i<Maxgame ; i++){
        indexA[i]=sc.nextInt()-1 ;
        indexB[i]=sc.nextInt()-1 ;
        pointA[i]=sc.nextInt();
        pointB[i]=sc.nextInt();
      }
      String solve=solve(team,indexA,indexB,pointA,pointB);
      System.out.println(solve);
    }
  }
  private static String solve(int team,int[] indexA,int[] indexB,int[] pointA,int[] pointB){
    int[] winpoint=new int[team];
    for(int i=0 ; i<indexA.length ; i++){
      if(pointA[i]>pointB[i]){
        winpoint[indexA[i] ]+=3 ;
      }
      else if(pointA[i]<pointB[i]){
        winpoint[indexB[i] ]+=3 ;
      }
      else {
        winpoint[indexA[i] ]++;
        winpoint[indexB[i] ]++;
      }
    }
    int[] rank=new int[team];
    for(int i=0 ; i<winpoint.length ; i++){
      for(int j=0 ; j<winpoint.length ; j++){
        if(winpoint[i]<winpoint[j])rank[i]++;
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<rank.length ; i++){
      sb.append((rank[i]+1)+"\n");
    }
    return sb.toString().trim();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var team : int ; team := sc.getCurrent()->toInteger() ;
     if (team = 0) then     break else skip ; 
    var Maxgame : int ; Maxgame := team * (team - 1) / 2 ;
    var indexA : Sequence(int) ; indexA := Integer.subrange(1,Maxgame)->collect(0) ;
    var indexB : Sequence(int) ; indexB := Integer.subrange(1,Maxgame)->collect(0) ;
    var pointA : Sequence(int) ; pointA := Integer.subrange(1,Maxgame)->collect(0) ;
    var pointB : Sequence(int) ; pointB := Integer.subrange(1,Maxgame)->collect(0) ;
        var i : int ; i := 0 ; while i < Maxgame do ( (     indexA[i+1] := sc.getCurrent()->toInteger() - 1 ; 
     indexB[i+1] := sc.getCurrent()->toInteger() - 1 ; 
     pointA[i+1] := sc.getCurrent()->toInteger() ; 
     pointB[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var solve : String ; solve := solve(team, indexA, indexB, pointA, pointB) ;
    OclFile["System.out"].println(solve) ; 
 ) );
  static   operation solve( team : int, indexA : Sequence(int), indexB : Sequence(int), pointA : Sequence(int), pointB : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var winpoint : Sequence(int) ; winpoint := Integer.subrange(1,team)->collect(0) ;
         var i : int ; i := 0 ; while i < indexA->size() do ( (     if (pointA[i+1] > pointB[i+1]) then (     winpoint[indexA[i+1]+1] := winpoint[indexA[i+1]+1]+(3) ) else     if (pointA[i+1] < pointB[i+1]) then (     winpoint[indexB[i+1]+1] := winpoint[indexB[i+1]+1]+(3) ) else (     winpoint[indexA[i+1]+1] := winpoint[indexA[i+1]+1] + 1 ; 
     winpoint[indexB[i+1]+1] := winpoint[indexB[i+1]+1] + 1 ) ;  )  ;     i := i + 1 ) ; 
    var rank : Sequence(int) ; rank := Integer.subrange(1,team)->collect(0) ;
        var i : int ; i := 0 ; while i < winpoint->size() do ( (         var j : int ; j := 0 ; while j < winpoint->size() do ( (     if (winpoint[i+1] < winpoint[j+1]) then     rank[i+1] := rank[i+1] + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < rank->size() do ( (     sb := sb + StringLib.newString((rank[i+1] + 1) + "\n") )  ;     i := i + 1 ) ; 
    return sb+""->trim() 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Map.Entry ;
import java.util.Scanner ;
import java.util.concurrent.atomic.AtomicInteger ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  static final Scanner s=new Scanner(System.in);
  static IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static IntStream REPS(int l,int r){
    return IntStream.rangeClosed(l,r);
  }
  static IntStream INS(int n){
    return REPS(n).map(i->getInt());
  }
  static int getInt(){
    return Integer.parseInt(s.next());
  }
  public static void main(String[] $){
    int n=getInt(),p[]=new int[n];
    for(int l=n*(n-1)/2 ; l>0 ; --l){
      int a=getInt()-1,b=getInt()-1,pa=getInt(),pb=getInt();
      if(pa>pb)p[a]+=3 ;
      else if(pa<pb)p[b]+=3 ;
      else {
++p[a];
++p[b];
      }
    }
    AtomicInteger c=new AtomicInteger(0);
    int r[]=new int[n];
    REPS(1,n).boxed().collect(Collectors.groupingBy(i->p[i-1])).entrySet().stream().sorted(Entry.comparingByKey(Comparator.reverseOrder())).map(Entry :: getValue).forEach(o->{
      c.incrementAndGet();
      for(int i : o)r[i-1]=c.get();
      c.addAndGet(o.size()-1);
    }
);
    Arrays.stream(r).forEach(System.out :: println);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static   operation REPS( l : int, r : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(l, r) );
  static   operation INS( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return REPS(n)->collect( _x1 | (lambda i : OclAny in getInt())->apply(_x1) ) );
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := getInt() ;
    var p : Sequence(void) ; p := Integer.subrange(1,n)->collect(0) ;
         var l : int ; l := n * (n - 1) / 2 ; while l > 0 do ( (     var a : int ; a := getInt() - 1 ;
    var b : int ; b := getInt() - 1 ;
    var pa : int ; pa := getInt() ;
    var pb : int ; pb := getInt() ;
     if (pa > pb) then     p[a+1] := p[a+1]+(3) ; else     if (pa < pb) then     p[b+1] := p[b+1]+(3) else (     p[a+1] := p[a+1] + 1 ; 
     p[b+1] := p[b+1] + 1 ) ;  )  ;     l := l - 1 ) ; 
    var c : int ; c := (0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,n)->collect(0) ;
    for o : REPS(1, n).collect(Collectors.groupingBy(lambda i : OclAny in p[i - 1+1]))->asSet()->sort()->collect( _x1 | (lambda _pars : OclAny in Entry.newEntry().getValue(_pars))->apply(_x1) ) do
    (    skip) ; 
    for _forEach : stream(r) do
    (    skip ;) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    KotoDistance solver=new KotoDistance();
    solver.solve(1,in,out);
    out.close();
  }
  static class KotoDistance {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int N=in.nextInt();
      int W=in.nextInt();
      int H=in.nextInt();
      int[] wimos=new int[W+10];
      int[] himos=new int[H+10];
      for(int i=0 ; i<N ; i++){
        int x=in.nextInt();
        int y=in.nextInt();
        int w=in.nextInt();
        wimos[Math.max(0,x-w)]++;
        wimos[Math.min(W,x+w)]--;
        himos[Math.max(0,y-w)]++;
        himos[Math.min(H,y+w)]--;
      }
      for(int i=1 ; i<=W+1 ; i++){
        wimos[i]+=wimos[i-1];
      }
      for(int i=1 ; i<=H+1 ; i++){
        himos[i]+=himos[i-1];
      }
      boolean wng=false ;
      for(int i=0 ; i<W ; i++){
        wng |=(wimos[i]==0);
      }
      boolean hng=false ;
      for(int i=0 ; i<H ; i++){
        hng |=(himos[i]==0);
      }
      out.println((hng && wng ? "No" : "Yes"));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : KotoDistance ; solver := KotoDistance.newKotoDistance() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class KotoDistance {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
     var W : int ; W := in.getCurrent()->toInteger() ;
    var H : int ; H := in.getCurrent()->toInteger() ;
    var wimos : Sequence(int) ; wimos := Integer.subrange(1,W + 10)->collect(0) ;
    var himos : Sequence(int) ; himos := Integer.subrange(1,H + 10)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var y : int ; y := in.getCurrent()->toInteger() ;
    var w : int ; w := in.getCurrent()->toInteger() ;
    wimos[Set{0, x - w}->max()+1] := wimos[Set{0, x - w}->max()+1] + 1 ; 
    wimos[Set{W, x + w}->min()+1] := wimos[Set{W, x + w}->min()+1] - 1 ; 
    himos[Set{0, y - w}->max()+1] := himos[Set{0, y - w}->max()+1] + 1 ; 
    himos[Set{H, y + w}->min()+1] := himos[Set{H, y + w}->min()+1] - 1 ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= W + 1 do ( (     wimos[i+1] := wimos[i+1]+(wimos[i - 1+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= H + 1 do ( (     himos[i+1] := himos[i+1]+(himos[i - 1+1]) )  ;     i := i + 1 ) ; 
    var wng : boolean ; wng := false ;
        var i : int ; i := 0 ; while i < W do ( (     wng := MathLib.bitwiseOr(wng, (wimos[i+1] = 0)) )  ;     i := i + 1 ) ; 
    var hng : boolean ; hng := false ;
        var i : int ; i := 0 ; while i < H do ( (     hng := MathLib.bitwiseOr(hng, (himos[i+1] = 0)) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] pointArray=new int[100];
    int[] rankArray=new int[100];
    int numberOfTeams,maxNumber ;
    int a,b,aPoint,bPoint ;
    numberOfTeams=sc.nextInt();
    maxNumber=numberOfTeams*(numberOfTeams-1)/2 ;
    for(int i=0 ; i<numberOfTeams ; i++){
      pointArray[i]=0 ;
      rankArray[i]=1 ;
    }
    for(int i=0 ; i<maxNumber ; i++){
      a=sc.nextInt()-1 ;
      b=sc.nextInt()-1 ;
      aPoint=sc.nextInt();
      bPoint=sc.nextInt();
      if(aPoint>bPoint){
        pointArray[a]+=3 ;
      }
      else if(aPoint<bPoint){
        pointArray[b]+=3 ;
      }
      else {
        pointArray[a]++;
        pointArray[b]++;
      }
    }
    for(int i=0 ; i<numberOfTeams ; i++){
      for(int j=0 ; j<numberOfTeams ; j++){
        if(pointArray[i]<pointArray[j]){
          rankArray[i]++;
        }
      }
    }
    for(int i=0 ; i<numberOfTeams ; i++){
      System.out.printf("%d\n",rankArray[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pointArray : Sequence(int) ; pointArray := Integer.subrange(1,100)->collect(0) ;
    var rankArray : Sequence(int) ; rankArray := Integer.subrange(1,100)->collect(0) ;
    var numberOfTeams : int ;
    var maxNumber : int ;
    var a : int ;
    var b : int ;
    var aPoint : int ;
    var bPoint : int ;
    numberOfTeams := sc.getCurrent()->toInteger() ; 
    maxNumber := numberOfTeams * (numberOfTeams - 1) / 2 ; 
        var i : int ; i := 0 ; while i < numberOfTeams do ( (     pointArray[i+1] := 0 ; 
     rankArray[i+1] := 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < maxNumber do ( (     a := sc.getCurrent()->toInteger() - 1 ; 
     b := sc.getCurrent()->toInteger() - 1 ; 
    aPoint := sc.getCurrent()->toInteger() ; 
    bPoint := sc.getCurrent()->toInteger() ; 
    if (aPoint > bPoint) then (     pointArray[a+1] := pointArray[a+1]+(3) ) else     if (aPoint < bPoint) then (     pointArray[b+1] := pointArray[b+1]+(3) ) else (     pointArray[a+1] := pointArray[a+1] + 1 ; 
     pointArray[b+1] := pointArray[b+1] + 1 ) ;  ;  
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < numberOfTeams do ( (         var j : int ; j := 0 ; while j < numberOfTeams do ( (     if (pointArray[i+1] < pointArray[j+1]) then (     rankArray[i+1] := rankArray[i+1] + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < numberOfTeams do ( (     OclFile["System.out"].printf("%d\n", rankArray[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countNumbersWith4(int n){
    if(n<4)return 0 ;
    int d=(int)Math.log10(n);
    int[] a=new int[d+2];
    a[0]=0 ;
    a[1]=1 ;
    for(int i=2 ; i<=d ; i++)a[i]=a[i-1]*9+(int)Math.ceil(Math.pow(10,i-1));
    int p=(int)Math.ceil(Math.pow(10,d));
    int msd=n/p ;
    if(msd==4)return(msd)*a[d]+(n % p)+1 ;
    if(msd>4)return(msd-1)*a[d]+p+countNumbersWith4(n % p);
    return(msd)*a[d]+countNumbersWith4(n % p);
  }
  public static void main(String[] args){
    int n=328 ;
    System.out.println("Count of numbers from 1 to "+n+" that have 4 as a digit is "+countNumbersWith4(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countNumbersWith4( n : int) : int
  pre: true
  post: true
  activity: (     if (n < 4) then     return 0 else skip ; 
     var d : int ; d := (n)->log10()->oclAsType(int) ;
    var a : Sequence(int) ; a := Integer.subrange(1,d + 2)->collect(0) ;
    a[0+1] := 0 ; 
    a[1+1] := 1 ; 
        var i : int ; i := 2 ; while i <= d do (     a[i+1] := a[i - 1+1] * 9 + (10->pow(i - 1))->ceil()->oclAsType(int) ;  ;     i := i + 1 ) ; 
    var p : int ; p := (10->pow(d))->ceil()->oclAsType(int) ;
    var msd : int ; msd := n / p ;
    if (msd = 4) then     return (msd) * a[d+1] + (n mod p) + 1 else skip ; 
    if (msd > 4) then     return (msd - 1) * a[d+1] + p + countNumbersWith4(n mod p) else skip ; 
    return (msd) * a[d+1] + countNumbersWith4(n mod p) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 328 ;
     OclFile["System.out"].println("Count of numbers from 1 to " + n + " that have 4 as a digit is " + countNumbersWith4(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),k=sc.nextInt();
    int x[]=new int[n];
    int y[]=new int[n];
    int cx[]=new int[n];
    int cy[]=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=sc.nextInt();
      y[i]=sc.nextInt();
      cx[i]=x[i];
      cy[i]=y[i];
    }
    Arrays.sort(x);
    Arrays.sort(y);
    long ans=Long.MAX_VALUE ;
    for(int lx=0 ; lx<n ; lx++){
      for(int rx=lx+1 ; rx<n ; rx++){
        for(int ly=0 ; ly<n ; ly++){
          for(int ry=ly+1 ; ry<n ; ry++){
            int x1=x[lx],x2=x[rx];
            int y1=y[ly],y2=y[ry];
            int cnt=0 ;
            for(int i=0 ; i<n ; i++){
              if(x1<=cx[i] && cx[i]<=x2 && y1<=cy[i] && cy[i]<=y2){
                cnt++;
              }
            }
            if(cnt>=k){
              ans=Math.min(ans,(long)(x2-x1)*(y2-y1));
            }
          }
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
    var cx : Sequence(int) ; cx := Integer.subrange(1,n)->collect(0) ;
    var cy : Sequence(int) ; cy := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     y[i+1] := sc.getCurrent()->toInteger() ; 
     cx[i+1] := x[i+1] ; 
     cy[i+1] := y[i+1] )  ;     i := i + 1 ) ; 
    x := x->sort() ; 
    y := y->sort() ; 
    var ans : long ; ans := "9223372036854775807"->toLong() ;
        var lx : int ; lx := 0 ; while lx < n do ( (         var rx : int ; rx := lx + 1 ; while rx < n do ( (         var ly : int ; ly := 0 ; while ly < n do ( (         var ry : int ; ry := ly + 1 ; while ry < n do ( (     var x1 : int ; x1 := x[lx+1] ;
    var x2 : int ; x2 := x[rx+1] ;
     var y1 : int ; y1 := y[ly+1] ;
    var y2 : int ; y2 := y[ry+1] ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (x1 <= cx[i+1] & cx[i+1] <= x2 & y1 <= cy[i+1] & cy[i+1] <= y2) then (     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (cnt >= k) then (     ans := Set{ans, (x2 - x1)->oclAsType(long) * (y2 - y1)}->min() ) else skip ; 
 )  ;     ry := ry + 1 ) )  ;     ly := ly + 1 ) )  ;     rx := rx + 1 ) )  ;     lx := lx + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    Team[] teams=new Team[n];
    for(int i=0 ; i<n ; i++)teams[i]=new Team(i,0);
    for(int i=0 ; i<n*(n-1)/2 ; i++){
      int a=scanner.nextInt()-1 ;
      int b=scanner.nextInt()-1 ;
      int c=scanner.nextInt();
      int d=scanner.nextInt();
      if(c>d)teams[a] .ten+=3 ;
      else if(c<d)teams[b] .ten+=3 ;
      else {
        teams[a] .ten++;
        teams[b] .ten++;
      }
    }
    Arrays.sort(teams);
    int[] rank=new int[n];
    rank[teams[0] .name]=1 ;
    int r=0 ;
    for(int i=1 ; i<n ; i++){
      if(teams[i] .ten==teams[i-1] .ten)r++;
      else r=0 ;
      rank[teams[i] .name]=i-r+1 ;
    }
    for(int ans : rank)System.out.println(ans);
  }
  class Team implements Comparable<Team>{
    int name,ten ;
    public Team(int name,int ten){
      super();
      this.name=name ;
      this.ten=ten ;
    }
    @ Override public int compareTo(Team o){
      return o.ten-ten ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var teams : Sequence(Team) ; teams := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     teams[i+1] := Team.newTeam(i, 0) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n * (n - 1) / 2 do ( (     var a : int ; a := scanner.getCurrent()->toInteger() - 1 ;
     var b : int ; b := scanner.getCurrent()->toInteger() - 1 ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    var d : int ; d := scanner.getCurrent()->toInteger() ;
    if (c > d) then     teams[a+1].ten := teams[a+1].ten+(3) else     if (c < d) then     teams[b+1].ten := teams[b+1].ten+(3) else (     teams[a+1].ten := teams[a+1].ten + 1 ; 
     teams[b+1].ten := teams[b+1].ten + 1 ) ;  ;  
 )  ;     i := i + 1 ) ; 
    teams := teams->sort() ; 
    var rank : Sequence(int) ; rank := Integer.subrange(1,n)->collect(0) ;
    rank[teams[0+1].name+1] := 1 ; 
    var r : int ; r := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (teams[i+1].ten = teams[i - 1+1].ten) then     r := r + 1 else     r := 0 ; ;  
     rank[teams[i+1].name+1] := i - r + 1 )  ;     i := i + 1 ) ; 
    for (ans : rank) do (     OclFile["System.out"].println(ans) ;  ) ; 
 );
 class Team implements Comparable<Team> {
   attribute name : int;
   static operation newTeam( name : int, ten : int) : Team
  pre: true
  post: true
  activity:
  ( var self : Team ;
    self := createTeam();
    self.initialise(name, ten);
    return self );
  operation initialise( name : int, ten : int) : void
  pre: true  post: true
  activity: (     execute super() ; 
     self.name := name ; 
     self.ten := ten );
      operation compareTo( o : Team) : int
  pre: true
  post: true
  activity: (     return o.ten - ten );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static Node head ;
  static class Node {
    int data ;
    Node next ;
  };
  static Node push(Node head_ref,int new_data){
    Node new_node=new Node();
    new_node.data=new_data ;
    new_node.next=head_ref ;
    head_ref=new_node ;
    return head=head_ref ;
  }
  static int sumOfNodes(Node head){
    Node ptr=head ;
    int sum=0 ;
    while(ptr!=null){
      sum+=ptr.data ;
      ptr=ptr.next ;
    }
    return sum ;
  }
  public static void main(String[] args){
    push(head,7);
    push(head,6);
    push(head,8);
    push(head,4);
    push(head,1);
    System.out.println("Sum of nodes="+sumOfNodes(head));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute head : Node;
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   operation push( head_ref : Node, new_data : int) : Node
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode() ;
     new_node.data := new_data ; 
    new_node.next := head_ref ; 
    head_ref := new_node ; 
    return head 
 );
  static   operation sumOfNodes( head : Node) : int
  pre: true
  post: true
  activity: (     var ptr : Node ; ptr := head ;
     var sum : int ; sum := 0 ;
     while (ptr /= null) do (     sum := sum+(ptr.data) ; 
     ptr := ptr.next ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute push(head, 7) ; 
     execute push(head, 6) ; 
    execute push(head, 8) ; 
    execute push(head, 4) ; 
    execute push(head, 1) ; 
    OclFile["System.out"].println("Sum of nodes=" + sumOfNodes(head)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sum=0 ;
  static class Node {
    int data ;
    Node next ;
  }
  static Node push(Node head_ref,int new_data){
    Node new_node=new Node();
    new_node.data=new_data ;
    new_node.next=(head_ref);
(head_ref)=new_node ;
    return head_ref ;
  }
  static void sumOfNodes(Node head){
    if(head==null)return ;
    sumOfNodes(head.next);
    sum=sum+head.data ;
  }
  static int sumOfNodesUtil(Node head){
    sum=0 ;
    sumOfNodes(head);
    return sum ;
  }
  public static void main(String args[]){
    Node head=null ;
    head=push(head,7);
    head=push(head,6);
    head=push(head,8);
    head=push(head,4);
    head=push(head,1);
    System.out.println("Sum of nodes="+sumOfNodesUtil(head));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute sum : int := 0;
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   operation push( head_ref : Node, new_data : int) : Node
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode() ;
     new_node.data := new_data ; 
    new_node.next := (head_ref) ; 
    (head_ref) := new_node ; 
    return head_ref 
 );
  static   operation sumOfNodes( head : Node) : void
  pre: true
  post: true
  activity: (     if (head = null) then     return else skip ; 
     execute sumOfNodes(head.next) ; 
     sum := sum + head.data );
  static   operation sumOfNodesUtil( head : Node) : int
  pre: true
  post: true
  activity: (     sum := 0 ; 
     execute sumOfNodes(head) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := null ;
     head := push(head, 7) ; 
    head := push(head, 6) ; 
    head := push(head, 8) ; 
    head := push(head, 4) ; 
    head := push(head, 1) ; 
    OclFile["System.out"].println("Sum of nodes=" + sumOfNodesUtil(head)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
(new Main()).solve();
  }
  void solve(){
    Scanner cin=new Scanner(System.in);
    int T=cin.nextInt();
    for(int C=1 ; C<=T ; ++C){
      int P=cin.nextInt();
      int Q=cin.nextInt();
      int N=cin.nextInt();
      int HP[]=new int[N];
      int GOLD[]=new int[N];
      for(int i=0 ; i<N ; ++i){
        HP[i]=cin.nextInt();
        GOLD[i]=cin.nextInt();
      }
      System.out.println("Case #"+C+": "+solve(P,Q,HP,GOLD,N));
    }
  }
  int solve(int P,int Q,int HP[],int GOLD[],int N){
    int SIZE=N*10+100 ;
    int score[]=new int[SIZE];
    score[1]=1 ;
    for(int i=0 ; i<N ; ++i){
      int next[]=new int[SIZE];
      int turn=HP[i]/Q ;
      int rest=HP[i]-Q*turn ;
      if(rest==0){
        rest=Q ;
--turn ;
      }
      int req=(rest+P-1)/P ;
      for(int j=0 ; j<SIZE ; ++j){
        if(score[j]==0){
          continue ;
        }
        int index=j+turn+1 ;
        next[index]=Math.max(next[index],score[j]);
        if(req<=j+turn){
          int index2=j+turn-req ;
          next[index2]=Math.max(next[index2],score[j]+GOLD[i]);
        }
      }
      score=next ;
    }
    int ret=0 ;
    for(int i=0 ; i<SIZE ; ++i){
      ret=Math.max(ret,score[i]);
    }
    return ret-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := cin.getCurrent()->toInteger() ;
         var C : int ; C := 1 ; while C <= T do ( (     var P : int ; P := cin.getCurrent()->toInteger() ;
     var Q : int ; Q := cin.getCurrent()->toInteger() ;
    var N : int ; N := cin.getCurrent()->toInteger() ;
    var HP : Sequence(int) ; HP := Integer.subrange(1,N)->collect(0) ;
    var GOLD : Sequence(int) ; GOLD := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     HP[i+1] := cin.getCurrent()->toInteger() ; 
     GOLD[i+1] := cin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Case #" + C + ": " + solve(P, Q, HP, GOLD, N)) ; 
 )  ;     C := C + 1 ) );
   operation solve( P : int, Q : int, HP : Sequence(int), GOLD : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var SIZE : int ; SIZE := N * 10 + 100 ;
     var score : Sequence(int) ; score := Integer.subrange(1,SIZE)->collect(0) ;
    score[1+1] := 1 ; 
        var i : int ; i := 0 ; while i < N do ( (     var next : Sequence(int) ; next := Integer.subrange(1,SIZE)->collect(0) ;
     var turn : int ; turn := HP[i+1] / Q ;
    var rest : int ; rest := HP[i+1] - Q * turn ;
    if (rest = 0) then (     rest := Q ; 
     turn := turn - 1 ) else skip ; 
    var req : int ; req := (rest + P - 1) / P ;
        var j : int ; j := 0 ; while j < SIZE do ( (     if (score[j+1] = 0) then (     continue ) else skip ; 
     var index : int ; index := j + turn + 1 ;
     next[index+1] := Set{next[index+1], score[j+1]}->max() ; 
     if (req <= j + turn) then (     var index2 : int ; index2 := j + turn - req ;
     next[index2+1] := Set{next[index2+1], score[j+1] + GOLD[i+1]}->max() ) else skip )  ;     j := j + 1 ) ; 
    score := next ; 
 )  ;     i := i + 1 ) ; 
    var ret : int ; ret := 0 ;
        var i : int ; i := 0 ; while i < SIZE do ( (     ret := Set{ret, score[i+1]}->max() )  ;     i := i + 1 ) ; 
    return ret - 1 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round3 ;
import java.io.FileInputStream ;
import java.io.FileNotFoundException ;
import java.io.FileOutputStream ;
public class B {
  public static void main(String[] args)throws FileNotFoundException {
    Kattio io ;
    io=new Kattio(new FileInputStream("round3/B-large-0.in"),new FileOutputStream("round3/B-large-0.out"));
    int cases=io.getInt();
    for(int i=1 ; i<=cases ; i++){
      io.print("Case #"+i+": ");
      System.err.println(i);
      new B().solve(io);
    }
    io.close();
  }
  int myPower,towerPower ;
  int health[],gold[];
  private void solve(Kattio io){
    myPower=io.getInt();
    towerPower=io.getInt();
    int n=io.getInt();
    health=new int[n];
    gold=new int[n];
    for(int i=0 ; i<n ; i++){
      health[i]=io.getInt();
      gold[i]=io.getInt();
    }
    memo=new int[n][201*n+10];
    io.println(go(0,1));
  }
  int memo[][];
  private int go(int monster,int savedTurns){
    if(monster==health.length)return 0 ;
    int orgSavedTurns=savedTurns ;
    if(memo[monster][savedTurns]>0)return memo[monster][savedTurns]-1 ;
    int towerShots=(health[monster]+towerPower-1)/towerPower ;
    int best=go(monster+1,savedTurns+towerShots);
    int h=health[monster] % towerPower ;
    if(h==0)h=towerPower ;
    int shotsReq=(h+myPower-1)/myPower ;
    savedTurns+=towerShots-1 ;
    if(shotsReq<=savedTurns){
      best=Math.max(best,gold[monster]+go(monster+1,savedTurns-shotsReq));
    }
    memo[monster][orgSavedTurns]=best+1 ;
    return best ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : Kattio ;
     io := Kattio.newKattio(OclFile.newOclFile_Read(OclFile.newOclFile("round3/B-large-0.in")), OclFile.newOclFile_Write(OclFile.newOclFile("round3/B-large-0.out"))) ; 
    var cases : int ; cases := io.getInt() ;
        var i : int ; i := 1 ; while i <= cases do ( (     io.print("Case #" + i + ": ") ; 
     OclFile["System.err"].println(i) ; 
     B.newB().solve(io) )  ;     i := i + 1 ) ; 
    io.close() ; 
 );
   attribute myPower : int;
   attribute health : int;
   operation solve( io : Kattio) : void
  pre: true
  post: true
  activity: (     myPower := io.getInt() ; 
     towerPower := io.getInt() ; 
    var n : int ; n := io.getInt() ;
    health := Integer.subrange(1,n)->collect(0) ; 
    gold := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     health[i+1] := io.getInt() ; 
     gold[i+1] := io.getInt() )  ;     i := i + 1 ) ; 
    memo := Integer.subrange(1,n)->collect(Integer.subrange(1,201 * n + 10)->collect(0)) ; 
    io.println(go(0, 1)) ; 
 );
   attribute memo : Sequence(Sequence(int));
   operation go( monster : int, savedTurns : int) : int
  pre: true
  post: true
  activity: (     if (monster = health->size()) then     return 0 else skip ; 
     var orgSavedTurns : int ; orgSavedTurns := savedTurns ;
    if (memo[monster+1][savedTurns+1] > 0) then     return memo[monster+1][savedTurns+1] - 1 else skip ; 
    var towerShots : int ; towerShots := (health[monster+1] + towerPower - 1) / towerPower ;
    var best : int ; best := go(monster + 1, savedTurns + towerShots) ;
    var h : int ; h := health[monster+1] mod towerPower ;
    if (h = 0) then     h := towerPower ; else skip ; 
    var shotsReq : int ; shotsReq := (h + myPower - 1) / myPower ;
    savedTurns := savedTurns+(towerShots - 1) ; 
    if (shotsReq <= savedTurns) then (     best := Set{best, gold[monster+1] + go(monster + 1, savedTurns - shotsReq)}->max() ) else skip ; 
    memo[monster+1][orgSavedTurns+1] := best + 1 ; 
    return best 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class CountKSubStr {
  int countkDist(String str,int k){
    int res=0 ;
    int n=str.length();
    int cnt[]=new int[26];
    for(int i=0 ; i<n ; i++){
      int dist_count=0 ;
      Arrays.fill(cnt,0);
      for(int j=i ; j<n ; j++){
        if(cnt[str.charAt(j)-'a']==0)dist_count++;
        cnt[str.charAt(j)-'a']++;
        if(dist_count==k)res++;
      }
    }
    return res ;
  }
  public static void main(String[] args){
    CountKSubStr ob=new CountKSubStr();
    String ch="abcbaa" ;
    int k=3 ;
    System.out.println("Total substrings with exactly "+k+" distinct characters : "+ob.countkDist(ch,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class CountKSubStr {
   operation countkDist( str : String, k : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     var n : int ; n := str->size() ;
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var dist_count : int ; dist_count := 0 ;
     cnt := cnt->collect(0) ; 
         var j : int ; j := i ; while j < n do ( (     if (cnt[str->at(j+1) - ('a')->char2byte()+1] = 0) then     dist_count := dist_count + 1 ; else skip ; 
     cnt[str->at(j+1) - ('a')->char2byte()+1] := cnt[str->at(j+1) - ('a')->char2byte()+1] + 1 ; 
     if (dist_count = k) then     res := res + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ob : CountKSubStr ; ob := CountKSubStr.newCountKSubStr() ;
     var ch : String ; ch := "abcbaa" ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println("Total substrings with exactly " + k + " distinct characters : " + ob.countkDist(ch, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Stack ;
public class GFG {
  static boolean checkRedundancy(String s){
    Stack<Character>st=new Stack<>();
    char[] str=s.toCharArray();
    for(char ch : str){
      if(ch==')'){
        char top=st.peek();
        st.pop();
        boolean flag=true ;
        while(top!='('){
          if(top=='+' || top=='-' || top=='*' || top=='/'){
            flag=false ;
          }
          top=st.peek();
          st.pop();
        }
        if(flag==true){
          return true ;
        }
      }
      else {
        st.push(ch);
      }
    }
    return false ;
  }
  static void findRedundant(String str){
    boolean ans=checkRedundancy(str);
    if(ans==true){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
  public static void main(String[] args){
    String str="((a+b))" ;
    findRedundant(str);
    str="(a+(b)/c)" ;
    findRedundant(str);
    str="(a+b*(c-d))" ;
    findRedundant(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkRedundancy( s : String) : boolean
  pre: true
  post: true
  activity: (     var st : Sequence(String) ; st := Sequence{} ;
     var str : Sequence(String) ; str := s->characters() ;
     for (ch : str) do ( (     if (ch = ')') then (     var top : String ; top := st->min() ;
     st := st->front() ; 
    var flag : boolean ; flag := true ;
    while (top /= '(') do (     if (top = '+' or top = '-' or top = '*' or top = '/') then (     flag := false ) else skip ; 
     top := st->min() ; 
     st := st->front() ) ; 
    if (flag = true) then (     return true ) else skip ; 
 ) else (     st := st->append(ch) ) )  ) ; 
     return false );
  static   operation findRedundant( str : String) : void
  pre: true
  post: true
  activity: (     var ans : boolean ; ans := checkRedundancy(str) ;
     if (ans = true) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "((a+b))" ;
     execute findRedundant(str) ; 
    str := "(a+(b)/c)" ; 
    execute findRedundant(str) ; 
    str := "(a+b*(c-d))" ; 
    execute findRedundant(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int binarySearch(int[] searchSpace,int s,int e,int num){
    int ans=0 ;
    while(s<=e){
      int mid=(s+e)/2 ;
      if(searchSpace[mid]>=num){
        ans=mid ;
        e=mid-1 ;
      }
      else s=mid+1 ;
    }
    return ans ;
  }
  static int longestSubArr(int[] arr,int n){
    int[] searchSpace=new int[n];
    int[] index=new int[n];
    int j=0 ;
    int ans=0 ;
    for(int i=0 ; i<n ; ++i){
      if(j==0 || searchSpace[j-1]<arr[i]){
        searchSpace[j]=arr[i];
        index[j]=i ;
        j++;
      }
      int idx=binarySearch(searchSpace,0,j-1,arr[i]);
      ans=Math.max(ans,i-index[idx]+1);
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
-5,-1,7,5,1,-2 };
      int n=arr.length ;
      System.out.println(longestSubArr(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation binarySearch( searchSpace : Sequence(int), s : int, e : int, num : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     while (s <= e) do (     var mid : int ; mid := (s + e) / 2 ;
     if (searchSpace[mid+1] >= num) then (     ans := mid ; 
     e := mid - 1 ) else     s := mid + 1 ; ) ; 
     return ans );
  static   operation longestSubArr( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var searchSpace : Sequence(int) ; searchSpace := Integer.subrange(1,n)->collect(0) ;
     var index : Sequence(int) ; index := Integer.subrange(1,n)->collect(0) ;
    var j : int ; j := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (j = 0 or searchSpace[j - 1+1] < arr[i+1]) then (     searchSpace[j+1] := arr[i+1] ; 
     index[j+1] := i ; 
     j := j + 1 ) else skip ; 
     var idx : int ; idx := binarySearch(searchSpace, 0, j - 1, arr[i+1]) ;
     ans := Set{ans, i - index[idx+1] + 1}->max() )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-5,-1,7,5,1,-2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(longestSubArr(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int solveEven(String s){
    if(s.length()% 2==1){
      return 2 ;
    }
    String ls=s.substring(0,s.length()/2);
    String rs=s.substring(s.length()/2,s.length());
    if(ls!=rs){
      return 1 ;
    }
    return solveEven(ls);
  }
  static int solveOdd(String s){
    return 2 ;
  }
  static int solve(String s){
    if(s.length()<=3){
      return-1 ;
    }
    int cnt[]=new int[25];
    for(int i=0 ; i<s.length(); i++){
      cnt[s.charAt(i)-'a']++;
    }
    if(Arrays.stream(cnt).max().getAsInt()>=s.length()-1){
      return-1 ;
    }
    if(s.length()% 2==0){
      return solveEven(s);
    }
    if(s.length()% 2==1){
      return solveOdd(s);
    }
    return Integer.MIN_VALUE ;
  }
  public static void main(String[] args){
    String s="nolon" ;
    System.out.println(solve(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solveEven( s : String) : int
  pre: true
  post: true
  activity: (     if (s->size() mod 2 = 1) then (     return 2 ) else skip ; 
     var ls : String ; ls := s.subrange(0+1,s->size() / 2) ;
    var rs : String ; rs := s.subrange(s->size() / 2+1,s->size()) ;
    if (ls /= rs) then (     return 1 ) else skip ; 
    return solveEven(ls) 
 );
  static   operation solveOdd( s : String) : int
  pre: true
  post: true
  activity: (     return 2 );
  static   operation solve( s : String) : int
  pre: true
  post: true
  activity: (     if (s->size() <= 3) then (     return -1 ) else skip ; 
     var cnt : Sequence(int) ; cnt := Integer.subrange(1,25)->collect(0) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     cnt[s->at(i+1) - ('a')->char2byte()+1] := cnt[s->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    if (stream(cnt).max().getAsInt() >= s->size() - 1) then (     return -1 ) else skip ; 
    if (s->size() mod 2 = 0) then (     return solveEven(s) ) else skip ; 
    if (s->size() mod 2 = 1) then (     return solveOdd(s) ) else skip ; 
    return -2147483648 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "nolon" ;
     OclFile["System.out"].println(solve(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,w,h,i,j,x,y,p ;
    int[] fw,fh ;
    n=sc.nextInt();
    w=sc.nextInt();
    h=sc.nextInt();
    fw=new int[w];
    fh=new int[h];
    j=0 ;
    for(; n-->0 ; ){
      x=sc.nextInt();
      y=sc.nextInt();
      p=sc.nextInt();
      if(x-p<0)fw[0]++;
      else fw[x-p]++;
      if(y-p<0)fh[0]++;
      else fh[y-p]++;
      if(x+p<w)fw[x+p]--;
      if(y+p<h)fh[y+p]--;
    }
    for(i=1 ; i<w ; i++)fw[i]+=fw[i-1];
    for(i=1 ; i<h ; i++)fh[i]+=fh[i-1];
    for(i=0 ; i<w ; i++)if(fw[i]<=0)break ;
    for(j=0 ; j<h ; j++)if(fh[j]<=0)break ;
    if(i==w || j==h)out.println("Yes");
    else out.println("No");
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var w : int ;
    var h : int ;
    var i : int ;
    var j : int ;
    var x : int ;
    var y : int ;
    var p : int ;
    var fw : Sequence(int) ;
    var fh : Sequence(int) ;
    n := sc.nextInt() ; 
    w := sc.nextInt() ; 
    h := sc.nextInt() ; 
    fw := Integer.subrange(1,w)->collect(0) ; 
    fh := Integer.subrange(1,h)->collect(0) ; 
    j := 0 ; 
      while n > 0 do ( (     x := sc.nextInt() ; 
     y := sc.nextInt() ; 
    p := sc.nextInt() ; 
    if (x - p < 0) then     fw[0+1] := fw[0+1] + 1 else     fw[x - p+1] := fw[x - p+1] + 1 ; ;  
    if (y - p < 0) then     fh[0+1] := fh[0+1] + 1 else     fh[y - p+1] := fh[y - p+1] + 1 ; ;  
    if (x + p < w) then     fw[x + p+1] := fw[x + p+1] - 1 ; else skip ; 
    if (y + p < h) then     fh[y + p+1] := fh[y + p+1] - 1 ; else skip ; 
 )  ) ; 
        i := 1 ; while i < w do (     fw[i+1] := fw[i+1]+(fw[i - 1+1]) ;  ;     i := i + 1 ) ; 
        i := 1 ; while i < h do (     fh[i+1] := fh[i+1]+(fh[i - 1+1]) ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < w do (     if (fw[i+1] <= 0) then     break else skip ;  ;     i := i + 1 ) ; 
        j := 0 ; while j < h do (     if (fh[j+1] <= 0) then     break else skip ;  ;     j := j + 1 ) ; 
    if (i = w or j = h) then     out.println("Yes") else     out.println("No") ; ;  
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int N=scn.nextInt(),K=scn.nextInt();
    long[] NCK=new long[N-K+1];
    NCK[0]=1 ;
    long A[]=new long[N];
    long MOD=1000000007 ;
    long min=0 ;
    long max=0 ;
    for(int i=0 ; i<N ; i++){
      A[i]=scn.nextLong();
    }
    Arrays.sort(A);
    for(int i=1 ; i<N-K+1 ; i++){
      NCK[i]=NCK[i-1]*(K+i-1);
      NCK[i] %=MOD ;
      NCK[i]*=modinv(i,MOD);
      NCK[i] %=MOD ;
    }
    for(int i=0 ; i<N-K+1 ; i++){
      min+=A[i]*NCK[N-K-i];
      min %=MOD ;
      max+=A[N-1-i]*NCK[N-K-i];
      max %=MOD ;
    }
    long ans=max-min ;
    ans %=MOD ;
    ans+=MOD ;
    ans %=MOD ;
    System.out.println(ans);
  }
  public static long modinv(long a,long mod){
    long b=mod,u=1,v=0 ;
    long buf=0 ;
    while(b>0){
      long t=a/b ;
      a-=t*b ;
      buf=a ;
      a=b ;
      b=buf ;
      u-=t*v ;
      buf=u ;
      u=v ;
      v=buf ;
    }
    u %=mod ;
    if(u<0)u+=mod ;
    return u ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scn.getCurrent()->toInteger() ;
    var K : int ; K := scn.getCurrent()->toInteger() ;
    var NCK : Sequence(long) ; NCK := Integer.subrange(1,N - K + 1)->collect(0) ;
    NCK[0+1] := 1 ; 
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
    var MOD : long ; MOD := 1000000007 ;
    var min : long ; min := 0 ;
    var max : long ; max := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := scn.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
        var i : int ; i := 1 ; while i < N - K + 1 do ( (     NCK[i+1] := NCK[i - 1+1] * (K + i - 1) ; 
     NCK[i+1] := NCK[i+1] mod MOD ; 
     NCK[i+1] := NCK[i+1]*(modinv(i, MOD)) ; 
     NCK[i+1] := NCK[i+1] mod MOD )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - K + 1 do ( (     min := min+(A[i+1] * NCK[N - K - i+1]) ; 
     min := min mod MOD ; 
     max := max+(A[N - 1 - i+1] * NCK[N - K - i+1]) ; 
     max := max mod MOD )  ;     i := i + 1 ) ; 
    var ans : long ; ans := max - min ;
    ans := ans mod MOD ; 
    ans := ans+(MOD) ; 
    ans := ans mod MOD ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation modinv( a : long, mod : long) : long
  pre: true
  post: true
  activity: (     var b : long ; b := mod ;
    var u : long ; u := 1 ;
    var v : long ; v := 0 ;
     var buf : long ; buf := 0 ;
    while (b > 0) do (     var t : long ; t := a / b ;
     a := a-(t * b) ; 
    buf := a ; 
    a := b ; 
    b := buf ; 
    u := u-(t * v) ; 
    buf := u ; 
    u := v ; 
    v := buf ; 
 ) ; 
    u := u mod mod ; 
    if (u < 0) then     u := u+(mod) ; else skip ; 
    return u 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void find_set(int n){
    if(n<=2){
      System.out.println("-1");
      return ;
    }
    int sum1=(n*(n-1))/2 ;
    int sum2=n ;
    System.out.println(sum1+" "+sum2);
  }
  public static void main(String[] args){
    int n=8 ;
    find_set(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation find_set( n : int) : void
  pre: true
  post: true
  activity: (     if (n <= 2) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
     var sum1 : int ; sum1 := (n * (n - 1)) / 2 ;
     var sum2 : int ; sum2 := n ;
     OclFile["System.out"].println(sum1 + " " + sum2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     execute find_set(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String replaceRemove(char[] s,char X,char Y,char Z){
    int start=0,end=s.length-1 ;
    while(start<=end){
      if(s[start]==Z){
        while(end>=0 && s[end]==Z){
          end--;
        }
        char temp ;
        if(end>start){
          temp=s[start];
          s[start]=s[end];
          s[end]=temp ;
          if(s[start]==X)s[start]=Y ;
          start++;
        }
      }
      else {
        if(s[start]==X)s[start]=Y ;
        start++;
      }
    }
    String new_s=new String(s);
    while(new_s.length()>0 && new_s.charAt(new_s.length()-1)==Z){
      new_s=new_s.substring(0,new_s.length()-1);
    }
    return new_s ;
  }
  public static void main(String[] args){
    String str="batman" ;
    char X='a',Y='d',Z='b' ;
    str=replaceRemove(str.toCharArray(),X,Y,Z);
    if(str.length()==0){
      System.out.println(-1);
    }
    else {
      System.out.println(str);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation replaceRemove( s : Sequence(String), X : String, Y : String, Z : String) : String
  pre: true
  post: true
  activity: (     var start : int ; start := 0 ;
    var end : int ; end := s->size() - 1 ;
     while (start <= end) do (     if (s[start+1] = Z) then (     while (end >= 0 & s[end+1] = Z) do (     end := end - 1 ) ; 
     var temp : String ;
     if (end > start) then (     temp := s[start+1] ; 
     s[start+1] := s[end+1] ; 
    s[end+1] := temp ; 
    if (s[start+1] = X) then     s[start+1] := Y ; else skip ; 
    start := start + 1 ; 
 ) else skip ) else (     if (s[start+1] = X) then     s[start+1] := Y ; else skip ; 
     start := start + 1 ) ) ; 
    var new_s : String ; new_s := StringLib.newString(s) ;
    while (new_s->size() > 0 & new_s->at(new_s->size() - 1+1) = Z) do (     new_s := new_s.subrange(0+1,new_s->size() - 1) ) ; 
    return new_s 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "batman" ;
     var X : String ; X := 'a' ;
    var Y : String ; Y := 'd' ;
    var Z : String ; Z := 'b' ;
     str := replaceRemove(str->characters(), X, Y, Z) ; 
     if (str->size() = 0) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(str) ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static boolean check(int n,int k,int[] a,int[] b){
    Arrays.sort(a);
    Arrays.sort(b);
    boolean fl=false ;
    int ind=-1 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]!=b[i]){
        if(fl==true){
          return false ;
        }
        fl=true ;
        ind=i ;
      }
    }
    if(ind==-1 | Math.abs(a[ind]-b[ind])<=k){
      return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    int n=2,k=4 ;
    int[] a={
      1,5 };
      int b[]={
        1,1 };
        if(check(n,k,a,b)){
          System.out.println("Yes");
        }
        else {
          System.out.println("No");
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( n : int, k : int, a : Sequence(int), b : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     b := b->sort() ; 
    var fl : boolean ; fl := false ;
    var ind : int ; ind := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] /= b[i+1]) then (     if (fl = true) then (     return false ) else skip ; 
     fl := true ; 
     ind := i ) else skip )  ;     i := i + 1 ) ; 
    if (ind = -1 or if a[ind+1] - b[ind+1] < 0 then -(a[ind+1] - b[ind+1]) else a[ind+1] - b[ind+1] endif <= k) then (     return true ) else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
    var k : int ; k := 4 ;
     var a : Sequence(int) ; a := Sequence{1,5} ;
     var b : Sequence(int) ; b := Sequence{1,1} ;
     if (check(n, k, a, b)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.*;
import java.util.Arrays ;
class GFG {
  static int findMaxNum(int arr[],int n){
    Arrays.sort(arr);
    int num=arr[0];
    for(int i=n-1 ; i>=0 ; i--){
      num=num*10+arr[i];
    }
    return num ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,0 };
      int n=arr.length ;
      System.out.println(findMaxNum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMaxNum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var num : int ; num := arr[0+1] ;
         var i : int ; i := n - 1 ; while i >= 0 do ( (     num := num * 10 + arr[i+1] )  ;     i := i - 1 ) ; 
     return num );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,0} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMaxNum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  void run(){
    for(; ; ){
      int n=ni();
      int m=ni();
      if((n | m)==0){
        break ;
      }
      int[] h=new int[n];
      int[] w=new int[m];
      for(int i=0 ; i<n ; ++i){
        h[i]=ni();
      }
      for(int j=0 ; j<m ; ++j){
        w[j]=ni();
      }
      int[] W=new int[1500*1000+1];
      for(int i=0 ; i<m ; ++i){
        int sum=0 ;
        for(int j=i ; j<m ; ++j){
          sum+=w[j];
++W[sum];
        }
      }
      int ans=0 ;
      for(int i=0 ; i<n ; ++i){
        int sum=0 ;
        for(int j=i ; j<n ; ++j){
          sum+=h[j];
          ans+=W[sum];
        }
      }
      System.out.println(ans);
    }
  }
  Main(){
    sc=new Scanner(System.in);
  }
  int ni(){
    return sc.nextInt();
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := ni() ;
     var m : int ; m := ni() ;
    if ((MathLib.bitwiseOr(n,m)) = 0) then (     break ) else skip ; 
    var h : Sequence(int) ; h := Integer.subrange(1,n)->collect(0) ;
    var w : Sequence(int) ; w := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     h[i+1] := ni() )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < m do ( (     w[j+1] := ni() )  ;     j := j + 1 ) ; 
    var W : Sequence(int) ; W := Integer.subrange(1,1500 * 1000 + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := i ; while j < m do ( (     sum := sum+(w[j+1]) ; 
     W[sum+1] := W[sum+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := i ; while j < n do ( (     sum := sum+(h[j+1]) ; 
     ans := ans+(W[sum+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ) );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt(),m=sc.nextInt();
      if((n | m)==0)break ;
      int h[]=new int[n+1],w[]=new int[m+1];
      for(int i=0 ; i<n ; i++)h[i+1]=sc.nextInt()+h[i];
      for(int j=0 ; j<m ; j++)w[j+1]=sc.nextInt()+w[j];
      short[] len=new short[1500*1000+1];
      for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<=n ; j++)len[h[j]-h[i] ]++;
      int cnt=0 ;
      for(int i=0 ; i<m ; i++)for(int j=i+1 ; j<=m ; j++)cnt+=len[w[j]-w[i] ];
      System.out.println(cnt);
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseOr(n,m)) = 0) then     break else skip ; 
    var h : Sequence(int) ; h := Integer.subrange(1,n + 1)->collect(0) ;
    var w : Sequence(void) ; w := Integer.subrange(1,m + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     h[i + 1+1] := sc.getCurrent()->toInteger() + h[i+1] ;  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < m do (     w[j + 1+1] := sc.getCurrent()->toInteger() + w[j+1] ;  ;     j := j + 1 ) ; 
    var len : Sequence(int) ; len := Integer.subrange(1,1500 * 1000 + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j <= n do (     len[h[j+1] - h[i+1]+1] := len[h[j+1] - h[i+1]+1] + 1 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < m do (         var j : int ; j := i + 1 ; while j <= m do (     cnt := cnt+(len[w[j+1] - w[i+1]+1]) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(true){
      int[] n=new int[2];
      @ SuppressWarnings("unchecked")MultiSet<Integer>[] set=new MultiSet[2];
      for(int i=0 ; i<2 ; i++){
        n[i]=in.nextInt();
        set[i]=new MultiSet<Integer>();
      }
      if(n[0]==0 && n[1]==0)break ;
      for(int i=0 ; i<2 ; i++){
        int[] w=new int[n[i] ];
        for(int j=0 ; j<n[i]; j++){
          w[j]=in.nextInt();
        }
        for(int j=0 ; j<n[i]; j++){
          int sum=0 ;
          for(int k=j ; k<n[i]; k++){
            sum+=w[k];
            set[i] .add(sum);
          }
        }
      }
      long res=0 ;
      for(int i : set[0] .set.keySet()){
        if(set[1] .set.containsKey(i)){
          res+=set[0] .get(i)*set[1] .get(i);
        }
      }
      System.out.println(res);
    }
  }
}
class MultiSet<T>{
  HashMap<T,Integer>set ;
  public MultiSet(){
    set=new HashMap<T,Integer>();
  }
  public void add(T val){
    if(set.containsKey(val)){
      set.put(val,set.get(val)+1);
    }
    else {
      set.put(val,1);
    }
  }
  public int get(T val){
    if(set.containsKey(val))return set.get(val);
    return 0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : Sequence(int) ; n := Integer.subrange(1,2)->collect(0) ;
     var set : Sequence(MultiSet<int>) ; set := Integer.subrange(1,2)->collect(null) ;
        var i : int ; i := 0 ; while i < 2 do ( (     n[i+1] := in.getCurrent()->toInteger() ; 
     set[i+1] := MultiSet<int>.newMultiSet() )  ;     i := i + 1 ) ; 
    if (n[0+1] = 0 & n[1+1] = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < 2 do ( (     var w : Sequence(int) ; w := Integer.subrange(1,n[i+1])->collect(0) ;
         var j : int ; j := 0 ; while j < n[i+1] do ( (     w[j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < n[i+1] do ( (     var sum : int ; sum := 0 ;
         var k : int ; k := j ; while k < n[i+1] do ( (     sum := sum+(w[k+1]) ; 
     set[i+1]->excludes(sum) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
    for (i : set[0+1].set.keySet()) do ( (     if (set[1+1].set.containsKey(i)) then (     res := res+(set[0+1]->at(i+1) * set[1+1]->at(i+1)) ) else skip )  ) ; 
    OclFile["System.out"].println(res) ; 
 ) );
}
class MultiSet<T> {
   attribute set : Map(T,int);
   static operation newMultiSet() : MultiSet
  pre: true
  post: true
  activity:
  ( var self : MultiSet ;
    self := createMultiSet();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     set := Map{} );
   operation add( val : T) : void
  pre: true
  post: true
  activity: (     if (set->keys()->includes(val)) then (     set := set->union(Map{val |-> set->at(val) + 1}) ) else (     set := set->union(Map{val |-> 1}) ) );
   operation get( val : T) : int
  pre: true
  post: true
  activity: (     if (set->keys()->includes(val)) then     return set->at(val) else skip ; 
     return 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileInputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  static int n,m ;
  static int[] h,w ;
  private static int check(int sx,int sy){
    int x=sx ;
    int y=sy ;
    int count=0 ;
    int width=w[sx];
    int height=h[sy];
    while(true){
      if(width==height){
        count++;
        x++;
        if(x>=m)return count ;
        width+=w[x];
      }
      else if(width<height){
        x++;
        if(x>=m)return count ;
        width+=w[x];
      }
      else {
        y++;
        if(y>=n)return count ;
        height+=h[y];
      }
    }
  }
  public static void main(String[] args){
    Scanner sca=new Scanner(System.in);
    while(true){
      n=sca.nextInt();
      m=sca.nextInt();
      if(n==0)break ;
      int i,j,k ;
      h=new int[n];
      for(i=0 ; i<n ; i++)h[i]=sca.nextInt();
      w=new int[m];
      for(i=0 ; i<m ; i++)w[i]=sca.nextInt();
      int count=0 ;
      int x,y ;
      for(y=0 ; y<n ; y++){
        for(x=0 ; x<m ; x++){
          count+=check(x,y);
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute h : Sequence(int);
  static   operation check( sx : int, sy : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := sx ;
     var y : int ; y := sy ;
    var count : int ; count := 0 ;
    var width : int ; width := w[sx+1] ;
    var height : int ; height := h[sy+1] ;
    while (true) do (     if (width = height) then (     count := count + 1 ; 
     x := x + 1 ; 
     if (x >= m) then     return count else skip ; 
     width := width+(w[x+1]) ) else     if (width < height) then (     x := x + 1 ; 
     if (x >= m) then     return count else skip ; 
     width := width+(w[x+1]) ) else (     y := y + 1 ; 
     if (y >= n) then     return count else skip ; 
     height := height+(h[y+1]) ) ;  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sca : OclFile ; sca := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     n := sca.getCurrent()->toInteger() ; 
     m := sca.getCurrent()->toInteger() ; 
    if (n = 0) then     break else skip ; 
    var i : int ;
    var j : int ;
    var k : int ;
    h := Integer.subrange(1,n)->collect(0) ; 
        i := 0 ; while i < n do (     h[i+1] := sca.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    w := Integer.subrange(1,m)->collect(0) ; 
        i := 0 ; while i < m do (     w[i+1] := sca.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var x : int ;
    var y : int ;
        y := 0 ; while y < n do ( (         x := 0 ; while x < m do ( (     count := count+(check(x, y)) )  ;     x := x + 1 ) )  ;     y := y + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class A1450 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      in.nextInt();
      char[] S=in.next().toCharArray();
      Arrays.sort(S);
      System.out.println(new String(S));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1450 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     skip ; 
     var S : Sequence(String) ; S := in.getCurrent()->characters() ;
     S := S->sort() ; 
     OclFile["System.out"].println(StringLib.newString(S)) )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int MOD=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr);
    Combination cmb=new Combination(n+1);
    long pSum=0 ;
    long mSum=0 ;
    for(int i=0 ; i<=n-k ; i++){
      long count=cmb.getComb(n-i-1,k-1);
      mSum+=(arr[i]+MOD)% MOD*count % MOD ;
      mSum %=MOD ;
      pSum+=(arr[n-i-1]+MOD)% MOD*count % MOD ;
      pSum %=MOD ;
    }
    System.out.println((pSum-mSum+MOD)% MOD);
  }
}
class Combination {
  static final int MOD=1000000007 ;
  long[] fac ;
  long[] finv ;
  long[] inv ;
  public Combination(int size){
    fac=new long[size];
    finv=new long[size];
    inv=new long[size];
    fac[0]=1 ;
    fac[1]=1 ;
    finv[0]=1 ;
    finv[1]=1 ;
    inv[1]=1 ;
    for(int i=2 ; i<size ; i++){
      fac[i]=fac[i-1]*i % MOD ;
      inv[i]=MOD-inv[MOD % i]*(MOD/i)% MOD ;
      finv[i]=finv[i-1]*inv[i] % MOD ;
    }
  }
  public long getComb(int n,int k){
    if(n<k || n<0 || k<0){
      return 0 ;
    }
    return fac[n]*(finv[k]*finv[n-k] % MOD)% MOD ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var cmb : Combination ; cmb := Combination.newCombination(n + 1) ;
    var pSum : long ; pSum := 0 ;
    var mSum : long ; mSum := 0 ;
        var i : int ; i := 0 ; while i <= n - k do ( (     var count : long ; count := cmb.getComb(n - i - 1, k - 1) ;
     mSum := mSum+((arr[i+1] + MOD) mod MOD * count mod MOD) ; 
    mSum := mSum mod MOD ; 
    pSum := pSum+((arr[n - i - 1+1] + MOD) mod MOD * count mod MOD) ; 
    pSum := pSum mod MOD ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((pSum - mSum + MOD) mod MOD) ; 
 );
}
class Combination {
  static    attribute MOD : int := 1000000007;
   attribute fac : Sequence(long);
   attribute finv : Sequence(long);
   attribute inv : Sequence(long);
   static operation newCombination( size : int) : Combination
  pre: true
  post: true
  activity:
  ( var self : Combination ;
    self := createCombination();
    self.initialise(size);
    return self );
  operation initialise( size : int) : void
  pre: true  post: true
  activity: (     fac := Integer.subrange(1,size)->collect(0) ; 
     finv := Integer.subrange(1,size)->collect(0) ; 
    inv := Integer.subrange(1,size)->collect(0) ; 
    fac[0+1] := 1 ; 
    fac[1+1] := 1 ; 
    finv[0+1] := 1 ; 
    finv[1+1] := 1 ; 
    inv[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < size do ( (     fac[i+1] := fac[i - 1+1] * i mod MOD ; 
     inv[i+1] := MOD - inv[MOD mod i+1] * (MOD / i) mod MOD ; 
     finv[i+1] := finv[i - 1+1] * inv[i+1] mod MOD )  ;     i := i + 1 ) ; 
 );
   operation getComb( n : int, k : int) : long
  pre: true
  post: true
  activity: (     if (n < k or n < 0 or k < 0) then (     return 0 ) else skip ; 
     return fac[n+1] * (finv[k+1] * finv[n - k+1] mod MOD) mod MOD );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.BigDecimal ;
import java.awt.geom.*;
import static java.util.Arrays.*;
class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=Integer.parseInt(stdIn.next());
    int W=Integer.parseInt(stdIn.next());
    int H=Integer.parseInt(stdIn.next());
    int x=0 ;
    int y=0 ;
    int w=0 ;
    int[] width=new int[W+1];
    int[] height=new int[H+1];
    boolean flag=false ;
    for(int i=0 ; i<n ; i++){
      x=Integer.parseInt(stdIn.next());
      y=Integer.parseInt(stdIn.next());
      w=Integer.parseInt(stdIn.next());
      boolean flag1=false ;
      boolean flag2=false ;
      int lx=Math.max(0,x-w);
      int hx=Math.min(W,x+w);
      int ly=Math.max(0,y-w);
      int hy=Math.min(H,y+w);
      width[lx]++;
      width[hx]--;
      height[ly]++;
      height[hy]--;
    }
    int count=0 ;
    for(int i=0 ; i<W ; i++){
      count+=width[i];
      if(count<=0){
        flag=true ;
      }
    }
    count=0 ;
    for(int i=0 ; i<H ; i++){
      count+=height[i];
      if(count<=0 && flag){
        out.println("No");
        out.flush();
        return ;
      }
    }
    out.println("Yes");
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (stdIn.getCurrent())->toInteger() ;
    var W : int ; W := (stdIn.getCurrent())->toInteger() ;
    var H : int ; H := (stdIn.getCurrent())->toInteger() ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var w : int ; w := 0 ;
    var width : Sequence(int) ; width := Integer.subrange(1,W + 1)->collect(0) ;
    var height : Sequence(int) ; height := Integer.subrange(1,H + 1)->collect(0) ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < n do ( (     x := (stdIn.getCurrent())->toInteger() ; 
     y := (stdIn.getCurrent())->toInteger() ; 
    w := (stdIn.getCurrent())->toInteger() ; 
    var flag1 : boolean ; flag1 := false ;
    var flag2 : boolean ; flag2 := false ;
    var lx : int ; lx := Set{0, x - w}->max() ;
    var hx : int ; hx := Set{W, x + w}->min() ;
    var ly : int ; ly := Set{0, y - w}->max() ;
    var hy : int ; hy := Set{H, y + w}->min() ;
    width[lx+1] := width[lx+1] + 1 ; 
    width[hx+1] := width[hx+1] - 1 ; 
    height[ly+1] := height[ly+1] + 1 ; 
    height[hy+1] := height[hy+1] - 1 ; 
 )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < W do ( (     count := count+(width[i+1]) ; 
     if (count <= 0) then (     flag := true ) else skip )  ;     i := i + 1 ) ; 
    count := 0 ; 
        var i : int ; i := 0 ; while i < H do ( (     count := count+(height[i+1]) ; 
     if (count <= 0 & flag) then (     skip ; 
     skip ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
public class ProblemG12A {
  public static void main(String[] args)throws Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter writer=new PrintWriter(System.out);
    int t=Integer.parseInt(reader.readLine());
    for(int i=0 ; i<t ; i++){
      int n=Integer.parseInt(reader.readLine());
      String line=reader.readLine();
      char[] array=line.toCharArray();
      Arrays.sort(array);
      for(int j=0 ; j<n ; j++){
        writer.print(array[j]);
      }
      writer.println();
    }
    reader.close();
    writer.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemG12A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (reader.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := (reader.readLine())->toInteger() ;
     var line : String ; line := reader.readLine() ;
    var array : Sequence(String) ; array := line->characters() ;
    array := array->sort() ; 
        var j : int ; j := 0 ; while j < n do ( (     skip )  ;     j := j + 1 ) ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      String s=sc.next();
      StringBuilder ans=new StringBuilder();
      int c=0 ;
      for(int i=0 ; i<n ; i++){
        char ch=s.charAt(i);
        if(ch!='t'){
          ans.append(ch);
        }
        else c++;
      }
      for(int i=0 ; i<c ; i++)ans.append('t');
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
    var ans : String ; ans := StringLib.newString() ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var ch : String ; ch := s->at(i+1) ;
     if (ch /= 't') then (     ans := ans + StringLib.newString(ch) ) else     c := c + 1 ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < c do (     ans := ans + StringLib.newString('t') ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Test {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int t=sc.nextInt();
      while(t-->0){
        int n=sc.nextInt();
        String str=sc.next();
        int rIndices=0 ;
        String ans="" ;
        for(int i=0 ; i<str.length(); i++){
          if(str.charAt(i)=='r')rIndices+=1 ;
          else ans+=""+str.charAt(i);
        }
        while(rIndices-->0){
          ans="r"+ans ;
        }
        System.out.println(ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var str : String ; str := sc.getCurrent() ;
    var rIndices : int ; rIndices := 0 ;
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = 'r') then     rIndices := rIndices+(1) ; else     ans := ans+("" + str->at(i+1)) ; )  ;     i := i + 1 ) ; 
        while (rIndices > 0) do (        rIndices := rIndices - 1 ;     skip ; (     ans := "r" + ans ) ;  ) ;  
    OclFile["System.out"].println(ans) ; 
 ) ;  ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class BuySweets {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),s=sc.nextInt();
    List<Integer>xi=new ArrayList<>();
    List<Integer>yi=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      xi.add(sc.nextInt());
      yi.add(sc.nextInt());
    }
    int ans=-1 ;
    for(int i=0 ; i<n ; i++){
      if(xi.get(i)<s && yi.get(i)!=0){
        ans=Math.max(ans,100-yi.get(i));
      }
      if(xi.get(i)<=s && yi.get(i)==0){
        ans=Math.max(ans,0);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class BuySweets {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var xi : Sequence(int) ; xi := Sequence{} ;
    var yi : Sequence(int) ; yi := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     xi := xi->including(sc.getCurrent()->toInteger()) ; 
     yi := yi->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (xi->at(i+1) < s & yi->at(i+1) /= 0) then (     ans := Set{ans, 100 - yi->at(i+1)}->max() ) else skip ; 
     if (xi->at(i+1) <= s & yi->at(i+1) = 0) then (     ans := Set{ans, 0}->max() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Cf {
  public static void main(String[] args)throws FileNotFoundException {
    FastReader in=new FastReader();
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    int n=in.nextInt();
    int s=in.nextInt();
    int min=100 ;
    boolean f=false ;
    for(int i=0 ; i<n ; i++){
      int x=in.nextInt();
      int y=in.nextInt();
      if(x<s && y!=0){
        min=Math.min(min,y);
        f=true ;
      }
      else if((x<=s)&&(y==0)){
        f=true ;
      }
    }
    if(min==100 && ! f)out.println("-1");
    else if(min==100)out.println("0");
    else out.println(100-min);
    out.close();
  }
  private static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    FastReader()throws FileNotFoundException {
      br=new BufferedReader(new InputStreamReader(System.getProperty("ONLINE_JUDGE")==null ? new FileInputStream("input.txt"): 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cf {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := in.nextInt() ;
    var s : int ; s := in.nextInt() ;
    var min : int ; min := 100 ;
    var f : boolean ; f := false ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.nextInt() ;
     var y : int ; y := in.nextInt() ;
     if (x < s & y /= 0) then (     min := Set{min, y}->min() ; 
     f := true ) else     if ((x <= s) & (y = 0)) then (     f := true ) else skip ; )  ;     i := i + 1 ) ; 
    if (min = 100 & not(f)) then     skip else     if (min = 100) then     skip else     skip ; ;  ;  
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(if OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null then OclFile.newOclFile_Read(OclFile.newOclFile("input.txt")) else OclFile["System.in"] endif)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import java.io.*;
public class Hello {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),money=in.nextInt();
    Map<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int x=in.nextInt(),y=in.nextInt();
      int total=x*100+y ;
      if(total<=(money*100)){
        int sub=100-y ;
        if(sub<=99){
          if(! map.containsKey(x)){
            map.put(x,sub);
          }
          else {
            map.put(x,Math.max(map.get(x),sub));
          }
        }
        else {
          map.put(x,0);
        }
      }
    }
    if(map.size()==0){
      pw.println(-1);
    }
    else {
      int ans=0 ;
      for(Integer i : map.values()){
        ans=Math.max(ans,i);
      }
      pw.println(ans);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hello {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var money : int ; money := in.getCurrent()->toInteger() ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
    var y : int ; y := in.getCurrent()->toInteger() ;
     var total : int ; total := x * 100 + y ;
     if (total <= (money * 100)) then (     var sub : int ; sub := 100 - y ;
     if (sub <= 99) then (     if (not(map->keys()->includes(x))) then (     map := map->union(Map{x |-> sub}) ) else (     map := map->union(Map{x |-> Set{map->at(x), sub}->max()}) ) ) else (     map := map->union(Map{x |-> 0}) ) ) else skip )  ;     i := i + 1 ) ; 
    if (map.size() = 0) then (     skip ) else (     var ans : int ; ans := 0 ;
     for (i : map->values()) do ( (     ans := Set{ans, i}->max() )  ) ; 
     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Asphalting {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int[] h=new int[n+1];
    int[] v=new int[n+1];
    String res="" ;
    for(int i=1 ; i<=n*n ; i++){
      int ho=scanner.nextInt();
      int ve=scanner.nextInt();
      if(h[ho]==0 && v[ve]==0){
        h[ho]=1 ;
        v[ve]=1 ;
        res+=i+" " ;
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Asphalting {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var h : Sequence(int) ; h := Integer.subrange(1,n + 1)->collect(0) ;
    var v : Sequence(int) ; v := Integer.subrange(1,n + 1)->collect(0) ;
    var res : String ; res := "" ;
        var i : int ; i := 1 ; while i <= n * n do ( (     var ho : int ; ho := scanner.getCurrent()->toInteger() ;
     var ve : int ; ve := scanner.getCurrent()->toInteger() ;
     if (h[ho+1] = 0 & v[ve+1] = 0) then (     h[ho+1] := 1 ; 
     v[ve+1] := 1 ; 
     res := res+(i + " ") ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeSet ;
public class road {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Set<Integer>s1=new TreeSet<>();
    Set<Integer>s2=new TreeSet<>();
    for(int i=0 ; i<n*n ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      if((! s1.contains(x))&&(! s2.contains(y))){
        System.out.print(i+1+" ");
        s1.add(x);
        s2.add(y);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class road {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s1 : Set(int) ; s1 := Set{} ;
    var s2 : Set(int) ; s2 := Set{} ;
        var i : int ; i := 0 ; while i < n * n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     if ((not(s1->includes(x))) & (not(s2->includes(y)))) then (     OclFile["System.out"].print(i + 1 + " ") ; 
     s1 := s1->including(x) ; 
     s2 := s2->including(y) ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class AsphaltingRoads {
  public static void main(String[] args)throws FileNotFoundException {
    FastReader in=new FastReader();
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    int n=in.nextInt();
    boolean[] row=new boolean[51];
    boolean[] col=new boolean[51];
    for(int i=0 ; i<n*n ; i++){
      int x=in.nextInt();
      int y=in.nextInt();
      if(! row[x] && ! col[y]){
        row[x]=true ;
        col[y]=true ;
        out.print(((i+1))+" ");
      }
    }
    out.println();
    out.close();
  }
  private static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    FastReader()throws FileNotFoundException {
      br=new BufferedReader(new InputStreamReader(System.getProperty("ONLINE_JUDGE")==null ? new FileInputStream("input.txt"): 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AsphaltingRoads {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := in.nextInt() ;
    var row : Sequence(boolean) ; row := Integer.subrange(1,51)->collect(false) ;
    var col : Sequence(boolean) ; col := Integer.subrange(1,51)->collect(false) ;
        var i : int ; i := 0 ; while i < n * n do ( (     var x : int ; x := in.nextInt() ;
     var y : int ; y := in.nextInt() ;
     if (not(row[x+1]) & not(col[y+1])) then (     row[x+1] := true ; 
     col[y+1] := true ; 
     skip ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(if OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null then OclFile.newOclFile_Read(OclFile.newOclFile("input.txt")) else OclFile["System.in"] endif)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int k=scanner.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scanner.nextInt();
    }
    Arrays.parallelSort(a);
    int result=0 ;
    int temp ;
    for(int i=0 ; n-1-i>=k-1 ; i++){
      temp=(int)((long)(a[n-1-i]-a[i])*comb(n-1-i,k-1)% MOD);
      result=(result+temp)% MOD ;
    }
    while(result<0)result+=MOD ;
    System.out.println(result);
  }
  static final int MOD=1000000007 ;
  static final int FACT_MAX=100000 ;
  static int[] FACT=new int[FACT_MAX+1];
  static {
    FACT[0]=1 ;
    for(int i=1 ; i<=FACT_MAX ; i++){
      FACT[i]=(int)((long)FACT[i-1]*i % MOD);
    }
  }
  static int comb(int n,int k){
    return(int)((long)FACT[n]*inverse((int)((long)FACT[k]*FACT[n-k] % MOD))% MOD);
  }
  static int inverse(int denom){
    return power(denom,MOD-2);
  }
  static int power(int b,int p){
    long res=1 ;
    for(long a=b % MOD ; p>0 ; a=a*a % MOD,p>>=1)if((p & 1)>0)res=res*a % MOD ;
    return(int)res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var result : int ; result := 0 ;
    var temp : int ;
        var i : int ; i := 0 ; while n - 1 - i >= k - 1 do ( (     temp := ((a[n - 1 - i+1] - a[i+1])->oclAsType(long) * comb(n - 1 - i, k - 1) mod MOD)->oclAsType(int) ; 
     result := (result + temp) mod MOD )  ;     i := i + 1 ) ; 
    while (result < 0) do     result := result+(MOD) ; ; 
    OclFile["System.out"].println(result) ; 
 );
  static    attribute MOD : int := 1000000007;
  static    attribute FACT_MAX : int := 100000;
  static   attribute FACT : Sequence(int) := Integer.subrange(1,FACT_MAX + 1)->collect(0);
  static operation initialiseClass()
  pre: true post: true
  activity:     FACT[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= FACT_MAX do ( (     FACT[i+1] := (FACT[i - 1+1]->oclAsType(long) * i mod MOD)->oclAsType(int) )  ;     i := i + 1 ) ; 
;
  static   operation comb( n : int, k : int) : int
  pre: true
  post: true
  activity: (     return (FACT[n+1]->oclAsType(long) * inverse((FACT[k+1]->oclAsType(long) * FACT[n - k+1] mod MOD)->oclAsType(int)) mod MOD)->oclAsType(int) );
  static   operation inverse( denom : int) : int
  pre: true
  post: true
  activity: (     return power(denom, MOD - 2) );
  static   operation power( b : int, p : int) : int
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var a : long ; a := b mod MOD ; while p > 0 do (     if ((p & 1) > 0) then     res := res * a mod MOD ; else skip ;  ;     a := a * a mod MOD ;     p := p/(2->pow(1)) ) ; 
     return res->oclAsType(int) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long m=sc.nextLong();
    for(long i=0 ; i<m ; i++){
      long money=sc.nextLong();
      long year=sc.nextLong();
      long n=sc.nextLong();
      long max=0 ;
      for(long j=0 ; j<n ; j++){
        long way=sc.nextLong();
        double p=sc.nextDouble();
        long cost=sc.nextLong();
        long currentMoney=money ;
        if(way==0){
          long sum=0 ;
          for(long k=0 ; k<year ; k++){
            sum+=currentMoney*p ;
            currentMoney-=cost ;
          }
          max=Math.max(max,currentMoney+sum);
        }
        else {
          for(long k=0 ; k<year ; k++){
            currentMoney+=currentMoney*p-cost ;
          }
          max=Math.max(max,currentMoney);
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : long ; m := sc.getCurrent()->toLong() ;
         var i : long ; i := 0 ; while i < m do ( (     var money : long ; money := sc.getCurrent()->toLong() ;
     var year : long ; year := sc.getCurrent()->toLong() ;
    var n : long ; n := sc.getCurrent()->toLong() ;
    var max : long ; max := 0 ;
        var j : long ; j := 0 ; while j < n do ( (     var way : long ; way := sc.getCurrent()->toLong() ;
     var p : double ; p := sc.getCurrent()->toReal() ;
    var cost : long ; cost := sc.getCurrent()->toLong() ;
    var currentMoney : long ; currentMoney := money ;
    if (way = 0) then (     var sum : long ; sum := 0 ;
         var k : long ; k := 0 ; while k < year do ( (     sum := sum+(currentMoney * p) ; 
     currentMoney := currentMoney-(cost) )  ;     k := k + 1 ) ; 
     max := Set{max, currentMoney + sum}->max() ) else (         var k : long ; k := 0 ; while k < year do ( (     currentMoney := currentMoney+(currentMoney * p - cost) )  ;     k := k + 1 ) ; 
     max := Set{max, currentMoney}->max() ) ;  
 )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    words=br.readLine().split(" ");
    int N,W,H ;
    N=parseInt(words[0]);
    W=parseInt(words[1]);
    H=parseInt(words[2]);
    int[] xs=new int[W];
    int[] ys=new int[H];
    for(int i=0 ; i<N ; i++){
      words=br.readLine().split(" ");
      int x,y,w ;
      x=parseInt(words[0]);
      y=parseInt(words[1]);
      w=parseInt(words[2]);
      if(0<=x-w){
        xs[x-w]++;
      }
      else {
        xs[0]++;
      }
      if(x+w<W){
        xs[x+w]--;
      }
      if(0<=y-w){
        ys[y-w]++;
      }
      else {
        ys[0]++;
      }
      if(y+w<H){
        ys[y+w]--;
      }
    }
    boolean fillW=true,fillH=true ;
    for(int i=0 ; i<xs.length ; i++){
      if(0<i){
        xs[i]+=xs[i-1];
      }
      if(xs[i]==0){
        fillW=false ;
        break ;
      }
    }
    for(int i=0 ; i<ys.length ; i++){
      if(0<i){
        ys[i]+=ys[i-1];
      }
      if(ys[i]==0){
        fillH=false ;
        break ;
      }
    }
    if(fillW | fillH){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    words := br.readLine()->split(" ") ; 
    var N : int ;
    var W : int ;
    var H : int ;
    N := (words[0+1] + "")->toInteger() ; 
    W := (words[1+1] + "")->toInteger() ; 
    H := (words[2+1] + "")->toInteger() ; 
    var xs : Sequence(int) ; xs := Integer.subrange(1,W)->collect(0) ;
    var ys : Sequence(int) ; ys := Integer.subrange(1,H)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     words := br.readLine()->split(" ") ; 
     var x : int ;
    var y : int ;
    var w : int ;
    x := (words[0+1] + "")->toInteger() ; 
    y := (words[1+1] + "")->toInteger() ; 
    w := (words[2+1] + "")->toInteger() ; 
    if (0 <= x - w) then (     xs[x - w+1] := xs[x - w+1] + 1 ) else (     xs[0+1] := xs[0+1] + 1 ) ;  
    if (x + w < W) then (     xs[x + w+1] := xs[x + w+1] - 1 ) else skip ; 
    if (0 <= y - w) then (     ys[y - w+1] := ys[y - w+1] + 1 ) else (     ys[0+1] := ys[0+1] + 1 ) ;  
    if (y + w < H) then (     ys[y + w+1] := ys[y + w+1] - 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    var fillW : boolean ; fillW := true ;
    var fillH : boolean ; fillH := true ;
        var i : int ; i := 0 ; while i < xs->size() do ( (     if (0 < i) then (     xs[i+1] := xs[i+1]+(xs[i - 1+1]) ) else skip ; 
     if (xs[i+1] = 0) then (     fillW := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < ys->size() do ( (     if (0 < i) then (     ys[i+1] := ys[i+1]+(ys[i - 1+1]) ) else skip ; 
     if (ys[i+1] = 0) then (     fillH := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (MathLib.bitwiseOr(fillW,fillH)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    for(int i=0 ; i<n ; i++){
      int money0=Integer.parseInt(br.readLine());
      int year=Integer.parseInt(br.readLine());
      int numOfMethod=Integer.parseInt(br.readLine());
      int maxResult=-1 ;
      for(int j=0 ; j<numOfMethod ; j++){
        String[] tmpStr=br.readLine().split(" ");
        int method=Integer.parseInt(tmpStr[0]);
        double ratio=Double.parseDouble(tmpStr[1]);
        int fee=Integer.parseInt(tmpStr[2]);
        int result=0 ;
        if(method==0){
          result=calcTanri(money0,year,ratio,fee);
        }
        else if(method==1){
          result=calcFukuri(money0,year,ratio,fee);
        }
        if(result>maxResult){
          maxResult=result ;
        }
      }
      System.out.println(maxResult);
    }
  }
  private static int calcFukuri(int money0,int year,double ratio,int fee){
    for(int i=0 ; i<year ; i++){
      money0*=(1+ratio);
      money0-=fee ;
    }
    return money0 ;
  }
  private static int calcTanri(int money0,int year,double ratio,int fee){
    int rishiSum=0 ;
    for(int i=0 ; i<year ; i++){
      rishiSum+=money0*ratio ;
      money0-=fee ;
    }
    return money0+rishiSum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var money0 : int ; money0 := (br.readLine())->toInteger() ;
     var year : int ; year := (br.readLine())->toInteger() ;
    var numOfMethod : int ; numOfMethod := (br.readLine())->toInteger() ;
    var maxResult : int ; maxResult := -1 ;
        var j : int ; j := 0 ; while j < numOfMethod do ( (     var tmpStr : Sequence(String) ; tmpStr := br.readLine()->split(" ") ;
     var method : int ; method := (tmpStr[0+1])->toInteger() ;
    var ratio : double ; ratio := (tmpStr[1+1])->toReal() ;
    var fee : int ; fee := (tmpStr[2+1])->toInteger() ;
    var result : int ; result := 0 ;
    if (method = 0) then (     result := calcTanri(money0, year, ratio, fee) ) else     if (method = 1) then (     result := calcFukuri(money0, year, ratio, fee) ) else skip ; ;  
    if (result > maxResult) then (     maxResult := result ) else skip ; 
 )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(maxResult) ; 
 )  ;     i := i + 1 ) );
  static   operation calcFukuri( money0 : int, year : int, ratio : double, fee : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < year do ( (     money0 := money0*((1 + ratio)) ; 
     money0 := money0-(fee) )  ;     i := i + 1 ) ; 
     return money0 );
  static   operation calcTanri( money0 : int, year : int, ratio : double, fee : int) : int
  pre: true
  post: true
  activity: (     var rishiSum : int ; rishiSum := 0 ;
         var i : int ; i := 0 ; while i < year do ( (     rishiSum := rishiSum+(money0 * ratio) ; 
     money0 := money0-(fee) )  ;     i := i + 1 ) ; 
     return money0 + rishiSum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int m=sc.nextInt();
    while(m!=0){
      int money=sc.nextInt();
      int year=sc.nextInt();
      int type=sc.nextInt();
      int finalAns=0 ;
      while(type!=0){
        int tanri=sc.nextInt();
        double rate=sc.nextDouble();
        int tesu=sc.nextInt();
        int ans=solve(money,year,tanri,rate,tesu);
        if(ans>finalAns)finalAns=ans ;
        type--;
      }
      System.out.println(finalAns);
      m--;
    }
  }
  public static int solve(int money,int year,int tanri,double rate,int tesu){
    int zandaka=0 ;
    int ratesum=0 ;
    if(tanri==1){
      while(year!=0){
        zandaka=money+(int)(money*rate)-tesu ;
        money=zandaka ;
        year--;
      }
    }
    else if(tanri==0){
      while(year!=0){
        zandaka=money-tesu ;
        ratesum+=(int)(money*rate);
        money=zandaka ;
        year--;
      }
    }
    return zandaka+ratesum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     while (m /= 0) do (     var money : int ; money := sc.getCurrent()->toInteger() ;
     var year : int ; year := sc.getCurrent()->toInteger() ;
    var type : int ; type := sc.getCurrent()->toInteger() ;
    var finalAns : int ; finalAns := 0 ;
    while (type /= 0) do (     var tanri : int ; tanri := sc.getCurrent()->toInteger() ;
     var rate : double ; rate := sc.getCurrent()->toReal() ;
    var tesu : int ; tesu := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := solve(money, year, tanri, rate, tesu) ;
    if (ans > finalAns) then     finalAns := ans ; else skip ; 
    type := type - 1 ; 
 ) ; 
    OclFile["System.out"].println(finalAns) ; 
    m := m - 1 ; 
 ) );
  static   operation solve( money : int, year : int, tanri : int, rate : double, tesu : int) : int
  pre: true
  post: true
  activity: (     var zandaka : int ; zandaka := 0 ;
     var ratesum : int ; ratesum := 0 ;
     if (tanri = 1) then (     while (year /= 0) do (     zandaka := money + (money * rate)->oclAsType(int) - tesu ; 
     money := zandaka ; 
     year := year - 1 ) ) else     if (tanri = 0) then (     while (year /= 0) do (     zandaka := money - tesu ; 
     ratesum := ratesum+((money * rate)->oclAsType(int)) ; 
     money := zandaka ; 
     year := year - 1 ) ) else skip ; ;  
     return zandaka + ratesum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.math.BigDecimal ;
public class Main {
  Main(){
    Scanner sc=new Scanner(System.in);
    int m=sc.nextInt();
    for(int k=0 ; k<m ; k++){
      String str=sc.next();
      BigDecimal def=new BigDecimal(str);
      int y=sc.nextInt();
      int n=sc.nextInt();
      BigDecimal bdm=new BigDecimal(0);
      for(int i=0 ; i<n ; i++){
        int s=sc.nextInt();
        str=sc.next();
        BigDecimal bd2=new BigDecimal(str);
        str=sc.next();
        BigDecimal bd3=new BigDecimal(str);
        BigDecimal bd=def ;
        BigDecimal bd4=new BigDecimal(0);
        if(s==1){
          for(int j=0 ; j<y ; j++){
            bd4=bd.multiply(bd2);
            bd4=bd4.setScale(0,BigDecimal.ROUND_DOWN);
            bd=bd4.add(bd);
            bd=bd.subtract(bd3);
          }
        }
        else {
          for(int j=0 ; j<y ; j++){
            bd4=bd4.add(bd2.multiply(bd));
            bd4=bd4.setScale(0,BigDecimal.ROUND_DOWN);
            bd=bd.subtract(bd3);
          }
          bd=bd.add(bd4);
        }
        if(bdm.compareTo(bd)==-1){
          bdm=bd ;
        }
      }
      System.out.println(bdm.toString());
    }
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
         var k : int ; k := 0 ; while k < m do ( (     var str : String ; str := sc.getCurrent() ;
     var def : double ; def := double(str) ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var bdm : double ; bdm := double(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     str := sc.getCurrent() ; 
    var bd2 : double ; bd2 := double(str) ;
    str := sc.getCurrent() ; 
    var bd3 : double ; bd3 := double(str) ;
    var bd : double ; bd := def ;
    var bd4 : double ; bd4 := double(0) ;
    if (s = 1) then (         var j : int ; j := 0 ; while j < y do ( (     bd4 := bd.multiply(bd2) ; 
     bd4 := bd4.setScale(0, ROUND_DOWN) ; 
     bd := bd4->excludes(bd) ; 
     bd := bd.subtract(bd3) )  ;     j := j + 1 ) ) else (         var j : int ; j := 0 ; while j < y do ( (     bd4 := bd4->excludes(bd2.multiply(bd)) ; 
     bd4 := bd4.setScale(0, ROUND_DOWN) ; 
     bd := bd.subtract(bd3) )  ;     j := j + 1 ) ; 
     bd := bd->excludes(bd4) ) ;  
    if (bdm->compareTo(bd) = -1) then (     bdm := bd ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(bdm+"") ; 
 )  ;     k := k + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class RedVsBlue {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int r=sc.nextInt();
      int b=sc.nextInt();
      int parts=r/(b+1);
      int remain=r %(b+1);
      while(r>0){
        for(int i=1 ; i<=parts ; i++){
          System.out.print("R");
        }
        r-=parts ;
        if(remain>0){
          System.out.print("R");
          remain--;
          r--;
        }
        if(b>0){
          System.out.print("B");
          b--;
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class RedVsBlue {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var parts : int ; parts := r / (b + 1) ;
    var remain : int ; remain := r mod (b + 1) ;
    while (r > 0) do (         var i : int ; i := 1 ; while i <= parts do ( (     OclFile["System.out"].print("R") )  ;     i := i + 1 ) ; 
     r := r-(parts) ; 
     if (remain > 0) then (     OclFile["System.out"].print("R") ; 
     remain := remain - 1 ; 
     r := r - 1 ) else skip ; 
     if (b > 0) then (     OclFile["System.out"].print("B") ; 
     b := b - 1 ) else skip ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class RedVersusBlue {
  private static Scanner s=new Scanner(System.in);
  private static void solve(){
    int n=s.nextInt(),r=s.nextInt(),b=s.nextInt();
    List<StringBuilder>sbs=new ArrayList<>();
    for(int i=0 ; i<b+1 ; i++){
      StringBuilder sb=new StringBuilder();
      sbs.add(sb);
    }
    int start=0 ;
    for(int i=0 ; i<r ; i++){
      if(start<sbs.size()){
        sbs.get(start).append("R");
        start++;
      }
      else {
        start=0 ;
        sbs.get(start).append("R");
        start++;
      }
    }
    for(int i=0 ; i<b ; i++){
      sbs.get(i).append("B");
    }
    StringBuilder res=new StringBuilder();
    for(int i=0 ; i<sbs.size(); i++)res.append(sbs.get(i));
    System.out.println(res);
  }
  public static void main(String[] args){
    int t=s.nextInt();
    while(t-->0){
      solve();
    }
    s.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class RedVersusBlue {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := s.getCurrent()->toInteger() ;
    var r : int ; r := s.getCurrent()->toInteger() ;
    var b : int ; b := s.getCurrent()->toInteger() ;
     var sbs : Sequence(String) ; sbs := Sequence{} ;
        var i : int ; i := 0 ; while i < b + 1 do ( (     var sb : String ; sb := StringLib.newString() ;
     sbs := sbs->including(sb) )  ;     i := i + 1 ) ; 
    var start : int ; start := 0 ;
        var i : int ; i := 0 ; while i < r do ( (     if (start < sbs->size()) then (     sbs := sbs->at(start+1) + StringLib.newString("R") ; 
     start := start + 1 ) else (     start := 0 ; 
     sbs := sbs->at(start+1) + StringLib.newString("R") ; 
     start := start + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < b do ( (     sbs := sbs->at(i+1) + StringLib.newString("B") )  ;     i := i + 1 ) ; 
    var res : String ; res := StringLib.newString() ;
        var i : int ; i := 0 ; while i < sbs->size() do (     res := res + StringLib.newString(sbs->at(i+1)) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_Red_Versus_Blue {
  static int t,n ;
  static int r,b ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    t=scanner.nextInt();
    while(t>0){
      t--;
      n=scanner.nextInt();
      r=scanner.nextInt();
      b=scanner.nextInt();
      Solve();
      Endl();
    }
  }
  public static void Solve(){
    int x=r/(b+1);
    int cntr=0 ;
    for(int i=1 ; i<=n ; i++){
      if(cntr<x){
        System.out.print("R");
        cntr++;
        r--;
      }
      else if(b>0){
        System.out.print("B");
        cntr=0 ;
        b--;
        x=r/(b+1);
      }
      else System.out.print("R");
    }
  }
  private static void Endl(){
    System.out.println("");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Red_Versus_Blue {
  static   attribute t : int;
  static   attribute r : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     t := scanner.getCurrent()->toInteger() ; 
     while (t > 0) do (     t := t - 1 ; 
     n := scanner.getCurrent()->toInteger() ; 
    r := scanner.getCurrent()->toInteger() ; 
    b := scanner.getCurrent()->toInteger() ; 
    execute Solve() ; 
    execute Endl() ; 
 ) );
  static   operation Solve() : void
  pre: true
  post: true
  activity: (     var x : int ; x := r / (b + 1) ;
     var cntr : int ; cntr := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     if (cntr < x) then (     OclFile["System.out"].print("R") ; 
     cntr := cntr + 1 ; 
     r := r - 1 ) else     if (b > 0) then (     OclFile["System.out"].print("B") ; 
     cntr := 0 ; 
     b := b - 1 ; 
     x := r / (b + 1) ) else     OclFile["System.out"].print("R") ; ;  )  ;     i := i + 1 ) );
  static   operation Endl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication115 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    ArrayList<Integer>arr=new ArrayList<>();
    ArrayList<Integer>arra=new ArrayList<>();
    int maxdif=0 ;
    int maxAll=1000000000 ;
    for(int i=0 ; i<num ; i++){
      int h=sc.nextInt();
      arr.add(h);
      arra.add(h);
    }
    for(int i=1 ; i<num-1 ; i++){
      for(int j=0 ; j<arr.size()-1 ; j++){
        if(j==i){
          maxdif=Math.max(Math.abs(arr.get(j-1)-arr.get(j+1)),maxdif);
        }
        else {
          maxdif=Math.max(Math.abs(arr.get(j)-arr.get(j+1)),maxdif);
        }
      }
      maxAll=Math.min(maxAll,maxdif);
      maxdif=0 ;
    }
    System.out.println(maxAll);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication115 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Sequence{} ;
    var arra : Sequence(int) ; arra := Sequence{} ;
    var maxdif : int ; maxdif := 0 ;
    var maxAll : int ; maxAll := 1000000000 ;
        var i : int ; i := 0 ; while i < num do ( (     var h : int ; h := sc.getCurrent()->toInteger() ;
     arr := arr->including(h) ; 
     arra := arra->including(h) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < num - 1 do ( (         var j : int ; j := 0 ; while j < arr->size() - 1 do ( (     if (j = i) then (     maxdif := Set{if arr->at(j - 1+1) - arr->at(j + 1+1) < 0 then -(arr->at(j - 1+1) - arr->at(j + 1+1)) else arr->at(j - 1+1) - arr->at(j + 1+1) endif, maxdif}->max() ) else (     maxdif := Set{if arr->at(j+1) - arr->at(j + 1+1) < 0 then -(arr->at(j+1) - arr->at(j + 1+1)) else arr->at(j+1) - arr->at(j + 1+1) endif, maxdif}->max() ) )  ;     j := j + 1 ) ; 
     maxAll := Set{maxAll, maxdif}->min() ; 
     maxdif := 0 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(maxAll) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder();
    int t=fs.nextInt();
    while(t-->0){
      long n=fs.nextLong(),k=fs.nextLong();
      long fjr=0 ;
      while(n>0){
        if(n % k==0){
          n=n/k ;
          fjr++;
        }
        else {
          fjr+=(n % k);
          n-=(n % k);
        }
      }
      sb.append(fjr).append("\n");
    }
    out.println(sb);
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    var t : int ; t := fs.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := fs.nextLong() ;
    var k : long ; k := fs.nextLong() ;
     var fjr : long ; fjr := 0 ;
     while (n > 0) do (     if (n mod k = 0) then (     n := n / k ; 
     fjr := fjr + 1 ) else (     fjr := fjr+((n mod k)) ; 
     n := n-((n mod k)) ) ) ; 
     sb := sb + StringLib.newString(fjr) + StringLib.newString("\n") ) ;  ) ;  
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test {
  static long whomever(long x,long y){
    long count=0 ;
    while(x>0){
      if(x % y==0){
        x/=y ;
        count++;
      }
      else {
        count+=(x % y);
        x-=(x % y);
      }
    }
    return count ;
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t ;
    long n,k ;
    t=Integer.parseInt(scan.nextLine());
    long r[]=new long[t];
    for(int i=0 ; i<t ; i++){
      String[] y=scan.nextLine().split(" ");
      n=Long.parseLong(y[0]);
      k=Long.parseLong(y[1]);
      r[i]=whomever(n,k);
    }
    for(long i : r){
      System.out.println(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation whomever( x : long, y : long) : long
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
     while (x > 0) do (     if (x mod y = 0) then (     x := x/(y) ; 
     count := count + 1 ) else (     count := count+((x mod y)) ; 
     x := x-((x mod y)) ) ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ;
    var n : long ;
    var k : long ;
    t := (scan.nextLine())->toInteger() ; 
    var r : Sequence(long) ; r := Integer.subrange(1,t)->collect(0) ;
        var i : int ; i := 0 ; while i < t do ( (     var y : Sequence(String) ; y := scan.nextLine()->split(" ") ;
     n := (y[0+1])->toLong() ; 
     k := (y[1+1])->toLong() ; 
     r[i+1] := whomever(n, k) )  ;     i := i + 1 ) ; 
    for (i : r) do ( (     OclFile["System.out"].println(i) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int A,B,X ;
    A=sc.nextInt();
    B=sc.nextInt();
    X=sc.nextInt();
    if(X % 500!=0){
      X+=500-X % 500 ;
    }
    int a=0 ;
    int b=0 ;
    if(A<B){
      a=X/1000+((X % 1000>0)? 1 : 0);
    }
    else if(A>2*B){
      b=X/500 ;
    }
    else {
      a=X/1000 ;
      X %=1000 ;
      b=X/500 ;
    }
    System.out.println(A*a+B*b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ;
    var B : int ;
    var X : int ;
    A := sc.getCurrent()->toInteger() ; 
    B := sc.getCurrent()->toInteger() ; 
    X := sc.getCurrent()->toInteger() ; 
    if (X mod 500 /= 0) then (     X := X+(500 - X mod 500) ) else skip ; 
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
    if (A < B) then (     a := X / 1000 + (if (X mod 1000 > 0) then 1 else 0 endif) ) else     if (A > 2 * B) then (     b := X / 500 ) else (     a := X / 1000 ; 
     X := X mod 1000 ; 
     b := X / 500 ) ;  ;  
    OclFile["System.out"].println(A * a + B * b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class heroZero {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int tc=sc.nextInt();
    long n,k ;
    for(int i=0 ; i<tc ; i++){
      n=sc.nextLong();
      k=sc.nextLong();
      long count=0 ;
      while(n>0){
        if(n % k==0){
          n/=k ;
          count++;
        }
        else {
          long rem=n % k ;
          count+=rem ;
          n-=rem ;
        }
      }
      if(n==0)System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class heroZero {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := sc.getCurrent()->toInteger() ;
     var n : long ;
    var k : long ;
         var i : int ; i := 0 ; while i < tc do ( (     n := sc.getCurrent()->toLong() ; 
     k := sc.getCurrent()->toLong() ; 
    var count : long ; count := 0 ;
    while (n > 0) do (     if (n mod k = 0) then (     n := n/(k) ; 
     count := count + 1 ) else (     var rem : long ; rem := n mod k ;
     count := count+(rem) ; 
     n := n-(rem) ) ) ; 
    if (n = 0) then     OclFile["System.out"].println(count) ; else skip ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean flipsPossible(int[] a,int n){
    int count_odd=0,count_even=0 ;
    for(int i=0 ; i<n ; i++){
      if((a[i] & 1)==1)count_odd++;
      else count_even++;
    }
    if(count_odd % 2==1 && count_even % 2==1)return false ;
    else return true ;
  }
  public static void main(String[] args){
    int[] a={
      1,0,1,1,0,1 };
      int n=a.length ;
      if(flipsPossible(a,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation flipsPossible( a : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var count_odd : int ; count_odd := 0 ;
    var count_even : int ; count_even := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if ((a[i+1] & 1) = 1) then     count_odd := count_odd + 1 ; else     count_even := count_even + 1 ; )  ;     i := i + 1 ) ; 
     if (count_odd mod 2 = 1 & count_even mod 2 = 1) then     return false else     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,0,1,1,0,1} ;
     var n : int ; n := a->size() ;
     if (flipsPossible(a, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long findF_N(long n){
    long ans=0 ;
    for(long i=0 ; i<n ; ++i)ans+=(i+1)*(n-i-1);
    return ans ;
  }
  public static void main(String[] args){
    long n=3 ;
    System.out.println(findF_N(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findF_N( n : long) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
         var i : long ; i := 0 ; while i < n do (     ans := ans+((i + 1) * (n - i - 1)) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 3 ;
     OclFile["System.out"].println(findF_N(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int term(int n){
    int ans=0 ;
    for(int i=1 ; i<=n ; i++)ans+=i ;
    return ans ;
  }
  public static void main(String args[]){
    int n=4 ;
    System.out.println(term(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation term( n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i <= n do (     ans := ans+(i) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(term(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int sumOfSeries(int n){
    int ans=0 ;
    for(int i=1 ; i<=n ; i++)ans+=i*i*i*i ;
    return ans ;
  }
  public static void main(String args[]){
    int n=4 ;
    System.out.println(sumOfSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfSeries( n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i <= n do (     ans := ans+(i * i * i * i) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(sumOfSeries(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void result(long n,long k,long t){
    if(t<=k)System.out.println(t);
    else if(t<=n)System.out.println(k);
    else {
      long temp=t-n ;
      temp=k-temp ;
      System.out.println(temp);
    }
  }
  public static void main(String args[]){
    long n,k,t ;
    n=10 ;
    k=5 ;
    t=12 ;
    result(n,k,t);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation result( n : long, k : long, t : long) : void
  pre: true
  post: true
  activity: (     if (t <= k) then     OclFile["System.out"].println(t) ; else     if (t <= n) then     OclFile["System.out"].println(k) else (     var temp : long ; temp := t - n ;
     temp := k - temp ; 
     OclFile["System.out"].println(temp) ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ;
    var k : long ;
    var t : long ;
     n := 10 ; 
    k := 5 ; 
    t := 12 ; 
    execute result(n, k, t) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int minNumber(int a[],int n,int x){
    Arrays.sort(a);
    int k ;
    for(k=0 ; a[(n)/2]!=x ; k++){
      a[n++]=x ;
      Arrays.sort(a);
    }
    return k ;
  }
  public static void main(String[] args){
    int x=10 ;
    int a[]={
      10,20,30 };
      int n=3 ;
      System.out.println(minNumber(a,n-1,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minNumber( a : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var k : int ;
         k := 0 ; while a[(n) / 2+1] /= x do ( (      a[n+1] := x  ; n := n + 1 ; 
     a := a->sort() )  ;     k := k + 1 ) ; 
     return k );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 10 ;
     var a : Sequence(int) ; a := Sequence{10,20,30} ;
     var n : int ; n := 3 ;
     OclFile["System.out"].println(minNumber(a, n - 1, x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MinimumDifficulty {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[] a=new int[n];
    a[0]=scan.nextInt();
    a[1]=scan.nextInt();
    int m=a[1]-a[0];
    for(int i=2 ; i<n ; i++){
      a[i]=scan.nextInt();
      m=Math.max(m,a[i]-a[i-1]);
    }
    int k=100000 ;
    for(int i=0 ; i<n-2 ; i++){
      k=Math.min(k,a[i+2]-a[i]);
    }
    System.out.println(Math.max(k,m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class MinimumDifficulty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    a[0+1] := scan.getCurrent()->toInteger() ; 
    a[1+1] := scan.getCurrent()->toInteger() ; 
    var m : int ; m := a[1+1] - a[0+1] ;
        var i : int ; i := 2 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() ; 
     m := Set{m, a[i+1] - a[i - 1+1]}->max() )  ;     i := i + 1 ) ; 
    var k : int ; k := 100000 ;
        var i : int ; i := 0 ; while i < n - 2 do ( (     k := Set{k, a[i + 2+1] - a[i+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{k, m}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int vis[];
  static int dfs(int x,Vector<Vector<Integer>>adj){
    int sz=1 ;
    vis[x]=1 ;
    for(int i=0 ; i<adj.get(x).size(); i++)if(vis[adj.get(x).get(i)]==0)sz+=dfs(adj.get(x).get(i),adj);
    return sz ;
  }
  static int maxValue(int n,Vector<Vector<Integer>>adj){
    int val=0 ;
    vis=new int[n+1];
    for(int i=0 ; i<n ; i++)vis[i]=0 ;
    for(int i=0 ; i<n ; i++)if(vis[i]==0)val+=dfs(i,adj)-1 ;
    return val ;
  }
  public static void main(String args[]){
    int n=3 ;
    Vector<Vector<Integer>>adj=new Vector<Vector<Integer>>();
    Vector<Integer>v=new Vector<Integer>();
    v.add(0);
    v.add(1);
    Vector<Integer>v1=new Vector<Integer>();
    v1.add(1);
    v1.add(2);
    adj.add(v);
    adj.add(v1);
    adj.add(new Vector<Integer>());
    System.out.println(maxValue(n,adj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute vis : Sequence(int);
  static   operation dfs( x : int, adj : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var sz : int ; sz := 1 ;
     vis[x+1] := 1 ; 
         var i : int ; i := 0 ; while i < adj->at(x+1)->size() do (     if (vis[adj->at(x+1)->at(i+1)+1] = 0) then     sz := sz+(dfs(adj->at(x+1)->at(i+1), adj)) ; else skip ;  ;     i := i + 1 ) ; 
     return sz );
  static   operation maxValue( n : int, adj : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var val : int ; val := 0 ;
     vis := Integer.subrange(1,n + 1)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     vis[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     if (vis[i+1] = 0) then     val := val+(dfs(i, adj) - 1) ; else skip ;  ;     i := i + 1 ) ; 
    return val 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var adj : Sequence(Sequence(int)) ; adj := Sequence{} ;
    var v : Sequence(int) ; v := Sequence{} ;
    v := v->including(0) ; 
    v := v->including(1) ; 
    var v1 : Sequence(int) ; v1 := Sequence{} ;
    v1 := v1->including(1) ; 
    v1 := v1->including(2) ; 
    adj := adj->including(v) ; 
    adj := adj->including(v1) ; 
    adj := adj->including(Sequence{}) ; 
    OclFile["System.out"].println(maxValue(n, adj)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      long a=in.nextLong();
      long b=in.nextLong();
      long c=in.nextLong();
      long d=in.nextLong();
      judge(a,b,c,d);
    }
  }
  public static void judge(long a,long b,long c,long d){
    if(a<b || d<b)System.out.println("No");
    else {
      long g=gcd(b,d);
      long max=b-g+a % g ;
      if(max>c)System.out.println("No");
      else System.out.println("Yes");
    }
  }
  public static long gcd(long p,long q){
    while(q>0){
      long t=p % q ;
      p=q ;
      q=t ;
    }
    return p ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : long ; a := in.getCurrent()->toLong() ;
     var b : long ; b := in.getCurrent()->toLong() ;
    var c : long ; c := in.getCurrent()->toLong() ;
    var d : long ; d := in.getCurrent()->toLong() ;
    execute judge(a, b, c, d) ; 
 )  ;     i := i + 1 ) );
  static   operation judge( a : long, b : long, c : long, d : long) : void
  pre: true
  post: true
  activity: (     if (a < b or d < b) then     OclFile["System.out"].println("No") ; else (     var g : long ; g := gcd(b, d) ;
     var max : long ; max := b - g + a mod g ;
     if (max > c) then     OclFile["System.out"].println("No") ; else     OclFile["System.out"].println("Yes") ; ) );
  static   operation gcd( p : long, q : long) : long
  pre: true
  post: true
  activity: (     while (q > 0) do (     var t : long ; t := p mod q ;
     p := q ; 
     q := t ) ; 
     return p );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskB solver=new TaskB();
    int testCount=Integer.parseInt(in.next());
    for(int i=1 ; i<=testCount ; i++)solver.solve(i,in,out);
    out.close();
  }
  static class TaskB {
    static final String YES="Yes" ;
    static final String NO="No" ;
    public void solve(int testNumber,InputReader in,PrintWriter out){
      long a=in.nextLong();
      long b=in.nextLong();
      long c=in.nextLong();
      long d=in.nextLong();
      if(a<b || d<b){
        out.println(NO);
        return ;
      }
      long g=gcd(b,d);
      long worst=g-a % g ;
      if(c>=b-worst){
        out.println(YES);
      }
      else {
        out.println(NO);
      }
    }
    private long gcd(long p,long q){
      while(q>0){
        long t=p % q ;
        p=q ;
        q=t ;
      }
      return p ;
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskB ; solver := TaskB.newTaskB() ;
    var testCount : int ; testCount := (in.next())->toInteger() ;
        var i : int ; i := 1 ; while i <= testCount do (     solver.solve(i, in, out) ;  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class TaskB {
  static    attribute YES : String := "Yes";
  static    attribute NO : String := "No";
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : long ; a := in.nextLong() ;
     var b : long ; b := in.nextLong() ;
    var c : long ; c := in.nextLong() ;
    var d : long ; d := in.nextLong() ;
    if (a < b or d < b) then (     skip ; 
     return ) else skip ; 
    var g : long ; g := gcd(b, d) ;
    var worst : long ; worst := g - a mod g ;
    if (c >= b - worst) then (     skip ) else (     skip ) ;  
 );
   operation gcd( p : long, q : long) : long
  pre: true
  post: true
  activity: (     while (q > 0) do (     var t : long ; t := p mod q ;
     p := q ; 
     q := t ) ; 
     return p );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    try(Scanner in=new Scanner(System.in)){
      int N=in.nextInt();
      int K=in.nextInt();
      StringBuilder S=new StringBuilder(in.next());
      S.replace(K-1,K,S.substring(K-1,K).toLowerCase());
      System.out.println(S);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := in.getCurrent()->toInteger() ;
     var K : int ; K := in.getCurrent()->toInteger() ;
    var S : String ; S := StringLib.newString(in.getCurrent()) ;
    S.replace(K - 1, K, S.subrange(K - 1+1,K)->toLowerCase()) ; 
    OclFile["System.out"].println(S) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void solve(){
    int A,B,X,ans ;
    Scanner sc=new Scanner(System.in);
    A=sc.nextInt();
    B=sc.nextInt();
    X=sc.nextInt();
    if(X % 500!=0)X+=500-X % 500 ;
    int a=0 ;
    int b=0 ;
    if(A<B){
      a=X/1000+((X % 1000>0)? 1 : 0);
    }
    else if(A>2*B){
      b=X/500 ;
    }
    else {
      a=X/1000 ;
      X %=1000 ;
      b=X/500 ;
    }
    System.out.println(A*a+B*b);
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var A : int ;
    var B : int ;
    var X : int ;
    var ans : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    A := sc.getCurrent()->toInteger() ; 
    B := sc.getCurrent()->toInteger() ; 
    X := sc.getCurrent()->toInteger() ; 
    if (X mod 500 /= 0) then     X := X+(500 - X mod 500) ; else skip ; 
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
    if (A < B) then (     a := X / 1000 + (if (X mod 1000 > 0) then 1 else 0 endif) ) else     if (A > 2 * B) then (     b := X / 500 ) else (     a := X / 1000 ; 
     X := X mod 1000 ; 
     b := X / 500 ) ;  ;  
    OclFile["System.out"].println(A * a + B * b) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int nTests=Integer.parseInt(br.readLine());
    for(int t=0 ; t<nTests ; t++){
      String[] s=br.readLine().split(" ");
      long a=Long.parseLong(s[0]);
      long b=Long.parseLong(s[1]);
      long c=Long.parseLong(s[2]);
      long d=Long.parseLong(s[3]);
      if(a<b){
        sb.append("No\n");
      }
      else {
        if(d<b){
          sb.append("No\n");
        }
        else {
          d=d % b ;
          if(d==0){
            if(a % b>c){
              sb.append("No\n");
            }
            else {
              sb.append("Yes\n");
            }
          }
          else {
            if(c+1>b-1){
              sb.append("Yes\n");
            }
            else {
              d+=b ;
              long div=gcd(b,d);
              long badLo=(c+1);
              long badHi=b-1 ;
              if(badHi-badLo+1>=div){
                sb.append("No\n");
              }
              else {
                long mBadLo=badLo % div ;
                long mBadHi=badHi % div ;
                if(mBadLo>mBadHi){
                  mBadHi+=div ;
                }
                long mA=a % div ;
                if(mA>=mBadLo && mA<=mBadHi){
                  sb.append("No\n");
                }
                else {
                  sb.append("Yes\n");
                }
              }
            }
          }
        }
      }
    }
    System.out.print(sb);
  }
  static long gcd(long a,long b){
    return(b==0 ? a : gcd(b,a % b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var nTests : int ; nTests := (br.readLine())->toInteger() ;
        var t : int ; t := 0 ; while t < nTests do ( (     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
     var a : long ; a := (s[0+1])->toLong() ;
    var b : long ; b := (s[1+1])->toLong() ;
    var c : long ; c := (s[2+1])->toLong() ;
    var d : long ; d := (s[3+1])->toLong() ;
    if (a < b) then (     sb := sb + StringLib.newString("No\n") ) else (     if (d < b) then (     sb := sb + StringLib.newString("No\n") ) else (     d := d mod b ; 
     if (d = 0) then (     if (a mod b > c) then (     sb := sb + StringLib.newString("No\n") ) else (     sb := sb + StringLib.newString("Yes\n") ) ) else (     if (c + 1 > b - 1) then (     sb := sb + StringLib.newString("Yes\n") ) else (     d := d+(b) ; 
     var div : long ; div := gcd(b, d) ;
    var badLo : long ; badLo := (c + 1) ;
    var badHi : long ; badHi := b - 1 ;
    if (badHi - badLo + 1 >= div) then (     sb := sb + StringLib.newString("No\n") ) else (     var mBadLo : long ; mBadLo := badLo mod div ;
     var mBadHi : long ; mBadHi := badHi mod div ;
    if (mBadLo > mBadHi) then (     mBadHi := mBadHi+(div) ) else skip ; 
    var mA : long ; mA := a mod div ;
    if (mA >= mBadLo & mA <= mBadHi) then (     sb := sb + StringLib.newString("No\n") ) else (     sb := sb + StringLib.newString("Yes\n") ) ;  
 ) ;  
 ) ) ) ) ;  
 )  ;     t := t + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (if b = 0 then a else gcd(b, a mod b) endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    int t=sc.nextInt();
    for(int i=1 ; i<=t ; i++){
      long a=sc.nextLong();
      long b=sc.nextLong();
      long c=sc.nextLong();
      long d=sc.nextLong();
      if(a<b || d<b){
        out.println("No");
        continue ;
      }
      long gcd=gcd(b,d);
      long init=a % gcd ;
      long max=b-gcd+init ;
      if(c>=max)out.println("Yes");
      else out.println("No");
    }
    out.close();
  }
  static long gcd(long a,long b){
    if(b==0)return a ;
    else return gcd(b,a % b);
  }
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var t : int ; t := sc.nextInt() ;
        var i : int ; i := 1 ; while i <= t do ( (     var a : long ; a := sc.nextLong() ;
     var b : long ; b := sc.nextLong() ;
    var c : long ; c := sc.nextLong() ;
    var d : long ; d := sc.nextLong() ;
    if (a < b or d < b) then (     skip ; 
     continue ) else skip ; 
    var gcd : long ; gcd := gcd(b, d) ;
    var init : long ; init := a mod gcd ;
    var max : long ; max := b - gcd + init ;
    if (c >= max) then     skip else     skip ; ;  
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else     return gcd(b, a mod b) );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    int t=Integer.parseInt(sa[0]);
    for(int i=0 ; i<t ; i++){
      sa=br.readLine().split(" ");
      long a=Long.parseLong(sa[0]);
      long b=Long.parseLong(sa[1]);
      long c=Long.parseLong(sa[2]);
      long d=Long.parseLong(sa[3]);
      if(a<b || b>d){
        System.out.println("No");
      }
      else {
        long e=BigInteger.valueOf(b).gcd(BigInteger.valueOf(d)).longValue();
        long g=a % b ;
        long h=(c+1-g+e-1)/e ;
        long min=g+e*h ;
        if(min<b){
          System.out.println("No");
        }
        else {
          System.out.println("Yes");
        }
      }
    }
    br.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var t : int ; t := (sa[0+1])->toInteger() ;
        var i : int ; i := 0 ; while i < t do ( (     sa := br.readLine()->split(" ") ; 
     var a : long ; a := (sa[0+1])->toLong() ;
    var b : long ; b := (sa[1+1])->toLong() ;
    var c : long ; c := (sa[2+1])->toLong() ;
    var d : long ; d := (sa[3+1])->toLong() ;
    if (a < b or b > d) then (     OclFile["System.out"].println("No") ) else (     var e : long ; e := (b + "")->toLong().gcd((d + "")->toLong())->oclAsType(long) ;
     var g : long ; g := a mod b ;
    var h : long ; h := (c + 1 - g + e - 1) / e ;
    var min : long ; min := g + e * h ;
    if (min < b) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) ;  
 ) ;  
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p132 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p132().run());
  }
  public String run(){
    int sum=0 ;
    int count=0 ;
    for(int i=2 ; count<40 ; i++){
      if(Library.isPrime(i)&& repunitMod(1000000000,i)==0){
        sum+=i ;
        count++;
      }
    }
    return Integer.toString(sum);
  }
  private static int repunitMod(int k,int m){
    return(Library.powMod(10,k,m*9)-1)/9 ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p132 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p132.newp132().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var count : int ; count := 0 ;
         var i : int ; i := 2 ; while count < 40 do ( (     if (Library.isPrime(i) & repunitMod(1000000000, i) = 0) then (     sum := sum+(i) ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     return ((sum) + "") );
  static   operation repunitMod( k : int, m : int) : int
  pre: true
  post: true
  activity: (     return (Library.powMod(10, k, m * 9) - 1) / 9 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long ans=0 ;
    for(long i=1 ; i<=n ; i++){
      if(i % 3!=0 && i % 5!=0){
        ans+=i ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : long ; ans := 0 ;
        var i : long ; i := 1 ; while i <= n do ( (     if (i mod 3 /= 0 & i mod 5 /= 0) then (     ans := ans+(i) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    int md1=1000000 ;
    for(int i=1 ; i<n-1 ; i++){
      int md=0 ;
      for(int j=0 ; j<n-1 ; j++){
        if(j!=i){
          if(j+1==i){
            int h=j+2 ;
            if(Math.abs(arr[j]-arr[h])>md){
              md=Math.abs(arr[j]-arr[h]);
            }
          }
          else {
            if(Math.abs(arr[j]-arr[j+1])>md){
              md=Math.abs(arr[j]-arr[j+1]);
            }
          }
        }
      }
      if(md<md1)md1=md ;
    }
    System.out.println(md1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var md1 : int ; md1 := 1000000 ;
        var i : int ; i := 1 ; while i < n - 1 do ( (     var md : int ; md := 0 ;
         var j : int ; j := 0 ; while j < n - 1 do ( (     if (j /= i) then (     if (j + 1 = i) then (     var h : int ; h := j + 2 ;
     if (if arr[j+1] - arr[h+1] < 0 then -(arr[j+1] - arr[h+1]) else arr[j+1] - arr[h+1] endif > md) then (     md := if arr[j+1] - arr[h+1] < 0 then -(arr[j+1] - arr[h+1]) else arr[j+1] - arr[h+1] endif ) else skip ) else (     if (if arr[j+1] - arr[j + 1+1] < 0 then -(arr[j+1] - arr[j + 1+1]) else arr[j+1] - arr[j + 1+1] endif > md) then (     md := if arr[j+1] - arr[j + 1+1] < 0 then -(arr[j+1] - arr[j + 1+1]) else arr[j+1] - arr[j + 1+1] endif ) else skip ) ) else skip )  ;     j := j + 1 ) ; 
     if (md < md1) then     md1 := md ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(md1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long N=scanner.nextLong();
    long x=0 ;
    long y=0 ;
    long sum=0 ;
    x=N/15 ;
    y=N % 15 ;
    sum=(60+60+120*(x-1))*x/2 ;
    if(y==1){
      sum+=1+15*x ;
    }
    else if(y==2 || y==3){
      sum+=3+15*x*2 ;
    }
    else if(y==4 || y==5 || y==6){
      sum+=7+15*x*3 ;
    }
    else if(y==7){
      sum+=14+15*x*4 ;
    }
    else if(y==8 || y==9 || y==10){
      sum+=22+15*x*5 ;
    }
    else if(y==11 || y==12){
      sum+=33+15*x*6 ;
    }
    else if(y==13){
      sum+=46+15*x*7 ;
    }
    else if(y==14){
      sum+=60+15*x*8 ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := scanner.getCurrent()->toLong() ;
    var x : long ; x := 0 ;
    var y : long ; y := 0 ;
    var sum : long ; sum := 0 ;
    x := N / 15 ; 
    y := N mod 15 ; 
    sum := (60 + 60 + 120 * (x - 1)) * x / 2 ; 
    if (y = 1) then (     sum := sum+(1 + 15 * x) ) else     if (y = 2 or y = 3) then (     sum := sum+(3 + 15 * x * 2) ) else     if (y = 4 or y = 5 or y = 6) then (     sum := sum+(7 + 15 * x * 3) ) else     if (y = 7) then (     sum := sum+(14 + 15 * x * 4) ) else     if (y = 8 or y = 9 or y = 10) then (     sum := sum+(22 + 15 * x * 5) ) else     if (y = 11 or y = 12) then (     sum := sum+(33 + 15 * x * 6) ) else     if (y = 13) then (     sum := sum+(46 + 15 * x * 7) ) else     if (y = 14) then (     sum := sum+(60 + 15 * x * 8) ) else skip ; ;  ;  ;  ;  ;  ;  ;  
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.Collectors ;
import java.util.stream.LongStream ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    long res=LongStream.rangeClosed(1,N).filter(p->{
      return !((p % 3==0)||(p % 5==0));
    }
).sum();
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
     var res : long ; res := Integer.subrange(1, N)->select( _x1 | (lambda p : OclAny in (     return not(((p mod 3 = 0) or (p mod 5 = 0))) ))->apply(_x1) )->sum() ;
     OclFile["System.out"].println(res) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastReader s=new FastReader();
    int N=s.nextInt();
    long count=0 ;
    for(int i=1 ; i<=N ; i++){
      if(i % 5==0 || i % 3==0)continue ;
      else count+=i ;
    }
    System.out.println(count);
  }
  private static boolean isPrime(int n){
    if(n==2)return true ;
    else if((n % 2==0 && n>2)|| n<2)return false ;
    else {
      for(int i=3 ; i<=(int)Math.sqrt(n); i+=2){
        if(n % i==0)return false ;
      }
      return true ;
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : FastReader ; s := FastReader.newFastReader() ;
     var N : int ; N := s.nextInt() ;
    var count : long ; count := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     if (i mod 5 = 0 or i mod 3 = 0) then     continue else     count := count+(i) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 2) then     return true else     if ((n mod 2 = 0 & n > 2) or n < 2) then     return false else (         var i : int ; i := 3 ; while i <= (n)->sqrt()->oclAsType(int) do ( (     if (n mod i = 0) then     return false else skip )  ;     i := i+(2) ) ; 
     return true ) ;  );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static void log(long i){
    System.out.println(i);
  }
  static void log(String s){
    System.out.println(s);
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long total=0 ;
    for(int i=0 ; i<=n ; i++){
      if(i % 15==0)continue ;
      if(i % 3==0)continue ;
      if(i % 5==0)continue ;
      total+=i ;
    }
    sc.close();
    log(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation log( i : long) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(i) );
  static   operation log( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var total : long ; total := 0 ;
        var i : int ; i := 0 ; while i <= n do ( (     if (i mod 15 = 0) then     continue else skip ; 
     if (i mod 3 = 0) then     continue else skip ; 
     if (i mod 5 = 0) then     continue else skip ; 
     total := total+(i) )  ;     i := i + 1 ) ; 
    skip ; 
    execute log(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int ___gcd(int a,int b){
    if(a==0 || b==0)return 0 ;
    if(a==b)return a ;
    if(a>b)return ___gcd(a-b,b);
    return ___gcd(a,b-a);
  }
  static int findLargest(int arr[],int n){
    int gcd=arr[0];
    for(int i=1 ; i<n ; i++)gcd=___gcd(gcd,arr[i]);
    return(gcd==1)? n :-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      1,3,5,7 };
      int n=arr.length ;
      System.out.print("Length of the "+"largest subarray="+findLargest(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation ___gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0 or b = 0) then     return 0 else skip ; 
     if (a = b) then     return a else skip ; 
     if (a > b) then     return ___gcd(a - b, b) else skip ; 
     return ___gcd(a, b - a) );
  static   operation findLargest( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var gcd : int ; gcd := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do (     gcd := ___gcd(gcd, arr[i+1]) ;  ;     i := i + 1 ) ; 
     return if (gcd = 1) then n else -1 endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,5,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print("Length of the " + "largest subarray=" + findLargest(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    SC sc=new SC(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int X=sc.nextInt();
    int costmin=Integer.MAX_VALUE ;
    for(int i=0 ; i<=100 ; i++){
      for(int j=0 ; j<=100 ; j++){
        if(1000*i+500*j>=X){
          costmin=Math.min(costmin,A*i+B*j);
        }
      }
    }
    pl(costmin);
  }
  public static void pl(Object o){
    System.out.println(o);
  }
  public static void pl(){
    System.out.println();
  }
  public static void p(Object o){
    System.out.print(o);
  }
  static class SC {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public SC(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        throw new UncheckedIOException(e);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : SC ; sc := SC.newSC(OclFile["System.in"]) ;
     var A : int ; A := sc.nextInt() ;
    var B : int ; B := sc.nextInt() ;
    var X : int ; X := sc.nextInt() ;
    var costmin : int ; costmin := 2147483647 ;
        var i : int ; i := 0 ; while i <= 100 do ( (         var j : int ; j := 0 ; while j <= 100 do ( (     if (1000 * i + 500 * j >= X) then (     costmin := Set{costmin, A * i + B * j}->min() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    execute pl(costmin) ; 
 );
  static   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation pl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
  static class SC {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newSC( in : OclFile) : SC
  pre: true
  post: true
  activity:
  ( var self : SC ;
    self := createSC();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p101 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p101().run());
  }
  private static final int DEGREE=10 ;
  public String run(){
    Fraction sum=Fraction.ZERO ;
    for(int k=1 ; k<=DEGREE ; k++){
      for(int n=k+1 ; ; n++){
        if(n==DEGREE+2)throw new AssertionError();
        Fraction reference=new Fraction(generatingFunction(n));
        Fraction term=optimumPolynomial(k,n);
        if(! term.equals(reference)){
          sum=sum.add(term);
          break ;
        }
      }
    }
    if(sum.denominator.equals(BigInteger.ONE))return sum.numerator.toString();
    else return sum.toString();
  }
  private static Fraction optimumPolynomial(int k,int n){
    Fraction sum=Fraction.ZERO ;
    for(int i=1 ; i<=k ; i++){
      Fraction product=new Fraction(generatingFunction(i));
      for(int j=1 ; j<=k ; j++){
        if(j!=i)product=product.multiply(new Fraction(BigInteger.valueOf(n-j),BigInteger.valueOf(i-j)));
      }
      sum=sum.add(product);
    }
    return sum ;
  }
  private static BigInteger generatingFunction(int n){
    BigInteger sum=BigInteger.ZERO ;
    BigInteger biN=BigInteger.valueOf(-n);
    for(int i=0 ; i<=DEGREE ; i++)sum=sum.add(biN.pow(i));
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class p101 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p101.newp101().run()) );
  static    attribute DEGREE : int := 10;
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : Fraction ; sum := Fraction.ZERO ;
         var k : int ; k := 1 ; while k <= DEGREE do ( (         var n : int ; n := k + 1 ; while true do ( (     if (n = DEGREE + 2) then     error AssertionException() ; else skip ; 
     var reference : Fraction ; reference := Fraction.newFraction(generatingFunction(n)) ;
     var term : Fraction ; term := optimumPolynomial(k, n) ;
     if (not(term = reference)) then (     sum := sum->excludes(term) ; 
     break ) else skip )  ;     n := n + 1 ) )  ;     k := k + 1 ) ; 
     if (sum.denominator = 1) then     return sum.numerator+"" else     return sum+"" );
  static   operation optimumPolynomial( k : int, n : int) : Fraction
  pre: true
  post: true
  activity: (     var sum : Fraction ; sum := Fraction.ZERO ;
         var i : int ; i := 1 ; while i <= k do ( (     var product : Fraction ; product := Fraction.newFraction(generatingFunction(i)) ;
         var j : int ; j := 1 ; while j <= k do ( (     if (j /= i) then     product := product.multiply(Fraction.newFraction((n - j + "")->toLong(), (i - j + "")->toLong())) ; else skip )  ;     j := j + 1 ) ; 
     sum := sum->excludes(product) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation generatingFunction( n : int) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     var biN : long ; biN := (-n + "")->toLong() ;
         var i : int ; i := 0 ; while i <= DEGREE do (     sum := sum->excludes(biN.pow(i)) ;  ;     i := i + 1 ) ; 
     return sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p117 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p117().run());
  }
  private static final int LENGTH=50 ;
  public String run(){
    long[] ways=new long[LENGTH+1];
    ways[0]=1 ;
    for(int n=1 ; n<=LENGTH ; n++){
      for(int k=1 ; k<=4 && k<=n ; k++)ways[n]+=ways[n-k];
    }
    return Long.toString(ways[LENGTH]);
  }
}
------------------------------------------------------------
OCL File:
---------
class p117 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p117.newp117().run()) );
  static    attribute LENGTH : int := 50;
   operation run() : String
  pre: true
  post: true
  activity: (     var ways : Sequence(long) ; ways := Integer.subrange(1,LENGTH + 1)->collect(0) ;
     ways[0+1] := 1 ; 
         var n : int ; n := 1 ; while n <= LENGTH do ( (         var k : int ; k := 1 ; while k <= 4 & k <= n do (     ways[n+1] := ways[n+1]+(ways[n - k+1]) ;  ;     k := k + 1 ) )  ;     n := n + 1 ) ; 
     return ((ways[LENGTH+1]) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p114 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p114().run());
  }
  private static final int LENGTH=50 ;
  public String run(){
    long[] ways=new long[LENGTH+1];
    ways[0]=1 ;
    ways[1]=1 ;
    ways[2]=1 ;
    for(int n=3 ; n<=LENGTH ; n++){
      long sum=ways[n-1]+1 ;
      for(int k=3 ; k<n ; k++)sum+=ways[n-k-1];
      ways[n]=sum ;
    }
    return Long.toString(ways[LENGTH]);
  }
}
------------------------------------------------------------
OCL File:
---------
class p114 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p114.newp114().run()) );
  static    attribute LENGTH : int := 50;
   operation run() : String
  pre: true
  post: true
  activity: (     var ways : Sequence(long) ; ways := Integer.subrange(1,LENGTH + 1)->collect(0) ;
     ways[0+1] := 1 ; 
    ways[1+1] := 1 ; 
    ways[2+1] := 1 ; 
        var n : int ; n := 3 ; while n <= LENGTH do ( (     var sum : long ; sum := ways[n - 1+1] + 1 ;
         var k : int ; k := 3 ; while k < n do (     sum := sum+(ways[n - k - 1+1]) ;  ;     k := k + 1 ) ; 
     ways[n+1] := sum )  ;     n := n + 1 ) ; 
    return ((ways[LENGTH+1]) + "") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
public class Main {
  public static void solution(int n,ArrayList<Integer>heights){
    int min=1000 ;
    int current=0 ;
    int ind=0 ;
    int ind2=0 ;
    for(int i=0 ; i<heights.size()-1 ; i++){
      current=Math.abs(heights.get(i)-heights.get(i+1));
      if(current<min){
        min=current ;
        ind=i+1 ;
        ind2=i+2 ;
      }
    }
    current=Math.abs(heights.get(heights.size()-1)-heights.get(0));
    if(current<min){
      min=current ;
      ind=n ;
      ind2=1 ;
    }
    System.out.println(ind+" "+ind2);
  }
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    ArrayList<Integer>heights=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      heights.add(input.nextInt());
    }
    solution(n,heights);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solution( n : int, heights : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var min : int ; min := 1000 ;
     var current : int ; current := 0 ;
    var ind : int ; ind := 0 ;
    var ind2 : int ; ind2 := 0 ;
        var i : int ; i := 0 ; while i < heights->size() - 1 do ( (     current := if heights->at(i+1) - heights->at(i + 1+1) < 0 then -(heights->at(i+1) - heights->at(i + 1+1)) else heights->at(i+1) - heights->at(i + 1+1) endif ; 
     if (current < min) then (     min := current ; 
     ind := i + 1 ; 
     ind2 := i + 2 ) else skip )  ;     i := i + 1 ) ; 
    current := if heights->at(heights->size() - 1+1) - heights->at(0+1) < 0 then -(heights->at(heights->size() - 1+1) - heights->at(0+1)) else heights->at(heights->size() - 1+1) - heights->at(0+1) endif ; 
    if (current < min) then (     min := current ; 
     ind := n ; 
     ind2 := 1 ) else skip ; 
    OclFile["System.out"].println(ind + " " + ind2) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var heights : Sequence(int) ; heights := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     heights := heights->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    execute solution(n, heights) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MinimumDifficulty {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final int n=sc.nextInt();
    int[] heights=new int[n];
    int maxDifficulty=-1 ;
    for(int i=0 ; i<n ; i++){
      heights[i]=sc.nextInt();
    }
    int current ;
    int next ;
    int diff ;
    int elementToRemove ;
    int newDifficulty=1000 ;
    for(int i=1 ; i<n-1 ; i++){
      elementToRemove=heights[i];
      maxDifficulty=-1 ;
      for(int j=0 ; j<n-1 ; j++){
        if(heights[j]==elementToRemove){
          current=heights[j-1];
        }
        else {
          current=heights[j];
        }
        if(heights[j+1]==elementToRemove){
          next=heights[j+2];
        }
        else {
          next=heights[j+1];
        }
        diff=next-current ;
        if(diff>maxDifficulty){
          maxDifficulty=diff ;
        }
        if(j==n-2){
          if(maxDifficulty<newDifficulty){
            newDifficulty=maxDifficulty ;
          }
        }
      }
    }
    System.out.println(newDifficulty);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MinimumDifficulty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var heights : Sequence(int) ; heights := Integer.subrange(1,n)->collect(0) ;
    var maxDifficulty : int ; maxDifficulty := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     heights[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var current : int ;
    var next : int ;
    var diff : int ;
    var elementToRemove : int ;
    var newDifficulty : int ; newDifficulty := 1000 ;
        var i : int ; i := 1 ; while i < n - 1 do ( (     elementToRemove := heights[i+1] ; 
     maxDifficulty := -1 ; 
         var j : int ; j := 0 ; while j < n - 1 do ( (     if (heights[j+1] = elementToRemove) then (     current := heights[j - 1+1] ) else (     current := heights[j+1] ) ;  
     if (heights[j + 1+1] = elementToRemove) then (     next := heights[j + 2+1] ) else (     next := heights[j + 1+1] ) ;  
    diff := next - current ; 
    if (diff > maxDifficulty) then (     maxDifficulty := diff ) else skip ; 
    if (j = n - 2) then (     if (maxDifficulty < newDifficulty) then (     newDifficulty := maxDifficulty ) else skip ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(newDifficulty) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class code {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    int diff=0,mindiff=Integer.MAX_VALUE,index1=0,index2=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    for(int i=1 ; i<=n ; i++){
      if(i==n){
        diff=Math.abs(arr[0]-arr[n-1]);
        if(mindiff>diff){
          mindiff=diff ;
          index1=n ;
          index2=1 ;
        }
      }
      else {
        diff=Math.abs(arr[i]-arr[i-1]);
        if(mindiff>diff){
          mindiff=diff ;
          index1=i ;
          index2=i+1 ;
        }
      }
    }
    System.out.println(index1+" "+index2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var diff : int ; diff := 0 ;
    var mindiff : int ; mindiff := 2147483647 ;
    var index1 : int ; index1 := 0 ;
    var index2 : int ; index2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (i = n) then (     diff := if arr[0+1] - arr[n - 1+1] < 0 then -(arr[0+1] - arr[n - 1+1]) else arr[0+1] - arr[n - 1+1] endif ; 
     if (mindiff > diff) then (     mindiff := diff ; 
     index1 := n ; 
     index2 := 1 ) else skip ) else (     diff := if arr[i+1] - arr[i - 1+1] < 0 then -(arr[i+1] - arr[i - 1+1]) else arr[i+1] - arr[i - 1+1] endif ; 
     if (mindiff > diff) then (     mindiff := diff ; 
     index1 := i ; 
     index2 := i + 1 ) else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(index1 + " " + index2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Code_34A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    int minValue=Integer.MAX_VALUE ;
    int idx1=-1,idx2=-1 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    for(int i=0 ; i<arr.length-1 ; i++){
      if(Math.abs(arr[i]-arr[i+1])<minValue){
        idx1=i+1 ;
        idx2=i+2 ;
        minValue=Math.abs(arr[i]-arr[i+1]);
      }
    }
    if(Math.abs(arr[0]-arr[n-1])<minValue){
      idx1=1 ;
      idx2=arr.length ;
    }
    System.out.println(idx1+" "+idx2);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code_34A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var minValue : int ; minValue := 2147483647 ;
    var idx1 : int ; idx1 := -1 ;
    var idx2 : int ; idx2 := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < arr->size() - 1 do ( (     if (if arr[i+1] - arr[i + 1+1] < 0 then -(arr[i+1] - arr[i + 1+1]) else arr[i+1] - arr[i + 1+1] endif < minValue) then (     idx1 := i + 1 ; 
     idx2 := i + 2 ; 
     minValue := if arr[i+1] - arr[i + 1+1] < 0 then -(arr[i+1] - arr[i + 1+1]) else arr[i+1] - arr[i + 1+1] endif ) else skip )  ;     i := i + 1 ) ; 
    if (if arr[0+1] - arr[n - 1+1] < 0 then -(arr[0+1] - arr[n - 1+1]) else arr[0+1] - arr[n - 1+1] endif < minValue) then (     idx1 := 1 ; 
     idx2 := arr->size() ) else skip ; 
    OclFile["System.out"].println(idx1 + " " + idx2) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static int getSum(int arr[],int p){
    return arr.length ;
  }
  public static void main(String[] args){
    int arr[]={
      5,6,8 };
      int p=7 ;
      System.out.print(getSum(arr,p));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getSum( arr : Sequence(int), p : int) : int
  pre: true
  post: true
  activity: (     return arr->size() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,6,8} ;
     var p : int ; p := 7 ;
     OclFile["System.out"].print(getSum(arr, p)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Queue ;
public class GFG {
  static int countOfBinaryNumberLessThanN(int N){
    Queue<Integer>q=new LinkedList<>();
    q.add(1);
    int cnt=0 ;
    int t ;
    while(q.size()>0){
      t=q.peek();
      q.remove();
      if(t<=N){
        cnt++;
        q.add(t*10);
        q.add(t*10+1);
      }
    }
    return cnt ;
  }
  static public void main(String[] args){
    int N=200 ;
    System.out.println(countOfBinaryNumberLessThanN(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countOfBinaryNumberLessThanN( N : int) : int
  pre: true
  post: true
  activity: (     var q : Sequence(int) ; q := Sequence{} ;
     q := q->including(1) ; 
    var cnt : int ; cnt := 0 ;
    var t : int ;
    while (q->size() > 0) do (     t := q->min() ; 
     q := q.remove() ; 
     if (t <= N) then (     cnt := cnt + 1 ; 
     q := q->including(t * 10) ; 
     q := q->including(t * 10 + 1) ) else skip ) ; 
    return cnt 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 200 ;
     OclFile["System.out"].println(countOfBinaryNumberLessThanN(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int fact(int n){
    int f=1 ;
    for(int i=2 ; i<=n ; i++){
      f=f*i ;
    }
    return f ;
  }
  static int npr(int n,int r){
    return fact(n)/fact(n-r);
  }
  static int countPermutations(String str){
    int even=(int)Math.floor((double)(str.length()/2));
    int odd=str.length()-even ;
    int ways=0 ;
    int[] freq=new int[26];
    for(int i=0 ; i<str.length(); i++){
      freq[(int)(str.charAt(i)-'a')]++;
    }
    int nvowels=freq[0]+freq[4]+freq[8]+freq[14]+freq[20];
    int nconsonants=str.length()-nvowels ;
    ways=npr(odd,nvowels)*npr(nconsonants,nconsonants);
    return ways ;
  }
  public static void main(String[] args){
    String str="geeks" ;
    System.out.println(countPermutations(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation fact( n : int) : int
  pre: true
  post: true
  activity: (     var f : int ; f := 1 ;
         var i : int ; i := 2 ; while i <= n do ( (     f := f * i )  ;     i := i + 1 ) ; 
     return f );
  static   operation npr( n : int, r : int) : int
  pre: true
  post: true
  activity: (     return fact(n) / fact(n - r) );
  static   operation countPermutations( str : String) : int
  pre: true
  post: true
  activity: (     var even : int ; even := ((str->size() / 2)->oclAsType(double))->floor()->oclAsType(int) ;
     var odd : int ; odd := str->size() - even ;
    var ways : int ; ways := 0 ;
    var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < str->size() do ( (     freq[(str->at(i+1) - ('a')->char2byte())->oclAsType(int)+1] := freq[(str->at(i+1) - ('a')->char2byte())->oclAsType(int)+1] + 1 )  ;     i := i + 1 ) ; 
    var nvowels : int ; nvowels := freq[0+1] + freq[4+1] + freq[8+1] + freq[14+1] + freq[20+1] ;
    var nconsonants : int ; nconsonants := str->size() - nvowels ;
    ways := npr(odd, nvowels) * npr(nconsonants, nconsonants) ; 
    return ways 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeks" ;
     OclFile["System.out"].println(countPermutations(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int check(int n,List<Integer>marks){
    Integer x=Collections.max(marks);
    int bonus=100-x ;
    int c=0 ;
    for(int i=0 ; i<n ; i++){
      if(marks.get(i)+bonus>=50)c+=1 ;
    }
    return c ;
  }
  public static void main(String[] args){
    int n=5 ;
    List<Integer>marks=Arrays.asList(0,21,83,45,64);
    System.out.println(check(n,marks));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( n : int, marks : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var x : int ; x := .max(marks) ;
     var bonus : int ; bonus := 100 - x ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (marks->at(i+1) + bonus >= 50) then     c := c+(1) ; else skip )  ;     i := i + 1 ) ; 
    return c 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var marks : Sequence(int) ; marks := Sequence{0,21,83,45,64} ;
     OclFile["System.out"].println(check(n, marks)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  static int INF=1<<29 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int A,B,X ;
    StringTokenizer st=new StringTokenizer(br.readLine());
    A=parseInt(st.nextToken());
    B=parseInt(st.nextToken());
    X=parseInt(st.nextToken());
    int[] dp=new int[X+1000+1];
    Arrays.fill(dp,INF);
    dp[0]=0 ;
    for(int i=0 ; i<=X ; i++){
      if(dp[i+1000]>dp[i]+A){
        dp[i+1000]=dp[i]+A ;
      }
    }
    for(int i=0 ; i<=X+500 ; i++){
      if(dp[i+500]>dp[i]+B){
        dp[i+500]=dp[i]+B ;
      }
    }
    int ans=INF ;
    for(int i=X+1000 ; i>=X ; i--){
      if(dp[i]<ans)ans=dp[i];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute INF : int := (1*(2->pow(29)))->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var A : int ;
    var B : int ;
    var X : int ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    A := (st.next() + "")->toInteger() ; 
    B := (st.next() + "")->toInteger() ; 
    X := (st.next() + "")->toInteger() ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,X + 1000 + 1)->collect(0) ;
    dp := dp->collect(INF) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i <= X do ( (     if (dp[i + 1000+1] > dp[i+1] + A) then (     dp[i + 1000+1] := dp[i+1] + A ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= X + 500 do ( (     if (dp[i + 500+1] > dp[i+1] + B) then (     dp[i + 500+1] := dp[i+1] + B ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := INF ;
        var i : int ; i := X + 1000 ; while i >= X do ( (     if (dp[i+1] < ans) then     ans := dp[i+1] ; else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countP(int n,int k){
    int[][] dp=new int[n+1][k+1];
    for(int i=0 ; i<=n ; i++)dp[i][0]=0 ;
    for(int i=0 ; i<=k ; i++)dp[0][k]=0 ;
    for(int i=1 ; i<=n ; i++)for(int j=1 ; j<=k ; j++)if(j==1 || i==j)dp[i][j]=1 ;
    else dp[i][j]=j*dp[i-1][j]+dp[i-1][j-1];
    return dp[n][k];
  }
  public static void main(String[] args){
    System.out.println(countP(5,2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countP( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,k + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i <= n do (     dp[i+1][0+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= k do (     dp[0+1][k+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (         var j : int ; j := 1 ; while j <= k do (     if (j = 1 or i = j) then     dp[i+1][j+1] := 1 else     dp[i+1][j+1] := j * dp[i - 1+1][j+1] + dp[i - 1+1][j - 1+1] ; ;   ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return dp[n+1][k+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(countP(5, 2)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class hw19 {
  public static void main(String[] args)throws IOException {
    Scanner scan=new Scanner(System.in);
    {
    }
    {
      String in=scan.next();
      int i=Integer.parseInt(String.valueOf(in.charAt(in.length()-1)));
      if(in.length()>1 &&(Integer.parseInt(String.valueOf(in.charAt(in.length()-2)))*10+i)% 4==0){
        System.out.println(4);
      }
      else if(in.length()==1 && i % 4==0){
        System.out.println(4);
      }
      else {
        System.out.println(0);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class hw19 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 skip 
 (     var in : String ; in := scan.getCurrent() ;
     var i : int ; i := (((in->at(in->size() - 1+1)) + ""))->toInteger() ;
     if (in->size() > 1 & ((((in->at(in->size() - 2+1)) + ""))->toInteger() * 10 + i) mod 4 = 0) then (     OclFile["System.out"].println(4) ) else     if (in->size() = 1 & i mod 4 = 0) then (     OclFile["System.out"].println(4) ) else (     OclFile["System.out"].println(0) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    int sum=0 ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      sum+=parseInt(line)>=40 ? parseInt(line): 40 ;
    }
    System.out.println(sum/5);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
    var sum : int ; sum := 0 ;
        line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     sum := sum+(if (line + "")->toInteger() >= 40 then (line + "")->toInteger() else 40 endif) ) ;     line := br.readLine() ;
 ) ;  
    OclFile["System.out"].println(sum / 5) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  PrintStream log=new PrintStream(new OutputStream(){
    public void write(int b){
    }
  }
);
  PrintStream result=System.out ;
  Scanner sc=new Scanner(System.in);
  void main()throws IOException {
    int sum=0 ;
    for(int i=0 ; i<5 ; i++){
      int t=sc.nextInt();
      sum+=Math.max(t,40);
    }
    result.println(sum/5);
  }
  public static void main(String[] args)throws IOException {
    new Main().main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute log : OclFile := OclFile.newOclFile_Write(OclFile());
   attribute result : OclFile := OclFile["System.out"];
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation main() : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < 5 do ( (     var t : int ; t := sc.getCurrent()->toInteger() ;
     sum := sum+(Set{t, 40}->max()) )  ;     i := i + 1 ) ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().main() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int[] p=new int[5];
    for(int i=0 ; i<5 ; i++){
      p[i]=stdIn.nextInt();
      if(p[i]<40){
        p[i]=40 ;
      }
    }
    int sum=0 ;
    for(int i=0 ; i<5 ; i++){
      sum+=p[i];
    }
    System.out.println(sum/5);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : Sequence(int) ; p := Integer.subrange(1,5)->collect(0) ;
        var i : int ; i := 0 ; while i < 5 do ( (     p[i+1] := stdIn.getCurrent()->toInteger() ; 
     if (p[i+1] < 40) then (     p[i+1] := 40 ) else skip )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 5 do ( (     sum := sum+(p[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum / 5) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int total=0 ;
    for(int i=0 ; i<5 ; i++){
      int n=sc.nextInt();
      if(n<40){
        n=40 ;
      }
      total+=n ;
    }
    out.println(total/5);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var total : int ; total := 0 ;
         var i : int ; i := 0 ; while i < 5 do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n < 40) then (     n := 40 ) else skip ; 
     total := total+(n) )  ;     i := i + 1 ) ; 
     out.println(total / 5) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findNthDigit(int p,int q,int N){
    int res=0 ;
    while(N>0){
      N--;
      p*=10 ;
      res=p/q ;
      p %=q ;
    }
    return res ;
  }
  public static void main(String args[]){
    int p=1,q=2,N=1 ;
    System.out.println(findNthDigit(p,q,N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNthDigit( p : int, q : int, N : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     while (N > 0) do (     N := N - 1 ; 
     p := p*(10) ; 
     res := p / q ; 
     p := p mod q ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : int ; p := 1 ;
    var q : int ; q := 2 ;
    var N : int ; N := 1 ;
     OclFile["System.out"].println(findNthDigit(p, q, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      int left=scanner.nextInt();
      int right=scanner.nextInt();
      int down=scanner.nextInt();
      int up=scanner.nextInt();
      int x=scanner.nextInt();
      int y=scanner.nextInt();
      int x1=scanner.nextInt();
      int y1=scanner.nextInt();
      int x2=scanner.nextInt();
      int y2=scanner.nextInt();
      int finalX=x+right-left ;
      int finalY=y+up-down ;
      if(finalX<x1 || finalX>x2 || finalY<y1 || finalY>y2)System.out.println("NO");
      else if((x1==x2 &&(left+right)>0)||(y1==y2 &&(up+down)>0))System.out.println("NO");
      else System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var left : int ; left := scanner.getCurrent()->toInteger() ;
     var right : int ; right := scanner.getCurrent()->toInteger() ;
    var down : int ; down := scanner.getCurrent()->toInteger() ;
    var up : int ; up := scanner.getCurrent()->toInteger() ;
    var x : int ; x := scanner.getCurrent()->toInteger() ;
    var y : int ; y := scanner.getCurrent()->toInteger() ;
    var x1 : int ; x1 := scanner.getCurrent()->toInteger() ;
    var y1 : int ; y1 := scanner.getCurrent()->toInteger() ;
    var x2 : int ; x2 := scanner.getCurrent()->toInteger() ;
    var y2 : int ; y2 := scanner.getCurrent()->toInteger() ;
    var finalX : int ; finalX := x + right - left ;
    var finalY : int ; finalY := y + up - down ;
    if (finalX < x1 or finalX > x2 or finalY < y1 or finalY > y2) then     OclFile["System.out"].println("NO") else     if ((x1 = x2 & (left + right) > 0) or (y1 = y2 & (up + down) > 0)) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[][] arr=new int[n][2];
    for(int i=0 ; i<n ; i++){
      arr[i][0]=sc.nextInt();
      arr[i][1]=sc.nextInt();
    }
    int ans=solve(arr,n,k);
    System.out.println(ans);
  }
  static int solve(int[][] arr,int n,int k){
    int ans1=-1 ;
    int ans2=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(ans1<Math.min(arr[i][0],arr[i][1])){
        ans1=Math.min(arr[i][0],arr[i][1]);
      }
      if(Math.max(arr[i][0],arr[i][1])<ans2){
        ans2=Math.max(arr[i][0],arr[i][1]);
      }
    }
    if(ans2<ans1){
      return-1 ;
    }
    if(k<=ans1){
      return ans1-k ;
    }
    if(ans2<=k){
      return k-ans2 ;
    }
    return 0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     arr[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := solve(arr, n, k) ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation solve( arr : Sequence(Sequence(int)), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var ans1 : int ; ans1 := -1 ;
     var ans2 : int ; ans2 := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     if (ans1 < Set{arr[i+1][0+1], arr[i+1][1+1]}->min()) then (     ans1 := Set{arr[i+1][0+1], arr[i+1][1+1]}->min() ) else skip ; 
     if (Set{arr[i+1][0+1], arr[i+1][1+1]}->max() < ans2) then (     ans2 := Set{arr[i+1][0+1], arr[i+1][1+1]}->max() ) else skip )  ;     i := i + 1 ) ; 
    if (ans2 < ans1) then (     return -1 ) else skip ; 
    if (k <= ans1) then (     return ans1 - k ) else skip ; 
    if (ans2 <= k) then (     return k - ans2 ) else skip ; 
    return 0 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      String[] tmp=sc.nextLine().split(" ");
      final int A=Integer.parseInt(tmp[0]);
      final int B=Integer.parseInt(tmp[1]);
      final int X=Integer.parseInt(tmp[2]);
      System.out.println(solve(A,B,X));
    }
  }
  private static int solve(int a,int b,int x){
    int ret=0 ;
    if(a>=(b*2)){
      ret=(x/500)*b ;
      if(x % 500>0){
        ret+=b ;
      }
      return ret ;
    }
    ret=x/1000*a ;
    if(a<b){
      if(x % 1000>0){
        ret+=a ;
      }
      return ret ;
    }
    if(x % 1000>500){
      ret+=a ;
    }
    else if(x % 1000>0){
      ret+=b ;
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var tmp : Sequence(String) ; tmp := sc.nextLine()->split(" ") ;
     var A : int ; A := (tmp[0+1])->toInteger() ;
    var B : int ; B := (tmp[1+1])->toInteger() ;
    var X : int ; X := (tmp[2+1])->toInteger() ;
    OclFile["System.out"].println(solve(A, B, X)) ; 
 ))  );
  static   operation solve( a : int, b : int, x : int) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
     if (a >= (b * 2)) then (     ret := (x / 500) * b ; 
     if (x mod 500 > 0) then (     ret := ret+(b) ) else skip ; 
     return ret ) else skip ; 
    ret := x / 1000 * a ; 
    if (a < b) then (     if (x mod 1000 > 0) then (     ret := ret+(a) ) else skip ; 
     return ret ) else skip ; 
    if (x mod 1000 > 500) then (     ret := ret+(a) ) else     if (x mod 1000 > 0) then (     ret := ret+(b) ) else skip ; ;  
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),x=in.nextInt();
    int left=Integer.MIN_VALUE ;
    int right=Integer.MAX_VALUE ;
    int ans=0 ;
    for(int i=1 ; i<=n ; i++){
      int l=in.nextInt(),r=in.nextInt();
      if(l>r){
        int temp=l ;
        l=r ;
        r=temp ;
      }
      left=Math.max(l,left);
      right=Math.min(r,right);
    }
    if(left>right){
      pw.println(-1);
    }
    else if(x>=left && x<=right){
      pw.println(0);
    }
    else {
      pw.println(Math.min(Math.abs(x-left),Math.abs(x-right)));
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
    var left : int ; left := -2147483648 ;
    var right : int ; right := 2147483647 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var l : int ; l := in.getCurrent()->toInteger() ;
    var r : int ; r := in.getCurrent()->toInteger() ;
     if (l > r) then (     var temp : int ; temp := l ;
     l := r ; 
     r := temp ) else skip ; 
     left := Set{l, left}->max() ; 
     right := Set{r, right}->min() )  ;     i := i + 1 ) ; 
    if (left > right) then (     skip ) else     if (x >= left & x <= right) then (     skip ) else (     skip ) ;  ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    long n=scan.nextLong();
    long k=scan.nextLong();
    long diploma=(long)(n/(2*(k+1)));
    long cer=diploma*k ;
    if(diploma+cer<=(n-(diploma+cer))){
      System.out.println(diploma+" "+cer+" "+(n-(diploma+cer)));
    }
    else {
      while(diploma+cer>(n-(diploma+cer))){
        diploma--;
        cer=diploma*k ;
      }
      System.out.println(diploma+" "+cer+" "+(n-(diploma+cer)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := scan.getCurrent()->toLong() ;
    var k : long ; k := scan.getCurrent()->toLong() ;
    var diploma : long ; diploma := (n / (2 * (k + 1)))->oclAsType(long) ;
    var cer : long ; cer := diploma * k ;
    if (diploma + cer <= (n - (diploma + cer))) then (     OclFile["System.out"].println(diploma + " " + cer + " " + (n - (diploma + cer))) ) else (     while (diploma + cer > (n - (diploma + cer))) do (     diploma := diploma - 1 ; 
     cer := diploma * k ) ; 
     OclFile["System.out"].println(diploma + " " + cer + " " + (n - (diploma + cer))) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.Scanner ;
public class cf456b {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    Scanner in=new Scanner(System.in);
    BigInteger b ;
    BigInteger x=new BigInteger("4");
    BigInteger y=new BigInteger("0");
    b=in.nextBigInteger();
    if(b.mod(x).equals(y))System.out.println("4");
    else System.out.println("0");
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf456b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var b : long ;
    var x : long ; x := long("4") ;
    var y : long ; y := long("0") ;
    b := in.nextBigInteger() ; 
    if (b.mod(x) = y) then     OclFile["System.out"].println("4") else     OclFile["System.out"].println("0") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A818 {
  public static void main(String[] args){
    Scanner kbd=new Scanner(System.in);
    long n=kbd.nextLong();
    long k=kbd.nextLong();
    long winners=n/2 ;
    long dip=winners/(k+1);
    long c=dip*k ;
    System.out.println(dip+" "+c+" "+(n-dip-c));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A818 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var kbd : OclFile ; kbd := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := kbd.getCurrent()->toLong() ;
    var k : long ; k := kbd.getCurrent()->toLong() ;
    var winners : long ; winners := n / 2 ;
    var dip : long ; dip := winners / (k + 1) ;
    var c : long ; c := dip * k ;
    OclFile["System.out"].println(dip + " " + c + " " + (n - dip - c)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    long n=input.nextLong();
    long k=input.nextLong();
    long d=n/(2*(1+k));
    long c=d*k ;
    long e=n-(c+d);
    System.out.println(d+" "+c+" "+e);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := input.getCurrent()->toLong() ;
    var k : long ; k := input.getCurrent()->toLong() ;
    var d : long ; d := n / (2 * (1 + k)) ;
    var c : long ; c := d * k ;
    var e : long ; e := n - (c + d) ;
    OclFile["System.out"].println(d + " " + c + " " + e) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    long n=input.nextLong();
    long k=input.nextLong();
    long d=n/(2*(1+k));
    long c=d*k ;
    long e=n-(c+d);
    System.out.println(d+" "+c+" "+e);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := input.getCurrent()->toLong() ;
    var k : long ; k := input.getCurrent()->toLong() ;
    var d : long ; d := n / (2 * (1 + k)) ;
    var c : long ; c := d * k ;
    var e : long ; e := n - (c + d) ;
    OclFile["System.out"].println(d + " " + c + " " + e) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  static int top=0 ;
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int[] stack ;
    String prec ;
    char c ;
    stack=new int[200];
    top=0 ;
    for(; ; ){
      if(! sc.hasNext())break ;
      prec=sc.next();
      c=prec.charAt(0);
      if('0'<=c && c<='9'){
        push(stack,Integer.parseInt(prec));
      }
      else if(c=='+'){
        push(stack,pop(stack)+pop(stack));
      }
      else if(c=='-'){
        push(stack,-pop(stack)+pop(stack));
      }
      else if(c=='*'){
        push(stack,pop(stack)*pop(stack));
      }
      else {
        break ;
      }
    }
    System.out.println(pop(stack));
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
  private static int pop(int[] stack){
    return stack[--top];
  }
  private static void push(int[] stack,int a){
    stack[top++]=a ;
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   attribute top : int := 0;
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var stack : Sequence(int) ;
    var prec : String ;
    var c : String ;
    stack := Integer.subrange(1,200)->collect(0) ; 
    top := 0 ; 
      while true do ( (     if (not(sc.hasNext())) then     break else skip ; 
     prec := sc.next() ; 
     c := prec->at(0+1) ; 
     if ('0' <= c & c <= '9') then (     execute push(stack, (prec)->toInteger()) ) else     if (c = '+') then (     execute push(stack, pop(stack) + pop(stack)) ) else     if (c = '-') then (     execute push(stack, -pop(stack) + pop(stack)) ) else     if (c = '*') then (     execute push(stack, pop(stack) * pop(stack)) ) else (     break ) ;  ;  ;  )  ) ; 
    OclFile["System.out"].println(pop(stack)) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
  static   operation pop( stack : Sequence(int)) : int
  pre: true
  post: true
  activity: (     return stack[(top - 1)+1] );
  static   operation push( stack : Sequence(int), a : int) : void
  pre: true
  post: true
  activity: (      stack[top+1] := a  ; top := top + 1 ; 
     return );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  static class Stack {
    int A[],head ;
    Stack(int size){
      A=new int[size+1];
      head=0 ;
    }
    void show(){
      for(int i=1 ; i<A.length ; i++)if(i==A.length-1)System.out.println(A[i]);
      else System.out.print(A[i]+" ");
    }
    boolean isEmpty(){
      return head==0 ;
    }
    boolean isFull(){
      return head==A.length-1 ;
    }
    void push(int key){
      if(isFull())return ;
      A[++head]=key ;
    }
    int pop(){
      if(isEmpty())return 0 ;
      return A[head--];
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String com ;
    Stack stack=new Stack(100);
    while(sc.hasNext()){
      com=sc.next();
      if(com.equals("+"))stack.push(stack.pop()+stack.pop());
      else if(com.equals("-"))stack.push(-1*stack.pop()+stack.pop());
      else if(com.equals("*"))stack.push(stack.pop()*stack.pop());
      else stack.push(Integer.parseInt(com));
    }
    System.out.println(stack.pop());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Stack {
   attribute A : int;
   static operation newStack( size : int) : Stack
  pre: true
  post: true
  activity:
  ( var self : Stack ;
    self := createStack();
    self.initialise(size);
    return self );
  operation initialise( size : int) : void
  pre: true  post: true
  activity: (     A := Integer.subrange(1,size + 1)->collect(0) ; 
     head := 0 );
   operation show() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < A->size() do (     if (i = A->size() - 1) then     OclFile["System.out"].println(A[i+1]) else     OclFile["System.out"].print(A[i+1] + " ") ; ;   ;     i := i + 1 ) );
   operation isEmpty() : boolean
  pre: true
  post: true
  activity: (     return head = 0 );
   operation isFull() : boolean
  pre: true
  post: true
  activity: (     return head = A->size() - 1 );
   operation push( key : int) : void
  pre: true
  post: true
  activity: (     if (isFull()) then     return else skip ; 
         head := head + 1 ;
 A[head+1] := key  );
   operation pop() : int
  pre: true
  post: true
  activity: (     if (isEmpty()) then     return 0 else skip ; 
     return A[head+1] );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var com : String ;
    var stack : Sequence ; stack := Sequence{} ;
    while (sc.hasNext()) do (     com := sc.getCurrent() ; 
     if (com = "+") then     stack := stack->append(stack->last() + stack->last()) ; else     if (com = "-") then     stack := stack->append(-1 * stack->last() + stack->last()) else     if (com = "*") then     stack := stack->append(stack->last() * stack->last()) else     stack := stack->append((com)->toInteger()) ; ;  ;  ) ; 
    OclFile["System.out"].println(stack->last()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static int computePolish(String in){
    Stack<Integer>polishStack=new Stack<Integer>();
    Scanner scan=new Scanner(in);
    while(scan.hasNext()){
      String current=scan.next();
      switch(current){
        case "*" : int mult1=polishStack.pop();
        int mult2=polishStack.pop();
        polishStack.push(mult1*mult2);
        break ;
        case "+" : int plus1=polishStack.pop();
        int plus2=polishStack.pop();
        polishStack.push(plus1+plus2);
        break ;
        case "-" : int subt1=polishStack.pop();
        int subt2=polishStack.pop();
        polishStack.push(subt2-subt1);
        break ;
        default : polishStack.push(Integer.parseInt(current));
        break ;
      }
    }
    return polishStack.pop();
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    System.out.println(computePolish(scan.nextLine()));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation computePolish( in : String) : int
  pre: true
  post: true
  activity: (     var polishStack : Sequence(int) ; polishStack := Sequence{} ;
     var scan : OclFile ; scan := OclFile.newOclFile_Read(in) ;
     while (scan.hasNext()) do (     var current : String ; current := scan.getCurrent() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (current) ; 
       if _switchval = "*" then
     var mult1 : int ; mult1 := polishStack->last() ;
    var mult2 : int ; mult2 := polishStack->last() ;
    polishStack := polishStack->append(mult1 * mult2) ; 
    break 
   else skip ;
       if _switchval = "+" then
     var plus1 : int ; plus1 := polishStack->last() ;
    var plus2 : int ; plus2 := polishStack->last() ;
    polishStack := polishStack->append(plus1 + plus2) ; 
    break 
   else skip ;
       if _switchval = "-" then
     var subt1 : int ; subt1 := polishStack->last() ;
    var subt2 : int ; subt2 := polishStack->last() ;
    polishStack := polishStack->append(subt2 - subt1) ; 
    break 
   else skip ;
       if true then
     polishStack := polishStack->append((current)->toInteger()) ; 
    break 
   else skip ;
 )
 ) ; 
     return polishStack->last() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println(computePolish(scan.nextLine())) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayDeque ;
import java.util.Deque ;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] stringArray=br.readLine().split("\\s");
    Deque<Integer>que=new ArrayDeque<>();
    int a=0 ;
    int b=0 ;
    for(int i=0 ; i<stringArray.length ; i++){
      switch(stringArray[i]){
        case "+" : a=que.pollFirst();
        b=que.pollFirst();
        que.addFirst(b+a);
        break ;
        case "-" : a=que.pollFirst();
        b=que.pollFirst();
        que.addFirst(b-a);
        break ;
        case "/" : a=que.pollFirst();
        b=que.pollFirst();
        que.addFirst(b/a);
        break ;
        case "*" : a=que.pollFirst();
        b=que.pollFirst();
        que.addFirst(b*a);
        break ;
        default : que.addFirst(Integer.parseInt(stringArray[i]));
      }
    }
    System.out.println(que.pop());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var stringArray : Sequence(String) ; stringArray := br.readLine()->split("\\s") ;
    var que : Sequence(int) ; que := ArrayDeque<OclAny>.newArrayDeque() ;
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
        var i : int ; i := 0 ; while i < stringArray->size() do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (stringArray[i+1]) ; 
       if _switchval = "+" then
     a := que->first() ;     que := que->tail() ; 
    b := que->first() ;     que := que->tail() ; 
    que := que->prepend(b + a) ; 
    break 
   else skip ;
       if _switchval = "-" then
     a := que->first() ;     que := que->tail() ; 
    b := que->first() ;     que := que->tail() ; 
    que := que->prepend(b - a) ; 
    break 
   else skip ;
       if _switchval = "/" then
     a := que->first() ;     que := que->tail() ; 
    b := que->first() ;     que := que->tail() ; 
    que := que->prepend(b / a) ; 
    break 
   else skip ;
       if _switchval = "*" then
     a := que->first() ;     que := que->tail() ; 
    b := que->first() ;     que := que->tail() ; 
    que := que->prepend(b * a) ; 
    break 
   else skip ;
       if true then
     que := que->prepend((stringArray[i+1])->toInteger()) ; 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(que->last()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int top=0 ;
  static int max=110 ;
  static int[] stack=new int[max];
  public static boolean isNum(String str){
    try {
      Integer.parseInt(str);
      return true ;
    }
    catch(NumberFormatException e){
      return false ;
    }
  }
  public static void initialize(){
    top=0 ;
  }
  public static boolean isEmpty(){
    return top==0 ;
  }
  public static boolean isFull(){
    return top>=max-1 ;
  }
  public static void push(int x){
    if(isFull()){
      throw new IllegalArgumentException("aa aa aa");
    }
    else {
      top++;
      stack[top]=x ;
    }
  }
  public static int pop(){
    if(isEmpty()){
      throw new IllegalArgumentException("aa aa aa");
    }
    else {
      top--;
      return stack[top+1];
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s="" ;
    int a ;
    while(sc.hasNext()){
      s=sc.next();
      if(isNum(s)){
        push(Integer.parseInt(s));
      }
      else if(s.equals("+")){
        a=pop()+pop();
        push(a);
      }
      else if(s.equals("-")){
        a=-(pop()-pop());
        push(a);
      }
      else {
        a=pop()*pop();
        push(a);
      }
    }
    System.out.println(pop());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute top : int := 0;
  static   attribute max : int := 110;
  static   attribute stack : Sequence(int) := Integer.subrange(1,max)->collect(0);
  static   operation isNum( str : String) : boolean
  pre: true
  post: true
  activity: (     try (     Integer.parseInt(str) ; 
     return true )   catch (e : IncorrectElementException) do (     return false )
 );
  static   operation initialize() : void
  pre: true
  post: true
  activity: (     top := 0 );
  static   operation isEmpty() : boolean
  pre: true
  post: true
  activity: (     return top = 0 );
  static   operation isFull() : boolean
  pre: true
  post: true
  activity: (     return top >= max - 1 );
  static   operation push( x : int) : void
  pre: true
  post: true
  activity: (     if (isFull()) then (     error IllegalArgumentException.newIllegalArgumentException("aa aa aa") ) else (     top := top + 1 ; 
     stack[top+1] := x ) );
  static   operation pop() : int
  pre: true
  post: true
  activity: (     if (isEmpty()) then (     error IllegalArgumentException.newIllegalArgumentException("aa aa aa") ) else (     top := top - 1 ; 
     return stack[top + 1+1] ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := "" ;
    var a : int ;
    while (sc.hasNext()) do (     s := sc.getCurrent() ; 
     if (isNum(s)) then (     execute push((s)->toInteger()) ) else     if (s = "+") then (     a := pop() + pop() ; 
     execute push(a) ) else     if (s = "-") then (     a := -(pop() - pop()) ; 
     execute push(a) ) else (     a := pop() * pop() ; 
     execute push(a) ) ;  ;  ) ; 
    OclFile["System.out"].println(pop()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int getTotalXorOfSubarrayXors(int arr[],int N){
    int res=0 ;
    for(int i=0 ; i<N ; i++)for(int j=i ; j<N ; j++)for(int k=i ; k<=j ; k++)res=res ^ arr[k];
    return res ;
  }
  public static void main(String args[]){
    int arr[]={3,5,2,4,6 };
      int N=arr.length ;
      System.out.println(getTotalXorOfSubarrayXors(arr,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getTotalXorOfSubarrayXors( arr : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < N do (         var j : int ; j := i ; while j < N do (         var k : int ; k := i ; while k <= j do (     res := MathLib.bitwiseXor(res,arr[k+1]) ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,5,2,4,6} ;
     var N : int ; N := arr->size() ;
     OclFile["System.out"].println(getTotalXorOfSubarrayXors(arr, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int longestSubarray(int arr[],int n){
    int i,d ;
    int hash[][]=new int[2][10];
    for(i=0 ; i<2 ; i++)for(int j=0 ; j<10 ; j++)hash[i][j]=0 ;
    int currRow ;
    int maxLen=1 ;
    int len=0 ;
    int tmp ;
    tmp=arr[0];
    while(tmp>0){
      hash[0][tmp % 10]=1 ;
      tmp/=10 ;
    }
    currRow=1 ;
    for(i=1 ; i<n ; i++){
      tmp=arr[i];
      for(d=0 ; d<=9 ; d++)hash[currRow][d]=0 ;
      while(tmp>0){
        hash[currRow][tmp % 10]=1 ;
        tmp/=10 ;
      }
      for(d=0 ; d<=9 ; d++){
        if(hash[currRow][d]!=0 && hash[1-currRow][d]!=0){
          len++;
          break ;
        }
      }
      if(d==10){
        len=1 ;
      }
      maxLen=Math.max(maxLen,len);
      currRow=1-currRow ;
    }
    return maxLen ;
  }
  public static void main(String args[]){
    int arr[]={
      11,22,33,44,54,56,63 };
      int n=arr.length ;
      System.out.println(longestSubarray(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation longestSubarray( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var d : int ;
     var hash : Sequence(Sequence(int)) ; hash := Integer.subrange(1,2)->collect(Integer.subrange(1,10)->collect(0)) ;
        i := 0 ; while i < 2 do (         var j : int ; j := 0 ; while j < 10 do (     hash[i+1][j+1] := 0 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var currRow : int ;
    var maxLen : int ; maxLen := 1 ;
    var len : int ; len := 0 ;
    var tmp : int ;
    tmp := arr[0+1] ; 
    while (tmp > 0) do (     hash[0+1][tmp mod 10+1] := 1 ; 
     tmp := tmp/(10) ) ; 
    currRow := 1 ; 
        i := 1 ; while i < n do ( (     tmp := arr[i+1] ; 
         d := 0 ; while d <= 9 do (     hash[currRow+1][d+1] := 0 ;  ;     d := d + 1 ) ; 
    while (tmp > 0) do (     hash[currRow+1][tmp mod 10+1] := 1 ; 
     tmp := tmp/(10) ) ; 
        d := 0 ; while d <= 9 do ( (     if (hash[currRow+1][d+1] /= 0 & hash[1 - currRow+1][d+1] /= 0) then (     len := len + 1 ; 
     break ) else skip )  ;     d := d + 1 ) ; 
    if (d = 10) then (     len := 1 ) else skip ; 
    maxLen := Set{maxLen, len}->max() ; 
    currRow := 1 - currRow ; 
 )  ;     i := i + 1 ) ; 
    return maxLen 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{11,22,33,44,54,56,63} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(longestSubarray(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    HashMap<Long,Integer>map=new HashMap<Long,Integer>();
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        long sum=a[i]+a[j];
        map.put(sum,map.getOrDefault(sum,0)+1);
      }
    }
    int max=0 ;
    for(Long key : map.keySet()){
      max=Math.max(map.get(key),max);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var map : Map(long,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var sum : long ; sum := a[i+1] + a[j+1] ;
     map := map->union(Map{sum |-> (if map->keys()->contains(sum) then map->at(sum) else 0 endif) + 1}) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    for (key : map->keys()) do ( (     max := Set{map->at(key), max}->max() )  ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class vfe {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int x=in.nextInt();
    int y=in.nextInt();
    ArrayList<Integer>list=new ArrayList<>();
    list.add(x);
    list.add(y);
    list.add(y-x);
    int i=2 ;
    while(!(list.get(i)==y && list.get(i-1)==x || list.get(i)==0 && list.get(i-1)==0)){
      list.add(list.get(i)-list.get(i-1));
      i++;
    }
    int k=in.nextInt();
    i-=1 ;
    k=k % i ;
    if(k==0){
      k=i ;
    }
    System.out.println(((list.get(k-1)% 1000000007)+1000000007)% 1000000007);
  }
}
------------------------------------------------------------
OCL File:
---------
 class vfe {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := in.getCurrent()->toInteger() ;
    var y : int ; y := in.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
    list := list->including(x) ; 
    list := list->including(y) ; 
    list := list->including(y - x) ; 
    var i : int ; i := 2 ;
    while (not((list->at(i+1) = y & list->at(i - 1+1) = x or list->at(i+1) = 0 & list->at(i - 1+1) = 0))) do (     list := list->including(list->at(i+1) - list->at(i - 1+1)) ; 
     i := i + 1 ) ; 
    var k : int ; k := in.getCurrent()->toInteger() ;
    i := i-(1) ; 
    k := k mod i ; 
    if (k = 0) then (     k := i ) else skip ; 
    OclFile["System.out"].println(((list->at(k - 1+1) mod 1000000007) + 1000000007) mod 1000000007) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.Scanner ;
public class FedyaAndMaths {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    Scanner in=new Scanner(System.in);
    BigInteger b ;
    BigInteger x=new BigInteger("4");
    BigInteger y=new BigInteger("0");
    b=in.nextBigInteger();
    if(b.mod(x).equals(y))System.out.println("4");
    else System.out.println("0");
  }
}
------------------------------------------------------------
OCL File:
---------
 class FedyaAndMaths {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var b : long ;
    var x : long ; x := long("4") ;
    var y : long ; y := long("0") ;
    b := in.nextBigInteger() ; 
    if (b.mod(x) = y) then     OclFile["System.out"].println("4") else     OclFile["System.out"].println("0") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void printCubeFree(int n){
    boolean[] cubFree=new boolean[n+1];
    for(int i=0 ; i<=n ; i++)cubFree[i]=true ;
    for(int i=2 ; i*i*i<=n ; i++){
      if(cubFree[i]){
        for(int multiple=1 ; i*i*i*multiple<=n ; multiple++){
          cubFree[i*i*i*multiple]=false ;
        }
      }
    }
    for(int i=2 ; i<=n ; i++){
      if(cubFree[i]==true)System.out.print(i+" ");
    }
  }
  public static void main(String[] args){
    printCubeFree(20);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printCubeFree( n : int) : void
  pre: true
  post: true
  activity: (     var cubFree : Sequence(boolean) ; cubFree := Integer.subrange(1,n + 1)->collect(false) ;
         var i : int ; i := 0 ; while i <= n do (     cubFree[i+1] := true ;  ;     i := i + 1 ) ; 
         var i : int ; i := 2 ; while i * i * i <= n do ( (     if (cubFree[i+1]) then (         var multiple : int ; multiple := 1 ; while i * i * i * multiple <= n do ( (     cubFree[i * i * i * multiple+1] := false )  ;     multiple := multiple + 1 ) ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 2 ; while i <= n do ( (     if (cubFree[i+1] = true) then     OclFile["System.out"].print(i + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute printCubeFree(20) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.Closeable ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.PriorityQueue ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    final int N=sc.nextInt();
    for(int i=1 ; i<10000 ; i++){
      int count=0 ;
      for(int j=1 ; j<=i ; j++){
        if(i % j==0){
          count++;
        }
      }
      if(count==N){
        System.out.println(i);
        break ;
      }
    }
  }
  public static class Scanner implements Closeable {
    private BufferedReader br ;
    private StringTokenizer tok ;
    public Scanner(InputStream is)throws IOException {
      br=new BufferedReader(new InputStreamReader(is));
    }
    private void getLine()throws IOException {
      while(! hasNext()){
        tok=new StringTokenizer(br.readLine());
      }
    }
    private boolean hasNext(){
      return tok!=null && tok.hasMoreTokens();
    }
    public String next()throws IOException {
      getLine();
      return tok.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public void close()throws IOException {
      br.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i < 10000 do ( (     var count : int ; count := 0 ;
         var j : int ; j := 1 ; while j <= i do ( (     if (i mod j = 0) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (count = N) then (     OclFile["System.out"].println(i) ; 
     break ) else skip )  ;     i := i + 1 ) );
  static class Scanner implements Closeable {
   attribute br : OclFile;
   attribute tok : OclIterator;
   static operation newScanner( is : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
   operation getLine() : void
  pre: true
  post: true
  activity: (     while (not(hasNext())) do (     tok := OclIterator.newOclIterator_String(br.readLine()) ) );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return tok /= null & tok.hasNext() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute getLine() ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner sc=new Scanner(System.in);
    int[] ans={
      0,1,2,4,6,16,12,64,24,36,48,1024,60 };
      int i=sc.nextInt();
      System.out.println(ans[i]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ans : Sequence(int) ; ans := Sequence{0,1,2,4,6,16,12,64,24,36,48,1024,60} ;
     var i : int ; i := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(ans[i+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int N ;
    N=sc.nextInt();
    int count=0 ;
    for(int i=1 ; ; ++i){
      for(int j=1 ; j<=i ; ++j){
        if(i % j==0){
          count++;
        }
      }
      if(count==N){
        System.out.println(i);
        break ;
      }
      count=0 ;
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ;
    N := sc.getCurrent()->toInteger() ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while true do ( (         var j : int ; j := 1 ; while j <= i do ( (     if (i mod j = 0) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (count = N) then (     OclFile["System.out"].println(i) ; 
     break ) else skip ; 
     count := 0 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int M=scan.nextInt();
    List<Integer>odd=new ArrayList<>();
    List<Integer>even=new ArrayList<>();
    for(int i=0 ; i<M ; ++i){
      int a=scan.nextInt();
      if(a % 2==0)even.add(a);
      else odd.add(a);
    }
    if(odd.size()>2){
      System.out.println("Impossible");
      return ;
    }
    List<Integer>ans=new ArrayList<>();
    if(odd.size()>=1){
      int d=odd.remove(0);
      System.out.print(d+" ");
      while(d>1){
        ans.add(2);
        d-=2 ;
      }
    }
    else {
      int d=even.remove(0);
      System.out.print(d+" ");
      ans.add(d-1);
    }
    for(int i=0 ; i<even.size(); ++i){
      ans.add(even.get(i));
      System.out.print(even.get(i)+" ");
    }
    if(odd.size()>=1){
      int d=odd.remove(0);
      System.out.print(d+" ");
      while(d>0){
        ans.add(2);
        d-=2 ;
      }
    }
    else {
      ans.add(1);
    }
    System.out.println();
    System.out.println(ans.size());
    for(int i : ans)System.out.print(i+" ");
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var M : int ; M := scan.getCurrent()->toInteger() ;
    var odd : Sequence(int) ; odd := Sequence{} ;
    var even : Sequence(int) ; even := Sequence{} ;
        var i : int ; i := 0 ; while i < M do ( (     var a : int ; a := scan.getCurrent()->toInteger() ;
     if (a mod 2 = 0) then     even := even->including(a) ; else     odd := odd->including(a) ; )  ;     i := i + 1 ) ; 
    if (odd->size() > 2) then (     OclFile["System.out"].println("Impossible") ; 
     return ) else skip ; 
    var ans : Sequence(int) ; ans := Sequence{} ;
    if (odd->size() >= 1) then (     var d : int ; d := odd->at(0+1) ;
     OclFile["System.out"].print(d + " ") ; 
     while (d > 1) do (     ans := ans->including(2) ; 
     d := d-(2) ) ) else (     var d : int ; d := even->at(0+1) ;
     OclFile["System.out"].print(d + " ") ; 
     ans := ans->including(d - 1) ) ;  
        var i : int ; i := 0 ; while i < even->size() do ( (     ans := ans->including(even->at(i+1)) ; 
     OclFile["System.out"].print(even->at(i+1) + " ") )  ;     i := i + 1 ) ; 
    if (odd->size() >= 1) then (     var d : int ; d := odd->at(0+1) ;
     OclFile["System.out"].print(d + " ") ; 
     while (d > 0) do (     ans := ans->including(2) ; 
     d := d-(2) ) ) else (     ans := ans->including(1) ) ;  
    OclFile["System.out"].println() ; 
    OclFile["System.out"].println(ans->size()) ; 
    for (i : ans) do (     OclFile["System.out"].print(i + " ") ;  ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    ArrayList<Integer>odd=new ArrayList<>();
    ArrayList<Integer>even=new ArrayList<>();
    for(int i=0 ; i<M ; i++){
      int A=sc.nextInt();
      if(A % 2==0)even.add(A);
      else odd.add(A);
    }
    if(odd.size()>2){
      System.out.println("Impossible");
    }
    else {
      ArrayList<Integer>list=new ArrayList<>();
      if(odd.size()>0)list.add(odd.get(0));
      list.addAll(even);
      if(odd.size()>1)list.add(odd.get(1));
      printList(list);
      if(list.size()==1){
        if(list.get(0)>1){
          list.set(0,list.get(0)-1);
          list.add(1);
        }
      }
      else {
        list.set(0,list.get(0)-1);
        list.set(list.size()-1,list.get(list.size()-1)-1);
        list.add(1,2);
        if(list.get(0)==0)list.remove(0);
        if(list.get(list.size()-1)==0)list.remove(list.size()-1);
      }
      System.out.println(list.size());
      printList(list);
    }
    sc.close();
  }
  static void printList(ArrayList<Integer>list){
    for(int i=0 ; i<list.size(); i++)System.out.print(list.get(i)+(i==list.size()-1 ? "\n" : " "));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var odd : Sequence(int) ; odd := Sequence{} ;
    var even : Sequence(int) ; even := Sequence{} ;
        var i : int ; i := 0 ; while i < M do ( (     var A : int ; A := sc.getCurrent()->toInteger() ;
     if (A mod 2 = 0) then     even := even->including(A) ; else     odd := odd->including(A) ; )  ;     i := i + 1 ) ; 
    if (odd->size() > 2) then (     OclFile["System.out"].println("Impossible") ) else (     var list : Sequence(int) ; list := Sequence{} ;
     if (odd->size() > 0) then     list := list->including(odd->at(0+1)) ; else skip ; 
    list := list->union(even) ; 
    if (odd->size() > 1) then     list := list->including(odd->at(1+1)) ; else skip ; 
    execute printList(list) ; 
    if (list->size() = 1) then (     if (list->at(0+1) > 1) then (     list := list.setAt(0+1,list->at(0+1) - 1) ; 
     list := list->including(1) ) else skip ) else (     list := list.setAt(0+1,list->at(0+1) - 1) ; 
     list := list.setAt(list->size() - 1+1,list->at(list->size() - 1+1) - 1) ; 
    list := list.insertAt(1+1,2) ; 
    if (list->at(0+1) = 0) then     list := list->excludingAt(0+1) ; else skip ; 
    if (list->at(list->size() - 1+1) = 0) then     list := list->excludingFirst(list->size() - 1) ; else skip ; 
 ) ;  
    OclFile["System.out"].println(list->size()) ; 
    execute printList(list) ; 
 ) ;  
    skip ; 
 );
  static   operation printList( list : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < list->size() do (     OclFile["System.out"].print(list->at(i+1) + (if i = list->size() - 1 then "\n" else " " endif)) ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int max_length_substring(String st,int n,int k){
    int max_len=0 ;
    int len=0 ;
    for(int i=0 ; i<n ; ++i){
      if(st.charAt(i)=='0')len++;
      else len=0 ;
      max_len=Math.max(max_len,len);
    }
    if(max_len==n)return n*k ;
    int pref=0,suff=0 ;
    for(int i=0 ; st.charAt(i)=='0' ; ++i,++pref);
    for(int i=n-1 ; st.charAt(i)=='0' ; --i,++suff);
    if(k>1)max_len=Math.max(max_len,pref+suff);
    return max_len ;
  }
  public static void main(String[] args){
    int n=6 ;
    int k=3 ;
    String st="110010" ;
    int ans=max_length_substring(st,n,k);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation max_length_substring( st : String, n : int, k : int) : int
  pre: true
  post: true
  activity: (     var max_len : int ; max_len := 0 ;
     var len : int ; len := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (st->at(i+1) = '0') then     len := len + 1 else     len := 0 ; ;  
     max_len := Set{max_len, len}->max() )  ;     i := i + 1 ) ; 
    if (max_len = n) then     return n * k else skip ; 
    var pref : int ; pref := 0 ;
    var suff : int ; suff := 0 ;
        var i : int ; i := 0 ; while st->at(i+1) = '0' do (   ;     i := i + 1 ;     pref := pref + 1 ) ; 
        var i : int ; i := n - 1 ; while st->at(i+1) = '0' do (   ;     i := i - 1 ;     suff := suff + 1 ) ; 
    if (k > 1) then     max_len := Set{max_len, pref + suff}->max() ; else skip ; 
    return max_len 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     var k : int ; k := 3 ;
    var st : String ; st := "110010" ;
    var ans : int ; ans := max_length_substring(st, n, k) ;
    OclFile["System.out"].println(ans) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=scan.nextInt();
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++){
      a[i]=scan.nextInt();
    }
    int min=Arrays.stream(a).min().getAsInt();
    int max=Arrays.stream(a).max().getAsInt();
    if(N==2){
      System.out.println("Yes");
      return ;
    }
    if(2<=max-min){
      System.out.println("No");
      return ;
    }
    if(max-min==0){
      if(max==N-1 || max*2<=N){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
      return ;
    }
    long max_count=Arrays.stream(a).filter(i->i==max).count();
    long min_count=Arrays.stream(a).filter(i->i==min).count();
    if(min_count<max && 2*(max-min_count)<=max_count){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var min : int ; min := stream(a).min().getAsInt() ;
    var max : int ; max := stream(a).max().getAsInt() ;
    if (N = 2) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
    if (2 <= max - min) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
    if (max - min = 0) then (     if (max = N - 1 or max * 2 <= N) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
     return ) else skip ; 
    var max_count : long ; max_count := stream(a)->select( _x1 | (lambda i : OclAny in i = max)->apply(_x1) )->size() ;
    var min_count : long ; min_count := stream(a)->select( _x1 | (lambda i : OclAny in i = min)->apply(_x1) )->size() ;
    if (min_count < max & 2 * (max - min_count) <= max_count) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Map ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int count=0 ;
    TreeMap<Integer,Integer>map=new TreeMap<>();
    for(int i=0 ; i<n ; i++){
      int query=scan.nextInt();
      int a=scan.nextInt();
      switch(query){
        case 0 : if(! map.containsKey(a))map.put(a,1);
        else map.put(a,map.get(a)+1);
        count++;
        System.out.println(count);
        break ;
        case 1 : if(map.get(a)!=null)System.out.println(map.get(a));
        else System.out.println(0);
        break ;
        case 2 : if(map.get(a)!=null){
          count-=map.get(a);
          map.remove(a);
        }
        break ;
        case 3 : int b=scan.nextInt();
        Map<Integer,Integer>subM=map.subMap(a,true,b,true);
        for(Integer x : subM.keySet()){
          for(int j=0 ; j<map.get(x); j++){
            System.out.println(x);
          }
        }
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var query : int ; query := scan.getCurrent()->toInteger() ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (query) ; 
       if _switchval = 0 then
     if (not(map->keys()->includes(a))) then     map := map->union(Map{a |-> 1}) else     map := map->union(Map{a |-> map->at(a) + 1}) ; ;  
    count := count + 1 ; 
    OclFile["System.out"].println(count) ; 
    break 
   else skip ;
       if _switchval = 1 then
     if (map->at(a) /= null) then     OclFile["System.out"].println(map->at(a)) else     OclFile["System.out"].println(0) ; ;  
    break 
   else skip ;
       if _switchval = 2 then
     if (map->at(a) /= null) then (     count := count-(map->at(a)) ; 
     map := map->antirestrict(Set{a}) ) else skip ; 
    break 
   else skip ;
       if _switchval = 3 then
     var b : int ; b := scan.getCurrent()->toInteger() ;
    var subM : Map(int,int) ; subM := map->restrict( _key | _key < true & _key >= a ) ;
    for (x : subM->keys()) do ( (         var j : int ; j := 0 ; while j < map->at(x) do ( (     OclFile["System.out"].println(x) )  ;     j := j + 1 ) )  ) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Comparator<String>comp=new Comparator<String>(){
    public int compare(String a,String b){
      for(int i=0 ; i<a.length(); i++){
        if(a.charAt(i)<b.charAt(i))return-1+(i % 2)*2 ;
        else if(a.charAt(i)>b.charAt(i))return 1-(i % 2)*2 ;
      }
      return 0 ;
    }
  };
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    String[] a=new String[n];
    HashMap<String,Integer>ids=new HashMap<String,Integer>();
    for(int i=0 ; i<n ; i++){
      a[i]=sc.next();
      ids.put(a[i],i+1);
    }
    Arrays.sort(a,comp);
    for(String x : a){
      System.out.print(ids.get(x)+" ");
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute comp : Function(<String>,(<String>,boolean)) := OclComparator<String>.newOclComparator();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(String) ; a := Integer.subrange(1,n)->collect(null) ;
    var ids : Map(String,int) ; ids := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent() ; 
     ids := ids->union(Map{a[i+1] |-> i + 1}) )  ;     i := i + 1 ) ; 
    a := OclComparator.sortWith(a, comp) ; 
    for (x : a) do ( (     OclFile["System.out"].print(ids->at(x) + " ") )  ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    DataSet d=new DataSet();
    d.input();
    int dif=d.max-d.min ;
    if(dif>1)System.out.println("No");
    else if(dif==1){
      if(2*(d.max-d.q)<=d.p && d.q<=d.min)System.out.println("Yes");
      else System.out.println("No");
    }
    else if(dif==0){
      if(d.max==d.N-1 || 2*d.max<=d.N)System.out.println("Yes");
      else System.out.println("No");
    }
  }
}
class DataSet {
  int N ;
  int[] a ;
  int max=0,min=1000000 ;
  int p=0,q=0 ;
  public void input(){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    a=new int[N];
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextInt();
      max=Math.max(max,a[i]);
      min=Math.min(min,a[i]);
    }
    for(int i=0 ; i<N ; i++){
      if(a[i]==max)p++;
      if(a[i]==min)q++;
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : DataSet ; d := DataSet.newDataSet() ;
     d.input() ; 
     var dif : int ; dif := d.max - d.min ;
     if (dif > 1) then     OclFile["System.out"].println("No") ; else     if (dif = 1) then (     if (2 * (d.max - d.q) <= d.p & d.q <= d.min) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; ) else     if (dif = 0) then (     if (d.max = d.N - 1 or 2 * d.max <= d.N) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; ) else skip ; ;  );
}
class DataSet {
   attribute N : int;
   attribute a : Sequence(int);
   attribute max : int := 0;
   attribute p : int := 0;
   operation input() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,N)->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     max := Set{max, a[i+1]}->max() ; 
     min := Set{min, a[i+1]}->min() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (a[i+1] = max) then     p := p + 1 ; else skip ; 
     if (a[i+1] = min) then     q := q + 1 ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    TreeMap<Integer,Integer>map=new TreeMap<Integer,Integer>();
    for(int i=0 ; i<N ; i++){
      int a=sc.nextInt();
      if(map.containsKey(a))map.put(a,map.get(a)+1);
      else map.put(a,1);
    }
    boolean flag=false ;
    ArrayList<Integer>key=new ArrayList<Integer>(map.keySet());
    ArrayList<Integer>val=new ArrayList<Integer>(map.values());
    int size=key.size();
    if(size==1 &&((val.get(0)-1)==key.get(0)||(long)2*key.get(0)<=val.get(0)))flag=true ;
    if(size==2 && key.get(1)-key.get(0)==1 && val.get(0)<key.get(1)&& 2*(key.get(1)-val.get(0))<=val.get(1))flag=true ;
    if(flag)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (map->keys()->includes(a)) then     map := map->union(Map{a |-> map->at(a) + 1}) ; else     map := map->union(Map{a |-> 1}) ; )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := false ;
    var key : Sequence(int) ; key := Sequence{}->union(map->keys()) ;
    var val : Sequence(int) ; val := Sequence{}->union(map->values()) ;
    var size : int ; size := key->size() ;
    if (size = 1 & ((val->at(0+1) - 1) = key->at(0+1) or 2->oclAsType(long) * key->at(0+1) <= val->at(0+1))) then     flag := true ; else skip ; 
    if (size = 2 & key->at(1+1) - key->at(0+1) = 1 & val->at(0+1) < key->at(1+1) & 2 * (key->at(1+1) - val->at(0+1)) <= val->at(1+1)) then     flag := true ; else skip ; 
    if (flag) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double Probability(double p[],int n){
    double[][] dp=new double[n+1][n+1];
    dp[0][0]=1.0 ;
    for(int i=1 ; i<=n ; i+=1){
      for(int j=0 ; j<=i ; j+=1){
        if(j==0)dp[i][j]=dp[i-1][j]*(1.0-p[i]);
        else dp[i][j]=dp[i-1][j]*(1.0-p[i])+dp[i-1][j-1]*p[i];
      }
    }
    double ans=0.0 ;
    for(int i=(n+1)/2 ; i<=n ; i+=1)ans+=dp[n][i];
    return ans ;
  }
  public static void main(String[] args){
    double p[]={
      0.0,0.3,0.4,0.7 };
      int n=p.length-1 ;
      System.out.println(Probability(p,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Probability( p : Sequence(double), n : int) : double
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(double)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0.0)) ;
     dp[0+1][0+1] := 1.0 ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= i do ( (     if (j = 0) then     dp[i+1][j+1] := dp[i - 1+1][j+1] * (1.0 - p[i+1]) ; else     dp[i+1][j+1] := dp[i - 1+1][j+1] * (1.0 - p[i+1]) + dp[i - 1+1][j - 1+1] * p[i+1] ; )  ;     j := j+(1) ) )  ;     i := i+(1) ) ; 
    var ans : double ; ans := 0.0 ;
        var i : int ; i := (n + 1) / 2 ; while i <= n do (     ans := ans+(dp[n+1][i+1]) ;  ;     i := i+(1) ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : Sequence(double) ; p := Sequence{0.0,0.3,0.4,0.7} ;
     var n : int ; n := p->size() - 1 ;
     OclFile["System.out"].println(Probability(p, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(new File("Main.in"));
    PrintWriter out=new PrintWriter(new File("Main.out"));
    int tests=in.nextInt();
    final int MOD=100003 ;
    int[][] f=new int[512][512];
    for(int m=0 ; m<512 ; m++)f[0][m]=1 ;
    for(int n=1 ; n<512 ; n++){
      for(int m=1 ; m<=n ; m++){
        f[n][m]=0 ;
        for(int k=1 ; k<=m ; k++){
          f[n][m]=(f[n][m]+f[n-k][m])% MOD ;
        }
      }
    }
    for(int i=0 ; i<10 ; i++){
      for(int j=0 ; j<10 ; j++)System.out.print(f[i][j]+" ");
      System.out.println();
    }
    for(int test=1 ; test<=tests ; test++){
      out.print("Case #"+test+": ");
      int n=in.nextInt();
      int ans=0 ;
      for(int h=2 ; h<=n ; h++)ans=(ans+f[n-1][h-1])% MOD ;
      out.println(ans);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("Main.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("Main.out")) ;
    var tests : int ; tests := in.getCurrent()->toInteger() ;
    var MOD : int ; MOD := 100003 ;
    var f : Sequence(Sequence(int)) ; f := Integer.subrange(1,512)->collect(Integer.subrange(1,512)->collect(0)) ;
        var m : int ; m := 0 ; while m < 512 do (     f[0+1][m+1] := 1 ;  ;     m := m + 1 ) ; 
        var n : int ; n := 1 ; while n < 512 do ( (         var m : int ; m := 1 ; while m <= n do ( (     f[n+1][m+1] := 0 ; 
         var k : int ; k := 1 ; while k <= m do ( (     f[n+1][m+1] := (f[n+1][m+1] + f[n - k+1][m+1]) mod MOD )  ;     k := k + 1 ) )  ;     m := m + 1 ) )  ;     n := n + 1 ) ; 
        var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < 10 do (     OclFile["System.out"].print(f[i+1][j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
        var test : int ; test := 1 ; while test <= tests do ( (     skip ; 
     var n : int ; n := in.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var h : int ; h := 2 ; while h <= n do (     ans := (ans + f[n - 1+1][h - 1+1]) mod MOD ;  ;     h := h + 1 ) ; 
    skip ; 
 )  ;     test := test + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class x {
  static final int MOD=100003 ;
  static final int MAXN=500 ;
  public static void main(String args[])throws Exception {
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    int[][] C=new int[MAXN+1][MAXN+1];
    for(int i=0 ; i<=MAXN ; i++){
      C[i][0]=1 ;
      for(int j=1 ; j<=i ; j++){
        C[i][j]=(C[i-1][j-1]+C[i-1][j])% MOD ;
      }
    }
    int[][] D=new int[MAXN+1][MAXN+1];
    int[] A=new int[MAXN+1];
    D[1][0]=1 ;
    for(int i=2 ; i<=MAXN ; i++){
      for(int j=1 ; j<i ; j++){
        for(int k=0 ; k<j ; k++)if(j-k-1>=0 && j-k-1<=i-j-1){
          long cur=D[j][k];
          cur=(D[i][j]+cur*C[i-j-1][j-k-1])% MOD ;
          D[i][j]=(int)cur ;
        }
        A[i]=(A[i]+D[i][j])% MOD ;
      }
    }
    for(int tt=1 ; tt<=t ; tt++){
      int n=in.nextInt();
      System.out.println("Case #"+tt+": "+A[n]);
    };
  };
};
------------------------------------------------------------
OCL File:
---------
 class x {
  static    attribute MOD : int := 100003;
  static    attribute MAXN : int := 500;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var C : Sequence(Sequence(int)) ; C := Integer.subrange(1,MAXN + 1)->collect(Integer.subrange(1,MAXN + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i <= MAXN do ( (     C[i+1][0+1] := 1 ; 
         var j : int ; j := 1 ; while j <= i do ( (     C[i+1][j+1] := (C[i - 1+1][j - 1+1] + C[i - 1+1][j+1]) mod MOD )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var D : Sequence(Sequence(int)) ; D := Integer.subrange(1,MAXN + 1)->collect(Integer.subrange(1,MAXN + 1)->collect(0)) ;
    var A : Sequence(int) ; A := Integer.subrange(1,MAXN + 1)->collect(0) ;
    D[1+1][0+1] := 1 ; 
        var i : int ; i := 2 ; while i <= MAXN do ( (         var j : int ; j := 1 ; while j < i do ( (         var k : int ; k := 0 ; while k < j do (     if (j - k - 1 >= 0 & j - k - 1 <= i - j - 1) then (     var cur : long ; cur := D[j+1][k+1] ;
     cur := (D[i+1][j+1] + cur * C[i - j - 1+1][j - k - 1+1]) mod MOD ; 
     D[i+1][j+1] := cur->oclAsType(int) ) else skip ;  ;     k := k + 1 ) ; 
     A[i+1] := (A[i+1] + D[i+1][j+1]) mod MOD )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var tt : int ; tt := 1 ; while tt <= t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println("Case #" + tt + ": " + A[n+1]) )  ;     tt := tt + 1 ) ; 
 );
}
;

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileInputStream ;
import java.io.FileNotFoundException ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
import java.io.FileOutputStream ;
public class Main {
  public static void main(String[] args){
    try {
      File file=new File("C-large.in");
      FileInputStream fis=new FileInputStream(file);
      BufferedInputStream bis=new BufferedInputStream(fis);
      BufferedReader dis=new BufferedReader(new InputStreamReader(bis));
      File ofile=new File("C-large.out");
      if(! ofile.exists()){
        ofile.createNewFile();
      }
      PrintStream out=new PrintStream(new FileOutputStream(ofile));
      int[][] f=new int[501][501];
      for(int i=0 ; i<501 ; i++){
        for(int j=0 ; j<501 ; j++){
          if(i==0){
            f[i][j]=1 ;
          }
          else {
            for(int k=1 ; k<=j ; k++){
              if(k>i)break ;
              f[i][j]+=f[i-k][j];
            }
            f[i][j] %=100003 ;
          }
        }
      }
      int[] f2=new int[501];
      for(int i=1 ; i<501 ; i++){
        for(int j=0 ; j<=i ; j++){
          f2[i]+=f[j][i-j];
          f2[i] %=100003 ;
        }
      }
      int T=Integer.parseInt(dis.readLine());
      int c=0 ;
      while(c++<T){
        out.print("Case #"+c+": ");
        out.println(f2[Integer.parseInt(dis.readLine())-1]);
      }
      fis.close();
      bis.close();
      dis.close();
    }
    catch(FileNotFoundException e){
      e.printStackTrace();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var file : OclFile ; file := OclFile("C-large.in") ;
     var fis : OclFile ; fis := OclFile.newOclFile_Read(file) ;
    var bis : OclFile ; bis := OclFile.newOclFile_Read(fis) ;
    var dis : OclFile ; dis := OclFile.newOclFile_Read(OclFile.newOclFile_Read(bis)) ;
    var ofile : OclFile ; ofile := OclFile("C-large.out") ;
    if (not(ofile.exists())) then (     skip ) else skip ; 
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(ofile)) ;
    var f : Sequence(Sequence(int)) ; f := Integer.subrange(1,501)->collect(Integer.subrange(1,501)->collect(0)) ;
        var i : int ; i := 0 ; while i < 501 do ( (         var j : int ; j := 0 ; while j < 501 do ( (     if (i = 0) then (     f[i+1][j+1] := 1 ) else (         var k : int ; k := 1 ; while k <= j do ( (     if (k > i) then     break else skip ; 
     f[i+1][j+1] := f[i+1][j+1]+(f[i - k+1][j+1]) )  ;     k := k + 1 ) ; 
     f[i+1][j+1] := f[i+1][j+1] mod 100003 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var f2 : Sequence(int) ; f2 := Integer.subrange(1,501)->collect(0) ;
        var i : int ; i := 1 ; while i < 501 do ( (         var j : int ; j := 0 ; while j <= i do ( (     f2[i+1] := f2[i+1]+(f[j+1][i - j+1]) ; 
     f2[i+1] := f2[i+1] mod 100003 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var T : int ; T := (dis.readLine())->toInteger() ;
    var c : int ; c := 0 ;
        while (c < T) do (        c := c + 1 ;     skip ; (     skip ; 
     skip ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class C {
  public static void main(String[] args){
    BigInteger[][] combine=new BigInteger[512][512];
    BigInteger[][] a=new BigInteger[512][512];
    BigInteger[] s=new BigInteger[512];
    for(int i=0 ; i<512 ; i++){
      combine[i][0]=BigInteger.ONE ;
      combine[i][i]=BigInteger.ONE ;
      for(int j=1 ; j<i ; j++){
        combine[i][j]=combine[i-1][j] .add(combine[i-1][j-1]);
      }
      for(int j=0 ; j<512 ; j++)a[i][j]=BigInteger.ZERO ;
      s[i]=BigInteger.ZERO ;
    }
    for(int n=2 ; n<512 ; n++){
      a[n][1]=BigInteger.ONE ;
      for(int m=2 ; m<n ; m++){
        a[n][m]=BigInteger.ZERO ;
        for(int k=1 ; k<m ; k++){
          int N=n-m-1 ;
          int M=m-k-1 ;
          if(M>=0 && M<=N){
            a[n][m]=a[n][m] .add(combine[N][M] .multiply(a[m][k]));
          }
        }
      }
      for(int m=1 ; m<n ; m++){
        s[n]=s[n] .add(a[n][m]);
      }
    }
    Scanner sc=new Scanner(System.in);
    int tests=sc.nextInt();
    for(int cas=1 ; cas<=tests ; cas++){
      int n=sc.nextInt();
      System.out.println("Case #"+cas+": "+(s[n] .mod(BigInteger.valueOf(100003))));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var combine : Sequence(Sequence(long)) ; combine := Integer.subrange(1,512)->collect(Integer.subrange(1,512)->collect(null)) ;
     var a : Sequence(Sequence(long)) ; a := Integer.subrange(1,512)->collect(Integer.subrange(1,512)->collect(null)) ;
    var s : Sequence(long) ; s := Integer.subrange(1,512)->collect(null) ;
        var i : int ; i := 0 ; while i < 512 do ( (     combine[i+1][0+1] := 1 ; 
     combine[i+1][i+1] := 1 ; 
        var j : int ; j := 1 ; while j < i do ( (     combine[i+1][j+1] := combine[i - 1+1][j+1]->excludes(combine[i - 1+1][j - 1+1]) )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < 512 do (     a[i+1][j+1] := 0 ;  ;     j := j + 1 ) ; 
    s[i+1] := 0 ; 
 )  ;     i := i + 1 ) ; 
        var n : int ; n := 2 ; while n < 512 do ( (     a[n+1][1+1] := 1 ; 
         var m : int ; m := 2 ; while m < n do ( (     a[n+1][m+1] := 0 ; 
         var k : int ; k := 1 ; while k < m do ( (     var N : int ; N := n - m - 1 ;
     var M : int ; M := m - k - 1 ;
     if (M >= 0 & M <= N) then (     a[n+1][m+1] := a[n+1][m+1]->excludes(combine[N+1][M+1].multiply(a[m+1][k+1])) ) else skip )  ;     k := k + 1 ) )  ;     m := m + 1 ) ; 
         var m : int ; m := 1 ; while m < n do ( (     s[n+1] := s[n+1]->excludes(a[n+1][m+1]) )  ;     m := m + 1 ) )  ;     n := n + 1 ) ; 
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var tests : int ; tests := sc.getCurrent()->toInteger() ;
        var cas : int ; cas := 1 ; while cas <= tests do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println("Case #" + cas + ": " + (s[n+1].mod((100003 + "")->toLong()))) )  ;     cas := cas + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class C implements Runnable {
  private String IFILE="C-large.in" ;
  private Scanner in ;
  private PrintWriter out ;
  private int MOD=100003 ;
  public void Run()throws IOException {
    in=new Scanner(new File(IFILE));
    out=new PrintWriter("output.txt");
    int ntest=in.nextInt();
    for(int test=1 ; test<=ntest ; test++){
      out.print("Case #"+test+": ");
      int n=in.nextInt();
      long[][] c=new long[n+1][n+1];
      c[0][0]=1 ;
      for(int j=1 ; j<=n ; j++){
        c[0][j]=1 ;
        for(int i=1 ; i<=n ; i++)c[i][j]=(c[i-1][j-1]+c[i][j-1])% MOD ;
      }
      long[][] mas=new long[n+1][n+1];
      for(int j=2 ; j<=n ; j++)mas[1][j]=1 ;
      for(int i=2 ; i<=n ; i++)for(int j=i+1 ; j<=n ; j++){
        for(int k=1 ; k<i ; k++){
          mas[i][j]=(mas[i][j]+mas[k][i]*c[j-i-1][i-k-1])% MOD ;
        }
      }
      long result=0 ;
      for(int i=1 ; i<=n ; i++)result=(result+mas[i][n])% MOD ;
      out.println(result);
    }
    in.close();
    out.close();
  }
  public void run(){
    try {
      Run();
    }
    catch(IOException e){
    }
  }
  public static void main(String[] args)throws IOException {
    new C().Run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C implements Runnable {
   attribute IFILE : String := "C-large.in";
   attribute in : OclFile;
   attribute out : OclFile;
   attribute MOD : int := 100003;
   operation Run() : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile(IFILE)) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ; 
    var ntest : int ; ntest := in.getCurrent()->toInteger() ;
        var test : int ; test := 1 ; while test <= ntest do ( (     skip ; 
     var n : int ; n := in.getCurrent()->toInteger() ;
    var c : Sequence(Sequence(long)) ; c := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
    c[0+1][0+1] := 1 ; 
        var j : int ; j := 1 ; while j <= n do ( (     c[0+1][j+1] := 1 ; 
         var i : int ; i := 1 ; while i <= n do (     c[i+1][j+1] := (c[i - 1+1][j - 1+1] + c[i+1][j - 1+1]) mod MOD ;  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    var mas : Sequence(Sequence(long)) ; mas := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var j : int ; j := 2 ; while j <= n do (     mas[1+1][j+1] := 1 ;  ;     j := j + 1 ) ; 
        var i : int ; i := 2 ; while i <= n do (         var j : int ; j := i + 1 ; while j <= n do ( (         var k : int ; k := 1 ; while k < i do ( (     mas[i+1][j+1] := (mas[i+1][j+1] + mas[k+1][i+1] * c[j - i - 1+1][i - k - 1+1]) mod MOD )  ;     k := k + 1 ) )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var result : long ; result := 0 ;
        var i : int ; i := 1 ; while i <= n do (     result := (result + mas[i+1][n+1]) mod MOD ;  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     test := test + 1 ) ; 
    skip ; 
    skip ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     execute Run() )   catch (e : IOException) do skip
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     C.newC().Run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Count {
  public static void main(String args[]){
    String str="#GeeKs01fOr@gEEks07" ;
    int upper=0,lower=0,number=0,special=0 ;
    for(int i=0 ; i<str.length(); i++){
      char ch=str.charAt(i);
      if(ch>='A' && ch<='Z')upper++;
      else if(ch>='a' && ch<='z')lower++;
      else if(ch>='0' && ch<='9')number++;
      else special++;
    }
    System.out.println("Lower case letters : "+lower);
    System.out.println("Upper case letters : "+upper);
    System.out.println("Number : "+number);
    System.out.println("Special characters : "+special);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Count {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "#GeeKs01fOr@gEEks07" ;
     var upper : int ; upper := 0 ;
    var lower : int ; lower := 0 ;
    var number : int ; number := 0 ;
    var special : int ; special := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     var ch : String ; ch := str->at(i+1) ;
     if (ch >= 'A' & ch <= 'Z') then     upper := upper + 1 ; else     if (ch >= 'a' & ch <= 'z') then     lower := lower + 1 else     if (ch >= '0' & ch <= '9') then     number := number + 1 else     special := special + 1 ; ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Lower case letters : " + lower) ; 
    OclFile["System.out"].println("Upper case letters : " + upper) ; 
    OclFile["System.out"].println("Number : " + number) ; 
    OclFile["System.out"].println("Special characters : " + special) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner sc=new FastScanner();
    PrintWriter pw=new PrintWriter(System.out);
    int Q=sc.ni();
    for(int q=0 ; q<Q ; q++){
      double A=sc.nd();
      double B=sc.nd();
      double ans=0 ;
      if(A==0 && B==0)ans=1 ;
      else if(A>=4*B)ans=1-B/A ;
      else ans=0.5+A/(16*B);
      pw.println(ans);
    }
    pw.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      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 ni(){
      return Integer.parseInt(next());
    }
    long nl(){
      return Long.parseLong(next());
    }
    double nd(){
      return Double.parseDouble(next());
    }
    String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner() ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var Q : int ; Q := sc.ni() ;
        var q : int ; q := 0 ; while q < Q do ( (     var A : double ; A := sc.nd() ;
     var B : double ; B := sc.nd() ;
    var ans : double ; ans := 0 ;
    if (A = 0 & B = 0) then     ans := 1 else     if (A >= 4 * B) then     ans := 1 - B / A else     ans := 0.5 + A / (16 * B) ; ;  ;  
    skip ; 
 )  ;     q := q + 1 ) ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nl() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nd() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class modmath {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String n=scan.next();
    if(n.length()>3){
      int a=Integer.parseInt(n.substring(n.length()-2,n.length()));
      if(a % 4==0){
        System.out.println(4);
      }
      else {
        System.out.println(0);
      }
    }
    else {
      int b=Integer.parseInt(n);
      if(b % 4==0){
        System.out.println(4);
      }
      else {
        System.out.println(0);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class modmath {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : String ; n := scan.getCurrent() ;
     if (n->size() > 3) then (     var a : int ; a := (n.subrange(n->size() - 2+1,n->size()))->toInteger() ;
     if (a mod 4 = 0) then (     OclFile["System.out"].println(4) ) else (     OclFile["System.out"].println(0) ) ) else (     var b : int ; b := (n)->toInteger() ;
     if (b mod 4 = 0) then (     OclFile["System.out"].println(4) ) else (     OclFile["System.out"].println(0) ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    TreeMap<Integer,Integer>mset=new TreeMap<>();
    int q=Integer.parseInt(in.next()),size=0 ;
    for(int i=0 ; i<q ; i++){
      int odr=Integer.parseInt(in.next());
      switch(odr){
        case 0 : int x0=Integer.parseInt(in.next());
        Integer num0=mset.get(x0);
        if(num0!=null)mset.put(x0,num0+1);
        else mset.put(x0,1);
        size++;
        out.println(size);
        break ;
        case 1 : int x1=Integer.parseInt(in.next());
        Integer num1=mset.get(x1);
        out.println((num1!=null)? num1 : 0);
        break ;
        case 2 : int x2=Integer.parseInt(in.next());
        Integer num2=mset.get(x2);
        if(num2!=null)size-=num2 ;
        mset.remove(x2);
        break ;
        case 3 : int L=Integer.parseInt(in.next()),R=Integer.parseInt(in.next());
        NavigableMap<Integer,Integer>sub=mset.subMap(L,true,R,true);
        Iterator<NavigableMap.Entry<Integer,Integer>>itr=sub.entrySet().iterator();
        while(itr.hasNext()){
          NavigableMap.Entry<Integer,Integer>get=itr.next();
          int k=get.getKey(),num=get.getValue();
          for(int j=0 ; j<num ; j++)out.println(k);
        }
        break ;
      }
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var mset : Map(int,int) ; mset := Map{} ;
    var q : int ; q := (in.getCurrent())->toInteger() ;
    var size : int ; size := 0 ;
        var i : int ; i := 0 ; while i < q do ( (     var odr : int ; odr := (in.getCurrent())->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (odr) ; 
       if _switchval = 0 then
     var x0 : int ; x0 := (in.getCurrent())->toInteger() ;
    var num0 : int ; num0 := mset->at(x0) ;
    if (num0 /= null) then     mset := mset->union(Map{x0 |-> num0 + 1}) else     mset := mset->union(Map{x0 |-> 1}) ; ;  
    size := size + 1 ; 
    skip ; 
    break 
   else skip ;
       if _switchval = 1 then
     var x1 : int ; x1 := (in.getCurrent())->toInteger() ;
    var num1 : int ; num1 := mset->at(x1) ;
    skip ; 
    break 
   else skip ;
       if _switchval = 2 then
     var x2 : int ; x2 := (in.getCurrent())->toInteger() ;
    var num2 : int ; num2 := mset->at(x2) ;
    if (num2 /= null) then     size := size-(num2) ; else skip ; 
    mset := mset->antirestrict(Set{x2}) ; 
    break 
   else skip ;
       if _switchval = 3 then
     var L : int ; L := (in.getCurrent())->toInteger() ;
    var R : int ; R := (in.getCurrent())->toInteger() ;
    var sub : NavigableMap<int,int> ; sub := mset->restrict( _key | _key < true & _key >= L ) ;
    var itr : OclIterator ; itr := sub->asSet()->iterator() ;
    while (itr.hasNext()) do (     var get : Entry<int,int> ; get := itr.next() ;
     var k : int ; k := get.getKey() ;
    var num : int ; num := get.getValue() ;
         var j : int ; j := 0 ; while j < num do (     skip ;  ;     j := j + 1 ) ) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAX=100000 ;
  static int bitscount=32 ;
  static int[][] prefix_count=new int[bitscount][MAX];
  static void findPrefixCount(int arr[],int n){
    for(int i=0 ; i<bitscount ; i++){
      prefix_count[i][0]=((arr[0]>>i)& 1);
      for(int j=1 ; j<n ; j++){
        prefix_count[i][j]=((arr[j]>>i)& 1);
        prefix_count[i][j]+=prefix_count[i][j-1];
      }
    }
  }
  static int rangeOr(int l,int r){
    int ans=0 ;
    for(int i=0 ; i<bitscount ; i++){
      int x ;
      if(l==0)x=prefix_count[i][r];
      else x=prefix_count[i][r]-prefix_count[i][l-1];
      if(x!=0)ans=(ans |(1<<i));
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      7,5,3,5,2,3 };
      int n=arr.length ;
      findPrefixCount(arr,n);
      int queries[][]={
        {
          1,3 },{
            4,5 }
          };
          int q=queries.length ;
          for(int i=0 ; i<q ; i++)System.out.println(rangeOr(queries[i][0],queries[i][1]));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100000;
  static   attribute bitscount : int := 32;
  static   attribute prefix_count : Sequence(Sequence(int)) := Integer.subrange(1,bitscount)->collect(Integer.subrange(1,MAX)->collect(0));
  static   operation findPrefixCount( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < bitscount do ( (     prefix_count[i+1][0+1] := (((arr[0+1]/(2->pow(i)))->oclAsType(long)) & 1) ; 
         var j : int ; j := 1 ; while j < n do ( (     prefix_count[i+1][j+1] := (((arr[j+1]/(2->pow(i)))->oclAsType(long)) & 1) ; 
     prefix_count[i+1][j+1] := prefix_count[i+1][j+1]+(prefix_count[i+1][j - 1+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation rangeOr( l : int, r : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < bitscount do ( (     var x : int ;
     if (l = 0) then     x := prefix_count[i+1][r+1] else     x := prefix_count[i+1][r+1] - prefix_count[i+1][l - 1+1] ; ;  
     if (x /= 0) then     ans := (MathLib.bitwiseOr(ans,((1*(2->pow(i)))->oclAsType(long)))) ; else skip )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{7,5,3,5,2,3} ;
     var n : int ; n := arr->size() ;
    execute findPrefixCount(arr, n) ; 
    var queries : Sequence(Sequence(int)) ; queries := Sequence{Sequence{1,3},Sequence{4,5}} ;
    var q : int ; q := queries->size() ;
        var i : int ; i := 0 ; while i < q do (     OclFile["System.out"].println(rangeOr(queries[i+1][0+1], queries[i+1][1+1])) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAX=100000 ;
  static int bitscount=32 ;
  static int[][] prefix_count=new int[bitscount][MAX];
  static void findPrefixCount(int arr[],int n){
    for(int i=0 ; i<bitscount ; i++){
      prefix_count[i][0]=((arr[0]>>i)& 1);
      for(int j=1 ; j<n ; j++){
        prefix_count[i][j]=((arr[j]>>i)& 1);
        prefix_count[i][j]+=prefix_count[i][j-1];
      }
    }
  }
  static int rangeAnd(int l,int r){
    int ans=0 ;
    for(int i=0 ; i<bitscount ; i++){
      int x ;
      if(l==0)x=prefix_count[i][r];
      else x=prefix_count[i][r]-prefix_count[i][l-1];
      if(x==r-l+1)ans=(ans |(1<<i));
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      7,5,3,5,2,3 };
      int n=arr.length ;
      findPrefixCount(arr,n);
      int queries[][]={
        {
          1,3 },{
            4,5 }
          };
          int q=queries.length ;
          for(int i=0 ; i<q ; i++)System.out.println(rangeAnd(queries[i][0],queries[i][1]));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100000;
  static   attribute bitscount : int := 32;
  static   attribute prefix_count : Sequence(Sequence(int)) := Integer.subrange(1,bitscount)->collect(Integer.subrange(1,MAX)->collect(0));
  static   operation findPrefixCount( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < bitscount do ( (     prefix_count[i+1][0+1] := (((arr[0+1]/(2->pow(i)))->oclAsType(long)) & 1) ; 
         var j : int ; j := 1 ; while j < n do ( (     prefix_count[i+1][j+1] := (((arr[j+1]/(2->pow(i)))->oclAsType(long)) & 1) ; 
     prefix_count[i+1][j+1] := prefix_count[i+1][j+1]+(prefix_count[i+1][j - 1+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation rangeAnd( l : int, r : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < bitscount do ( (     var x : int ;
     if (l = 0) then     x := prefix_count[i+1][r+1] else     x := prefix_count[i+1][r+1] - prefix_count[i+1][l - 1+1] ; ;  
     if (x = r - l + 1) then     ans := (MathLib.bitwiseOr(ans,((1*(2->pow(i)))->oclAsType(long)))) ; else skip )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{7,5,3,5,2,3} ;
     var n : int ; n := arr->size() ;
    execute findPrefixCount(arr, n) ; 
    var queries : Sequence(Sequence(int)) ; queries := Sequence{Sequence{1,3},Sequence{4,5}} ;
    var q : int ; q := queries->size() ;
        var i : int ; i := 0 ; while i < q do (     OclFile["System.out"].println(rangeAnd(queries[i+1][0+1], queries[i+1][1+1])) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int m=sc.nextInt();
      int v=sc.nextInt();
      long res=0 ;
      int[] arr=new int[m];
      for(int i1=0 ; i1<m ; i1++){
        arr[i1]=sc.nextInt();
        res+=arr[i1];
      }
      int p=v ;
      boolean flag=true ;
      while(flag){
        for(int i1=0 ; i1<m ; i1++){
          if(arr[i1] % v==0){
            int a=arr[i1]/v ;
            res+=((long)a*p);
            arr[i1]=a ;
          }
          else {
            flag=false ;
            break ;
          }
        }
        p*=v ;
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var m : int ; m := sc.getCurrent()->toInteger() ;
     var v : int ; v := sc.getCurrent()->toInteger() ;
    var res : long ; res := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,m)->collect(0) ;
        var i1 : int ; i1 := 0 ; while i1 < m do ( (     arr[i1+1] := sc.getCurrent()->toInteger() ; 
     res := res+(arr[i1+1]) )  ;     i1 := i1 + 1 ) ; 
    var p : int ; p := v ;
    var flag : boolean ; flag := true ;
    while (flag) do (         var i1 : int ; i1 := 0 ; while i1 < m do ( (     if (arr[i1+1] mod v = 0) then (     var a : int ; a := arr[i1+1] / v ;
     res := res+((a->oclAsType(long) * p)) ; 
     arr[i1+1] := a ) else (     flag := false ; 
     break ) )  ;     i1 := i1 + 1 ) ; 
     p := p*(v) ) ; 
    OclFile["System.out"].println(res) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  private void solve(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    List<Task>tasks=new ArrayList<Task>();
    for(int i=0 ; i<N ; i++){
      int A=sc.nextInt();
      int B=sc.nextInt();
      tasks.add(new Task(A,B));
    }
    tasks.sort((a,b)->a.deadLine-b.deadLine);
    long timeSum=0 ;
    String ans="Yes" ;
    for(Task task : tasks){
      timeSum+=task.timeToTake ;
      if(timeSum>task.deadLine){
        ans="No" ;
        break ;
      }
    }
    System.out.print(ans);
  }
  class Task {
    int timeToTake ;
    int deadLine ;
    Task(int timeToTake,int deadLine){
      this.timeToTake=timeToTake ;
      this.deadLine=deadLine ;
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var tasks : Sequence(Task) ; tasks := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
     tasks := tasks->including(Task.newTask(A, B)) )  ;     i := i + 1 ) ; 
    tasks := tasks.sort(lambda (a , b) : OclAny in a.deadLine - b.deadLine) ; 
    var timeSum : long ; timeSum := 0 ;
    var ans : String ; ans := "Yes" ;
    for (task : tasks) do ( (     timeSum := timeSum+(task.timeToTake) ; 
     if (timeSum > task.deadLine) then (     ans := "No" ; 
     break ) else skip )  ) ; 
    OclFile["System.out"].print(ans) ; 
 );
 class Task {
   attribute timeToTake : int;
   attribute deadLine : int;
   static operation newTask( timeToTake : int, deadLine : int) : Task
  pre: true
  post: true
  activity:
  ( var self : Task ;
    self := createTask();
    self.initialise(timeToTake, deadLine);
    return self );
  operation initialise( timeToTake : int, deadLine : int) : void
  pre: true  post: true
  activity: (     self.timeToTake := timeToTake ; 
     self.deadLine := deadLine );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Objects ;
import java.util.Scanner ;
import java.util.Comparator ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    DMegalomania solver=new DMegalomania();
    solver.solve(1,in,out);
    out.close();
  }
  static class DMegalomania {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      ArrayList<Pair<Integer,Integer>>alp=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        alp.add(new Pair<>(in.nextInt(),in.nextInt()));
      }
      alp.sort(Comparator.comparing(p->p.u));
      int time=0 ;
      for(Pair<Integer,Integer>p : alp){
        if(time+p.t>p.u){
          out.println("No");
          return ;
        }
        time+=p.t ;
      }
      out.println("Yes");
    }
  }
  static class Pair<T,U>{
    public T t ;
    public U u ;
    public Pair(T t,U u){
      this.t=t ;
      this.u=u ;
    }
    public String toString(){
      return "Pair{"+"t="+t.toString()+",u="+u.toString()+'}' ;
    }
    public boolean equals(Object o){
      if(this==o)return true ;
      if(o==null || getClass()!=o.getClass())return false ;
      Pair<?,?>pair=(Pair<?,?>)o ;
      return Objects.equals(t,pair.t)&& Objects.equals(u,pair.u);
    }
    public int hashCode(){
      return Objects.hash(t,u);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : DMegalomania ; solver := DMegalomania.newDMegalomania() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class DMegalomania {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var alp : Sequence(Map(String,OclAny)) ; alp := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     alp := alp->including(Tuple(in.getCurrent()->toInteger(), in.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    alp := alp.sort(Comparator.comparing(lambda p : OclAny in p.u)) ; 
    var time : int ; time := 0 ;
    for (p : alp) do ( (     if (time + p.t > p.u) then (     skip ; 
     return ) else skip ; 
     time := time+(p.t) )  ) ; 
    skip ; 
 );
}
  static class Pair<T,U> {
   attribute t : T;
   attribute u : U;
   static operation newPair( t : T, u : U) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(t, u);
    return self );
  operation initialise( t : T, u : U) : void
  pre: true  post: true
  activity: (     self.t := t ; 
     self.u := u );
   operation toString() : String
  pre: true
  post: true
  activity: (     return "Pair{" + "t=" + t+"" + ",u=" + u+"" + '}' );
   operation equals( o : OclAny) : boolean
  pre: true
  post: true
  activity: (     if (self = o) then     return true else skip ; 
     if (o = null or getClass() /= o->oclType()) then     return false else skip ; 
     var pair : Map(String,OclAny) ; pair := o->oclAsType(Map(String,OclAny)) ;
     return Objects = t, pair.t & Objects = u, pair.u );
   operation hashCode() : int
  pre: true
  post: true
  activity: (     return Objects.hash(t, u) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    int n=sc.nextInt();
    PriorityQueue<Task>queue=new PriorityQueue<>(new Comparator<Task>(){
      @ Override public int compare(Task o1,Task o2){
        return Integer.compare(o1.b,o2.b);
      }
    }
);
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      queue.add(new Task(a,b));
    }
    boolean isFinish=true ;
    int time=0 ;
    while(! queue.isEmpty()){
      Task task=queue.poll();
      time+=task.a ;
      if(time>task.b){
        isFinish=false ;
        break ;
      }
    }
    System.out.println(isFinish ? "Yes" : "No");
  }
  static class Task {
    int a,b ;
    Task(int a,int b){
      this.a=a ;
      this.b=b ;
    }
  }
  static class MyScanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),1<<15);
    StringTokenizer tokenizer ;
    String next(){
      try {
        while(tokenizer==null || ! tokenizer.hasMoreTokens()){
          tokenizer=new StringTokenizer(reader.readLine());
        }
      }
      catch(IOException ignored){
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var n : int ; n := sc.nextInt() ;
    var queue : Sequence(Task) ; queue := Sequence{}->union(OclComparator<Task>.newOclComparator()) ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.nextInt() ;
     var b : int ; b := sc.nextInt() ;
     queue := queue->including(Task.newTask(a, b)) )  ;     i := i + 1 ) ; 
    var isFinish : boolean ; isFinish := true ;
    var time : int ; time := 0 ;
    while (not(queue->isEmpty())) do (     var task : Task ; task := queue->min() ;
     time := time+(task.a) ; 
     if (time > task.b) then (     isFinish := false ; 
     break ) else skip ) ; 
    OclFile["System.out"].println(if isFinish then "Yes" else "No" endif) ; 
 );
  static class Task {
   attribute a : int;
   static operation newTask( a : int, b : int) : Task
  pre: true
  post: true
  activity:
  ( var self : Task ;
    self := createTask();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
}
  static class MyScanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (1*(2->pow(15)))->oclAsType(long));
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (ignored : IOException) do skip
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Map ;
import java.util.TreeMap ;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    Map<Integer,Long>map=new TreeMap<>();
    for(int i=0 ; i<n ; i++){
      String str[]=br.readLine().split(" ");
      int a=Integer.parseInt(str[0]);
      int b=Integer.parseInt(str[1]);
      if(map.containsKey(b))map.put(b,map.get(b)+a);
      else map.put(b,(long)a);
    }
    Object key[]=map.keySet().toArray();
    int count=0 ;
    long left=0 ;
    for(long i : map.values()){
      if((int)key[count]<i){
        System.out.println("No");
        return ;
      }
      long dist=(int)key[count]-left ;
      if(map.get((int)key[count])>dist){
        System.out.println("No");
        return ;
      }
      left+=map.get((int)key[count]);
      count++;
    }
    System.out.println("Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var map : Map(int,long) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     var a : int ; a := (str[0+1])->toInteger() ;
     var b : int ; b := (str[1+1])->toInteger() ;
     if (map->keys()->includes(b)) then     map := map->union(Map{b |-> map->at(b) + a}) ; else     map := map->union(Map{b |-> (a)->char2byte()}) ; )  ;     i := i + 1 ) ; 
    var key : Sequence(OclAny) ; key := map->keys()->asSequence() ;
    var count : int ; count := 0 ;
    var left : long ; left := 0 ;
    for (i : map->values()) do ( (     if (key[count+1]->oclAsType(int) < i) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
     var dist : long ; dist := key[count+1]->oclAsType(int) - left ;
    if (map->at(key[count+1]->oclAsType(int)) > dist) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
    left := left+(map->at(key[count+1]->oclAsType(int))) ; 
    count := count + 1 ; 
 )  ) ; 
    OclFile["System.out"].println("Yes") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    solve(System.in,System.out);
  }
  private static class Task {
    long weight ;
    long deadline ;
  }
  static void solve(InputStream is,PrintStream os){
    Scanner sc=new Scanner(is);
    long n=sc.nextLong();
    List<Task>tasks=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      Task task=new Task();
      task.weight=sc.nextLong();
      task.deadline=sc.nextLong();
      tasks.add(task);
    }
    tasks.sort(Comparator.comparingLong(t->t.deadline));
    long current=0 ;
    for(int i=0 ; i<n ; i++){
      Task task=tasks.get(i);
      current+=task.weight ;
      if(task.deadline<current){
        os.println("No");
        return ;
      }
    }
    os.println("Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve(OclFile["System.in"], OclFile["System.out"]) );
  static class Task {
   attribute weight : long;
   attribute deadline : long;
}
  static   operation solve( is : OclFile, os : OclFile) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(is) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var tasks : Sequence(Task) ; tasks := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var task : Task ; task := Task.newTask() ;
     task.weight := sc.getCurrent()->toLong() ; 
     task.deadline := sc.getCurrent()->toLong() ; 
     tasks := tasks->including(task) )  ;     i := i + 1 ) ; 
    tasks := tasks.sort(Comparator.comparingLong(lambda t : OclAny in t.deadline)) ; 
    var current : long ; current := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var task : Task ; task := tasks->at(i+1) ;
     current := current+(task.weight) ; 
     if (task.deadline < current) then (     os.println("No") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    os.println("Yes") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printArr(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  static void randomList(int m,int n){
    int arr[]=new int[m];
    for(int i=0 ; i<n ; i++){
      arr[(int)(Math.random()*m)]++;
    }
    printArr(arr,m);
  }
  public static void main(String args[]){
    int m=4,n=8 ;
    randomList(m,n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation randomList( m : int, n : int) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,m)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[(MathLib.random() * m)->oclAsType(int)+1] := arr[(MathLib.random() * m)->oclAsType(int)+1] + 1 )  ;     i := i + 1 ) ; 
     execute printArr(arr, m) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 4 ;
    var n : int ; n := 8 ;
     execute randomList(m, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class cf456B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    BigInteger b ;
    BigInteger x=new BigInteger("4");
    BigInteger y=new BigInteger("0");
    b=scan.nextBigInteger();
    if(b.mod(x).equals(y)){
      System.out.println("4");
    }
    else {
      System.out.println("0");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf456B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var b : long ;
    var x : long ; x := long("4") ;
    var y : long ; y := long("0") ;
    b := scan.nextBigInteger() ; 
    if (b.mod(x) = y) then (     OclFile["System.out"].println("4") ) else (     OclFile["System.out"].println("0") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CodeForces578B {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int k=input.nextInt();
    int x=input.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=input.nextInt();
    }
    long pref[]=new long[n];
    long suff[]=new long[n];
    pref[0]=a[0];
    for(int i=1 ; i<n ; ++i)pref[i]=pref[i-1] | a[i];
    suff[n-1]=a[n-1];
    for(int i=n-2 ; i>=0 ; --i)suff[i]=suff[i+1] | a[i];
    int powerX=1 ;
    for(int i=0 ; i<k ; ++i)powerX*=x ;
    long ans=0 ;
    for(int i=0 ; i<n ; ++i){
      long cur=(long)a[i]*powerX ;
      if(i>0)cur |=pref[i-1];
      if(i<n-1)cur |=suff[i+1];
      ans=Math.max(ans,cur);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces578B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var k : int ; k := input.getCurrent()->toInteger() ;
    var x : int ; x := input.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var pref : Sequence(long) ; pref := Integer.subrange(1,n)->collect(0) ;
    var suff : Sequence(long) ; suff := Integer.subrange(1,n)->collect(0) ;
    pref[0+1] := a[0+1] ; 
        var i : int ; i := 1 ; while i < n do (     pref[i+1] := pref[i - 1+1] or a[i+1] ;  ;     i := i + 1 ) ; 
    suff[n - 1+1] := a[n - 1+1] ; 
        var i : int ; i := n - 2 ; while i >= 0 do (     suff[i+1] := suff[i + 1+1] or a[i+1] ;  ;     i := i - 1 ) ; 
    var powerX : int ; powerX := 1 ;
        var i : int ; i := 0 ; while i < k do (     powerX := powerX*(x) ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var cur : long ; cur := a[i+1]->oclAsType(long) * powerX ;
     if (i > 0) then     cur := MathLib.bitwiseOr(cur, pref[i - 1+1]) ; else skip ; 
     if (i < n - 1) then     cur := MathLib.bitwiseOr(cur, suff[i + 1+1]) ; else skip ; 
     ans := Set{ans, cur}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.SortedMap ;
import java.util.SortedSet ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    int count=0 ;
    TreeMap<Integer,Integer>map=new TreeMap<>();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<q ; i++){
      int op=sc.nextInt();
      int y=sc.nextInt();
      switch(op){
        case 0 : if(! map.keySet().contains(y)){
          map.put(y,1);
        }
        else {
          map.put(y,map.get(y)+1);
        }
        sb.append(++count);
        sb.append('\n');
        break ;
        case 1 : if(map.keySet().contains(y)){
          sb.append(map.get(y));
        }
        else {
          sb.append('0');
        }
        sb.append('\n');
        break ;
        case 2 : if(map.keySet().contains(y)){
          int num2=map.get(y);
          map.remove(y);
          count-=num2 ;
        }
        break ;
        case 3 : int z=sc.nextInt()+1 ;
        Set<Integer>subset=map.subMap(y,z).keySet();
        for(int num : subset){
          int end=map.get(num);
          for(int j=0 ; j<end ; j++){
            sb.append(num);
            sb.append('\n');
          }
        }
        break ;
      }
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var map : Map(int,int) ; map := Map{} ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < q do ( (     var op : int ; op := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (op) ; 
       if _switchval = 0 then
     if (not(map->keys()->includes(y))) then (     map := map->union(Map{y |-> 1}) ) else (     map := map->union(Map{y |-> map->at(y) + 1}) ) ;  
    sb := sb + StringLib.newString((count + 1)) ; 
    sb := sb + StringLib.newString('
') ; 
    break 
   else skip ;
       if _switchval = 1 then
     if (map->keys()->includes(y)) then (     sb := sb + StringLib.newString(map->at(y)) ) else (     sb := sb + StringLib.newString('0') ) ;  
    sb := sb + StringLib.newString('
') ; 
    break 
   else skip ;
       if _switchval = 2 then
     if (map->keys()->includes(y)) then (     var num2 : int ; num2 := map->at(y) ;
     map := map->antirestrict(Set{y}) ; 
     count := count-(num2) ) else skip ; 
    break 
   else skip ;
       if _switchval = 3 then
     var z : int ; z := sc.getCurrent()->toInteger() + 1 ;
    var subset : Set(int) ; subset := map->restrict( _key | _key < z & _key >= y ).keySet() ;
    for (num : subset) do ( (     var end : int ; end := map->at(num) ;
         var j : int ; j := 0 ; while j < end do ( (     sb := sb + StringLib.newString(num) ; 
     sb := sb + StringLib.newString('
') )  ;     j := j + 1 ) )  ) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class p013 {
  public static void main(String args[])throws Exception {
    StringTokenizer stok=new StringTokenizer(new Scanner(System.in).useDelimiter("\\A").next());
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(stok.nextToken());
    int k=Integer.parseInt(stok.nextToken());
    long x=Long.parseLong(stok.nextToken());
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Long.parseLong(stok.nextToken());
    }
    long[] xp=new long[k+1];
    xp[0]=1 ;
    for(int i=1 ; i<=k ; i++)xp[i]=x*xp[i-1];
    long[] pf=new long[n+2],sf=new long[n+2];
    for(int i=1 ; i<=n ; i++)pf[i]=a[i-1] | pf[i-1];
    for(int i=n ; i>=1 ; i--)sf[i]=a[i-1] | sf[i+1];
    long max=Integer.MIN_VALUE ;
    for(int i=1 ; i<=n ; i++)max=Math.max(max,pf[i-1] | sf[i+1] |(a[i-1]*xp[k]));
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p013 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stok : OclIterator ; stok := OclIterator.newOclIterator_String(OclFile.newOclFile_Read(OclFile["System.in"]).useDelimiter("\\A").next()) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (stok.next())->toInteger() ;
    var k : int ; k := (stok.next())->toInteger() ;
    var x : long ; x := (stok.next())->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (stok.next())->toLong() )  ;     i := i + 1 ) ; 
    var xp : Sequence(long) ; xp := Integer.subrange(1,k + 1)->collect(0) ;
    xp[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= k do (     xp[i+1] := x * xp[i - 1+1] ;  ;     i := i + 1 ) ; 
    var pf : Sequence(long) ; pf := Integer.subrange(1,n + 2)->collect(0) ;
    var sf : Sequence(long) ; sf := Integer.subrange(1,n + 2)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     pf[i+1] := a[i - 1+1] or pf[i - 1+1] ;  ;     i := i + 1 ) ; 
        var i : int ; i := n ; while i >= 1 do (     sf[i+1] := a[i - 1+1] or sf[i + 1+1] ;  ;     i := i - 1 ) ; 
    var max : long ; max := -2147483648 ;
        var i : int ; i := 1 ; while i <= n do (     max := Set{max, pf[i - 1+1] or sf[i + 1+1] or (a[i - 1+1] * xp[k+1])}->max() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    char[][] m=new char[h][];
    for(int i=0 ; i<h ; i++){
      m[i]=sc.next().toCharArray();
    }
    int ans=0 ;
    for(int i=1 ; i<h ; i++){
      LOOP : for(int j=0 ;
      j<w ;
      j++){
        if(m[i][j]!='-')continue ;
        if(j>0 && m[i][j-1]!='-')continue ;
        if(j<w-1 && m[i][j+1]!='-')continue ;
        for(int i1=-1 ; i1<=1 ; i1++){
          for(int j1=-1 ; j1<=1 ; j1++){
            int i2=i+i1 ;
            int j2=j+j1 ;
            if(i2<0 || i2>=h || j2<0 || j2>=w)continue ;
            if(m[i2][j2]=='x')continue LOOP ;
          }
        }
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var m : Sequence(Sequence(String)) ; m := Integer.subrange(1,h)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < h do ( (     m[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (m[i+1][j+1] /= '-') then     continue else skip ; 
     if (j > 0 & m[i+1][j - 1+1] /= '-') then     continue else skip ; 
    if (j < w - 1 & m[i+1][j + 1+1] /= '-') then     continue else skip ; 
        var i1 : int ; i1 := -1 ; while i1 <= 1 do ( (         var j1 : int ; j1 := -1 ; while j1 <= 1 do ( (     var i2 : int ; i2 := i + i1 ;
     var j2 : int ; j2 := j + j1 ;
     if (i2 < 0 or i2 >= h or j2 < 0 or j2 >= w) then     continue else skip ; 
     if (m[i2+1][j2+1] = 'x') then     continue else skip )  ;     j1 := j1 + 1 ) )  ;     i1 := i1 + 1 ) ; 
    ans := ans + 1 ; 
 )  ;     j := j + 1 ) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  final int[] a={
    0,0,1,1,1,-1,-1,-1 };
    final int[] b={
      1,-1,1,0,-1,1,0,-1 };
      void run(){
        try(Scanner sc=new Scanner(System.in)){
          int m=Integer.parseInt(sc.next());
          int n=Integer.parseInt(sc.next());
          char[][] map=new char[m][];
          for(int i=0 ; i<m ; i++){
            map[i]=sc.next().toCharArray();
          }
          int cnt=0 ;
          for(int i=1 ; i<m ; i++){
            for(int j=0 ; j<n ; j++){
              if(map[i][j]=='-'){
                boolean f=false ;
                for(int k=0 ; k<8 ; k++){
                  int ny=i+a[k];
                  int nx=j+b[k];
                  if(ny>=0 && ny<m && nx>=0 && nx<n){
                    if(k<2 && map[ny][nx]!='-' || map[ny][nx]=='x'){
                      f=true ;
                      break ;
                    }
                  }
                }
                if(! f){
                  cnt++;
                }
              }
            }
          }
          System.out.println(cnt);
        }
      }
      public static void main(String[] args){
        new Main().run();
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute a : Sequence(int) := Sequence{0,0,1,1,1,-1,-1,-1};
   attribute b : Sequence(int) := Sequence{1,-1,1,0,-1,1,0,-1};
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var m : int ; m := (sc.getCurrent())->toInteger() ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var map : Sequence(Sequence(String)) ; map := Integer.subrange(1,m)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < m do ( (     map[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 1 ; while i < m do ( (         var j : int ; j := 0 ; while j < n do ( (     if (map[i+1][j+1] = '-') then (     var f : boolean ; f := false ;
         var k : int ; k := 0 ; while k < 8 do ( (     var ny : int ; ny := i + a[k+1] ;
     var nx : int ; nx := j + b[k+1] ;
     if (ny >= 0 & ny < m & nx >= 0 & nx < n) then (     if (k < 2 & map[ny+1][nx+1] /= '-' or map[ny+1][nx+1] = 'x') then (     f := true ; 
     break ) else skip ) else skip )  ;     k := k + 1 ) ; 
     if (not(f)) then (     cnt := cnt + 1 ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 ))  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String line ;
    int M,N ;
    M=sc.nextInt();
    N=sc.nextInt();
    boolean[][] seats=new boolean[M+2][N+2];
    for(int i=0 ; i<M+2 ; i++){
      Arrays.fill(seats[i],true);
    }
    Arrays.fill(seats[1],false);
    for(int i=1 ; i<=M ; i++){
      String s=sc.next();
      for(int j=1 ; j<=N ; j++){
        char c=s.charAt(j-1);
        if(c=='o'){
          for(int k=-1 ; k<=1 ; k++){
            seats[i][j+k]=false ;
          }
        }
        else if(c=='x'){
          for(int k=-1 ; k<=1 ; k++){
            for(int l=-1 ; l<=1 ; l++){
              seats[i+k][j+l]=false ;
            }
          }
        }
      }
    }
    int ans=0 ;
    for(int i=1 ; i<=M ; i++){
      for(int j=1 ; j<=N ; j++){
        if(seats[i][j])ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : String ;
    var M : int ;
    var N : int ;
    M := sc.getCurrent()->toInteger() ; 
    N := sc.getCurrent()->toInteger() ; 
    var seats : Sequence(Sequence(boolean)) ; seats := Integer.subrange(1,M + 2)->collect(Integer.subrange(1,N + 2)->collect(false)) ;
        var i : int ; i := 0 ; while i < M + 2 do ( (     seats[i+1] := seats[i+1]->collect(true) )  ;     i := i + 1 ) ; 
    seats[1+1] := seats[1+1]->collect(false) ; 
        var i : int ; i := 1 ; while i <= M do ( (     var s : String ; s := sc.getCurrent() ;
         var j : int ; j := 1 ; while j <= N do ( (     var c : String ; c := s->at((j)->char2byte() - 1+1) ;
     if (c = 'o') then (         var k : int ; k := -1 ; while k <= 1 do ( (     seats[i+1][j + k+1] := false )  ;     k := k + 1 ) ) else     if (c = 'x') then (         var k : int ; k := -1 ; while k <= 1 do ( (         var l : int ; l := -1 ; while l <= 1 do ( (     seats[i + k+1][j + l+1] := false )  ;     l := l + 1 ) )  ;     k := k + 1 ) ) else skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= M do ( (         var j : int ; j := 1 ; while j <= N do ( (     if (seats[i+1][j+1]) then     ans := ans + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    char[][] field=new char[h][];
    for(int i=0 ; i<h ; i++){
      field[i]=sc.next().toCharArray();
    }
    boolean[][] ans=new boolean[h+2][w+2];
    for(int i=2 ; i<=h ; i++){
      Arrays.fill(ans[i],true);
      ans[i][0]=false ;
      ans[i][w+1]=false ;
    }
    for(int i=1 ; i<=h ; i++){
      for(int j=1 ; j<=w ; j++){
        if(field[i-1][j-1]=='o'){
          ans[i][j-1]=false ;
          ans[i][j]=false ;
          ans[i][j+1]=false ;
        }
        else if(field[i-1][j-1]=='x'){
          for(int k=i-1 ; k<=i+1 ; k++){
            for(int l=j-1 ; l<=j+1 ; l++){
              ans[k][l]=false ;
            }
          }
        }
      }
    }
    int count=0 ;
    for(int i=1 ; i<=h ; i++){
      for(int j=1 ; j<=w ; j++){
        if(ans[i][j]){
          count++;
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var field : Sequence(Sequence(String)) ; field := Integer.subrange(1,h)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < h do ( (     field[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    var ans : Sequence(Sequence(boolean)) ; ans := Integer.subrange(1,h + 2)->collect(Integer.subrange(1,w + 2)->collect(false)) ;
        var i : int ; i := 2 ; while i <= h do ( (     ans[i+1] := ans[i+1]->collect(true) ; 
     ans[i+1][0+1] := false ; 
     ans[i+1][w + 1+1] := false )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= h do ( (         var j : int ; j := 1 ; while j <= w do ( (     if (field[i - 1+1][j - 1+1] = 'o') then (     ans[i+1][j - 1+1] := false ; 
     ans[i+1][j+1] := false ; 
     ans[i+1][j + 1+1] := false ) else     if (field[i - 1+1][j - 1+1] = 'x') then (         var k : int ; k := i - 1 ; while k <= i + 1 do ( (         var l : int ; l := j - 1 ; while l <= j + 1 do ( (     ans[k+1][l+1] := false )  ;     l := l + 1 ) )  ;     k := k + 1 ) ) else skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= h do ( (         var j : int ; j := 1 ; while j <= w do ( (     if (ans[i+1][j+1]) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int isPowerOf2(String s){
    char[] str=s.toCharArray();
    int len_str=s.length();
    int num=0 ;
    if(len_str==1 && str[len_str-1]=='1')return 0 ;
    while(len_str!=1 || str[len_str-1]!='1'){
      if((str[len_str-1]-'0')% 2==1)return 0 ;
      int j=0 ;
      for(int i=0 ; i<len_str ; i++){
        num=num*10+(int)str[i]-(int)'0' ;
        if(num<2){
          if(i!=0)str[j++]='0' ;
          continue ;
        }
        str[j++]=(char)((int)(num/2)+(int)'0');
        num=(num)-(num/2)*2 ;
      }
      str[j]='\0' ;
      len_str=j ;
    }
    return 1 ;
  }
  public static void main(String[] args){
    String str1="124684622466842024680246842024662202000002" ;
    String str2="1" ;
    String str3="128" ;
    System.out.println(isPowerOf2(str1)+"\n"+isPowerOf2(str2)+"\n"+isPowerOf2(str3));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPowerOf2( s : String) : int
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := s->characters() ;
     var len_str : int ; len_str := s->size() ;
    var num : int ; num := 0 ;
    if (len_str = 1 & str[len_str - 1+1] = '1') then     return 0 else skip ; 
    while (len_str /= 1 or str[len_str - 1+1] /= '1') do (     if ((str[len_str - 1+1] - ('0')->char2byte()) mod 2 = 1) then     return 0 else skip ; 
     var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < len_str do ( (     num := num * 10 + str[i+1]->oclAsType(int) - ('0')->char2byte() ; 
     if (num < 2) then (     if (i /= 0) then      str[j+1] := '0'  ; j := j + 1 ; else skip ; 
     continue ) else skip ; 
      str[j+1] := ((num / 2)->oclAsType(int) + ('0')->char2byte())->oclAsType(String)  ; j := j + 1 ; 
     num := (num) - (num / 2) * 2 )  ;     i := i + 1 ) ; 
    str[j+1] := '\0' ; 
    len_str := j ; 
 ) ; 
    return 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "124684622466842024680246842024662202000002" ;
     var str2 : String ; str2 := "1" ;
     var str3 : String ; str3 := "128" ;
     OclFile["System.out"].println(isPowerOf2(str1) + "\n" + isPowerOf2(str2) + "\n" + isPowerOf2(str3)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class FindAnagrams {
  private static void printAnagrams(String arr[]){
    HashMap<String,List<String>>map=new HashMap<>();
    for(int i=0 ; i<arr.length ; i++){
      String word=arr[i];
      char[] letters=word.toCharArray();
      Arrays.sort(letters);
      String newWord=new String(letters);
      if(map.containsKey(newWord)){
        map.get(newWord).add(word);
      }
      else {
        List<String>words=new ArrayList<>();
        words.add(word);
        map.put(newWord,words);
      }
    }
    for(String s : map.keySet()){
      List<String>values=map.get(s);
      if(values.size()>1){
        System.out.print(values);
      }
    }
  }
  public static void main(String[] args){
    String arr[]={
      "cat","dog","tac","god","act" };
      printAnagrams(arr);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class FindAnagrams {
  static   operation printAnagrams( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var map : Map(String,Sequence(String)) ; map := Map{} ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     var word : String ; word := arr[i+1] ;
     var letters : Sequence(String) ; letters := word->characters() ;
    letters := letters->sort() ; 
    var newWord : String ; newWord := StringLib.newString(letters) ;
    if (map->keys()->includes(newWord)) then (     map->at(newWord)->excludes(word) ) else (     var words : Sequence(String) ; words := Sequence{} ;
     words := words->including(word) ; 
     map := map->union(Map{newWord |-> words}) ) ;  
 )  ;     i := i + 1 ) ; 
     for (s : map->keys()) do ( (     var values : Sequence(String) ; values := map->at(s) ;
     if (values->size() > 1) then (     OclFile["System.out"].print(values) ) else skip )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"cat","dog","tac","god","act"} ;
     execute printAnagrams(arr) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Div2_213A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),k=in.nextInt();
    ArrayList<char[]>ls=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      char[] s=in.next().toCharArray();
      ls.add(s);
    }
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      int[] kk=new int[k+10];
      boolean ok=true ;
      char[] ss=ls.get(i);
      for(int j=0 ; j<ss.length ; j++){
        int v=ss[j]-'0' ;
        try {
          kk[v]++;
        }
        catch(Exception e){
          ok=false ;
          break ;
        }
      }
      for(int l=0 ; l<=k ; l++)if(kk[l]==0){
        ok=false ;
        break ;
      }
      if(ok)ans++;
    }
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Div2{
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var ls : Sequence(Sequence(String)) ; ls := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var s : Sequence(String) ; s := in.getCurrent()->characters() ;
     ls := ls->including(s) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var kk : Sequence(int) ; kk := Integer.subrange(1,k + 10)->collect(0) ;
     var ok : boolean ; ok := true ;
    var ss : Sequence(String) ; ss := ls->at(i+1) ;
        var j : int ; j := 0 ; while j < ss->size() do ( (     var v : int ; v := ss[j+1] - ('0')->char2byte() ;
     try (     kk[v+1] := kk[v+1] + 1 )   catch (e : ProgramException) do (     ok := false ; 
     break )
 )  ;     j := j + 1 ) ; 
        var l : int ; l := 0 ; while l <= k do (     if (kk[l+1] = 0) then (     ok := false ; 
     break ) else skip ;  ;     l := l + 1 ) ; 
    if (ok) then     ans := ans + 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}
13A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var ls : Sequence(Sequence(String)) ; ls := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var s : Sequence(String) ; s := in.getCurrent()->characters() ;
     ls := ls->including(s) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var kk : Sequence(int) ; kk := Integer.subrange(1,k + 10)->collect(0) ;
     var ok : boolean ; ok := true ;
    var ss : Sequence(String) ; ss := ls->at(i+1) ;
        var j : int ; j := 0 ; while j < ss->size() do ( (     var v : int ; v := ss[j+1] - ('0')->char2byte() ;
     try (     kk[v+1] := kk[v+1] + 1 )   catch (e : ProgramException) do (     ok := false ; 
     break )
 )  ;     j := j + 1 ) ; 
        var l : int ; l := 0 ; while l <= k do (     if (kk[l+1] = 0) then (     ok := false ; 
     break ) else skip ;  ;     l := l + 1 ) ; 
    if (ok) then     ans := ans + 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import static java.lang.System.*;
import static java.lang.Math.*;
public class pre5 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int k=obj.nextInt();
    char str[]=obj.next().toCharArray();
    int n=str.length ;
    Arrays.sort(str);
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=(str[i]-'0');
    int idx=0,ans=0 ;
    while(idx<n && sum<k){
      sum-=str[idx]-'0' ;
      str[idx]='9' ;
      sum+=9 ;
      idx++;
      ans++;
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre5 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var k : int ; k := obj.nextInt() ;
    var str : Sequence(String) ; str := obj.next()->characters() ;
    var n : int ; n := str->size() ;
    str := str->sort() ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (     sum := sum+((str[i+1] - ('0')->char2byte())) ;  ;     i := i + 1 ) ; 
    var idx : int ; idx := 0 ;
    var ans : int ; ans := 0 ;
    while (idx < n & sum < k) do (     sum := sum-(str[idx+1] - ('0')->char2byte()) ; 
     str[idx+1] := '9' ; 
    sum := sum+(9) ; 
    idx := idx + 1 ; 
    ans := ans + 1 ; 
 ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Div2_213A {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int answer=0 ;
    int N=input.nextInt();
    int K=input.nextInt();
    main : for(int n=0 ;
    n<N ;
    n++){
      String s=input.next();
      for(int k=0 ; k<=K ; k++){
        if(s.indexOf(""+k)==-1){
          continue main ;
        }
      }
      answer++;
    }
    pw.println(answer);
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Div2{
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var answer : int ; answer := 0 ;
    var N : int ; N := input.getCurrent()->toInteger() ;
    var K : int ; K := input.getCurrent()->toInteger() ;
        var n : int ; n := 0 ; while n < N do ( (     var s : String ; s := input.getCurrent() ;
         var k : int ; k := 0 ; while k <= K do ( (     if (s->indexOf("" + k)-1 = -1) then (     continue ) else skip )  ;     k := k + 1 ) ; 
     answer := answer + 1 )  ;     n := n + 1 ) ; 
    skip ; 
    skip ; 
 );
}
13A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var answer : int ; answer := 0 ;
    var N : int ; N := input.getCurrent()->toInteger() ;
    var K : int ; K := input.getCurrent()->toInteger() ;
        var n : int ; n := 0 ; while n < N do ( (     var s : String ; s := input.getCurrent() ;
         var k : int ; k := 0 ; while k <= K do ( (     if (s->indexOf("" + k)-1 = -1) then (     continue ) else skip )  ;     k := k + 1 ) ; 
     answer := answer + 1 )  ;     n := n + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Set ;
import java.util.HashSet ;
public class CF365_D2_A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    Set<Integer>set=new HashSet<>();
    int t=scanner.nextInt();
    int num=scanner.nextInt();
    scanner.nextLine();
    int cnt=0 ;
    while(t--!=0){
      set.clear();
      String line=scanner.next();
      for(int i=0 ; i<line.length(); i++){
        set.add(Integer.parseInt(line.charAt(i)+""));
      }
      boolean add=true ;
      for(int i=0 ; i<=num ; i++){
        if(! set.contains(i)){
          add=false ;
          break ;
        }
      }
      if(add)cnt++;
    }
    System.out.println(cnt);
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF365_D2_A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var set : Set(int) ; set := Set{} ;
    var t : int ; t := scanner.getCurrent()->toInteger() ;
    var num : int ; num := scanner.getCurrent()->toInteger() ;
    skip ; 
    var cnt : int ; cnt := 0 ;
        while (t /= 0) do (    skip ; (     set := set->intersection(Set{}) ; 
     var line : String ; line := scanner.getCurrent() ;
        var i : int ; i := 0 ; while i < line->size() do ( (     set := set->including((line->at(i+1) + "")->toInteger()) )  ;     i := i + 1 ) ; 
    var add : boolean ; add := true ;
        var i : int ; i := 0 ; while i <= num do ( (     if (not(set->includes(i))) then (     add := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (add) then     cnt := cnt + 1 ; else skip ; 
 ) ;  ) ;  
    OclFile["System.out"].println(cnt) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    int i,j,q,order,x,counter=0 ;
    Map<Integer,Integer>map=new HashMap<Integer,Integer>();
    TreeSet<Integer>set=new TreeSet<Integer>();
    try(Scanner sc=new Scanner(System.in)){
      q=sc.nextInt();
      for(i=0 ; i<q ; i++){
        order=sc.nextInt();
        x=sc.nextInt();
        switch(order){
          case 0 : counter++;
          if(! set.add(x)){
            if(map.containsKey(x)){
              map.compute(x,(key,old)->old+1);
            }
            else {
              map.put(x,1);
            }
          }
          System.out.println(counter);
          break ;
          case 1 : if(set.contains(x)){
            if(map.containsKey(x)){
              System.out.println(map.get(x)+1);
            }
            else {
              System.out.println(1);
            }
          }
          else {
            System.out.println(0);
          }
          break ;
          case 2 : if(set.remove(x)){
            counter--;
            if(map.containsKey(x)){
              counter-=map.remove(x);
            }
          }
          break ;
          case 3 : for(Integer output : set.subSet(x,true,sc.nextInt(),true)){
            System.out.println(output);
            if(map.containsKey(output)){
              for(j=0 ; j<map.get(output); j++){
                System.out.println(output);
              }
            }
          }
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var q : int ;
    var order : int ;
    var x : int ;
    var counter : int ; counter := 0 ;
     var map : Map(int,int) ; map := Map{} ;
     var set : Set(int) ; set := Set{} ;
     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     q := sc.getCurrent()->toInteger() ; 
         i := 0 ; while i < q do ( (     order := sc.getCurrent()->toInteger() ; 
     x := sc.getCurrent()->toInteger() ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (order) ; 
       if _switchval = 0 then
     counter := counter + 1 ; 
    if (not(set->excludes(x))) then (     if (map->keys()->includes(x)) then (     map := map.compute(x, lambda (key , old) : OclAny in old + 1) ) else (     map := map->union(Map{x |-> 1}) ) ) else skip ; 
    OclFile["System.out"].println(counter) ; 
    break 
   else skip ;
       if _switchval = 1 then
     if (set->includes(x)) then (     if (map->keys()->includes(x)) then (     OclFile["System.out"].println(map->at(x) + 1) ) else (     OclFile["System.out"].println(1) ) ) else (     OclFile["System.out"].println(0) ) ;  
    break 
   else skip ;
       if _switchval = 2 then
     if (set->includes(x)) then (     counter := counter - 1 ; 
     if (map->keys()->includes(x)) then (     counter := counter - (map->at(x)) ;     map := map->excludingFirst(x) ) else skip ) else skip ; 
    break 
   else skip ;
       if _switchval = 3 then
     for (output : set->select( _x0 | _x0 >= x & _x0 < true )) do ( (     OclFile["System.out"].println(output) ; 
     if (map->keys()->includes(output)) then (         j := 0 ; while j < map->at(output) do ( (     OclFile["System.out"].println(output) )  ;     j := j + 1 ) ) else skip )  ) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  static FastScanner in=new FastScanner();
  static PrintWriter out=new PrintWriter(System.out);
  public static void s(int t){
    t=2 ;
  }
  public static void main(String[] args){
    int n=in.nextInt(),k=in.nextInt(),count=0 ;
    Set<Integer>set=new HashSet<>();
    while(n--!=0){
      set.clear();
      char[] arr=in.next().toCharArray();
      if(arr.length>=k+1){
        for(char i : arr){
          int temp=Integer.parseInt(i+"");
          if(temp>=0 && temp<=k)set.add(temp);
        }
        count+=set.size()==(k+1)? 1 : 0 ;
      }
    }
    out.println(count);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   attribute in : FastScanner := FastScanner.newFastScanner();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation s( t : int) : void
  pre: true
  post: true
  activity: (     t := 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
    var k : int ; k := in.nextInt() ;
    var count : int ; count := 0 ;
     var set : Set(int) ; set := Set{} ;
        while (n /= 0) do (    skip ; (     set := set->intersection(Set{}) ; 
     var arr : Sequence(String) ; arr := in.next()->characters() ;
     if (arr->size() >= k + 1) then (     for (i : arr) do ( (     var temp : int ; temp := (i + "")->toInteger() ;
     if (temp >= 0 & temp <= k) then     set := set->including(temp) ; else skip )  ) ; 
     count := count+(if set->size() = (k + 1) then 1 else 0 endif) ) else skip ) ;  ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import org.w3c.dom.ranges.Range ;
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt();
    int k=in.nextInt();
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      char[] num=in.next().toCharArray();
      boolean[] range=new boolean[k+1];
      for(int j=0 ; j<num.length ; j++){
        int current=num[j]-'0' ;
        if(current<=k)range[current]=true ;
      }
      boolean flag=true ;
      for(boolean bol : range){
        if(! bol){
          flag=false ;
          break ;
        }
      }
      if(flag)ans++;
    }
    out.println(ans);
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new FileReader("sub.in"));
      }
      catch(FileNotFoundException ex){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException ex){
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException ex){
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.nextInt() ;
    var k : int ; k := in.nextInt() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var num : Sequence(String) ; num := in.next()->characters() ;
     var range : Sequence(boolean) ; range := Integer.subrange(1,k + 1)->collect(false) ;
        var j : int ; j := 0 ; while j < num->size() do ( (     var current : int ; current := num[j+1] - ('0')->char2byte() ;
     if (current <= k) then     range[current+1] := true ; else skip )  ;     j := j + 1 ) ; 
    var flag : boolean ; flag := true ;
    for (bol : range) do ( (     if (not(bol)) then (     flag := false ; 
     break ) else skip )  ) ; 
    if (flag) then     ans := ans + 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("sub.in"))) )   catch (ex : FileNotFoundException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (ex : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (ex : IOException) do skip
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class AserejaAndBottle {
  public static void main(String[] args)throws IOException {
    BufferedReader buf=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(buf.readLine());
    int[] a=new int[n];
    int[] b=new int[n];
    int r=0 ;
    while(n-->0){
      String[] inp=buf.readLine().split(" ");
      a[r]=Integer.parseInt(inp[0]);
      b[r++]=Integer.parseInt(inp[1]);
    }
    int ans=0 ;
    for(int i=0 ; i<a.length ; i++){
      int count=0 ;
      for(int j=0 ; j<b.length ; j++){
        if(a[i]==b[j] && i!=j){
          count=1 ;
          break ;
        }
      }
      if(count==0)ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class AserejaAndBottle {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var buf : OclFile ; buf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (buf.readLine())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var r : int ; r := 0 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var inp : Sequence(String) ; inp := buf.readLine()->split(" ") ;
     a[r+1] := (inp[0+1])->toInteger() ; 
      b[r+1] := (inp[1+1])->toInteger()  ; r := r + 1 ) ;  ) ;  
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < a->size() do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < b->size() do ( (     if (a[i+1] = b[j+1] & i /= j) then (     count := 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (count = 0) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class SerejaAndBottles {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int num=scanner.nextInt();
    List<Integer>a=new ArrayList<>();
    List<Integer>b=new ArrayList<>();
    Map<Integer,Integer>bMap=new HashMap<>();
    for(int i=0 ; i<num ; i++){
      a.add(scanner.nextInt());
      int t=scanner.nextInt();
      b.add(t);
      bMap.put(t,bMap.getOrDefault(t,0)+1);
    }
    int res=0 ;
    for(int i=0 ; i<num ; i++){
      Integer value=bMap.getOrDefault(a.get(i),0);
      if(value>=2){
        continue ;
      }
      else if(value==1){
        if(b.get(i).equals(a.get(i))){
          res++;
        }
      }
      else {
        res++;
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class SerejaAndBottles {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
    var b : Sequence(int) ; b := Sequence{} ;
    var bMap : Map(int,int) ; bMap := Map{} ;
        var i : int ; i := 0 ; while i < num do ( (     a := a->including(scanner.getCurrent()->toInteger()) ; 
     var t : int ; t := scanner.getCurrent()->toInteger() ;
     b := b->including(t) ; 
     bMap := bMap->union(Map{t |-> (if bMap->keys()->contains(t) then bMap->at(t) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < num do ( (     var value : int ; value := (if bMap->keys()->contains(a->at(i+1)) then bMap->at(a->at(i+1)) else 0 endif) ;
     if (value >= 2) then (     continue ) else     if (value = 1) then (     if (b->at(i+1) = a->at(i+1)) then (     res := res + 1 ) else skip ) else (     res := res + 1 ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    int b[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
    }
    int size=n ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(a[i]==b[j] && j!=i){
          size--;
          break ;
        }
      }
    }
    System.out.println(size);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var size : int ; size := n ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (a[i+1] = b[j+1] & j /= i) then (     size := size - 1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(size) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[][] bottles=new int[n][2];
    for(int i=0 ; i<n ; i++){
      bottles[i][0]=sc.nextInt();
      bottles[i][1]=sc.nextInt();
    }
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      boolean openable=false ;
      for(int j=0 ; j<n ; j++){
        if(j==i)continue ;
        if(bottles[j][1]==bottles[i][0]){
          openable=true ;
          break ;
        }
      }
      if(! openable)ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var bottles : Sequence(Sequence(int)) ; bottles := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     bottles[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     bottles[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var openable : boolean ; openable := false ;
         var j : int ; j := 0 ; while j < n do ( (     if (j = i) then     continue else skip ; 
     if (bottles[j+1][1+1] = bottles[i+1][0+1]) then (     openable := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (not(openable)) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  @ SuppressWarnings("resource")public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    String s=String.valueOf(n);
    if(n<100){
      s="0"+s ;
    }
    System.out.println("ABC"+s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var s : String ; s := ((n) + "") ;
    if (n < 100) then (     s := "0" + s ) else skip ; 
    OclFile["System.out"].println("ABC" + s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  static boolean[] dp ;
  static int N=(int)1e4+5 ;
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long k=in.nextLong();
    char[] s=in.next().toCharArray();
    ArrayList<Integer>ls=new ArrayList<>();
    for(int i=0 ; i<s.length ; i++)ls.add(s[i]-'0');
    long total=0 ;
    Collections.sort(ls);
    for(int x : ls)total+=x ;
    if(total>=k){
      pw.println(0);
      pw.close();
      return ;
    }
    int op=0 ;
    for(int i=0 ; i<ls.size(); i++){
      total-=ls.get(i);
      total+=9 ;
      op++;
      if(total>=k){
        break ;
      }
    }
    pw.println(op);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute dp : Sequence(boolean);
  static   attribute N : int := 1e4->oclAsType(int) + 5;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var k : long ; k := in.getCurrent()->toLong() ;
    var s : Sequence(String) ; s := in.getCurrent()->characters() ;
    var ls : Sequence(int) ; ls := Sequence{} ;
        var i : int ; i := 0 ; while i < s->size() do (     ls := ls->including(s[i+1] - ('0')->char2byte()) ;  ;     i := i + 1 ) ; 
    var total : long ; total := 0 ;
    ls := ls->sort() ; 
    for (x : ls) do (     total := total+(x) ;  ) ; 
    if (total >= k) then (     skip ; 
     skip ; 
     return ) else skip ; 
    var op : int ; op := 0 ;
        var i : int ; i := 0 ; while i < ls->size() do ( (     total := total-(ls->at(i+1)) ; 
     total := total+(9) ; 
     op := op + 1 ; 
     if (total >= k) then (     break ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line=br.readLine();
    System.out.println("ABC"+line);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := br.readLine() ;
     OclFile["System.out"].println("ABC" + line) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.*;
import static java.lang.System.*;
public class Main {
  public static void main(String[] args){
    int i,j ;
    Scanner sc=new Scanner(in);
    int n=parseInt(sc.next());
    sc.close();
    out.printf("ABC%03d%n",n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
    var n : int ; n := parseInt(sc.getCurrent()) ;
    skip ; 
    out.printf("ABC%03d%n", n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main m=new Main();
    m.answer();
  }
  private Scanner scan=new Scanner(System.in);
  private final int N ;
  public Main(){
    N=Integer.parseInt(scan.next());
    scan.close();
  }
  public final void answer(){
    System.out.println("ABC"+N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.answer() );
   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute N : int;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     N := (scan.getCurrent())->toInteger() ; 
     skip );
   operation answer() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("ABC" + N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      TreeMap<Integer,Integer>S=new TreeMap<>();
      int c=0 ;
      int q=sc.nextInt();
      for(int i=0 ; i<q ; i++){
        int cmd=sc.nextInt();
        Integer x=sc.nextInt();
        if(cmd==0){
          Integer n=S.getOrDefault(x,0);
          S.put(x,n+1);
          System.out.println(++c);
        }
        else if(cmd==1){
          Integer n=S.getOrDefault(x,0);
          System.out.println(n);
        }
        else if(cmd==2){
          Integer n=S.getOrDefault(x,0);
          S.remove(x);
          c-=n ;
        }
        else {
          int r=sc.nextInt();
          S.subMap(x,true,r,true).forEach((k,v)->{
            for(int j=0 ; j<v ; j++)System.out.println(k);
          }
);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var S : Map(int,int) ; S := Map{} ;
     var c : int ; c := 0 ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < q do ( (     var cmd : int ; cmd := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (cmd = 0) then (     var n : int ; n := (if S->keys()->contains(x) then S->at(x) else 0 endif) ;
     S := S->union(Map{x |-> n + 1}) ; 
     OclFile["System.out"].println((c + 1)) ) else     if (cmd = 1) then (     var n : int ; n := (if S->keys()->contains(x) then S->at(x) else 0 endif) ;
     OclFile["System.out"].println(n) ) else     if (cmd = 2) then (     var n : int ; n := (if S->keys()->contains(x) then S->at(x) else 0 endif) ;
     S := S->antirestrict(Set{x}) ; 
     c := c-(n) ) else (     var r : int ; r := sc.getCurrent()->toInteger() ;
     for ,v : S->restrict( _key | _key < true & _key >= x ) do
    (    skip) ) ;  ;  )  ;     i := i + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try {
      Scanner sc=new Scanner(System.in);
      String a="ABC"+sc.nextInt();
      System.out.println(a);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := "ABC" + sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(a) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static void printArr(int arr[],int n){
    for(int i=0 ; i<n ; i++){
      System.out.print(arr[i]+" ");
    }
  }
  static void findNumbers(int arr[],int n){
    Arrays.sort(arr);
    reverse(arr);
    int freq[]=new int[arr[0]+1];
    for(int i=0 ; i<n ; i++){
      freq[arr[i] ]++;
    }
    int size=(int)Math.sqrt(n);
    int brr[]=new int[size],x,l=0 ;
    for(int i=0 ; i<n ; i++){
      if(freq[arr[i] ]>0 && l<size){
        brr[l]=arr[i];
        freq[brr[l] ]--;
        l++;
        for(int j=0 ; j<l ; j++){
          if(i!=j){
            x=__gcd(arr[i],brr[j]);
            freq[x]-=2 ;
          }
        }
      }
    }
    printArr(brr,size);
  }
  public static void reverse(int[] input){
    int last=input.length-1 ;
    int middle=input.length/2 ;
    for(int i=0 ; i<=middle ; i++){
      int temp=input[i];
      input[i]=input[last-i];
      input[last-i]=temp ;
    }
  }
  static int __gcd(int a,int b){
    if(b==0){
      return a ;
    }
    return __gcd(b,a % b);
  }
  public static void main(String[] args){
    int arr[]={
      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,5,7,10,12,2,2 };
      int n=arr.length ;
      findNumbers(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
  static   operation findNumbers( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     execute reverse(arr) ; 
    var freq : Sequence(int) ; freq := Integer.subrange(1,arr[0+1] + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     freq[arr[i+1]+1] := freq[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var size : int ; size := (n)->sqrt()->oclAsType(int) ;
    var brr : Sequence(void) ; brr := Integer.subrange(1,size)->collect(0) ;
    var x : int ;
    var l : int ; l := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (freq[arr[i+1]+1] > 0 & l < size) then (     brr[l+1] := arr[i+1] ; 
     freq[brr[l+1]+1] := freq[brr[l+1]+1] - 1 ; 
     l := l + 1 ; 
         var j : int ; j := 0 ; while j < l do ( (     if (i /= j) then (     x := __gcd(arr[i+1], brr[j+1]) ; 
     freq[x+1] := freq[x+1]-(2) ) else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    execute printArr(brr, size) ; 
 );
  static   operation reverse( input : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var last : int ; last := input->size() - 1 ;
     var middle : int ; middle := input->size() / 2 ;
         var i : int ; i := 0 ; while i <= middle do ( (     var temp : int ; temp := input[i+1] ;
     input[i+1] := input[last - i+1] ; 
     input[last - i+1] := temp )  ;     i := i + 1 ) );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else skip ; 
     return __gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,5,7,10,12,2,2} ;
     var n : int ; n := arr->size() ;
     execute findNumbers(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    for(int i=0 ; i<t ; i++){
      long n=scanner.nextLong();
      if(n==1){
        System.out.println(2);
        continue ;
      }
      if(n<10){
        System.out.println(n);
        continue ;
      }
      while(! method(n)){
        n++;
      }
      System.out.println(n);
    }
  }
  private static boolean method(long n){
    long temp=n ;
    long sum=0 ;
    while(temp!=0){
      sum+=temp % 10 ;
      temp/=10 ;
    }
    if(sum==1){
      return false ;
    }
    if(n % sum==0){
      return true ;
    }
    for(long i=2 ; i<sum ; i++){
      if(n % i==0 && sum % i==0){
        return true ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : long ; n := scanner.getCurrent()->toLong() ;
     if (n = 1) then (     OclFile["System.out"].println(2) ; 
     continue ) else skip ; 
    if (n < 10) then (     OclFile["System.out"].println(n) ; 
     continue ) else skip ; 
    while (not(method(n))) do (     n := n + 1 ) ; 
    OclFile["System.out"].println(n) ; 
 )  ;     i := i + 1 ) );
  static   operation method( n : long) : boolean
  pre: true
  post: true
  activity: (     var temp : long ; temp := n ;
     var sum : long ; sum := 0 ;
    while (temp /= 0) do (     sum := sum+(temp mod 10) ; 
     temp := temp/(10) ) ; 
    if (sum = 1) then (     return false ) else skip ; 
    if (n mod sum = 0) then (     return true ) else skip ; 
        var i : long ; i := 2 ; while i < sum do ( (     if (n mod i = 0 & sum mod i = 0) then (     return true ) else skip )  ;     i := i + 1 ) ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.nio.charset.StandardCharsets ;
import java.util.Scanner ;
import java.util.concurrent.TransferQueue ;
public class ylhgcd {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in,StandardCharsets.UTF_8.name());
    int count=cin.nextInt();
    while(count>0){
      long num=cin.nextLong();
      System.out.println(getYlhgcd(num));
      count--;
    }
  }
  private static long getYlhgcd(long num){
    long num2,tmp_num ;
    while(true){
      tmp_num=num ;
      num2=0 ;
      while(tmp_num!=0){
        num2+=tmp_num % 10 ;
        tmp_num/=10 ;
      }
      if(gcd(num,num2)!=1){
        break ;
      }
      num++;
    }
    return num ;
  }
  private static long gcd(long num,long num2){
    while(num2!=0){
      num=num % num2 ;
      if(num2>num){
        long tmp=num ;
        num=num2 ;
        num2=tmp ;
      }
    }
    return num ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ylhgcd {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"], StandardCharsets.UTF_8.name()) ;
     var count : int ; count := cin.getCurrent()->toInteger() ;
     while (count > 0) do (     var num : long ; num := cin.getCurrent()->toLong() ;
     OclFile["System.out"].println(getYlhgcd(num)) ; 
     count := count - 1 ) );
  static   operation getYlhgcd( num : long) : long
  pre: true
  post: true
  activity: (     var num2 : long ;
    var tmp_num : long ;
     while (true) do (     tmp_num := num ; 
     num2 := 0 ; 
    while (tmp_num /= 0) do (     num2 := num2+(tmp_num mod 10) ; 
     tmp_num := tmp_num/(10) ) ; 
    if (gcd(num, num2) /= 1) then (     break ) else skip ; 
    num := num + 1 ; 
 ) ; 
     return num );
  static   operation gcd( num : long, num2 : long) : long
  pre: true
  post: true
  activity: (     while (num2 /= 0) do (     num := num mod num2 ; 
     if (num2 > num) then (     var tmp : long ; tmp := num ;
     num := num2 ; 
     num2 := tmp ) else skip ) ; 
     return num );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class A_GCD_Sum {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int T=reader.nextInt();
    while(T!=0){
      T--;
      long num=reader.nextLong();
      while(gcd(num,sumOfDigits(num))==1){
        num++;
      }
      System.out.println(num);
    }
  }
  public static long gcd(long a,long b){
    if(b==0){
      return a ;
    }
    return gcd(b,a % b);
  }
  public static long sumOfDigits(long num){
    long sum=0L ;
    while(num!=0){
      sum+=num % 10 ;
      num=num/10 ;
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_GCD_Sum {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var T : int ; T := reader.nextInt() ;
     while (T /= 0) do (     T := T - 1 ; 
     var num : long ; num := reader.nextLong() ;
     while (gcd(num, sumOfDigits(num)) = 1) do (     num := num + 1 ) ; 
     OclFile["System.out"].println(num) ) );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else skip ; 
     return gcd(b, a mod b) );
  static   operation sumOfDigits( num : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0L ;
     while (num /= 0) do (     sum := sum+(num mod 10) ; 
     num := num / 10 ) ; 
     return sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.nio.charset.StandardCharsets ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class ZuiDaGongYueShuB {
  public static void main(String[] args){
    List<Long>inputDatas=getInputDatas();
    List<long[]>gongYueShuZu=getGongYueShuZu(inputDatas);
    gongYueShuZu.stream().forEach(e->System.out.println(calMinZuiDaGongYue(e[0],e[1])));
  }
  static long calMinZuiDaGongYue(long a,long b){
    long r=calZuiDaGongYueShu(a,b);
    while(r<2){
      if(a++% 10<9){
        b++;
      }
      else {
        b=calMeiYiWeiShuZiZhiHe(a);
      }
      r=calZuiDaGongYueShu(a,b);
    }
    return a ;
  }
  static long calZuiDaGongYueShu(long a,long b){
    long r=a % b ;
    while(r!=0){
      a=b ;
      b=r ;
      r=a % b ;
    }
    return b ;
  }
  static List<Long>getInputDatas(){
    Scanner scanner=new Scanner(System.in,StandardCharsets.UTF_8.name());
    int lines=Integer.parseInt(scanner.nextLine());
    List<Long>result=new ArrayList();
    for(int i=0 ; i<lines ; i++){
      result.add(Long.parseLong(scanner.nextLine()));
    }
    return result ;
  }
  static List<long[]>getGongYueShuZu(List<Long>inputData){
    return inputData.stream().map(ZuiDaGongYueShuB :: transLongToGongYueShuZu).collect(Collectors.toList());
  }
  static long[] transLongToGongYueShuZu(long num){
    long[] arr=new long[2];
    arr[0]=num ;
    arr[1]=calMeiYiWeiShuZiZhiHe(num);
    return arr ;
  }
  static long calMeiYiWeiShuZiZhiHe(long num){
    long r=0L ;
    while(num!=0){
      r+=num % 10 ;
      num/=10 ;
    }
    return r ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ZuiDaGongYueShuB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputDatas : Sequence(long) ; inputDatas := getInputDatas() ;
     var gongYueShuZu : Sequence(Sequence(long)) ; gongYueShuZu := getGongYueShuZu(inputDatas) ;
     for e : gongYueShuZu do
    (    OclFile["System.out"].println(calMinZuiDaGongYue(e[0+1], e[1+1]))) );
  static   operation calMinZuiDaGongYue( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var r : long ; r := calZuiDaGongYueShu(a, b) ;
     while (r < 2) do (     if (a mod 10 < 9) then (     b := b + 1 ) else (     b := calMeiYiWeiShuZiZhiHe(a) ) ;  
     r := calZuiDaGongYueShu(a, b) ) ; 
     return a );
  static   operation calZuiDaGongYueShu( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var r : long ; r := a mod b ;
     while (r /= 0) do (     a := b ; 
     b := r ; 
     r := a mod b ) ; 
     return b );
  static   operation getInputDatas() : Sequence(long)
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"], StandardCharsets.UTF_8.name()) ;
     var lines : int ; lines := (scanner.nextLine())->toInteger() ;
    var result : Sequence(long) ; result := Sequence{} ;
        var i : int ; i := 0 ; while i < lines do ( (     result := result->including((scanner.nextLine())->toLong()) )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation getGongYueShuZu( inputData : Sequence(long)) : Sequence(Sequence(long))
  pre: true
  post: true
  activity: (     return inputData->collect( _x1 | (lambda _pars : OclAny in ZuiDaGongYueShuB.newZuiDaGongYueShuB().transLongToGongYueShuZu(_pars))->apply(_x1) ).collect(Collectors.toList()) );
  static   operation transLongToGongYueShuZu( num : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var arr : Sequence(long) ; arr := Integer.subrange(1,2)->collect(0) ;
     arr[0+1] := num ; 
     arr[1+1] := calMeiYiWeiShuZiZhiHe(num) ; 
     return arr );
  static   operation calMeiYiWeiShuZiZhiHe( num : long) : long
  pre: true
  post: true
  activity: (     var r : long ; r := 0L ;
     while (num /= 0) do (     r := r+(num mod 10) ; 
     num := num/(10) ) ; 
     return r );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class MyClass {
  static Scanner in=new Scanner(System.in);
  static long k ;
  static char a[];
  public static void main(String args[]){
    k=in.nextLong();
    a=in.next().toCharArray();
    long sumHave=0 ;
    for(char i : a){
      sumHave+=(i-'0');
    }
    Arrays.sort(a);
    long ans=0 ;
    int len=a.length ;
    while(true){
      boolean find=false ;
      for(int i=0 ; i<len ; i++){
        if(k>sumHave){
          if(9-(a[i]-'0')!=0){
            ans++;
            sumHave+=(9-(a[i]-'0'));
            a[i]='9' ;
          }
        }
        else {
          find=true ;
          break ;
        }
      }
      if(find){
        break ;
      }
    }
    System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute k : long;
  static   attribute a : Sequence(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     k := in.getCurrent()->toLong() ; 
     a := in.getCurrent()->characters() ; 
    var sumHave : long ; sumHave := 0 ;
    for (i : a) do ( (     sumHave := sumHave+((i - ('0')->char2byte())) )  ) ; 
    a := a->sort() ; 
    var ans : long ; ans := 0 ;
    var len : int ; len := a->size() ;
    while (true) do (     var find : boolean ; find := false ;
         var i : int ; i := 0 ; while i < len do ( (     if (k > sumHave) then (     if (9 - (a[i+1] - ('0')->char2byte()) /= 0) then (     ans := ans + 1 ; 
     sumHave := sumHave+((9 - (a[i+1] - ('0')->char2byte()))) ; 
     a[i+1] := '9' ) else skip ) else (     find := true ; 
     break ) )  ;     i := i + 1 ) ; 
     if (find) then (     break ) else skip ) ; 
    OclFile["System.out"].print(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Solution {
  static void printAllSubsetsRec(int arr[],int n,Vector<Integer>v,int sum){
    if(sum==0){
      for(int i=0 ; i<v.size(); i++)System.out.print(v.get(i)+" ");
      System.out.println();
      return ;
    }
    if(n==0)return ;
    printAllSubsetsRec(arr,n-1,v,sum);
    Vector<Integer>v1=new Vector<Integer>(v);
    v1.add(arr[n-1]);
    printAllSubsetsRec(arr,n-1,v1,sum-arr[n-1]);
  }
  static void printAllSubsets(int arr[],int n,int sum){
    Vector<Integer>v=new Vector<Integer>();
    printAllSubsetsRec(arr,n,v,sum);
  }
  public static void main(String args[]){
    int arr[]={
      2,5,8,4,6,11 };
      int sum=13 ;
      int n=arr.length ;
      printAllSubsets(arr,n,sum);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation printAllSubsetsRec( arr : Sequence(int), n : int, v : Sequence(int), sum : int) : void
  pre: true
  post: true
  activity: (     if (sum = 0) then (         var i : int ; i := 0 ; while i < v->size() do (     OclFile["System.out"].print(v->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ; 
     return ) else skip ; 
     if (n = 0) then     return else skip ; 
    execute printAllSubsetsRec(arr, n - 1, v, sum) ; 
    var v1 : Sequence(int) ; v1 := Sequence{}->union(v) ;
    v1 := v1->including(arr[n - 1+1]) ; 
    execute printAllSubsetsRec(arr, n - 1, v1, sum - arr[n - 1+1]) ; 
 );
  static   operation printAllSubsets( arr : Sequence(int), n : int, sum : int) : void
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Sequence{} ;
     execute printAllSubsetsRec(arr, n, v, sum) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,5,8,4,6,11} ;
     var sum : int ; sum := 13 ;
     var n : int ; n := arr->size() ;
     execute printAllSubsets(arr, n, sum) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    if(s.contains("7")){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
     if (s->includes("7")) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String N=br.readLine();
    System.out.println(N.contains("7")? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var N : String ; N := br.readLine() ;
     OclFile["System.out"].println(if N->includes("7") then "Yes" else "No" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    String seven="No" ;
    try(Scanner scn=new Scanner(System.in)){
      final char[] N=scn.next().toCharArray();
      for(int i=0 ; i<N.length ; i++){
        if(N[i]=='7'){
          seven="Yes" ;
          break ;
        }
      }
    }
    System.out.println(seven);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var seven : String ; seven := "No" ;
     try (    var scn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : Sequence(String) ; N := scn.getCurrent()->characters() ;
         var i : int ; i := 0 ; while i < N->size() do ( (     if (N[i+1] = '7') then (     seven := "Yes" ; 
     break ) else skip )  ;     i := i + 1 ) ))  
     OclFile["System.out"].println(seven) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void solve(int N,int K){
    int Array[]=new int[N+1];
    if(N<=K){
      System.out.println("1");
      return ;
    }
    int i=0 ;
    int sum=K ;
    for(i=1 ; i<=K ; ++i){
      Array[i]=1 ;
    }
    Array[i]=sum ;
    for(i=K+2 ; i<=N ; ++i){
      Array[i]=sum-Array[i-K-1]+Array[i-1];
      sum=Array[i];
    }
    System.out.println(Array[N]);
  }
  public static void main(String args[]){
    int N=4,K=2 ;
    solve(N,K);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( N : int, K : int) : void
  pre: true
  post: true
  activity: (     var Array : Sequence(int) ; Array := Integer.subrange(1,N + 1)->collect(0) ;
     if (N <= K) then (     OclFile["System.out"].println("1") ; 
     return ) else skip ; 
    var i : int ; i := 0 ;
    var sum : int ; sum := K ;
        i := 1 ; while i <= K do ( (     Array[i+1] := 1 )  ;     i := i + 1 ) ; 
    Array[i+1] := sum ; 
        i := K + 2 ; while i <= N do ( (     Array[i+1] := sum - Array[i - K - 1+1] + Array[i - 1+1] ; 
     sum := Array[i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Array[N+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
    var K : int ; K := 2 ;
     execute solve(N, K) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int b=sc.nextInt();
      if(b==0){
        break ;
      }
      calculatorResult(b);
    }
  }
  public static void calculatorResult(int b){
    int i=1 ;
    int lowestFloor=1 ;
    int numberOfFloors=0 ;
    int sum=0 ;
    while(true){
      if(sum==b){
        break ;
      }
      if(sum<b){
        sum+=i ;
        numberOfFloors++;
        i++;
      }
      if(sum>b){
        sum-=lowestFloor ;
        lowestFloor++;
        numberOfFloors--;
      }
    }
    System.out.println(lowestFloor+" "+numberOfFloors);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (b = 0) then (     break ) else skip ; 
     execute calculatorResult(b) ) );
  static   operation calculatorResult( b : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 1 ;
     var lowestFloor : int ; lowestFloor := 1 ;
    var numberOfFloors : int ; numberOfFloors := 0 ;
    var sum : int ; sum := 0 ;
    while (true) do (     if (sum = b) then (     break ) else skip ; 
     if (sum < b) then (     sum := sum+(i) ; 
     numberOfFloors := numberOfFloors + 1 ; 
     i := i + 1 ) else skip ; 
     if (sum > b) then (     sum := sum-(lowestFloor) ; 
     lowestFloor := lowestFloor + 1 ; 
     numberOfFloors := numberOfFloors - 1 ) else skip ) ; 
    OclFile["System.out"].println(lowestFloor + " " + numberOfFloors) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner a=new Scanner(System.in);
    int f=a.nextInt();
    String s=String.valueOf(f);
    for(int i=0 ; i<s.length(); i++){
      if(Character.getNumericValue(s.charAt(i))==7){
        System.out.println("Yes");
        break ;
      }
      else if(i==s.length()-1 && Character.getNumericValue(s.charAt(i))!=7){
        System.out.println("No");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : OclFile ; a := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var f : int ; f := a.getCurrent()->toInteger() ;
     var s : String ; s := ((f) + "") ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (("" + s->at(i+1))->toInteger() = 7) then (     OclFile["System.out"].println("Yes") ; 
     break ) else     if (i = s->size() - 1 & ("" + s->at(i+1))->toInteger() /= 7) then (     OclFile["System.out"].println("No") ) else skip ; )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    String n=sc.next();
    boolean ans=false ;
    for(char c : n.toCharArray()){
      if(c=='7'){
        ans=true ;
      }
    }
    System.out.println(ans ? "Yes" : "No");
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : String ; n := sc.getCurrent() ;
    var ans : boolean ; ans := false ;
    for (c : n->characters()) do ( (     if (c = '7') then (     ans := true ) else skip )  ) ; 
    OclFile["System.out"].println(if ans then "Yes" else "No" endif) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minMoves(int n){
    String s=Integer.toString(n);
    int ans=Integer.MAX_VALUE ;
    int len=s.length();
    for(int i=0 ; i<len ; ++i){
      for(int j=0 ; j<len ; ++j){
        if(i==j)continue ;
        char t[]=s.toCharArray();
        int cur=0 ;
        for(int k=i ; k<len-1 ; ++k){
          swap(t,k,k+1);
++cur ;
        }
        for(int k=j-((j>i)? 1 : 0); k<len-2 ; ++k){
          swap(t,k,k+1);
++cur ;
        }
        int pos=-1 ;
        for(int k=0 ; k<len ; ++k){
          if(t[k]!='0'){
            pos=k ;
            break ;
          }
        }
        for(int k=pos ; k>0 ; --k){
          swap(t,k,k-1);
++cur ;
        }
        long nn=Integer.parseInt(String.valueOf(t));
        if(nn % 25==0)ans=Math.min(ans,cur);
      }
    }
    if(ans==Integer.MAX_VALUE)return-1 ;
    return ans ;
  }
  static void swap(char t[],int i,int j){
    char temp=t[i];
    t[i]=t[j];
    t[j]=temp ;
  }
  public static void main(String[] args){
    int n=509201 ;
    System.out.println(minMoves(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minMoves( n : int) : int
  pre: true
  post: true
  activity: (     var s : String ; s := ((n) + "") ;
     var ans : int ; ans := 2147483647 ;
    var len : int ; len := s->size() ;
        var i : int ; i := 0 ; while i < len do ( (         var j : int ; j := 0 ; while j < len do ( (     if (i = j) then     continue else skip ; 
     var t : Sequence(String) ; t := s->characters() ;
    var cur : int ; cur := 0 ;
        var k : int ; k := i ; while k < len - 1 do ( (     execute swap(t, k, k + 1) ; 
     cur := cur + 1 )  ;     k := k + 1 ) ; 
        var k : int ; k := j - (if (j > i) then 1 else 0 endif) ; while k < len - 2 do ( (     execute swap(t, k, k + 1) ; 
     cur := cur + 1 )  ;     k := k + 1 ) ; 
    var pos : int ; pos := -1 ;
        var k : int ; k := 0 ; while k < len do ( (     if (t[k+1] /= '0') then (     pos := k ; 
     break ) else skip )  ;     k := k + 1 ) ; 
        var k : int ; k := pos ; while k > 0 do ( (     execute swap(t, k, k - 1) ; 
     cur := cur + 1 )  ;     k := k - 1 ) ; 
    var nn : long ; nn := (((t) + ""))->toInteger() ;
    if (nn mod 25 = 0) then     ans := Set{ans, cur}->min() ; else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (ans = 2147483647) then     return -1 else skip ; 
    return ans 
 );
  static   operation swap( t : Sequence(String), i : int, j : int) : void
  pre: true
  post: true
  activity: (     var temp : String ; temp := t[i+1] ;
     t[i+1] := t[j+1] ; 
     t[j+1] := temp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 509201 ;
     OclFile["System.out"].println(minMoves(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countSubarrays(int a[],int n,int m){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int odd=0 ;
      for(int j=i ; j<n ; j++){
        if(a[j] % 2==0)odd++;
        if(odd==m)count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int a[]={
      2,2,5,6,9,2,11 };
      int n=a.length ;
      int m=2 ;
      System.out.println(countSubarrays(a,n,m));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSubarrays( a : Sequence(int), n : int, m : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var odd : int ; odd := 0 ;
         var j : int ; j := i ; while j < n do ( (     if (a[j+1] mod 2 = 0) then     odd := odd + 1 ; else skip ; 
     if (odd = m) then     count := count + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,2,5,6,9,2,11} ;
     var n : int ; n := a->size() ;
     var m : int ; m := 2 ;
     OclFile["System.out"].println(countSubarrays(a, n, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B_main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    char[] n=sc.next().toCharArray();
    int[] cnt=new int[10];
    int cur=0 ;
    for(int i=0 ; i<n.length ; i++){
      int digit=n[i]-'0' ;
      cnt[digit]++;
      cur+=digit ;
    }
    int ans=0 ;
    for(int i=0 ; i<9 ; i++){
      for(int j=0 ; j<cnt[i]; j++){
        if(cur<k){
          ans++;
          cur+=9-i ;
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var n : Sequence(String) ; n := sc.getCurrent()->characters() ;
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,10)->collect(0) ;
    var cur : int ; cur := 0 ;
        var i : int ; i := 0 ; while i < n->size() do ( (     var digit : int ; digit := n[i+1] - ('0')->char2byte() ;
     cnt[digit+1] := cnt[digit+1] + 1 ; 
     cur := cur+(digit) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 9 do ( (         var j : int ; j := 0 ; while j < cnt[i+1] do ( (     if (cur < k) then (     ans := ans + 1 ; 
     cur := cur+(9 - i) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int countSubarrays(int a[],int n,int m){
    int count=0 ;
    int prefix[]=new int[n];
    int odd=0 ;
    for(int i=0 ; i<n ; i++){
      prefix[odd]++;
      if((a[i] & 1)==1)odd++;
      if(odd>=m)count+=prefix[odd-m];
    }
    return count ;
  }
  public static void main(String[] args){
    int a[]={
      2,2,5,6,9,2,11 };
      int n=a.length ;
      int m=2 ;
      System.out.println(countSubarrays(a,n,m));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSubarrays( a : Sequence(int), n : int, m : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var prefix : Sequence(int) ; prefix := Integer.subrange(1,n)->collect(0) ;
    var odd : int ; odd := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     prefix[odd+1] := prefix[odd+1] + 1 ; 
     if ((a[i+1] & 1) = 1) then     odd := odd + 1 ; else skip ; 
     if (odd >= m) then     count := count+(prefix[odd - m+1]) ; else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,2,5,6,9,2,11} ;
     var n : int ; n := a->size() ;
     var m : int ; m := 2 ;
     OclFile["System.out"].println(countSubarrays(a, n, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int reverse(int num){
    int rev=0 ;
    while(num>0){
      rev=rev*10+num % 10 ;
      num=num/10 ;
    }
    return rev ;
  }
  static boolean isPalindrome(int num){
    if(num==reverse(num))return true ;
    return false ;
  }
  static void printPalindromes(int d){
    if(d<=0)return ;
    int smallest=(int)Math.pow(10,d-1);
    int largest=(int)Math.pow(10,d)-1 ;
    for(int i=smallest ; i<=largest ; i++){
      if(isPalindrome(i))System.out.print(i+" ");
    }
  }
  public static void main(String[] args){
    int d=2 ;
    printPalindromes(d);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation reverse( num : int) : int
  pre: true
  post: true
  activity: (     var rev : int ; rev := 0 ;
     while (num > 0) do (     rev := rev * 10 + num mod 10 ; 
     num := num / 10 ) ; 
     return rev );
  static   operation isPalindrome( num : int) : boolean
  pre: true
  post: true
  activity: (     if (num = reverse(num)) then     return true else skip ; 
     return false );
  static   operation printPalindromes( d : int) : void
  pre: true
  post: true
  activity: (     if (d <= 0) then     return else skip ; 
     var smallest : int ; smallest := 10->pow(d - 1)->oclAsType(int) ;
     var largest : int ; largest := 10->pow(d)->oclAsType(int) - 1 ;
         var i : int ; i := smallest ; while i <= largest do ( (     if (isPalindrome(i)) then     OclFile["System.out"].print(i + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : int ; d := 2 ;
     execute printPalindromes(d) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class pr11 {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    double a=scan.nextDouble(),b=scan.nextDouble(),c=scan.nextDouble(),d=scan.nextDouble();
    double p1=(a*d)/(b*c-a*c+a*d);
    System.out.println(p1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pr11 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : double ; a := scan.getCurrent()->toReal() ;
    var b : double ; b := scan.getCurrent()->toReal() ;
    var c : double ; c := scan.getCurrent()->toReal() ;
    var d : double ; d := scan.getCurrent()->toReal() ;
     var p1 : double ; p1 := (a * d) / (b * c - a * c + a * d) ;
     OclFile["System.out"].println(p1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    double p1=(double)a/(double)b ;
    double p2=(1.0-(double)c/(double)d)*(1.0-p1);
    double ans=0 ;
    for(int i=0 ; i<10000 ; i++){
      ans+=Math.pow(p2,i)*p1 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var p1 : double ; p1 := a->oclAsType(double) / b->oclAsType(double) ;
    var p2 : double ; p2 := (1.0 - c->oclAsType(double) / d->oclAsType(double)) * (1.0 - p1) ;
    var ans : double ; ans := 0 ;
        var i : int ; i := 0 ; while i < 10000 do ( (     ans := ans+(p2->pow(i) * p1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Archer {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    System.out.println((double)(a*d)/(a*d+b*c-a*c));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Archer {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println((a * d)->oclAsType(double) / (a * d + b * c - a * c)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BArcher solver=new BArcher();
    solver.solve(1,in,out);
    out.close();
  }
  static class BArcher {
    public void solve(int testNumber,Scanner sc,PrintWriter pw){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int d=sc.nextInt();
      double per1=1.0*a/b ;
      double per2=1.0*c/d ;
      pw.println((per1)/(1-(1-per1)*(1-per2)));
    }
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(FileReader r){
      br=new BufferedReader(r);
    }
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BArcher ; solver := BArcher.newBArcher() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BArcher {
   operation solve( testNumber : int, sc : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.nextInt() ;
     var b : int ; b := sc.nextInt() ;
    var c : int ; c := sc.nextInt() ;
    var d : int ; d := sc.nextInt() ;
    var per1 : double ; per1 := 1.0 * a / b ;
    var per2 : double ; per2 := 1.0 * c / d ;
    pw.println((per1) / (1 - (1 - per1) * (1 - per2))) ; 
 );
}
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( r : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(r);
    return self );
  operation initialise( r : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(r) );
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  private static long ans=0,low=0 ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    long n=in.nextInt();
    while(n>0){
      ans=0 ;
      low=0 ;
      long d=2*n ;
      for(int i=1 ; i*i<=d ; i++){
        if(d % i!=0)continue ;
        calc(i,d/i);
        calc(d/i,i);
      }
      out.println(low+" "+ans);
      n=in.nextInt();
    }
    out.flush();
  }
  private static void calc(long x,long y){
    if((x-y+1)% 2!=0 ||(x+y-1)% 2!=0)return ;
    long b=(x+y-1)/2,a=(x-y+1)/2 ;
    if(b<1 || a<1)return ;
    if(b-a+1>ans){
      ans=b-a+1 ;
      low=a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ans : long := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := in.getCurrent()->toInteger() ;
    while (n > 0) do (     ans := 0 ; 
     low := 0 ; 
    var d : long ; d := 2 * n ;
        var i : int ; i := 1 ; while i * i <= d do ( (     if (d mod i /= 0) then     continue else skip ; 
     execute calc(i, d / i) ; 
     execute calc(d / i, i) )  ;     i := i + 1 ) ; 
    skip ; 
    n := in.getCurrent()->toInteger() ; 
 ) ; 
    skip ; 
 );
  static   operation calc( x : long, y : long) : void
  pre: true
  post: true
  activity: (     if ((x - y + 1) mod 2 /= 0 or (x + y - 1) mod 2 /= 0) then     return else skip ; 
     var b : long ; b := (x + y - 1) / 2 ;
    var a : long ; a := (x - y + 1) / 2 ;
     if (b < 1 or a < 1) then     return else skip ; 
     if (b - a + 1 > ans) then (     ans := b - a + 1 ; 
     low := a ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF312B {
  public static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    double a=scanner.nextInt();
    double b=scanner.nextInt();
    double c=scanner.nextInt();
    double d=scanner.nextInt();
    double rWinProb=a/b ;
    double zWinProb=c/d ;
    double rMissAndZMissProb=(1-rWinProb)*(1-zWinProb);
    double total=rWinProb/(1-rMissAndZMissProb);
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF312B {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var a : double ; a := scanner.getCurrent()->toInteger() ;
    var b : double ; b := scanner.getCurrent()->toInteger() ;
    var c : double ; c := scanner.getCurrent()->toInteger() ;
    var d : double ; d := scanner.getCurrent()->toInteger() ;
    var rWinProb : double ; rWinProb := a / b ;
    var zWinProb : double ; zWinProb := c / d ;
    var rMissAndZMissProb : double ; rMissAndZMissProb := (1 - rWinProb) * (1 - zWinProb) ;
    var total : double ; total := rWinProb / (1 - rMissAndZMissProb) ;
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void isHalfReducible(int arr[],int n,int m){
    int frequencyHash[]=new int[m+1];
    int i ;
    for(i=0 ; i<frequencyHash.length ; i++)frequencyHash[i]=0 ;
    for(i=0 ; i<n ; i++){
      frequencyHash[arr[i] %(m+1)]++;
    }
    for(i=0 ; i<=m ; i++){
      if(frequencyHash[i]>=n/2)break ;
    }
    if(i<=m)System.out.println("Yes");
    else System.out.println("No");
  }
  public static void main(String args[]){
    int arr[]={
      8,16,32,3,12 };
      int n=arr.length ;
      int m=7 ;
      isHalfReducible(arr,n,m);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isHalfReducible( arr : Sequence(int), n : int, m : int) : void
  pre: true
  post: true
  activity: (     var frequencyHash : Sequence(int) ; frequencyHash := Integer.subrange(1,m + 1)->collect(0) ;
     var i : int ;
        i := 0 ; while i < frequencyHash->size() do (     frequencyHash[i+1] := 0 ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     frequencyHash[arr[i+1] mod (m + 1)+1] := frequencyHash[arr[i+1] mod (m + 1)+1] + 1 )  ;     i := i + 1 ) ; 
        i := 0 ; while i <= m do ( (     if (frequencyHash[i+1] >= n / 2) then     break else skip )  ;     i := i + 1 ) ; 
    if (i <= m) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,16,32,3,12} ;
     var n : int ; n := arr->size() ;
     var m : int ; m := 7 ;
     execute isHalfReducible(arr, n, m) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int findShortestSubArray(int[] nums){
    Map<Integer,Integer>left=new HashMap(),right=new HashMap(),count=new HashMap();
    for(int i=0 ; i<nums.length ; i++){
      int x=nums[i];
      if(left.get(x)==null)left.put(x,i);
      right.put(x,i);
      count.put(x,count.getOrDefault(x,0)+1);
    }
    int ans=nums.length ;
    int degree=Collections.max(count.values());
    for(int x : count.keySet()){
      if(count.get(x)==degree){
        ans=Math.min(ans,right.get(x)-left.get(x)+1);
      }
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation findShortestSubArray( nums : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var left : Map(int,int) ; left := Map{} ;
    var right : Map(int,int) ; right := Map{} ;
    var count : Map(int,int) ; count := Map{} ;
         var i : int ; i := 0 ; while i < nums->size() do ( (     var x : int ; x := nums[i+1] ;
     if (left->at(x+1) = null) then     left := left->union(Map{x |-> i}) ; else skip ; 
     right := right->union(Map{x |-> i}) ; 
     count := count->union(Map{x |-> count->at(x, 0+1) + 1}) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := nums->size() ;
    var degree : int ; degree := .max(count.allInstances()) ;
    for (x : count.keySet()) do ( (     if (count->at(x+1) = degree) then (     ans := Set{ans, right->at(x+1) - left->at(x+1) + 1}->min() ) else skip )  ) ; 
    return ans 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Number835B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int sum=in.nextInt();
    String numbers=in.next();
    ArrayList<Integer>list=new ArrayList();
    int size=numbers.length();
    int num_sum=0 ;
    for(int i=0 ; i<size ; i++){
      list.add(Integer.parseInt(String.valueOf(numbers.charAt(i))));
      num_sum+=list.get(i);
    }
    if(num_sum>=sum){
      System.out.println(0);
      return ;
    }
    Collections.sort(list);
    for(int i=0 ; i<size ; i++){
      num_sum+=9-list.get(i);
      if(num_sum>=sum){
        System.out.println(i+1);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Number835B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sum : int ; sum := in.getCurrent()->toInteger() ;
    var numbers : String ; numbers := in.getCurrent() ;
    var list : Sequence(int) ; list := Sequence{} ;
    var size : int ; size := numbers->size() ;
    var num_sum : int ; num_sum := 0 ;
        var i : int ; i := 0 ; while i < size do ( (     list := list->including((((numbers->at(i+1)) + ""))->toInteger()) ; 
     num_sum := num_sum+(list->at(i+1)) )  ;     i := i + 1 ) ; 
    if (num_sum >= sum) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    list := list->sort() ; 
        var i : int ; i := 0 ; while i < size do ( (     num_sum := num_sum+(9 - list->at(i+1)) ; 
     if (num_sum >= sum) then (     OclFile["System.out"].println(i + 1) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int possibleStrings(int n,int r,int b,int g){
    int fact[]=new int[n+1];
    fact[0]=1 ;
    for(int i=1 ; i<=n ; i++)fact[i]=fact[i-1]*i ;
    int left=n-(r+g+b);
    int sum=0 ;
    for(int i=0 ; i<=left ; i++){
      for(int j=0 ; j<=left-i ; j++){
        int k=left-(i+j);
        sum=sum+fact[n]/(fact[i+r]*fact[j+b]*fact[k+g]);
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=4,r=2 ;
    int b=0,g=1 ;
    System.out.println(possibleStrings(n,r,b,g));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation possibleStrings( n : int, r : int, b : int, g : int) : int
  pre: true
  post: true
  activity: (     var fact : Sequence(int) ; fact := Integer.subrange(1,n + 1)->collect(0) ;
     fact[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do (     fact[i+1] := fact[i - 1+1] * i ;  ;     i := i + 1 ) ; 
    var left : int ; left := n - (r + g + b) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i <= left do ( (         var j : int ; j := 0 ; while j <= left - i do ( (     var k : int ; k := left - (i + j) ;
     sum := sum + fact[n+1] / (fact[i + r+1] * fact[j + b+1] * fact[k + g+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
    var r : int ; r := 2 ;
     var b : int ; b := 0 ;
    var g : int ; g := 1 ;
     OclFile["System.out"].println(possibleStrings(n, r, b, g)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAX=100 ;
  static void middlesum(int mat[][],int n){
    int row_sum=0,col_sum=0 ;
    for(int i=0 ; i<n ; i++)row_sum+=mat[n/2][i];
    System.out.println("Sum of middle row="+row_sum);
    for(int i=0 ; i<n ; i++)col_sum+=mat[i][n/2];
    System.out.println("Sum of middle column="+col_sum);
  }
  public static void main(String[] args){
    int mat[][]={
      {
        2,5,7 },{
          3,7,2 },{
            5,6,9 }
          };
          middlesum(mat,3);
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100;
  static   operation middlesum( mat : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (     var row_sum : int ; row_sum := 0 ;
    var col_sum : int ; col_sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     row_sum := row_sum+(mat[n / 2+1][i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Sum of middle row=" + row_sum) ; 
        var i : int ; i := 0 ; while i < n do (     col_sum := col_sum+(mat[i+1][n / 2+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Sum of middle column=" + col_sum) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{2,5,7},Sequence{3,7,2},Sequence{5,6,9}} ;
     execute middlesum(mat, 3) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line=br.readLine();
    int n=Integer.parseInt(line);
    String[] str_x=br.readLine().split(" ");
    String[] str_y=br.readLine().split(" ");
    double[] x=new double[n];
    double[] y=new double[n];
    double d1=0d ;
    double d2=0d ;
    double d3=0d ;
    double di=0d ;
    for(int i=0 ; i<n ; i++){
      x[i]=Double.parseDouble(str_x[i]);
      y[i]=Double.parseDouble(str_y[i]);
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      d1+=Math.abs(x[i]-y[i]);
      d2+=Math.pow(Math.abs(x[i]-y[i]),2);
      d3+=Math.pow(Math.abs(x[i]-y[i]),3);
      if(di<Math.abs(x[i]-y[i])){
        di=Math.abs(x[i]-y[i]);
      }
    }
    sb.append(d1).append("\n");
    sb.append(Math.sqrt(d2)).append("\n");
    sb.append(Math.cbrt(d3)).append("\n");
    sb.append(di).append("\n");
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := br.readLine() ;
    var n : int ; n := (line)->toInteger() ;
    var str_x : Sequence(String) ; str_x := br.readLine()->split(" ") ;
    var str_y : Sequence(String) ; str_y := br.readLine()->split(" ") ;
    var x : Sequence(double) ; x := Integer.subrange(1,n)->collect(0.0) ;
    var y : Sequence(double) ; y := Integer.subrange(1,n)->collect(0.0) ;
    var d1 : double ; d1 := 0d ;
    var d2 : double ; d2 := 0d ;
    var d3 : double ; d3 := 0d ;
    var di : double ; di := 0d ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := (str_x[i+1])->toReal() ; 
     y[i+1] := (str_y[i+1])->toReal() )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     d1 := d1+(if x[i+1] - y[i+1] < 0 then -(x[i+1] - y[i+1]) else x[i+1] - y[i+1] endif) ; 
     d2 := d2+(if x[i+1] - y[i+1] < 0 then -(x[i+1] - y[i+1]) else x[i+1] - y[i+1] endif->pow(2)) ; 
     d3 := d3+(if x[i+1] - y[i+1] < 0 then -(x[i+1] - y[i+1]) else x[i+1] - y[i+1] endif->pow(3)) ; 
     if (di < if x[i+1] - y[i+1] < 0 then -(x[i+1] - y[i+1]) else x[i+1] - y[i+1] endif) then (     di := if x[i+1] - y[i+1] < 0 then -(x[i+1] - y[i+1]) else x[i+1] - y[i+1] endif ) else skip )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(d1) + StringLib.newString("\n") ; 
    sb := sb + StringLib.newString((d2)->sqrt()) + StringLib.newString("\n") ; 
    sb := sb + StringLib.newString((d3)->cbrt()) + StringLib.newString("\n") ; 
    sb := sb + StringLib.newString(di) + StringLib.newString("\n") ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      int n=Integer.parseInt(br.readLine());
      String[] x_st=br.readLine().split(" ");
      String[] y_st=br.readLine().split(" ");
      double[] x=new double[n];
      double[] y=new double[n];
      double[] distance=new double[n];
      double d1=0,d2=0,d3=0,d_infinite=0 ;
      for(int i=0 ; i<n ; i++){
        x[i]=Double.parseDouble(x_st[i]);
        y[i]=Double.parseDouble(y_st[i]);
      }
      for(int i=0 ; i<n ; i++){
        distance[i]=Math.abs(x[i]-y[i]);
        d1+=distance[i];
        d2+=Math.pow(distance[i],2);
        d3+=Math.pow(distance[i],3);
        if(d_infinite<distance[i])d_infinite=distance[i];
      }
      d2=Math.pow(d2,1./2);
      d3=Math.pow(d3,1./3);
      System.out.println(d1+"\n"+d2+"\n"+d3+"\n"+d_infinite);
    }
    catch(Exception e){
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var x_st : Sequence(String) ; x_st := br.readLine()->split(" ") ;
    var y_st : Sequence(String) ; y_st := br.readLine()->split(" ") ;
    var x : Sequence(double) ; x := Integer.subrange(1,n)->collect(0.0) ;
    var y : Sequence(double) ; y := Integer.subrange(1,n)->collect(0.0) ;
    var distance : Sequence(double) ; distance := Integer.subrange(1,n)->collect(0.0) ;
    var d1 : double ; d1 := 0 ;
    var d2 : double ; d2 := 0 ;
    var d3 : double ; d3 := 0 ;
    var d_infinite : double ; d_infinite := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := (x_st[i+1])->toReal() ; 
     y[i+1] := (y_st[i+1])->toReal() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     distance[i+1] := if x[i+1] - y[i+1] < 0 then -(x[i+1] - y[i+1]) else x[i+1] - y[i+1] endif ; 
     d1 := d1+(distance[i+1]) ; 
    d2 := d2+(distance[i+1]->pow(2)) ; 
    d3 := d3+(distance[i+1]->pow(3)) ; 
    if (d_infinite < distance[i+1]) then     d_infinite := distance[i+1] ; else skip ; 
 )  ;     i := i + 1 ) ; 
    d2 := d2->pow(1. / 2) ; 
    d3 := d3->pow(1. / 3) ; 
    OclFile["System.out"].println(d1 + "\n" + d2 + "\n" + d3 + "\n" + d_infinite) ; 
 )   catch (e : ProgramException) do (     OclFile["System.out"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.PrintWriter ;
import java.text.DecimalFormat ;
import java.util.Scanner ;
class Main {
  private static final Scanner sc=new Scanner(System.in);
  private static final DecimalFormat fmt=new DecimalFormat("0.########");
  private static final PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] Args)throws IOException {
    final int n=Integer.parseInt(sc.next());
    final int x[]=new int[n];
    for(int i=0 ; i<n ; i++)x[i]=Integer.parseInt(sc.next());
    int d1=0,d2=0,di=0 ;
    long d3=0 ;
    for(int i=0 ; i<n ; i++){
      final int y=Math.abs(Integer.parseInt(sc.next())-x[i]);
      d1+=y ;
      d2+=y*y ;
      d3+=y*y*y ;
      di=Math.max(di,y);
    }
    out.println(d1);
    out.println(fmt.format(Math.sqrt(d2)));
    out.println(fmt.format(Math.pow(d3,1.0/3.0)));
    out.println(di);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute fmt : DecimalFormat := DecimalFormat.newDecimalFormat("0.########");
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( Args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (sc.getCurrent())->toInteger() ;
     var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     x[i+1] := (sc.getCurrent())->toInteger() ;  ;     i := i + 1 ) ; 
    var d1 : int ; d1 := 0 ;
    var d2 : int ; d2 := 0 ;
    var di : int ; di := 0 ;
    var d3 : long ; d3 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var y : int ; y := if (sc.getCurrent())->toInteger() - x[i+1] < 0 then -((sc.getCurrent())->toInteger() - x[i+1]) else (sc.getCurrent())->toInteger() - x[i+1] endif ;
     d1 := d1+(y) ; 
    d2 := d2+(y * y) ; 
    d3 := d3+(y * y * y) ; 
    di := Set{di, y}->max() ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[] vect1=new int[n];
    int[] vect2=new int[n];
    double keisan=0.0 ;
    double inf=Double.POSITIVE_INFINITY ;
    for(int i=0 ; i<n ; i++){
      vect1[i]=scan.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      vect2[i]=scan.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      double zet=0 ;
      zet=vect1[i]-vect2[i];
      zet=Math.abs(zet);
      zet=Math.pow(zet,1);
      keisan+=zet ;
    }
    keisan=Math.pow(keisan,(1.0/1.0));
    System.out.println(keisan);
    keisan=0.0 ;
    for(int i=0 ; i<n ; i++){
      double zet=0 ;
      zet=vect1[i]-vect2[i];
      zet=Math.abs(zet);
      zet=Math.pow(zet,2);
      keisan+=zet ;
    }
    keisan=Math.pow(keisan,(1.0/2.0));
    System.out.println(keisan);
    keisan=0.0 ;
    for(int i=0 ; i<n ; i++){
      double zet=0 ;
      zet=vect1[i]-vect2[i];
      zet=Math.abs(zet);
      zet=Math.pow(zet,3);
      keisan+=zet ;
    }
    keisan=Math.pow(keisan,(1.0/3.0));
    System.out.println(keisan);
    keisan=0.0 ;
    for(int i=0 ; i<n ; i++){
      double zet=0 ;
      zet=vect1[i]-vect2[i];
      zet=Math.abs(zet);
      if(zet>keisan){
        keisan=zet ;
      }
    }
    System.out.println(keisan);
    keisan=0.0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var vect1 : Sequence(int) ; vect1 := Integer.subrange(1,n)->collect(0) ;
    var vect2 : Sequence(int) ; vect2 := Integer.subrange(1,n)->collect(0) ;
    var keisan : double ; keisan := 0.0 ;
    var inf : double ; inf := Math_PINFINITY ;
        var i : int ; i := 0 ; while i < n do ( (     vect1[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     vect2[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var zet : double ; zet := 0 ;
     zet := vect1[i+1] - vect2[i+1] ; 
    zet := if zet < 0 then -(zet) else zet endif ; 
    zet := zet->pow(1) ; 
    keisan := keisan+(zet) ; 
 )  ;     i := i + 1 ) ; 
    keisan := keisan->pow((1.0 / 1.0)) ; 
    OclFile["System.out"].println(keisan) ; 
    keisan := 0.0 ; 
        var i : int ; i := 0 ; while i < n do ( (     var zet : double ; zet := 0 ;
     zet := vect1[i+1] - vect2[i+1] ; 
    zet := if zet < 0 then -(zet) else zet endif ; 
    zet := zet->pow(2) ; 
    keisan := keisan+(zet) ; 
 )  ;     i := i + 1 ) ; 
    keisan := keisan->pow((1.0 / 2.0)) ; 
    OclFile["System.out"].println(keisan) ; 
    keisan := 0.0 ; 
        var i : int ; i := 0 ; while i < n do ( (     var zet : double ; zet := 0 ;
     zet := vect1[i+1] - vect2[i+1] ; 
    zet := if zet < 0 then -(zet) else zet endif ; 
    zet := zet->pow(3) ; 
    keisan := keisan+(zet) ; 
 )  ;     i := i + 1 ) ; 
    keisan := keisan->pow((1.0 / 3.0)) ; 
    OclFile["System.out"].println(keisan) ; 
    keisan := 0.0 ; 
        var i : int ; i := 0 ; while i < n do ( (     var zet : double ; zet := 0 ;
     zet := vect1[i+1] - vect2[i+1] ; 
     zet := if zet < 0 then -(zet) else zet endif ; 
     if (zet > keisan) then (     keisan := zet ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(keisan) ; 
    keisan := 0.0 ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static final int BIG_NUM=2000000000 ;
  public static final int MOD=1000000007 ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    double x[]=new double[100];
    double y[]=new double[100];
    double p_1=0,p_2=0,p_3=0,p_infinity=-1 ;
    int N=scanner.nextInt();
    for(int i=0 ; i<N ; i++)x[i]=scanner.nextDouble();
    for(int i=0 ; i<N ; i++)y[i]=scanner.nextDouble();
    for(int i=0 ; i<N ; i++){
      p_1+=Math.abs(x[i]-y[i]);
      p_2+=(x[i]-y[i])*(x[i]-y[i]);
      p_3+=Math.abs((x[i]-y[i])*(x[i]-y[i])*(x[i]-y[i]));
      p_infinity=Math.max(p_infinity,Math.abs(x[i]-y[i]));
    }
    System.out.printf("%.10f\n",p_1);
    System.out.printf("%.10f\n",Math.sqrt(p_2));
    System.out.printf("%.10f\n",Math.cbrt(p_3));
    System.out.printf("%.10f\n",p_infinity);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BIG_NUM : int := 2000000000;
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : Sequence(double) ; x := Integer.subrange(1,100)->collect(0.0) ;
    var y : Sequence(double) ; y := Integer.subrange(1,100)->collect(0.0) ;
    var p    var pdouble : double ; pdouble := 0 : double ; p    var pdouble : double ; pdouble := 0 := 0 ;
    var p0 : double ; p0 := 0 ;
    var p_3 : double ; p_3 := 0 ;
    var p_infinity : double ; p_infinity := -1 ;
    var N : int ; N := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < N do (     x[i+1] := scanner.getCurrent()->toReal() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do (     y[i+1] := scanner.getCurrent()->toReal() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     pp_1 := pp_1+(if x[i+1] - y[i+1] < 0 then -(x[i+1] - y[i+1]) else x[i+1] - y[i+1] endif) ; 
     p(x[i+1] - y[i+1]) * (x[i+1] - y[i+1]) := p(x[i+1] - y[i+1]) * (x[i+1] - y[i+1])+((x[i+1] - y[i+1]) * (x[i+1] - y[i+1])) ; 
     p_3 := p_3+(if (x[i+1] - y[i+1]) * (x[i+1] - y[i+1]) * (x[i+1] - y[i+1]) < 0 then -((x[i+1] - y[i+1]) * (x[i+1] - y[i+1]) * (x[i+1] - y[i+1])) else (x[i+1] - y[i+1]) * (x[i+1] - y[i+1]) * (x[i+1] - y[i+1]) endif) ; 
     p_infinity := Set{p_infinity, if x[i+1] - y[i+1] < 0 then -(x[i+1] - y[i+1]) else x[i+1] - y[i+1] endif}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.10f\n", p"%.10f\n") ; 
    OclFile["System.out"].printf("%.10f\n", (p_2)->sqrt()) ; 
    OclFile["System.out"].printf("%.10f\n", (p_3)->cbrt()) ; 
    OclFile["System.out"].printf("%.10f\n", p_infinity) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int BinarySearch(long low,long high,long b){
    long mid=0 ;
    while(low<high){
      mid=(low+high)/2 ;
      long ans=mid*mid+mid ;
      if(ans==b)return(int)mid ;
      else if(ans<b)low=mid+1 ;
      else high=mid ;
    }
    return(int)mid ;
  }
  public static void main(String[] args)throws Exception {
    try(Scanner sc=new Scanner(System.in)){
      while(true){
        long b=sc.nextLong();
        if(b==0)break ;
        b*=2 ;
        int max=BinarySearch(1,(long)Math.sqrt(b)+2,b);
        int size=1 ;
        int a=0 ;
        for(size=max ; size>0 ; size--){
          if(b % size!=0)continue ;
          else if((b/size-size+1)% 2!=0)continue ;
          a=(int)(b/size-size+1)/2 ;
          break ;
        }
        System.out.println(a+" "+size);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation BinarySearch( low : long, high : long, b : long) : int
  pre: true
  post: true
  activity: (     var mid : long ; mid := 0 ;
     while (low < high) do (     mid := (low + high) / 2 ; 
     var ans : long ; ans := mid * mid + mid ;
     if (ans = b) then     return mid->oclAsType(int) else     if (ans < b) then     low := mid + 1 else     high := mid ; ;  ) ; 
     return mid->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (true) do (     var b : long ; b := sc.getCurrent()->toLong() ;
     if (b = 0) then     break else skip ; 
    b := b*(2) ; 
    var max : int ; max := BinarySearch(1, (b)->sqrt()->oclAsType(long) + 2, b) ;
    var size : int ; size := 1 ;
    var a : int ; a := 0 ;
        size := max ; while size > 0 do ( (     if (b mod size /= 0) then     continue else     if ((b / size - size + 1) mod 2 /= 0) then     continue else skip ; ;  
     a := (b / size - size + 1)->oclAsType(int) / 2 ; 
     break )  ;     size := size - 1 ) ; 
    OclFile["System.out"].println(a + " " + size) ; 
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class aliceAndBob {
  public static long ans2 ;
  public static void gcd(long i,long j){
    if(i==0 || j==0){
      ans2=j+i ;
      return ;
    }
    if(i>=j){
      gcd(i % j,j);
    }
    else {
      gcd(j % i,i);
    }
  }
  public static void main(String[] args){
    Kattio io=new Kattio();
    long n=io.nextLong();
    long a=io.nextLong();
    long max=a ;
    long gcd=a ;
    for(long i=1 ; i<n ; i++){
      long b=io.nextLong();
      max=Math.max(max,b);
      ans2=0 ;
      gcd(gcd,b);
      gcd=ans2 ;
    }
    if(((max/gcd)-n)% 2==0){
      io.print("Bob");
    }
    else {
      io.print("Alice");
    }
    io.close();
  }
  static class Kattio extends PrintWriter {
    private BufferedReader r ;
    private StringTokenizer st ;
    public Kattio(){
      this(System.in,System.out);
    }
    public Kattio(InputStream i,OutputStream o){
      super(o);
      r=new BufferedReader(new InputStreamReader(i));
    }
    public Kattio(String problemName)throws IOException {
      super(problemName+".out");
      r=new BufferedReader(new FileReader(problemName+".in"));
    }
    public String next(){
      try {
        while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(r.readLine());
        return st.nextToken();
      }
      catch(Exception e){
      }
      return null ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class aliceAndBob {
  static   attribute ans2 : long;
  static   operation gcd( i : long, j : long) : void
  pre: true
  post: true
  activity: (     if (i = 0 or j = 0) then (     ans2 := j + i ; 
     return ) else skip ; 
     if (i >= j) then (     execute gcd(i mod j, j) ) else (     execute gcd(j mod i, i) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : Kattio ; io := Kattio.newKattio() ;
     var n : long ; n := io.nextLong() ;
    var a : long ; a := io.nextLong() ;
    var max : long ; max := a ;
    var gcd : long ; gcd := a ;
        var i : long ; i := 1 ; while i < n do ( (     var b : long ; b := io.nextLong() ;
     max := Set{max, b}->max() ; 
    ans2 := 0 ; 
    execute gcd(gcd, b) ; 
    gcd := ans2 ; 
 )  ;     i := i + 1 ) ; 
    if (((max / gcd) - n) mod 2 = 0) then (     io.print("Bob") ) else (     io.print("Alice") ) ;  
    io.close() ; 
 );
  static class Kattio extends OclFile {
   attribute r : OclFile;
   attribute st : OclIterator;
   static operation newKattio() : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile["System.in"], OclFile["System.out"]) );
   static operation newKattio( i : OclFile, o : OclFile) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(i, o);
    return self );
  operation initialise( i : OclFile, o : OclFile) : void
  pre: true  post: true
  activity: (     execute super(o) ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(i)) );
   static operation newKattio( problemName : String) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(problemName);
    return self );
  operation initialise( problemName : String) : void
  pre: true  post: true
  activity: (     execute super(problemName + ".out") ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(problemName + ".in")) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(r.readLine()) ; ; 
     return st.next() )   catch (e : ProgramException) do skip
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _835A_KeyRaces {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int s=input.nextInt();
    int v1=input.nextInt();
    int v2=input.nextInt();
    int t1=input.nextInt();
    int t2=input.nextInt();
    int r1=2*t1+s*v1 ;
    int r2=2*t2+s*v2 ;
    if(r1<r2){
      System.out.println("First");
    }
    else if(r2<r1){
      System.out.println("Second");
    }
    else {
      System.out.println("Friendship");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _835A_KeyRaces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : int ; s := input.getCurrent()->toInteger() ;
    var v1 : int ; v1 := input.getCurrent()->toInteger() ;
    var v2 : int ; v2 := input.getCurrent()->toInteger() ;
    var t1 : int ; t1 := input.getCurrent()->toInteger() ;
    var t2 : int ; t2 := input.getCurrent()->toInteger() ;
    var r1 : int ; r1 := 2 * t1 + s * v1 ;
    var r2 : int ; r2 := 2 * t2 + s * v2 ;
    if (r1 < r2) then (     OclFile["System.out"].println("First") ) else     if (r2 < r1) then (     OclFile["System.out"].println("Second") ) else (     OclFile["System.out"].println("Friendship") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B940 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int K=in.nextInt();
    long A=in.nextInt();
    long B=in.nextInt();
    long cost=0 ;
    while(N!=1){
      if(N<K){
        cost+=(N-1)*A ;
        break ;
      }
      int r=N % K ;
      cost+=r*A ;
      N-=r ;
      if(B>=(N-N/K)*A){
        cost+=(N-1)*A ;
        break ;
      }
      cost+=B ;
      N/=K ;
    }
    System.out.println(cost);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B940 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    var A : long ; A := in.getCurrent()->toInteger() ;
    var B : long ; B := in.getCurrent()->toInteger() ;
    var cost : long ; cost := 0 ;
    while (N /= 1) do (     if (N < K) then (     cost := cost+((N - 1) * A) ; 
     break ) else skip ; 
     var r : int ; r := N mod K ;
    cost := cost+(r * A) ; 
    N := N-(r) ; 
    if (B >= (N - N / K) * A) then (     cost := cost+((N - 1) * A) ; 
     break ) else skip ; 
    cost := cost+(B) ; 
    N := N/(K) ; 
 ) ; 
    OclFile["System.out"].println(cost) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class A835 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String line=scanner.nextLine();
    List<Integer>nums=Arrays.stream(line.split(" ")).map(Integer :: parseInt).collect(Collectors.toList());
    int charCount=nums.get(0);
    int timeOne=nums.get(1);
    int timeTwo=nums.get(2);
    int pingOne=nums.get(3);
    int pingTwo=nums.get(4);
    if(timeOne*charCount+pingOne*2>timeTwo*charCount+pingTwo*2){
      System.out.println("Second");
    }
    else if(timeOne*charCount+pingOne*2<timeTwo*charCount+pingTwo*2){
      System.out.println("First");
    }
    else {
      System.out.println("Friendship");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A835 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : String ; line := scanner.nextLine() ;
    var nums : Sequence(int) ; nums := stream(line->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) ).collect(Collectors.toList()) ;
    var charCount : int ; charCount := nums->at(0+1) ;
    var timeOne : int ; timeOne := nums->at(1+1) ;
    var timeTwo : int ; timeTwo := nums->at(2+1) ;
    var pingOne : int ; pingOne := nums->at(3+1) ;
    var pingTwo : int ; pingTwo := nums->at(4+1) ;
    if (timeOne * charCount + pingOne * 2 > timeTwo * charCount + pingTwo * 2) then (     OclFile["System.out"].println("Second") ) else     if (timeOne * charCount + pingOne * 2 < timeTwo * charCount + pingTwo * 2) then (     OclFile["System.out"].println("First") ) else (     OclFile["System.out"].println("Friendship") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.Arrays ;
import java.util.Scanner ;
public class giuhiuhi {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int s=sc.nextInt();
    int v1=sc.nextInt();
    int v2=sc.nextInt();
    int t1=sc.nextInt();
    int t2=sc.nextInt();
    int sum1=t1*2+s*v1 ;
    int sum2=t2*2+s*v2 ;
    if(sum1==sum2){
      System.out.println("Friendship");
    }
    else if(sum1>sum2){
      System.out.println("Second");
    }
    else {
      System.out.println("First");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class giuhiuhi {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : int ; s := sc.getCurrent()->toInteger() ;
    var v1 : int ; v1 := sc.getCurrent()->toInteger() ;
    var v2 : int ; v2 := sc.getCurrent()->toInteger() ;
    var t1 : int ; t1 := sc.getCurrent()->toInteger() ;
    var t2 : int ; t2 := sc.getCurrent()->toInteger() ;
    var sum1 : int ; sum1 := t1 * 2 + s * v1 ;
    var sum2 : int ; sum2 := t2 * 2 + s * v2 ;
    if (sum1 = sum2) then (     OclFile["System.out"].println("Friendship") ) else     if (sum1 > sum2) then (     OclFile["System.out"].println("Second") ) else (     OclFile["System.out"].println("First") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class _835A_KeyRaces {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int s=in.nextInt();
    int v1=in.nextInt();
    int v2=in.nextInt();
    int t1=in.nextInt();
    int t2=in.nextInt();
    int resF=s*v1+(2*t1);
    int resS=s*v2+(2*t2);
    if(resF<resS){
      System.out.println("First");
    }
    else if(resS<resF){
      System.out.println("Second");
    }
    else {
      System.out.println("Friendship");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _835A_KeyRaces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : int ; s := in.getCurrent()->toInteger() ;
    var v1 : int ; v1 := in.getCurrent()->toInteger() ;
    var v2 : int ; v2 := in.getCurrent()->toInteger() ;
    var t1 : int ; t1 := in.getCurrent()->toInteger() ;
    var t2 : int ; t2 := in.getCurrent()->toInteger() ;
    var resF : int ; resF := s * v1 + (2 * t1) ;
    var resS : int ; resS := s * v2 + (2 * t2) ;
    if (resF < resS) then (     OclFile["System.out"].println("First") ) else     if (resS < resF) then (     OclFile["System.out"].println("Second") ) else (     OclFile["System.out"].println("Friendship") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long count_of_ways(long n){
    long count=0 ;
    for(int i=0 ; i<=n ; i++)for(int j=0 ; j<=n ; j++)for(int k=0 ; k<=n ; k++)if(i+j+k==n)count++;
    return count ;
  }
  public static void main(String[] args){
    long n=3 ;
    System.out.println(count_of_ways(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count_of_ways( n : long) : long
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
         var i : int ; i := 0 ; while i <= n do (         var j : int ; j := 0 ; while j <= n do (         var k : int ; k := 0 ; while k <= n do (     if (i + j + k = n) then     count := count + 1 ; else skip ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 3 ;
     OclFile["System.out"].println(count_of_ways(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    System.out.println(solve(s));
    sc.close();
  }
  static int solve(String s){
    return Math.min(s.length(),(int)s.chars().filter(ch->ch=='a').count()*2-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
     OclFile["System.out"].println(solve(s)) ; 
     skip );
  static   operation solve( s : String) : int
  pre: true
  post: true
  activity: (     return Set{s->size(), s.chars()->select( _x1 | (lambda ch : OclAny in ch = 'a')->apply(_x1) )->size()->oclAsType(int) * 2 - 1}->min() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MAIN {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String linea=sc.nextLine();
    int con=0 ;
    int total=0 ;
    for(int i=0 ; i<linea.length(); i++){
      if(String.valueOf(linea.charAt(i)).equals("a"))con++;
    }
    total=con+con-1 ;
    if(total>=linea.length())System.out.println(linea.length());
    else System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MAIN {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var linea : String ; linea := sc.nextLine() ;
    var con : int ; con := 0 ;
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < linea->size() do ( (     if (((linea->at(i+1)) + "") = "a") then     con := con + 1 ; else skip )  ;     i := i + 1 ) ; 
    total := con + con - 1 ; 
    if (total >= linea->size()) then     OclFile["System.out"].println(linea->size()) else     OclFile["System.out"].println(total) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int count=0 ;
    for(char c : s.toCharArray())if(c=='a')count++;
    System.out.println(Math.min(s.length(),Math.max(0,2*count-1)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var count : int ; count := 0 ;
    for (c : s->characters()) do (     if (c = 'a') then     count := count + 1 ; else skip ;  ) ; 
    OclFile["System.out"].println(Set{s->size(), Set{0, 2 * count - 1}->max()}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1146A_LoveA {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String str=input.next();
    int a=0 ;
    int nona=0 ;
    for(char c : str.toCharArray()){
      if(c=='a'){
        a++;
      }
      else {
        nona++;
      }
    }
    if(a>nona){
      System.out.println(str.length());
    }
    else {
      System.out.println(2*a-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1146A_LoveA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := input.getCurrent() ;
    var a : int ; a := 0 ;
    var nona : int ; nona := 0 ;
    for (c : str->characters()) do ( (     if (c = 'a') then (     a := a + 1 ) else (     nona := nona + 1 ) )  ) ; 
    if (a > nona) then (     OclFile["System.out"].println(str->size()) ) else (     OclFile["System.out"].println(2 * a - 1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuffer sb=new StringBuffer();
    while(true){
      int n=Integer.parseInt(br.readLine());
      if(n==0){
        break ;
      }
      int from=1 ;
      int to=calcN(n);
      long sum=calcSum(to);
      int m=0 ;
      int a=0 ;
      for(int i=calcN(n); i>=1 ; i--){
        if(2*n % i==0){
          int tmp2a=2*n/i-i+1 ;
          if(tmp2a % 2==0 && tmp2a>=2){
            m=i ;
            a=tmp2a/2 ;
            break ;
          }
        }
      }
      sb.append(a+" "+m+"\n");
    }
    System.out.print(sb);
  }
  static int calcN(long sum){
    return(int)Math.ceil((-1+Math.sqrt(1+(double)8*sum))/2);
  }
  static long calcSum(long n){
    return(n*(n+1)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
     while (true) do (     var n : int ; n := (br.readLine())->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var from : int ; from := 1 ;
    var to : int ; to := calcN(n) ;
    var sum : long ; sum := calcSum(to) ;
    var m : int ; m := 0 ;
    var a : int ; a := 0 ;
        var i : int ; i := calcN(n) ; while i >= 1 do ( (     if (2 * n mod i = 0) then (     var tmp2a : int ; tmp2a := 2 * n / i - i + 1 ;
     if (tmp2a mod 2 = 0 & tmp2a >= 2) then (     m := i ; 
     a := tmp2a / 2 ; 
     break ) else skip ) else skip )  ;     i := i - 1 ) ; 
    sb := sb + StringLib.newString(a + " " + m + "\n") ; 
 ) ; 
     OclFile["System.out"].print(sb) );
  static   operation calcN( sum : long) : int
  pre: true
  post: true
  activity: (     return ((-1 + (1 + 8->oclAsType(double) * sum)->sqrt()) / 2)->ceil()->oclAsType(int) );
  static   operation calcSum( n : long) : long
  pre: true
  post: true
  activity: (     return (n * (n + 1) / 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; ++i){
        a[i]=sc.nextInt();
      }
      System.out.println(solve(a));
    }
    sc.close();
  }
  static int solve(int[] a){
    int zeroCount=(int)Arrays.stream(a).filter(x->x==0).count();
    return zeroCount+((Arrays.stream(a).sum()+zeroCount==0)? 1 : 0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(solve(a)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var zeroCount : int ; zeroCount := stream(a)->select( _x1 | (lambda x : OclAny in x = 0)->apply(_x1) )->size()->oclAsType(int) ;
     return zeroCount + (if (stream(a)->sum() + zeroCount = 0) then 1 else 0 endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemB {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    long x=scn.nextInt();
    long y=scn.nextInt();
    long n=scn.nextInt();
    int mod=(int)(1e9)+7 ;
    long[] arr={
      x,y,y-x,-x,-y,x-y };
      System.out.println(((arr[(int)((n-1)% 6)] % mod)+mod)% mod);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := scn.getCurrent()->toInteger() ;
    var y : long ; y := scn.getCurrent()->toInteger() ;
    var n : long ; n := scn.getCurrent()->toInteger() ;
    var mod : int ; mod := (1e9)->oclAsType(int) + 7 ;
    var arr : Sequence(long) ; arr := Sequence{x,y,y - x,-x,-y,x - y} ;
    OclFile["System.out"].println(((arr[((n - 1) mod 6)->oclAsType(int)+1] mod mod) + mod) mod mod) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long n=in.nextLong(),k=in.nextLong(),A=in.nextLong(),B=in.nextLong();
    if(k==1){
      pw.println((n-1)*A);
      pw.close();
      return ;
    }
    long ans=0 ;
    while(n!=1){
      if(n<k){
        ans+=(n-1)*A ;
        break ;
      }
      ans+=(n % k)*A ;
      n-=(n % k);
      if(B>=(n-n/k)*A){
        ans+=(n-n/k)*A ;
        n/=k ;
      }
      else {
        ans+=B ;
        n/=k ;
      }
    }
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := in.getCurrent()->toLong() ;
    var k : long ; k := in.getCurrent()->toLong() ;
    var A : long ; A := in.getCurrent()->toLong() ;
    var B : long ; B := in.getCurrent()->toLong() ;
    if (k = 1) then (     skip ; 
     skip ; 
     return ) else skip ; 
    var ans : long ; ans := 0 ;
    while (n /= 1) do (     if (n < k) then (     ans := ans+((n - 1) * A) ; 
     break ) else skip ; 
     ans := ans+((n mod k) * A) ; 
     n := n-((n mod k)) ; 
     if (B >= (n - n / k) * A) then (     ans := ans+((n - n / k) * A) ; 
     n := n/(k) ) else (     ans := ans+(B) ; 
     n := n/(k) ) ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main implements Runnable {
  BufferedReader in ;
  PrintWriter out ;
  StringTokenizer tok=new StringTokenizer("");
  public static void main(String[] args){
    new Thread(null,new Main(),"",256*(1L<<20)).start();
  }
  public void run(){
    try {
      long t1=System.currentTimeMillis();
      if(System.getProperty("ONLINE_JUDGE")!=null){
        in=new BufferedReader(new InputStreamReader(System.in));
        out=new PrintWriter(System.out);
      }
      else {
        in=new BufferedReader(new FileReader("input.txt"));
        out=new PrintWriter("output.txt");
      }
      Locale.setDefault(Locale.US);
      solve();
      in.close();
      out.close();
      long t2=System.currentTimeMillis();
      System.err.println("Time="+(t2-t1));
    }
    catch(Throwable t){
      t.printStackTrace(System.err);
      System.exit(-1);
    }
  }
  String readString()throws IOException {
    while(! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  int readInt()throws IOException {
    return Integer.parseInt(readString());
  }
  long readLong()throws IOException {
    return Long.parseLong(readString());
  }
  double readDouble()throws IOException {
    return Double.parseDouble(readString());
  }
  void solve()throws IOException {
    int tests=readInt();
    for(int i=0 ; i<tests ; i++){
      int len=readInt();
      int sum=0 ;
      int ops=0 ;
      for(int j=0 ; j<len ; j++){
        int x=readInt();
        sum+=x ;
        if(x==0){
          ops++;
          sum++;
        }
      }
      if(sum==0){
        ops++;
      }
      out.println(ops);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
   attribute in : OclFile;
   attribute out : OclFile;
   attribute tok : OclIterator := OclIterator.newOclIterator_String("");
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(null, Main.newMain(), "", 256 * ((1L*(2->pow(20)))->oclAsType(long))).start() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     var t1 : long ; t1 := OclDate.getSystemTime() ;
     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") /= null) then (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ) else (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ) ;  
    Locale.setDefault(Locale.US) ; 
    execute solve() ; 
    skip ; 
    skip ; 
    var t2 : long ; t2 := OclDate.getSystemTime() ;
    OclFile["System.err"].println("Time=" + (t2 - t1)) ; 
 )   catch (t : OclException) do (     t.printStackTrace(OclFile["System.err"]) ; 
 OclProcess.exit(-1) )
 );
   operation readString() : String
  pre: true
  post: true
  activity: (     while (not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return tok.next() );
   operation readInt() : int
  pre: true
  post: true
  activity: (     return (readString())->toInteger() );
   operation readLong() : long
  pre: true
  post: true
  activity: (     return (readString())->toLong() );
   operation readDouble() : double
  pre: true
  post: true
  activity: (     return (readString())->toReal() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var tests : int ; tests := readInt() ;
         var i : int ; i := 0 ; while i < tests do ( (     var len : int ; len := readInt() ;
     var sum : int ; sum := 0 ;
    var ops : int ; ops := 0 ;
        var j : int ; j := 0 ; while j < len do ( (     var x : int ; x := readInt() ;
     sum := sum+(x) ; 
     if (x = 0) then (     ops := ops + 1 ; 
     sum := sum + 1 ) else skip )  ;     j := j + 1 ) ; 
    if (sum = 0) then (     ops := ops + 1 ) else skip ; 
    skip ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class P1300A {
  public static void main(String[] args)throws IOException {
    BufferedReader io=new BufferedReader(new InputStreamReader(System.in));
    Integer cnt=Integer.valueOf(io.readLine());
    List<Integer>rs=new ArrayList<Integer>();
    while(cnt>0){
      cnt--;
      Integer len=Integer.valueOf(io.readLine());
      String[] input=io.readLine().split(" ");
      Boolean flag=false ;
      Integer tmp=0 ;
      while(! flag){
        Integer sum=0 ;
        boolean allNegative=true ;
        for(int i=0 ; i<input.length ; i++){
          sum=sum+Integer.valueOf(input[i]);
          if(input[i] .equals("0")){
            input[i]="1" ;
            sum++;
            tmp++;
          }
          if(Integer.valueOf(input[i]).compareTo(0)>0){
            allNegative=false ;
          }
        }
        if(sum.compareTo(0)==0){
          if(! allNegative){
            tmp++;
            flag=true ;
          }
        }
        else if(sum.compareTo(0)!=0){
          flag=true ;
        }
      }
      rs.add(tmp);
    }
    for(Integer integer : rs){
      System.out.println(integer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P1300A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var cnt : int ; cnt := (io.readLine())->toInteger() ;
    var rs : Sequence(int) ; rs := Sequence{} ;
    while (cnt > 0) do (     cnt := cnt - 1 ; 
     var len : int ; len := (io.readLine())->toInteger() ;
    var input : Sequence(String) ; input := io.readLine()->split(" ") ;
    var flag : Boolean ; flag := false ;
    var tmp : int ; tmp := 0 ;
    while (not(flag)) do (     var sum : int ; sum := 0 ;
     var allNegative : boolean ; allNegative := true ;
         var i : int ; i := 0 ; while i < input->size() do ( (     sum := sum + (input[i+1])->toInteger() ; 
     if (input[i+1] = "0") then (     input[i+1] := "1" ; 
     sum := sum + 1 ; 
     tmp := tmp + 1 ) else skip ; 
     if ((input[i+1])->toInteger()->compareTo(0) > 0) then (     allNegative := false ) else skip )  ;     i := i + 1 ) ; 
     if (sum->compareTo(0) = 0) then (     if (not(allNegative)) then (     tmp := tmp + 1 ; 
     flag := true ) else skip ) else     if (sum->compareTo(0) /= 0) then (     flag := true ) else skip ; ) ; 
    rs := rs->including(tmp) ; 
 ) ; 
    for (integer : rs) do ( (     OclFile["System.out"].println(integer) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder();
    int t=fs.nextInt();
    while(t-->0){
      int n=fs.nextInt();
      int ch=0,res=0 ;
      for(int i=0 ; i<n ; i++){
        int a=fs.nextInt();
        if(a==0){
++ch ;
++res ;
        }
        else {
          res+=a ;
        }
      }
      if(res==0)++ch ;
      sb.append(ch).append("\n");
    }
    out.println(sb);
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    var t : int ; t := fs.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := fs.nextInt() ;
     var ch : int ; ch := 0 ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := fs.nextInt() ;
     if (a = 0) then (     ch := ch + 1 ; 
     res := res + 1 ) else (     res := res+(a) ) )  ;     i := i + 1 ) ; 
    if (res = 0) then     ch := ch + 1 ; else skip ; 
    sb := sb + StringLib.newString(ch) + StringLib.newString("\n") ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class _805B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String a="aabb" ;
    while(a.length()<n){
      a+=a ;
    }
    System.out.println(a.substring(0,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class _805B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : String ; a := "aabb" ;
    while (a->size() < n) do (     a := a+(a) ) ; 
    OclFile["System.out"].println(a.subrange(0+1,n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class _3_Palindrome {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    StringBuilder sb=new StringBuilder();
    int i=0 ;
    boolean appendA=true ;
    while(i<n && i+1<n){
      if(appendA)sb.append("aa");
      else sb.append("bb");
      appendA=! appendA ;
      i+=2 ;
    }
    if((i<n)){
      if(appendA){
        sb.append("a");
      }
      else {
        sb.append("b");
      }
    }
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class _3_Palindrome {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
    var i : int ; i := 0 ;
    var appendA : boolean ; appendA := true ;
    while (i < n & i + 1 < n) do (     if (appendA) then     sb := sb + StringLib.newString("aa") else     sb := sb + StringLib.newString("bb") ; ;  
     appendA := not(appendA) ; 
     i := i+(2) ) ; 
    if ((i < n)) then (     if (appendA) then (     sb := sb + StringLib.newString("a") ) else (     sb := sb + StringLib.newString("b") ) ) else skip ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class B_3_palindrome {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    char[] arr=new char[t];
    Arrays.fill(arr,'a');
    for(int i=2 ; i<arr.length ; i+=4){
      arr[i]='b' ;
      if(i+1<arr.length)arr[i+1]='b' ;
    }
    System.out.println(new String(arr));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_3_palindrome {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := Integer.subrange(1,t)->collect(0) ;
    arr := arr->collect('a') ; 
        var i : int ; i := 2 ; while i < arr->size() do ( (     arr[i+1] := 'b' ; 
     if (i + 1 < arr->size()) then     arr[i + 1+1] := 'b' ; else skip )  ;     i := i+(4) ) ; 
    OclFile["System.out"].println(StringLib.newString(arr)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void pattern(int n){
    int i,j ;
    for(i=n-1 ; i>=0 ; i--){
      for(j=n-1 ; j>i ; j--){
        System.out.print(" ");
      }
      System.out.print((char)(i+65));
      for(j=1 ; j<(i*2); j++)System.out.print(" ");
      if(i>=1)System.out.print((char)(i+65));
      System.out.print("\n");
    }
  }
  public static void main(String args[]){
    int n=5 ;
    pattern(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pattern( n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := n - 1 ; while i >= 0 do ( (         j := n - 1 ; while j > i do ( (     OclFile["System.out"].print(" ") )  ;     j := j - 1 ) ; 
     OclFile["System.out"].print((i + 65)->oclAsType(String)) ; 
        j := 1 ; while j < (i * 2) do (     OclFile["System.out"].print(" ") ;  ;     j := j + 1 ) ; 
    if (i >= 1) then     OclFile["System.out"].print((i + 65)->oclAsType(String)) ; else skip ; 
    OclFile["System.out"].print("\n") ; 
 )  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute pattern(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void pattern(int n){
    int i,j,k=0 ;
    for(i=n-1 ; i>=0 ; i--){
      for(j=n-1 ; j>k ; j--){
        System.out.print(" ");
      }
      System.out.print((char)(i+65));
      for(j=1 ; j<(k*2); j++)System.out.print(" ");
      if(i<n-1)System.out.print((char)(i+65));
      System.out.print("\n");
      k++;
    }
  }
  public static void main(String args[]){
    int n=5 ;
    pattern(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pattern( n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var k : int ; k := 0 ;
         i := n - 1 ; while i >= 0 do ( (         j := n - 1 ; while j > k do ( (     OclFile["System.out"].print(" ") )  ;     j := j - 1 ) ; 
     OclFile["System.out"].print((i + 65)->oclAsType(String)) ; 
        j := 1 ; while j < (k * 2) do (     OclFile["System.out"].print(" ") ;  ;     j := j + 1 ) ; 
    if (i < n - 1) then     OclFile["System.out"].print((i + 65)->oclAsType(String)) ; else skip ; 
    OclFile["System.out"].print("\n") ; 
    k := k + 1 ; 
 )  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute pattern(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int changeTheArray(int arr[],int n){
    int minEle=Arrays.stream(arr).min().getAsInt();
    int maxEle=Arrays.stream(arr).max().getAsInt();
    int minOperations=Integer.MAX_VALUE ;
    for(int num=minEle ; num<=maxEle ; num++){
      int operations=0 ;
      for(int i=0 ; i<n ; i++){
        if(arr[i]!=num){
          operations+=(Math.abs(num-arr[i])-1);
        }
      }
      minOperations=Math.min(minOperations,operations);
    }
    return minOperations ;
  }
  public static void main(String args[]){
    int arr[]={
      10,1,4 };
      int n=arr.length ;
      System.out.println(changeTheArray(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation changeTheArray( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var minEle : int ; minEle := stream(arr).min().getAsInt() ;
     var maxEle : int ; maxEle := stream(arr).max().getAsInt() ;
    var minOperations : int ; minOperations := 2147483647 ;
        var num : int ; num := minEle ; while num <= maxEle do ( (     var operations : int ; operations := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] /= num) then (     operations := operations+((if num - arr[i+1] < 0 then -(num - arr[i+1]) else num - arr[i+1] endif - 1)) ) else skip )  ;     i := i + 1 ) ; 
     minOperations := Set{minOperations, operations}->min() )  ;     num := num + 1 ) ; 
    return minOperations 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,1,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(changeTheArray(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  static int B ;
  static int num ;
  static int left,right ;
  public static void main(String args[])throws IOException {
    Scanner scan=new Scanner(System.in);
    for(B=scan.nextInt(); B>0 ; B=scan.nextInt()){
      left=1 ;
      right=1 ;
      num=0 ;
      for(int i=1 ; ; i++){
        num+=i ;
        right=i ;
        if(num>=B){
          break ;
        }
      }
      while(true){
        if(num==B){
          System.out.println(left+" "+(right-left+1));
          break ;
        }
        else if(num>B){
          Numdec();
        }
        else if(num<B){
          NumInc();
        }
      }
    }
    scan.close();
  }
  public static void NumInc(){
    while(num<B){
      right++;
      num+=right-left ;
      left++;
    }
    if(num/2>B){
      left=B ;
      right=B ;
    }
  }
  public static void Numdec(){
    while(num>B){
      num-=left ;
      left++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute B : int;
  static   attribute num : int;
  static   attribute left : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         B := scan.getCurrent()->toInteger() ; while B > 0 do ( (     left := 1 ; 
     right := 1 ; 
    num := 0 ; 
        var i : int ; i := 1 ; while true do ( (     num := num+(i) ; 
     right := i ; 
     if (num >= B) then (     break ) else skip )  ;     i := i + 1 ) ; 
    while (true) do (     if (num = B) then (     OclFile["System.out"].println(left + " " + (right - left + 1)) ; 
     break ) else     if (num > B) then (     execute Numdec() ) else     if (num < B) then (     execute NumInc() ) else skip ; ;  ) ; 
 )  ;     B := scan.getCurrent()->toInteger() ) ; 
     skip );
  static   operation NumInc() : void
  pre: true
  post: true
  activity: (     while (num < B) do (     right := right + 1 ; 
     num := num+(right - left) ; 
     left := left + 1 ) ; 
     if (num / 2 > B) then (     left := B ; 
     right := B ) else skip );
  static   operation Numdec() : void
  pre: true
  post: true
  activity: (     while (num > B) do (     num := num-(left) ; 
     left := left + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long n=in.nextLong(),k=in.nextLong(),A=in.nextLong(),B=in.nextLong();
    long ans=0 ;
    while(n!=1){
      if(n<k){
        ans+=(n-1)*A ;
        break ;
      }
      ans+=(n % k)*A ;
      n-=(n % k);
      if(B>=(n-n/k)*A){
        ans+=(n-1)*A ;
        break ;
      }
      ans+=B ;
      n/=k ;
    }
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := in.getCurrent()->toLong() ;
    var k : long ; k := in.getCurrent()->toLong() ;
    var A : long ; A := in.getCurrent()->toLong() ;
    var B : long ; B := in.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
    while (n /= 1) do (     if (n < k) then (     ans := ans+((n - 1) * A) ; 
     break ) else skip ; 
     ans := ans+((n mod k) * A) ; 
    n := n-((n mod k)) ; 
    if (B >= (n - n / k) * A) then (     ans := ans+((n - 1) * A) ; 
     break ) else skip ; 
    ans := ans+(B) ; 
    n := n/(k) ; 
 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CodeForces {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    int c2=0 ;
    int c1=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==1){
        c1++;
      }
      else {
        c2++;
      }
    }
    int a[]=new int[n];
    if(c1==0){
      for(int i=0 ; i<n ; i++){
        a[i]=2 ;
      }
    }
    else if(c2==0){
      for(int i=0 ; i<n ; i++){
        a[i]=1 ;
      }
    }
    else {
      if(n==1){
        if(arr[0]==2){
          a[0]=2 ;
        }
        else {
          a[0]=1 ;
        }
      }
      else {
        if(c2>0){
          a[0]=2 ;
          a[1]=1 ;
          c2--;
          for(int i=2 ; i<n ; i++){
            if(c2>0){
              a[i]=2 ;
              c2--;
            }
            else {
              a[i]=1 ;
            }
          }
        }
        else {
          for(int i=0 ; i<n ; i++){
            a[i]=1 ;
          }
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(a[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var c2 : int ; c2 := 0 ;
    var c1 : int ; c1 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 1) then (     c1 := c1 + 1 ) else (     c2 := c2 + 1 ) )  ;     i := i + 1 ) ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    if (c1 = 0) then (         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := 2 )  ;     i := i + 1 ) ) else     if (c2 = 0) then (         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := 1 )  ;     i := i + 1 ) ) else (     if (n = 1) then (     if (arr[0+1] = 2) then (     a[0+1] := 2 ) else (     a[0+1] := 1 ) ) else (     if (c2 > 0) then (     a[0+1] := 2 ; 
     a[1+1] := 1 ; 
     c2 := c2 - 1 ; 
         var i : int ; i := 2 ; while i < n do ( (     if (c2 > 0) then (     a[i+1] := 2 ; 
     c2 := c2 - 1 ) else (     a[i+1] := 1 ) )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := 1 )  ;     i := i + 1 ) ) ) ) ;  ;  
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(a[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.awt.Point ;
import java.math.BigInteger ;
public final class Main {
  BufferedReader br ;
  StringTokenizer stk ;
  public static void main(String[] args)throws Exception {
    new Main().run();
  }
  {
    stk=null ;
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  void run()throws Exception {
    int n=ni();
    int ones=0,twos=0 ;
    for(int i=0 ; i<n ; i++){
      int num=ni();
      if(num==1){
        ones++;
      }
      else {
        twos++;
      }
    }
    StringBuilder res=new StringBuilder(n<<2);
    for(int i=0 ; i<n ; i++){
      if(i==0 || i>1){
        if(twos>0){
          res.append("2").append(" ");
          twos--;
        }
        else {
          res.append("1").append(" ");
          ones--;
        }
      }
      else if(i==1){
        if(ones>0){
          res.append("1").append(" ");
          ones--;
        }
        else {
          res.append("2").append(" ");
          twos--;
        }
      }
    }
    pl(res.deleteCharAt(res.length()-1));
  }
  String nextToken()throws Exception {
    if(stk==null || ! stk.hasMoreTokens()){
      stk=new StringTokenizer(br.readLine()," ");
    }
    return stk.nextToken();
  }
  String nt()throws Exception {
    return nextToken();
  }
  String ns()throws Exception {
    return br.readLine();
  }
  int ni()throws Exception {
    return Integer.parseInt(nextToken());
  }
  long nl()throws Exception {
    return Long.parseLong(nextToken());
  }
  double nd()throws Exception {
    return Double.parseDouble(nextToken());
  }
  void p(Object o){
    System.out.print(o);
  }
  void pl(Object o){
    System.out.println(o);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute br : OclFile;
   attribute stk : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
  operation initialiseInstance()
  pre: true post: true
  activity:     stk := null ; 
    br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := ni() ;
     var ones : int ; ones := 0 ;
    var twos : int ; twos := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := ni() ;
     if (num = 1) then (     ones := ones + 1 ) else (     twos := twos + 1 ) )  ;     i := i + 1 ) ; 
    var res : String ; res := StringLib.newString((n*(2->pow(2)))->oclAsType(long)) ;
        var i : int ; i := 0 ; while i < n do ( (     if (i = 0 or i > 1) then (     if (twos > 0) then (     res := res + StringLib.newString("2") + StringLib.newString(" ") ; 
     twos := twos - 1 ) else (     res := res + StringLib.newString("1") + StringLib.newString(" ") ; 
     ones := ones - 1 ) ) else     if (i = 1) then (     if (ones > 0) then (     res := res + StringLib.newString("1") + StringLib.newString(" ") ; 
     ones := ones - 1 ) else (     res := res + StringLib.newString("2") + StringLib.newString(" ") ; 
     twos := twos - 1 ) ) else skip ; )  ;     i := i + 1 ) ; 
    execute pl(res->excludingAt(res->size() - 1+1)) ; 
 );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     if (stk = null or not(stk.hasNext())) then (     stk := OclIterator.newOclIterator_String_String(br.readLine(), " ") ) else skip ; 
     return stk.next() );
   operation nt() : String
  pre: true
  post: true
  activity: (     return nextToken() );
   operation ns() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nl() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nd() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem1149A {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    int cnt1=0,cnt2=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      if(a[i]==1)cnt1++;
      else cnt2++;
    }
    int res[]=new int[n];
    if(cnt1==0 || cnt2==0){
      if(cnt1==0){
        for(int i=0 ; i<n ; i++){
          System.out.print(a[i]+" ");
        }
      }
      else {
        for(int i=0 ; i<n ; i++){
          System.out.print(a[i]+" ");
        }
      }
    }
    else {
      System.out.print(2+" "+1+" ");
      for(int i=1 ; i<=cnt2-1 ; i++){
        System.out.print(2+" ");
      }
      for(int i=1 ; i<=cnt1-1 ; i++){
        System.out.print(1+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem1149A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var cnt1 : int ; cnt1 := 0 ;
    var cnt2 : int ; cnt2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (a[i+1] = 1) then     cnt1 := cnt1 + 1 ; else     cnt2 := cnt2 + 1 ; )  ;     i := i + 1 ) ; 
    var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
    if (cnt1 = 0 or cnt2 = 0) then (     if (cnt1 = 0) then (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(a[i+1] + " ") )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(a[i+1] + " ") )  ;     i := i + 1 ) ) ) else (     OclFile["System.out"].print(2 + " " + 1 + " ") ; 
         var i : int ; i := 1 ; while i <= cnt2 - 1 do ( (     OclFile["System.out"].print(2 + " ") )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i <= cnt1 - 1 do ( (     OclFile["System.out"].print(1 + " ") )  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1149 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int ones=0 ;
    int twos=0 ;
    for(int n=0 ; n<N ; n++){
      int a=in.nextInt();
      if(a==1){
        ones++;
      }
      else {
        twos++;
      }
    }
    StringBuilder output=new StringBuilder();
    if(twos>0){
      twos--;
      output.append("2 ");
    }
    if(ones>0){
      ones--;
      output.append("1 ");
    }
    while(twos>0){
      twos--;
      output.append("2 ");
    }
    while(ones>0){
      ones--;
      output.append("1 ");
    }
    System.out.println(output);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1149 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var ones : int ; ones := 0 ;
    var twos : int ; twos := 0 ;
        var n : int ; n := 0 ; while n < N do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     if (a = 1) then (     ones := ones + 1 ) else (     twos := twos + 1 ) )  ;     n := n + 1 ) ; 
    var output : String ; output := StringLib.newString() ;
    if (twos > 0) then (     twos := twos - 1 ; 
     output := output + StringLib.newString("2 ") ) else skip ; 
    if (ones > 0) then (     ones := ones - 1 ; 
     output := output + StringLib.newString("1 ") ) else skip ; 
    while (twos > 0) do (     twos := twos - 1 ; 
     output := output + StringLib.newString("2 ") ) ; 
    while (ones > 0) do (     ones := ones - 1 ; 
     output := output + StringLib.newString("1 ") ) ; 
    OclFile["System.out"].println(output) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public int nthTerm(int N){
    return(N*N*N)+(N*N)+N ;
  }
  public static void main(String[] args){
    int N=3 ;
    GFG a=new GFG();
    System.out.println(a.nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
   operation nthTerm( N : int) : int
  pre: true
  post: true
  activity: (     return (N * N * N) + (N * N) + N );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
     var a : GFG ; a := GFG.newGFG() ;
     OclFile["System.out"].println(a.nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Nth {
  public int nthTerm(int N){
    return(N*((N % 2)+(N % 3)));
  }
}
class GFG {
  public static void main(String[] args){
    int N=5 ;
    Nth a=new Nth();
    System.out.println("Nth term for N="+N+" : "+a.nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Nth {
   operation nthTerm( N : int) : int
  pre: true
  post: true
  activity: (     return (N * ((N mod 2) + (N mod 3))) );
}
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     var a : Nth ; a := Nth.newNth() ;
     OclFile["System.out"].println("Nth term for N=" + N + " : " + a.nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Nth {
  public int nthTerm(int N){
    return(N*((N/2)+((N % 2)*2)+N));
  }
}
class GFG {
  public static void main(String[] args){
    int N=5 ;
    Nth a=new Nth();
    System.out.println("Nth term for N="+N+" : "+a.nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Nth {
   operation nthTerm( N : int) : int
  pre: true
  post: true
  activity: (     return (N * ((N / 2) + ((N mod 2) * 2) + N)) );
}
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     var a : Nth ; a := Nth.newNth() ;
     OclFile["System.out"].println("Nth term for N=" + N + " : " + a.nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  private static Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    int n=scanner.nextInt();
    int[] a=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      a[i]=scanner.nextInt();
    }
    int[][] f=new int[n+1][n+1];
    for(int i=0 ; i<=n ; i++){
      Arrays.fill(f[i],(int)1e9);
    }
    for(int i=1 ; i<=n ; i++){
      f[i][i]=1 ;
    }
    for(int len=2 ; len<=n ; len++){
      for(int i=1,j=i+len-1 ; j<=n ; i++,j++){
        if(a[i]==a[j]){
          if(i+1>j-1){
            f[i][j]=1 ;
          }
          else {
            f[i][j]=Math.min(f[i][j],f[i+1][j-1]);
          }
        }
        for(int k=i ; k<j ; k++){
          f[i][j]=Math.min(f[i][j],f[i][k]+f[k+1][j]);
        }
      }
    }
    System.out.println(f[1][n]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var f : Sequence(Sequence(int)) ; f := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i <= n do ( (     f[i+1] := f[i+1]->collect(1e9->oclAsType(int)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     f[i+1][i+1] := 1 )  ;     i := i + 1 ) ; 
        var len : int ; len := 2 ; while len <= n do ( (         var i : int ; i := 1 ;
    var j : int ; j := i + len - 1 ; while j <= n do ( (     if (a[i+1] = a[j+1]) then (     if (i + 1 > j - 1) then (     f[i+1][j+1] := 1 ) else (     f[i+1][j+1] := Set{f[i+1][j+1], f[i + 1+1][j - 1+1]}->min() ) ) else skip ; 
         var k : int ; k := i ; while k < j do ( (     f[i+1][j+1] := Set{f[i+1][j+1], f[i+1][k+1] + f[k + 1+1][j+1]}->min() )  ;     k := k + 1 ) )  ;     i := i + 1 ;     j := j + 1 ) )  ;     len := len + 1 ) ; 
    OclFile["System.out"].println(f[1+1][n+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Zuma_336B {
  static int[] nums ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    nums=new int[n];
    for(int i=0 ; i<n ; i++)nums[i]=sc.nextInt();
    int[][] dp=new int[n][n];
    for(int r=0 ; r<n ; r++){
      for(int l=r ; l>-1 ; l--){
        if(l==r){
          dp[l][r]=1 ;
        }
        else {
          dp[l][r]=dp[l][r-1]+1 ;
          for(int m=r-1 ; m>=l ; m--){
            if(nums[m]!=nums[r])continue ;
            if(m==r-1){
              if(m==l){
                dp[l][r]=1 ;
              }
              else {
                dp[l][r]=Math.min(dp[l][r],dp[l][m-1]+1);
              }
            }
            else {
              if(m==l){
                dp[l][r]=Math.min(dp[l][r],dp[m+1][r-1]);
              }
              else {
                dp[l][r]=Math.min(dp[l][r],dp[l][m-1]+dp[m+1][r-1]);
              }
            }
          }
        }
      }
    }
    System.out.println(dp[0][n-1]);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Zuma_336B {
  static   attribute nums : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    nums := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     nums[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var r : int ; r := 0 ; while r < n do ( (         var l : int ; l := r ; while l > -1 do ( (     if (l = r) then (     dp[l+1][r+1] := 1 ) else (     dp[l+1][r+1] := dp[l+1][r - 1+1] + 1 ; 
         var m : int ; m := r - 1 ; while m >= l do ( (     if (nums[m+1] /= nums[r+1]) then     continue else skip ; 
     if (m = r - 1) then (     if (m = l) then (     dp[l+1][r+1] := 1 ) else (     dp[l+1][r+1] := Set{dp[l+1][r+1], dp[l+1][m - 1+1] + 1}->min() ) ) else (     if (m = l) then (     dp[l+1][r+1] := Set{dp[l+1][r+1], dp[m + 1+1][r - 1+1]}->min() ) else (     dp[l+1][r+1] := Set{dp[l+1][r+1], dp[l+1][m - 1+1] + dp[m + 1+1][r - 1+1]}->min() ) ) )  ;     m := m - 1 ) ) )  ;     l := l - 1 ) )  ;     r := r + 1 ) ; 
    OclFile["System.out"].println(dp[0+1][n - 1+1]) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Zuma_336B {
  static int[][] memo ;
  static int[] nums ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    nums=new int[n];
    for(int i=0 ; i<n ; i++)nums[i]=sc.nextInt();
    memo=new int[n][n];
    for(int[] arr : memo)Arrays.fill(arr,-1);
    System.out.println(helper(0,n-1));
    sc.close();
  }
  private static int helper(int l,int r){
    if(l>r)return 0 ;
    if(l==r)return 1 ;
    if(memo[l][r]!=-1)return memo[l][r];
    int res=1+helper(l,r-1);
    if(nums[r]==nums[r-1])res=Math.min(res,1+helper(l,r-2));
    for(int m=l ; m<r-1 ; m++){
      if(nums[m]!=nums[r])continue ;
      res=Math.min(res,helper(l,m-1)+helper(m+1,r-1));
    }
    return memo[l][r]=res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Zuma_336B {
  static   attribute memo : Sequence(Sequence(int));
  static   attribute nums : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    nums := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     nums[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    memo := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
    for (arr : memo) do (     arr := arr->collect(-1) ;  ) ; 
    OclFile["System.out"].println(helper(0, n - 1)) ; 
    skip ; 
 );
  static   operation helper( l : int, r : int) : int
  pre: true
  post: true
  activity: (     if (l > r) then     return 0 else skip ; 
     if (l = r) then     return 1 else skip ; 
    if (memo[l+1][r+1] /= -1) then     return memo[l+1][r+1] else skip ; 
    var res : int ; res := 1 + helper(l, r - 1) ;
    if (nums[r+1] = nums[r - 1+1]) then     res := Set{res, 1 + helper(l, r - 2)}->min() ; else skip ; 
        var m : int ; m := l ; while m < r - 1 do ( (     if (nums[m+1] /= nums[r+1]) then     continue else skip ; 
     res := Set{res, helper(l, m - 1) + helper(m + 1, r - 1)}->min() )  ;     m := m + 1 ) ; 
    return memo[l+1][r+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static void main(String[] args){
    Scanner stdin=new Scanner(System.in);
    while(true){
      int[] size=new int[3];
      size[0]=stdin.nextInt();
      size[1]=stdin.nextInt();
      size[2]=stdin.nextInt();
      if(size[0]==0 && size[1]==0 && size[2]==0){
        break ;
      }
      Arrays.sort(size);
      int n=stdin.nextInt();
      for(int i=0 ; i<n ; i++){
        int r=stdin.nextInt();
        if(size[0]*size[0]+size[1]*size[1]<r*r*4){
          System.out.println("OK");
        }
        else {
          System.out.println("NA");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var size : Sequence(int) ; size := Integer.subrange(1,3)->collect(0) ;
     size[0+1] := stdin.getCurrent()->toInteger() ; 
    size[1+1] := stdin.getCurrent()->toInteger() ; 
    size[2+1] := stdin.getCurrent()->toInteger() ; 
    if (size[0+1] = 0 & size[1+1] = 0 & size[2+1] = 0) then (     break ) else skip ; 
    size := size->sort() ; 
    var n : int ; n := stdin.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var r : int ; r := stdin.getCurrent()->toInteger() ;
     if (size[0+1] * size[0+1] + size[1+1] * size[1+1] < r * r * 4) then (     OclFile["System.out"].println("OK") ) else (     OclFile["System.out"].println("NA") ) )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemB {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    String line[]=br.readLine().split(" ");
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=Integer.parseInt(line[i]);
    int k=1 ;
    sort(arr);
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]>=k){
        ans++;
        k++;
      }
    }
    System.out.println(ans);
  }
  public static void sort(int arr[]){
    ArrayList<Integer>list=new ArrayList<>();
    for(int it : arr)list.add(it);
    Collections.sort(list);
    for(int i=0 ; i<arr.length ; i++)arr[i]=list.get(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := (line[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var k : int ; k := 1 ;
    execute sort(arr) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] >= k) then (     ans := ans + 1 ; 
     k := k + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation sort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     for (it : arr) do (     list := list->including(it) ;  ) ; 
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < arr->size() do (     arr[i+1] := list->at(i+1) ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException,InterruptedException {
    PrintWriter pw=new PrintWriter(System.out);
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    TreeMap<Integer,Integer>tm=new TreeMap<>();
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      if(tm.containsKey(x))tm.replace(x,tm.get(x)+1);
      else tm.put(x,1);
    }
    int c=0 ;
    for(int i=1 ; i<=n ; i++){
      Integer re=tm.higherKey(i-1);
      if(re!=null){
        c++;
        int v=tm.get(re);
        if(v-1==0)tm.remove(re);
        else tm.replace(re,v-1);
      }
      else break ;
    }
    pw.println(c);
    pw.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(String file)throws FileNotFoundException {
      br=new BufferedReader(new FileReader(file));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var tm : Map(int,int) ; tm := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (tm->keys()->includes(x)) then     tm := tm.replace(x, tm->at(x) + 1) ; else     tm := tm->union(Map{x |-> 1}) ; )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var re : int ; re := tm.higherKey(i - 1) ;
     if (re /= null) then (     c := c + 1 ; 
     var v : int ; v := tm->at(re) ;
     if (v - 1 = 0) then     tm := tm->antirestrict(Set{re}) ; else     tm := tm.replace(re, v - 1) ; ) else     break )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( file : String) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Polycarp {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Integer[] a=new Integer[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    Arrays.sort(a);
    int day=1 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]>=day)day++;
    }
    System.out.println(day-1);
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public double nextDouble()throws IOException {
      String x=next();
      StringBuilder sb=new StringBuilder("0");
      double res=0,f=1 ;
      boolean dec=false,neg=false ;
      int start=0 ;
      if(x.charAt(0)=='-'){
        neg=true ;
        start++;
      }
      for(int i=start ; i<x.length(); i++)if(x.charAt(i)=='.'){
        res=Long.parseLong(sb.toString());
        sb=new StringBuilder("0");
        dec=true ;
      }
      else {
        sb.append(x.charAt(i));
        if(dec)f*=10 ;
      }
      res+=Long.parseLong(sb.toString())/f ;
      return res*(neg ?-1 : 1);
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Polycarp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var day : int ; day := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] >= day) then     day := day + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(day - 1) ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     var x : String ; x := next() ;
     var sb : String ; sb := StringLib.newString("0") ;
    var res : double ; res := 0 ;
    var f : double ; f := 1 ;
    var dec : boolean ; dec := false ;
    var neg : boolean ; neg := false ;
    var start : int ; start := 0 ;
    if (x->at(0+1) = '-') then (     neg := true ; 
     start := start + 1 ) else skip ; 
        var i : int ; i := start ; while i < x->size() do (     if (x->at(i+1) = '.') then (     res := (sb+"")->toLong() ; 
     sb := StringLib.newString("0") ; 
     dec := true ) else (     sb := sb + StringLib.newString(x->at(i+1)) ; 
     if (dec) then     f := f*(10) ; else skip ) ;   ;     i := i + 1 ) ; 
    res := res+((sb+"")->toLong() / f) ; 
    return res * (if neg then -1 else 1 endif) 
 );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int N ;
  static int[] color ;
  static List<Integer>[] e ;
  static boolean dfs(int v,int c){
    color[v]=c ;
    for(int i : e[v]){
      if(color[i]==c)return false ;
      if(color[i]==0 && ! dfs(i,-c))return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int INF=Integer.MAX_VALUE/2 ;
    N=sc.nextInt();
    color=new int[N];
    e=new ArrayList[N];
    int[][] d=new int[N][N];
    for(int i=0 ; i<N ; i++){
      e[i]=new ArrayList<>();
      String S=sc.next();
      for(int j=0 ; j<N ; j++){
        if(i==j)continue ;
        if(S.charAt(j)=='1'){
          e[i] .add(j);
          d[i][j]=1 ;
        }
        else d[i][j]=INF ;
      }
    }
    if(! dfs(0,1)){
      System.out.println(-1);
      return ;
    }
    int dmax=0 ;
    for(int k=0 ; k<N ; k++)for(int i=0 ; i<N ; i++)for(int j=0 ; j<N ; j++)d[i][j]=Math.min(d[i][j],d[i][k]+d[k][j]);
    for(int i=0 ; i<N ; i++)for(int j=0 ; j<N ; j++)if(d[i][j]!=INF)dmax=Math.max(dmax,d[i][j]);
    System.out.println(dmax+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute color : Sequence(int);
  static   attribute e : Sequence(Sequence(int));
  static   operation dfs( v : int, c : int) : boolean
  pre: true
  post: true
  activity: (     color[v+1] := c ; 
     for (i : e[v+1]) do ( (     if (color[i+1] = c) then     return false else skip ; 
     if (color[i+1] = 0 & not(dfs(i, -c))) then     return false else skip )  ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var INF : int ; INF := 2147483647 / 2 ;
    N := sc.getCurrent()->toInteger() ; 
    color := Integer.subrange(1,N)->collect(0) ; 
    e := Integer.subrange(1,N)->collect(null) ; 
    var d : Sequence(Sequence(int)) ; d := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     e[i+1] := Sequence{} ; 
     var S : String ; S := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < N do ( (     if (i = j) then     continue else skip ; 
     if (S->at(j+1) = '1') then (     e[i+1]->excludes(j) ; 
     d[i+1][j+1] := 1 ) else     d[i+1][j+1] := INF ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (not(dfs(0, 1))) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var dmax : int ; dmax := 0 ;
        var k : int ; k := 0 ; while k < N do (         var i : int ; i := 0 ; while i < N do (         var j : int ; j := 0 ; while j < N do (     d[i+1][j+1] := Set{d[i+1][j+1], d[i+1][k+1] + d[k+1][j+1]}->min() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ;  ;     k := k + 1 ) ; 
        var i : int ; i := 0 ; while i < N do (         var j : int ; j := 0 ; while j < N do (     if (d[i+1][j+1] /= INF) then     dmax := Set{dmax, d[i+1][j+1]}->max() ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dmax + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BGraphPartition solver=new BGraphPartition();
    solver.solve(1,in,out);
    out.close();
  }
  static class BGraphPartition {
    int n ;
    boolean[][] a ;
    int[] ind ;
    int bfs(int u){
      ind[u]=1 ;
      int[] q=new int[n];
      int h=0,t=1 ;
      q[h]=u ;
      int ans=1 ;
      while(h<t){
        u=q[h++];
        for(int v=0 ; v<n ; v++){
          if(a[u][v]){
            if(ind[v]!=0 && ind[v]!=ind[u]-1 && ind[v]!=ind[u]+1){
              return-1 ;
            }
            if(ind[v]==0){
              q[t++]=v ;
              ind[v]=ind[u]+1 ;
              ans=ind[v];
            }
          }
        }
      }
      return ans ;
    }
    public void solve(int testNumber,Scanner in,PrintWriter out){
      n=in.nextInt();
      a=new boolean[n][n];
      for(int i=0 ; i<n ; i++){
        String s=in.next();
        for(int j=0 ; j<n ; j++){
          a[i][j]=s.charAt(j)=='1' ;
        }
      }
      int ans=-1 ;
      for(int i=0 ; i<n ; i++){
        ind=new int[n];
        int k=bfs(i);
        if(k>ans){
          ans=k ;
        }
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BGraphPartition ; solver := BGraphPartition.newBGraphPartition() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BGraphPartition {
   attribute n : int;
   attribute a : Sequence(Sequence(boolean));
   attribute ind : Sequence(int);
   operation bfs( u : int) : int
  pre: true
  post: true
  activity: (     ind[u+1] := 1 ; 
     var q : Sequence(int) ; q := Integer.subrange(1,n)->collect(0) ;
    var h : int ; h := 0 ;
    var t : int ; t := 1 ;
    q[h+1] := u ; 
    var ans : int ; ans := 1 ;
    while (h < t) do (      u := q[h+1]  ; h := h + 1 ; 
         var v : int ; v := 0 ; while v < n do ( (     if (a[u+1][v+1]) then (     if (ind[v+1] /= 0 & ind[v+1] /= ind[u+1] - 1 & ind[v+1] /= ind[u+1] + 1) then (     return -1 ) else skip ; 
     if (ind[v+1] = 0) then (      q[t+1] := v  ; t := t + 1 ; 
     ind[v+1] := ind[u+1] + 1 ; 
     ans := ind[v+1] ) else skip ) else skip )  ;     v := v + 1 ) ) ; 
    return ans 
 );
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     n := in.getCurrent()->toInteger() ; 
     a := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ; 
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := in.getCurrent() ;
         var j : int ; j := 0 ; while j < n do ( (     a[i+1][j+1] := s->at(j+1) = '1' )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     ind := Integer.subrange(1,n)->collect(0) ; 
     var k : int ; k := bfs(i) ;
     if (k > ans) then (     ans := k ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int N=scn.nextInt();
    int[][] way=new int[N][N];
    scn.nextLine();
    for(int j=0 ; j<N ; j++){
      char[] ss=scn.nextLine().toCharArray();
      for(int i=0 ; i<N ; i++){
        way[j][i]=(ss[i]==48)? 0 : 1 ;
      }
    }
    int ans=-1 ;
    for(int n=0 ; n<N ; n++){
      int[] group=new int[N];
      boolean can=true ;
      HashSet<Integer>the=new HashSet<Integer>();
      HashSet<Integer>next=new HashSet<Integer>();
      int now_g=0 ;
      next.add(n);
      while(! next.isEmpty()){
        the=new HashSet<Integer>();
        now_g++;
        for(int j : next){
          the.add(j);
          group[j]=now_g ;
        }
        next=new HashSet<Integer>();
        for(int j : the){
          for(int i=0 ; i<N ; i++){
            if(way[j][i]!=1)continue ;
            if(group[i]!=0){
              if(group[i]==now_g-1){
                continue ;
              }
              else {
                can=false ;
                break ;
              }
            }
            next.add(i);
          }
          if(! can)break ;
        }
      }
      if(can)ans=Math.max(now_g,ans);
    }
    System.out.println((ans<2)?-1 : ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scn.getCurrent()->toInteger() ;
    var way : Sequence(Sequence(int)) ; way := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
    skip ; 
        var j : int ; j := 0 ; while j < N do ( (     var ss : Sequence(String) ; ss := scn.nextLine()->characters() ;
         var i : int ; i := 0 ; while i < N do ( (     way[j+1][i+1] := if (ss[i+1] = 48) then 0 else 1 endif )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    var ans : int ; ans := -1 ;
        var n : int ; n := 0 ; while n < N do ( (     var group : Sequence(int) ; group := Integer.subrange(1,N)->collect(0) ;
     var can : boolean ; can := true ;
    var the : Set(int) ; the := Set{} ;
    var next : Set(int) ; next := Set{} ;
    var now_g : int ; now_g := 0 ;
    next := next->including(n) ; 
    while (not(next->isEmpty())) do (     the := Set{} ; 
     now_g := now_g + 1 ; 
    for (j : next) do ( (     the := the->including(j) ; 
     group[j+1] := now_g )  ) ; 
    next := Set{} ; 
    for (j : the) do ( (         var i : int ; i := 0 ; while i < N do ( (     if (way[j+1][i+1] /= 1) then     continue else skip ; 
     if (group[i+1] /= 0) then (     if (group[i+1] = now_g - 1) then (     continue ) else (     can := false ; 
     break ) ) else skip ; 
     next := next->including(i) )  ;     i := i + 1 ) ; 
     if (not(can)) then     break else skip )  ) ; 
 ) ; 
    if (can) then     ans := Set{now_g, ans}->max() ; else skip ; 
 )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(if (ans < 2) then -1 else ans endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1681A_SpaceNavigation {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int x=input.nextInt();
      int y=input.nextInt();
      input.nextLine();
      String direction=input.nextLine();
      int up=0 ;
      int right=0 ;
      int down=0 ;
      int left=0 ;
      boolean flag1=false ;
      boolean flag2=false ;
      for(char c : direction.toCharArray()){
        switch(c){
          case 'U' : up++;
          break ;
          case 'R' : right++;
          break ;
          case 'L' : left--;
          break ;
          case 'D' : down--;
          break ;
        }
        if(x==left || x==right){
          flag1=true ;
        }
        if(y==up || y==down){
          flag2=true ;
        }
        if(flag1 && flag2){
          break ;
        }
      }
      if(flag1 && flag2){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1681A_SpaceNavigation {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var x : int ; x := input.getCurrent()->toInteger() ;
     var y : int ; y := input.getCurrent()->toInteger() ;
    skip ; 
    var direction : String ; direction := input.nextLine() ;
    var up : int ; up := 0 ;
    var right : int ; right := 0 ;
    var down : int ; down := 0 ;
    var left : int ; left := 0 ;
    var flag1 : boolean ; flag1 := false ;
    var flag2 : boolean ; flag2 := false ;
    for (c : direction->characters()) do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
       if _switchval = 'U' then
     up := up + 1 ; 
    break 
   else skip ;
       if _switchval = 'R' then
     right := right + 1 ; 
    break 
   else skip ;
       if _switchval = 'L' then
     left := left - 1 ; 
    break 
   else skip ;
       if _switchval = 'D' then
     down := down - 1 ; 
    break 
   else skip ;
 )
     if (x = left or x = right) then (     flag1 := true ) else skip ; 
     if (y = up or y = down) then (     flag2 := true ) else skip ; 
     if (flag1 & flag2) then (     break ) else skip )  ) ; 
    if (flag1 & flag2) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem_1481A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    int px,py ;
    for(int i=0 ; i<t ; i++){
      px=scanner.nextInt();
      py=scanner.nextInt();
      int u=0,d=0,l=0,r=0 ;
      char[] strs=scanner.next().toCharArray();
      for(char str : strs){
        switch(str){
          case 'U' : u++;
          break ;
          case 'D' : d++;
          break ;
          case 'L' : l++;
          break ;
          case 'R' : r++;
          break ;
        }
      }
      if(-l<=px && px<=r &&-d<=py && py<=u){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem_1481A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
     var px : int ;
    var py : int ;
         var i : int ; i := 0 ; while i < t do ( (     px := scanner.getCurrent()->toInteger() ; 
     py := scanner.getCurrent()->toInteger() ; 
    var u : int ; u := 0 ;
    var d : int ; d := 0 ;
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    var strs : Sequence(String) ; strs := scanner.getCurrent()->characters() ;
    for (str : strs) do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (str) ; 
       if _switchval = 'U' then
     u := u + 1 ; 
    break 
   else skip ;
       if _switchval = 'D' then
     d := d + 1 ; 
    break 
   else skip ;
       if _switchval = 'L' then
     l := l + 1 ; 
    break 
   else skip ;
       if _switchval = 'R' then
     r := r + 1 ; 
    break 
   else skip ;
 )
 )  ) ; 
    if (-l <= px & px <= r & -d <= py & py <= u) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int solve(int ang,int n){
    if((ang*n)>(180*(n-2))){
      return 0 ;
    }
    else if((ang*n)% 180!=0){
      return 0 ;
    }
    int ans=1 ;
    int freq=(ang*n)/180 ;
    ans=ans*(n-1-freq);
    ans=ans*n ;
    return ans ;
  }
  public static void main(String[] args){
    int ang=90,n=4 ;
    System.out.println(solve(ang,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( ang : int, n : int) : int
  pre: true
  post: true
  activity: (     if ((ang * n) > (180 * (n - 2))) then (     return 0 ) else     if ((ang * n) mod 180 /= 0) then (     return 0 ) else skip ; ;  
     var ans : int ; ans := 1 ;
    var freq : int ; freq := (ang * n) / 180 ;
    ans := ans * (n - 1 - freq) ; 
    ans := ans * n ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ang : int ; ang := 90 ;
    var n : int ; n := 4 ;
     OclFile["System.out"].println(solve(ang, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test279 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int x=in.nextInt();
      int y=in.nextInt();
      char a[]=in.next().toCharArray();
      int u=0,d=0,r=0,l=0 ;
      boolean b=false,c=false ;
      for(int i=0 ; i<a.length ; i++){
        if(a[i]=='R'){
          r++;
        }
        else if(a[i]=='U'){
          u++;
        }
        else if(a[i]=='D'){
          d--;
        }
        else {
          l--;
        }
      }
      if(x>=0){
        if(x<=r){
          b=true ;
        }
      }
      else {
        if(x>=l){
          b=true ;
        }
      }
      if(y>=0){
        if(y<=u){
          c=true ;
        }
      }
      else {
        if(y>=d){
          c=true ;
        }
      }
      if(c && b){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test279 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var y : int ; y := in.getCurrent()->toInteger() ;
    var a : Sequence(String) ; a := in.getCurrent()->characters() ;
    var u : int ; u := 0 ;
    var d : int ; d := 0 ;
    var r : int ; r := 0 ;
    var l : int ; l := 0 ;
    var b : boolean ; b := false ;
    var c : boolean ; c := false ;
        var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] = 'R') then (     r := r + 1 ) else     if (a[i+1] = 'U') then (     u := u + 1 ) else     if (a[i+1] = 'D') then (     d := d - 1 ) else (     l := l - 1 ) ;  ;  )  ;     i := i + 1 ) ; 
    if (x >= 0) then (     if (x <= r) then (     b := true ) else skip ) else (     if (x >= l) then (     b := true ) else skip ) ;  
    if (y >= 0) then (     if (y <= u) then (     c := true ) else skip ) else (     if (y >= d) then (     c := true ) else skip ) ;  
    if (c & b) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] input=null ;
    Cheese c=null ;
    Gate g=null ;
    while(true){
      input=br.readLine().split(" ");
      int height=Integer.parseInt(input[1]);
      int width=Integer.parseInt(input[0]);
      int depth=Integer.parseInt(input[2]);
      if(height+width+depth==0)break ;
      c=new Cheese(width,height,depth);
      int numGate=Integer.parseInt(br.readLine());
      for(int i=0 ; i<numGate ; i++){
        g=new Gate(Integer.parseInt(br.readLine()));
        System.out.println((c.isSmaller(g))? "OK" : "NA");
      }
    }
  }
}
class Cheese {
  int width ;
  int height ;
  int depth ;
  double lengthWH ;
  double lengthHD ;
  double lengthWD ;
  public Cheese(int width,int height,int depth){
    this.width=width ;
    this.height=height ;
    this.depth=depth ;
    this.lengthWH=Math.sqrt(this.width*this.width+this.height*this.height);
    this.lengthHD=Math.sqrt(this.height*this.height+this.depth*this.depth);
    this.lengthWD=Math.sqrt(this.width*this.width+this.depth*this.depth);
  }
  public boolean isSmaller(Gate gate){
    int gateDiameter=gate.getDiameter();
    return((this.lengthHD<gateDiameter)||(this.lengthWD<gateDiameter)||(this.lengthWH<gateDiameter));
  }
}
class Gate {
  int r ;
  public Gate(int r){
    this.r=r ;
  }
  public int getDiameter(){
    return this.r*2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : Sequence(String) ; input := null ;
    var c : Cheese ; c := null ;
    var g : Gate ; g := null ;
    while (true) do (     input := br.readLine()->split(" ") ; 
     var height : int ; height := (input[1+1])->toInteger() ;
    var width : int ; width := (input[0+1])->toInteger() ;
    var depth : int ; depth := (input[2+1])->toInteger() ;
    if (height + width + depth = 0) then     break else skip ; 
    c := Cheese.newCheese(width, height, depth) ; 
    var numGate : int ; numGate := (br.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < numGate do ( (     g := Gate.newGate((br.readLine())->toInteger()) ; 
     OclFile["System.out"].println(if (c.isSmaller(g)) then "OK" else "NA" endif) )  ;     i := i + 1 ) ; 
 ) ; 
 );
}
class Cheese {
   attribute width : int;
   attribute height : int;
   attribute depth : int;
   attribute lengthWH : double;
   attribute lengthHD : double;
   attribute lengthWD : double;
   static operation newCheese( width : int, height : int, depth : int) : Cheese
  pre: true
  post: true
  activity:
  ( var self : Cheese ;
    self := createCheese();
    self.initialise(width, height,depth);
    return self );
  operation initialise( width : int, height : int, depth : int) : void
  pre: true  post: true
  activity: (     self.width := width ; 
     self.height := height ; 
    self.depth := depth ; 
    self.lengthWH := (self.width * self.width + self.height * self.height)->sqrt() ; 
    self.lengthHD := (self.height * self.height + self.depth * self.depth)->sqrt() ; 
    self.lengthWD := (self.width * self.width + self.depth * self.depth)->sqrt() ; 
 );
   operation isSmaller( gate : Gate) : boolean
  pre: true
  post: true
  activity: (     var gateDiameter : int ; gateDiameter := gate.getDiameter() ;
     return ((self.lengthHD < gateDiameter) or (self.lengthWD < gateDiameter) or (self.lengthWH < gateDiameter)) );
}
class Gate {
   attribute r : int;
   static operation newGate( r : int) : Gate
  pre: true
  post: true
  activity:
  ( var self : Gate ;
    self := createGate();
    self.initialise(r);
    return self );
  operation initialise( r : int) : void
  pre: true  post: true
  activity: (     self.r := r );
   operation getDiameter() : int
  pre: true
  post: true
  activity: (     return self.r * 2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static Scanner sc=new Scanner(System.in);
  public static int a,b ;
  public static void main(String[] args){
    while(read()){
      solve();
    }
  }
  public static boolean read(){
    if(! sc.hasNext()){
      return false ;
    }
    a=sc.nextInt();
    b=sc.nextInt();
    return true ;
  }
  public static void solve(){
    int d=a/b,r=a % b ;
    double f=(double)a/b ;
    System.out.printf("%d %d %.8f\n",d,r,f);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute a : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (read()) do (     execute solve() ) );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     if (not(sc.hasNext())) then (     return false ) else skip ; 
     a := sc.getCurrent()->toInteger() ; 
     b := sc.getCurrent()->toInteger() ; 
     return true );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var d : int ; d := a / b ;
    var r : int ; r := a mod b ;
     var f : double ; f := a->oclAsType(double) / b ;
     OclFile["System.out"].printf("%d %d %.8f\n", d, r, f) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int a=0,b=0 ;
    try {
      String str=br.readLine();
      a=Integer.parseInt(str.substring(0,str.indexOf(" ")));
      b=Integer.parseInt(str.substring(str.indexOf(" ")+1,str.length()));
    }
    catch(IOException e){
      e.printStackTrace();
    }
    catch(NumberFormatException e){
      e.printStackTrace();
    }
    System.out.println((int)a/b+" "+a % b+" "+(float)a/b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var a : int ; a := 0 ;
    var b : int ; b := 0 ;
     try (     var str : String ; str := br.readLine() ;
     a := (str.subrange(0+1,str->indexOf(" ")-1))->toInteger() ; 
     b := (str.subrange(str->indexOf(" ")-1 + 1+1,str->size()))->toInteger() )   catch (e : IOException) do (     e.printStackTrace() )
   catch (e : IncorrectElementException) do (     e.printStackTrace() )
     OclFile["System.out"].println(a->oclAsType(int) / b + " " + a mod b + " " + a->oclAsType(double) / b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Scanner ;
class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(isr);
    String line=br.readLine();
    String[] ss=line.split(" ");
    int[] ia={
      Integer.parseInt(ss[0]),Integer.parseInt(ss[1])};
      double[] da={
        Double.parseDouble(ss[0]),Double.parseDouble(ss[1])};
        System.out.println(ia[0]/ia[1]+" "+ia[0] % ia[1]+" "+String.format("%f",da[0]/da[1]));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
    var line : String ; line := br.readLine() ;
    var ss : Sequence(String) ; ss := line->split(" ") ;
    var ia : Sequence(int) ; ia := Sequence{(ss[0+1])->toInteger(),(ss[1+1])->toInteger()} ;
    var da : Sequence(double) ; da := Sequence{(ss[0+1])->toReal(),(ss[1+1])->toReal()} ;
    OclFile["System.out"].println(ia[0+1] / ia[1+1] + " " + ia[0+1] mod ia[1+1] + " " + StringLib.format("%f",Sequence{da[0+1] / da[1+1]})) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long[] ary=new long[] {
      sc.nextLong(),sc.nextLong(),sc.nextLong()};
      Arrays.sort(ary);
      System.out.println(ary[0]+" "+ary[1]+" "+ary[2]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ary : Sequence(long) ; ary := Sequence{sc.getCurrent()->toLong(),sc.getCurrent()->toLong(),sc.getCurrent()->toLong()} ;
     ary := ary->sort() ; 
     OclFile["System.out"].println(ary[0+1] + " " + ary[1+1] + " " + ary[2+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.text.DecimalFormat ;
public class Main {
  public static void main(String[] args){
    DecimalFormat df1=new DecimalFormat("0.00000");
    java.util.Scanner scan=new java.util.Scanner(System.in);
    int a=scan.nextInt();
    int b=scan.nextInt();
    System.out.println(a/b+" "+a % b+" "+df1.format((double)a/b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var df1 : DecimalFormat ; df1 := DecimalFormat.newDecimalFormat("0.00000") ;
     var scan : Scanner ; scan := Scanner.newScanner(OclFile["System.in"]) ;
    var a : int ; a := scan.nextInt() ;
    var b : int ; b := scan.nextInt() ;
    OclFile["System.out"].println(a / b + " " + a mod b + " " + df1.format(a->oclAsType(double) / b)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p002 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p002().run());
  }
  public String run(){
    int sum=0 ;
    int x=1 ;
    int y=2 ;
    while(x<=4000000){
      if(x % 2==0)sum+=x ;
      int z=x+y ;
      x=y ;
      y=z ;
    }
    return Integer.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
class p002 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p002.newp002().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var x : int ; x := 1 ;
    var y : int ; y := 2 ;
    while (x <= 4000000) do (     if (x mod 2 = 0) then     sum := sum+(x) ; else skip ; 
     var z : int ; z := x + y ;
     x := y ; 
     y := z ) ; 
    return ((sum) + "") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int SIZE=4 ;
  static boolean productOfSingelDgt(int n){
    if(n>=0 && n<=9)return true ;
    int[] prime={
      2,3,5,7 };
      for(int i=0 ; i<SIZE && n>1 ; i++)while(n % prime[i]==0)n=n/prime[i];
      return(n==1);
    }
    public static void main(String[] args){
      int n=24 ;
      if(productOfSingelDgt(n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute SIZE : int := 4;
  static   operation productOfSingelDgt( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n >= 0 & n <= 9) then     return true else skip ; 
     var prime : Sequence(int) ; prime := Sequence{2,3,5,7} ;
         var i : int ; i := 0 ; while i < SIZE & n > 1 do (     while (n mod prime[i+1] = 0) do     n := n / prime[i+1] ; ;  ;     i := i + 1 ) ; 
     return (n = 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 24 ;
     if (productOfSingelDgt(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.*;
import javafx.util.Pair ;
public class Main {
  public static void main(String args[]){
    FastScanner input=new FastScanner();
    long n=input.nextLong();
    int m=input.nextInt();
    long k=input.nextLong();
    long a[]=new long[m];
    long ans=0 ;
    long stop_area=0 ;
    for(int i=0 ; i<m ; i++){
      a[i]=input.nextLong()-1 ;
    }
    for(int i=0 ; i<m ; i++){
      if(stop_area<=a[i]){
        stop_area=(a[i]-i)/k*k+k+i ;
        ans++;
      }
    }
    System.out.println(ans);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var n : long ; n := input.nextLong() ;
    var m : int ; m := input.nextInt() ;
    var k : long ; k := input.nextLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,m)->collect(0) ;
    var ans : long ; ans := 0 ;
    var stop_area : long ; stop_area := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := input.nextLong() - 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     if (stop_area <= a[i+1]) then (     stop_area := (a[i+1] - i) / k * k + k + i ; 
     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Comparator ;
public class A1575 {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    String line=reader.readLine();
    int idx=line.indexOf(' ');
    int N=Integer.parseInt(line.substring(0,idx));
    int M=Integer.parseInt(line.substring(idx+1));
    Data[] data=new Data[N];
    for(int n=0 ; n<N ; n++){
      Data d=new Data();
      d.id=n+1 ;
      d.name=reader.readLine();
      data[n]=d ;
    }
    Arrays.sort(data,new Comparator<Data>(){
      @ Override public int compare(Data o1,Data o2){
        String name1=o1.name ;
        String name2=o2.name ;
        int idx=0 ;
        int diff ;
        do {
          char c1=name1.charAt(idx);
          char c2=name2.charAt(idx);
          diff=(idx % 2==0)?(c1-c2):(c2-c1);
          idx++;
        }
        while(diff==0);
        return diff ;
      }
    }
);
    StringBuilder output=new StringBuilder();
    for(Data d : data){
      output.append(d.id).append(' ');
    }
    System.out.println(output);
  }
  static class Data {
    int id ;
    String name ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1575 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := reader.readLine() ;
    var idx : int ; idx := line->indexOf(' ')-1 ;
    var N : int ; N := (line.subrange(0+1,idx))->toInteger() ;
    var M : int ; M := (line.subrange(idx + 1+1,idx + 1))->toInteger() ;
    var data : Sequence(Data) ; data := Integer.subrange(1,N)->collect(null) ;
        var n : int ; n := 0 ; while n < N do ( (     var d : Data ; d := Data.newData() ;
     d.id := n + 1 ; 
     d.name := reader.readLine() ; 
     data[n+1] := d )  ;     n := n + 1 ) ; 
    data := OclComparator.sortWith(data, OclComparator<Data>.newOclComparator()) ; 
    var output : String ; output := StringLib.newString() ;
    for (d : data) do ( (     output := output + StringLib.newString(d.id) + StringLib.newString(' ') )  ) ; 
    OclFile["System.out"].println(output) ; 
 );
  static class Data {
   attribute id : int;
   attribute name : String;
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
import java.util.stream.Collectors ;
import java.io.*;
public class absolute {
  public static long process(long n,long[] ar,long k){
    int i=0,steps=0 ;
    long stdiv=ar[0]/k,st=(stdiv+((ar[0] % k!=0)? 1 : 0))*k ;
    if(k==1)return ar.length ;
    while(i<ar.length){
      int count=0 ;
      while(i<ar.length && ar[i]<=st){
        i++;
        count++;
      }
      if(count==0){
        if(ar[i]<=st+k)st+=k ;
        else {
          long div=ar[i]/k ;
          if(st % k==0)st=k*(div+1);
          else {
            long prev=st % k ;
            st=k*(div)+prev ;
          }
        }
      }
      else st+=count ;
      steps=steps+((count>0)? 1 : 0);
    }
    return steps ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    int m=sc.nextInt();
    long k=sc.nextLong();
    long[] ar=new long[m];
    for(int i=0 ; i<m ; i++)ar[i]=sc.nextLong();
    System.out.println(process(n,ar,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class absolute {
  static   operation process( n : long, ar : Sequence(long), k : long) : long
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var steps : int ; steps := 0 ;
     var stdiv : long ; stdiv := ar[0+1] / k ;
    var st : long ; st := (stdiv + (if (ar[0+1] mod k /= 0) then 1 else 0 endif)) * k ;
    if (k = 1) then     return ar->size() else skip ; 
    while (i < ar->size()) do (     var count : int ; count := 0 ;
     while (i < ar->size() & ar[i+1] <= st) do (     i := i + 1 ; 
     count := count + 1 ) ; 
     if (count = 0) then (     if (ar[i+1] <= st + k) then     st := st+(k) ; else (     var div : long ; div := ar[i+1] / k ;
     if (st mod k = 0) then     st := k * (div + 1) ; else (     var prev : long ; prev := st mod k ;
     st := k * (div) + prev ) ) ) else     st := st+(count) ; ;  
     steps := steps + (if (count > 0) then 1 else 0 endif) ) ; 
    return steps 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var ar : Sequence(long) ; ar := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     ar[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(process(n, ar, k)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Ideone {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args)throws java.lang.Exception {
    FastReader fs=new FastReader();
    int n=fs.nextInt();
    int[] arr={
      4,22,27,58,85,94,121,166,202,265,274,319,346,355,378,382,391,438,454,483,517,526,535,562,576,588,627,634,636,645,648,654,663,666,690,706,728,729,762,778,825,852,861,895,913,915,922,958,985,1086,1111,1165 };
      System.out.println(arr[n-1]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Ideone {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastReader ; fs := FastReader.newFastReader() ;
     var n : int ; n := fs.nextInt() ;
     var arr : Sequence(int) ; arr := Sequence{4,22,27,58,85,94,121,166,202,265,274,319,346,355,378,382,391,438,454,483,517,526,535,562,576,588,627,634,636,645,648,654,663,666,690,706,728,729,762,778,825,852,861,895,913,915,922,958,985,1086,1111,1165} ;
     OclFile["System.out"].println(arr[n - 1+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new aoj107().doIt();
  }
  class aoj107 {
    boolean ans(int a,int b,double r){
      for(double i=0 ; i<90 ; i++){
        double sin=2*r*Math.sin(Math.toRadians(i));
        double cos=2*r*Math.cos(Math.toRadians(i));
        if(a<sin && b<cos)return true ;
      }
      return false ;
    }
    void doIt(){
      while(true){
        int a=sc.nextInt();
        int b=sc.nextInt();
        int c=sc.nextInt();
        if(a+b+c==0)break ;
        int cnt=sc.nextInt();
        for(int i=0 ; i<cnt ; i++){
          double r=sc.nextDouble();
          if(ans(a,b,r)){
            System.out.println("OK");
          }
          else if(ans(b,a,r)){
            System.out.println("OK");
          }
          else if(ans(c,a,r)){
            System.out.println("OK");
          }
          else if(ans(a,c,r)){
            System.out.println("OK");
          }
          else if(ans(c,b,r)){
            System.out.println("OK");
          }
          else if(ans(b,c,r)){
            System.out.println("OK");
          }
          else {
            System.out.println("NA");
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     aoj107.newaoj107().doIt() );
 class aoj107 {
   operation ans( a : int, b : int, r : double) : boolean
  pre: true
  post: true
  activity: (         var i : double ; i := 0 ; while i < 90 do ( (     var sin : double ; sin := 2 * r * ((0.017453292519943295*(i)))->sin() ;
     var cos : double ; cos := 2 * r * ((0.017453292519943295*(i)))->cos() ;
     if (a < sin & b < cos) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (true) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    if (a + b + c = 0) then     break else skip ; 
    var cnt : int ; cnt := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < cnt do ( (     var r : double ; r := sc.getCurrent()->toReal() ;
     if (ans(a, b, r)) then (     OclFile["System.out"].println("OK") ) else     if (ans(b, a, r)) then (     OclFile["System.out"].println("OK") ) else     if (ans(c, a, r)) then (     OclFile["System.out"].println("OK") ) else     if (ans(a, c, r)) then (     OclFile["System.out"].println("OK") ) else     if (ans(c, b, r)) then (     OclFile["System.out"].println("OK") ) else     if (ans(b, c, r)) then (     OclFile["System.out"].println("OK") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  )  ;     i := i + 1 ) ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NumbersJoke {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] resList=new int[] {
      4,22,27,58,85,94,121,166,202,265,274,319,346,355,378,382,391,438,454,483,517,526,535,562,576,588,627,634,636,645,648,654,663,666,690,706,728,729,762,778,825,852,861,895,913,915,922,958,985,1086 };
      System.out.println(resList[n-1]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class NumbersJoke {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
     var resList : Sequence(int) ; resList := Sequence{4,22,27,58,85,94,121,166,202,265,274,319,346,355,378,382,391,438,454,483,517,526,535,562,576,588,627,634,636,645,648,654,663,666,690,706,728,729,762,778,825,852,861,895,913,915,922,958,985,1086} ;
     OclFile["System.out"].println(resList[n - 1+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class a {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int[] ans={
      4,22,27,58,85,94,121,166,202,265,274,319,346,355,378,382,391,438,454,483,517,526,535,562,576,588,627,634,636,645,648,654,663,666,690,706,728,729,762,778,825,852,861,895,913,915,922,958,985,1086,1111,1165 };
      int a=in.nextInt();
      System.out.println(ans[a-1]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ans : Sequence(int) ; ans := Sequence{4,22,27,58,85,94,121,166,202,265,274,319,346,355,378,382,391,438,454,483,517,526,535,562,576,588,627,634,636,645,648,654,663,666,690,706,728,729,762,778,825,852,861,895,913,915,922,958,985,1086,1111,1165} ;
     var a : int ; a := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println(ans[a - 1+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] str)throws IOException {
    BufferedReader l=new BufferedReader(new InputStreamReader(System.in));
    int arr[]={
      4,22,27,58,85,94,121,166,202,265,274,319,346,355,378,382,391,438,454,483,517,526,535,562,576,588,627,634,636,645 };
      int t=Integer.parseInt(l.readLine());
      System.out.println(arr[t-1]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( str : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : OclFile ; l := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var arr : Sequence(int) ; arr := Sequence{4,22,27,58,85,94,121,166,202,265,274,319,346,355,378,382,391,438,454,483,517,526,535,562,576,588,627,634,636,645} ;
     var t : int ; t := (l.readLine())->toInteger() ;
     OclFile["System.out"].println(arr[t - 1+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  final static int MAX_CHARS=26 ;
  static boolean isValid(int count[],int k){
    int val=0 ;
    for(int i=0 ; i<MAX_CHARS ; i++){
      if(count[i]>0){
        val++;
      }
    }
    return(k>=val);
  }
  static void kUniques(String s,int k){
    int u=0 ;
    int n=s.length();
    int count[]=new int[MAX_CHARS];
    Arrays.fill(count,0);
    for(int i=0 ; i<n ; i++){
      if(count[s.charAt(i)-'a']==0){
        u++;
      }
      count[s.charAt(i)-'a']++;
    }
    if(u<k){
      System.out.print("Not enough unique characters");
      return ;
    }
    int curr_start=0,curr_end=0 ;
    int max_window_size=1,max_window_start=0 ;
    Arrays.fill(count,0);
    count[s.charAt(0)-'a']++;
    for(int i=1 ; i<n ; i++){
      count[s.charAt(i)-'a']++;
      curr_end++;
      while(! isValid(count,k)){
        count[s.charAt(curr_start)-'a']--;
        curr_start++;
      }
      if(curr_end-curr_start+1>max_window_size){
        max_window_size=curr_end-curr_start+1 ;
        max_window_start=curr_start ;
      }
    }
    System.out.println("Max sustring is : "+s.substring(max_window_start,max_window_size)+" with length "+max_window_size);
  }
  static public void main(String[] args){
    String s="aabacbebebe" ;
    int k=3 ;
    kUniques(s,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX_CHARS : int := 26;
  static   operation isValid( count : Sequence(int), k : int) : boolean
  pre: true
  post: true
  activity: (     var val : int ; val := 0 ;
         var i : int ; i := 0 ; while i < MAX_CHARS do ( (     if (count[i+1] > 0) then (     val := val + 1 ) else skip )  ;     i := i + 1 ) ; 
     return (k >= val) );
  static   operation kUniques( s : String, k : int) : void
  pre: true
  post: true
  activity: (     var u : int ; u := 0 ;
     var n : int ; n := s->size() ;
    var count : Sequence(int) ; count := Integer.subrange(1,MAX_CHARS)->collect(0) ;
    count := count->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (count[s->at(i+1) - ('a')->char2byte()+1] = 0) then (     u := u + 1 ) else skip ; 
     count[s->at(i+1) - ('a')->char2byte()+1] := count[s->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    if (u < k) then (     OclFile["System.out"].print("Not enough unique characters") ; 
     return ) else skip ; 
    var curr_start : int ; curr_start := 0 ;
    var curr_end : int ; curr_end := 0 ;
    var max_window_size : int ; max_window_size := 1 ;
    var max_window_start : int ; max_window_start := 0 ;
    count := count->collect(0) ; 
    count[s->at(0+1) - ('a')->char2byte()+1] := count[s->at(0+1) - ('a')->char2byte()+1] + 1 ; 
        var i : int ; i := 1 ; while i < n do ( (     count[s->at(i+1) - ('a')->char2byte()+1] := count[s->at(i+1) - ('a')->char2byte()+1] + 1 ; 
     curr_end := curr_end + 1 ; 
     while (not(isValid(count, k))) do (     count[s->at(curr_start+1) - ('a')->char2byte()+1] := count[s->at(curr_start+1) - ('a')->char2byte()+1] - 1 ; 
     curr_start := curr_start + 1 ) ; 
     if (curr_end - curr_start + 1 > max_window_size) then (     max_window_size := curr_end - curr_start + 1 ; 
     max_window_start := curr_start ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Max sustring is : " + s.subrange(max_window_start+1,max_window_size) + " with length " + max_window_size) ; 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "aabacbebebe" ;
     var k : int ; k := 3 ;
     execute kUniques(s, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Casier {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long m=sc.nextLong();
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(n % m==0)System.out.println("0");
    else {
      long x=b*(n % m);
      long y=(m-n % m)*a ;
      if(x<y)System.out.print(x);
      else System.out.print(y);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Casier {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var m : long ; m := sc.getCurrent()->toLong() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    if (n mod m = 0) then     OclFile["System.out"].println("0") else (     var x : long ; x := b * (n mod m) ;
     var y : long ; y := (m - n mod m) * a ;
     if (x < y) then     OclFile["System.out"].print(x) ; else     OclFile["System.out"].print(y) ; ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CommentaryBoxes {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long m=sc.nextLong();
    int a=sc.nextInt();
    int b=sc.nextInt();
    long left=n % m ;
    long build=(m-left)*a ;
    long destroy=left*b ;
    System.out.println(build>destroy ? destroy : build);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CommentaryBoxes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var m : long ; m := sc.getCurrent()->toLong() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var left : long ; left := n mod m ;
    var build : long ; build := (m - left) * a ;
    var destroy : long ; destroy := left * b ;
    OclFile["System.out"].println(if build > destroy then destroy else build endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long n=in.nextLong(),m=in.nextLong(),a=in.nextLong(),b=in.nextLong();
    if(n % m==0){
      pw.println(0);
    }
    else {
      long ans1=n % m ;
      ans1=ans1*b ;
      long div=1+(n/m);
      div=div*m ;
      div=div-n ;
      long ans2=div*a ;
      pw.println(Math.min(ans2,ans1));
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := in.getCurrent()->toLong() ;
    var m : long ; m := in.getCurrent()->toLong() ;
    var a : long ; a := in.getCurrent()->toLong() ;
    var b : long ; b := in.getCurrent()->toLong() ;
    if (n mod m = 0) then (     skip ) else (     var ans1 : long ; ans1 := n mod m ;
     ans1 := ans1 * b ; 
    var div : long ; div := 1 + (n / m) ;
    div := div * m ; 
    div := div - n ; 
    var ans2 : long ; ans2 := div * a ;
    skip ; 
 ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.HashMap ;
import java.util.Map ;
public class OurTanyaIsCryingOutLoud {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    long n=Integer.parseInt(br.readLine());
    long k=Integer.parseInt(br.readLine());
    long A=Integer.parseInt(br.readLine());
    long B=Integer.parseInt(br.readLine());
    if(k==1 || n<k){
      pr.println((n-1)*A);
      return ;
    }
    long res=0 ;
    while(n>1){
      if(n % k!=0){
        long t=n % k ;
        if(n<k)t--;
        n-=t ;
        res+=A*t ;
      }
      else {
        long next=n/k ;
        long temp1=(n-next)*A ;
        long temp2=B ;
        res+=Math.min(temp1,temp2);
        n/=k ;
      }
    }
    pr.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class OurTanyaIsCryingOutLoud {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : long ; n := (br.readLine())->toInteger() ;
     var k : long ; k := (br.readLine())->toInteger() ;
    var A : long ; A := (br.readLine())->toInteger() ;
    var B : long ; B := (br.readLine())->toInteger() ;
    if (k = 1 or n < k) then (     skip ; 
     return ) else skip ; 
    var res : long ; res := 0 ;
    while (n > 1) do (     if (n mod k /= 0) then (     var t : long ; t := n mod k ;
     if (n < k) then     t := t - 1 ; else skip ; 
     n := n-(t) ; 
     res := res+(A * t) ) else (     var next : long ; next := n / k ;
     var temp1 : long ; temp1 := (n - next) * A ;
    var temp2 : long ; temp2 := B ;
    res := res+(Set{temp1, temp2}->min()) ; 
    n := n/(k) ; 
 ) ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX_SIZE=(int)1e6 ;
  static boolean[] prime=new boolean[MAX_SIZE+1];
  static void sieve(){
    Arrays.fill(prime,true);
    for(int p=2 ; p*p<=MAX_SIZE ; p++){
      if(prime[p]==true){
        for(int i=p*p ; i<=MAX_SIZE ; i+=p)prime[i]=false ;
      }
    }
  }
  static int kthPrimeGreaterThanN(int n,int k){
    int res=-1 ;
    for(int i=n+1 ; i<MAX_SIZE ; i++){
      if(prime[i]==true)k--;
      if(k==0){
        res=i ;
        break ;
      }
    }
    return res ;
  }
  public static void main(String[] args){
    sieve();
    int n=2,k=15 ;
    System.out.println(kthPrimeGreaterThanN(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX_SIZE : int := 1e6->oclAsType(int);
  static   attribute prime : Sequence(boolean) := Integer.subrange(1,MAX_SIZE + 1)->collect(false);
  static   operation sieve() : void
  pre: true
  post: true
  activity: (     prime := prime->collect(true) ; 
         var p : int ; p := 2 ; while p * p <= MAX_SIZE do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * p ; while i <= MAX_SIZE do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation kthPrimeGreaterThanN( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := -1 ;
         var i : int ; i := n + 1 ; while i < MAX_SIZE do ( (     if (prime[i+1] = true) then     k := k - 1 ; else skip ; 
     if (k = 0) then (     res := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute sieve() ; 
     var n : int ; n := 2 ;
    var k : int ; k := 15 ;
     OclFile["System.out"].println(kthPrimeGreaterThanN(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static void printFibonacciNumbers(int n){
    int f1=0,f2=1,i ;
    if(n<1)return ;
    for(i=1 ; i<=n ; i++){
      System.out.print(f2+" ");
      int next=f1+f2 ;
      f1=f2 ;
      f2=next ;
    }
  }
  public static void main(String[] args){
    printFibonacciNumbers(7);
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation printFibonacciNumbers( n : int) : void
  pre: true
  post: true
  activity: (     var f1 : int ; f1 := 0 ;
    var f2 : int ; f2 := 1 ;
    var i : int ;
     if (n < 1) then     return else skip ; 
         i := 1 ; while i <= n do ( (     OclFile["System.out"].print(f2 + " ") ; 
     var next : int ; next := f1 + f2 ;
     f1 := f2 ; 
     f2 := next )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute printFibonacciNumbers(7) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAX=50 ;
  static void remove_row_col(int arr[][],int n,int x){
    for(int i=x ; i<n ; i++){
      for(int j=x ; j<n ; j++){
        System.out.print(arr[i][j]+" ");
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    int n=3 ;
    int arr[][]={
      {
        1,2,3 },{
          4,5,6 },{
            7,8,9 }
          };
          int x=1 ;
          remove_row_col(arr,n,x);
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 50;
  static   operation remove_row_col( arr : Sequence(Sequence(int)), n : int, x : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := x ; while i < n do ( (         var j : int ; j := x ; while j < n do ( (     OclFile["System.out"].print(arr[i+1][j+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,2,3},Sequence{4,5,6},Sequence{7,8,9}} ;
     var x : int ; x := 1 ;
     execute remove_row_col(arr, n, x) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    aoj solver=new aoj();
    solver.solve(1,in,out);
    out.close();
  }
  static class aoj {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      long[] len=new long[3];
      while(true){
        len[0]=in.nextLong();
        len[1]=in.nextLong();
        len[2]=in.nextLong();
        if(len[0]==0 && len[1]==0 && len[2]==0)break ;
        Arrays.sort(len);
        double min1=len[0],min2=len[1];
        int loops=in.nextInt();
        for(int i=0 ; i<loops ; i++){
          long r=in.nextLong()*2 ;
          if(min1*min1+min2*min2<r*r){
            out.println("OK");
          }
          else {
            out.println("NA");
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : aoj ; solver := aoj.newaoj() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class aoj {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var len : Sequence(long) ; len := Integer.subrange(1,3)->collect(0) ;
     while (true) do (     len[0+1] := in.getCurrent()->toLong() ; 
     len[1+1] := in.getCurrent()->toLong() ; 
    len[2+1] := in.getCurrent()->toLong() ; 
    if (len[0+1] = 0 & len[1+1] = 0 & len[2+1] = 0) then     break else skip ; 
    len := len->sort() ; 
    var min1 : double ; min1 := len[0+1] ;
    var min2 : double ; min2 := len[1+1] ;
    var loops : int ; loops := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < loops do ( (     var r : long ; r := in.getCurrent()->toLong() * 2 ;
     if (min1 * min1 + min2 * min2 < r * r) then (     skip ) else (     skip ) )  ;     i := i + 1 ) ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Iterator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    String pass="" ;
    String code=scn.next();
    String[] nums=new String[10];
    for(int i=0 ; i<10 ; i++)nums[i]=scn.next();
    String[] symb=new String[8];
    for(int i=0 ; i<8 ; i++){
      symb[i]="" ;
      for(int k=0 ; k<10 ; k++){
        symb[i]+=code.charAt(k+i*10);
      }
    }
    for(int i=0 ; i<8 ; i++){
      for(int k=0 ; k<10 ; k++){
        if(symb[i] .equals(nums[k])){
          pass+=k ;
          break ;
        }
      }
    }
    System.out.println(pass);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pass : String ; pass := "" ;
    var code : String ; code := scn.getCurrent() ;
    var nums : Sequence(String) ; nums := Integer.subrange(1,10)->collect(null) ;
        var i : int ; i := 0 ; while i < 10 do (     nums[i+1] := scn.getCurrent() ;  ;     i := i + 1 ) ; 
    var symb : Sequence(String) ; symb := Integer.subrange(1,8)->collect(null) ;
        var i : int ; i := 0 ; while i < 8 do ( (     symb[i+1] := "" ; 
         var k : int ; k := 0 ; while k < 10 do ( (     symb[i+1] := symb[i+1]+(code->at(k + i * 10+1)) )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 8 do ( (         var k : int ; k := 0 ; while k < 10 do ( (     if (symb[i+1] = nums[k+1]) then (     pass := pass+(k) ; 
     break ) else skip )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(pass) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Test {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    Map<String,Integer>password=new HashMap<>();
    String code=in.next();
    for(int i=0 ; i<10 ; i++){
      String key=in.next();
      password.put(key,i);
    }
    for(int i=0 ; i<80 ; i+=10){
      String s=code.substring(i,(i+10));
      System.out.print(password.get(s));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var password : Map(String,int) ; password := Map{} ;
    var code : String ; code := in.getCurrent() ;
        var i : int ; i := 0 ; while i < 10 do ( (     var key : String ; key := in.getCurrent() ;
     password := password->union(Map{key |-> i}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 80 do ( (     var s : String ; s := code.subrange(i+1,(i + 10)) ;
     OclFile["System.out"].print(password->at(s)) )  ;     i := i+(10) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class RestoringPassword {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String value=scanner.next();
    Map<String,Integer>maps=new HashMap<>();
    for(int i=0 ; i<10 ; i++){
      maps.put(scanner.next(),i);
    }
    for(int i=0 ; i<80 ; i+=10){
      System.out.print(maps.get(value.subSequence(i,i+10)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class RestoringPassword {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var value : String ; value := scanner.getCurrent() ;
    var maps : Map(String,int) ; maps := Map{} ;
        var i : int ; i := 0 ; while i < 10 do ( (     maps := maps->union(Map{scanner.getCurrent() |-> i}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 80 do ( (     OclFile["System.out"].print(maps->at(value.subrange(i+1,i + 10))) )  ;     i := i+(10) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication118 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayList<String>arr=new ArrayList<>();
    String s=sc.next();
    for(int i=0 ; i<10 ; i++){
      arr.add(sc.next());
    }
    for(int i=0 ; i<8 ; i++){
      String h=s.subSequence(i*10,(i+1)*10).toString();
      for(int j=0 ; j<arr.size(); j++){
        if(h.contains(arr.get(j))){
          System.out.print(j);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication118 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(String) ; arr := Sequence{} ;
    var s : String ; s := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < 10 do ( (     arr := arr->including(sc.getCurrent()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 8 do ( (     var h : String ; h := s.subrange(i * 10+1,(i + 1) * 10)+"" ;
         var j : int ; j := 0 ; while j < arr->size() do ( (     if (h->includes(arr->at(j+1))) then (     OclFile["System.out"].print(j) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    int counter=0 ;
    while(input.ready()){
      String[] inputStr=input.readLine().split(" ");
      final int FROM_YEAR=Integer.parseInt(inputStr[0]);
      final int TO_YEAR=Integer.parseInt(inputStr[1]);
      if(TO_YEAR==0){
        break ;
      }
      if(counter>0){
        System.out.println();
      }
      counter++;
      ArrayList<Integer>ansList=leapYearCount(FROM_YEAR,TO_YEAR);
      if(ansList.size()==0){
        System.out.println("NA");
        continue ;
      }
      for(Integer each : ansList){
        System.out.println(each);
      }
    }
  }
  private static ArrayList<Integer>leapYearCount(int fromYear,int toYear){
    ArrayList<Integer>yearList=new ArrayList<>();
    for(int i=fromYear ; i<=toYear ; i++){
      if(isLeapYear(i)){
        yearList.add(i);
      }
    }
    return yearList ;
  }
  private static boolean isLeapYear(int year){
    if(year % 4!=0){
      return false ;
    }
    if(year % 100==0){
      if(year % 400==0){
        return true ;
      }
      return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var counter : int ; counter := 0 ;
     while (input.canRead()) do (     var inputStr : Sequence(String) ; inputStr := input.readLine()->split(" ") ;
     var FROM_YEAR : int ; FROM_YEAR := (inputStr[0+1])->toInteger() ;
    var TO_YEAR : int ; TO_YEAR := (inputStr[1+1])->toInteger() ;
    if (TO_YEAR = 0) then (     break ) else skip ; 
    if (counter > 0) then (     OclFile["System.out"].println() ) else skip ; 
    counter := counter + 1 ; 
    var ansList : Sequence(int) ; ansList := leapYearCount(FROM_YEAR, TO_YEAR) ;
    if (ansList->size() = 0) then (     OclFile["System.out"].println("NA") ; 
     continue ) else skip ; 
    for (each : ansList) do ( (     OclFile["System.out"].println(each) )  ) ; 
 ) );
  static   operation leapYearCount( fromYear : int, toYear : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var yearList : Sequence(int) ; yearList := Sequence{} ;
         var i : int ; i := fromYear ; while i <= toYear do ( (     if (isLeapYear(i)) then (     yearList := yearList->including(i) ) else skip )  ;     i := i + 1 ) ; 
     return yearList );
  static   operation isLeapYear( year : int) : boolean
  pre: true
  post: true
  activity: (     if (year mod 4 /= 0) then (     return false ) else skip ; 
     if (year mod 100 = 0) then (     if (year mod 400 = 0) then (     return true ) else skip ; 
     return false ) else skip ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GfG {
  static int digSum(int n){
    int sum=0 ;
    while(n>0 || sum>9){
      if(n==0){
        n=sum ;
        sum=0 ;
      }
      sum+=n % 10 ;
      n/=10 ;
    }
    return sum ;
  }
  public static void main(String argc[]){
    int n=1234 ;
    System.out.println(digSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation digSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n > 0 or sum > 9) do (     if (n = 0) then (     n := sum ; 
     sum := 0 ) else skip ; 
     sum := sum+(n mod 10) ; 
     n := n/(10) ) ; 
     return sum );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1234 ;
     OclFile["System.out"].println(digSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.concurrent.LinkedBlockingQueue ;
class Main {
  Scanner sc=new Scanner(System.in);
  public void run(){
    boolean[] isuruu=new boolean[3000];
    for(int i=0 ; i<3000 ; i++){
      isuruu[i]=i % 400==0 ||(i % 100!=0 && i % 4==0);
    }
    boolean isFirst=true ;
    while(true){
      int a=sc.nextInt(),b=sc.nextInt();
      if(a==0 && b==0)break ;
      if(! isFirst)ln();
      boolean isset=false ;
      for(int y=a ; y<=b ; y++){
        if(isuruu[y]){
          ln(y);
          isset=true ;
        }
      }
      if(! isset)ln("NA");
      isFirst=false ;
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  public static void pr(Object o){
    System.out.print(o);
  }
  public static void ln(Object o){
    System.out.println(o);
  }
  public static void ln(){
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var isuruu : Sequence(boolean) ; isuruu := Integer.subrange(1,3000)->collect(false) ;
         var i : int ; i := 0 ; while i < 3000 do ( (     isuruu[i+1] := i mod 400 = 0 or (i mod 100 /= 0 & i mod 4 = 0) )  ;     i := i + 1 ) ; 
     var isFirst : boolean ; isFirst := true ;
     while (true) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
     if (a = 0 & b = 0) then     break else skip ; 
    if (not(isFirst)) then     execute ln() ; else skip ; 
    var isset : boolean ; isset := false ;
        var y : int ; y := a ; while y <= b do ( (     if (isuruu[y+1]) then (     execute ln(y) ; 
     isset := true ) else skip )  ;     y := y + 1 ) ; 
    if (not(isset)) then     execute ln("NA") ; else skip ; 
    isFirst := false ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    ArrayList<String>result=new ArrayList<String>();
    String[] s ;
    int a,b,i ;
    boolean flg,exst ;
    Scanner sc=new Scanner(System.in);
    while(true){
      s=sc.nextLine().split("\\s");
      a=Integer.parseInt(s[0]);
      b=Integer.parseInt(s[1]);
      if(a+b==0){
        break ;
      }
      exst=false ;
      for(i=a ; i<=b ; i++){
        flg=false ;
        if(i % 400==0){
          flg=true ;
        }
        else if(i % 4==0 && i % 100!=0){
          flg=true ;
        }
        if(flg){
          result.add(String.valueOf(i));
          exst=true ;
        }
      }
      if(! exst){
        result.add("NA");
      }
      result.add("");
    }
    for(i=0 ; i<result.size()-1 ; i++){
      System.out.println(result.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var result : Sequence(String) ; result := Sequence{} ;
     var s : Sequence(String) ;
    var a : int ;
    var b : int ;
    var i : int ;
    var flg : boolean ;
    var exst : boolean ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (true) do (     s := sc.nextLine()->split("\\s") ; 
     a := (s[0+1])->toInteger() ; 
    b := (s[1+1])->toInteger() ; 
    if (a + b = 0) then (     break ) else skip ; 
    exst := false ; 
        i := a ; while i <= b do ( (     flg := false ; 
     if (i mod 400 = 0) then (     flg := true ) else     if (i mod 4 = 0 & i mod 100 /= 0) then (     flg := true ) else skip ; ;  
     if (flg) then (     result := result->including(((i) + "")) ; 
     exst := true ) else skip )  ;     i := i + 1 ) ; 
    if (not(exst)) then (     result := result->including("NA") ) else skip ; 
    result := result->including("") ; 
 ) ; 
        i := 0 ; while i < result->size() - 1 do ( (     OclFile["System.out"].println(result->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.LinkedList ;
import java.util.List ;
public class Main {
  public static void main(String[] args){
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    List<String>inputDataList=new ArrayList<String>();
    String input=null ;
    try {
      while((input=in.readLine())!=null){
        inputDataList.add(input);
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
    finally {
      try {
        in.close();
      }
      catch(IOException e){
        e.printStackTrace();
      }
    }
    boolean firstTry=true ;
    for(String inputData : inputDataList){
      String[] years=inputData.split(" ");
      int start=Integer.parseInt(years[0]);
      int end=Integer.parseInt(years[1]);
      if(start==0 && end==0){
        break ;
      }
      if(firstTry){
        firstTry=false ;
      }
      else {
        System.out.println();
      }
      searchLeapYear(start,end);
    }
  }
  private static void searchLeapYear(int start,int end){
    List<Integer>leapYearList=new LinkedList<Integer>();
    for(int i=start ; i<=end ; i++){
      if(i % 4==0){
        if(i % 100!=0){
          leapYearList.add(i);
        }
        else {
          if(i % 400==0){
            leapYearList.add(i);
          }
        }
      }
    }
    if(leapYearList.size()!=0){
      for(Integer year : leapYearList){
        System.out.println(year);
      }
    }
    else {
      System.out.println("NA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var inputDataList : Sequence(String) ; inputDataList := Sequence{} ;
    var input : String ; input := null ;
    try (         input := in.readLine() ;
    while ((input) /= null) do (    skip ; (     inputDataList := inputDataList->including(input) ) ;     input := in.readLine() ;
 ) )   catch (e : IOException) do (     e.printStackTrace() )
   finally (     try (     skip )   catch (e : IOException) do (     e.printStackTrace() )
 )
    var firstTry : boolean ; firstTry := true ;
    for (inputData : inputDataList) do ( (     var years : Sequence(String) ; years := inputData->split(" ") ;
     var start : int ; start := (years[0+1])->toInteger() ;
    var end : int ; end := (years[1+1])->toInteger() ;
    if (start = 0 & end = 0) then (     break ) else skip ; 
    if (firstTry) then (     firstTry := false ) else (     OclFile["System.out"].println() ) ;  
    execute searchLeapYear(start, end) ; 
 )  ) ; 
 );
  static   operation searchLeapYear( start : int, end : int) : void
  pre: true
  post: true
  activity: (     var leapYearList : Sequence(int) ; leapYearList := Sequence{} ;
         var i : int ; i := start ; while i <= end do ( (     if (i mod 4 = 0) then (     if (i mod 100 /= 0) then (     leapYearList := leapYearList->including(i) ) else (     if (i mod 400 = 0) then (     leapYearList := leapYearList->including(i) ) else skip ) ) else skip )  ;     i := i + 1 ) ; 
     if (leapYearList->size() /= 0) then (     for (year : leapYearList) do ( (     OclFile["System.out"].println(year) )  ) ) else (     OclFile["System.out"].println("NA") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  void run(){
    sc=new Scanner(System.in);
    int y1=sc.nextInt();
    int y2=sc.nextInt();
    for(; ; ){
      boolean f=false ;
      for(int y=y1 ; y<=y2 ; y++){
        if(y % 4==0 &&(y % 100!=0 || y % 400==0)){
          println(y+"");
          f=true ;
        }
      }
      if(! f)println("NA");
      y1=sc.nextInt();
      y2=sc.nextInt();
      if(y1==0 && y2==0)break ;
      println("");
    }
    sc.close();
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var y1 : int ; y1 := sc.getCurrent()->toInteger() ;
    var y2 : int ; y2 := sc.getCurrent()->toInteger() ;
      while true do ( (     var f : boolean ; f := false ;
         var y : int ; y := y1 ; while y <= y2 do ( (     if (y mod 4 = 0 & (y mod 100 /= 0 or y mod 400 = 0)) then (     execute println(y + "") ; 
     f := true ) else skip )  ;     y := y + 1 ) ; 
    if (not(f)) then     execute println("NA") ; else skip ; 
    y1 := sc.getCurrent()->toInteger() ; 
    y2 := sc.getCurrent()->toInteger() ; 
    if (y1 = 0 & y2 = 0) then     break else skip ; 
    execute println("") ; 
 )  ) ; 
    skip ; 
 );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    List<List<String>>result=new ArrayList<List<String>>();
    long[] x=new long[3];
    for(int i=0 ; i<3 ; i++){
      x[i]=stdIn.nextLong();
    }
    while(x[0]!=0 || x[1]!=0 || x[2]!=0){
      List<String>list=new ArrayList<String>();
      for(int i=0 ; i<3 ; i++){
        int max=i ;
        for(int j=i+1 ; j<3 ; j++){
          if(x[j]>x[max]){
            max=j ;
          }
        }
        long temp=x[max];
        x[max]=x[i];
        x[i]=temp ;
      }
      long r=x[1]*x[1]+x[2]*x[2];
      int n=stdIn.nextInt();
      for(int i=0 ; i<n ; i++){
        long m=stdIn.nextLong();
        if(4*m*m<=r){
          list.add("NA");
        }
        else {
          list.add("OK");
        }
      }
      result.add(list);
      x[0]=stdIn.nextLong();
      x[1]=stdIn.nextLong();
      x[2]=stdIn.nextLong();
    }
    for(List<String>ans : result){
      for(String str : ans){
        System.out.println(str);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var result : Sequence(Sequence(String)) ; result := Sequence{} ;
    var x : Sequence(long) ; x := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     x[i+1] := stdIn.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    while (x[0+1] /= 0 or x[1+1] /= 0 or x[2+1] /= 0) do (     var list : Sequence(String) ; list := Sequence{} ;
         var i : int ; i := 0 ; while i < 3 do ( (     var max : int ; max := i ;
         var j : int ; j := i + 1 ; while j < 3 do ( (     if (x[j+1] > x[max+1]) then (     max := j ) else skip )  ;     j := j + 1 ) ; 
    var temp : long ; temp := x[max+1] ;
    x[max+1] := x[i+1] ; 
    x[i+1] := temp ; 
 )  ;     i := i + 1 ) ; 
    var r : long ; r := x[1+1] * x[1+1] + x[2+1] * x[2+1] ;
    var n : int ; n := stdIn.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var m : long ; m := stdIn.getCurrent()->toLong() ;
     if (4 * m * m <= r) then (     list := list->including("NA") ) else (     list := list->including("OK") ) )  ;     i := i + 1 ) ; 
    result := result->including(list) ; 
    x[0+1] := stdIn.getCurrent()->toLong() ; 
    x[1+1] := stdIn.getCurrent()->toLong() ; 
    x[2+1] := stdIn.getCurrent()->toLong() ; 
 ) ; 
    for (ans : result) do ( (     for (str : ans) do ( (     OclFile["System.out"].println(str) )  ) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final int N=sc.nextInt();
    long[] difficults=new long[N];
    long[] partial_sum=new long[N];
    for(int i=0 ; i<N ; i++){
      final long a=sc.nextLong();
      difficults[i]=a ;
    }
    Arrays.sort(difficults);
    for(int i=0 ; i<N ; i++){
      partial_sum[i]=difficults[i]+(i==0 ? 0 : partial_sum[i-1]);
    }
    final int M=sc.nextInt();
    int[] solver=new int[M];
    for(int i=0 ; i<M ; i++){
      final int b=sc.nextInt();
      solver[i]=b ;
    }
    for(int i=0 ; i<M ; i++){
      final long purpose=sc.nextLong();
      final int rate=solver[i];
      if(difficults[0]>rate){
        System.out.println(purpose<=0 ? "Yes" : "No");
      }
      else {
        int lower=0 ;
        int higher=N ;
        while(lower+1!=higher){
          final int mid=(lower+higher)/2 ;
          if(difficults[mid]<=solver[i]){
            lower=mid ;
          }
          else {
            higher=mid ;
          }
        }
        final long score=partial_sum[lower];
        System.out.println(score>=purpose ? "Yes" : "No");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var difficults : Sequence(long) ; difficults := Integer.subrange(1,N)->collect(0) ;
    var partial_sum : Sequence(long) ; partial_sum := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     var a : long ; a := sc.getCurrent()->toLong() ;
     difficults[i+1] := a )  ;     i := i + 1 ) ; 
    difficults := difficults->sort() ; 
        var i : int ; i := 0 ; while i < N do ( (     partial_sum[i+1] := difficults[i+1] + (if i = 0 then 0 else partial_sum[i - 1+1] endif) )  ;     i := i + 1 ) ; 
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var solver : Sequence(int) ; solver := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     var b : int ; b := sc.getCurrent()->toInteger() ;
     solver[i+1] := b )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var purpose : long ; purpose := sc.getCurrent()->toLong() ;
     var rate : int ; rate := solver[i+1] ;
     if (difficults[0+1] > rate) then (     OclFile["System.out"].println(if purpose <= 0 then "Yes" else "No" endif) ) else (     var lower : int ; lower := 0 ;
     var higher : int ; higher := N ;
    while (lower + 1 /= higher) do (     var mid : int ; mid := (lower + higher) / 2 ;
     if (difficults[mid+1] <= solver[i+1]) then (     lower := mid ) else (     higher := mid ) ) ; 
    var score : long ; score := partial_sum[lower+1] ;
    OclFile["System.out"].println(if score >= purpose then "Yes" else "No" endif) ; 
 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new RitProA().doIt();
  }
  class RitProA {
    void doIt(){
      int N=in.nextInt();
      int a[]=new int[N];
      long sum[]=new long[1000002];
      for(int i=0 ; i<N ; i++){
        a[i]=in.nextInt();
      }
      Arrays.sort(a);
      long cnt=0 ;
      for(int i=0 ; i<N ; i++){
        cnt=cnt+a[i];
        sum[a[i] ]=cnt ;
      }
      for(int i=0 ; i<1000000 ; i++){
        if(sum[i+1]==0){
          sum[i+1]=sum[i];
        }
      }
      int M=in.nextInt();
      int b[]=new int[M];
      long c[]=new long[M];
      for(int i=0 ; i<M ; i++){
        b[i]=in.nextInt();
      }
      for(int i=0 ; i<M ; i++){
        c[i]=in.nextLong();
      }
      for(int i=0 ; i<M ; i++){
        if(sum[b[i] ]>=c[i]){
          System.out.println("Yes");
        }
        else {
          System.out.println("No");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     RitProA.newRitProA().doIt() );
 class RitProA {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var sum : Sequence(long) ; sum := Integer.subrange(1,1000002)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var cnt : long ; cnt := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     cnt := cnt + a[i+1] ; 
     sum[a[i+1]+1] := cnt )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 1000000 do ( (     if (sum[i + 1+1] = 0) then (     sum[i + 1+1] := sum[i+1] ) else skip )  ;     i := i + 1 ) ; 
    var M : int ; M := in.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Integer.subrange(1,M)->collect(0) ;
    var c : Sequence(long) ; c := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     b[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     c[i+1] := in.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     if (sum[b[i+1]+1] >= c[i+1]) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) )  ;     i := i + 1 ) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
public class Main {
  static final int MAX=1_000_001 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int N=parseInt(br.readLine());
    long[] sum=new long[MAX];
    StringTokenizer st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<N ; i++){
      int a=parseInt(st.nextToken());
      sum[a]+=a ;
    }
    for(int i=1 ; i<MAX ; i++){
      sum[i]+=sum[i-1];
    }
    int M=parseInt(br.readLine());
    int[] b=new int[M];
    long[] c=new long[M];
    st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<M ; i++){
      b[i]=parseInt(st.nextToken());
    }
    st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<M ; i++){
      c[i]=parseLong(st.nextToken());
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<M ; i++){
      if(sum[b[i] ]>=c[i]){
        sb.append("Yes\n");
      }
      else {
        sb.append("No\n");
      }
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 1_000_001;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var N : int ; N := parseInt(br.readLine()) ;
    var sum : Sequence(long) ; sum := Integer.subrange(1,MAX)->collect(0) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := parseInt(st.next()) ;
     sum[a+1] := sum[a+1]+(a) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < MAX do ( (     sum[i+1] := sum[i+1]+(sum[i - 1+1]) )  ;     i := i + 1 ) ; 
    var M : int ; M := parseInt(br.readLine()) ;
    var b : Sequence(int) ; b := Integer.subrange(1,M)->collect(0) ;
    var c : Sequence(long) ; c := Integer.subrange(1,M)->collect(0) ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < M do ( (     b[i+1] := (st.next() + "")->toInteger() )  ;     i := i + 1 ) ; 
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < M do ( (     c[i+1] := parseLong(st.next()) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < M do ( (     if (sum[b[i+1]+1] >= c[i+1]) then (     sb := sb + StringLib.newString("Yes\n") ) else (     sb := sb + StringLib.newString("No\n") ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeSet ;
public class B334 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int[] X=new int[8];
    int[] Y=new int[8];
    Set<Integer>xSet=new TreeSet<>();
    Set<Integer>ySet=new TreeSet<>();
    for(int i=0 ; i<8 ; i++){
      int x=in.nextInt();
      int y=in.nextInt();
      X[i]=x ;
      Y[i]=y ;
      xSet.add(x);
      ySet.add(y);
    }
    boolean ok=xSet.size()==3 && ySet.size()==3 ;
    if(ok){
      Integer[] xArray=new Integer[3];
      Integer[] yArray=new Integer[3];
      xSet.toArray(xArray);
      ySet.toArray(yArray);
      for(int x : xArray){
        for(int y : yArray){
          if(x!=(int)xArray[1] || y!=(int)yArray[1]){
            boolean found=false ;
            for(int i=0 ; i<8 ; i++){
              if(X[i]==x && Y[i]==y){
                found=true ;
              }
            }
            ok &=found ;
          }
        }
      }
    }
    System.out.println(ok ? "respectable" : "ugly");
  }
}
------------------------------------------------------------
OCL File:
---------
 class B334 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : Sequence(int) ; X := Integer.subrange(1,8)->collect(0) ;
    var Y : Sequence(int) ; Y := Integer.subrange(1,8)->collect(0) ;
    var xSet : Set(int) ; xSet := Set{} ;
    var ySet : Set(int) ; ySet := Set{} ;
        var i : int ; i := 0 ; while i < 8 do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var y : int ; y := in.getCurrent()->toInteger() ;
    X[i+1] := x ; 
    Y[i+1] := y ; 
    xSet := xSet->including(x) ; 
    ySet := ySet->including(y) ; 
 )  ;     i := i + 1 ) ; 
    var ok : boolean ; ok := xSet->size() = 3 & ySet->size() = 3 ;
    if (ok) then (     var xArray : Sequence(int) ; xArray := Integer.subrange(1,3)->collect(null) ;
     var yArray : Sequence(int) ; yArray := Integer.subrange(1,3)->collect(null) ;
    xSet := xSet.toArray(xArray) ; 
    ySet := ySet.toArray(yArray) ; 
    for (x : xArray) do ( (     for (y : yArray) do ( (     if (x /= xArray[1+1]->oclAsType(int) or y /= yArray[1+1]->oclAsType(int)) then (     var found : boolean ; found := false ;
         var i : int ; i := 0 ; while i < 8 do ( (     if (X[i+1] = x & Y[i+1] = y) then (     found := true ) else skip )  ;     i := i + 1 ) ; 
     ok := MathLib.bitwiseAnd(ok, found) ) else skip )  ) )  ) ; 
 ) else skip ; 
    OclFile["System.out"].println(if ok then "respectable" else "ugly" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    AAProblemAboutPolyline solver=new AAProblemAboutPolyline();
    solver.solve(1,in,out);
    out.close();
  }
  static class AAProblemAboutPolyline {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int a=in.nextInt(),b=in.nextInt();
      if(b>a){
        out.println(-1);
        return ;
      }
      double x=(double)(a+b)/2 ;
      int periods=(int)x/b ;
      x/=periods ;
      out.println(Util.formatDouble(x));
    }
  }
  static class Util {
    public static String formatDouble(double x){
      return String.format("%.15f",x);
    }
    private Util(){
    }
  }
  static class InputReader {
    public final BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : AAProblemAboutPolyline ; solver := AAProblemAboutPolyline.newAAProblemAboutPolyline() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class AAProblemAboutPolyline {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.nextInt() ;
    var b : int ; b := in.nextInt() ;
     if (b > a) then (     skip ; 
     return ) else skip ; 
    var x : double ; x := (a + b)->oclAsType(double) / 2 ;
    var periods : int ; periods := x->oclAsType(int) / b ;
    x := x/(periods) ; 
    skip ; 
 );
}
  static class Util {
  static   operation formatDouble( x : double) : String
  pre: true
  post: true
  activity: (     return StringLib.format("%.15f",Sequence{x}) );
   static operation newUtil() : Util
  pre: true
  post: true
  activity:
  ( var self : Util ;
    self := createUtil();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    String a=sc.next(),b=sc.next();
    int[][] dp=new int[n+1][m+1];
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=m ; j++){
        dp[i][j]=Math.max(dp[i][j],Math.max(dp[i-1][j],dp[i][j-1])-1);
        if(a.charAt(i-1)==b.charAt(j-1)){
          dp[i][j]=Math.max(dp[i][j],dp[i-1][j-1]+2);
        }
      }
    }
    int ans=0 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=m ; j++){
        ans=Math.max(ans,dp[i][j]);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : String ; a := sc.getCurrent() ;
    var b : String ; b := sc.getCurrent() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= m do ( (     dp[i+1][j+1] := Set{dp[i+1][j+1], Set{dp[i - 1+1][j+1], dp[i+1][j - 1+1]}->max() - 1}->max() ; 
     if (a->at(i - 1+1) = b->at(j - 1+1)) then (     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i - 1+1][j - 1+1] + 2}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= m do ( (     ans := Set{ans, dp[i+1][j+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF578A extends PrintWriter {
  CF578A(){
    super(System.out,true);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    CF578A o=new CF578A();
    o.main();
    o.flush();
  }
  void main(){
    int x=sc.nextInt();
    int y=sc.nextInt();
    if(x<y){
      println(-1);
      return ;
    }
    if(x==y){
      println(y);
      return ;
    }
    double z1=(double)(x+y)/((x+y)/(2*y)*2);
    double z2=(double)(x-y)/((x-y)/(2*y)*2);
    printf("%.9f\n",Math.min(z1,z2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF578A extends OclFile {
   static operation newCF578A() : CF578A
  pre: true
  post: true
  activity:
  ( var self : CF578A ;
    self := createCF578A();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"], true) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : CF578A ; o := CF578A.newCF578A() ;
     o.main() ; 
     o.flush() );
   operation main() : void
  pre: true
  post: true
  activity: (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    if (x < y) then (     execute println(-1) ; 
     return ) else skip ; 
    if (x = y) then (     execute println(y) ; 
     return ) else skip ; 
    var z1 : double ; z1 := (x + y)->oclAsType(double) / ((x + y) / (2 * y) * 2) ;
    var z2 : double ; z2 := (x - y)->oclAsType(double) / ((x - y) / (2 * y) * 2) ;
    execute printf("%.9f\n", Set{z1, z2}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int count=0 ;
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner sc2=new Scanner(System.in);
    String[] s=sc2.nextLine().split("[\\s]+");
    double x=Double.parseDouble(s[0])-Double.parseDouble(s[2]);
    double y=Double.parseDouble(s[1])-Double.parseDouble(s[3]);
    System.out.println(Math.sqrt(x*x+y*y));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute count : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc2 : OclFile ; sc2 := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc2.nextLine()->split("[\\s]+") ;
    var x : double ; x := (s[0+1])->toReal() - (s[2+1])->toReal() ;
    var y : double ; y := (s[1+1])->toReal() - (s[3+1])->toReal() ;
    OclFile["System.out"].println((x * x + y * y)->sqrt()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    double x1=scan.nextDouble();
    double y1=scan.nextDouble();
    double x2=scan.nextDouble();
    double y2=scan.nextDouble();
    System.out.printf("%.8f",Math.sqrt(((x2-x1)*(x2-x1))+((y2-y1)*(y2-y1))));
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
    var x1 : double ; x1 := scan.getCurrent()->toReal() ;
    var y1 : double ; y1 := scan.getCurrent()->toReal() ;
    var x2 : double ; x2 := scan.getCurrent()->toReal() ;
    var y2 : double ; y2 := scan.getCurrent()->toReal() ;
    OclFile["System.out"].printf("%.8f", (((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)))->sqrt()) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Point {
  private double x,y ;
  public Point(double x,double y){
    this.x=x ;
    this.y=y ;
  }
  public double getX(){
    return x ;
  }
  public double getY(){
    return y ;
  }
}
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Point[] points=new Point[2];
    for(int i=0 ; i<2 ; i++){
      points[i]=new Point(sc.nextDouble(),sc.nextDouble());
    }
    double x=points[0] .getX()-points[1] .getX();
    double y=points[0] .getY()-points[1] .getY();
    double distance=Math.sqrt(Math.pow(x,2)+Math.pow(y,2));
    System.out.printf("%.6f \n",distance);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Point {
   attribute x : double;
   static operation newPoint( x : double, y : double) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation getX() : double
  pre: true
  post: true
  activity: (     return x );
   operation getY() : double
  pre: true
  post: true
  activity: (     return y );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var points : Sequence(Point) ; points := Integer.subrange(1,2)->collect(null) ;
        var i : int ; i := 0 ; while i < 2 do ( (     points[i+1] := Point.newPoint(sc.getCurrent()->toReal(), sc.getCurrent()->toReal()) )  ;     i := i + 1 ) ; 
    var x : double ; x := points[0+1].getX() - points[1+1].getX() ;
    var y : double ; y := points[0+1].getY() - points[1+1].getY() ;
    var distance : double ; distance := (x->pow(2) + y->pow(2))->sqrt() ;
    OclFile["System.out"].printf("%.6f \n", distance) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine()," ");
    double a=Double.parseDouble(st.nextToken());
    double b=Double.parseDouble(st.nextToken());
    double c=Double.parseDouble(st.nextToken());
    double d=Double.parseDouble(st.nextToken());
    System.out.printf("%.8f",Math.sqrt(Math.pow(c-a,2)+Math.pow(d-b,2)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String_String(br.readLine(), " ") ;
    var a : double ; a := (st.next())->toReal() ;
    var b : double ; b := (st.next())->toReal() ;
    var c : double ; c := (st.next())->toReal() ;
    var d : double ; d := (st.next())->toReal() ;
    OclFile["System.out"].printf("%.8f", (c - a->pow(2) + d - b->pow(2))->sqrt()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication173 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String x=sc.next();
    String y=sc.next();
    for(int i=0 ; i<x.length(); i++){
      if(x.charAt(i)<y.charAt(i)){
        System.out.println("-1");
        return ;
      }
    }
    System.out.println(y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication173 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : String ; x := sc.getCurrent() ;
    var y : String ; y := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < x->size() do ( (     if (x->at(i+1) < y->at(i+1)) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(y) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static long gcd(long a,long b){
    if(a==0){
      return b ;
    }
    return gcd(b % a,a);
  }
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    int n=Integer.parseInt(f.readLine());
    StringTokenizer st=new StringTokenizer(f.readLine());
    int[] c=new int[n];
    for(int i=0 ; i<n ; i++){
      c[i]=Integer.parseInt(st.nextToken())-1 ;
    }
    ArrayList<Integer>cycles=new ArrayList<>();
    boolean[] visited=new boolean[n];
    boolean flag=false ;
    for(int i=0 ; i<n ; i++){
      if(! visited[i]){
        int j=i ;
        int length=0 ;
        while(! visited[j]){
          visited[j]=true ;
          j=c[j];
          length++;
        }
        if(j!=i){
          flag=true ;
          break ;
        }
        cycles.add(length);
      }
    }
    if(flag){
      out.println(-1);
    }
    else {
      long total=1 ;
      for(int i : cycles){
        long gcd=gcd(total,i);
        total*=i ;
        total/=gcd ;
      }
      out.println(total % 2==0 ? total/2 : total);
    }
    f.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then (     return b ) else skip ; 
     return gcd(b mod a, a) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    var n : int ; n := (f.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := (st.next())->toInteger() - 1 )  ;     i := i + 1 ) ; 
    var cycles : Sequence(int) ; cycles := Sequence{} ;
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,n)->collect(false) ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (not(visited[i+1])) then (     var j : int ; j := i ;
     var length : int ; length := 0 ;
    while (not(visited[j+1])) do (     visited[j+1] := true ; 
     j := c[j+1] ; 
     length := length + 1 ) ; 
    if (j /= i) then (     flag := true ; 
     break ) else skip ; 
    cycles := cycles->including(length) ; 
 ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then (     skip ) else (     var total : long ; total := 1 ;
     for (i : cycles) do ( (     var gcd : long ; gcd := gcd(total, i) ;
     total := total*(i) ; 
     total := total/(gcd) )  ) ; 
     skip ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.text.DecimalFormat ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    double x1=input.nextDouble();
    double y1=input.nextDouble();
    double x2=input.nextDouble();
    double y2=input.nextDouble();
    DecimalFormat df=new DecimalFormat("#.#########");
    System.out.println(df.format(Math.sqrt(Math.pow((x1-x2),2)+Math.pow(y1-y2,2))));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : double ; x1 := input.getCurrent()->toReal() ;
    var y1 : double ; y1 := input.getCurrent()->toReal() ;
    var x2 : double ; x2 := input.getCurrent()->toReal() ;
    var y2 : double ; y2 := input.getCurrent()->toReal() ;
    var df : DecimalFormat ; df := DecimalFormat.newDecimalFormat("#.#########") ;
    OclFile["System.out"].println(df.format(((x1 - x2)->pow(2) + y1 - y2->pow(2))->sqrt())) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class guessgame {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n,p,p1 ;
    int x ;
    n=sc.nextLong();
    x=sc.nextInt();
    if(x==0){
      p=(long)Math.ceil(n/3.0);
      if(p % 2==0 &&(n % 3==2 || n % 3==0))System.out.println(0);
      else if(p % 2==1 &&(n % 3==1 || n % 3==2))System.out.println(1);
      else System.out.println(2);
    }
    else if(x==1){
      if(n % 3==1)System.out.println(0);
      else if(n % 3==0)System.out.println(1);
      else System.out.println(2);
    }
    else {
      p=(long)Math.ceil(n/3.0);
      if(p % 2==1 &&(n % 3==2 || n % 3==0))System.out.println(0);
      else if(p % 2==0 &&(n % 3==1 || n % 3==2))System.out.println(1);
      else System.out.println(2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class guessgame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ;
    var p : long ;
    var p1 : long ;
    var x : int ;
    n := sc.getCurrent()->toLong() ; 
    x := sc.getCurrent()->toInteger() ; 
    if (x = 0) then (     p := (n / 3.0)->ceil()->oclAsType(long) ; 
     if (p mod 2 = 0 & (n mod 3 = 2 or n mod 3 = 0)) then     OclFile["System.out"].println(0) ; else     if (p mod 2 = 1 & (n mod 3 = 1 or n mod 3 = 2)) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println(2) ; ;  ) else     if (x = 1) then (     if (n mod 3 = 1) then     OclFile["System.out"].println(0) ; else     if (n mod 3 = 0) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println(2) ; ;  ) else (     p := (n / 3.0)->ceil()->oclAsType(long) ; 
     if (p mod 2 = 1 & (n mod 3 = 2 or n mod 3 = 0)) then     OclFile["System.out"].println(0) ; else     if (p mod 2 = 0 & (n mod 3 = 1 or n mod 3 = 2)) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println(2) ; ;  ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class guessgame {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n,p,p1 ;
    int x ;
    n=sc.nextLong();
    x=sc.nextInt();
    if(x==0){
      p=(long)Math.ceil(n/3.0);
      if(p % 2==0 &&(n % 3==2 || n % 3==0))System.out.println(0);
      if(p % 2==1 &&(n % 3==1 || n % 3==2))System.out.println(1);
      if((n/3)% 2==1 &&(n % 3==0 || n % 3==1))System.out.println(2);
    }
    else if(x==1){
      if(n % 3==1)System.out.println(0);
      if(n % 3==0)System.out.println(1);
      if(n % 3==2)System.out.println(2);
    }
    else {
      p=(long)Math.ceil(n/3.0);
      if(p % 2==1 &&(n % 3==2 || n % 3==0))System.out.println(0);
      if(p % 2==0 &&(n % 3==1 || n % 3==2))System.out.println(1);
      if((n/3)% 2==0 &&(n % 3==0 || n % 3==1))System.out.println(2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class guessgame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ;
    var p : long ;
    var p1 : long ;
    var x : int ;
    n := sc.getCurrent()->toLong() ; 
    x := sc.getCurrent()->toInteger() ; 
    if (x = 0) then (     p := (n / 3.0)->ceil()->oclAsType(long) ; 
     if (p mod 2 = 0 & (n mod 3 = 2 or n mod 3 = 0)) then     OclFile["System.out"].println(0) ; else skip ; 
     if (p mod 2 = 1 & (n mod 3 = 1 or n mod 3 = 2)) then     OclFile["System.out"].println(1) ; else skip ; 
     if ((n / 3) mod 2 = 1 & (n mod 3 = 0 or n mod 3 = 1)) then     OclFile["System.out"].println(2) ; else skip ) else     if (x = 1) then (     if (n mod 3 = 1) then     OclFile["System.out"].println(0) ; else skip ; 
     if (n mod 3 = 0) then     OclFile["System.out"].println(1) ; else skip ; 
     if (n mod 3 = 2) then     OclFile["System.out"].println(2) ; else skip ) else (     p := (n / 3.0)->ceil()->oclAsType(long) ; 
     if (p mod 2 = 1 & (n mod 3 = 2 or n mod 3 = 0)) then     OclFile["System.out"].println(0) ; else skip ; 
     if (p mod 2 = 0 & (n mod 3 = 1 or n mod 3 = 2)) then     OclFile["System.out"].println(1) ; else skip ; 
     if ((n / 3) mod 2 = 0 & (n mod 3 = 0 or n mod 3 = 1)) then     OclFile["System.out"].println(2) ; else skip ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.io.IOException ;
import java.nio.file.Files ;
import java.nio.file.Paths ;
import java.util.Scanner ;
public class Main {
  static int solve(String a,String b){
    char[] cs1=a.toCharArray();
    char[] cs2=b.toCharArray();
    int[][] dp=new int[a.length()+1][b.length()+1];
    int mx=0 ;
    for(int i=a.length()-1 ; i>=0 ; i--){
      for(int j=b.length()-1 ; j>=0 ; j--){
        if(cs1[i]==cs2[j]){
          dp[i][j]=2+dp[i+1][j+1];
        }
        else {
          dp[i][j]=Math.max(dp[i+1][j]-1,dp[i][j+1]-1);
          dp[i][j]=Math.max(0,dp[i][j]);
        }
        mx=Math.max(mx,dp[i][j]);
      }
    }
    return mx ;
  }
  public static void main(String[] args)throws IOException {
    if(! isOj()){
      System.setIn(Files.newInputStream(Paths.get("src/main/java/input.txt")));
    }
    Scanner sc=new Scanner(new BufferedInputStream(System.in));
    sc.nextLine();
    String s1=sc.next();
    String s2=sc.next();
    System.out.println(solve(s1,s2));
  }
  static boolean isOj(){
    if(System.getProperty("ONLINE_JUDGE")!=null){
      return true ;
    }
    return System.getenv("CP_LOCAL_ENV")==null ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( a : String, b : String) : int
  pre: true
  post: true
  activity: (     var cs1 : Sequence(String) ; cs1 := a->characters() ;
     var cs2 : Sequence(String) ; cs2 := b->characters() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,a->size() + 1)->collect(Integer.subrange(1,b->size() + 1)->collect(0)) ;
    var mx : int ; mx := 0 ;
        var i : int ; i := a->size() - 1 ; while i >= 0 do ( (         var j : int ; j := b->size() - 1 ; while j >= 0 do ( (     if (cs1[i+1] = cs2[j+1]) then (     dp[i+1][j+1] := 2 + dp[i + 1+1][j + 1+1] ) else (     dp[i+1][j+1] := Set{dp[i + 1+1][j+1] - 1, dp[i+1][j + 1+1] - 1}->max() ; 
     dp[i+1][j+1] := Set{0, dp[i+1][j+1]}->max() ) ;  
     mx := Set{mx, dp[i+1][j+1]}->max() )  ;     j := j - 1 ) )  ;     i := i - 1 ) ; 
    return mx 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (not(isOj())) then ( setIn(Files.newInputStream(Paths->at("src/main/java/input.txt"+1))) ) else skip ; 
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    skip ; 
    var s1 : String ; s1 := sc.getCurrent() ;
    var s2 : String ; s2 := sc.getCurrent() ;
    OclFile["System.out"].println(solve(s1, s2)) ; 
 );
  static   operation isOj() : boolean
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") /= null) then (     return true ) else skip ; 
     return OclProcess.getEnvironmentProperty("CP_LOCAL_ENV") = null );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class practice {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int x=in.nextInt();
    n=n % 6 ;
    int l=0 ;
    int m=1 ;
    int r=2 ;
    while(n>0){
      if(n % 2==0){
        int temp=m ;
        m=r ;
        r=temp ;
      }
      else {
        int temp=m ;
        m=l ;
        l=temp ;
      }
      n--;
    }
    if(l==x){
      System.out.println(0);
    }
    else if(m==x){
      System.out.println(1);
    }
    else {
      System.out.println(2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
    n := n mod 6 ; 
    var l : int ; l := 0 ;
    var m : int ; m := 1 ;
    var r : int ; r := 2 ;
    while (n > 0) do (     if (n mod 2 = 0) then (     var temp : int ; temp := m ;
     m := r ; 
     r := temp ) else (     var temp : int ; temp := m ;
     m := l ; 
     l := temp ) ;  
     n := n - 1 ) ; 
    if (l = x) then (     OclFile["System.out"].println(0) ) else     if (m = x) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(2) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ShellGame {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x=sc.nextInt();
    n=n % 6 ;
    int[] state={
      0,1,2,2,1,0 };
      int pos=0 ;
      if(x==0){
        if(n % 2!=0)pos=5 ;
        else pos=0 ;
      }
      if(x==1){
        if(n % 2!=0)pos=1 ;
        else pos=4 ;
      }
      if(x==2){
        if(n % 2!=0)pos=3 ;
        else pos=2 ;
      }
      System.out.println(state[(6+pos-n)% 6]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class ShellGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    n := n mod 6 ; 
    var state : Sequence(int) ; state := Sequence{0,1,2,2,1,0} ;
    var pos : int ; pos := 0 ;
    if (x = 0) then (     if (n mod 2 /= 0) then     pos := 5 ; else     pos := 0 ; ) else skip ; 
    if (x = 1) then (     if (n mod 2 /= 0) then     pos := 1 ; else     pos := 4 ; ) else skip ; 
    if (x = 2) then (     if (n mod 2 /= 0) then     pos := 3 ; else     pos := 2 ; ) else skip ; 
    OclFile["System.out"].println(state[(6 + pos - n) mod 6+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static int j ;
  public static int y ;
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    j=stdIn.nextInt();
    y=stdIn.nextInt();
    solv(0,0,new int[10],0);
  }
  public static void solv(int a,int b,int[] c,int d){
    if(a==j && b==y){
      for(int i=0 ; i<d ; i++){
        System.out.print((c[i]==1)? "A" : "B");
      }
      System.out.println();
      return ;
    }
    if(a>j || b>y){
      return ;
    }
    if((a==5 && b<=3)||(a<=3 && b==5))return ;
    if(a==5 && b==5)return ;
    int[] ca=new int[10];
    int[] cb=new int[10];
    for(int i=0 ; i<d ; i++){
      ca[i]=c[i];
      cb[i]=c[i];
    }
    ca[d]=1 ;
    cb[d]=0 ;
    solv(a+1,b,ca,d+1);
    solv(a,b+1,cb,d+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute j : int;
  static   attribute y : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     j := stdIn.getCurrent()->toInteger() ; 
     y := stdIn.getCurrent()->toInteger() ; 
     execute solv(0, 0, Integer.subrange(1,10)->collect(0), 0) );
  static   operation solv( a : int, b : int, c : Sequence(int), d : int) : void
  pre: true
  post: true
  activity: (     if (a = j & b = y) then (         var i : int ; i := 0 ; while i < d do ( (     OclFile["System.out"].print(if (c[i+1] = 1) then "A" else "B" endif) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ; 
     return ) else skip ; 
     if (a > j or b > y) then (     return ) else skip ; 
    if ((a = 5 & b <= 3) or (a <= 3 & b = 5)) then     return else skip ; 
    if (a = 5 & b = 5) then     return else skip ; 
    var ca : Sequence(int) ; ca := Integer.subrange(1,10)->collect(0) ;
    var cb : Sequence(int) ; cb := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < d do ( (     ca[i+1] := c[i+1] ; 
     cb[i+1] := c[i+1] )  ;     i := i + 1 ) ; 
    ca[d+1] := 1 ; 
    cb[d+1] := 0 ; 
    execute solv(a + 1, b, ca, d + 1) ; 
    execute solv(a, b + 1, cb, d + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int j,y ;
      j=parseInt(line.substring(0,line.indexOf(' ')));
      y=parseInt(line.substring(line.indexOf(' ')+1));
      play(0,0,"",j,y);
    }
  }
  static void play(int _j,int _y,String r,int j,int y){
    if(_j==j && _y==y){
      System.out.println(r);
      return ;
    }
    if(_j>j || _y>y)return ;
    if((_j>=5 && _y<4)||(_j<4 && _y>=5))return ;
    play(_j+1,_y,r+"A",j,y);
    play(_j,_y+1,r+"B",j,y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var j : int ;
    var y : int ;
     j := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
     y := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
     execute play(0, 0, "", j, y) ) ;     line := br.readLine() ;
 ) );
  static   operation play( _j : int, _y : int, r : String, j : int, y : int) : void
  pre: true
  post: true
  activity: (     if (_j = j & _y = y) then (     OclFile["System.out"].println(r) ; 
     return ) else skip ; 
     if (_j > j or _y > y) then     return else skip ; 
    if ((_j >= 5 & _y < 4) or (_j < 4 & _y >= 5)) then     return else skip ; 
    execute play(_j + 1, _y, r + "A", j, y) ; 
    execute play(_j, _y + 1, r + "B", j, y) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    dfs(sc.nextInt(),sc.nextInt(),"");
  }
  void dfs(int j,int y,String ans){
    if((j | y)==0){
      if(ok(ans)){
        System.out.println(ans);
      }
    }
    if(j>0)dfs(j-1,y,ans+'A');
    if(y>0)dfs(j,y-1,ans+'B');
  }
  boolean ok(String ans){
    int jc=0,yc=0 ;
    for(int i=0,l=ans.length(); i<l ; i++){
      if(ans.charAt(i)=='A')jc++;
      else yc++;
      if((3>=jc && yc==5)||(3>=yc && jc==5)){
        return jc+yc==l ;
      }
      if(jc==yc && jc==5){
        return jc+yc==l ;
      }
      if((jc==4 && yc==6)||(yc==4 && jc==6)){
        return jc+yc==l ;
      }
    }
    return true ;
  }
  void debug(Object...os){
    System.out.println(deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute dfs(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger(), "") );
   operation dfs( j : int, y : int, ans : String) : void
  pre: true
  post: true
  activity: (     if ((j or y) = 0) then (     if (ok(ans)) then (     OclFile["System.out"].println(ans) ) else skip ) else skip ; 
     if (j > 0) then     execute dfs(j - 1, y, ans + 'A') ; else skip ; 
     if (y > 0) then     execute dfs(j, y - 1, ans + 'B') ; else skip );
   operation ok( ans : String) : boolean
  pre: true
  post: true
  activity: (     var jc : int ; jc := 0 ;
    var yc : int ; yc := 0 ;
         var i : int ; i := 0 ;
    var l : int ; l := ans->size() ; while i < l do ( (     if (ans->at(i+1) = 'A') then     jc := jc + 1 else     yc := yc + 1 ; ;  
     if ((3 >= jc & yc = 5) or (3 >= yc & jc = 5)) then (     return jc + yc = l ) else skip ; 
     if (jc = yc & jc = 5) then (     return jc + yc = l ) else skip ; 
     if ((jc = 4 & yc = 6) or (yc = 4 & jc = 6)) then (     return jc + yc = l ) else skip )  ;     i := i + 1 ) ; 
     return true );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    a=scanner.nextInt();
    b=scanner.nextInt();
    slove(0,0,"");
  }
  private void slove(int x,int y,String s){
    if((x==5 && y<b && y!=4)|| y==5 && x<a && x!=4)return ;
    if(x==a+1 || y==b+1)return ;
    if(x==a && y==b)System.out.println(s);
    for(int i=0 ; i<2 ; i++){
      if(i==0){
        slove(x+1,y,s+"A");
      }
      else slove(x,y+1,s+"B");
    }
  }
  int a,b ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     a := scanner.getCurrent()->toInteger() ; 
     b := scanner.getCurrent()->toInteger() ; 
     execute slove(0, 0, "") );
   operation slove( x : int, y : int, s : String) : void
  pre: true
  post: true
  activity: (     if ((x = 5 & y < b & y /= 4) or y = 5 & x < a & x /= 4) then     return else skip ; 
     if (x = a + 1 or y = b + 1) then     return else skip ; 
     if (x = a & y = b) then     OclFile["System.out"].println(s) ; else skip ; 
         var i : int ; i := 0 ; while i < 2 do ( (     if (i = 0) then (     execute slove(x + 1, y, s + "A") ) else     execute slove(x, y + 1, s + "B") ; )  ;     i := i + 1 ) );
   attribute a : int;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  public Main(){
    int j=sc.nextInt();
    int y=sc.nextInt();
    parse(0,0,j,y,"");
  }
  void parse(int a,int b,int j,int y,String p){
    if(a==j && b==y){
      System.out.println(p);
      return ;
    }
    if(a>=5 && b<=3)return ;
    if(b>=5 && a<=3)return ;
    if(a+1<=j && b<=y)parse(a+1,b,j,y,p+"A");
    if(a<=j && b+1<=y)parse(a,b+1,j,y,p+"B");
  }
  public static void main(String[] a){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var j : int ; j := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     execute parse(0, 0, j, y, "") );
   operation parse( a : int, b : int, j : int, y : int, p : String) : void
  pre: true
  post: true
  activity: (     if (a = j & b = y) then (     OclFile["System.out"].println(p) ; 
     return ) else skip ; 
     if (a >= 5 & b <= 3) then     return else skip ; 
    if (b >= 5 & a <= 3) then     return else skip ; 
    if (a + 1 <= j & b <= y) then     execute parse(a + 1, b, j, y, p + "A") ; else skip ; 
    if (a <= j & b + 1 <= y) then     execute parse(a, b + 1, j, y, p + "B") ; else skip ; 
 );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static boolean Div_by_8(int n){
    return(((n>>3)<<3)==n);
  }
  public static void main(String[] args){
    int n=16 ;
    if(Div_by_8(n))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Div_by_8( n : int) : boolean
  pre: true
  post: true
  activity: (     return (((((n/(2->pow(3)))->oclAsType(long))*(2->pow(3)))->oclAsType(long)) = n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 16 ;
     if (Div_by_8(n)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    double xp0,xp1,yp0,yp1 ;
    int q ;
    double[] xp2,yp2 ;
    int i ;
    double s1x,s1y,s2x,s2y,s ;
    xp0=sc.nextDouble();
    yp0=sc.nextDouble();
    xp1=sc.nextDouble();
    yp1=sc.nextDouble();
    q=sc.nextInt();
    xp2=new double[q];
    yp2=new double[q];
    s1x=xp1-xp0 ;
    s1y=yp1-yp0 ;
    for(i=0 ; i<q ; i++){
      xp2[i]=sc.nextDouble();
      yp2[i]=sc.nextDouble();
      s2x=xp2[i]-xp0 ;
      s2y=yp2[i]-yp0 ;
      s=s1x*s2y-s1y*s2x ;
      if(s>0){
        System.out.println("COUNTER_CLOCKWISE");
      }
      else if(s<0){
        System.out.println("CLOCKWISE");
      }
      else {
        if(s1x*s2x<0 || s1y*s2y<0){
          System.out.println("ONLINE_BACK");
        }
        else {
          if(((s1x*s1x)+(s1y*s1y))<((s2x*s2x)+(s2y*s2y))){
            System.out.println("ONLINE_FRONT");
          }
          else {
            System.out.println("ON_SEGMENT");
          }
        }
      }
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var xp0 : double ;
    var xp1 : double ;
    var yp0 : double ;
    var yp1 : double ;
    var q : int ;
    var xp2 : Sequence(double) ;
    var yp2 : Sequence(double) ;
    var i : int ;
    var s1x : double ;
    var s1y : double ;
    var s2x : double ;
    var s2y : double ;
    var s : double ;
    xp0 := sc.nextDouble() ; 
    yp0 := sc.nextDouble() ; 
    xp1 := sc.nextDouble() ; 
    yp1 := sc.nextDouble() ; 
    q := sc.nextInt() ; 
    xp2 := Integer.subrange(1,q)->collect(0.0) ; 
    yp2 := Integer.subrange(1,q)->collect(0.0) ; 
    s1x := xp1 - xp0 ; 
    s1y := yp1 - yp0 ; 
        i := 0 ; while i < q do ( (     xp2[i+1] := sc.nextDouble() ; 
     yp2[i+1] := sc.nextDouble() ; 
    s2x := xp2[i+1] - xp0 ; 
    s2y := yp2[i+1] - yp0 ; 
    s := s1x * s2y - s1y * s2x ; 
    if (s > 0) then (     OclFile["System.out"].println("COUNTER_CLOCKWISE") ) else     if (s < 0) then (     OclFile["System.out"].println("CLOCKWISE") ) else (     if (s1x * s2x < 0 or s1y * s2y < 0) then (     OclFile["System.out"].println("ONLINE_BACK") ) else (     if (((s1x * s1x) + (s1y * s1y)) < ((s2x * s2x) + (s2y * s2y))) then (     OclFile["System.out"].println("ONLINE_FRONT") ) else (     OclFile["System.out"].println("ON_SEGMENT") ) ) ) ;  ;  
 )  ;     i := i + 1 ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static String clockwise(Vector v1,Vector v2){
    long cross=v1.x*v2.y-v1.y*v2.x ;
    long value=v1.x*v2.x+v1.y*v2.y ;
    long len1=v1.x*v1.x+v1.y*v1.y ;
    long len2=v2.x*v2.x+v2.y*v2.y ;
    if(cross==0L){
      if(value<0L)return "ONLINE_BACK" ;
      else if(len1<len2)return "ONLINE_FRONT" ;
      else return "ON_SEGMENT" ;
    }
    else if(cross>0L){
      return "COUNTER_CLOCKWISE" ;
    }
    else {
      return "CLOCKWISE" ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Point p0=new Point(sc.nextLong(),sc.nextLong());
    Point p1=new Point(sc.nextLong(),sc.nextLong());
    Vector v1=new Vector(p0,p1);
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      Point p2=new Point(sc.nextLong(),sc.nextLong());
      Vector v2=new Vector(p0,p2);
      System.out.println(clockwise(v1,v2));
    }
  }
}
class Point {
  long x ;
  long y ;
  Point(long x,long y){
    this.x=x ;
    this.y=y ;
  }
}
class Vector {
  long x ;
  long y ;
  Vector(Point ps,Point pg){
    x=pg.x-ps.x ;
    y=pg.y-ps.y ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation clockwise( v1 : Sequence, v2 : Sequence) : String
  pre: true
  post: true
  activity: (     var cross : long ; cross := v1.x * v2.y - v1.y * v2.x ;
     var value : long ; value := v1.x * v2.x + v1.y * v2.y ;
    var len1 : long ; len1 := v1.x * v1.x + v1.y * v1.y ;
    var len2 : long ; len2 := v2.x * v2.x + v2.y * v2.y ;
    if (cross = 0L) then (     if (value < 0L) then     return "ONLINE_BACK" else     if (len1 < len2) then     return "ONLINE_FRONT" else     return "ON_SEGMENT" ;  ) else     if (cross > 0L) then (     return "COUNTER_CLOCKWISE" ) else (     return "CLOCKWISE" ) ;  ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p0 : Point ; p0 := Point.newPoint(sc.getCurrent()->toLong(), sc.getCurrent()->toLong()) ;
    var p1 : Point ; p1 := Point.newPoint(sc.getCurrent()->toLong(), sc.getCurrent()->toLong()) ;
    var v1 : Sequence ; v1 := Sequence{} ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var p2 : Point ; p2 := Point.newPoint(sc.getCurrent()->toLong(), sc.getCurrent()->toLong()) ;
     var v2 : Sequence ; v2 := Sequence{} ;
     OclFile["System.out"].println(clockwise(v1, v2)) )  ;     i := i + 1 ) ; 
 );
}
class Point {
   attribute x : long;
   attribute y : long;
   static operation newPoint( x : long, y : long) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : long, y : long) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}
class Vector {
   attribute x : long;
   attribute y : long;
   static operation newVector( ps : Point, pg : Point) : Vector
  pre: true
  post: true
  activity:
  ( var self : Vector ;
    self := createVector();
    self.initialise(ps, pg);
    return self );
  operation initialise( ps : Point, pg : Point) : void
  pre: true  post: true
  activity: (     x := pg.x - ps.x ; 
     y := pg.y - ps.y );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long centered_heptagonal_num(long n){
    return(7*n*n-7*n+2)/2 ;
  }
  public static void main(String[] args){
    long n=5 ;
    System.out.println(n+"th Centered "+"heptagonal number : "+centered_heptagonal_num(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation centered_heptagonal_num( n : long) : long
  pre: true
  post: true
  activity: (     return (7 * n * n - 7 * n + 2) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 5 ;
     OclFile["System.out"].println(n + "th Centered " + "heptagonal number : " + centered_heptagonal_num(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    double px,py,x1,y1,x2,y2,angle1,angle2,back,rad,leng1,leng2 ;
    int q ;
    px=scan.nextDouble();
    py=scan.nextDouble();
    x1=scan.nextDouble();
    y1=scan.nextDouble();
    rad=Math.atan2(y1-py,x1-px);
    angle1=rad*180/Math.PI ;
    if(angle1<0)angle1+=360 ;
    back=angle1+180 ;
    leng1=Math.sqrt((x1-px)*(x1-px)+(y1-py)*(y1-py));
    if(back>=360)back-=360 ;
    q=scan.nextInt();
    for(int i=0 ; i<q ; i++){
      x2=scan.nextDouble();
      y2=scan.nextDouble();
      rad=Math.atan2(y2-py,x2-px);
      angle2=rad*180/Math.PI ;
      if(angle2<0)angle2+=360 ;
      if(px==x2 && py==y2){
        System.out.println("ON_SEGMENT");
      }
      else if(angle2==angle1){
        leng2=Math.sqrt((x2-px)*(x2-px)+(y2-py)*(y2-py));
        if((leng2-leng1)<=0){
          System.out.println("ON_SEGMENT");
        }
        else {
          System.out.println("ONLINE_FRONT");
        }
      }
      else if(angle2==back){
        System.out.println("ONLINE_BACK");
      }
      else if(back<180){
        if(angle2>back && angle2<angle1){
          System.out.println("CLOCKWISE");
        }
        else {
          System.out.println("COUNTER_CLOCKWISE");
        }
      }
      else {
        if(angle2<back && angle2>angle1){
          System.out.println("COUNTER_CLOCKWISE");
        }
        else {
          System.out.println("CLOCKWISE");
        }
      }
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var px : double ;
    var py : double ;
    var x1 : double ;
    var y1 : double ;
    var x2 : double ;
    var y2 : double ;
    var angle1 : double ;
    var angle2 : double ;
    var back : double ;
    var rad : double ;
    var leng1 : double ;
    var leng2 : double ;
    var q : int ;
    px := scan.getCurrent()->toReal() ; 
    py := scan.getCurrent()->toReal() ; 
    x1 := scan.getCurrent()->toReal() ; 
    y1 := scan.getCurrent()->toReal() ; 
    rad := atan2(y1 - py, x1 - px) ; 
    angle1 := rad * 180 / 3.141592653589793 ; 
    if (angle1 < 0) then     angle1 := angle1+(360) ; else skip ; 
    back := angle1 + 180 ; 
    leng1 := ((x1 - px) * (x1 - px) + (y1 - py) * (y1 - py))->sqrt() ; 
    if (back >= 360) then     back := back-(360) ; else skip ; 
    q := scan.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < q do ( (     x2 := scan.getCurrent()->toReal() ; 
     y2 := scan.getCurrent()->toReal() ; 
    rad := atan2(y2 - py, x2 - px) ; 
    angle2 := rad * 180 / 3.141592653589793 ; 
    if (angle2 < 0) then     angle2 := angle2+(360) ; else skip ; 
    if (px = x2 & py = y2) then (     OclFile["System.out"].println("ON_SEGMENT") ) else     if (angle2 = angle1) then (     leng2 := ((x2 - px) * (x2 - px) + (y2 - py) * (y2 - py))->sqrt() ; 
     if ((leng2 - leng1) <= 0) then (     OclFile["System.out"].println("ON_SEGMENT") ) else (     OclFile["System.out"].println("ONLINE_FRONT") ) ) else     if (angle2 = back) then (     OclFile["System.out"].println("ONLINE_BACK") ) else     if (back < 180) then (     if (angle2 > back & angle2 < angle1) then (     OclFile["System.out"].println("CLOCKWISE") ) else (     OclFile["System.out"].println("COUNTER_CLOCKWISE") ) ) else (     if (angle2 < back & angle2 > angle1) then (     OclFile["System.out"].println("COUNTER_CLOCKWISE") ) else (     OclFile["System.out"].println("CLOCKWISE") ) ) ;  ;  ;  ;  
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double xp0=sc.nextDouble();
    double yp0=sc.nextDouble();
    Vector2d p0=new Vector2d(xp0,yp0);
    double xp1=sc.nextDouble();
    double yp1=sc.nextDouble();
    Vector2d p1=new Vector2d(xp1,yp1);
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      double x=sc.nextDouble();
      double y=sc.nextDouble();
      System.out.println(solve(p0,p1,new Vector2d(x,y)));
    }
    sc.close();
  }
  static class Vector2d {
    Vector2d(Double x,Double y){
      this.x=x ;
      this.y=y ;
    }
    Double x ;
    Double y ;
    public String toString(){
      return String.format("%1$.10f %2$.10f",x,y);
    }
  }
  public static Vector2d sub(Vector2d v1,Vector2d v2){
    return new Vector2d(v2.x-v1.x,v2.y-v1.y);
  }
  public static String solve(Vector2d p0,Vector2d p1,Vector2d p2){
    Vector2d v1=sub(p0,p1);
    Vector2d v2=sub(p0,p2);
    Double a=v1.x*v2.y-v1.y*v2.x ;
    if(a==0){
      if(v2.x/v1.x<0 || v2.y/v1.y<0){
        return "ONLINE_BACK" ;
      }
      else if(v2.x/v1.x>1 || v2.y/v1.y>1){
        return "ONLINE_FRONT" ;
      }
      else {
        return "ON_SEGMENT" ;
      }
    }
    else if(a>0){
      return "COUNTER_CLOCKWISE" ;
    }
    else {
      return "CLOCKWISE" ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var xp0 : double ; xp0 := sc.getCurrent()->toReal() ;
    var yp0 : double ; yp0 := sc.getCurrent()->toReal() ;
    var p0 : Vector2d ; p0 := Vector2d.newVector2d(xp0, yp0) ;
    var xp1 : double ; xp1 := sc.getCurrent()->toReal() ;
    var yp1 : double ; yp1 := sc.getCurrent()->toReal() ;
    var p1 : Vector2d ; p1 := Vector2d.newVector2d(xp1, yp1) ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var x : double ; x := sc.getCurrent()->toReal() ;
     var y : double ; y := sc.getCurrent()->toReal() ;
     OclFile["System.out"].println(solve(p0, p1, Vector2d.newVector2d(x, y))) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class Vector2d {
   static operation newVector2d( x : double, y : double) : Vector2d
  pre: true
  post: true
  activity:
  ( var self : Vector2d ;
    self := createVector2d();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   attribute x : double;
   attribute y : double;
   operation toString() : String
  pre: true
  post: true
  activity: (     return StringLib.format("%1$.10f %2$.10f",Sequence{x,y}) );
}
  static   operation sub( v1 : Vector2d, v2 : Vector2d) : Vector2d
  pre: true
  post: true
  activity: (     return Vector2d.newVector2d(v2.x - v1.x, v2.y - v1.y) );
  static   operation solve( p0 : Vector2d, p1 : Vector2d, p2 : Vector2d) : String
  pre: true
  post: true
  activity: (     var v1 : Vector2d ; v1 := sub(p0, p1) ;
     var v2 : Vector2d ; v2 := sub(p0, p2) ;
     var a : double ; a := v1.x * v2.y - v1.y * v2.x ;
     if (a = 0) then (     if (v2.x / v1.x < 0 or v2.y / v1.y < 0) then (     return "ONLINE_BACK" ) else     if (v2.x / v1.x > 1 or v2.y / v1.y > 1) then (     return "ONLINE_FRONT" ) else (     return "ON_SEGMENT" ) ;  ) else     if (a > 0) then (     return "COUNTER_CLOCKWISE" ) else (     return "CLOCKWISE" ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  static final int INF=(1<<31)-1 ;
  static final int MAXN=11111 ;
  public static void main(String[] args)throws Exception {
    Scanner input=new Scanner(System.in);
    int x0,y0,x1,y1,x2,y2 ;
    int q ;
    x0=input.nextInt();
    y0=input.nextInt();
    x1=input.nextInt();
    y1=input.nextInt();
    q=input.nextInt();
    for(int i=0 ; i<q ; ++i){
      x2=input.nextInt();
      y2=input.nextInt();
      int d=ccw(x1-x0,y1-y0,x2-x1,y2-y1);
      if(d>0)System.out.println("COUNTER_CLOCKWISE");
      else if(d<0)System.out.println("CLOCKWISE");
      else {
        int a2,b2,a1,b1 ;
        a1=x1-x0 ;
        b1=y1-y0 ;
        a2=x2-x0 ;
        b2=y2-y0 ;
        if(a1*a2<=0 && b1*b2<=0 &&(a1*a1+b1*b1!=0 && a2*a2+b2*b2!=0))System.out.println("ONLINE_BACK");
        else if(Math.hypot(a1,b1)<Math.hypot(a2,b2))System.out.println("ONLINE_FRONT");
        else System.out.println("ON_SEGMENT");
      }
    }
  }
  static int ccw(int a0,int b0,int a1,int b1){
    int d=a0*b1-a1*b0 ;
    return d ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := ((1*(2->pow(31)))->oclAsType(long)) - 1;
  static    attribute MAXN : int := 11111;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x0 : int ;
    var y0 : int ;
    var x1 : int ;
    var y1 : int ;
    var x2 : int ;
    var y2 : int ;
    var q : int ;
    x0 := input.getCurrent()->toInteger() ; 
    y0 := input.getCurrent()->toInteger() ; 
    x1 := input.getCurrent()->toInteger() ; 
    y1 := input.getCurrent()->toInteger() ; 
    q := input.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < q do ( (     x2 := input.getCurrent()->toInteger() ; 
     y2 := input.getCurrent()->toInteger() ; 
     var d : int ; d := ccw(x1 - x0, y1 - y0, x2 - x1, y2 - y1) ;
     if (d > 0) then     OclFile["System.out"].println("COUNTER_CLOCKWISE") ; else     if (d < 0) then     OclFile["System.out"].println("CLOCKWISE") else (     var a2 : int ;
    var b2 : int ;
    var a1 : int ;
    var b1 : int ;
     a1 := x1 - x0 ; 
    b1 := y1 - y0 ; 
    a2 := x2 - x0 ; 
    b2 := y2 - y0 ; 
    if (a1 * a2 <= 0 & b1 * b2 <= 0 & (a1 * a1 + b1 * b1 /= 0 & a2 * a2 + b2 * b2 /= 0)) then     OclFile["System.out"].println("ONLINE_BACK") else     if (hypot(a1, b1) < hypot(a2, b2)) then     OclFile["System.out"].println("ONLINE_FRONT") else     OclFile["System.out"].println("ON_SEGMENT") ; ;  ;  
 ) ;  )  ;     i := i + 1 ) ; 
 );
  static   operation ccw( a0 : int, b0 : int, a1 : int, b1 : int) : int
  pre: true
  post: true
  activity: (     var d : int ; d := a0 * b1 - a1 * b0 ;
     return d );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
class GFG {
  static int MOD=1000000007 ;
  static long sum(long N){
    long val=N*(N+1);
    val=val % MOD ;
    return val ;
  }
  static int sumX(int N,int M,int K){
    for(int i=0 ; i<M ; i++){
      N=(int)sum(K+N);
    }
    N=N % MOD ;
    return N ;
  }
  public static void main(String args[]){
    int N=1,M=2,K=3 ;
    System.out.println(sumX(N,M,K));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MOD : int := 1000000007;
  static   operation sum( N : long) : long
  pre: true
  post: true
  activity: (     var val : long ; val := N * (N + 1) ;
     val := val mod MOD ; 
     return val );
  static   operation sumX( N : int, M : int, K : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < M do ( (     N := sum(K + N)->oclAsType(int) )  ;     i := i + 1 ) ; 
     N := N mod MOD ; 
     return N );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 1 ;
    var M : int ; M := 2 ;
    var K : int ; K := 3 ;
     OclFile["System.out"].println(sumX(N, M, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
class GFG {
  public static int findGCD(int a,int b){
    if(b==0)return a ;
    else return findGCD(b,a % b);
  }
  static void findNumbers(int a,int b){
    int gcd=findGCD(a,b);
    System.out.println((a/gcd)+" "+(b/gcd));
  }
  public static void main(String[] args){
    int a=12,b=16 ;
    findNumbers(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findGCD( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else     return findGCD(b, a mod b) );
  static   operation findNumbers( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var gcd : int ; gcd := findGCD(a, b) ;
     OclFile["System.out"].println((a / gcd) + " " + (b / gcd)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 12 ;
    var b : int ; b := 16 ;
     execute findNumbers(a, b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean productsDistinct(int N){
    String s="" ;
    while(N>0){
      s+=(char)(N % 10+'0');
      N/=10 ;
    }
    s=reverse(s);
    int sz=s.length();
    HashSet<Integer>se=new HashSet<Integer>();
    for(int i=0 ; i<sz ; i++){
      int product=1 ;
      for(int j=i ; j<sz ; j++){
        product*=(int)(s.charAt(j)-'0');
        if(se.contains(product))return false ;
        else se.add(product);
      }
    }
    return true ;
  }
  static String reverse(String input){
    char[] a=input.toCharArray();
    int l,r ;
    r=a.length-1 ;
    for(l=0 ; l<r ; l++,r--){
      char temp=a[l];
      a[l]=a[r];
      a[r]=temp ;
    }
    return String.valueOf(a);
  }
  public static void main(String[] args){
    int N=2345 ;
    if(productsDistinct(N))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation productsDistinct( N : int) : boolean
  pre: true
  post: true
  activity: (     var s : String ; s := "" ;
     while (N > 0) do (     s := s+((N mod 10 + '0')->oclAsType(String)) ; 
     N := N/(10) ) ; 
    s := reverse(s) ; 
    var sz : int ; sz := s->size() ;
    var se : Set(int) ; se := Set{} ;
        var i : int ; i := 0 ; while i < sz do ( (     var product : int ; product := 1 ;
         var j : int ; j := i ; while j < sz do ( (     product := product*((s->at(j+1) - ('0')->char2byte())->oclAsType(int)) ; 
     if (se->includes(product)) then     return false else     se := se->including(product) ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation reverse( input : String) : String
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := input->characters() ;
     var l : int ;
    var r : int ;
    r := a->size() - 1 ; 
        l := 0 ; while l < r do ( (     var temp : String ; temp := a[l+1] ;
     a[l+1] := a[r+1] ; 
     a[r+1] := temp )  ;     l := l + 1 ;     r := r - 1 ) ; 
    return (a)->sum()  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 2345 ;
     if (productsDistinct(N)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int[] a=new int[1200];
    int[] b=new int[1200];
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt(),x=0,y=0 ;
      String s1=sc.next();
      String s2=sc.next();
      for(int j=0 ; j<n ; j++){
        a[j]=s1.charAt(j);
      }
      for(int j=0 ; j<n ; j++){
        b[j]=s2.charAt(j);
      }
      for(int j=0 ; j<n ; j++){
        if(a[j]>b[j])x++;
        else if(a[j]<b[j])y++;
      }
      if(x>y)System.out.println("RED");
      if(x<y)System.out.println("BLUE");
      if(x==y)System.out.println("EQUAL");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,1200)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,1200)->collect(0) ;
        var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
     var s1 : String ; s1 := sc.getCurrent() ;
    var s2 : String ; s2 := sc.getCurrent() ;
        var j : int ; j := 0 ; while j < n do ( (     a[j+1] := s1->at(j+1) )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     b[j+1] := s2->at(j+1) )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     if (a[j+1] > b[j+1]) then     x := x + 1 ; else     if (a[j+1] < b[j+1]) then     y := y + 1 ; else skip ; )  ;     j := j + 1 ) ; 
    if (x > y) then     OclFile["System.out"].println("RED") ; else skip ; 
    if (x < y) then     OclFile["System.out"].println("BLUE") ; else skip ; 
    if (x = y) then     OclFile["System.out"].println("EQUAL") ; else skip ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int W=scan.nextInt();
    int H=scan.nextInt();
    int C=scan.nextInt();
    int g ;
    int b ;
    int x ;
    int t ;
    int y ;
    if(W>H){
      t=W ;
      y=H ;
      while(W % H!=0){
        g=W ;
        W=H ;
        H=g % H ;
      }
      b=H*H ;
      x=(t*y)/b ;
      System.out.println(x*C);
    }
    else if(W<H){
      t=W ;
      y=H ;
      while(H % W!=0){
        g=H ;
        H=W ;
        W=g % W ;
      }
      b=W*W ;
      x=(t*y)/b ;
      System.out.println(x*C);
    }
    else if(H==W){
      System.out.println(C);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var W : int ; W := scan.getCurrent()->toInteger() ;
    var H : int ; H := scan.getCurrent()->toInteger() ;
    var C : int ; C := scan.getCurrent()->toInteger() ;
    var g : int ;
    var b : int ;
    var x : int ;
    var t : int ;
    var y : int ;
    if (W > H) then (     t := W ; 
     y := H ; 
    while (W mod H /= 0) do (     g := W ; 
     W := H ; 
     H := g mod H ) ; 
    b := H * H ; 
    x := (t * y) / b ; 
    OclFile["System.out"].println(x * C) ; 
 ) else     if (W < H) then (     t := W ; 
     y := H ; 
    while (H mod W /= 0) do (     g := H ; 
     H := W ; 
     W := g mod W ) ; 
    b := W * W ; 
    x := (t * y) / b ; 
    OclFile["System.out"].println(x * C) ; 
 ) else     if (H = W) then (     OclFile["System.out"].println(C) ) else skip ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int[] a=new int[1200];
    int[] b=new int[1200];
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt(),x=0,y=0 ;
      String s1=sc.next();
      String s2=sc.next();
      for(int j=0 ; j<n ; j++){
        a[j]=s1.charAt(j);
      }
      for(int j=0 ; j<n ; j++){
        b[j]=s2.charAt(j);
      }
      for(int j=0 ; j<n ; j++){
        if(a[j]>b[j])x++;
        else if(a[j]<b[j])y++;
      }
      if(x>y)System.out.println("RED");
      if(x<y)System.out.println("BLUE");
      if(x==y)System.out.println("EQUAL");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,1200)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,1200)->collect(0) ;
        var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
     var s1 : String ; s1 := sc.getCurrent() ;
    var s2 : String ; s2 := sc.getCurrent() ;
        var j : int ; j := 0 ; while j < n do ( (     a[j+1] := s1->at(j+1) )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     b[j+1] := s2->at(j+1) )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     if (a[j+1] > b[j+1]) then     x := x + 1 ; else     if (a[j+1] < b[j+1]) then     y := y + 1 ; else skip ; )  ;     j := j + 1 ) ; 
    if (x > y) then     OclFile["System.out"].println("RED") ; else skip ; 
    if (x < y) then     OclFile["System.out"].println("BLUE") ; else skip ; 
    if (x = y) then     OclFile["System.out"].println("EQUAL") ; else skip ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    long n=sc.nextLong();
    int mod=1000000007 ;
    int[] arr={
      x-y,x,y,y-x,-x,-y,x-y };
      int idx=(int)n % 6 ;
      int val=arr[idx] % mod ;
      if(val<0)System.out.println(mod+val);
      else System.out.println(val);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var n : long ; n := sc.getCurrent()->toLong() ;
    var mod : int ; mod := 1000000007 ;
    var arr : Sequence(int) ; arr := Sequence{x - y,x,y,y - x,-x,-y,x - y} ;
    var idx : int ; idx := n->oclAsType(int) mod 6 ;
    var val : int ; val := arr[idx+1] mod mod ;
    if (val < 0) then     OclFile["System.out"].println(mod + val) else     OclFile["System.out"].println(val) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int missingNum(int arr[],int n){
    List<Integer>list=new ArrayList<>(arr.length);
    for(int i : arr){
      list.add(Integer.valueOf(i));
    }
    int minvalue=Collections.min(list);
    ;
    int xornum=0 ;
    for(int i=0 ; i<n ; i++){
      xornum ^=(minvalue)^ arr[i];
      minvalue++;
    }
    return xornum ^ minvalue ;
  }
  public static void main(String[] args){
    int arr[]={
      13,12,11,15 };
      int n=arr.length ;
      System.out.println(missingNum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation missingNum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{}->union(arr->size()) ;
     for (i : arr) do ( (     list := list->including((i)->toInteger()) )  ) ; 
    var minvalue : int ; minvalue := .min(list) ;
    var xornum : int ; xornum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     xornum := MathLib.bitwiseXor(xornum,(minvalue) xor arr[i+1]) ; 
     minvalue := minvalue + 1 )  ;     i := i + 1 ) ; 
    return MathLib.bitwiseXor(xornum,minvalue) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{13,12,11,15} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(missingNum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    int[] a=new int[1200];
    int[] b=new int[1200];
    while(t-->0){
      int n=in.nextInt(),x=0,y=0 ;
      String s1=in.next();
      String s2=in.next();
      for(int i=0 ; i<n ; i++)a[i]=s1.charAt(i);
      for(int i=0 ; i<n ; i++)b[i]=s2.charAt(i);
      for(int i=0 ; i<n ; i++){
        if(a[i]>b[i])x++;
        else if(a[i]<b[i])y++;
      }
      if(x>y)System.out.println("RED");
      if(x<y)System.out.println("BLUE");
      if(x==y)System.out.println("EQUAL");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,1200)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,1200)->collect(0) ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
     var s1 : String ; s1 := in.getCurrent() ;
    var s2 : String ; s2 := in.getCurrent() ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := s1->at(i+1) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     b[i+1] := s2->at(i+1) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] > b[i+1]) then     x := x + 1 ; else     if (a[i+1] < b[i+1]) then     y := y + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    if (x > y) then     OclFile["System.out"].println("RED") ; else skip ; 
    if (x < y) then     OclFile["System.out"].println("BLUE") ; else skip ; 
    if (x = y) then     OclFile["System.out"].println("EQUAL") ; else skip ; 
 ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt(),x=0,y=0 ;
      char[] c1=in.next().toCharArray();
      char[] c2=in.next().toCharArray();
      for(int i=0 ; i<n ; i++){
        if(c1[i]>c2[i])x++;
        else if(c1[i]<c2[i])y++;
      }
      if(x>y)System.out.println("RED");
      if(x<y)System.out.println("BLUE");
      if(x==y)System.out.println("EQUAL");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
     var c1 : Sequence(String) ; c1 := in.getCurrent()->characters() ;
    var c2 : Sequence(String) ; c2 := in.getCurrent()->characters() ;
        var i : int ; i := 0 ; while i < n do ( (     if (c1[i+1] > c2[i+1]) then     x := x + 1 ; else     if (c1[i+1] < c2[i+1]) then     y := y + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    if (x > y) then     OclFile["System.out"].println("RED") ; else skip ; 
    if (x < y) then     OclFile["System.out"].println("BLUE") ; else skip ; 
    if (x = y) then     OclFile["System.out"].println("EQUAL") ; else skip ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF1459A {
  public static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int test=scanner.nextInt();
    while(test-->0){
      int n=scanner.nextInt();
      String r=scanner.next();
      String b=scanner.next();
      int red=0,blue=0 ;
      for(int i=0 ; i<n ; i++){
        int redCard=r.charAt(i)-'0' ;
        int blueCard=b.charAt(i)-'0' ;
        if(redCard>blueCard)red++;
        else if(redCard<blueCard)blue++;
      }
      if(red>blue)System.out.println("RED");
      else if(blue>red)System.out.println("BLUE");
      else System.out.println("EQUAL");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF1459A {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var test : int ; test := scanner.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var r : String ; r := scanner.getCurrent() ;
    var b : String ; b := scanner.getCurrent() ;
    var red : int ; red := 0 ;
    var blue : int ; blue := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var redCard : int ; redCard := r->at(i+1) - ('0')->char2byte() ;
     var blueCard : int ; blueCard := b->at(i+1) - ('0')->char2byte() ;
     if (redCard > blueCard) then     red := red + 1 ; else     if (redCard < blueCard) then     blue := blue + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    if (red > blue) then     OclFile["System.out"].println("RED") else     if (blue > red) then     OclFile["System.out"].println("BLUE") else     OclFile["System.out"].println("EQUAL") ; ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void candies(int n,int k){
    int count=0 ;
    int ind=1 ;
    int[] arr=new int[k];
    for(int i=0 ; i<k ; i++)arr[i]=0 ;
    while(n>0){
      int f1=(ind-1)*k ;
      int f2=ind*k ;
      int sum1=(f1*(f1+1))/2 ;
      int sum2=(f2*(f2+1))/2 ;
      int res=sum2-sum1 ;
      if(res<=n){
        count++;
        n-=res ;
        ind++;
      }
      else {
        int i=0 ;
        int term=((ind-1)*k)+1 ;
        while(n>0){
          if(term<=n){
            arr[i++]=term ;
            n-=term ;
            term++;
          }
          else {
            arr[i++]=n ;
            n=0 ;
          }
        }
      }
    }
    for(int i=0 ; i<k ; i++)arr[i]+=(count*(i+1))+(k*(count*(count-1))/2);
    for(int i=0 ; i<k ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String[] args){
    int n=10,k=3 ;
    candies(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation candies( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var ind : int ; ind := 1 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do (     arr[i+1] := 0 ;  ;     i := i + 1 ) ; 
    while (n > 0) do (     var f1 : int ; f1 := (ind - 1) * k ;
     var f2 : int ; f2 := ind * k ;
    var sum1 : int ; sum1 := (f1 * (f1 + 1)) / 2 ;
    var sum2 : int ; sum2 := (f2 * (f2 + 1)) / 2 ;
    var res : int ; res := sum2 - sum1 ;
    if (res <= n) then (     count := count + 1 ; 
     n := n-(res) ; 
     ind := ind + 1 ) else (     var i : int ; i := 0 ;
     var term : int ; term := ((ind - 1) * k) + 1 ;
     while (n > 0) do (     if (term <= n) then (      arr[i+1] := term  ; i := i + 1 ; 
     n := n-(term) ; 
     term := term + 1 ) else (      arr[i+1] := n  ; i := i + 1 ; 
     n := 0 ) ) ) ;  
 ) ; 
        var i : int ; i := 0 ; while i < k do (     arr[i+1] := arr[i+1]+((count * (i + 1)) + (k * (count * (count - 1)) / 2)) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
    var k : int ; k := 3 ;
     execute candies(n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  static final int max_val=257 ;
  static int PrimeCharacters(String s){
    boolean prime[]=new boolean[max_val+1];
    for(int i=0 ; i<=max_val ; i++)prime[i]=true ;
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=max_val ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=max_val ; i+=p)prime[i]=false ;
      }
    }
    int count=0 ;
    for(int i=0 ; i<s.length(); ++i){
      if(prime[(int)(s.charAt(i))])count++;
    }
    return count ;
  }
  public static void main(String args[]){
    String S="geeksforgeeks" ;
    System.out.print(PrimeCharacters(S));
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
  static    attribute max_val : int := 257;
  static   operation PrimeCharacters( s : String) : int
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,max_val + 1)->collect(false) ;
         var i : int ; i := 0 ; while i <= max_val do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
    prime[0+1] := false ; 
    prime[1+1] := false ; 
        var p : int ; p := 2 ; while p * p <= max_val do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= max_val do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (prime[(s->at(i+1))->oclAsType(int)+1]) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := "geeksforgeeks" ;
     OclFile["System.out"].print(PrimeCharacters(S)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class C_Replacement {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int len=sc.nextInt();
    int nums[]=new int[len];
    int temp[]=new int[len];
    StringBuilder sb=new StringBuilder("1 ");
    for(int i=0 ; i<len ; i++){
      nums[i]=sc.nextInt();
      temp[i]=nums[i];
    }
    if(len==1 && nums[0]==1){
      System.out.println(2);
      return ;
    }
    Arrays.sort(temp);
    for(int i=1 ; i<len ; i++){
      if(i==len-1 && temp[i-1]==1 && temp[i]==1)sb.append(2);
      else sb.append(temp[i-1]+" ");
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class C_Replacement {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := sc.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,len)->collect(0) ;
    var temp : Sequence(int) ; temp := Integer.subrange(1,len)->collect(0) ;
    var sb : String ; sb := StringLib.newString("1 ") ;
        var i : int ; i := 0 ; while i < len do ( (     nums[i+1] := sc.getCurrent()->toInteger() ; 
     temp[i+1] := nums[i+1] )  ;     i := i + 1 ) ; 
    if (len = 1 & nums[0+1] = 1) then (     OclFile["System.out"].println(2) ; 
     return ) else skip ; 
    temp := temp->sort() ; 
        var i : int ; i := 1 ; while i < len do ( (     if (i = len - 1 & temp[(i)->char2byte() - 1+1] = 1 & temp[i+1] = 1) then     sb := sb + StringLib.newString(2) ; else     sb := sb + StringLib.newString(temp[(i)->char2byte() - 1+1] + " ") ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      Arrays.sort(arr);
      if(arr[n-1]==1)arr[n-1]=2 ;
      else arr[n-1]=1 ;
      Arrays.sort(arr);
      for(int i=0 ; i<n ; i++){
        System.out.print(arr[i]+" ");
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    if (arr[n - 1+1] = 1) then     arr[n - 1+1] := 2 else     arr[n - 1+1] := 1 ; ;  
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minimunMoves(String arr[],int n){
    int ans=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      int curr_count=0 ;
      String tmp="" ;
      for(int j=0 ; j<n ; j++){
        tmp=arr[j]+arr[j];
        int index=tmp.indexOf(arr[i]);
        if(index==arr[i] .length())return-1 ;
        curr_count+=index ;
      }
      ans=Math.min(curr_count,ans);
    }
    return ans ;
  }
  public static void main(String args[]){
    String arr[]={
      "xzzwo","zwoxz","zzwox","xzzwo" };
      int n=arr.length ;
      System.out.println(minimunMoves(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimunMoves( arr : Sequence(String), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 2147483647 ;
         var i : int ; i := 0 ; while i < n do ( (     var curr_count : int ; curr_count := 0 ;
     var tmp : String ; tmp := "" ;
         var j : int ; j := 0 ; while j < n do ( (     tmp := arr[j+1] + arr[j+1] ; 
     var index : int ; index := tmp->indexOf(arr[i+1])-1 ;
     if (index = arr[i+1]->size()) then     return -1 else skip ; 
     curr_count := curr_count+(index) )  ;     j := j + 1 ) ; 
     ans := Set{curr_count, ans}->min() )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"xzzwo","zwoxz","zzwox","xzzwo"} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minimunMoves(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double Area(int b1,int b2,int h){
    return((b1+b2)/2)*h ;
  }
  public static void main(String[] args){
    int base1=8,base2=10,height=6 ;
    double area=Area(base1,base2,height);
    System.out.println("Area is: "+area);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Area( b1 : int, b2 : int, h : int) : double
  pre: true
  post: true
  activity: (     return ((b1 + b2) / 2) * h );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var base1 : int ; base1 := 8 ;
    var base2 : int ; base2 := 10 ;
    var height : int ; height := 6 ;
     var area : double ; area := Area(base1, base2, height) ;
     OclFile["System.out"].println("Area is: " + area) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      String str=reader.readLine();
      String s[]=str.split(" ");
      int w=Integer.parseInt(s[0]);
      int h=Integer.parseInt(s[1]);
      int c=Integer.parseInt(s[2]);
      int fee=0 ;
      int gc=gcd(w,h);
      int gw=w/gc ;
      int gh=h/gc ;
      fee=(gw*gh)*c ;
      System.out.println(fee);
      reader.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  static int gcd(int a,int b){
    return b>0 ? gcd(b,a % b): a ;
  }
  static int lcm(int a,int b){
    return a*b/gcd(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var str : String ; str := reader.readLine() ;
     var s : Sequence(String) ; s := str->split(" ") ;
    var w : int ; w := (s[0+1])->toInteger() ;
    var h : int ; h := (s[1+1])->toInteger() ;
    var c : int ; c := (s[2+1])->toInteger() ;
    var fee : int ; fee := 0 ;
    var gc : int ; gc := gcd(w, h) ;
    var gw : int ; gw := w / gc ;
    var gh : int ; gh := h / gc ;
    fee := (gw * gh) * c ; 
    OclFile["System.out"].println(fee) ; 
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b > 0 then gcd(b, a mod b) else a endif );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return a * b / gcd(a, b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void smallestPermute(int n){
    char res[]=new char[n+1];
    if(n % 2==0){
      for(int i=0 ; i<n ; i++){
        if(i % 2==0)res[i]=(char)(48+i+2);
        else res[i]=(char)(48+i);
      }
    }
    else {
      for(int i=0 ; i<n-2 ; i++){
        if(i % 2==0)res[i]=(char)(48+i+2);
        else res[i]=(char)(48+i);
      }
      res[n-1]=(char)(48+n-2);
      res[n-2]=(char)(48+n);
      res[n-3]=(char)(48+n-1);
    }
    res[n]='\0' ;
    for(int i=0 ; i<n ; i++){
      System.out.print(res[i]);
    }
  }
  public static void main(String[] args){
    int n=7 ;
    smallestPermute(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation smallestPermute( n : int) : void
  pre: true
  post: true
  activity: (     var res : Sequence(String) ; res := Integer.subrange(1,n + 1)->collect(0) ;
     if (n mod 2 = 0) then (         var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then     res[i+1] := (48 + i + 2)->oclAsType(String) ; else     res[i+1] := (48 + i)->oclAsType(String) ; )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < n - 2 do ( (     if (i mod 2 = 0) then     res[i+1] := (48 + i + 2)->oclAsType(String) ; else     res[i+1] := (48 + i)->oclAsType(String) ; )  ;     i := i + 1 ) ; 
     res[n - 1+1] := (48 + n - 2)->oclAsType(String) ; 
     res[n - 2+1] := (48 + n)->oclAsType(String) ; 
     res[n - 3+1] := (48 + n - 1)->oclAsType(String) ) ;  
     res[n+1] := '\0' ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(res[i+1]) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     execute smallestPermute(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class OddOccurrence {
  static int getOddOccurrence(int arr[],int arr_size){
    int i ;
    for(i=0 ; i<arr_size ; i++){
      int count=0 ;
      for(int j=0 ; j<arr_size ; j++){
        if(arr[i]==arr[j])count++;
      }
      if(count % 2!=0)return arr[i];
    }
    return-1 ;
  }
  public static void main(String[] args){
    int arr[]=new int[] {
      2,3,5,4,5,2,4,3,5,2,4,4,2 };
      int n=arr.length ;
      System.out.println(getOddOccurrence(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class OddOccurrence {
  static   operation getOddOccurrence( arr : Sequence(int), arr_size : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
         i := 0 ; while i < arr_size do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < arr_size do ( (     if (arr[i+1] = arr[j+1]) then     count := count + 1 ; else skip )  ;     j := j + 1 ) ; 
     if (count mod 2 /= 0) then     return arr[i+1] else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,5,4,5,2,4,3,5,2,4,4,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(getOddOccurrence(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  final static int n=4 ;
  final static int m=4 ;
  static float calcProbability(int M[][],int k){
    float dp[][]=new float[m][n];
    float sum[]=new float[n];
    for(int j=0 ; j<n ; j++){
      dp[0][j]=M[0][j];
      sum[0]=sum[0]+dp[0][j];
    }
    for(int i=1 ; i<m ; i++){
      for(int j=0 ; j<n ; j++){
        dp[i][j]+=dp[i-1][j]/sum[i-1]+M[i][j];
        sum[i]+=dp[i][j];
      }
    }
    return dp[n-1][k-1]/sum[n-1];
  }
  public static void main(String[] args){
    int M[][]={
      {
        1,1,0,3 },{
          2,3,2,3 },{
            9,3,0,2 },{
              2,3,2,2 }
            };
            int k=3 ;
            System.out.println(calcProbability(M,k));
          }
        }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute n : int := 4;
  static   attribute m : int := 4;
  static   operation calcProbability( M : Sequence(Sequence(int)), k : int) : double
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(double)) ; dp := Integer.subrange(1,m)->collect(Integer.subrange(1,n)->collect(0.0)) ;
     var sum : Sequence(double) ; sum := Integer.subrange(1,n)->collect(0.0) ;
        var j : int ; j := 0 ; while j < n do ( (     dp[0+1][j+1] := M[0+1][j+1] ; 
     sum[0+1] := sum[0+1] + dp[0+1][j+1] )  ;     j := j + 1 ) ; 
        var i : int ; i := 1 ; while i < m do ( (         var j : int ; j := 0 ; while j < n do ( (     dp[i+1][j+1] := dp[i+1][j+1]+(dp[i - 1+1][j+1] / sum[i - 1+1] + M[i+1][j+1]) ; 
     sum[i+1] := sum[i+1]+(dp[i+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return dp[n - 1+1][k - 1+1] / sum[n - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var M : Sequence(Sequence(int)) ; M := Sequence{Sequence{1,1,0,3},Sequence{2,3,2,3},Sequence{9,3,0,2},Sequence{2,3,2,2}} ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println(calcProbability(M, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[][] A=new int[n][m];
    int[] b=new int[m];
    int[] Ab=new int[n];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        A[i][j]=sc.nextInt();
      }
    }
    for(int i=0 ; i<m ; i++){
      b[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        Ab[i]+=A[i][j]*b[j];
      }
      System.out.println(Ab[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var A : Sequence(Sequence(int)) ; A := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
    var Ab : Sequence(int) ; Ab := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     A[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     Ab[i+1] := Ab[i+1]+(A[i+1][j+1] * b[j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(Ab[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    int n=0 ;
    int m=0 ;
    int[][] md ;
    int[] vd ;
    String x="" ;
    try {
      x=in.readLine();
      String[] nm=x.split(" ");
      n=Integer.parseInt(nm[0]);
      m=Integer.parseInt(nm[1]);
      md=new int[n][m];
      vd=new int[m];
      for(int i=0 ; i<n ; i++){
        x=in.readLine();
        String[] row=x.split(" ");
        for(int j=0 ; j<m ; j++){
          md[i][j]=Integer.parseInt(row[j]);
        }
      }
      for(int i=0 ; i<m ; i++){
        x=in.readLine();
        vd[i]=Integer.parseInt(x);
      }
      for(int i=0 ; i<n ; i++){
        int v=0 ;
        for(int j=0 ; j<m ; j++){
          v=v+md[i][j]*vd[j];
        }
        System.out.println(v);
      }
    }
    catch(NumberFormatException e){
      e.printStackTrace();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := 0 ;
    var m : int ; m := 0 ;
    var md : Sequence(Sequence(int)) ;
    var vd : Sequence(int) ;
    var x : String ; x := "" ;
    try (     x := in.readLine() ; 
     var nm : Sequence(String) ; nm := x->split(" ") ;
    n := (nm[0+1])->toInteger() ; 
    m := (nm[1+1])->toInteger() ; 
    md := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ; 
    vd := Integer.subrange(1,m)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     x := in.readLine() ; 
     var row : Sequence(String) ; row := x->split(" ") ;
         var j : int ; j := 0 ; while j < m do ( (     md[i+1][j+1] := (row[j+1])->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     x := in.readLine() ; 
     vd[i+1] := (x)->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := 0 ;
         var j : int ; j := 0 ; while j < m do ( (     v := v + md[i+1][j+1] * vd[j+1] )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(v) )  ;     i := i + 1 ) ; 
 )   catch (e : IncorrectElementException) do (     e.printStackTrace() )
   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int row=scan.nextInt();
    int column=scan.nextInt();
    int[][] matrix=new int[row][column];
    int[] vector=new int[column];
    int[] vectorAnswer=new int[row];
    for(int rowI=0 ; rowI<row ; rowI++){
      for(int columnI=0 ; columnI<column ; columnI++){
        matrix[rowI][columnI]=scan.nextInt();
      }
    }
    for(int columnI=0 ; columnI<column ; columnI++){
      vector[columnI]=scan.nextInt();
    }
    for(int rowI=0 ; rowI<row ; rowI++){
      for(int columnI=0 ; columnI<column ; columnI++){
        vectorAnswer[rowI]+=matrix[rowI][columnI]*vector[columnI];
      }
    }
    for(int rowI=0 ; rowI<row ; rowI++){
      System.out.println(vectorAnswer[rowI]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var row : int ; row := scan.getCurrent()->toInteger() ;
    var column : int ; column := scan.getCurrent()->toInteger() ;
    var matrix : Sequence(Sequence(int)) ; matrix := Integer.subrange(1,row)->collect(Integer.subrange(1,column)->collect(0)) ;
    var vector : Sequence(int) ; vector := Integer.subrange(1,column)->collect(0) ;
    var vectorAnswer : Sequence(int) ; vectorAnswer := Integer.subrange(1,row)->collect(0) ;
        var rowI : int ; rowI := 0 ; while rowI < row do ( (         var columnI : int ; columnI := 0 ; while columnI < column do ( (     matrix[rowI+1][columnI+1] := scan.getCurrent()->toInteger() )  ;     columnI := columnI + 1 ) )  ;     rowI := rowI + 1 ) ; 
        var columnI : int ; columnI := 0 ; while columnI < column do ( (     vector[columnI+1] := scan.getCurrent()->toInteger() )  ;     columnI := columnI + 1 ) ; 
        var rowI : int ; rowI := 0 ; while rowI < row do ( (         var columnI : int ; columnI := 0 ; while columnI < column do ( (     vectorAnswer[rowI+1] := vectorAnswer[rowI+1]+(matrix[rowI+1][columnI+1] * vector[columnI+1]) )  ;     columnI := columnI + 1 ) )  ;     rowI := rowI + 1 ) ; 
        var rowI : int ; rowI := 0 ; while rowI < row do ( (     OclFile["System.out"].println(vectorAnswer[rowI+1]) )  ;     rowI := rowI + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] arg){
    int rows,cols ;
    int[][] a,b,c ;
    Scanner in=new Scanner(System.in);
    rows=in.nextInt();
    cols=in.nextInt();
    a=new int[rows][cols];
    b=new int[cols][1];
    c=new int[rows][1];
    in.nextLine();
    for(int i=0 ; i<a.length ; i++){
      for(int j=0 ; j<a[0] .length ; j++){
        a[i][j]=in.nextInt();
      }
      in.nextLine();
    }
    for(int i=0 ; i<b.length ; i++){
      b[i][0]=in.nextInt();
      in.nextLine();
    }
    for(int i=0 ; i<a.length ; i++){
      int tmp=0 ;
      for(int j=0 ; j<a[0] .length ; j++)tmp+=a[i][j]*b[j][0];
      c[i][0]=tmp ;
    }
    for(int i=0 ; i<c.length ; i++){
      System.out.println(c[i][0]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var rows : int ;
    var cols : int ;
     var a : Sequence(Sequence(int)) ;
    var b : Sequence(Sequence(int)) ;
    var c : Sequence(Sequence(int)) ;
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    rows := in.getCurrent()->toInteger() ; 
    cols := in.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,rows)->collect(Integer.subrange(1,cols)->collect(0)) ; 
    b := Integer.subrange(1,cols)->collect(Integer.subrange(1,1)->collect(0)) ; 
    c := Integer.subrange(1,rows)->collect(Integer.subrange(1,1)->collect(0)) ; 
    skip ; 
        var i : int ; i := 0 ; while i < a->size() do ( (         var j : int ; j := 0 ; while j < a[0+1]->size() do ( (     a[i+1][j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < b->size() do ( (     b[i+1][0+1] := in.getCurrent()->toInteger() ; 
     skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     var tmp : int ; tmp := 0 ;
         var j : int ; j := 0 ; while j < a[0+1]->size() do (     tmp := tmp+(a[i+1][j+1] * b[j+1][0+1]) ;  ;     j := j + 1 ) ; 
     c[i+1][0+1] := tmp )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < c->size() do ( (     OclFile["System.out"].println(c[i+1][0+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    int n,m ;
    String[] str ;
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    str=br.readLine().split(" ");
    n=Integer.parseInt(str[0]);
    m=Integer.parseInt(str[1]);
    int[][] arr=new int[n][m];
    int[] vec=new int[m];
    int[] ans=new int[n];
    for(int i=0 ; i<n ; i++){
      String[] str2=br.readLine().split(" ");
      for(int j=0 ; j<m ; j++){
        arr[i][j]=Integer.parseInt(str2[j]);
      }
    }
    for(int i=0 ; i<m ; i++){
      vec[i]=Integer.parseInt(br.readLine());
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        ans[i]+=arr[i][j]*vec[j];
      }
    }
    for(int num : ans){
      System.out.println(num);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var m : int ;
     var str : Sequence(String) ;
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    str := br.readLine()->split(" ") ; 
    n := (str[0+1])->toInteger() ; 
    m := (str[1+1])->toInteger() ; 
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var vec : Sequence(int) ; vec := Integer.subrange(1,m)->collect(0) ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var str2 : Sequence(String) ; str2 := br.readLine()->split(" ") ;
         var j : int ; j := 0 ; while j < m do ( (     arr[i+1][j+1] := (str2[j+1])->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     vec[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     ans[i+1] := ans[i+1]+(arr[i+1][j+1] * vec[j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    for (num : ans) do ( (     OclFile["System.out"].println(num) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class MinSum {
  static long findMinSum(long a[],long b[],long n){
    Arrays.sort(a);
    Arrays.sort(b);
    long sum=0 ;
    for(int i=0 ; i<n ; i++)sum=sum+Math.abs(a[i]-b[i]);
    return sum ;
  }
  public static void main(String[] args){
    long a[]={
      4,1,8,7 };
      long b[]={
        2,3,6,5 };
        int n=a.length ;
        System.out.println(findMinSum(a,b,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class MinSum {
  static   operation findMinSum( a : Sequence(long), b : Sequence(long), n : long) : long
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     b := b->sort() ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (     sum := sum + if a[i+1] - b[i+1] < 0 then -(a[i+1] - b[i+1]) else a[i+1] - b[i+1] endif ;  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Sequence{4,1,8,7} ;
     var b : Sequence(long) ; b := Sequence{2,3,6,5} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(findMinSum(a, b, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.List ;
import java.util.ArrayList ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int Q=scan.nextInt();
    List<Long>ans=new ArrayList<>();
    while(Q-->0){
      long A=scan.nextLong();
      long B=scan.nextLong();
      long r=(long)(Math.sqrt((double)A*B));
      if(r*r==A*B && A!=B)--r ;
      if(r*(r+1)<A*B){
        ans.add(2*r-1);
      }
      else {
        ans.add(2*(r-1));
      }
    }
    for(long i : ans)System.out.println(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var Q : int ; Q := scan.getCurrent()->toInteger() ;
    var ans : Sequence(long) ; ans := Sequence{} ;
        while (Q > 0) do (        Q := Q - 1 ;     skip ; (     var A : long ; A := scan.getCurrent()->toLong() ;
     var B : long ; B := scan.getCurrent()->toLong() ;
    var r : long ; r := ((A->oclAsType(double) * B)->sqrt())->oclAsType(long) ;
    if (r * r = A * B & A /= B) then     r := r - 1 ; else skip ; 
    if (r * (r + 1) < A * B) then (     ans := ans->including(2 * r - 1) ) else (     ans := ans->including(2 * (r - 1)) ) ;  
 ) ;  ) ;  
    for (i : ans) do (     OclFile["System.out"].println(i) ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskD solver=new TaskD();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskD {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int N=in.nextInt();
      for(int i=0 ; i<N ; i++){
        long A=in.nextLong();
        long B=in.nextLong();
        long a=Math.min(A,B);
        long b=Math.max(A,B);
        long ans ;
        if(a==b || a+1==b){
          ans=2*(a-1);
        }
        else {
          long c=(long)Math.sqrt(a*b);
          if(c*c==a*b)c--;
          if(c*(c+1)<a*b){
            ans=2*c-1 ;
          }
          else {
            ans=2*c-2 ;
          }
        }
        out.println(ans);
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskD ; solver := TaskD.newTaskD() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskD {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.nextInt() ;
         var i : int ; i := 0 ; while i < N do ( (     var A : long ; A := in.nextLong() ;
     var B : long ; B := in.nextLong() ;
    var a : long ; a := Set{A, B}->min() ;
    var b : long ; b := Set{A, B}->max() ;
    var ans : long ;
    if (a = b or a + 1 = b) then (     ans := 2 * (a - 1) ) else (     var c : long ; c := (a * b)->sqrt()->oclAsType(long) ;
     if (c * c = a * b) then     c := c - 1 ; else skip ; 
     if (c * (c + 1) < a * b) then (     ans := 2 * c - 1 ) else (     ans := 2 * c - 2 ) ) ;  
    skip ; 
 )  ;     i := i + 1 ) );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class geeks {
  public static int minOperations(int[] a,int n,int K){
    HashMap<Integer,Boolean>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      try {
        if(map.get(a[i]))return 1 ;
      }
      catch(Exception e){
      }
      try {
        map.put(a[i],true);
      }
      catch(Exception e){
      }
    }
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++)b[i]=a[i] & K ;
    map.clear();
    for(int i=0 ; i<n ; i++){
      if(a[i]!=b[i]){
        try {
          map.put(b[i],true);
        }
        catch(Exception e){
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      try {
        if(map.get(a[i]))return 1 ;
      }
      catch(Exception e){
      }
    }
    map.clear();
    for(int i=0 ; i<n ; i++){
      try {
        if(map.get(b[i]))return 2 ;
      }
      catch(Exception e){
      }
      try {
        map.put(b[i],true);
      }
      catch(Exception e){
      }
    }
    return-1 ;
  }
  public static void main(String[] args){
    int K=3 ;
    int[] a={
      1,2,3,7 };
      int n=a.length ;
      System.out.println(minOperations(a,n,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class geeks {
  static   operation minOperations( a : Sequence(int), n : int, K : int) : int
  pre: true
  post: true
  activity: (     var map : Map(int,Boolean) ; map := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     try (     if (map->at(a[i+1])) then     return 1 else skip )   catch (e : ProgramException) do skip
     try (     map := map->union(Map{a[i+1] |-> true}) )   catch (e : ProgramException) do skip
 )  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     b[i+1] := a[i+1] & K ;  ;     i := i + 1 ) ; 
    map := map->intersection(Map{}) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] /= b[i+1]) then (     try (     map := map->union(Map{b[i+1] |-> true}) )   catch (e : ProgramException) do skip
 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     try (     if (map->at(a[i+1])) then     return 1 else skip )   catch (e : ProgramException) do skip
 )  ;     i := i + 1 ) ; 
    map := map->intersection(Map{}) ; 
        var i : int ; i := 0 ; while i < n do ( (     try (     if (map->at(b[i+1])) then     return 2 else skip )   catch (e : ProgramException) do skip
     try (     map := map->union(Map{b[i+1] |-> true}) )   catch (e : ProgramException) do skip
 )  ;     i := i + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var K : int ; K := 3 ;
     var a : Sequence(int) ; a := Sequence{1,2,3,7} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(minOperations(a, n, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int W,H,C ;
    StringTokenizer st=new StringTokenizer(br.readLine());
    W=parseInt(st.nextToken());
    H=parseInt(st.nextToken());
    C=parseInt(st.nextToken());
    int gcd=gcd(W,H);
    System.out.println(W*H/gcd/gcd*C);
  }
  static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var W : int ;
    var H : int ;
    var C : int ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    W := (st.next() + "")->toInteger() ; 
    H := (st.next() + "")->toInteger() ; 
    C := (st.next() + "")->toInteger() ; 
    var gcd : int ; gcd := gcd(W, H) ;
    OclFile["System.out"].println(W * H / gcd / gcd * C) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      long a=sc.nextLong();
      long b=sc.nextLong();
      long rt=(long)Math.floor(Math.sqrt(a*b));
      long ans=0 ;
      if(rt*(rt+1)<a*b){
        ans=2*rt-1 ;
      }
      else if(rt*rt<a*b){
        ans=2*rt-2 ;
      }
      else {
        ans=2*rt-3 ;
        if(rt==a && rt==b){
          ans++;
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < q do ( (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
    var rt : long ; rt := ((a * b)->sqrt())->floor()->oclAsType(long) ;
    var ans : long ; ans := 0 ;
    if (rt * (rt + 1) < a * b) then (     ans := 2 * rt - 1 ) else     if (rt * rt < a * b) then (     ans := 2 * rt - 2 ) else (     ans := 2 * rt - 3 ; 
     if (rt = a & rt = b) then (     ans := ans + 1 ) else skip ) ;  ;  
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.PriorityQueue ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int q=Integer.parseInt(br.readLine());
    for(int i=0 ; i<q ; i++){
      String[] tmpArray=br.readLine().split(" ");
      int a=Integer.parseInt(tmpArray[0]);
      int b=Integer.parseInt(tmpArray[1]);
      if(a>b){
        int tmp=a ;
        a=b ;
        b=tmp ;
      }
      long result=0 ;
      if(a==b){
        result=2*a-2 ;
      }
      else if(a+1==b){
        result=2*a-2 ;
      }
      else {
        long c=(long)Math.sqrt((long)a*b);
        if(c*c==(long)a*b){
          c--;
        }
        if(c*(c+1)>=(long)a*b){
          result=2*c-2 ;
        }
        else {
          result=2*c-1 ;
        }
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var q : int ; q := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < q do ( (     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
     var a : int ; a := (tmpArray[0+1])->toInteger() ;
    var b : int ; b := (tmpArray[1+1])->toInteger() ;
    if (a > b) then (     var tmp : int ; tmp := a ;
     a := b ; 
     b := tmp ) else skip ; 
    var result : long ; result := 0 ;
    if (a = b) then (     result := 2 * a - 2 ) else     if (a + 1 = b) then (     result := 2 * a - 2 ) else (     var c : long ; c := (a->oclAsType(long) * b)->sqrt()->oclAsType(long) ;
     if (c * c = a->oclAsType(long) * b) then (     c := c - 1 ) else skip ; 
     if (c * (c + 1) >= a->oclAsType(long) * b) then (     result := 2 * c - 2 ) else (     result := 2 * c - 1 ) ) ;  ;  
    OclFile["System.out"].println(result) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int q=scanner.nextInt();
    for(int i=0 ; i<q ; i++){
      long a=scanner.nextLong();
      long b=scanner.nextLong();
      System.out.println(solve(a,b));
    }
  }
  private static long solve(long a,long b){
    if(a>b)return solve(b,a);
    if(a==b)return 2*a-2 ;
    if(a+1==b)return 2*a-2 ;
    long ab=Math.multiplyExact(a,b);
    long c=findUpperRoot(ab);
    long cc1=Math.multiplyExact(c,c+1);
    if(cc1>=ab)return 2*c-2 ;
    return 2*c-1 ;
  }
  private static long findUpperRoot(long n){
    long ll=0 ;
    long ul=(long)Math.sqrt(n)+1 ;
    while(Math.addExact(ll,1)<ul){
      long mid=Math.addExact(ll,ul)/2 ;
      if(Math.multiplyExact(mid,mid)<n){
        ll=mid ;
      }
      else {
        ul=mid ;
      }
    }
    return ll ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < q do ( (     var a : long ; a := scanner.getCurrent()->toLong() ;
     var b : long ; b := scanner.getCurrent()->toLong() ;
     OclFile["System.out"].println(solve(a, b)) )  ;     i := i + 1 ) );
  static   operation solve( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a > b) then     return solve(b, a) else skip ; 
     if (a = b) then     return 2 * a - 2 else skip ; 
    if (a + 1 = b) then     return 2 * a - 2 else skip ; 
    var ab : long ; ab := multiplyExact(a, b) ;
    var c : long ; c := findUpperRoot(ab) ;
    var cc1 : long ; cc1 := multiplyExact(c, c + 1) ;
    if (cc1 >= ab) then     return 2 * c - 2 else skip ; 
    return 2 * c - 1 
 );
  static   operation findUpperRoot( n : long) : long
  pre: true
  post: true
  activity: (     var ll : long ; ll := 0 ;
     var ul : long ; ul := (n)->sqrt()->oclAsType(long) + 1 ;
     while (addExact(ll, 1) < ul) do (     var mid : long ; mid := addExact(ll, ul) / 2 ;
     if (multiplyExact(mid, mid) < n) then (     ll := mid ) else (     ul := mid ) ) ; 
     return ll );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printSeriesSum(int N){
    double sum=0 ;
    for(int i=1 ; i<=N ; i++){
      if(i % 2==1){
        sum+=(double)i/(i+1);
      }
      else {
        sum-=(double)i/(i+1);
      }
    }
    System.out.print(sum+"\n");
  }
  public static void main(String[] args){
    int N=10 ;
    printSeriesSum(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printSeriesSum( N : int) : void
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
         var i : int ; i := 1 ; while i <= N do ( (     if (i mod 2 = 1) then (     sum := sum+(i->oclAsType(double) / (i + 1)) ) else (     sum := sum-(i->oclAsType(double) / (i + 1)) ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(sum + "\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 10 ;
     execute printSeriesSum(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printSeriesSum(int N){
    long sum=0 ;
    for(int i=1 ; i<=N ; i++){
      sum+=Math.pow(i,i-1);
    }
    System.out.print(sum+"\n");
  }
  public static void main(String[] args){
    int N=5 ;
    printSeriesSum(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printSeriesSum( N : int) : void
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var i : int ; i := 1 ; while i <= N do ( (     sum := sum+(i->pow(i - 1)) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(sum + "\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     execute printSeriesSum(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p053 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p053().run());
  }
  public String run(){
    BigInteger MILLION=BigInteger.TEN.pow(6);
    int count=0 ;
    for(int n=1 ; n<=100 ; n++){
      for(int r=0 ; r<=n ; r++){
        if(Library.binomial(n,r).compareTo(MILLION)>0)count++;
      }
    }
    return Integer.toString(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p053 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p053.newp053().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var MILLION : long ; MILLION := 10.pow(6) ;
     var count : int ; count := 0 ;
         var n : int ; n := 1 ; while n <= 100 do ( (         var r : int ; r := 0 ; while r <= n do ( (     if (Library.binomial(n, r)->compareTo(MILLION) > 0) then     count := count + 1 ; else skip )  ;     r := r + 1 ) )  ;     n := n + 1 ) ; 
     return ((count) + "") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int arr[]=new int[] {
    3,7,90,20,10,50,40 };
    static void findMinAvgSubarray(int n,int k){
      if(n<k)return ;
      int res_index=0 ;
      int curr_sum=0 ;
      for(int i=0 ; i<k ; i++)curr_sum+=arr[i];
      int min_sum=curr_sum ;
      for(int i=k ; i<n ; i++){
        curr_sum+=arr[i]-arr[i-k];
        if(curr_sum<min_sum){
          min_sum=curr_sum ;
          res_index=(i-k+1);
        }
      }
      System.out.println("Subarray between["+res_index+","+(res_index+k-1)+"] has minimum average");
    }
    public static void main(String[] args){
      int k=3 ;
      findMinAvgSubarray(arr.length,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
class Test {
  static   attribute arr : int := Sequence{3,7,90,20,10,50,40};
  static   operation findMinAvgSubarray( n : int, k : int) : void
  pre: true
  post: true
  activity: (     if (n < k) then     return else skip ; 
     var res_index : int ; res_index := 0 ;
    var curr_sum : int ; curr_sum := 0 ;
        var i : int ; i := 0 ; while i < k do (     curr_sum := curr_sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    var min_sum : int ; min_sum := curr_sum ;
        var i : int ; i := k ; while i < n do ( (     curr_sum := curr_sum+(arr[i+1] - arr[i - k+1]) ; 
     if (curr_sum < min_sum) then (     min_sum := curr_sum ; 
     res_index := (i - k + 1) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Subarray between[" + res_index + "," + (res_index + k - 1) + "] has minimum average") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 3 ;
     execute findMinAvgSubarray(arr->size(), k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class EqualGames {
  public static int minStep(int a,int b){
    if(a==b){
      return 0 ;
    }
    int x=1 ;
    int last=(x*(x+1)/2);
    int sum=a+b+last ;
    while((sum & 1)!=0 ||(sum/2<a || sum/2<b)){
      sum-=last ;
      x++;
      last=x*(x+1)/2 ;
      sum+=last ;
    }
    return x ;
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int num=scanner.nextInt();
    for(int i=0 ; i<num ; ++i){
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      System.out.println(minStep(a,b));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class EqualGames {
  static   operation minStep( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = b) then (     return 0 ) else skip ; 
     var x : int ; x := 1 ;
    var last : int ; last := (x * (x + 1) / 2) ;
    var sum : int ; sum := a + b + last ;
    while ((MathLib.bitwiseAnd(sum,1)) /= 0 or (sum / 2 < a or sum / 2 < b)) do (     sum := sum-(last) ; 
     x := x + 1 ; 
     last := x * (x + 1) / 2 ; 
     sum := sum+(last) ) ; 
    return x 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < num do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(minStep(a, b)) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class T2022081104_1 {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    List<String>sout=new ArrayList<>();
    try {
      int t=Integer.parseInt(br.readLine());
      if(t<1 || t>100){
        return ;
      }
      for(int i=0 ; i<t ; i++){
        String[] tmp1=br.readLine().split(" ");
        int a=Integer.parseInt(tmp1[0]);
        int b=Integer.parseInt(tmp1[1]);
        if(a<1 || a>1000000000 || b<1 || b>1000000000){
          return ;
        }
        else {
          sout.add(printNumber(a,b)+"");
        }
      }
    }
    catch(IOException ioException){
      return ;
    }
    finally {
      for(String i : sout){
        System.out.println(i);
      }
    }
  }
  private static int printNumber(int a,int b){
    int tmp=1 ;
    if(a==b){
      return 0 ;
    }
    if(a<b){
      int c=a ;
      a=b ;
      b=c ;
    }
    while(true){
      long sum=tmp*(tmp+1)/2 ;
      if(sum>=(a-b)&&(sum+a+b)% 2==0){
        break ;
      }
      tmp=tmp+1 ;
    }
    return tmp ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class T2022081104_1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sout : Sequence(String) ; sout := Sequence{} ;
     try (     var t : int ; t := (br.readLine())->toInteger() ;
     if (t < 1 or t > 100) then (     return ) else skip ; 
         var i : int ; i := 0 ; while i < t do ( (     var tmp1 : Sequence(String) ; tmp1 := br.readLine()->split(" ") ;
     var a : int ; a := (tmp1[0+1])->toInteger() ;
     var b : int ; b := (tmp1[1+1])->toInteger() ;
     if (a < 1 or a > 1000000000 or b < 1 or b > 1000000000) then (     return ) else (     sout := sout->including(printNumber(a, b) + "") ) )  ;     i := i + 1 ) )   catch (ioException : IOException) do (     return )
   finally (     for (i : sout) do ( (     OclFile["System.out"].println(i) )  ) )
 );
  static   operation printNumber( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := 1 ;
     if (a = b) then (     return 0 ) else skip ; 
    if (a < b) then (     var c : int ; c := a ;
     a := b ; 
     b := c ) else skip ; 
    while (true) do (     var sum : long ; sum := tmp * (tmp + 1) / 2 ;
     if (sum >= (a - b) & (sum + a + b) mod 2 = 0) then (     break ) else skip ; 
     tmp := tmp + 1 ) ; 
    return tmp 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  int h,w ;
  char[][] grid ;
  Boolean B,W ;
  int countB,countW ;
  int[] dx={
    1,-1,0,0 };
    int[] dy={
      0,0,1,-1 };
      char from,to ;
      int countGrid ;
      void solve(){
        Scanner sc=new Scanner(System.in);
        w=sc.nextInt();
        while(w!=0){
          h=sc.nextInt();
          grid=new char[h][w];
          for(int i=0 ; i<h ; i++){
            String line=sc.next();
            grid[i]=line.toCharArray();
          }
          countB=0 ;
          countW=0 ;
          for(int i=0 ; i<h ; i++){
            for(int j=0 ; j<w ; j++){
              if(grid[i][j]=='.'){
                B=false ;
                W=false ;
                countGrid=0 ;
                dfs(j,i);
                if(B && ! W)countB+=countGrid ;
                if(! B && W)countW+=countGrid ;
              }
            }
          }
          System.out.println(countB+" "+countW);
          w=sc.nextInt();
        }
      }
      void dfs(int x,int y){
        grid[y][x]='x' ;
        countGrid++;
        for(int i=0 ; i<4 ; i++){
          int nx=x+dx[i];
          int ny=y+dy[i];
          if(nx<w && nx>=0 && ny<h && ny>=0){
            if(grid[ny][nx]=='B')B=true ;
            else if(grid[ny][nx]=='W')W=true ;
            else if(grid[ny][nx]=='.'){
              dfs(nx,ny);
            }
          }
        }
      }
      public static void main(String[] args){
        new Main().solve();
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute h : int;
   attribute grid : Sequence(Sequence(String));
   attribute B : Boolean;
   attribute countB : int;
   attribute dx : Sequence(int) := Sequence{1,-1,0,0};
   attribute dy : Sequence(int) := Sequence{0,0,1,-1};
   attribute from : String;
   attribute countGrid : int;
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     w := sc.getCurrent()->toInteger() ; 
     while (w /= 0) do (     h := sc.getCurrent()->toInteger() ; 
     grid := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ; 
        var i : int ; i := 0 ; while i < h do ( (     var line : String ; line := sc.getCurrent() ;
     grid[i+1] := line->characters() )  ;     i := i + 1 ) ; 
    countB := 0 ; 
    countW := 0 ; 
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (grid[i+1][j+1] = '.') then (     B := false ; 
     W := false ; 
    countGrid := 0 ; 
    execute dfs(j, i) ; 
    if (B & not(W)) then     countB := countB+(countGrid) ; else skip ; 
    if (not(B) & W) then     countW := countW+(countGrid) ; else skip ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(countB + " " + countW) ; 
    w := sc.getCurrent()->toInteger() ; 
 ) );
   operation dfs( x : int, y : int) : void
  pre: true
  post: true
  activity: (     grid[y+1][x+1] := 'x' ; 
     countGrid := countGrid + 1 ; 
         var i : int ; i := 0 ; while i < 4 do ( (     var nx : int ; nx := x + dx[i+1] ;
     var ny : int ; ny := y + dy[i+1] ;
     if (nx < w & nx >= 0 & ny < h & ny >= 0) then (     if (grid[ny+1][nx+1] = 'B') then     B := true ; else     if (grid[ny+1][nx+1] = 'W') then     W := true else     if (grid[ny+1][nx+1] = '.') then (     execute dfs(nx, ny) ) else skip ; ;  ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ProblemD {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    int[] result=new int[t];
    for(int i=0 ; i<t ; i++){
      int a=in.nextInt();
      int b=in.nextInt();
      int x=0 ;
      while(true){
        int sum=a+b+x*(x+1)/2 ;
        if(sum % 2==0 && sum/2>=Math.max(a,b)){
          result[i]=x ;
          break ;
        }
        x++;
      }
    }
    for(int i=0 ; i<t ; i++){
      System.out.println(result[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemD {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var result : Sequence(int) ; result := Integer.subrange(1,t)->collect(0) ;
        var i : int ; i := 0 ; while i < t do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
     var x : int ; x := 0 ;
     while (true) do (     var sum : int ; sum := a + b + x * (x + 1) / 2 ;
     if (sum mod 2 = 0 & sum / 2 >= Set{a, b}->max()) then (     result[i+1] := x ; 
     break ) else skip ; 
     x := x + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < t do ( (     OclFile["System.out"].println(result[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  static int gcd(int x,int y){
    if(y==0){
      return x ;
    }
    else {
      return gcd(y,x % y);
    }
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int W=sc.nextInt();
    int H=sc.nextInt();
    int WH=gcd(W,H);
    int C=sc.nextInt();
    int a=(W/WH)*(H/WH);
    System.out.println(a*C);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (y = 0) then (     return x ) else (     return gcd(y, x mod y) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var W : int ; W := sc.getCurrent()->toInteger() ;
    var H : int ; H := sc.getCurrent()->toInteger() ;
    var WH : int ; WH := gcd(W, H) ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var a : int ; a := (W / WH) * (H / WH) ;
    OclFile["System.out"].println(a * C) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    for(int i=0 ; i<t ; i++){
      long a=scanner.nextInt();
      long b=scanner.nextInt();
      if(a==b){
        System.out.println(0);
        continue ;
      }
      long n=(long)Math.sqrt(2*Math.abs(a-b));
      if((a+b)% 2==0){
        if(n % 4==1 || n % 4==2){
          n+=3-n % 4 ;
        }
      }
      else {
        if(n % 4==3 || n % 4==0){
          n+=Math.abs(n % 4-1);
        }
      }
      while(true){
        long temp=n*n+n+2*a+2*b ;
        if(temp/4>=a && temp/4>=b){
          break ;
        }
        if((n % 4)% 2==0){
          n+=3 ;
        }
        else {
          n++;
        }
      }
      System.out.println(n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : long ; a := scanner.getCurrent()->toInteger() ;
     var b : long ; b := scanner.getCurrent()->toInteger() ;
    if (a = b) then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
    var n : long ; n := (2 * if a - b < 0 then -(a - b) else a - b endif)->sqrt()->oclAsType(long) ;
    if ((a + b) mod 2 = 0) then (     if (n mod 4 = 1 or n mod 4 = 2) then (     n := n+(3 - n mod 4) ) else skip ) else (     if (n mod 4 = 3 or n mod 4 = 0) then (     n := n+(if n mod 4 - 1 < 0 then -(n mod 4 - 1) else n mod 4 - 1 endif) ) else skip ) ;  
    while (true) do (     var temp : long ; temp := n * n + n + 2 * a + 2 * b ;
     if (temp / 4 >= a & temp / 4 >= b) then (     break ) else skip ; 
     if ((n mod 4) mod 2 = 0) then (     n := n+(3) ) else (     n := n + 1 ) ) ; 
    OclFile["System.out"].println(n) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Security0812D {
  public static void main(String[] args){
    Scanner reader=new Scanner(System.in);
    int count=0 ;
    int total=reader.nextInt();
    while(reader.hasNextInt()){
      int a=reader.nextInt();
      int b=reader.nextInt();
      System.out.println(process(a,b));
      if(++count==total){
        break ;
      }
    }
  }
  private static int process(int a,int b){
    int n=Math.abs(a-b);
    int m=(int)Math.sqrt(n*2);
    while(m*(m+1)/2<n ||(m*(m+1)/2-n)% 2!=0){
      m++;
    }
    return m ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Security0812D {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := 0 ;
     var total : int ; total := reader.getCurrent()->toInteger() ;
     while (reader.hasNextInt()) do (     var a : int ; a := reader.getCurrent()->toInteger() ;
     var b : int ; b := reader.getCurrent()->toInteger() ;
     OclFile["System.out"].println(process(a, b)) ; 
     if ((count + 1) = total) then (     break ) else skip ) );
  static   operation process( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := if a - b < 0 then -(a - b) else a - b endif ;
     var m : int ; m := (n * 2)->sqrt()->oclAsType(int) ;
     while (m * (m + 1) / 2 < n or (m * (m + 1) / 2 - n) mod 2 /= 0) do (     m := m + 1 ) ; 
     return m );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Googlerese {
  public static void main(String[] args)throws Exception {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String dict="yhesocvxduiglbkrztnwjpfmaq" ;
    int T=Integer.parseInt(in.readLine());
    for(int i=0 ; i<T ; i++){
      String s=in.readLine();
      String ans="" ;
      for(int j=0 ; j<s.length(); j++){
        if(s.charAt(j)<97 || s.charAt(j)>122){
          ans+=s.charAt(j);
        }
        else {
          ans+=dict.charAt(s.charAt(j)-97);
        }
      }
      System.out.println("Case #"+(i+1)+": "+ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Googlerese {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var dict : String ; dict := "yhesocvxduiglbkrztnwjpfmaq" ;
     var T : int ; T := (in.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < T do ( (     var s : String ; s := in.readLine() ;
     var ans : String ; ans := "" ;
         var j : int ; j := 0 ; while j < s->size() do ( (     if (s->at(j+1) < 97 or s->at(j+1) > 122) then (     ans := ans+(s->at(j+1)) ) else (     ans := ans+(dict->at(s->at(j+1) - 97+1)) ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("Case #" + (i + 1) + ": " + ans) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package j2012qualifier ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class A {
  public static String inputDirectory="src/j2012qualifier/" ;
  public static String inputFile="A.in" ;
  public static String outputFile="A.out" ;
  public static PrintWriter output ;
  public static void main(String[] args)throws FileNotFoundException {
    Scanner s=new Scanner(new File(inputDirectory+inputFile));
    output=new PrintWriter(new File(inputDirectory+outputFile));
    Map<Character,Character>codeMap=new HashMap<Character,Character>();
    String source="qzejp mysljylc kd kxveddknmc re jsicpdrysi rbcpc ypc rtcsra dkh wyfrepkym veddknkmkrkcd de kr kd eoya kw aej tysr re ujdr lkgc jv" ;
    String result="zqour language is impossible to understand there are twenty six factorial possibilities so it is okay if you want to just give up" ;
    for(int i=0 ; i<source.length(); i++){
      codeMap.put(source.charAt(i),result.charAt(i));
    }
    int cases=s.nextInt();
    s.nextLine();
    for(int Case=1 ; Case<=cases ; Case++){
      String code=s.nextLine();
      char[] uncoded=new char[code.length()];
      for(int i=0 ; i<uncoded.length ; i++){
        uncoded[i]=codeMap.get(code.charAt(i));
      }
      String answer=String.valueOf(uncoded);
      out("Case #"+Case+": "+answer);
    }
    output.flush();
  }
  public static void out(String s){
    output.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute inputDirectory : String := "src/j2012qualifier/";
  static   attribute inputFile : String := "A.in";
  static   attribute outputFile : String := "A.out";
  static   attribute output : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile(inputDirectory + inputFile)) ;
     output := OclFile.newOclFile_Write(OclFile(inputDirectory + outputFile)) ; 
    var codeMap : Map(String,String) ; codeMap := Map{} ;
    var source : String ; source := "qzejp mysljylc kd kxveddknmc re jsicpdrysi rbcpc ypc rtcsra dkh wyfrepkym veddknkmkrkcd de kr kd eoya kw aej tysr re ujdr lkgc jv" ;
    var result : String ; result := "zqour language is impossible to understand there are twenty six factorial possibilities so it is okay if you want to just give up" ;
        var i : int ; i := 0 ; while i < source->size() do ( (     codeMap := codeMap->union(Map{source->at(i+1) |-> result->at(i+1)}) )  ;     i := i + 1 ) ; 
    var cases : int ; cases := s.getCurrent()->toInteger() ;
    skip ; 
        var Case : int ; Case := 1 ; while Case <= cases do ( (     var code : String ; code := s.nextLine() ;
     var uncoded : Sequence(String) ; uncoded := Integer.subrange(1,code->size())->collect(0) ;
        var i : int ; i := 0 ; while i < uncoded->size() do ( (     uncoded[i+1] := codeMap->at(code->at(i+1)) )  ;     i := i + 1 ) ; 
    var answer : String ; answer := (uncoded)->sum()  ;
    execute out("Case #" + Case + ": " + answer) ; 
 )  ;     Case := Case + 1 ) ; 
    skip ; 
 );
  static   operation out( s : String) : void
  pre: true
  post: true
  activity: (     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package google.codejam2012.qualification ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class SpeakingInTongues {
  private static String TRANSLATER="yhesocvxduiglbkrztnwjpfmaq" ;
  private static char translate(char ch){
    if('a'<=ch & ch<='z')return TRANSLATER.charAt(ch-'a');
    else return ch ;
  }
  private static String translate(String s){
    int l=s.length();
    StringBuilder translated=new StringBuilder(l);
    for(int i=0 ; i<l ; i++){
      translated.append(translate(s.charAt(i)));
    }
    return translated.toString();
  }
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in),64<<10);
      int testsNumber=Integer.parseInt(br.readLine().trim());
      for(int test=1 ; test<=testsNumber ; test++){
        System.out.println("Case #"+test+":"+translate(br.readLine()));
      }
    }
    catch(Exception e){
      System.err.println("Error:"+e.getMessage());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SpeakingInTongues {
  static   attribute TRANSLATER : String := "yhesocvxduiglbkrztnwjpfmaq";
  static   operation translate( ch : String) : String
  pre: true
  post: true
  activity: (     if ('a' <= ch & ch <= 'z') then     return TRANSLATER->at(ch - ('a')->char2byte()+1) else     return ch );
  static   operation translate( s : String) : String
  pre: true
  post: true
  activity: (     var l : int ; l := s->size() ;
     var translated : String ; translated := StringLib.newString(l) ;
         var i : int ; i := 0 ; while i < l do ( (     translated := translated + StringLib.newString(translate(s->at(i+1))) )  ;     i := i + 1 ) ; 
     return translated+"" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (64*(2->pow(10)))->oclAsType(long)) ;
     var testsNumber : int ; testsNumber := (br.readLine()->trim())->toInteger() ;
         var test : int ; test := 1 ; while test <= testsNumber do ( (     OclFile["System.out"].println("Case #" + test + ":" + translate(br.readLine())) )  ;     test := test + 1 ) )   catch (e : ProgramException) do (     OclFile["System.err"].println("Error:" + e.getMessage()) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.PrintStream ;
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.FileOutputStream ;
import java.util.Arrays ;
import java.io.PrintWriter ;
import java.io.FileInputStream ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream ;
    try {
      inputStream=new FileInputStream("gcj1.in");
    }
    catch(IOException e){
      throw new RuntimeException(e);
    }
    OutputStream outputStream ;
    try {
      outputStream=new FileOutputStream("gcj1.out");
    }
    catch(IOException e){
      throw new RuntimeException(e);
    }
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    GCJ1 solver=new GCJ1();
    solver.solve(1,in,out);
    out.close();
  }
}
class GCJ1 {
  public void solve(int testNumber,Scanner in,PrintWriter out){
    char[] map={
      'y','h','e','s','o','c','v','x','d','u','i','g','l','b','k','r','z','t','n','w','j','p','f','m','a','q' };
      int cases=in.nextInt();
      in.nextLine();
      for(int i=0 ; i<cases ; i++){
        String input=in.nextLine();
        char[] output=new char[input.length()];
        for(int j=0 ; j<output.length ; j++){
          if(input.charAt(j)==' ')output[j]=' ' ;
          else output[j]=map[input.charAt(j)-'a'];
        }
        out.println("Case #"+(i+1)+": "+new String(output));
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ;
     try (     inputStream := OclFile.newOclFile_Read(OclFile.newOclFile("gcj1.in")) )   catch (e : IOException) do (     error ProgramException(e) )
    var outputStream : OclFile ;
    try (     outputStream := OclFile.newOclFile_Write(OclFile.newOclFile("gcj1.out")) )   catch (e : IOException) do (     error ProgramException(e) )
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : GCJ1 ; solver := GCJ1.newGCJ1() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
}
class GCJ1 {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var map : Sequence(String) ; map := Sequence{'y','h','e','s','o','c','v','x','d','u','i','g','l','b','k','r','z','t','n','w','j','p','f','m','a','q'} ;
     var cases : int ; cases := in.getCurrent()->toInteger() ;
     skip ; 
         var i : int ; i := 0 ; while i < cases do ( (     var input : String ; input := in.nextLine() ;
     var output : Sequence(String) ; output := Integer.subrange(1,input->size())->collect(0) ;
         var j : int ; j := 0 ; while j < output->size() do ( (     if (input->at(j+1) = ' ') then     output[j+1] := ' ' ; else     output[j+1] := map[input->at(j+1) - ('a')->char2byte()+1] ; )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf108A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String time=scan.next();
    int HH=Integer.parseInt(time.substring(0,2));
    int MM=Integer.parseInt(time.substring(3));
    while(true){
      MM++;
      if(MM==60){
        MM=0 ;
        HH++;
        if(HH==24){
          System.out.println("00:00");
          break ;
        }
      }
      StringBuilder hime=new StringBuilder();
      if(HH<10){
        hime.append(0);
      }
      hime.append(HH);
      hime.append(':');
      if(MM<10){
        hime.append(0);
      }
      hime.append(MM);
      if(isPal(hime)){
        System.out.println(hime);
        break ;
      }
    }
  }
  public static boolean isPal(StringBuilder time){
    StringBuilder rev=new StringBuilder(time);
    rev.reverse();
    if(rev.toString().equals(time.toString())){
      return true ;
    }
    else {
      return false ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf108A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var time : String ; time := scan.getCurrent() ;
    var HH : int ; HH := (time.subrange(0+1,2))->toInteger() ;
    var MM : int ; MM := (time.subrange(3+1,3))->toInteger() ;
    while (true) do (     MM := MM + 1 ; 
     if (MM = 60) then (     MM := 0 ; 
     HH := HH + 1 ; 
     if (HH = 24) then (     OclFile["System.out"].println("00:00") ; 
     break ) else skip ) else skip ; 
    var hime : String ; hime := StringLib.newString() ;
    if (HH < 10) then (     hime := hime + StringLib.newString(0) ) else skip ; 
    hime := hime + StringLib.newString(HH) ; 
    hime := hime + StringLib.newString(':') ; 
    if (MM < 10) then (     hime := hime + StringLib.newString(0) ) else skip ; 
    hime := hime + StringLib.newString(MM) ; 
    if (isPal(hime)) then (     OclFile["System.out"].println(hime) ; 
     break ) else skip ; 
 ) ; 
 );
  static   operation isPal( time : String) : boolean
  pre: true
  post: true
  activity: (     var rev : String ; rev := StringLib.newString(time) ;
     rev := rev->reverse() ; 
     if (rev+"" = time+"") then (     return true ) else (     return false ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int h ;
  static int w ;
  static int cnt=0 ;
  static char[][] g ;
  static boolean[][] v ;
  static boolean wbool ;
  static boolean bbool ;
  static void dfs(int i,int j){
    if(v[i][j])return ;
    if(g[i][j]=='W'){
      wbool=true ;
      return ;
    }
    if(g[i][j]=='B'){
      bbool=true ;
      return ;
    }
    if(g[i][j]!='.')return ;
    v[i][j]=true ;
    cnt++;
    if(i>0)dfs(i-1,j);
    if(i<h-1)dfs(i+1,j);
    if(j>0)dfs(i,j-1);
    if(j<w-1)dfs(i,j+1);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      w=sc.nextInt();
      h=sc.nextInt();
      if(w+h==0)break ;
      g=new char[h+1][w+1];
      v=new boolean[h+1][w+1];
      for(int i=0 ; i<h ; i++){
        g[i]=sc.next().toCharArray();
      }
      int hcnt=0 ;
      int bcnt=0 ;
      for(int i=0 ; i<h ; i++){
        for(int j=0 ; j<w ; j++){
          if(g[i][j]=='.' && v[i][j]==false){
            wbool=false ;
            bbool=false ;
            cnt=0 ;
            dfs(i,j);
            if(wbool && ! bbool){
              hcnt+=cnt ;
            }
            if(bbool && ! wbool){
              bcnt+=cnt ;
            }
          }
        }
      }
      System.out.println(bcnt+" "+hcnt);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute h : int;
  static   attribute w : int;
  static   attribute cnt : int := 0;
  static   attribute g : Sequence(Sequence(String));
  static   attribute v : Sequence(Sequence(boolean));
  static   attribute wbool : boolean;
  static   attribute bbool : boolean;
  static   operation dfs( i : int, j : int) : void
  pre: true
  post: true
  activity: (     if (v[i+1][j+1]) then     return else skip ; 
     if (g[i+1][j+1] = 'W') then (     wbool := true ; 
     return ) else skip ; 
    if (g[i+1][j+1] = 'B') then (     bbool := true ; 
     return ) else skip ; 
    if (g[i+1][j+1] /= '.') then     return else skip ; 
    v[i+1][j+1] := true ; 
    cnt := cnt + 1 ; 
    if (i > 0) then     execute dfs(i - 1, j) ; else skip ; 
    if (i < h - 1) then     execute dfs(i + 1, j) ; else skip ; 
    if (j > 0) then     execute dfs(i, j - 1) ; else skip ; 
    if (j < w - 1) then     execute dfs(i, j + 1) ; else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     w := sc.getCurrent()->toInteger() ; 
     h := sc.getCurrent()->toInteger() ; 
    if (w + h = 0) then     break else skip ; 
    g := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(0)) ; 
    v := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(false)) ; 
        var i : int ; i := 0 ; while i < h do ( (     g[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    var hcnt : int ; hcnt := 0 ;
    var bcnt : int ; bcnt := 0 ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (g[i+1][j+1] = '.' & v[i+1][j+1] = false) then (     wbool := false ; 
     bbool := false ; 
    cnt := 0 ; 
    execute dfs(i, j) ; 
    if (wbool & not(bbool)) then (     hcnt := hcnt+(cnt) ) else skip ; 
    if (bbool & not(wbool)) then (     bcnt := bcnt+(cnt) ) else skip ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(bcnt + " " + hcnt) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf108A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String in=scan.next();
    int HH=Integer.parseInt(in.substring(0,2));
    int MM=Integer.parseInt(in.substring(3));
    while(true){
      MM++;
      if(MM==60){
        MM=0 ;
        HH++;
        if(HH==24){
          System.out.println("00:00");
          break ;
        }
      }
      StringBuilder time=new StringBuilder();
      if(HH<10){
        time.append(0);
      }
      time.append(HH);
      time.append(":");
      if(MM<10){
        time.append(0);
      }
      time.append(MM);
      if(ispal(time)){
        System.out.println(time);
        break ;
      }
    }
  }
  public static boolean ispal(StringBuilder time){
    StringBuilder rev=new StringBuilder(time);
    rev.reverse();
    if(rev.toString().equals(time.toString())){
      return true ;
    }
    else {
      return false ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf108A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var in : String ; in := scan.getCurrent() ;
    var HH : int ; HH := (in.subrange(0+1,2))->toInteger() ;
    var MM : int ; MM := (in.subrange(3+1,3))->toInteger() ;
    while (true) do (     MM := MM + 1 ; 
     if (MM = 60) then (     MM := 0 ; 
     HH := HH + 1 ; 
     if (HH = 24) then (     OclFile["System.out"].println("00:00") ; 
     break ) else skip ) else skip ; 
    var time : String ; time := StringLib.newString() ;
    if (HH < 10) then (     time := time + StringLib.newString(0) ) else skip ; 
    time := time + StringLib.newString(HH) ; 
    time := time + StringLib.newString(":") ; 
    if (MM < 10) then (     time := time + StringLib.newString(0) ) else skip ; 
    time := time + StringLib.newString(MM) ; 
    if (ispal(time)) then (     OclFile["System.out"].println(time) ; 
     break ) else skip ; 
 ) ; 
 );
  static   operation ispal( time : String) : boolean
  pre: true
  post: true
  activity: (     var rev : String ; rev := StringLib.newString(time) ;
     rev := rev->reverse() ; 
     if (rev+"" = time+"") then (     return true ) else (     return false ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf108A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String in=scan.next();
    int HH=Integer.parseInt(in.substring(0,2));
    int MM=Integer.parseInt(in.substring(3));
    while(true){
      MM++;
      if(MM==60){
        MM=0 ;
        HH++;
        if(HH==24){
          System.out.println("00:00");
          break ;
        }
      }
      StringBuilder time=new StringBuilder();
      if(HH<10){
        time.append(0);
      }
      time.append(HH);
      time.append(':');
      if(MM<10){
        time.append(0);
      }
      time.append(MM);
      if(isPal(time)){
        System.out.println(time);
        break ;
      }
    }
  }
  public static boolean isPal(StringBuilder time){
    StringBuilder rev=new StringBuilder(time);
    rev.reverse();
    return rev.toString().equals(time.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf108A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var in : String ; in := scan.getCurrent() ;
    var HH : int ; HH := (in.subrange(0+1,2))->toInteger() ;
    var MM : int ; MM := (in.subrange(3+1,3))->toInteger() ;
    while (true) do (     MM := MM + 1 ; 
     if (MM = 60) then (     MM := 0 ; 
     HH := HH + 1 ; 
     if (HH = 24) then (     OclFile["System.out"].println("00:00") ; 
     break ) else skip ) else skip ; 
    var time : String ; time := StringLib.newString() ;
    if (HH < 10) then (     time := time + StringLib.newString(0) ) else skip ; 
    time := time + StringLib.newString(HH) ; 
    time := time + StringLib.newString(':') ; 
    if (MM < 10) then (     time := time + StringLib.newString(0) ) else skip ; 
    time := time + StringLib.newString(MM) ; 
    if (isPal(time)) then (     OclFile["System.out"].println(time) ; 
     break ) else skip ; 
 ) ; 
 );
  static   operation isPal( time : String) : boolean
  pre: true
  post: true
  activity: (     var rev : String ; rev := StringLib.newString(time) ;
     rev := rev->reverse() ; 
     return rev+"" = time+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextInt()){
      BigInteger w=sc.nextBigInteger();
      BigInteger h=sc.nextBigInteger();
      BigInteger c=sc.nextBigInteger();
      BigInteger gcd=w.gcd(h);
      System.out.println(w.divide(gcd).multiply(h.divide(gcd)).multiply(c));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextInt()) do (     var w : long ; w := sc.nextBigInteger() ;
     var h : long ; h := sc.nextBigInteger() ;
    var c : long ; c := sc.nextBigInteger() ;
    var gcd : long ; gcd := w.gcd(h) ;
    OclFile["System.out"].println(w.divide(gcd).multiply(h.divide(gcd)).multiply(c)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    String s1=s.substring(0,2);
    String s2=s.substring(3);
    int hh=Integer.parseInt(s1);
    int mm=Integer.parseInt(s2);
    do {
++mm ;
      if(mm==60){
        mm=0 ;
++hh ;
      }
      if(hh==24)hh=0 ;
    }
    while(hh % 10*10+hh/10!=mm);
    if(hh/10==0 && mm/10==0)System.out.println("0"+hh+":0"+mm);
    else if(hh/10==0)System.out.println("0"+hh+":"+mm);
    else if(mm/10==0)System.out.println(hh+":0"+mm);
    else System.out.println(hh+":"+mm);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var s1 : String ; s1 := s.subrange(0+1,2) ;
    var s2 : String ; s2 := s.subrange(3+1,3) ;
    var hh : int ; hh := (s1)->toInteger() ;
    var mm : int ; mm := (s2)->toInteger() ;
  while true do ((     mm := mm + 1 ; 
     if (mm = 60) then (     mm := 0 ; 
     hh := hh + 1 ) else skip ; 
     if (hh = 24) then     hh := 0 ; else skip ) ;
    if (hh mod 10 * 10 + hh / 10 /= mm) then skip else break) ; 
    if (hh / 10 = 0 & mm / 10 = 0) then     OclFile["System.out"].println("0" + hh + ":0" + mm) else     if (hh / 10 = 0) then     OclFile["System.out"].println("0" + hh + ":" + mm) else     if (mm / 10 = 0) then     OclFile["System.out"].println(hh + ":0" + mm) else     OclFile["System.out"].println(hh + ":" + mm) ; ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findTheNumber(int n){
    if(n==1){
      System.out.print("Impossible"+"\n");
      return ;
    }
    for(int i=0 ; i<n-1 ; i++){
      System.out.print("5");
    }
    System.out.print("4");
  }
  public static void main(String[] args){
    int n=12 ;
    findTheNumber(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findTheNumber( n : int) : void
  pre: true
  post: true
  activity: (     if (n = 1) then (     OclFile["System.out"].print("Impossible" + "\n") ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < n - 1 do ( (     OclFile["System.out"].print("5") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("4") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     execute findTheNumber(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      if(n<10){
        System.out.println(n);
        continue ;
      }
      String s=String.valueOf(n);
      char[] charArray=new char[s.length()];
      Arrays.fill(charArray,s.charAt(0));
      String str=new String(charArray);
      int k=Integer.valueOf(str);
      int tmp=(int)s.charAt(0)-'0' ;
      if(n<k){
        System.out.println((s.length()-1)*9+tmp-1);
      }
      else {
        System.out.println((s.length()-1)*9+tmp);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n < 10) then (     OclFile["System.out"].println(n) ; 
     continue ) else skip ; 
    var s : String ; s := ((n) + "") ;
    var charArray : Sequence(String) ; charArray := Integer.subrange(1,s->size())->collect(0) ;
    charArray := charArray->collect(s->at(0+1)) ; 
    var str : String ; str := StringLib.newString(charArray) ;
    var k : int ; k := (str)->toInteger() ;
    var tmp : int ; tmp := s->at(0+1)->oclAsType(int) - ('0')->char2byte() ;
    if (n < k) then (     OclFile["System.out"].println((s->size() - 1) * 9 + tmp - 1) ) else (     OclFile["System.out"].println((s->size() - 1) * 9 + tmp) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_Happy_Birthday_Polycarp {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; tc++){
      int n=sc.nextInt();
      System.out.println(solve(n));
    }
    sc.close();
  }
  static int solve(int n){
    int result=0 ;
    for(int digit=1 ; digit<=9 ; digit++){
      long beautiful=digit ;
      while(beautiful<=n){
        result++;
        beautiful=beautiful*10+digit ;
      }
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Happy_Birthday_Polycarp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(n)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var digit : int ; digit := 1 ; while digit <= 9 do ( (     var beautiful : long ; beautiful := digit ;
     while (beautiful <= n) do (     result := result + 1 ; 
     beautiful := beautiful * 10 + digit ) )  ;     digit := digit + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class HappyBirthdayPolycarp {
  public static void main(String[] args)throws IOException {
    Reader in=new Reader();
    PrintWriter out=new PrintWriter(System.out);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      int res=0 ;
      for(int i=1 ; i<=9 ; i++){
        long n=0 ;
        for(int j=1 ; j<=9 ; j++){
          n*=10 ;
          n+=i ;
          if(n<=N){
            res++;
          }
        }
      }
      out.println(res);
    }
    out.close();
  }
  static class Reader {
    BufferedReader in ;
    StringTokenizer st ;
    public Reader(){
      in=new BufferedReader(new InputStreamReader(System.in));
      st=new StringTokenizer("");
    }
    public String nextLine()throws IOException {
      st=new StringTokenizer("");
      return in.readLine();
    }
    public String next()throws IOException {
      while(! st.hasMoreTokens()){
        st=new StringTokenizer(in.readLine());
      }
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
  public static void sort(int[] arr){
    List<Integer>list=new ArrayList<>();
    for(int i : arr){
      list.add(i);
    }
    Collections.sort(list);
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=list.get(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HappyBirthdayPolycarp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var res : int ; res := 0 ;
         var i : int ; i := 1 ; while i <= 9 do ( (     var n : long ; n := 0 ;
         var j : int ; j := 1 ; while j <= 9 do ( (     n := n*(10) ; 
     n := n+(i) ; 
     if (n <= N) then (     res := res + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     skip )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static class Reader {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newReader() : Reader
  pre: true
  post: true
  activity:
  ( var self : Reader ;
    self := createReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := OclIterator.newOclIterator_String("") );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     st := OclIterator.newOclIterator_String("") ; 
     return in.readLine() );
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   operation sort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     for (i : arr) do ( (     list := list->including(i) )  ) ; 
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := list->at(i+1) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; tc++){
      int n=sc.nextInt();
      System.out.println(solve(n));
    }
    sc.close();
  }
  static int solve(int n){
    int result=0 ;
    for(int digit=1 ; digit<=9 ; digit++){
      long beautiful=digit ;
      while(beautiful<=n){
        result++;
        beautiful=beautiful*10+digit ;
      }
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(n)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var digit : int ; digit := 1 ; while digit <= 9 do ( (     var beautiful : long ; beautiful := digit ;
     while (beautiful <= n) do (     result := result + 1 ; 
     beautiful := beautiful * 10 + digit ) )  ;     digit := digit + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int countSubstr(String s){
    int n=s.length();
    int[] auxArr=new int[n];
    if(s.charAt(0)=='1')auxArr[0]=1 ;
    for(int i=1 ; i<n ; i++){
      if(s.charAt(i)=='1')auxArr[i]=auxArr[i-1]+1 ;
      else auxArr[i]=auxArr[i-1];
    }
    int count=0 ;
    for(int i=n-1 ; i>=0 ; i--)if(s.charAt(i)=='1')count+=auxArr[i];
    return count ;
  }
  public static void main(String[] args){
    String s="1101" ;
    System.out.println(countSubstr(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSubstr( s : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var auxArr : Sequence(int) ; auxArr := Integer.subrange(1,n)->collect(0) ;
    if (s->at(0+1) = '1') then     auxArr[0+1] := 1 ; else skip ; 
        var i : int ; i := 1 ; while i < n do ( (     if (s->at(i+1) = '1') then     auxArr[i+1] := auxArr[i - 1+1] + 1 ; else     auxArr[i+1] := auxArr[i - 1+1] ; )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do (     if (s->at(i+1) = '1') then     count := count+(auxArr[i+1]) ; else skip ;  ;     i := i - 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "1101" ;
     OclFile["System.out"].println(countSubstr(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    Book[] a=new Book[n];
    for(int i=0 ; i<n ; i++){
      String name=sc.next();
      a[i]=new Book(i+1,name);
    }
    Arrays.sort(a);
    for(Book x : a){
      System.out.print(x.getPos()+" ");
    }
    System.out.println();
  }
}
class Book implements Comparable<Book>{
  private final int pos ;
  private final String name ;
  Book(int p,String bookname){
    pos=p ;
    name=bookname ;
  }
  int getPos(){
    return pos ;
  }
  public int compareTo(Book b){
    for(int i=0 ; i<name.length(); i++){
      if(name.charAt(i)<b.name.charAt(i))return-1+(i % 2)*2 ;
      else if(name.charAt(i)>b.name.charAt(i))return 1-(i % 2)*2 ;
    }
    return 0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(Book) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var name : String ; name := sc.getCurrent() ;
     a[i+1] := Book.newBook(i + 1, name) )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    for (x : a) do ( (     OclFile["System.out"].print(x.getPos() + " ") )  ) ; 
    OclFile["System.out"].println() ; 
 );
}
class Book implements Comparable<Book> {
   attribute pos : int;
   attribute name : String;
   static operation newBook( p : int, bookname : String) : Book
  pre: true
  post: true
  activity:
  ( var self : Book ;
    self := createBook();
    self.initialise(p, bookname);
    return self );
  operation initialise( p : int, bookname : String) : void
  pre: true  post: true
  activity: (     pos := p ; 
     name := bookname );
   operation getPos() : int
  pre: true
  post: true
  activity: (     return pos );
   operation compareTo( b : Book) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < name->size() do ( (     if (name->at(i+1) < b.name->at(i+1)) then     return -1 + (i mod 2) * 2 else     if (name->at(i+1) > b.name->at(i+1)) then     return 1 - (i mod 2) * 2 else skip ; )  ;     i := i + 1 ) ; 
     return 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int x1=in.nextInt();
    int y1=in.nextInt();
    int x2=in.nextInt();
    int y2=in.nextInt();
    int x=Math.abs(x2-x1);
    int y=Math.abs(y2-y1);
    int dis=Math.min(x,y);
    int finalDis=dis+Math.abs(x-y);
    System.out.printf("%d\n",finalDis);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : int ; x1 := in.getCurrent()->toInteger() ;
    var y1 : int ; y1 := in.getCurrent()->toInteger() ;
    var x2 : int ; x2 := in.getCurrent()->toInteger() ;
    var y2 : int ; y2 := in.getCurrent()->toInteger() ;
    var x : int ; x := if x2 - x1 < 0 then -(x2 - x1) else x2 - x1 endif ;
    var y : int ; y := if y2 - y1 < 0 then -(y2 - y1) else y2 - y1 endif ;
    var dis : int ; dis := Set{x, y}->min() ;
    var finalDis : int ; finalDis := dis + if x - y < 0 then -(x - y) else x - y endif ;
    OclFile["System.out"].printf("%d\n", finalDis) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int x1=in.nextInt(),y1=in.nextInt();
    int x2=in.nextInt(),y2=in.nextInt();
    System.out.println(Math.max(Math.abs(x1-x2),Math.abs(y1-y2)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : int ; x1 := in.getCurrent()->toInteger() ;
    var y1 : int ; y1 := in.getCurrent()->toInteger() ;
     var x2 : int ; x2 := in.getCurrent()->toInteger() ;
    var y2 : int ; y2 := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println(Set{if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif, if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif}->max()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.*;
public class App {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws Exception {
    if(System.getProperty("ONLINE_JUDGE")==null){
      File inputFile=new File("/Users/vipinjain/self/cp/input.txt");
      File outputFile=new File("/Users/vipinjain/self/cp/output.txt");
      br=new BufferedReader(new FileReader(inputFile));
      bw=new BufferedWriter(new FileWriter(outputFile));
    }
    int tests ;
    tests=1 ;
    while(tests-->0){
      solve();
    }
    bw.flush();
    bw.close();
    br.close();
  }
  static boolean isVowel(char c){
    return c=='a' || c=='e' || c=='i' || c=='o' || c=='u' || c=='y' ;
  }
  static void solve()throws Exception {
    int x1,x2,y1,y2 ;
    String[] tmp=br.readLine().split(" ");
    x1=Integer.parseInt(tmp[0]);
    y1=Integer.parseInt(tmp[1]);
    tmp=br.readLine().split(" ");
    x2=Integer.parseInt(tmp[0]);
    y2=Integer.parseInt(tmp[1]);
    int ans=Math.max(Math.abs(x2-x1),Math.abs(y2-y1));
    bw.write(ans+"");
    bw.write("\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null) then (     var inputFile : OclFile ; inputFile := OclFile("/Users/vipinjain/self/cp/input.txt") ;
     var outputFile : OclFile ; outputFile := OclFile("/Users/vipinjain/self/cp/output.txt") ;
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputFile)) ; 
     bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputFile)) ) else skip ; 
     var tests : int ;
    tests := 1 ; 
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation isVowel( c : String) : boolean
  pre: true
  post: true
  activity: (     return c = 'a' or c = 'e' or c = 'i' or c = 'o' or c = 'u' or c = 'y' );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var x1 : int ;
    var x2 : int ;
    var y1 : int ;
    var y2 : int ;
     var tmp : Sequence(String) ; tmp := br.readLine()->split(" ") ;
    x1 := (tmp[0+1])->toInteger() ; 
    y1 := (tmp[1+1])->toInteger() ; 
    tmp := br.readLine()->split(" ") ; 
    x2 := (tmp[0+1])->toInteger() ; 
    y2 := (tmp[1+1])->toInteger() ; 
    var ans : int ; ans := Set{if x2 - x1 < 0 then -(x2 - x1) else x2 - x1 endif, if y2 - y1 < 0 then -(y2 - y1) else y2 - y1 endif}->max() ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GFG {
  static int getNumToAdd(int arr[],int n){
    Arrays.sort(arr);
    int d=arr[1]-arr[0];
    int numToAdd=-1 ;
    boolean numAdded=false ;
    for(int i=2 ; i<n ; i++){
      int diff=arr[i]-arr[i-1];
      if(diff!=d){
        if(numAdded)return-1 ;
        if(diff==2*d){
          numToAdd=arr[i]-d ;
          numAdded=true ;
        }
        else return-1 ;
      }
    }
    if(numToAdd==-1)return(arr[n-1]+d);
    return numToAdd ;
  }
  public static void main(String[] args){
    int arr[]={
      1,3,5,7,11,13,15 };
      int n=arr.length ;
      System.out.println(getNumToAdd(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getNumToAdd( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var d : int ; d := arr[1+1] - arr[0+1] ;
    var numToAdd : int ; numToAdd := -1 ;
    var numAdded : boolean ; numAdded := false ;
        var i : int ; i := 2 ; while i < n do ( (     var diff : int ; diff := arr[i+1] - arr[i - 1+1] ;
     if (diff /= d) then (     if (numAdded) then     return -1 else skip ; 
     if (diff = 2 * d) then (     numToAdd := arr[i+1] - d ; 
     numAdded := true ) else     return -1 ) else skip )  ;     i := i + 1 ) ; 
    if (numToAdd = -1) then     return (arr[n - 1+1] + d) else skip ; 
    return numToAdd 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,5,7,11,13,15} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(getNumToAdd(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(in.readLine());
    int xi=Integer.parseInt(st.nextToken());
    int yi=Integer.parseInt(st.nextToken());
    st=new StringTokenizer(in.readLine());
    int xf=Integer.parseInt(st.nextToken());
    int yf=Integer.parseInt(st.nextToken());
    int dx=Math.abs(xf-xi);
    int dy=Math.abs(yf-yi);
    System.out.println(Math.max(dy,dx));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(in.readLine()) ;
    var xi : int ; xi := (st.next())->toInteger() ;
    var yi : int ; yi := (st.next())->toInteger() ;
    st := OclIterator.newOclIterator_String(in.readLine()) ; 
    var xf : int ; xf := (st.next())->toInteger() ;
    var yf : int ; yf := (st.next())->toInteger() ;
    var dx : int ; dx := if xf - xi < 0 then -(xf - xi) else xf - xi endif ;
    var dy : int ; dy := if yf - yi < 0 then -(yf - yi) else yf - yi endif ;
    OclFile["System.out"].println(Set{dy, dx}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class ProfessorGukiZsRobot {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int x1=Integer.parseInt(str[0]);
    int y1=Integer.parseInt(str[1]);
    str=br.readLine().split(" ");
    int x2=Integer.parseInt(str[0]);
    int y2=Integer.parseInt(str[1]);
    System.out.print(Math.max(Math.abs(x1-x2),Math.abs(y2-y1)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProfessorGukiZsRobot {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var x1 : int ; x1 := (str[0+1])->toInteger() ;
    var y1 : int ; y1 := (str[1+1])->toInteger() ;
    str := br.readLine()->split(" ") ; 
    var x2 : int ; x2 := (str[0+1])->toInteger() ;
    var y2 : int ; y2 := (str[1+1])->toInteger() ;
    OclFile["System.out"].print(Set{if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif, if y2 - y1 < 0 then -(y2 - y1) else y2 - y1 endif}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Stack ;
import java.util.StringTokenizer ;
public class Main {
  public class Activity implements Comparable<Activity>{
    int start ;
    int end ;
    public Activity(int start,int end){
      this.start=start ;
      this.end=end ;
    }
    @ Override public int compareTo(Activity o){
      if(this.start!=o.start){
        return this.start-o.start ;
      }
      return this.end-this.end ;
    }
    public String toString(){
      return String.format("%d-%d",start,end);
    }
  }
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(reader.readLine());
    Activity[] activities=new Activity[n];
    for(int i=0 ; i<n ; i++){
      StringTokenizer st=new StringTokenizer(reader.readLine());
      int start=Integer.parseInt(st.nextToken());
      int end=Integer.parseInt(st.nextToken());
      activities[i]=new Activity(start,end);
    }
    reader.close();
    Arrays.sort(activities);
    Stack<Activity>stack=new Stack<Activity>();
    stack.push(activities[0]);
    for(int i=1 ; i<n ; i++){
      Activity last=stack.peek();
      Activity acti=activities[i];
      if(acti.start>last.end){
        stack.push(acti);
      }
      else if(acti.end<last.end){
        stack.pop();
        stack.push(acti);
      }
    }
    System.out.println(stack.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class Activity implements Comparable<Activity> {
   attribute start : int;
   attribute end : int;
   static operation newActivity( start : int, end : int) : Activity
  pre: true
  post: true
  activity:
  ( var self : Activity ;
    self := createActivity();
    self.initialise(start, end);
    return self );
  operation initialise( start : int, end : int) : void
  pre: true  post: true
  activity: (     self.start := start ; 
     self.end := end );
      operation compareTo( o : Activity) : int
  pre: true
  post: true
  activity: (     if (self.start /= o.start) then (     return self.start - o.start ) else skip ; 
     return self.end - self.end );
   operation toString() : String
  pre: true
  post: true
  activity: (     return StringLib.format("%d-%d",Sequence{start,end}) );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (reader.readLine())->toInteger() ;
    var activities : Sequence(Activity) ; activities := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(reader.readLine()) ;
     var start : int ; start := (st.next())->toInteger() ;
     var end : int ; end := (st.next())->toInteger() ;
     activities[i+1] := Activity.newActivity(start, end) )  ;     i := i + 1 ) ; 
    skip ; 
    activities := activities->sort() ; 
    var stack : Sequence(Activity) ; stack := Sequence{} ;
    stack := stack->append(activities[0+1]) ; 
        var i : int ; i := 1 ; while i < n do ( (     var last : Activity ; last := stack->min() ;
     var acti : Activity ; acti := activities[i+1] ;
     if (acti.start > last.end) then (     stack := stack->append(acti) ) else     if (acti.end < last.end) then (     stack := stack->front() ; 
     stack := stack->append(acti) ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(stack->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Work[] works=new Work[n];
    for(int i=0 ; i<n ; i++){
      works[i]=new Work(sc.nextInt(),sc.nextInt());
    }
    Arrays.sort(works);
    int[] dp=new int[n+1];
    Arrays.fill(dp,Integer.MAX_VALUE);
    dp[0]=0 ;
    int max=0 ;
    for(Work w : works){
      int left=0 ;
      int right=max+1 ;
      while(right-left>1){
        int m=(left+right)/2 ;
        if(dp[m]<w.left){
          left=m ;
        }
        else {
          right=m ;
        }
      }
      dp[left+1]=Math.min(dp[left+1],w.right);
      max=Math.max(max,left+1);
    }
    System.out.println(max);
  }
  static class Work implements Comparable<Work>{
    int left ;
    int right ;
    public Work(int left,int right){
      this.left=left ;
      this.right=right ;
    }
    public int compareTo(Work another){
      return right-another.right ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var works : Sequence(Work) ; works := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     works[i+1] := Work.newWork(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    works := works->sort() ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
    dp := dp->collect(2147483647) ; 
    dp[0+1] := 0 ; 
    var max : int ; max := 0 ;
    for (w : works) do ( (     var left : int ; left := 0 ;
     var right : int ; right := max + 1 ;
    while (right - left > 1) do (     var m : int ; m := (left + right) / 2 ;
     if (dp[m+1] < w.left) then (     left := m ) else (     right := m ) ) ; 
    dp[left + 1+1] := Set{dp[left + 1+1], w.right}->min() ; 
    max := Set{max, left + 1}->max() ; 
 )  ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static class Work implements Comparable<Work> {
   attribute left : int;
   attribute right : int;
   static operation newWork( left : int, right : int) : Work
  pre: true
  post: true
  activity:
  ( var self : Work ;
    self := createWork();
    self.initialise(left, right);
    return self );
  operation initialise( left : int, right : int) : void
  pre: true  post: true
  activity: (     self.left := left ; 
     self.right := right );
   operation compareTo( another : Work) : int
  pre: true
  post: true
  activity: (     return right - another.right );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Scanner ;
class Activity implements Comparable<Activity>{
  int s ;
  int t ;
  Activity(int s,int t){
    this.s=s ;
    this.t=t ;
  }
  public int compareTo(Activity act){
    return t-act.t ;
  }
}
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    PriorityQueue<Activity>que=new PriorityQueue<>();
    for(int i=0 ; i<n ; i++){
      int s=sc.nextInt();
      int t=sc.nextInt();
      que.add(new Activity(s,t));
    }
    int res=0 ;
    int time=0 ;
    while(! que.isEmpty()){
      Activity act=que.poll();
      if(time>=act.s)continue ;
      res++;
      time=act.t ;
    }
    System.out.println(res);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Activity implements Comparable<Activity> {
   attribute s : int;
   attribute t : int;
   static operation newActivity( s : int, t : int) : Activity
  pre: true
  post: true
  activity:
  ( var self : Activity ;
    self := createActivity();
    self.initialise(s, t);
    return self );
  operation initialise( s : int, t : int) : void
  pre: true  post: true
  activity: (     self.s := s ; 
     self.t := t );
   operation compareTo( act : Activity) : int
  pre: true
  post: true
  activity: (     return t - act.t );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var que : Sequence(Activity) ; que := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     que := que->including(Activity.newActivity(s, t)) )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    var time : int ; time := 0 ;
    while (not(que->isEmpty())) do (     var act : Activity ; act := que->min() ;
     if (time >= act.s) then     continue else skip ; 
     res := res + 1 ; 
     time := act.t ) ; 
    OclFile["System.out"].println(res) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner s=new Scanner(System.in);
  static boolean black,white ;
  static char[][] map ;
  static int W,H ;
  public static void main(String[] args){
    int count ;
    while(true){
      W=s.nextInt();
      H=s.nextInt();
      if(W==0 && H==0)break ;
      int bCount=0,wCount=0 ;
      map=new char[H][W];
      for(int i=0 ; i<H ; i++){
        map[i]=s.next().toCharArray();
      }
      for(int i=0 ; i<H ; i++){
        for(int j=0 ; j<W ; j++){
          black=false ;
          white=false ;
          count=0 ;
          if(map[i][j]=='.')count=search(i,j);
          if(black && ! white)bCount+=count ;
          else if(! black && white)wCount+=count ;
        }
      }
      System.out.println(bCount+" "+wCount);
    }
  }
  static int search(int i,int j){
    int count=0 ;
    if(i<0 || i>=H || j<0 || j>=W)return 0 ;
    if(map[i][j]=='.'){
      map[i][j]='x' ;
      count++;
      count+=search(i+1,j)+search(i-1,j)+search(i,j+1)+search(i,j-1);
    }
    else if(map[i][j]=='B'){
      black=true ;
    }
    else if(map[i][j]=='W'){
      white=true ;
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute black : boolean;
  static   attribute map : Sequence(Sequence(String));
  static   attribute W : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var count : int ;
     while (true) do (     W := s.getCurrent()->toInteger() ; 
     H := s.getCurrent()->toInteger() ; 
    if (W = 0 & H = 0) then     break else skip ; 
    var bCount : int ; bCount := 0 ;
    var wCount : int ; wCount := 0 ;
    map := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ; 
        var i : int ; i := 0 ; while i < H do ( (     map[i+1] := s.getCurrent()->characters() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     black := false ; 
     white := false ; 
    count := 0 ; 
    if (map[i+1][j+1] = '.') then     count := search(i, j) ; else skip ; 
    if (black & not(white)) then     bCount := bCount+(count) else     if (not(black) & white) then     wCount := wCount+(count) ; else skip ; ;  
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(bCount + " " + wCount) ; 
 ) );
  static   operation search( i : int, j : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     if (i < 0 or i >= H or j < 0 or j >= W) then     return 0 else skip ; 
     if (map[i+1][j+1] = '.') then (     map[i+1][j+1] := 'x' ; 
     count := count + 1 ; 
     count := count+(search(i + 1, j) + search(i - 1, j) + search(i, j + 1) + search(i, j - 1)) ) else     if (map[i+1][j+1] = 'B') then (     black := true ) else     if (map[i+1][j+1] = 'W') then (     white := true ) else skip ; ;  ;  
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] tmpArray=br.readLine().split(" ");
    int n=Integer.parseInt(tmpArray[0]);
    Activity[] acts=new Activity[n];
    for(int i=0 ; i<n ; i++){
      tmpArray=br.readLine().split(" ");
      int start=Integer.parseInt(tmpArray[0]);
      int end=Integer.parseInt(tmpArray[1]);
      acts[i]=new Activity(start,end);
    }
    Arrays.sort(acts);
    int count=1 ;
    int currentTime=acts[0] .end ;
    for(int i=1 ; i<n ; i++){
      if(currentTime<acts[i] .start){
        count++;
        currentTime=acts[i] .end ;
      }
    }
    System.out.println(count);
  }
}
class Activity implements Comparable<Activity>{
  int start ;
  int end ;
  public Activity(int s,int e){
    this.start=s ;
    this.end=e ;
  }
  @ Override public int compareTo(Activity a1){
    return this.end-a1.end ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
    var n : int ; n := (tmpArray[0+1])->toInteger() ;
    var acts : Sequence(Activity) ; acts := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     tmpArray := br.readLine()->split(" ") ; 
     var start : int ; start := (tmpArray[0+1])->toInteger() ;
     var end : int ; end := (tmpArray[1+1])->toInteger() ;
     acts[i+1] := Activity.newActivity(start, end) )  ;     i := i + 1 ) ; 
    acts := acts->sort() ; 
    var count : int ; count := 1 ;
    var currentTime : int ; currentTime := acts[0+1].end ;
        var i : int ; i := 1 ; while i < n do ( (     if (currentTime < acts[i+1].start) then (     count := count + 1 ; 
     currentTime := acts[i+1].end ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}
class Activity implements Comparable<Activity> {
   attribute start : int;
   attribute end : int;
   static operation newActivity( s : int, e : int) : Activity
  pre: true
  post: true
  activity:
  ( var self : Activity ;
    self := createActivity();
    self.initialise(s, e);
    return self );
  operation initialise( s : int, e : int) : void
  pre: true  post: true
  activity: (     self.start := s ; 
     self.end := e );
      operation compareTo( a1 : Activity) : int
  pre: true
  post: true
  activity: (     return self.end - a1.end );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<Time>L=new ArrayList<>();
    int cnt=0,tt=0 ;
    for(int i=0 ; i<n ; i++){
      int s=sc.nextInt();
      int t=sc.nextInt();
      Time time=new Time();
      time.element(s,t);
      L.add(time);
    }
    Collections.sort(L,new Comparator<Time>(){
      @ Override public int compare(Time o1,Time o2){
        return o1.end<o2.end ?-1 : 1 ;
      }
    }
);
    for(Time time : L){
      if(time.start>tt){
        tt=time.end ;
        cnt++;
      }
    }
    System.out.println(cnt);
  }
  public static class Time {
    int start,end ;
    public void element(int start,int end){
      this.start=start ;
      this.end=end ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var L : Sequence(Time) ; L := Sequence{} ;
    var cnt : int ; cnt := 0 ;
    var tt : int ; tt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var time : Time ; time := Time.newTime() ;
    time.element(s, t) ; 
    L := L->including(time) ; 
 )  ;     i := i + 1 ) ; 
    L, OclComparator<Time>.newOclComparator() := L, OclComparator<Time>.newOclComparator()->sort() ; 
    for (time : L) do ( (     if (time.start > tt) then (     tt := time.end ; 
     cnt := cnt + 1 ) else skip )  ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
  static class Time {
   attribute start : int;
   operation element( start : int, end : int) : void
  pre: true
  post: true
  activity: (     self.start := start ; 
     self.end := end );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int min_moves(int n){
    int ans=Integer.MAX_VALUE ;
    for(int i=1 ; i*i<=n ; i++){
      if(n % i==0){
        ans=Math.min(ans,i+n/i-2);
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(min_moves(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation min_moves( n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 2147483647 ;
         var i : int ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     ans := Set{ans, i + n / i - 2}->min() ) else skip )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(min_moves(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Ex3 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=1 ;
    for(int oo=0 ; oo<t ; oo++){
      int n=in.nextInt();
      int arr[][]=new int[n][n];
      for(int i=0 ; i<n ; i++){
        arr[0][i]=1 ;
        arr[i][0]=1 ;
      }
      for(int i=1 ; i<n ; i++){
        for(int j=1 ; j<n ; j++){
          arr[i][j]=arr[i-1][j]+arr[i][j-1];
        }
      }
      int max=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          max=Math.max(max,arr[i][j]);
        }
      }
      System.out.println(max);
    }
  }
  public class ListNode<E>{
    private E value ;
    private ListNode next ;
    public ListNode(E newVal,ListNode<E>newNext){
      value=newVal ;
      next=newNext ;
    }
    public E getValue(){
      return value ;
    }
    public ListNode<E>getNext(){
      return next ;
    }
    public void setValue(E newValue){
      value=newValue ;
    }
    public void setNext(ListNode<E>newNext){
      next=newNext ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ex3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
         var oo : int ; oo := 0 ; while oo < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[0+1][i+1] := 1 ; 
     arr[i+1][0+1] := 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 1 ; while j < n do ( (     arr[i+1][j+1] := arr[i - 1+1][j+1] + arr[i+1][j - 1+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     max := Set{max, arr[i+1][j+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 )  ;     oo := oo + 1 ) );
 class ListNode<E> {
   attribute value : E;
   attribute next : ListNode;
   static operation newListNode( newVal : E, newNext : ListNode<E>) : ListNode
  pre: true
  post: true
  activity:
  ( var self : ListNode ;
    self := createListNode();
    self.initialise(newVal, newNext);
    return self );
  operation initialise( newVal : E, newNext : ListNode<E>) : void
  pre: true  post: true
  activity: (     value := newVal ; 
     next := newNext );
   operation getValue() : E
  pre: true
  post: true
  activity: (     return value );
   operation getNext() : ListNode<E>
  pre: true
  post: true
  activity: (     return next );
   operation setValue( newValue : E) : void
  pre: true
  post: true
  activity: (     value := newValue );
   operation setNext( newNext : ListNode<E>) : void
  pre: true
  post: true
  activity: (     next := newNext );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String encryptString(String str,int n){
    int i=0,cnt=0 ;
    String encryptedStr="" ;
    while(i<n){
      cnt=i+1 ;
      while(cnt-->0)encryptedStr+=str.charAt(i);
      i++;
    }
    return encryptedStr ;
  }
  public static void main(String[] args){
    String str="geeks" ;
    int n=str.length();
    System.out.println(encryptString(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation encryptString( str : String, n : int) : String
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var cnt : int ; cnt := 0 ;
     var encryptedStr : String ; encryptedStr := "" ;
     while (i < n) do (     cnt := i + 1 ; 
         while (cnt > 0) do (        cnt := cnt - 1 ;     skip ;     encryptedStr := encryptedStr+(str->at(i+1)) ; ;  ) ;  
     i := i + 1 ) ; 
     return encryptedStr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeks" ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].println(encryptString(str, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test162 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int x=in.nextInt();
    int n[][]=new int[x][x];
    for(int i=0 ; i<x ; i++){
      for(int j=0 ; j<x ; j++){
        if(i==0 || j==0){
          n[i][j]=1 ;
        }
        else {
          n[i][j]=n[i-1][j]+n[i][j-1];
        }
      }
    }
    System.out.println(n[x-1][x-1]);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test162 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := in.getCurrent()->toInteger() ;
    var n : Sequence(Sequence(int)) ; n := Integer.subrange(1,x)->collect(Integer.subrange(1,x)->collect(0)) ;
        var i : int ; i := 0 ; while i < x do ( (         var j : int ; j := 0 ; while j < x do ( (     if (i = 0 or j = 0) then (     n[i+1][j+1] := 1 ) else (     n[i+1][j+1] := n[i - 1+1][j+1] + n[i+1][j - 1+1] ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n[x - 1+1][x - 1+1]) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _509A_MaximuminTable {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    int[][] matrix=new int[test][test];
    for(int i=1 ; i<=test ; i++){
      for(int k=1 ; k<=test ; k++){
        if(i==1){
          matrix[i-1][k-1]=1 ;
        }
        else if(k==1){
          matrix[i-1][k-1]=1 ;
        }
        else {
          matrix[i-1][k-1]=matrix[i-2][k-1]+matrix[i-1][k-2];
        }
      }
    }
    System.out.println(matrix[test-1][test-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _509A_MaximuminTable {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
    var matrix : Sequence(Sequence(int)) ; matrix := Integer.subrange(1,test)->collect(Integer.subrange(1,test)->collect(0)) ;
        var i : int ; i := 1 ; while i <= test do ( (         var k : int ; k := 1 ; while k <= test do ( (     if (i = 1) then (     matrix[i - 1+1][k - 1+1] := 1 ) else     if (k = 1) then (     matrix[i - 1+1][k - 1+1] := 1 ) else (     matrix[i - 1+1][k - 1+1] := matrix[i - 2+1][k - 1+1] + matrix[i - 1+1][k - 2+1] ) ;  )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(matrix[test - 1+1][test - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Scanner ;
public class MaximumTable {
  LinkedList<Integer>list=new LinkedList<>();
  public void inputInList(int number){
    for(int i=1 ; i<=number ; i++){
      list.add(i);
    }
    for(int k=1 ; k<number-1 ; k++){
      int count=0 ;
      while(true){
        count++;
        list.set(count,list.get(count)+list.get(count-1));
        if(count==list.size()-1){
          break ;
        }
      }
    }
    System.out.println(list.get(list.size()-1));
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    MaximumTable instance=new MaximumTable();
    int number=input.nextInt();
    instance.inputInList(number);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MaximumTable {
   attribute list : Sequence(int) := Sequence{};
   operation inputInList( number : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= number do ( (     list := list->including(i) )  ;     i := i + 1 ) ; 
         var k : int ; k := 1 ; while k < number - 1 do ( (     var count : int ; count := 0 ;
     while (true) do (     count := count + 1 ; 
     list := list.setAt(count+1,list->at(count+1) + list->at(count - 1+1)) ; 
     if (count = list->size() - 1) then (     break ) else skip ) )  ;     k := k + 1 ) ; 
     OclFile["System.out"].println(list->at(list->size() - 1+1)) );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var instance : MaximumTable ; instance := MaximumTable.newMaximumTable() ;
     var number : int ; number := input.getCurrent()->toInteger() ;
     instance.inputInList(number) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Ex3 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=1 ;
    for(int oo=0 ; oo<t ; oo++){
      int n=in.nextInt();
      int arr[][]=new int[n][n];
      for(int i=0 ; i<n ; i++){
        arr[0][i]=1 ;
        arr[i][0]=1 ;
      }
      int max=1 ;
      for(int i=1 ; i<n ; i++){
        for(int j=1 ; j<n ; j++){
          arr[i][j]=arr[i-1][j]+arr[i][j-1];
          max=Math.max(max,arr[i][j]);
        }
      }
      System.out.println(max);
    }
  }
  public class ListNode<E>{
    private E value ;
    private ListNode next ;
    public ListNode(E newVal,ListNode<E>newNext){
      value=newVal ;
      next=newNext ;
    }
    public E getValue(){
      return value ;
    }
    public ListNode<E>getNext(){
      return next ;
    }
    public void setValue(E newValue){
      value=newValue ;
    }
    public void setNext(ListNode<E>newNext){
      next=newNext ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ex3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
         var oo : int ; oo := 0 ; while oo < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[0+1][i+1] := 1 ; 
     arr[i+1][0+1] := 1 )  ;     i := i + 1 ) ; 
    var max : int ; max := 1 ;
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 1 ; while j < n do ( (     arr[i+1][j+1] := arr[i - 1+1][j+1] + arr[i+1][j - 1+1] ; 
     max := Set{max, arr[i+1][j+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 )  ;     oo := oo + 1 ) );
 class ListNode<E> {
   attribute value : E;
   attribute next : ListNode;
   static operation newListNode( newVal : E, newNext : ListNode<E>) : ListNode
  pre: true
  post: true
  activity:
  ( var self : ListNode ;
    self := createListNode();
    self.initialise(newVal, newNext);
    return self );
  operation initialise( newVal : E, newNext : ListNode<E>) : void
  pre: true  post: true
  activity: (     value := newVal ; 
     next := newNext );
   operation getValue() : E
  pre: true
  post: true
  activity: (     return value );
   operation getNext() : ListNode<E>
  pre: true
  post: true
  activity: (     return next );
   operation setValue( newValue : E) : void
  pre: true
  post: true
  activity: (     value := newValue );
   operation setNext( newNext : ListNode<E>) : void
  pre: true
  post: true
  activity: (     next := newNext );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        int n=sc.nextInt();
        String s=sc.next();
        int odd=0 ;
        for(int i=0 ; i<n ; i++){
          if(s.charAt(i)% 2!=0)odd++;
        }
        if(odd<=1)System.out.println(-1);
        else {
          int cnt=0 ;
          for(int i=0 ; i<n ; i++){
            if(s.charAt(i)% 2!=0){
              System.out.print(s.charAt(i));
              cnt++;
            }
            if(cnt==2)break ;
          }
          System.out.println();
        }
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
    var odd : int ; odd := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) mod 2 /= 0) then     odd := odd + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (odd <= 1) then     OclFile["System.out"].println(-1) else (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) mod 2 /= 0) then (     OclFile["System.out"].print(s->at(i+1)) ; 
     cnt := cnt + 1 ) else skip ; 
     if (cnt = 2) then     break else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ;  
 ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class abc {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    while(n-->0){
      int k=in.nextInt();
      String s=in.next();
      String t="" ;
      int a=0 ;
      for(int i=0 ; i<k ; i++){
        if(a==2)break ;
        if((s.charAt(i)-'0')% 2==1){
          a++;
          t+=s.charAt(i);
        }
      }
      if(a==2){
        System.out.println(t);
      }
      else {
        System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class abc {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var k : int ; k := in.getCurrent()->toInteger() ;
     var s : String ; s := in.getCurrent() ;
    var t : String ; t := "" ;
    var a : int ; a := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     if (a = 2) then     break else skip ; 
     if ((s->at(i+1) - ('0')->char2byte()) mod 2 = 1) then (     a := a + 1 ; 
     t := t+(s->at(i+1)) ) else skip )  ;     i := i + 1 ) ; 
    if (a = 2) then (     OclFile["System.out"].println(t) ) else (     OclFile["System.out"].println(-1) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class EvenButNotEven {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    while(test-->0){
      int n=sc.nextInt();
      String s=sc.next();
      StringBuilder sb=new StringBuilder();
      int count=0 ;
      for(char ch : s.toCharArray()){
        int number=(ch-'0');
        if(number % 2==1){
          if(count<2){
            sb.append(ch);
            count++;
          }
        }
      }
      if(count<=1){
        System.out.println("-1");
      }
      else {
        System.out.println(sb.toString());
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class EvenButNotEven {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
    var sb : String ; sb := StringLib.newString() ;
    var count : int ; count := 0 ;
    for (ch : s->characters()) do ( (     var number : int ; number := (ch - ('0')->char2byte()) ;
     if (number mod 2 = 1) then (     if (count < 2) then (     sb := sb + StringLib.newString(ch) ; 
     count := count + 1 ) else skip ) else skip )  ) ; 
    if (count <= 1) then (     OclFile["System.out"].println("-1") ) else (     OclFile["System.out"].println(sb+"") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  static int maxLengthSubArray(int arr[],int n){
    int maxLen=-1 ;
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        int lcm=1*arr[i];
        int product=1*arr[i];
        for(int k=i+1 ; k<=j ; k++){
          lcm=(((arr[k]*lcm))/(gcd(arr[k],lcm)));
          product=product*arr[k];
        }
        if(lcm==product){
          maxLen=Math.max(maxLen,j-i+1);
        }
      }
    }
    return maxLen ;
  }
  public static void main(String args[]){
    int arr[]={
      6,10,21 };
      int n=arr.length ;
      System.out.println(maxLengthSubArray(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation maxLengthSubArray( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var maxLen : int ; maxLen := -1 ;
         var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var lcm : int ; lcm := 1 * arr[i+1] ;
     var product : int ; product := 1 * arr[i+1] ;
         var k : int ; k := i + 1 ; while k <= j do ( (     lcm := (((arr[k+1] * lcm)) / (gcd(arr[k+1], lcm))) ; 
     product := product * arr[k+1] )  ;     k := k + 1 ) ; 
     if (lcm = product) then (     maxLen := Set{maxLen, j - i + 1}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return maxLen );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,10,21} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxLengthSubArray(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPrime(int n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static boolean isStrongPrime(int n){
    if(! isPrime(n)|| n==2)return false ;
    int previous_prime=n-1 ;
    int next_prime=n+1 ;
    while(! isPrime(next_prime))next_prime++;
    while(! isPrime(previous_prime))previous_prime--;
    int mean=(previous_prime+next_prime)/2 ;
    if(n>mean)return true ;
    else return false ;
  }
  public static void main(String args[]){
    int n=11 ;
    if(isStrongPrime(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation isStrongPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (not(isPrime(n)) or n = 2) then     return false else skip ; 
     var previous_prime : int ; previous_prime := n - 1 ;
    var next_prime : int ; next_prime := n + 1 ;
    while (not(isPrime(next_prime))) do     next_prime := next_prime + 1 ; ; 
    while (not(isPrime(previous_prime))) do     previous_prime := previous_prime - 1 ; ; 
    var mean : int ; mean := (previous_prime + next_prime) / 2 ;
    if (n > mean) then     return true else     return false ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 11 ;
     if (isStrongPrime(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
import java.io.*;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int tests=Integer.parseInt(br.readLine());
    while(tests-->0){
      String[] firstLine=br.readLine().split(" ");
      int n=Integer.valueOf(firstLine[0]);
      int[] damages=new int[n];
      int i=0 ;
      for(String dmg : br.readLine().split(" ")){
        damages[i]=Integer.valueOf(dmg);
        i++;
      }
      Arrays.sort(damages);
      int d1=damages[n-1];
      int d2=damages[n-2];
      int hp=Integer.valueOf(firstLine[1]);
      if(d1>=hp){
        System.out.println(1);
      }
      else {
        int td=d1+d2 ;
        if(td>=hp){
          System.out.println(2);
        }
        else {
          int r=hp % td ;
          int acc=r==0 ? 0 : r<=d1 ? 1 : 2 ;
          int ans=acc+2*(hp/td);
          System.out.println(ans);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tests : int ; tests := (br.readLine())->toInteger() ;
         while (tests > 0) do (        tests := tests - 1 ;     skip ; (     var firstLine : Sequence(String) ; firstLine := br.readLine()->split(" ") ;
     var n : int ; n := (firstLine[0+1])->toInteger() ;
    var damages : Sequence(int) ; damages := Integer.subrange(1,n)->collect(0) ;
    var i : int ; i := 0 ;
    for (dmg : br.readLine()->split(" ")) do ( (     damages[i+1] := (dmg)->toInteger() ; 
     i := i + 1 )  ) ; 
    damages := damages->sort() ; 
    var d1 : int ; d1 := damages[n - 1+1] ;
    var d2 : int ; d2 := damages[n - 2+1] ;
    var hp : int ; hp := (firstLine[1+1])->toInteger() ;
    if (d1 >= hp) then (     OclFile["System.out"].println(1) ) else (     var td : int ; td := d1 + d2 ;
     if (td >= hp) then (     OclFile["System.out"].println(2) ) else (     var r : int ; r := hp mod td ;
     var acc : int ; acc := if r = 0 then 0 else if r <= d1 then 1 else 2 endif endif ;
     var ans : int ; ans := acc + 2 * (hp / td) ;
     OclFile["System.out"].println(ans) ) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxSumBitonicSubArr(int arr[],int n){
    int[] msis=new int[n];
    int[] msds=new int[n];
    int max_sum=Integer.MIN_VALUE ;
    msis[0]=arr[0];
    for(int i=1 ; i<n ; i++)if(arr[i]>arr[i-1])msis[i]=msis[i-1]+arr[i];
    else msis[i]=arr[i];
    msds[n-1]=arr[n-1];
    for(int i=n-2 ; i>=0 ; i--)if(arr[i]>arr[i+1])msds[i]=msds[i+1]+arr[i];
    else msds[i]=arr[i];
    for(int i=0 ; i<n ; i++)if(max_sum<(msis[i]+msds[i]-arr[i]))max_sum=msis[i]+msds[i]-arr[i];
    return max_sum ;
  }
  public static void main(String[] args){
    int arr[]={
      5,3,9,2,7,6,4 };
      int n=arr.length ;
      System.out.println("Maximum Sum="+maxSumBitonicSubArr(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxSumBitonicSubArr( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var msis : Sequence(int) ; msis := Integer.subrange(1,n)->collect(0) ;
     var msds : Sequence(int) ; msds := Integer.subrange(1,n)->collect(0) ;
    var max_sum : int ; max_sum := -2147483648 ;
    msis[0+1] := arr[0+1] ; 
        var i : int ; i := 1 ; while i < n do (     if (arr[i+1] > arr[i - 1+1]) then     msis[i+1] := msis[i - 1+1] + arr[i+1] else     msis[i+1] := arr[i+1] ; ;   ;     i := i + 1 ) ; 
    msds[n - 1+1] := arr[n - 1+1] ; 
        var i : int ; i := n - 2 ; while i >= 0 do (     if (arr[i+1] > arr[i + 1+1]) then     msds[i+1] := msds[i + 1+1] + arr[i+1] else     msds[i+1] := arr[i+1] ; ;   ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     if (max_sum < (msis[i+1] + msds[i+1] - arr[i+1])) then     max_sum := msis[i+1] + msds[i+1] - arr[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    return max_sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,3,9,2,7,6,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Maximum Sum=" + maxSumBitonicSubArr(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args)throws java.lang.Exception {
    FastReader sc=new FastReader();
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int h=sc.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      Arrays.sort(a);
      int sum=a[n-1]+a[n-2];
      int x=(h/sum)*2 ;
      h=h % sum ;
      x+=(h==0)? 0 : h<=a[n-1] ? 1 : 2 ;
      System.out.println(x);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var t : int ; t := sc.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.nextInt() ;
     var h : int ; h := sc.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var sum : int ; sum := a[n - 1+1] + a[n - 2+1] ;
    var x : int ; x := (h / sum) * 2 ;
    h := h mod sum ; 
    x := x+(if (h = 0) then 0 else if h <= a[n - 1+1] then 1 else 2 endif endif) ; 
    OclFile["System.out"].println(x) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class A_Little_Elephant_and_Bits {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args)throws java.lang.Exception {
    FastReader scn=new FastReader();
    String str=scn.next();
    int count=0 ;
    char[] ch=str.toCharArray();
    for(int i=0 ; i<ch.length ; i++){
      if(ch[i]=='0'){
        count=i ;
        break ;
      }
    }
    if(count==0){
      System.out.println(str.substring(0,ch.length-1));
      return ;
    }
    System.out.println(str.substring(0,count)+""+str.substring(count+1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Little_Elephant_and_Bits {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : FastReader ; scn := FastReader.newFastReader() ;
     var str : String ; str := scn.next() ;
    var count : int ; count := 0 ;
    var ch : Sequence(String) ; ch := str->characters() ;
        var i : int ; i := 0 ; while i < ch->size() do ( (     if (ch[i+1] = '0') then (     count := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (count = 0) then (     OclFile["System.out"].println(str.subrange(0+1,ch->size() - 1)) ; 
     return ) else skip ; 
    OclFile["System.out"].println(str.subrange(0+1,count) + "" + str.subrange(count + 1+1,count + 1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import javax.lang.model.util.ElementScanner6 ;
public class ques1 {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    String s=scn.next();
    String ans="" ;
    boolean ansFound=false ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='0'){
        ans=s.substring(0,i)+s.substring(i+1);
        ansFound=true ;
        break ;
      }
    }
    if(! ansFound){
      ans=s.substring(1);
    }
    System.out.println(ans);
  }
  public static boolean isPrime(int n){
    boolean ans=true ;
    for(int i=2 ; i*i<=n ; i++){
      if(n % i==0){
        ans=false ;
        break ;
      }
    }
    if(ans==true)return true ;
    else return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ques1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scn.getCurrent() ;
    var ans : String ; ans := "" ;
    var ansFound : boolean ; ansFound := false ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '0') then (     ans := s.subrange(0+1,i) + s.subrange(i + 1+1,i + 1) ; 
     ansFound := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (not(ansFound)) then (     ans := s.subrange(1+1,1) ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     var ans : boolean ; ans := true ;
         var i : int ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     ans := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (ans = true) then     return true else     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication1 {
  static int ans=Integer.MIN_VALUE ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String str=in.next();
    StringBuilder sb=new StringBuilder();
    boolean check=false ;
    for(int i=0 ; i<str.length(); i++){
      char ch=str.charAt(i);
      if(ch=='0'){
        if(i<str.length()-1)sb.append(str.substring(i+1,str.length()));
        check=true ;
        break ;
      }
      else {
        sb.append(ch);
      }
    }
    System.out.println(check ? sb.toString(): sb.deleteCharAt(0).toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication1 {
  static   attribute ans : int := -2147483648;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := in.getCurrent() ;
    var sb : String ; sb := StringLib.newString() ;
    var check : boolean ; check := false ;
        var i : int ; i := 0 ; while i < str->size() do ( (     var ch : String ; ch := str->at(i+1) ;
     if (ch = '0') then (     if (i < str->size() - 1) then     sb := sb + StringLib.newString(str.subrange(i + 1+1,str->size())) ; else skip ; 
     check := true ; 
     break ) else (     sb := sb + StringLib.newString(ch) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if check then sb+"" else sb->excludingAt(0+1)+"" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class vfe {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      if(360 %(180-n)==0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class vfe {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (360 mod (180 - n) = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class the_child_and_set {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    String s=in.nextLine();
    int c=0 ;
    long ans=1 ;
    for(int i=0 ; i<s.length()-1 ; i++){
      if((s.charAt(i)-'0')+(s.charAt(i+1)-'0')==9){
        c++;
      }
      else {
        if(c % 2==0){
          ans*=(c/2+1);
        }
        c=0 ;
      }
    }
    if(c % 2==0)ans*=(c/2)+1 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class the_child_and_set {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.nextLine() ;
    var c : int ; c := 0 ;
    var ans : long ; ans := 1 ;
        var i : int ; i := 0 ; while i < s->size() - 1 do ( (     if ((s->at(i+1) - ('0')->char2byte()) + (s->at(i + 1+1) - ('0')->char2byte()) = 9) then (     c := c + 1 ) else (     if (c mod 2 = 0) then (     ans := ans*((c / 2 + 1)) ) else skip ; 
     c := 0 ) )  ;     i := i + 1 ) ; 
    if (c mod 2 = 0) then     ans := ans*((c / 2) + 1) ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class pre88 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    char str[]=obj.next().toCharArray();
    if(str.length==1){
      System.out.println(1);
      return ;
    }
    long max=1,count=1 ;
    for(int i=0 ; i<str.length-1 ; i++){
      if(str[i]+str[i+1]-2*'0'!=9){
        if(count!=1 && count % 2==1)max*=(count+1)/2 ;
        count=1 ;
      }
      else count++;
    }
    if(count!=1 && count % 2==1)max*=(count+1)/2 ;
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre88 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var str : Sequence(String) ; str := obj.next()->characters() ;
    if (str->size() = 1) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    var max : long ; max := 1 ;
    var count : long ; count := 1 ;
        var i : int ; i := 0 ; while i < str->size() - 1 do ( (     if (str[i+1] + str[i + 1+1] - 2 * '0' /= 9) then (     if (count /= 1 & count mod 2 = 1) then     max := max*((count + 1) / 2) ; else skip ; 
     count := 1 ) else     count := count + 1 ; )  ;     i := i + 1 ) ; 
    if (count /= 1 & count mod 2 = 1) then     max := max*((count + 1) / 2) ; else skip ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B374 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char[] S=(in.next()+'i').toCharArray();
    int length=1 ;
    int last=S[0]-'0' ;
    long answer=1 ;
    for(int i=1 ; i<S.length ; i++){
      int current=S[i]-'0' ;
      if(current+last==9){
        length++;
      }
      else {
        if(length % 2==1){
          answer*=(length+1)/2 ;
        }
        length=1 ;
      }
      last=current ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B374 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : Sequence(String) ; S := (in.getCurrent() + 'i')->characters() ;
    var length : int ; length := 1 ;
    var last : int ; last := S[0+1] - ('0')->char2byte() ;
    var answer : long ; answer := 1 ;
        var i : int ; i := 1 ; while i < S->size() do ( (     var current : int ; current := S[i+1] - ('0')->char2byte() ;
     if (current + last = 9) then (     length := length + 1 ) else (     if (length mod 2 = 1) then (     answer := answer*((length + 1) / 2) ) else skip ; 
     length := 1 ) ;  
     last := current )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p162 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p162().run());
  }
  public String run(){
    BigInteger sum=BigInteger.ZERO ;
    for(int n=1 ; n<=16 ; n++){
      sum=sum.add(bi(15).multiply(bi(16).pow(n-1))).subtract(bi(43).multiply(bi(15).pow(n-1))).add(bi(41).multiply(bi(14).pow(n-1))).subtract(bi(13).pow(n));
    }
    return sum.toString(16).toUpperCase();
  }
  private static BigInteger bi(int n){
    return BigInteger.valueOf(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p162 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p162.newp162().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var n : int ; n := 1 ; while n <= 16 do ( (     sum := sum->excludes(bi(15).multiply(bi(16).pow(n - 1))).subtract(bi(43).multiply(bi(15).pow(n - 1)))->excludes(bi(41).multiply(bi(14).pow(n - 1))).subtract(bi(13).pow(n)) )  ;     n := n + 1 ) ; 
     return sum.toString(16)->toUpperCase() );
  static   operation bi( n : int) : long
  pre: true
  post: true
  activity: (     return (n + "")->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class D {
  static int[][] T ;
  static long[][][] DP ;
  public static long get(int n,int from,int to){
    if(n==0 || from==to)return 0 ;
    if(DP[n][from][to]!=-1)return DP[n][from][to];
    int third=3-from-to ;
    return DP[n][from][to]=Math.min(get(n-1,from,third)+T[from][to]+get(n-1,third,to),get(n-1,from,to)+T[from][third]+get(n-1,to,from)+T[third][to]+get(n-1,from,to));
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    T=new int[3][3];
    for(int i=0 ; i<3 ; i++)for(int j=0 ; j<3 ; j++)T[i][j]=in.nextInt();
    int n=in.nextInt();
    DP=new long[n+1][3][3];
    for(int i=0 ; i<=n ; i++)for(int j=0 ; j<3 ; j++)Arrays.fill(DP[i][j],-1);
    System.out.println(get(n,0,2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   attribute T : Sequence(Sequence(int));
  static   attribute DP : Sequence(Sequence(Sequence(long)));
  static   operation get( n : int, from : int, to : int) : long
  pre: true
  post: true
  activity: (     if (n = 0 or from = to) then     return 0 else skip ; 
     if (DP[n+1][from+1][to+1] /= -1) then     return DP[n+1][from+1][to+1] else skip ; 
     var third : int ; third := 3 - from - to ;
     return DP[n+1][from+1][to+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     T := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ; 
        var i : int ; i := 0 ; while i < 3 do (         var j : int ; j := 0 ; while j < 3 do (     T[i+1][j+1] := in.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var n : int ; n := in.getCurrent()->toInteger() ;
    DP := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0))) ; 
        var i : int ; i := 0 ; while i <= n do (         var j : int ; j := 0 ; while j < 3 do (     DP[i+1][j+1] := DP[i+1][j+1]->collect(-1) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(at(n, 0, 2+1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class T1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String x=sc.next();
    String y=sc.next();
    StringBuilder sb=new StringBuilder();
    for(int k=0 ; k<x.length(); k++){
      char xch=x.charAt(k);
      char ych=y.charAt(k);
      if(xch<ych){
        break ;
      }
      if(xch==ych){
        if(xch=='z'){
          sb.append(xch);
        }
        else {
          sb.append(((char)(xch+1)));
        }
      }
      else {
        sb.append(ych);
      }
    }
    if(sb.length()==x.length()){
      System.out.println(sb.toString());
    }
    else {
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class T1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : String ; x := sc.getCurrent() ;
    var y : String ; y := sc.getCurrent() ;
    var sb : String ; sb := StringLib.newString() ;
        var k : int ; k := 0 ; while k < x->size() do ( (     var xch : String ; xch := x->at(k+1) ;
     var ych : String ; ych := y->at(k+1) ;
     if (xch < ych) then (     break ) else skip ; 
     if (xch = ych) then (     if (xch = 'z') then (     sb := sb + StringLib.newString(xch) ) else (     sb := sb + StringLib.newString(((xch + 1)->oclAsType(String))) ) ) else (     sb := sb + StringLib.newString(ych) ) )  ;     k := k + 1 ) ; 
    if (sb->size() = x->size()) then (     OclFile["System.out"].println(sb+"") ) else (     OclFile["System.out"].println(-1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int findLen(String A,int n,int k,char ch){
    int maxlen=1 ;
    int cnt=0 ;
    int l=0,r=0 ;
    while(r<n){
      if(A.charAt(r)!=ch)++cnt ;
      while(cnt>k){
        if(A.charAt(l)!=ch)--cnt ;
++l ;
      }
      maxlen=Math.max(maxlen,r-l+1);
++r ;
    }
    return maxlen ;
  }
  static int answer(String A,int n,int k){
    int maxlen=1 ;
    for(int i=0 ; i<26 ; ++i){
      maxlen=Math.max(maxlen,findLen(A,n,k,(char)(i+'A')));
      maxlen=Math.max(maxlen,findLen(A,n,k,(char)(i+'a')));
    }
    return maxlen ;
  }
  public static void main(String[] args){
    int n=5,k=2 ;
    String A="ABABA" ;
    System.out.println("Maximum length="+answer(A,n,k));
    n=6 ;
    k=4 ;
    String B="HHHHHH" ;
    System.out.println("Maximum length="+answer(B,n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findLen( A : String, n : int, k : int, ch : String) : int
  pre: true
  post: true
  activity: (     var maxlen : int ; maxlen := 1 ;
     var cnt : int ; cnt := 0 ;
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    while (r < n) do (     if (A->at(r+1) /= ch) then     cnt := cnt + 1 ; else skip ; 
     while (cnt > k) do (     if (A->at(l+1) /= ch) then     cnt := cnt - 1 ; else skip ; 
     l := l + 1 ) ; 
     maxlen := Set{maxlen, r - l + 1}->max() ; 
     r := r + 1 ) ; 
    return maxlen 
 );
  static   operation answer( A : String, n : int, k : int) : int
  pre: true
  post: true
  activity: (     var maxlen : int ; maxlen := 1 ;
         var i : int ; i := 0 ; while i < 26 do ( (     maxlen := Set{maxlen, findLen(A, n, k, (i + 'A')->oclAsType(String))}->max() ; 
     maxlen := Set{maxlen, findLen(A, n, k, (i + 'a')->oclAsType(String))}->max() )  ;     i := i + 1 ) ; 
     return maxlen );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var k : int ; k := 2 ;
     var A : String ; A := "ABABA" ;
    OclFile["System.out"].println("Maximum length=" + answer(A, n, k)) ; 
    n := 6 ; 
    k := 4 ; 
    var B : String ; B := "HHHHHH" ;
    OclFile["System.out"].println("Maximum length=" + answer(B, n, k)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      scanner.nextLine();
      int countLunch=0,countDinner=0,countMidnight=0 ;
      int countOkLunch=0,countOkDinner=0,countOkMidnight=0 ;
      for(int i=0 ; i<n ; i++){
        String s=scanner.nextLine();
        int h=Integer.parseInt(s.substring(0,2));
        int m=Integer.parseInt(s.substring(3,5));
        int m1=Integer.parseInt(s.substring(6,8));
        if(m1<m){
          m1+=60 ;
        }
        boolean checkShorter=m1-m<=8 ;
        if(11<=h && h<15){
          countLunch++;
          if(checkShorter){
            countOkLunch++;
          }
        }
        else if(18<=h && h<21){
          countDinner++;
          if(checkShorter){
            countOkDinner++;
          }
        }
        else if(21<=h || h<2){
          countMidnight++;
          if(checkShorter){
            countOkMidnight++;
          }
        }
      }
      if(countLunch==0){
        System.out.println("lunch no guest");
      }
      else {
        System.out.println("lunch "+countOkLunch*100/countLunch);
      }
      if(countDinner==0){
        System.out.println("dinner no guest");
      }
      else {
        System.out.println("dinner "+countOkDinner*100/countDinner);
      }
      if(countMidnight==0){
        System.out.println("midnight no guest");
      }
      else {
        System.out.println("midnight "+countOkMidnight*100/countMidnight);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    skip ; 
    var countLunch : int ; countLunch := 0 ;
    var countDinner : int ; countDinner := 0 ;
    var countMidnight : int ; countMidnight := 0 ;
    var countOkLunch : int ; countOkLunch := 0 ;
    var countOkDinner : int ; countOkDinner := 0 ;
    var countOkMidnight : int ; countOkMidnight := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := scanner.nextLine() ;
     var h : int ; h := (s.subrange(0+1,2))->toInteger() ;
    var m : int ; m := (s.subrange(3+1,5))->toInteger() ;
    var m1 : int ; m1 := (s.subrange(6+1,8))->toInteger() ;
    if (m1 < m) then (     m1 := m1+(60) ) else skip ; 
    var checkShorter : boolean ; checkShorter := m1 - m <= 8 ;
    if (11 <= h & h < 15) then (     countLunch := countLunch + 1 ; 
     if (checkShorter) then (     countOkLunch := countOkLunch + 1 ) else skip ) else     if (18 <= h & h < 21) then (     countDinner := countDinner + 1 ; 
     if (checkShorter) then (     countOkDinner := countOkDinner + 1 ) else skip ) else     if (21 <= h or h < 2) then (     countMidnight := countMidnight + 1 ; 
     if (checkShorter) then (     countOkMidnight := countOkMidnight + 1 ) else skip ) else skip ; ;  ;  
 )  ;     i := i + 1 ) ; 
    if (countLunch = 0) then (     OclFile["System.out"].println("lunch no guest") ) else (     OclFile["System.out"].println("lunch " + countOkLunch * 100 / countLunch) ) ;  
    if (countDinner = 0) then (     OclFile["System.out"].println("dinner no guest") ) else (     OclFile["System.out"].println("dinner " + countOkDinner * 100 / countDinner) ) ;  
    if (countMidnight = 0) then (     OclFile["System.out"].println("midnight no guest") ) else (     OclFile["System.out"].println("midnight " + countOkMidnight * 100 / countMidnight) ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int t=in.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      int a=in.nextInt();
      if(360 %(180-a)==0){
        pw.println("YES");
      }
      else pw.println("NO");
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        var tt : int ; tt := 0 ; while tt < t do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     if (360 mod (180 - a) = 0) then (     skip ) else     skip ; )  ;     tt := tt + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.ListIterator ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    while(true){
      final int n=sc.nextInt();
      if(n==0){
        break ;
      }
      int[] arrived=new int[3];
      int[] accepted=new int[3];
      for(int i=0 ; i<n ; i++){
        String[] time_str=sc.next().split(":");
        int hour=Integer.parseInt(time_str[0]);
        int min=Integer.parseInt(time_str[1]);
        int min2=sc.nextInt();
        int type=-1 ;
        if(hour>=11 && hour<15){
          type=0 ;
        }
        else if(hour>=18 && hour<21){
          type=1 ;
        }
        else if((hour>=21 && hour<=24)||(hour>=0 && hour<2)){
          type=2 ;
        }
        if(type==-1){
          continue ;
        }
        arrived[type]++;
        if(min>min2){
          min2+=60 ;
        }
        if(min2-min<=8){
          accepted[type]++;
        }
      }
      String[] str={
        "lunch","dinner","midnight" };
        for(int i=0 ; i<3 ; i++){
          System.out.println(str[i]+" "+(arrived[i]==0 ? "no guest" :((accepted[i]*100)/arrived[i])+""));
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var arrived : Sequence(int) ; arrived := Integer.subrange(1,3)->collect(0) ;
    var accepted : Sequence(int) ; accepted := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var time_str : Sequence(String) ; time_str := sc.getCurrent()->split(":") ;
     var hour : int ; hour := (time_str[0+1])->toInteger() ;
    var min : int ; min := (time_str[1+1])->toInteger() ;
    var min2 : int ; min2 := sc.getCurrent()->toInteger() ;
    var type : int ; type := -1 ;
    if (hour >= 11 & hour < 15) then (     type := 0 ) else     if (hour >= 18 & hour < 21) then (     type := 1 ) else     if ((hour >= 21 & hour <= 24) or (hour >= 0 & hour < 2)) then (     type := 2 ) else skip ; ;  ;  
    if (type = -1) then (     continue ) else skip ; 
    arrived[type+1] := arrived[type+1] + 1 ; 
    if (min > min2) then (     min2 := min2+(60) ) else skip ; 
    if (min2 - min <= 8) then (     accepted[type+1] := accepted[type+1] + 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    var str : Sequence(String) ; str := Sequence{"lunch","dinner","midnight"} ;
        var i : int ; i := 0 ; while i < 3 do ( (     OclFile["System.out"].println(str[i+1] + " " + (if arrived[i+1] = 0 then "no guest" else ((accepted[i+1] * 100) / arrived[i+1]) + "" endif)) )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      int n=in.nextInt();
      if(n==0)return ;
      int L[]=new int[2];
      int D[]=new int[2];
      int M[]=new int[2];
      for(int i=0 ; i<n ; i++){
        String str[]=in.next().split(":");
        int h=Integer.valueOf(str[0]);
        int m1=Integer.valueOf(str[1]);
        int m2=in.nextInt();
        int cnt=0 ;
        if(11<=h && h<=14){
          L[0]++;
          while(m1!=m2){
            m1=(m1+1)% 60 ;
            cnt++;
          }
          if(cnt<9)L[1]++;
        }
        else if(18<=h && h<=20){
          D[0]++;
          while(m1!=m2){
            m1=(m1+1)% 60 ;
            cnt++;
          }
          if(cnt<9)D[1]++;
        }
        else if(21<=h || h<=1){
          M[0]++;
          while(m1!=m2){
            m1=(m1+1)% 60 ;
            cnt++;
          }
          if(cnt<9)M[1]++;
        }
      }
      if(L[0]>0)System.out.println("lunch "+100*L[1]/L[0]);
      else System.out.println("lunch no guest");
      if(D[0]>0)System.out.println("dinner "+100*D[1]/D[0]);
      else System.out.println("dinner no guest");
      if(M[0]>0)System.out.println("midnight "+100*M[1]/M[0]);
      else System.out.println("midnight no guest");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var L : Sequence(int) ; L := Integer.subrange(1,2)->collect(0) ;
    var D : Sequence(int) ; D := Integer.subrange(1,2)->collect(0) ;
    var M : Sequence(int) ; M := Integer.subrange(1,2)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var str : Sequence(String) ; str := in.getCurrent()->split(":") ;
     var h : int ; h := (str[0+1])->toInteger() ;
    var m1 : int ; m1 := (str[1+1])->toInteger() ;
    var m2 : int ; m2 := in.getCurrent()->toInteger() ;
    var cnt : int ; cnt := 0 ;
    if (11 <= h & h <= 14) then (     L[0+1] := L[0+1] + 1 ; 
     while (m1 /= m2) do (     m1 := (m1 + 1) mod 60 ; 
     cnt := cnt + 1 ) ; 
     if (cnt < 9) then     L[1+1] := L[1+1] + 1 ; else skip ) else     if (18 <= h & h <= 20) then (     D[0+1] := D[0+1] + 1 ; 
     while (m1 /= m2) do (     m1 := (m1 + 1) mod 60 ; 
     cnt := cnt + 1 ) ; 
     if (cnt < 9) then     D[1+1] := D[1+1] + 1 ; else skip ) else     if (21 <= h or h <= 1) then (     M[0+1] := M[0+1] + 1 ; 
     while (m1 /= m2) do (     m1 := (m1 + 1) mod 60 ; 
     cnt := cnt + 1 ) ; 
     if (cnt < 9) then     M[1+1] := M[1+1] + 1 ; else skip ) else skip ; ;  ;  
 )  ;     i := i + 1 ) ; 
    if (L[0+1] > 0) then     OclFile["System.out"].println("lunch " + 100 * L[1+1] / L[0+1]) else     OclFile["System.out"].println("lunch no guest") ; ;  
    if (D[0+1] > 0) then     OclFile["System.out"].println("dinner " + 100 * D[1+1] / D[0+1]) else     OclFile["System.out"].println("dinner no guest") ; ;  
    if (M[0+1] > 0) then     OclFile["System.out"].println("midnight " + 100 * M[1+1] / M[0+1]) else     OclFile["System.out"].println("midnight no guest") ; ;  
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int L=0 ;
      int Lc=0 ;
      int D=0 ;
      int Dc=0 ;
      int M=0 ;
      int Mc=0 ;
      String s ;
      int a,b,c ;
      for(int i=0 ; i<n ; i++){
        s=sc.next();
        a=Integer.valueOf(s.substring(0,2));
        b=Integer.valueOf(s.substring(3,5));
        c=sc.nextInt();
        if(11<=a && a<=14){
          L++;
          if(b>c)c+=60 ;
          if(c-b<=8)Lc++;
        }
        else if(18<=a && a<=20){
          D++;
          if(b>c)c+=60 ;
          if(c-b<=8)Dc++;
        }
        else if((21<=a && a<=24)|| a==0 || a==1){
          M++;
          if(b>c)c+=60 ;
          if(c-b<=8)Mc++;
        }
      }
      System.out.print("lunch ");
      if(L==0)System.out.println("no guest");
      else System.out.println((100*Lc)/L);
      System.out.print("dinner ");
      if(D==0)System.out.println("no guest");
      else System.out.println((100*Dc)/D);
      System.out.print("midnight ");
      if(M==0)System.out.println("no guest");
      else System.out.println((100*Mc)/M);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var L : int ; L := 0 ;
    var Lc : int ; Lc := 0 ;
    var D : int ; D := 0 ;
    var Dc : int ; Dc := 0 ;
    var M : int ; M := 0 ;
    var Mc : int ; Mc := 0 ;
    var s : String ;
    var a : int ;
    var b : int ;
    var c : int ;
        var i : int ; i := 0 ; while i < n do ( (     s := sc.getCurrent() ; 
     a := (s.subrange(0+1,2))->toInteger() ; 
    b := (s.subrange(3+1,5))->toInteger() ; 
    c := sc.getCurrent()->toInteger() ; 
    if (11 <= a & a <= 14) then (     L := L + 1 ; 
     if (b > c) then     c := c+(60) ; else skip ; 
     if ((c)->char2byte() - (b)->char2byte() <= 8) then     Lc := Lc + 1 ; else skip ) else     if (18 <= a & a <= 20) then (     D := D + 1 ; 
     if (b > c) then     c := c+(60) ; else skip ; 
     if ((c)->char2byte() - (b)->char2byte() <= 8) then     Dc := Dc + 1 ; else skip ) else     if ((21 <= a & a <= 24) or a = 0 or a = 1) then (     M := M + 1 ; 
     if (b > c) then     c := c+(60) ; else skip ; 
     if ((c)->char2byte() - (b)->char2byte() <= 8) then     Mc := Mc + 1 ; else skip ) else skip ; ;  ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("lunch ") ; 
    if (L = 0) then     OclFile["System.out"].println("no guest") else     OclFile["System.out"].println((100 * Lc) / L) ; ;  
    OclFile["System.out"].print("dinner ") ; 
    if (D = 0) then     OclFile["System.out"].println("no guest") else     OclFile["System.out"].println((100 * Dc) / D) ; ;  
    OclFile["System.out"].print("midnight ") ; 
    if (M = 0) then     OclFile["System.out"].println("no guest") else     OclFile["System.out"].println((100 * Mc) / M) ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    String S[][]=new String[H][W];
    for(int i=0 ; i<H ; i++){
      S[i]=sc.next().split("");
    }
    int count=0 ;
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        count=0 ;
        if(S[i][j] .equals("#")){
          continue ;
        }
        if(j-1>=0){
          if(i-1>=0 && S[i-1][j-1] .equals("#"))count++;
          if(S[i][j-1] .equals("#"))count++;
          if(i+1<H && S[i+1][j-1] .equals("#"))count++;
        }
        if(i-1>=0 && S[i-1][j] .equals("#"))count++;
        if(i+1<H && S[i+1][j] .equals("#"))count++;
        if(j+1<W){
          if(i-1>=0 && S[i-1][j+1] .equals("#"))count++;
          if(S[i][j+1] .equals("#"))count++;
          if(i+1<H && S[i+1][j+1] .equals("#"))count++;
        }
        S[i][j]=""+count ;
      }
    }
    for(int i=0 ; i<H ; i++){
      System.out.println(String.join("",S[i]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var S : Sequence(Sequence(String)) ; S := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(null)) ;
        var i : int ; i := 0 ; while i < H do ( (     S[i+1] := sc.getCurrent()->split("") )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     count := 0 ; 
     if (S[i+1][j+1] = "#") then (     continue ) else skip ; 
    if (j - 1 >= 0) then (     if ((i)->char2byte() - 1 >= 0 & S[(i)->char2byte() - 1+1][j - 1+1] = "#") then     count := count + 1 ; else skip ; 
     if (S[i+1][j - 1+1] = "#") then     count := count + 1 ; else skip ; 
     if (i + 1 < H & S[i + 1+1][j - 1+1] = "#") then     count := count + 1 ; else skip ) else skip ; 
    if ((i)->char2byte() - 1 >= 0 & S[(i)->char2byte() - 1+1][j+1] = "#") then     count := count + 1 ; else skip ; 
    if (i + 1 < H & S[i + 1+1][j+1] = "#") then     count := count + 1 ; else skip ; 
    if (j + 1 < W) then (     if ((i)->char2byte() - 1 >= 0 & S[(i)->char2byte() - 1+1][j + 1+1] = "#") then     count := count + 1 ; else skip ; 
     if (S[i+1][j + 1+1] = "#") then     count := count + 1 ; else skip ; 
     if (i + 1 < H & S[i + 1+1][j + 1+1] = "#") then     count := count + 1 ; else skip ) else skip ; 
    S[i+1][j+1] := "" + count ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < H do ( (     OclFile["System.out"].println(join("", S[i+1])) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.Scanner ;
class Main {
  static Scanner sc=new Scanner(System.in);
  static PrintStream so=System.out ;
  public static void main(String[] args)throws InterruptedException {
    int h=sc.nextInt();
    int w=sc.nextInt();
    int[][] s=new int[h+2][w+2];
    for(int i=1 ; i<=h ; i++){
      String line=sc.next();
      for(int j=1 ; j<=w ; j++){
        s[i][j]=line.charAt(j-1)=='.' ? 0 :-1 ;
      }
    }
    int[] mx={
      1,0,-1,0,1,1,-1,-1 };
      int[] my={
        0,1,0,-1,-1,1,-1,1 };
        for(int i=1 ; i<=h ; i++){
          for(int j=1 ; j<=w ; j++){
            if(s[i][j]==-1){
              for(int m=0 ; m<8 ; m++){
                if(s[i+mx[m] ][j+my[m] ]!=-1){
                  s[i+mx[m] ][j+my[m] ]+=1 ;
                }
              }
            }
          }
        }
        for(int i=1 ; i<=h ; i++){
          for(int j=1 ; j<=w ; j++){
            so.print(s[i][j]==-1 ? "#" : s[i][j]);
          }
          so.println();
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute so : OclFile := OclFile["System.out"];
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var h : int ; h := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    var s : Sequence(Sequence(int)) ; s := Integer.subrange(1,h + 2)->collect(Integer.subrange(1,w + 2)->collect(0)) ;
        var i : int ; i := 1 ; while i <= h do ( (     var line : String ; line := sc.getCurrent() ;
         var j : int ; j := 1 ; while j <= w do ( (     s[i+1][j+1] := if line->at((j)->char2byte() - 1+1) = '.' then 0 else -1 endif )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var mx : Sequence(int) ; mx := Sequence{1,0,-1,0,1,1,-1,-1} ;
    var my : Sequence(int) ; my := Sequence{0,1,0,-1,-1,1,-1,1} ;
        var i : int ; i := 1 ; while i <= h do ( (         var j : int ; j := 1 ; while j <= w do ( (     if (s[i+1][j+1] = -1) then (         var m : int ; m := 0 ; while m < 8 do ( (     if (s[i + mx[m+1]+1][j + my[m+1]+1] /= -1) then (     s[i + mx[m+1]+1][j + my[m+1]+1] := s[i + mx[m+1]+1][j + my[m+1]+1]+(1) ) else skip )  ;     m := m + 1 ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= h do ( (         var j : int ; j := 1 ; while j <= w do ( (     skip )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner sc=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    int X=Integer.parseInt(sc.next());
    int Y=Integer.parseInt(sc.next());
    char S[][]=new char[50][50];
    for(int x=0 ; x<X ; x++){
      String s=sc.next();
      for(int y=0 ; y<Y ; y++){
        S[x][y]=s.charAt(y);
      }
    }
    int dx[]={
      1,1,0,-1,-1,-1,0,1 };
      int dy[]={
        0,1,1,1,0,-1,-1,-1 };
        for(int i=0 ; i<X ; i++){
          for(int j=0 ; j<Y ; j++){
            if(S[i][j]=='.'){
              int count=0 ;
              for(int k=0 ; k<8 ; k++){
                int x=i+dx[k];
                int y=j+dy[k];
                if(0<=x && x<X && 0<=y && y<Y && S[x][y]=='#'){
                  count++;
                }
                S[i][j]=(char)('0'+count);
              }
            }
          }
        }
        for(int i=0 ; i<X ; i++){
          for(int j=0 ; j<Y ; j++){
            out.print(S[i][j]);
          }
          out.println();
        }
        out.close();
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var X : int ; X := (sc.getCurrent())->toInteger() ;
    var Y : int ; Y := (sc.getCurrent())->toInteger() ;
    var S : Sequence(Sequence(String)) ; S := Integer.subrange(1,50)->collect(Integer.subrange(1,50)->collect(0)) ;
        var x : int ; x := 0 ; while x < X do ( (     var s : String ; s := sc.getCurrent() ;
         var y : int ; y := 0 ; while y < Y do ( (     S[x+1][y+1] := s->at(y+1) )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
    var dx : Sequence(int) ; dx := Sequence{1,1,0,-1,-1,-1,0,1} ;
    var dy : Sequence(int) ; dy := Sequence{0,1,1,1,0,-1,-1,-1} ;
        var i : int ; i := 0 ; while i < X do ( (         var j : int ; j := 0 ; while j < Y do ( (     if (S[i+1][j+1] = '.') then (     var count : int ; count := 0 ;
         var k : int ; k := 0 ; while k < 8 do ( (     var x : int ; x := i + dx[k+1] ;
     var y : int ; y := j + dy[k+1] ;
     if (0 <= x & x < X & 0 <= y & y < Y & S[x+1][y+1] = '#') then (     count := count + 1 ) else skip ; 
     S[i+1][j+1] := ('0' + count)->oclAsType(String) )  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < X do ( (         var j : int ; j := 0 ; while j < Y do ( (     skip )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    sc.nextLine();
    String[] str=new String[H];
    String[][] S=new String[H][W];
    for(int i=0 ; i<H ; i++){
      str[i]=sc.nextLine();
    }
    sc.close();
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        String s[]=str[i] .split("");
        S[i][j]=s[j];
      }
    }
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        if(S[i][j] .equals("#")){
          System.out.print("#");
        }
        else {
          System.out.print(mineCount(i,j,S));
        }
      }
      System.out.println();
    }
  }
  public static int mineCount(int h,int w,String[][] S){
    int count=0 ;
    for(int i=h-1 ; i<=h+1 ; i++){
      if(i<0 || i>=S.length){
        continue ;
      }
      for(int j=w-1 ; j<=w+1 ; j++){
        if(j<0 || j>=S[0] .length){
          continue ;
        }
        if(S[i][j] .equals("#")){
          count++;
        }
      }
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    skip ; 
    var str : Sequence(String) ; str := Integer.subrange(1,H)->collect(null) ;
    var S : Sequence(Sequence(String)) ; S := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(null)) ;
        var i : int ; i := 0 ; while i < H do ( (     str[i+1] := sc.nextLine() )  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     var s : Sequence(String) ; s := str[i+1]->split("") ;
     S[i+1][j+1] := s[j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (S[i+1][j+1] = "#") then (     OclFile["System.out"].print("#") ) else (     OclFile["System.out"].print(mineCount(i, j, S)) ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
  static   operation mineCount( h : int, w : int, S : Sequence(Sequence(String))) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := h - 1 ; while i <= h + 1 do ( (     if (i < 0 or i >= S->size()) then (     continue ) else skip ; 
         var j : int ; j := w - 1 ; while j <= w + 1 do ( (     if (j < 0 or j >= S[0+1]->size()) then (     continue ) else skip ; 
     if (S[i+1][j+1] = "#") then (     count := count + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    String s[]=new String[h];
    for(int i=0 ; i<h ; i++){
      s[i]=sc.next();
    }
    String t[]=new String[w];
    for(int i=0 ; i<h ; i++){
      String b="" ;
      for(int j=0 ; j<w ; j++){
        int a=0 ;
        if(s[i] .substring(j,j+1).equals("#")){
          b+="#" ;
        }
        else {
          if(i>0 && j>0 && s[i-1] .substring(j-1,j).equals("#"))a++;
          if(i>0 && s[i-1] .substring(j,j+1).equals("#"))a++;
          if(i>0 && j<w-1 && s[i-1] .substring(j+1,j+2).equals("#"))a++;
          if(j>0 && s[i] .substring(j-1,j).equals("#"))a++;
          if(j<w-1 && s[i] .substring(j+1,j+2).equals("#"))a++;
          if(i<h-1 && j>0 && s[i+1] .substring(j-1,j).equals("#"))a++;
          if(i<h-1 && s[i+1] .substring(j,j+1).equals("#"))a++;
          if(i<h-1 && j<w-1 && s[i+1] .substring(j+1,j+2).equals("#"))a++;
          b+=String.valueOf(a);
        }
      }
      System.out.println(b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := Integer.subrange(1,h)->collect(null) ;
        var i : int ; i := 0 ; while i < h do ( (     s[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    var t : Sequence(String) ; t := Integer.subrange(1,w)->collect(null) ;
        var i : int ; i := 0 ; while i < h do ( (     var b : String ; b := "" ;
         var j : int ; j := 0 ; while j < w do ( (     var a : int ; a := 0 ;
     if (s[i+1].subrange(j+1,j + 1) = "#") then (     b := b+("#") ) else (     if (i > 0 & j > 0 & s[(i)->char2byte() - 1+1].subrange((j)->char2byte() - 1+1,j) = "#") then     a := a + 1 ; else skip ; 
     if (i > 0 & s[(i)->char2byte() - 1+1].subrange(j+1,j + 1) = "#") then     a := a + 1 ; else skip ; 
    if (i > 0 & j < w - 1 & s[(i)->char2byte() - 1+1].subrange(j + 1+1,j + 2) = "#") then     a := a + 1 ; else skip ; 
    if (j > 0 & s[i+1].subrange((j)->char2byte() - 1+1,j) = "#") then     a := a + 1 ; else skip ; 
    if (j < w - 1 & s[i+1].subrange(j + 1+1,j + 2) = "#") then     a := a + 1 ; else skip ; 
    if (i < h - 1 & j > 0 & s[i + 1+1].subrange((j)->char2byte() - 1+1,j) = "#") then     a := a + 1 ; else skip ; 
    if (i < h - 1 & s[i + 1+1].subrange(j+1,j + 1) = "#") then     a := a + 1 ; else skip ; 
    if (i < h - 1 & j < w - 1 & s[i + 1+1].subrange(j + 1+1,j + 2) = "#") then     a := a + 1 ; else skip ; 
    b := b+(((a) + "")) ; 
 ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(b) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int countDistinct(int arr[],int n){
    Arrays.sort(arr);
    int res=0 ;
    for(int i=0 ; i<n ; i++){
      while(i<n-1 && arr[i]==arr[i+1]){
        i++;
      }
      res++;
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      6,10,5,4,9,120,4,6,10 };
      int n=arr.length ;
      System.out.println(countDistinct(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDistinct( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     while (i < n - 1 & arr[i+1] = arr[i + 1+1]) do (     i := i + 1 ) ; 
     res := res + 1 )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,10,5,4,9,120,4,6,10} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countDistinct(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Solution {
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(reader.readLine());
    String[] s=reader.readLine().split(" ");
    Map<Integer,Integer>map=new HashMap<>();
    Integer[] nums=new Integer[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=Integer.parseInt(s[i]);
      map.put(nums[i],i+1);
    }
    Arrays.sort(nums);
    String str=reader.readLine();
    solve(nums,n,map,str);
  }
  public static void solve(Integer[] nums,int n,Map<Integer,Integer>map,String s){
    TreeSet<Integer>set=new TreeSet();
    int introvert=0 ;
    int extrovert=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='0'){
        System.out.print(map.get(nums[introvert])+" ");
        set.add(nums[introvert]);
        introvert++;
      }
      else {
        System.out.print(map.get(set.last())+" ");
        set.remove(set.last());
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (reader.readLine())->toInteger() ;
    var s : Sequence(String) ; s := reader.readLine()->split(" ") ;
    var map : Map(int,int) ; map := Map{} ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := (s[i+1])->toInteger() ; 
     map := map->union(Map{nums[i+1] |-> i + 1}) )  ;     i := i + 1 ) ; 
    nums := nums->sort() ; 
    var str : String ; str := reader.readLine() ;
    execute solve(nums, n, map, str) ; 
 );
  static   operation solve( nums : Sequence(int), n : int, map : Map(int,int), s : String) : void
  pre: true
  post: true
  activity: (     var set : Set(int) ; set := Set{} ;
     var introvert : int ; introvert := 0 ;
     var extrovert : int ; extrovert := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '0') then (     OclFile["System.out"].print(map->at(nums[introvert+1]) + " ") ; 
     set := set->including(nums[introvert+1]) ; 
     introvert := introvert + 1 ) else (     OclFile["System.out"].print(map->at(set->last()) + " ") ; 
     set := set->excludingFirst(set->last()) ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[][] s={
      {
        0,1,1,1,1,1,1 },{
          0,0,0,0,1,1,0 },{
            1,0,1,1,0,1,1 },{
              1,0,0,1,1,1,1 },{
                1,1,0,0,1,1,0 },{
                  1,1,0,1,1,0,1 },{
                    1,1,1,1,1,0,1 },{
                      0,1,0,0,1,1,1 },{
                        1,1,1,1,1,1,1 },{
                          1,1,0,1,1,1,1 }
                        };
                        for(; ; ){
                          int n=sc.nextInt();
                          int[] a=new int[7];
                          if(n==-1){
                            break ;
                          }
                          while(n-->0){
                            int m=sc.nextInt();
                            for(int i=0 ; i<7 ; i++){
                              System.out.print((a[i] ^ s[m][i])+(i==6 ? "\n" : ""));
                            }
                            a=s[m] .clone();
                          }
                        }
                      }
                    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(Sequence(int)) ; s := Sequence{Sequence{0,1,1,1,1,1,1},Sequence{0,0,0,0,1,1,0},Sequence{1,0,1,1,0,1,1},Sequence{1,0,0,1,1,1,1},Sequence{1,1,0,0,1,1,0},Sequence{1,1,0,1,1,0,1},Sequence{1,1,1,1,1,0,1},Sequence{0,1,0,0,1,1,1},Sequence{1,1,1,1,1,1,1},Sequence{1,1,0,1,1,1,1}} ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,7)->collect(0) ;
     if (n = -1) then (     break ) else skip ; 
         while (n > 0) do (        n := n - 1 ;     skip ; (     var m : int ; m := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < 7 do ( (     OclFile["System.out"].print((a[i+1] xor s[m+1][i+1]) + (if i = 6 then "\n" else "" endif)) )  ;     i := i + 1 ) ; 
     a := s[m+1]->copy() ) ;  ) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class fence_kp_java {
  static Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      int a=in.nextInt();
      if(360 %(180-a)==0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class fence_kp_java {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     if (360 mod (180 - a) = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    int n=Integer.parseInt(br.readLine());
    int a[]=new int[n];
    String s[]=br.readLine().split(" ");
    char pas[]=br.readLine().toCharArray();
    class Pair {
      int index ;
      int val ;
      Pair(int i,int val){
        this.index=i+1 ;
        this.val=val ;
      }
    }
    PriorityQueue<Pair>minQ=new PriorityQueue<>((i1,i2)->{
      return i1.val-i2.val ;
    }
);
    PriorityQueue<Pair>maxQ=new PriorityQueue<>((i1,i2)->{
      return i2.val-i1.val ;
    }
);
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(s[i]);
      minQ.add(new Pair(i,a[i]));
    }
    for(char ch : pas){
      if(ch=='0'){
        pw.write(minQ.peek().index+" ");
        Pair p=minQ.peek();
        minQ.poll();
        maxQ.add(p);
      }
      else {
        pw.write(maxQ.peek().index+" ");
        maxQ.poll();
      }
    }
    pw.write("\n");
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var s : Sequence(String) ; s := br.readLine()->split(" ") ;
    var pas : Sequence(String) ; pas := br.readLine()->characters() ;
class Pair {
   attribute index : int;
   attribute val : int;
   static operation newPair( i : int, val : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(i, val);
    return self );
  operation initialise( i : int, val : int) : void
  pre: true  post: true
  activity: (     self.index := i + 1 ; 
     self.val := val );
}
    var minQ : Sequence(Map) ; minQ := Sequence{}->union(lambda (i1 , i2) : OclAny in (     return i1.val - i2.val )) ;
    var maxQ : Sequence(Map) ; maxQ := Sequence{}->union(lambda (i1 , i2) : OclAny in (     return i2.val - i1.val )) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (s[i+1])->toInteger() ; 
     minQ := minQ->including(Map(i, a[i+1])) )  ;     i := i + 1 ) ; 
    for (ch : pas) do ( (     if (ch = '0') then (     skip ; 
     var p : Map ; p := minQ->min() ;
     minQ := minQ->sort()->tail() ; 
     maxQ := maxQ->including(p) ) else (     skip ; 
     maxQ := maxQ->sort()->tail() ) )  ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(reader.readLine());
    String[] s=reader.readLine().split(" ");
    Map<Integer,Integer>map=new HashMap<>();
    Integer[] nums=new Integer[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=Integer.parseInt(s[i]);
      map.put(nums[i],i+1);
    }
    Arrays.sort(nums);
    String str=reader.readLine();
    solve(nums,n,map,str);
  }
  public static void solve(Integer[] nums,int n,Map<Integer,Integer>map,String s){
    Stack<Integer>stack=new Stack();
    int introvert=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='0'){
        System.out.print(map.get(nums[introvert])+" ");
        stack.push(nums[introvert++]);
      }
      else {
        System.out.print(map.get(stack.pop())+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (reader.readLine())->toInteger() ;
    var s : Sequence(String) ; s := reader.readLine()->split(" ") ;
    var map : Map(int,int) ; map := Map{} ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := (s[i+1])->toInteger() ; 
     map := map->union(Map{nums[i+1] |-> i + 1}) )  ;     i := i + 1 ) ; 
    nums := nums->sort() ; 
    var str : String ; str := reader.readLine() ;
    execute solve(nums, n, map, str) ; 
 );
  static   operation solve( nums : Sequence(int), n : int, map : Map(int,int), s : String) : void
  pre: true
  post: true
  activity: (     var stack : Sequence(int) ; stack := Sequence{} ;
     var introvert : int ; introvert := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '0') then (     OclFile["System.out"].print(map->at(nums[introvert+1]) + " ") ; 
     stack := stack->append(nums[introvert+1]) ) else (     OclFile["System.out"].print(map->at(stack->last()) + " ") ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf470_2_1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    char mat[][]=new char[n][m];
    for(int i=0 ; i<n ; ++i)mat[i]=sc.next().toCharArray();
    for(int i=0 ; i<n ; ++i){
      for(int j=0 ; j<m ; ++j){
        if(mat[i][j]=='S'){
          if(i+1<n && mat[i+1][j]=='W'){
            System.out.print("No");
            return ;
          }
          if(i-1>=0 && mat[i-1][j]=='W'){
            System.out.print("No");
            return ;
          }
          if(j+1<m && mat[i][j+1]=='W'){
            System.out.print("No");
            return ;
          }
          if(j-1>=0 && mat[i][j-1]=='W'){
            System.out.print("No");
            return ;
          }
        }
      }
    }
    System.out.println("Yes");
    for(int i=0 ; i<n ; ++i){
      for(int j=0 ; j<m ; ++j){
        if(mat[i][j]=='.')System.out.print("D");
        else System.out.print(mat[i][j]);
      }
      System.out.println();
    }
    System.out.close();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf470{
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var mat : Sequence(Sequence(String)) ; mat := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do (     mat[i+1] := sc.getCurrent()->characters() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (mat[i+1][j+1] = 'S') then (     if (i + 1 < n & mat[i + 1+1][j+1] = 'W') then (     OclFile["System.out"].print("No") ; 
     return ) else skip ; 
     if ((i)->char2byte() - 1 >= 0 & mat[(i)->char2byte() - 1+1][j+1] = 'W') then (     OclFile["System.out"].print("No") ; 
     return ) else skip ; 
     if (j + 1 < m & mat[i+1][j + 1+1] = 'W') then (     OclFile["System.out"].print("No") ; 
     return ) else skip ; 
     if (j - 1 >= 0 & mat[i+1][j - 1+1] = 'W') then (     OclFile["System.out"].print("No") ; 
     return ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Yes") ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (mat[i+1][j+1] = '.') then     OclFile["System.out"].print("D") ; else     OclFile["System.out"].print(mat[i+1][j+1]) ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].close() ; 
    skip ; 
 );
}
_1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var mat : Sequence(Sequence(String)) ; mat := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do (     mat[i+1] := sc.getCurrent()->characters() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (mat[i+1][j+1] = 'S') then (     if (i + 1 < n & mat[i + 1+1][j+1] = 'W') then (     OclFile["System.out"].print("No") ; 
     return ) else skip ; 
     if ((i)->char2byte() - 1 >= 0 & mat[(i)->char2byte() - 1+1][j+1] = 'W') then (     OclFile["System.out"].print("No") ; 
     return ) else skip ; 
     if (j + 1 < m & mat[i+1][j + 1+1] = 'W') then (     OclFile["System.out"].print("No") ; 
     return ) else skip ; 
     if (j - 1 >= 0 & mat[i+1][j - 1+1] = 'W') then (     OclFile["System.out"].print("No") ; 
     return ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Yes") ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (mat[i+1][j+1] = '.') then     OclFile["System.out"].print("D") ; else     OclFile["System.out"].print(mat[i+1][j+1]) ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].close() ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMin(int arr[],int n){
    int m=0 ;
    for(int i=0 ; i<n ; i++)m=Math.max(m,arr[i]);
    int freq[]=new int[m+2];
    for(int i=0 ; i<n ; i++)freq[arr[i] ]++;
    for(int i=1 ; i<=m+1 ; i++){
      int j=i ;
      int cnt=0 ;
      while(j<=m){
        cnt+=freq[j];
        j+=i ;
      }
      if(cnt==0)return i ;
    }
    return m+1 ;
  }
  public static void main(String[] args){
    int arr[]={
      2,12,6 };
      int n=arr.length ;
      System.out.println(findMin(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMin( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var m : int ; m := 0 ;
         var i : int ; i := 0 ; while i < n do (     m := Set{m, arr[i+1]}->max() ;  ;     i := i + 1 ) ; 
    var freq : Sequence(int) ; freq := Integer.subrange(1,m + 2)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     freq[arr[i+1]+1] := freq[arr[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= m + 1 do ( (     var j : int ; j := i ;
     var cnt : int ; cnt := 0 ;
     while (j <= m) do (     cnt := cnt+(freq[j+1]) ; 
     j := j+(i) ) ; 
     if (cnt = 0) then     return i else skip )  ;     i := i + 1 ) ; 
    return m + 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,12,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMin(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMin(int arr[],int n){
    int m=0 ;
    for(int i=0 ; i<n ; i++)m=Math.max(m,arr[i]);
    int cnt[]=new int[m+2];
    for(int i=0 ; i<n ; i++){
      for(int j=1 ; j*j<=arr[i]; j++){
        if(arr[i] % j==0){
          if(j*j==arr[i])cnt[j]++;
          else {
            cnt[j]++;
            cnt[arr[i]/j]++;
          }
        }
      }
    }
    for(int i=1 ; i<=m+1 ; i++)if(cnt[i]==0){
      return i ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      2,12,6 };
      int n=arr.length ;
      System.out.println(findMin(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMin( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var m : int ; m := 0 ;
         var i : int ; i := 0 ; while i < n do (     m := Set{m, arr[i+1]}->max() ;  ;     i := i + 1 ) ; 
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,m + 2)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 1 ; while j * j <= arr[i+1] do ( (     if (arr[i+1] mod j = 0) then (     if (j * j = arr[i+1]) then     cnt[j+1] := cnt[j+1] + 1 ; else (     cnt[j+1] := cnt[j+1] + 1 ; 
     cnt[arr[i+1] / j+1] := cnt[arr[i+1] / j+1] + 1 ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= m + 1 do (     if (cnt[i+1] = 0) then (     return i ) else skip ;  ;     i := i + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,12,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMin(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Anton_and_classes {
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine()),min1=Integer.MAX_VALUE,max2=0 ;
    while(n-->0){
      StringTokenizer st=new StringTokenizer(br.readLine());
      int l=Integer.parseInt(st.nextToken()),r=Integer.parseInt(st.nextToken());
      min1=Math.min(min1,r);
      max2=Math.max(max2,l);
    }
    int m=Integer.parseInt(br.readLine()),max1=0,min2=Integer.MAX_VALUE ;
    while(m-->0){
      StringTokenizer s=new StringTokenizer(br.readLine());
      int l=Integer.parseInt(s.nextToken()),r=Integer.parseInt(s.nextToken());
      max1=Math.max(max1,l);
      min2=Math.min(min2,r);
    }
    int d1=min1>max1 ? 0 : max1-min1,d2=min2>max2 ? 0 : max2-min2 ;
    System.out.println(d2>d1 ? d2 : d1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Anton_and_classes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var min1 : int ; min1 := 2147483647 ;
    var max2 : int ; max2 := 0 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var l : int ; l := (st.next())->toInteger() ;
    var r : int ; r := (st.next())->toInteger() ;
     min1 := Set{min1, r}->min() ; 
     max2 := Set{max2, l}->max() ) ;  ) ;  
    var m : int ; m := (br.readLine())->toInteger() ;
    var max1 : int ; max1 := 0 ;
    var min2 : int ; min2 := 2147483647 ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     var s : OclIterator ; s := OclIterator.newOclIterator_String(br.readLine()) ;
     var l : int ; l := (s.next())->toInteger() ;
    var r : int ; r := (s.next())->toInteger() ;
     max1 := Set{max1, l}->max() ; 
     min2 := Set{min2, r}->min() ) ;  ) ;  
    var d1 : int ; d1 := if min1 > max1 then 0 else max1 - min1 endif ;
    var d2 : int ; d2 := if min2 > max2 then 0 else max2 - min2 endif ;
    OclFile["System.out"].println(if d2 > d1 then d2 else d1 endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static final int mx=Integer.MAX_VALUE ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int maxStrt1=0,minEnd1=mx,maxStrt2=0,minEnd2=mx ;
    int n=Integer.parseInt(st.nextToken());
    int[][] chs=new int[n][2];
    for(int i=0 ; i<n ; i++){
      st=new StringTokenizer(br.readLine());
      chs[i][0]=Integer.parseInt(st.nextToken());
      chs[i][1]=Integer.parseInt(st.nextToken());
      maxStrt1=Math.max(chs[i][0],maxStrt1);
      minEnd1=Math.min(chs[i][1],minEnd1);
    }
    int m=Integer.parseInt(br.readLine());
    int[][] prg=new int[m][2];
    for(int i=0 ; i<m ; i++){
      st=new StringTokenizer(br.readLine());
      prg[i][0]=Integer.parseInt(st.nextToken());
      prg[i][1]=Integer.parseInt(st.nextToken());
      maxStrt2=Math.max(prg[i][0],maxStrt2);
      minEnd2=Math.min(prg[i][1],minEnd2);
    }
    System.out.println(Math.max(0,Math.max(maxStrt2-minEnd1,maxStrt1-minEnd2)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute mx : int := 2147483647;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var maxStrt1 : int ; maxStrt1 := 0 ;
    var minEnd1 : int ; minEnd1 := mx ;
    var maxStrt2 : int ; maxStrt2 := 0 ;
    var minEnd2 : int ; minEnd2 := mx ;
    var n : int ; n := (st.next())->toInteger() ;
    var chs : Sequence(Sequence(int)) ; chs := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     chs[i+1][0+1] := (st.next())->toInteger() ; 
    chs[i+1][1+1] := (st.next())->toInteger() ; 
    maxStrt1 := Set{chs[i+1][0+1], maxStrt1}->max() ; 
    minEnd1 := Set{chs[i+1][1+1], minEnd1}->min() ; 
 )  ;     i := i + 1 ) ; 
    var m : int ; m := (br.readLine())->toInteger() ;
    var prg : Sequence(Sequence(int)) ; prg := Integer.subrange(1,m)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     prg[i+1][0+1] := (st.next())->toInteger() ; 
    prg[i+1][1+1] := (st.next())->toInteger() ; 
    maxStrt2 := Set{prg[i+1][0+1], maxStrt2}->max() ; 
    minEnd2 := Set{prg[i+1][1+1], minEnd2}->min() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{0, Set{maxStrt2 - minEnd1, maxStrt1 - minEnd2}->max()}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt(),M=in.nextInt(),Q=in.nextInt();
    int[][] train=new int[N+1][N+1];
    while(M-->0)++train[in.nextInt()][in.nextInt()];
    int[][] psum=new int[N+1][N+1];
    for(int l=1 ; l<=N ; ++l)for(int r=1 ; r<=N ; ++r)psum[l][r]=psum[l][r-1]+train[l][r];
    for(int l=1 ; l<=N ; ++l)for(int r=1 ; r<=N ; ++r)psum[l][r]+=psum[l-1][r];
    while(Q-->0){
      int l=in.nextInt()-1,r=in.nextInt();
      System.out.println(psum[r][r]+psum[l][l]-psum[l][r]-psum[r][l]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var M : int ; M := in.getCurrent()->toInteger() ;
    var Q : int ; Q := in.getCurrent()->toInteger() ;
    var train : Sequence(Sequence(int)) ; train := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
        while (M > 0) do (        M := M - 1 ;     skip ;     train[in.getCurrent()->toInteger()+1][in.getCurrent()->toInteger()+1] := train[in.getCurrent()->toInteger()+1][in.getCurrent()->toInteger()+1] + 1 ; ;  ) ;  
    var psum : Sequence(Sequence(int)) ; psum := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
        var l : int ; l := 1 ; while l <= N do (         var r : int ; r := 1 ; while r <= N do (     psum[l+1][r+1] := psum[l+1][r - 1+1] + train[l+1][r+1] ;  ;     r := r + 1 ) ;  ;     l := l + 1 ) ; 
        var l : int ; l := 1 ; while l <= N do (         var r : int ; r := 1 ; while r <= N do (     psum[l+1][r+1] := psum[l+1][r+1]+(psum[l - 1+1][r+1]) ;  ;     r := r + 1 ) ;  ;     l := l + 1 ) ; 
        while (Q > 0) do (        Q := Q - 1 ;     skip ; (     var l : int ; l := in.getCurrent()->toInteger() - 1 ;
    var r : int ; r := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println(psum[r+1][r+1] + psum[l+1][l+1] - psum[l+1][r+1] - psum[r+1][l+1]) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int Q=sc.nextInt();
    int[][] sum=new int[N+1][N+1];
    for(int i=0 ; i<M ; i++){
      sum[sc.nextInt()][sc.nextInt()]++;
    }
    int[] p=new int[Q];
    int[] q=new int[Q];
    for(int i=0 ; i<Q ; i++){
      p[i]=sc.nextInt();
      q[i]=sc.nextInt();
    }
    for(int i=1 ; i<=N ; i++){
      for(int j=1 ; j<=N ; j++){
        sum[i][j]+=sum[i-1][j];
        sum[i][j]+=sum[i][j-1];
        sum[i][j]-=sum[i-1][j-1];
      }
    }
    for(int i=0 ; i<Q ; i++){
      out.println(sum[q[i] ][q[i] ]-sum[p[i]-1][q[i] ]-sum[q[i] ][p[i]-1]+sum[p[i]-1][p[i]-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var Q : int ; Q := sc.getCurrent()->toInteger() ;
    var sum : Sequence(Sequence(int)) ; sum := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < M do ( (     sum[sc.getCurrent()->toInteger()+1][sc.getCurrent()->toInteger()+1] := sum[sc.getCurrent()->toInteger()+1][sc.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
    var p : Sequence(int) ; p := Integer.subrange(1,Q)->collect(0) ;
    var q : Sequence(int) ; q := Integer.subrange(1,Q)->collect(0) ;
        var i : int ; i := 0 ; while i < Q do ( (     p[i+1] := sc.getCurrent()->toInteger() ; 
     q[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := 1 ; while j <= N do ( (     sum[i+1][j+1] := sum[i+1][j+1]+(sum[i - 1+1][j+1]) ; 
     sum[i+1][j+1] := sum[i+1][j+1]+(sum[i+1][j - 1+1]) ; 
     sum[i+1][j+1] := sum[i+1][j+1]-(sum[i - 1+1][j - 1+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Q do ( (     out.println(sum[q[i+1]+1][q[i+1]+1] - sum[p[i+1] - 1+1][q[i+1]+1] - sum[q[i+1]+1][p[i+1] - 1+1] + sum[p[i+1] - 1+1][p[i+1] - 1+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.util.Arrays ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int[] A=new int[N];
    int sum=0 ;
    for(int j=0 ; j<N ; j++){
      A[j]=scan.nextInt();
      sum+=A[j];
    }
    int ans=1 ;
    int half=sum/2 ;
    if(A[0]>half){
      System.out.println(1);
      System.out.println(1);
      return ;
    }
    ArrayList<Integer>list=new ArrayList<>();
    list.add(1);
    int s=A[0];
    for(int i=1 ; i<N ; i++){
      if(2*A[i]<=A[0] && s<=half){
        ans++;
        s+=A[i];
        list.add(i+1);
      }
    }
    if(s<=half){
      System.out.println(0);
    }
    else {
      System.out.println(ans);
      for(int i=0 ; i<list.size(); i++){
        System.out.print(list.get(i)+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var sum : int ; sum := 0 ;
        var j : int ; j := 0 ; while j < N do ( (     A[j+1] := scan.getCurrent()->toInteger() ; 
     sum := sum+(A[j+1]) )  ;     j := j + 1 ) ; 
    var ans : int ; ans := 1 ;
    var half : int ; half := sum / 2 ;
    if (A[0+1] > half) then (     OclFile["System.out"].println(1) ; 
     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    var list : Sequence(int) ; list := Sequence{} ;
    list := list->including(1) ; 
    var s : int ; s := A[0+1] ;
        var i : int ; i := 1 ; while i < N do ( (     if (2 * A[i+1] <= A[0+1] & s <= half) then (     ans := ans + 1 ; 
     s := s+(A[i+1]) ; 
     list := list->including(i + 1) ) else skip )  ;     i := i + 1 ) ; 
    if (s <= half) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(ans) ; 
         var i : int ; i := 0 ; while i < list->size() do ( (     OclFile["System.out"].print(list->at(i+1) + " ") )  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    ArrayList<Integer>arr=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      arr.add(in.nextInt());
    }
    for(int i=0 ; i<n ; i++){
      if(360 %(180-arr.get(i))==0)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr := arr->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (360 mod (180 - arr->at(i+1)) = 0) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt(),m=scanner.nextInt(),q=scanner.nextInt();
      int[][] x=new int[n][n],c=new int[n+1][n+1];
      IntStream.range(0,n).forEach(i->Arrays.fill(x[i],0));
      IntStream.range(0,m).forEach(i->{
        int l=scanner.nextInt()-1,r=scanner.nextInt()-1 ;
        x[l][r]++;
      }
);
      Arrays.fill(c[0],0);
      IntStream.rangeClosed(1,n).forEach(i->c[i][0]=0);
      IntStream.rangeClosed(1,n).forEach(i->IntStream.rangeClosed(1,n).forEach(j->c[i][j]=c[i][j-1]+x[i-1][j-1]));
      IntStream.range(0,q).forEach(i->{
        int s=scanner.nextInt(),t=scanner.nextInt();
        System.out.println(IntStream.rangeClosed(s,t).map(j->c[j][t]-c[j][s-1]).sum());
      }
);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var q : int ; q := scanner.getCurrent()->toInteger() ;
     var x : Sequence(Sequence(int)) ; x := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
    for i : Integer.subrange(0, n-1) do
    (    x[i+1] := x[i+1]->collect(0)) ; 
    for i : Integer.subrange(0, m-1) do
    (    skip) ; 
    c[0+1] := c[0+1]->collect(0) ; 
    for i : Integer.subrange(1, n) do
    (    c[i+1][0+1] := 0) ; 
    for i : Integer.subrange(1, n) do
    (    for j : Integer.subrange(1, n) do
    (    c[i+1][j+1] := c[i+1][j - 1+1] + x[i - 1+1][j - 1+1])) ; 
    for i : Integer.subrange(0, q-1) do
    (    skip) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int q=sc.nextInt();
    int[] ramp=new int[n];
    int[][] tr=new int[n][n];
    for(int i=0 ; i<m ; i++){
      int l=sc.nextInt()-1 ;
      int r=sc.nextInt()-1 ;
      tr[l][r]++;
      ramp[l]++;
      ramp[r]--;
    }
    int[][] dp=new int[n][n];
    int[][] sdp=new int[n][n];
    for(int l=0 ; l<n ; l++){
      for(int r=l ; r<n ; r++){
        if(r>0)sdp[l][r]=sdp[l][r-1];
        sdp[l][r]+=tr[l][r];
      }
    }
    for(int r=n-1 ; r>=0 ; r--){
      for(int l=r ; l>=0 ; l--){
        int cur=0 ;
        if(l<n-1)cur+=dp[l+1][r];
        cur+=sdp[l][r];
        dp[l][r]=cur ;
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<q ; i++){
      int l=sc.nextInt()-1 ;
      int r=sc.nextInt()-1 ;
      sb.append(dp[l][r]+"\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var ramp : Sequence(int) ; ramp := Integer.subrange(1,n)->collect(0) ;
    var tr : Sequence(Sequence(int)) ; tr := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (     var l : int ; l := sc.getCurrent()->toInteger() - 1 ;
     var r : int ; r := sc.getCurrent()->toInteger() - 1 ;
    tr[l+1][r+1] := tr[l+1][r+1] + 1 ; 
    ramp[l+1] := ramp[l+1] + 1 ; 
    ramp[r+1] := ramp[r+1] - 1 ; 
 )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var sdp : Sequence(Sequence(int)) ; sdp := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var l : int ; l := 0 ; while l < n do ( (         var r : int ; r := l ; while r < n do ( (     if (r > 0) then     sdp[l+1][r+1] := sdp[l+1][r - 1+1] ; else skip ; 
     sdp[l+1][r+1] := sdp[l+1][r+1]+(tr[l+1][r+1]) )  ;     r := r + 1 ) )  ;     l := l + 1 ) ; 
        var r : int ; r := n - 1 ; while r >= 0 do ( (         var l : int ; l := r ; while l >= 0 do ( (     var cur : int ; cur := 0 ;
     if (l < n - 1) then     cur := cur+(dp[l + 1+1][r+1]) ; else skip ; 
     cur := cur+(sdp[l+1][r+1]) ; 
     dp[l+1][r+1] := cur )  ;     l := l - 1 ) )  ;     r := r - 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < q do ( (     var l : int ; l := sc.getCurrent()->toInteger() - 1 ;
     var r : int ; r := sc.getCurrent()->toInteger() - 1 ;
     sb := sb + StringLib.newString(dp[l+1][r+1] + "\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int q=sc.nextInt();
    int[][] table=new int[n+1][n+1];
    for(int i=0 ; i<m ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      table[x][y]++;
    }
    int[][] query=new int[q][2];
    for(int i=0 ; i<q ; i++){
      query[i][0]=sc.nextInt();
      query[i][1]=sc.nextInt();
    }
    int[][] sumTable=new int[n+1][n+1];
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=n ; j++){
        sumTable[i][j]=sumTable[i][j-1]+sumTable[i-1][j]-sumTable[i-1][j-1]+table[i][j];
      }
    }
    int result=0 ;
    for(int i=0 ; i<q ; i++){
      int x=query[i][0];
      int y=query[i][1];
      result=sumTable[y][y]-sumTable[y][x-1]-sumTable[x-1][y]+sumTable[x-1][x-1];
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var table : Sequence(Sequence(int)) ; table := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     table[x+1][y+1] := table[x+1][y+1] + 1 )  ;     i := i + 1 ) ; 
    var query : Sequence(Sequence(int)) ; query := Integer.subrange(1,q)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < q do ( (     query[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     query[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sumTable : Sequence(Sequence(int)) ; sumTable := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     sumTable[i+1][j+1] := sumTable[i+1][j - 1+1] + sumTable[i - 1+1][j+1] - sumTable[i - 1+1][j - 1+1] + table[i+1][j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < q do ( (     var x : int ; x := query[i+1][0+1] ;
     var y : int ; y := query[i+1][1+1] ;
     result := sumTable[y+1][y+1] - sumTable[y+1][x - 1+1] - sumTable[x - 1+1][y+1] + sumTable[x - 1+1][x - 1+1] ; 
     OclFile["System.out"].println(result) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    double cx,cy,r,x1,y1,x2,y2 ;
    int q,i ;
    double l1x,l1y,l2x,l2y,d,t1,t2,ax,ay,bx,by,a,bb,c,tmp ;
    cx=sc.nextDouble();
    cy=sc.nextDouble();
    r=sc.nextDouble();
    q=sc.nextInt();
    for(i=0 ; i<q ; i++){
      x1=sc.nextDouble();
      y1=sc.nextDouble();
      x2=sc.nextDouble();
      y2=sc.nextDouble();
      l1x=x2-x1 ;
      l1y=y2-y1 ;
      l2x=x1-cx ;
      l2y=y1-cy ;
      a=l1x*l1x+l1y*l1y ;
      bb=l1x*l2x+l1y*l2y ;
      c=l2x*l2x+l2y*l2y-r*r ;
      d=Math.sqrt(bb*bb-a*c);
      t1=(-bb+d)/a ;
      t2=(-bb-d)/a ;
      ax=x1+t1*l1x ;
      ay=y1+t1*l1y ;
      bx=x1+t2*l1x ;
      by=y1+t2*l1y ;
      if(ax>bx ||(ax==bx && ay>by)){
        tmp=ax ;
        ax=bx ;
        bx=tmp ;
        tmp=ay ;
        ay=by ;
        by=tmp ;
      }
      out.println(ax+" "+ay+" "+bx+" "+by);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var cx : double ;
    var cy : double ;
    var r : double ;
    var x1 : double ;
    var y1 : double ;
    var x2 : double ;
    var y2 : double ;
    var q : int ;
    var i : int ;
    var l1x : double ;
    var l1y : double ;
    var l2x : double ;
    var l2y : double ;
    var d : double ;
    var t1 : double ;
    var t2 : double ;
    var ax : double ;
    var ay : double ;
    var bx : double ;
    var by : double ;
    var a : double ;
    var bb : double ;
    var c : double ;
    var tmp : double ;
    cx := sc.nextDouble() ; 
    cy := sc.nextDouble() ; 
    r := sc.nextDouble() ; 
    q := sc.nextInt() ; 
        i := 0 ; while i < q do ( (     x1 := sc.nextDouble() ; 
     y1 := sc.nextDouble() ; 
    x2 := sc.nextDouble() ; 
    y2 := sc.nextDouble() ; 
    l1x := x2 - x1 ; 
    l1y := y2 - y1 ; 
    l2x := x1 - cx ; 
    l2y := y1 - cy ; 
    a := l1x * l1x + l1y * l1y ; 
    bb := l1x * l2x + l1y * l2y ; 
    c := l2x * l2x + l2y * l2y - r * r ; 
    d := (bb * bb - a * c)->sqrt() ; 
    t1 := (-bb + d) / a ; 
    t2 := (-bb - d) / a ; 
    ax := x1 + t1 * l1x ; 
    ay := y1 + t1 * l1y ; 
    bx := x1 + t2 * l1x ; 
    by := y1 + t2 * l1y ; 
    if (ax > bx or (ax = bx & ay > by)) then (     tmp := ax ; 
     ax := bx ; 
    bx := tmp ; 
    tmp := ay ; 
    ay := by ; 
    by := tmp ; 
 ) else skip ; 
    out.println(ax + " " + ay + " " + bx + " " + by) ; 
 )  ;     i := i + 1 ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    int k=sc.nextInt();
    String s=sc.next();
    char[] ss=s.toCharArray();
    boolean[] a=new boolean[n];
    for(int i=0 ; i<n ; i++){
      if(ss[i]=='A'){
        a[i]=true ;
      }
    }
    boolean flip=false ;
    int index=0 ;
    for(int i=0 ; i<Math.min(k,2*n+k % 2); i++){
      if(a[index] ^ flip){
        a[index]=! a[index];
      }
      else {
        flip=! flip ;
        index=(index+1)% n ;
      }
    }
    for(int i=0 ; i<n ; i++){
      if(a[(index+i)% n] ^ flip){
        System.out.print('A');
      }
      else {
        System.out.print('B');
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var ss : Sequence(String) ; ss := s->characters() ;
    var a : Sequence(boolean) ; a := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     if (ss[i+1] = 'A') then (     a[i+1] := true ) else skip )  ;     i := i + 1 ) ; 
    var flip : boolean ; flip := false ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < Set{k, 2 * n + k mod 2}->min() do ( (     if (a[index+1] xor flip) then (     a[index+1] := not(a[index+1]) ) else (     flip := not(flip) ; 
     index := (index + 1) mod n ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[(index + i) mod n+1] xor flip) then (     OclFile["System.out"].print('A') ) else (     OclFile["System.out"].print('B') ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int N=sc.nextInt();
    int K=sc.nextInt();
    char[] S=sc.next().toCharArray();
    boolean[] a=new boolean[N];
    for(int i=0 ; i<N ; i++)a[i]=S[i]=='A' ;
    boolean flip=false ;
    int idx=0 ;
    int T=Math.min(2*N,K);
    for(int i=0 ; i<T ; i++){
      if(a[idx] ^ flip){
        a[idx]=false ^ flip ;
      }
      else {
        flip ^=true ;
        a[idx]=true ^ flip ;
        idx=(idx+1)% N ;
      }
    }
    if(T<K && N % 2==1)a[idx] ^=(K-T)% 2==1 ;
    for(int i=0 ; i<N ; i++)pw.print(a[(i+idx)% N] ^ flip ? 'A' : 'B');
    pw.println();
    sc.close();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var S : Sequence(String) ; S := sc.getCurrent()->characters() ;
    var a : Sequence(boolean) ; a := Integer.subrange(1,N)->collect(false) ;
        var i : int ; i := 0 ; while i < N do (     a[i+1] := S[i+1] = 'A' ;  ;     i := i + 1 ) ; 
    var flip : boolean ; flip := false ;
    var idx : int ; idx := 0 ;
    var T : int ; T := Set{2 * N, K}->min() ;
        var i : int ; i := 0 ; while i < T do ( (     if (a[idx+1] xor flip) then (     a[idx+1] := false xor flip ) else (     flip := MathLib.bitwiseXor(flip,true) ; 
     a[idx+1] := true xor flip ; 
     idx := (idx + 1) mod N ) )  ;     i := i + 1 ) ; 
    if (T < K & N mod 2 = 1) then     a[idx+1] := MathLib.bitwiseXor(a[idx+1],(K - T) mod 2 = 1) ; else skip ; 
        var i : int ; i := 0 ; while i < N do (     skip ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int minCost(String str,int K){
    int n=str.length();
    int res=999999999,count=0,a,b ;
    int cnt[]=new int[27];
    Arrays.fill(cnt,0);
    for(int i=0 ; i<n ; i++)cnt[str.charAt(i)-'a'+1]++;
    for(int i=1 ; i<(26-K+1); i++){
      a=i ;
      b=i+K ;
      count=0 ;
      for(int j=1 ; j<=26 ; j++){
        if(cnt[j]>0){
          if(j>=a && j>=b)count=count+(Math.min(j-b,25-j+a+1))*cnt[j];
          else if(j<=a && j<=b)count=count+(Math.min(a-j,25+j-b+1))*cnt[j];
        }
      }
      res=Math.min(res,count);
    }
    for(int i=26-K+1 ; i<=26 ; i++){
      a=i ;
      b=(i+K)% 26 ;
      count=0 ;
      for(int j=1 ; j<=26 ; j++){
        if(cnt[j]>0){
          if(j>=b && j<=a)count=count+(Math.min(j-b,a-j))*cnt[j];
        }
      }
      res=Math.min(res,count);
    }
    return res ;
  }
  public static void main(String[] args){
    String str="abcdefghi" ;
    int K=2 ;
    System.out.println(minCost(str,K));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minCost( str : String, K : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var res : int ; res := 999999999 ;
    var count : int ; count := 0 ;
    var a : int ;
    var b : int ;
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,27)->collect(0) ;
    cnt := cnt->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     cnt[str->at(i+1) - ('a')->char2byte() + 1+1] := cnt[str->at(i+1) - ('a')->char2byte() + 1+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < (26 - K + 1) do ( (     a := i ; 
     b := i + K ; 
    count := 0 ; 
        var j : int ; j := 1 ; while j <= 26 do ( (     if (cnt[j+1] > 0) then (     if (j >= a & j >= b) then     count := count + (Set{j - b, 25 - j + a + 1}->min()) * cnt[j+1] ; else     if (j <= a & j <= b) then     count := count + (Set{a - j, 25 + j - b + 1}->min()) * cnt[j+1] ; else skip ; ) else skip )  ;     j := j + 1 ) ; 
    res := Set{res, count}->min() ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 26 - K + 1 ; while i <= 26 do ( (     a := i ; 
     b := (i + K) mod 26 ; 
    count := 0 ; 
        var j : int ; j := 1 ; while j <= 26 do ( (     if (cnt[j+1] > 0) then (     if (j >= b & j <= a) then     count := count + (Set{j - b, a - j}->min()) * cnt[j+1] ; else skip ) else skip )  ;     j := j + 1 ) ; 
    res := Set{res, count}->min() ; 
 )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abcdefghi" ;
     var K : int ; K := 2 ;
     OclFile["System.out"].println(minCost(str, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static String search(int arr[],int n,int x){
    if(arr[n-1]==x)return "Found" ;
    int backup=arr[n-1];
    arr[n-1]=x ;
    for(int i=0 ; ; i++){
      if(arr[i]==x){
        arr[n-1]=backup ;
        if(i<n-1)return "Found" ;
        return "Not Found" ;
      }
    }
  }
  public static void main(String[] args){
    int arr[]={
      4,6,1,5,8 };
      int n=arr.length ;
      int x=1 ;
      System.out.println(search(arr,n,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation search( arr : Sequence(int), n : int, x : int) : String
  pre: true
  post: true
  activity: (     if (arr[n - 1+1] = x) then     return "Found" else skip ; 
     var backup : int ; backup := arr[n - 1+1] ;
     arr[n - 1+1] := x ; 
         var i : int ; i := 0 ; while true do ( (     if (arr[i+1] = x) then (     arr[n - 1+1] := backup ; 
     if (i < n - 1) then     return "Found" else skip ; 
     return "Not Found" ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,6,1,5,8} ;
     var n : int ; n := arr->size() ;
     var x : int ; x := 1 ;
     OclFile["System.out"].println(search(arr, n, x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Arrays ;
import java.util.Collections ;
class GFG {
  public static int calculateDifference(int[] arr,int n){
    int max_val=Arrays.stream(arr).max().getAsInt();
    boolean[] prime=new boolean[max_val+1];
    Arrays.fill(prime,true);
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=max_val ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=max_val ; i+=p)prime[i]=false ;
      }
    }
    int P1=1,P2=1 ;
    for(int i=0 ; i<n ; i++){
      if(prime[arr[i] ]){
        P1*=arr[i];
      }
      else if(arr[i]!=1){
        P2*=arr[i];
      }
    }
    return Math.abs(P2-P1);
  }
  public static void main(String[] args){
    int[] arr=new int[] {
      1,3,5,10,15,7 };
      int n=arr.length ;
      System.out.println(calculateDifference(arr,n));
      System.exit(0);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculateDifference( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max_val : int ; max_val := stream(arr).max().getAsInt() ;
     var prime : Sequence(boolean) ; prime := Integer.subrange(1,max_val + 1)->collect(false) ;
    prime := prime->collect(true) ; 
    prime[0+1] := false ; 
    prime[1+1] := false ; 
        var p : int ; p := 2 ; while p * p <= max_val do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= max_val do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var P1 : int ; P1 := 1 ;
    var P2 : int ; P2 := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (prime[arr[i+1]+1]) then (     P1 := P1*(arr[i+1]) ) else     if (arr[i+1] /= 1) then (     P2 := P2*(arr[i+1]) ) else skip ; )  ;     i := i + 1 ) ; 
    return if P2 - P1 < 0 then -(P2 - P1) else P2 - P1 endif 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,5,10,15,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(calculateDifference(arr, n)) ; 
 OclProcess.exit(0) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.math.BigInteger ;
import java.math.RoundingMode ;
import java.util.Stack ;
public final class p493 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p493().run());
  }
  private static final int NUM_COLORS=7 ;
  private static final int BALLS_PER_COLOR=10 ;
  private static final int NUM_PICKED=20 ;
  private BigInteger numerator=BigInteger.ZERO ;
  public String run(){
    explore(NUM_PICKED,BALLS_PER_COLOR,new Stack<Integer>());
    BigInteger denominator=Library.binomial(NUM_COLORS*BALLS_PER_COLOR,NUM_PICKED);
    BigDecimal num=new BigDecimal(numerator);
    BigDecimal den=new BigDecimal(denominator);
    return num.divide(den,9,RoundingMode.HALF_EVEN).toString();
  }
  private void explore(int remain,int limit,Stack<Integer>history){
    if(remain==0){
      int[] hist=new int[NUM_COLORS];
      for(int i=0 ; i<history.size(); i++)hist[i]=history.get(i);
      int[] histogram=new int[BALLS_PER_COLOR+1];
      for(int x : hist)histogram[x]++;
      BigInteger count=Library.factorial(NUM_COLORS);
      for(int x : histogram)count=divideExactly(count,Library.factorial(x));
      for(int x : hist)count=count.multiply(Library.binomial(BALLS_PER_COLOR,x));
      int distinctColors=history.size();
      numerator=numerator.add(count.multiply(BigInteger.valueOf(distinctColors)));
    }
    else if(history.size()<NUM_COLORS){
      for(int i=Math.min(limit,remain); i>0 ; i--){
        history.push(i);
        explore(remain-i,i,history);
        history.pop();
      }
    }
  }
  private static BigInteger divideExactly(BigInteger x,BigInteger y){
    BigInteger[] temp=x.divideAndRemainder(y);
    if(temp[1] .signum()!=0)throw new IllegalArgumentException("Not divisible");
    return temp[0];
  }
}
------------------------------------------------------------
OCL File:
---------
 class p493 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p493.newp493().run()) );
  static    attribute NUM_COLORS : int := 7;
  static    attribute BALLS_PER_COLOR : int := 10;
  static    attribute NUM_PICKED : int := 20;
   attribute numerator : long := 0;
   operation run() : String
  pre: true
  post: true
  activity: (     execute explore(NUM_PICKED, BALLS_PER_COLOR, Sequence{}) ; 
     var denominator : long ; denominator := Library.binomial(NUM_COLORS * BALLS_PER_COLOR, NUM_PICKED) ;
    var num : double ; num := double(numerator) ;
    var den : double ; den := double(denominator) ;
    return num.divide(den, 9, RoundingMode.HALF_EVEN)+"" 
 );
   operation explore( remain : int, limit : int, history : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (remain = 0) then (     var hist : Sequence(int) ; hist := Integer.subrange(1,NUM_COLORS)->collect(0) ;
         var i : int ; i := 0 ; while i < history->size() do (     hist[i+1] := history->at(i+1) ;  ;     i := i + 1 ) ; 
    var histogram : Sequence(int) ; histogram := Integer.subrange(1,BALLS_PER_COLOR + 1)->collect(0) ;
    for (x : hist) do (     histogram[x+1] := histogram[x+1] + 1 ;  ) ; 
    var count : long ; count := Library.factorial(NUM_COLORS) ;
    for (x : histogram) do (     count := divideExactly(count, Library.factorial(x)) ;  ) ; 
    for (x : hist) do (     count := count.multiply(Library.binomial(BALLS_PER_COLOR, x)) ;  ) ; 
    var distinctColors : int ; distinctColors := history->size() ;
    numerator := numerator->excludes(count.multiply((distinctColors + "")->toLong())) ; 
 ) else     if (history->size() < NUM_COLORS) then (         var i : int ; i := Set{limit, remain}->min() ; while i > 0 do ( (     history := history->append(i) ; 
     execute explore(remain - i, i, history) ; 
     history := history->front() )  ;     i := i - 1 ) ) else skip ; );
  static   operation divideExactly( x : long, y : long) : long
  pre: true
  post: true
  activity: (     var temp : Sequence(long) ; temp := x.divideAndRemainder(y) ;
     if (temp[1+1].signum() /= 0) then     error IllegalArgumentException.newIllegalArgumentException("Not divisible") ; else skip ; 
     return temp[0+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class minister {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String s=br.readLine();
    String[] ss=s.trim().split(" ");
    int seat=Integer.parseInt(ss[0]);
    ArrayList<Integer>arl=new ArrayList<Integer>();
    arl.add(1);
    int total=seat ;
    int maj=seat ;
    for(int i=1 ; i<n ; i++){
      int k=Integer.parseInt(ss[i]);
      if(2*k<=seat){
        total+=k ;
        arl.add(i+1);
      }
      maj+=k ;
    }
    if(maj % 2!=0){
      maj+=1 ;
    }
    else {
      maj+=2 ;
    }
    if(total>=(maj/2)){
      System.out.println(arl.size());
      for(int i=0 ; i<arl.size(); i++){
        System.out.print(arl.get(i)+" ");
      }
      System.out.println();
    }
    else {
      System.out.println("0");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class minister {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var s : String ; s := br.readLine() ;
    var ss : Sequence(String) ; ss := s->trim()->split(" ") ;
    var seat : int ; seat := (ss[0+1])->toInteger() ;
    var arl : Sequence(int) ; arl := Sequence{} ;
    arl := arl->including(1) ; 
    var total : int ; total := seat ;
    var maj : int ; maj := seat ;
        var i : int ; i := 1 ; while i < n do ( (     var k : int ; k := (ss[i+1])->toInteger() ;
     if (2 * k <= seat) then (     total := total+(k) ; 
     arl := arl->including(i + 1) ) else skip ; 
     maj := maj+(k) )  ;     i := i + 1 ) ; 
    if (maj mod 2 /= 0) then (     maj := maj+(1) ) else (     maj := maj+(2) ) ;  
    if (total >= (maj / 2)) then (     OclFile["System.out"].println(arl->size()) ; 
         var i : int ; i := 0 ; while i < arl->size() do ( (     OclFile["System.out"].print(arl->at(i+1) + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) else (     OclFile["System.out"].println("0") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int __gcd(int a,int b){
    if(a==0)return b ;
    return __gcd(b % a,a);
  }
  static int LCM(int den[],int N){
    int ans=den[0];
    for(int i=1 ; i<N ; i++)ans=(((den[i]*ans))/(__gcd(den[i],ans)));
    return ans ;
  }
  static int HCF(int num[],int N){
    int ans=num[0];
    for(int i=1 ; i<N ; i++)ans=__gcd(num[i],ans);
    return ans ;
  }
  static void HCFOfFractions(int num[],int den[],int N){
    int Numerator=HCF(num,N);
    int Denominator=LCM(den,N);
    int result=__gcd(Numerator,Denominator);
    Numerator=Numerator/result ;
    Denominator=Denominator/result ;
    System.out.println("HCF is="+Numerator+"/"+Denominator);
  }
  public static void main(String[] args){
    int num[]={
      24,48,72,96 },den[]={
        2,6,8,3 };
        int N=num.length ;
        HCFOfFractions(num,den,N);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return __gcd(b mod a, a) );
  static   operation LCM( den : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := den[0+1] ;
         var i : int ; i := 1 ; while i < N do (     ans := (((den[i+1] * ans)) / (__gcd(den[i+1], ans))) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation HCF( num : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := num[0+1] ;
         var i : int ; i := 1 ; while i < N do (     ans := __gcd(num[i+1], ans) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation HCFOfFractions( num : Sequence(int), den : Sequence(int), N : int) : void
  pre: true
  post: true
  activity: (     var Numerator : int ; Numerator := HCF(num, N) ;
     var Denominator : int ; Denominator := LCM(den, N) ;
    var result : int ; result := __gcd(Numerator, Denominator) ;
    Numerator := Numerator / result ; 
    Denominator := Denominator / result ; 
    OclFile["System.out"].println("HCF is=" + Numerator + "/" + Denominator) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : Sequence(int) ; num := Sequence{24,48,72,96} ;
    var den : Sequence(void) ; den := Sequence{2,6,8,3} ;
     var N : int ; N := num->size() ;
     execute HCFOfFractions(num, den, N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int PowerOFPINnfactorial(int n,int p){
    int ans=0 ;
    int temp=p ;
    while(temp<=n){
      ans+=n/temp ;
      temp=temp*p ;
    }
    return ans ;
  }
  public static void main(String[] args){
    System.out.println(PowerOFPINnfactorial(4,2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation PowerOFPINnfactorial( n : int, p : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var temp : int ; temp := p ;
     while (temp <= n) do (     ans := ans+(n / temp) ; 
     temp := temp * p ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(PowerOFPINnfactorial(4, 2)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int PowerOFPINnfactorial(int n,int p){
    int ans=0 ;
    for(int i=1 ; i<=n ; i++){
      int count=0,temp=i ;
      while(temp % p==0){
        count++;
        temp=temp/p ;
      }
      ans+=count ;
    }
    return ans ;
  }
  public static void main(String[] args){
    System.out.println(PowerOFPINnfactorial(4,2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation PowerOFPINnfactorial( n : int, p : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     var count : int ; count := 0 ;
    var temp : int ; temp := i ;
     while (temp mod p = 0) do (     count := count + 1 ; 
     temp := temp / p ) ; 
     ans := ans+(count) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(PowerOFPINnfactorial(4, 2)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    String t=sc.nextLine();
    String u=s+s ;
    if(u.contains(t)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var t : String ; t := sc.nextLine() ;
    var u : String ; u := s + s ;
    if (u->includes(t)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.stream.IntStream ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.util.InputMismatchException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BStringRotation solver=new BStringRotation();
    solver.solve(1,in,out);
    out.close();
  }
  static class BStringRotation {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      String s=in.nextString();
      String t=in.nextString();
      out.println(IntStream.range(0,s.length()).anyMatch(i->t.equals(s.substring(i,s.length())+s.substring(0,i)))? "Yes" : "No");
    }
  }
  static class InputReader {
    private BufferedReader br ;
    private StringTokenizer st ;
    public InputReader(InputStream inputStream){
      br=new BufferedReader(new InputStreamReader(inputStream));
      st=new StringTokenizer("");
    }
    public String nextString(){
      while(! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine()," ");
        }
        catch(IOException e){
          throw new InputMismatchException();
        }
      }
      return st.nextToken();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BStringRotation ; solver := BStringRotation.newBStringRotation() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BStringRotation {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.nextString() ;
     var t : String ; t := in.nextString() ;
     skip );
}
  static class InputReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newInputReader( inputStream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) ; 
     st := OclIterator.newOclIterator_String("") );
   operation nextString() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String_String(br.readLine(), " ") )   catch (e : IOException) do (     error IncorrectElementException() )
 ) ; 
     return st.next() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import static java.lang.Math.*;
public class Main {
  static boolean check(String a,String b){
    if(a.length()!=b.length())return false ;
    for(int i=0 ; i<a.length(); i++){
      if(a.charAt(i)==b.charAt(0)&&(a.substring(i,a.length())+a.substring(0,i)).equals(b)){
        return true ;
      }
    }
    return false ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String a=in.nextLine();
    String b=in.nextLine();
    System.out.println(check(a,b)? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation check( a : String, b : String) : boolean
  pre: true
  post: true
  activity: (     if (a->size() /= b->size()) then     return false else skip ; 
         var i : int ; i := 0 ; while i < a->size() do ( (     if (a->at(i+1) = b->at(0+1) & (a.subrange(i+1,a->size()) + a.subrange(0+1,i)) = b) then (     return true ) else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := in.nextLine() ;
     var b : String ; b := in.nextLine() ;
     OclFile["System.out"].println(if check(a, b) then "Yes" else "No" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String t=sc.next();
    String result="No" ;
    for(int i=0 ; i<s.length(); i++){
      if(t.equals(s)){
        result="Yes" ;
      }
      s=turn(s);
    }
    System.out.println(result);
  }
  static String turn(String s){
    String end=s.substring(s.length()-1,s.length());
    String tmp=end+s ;
    return tmp.substring(0,tmp.length()-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var result : String ; result := "No" ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (t = s) then (     result := "Yes" ) else skip ; 
     s := turn(s) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation turn( s : String) : String
  pre: true
  post: true
  activity: (     var end : String ; end := s.subrange(s->size() - 1+1,s->size()) ;
     var tmp : String ; tmp := end + s ;
     return tmp.subrange(0+1,tmp->size() - 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String t=sc.next();
    int leng=s.length();
    for(int i=0 ; i<leng ; i++){
      if(s.equals(t)){
        System.out.println("Yes");
        System.exit(0);
      }
      String a=t.substring(leng-1,leng);
      String b=t.substring(0,leng-1);
      t=a+b ;
    }
    System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var leng : int ; leng := s->size() ;
        var i : int ; i := 0 ; while i < leng do ( (     if (s = t) then (     OclFile["System.out"].println("Yes") ; 
 OclProcess.exit(0) ) else skip ; 
     var a : String ; a := t.subrange((leng)->char2byte() - 1+1,leng) ;
     var b : String ; b := t.subrange(0+1,(leng)->char2byte() - 1) ;
     t := a + b )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("No") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import java.awt.Point ;
import java.io.*;
public class Exercise {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int landings=sc.nextInt();
    int time=sc.nextInt();
    int minutes[]=new int[landings];
    for(int i=0 ; i<landings ; i++){
      int hours=sc.nextInt()*60 ;
      int minute=sc.nextInt();
      minutes[i]=minute+hours ;
    }
    if(time+1<=minutes[0]){
      System.out.println(0+" "+0);
      return ;
    }
    for(int i=0 ; i<landings-1 ; i++){
      if(minutes[i+1]-minutes[i]>=2*time+2){
        int flight=minutes[i]+time+1 ;
        int h=flight/60 ;
        int m=flight % 60 ;
        System.out.println(h+" "+m);
        return ;
      }
    }
    int flight=minutes[landings-1]+time+1 ;
    int h=flight/60 ;
    int m=flight % 60 ;
    System.out.println(h+" "+m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Exercise {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var landings : int ; landings := sc.getCurrent()->toInteger() ;
    var time : int ; time := sc.getCurrent()->toInteger() ;
    var minutes : Sequence(int) ; minutes := Integer.subrange(1,landings)->collect(0) ;
        var i : int ; i := 0 ; while i < landings do ( (     var hours : int ; hours := sc.getCurrent()->toInteger() * 60 ;
     var minute : int ; minute := sc.getCurrent()->toInteger() ;
     minutes[i+1] := minute + hours )  ;     i := i + 1 ) ; 
    if (time + 1 <= minutes[0+1]) then (     OclFile["System.out"].println(0 + " " + 0) ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < landings - 1 do ( (     if (minutes[i + 1+1] - minutes[i+1] >= 2 * time + 2) then (     var flight : int ; flight := minutes[i+1] + time + 1 ;
     var h : int ; h := flight / 60 ;
    var m : int ; m := flight mod 60 ;
    OclFile["System.out"].println(h + " " + m) ; 
    return 
 ) else skip )  ;     i := i + 1 ) ; 
    var flight : int ; flight := minutes[landings - 1+1] + time + 1 ;
    var h : int ; h := flight / 60 ;
    var m : int ; m := flight mod 60 ;
    OclFile["System.out"].println(h + " " + m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void sortWithRemainderP(int arr[],int n,int k,int p){
    Vector<Integer>v1=new Vector<Integer>();
    Vector<Integer>v2=new Vector<Integer>();
    for(int i=0 ; i<n ; i++){
      if(arr[i] % k==p){
        v1.add(i);
        v2.add(arr[i]);
      }
    }
    Collections.sort(v2);
    for(int i=0 ; i<v1.size(); i++)arr[v1.get(i)]=v2.get(i);
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String[] args){
    int arr[]={
      8,255,16,2,4,0 };
      int n=arr.length ;
      int k=2 ;
      int p=0 ;
      sortWithRemainderP(arr,n,k,p);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sortWithRemainderP( arr : Sequence(int), n : int, k : int, p : int) : void
  pre: true
  post: true
  activity: (     var v1 : Sequence(int) ; v1 := Sequence{} ;
     var v2 : Sequence(int) ; v2 := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod k = p) then (     v1 := v1->including(i) ; 
     v2 := v2->including(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    v2 := v2->sort() ; 
        var i : int ; i := 0 ; while i < v1->size() do (     arr[v1->at(i+1)+1] := v2->at(i+1) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,255,16,2,4,0} ;
     var n : int ; n := arr->size() ;
    var k : int ; k := 2 ;
    var p : int ; p := 0 ;
    execute sortWithRemainderP(arr, n, k, p) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void removeAnagrams(String arr[],int N){
    Vector<String>ans=new Vector<String>();
    HashSet<String>found=new HashSet<String>();
    for(int i=0 ; i<N ; i++){
      String word=arr[i];
      word=sort(word);
      if(! found.contains(word)){
        ans.add(arr[i]);
        found.add(word);
      }
    }
    Collections.sort(ans);
    for(int i=0 ; i<ans.size(); ++i){
      System.out.print(ans.get(i)+" ");
    }
  }
  static String sort(String inputString){
    char tempArray[]=inputString.toCharArray();
    Arrays.sort(tempArray);
    return new String(tempArray);
  }
  public static void main(String[] args){
    String arr[]={
      "geeks","keegs","code","doce" };
      int N=4 ;
      removeAnagrams(arr,N);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation removeAnagrams( arr : Sequence(String), N : int) : void
  pre: true
  post: true
  activity: (     var ans : Sequence(String) ; ans := Sequence{} ;
     var found : Set(String) ; found := Set{} ;
        var i : int ; i := 0 ; while i < N do ( (     var word : String ; word := arr[i+1] ;
     word := sort(word) ; 
     if (not(found->includes(word))) then (     ans := ans->including(arr[i+1]) ; 
     found := found->including(word) ) else skip )  ;     i := i + 1 ) ; 
    ans := ans->sort() ; 
        var i : int ; i := 0 ; while i < ans->size() do ( (     OclFile["System.out"].print(ans->at(i+1) + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation sort( inputString : String) : String
  pre: true
  post: true
  activity: (     var tempArray : Sequence(String) ; tempArray := inputString->characters() ;
     tempArray := tempArray->sort() ; 
     return StringLib.newString(tempArray) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"geeks","keegs","code","doce"} ;
     var N : int ; N := 4 ;
     execute removeAnagrams(arr, N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long countStrs(int n){
    long[][] dp=new long[n+1][27];
    for(int i=0 ; i<n+1 ; i++){
      for(int j=0 ; j<27 ; j++){
        dp[i][j]=0 ;
      }
    }
    for(int i=0 ; i<=25 ; i++){
      dp[1][i]=1 ;
    }
    for(int i=2 ; i<=n ; i++){
      for(int j=0 ; j<=25 ; j++){
        if(j==0){
          dp[i][j]=dp[i-1][j+1];
        }
        else {
          dp[i][j]=(dp[i-1][j-1]+dp[i-1][j+1]);
        }
      }
    }
    long sum=0 ;
    for(int i=0 ; i<=25 ; i++){
      sum=(sum+dp[n][i]);
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println("Total strings are : "+countStrs(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countStrs( n : int) : long
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,27)->collect(0)) ;
         var i : int ; i := 0 ; while i < n + 1 do ( (         var j : int ; j := 0 ; while j < 27 do ( (     dp[i+1][j+1] := 0 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= 25 do ( (     dp[1+1][i+1] := 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= 25 do ( (     if (j = 0) then (     dp[i+1][j+1] := dp[i - 1+1][j + 1+1] ) else (     dp[i+1][j+1] := (dp[i - 1+1][j - 1+1] + dp[i - 1+1][j + 1+1]) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i <= 25 do ( (     sum := (sum + dp[n+1][i+1]) )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println("Total strings are : " + countStrs(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isValidISBN(String isbn){
    int n=isbn.length();
    if(n!=10)return false ;
    int sum=0 ;
    for(int i=0 ; i<9 ; i++){
      int digit=isbn.charAt(i)-'0' ;
      if(0>digit || 9<digit)return false ;
      sum+=(digit*(10-i));
    }
    char last=isbn.charAt(9);
    if(last!='X' &&(last<'0' || last>'9'))return false ;
    sum+=((last=='X')? 10 :(last-'0'));
    return(sum % 11==0);
  }
  public static void main(String[] args){
    String isbn="007462542X" ;
    if(isValidISBN(isbn))System.out.print("Valid");
    else System.out.print("Invalid");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isValidISBN( isbn : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := isbn->size() ;
     if (n /= 10) then     return false else skip ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 9 do ( (     var digit : int ; digit := isbn->at(i+1) - ('0')->char2byte() ;
     if (0 > digit or 9 < digit) then     return false else skip ; 
     sum := sum+((digit * (10 - i))) )  ;     i := i + 1 ) ; 
    var last : String ; last := isbn->at(9+1) ;
    if (last /= 'X' & (last < '0' or last > '9')) then     return false else skip ; 
    sum := sum+((if (last = 'X') then 10 else ((last)->char2byte() - ('0')->char2byte()) endif)) ; 
    return (sum mod 11 = 0) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isbn : String ; isbn := "007462542X" ;
     if (isValidISBN(isbn)) then     OclFile["System.out"].print("Valid") ; else     OclFile["System.out"].print("Invalid") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static long ll ;
  static boolean is_power_of_two(long n){
    return false ;
  }
  static int countSubArrays(int arr[],int n){
    int cnt=0 ;
    for(int j=0 ; j<n ; j++){
      long xorval=0 ;
      for(int k=j ; k<n ; k++){
        long num=1<<arr[k];
        xorval ^=num ;
        if(xorval==0 || is_power_of_two(xorval))cnt++;
      }
    }
    return cnt ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,1,2,3,4 };
      int n=arr.length ;
      System.out.println(countSubArrays(arr,n)+"1");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GfG {
  static   attribute ll : long;
  static   operation is_power_of_two( n : long) : boolean
  pre: true
  post: true
  activity: (     return false );
  static   operation countSubArrays( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     var xorval : long ; xorval := 0 ;
         var k : int ; k := j ; while k < n do ( (     var num : long ; num := (1*(2->pow(arr[k+1])))->oclAsType(long) ;
     xorval := MathLib.bitwiseXor(xorval,num) ; 
     if (xorval = 0 or is_power_of_two(xorval)) then     cnt := cnt + 1 ; else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,1,2,3,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countSubArrays(arr, n) + "1") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int c=sc.nextInt();
    int[] maxes=new int[c+1];
    for(int i=1 ; i<=c ; i++){
      maxes[i]=sc.nextInt();
    }
    PriorityQueue<Ball>queue=new PriorityQueue<>();
    for(int i=0 ; i<n ; i++){
      queue.add(new Ball(sc.nextInt(),sc.nextInt()));
    }
    long total=0 ;
    while(queue.size()>0 && m>0){
      Ball b=queue.poll();
      if(maxes[b.color]==0){
        continue ;
      }
      maxes[b.color]--;
      total+=b.value ;
      m--;
    }
    System.out.println(total);
  }
  static class Ball implements Comparable<Ball>{
    int color ;
    int value ;
    public Ball(int color,int value){
      this.color=color ;
      this.value=value ;
    }
    public int compareTo(Ball another){
      return another.value-value ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var maxes : Sequence(int) ; maxes := Integer.subrange(1,c + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= c do ( (     maxes[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var queue : Sequence(Ball) ; queue := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     queue := queue->including(Ball.newBall(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var total : long ; total := 0 ;
    while (queue->size() > 0 & m > 0) do (     var b : Ball ; b := queue->min() ;
     if (maxes[b.color+1] = 0) then (     continue ) else skip ; 
    maxes[b.color+1] := maxes[b.color+1] - 1 ; 
    total := total+(b.value) ; 
    m := m - 1 ; 
 ) ; 
    OclFile["System.out"].println(total) ; 
 );
  static class Ball implements Comparable<Ball> {
   attribute color : int;
   attribute value : int;
   static operation newBall( color : int, value : int) : Ball
  pre: true
  post: true
  activity:
  ( var self : Ball ;
    self := createBall();
    self.initialise(color, value);
    return self );
  operation initialise( color : int, value : int) : void
  pre: true  post: true
  activity: (     self.color := color ; 
     self.value := value );
   operation compareTo( another : Ball) : int
  pre: true
  post: true
  activity: (     return another.value - value );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
public class CodeForce {
  public static int findmin(int[] arr){
    int sum=0 ;
    for(int i=1 ; i<arr.length ; i++){
      int count=0 ;
      while(i<arr.length && arr[i]==0){
        i++;
        count++;
      }
      if(count % 2!=0){
        sum=sum+count/2+1 ;
      }
      else sum=sum+count/2 ;
    }
    return sum ;
  }
  public static int findmax(int[] arr){
    int sum=0 ;
    for(int i=1 ; i<arr.length ; i++){
      int count=0 ;
      while(i<arr.length && arr[i]==0){
        i++;
        count++;
      }
      sum=sum+count ;
    }
    return sum ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sr=br.readLine().split(" ");
    int x=Integer.parseInt(sr[0]);
    int k=Integer.parseInt(sr[1]);
    int[] count=new int[x];
    for(int i=0 ; i<k ; i++){
      sr=br.readLine().split(" ");
      int a=Integer.parseInt(sr[0]);
      int b=Integer.parseInt(sr[1]);
      if(a==1){
        int c=Integer.parseInt(sr[2]);
        count[c]++;
        count[b]++;
      }
      else {
        count[b]++;
      }
    }
    System.out.print(findmin(count)+" ");
    System.out.print(findmax(count));
    System.out.println("");
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForce {
  static   operation findmin( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i < arr->size() do ( (     var count : int ; count := 0 ;
     while (i < arr->size() & arr[i+1] = 0) do (     i := i + 1 ; 
     count := count + 1 ) ; 
     if (count mod 2 /= 0) then (     sum := sum + count / 2 + 1 ) else     sum := sum + count / 2 ; )  ;     i := i + 1 ) ; 
     return sum );
  static   operation findmax( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i < arr->size() do ( (     var count : int ; count := 0 ;
     while (i < arr->size() & arr[i+1] = 0) do (     i := i + 1 ; 
     count := count + 1 ) ; 
     sum := sum + count )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sr : Sequence(String) ; sr := br.readLine()->split(" ") ;
    var x : int ; x := (sr[0+1])->toInteger() ;
    var k : int ; k := (sr[1+1])->toInteger() ;
    var count : Sequence(int) ; count := Integer.subrange(1,x)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     sr := br.readLine()->split(" ") ; 
     var a : int ; a := (sr[0+1])->toInteger() ;
     var b : int ; b := (sr[1+1])->toInteger() ;
     if (a = 1) then (     var c : int ; c := (sr[2+1])->toInteger() ;
     count[c+1] := count[c+1] + 1 ; 
     count[b+1] := count[b+1] + 1 ) else (     count[b+1] := count[b+1] + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(findmin(count) + " ") ; 
    OclFile["System.out"].print(findmax(count)) ; 
    OclFile["System.out"].println("") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SREUJA_AND_CONTEST {
  public static void main(String[] args){
    Scanner nik=new Scanner(System.in);
    int n=nik.nextInt();
    int x=nik.nextInt();
    boolean b[]=new boolean[n+1];
    for(int i=0 ; i<x ; i++){
      int t=nik.nextInt();
      if(t==2){
        b[nik.nextInt()]=true ;
      }
      else {
        b[nik.nextInt()]=true ;
        b[nik.nextInt()]=true ;
      }
    }
    int min=0,max=0 ;
    for(int i=1 ; i<n ; i++){
      if(i+1<n && b[i]==false && b[i+1]==false){
        min+=1 ;
        max+=2 ;
        i+=1 ;
      }
      else if(b[i]==false){
        max+=1 ;
        min++;
      }
    }
    System.out.println(min+" "+max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class SREUJA_AND_CONTEST {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var nik : OclFile ; nik := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := nik.getCurrent()->toInteger() ;
    var x : int ; x := nik.getCurrent()->toInteger() ;
    var b : Sequence(boolean) ; b := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 0 ; while i < x do ( (     var t : int ; t := nik.getCurrent()->toInteger() ;
     if (t = 2) then (     b[nik.getCurrent()->toInteger()+1] := true ) else (     b[nik.getCurrent()->toInteger()+1] := true ; 
     b[nik.getCurrent()->toInteger()+1] := true ) )  ;     i := i + 1 ) ; 
    var min : int ; min := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (i + 1 < n & b[i+1] = false & b[i + 1+1] = false) then (     min := min+(1) ; 
     max := max+(2) ; 
     i := i+(1) ) else     if (b[i+1] = false) then (     max := max+(1) ; 
     min := min + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min + " " + max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B_Sereja_and_Contests {
  static Scanner in=new Scanner(System.in);
  static int x,k ;
  static boolean contest[];
  static void solve(){
    int min_contest=0,max_contest=0 ;
    int organaize_contest=1 ;
    while(organaize_contest<x){
      if(! contest[organaize_contest]){
        if(organaize_contest+1<x && ! contest[organaize_contest+1]){
          contest[organaize_contest]=true ;
          contest[organaize_contest+1]=true ;
          max_contest+=2 ;
          min_contest+=1 ;
          organaize_contest+=2 ;
        }
        else {
          contest[organaize_contest++]=true ;
          max_contest++;
          min_contest++;
        }
      }
      else {
++organaize_contest ;
      }
    }
    System.out.println(min_contest+" "+max_contest);
  }
  public static void main(String[] amit){
    x=in.nextInt();
    k=in.nextInt();
    contest=new boolean[x+1];
    for(int i=0 ; i<k ; ++i){
      int type=in.nextInt();
      if(type==1){
        contest[in.nextInt()]=true ;
        contest[in.nextInt()]=true ;
      }
      else {
        contest[in.nextInt()]=true ;
      }
    }
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Sereja_and_Contests {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute x : int;
  static   attribute contest : Sequence(boolean);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var min_contest : int ; min_contest := 0 ;
    var max_contest : int ; max_contest := 0 ;
     var organaize_contest : int ; organaize_contest := 1 ;
     while (organaize_contest < x) do (     if (not(contest[organaize_contest+1])) then (     if (organaize_contest + 1 < x & not(contest[organaize_contest + 1+1])) then (     contest[organaize_contest+1] := true ; 
     contest[organaize_contest + 1+1] := true ; 
    max_contest := max_contest+(2) ; 
    min_contest := min_contest+(1) ; 
    organaize_contest := organaize_contest+(2) ; 
 ) else (      contest[organaize_contest+1] := true  ; organaize_contest := organaize_contest + 1 ; 
     max_contest := max_contest + 1 ; 
     min_contest := min_contest + 1 ) ) else (     organaize_contest := organaize_contest + 1 ) ) ; 
     OclFile["System.out"].println(min_contest + " " + max_contest) );
  static   operation main( amit : Sequence(String)) : void
  pre: true
  post: true
  activity: (     x := in.getCurrent()->toInteger() ; 
     k := in.getCurrent()->toInteger() ; 
    contest := Integer.subrange(1,x + 1)->collect(false) ; 
        var i : int ; i := 0 ; while i < k do ( (     var type : int ; type := in.getCurrent()->toInteger() ;
     if (type = 1) then (     contest[in.getCurrent()->toInteger()+1] := true ; 
     contest[in.getCurrent()->toInteger()+1] := true ) else (     contest[in.getCurrent()->toInteger()+1] := true ) )  ;     i := i + 1 ) ; 
    execute solve() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Answer {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=sc.nextInt(),s=sc.nextInt();
    int[] times=new int[n];
    for(int i=0 ; i<n ; i++){
      int h=sc.nextInt();
      int m=sc.nextInt();
      times[i]=h*60+m ;
    }
    if(times[0]>=s+1)pw.println("0 0");
    else {
      boolean flag=false ;
      for(int i=0 ; i<n-1 ; i++){
        if(times[i+1]-times[i]>=2*s+2){
          times[i]+=s+1 ;
          pw.println((times[i]/60)+" "+(times[i] % 60));
          flag=true ;
          break ;
        }
      }
      if(! flag){
        times[n-1]+=s+1 ;
        pw.println((times[n-1]/60)+" "+(times[n-1] % 60));
      }
    }
    pw.close();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Answer {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var times : Sequence(int) ; times := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var h : int ; h := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     times[i+1] := h * 60 + m )  ;     i := i + 1 ) ; 
    if (times[0+1] >= s + 1) then     skip else (     var flag : boolean ; flag := false ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     if (times[i + 1+1] - times[i+1] >= 2 * s + 2) then (     times[i+1] := times[i+1]+(s + 1) ; 
     skip ; 
     flag := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (not(flag)) then (     times[n - 1+1] := times[n - 1+1]+(s + 1) ; 
     skip ) else skip ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void sieve(boolean[] primes,int x){
    primes[1]=true ;
    for(int i=2 ; i*i<=x ; i++){
      if(primes[i]==false){
        for(int j=2 ; j*i<=x ; j++)primes[i*j]=true ;
      }
    }
  }
  static int nDivisors(boolean[] primes,int x,int a,int b,int n){
    int result=0 ;
    ArrayList<Integer>v=new ArrayList<Integer>();
    for(int i=2 ; i<=x ; i++)if(primes[i]==false)v.add(i);
    for(int i=a ; i<=b ; i++){
      int temp=i ;
      int total=1 ;
      int j=0 ;
      for(int k=v.get(j); k*k<=temp ; k=v.get(++j)){
        int count=0 ;
        while(temp % k==0){
          count++;
          temp=temp/k ;
        }
        total=total*(count+1);
      }
      if(temp!=1)total=total*2 ;
      if(total==n)result++;
    }
    return result ;
  }
  static int countNDivisors(int a,int b,int n){
    int x=(int)Math.sqrt(b)+1 ;
    boolean[] primes=new boolean[x+1];
    sieve(primes,x);
    return nDivisors(primes,x,a,b,n);
  }
  public static void main(String[] args){
    int a=1,b=7,n=2 ;
    System.out.println(countNDivisors(a,b,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sieve( primes : Sequence(boolean), x : int) : void
  pre: true
  post: true
  activity: (     primes[1+1] := true ; 
         var i : int ; i := 2 ; while i * i <= x do ( (     if (primes[i+1] = false) then (         var j : int ; j := 2 ; while j * i <= x do (     primes[i * j+1] := true ;  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) );
  static   operation nDivisors( primes : Sequence(boolean), x : int, a : int, b : int, n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var v : Sequence(int) ; v := Sequence{} ;
        var i : int ; i := 2 ; while i <= x do (     if (primes[i+1] = false) then     v := v->including(i) ; else skip ;  ;     i := i + 1 ) ; 
        var i : int ; i := a ; while i <= b do ( (     var temp : int ; temp := i ;
     var total : int ; total := 1 ;
    var j : int ; j := 0 ;
        var k : int ; k := v->at(j+1) ; while k * k <= temp do ( (     var count : int ; count := 0 ;
     while (temp mod k = 0) do (     count := count + 1 ; 
     temp := temp / k ) ; 
     total := total * (count + 1) )  ;     k := v->at((j + 1)+1) ) ; 
    if (temp /= 1) then     total := total * 2 ; else skip ; 
    if (total = n) then     result := result + 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation countNDivisors( a : int, b : int, n : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := (b)->sqrt()->oclAsType(int) + 1 ;
     var primes : Sequence(boolean) ; primes := Integer.subrange(1,x + 1)->collect(false) ;
     execute sieve(primes, x) ; 
     return nDivisors(primes, x, a, b, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 1 ;
    var b : int ; b := 7 ;
    var n : int ; n := 2 ;
     OclFile["System.out"].println(countNDivisors(a, b, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class SmallPrime {
  static boolean isPrime(int n){
    int i,c=0 ;
    for(i=1 ; i<n/2 ; i++){
      if(n % i==0)c++;
    }
    if(c==1){
      return true ;
    }
    else {
      return false ;
    }
  }
  static void findMinNum(int arr[],int n){
    int first=0,last=0,num,rev,i ;
    int hash[]=new int[10];
    for(i=0 ; i<n ; i++){
      hash[arr[i] ]++;
    }
    System.out.print("Minimum number: ");
    for(i=0 ; i<=9 ; i++){
      for(int j=0 ; j<hash[i]; j++)System.out.print(i);
    }
    System.out.println();
    System.out.println();
    for(i=0 ; i<=9 ; i++){
      if(hash[i]!=0){
        first=i ;
        break ;
      }
    }
    for(i=9 ; i>=0 ; i--){
      if(hash[i]!=0){
        last=i ;
        break ;
      }
    }
    num=first*10+last ;
    rev=last*10+first ;
    System.out.print("Prime combinations: ");
    if(isPrime(num)&& isPrime(rev)){
      System.out.println(num+" "+rev);
    }
    else if(isPrime(num)){
      System.out.println(num);
    }
    else if(isPrime(rev)){
      System.out.println(rev);
    }
    else {
      System.out.println("No combinations exist");
    }
  }
  public static void main(String[] args){
    SmallPrime smallprime=new SmallPrime();
    int arr[]={
      1,2,4,7,8 };
      smallprime.findMinNum(arr,5);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class SmallPrime {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ;
    var c : int ; c := 0 ;
         i := 1 ; while i < n / 2 do ( (     if (n mod i = 0) then     c := c + 1 ; else skip )  ;     i := i + 1 ) ; 
     if (c = 1) then (     return true ) else (     return false ) );
  static   operation findMinNum( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var first : int ; first := 0 ;
    var last : int ; last := 0 ;
    var num : int ;
    var rev : int ;
    var i : int ;
     var hash : Sequence(int) ; hash := Integer.subrange(1,10)->collect(0) ;
        i := 0 ; while i < n do ( (     hash[arr[i+1]+1] := hash[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("Minimum number: ") ; 
        i := 0 ; while i <= 9 do ( (         var j : int ; j := 0 ; while j < hash[i+1] do (     OclFile["System.out"].print(i) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    OclFile["System.out"].println() ; 
        i := 0 ; while i <= 9 do ( (     if (hash[i+1] /= 0) then (     first := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        i := 9 ; while i >= 0 do ( (     if (hash[i+1] /= 0) then (     last := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    num := first * 10 + last ; 
    rev := last * 10 + first ; 
    OclFile["System.out"].print("Prime combinations: ") ; 
    if (isPrime(num) & isPrime(rev)) then (     OclFile["System.out"].println(num + " " + rev) ) else     if (isPrime(num)) then (     OclFile["System.out"].println(num) ) else     if (isPrime(rev)) then (     OclFile["System.out"].println(rev) ) else (     OclFile["System.out"].println("No combinations exist") ) ;  ;  ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var smallprime : SmallPrime ; smallprime := SmallPrime.newSmallPrime() ;
     var arr : Sequence(int) ; arr := Sequence{1,2,4,7,8} ;
     smallprime.findMinNum(arr, 5) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class B873 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    in.next();
    char[] S=in.next().toCharArray();
    Map<Integer,Integer>map=new HashMap<>();
    int answer=0 ;
    int onesMinusZeros=0 ;
    map.put(onesMinusZeros,-1);
    for(int n=0 ; n<S.length ; n++){
      char c=S[n];
      if(c=='0'){
        onesMinusZeros--;
      }
      else {
        onesMinusZeros++;
      }
      Integer first=map.get(onesMinusZeros);
      if(first==null){
        map.put(onesMinusZeros,n);
      }
      else {
        answer=Math.max(answer,n-first);
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B873 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var S : Sequence(String) ; S := in.getCurrent()->characters() ;
    var map : Map(int,int) ; map := Map{} ;
    var answer : int ; answer := 0 ;
    var onesMinusZeros : int ; onesMinusZeros := 0 ;
    map := map->union(Map{onesMinusZeros |-> -1}) ; 
        var n : int ; n := 0 ; while n < S->size() do ( (     var c : String ; c := S[n+1] ;
     if (c = '0') then (     onesMinusZeros := onesMinusZeros - 1 ) else (     onesMinusZeros := onesMinusZeros + 1 ) ;  
     var first : int ; first := map->at(onesMinusZeros) ;
     if (first = null) then (     map := map->union(Map{onesMinusZeros |-> n}) ) else (     answer := Set{answer, n - (first)->char2byte()}->max() ) )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean check(String s,int m){
    int l=s.length();
    int c1=0 ;
    int c2=0 ;
    for(int i=0 ; i<l ; i++){
      if(s.charAt(i)=='0'){
        c2=0 ;
        c1++;
      }
      else {
        c1=0 ;
        c2++;
      }
      if(c1==m || c2==m)return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    String s="001001" ;
    int m=2 ;
    if(check(s,m))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( s : String, m : int) : boolean
  pre: true
  post: true
  activity: (     var l : int ; l := s->size() ;
     var c1 : int ; c1 := 0 ;
    var c2 : int ; c2 := 0 ;
        var i : int ; i := 0 ; while i < l do ( (     if (s->at(i+1) = '0') then (     c2 := 0 ; 
     c1 := c1 + 1 ) else (     c1 := 0 ; 
     c2 := c2 + 1 ) ;  
     if (c1 = m or c2 = m) then     return true else skip )  ;     i := i + 1 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "001001" ;
     var m : int ; m := 2 ;
     if (check(s, m)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static int R=100 ;
  public static int T=30 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    br.readLine();
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int r=Integer.parseInt(line.substring(0,line.indexOf(' ')));
      int t=Integer.parseInt(line.substring(line.indexOf(' ')+1));
      int[] _r=new int[2];
      int[] _t=new int[2];
      if(r % R==0){
        _r[0]=r/R ;
      }
      else {
        _r[0]=r/R ;
        _r[1]=r/R+1 ;
      }
      if(t % T==0){
        _t[0]=t/T*5 ;
      }
      else {
        _t[0]=t/T*5 ;
        _t[1]=(t/T+1)*5 ;
      }
      int[] _rt=new int[4];
      _rt[0]=_r[0]+_t[0];
      _rt[1]=_t[1]>0 ? _r[0]+_t[1] : 0 ;
      _rt[2]=_r[1]>0 ? _r[1]+_t[0] : 0 ;
      _rt[3]=_r[1]>0 && _t[1]>0 ? _r[1]+_t[1] : 0 ;
      Arrays.sort(_rt);
      for(int i=0 ; i<4 ; i++){
        if(_rt[i]>0){
          if(i>0 && _rt[i-1]>0){
            System.out.print(" ");
          }
          System.out.print(_rt[i]);
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute R : int := 100;
  static   attribute T : int := 30;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     skip ; 
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var r : int ; r := (line.subrange(0+1,line->indexOf(' ')-1))->toInteger() ;
     var t : int ; t := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1))->toInteger() ;
    var _r : Sequence(int) ; _r := Integer.subrange(1,2)->collect(0) ;
    var _t : Sequence(int) ; _t := Integer.subrange(1,2)->collect(0) ;
    if (r mod R = 0) then (     _r[0+1] := r / R ) else (     _r[0+1] := r / R ; 
     _r[1+1] := r / R + 1 ) ;  
    if (t mod T = 0) then (     _t[0+1] := t / T * 5 ) else (     _t[0+1] := t / T * 5 ; 
     _t[1+1] := (t / T + 1) * 5 ) ;  
    var _rt : Sequence(int) ; _rt := Integer.subrange(1,4)->collect(0) ;
    _rt[0+1] := _r[0+1] + _t[0+1] ; 
    _rt[1+1] := if _t[1+1] > 0 then _r[0+1] + _t[1+1] else 0 endif ; 
    _rt[2+1] := if _r[1+1] > 0 then _r[1+1] + _t[0+1] else 0 endif ; 
    _rt[3+1] := if _r[1+1] > 0 & _t[1+1] > 0 then _r[1+1] + _t[1+1] else 0 endif ; 
    _rt := _rt->sort() ; 
        var i : int ; i := 0 ; while i < 4 do ( (     if (_rt[i+1] > 0) then (     if (i > 0 & _rt[i - 1+1] > 0) then (     OclFile["System.out"].print(" ") ) else skip ; 
     OclFile["System.out"].print(_rt[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    new Main().mainrun();
  }
  Scanner scan ;
  private final int interval_deg=30 ;
  private final int interval_r=100 ;
  private int N ;
  private void mainrun(){
    scan=new Scanner(System.in);
    N=scan.nextInt();
    for(int i=0 ; i<N ; i++){
      System.out.println(looprun(scan.nextInt(),scan.nextInt()));
    }
    scan.close();
  }
  private String looprun(double r,double deg){
    String ans="" ;
    int p=(int)(r/interval_r+(int)(deg/interval_deg)*5);
    ans+=p ;
    if(r % interval_r!=0){
      ans+=" "+(p+1);
    }
    if(deg % interval_deg!=0){
      ans+=" "+(p+5);
    }
    if(deg % interval_deg!=0 && r % interval_r!=0){
      ans+=" "+(p+6);
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().mainrun() );
   attribute scan : OclFile;
   attribute interval_deg : int := 30;
   attribute interval_r : int := 100;
   attribute N : int;
   operation mainrun() : void
  pre: true
  post: true
  activity: (     scan := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     N := scan.getCurrent()->toInteger() ; 
         var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].println(looprun(scan.getCurrent()->toInteger(), scan.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
     skip );
   operation looprun( r : double, deg : double) : String
  pre: true
  post: true
  activity: (     var ans : String ; ans := "" ;
     var p : int ; p := (r / interval_r + (deg / interval_deg)->oclAsType(int) * 5)->oclAsType(int) ;
    ans := ans+(p) ; 
    if (r mod interval_r /= 0) then (     ans := ans+(" " + (p + 1)) ) else skip ; 
    if (deg mod interval_deg /= 0) then (     ans := ans+(" " + (p + 5)) ) else skip ; 
    if (deg mod interval_deg /= 0 & r mod interval_r /= 0) then (     ans := ans+(" " + (p + 6)) ) else skip ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  int CalcID(int r,int t){
    return r+5*t ;
  }
  void solve(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; ++i){
      int r=sc.nextInt();
      int t=sc.nextInt();
      boolean onR=r % 100==0 ;
      boolean onT=t % 30==0 ;
      r/=100 ;
      t/=30 ;
      if(onR && onT)System.out.println(CalcID(r,t));
      else if(onR)System.out.println(CalcID(r,t)+" "+CalcID(r,t+1));
      else if(onT)System.out.println(CalcID(r,t)+" "+CalcID(r+1,t));
      else System.out.println(CalcID(r,t)+" "+CalcID(r+1,t)+" "+CalcID(r,t+1)+" "+CalcID(r+1,t+1));
    }
  }
  public static void main(String[] a){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation CalcID( r : int, t : int) : int
  pre: true
  post: true
  activity: (     return r + 5 * t );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var r : int ; r := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var onR : boolean ; onR := r mod 100 = 0 ;
    var onT : boolean ; onT := t mod 30 = 0 ;
    r := r/(100) ; 
    t := t/(30) ; 
    if (onR & onT) then     OclFile["System.out"].println(CalcID(r, t)) else     if (onR) then     OclFile["System.out"].println(CalcID(r, t) + " " + CalcID(r, t + 1)) else     if (onT) then     OclFile["System.out"].println(CalcID(r, t) + " " + CalcID(r + 1, t)) else     OclFile["System.out"].println(CalcID(r, t) + " " + CalcID(r + 1, t) + " " + CalcID(r, t + 1) + " " + CalcID(r + 1, t + 1)) ; ;  ;  ;  
 )  ;     i := i + 1 ) );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n-->0){
      int r=sc.nextInt();
      int t=sc.nextInt();
      boolean fr=r % 100==0 ;
      boolean ft=t % 30==0 ;
      r/=100 ;
      t/=30 ;
      if(fr && ft){
        System.out.println(r+t*5);
      }
      else if(fr){
        System.out.println((r+t*5)+" "+(r+t*5+5));
      }
      else if(ft){
        System.out.println((r+t*5)+" "+(r+t*5+1));
      }
      else {
        System.out.println((r+t*5)+" "+(r+t*5+1)+" "+(r+t*5+5)+" "+(r+t*5+6));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var r : int ; r := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var fr : boolean ; fr := r mod 100 = 0 ;
    var ft : boolean ; ft := t mod 30 = 0 ;
    r := r/(100) ; 
    t := t/(30) ; 
    if (fr & ft) then (     OclFile["System.out"].println(r + t * 5) ) else     if (fr) then (     OclFile["System.out"].println((r + t * 5) + " " + (r + t * 5 + 5)) ) else     if (ft) then (     OclFile["System.out"].println((r + t * 5) + " " + (r + t * 5 + 1)) ) else (     OclFile["System.out"].println((r + t * 5) + " " + (r + t * 5 + 1) + " " + (r + t * 5 + 5) + " " + (r + t * 5 + 6)) ) ;  ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n,r,t,base ;
    n=scan.nextInt();
    for(int i=0 ; i<n ; i++){
      r=scan.nextInt();
      t=scan.nextInt();
      base=t/30*5+r/100 ;
      if(r % 100==0){
        if(t % 30==0){
          System.out.println(base);
        }
        else {
          System.out.println(base+" "+(base+5));
        }
      }
      else {
        if(t % 30==0){
          System.out.println(base+" "+(base+1));
        }
        else {
          System.out.println(base+" "+(base+1)+" "+(base+5)+" "+(base+6));
        }
      }
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var r : int ;
    var t : int ;
    var base : int ;
    n := scan.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     r := scan.getCurrent()->toInteger() ; 
     t := scan.getCurrent()->toInteger() ; 
     base := t / 30 * 5 + r / 100 ; 
     if (r mod 100 = 0) then (     if (t mod 30 = 0) then (     OclFile["System.out"].println(base) ) else (     OclFile["System.out"].println(base + " " + (base + 5)) ) ) else (     if (t mod 30 = 0) then (     OclFile["System.out"].println(base + " " + (base + 1)) ) else (     OclFile["System.out"].println(base + " " + (base + 1) + " " + (base + 5) + " " + (base + 6)) ) ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Math {
  public static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int result=sc.nextInt();
    for(int i=1 ; i<n ; i++){
      result=gcd(result,sc.nextInt());
    }
    System.out.println(result*n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Math {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var result : int ; result := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i < n do ( (     result := gcd(result, sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result * n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int k=in.nextInt();
    for(int i=0 ; i<k ; i++){
      long A=in.nextLong();
      long B=in.nextLong();
      if(B==1){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
        System.out.println(A+" "+A*B+" "+(B+1)*A);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < k do ( (     var A : long ; A := in.getCurrent()->toLong() ;
     var B : long ; B := in.getCurrent()->toLong() ;
     if (B = 1) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(A + " " + A * B + " " + (B + 1) * A) ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class cf389A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[] arr=new int[n];
    int result=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=scan.nextInt();
    }
    Arrays.sort(arr);
    while(arr[n-1]>arr[0]){
      int x=(n-2);
      int var=arr[n-1];
      while(var>0 && x>-1){
        while(var>arr[x]){
          var-=arr[x];
        }
        x--;
      }
      arr[n-1]=var ;
      Arrays.sort(arr);
    }
    System.out.println(arr[0]*n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf389A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    while (arr[n - 1+1] > arr[0+1]) do (     var x : int ; x := (n - 2) ;
     var var : int ; var := arr[n - 1+1] ;
    while (var > 0 & x > -1) do (     while (var > arr[x+1]) do (     var := var-(arr[x+1]) ) ; 
     x := x - 1 ) ; 
    arr[n - 1+1] := var ; 
    arr := arr->sort() ; 
 ) ; 
    OclFile["System.out"].println(arr[0+1] * n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class hw14 {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    {
      int n=scan.nextInt();
      int[] in=new int[n];
      for(int i=0 ; i<n ; i++){
        in[i]=scan.nextInt();
      }
      System.out.println(minDif(in)*n);
    }
  }
  public static int minDif(int[] a){
    Arrays.sort(a);
    int dif=100 ;
    for(int i=1 ; i<a.length ; i++){
      int i1=a[i]-a[i-1];
      if(i1<dif && i1!=0){
        dif=i1 ;
      }
    }
    for(int i=0 ; i<a.length ; i++){
      while(a[i] % dif!=0){
        dif=a[i] % dif ;
      }
    }
    return dif ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class hw14 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var in : Sequence(int) ; in := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     in[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(minDif(in) * n) ) );
  static   operation minDif( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var dif : int ; dif := 100 ;
        var i : int ; i := 1 ; while i < a->size() do ( (     var i1 : int ; i1 := a[i+1] - a[i - 1+1] ;
     if (i1 < dif & i1 /= 0) then (     dif := i1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     while (a[i+1] mod dif /= 0) do (     dif := a[i+1] mod dif ) )  ;     i := i + 1 ) ; 
    return dif 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=s.nextInt();
    }
    Arrays.sort(arr);
    while(arr[0]!=arr[n-1]){
      for(int i=n-1 ; i>=0 ; i--){
        for(int j=i-1 ; j>=0 ; j--){
          if(arr[i]>arr[j]){
            arr[i]=arr[i]-arr[j];
          }
        }
      }
      Arrays.sort(arr);
    }
    System.out.println(arr[0]*n);
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    while (arr[0+1] /= arr[n - 1+1]) do (         var i : int ; i := n - 1 ; while i >= 0 do ( (         var j : int ; j := i - 1 ; while j >= 0 do ( (     if (arr[i+1] > arr[j+1]) then (     arr[i+1] := arr[i+1] - arr[j+1] ) else skip )  ;     j := j - 1 ) )  ;     i := i - 1 ) ; 
     arr := arr->sort() ) ; 
    OclFile["System.out"].println(arr[0+1] * n) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    new Main().A();
  }
  public void A(){
    Scanner in=new Scanner(System.in);
    int total=in.nextInt();
    String s=in.next();
    HashMap<Integer,Integer>map=new HashMap<>();
    int ones=0,zeros=0 ;
    for(int i=0 ; i<total ; i++){
      if(s.charAt(i)=='0')zeros++;
      else ones++;
      map.put(ones-zeros,i);
    }
    int diff=0,result=0 ;
    for(int i=0 ; i<total ; i++){
      if(map.containsKey(diff)&& map.get(diff)>i)result=Math.max(result,map.get(diff)-i+1);
      if(s.charAt(i)=='1')diff++;
      else diff--;
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().A() );
   operation A() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var total : int ; total := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var map : Map(int,int) ; map := Map{} ;
    var ones : int ; ones := 0 ;
    var zeros : int ; zeros := 0 ;
        var i : int ; i := 0 ; while i < total do ( (     if (s->at(i+1) = '0') then     zeros := zeros + 1 else     ones := ones + 1 ; ;  
     map := map->union(Map{ones - zeros |-> i}) )  ;     i := i + 1 ) ; 
    var diff : int ; diff := 0 ;
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < total do ( (     if (map->keys()->includes(diff) & map->at(diff) > i) then     result := Set{result, map->at(diff) - i + 1}->max() ; else skip ; 
     if (s->at(i+1) = '1') then     diff := diff + 1 ; else     diff := diff - 1 ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class LoveSong {
  static int MAX=(int)1e+5 ;
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=sc.nextInt(),q=sc.nextInt();
    String s=sc.next();
    long[] a=new long[MAX];
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=(s.charAt(i)-96);
      a[i]=sum ;
    }
    while(q-->0){
      int l=sc.nextInt(),r=sc.nextInt();
--l ;
--r ;
      long ans=a[r];
      if(l!=0)ans-=a[--l];
      pw.println(ans);
    }
    pw.flush();
  }
  static class Scanner {
    BufferedReader br ;
    StringTokenizer st ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(FileReader f){
      br=new BufferedReader(f);
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public int[] nextIntArr(int n)throws IOException {
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=Integer.parseInt(next());
      }
      return arr ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class LoveSong {
  static   attribute MAX : int := 1e+5->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var a : Sequence(long) ; a := Integer.subrange(1,MAX)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+((s->at(i+1) - 96)) ; 
     a[i+1] := sum )  ;     i := i + 1 ) ; 
        while (q > 0) do (        q := q - 1 ;     skip ; (     var l : int ; l := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
     l := l - 1 ; 
    r := r - 1 ; 
    var ans : long ; ans := a[r+1] ;
    if (l /= 0) then         l := l - 1 ;
 ans := ans - (a[l+1])  ; else skip ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(s))) );
   static operation newScanner( f : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(f) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArr( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (next())->toInteger() )  ;     i := i + 1 ) ; 
     return arr );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B1539 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));
    int n=in.nextInt(),q=in.nextInt();
    String s=in.next();
    int[] arr=new int[s.length()+1];
    arr[0]=0 ;
    for(int i=1 ; i<=s.length(); i++)arr[i]=arr[i-1]+((int)s.charAt(i-1))-((int)'a'-1);
    while(q-->0){
      int res=0 ;
      int l=in.nextInt();
      int r=in.nextInt();
      res=arr[r]-arr[l-1];
      pw.println(res);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1539 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var q : int ; q := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,s->size() + 1)->collect(0) ;
    arr[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= s->size() do (     arr[i+1] := arr[i - 1+1] + (s->at(i - 1+1)->oclAsType(int)) - (('a')->char2byte() - 1) ;  ;     i := i + 1 ) ; 
        while (q > 0) do (        q := q - 1 ;     skip ; (     var res : int ; res := 0 ;
     var l : int ; l := in.getCurrent()->toInteger() ;
    var r : int ; r := in.getCurrent()->toInteger() ;
    res := arr[r+1] - arr[l - 1+1] ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static int lcm(int a,int b){
    return(a*b)/gcd(a,b);
  }
  static void printSum(int num1,int den1,int num2,int den2){
    int lcd=lcm(den1,den2);
    num1*=(lcd/den1);
    num2*=(lcd/den2);
    int res_num=num1+num2 ;
    System.out.print(res_num+"/"+lcd);
  }
  public static void main(String args[]){
    int num1=1,den1=6 ;
    int num2=7,den2=15 ;
    printSum(num1,den1,num2,den2);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return (a * b) / gcd(a, b) );
  static   operation printSum( num1 : int, den1 : int, num2 : int, den2 : int) : void
  pre: true
  post: true
  activity: (     var lcd : int ; lcd := lcm(den1, den2) ;
     num1 := num1*((lcd / den1)) ; 
    num2 := num2*((lcd / den2)) ; 
    var res_num : int ; res_num := num1 + num2 ;
    OclFile["System.out"].print(res_num + "/" + lcd) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num1 : int ; num1 := 1 ;
    var den1 : int ; den1 := 6 ;
     var num2 : int ; num2 := 7 ;
    var den2 : int ; den2 := 15 ;
     execute printSum(num1, den1, num2, den2) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String firstLetterWord(String str){
    String result="" ;
    boolean v=true ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)==' '){
        v=true ;
      }
      else if(str.charAt(i)!=' ' && v==true){
        result+=(str.charAt(i));
        v=false ;
      }
    }
    return result ;
  }
  public static void main(String[] args){
    String str="geeks for geeks" ;
    System.out.println(firstLetterWord(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation firstLetterWord( str : String) : String
  pre: true
  post: true
  activity: (     var result : String ; result := "" ;
     var v : boolean ; v := true ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = ' ') then (     v := true ) else     if (str->at(i+1) /= ' ' & v = true) then (     result := result+((str->at(i+1))) ; 
     v := false ) else skip ; )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeks for geeks" ;
     OclFile["System.out"].println(firstLetterWord(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String str=scan.nextLine();
    printTiles(str);
  }
  public static void printTiles(String str){
    StringBuilder sb=new StringBuilder();
    boolean vFirst=true ;
    boolean hFirst=true ;
    for(char c : str.toCharArray()){
      if(c=='0'){
        if(vFirst){
          sb.append(3).append(" ").append(1).append("\n");
        }
        else {
          sb.append(1).append(" ").append(1).append("\n");
        }
        vFirst=! vFirst ;
      }
      else {
        if(hFirst){
          sb.append(1).append(" ").append(3).append("\n");
        }
        else {
          sb.append(1).append(" ").append(1).append("\n");
        }
        hFirst=! hFirst ;
      }
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := scan.nextLine() ;
     execute printTiles(str) );
  static   operation printTiles( str : String) : void
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     var vFirst : boolean ; vFirst := true ;
    var hFirst : boolean ; hFirst := true ;
    for (c : str->characters()) do ( (     if (c = '0') then (     if (vFirst) then (     sb := sb + StringLib.newString(3) + StringLib.newString(" ") + StringLib.newString(1) + StringLib.newString("\n") ) else (     sb := sb + StringLib.newString(1) + StringLib.newString(" ") + StringLib.newString(1) + StringLib.newString("\n") ) ;  
     vFirst := not(vFirst) ) else (     if (hFirst) then (     sb := sb + StringLib.newString(1) + StringLib.newString(" ") + StringLib.newString(3) + StringLib.newString("\n") ) else (     sb := sb + StringLib.newString(1) + StringLib.newString(" ") + StringLib.newString(1) + StringLib.newString("\n") ) ;  
     hFirst := not(hFirst) ) )  ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Odd_Selection {
  public static void main(String[] args)throws Exception {
    InputStreamReader r=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(r);
    PrintWriter p=new PrintWriter(System.out);
    int test=1 ;
    me146 : while(test-->0){
      String str[]=br.readLine().trim().split("");
      int vertical=0 ;
      int horizontal=0 ;
      for(int i=0 ; i<str.length ; i++){
        if(str[i] .equals("1")){
          p.println("1 "+(horizontal==0 ? 1 : 3));
          horizontal=(horizontal+1)% 2 ;
        }
        else {
          p.println("3 "+(vertical+1));
          vertical=(vertical+1)% 4 ;
        }
      }
    }
    p.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Odd_Selection {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(r) ;
    var p : OclFile ; p := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := 1 ;
        while (test > 0) do (        test := test - 1 ;     skip ; (     var str : Sequence(String) ; str := br.readLine()->trim()->split("") ;
     var vertical : int ; vertical := 0 ;
     var horizontal : int ; horizontal := 0 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (str[i+1] = "1") then (     skip ; 
     horizontal := (horizontal + 1) mod 2 ) else (     skip ; 
     vertical := (vertical + 1) mod 4 ) )  ;     i := i + 1 ) ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void pre_process(String substrings[],String s){
    int n=s.length();
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      String dup="" ;
      for(int j=i ; j<n ; j++){
        dup+=s.charAt(j);
        substrings[count++]=dup ;
      }
    }
    int size=substrings.length ;
    for(int i=0 ; i<size-1 ; i++){
      for(int j=i+1 ; j<substrings.length ; j++){
        if(substrings[i] .compareTo(substrings[j])>0){
          String temp=substrings[i];
          substrings[i]=substrings[j];
          substrings[j]=temp ;
        }
      }
    }
  }
  public static void main(String args[]){
    String s="geek" ;
    String substrings[]=new String[10];
    pre_process(substrings,s);
    int queries[]={
      1,5,10 };
      int q=queries.length ;
      for(int i=0 ; i<q ; i++)System.out.println(substrings[queries[i]-1]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pre_process( substrings : Sequence(String), s : String) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var dup : String ; dup := "" ;
         var j : int ; j := i ; while j < n do ( (     dup := dup+(s->at(j+1)) ; 
      substrings[count+1] := dup  ; count := count + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var size : int ; size := substrings->size() ;
        var i : int ; i := 0 ; while i < size - 1 do ( (         var j : int ; j := i + 1 ; while j < substrings->size() do ( (     if (substrings[i+1]->compareTo(substrings[j+1]) > 0) then (     var temp : String ; temp := substrings[i+1] ;
     substrings[i+1] := substrings[j+1] ; 
     substrings[j+1] := temp ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geek" ;
     var substrings : Sequence(String) ; substrings := Integer.subrange(1,10)->collect(null) ;
    execute pre_process(substrings, s) ; 
    var queries : Sequence(int) ; queries := Sequence{1,5,10} ;
    var q : int ; q := queries->size() ;
        var i : int ; i := 0 ; while i < q do (     OclFile["System.out"].println(substrings[queries[i+1] - 1+1]) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
public class GridGame {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int[][] grid=new int[4][4];
    String s=br.readLine();
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='0'){
        for(int j=0 ; j<4 ; j++){
          if(grid[0][j]==0){
            pr.println(1+" "+(j+1));
            grid[0][j]=1 ;
            grid[1][j]=1 ;
            if(j==3){
              for(int k=0 ; k<=1 ; k++){
                Arrays.fill(grid[k],0);
              }
            }
            break ;
          }
        }
      }
      else {
        if(grid[3][0]==0){
          pr.println(4+" "+1);
          grid[3][1]=1 ;
          grid[3][0]=1 ;
        }
        else {
          pr.println(4+" "+3);
          Arrays.fill(grid[3],0);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GridGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var grid : Sequence(Sequence(int)) ; grid := Integer.subrange(1,4)->collect(Integer.subrange(1,4)->collect(0)) ;
     var s : String ; s := br.readLine() ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '0') then (         var j : int ; j := 0 ; while j < 4 do ( (     if (grid[0+1][j+1] = 0) then (     skip ; 
     grid[0+1][j+1] := 1 ; 
    grid[1+1][j+1] := 1 ; 
    if (j = 3) then (         var k : int ; k := 0 ; while k <= 1 do ( (     grid[k+1] := grid[k+1]->collect(0) )  ;     k := k + 1 ) ) else skip ; 
    break 
 ) else skip )  ;     j := j + 1 ) ) else (     if (grid[3+1][0+1] = 0) then (     skip ; 
     grid[3+1][1+1] := 1 ; 
     grid[3+1][0+1] := 1 ) else (     skip ; 
     grid[3+1] := grid[3+1]->collect(0) ) ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class P291B {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    String command=s.nextLine()+" " ;
    ArrayList<String>lexemes=new ArrayList<>();
    StringBuilder current=new StringBuilder("");
    boolean quote=false ;
    for(int i=0 ; i<command.length(); i++){
      if(quote){
        if(command.charAt(i)=='"'){
          quote=false ;
          lexemes.add(current.toString());
          current=new StringBuilder("");
        }
        else {
          current.append(command.charAt(i));
        }
      }
      else {
        if(command.charAt(i)=='"'){
          quote=true ;
        }
        else if(command.charAt(i)==' '){
          if(current.length()!=0){
            lexemes.add(current.toString());
            current=new StringBuilder("");
          }
        }
        else {
          current.append(command.charAt(i));
        }
      }
    }
    for(String lexeme : lexemes){
      System.out.printf("<%s>\n",lexeme);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P291B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var command : String ; command := s.nextLine() + " " ;
    var lexemes : Sequence(String) ; lexemes := Sequence{} ;
    var current : String ; current := StringLib.newString("") ;
    var quote : boolean ; quote := false ;
        var i : int ; i := 0 ; while i < command->size() do ( (     if (quote) then (     if (command->at(i+1) = '"') then (     quote := false ; \n     lexemes := lexemes->including(current+"") ; \n     current := StringLib.newString("") ) else (     current := current + StringLib.newString(command->at(i+1)) ) ) else (     if (command->at(i+1) = '"') then (     quote := true ) else     if (command->at(i+1) = ' ') then (     if (current->size() /= 0) then (     lexemes := lexemes->including(current+"") ; 
     current := StringLib.newString("") ) else skip ) else (     current := current + StringLib.newString(command->at(i+1)) ) ;  ) )  ;     i := i + 1 ) ; 
    for (lexeme : lexemes) do ( (     OclFile["System.out"].printf("<%s>\n", lexeme) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class CommandLineArgs {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String input=br.readLine();
    input+=" " ;
    boolean quoteMode=false ;
    boolean spaceMode=false ;
    StringBuilder tag=new StringBuilder("");
    for(int a=0 ; a<input.length(); a++){
      if(input.charAt(a)==' ' && ! quoteMode){
        if(spaceMode){
          System.out.println("<"+tag+">");
          spaceMode=false ;
        }
        tag=new StringBuilder("");
        continue ;
      }
      if(input.charAt(a)=='"'){
        if(quoteMode){
          System.out.println("<"+tag+">");
        }
        quoteMode=! quoteMode ;
        tag=new StringBuilder("");
        continue ;
      }
      if(! quoteMode){
        spaceMode=true ;
      }
      tag.append(input.charAt(a));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CommandLineArgs {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : String ; input := br.readLine() ;
    input := input+(" ") ; 
    var quoteMode : boolean ; quoteMode := false ;
    var spaceMode : boolean ; spaceMode := false ;
    var tag : String ; tag := StringLib.newString("") ;
        var a : int ; a := 0 ; while a < input->size() do ( (     if (input->at(a+1) = ' ' & not(quoteMode)) then (     if (spaceMode) then (     OclFile["System.out"].println("<" + tag + ">") ; 
     spaceMode := false ) else skip ; 
     tag := StringLib.newString("") ; 
     continue ) else skip ; 
     if (input->at(a+1) = '"') then (     if (quoteMode) then (     OclFile["System.out"].println("<" + tag + ">") ) else skip ; \n     quoteMode := not(quoteMode) ; \n     tag := StringLib.newString("") ; \n     continue ) else skip ; \n     if (not(quoteMode)) then (     spaceMode := true ) else skip ; \n     tag := tag + StringLib.newString(input->at(a+1)) )  ;     a := a + 1 ) ; \n );\n\n}\n\n

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B291 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char[] S=(in.nextLine()+" ").toCharArray();
    StringBuilder output=new StringBuilder();
    boolean quoted=false ;
    boolean inLexeme=false ;
    for(int i=0 ; i<S.length ; i++){
      char c=S[i];
      if(quoted){
        if(c=='"'){
          quoted=false ;
          output.append('>').append('\n');
        }
        else {
          output.append(c);
        }
      }
      else {
        if(c=='"'){
          quoted=true ;
          output.append('<');
        }
        else if(c==' '){
          if(inLexeme){
            inLexeme=false ;
            output.append('>').append('\n');
          }
        }
        else {
          if(! inLexeme){
            inLexeme=true ;
            output.append('<');
          }
          output.append(c);
        }
      }
    }
    System.out.print(output);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B291 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : Sequence(String) ; S := (in.nextLine() + " ")->characters() ;
    var output : String ; output := StringLib.newString() ;
    var quoted : boolean ; quoted := false ;
    var inLexeme : boolean ; inLexeme := false ;
        var i : int ; i := 0 ; while i < S->size() do ( (     var c : String ; c := S[i+1] ;
     if (quoted) then (     if (c = '"') then (     quoted := false ; \n     output := output + StringLib.newString('>') + StringLib.newString('\n') ) else (     output := output + StringLib.newString(c) ) ) else (     if (c = '"') then (     quoted := true ; 
     output := output + StringLib.newString('<') ) else     if (c = ' ') then (     if (inLexeme) then (     inLexeme := false ; 
     output := output + StringLib.newString('>') + StringLib.newString('
') ) else skip ) else (     if (not(inLexeme)) then (     inLexeme := true ; 
     output := output + StringLib.newString('<') ) else skip ; 
     output := output + StringLib.newString(c) ) ;  ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(output) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _137A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    int count=0 ;
    int cc=0,cp=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='C' && cp!=0){
        count++;
        cp=0 ;
      }
      else if(s.charAt(i)=='P' && cc!=0){
        count++;
        cc=0 ;
      }
      if(s.charAt(i)=='C'){
        cc++;
      }
      else {
        cp++;
      }
      if(cc==5 || cp==5){
        count++;
        cc=0 ;
        cp=0 ;
      }
    }
    if(cc!=0 || cp!=0){
      count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _137A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var count : int ; count := 0 ;
    var cc : int ; cc := 0 ;
    var cp : int ; cp := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'C' & cp /= 0) then (     count := count + 1 ; 
     cp := 0 ) else     if (s->at(i+1) = 'P' & cc /= 0) then (     count := count + 1 ; 
     cc := 0 ) else skip ; ;  
     if (s->at(i+1) = 'C') then (     cc := cc + 1 ) else (     cp := cp + 1 ) ;  
     if (cc = 5 or cp = 5) then (     count := count + 1 ; 
     cc := 0 ; 
     cp := 0 ) else skip )  ;     i := i + 1 ) ; 
    if (cc /= 0 or cp /= 0) then (     count := count + 1 ) else skip ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void swap(long a[],int b,int e,int t){
    for(int i=0 ; i<e-b ; i++){
      long tmp=a[b+i];
      a[b+i]=a[t+i];
      a[t+i]=tmp ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long a[]=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextLong();
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      int b=sc.nextInt();
      int e=sc.nextInt();
      int t=sc.nextInt();
      swap(a,b,e,t);
    }
    for(int i=0 ; i<n-1 ; i++)System.out.print(a[i]+" ");
    System.out.println(a[n-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation swap( a : Sequence(long), b : int, e : int, t : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < e - b do ( (     var tmp : long ; tmp := a[b + i+1] ;
     a[b + i+1] := a[t + i+1] ; 
     a[t + i+1] := tmp )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var b : int ; b := sc.getCurrent()->toInteger() ;
     var e : int ; e := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     execute swap(a, b, e, t) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a[n - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int size=in.nextInt(),arr[]=new int[size];
    for(int i=0 ; i<size ; i++){
      arr[i]=Integer.parseInt(in.next());
    }
    int query=in.nextInt();
    for(int i=0 ; i<query ; i++){
      int begin=Integer.parseInt(in.next()),end=Integer.parseInt(in.next()),target=Integer.parseInt(in.next());
      for(int j=0 ; j<end-begin ; j++){
        int temp=arr[begin+j];
        arr[begin+j]=arr[target+j];
        arr[target+j]=temp ;
      }
    }
    for(int i=0 ; i<size ; i++){
      out.printf("%d%s",arr[i],(i<size-1)? " " : "\n");
    }
    out.flush();
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var size : int ; size := in.getCurrent()->toInteger() ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < size do ( (     arr[i+1] := (in.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var query : int ; query := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < query do ( (     var begin : int ; begin := (in.getCurrent())->toInteger() ;
    var end : int ; end := (in.getCurrent())->toInteger() ;
    var target : int ; target := (in.getCurrent())->toInteger() ;
         var j : int ; j := 0 ; while j < end - begin do ( (     var temp : int ; temp := arr[begin + j+1] ;
     arr[begin + j+1] := arr[target + j+1] ; 
     arr[target + j+1] := temp )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < size do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Integer>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      list.add(sc.nextInt());
    }
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      int b=sc.nextInt();
      int e=sc.nextInt();
      int t=sc.nextInt();
      for(int j=b ; j<e ; j++){
        Collections.swap(list,j,t-b+j);
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int num : list){
      sb.append(num+" ");
    }
    String str=sb.toString();
    str=str.substring(0,str.length()-1);
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var b : int ; b := sc.getCurrent()->toInteger() ;
     var e : int ; e := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var j : int ; j := b ; while j < e do ( (     list := Integer.subrange(1,list.size)->collect( _x | if _x = j+1 then list->at(t - b + j+1) else if _x = t - b + j+1 then list->at(j+1) else list->at(_x) endif endif ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    for (num : list) do ( (     sb := sb + StringLib.newString(num + " ") )  ) ; 
    var str : String ; str := sb+"" ;
    str := str.subrange(0+1,str->size() - 1) ; 
    OclFile["System.out"].println(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int[] a=new int[n];
    str=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++)a[i]=Integer.parseInt(str[i]);
    str=br.readLine().split(" ");
    int q=Integer.parseInt(str[0]);
    for(int i=0 ; i<q ; i++){
      str=br.readLine().split(" ");
      int b=Integer.parseInt(str[0]);
      int e=Integer.parseInt(str[1]);
      int t=Integer.parseInt(str[2]);
      for(int j=0 ; j<(e-b); j++){
        int bf=a[b+j];
        a[b+j]=a[t+j];
        a[t+j]=bf ;
      }
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(a[i]);
      if(i!=n-1)System.out.print(" ");
    }
    System.out.print("\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    str := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (str[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    str := br.readLine()->split(" ") ; 
    var q : int ; q := (str[0+1])->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     str := br.readLine()->split(" ") ; 
     var b : int ; b := (str[0+1])->toInteger() ;
    var e : int ; e := (str[1+1])->toInteger() ;
    var t : int ; t := (str[2+1])->toInteger() ;
        var j : int ; j := 0 ; while j < (e - b) do ( (     var bf : int ; bf := a[b + j+1] ;
     a[b + j+1] := a[t + j+1] ; 
     a[t + j+1] := bf )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(a[i+1]) ; 
     if (i /= n - 1) then     OclFile["System.out"].print(" ") ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("\n") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    int num=sc.nextInt();
    ArrayList<Integer>array=new ArrayList<>();
    for(int i=0 ; i<num ; i++){
      int tmp=sc.nextInt();
      array.add(tmp);
    }
    int num_query=sc.nextInt();
    for(int i=0 ; i<num_query ; i++){
      int b=sc.nextInt();
      int e=sc.nextInt();
      int t=sc.nextInt();
      List<Integer>left=new ArrayList<>(array.subList(b,e));
      for(int j=0 ; j<left.size(); j++){
        array.set(j+b,array.get(j+t));
        array.set(j+t,left.get(j));
      }
    }
    for(int i=0 ; i<array.size(); i++){
      sb.append(array.get(i));
      if(i!=array.size()-1)sb.append(' ');
    }
    System.out.println(sb);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
    var num : int ; num := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Sequence{} ;
        var i : int ; i := 0 ; while i < num do ( (     var tmp : int ; tmp := sc.getCurrent()->toInteger() ;
     array := array->including(tmp) )  ;     i := i + 1 ) ; 
    var num_query : int ; num_query := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < num_query do ( (     var b : int ; b := sc.getCurrent()->toInteger() ;
     var e : int ; e := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var left : Sequence(int) ; left := Sequence{}->union(array.subrange(b+1,e)) ;
        var j : int ; j := 0 ; while j < left->size() do ( (     array := array.setAt(j + b+1,array->at(j + t+1)) ; 
     array := array.setAt(j + t+1,left->at(j+1)) )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < array->size() do ( (     sb := sb + StringLib.newString(array->at(i+1)) ; 
     if (i /= array->size() - 1) then     sb := sb + StringLib.newString(' ') ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class A_Nastia_and_Nearly_Good_Numbers {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int T=reader.nextInt();
    while(T!=0){
      T--;
      int A=reader.nextInt();
      int B=reader.nextInt();
      if(B==1){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
        System.out.println((long)A*(long)B+" "+A+" "+(long)A*((long)B+1));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Nastia_and_Nearly_Good_Numbers {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var T : int ; T := reader.nextInt() ;
     while (T /= 0) do (     T := T - 1 ; 
     var A : int ; A := reader.nextInt() ;
     var B : int ; B := reader.nextInt() ;
     if (B = 1) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(A->oclAsType(long) * B->oclAsType(long) + " " + A + " " + A->oclAsType(long) * (B->oclAsType(long) + 1)) ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static long mod=1000000007 ;
  static long[][] arr=new long[1001][1001];
  static void Preprocess(){
    arr[0][0]=1 ;
    for(int i=1 ; i<=1000 ; ++i){
      arr[i][0]=1 ;
      for(int j=1 ; j<i ; ++j){
        arr[i][j]=(arr[i-1][j-1]+arr[i-1][j])% mod ;
      }
      arr[i][i]=1 ;
    }
  }
  static long powmod(long a,long n){
    if(n==0){
      return 1 ;
    }
    long pt=powmod(a,n/2);
    pt=(pt*pt)% mod ;
    if(n % 2==1){
      return(pt*a)% mod ;
    }
    else {
      return pt ;
    }
  }
  static long CountSubset(int[] val,int n){
    long ans=powmod(2,n-1);
    Arrays.sort(val);
    for(int i=0 ; i<n ; ++i){
      int j=i+1 ;
      while(j<n && val[j]==val[i]){
        int r=n-1-j ;
        int l=i ;
        ans=(ans+arr[l+r][l])% mod ;
        j++;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    Preprocess();
    int val[]={
      2,3,2 };
      int n=val.length ;
      System.out.println(CountSubset(val,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute mod : long := 1000000007;
  static   attribute arr : Sequence(Sequence(long)) := Integer.subrange(1,1001)->collect(Integer.subrange(1,1001)->collect(0));
  static   operation Preprocess() : void
  pre: true
  post: true
  activity: (     arr[0+1][0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= 1000 do ( (     arr[i+1][0+1] := 1 ; 
         var j : int ; j := 1 ; while j < i do ( (     arr[i+1][j+1] := (arr[i - 1+1][j - 1+1] + arr[i - 1+1][j+1]) mod mod )  ;     j := j + 1 ) ; 
     arr[i+1][i+1] := 1 )  ;     i := i + 1 ) );
  static   operation powmod( a : long, n : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then (     return 1 ) else skip ; 
     var pt : long ; pt := powmod(a, n / 2) ;
     pt := (pt * pt) mod mod ; 
     if (n mod 2 = 1) then (     return (pt * a) mod mod ) else (     return pt ) );
  static   operation CountSubset( val : Sequence(int), n : int) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := powmod(2, n - 1) ;
     val := val->sort() ; 
         var i : int ; i := 0 ; while i < n do ( (     var j : int ; j := i + 1 ;
     while (j < n & val[j+1] = val[i+1]) do (     var r : int ; r := n - 1 - j ;
     var l : int ; l := i ;
     ans := (ans + arr[l + r+1][l+1]) mod mod ; 
     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute Preprocess() ; 
     var val : Sequence(int) ; val := Sequence{2,3,2} ;
     var n : int ; n := val->size() ;
     OclFile["System.out"].println(CountSubset(val, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class tasks {
  public static void main(String...args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int count=0 ;
    int x=0,y=0,z=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<3 ; j++){
        if(count==0){
          x+=in.nextInt();
          count++;
        }
        else if(count==1){
          y+=in.nextInt();
          count++;
        }
        else {
          z+=in.nextInt();
          count=0 ;
        }
      }
    }
    if(x==0 && y==0 && z==0)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class tasks {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var z : int ; z := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 3 do ( (     if (count = 0) then (     x := x+(in.getCurrent()->toInteger()) ; 
     count := count + 1 ) else     if (count = 1) then (     y := y+(in.getCurrent()->toInteger()) ; 
     count := count + 1 ) else (     z := z+(in.getCurrent()->toInteger()) ; 
     count := 0 ) ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (x = 0 & y = 0 & z = 0) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Codeforces {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int x,y,z ;
    int sumx=0,sumy=0,sumz=0 ;
    for(int i=0 ; i<n ; i++){
      x=input.nextInt();
      y=input.nextInt();
      z=input.nextInt();
      sumx+=x ;
      sumy+=y ;
      sumz+=z ;
    }
    if(sumx==0 && sumy==0 && sumz==0)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var x : int ;
    var y : int ;
    var z : int ;
    var sumx : int ; sumx := 0 ;
    var sumy : int ; sumy := 0 ;
    var sumz : int ; sumz := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x := input.getCurrent()->toInteger() ; 
     y := input.getCurrent()->toInteger() ; 
    z := input.getCurrent()->toInteger() ; 
    sumx := sumx+(x) ; 
    sumy := sumy+(y) ; 
    sumz := sumz+(z) ; 
 )  ;     i := i + 1 ) ; 
    if (sumx = 0 & sumy = 0 & sumz = 0) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int len=sc.nextInt();
    int[][] grid=new int[len][3];
    for(int i=0 ; i<len ; i++){
      for(int j=0 ; j<3 ; j++){
        grid[i][j]=sc.nextInt();
      }
    }
    System.out.println(new Main().solveGrid(grid));
  }
  public String solveGrid(int[][] grid){
    for(int i=0 ; i<3 ; i++){
      int sum=0 ;
      for(int j=0 ; j<grid.length ; j++){
        sum+=grid[j][i];
      }
      if(sum!=0)return "NO" ;
    }
    return "YES" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := sc.getCurrent()->toInteger() ;
    var grid : Sequence(Sequence(int)) ; grid := Integer.subrange(1,len)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < len do ( (         var j : int ; j := 0 ; while j < 3 do ( (     grid[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Main.newMain().solveGrid(grid)) ; 
 );
   operation solveGrid( grid : Sequence(Sequence(int))) : String
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 3 do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < grid->size() do ( (     sum := sum+(grid[j+1][i+1]) )  ;     j := j + 1 ) ; 
     if (sum /= 0) then     return "NO" else skip )  ;     i := i + 1 ) ; 
     return "YES" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x=0 ;
    int y=0 ;
    int z=0 ;
    for(int i=0 ; i<n ; i++){
      x+=sc.nextInt();
      y+=sc.nextInt();
      z+=sc.nextInt();
    }
    sc.close();
    if(x==0 && y==0 && z==0){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var z : int ; z := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x := x+(sc.getCurrent()->toInteger()) ; 
     y := y+(sc.getCurrent()->toInteger()) ; 
     z := z+(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    skip ; 
    if (x = 0 & y = 0 & z = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void solve(){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int n=s.length();
    int cnt=1 ;
    int charcnt=0 ;
    for(int i=1 ; i<n ; i++){
      if(s.charAt(i)==s.charAt(i-1)){
        charcnt++;
        if(charcnt==5){
          charcnt=0 ;
          cnt++;
        }
      }
      else {
        cnt++;
        charcnt=0 ;
      }
    }
    System.out.println(cnt);
  }
  public static void main(String[] arg){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var n : int ; n := s->size() ;
    var cnt : int ; cnt := 1 ;
    var charcnt : int ; charcnt := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (s->at(i+1) = s->at(i - 1+1)) then (     charcnt := charcnt + 1 ; 
     if (charcnt = 5) then (     charcnt := 0 ; 
     cnt := cnt + 1 ) else skip ) else (     cnt := cnt + 1 ; 
     charcnt := 0 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
public class Main {
  public static String solution(ArrayList<Integer>x,ArrayList<Integer>y,ArrayList<Integer>z){
    int xtotal=0 ;
    int ytotal=0 ;
    int ztotal=0 ;
    for(int i=0 ; i<x.size(); i++){
      xtotal+=x.get(i);
    }
    for(int i=0 ; i<y.size(); i++){
      ytotal+=y.get(i);
    }
    for(int i=0 ; i<z.size(); i++){
      ztotal+=z.get(i);
    }
    if(xtotal==0 && ytotal==0 && ztotal==0)return "YES" ;
    else return "NO" ;
  }
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    ArrayList<Integer>x=new ArrayList<>();
    ArrayList<Integer>y=new ArrayList<>();
    ArrayList<Integer>z=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      x.add(input.nextInt());
      y.add(input.nextInt());
      z.add(input.nextInt());
    }
    System.out.println(solution(x,y,z));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solution( x : Sequence(int), y : Sequence(int), z : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var xtotal : int ; xtotal := 0 ;
     var ytotal : int ; ytotal := 0 ;
    var ztotal : int ; ztotal := 0 ;
        var i : int ; i := 0 ; while i < x->size() do ( (     xtotal := xtotal+(x->at(i+1)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < y->size() do ( (     ytotal := ytotal+(y->at(i+1)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < z->size() do ( (     ztotal := ztotal+(z->at(i+1)) )  ;     i := i + 1 ) ; 
    if (xtotal = 0 & ytotal = 0 & ztotal = 0) then     return "YES" else     return "NO" ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Sequence{} ;
    var y : Sequence(int) ; y := Sequence{} ;
    var z : Sequence(int) ; z := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     x := x->including(input.getCurrent()->toInteger()) ; 
     y := y->including(input.getCurrent()->toInteger()) ; 
     z := z->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solution(x, y, z)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean isProductEven(int arr[],int n){
    for(int i=0 ; i<n ; i++)if((arr[i] & 1)==0)return true ;
    return false ;
  }
  public static void main(String args[]){
    int arr[]={
      2,4,3,5 };
      int n=arr.length ;
      if(isProductEven(arr,n))System.out.println("Even");
      else System.out.println("Odd");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isProductEven( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     if ((arr[i+1] & 1) = 0) then     return true else skip ;  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,3,5} ;
     var n : int ; n := arr->size() ;
     if (isProductEven(arr, n)) then     OclFile["System.out"].println("Even") ; else     OclFile["System.out"].println("Odd") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class practice2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      int zero=0 ;
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
        if(arr[i]<0)zero++;
      }
      Arrays.sort(arr);
      int num=n-1 ;
      for(int i=0 ; i<num ; i++){
        if(arr[i+1]-arr[i]<arr[num]){
--num ;
--i ;
        }
      }
      System.out.println(++num);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var zero : int ; zero := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr[i+1] < 0) then     zero := zero + 1 ; else skip )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var num : int ; num := n - 1 ;
        var i : int ; i := 0 ; while i < num do ( (     if (arr[i + 1+1] - arr[i+1] < arr[num+1]) then (     num := num - 1 ; 
     i := i - 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((num + 1)) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test257 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int a[]=new int[3];
      for(int i=0 ; i<3 ; i++){
        a[i]=in.nextInt();
      }
      int sum=0 ;
      boolean x=true ;
      while(sum<3){
        if(n==0){
          x=false ;
          break ;
        }
        n=a[n-1];
        sum++;
      }
      if(x){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test257 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var x : boolean ; x := true ;
    while (sum < 3) do (     if (n = 0) then (     x := false ; 
     break ) else skip ; 
     n := a[n - 1+1] ; 
     sum := sum + 1 ) ; 
    if (x) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  static long pow(long a,long b){
    if(b==0){
      return 1 ;
    }
    long ans=0L ;
    if(b % 2==0){
      long val=pow(a,b/2);
      ans+=val*val ;
    }
    else {
      long val=pow(a,b/2);
      ans+=val*val*2 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int a=sc.nextInt();
      int b=sc.nextInt();
      if(b==1){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
        System.out.println(a+" "+(b*(a*1L))+" "+(b+1L)*a);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation pow( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return 1 ) else skip ; 
     var ans : long ; ans := 0L ;
     if (b mod 2 = 0) then (     var val : long ; val := pow(a, b / 2) ;
     ans := ans+(val * val) ) else (     var val : long ; val := pow(a, b / 2) ;
     ans := ans+(val * val * 2) ) ;  
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (b = 1) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(a + " " + (b * (a * 1L)) + " " + (b + 1L) * a) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Solution {
  static PrintWriter pw ;
  static FastScanner s ;
  public static void main(String[] args)throws Exception {
    pw=new PrintWriter(System.out);
    s=new FastScanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int x=s.nextInt();
      int a[]=new int[3];
      for(int i=0 ; i<3 ; i++){
        a[i]=s.nextInt();
      }
      if(a[x-1]==0){
        pw.println("NO");
      }
      else {
        if(a[a[x-1]-1]==0){
          pw.println("NO");
        }
        else pw.println("YES");
      }
    }
    pw.flush();
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public FastScanner(String s)throws Exception {
    br=new BufferedReader(new FileReader(new File(s)));
  }
  public String next()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(next());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute pw : OclFile;
  static   attribute s : FastScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     pw := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     s := FastScanner.newFastScanner(OclFile["System.in"]) ; 
    var t : int ; t := s.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var x : int ; x := s.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
         var i : int ; i := 0 ; while i < 3 do ( (     a[i+1] := s.nextInt() )  ;     i := i + 1 ) ; 
     if (a[x - 1+1] = 0) then (     skip ) else (     if (a[a[x - 1+1] - 1+1] = 0) then (     skip ) else     skip ; ) ) ;  ) ;  
    skip ; 
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.StringTokenizer ;
import java.io.*;
import java.util.*;
import java.util.List ;
import java.util.stream.Collectors ;
import java.util.stream.Stream ;
import java.math.*;
public class Main {
  public static void main(String[] args){
    FastScanner sc=new FastScanner();
    int t=sc.nextInt();
    while(t-->0){
      int x=sc.nextInt();
      HashMap<Integer,Integer>hs=new HashMap<>();
      hs.put(1,sc.nextInt());
      hs.put(2,sc.nextInt());
      hs.put(3,sc.nextInt());
      int count=0 ;
      while(hs.get(x)!=0){
        count++;
        int val=hs.get(x);
        x=val ;
      }
      if(count==2){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
  static void sort(int[] a){
    ArrayList<Integer>l=new ArrayList<>();
    for(int i : a)l.add(i);
    Collections.sort(l);
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())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());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner() ;
     var t : int ; t := sc.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x : int ; x := sc.nextInt() ;
     var hs : Map(int,int) ; hs := Map{} ;
    hs := hs->union(Map{1 |-> sc.nextInt()}) ; 
    hs := hs->union(Map{2 |-> sc.nextInt()}) ; 
    hs := hs->union(Map{3 |-> sc.nextInt()}) ; 
    var count : int ; count := 0 ;
    while (hs->at(x) /= 0) do (     count := count + 1 ; 
     var val : int ; val := hs->at(x) ;
     x := val ) ; 
    if (count = 2) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l := l->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Tttest {
  public static String fun(int arr[],int key){
    while(key>0){
      int temp=arr[key-1];
      arr[key-1]=0 ;
      key=temp ;
    }
    if(arr[0]==0 && arr[1]==0 && arr[2]==0){
      return "YES" ;
    }
    return "NO" ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int key=sc.nextInt();
      int[] arr=new int[3];
      for(int i=0 ; i<3 ; i++){
        arr[i]=sc.nextInt();
      }
      System.out.println(fun(arr,key));
      t--;
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Tttest {
  static   operation fun( arr : Sequence(int), key : int) : String
  pre: true
  post: true
  activity: (     while (key > 0) do (     var temp : int ; temp := arr[key - 1+1] ;
     arr[key - 1+1] := 0 ; 
     key := temp ) ; 
     if (arr[0+1] = 0 & arr[1+1] = 0 & arr[2+1] = 0) then (     return "YES" ) else skip ; 
     return "NO" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var key : int ; key := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(fun(arr, key)) ; 
    t := t - 1 ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int centered_pentagonal_Num(int n){
    return(5*n*n-5*n+2)/2 ;
  }
  public static void main(String[] args){
    int n=7 ;
    System.out.print(n+"th Centered "+"pentagonal number: ");
    System.out.println(centered_pentagonal_Num(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation centered_pentagonal_Num( n : int) : int
  pre: true
  post: true
  activity: (     return (5 * n * n - 5 * n + 2) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     OclFile["System.out"].print(n + "th Centered " + "pentagonal number: ") ; 
     OclFile["System.out"].println(centered_pentagonal_Num(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
public class Main {
  public static long solution(long n,long k){
    if(n % 2==0){
      if(k<=(n/2))return((2*k)-1);
      else return(2*(k-(n/2)));
    }
    else {
      if(k<=(n/2)+1)return((2*k)-1);
      else return(2*(k-(n/2)-1));
    }
  }
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    long n=input.nextLong();
    long k=input.nextLong();
    System.out.println(solution(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solution( n : long, k : long) : long
  pre: true
  post: true
  activity: (     if (n mod 2 = 0) then (     if (k <= (n / 2)) then     return ((2 * k) - 1) else     return (2 * (k - (n / 2))) ) else (     if (k <= (n / 2) + 1) then     return ((2 * k) - 1) else     return (2 * (k - (n / 2) - 1)) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := input.getCurrent()->toLong() ;
     var k : long ; k := input.getCurrent()->toLong() ;
     OclFile["System.out"].println(solution(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int n=s.length();
    char prev=s.charAt(0);
    int ans=1 ;
    int cur=0 ;
    boolean flag=false ;
    for(int i=1 ; i<n ; i++){
      if(prev==s.charAt(i)){
        cur+=1 ;
        if(cur==5){
          cur=0 ;
          ans+=1 ;
        }
      }
      else {
        cur=0 ;
        ans+=1 ;
      }
      prev=s.charAt(i);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var n : int ; n := s->size() ;
    var prev : String ; prev := s->at(0+1) ;
    var ans : int ; ans := 1 ;
    var cur : int ; cur := 0 ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 1 ; while i < n do ( (     if (prev = s->at(i+1)) then (     cur := cur+(1) ; 
     if (cur = 5) then (     cur := 0 ; 
     ans := ans+(1) ) else skip ) else (     cur := 0 ; 
     ans := ans+(1) ) ;  
     prev := s->at(i+1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sr=new Scanner(System.in);
    long d=sr.nextLong();
    long e=sr.nextLong();
    long temp ;
    if(d % 2==0){
      if(e<=d/2){
        temp=2*e-1 ;
        System.out.println(temp);
      }
      else {
        temp=2*(e-d/2);
        System.out.println(temp);
      }
    }
    else {
      if(e<=d/2+1){
        temp=2*e-1 ;
        System.out.println(temp);
      }
      else {
        temp=2*(e-d/2-1);
        System.out.println(temp);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sr : OclFile ; sr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : long ; d := sr.getCurrent()->toLong() ;
    var e : long ; e := sr.getCurrent()->toLong() ;
    var temp : long ;
    if (d mod 2 = 0) then (     if (e <= d / 2) then (     temp := 2 * e - 1 ; 
     OclFile["System.out"].println(temp) ) else (     temp := 2 * (e - d / 2) ; 
     OclFile["System.out"].println(temp) ) ) else (     if (e <= d / 2 + 1) then (     temp := 2 * e - 1 ; 
     OclFile["System.out"].println(temp) ) else (     temp := 2 * (e - d / 2 - 1) ; 
     OclFile["System.out"].println(temp) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long p=sc.nextLong();
    long temp ;
    if(n % 2==0){
      if(p<=n/2){
        temp=2*p-1 ;
        System.out.println(temp);
      }
      else {
        temp=2*(p-n/2);
        System.out.println(temp);
      }
    }
    else {
      if(p<=n/2+1){
        temp=2*p-1 ;
        System.out.println(temp);
      }
      else {
        temp=2*(p-n/2-1);
        System.out.println(temp);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var p : long ; p := sc.getCurrent()->toLong() ;
    var temp : long ;
    if (n mod 2 = 0) then (     if (p <= n / 2) then (     temp := 2 * p - 1 ; 
     OclFile["System.out"].println(temp) ) else (     temp := 2 * (p - n / 2) ; 
     OclFile["System.out"].println(temp) ) ) else (     if (p <= n / 2 + 1) then (     temp := 2 * p - 1 ; 
     OclFile["System.out"].println(temp) ) else (     temp := 2 * (p - n / 2 - 1) ; 
     OclFile["System.out"].println(temp) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long y=sc.nextLong();
    long temp ;
    if(n % 2==0){
      if(y<=n/2){
        temp=2*y-1 ;
        System.out.println(temp);
      }
      else {
        temp=2*(y-n/2);
        System.out.println(temp);
      }
    }
    else {
      if(y<=n/2+1){
        temp=2*y-1 ;
        System.out.println(temp);
      }
      else {
        temp=2*(y-n/2-1);
        System.out.println(temp);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var y : long ; y := sc.getCurrent()->toLong() ;
    var temp : long ;
    if (n mod 2 = 0) then (     if (y <= n / 2) then (     temp := 2 * y - 1 ; 
     OclFile["System.out"].println(temp) ) else (     temp := 2 * (y - n / 2) ; 
     OclFile["System.out"].println(temp) ) ) else (     if (y <= n / 2 + 1) then (     temp := 2 * y - 1 ; 
     OclFile["System.out"].println(temp) ) else (     temp := 2 * (y - n / 2 - 1) ; 
     OclFile["System.out"].println(temp) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NastiaAndNearlyGoodNumbers {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    while(test-->0){
      long a=sc.nextLong();
      long b=sc.nextLong();
      if(b==1){
        System.out.println("NO");
      }
      else {
        long result1=a ;
        long result2=a*b ;
        long result3=a*(b+1);
        System.out.println("YES");
        System.out.println(result1+" "+result2+" "+result3);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NastiaAndNearlyGoodNumbers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
     if (b = 1) then (     OclFile["System.out"].println("NO") ) else (     var result1 : long ; result1 := a ;
     var result2 : long ; result2 := a * b ;
    var result3 : long ; result3 := a * (b + 1) ;
    OclFile["System.out"].println("YES") ; 
    OclFile["System.out"].println(result1 + " " + result2 + " " + result3) ; 
 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long k=sc.nextLong();
    long temp ;
    if(n % 2==0){
      if(k<=n/2){
        temp=2*k-1 ;
        System.out.println(temp);
      }
      else {
        temp=2*(k-n/2);
        System.out.println(temp);
      }
    }
    else {
      if(k<=n/2+1){
        temp=2*k-1 ;
        System.out.println(temp);
      }
      else {
        temp=2*(k-n/2-1);
        System.out.println(temp);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var temp : long ;
    if (n mod 2 = 0) then (     if (k <= n / 2) then (     temp := 2 * k - 1 ; 
     OclFile["System.out"].println(temp) ) else (     temp := 2 * (k - n / 2) ; 
     OclFile["System.out"].println(temp) ) ) else (     if (k <= n / 2 + 1) then (     temp := 2 * k - 1 ; 
     OclFile["System.out"].println(temp) ) else (     temp := 2 * (k - n / 2 - 1) ; 
     OclFile["System.out"].println(temp) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.geom.*;
public class Main {
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      boolean[] in=new boolean[31];
      for(int i=0 ; i<28 ; i++){
        int now=sc.nextInt();
        in[now]=true ;
      }
      for(int i=1 ; i<31 ; i++){
        if(! in[i]){
          System.out.println(i);
        }
      }
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var in : Sequence(boolean) ; in := Integer.subrange(1,31)->collect(false) ;
         var i : int ; i := 0 ; while i < 28 do ( (     var now : int ; now := sc.getCurrent()->toInteger() ;
     in[now+1] := true )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i < 31 do ( (     if (not(in[i+1])) then (     OclFile["System.out"].println(i) ) else skip )  ;     i := i + 1 ) ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.HashSet ;
class Main {
  public static void main(String[] args)throws IOException {
    final int NUM=28 ;
    final int NUMs=30 ;
    ArrayList<Integer>al=new ArrayList<Integer>();
    HashSet<Integer>h=new HashSet<Integer>();
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    for(int i=0 ; i<NUM ; i++){
      h.add(Integer.parseInt(in.readLine()));
    }
    for(int i=0 ; i<NUMs ; i++){
      if(! h.contains(i+1)){
        al.add(i+1);
      }
    }
    System.out.println(al.get(0));
    System.out.println(al.get(1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var NUM : int ; NUM := 28 ;
     var NUMs : int ; NUMs := 30 ;
    var al : Sequence(int) ; al := Sequence{} ;
    var h : Set(int) ; h := Set{} ;
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
        var i : int ; i := 0 ; while i < NUM do ( (     h := h->including((in.readLine())->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < NUMs do ( (     if (not(h->includes(i + 1))) then (     al := al->including(i + 1) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(al->at(0+1)) ; 
    OclFile["System.out"].println(al->at(1+1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    final int N=31 ;
    int[] student=new int[N],yet=new int[2];
    Scanner sc=new Scanner(System.in);
    for(int i=0 ; i<28 ; i++){
      student[sc.nextInt()]++;
    }
    for(int i=1,j=0 ; i<31 ; i++){
      if(student[i]==0){
        yet[j]=i ;
        j++;
      }
    }
    Arrays.sort(yet);
    System.out.printf("%d\n%d\n",yet[0],yet[1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 31 ;
     var student : Sequence(int) ; student := Integer.subrange(1,N)->collect(0) ;
    var yet : Sequence(int) ; yet := Integer.subrange(1,2)->collect(0) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
        var i : int ; i := 0 ; while i < 28 do ( (     student[sc.getCurrent()->toInteger()+1] := student[sc.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ;
    var j : int ; j := 0 ; while i < 31 do ( (     if (student[i+1] = 0) then (     yet[j+1] := i ; 
     j := j + 1 ) else skip )  ;     i := i + 1 ) ; 
    yet := yet->sort() ; 
    OclFile["System.out"].printf("%d\n%d\n", yet[0+1], yet[1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int[] Stu=new int[30];
    for(int i=0 ; i<30 ; i++){
      Stu[i]=i+1 ;
    }
    for(int i=0 ; i<28 ; i++){
      int a=s.nextInt();
      Stu[a-1]=0 ;
    }
    for(int i=0 ; i<30 ; i++){
      if(Stu[i]!=0){
        System.out.println(Stu[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var Stu : Sequence(int) ; Stu := Integer.subrange(1,30)->collect(0) ;
        var i : int ; i := 0 ; while i < 30 do ( (     Stu[i+1] := i + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 28 do ( (     var a : int ; a := s.getCurrent()->toInteger() ;
     Stu[a - 1+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 30 do ( (     if (Stu[i+1] /= 0) then (     OclFile["System.out"].println(Stu[i+1]) ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int[] handout=new int[31];
  static int[] source=new int[29];
  public static void main(String[] args){
    read();
    slove();
  }
  static boolean read(){
    for(int i=1 ; i<=28 ; i++){
      source[i]=sc.nextInt();
    }
    return true ;
  }
  static void slove(){
    for(int i=1 ; i<=30 ; i++){
      handout[i]=i ;
    }
    for(int i=1 ; i<=30 ; i++){
      for(int j=1 ; j<=28 ; j++){
        if(handout[i]==source[j])handout[i]=0 ;
      }
      if(handout[i]!=0)System.out.println(handout[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute handout : Sequence(int) := Integer.subrange(1,31)->collect(0);
  static   attribute source : Sequence(int) := Integer.subrange(1,29)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute read() ; 
     execute slove() );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= 28 do ( (     source[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return true );
  static   operation slove() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= 30 do ( (     handout[i+1] := i )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i <= 30 do ( (         var j : int ; j := 1 ; while j <= 28 do ( (     if (handout[i+1] = source[j+1]) then     handout[i+1] := 0 ; else skip )  ;     j := j + 1 ) ; 
     if (handout[i+1] /= 0) then     OclFile["System.out"].println(handout[i+1]) ; else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  private static String fileName=B.class.getSimpleName().replaceFirst("_.*","");
  private static String inputFileName=fileName+".in" ;
  private static String outputFileName=fileName+".out" ;
  private static Scanner in ;
  private static PrintWriter out ;
  private void solve(){
    int points=in.nextInt();
    int d=in.nextInt();
    List<Integer>xs=new ArrayList<Integer>();
    for(int i=0 ; i<points ; i++){
      int x=in.nextInt();
      int amount=in.nextInt();
      for(int j=0 ; j<amount ; j++){
        xs.add(x);
      }
    }
    Collections.sort(xs);
    double left=0 ;
    double right=1e12 ;
    binsearch : while(left+0.5e-6<right){
      System.out.println(right-left);
      double time=(left+right)/2 ;
      double p=-1e15 ;
      for(int x : xs){
        double pp=Math.max(x-time,p+d);
        if(pp>x+time){
          if(left==time){
            break ;
          }
          left=time ;
          continue binsearch ;
        }
        p=pp ;
      }
      if(right==time){
        break ;
      }
      right=time ;
    }
    out.println(right);
  }
  public static void main(String[] args)throws IOException {
    Locale.setDefault(Locale.US);
    if(args.length>=2){
      inputFileName=args[0];
      outputFileName=args[1];
    }
    in=new Scanner(new FileReader(inputFileName));
    out=new PrintWriter(outputFileName);
    int tests=in.nextInt();
    in.nextLine();
    for(int t=1 ; t<=tests ; t++){
      out.print("Case #"+t+": ");
      new B().solve();
      System.out.println("Case #"+t+": solved");
    }
    in.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute fileName : String := OclType["B"].getSimpleName().replaceFirstMatch("_.*", "");
  static   attribute inputFileName : String := fileName + ".in";
  static   attribute outputFileName : String := fileName + ".out";
  static   attribute in : OclFile;
  static   attribute out : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     var points : int ; points := in.getCurrent()->toInteger() ;
     var d : int ; d := in.getCurrent()->toInteger() ;
    var xs : Sequence(int) ; xs := Sequence{} ;
        var i : int ; i := 0 ; while i < points do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var amount : int ; amount := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < amount do ( (     xs := xs->including(x) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    xs := xs->sort() ; 
    var left : double ; left := 0 ;
    var right : double ; right := 1e12 ;
    while (left + 0.5e-6 < right) do (     OclFile["System.out"].println(right - left) ; 
     var time : double ; time := (left + right) / 2 ;
    var p : double ; p := -1e15 ;
    for (x : xs) do ( (     var pp : double ; pp := Set{x - time, p + d}->max() ;
     if (pp > x + time) then (     if (left = time) then (     break ) else skip ; 
     left := time ; 
     continue ) else skip ; 
     p := pp )  ) ; 
    if (right = time) then (     break ) else skip ; 
    right := time ; 
 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.US) ; 
     if (args->size() >= 2) then (     inputFileName := args[0+1] ; 
     outputFileName := args[1+1] ) else skip ; 
    in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(inputFileName))) ; 
    out := OclFile.newOclFile_Write(OclFile.newOclFile(outputFileName)) ; 
    var tests : int ; tests := in.getCurrent()->toInteger() ;
    skip ; 
        var t : int ; t := 1 ; while t <= tests do ( (     skip ; 
     B.newB().solve() ; 
     OclFile["System.out"].println("Case #" + t + ": solved") )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static BufferedReader br ;
  public static void main(String[] args)throws Exception {
    input input=new input();
    String x=input.sin();
    String z=input.sin();
    StringBuilder y=new StringBuilder();
    for(int k=0 ; k<x.length(); k++){
      int xc=x.charAt(k);
      int zc=z.charAt(k);
      if(zc==xc){
        y.append(x.charAt(k));
        continue ;
      }
      if(zc>xc){
        System.out.println(-1);
        return ;
      }
      else {
        y.append(z.charAt(k));
      }
    }
    System.out.println(y.toString());
  }
}
class input {
  BufferedReader br ;
  public input(){
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  int in()throws Exception {
    return Integer.parseInt(br.readLine());
  }
  long Lin()throws Exception {
    return Long.parseLong(br.readLine());
  }
  long Lin(String num)throws Exception {
    return Long.parseLong(num);
  }
  String sin()throws Exception {
    return br.readLine();
  }
  String[] sarrin()throws Exception {
    return br.readLine().split(" ");
  }
  String[] regexSplit()throws Exception {
    return br.readLine().split(" ?(?<!\\G)((?<=[^\\p{Punct}])(?=\\p{Punct})|\\b)?");
  }
  int in(String num)throws Exception {
    return Integer.parseInt(num);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : input ; input := input.newinput() ;
     var x : String ; x := input.sin() ;
    var z : String ; z := input.sin() ;
    var y : String ; y := StringLib.newString() ;
        var k : int ; k := 0 ; while k < x->size() do ( (     var xc : int ; xc := x->at(k+1) ;
     var zc : int ; zc := z->at(k+1) ;
     if (zc = xc) then (     y := y + StringLib.newString(x->at(k+1)) ; 
     continue ) else skip ; 
     if (zc > xc) then (     OclFile["System.out"].println(-1) ; 
     return ) else (     y := y + StringLib.newString(z->at(k+1)) ) )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(y+"") ; 
 );
}
class input {
   attribute br : OclFile;
   static operation newinput() : input
  pre: true
  post: true
  activity:
  ( var self : input ;
    self := createinput();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation in() : int
  pre: true
  post: true
  activity: (     return (br.readLine())->toInteger() );
   operation Lin() : long
  pre: true
  post: true
  activity: (     return (br.readLine())->toLong() );
   operation Lin( num : String) : long
  pre: true
  post: true
  activity: (     return (num)->toLong() );
   operation sin() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation sarrin() : Sequence(String)
  pre: true
  post: true
  activity: (     return br.readLine()->split(" ") );
   operation regexSplit() : Sequence(String)
  pre: true
  post: true
  activity: (     return br.readLine()->split(" ?(?<!\\G)((?<=[^\\p{Punct}])(?=\\p{Punct})|\\b)?") );
   operation in( num : String) : int
  pre: true
  post: true
  activity: (     return (num)->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication105 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int counter=1 ;
    int count=1 ;
    char old=s.charAt(0);
    for(int i=1 ; i<s.length(); i++){
      if(s.charAt(i)==old){
        if(counter<5){
          counter++;
        }
        else {
          counter=1 ;
          count++;
        }
      }
      else {
        counter=1 ;
        count++;
        old=s.charAt(i);
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication105 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var counter : int ; counter := 1 ;
    var count : int ; count := 1 ;
    var old : String ; old := s->at(0+1) ;
        var i : int ; i := 1 ; while i < s->size() do ( (     if (s->at(i+1) = old) then (     if (counter < 5) then (     counter := counter + 1 ) else (     counter := 1 ; 
     count := count + 1 ) ) else (     counter := 1 ; 
     count := count + 1 ; 
     old := s->at(i+1) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round1 ;
import java.io.File ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class HotDogs {
  static class Point {
    int position,total ;
    public Point(int position,int total){
      this.position=position ;
      this.total=total ;
    }
  }
  static final double eps=0.0000000001 ;
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(new File("hotDog.in"));
    PrintWriter out=new PrintWriter(new File("hotDog.out"));
    int tt=in.nextInt();
    for(int t=1 ; t<=tt ; t++){
      System.out.println(t);
      int c=in.nextInt();
      double d=in.nextInt();
      Point[] p=new Point[c];
      for(int i=0 ; i<c ; i++){
        int position=in.nextInt();
        int total=in.nextInt();
        p[i]=new Point(position,total);
      }
      double lg=0,dg=1000000000 ;
      dg*=dg ;
      int count=0 ;
      while(dg-lg>eps && count<100000){
        count++;
        double s=(dg+lg)/2 ;
        boolean moze=true ;
        double tmin=-1000000000000000000.0 ;
        for(int i=0 ; moze && i<c ; i++){
          double t1=Math.max(tmin,p[i] .position-s);
          double tlast=t1+(double)(p[i] .total-1)*(double)d ;
          if(tlast-p[i] .position>s+eps)moze=false ;
          else tmin=tlast+(double)d ;
        }
        if(moze)dg=s ;
        else lg=s ;
      }
      System.out.println(dg+" "+lg);
      out.printf("Case #%d: %.10f",t,(lg+dg)/2);
      out.println();
    }
    out.flush();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class HotDogs {
  static class Point {
   attribute position : int;
   static operation newPoint( position : int, total : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(position, total);
    return self );
  operation initialise( position : int, total : int) : void
  pre: true  post: true
  activity: (     self.position := position ; 
     self.total := total );
}
  static    attribute eps : double := 0.0000000001;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("hotDog.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("hotDog.out")) ;
    var tt : int ; tt := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= tt do ( (     OclFile["System.out"].println(t) ; 
     var c : int ; c := in.getCurrent()->toInteger() ;
    var d : double ; d := in.getCurrent()->toInteger() ;
    var p : Sequence(Point) ; p := Integer.subrange(1,c)->collect(null) ;
        var i : int ; i := 0 ; while i < c do ( (     var position : int ; position := in.getCurrent()->toInteger() ;
     var total : int ; total := in.getCurrent()->toInteger() ;
     p[i+1] := Point.newPoint(position, total) )  ;     i := i + 1 ) ; 
    var lg : double ; lg := 0 ;
    var dg : double ; dg := 1000000000 ;
    dg := dg*(dg) ; 
    var count : int ; count := 0 ;
    while (dg - lg > eps & count < 100000) do (     count := count + 1 ; 
     var s : double ; s := (dg + lg) / 2 ;
    var moze : boolean ; moze := true ;
    var tmin : double ; tmin := -1000000000000000000.0 ;
        var i : int ; i := 0 ; while moze & i < c do ( (     var t1 : double ; t1 := Set{tmin, p[i+1].position - s}->max() ;
     var tlast : double ; tlast := t1 + (p[i+1].total - 1)->oclAsType(double) * d->oclAsType(double) ;
     if (tlast - p[i+1].position > s + eps) then     moze := false ; else     tmin := tlast + d->oclAsType(double) ; )  ;     i := i + 1 ) ; 
    if (moze) then     dg := s else     lg := s ; ;  
 ) ; 
    OclFile["System.out"].println(dg + " " + lg) ; 
    skip ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    double M=(double)(m);
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    int max=0 ;
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      int x=(int)(Math.ceil(arr[i]/M));
      if(x>=max){
        max=x ;
        ans=i ;
      }
    }
    System.out.print(ans+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var M : double ; M := (m)->oclAsType(double) ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := ((arr[i+1] / M)->ceil())->oclAsType(int) ;
     if (x >= max) then (     max := x ; 
     ans := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(ans + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      long a=sc.nextLong();
      long b=sc.nextLong();
      if(b==1)System.out.println("NO");
      else {
        long z=a*b*b ;
        long x=a ;
        long y=z-a ;
        System.out.println("YES");
        System.out.println(x+" "+y+" "+z);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
     if (b = 1) then     OclFile["System.out"].println("NO") ; else (     var z : long ; z := a * b * b ;
     var x : long ; x := a ;
    var y : long ; y := z - a ;
    OclFile["System.out"].println("YES") ; 
    OclFile["System.out"].println(x + " " + y + " " + z) ; 
 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round1b ;
import java.io.FileInputStream ;
import java.io.FileNotFoundException ;
import java.io.FileOutputStream ;
import java.util.ArrayList ;
import java.util.Collections ;
import qual2011.Kattio ;
public class B {
  public static void main(String[] args)throws FileNotFoundException {
    Kattio io ;
    io=new Kattio(new FileInputStream("src/round1b/B-large-0.in"),new FileOutputStream("src/round1b/B-large-0.out"));
    int cases=io.getInt();
    for(int i=1 ; i<=cases ; i++){
      io.print("Case #"+i+": ");
      new B().solve(io);
    }
    io.close();
  }
  private void solve(Kattio io){
    int C=io.getInt(),D=io.getInt();
    ArrayList<Long>vendor=new ArrayList<Long>();
    for(int i=0 ; i<C ; i++){
      int P=io.getInt(),V=io.getInt();
      for(int j=0 ; j<V ; j++){
        vendor.add((long)P*2);
      }
    }
    D*=2 ;
    Collections.sort(vendor);
    long lo=0,hi=2000000000000L ;
    int iter=0 ;
    long best=hi ;
    while(hi>lo){
      long x=(hi+lo)/2 ;
      long allowed=vendor.get(0)-x ;
      boolean ok=true ;
      for(Long v : vendor){
        long t=Math.max(allowed,v-x);
        if(Math.abs(t-v)>x){
          ok=false ;
          break ;
        }
        allowed=t+D ;
      }
      if(ok){
        hi=x ;
        best=x ;
      }
      else {
        lo=x+1 ;
      }
      iter++;
    }
    io.println(best/2.0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : Kattio ;
     io := Kattio.newKattio(OclFile.newOclFile_Read(OclFile.newOclFile("src/round1b/B-large-0.in")), OclFile.newOclFile_Write(OclFile.newOclFile("src/round1b/B-large-0.out"))) ; 
    var cases : int ; cases := io.getInt() ;
        var i : int ; i := 1 ; while i <= cases do ( (     io.print("Case #" + i + ": ") ; 
     B.newB().solve(io) )  ;     i := i + 1 ) ; 
    io.close() ; 
 );
   operation solve( io : Kattio) : void
  pre: true
  post: true
  activity: (     var C : int ; C := io.getInt() ;
    var D : int ; D := io.getInt() ;
     var vendor : Sequence(long) ; vendor := Sequence{} ;
        var i : int ; i := 0 ; while i < C do ( (     var P : int ; P := io.getInt() ;
    var V : int ; V := io.getInt() ;
         var j : int ; j := 0 ; while j < V do ( (     vendor := vendor->including(P->oclAsType(long) * 2) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    D := D*(2) ; 
    vendor := vendor->sort() ; 
    var lo : long ; lo := 0 ;
    var hi : long ; hi := 2000000000000L ;
    var iter : int ; iter := 0 ;
    var best : long ; best := hi ;
    while (hi > lo) do (     var x : long ; x := (hi + lo) / 2 ;
     var allowed : long ; allowed := vendor->at(0+1) - x ;
    var ok : boolean ; ok := true ;
    for (v : vendor) do ( (     var t : long ; t := Set{allowed, v - x}->max() ;
     if (if t - v < 0 then -(t - v) else t - v endif > x) then (     ok := false ; 
     break ) else skip ; 
     allowed := t + D )  ) ; 
    if (ok) then (     hi := x ; 
     best := x ) else (     lo := x + 1 ) ;  
    iter := iter + 1 ; 
 ) ; 
    io.println(best / 2.0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class B {
  public static void main(String[] args)throws Exception {
    new B().run();
  }
  final double EPS=1e-9 ;
  void run()throws Exception {
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    for(int o=1 ; o<=T ; o++){
      int C=sc.nextInt();
      int D=sc.nextInt();
      ArrayList<Integer>ps=new ArrayList<Integer>();
      for(int i=0 ; i<C ; i++){
        int P=sc.nextInt();
        int V=sc.nextInt();
        for(int j=0 ; j<V ; j++)ps.add(P);
      }
      Collections.sort(ps);
      double left=0,right=1e13 ;
      double ans=right*2 ;
      for(int e=0 ; e<200 ; e++){
        double m=(left+right)/2 ;
        if(ok(ps,D,m)){
          right=m ;
          ans=min(m,ans);
        }
        else {
          left=m ;
        }
      }
      System.out.printf("Case #%d: %f\n",o,ans);
    }
  }
  boolean ok(ArrayList<Integer>ps,int D,double len){
    double last=ps.get(0)-len ;
    for(int i=1 ; i<ps.size(); i++){
      double p=ps.get(i);
      if(p-last+len<D+EPS)return false ;
      if(p-last-len>D-EPS){
        last=p-len ;
      }
      else {
        last+=D ;
      }
    }
    return true ;
  }
}
class CL implements Comparable<CL>{
  int pos ;
  int num ;
  CL(int p,int v){
    pos=p ;
    num=v ;
  }
  public int compareTo(CL cl){
    return this.pos-cl.pos ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     B.newB().run() );
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var o : int ; o := 1 ; while o <= T do ( (     var C : int ; C := sc.getCurrent()->toInteger() ;
     var D : int ; D := sc.getCurrent()->toInteger() ;
    var ps : Sequence(int) ; ps := Sequence{} ;
        var i : int ; i := 0 ; while i < C do ( (     var P : int ; P := sc.getCurrent()->toInteger() ;
     var V : int ; V := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < V do (     ps := ps->including(P) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    ps := ps->sort() ; 
    var left : double ; left := 0 ;
    var right : double ; right := 1e13 ;
    var ans : double ; ans := right * 2 ;
        var e : int ; e := 0 ; while e < 200 do ( (     var m : double ; m := (left + right) / 2 ;
     if (ok(ps, D, m)) then (     right := m ; 
     ans := Set{m, ans}->min() ) else (     left := m ) )  ;     e := e + 1 ) ; 
    OclFile["System.out"].printf("Case #%d: %f\n", o, ans) ; 
 )  ;     o := o + 1 ) );
   operation ok( ps : Sequence(int), D : int, len : double) : boolean
  pre: true
  post: true
  activity: (     var last : double ; last := ps->at(0+1) - len ;
         var i : int ; i := 1 ; while i < ps->size() do ( (     var p : double ; p := ps->at(i+1) ;
     if (p - last + len < D + EPS) then     return false else skip ; 
     if (p - last - len > D - EPS) then (     last := p - len ) else (     last := last+(D) ) )  ;     i := i + 1 ) ; 
     return true );
}
class CL implements Comparable<CL> {
   attribute pos : int;
   attribute num : int;
   static operation newCL( p : int, v : int) : CL
  pre: true
  post: true
  activity:
  ( var self : CL ;
    self := createCL();
    self.initialise(p, v);
    return self );
  operation initialise( p : int, v : int) : void
  pre: true  post: true
  activity: (     pos := p ; 
     num := v );
   operation compareTo( cl : CL) : int
  pre: true
  post: true
  activity: (     return self.pos - cl.pos );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class B implements Runnable {
  public void solve()throws IOException {
    int tn=in.nextInt();
    for(int test=1 ; test<=tn ; test++){
      int n=in.nextInt();
      int d=in.nextInt();
      int[] v=new int[n];
      int[] x=new int[n];
      for(int i=0 ; i<n ; i++){
        x[i]=in.nextInt();
        v[i]=in.nextInt();
      }
      double l=0.0 ;
      double r=1E14 ;
      while(r-l>0.1){
        double t=0.5*(l+r);
        double X=Double.NEGATIVE_INFINITY ;
        boolean ok=true ;
        for(int i=0 ; i<n ; i++){
          X=Math.max(X+d,x[i]-t)+(v[i]-1)*1.0*d ;
          if(Math.abs(X-x[i])>t){
            ok=false ;
            break ;
          }
        }
        if(ok){
          r=t ;
        }
        else {
          l=t ;
        }
      }
      out.println("Case #"+test+": "+Math.round(l+r)*0.5);
    }
  }
  public Scanner in ;
  public PrintWriter out ;
  B()throws IOException {
    in=new Scanner(System.in);
    out=new PrintWriter(System.out);
  }
  void close()throws IOException {
    out.close();
  }
  void check(boolean f,String msg){
    if(! f){
      out.close();
      throw new RuntimeException(msg);
    }
  }
  public void run(){
    try {
      solve();
      close();
    }
    catch(Exception e){
      e.printStackTrace(out);
      out.flush();
      throw new RuntimeException(e);
    }
  }
  public static void main(String[] args)throws IOException {
    new Thread(new B()).start();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B implements Runnable {
   operation solve() : void
  pre: true
  post: true
  activity: (     var tn : int ; tn := in.nextInt() ;
         var test : int ; test := 1 ; while test <= tn do ( (     var n : int ; n := in.nextInt() ;
     var d : int ; d := in.nextInt() ;
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := in.nextInt() ; 
     v[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    var l : double ; l := 0.0 ;
    var r : double ; r := 1E14 ;
    while (r - l > 0.1) do (     var t : double ; t := 0.5 * (l + r) ;
     var X : double ; X := Math_NINFINITY ;
    var ok : boolean ; ok := true ;
        var i : int ; i := 0 ; while i < n do ( (     X := Set{X + d, x[i+1] - t}->max() + (v[i+1] - 1) * 1.0 * d ; 
     if (if X - x[i+1] < 0 then -(X - x[i+1]) else X - x[i+1] endif > t) then (     ok := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (ok) then (     r := t ) else (     l := t ) ;  
 ) ; 
    out.println("Case #" + test + ": " + (l + r)->round() * 0.5) ; 
 )  ;     test := test + 1 ) );
   attribute in : OclFile;
   attribute out : OclFile;
   static operation newB() : B
  pre: true
  post: true
  activity:
  ( var self : B ;
    self := createB();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
   operation check( f : boolean, msg : String) : void
  pre: true
  post: true
  activity: (     if (not(f)) then (     skip ; 
     error ProgramException(msg) ) else skip );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     execute solve() ; 
     execute close() )   catch (e : ProgramException) do (     e.printStackTrace(out) ; 
     skip ; 
     error ProgramException(e) )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(B.newB()).start() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static long findWays(int f,int d,int s){
    long mem[][]=new long[d+1][s+1];
    mem[0][0]=1 ;
    for(int i=1 ; i<=d ; i++){
      for(int j=i ; j<=s ; j++){
        mem[i][j]=mem[i][j-1]+mem[i-1][j-1];
        if(j-f-1>=0)mem[i][j]-=mem[i-1][j-f-1];
      }
    }
    return mem[d][s];
  }
  public static void main(String[] args){
    System.out.println(findWays(4,2,1));
    System.out.println(findWays(2,2,3));
    System.out.println(findWays(6,3,8));
    System.out.println(findWays(4,2,5));
    System.out.println(findWays(4,3,5));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findWays( f : int, d : int, s : int) : long
  pre: true
  post: true
  activity: (     var mem : Sequence(Sequence(long)) ; mem := Integer.subrange(1,d + 1)->collect(Integer.subrange(1,s + 1)->collect(0)) ;
     mem[0+1][0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= d do ( (         var j : int ; j := i ; while j <= s do ( (     mem[i+1][j+1] := mem[i+1][j - 1+1] + mem[i - 1+1][j - 1+1] ; 
     if (j - f - 1 >= 0) then     mem[i+1][j+1] := mem[i+1][j+1]-(mem[i - 1+1][j - f - 1+1]) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return mem[d+1][s+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(findWays(4, 2, 1)) ; 
     OclFile["System.out"].println(findWays(2, 2, 3)) ; 
    OclFile["System.out"].println(findWays(6, 3, 8)) ; 
    OclFile["System.out"].println(findWays(4, 2, 5)) ; 
    OclFile["System.out"].println(findWays(4, 3, 5)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int Z=sc.nextInt();
    int W=sc.nextInt();
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++)a[i]=sc.nextInt();
    int ans=Math.abs(a[N-1]-W);
    int[] dp=new int[N+1];
    for(int i=N-1 ; i>=1 ; i--){
      int min=Math.abs(a[N-1]-a[i-1]);
      int maxV=0 ;
      for(int j=N-1 ; j>i ; j--){
        int max=Math.abs(a[N-1]-a[j-1]);
        if(j<N-1)maxV=Math.max(maxV,dp[j+1]);
        max=Math.max(max,maxV);
        if(max<min){
          min=max ;
        }
      }
      dp[i]=min ;
    }
    for(int i=1 ; i<N ; i++)ans=Math.max(ans,dp[i]);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var Z : int ; Z := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := if a[N - 1+1] - W < 0 then -(a[N - 1+1] - W) else a[N - 1+1] - W endif ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := N - 1 ; while i >= 1 do ( (     var min : int ; min := if a[N - 1+1] - a[i - 1+1] < 0 then -(a[N - 1+1] - a[i - 1+1]) else a[N - 1+1] - a[i - 1+1] endif ;
     var maxV : int ; maxV := 0 ;
         var j : int ; j := N - 1 ; while j > i do ( (     var max : int ; max := if a[N - 1+1] - a[j - 1+1] < 0 then -(a[N - 1+1] - a[j - 1+1]) else a[N - 1+1] - a[j - 1+1] endif ;
     if (j < N - 1) then     maxV := Set{maxV, dp[j + 1+1]}->max() ; else skip ; 
     max := Set{max, maxV}->max() ; 
     if (max < min) then (     min := max ) else skip )  ;     j := j - 1 ) ; 
     dp[i+1] := min )  ;     i := i - 1 ) ; 
        var i : int ; i := 1 ; while i < N do (     ans := Set{ans, dp[i+1]}->max() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
import java.util.stream.Stream ;
class Main {
  static class System {
    private static final InputStream in=java.lang.System.in ;
    private static final PrintWriter out=new PrintWriter(java.lang.System.out,false);
  }
  public static void main(String[] $){
    new Main().solve();
    System.out.flush();
  }
  static Scanner s=new Scanner(System.in);
  static IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static IntStream REPS(int l,int r){
    return IntStream.rangeClosed(l,r);
  }
  static int gInt(){
    return s.nextInt();
  }
  static long gLong(){
    return s.nextLong();
  }
  static long gDouble(){
    return s.nextLong();
  }
  static IntStream ints(int n){
    return REPS(n).map(i->gInt());
  }
  static Stream<String>strs(int n){
    return REPS(n).mapToObj(i->s.next());
  }
  private void solve(){
    int n=gInt(),x=gInt(),y=gInt(),a[]=ints(n).distinct().toArray();
    n=a.length ;
    if(n==1)System.out.println(Math.abs(a[0]-y));
    else System.out.println(Math.max(Math.abs(a[n-1]-y),Math.abs(a[n-2]-a[n-1])));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class System {
  static    attribute in : OclFile := java.lang.System.in;
  static    attribute out : OclFile := OclFile.newOclFile_Write(java.lang.System.out, false);
}
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() ; 
     OclFile["System.out"].flush() );
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static   operation REPS( l : int, r : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(l, r) );
  static   operation gInt() : int
  pre: true
  post: true
  activity: (     return s.getCurrent()->toInteger() );
  static   operation gLong() : long
  pre: true
  post: true
  activity: (     return s.getCurrent()->toLong() );
  static   operation gDouble() : long
  pre: true
  post: true
  activity: (     return s.getCurrent()->toLong() );
  static   operation ints( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return REPS(n)->collect( _x1 | (lambda i : OclAny in gInt())->apply(_x1) ) );
  static   operation strs( n : int) : Stream<String>
  pre: true
  post: true
  activity: (     return REPS(n).mapToObj(lambda i : OclAny in s.getCurrent()) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := gInt() ;
    var x : int ; x := gInt() ;
    var y : int ; y := gInt() ;
    var a : Sequence(void) ; a := ints(n)->asOrderedSet()->asSequence() ;
     n := a->size() ; 
     if (n = 1) then     OclFile["System.out"].println(if a[0+1] - y < 0 then -(a[0+1] - y) else a[0+1] - y endif) ; else     OclFile["System.out"].println(Set{if a[n - 1+1] - y < 0 then -(a[n - 1+1] - y) else a[n - 1+1] - y endif, if a[n - 2+1] - a[n - 1+1] < 0 then -(a[n - 2+1] - a[n - 1+1]) else a[n - 2+1] - a[n - 1+1] endif}->max()) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] cards=new int[n+2];
    for(int i=0 ; i<n+2 ; i++){
      cards[i]=sc.nextInt();
    }
    int[][] mainTable=new int[n+2][n+2];
    int[][] subTable=new int[n+2][n+2];
    for(int j=0 ; j<n+1 ; j++){
      mainTable[j][n+1]=Math.abs(cards[j]-cards[n+1]);
      mainTable[n+1][j]=Math.abs(cards[j]-cards[n+1]);
      subTable[j][n+1]=Math.abs(cards[j]-cards[n+1]);
      subTable[n+1][j]=Math.abs(cards[j]-cards[n+1]);
    }
    for(int i=n ; i>=1 ; i--){
      for(int j=0 ; j<i ; j++){
        mainTable[i][j]=subTable[i][i+1];
        subTable[i][j]=Math.max(mainTable[i][j],subTable[i+1][j]);
        mainTable[j][i]=subTable[i+1][i];
        subTable[j][i]=Math.min(mainTable[j][i],subTable[j][i+1]);
      }
    }
    System.out.println(mainTable[0][1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var cards : Sequence(int) ; cards := Integer.subrange(1,n + 2)->collect(0) ;
        var i : int ; i := 0 ; while i < n + 2 do ( (     cards[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var mainTable : Sequence(Sequence(int)) ; mainTable := Integer.subrange(1,n + 2)->collect(Integer.subrange(1,n + 2)->collect(0)) ;
    var subTable : Sequence(Sequence(int)) ; subTable := Integer.subrange(1,n + 2)->collect(Integer.subrange(1,n + 2)->collect(0)) ;
        var j : int ; j := 0 ; while j < n + 1 do ( (     mainTable[j+1][n + 1+1] := if cards[j+1] - cards[n + 1+1] < 0 then -(cards[j+1] - cards[n + 1+1]) else cards[j+1] - cards[n + 1+1] endif ; 
     mainTable[n + 1+1][j+1] := if cards[j+1] - cards[n + 1+1] < 0 then -(cards[j+1] - cards[n + 1+1]) else cards[j+1] - cards[n + 1+1] endif ; 
     subTable[j+1][n + 1+1] := if cards[j+1] - cards[n + 1+1] < 0 then -(cards[j+1] - cards[n + 1+1]) else cards[j+1] - cards[n + 1+1] endif ; 
     subTable[n + 1+1][j+1] := if cards[j+1] - cards[n + 1+1] < 0 then -(cards[j+1] - cards[n + 1+1]) else cards[j+1] - cards[n + 1+1] endif )  ;     j := j + 1 ) ; 
        var i : int ; i := n ; while i >= 1 do ( (         var j : int ; j := 0 ; while j < i do ( (     mainTable[i+1][j+1] := subTable[i+1][i + 1+1] ; 
     subTable[i+1][j+1] := Set{mainTable[i+1][j+1], subTable[i + 1+1][j+1]}->max() ; 
     mainTable[j+1][i+1] := subTable[i + 1+1][i+1] ; 
     subTable[j+1][i+1] := Set{mainTable[j+1][i+1], subTable[j+1][i + 1+1]}->min() )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(mainTable[0+1][1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] $){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt(),z=s.nextInt(),w=s.nextInt(),a[]=new int[n--];
    Arrays.setAll(a,i->s.nextInt());
    System.out.println(n==0 ? Math.abs(a[0]-w): Math.max(Math.abs(a[n]-w),Math.abs(a[n-1]-a[n])));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var z : int ; z := s.getCurrent()->toInteger() ;
    var w : int ; w := s.getCurrent()->toInteger() ;
    var a : Sequence(void) ; a := Integer.subrange(1,n)->collect(0) ;
 setAll(a, lambda i : OclAny in s.getCurrent()->toInteger()) ; 
     OclFile["System.out"].println(if n = 0 then if a[0+1] - w < 0 then -(a[0+1] - w) else a[0+1] - w endif else Set{if a[n+1] - w < 0 then -(a[n+1] - w) else a[n+1] - w endif, if a[n - 1+1] - a[n+1] < 0 then -(a[n - 1+1] - a[n+1]) else a[n - 1+1] - a[n+1] endif}->max() endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long z=sc.nextLong();
    long w=sc.nextLong();
    long[] ar=new long[n];
    for(int i=0 ; i<n ; i++){
      ar[i]=sc.nextLong();
    }
    if(n==1){
      System.out.println(Math.abs(ar[0]-w));
    }
    else {
      long ans=0 ;
      for(int i=1 ; i<ar.length ; i++){
        ans=Math.max(Math.abs(ar[i]-w),Math.abs(ar[i]-ar[i-1]));
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var z : long ; z := sc.getCurrent()->toLong() ;
    var w : long ; w := sc.getCurrent()->toLong() ;
    var ar : Sequence(long) ; ar := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    if (n = 1) then (     OclFile["System.out"].println(if ar[0+1] - w < 0 then -(ar[0+1] - w) else ar[0+1] - w endif) ) else (     var ans : long ; ans := 0 ;
         var i : int ; i := 1 ; while i < ar->size() do ( (     ans := Set{if ar[i+1] - w < 0 then -(ar[i+1] - w) else ar[i+1] - w endif, if ar[i+1] - ar[i - 1+1] < 0 then -(ar[i+1] - ar[i - 1+1]) else ar[i+1] - ar[i - 1+1] endif}->max() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Z_ccc_12_2 {
  static int p[];
  public static void main(String args[])throws IOException {
    InputStreamReader r=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(r);
    int n=Integer.parseInt(br.readLine());
    p=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      p[i]=Integer.parseInt(br.readLine());
    }
    int max=dfs(1,1);
    for(int i=2 ; i<=n ; i++){
      max=Integer.max(max,dfs(i,1));
    }
    System.out.println(max);
  }
  public static int dfs(int index,int depth){
    if(p[index]==-1){
      return depth ;
    }
    else {
      return dfs(p[index],depth+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Z_ccc_12{
  static   attribute p : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(r) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    p := Integer.subrange(1,n + 1)->collect(0) ; 
        var i : int ; i := 1 ; while i <= n do ( (     p[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    var max : int ; max := dfs(1, 1) ;
        var i : int ; i := 2 ; while i <= n do ( (     max := Set{max, dfs(i, 1)}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static   operation dfs( index : int, depth : int) : int
  pre: true
  post: true
  activity: (     if (p[index+1] = -1) then (     return depth ) else (     return dfs(p[index+1], depth + 1) ) );
}
 {
  static   attribute p : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(r) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    p := Integer.subrange(1,n + 1)->collect(0) ; 
        var i : int ; i := 1 ; while i <= n do ( (     p[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    var max : int ; max := dfs(1, 1) ;
        var i : int ; i := 2 ; while i <= n do ( (     max := Set{max, dfs(i, 1)}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static   operation dfs( index : int, depth : int) : int
  pre: true
  post: true
  activity: (     if (p[index+1] = -1) then (     return depth ) else (     return dfs(p[index+1], depth + 1) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    for(; ; ){
      String s=sc.next();
      String t=sc.next();
      if(s.equals("0")){
        break ;
      }
      int hit=0,blow=0 ;
      for(int j=0 ; j<4 ; j++){
        if(t.charAt(j)==s.charAt(j)){
          hit++;
        }
        for(int i=0 ; i<4 ; i++){
          if(t.charAt(j)==s.charAt(i)){
            blow++;
          }
        }
      }
      blow-=hit ;
      println(hit+" "+blow);
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var s : String ; s := sc.getCurrent() ;
     var t : String ; t := sc.getCurrent() ;
    if (s = "0") then (     break ) else skip ; 
    var hit : int ; hit := 0 ;
    var blow : int ; blow := 0 ;
        var j : int ; j := 0 ; while j < 4 do ( (     if (t->at(j+1) = s->at(j+1)) then (     hit := hit + 1 ) else skip ; 
         var i : int ; i := 0 ; while i < 4 do ( (     if (t->at(j+1) = s->at(i+1)) then (     blow := blow + 1 ) else skip )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    blow := blow-(hit) ; 
    execute println(hit + " " + blow) ; 
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class CompositeColoring {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t!=0){
      solve(br,pr);
      t--;
    }
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    String[] temp=br.readLine().split(" ");
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=Integer.parseInt(temp[i]);
    }
    List<Integer>primes=new ArrayList<>();
    Collections.addAll(primes,2,3,5,7,11,13,17,19,23,29,31);
    int[] res=new int[n];
    Map<Integer,Integer>used=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int num=nums[i];
      for(int j=0 ; j<11 ; j++){
        if(num % primes.get(j)==0){
          int prime=primes.get(j);
          if(used.containsKey(prime)){
            res[i]=used.get(prime);
          }
          else {
            used.put(prime,used.size()+1);
            res[i]=used.get(prime);
          }
          break ;
        }
      }
    }
    pr.println(used.size());
    for(int i : res){
      pr.print(i+" ");
    }
    pr.print('\n');
  }
}
------------------------------------------------------------
OCL File:
---------
 class CompositeColoring {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
    while (t /= 0) do (     execute solve(br, pr) ; 
     t := t - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := (temp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var primes : Sequence(int) ; primes := Sequence{} ;
addAll(primes, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31) ; 
    var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
    var used : Map(int,int) ; used := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := nums[i+1] ;
         var j : int ; j := 0 ; while j < 11 do ( (     if (num mod primes->at(j+1) = 0) then (     var prime : int ; prime := primes->at(j+1) ;
     if (used->keys()->includes(prime)) then (     res[i+1] := used->at(prime) ) else (     used := used->union(Map{prime |-> used.size() + 1}) ; 
     res[i+1] := used->at(prime) ) ;  
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    for (i : res) do ( (     skip )  ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double innerCirclearea(double radius){
    if(radius<0){
      return-1 ;
    }
    double r=radius/2 ;
    double Area=(3.14*Math.pow(r,2));
    return Area ;
  }
  public static void main(String arr[]){
    double radius=4 ;
    System.out.println("Area of circle c2="+innerCirclearea(radius));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation innerCirclearea( radius : double) : double
  pre: true
  post: true
  activity: (     if (radius < 0) then (     return -1 ) else skip ; 
     var r : double ; r := radius / 2 ;
     var Area : double ; Area := (3.14 * r->pow(2)) ;
     return Area );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var radius : double ; radius := 4 ;
     OclFile["System.out"].println("Area of circle c2=" + innerCirclearea(radius)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void getXandYintercept(int P[],int Q[]){
    int a=P[1]-Q[1];
    int b=P[0]-Q[0];
    if(b==0){
      System.out.println(P[0]);
      System.out.println("infinity");
      return ;
    }
    if(a==0){
      System.out.println("infinity");
      System.out.println(P[1]);
      return ;
    }
    double m=a/(b*1.0);
    int x=P[0];
    int y=P[1];
    double c=y-m*x ;
    y=0 ;
    double r=(y-c)/(m*1.0);
    System.out.println(r);
    x=0 ;
    y=(int)(m*x+c);
    System.out.print(c);
  }
  public static void main(String[] args){
    int p1[]={
      5,2 };
      int p2[]={
        2,7 };
        getXandYintercept(p1,p2);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getXandYintercept( P : Sequence(int), Q : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := P[1+1] - Q[1+1] ;
     var b : int ; b := P[0+1] - Q[0+1] ;
    if (b = 0) then (     OclFile["System.out"].println(P[0+1]) ; 
     OclFile["System.out"].println("infinity") ; 
     return ) else skip ; 
    if (a = 0) then (     OclFile["System.out"].println("infinity") ; 
     OclFile["System.out"].println(P[1+1]) ; 
     return ) else skip ; 
    var m : double ; m := a / (b * 1.0) ;
    var x : int ; x := P[0+1] ;
    var y : int ; y := P[1+1] ;
    var c : double ; c := y - m * x ;
    y := 0 ; 
    var r : double ; r := (y - c) / (m * 1.0) ;
    OclFile["System.out"].println(r) ; 
    x := 0 ; 
    y := (m * x + c)->oclAsType(int) ; 
    OclFile["System.out"].print(c) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p1 : Sequence(int) ; p1 := Sequence{5,2} ;
     var p2 : Sequence(int) ; p2 := Sequence{2,7} ;
     execute getXandYintercept(p1, p2) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxConsecutiveOnes(int x){
    int count=0 ;
    while(x!=0){
      x=(x &(x<<1));
      count++;
    }
    return count ;
  }
  static int maxOnes(int arr[],int n){
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      int currMax=maxConsecutiveOnes(arr[i]);
      ans=Math.max(ans,currMax);
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4 };
      int n=arr.length ;
      System.out.println(maxOnes(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxConsecutiveOnes( x : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (x /= 0) do (     x := (x & ((x*(2->pow(1)))->oclAsType(long))) ; 
     count := count + 1 ) ; 
     return count );
  static   operation maxOnes( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var currMax : int ; currMax := maxConsecutiveOnes(arr[i+1]) ;
     ans := Set{ans, currMax}->max() )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxOnes(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int ans=1 ;
    if((n % k)==0)ans=0 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 1 ;
    if ((n mod k) = 0) then     ans := 0 ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    MyScanner in=new MyScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    A solver=new A();
    solver.solve(1,in,out);
    out.close();
  }
  static class A {
    public void solve(int testNumber,MyScanner in,PrintWriter out){
      int N=in.nextInt();
      int K=in.nextInt();
      out.println(N % K==0 ? 0 : 1);
    }
  }
  static class MyScanner {
    private BufferedReader in ;
    private StringTokenizer st ;
    public MyScanner(InputStream stream){
      in=new BufferedReader(new InputStreamReader(stream));
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          String rl=in.readLine();
          if(rl==null){
            return null ;
          }
          st=new StringTokenizer(rl);
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : MyScanner ; in := MyScanner.newMyScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : A ; solver := A.newA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class A {
   operation solve( testNumber : int, in : MyScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.nextInt() ;
     var K : int ; K := in.nextInt() ;
     skip );
}
  static class MyScanner {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner( stream : OclFile) : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     var rl : String ; rl := in.readLine() ;
     if (rl = null) then (     return null ) else skip ; 
     st := OclIterator.newOclIterator_String(rl) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.IOException ;
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Deque ;
import java.util.Scanner ;
import javax.swing.plaf.synth.SynthSeparatorUI ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    if(N % K==0)System.out.println(0);
    else System.out.println(1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
     if (N mod K = 0) then     OclFile["System.out"].println(0) ; else     OclFile["System.out"].println(1) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int N=stdIn.nextInt();
    int K=stdIn.nextInt();
    if(N % K==0){
      System.out.println(0);
    }
    else {
      System.out.println(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := stdIn.getCurrent()->toInteger() ;
     var K : int ; K := stdIn.getCurrent()->toInteger() ;
     if (N mod K = 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(1) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String[] nyu=sc.nextLine().split(" ");
    int A=Integer.parseInt(nyu[0]);
    int B=Integer.parseInt(nyu[1]);
    if(A % B==0){
      System.out.println(0);
    }
    else {
      System.out.println(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var nyu : Sequence(String) ; nyu := sc.nextLine()->split(" ") ;
    var A : int ; A := (nyu[0+1])->toInteger() ;
    var B : int ; B := (nyu[1+1])->toInteger() ;
    if (A mod B = 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void PrintMinNumberForPattern(String arr){
    int curr_max=0 ;
    int last_entry=0 ;
    int j ;
    for(int i=0 ; i<arr.length(); i++){
      int noOfNextD=0 ;
      switch(arr.charAt(i)){
        case 'I' : j=i+1 ;
        while(j<arr.length()&& arr.charAt(j)=='D'){
          noOfNextD++;
          j++;
        }
        if(i==0){
          curr_max=noOfNextD+2 ;
          System.out.print(" "+++last_entry);
          System.out.print(" "+curr_max);
          last_entry=curr_max ;
        }
        else {
          curr_max=curr_max+noOfNextD+1 ;
          last_entry=curr_max ;
          System.out.print(" "+last_entry);
        }
        for(int k=0 ; k<noOfNextD ; k++){
          System.out.print(" "+--last_entry);
          i++;
        }
        break ;
        case 'D' : if(i==0){
          j=i+1 ;
          while(j<arr.length()&& arr.charAt(j)=='D'){
            noOfNextD++;
            j++;
          }
          curr_max=noOfNextD+2 ;
          System.out.print(" "+curr_max+" "+(curr_max-1));
          last_entry=curr_max-1 ;
        }
        else {
          System.out.print(" "+(last_entry-1));
          last_entry--;
        }
        break ;
      }
    }
    System.out.println();
  }
  public static void main(String[] args){
    PrintMinNumberForPattern("IDID");
    PrintMinNumberForPattern("I");
    PrintMinNumberForPattern("DD");
    PrintMinNumberForPattern("II");
    PrintMinNumberForPattern("DIDI");
    PrintMinNumberForPattern("IIDDD");
    PrintMinNumberForPattern("DDIDDIID");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation PrintMinNumberForPattern( arr : String) : void
  pre: true
  post: true
  activity: (     var curr_max : int ; curr_max := 0 ;
     var last_entry : int ; last_entry := 0 ;
    var j : int ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     var noOfNextD : int ; noOfNextD := 0 ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (arr->at(i+1)) ; 
       if _switchval = 'I' then
     j := i + 1 ; 
    while (j < arr->size() & arr->at(j+1) = 'D') do (     noOfNextD := noOfNextD + 1 ; 
     j := j + 1 ) ; 
    if (i = 0) then (     curr_max := noOfNextD + 2 ; 
     OclFile["System.out"].print(" " + last_entry) ; 
     OclFile["System.out"].print(" " + curr_max) ; 
     last_entry := curr_max ) else (     curr_max := curr_max + noOfNextD + 1 ; 
     last_entry := curr_max ; 
     OclFile["System.out"].print(" " + last_entry) ) ;  
        var k : int ; k := 0 ; while k < noOfNextD do ( (     OclFile["System.out"].print(" " + (last_entry - 1)) ; 
     i := i + 1 )  ;     k := k + 1 ) ; 
    break 
   else skip ;
       if _switchval = 'D' then
     if (i = 0) then (     j := i + 1 ; 
     while (j < arr->size() & arr->at(j+1) = 'D') do (     noOfNextD := noOfNextD + 1 ; 
     j := j + 1 ) ; 
    curr_max := noOfNextD + 2 ; 
    OclFile["System.out"].print(" " + curr_max + " " + (curr_max - 1)) ; 
    last_entry := curr_max - 1 ; 
 ) else (     OclFile["System.out"].print(" " + (last_entry - 1)) ; 
     last_entry := last_entry - 1 ) ;  
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute PrintMinNumberForPattern("IDID") ; 
     execute PrintMinNumberForPattern("I") ; 
    execute PrintMinNumberForPattern("DD") ; 
    execute PrintMinNumberForPattern("II") ; 
    execute PrintMinNumberForPattern("DIDI") ; 
    execute PrintMinNumberForPattern("IIDDD") ; 
    execute PrintMinNumberForPattern("DDIDDIID") ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    char[] r=new char[4];
    char[] a=new char[4];
    while(in.hasNext()){
      r=in.next().toCharArray();
      a=in.next().toCharArray();
      if(r.length==1){
        break ;
      }
      int hit=0,brow=0 ;
      for(int i=0 ; i<4 ; i++){
        for(int j=0 ; j<4 ; j++){
          if(r[i]==a[j]){
            if(i==j){
              hit++;
            }
            else {
              brow++;
            }
            break ;
          }
        }
      }
      System.out.println(hit+" "+brow);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : Sequence(String) ; r := Integer.subrange(1,4)->collect(0) ;
     var a : Sequence(String) ; a := Integer.subrange(1,4)->collect(0) ;
     while (in.hasNext()) do (     r := in.getCurrent()->characters() ; 
     a := in.getCurrent()->characters() ; 
    if (r->size() = 1) then (     break ) else skip ; 
    var hit : int ; hit := 0 ;
    var brow : int ; brow := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < 4 do ( (     if (r[i+1] = a[j+1]) then (     if (i = j) then (     hit := hit + 1 ) else (     brow := brow + 1 ) ;  
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(hit + " " + brow) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int[] solve(int n){
    int low=1,high=(int)1e4,x=n,p=0 ;
    while(low<=high){
      int mid=(low+high)/2 ;
      int sum=(mid*(mid+1))/2 ;
      if(x-sum>=1){
        p=mid ;
        low=mid+1 ;
      }
      else {
        high=mid-1 ;
      }
    }
    int start=1,end=(int)1e4,y=1,q=0 ;
    while(start<=end){
      int mid=(start+end)/2 ;
      int sum=(mid*(mid+1))/2 ;
      if(y+sum<=n){
        q=mid ;
        start=mid+1 ;
      }
      else {
        end=mid-1 ;
      }
    }
    x=x-(p*(p+1))/2 ;
    y=y+(q*(q+1))/2 ;
    int r=x ;
    int c=q+1-n+y ;
    int ans[]={
      r,c };
      return ans ;
    }
    public static void main(String[] args){
      int n=5 ;
      int[] p=solve(n);
      System.out.println(p[0]+" "+p[1]);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var low : int ; low := 1 ;
    var high : int ; high := 1e4->oclAsType(int) ;
    var x : int ; x := n ;
    var p : int ; p := 0 ;
     while (low <= high) do (     var mid : int ; mid := (low + high) / 2 ;
     var sum : int ; sum := (mid * (mid + 1)) / 2 ;
     if (x - sum >= 1) then (     p := mid ; 
     low := mid + 1 ) else (     high := mid - 1 ) ) ; 
    var start : int ; start := 1 ;
    var end : int ; end := 1e4->oclAsType(int) ;
    var y : int ; y := 1 ;
    var q : int ; q := 0 ;
    while (start <= end) do (     var mid : int ; mid := (start + end) / 2 ;
     var sum : int ; sum := (mid * (mid + 1)) / 2 ;
     if (y + sum <= n) then (     q := mid ; 
     start := mid + 1 ) else (     end := mid - 1 ) ) ; 
    x := x - (p * (p + 1)) / 2 ; 
    y := y + (q * (q + 1)) / 2 ; 
    var r : int ; r := x ;
    var c : int ; c := q + 1 - n + y ;
    var ans : Sequence(int) ; ans := Sequence{r,c} ;
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var p : Sequence(int) ; p := solve(n) ;
     OclFile["System.out"].println(p[0+1] + " " + p[1+1]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int M=scanner.nextInt();
    int[][] edges=new int[M][2];
    int[][] graph=new int[N][N];
    for(int i=0 ; i<M ; i++){
      int a=scanner.nextInt()-1 ;
      int b=scanner.nextInt()-1 ;
      graph[a][b]=1 ;
      graph[b][a]=1 ;
      edges[i][0]=a ;
      edges[i][1]=b ;
    }
    int count=0 ;
    for(int i=0 ; i<M ; i++){
      int a=edges[i][0];
      int b=edges[i][1];
      graph[a][b]=0 ;
      graph[b][a]=0 ;
      boolean[] visited=new boolean[N];
      dfs(graph,visited,N,0);
      boolean bridge=false ;
      for(int j=0 ; j<N ; j++)if(! visited[j])bridge=true ;
      if(bridge)count++;
      graph[a][b]=1 ;
      graph[b][a]=1 ;
    }
    System.out.println(count);
  }
  private static void dfs(int[][] graph,boolean[] visited,int N,int i){
    visited[i]=true ;
    for(int j=0 ; j<N ; j++)if(graph[i][j]>0 && ! visited[j])dfs(graph,visited,N,j);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var M : int ; M := scanner.getCurrent()->toInteger() ;
    var edges : Sequence(Sequence(int)) ; edges := Integer.subrange(1,M)->collect(Integer.subrange(1,2)->collect(0)) ;
    var graph : Sequence(Sequence(int)) ; graph := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
        var i : int ; i := 0 ; while i < M do ( (     var a : int ; a := scanner.getCurrent()->toInteger() - 1 ;
     var b : int ; b := scanner.getCurrent()->toInteger() - 1 ;
    graph[a+1][b+1] := 1 ; 
    graph[b+1][a+1] := 1 ; 
    edges[i+1][0+1] := a ; 
    edges[i+1][1+1] := b ; 
 )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     var a : int ; a := edges[i+1][0+1] ;
     var b : int ; b := edges[i+1][1+1] ;
    graph[a+1][b+1] := 0 ; 
    graph[b+1][a+1] := 0 ; 
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,N)->collect(false) ;
    execute dfs(graph, visited, N, 0) ; 
    var bridge : boolean ; bridge := false ;
        var j : int ; j := 0 ; while j < N do (     if (not(visited[j+1])) then     bridge := true ; else skip ;  ;     j := j + 1 ) ; 
    if (bridge) then     count := count + 1 ; else skip ; 
    graph[a+1][b+1] := 1 ; 
    graph[b+1][a+1] := 1 ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation dfs( graph : Sequence(Sequence(int)), visited : Sequence(boolean), N : int, i : int) : void
  pre: true
  post: true
  activity: (     visited[i+1] := true ; 
         var j : int ; j := 0 ; while j < N do (     if (graph[i+1][j+1] > 0 & not(visited[j+1])) then     execute dfs(graph, visited, N, j) ; else skip ;  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Set<Integer>cnt=new HashSet<>();
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int vertices=sc.nextInt();
    int edges=sc.nextInt();
    List<List<Integer>>edge=new ArrayList<>();
    for(int i=0 ; i<edges ; i++){
      edge.add(Arrays.asList(sc.nextInt(),sc.nextInt()));
    }
    int ans=0 ;
    for(int i=0 ; i<edges ; i++){
      List<Integer>e=edge.remove(i);
      connected(mapGen(edge),edge.get(0).get(0));
      if(cnt.size()!=vertices)ans++;
      cnt.clear();
      edge.add(i,e);
    }
    System.out.println(ans);
  }
  private static Map<Integer,List<Integer>>mapGen(List<List<Integer>>edges){
    Map<Integer,List<Integer>>g=new HashMap<>();
    for(int i=0 ; i<edges.size(); i++){
      int v=edges.get(i).get(0);
      int w=edges.get(i).get(1);
      if(! g.containsKey(v))g.put(v,new ArrayList<>());
      if(! g.containsKey(w))g.put(w,new ArrayList<>());
      g.get(v).add(w);
      g.get(w).add(v);
    }
    return g ;
  }
  private static void connected(Map<Integer,List<Integer>>g,int v){
    if(cnt.contains(v))return ;
    cnt.add(v);
    for(int w : g.get(v)){
      connected(g,w);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute cnt : Set(int) := Set{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var vertices : int ; vertices := sc.getCurrent()->toInteger() ;
    var edges : int ; edges := sc.getCurrent()->toInteger() ;
    var edge : Sequence(Sequence(int)) ; edge := Sequence{} ;
        var i : int ; i := 0 ; while i < edges do ( (     edge := edge->including(Sequence{sc.getCurrent()->toInteger(),sc.getCurrent()->toInteger()}) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < edges do ( (     var e : Sequence(int) ; e := edge->at(i+1) ;
     execute connected(mapGen(edge), edge->at(0+1)->at(0+1)) ; 
    if (cnt->size() /= vertices) then     ans := ans + 1 ; else skip ; 
    cnt := cnt->intersection(Set{}) ; 
    edge := edge.insertAt(i+1,e) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation mapGen( edges : Sequence(Sequence(int))) : Map(int,Sequence(int))
  pre: true
  post: true
  activity: (     var g : Map(int,Sequence(int)) ; g := Map{} ;
         var i : int ; i := 0 ; while i < edges->size() do ( (     var v : int ; v := edges->at(i+1)->at(0+1) ;
     var w : int ; w := edges->at(i+1)->at(1+1) ;
    if (not(g->keys()->includes(v))) then     g := g->union(Map{v |-> Sequence{}}) ; else skip ; 
    if (not(g->keys()->includes(w))) then     g := g->union(Map{w |-> Sequence{}}) ; else skip ; 
    g->at(v)->excludes(w) ; 
    g->at(w)->excludes(v) ; 
 )  ;     i := i + 1 ) ; 
     return g );
  static   operation connected( g : Map(int,Sequence(int)), v : int) : void
  pre: true
  post: true
  activity: (     if (cnt->includes(v)) then     return else skip ; 
     cnt := cnt->including(v) ; 
     for (w : g->at(v)) do ( (     execute connected(g, w) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner scan ;
  int n ;
  int m ;
  int[] a ;
  int[] b ;
  boolean[] judge ;
  int count ;
  boolean[][] connect ;
  public static void main(String args[]){
    new Main().compute();
  }
  void compute(){
    scan=new Scanner(System.in);
    n=scan.nextInt();
    m=scan.nextInt();
    a=new int[m];
    b=new int[m];
    for(int i=0 ; i<m ; i++){
      a[i]=scan.nextInt();
      b[i]=scan.nextInt();
    }
    judge=new boolean[n];
    count=0 ;
    connect=new boolean[n][n];
    for(int i=0 ; i<m ; i++){
      connect[a[i]-1][b[i]-1]=true ;
      connect[b[i]-1][a[i]-1]=true ;
    }
    for(int i=0 ; i<m ; i++){
      for(int j=0 ; j<n ; j++){
        judge[j]=false ;
      }
      connect[a[i]-1][b[i]-1]=false ;
      connect[b[i]-1][a[i]-1]=false ;
      dfs(0);
      connect[a[i]-1][b[i]-1]=true ;
      connect[b[i]-1][a[i]-1]=true ;
      for(int j=0 ; j<n ; j++){
        if(! judge[j]){
          count++;
          break ;
        }
      }
    }
    System.out.println(count);
  }
  void dfs(int x){
    judge[x]=true ;
    for(int i=0 ; i<n ; i++){
      if((connect[x][i])&&(! judge[i])){
        dfs(i);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute scan : OclFile;
   attribute n : int;
   attribute m : int;
   attribute a : Sequence(int);
   attribute b : Sequence(int);
   attribute judge : Sequence(boolean);
   attribute count : int;
   attribute connect : Sequence(Sequence(boolean));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().compute() );
   operation compute() : void
  pre: true
  post: true
  activity: (     scan := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     n := scan.getCurrent()->toInteger() ; 
    m := scan.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,m)->collect(0) ; 
    b := Integer.subrange(1,m)->collect(0) ; 
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := scan.getCurrent()->toInteger() ; 
     b[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    judge := Integer.subrange(1,n)->collect(false) ; 
    count := 0 ; 
    connect := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ; 
        var i : int ; i := 0 ; while i < m do ( (     connect[a[i+1] - 1+1][b[i+1] - 1+1] := true ; 
     connect[b[i+1] - 1+1][a[i+1] - 1+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j < n do ( (     judge[j+1] := false )  ;     j := j + 1 ) ; 
     connect[a[i+1] - 1+1][b[i+1] - 1+1] := false ; 
    connect[b[i+1] - 1+1][a[i+1] - 1+1] := false ; 
    execute dfs(0) ; 
    connect[a[i+1] - 1+1][b[i+1] - 1+1] := true ; 
    connect[b[i+1] - 1+1][a[i+1] - 1+1] := true ; 
        var j : int ; j := 0 ; while j < n do ( (     if (not(judge[j+1])) then (     count := count + 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
   operation dfs( x : int) : void
  pre: true
  post: true
  activity: (     judge[x+1] := true ; 
         var i : int ; i := 0 ; while i < n do ( (     if ((connect[x+1][i+1]) & (not(judge[i+1]))) then (     execute dfs(i) ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
import java.util.function.Function ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] a=new int[m];
    int[] b=new int[m];
    for(int i=0 ; i<m ; i++){
      a[i]=sc.nextInt()-1 ;
      b[i]=sc.nextInt()-1 ;
    }
    int ret=m ;
    for(int i=0 ; i<m ; i++){
      int[][] d=new int[n][n];
      for(int j=0 ; j<m ; j++){
        d[a[j] ][b[j] ]=1 ;
        d[b[j] ][a[j] ]=1 ;
      }
      for(int j=0 ; j<n ; j++){
        d[j][j]=1 ;
      }
      d[a[i] ][b[i] ]=0 ;
      d[b[i] ][a[i] ]=0 ;
      for(int k=0 ; k<n ; k++){
        for(int x=0 ; x<n ; x++){
          for(int y=0 ; y<n ; y++){
            d[x][y] |=d[x][k] & d[k][y];
          }
        }
      }
      ret-=d[a[i] ][b[i] ];
    }
    System.out.println(ret);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := sc.getCurrent()->toInteger() - 1 ; 
     b[i+1] := sc.getCurrent()->toInteger() - 1 )  ;     i := i + 1 ) ; 
    var ret : int ; ret := m ;
        var i : int ; i := 0 ; while i < m do ( (     var d : Sequence(Sequence(int)) ; d := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
         var j : int ; j := 0 ; while j < m do ( (     d[a[j+1]+1][b[j+1]+1] := 1 ; 
     d[b[j+1]+1][a[j+1]+1] := 1 )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     d[j+1][j+1] := 1 )  ;     j := j + 1 ) ; 
    d[a[i+1]+1][b[i+1]+1] := 0 ; 
    d[b[i+1]+1][a[i+1]+1] := 0 ; 
        var k : int ; k := 0 ; while k < n do ( (         var x : int ; x := 0 ; while x < n do ( (         var y : int ; y := 0 ; while y < n do ( (     d[x+1][y+1] := MathLib.bitwiseOr(d[x+1][y+1], d[x+1][k+1] & d[k+1][y+1]) )  ;     y := y + 1 ) )  ;     x := x + 1 ) )  ;     k := k + 1 ) ; 
    ret := ret-(d[a[i+1]+1][b[i+1]+1]) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ret) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=10 ;
  static boolean isDigit(char ch){
    if(ch>='0' && ch<='9')return true ;
    return false ;
  }
  static boolean allDigits(String str,int len){
    boolean[] present=new boolean[MAX];
    for(int i=0 ; i<len ; i++){
      if(isDigit(str.charAt(i))){
        int digit=str.charAt(i)-'0' ;
        present[digit]=true ;
      }
    }
    for(int i=0 ; i<MAX ; i++){
      if(! present[i])return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    String str="Geeks12345for69708" ;
    int len=str.length();
    if(allDigits(str,len))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 10;
  static   operation isDigit( ch : String) : boolean
  pre: true
  post: true
  activity: (     if (ch >= '0' & ch <= '9') then     return true else skip ; 
     return false );
  static   operation allDigits( str : String, len : int) : boolean
  pre: true
  post: true
  activity: (     var present : Sequence(boolean) ; present := Integer.subrange(1,MAX)->collect(false) ;
         var i : int ; i := 0 ; while i < len do ( (     if (isDigit(str->at(i+1))) then (     var digit : int ; digit := str->at(i+1) - ('0')->char2byte() ;
     present[digit+1] := true ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < MAX do ( (     if (not(present[i+1])) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "Geeks12345for69708" ;
     var len : int ; len := str->size() ;
     if (allDigits(str, len)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Vector<Integer>makeSeq(String s,int a[]){
    Vector<Integer>seq=new Vector<Integer>();
    for(int i=0 ; i<s.length(); i++)if(s.charAt(i)=='A')seq.add(a[i]);
    for(int i=0 ; i<s.length(); i++)if(s.charAt(i)=='B')seq.add(a[i]);
    return seq ;
  }
  static boolean checkSeq(Vector<Integer>v){
    boolean check=true ;
    for(int i=1 ; i<v.size(); i++)if(v.get(i)<v.get(i-1))check=false ;
    return check ;
  }
  static String digitPartition(int X){
    String num=String.valueOf(X);
    int l=num.length();
    int[] a=new int[l];
    for(int i=0 ; i<l ; i++)a[i]=(num.charAt(i)-'0');
    for(int D=0 ; D<10 ; D++){
      String res="" ;
      for(int i=0 ; i<l ; i++){
        if(a[i]<D)res+='A' ;
        else if(a[i]>D)res+='B' ;
        else res+='C' ;
      }
      boolean flag=false ;
      for(int i=0 ; i<l ; i++){
        if(res.charAt(i)=='B')flag=true ;
        if(res.charAt(i)=='C')res=res.substring(0,i)+(flag ? 'A' : 'B')+res.substring(i+1);
      }
      Vector<Integer>seq=makeSeq(res,a);
      if(checkSeq(seq))return res ;
    }
    return "-1" ;
  }
  public static void main(String[] args){
    int X=777147777 ;
    System.out.print(digitPartition(X));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation makeSeq( s : String, a : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var seq : Sequence(int) ; seq := Sequence{} ;
         var i : int ; i := 0 ; while i < s->size() do (     if (s->at(i+1) = 'A') then     seq := seq->including(a[i+1]) ; else skip ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < s->size() do (     if (s->at(i+1) = 'B') then     seq := seq->including(a[i+1]) ; else skip ;  ;     i := i + 1 ) ; 
     return seq );
  static   operation checkSeq( v : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var check : boolean ; check := true ;
         var i : int ; i := 1 ; while i < v->size() do (     if (v->at(i+1) < v->at(i - 1+1)) then     check := false ; else skip ;  ;     i := i + 1 ) ; 
     return check );
  static   operation digitPartition( X : int) : String
  pre: true
  post: true
  activity: (     var num : String ; num := ((X) + "") ;
     var l : int ; l := num->size() ;
    var a : Sequence(int) ; a := Integer.subrange(1,l)->collect(0) ;
        var i : int ; i := 0 ; while i < l do (     a[i+1] := (num->at(i+1) - ('0')->char2byte()) ;  ;     i := i + 1 ) ; 
        var D : int ; D := 0 ; while D < 10 do ( (     var res : String ; res := "" ;
         var i : int ; i := 0 ; while i < l do ( (     if (a[i+1] < D) then     res := res+('A') ; else     if (a[i+1] > D) then     res := res+('B') else     res := res+('C') ; ;  )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < l do ( (     if (res->at(i+1) = 'B') then     flag := true ; else skip ; 
     if (res->at(i+1) = 'C') then     res := res.subrange(0+1,i) + (if flag then 'A' else 'B' endif) + res.subrange(i + 1+1,i + 1) ; else skip )  ;     i := i + 1 ) ; 
    var seq : Sequence(int) ; seq := makeSeq(res, a) ;
    if (checkSeq(seq)) then     return res else skip ; 
 )  ;     D := D + 1 ) ; 
    return "-1" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 777147777 ;
     OclFile["System.out"].print(digitPartition(X)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));
    int T=in.nextInt();
    while(T-->0){
      int n=in.nextInt();
      long k=in.nextLong();
      Long[] arr=new Long[n];
      Arrays.setAll(arr,i->in.nextLong());
      long max=Integer.MIN_VALUE ;
      for(long x : arr)max=Math.max(max,x);
      for(int i=0 ; i<n ; i++)arr[i]=max-arr[i];
      if((k & 1)==0){
        max=Integer.MIN_VALUE ;
        for(long x : arr)max=Math.max(max,x);
        for(int i=0 ; i<n ; i++)arr[i]=max-arr[i];
        for(long i : arr)pw.print(i+" ");
        pw.println();
      }
      else {
        for(long i : arr)pw.print(i+" ");
        pw.println();
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : long ; k := in.getCurrent()->toLong() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(null) ;
setAll(arr, lambda i : OclAny in in.getCurrent()->toLong()) ; 
    var max : long ; max := -2147483648 ;
    for (x : arr) do (     max := Set{max, x}->max() ;  ) ; 
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := max - arr[i+1] ;  ;     i := i + 1 ) ; 
    if ((MathLib.bitwiseAnd(k,1)) = 0) then (     max := -2147483648 ; 
     for (x : arr) do (     max := Set{max, x}->max() ;  ) ; 
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := max - arr[i+1] ;  ;     i := i + 1 ) ; 
    for (i : arr) do (     skip ;  ) ; 
    skip ; 
 ) else (     for (i : arr) do (     skip ;  ) ; 
     skip ) ;  
 ) ;  ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      Solve();
    }
  }
  private static void Solve(){
    int n=sc.nextInt();
    long k=sc.nextLong();
    long[] a=new long[n];
    long min=sc.nextInt();
    long max=min ;
    StringBuilder ans=new StringBuilder();
    a[0]=min ;
    for(int i=1 ; i<n ; i++){
      a[i]=sc.nextInt();
      min=Math.min(min,a[i]);
      max=Math.max(max,a[i]);
    }
    if(k % 2==1){
      for(int i=0 ; i<n ; i++){
        ans.append((max-a[i])+" ");
      }
    }
    else {
      for(int i=0 ; i<n ; i++){
        ans.append((a[i]-min)+" ");
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     execute Solve() )  ;     i := i + 1 ) );
  static   operation Solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : long ; k := sc.getCurrent()->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var min : long ; min := sc.getCurrent()->toInteger() ;
    var max : long ; max := min ;
    var ans : String ; ans := StringLib.newString() ;
    a[0+1] := min ; 
        var i : int ; i := 1 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     min := Set{min, a[i+1]}->min() ; 
     max := Set{max, a[i+1]}->max() )  ;     i := i + 1 ) ; 
    if (k mod 2 = 1) then (         var i : int ; i := 0 ; while i < n do ( (     ans := ans + StringLib.newString((max - a[i+1]) + " ") )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < n do ( (     ans := ans + StringLib.newString((a[i+1] - min) + " ") )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int toDigit(String str){
    int digit=0 ;
    int inc=0 ;
    for(int r=str.length()-1 ; r>=0 ; r--){
      digit+=(int)((str.charAt(r)-'0')*Math.pow(10,(inc++)));
    }
    return(digit);
  }
  int hit(String reply,String answer){
    int count=0 ;
    for(int r=0 ; r<reply.length(); r++){
      if(reply.charAt(r)==answer.charAt(r))count++;
    }
    return(count);
  }
  int blow(String reply,String answer){
    int count=0 ;
    for(int r=0 ; r<reply.length(); r++){
      for(int c=0 ; c<answer.length(); c++){
        if(r==c)continue ;
        else if(reply.charAt(r)==answer.charAt(c))count++;
      }
    }
    return(count);
  }
  void doIt(){
    Scanner stdIn=new Scanner(System.in);
    String reply,answer ;
    while(true){
      reply=stdIn.next();
      answer=stdIn.next();
      if(toDigit(reply)+toDigit(answer)==0)break ;
      System.out.println(hit(reply,answer)+" "+blow(reply,answer));
    }
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation toDigit( str : String) : int
  pre: true
  post: true
  activity: (     var digit : int ; digit := 0 ;
     var inc : int ; inc := 0 ;
         var r : int ; r := str->size() - 1 ; while r >= 0 do ( (     digit := digit+(((str->at(r+1) - ('0')->char2byte()) * 10->pow((inc)))->oclAsType(int)) )  ;     r := r - 1 ) ; 
     return (digit) );
   operation hit( reply : String, answer : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var r : int ; r := 0 ; while r < reply->size() do ( (     if (reply->at(r+1) = answer->at(r+1)) then     count := count + 1 ; else skip )  ;     r := r + 1 ) ; 
     return (count) );
   operation blow( reply : String, answer : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var r : int ; r := 0 ; while r < reply->size() do ( (         var c : int ; c := 0 ; while c < answer->size() do ( (     if (r = c) then     continue else     if (reply->at(r+1) = answer->at(c+1)) then     count := count + 1 ; else skip ; )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
     return (count) );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var reply : String ;
    var answer : String ;
     while (true) do (     reply := stdIn.getCurrent() ; 
     answer := stdIn.getCurrent() ; 
     if (toDigit(reply) + toDigit(answer) = 0) then     break else skip ; 
     OclFile["System.out"].println(hit(reply, answer) + " " + blow(reply, answer)) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maxDiff(int arr[],int n){
    int maxDiff=-1 ;
    int maxRight=arr[n-1];
    for(int i=n-2 ; i>=0 ; i--){
      if(arr[i]>maxRight)maxRight=arr[i];
      else {
        int diff=maxRight-arr[i];
        if(diff>maxDiff){
          maxDiff=diff ;
        }
      }
    }
    return maxDiff ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,90,10,110 };
      int n=arr.length ;
      System.out.println("Maximum difference is "+maxDiff(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxDiff( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var maxDiff : int ; maxDiff := -1 ;
     var maxRight : int ; maxRight := arr[n - 1+1] ;
         var i : int ; i := n - 2 ; while i >= 0 do ( (     if (arr[i+1] > maxRight) then     maxRight := arr[i+1] ; else (     var diff : int ; diff := maxRight - arr[i+1] ;
     if (diff > maxDiff) then (     maxDiff := diff ) else skip ) )  ;     i := i - 1 ) ; 
     return maxDiff );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,90,10,110} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Maximum difference is " + maxDiff(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class rectangles {
  public void run()throws Exception {
    Scanner file=new Scanner(System.in);
    int r=file.nextInt(),c=file.nextInt();
    int[][] mat=new int[r][c];
    for(int i=0 ; i<mat.length ; i++)for(int j=0 ; j<c ; j++)mat[i][j]=file.nextInt();
    long total=0 ;
    for(int i=0 ; i<mat.length ; i++){
      int whiteCount=0,blackCount=0 ;
      for(int j=0 ; j<mat[i] .length ; j++){
        if(mat[i][j]==1)blackCount++;
        else whiteCount++;
      }
      total+=(long)Math.pow(2,whiteCount)-1+(long)Math.pow(2,blackCount)-1 ;
    }
    for(int i=0 ; i<mat[0] .length ; i++){
      int whiteCount=0,blackCount=0 ;
      for(int j=0 ; j<mat.length ; j++){
        if(mat[j][i]==1)blackCount++;
        else whiteCount++;
      }
      total+=(long)Math.pow(2,whiteCount)-1+(long)Math.pow(2,blackCount)-1 ;
    }
    System.out.println(total-r*c);
  }
  public static void main(String[] args)throws Exception {
    new rectangles().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class rectangles {
   operation run() : void
  pre: true
  post: true
  activity: (     var file : OclFile ; file := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := file.getCurrent()->toInteger() ;
    var c : int ; c := file.getCurrent()->toInteger() ;
    var mat : Sequence(Sequence(int)) ; mat := Integer.subrange(1,r)->collect(Integer.subrange(1,c)->collect(0)) ;
        var i : int ; i := 0 ; while i < mat->size() do (         var j : int ; j := 0 ; while j < c do (     mat[i+1][j+1] := file.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var total : long ; total := 0 ;
        var i : int ; i := 0 ; while i < mat->size() do ( (     var whiteCount : int ; whiteCount := 0 ;
    var blackCount : int ; blackCount := 0 ;
         var j : int ; j := 0 ; while j < mat[i+1]->size() do ( (     if (mat[i+1][j+1] = 1) then     blackCount := blackCount + 1 ; else     whiteCount := whiteCount + 1 ; )  ;     j := j + 1 ) ; 
     total := total+(2->pow(whiteCount)->oclAsType(long) - 1 + 2->pow(blackCount)->oclAsType(long) - 1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < mat[0+1]->size() do ( (     var whiteCount : int ; whiteCount := 0 ;
    var blackCount : int ; blackCount := 0 ;
         var j : int ; j := 0 ; while j < mat->size() do ( (     if (mat[j+1][i+1] = 1) then     blackCount := blackCount + 1 ; else     whiteCount := whiteCount + 1 ; )  ;     j := j + 1 ) ; 
     total := total+(2->pow(whiteCount)->oclAsType(long) - 1 + 2->pow(blackCount)->oclAsType(long) - 1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total - r * c) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     rectangles.newrectangles().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countWays(int n,int l,int r){
    int tL=l,tR=r ;
    int[] L=new int[3];
    int[] R=new int[3];
    L[l % 2]=l ;
    R[r % 2]=r ;
    l++;
    r--;
    if(l<=tR && r>=tL){
      L[l % 2]=l ;
      R[r % 2]=r ;
    }
    int cnt0=0,cnt1=0 ;
    if(R[0]>0 && L[0]>0)cnt0=(R[0]-L[0])/2+1 ;
    if(R[1]>0 && L[1]>0)cnt1=(R[1]-L[1])/2+1 ;
    int[][] dp=new int[n+1][3];
    dp[1][0]=cnt0 ;
    dp[1][1]=cnt1 ;
    for(int i=2 ; i<=n ; i++){
      dp[i][0]=(cnt0*dp[i-1][0]+cnt1*dp[i-1][1]);
      dp[i][1]=(cnt0*dp[i-1][1]+cnt1*dp[i-1][0]);
    }
    return dp[n][0];
  }
  public static void main(String[] args){
    int n=2,l=1,r=3 ;
    System.out.println(countWays(n,l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countWays( n : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     var tL : int ; tL := l ;
    var tR : int ; tR := r ;
     var L : Sequence(int) ; L := Integer.subrange(1,3)->collect(0) ;
    var R : Sequence(int) ; R := Integer.subrange(1,3)->collect(0) ;
    L[l mod 2+1] := l ; 
    R[r mod 2+1] := r ; 
    l := l + 1 ; 
    r := r - 1 ; 
    if (l <= tR & r >= tL) then (     L[l mod 2+1] := l ; 
     R[r mod 2+1] := r ) else skip ; 
    var cnt0 : int ; cnt0 := 0 ;
    var cnt1 : int ; cnt1 := 0 ;
    if (R[0+1] > 0 & L[0+1] > 0) then     cnt0 := (R[0+1] - L[0+1]) / 2 + 1 ; else skip ; 
    if (R[1+1] > 0 & L[1+1] > 0) then     cnt1 := (R[1+1] - L[1+1]) / 2 + 1 ; else skip ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,3)->collect(0)) ;
    dp[1+1][0+1] := cnt0 ; 
    dp[1+1][1+1] := cnt1 ; 
        var i : int ; i := 2 ; while i <= n do ( (     dp[i+1][0+1] := (cnt0 * dp[i - 1+1][0+1] + cnt1 * dp[i - 1+1][1+1]) ; 
     dp[i+1][1+1] := (cnt0 * dp[i - 1+1][1+1] + cnt1 * dp[i - 1+1][0+1]) )  ;     i := i + 1 ) ; 
    return dp[n+1][0+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
    var l : int ; l := 1 ;
    var r : int ; r := 3 ;
     OclFile["System.out"].println(countWays(n, l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isBetween(int a,int b,int c){
    return(Math.min(a,b)<=c && c<=Math.max(a,b));
  }
  static boolean canJoin(int x[],int y[],int i,int j,int k){
    return(x[k]==x[i] || x[k]==x[j])&& isBetween(y[i],y[j],y[k])||(y[k]==y[i] || y[k]==y[j])&& isBetween(x[i],x[j],x[k]);
  }
  static int countLineSegments(int x[],int y[]){
    if((x[0]==x[1] && x[1]==x[2])||(y[0]==y[1] && y[1]==y[2]))return 1 ;
    else if(canJoin(x,y,0,1,2)|| canJoin(x,y,0,2,1)|| canJoin(x,y,1,2,0))return 2 ;
    else return 3 ;
  }
  public static void main(String[] args){
    int x[]=new int[3],y[]=new int[3];
    x[0]=-1 ;
    y[0]=-1 ;
    x[1]=-1 ;
    y[1]=3 ;
    x[2]=4 ;
    y[2]=3 ;
    System.out.println(countLineSegments(x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isBetween( a : int, b : int, c : int) : boolean
  pre: true
  post: true
  activity: (     return (Set{a, b}->min() <= c & c <= Set{a, b}->max()) );
  static   operation canJoin( x : Sequence(int), y : Sequence(int), i : int, j : int, k : int) : boolean
  pre: true
  post: true
  activity: (     return (x[k+1] = x[i+1] or x[k+1] = x[j+1]) & isBetween(y[i+1], y[j+1], y[k+1]) or (y[k+1] = y[i+1] or y[k+1] = y[j+1]) & isBetween(x[i+1], x[j+1], x[k+1]) );
  static   operation countLineSegments( x : Sequence(int), y : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if ((x[0+1] = x[1+1] & x[1+1] = x[2+1]) or (y[0+1] = y[1+1] & y[1+1] = y[2+1])) then     return 1 else     if (canJoin(x, y, 0, 1, 2) or canJoin(x, y, 0, 2, 1) or canJoin(x, y, 1, 2, 0)) then     return 2 else     return 3 ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : Sequence(int) ; x := Integer.subrange(1,3)->collect(0) ;
    var y : Sequence(void) ; y := Integer.subrange(1,3)->collect(0) ;
     x[0+1] := -1 ; 
    y[0+1] := -1 ; 
    x[1+1] := -1 ; 
    y[1+1] := 3 ; 
    x[2+1] := 4 ; 
    y[2+1] := 3 ; 
    OclFile["System.out"].println(countLineSegments(x, y)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void SieveOfSundaram(boolean marked[],int nNew){
    for(int i=1 ; i<=nNew ; i++)for(int j=i ; (i+j+2*i*j)<=nNew ; j++)marked[i+j+2*i*j]=true ;
  }
  static int countPrimePairs(int n){
    int nNew=(n-2)/2 ;
    boolean marked[]=new boolean[nNew+1];
    SieveOfSundaram(marked,nNew);
    int count=0,prime_num ;
    for(int i=1 ; i<=nNew ; i++){
      if(marked[i]==false){
        prime_num=2*i+1 ;
        count=count+(prime_num/2);
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int n=12 ;
    System.out.println("Number of prime pairs: "+countPrimePairs(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation SieveOfSundaram( marked : Sequence(boolean), nNew : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= nNew do (         var j : int ; j := i ; while (i + j + 2 * i * j) <= nNew do (     marked[i + j + 2 * i * j+1] := true ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) );
  static   operation countPrimePairs( n : int) : int
  pre: true
  post: true
  activity: (     var nNew : int ; nNew := (n - 2) / 2 ;
     var marked : Sequence(boolean) ; marked := Integer.subrange(1,nNew + 1)->collect(false) ;
    execute SieveOfSundaram(marked, nNew) ; 
    var count : int ; count := 0 ;
    var prime_num : int ;
        var i : int ; i := 1 ; while i <= nNew do ( (     if (marked[i+1] = false) then (     prime_num := 2 * i + 1 ; 
     count := count + (prime_num / 2) ) else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     OclFile["System.out"].println("Number of prime pairs: " + countPrimePairs(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class gfg {
  static int getMinCost(int n,int m){
    int cost=(n-1)*m+(m-1)*n ;
    return cost ;
  }
  public static void main(String[] args){
    int n=4,m=5 ;
    System.out.println(getMinCost(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class gfg {
  static   operation getMinCost( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var cost : int ; cost := (n - 1) * m + (m - 1) * n ;
     return cost );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
    var m : int ; m := 5 ;
     OclFile["System.out"].println(getMinCost(n, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Task1 {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] ns=br.readLine().split(" ");
    int n=Integer.parseInt(ns[0]);
    int a=Integer.parseInt(ns[1]);
    int t ;
    if(a % 2==1){
      t=(a+1)/2 ;
    }
    else {
      t=(n-a)/2+1 ;
    }
    System.out.println(t);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Task1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var ns : Sequence(String) ; ns := br.readLine()->split(" ") ;
    var n : int ; n := (ns[0+1])->toInteger() ;
    var a : int ; a := (ns[1+1])->toInteger() ;
    var t : int ;
    if (a mod 2 = 1) then (     t := (a + 1) / 2 ) else (     t := (n - a) / 2 + 1 ) ;  
    OclFile["System.out"].println(t) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class VK_A1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    if(a % 2==0){
      System.out.println(n/2-a/2+1);
    }
    else {
      System.out.println(a/2+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class VK_A1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (a mod 2 = 0) then (     OclFile["System.out"].println(n / 2 - a / 2 + 1) ) else (     OclFile["System.out"].println(a / 2 + 1) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int a=scanner.nextInt();
    if(a % 2==1){
      System.out.print(a/2+1);
    }
    else {
      System.out.print(n/2-a/2+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : int ; a := scanner.getCurrent()->toInteger() ;
     if (a mod 2 = 1) then (     OclFile["System.out"].print(a / 2 + 1) ) else (     OclFile["System.out"].print(n / 2 - a / 2 + 1) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class vkcup {
  public static void main(String[] args)throws IOException {
    new vkcup().run();
  }
  StreamTokenizer in ;
  PrintWriter out ;
  int nextInt()throws IOException {
    in.nextToken();
    return(int)in.nval ;
  }
  String nextString()throws IOException {
    in.nextToken();
    return in.sval ;
  }
  void run()throws IOException {
    in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    out=new PrintWriter(new OutputStreamWriter(System.out));
    solve();
    out.flush();
  }
  void solve()throws IOException {
    int n=nextInt();
    int a=nextInt();
    int answer ;
    if(a % 2==0)answer=(n-a)/2+1 ;
    else answer=a/2+1 ;
    out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class vkcup {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     vkcup.newvkcup().run() );
   attribute in : StreamTokenizer;
   attribute out : OclFile;
   operation nextInt() : int
  pre: true
  post: true
  activity: (     in.next() ; 
     return in.nval->oclAsType(int) );
   operation nextString() : String
  pre: true
  post: true
  activity: (     in.next() ; 
     return in.sval );
   operation run() : void
  pre: true
  post: true
  activity: (     in := StreamTokenizer.newStreamTokenizer(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
     execute solve() ; 
     skip );
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var a : int ; a := nextInt() ;
    var answer : int ;
    if (a mod 2 = 0) then     answer := (n - a) / 2 + 1 else     answer := a / 2 + 1 ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      char[] a=sc.next().toCharArray();
      char[] b=sc.next().toCharArray();
      if(a.length!=4)break ;
      int hit=0 ;
      int blow=0 ;
      int[] aa=new int[10];
      int[] bb=new int[10];
      for(int i=0 ; i<4 ; i++){
        if(a[i]==b[i]){
          hit++;
        }
        else {
          aa[a[i]-'0']++;
          bb[b[i]-'0']++;
        }
      }
      for(int i=0 ; i<10 ; i++)blow+=Math.min(aa[i],bb[i]);
      System.out.println(hit+" "+blow);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var a : Sequence(String) ; a := sc.getCurrent()->characters() ;
     var b : Sequence(String) ; b := sc.getCurrent()->characters() ;
    if (a->size() /= 4) then     break else skip ; 
    var hit : int ; hit := 0 ;
    var blow : int ; blow := 0 ;
    var aa : Sequence(int) ; aa := Integer.subrange(1,10)->collect(0) ;
    var bb : Sequence(int) ; bb := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     if (a[i+1] = b[i+1]) then (     hit := hit + 1 ) else (     aa[a[i+1] - ('0')->char2byte()+1] := aa[a[i+1] - ('0')->char2byte()+1] + 1 ; 
     bb[b[i+1] - ('0')->char2byte()+1] := bb[b[i+1] - ('0')->char2byte()+1] + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 10 do (     blow := blow+(Set{aa[i+1], bb[i+1]}->min()) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(hit + " " + blow) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class VKCupQualA {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    PrintWriter cout=new PrintWriter(System.out);
    int N=cin.nextInt(),a=cin.nextInt();
    if(a % 2==1)cout.println((a+1)/2);
    else cout.println((N-a+2)/2);
    cout.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class VKCupQualA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cout : OclFile ; cout := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := cin.getCurrent()->toInteger() ;
    var a : int ; a := cin.getCurrent()->toInteger() ;
    if (a mod 2 = 1) then     skip else     skip ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void convert_str(String str,int k){
    char[] s=str.toCharArray();
    int l=s.length ;
    for(int i=0 ; i<l ; i++){
      int ascii=(int)s[i];
      if(ascii>='a' && ascii<='z' && __gcd(ascii,k)==1){
        char c=(char)(s[i]-32);
        s[i]=c ;
      }
    }
    System.out.println(String.valueOf(s));
  }
  static int __gcd(int a,int b){
    if(a==0){
      return b ;
    }
    if(b==0){
      return a ;
    }
    if(a==b){
      return a ;
    }
    if(a>b){
      return __gcd(a-b,b);
    }
    return __gcd(a,b-a);
  }
  public static void main(String[] args){
    String s="geeksforgeeks" ;
    int k=4 ;
    convert_str(s,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation convert_str( str : String, k : int) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := str->characters() ;
     var l : int ; l := s->size() ;
         var i : int ; i := 0 ; while i < l do ( (     var ascii : int ; ascii := s[i+1]->oclAsType(int) ;
     if (ascii >= 'a' & ascii <= 'z' & __gcd(ascii, k) = 1) then (     var c : String ; c := (s[i+1] - 32)->oclAsType(String) ;
     s[i+1] := c ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println((s)->sum() ) );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then (     return b ) else skip ; 
     if (b = 0) then (     return a ) else skip ; 
    if (a = b) then (     return a ) else skip ; 
    if (a > b) then (     return __gcd(a - b, b) ) else skip ; 
    return __gcd(a, b - a) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     var k : int ; k := 4 ;
     execute convert_str(s, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPrime(int n){
    int i ;
    if(n==1)return false ;
    for(i=2 ; i<=Math.sqrt(n); i++){
      if(n % i==0)return false ;
    }
    return true ;
  }
  static int countDistinct(String s){
    Set<Character>m=new HashSet<Character>();
    for(int i=0 ; i<s.length(); i++){
      m.add(s.charAt(i));
    }
    return m.size();
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    if(isPrime(countDistinct(str)))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ;
     if (n = 1) then     return false else skip ; 
         i := 2 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation countDistinct( s : String) : int
  pre: true
  post: true
  activity: (     var m : Set(String) ; m := Set{} ;
         var i : int ; i := 0 ; while i < s->size() do ( (     m := m->including(s->at(i+1)) )  ;     i := i + 1 ) ; 
     return m->size() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     if (isPrime(countDistinct(str))) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int arr[]=new int[] {
    1,2,2,4 };
    static int countIncreasing(int n){
      int cnt=0 ;
      int len=1 ;
      for(int i=0 ; i<n-1 ; ++i){
        if(arr[i+1]>arr[i])len++;
        else {
          cnt+=(((len-1)*len)/2);
          len=1 ;
        }
      }
      if(len>1)cnt+=(((len-1)*len)/2);
      return cnt ;
    }
    public static void main(String[] args){
      System.out.println("Count of strictly increasing subarrays is "+countIncreasing(arr.length));
    }
  }

------------------------------------------------------------
OCL File:
---------
class Test {
  static   attribute arr : int := Sequence{1,2,2,4};
  static   operation countIncreasing( n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var len : int ; len := 1 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i + 1+1] > arr[i+1]) then     len := len + 1 ; else (     cnt := cnt+((((len - 1) * len) / 2)) ; 
     len := 1 ) )  ;     i := i + 1 ) ; 
    if (len > 1) then     cnt := cnt+((((len - 1) * len) / 2)) ; else skip ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Count of strictly increasing subarrays is " + countIncreasing(arr->size())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int BITS=32 ;
  static int andSum(int arr[],int n){
    int ans=0 ;
    for(int i=0 ; i<BITS ; i++){
      int countSetBits=0 ;
      for(int j=0 ; j<n ; j++){
        if((arr[j] &(1<<i))!=0)countSetBits++;
      }
      int subset=(1<<countSetBits)-1 ;
      subset=(subset*(1<<i));
      ans+=subset ;
    }
    return ans ;
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3 };
      int size=3 ;
      System.out.println(andSum(arr,size));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute BITS : int := 32;
  static   operation andSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < BITS do ( (     var countSetBits : int ; countSetBits := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if ((arr[j+1] & ((1*(2->pow(i)))->oclAsType(long))) /= 0) then     countSetBits := countSetBits + 1 ; else skip )  ;     j := j + 1 ) ; 
    var subset : int ; subset := ((1*(2->pow(countSetBits)))->oclAsType(long)) - 1 ;
    subset := (subset * ((1*(2->pow(i)))->oclAsType(long))) ; 
    ans := ans+(subset) ; 
 )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3} ;
     var size : int ; size := 3 ;
     OclFile["System.out"].println(andSum(arr, size)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countWays(int A,int B,int C){
    int minAddA=Math.max(0,(C+B-A+2)/2);
    int count_ways=Math.max(C-minAddA+1,0);
    return count_ways ;
  }
  public static void main(String args[]){
    int A=3,B=5,C=5 ;
    System.out.println(countWays(A,B,C));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countWays( A : int, B : int, C : int) : int
  pre: true
  post: true
  activity: (     var minAddA : int ; minAddA := Set{0, (C + B - A + 2) / 2}->max() ;
     var count_ways : int ; count_ways := Set{C - minAddA + 1, 0}->max() ;
     return count_ways );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 3 ;
    var B : int ; B := 5 ;
    var C : int ; C := 5 ;
     OclFile["System.out"].println(countWays(A, B, C)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int N=5 ;
  static final int M=5 ;
  static int minOperation(boolean arr[][]){
    int ans=0 ;
    for(int i=N-1 ; i>=0 ; i--){
      for(int j=M-1 ; j>=0 ; j--){
        if(arr[i][j]==false){
          ans++;
          for(int k=0 ; k<=i ; k++){
            for(int h=0 ; h<=j ; h++){
              if(arr[k][h]==true){
                arr[k][h]=false ;
              }
              else {
                arr[k][h]=true ;
              }
            }
          }
        }
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    boolean mat[][]={
      {
        false,false,true,true,true },{
          false,false,false,true,true },{
            false,false,false,true,true },{
              true,true,true,true,true },{
                true,true,true,true,true }
              };
              System.out.println(minOperation(mat));
            }
          }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute N : int := 5;
  static    attribute M : int := 5;
  static   operation minOperation( arr : Sequence(Sequence(boolean))) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := N - 1 ; while i >= 0 do ( (         var j : int ; j := M - 1 ; while j >= 0 do ( (     if (arr[i+1][j+1] = false) then (     ans := ans + 1 ; 
         var k : int ; k := 0 ; while k <= i do ( (         var h : int ; h := 0 ; while h <= j do ( (     if (arr[k+1][h+1] = true) then (     arr[k+1][h+1] := false ) else (     arr[k+1][h+1] := true ) )  ;     h := h + 1 ) )  ;     k := k + 1 ) ) else skip )  ;     j := j - 1 ) )  ;     i := i - 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(boolean)) ; mat := Sequence{Sequence{false,false,true,true,true},Sequence{false,false,false,true,true},Sequence{false,false,false,true,true},Sequence{true,true,true,true,true},Sequence{true,true,true,true,true}} ;
     OclFile["System.out"].println(minOperation(mat)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B748 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char[] A=in.next().toCharArray();
    char[] B=in.next().toCharArray();
    char[] map=new char[26];
    for(int i=0 ; i<26 ; i++){
      map[i]=' ' ;
    }
    boolean possible=true ;
    for(int i=0 ; i<A.length ; i++){
      char a=A[i];
      char b=B[i];
      if(map[a-'a']==' ' || map[a-'a']==b){
        map[a-'a']=b ;
      }
      else {
        possible=false ;
      }
      if(map[b-'a']==' ' || map[b-'a']==a){
        map[b-'a']=a ;
      }
      else {
        possible=false ;
      }
    }
    if(possible){
      int count=0 ;
      StringBuilder out=new StringBuilder();
      for(int i=0 ; i<26 ; i++){
        if(map[i]!=' ' && map[i]<(char)('a'+i)){
          count++;
          out.append(map[i]).append(' ').append((char)('a'+i)).append('\n');
        }
      }
      System.out.println(count);
      System.out.print(out);
    }
    else {
      System.out.println("-1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B748 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : Sequence(String) ; A := in.getCurrent()->characters() ;
    var B : Sequence(String) ; B := in.getCurrent()->characters() ;
    var map : Sequence(String) ; map := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < 26 do ( (     map[i+1] := ' ' )  ;     i := i + 1 ) ; 
    var possible : boolean ; possible := true ;
        var i : int ; i := 0 ; while i < A->size() do ( (     var a : String ; a := A[i+1] ;
     var b : String ; b := B[i+1] ;
     if (map[(a)->char2byte() - ('a')->char2byte()+1] = ' ' or map[(a)->char2byte() - ('a')->char2byte()+1] = b) then (     map[(a)->char2byte() - ('a')->char2byte()+1] := b ) else (     possible := false ) ;  
     if (map[(b)->char2byte() - ('a')->char2byte()+1] = ' ' or map[(b)->char2byte() - ('a')->char2byte()+1] = a) then (     map[(b)->char2byte() - ('a')->char2byte()+1] := a ) else (     possible := false ) )  ;     i := i + 1 ) ; 
    if (possible) then (     var count : int ; count := 0 ;
     var out : String ; out := StringLib.newString() ;
        var i : int ; i := 0 ; while i < 26 do ( (     if (map[i+1] /= ' ' & map[i+1] < ('a' + i)->oclAsType(String)) then (     count := count + 1 ; 
     out := out + StringLib.newString(map[i+1]) + StringLib.newString(' ') + StringLib.newString(('a' + i)->oclAsType(String)) + StringLib.newString('
') ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    OclFile["System.out"].print(out) ; 
 ) else (     OclFile["System.out"].println("-1") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class a_Quasi_palindrome {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String x=sc.next();
    int j=0 ;
    boolean ispal=true ;
    boolean isok=false ;
    for(int i=x.length()-1 ; i>=0 ; i--){
      if(! isok && x.charAt(i)=='0')i--;
      if(x.charAt(i)!='0')isok=true ;
      if(isok){
        if(x.charAt(i)!=x.charAt(j)){
          ispal=false ;
          break ;
        }
        j++;
      }
    }
    System.out.println(ispal ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class a_Quasi_palindrome {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : String ; x := sc.getCurrent() ;
    var j : int ; j := 0 ;
    var ispal : boolean ; ispal := true ;
    var isok : boolean ; isok := false ;
        var i : int ; i := x->size() - 1 ; while i >= 0 do ( (     if (not(isok) & x->at(i+1) = '0') then     i := i - 1 ; else skip ; 
     if (x->at(i+1) /= '0') then     isok := true ; else skip ; 
     if (isok) then (     if (x->at(i+1) /= x->at(j+1)) then (     ispal := false ; 
     break ) else skip ; 
     j := j + 1 ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(if ispal then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class a_Quasi_palindrome {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    while(x % 10==0)x/=10 ;
    String y=""+x ;
    boolean isok=true ;
    for(int i=0 ; i<y.length()/2 ; i++){
      if(y.charAt(i)!=y.charAt(y.length()-i-1))isok=false ;
    }
    System.out.println(isok ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class a_Quasi_palindrome {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    while (x mod 10 = 0) do     x := x/(10) ; ; 
    var y : String ; y := "" + x ;
    var isok : boolean ; isok := true ;
        var i : int ; i := 0 ; while i < y->size() / 2 do ( (     if (y->at(i+1) /= y->at(y->size() - i - 1+1)) then     isok := false ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if isok then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public String HitBlow(int ans,int in){
    int hit=0,blow=0 ;
    int[] a=new int[4],b=new int[4];
    for(int i=0 ; i<4 ; i++){
      a[i]=ans % 10 ;
      ans/=10 ;
      b[i]=in % 10 ;
      in/=10 ;
    }
    for(int i=0 ; i<4 ; i++){
      if(a[i]==b[i])hit++;
      else {
        for(int j=0 ; j<4 ; j++)if(b[i]==a[j])blow++;
      }
    }
    return hit+" "+blow ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Main m=new Main();
    while(true){
      int ans=sc.nextInt();
      int in=sc.nextInt();
      if(ans==0 && in==0)break ;
      System.out.println(m.HitBlow(ans,in));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation HitBlow( ans : int, in : int) : String
  pre: true
  post: true
  activity: (     var hit : int ; hit := 0 ;
    var blow : int ; blow := 0 ;
     var a : Sequence(int) ; a := Integer.subrange(1,4)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     a[i+1] := ans mod 10 ; 
     ans := ans/(10) ; 
     b[i+1] := in mod 10 ; 
     in := in/(10) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 4 do ( (     if (a[i+1] = b[i+1]) then     hit := hit + 1 ; else (         var j : int ; j := 0 ; while j < 4 do (     if (b[i+1] = a[j+1]) then     blow := blow + 1 ; else skip ;  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
    return hit + " " + blow 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : Main ; m := Main.newMain() ;
     while (true) do (     var ans : int ; ans := sc.getCurrent()->toInteger() ;
     var in : int ; in := sc.getCurrent()->toInteger() ;
     if (ans = 0 & in = 0) then     break else skip ; 
     OclFile["System.out"].println(m.HitBlow(ans, in)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Sheet5ProblemF {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String num=input.nextLine();
    String rev="" ;
    boolean good=true ;
    for(int i=num.length()-1 ; i>=0 ; i--)rev+=num.charAt(i);
    if(rev.equals(num))System.out.println("YES");
    else {
      String zeros="" ;
      for(int i=num.length()-1 ; i>=0 ; i--){
        if(num.charAt(i)=='0'){
          zeros+='0' ;
          continue ;
        }
        else break ;
      }
      rev+=zeros ;
      int i=0 ;
      int j=rev.length()-1 ;
      while(i<j){
        if(rev.charAt(i)!=rev.charAt(j)){
          good=false ;
          break ;
        }
        i++;
        j--;
      }
      if(good)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sheet5ProblemF {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : String ; num := input.nextLine() ;
    var rev : String ; rev := "" ;
    var good : boolean ; good := true ;
        var i : int ; i := num->size() - 1 ; while i >= 0 do (     rev := rev+(num->at(i+1)) ;  ;     i := i - 1 ) ; 
    if (rev = num) then     OclFile["System.out"].println("YES") else (     var zeros : String ; zeros := "" ;
         var i : int ; i := num->size() - 1 ; while i >= 0 do ( (     if (num->at(i+1) = '0') then (     zeros := zeros+('0') ; 
     continue ) else     break )  ;     i := i - 1 ) ; 
    rev := rev+(zeros) ; 
    var i : int ; i := 0 ;
    var j : int ; j := rev->size() - 1 ;
    while (i < j) do (     if (rev->at(i+1) /= rev->at(j+1)) then (     good := false ; 
     break ) else skip ; 
     i := i + 1 ; 
     j := j - 1 ) ; 
    if (good) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Node {
    int data ;
    Node next ;
  };
  static Node push(Node head_ref,int data){
    Node ptr1=new Node();
    Node temp=head_ref ;
    ptr1.data=data ;
    ptr1.next=head_ref ;
    if(head_ref!=null){
      while(temp.next!=head_ref)temp=temp.next ;
      temp.next=ptr1 ;
    }
    else ptr1.next=ptr1 ;
    head_ref=ptr1 ;
    return head_ref ;
  }
  static int countNodes(Node head){
    Node temp=head ;
    int result=0 ;
    if(head!=null){
      do {
        temp=temp.next ;
        result++;
      }
      while(temp!=head);
    }
    return result ;
  }
  public static void main(String args[]){
    Node head=null ;
    head=push(head,12);
    head=push(head,56);
    head=push(head,2);
    head=push(head,11);
    System.out.printf("%d",countNodes(head));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   operation push( head_ref : Node, data : int) : Node
  pre: true
  post: true
  activity: (     var ptr1 : Node ; ptr1 := Node.newNode() ;
     var temp : Node ; temp := head_ref ;
    ptr1.data := data ; 
    ptr1.next := head_ref ; 
    if (head_ref /= null) then (     while (temp.next /= head_ref) do     temp := temp.next ; ; 
     temp.next := ptr1 ) else     ptr1.next := ptr1 ; ;  
    head_ref := ptr1 ; 
    return head_ref 
 );
  static   operation countNodes( head : Node) : int
  pre: true
  post: true
  activity: (     var temp : Node ; temp := head ;
     var result : int ; result := 0 ;
     if (head /= null) then (   while true do ((     temp := temp.next ; 
     result := result + 1 ) ;
    if (temp /= head) then skip else break) ) else skip ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := null ;
     head := push(head, 12) ; 
    head := push(head, 56) ; 
    head := push(head, 2) ; 
    head := push(head, 11) ; 
    OclFile["System.out"].printf("%d", countNodes(head)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Arrays ;
class Main {
  static final PrintWriter out=new PrintWriter(System.out);
  static final int MOD=10007 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=Integer.parseInt(line);
      int[] pic=new int[n];
      line=br.readLine();
      for(int i=0 ; i<n ; i++)pic[i]=bit(line.charAt(i));
      int[][] dp=new int[n][1<<3];
      for(int i=0 ; i<1<<3 ; i++){
        if((i &(1<<0))!=0 &&(i & pic[0])!=0)dp[0][i]=1 ;
      }
      for(int i=1 ; i<n ; i++){
        for(int j=1 ; j<(1<<3); j++){
          for(int k=1 ; k<(1<<3); k++){
            if((k & pic[i])!=0){
              if((j & pic[i])!=0)dp[i][k]+=dp[i-1][j];
              else if((j & pic[i])==0 &&(j & k)!=0)dp[i][k]+=dp[i-1][j];
              dp[i][k] %=MOD ;
            }
          }
        }
      }
      int ans=0 ;
      for(int i=1 ; i<1<<3 ; i++)ans+=dp[n-1][i];
      out.println(ans % MOD);
      out.flush();
    }
  }
  public static int bit(char c){
    if(c=='J')return 1<<0 ;
    else if(c=='O')return 1<<1 ;
    else return 1<<2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static    attribute MOD : int := 10007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := (line)->toInteger() ;
     var pic : Sequence(int) ; pic := Integer.subrange(1,n)->collect(0) ;
    line := br.readLine() ; 
        var i : int ; i := 0 ; while i < n do (     pic[i+1] := bit(line->at(i+1)) ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,(1*(2->pow(3)))->oclAsType(long))->collect(0)) ;
        var i : int ; i := 0 ; while i < (1*(2->pow(3)))->oclAsType(long) do ( (     if ((MathLib.bitwiseAnd(i,((1*(2->pow(0)))->oclAsType(long)))) /= 0 & (MathLib.bitwiseAnd(i,pic[0+1])) /= 0) then     dp[0+1][i+1] := 1 ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 1 ; while j < ((1*(2->pow(3)))->oclAsType(long)) do ( (         var k : int ; k := 1 ; while k < ((1*(2->pow(3)))->oclAsType(long)) do ( (     if ((MathLib.bitwiseAnd(k,pic[i+1])) /= 0) then (     if ((MathLib.bitwiseAnd(j,pic[i+1])) /= 0) then     dp[i+1][k+1] := dp[i+1][k+1]+(dp[i - 1+1][j+1]) else     if ((MathLib.bitwiseAnd(j,pic[i+1])) = 0 & (MathLib.bitwiseAnd(j,k)) /= 0) then     dp[i+1][k+1] := dp[i+1][k+1]+(dp[i - 1+1][j+1]) ; else skip ; ;  
     dp[i+1][k+1] := dp[i+1][k+1] mod MOD ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < (1*(2->pow(3)))->oclAsType(long) do (     ans := ans+(dp[(n)->char2byte() - 1+1][i+1]) ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 ) ;     line := br.readLine() ;
 ) );
  static   operation bit( c : String) : int
  pre: true
  post: true
  activity: (     if (c = 'J') then     return (1*(2->pow(0)))->oclAsType(long) else     if (c = 'O') then     return (1*(2->pow(1)))->oclAsType(long) else     return (1*(2->pow(2)))->oclAsType(long) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static int[] countSum(int arr[],int n){
    int result=0 ;
    int[] countODD=new int[n+1];
    int[] countEVEN=new int[n+1];
    countODD[0]=0 ;
    countEVEN[0]=0 ;
    for(int i=1 ; i<=n ; i++){
      if(arr[i-1] % 2==0){
        countEVEN[i]=countEVEN[i-1]+countEVEN[i-1]+1 ;
        countODD[i]=countODD[i-1]+countODD[i-1];
      }
      else {
        countEVEN[i]=countEVEN[i-1]+countODD[i-1];
        countODD[i]=countODD[i-1]+countEVEN[i-1]+1 ;
      }
    }
    int[] ans=new int[2];
    ans[0]=countEVEN[n];
    ans[1]=countODD[n];
    return ans ;
  }
  public static void main(String[] args){
    int[] arr=new int[] {
      1,2,2,3 };
      int n=4 ;
      int[] ans=countSum(arr,n);
      System.out.println("EvenSum="+ans[0]);
      System.out.println("OddSum="+ans[1]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSum( arr : Sequence(int), n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var countODD : Sequence(int) ; countODD := Integer.subrange(1,n + 1)->collect(0) ;
    var countEVEN : Sequence(int) ; countEVEN := Integer.subrange(1,n + 1)->collect(0) ;
    countODD[0+1] := 0 ; 
    countEVEN[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (arr[i - 1+1] mod 2 = 0) then (     countEVEN[i+1] := countEVEN[i - 1+1] + countEVEN[i - 1+1] + 1 ; 
     countODD[i+1] := countODD[i - 1+1] + countODD[i - 1+1] ) else (     countEVEN[i+1] := countEVEN[i - 1+1] + countODD[i - 1+1] ; 
     countODD[i+1] := countODD[i - 1+1] + countEVEN[i - 1+1] + 1 ) )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,2)->collect(0) ;
    ans[0+1] := countEVEN[n+1] ; 
    ans[1+1] := countODD[n+1] ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,2,3} ;
     var n : int ; n := 4 ;
    var ans : Sequence(int) ; ans := countSum(arr, n) ;
    OclFile["System.out"].println("EvenSum=" + ans[0+1]) ; 
    OclFile["System.out"].println("OddSum=" + ans[1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    n=scanner.nextInt();
    char[] c=scanner.next().toCharArray();
    num=new int[n];
    for(int i=0 ; i<n ; i++)num[i]=1<<"JOI".indexOf(c[i]);
    dp=new int[8][n];
    System.out.println(slove(1,0));
  }
  private int slove(int x,int day){
    if(day==n)return 1 ;
    if(dp[x][day]!=0)return dp[x][day];
    int ans=0 ;
    for(int i=1 ; i<8 ; i++){
      if(((x & i)==0)||(i & num[day])==0)continue ;
      ans+=slove(i,day+1);
      ans %=mod ;
    }
    return dp[x][day]=ans % mod ;
  }
  int n ;
  int[] num ;
  int[][] dp ;
  int mod=10007 ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := scanner.getCurrent()->toInteger() ; 
    var c : Sequence(String) ; c := scanner.getCurrent()->characters() ;
    num := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     num[i+1] := (1*(2->pow("JOI"->indexOf(c[i+1])-1)))->oclAsType(long) ;  ;     i := i + 1 ) ; 
    dp := Integer.subrange(1,8)->collect(Integer.subrange(1,n)->collect(0)) ; 
    OclFile["System.out"].println(slove(1, 0)) ; 
 );
   operation slove( x : int, day : int) : int
  pre: true
  post: true
  activity: (     if (day = n) then     return 1 else skip ; 
     if (dp[x+1][day+1] /= 0) then     return dp[x+1][day+1] else skip ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < 8 do ( (     if (((x & i) = 0) or (MathLib.bitwiseAnd(i,num[day+1])) = 0) then     continue else skip ; 
     ans := ans+(slove(i, day + 1)) ; 
     ans := ans mod mod )  ;     i := i + 1 ) ; 
    return dp[x+1][day+1] 
 );
   attribute n : int;
   attribute num : Sequence(int);
   attribute dp : Sequence(Sequence(int));
   attribute mod : int := 10007;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int mod=10007 ;
    int n=sc.nextInt();
    int[] tanto=new int[n];
    char[] line=sc.next().toCharArray();
    for(int i=0 ; i<n ; i++){
      if(line[i]=='J')tanto[i]=0 ;
      if(line[i]=='O')tanto[i]=1 ;
      if(line[i]=='I')tanto[i]=2 ;
    }
    int[][] dp=new int[2][1<<3];
    dp[0][0]=1 ;
    int idx=1 ;
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      for(int bit=0 ; bit<(1<<3); bit++){
        if((bit &(1<<tanto[i]))==0)continue ;
        if(i==0){
          if((bit & 1)>0)dp[idx][bit]=1 ;
          continue ;
        }
        for(int bit2=0 ; bit2<(1<<3); bit2++){
          if((bit & bit2)>0){
            dp[idx][bit]+=dp[1-idx][bit2];
            dp[idx][bit] %=mod ;
          }
        }
        if(i==n-1){
          cnt+=dp[idx][bit];
          cnt %=mod ;
        }
      }
      idx=1-idx ;
      dp[idx]=new int[1<<3];
    }
    System.out.println(cnt);
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var mod : int ; mod := 10007 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var tanto : Sequence(int) ; tanto := Integer.subrange(1,n)->collect(0) ;
    var line : Sequence(String) ; line := sc.getCurrent()->characters() ;
        var i : int ; i := 0 ; while i < n do ( (     if (line[i+1] = 'J') then     tanto[i+1] := 0 ; else skip ; 
     if (line[i+1] = 'O') then     tanto[i+1] := 1 ; else skip ; 
     if (line[i+1] = 'I') then     tanto[i+1] := 2 ; else skip )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,(1*(2->pow(3)))->oclAsType(long))->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
    var idx : int ; idx := 1 ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var bit : int ; bit := 0 ; while bit < ((1*(2->pow(3)))->oclAsType(long)) do ( (     if ((MathLib.bitwiseAnd(bit,((1*(2->pow(tanto[i+1])))->oclAsType(long)))) = 0) then     continue else skip ; 
     if (i = 0) then (     if ((MathLib.bitwiseAnd(bit,1)) > 0) then     dp[idx+1][bit+1] := 1 ; else skip ; 
     continue ) else skip ; 
         var bit2 : int ; bit2 := 0 ; while bit2 < ((1*(2->pow(3)))->oclAsType(long)) do ( (     if ((MathLib.bitwiseAnd(bit,bit2)) > 0) then (     dp[idx+1][bit+1] := dp[idx+1][bit+1]+(dp[1 - idx+1][bit2+1]) ; 
     dp[idx+1][bit+1] := dp[idx+1][bit+1] mod mod ) else skip )  ;     bit2 := bit2 + 1 ) ; 
     if (i = n - 1) then (     cnt := cnt+(dp[idx+1][bit+1]) ; 
     cnt := cnt mod mod ) else skip )  ;     bit := bit + 1 ) ; 
     idx := 1 - idx ; 
     dp[idx+1] := Integer.subrange(1,(1*(2->pow(3)))->oclAsType(long))->collect(0) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.IOException ;
import java.math.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static String[] B=new String[] {
    "000","001","010","011","100","101","110","111" };
    public static void main(String[] args){
      int n=sc.nextInt();
      String m=sc.next();
      int[][] dp=new int[n][1<<3];
      for(int i=0 ; i<1<<3 ; i++){
        if(B[i] .charAt(JOI(m.charAt(0)))=='1' && B[i] .charAt(0)=='1'){
          dp[0][i]=1 ;
        }
      }
      for(int i=1 ; i<n ; i++){
        for(int j=0 ; j<1<<3 ; j++){
          if(B[j] .charAt(JOI(m.charAt(i)))=='1'){
            for(int k=0 ; k<1<<3 ; k++){
              if((k & j)!=0){
                dp[i][j]+=dp[i-1][k] % 10007 ;
              }
            }
          }
        }
      }
      int sum=0 ;
      for(int i=0 ; i<1<<3 ; i++){
        sum+=dp[n-1][i] % 10007 ;
      }
      System.out.println(sum % 10007);
    }
    static int JOI(char a){
      if(a=='J')return 0 ;
      if(a=='O')return 1 ;
      return 2 ;
    }
    static String B(String a){
      StringBuilder sb=new StringBuilder();
      for(int i=0 ; i<3-a.length(); i++){
        sb.append("0");
      }
      sb.append(a);
      return sb.toString();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute B : Sequence(String) := Sequence{"000","001","010","011","100","101","110","111"};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : String ; m := sc.getCurrent() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,(1*(2->pow(3)))->oclAsType(long))->collect(0)) ;
        var i : int ; i := 0 ; while i < (1*(2->pow(3)))->oclAsType(long) do ( (     if (B[i+1]->at(JOI(m->at(0+1))+1) = '1' & B[i+1]->at(0+1) = '1') then (     dp[0+1][i+1] := 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 0 ; while j < (1*(2->pow(3)))->oclAsType(long) do ( (     if (B[j+1]->at(JOI(m->at(i+1))+1) = '1') then (         var k : int ; k := 0 ; while k < (1*(2->pow(3)))->oclAsType(long) do ( (     if ((MathLib.bitwiseAnd(k,j)) /= 0) then (     dp[i+1][j+1] := dp[i+1][j+1]+(dp[i - 1+1][k+1] mod 10007) ) else skip )  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < (1*(2->pow(3)))->oclAsType(long) do ( (     sum := sum+(dp[n - 1+1][i+1] mod 10007) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum mod 10007) ; 
 );
  static   operation JOI( a : String) : int
  pre: true
  post: true
  activity: (     if (a = 'J') then     return 0 else skip ; 
     if (a = 'O') then     return 1 else skip ; 
     return 2 );
  static   operation B( a : String) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < 3 - a->size() do ( (     sb := sb + StringLib.newString("0") )  ;     i := i + 1 ) ; 
     sb := sb + StringLib.newString(a) ; 
     return sb+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  final int MOD=10007 ;
  void run(){
    int N=sc.nextInt();
    String S=sc.next();
    int[][] dp=new int[N][1<<3];
    for(int i=0 ; i<N ; i++){
      if(i==0){
        for(int j=0 ; j<8 ; j++){
          if((j & 1)>0 &&(j & c_to_i(S.charAt(0)))>0){
            dp[i][j]=1 ;
          }
        }
      }
      else {
        for(int j=0 ; j<8 ; j++){
          for(int k=0 ; k<8 ; k++){
            if((j & k)>0 &&(k & c_to_i(S.charAt(i)))>0){
              dp[i][k]=(dp[i][k]+dp[i-1][j])% MOD ;
            }
          }
        }
      }
    }
    int ans=0 ;
    for(int i=0 ; i<8 ; i++)ans=(ans+dp[N-1][i])% MOD ;
    System.out.println(ans);
  }
  int c_to_i(char c){
    switch(c){
      case 'J' : return 1 ;
      case 'O' : return 2 ;
      case 'I' : return 4 ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute MOD : int := 10007;
   operation run() : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var S : String ; S := sc.getCurrent() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,N)->collect(Integer.subrange(1,(1*(2->pow(3)))->oclAsType(long))->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     if (i = 0) then (         var j : int ; j := 0 ; while j < 8 do ( (     if ((MathLib.bitwiseAnd(j,1)) > 0 & (MathLib.bitwiseAnd(j,c_to_i(S->at(0+1)))) > 0) then (     dp[i+1][j+1] := 1 ) else skip )  ;     j := j + 1 ) ) else (         var j : int ; j := 0 ; while j < 8 do ( (         var k : int ; k := 0 ; while k < 8 do ( (     if ((MathLib.bitwiseAnd(j,k)) > 0 & (MathLib.bitwiseAnd(k,c_to_i(S->at(i+1)))) > 0) then (     dp[i+1][k+1] := (dp[i+1][k+1] + dp[i - 1+1][j+1]) mod MOD ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 8 do (     ans := (ans + dp[N - 1+1][i+1]) mod MOD ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation c_to_i( c : String) : int
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
       if _switchval = 'J' then
     return 1 
   else skip ;
       if _switchval = 'O' then
     return 2 
   else skip ;
       if _switchval = 'I' then
     return 4 
   else skip ;
 )
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static void printNonDivisible(int[] A,int[] B,int n,int m){
    for(int i=0 ; i<m ; i++){
      int j=0 ;
      for(j=0 ; j<n ; j++)if(B[i] % A[j]==0)break ;
      if(j==n)System.out.println(B[i]);
    }
  }
  static public void main(String[] args){
    int[] A={
      100,200,400,100 };
      int n=A.length ;
      int[] B={
        190,200,87,600,800 };
        int m=B.length ;
        printNonDivisible(A,B,n,m);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printNonDivisible( A : Sequence(int), B : Sequence(int), n : int, m : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < m do ( (     var j : int ; j := 0 ;
         j := 0 ; while j < n do (     if (B[i+1] mod A[j+1] = 0) then     break else skip ;  ;     j := j + 1 ) ; 
     if (j = n) then     OclFile["System.out"].println(B[i+1]) ; else skip )  ;     i := i + 1 ) );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{100,200,400,100} ;
     var n : int ; n := A->size() ;
    var B : Sequence(int) ; B := Sequence{190,200,87,600,800} ;
    var m : int ; m := B->size() ;
    execute printNonDivisible(A, B, n, m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p381 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p381().run());
  }
  public String run(){
    boolean[] isPrime=Library.listPrimality(Library.pow(10,8));
    long sum=0 ;
    for(int i=5 ; i<isPrime.length ; i++){
      if(isPrime[i])sum+=s(i);
    }
    return Long.toString(sum);
  }
  private static int s(int p){
    return(int)((long)(p-3)*Library.reciprocalMod(8 % p,p)% p);
  }
}
------------------------------------------------------------
OCL File:
---------
class p381 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p381.newp381().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var isPrime : Sequence(boolean) ; isPrime := Library.listPrimality(Library.pow(10, 8)) ;
     var sum : long ; sum := 0 ;
         var i : int ; i := 5 ; while i < isPrime->size() do ( (     if (isPrime[i+1]) then     sum := sum+(s(i)) ; else skip )  ;     i := i + 1 ) ; 
     return ((sum) + "") );
  static   operation s( p : int) : int
  pre: true
  post: true
  activity: (     return ((p - 3)->oclAsType(long) * Library.reciprocalMod(8 mod p, p) mod p)->oclAsType(int) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int findMaxValue(int[] arr,int n){
    if(n<4){
      System.out.println("The array should have"+" atleast 4 elements");
    }
    int table1[]=new int[n+1];
    int table2[]=new int[n];
    int table3[]=new int[n-1];
    int table4[]=new int[n-2];
    Arrays.fill(table1,Integer.MIN_VALUE);
    Arrays.fill(table2,Integer.MIN_VALUE);
    Arrays.fill(table3,Integer.MIN_VALUE);
    Arrays.fill(table4,Integer.MIN_VALUE);
    for(int i=n-1 ; i>=0 ; i--){
      table1[i]=Math.max(table1[i+1],arr[i]);
    }
    for(int i=n-2 ; i>=0 ; i--){
      table2[i]=Math.max(table2[i+1],table1[i+1]-arr[i]);
    }
    for(int i=n-3 ; i>=0 ; i--)table3[i]=Math.max(table3[i+1],table2[i+1]+arr[i]);
    for(int i=n-4 ; i>=0 ; i--)table4[i]=Math.max(table4[i+1],table3[i+1]-arr[i]);
    return table4[0];
  }
  public static void main(String[] args){
    int arr[]={
      4,8,9,2,20 };
      int n=arr.length ;
      System.out.println(findMaxValue(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMaxValue( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n < 4) then (     OclFile["System.out"].println("The array should have" + " atleast 4 elements") ) else skip ; 
     var table1 : Sequence(int) ; table1 := Integer.subrange(1,n + 1)->collect(0) ;
    var table2 : Sequence(int) ; table2 := Integer.subrange(1,n)->collect(0) ;
    var table3 : Sequence(int) ; table3 := Integer.subrange(1,n - 1)->collect(0) ;
    var table4 : Sequence(int) ; table4 := Integer.subrange(1,n - 2)->collect(0) ;
    table1 := table1->collect(-2147483648) ; 
    table2 := table2->collect(-2147483648) ; 
    table3 := table3->collect(-2147483648) ; 
    table4 := table4->collect(-2147483648) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     table1[i+1] := Set{table1[i + 1+1], arr[i+1]}->max() )  ;     i := i - 1 ) ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     table2[i+1] := Set{table2[i + 1+1], table1[i + 1+1] - arr[i+1]}->max() )  ;     i := i - 1 ) ; 
        var i : int ; i := n - 3 ; while i >= 0 do (     table3[i+1] := Set{table3[i + 1+1], table2[i + 1+1] + arr[i+1]}->max() ;  ;     i := i - 1 ) ; 
        var i : int ; i := n - 4 ; while i >= 0 do (     table4[i+1] := Set{table4[i + 1+1], table3[i + 1+1] - arr[i+1]}->max() ;  ;     i := i - 1 ) ; 
    return table4[0+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,8,9,2,20} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMaxValue(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  boolean check(){
    Scanner sc=new Scanner(System.in);
    Pair[] D=new Pair[6];
    for(int i=0 ; i<6 ; i++){
      D[i]=new Pair(0,0);
      D[i] .first=sc.nextInt();
      D[i] .second=sc.nextInt();
      if(D[i] .first>D[i] .second){
        int tmp=D[i] .first ;
        D[i] .first=D[i] .second ;
        D[i] .second=tmp ;
      }
    }
    Arrays.sort(D,new Comparator<Pair>(){
      public int compare(Pair a,Pair b){
        if(a.first==b.first)return a.second-b.second ;
        return a.first-b.first ;
      }
    }
);
    for(int i=0 ; i<6 ; i+=2){
      if(D[i] .first==D[i+1] .first && D[i] .second==D[i+1] .second)D[i/2]=D[i];
      else return false ;
    }
    return D[0] .first==D[1] .first && D[0] .second==D[2] .first && D[1] .second==D[2] .second ;
  }
  void solve(){
    if(check())System.out.println("yes");
    else System.out.println("no");
  }
  class Pair {
    public int first ;
    public int second ;
    Pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation check() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var D : Sequence(Map) ; D := Integer.subrange(1,6)->collect(null) ;
        var i : int ; i := 0 ; while i < 6 do ( (     D[i+1] := Map(0, 0) ; 
     D[i+1]->at("first") := sc.getCurrent()->toInteger() ; 
     D[i+1]->at("second") := sc.getCurrent()->toInteger() ; 
     if (D[i+1]->at("first") > D[i+1]->at("second")) then (     var tmp : int ; tmp := D[i+1]->at("first") ;
     D[i+1]->at("first") := D[i+1]->at("second") ; 
     D[i+1]->at("second") := tmp ) else skip )  ;     i := i + 1 ) ; 
    D := OclComparator.sortWith(D, OclComparator<Map>.newOclComparator()) ; 
        var i : int ; i := 0 ; while i < 6 do ( (     if (D[i+1]->at("first") = D[i + 1+1]->at("first") & D[i+1]->at("second") = D[i + 1+1]->at("second")) then     D[i / 2+1] := D[i+1] ; else     return false )  ;     i := i+(2) ) ; 
    return D[0+1]->at("first") = D[1+1]->at("first") & D[0+1]->at("second") = D[2+1]->at("first") & D[1+1]->at("second") = D[2+1]->at("second") 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     if (check()) then     OclFile["System.out"].println("yes") ; else     OclFile["System.out"].println("no") ; );
 class Pair {
   attribute first : int;
   attribute second : int;
   static operation newPair( first : int, second : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String[] pooeater=s.split("/");
    int[] n=new int[3];
    n[0]=Integer.parseInt(pooeater[0]);
    n[1]=Integer.parseInt(pooeater[1]);
    n[2]=Integer.parseInt(pooeater[2]);
    if(n[0]>2019){
      System.out.println("TBD");
    }
    else if(n[1]>04){
      System.out.println("TBD");
    }
    else {
      System.out.println("Heisei");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var pooeater : Sequence(String) ; pooeater := s->split("/") ;
    var n : Sequence(int) ; n := Integer.subrange(1,3)->collect(0) ;
    n[0+1] := (pooeater[0+1])->toInteger() ; 
    n[1+1] := (pooeater[1+1])->toInteger() ; 
    n[2+1] := (pooeater[2+1])->toInteger() ; 
    if (n[0+1] > 2019) then (     OclFile["System.out"].println("TBD") ) else     if (n[1+1] > 04) then (     OclFile["System.out"].println("TBD") ) else (     OclFile["System.out"].println("Heisei") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    AStillTBD solver=new AStillTBD();
    solver.solve(1,in,out);
    out.close();
  }
  static class AStillTBD {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      String date=in.next();
      int mon=Integer.parseInt(date.substring(5,7));
      int day=Integer.parseInt(date.substring(8));
      if(mon<=4 && day<=30)out.println("Heisei");
      else if(mon>4)out.println("TBD");
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : AStillTBD ; solver := AStillTBD.newAStillTBD() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class AStillTBD {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var date : String ; date := in.next() ;
     var mon : int ; mon := (date.subrange(5+1,7))->toInteger() ;
     var day : int ; day := (date.subrange(8+1,8))->toInteger() ;
     if (mon <= 4 & day <= 30) then     skip ; else     if (mon > 4) then     skip ; else skip ; );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.text.ParseException ;
import java.text.SimpleDateFormat ;
import java.util.Date ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws ParseException {
    SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd");
    Date baseDate=sdf.parse("2019/04/30");
    try(Scanner sc=new Scanner(System.in)){
      String ret=baseDate.compareTo(sdf.parse(sc.nextLine()))==-1 ? "TBD" : "Heisei" ;
      System.out.println(ret);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sdf : SimpleDateFormat ; sdf := SimpleDateFormat.newSimpleDateFormat("yyyy/MM/dd") ;
     var baseDate : OclDate ; baseDate := sdf.parse("2019/04/30") ;
     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var ret : String ; ret := if baseDate.compareTo(sdf.parse(sc.nextLine())) = -1 then "TBD" else "Heisei" endif ;
     OclFile["System.out"].println(ret) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder x=new StringBuilder(sc.next());
    System.out.println(x+x.reverse().toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : String ; x := StringLib.newString(sc.getCurrent()) ;
     OclFile["System.out"].println(x + x->reverse()+"") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    String s=sc.next();
    String mon=s.substring(5,7);
    System.out.println(mon.equals("01")|| mon.equals("02")|| mon.equals("03")|| mon.equals("04")? "Heisei" : "TBD");
  }
  static int l_min(int[] a){
    Arrays.sort(a);
    return a[0];
  }
  static int l_max(int[] a){
    int l=a.length ;
    Arrays.sort(a);
    return a[l-1];
  }
  public static PrintWriter out ;
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var s : String ; s := sc.next() ;
     var mon : String ; mon := s.subrange(5+1,7) ;
     OclFile["System.out"].println(if mon = "01" or mon = "02" or mon = "03" or mon = "04" then "Heisei" else "TBD" endif) );
  static   operation l_min( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     return a[0+1] );
  static   operation l_max( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var l : int ; l := a->size() ;
     a := a->sort() ; 
     return a[(l)->char2byte() - 1+1] );
  static   attribute out : OclFile;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    Scanner sc=new Scanner(System.in);
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String s=sc.nextLine();
    String[] t=s.split("/");
    int[] n=new int[3];
    for(int i=0 ; i<3 ; i++)n[i]=Integer.parseInt(t[i]);
    if(n[0]<2019){
      System.out.println("Heisei");
    }
    else if(n[0]==2019){
      if(n[1]<4)System.out.println("Heisei");
      else if(n[1]==4){
        if(n[2]<=30)System.out.println("Heisei");
        else System.out.println("TBD");
      }
      else System.out.println("TBD");
    }
    else System.out.println("TBD");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var s : String ; s := sc.nextLine() ;
    var t : Sequence(String) ; t := s->split("/") ;
    var n : Sequence(int) ; n := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do (     n[i+1] := (t[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    if (n[0+1] < 2019) then (     OclFile["System.out"].println("Heisei") ) else     if (n[0+1] = 2019) then (     if (n[1+1] < 4) then     OclFile["System.out"].println("Heisei") ; else     if (n[1+1] = 4) then (     if (n[2+1] <= 30) then     OclFile["System.out"].println("Heisei") ; else     OclFile["System.out"].println("TBD") ; ) else     OclFile["System.out"].println("TBD") ; ;  ) else     OclFile["System.out"].println("TBD") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int totalways(int[] arr,int n){
    HashMap<Integer,Integer>cnt=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      if(cnt.containsKey(arr[i])){
        cnt.put(arr[i],cnt.get(arr[i])+1);
      }
      else {
        cnt.put(arr[i],1);
      }
    }
    if(n % 2==1){
      int start=0,endd=n-1 ;
      for(int i=start ; i<=endd ; i=i+2){
        if(i==0){
          if(cnt.get(i)!=1){
            return 0 ;
          }
        }
        else {
          if(cnt.get(i)!=2){
            return 0 ;
          }
        }
      }
      int ways=1 ;
      start=2 ;
      endd=n-1 ;
      for(int i=start ; i<=endd ; i=i+2){
        ways=ways*2 ;
      }
      return ways ;
    }
    else if(n % 2==0){
      int start=1,endd=n-1 ;
      for(int i=1 ; i<=endd ; i=i+2){
        if(cnt.get(i)!=2)return 0 ;
      }
      int ways=1 ;
      for(int i=start ; i<=endd ; i=i+2){
        ways=ways*2 ;
      }
      return ways ;
    }
    return Integer.MIN_VALUE ;
  }
  public static void main(String[] args){
    int N=5 ;
    int[] arr={
      2,4,4,0,2 };
      System.out.println(totalways(arr,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation totalways( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var cnt : Map(int,int) ; cnt := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (cnt->keys()->includes(arr[i+1])) then (     cnt := cnt->union(Map{arr[i+1] |-> cnt->at(arr[i+1]) + 1}) ) else (     cnt := cnt->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
     if (n mod 2 = 1) then (     var start : int ; start := 0 ;
    var endd : int ; endd := n - 1 ;
         var i : int ; i := start ; while i <= endd do ( (     if (i = 0) then (     if (cnt->at(i) /= 1) then (     return 0 ) else skip ) else (     if (cnt->at(i) /= 2) then (     return 0 ) else skip ) )  ;     i := i + 2 ) ; 
    var ways : int ; ways := 1 ;
    start := 2 ; 
    endd := n - 1 ; 
        var i : int ; i := start ; while i <= endd do ( (     ways := ways * 2 )  ;     i := i + 2 ) ; 
    return ways 
 ) else     if (n mod 2 = 0) then (     var start : int ; start := 1 ;
    var endd : int ; endd := n - 1 ;
         var i : int ; i := 1 ; while i <= endd do ( (     if (cnt->at(i) /= 2) then     return 0 else skip )  ;     i := i + 2 ) ; 
    var ways : int ; ways := 1 ;
        var i : int ; i := start ; while i <= endd do ( (     ways := ways * 2 )  ;     i := i + 2 ) ; 
    return ways 
 ) else skip ; ;  
     return -2147483648 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     var arr : Sequence(int) ; arr := Sequence{2,4,4,0,2} ;
     OclFile["System.out"].println(totalways(arr, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int calculate(int a[],int n){
    Arrays.sort(a);
    int count=1 ;
    int answer=0 ;
    for(int i=1 ; i<n ; i++){
      if(a[i]==a[i-1]){
        count+=1 ;
      }
      else {
        answer=answer+(count*(count-1))/2 ;
        count=1 ;
      }
    }
    answer=answer+(count*(count-1))/2 ;
    return answer ;
  }
  public static void main(String[] args){
    int a[]={
      1,2,1,2,4 };
      int n=a.length ;
      System.out.println(calculate(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculate( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var count : int ; count := 1 ;
    var answer : int ; answer := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] = a[i - 1+1]) then (     count := count+(1) ) else (     answer := answer + (count * (count - 1)) / 2 ; 
     count := 1 ) )  ;     i := i + 1 ) ; 
    answer := answer + (count * (count - 1)) / 2 ; 
    return answer 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,1,2,4} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(calculate(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
class GFG {
  public static int kthgroupsum(int k){
    int cur=(k*(k-1))+1 ;
    int sum=0 ;
    while(k-->0){
      sum+=cur ;
      cur+=2 ;
    }
    return sum ;
  }
  public static void main(String[] args){
    int k=3 ;
    System.out.print(kthgroupsum(k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation kthgroupsum( k : int) : int
  pre: true
  post: true
  activity: (     var cur : int ; cur := (k * (k - 1)) + 1 ;
     var sum : int ; sum := 0 ;
         while (k > 0) do (        k := k - 1 ;     skip ; (     sum := sum+(cur) ; 
     cur := cur+(2) ) ;  ) ;  
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 3 ;
     OclFile["System.out"].print(kthgroupsum(k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int w=sc.nextInt();
      int h=sc.nextInt();
      if(w==0 && h==0)break ;
      String s ;
      int t ;
      int d=0 ;
      int x=0 ;
      int y=0 ;
      char c ;
      while(true){
        s=sc.next();
        c=s.charAt(0);
        if(c=='S'){
          System.out.println((x+1)+" "+(y+1));
          break ;
        }
        else if(c=='R'){
          d++;
          if(d==4)d=0 ;
        }
        else if(c=='L'){
          d--;
          if(d==-1)d=3 ;
        }
        else if((c=='F' && d==0)||(c=='B' && d==2)){
          t=sc.nextInt();
          y+=t ;
          if(y>h-1)y=h-1 ;
        }
        else if((c=='F' && d==1)||(c=='B' && d==3)){
          t=sc.nextInt();
          x+=t ;
          if(x>w-1)x=w-1 ;
        }
        else if((c=='F' && d==2)||(c=='B' && d==0)){
          t=sc.nextInt();
          y-=t ;
          if(y<0)y=0 ;
        }
        else if((c=='F' && d==3)||(c=='B' && d==1)){
          t=sc.nextInt();
          x-=t ;
          if(x<0)x=0 ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var w : int ; w := sc.getCurrent()->toInteger() ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    if (w = 0 & h = 0) then     break else skip ; 
    var s : String ;
    var t : int ;
    var d : int ; d := 0 ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var c : String ;
    while (true) do (     s := sc.getCurrent() ; 
     c := s->at(0+1) ; 
     if (c = 'S') then (     OclFile["System.out"].println((x + 1) + " " + (y + 1)) ; 
     break ) else     if (c = 'R') then (     d := d + 1 ; 
     if (d = 4) then     d := 0 ; else skip ) else     if (c = 'L') then (     d := d - 1 ; 
     if (d = -1) then     d := 3 ; else skip ) else     if ((c = 'F' & d = 0) or (c = 'B' & d = 2)) then (     t := sc.getCurrent()->toInteger() ; 
     y := y+(t) ; 
     if (y > h - 1) then     y := h - 1 ; else skip ) else     if ((c = 'F' & d = 1) or (c = 'B' & d = 3)) then (     t := sc.getCurrent()->toInteger() ; 
     x := x+(t) ; 
     if (x > w - 1) then     x := w - 1 ; else skip ) else     if ((c = 'F' & d = 2) or (c = 'B' & d = 0)) then (     t := sc.getCurrent()->toInteger() ; 
     y := y-(t) ; 
     if (y < 0) then     y := 0 ; else skip ) else     if ((c = 'F' & d = 3) or (c = 'B' & d = 1)) then (     t := sc.getCurrent()->toInteger() ; 
     x := x-(t) ; 
     if (x < 0) then     x := 0 ; else skip ) else skip ; ;  ;  ;  ;  ;  ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
class GFG {
  public static int kthgroupsum(int k){
    return k*k*k ;
  }
  public static void main(String[] args){
    int k=3 ;
    System.out.print(kthgroupsum(k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation kthgroupsum( k : int) : int
  pre: true
  post: true
  activity: (     return k * k * k );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 3 ;
     OclFile["System.out"].print(kthgroupsum(k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public void go(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextLine()){
      String lines0 ;
      String lines1 ;
      lines0=sc.nextLine();
      if(lines0.equals(".")){
        sc.close();
        return ;
      }
      lines1=sc.nextLine();
      if(lines0.equals(lines1)){
        System.out.println("IDENTICAL");
        continue ;
      }
      String[] strSplit0=lines0.split("\"",-1);
      String[] strSplit1=lines1.split("\"",-1);
      if(strSplit0.length!=strSplit1.length){
        System.out.println("DIFFERENT");
        continue ;
      }
      int close=0 ;
      for(int j=0 ; j<strSplit0.length ; j++){
        if(! strSplit0[j] .equals(strSplit1[j])){
          if(j % 2==1){
            close++;
          }
          else {
            close=2 ;
            break ;
          }
        }
      }
      switch(close){
        case 1 : System.out.println("CLOSE");
        break ;
        case 0 : System.out.println("IDENTICAL");
        break ;
        default : System.out.println("DIFFERENT");
      }
    }
  }
  public static void main(String[] args){
    Main kadai=new Main();
    kadai.go();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation go() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextLine()) do (     var lines0 : String ;
     var lines1 : String ;
    lines0 := sc.nextLine() ; 
    if (lines0 = ".") then (     skip ; 
     return ) else skip ; 
    lines1 := sc.nextLine() ; 
    if (lines0 = lines1) then (     OclFile["System.out"].println("IDENTICAL") ; 
     continue ) else skip ; 
    var strSplit0 : Sequence(String) ; strSplit0 := lines0->split("\"") ;\n    var strSplit1 : Sequence(String) ; strSplit1 := lines1->split("\"") ;
    if (strSplit0->size() /= strSplit1->size()) then (     OclFile["System.out"].println("DIFFERENT") ; 
     continue ) else skip ; 
    var close : int ; close := 0 ;
        var j : int ; j := 0 ; while j < strSplit0->size() do ( (     if (not(strSplit0[j+1] = strSplit1[j+1])) then (     if (j mod 2 = 1) then (     close := close + 1 ) else (     close := 2 ; 
     break ) ) else skip )  ;     j := j + 1 ) ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (close) ; 
       if _switchval = 1 then
     OclFile["System.out"].println("CLOSE") ; 
    break 
   else skip ;
       if _switchval = 0 then
     OclFile["System.out"].println("IDENTICAL") ; 
    break 
   else skip ;
       if true then
     OclFile["System.out"].println("DIFFERENT") ; 
   else skip ;
 )
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var kadai : Main ; kadai := Main.newMain() ;
     kadai.go() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static final String IDENTICAL="IDENTICAL" ;
  static final String CLOSE="CLOSE" ;
  static final String DIFFERENT="DIFFERENT" ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(true){
      String s1=in.next();
      if(s1.equals("."))break ;
      String[] arrStr1=s1.split("\"",-1);
      String s2=in.next();
      String[] arrSrt2=s2.split("\"",-1);
      if(arrStr1.length==arrSrt2.length){
        int result=0 ;
        for(int i=0 ; i<arrStr1.length ; i++){
          if(i % 2==0 && ! arrStr1[i] .equals(arrSrt2[i])){
            result+=2 ;
          }
          else if(i % 2==1 && ! arrStr1[i] .equals(arrSrt2[i])){
            result++;
          }
        }
        if(result==0){
          System.out.println(IDENTICAL);
        }
        else if(result==1){
          System.out.println(CLOSE);
        }
        else {
          System.out.println(DIFFERENT);
        }
      }
      else {
        System.out.println(DIFFERENT);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute IDENTICAL : String := "IDENTICAL";
  static    attribute CLOSE : String := "CLOSE";
  static    attribute DIFFERENT : String := "DIFFERENT";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var s1 : String ; s1 := in.getCurrent() ;
     if (s1 = ".") then     break else skip ; 
    var arrStr1 : Sequence(String) ; arrStr1 := s1->split("\"") ;\n    var s2 : String ; s2 := in.getCurrent() ;\n    var arrSrt2 : Sequence(String) ; arrSrt2 := s2->split("\"") ;
    if (arrStr1->size() = arrSrt2->size()) then (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < arrStr1->size() do ( (     if (i mod 2 = 0 & not(arrStr1[i+1] = arrSrt2[i+1])) then (     result := result+(2) ) else     if (i mod 2 = 1 & not(arrStr1[i+1] = arrSrt2[i+1])) then (     result := result + 1 ) else skip ; )  ;     i := i + 1 ) ; 
     if (result = 0) then (     OclFile["System.out"].println(IDENTICAL) ) else     if (result = 1) then (     OclFile["System.out"].println(CLOSE) ) else (     OclFile["System.out"].println(DIFFERENT) ) ;  ) else (     OclFile["System.out"].println(DIFFERENT) ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    String s1="",s2="" ;
    while(true){
      s1=bfr.readLine()+"END" ;
      if(s1.equals(".END")){
        System.exit(0);
      }
      s2=bfr.readLine()+"END" ;
      String[] s1m=s1.split("\"");
      String[] s2m=s2.split("\"");
      int cnt=0 ;
      if(s1m.length!=s2m.length){
        System.out.println("DIFFERENT");
      }
      else {
        boolean isnea=false ;
        for(int i=0 ; i<s2m.length ; i++){
          if(! s1m[i] .equals(s2m[i])&& i % 2==1){
            isnea=true ;
            cnt++;
          }
          else if(i % 2==0){
            if(! s1m[i] .equals(s2m[i])){
              cnt=2 ;
            }
          }
        }
        if(cnt>1){
          System.out.println("DIFFERENT");
        }
        else if(cnt==1){
          System.out.println("CLOSE");
        }
        else if(cnt==0){
          System.out.println("IDENTICAL");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bfr : OclFile ; bfr := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s1 : String ; s1 := "" ;
    var s2 : String ; s2 := "" ;
     while (true) do (     s1 := bfr.readLine() + "END" ; 
     if (s1 = ".END") then ( OclProcess.exit(0) ) else skip ; 
    s2 := bfr.readLine() + "END" ; 
    var s1m : Sequence(String) ; s1m := s1->split("\"") ;\n    var s2m : Sequence(String) ; s2m := s2->split("\"") ;
    var cnt : int ; cnt := 0 ;
    if (s1m->size() /= s2m->size()) then (     OclFile["System.out"].println("DIFFERENT") ) else (     var isnea : boolean ; isnea := false ;
         var i : int ; i := 0 ; while i < s2m->size() do ( (     if (not(s1m[i+1] = s2m[i+1]) & i mod 2 = 1) then (     isnea := true ; 
     cnt := cnt + 1 ) else     if (i mod 2 = 0) then (     if (not(s1m[i+1] = s2m[i+1])) then (     cnt := 2 ) else skip ) else skip ; )  ;     i := i + 1 ) ; 
     if (cnt > 1) then (     OclFile["System.out"].println("DIFFERENT") ) else     if (cnt = 1) then (     OclFile["System.out"].println("CLOSE") ) else     if (cnt = 0) then (     OclFile["System.out"].println("IDENTICAL") ) else skip ; ;  ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    String s=in.nextLine();
    while(! ".".equals(s)){
      String t=in.nextLine();
      if(s.equals(t)){
        out.println("IDENTICAL");
        s=in.nextLine();
        continue ;
      }
      List<String>st=parse(s,false),tt=parse(t,false),sk=parse(s,true),tk=parse(t,true);
      if(! sk.equals(tk)|| st.size()!=tt.size()){
        out.println("DIFFERENT");
        s=in.nextLine();
        continue ;
      }
      int cnt=0 ;
      for(int i=0 ; i<st.size(); i++){
        if(! st.get(i).equals(tt.get(i)))cnt++;
      }
      out.println(cnt==0 ? "IDENTICAL" : cnt==1 ? "CLOSE" : "DIFFERENT");
      s=in.nextLine();
    }
    out.flush();
  }
  private static List<String>parse(String s,boolean init){
    List<String>res=new ArrayList<>();
    boolean q=init ;
    StringBuilder sb=new StringBuilder();
    for(char c : s.toCharArray()){
      if(c=='"'){
        if(q){
          res.add(sb.toString());
          q=false ;
        }
        else {
          sb.setLength(0);
          q=true ;
        }
      }
      else if(q){
        sb.append(c);
      }
    }
    if(q){
      res.add(sb.toString());
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : String ; s := in.nextLine() ;
    while (not("." = s)) do (     var t : String ; t := in.nextLine() ;
     if (s = t) then (     skip ; 
     s := in.nextLine() ; 
     continue ) else skip ; 
    var st : Sequence(String) ; st := parse(s, false) ;
    var tt : Sequence(String) ; tt := parse(t, false) ;
    var sk : Sequence(String) ; sk := parse(s, true) ;
    var tk : Sequence(String) ; tk := parse(t, true) ;
    if (not(sk = tk) or st->size() /= tt->size()) then (     skip ; 
     s := in.nextLine() ; 
     continue ) else skip ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < st->size() do ( (     if (not(st->at(i+1) = tt->at(i+1))) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
    s := in.nextLine() ; 
 ) ; 
    skip ; 
 );
  static   operation parse( s : String, init : boolean) : Sequence(String)
  pre: true
  post: true
  activity: (     var res : Sequence(String) ; res := Sequence{} ;
     var q : boolean ; q := init ;
    var sb : String ; sb := StringLib.newString() ;
    for (c : s->characters()) do ( (     if (c = '"') then (     if (q) then (     res := res->including(sb+"") ; \n     q := false ) else (     sb := sb.subrange(1,0) ; \n     q := true ) ) else     if (q) then (     sb := sb + StringLib.newString(c) ) else skip ; )  ) ; \n    if (q) then (     res := res->including(sb+"") ) else skip ; \n    return res \n );\n\n}\n\n

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B_Lovely_Palindromes {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    StringBuilder sb=new StringBuilder(s).reverse();
    System.out.println(s+=sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Lovely_Palindromes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
     var sb : String ; sb := StringLib.newString(s)->reverse() ;
     OclFile["System.out"].println(s) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    while(true){
      String str1=cin.next();
      if(str1.equals("."))break ;
      String str2=cin.next();
      String[] stra1=str1.split("\"",-1);
      String[] stra2=str2.split("\"",-1);
      int n=stra1.length,jd=0 ;
      if(n==stra2.length){
        int s1m,s1lm,s2m,s2lm ;
        if(str1.indexOf("\"")==0)s1m=1 ;
        else s1m=0 ;
        if(str2.indexOf("\"")==0)s2m=1 ;
        else s2m=0 ;
        if(str1.lastIndexOf("\"")==str1.length()-1)s1lm=1 ;
        else s1lm=0 ;
        if(str2.lastIndexOf("\"")==str2.length()-1)s2lm=1 ;
        else s2lm=0 ;
        if(s1m==s2m && s1lm==s2lm){
          boolean MODE=false ;
          int same=0 ;
          for(int i=0 ; i<n ; i++){
            if(! MODE && ! stra1[i] .equals(stra2[i])){
              same=0 ;
              break ;
            }
            else if(! MODE && stra1[i] .equals(stra2[i]))same++;
            else if(MODE && stra1[i] .equals(stra2[i]))same++;
            MODE=! MODE ;
          }
          if(same==n)jd=2 ;
          else if(n>=2 && same==n-1)jd=1 ;
        }
      }
      if(jd==2)System.out.println("IDENTICAL");
      else if(jd==1)System.out.println("CLOSE");
      else System.out.println("DIFFERENT");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var str1 : String ; str1 := cin.getCurrent() ;
     if (str1 = ".") then     break else skip ; 
    var str2 : String ; str2 := cin.getCurrent() ;
    var stra1 : Sequence(String) ; stra1 := str1->split("\"") ;\n    var stra2 : Sequence(String) ; stra2 := str2->split("\"") ;
    var n : int ; n := stra1->size() ;
    var jd : int ; jd := 0 ;
    if (n = stra2->size()) then (     var s1m : int ;
    var s1lm : int ;
    var s2m : int ;
    var s2lm : int ;
     if (str1->indexOf("\"")-1 = 0) then     s1m := 1 else     s1m := 0 ; ;  \n    if (str2->indexOf("\"")-1 = 0) then     s2m := 1 else     s2m := 0 ; ;  
    if (str1->lastIndexOf("\"")-1 = str1->size() - 1) then     s1lm := 1 else     s1lm := 0 ; ;  \n    if (str2->lastIndexOf("\"")-1 = str2->size() - 1) then     s2lm := 1 else     s2lm := 0 ; ;  
    if (s1m = s2m & s1lm = s2lm) then (     var MODE : boolean ; MODE := false ;
     var same : int ; same := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (not(MODE) & not(stra1[i+1] = stra2[i+1])) then (     same := 0 ; 
     break ) else     if (not(MODE) & stra1[i+1] = stra2[i+1]) then     same := same + 1 else     if (MODE & stra1[i+1] = stra2[i+1]) then     same := same + 1 ; else skip ; ;  ;  
     MODE := not(MODE) )  ;     i := i + 1 ) ; 
     if (same = n) then     jd := 2 ; else     if (n >= 2 & same = n - 1) then     jd := 1 ; else skip ; ) else skip ; 
 ) else skip ; 
    if (jd = 2) then     OclFile["System.out"].println("IDENTICAL") else     if (jd = 1) then     OclFile["System.out"].println("CLOSE") else     OclFile["System.out"].println("DIFFERENT") ; ;  ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Answer {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=Integer.parseInt(sc.nextLine());
    String s=sc.next();
    StringBuilder ans=new StringBuilder();
    int count=0 ;
    boolean flag=false ;
    for(Character x : s.toCharArray()){
      if(x=='1'){
        count++;
        flag=false ;
      }
      else if(x=='0' && ! flag){
        ans.append(count);
        count=0 ;
        flag=true ;
      }
      else ans.append(0);
    }
    ans.append(count);
    pw.println(ans.toString());
    pw.close();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Answer {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (sc.nextLine())->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var ans : String ; ans := StringLib.newString() ;
    var count : int ; count := 0 ;
    var flag : boolean ; flag := false ;
    for (x : s->characters()) do ( (     if (x = '1') then (     count := count + 1 ; 
     flag := false ) else     if (x = '0' & not(flag)) then (     ans := ans + StringLib.newString(count) ; 
     count := 0 ; 
     flag := true ) else     ans := ans + StringLib.newString(0) ; ;  )  ) ; 
    ans := ans + StringLib.newString(count) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    char[] s=(in.next()+"0").toCharArray();
    boolean hasZero=false ;
    for(int i=0 ; i<n ; i++){
      if(s[i]=='1'){
        int cnt=0 ;
        int j=i ;
        while(j<s.length && s[j]=='1'){
          cnt++;
          j++;
        }
        i=j-1 ;
        pw.print(cnt);
      }
      else {
        if(s[i]=='0'){
          int cnt=0 ;
          int j=i ;
          while(j<s.length && s[j]=='0'){
            j++;
            cnt++;
          }
          i=j-1 ;
          for(int k=0 ; k<cnt-1 ; k++)pw.print("0");
        }
      }
    }
    pw.println();
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := (in.getCurrent() + "0")->characters() ;
    var hasZero : boolean ; hasZero := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] = '1') then (     var cnt : int ; cnt := 0 ;
     var j : int ; j := i ;
    while (j < s->size() & s[j+1] = '1') do (     cnt := cnt + 1 ; 
     j := j + 1 ) ; 
    i := j - 1 ; 
    skip ; 
 ) else (     if (s[i+1] = '0') then (     var cnt : int ; cnt := 0 ;
     var j : int ; j := i ;
    while (j < s->size() & s[j+1] = '0') do (     j := j + 1 ; 
     cnt := cnt + 1 ) ; 
    i := j - 1 ; 
        var k : int ; k := 0 ; while k < cnt - 1 do (     skip ;  ;     k := k + 1 ) ; 
 ) else skip ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long n,d ;
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    String S=in.next()+"0" ;
    StringBuilder sb=new StringBuilder();
    int count=0 ;
    for(int i=0 ; i<S.length(); i++){
      if(S.charAt(i)=='0'){
        sb.append(count);
        count=0 ;
      }
      else {
        count++;
      }
    }
    pw.println(sb);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var S : String ; S := in.getCurrent() + "0" ;
    var sb : String ; sb := StringLib.newString() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < S->size() do ( (     if (S->at(i+1) = '0') then (     sb := sb + StringLib.newString(count) ; 
     count := 0 ) else (     count := count + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void centeredHexagonalSeries(int n){
    for(int i=1 ; i<=n ; i++)System.out.print(3*i*(i-1)+1+" ");
  }
  public static void main(String args[]){
    int n=10 ;
    centeredHexagonalSeries(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation centeredHexagonalSeries( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= n do (     OclFile["System.out"].print(3 * i * (i - 1) + 1 + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     execute centeredHexagonalSeries(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static long getCount(int A,int B2,int C){
    long count=0 ;
    for(int i=1 ; i<=A ; i++){
      long j=(B2/i)+1 ;
      if(C>=j)count=(count+C-j+1);
      if(A>=j && C>=i)count=(count+(C-i+1)*(A-j+1));
      if(A>=j)A=(int)(j-1);
    }
    return count ;
  }
  static long countTriplets(int A,int B,int C){
    long ans=0 ;
    for(int i=1 ; i<=B ; i++){
      ans=(ans+getCount(A,i*i,C));
    }
    return ans ;
  }
  public static void main(String[] args){
    int A,B,C ;
    A=3 ;
    B=2 ;
    C=2 ;
    System.out.println(countTriplets(A,B,C));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getCount( A : int, B2 : int, C : int) : long
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
         var i : int ; i := 1 ; while i <= A do ( (     var j : long ; j := (B2 / i) + 1 ;
     if (C >= j) then     count := (count + C - j + 1) ; else skip ; 
     if (A >= j & C >= i) then     count := (count + (C - i + 1) * (A - j + 1)) ; else skip ; 
     if (A >= j) then     A := (j - 1)->oclAsType(int) ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation countTriplets( A : int, B : int, C : int) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
         var i : int ; i := 1 ; while i <= B do ( (     ans := (ans + getCount(A, i * i, C)) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ;
    var B : int ;
    var C : int ;
     A := 3 ; 
    B := 2 ; 
    C := 2 ; 
    OclFile["System.out"].println(countTriplets(A, B, C)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] data=new int[n+1];
    int minScore=0 ;
    for(int i=1 ; i<=n ; i++){
      int score=sc.nextInt();
      data[i]=score ;
      if(i==k)minScore=score ;
    }
    int cnt=0 ;
    for(int i=1 ; i<=n ; i++){
      if(data[i]>=minScore && data[i]>0)cnt++;
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var data : Sequence(int) ; data := Integer.subrange(1,n + 1)->collect(0) ;
    var minScore : int ; minScore := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var score : int ; score := sc.getCurrent()->toInteger() ;
     data[i+1] := score ; 
     if (i = k) then     minScore := score ; else skip )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (data[i+1] >= minScore & data[i+1] > 0) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class nextRound {
  public static void main(String[] args){
    int n,k ;
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    k=sc.nextInt();
    int i,j ;
    int a[]=new int[n+1];
    a[0]=0 ;
    for(i=1 ; i<=n ; i++){
      a[i]=sc.nextInt();
    }
    int results=0 ;
    for(i=1 ; i<=n ; i++){
      if(a[i]>=a[k] && a[i]!=0)results++;
    }
    System.out.println(results);
  }
}
------------------------------------------------------------
OCL File:
---------
 class nextRound {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var k : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := sc.getCurrent()->toInteger() ; 
    k := sc.getCurrent()->toInteger() ; 
    var i : int ;
    var j : int ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    a[0+1] := 0 ; 
        i := 1 ; while i <= n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var results : int ; results := 0 ;
        i := 1 ; while i <= n do ( (     if (a[i+1] >= a[k+1] & a[i+1] /= 0) then     results := results + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(results) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class nectround {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int p=0 ;
    int[] a=new int[51];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    int t=a[0];
    int cp=1 ;
    int cs=a[k-1];
    int x=0 ;
    for(int i=0 ; i<n ; i++){
      if(cs<=a[i] && a[i]!=0){
        x++;
      }
      else {
        break ;
      }
    }
    System.out.println(x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class nectround {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var p : int ; p := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,51)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var t : int ; t := a[0+1] ;
    var cp : int ; cp := 1 ;
    var cs : int ; cs := a[k - 1+1] ;
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (cs <= a[i+1] & a[i+1] /= 0) then (     x := x + 1 ) else (     break ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(x) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NextRound {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int number=in.nextInt();
    int index=in.nextInt();
    int[] contest=new int[number];
    for(int i=0 ; i<number ; i++){
      contest[i]=in.nextInt();
    }
    int counter=0 ;
    for(int i=0 ; i<number ; i++){
      if(contest[i]>=contest[index-1] && contest[i]!=0)counter++;
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class NextRound {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := in.getCurrent()->toInteger() ;
    var index : int ; index := in.getCurrent()->toInteger() ;
    var contest : Sequence(int) ; contest := Integer.subrange(1,number)->collect(0) ;
        var i : int ; i := 0 ; while i < number do ( (     contest[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < number do ( (     if (contest[i+1] >= contest[index - 1+1] & contest[i+1] /= 0) then     counter := counter + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int[] a=new int[51];
    int n=scan.nextInt();
    int k=scan.nextInt();
    int i ;
    for(i=0 ; i<n ; i++){
      a[i]=scan.nextInt();
    }
    if(a[k]<=0){
      i=k-1 ;
      while(i!=-1){
        if(a[i]>0){
          i++;
          break ;
        }
        i--;
      }
      System.out.println((i>0)? i : 0);
    }
    else {
      if(a[k-1]==a[k]){
        i=k ;
        while(a[i]==a[i+1]){
          i++;
        }
        System.out.println(i+1);
      }
      else System.out.println(k);
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,51)->collect(0) ;
    var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var i : int ;
        i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (a[k+1] <= 0) then (     i := k - 1 ; 
     while (i /= -1) do (     if (a[i+1] > 0) then (     i := i + 1 ; 
     break ) else skip ; 
     i := i - 1 ) ; 
     OclFile["System.out"].println(if (i > 0) then i else 0 endif) ) else (     if (a[k - 1+1] = a[k+1]) then (     i := k ; 
     while (a[i+1] = a[i + 1+1]) do (     i := i + 1 ) ; 
     OclFile["System.out"].println(i + 1) ) else     OclFile["System.out"].println(k) ; ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String n=in.next();
    System.out.print(n);
    for(int i=n.length()-1 ; i>=0 ; i--){
      System.out.print(n.charAt(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : String ; n := in.getCurrent() ;
     OclFile["System.out"].print(n) ; 
         var i : int ; i := n->size() - 1 ; while i >= 0 do ( (     OclFile["System.out"].print(n->at(i+1)) )  ;     i := i - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CF6A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] a=new int[4];
    for(int i=0 ; i<4 ; i++){
      a[i]=sc.nextInt();
    }
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<3 ; j++){
        if(a[j]>a[j+1]){
          int tmp=a[j];
          a[j]=a[j+1];
          a[j+1]=tmp ;
        }
      }
    }
    if(a[0]+a[1]>a[2] || a[1]+a[2]>a[3])System.out.println("TRIANGLE");
    else if(a[0]+a[1]==a[2] || a[1]+a[2]==a[3])System.out.println("SEGMENT");
    else System.out.println("IMPOSSIBLE");
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF6A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     if (a[j+1] > a[j + 1+1]) then (     var tmp : int ; tmp := a[j+1] ;
     a[j+1] := a[j + 1+1] ; 
     a[j + 1+1] := tmp ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (a[0+1] + a[1+1] > a[2+1] or a[1+1] + a[2+1] > a[3+1]) then     OclFile["System.out"].println("TRIANGLE") else     if (a[0+1] + a[1+1] = a[2+1] or a[1+1] + a[2+1] = a[3+1]) then     OclFile["System.out"].println("SEGMENT") else     OclFile["System.out"].println("IMPOSSIBLE") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] arr=new int[4];
    for(int i=0 ; i<4 ; i++){
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr);
    if(arr[0]+arr[1]>arr[2] || arr[1]+arr[2]>arr[3]){
      System.out.println("TRIANGLE");
    }
    else if(arr[0]+arr[1]==arr[2] || arr[1]+arr[2]==arr[3]){
      System.out.println("SEGMENT");
    }
    else {
      System.out.println("IMPOSSIBLE");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    if (arr[0+1] + arr[1+1] > arr[2+1] or arr[1+1] + arr[2+1] > arr[3+1]) then (     OclFile["System.out"].println("TRIANGLE") ) else     if (arr[0+1] + arr[1+1] = arr[2+1] or arr[1+1] + arr[2+1] = arr[3+1]) then (     OclFile["System.out"].println("SEGMENT") ) else (     OclFile["System.out"].println("IMPOSSIBLE") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Asda {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int[] triangle=new int[4];
    for(int i=0 ; i<triangle.length ; i++){
      triangle[i]=scan.nextInt();
    }
    Arrays.sort(triangle);
    if(triangle[0]+triangle[1]>triangle[2] || triangle[1]+triangle[2]>triangle[3]){
      System.out.println("TRIANGLE");
    }
    else if(triangle[0]+triangle[1]==triangle[2] || triangle[1]+triangle[2]==triangle[3]){
      System.out.println("SEGMENT");
    }
    else System.out.println("IMPOSSIBLE");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Asda {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var triangle : Sequence(int) ; triangle := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < triangle->size() do ( (     triangle[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    triangle := triangle->sort() ; 
    if (triangle[0+1] + triangle[1+1] > triangle[2+1] or triangle[1+1] + triangle[2+1] > triangle[3+1]) then (     OclFile["System.out"].println("TRIANGLE") ) else     if (triangle[0+1] + triangle[1+1] = triangle[2+1] or triangle[1+1] + triangle[2+1] = triangle[3+1]) then (     OclFile["System.out"].println("SEGMENT") ) else     OclFile["System.out"].println("IMPOSSIBLE") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static String[] ABC={
    "A","B","C" };
    public static void main(String[] args){
      Scanner sc=new Scanner(System.in);
      String S=sc.next();
      if(dfs(S)){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
    static boolean dfs(String S){
      if(S.equals("ABC")){
        return true ;
      }
      int cnt=0 ;
      boolean f=false ;
      boolean[] pos=new boolean[S.length()];
      for(int j=0 ; j+3<=S.length(); ++j){
        if(S.substring(j,j+3).equals("ABC")){
          pos[j]=true ;
++cnt ;
        }
      }
      if(cnt<1)return false ;
      out : for(int i=0 ;
      i<3 ;
++i){
        for(int j=0 ; j<S.length(); ++j){
          if(S.charAt(j)=='A'+i){
            if(j-i<0 || ! pos[j-i])continue out ;
          }
        }
        String next=S.replaceAll("ABC",ABC[i]);
        f |=dfs(next.toString());
      }
      return f ;
    }
    static void tr(Object...objects){
      System.out.println(Arrays.deepToString(objects));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ABC : Sequence(String) := Sequence{"A","B","C"};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
     if (dfs(S)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
  static   operation dfs( S : String) : boolean
  pre: true
  post: true
  activity: (     if (S = "ABC") then (     return true ) else skip ; 
     var cnt : int ; cnt := 0 ;
    var f : boolean ; f := false ;
    var pos : Sequence(boolean) ; pos := Integer.subrange(1,S->size())->collect(false) ;
        var j : int ; j := 0 ; while j + 3 <= S->size() do ( (     if (S.subrange(j+1,j + 3) = "ABC") then (     pos[j+1] := true ; 
     cnt := cnt + 1 ) else skip )  ;     j := j + 1 ) ; 
    if (cnt < 1) then     return false else skip ; 
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < S->size() do ( (     if (S->at(j+1) = 'A' + i) then (     if (j - i < 0 or not(pos[j - i+1])) then     continue else skip ) else skip )  ;     j := j + 1 ) ; 
     var next : String ; next := S.replaceAllMatches("ABC", ABC[i+1] ) ;
     f := MathLib.bitwiseOr(f, dfs(next+"")) )  ;     i := i + 1 ) ; 
    return f 
 );
  static   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int[] a=new int[4];
    for(int i=0 ; i<4 ; i+=1){
      a[i]=in.nextInt();
    }
    Arrays.sort(a);
    String[] ans={
      "IMPOSSIBLE","SEGMENT","TRIANGLE" };
      int best=0 ;
      for(int i=0 ; i<2 ; i++){
        if(a[i]+a[i+1]>a[i+2]){
          best=2 ;
        }
        else if(a[i]+a[i+1]==a[i+2]){
          best=Math.max(1,best);
        }
      }
      System.out.println(ans[best]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i+(1) ) ; 
    a := a->sort() ; 
    var ans : Sequence(String) ; ans := Sequence{"IMPOSSIBLE","SEGMENT","TRIANGLE"} ;
    var best : int ; best := 0 ;
        var i : int ; i := 0 ; while i < 2 do ( (     if (a[i+1] + a[i + 1+1] > a[i + 2+1]) then (     best := 2 ) else     if (a[i+1] + a[i + 1+1] = a[i + 2+1]) then (     best := Set{1, best}->max() ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans[best+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner user=new Scanner(System.in);
    int[] arr=new int[4];
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=user.nextInt();
    }
    for(int i=0 ; i<arr.length ; i++){
      for(int j=0 ; j<arr.length ; j++){
        if(arr[i]<arr[j]){
          int temp=arr[i];
          arr[i]=arr[j];
          arr[j]=temp ;
        }
      }
    }
    if(arr[0]+arr[1]>arr[2] || arr[1]+arr[2]>arr[3]){
      System.out.println("TRIANGLE");
    }
    else if(arr[0]+arr[1]==arr[2] || arr[1]+arr[2]==arr[3]){
      System.out.println("SEGMENT");
    }
    else System.out.println("IMPOSSIBLE");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var user : OclFile ; user := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := user.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (         var j : int ; j := 0 ; while j < arr->size() do ( (     if (arr[i+1] < arr[j+1]) then (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := arr[j+1] ; 
     arr[j+1] := temp ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (arr[0+1] + arr[1+1] > arr[2+1] or arr[1+1] + arr[2+1] > arr[3+1]) then (     OclFile["System.out"].println("TRIANGLE") ) else     if (arr[0+1] + arr[1+1] = arr[2+1] or arr[1+1] + arr[2+1] = arr[3+1]) then (     OclFile["System.out"].println("SEGMENT") ) else     OclFile["System.out"].println("IMPOSSIBLE") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Stack ;
class GFG {
  static void printPrevSmaller(int arr[],int n){
    Stack<Integer>S=new Stack<>();
    for(int i=0 ; i<n ; i++){
      while(! S.empty()&& S.peek()>=arr[i]){
        S.pop();
      }
      if(S.empty()){
        System.out.print("_,");
      }
      else {
        System.out.print(S.peek()+",");
      }
      S.push(arr[i]);
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,3,0,2,5 };
      int n=arr.length ;
      printPrevSmaller(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printPrevSmaller( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var S : Sequence(int) ; S := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     while (not(S->isEmpty()) & S->min() >= arr[i+1]) do (     S := S->front() ) ; 
     if (S->isEmpty()) then (     OclFile["System.out"].print("_,") ) else (     OclFile["System.out"].print(S->min() + ",") ) ;  
     S := S->append(arr[i+1]) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,0,2,5} ;
     var n : int ; n := arr->size() ;
     execute printPrevSmaller(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class GFG {
  static int maxSum(int arr[],int n){
    int res=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      int curr_sum=0 ;
      for(int j=0 ; j<n ; j++){
        int index=(i+j)% n ;
        curr_sum+=j*arr[index];
      }
      res=Math.max(res,curr_sum);
    }
    return res ;
  }
  public static void main(String args[]){
    int arr[]={
      8,3,1,2 };
      int n=arr.length ;
      System.out.println(maxSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := -2147483648 ;
         var i : int ; i := 0 ; while i < n do ( (     var curr_sum : int ; curr_sum := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     var index : int ; index := (i + j) mod n ;
     curr_sum := curr_sum+(j * arr[index+1]) )  ;     j := j + 1 ) ; 
     res := Set{res, curr_sum}->max() )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,3,1,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class a {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t,j,c ;
    long n ;
    t=sc.nextInt();
    for(j=1 ; j<=t ; j++){
      n=sc.nextLong();
      c=0 ;
      while(n>1){
        if(n % 2==0)n/=2 ;
        else if(n % 3==0)n=2*n/3 ;
        else if(n % 5==0)n=4*n/5 ;
        else break ;
        c++;
      }
      if(n==1)System.out.println(c);
      else System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ;
    var j : int ;
    var c : int ;
    var n : long ;
    t := sc.getCurrent()->toInteger() ; 
        j := 1 ; while j <= t do ( (     n := sc.getCurrent()->toLong() ; 
     c := 0 ; 
     while (n > 1) do (     if (n mod 2 = 0) then     n := n/(2) else     if (n mod 3 = 0) then     n := 2 * n / 3 else     if (n mod 5 = 0) then     n := 4 * n / 5 else     break ;  ;  ;  
     c := c + 1 ) ; 
     if (n = 1) then     OclFile["System.out"].println(c) ; else     OclFile["System.out"].println(-1) ; )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1176A_DivideIt {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=input.nextInt();
    while(test-->0){
      int counter=0 ;
      long num=input.nextLong();
      while(true){
        if(num % 2==0){
          num/=2 ;
        }
        else if(num % 3==0){
          num=2*num/3 ;
        }
        else if(num % 5==0){
          num=4*num/5 ;
        }
        else {
          break ;
        }
        counter++;
      }
      if(num==1){
        System.out.println(counter);
      }
      else {
        System.out.println("-1");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1176A_DivideIt {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := input.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var counter : int ; counter := 0 ;
     var num : long ; num := input.getCurrent()->toLong() ;
     while (true) do (     if (num mod 2 = 0) then (     num := num/(2) ) else     if (num mod 3 = 0) then (     num := 2 * num / 3 ) else     if (num mod 5 = 0) then (     num := 4 * num / 5 ) else (     break ) ;  ;  ;  
     counter := counter + 1 ) ; 
     if (num = 1) then (     OclFile["System.out"].println(counter) ) else (     OclFile["System.out"].println("-1") ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Set ;
public final class p125 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p125().run());
  }
  public String run(){
    Set<Integer>nums=new HashSet<>();
    for(int i=1 ; i<=10000 ; i++){
      int sum=i*i ;
      for(int j=i+1 ; ; j++){
        sum+=j*j ;
        if(sum>=100000000)break ;
        if(Library.isPalindrome(sum))nums.add(sum);
      }
    }
    long sum=0 ;
    for(int x : nums)sum+=x ;
    return Long.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p125 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p125.newp125().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var nums : Set(int) ; nums := Set{} ;
         var i : int ; i := 1 ; while i <= 10000 do ( (     var sum : int ; sum := i * i ;
         var j : int ; j := i + 1 ; while true do ( (     sum := sum+(j * j) ; 
     if (sum >= 100000000) then     break else skip ; 
     if (Library.isPalindrome(sum)) then     nums := nums->including(sum) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    for (x : nums) do (     sum := sum+(x) ;  ) ; 
    return ((sum) + "") 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner in ;
  public static void main(String[] args){
    in=new Scanner(System.in);
    StringBuilder s=new StringBuilder(in.next());
    StringBuilder t=new StringBuilder(s);
    System.out.println(t.append(s.reverse()));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var s : String ; s := StringLib.newString(in.getCurrent()) ;
     var t : String ; t := StringLib.newString(s) ;
     OclFile["System.out"].println(t + StringLib.newString(s->reverse())) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int firstFactorialDivisibleNumber(int x){
    int i=1 ;
    int fact=1 ;
    for(i=1 ; i<x ; i++){
      fact=fact*i ;
      if(fact % x==0)break ;
    }
    return i ;
  }
  public static void main(String[] args){
    int x=16 ;
    System.out.print(firstFactorialDivisibleNumber(x));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation firstFactorialDivisibleNumber( x : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 1 ;
     var fact : int ; fact := 1 ;
         i := 1 ; while i < x do ( (     fact := fact * i ; 
     if (fact mod x = 0) then     break else skip )  ;     i := i + 1 ) ; 
     return i );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 16 ;
     OclFile["System.out"].print(firstFactorialDivisibleNumber(x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class PellNumber {
  public static int pell(int n){
    if(n<=2)return n ;
    int a=1 ;
    int b=2 ;
    int c ;
    for(int i=3 ; i<=n ; i++){
      c=2*b+a ;
      a=b ;
      b=c ;
    }
    return b ;
  }
  public static void main(String args[]){
    int n=4 ;
    System.out.println(pell(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class PellNumber {
  static   operation pell( n : int) : int
  pre: true
  post: true
  activity: (     if (n <= 2) then     return n else skip ; 
     var a : int ; a := 1 ;
    var b : int ; b := 2 ;
    var c : int ;
        var i : int ; i := 3 ; while i <= n do ( (     c := 2 * b + a ; 
     a := b ; 
     b := c )  ;     i := i + 1 ) ; 
    return b 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(pell(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String args[]){
    FastReader sc=new FastReader();
    long x=sc.nextLong();
    long y=sc.nextLong();
    int n=sc.nextInt();
    long mo=1000000007l ;
    long res[]=new long[6];
    res[0]=(x+mo)% mo ;
    res[1]=(y+mo)% mo ;
    res[2]=(y-x+mo)% mo ;
    res[3]=(mo-x)% mo ;
    res[4]=(mo-y)% mo ;
    res[5]=(x-y+mo)% mo ;
    n-=1 ;
    n %=6 ;
    System.out.println((res[n]+mo)% mo);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var x : long ; x := sc.nextLong() ;
    var y : long ; y := sc.nextLong() ;
    var n : int ; n := sc.nextInt() ;
    var mo : long ; mo := 1000000007l ;
    var res : Sequence(long) ; res := Integer.subrange(1,6)->collect(0) ;
    res[0+1] := (x + mo) mod mo ; 
    res[1+1] := (y + mo) mod mo ; 
    res[2+1] := (y - x + mo) mod mo ; 
    res[3+1] := (mo - x) mod mo ; 
    res[4+1] := (mo - y) mod mo ; 
    res[5+1] := (x - y + mo) mod mo ; 
    n := n-(1) ; 
    n := n mod 6 ; 
    OclFile["System.out"].println((res[n+1] + mo) mod mo) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  private static long gcd(long a,long b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    String s=in.next();
    out.println(solve(s)? "Yes" : "No");
    out.flush();
  }
  private static boolean solve(String s){
    if("ABC".equals(s))return true ;
    int n=s.length(),step=0 ;
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      char c=s.charAt(i);
      sb.append(c);
      if(c=='A'){
        step=1 ;
      }
      else if(step==1 && c=='B')step=2 ;
      else if(step==2 && c=='C'){
        step=0 ;
        sb.setLength(sb.length()-3);
        sb.append('X');
      }
    }
    String ns=sb.toString();
    if(! ns.contains("X"))return false ;
    if(! ns.contains("B")){
      String r=ns.replace('X','B');
      if(solve(r)){
        return true ;
      }
    }
    if(! ns.contains("A")){
      String r=ns.replace('X','A');
      if(solve(r)){
        return true ;
      }
    }
    if(! ns.contains("C")){
      String r=ns.replace('X','C');
      if(solve(r)){
        return true ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : String ; s := in.getCurrent() ;
    skip ; 
    skip ; 
 );
  static   operation solve( s : String) : boolean
  pre: true
  post: true
  activity: (     if ("ABC" = s) then     return true else skip ; 
     var n : int ; n := s->size() ;
    var step : int ; step := 0 ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     var c : String ; c := s->at(i+1) ;
     sb := sb + StringLib.newString(c) ; 
     if (c = 'A') then (     step := 1 ) else     if (step = 1 & c = 'B') then     step := 2 else     if (step = 2 & c = 'C') then (     step := 0 ; 
     sb := sb.subrange(1,sb->size() - 3) ; 
     sb := sb + StringLib.newString('X') ) else skip ; ;  )  ;     i := i + 1 ) ; 
    var ns : String ; ns := sb+"" ;
    if (not(ns->includes("X"))) then     return false else skip ; 
    if (not(ns->includes("B"))) then (     var r : String ; r := ns.replace('X', 'B') ;
     if (solve(r)) then (     return true ) else skip ) else skip ; 
    if (not(ns->includes("A"))) then (     var r : String ; r := ns.replace('X', 'A') ;
     if (solve(r)) then (     return true ) else skip ) else skip ; 
    if (not(ns->includes("C"))) then (     var r : String ; r := ns.replace('X', 'C') ;
     if (solve(r)) then (     return true ) else skip ) else skip ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int xor_triplet(int arr[],int n){
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        for(int k=j ; k<n ; k++){
          int xor1=0,xor2=0 ;
          for(int x=i ; x<j ; x++){
            xor1 ^=arr[x];
          }
          for(int x=j ; x<=k ; x++){
            xor2 ^=arr[x];
          }
          if(xor1==xor2){
            ans++;
          }
        }
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5 };
      int n=arr.length ;
      System.out.println(xor_triplet(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation xor_triplet( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (         var k : int ; k := j ; while k < n do ( (     var xor1 : int ; xor1 := 0 ;
    var xor2 : int ; xor2 := 0 ;
         var x : int ; x := i ; while x < j do ( (     xor1 := MathLib.bitwiseXor(xor1,arr[x+1]) )  ;     x := x + 1 ) ; 
         var x : int ; x := j ; while x <= k do ( (     xor2 := MathLib.bitwiseXor(xor2,arr[x+1]) )  ;     x := x + 1 ) ; 
     if (xor1 = xor2) then (     ans := ans + 1 ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(xor_triplet(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class AA {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int p=0 ; p<t ; p++){
      int n=sc.nextInt();
      int[] ar=new int[n];
      for(int i=0 ; i<n ; i++)ar[i]=sc.nextInt();
      int[] dp=new int[n];
      int maxi=1 ;
      for(int i=1 ; i<=n ; i++){
        int q=get(dp,i,n,ar);
        maxi=Math.max(maxi,q);
      }
      System.out.println(maxi);
    }
    sc.close();
  }
  static int get(int[] dp,int i,int n,int[] ar){
    if(dp[i-1]!=0)return dp[i-1];
    long y=2*i ;
    int max=1 ;
    while(y<=n){
      if(ar[(int)y-1]>ar[i-1]){
        int q=1+get(dp,(int)y,n,ar);
        max=Math.max(q,max);
      }
      y+=i ;
    }
    return dp[i-1]=max ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class AA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var p : int ; p := 0 ; while p < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     ar[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
    var maxi : int ; maxi := 1 ;
        var i : int ; i := 1 ; while i <= n do ( (     var q : int ; q := get(dp, i, n, ar) ;
     maxi := Set{maxi, q}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(maxi) ; 
 )  ;     p := p + 1 ) ; 
     skip );
  static   operation get( dp : Sequence(int), i : int, n : int, ar : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (dp[i - 1+1] /= 0) then     return dp[i - 1+1] else skip ; 
     var y : long ; y := 2 * i ;
    var max : int ; max := 1 ;
    while (y <= n) do (     if (ar[y->oclAsType(int) - 1+1] > ar[i - 1+1]) then (     var q : int ; q := 1 + get(dp, y->oclAsType(int), n, ar) ;
     max := Set{q, max}->max() ) else skip ; 
     y := y+(i) ) ; 
    return dp[i - 1+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.List ;
public class OracAndModels {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t!=0){
      solve(br,pr);
      t--;
    }
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    String[] temp=br.readLine().split(" ");
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=Integer.parseInt(temp[i]);
    }
    List<Integer>[] factors=new ArrayList[n+2];
    for(int i=1 ; i<=n ; i++){
      factors[i]=new ArrayList<>();
      for(int j=1 ; j*j<=n ; j++){
        if(i % j==0){
          factors[i] .add(j);
          factors[i] .add(i/j);
        }
      }
    }
    int[] dp=new int[n];
    dp[0]=1 ;
    int res=1 ;
    for(int i=1 ; i<n ; i++){
      dp[i]=1 ;
      for(int j : factors[i+1]){
        if(nums[i]>nums[j-1]){
          dp[i]=Math.max(dp[i],dp[j-1]+1);
          res=Math.max(res,dp[i]);
        }
      }
    }
    pr.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class OracAndModels {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
    while (t /= 0) do (     execute solve(br, pr) ; 
     t := t - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := (temp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var factors : Sequence(Sequence(int)) ; factors := Integer.subrange(1,n + 2)->collect(null) ;
        var i : int ; i := 1 ; while i <= n do ( (     factors[i+1] := Sequence{} ; 
         var j : int ; j := 1 ; while j * j <= n do ( (     if (i mod j = 0) then (     factors[i+1]->excludes(j) ; 
     factors[i+1]->excludes(i / j) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
    dp[0+1] := 1 ; 
    var res : int ; res := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     dp[i+1] := 1 ; 
     for (j : factors[i + 1+1]) do ( (     if (nums[i+1] > nums[j - 1+1]) then (     dp[i+1] := Set{dp[i+1], dp[j - 1+1] + 1}->max() ; 
     res := Set{res, dp[i+1]}->max() ) else skip )  ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    int temp ;
    if(A>B){
      temp=A ;
      A=B ;
      B=temp ;
    }
    if(B>C){
      temp=B ;
      B=C ;
      C=temp ;
    }
    if(A>B){
      temp=A ;
      A=B ;
      B=temp ;
    }
    System.out.println(C*10+B+A);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var temp : int ;
    if (A > B) then (     temp := A ; 
     A := B ; 
     B := temp ) else skip ; 
    if (B > C) then (     temp := B ; 
     B := C ; 
     C := temp ) else skip ; 
    if (A > B) then (     temp := A ; 
     A := B ; 
     B := temp ) else skip ; 
    OclFile["System.out"].println(C * 10 + B + A) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.StringTokenizer ;
public class Main {
  private void solve(InputReader in,PrintWriter out){
    Integer[] arr=new Integer[3];
    for(int i=0 ; i<3 ; i++){
      arr[i]=in.nextInt();
    }
    Arrays.sort(arr,Comparator.reverseOrder());
    out.println(Integer.parseInt(""+arr[0]+arr[1]+"")+arr[2]);
  }
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    try(InputReader in=new InputReader(System.in);
    PrintWriter out=new PrintWriter(System.out)){
      solve(in,out);
    }
  }
  static class InputReader implements AutoCloseable {
    private BufferedReader reader ;
    private StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    @ Override public void close(){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,3)->collect(null) ;
         var i : int ; i := 0 ; while i < 3 do ( (     arr[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
     arr := OclComparator.sortWith(arr, Comparator.reverseOrder()) ; 
     out.println(("" + arr[0+1] + arr[1+1] + "")->toInteger() + arr[2+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var in : InputReader := InputReader.newInputReader(OclFile["System.in"]) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]) ;
 (     execute solve(in, out) ))  );
  static class InputReader implements AutoCloseable {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
      operation close() : void
  pre: true
  post: true
  activity: skip;
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int[] ABC=new int[3];
    ABC[0]=sc.nextInt();
    ABC[1]=sc.nextInt();
    ABC[2]=sc.nextInt();
    int max=0 ;
    int maxI=-1 ;
    for(int i=0 ; i<3 ; i++){
      if(max<ABC[i]){
        max=ABC[i];
        maxI=i ;
      }
    }
    int ans=0 ;
    for(int i=0 ; i<3 ; i++){
      if(i==maxI){
        ans+=ABC[i]*10 ;
      }
      else {
        ans+=ABC[i];
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ABC : Sequence(int) ; ABC := Integer.subrange(1,3)->collect(0) ;
    ABC[0+1] := sc.getCurrent()->toInteger() ; 
    ABC[1+1] := sc.getCurrent()->toInteger() ; 
    ABC[2+1] := sc.getCurrent()->toInteger() ; 
    var max : int ; max := 0 ;
    var maxI : int ; maxI := -1 ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (max < ABC[i+1]) then (     max := ABC[i+1] ; 
     maxI := i ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (i = maxI) then (     ans := ans+(ABC[i+1] * 10) ) else (     ans := ans+(ABC[i+1]) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    final int[] num=new int[3];
    num[0]=sc.nextInt();
    num[1]=sc.nextInt();
    num[2]=sc.nextInt();
    int[] num2=Arrays.stream(num).sorted().toArray();
    System.out.println(num2[0]+num2[1]+num2[2]*10);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : Sequence(int) ; num := Integer.subrange(1,3)->collect(0) ;
    num[0+1] := sc.getCurrent()->toInteger() ; 
    num[1+1] := sc.getCurrent()->toInteger() ; 
    num[2+1] := sc.getCurrent()->toInteger() ; 
    var num2 : Sequence(int) ; num2 := stream(num)->sort()->asSequence() ;
    OclFile["System.out"].println(num2[0+1] + num2[1+1] + num2[2+1] * 10) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String[] scores=new String[3];
    for(int i=0 ; i<3 ; i++){
      scores[i]=sc.next();
    }
    Arrays.sort(scores,Comparator.reverseOrder());
    String big=scores[0]+scores[1];
    String small=scores[2];
    System.out.println(Integer.parseInt(big)+Integer.parseInt(small));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var scores : Sequence(String) ; scores := Integer.subrange(1,3)->collect(null) ;
        var i : int ; i := 0 ; while i < 3 do ( (     scores[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    scores := OclComparator.sortWith(scores, Comparator.reverseOrder()) ; 
    var big : String ; big := scores[0+1] + scores[1+1] ;
    var small : String ; small := scores[2+1] ;
    OclFile["System.out"].println((big)->toInteger() + (small)->toInteger()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Codefroces801B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s1=in.nextLine();
    String itog=in.nextLine();
    int i=0 ;
    boolean p=true ;
    StringBuffer s2=new StringBuffer("");
    while(i<itog.length()){
      if(itog.charAt(i)>s1.charAt(i)){
        p=false ;
        break ;
      }
      else {
        if(itog.charAt(i)==s1.charAt(i)){
          s2.append(itog.charAt(i));
        }
        else {
          s2.append(itog.charAt(i));
        }
      }
      i++;
    }
    if(! p){
      System.out.println(-1);
    }
    else {
      System.out.println(s2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codefroces801B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := in.nextLine() ;
    var itog : String ; itog := in.nextLine() ;
    var i : int ; i := 0 ;
    var p : boolean ; p := true ;
    var s2 : String ; s2 := StringLib.newString("") ;
    while (i < itog->size()) do (     if (itog->at(i+1) > s1->at(i+1)) then (     p := false ; 
     break ) else (     if (itog->at(i+1) = s1->at(i+1)) then (     s2 := s2 + StringLib.newString(itog->at(i+1)) ) else (     s2 := s2 + StringLib.newString(itog->at(i+1)) ) ) ;  
     i := i + 1 ) ; 
    if (not(p)) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(s2) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder sb=new StringBuilder(sc.next());
    for(int i=sb.length()-1 ; i>=0 ; i--)sb.append(sb.charAt(i));
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString(sc.getCurrent()) ;
         var i : int ; i := sb->size() - 1 ; while i >= 0 do (     sb := sb + StringLib.newString(sb->at(i+1)) ;  ;     i := i - 1 ) ; 
     OclFile["System.out"].print(sb) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeNinetySeven {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int m=input.nextInt();
    int n=input.nextInt();
    char[][] arrayOne=new char[m][n];
    for(int i=0 ; i<m ; i++){
      String data="" ;
      if(input.hasNext()){
        data=input.next();
      }
      else {
        break ;
      }
      for(int j=0 ; j<n ; j++){
        arrayOne[i][j]=data.charAt(j);
      }
    }
    int sumr=0 ;
    int sumc=0 ;
    int count1=0 ;
    int count2=0 ;
    for(int i=0 ; i<m ; i++){
      for(int j=0 ; j<n ; j++){
        if(arrayOne[i][j]==66){
          sumr+=i+1 ;
          count1++;
        }
      }
    }
    for(int i=0 ; i<m ; i++){
      for(int j=0 ; j<n ; j++){
        if(arrayOne[i][j]==66){
          sumc+=j+1 ;
          count2++;
        }
      }
    }
    System.out.println(sumr/count1+" "+sumc/count2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeNinetySeven {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := input.getCurrent()->toInteger() ;
    var n : int ; n := input.getCurrent()->toInteger() ;
    var arrayOne : Sequence(Sequence(String)) ; arrayOne := Integer.subrange(1,m)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (     var data : String ; data := "" ;
     if (input.hasNext()) then (     data := input.getCurrent() ) else (     break ) ;  
         var j : int ; j := 0 ; while j < n do ( (     arrayOne[i+1][j+1] := data->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sumr : int ; sumr := 0 ;
    var sumc : int ; sumc := 0 ;
    var count1 : int ; count1 := 0 ;
    var count2 : int ; count2 := 0 ;
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j < n do ( (     if (arrayOne[i+1][j+1] = 66) then (     sumr := sumr+(i + 1) ; 
     count1 := count1 + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j < n do ( (     if (arrayOne[i+1][j+1] = 66) then (     sumc := sumc+(j + 1) ; 
     count2 := count2 + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sumr / count1 + " " + sumc / count2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class A {
  static int calc(int[] q){
    int res=1234567 ;
    for(int a=0 ; a<=100 ; a++){
      int cur=0 ;
      for(int i=0 ; i<q.length ; i++)cur+=Math.abs(q[i]-a);
      res=Math.min(res,cur);
    }
    return res ;
  }
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int numTests=sc.nextInt();
    for(int test=1 ; test<=numTests ; test++){
      int n=sc.nextInt();
      String must="" ;
      int[][] q=new int[111][n];
      for(int i=0 ; i<n ; i++){
        String s=sc.next()+"?" ;
        String t="" ;
        int ind=0 ;
        char c='?' ;
        int cnt=1 ;
        for(int j=0 ; j<s.length(); j++){
          if(s.charAt(j)==c)cnt++;
          else {
            t+=c ;
            q[ind][i]=cnt ;
            cnt=0 ;
            ind++;
            c=s.charAt(j);
          }
        }
        if(i==0)must=t ;
        else if(! must.equals(t))must="?" ;
      }
      String lost="Fegla Won" ;
      if(must.equals("?")){
        System.out.println("Case #"+test+": "+lost);
      }
      else {
        int res=0 ;
        for(int i=0 ; i<111 ; i++)res+=calc(q[i]);
        System.out.println("Case #"+test+": "+res);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation calc( q : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1234567 ;
         var a : int ; a := 0 ; while a <= 100 do ( (     var cur : int ; cur := 0 ;
         var i : int ; i := 0 ; while i < q->size() do (     cur := cur+(if q[i+1] - a < 0 then -(q[i+1] - a) else q[i+1] - a endif) ;  ;     i := i + 1 ) ; 
     res := Set{res, cur}->min() )  ;     a := a + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numTests : int ; numTests := sc.getCurrent()->toInteger() ;
         var test : int ; test := 1 ; while test <= numTests do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var must : String ; must := "" ;
    var q : Sequence(Sequence(int)) ; q := Integer.subrange(1,111)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() + "?" ;
     var t : String ; t := "" ;
    var ind : int ; ind := 0 ;
    var c : String ; c := '?' ;
    var cnt : int ; cnt := 1 ;
        var j : int ; j := 0 ; while j < s->size() do ( (     if (s->at(j+1) = c) then     cnt := cnt + 1 ; else (     t := t+(c) ; 
     q[ind+1][i+1] := cnt ; 
    cnt := 0 ; 
    ind := ind + 1 ; 
    c := s->at(j+1) ; 
 ) )  ;     j := j + 1 ) ; 
    if (i = 0) then     must := t else     if (not(must = t)) then     must := "?" ; else skip ; ;  
 )  ;     i := i + 1 ) ; 
    var lost : String ; lost := "Fegla Won" ;
    if (must = "?") then (     OclFile["System.out"].println("Case #" + test + ": " + lost) ) else (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < 111 do (     res := res+(calc(q[i+1])) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Case #" + test + ": " + res) ) ;  
 )  ;     test := test + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int T=sc.nextInt();
    for(int i=1 ; i<=T ; ++i){
      System.out.printf("Case #%d: %s\n",i,solve());
    }
  }
  static String solve(){
    int N=sc.nextInt();
    String[] str=new String[N];
    for(int i=0 ; i<N ; ++i){
      str[i]=sc.next();
    }
    int[][] count=new int[N][101];
    int[] pos=new int[N];
    for(int i=0 ; pos[0]<str[0] .length(); ++i){
      char c=str[0] .charAt(pos[0]);
      for(int j=0 ; j<N ; ++j){
        if(pos[j]>=str[j] .length()|| str[j] .charAt(pos[j])!=c){
          return "Fegla Won" ;
        }
        while(pos[j]<str[j] .length()&& str[j] .charAt(pos[j])==c){
++pos[j];
++count[j][i];
        }
      }
    }
    for(int i=0 ; i<N ; ++i){
      if(pos[i]!=str[i] .length()){
        return "Fegla Won" ;
      }
    }
    int ans=0 ;
    for(int i=0 ; count[0][i]>0 ; ++i){
      int min=1<<30 ;
      for(int j=1 ; j<=100 ; ++j){
        int sum=0 ;
        for(int k=0 ; k<N ; ++k){
          sum+=Math.abs(count[k][i]-j);
        }
        min=Math.min(min,sum);
      }
      ans+=min ;
    }
    return ""+ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= T do ( (     OclFile["System.out"].printf("Case #%d: %s\n", i, solve()) )  ;     i := i + 1 ) );
  static   operation solve() : String
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var str : Sequence(String) ; str := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     str[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    var count : Sequence(Sequence(int)) ; count := Integer.subrange(1,N)->collect(Integer.subrange(1,101)->collect(0)) ;
    var pos : Sequence(int) ; pos := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while pos[0+1] < str[0+1]->size() do ( (     var c : String ; c := str[0+1]->at(pos[0+1]+1) ;
         var j : int ; j := 0 ; while j < N do ( (     if (pos[j+1] >= str[j+1]->size() or str[j+1]->at(pos[j+1]+1) /= c) then (     return "Fegla Won" ) else skip ; 
     while (pos[j+1] < str[j+1]->size() & str[j+1]->at(pos[j+1]+1) = c) do (     pos[j+1] := pos[j+1] + 1 ; 
     count[j+1][i+1] := count[j+1][i+1] + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (pos[i+1] /= str[i+1]->size()) then (     return "Fegla Won" ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while count[0+1][i+1] > 0 do ( (     var min : int ; min := (1*(2->pow(30)))->oclAsType(long) ;
         var j : int ; j := 1 ; while j <= 100 do ( (     var sum : int ; sum := 0 ;
         var k : int ; k := 0 ; while k < N do ( (     sum := sum+(if count[k+1][i+1] - (j)->char2byte() < 0 then -(count[k+1][i+1] - (j)->char2byte()) else count[k+1][i+1] - (j)->char2byte() endif) )  ;     k := k + 1 ) ; 
     min := Set{min, sum}->min() )  ;     j := j + 1 ) ; 
     ans := ans+(min) )  ;     i := i + 1 ) ; 
    return "" + ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x=1 ;
    int y=n ;
    for(int i=(int)Math.sqrt(n); i>=1 ; i--){
      if(n % i==0){
        x=i ;
        y=n/i ;
        break ;
      }
    }
    System.out.println(x+" "+y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := 1 ;
    var y : int ; y := n ;
        var i : int ; i := (n)->sqrt()->oclAsType(int) ; while i >= 1 do ( (     if (n mod i = 0) then (     x := i ; 
     y := n / i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(x + " " + y) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class hef {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int a1=0,a2=0,diff=Integer.MAX_VALUE ;
    for(int i=1 ; i*i<=n ; i++){
      if(n % i==0){
        if((n/i)-i<diff){
          diff=n/i-i ;
          a1=i ;
          a2=n/i ;
        }
      }
    }
    System.out.println(a1+" "+a2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class hef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var a1 : int ; a1 := 0 ;
    var a2 : int ; a2 := 0 ;
    var diff : int ; diff := 2147483647 ;
        var i : int ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     if ((n / i) - i < diff) then (     diff := n / i - i ; 
     a1 := i ; 
     a2 := n / i ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a1 + " " + a2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.rmi.server.RemoteServer ;
import java.rmi.server.SocketSecurityException ;
import java.security.cert.CollectionCertStoreParameters ;
import java.util.*;
import javax.xml.transform.SourceLocator ;
public class A_Display_Size {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int sqrt=(int)Math.sqrt(n);
    for(int i=sqrt ; i>=1 ; i--){
      if(n % i==0){
        System.out.println((i)+" "+(n/i));
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Display_Size {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
     var sqrt : int ; sqrt := (n)->sqrt()->oclAsType(int) ;
         var i : int ; i := sqrt ; while i >= 1 do ( (     if (n mod i = 0) then (     OclFile["System.out"].println((i) + " " + (n / i)) ; 
     break ) else skip )  ;     i := i - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      String s=in.next();
      int cnt=0 ;
      boolean ch=false ;
      for(int i=0 ; i<n ; i++){
        if(s.charAt(i)=='8'){
          cnt=i ;
          ch=true ;
          break ;
        }
      }
      if(ch)System.out.println((n-cnt>=11)? "YES" : "NO");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var s : String ; s := in.getCurrent() ;
    var cnt : int ; cnt := 0 ;
    var ch : boolean ; ch := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = '8') then (     cnt := i ; 
     ch := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (ch) then     OclFile["System.out"].println(if (n - (cnt)->char2byte() >= 11) then "YES" else "NO" endif) else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class _1167A_TelephoNumber {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=input.nextInt();
    while(test-->0){
      int len=input.nextInt();
      String str=input.next();
      if(len<11){
        System.out.println("NO");
        continue ;
      }
      str=str.substring(0,len-10);
      if(str.contains("8")){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1167A_TelephoNumber {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := input.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var len : int ; len := input.getCurrent()->toInteger() ;
     var str : String ; str := input.getCurrent() ;
    if (len < 11) then (     OclFile["System.out"].println("NO") ; 
     continue ) else skip ; 
    str := str.subrange(0+1,len - 10) ; 
    if (str->includes("8")) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maximumPoints(int arr[],int n,int k,int i){
    int start ;
    if(k>i)start=0 ;
    else start=i-k ;
    int res=0 ;
    for(int j=start ; j<=start+k && j<n ; j++)res+=arr[j];
    int curr_sum=res ;
    for(int j=start+k+1 ; j<n && j<=i+k ; j++){
      curr_sum+=arr[j]-arr[j-k-1];
      res=Math.max(res,curr_sum);
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      5,6,4,2,8,3,1 };
      int k=3,i=3 ;
      int n=arr.length ;
      System.out.print("Maximum points : "+maximumPoints(arr,n,k-1,i));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maximumPoints( arr : Sequence(int), n : int, k : int, i : int) : int
  pre: true
  post: true
  activity: (     var start : int ;
     if (k > i) then     start := 0 else     start := i - k ; ;  
    var res : int ; res := 0 ;
        var j : int ; j := start ; while j <= start + k & j < n do (     res := res+(arr[j+1]) ;  ;     j := j + 1 ) ; 
    var curr_sum : int ; curr_sum := res ;
        var j : int ; j := start + k + 1 ; while j < n & j <= i + k do ( (     curr_sum := curr_sum+(arr[j+1] - arr[j - k - 1+1]) ; 
     res := Set{res, curr_sum}->max() )  ;     j := j + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,6,4,2,8,3,1} ;
     var k : int ; k := 3 ;
    var i : int ; i := 3 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print("Maximum points : " + maximumPoints(arr, n, k - 1, i)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minCost(char[] str1,char[] str2,int n){
    int cost=0 ;
    for(int i=0 ; i<n ; i++){
      if(str1[i]!=str2[i]){
        if(i<n-1 && str1[i+1]!=str2[i+1]){
          swap(str1,i,i+1);
          cost++;
        }
        else {
          cost++;
        }
      }
    }
    return cost ;
  }
  static void swap(char[] arr,int i,int j){
    char temp=arr[i];
    arr[i]=arr[j];
    arr[j]=temp ;
  }
  public static void main(String[] args){
    String str1="abb",str2="bba" ;
    int n=str1.length();
    System.out.println(minCost(str1.toCharArray(),str2.toCharArray(),n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minCost( str1 : Sequence(String), str2 : Sequence(String), n : int) : int
  pre: true
  post: true
  activity: (     var cost : int ; cost := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (str1[i+1] /= str2[i+1]) then (     if (i < n - 1 & str1[i + 1+1] /= str2[i + 1+1]) then (     execute swap(str1, i, i + 1) ; 
     cost := cost + 1 ) else (     cost := cost + 1 ) ) else skip )  ;     i := i + 1 ) ; 
     return cost );
  static   operation swap( arr : Sequence(String), i : int, j : int) : void
  pre: true
  post: true
  activity: (     var temp : String ; temp := arr[i+1] ;
     arr[i+1] := arr[j+1] ; 
     arr[j+1] := temp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "abb" ;
    var str2 : String ; str2 := "bba" ;
     var n : int ; n := str1->size() ;
     OclFile["System.out"].println(minCost(str1->characters(), str2->characters(), n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void removeSpecialCharacter(String s){
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)<'A' || s.charAt(i)>'Z' && s.charAt(i)<'a' || s.charAt(i)>'z'){
        s=s.substring(0,i)+s.substring(i+1);
        i--;
      }
    }
    System.out.print(s);
  }
  public static void main(String[] args){
    String s="$Gee*k;s..fo,r'Ge^eks?" ;
    removeSpecialCharacter(s);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation removeSpecialCharacter( s : String) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) < 'A' or s->at(i+1) > 'Z' & s->at(i+1) < 'a' or s->at(i+1) > 'z') then (     s := s.subrange(0+1,i) + s.subrange(i + 1+1,i + 1) ; 
     i := i - 1 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "$Gee*k;s..fo,r'Ge^eks?" ;
     execute removeSpecialCharacter(s) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int vis[]=new int[1000];
  public static void main(String args[]){
    Scanner input=new Scanner(System.in);
    int n,A,B,C,T ;
    n=input.nextInt();
    A=input.nextInt();
    B=input.nextInt();
    C=input.nextInt();
    T=input.nextInt();
    for(int i=1 ; i<=T ; i++)vis[i]=0 ;
    for(int i=1 ; i<=n ; i++){
      int x=input.nextInt();
      vis[x]++;
    }
    if(C<=B){
      System.out.println(n*A);
    }
    else {
      int get=n*A ;
      int cost=0 ;
      int num=0 ;
      for(int i=1 ; i<=T ; i++){
        get+=num*C ;
        cost-=num*B ;
        num+=vis[i];
      }
      System.out.println(get+cost);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute vis : int := Integer.subrange(1,1000)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var A : int ;
    var B : int ;
    var C : int ;
    var T : int ;
    n := input.getCurrent()->toInteger() ; 
    A := input.getCurrent()->toInteger() ; 
    B := input.getCurrent()->toInteger() ; 
    C := input.getCurrent()->toInteger() ; 
    T := input.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i <= T do (     vis[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     var x : int ; x := input.getCurrent()->toInteger() ;
     vis[x+1] := vis[x+1] + 1 )  ;     i := i + 1 ) ; 
    if (C <= B) then (     OclFile["System.out"].println(n * A) ) else (     var get : int ; get := n * A ;
     var cost : int ; cost := 0 ;
    var num : int ; num := 0 ;
        var i : int ; i := 1 ; while i <= T do ( (     get := get+(num * C) ; 
     cost := cost-(num * B) ; 
     num := num+(vis[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(get + cost) ; 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Dring {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int number=in.nextByte();
    int[] drink=new int[number];
    int total=0 ;
    for(int i=0 ; i<number ; i++){
      drink[i]=in.nextInt();
      total+=drink[i];
    }
    System.out.println((total/(number*100.0))*100);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Dring {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := in.nextByte() ;
    var drink : Sequence(int) ; drink := Integer.subrange(1,number)->collect(0) ;
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < number do ( (     drink[i+1] := in.getCurrent()->toInteger() ; 
     total := total+(drink[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((total / (number * 100.0)) * 100) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test {
  public static void main(String[] args){
    int x ;
    int y ;
    int z ;
    Scanner sc=new Scanner(System.in);
    x=sc.nextInt();
    y=sc.nextInt();
    z=sc.nextInt();
    int blue=0 ;
    int purple=0 ;
    int black=0 ;
    blue=sc.nextInt();
    purple=sc.nextInt();
    black=sc.nextInt();
    int sum=black+blue+purple ;
    if(blue<x || blue-x+purple<y || sum-x-y<z)System.out.printf("NO");
    else System.out.printf("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ;
     var y : int ;
    var z : int ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    x := sc.getCurrent()->toInteger() ; 
    y := sc.getCurrent()->toInteger() ; 
    z := sc.getCurrent()->toInteger() ; 
    var blue : int ; blue := 0 ;
    var purple : int ; purple := 0 ;
    var black : int ; black := 0 ;
    blue := sc.getCurrent()->toInteger() ; 
    purple := sc.getCurrent()->toInteger() ; 
    black := sc.getCurrent()->toInteger() ; 
    var sum : int ; sum := black + blue + purple ;
    if (blue < x or blue - x + purple < y or sum - x - y < z) then     OclFile["System.out"].printf("NO") else     OclFile["System.out"].printf("YES") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class P1114A {
  public static void main(String[] args)throws IOException {
    BufferedReader io=new BufferedReader(new InputStreamReader(System.in));
    String[] xyz=io.readLine().split(" ");
    Integer x=Integer.valueOf(xyz[0]);
    Integer y=Integer.valueOf(xyz[1]);
    Integer z=Integer.valueOf(xyz[2]);
    String[] abc=io.readLine().split(" ");
    Integer a=Integer.valueOf(abc[0]);
    Integer b=Integer.valueOf(abc[1]);
    Integer c=Integer.valueOf(abc[2]);
    boolean flag=true ;
    if(a.compareTo(x)<0){
      flag=false ;
    }
    else {
      a=a-x ;
      if(a+b-y<0){
        flag=false ;
      }
      else {
        if(a.compareTo(y)>0){
          a=a-y ;
        }
        else {
          b=b-(y-a);
          a=0 ;
        }
        if(z-(a+b+c)>0){
          flag=false ;
        }
      }
    }
    if(flag){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P1114A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var xyz : Sequence(String) ; xyz := io.readLine()->split(" ") ;
    var x : int ; x := (xyz[0+1])->toInteger() ;
    var y : int ; y := (xyz[1+1])->toInteger() ;
    var z : int ; z := (xyz[2+1])->toInteger() ;
    var abc : Sequence(String) ; abc := io.readLine()->split(" ") ;
    var a : int ; a := (abc[0+1])->toInteger() ;
    var b : int ; b := (abc[1+1])->toInteger() ;
    var c : int ; c := (abc[2+1])->toInteger() ;
    var flag : boolean ; flag := true ;
    if (a->compareTo(x) < 0) then (     flag := false ) else (     a := a - x ; 
     if (a + b - y < 0) then (     flag := false ) else (     if (a->compareTo(y) > 0) then (     a := a - y ) else (     b := b - (y - a) ; 
     a := 0 ) ;  
     if (z - (a + b + c) > 0) then (     flag := false ) else skip ) ) ;  
    if (flag) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class GotAnyGrapes {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int x=sc.nextInt();
    int y=sc.nextInt();
    int z=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int total=a+b+c ;
    if(a>=x){
      total-=x ;
      a-=x ;
      if(a+b>=y){
        total-=y ;
        if(total>=z){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
      else {
        System.out.println("NO");
      }
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GotAnyGrapes {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var z : int ; z := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var total : int ; total := a + b + c ;
    if (a >= x) then (     total := total-(x) ; 
     a := a-(x) ; 
     if (a + b >= y) then (     total := total-(y) ; 
     if (total >= z) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else (     OclFile["System.out"].println("NO") ) ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1114A_GotAnyGrapes {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int x=input.nextInt();
    int y=input.nextInt();
    int z=input.nextInt();
    int a=input.nextInt();
    int b=input.nextInt();
    int c=input.nextInt();
    a-=x ;
    boolean adrew=a>=0 ;
    b+=a ;
    b-=y ;
    boolean demitry=b>=0 ;
    c+=b ;
    c-=z ;
    boolean michal=c>=0 ;
    if(adrew && demitry && michal){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1114A_GotAnyGrapes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := input.getCurrent()->toInteger() ;
    var y : int ; y := input.getCurrent()->toInteger() ;
    var z : int ; z := input.getCurrent()->toInteger() ;
    var a : int ; a := input.getCurrent()->toInteger() ;
    var b : int ; b := input.getCurrent()->toInteger() ;
    var c : int ; c := input.getCurrent()->toInteger() ;
    a := a-(x) ; 
    var adrew : boolean ; adrew := a >= 0 ;
    b := b+(a) ; 
    b := b-(y) ; 
    var demitry : boolean ; demitry := b >= 0 ;
    c := c+(b) ; 
    c := c-(z) ; 
    var michal : boolean ; michal := c >= 0 ;
    if (adrew & demitry & michal) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int nthTerm(int n){
    return(n*n)+(n*n*n);
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.print(nthTerm(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nthTerm( n : int) : int
  pre: true
  post: true
  activity: (     return (n * n) + (n * n * n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].print(nthTerm(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int gcdFunc(int a,int b){
    if(b==0)return a ;
    return gcdFunc(b,a % b);
  }
  static int findMinimumElements(int[] a,int n){
    int[] b=new int[n-1];
    for(int i=1 ; i<n ; i++){
      b[i-1]=a[i]-a[i-1];
    }
    int gcd=b[0];
    for(int i=0 ; i<n-1 ; i++){
      gcd=gcdFunc(gcd,b[i]);
    }
    int ans=0 ;
    for(int i=0 ; i<n-1 ; i++){
      ans+=(b[i]/gcd)-1 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr1[]={
      1,6,8,10,14,16 };
      int n1=arr1.length ;
      System.out.print(findMinimumElements(arr1,n1)+"\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gcdFunc( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcdFunc(b, a mod b) );
  static   operation findMinimumElements( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var b : Sequence(int) ; b := Integer.subrange(1,n - 1)->collect(0) ;
         var i : int ; i := 1 ; while i < n do ( (     b[i - 1+1] := a[i+1] - a[i - 1+1] )  ;     i := i + 1 ) ; 
    var gcd : int ; gcd := b[0+1] ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     gcd := gcdFunc(gcd, b[i+1]) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     ans := ans+((b[i+1] / gcd) - 1) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{1,6,8,10,14,16} ;
     var n1 : int ; n1 := arr1->size() ;
     OclFile["System.out"].print(findMinimumElements(arr1, n1) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean strmatch(char txt[],char pat[],int n,int m){
    if(m==0)return(n==0);
    int i=0,j=0,index_txt=-1,index_pat=-1 ;
    while(i<n){
      if(j<m && txt[i]==pat[j]){
        i++;
        j++;
      }
      else if(j<m && pat[j]=='?'){
        i++;
        j++;
      }
      else if(j<m && pat[j]=='*'){
        index_txt=i ;
        index_pat=j ;
        j++;
      }
      else if(index_pat!=-1){
        j=index_pat+1 ;
        i=index_txt+1 ;
        index_txt++;
      }
      else {
        return false ;
      }
    }
    while(j<m && pat[j]=='*'){
      j++;
    }
    if(j==m){
      return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    char str[]="baaabab".toCharArray();
    char pattern[]="*****ba*****ab".toCharArray();
    if(strmatch(str,pattern,str.length,pattern.length))System.out.println("Yes");
    else System.out.println("No");
    char pattern2[]="a*****ab".toCharArray();
    if(strmatch(str,pattern2,str.length,pattern2.length))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation strmatch( txt : Sequence(String), pat : Sequence(String), n : int, m : int) : boolean
  pre: true
  post: true
  activity: (     if (m = 0) then     return (n = 0) else skip ; 
     var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    var index_txt : int ; index_txt := -1 ;
    var index_pat : int ; index_pat := -1 ;
    while (i < n) do (     if (j < m & txt[i+1] = pat[j+1]) then (     i := i + 1 ; 
     j := j + 1 ) else     if (j < m & pat[j+1] = '?') then (     i := i + 1 ; 
     j := j + 1 ) else     if (j < m & pat[j+1] = '*') then (     index_txt := i ; 
     index_pat := j ; 
     j := j + 1 ) else     if (index_pat /= -1) then (     j := index_pat + 1 ; 
     i := index_txt + 1 ; 
     index_txt := index_txt + 1 ) else (     return false ) ;  ;  ;  ) ; 
    while (j < m & pat[j+1] = '*') do (     j := j + 1 ) ; 
    if (j = m) then (     return true ) else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := "baaabab"->characters() ;
     var pattern : Sequence(String) ; pattern := "*****ba*****ab"->characters() ;
    if (strmatch(str, pattern, str->size(), pattern->size())) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
    var pattern2 : Sequence(String) ; pattern2 := "a*****ab"->characters() ;
    if (strmatch(str, pattern2, str->size(), pattern2->size())) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  static long pow(long a,long b){
    if(b==0){
      return 1 ;
    }
    long ans=0L ;
    if(b % 2==0){
      long val=pow(a,b/2);
      ans+=val*val ;
    }
    else {
      long val=pow(a,b/2);
      ans+=val*val*2 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if((n*m)% 3==0){
        System.out.println((n*m)/3);
      }
      else {
        System.out.println(((n*m)/3)+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation pow( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return 1 ) else skip ; 
     var ans : long ; ans := 0L ;
     if (b mod 2 = 0) then (     var val : long ; val := pow(a, b / 2) ;
     ans := ans+(val * val) ) else (     var val : long ; val := pow(a, b / 2) ;
     ans := ans+(val * val * 2) ) ;  
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     if ((n * m) mod 3 = 0) then (     OclFile["System.out"].println((n * m) / 3) ) else (     OclFile["System.out"].println(((n * m) / 3) + 1) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int m=sc.nextInt();
      System.out.println(solve(n,m));
    }
    sc.close();
  }
  static int solve(int n,int m){
    return(n*m+2)/3 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(n, m)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( n : int, m : int) : int
  pre: true
  post: true
  activity: (     return (n * m + 2) / 3 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class trailzero {
  public static void main(String[] args)throws Throwable {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    int T=sc.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    if(B>C){
      System.out.println(n*A);
    }
    else {
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        sum+=T-a[i];
      }
      int sum2=sum*B ;
      sum=sum*C ;
      sum2=n*A-sum2 ;
      System.out.println(sum+sum2);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class trailzero {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (B > C) then (     OclFile["System.out"].println(n * A) ) else (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(T - a[i+1]) )  ;     i := i + 1 ) ; 
    var sum2 : int ; sum2 := sum * B ;
    sum := sum * C ; 
    sum2 := n * A - sum2 ; 
    OclFile["System.out"].println(sum + sum2) ; 
 ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void restoreSortedArray(int arr[],int n){
    for(int i=0 ; i<n ; i++){
      if(arr[i]>arr[i+1]){
        reverse(arr,0,i);
        reverse(arr,i+1,n);
        reverse(arr,0,n);
      }
    }
  }
  static void reverse(int[] arr,int i,int j){
    int temp ;
    while(i<j){
      temp=arr[i];
      arr[i]=arr[j];
      arr[j]=temp ;
      i++;
      j--;
    }
  }
  static void printArray(int arr[],int size){
    for(int i=0 ; i<size ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String[] args){
    int arr[]={
      3,4,5,1,2 };
      int n=arr.length ;
      restoreSortedArray(arr,n-1);
      printArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation restoreSortedArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] > arr[i + 1+1]) then (     execute reverse(arr, 0, i) ; 
     execute reverse(arr, i + 1, n) ; 
     execute reverse(arr, 0, n) ) else skip )  ;     i := i + 1 ) );
  static   operation reverse( arr : Sequence(int), i : int, j : int) : void
  pre: true
  post: true
  activity: (     var temp : int ;
     while (i < j) do (     temp := arr[i+1] ; 
     arr[i+1] := arr[j+1] ; 
    arr[j+1] := temp ; 
    i := i + 1 ; 
    j := j - 1 ; 
 ) );
  static   operation printArray( arr : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < size do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,4,5,1,2} ;
     var n : int ; n := arr->size() ;
     execute restoreSortedArray(arr, n - 1) ; 
     execute printArray(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    FastReader in=new FastReader();
    int N=in.nextInt();
    double sum=0 ;
    for(int i=0 ; i<N ; i++){
      sum+=in.nextInt();
    }
    sum=sum/N ;
    System.out.println(sum);
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  String next(){
    try {
      while(st==null || ! st.hasMoreElements()){
        st=new StringTokenizer(br.readLine());
      }
      return st.nextToken();
    }
    catch(Exception e){
      throw new Error(e.getMessage());
    }
  }
  int nextInt(){
    return Integer.parseInt(next());
  }
  long nextLong(){
    return Long.parseLong(next());
  }
  double nextDouble(){
    return Double.parseDouble(next());
  }
  String nextLine(){
    try {
      return st.hasMoreTokens()? st.nextToken("\n"): br.readLine();
    }
    catch(Exception e){
      throw new Error(e.getMessage());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var N : int ; N := in.nextInt() ;
    var sum : double ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     sum := sum+(in.nextInt()) )  ;     i := i + 1 ) ; 
    sum := sum / N ; 
    OclFile["System.out"].println(sum) ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() )   catch (e : ProgramException) do (     error SystemException(e.getMessage()) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return if st.hasNext() then st.nextToken("\n") else br.readLine() endif )   catch (e : ProgramException) do (     error SystemException(e.getMessage()) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().solve(new Scanner(System.in));
  }
  public void solve(Scanner sc){
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    int c=Integer.parseInt(sc.next());
    int div=b/a ;
    if(div>=c){
      System.out.println(c);
    }
    else {
      System.out.println(div);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := (sc.next())->toInteger() ;
     var b : int ; b := (sc.next())->toInteger() ;
    var c : int ; c := (sc.next())->toInteger() ;
    var div : int ; div := b / a ;
    if (div >= c) then (     OclFile["System.out"].println(c) ) else (     OclFile["System.out"].println(div) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner s=new Scanner(System.in);
    int a=s.nextInt(),b=s.nextInt(),c=s.nextInt();
    System.out.println(Math.min(b/a,c));
  }
}
class Scanner {
  StringTokenizer st ;
  BufferedReader br ;
  public Scanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public String nextLine()throws IOException {
    return br.readLine();
  }
  public double nextDouble()throws IOException {
    String x=next();
    StringBuilder sb=new StringBuilder("0");
    double res=0,f=1 ;
    boolean dec=false,neg=false ;
    int start=0 ;
    if(x.charAt(0)=='-'){
      neg=true ;
      start++;
    }
    for(int i=start ; i<x.length(); i++)if(x.charAt(i)=='.'){
      res=Long.parseLong(sb.toString());
      sb=new StringBuilder("0");
      dec=true ;
    }
    else {
      sb.append(x.charAt(i));
      if(dec)f*=10 ;
    }
    res+=Long.parseLong(sb.toString())/f ;
    return res*(neg ?-1 : 1);
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := s.getCurrent()->toInteger() ;
    var b : int ; b := s.getCurrent()->toInteger() ;
    var c : int ; c := s.getCurrent()->toInteger() ;
     OclFile["System.out"].println(Set{b / a, c}->min()) );
}
class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     var x : String ; x := next() ;
     var sb : String ; sb := StringLib.newString("0") ;
    var res : double ; res := 0 ;
    var f : double ; f := 1 ;
    var dec : boolean ; dec := false ;
    var neg : boolean ; neg := false ;
    var start : int ; start := 0 ;
    if (x->at(0+1) = '-') then (     neg := true ; 
     start := start + 1 ) else skip ; 
        var i : int ; i := start ; while i < x->size() do (     if (x->at(i+1) = '.') then (     res := (sb+"")->toLong() ; 
     sb := StringLib.newString("0") ; 
     dec := true ) else (     sb := sb + StringLib.newString(x->at(i+1)) ; 
     if (dec) then     f := f*(10) ; else skip ) ;   ;     i := i + 1 ) ; 
    res := res+((sb+"")->toLong() / f) ; 
    return res * (if neg then -1 else 1 endif) 
 );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static PrintStream out=System.out ;
  static void solve(Scanner in){
    int A=in.nextInt();
    int B=in.nextInt();
    int C=in.nextInt();
    int num=B/A ;
    if(num>=C)out.println(C);
    else out.println(num);
  }
  public static void main(String[] args){
    Scanner in=new Scanner(new BufferedInputStream(System.in));
    solve(in);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile["System.out"];
  static   operation solve( in : OclFile) : void
  pre: true
  post: true
  activity: (     var A : int ; A := in.nextInt() ;
     var B : int ; B := in.nextInt() ;
    var C : int ; C := in.nextInt() ;
    var num : int ; num := B / A ;
    if (num >= C) then     skip else     skip ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     execute solve(in) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.Math ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    int ans=0 ;
    if(B/A>C){
      ans=C ;
    }
    else {
      ans=B/A ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    if (B / A > C) then (     ans := C ) else (     ans := B / A ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int count=0 ;
    boolean sw=false ;
    int answer=0 ;
    int max=Integer.MIN_VALUE ;
    int min=Integer.MAX_VALUE ;
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    if(A*C<=B){
      answer=C ;
    }
    else {
      answer=B/A ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var sw : boolean ; sw := false ;
    var answer : int ; answer := 0 ;
    var max : int ; max := -2147483648 ;
    var min : int ; min := 2147483647 ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    if (A * C <= B) then (     answer := C ) else (     answer := B / A ) ;  
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public List<Integer>selfDividingNumbers(int left,int right){
    LinkedList list=new LinkedList();
    for(int i=left ; i<=right ; i++){
      if(isSelfDiving(i))list.add(i);
    }
    return list ;
  }
  public boolean isSelfDiving(int num){
    int digit=num % 10 ;
    int temp=num ;
    boolean isTrue=true ;
    while(temp!=0){
      if(digit==0 || num % digit!=0){
        isTrue=false ;
        break ;
      }
      else {
        temp/=10 ;
        digit=temp % 10 ;
      }
    }
    return isTrue ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation selfDividingNumbers( left : int, right : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var list : Sequence ; list := Sequence{} ;
         var i : int ; i := left ; while i <= right do ( (     if (isSelfDiving(i)) then     list := list->including(i) ; else skip )  ;     i := i + 1 ) ; 
     return list );
   operation isSelfDiving( num : int) : boolean
  pre: true
  post: true
  activity: (     var digit : int ; digit := num mod 10 ;
     var temp : int ; temp := num ;
    var isTrue : boolean ; isTrue := true ;
    while (temp /= 0) do (     if (digit = 0 or num mod digit /= 0) then (     isTrue := false ; 
     break ) else (     temp := temp/(10) ; 
     digit := temp mod 10 ) ) ; 
    return isTrue 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  int OFS=540,MAX=1260-OFS+4 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int N=sc.nextInt(),M=sc.nextInt();
      if((N | M)==0)break ;
      int[][] use=new int[M][MAX];
      int r=sc.nextInt();
      for(int i=0 ; i<r ; i++){
        int t=sc.nextInt()-OFS+1,n=sc.nextInt(),m=sc.nextInt()-1,s=sc.nextInt();
        use[m][t]+=s==1 ? 1 :-1 ;
      }
      for(int j=0 ; j<M ; j++){
        int cnt=use[j][0];
        for(int i=1 ; i<MAX ; i++){
          cnt+=use[j][i];
          if(cnt>0){
            use[j][i]=use[j][i-1]+1 ;
          }
          else {
            use[j][i]=use[j][i-1];
          }
        }
      }
      int q=sc.nextInt();
      for(int i=0 ; i<q ; i++){
        int s=sc.nextInt()-OFS,e=sc.nextInt()-OFS,tar=sc.nextInt()-1 ;
        System.out.println(use[tar][e]-use[tar][s]);
      }
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   attribute OFS : int := 540;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseOr(N,M)) = 0) then     break else skip ; 
    var use : Sequence(Sequence(int)) ; use := Integer.subrange(1,M)->collect(Integer.subrange(1,MAX)->collect(0)) ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < r do ( (     var t : int ; t := sc.getCurrent()->toInteger() - OFS + 1 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() - 1 ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
     use[m+1][t+1] := use[m+1][t+1]+(if s = 1 then 1 else -1 endif) )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < M do ( (     var cnt : int ; cnt := use[j+1][0+1] ;
         var i : int ; i := 1 ; while i < MAX do ( (     cnt := cnt+(use[j+1][i+1]) ; 
     if (cnt > 0) then (     use[j+1][i+1] := use[j+1][i - 1+1] + 1 ) else (     use[j+1][i+1] := use[j+1][i - 1+1] ) )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var s : int ; s := sc.getCurrent()->toInteger() - OFS ;
    var e : int ; e := sc.getCurrent()->toInteger() - OFS ;
    var tar : int ; tar := sc.getCurrent()->toInteger() - 1 ;
     OclFile["System.out"].println(use[tar+1][e+1] - use[tar+1][s+1]) )  ;     i := i + 1 ) ; 
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void diagonalsMinMax(int[][] mat){
    int n=mat.length ;
    if(n==0)return ;
    int principalMin=mat[0][0],principalMax=mat[0][0];
    int secondaryMin=mat[n-1][0],secondaryMax=mat[n-1][0];
    for(int i=0 ; i<n ; i++){
      if(mat[i][i]<principalMin){
        principalMin=mat[i][i];
      }
      if(mat[i][i]>principalMax){
        principalMax=mat[i][i];
      }
      if(mat[n-1-i][i]<secondaryMin){
        secondaryMin=mat[n-1-i][i];
      }
      if(mat[n-1-i][i]>secondaryMax){
        secondaryMax=mat[n-1-i][i];
      }
    }
    System.out.println("Principal Diagonal Smallest Element:  "+principalMin);
    System.out.println("Principal Diagonal Greatest Element : "+principalMax);
    System.out.println("Secondary Diagonal Smallest Element: "+secondaryMin);
    System.out.println("Secondary Diagonal Greatest Element: "+secondaryMax);
  }
  static public void main(String[] args){
    int[][] matrix={
      {
        1,2,3,4,-10 },{
          5,6,7,8,6 },{
            1,2,11,3,4 },{
              5,6,70,5,8 },{
                4,9,7,1,-5 }
              };
              diagonalsMinMax(matrix);
            }
          }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation diagonalsMinMax( mat : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var n : int ; n := mat->size() ;
     if (n = 0) then     return else skip ; 
    var principalMin : int ; principalMin := mat[0+1][0+1] ;
    var principalMax : int ; principalMax := mat[0+1][0+1] ;
    var secondaryMin : int ; secondaryMin := mat[n - 1+1][0+1] ;
    var secondaryMax : int ; secondaryMax := mat[n - 1+1][0+1] ;
        var i : int ; i := 0 ; while i < n do ( (     if (mat[i+1][i+1] < principalMin) then (     principalMin := mat[i+1][i+1] ) else skip ; 
     if (mat[i+1][i+1] > principalMax) then (     principalMax := mat[i+1][i+1] ) else skip ; 
     if (mat[n - 1 - i+1][i+1] < secondaryMin) then (     secondaryMin := mat[n - 1 - i+1][i+1] ) else skip ; 
     if (mat[n - 1 - i+1][i+1] > secondaryMax) then (     secondaryMax := mat[n - 1 - i+1][i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Principal Diagonal Smallest Element:  " + principalMin) ; 
    OclFile["System.out"].println("Principal Diagonal Greatest Element : " + principalMax) ; 
    OclFile["System.out"].println("Secondary Diagonal Smallest Element: " + secondaryMin) ; 
    OclFile["System.out"].println("Secondary Diagonal Greatest Element: " + secondaryMax) ; 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var matrix : Sequence(Sequence(int)) ; matrix := Sequence{Sequence{1,2,3,4,-10},Sequence{5,6,7,8,6},Sequence{1,2,11,3,4},Sequence{5,6,70,5,8},Sequence{4,9,7,1,-5}} ;
     execute diagonalsMinMax(matrix) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static final int UPPER=1260 ;
  public static final int UNDER=540 ;
  public static final int MAX=UPPER-UNDER ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      final int N=sc.nextInt();
      final int M=sc.nextInt();
      if(N==0 && M==0){
        break ;
      }
      final int r=sc.nextInt();
      int[][] students=new int[M][MAX];
      for(int i=0 ; i<r ; i++){
        final int t=sc.nextInt()-UNDER ;
        final int n=sc.nextInt();
        final int m=sc.nextInt()-1 ;
        final int s=sc.nextInt();
        if(s==1){
          students[m][t]++;
        }
        else if(t<MAX){
          students[m][t]--;
        }
      }
      for(int i=0 ; i<M ; i++){
        for(int t=1 ; t<MAX ; t++){
          students[i][t]+=students[i][t-1];
        }
      }
      final int q=sc.nextInt();
      for(int i=0 ; i<q ; i++){
        final int ts=sc.nextInt()-UNDER ;
        final int te=sc.nextInt()-UNDER ;
        final int m=sc.nextInt()-1 ;
        int count=0 ;
        for(int t=ts ; t<te ; t++){
          count+=students[m][t]==0 ? 0 : 1 ;
        }
        System.out.println(count);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute UPPER : int := 1260;
  static    attribute UNDER : int := 540;
  static    attribute MAX : int := UPPER - UNDER;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var M : int ; M := sc.getCurrent()->toInteger() ;
    if (N = 0 & M = 0) then (     break ) else skip ; 
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var students : Sequence(Sequence(int)) ; students := Integer.subrange(1,M)->collect(Integer.subrange(1,MAX)->collect(0)) ;
        var i : int ; i := 0 ; while i < r do ( (     var t : int ; t := sc.getCurrent()->toInteger() - UNDER ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() - 1 ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    if (s = 1) then (     students[m+1][t+1] := students[m+1][t+1] + 1 ) else     if (t < MAX) then (     students[m+1][t+1] := students[m+1][t+1] - 1 ) else skip ; ;  
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (         var t : int ; t := 1 ; while t < MAX do ( (     students[i+1][t+1] := students[i+1][t+1]+(students[i+1][t - 1+1]) )  ;     t := t + 1 ) )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var ts : int ; ts := sc.getCurrent()->toInteger() - UNDER ;
     var te : int ; te := sc.getCurrent()->toInteger() - UNDER ;
    var m : int ; m := sc.getCurrent()->toInteger() - 1 ;
    var count : int ; count := 0 ;
        var t : int ; t := ts ; while t < te do ( (     count := count+(if students[m+1][t+1] = 0 then 0 else 1 endif) )  ;     t := t + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if(n==0 && m==0)break ;
      int r=sc.nextInt();
      int[][] map=new int[m+1][n+1];
      int[][] rec=new int[m+1][721];
      int a,b,c,d ;
      for(int i=0 ; i<r ; i++){
        a=sc.nextInt()-540 ;
        b=sc.nextInt();
        c=sc.nextInt();
        d=sc.nextInt();
        if(d==1)map[c][b]=a ;
        else {
          for(int j=map[c][b]+1 ; j<=a ; j++)rec[c][j]++;
        }
      }
      int q=sc.nextInt();
      int sum ;
      for(int i=0 ; i<q ; i++){
        a=sc.nextInt()-540 ;
        b=sc.nextInt()-540 ;
        c=sc.nextInt();
        sum=0 ;
        for(int j=a+1 ; j<=b ; j++){
          if(rec[c][j]>0)sum++;
        }
        System.out.println(sum);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if (n = 0 & m = 0) then     break else skip ; 
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
    var rec : Sequence(Sequence(int)) ; rec := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,721)->collect(0)) ;
    var a : int ;
    var b : int ;
    var c : int ;
    var d : int ;
        var i : int ; i := 0 ; while i < r do ( (     a := sc.getCurrent()->toInteger() - 540 ; 
     b := sc.getCurrent()->toInteger() ; 
    c := sc.getCurrent()->toInteger() ; 
    d := sc.getCurrent()->toInteger() ; 
    if (d = 1) then     map[c+1][b+1] := a else (         var j : int ; j := map[c+1][b+1] + 1 ; while j <= a do (     rec[c+1][j+1] := rec[c+1][j+1] + 1 ;  ;     j := j + 1 ) ) ;  
 )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var sum : int ;
        var i : int ; i := 0 ; while i < q do ( (     a := sc.getCurrent()->toInteger() - 540 ; 
     b := sc.getCurrent()->toInteger() - 540 ; 
    c := sc.getCurrent()->toInteger() ; 
    sum := 0 ; 
        var j : int ; j := a + 1 ; while j <= b do ( (     if (rec[c+1][j+1] > 0) then     sum := sum + 1 ; else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int juice=in.nextInt();
    int count=0 ;
    for(int i=1 ; i<=juice ; i++){
      int per=in.nextInt();
      count=count+per ;
    }
    double amount=(double)count/juice ;
    System.out.println(amount);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var juice : int ; juice := in.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= juice do ( (     var per : int ; per := in.getCurrent()->toInteger() ;
     count := count + per )  ;     i := i + 1 ) ; 
    var amount : double ; amount := count->oclAsType(double) / juice ;
    OclFile["System.out"].println(amount) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if((n | m)==0)break ;
      boolean[][] log=new boolean[m+1][1261];
      List<int[]>list=new ArrayList<int[]>();
      int r=sc.nextInt();
      while(r--!=0){
        int t=sc.nextInt();
        int N=sc.nextInt();
        int M=sc.nextInt();
        int s=sc.nextInt();
        if(s==1){
          list.add(new int[] {
            N,M,t }
);
          }
          else {
            int st=-1 ;
            for(int i=0 ; i<list.size(); i++){
              int[] a=list.get(i);
              if(a[0]==N && a[1]==M){
                st=a[2];
                list.remove(i);
                break ;
              }
            }
            for(int i=st ; i<t ; i++)log[M][i]=true ;
          }
        }
        int q=sc.nextInt();
        while(q--!=0){
          int s=0 ;
          int ts=sc.nextInt();
          int te=sc.nextInt();
          int M=sc.nextInt();
          for(int i=ts ; i<te ; i++)if(log[M][i])s++;
          System.out.println(s);
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,m)) = 0) then     break else skip ; 
    var log : Sequence(Sequence(boolean)) ; log := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,1261)->collect(false)) ;
    var list : Sequence(Sequence(int)) ; list := Sequence{} ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
        while (r /= 0) do (    skip ; (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    if (s = 1) then (     list := list->including(Sequence{N,M,t}) ) else (     var st : int ; st := -1 ;
         var i : int ; i := 0 ; while i < list->size() do ( (     var a : Sequence(int) ; a := list->at(i+1) ;
     if (a[0+1] = N & a[1+1] = M) then (     st := a[2+1] ; 
     list := list->excludingAt(i+1) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := st ; while i < t do (     log[M+1][i+1] := true ;  ;     i := i + 1 ) ) ;  
 ) ;  ) ;  
    var q : int ; q := sc.getCurrent()->toInteger() ;
        while (q /= 0) do (    skip ; (     var s : int ; s := 0 ;
     var ts : int ; ts := sc.getCurrent()->toInteger() ;
    var te : int ; te := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
        var i : int ; i := ts ; while i < te do (     if (log[M+1][i+1]) then     s := s + 1 ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 ) ;  ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Arrays ;
class GFG {
  static int minOps(int arr[],int n,int k){
    Arrays.sort(arr);
    int max=arr[arr.length-1];
    int res=0 ;
    for(int i=0 ; i<n ; i++){
      if((max-arr[i])% k!=0)return-1 ;
      else res+=(max-arr[i])/k ;
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      21,33,9,45,63 };
      int n=arr.length ;
      int k=6 ;
      System.out.println(minOps(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minOps( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var max : int ; max := arr[arr->size() - 1+1] ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if ((max - arr[i+1]) mod k /= 0) then     return -1 else     res := res+((max - arr[i+1]) / k) ; )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{21,33,9,45,63} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 6 ;
     OclFile["System.out"].println(minOps(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GFG {
  static int[] getFrequencies(String str){
    int freq[]=new int[26];
    for(int i=0 ; i<str.length(); i++){
      freq[str.charAt(i)-'a']++;
    }
    return freq ;
  }
  static int countMinParts(String str){
    int n=str.length();
    int freq[]=getFrequencies(str);
    List<Integer>oddFreq=new ArrayList<>();
    List<Integer>evenFreq=new ArrayList<>();
    int i,sumEven=0 ;
    for(i=0 ; i<26 ; i++){
      if(freq[i]==0)continue ;
      if(freq[i] % 2==0)evenFreq.add(freq[i]);
      else oddFreq.add(freq[i]);
    }
    for(i=0 ; i<evenFreq.size(); i++){
      sumEven+=evenFreq.get(i);
    }
    if(oddFreq.size()==0)return 1 ;
    if(sumEven==0){
      if(oddFreq.size()==1)return 1 ;
      return 0 ;
    }
    i=0 ;
    while(i<oddFreq.size()){
      if((sumEven/2)% oddFreq.size()==0)return oddFreq.size();
      if(oddFreq.get(i)==1){
        i++;
        continue ;
      }
      sumEven+=2 ;
      oddFreq.set(i,oddFreq.get(i)-2);
    }
    return n ;
  }
  public static void main(String[] args){
    String s="noonpeep" ;
    System.out.println(countMinParts(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getFrequencies( str : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
         var i : int ; i := 0 ; while i < str->size() do ( (     freq[str->at(i+1) - ('a')->char2byte()+1] := freq[str->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
     return freq );
  static   operation countMinParts( str : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var freq : Sequence(int) ; freq := getFrequencies(str) ;
    var oddFreq : Sequence(int) ; oddFreq := Sequence{} ;
    var evenFreq : Sequence(int) ; evenFreq := Sequence{} ;
    var i : int ;
    var sumEven : int ; sumEven := 0 ;
        i := 0 ; while i < 26 do ( (     if (freq[i+1] = 0) then     continue else skip ; 
     if (freq[i+1] mod 2 = 0) then     evenFreq := evenFreq->including(freq[i+1]) ; else     oddFreq := oddFreq->including(freq[i+1]) ; )  ;     i := i + 1 ) ; 
        i := 0 ; while i < evenFreq->size() do ( (     sumEven := sumEven+(evenFreq->at(i+1)) )  ;     i := i + 1 ) ; 
    if (oddFreq->size() = 0) then     return 1 else skip ; 
    if (sumEven = 0) then (     if (oddFreq->size() = 1) then     return 1 else skip ; 
     return 0 ) else skip ; 
    i := 0 ; 
    while (i < oddFreq->size()) do (     if ((sumEven / 2) mod oddFreq->size() = 0) then     return oddFreq->size() else skip ; 
     if (oddFreq->at(i+1) = 1) then (     i := i + 1 ; 
     continue ) else skip ; 
     sumEven := sumEven+(2) ; 
     oddFreq := oddFreq.setAt(i+1,oddFreq->at(i+1) - 2) ) ; 
    return n 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "noonpeep" ;
     OclFile["System.out"].println(countMinParts(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int N=4 ;
  static int stepsRequired(int arr[][]){
    int result=0 ;
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        if(i>j+1)result+=Math.abs(arr[i][j]);
      }
    }
    return result ;
  }
  public static void main(String[] args){
    int arr[][]=new int[][] {
      {
        1,2,3,4 },{
          3,1,0,3 },{
            3,2,1,3 },{
-3,4,2,1 }
            };
            System.out.println(stepsRequired(arr));
          }
        }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 4;
  static   operation stepsRequired( arr : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     if (i > j + 1) then     result := result+(if arr[i+1][j+1] < 0 then -(arr[i+1][j+1]) else arr[i+1][j+1] endif) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,2,3,4},Sequence{3,1,0,3},Sequence{3,2,1,3},Sequence{-3,4,2,1}} ;
     OclFile["System.out"].println(stepsRequired(arr)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int N=4 ;
  static int stepsRequired(int arr[][]){
    int result=0 ;
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        if(j>i+1)result+=Math.abs(arr[i][j]);
      }
    }
    return result ;
  }
  public static void main(String[] args){
    int[][] arr={
      {
        1,2,3,2 },{
          3,1,0,3 },{
            3,2,1,3 },{
-3,4,2,1 }
            };
            System.out.println(stepsRequired(arr));
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 4;
  static   operation stepsRequired( arr : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     if (j > i + 1) then     result := result+(if arr[i+1][j+1] < 0 then -(arr[i+1][j+1]) else arr[i+1][j+1] endif) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,2,3,2},Sequence{3,1,0,3},Sequence{3,2,1,3},Sequence{-3,4,2,1}} ;
     OclFile["System.out"].println(stepsRequired(arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p173 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p173().run());
  }
  private static final int TILES=1000000 ;
  public String run(){
    int count=0 ;
    for(int n=3 ; n<=TILES/4+1 ; n++){
      for(int k=n-2 ; k>=1 ; k-=2){
        if((long)n*n-(long)k*k>TILES)break ;
        count++;
      }
    }
    return Integer.toString(count);
  }
}
------------------------------------------------------------
OCL File:
---------
class p173 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p173.newp173().run()) );
  static    attribute TILES : int := 1000000;
   operation run() : String
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var n : int ; n := 3 ; while n <= TILES / 4 + 1 do ( (         var k : int ; k := n - 2 ; while k >= 1 do ( (     if (n->oclAsType(long) * n - k->oclAsType(long) * k > TILES) then     break else skip ; 
     count := count + 1 )  ;     k := k-(2) ) )  ;     n := n + 1 ) ; 
     return ((count) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void diagonalsMinMax(int[][] mat){
    int n=mat.length ;
    if(n==0)return ;
    int principalMin=mat[0][0],principalMax=mat[0][0];
    int secondaryMin=mat[n-1][0],secondaryMax=mat[n-1][0];
    for(int i=1 ; i<n ; i++){
      for(int j=1 ; j<n ; j++){
        if(i==j){
          if(mat[i][j]<principalMin){
            principalMin=mat[i][j];
          }
          if(mat[i][j]>principalMax){
            principalMax=mat[i][j];
          }
        }
        if((i+j)==(n-1)){
          if(mat[i][j]<secondaryMin){
            secondaryMin=mat[i][j];
          }
          if(mat[i][j]>secondaryMax){
            secondaryMax=mat[i][j];
          }
        }
      }
    }
    System.out.println("Principal Diagonal Smallest Element:  "+principalMin);
    System.out.println("Principal Diagonal Greatest Element : "+principalMax);
    System.out.println("Secondary Diagonal Smallest Element: "+secondaryMin);
    System.out.println("Secondary Diagonal Greatest Element: "+secondaryMax);
  }
  static public void main(String[] args){
    int[][] matrix={
      {
        1,2,3,4,-10 },{
          5,6,7,8,6 },{
            1,2,11,3,4 },{
              5,6,70,5,8 },{
                4,9,7,1,-5 }
              };
              diagonalsMinMax(matrix);
            }
          }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation diagonalsMinMax( mat : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var n : int ; n := mat->size() ;
     if (n = 0) then     return else skip ; 
    var principalMin : int ; principalMin := mat[0+1][0+1] ;
    var principalMax : int ; principalMax := mat[0+1][0+1] ;
    var secondaryMin : int ; secondaryMin := mat[n - 1+1][0+1] ;
    var secondaryMax : int ; secondaryMax := mat[n - 1+1][0+1] ;
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 1 ; while j < n do ( (     if (i = j) then (     if (mat[i+1][j+1] < principalMin) then (     principalMin := mat[i+1][j+1] ) else skip ; 
     if (mat[i+1][j+1] > principalMax) then (     principalMax := mat[i+1][j+1] ) else skip ) else skip ; 
     if ((i + j) = (n - 1)) then (     if (mat[i+1][j+1] < secondaryMin) then (     secondaryMin := mat[i+1][j+1] ) else skip ; 
     if (mat[i+1][j+1] > secondaryMax) then (     secondaryMax := mat[i+1][j+1] ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Principal Diagonal Smallest Element:  " + principalMin) ; 
    OclFile["System.out"].println("Principal Diagonal Greatest Element : " + principalMax) ; 
    OclFile["System.out"].println("Secondary Diagonal Smallest Element: " + secondaryMin) ; 
    OclFile["System.out"].println("Secondary Diagonal Greatest Element: " + secondaryMax) ; 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var matrix : Sequence(Sequence(int)) ; matrix := Sequence{Sequence{1,2,3,4,-10},Sequence{5,6,7,8,6},Sequence{1,2,11,3,4},Sequence{5,6,70,5,8},Sequence{4,9,7,1,-5}} ;
     execute diagonalsMinMax(matrix) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int rev(int n,int temp){
    if(n==0)return temp ;
    temp=(temp*10)+(n % 10);
    return rev(n/10,temp);
  }
  public static void main(String[] args){
    int n=121 ;
    int temp=rev(n,0);
    if(temp==n)System.out.println("yes");
    else System.out.println("no");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation rev( n : int, temp : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return temp else skip ; 
     temp := (temp * 10) + (n mod 10) ; 
     return rev(n / 10, temp) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 121 ;
     var temp : int ; temp := rev(n, 0) ;
     if (temp = n) then     OclFile["System.out"].println("yes") ; else     OclFile["System.out"].println("no") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
public class Solution {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    StringBuilder result=new StringBuilder();
    for(int i=0 ; i<t ; i++){
      int n=scan.nextInt();
      List<Integer>a=new ArrayList<>();
      List<Integer>aSorted=new ArrayList<>();
      for(int j=0 ; j<n ; j++){
        int next=scan.nextInt();
        a.add(next);
        aSorted.add(next);
      }
      Collections.sort(aSorted);
      int iter=1 ;
      while(! a.equals(aSorted)){
        int a1=(iter % 2!=0)? 0 : 1 ;
        int a2=(iter % 2!=0)? n-3 : n-2 ;
        for(int j=a1 ; j<=a2 ; j+=2){
          if(a.get(j)>a.get(j+1)){
            int temp=a.get(j+1);
            a.set(j+1,a.get(j));
            a.set(j,temp);
          }
        }
        iter++;
      }
      int res=iter-1 ;
      result.append(res+"\n");
    }
    System.out.println(result);
  }
  private static void f(int[] a,int i){
    if(a[i]>a[i+1]){
      int temp=a[i];
      a[i]=a[i+1];
      a[i+1]=temp ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
    var result : String ; result := StringLib.newString() ;
        var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Sequence{} ;
    var aSorted : Sequence(int) ; aSorted := Sequence{} ;
        var j : int ; j := 0 ; while j < n do ( (     var next : int ; next := scan.getCurrent()->toInteger() ;
     a := a->including(next) ; 
     aSorted := aSorted->including(next) )  ;     j := j + 1 ) ; 
    aSorted := aSorted->sort() ; 
    var iter : int ; iter := 1 ;
    while (not(a = aSorted)) do (     var a1 : int ; a1 := if (iter mod 2 /= 0) then 0 else 1 endif ;
     var a2 : int ; a2 := if (iter mod 2 /= 0) then n - 3 else n - 2 endif ;
         var j : int ; j := a1 ; while j <= a2 do ( (     if (a->at(j+1) > a->at(j + 1+1)) then (     var temp : int ; temp := a->at(j + 1+1) ;
     a := a.setAt(j + 1+1,a->at(j+1)) ; 
     a := a.setAt(j+1,temp) ) else skip )  ;     j := j+(2) ) ; 
     iter := iter + 1 ) ; 
    var res : int ; res := iter - 1 ;
    result := result + StringLib.newString(res + "\n") ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation f( a : Sequence(int), i : int) : void
  pre: true
  post: true
  activity: (     if (a[i+1] > a[i + 1+1]) then (     var temp : int ; temp := a[i+1] ;
     a[i+1] := a[i + 1+1] ; 
     a[i + 1+1] := temp ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
public class Solution {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    StringBuilder result=new StringBuilder();
    for(int i=0 ; i<t ; i++){
      int n=scan.nextInt();
      List<Integer>a=new ArrayList<>();
      List<Integer>aSorted=new ArrayList<>();
      for(int j=0 ; j<n ; j++){
        int next=scan.nextInt();
        a.add(next);
        aSorted.add(next);
      }
      Collections.sort(aSorted);
      int iter=1 ;
      while(! a.equals(aSorted)){
        int a1=(iter % 2!=0)? 0 : 1 ;
        int a2=(iter % 2!=0)? n-3 : n-2 ;
        for(int j=a1 ; j<=a2 ; j+=2){
          if(a.get(j)>a.get(j+1)){
            int temp=a.get(j+1);
            a.set(j+1,a.get(j));
            a.set(j,temp);
          }
        }
        iter++;
      }
      int res=iter-1 ;
      result.append(res+"\n");
    }
    System.out.println(result);
  }
  private static void f(int[] a,int i){
    if(a[i]>a[i+1]){
      int temp=a[i];
      a[i]=a[i+1];
      a[i+1]=temp ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
    var result : String ; result := StringLib.newString() ;
        var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Sequence{} ;
    var aSorted : Sequence(int) ; aSorted := Sequence{} ;
        var j : int ; j := 0 ; while j < n do ( (     var next : int ; next := scan.getCurrent()->toInteger() ;
     a := a->including(next) ; 
     aSorted := aSorted->including(next) )  ;     j := j + 1 ) ; 
    aSorted := aSorted->sort() ; 
    var iter : int ; iter := 1 ;
    while (not(a = aSorted)) do (     var a1 : int ; a1 := if (iter mod 2 /= 0) then 0 else 1 endif ;
     var a2 : int ; a2 := if (iter mod 2 /= 0) then n - 3 else n - 2 endif ;
         var j : int ; j := a1 ; while j <= a2 do ( (     if (a->at(j+1) > a->at(j + 1+1)) then (     var temp : int ; temp := a->at(j + 1+1) ;
     a := a.setAt(j + 1+1,a->at(j+1)) ; 
     a := a.setAt(j+1,temp) ) else skip )  ;     j := j+(2) ) ; 
     iter := iter + 1 ) ; 
    var res : int ; res := iter - 1 ;
    result := result + StringLib.newString(res + "\n") ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation f( a : Sequence(int), i : int) : void
  pre: true
  post: true
  activity: (     if (a[i+1] > a[i + 1+1]) then (     var temp : int ; temp := a[i+1] ;
     a[i+1] := a[i + 1+1] ; 
     a[i + 1+1] := temp ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    double total=0 ;
    for(int i=0 ; i<n ; i++){
      total+=sc.nextDouble();
    }
    System.out.println(total/n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var total : double ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     total := total+(sc.getCurrent()->toReal()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total / n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TASK_1561A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int[][] arr=new int[t][];
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int[] arrInner=new int[n];
      for(int j=0 ; j<n ; j++){
        arrInner[j]=sc.nextInt();
      }
      arr[i]=arrInner ;
    }
    for(int i=0 ; i<arr.length ; i++){
      int[] arrInner=arr[i];
      int n=arrInner.length ;
      boolean[] arrBoolean=new boolean[n*2];
      int k=0 ;
      boolean isSorted ;
      while(k<=n){
        isSorted=false ;
        for(int j=0 ; j<arrInner.length-1 ; j=j+2){
          if(arrInner[j]>arrInner[j+1]){
            int temp=arrInner[j+1];
            arrInner[j+1]=arrInner[j];
            arrInner[j]=temp ;
            isSorted=true ;
          }
        }
        arrBoolean[k]=isSorted ;
        isSorted=false ;
        for(int j=1 ; j<arrInner.length-1 ; j=j+2){
          if(arrInner[j]>arrInner[j+1]){
            int temp=arrInner[j+1];
            arrInner[j+1]=arrInner[j];
            arrInner[j]=temp ;
            isSorted=true ;
          }
        }
        arrBoolean[k+1]=isSorted ;
        k+=2 ;
      }
      for(int j=0 ; j<arrBoolean.length-1 ; j++){
        if(arrBoolean[j]==false && arrBoolean[j+1]==false){
          System.out.println(j);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TASK_1561A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,t)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arrInner : Sequence(int) ; arrInner := Integer.subrange(1,n)->collect(0) ;
         var j : int ; j := 0 ; while j < n do ( (     arrInner[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
     arr[i+1] := arrInner )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (     var arrInner : Sequence(int) ; arrInner := arr[i+1] ;
     var n : int ; n := arrInner->size() ;
    var arrBoolean : Sequence(boolean) ; arrBoolean := Integer.subrange(1,n * 2)->collect(false) ;
    var k : int ; k := 0 ;
    var isSorted : boolean ;
    while (k <= n) do (     isSorted := false ; 
         var j : int ; j := 0 ; while j < arrInner->size() - 1 do ( (     if (arrInner[j+1] > arrInner[j + 1+1]) then (     var temp : int ; temp := arrInner[j + 1+1] ;
     arrInner[j + 1+1] := arrInner[j+1] ; 
     arrInner[j+1] := temp ; 
     isSorted := true ) else skip )  ;     j := j + 2 ) ; 
    arrBoolean[k+1] := isSorted ; 
    isSorted := false ; 
        var j : int ; j := 1 ; while j < arrInner->size() - 1 do ( (     if (arrInner[j+1] > arrInner[j + 1+1]) then (     var temp : int ; temp := arrInner[j + 1+1] ;
     arrInner[j + 1+1] := arrInner[j+1] ; 
     arrInner[j+1] := temp ; 
     isSorted := true ) else skip )  ;     j := j + 2 ) ; 
    arrBoolean[k + 1+1] := isSorted ; 
    k := k+(2) ; 
 ) ; 
        var j : int ; j := 0 ; while j < arrBoolean->size() - 1 do ( (     if (arrBoolean[j+1] = false & arrBoolean[j + 1+1] = false) then (     OclFile["System.out"].println(j) ; 
     break ) else skip )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TASK_1561A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int[][] arr=new int[t][];
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int[] arrInner=new int[n];
      for(int j=0 ; j<n ; j++){
        arrInner[j]=sc.nextInt();
      }
      arr[i]=arrInner ;
    }
    for(int i=0 ; i<arr.length ; i++){
      int[] arrInner=arr[i];
      int n=arrInner.length ;
      boolean[] arrBoolean=new boolean[n*2];
      int k=0 ;
      boolean isSorted ;
      while(k<=n){
        isSorted=false ;
        for(int j=0 ; j<arrInner.length-1 ; j=j+2){
          if(arrInner[j]>arrInner[j+1]){
            int temp=arrInner[j+1];
            arrInner[j+1]=arrInner[j];
            arrInner[j]=temp ;
            isSorted=true ;
          }
        }
        arrBoolean[k]=isSorted ;
        isSorted=false ;
        for(int j=1 ; j<arrInner.length-1 ; j=j+2){
          if(arrInner[j]>arrInner[j+1]){
            int temp=arrInner[j+1];
            arrInner[j+1]=arrInner[j];
            arrInner[j]=temp ;
            isSorted=true ;
          }
        }
        arrBoolean[k+1]=isSorted ;
        k+=2 ;
      }
      int count=0 ;
      for(int j=0 ; j<arrBoolean.length-1 ; j++){
        if(arrBoolean[j]==false && arrBoolean[j+1]==false){
          if(j==0){
            count=j ;
            break ;
          }
          else {
            count=j ;
            break ;
          }
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TASK_1561A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,t)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arrInner : Sequence(int) ; arrInner := Integer.subrange(1,n)->collect(0) ;
         var j : int ; j := 0 ; while j < n do ( (     arrInner[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
     arr[i+1] := arrInner )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (     var arrInner : Sequence(int) ; arrInner := arr[i+1] ;
     var n : int ; n := arrInner->size() ;
    var arrBoolean : Sequence(boolean) ; arrBoolean := Integer.subrange(1,n * 2)->collect(false) ;
    var k : int ; k := 0 ;
    var isSorted : boolean ;
    while (k <= n) do (     isSorted := false ; 
         var j : int ; j := 0 ; while j < arrInner->size() - 1 do ( (     if (arrInner[j+1] > arrInner[j + 1+1]) then (     var temp : int ; temp := arrInner[j + 1+1] ;
     arrInner[j + 1+1] := arrInner[j+1] ; 
     arrInner[j+1] := temp ; 
     isSorted := true ) else skip )  ;     j := j + 2 ) ; 
    arrBoolean[k+1] := isSorted ; 
    isSorted := false ; 
        var j : int ; j := 1 ; while j < arrInner->size() - 1 do ( (     if (arrInner[j+1] > arrInner[j + 1+1]) then (     var temp : int ; temp := arrInner[j + 1+1] ;
     arrInner[j + 1+1] := arrInner[j+1] ; 
     arrInner[j+1] := temp ; 
     isSorted := true ) else skip )  ;     j := j + 2 ) ; 
    arrBoolean[k + 1+1] := isSorted ; 
    k := k+(2) ; 
 ) ; 
    var count : int ; count := 0 ;
        var j : int ; j := 0 ; while j < arrBoolean->size() - 1 do ( (     if (arrBoolean[j+1] = false & arrBoolean[j + 1+1] = false) then (     if (j = 0) then (     count := j ; 
     break ) else (     count := j ; 
     break ) ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; ++i){
        a[i]=sc.nextInt();
      }
      System.out.println(solve(a));
    }
    sc.close();
  }
  static int solve(int[] a){
    int result=0 ;
    while(IntStream.range(0,a.length-1).anyMatch(i->a[i]>a[i+1])){
      int beginIndex=(result % 2==0)? 0 : 1 ;
      for(int i=beginIndex ; i+1<a.length ; i+=2){
        if(a[i]>a[i+1]){
          int temp=a[i];
          a[i]=a[i+1];
          a[i+1]=temp ;
        }
      }
++result ;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(solve(a)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     while (Integer.subrange(0, a->size() - 1-1)->exists( _x2 | (lambda i : OclAny in a[i+1] > a[i + 1+1])->apply(_x2) )) do (     var beginIndex : int ; beginIndex := if (result mod 2 = 0) then 0 else 1 endif ;
         var i : int ; i := beginIndex ; while i + 1 < a->size() do ( (     if (a[i+1] > a[i + 1+1]) then (     var temp : int ; temp := a[i+1] ;
     a[i+1] := a[i + 1+1] ; 
     a[i + 1+1] := temp ) else skip )  ;     i := i+(2) ) ; 
     result := result + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Old_Peykan {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int t=1 ;
    while(t-->0){
      String str[]=br.readLine().trim().split(" ");
      int n=Integer.parseInt(str[0]);
      int m=Integer.parseInt(str[1]);
      str=br.readLine().trim().split(" ");
      int d[]=new int[n];
      for(int i=0 ; i<n ; i++){
        d[i]=Integer.parseInt(str[i]);
      }
      str=br.readLine().trim().split(" ");
      int s[]=new int[n];
      for(int i=0 ; i<n ; i++){
        s[i]=Integer.parseInt(str[i]);
      }
      int max[]=new int[n];
      max[0]=s[0];
      for(int i=1 ; i<n ; i++){
        max[i]=Math.max(s[i],max[i-1]);
      }
      long time=0 ;
      long patrol=0 ;
      for(int i=0 ; i<n ; i++){
        patrol+=s[i];
        if(patrol<d[i]){
          int dif=(int)Math.abs(patrol-d[i]);
          int x=(int)Math.ceil(dif*1.0/max[i]);
          time+=x*m ;
          patrol+=x*max[i];
          patrol-=d[i];
          time+=d[i];
        }
        else {
          time+=d[i];
          patrol-=d[i];
        }
      }
      pw.println(time);
    }
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Old_Peykan {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := 1 ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var str : Sequence(String) ; str := br.readLine()->trim()->split(" ") ;
     var n : int ; n := (str[0+1])->toInteger() ;
    var m : int ; m := (str[1+1])->toInteger() ;
    str := br.readLine()->trim()->split(" ") ; 
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     d[i+1] := (str[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    str := br.readLine()->trim()->split(" ") ; 
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := (str[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var max : Sequence(int) ; max := Integer.subrange(1,n)->collect(0) ;
    max[0+1] := s[0+1] ; 
        var i : int ; i := 1 ; while i < n do ( (     max[i+1] := Set{s[i+1], max[i - 1+1]}->max() )  ;     i := i + 1 ) ; 
    var time : long ; time := 0 ;
    var patrol : long ; patrol := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     patrol := patrol+(s[i+1]) ; 
     if (patrol < d[i+1]) then (     var dif : int ; dif := if patrol - d[i+1] < 0 then -(patrol - d[i+1]) else patrol - d[i+1] endif->oclAsType(int) ;
     var x : int ; x := (dif * 1.0 / max[i+1])->ceil()->oclAsType(int) ;
    time := time+(x * m) ; 
    patrol := patrol+(x * max[i+1]) ; 
    patrol := patrol-(d[i+1]) ; 
    time := time+(d[i+1]) ; 
 ) else (     time := time+(d[i+1]) ; 
     patrol := patrol-(d[i+1]) ) )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int m=scanner.nextInt();
    int k=scanner.nextInt();
    int[] length=new int[m];
    int[] oil=new int[m];
    for(int i=0 ; i<m ; i++){
      length[i]=scanner.nextInt();
    }
    for(int i=0 ; i<m ; i++){
      oil[i]=scanner.nextInt();
    }
    int maxOil=0 ;
    int costTime=0 ;
    int oilLeft=0 ;
    for(int i=0 ; i<m ; i++){
      maxOil=Math.max(maxOil,oil[i]);
      costTime+=length[i];
      oilLeft=oilLeft+oil[i]-length[i];
      while(oilLeft<0){
        oilLeft+=maxOil ;
        costTime+=k ;
      }
    }
    System.out.print(costTime);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
    var length : Sequence(int) ; length := Integer.subrange(1,m)->collect(0) ;
    var oil : Sequence(int) ; oil := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     length[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     oil[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var maxOil : int ; maxOil := 0 ;
    var costTime : int ; costTime := 0 ;
    var oilLeft : int ; oilLeft := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     maxOil := Set{maxOil, oil[i+1]}->max() ; 
     costTime := costTime+(length[i+1]) ; 
     oilLeft := oilLeft + oil[i+1] - length[i+1] ; 
     while (oilLeft < 0) do (     oilLeft := oilLeft+(maxOil) ; 
     costTime := costTime+(k) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(costTime) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static Scanner sc=new Scanner(System.in);
  static int M=201000 ;
  static int N=2010 ;
  public static void main(String args[]){
    int n,k,a[]=new int[N],s[]=new int[N],m[]=new int[N],sum=0,ans=0 ;
    n=sc.nextInt();
    k=sc.nextInt();
    Arrays.fill(m,0);
    for(int i=1 ; i<=n ; i++)a[i]=sc.nextInt();
    for(int i=1 ; i<=n ; i++)s[i]=sc.nextInt();
    for(int i=1 ; i<=n ; i++)m[i]=Math.max(m[i-1],s[i]);
    for(int i=1 ; i<=n ; i++){
      sum+=s[i];
      while(a[i]>sum){
        ans+=k ;
        sum+=m[i];
      }
      sum-=a[i];
      ans+=a[i];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute M : int := 201000;
  static   attribute N : int := 2010;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var k : int ;
    var a : Sequence(void) ; a := Integer.subrange(1,N)->collect(0) ;
    var s : Sequence(void) ; s := Integer.subrange(1,N)->collect(0) ;
    var m : Sequence(void) ; m := Integer.subrange(1,N)->collect(0) ;
    var sum : int ; sum := 0 ;
    var ans : int ; ans := 0 ;
     n := sc.getCurrent()->toInteger() ; 
    k := sc.getCurrent()->toInteger() ; 
    m := m->collect(0) ; 
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (     s[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (     m[i+1] := Set{m[i - 1+1], s[i+1]}->max() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     sum := sum+(s[i+1]) ; 
     while (a[i+1] > sum) do (     ans := ans+(k) ; 
     sum := sum+(m[i+1]) ) ; 
     sum := sum-(a[i+1]) ; 
     ans := ans+(a[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int f=0 ;
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    int k=0,j=0,i=0 ;
    for(k=0 ; k<n ; k++){
      int t=a[k];
      for(i=0 ; i<n ; i++){
        for(j=0 ; j<n-1 ; j++){
          if(i!=j && t==(a[i]+a[j])){
            f=1 ;
            break ;
          }
        }
        if(f==1)break ;
      }
      if(f==1)break ;
    }
    if(f==1)System.out.println(k+1+" "+(j+1)+" "+(i+1));
    else System.out.println("-1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var f : int ; f := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var k : int ; k := 0 ;
    var j : int ; j := 0 ;
    var i : int ; i := 0 ;
        k := 0 ; while k < n do ( (     var t : int ; t := a[k+1] ;
         i := 0 ; while i < n do ( (         j := 0 ; while j < n - 1 do ( (     if (i /= j & t = (a[i+1] + a[j+1])) then (     f := 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (f = 1) then     break else skip )  ;     i := i + 1 ) ; 
     if (f = 1) then     break else skip )  ;     k := k + 1 ) ; 
    if (f = 1) then     OclFile["System.out"].println(k + 1 + " " + (j + 1) + " " + (i + 1)) else     OclFile["System.out"].println("-1") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A241 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int M=in.nextInt();
    int K=in.nextInt();
    int[] D=new int[M];
    int[] S=new int[M];
    for(int m=0 ; m<M ; m++){
      D[m]=in.nextInt();
    }
    for(int m=0 ; m<M ; m++){
      S[m]=in.nextInt();
    }
    int max=0 ;
    int time=0 ;
    int fuel=0 ;
    for(int m=0 ; m<M ; m++){
      fuel+=S[m];
      max=Math.max(max,S[m]);
      while(fuel<D[m]){
        time+=K ;
        fuel+=max ;
      }
      fuel-=D[m];
      time+=D[m];
    }
    System.out.println(time);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A241 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var M : int ; M := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    var D : Sequence(int) ; D := Integer.subrange(1,M)->collect(0) ;
    var S : Sequence(int) ; S := Integer.subrange(1,M)->collect(0) ;
        var m : int ; m := 0 ; while m < M do ( (     D[m+1] := in.getCurrent()->toInteger() )  ;     m := m + 1 ) ; 
        var m : int ; m := 0 ; while m < M do ( (     S[m+1] := in.getCurrent()->toInteger() )  ;     m := m + 1 ) ; 
    var max : int ; max := 0 ;
    var time : int ; time := 0 ;
    var fuel : int ; fuel := 0 ;
        var m : int ; m := 0 ; while m < M do ( (     fuel := fuel+(S[m+1]) ; 
     max := Set{max, S[m+1]}->max() ; 
    while (fuel < D[m+1]) do (     time := time+(K) ; 
     fuel := fuel+(max) ) ; 
    fuel := fuel-(D[m+1]) ; 
    time := time+(D[m+1]) ; 
 )  ;     m := m + 1 ) ; 
    OclFile["System.out"].println(time) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int AG=sc.nextInt();
    int[] vala=new int[AG];
    float valt=0 ;
    for(int i=0 ; i<AG ; i++){
      vala[i]=sc.nextInt();
      valt+=vala[i];
    }
    float h=valt/AG ;
    System.out.print(valt/AG);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var AG : int ; AG := sc.getCurrent()->toInteger() ;
    var vala : Sequence(int) ; vala := Integer.subrange(1,AG)->collect(0) ;
    var valt : double ; valt := 0 ;
        var i : int ; i := 0 ; while i < AG do ( (     vala[i+1] := sc.getCurrent()->toInteger() ; 
     valt := valt+(vala[i+1]) )  ;     i := i + 1 ) ; 
    var h : double ; h := valt / AG ;
    OclFile["System.out"].print(valt / AG) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int PointInKSquares(int n,int a[],int k){
    Arrays.sort(a);
    return a[n-k];
  }
  public static void main(String[] args){
    int k=2 ;
    int[] a={
      1,2,3,4 };
      int n=a.length ;
      int x=PointInKSquares(n,a,k);
      System.out.println("("+x+","+x+")");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation PointInKSquares( n : int, a : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     return a[n - k+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 2 ;
     var a : Sequence(int) ; a := Sequence{1,2,3,4} ;
    var n : int ; n := a->size() ;
    var x : int ; x := PointInKSquares(n, a, k) ;
    OclFile["System.out"].println("(" + x + "," + x + ")") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] p=new int[n];
    int num=0 ;
    int ren=0 ;
    int zenkai=-1 ;
    for(int i=0 ; i<n ; i++){
      p[i]=sc.nextInt();
      if(p[i]==i+1){
        num++;
        if(zenkai==i){
          ren++;
          zenkai=-1 ;
          continue ;
        }
        zenkai=i+1 ;
      }
    }
    System.out.println(num-ren);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    var num : int ; num := 0 ;
    var ren : int ; ren := 0 ;
    var zenkai : int ; zenkai := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := sc.getCurrent()->toInteger() ; 
     if (p[i+1] = i + 1) then (     num := num + 1 ; 
     if (zenkai = i) then (     ren := ren + 1 ; 
     zenkai := -1 ; 
     continue ) else skip ; 
     zenkai := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(num - ren) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      int[] p=IntStream.range(0,n).map(i->scanner.nextInt()).toArray();
      System.out.println(getResult(p,0));
    }
  }
  private static int getResult(int[] p,int start){
    int next=-1 ;
    for(int i=start ; i<p.length ; i++){
      if((i+1)==p[i]){
        next=i ;
        break ;
      }
    }
    if(next>=0){
      int result=Integer.MAX_VALUE ;
      if(next==p.length-1){
        result=getResult(swap(p,next-1),next-1)+1 ;
      }
      else {
        result=getResult(swap(p,next),next)+1 ;
      }
      return result ;
    }
    return 0 ;
  }
  private static int[] swap(int[] p,int index){
    int temp=p[index];
    p[index]=p[index+1];
    p[index+1]=temp ;
    return p ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var p : Sequence(int) ; p := Integer.subrange(0, n-1)->collect( _x1 | (lambda i : OclAny in scanner.getCurrent()->toInteger())->apply(_x1) )->asSequence() ;
     OclFile["System.out"].println(getResult(p, 0)) ))  );
  static   operation getResult( p : Sequence(int), start : int) : int
  pre: true
  post: true
  activity: (     var next : int ; next := -1 ;
         var i : int ; i := start ; while i < p->size() do ( (     if ((i + 1) = p[i+1]) then (     next := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (next >= 0) then (     var result : int ; result := 2147483647 ;
     if (next = p->size() - 1) then (     result := getResult(swap(p, next - 1), next - 1) + 1 ) else (     result := getResult(swap(p, next), next) + 1 ) ;  
     return result ) else skip ; 
     return 0 );
  static   operation swap( p : Sequence(int), index : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var temp : int ; temp := p[index+1] ;
     p[index+1] := p[index + 1+1] ; 
     p[index + 1+1] := temp ; 
     return p );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.Math.*;
import static java.lang.System.*;
public class Main {
  public static int AMAX=100000 ;
  public static void main(String[] args){
    int i=0,j=0,k=0 ;
    Scanner sc=new Scanner(in);
    int n=parseInt(sc.next());
    int cnt=0 ;
    int cnt2=0 ;
    for(i=1 ; i<=n ; i++){
      if(parseInt(sc.next())==i){
        cnt++;
      }
      else {
        cnt2+=(int)ceil((double)cnt/2);
        cnt=0 ;
      }
    }
    sc.close();
    cnt2+=(int)ceil((double)cnt/2);
    out.println(cnt2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute AMAX : int := 100000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    var k : int ; k := 0 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
    var n : int ; n := parseInt(sc.getCurrent()) ;
    var cnt : int ; cnt := 0 ;
    var cnt2 : int ; cnt2 := 0 ;
        i := 1 ; while i <= n do ( (     if ((sc.getCurrent() + "")->toInteger() = i) then (     cnt := cnt + 1 ) else (     cnt2 := cnt2+(ceil(cnt->oclAsType(double) / 2)->oclAsType(int)) ; 
     cnt := 0 ) )  ;     i := i + 1 ) ; 
    skip ; 
    cnt2 := cnt2+(ceil(cnt->oclAsType(double) / 2)->oclAsType(int)) ; 
    out.println(cnt2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int arr[]=new int[n+1];
    boolean flag=false ;
    for(int i=1 ; i<=n ; i++){
      arr[i]=scanner.nextInt();
    }
    int count=0 ;
    int i=1 ;
    while(flag==false){
      if(i==n+1){
        i=1 ;
      }
      if(arr[i]==i){
        if(i!=n){
          int temp=arr[i];
          arr[i]=arr[i+1];
          arr[i+1]=temp ;
          i++;
          count++;
        }
        else {
          int temp=arr[i];
          arr[i]=arr[i-1];
          arr[i-1]=temp ;
          i++;
          count++;
        }
      }
      else {
        i++;
      }
      if(i==n+1){
        for(int j=1 ; j<=n ; j++){
          if(arr[j]==j){
            break ;
          }
          if(j==n)flag=true ;
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var i : int ; i := 1 ;
    while (flag = false) do (     if (i = n + 1) then (     i := 1 ) else skip ; 
     if (arr[i+1] = i) then (     if (i /= n) then (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := arr[i + 1+1] ; 
    arr[i + 1+1] := temp ; 
    i := i + 1 ; 
    count := count + 1 ; 
 ) else (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := arr[i - 1+1] ; 
    arr[i - 1+1] := temp ; 
    i := i + 1 ; 
    count := count + 1 ; 
 ) ) else (     i := i + 1 ) ;  
     if (i = n + 1) then (         var j : int ; j := 1 ; while j <= n do ( (     if (arr[j+1] = j) then (     break ) else skip ; 
     if (j = n) then     flag := true ; else skip )  ;     j := j + 1 ) ) else skip ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int n ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    int[] p=new int[n];
    for(int i=0 ; i<n ; i++)p[i]=sc.nextInt()-1 ;
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(p[i]==i && i!=n-1){
        ans++;
        swap(p,i);
      }
      else if(p[i]==i && i==n-1){
        ans++;
        swap(p,i);
      }
    }
    System.out.println(ans);
  }
  static int[] swap(int[] p,int pos){
    if(pos!=n-1){
      int w=p[pos];
      p[pos]=p[pos+1];
      p[pos+1]=w ;
    }
    else {
      int w=p[pos-1];
      p[pos-1]=p[pos];
      p[pos]=w ;
    }
    return p ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     p[i+1] := sc.getCurrent()->toInteger() - 1 ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (p[i+1] = i & i /= n - 1) then (     ans := ans + 1 ; 
     execute swap(p, i) ) else     if (p[i+1] = i & i = n - 1) then (     ans := ans + 1 ; 
     execute swap(p, i) ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation swap( p : Sequence(int), pos : int) : Sequence(int)
  pre: true
  post: true
  activity: (     if (pos /= n - 1) then (     var w : int ; w := p[pos+1] ;
     p[pos+1] := p[pos + 1+1] ; 
     p[pos + 1+1] := w ) else (     var w : int ; w := p[pos - 1+1] ;
     p[pos - 1+1] := p[pos+1] ; 
     p[pos+1] := w ) ;  
     return p );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] sa=br.readLine().split(" ");
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Long.parseLong(sa[i]);
    }
    br.close();
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum ^=a[i];
    }
    for(int i=0 ; i<n ; i++){
      a[i] &=~ sum ;
    }
    Hakidasi h=new Hakidasi(a);
    long sum2=0 ;
    for(int i=0 ; i<n ; i++){
      sum2 ^=h.arr[i];
    }
    System.out.println(sum+sum2*2);
  }
  static class Hakidasi {
    long[] arr ;
    int[] msb ;
    int n,rank ;
    public Hakidasi(long[] a){
      n=a.length ;
      arr=Arrays.copyOf(a,n);
      msb=new int[n];
      for(int i=62 ; i>=0 ; i--){
        boolean flg=false ;
        for(int j=rank ; j<n ; j++){
          if((arr[j]>>i & 1)==1){
            long t=arr[rank];
            arr[rank]=arr[j];
            arr[j]=t ;
            flg=true ;
            break ;
          }
        }
        if(flg){
          msb[rank]=i ;
          for(int j=0 ; j<n ; j++){
            if(j!=rank &&(arr[j]>>i & 1)==1){
              arr[j] ^=arr[rank];
            }
          }
          rank++;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sa[i+1])->toLong() )  ;     i := i + 1 ) ; 
    skip ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := MathLib.bitwiseXor(sum,a[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := MathLib.bitwiseAnd(a[i+1], -(sum + 1)) )  ;     i := i + 1 ) ; 
    var h : Hakidasi ; h := Hakidasi.newHakidasi(a) ;
    var sum2 : long ; sum2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum2 := MathLib.bitwiseXor(sum2,h.arr[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum + sum2 * 2) ; 
 );
  static class Hakidasi {
   attribute arr : Sequence(long);
   attribute msb : Sequence(int);
   attribute n : int;
   static operation newHakidasi( a : Sequence(long)) : Hakidasi
  pre: true
  post: true
  activity:
  ( var self : Hakidasi ;
    self := createHakidasi();
    self.initialise(a);
    return self );
  operation initialise( a : Sequence(long)) : void
  pre: true  post: true
  activity: (     n := a->size() ; 
     arr := a.subrange(1,n) ; 
     msb := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 62 ; while i >= 0 do ( (     var flg : boolean ; flg := false ;
         var j : int ; j := rank ; while j < n do ( (     if ((MathLib.bitwiseAnd((arr[j+1]/(2->pow(i)))->oclAsType(long),1)) = 1) then (     var t : long ; t := arr[rank+1] ;
     arr[rank+1] := arr[j+1] ; 
    arr[j+1] := t ; 
    flg := true ; 
    break 
 ) else skip )  ;     j := j + 1 ) ; 
     if (flg) then (     msb[rank+1] := i ; 
         var j : int ; j := 0 ; while j < n do ( (     if (j /= rank & (MathLib.bitwiseAnd((arr[j+1]/(2->pow(i)))->oclAsType(long),1)) = 1) then (     arr[j+1] := MathLib.bitwiseXor(arr[j+1],arr[rank+1]) ) else skip )  ;     j := j + 1 ) ; 
     rank := rank + 1 ) else skip )  ;     i := i - 1 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
public class code {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String ans="-1" ;
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    for(int j=0 ; j<n ; j++)for(int i=0 ; i<n ; i++)for(int y=0 ; y<n ; y++)if(arr[j]==arr[i]+arr[y] && i!=y)ans=(j+1)+" "+(i+1)+" "+(y+1);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : String ; ans := "-1" ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < n do (         var i : int ; i := 0 ; while i < n do (         var y : int ; y := 0 ; while y < n do (     if (arr[j+1] = arr[i+1] + arr[y+1] & i /= y) then     ans := (j + 1) + " " + (i + 1) + " " + (y + 1) ; else skip ;  ;     y := y + 1 ) ;  ;     i := i + 1 ) ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num=Integer.parseInt(sc.next());
    long[] inputs=new long[num];
    long sum=0 ;
    for(int i=0 ; i<num ; i++){
      inputs[i]=Long.parseLong(sc.next());
      sum ^=inputs[i];
    }
    for(int i=0 ; i<num ; i++){
      inputs[i] &=~ sum ;
    }
    System.out.println(sum+(maxSubarrayXOR(inputs)<<1));
  }
  public static long maxSubarrayXOR(long A[]){
    int idx=0 ;
    for(int bit=60 ; bit>=0 ; bit--){
      int find=idx ;
      while(find<A.length){
        if((A[find] &(1L<<bit))!=0){
          break ;
        }
        find++;
      }
      if(find==A.length)continue ;
      if(idx!=find){
        A[idx] ^=A[find];
        A[find] ^=A[idx];
        A[idx] ^=A[find];
        find=idx ;
      }
      for(int i=0 ; i<A.length ; i++){
        if(i!=find &&(A[i] &(1L<<bit))!=0){
          A[i] ^=A[find];
        }
      }
      idx++;
    }
    long ret=0 ;
    for(long l : A){
      ret ^=l ;
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := (sc.getCurrent())->toInteger() ;
    var inputs : Sequence(long) ; inputs := Integer.subrange(1,num)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < num do ( (     inputs[i+1] := (sc.getCurrent())->toLong() ; 
     sum := MathLib.bitwiseXor(sum,inputs[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < num do ( (     inputs[i+1] := MathLib.bitwiseAnd(inputs[i+1], -(sum + 1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum + ((maxSubarrayXOR(inputs)*(2->pow(1)))->oclAsType(long))) ; 
 );
  static   operation maxSubarrayXOR( A : Sequence(long)) : long
  pre: true
  post: true
  activity: (     var idx : int ; idx := 0 ;
         var bit : int ; bit := 60 ; while bit >= 0 do ( (     var find : int ; find := idx ;
     while (find < A->size()) do (     if ((A[find+1] & ((1L*(2->pow(bit)))->oclAsType(long))) /= 0) then (     break ) else skip ; 
     find := find + 1 ) ; 
    if (find = A->size()) then     continue else skip ; 
    if (idx /= find) then (     A[idx+1] := MathLib.bitwiseXor(A[idx+1],A[find+1]) ; 
     A[find+1] := MathLib.bitwiseXor(A[find+1],A[idx+1]) ; 
     A[idx+1] := MathLib.bitwiseXor(A[idx+1],A[find+1]) ; 
     find := idx ) else skip ; 
        var i : int ; i := 0 ; while i < A->size() do ( (     if (i /= find & (A[i+1] & ((1L*(2->pow(bit)))->oclAsType(long))) /= 0) then (     A[i+1] := MathLib.bitwiseXor(A[i+1],A[find+1]) ) else skip )  ;     i := i + 1 ) ; 
    idx := idx + 1 ; 
 )  ;     bit := bit - 1 ) ; 
    var ret : long ; ret := 0 ;
    for (l : A) do ( (     ret := MathLib.bitwiseXor(ret,l) )  ) ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static PrintWriter out=new PrintWriter(System.out);
  static Scanner sc=new Scanner(System.in);
  static BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
  long mod=1000000000+7 ;
  long[] frac,inv ;
  public static void main(String[] args)throws IOException {
    Main main=new Main();
    out.println(main.solve());
    out.flush();
  }
  long solve()throws IOException {
    int n=sc.nextInt();
    long[] a=new long[n];
    long maxi=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
      maxi=Math.max(maxi,a[i]);
    }
    if(maxi==0)return 0 ;
    long odd_rec=0 ;
    for(int i=60 ; i>=0 ; i--){
      int cnt=0 ;
      long mask=1L<<i ;
      for(long num : a){
        if((num & mask)>0)cnt++;
      }
      if(cnt % 2==1)odd_rec |=mask ;
    }
    long antimask=~ odd_rec ;
    for(int i=0 ; i<n ; i++)a[i] &=antimask ;
    TreeSet<Long>set=new TreeSet<>(Collections.reverseOrder());
    long[] line_base=new long[61];
    for(long c : a){
      long backup=c ;
      for(int i=60 ; i>=0 ; i--){
        long mask=1L<<i ;
        if((mask & backup)==0)continue ;
        if(line_base[i]==0){
          line_base[i]=backup ;
          set.add(backup);
          break ;
        }
        else {
          backup ^=line_base[i];
        }
      }
    }
    long ans=0 ;
    for(long b : set){
      if((ans ^ b)>ans)ans=ans ^ b ;
    }
    return 2*ans+odd_rec ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute mod : long := 1000000000 + 7;
   attribute frac : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     skip ; 
     skip );
   operation solve() : long
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var maxi : long ; maxi := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() ; 
     maxi := Set{maxi, a[i+1]}->max() )  ;     i := i + 1 ) ; 
    if (maxi = 0) then     return 0 else skip ; 
    var odd_rec : long ; odd_rec := 0 ;
        var i : int ; i := 60 ; while i >= 0 do ( (     var cnt : int ; cnt := 0 ;
     var mask : long ; mask := (1L*(2->pow(i)))->oclAsType(long) ;
     for (num : a) do ( (     if ((num & mask) > 0) then     cnt := cnt + 1 ; else skip )  ) ; 
     if (cnt mod 2 = 1) then     odd_rec := MathLib.bitwiseOr(odd_rec, mask) ; else skip )  ;     i := i - 1 ) ; 
    var antimask : long ; antimask := -(odd_rec + 1) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := MathLib.bitwiseAnd(a[i+1], antimask) ;  ;     i := i + 1 ) ; 
    var set : Set(long) ; set := Set{}->union(reverseOrder()) ;
    var line_base : Sequence(long) ; line_base := Integer.subrange(1,61)->collect(0) ;
    for (c : a) do ( (     var backup : long ; backup := c ;
         var i : int ; i := 60 ; while i >= 0 do ( (     var mask : long ; mask := (1L*(2->pow(i)))->oclAsType(long) ;
     if ((MathLib.bitwiseAnd(mask,backup)) = 0) then     continue else skip ; 
     if (line_base[i+1] = 0) then (     line_base[i+1] := backup ; 
     set := set->including(backup) ; 
     break ) else (     backup := MathLib.bitwiseXor(backup,line_base[i+1]) ) )  ;     i := i - 1 ) )  ) ; 
    var ans : long ; ans := 0 ;
    for (b : set) do ( (     if ((MathLib.bitwiseXor(ans,b)) > ans) then     ans := MathLib.bitwiseXor(ans,b) ; else skip )  ) ; 
    return 2 * ans + odd_rec 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class amd {
  static int cost=Integer.MAX_VALUE ;
  static List<List<Integer>>g ;
  static boolean vis[]=new boolean[100005];
  static boolean color[]=new boolean[100005];
  static boolean p=true ;
  public static void dfs(int curr,boolean c){
    if(vis[curr])return ;
    vis[curr]=true ;
    color[curr]=c ;
    for(int a : g.get(curr)){
      if(vis[a]){
        if(color[a]==c){
          p=false ;
        }
      }
      else {
        dfs(a,! c);
      }
    }
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=1 ;
    while(t-->0){
      int n=s.nextInt();
      int m=s.nextInt();
      g=new ArrayList();
      for(int i=0 ; i<=n ; i++){
        g.add(new ArrayList<Integer>());
      }
      for(int i=0 ; i<m ; i++){
        int a=s.nextInt();
        int b=s.nextInt();
        g.get(a).add(b);
        g.get(b).add(a);
      }
      for(int i=1 ; i<=n ; i++){
        if(vis[i]==false){
          dfs(i,false);
        }
      }
      if(p){
        int z=0 ;
        int q=0 ;
        StringBuilder sb1=new StringBuilder();
        StringBuilder sb2=new StringBuilder();
        for(int i=1 ; i<=n ; i++){
          if(color[i]){
            q++;
            sb1.append(i+" ");
          }
          else {
            z++;
            sb2.append(i+" ");
          }
        }
        System.out.println(q);
        System.out.println(sb1);
        System.out.println(z);
        System.out.println(sb2);
      }
      else {
        System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class amd {
  static   attribute cost : int := 2147483647;
  static   attribute g : Sequence(Sequence(int));
  static   attribute vis : boolean := Integer.subrange(1,100005)->collect(false);
  static   attribute color : boolean := Integer.subrange(1,100005)->collect(false);
  static   attribute p : boolean := true;
  static   operation dfs( curr : int, c : boolean) : void
  pre: true
  post: true
  activity: (     if (vis[curr+1]) then     return else skip ; 
     vis[curr+1] := true ; 
     color[curr+1] := c ; 
     for (a : g->at(curr+1)) do ( (     if (vis[a+1]) then (     if (color[a+1] = c) then (     p := false ) else skip ) else (     execute dfs(a, not(c)) ) )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var m : int ; m := s.getCurrent()->toInteger() ;
    g := Sequence{} ; 
        var i : int ; i := 0 ; while i <= n do ( (     g := g->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := s.getCurrent()->toInteger() ;
     var b : int ; b := s.getCurrent()->toInteger() ;
     g->at(a+1)->excludes(b) ; 
     g->at(b+1)->excludes(a) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (vis[i+1] = false) then (     execute dfs(i, false) ) else skip )  ;     i := i + 1 ) ; 
    if (p) then (     var z : int ; z := 0 ;
     var q : int ; q := 0 ;
    var sb1 : String ; sb1 := StringLib.newString() ;
    var sb2 : String ; sb2 := StringLib.newString() ;
        var i : int ; i := 1 ; while i <= n do ( (     if (color[i+1]) then (     q := q + 1 ; 
     sb1 := sb1 + StringLib.newString(i + " ") ) else (     z := z + 1 ; 
     sb2 := sb2 + StringLib.newString(i + " ") ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(q) ; 
    OclFile["System.out"].println(sb1) ; 
    OclFile["System.out"].println(z) ; 
    OclFile["System.out"].println(sb2) ; 
 ) else (     OclFile["System.out"].println(-1) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ACardGame {
  public static void main(String[] args){
    char cards[]={
      'S','H','D','C' };
      char symbol[]={
        '6','7','8','9','T','J','Q','K','A' };
        String trump,card1,card2 ;
        Scanner in=new Scanner(System.in);
        trump=in.next();
        card1=in.next();
        card2=in.next();
        if(card1.contains(trump)&& ! card2.contains(trump)){
          System.out.println("YES");
        }
        else if(card2.contains(trump)&& ! card1.contains(trump)){
          System.out.println("NO");
        }
        else if(new String(symbol).indexOf(card1.charAt(0))>new String(symbol).indexOf(card2.charAt(0))&& card1.charAt(1)==card2.charAt(1)){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class ACardGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cards : Sequence(String) ; cards := Sequence{'S','H','D','C'} ;
     var symbol : Sequence(String) ; symbol := Sequence{'6','7','8','9','T','J','Q','K','A'} ;
    var trump : String ;
    var card1 : String ;
    var card2 : String ;
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    trump := in.getCurrent() ; 
    card1 := in.getCurrent() ; 
    card2 := in.getCurrent() ; 
    if (card1->includes(trump) & not(card2->includes(trump))) then (     OclFile["System.out"].println("YES") ) else     if (card2->includes(trump) & not(card1->includes(trump))) then (     OclFile["System.out"].println("NO") ) else     if (StringLib.newString(symbol)->indexOf(card1->at(0+1))-1 > StringLib.newString(symbol)->indexOf(card2->at(0+1))-1 & card1->at(1+1) = card2->at(1+1)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Scanner ;
import java.util.Arrays ;
import java.util.Collections ;
import java.lang.Math ;
import java.util.ArrayList ;
import java.util.*;
import java.math.*;
public class cardgame {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String trump=sc.nextLine();
    String s=sc.nextLine();
    String[] arr=s.split("");
    int value1=value(arr[0]);
    int value2=value(arr[3]);
    if(arr[1] .compareTo(trump)==0 && arr[4] .compareTo(trump)!=0){
      System.out.println("YES");
      System.exit(0);
    }
    else if(arr[1] .compareTo(trump)!=0 && arr[4] .compareTo(trump)==0){
      System.out.println("NO");
      System.exit(0);
    }
    else if(arr[1] .compareTo(arr[4])==0){
      if(value1>value2){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    else {
      System.out.println("NO");
    }
  }
  public static int value(String number){
    if(number.compareTo("6")==0){
      return 0 ;
    }
    else if(number.compareTo("7")==0){
      return 1 ;
    }
    else if(number.compareTo("8")==0){
      return 2 ;
    }
    else if(number.compareTo("9")==0){
      return 3 ;
    }
    else if(number.compareTo("T")==0){
      return 4 ;
    }
    else if(number.compareTo("J")==0){
      return 5 ;
    }
    else if(number.compareTo("Q")==0){
      return 6 ;
    }
    else if(number.compareTo("K")==0){
      return 7 ;
    }
    else if(number.compareTo("A")==0){
      return 8 ;
    }
    else {
      return-1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cardgame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var trump : String ; trump := sc.nextLine() ;
    var s : String ; s := sc.nextLine() ;
    var arr : Sequence(String) ; arr := s->split("") ;
    var value1 : int ; value1 := value(arr[0+1]) ;
    var value2 : int ; value2 := value(arr[3+1]) ;
    if (arr[1+1]->compareTo(trump) = 0 & arr[4+1]->compareTo(trump) /= 0) then (     OclFile["System.out"].println("YES") ; 
 OclProcess.exit(0) ) else     if (arr[1+1]->compareTo(trump) /= 0 & arr[4+1]->compareTo(trump) = 0) then (     OclFile["System.out"].println("NO") ; 
 OclProcess.exit(0) ) else     if (arr[1+1]->compareTo(arr[4+1]) = 0) then (     if (value1 > value2) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else (     OclFile["System.out"].println("NO") ) ;  ;  ;  
 );
  static   operation value( number : String) : int
  pre: true
  post: true
  activity: (     if (number->compareTo("6") = 0) then (     return 0 ) else     if (number->compareTo("7") = 0) then (     return 1 ) else     if (number->compareTo("8") = 0) then (     return 2 ) else     if (number->compareTo("9") = 0) then (     return 3 ) else     if (number->compareTo("T") = 0) then (     return 4 ) else     if (number->compareTo("J") = 0) then (     return 5 ) else     if (number->compareTo("Q") = 0) then (     return 6 ) else     if (number->compareTo("K") = 0) then (     return 7 ) else     if (number->compareTo("A") = 0) then (     return 8 ) else (     return -1 ) ;  ;  ;  ;  ;  ;  ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Ideone {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    char trump=sc.next().charAt(0);
    HashMap<Character,Integer>m=new HashMap<>();
    m.put('6',1);
    m.put('7',2);
    m.put('8',3);
    m.put('9',4);
    m.put('T',5);
    m.put('J',6);
    m.put('Q',7);
    m.put('K',9);
    m.put('A',10);
    boolean beat=false ;
    String s1=sc.next();
    String s2=sc.next();
    if(s1.charAt(1)==trump){
      if(s2.charAt(1)!=trump || s1.charAt(1)==trump &&(m.get(s1.charAt(0))>m.get(s2.charAt(0))))beat=true ;
      else beat=false ;
    }
    else if(s1.charAt(1)==trump)beat=false ;
    else if(s1.charAt(1)==s2.charAt(1)&&(m.get(s1.charAt(0))>m.get(s2.charAt(0))))beat=true ;
    else beat=false ;
    if(beat)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ideone {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var trump : String ; trump := sc.getCurrent()->at(0+1) ;
    var m : Map(String,int) ; m := Map{} ;
    m := m->union(Map{'6' |-> 1}) ; 
    m := m->union(Map{'7' |-> 2}) ; 
    m := m->union(Map{'8' |-> 3}) ; 
    m := m->union(Map{'9' |-> 4}) ; 
    m := m->union(Map{'T' |-> 5}) ; 
    m := m->union(Map{'J' |-> 6}) ; 
    m := m->union(Map{'Q' |-> 7}) ; 
    m := m->union(Map{'K' |-> 9}) ; 
    m := m->union(Map{'A' |-> 10}) ; 
    var beat : boolean ; beat := false ;
    var s1 : String ; s1 := sc.getCurrent() ;
    var s2 : String ; s2 := sc.getCurrent() ;
    if (s1->at(1+1) = trump) then (     if (s2->at(1+1) /= trump or s1->at(1+1) = trump & (m->at(s1->at(0+1)) > m->at(s2->at(0+1)))) then     beat := true ; else     beat := false ; ) else     if (s1->at(1+1) = trump) then     beat := false else     if (s1->at(1+1) = s2->at(1+1) & (m->at(s1->at(0+1)) > m->at(s2->at(0+1)))) then     beat := true else     beat := false ; ;  ;  ;  
    if (beat) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Iterator ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
public class CodeforcesProblems {
  static int getRank(char ch){
    String rank="6789TJQKA" ;
    for(int i=0 ; i<rank.length(); i++){
      if(rank.charAt(i)==ch){
        return i ;
      }
    }
    return 0 ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    char s=br.readLine().charAt(0);
    String[] inputs=br.readLine().split(" ");
    char fi=inputs[0] .charAt(0);
    char se=inputs[1] .charAt(0);
    char s1=inputs[0] .charAt(1);
    char s2=inputs[1] .charAt(1);
    if(s1!=s2){
      if(s1==s)System.out.println("YES");
      else System.out.println("NO");
      return ;
    }
    int x=getRank(fi);
    int y=getRank(se);
    if(x>y)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeforcesProblems {
  static   operation getRank( ch : String) : int
  pre: true
  post: true
  activity: (     var rank : String ; rank := "6789TJQKA" ;
         var i : int ; i := 0 ; while i < rank->size() do ( (     if (rank->at(i+1) = ch) then (     return i ) else skip )  ;     i := i + 1 ) ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := br.readLine()->at(0+1) ;
    var inputs : Sequence(String) ; inputs := br.readLine()->split(" ") ;
    var fi : String ; fi := inputs[0+1]->at(0+1) ;
    var se : String ; se := inputs[1+1]->at(0+1) ;
    var s1 : String ; s1 := inputs[0+1]->at(1+1) ;
    var s2 : String ; s2 := inputs[1+1]->at(1+1) ;
    if (s1 /= s2) then (     if (s1 = s) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
     return ) else skip ; 
    var x : int ; x := getRank(fi) ;
    var y : int ; y := getRank(se) ;
    if (x > y) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication97 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String result="" ;
    char m=s.charAt(0);
    for(int i=0 ; i<s.length(); i++){
      m=(char)Math.max((int)s.charAt(i),(int)m);
    }
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)==m){
        result+=m ;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication97 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var result : String ; result := "" ;
    var m : String ; m := s->at(0+1) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     m := Set{s->at(i+1)->oclAsType(int), (m)->char2byte()}->max()->oclAsType(String) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = m) then (     result := result+(m) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String order="6789TJQKA",suit="SHDC",ch=sc.next(),s1=sc.next(),s2=sc.next();
    if(s1.charAt(1)==ch.charAt(0)&& s2.charAt(1)!=ch.charAt(0))System.out.println("YES");
    else if(s1.charAt(1)==s2.charAt(1)){
      if(order.indexOf(s1.charAt(0))>order.indexOf(s2.charAt(0)))System.out.println("YES");
      else System.out.println("NO");
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var order : String ; order := "6789TJQKA" ;
    var suit : String ; suit := "SHDC" ;
    var ch : String ; ch := sc.getCurrent() ;
    var s1 : String ; s1 := sc.getCurrent() ;
    var s2 : String ; s2 := sc.getCurrent() ;
     if (s1->at(1+1) = ch->at(0+1) & s2->at(1+1) /= ch->at(0+1)) then     OclFile["System.out"].println("YES") ; else     if (s1->at(1+1) = s2->at(1+1)) then (     if (order->indexOf(s1->at(0+1))-1 > order->indexOf(s2->at(0+1))-1) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) else     OclFile["System.out"].println("NO") ; ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Pair {
  int first,second ;
  Pair(int a,int b){
    first=a ;
    second=b ;
  }
}
public class GFG {
  static ArrayList<Pair>findSubArrays(int[] arr,int n){
    HashMap<Integer,ArrayList<Integer>>map=new HashMap<>();
    ArrayList<Pair>out=new ArrayList<>();
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=arr[i];
      if(sum==0)out.add(new Pair(0,i));
      ArrayList<Integer>al=new ArrayList<>();
      if(map.containsKey(sum)){
        al=map.get(sum);
        for(int it=0 ; it<al.size(); it++){
          out.add(new Pair(al.get(it)+1,i));
        }
      }
      al.add(i);
      map.put(sum,al);
    }
    return out ;
  }
  static void print(ArrayList<Pair>out){
    for(int i=0 ; i<out.size(); i++){
      Pair p=out.get(i);
      System.out.println("Subarray found from Index "+p.first+" to "+p.second);
    }
  }
  public static void main(String args[]){
    int[] arr={
      6,3,-1,-3,4,-2,2,4,6,-12,-7 };
      int n=arr.length ;
      ArrayList<Pair>out=findSubArrays(arr,n);
      if(out.size()==0)System.out.println("No subarray exists");
      else print(out);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Pair {
   attribute first : int;
   static operation newPair( a : int, b : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     first := a ; 
     second := b );
}
class GFG {
  static   operation findSubArrays( arr : Sequence(int), n : int) : Sequence(Map)
  pre: true
  post: true
  activity: (     var map : Map(int,Sequence(int)) ; map := Map{} ;
     var out : Sequence(Map) ; out := Sequence{} ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(arr[i+1]) ; 
     if (sum = 0) then     out := out->including(Map(0, i)) ; else skip ; 
    var al : Sequence(int) ; al := Sequence{} ;
    if (map->keys()->includes(sum)) then (     al := map->at(sum) ; 
         var it : int ; it := 0 ; while it < al->size() do ( (     out := out->including(Map(al->at(it+1) + 1, i)) )  ;     it := it + 1 ) ) else skip ; 
    al := al->including(i) ; 
    map := map->union(Map{sum |-> al}) ; 
 )  ;     i := i + 1 ) ; 
    return out 
 );
  static   operation print( out : Sequence(Map)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < out->size() do ( (     var p : Map ; p := out->at(i+1) ;
     OclFile["System.out"].println("Subarray found from Index " + p->at("first") + " to " + p->at("second")) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,3,-1,-3,4,-2,2,4,6,-12,-7} ;
     var n : int ; n := arr->size() ;
     var out : Sequence(Map) ; out := findSubArrays(arr, n) ;
     if (out->size() = 0) then     OclFile["System.out"].println("No subarray exists") ; else     execute print(out) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int NORTH=0 ;
  int EAST=1 ;
  int SOUTH=2 ;
  int WEST=3 ;
  int[] dx={
    0,1,0,-1 };
    int[] dy={
      1,0,-1,0 };
      void run(){
        Scanner sc=new Scanner(System.in);
        while(true){
          int w=sc.nextInt();
          int h=sc.nextInt();
          if(w==0 && h==0){
            break ;
          }
          int[][] field=new int[h][w];
          int direction=NORTH ;
          int x=0 ;
          int y=0 ;
          while(true){
            String command=sc.next();
            if(command.equals("STOP")){
              break ;
            }
            if(command.equals("FORWARD")){
              int n=sc.nextInt();
              for(int i=0 ; i<n ; i++){
                int nx=x+dx[direction];
                int ny=y+dy[direction];
                if(nx<0 || nx>=w || ny<0 || ny>=h){
                  break ;
                }
                x=nx ;
                y=ny ;
              }
            }
            if(command.equals("BACKWARD")){
              int n=sc.nextInt();
              for(int i=0 ; i<n ; i++){
                int nx=x-dx[direction];
                int ny=y-dy[direction];
                if(nx<0 || nx>=w || ny<0 || ny>=h){
                  break ;
                }
                x=nx ;
                y=ny ;
              }
            }
            if(command.equals("RIGHT")){
              direction=(direction+1)% 4 ;
            }
            if(command.equals("LEFT")){
              direction=(direction+3)% 4 ;
            }
          }
          x+=1 ;
          y+=1 ;
          System.out.println(x+" "+y);
        }
      }
      public static void main(String[] args){
        new Main().run();
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute NORTH : int := 0;
   attribute EAST : int := 1;
   attribute SOUTH : int := 2;
   attribute WEST : int := 3;
   attribute dx : Sequence(int) := Sequence{0,1,0,-1};
   attribute dy : Sequence(int) := Sequence{1,0,-1,0};
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var w : int ; w := sc.getCurrent()->toInteger() ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    if (w = 0 & h = 0) then (     break ) else skip ; 
    var field : Sequence(Sequence(int)) ; field := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    var direction : int ; direction := NORTH ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    while (true) do (     var command : String ; command := sc.getCurrent() ;
     if (command = "STOP") then (     break ) else skip ; 
    if (command = "FORWARD") then (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var nx : int ; nx := x + dx[direction+1] ;
     var ny : int ; ny := y + dy[direction+1] ;
    if (nx < 0 or nx >= w or ny < 0 or ny >= h) then (     break ) else skip ; 
    x := nx ; 
    y := ny ; 
 )  ;     i := i + 1 ) ) else skip ; 
    if (command = "BACKWARD") then (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var nx : int ; nx := x - dx[direction+1] ;
     var ny : int ; ny := y - dy[direction+1] ;
    if (nx < 0 or nx >= w or ny < 0 or ny >= h) then (     break ) else skip ; 
    x := nx ; 
    y := ny ; 
 )  ;     i := i + 1 ) ) else skip ; 
    if (command = "RIGHT") then (     direction := (direction + 1) mod 4 ) else skip ; 
    if (command = "LEFT") then (     direction := (direction + 3) mod 4 ) else skip ; 
 ) ; 
    x := x+(1) ; 
    y := y+(1) ; 
    OclFile["System.out"].println(x + " " + y) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static long productPrimeFactors(int n){
    long product=1 ;
    for(int i=2 ; i<=n ; i++){
      if(n % i==0){
        boolean isPrime=true ;
        for(int j=2 ; j<=i/2 ; j++){
          if(i % j==0){
            isPrime=false ;
            break ;
          }
        }
        if(isPrime){
          product=product*i ;
        }
      }
    }
    return product ;
  }
  public static void main(String[] args){
    int n=44 ;
    System.out.print(productPrimeFactors(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation productPrimeFactors( n : int) : long
  pre: true
  post: true
  activity: (     var product : long ; product := 1 ;
         var i : int ; i := 2 ; while i <= n do ( (     if (n mod i = 0) then (     var isPrime : boolean ; isPrime := true ;
         var j : int ; j := 2 ; while j <= i / 2 do ( (     if (i mod j = 0) then (     isPrime := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (isPrime) then (     product := product * i ) else skip ) else skip )  ;     i := i + 1 ) ; 
     return product );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 44 ;
     OclFile["System.out"].print(productPrimeFactors(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class NDN {
  static int countNonDecreasing(int n){
    int dp[][]=new int[10][n+1];
    for(int i=0 ; i<10 ; i++)dp[i][1]=1 ;
    for(int digit=0 ; digit<=9 ; digit++){
      for(int len=2 ; len<=n ; len++){
        for(int x=0 ; x<=digit ; x++)dp[digit][len]+=dp[x][len-1];
      }
    }
    int count=0 ;
    for(int i=0 ; i<10 ; i++)count+=dp[i][n];
    return count ;
  }
  public static void main(String args[]){
    int n=3 ;
    System.out.println(countNonDecreasing(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class NDN {
  static   operation countNonDecreasing( n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,10)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i < 10 do (     dp[i+1][1+1] := 1 ;  ;     i := i + 1 ) ; 
        var digit : int ; digit := 0 ; while digit <= 9 do ( (         var len : int ; len := 2 ; while len <= n do ( (         var x : int ; x := 0 ; while x <= digit do (     dp[digit+1][len+1] := dp[digit+1][len+1]+(dp[x+1][len - 1+1]) ;  ;     x := x + 1 ) )  ;     len := len + 1 ) )  ;     digit := digit + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < 10 do (     count := count+(dp[i+1][n+1]) ;  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(countNonDecreasing(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] $){
    int n=scanner.nextInt();
    List<Integer>[] edge=new ArrayList[n];
    for(int i=0 ; i<n ; i++){
      edge[i]=new ArrayList<>();
    }
    for(int i=1 ; i<n ; i++){
      int a=scanner.nextInt()-1 ;
      int b=scanner.nextInt()-1 ;
      edge[a] .add(b);
      edge[b] .add(a);
    }
    Deque<Integer>deque=new ArrayDeque<>();
    deque.add(0);
    int[] dist1=new int[n];
    boolean[] visited1=new boolean[n];
    while(! deque.isEmpty()){
      int i=deque.poll();
      for(int j : edge[i]){
        if(! visited1[j]){
          visited1[j]=true ;
          dist1[j]=dist1[i]+1 ;
          deque.add(j);
        }
      }
    }
    deque.add(n-1);
    int[] dist2=new int[n];
    boolean[] visited2=new boolean[n];
    while(! deque.isEmpty()){
      int i=deque.poll();
      for(int j : edge[i]){
        if(! visited2[j]){
          visited2[j]=true ;
          dist2[j]=dist2[i]+1 ;
          deque.add(j);
        }
      }
    }
    int count1=0 ;
    int count2=0 ;
    for(int i=0 ; i<n ; i++){
      if(dist1[i]<=dist2[i]){
        count1++;
      }
      else {
        count2++;
      }
    }
    System.out.println(count1>count2 ? "Fennec" : "Snuke");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var edge : Sequence(Sequence(int)) ; edge := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     edge[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     var a : int ; a := scanner.getCurrent()->toInteger() - 1 ;
     var b : int ; b := scanner.getCurrent()->toInteger() - 1 ;
     edge[a+1]->excludes(b) ; 
     edge[b+1]->excludes(a) )  ;     i := i + 1 ) ; 
    var deque : Sequence(int) ; deque := ArrayDeque<OclAny>.newArrayDeque() ;
    deque := deque->including(0) ; 
    var dist1 : Sequence(int) ; dist1 := Integer.subrange(1,n)->collect(0) ;
    var visited1 : Sequence(boolean) ; visited1 := Integer.subrange(1,n)->collect(false) ;
    while (not(deque->isEmpty())) do (     var i : int ; i := deque->min() ;
     for (j : edge[i+1]) do ( (     if (not(visited1[j+1])) then (     visited1[j+1] := true ; 
     dist1[j+1] := dist1[i+1] + 1 ; 
     deque := deque->including(j) ) else skip )  ) ) ; 
    deque := deque->including(n - 1) ; 
    var dist2 : Sequence(int) ; dist2 := Integer.subrange(1,n)->collect(0) ;
    var visited2 : Sequence(boolean) ; visited2 := Integer.subrange(1,n)->collect(false) ;
    while (not(deque->isEmpty())) do (     var i : int ; i := deque->min() ;
     for (j : edge[i+1]) do ( (     if (not(visited2[j+1])) then (     visited2[j+1] := true ; 
     dist2[j+1] := dist2[i+1] + 1 ; 
     deque := deque->including(j) ) else skip )  ) ) ; 
    var count1 : int ; count1 := 0 ;
    var count2 : int ; count2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (dist1[i+1] <= dist2[i+1]) then (     count1 := count1 + 1 ) else (     count2 := count2 + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if count1 > count2 then "Fennec" else "Snuke" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    arc078_b solver=new arc078_b();
    solver.solve(1,in,out);
    out.close();
  }
  static class arc078_b {
    Node[] nodes ;
    public void solve(int testNumber,Scanner s,PrintWriter out){
      int N=s.nextInt();
      nodes=new Node[N];
      for(int i=0 ; i<N ; i++)nodes[i]=new Node();
      for(int i=1 ; i<N ; i++){
        int x=s.nextInt()-1,y=s.nextInt()-1 ;
        nodes[x] .adj.add(nodes[y]);
        nodes[y] .adj.add(nodes[x]);
      }
      int black=0,white=0 ;
      ArrayList<Node>queue=new ArrayList<>();
      nodes[0] .color=1 ;
      queue.add(nodes[0]);
      nodes[N-1] .color=2 ;
      queue.add(nodes[N-1]);
      while(queue.size()>0){
        int k=queue.size();
        while(k-->0){
          Node cur=queue.remove(0);
          for(Node n : cur.adj){
            if(n.color==0){
              n.color=cur.color ;
              queue.add(n);
            }
          }
        }
      }
      for(Node n : nodes)if(n.color==1)black++;
      else white++;
      out.println((black>white)? "Fennec" : "Snuke");
    }
    private class Node {
      int color=0 ;
      ArrayList<Node>adj=new ArrayList<Node>();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : arc078_b ; solver := arc078_b.newarc078_b() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class arc078_b {
   attribute nodes : Sequence(Node);
   operation solve( testNumber : int, s : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := s.nextInt() ;
     nodes := Integer.subrange(1,N)->collect(null) ; 
        var i : int ; i := 0 ; while i < N do (     nodes[i+1] := Node.newNode() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < N do ( (     var x : int ; x := s.nextInt() - 1 ;
    var y : int ; y := s.nextInt() - 1 ;
     nodes[x+1].adj->excludes(nodes[y+1]) ; 
     nodes[y+1].adj->excludes(nodes[x+1]) )  ;     i := i + 1 ) ; 
    var black : int ; black := 0 ;
    var white : int ; white := 0 ;
    var queue : Sequence(Node) ; queue := Sequence{} ;
    nodes[0+1].color := 1 ; 
    queue := queue->including(nodes[0+1]) ; 
    nodes[N - 1+1].color := 2 ; 
    queue := queue->including(nodes[N - 1+1]) ; 
    while (queue->size() > 0) do (     var k : int ; k := queue->size() ;
         while (k > 0) do (        k := k - 1 ;     skip ; (     var cur : Node ; cur := queue->at(0+1) ;
     for (n : cur.adj) do ( (     if (n.color = 0) then (     n.color := cur.color ; 
     queue := queue->including(n) ) else skip )  ) ) ;  ) ) ; 
    for (n : nodes) do (     if (n.color = 1) then     black := black + 1 else     white := white + 1 ; ;   ) ; 
    skip ; 
 );
 class Node {
   attribute color : int := 0;
   attribute adj : Sequence(Node) := Sequence{};
}
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public int[][] dist ;
  public LinkedList<Integer>[] node ;
  void run(){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    node=new LinkedList[n];
    for(int i=0 ; i<n ; i++)node[i]=new LinkedList<Integer>();
    dist=new int[2][n];
    for(int i=0 ; i<n-1 ; i++){
      int a=scan.nextInt();
      int b=scan.nextInt();
      node[a-1] .add(b-1);
      node[b-1] .add(a-1);
    }
    dfs(0,0,-1);
    dfs(1,n-1,-1);
    int black=0 ;
    for(int i=0 ; i<n ; i++){
      if(dist[0][i]<=dist[1][i])black++;
    }
    if(black>n/2)System.out.println("Fennec");
    else System.out.println("Snuke");
  }
  void dfs(int id,int current,int prev){
    if(prev!=-1)dist[id][current]=dist[id][prev]+1 ;
    for(int i=0 ; i<node[current] .size(); i++){
      int next=node[current] .get(i);
      if(next!=prev)dfs(id,next,current);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute dist : Sequence(Sequence(int));
   attribute node : Sequence(Sequence(int));
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    node := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do (     node[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
    dist := Integer.subrange(1,2)->collect(Integer.subrange(1,n)->collect(0)) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var a : int ; a := scan.getCurrent()->toInteger() ;
     var b : int ; b := scan.getCurrent()->toInteger() ;
     node[a - 1+1]->excludes(b - 1) ; 
     node[b - 1+1]->excludes(a - 1) )  ;     i := i + 1 ) ; 
    execute dfs(0, 0, -1) ; 
    execute dfs(1, n - 1, -1) ; 
    var black : int ; black := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (dist[0+1][i+1] <= dist[1+1][i+1]) then     black := black + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (black > n / 2) then     OclFile["System.out"].println("Fennec") else     OclFile["System.out"].println("Snuke") ; ;  
 );
   operation dfs( id : int, current : int, prev : int) : void
  pre: true
  post: true
  activity: (     if (prev /= -1) then     dist[id+1][current+1] := dist[id+1][prev+1] + 1 ; else skip ; 
         var i : int ; i := 0 ; while i < node[current+1]->size() do ( (     var next : int ; next := node[current+1]->at(i+1) ;
     if (next /= prev) then     execute dfs(id, next, current) ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int N=100010 ;
  static int[] id=new int[100010];
  static int[] sz=new int[100010];
  static int Root(int idx){
    int i=idx ;
    while(i!=id[i]){
      id[i]=id[id[i] ];
      i=id[i];
    }
    return i ;
  }
  static void Union(int a,int b){
    int i=Root(a);
    int j=Root(b);
    if(i!=j){
      if(sz[i]>=sz[j]){
        id[j]=i ;
        sz[i]+=sz[j];
        sz[j]=0 ;
      }
      else {
        id[i]=j ;
        sz[j]+=sz[i];
        sz[i]=0 ;
      }
    }
  }
  static int minChange(int n,int a[],int b[]){
    for(int i=0 ; i<N ; i++){
      id[i]=i ;
      sz[i]=1 ;
    }
    for(int i=0 ; i<n ; ++i)if(Root(a[i])!=Root(b[i]))Union(a[i],b[i]);
    int ans=0 ;
    for(int i=0 ; i<n ; ++i)if(id[i]==i)ans+=(sz[i]-1);
    return ans ;
  }
  public static void main(String[] args){
    int a[]={
      2,1,1,3,5 },b[]={
        1,2,2,4,5 };
        int n=a.length ;
        System.out.println(minChange(n,a,b));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 100010;
  static   attribute id : Sequence(int) := Integer.subrange(1,100010)->collect(0);
  static   attribute sz : Sequence(int) := Integer.subrange(1,100010)->collect(0);
  static   operation Root( idx : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := idx ;
     while (i /= id[i+1]) do (     id[i+1] := id[id[i+1]+1] ; 
     i := id[i+1] ) ; 
     return i );
  static   operation Union( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := Root(a) ;
     var j : int ; j := Root(b) ;
     if (i /= j) then (     if (sz[i+1] >= sz[j+1]) then (     id[j+1] := i ; 
     sz[i+1] := sz[i+1]+(sz[j+1]) ; 
     sz[j+1] := 0 ) else (     id[i+1] := j ; 
     sz[j+1] := sz[j+1]+(sz[i+1]) ; 
     sz[i+1] := 0 ) ) else skip );
  static   operation minChange( n : int, a : Sequence(int), b : Sequence(int)) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do ( (     id[i+1] := i ; 
     sz[i+1] := 1 )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do (     if (Root(a[i+1]) /= Root(b[i+1])) then     execute Union(a[i+1], b[i+1]) ; else skip ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (id[i+1] = i) then     ans := ans+((sz[i+1] - 1)) ; else skip ;  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,1,1,3,5} ;
    var b : Sequence(void) ; b := Sequence{1,2,2,4,5} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(minChange(n, a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.*;
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt(),k=sc.nextInt();
      int[] arr=new int[n+1];
      for(int i=1 ; i<=n ; i++)arr[i]=sc.nextInt();
      boolean[] peak=new boolean[n+1];
      for(int i=2 ; i<n ; i++){
        if(arr[i]>arr[i-1] && arr[i]>arr[i+1])peak[i]=true ;
      }
      int count=0 ;
      for(int i=2 ; i<k ; i++){
        if(peak[i])count++;
      }
      int max=count ;
      int l=1 ;
      int L=2,R=k+1 ;
      while(R<=n){
        if(peak[L])count--;
        if(peak[R-1])count++;
        if(count>max){
          max=count ;
          l=L ;
        }
        R++;
        L++;
      }
      sb.append((max+1)+" "+l+"\n");
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var peak : Sequence(boolean) ; peak := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 2 ; while i < n do ( (     if (arr[i+1] > arr[i - 1+1] & arr[i+1] > arr[i + 1+1]) then     peak[i+1] := true ; else skip )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 2 ; while i < k do ( (     if (peak[i+1]) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    var max : int ; max := count ;
    var l : int ; l := 1 ;
    var L : int ; L := 2 ;
    var R : int ; R := k + 1 ;
    while (R <= n) do (     if (peak[L+1]) then     count := count - 1 ; else skip ; 
     if (peak[R - 1+1]) then     count := count + 1 ; else skip ; 
    if (count > max) then (     max := count ; 
     l := L ) else skip ; 
    R := R + 1 ; 
    L := L + 1 ; 
 ) ; 
    sb := sb + StringLib.newString((max + 1) + " " + l + "\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class NasthyaAndDoor {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int t=scn.nextInt();
    while(t-->0){
      int n=scn.nextInt();
      int k=scn.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=scn.nextInt();
      }
      int peaks=0 ;
      for(int i=1 ; i<k-1 ; i++){
        if(arr[i]>arr[i-1] && arr[i]>arr[i+1]){
          peaks++;
        }
      }
      int maxPeaks=peaks ;
      int idx=0 ;
      int l=0 ;
      int r=k-1 ;
      while(r<=n-2){
        if(arr[r]>arr[r-1] && arr[r]>arr[r+1]){
          peaks++;
        }
        r++;
        l++;
        if(arr[l]>arr[l-1] && arr[l]>arr[l+1]){
          peaks--;
        }
        if(peaks>maxPeaks){
          idx=l ;
          maxPeaks=peaks ;
        }
      }
      System.out.println(maxPeaks+1+" "+(idx+1));
    }
    scn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class NasthyaAndDoor {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scn.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scn.getCurrent()->toInteger() ;
     var k : int ; k := scn.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var peaks : int ; peaks := 0 ;
        var i : int ; i := 1 ; while i < k - 1 do ( (     if (arr[i+1] > arr[i - 1+1] & arr[i+1] > arr[i + 1+1]) then (     peaks := peaks + 1 ) else skip )  ;     i := i + 1 ) ; 
    var maxPeaks : int ; maxPeaks := peaks ;
    var idx : int ; idx := 0 ;
    var l : int ; l := 0 ;
    var r : int ; r := k - 1 ;
    while (r <= n - 2) do (     if (arr[r+1] > arr[r - 1+1] & arr[r+1] > arr[r + 1+1]) then (     peaks := peaks + 1 ) else skip ; 
     r := r + 1 ; 
    l := l + 1 ; 
    if (arr[l+1] > arr[l - 1+1] & arr[l+1] > arr[l + 1+1]) then (     peaks := peaks - 1 ) else skip ; 
    if (peaks > maxPeaks) then (     idx := l ; 
     maxPeaks := peaks ) else skip ; 
 ) ; 
    OclFile["System.out"].println(maxPeaks + 1 + " " + (idx + 1)) ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class B {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int T=sc.nextInt();
    for(int i=1 ; i<=T ; ++i){
      System.out.print("Case #"+i+": ");
      System.out.printf("%.9f\n",solve());
    }
  }
  static double solve(){
    int N=sc.nextInt();
    int K=sc.nextInt();
    double[] Pt=new double[N];
    for(int i=0 ; i<N ; ++i){
      Pt[i]=sc.nextDouble();
    }
    Arrays.sort(Pt);
    double[] P=new double[K];
    double ans=0 ;
    for(int u=0 ; u<=K ; ++u){
      for(int i=0 ; i<u ; ++i){
        P[i]=Pt[i];
      }
      for(int i=u ; i<K ; ++i){
        P[i]=Pt[N-1-(i-u)];
      }
      double[][] dp=new double[K+1][K+1];
      dp[0][0]=1 ;
      for(int i=1 ; i<=K ; ++i){
        for(int j=0 ; j<=i ; ++j){
          if(j==0){
            dp[i][j]=Math.max(dp[i][j],dp[i-1][j]*(1-P[i-1]));
          }
          else {
            dp[i][j]=Math.max(dp[i][j],dp[i-1][j]*(1-P[i-1])+dp[i-1][j-1]*P[i-1]);
          }
        }
      }
      ans=Math.max(ans,dp[K][K/2]);
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= T do ( (     OclFile["System.out"].print("Case #" + i + ": ") ; 
     OclFile["System.out"].printf("%.9f\n", solve()) )  ;     i := i + 1 ) );
  static   operation solve() : double
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    var Pt : Sequence(double) ; Pt := Integer.subrange(1,N)->collect(0.0) ;
        var i : int ; i := 0 ; while i < N do ( (     Pt[i+1] := sc.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
    Pt := Pt->sort() ; 
    var P : Sequence(double) ; P := Integer.subrange(1,K)->collect(0.0) ;
    var ans : double ; ans := 0 ;
        var u : int ; u := 0 ; while u <= K do ( (         var i : int ; i := 0 ; while i < u do ( (     P[i+1] := Pt[i+1] )  ;     i := i + 1 ) ; 
         var i : int ; i := u ; while i < K do ( (     P[i+1] := Pt[N - 1 - (i - u)+1] )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(double)) ; dp := Integer.subrange(1,K + 1)->collect(Integer.subrange(1,K + 1)->collect(0.0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= K do ( (         var j : int ; j := 0 ; while j <= i do ( (     if (j = 0) then (     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i - 1+1][j+1] * (1 - P[i - 1+1])}->max() ) else (     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i - 1+1][j+1] * (1 - P[i - 1+1]) + dp[i - 1+1][j - 1+1] * P[i - 1+1]}->max() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    ans := Set{ans, dp[K+1][K / 2+1]}->max() ; 
 )  ;     u := u + 1 ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class training {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String s=scanner.next();
    String s1="" ;
    for(char ch : s.toCharArray()){
      if(s1=="" || ch>s1.charAt(0)){
        s1="" ;
        s1+=ch ;
      }
      else if(ch==s1.charAt(0)){
        s1+=ch ;
      }
    }
    System.out.println(s1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class training {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scanner.getCurrent() ;
    var s1 : String ; s1 := "" ;
    for (ch : s->characters()) do ( (     if (s1 = "" or ch > s1->at(0+1)) then (     s1 := "" ; 
     s1 := s1+(ch) ) else     if (ch = s1->at(0+1)) then (     s1 := s1+(ch) ) else skip ; )  ) ; 
    OclFile["System.out"].println(s1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Worms_Evolution {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scn.nextInt();
    }
    boolean f=false ;
    A : for(int i=0 ;
    i<n ;
    i++){
      for(int j=0 ; j<n ; j++){
        if(i!=j){
          for(int z=0 ; z<n ; z++){
            if(a[i]==a[j]+a[z] && z!=i && z!=j){
              System.out.println((i+1)+" "+(j+1)+" "+(z+1));
              f=true ;
              break A ;
            }
          }
        }
      }
    }
    if(! f)System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Worms_Evolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var f : boolean ; f := false ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (i /= j) then (         var z : int ; z := 0 ; while z < n do ( (     if (a[i+1] = a[j+1] + a[z+1] & z /= i & z /= j) then (     OclFile["System.out"].println((i + 1) + " " + (j + 1) + " " + (z + 1)) ; 
     f := true ; 
     break ) else skip )  ;     z := z + 1 ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (not(f)) then     OclFile["System.out"].println(-1) ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int LISusingLCS(Vector<Integer>seq){
    int n=seq.size();
    int L[][]=new int[n+1][n+1];
    Vector<Integer>sortedseq=new Vector<Integer>(seq);
    Collections.sort(sortedseq);
    for(int i=0 ; i<=n ; i++){
      for(int j=0 ; j<=n ; j++){
        if(i==0 || j==0)L[i][j]=0 ;
        else if(seq.get(i-1)==sortedseq.get(j-1))L[i][j]=L[i-1][j-1]+1 ;
        else L[i][j]=Math.max(L[i-1][j],L[i][j-1]);
      }
    }
    return L[n][n];
  }
  public static void main(String args[]){
    Vector<Integer>sequence=new Vector<Integer>();
    sequence.add(12);
    sequence.add(34);
    sequence.add(1);
    sequence.add(5);
    sequence.add(40);
    sequence.add(80);
    System.out.println(LISusingLCS(sequence));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation LISusingLCS( seq : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := seq->size() ;
     var L : Sequence(Sequence(int)) ; L := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
    var sortedseq : Sequence(int) ; sortedseq := Sequence{}->union(seq) ;
    sortedseq := sortedseq->sort() ; 
        var i : int ; i := 0 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= n do ( (     if (i = 0 or j = 0) then     L[i+1][j+1] := 0 ; else     if (seq->at(i - 1+1) = sortedseq->at(j - 1+1)) then     L[i+1][j+1] := L[i - 1+1][j - 1+1] + 1 else     L[i+1][j+1] := Set{L[i - 1+1][j+1], L[i+1][j - 1+1]}->max() ; ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return L[n+1][n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sequence : Sequence(int) ; sequence := Sequence{} ;
     sequence := sequence->including(12) ; 
    sequence := sequence->including(34) ; 
    sequence := sequence->including(1) ; 
    sequence := sequence->including(5) ; 
    sequence := sequence->including(40) ; 
    sequence := sequence->including(80) ; 
    OclFile["System.out"].println(LISusingLCS(sequence)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=50 ;
  static void solveQuery(int n,int q,int qi[],int qj[]){
    int[] arr=new int[MAX];
    for(int i=0 ; i<=n ; i++)arr[i]=0 ;
    for(int k=0 ; k<q ; k++){
      int flag=0 ;
      if(qj[k]<qi[k]){
        int temp=qi[k];
        qi[k]=qj[k];
        qj[k]=temp ;
      }
      if(arr[qi[k] ]!=0 || arr[qj[k] ]!=0)flag=1 ;
      else if(qi[k]==qj[k])flag=1 ;
      else {
        for(int i=1 ; i<qi[k]; i++){
          if(arr[i]!=0 && arr[i]<qj[k] && qi[k]<arr[i]){
            flag=1 ;
            break ;
          }
        }
        if(flag==0){
          for(int i=qi[k]+1 ; i<qj[k]; i++){
            if(arr[i]!=0 && arr[i]>qj[k]){
              flag=1 ;
              break ;
            }
          }
        }
      }
      if(flag==0){
        System.out.println("YES");
        arr[qi[k] ]=qj[k];
        arr[qj[k] ]=qi[k];
      }
      else System.out.println("NO");
    }
  }
  public static void main(String[] args){
    int n=10 ;
    int q=7 ;
    int qi[]={
      1,2,2,2,9,10,8 };
      int qj[]={
        5,7,3,4,9,9,6 };
        solveQuery(n,q,qi,qj);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 50;
  static   operation solveQuery( n : int, q : int, qi : Sequence(int), qj : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,MAX)->collect(0) ;
         var i : int ; i := 0 ; while i <= n do (     arr[i+1] := 0 ;  ;     i := i + 1 ) ; 
         var k : int ; k := 0 ; while k < q do ( (     var flag : int ; flag := 0 ;
     if (qj[k+1] < qi[k+1]) then (     var temp : int ; temp := qi[k+1] ;
     qi[k+1] := qj[k+1] ; 
     qj[k+1] := temp ) else skip ; 
     if (arr[qi[k+1]+1] /= 0 or arr[qj[k+1]+1] /= 0) then     flag := 1 else     if (qi[k+1] = qj[k+1]) then     flag := 1 else (         var i : int ; i := 1 ; while i < qi[k+1] do ( (     if (arr[i+1] /= 0 & arr[i+1] < qj[k+1] & qi[k+1] < arr[i+1]) then (     flag := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (flag = 0) then (         var i : int ; i := qi[k+1] + 1 ; while i < qj[k+1] do ( (     if (arr[i+1] /= 0 & arr[i+1] > qj[k+1]) then (     flag := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ) else skip ) ;  ;  
     if (flag = 0) then (     OclFile["System.out"].println("YES") ; 
     arr[qi[k+1]+1] := qj[k+1] ; 
     arr[qj[k+1]+1] := qi[k+1] ) else     OclFile["System.out"].println("NO") ; )  ;     k := k + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     var q : int ; q := 7 ;
    var qi : Sequence(int) ; qi := Sequence{1,2,2,2,9,10,8} ;
    var qj : Sequence(int) ; qj := Sequence{5,7,3,4,9,9,6} ;
    execute solveQuery(n, q, qi, qj) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public final class p049 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p049().run());
  }
  private static final int LIMIT=10000 ;
  public String run(){
    boolean[] isPrime=Library.listPrimality(LIMIT-1);
    for(int base=1000 ; base<LIMIT ; base++){
      if(isPrime[base]){
        for(int step=1 ; step<LIMIT ; step++){
          int a=base+step ;
          int b=a+step ;
          if(a<LIMIT && isPrime[a] && hasSameDigits(a,base)&& b<LIMIT && isPrime[b] && hasSameDigits(b,base)&&(base!=1487 || a!=4817))return ""+base+a+b ;
        }
      }
    }
    throw new RuntimeException("Not found");
  }
  private static boolean hasSameDigits(int x,int y){
    char[] xdigits=Integer.toString(x).toCharArray();
    char[] ydigits=Integer.toString(y).toCharArray();
    Arrays.sort(xdigits);
    Arrays.sort(ydigits);
    return Arrays.equals(xdigits,ydigits);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p049 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p049.newp049().run()) );
  static    attribute LIMIT : int := 10000;
   operation run() : String
  pre: true
  post: true
  activity: (     var isPrime : Sequence(boolean) ; isPrime := Library.listPrimality(LIMIT - 1) ;
         var base : int ; base := 1000 ; while base < LIMIT do ( (     if (isPrime[base+1]) then (         var step : int ; step := 1 ; while step < LIMIT do ( (     var a : int ; a := base + step ;
     var b : int ; b := a + step ;
     if (a < LIMIT & isPrime[a+1] & hasSameDigits(a, base) & b < LIMIT & isPrime[b+1] & hasSameDigits(b, base) & (base /= 1487 or a /= 4817)) then     return "" + base + a + b else skip )  ;     step := step + 1 ) ) else skip )  ;     base := base + 1 ) ; 
     error ProgramException("Not found") );
  static   operation hasSameDigits( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     var xdigits : Sequence(String) ; xdigits := ((x) + "")->characters() ;
     var ydigits : Sequence(String) ; ydigits := ((y) + "")->characters() ;
    xdigits := xdigits->sort() ; 
    ydigits := ydigits->sort() ; 
    return xdigits = ydigits 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p315 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p315().run());
  }
  public String run(){
    boolean[] isPrime=Library.listPrimality(20000000);
    int sum=0 ;
    for(int i=10000000 ; i<isPrime.length ; i++){
      if(isPrime[i])sum+=samTransitionsMinusMaxTransitions(i);
    }
    return Integer.toString(sum);
  }
  private static int samTransitionsMinusMaxTransitions(int n){
    int samTrans=0 ;
    int maxTrans=0 ;
    long segmentState=0 ;
    while(true){
      long newState=numberToSegments(n);
      if(newState==segmentState)break ;
      maxTrans+=Long.bitCount(newState ^ segmentState);
      segmentState=newState ;
      samTrans+=2*Long.bitCount(newState);
      n=digitSum(n);
    }
    maxTrans+=Long.bitCount(segmentState);
    return samTrans-maxTrans ;
  }
  private static long numberToSegments(int n){
    if(n<0 || n>999999999)throw new IllegalArgumentException();
    long result=0 ;
    int i=0 ;
    do {
      result |=(long)DECIMAL_DIGIT_TO_SEGMENT[n % 10]<<(i*7);
      n/=10 ;
      i++;
    }
    while(n!=0);
    return result ;
  }
  private static int digitSum(int n){
    if(n<0)throw new IllegalArgumentException();
    int result=0 ;
    while(n!=0){
      result+=n % 10 ;
      n/=10 ;
    }
    return result ;
  }
  private static final int[] DECIMAL_DIGIT_TO_SEGMENT={
    0x77,0x12,0x5D,0x5B,0x3A,0x6B,0x6F,0x72,0x7F,0x7B };
  }

------------------------------------------------------------
OCL File:
---------
class p315 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p315.newp315().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var isPrime : Sequence(boolean) ; isPrime := Library.listPrimality(20000000) ;
     var sum : int ; sum := 0 ;
         var i : int ; i := 10000000 ; while i < isPrime->size() do ( (     if (isPrime[i+1]) then     sum := sum+(samTransitionsMinusMaxTransitions(i)) ; else skip )  ;     i := i + 1 ) ; 
     return ((sum) + "") );
  static   operation samTransitionsMinusMaxTransitions( n : int) : int
  pre: true
  post: true
  activity: (     var samTrans : int ; samTrans := 0 ;
     var maxTrans : int ; maxTrans := 0 ;
    var segmentState : long ; segmentState := 0 ;
    while (true) do (     var newState : long ; newState := numberToSegments(n) ;
     if (newState = segmentState) then     break else skip ; 
    maxTrans := maxTrans+(bitCount(MathLib.bitwiseXor(newState,segmentState))) ; 
    segmentState := newState ; 
    samTrans := samTrans+(2 * bitCount(newState)) ; 
    n := digitSum(n) ; 
 ) ; 
    maxTrans := maxTrans+(bitCount(segmentState)) ; 
    return samTrans - maxTrans 
 );
  static   operation numberToSegments( n : int) : long
  pre: true
  post: true
  activity: (     if (n < 0 or n > 999999999) then     error IllegalArgumentException.newIllegalArgumentException() ; else skip ; 
     var result : long ; result := 0 ;
    var i : int ; i := 0 ;
  while true do ((     result := MathLib.bitwiseOr(result, (DECIMAL_DIGIT_TO_SEGMENT[n mod 10+1]->oclAsType(long)*(2->pow((i * 7))))->oclAsType(long)) ; 
     n := n/(10) ; 
     i := i + 1 ) ;
    if (n /= 0) then skip else break) ; 
    return result 
 );
  static   operation digitSum( n : int) : int
  pre: true
  post: true
  activity: (     if (n < 0) then     error IllegalArgumentException.newIllegalArgumentException() ; else skip ; 
     var result : int ; result := 0 ;
     while (n /= 0) do (     result := result+(n mod 10) ; 
     n := n/(10) ) ; 
     return result );
  static    attribute DECIMAL_DIGIT_TO_SEGMENT : Sequence(int) := Sequence{0x77,0x12,0x5D,0x5B,0x3A,0x6B,0x6F,0x72,0x7F,0x7B};
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printNumber(int holes){
    if(holes==0)System.out.print("1");
    else if(holes==1)System.out.print("0");
    else {
      int rem=0,quo=0 ;
      rem=holes % 2 ;
      quo=holes/2 ;
      if(rem==1)System.out.print("4");
      for(int i=0 ; i<quo ; i++)System.out.print("8");
    }
  }
  public static void main(String[] args){
    int holes=3 ;
    printNumber(holes);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printNumber( holes : int) : void
  pre: true
  post: true
  activity: (     if (holes = 0) then     OclFile["System.out"].print("1") ; else     if (holes = 1) then     OclFile["System.out"].print("0") else (     var rem : int ; rem := 0 ;
    var quo : int ; quo := 0 ;
     rem := holes mod 2 ; 
    quo := holes / 2 ; 
    if (rem = 1) then     OclFile["System.out"].print("4") ; else skip ; 
        var i : int ; i := 0 ; while i < quo do (     OclFile["System.out"].print("8") ;  ;     i := i + 1 ) ; 
 ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var holes : int ; holes := 3 ;
     execute printNumber(holes) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countSubarray(int arr[],int n,int k){
    int s=0 ;
    int i=0 ;
    while(i<n){
      if(arr[i]>k){
        i++;
        continue ;
      }
      int count=0 ;
      while(i<n && arr[i]<=k){
        i++;
        count++;
      }
      s+=((count*(count+1))/2);
    }
    return(n*(n+1)/2-s);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3 };
      int k=2 ;
      int n=arr.length ;
      System.out.print(countSubarray(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSubarray( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var s : int ; s := 0 ;
     var i : int ; i := 0 ;
     while (i < n) do (     if (arr[i+1] > k) then (     i := i + 1 ; 
     continue ) else skip ; 
     var count : int ; count := 0 ;
     while (i < n & arr[i+1] <= k) do (     i := i + 1 ; 
     count := count + 1 ) ; 
     s := s+(((count * (count + 1)) / 2)) ) ; 
     return (n * (n + 1) / 2 - s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3} ;
     var k : int ; k := 2 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(countSubarray(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Fast f=new Fast(System.in);
    int t=f.nextInt();
    while(t--!=0){
      int n=f.nextInt();
      System.out.println((int)pow(2,(n/2.0)+1)-2);
    }
    System.out.flush();
    System.out.close();
  }
}
class Fast {
  StringTokenizer st ;
  BufferedReader br ;
  public Fast(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public Fast(String file)throws IOException {
    br=new BufferedReader(new FileReader(file));
  }
  public Fast(FileReader r){
    br=new BufferedReader(r);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String readAllLines(BufferedReader reader)throws IOException {
    StringBuilder content=new StringBuilder();
    String line ;
    while((line=reader.readLine())!=null){
      content.append(line);
      content.append(System.lineSeparator());
    }
    return content.toString();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public int[] nextIntArray(int n)throws IOException {
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : Fast ; f := Fast.newFast(OclFile["System.in"]) ;
     var t : int ; t := f.nextInt() ;
        while (t /= 0) do (    skip ; (     var n : int ; n := f.nextInt() ;
     OclFile["System.out"].println(pow(2, (n / 2.0) + 1)->oclAsType(int) - 2) ) ;  ) ;  
    OclFile["System.out"].flush() ; 
    OclFile["System.out"].close() ; 
 );
}
class Fast {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newFast( s : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFast( file : String) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   static operation newFast( r : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(r);
    return self );
  operation initialise( r : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(r) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation readAllLines( reader : OclFile) : String
  pre: true
  post: true
  activity: (     var content : String ; content := StringLib.newString() ;
     var line : String ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     content := content + StringLib.newString(line) ; 
     content := content + StringLib.newString(lineSeparator()) ) ;     line := reader.readLine() ;
 ) ;  
     return content+"" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Exersise {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] array=new int[n];
    for(int i=0 ; i<array.length ; i++){
      array[i]=input.nextInt();
    }
    for(int i=0 ; i<array.length ; i++){
      System.out.println(find(array[i]));
    }
  }
  public static int find(int n){
    int sum=(int)Math.pow(2,n);
    int sum2=0 ;
    for(int i=1 ; i<n/2 ; i++){
      sum=sum+(int)Math.pow(2,i);
    }
    for(int i=n/2 ; i<n ; i++){
      sum2=sum2+(int)Math.pow(2,i);
    }
    int y=Math.abs(sum2-sum);
    return y ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Exersise {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < array->size() do ( (     array[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < array->size() do ( (     OclFile["System.out"].println(find(array[i+1])) )  ;     i := i + 1 ) ; 
 );
  static   operation find( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 2->pow(n)->oclAsType(int) ;
     var sum2 : int ; sum2 := 0 ;
        var i : int ; i := 1 ; while i < n / 2 do ( (     sum := sum + 2->pow(i)->oclAsType(int) )  ;     i := i + 1 ) ; 
        var i : int ; i := n / 2 ; while i < n do ( (     sum2 := sum2 + 2->pow(i)->oclAsType(int) )  ;     i := i + 1 ) ; 
    var y : int ; y := if sum2 - sum < 0 then -(sum2 - sum) else sum2 - sum endif ;
    return y 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PhoenixAndBalance {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      int a[]=new int[n];
      int sum1=0 ;
      int sum2=0 ;
      int total=0 ;
      for(int i=1 ; i<=n ; i++){
        a[i-1]=(int)Math.pow(2,i);
      }
      int pos=n/2 ;
      for(int i=0 ; i<pos-1 ; i++){
        sum1+=a[i];
      }
      sum1+=a[n-1];
      for(int i=pos-1 ; i<n-1 ; i++){
        sum2+=a[i];
      }
      total=sum1-sum2 ;
      System.out.println(total);
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PhoenixAndBalance {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum1 : int ; sum1 := 0 ;
    var sum2 : int ; sum2 := 0 ;
    var total : int ; total := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i - 1+1] := 2->pow(i)->oclAsType(int) )  ;     i := i + 1 ) ; 
    var pos : int ; pos := n / 2 ;
        var i : int ; i := 0 ; while i < pos - 1 do ( (     sum1 := sum1+(a[i+1]) )  ;     i := i + 1 ) ; 
    sum1 := sum1+(a[n - 1+1]) ; 
        var i : int ; i := pos - 1 ; while i < n - 1 do ( (     sum2 := sum2+(a[i+1]) )  ;     i := i + 1 ) ; 
    total := sum1 - sum2 ; 
    OclFile["System.out"].println(total) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Fast f=new Fast(System.in);
    int t=f.nextInt();
    while(t--!=0){
      int n=f.nextInt(),s1=0,s2=0 ;
      for(int i=1 ; i<=(n/2)-1 ; i++)s1+=1<<i ;
      s1+=1<<n ;
      for(int i=n/2 ; i<n ; i++)s2+=1<<i ;
      System.out.println(s1-s2);
    }
    System.out.flush();
    System.out.close();
  }
}
class Fast {
  StringTokenizer st ;
  BufferedReader br ;
  public Fast(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public Fast(String file)throws IOException {
    br=new BufferedReader(new FileReader(file));
  }
  public Fast(FileReader r){
    br=new BufferedReader(r);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String readAllLines(BufferedReader reader)throws IOException {
    StringBuilder content=new StringBuilder();
    String line ;
    while((line=reader.readLine())!=null){
      content.append(line);
      content.append(System.lineSeparator());
    }
    return content.toString();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public int[] nextIntArray(int n)throws IOException {
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : Fast ; f := Fast.newFast(OclFile["System.in"]) ;
     var t : int ; t := f.nextInt() ;
        while (t /= 0) do (    skip ; (     var n : int ; n := f.nextInt() ;
    var s1 : int ; s1 := 0 ;
    var s2 : int ; s2 := 0 ;
         var i : int ; i := 1 ; while i <= (n / 2) - 1 do (     s1 := s1+((1*(2->pow(i)))->oclAsType(long)) ;  ;     i := i + 1 ) ; 
    s1 := s1+((1*(2->pow(n)))->oclAsType(long)) ; 
        var i : int ; i := n / 2 ; while i < n do (     s2 := s2+((1*(2->pow(i)))->oclAsType(long)) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s1 - s2) ; 
 ) ;  ) ;  
    OclFile["System.out"].flush() ; 
    OclFile["System.out"].close() ; 
 );
}
class Fast {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newFast( s : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFast( file : String) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   static operation newFast( r : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(r);
    return self );
  operation initialise( r : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(r) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation readAllLines( reader : OclFile) : String
  pre: true
  post: true
  activity: (     var content : String ; content := StringLib.newString() ;
     var line : String ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     content := content + StringLib.newString(line) ; 
     content := content + StringLib.newString(lineSeparator()) ) ;     line := reader.readLine() ;
 ) ;  
     return content+"" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long x=sc.nextLong();
    long y=sc.nextLong();
    int n=sc.nextInt();
    long ans=0 ;
    switch(n % 6){
      case 0 : ans=(x-y);
      break ;
      case 1 : ans=x ;
      break ;
      case 2 : ans=y ;
      break ;
      case 3 : ans=y-x ;
      break ;
      case 4 : ans=-x ;
      break ;
      case 5 : ans=-y ;
      break ;
    }
    long mod=1000000007 ;
    while(ans<0)ans+=mod ;
    System.out.println(ans %(mod));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := sc.getCurrent()->toLong() ;
    var y : long ; y := sc.getCurrent()->toLong() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : long ; ans := 0 ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (n mod 6) ; 
       if _switchval = 0 then
     ans := (x - y) ; 
    break 
   else skip ;
       if _switchval = 1 then
     ans := x ; 
    break 
   else skip ;
       if _switchval = 2 then
     ans := y ; 
    break 
   else skip ;
       if _switchval = 3 then
     ans := y - x ; 
    break 
   else skip ;
       if _switchval = 4 then
     ans := -x ; 
    break 
   else skip ;
       if _switchval = 5 then
     ans := -y ; 
    break 
   else skip ;
 )
    var mod : long ; mod := 1000000007 ;
    while (ans < 0) do     ans := ans+(mod) ; ; 
    OclFile["System.out"].println(ans mod (mod)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.HashMap ;
public class Solution {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=s.nextInt();
    }
    printTriplet(arr);
  }
  public static void printTriplet(int[] arr){
    HashMap<Integer,Integer>hash=new HashMap<>();
    HashMap<Integer,Integer>hash2=new HashMap<>();
    for(int i=0 ; i<arr.length ; i++){
      if(hash.containsKey(arr[i])){
        int freq=hash.get(arr[i]);
        hash.put(arr[i],freq+1);
      }
      else {
        hash.put(arr[i],1);
      }
      hash2.put(arr[i],i+1);
    }
    for(int i=0 ; i<arr.length ; i++){
      for(int j=0 ; j<arr.length ; j++){
        if(i!=j){
          if(hash.containsKey(arr[i]-arr[j])){
            int freq=hash.get(arr[i]-arr[j]);
            if(freq>1 ||(arr[i]!=2*arr[j] && arr[j]!=0)){
              System.out.println((i+1)+" "+(j+1)+" "+(hash2.get(arr[i]-arr[j])));
              return ;
            }
          }
        }
      }
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute printTriplet(arr) ; 
 );
  static   operation printTriplet( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var hash : Map(int,int) ; hash := Map{} ;
     var hash2 : Map(int,int) ; hash2 := Map{} ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (hash->keys()->includes(arr[i+1])) then (     var freq : int ; freq := hash->at(arr[i+1]) ;
     hash := hash->union(Map{arr[i+1] |-> freq + 1}) ) else (     hash := hash->union(Map{arr[i+1] |-> 1}) ) ;  
     hash2 := hash2->union(Map{arr[i+1] |-> i + 1}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (         var j : int ; j := 0 ; while j < arr->size() do ( (     if (i /= j) then (     if (hash->keys()->includes(arr[i+1] - arr[j+1])) then (     var freq : int ; freq := hash->at(arr[i+1] - arr[j+1]) ;
     if (freq > 1 or (arr[i+1] /= 2 * arr[j+1] & arr[j+1] /= 0)) then (     OclFile["System.out"].println((i + 1) + " " + (j + 1) + " " + (hash2->at(arr[i+1] - arr[j+1]))) ; 
     return ) else skip ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class amd {
  public static class pair {
    char c ;
    int idx ;
    pair(char c,int idx){
      this.c=c ;
      this.idx=idx ;
    }
  }
  public static boolean ispal(StringBuilder s){
    int i=0 ;
    int j=s.length()-1 ;
    while(i<=j){
      if(s.charAt(i)==s.charAt(j)){
        i++;
        j--;
      }
      else {
        return false ;
      }
    }
    return true ;
  }
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int t=1 ;
    while(t-->0){
      String str=s.next();
      PriorityQueue<pair>pq=new PriorityQueue<amd.pair>((a,b)->{
        return b.c==a.c ? a.idx-b.idx : b.c-a.c ;
      }
);
      for(int i=0 ; i<str.length(); i++){
        pq.add(new pair(str.charAt(i),i));
      }
      StringBuilder ans=new StringBuilder();
      int i=0 ;
      int j=str.length()-1 ;
      while(i<=j){
        pair a=pq.poll();
        ans.append(a.c);
        if(ispal(ans)){
          i=a.idx+1 ;
        }
        else {
          ans.deleteCharAt(ans.length()-1);
          break ;
        }
        while(pq.isEmpty()==false){
          pair b=pq.peek();
          if(b.idx>=i){
            break ;
          }
          else {
            pq.poll();
          }
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class amd {
  static class pair {
   attribute c : String;
   attribute idx : int;
   static operation newpair( c : String, idx : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(c, idx);
    return self );
  operation initialise( c : String, idx : int) : void
  pre: true  post: true
  activity: (     self.c := c ; 
     self.idx := idx );
}
  static   operation ispal( s : String) : boolean
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var j : int ; j := s->size() - 1 ;
     while (i <= j) do (     if (s->at(i+1) = s->at(j+1)) then (     i := i + 1 ; 
     j := j - 1 ) else (     return false ) ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var str : String ; str := s.getCurrent() ;
     var pq : Sequence(pair) ; pq := Sequence{}->union(lambda (a , b) : OclAny in (     return if b.c = a.c then a.idx - b.idx else b.c - a.c endif )) ;
        var i : int ; i := 0 ; while i < str->size() do ( (     pq := pq->including(pair.newpair(str->at(i+1), i)) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := StringLib.newString() ;
    var i : int ; i := 0 ;
    var j : int ; j := str->size() - 1 ;
    while (i <= j) do (     var a : pair ; a := pq->min() ;
     ans := ans + StringLib.newString(a.c) ; 
     if (ispal(ans)) then (     i := a.idx + 1 ) else (     ans := ans->excludingAt(ans->size() - 1+1) ; 
     break ) ;  
     while (pq->isEmpty() = false) do (     var b : pair ; b := pq->min() ;
     if (b.idx >= i) then (     break ) else (     pq := pq->sort()->tail() ) ) ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class TheMonster {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long a=in.nextLong(),b=in.nextLong();
    long c=in.nextLong(),d=in.nextLong();
    pw.println(solve(a,b,c,d));
    pw.close();
  }
  static long solve(long a,long b,long c,long d){
    HashSet<Long>set=new HashSet<>();
    set.add(b);
    for(long i=1 ; i<=(long)1e5 ; i++)set.add(b+i*a);
    if(set.contains(d))return d ;
    for(long i=1 ; i<=(long)1e5 ; i++)if(set.contains(d+i*c))return(d+i*c);
    return-1 ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class TheMonster {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : long ; a := in.getCurrent()->toLong() ;
    var b : long ; b := in.getCurrent()->toLong() ;
    var c : long ; c := in.getCurrent()->toLong() ;
    var d : long ; d := in.getCurrent()->toLong() ;
    skip ; 
    skip ; 
 );
  static   operation solve( a : long, b : long, c : long, d : long) : long
  pre: true
  post: true
  activity: (     var set : Set(long) ; set := Set{} ;
     set := set->including(b) ; 
        var i : long ; i := 1 ; while i <= 1e5->oclAsType(long) do (     set := set->including(b + i * a) ;  ;     i := i + 1 ) ; 
    if (set->includes(d)) then     return d else skip ; 
        var i : long ; i := 1 ; while i <= 1e5->oclAsType(long) do (     if (set->includes(d + i * c)) then     return (d + i * c) else skip ;  ;     i := i + 1 ) ; 
    return -1 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    long a,b,c,d ;
    Scanner in=new Scanner(System.in);
    a=in.nextInt();
    b=in.nextInt();
    c=in.nextInt();
    d=in.nextInt();
    long rick=b,monty=d,cnt=1 ;
    for(int i=0 ; i<10000 ; i++){
      rick=b+i*a ;
      for(int j=0 ; j<10000 ; j++){
        monty=d+j*c ;
        if(rick==monty){
          System.out.println(rick);
          System.exit(0);
        }
      }
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ;
    var b : long ;
    var c : long ;
    var d : long ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    a := in.getCurrent()->toInteger() ; 
    b := in.getCurrent()->toInteger() ; 
    c := in.getCurrent()->toInteger() ; 
    d := in.getCurrent()->toInteger() ; 
    var rick : long ; rick := b ;
    var monty : long ; monty := d ;
    var cnt : long ; cnt := 1 ;
        var i : int ; i := 0 ; while i < 10000 do ( (     rick := b + i * a ; 
         var j : int ; j := 0 ; while j < 10000 do ( (     monty := d + j * c ; 
     if (rick = monty) then (     OclFile["System.out"].println(rick) ; 
 OclProcess.exit(0) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Pattern {
  void display(int n){
    int sp=n/2,st=1 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=sp ; j++)System.out.print(" ");
      int count=st/2+1 ;
      for(int k=1 ; k<=st ; k++){
        System.out.print(count);
        if(k<=st/2)count--;
        else count++;
      }
      System.out.println();
      if(i<=n/2){
        sp=sp-1 ;
        st=st+2 ;
      }
      else {
        sp=sp+1 ;
        st=st-2 ;
      }
    }
  }
  public static void main(String[] args){
    Pattern p=new Pattern();
    int n=7 ;
    p.display(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Pattern {
   operation display( n : int) : void
  pre: true
  post: true
  activity: (     var sp : int ; sp := n / 2 ;
    var st : int ; st := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= sp do (     OclFile["System.out"].print(" ") ;  ;     j := j + 1 ) ; 
     var count : int ; count := st / 2 + 1 ;
        var k : int ; k := 1 ; while k <= st do ( (     OclFile["System.out"].print(count) ; 
     if (k <= st / 2) then     count := count - 1 ; else     count := count + 1 ; )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println() ; 
    if (i <= n / 2) then (     sp := sp - 1 ; 
     st := st + 2 ) else (     sp := sp + 1 ; 
     st := st - 2 ) ;  
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : OclRegex ; p := OclRegex() ;
     var n : int ; n := 7 ;
     p.display(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Pattern {
  void display(int n){
    int sp=n/2,st=1 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=sp ; j++){
        System.out.print(" ");
      }
      int count=1 ;
      for(int k=1 ; k<=st ; k++){
        if(k % 2==0)System.out.print("*");
        else System.out.print(count++);
      }
      System.out.println();
      if(i<=n/2){
        sp=sp-1 ;
        st=st+2 ;
      }
      else {
        sp=sp+1 ;
        st=st-2 ;
      }
    }
  }
  public static void main(String[] args){
    int n=5 ;
    Pattern p=new Pattern();
    p.display(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Pattern {
   operation display( n : int) : void
  pre: true
  post: true
  activity: (     var sp : int ; sp := n / 2 ;
    var st : int ; st := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= sp do ( (     OclFile["System.out"].print(" ") )  ;     j := j + 1 ) ; 
     var count : int ; count := 1 ;
        var k : int ; k := 1 ; while k <= st do ( (     if (k mod 2 = 0) then     OclFile["System.out"].print("*") ; else     OclFile["System.out"].print(count) ; )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println() ; 
    if (i <= n / 2) then (     sp := sp - 1 ; 
     st := st + 2 ) else (     sp := sp + 1 ; 
     st := st - 2 ) ;  
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var p : OclRegex ; p := OclRegex() ;
     p.display(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  public static int binomialCoeff(int n,int k){
    int[][] C=new int[n+1][k+1];
    int i,j ;
    for(i=0 ; i<=n ; i++){
      for(j=0 ; j<=Math.min(i,k); j++){
        if(j==0 || j==i)C[i][j]=1 ;
        else C[i][j]=C[i-1][j-1]+C[i-1][j];
      }
    }
    return C[n][k];
  }
  public static int count(int n,int k){
    int sum=0 ;
    for(int j=1 ; j<=k ; j++){
      sum=sum+binomialCoeff(n,j);
    }
    return sum ;
  }
  public static void main(String args[]){
    GFG g=new GFG();
    int n=3,k=2 ;
    System.out.print(count(n,k));
    int n1=5,k1=2 ;
    System.out.print(count(n1,k1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation binomialCoeff( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var C : Sequence(Sequence(int)) ; C := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,k + 1)->collect(0)) ;
     var i : int ;
    var j : int ;
         i := 0 ; while i <= n do ( (         j := 0 ; while j <= Set{i, k}->min() do ( (     if (j = 0 or j = i) then     C[i+1][j+1] := 1 ; else     C[i+1][j+1] := C[i - 1+1][j - 1+1] + C[i - 1+1][j+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return C[n+1][k+1] );
  static   operation count( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var j : int ; j := 1 ; while j <= k do ( (     sum := sum + binomialCoeff(n, j) )  ;     j := j + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : GFG ; g := GFG.newGFG() ;
     var n : int ; n := 3 ;
    var k : int ; k := 2 ;
    OclFile["System.out"].print(count(n, k)) ; 
    var n1 : int ; n1 := 5 ;
    var k1 : int ; k1 := 2 ;
    OclFile["System.out"].print(count(n1, k1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void isPossible(int[] A,int n,int k){
    int countOfTwo=0 ;
    for(int i=0 ; i<n ; i++){
      if(A[i] % 2==0){
        countOfTwo++;
      }
    }
    if(k==0 && countOfTwo==n)System.out.print("NO");
    else if(countOfTwo>=k){
      System.out.print("YES");
    }
    else System.out.print("No");
  }
  public static void main(String[] args){
    int[] arr={
      1,2,4,5 };
      int K=2 ;
      int n=arr.length ;
      isPossible(arr,n,K);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPossible( A : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var countOfTwo : int ; countOfTwo := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (A[i+1] mod 2 = 0) then (     countOfTwo := countOfTwo + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (k = 0 & countOfTwo = n) then     OclFile["System.out"].print("NO") ; else     if (countOfTwo >= k) then (     OclFile["System.out"].print("YES") ) else     OclFile["System.out"].print("No") ; ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,4,5} ;
     var K : int ; K := 2 ;
     var n : int ; n := arr->size() ;
     execute isPossible(arr, n, K) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPossible(char[] str){
    Map<Character,Integer>freq=new HashMap<>();
    int max_freq=0 ;
    for(int j=0 ; j<(str.length); j++){
      if(freq.containsKey(str[j])){
        freq.put(str[j],freq.get(str[j])+1);
        if(freq.get(str[j])>max_freq)max_freq=freq.get(str[j]);
      }
      else {
        freq.put(str[j],1);
        if(freq.get(str[j])>max_freq)max_freq=freq.get(str[j]);
      }
    }
    if(max_freq<=(str.length-max_freq+1))return true ;
    return false ;
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    if(isPossible(str.toCharArray()))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPossible( str : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     var freq : Map(String,int) ; freq := Map{} ;
     var max_freq : int ; max_freq := 0 ;
        var j : int ; j := 0 ; while j < (str->size()) do ( (     if (freq->keys()->includes(str[j+1])) then (     freq := freq->union(Map{str[j+1] |-> freq->at(str[j+1]) + 1}) ; 
     if (freq->at(str[j+1]) > max_freq) then     max_freq := freq->at(str[j+1]) ; else skip ) else (     freq := freq->union(Map{str[j+1] |-> 1}) ; 
     if (freq->at(str[j+1]) > max_freq) then     max_freq := freq->at(str[j+1]) ; else skip ) )  ;     j := j + 1 ) ; 
    if (max_freq <= (str->size() - max_freq + 1)) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     if (isPossible(str->characters())) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      int m=input.nextInt();
      int k=input.nextInt();
      char s1[]=input.next().toCharArray();
      char s2[]=input.next().toCharArray();
      Arrays.sort(s1);
      Arrays.sort(s2);
      int i=0,j=0 ;
      StringBuilder result=new StringBuilder();
      int nows1=0,nows2=0 ;
      while(i<s1.length && j<s2.length){
        if(s1[i]<s2[j] && nows1<k){
          result.append(s1[i]);
          i++;
          nows1++;
          nows2=0 ;
        }
        else if(s2[j]<s1[i] && nows2<k){
          result.append(s2[j]);
          j++;
          nows2++;
          nows1=0 ;
        }
        else if(s1[i]<s2[j]){
          result.append(s2[j]);
          j++;
          nows1=0 ;
          nows2=1 ;
        }
        else if(s2[j]<s1[i]){
          result.append(s1[i]);
          i++;
          nows2=0 ;
          nows1=1 ;
        }
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := input.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.getCurrent()->toInteger() ;
     var m : int ; m := input.getCurrent()->toInteger() ;
    var k : int ; k := input.getCurrent()->toInteger() ;
    var s1 : Sequence(String) ; s1 := input.getCurrent()->characters() ;
    var s2 : Sequence(String) ; s2 := input.getCurrent()->characters() ;
    s1 := s1->sort() ; 
    s2 := s2->sort() ; 
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    var result : String ; result := StringLib.newString() ;
    var nows1 : int ; nows1 := 0 ;
    var nows2 : int ; nows2 := 0 ;
    while (i < s1->size() & j < s2->size()) do (     if (s1[i+1] < s2[j+1] & nows1 < k) then (     result := result + StringLib.newString(s1[i+1]) ; 
     i := i + 1 ; 
     nows1 := nows1 + 1 ; 
     nows2 := 0 ) else     if (s2[j+1] < s1[i+1] & nows2 < k) then (     result := result + StringLib.newString(s2[j+1]) ; 
     j := j + 1 ; 
     nows2 := nows2 + 1 ; 
     nows1 := 0 ) else     if (s1[i+1] < s2[j+1]) then (     result := result + StringLib.newString(s2[j+1]) ; 
     j := j + 1 ; 
     nows1 := 0 ; 
     nows2 := 1 ) else     if (s2[j+1] < s1[i+1]) then (     result := result + StringLib.newString(s1[i+1]) ; 
     i := i + 1 ; 
     nows2 := 0 ; 
     nows1 := 1 ) else skip ; ;  ;  ) ; 
    OclFile["System.out"].println(result) ; 
 ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      in.nextInt();
      in.nextInt();
      int K=in.nextInt();
      int[] aStat=stat(in.next());
      int[] bStat=stat(in.next());
      int aIdx=0 ;
      int bIdx=0 ;
      boolean lastA=true ;
      int count=0 ;
      StringBuilder out=new StringBuilder();
      while(true){
        while(aIdx<aStat.length && aStat[aIdx]==0)aIdx++;
        while(bIdx<bStat.length && bStat[bIdx]==0)bIdx++;
        if(aIdx==aStat.length || bIdx==bStat.length)break ;
        boolean useA=true ;
        if(aIdx<bIdx){
          useA=(! lastA)||(lastA && count<K);
        }
        else {
          useA=!(lastA ||((! lastA)&& count<K));
        }
        if(useA==lastA){
          count++;
        }
        else {
          lastA=useA ;
          count=1 ;
        }
        out.append((char)('a'+(useA ? aIdx : bIdx)));
        if(useA){
          aStat[aIdx]--;
        }
        else {
          bStat[bIdx]--;
        }
      }
      System.out.println(out);
    }
  }
  private static int[] stat(String s){
    int[] result=new int[26];
    for(char c : s.toCharArray()){
      result[c-'a']++;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     skip ; 
     skip ; 
    var K : int ; K := in.getCurrent()->toInteger() ;
    var aStat : Sequence(int) ; aStat := stat(in.getCurrent()) ;
    var bStat : Sequence(int) ; bStat := stat(in.getCurrent()) ;
    var aIdx : int ; aIdx := 0 ;
    var bIdx : int ; bIdx := 0 ;
    var lastA : boolean ; lastA := true ;
    var count : int ; count := 0 ;
    var out : String ; out := StringLib.newString() ;
    while (true) do (     while (aIdx < aStat->size() & aStat[aIdx+1] = 0) do     aIdx := aIdx + 1 ; ; 
     while (bIdx < bStat->size() & bStat[bIdx+1] = 0) do     bIdx := bIdx + 1 ; ; 
    if (aIdx = aStat->size() or bIdx = bStat->size()) then     break else skip ; 
    var useA : boolean ; useA := true ;
    if (aIdx < bIdx) then (     useA := (not(lastA)) or (lastA & count < K) ) else (     useA := not((lastA or ((not(lastA)) & count < K))) ) ;  
    if (useA = lastA) then (     count := count + 1 ) else (     lastA := useA ; 
     count := 1 ) ;  
    out := out + StringLib.newString(('a' + (if useA then aIdx else bIdx endif))->oclAsType(String)) ; 
    if (useA) then (     aStat[aIdx+1] := aStat[aIdx+1] - 1 ) else (     bStat[bIdx+1] := bStat[bIdx+1] - 1 ) ;  
 ) ; 
    OclFile["System.out"].println(out) ; 
 )  ;     t := t + 1 ) );
  static   operation stat( s : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var result : Sequence(int) ; result := Integer.subrange(1,26)->collect(0) ;
     for (c : s->characters()) do ( (     result[c - ('a')->char2byte()+1] := result[c - ('a')->char2byte()+1] + 1 )  ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Worms {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x=0,y=0,z=0,a=0,found=0 ;
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    for(int i=0 ; i<arr.length ; i++){
      for(int j=0 ; j<arr.length ; j++){
        if(i!=j){
          for(int k=0 ; k<arr.length ; k++){
            if(k!=j && arr[i]==arr[j]+arr[k]){
              System.out.println(""+(i+1)+" "+(j+1)+" "+(k+1));
              found=1 ;
              break ;
            }
          }
          if(found==1)break ;
        }
      }
      if(found==1)break ;
    }
    if(found==0){
      System.out.println("-1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Worms {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var z : int ; z := 0 ;
    var a : int ; a := 0 ;
    var found : int ; found := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (         var j : int ; j := 0 ; while j < arr->size() do ( (     if (i /= j) then (         var k : int ; k := 0 ; while k < arr->size() do ( (     if (k /= j & arr[i+1] = arr[j+1] + arr[k+1]) then (     OclFile["System.out"].println("" + (i + 1) + " " + (j + 1) + " " + (k + 1)) ; 
     found := 1 ; 
     break ) else skip )  ;     k := k + 1 ) ; 
     if (found = 1) then     break else skip ) else skip )  ;     j := j + 1 ) ; 
     if (found = 1) then     break else skip )  ;     i := i + 1 ) ; 
    if (found = 0) then (     OclFile["System.out"].println("-1") ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Lex1689A {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int testCases=sc.nextInt();
    sc.nextLine();
    while(testCases-->0){
      String inputs[]=sc.nextLine().split(" ");
      int n=Integer.parseInt(inputs[0]);
      int m=Integer.parseInt(inputs[1]);
      int k=Integer.parseInt(inputs[2]);
      char a[]=sc.nextLine().toCharArray();
      char b[]=sc.nextLine().toCharArray();
      Arrays.sort(a);
      Arrays.sort(b);
      int i=0,j=0 ;
      String c="" ;
      int l=k ;
      int tmp=k ;
      while(n>0 && m>0){
        if(a[i]<=b[j] && k>0){
          c+=a[i];
          i++;
          k--;
          l=tmp ;
          n--;
        }
        else if(b[j]<=a[i] && l>0){
          c+=b[j];
          j++;
          l--;
          k=tmp ;
          m--;
        }
        else if(a[i]<=b[j] && k==0){
          c+=b[j];
          j++;
          l--;
          k=tmp ;
          m--;
        }
        else if(b[j]<=a[i] && l==0){
          c+=a[i];
          i++;
          k--;
          l=tmp ;
          n--;
        }
      }
      System.out.println(c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Lex1689A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := sc.getCurrent()->toInteger() ;
     skip ; 
         while (testCases > 0) do (        testCases := testCases - 1 ;     skip ; (     var inputs : Sequence(String) ; inputs := sc.nextLine()->split(" ") ;
     var n : int ; n := (inputs[0+1])->toInteger() ;
    var m : int ; m := (inputs[1+1])->toInteger() ;
    var k : int ; k := (inputs[2+1])->toInteger() ;
    var a : Sequence(String) ; a := sc.nextLine()->characters() ;
    var b : Sequence(String) ; b := sc.nextLine()->characters() ;
    a := a->sort() ; 
    b := b->sort() ; 
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    var c : String ; c := "" ;
    var l : int ; l := k ;
    var tmp : int ; tmp := k ;
    while (n > 0 & m > 0) do (     if (a[i+1] <= b[j+1] & k > 0) then (     c := c+(a[i+1]) ; 
     i := i + 1 ; 
    k := k - 1 ; 
    l := tmp ; 
    n := n - 1 ; 
 ) else     if (b[j+1] <= a[i+1] & l > 0) then (     c := c+(b[j+1]) ; 
     j := j + 1 ; 
    l := l - 1 ; 
    k := tmp ; 
    m := m - 1 ; 
 ) else     if (a[i+1] <= b[j+1] & k = 0) then (     c := c+(b[j+1]) ; 
     j := j + 1 ; 
    l := l - 1 ; 
    k := tmp ; 
    m := m - 1 ; 
 ) else     if (b[j+1] <= a[i+1] & l = 0) then (     c := c+(a[i+1]) ; 
     i := i + 1 ; 
    k := k - 1 ; 
    l := tmp ; 
    n := n - 1 ; 
 ) else skip ; ;  ;  ) ; 
    OclFile["System.out"].println(c) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Random {
  public static void LLP(String s){
    char max=0 ;
    int count=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(max<s.charAt(i)){
        max=s.charAt(i);
        count=1 ;
      }
      else if(max==s.charAt(i)){
        count++;
      }
    }
    for(int i=0 ; i<count ; i++){
      System.out.print(max);
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    LLP(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Random {
  static   operation LLP( s : String) : void
  pre: true
  post: true
  activity: (     var max : String ; max := 0 ;
     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (max < s->at(i+1)) then (     max := s->at(i+1) ; 
     count := 1 ) else     if (max = s->at(i+1)) then (     count := count + 1 ) else skip ; )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < count do ( (     OclFile["System.out"].print(max) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
     execute LLP(s) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.PriorityQueue ;
public class problemA {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int k=sc.nextInt();
      String inputA=sc.next();
      char aArray[]=inputA.toCharArray();
      PriorityQueue<Character>a=new PriorityQueue<Character>();
      for(int i=0 ; i<aArray.length ; i++){
        a.add(aArray[i]);
      }
      String inputB=sc.next();
      char bArray[]=inputB.toCharArray();
      PriorityQueue<Character>b=new PriorityQueue<Character>();
      for(int i=0 ; i<bArray.length ; i++){
        b.add(bArray[i]);
      }
      int consA=0 ;
      int consB=0 ;
      while(! a.isEmpty()&& ! b.isEmpty()){
        char topA,topB ;
        topA=a.peek();
        topB=b.peek();
        if(topA<topB){
          if(consA<k){
            System.out.print(topA);
            consA++;
            a.remove();
            consB=0 ;
          }
          else {
            System.out.print(topB);
            consB++;
            b.remove();
            consA=0 ;
          }
        }
        else {
          if(consB<k){
            System.out.print(topB);
            consB++;
            b.remove();
            consA=0 ;
          }
          else {
            System.out.print(topA);
            consA++;
            a.remove();
            consB=0 ;
          }
        }
      }
      System.out.println();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class problemA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var inputA : String ; inputA := sc.getCurrent() ;
    var aArray : Sequence(String) ; aArray := inputA->characters() ;
    var a : Sequence(String) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < aArray->size() do ( (     a := a->including(aArray[i+1]) )  ;     i := i + 1 ) ; 
    var inputB : String ; inputB := sc.getCurrent() ;
    var bArray : Sequence(String) ; bArray := inputB->characters() ;
    var b : Sequence(String) ; b := Sequence{} ;
        var i : int ; i := 0 ; while i < bArray->size() do ( (     b := b->including(bArray[i+1]) )  ;     i := i + 1 ) ; 
    var consA : int ; consA := 0 ;
    var consB : int ; consB := 0 ;
    while (not(a->isEmpty()) & not(b->isEmpty())) do (     var topA : String ;
    var topB : String ;
     topA := a->min() ; 
     topB := b->min() ; 
     if (topA < topB) then (     if (consA < k) then (     OclFile["System.out"].print(topA) ; 
     consA := consA + 1 ; 
     a := a.remove() ; 
     consB := 0 ) else (     OclFile["System.out"].print(topB) ; 
     consB := consB + 1 ; 
     b := b.remove() ; 
     consA := 0 ) ) else (     if (consB < k) then (     OclFile["System.out"].print(topB) ; 
     consB := consB + 1 ; 
     b := b.remove() ; 
     consA := 0 ) else (     OclFile["System.out"].print(topA) ; 
     consA := consA + 1 ; 
     a := a.remove() ; 
     consB := 0 ) ) ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findNthEvenDigitNumber(int n){
    if(n==1){
      return 0 ;
    }
    Vector<Integer>v=new Vector<>();
    n=n-1 ;
    while(n>0){
      v.add(n % 5);
      n=n/5 ;
    }
    int result=0 ;
    for(int i=v.size()-1 ; i>=0 ; i--){
      result=result*10 ;
      result=result+v.get(i);
    }
    return 2*result ;
  }
  public static void main(String[] args){
    System.out.println(findNthEvenDigitNumber(2));
    System.out.println(findNthEvenDigitNumber(10));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNthEvenDigitNumber( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then (     return 0 ) else skip ; 
     var v : Sequence(int) ; v := Sequence{} ;
    n := n - 1 ; 
    while (n > 0) do (     v := v->including(n mod 5) ; 
     n := n / 5 ) ; 
    var result : int ; result := 0 ;
        var i : int ; i := v->size() - 1 ; while i >= 0 do ( (     result := result * 10 ; 
     result := result + v->at(i+1) )  ;     i := i - 1 ) ; 
    return 2 * result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(findNthEvenDigitNumber(2)) ; 
     OclFile["System.out"].println(findNthEvenDigitNumber(10)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    System.out.println(f(n));
  }
  static long f(int n){
    if(n==0){
      return 1 ;
    }
    else {
      return n*f(n-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(f(n)) );
  static   operation f( n : int) : long
  pre: true
  post: true
  activity: (     if (n = 0) then (     return 1 ) else (     return n * f(n - 1) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    String strLine="" ;
    BufferedReader stdReader=new BufferedReader(new InputStreamReader(System.in));
    int MAX_DETASET=20 ;
    int cnt=0 ;
    ArrayList<String>list=new ArrayList<String>();
    if((strLine=stdReader.readLine())!=null){
      long intStrLine=Integer.parseInt(strLine);
      long k=intStrLine ;
      for(long i=intStrLine-1 ; i>0 ; i--){
        k=k*i ;
      }
      System.out.println(k);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var strLine : String ; strLine := "" ;
     var stdReader : OclFile ; stdReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var MAX_DETASET : int ; MAX_DETASET := 20 ;
    var cnt : int ; cnt := 0 ;
    var list : Sequence(String) ; list := Sequence{} ;
    if ((strLine) /= null) then (     var intStrLine : long ; intStrLine := (strLine)->toInteger() ;
     var k : long ; k := intStrLine ;
         var i : long ; i := intStrLine - 1 ; while i > 0 do ( (     k := k * i )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println(k) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Scanner ;
public class Main {
  public Main(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      BigDecimal bd=new BigDecimal("1");
      for(int i=sc.nextInt(); i>1 ; i--){
        BigDecimal tmp=new BigDecimal(String.valueOf(i));
        bd=bd.multiply(tmp);
      }
      System.out.println(bd);
    }
  }
  public static void main(String[] args){
    Main test=new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var bd : double ; bd := double("1") ;
         var i : int ; i := sc.getCurrent()->toInteger() ; while i > 1 do ( (     var tmp : double ; tmp := double(((i) + "")) ;
     bd := bd.multiply(tmp) )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println(bd) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var test : Main ; test := Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public void doIt(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long sum=1 ;
    for(int i=1 ; i<=n ; i++){
      sum*=i ;
    }
    System.out.println(sum);
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var sum : long ; sum := 1 ;
        var i : int ; i := 1 ; while i <= n do ( (     sum := sum*(i) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  long rep(long n){
    if(n==0){
      return 1 ;
    }
    else {
      return rep(n-1)*n ;
    }
  }
  void run(){
    int n=sc.nextInt();
    System.out.println(rep(n));
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation rep( n : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then (     return 1 ) else (     return rep(n - 1) * n ) );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(rep(n)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    System.out.println((int)Math.pow(n,2)-a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(n->pow(2)->oclAsType(int) - a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int averageOdd(int n){
    if(n % 2==0){
      System.out.println("Invalid Input");
      return-1 ;
    }
    int sum=0,count=0 ;
    while(n>=1){
      count++;
      sum+=n ;
      n=n-2 ;
    }
    return sum/count ;
  }
  public static void main(String args[]){
    int n=15 ;
    System.out.println(averageOdd(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation averageOdd( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 = 0) then (     OclFile["System.out"].println("Invalid Input") ; 
     return -1 ) else skip ; 
     var sum : int ; sum := 0 ;
    var count : int ; count := 0 ;
     while (n >= 1) do (     count := count + 1 ; 
     sum := sum+(n) ; 
     n := n - 2 ) ; 
     return sum / count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     OclFile["System.out"].println(averageOdd(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Collection ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    solve();
  }
  public static void solve(){
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    Integer n=sc.nextInt();
    Integer a=sc.nextInt();
    sc.close();
    out.println(n*n-a);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String str=br.readLine();
      int N=Integer.parseInt(str);
      str=br.readLine();
      int A=Integer.parseInt(str);
      System.out.println(N*N-A);
    }
    catch(Exception e){
      System.exit(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var str : String ; str := br.readLine() ;
     var N : int ; N := (str)->toInteger() ;
    str := br.readLine() ; 
    var A : int ; A := (str)->toInteger() ;
    OclFile["System.out"].println(N * N - A) ; 
 )   catch (e : ProgramException) do ( OclProcess.exit(0) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.HashSet ;
import java.util.Set ;
import java.util.StringTokenizer ;
public class cp_test2 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        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().trim();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  static class FastWriter {
    private final BufferedWriter bw ;
    public FastWriter(){
      this.bw=new BufferedWriter(new OutputStreamWriter(System.out));
    }
    public void print(Object object)throws IOException {
      bw.append(""+object);
    }
    public void println(Object object)throws IOException {
      print(object);
      bw.append("\n");
    }
    public void close()throws IOException {
      bw.close();
    }
  }
  public static void main(String[] args){
    try {
      FastReader in=new FastReader();
      FastWriter out=new FastWriter();
      String s=in.nextLine();
      char mx=s.charAt(0);
      for(int i=0 ; i<s.length(); i++){
        mx=(char)Math.max((int)mx,(int)s.charAt(i));
      }
      String r="" ;
      for(int i=0 ; i<s.length(); i++){
        if(s.charAt(i)==mx){
          r+=mx ;
        }
      }
      System.out.println(r);
    }
    catch(Exception e){
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp_test2 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine()->trim() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return str );
}
  static class FastWriter {
   attribute bw : OclFile;
   static operation newFastWriter() : FastWriter
  pre: true
  post: true
  activity:
  ( var self : FastWriter ;
    self := createFastWriter();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) );
   operation print( object : OclAny) : void
  pre: true
  post: true
  activity: (     skip );
   operation println( object : OclAny) : void
  pre: true
  post: true
  activity: (     execute print(object) ; 
     skip );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : FastWriter ; out := FastWriter.newFastWriter() ;
    var s : String ; s := in.nextLine() ;
    var mx : String ; mx := s->at(0+1) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     mx := Set{(mx)->char2byte(), s->at(i+1)->oclAsType(int)}->max()->oclAsType(String) )  ;     i := i + 1 ) ; 
    var r : String ; r := "" ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = mx) then (     r := r+(mx) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(r) ; 
 )   catch (e : ProgramException) do (     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] arg)throws IOException {
    new Main().read();
  }
  public void read()throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    int N,A ;
    N=Integer.parseInt(in.readLine());
    A=Integer.parseInt(in.readLine());
    System.out.println(N*N-A);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().read() );
   operation read() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var N : int ;
    var A : int ;
    N := (in.readLine())->toInteger() ; 
    A := (in.readLine())->toInteger() ; 
    OclFile["System.out"].println(N * N - A) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int N=stdIn.nextInt();
    int A=stdIn.nextInt();
    int answer=N*N-A ;
    System.out.print(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := stdIn.getCurrent()->toInteger() ;
    var A : int ; A := stdIn.getCurrent()->toInteger() ;
    var answer : int ; answer := N * N - A ;
    OclFile["System.out"].print(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int input=sc.nextInt();
    if(input % 2==0){
      System.out.println(input/2);
    }
    else {
      System.out.println(input/2+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : int ; input := sc.getCurrent()->toInteger() ;
     if (input mod 2 = 0) then (     OclFile["System.out"].println(input / 2) ) else (     OclFile["System.out"].println(input / 2 + 1) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String in=br.readLine();
      String chr[]=in.split(" ");
      int n=Integer.parseInt(chr[0]);
      System.out.println(n % 2==0 ? n/2 :(n+1)/2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var in : String ; in := br.readLine() ;
     var chr : Sequence(String) ; chr := in->split(" ") ;
     var n : int ; n := (chr[0+1])->toInteger() ;
     OclFile["System.out"].println(if n mod 2 = 0 then n / 2 else (n + 1) / 2 endif) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int ans=N/2+N % 2 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     var ans : int ; ans := N / 2 + N mod 2 ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    double n=0 ;
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    double x ;
    if(n % 2==0){
      x=n/2 ;
    }
    else {
      x=n/2+0.5 ;
    }
    int y=(int)x ;
    System.out.println(y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 0 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := sc.getCurrent()->toInteger() ; 
    var x : double ;
    if (n mod 2 = 0) then (     x := n / 2 ) else (     x := n / 2 + 0.5 ) ;  
    var y : int ; y := x->oclAsType(int) ;
    OclFile["System.out"].println(y) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws Exception {
    final Scanner sc=new Scanner(System.in);
    long N ;
    N=sc.nextLong();
    System.out.println((N+1)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ;
     N := sc.getCurrent()->toLong() ; 
     OclFile["System.out"].println((N + 1) / 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int averageOdd(int n){
    if(n % 2==0){
      System.out.println("Invalid Input");
      return-1 ;
    }
    return(n+1)/2 ;
  }
  public static void main(String args[]){
    int n=15 ;
    System.out.println(averageOdd(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation averageOdd( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 = 0) then (     OclFile["System.out"].println("Invalid Input") ; 
     return -1 ) else skip ; 
     return (n + 1) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     OclFile["System.out"].println(averageOdd(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _194A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    if(k/n>2){
      System.out.println(0);
    }
    else {
      System.out.println(n-k % n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _194A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     if (k / n > 2) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(n - k mod n) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),k=sc.nextInt();
    n-=(k-n*2);
    System.out.print(Math.max(n,0));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
     n := n-((k - n * 2)) ; 
     OclFile["System.out"].print(Set{n, 0}->max()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_194 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),k=sc.nextInt();
    n-=(k-n*2);
    System.out.print(Math.max(n,0));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_194 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
     n := n-((k - n * 2)) ; 
     OclFile["System.out"].print(Set{n, 0}->max()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder();
    int n=fs.nextInt();
    long c=fs.nextLong();
    Long[] a=fs.readArray(n);
    int cnt=0 ;
    for(int i=1 ; i<n ; i++){
      if(a[i]-a[i-1]>c)cnt=0 ;
      else cnt++;
    }
    out.println(cnt+1);
    out.close();
  }
  static int isPerfectSquare(int x){
    if(x>=0){
      int sr=(int)Math.sqrt(x);
      if((sr*sr)==x)return sr ;
      else return 0 ;
    }
    return 0 ;
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    Long[] readArray(int n){
      Long[] a=new Long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := fs.nextInt() ;
    var c : long ; c := fs.nextLong() ;
    var a : Sequence(long) ; a := fs.readArray(n) ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] - a[i - 1+1] > c) then     cnt := 0 ; else     cnt := cnt + 1 ; )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation isPerfectSquare( x : int) : int
  pre: true
  post: true
  activity: (     if (x >= 0) then (     var sr : int ; sr := (x)->sqrt()->oclAsType(int) ;
     if ((sr * sr) = x) then     return sr else     return 0 ) else skip ; 
     return 0 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math.*;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int AG ;
    int op ;
    AG=sc.nextInt();
    op=sc.nextInt();
    int h=AG*3 ;
    System.out.println(op<=h ? h-op : 0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var AG : int ;
    var op : int ;
    AG := sc.getCurrent()->toInteger() ; 
    op := sc.getCurrent()->toInteger() ; 
    var h : int ; h := AG * 3 ;
    OclFile["System.out"].println(if op <= h then h - op else 0 endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static final Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    long ans=0 ;
    for(int i=1 ; i<=3 ; i++){
      ans+=Math.pow(n,i);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ans : long ; ans := 0 ;
         var i : int ; i := 1 ; while i <= 3 do ( (     ans := ans+(n->pow(i)) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.InputMismatchException ;
import java.io.IOException ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    FastReader in=new FastReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ACalc solver=new ACalc();
    solver.solve(1,in,out);
    out.close();
  }
  static class ACalc {
    public void solve(int testNumber,FastReader in,PrintWriter out){
      long a=in.nextLong();
      out.println((long)(Math.pow(a,2)+Math.pow(a,3)+a));
    }
  }
  static class FastReader {
    private InputStream stream ;
    private byte[] buf=new byte[8192];
    private int curChar ;
    private int pnumChars ;
    public FastReader(InputStream stream){
      this.stream=stream ;
    }
    private int pread(){
      if(pnumChars==-1){
        throw new InputMismatchException();
      }
      if(curChar>=pnumChars){
        curChar=0 ;
        try {
          pnumChars=stream.read(buf);
        }
        catch(IOException e){
          throw new InputMismatchException();
        }
        if(pnumChars<=0){
          return-1 ;
        }
      }
      return buf[curChar++];
    }
    public long nextLong(){
      int c=pread();
      while(isSpaceChar(c))c=pread();
      int sgn=1 ;
      if(c=='-'){
        sgn=-1 ;
        c=pread();
      }
      long res=0 ;
      do {
        if(c<'0' || c>'9'){
          throw new InputMismatchException();
        }
        res*=10 ;
        res+=c-'0' ;
        c=pread();
      }
      while(! isSpaceChar(c));
      return res*sgn ;
    }
    private boolean isSpaceChar(int c){
      return c==' ' || c=='\n' || c=='\r' || c=='\t' || c==-1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : FastReader ; in := FastReader.newFastReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ACalc ; solver := ACalc.newACalc() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ACalc {
   operation solve( testNumber : int, in : FastReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : long ; a := in.nextLong() ;
     skip );
}
  static class FastReader {
   attribute stream : OclFile;
   attribute buf : Sequence(int) := Integer.subrange(1,8192)->collect(0);
   attribute curChar : int;
   attribute pnumChars : int;
   static operation newFastReader( stream : OclFile) : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     self.stream := stream );
   operation pread() : int
  pre: true
  post: true
  activity: (     if (pnumChars = -1) then (     error IncorrectElementException() ) else skip ; 
     if (curChar >= pnumChars) then (     curChar := 0 ; 
     try (     pnumChars := stream.read(buf) )   catch (e : IOException) do (     error IncorrectElementException() )
     if (pnumChars <= 0) then (     return -1 ) else skip ) else skip ; 
     return buf[curChar+1] );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     var c : int ; c := pread() ;
     while (isSpaceChar(c)) do     c := pread() ; ; 
    var sgn : int ; sgn := 1 ;
    if (c = '-') then (     sgn := -1 ; 
     c := pread() ) else skip ; 
    var res : long ; res := 0 ;
  while true do ((     if (c < '0' or c > '9') then (     error IncorrectElementException() ) else skip ; 
     res := res*(10) ; 
     res := res+(c - ('0')->char2byte()) ; 
     c := pread() ) ;
    if (not(isSpaceChar(c))) then skip else break) ; 
    return res * sgn 
 );
   operation isSpaceChar( c : int) : boolean
  pre: true
  post: true
  activity: (     return c = ' ' or c = '
' or c = '\r' or c = '\t' or c = -1 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    Main mainObj=new Main();
    mainObj.solve();
  }
  public void solve()throws IOException {
    FastScanner fs=new FastScanner();
    int a=fs.nextInt();
    int a2=a*a ;
    int a3=a*a*a ;
    System.out.println(a+a2+a3);
  }
  public class FastScanner {
    BufferedReader reader ;
    private StringTokenizer st ;
    public FastScanner(){
      st=null ;
      reader=new BufferedReader(new InputStreamReader(System.in));
    }
    public String next()throws IOException {
      if(st==null || ! st.hasMoreElements()){
        st=new StringTokenizer(reader.readLine());
      }
      return st.nextToken();
    }
    public String nextLine()throws IOException {
      st=null ;
      String readLine=null ;
      readLine=reader.readLine();
      return readLine ;
    }
    public int nextInt()throws NumberFormatException,IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws NumberFormatException,IOException {
      return Long.parseLong(next());
    }
    public int[] nextIntArr(int n)throws NumberFormatException,IOException {
      int[] retArr=new int[n];
      for(int i=0 ; i<n ; i++){
        retArr[i]=nextInt();
      }
      return retArr ;
    }
    public long[] nextLongArr(int n)throws NumberFormatException,IOException {
      long[] retArr=new long[n];
      for(int i=0 ; i<n ; i++){
        retArr[i]=nextLong();
      }
      return retArr ;
    }
    public void close()throws IOException {
      reader.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mainObj : Main ; mainObj := Main.newMain() ;
     mainObj.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var a : int ; a := fs.nextInt() ;
    var a2 : int ; a2 := a * a ;
    var a3 : int ; a3 := a * a * a ;
    OclFile["System.out"].println(a + a2 + a3) ; 
 );
 class FastScanner {
   attribute reader : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     st := null ; 
     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (st = null or not(st.hasNext())) then (     st := OclIterator.newOclIterator_String(reader.readLine()) ) else skip ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     st := null ; 
     var readLine : String ; readLine := null ;
     readLine := reader.readLine() ; 
     return readLine );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextIntArr( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var retArr : Sequence(int) ; retArr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     retArr[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return retArr );
   operation nextLongArr( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var retArr : Sequence(long) ; retArr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     retArr[i+1] := nextLong() )  ;     i := i + 1 ) ; 
     return retArr );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    System.out.println(n*(1+n*(1+n)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(n * (1 + n * (1 + n))) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    long result=a+a*a+a*a*a ;
    System.out.println(result);
  }
  public static class Scanner {
    private BufferedReader br ;
    private StringTokenizer tok ;
    public Scanner(InputStream is)throws IOException {
      br=new BufferedReader(new InputStreamReader(is));
    }
    private void getLine()throws IOException {
      while(! hasNext())tok=new StringTokenizer(br.readLine());
    }
    private boolean hasNext(){
      return tok!=null && tok.hasMoreTokens();
    }
    public String next()throws IOException {
      getLine();
      return tok.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var result : long ; result := a + a * a + a * a * a ;
     OclFile["System.out"].println(result) );
  static class Scanner {
   attribute br : OclFile;
   attribute tok : OclIterator;
   static operation newScanner( is : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
   operation getLine() : void
  pre: true
  post: true
  activity: (     while (not(hasNext())) do     tok := OclIterator.newOclIterator_String(br.readLine()) ; );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return tok /= null & tok.hasNext() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute getLine() ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class D {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(in.readLine());
    adj=new ArrayList[n];
    for(int a=0 ; a<n ; a++)adj[a]=new ArrayList<Integer>();
    for(int a=0 ; a<n-1 ; a++){
      StringTokenizer token=new StringTokenizer(in.readLine());
      int x=Integer.parseInt(token.nextToken())-1 ;
      int y=Integer.parseInt(token.nextToken())-1 ;
      adj[x] .add(y);
      adj[y] .add(x);
    }
    int sub=0 ;
    for(int a=0 ; a<n ; a++){
      int num1s=0 ;
      for(int b : adj[a]){
        if(adj[b] .size()==1)num1s++;
      }
      if(num1s<=1)continue ;
      sub+=num1s-1 ;
    }
    boolean flat=true ;
    for(int a=0 ; a<n ; a++)if(adj[a] .size()>2)flat=false ;
    if(dfs(0,-1)==Integer.MIN_VALUE ||(flat && n % 2==0))System.out.println("3 "+(n-1-sub));
    else System.out.println("1 "+(n-1-sub));
  }
  static ArrayList<Integer>[] adj ;
  static int dfs(int curr,int par){
    int currpar=-1 ;
    for(int a : adj[curr])if(a!=par){
      int temp=dfs(a,curr);
      if(temp==Integer.MIN_VALUE)return Integer.MIN_VALUE ;
      if(currpar==-1)currpar=temp ;
      else if(temp!=currpar)return Integer.MIN_VALUE ;
    }
    return(currpar+1)% 2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (in.readLine())->toInteger() ;
    adj := Integer.subrange(1,n)->collect(null) ; 
        var a : int ; a := 0 ; while a < n do (     adj[a+1] := Sequence{} ;  ;     a := a + 1 ) ; 
        var a : int ; a := 0 ; while a < n - 1 do ( (     var token : OclIterator ; token := OclIterator.newOclIterator_String(in.readLine()) ;
     var x : int ; x := (token.next())->toInteger() - 1 ;
    var y : int ; y := (token.next())->toInteger() - 1 ;
    adj[x+1]->excludes(y) ; 
    adj[y+1]->excludes(x) ; 
 )  ;     a := a + 1 ) ; 
    var sub : int ; sub := 0 ;
        var a : int ; a := 0 ; while a < n do ( (     var num1s : int ; num1s := 0 ;
     for (b : adj[a+1]) do ( (     if (adj[b+1]->size() = 1) then     num1s := num1s + 1 ; else skip )  ) ; 
     if (num1s <= 1) then     continue else skip ; 
     sub := sub+(num1s - 1) )  ;     a := a + 1 ) ; 
    var flat : boolean ; flat := true ;
        var a : int ; a := 0 ; while a < n do (     if (adj[a+1]->size() > 2) then     flat := false ; else skip ;  ;     a := a + 1 ) ; 
    if (dfs(0, -1) = -2147483648 or (flat & n mod 2 = 0)) then     OclFile["System.out"].println("3 " + (n - 1 - sub)) else     OclFile["System.out"].println("1 " + (n - 1 - sub)) ; ;  
 );
  static   attribute adj : Sequence(Sequence(int));
  static   operation dfs( curr : int, par : int) : int
  pre: true
  post: true
  activity: (     var currpar : int ; currpar := -1 ;
     for (a : adj[curr+1]) do (     if (a /= par) then (     var temp : int ; temp := dfs(a, curr) ;
     if (temp = -2147483648) then     return -2147483648 else skip ; 
     if (currpar = -1) then     currpar := temp ; else     if (temp /= currpar) then     return -2147483648 else skip ; ) else skip ;  ) ; 
     return (currpar + 1) mod 2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      if(100 % n==0)System.out.println(100/n);
      else {
        int k=n/2 ;
        for(int i=k ; i>=1 ; i--){
          if(n % i==0 &&(100-n)% i==0){
            System.out.println(100/i);
            break ;
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (100 mod n = 0) then     OclFile["System.out"].println(100 / n) ; else (     var k : int ; k := n / 2 ;
         var i : int ; i := k ; while i >= 1 do ( (     if (n mod i = 0 & (100 - n) mod i = 0) then (     OclFile["System.out"].println(100 / i) ; 
     break ) else skip )  ;     i := i - 1 ) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int k=sc.nextInt();
      int gcd=gcd(100,k);
      System.out.println(100/gcd);
    }
    sc.close();
  }
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var k : int ; k := sc.getCurrent()->toInteger() ;
     var gcd : int ; gcd := gcd(100, k) ;
     OclFile["System.out"].println(100 / gcd) ) ;  ) ;  
     skip );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test281 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int x=in.nextInt();
      int g=gcd(100,x);
      System.out.println(100/g);
    }
    in.close();
  }
  private static int gcd(int x,int i){
    if(i==0)return x ;
    else {
      return gcd(i,x % i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class test281 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var g : int ; g := gcd(100, x) ;
     OclFile["System.out"].println(100 / g) )  ;     j := j + 1 ) ; 
     skip );
  static   operation gcd( x : int, i : int) : int
  pre: true
  post: true
  activity: (     if (i = 0) then     return x else (     return gcd(i, x mod i) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n % 2==0)System.out.println(((n/2)+1)*((n/2)+1));
    else System.out.println((n+1)/2*(n+3)/2*2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then     OclFile["System.out"].println(((n / 2) + 1) * ((n / 2) + 1)) ; else     OclFile["System.out"].println((n + 1) / 2 * (n + 3) / 2 * 2) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A716 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int c=scanner.nextInt();
    int[] t=new int[n];
    for(int i=0 ; i<n ; i++){
      t[i]=scanner.nextInt();
    }
    scanner.close();
    int ans=1 ;
    for(int i=n-1 ; i>=1 ; i--){
      if(t[i]-t[i-1]<=c){
        ans++;
      }
      else {
        break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A716 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     t[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : int ; ans := 1 ;
        var i : int ; i := n - 1 ; while i >= 1 do ( (     if (t[i+1] - t[i - 1+1] <= c) then (     ans := ans + 1 ) else (     break ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    if(n % 2==0)System.out.println(((n/2)+1)*((n/2)+1));
    else System.out.println((n+1)/2*(n+3)/2*2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then     OclFile["System.out"].println(((n / 2) + 1) * ((n / 2) + 1)) ; else     OclFile["System.out"].println((n + 1) / 2 * (n + 3) / 2 * 2) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Security0728E {
  public static void main(String[] args){
    Scanner reader=new Scanner(System.in);
    int n=reader.nextInt();
    System.out.println(change(n));
  }
  private static long change(int n){
    if(n % 2==0){
      return(long)(n/2+1)*(n/2+1);
    }
    return 2L*(n/2+1)*(n/2+2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Security0728E {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := reader.getCurrent()->toInteger() ;
     OclFile["System.out"].println(change(n)) );
  static   operation change( n : int) : long
  pre: true
  post: true
  activity: (     if (n mod 2 = 0) then (     return (n / 2 + 1)->oclAsType(long) * (n / 2 + 1) ) else skip ; 
     return 2L * (n / 2 + 1) * (n / 2 + 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class E {
  int possiblemove(int n){
    int[] dp=new int[1001];
    dp[0]=1 ;
    dp[1]=4 ;
    for(int i=2 ; i<=n ; ++i){
      if((i & 1)==0){
        dp[i]=(i+1)*(i+1)-dp[i-1]-dp[i-2];
      }
      else {
        dp[i]=4*dp[i-1]-dp[i-2];
      }
    }
    return dp[n];
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    E test=new E();
    System.out.println(test.possiblemove(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class E {
   operation possiblemove( n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,1001)->collect(0) ;
     dp[0+1] := 1 ; 
    dp[1+1] := 4 ; 
        var i : int ; i := 2 ; while i <= n do ( (     if ((MathLib.bitwiseAnd(i,1)) = 0) then (     dp[i+1] := (i + 1) * (i + 1) - dp[i - 1+1] - dp[i - 2+1] ) else (     dp[i+1] := 4 * dp[i - 1+1] - dp[i - 2+1] ) )  ;     i := i + 1 ) ; 
    return dp[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var test : E ; test := E.newE() ;
     OclFile["System.out"].println(test.possiblemove(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n % 2==0)System.out.println(((n/2)+1)*((n/2)+1));
    else System.out.println((n+1)/2*(n+3)/2*2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then     OclFile["System.out"].println(((n / 2) + 1) * ((n / 2) + 1)) ; else     OclFile["System.out"].println((n + 1) / 2 * (n + 3) / 2 * 2) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static PrintWriter out=new PrintWriter(System.out);
  static Scanner in=new Scanner(System.in);
  static BufferedReader re=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter wr=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws IOException {
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int T=in.nextInt();
    while(T>0){
      int n=in.nextInt();
      if(n % 2==0){
        for(int i=n-2 ; i>=1 ; i--){
          out.print(i+" ");
        }
        out.print(n-1+" ");
        out.print(n);
        out.println();
      }
      else {
        out.print("1 ");
        for(int i=n-2 ; i>=2 ; i--){
          out.print(i+" ");
        }
        out.print(n-1+" ");
        out.print(n);
        out.println();
      }
      T--;
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute re : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute wr : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
     while (T > 0) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (         var i : int ; i := n - 2 ; while i >= 1 do ( (     skip )  ;     i := i - 1 ) ; 
     skip ; 
     skip ; 
     skip ) else (     skip ; 
         var i : int ; i := n - 2 ; while i >= 2 do ( (     skip )  ;     i := i - 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 ) ;  
     T := T - 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static Boolean areElementsContiguous(int arr[],int n){
    HashSet<Integer>us=new HashSet<Integer>();
    for(int i=0 ; i<n ; i++)us.add(arr[i]);
    int count=1 ;
    int curr_ele=arr[0]-1 ;
    while(us.contains(curr_ele)==true){
      count++;
      curr_ele--;
    }
    curr_ele=arr[0]+1 ;
    while(us.contains(curr_ele)==true){
      count++;
      curr_ele++;
    }
    return(count==(us.size()));
  }
  public static void main(String[] args){
    int arr[]={
      5,2,3,6,4,4,6,6 };
      int n=arr.length ;
      if(areElementsContiguous(arr,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation areElementsContiguous( arr : Sequence(int), n : int) : Boolean
  pre: true
  post: true
  activity: (     var us : Set(int) ; us := Set{} ;
         var i : int ; i := 0 ; while i < n do (     us := us->including(arr[i+1]) ;  ;     i := i + 1 ) ; 
    var count : int ; count := 1 ;
    var curr_ele : int ; curr_ele := arr[0+1] - 1 ;
    while (us->includes(curr_ele) = true) do (     count := count + 1 ; 
     curr_ele := curr_ele - 1 ) ; 
    curr_ele := arr[0+1] + 1 ; 
    while (us->includes(curr_ele) = true) do (     count := count + 1 ; 
     curr_ele := curr_ele + 1 ) ; 
    return (count = (us->size())) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,2,3,6,4,4,6,6} ;
     var n : int ; n := arr->size() ;
     if (areElementsContiguous(arr, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class BestPermutation {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      t--;
      int n=sc.nextInt();
      if(n % 3==2){
        for(int i=1 ; i<=n ; i++){
          System.out.print(i+" ");
        }
      }
      else {
        System.out.print(n-2+" ");
        for(int i=2 ; i<=n-3 ; i++){
          System.out.print(i+" ");
        }
        System.out.print(1+" "+(n-1)+" "+n);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BestPermutation {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     t := t - 1 ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n mod 3 = 2) then (         var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i + 1 ) ) else (     OclFile["System.out"].print(n - 2 + " ") ; 
         var i : int ; i := 2 ; while i <= n - 3 do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(1 + " " + (n - 1) + " " + n) ) ;  
     OclFile["System.out"].println() ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B {
  public static void main(String[] args){
    try(Scanner s=new Scanner(System.in)){
      int cnt=s.nextInt();
      for(int i=0 ; i<cnt ; i++){
        int n=s.nextInt();
        if(n % 2==0){
          for(int j=n-2 ; j>0 ; j--){
            System.out.print(j+" ");
          }
        }
        else {
          System.out.print(1+" ");
          for(int j=1 ; j<n-3 ; j+=2){
            System.out.print((j+2)+" "+(j+1)+" ");
          }
        }
        System.out.println((n-1)+" "+n);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var cnt : int ; cnt := s.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < cnt do ( (     var n : int ; n := s.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (         var j : int ; j := n - 2 ; while j > 0 do ( (     OclFile["System.out"].print(j + " ") )  ;     j := j - 1 ) ) else (     OclFile["System.out"].print(1 + " ") ; 
         var j : int ; j := 1 ; while j < n - 3 do ( (     OclFile["System.out"].print((j + 2) + " " + (j + 1) + " ") )  ;     j := j+(2) ) ) ;  
     OclFile["System.out"].println((n - 1) + " " + n) )  ;     i := i + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static double aver(int[] arr){
    int sum=0 ;
    for(int i=0 ; i<arr.length ; i++){
      sum=sum+arr[i];
    }
    return sum/arr.length ;
  }
  public static int fac(int x){
    int sum=1 ;
    while(x>0){
      sum=sum*x ;
      x=x-1 ;
    }
    return sum ;
  }
  public static int comb(int x,int y){
    int sum=0 ;
    sum=fac(x);
    int temp=(fac(y)*fac(x-y));
    return sum/temp ;
  }
  public static int comp(String x,String y){
    int count=0 ;
    String[] arr=x.split("");
    String[] arrr=y.split("");
    for(int i=0 ; i<arrr.length ; i++){
      if(! arr[i] .equals(arrr[i]))count+=1 ;
    }
    return count ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n>0){
      int x=sc.nextInt();
      while(x>0){
        System.out.print(1+" ");
        x=x-1 ;
      }
      System.out.println();
      n=n-1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation aver( arr : Sequence(int)) : double
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     sum := sum + arr[i+1] )  ;     i := i + 1 ) ; 
     return sum / arr->size() );
  static   operation fac( x : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 1 ;
     while (x > 0) do (     sum := sum * x ; 
     x := x - 1 ) ; 
     return sum );
  static   operation comb( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     sum := fac(x) ; 
     var temp : int ; temp := (fac(y) * fac(x - y)) ;
     return sum / temp );
  static   operation comp( x : String, y : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var arr : Sequence(String) ; arr := x->split("") ;
    var arrr : Sequence(String) ; arrr := y->split("") ;
        var i : int ; i := 0 ; while i < arrr->size() do ( (     if (not(arr[i+1] = arrr[i+1])) then     count := count+(1) ; else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     while (n > 0) do (     var x : int ; x := sc.getCurrent()->toInteger() ;
     while (x > 0) do (     OclFile["System.out"].print(1 + " ") ; 
     x := x - 1 ) ; 
     OclFile["System.out"].println() ; 
     n := n - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CD {
  private static int max ;
  public static void main(String[] args){
    Scanner st=new Scanner(System.in);
    int t=st.nextInt();
    while(t-->0){
      int a=st.nextInt();
      int[] arr=new int[a];
      for(int i=0 ; i<a ; i++){
        arr[i]=1 ;
      }
      for(int i : arr){
        System.out.print(i+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CD {
  static   attribute max : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var st : OclFile ; st := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := st.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := st.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,a)->collect(0) ;
        var i : int ; i := 0 ; while i < a do ( (     arr[i+1] := 1 )  ;     i := i + 1 ) ; 
    for (i : arr) do ( (     OclFile["System.out"].print(i + " ") )  ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class pre423 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int tc=obj.nextInt();
    while(tc--!=0){
      int n=obj.nextInt();
      for(int i=1 ; n!=0 ; i+=2,n--){
        if(i>=1000)i=1 ;
        System.out.print(i+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre423 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var tc : int ; tc := obj.nextInt() ;
         while (tc /= 0) do (    skip ; (     var n : int ; n := obj.nextInt() ;
         var i : int ; i := 1 ; while n /= 0 do ( (     if (i >= 1000) then     i := 1 ; else skip ; 
     OclFile["System.out"].print(i + " ") )  ;     i := i+(2) ;     n := n - 1 ) ; 
     OclFile["System.out"].println() ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A716 {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int c=input.nextInt();
    int[] t=new int[n];
    for(int i=0 ; i<n ; ++i)t[i]=input.nextInt();
    int s=1 ;
    int i=n-1 ;
    while(i>0 && t[i]-t[i-1]<=c){
--i ;
      s++;
    }
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A716 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var c : int ; c := input.getCurrent()->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     t[i+1] := input.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var s : int ; s := 1 ;
    var i : int ; i := n - 1 ;
    while (i > 0 & t[i+1] - t[i - 1+1] <= c) do (     i := i - 1 ; 
     s := s + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test189 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      for(int i=0 ; i<n ; i++){
        System.out.print("1 ");
      }
      System.out.println();
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test189 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print("1 ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1372 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      for(int i=0 ; i<n-1 ; i++){
        System.out.print(1+" ");
      }
      System.out.println(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1372 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     OclFile["System.out"].print(1 + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(1) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Dispatcher {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int q=scan.nextInt();
    for(int t=0 ; t<q ; t++){
      int n=scan.nextInt();
      if(n<4){
        System.out.println(4-n);
      }
      else {
        if(n % 2!=0)System.out.println("1");
        else System.out.println("0");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Dispatcher {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := scan.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < q do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     if (n < 4) then (     OclFile["System.out"].println(4 - n) ) else (     if (n mod 2 /= 0) then     OclFile["System.out"].println("1") ; else     OclFile["System.out"].println("0") ; ) )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class spich {
  public static int isCount(int n){
    if(n<4)return 4-n ;
    else if(n % 2==0)return 0 ;
    else return 1 ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int cou=in.nextInt();
    int[] n=new int[cou];
    for(int i=0 ; i<cou ; i++){
      n[i]=in.nextInt();
      System.out.println(isCount(n[i]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class spich {
  static   operation isCount( n : int) : int
  pre: true
  post: true
  activity: (     if (n < 4) then     return 4 - n else     if (n mod 2 = 0) then     return 0 else     return 1 ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cou : int ; cou := in.getCurrent()->toInteger() ;
     var n : Sequence(int) ; n := Integer.subrange(1,cou)->collect(0) ;
         var i : int ; i := 0 ; while i < cou do ( (     n[i+1] := in.getCurrent()->toInteger() ; 
     OclFile["System.out"].println(isCount(n[i+1])) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int getLeftMostZero(Queue<Integer>zero){
    if(zero.isEmpty())return-1 ;
    zero.remove();
    return 0 ;
  }
  static int getLeftMostOne(Queue<Integer>one){
    if(one.isEmpty())return-1 ;
    one.remove();
    return 1 ;
  }
  static int getLeftMostElement(Queue<Integer>zero,Queue<Integer>one){
    if(zero.isEmpty()&& one.isEmpty())return-1 ;
    else if(zero.isEmpty()){
      one.remove();
      return 1 ;
    }
    else if(one.isEmpty()){
      zero.remove();
      return 0 ;
    }
    int res=(zero.peek()<one.peek())? 0 : 1 ;
    if(res==0)zero.remove();
    else one.remove();
    return res ;
  }
  static void performQueries(int arr[],int n,int queries[],int q){
    Queue<Integer>zero=new LinkedList<>();
    Queue<Integer>one=new LinkedList<>();
    for(int i=0 ; i<n ; i++){
      if(arr[i]==0)zero.add(i);
      else one.add(i);
    }
    for(int i=0 ; i<q ; i++){
      int type=queries[i];
      switch(type){
        case 1 : System.out.println(getLeftMostZero(zero));
        break ;
        case 2 : System.out.println(getLeftMostOne(one));
        break ;
        case 3 : System.out.println(getLeftMostElement(zero,one));
        break ;
      }
    }
  }
  public static void main(String args[]){
    int arr[]={
      1,0,1,1,1 };
      int n=arr.length ;
      int queries[]={
        1,3,1 };
        int q=queries.length ;
        performQueries(arr,n,queries,q);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getLeftMostZero( zero : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (zero->isEmpty()) then     return -1 else skip ; 
     zero := zero.remove() ; 
     return 0 );
  static   operation getLeftMostOne( one : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (one->isEmpty()) then     return -1 else skip ; 
     one := one.remove() ; 
     return 1 );
  static   operation getLeftMostElement( zero : Sequence(int), one : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (zero->isEmpty() & one->isEmpty()) then     return -1 else     if (zero->isEmpty()) then (     one := one.remove() ; 
     return 1 ) else     if (one->isEmpty()) then (     zero := zero.remove() ; 
     return 0 ) else skip ; ;  ;  
     var res : int ; res := if (zero->min() < one->min()) then 0 else 1 endif ;
     if (res = 0) then     zero := zero.remove() else     one := one.remove() ; ;  
     return res );
  static   operation performQueries( arr : Sequence(int), n : int, queries : Sequence(int), q : int) : void
  pre: true
  post: true
  activity: (     var zero : Sequence(int) ; zero := Sequence{} ;
     var one : Sequence(int) ; one := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 0) then     zero := zero->including(i) ; else     one := one->including(i) ; )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < q do ( (     var type : int ; type := queries[i+1] ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (type) ; 
       if _switchval = 1 then
     OclFile["System.out"].println(getLeftMostZero(zero)) ; 
    break 
   else skip ;
       if _switchval = 2 then
     OclFile["System.out"].println(getLeftMostOne(one)) ; 
    break 
   else skip ;
       if _switchval = 3 then
     OclFile["System.out"].println(getLeftMostElement(zero, one)) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,0,1,1,1} ;
     var n : int ; n := arr->size() ;
    var queries : Sequence(int) ; queries := Sequence{1,3,1} ;
    var q : int ; q := queries->size() ;
    execute performQueries(arr, n, queries, q) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class main {
  public static int isCount(int n){
    if(n<4)return 4-n ;
    else if(n % 2==0)return 0 ;
    else return 1 ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int cou=in.nextInt();
    int[] n=new int[cou];
    for(int i=0 ; i<cou ; i++){
      n[i]=in.nextInt();
      System.out.println(isCount(n[i]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation isCount( n : int) : int
  pre: true
  post: true
  activity: (     if (n < 4) then     return 4 - n else     if (n mod 2 = 0) then     return 0 else     return 1 ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cou : int ; cou := in.getCurrent()->toInteger() ;
     var n : Sequence(int) ; n := Integer.subrange(1,cou)->collect(0) ;
         var i : int ; i := 0 ; while i < cou do ( (     n[i+1] := in.getCurrent()->toInteger() ; 
     OclFile["System.out"].println(isCount(n[i+1])) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class NewClass4 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=in.nextInt();
      if(n==1 || n==2)System.out.println(2);
      else {
        if(n % 2==1)System.out.println(1);
        else System.out.println(0);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass4 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 1 or n = 2) then     OclFile["System.out"].println(2) ; else (     if (n mod 2 = 1) then     OclFile["System.out"].println(1) ; else     OclFile["System.out"].println(0) ; ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    while(q-->0){
      int n=sc.nextInt();
      if(n==1)System.out.println(3);
      else if(n==2)System.out.println(2);
      else System.out.println(n % 2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
         while (q > 0) do (        q := q - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 1) then     OclFile["System.out"].println(3) ; else     if (n = 2) then     OclFile["System.out"].println(2) else     OclFile["System.out"].println(n mod 2) ; ;  ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    if(t==0)System.out.println("1");
    else if((t-1)% 4==0)System.out.println("8");
    else if((t-1)% 4==1)System.out.println("4");
    else if((t-1)% 4==2)System.out.println("2");
    else System.out.println("6");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     if (t = 0) then     OclFile["System.out"].println("1") ; else     if ((t - 1) mod 4 = 0) then     OclFile["System.out"].println("8") else     if ((t - 1) mod 4 = 1) then     OclFile["System.out"].println("4") else     if ((t - 1) mod 4 = 2) then     OclFile["System.out"].println("2") else     OclFile["System.out"].println("6") ; ;  ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n==0)System.out.println(1);
    else if((n)% 4==1)System.out.println(8);
    else if((n)% 4==2)System.out.println(4);
    else if((n)% 4==3)System.out.println(2);
    else System.out.println(6);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     OclFile["System.out"].println(1) ; else     if ((n) mod 4 = 1) then     OclFile["System.out"].println(8) else     if ((n) mod 4 = 2) then     OclFile["System.out"].println(4) else     if ((n) mod 4 = 3) then     OclFile["System.out"].println(2) else     OclFile["System.out"].println(6) ; ;  ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n==0)System.out.println(1);
    else if((n-1)% 4==0)System.out.println(8);
    else if((n-1)% 4==1)System.out.println(4);
    else if((n-1)% 4==2)System.out.println(2);
    else System.out.println(6);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     OclFile["System.out"].println(1) ; else     if ((n - 1) mod 4 = 0) then     OclFile["System.out"].println(8) else     if ((n - 1) mod 4 = 1) then     OclFile["System.out"].println(4) else     if ((n - 1) mod 4 = 2) then     OclFile["System.out"].println(2) else     OclFile["System.out"].println(6) ; ;  ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class CrazyComputer {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(reader.readLine());
    int n=Integer.parseInt(st.nextToken());
    long c=Long.parseLong(st.nextToken());
    int count=1 ;
    st=new StringTokenizer(reader.readLine());
    long now=Long.parseLong(st.nextToken());
    for(int i=1 ; i<n ; i++){
      long hehe=Long.parseLong(st.nextToken());
      if(hehe-now>c){
        count=1 ;
      }
      else count++;
      now=hehe ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CrazyComputer {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(reader.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var c : long ; c := (st.next())->toLong() ;
    var count : int ; count := 1 ;
    st := OclIterator.newOclIterator_String(reader.readLine()) ; 
    var now : long ; now := (st.next())->toLong() ;
        var i : int ; i := 1 ; while i < n do ( (     var hehe : long ; hehe := (st.next())->toLong() ;
     if (hehe - now > c) then (     count := 1 ) else     count := count + 1 ; ;  
     now := hehe )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n==0)System.out.println("1");
    else if((n-1)% 4==0)System.out.println("8");
    else if((n-1)% 4==1)System.out.println("4");
    else if((n-1)% 4==2)System.out.println("2");
    else System.out.println("6");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     OclFile["System.out"].println("1") ; else     if ((n - 1) mod 4 = 0) then     OclFile["System.out"].println("8") else     if ((n - 1) mod 4 = 1) then     OclFile["System.out"].println("4") else     if ((n - 1) mod 4 = 2) then     OclFile["System.out"].println("2") else     OclFile["System.out"].println("6") ; ;  ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n==0)System.out.println("1");
    else if((n-1)% 4==0)System.out.println("8");
    else if((n-1)% 4==1)System.out.println("4");
    else if((n-1)% 4==2)System.out.println("2");
    else System.out.println("6");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     OclFile["System.out"].println("1") ; else     if ((n - 1) mod 4 = 0) then     OclFile["System.out"].println("8") else     if ((n - 1) mod 4 = 1) then     OclFile["System.out"].println("4") else     if ((n - 1) mod 4 = 2) then     OclFile["System.out"].println("2") else     OclFile["System.out"].println("6") ; ;  ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _246A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n<=2)System.out.println(-1);
    else {
      while(n!=0){
        System.out.print(n+" ");
        n--;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n <= 2) then     OclFile["System.out"].println(-1) ; else (     while (n /= 0) do (     OclFile["System.out"].print(n + " ") ; 
     n := n - 1 ) ) );
}
46A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n <= 2) then     OclFile["System.out"].println(-1) ; else (     while (n /= 0) do (     OclFile["System.out"].print(n + " ") ; 
     n := n - 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void Vertices(int x,int y){
    int val=Math.abs(x)+Math.abs(y);
    System.out.print(val*(x<0 ?-1 : 1)+" 0 ");
    System.out.print("0 "+val*(y<0 ?-1 : 1));
  }
  public static void main(String[] args){
    int x=3,y=3 ;
    Vertices(x,y);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Vertices( x : int, y : int) : void
  pre: true
  post: true
  activity: (     var val : int ; val := if x < 0 then -(x) else x endif + if y < 0 then -(y) else y endif ;
     OclFile["System.out"].print(val * (if x < 0 then -1 else 1 endif) + " 0 ") ; 
     OclFile["System.out"].print("0 " + val * (if y < 0 then -1 else 1 endif)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 3 ;
    var y : int ; y := 3 ;
     execute Vertices(x, y) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BuggySorting_246A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n>2){
      for(int i=2 ; i<=n ; i++){
        System.out.print(i+" ");
      }
      System.out.println(1);
    }
    else {
      System.out.println(-1);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class BuggySorting{
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n > 2) then (         var i : int ; i := 2 ; while i <= n do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(-1) ) ;  
     skip );
}
46A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n > 2) then (         var i : int ; i := 2 ; while i <= n do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(-1) ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication75 {
  static boolean prime(int n){
    for(int i=2 ; i<n ; i++)if(n % i==0)return true ;
    return false ;
  }
  public static void main(String[] args){
    Scanner read=new Scanner(System.in);
    int n=read.nextInt();
    if(n==1 || n==2){
      System.out.println("-1");
      return ;
    }
    for(int i=n ; i>=1 ; i--)System.out.print(i+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication75 {
  static   operation prime( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i < n do (     if (n mod i = 0) then     return true else skip ;  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : OclFile ; read := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := read.getCurrent()->toInteger() ;
     if (n = 1 or n = 2) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
         var i : int ; i := n ; while i >= 1 do (     OclFile["System.out"].print(i + " ") ;  ;     i := i - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  static void printPath(int arr[],int idx){
    if(idx==1){
      System.out.print(idx+" ");
      return ;
    }
    printPath(arr,arr[idx-2]);
    System.out.print(idx+" ");
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n<=2){
      System.out.println(-1);
      return ;
    }
    System.out.print(100+" 99 ");
    for(int i=0 ; i<n-2 ; ++i){
      System.out.print(i+1+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation printPath( arr : Sequence(int), idx : int) : void
  pre: true
  post: true
  activity: (     if (idx = 1) then (     OclFile["System.out"].print(idx + " ") ; 
     return ) else skip ; 
     execute printPath(arr, arr[idx - 2+1]) ; 
     OclFile["System.out"].print(idx + " ") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    if (n <= 2) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    OclFile["System.out"].print(100 + " 99 ") ; 
        var i : int ; i := 0 ; while i < n - 2 do ( (     OclFile["System.out"].print(i + 1 + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=sc.nextInt();
    }
    if(sum % n==0){
      System.out.println(n);
    }
    else {
      System.out.println(n-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    if (sum mod n = 0) then (     OclFile["System.out"].println(n) ) else (     OclFile["System.out"].println(n - 1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class BIncreaseAndDecrease {
  public static void main(String[] args)throws IOException {
    BufferedReader buf=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(buf.readLine());
    String[] inp=buf.readLine().split(" ");
    int[] arr=new int[inp.length];
    long sum=0 ;
    for(int i=0 ; i<inp.length ; i++)sum+=Integer.parseInt(inp[i]);
    if(sum % arr.length==0)System.out.println(arr.length);
    else System.out.println(arr.length-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class BIncreaseAndDecrease {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var buf : OclFile ; buf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (buf.readLine())->toInteger() ;
    var inp : Sequence(String) ; inp := buf.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,inp->size())->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < inp->size() do (     sum := sum+((inp[i+1])->toInteger()) ;  ;     i := i + 1 ) ; 
    if (sum mod arr->size() = 0) then     OclFile["System.out"].println(arr->size()) else     OclFile["System.out"].println(arr->size() - 1) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),a=0,sum=0 ;
    for(int i=0 ; i<n ; i++){
      a=in.nextInt();
      sum+=a ;
    }
    System.out.printf("%d\n",sum % n==0 ? n : n-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : int ; a := 0 ;
    var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     a := in.getCurrent()->toInteger() ; 
     sum := sum+(a) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].printf("%d\n", if sum mod n = 0 then n else n - 1 endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int ans=0 ;
    if(n==1)ans=2 ;
    else if(n==0 || n==2)ans=1 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    if (n = 1) then     ans := 2 else     if (n = 0 or n = 2) then     ans := 1 ; else skip ; ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.HashSet ;
import java.util.Set ;
import java.util.StringTokenizer ;
public class cp_test2 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        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().trim();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  static class FastWriter {
    private final BufferedWriter bw ;
    public FastWriter(){
      this.bw=new BufferedWriter(new OutputStreamWriter(System.out));
    }
    public void print(Object object)throws IOException {
      bw.append(""+object);
    }
    public void println(Object object)throws IOException {
      print(object);
      bw.append("\n");
    }
    public void close()throws IOException {
      bw.close();
    }
  }
  public static void main(String[] args){
    try {
      FastReader in=new FastReader();
      FastWriter out=new FastWriter();
      int n=in.nextInt();
      long c=in.nextLong();
      long[] arr=new long[n];
      for(int i=0 ; i<n ; i++){
        long temp=in.nextLong();
        arr[i]=temp ;
      }
      int count=0 ;
      for(int i=1 ; i<n ; i++){
        if(arr[i]-arr[i-1]<=c){
          count++;
        }
        else {
          count=0 ;
        }
      }
      System.out.print(count+1);
    }
    catch(Exception e){
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp_test2 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine()->trim() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return str );
}
  static class FastWriter {
   attribute bw : OclFile;
   static operation newFastWriter() : FastWriter
  pre: true
  post: true
  activity:
  ( var self : FastWriter ;
    self := createFastWriter();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) );
   operation print( object : OclAny) : void
  pre: true
  post: true
  activity: (     skip );
   operation println( object : OclAny) : void
  pre: true
  post: true
  activity: (     execute print(object) ; 
     skip );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : FastWriter ; out := FastWriter.newFastWriter() ;
    var n : int ; n := in.nextInt() ;
    var c : long ; c := in.nextLong() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : long ; temp := in.nextLong() ;
     arr[i+1] := temp )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] - arr[i - 1+1] <= c) then (     count := count + 1 ) else (     count := 0 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(count + 1) ; 
 )   catch (e : ProgramException) do (     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    out.println(solve(sc.nextInt()));
    sc.close();
  }
  private static int solve(int n){
    if(n==0)return 1 ;
    if(n==1)return 2 ;
    if(n==2)return 1 ;
    return 0 ;
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     out.println(solve(sc.nextInt())) ; 
     sc.close() );
  static   operation solve( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     if (n = 1) then     return 2 else skip ; 
     if (n = 2) then     return 1 else skip ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    String str="" ;
    int mjs=0 ;
    str=bfr.readLine();
    mjs=Integer.parseInt(str);
    if(mjs==0){
      System.out.println("1");
    }
    else if(mjs==1){
      System.out.println("2");
    }
    else if(mjs==2){
      System.out.println("1");
    }
    else if(mjs>=3){
      System.out.println("0");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bfr : OclFile ; bfr := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := "" ;
    var mjs : int ; mjs := 0 ;
    str := bfr.readLine() ; 
    mjs := (str)->toInteger() ; 
    if (mjs = 0) then (     OclFile["System.out"].println("1") ) else     if (mjs = 1) then (     OclFile["System.out"].println("2") ) else     if (mjs = 2) then (     OclFile["System.out"].println("1") ) else     if (mjs >= 3) then (     OclFile["System.out"].println("0") ) else skip ; ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.HashSet ;
class GFG {
  public static void getSum(int[] a,int n){
    int[] P=new int[n];
    P[0]=a[0];
    for(int i=1 ; i<n ; i++)P[i]=a[i]+P[i-1];
    int S=P[n-1];
    HashMap<Integer,Integer>hash=new HashMap<>();
    for(int i=0 ; i<n ; i++)hash.put(P[i],1);
    HashSet<Integer>res=new HashSet<>();
    for(int i=1 ; i*i<=S ; i++){
      if(S % i==0){
        boolean pres=true ;
        int div1=i,div2=S/i ;
        for(int j=div1 ; j<=S ; j+=div1){
          if(hash.get(j)==null || hash.get(j)!=1){
            pres=false ;
            break ;
          }
        }
        if(pres && div1!=S)res.add(div1);
        pres=true ;
        for(int j=S/i ; j<=S ; j+=S/i){
          if(hash.get(j)==null || hash.get(j)!=1){
            pres=false ;
            break ;
          }
        }
        if(pres && div2!=S)res.add(div2);
      }
    }
    if(res.size()==0){
      System.out.println("-1");
      return ;
    }
    for(int i : res)System.out.print(i+" ");
  }
  public static void main(String[] args){
    int[] a={
      1,2,1,1,1,2,1,3 };
      int n=a.length ;
      getSum(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getSum( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var P : Sequence(int) ; P := Integer.subrange(1,n)->collect(0) ;
     P[0+1] := a[0+1] ; 
        var i : int ; i := 1 ; while i < n do (     P[i+1] := a[i+1] + P[i - 1+1] ;  ;     i := i + 1 ) ; 
    var S : int ; S := P[n - 1+1] ;
    var hash : Map(int,int) ; hash := Map{} ;
        var i : int ; i := 0 ; while i < n do (     hash := hash->union(Map{P[i+1] |-> 1}) ;  ;     i := i + 1 ) ; 
    var res : Set(int) ; res := Set{} ;
        var i : int ; i := 1 ; while i * i <= S do ( (     if (S mod i = 0) then (     var pres : boolean ; pres := true ;
     var div1 : int ; div1 := i ;
    var div2 : int ; div2 := S / i ;
        var j : int ; j := div1 ; while j <= S do ( (     if (hash->at(j) = null or hash->at(j) /= 1) then (     pres := false ; 
     break ) else skip )  ;     j := j+(div1) ) ; 
    if (pres & div1 /= S) then     res := res->including(div1) ; else skip ; 
    pres := true ; 
        var j : int ; j := S / i ; while j <= S do ( (     if (hash->at(j) = null or hash->at(j) /= 1) then (     pres := false ; 
     break ) else skip )  ;     j := j+(S / i) ) ; 
    if (pres & div2 /= S) then     res := res->including(div2) ; else skip ; 
 ) else skip )  ;     i := i + 1 ) ; 
    if (res->size() = 0) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
    for (i : res) do (     OclFile["System.out"].print(i + " ") ;  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,1,1,1,2,1,3} ;
     var n : int ; n := a->size() ;
     execute getSum(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    FastDivision solver=new FastDivision();
    solver.solve(1,in,out);
    out.close();
  }
  static class FastDivision {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int ans=-1 ;
      if(n==0 || n==2){
        ans=1 ;
      }
      else if(n==1){
        ans=2 ;
      }
      else {
        ans=0 ;
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : FastDivision ; solver := FastDivision.newFastDivision() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class FastDivision {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var ans : int ; ans := -1 ;
     if (n = 0 or n = 2) then (     ans := 1 ) else     if (n = 1) then (     ans := 2 ) else (     ans := 0 ) ;  ;  
     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    switch(n){
      case 0 : System.out.println(1);
      break ;
      case 1 : System.out.println(2);
      break ;
      case 2 : System.out.println(1);
      break ;
      default : System.out.println(0);
      break ;
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (n) ; 
       if _switchval = 0 then
     OclFile["System.out"].println(1) ; 
    break 
   else skip ;
       if _switchval = 1 then
     OclFile["System.out"].println(2) ; 
    break 
   else skip ;
       if _switchval = 2 then
     OclFile["System.out"].println(1) ; 
    break 
   else skip ;
       if true then
     OclFile["System.out"].println(0) ; 
    break 
   else skip ;
 )
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test210 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int x=in.nextInt()-1 ;
      for(int i=2 ; i<=x ; i++){
        if(x %(x/i)==0){
          System.out.println(i+" "+x);
          break ;
        }
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test210 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var x : int ; x := in.getCurrent()->toInteger() - 1 ;
         var i : int ; i := 2 ; while i <= x do ( (     if (x mod (x / i) = 0) then (     OclFile["System.out"].println(i + " " + x) ; 
     break ) else skip )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class A_Gregor_and_Cryptography {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int T=reader.nextInt();
    while(T!=0){
      T--;
      int P=reader.nextInt();
      int num=P-1 ;
      System.out.println(2+" "+num);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Gregor_and_Cryptography {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var T : int ; T := reader.nextInt() ;
     while (T /= 0) do (     T := T - 1 ; 
     var P : int ; P := reader.nextInt() ;
     var num : int ; num := P - 1 ;
     OclFile["System.out"].println(2 + " " + num) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    while(test-->0){
      int n=sc.nextInt();
      System.out.println("2 "+(n % 2==0 ? n : n-1));
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println("2 " + (if n mod 2 = 0 then n else n - 1 endif)) ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    Scanner sc=new Scanner(systemin);
    int N=sc.nextInt();
    sc.nextLine();
    int cnt=0 ;
    for(int i=0 ; i<N ; i++){
      String s=sc.nextLine();
      if(s.equals("E869120")){
        cnt++;
      }
    }
    System.out.printf("%d\n",cnt);
    sc.close();
    return false ;
  }
  PrintStream log ;
  PrintStream result=System.out ;
  BufferedReader systemin ;
  static Main instance=new Main();
  Main(){
    systemin=new BufferedReader(new InputStreamReader(System.in));
    log=new PrintStream(new OutputStream(){
      public void write(int b){
      }
    }
);
  }
  public static void main(String[] args)throws IOException {
    instance.main();
    instance.systemin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(systemin) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    skip ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var s : String ; s := sc.nextLine() ;
     if (s = "E869120") then (     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%d\n", cnt) ; 
    skip ; 
    return false 
 );
   attribute log : OclFile;
   attribute result : OclFile := OclFile["System.out"];
   attribute systemin : OclFile;
  static   attribute instance : Main := Main.newMain();
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     systemin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     log := OclFile.newOclFile_Write(OclFile()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     instance.main() ; 
     instance.systemin.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String target="E869120" ;
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(target.equals(sc.next())){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var target : String ; target := "E869120" ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (target = sc.getCurrent()) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int ans=0 ;
    for(int i=0 ; i<n ; i++)if(sc.next().equals("E869120"))ans++;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (sc.getCurrent() = "E869120") then     ans := ans + 1 ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf {
  public static void main(String[] args){
    Scanner css=new Scanner(System.in);
    int t=css.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=css.nextInt();
      int[] arr=new int[n];
      for(int j=0 ; j<n ; j++){
        arr[j]=css.nextInt();
      }
      Arrays.sort(arr);
      int min=Integer.MAX_VALUE ;
      for(int j=0 ; j<arr.length-2 ; j++){
        int count=0 ;
        if((arr[j]==arr[j+1] && arr[j+1]==arr[j+2])){
          min=0 ;
          break ;
        }
        else {
          count+=(arr[j+1]-arr[j])+(arr[j+2]-arr[j+1]);
          min=Math.min(min,count);
        }
      }
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var css : OclFile ; css := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := css.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := css.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     arr[j+1] := css.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    arr := arr->sort() ; 
    var min : int ; min := 2147483647 ;
        var j : int ; j := 0 ; while j < arr->size() - 2 do ( (     var count : int ; count := 0 ;
     if ((arr[j+1] = arr[j + 1+1] & arr[j + 1+1] = arr[j + 2+1])) then (     min := 0 ; 
     break ) else (     count := count+((arr[j + 1+1] - arr[j+1]) + (arr[j + 2+1] - arr[j + 1+1])) ; 
     min := Set{min, count}->min() ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int i=sc.nextInt();
    System.out.println(n-i+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var i : int ; i := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(n - i + 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    String[] line=br.readLine().split(" ");
    int a=Integer.parseInt(line[0]);
    int b=Integer.parseInt(line[1]);
    out.println(a-b+1);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var a : int ; a := (line[0+1])->toInteger() ;
    var b : int ; b := (line[1+1])->toInteger() ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.util.ArrayDeque ;
import java.util.Scanner ;
import java.util.*;
import java.util.Arrays ;
import java.util.ArrayList ;
import java.util.Set ;
import java.util.HashSet ;
import java.util.Collection ;
public class Main {
  static final Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    int i=sc.nextInt();
    System.out.println(N-i+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var i : int ; i := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N - i + 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String[] str=in.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int i=Integer.parseInt(str[1]);
    System.out.println(n-i+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := in.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var i : int ; i := (str[1+1])->toInteger() ;
    OclFile["System.out"].println(n - i + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    System.out.println(sc.nextInt()-sc.nextInt()+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println(sc.getCurrent()->toInteger() - sc.getCurrent()->toInteger() + 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String ar[]){
    Scanner cin=new Scanner(System.in);
    int n=cin.nextInt();
    int ans1=n/30 ;
    n %=30 ;
    int ans2=n*2 ;
    System.out.println(ans1+" "+ans2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( ar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := cin.getCurrent()->toInteger() ;
    var ans1 : int ; ans1 := n / 30 ;
    n := n mod 30 ; 
    var ans2 : int ; ans2 := n * 2 ;
    OclFile["System.out"].println(ans1 + " " + ans2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int minute=12*60*n/360 ;
    System.out.println((minute/60)+" "+(minute % 60));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var minute : int ; minute := 12 * 60 * n / 360 ;
     OclFile["System.out"].println((minute / 60) + " " + (minute mod 60)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Task_467 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int result=0 ;
    for(int i=0 ; i<n ; i++){
      int p=in.nextInt();
      int q=in.nextInt();
      if(q-p>=2)result++;
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Task_467 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var p : int ; p := in.getCurrent()->toInteger() ;
     var q : int ; q := in.getCurrent()->toInteger() ;
     if (q - p >= 2) then     result := result + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int t=sc.nextInt();
      int c=sc.nextInt();
      if((c-t)>=2){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
     if ((c - t) >= 2) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Rough {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long arr[][]=new long[(int)n][2];
    long count=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<2 ; j++){
        arr[i][j]=sc.nextInt();
      }
    }
    for(int i=0 ; i<n ; i++){
      long vk=(arr[i][1]-arr[i][0]);
      if(vk>=2){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Rough {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var arr : Sequence(Sequence(long)) ; arr := Integer.subrange(1,n->oclAsType(int))->collect(Integer.subrange(1,2)->collect(0)) ;
    var count : long ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 2 do ( (     arr[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var vk : long ; vk := (arr[i+1][1+1] - arr[i+1][0+1]) ;
     if (vk >= 2) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findElement(int arr[],int size){
    int right_mul=1,left_mul=1 ;
    for(int i=1 ; i<size ; i++)right_mul*=arr[i];
    for(int i=0,j=1 ; j<size ; i++,j++){
      right_mul/=arr[j];
      left_mul*=arr[i];
      if(left_mul==right_mul)return arr[i+1];
    }
    return-1 ;
  }
  public static void main(String args[]){
    int arr[]={
      2,3,4,1,4,6 };
      int size=arr.length ;
      System.out.println(findElement(arr,size));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findElement( arr : Sequence(int), size : int) : int
  pre: true
  post: true
  activity: (     var right_mul : int ; right_mul := 1 ;
    var left_mul : int ; left_mul := 1 ;
         var i : int ; i := 1 ; while i < size do (     right_mul := right_mul*(arr[i+1]) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ;
    var j : int ; j := 1 ; while j < size do ( (     right_mul := right_mul/(arr[j+1]) ; 
     left_mul := left_mul*(arr[i+1]) ; 
     if (left_mul = right_mul) then     return arr[i + 1+1] else skip )  ;     i := i + 1 ;     j := j + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4,1,4,6} ;
     var size : int ; size := arr->size() ;
     OclFile["System.out"].println(findElement(arr, size)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Solution {
  static class INT {
    int data ;
    INT(int d){
      data=d ;
    }
  }
  static void findPostOrderUtil(int pre[],int n,int minval,int maxval,INT preIndex){
    if(preIndex.data==n)return ;
    if(pre[preIndex.data]<minval || pre[preIndex.data]>maxval){
      return ;
    }
    int val=pre[preIndex.data];
    preIndex.data++;
    findPostOrderUtil(pre,n,minval,val,preIndex);
    findPostOrderUtil(pre,n,val,maxval,preIndex);
    System.out.print(val+" ");
  }
  static void findPostOrder(int pre[],int n){
    INT preIndex=new INT(0);
    findPostOrderUtil(pre,n,Integer.MIN_VALUE,Integer.MAX_VALUE,preIndex);
  }
  public static void main(String args[]){
    int pre[]={
      40,30,35,80,100 };
      int n=pre.length ;
      findPostOrder(pre,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Solution {
  static class INT {
   attribute data : int;
   static operation newINT( d : int) : INT
  pre: true
  post: true
  activity:
  ( var self : INT ;
    self := createINT();
    self.initialise(d);
    return self );
  operation initialise( d : int) : void
  pre: true  post: true
  activity: (     data := d );
}
  static   operation findPostOrderUtil( pre : Sequence(int), n : int, minval : int, maxval : int, preIndex : INT) : void
  pre: true
  post: true
  activity: (     if (preIndex.data = n) then     return else skip ; 
     if (pre[preIndex.data+1] < minval or pre[preIndex.data+1] > maxval) then (     return ) else skip ; 
    var val : int ; val := pre[preIndex.data+1] ;
    preIndex.data := preIndex.data + 1 ; 
    execute findPostOrderUtil(pre, n, minval, val, preIndex) ; 
    execute findPostOrderUtil(pre, n, val, maxval, preIndex) ; 
    OclFile["System.out"].print(val + " ") ; 
 );
  static   operation findPostOrder( pre : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var preIndex : INT ; preIndex := INT.newINT(0) ;
     execute findPostOrderUtil(pre, n, -2147483648, 2147483647, preIndex) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var pre : Sequence(int) ; pre := Sequence{40,30,35,80,100} ;
     var n : int ; n := pre->size() ;
     execute findPostOrder(pre, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector ;
class GFG {
  static void originalArray(int greater[],int n){
    Vector<Integer>temp=new Vector<Integer>();
    for(int i=0 ; i<=n ; i++)temp.add(i);
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      int k=n-greater[i]-i ;
      arr[i]=temp.get(k);
      temp.remove(k);
    }
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String[] args){
    int Arr[]={
      6,3,2,1,0,1,0 };
      int n=Arr.length ;
      originalArray(Arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation originalArray( greater : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(int) ; temp := Sequence{} ;
         var i : int ; i := 0 ; while i <= n do (     temp := temp->including(i) ;  ;     i := i + 1 ) ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var k : int ; k := n - greater[i+1] - i ;
     arr[i+1] := temp->at(k+1) ; 
     temp := temp->excludingAt(k+1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Arr : Sequence(int) ; Arr := Sequence{6,3,2,1,0,1,0} ;
     var n : int ; n := Arr->size() ;
     execute originalArray(Arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testCases=sc.nextInt();
    for(int index=0 ; index<testCases ; index++){
      int size=sc.nextInt();
      int[] arr=new int[size];
      for(int i=0 ; i<size ; i++){
        arr[i]=sc.nextInt();
      }
      System.out.println(new Main().getMinimumNumberOfOperations(arr));
    }
  }
  public int getMinimumNumberOfOperations(int[] arr){
    int min=Integer.MAX_VALUE ;
    Arrays.sort(arr);
    for(int i=2 ; i<arr.length ; i++){
      int x=Math.abs(arr[i]-arr[i-1])+Math.abs(arr[i-2]-arr[i-1]);
      min=Math.min(x,min);
    }
    return min ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := sc.getCurrent()->toInteger() ;
         var index : int ; index := 0 ; while index < testCases do ( (     var size : int ; size := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < size do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(Main.newMain().getMinimumNumberOfOperations(arr)) )  ;     index := index + 1 ) );
   operation getMinimumNumberOfOperations( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var min : int ; min := 2147483647 ;
     arr := arr->sort() ; 
         var i : int ; i := 2 ; while i < arr->size() do ( (     var x : int ; x := if arr[i+1] - arr[i - 1+1] < 0 then -(arr[i+1] - arr[i - 1+1]) else arr[i+1] - arr[i - 1+1] endif + if arr[i - 2+1] - arr[i - 1+1] < 0 then -(arr[i - 2+1] - arr[i - 1+1]) else arr[i - 2+1] - arr[i - 1+1] endif ;
     min := Set{x, min}->min() )  ;     i := i + 1 ) ; 
     return min );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Codeforces {
  public static void main(String[] args){
    Scanner kali=new Scanner(System.in);
    int rooms=kali.nextInt();
    int empty=0 ;
    for(int i=1 ; i<=rooms ; i++){
      int peoples=kali.nextInt();
      int max_place=kali.nextInt();
      if(max_place-peoples>=2){
        empty++;
      }
    }
    System.out.println(empty);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var kali : OclFile ; kali := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var rooms : int ; rooms := kali.getCurrent()->toInteger() ;
    var empty : int ; empty := 0 ;
        var i : int ; i := 1 ; while i <= rooms do ( (     var peoples : int ; peoples := kali.getCurrent()->toInteger() ;
     var max_place : int ; max_place := kali.getCurrent()->toInteger() ;
     if (max_place - peoples >= 2) then (     empty := empty + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(empty) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int t=sc.nextInt();
      int c=sc.nextInt();
      if((c-t)>=2){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
     if ((c - t) >= 2) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n % 10==3){
      System.out.println("bon");
    }
    else if(n % 10==0 || n % 10==1 || n % 10==6 || n % 10==8){
      System.out.println("pon");
    }
    else {
      System.out.println("hon");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n mod 10 = 3) then (     OclFile["System.out"].println("bon") ) else     if (n mod 10 = 0 or n mod 10 = 1 or n mod 10 = 6 or n mod 10 = 8) then (     OclFile["System.out"].println("pon") ) else (     OclFile["System.out"].println("hon") ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  static FastReader in=new FastReader();
  public static void main(String[] args){
    int t=1 ;
    while(t-->0)solve();
  }
  public static void solve(){
    int n=in.nextInt()% 10 ;
    switch(n){
      case 2 : case 4 : case 5 : case 7 : case 9 : System.out.println("hon");
      break ;
      case 0 : case 1 : case 6 : case 8 : System.out.println("pon");
      break ;
      case 3 : System.out.println("bon");
      break ;
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static int max(int a,int b){
    return a>b ? a : b ;
  }
  public static int min(int a,int b){
    return a<b ? a : b ;
  }
  public static int gcd(int a,int b){
    return b==0 ? a : gcd(b,(a % b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : FastReader := FastReader.newFastReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ;     execute solve() ; ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() mod 10 ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (n) ; 
    if _switchval = 2 or _switchval = 4 or _switchval = 5 or _switchval = 7 or _switchval = 9 then
    OclFile["System.out"].println("hon") ; 
    break 
   else skip ;
    if _switchval = 0 or _switchval = 1 or _switchval = 6 or _switchval = 8 then
    OclFile["System.out"].println("pon") ; 
    break 
   else skip ;
       if _switchval = 3 then
     OclFile["System.out"].println("bon") ; 
    break 
   else skip ;
 )
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation max( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if a > b then a else b endif );
  static   operation min( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if a < b then a else b endif );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, (a mod b)) endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt()% 10 ;
    if(n==3){
      System.out.println("bon");
    }
    else if(n==0 || n==1 || n==6 || n==8){
      System.out.println("pon");
    }
    else {
      System.out.println("hon");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() mod 10 ;
     if (n = 3) then (     OclFile["System.out"].println("bon") ) else     if (n = 0 or n = 1 or n = 6 or n = 8) then (     OclFile["System.out"].println("pon") ) else (     OclFile["System.out"].println("hon") ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static Scanner scan=new Scanner(System.in);
  public static void main(String[] args){
    int n=nextInt();
    int a=n % 10 ;
    if(a==2 || a==4 || a==5 || a==7 || a==9){
      print("hon");
    }
    else if(a==0 || a==1 || a==6 || a==8){
      print("pon");
    }
    else if(a==3){
      print("bon");
    }
  }
  public static int nextInt(){
    return Integer.parseInt(scan.next());
  }
  public static long nextLong(){
    return Long.parseLong(scan.next());
  }
  public static String next(){
    return scan.next();
  }
  public static double nextDouble(){
    return Double.parseDouble(scan.next());
  }
  public static float nextFloat(){
    return Float.parseFloat(scan.next());
  }
  public static void yesNo(boolean flag){
    if(flag)System.out.println("Yes");
    else System.out.println("No");
  }
  public static void print(Object a){
    System.out.println(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var a : int ; a := n mod 10 ;
     if (a = 2 or a = 4 or a = 5 or a = 7 or a = 9) then (     execute print("hon") ) else     if (a = 0 or a = 1 or a = 6 or a = 8) then (     execute print("pon") ) else     if (a = 3) then (     execute print("bon") ) else skip ; ;  );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (scan.getCurrent())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (scan.getCurrent())->toLong() );
  static   operation next() : String
  pre: true
  post: true
  activity: (     return scan.getCurrent() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (scan.getCurrent())->toReal() );
  static   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(scan.getCurrent()) );
  static   operation yesNo( flag : boolean) : void
  pre: true
  post: true
  activity: (     if (flag) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
  static   operation print( a : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String num=sc.next();
    int n=num.length();
    if(num.substring(n-1,n).equals("0")|| num.substring(n-1,n).equals("1")|| num.substring(n-1,n).equals("6")|| num.substring(n-1,n).equals("8")){
      System.out.println("pon");
      return ;
    }
    else if(num.substring(n-1,n).equals("3")){
      System.out.println("bon");
      return ;
    }
    else {
      System.out.println("hon");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : String ; num := sc.getCurrent() ;
     var n : int ; n := num->size() ;
     if (num.subrange((n)->char2byte() - 1+1,n) = "0" or num.subrange((n)->char2byte() - 1+1,n) = "1" or num.subrange((n)->char2byte() - 1+1,n) = "6" or num.subrange((n)->char2byte() - 1+1,n) = "8") then (     OclFile["System.out"].println("pon") ; 
     return ) else     if (num.subrange((n)->char2byte() - 1+1,n) = "3") then (     OclFile["System.out"].println("bon") ; 
     return ) else (     OclFile["System.out"].println("hon") ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder stringBuilder=new StringBuilder();
    StringTokenizer st ;
    st=new StringTokenizer(in.readLine());
    int n=Integer.parseInt(st.nextToken());
    int t=Integer.parseInt(st.nextToken());
    if(n==1 && t==10)System.out.println(-1);
    else {
      System.out.print(t);
      if(t==10){
        for(int i=0 ; i<n-2 ; i++){
          System.out.print(0);
        }
      }
      else for(int i=0 ;
      i<n-1 ;
      i++){
        System.out.print(0);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var stringBuilder : String ; stringBuilder := StringLib.newString() ;
    var st : OclIterator ;
    st := OclIterator.newOclIterator_String(in.readLine()) ; 
    var n : int ; n := (st.next())->toInteger() ;
    var t : int ; t := (st.next())->toInteger() ;
    if (n = 1 & t = 10) then     OclFile["System.out"].println(-1) else (     OclFile["System.out"].print(t) ; 
     if (t = 10) then (         var i : int ; i := 0 ; while i < n - 2 do ( (     OclFile["System.out"].print(0) )  ;     i := i + 1 ) ) else         var i : int ; i := 0 ; while i < n - 1 do ( (     OclFile["System.out"].print(0) )  ;     i := i + 1 ) ; ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    if(n==1 && t==10){
      System.out.print(-1);
    }
    else if(t==10){
      for(int i=0 ; i<n-1 ; i++)System.out.print(1);
      System.out.print(0);
      System.exit(0);
    }
    else {
      for(int i=0 ; i<n ; i++)System.out.print(t);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     if (n = 1 & t = 10) then (     OclFile["System.out"].print(-1) ) else     if (t = 10) then (         var i : int ; i := 0 ; while i < n - 1 do (     OclFile["System.out"].print(1) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(0) ; 
 OclProcess.exit(0) ) else (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(t) ;  ;     i := i + 1 ) ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    try(Scanner sc=new Scanner(System.in)){
      int N=sc.nextInt();
      int u=sc.nextInt()-1 ;
      int v=sc.nextInt()-1 ;
      List<Integer>[] edges=new List[N];
      for(int i=0 ; i<N ; i++){
        edges[i]=new ArrayList<>();
      }
      for(int i=0 ; i<N-1 ; i++){
        int a=sc.nextInt()-1 ;
        int b=sc.nextInt()-1 ;
        edges[a] .add(b);
        edges[b] .add(a);
      }
      int[] d=new int[N];
      for(int i=0 ; i<N ; i++){
        d[i]=Integer.MAX_VALUE ;
      }
      d[u]=0 ;
      dfs(u,d,edges);
      int[] e=new int[N];
      for(int i=0 ; i<N ; i++){
        e[i]=Integer.MAX_VALUE ;
      }
      e[v]=0 ;
      dfs(v,e,edges);
      int q=-1 ;
      for(int i=0 ; i<N ; i++){
        if(d[i]<e[i]){
          if(e[i]>q){
            q=e[i];
          }
        }
      }
      if(q<=0){
        System.out.println(0);
      }
      else {
        System.out.println(q-1);
      }
    }
  }
  static void dfs(int u,int[] d,List<Integer>[] edges){
    for(Integer nu : edges[u]){
      if(d[nu]==Integer.MAX_VALUE){
        d[nu]=d[u]+1 ;
        dfs(nu,d,edges);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var u : int ; u := sc.getCurrent()->toInteger() - 1 ;
    var v : int ; v := sc.getCurrent()->toInteger() - 1 ;
    var edges : Sequence(Sequence(int)) ; edges := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     edges[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
     var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
     edges[a+1]->excludes(b) ; 
     edges[b+1]->excludes(a) )  ;     i := i + 1 ) ; 
    var d : Sequence(int) ; d := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     d[i+1] := 2147483647 )  ;     i := i + 1 ) ; 
    d[u+1] := 0 ; 
    execute dfs(u, d, edges) ; 
    var e : Sequence(int) ; e := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     e[i+1] := 2147483647 )  ;     i := i + 1 ) ; 
    e[v+1] := 0 ; 
    execute dfs(v, e, edges) ; 
    var q : int ; q := -1 ;
        var i : int ; i := 0 ; while i < N do ( (     if (d[i+1] < e[i+1]) then (     if (e[i+1] > q) then (     q := e[i+1] ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (q <= 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(q - 1) ) ;  
 ))  );
  static   operation dfs( u : int, d : Sequence(int), edges : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     for (nu : edges[u+1]) do ( (     if (d[nu+1] = 2147483647) then (     d[nu+1] := d[u+1] + 1 ; 
     execute dfs(nu, d, edges) ) else skip )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    if(t==10){
      if(n==1)System.out.println(-1);
      else {
        System.out.print(1);
        for(int i=2 ; i<=n ; i++)System.out.print(0);
        System.out.println();
      }
    }
    else {
      for(int i=0 ; i<n ; i++)System.out.print(t);
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     if (t = 10) then (     if (n = 1) then     OclFile["System.out"].println(-1) ; else (     OclFile["System.out"].print(1) ; 
         var i : int ; i := 2 ; while i <= n do (     OclFile["System.out"].print(0) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ) else (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(t) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0){
      solve(sc);
    }
  }
  static void solve(Scanner sc){
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    Arrays.sort(a);
    int ans=(int)2e9 ;
    for(int i=0 ; i<n-2 ; i++){
      ans=Math.min(ans,a[i+2]-a[i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     execute solve(sc) ) ;  ) );
  static   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var ans : int ; ans := 2e9->oclAsType(int) ;
        var i : int ; i := 0 ; while i < n - 2 do ( (     ans := Set{ans, a[i + 2+1] - a[i+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class teest {
  public static void main(String[] args){
    Scanner a=new Scanner(System.in);
    int n=a.nextInt(),t=a.nextInt();
    if(n==1 && t>9)System.out.println(-1);
    else {
      StringBuilder s ;
      if(t==10)s=new StringBuilder("1");
      else s=new StringBuilder(String.valueOf(t));
      for(int i=1 ; i<n ; i++){
        s.append('0');
      }
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class teest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : OclFile ; a := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := a.getCurrent()->toInteger() ;
    var t : int ; t := a.getCurrent()->toInteger() ;
     if (n = 1 & t > 9) then     OclFile["System.out"].println(-1) ; else (     var s : String ;
     if (t = 10) then     s := StringLib.newString("1") else     s := StringLib.newString(((t) + "")) ; ;  
         var i : int ; i := 1 ; while i < n do ( (     s := s + StringLib.newString('0') )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(s) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    if(n==1 && t==10){
      System.out.println(-1);
    }
    else if(n>=2 && t==10){
      for(int i=1 ; i<n ; i++){
        System.out.print(1);
      }
      System.out.println(0);
    }
    else {
      for(int i=1 ; i<=n ; i++){
        System.out.print(t);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     if (n = 1 & t = 10) then (     OclFile["System.out"].println(-1) ) else     if (n >= 2 & t = 10) then (         var i : int ; i := 1 ; while i < n do ( (     OclFile["System.out"].print(1) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(0) ) else (         var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].print(t) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1393 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      int n=scanner.nextInt();
      System.out.println(1+n/2);
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1393 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(1 + n / 2) ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A1393 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n-->0){
      int t=sc.nextInt();
      System.out.println((t>>1)+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1393 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var t : int ; t := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(((t/(2->pow(1)))->oclAsType(long)) + 1) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Round662A {
  public static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t-->0){
      int n=Integer.parseInt(br.readLine());
      pw.println((n/2)+1);
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Round662A {
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
     skip ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class RainbowDashFluttershyandChessColoring {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int t1=1 ; t1<=t ; t1++){
      long n=sc.nextLong();
      long res=0 ;
      if(n==1)System.out.println(1);
      else {
        if(n>=4)res=(n/2)-1 ;
        res=res+2 ;
        System.out.println(res);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class RainbowDashFluttershyandChessColoring {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var t1 : int ; t1 := 1 ; while t1 <= t do ( (     var n : long ; n := sc.getCurrent()->toLong() ;
     var res : long ; res := 0 ;
     if (n = 1) then     OclFile["System.out"].println(1) ; else (     if (n >= 4) then     res := (n / 2) - 1 ; else skip ; 
     res := res + 2 ; 
     OclFile["System.out"].println(res) ) )  ;     t1 := t1 + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Solution {
  public static void main(String[] args){
    FastReader sc=new FastReader();
    StringBuilder sb=new StringBuilder();
    int testcases=sc.nextInt();
    while(testcases-->0){
      int n=sc.nextInt();
      if(n==1){
        sb.append(-1).append("\n");
      }
      else {
        sb.append(2);
        for(int i=1 ; i<n ; i++){
          sb.append(3);
        }
        sb.append("\n");
      }
    }
    System.out.println(sb);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var sb : String ; sb := StringLib.newString() ;
    var testcases : int ; testcases := sc.nextInt() ;
        while (testcases > 0) do (        testcases := testcases - 1 ;     skip ; (     var n : int ; n := sc.nextInt() ;
     if (n = 1) then (     sb := sb + StringLib.newString(-1) + StringLib.newString("\n") ) else (     sb := sb + StringLib.newString(2) ; 
         var i : int ; i := 1 ; while i < n do ( (     sb := sb + StringLib.newString(3) )  ;     i := i + 1 ) ; 
     sb := sb + StringLib.newString("\n") ) ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int k=0 ; k<t ; k++){
      int n=sc.nextInt();
      if(n==1)System.out.println(-1);
      else if(n==2)System.out.println(23);
      else if(n==3)System.out.println(233);
      else {
        for(int i=1 ; i<=n-2 ; i++)System.out.print(3);
        System.out.print(2);
        System.out.print(3);
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var k : int ; k := 0 ; while k < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 1) then     OclFile["System.out"].println(-1) ; else     if (n = 2) then     OclFile["System.out"].println(23) else     if (n = 3) then     OclFile["System.out"].println(233) else (         var i : int ; i := 1 ; while i <= n - 2 do (     OclFile["System.out"].print(3) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(2) ; 
     OclFile["System.out"].print(3) ; 
     OclFile["System.out"].println() ) ;  ;  )  ;     k := k + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static List<String>permutation(List<String>list,String target,String ans){
    if(target.length()<=1){
      list.add(ans+target);
    }
    else {
      for(int i=0 ; i<target.length(); i++){
        permutation(list,target.substring(0,i)+target.substring(i+1),ans+target.charAt(i));
      }
    }
    return list ;
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    Integer n=Integer.parseInt(scanner.next());
    String[][] line=new String[2][1];
    for(int i=0 ; i<2 ; i++){
      Arrays.fill(line[i],"");
      for(int j=0 ; j<n ; j++){
        line[i][0]+=scanner.next();
      }
    }
    String number="" ;
    for(int i=1 ; i<=n ; i++){
      number+=i ;
    }
    List<String>listA=new ArrayList<>();
    permutation(listA,number,"");
    int sum=0 ;
    for(int j=0 ; j<line.length ; j++){
      for(int i=0 ; i<listA.size(); i++){
        if(listA.get(i).equals(line[j][0])){
          if(sum==0){
            sum+=i ;
          }
          else {
            sum-=i ;
          }
        }
      }
    }
    System.out.println(Math.abs(sum));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation permutation( list : Sequence(String), target : String, ans : String) : Sequence(String)
  pre: true
  post: true
  activity: (     if (target->size() <= 1) then (     list->excludes(ans + target) ) else (         var i : int ; i := 0 ; while i < target->size() do ( (     execute permutation(list, target.subrange(0+1,i) + target.subrange(i + 1+1,i + 1), ans + target->at(i+1)) )  ;     i := i + 1 ) ) ;  
     return list );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (scanner.getCurrent())->toInteger() ;
    var line : Sequence(Sequence(String)) ; line := Integer.subrange(1,2)->collect(Integer.subrange(1,1)->collect(null)) ;
        var i : int ; i := 0 ; while i < 2 do ( (     line[i+1] := line[i+1]->collect("") ; 
         var j : int ; j := 0 ; while j < n do ( (     line[i+1][0+1] := line[i+1][0+1]+(scanner.getCurrent()) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var number : String ; number := "" ;
        var i : int ; i := 1 ; while i <= n do ( (     number := number+(i) )  ;     i := i + 1 ) ; 
    var listA : Sequence(String) ; listA := Sequence{} ;
    execute permutation(listA, number, "") ; 
    var sum : int ; sum := 0 ;
        var j : int ; j := 0 ; while j < line->size() do ( (         var i : int ; i := 0 ; while i < listA->size() do ( (     if (listA->at(i+1) = line[j+1][0+1]) then (     if (sum = 0) then (     sum := sum+(i) ) else (     sum := sum-(i) ) ) else skip )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(if sum < 0 then -(sum) else sum endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int j,t,n ;
    ArrayList<Integer>arr=new ArrayList<>();
    for(Integer i=1 ; i<=1670 ; i++){
      if(i % 3!=0 && i % 10!=3)arr.add(i);
    }
    t=sc.nextInt();
    for(j=0 ; j<t ; j++){
      n=sc.nextInt();
      System.out.println(arr.get(n-1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var j : int ;
    var t : int ;
    var n : int ;
    var arr : Sequence(int) ; arr := Sequence{} ;
        var i : int ; i := 1 ; while i <= 1670 do ( (     if (i mod 3 /= 0 & i mod 10 /= 3) then     arr := arr->including(i) ; else skip )  ;     i := i + 1 ) ; 
    t := sc.getCurrent()->toInteger() ; 
        j := 0 ; while j < t do ( (     n := sc.getCurrent()->toInteger() ; 
     OclFile["System.out"].println(arr->at(n - 1+1)) )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int j,t,n,i ;
    t=sc.nextInt();
    for(j=0 ; j<t ; j++){
      n=sc.nextInt();
      for(i=1 ; i<=n ; i++){
        if(i % 3==0 || i % 10==3)n=n+1 ;
      }
      System.out.println(n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var j : int ;
    var t : int ;
    var n : int ;
    var i : int ;
     t := sc.getCurrent()->toInteger() ; 
         j := 0 ; while j < t do ( (     n := sc.getCurrent()->toInteger() ; 
         i := 1 ; while i <= n do ( (     if (i mod 3 = 0 or i mod 10 = 3) then     n := n + 1 ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(n) )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      Arrays.sort(arr);
      int max=Integer.MAX_VALUE ;
      for(int i=0 ; i<n-2 ; i++){
        max=Math.min(max,Math.abs(arr[i]-arr[i+1])+Math.abs(arr[i+1]-arr[i+2]));
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var max : int ; max := 2147483647 ;
        var i : int ; i := 0 ; while i < n - 2 do ( (     max := Set{max, if arr[i+1] - arr[i + 1+1] < 0 then -(arr[i+1] - arr[i + 1+1]) else arr[i+1] - arr[i + 1+1] endif + if arr[i + 1+1] - arr[i + 2+1] < 0 then -(arr[i + 1+1] - arr[i + 2+1]) else arr[i + 1+1] - arr[i + 2+1] endif}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test112 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      int x=in.nextInt();
      int sum=0 ;
      for(int j=1 ; ; j++){
        if(j % 3!=0 && j % 10!=3){
          sum++;
        }
        if(sum==x){
          System.out.println(j);
          break ;
        }
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test112 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var sum : int ; sum := 0 ;
         var j : int ; j := 1 ; while true do ( (     if (j mod 3 /= 0 & j mod 10 /= 3) then (     sum := sum + 1 ) else skip ; 
     if (sum = x) then (     OclFile["System.out"].println(j) ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    ArrayList<Integer>a=new ArrayList<>();
    for(int i=1 ; i<=1666 ; i++){
      if(i % 3==0 || i % 10==3){
        continue ;
      }
      a.add(i);
    }
    int t=in.nextInt();
    while(t--!=0){
      int k=in.nextInt();
      System.out.println(a.get(k-1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Sequence{} ;
        var i : int ; i := 1 ; while i <= 1666 do ( (     if (i mod 3 = 0 or i mod 10 = 3) then (     continue ) else skip ; 
     a := a->including(i) )  ;     i := i + 1 ) ; 
    var t : int ; t := in.getCurrent()->toInteger() ;
        while (t /= 0) do (    skip ; (     var k : int ; k := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println(a->at(k - 1+1)) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class dislikes_of_threes {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      for(int i=1 ; ; i++){
        if(i % 3==0 || i % 10==3){
          continue ;
        }
        else {
          n--;
          if(n==0){
            System.out.println(i);
            break ;
          }
        }
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class dislikes_of_threes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while true do ( (     if (i mod 3 = 0 or i mod 10 = 3) then (     continue ) else (     n := n - 1 ; 
     if (n = 0) then (     OclFile["System.out"].println(i) ; 
     break ) else skip ) )  ;     i := i + 1 ) ; 
     t := t - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      if(n % 2==0){
        System.out.println("0 0 "+n/2);
      }
      else System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (     OclFile["System.out"].println("0 0 " + n / 2) ) else     OclFile["System.out"].println(-1) ; ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner mc=new Scanner(System.in);
    int m=mc.nextInt();
    while(m--!=0){
      int n=mc.nextInt();
      if(n % 2==0)System.out.println("0 0 "+n/2);
      else System.out.println("-1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mc : OclFile ; mc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := mc.getCurrent()->toInteger() ;
         while (m /= 0) do (    skip ; (     var n : int ; n := mc.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then     OclFile["System.out"].println("0 0 " + n / 2) ; else     OclFile["System.out"].println("-1") ; ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      if((n & 1)==1)System.out.println(-1);
      else System.out.println(0+" "+n/2+" "+n/2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseAnd(n,1)) = 1) then     OclFile["System.out"].println(-1) ; else     OclFile["System.out"].println(0 + " " + n / 2 + " " + n / 2) ; ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Solution {
  static PrintWriter pw ;
  static FastScanner s ;
  public static void main(String[] args)throws Exception {
    pw=new PrintWriter(System.out);
    s=new FastScanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      if(n % 2==1){
        pw.println(-1);
      }
      else {
        pw.println("0 0 "+n/2);
      }
    }
    pw.flush();
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public FastScanner(String s)throws Exception {
    br=new BufferedReader(new FileReader(new File(s)));
  }
  public String next()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(next());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute pw : OclFile;
  static   attribute s : FastScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     pw := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     s := FastScanner.newFastScanner(OclFile["System.in"]) ; 
    var t : int ; t := s.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.nextInt() ;
     if (n mod 2 = 1) then (     skip ) else (     skip ) ) ;  ) ;  
    skip ; 
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] p=new int[n];
    int[] q=new int[n];
    IntStream.rangeClosed(1,n).forEach(i->p[i-1]=sc.nextInt());
    IntStream.rangeClosed(1,n).forEach(i->q[i-1]=sc.nextInt());
    int[] convertedP=convert(p);
    int[] convertedQ=convert(q);
    int diff=0 ;
    for(int i=0 ; i<n ; i++){
      diff=diff+(convertedP[i]-convertedQ[i])*pow(n-i-1);
    }
    print(abs(diff));
    sc.close();
  }
  public static int[] convert(int[] n){
    int[] converted=new int[n.length];
    for(int i=0 ; i<n.length ; i++){
      converted[i]=n[i];
      int order=n[i];
      for(int j=0 ; j<i ; j++){
        if(n[j]<order){
          converted[i]=converted[i]-1 ;
        }
      }
    }
    return converted ;
  }
  public static int abs(int n){
    return n>0 ? n :-n ;
  }
  public static int pow(int n){
    int powNum=1 ;
    for(int i=1 ; i<=n ; i++){
      powNum=powNum*i ;
    }
    return powNum ;
  }
  public static void print(Object obj){
    System.out.println(obj);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    var q : Sequence(int) ; q := Integer.subrange(1,n)->collect(0) ;
    for i : Integer.subrange(1, n) do
    (    p[i - 1+1] := sc.getCurrent()->toInteger()) ; 
    for i : Integer.subrange(1, n) do
    (    q[i - 1+1] := sc.getCurrent()->toInteger()) ; 
    var convertedP : Sequence(int) ; convertedP := convert(p) ;
    var convertedQ : Sequence(int) ; convertedQ := convert(q) ;
    var diff : int ; diff := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     diff := diff + (convertedP[i+1] - convertedQ[i+1]) * pow(n - i - 1) )  ;     i := i + 1 ) ; 
    execute print(abs(diff)) ; 
    skip ; 
 );
  static   operation convert( n : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var converted : Sequence(int) ; converted := Integer.subrange(1,n->size())->collect(0) ;
         var i : int ; i := 0 ; while i < n->size() do ( (     converted[i+1] := n[i+1] ; 
     var order : int ; order := n[i+1] ;
         var j : int ; j := 0 ; while j < i do ( (     if (n[j+1] < order) then (     converted[i+1] := converted[i+1] - 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return converted );
  static   operation abs( n : int) : int
  pre: true
  post: true
  activity: (     return if n > 0 then n else -n endif );
  static   operation pow( n : int) : int
  pre: true
  post: true
  activity: (     var powNum : int ; powNum := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (     powNum := powNum * i )  ;     i := i + 1 ) ; 
     return powNum );
  static   operation print( obj : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(obj) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      if(n<=2){
        for(int i=9 ; i>=0 && n>0 ; i--){
          System.out.print(i);
          n--;
        }
        System.out.println();
      }
      else {
        System.out.print(9);
        System.out.print(8);
        System.out.print(9);
        n-=3 ;
        for(int i=0 ; i<n ; i++){
          System.out.print(i % 10);
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n <= 2) then (         var i : int ; i := 9 ; while i >= 0 & n > 0 do ( (     OclFile["System.out"].print(i) ; 
     n := n - 1 )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println() ) else (     OclFile["System.out"].print(9) ; 
     OclFile["System.out"].print(8) ; 
    OclFile["System.out"].print(9) ; 
    n := n-(3) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(i mod 10) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner input=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=input.nextInt();
    while(t-->0){
      int n=input.nextInt();
      int y=0 ;
      if(n>2){
        out.print(989);
        while((n-3)>0){
          out.print(y % 10);
          y++;
          n--;
        }
      }
      else if(n==2){
        out.print(98);
      }
      else {
        out.print(9);
      }
      out.println();
    }
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := input.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := input.getCurrent()->toInteger() ;
     var y : int ; y := 0 ;
     if (n > 2) then (     skip ; 
     while ((n - 3) > 0) do (     skip ; 
     y := y + 1 ; 
     n := n - 1 ) ) else     if (n = 2) then (     skip ) else (     skip ) ;  ;  
     skip ) ;  ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int c=0 ;
    for(int i=0 ; i<=(n/k); ++i){
      for(int j=0 ; j<k ; ++j){
        c++;
        if(c<=n)System.out.print((char)(97+j));
        else break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i <= (n / k) do ( (         var j : int ; j := 0 ; while j < k do ( (     c := c + 1 ; 
     if (c <= n) then     OclFile["System.out"].print((97 + j)->oclAsType(String)) ; else     break )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  static int MOD=1000000007 ;
  static int[] arr=new int[100001];
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      solve(s);
    }
  }
  public static void solve(Scanner s){
    int n=s.nextInt();
    for(int i=1 ; i<=n ; i++)arr[i]=s.nextInt();
    Arrays.sort(arr,1,n+1);
    long ans=Integer.MAX_VALUE ;
    for(int i=3 ; i<=n ; i++)ans=Math.min(ans,arr[i]-arr[i-2]);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   attribute MOD : int := 1000000007;
  static   attribute arr : Sequence(int) := Integer.subrange(1,100001)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve(s) ) ;  ) );
  static   operation solve( s : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= n do (     arr[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr.subrange(1,1)^(arr.subrange(1+1,n + 1)->sort())^arr.subrange(n + 1+1,arr.size) ; 
    var ans : long ; ans := 2147483647 ;
        var i : int ; i := 3 ; while i <= n do (     ans := Set{ans, arr[i+1] - arr[i - 2+1]}->min() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.function.IntPredicate ;
import org.omg.CORBA.Current ;
import static java.lang.Math.abs ;
public class omar {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int k=input.nextInt();
    String s="" ;
    for(int i=0 ; i<n ; i++){
      s+=(char)((int)'a'+i % k);
    }
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class omar {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var k : int ; k := input.getCurrent()->toInteger() ;
    var s : String ; s := "" ;
        var i : int ; i := 0 ; while i < n do ( (     s := s+((('a')->char2byte() + i mod k)->oclAsType(String)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    String out="" ;
    String[] chars=new String[26];
    int[] v=new int[k];
    for(int i=0 ; i<26 ; i++){
      chars[i]=Character.toString((char)(i+97));
    }
    for(int i=0 ; i<k ; i++){
      v[i]=i ;
    }
    while(out.length()<n){
      if(k==n){
        for(int i=0 ; i<n ; i++){
          out+=chars[i];
        }
      }
      else {
        for(int i=0 ; i<k ; i++){
          if(out.length()<n){
            out+=chars[v[i] ];
          }
          else break ;
        }
      }
    }
    System.out.println(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var out : String ; out := "" ;
    var chars : Sequence(String) ; chars := Integer.subrange(1,26)->collect(null) ;
    var v : Sequence(int) ; v := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < 26 do ( (     chars[i+1] := ((i + 97)->oclAsType(String) + "") )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do ( (     v[i+1] := i )  ;     i := i + 1 ) ; 
    while (out->size() < n) do (     if (k = n) then (         var i : int ; i := 0 ; while i < n do ( (     out := out+(chars[i+1]) )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < k do ( (     if (out->size() < n) then (     out := out+(chars[v[i+1]+1]) ) else     break )  ;     i := i + 1 ) ) ) ; 
    OclFile["System.out"].println(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    String s="" ;
    for(int i=0 ; i<n ; i++){
      s+=(char)((int)'a'+i % k);
    }
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var s : String ; s := "" ;
        var i : int ; i := 0 ; while i < n do ( (     s := s+((('a')->char2byte() + i mod k)->oclAsType(String)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    String s="" ;
    for(int i=0 ; i<n ; i++){
      s+=(char)((int)'a'+(i % k));
    }
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var s : String ; s := "" ;
        var i : int ; i := 0 ; while i < n do ( (     s := s+((('a')->char2byte() + (i mod k))->oclAsType(String)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class WTLW {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] arr=new String[0];
    try {
      String s=br.readLine();
      arr=s.split(" ");
    }
    catch(IOException e){
    }
    if(arr.length==0)System.exit(1);
    long n=Long.valueOf(arr[0]);
    long t=Long.valueOf(arr[1]);
    double base=1.000000011 ;
    System.out.println(n*Math.pow(base,t));
  }
}
------------------------------------------------------------
OCL File:
---------
 class WTLW {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var arr : Sequence(String) ; arr := Integer.subrange(1,0)->collect(null) ;
    try (     var s : String ; s := br.readLine() ;
     arr := s->split(" ") )   catch (e : IOException) do skip
    if (arr->size() = 0) then OclProcess.exit(1) ; else skip ; 
    var n : long ; n := (arr[0+1])->toLong() ;
    var t : long ; t := (arr[1+1])->toLong() ;
    var base : double ; base := 1.000000011 ;
    OclFile["System.out"].println(n * base->pow(t)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    System.out.println(n*Math.pow(1.000000011,t));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(n * 1.000000011->pow(t)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main extends PrintWriter {
  Main(){
    super(System.out,true);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    Main o=new Main();
    o.main();
    o.flush();
  }
  int[] fac ;
  boolean[] used ;
  int rank(int[] aa,int n){
    Arrays.fill(used,false);
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      int k=0 ;
      for(int a=0 ; a<aa[i]; a++)if(! used[a])k++;
      sum+=fac[n-1-i]*k ;
      used[aa[i] ]=true ;
    }
    return sum ;
  }
  void main(){
    int n=sc.nextInt();
    int[] pp=new int[n];
    for(int i=0 ; i<n ; i++)pp[i]=sc.nextInt()-1 ;
    int[] qq=new int[n];
    for(int i=0 ; i<n ; i++)qq[i]=sc.nextInt()-1 ;
    fac=new int[n];
    for(int i=0,f=1 ; i<n ; i++){
      fac[i]=f ;
      f*=(i+1);
    }
    used=new boolean[n];
    println(Math.abs(rank(pp,n)-rank(qq,n)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends OclFile {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"], true) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : Main ; o := Main.newMain() ;
     o.main() ; 
     o.flush() );
   attribute fac : Sequence(int);
   attribute used : Sequence(boolean);
   operation rank( aa : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     used := used->collect(false) ; 
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var k : int ; k := 0 ;
         var a : int ; a := 0 ; while a < aa[i+1] do (     if (not(used[a+1])) then     k := k + 1 ; else skip ;  ;     a := a + 1 ) ; 
     sum := sum+(fac[n - 1 - i+1] * k) ; 
     used[aa[i+1]+1] := true )  ;     i := i + 1 ) ; 
     return sum );
   operation main() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var pp : Sequence(int) ; pp := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     pp[i+1] := sc.getCurrent()->toInteger() - 1 ;  ;     i := i + 1 ) ; 
    var qq : Sequence(int) ; qq := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     qq[i+1] := sc.getCurrent()->toInteger() - 1 ;  ;     i := i + 1 ) ; 
    fac := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ;
    var f : int ; f := 1 ; while i < n do ( (     fac[i+1] := f ; 
     f := f*((i + 1)) )  ;     i := i + 1 ) ; 
    used := Integer.subrange(1,n)->collect(false) ; 
    execute println(if rank(pp, n) - rank(qq, n) < 0 then -(rank(pp, n) - rank(qq, n)) else rank(pp, n) - rank(qq, n) endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    Scanner input=new Scanner(System.in);
    int i=input.nextInt();
    long num=input.nextLong();
    System.out.println(i*Math.pow(1.000000011,num));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var i : int ; i := input.getCurrent()->toInteger() ;
    var num : long ; num := input.getCurrent()->toLong() ;
    OclFile["System.out"].println(i * 1.000000011->pow(num)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class smth {
  public static void main(String[] args)throws IOException {
    try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
){
      String[] strings=reader.readLine().split(" ");
      double trans=Double.parseDouble(strings[0]);
      int t=Integer.parseInt(strings[1]);
      for(int i=0 ; i<t/100 ; i++){
        trans*=1.0000011000006015 ;
      }
      System.out.println(trans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class smth {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var strings : Sequence(String) ; strings := reader.readLine()->split(" ") ;
     var trans : double ; trans := (strings[0+1])->toReal() ;
    var t : int ; t := (strings[1+1])->toInteger() ;
        var i : int ; i := 0 ; while i < t / 100 do ( (     trans := trans*(1.0000011000006015) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(trans) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Delimost {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int t=in.nextInt();
    System.out.println(n*Math.pow(1.000000011,t));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Delimost {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
     var t : int ; t := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println(n * 1.000000011->pow(t)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      long N=sc.nextLong(),K=sc.nextLong();
      long ans=0 ;
      for(long i=0 ; i<N-1 ; i++){
        ans=K*((long)(ans/(K-1)))+ans %(K-1)+1 ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : long ; N := sc.getCurrent()->toLong() ;
    var K : long ; K := sc.getCurrent()->toLong() ;
     var ans : long ; ans := 0 ;
         var i : long ; i := 0 ; while i < N - 1 do ( (     ans := K * ((ans / (K - 1))->oclAsType(long)) + ans mod (K - 1) + 1 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int m=4 ;
  static int n=3 ;
  static class pair {
    int first,second ;
    public pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static int Maze(int matrix[][]){
    Queue<pair>q=new LinkedList<>();
    q.add(new pair(0,0));
    int count=0 ;
    while(! q.isEmpty()){
      pair p=q.peek();
      q.remove();
      if(p.first==n-1 && p.second==m-1)count++;
      if(p.first+1<n && matrix[p.first+1][p.second]==1){
        q.add(new pair(p.first+1,p.second));
      }
      if(p.second+1<m && matrix[p.first][p.second+1]==1){
        q.add(new pair(p.first,p.second+1));
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int matrix[][]={
      {
        1,0,0,1 },{
          1,1,1,1 },{
            1,0,1,1 }
          };
          System.out.println(Maze(matrix));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute m : int := 4;
  static   attribute n : int := 3;
  static class pair {
   attribute first : int;
   static operation newpair( first : int, second : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation Maze( matrix : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var q : Sequence(pair) ; q := Sequence{} ;
     q := q->including(pair.newpair(0, 0)) ; 
    var count : int ; count := 0 ;
    while (not(q->isEmpty())) do (     var p : pair ; p := q->min() ;
     q := q.remove() ; 
    if (p->at("first") = n - 1 & p->at("second") = m - 1) then     count := count + 1 ; else skip ; 
    if (p->at("first") + 1 < n & matrix[p->at("first") + 1+1][p->at("second")+1] = 1) then (     q := q->including(pair.newpair(p->at("first") + 1, p->at("second"))) ) else skip ; 
    if (p->at("second") + 1 < m & matrix[p->at("first")+1][p->at("second") + 1+1] = 1) then (     q := q->including(pair.newpair(p->at("first"), p->at("second") + 1)) ) else skip ; 
 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var matrix : Sequence(Sequence(int)) ; matrix := Sequence{Sequence{1,0,0,1},Sequence{1,1,1,1},Sequence{1,0,1,1}} ;
     OclFile["System.out"].println(Maze(matrix)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Jail solver=new Jail();
    solver.solve(1,in,out);
    out.close();
  }
  static class Jail {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      long N=in.nextInt();
      long K=in.nextInt();
      long ans=0 ;
      for(int i=0 ; i<N-1 ; i++){
        ans+=ans/(K-1)+1 ;
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Jail ; solver := Jail.newJail() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class Jail {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : long ; N := in.getCurrent()->toInteger() ;
     var K : long ; K := in.getCurrent()->toInteger() ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     ans := ans+(ans / (K - 1) + 1) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    long idx=0 ;
    for(int i=1 ; i<n ; i++){
      idx+=idx/(k-1)+1 ;
    }
    System.out.println(idx);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var idx : long ; idx := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     idx := idx+(idx / (k - 1) + 1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(idx) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  private static long gcd(long a,long b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt(),k=in.nextInt();
    long ans=0 ;
    for(int i=1 ; i<n ; i++){
      ans+=ans/(k-1);
      ans++;
    }
    out.println(ans);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     ans := ans+(ans / (k - 1)) ; 
     ans := ans + 1 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    System.out.println((n-1)*(m-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println((n - 1) * (m - 1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int len=sc.nextInt();
      Set<Integer>set=new HashSet<>(len);
      for(int i=1 ; i<=len ; i++){
        set.add(i);
      }
      int a=1 ;
      for(int i=1 ; i<len ; i++){
        int next=sc.nextInt();
        a+=factorial(len-i)*count(set,next)-1 ;
        set.remove(next);
      }
      sc.nextInt();
      set=new HashSet<>(len);
      for(int i=1 ; i<=len ; i++){
        set.add(i);
      }
      int b=1 ;
      for(int i=1 ; i<len ; i++){
        int next=sc.nextInt();
        b+=factorial(len-i)*count(set,next)-1 ;
        set.remove(next);
      }
      System.out.print(Math.abs(b-a));
    }
  }
  private static int count(Set<Integer>set,int num){
    int ans=0 ;
    for(int i=1 ; i<=num ; i++){
      if(set.contains(i)){
        ans++;
      }
    }
    return ans ;
  }
  private static int factorial(int num){
    int ans=1 ;
    for(int i=num ; i>=1 ; i--){
      ans*=i ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var len : int ; len := sc.getCurrent()->toInteger() ;
     var set : Set(int) ; set := Set{} ;
        var i : int ; i := 1 ; while i <= len do ( (     set := set->including(i) )  ;     i := i + 1 ) ; 
    var a : int ; a := 1 ;
        var i : int ; i := 1 ; while i < len do ( (     var next : int ; next := sc.getCurrent()->toInteger() ;
     a := a+(factorial(len - i) * count(set, next) - 1) ; 
     set := set->excludingAt(next+1) )  ;     i := i + 1 ) ; 
    skip ; 
    set := Set{} ; 
        var i : int ; i := 1 ; while i <= len do ( (     set := set->including(i) )  ;     i := i + 1 ) ; 
    var b : int ; b := 1 ;
        var i : int ; i := 1 ; while i < len do ( (     var next : int ; next := sc.getCurrent()->toInteger() ;
     b := b+(factorial(len - i) * count(set, next) - 1) ; 
     set := set->excludingAt(next+1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(if b - a < 0 then -(b - a) else b - a endif) ; 
 ))  );
  static   operation count( set : Set(int), num : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i <= num do ( (     if (set->includes(i)) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
     return ans );
  static   operation factorial( num : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
         var i : int ; i := num ; while i >= 1 do ( (     ans := ans*(i) )  ;     i := i - 1 ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static void solve(){
    Scanner sc=new Scanner(System.in);
    System.out.println((sc.nextInt()-1)*(sc.nextInt()-1));
    sc.close();
  }
  public static void main(String args[]){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println((sc.getCurrent()->toInteger() - 1) * (sc.getCurrent()->toInteger() - 1)) ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    System.out.println((n-1)*(m-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
     var m : int ; m := scan.getCurrent()->toInteger() ;
     OclFile["System.out"].println((n - 1) * (m - 1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int m=Integer.parseInt(sc.next());
    System.out.println((n-1)*(m-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
     var m : int ; m := (sc.getCurrent())->toInteger() ;
     OclFile["System.out"].println((n - 1) * (m - 1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    if(n % 1000==0){
      System.out.println(0);
    }
    else {
      System.out.println(1000-(n % 1000));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     if (n mod 1000 = 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(1000 - (n mod 1000)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import java.util.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        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 ;
    }
    public Character charAt(int i){
      return null ;
    }
  }
  public static void main(String[] args)throws IOException {
    FastReader s=new FastReader();
    int n=s.nextInt();
    int p=1000,j=0 ;
    while(n>0){
      j=n-p ;
      n-=p ;
    }
    System.out.println(Math.abs(j));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation charAt( i : int) : String
  pre: true
  post: true
  activity: (     return null );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : FastReader ; s := FastReader.newFastReader() ;
     var n : int ; n := s.nextInt() ;
    var p : int ; p := 1000 ;
    var j : int ; j := 0 ;
    while (n > 0) do (     j := n - p ; 
     n := n-(p) ) ; 
    OclFile["System.out"].println(if j < 0 then -(j) else j endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static boolean isPerfectSquare(int num){
    int n=(int)(Math.sqrt(num));
    return(n*n==num);
  }
  static void checkFib(int array[],int n){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(isPerfectSquare(5*array[i]*array[i]+4)|| isPerfectSquare(5*array[i]*array[i]-4)){
        System.out.print(array[i]+" ");
        count++;
      }
    }
    if(count==0)System.out.println("None Present");
  }
  public static void main(String[] args){
    int array[]={
      4,2,8,5,20,1,40,13,23 };
      int n=array.length ;
      checkFib(array,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPerfectSquare( num : int) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := ((num)->sqrt())->oclAsType(int) ;
     return (n * n = num) );
  static   operation checkFib( array : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (isPerfectSquare(5 * array[i+1] * array[i+1] + 4) or isPerfectSquare(5 * array[i+1] * array[i+1] - 4)) then (     OclFile["System.out"].print(array[i+1] + " ") ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (count = 0) then     OclFile["System.out"].println("None Present") ; else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Sequence{4,2,8,5,20,1,40,13,23} ;
     var n : int ; n := array->size() ;
     execute checkFib(array, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    while(n>=1000){
      n=n-1000 ;
    }
    if(n!=0 && 1000>=n){
      n=1000-n ;
    }
    out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     while (n >= 1000) do (     n := n - 1000 ) ; 
     if (n /= 0 & 1000 >= n) then (     n := 1000 - n ) else skip ; 
     out.println(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int res=n/1000 ;
    if(n % 1000!=0)res++;
    res=(res*1000)-n ;
    pw.println(res);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var res : int ; res := n / 1000 ;
    if (n mod 1000 /= 0) then     res := res + 1 ; else skip ; 
    res := (res * 1000) - n ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedWriter ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int s=0 ;
    if(N % 1000==0){
      System.out.println(0);
    }
    else {
      s=N % 1000 ;
      System.out.println(1000-s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     var s : int ; s := 0 ;
     if (N mod 1000 = 0) then (     OclFile["System.out"].println(0) ) else (     s := N mod 1000 ; 
     OclFile["System.out"].println(1000 - s) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class1 {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int ans=x/2+1 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class class1 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     var ans : int ; ans := x / 2 + 1 ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(final String[] args)throws Exception {
    final Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    StringBuffer p=new StringBuffer();
    for(int i=0 ; i<N ; i++){
      p.append(sc.next());
    }
    StringBuffer q=new StringBuffer();
    for(int i=0 ; i<N ; i++){
      q.append(sc.next());
    }
    final Solver solver=new Solver(p.toString(),q.toString());
    solver.solve(N);
  }
}
class Solver {
  final String P ;
  final String Q ;
  long lessThanP=0 ;
  long lessThanQ=0 ;
  public Solver(String P,String Q){
    this.P=P ;
    this.Q=Q ;
  }
  public void solve(int N){
    StringBuffer sb=new StringBuffer();
    for(int i=1 ; i<=N ; i++){
      sb.append(i);
    }
    permutate(sb,0,N-1);
    System.out.println(Math.abs(lessThanP-lessThanQ));
  }
  private void permutate(StringBuffer str,int l,int r){
    if(l==r){
      final String perm=str.toString();
      if(perm.compareTo(P)<0){
        lessThanP++;
      }
      if(perm.compareTo(Q)<0){
        lessThanQ++;
      }
    }
    else {
      for(int i=l ; i<=r ; i++){
        swap(str,l,i);
        permutate(str,l+1,r);
        swap(str,l,i);
      }
    }
  }
  private StringBuffer swap(StringBuffer s,int i,int j){
    char tmp=s.charAt(j);
    s.setCharAt(j,s.charAt(i));
    s.setCharAt(i,tmp);
    return s ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var p : String ; p := StringLib.newString() ;
        var i : int ; i := 0 ; while i < N do ( (     p := p + StringLib.newString(sc.getCurrent()) )  ;     i := i + 1 ) ; 
    var q : String ; q := StringLib.newString() ;
        var i : int ; i := 0 ; while i < N do ( (     q := q + StringLib.newString(sc.getCurrent()) )  ;     i := i + 1 ) ; 
    var solver : Solver ; solver := Solver.newSolver(p+"", q+"") ;
    solver.solve(N) ; 
 );
}
class Solver {
   attribute P : String;
   attribute Q : String;
   attribute lessThanP : long := 0;
   attribute lessThanQ : long := 0;
   static operation newSolver( P : String, Q : String) : Solver
  pre: true
  post: true
  activity:
  ( var self : Solver ;
    self := createSolver();
    self.initialise(P, Q);
    return self );
  operation initialise( P : String, Q : String) : void
  pre: true  post: true
  activity: (     self.P := P ; 
     self.Q := Q );
   operation solve( N : int) : void
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 1 ; while i <= N do ( (     sb := sb + StringLib.newString(i) )  ;     i := i + 1 ) ; 
     execute permutate(sb, 0, N - 1) ; 
     OclFile["System.out"].println(if lessThanP - lessThanQ < 0 then -(lessThanP - lessThanQ) else lessThanP - lessThanQ endif) );
   operation permutate( str : String, l : int, r : int) : void
  pre: true
  post: true
  activity: (     if (l = r) then (     var perm : String ; perm := str+"" ;
     if (perm->compareTo(P) < 0) then (     lessThanP := lessThanP + 1 ) else skip ; 
     if (perm->compareTo(Q) < 0) then (     lessThanQ := lessThanQ + 1 ) else skip ) else (         var i : int ; i := l ; while i <= r do ( (     execute swap(str, l, i) ; 
     execute permutate(str, l + 1, r) ; 
     execute swap(str, l, i) )  ;     i := i + 1 ) ) );
   operation swap( s : String, i : int, j : int) : String
  pre: true
  post: true
  activity: (     var tmp : String ; tmp := s->at(j+1) ;
     s := s.setAt(j+1, s->at(i+1)) ; 
     s := s.setAt(i+1, tmp) ; 
     return s );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Splits {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    System.out.println((n/2)+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Splits {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
     OclFile["System.out"].println((n / 2) + 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Math.*;
public class x964A {
  public static void main(String[] args)throws IOException {
    InputStreamReader reader=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(reader);
    StringTokenizer token=new StringTokenizer("");
    InputReader scan=new InputReader(br,token);
    StringBuilder sb=new StringBuilder();
    int X=scan.nextInt();
    int result=X/2+1 ;
    sb.append(result);
    System.out.println(sb);
  }
  static class InputReader {
    private BufferedReader readfile ;
    private StringTokenizer token ;
    InputReader(BufferedReader br,StringTokenizer st){
      this.readfile=br ;
      this.token=st ;
    }
    String next(){
      while(! this.token.hasMoreTokens()){
        try {
          token=new StringTokenizer(readfile.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return this.token.nextToken();
    }
    String nextLine()throws IOException {
      return readfile.readLine();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class x964A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(reader) ;
    var token : OclIterator ; token := OclIterator.newOclIterator_String("") ;
    var scan : InputReader ; scan := InputReader.newInputReader(br, token) ;
    var sb : String ; sb := StringLib.newString() ;
    var X : int ; X := scan.nextInt() ;
    var result : int ; result := X / 2 + 1 ;
    sb := sb + StringLib.newString(result) ; 
    OclFile["System.out"].println(sb) ; 
 );
  static class InputReader {
   attribute readfile : OclFile;
   attribute token : OclIterator;
   static operation newInputReader( br : OclFile, st : OclIterator) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(br, st);
    return self );
  operation initialise( br : OclFile, st : OclIterator) : void
  pre: true  post: true
  activity: (     self.readfile := br ; 
     self.token := st );
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(self.token.hasNext())) do (     try (     token := OclIterator.newOclIterator_String(readfile.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return self.token.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return readfile.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int n=in.nextInt();
      System.out.println(n/2+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println(n / 2 + 1) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Splits {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    System.out.println(n/2+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Splits {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(n / 2 + 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  void solve()throws IOException {
    int n=ni(),m=ni();
    int[] a=nia(m);
    out.println(n-m-1);
  }
  String ns()throws IOException {
    while(! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine()," ");
    }
    return tok.nextToken();
  }
  int ni()throws IOException {
    return Integer.parseInt(ns());
  }
  long nl()throws IOException {
    return Long.parseLong(ns());
  }
  double nd()throws IOException {
    return Double.parseDouble(ns());
  }
  String[] nsa(int n)throws IOException {
    String[] res=new String[n];
    for(int i=0 ; i<n ; i++){
      res[i]=ns();
    }
    return res ;
  }
  int[] nia(int n)throws IOException {
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=ni();
    }
    return res ;
  }
  long[] nla(int n)throws IOException {
    long[] res=new long[n];
    for(int i=0 ; i<n ; i++){
      res[i]=nl();
    }
    return res ;
  }
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  public static void main(String[] args)throws IOException {
    in=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(System.out);
    tok=new StringTokenizer("");
    Main main=new Main();
    main.solve();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := ni() ;
    var m : int ; m := ni() ;
     var a : Sequence(int) ; a := nia(m) ;
     out.println(n - m - 1) );
   operation ns() : String
  pre: true
  post: true
  activity: (     while (not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String_String(in.readLine(), " ") ) ; 
     return tok.next() );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (ns())->toInteger() );
   operation nl() : long
  pre: true
  post: true
  activity: (     return (ns())->toLong() );
   operation nd() : double
  pre: true
  post: true
  activity: (     return (ns())->toReal() );
   operation nsa( n : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var res : Sequence(String) ; res := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := ns() )  ;     i := i + 1 ) ; 
     return res );
   operation nia( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := ni() )  ;     i := i + 1 ) ; 
     return res );
   operation nla( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var res : Sequence(long) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := nl() )  ;     i := i + 1 ) ; 
     return res );
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    tok := OclIterator.newOclIterator_String("") ; 
    var main : Main ; main := Main.newMain() ;
    main.solve() ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.security.NoSuchAlgorithmException ;
import java.util.ArrayList ;
import java.util.HashMap ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[] a=new int[M];
    for(int i=0 ; i<M ; i++){
      a[i]=sc.nextInt();
    }
    boolean[] hoge=new boolean[N];
    for(int i=0 ; i<N ; i++){
      hoge[i]=true ;
    }
    for(int i=0 ; i<M ; i++){
      hoge[a[i] ]=false ;
    }
    int sum=0 ;
    for(int i=0 ; i<N ; i++){
      boolean[] nex=new boolean[N>>(i+1)];
      if(nex.length==0)break ;
      for(int k=0 ; k<hoge.length ; k+=2){
        if(hoge[k] && hoge[k+1]){
          nex[k/2]=true ;
          sum++;
        }
        else if(! hoge[k] && hoge[k+1] || hoge[k] && ! hoge[k+1]){
          nex[k/2]=true ;
        }
      }
      hoge=nex ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var hoge : Sequence(boolean) ; hoge := Integer.subrange(1,N)->collect(false) ;
        var i : int ; i := 0 ; while i < N do ( (     hoge[i+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     hoge[a[i+1]+1] := false )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var nex : Sequence(boolean) ; nex := Integer.subrange(1,(N/(2->pow((i + 1))))->oclAsType(long))->collect(false) ;
     if (nex->size() = 0) then     break else skip ; 
         var k : int ; k := 0 ; while k < hoge->size() do ( (     if (hoge[k+1] & hoge[k + 1+1]) then (     nex[k / 2+1] := true ; 
     sum := sum + 1 ) else     if (not(hoge[k+1]) & hoge[k + 1+1] or hoge[k+1] & not(hoge[k + 1+1])) then (     nex[k / 2+1] := true ) else skip ; )  ;     k := k+(2) ) ; 
     hoge := nex )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findNthNumber(int A,int B,int N){
    int sum=0 ;
    for(int i=2 ; i<N ; i++){
      sum=A+B ;
      A=B ;
      B=sum ;
    }
    return sum ;
  }
  public static void main(String[] args){
    int A=5,B=7,N=10 ;
    System.out.println(findNthNumber(A,B,N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNthNumber( A : int, B : int, N : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 2 ; while i < N do ( (     sum := A + B ; 
     A := B ; 
     B := sum )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 5 ;
    var B : int ; B := 7 ;
    var N : int ; N := 10 ;
     OclFile["System.out"].println(findNthNumber(A, B, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      System.out.println(sc.nextInt()-sc.nextInt()-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     OclFile["System.out"].println(sc.getCurrent()->toInteger() - sc.getCurrent()->toInteger() - 1) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
  Scanner sc=new Scanner(System.in);
  int rec(int[] b,int left,int right){
    if(right-left==2){
      if(b[left]==-1 && b[left+1]==-1){
        return-1 ;
      }
      if(b[left]==-1 || b[left+1]==-1){
        return 0 ;
      }
      return 1 ;
    }
    int mid=(left+right)/2 ;
    int leftSum=rec(b,left,mid);
    int rightSum=rec(b,mid,right);
    if(leftSum==-1 && rightSum==-1){
      return-1 ;
    }
    if(leftSum==-1 || rightSum==-1){
      return leftSum+rightSum+1 ;
    }
    return leftSum+rightSum+1 ;
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int a[]=new int[m];
    for(int i=0 ; i<m ; i++){
      a[i]=sc.nextInt();
    }
    int b[]=new int[n];
    for(int i=0 ; i<m ; i++){
      b[a[i] ]=-1 ;
    }
    System.out.println(rec(b,0,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation rec( b : Sequence(int), left : int, right : int) : int
  pre: true
  post: true
  activity: (     if (right - left = 2) then (     if (b[left+1] = -1 & b[left + 1+1] = -1) then (     return -1 ) else skip ; 
     if (b[left+1] = -1 or b[left + 1+1] = -1) then (     return 0 ) else skip ; 
     return 1 ) else skip ; 
     var mid : int ; mid := (left + right) / 2 ;
    var leftSum : int ; leftSum := rec(b, left, mid) ;
    var rightSum : int ; rightSum := rec(b, mid, right) ;
    if (leftSum = -1 & rightSum = -1) then (     return -1 ) else skip ; 
    if (leftSum = -1 or rightSum = -1) then (     return leftSum + rightSum + 1 ) else skip ; 
    return leftSum + rightSum + 1 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     b[a[i+1]+1] := -1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(rec(b, 0, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int count=n-1 ;
    System.out.println(Math.max(0,n-1-m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var count : int ; count := n - 1 ;
    OclFile["System.out"].println(Set{0, n - 1 - m}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class practice {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    String s=scn.next(),p ;
    int k=scn.nextInt(),x=0,y=0,ans=0 ;
    char a,b ;
    for(int i=0 ; i<k ; i++){
      p=scn.next();
      for(int j=0 ; j<s.length(); j++){
        if(s.charAt(j)==p.charAt(0)){
          x++;
        }
        else if(s.charAt(j)==p.charAt(1)){
          y++;
        }
        else {
          ans+=Math.min(x,y);
          x=0 ;
          y=0 ;
        }
      }
      ans+=Math.min(x,y);
      x=0 ;
      y=0 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scn.getCurrent() ;
    var p : String ;
    var k : int ; k := scn.getCurrent()->toInteger() ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var ans : int ; ans := 0 ;
    var a : String ;
    var b : String ;
        var i : int ; i := 0 ; while i < k do ( (     p := scn.getCurrent() ; 
         var j : int ; j := 0 ; while j < s->size() do ( (     if (s->at(j+1) = p->at(0+1)) then (     x := x + 1 ) else     if (s->at(j+1) = p->at(1+1)) then (     y := y + 1 ) else (     ans := ans+(Set{x, y}->min()) ; 
     x := 0 ; 
     y := 0 ) ;  )  ;     j := j + 1 ) ; 
    ans := ans+(Set{x, y}->min()) ; 
    x := 0 ; 
    y := 0 ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    System.out.println((int)Math.pow(sc.nextInt(),3));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println(sc.getCurrent()->toInteger()->pow(3)->oclAsType(int)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException,Exception {
    BufferedReader st=new BufferedReader(new InputStreamReader(System.in));
    int n=getInt(st);
    int ans=n*n*n ;
    anser(ans);
  }
  private static int getInt(BufferedReader st)throws Exception,IOException {
    int num=Integer.parseInt(st.readLine());
    return num ;
  }
  private static void anser(int num){
    System.out.println(num);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var st : OclFile ; st := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := getInt(st) ;
     var ans : int ; ans := n * n * n ;
     execute anser(ans) );
  static   operation getInt( st : OclFile) : int
  pre: true
  post: true
  activity: (     var num : int ; num := (st.readLine())->toInteger() ;
     return num );
  static   operation anser( num : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(num) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    solve(System.in,System.out);
  }
  static void solve(InputStream is,PrintStream os){
    Scanner scan=new Scanner(is);
    int N=scan.nextInt();
    int answer=(int)Math.pow((double)N,3.0);
    os.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation solve( is : OclFile, os : OclFile) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(is) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
     var answer : int ; answer := N->oclAsType(double)->pow(3.0)->oclAsType(int) ;
     os.println(answer) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
import java.io.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int res=(int)(Math.pow(n,3));
    System.out.println(res);
    sc.close();
  }
}
class io {
  public static void YesNo(boolean f){
    System.out.println(f ? "Yes" : "No");
  }
  public static void YESNO(boolean f){
    System.out.println(f ? "YES" : "NO");
  }
}
class Algo {
  public static boolean isOdd(int n){
    return n % 2==1 ;
  }
  public static boolean isEven(int n){
    return n % 2==0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var res : int ; res := (n->pow(3))->oclAsType(int) ;
    OclFile["System.out"].println(res) ; 
    skip ; 
 );
}
class io {
  static   operation YesNo( f : boolean) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if f then "Yes" else "No" endif) );
  static   operation YESNO( f : boolean) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if f then "YES" else "NO" endif) );
}
class Algo {
  static   operation isOdd( n : int) : boolean
  pre: true
  post: true
  activity: (     return n mod 2 = 1 );
  static   operation isEven( n : int) : boolean
  pre: true
  post: true
  activity: (     return n mod 2 = 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println((int)Math.pow(N,3));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N->pow(3)->oclAsType(int)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    Scanner sc=new Scanner(systemin);
    int N=sc.nextInt();
    int M=sc.nextInt();
    System.out.printf("%d\n",N*M);
    sc.close();
    return false ;
  }
  PrintStream log ;
  PrintStream result=System.out ;
  BufferedReader systemin ;
  static Main instance=new Main();
  Main(){
    systemin=new BufferedReader(new InputStreamReader(System.in));
    log=new PrintStream(new OutputStream(){
      public void write(int b){
      }
    }
);
  }
  public static void main(String[] args)throws IOException {
    instance.main();
    instance.systemin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(systemin) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].printf("%d\n", N * M) ; 
    skip ; 
    return false 
 );
   attribute log : OclFile;
   attribute result : OclFile := OclFile["System.out"];
   attribute systemin : OclFile;
  static   attribute instance : Main := Main.newMain();
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     systemin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     log := OclFile.newOclFile_Write(OclFile()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     instance.main() ; 
     instance.systemin.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    System.out.println(m*n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(m * n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int findNature(int a,int b,int n){
    int[] seq=new int[100];
    seq[0]=a ;
    seq[1]=b ;
    for(int i=2 ; i<=n ; i++)seq[i]=seq[i-1]+seq[i-2];
    if((seq[n] & 1)!=0)return 1 ;
    else return 0 ;
  }
  public static void main(String[] args){
    int a=2,b=4 ;
    int n=3 ;
    if(findNature(a,b,n)==1)System.out.println("Odd ");
    else System.out.println("Even ");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNature( a : int, b : int, n : int) : int
  pre: true
  post: true
  activity: (     var seq : Sequence(int) ; seq := Integer.subrange(1,100)->collect(0) ;
     seq[0+1] := a ; 
    seq[1+1] := b ; 
        var i : int ; i := 2 ; while i <= n do (     seq[i+1] := seq[i - 1+1] + seq[i - 2+1] ;  ;     i := i + 1 ) ; 
    if ((seq[n+1] & 1) /= 0) then     return 1 else     return 0 ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2 ;
    var b : int ; b := 4 ;
     var n : int ; n := 3 ;
     if (findNature(a, b, n) = 1) then     OclFile["System.out"].println("Odd ") ; else     OclFile["System.out"].println("Even ") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    System.out.println(sc.nextInt()*sc.nextInt());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println(sc.getCurrent()->toInteger() * sc.getCurrent()->toInteger()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int r=sc.nextInt();
    int ans ;
    if(n>=10){
      ans=r ;
    }
    else {
      ans=r+(100*(10-n));
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var ans : int ;
    if (n >= 10) then (     ans := r ) else (     ans := r + (100 * (10 - n)) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.System.out ;
public class Main {
  static MyReader in=new MyReader();
  public static void main(String[] args){
    int N,R ;
    {
      int[] a=in.ii();
      N=a[0];
      R=a[1];
    }
    int ans ;
    if(N>=10){
      ans=R ;
    }
    else {
      ans=R+100*(10-N);
    }
    out.println(ans);
  }
  static class MyReader extends BufferedReader {
    MyReader(){
      super(new InputStreamReader(System.in));
    }
    String s(){
      try {
        return readLine();
      }
      catch(IOException e){
        return "" ;
      }
    }
    String[] ss(){
      return s().split(" ");
    }
    int i(){
      return Integer.parseInt(s());
    }
    int[] ii(){
      String[] ss=ss();
      int[] ii=new int[ss.length];
      for(int j=0 ; j<ss.length ; j++)ii[j]=Integer.parseInt(ss[j]);
      return ii ;
    }
    ArrayList<Integer>li(){
      String[] ss=ss();
      ArrayList<Integer>li=new ArrayList<>();
      for(int j=0 ; j<ss.length ; j++)li.add(Integer.parseInt(ss[j]));
      return li ;
    }
    long l(){
      return Long.parseLong(s());
    }
    long[] ll(){
      String[] ss=ss();
      long[] ll=new long[ss.length];
      for(int j=0 ; j<ss.length ; j++)ll[j]=Long.parseLong(ss[j]);
      return ll ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : MyReader := MyReader.newMyReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ;
    var R : int ;
 (     var a : Sequence(int) ; a := in.ii() ;
     N := a[0+1] ; 
     R := a[1+1] ) 
    var ans : int ;
    if (N >= 10) then (     ans := R ) else (     ans := R + 100 * (10 - N) ) ;  
    out.println(ans) ; 
 );
  static class MyReader extends OclFile {
   static operation newMyReader() : MyReader
  pre: true
  post: true
  activity:
  ( var self : MyReader ;
    self := createMyReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation s() : String
  pre: true
  post: true
  activity: (     try (     return readLine() )   catch (e : IOException) do (     return "" )
 );
   operation ss() : Sequence(String)
  pre: true
  post: true
  activity: (     return s()->split(" ") );
   operation i() : int
  pre: true
  post: true
  activity: (     return (s())->toInteger() );
   operation ii() : Sequence(int)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var ii : Sequence(int) ; ii := Integer.subrange(1,ss->size())->collect(0) ;
         var j : int ; j := 0 ; while j < ss->size() do (     ii[j+1] := (ss[j+1])->toInteger() ;  ;     j := j + 1 ) ; 
     return ii );
   operation li() : Sequence(int)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var li : Sequence(int) ; li := Sequence{} ;
         var j : int ; j := 0 ; while j < ss->size() do (     li := li->including((ss[j+1])->toInteger()) ;  ;     j := j + 1 ) ; 
     return li );
   operation l() : long
  pre: true
  post: true
  activity: (     return (s())->toLong() );
   operation ll() : Sequence(long)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var ll : Sequence(long) ; ll := Integer.subrange(1,ss->size())->collect(0) ;
         var j : int ; j := 0 ; while j < ss->size() do (     ll[j+1] := (ss[j+1])->toLong() ;  ;     j := j + 1 ) ; 
     return ll );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  final int MOD=1000000007 ;
  final int MAX=Integer.MAX_VALUE ;
  final long LMAX=Long.MAX_VALUE ;
  int LEN=(int)1e6+1 ;
  void doIt(){
    int N=sc.nextInt();
    int R=sc.nextInt();
    System.out.println(R+(100*Math.max(10-N,0)));
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute MOD : int := 1000000007;
   attribute MAX : int := 2147483647;
   attribute LMAX : long := "9223372036854775807"->toLong();
   attribute LEN : int := 1e6->oclAsType(int) + 1;
   operation doIt() : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var R : int ; R := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(R + (100 * Set{10 - N, 0}->max())) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(final String[] args)throws Exception {
    final Scanner sc=new Scanner(System.in);
    long N ;
    N=sc.nextLong();
    long R ;
    R=sc.nextLong();
    final Solver solver=new Solver();
    solver.solve(N,R);
  }
}
class Solver {
  public void solve(long N,long R){
    if(N<10){
      System.out.println(R+(100*(10-N)));
    }
    else {
      System.out.println(R);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ;
    N := sc.getCurrent()->toLong() ; 
    var R : long ;
    R := sc.getCurrent()->toLong() ; 
    var solver : Solver ; solver := Solver.newSolver() ;
    solver.solve(N, R) ; 
 );
}
class Solver {
   operation solve( N : long, R : long) : void
  pre: true
  post: true
  activity: (     if (N < 10) then (     OclFile["System.out"].println(R + (100 * (10 - N))) ) else (     OclFile["System.out"].println(R) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] data=br.readLine().split(" ");
    int numContest=Integer.parseInt(data[0]);
    int rate=Integer.parseInt(data[1]);
    if(numContest<10){
      rate=rate+100*(10-numContest);
    }
    System.out.println(rate);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var data : Sequence(String) ; data := br.readLine()->split(" ") ;
    var numContest : int ; numContest := (data[0+1])->toInteger() ;
    var rate : int ; rate := (data[1+1])->toInteger() ;
    if (numContest < 10) then (     rate := rate + 100 * (10 - numContest) ) else skip ; 
    OclFile["System.out"].println(rate) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    System.out.println((n*(n-1)/2)+(m*(m-1)/2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println((n * (n - 1) / 2) + (m * (m - 1) / 2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static void solve(){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    int v1=n*(n-1)/2 ;
    int v2=m*(m-1)/2 ;
    System.out.println(v1+v2);
  }
  public static void main(String[] args){
    solve();
  }
  class Counter extends HashMap<Integer,Integer>{
    public int get(int k){
      return containsKey(k)? super.get(k): 0 ;
    }
    public void add(int k,int v){
      put(k,get(k)+v);
    }
  }
  static class Node {
    int val ;
    Node next ;
    Node random ;
    public Node(int val){
      this.val=val ;
      this.next=null ;
      this.random=null ;
    }
  }
  static class TreeNode {
    int val ;
    TreeNode left ;
    TreeNode right ;
    TreeNode(int x){
      val=x ;
    }
  }
  static class Trie {
    void add(String word){
    }
    boolean search(String w){
      return false ;
    }
  }
  static class Node1 {
    public int val ;
    public List<Node1>children ;
    public Node1(){
    }
    public Node1(int _val,List<Node1>_children){
      val=_val ;
      children=_children ;
    }
  };
  static class TrieNode {
  }
  static class KvNode implements Comparable<KvNode>{
    String key ;
    int freq ;
    public KvNode(String key,int freq){
      this.key=key ;
      this.freq=freq ;
    }
    @ Override public int compareTo(KvNode o){
      if(this.key.equals(o.key)){
        return 0 ;
      }
      return Integer.compare(o.freq,this.freq);
    }
  }
  static class ListNode {
    int val ;
    ListNode next ;
    ListNode(int x){
      val=x ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var v1 : int ; v1 := n * (n - 1) / 2 ;
    var v2 : int ; v2 := m * (m - 1) / 2 ;
    OclFile["System.out"].println(v1 + v2) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
 class Counter extends Map(int,int) {
   operation get( k : int) : int
  pre: true
  post: true
  activity: (     return if containsKey(k) then super->at(k+1) else 0 endif );
   operation add( k : int, v : int) : void
  pre: true
  post: true
  activity: (     execute put(k, at(k+1) + v) );
}
  static class Node {
   attribute val : int;
   attribute next : Node;
   attribute random : Node;
   static operation newNode( val : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(val);
    return self );
  operation initialise( val : int) : void
  pre: true  post: true
  activity: (     self.val := val ; 
     self.next := null ; 
     self.random := null );
}
  static class TreeNode {
   attribute val : int;
   attribute left : TreeNode;
   attribute right : TreeNode;
   static operation newTreeNode( x : int) : TreeNode
  pre: true
  post: true
  activity:
  ( var self : TreeNode ;
    self := createTreeNode();
    self.initialise(x);
    return self );
  operation initialise( x : int) : void
  pre: true  post: true
  activity: (     val := x );
}
  static class Trie {
   operation add( word : String) : void
  pre: true
  post: true
  activity: skip;
   operation search( w : String) : boolean
  pre: true
  post: true
  activity: (     return false );
}
  static class Node1 {
   attribute val : int;
   attribute children : Sequence(Node1);
   static operation newNode1() : Node1
  pre: true
  post: true
  activity:
  ( var self : Node1 ;
    self := createNode1();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   static operation newNode1( _val : int, _children : Sequence(Node1)) : Node1
  pre: true
  post: true
  activity:
  ( var self : Node1 ;
    self := createNode1();
    self.initialise(_val, _children);
    return self );
  operation initialise( _val : int, _children : Sequence(Node1)) : void
  pre: true  post: true
  activity: (     val := _val ; 
     children := _children );
}
  static class TrieNode { }
  static class KvNode implements Comparable<KvNode> {
   attribute key : String;
   attribute freq : int;
   static operation newKvNode( key : String, freq : int) : KvNode
  pre: true
  post: true
  activity:
  ( var self : KvNode ;
    self := createKvNode();
    self.initialise(key, freq);
    return self );
  operation initialise( key : String, freq : int) : void
  pre: true  post: true
  activity: (     self.key := key ; 
     self.freq := freq );
      operation compareTo( o : KvNode) : int
  pre: true
  post: true
  activity: (     if (self.key = o.key) then (     return 0 ) else skip ; 
     return compare(o.freq, self.freq) );
}
  static class ListNode {
   attribute val : int;
   attribute next : ListNode;
   static operation newListNode( x : int) : ListNode
  pre: true
  post: true
  activity:
  ( var self : ListNode ;
    self := createListNode();
    self.initialise(x);
    return self );
  operation initialise( x : int) : void
  pre: true  post: true
  activity: (     val := x );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int M=scanner.nextInt();
    int nPlusMChoose2=(N+M)*(N+M-1)/2 ;
    int oddCombos=N*M ;
    int result=nPlusMChoose2-oddCombos ;
    System.out.printf("%d\n",result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var M : int ; M := scanner.getCurrent()->toInteger() ;
    var nPlusMChoose2 : int ; nPlusMChoose2 := (N + M) * (N + M - 1) / 2 ;
    var oddCombos : int ; oddCombos := N * M ;
    var result : int ; result := nPlusMChoose2 - oddCombos ;
    OclFile["System.out"].printf("%d\n", result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  static int comb(int m,int n){
    int res=1 ;
    if(n>m-n)n=m-n ;
    for(int i=0 ; i<n ; i++){
      res*=(m-i);
      res/=(i+1);
    }
    return res ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int m=in.nextInt();
    int n=in.nextInt();
    int total_ways=0 ;
    if(m>=2)total_ways+=comb(m,2);
    if(n>=2)total_ways+=comb(n,2);
    System.out.println(total_ways);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation comb( m : int, n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     if (n > m - n) then     n := m - n ; else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     res := res*((m - i)) ; 
     res := res/((i + 1)) )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var total_ways : int ; total_ways := 0 ;
    if (m >= 2) then     total_ways := total_ways+(comb(m, 2)) ; else skip ; 
    if (n >= 2) then     total_ways := total_ways+(comb(n, 2)) ; else skip ; 
    OclFile["System.out"].println(total_ways) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    Map<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      int count=map.getOrDefault(a,0);
      map.put(a,++count);
    }
    if(map.size()<=k){
      System.out.println(0);
      return ;
    }
    int diff=map.size()-k ;
    List<Map.Entry<Integer,Integer>>list=new ArrayList<>(map.entrySet());
    list.sort((e1,e2)->(e1.getValue()-e2.getValue()));
    int count=0 ;
    for(int i=0 ; i<diff ; i++){
      count+=list.get(i).getValue();
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var count : int ; count := (if map->keys()->contains(a) then map->at(a) else 0 endif) ;
     map := map->union(Map{a |-> (count + 1)}) )  ;     i := i + 1 ) ; 
    if (map.size() <= k) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var diff : int ; diff := map.size() - k ;
    var list : Sequence(Map(int,int)) ; list := Sequence{}->union(map->asSet()) ;
    list := list.sort(lambda (e1 , e2) : OclAny in (e1.getValue() - e2.getValue())) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < diff do ( (     count := count+(list->at(i+1).getValue()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int num1=scan.nextInt();
    int num2=scan.nextInt();
    int n=(num1*(num1-1))/2 ;
    int m=(num2*(num2-1))/2 ;
    int sum=n+m ;
    System.out.println(sum);
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num1 : int ; num1 := scan.getCurrent()->toInteger() ;
    var num2 : int ; num2 := scan.getCurrent()->toInteger() ;
    var n : int ; n := (num1 * (num1 - 1)) / 2 ;
    var m : int ; m := (num2 * (num2 - 1)) / 2 ;
    var sum : int ; sum := n + m ;
    OclFile["System.out"].println(sum) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Solution {
  public int findRadius(int[] houses,int[] heaters){
    Arrays.sort(heaters);
    int result=Integer.MIN_VALUE ;
    for(int house : houses){
      int index=Arrays.binarySearch(heaters,house);
      if(index<0)index=-(index+1);
      int dist1=index-1>=0 ? house-heaters[index-1] : Integer.MAX_VALUE ;
      int dist2=index<heaters.length ? heaters[index]-house : Integer.MAX_VALUE ;
      result=Math.max(result,Math.min(dist1,dist2));
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation findRadius( houses : Sequence(int), heaters : Sequence(int)) : int
  pre: true
  post: true
  activity: (     heaters := heaters->sort() ; 
     var result : int ; result := -2147483648 ;
     for (house : houses) do ( (     var index : int ; index := (heaters->indexOf(house) - 1) ;
     if (index < 0) then     index := -(index + 1) ; else skip ; 
    var dist1 : int ; dist1 := if index - 1 >= 0 then house - heaters[index - 1+1] else 2147483647 endif ;
    var dist2 : int ; dist2 := if index < heaters->size() then heaters[index+1] - house else 2147483647 endif ;
    result := Set{result, Set{dist1, dist2}->min()}->max() ; 
 )  ) ; 
     return result );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t--!=0){
      int n=scanner.nextInt();
      int k=scanner.nextInt();
      if(n % k==0){
        System.out.println(1);
        continue ;
      }
      if(n==1){
        System.out.println(k);
        continue ;
      }
      if(n<k){
        System.out.println(k % n==0 ? k/n : k/n+1);
      }
      else {
        System.out.println(((n/k+1)*k-n)/n+2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var k : int ; k := scanner.getCurrent()->toInteger() ;
    if (n mod k = 0) then (     OclFile["System.out"].println(1) ; 
     continue ) else skip ; 
    if (n = 1) then (     OclFile["System.out"].println(k) ; 
     continue ) else skip ; 
    if (n < k) then (     OclFile["System.out"].println(if k mod n = 0 then k / n else k / n + 1 endif) ) else (     OclFile["System.out"].println(((n / k + 1) * k - n) / n + 2) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SumD {
  int number ;
  public SumD(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  public void input(int n,int k){
    int count=n ;
    int index=0 ;
    if(k>=n){
      count=k ;
      index++;
    }
    while(true){
      if(count % k==0){
        break ;
      }
      if(index==0){
        if(2*k>n){
          count+=(k*2-n);
        }
        else {
          int c=n-k ;
          if((c/(double)k)% 1==0){
            count=(c/k)*k ;
          }
          else {
            count=((c/k)+1)*k ;
          }
        }
        if(count<n){
          count+=k ;
        }
        index++;
      }
      else {
        count+=k ;
      }
    }
    if((count/(double)n)% 1==0){
      System.out.println(count/n);
    }
    else {
      System.out.println((count/n)+1);
    }
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    SumD instance=new SumD(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      int num1=input.nextInt();
      int num2=input.nextInt();
      instance.input(num1,num2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SumD {
   attribute number : int;
   static operation newSumD( number : int) : SumD
  pre: true
  post: true
  activity:
  ( var self : SumD ;
    self := createSumD();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
   operation input( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var count : int ; count := n ;
     var index : int ; index := 0 ;
    if (k >= n) then (     count := k ; 
     index := index + 1 ) else skip ; 
    while (true) do (     if (count mod k = 0) then (     break ) else skip ; 
     if (index = 0) then (     if (2 * k > n) then (     count := count+((k * 2 - n)) ) else (     var c : int ; c := n - k ;
     if ((c / k->oclAsType(double)) mod 1 = 0) then (     count := (c / k) * k ) else (     count := ((c / k) + 1) * k ) ) ;  
     if (count < n) then (     count := count+(k) ) else skip ; 
     index := index + 1 ) else (     count := count+(k) ) ) ; 
    if ((count / n->oclAsType(double)) mod 1 = 0) then (     OclFile["System.out"].println(count / n) ) else (     OclFile["System.out"].println((count / n) + 1) ) ;  
 );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
     var instance : SumD ; instance := SumD.newSumD(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var num1 : int ; num1 := input.getCurrent()->toInteger() ;
     var num2 : int ; num2 := input.getCurrent()->toInteger() ;
     instance.input(num1, num2) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      long n=sc.nextLong();
      long k=sc.nextLong();
      if(n % k==0)System.out.println("1");
      else if(k % n==0)System.out.println(k/n);
      else if(n>k)System.out.println("2");
      else System.out.println(k/n+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : long ; n := sc.getCurrent()->toLong() ;
     var k : long ; k := sc.getCurrent()->toLong() ;
     if (n mod k = 0) then     OclFile["System.out"].println("1") ; else     if (k mod n = 0) then     OclFile["System.out"].println(k / n) else     if (n > k) then     OclFile["System.out"].println("2") else     OclFile["System.out"].println(k / n + 1) ; ;  ;  )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int prev=sc.nextInt();
    int count=0 ;
    for(int i=1 ; i<n ; i++){
      int x=sc.nextInt();
      if(prev<x){
        count++;
      }
      prev=x ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var prev : int ; prev := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (prev < x) then (     count := count + 1 ) else skip ; 
     prev := x )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] nums=new int[n];
    int ans=0 ;
    for(int i=0 ; i<n ; i++)nums[i]=sc.nextInt();
    for(int i=0 ; i<n-1 ; i++)if(nums[i]<nums[i+1])ans++;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do (     nums[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do (     if (nums[i+1] < nums[i + 1+1]) then     ans := ans + 1 ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long m=sc.nextLong();
    long count=0 ;
    long[] array=new long[3];
    Arrays.sort(array);
    System.out.println(1.0*n/m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var m : long ; m := sc.getCurrent()->toLong() ;
    var count : long ; count := 0 ;
    var array : Sequence(long) ; array := Integer.subrange(1,3)->collect(0) ;
    array := array->sort() ; 
    OclFile["System.out"].println(1.0 * n / m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args){
    SC sc=new SC(System.in);
    double T=sc.nextDouble();
    double X=sc.nextDouble();
    pl(T/X);
  }
  public static void pl(Object o){
    System.out.println(o);
  }
  public static void pl(){
    System.out.println();
  }
  public static void p(Object o){
    System.out.print(o);
  }
  static class SC {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public SC(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        throw new UncheckedIOException(e);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : SC ; sc := SC.newSC(OclFile["System.in"]) ;
     var T : double ; T := sc.nextDouble() ;
     var X : double ; X := sc.nextDouble() ;
     execute pl(T / X) );
  static   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation pl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
  static class SC {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newSC( in : OclFile) : SC
  pre: true
  post: true
  activity:
  ( var self : SC ;
    self := createSC();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int x=sc.nextInt();
    double ans=(double)t/x ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var ans : double ; ans := t->oclAsType(double) / x ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in),1);
    String s=r.readLine();
    String[] sl=s.split(" ");
    int n=Integer.parseInt(sl[0]);
    int m=Integer.parseInt(sl[1]);
    System.out.println((double)n/m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 1) ;
     var s : String ; s := r.readLine() ;
    var sl : Sequence(String) ; sl := s->split(" ") ;
    var n : int ; n := (sl[0+1])->toInteger() ;
    var m : int ; m := (sl[1+1])->toInteger() ;
    OclFile["System.out"].println(n->oclAsType(double) / m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.util.Collections ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    NotsoDiverse solver=new NotsoDiverse();
    solver.solve(1,in,out);
    out.close();
  }
  static class NotsoDiverse {
    int[] cnt=new int[200001];
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int N=in.nextInt();
      int K=in.nextInt();
      for(int i=0 ; i<N ; i++){
        cnt[in.nextInt()]++;
      }
      ArrayList<Integer>arr=new ArrayList<>();
      for(int i=0 ; i<cnt.length ; i++){
        if(cnt[i]>0){
          arr.add(cnt[i]);
        }
      }
      Collections.sort(arr);
      int ans=0 ;
      for(int i=0 ; i<arr.size()-K ; i++){
        ans+=arr.get(i);
      }
      out.println(ans);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : NotsoDiverse ; solver := NotsoDiverse.newNotsoDiverse() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class NotsoDiverse {
   attribute cnt : Sequence(int) := Integer.subrange(1,200001)->collect(0);
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.nextInt() ;
     var K : int ; K := in.nextInt() ;
        var i : int ; i := 0 ; while i < N do ( (     cnt[in.nextInt()+1] := cnt[in.nextInt()+1] + 1 )  ;     i := i + 1 ) ; 
    var arr : Sequence(int) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < cnt->size() do ( (     if (cnt[i+1] > 0) then (     arr := arr->including(cnt[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < arr->size() - K do ( (     ans := ans+(arr->at(i+1)) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countWays(int n,int arr[],int k){
    if(k<=0 || k>=n)return 0 ;
    Set<Integer>s=new HashSet<Integer>();
    for(int i=0 ; i<n ; i++)s.add(arr[i]);
    if(s.size()<=k)return 0 ;
    return s.size()-k ;
  }
  public static void main(String args[]){
    int arr[]={
      100,200,400,50 };
      int k=3 ;
      int n=arr.length ;
      System.out.println(countWays(n,arr,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countWays( n : int, arr : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     if (k <= 0 or k >= n) then     return 0 else skip ; 
     var s : Set(int) ; s := Set{} ;
        var i : int ; i := 0 ; while i < n do (     s := s->including(arr[i+1]) ;  ;     i := i + 1 ) ; 
    if (s->size() <= k) then     return 0 else skip ; 
    return s->size() - k 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{100,200,400,50} ;
     var k : int ; k := 3 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countWays(n, arr, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int[][] move={
      {
        1,0 },{
          0,1 },{
-1,0 },{
              0,-1 }
            };
            while(true){
              int c=sc.nextInt();
              int r=sc.nextInt();
              if((r | c)==0)break ;
              int ri=1 ;
              int rj=1 ;
              int dir=0 ;
              while(true){
                String cmd=sc.next();
                if("STOP".equals(cmd)){
                  System.out.println(rj+" "+ri);
                  break ;
                }
                if("RIGHT".equals(cmd))dir=(dir+1)% 4 ;
                else if("LEFT".equals(cmd))dir=(dir+3)% 4 ;
                else if("FORWARD".equals(cmd)){
                  int k=sc.nextInt();
                  while(k--!=0){
                    int ni=ri+move[dir][0];
                    int nj=rj+move[dir][1];
                    if(1<=ni && ni<=r && 1<=nj && nj<=c){
                      ri=ni ;
                      rj=nj ;
                    }
                    else break ;
                  }
                }
                else {
                  int k=sc.nextInt();
                  while(k--!=0){
                    int ni=ri+move[(dir+2)% 4][0];
                    int nj=rj+move[(dir+2)% 4][1];
                    if(1<=ni && ni<=r && 1<=nj && nj<=c){
                      ri=ni ;
                      rj=nj ;
                    }
                    else break ;
                  }
                }
              }
            }
          }
          public static void main(String[] args){
            new Main().run();
          }
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var move : Sequence(Sequence(int)) ; move := Sequence{Sequence{1,0},Sequence{0,1},Sequence{-1,0},Sequence{0,-1}} ;
     while (true) do (     var c : int ; c := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(r,c)) = 0) then     break else skip ; 
    var ri : int ; ri := 1 ;
    var rj : int ; rj := 1 ;
    var dir : int ; dir := 0 ;
    while (true) do (     var cmd : String ; cmd := sc.getCurrent() ;
     if ("STOP" = cmd) then (     OclFile["System.out"].println(rj + " " + ri) ; 
     break ) else skip ; 
     if ("RIGHT" = cmd) then     dir := (dir + 1) mod 4 ; else     if ("LEFT" = cmd) then     dir := (dir + 3) mod 4 else     if ("FORWARD" = cmd) then (     var k : int ; k := sc.getCurrent()->toInteger() ;
         while (k /= 0) do (    skip ; (     var ni : int ; ni := ri + move[dir+1][0+1] ;
     var nj : int ; nj := rj + move[dir+1][1+1] ;
     if (1 <= ni & ni <= r & 1 <= nj & nj <= c) then (     ri := ni ; 
     rj := nj ) else     break ) ;  ) ) else (     var k : int ; k := sc.getCurrent()->toInteger() ;
         while (k /= 0) do (    skip ; (     var ni : int ; ni := ri + move[(dir + 2) mod 4+1][0+1] ;
     var nj : int ; nj := rj + move[(dir + 2) mod 4+1][1+1] ;
     if (1 <= ni & ni <= r & 1 <= nj & nj <= c) then (     ri := ni ; 
     rj := nj ) else     break ) ;  ) ) ;  ;  ) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    System.out.println(sc.nextInt()/sc.nextDouble());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println(sc.getCurrent()->toInteger() / sc.getCurrent()->toReal()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    Scanner sc=new Scanner(systemin);
    int N=sc.nextInt();
    long sum=0 ;
    for(int i=0 ; i<N ; i++){
      int v=sc.nextInt();
      sum+=v-i-1 ;
    }
    System.out.printf("%d\n",sum);
    sc.close();
    return false ;
  }
  PrintStream log ;
  PrintStream result=System.out ;
  BufferedReader systemin ;
  static Main instance=new Main();
  Main(){
    systemin=new BufferedReader(new InputStreamReader(System.in));
    log=new PrintStream(new OutputStream(){
      public void write(int b){
      }
    }
);
  }
  public static void main(String[] args)throws IOException {
    instance.main();
    instance.systemin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(systemin) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var v : int ; v := sc.getCurrent()->toInteger() ;
     sum := sum+(v - i - 1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%d\n", sum) ; 
    skip ; 
    return false 
 );
   attribute log : OclFile;
   attribute result : OclFile := OclFile["System.out"];
   attribute systemin : OclFile;
  static   attribute instance : Main := Main.newMain();
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     systemin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     log := OclFile.newOclFile_Write(OclFile()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     instance.main() ; 
     instance.systemin.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long total=0 ;
    for(int i=0 ; i<n ; i++){
      total+=sc.nextInt()-(i+1);
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var total : long ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     total := total+(sc.getCurrent()->toInteger() - (i + 1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextInt();
    long ans=0 ;
    for(int i=0 ; i<n ; i++)ans+=sc.nextInt();
    System.out.println(ans-n*(n+1)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toInteger() ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do (     ans := ans+(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans - n * (n + 1) / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    solve();
  }
  private static void solve(){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      System.out.println(Math.max(0,n/2));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(Set{0, n / 2}->max()) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    solve();
  }
  private static void solve(){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int max=0 ;
      for(int i=1 ; i<=n ; i++){
        max=Math.max(0,n/2);
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var max : int ; max := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     max := Set{0, n / 2}->max() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(max) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class actividad {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt(),n ;
    while(t-->0){
      n=in.nextInt();
      if(n % 2==0){
        System.out.println(n/2);
      }
      else {
        System.out.println((n-1)/2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class actividad {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var n : int ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     n := in.getCurrent()->toInteger() ; 
     if (n mod 2 = 0) then (     OclFile["System.out"].println(n / 2) ) else (     OclFile["System.out"].println((n - 1) / 2) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int k=in.nextInt();
    while(k>0){
      int n=in.nextInt();
      System.out.println((int)Math.floor(n/2));
      k--;
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := in.getCurrent()->toInteger() ;
     while (k > 0) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println((n / 2)->floor()->oclAsType(int)) ; 
     k := k - 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MaximumGCD1370A {
  private static int n=1000001 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=Integer.parseInt(sc.nextLine());
    for(int i=0 ; i<t ; i++){
      int n=Integer.parseInt(sc.nextLine());
      System.out.println(n/2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MaximumGCD1370A {
  static   attribute n : int := 1000001;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := (sc.nextLine())->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := (sc.nextLine())->toInteger() ;
     OclFile["System.out"].println(n / 2) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class test {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n % 2==0){
      System.out.println("0");
    }
    else {
      System.out.println("1");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (     OclFile["System.out"].println("0") ) else (     OclFile["System.out"].println("1") ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p130 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p130().run());
  }
  public String run(){
    int sum=0 ;
    int found=0 ;
    for(int i=7 ; found<25 ; i+=2){
      if(i % 5!=0 && ! Library.isPrime(i)&&(i-1)% findLeastDivisibleRepunit(i)==0){
        sum+=i ;
        found++;
      }
    }
    return Integer.toString(sum);
  }
  private static int findLeastDivisibleRepunit(int n){
    if(n % 2==0 || n % 5==0)return 0 ;
    if(n>Integer.MAX_VALUE/10)throw new IllegalArgumentException("Arithmetic overflow");
    int sum=1 ;
    int pow=1 ;
    int k=1 ;
    while(sum % n!=0){
      k++;
      pow=pow*10 % n ;
      sum=(sum+pow)% n ;
    }
    return k ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p130 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p130.newp130().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var found : int ; found := 0 ;
         var i : int ; i := 7 ; while found < 25 do ( (     if (i mod 5 /= 0 & not(Library.isPrime(i)) & (i - 1) mod findLeastDivisibleRepunit(i) = 0) then (     sum := sum+(i) ; 
     found := found + 1 ) else skip )  ;     i := i+(2) ) ; 
     return ((sum) + "") );
  static   operation findLeastDivisibleRepunit( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 = 0 or n mod 5 = 0) then     return 0 else skip ; 
     if (n > 2147483647 / 10) then     error IllegalArgumentException.newIllegalArgumentException("Arithmetic overflow") ; else skip ; 
    var sum : int ; sum := 1 ;
    var pow : int ; pow := 1 ;
    var k : int ; k := 1 ;
    while (sum mod n /= 0) do (     k := k + 1 ; 
     pow := pow * 10 mod n ; 
     sum := (sum + pow) mod n ) ; 
    return k 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int NumberOfSolutions(int x,int y,int z,int n){
    int ans=0 ;
    for(int i=0 ; i<=x ; i++){
      for(int j=0 ; j<=y ; j++){
        int temp=n-i-j ;
        if(temp>=0){
          temp=Math.min(temp,z);
          ans+=temp+1 ;
        }
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int x=1,y=2,z=3,n=4 ;
    System.out.println(NumberOfSolutions(x,y,z,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation NumberOfSolutions( x : int, y : int, z : int, n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i <= x do ( (         var j : int ; j := 0 ; while j <= y do ( (     var temp : int ; temp := n - i - j ;
     if (temp >= 0) then (     temp := Set{temp, z}->min() ; 
     ans := ans+(temp + 1) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 1 ;
    var y : int ; y := 2 ;
    var z : int ; z := 3 ;
    var n : int ; n := 4 ;
     OclFile["System.out"].println(NumberOfSolutions(x, y, z, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Map.Entry ;
import java.io.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    PrintWriter pw=new PrintWriter(System.out);
    int n=sc.nextInt();
    int k=sc.nextInt();
    TreeMap<Integer,Integer>map=new TreeMap<Integer,Integer>();
    while(n-->0){
      int x=sc.nextInt();
      map.put(x,map.getOrDefault(x,0)+1);
    }
    ArrayList<Integer>c=new ArrayList<Integer>();
    for(Entry<Integer,Integer>e : map.entrySet()){
      c.add(e.getValue());
    }
    if(c.size()<=k)pw.println(0);
    else {
      Collections.sort(c);
      int ans=0 ;
      for(int i=0 ; i<c.size()-k ; i++)ans+=c.get(i);
      pw.println(ans);
    }
    pw.flush();
    pw.close();
  }
  static class MyScanner {
    BufferedReader br ;
    StringTokenizer st ;
    MyScanner(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(st==null || ! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.nextInt() ;
    var k : int ; k := sc.nextInt() ;
    var map : Map(int,int) ; map := Map{} ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var x : int ; x := sc.nextInt() ;
     map := map->union(Map{x |-> (if map->keys()->contains(x) then map->at(x) else 0 endif) + 1}) ) ;  ) ;  
    var c : Sequence(int) ; c := Sequence{} ;
    for (e : map->asSet()) do ( (     c := c->including(e.getValue()) )  ) ; 
    if (c->size() <= k) then     skip else (     c := c->sort() ; 
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < c->size() - k do (     ans := ans+(c->at(i+1)) ;  ;     i := i + 1 ) ; 
     skip ) ;  
    skip ; 
    skip ; 
 );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    System.out.println(n % 2==0 ? "0" : "1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if n mod 2 = 0 then "0" else "1" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int K=sc.nextInt();
    System.out.println((K/2)*((K+1)/2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println((K / 2) * ((K + 1) / 2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    int result=(int)Math.pow(k/2,2);
    if(k % 2==1)result=(k/2)*(k/2+1);
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var result : int ; result := k / 2->pow(2)->oclAsType(int) ;
    if (k mod 2 = 1) then     result := (k / 2) * (k / 2 + 1) ; else skip ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int k=sc.nextInt();
      if(k % 2==0){
        System.out.println((int)Math.pow((k/2),2));
      }
      else {
        System.out.println((k/2)*(k/2+1));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var k : int ; k := sc.getCurrent()->toInteger() ;
     if (k mod 2 = 0) then (     OclFile["System.out"].println((k / 2)->pow(2)->oclAsType(int)) ) else (     OclFile["System.out"].println((k / 2) * (k / 2 + 1)) ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    System.out.println(n/2*(n/2+n % 2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println(n / 2 * (n / 2 + n mod 2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int K=scanner.nextInt();
    scanner.close();
    int num=0 ;
    for(int n=1 ; n<=K ; n++){
      for(int m=1 ; m<=K ; m++){
        if(n<=m){
          continue ;
        }
        if(n % 2==0){
          if(m % 2==1){
            num++;
          }
          else {
            continue ;
          }
        }
        else {
          if(m % 2==0){
            num++;
          }
          else {
            continue ;
          }
        }
      }
    }
    System.out.println(num);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var K : int ; K := scanner.getCurrent()->toInteger() ;
    skip ; 
    var num : int ; num := 0 ;
        var n : int ; n := 1 ; while n <= K do ( (         var m : int ; m := 1 ; while m <= K do ( (     if (n <= m) then (     continue ) else skip ; 
     if (n mod 2 = 0) then (     if (m mod 2 = 1) then (     num := num + 1 ) else (     continue ) ) else (     if (m mod 2 = 0) then (     num := num + 1 ) else (     continue ) ) )  ;     m := m + 1 ) )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(num) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      if(n<9){
        System.out.println("0");
      }
      else if(n==9){
        System.out.println("1");
      }
      else {
        if(n % 10==9){
          System.out.println(n/10+1);
        }
        else {
          System.out.println(n/10);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n < 9) then (     OclFile["System.out"].println("0") ) else     if (n = 9) then (     OclFile["System.out"].println("1") ) else (     if (n mod 10 = 9) then (     OclFile["System.out"].println(n / 10 + 1) ) else (     OclFile["System.out"].println(n / 10) ) ) ;  )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.*;
public class ques {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int ans=n/10 ;
      if(n % 10==9){
        ans++;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ques {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ans : int ; ans := n / 10 ;
     if (n mod 10 = 9) then (     ans := ans + 1 ) else skip ; 
     OclFile["System.out"].println(ans) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] sa=br.readLine().split(" ");
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Long.parseLong(sa[i]);
    }
    br.close();
    int[] cnt=new int[61];
    for(int i=0 ; i<n ; i++){
      int j=0 ;
      long x=a[i];
      while(x>0){
        cnt[j]+=x % 2 ;
        x/=2 ;
        j++;
      }
    }
    long ans=0 ;
    for(int i=0 ; i<cnt.length ; i++){
      long val=(long)cnt[i]*(n-cnt[i]);
      val %=1000000007 ;
      long val2=(1L<<i);
      val2 %=1000000007 ;
      val*=val2 ;
      val %=1000000007 ;
      ans+=val ;
      ans %=1000000007 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sa[i+1])->toLong() )  ;     i := i + 1 ) ; 
    skip ; 
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,61)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var j : int ; j := 0 ;
     var x : long ; x := a[i+1] ;
     while (x > 0) do (     cnt[j+1] := cnt[j+1]+(x mod 2) ; 
     x := x/(2) ; 
     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < cnt->size() do ( (     var val : long ; val := cnt[i+1]->oclAsType(long) * (n - cnt[i+1]) ;
     val := val mod 1000000007 ; 
    var val2 : long ; val2 := ((1L*(2->pow(i)))->oclAsType(long)) ;
    val2 := val2 mod 1000000007 ; 
    val := val*(val2) ; 
    val := val mod 1000000007 ; 
    ans := ans+(val) ; 
    ans := ans mod 1000000007 ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      System.out.println((int)((n+1)/10));
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(((n + 1) / 10)->oclAsType(int)) ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1285A_MezoPlayingZoma {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int len=parseInt(input.nextLine());
    String moves=input.nextLine();
    int max=0 ;
    int min=0 ;
    for(char c : moves.toCharArray()){
      if(c=='R'){
        max++;
      }
      else if(c=='L'){
        min--;
      }
    }
    System.out.println(max-min+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1285A_MezoPlayingZoma {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := parseInt(input.nextLine()) ;
    var moves : String ; moves := input.nextLine() ;
    var max : int ; max := 0 ;
    var min : int ; min := 0 ;
    for (c : moves->characters()) do ( (     if (c = 'R') then (     max := max + 1 ) else     if (c = 'L') then (     min := min - 1 ) else skip ; )  ) ; 
    OclFile["System.out"].println((max)->char2byte() - min + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().solve(new Scanner(System.in),new PrintWriter(System.out));
  }
  private void solve(Scanner in,PrintWriter out){
    int n=in.nextInt(),k=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; ++i){
      a[i]=in.nextInt();
    }
    Arrays.sort(a);
    ArrayList<Integer>segs=new ArrayList<>();
    int size=1 ;
    for(int i=1 ; i<n ; ++i){
      if(a[i]==a[i-1]){
++size ;
      }
      else {
        segs.add(size);
        size=1 ;
      }
    }
    segs.add(size);
    segs.sort(new Comparator<Integer>(){
      @ Override public int compare(Integer a,Integer b){
        return a-b ;
      }
    }
);
    int ans=0 ;
    for(int i=0 ; i<segs.size()-k ; ++i){
      ans+=segs.get(i);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve(OclFile.newOclFile_Read(OclFile["System.in"]), OclFile.newOclFile_Write(OclFile["System.out"])) );
   operation solve( in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
    var k : int ; k := in.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var segs : Sequence(int) ; segs := Sequence{} ;
    var size : int ; size := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] = a[i - 1+1]) then (     size := size + 1 ) else (     segs := segs->including(size) ; 
     size := 1 ) )  ;     i := i + 1 ) ; 
    segs := segs->including(size) ; 
    segs := segs.sort(OclComparator<int>.newOclComparator()) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < segs->size() - k do ( (     ans := ans+(segs->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    sc.next();
    System.out.println(n+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     skip ; 
     OclFile["System.out"].println(n + 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test237 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    in.next();
    System.out.println((n+1));
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test237 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    skip ; 
    OclFile["System.out"].println((n + 1)) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class dice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t,j,x ;
    t=sc.nextInt();
    for(j=1 ; j<=t ; j++){
      x=sc.nextInt();
      System.out.println((int)Math.ceil(x/7.0));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class dice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ;
    var j : int ;
    var x : int ;
     t := sc.getCurrent()->toInteger() ; 
         j := 1 ; while j <= t do ( (     x := sc.getCurrent()->toInteger() ; 
     OclFile["System.out"].println((x / 7.0)->ceil()->oclAsType(int)) )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      System.out.println(x/2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(x / 2) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        int x=sc.nextInt();
        if(x>=2 && x<=7)System.out.println(1);
        else {
          int temp=x/7 ;
          System.out.println(temp+1);
        }
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x >= 2 & x <= 7) then     OclFile["System.out"].println(1) ; else (     var temp : int ; temp := x / 7 ;
     OclFile["System.out"].println(temp + 1) ) ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DisgnToturial {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    if(n % 2==0){
      System.out.println(8+" "+(n-8));
    }
    else {
      System.out.println(9+" "+(n-9));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DisgnToturial {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (     OclFile["System.out"].println(8 + " " + (n - 8)) ) else (     OclFile["System.out"].println(9 + " " + (n - 9)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.BorderLayout ;
import static java.lang.Math.*;
import java.math.BigDecimal ;
import java.text.DecimalFormat ;
import java.util.Scanner ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.BitSet ;
import java.util.Collection ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.Deque ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Iterator ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Map ;
import java.util.Queue ;
import java.util.Set ;
import java.util.Stack ;
import java.util.TreeSet ;
import java.util.Vector ;
import java.util.concurrent.atomic.AtomicMarkableReference ;
import java.util.Scanner ;
public class NewClass1 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    if(a % 2==0)System.out.print("4"+" "+(a-4));
    else System.out.println("9"+" "+(a-9));
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
     if (a mod 2 = 0) then     OclFile["System.out"].print("4" + " " + (a - 4)) ; else     OclFile["System.out"].println("9" + " " + (a - 9)) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static final PrintStream out=System.out ;
  static final Scanner sc=new Scanner(System.in);
  static final long Mod=1000_000_007L ;
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
    System.exit(0);
  }
  void solve(){
    int N=nextInt();
    long[] A=new long[3*100000+5];
    for(int i=0 ; i<N ; i++){
      A[i]=nextLong();
    }
    long res=0 ;
    for(int k=0 ; k<60 ; k++){
      long t=1L<<k ;
      int x=0,y=0 ;
      for(int i=0 ; i<N ; i++){
        if((A[i] & t)==t)x++;
        else y++;
      }
      res+=t % Mod*x % Mod*y % Mod ;
      res %=Mod ;
    }
    out.println(res);
  }
  public int[] nextIntArray(int n){
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public long[] nextLongArray(int n){
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=nextLong();
    return a ;
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
  public String next(){
    return sc.next();
  }
  long gcd(long m,long n){
    if(m<n)return gcd(n,m);
    if(n==0)return m ;
    return gcd(n,m % n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute out : OclFile := OclFile["System.out"];
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute Mod : long := 1000_000_007L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() ; 
 OclProcess.exit(0) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : int ; N := nextInt() ;
     var A : Sequence(long) ; A := Integer.subrange(1,3 * 100000 + 5)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := nextLong() )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
        var k : int ; k := 0 ; while k < 60 do ( (     var t : long ; t := (1L*(2->pow(k)))->oclAsType(long) ;
     var x : int ; x := 0 ;
    var y : int ; y := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if ((A[i+1] & t) = t) then     x := x + 1 ; else     y := y + 1 ; )  ;     i := i + 1 ) ; 
    res := res+(t mod Mod * x mod Mod * y mod Mod) ; 
    res := res mod Mod ; 
 )  ;     k := k + 1 ) ; 
    skip ; 
 );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation next() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
   operation gcd( m : long, n : long) : long
  pre: true
  post: true
  activity: (     if (m < n) then     return gcd(n, m) else skip ; 
     if (n = 0) then     return m else skip ; 
     return gcd(n, m mod n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    for(int i=2 ; i<n ; i++){
      if(! BigInteger.valueOf(i).isProbablePrime(100)&& ! BigInteger.valueOf(n-i).isProbablePrime(100)){
        System.out.println(i+" "+(n-i));
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 2 ; while i < n do ( (     if (not((i + "")->toLong().isProbablePrime(100)) & not((n - i + "")->toLong().isProbablePrime(100))) then (     OclFile["System.out"].println(i + " " + (n - i)) ; 
     return ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class problem472A {
  public static void main(String[] args){
    new problem472A().solve();
  }
  Scanner in ;
  private void solve(){
    in=new Scanner(System.in);
    int n=in.nextInt();
    if(n % 2==0){
      System.out.println(4+" "+(n-4));
    }
    else {
      System.out.println(9+" "+(n-9));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class problem472A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     problem472A.newproblem472A().solve() );
   attribute in : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (     OclFile["System.out"].println(4 + " " + (n - 4)) ) else (     OclFile["System.out"].println(9 + " " + (n - 9)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class CodeForce {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n % 2==0){
      System.out.print(4+" ");
      System.out.println(n-4);
    }
    else {
      System.out.print(9+" ");
      System.out.println(n-9);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForce {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (     OclFile["System.out"].print(4 + " ") ; 
     OclFile["System.out"].println(n - 4) ) else (     OclFile["System.out"].print(9 + " ") ; 
     OclFile["System.out"].println(n - 9) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Reader rd=new Reader(System.in);
    int N=rd.nextInt();
    int K=rd.nextInt();
    int counter=0 ;
    int[] aNum=new int[N];
    for(int i=0 ; i<N ; i++){
      aNum[rd.nextInt()-1]++;
    }
    Arrays.sort(aNum);
    int ans=0 ;
    for(int i=0 ; i<N ; i++){
      if(K>0)K--;
      else ans+=aNum[N-i-1];
    }
    System.out.println(ans);
  }
}
class Reader {
  private BufferedReader br ;
  private StringTokenizer st ;
  public Reader(InputStream in){
    br=new BufferedReader(new InputStreamReader(in));
    st=null ;
  }
  public String nextString()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(nextString());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(nextString());
  }
  public double nextDouble()throws IOException {
    return Double.parseDouble(nextString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var rd : OclFile ; rd := OclFile(OclFile["System.in"]) ;
     var N : int ; N := rd.getCurrent()->toInteger() ;
    var K : int ; K := rd.getCurrent()->toInteger() ;
    var counter : int ; counter := 0 ;
    var aNum : Sequence(int) ; aNum := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     aNum[rd.getCurrent()->toInteger() - 1+1] := aNum[rd.getCurrent()->toInteger() - 1+1] + 1 )  ;     i := i + 1 ) ; 
    aNum := aNum->sort() ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (K > 0) then     K := K - 1 ; else     ans := ans+(aNum[N - i - 1+1]) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}
class Reader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newReader( in : OclFile) : Reader
  pre: true
  post: true
  activity:
  ( var self : Reader ;
    self := createReader();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     st := null );
   operation nextString() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextString())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextString())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextString())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Mavenproject5 {
  public static void main(String[] args){
    Scanner read=new Scanner(System.in);
    int width=read.nextInt();
    int length=read.nextInt();
    int dominos ;
    dominos=width*length/2 ;
    System.out.println(dominos);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mavenproject5 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : OclFile ; read := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var width : int ; width := read.getCurrent()->toInteger() ;
    var length : int ; length := read.getCurrent()->toInteger() ;
    var dominos : int ;
    dominos := width * length / 2 ; 
    OclFile["System.out"].println(dominos) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Domino_piling {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int x=sc.nextInt();
      int y=sc.nextInt();
      int prod=x*y ;
      if(prod % 2!=0){
        System.out.println((prod-1)/2);
      }
      else {
        System.out.println(prod/2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Domino_piling {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     var prod : int ; prod := x * y ;
     if (prod mod 2 /= 0) then (     OclFile["System.out"].println((prod - 1) / 2) ) else (     OclFile["System.out"].println(prod / 2) ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int M=sc.nextInt();
    int N=sc.nextInt();
    int s=M*N ;
    System.out.println(s/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var M : int ; M := sc.getCurrent()->toInteger() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var s : int ; s := M * N ;
    OclFile["System.out"].println(s / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    int a=sc.nextInt();
    int takes=k*a/2 ;
    System.out.println(takes);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var takes : int ; takes := k * a / 2 ;
    OclFile["System.out"].println(takes) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Codeforces {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    System.out.println((n*k)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println((n * k) / 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test140 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      int a=in.nextInt();
      if(a % 2==0){
        System.out.println(a/2);
      }
      else {
        System.out.println((a+1)/2);
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test140 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     if (a mod 2 = 0) then (     OclFile["System.out"].println(a / 2) ) else (     OclFile["System.out"].println((a + 1) / 2) ) )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    long startTime=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long div=(long)Math.pow(10,9)+7 ;
    long[] A=new long[n];
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      A[i]=sc.nextLong();
    }
    for(int i=0 ; i<60 ; i++){
      long a=0 ;
      long count1=0 ;
      for(int j=0 ; j<n ; j++){
        if((A[j]>>i & 1)==1)count1++;
      }
      a=a+count1*(n-count1);
      for(int j=0 ; j<i ; j++){
        a=(a<<1)% div ;
      }
      ans+=a ;
      ans %=div ;
    }
    System.out.println(ans);
    long endTime=System.currentTimeMillis();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var startTime : long ; startTime := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var div : long ; div := 10->pow(9)->oclAsType(long) + 7 ;
    var A : Sequence(long) ; A := Integer.subrange(1,n)->collect(0) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 60 do ( (     var a : long ; a := 0 ;
     var count1 : long ; count1 := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd((A[j+1]/(2->pow(i)))->oclAsType(long),1)) = 1) then     count1 := count1 + 1 ; else skip )  ;     j := j + 1 ) ; 
    a := a + count1 * (n - count1) ; 
        var j : int ; j := 0 ; while j < i do ( (     a := ((a*(2->pow(1)))->oclAsType(long)) mod div )  ;     j := j + 1 ) ; 
    ans := ans+(a) ; 
    ans := ans mod div ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    var endTime : long ; endTime := OclDate.getSystemTime() ;
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1371A_MagicalSticks {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int num=parseInt(input.nextLine());
      if(num % 2==0){
        System.out.println(num/2);
      }
      else {
        System.out.println(num/2+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1371A_MagicalSticks {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var num : int ; num := parseInt(input.nextLine()) ;
     if (num mod 2 = 0) then (     OclFile["System.out"].println(num / 2) ) else (     OclFile["System.out"].println(num / 2 + 1) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Exersise {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] array=new int[n];
    for(int i=0 ; i<array.length ; i++){
      array[i]=input.nextInt();
    }
    for(int i=0 ; i<array.length ; i++){
      if(array[i] % 2==0){
        System.out.println(array[i]/2);
      }
      else {
        System.out.println(array[i]/2+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Exersise {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < array->size() do ( (     array[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < array->size() do ( (     if (array[i+1] mod 2 = 0) then (     OclFile["System.out"].println(array[i+1] / 2) ) else (     OclFile["System.out"].println(array[i+1] / 2 + 1) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MagicalStick {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      if(n % 2==0){
        System.out.println(n/2);
      }
      else {
        System.out.println((n/2)+1);
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MagicalStick {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (     OclFile["System.out"].println(n / 2) ) else (     OclFile["System.out"].println((n / 2) + 1) ) ;  
     t := t - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewClass22 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int a=in.nextInt();
      if(a % 2==0){
        System.out.println(a/2);
      }
      else if(a==1){
        System.out.println(1);
      }
      else System.out.println(a/2+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass22 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := in.getCurrent()->toInteger() ;
     if (a mod 2 = 0) then (     OclFile["System.out"].println(a / 2) ) else     if (a = 1) then (     OclFile["System.out"].println(1) ) else     OclFile["System.out"].println(a / 2 + 1) ; ;  ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class LC {
  static class pair {
    int l,r ;
    public pair(int l,int r){
      this.l=l ;
      this.r=r ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<Integer>first=new ArrayList<>();
    ArrayList<Integer>sec=new ArrayList<>();
    ArrayList<Integer>moves=new ArrayList<>();
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      int temp=sc.nextInt();
      moves.add(temp);
      sum+=temp ;
      if(temp<0)sec.add(-1*temp);
      else first.add(temp);
    }
    if(sum>0){
      System.out.println("first");
      return ;
    }
    else if(sum<0){
      System.out.println("second");
      return ;
    }
    else {
      for(int i=0 ; i<first.size()&& i<sec.size(); i++){
        if(first.get(i)>sec.get(i)){
          System.out.println("first");
          return ;
        }
        if(sec.get(i)>first.get(i)){
          System.out.println("second");
          return ;
        }
      }
    }
    if(moves.get(moves.size()-1)>0)System.out.println("first");
    else System.out.println("second");
  }
}
------------------------------------------------------------
OCL File:
---------
 class LC {
  static class pair {
   attribute l : int;
   static operation newpair( l : int, r : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(l, r);
    return self );
  operation initialise( l : int, r : int) : void
  pre: true  post: true
  activity: (     self.l := l ; 
     self.r := r );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var first : Sequence(int) ; first := Sequence{} ;
    var sec : Sequence(int) ; sec := Sequence{} ;
    var moves : Sequence(int) ; moves := Sequence{} ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : int ; temp := sc.getCurrent()->toInteger() ;
     moves := moves->including(temp) ; 
     sum := sum+(temp) ; 
     if (temp < 0) then     sec := sec->including(-1 * temp) ; else     first := first->including(temp) ; )  ;     i := i + 1 ) ; 
    if (sum > 0) then (     OclFile["System.out"].println("first") ; 
     return ) else     if (sum < 0) then (     OclFile["System.out"].println("second") ; 
     return ) else (         var i : int ; i := 0 ; while i < first->size() & i < sec->size() do ( (     if (first->at(i+1) > sec->at(i+1)) then (     OclFile["System.out"].println("first") ; 
     return ) else skip ; 
     if (sec->at(i+1) > first->at(i+1)) then (     OclFile["System.out"].println("second") ; 
     return ) else skip )  ;     i := i + 1 ) ) ;  ;  
    if (moves->at(moves->size() - 1+1) > 0) then     OclFile["System.out"].println("first") else     OclFile["System.out"].println("second") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextInt();
    for(int i=1 ; i<=n ; i++){
      long t=sc.nextInt();
      System.out.println(t);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= n do ( (     var t : long ; t := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(t) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class sol {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      System.out.println(a);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class sol {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(a) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int t=scn.nextInt();
    while(t>0){
      int n=scn.nextInt();
      System.out.println(n);
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scn.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := scn.getCurrent()->toInteger() ;
     OclFile["System.out"].println(n) ; 
     t := t - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      System.out.println(n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(n) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class A_Bachgold_Problem {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int N=reader.nextInt();
    int count=0 ;
    if(N % 2==0){
      count=N/2 ;
      System.out.print(count+"\n");
      for(int i=1 ; i<=count ; i++){
        System.out.print(2+" ");
      }
    }
    else {
      if(N % 2==1){
        count=N/2 ;
        int num=count-1 ;
        System.out.print(count+"\n");
        for(int i=1 ; i<=num ; i++){
          System.out.print(2+" ");
        }
        System.out.print(3);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Bachgold_Problem {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var N : int ; N := reader.nextInt() ;
     var count : int ; count := 0 ;
     if (N mod 2 = 0) then (     count := N / 2 ; 
     OclFile["System.out"].print(count + "\n") ; 
         var i : int ; i := 1 ; while i <= count do ( (     OclFile["System.out"].print(2 + " ") )  ;     i := i + 1 ) ) else (     if (N mod 2 = 1) then (     count := N / 2 ; 
     var num : int ; num := count - 1 ;
    OclFile["System.out"].print(count + "\n") ; 
        var i : int ; i := 1 ; while i <= num do ( (     OclFile["System.out"].print(2 + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(3) ; 
 ) else skip ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static final long MOD=1_000_000_007 ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=Integer.parseInt(scanner.next());
    long[] arr=new long[N];
    for(int i=0 ; i<N ; i++){
      arr[i]=Long.parseLong(scanner.next());
    }
    scanner.close();
    long ans=0 ;
    for(int k=0 ; k<60 ; k++){
      long x0=0 ;
      long x1=0 ;
      for(int i=0 ; i<N ; i++){
        long x=(arr[i]>>k)& 1 ;
        if(x==0){
          x0++;
        }
        else {
          x1++;
        }
      }
      long p=1 ;
      for(int i=0 ; i<k ; i++){
        p*=2 ;
        p %=MOD ;
      }
      long count=(x0*x1)% MOD ;
      ans+=count*p ;
      ans %=MOD ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (scanner.getCurrent())->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := (scanner.getCurrent())->toLong() )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : long ; ans := 0 ;
        var k : int ; k := 0 ; while k < 60 do ( (     var x0 : long ; x0 := 0 ;
     var x1 : long ; x1 := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var x : long ; x := MathLib.bitwiseAnd(((arr[i+1]/(2->pow(k)))->oclAsType(long)),1) ;
     if (x = 0) then (     x0 := x0 + 1 ) else (     x1 := x1 + 1 ) )  ;     i := i + 1 ) ; 
    var p : long ; p := 1 ;
        var i : int ; i := 0 ; while i < k do ( (     p := p*(2) ; 
     p := p mod MOD )  ;     i := i + 1 ) ; 
    var count : long ; count := (x0 * x1) mod MOD ;
    ans := ans+(count * p) ; 
    ans := ans mod MOD ; 
 )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class HelloWorld {
  public static void main(String[] args){
    Scanner nn=new Scanner(System.in);
    int n ;
    n=nn.nextInt();
    System.out.println(n/2);
    while(n>3){
      System.out.print(2);
      System.out.print(' ');
      n-=2 ;
    }
    System.out.print(n);
  }
  public static void solve(){
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var nn : OclFile ; nn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    n := nn.getCurrent()->toInteger() ; 
    OclFile["System.out"].println(n / 2) ; 
    while (n > 3) do (     OclFile["System.out"].print(2) ; 
     OclFile["System.out"].print(' ') ; 
     n := n-(2) ) ; 
    OclFile["System.out"].print(n) ; 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: skip;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test138 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int x=in.nextInt();
    if(x % 2==0){
      System.out.println(x/2);
      for(int i=0 ; i<x/2 ; i++){
        System.out.print(2+" ");
      }
    }
    else {
      System.out.println(x/2);
      for(int i=0 ; i<x/2-1 ; i++){
        System.out.print(2+" ");
      }
      System.out.println(3);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test138 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := in.getCurrent()->toInteger() ;
     if (x mod 2 = 0) then (     OclFile["System.out"].println(x / 2) ; 
         var i : int ; i := 0 ; while i < x / 2 do ( (     OclFile["System.out"].print(2 + " ") )  ;     i := i + 1 ) ) else (     OclFile["System.out"].println(x / 2) ; 
         var i : int ; i := 0 ; while i < x / 2 - 1 do ( (     OclFile["System.out"].print(2 + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(3) ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    System.out.print(n/2+"\n");
    if(n % 2==0){
      for(int i=0 ; i<n/2 ; i++){
        System.out.printf("2\t");
      }
    }
    System.out.println();
    if(n % 2==1){
      for(int i=0 ; i<n/2-1 ; i++){
        System.out.printf("2\t");
      }
      System.out.println("3");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].print(n / 2 + "\n") ; 
    if (n mod 2 = 0) then (         var i : int ; i := 0 ; while i < n / 2 do ( (     OclFile["System.out"].printf("2\t") )  ;     i := i + 1 ) ) else skip ; 
    OclFile["System.out"].println() ; 
    if (n mod 2 = 1) then (         var i : int ; i := 0 ; while i < n / 2 - 1 do ( (     OclFile["System.out"].printf("2\t") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("3") ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewClass20 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    if(t % 2==0){
      System.out.println(t/2);
      for(int i=0 ; i<t/2 ; i++){
        System.out.print(2+" ");
      }
    }
    else {
      int r=t-3 ;
      System.out.println(r/2+1);
      for(int i=0 ; i<r/2 ; i++){
        System.out.print(2+" ");
      }
      System.out.print(3);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass20 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
     if (t mod 2 = 0) then (     OclFile["System.out"].println(t / 2) ; 
         var i : int ; i := 0 ; while i < t / 2 do ( (     OclFile["System.out"].print(2 + " ") )  ;     i := i + 1 ) ) else (     var r : int ; r := t - 3 ;
     OclFile["System.out"].println(r / 2 + 1) ; 
         var i : int ; i := 0 ; while i < r / 2 do ( (     OclFile["System.out"].print(2 + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(3) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextInt()){
      int W=sc.nextInt();
      System.out.println(W*32);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextInt()) do (     var W : int ; W := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(W * 32) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long firstsum=0 ;
    long secondsum=0 ;
    long arr1[]=new long[n];
    long arr2[]=new long[n];
    boolean turn=false ;
    int p=0 ;
    int q=0 ;
    for(int i=0 ; i<n ; i++){
      long temp=sc.nextLong();
      if(temp>0){
        turn=true ;
        arr1[p++]=temp ;
        firstsum+=temp ;
      }
      else {
        turn=false ;
        temp*=-1 ;
        arr2[q++]=temp ;
        secondsum+=temp ;
      }
    }
    if(firstsum>secondsum){
      System.out.println("first");
    }
    else if(firstsum<secondsum){
      System.out.println("second");
    }
    else {
      for(int i=0 ; i<Math.min(p,q); i++){
        if(arr1[i]!=arr2[i]){
          String ans=arr1[i]>arr2[i] ? "first" : "second" ;
          System.out.println(ans);
          return ;
        }
      }
      if(turn){
        System.out.println("first");
      }
      else {
        System.out.println("second");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var firstsum : long ; firstsum := 0 ;
    var secondsum : long ; secondsum := 0 ;
    var arr1 : Sequence(long) ; arr1 := Integer.subrange(1,n)->collect(0) ;
    var arr2 : Sequence(long) ; arr2 := Integer.subrange(1,n)->collect(0) ;
    var turn : boolean ; turn := false ;
    var p : int ; p := 0 ;
    var q : int ; q := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : long ; temp := sc.getCurrent()->toLong() ;
     if (temp > 0) then (     turn := true ; 
      arr1[p+1] := temp  ; p := p + 1 ; 
     firstsum := firstsum+(temp) ) else (     turn := false ; 
     temp := temp*(-1) ; 
      arr2[q+1] := temp  ; q := q + 1 ; 
     secondsum := secondsum+(temp) ) )  ;     i := i + 1 ) ; 
    if (firstsum > secondsum) then (     OclFile["System.out"].println("first") ) else     if (firstsum < secondsum) then (     OclFile["System.out"].println("second") ) else (         var i : int ; i := 0 ; while i < Set{p, q}->min() do ( (     if (arr1[i+1] /= arr2[i+1]) then (     var ans : String ; ans := if arr1[i+1] > arr2[i+1] then "first" else "second" endif ;
     OclFile["System.out"].println(ans) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     if (turn) then (     OclFile["System.out"].println("first") ) else (     OclFile["System.out"].println("second") ) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner sc=new Scanner(System.in);
    long num=sc.nextInt();
    System.out.println(num*32);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : long ; num := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(num * 32) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    out.println(sc.nextInt()*32);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     out.println(sc.getCurrent()->toInteger() * 32) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    System.out.println(32*in.nextInt());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println(32 * in.getCurrent()->toInteger()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Random ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    System.out.println(sc.nextInt()*32);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println(sc.getCurrent()->toInteger() * 32) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  final int MOD=1000000007 ;
  final int MAX=Integer.MAX_VALUE ;
  final long LMAX=Long.MAX_VALUE ;
  int LEN=0 ;
  void doIt(){
    int n=sc.nextInt();
    long a[]=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
    }
    long ans=0 ;
    for(int i=0 ; i<=60 ; i++){
      long zero=0,one=0 ;
      for(int j=0 ; j<n ; j++){
        if((a[j]>>i & 1)==1)one++;
        else zero++;
      }
      long num=zero*one %(long)MOD ;
      for(int j=0 ; j<i ; j++){
        num=(num<<1)%(long)MOD ;
      }
      ans=(ans+num)%(long)MOD ;
    }
    System.out.println(ans %(long)MOD);
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute MOD : int := 1000000007;
   attribute MAX : int := 2147483647;
   attribute LMAX : long := "9223372036854775807"->toLong();
   attribute LEN : int := 0;
   operation doIt() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i <= 60 do ( (     var zero : long ; zero := 0 ;
    var one : long ; one := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd((a[j+1]/(2->pow(i)))->oclAsType(long),1)) = 1) then     one := one + 1 ; else     zero := zero + 1 ; )  ;     j := j + 1 ) ; 
    var num : long ; num := zero * one mod MOD->oclAsType(long) ;
        var j : int ; j := 0 ; while j < i do ( (     num := ((num*(2->pow(1)))->oclAsType(long)) mod MOD->oclAsType(long) )  ;     j := j + 1 ) ; 
    ans := (ans + num) mod MOD->oclAsType(long) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans mod MOD->oclAsType(long)) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(sc.nextInt()% 2==0){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (sc.getCurrent()->toInteger() mod 2 = 0) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    long n=s.nextLong();
    long m=s.nextLong();
    long ans=0 ;
    ans=(m-1)*n ;
    if(m==1){
      ans=n-1 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := s.getCurrent()->toLong() ;
    var m : long ; m := s.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
    ans := (m - 1) * n ; 
    if (m = 1) then (     ans := n - 1 ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Dominoes {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long m=sc.nextLong();
    if(m==1){
      System.out.println(n-1);
    }
    else {
      System.out.println((m-1)*n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Dominoes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
     var m : long ; m := sc.getCurrent()->toLong() ;
     if (m = 1) then (     OclFile["System.out"].println(n - 1) ) else (     OclFile["System.out"].println((m - 1) * n) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextInt();
    long m=sc.nextInt();
    if(m==1 && n==1)System.out.print(0);
    else if(m==1)System.out.print(n-1);
    else if(n==1)System.out.print((m-1));
    else System.out.print((m-1)*n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toInteger() ;
     var m : long ; m := sc.getCurrent()->toInteger() ;
     if (m = 1 & n = 1) then     OclFile["System.out"].print(0) ; else     if (m = 1) then     OclFile["System.out"].print(n - 1) else     if (n = 1) then     OclFile["System.out"].print((m - 1)) else     OclFile["System.out"].print((m - 1) * n) ; ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long n=in.nextInt(),m=in.nextInt();
    System.out.println(m==1 ? n-1 :(m-1)*n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toInteger() ;
    var m : long ; m := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if m = 1 then n - 1 else (m - 1) * n endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DominoesICPC {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    long vertical=input.nextInt();
    long horizon=input.nextInt();
    if(horizon==1){
      System.out.println(vertical-1);
    }
    else {
      System.out.println(vertical*(horizon-1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DominoesICPC {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var vertical : long ; vertical := input.getCurrent()->toInteger() ;
     var horizon : long ; horizon := input.getCurrent()->toInteger() ;
     if (horizon = 1) then (     OclFile["System.out"].println(vertical - 1) ) else (     OclFile["System.out"].println(vertical * (horizon - 1)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countOddSquares(int n,int m){
    return(int)Math.pow(m,0.5)-(int)Math.pow(n-1,0.5);
  }
  public static void main(String[] args){
    int n=5,m=100 ;
    System.out.println("Count is "+((m-n+1)-countOddSquares(n,m)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countOddSquares( n : int, m : int) : int
  pre: true
  post: true
  activity: (     return m->pow(0.5)->oclAsType(int) - n - 1->pow(0.5)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var m : int ; m := 100 ;
     OclFile["System.out"].println("Count is " + ((m - n + 1) - countOddSquares(n, m))) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int tf=0 ;
    int f=0 ;
    int h=0 ;
    for(int i=0 ; i<n ; i++){
      int v=sc.nextInt();
      if(v==25){
        tf++;
      }
      else if(v==50){
        if(tf>=1){
          f++;
          tf--;
        }
        else {
          System.out.println("NO");
          return ;
        }
      }
      else {
        if(f>=1 && tf>=1){
          tf--;
          f--;
          h++;
        }
        else if(tf>=3){
          tf-=3 ;
          h++;
        }
        else {
          System.out.println("NO");
          return ;
        }
      }
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var tf : int ; tf := 0 ;
    var f : int ; f := 0 ;
    var h : int ; h := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := sc.getCurrent()->toInteger() ;
     if (v = 25) then (     tf := tf + 1 ) else     if (v = 50) then (     if (tf >= 1) then (     f := f + 1 ; 
     tf := tf - 1 ) else (     OclFile["System.out"].println("NO") ; 
     return ) ) else (     if (f >= 1 & tf >= 1) then (     tf := tf - 1 ; 
     f := f - 1 ; 
     h := h + 1 ) else     if (tf >= 3) then (     tf := tf-(3) ; 
     h := h + 1 ) else (     OclFile["System.out"].println("NO") ; 
     return ) ;  ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Acinemafans {
  public static void main(String[] args)throws IOException {
    BufferedReader buf=new BufferedReader(new InputStreamReader(System.in));
    int l=Integer.parseInt(buf.readLine());
    String[] inp=buf.readLine().split(" ");
    int[] arr=new int[inp.length];
    for(int i=0 ; i<inp.length ; i++){
      arr[i]=Integer.parseInt(inp[i]);
    }
    int c25=0,c50=0 ;
    for(int i : arr){
      if(i==25){
        c25++;
      }
      else if(i==50){
        if(c25==0){
          System.out.println("NO");
          return ;
        }
        c50++;
        c25--;
      }
      else {
        if(c25==0 || c50==0 && c25<3){
          System.out.println("NO");
          return ;
        }
        c25--;
        if(c50!=0)c50--;
        else c25-=2 ;
      }
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Acinemafans {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var buf : OclFile ; buf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var l : int ; l := (buf.readLine())->toInteger() ;
    var inp : Sequence(String) ; inp := buf.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,inp->size())->collect(0) ;
        var i : int ; i := 0 ; while i < inp->size() do ( (     arr[i+1] := (inp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var c25 : int ; c25 := 0 ;
    var c50 : int ; c50 := 0 ;
    for (i : arr) do ( (     if (i = 25) then (     c25 := c25 + 1 ) else     if (i = 50) then (     if (c25 = 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
     c50 := c50 + 1 ; 
     c25 := c25 - 1 ) else (     if (c25 = 0 or c50 = 0 & c25 < 3) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
     c25 := c25 - 1 ; 
     if (c50 /= 0) then     c50 := c50 - 1 ; else     c25 := c25-(2) ; ) ;  )  ) ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int t25=0,t50=0 ;
    boolean flag=true ;
    for(int i=0 ; i<n ; i++){
      int v=in.nextInt();
      if(v==25){
        t25++;
      }
      else if(v==50){
        t50++;
        t25--;
      }
      else if(v==75){
        if(t50>=1){
          t50--;
        }
        else {
          t25-=2 ;
        }
      }
      else {
        if(t50>=1){
          t50--;
          t25--;
        }
        else {
          t25-=3 ;
        }
      }
      if(t25<0 || t50<0){
        flag=false ;
      }
    }
    if(flag){
      pw.println("YES");
    }
    else {
      pw.println("NO");
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var t25 : int ; t25 := 0 ;
    var t50 : int ; t50 := 0 ;
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := in.getCurrent()->toInteger() ;
     if (v = 25) then (     t25 := t25 + 1 ) else     if (v = 50) then (     t50 := t50 + 1 ; 
     t25 := t25 - 1 ) else     if (v = 75) then (     if (t50 >= 1) then (     t50 := t50 - 1 ) else (     t25 := t25-(2) ) ) else (     if (t50 >= 1) then (     t50 := t50 - 1 ; 
     t25 := t25 - 1 ) else (     t25 := t25-(3) ) ) ;  ;  ;  
     if (t25 < 0 or t50 < 0) then (     flag := false ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Solution {
  static int res=0 ;
  static int checkRecursive(int num,int x,int k,int n){
    if(x==0)res++;
    int r=(int)Math.floor(Math.pow(num,1.0/n));
    for(int i=k+1 ; i<=r ; i++){
      int a=x-(int)Math.pow(i,n);
      if(a>=0)checkRecursive(num,x-(int)Math.pow(i,n),i,n);
    }
    return res ;
  }
  static int check(int x,int n){
    return checkRecursive(x,x,0,n);
  }
  public static void main(String[] args){
    System.out.println(check(10,2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute res : int := 0;
  static   operation checkRecursive( num : int, x : int, k : int, n : int) : int
  pre: true
  post: true
  activity: (     if (x = 0) then     res := res + 1 ; else skip ; 
     var r : int ; r := (num->pow(1.0 / n))->floor()->oclAsType(int) ;
         var i : int ; i := k + 1 ; while i <= r do ( (     var a : int ; a := x - i->pow(n)->oclAsType(int) ;
     if (a >= 0) then     execute checkRecursive(num, x - i->pow(n)->oclAsType(int), i, n) ; else skip )  ;     i := i + 1 ) ; 
     return res );
  static   operation check( x : int, n : int) : int
  pre: true
  post: true
  activity: (     return checkRecursive(x, x, 0, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(check(10, 2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CinemaLine {
  int number ;
  public CinemaLine(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  static int number25=0 ;
  static int number50=0 ;
  boolean b=true ;
  public void input(int num){
    if(num==25){
      number25++;
    }
    else if(num==50 && number25>=1){
      number25--;
      number50++;
    }
    else if(num==100 &&((number25>=1 && number50>=1)|| number25>=3)){
      if(number50>=1){
        number25--;
        number50--;
      }
      else {
        number25-=3 ;
      }
    }
    else {
      b=false ;
    }
  }
  public void print(){
    if(b==true){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    CinemaLine instance=new CinemaLine(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      int n=input.nextInt();
      instance.input(n);
    }
    instance.print();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CinemaLine {
   attribute number : int;
   static operation newCinemaLine( number : int) : CinemaLine
  pre: true
  post: true
  activity:
  ( var self : CinemaLine ;
    self := createCinemaLine();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
  static   attribute number25 : int := 0;
  static   attribute number50 : int := 0;
   attribute b : boolean := true;
   operation input( num : int) : void
  pre: true
  post: true
  activity: (     if (num = 25) then (     number25 := number25 + 1 ) else     if (num = 50 & number25 >= 1) then (     number25 := number25 - 1 ; 
     number50 := number50 + 1 ) else     if (num = 100 & ((number25 >= 1 & number50 >= 1) or number25 >= 3)) then (     if (number50 >= 1) then (     number25 := number25 - 1 ; 
     number50 := number50 - 1 ) else (     number25 := number25-(3) ) ) else (     b := false ) ;  ;  );
   operation print() : void
  pre: true
  post: true
  activity: (     if (b = true) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
    var instance : CinemaLine ; instance := CinemaLine.newCinemaLine(number) ;
        var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     instance.input(n) )  ;     i := i + 1 ) ; 
    instance.print() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isFrequencyEqual(String str,int len){
    if(len % 2==1){
      return false ;
    }
    int i,freq[]=new int[26];
    for(i=0 ; i<len ; i++){
      freq[str.charAt(i)-'a']++;
    }
    for(i=0 ; i<26 ; i++){
      if(freq[i]==len/2){
        return true ;
      }
    }
    return false ;
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    int len=str.length();
    if(isFrequencyEqual(str,len)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isFrequencyEqual( str : String, len : int) : boolean
  pre: true
  post: true
  activity: (     if (len mod 2 = 1) then (     return false ) else skip ; 
     var i : int ;
    var freq : Sequence(void) ; freq := Integer.subrange(1,26)->collect(0) ;
        i := 0 ; while i < len do ( (     freq[str->at(i+1) - ('a')->char2byte()+1] := freq[str->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
        i := 0 ; while i < 26 do ( (     if (freq[i+1] = len / 2) then (     return true ) else skip )  ;     i := i + 1 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var len : int ; len := str->size() ;
     if (isFrequencyEqual(str, len)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class jjj {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0){
      long n=sc.nextLong();
      if(n<=2)System.out.println(0);
      else {
        System.out.println(n % 2==0 ? n/2-1 : n/2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class jjj {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     var n : long ; n := sc.getCurrent()->toLong() ;
     if (n <= 2) then     OclFile["System.out"].println(0) ; else (     OclFile["System.out"].println(if n mod 2 = 0 then n / 2 - 1 else n / 2 endif) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n-->0){
      int fw=sc.nextInt();
      if(fw<3)System.out.println(0);
      else if(fw % 2==0){
        System.out.println(fw/2-1);
      }
      else if(fw % 2!=0){
        System.out.println((fw+1)/2-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var fw : int ; fw := sc.getCurrent()->toInteger() ;
     if (fw < 3) then     OclFile["System.out"].println(0) ; else     if (fw mod 2 = 0) then (     OclFile["System.out"].println(fw / 2 - 1) ) else     if (fw mod 2 /= 0) then (     OclFile["System.out"].println((fw + 1) / 2 - 1) ) else skip ; ;  ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MathsSecondAttempt {
  public static void main(String[] args){
    CandiesandTwoSisters();
  }
  public static void CandiesandTwoSisters(){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=scan.nextInt();
      System.out.println((n-1)/2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MathsSecondAttempt {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute CandiesandTwoSisters() );
  static   operation CandiesandTwoSisters() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     OclFile["System.out"].println((n - 1) / 2) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CandyAndTwoSister {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      int Count=0 ;
      if(n==1 || n==2){
        Count=0 ;
      }
      else {
        Count=(n-1)/2 ;
      }
      System.out.println(Count);
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CandyAndTwoSister {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var Count : int ; Count := 0 ;
    if (n = 1 or n = 2) then (     Count := 0 ) else (     Count := (n - 1) / 2 ) ;  
    OclFile["System.out"].println(Count) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A1335 {
  static FastScanner sc=new FastScanner();
  public static void main(String[] args){
    int tt=sc.nextInt();
    while(tt-->0)solve();
  }
  public static void solve(){
    int n=sc.nextInt();
    if(n % 2==0){
      System.out.println((n/2)-1);
    }
    else {
      System.out.println(n/2);
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1335 {
  static   attribute sc : FastScanner := FastScanner.newFastScanner();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var tt : int ; tt := sc.nextInt() ;
         while (tt > 0) do (        tt := tt - 1 ;     skip ;     execute solve() ; ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     if (n mod 2 = 0) then (     OclFile["System.out"].println((n / 2) - 1) ) else (     OclFile["System.out"].println(n / 2) ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countSubArrayProductLessThanK(ArrayList<Integer>a,long k){
    int n=a.size();
    long p=1 ;
    int res=0 ;
    for(int start=0,end=0 ; end<n ; end++){
      p*=a.get(end);
      while(start<end && p>=k)p/=a.get(start++);
      if(p<k){
        int len=end-start+1 ;
        res+=len ;
      }
    }
    return res ;
  }
  public static void main(String[] args){
    ArrayList<Integer>al=new ArrayList<Integer>();
    al.add(1);
    al.add(2);
    al.add(3);
    al.add(4);
    System.out.println(countSubArrayProductLessThanK(al,10));
    ArrayList<Integer>al1=new ArrayList<Integer>();
    al1.add(1);
    al1.add(9);
    al1.add(2);
    al1.add(8);
    al1.add(6);
    al1.add(4);
    al1.add(3);
    System.out.println(countSubArrayProductLessThanK(al1,100));
    ArrayList<Integer>al2=new ArrayList<Integer>();
    al2.add(5);
    al2.add(3);
    al2.add(2);
    System.out.println(countSubArrayProductLessThanK(al2,16));
    ArrayList<Integer>al3=new ArrayList<Integer>();
    al3.add(100);
    al3.add(200);
    System.out.println(countSubArrayProductLessThanK(al3,100));
    ArrayList<Integer>al4=new ArrayList<Integer>();
    al4.add(100);
    al4.add(200);
    System.out.println(countSubArrayProductLessThanK(al3,101));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSubArrayProductLessThanK( a : Sequence(int), k : long) : int
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() ;
     var p : long ; p := 1 ;
    var res : int ; res := 0 ;
        var start : int ; start := 0 ;
    var end : int ; end := 0 ; while end < n do ( (     p := p*(a->at(end+1)) ; 
     while (start < end & p >= k) do     p := p/(a->at(start+1)) ; ; 
     if (p < k) then (     var len : int ; len := end - start + 1 ;
     res := res+(len) ) else skip )  ;     end := end + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var al : Sequence(int) ; al := Sequence{} ;
     al := al->including(1) ; 
    al := al->including(2) ; 
    al := al->including(3) ; 
    al := al->including(4) ; 
    OclFile["System.out"].println(countSubArrayProductLessThanK(al, 10)) ; 
    var al1 : Sequence(int) ; al1 := Sequence{} ;
    al1 := al1->including(1) ; 
    al1 := al1->including(9) ; 
    al1 := al1->including(2) ; 
    al1 := al1->including(8) ; 
    al1 := al1->including(6) ; 
    al1 := al1->including(4) ; 
    al1 := al1->including(3) ; 
    OclFile["System.out"].println(countSubArrayProductLessThanK(al1, 100)) ; 
    var al2 : Sequence(int) ; al2 := Sequence{} ;
    al2 := al2->including(5) ; 
    al2 := al2->including(3) ; 
    al2 := al2->including(2) ; 
    OclFile["System.out"].println(countSubArrayProductLessThanK(al2, 16)) ; 
    var al3 : Sequence(int) ; al3 := Sequence{} ;
    al3 := al3->including(100) ; 
    al3 := al3->including(200) ; 
    OclFile["System.out"].println(countSubArrayProductLessThanK(al3, 100)) ; 
    var al4 : Sequence(int) ; al4 := Sequence{} ;
    al4 := al4->including(100) ; 
    al4 := al4->including(200) ; 
    OclFile["System.out"].println(countSubArrayProductLessThanK(al3, 101)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class caps_lock {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.nextLine();
    int count=0 ;
    int k=0 ;
    char temp=str.charAt(0);
    String str1=Character.toString(temp);
    str1=str1.toLowerCase();
    if(str1.charAt(0)!=str.charAt(0)){
      k=1 ;
      count=1 ;
    }
    for(int i=1 ; i<str.length(); i++){
      char temp1=str.charAt(i);
      String str12=Character.toString(temp1);
      str12=str12.toLowerCase();
      if(str12.charAt(0)!=str.charAt(i)){
        count++;
      }
    }
    if(count==str.length()){
      System.out.println(str.substring(0,str.length()).toLowerCase());
    }
    else if(k==0 && count==str.length()-1){
      System.out.println(str.substring(0,1).toUpperCase()+str.substring(1,str.length()).toLowerCase());
    }
    else System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class caps_lock {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.nextLine() ;
    var count : int ; count := 0 ;
    var k : int ; k := 0 ;
    var temp : String ; temp := str->at(0+1) ;
    var str1 : String ; str1 := (temp + "") ;
    str1 := str1->toLowerCase() ; 
    if (str1->at(0+1) /= str->at(0+1)) then (     k := 1 ; 
     count := 1 ) else skip ; 
        var i : int ; i := 1 ; while i < str->size() do ( (     var temp1 : String ; temp1 := str->at(i+1) ;
     var str12 : String ; str12 := (temp1 + "") ;
     str12 := str12->toLowerCase() ; 
     if (str12->at(0+1) /= str->at(i+1)) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (count = str->size()) then (     OclFile["System.out"].println(str.subrange(0+1,str->size())->toLowerCase()) ) else     if (k = 0 & count = str->size() - 1) then (     OclFile["System.out"].println(str.subrange(0+1,1)->toUpperCase() + str.subrange(1+1,str->size())->toLowerCase()) ) else     OclFile["System.out"].println(str) ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Mridul8 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    String str1=str.substring(1);
    String str2=str1.toUpperCase();
    if(str1.equals(str2)){
      if(str.substring(0,1).equals(str.substring(0,1).toLowerCase())){
        String str4="" ;
        str4=str.substring(0,1).toUpperCase()+str.substring(1).toLowerCase();
        System.out.println(str4);
      }
      else {
        System.out.println(str.toLowerCase());
      }
    }
    else {
      System.out.println(str);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mridul8 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var str1 : String ; str1 := str.subrange(1+1,1) ;
    var str2 : String ; str2 := str1->toUpperCase() ;
    if (str1 = str2) then (     if (str.subrange(0+1,1) = str.subrange(0+1,1)->toLowerCase()) then (     var str4 : String ; str4 := "" ;
     str4 := str.subrange(0+1,1)->toUpperCase() + str.subrange(1+1,1)->toLowerCase() ; 
     OclFile["System.out"].println(str4) ) else (     OclFile["System.out"].println(str->toLowerCase()) ) ) else (     OclFile["System.out"].println(str) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static String oper ;
  public static void main(String args[])throws Exception {
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    char[] chs=s.toCharArray();
    String oper=dfs(chs,1,chs[0]-'0',"");
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<chs.length ; i++){
      sb.append(chs[i]);
      if(i<chs.length-1)sb.append(oper.charAt(i));
    }
    System.out.println(sb.toString()+"=7");
  }
  private static String dfs(char[] chs,int idx,int cur,String opers){
    if(idx==chs.length){
      if(cur==7)return opers ;
      else return null ;
    }
    String plus=dfs(chs,idx+1,cur+(chs[idx]-'0'),opers+"+");
    if(plus!=null)return plus ;
    String nega=dfs(chs,idx+1,cur-(chs[idx]-'0'),opers+"-");
    if(nega!=null)return nega ;
    return null ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute oper : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var chs : Sequence(String) ; chs := s->characters() ;
    var oper : String ; oper := dfs(chs, 1, chs[0+1] - ('0')->char2byte(), "") ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < chs->size() do ( (     sb := sb + StringLib.newString(chs[i+1]) ; 
     if (i < chs->size() - 1) then     sb := sb + StringLib.newString(oper->at(i+1)) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"" + "=7") ; 
 );
  static   operation dfs( chs : Sequence(String), idx : int, cur : int, opers : String) : String
  pre: true
  post: true
  activity: (     if (idx = chs->size()) then (     if (cur = 7) then     return opers else     return null ) else skip ; 
     var plus : String ; plus := dfs(chs, idx + 1, cur + (chs[idx+1] - ('0')->char2byte()), opers + "+") ;
    if (plus /= null) then     return plus else skip ; 
    var nega : String ; nega := dfs(chs, idx + 1, cur - (chs[idx+1] - ('0')->char2byte()), opers + "-") ;
    if (nega /= null) then     return nega else skip ; 
    return null 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Application {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String word=scan.nextLine();
    String up=word.toUpperCase();
    String fall=word.substring(0,1).toLowerCase()+word.substring(1).toUpperCase();
    if(word.equals(fall)){
      System.out.println(word.substring(0,1).toUpperCase()+word.substring(1).toLowerCase());
    }
    else if(word.equals(up)){
      System.out.println(word.toLowerCase());
    }
    else {
      System.out.println(word);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Application {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var word : String ; word := scan.nextLine() ;
    var up : String ; up := word->toUpperCase() ;
    var fall : String ; fall := word.subrange(0+1,1)->toLowerCase() + word.subrange(1+1,1)->toUpperCase() ;
    if (word = fall) then (     OclFile["System.out"].println(word.subrange(0+1,1)->toUpperCase() + word.subrange(1+1,1)->toLowerCase()) ) else     if (word = up) then (     OclFile["System.out"].println(word->toLowerCase()) ) else (     OclFile["System.out"].println(word) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Capslock {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String assel=sc.next();
    String lower=assel.toLowerCase();
    boolean all=false ;
    boolean allexceptfirst=false ;
    if(assel.length()==1){
      if(assel.charAt(0)==lower.charAt(0))allexceptfirst=true ;
      else all=true ;
    }
    else if(lower.charAt(0)-assel.charAt(0)==32){
      for(int i=1 ; i<assel.length(); i++){
        if(lower.charAt(i)-assel.charAt(i)==32){
          all=true ;
        }
        else {
          all=false ;
          break ;
        }
      }
    }
    else if(lower.charAt(0)-assel.charAt(0)==0){
      for(int i=1 ; i<assel.length(); i++){
        if(lower.charAt(i)-assel.charAt(i)==32){
          allexceptfirst=true ;
        }
        else {
          allexceptfirst=false ;
          break ;
        }
      }
    }
    if(all)System.out.println(lower);
    else if(allexceptfirst){
      System.out.println((char)(lower.charAt(0)-32)+lower.substring(1,lower.length()));
    }
    else System.out.println(assel);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Capslock {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var assel : String ; assel := sc.getCurrent() ;
    var lower : String ; lower := assel->toLowerCase() ;
    var all : boolean ; all := false ;
    var allexceptfirst : boolean ; allexceptfirst := false ;
    if (assel->size() = 1) then (     if (assel->at(0+1) = lower->at(0+1)) then     allexceptfirst := true ; else     all := true ; ) else     if (lower->at(0+1) - assel->at(0+1) = 32) then (         var i : int ; i := 1 ; while i < assel->size() do ( (     if (lower->at(i+1) - assel->at(i+1) = 32) then (     all := true ) else (     all := false ; 
     break ) )  ;     i := i + 1 ) ) else     if (lower->at(0+1) - assel->at(0+1) = 0) then (         var i : int ; i := 1 ; while i < assel->size() do ( (     if (lower->at(i+1) - assel->at(i+1) = 32) then (     allexceptfirst := true ) else (     allexceptfirst := false ; 
     break ) )  ;     i := i + 1 ) ) else skip ; ;  ;  
    if (all) then     OclFile["System.out"].println(lower) else     if (allexceptfirst) then (     OclFile["System.out"].println((lower->at(0+1) - 32)->oclAsType(String) + lower.subrange(1+1,lower->size())) ) else     OclFile["System.out"].println(assel) ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Code_131A {
  public static String changeCase(String str){
    char[] chrArr=str.toCharArray();
    for(int i=0 ; i<chrArr.length ; i++){
      if(chrArr[i]>='a' && chrArr[i]<='z')chrArr[i]-=32 ;
      else if(chrArr[i]>='A' && chrArr[i]<='Z')chrArr[i]+=32 ;
    }
    return String.valueOf(chrArr);
  }
  public static boolean isCapital(String str){
    char[] chrArr=str.toCharArray();
    for(int i=1 ; i<chrArr.length ; i++){
      if(chrArr[i]>='a' && chrArr[i]<='z')return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    if(isCapital(str))str=changeCase(str);
    System.out.println(str);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code_131A {
  static   operation changeCase( str : String) : String
  pre: true
  post: true
  activity: (     var chrArr : Sequence(String) ; chrArr := str->characters() ;
         var i : int ; i := 0 ; while i < chrArr->size() do ( (     if (chrArr[i+1] >= 'a' & chrArr[i+1] <= 'z') then     chrArr[i+1] := chrArr[i+1]-(32) ; else     if (chrArr[i+1] >= 'A' & chrArr[i+1] <= 'Z') then     chrArr[i+1] := chrArr[i+1]+(32) ; else skip ; )  ;     i := i + 1 ) ; 
     return (chrArr)->sum()  );
  static   operation isCapital( str : String) : boolean
  pre: true
  post: true
  activity: (     var chrArr : Sequence(String) ; chrArr := str->characters() ;
         var i : int ; i := 1 ; while i < chrArr->size() do ( (     if (chrArr[i+1] >= 'a' & chrArr[i+1] <= 'z') then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    if (isCapital(str)) then     str := changeCase(str) ; else skip ; 
    OclFile["System.out"].println(str) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class App {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    HashSet<Integer>arr=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      arr.add(in.nextInt());
    }
    if(arr.size()<3){
      System.out.println("YES");
    }
    else if(arr.size()>3){
      System.out.println("NO");
    }
    else {
      int[] s=new int[3];
      int i=0 ;
      for(int index : arr){
        s[i]=index ;
        i++;
      }
      Arrays.sort(s);
      if(s[1]-s[0]==s[2]-s[1]){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Set(int) ; arr := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr := arr->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    if (arr->size() < 3) then (     OclFile["System.out"].println("YES") ) else     if (arr->size() > 3) then (     OclFile["System.out"].println("NO") ) else (     var s : Sequence(int) ; s := Integer.subrange(1,3)->collect(0) ;
     var i : int ; i := 0 ;
    for (index : arr) do ( (     s[i+1] := index ; 
     i := i + 1 )  ) ; 
    s := s->sort() ; 
    if (s[1+1] - s[0+1] = s[2+1] - s[1+1]) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class FilyaAndHomework {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    ArrayList<Long>ls=new ArrayList<>();
    for(int i=0 ; i<n ; i++)ls.add(in.nextLong());
    if(solve(ls))pw.println("YES");
    else pw.println("NO");
    pw.close();
  }
  static boolean solve(ArrayList<Long>ls){
    Collections.sort(ls);
    long min=Collections.min(ls);
    long max=Collections.max(ls);
    if(max==min)return true ;
    long midde=-1 ;
    for(long v : ls)if(min<v && max>v){
      midde=v ;
      break ;
    }
    if(midde==-1)return true ;
    long abs=max-midde ;
    for(long v : ls){
      if(v==midde)continue ;
      long temp=Math.abs(v-midde);
      if(temp!=abs)return false ;
    }
    return true ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class FilyaAndHomework {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var ls : Sequence(long) ; ls := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     ls := ls->including(in.getCurrent()->toLong()) ;  ;     i := i + 1 ) ; 
    if (solve(ls)) then     skip else     skip ; ;  
    skip ; 
 );
  static   operation solve( ls : Sequence(long)) : boolean
  pre: true
  post: true
  activity: (     ls := ls->sort() ; 
     var min : long ; min := .min(ls) ;
    var max : long ; max := .max(ls) ;
    if (max = min) then     return true else skip ; 
    var midde : long ; midde := -1 ;
    for (v : ls) do (     if (min < v & max > v) then (     midde := v ; 
     break ) else skip ;  ) ; 
    if (midde = -1) then     return true else skip ; 
    var abs : long ; abs := max - midde ;
    for (v : ls) do ( (     if (v = midde) then     continue else skip ; 
     var temp : long ; temp := if v - midde < 0 then -(v - midde) else v - midde endif ;
     if (temp /= abs) then     return false else skip )  ) ; 
    return true 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int[] arr=new int[n];
      Set<Integer>set=new HashSet<>();
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
        set.add(arr[i]);
      }
      List<Integer>list=new ArrayList<Integer>(set);
      Collections.sort(list);
      if(set.size()==1 || set.size()==2)System.out.println("YES");
      else if(set.size()==3){
        if(2*list.get(1)==list.get(0)+list.get(2))System.out.println("YES");
        else System.out.println("NO");
      }
      else System.out.println("NO");
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     set := set->including(arr[i+1]) )  ;     i := i + 1 ) ; 
    var list : Sequence(int) ; list := Sequence{}->union(set) ;
    list := list->sort() ; 
    if (set->size() = 1 or set->size() = 2) then     OclFile["System.out"].println("YES") else     if (set->size() = 3) then (     if (2 * list->at(1+1) = list->at(0+1) + list->at(2+1)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) else     OclFile["System.out"].println("NO") ; ;  ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void rotateMatrix(int N,int mat[][]){
    for(int x=0 ; x<N/2 ; x++){
      for(int y=x ; y<N-x-1 ; y++){
        int temp=mat[x][y];
        mat[x][y]=mat[y][N-1-x];
        mat[y][N-1-x]=mat[N-1-x][N-1-y];
        mat[N-1-x][N-1-y]=mat[N-1-y][x];
        mat[N-1-y][x]=temp ;
      }
    }
  }
  static void displayMatrix(int N,int mat[][]){
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++)System.out.print(" "+mat[i][j]);
      System.out.print("\n");
    }
    System.out.print("\n");
  }
  public static void main(String[] args){
    int N=4 ;
    int mat[][]={
      {
        1,2,3,4 },{
          5,6,7,8 },{
            9,10,11,12 },{
              13,14,15,16 }
            };
            rotateMatrix(N,mat);
            displayMatrix(N,mat);
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation rotateMatrix( N : int, mat : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var x : int ; x := 0 ; while x < N / 2 do ( (         var y : int ; y := x ; while y < N - x - 1 do ( (     var temp : int ; temp := mat[x+1][y+1] ;
     mat[x+1][y+1] := mat[y+1][N - 1 - x+1] ; 
    mat[y+1][N - 1 - x+1] := mat[N - 1 - x+1][N - 1 - y+1] ; 
    mat[N - 1 - x+1][N - 1 - y+1] := mat[N - 1 - y+1][x+1] ; 
    mat[N - 1 - y+1][x+1] := temp ; 
 )  ;     y := y + 1 ) )  ;     x := x + 1 ) );
  static   operation displayMatrix( N : int, mat : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do (     OclFile["System.out"].print(" " + mat[i+1][j+1]) ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,2,3,4},Sequence{5,6,7,8},Sequence{9,10,11,12},Sequence{13,14,15,16}} ;
     execute rotateMatrix(N, mat) ; 
     execute displayMatrix(N, mat) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int RODS=3 ;
  static int N=3 ;
  static int[][][] dp=new int[N+1][RODS+1][RODS+1];
  static void initialize(){
    for(int i=0 ; i<=N ; i+=1){
      for(int j=1 ; j<=RODS ; j++){
        for(int k=1 ; k<=RODS ; k+=1){
          dp[i][j][k]=Integer.MAX_VALUE ;
        }
      }
    }
  }
  static int mincost(int idx,int src,int dest,int costs[][]){
    if(idx>N)return 0 ;
    if(dp[idx][src][dest]!=Integer.MAX_VALUE)return dp[idx][src][dest];
    int rem=6-(src+dest);
    int ans=Integer.MAX_VALUE ;
    int case1=costs[src-1][dest-1]+mincost(idx+1,src,rem,costs)+mincost(idx+1,rem,dest,costs);
    int case2=costs[src-1][rem-1]+mincost(idx+1,src,dest,costs)+mincost(idx+1,dest,src,costs)+costs[rem-1][dest-1]+mincost(idx+1,src,dest,costs);
    ans=Math.min(case1,case2);
    dp[idx][src][dest]=ans ;
    return ans ;
  }
  public static void main(String[] args){
    int[][] costs={
      {
        0,1,2 },{
          2,0,1 },{
            3,2,0 }
          };
          initialize();
          System.out.print(mincost(1,1,3,costs));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute RODS : int := 3;
  static   attribute N : int := 3;
  static   attribute dp : Sequence(Sequence(Sequence(int))) := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,RODS + 1)->collect(Integer.subrange(1,RODS + 1)->collect(0)));
  static   operation initialize() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= N do ( (         var j : int ; j := 1 ; while j <= RODS do ( (         var k : int ; k := 1 ; while k <= RODS do ( (     dp[i+1][j+1][k+1] := 2147483647 )  ;     k := k+(1) ) )  ;     j := j + 1 ) )  ;     i := i+(1) ) );
  static   operation mincost( idx : int, src : int, dest : int, costs : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     if (idx > N) then     return 0 else skip ; 
     if (dp[idx+1][src+1][dest+1] /= 2147483647) then     return dp[idx+1][src+1][dest+1] else skip ; 
    var rem : int ; rem := 6 - (src + dest) ;
    var ans : int ; ans := 2147483647 ;
    var case1 : int ; case1 := costs[src - 1+1][dest - 1+1] + mincost(idx + 1, src, rem, costs) + mincost(idx + 1, rem, dest, costs) ;
    var case2 : int ; case2 := costs[src - 1+1][rem - 1+1] + mincost(idx + 1, src, dest, costs) + mincost(idx + 1, dest, src, costs) + costs[rem - 1+1][dest - 1+1] + mincost(idx + 1, src, dest, costs) ;
    ans := Set{case1, case2}->min() ; 
    dp[idx+1][src+1][dest+1] := ans ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var costs : Sequence(Sequence(int)) ; costs := Sequence{Sequence{0,1,2},Sequence{2,0,1},Sequence{3,2,0}} ;
     execute initialize() ; 
     OclFile["System.out"].print(mincost(1, 1, 3, costs)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printNonDivisible(int[] A,int[] B,int n,int m){
    int maxB=0 ;
    for(int i=0 ; i<m ; i++)if(B[i]>maxB)maxB=B[i];
    int[] mark=new int[maxB+1];
    for(int i=0 ; i<maxB ; i++)mark[i]=0 ;
    for(int i=0 ; i<n ; i++)for(int x=A[i]; x<=maxB ; x+=A[i])mark[x]++;
    for(int i=0 ; i<m ; i++)if(mark[B[i] ]==0)System.out.println(B[i]);
  }
  static public void main(String[] args){
    int[] A={
      100,200,400,100 };
      int n=A.length ;
      int[] B={
        190,200,87,600,800 };
        int m=B.length ;
        printNonDivisible(A,B,n,m);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printNonDivisible( A : Sequence(int), B : Sequence(int), n : int, m : int) : void
  pre: true
  post: true
  activity: (     var maxB : int ; maxB := 0 ;
         var i : int ; i := 0 ; while i < m do (     if (B[i+1] > maxB) then     maxB := B[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    var mark : Sequence(int) ; mark := Integer.subrange(1,maxB + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < maxB do (     mark[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (         var x : int ; x := A[i+1] ; while x <= maxB do (     mark[x+1] := mark[x+1] + 1 ;  ;     x := x+(A[i+1]) ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     if (mark[B[i+1]+1] = 0) then     OclFile["System.out"].println(B[i+1]) ; else skip ;  ;     i := i + 1 ) ; 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{100,200,400,100} ;
     var n : int ; n := A->size() ;
    var B : Sequence(int) ; B := Sequence{190,200,87,600,800} ;
    var m : int ; m := B->size() ;
    execute printNonDivisible(A, B, n, m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static int sumOfSeries(int n){
    int sum=0 ;
    for(int x=1 ; x<=n ; x++)sum+=x*x*x ;
    return sum ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(sumOfSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfSeries( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var x : int ; x := 1 ; while x <= n do (     sum := sum+(x * x * x) ;  ;     x := x + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(sumOfSeries(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  static Scanner s=new Scanner(System.in);
  static int gInt(){
    return Integer.parseInt(s.next());
  };
  public static void main(String[] $){
    int[] v=s.next().chars().map(i->i-'0').toArray();
    int a=v[0];
    int b=v[1];
    int c=v[2];
    int d=v[3];
    if(a+b+c+d==7){
      o("+","+","+",a,b,c,d);
      return ;
    }
    if(a-b+c+d==7){
      o("-","+","+",a,b,c,d);
      return ;
    }
    if(a+b-c+d==7){
      o("+","-","+",a,b,c,d);
      return ;
    }
    if(a+b+c-d==7){
      o("+","+","-",a,b,c,d);
      return ;
    }
    if(a-b-c+d==7){
      o("-","-","+",a,b,c,d);
      return ;
    }
    if(a-b+c-d==7){
      o("-","+","-",a,b,c,d);
      return ;
    }
    if(a+b-c-d==7){
      o("+","-","-",a,b,c,d);
      return ;
    }
    if(a-b-c-d==7){
      o("-","-","-",a,b,c,d);
      return ;
    }
  }
  static void o(String s1,String s2,String s3,int a,int b,int c,int d){
    System.out.println(a+s1+b+s2+c+s3+d+"=7");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation gInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := s.getCurrent().chars()->collect( _x1 | (lambda i : OclAny in i - ('0')->char2byte())->apply(_x1) )->asSequence() ;
     var a : int ; a := v[0+1] ;
    var b : int ; b := v[1+1] ;
    var c : int ; c := v[2+1] ;
    var d : int ; d := v[3+1] ;
    if (a + b + c + d = 7) then (     execute o("+", "+", "+", a, b, c, d) ; 
     return ) else skip ; 
    if (a - b + c + d = 7) then (     execute o("-", "+", "+", a, b, c, d) ; 
     return ) else skip ; 
    if (a + b - c + d = 7) then (     execute o("+", "-", "+", a, b, c, d) ; 
     return ) else skip ; 
    if (a + b + c - d = 7) then (     execute o("+", "+", "-", a, b, c, d) ; 
     return ) else skip ; 
    if (a - b - c + d = 7) then (     execute o("-", "-", "+", a, b, c, d) ; 
     return ) else skip ; 
    if (a - b + c - d = 7) then (     execute o("-", "+", "-", a, b, c, d) ; 
     return ) else skip ; 
    if (a + b - c - d = 7) then (     execute o("+", "-", "-", a, b, c, d) ; 
     return ) else skip ; 
    if (a - b - c - d = 7) then (     execute o("-", "-", "-", a, b, c, d) ; 
     return ) else skip ; 
 );
  static   operation o( s1 : String, s2 : String, s3 : String, a : int, b : int, c : int, d : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(a + s1 + b + s2 + c + s3 + d + "=7") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static int sumOfSeries(int n){
    int x=(n*(n+1)/2);
    return x*x ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(sumOfSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfSeries( n : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := (n * (n + 1) / 2) ;
     return x * x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(sumOfSeries(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static int sumOfSeries(int n){
    int x ;
    if(n % 2==0)x=(n/2)*(n+1);
    else x=((n+1)/2)*n ;
    return x*x ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(sumOfSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfSeries( n : int) : int
  pre: true
  post: true
  activity: (     var x : int ;
     if (n mod 2 = 0) then     x := (n / 2) * (n + 1) else     x := ((n + 1) / 2) * n ; ;  
     return x * x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(sumOfSeries(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int R=4 ;
  static int C=4 ;
  static int getTotalCoverageOfMatrix(int[][] mat){
    int res=0 ;
    for(int i=0 ; i<R ; i++){
      boolean isOne=false ;
      for(int j=0 ; j<C ; j++){
        if(mat[i][j]==1)isOne=true ;
        else if(isOne)res++;
      }
      isOne=false ;
      for(int j=C-1 ; j>=0 ; j--){
        if(mat[i][j]==1)isOne=true ;
        else if(isOne)res++;
      }
    }
    for(int j=0 ; j<C ; j++){
      boolean isOne=false ;
      for(int i=0 ; i<R ; i++){
        if(mat[i][j]==1)isOne=true ;
        else if(isOne)res++;
      }
      isOne=false ;
      for(int i=R-1 ; i>=0 ; i--){
        if(mat[i][j]==1)isOne=true ;
        else if(isOne)res++;
      }
    }
    return res ;
  }
  static public void main(String[] args){
    int[][] mat={
      {
        0,0,0,0 },{
          1,0,0,1 },{
            0,1,1,0 },{
              0,1,0,0 }
            };
            System.out.println(getTotalCoverageOfMatrix(mat));
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute R : int := 4;
  static   attribute C : int := 4;
  static   operation getTotalCoverageOfMatrix( mat : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < R do ( (     var isOne : boolean ; isOne := false ;
         var j : int ; j := 0 ; while j < C do ( (     if (mat[i+1][j+1] = 1) then     isOne := true ; else     if (isOne) then     res := res + 1 ; else skip ; )  ;     j := j + 1 ) ; 
     isOne := false ; 
         var j : int ; j := C - 1 ; while j >= 0 do ( (     if (mat[i+1][j+1] = 1) then     isOne := true ; else     if (isOne) then     res := res + 1 ; else skip ; )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
         var j : int ; j := 0 ; while j < C do ( (     var isOne : boolean ; isOne := false ;
         var i : int ; i := 0 ; while i < R do ( (     if (mat[i+1][j+1] = 1) then     isOne := true ; else     if (isOne) then     res := res + 1 ; else skip ; )  ;     i := i + 1 ) ; 
     isOne := false ; 
         var i : int ; i := R - 1 ; while i >= 0 do ( (     if (mat[i+1][j+1] = 1) then     isOne := true ; else     if (isOne) then     res := res + 1 ; else skip ; )  ;     i := i - 1 ) )  ;     j := j + 1 ) ; 
     return res );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{0,0,0,0},Sequence{1,0,0,1},Sequence{0,1,1,0},Sequence{0,1,0,0}} ;
     OclFile["System.out"].println(getTotalCoverageOfMatrix(mat)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void replace_elements(int arr[],int n){
    int pos=0 ;
    for(int i=0 ; i<n ; i++){
      arr[pos++]=arr[i];
      while(pos>1 && arr[pos-2]==arr[pos-1]){
        pos--;
        arr[pos-1]++;
      }
    }
    for(int i=0 ; i<pos ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String args[]){
    int arr[]={
      6,4,3,4,3,3,5 };
      int n=arr.length ;
      replace_elements(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation replace_elements( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var pos : int ; pos := 0 ;
         var i : int ; i := 0 ; while i < n do ( (      arr[pos+1] := arr[i+1]  ; pos := pos + 1 ; 
     while (pos > 1 & arr[pos - 2+1] = arr[pos - 1+1]) do (     pos := pos - 1 ; 
     arr[pos - 1+1] := arr[pos - 1+1] + 1 ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < pos do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,4,3,4,3,3,5} ;
     var n : int ; n := arr->size() ;
     execute replace_elements(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countOnes(int n){
    int count=1 ;
    int rem=1 ;
    while(rem!=0){
      rem=(rem*10+1)% n ;
      count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int n=13 ;
    System.out.println(countOnes(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countOnes( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 1 ;
     var rem : int ; rem := 1 ;
     while (rem /= 0) do (     rem := (rem * 10 + 1) mod n ; 
     count := count + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 13 ;
     OclFile["System.out"].println(countOnes(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.HashSet ;
import java.util.Set ;
public final class p029 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p029().run());
  }
  public String run(){
    Set<BigInteger>generated=new HashSet<>();
    for(int a=2 ; a<=100 ; a++){
      for(int b=2 ; b<=100 ; b++)generated.add(BigInteger.valueOf(a).pow(b));
    }
    return Integer.toString(generated.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class p029 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p029.newp029().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var generated : Set(long) ; generated := Set{} ;
         var a : int ; a := 2 ; while a <= 100 do ( (         var b : int ; b := 2 ; while b <= 100 do (     generated := generated->including((a + "")->toLong().pow(b)) ;  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
     return ((generated->size()) + "") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int z=0 ; z<n ; z++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      int[][] dp=new int[y+2][x+2];
      boolean[][] xx=new boolean[y+2][x+2];
      boolean[][] yy=new boolean[y+2][x+2];
      int p=sc.nextInt();
      int[] a=new int[4];
      int b ;
      for(int i=0 ; i<p ; i++){
        for(int j=0 ; j<4 ; j++)a[j]=sc.nextInt()+1 ;
        if(a[0]==a[2]){
          b=Math.max(a[1],a[3]);
          yy[b][a[0] ]=true ;
        }
        else {
          b=Math.max(a[0],a[2]);
          xx[a[1] ][b]=true ;
        }
      }
      dp[1][0]=1 ;
      for(int i=1 ; i<=y+1 ; i++){
        for(int j=1 ; j<=x+1 ; j++){
          if(yy[i][j]==false)dp[i][j]+=dp[i-1][j];
          if(xx[i][j]==false)dp[i][j]+=dp[i][j-1];
        }
      }
      b=dp[y+1][x+1];
      if(b==0)System.out.println("Miserable Hokusai!");
      else System.out.println(b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var z : int ; z := 0 ; while z < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,y + 2)->collect(Integer.subrange(1,x + 2)->collect(0)) ;
    var xx : Sequence(Sequence(boolean)) ; xx := Integer.subrange(1,y + 2)->collect(Integer.subrange(1,x + 2)->collect(false)) ;
    var yy : Sequence(Sequence(boolean)) ; yy := Integer.subrange(1,y + 2)->collect(Integer.subrange(1,x + 2)->collect(false)) ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,4)->collect(0) ;
    var b : int ;
        var i : int ; i := 0 ; while i < p do ( (         var j : int ; j := 0 ; while j < 4 do (     a[j+1] := sc.getCurrent()->toInteger() + 1 ;  ;     j := j + 1 ) ; 
     if (a[0+1] = a[2+1]) then (     b := Set{a[1+1], a[3+1]}->max() ; 
     yy[b+1][a[0+1]+1] := true ) else (     b := Set{a[0+1], a[2+1]}->max() ; 
     xx[a[1+1]+1][b+1] := true ) )  ;     i := i + 1 ) ; 
    dp[1+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= y + 1 do ( (         var j : int ; j := 1 ; while j <= x + 1 do ( (     if (yy[i+1][j+1] = false) then     dp[i+1][j+1] := dp[i+1][j+1]+(dp[i - 1+1][j+1]) ; else skip ; 
     if (xx[i+1][j+1] = false) then     dp[i+1][j+1] := dp[i+1][j+1]+(dp[i+1][j - 1+1]) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    b := dp[y + 1+1][x + 1+1] ; 
    if (b = 0) then     OclFile["System.out"].println("Miserable Hokusai!") else     OclFile["System.out"].println(b) ; ;  
 )  ;     z := z + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int nbim=sc.nextInt();
    while(nbim-->0){
      int gx=sc.nextInt();
      int gy=sc.nextInt();
      int[][] dp=new int[gy+2][gx+2];
      boolean[][][] hasTabis=new boolean[gy+2][gx+2][2];
      int p=sc.nextInt();
      for(int i=0 ; i<p ; i++){
        int x=sc.nextInt()+1 ;
        int y=sc.nextInt()+1 ;
        int x2=sc.nextInt()+1 ;
        int y2=sc.nextInt()+1 ;
        hasTabis[Math.max(y,y2)][Math.max(x,x2)][x!=x2 ? 0 : 1]=true ;
      }
      dp[0][1]=1 ;
      for(int i=1 ; i<gy+2 ; i++){
        for(int j=1 ; j<gx+2 ; j++){
          dp[i][j]=(hasTabis[i][j][1] ? 0 : dp[i-1][j])+(hasTabis[i][j][0] ? 0 : dp[i][j-1]);
        }
      }
      System.out.println(dp[gy+1][gx+1]==0 ? "Miserable Hokusai!" : dp[gy+1][gx+1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var nbim : int ; nbim := sc.getCurrent()->toInteger() ;
         while (nbim > 0) do (        nbim := nbim - 1 ;     skip ; (     var gx : int ; gx := sc.getCurrent()->toInteger() ;
     var gy : int ; gy := sc.getCurrent()->toInteger() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,gy + 2)->collect(Integer.subrange(1,gx + 2)->collect(0)) ;
    var hasTabis : Sequence(Sequence(Sequence(boolean))) ; hasTabis := Integer.subrange(1,gy + 2)->collect(Integer.subrange(1,gx + 2)->collect(Integer.subrange(1,2)->collect(false))) ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < p do ( (     var x : int ; x := sc.getCurrent()->toInteger() + 1 ;
     var y : int ; y := sc.getCurrent()->toInteger() + 1 ;
    var x2 : int ; x2 := sc.getCurrent()->toInteger() + 1 ;
    var y2 : int ; y2 := sc.getCurrent()->toInteger() + 1 ;
    hasTabis[Set{y, y2}->max()+1][Set{x, x2}->max()+1][if x /= x2 then 0 else 1 endif+1] := true ; 
 )  ;     i := i + 1 ) ; 
    dp[0+1][1+1] := 1 ; 
        var i : int ; i := 1 ; while i < gy + 2 do ( (         var j : int ; j := 1 ; while j < gx + 2 do ( (     dp[i+1][j+1] := (if hasTabis[i+1][j+1][1+1] then 0 else dp[i - 1+1][j+1] endif) + (if hasTabis[i+1][j+1][0+1] then 0 else dp[i+1][j - 1+1] endif) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if dp[gy + 1+1][gx + 1+1] = 0 then "Miserable Hokusai!" else dp[gy + 1+1][gx + 1+1] endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class _250B implements Runnable {
  private BufferedReader in ;
  private Object solve()throws IOException {
    StringBuilder sb=new StringBuilder();
    for(int i=0,n=nextInt(); i<n ; i++){
      String[] s=nextToken().split(":",-1);
      int k=0,m=s.length-1 ;
      if(s[k] .isEmpty()){
        k++;
      }
      if(s[m] .isEmpty()){
        m--;
      }
      for(int j=k ; j<=m ; j++){
        if(s[j] .isEmpty()){
          for(int l=1,lim=8-m+k ; l<=lim ; l++){
            sb.append("0000");
            if(l<lim){
              sb.append(':');
            }
          }
        }
        else {
          for(int l=s[j] .length(); l<4 ; l++){
            sb.append('0');
          }
          sb.append(s[j]);
        }
        if(j<m){
          sb.append(':');
        }
      }
      sb.append('\n');
    }
    return sb ;
  }
  public static void main(String[] args){
    new _250B().run();
  }
  @ Override public void run(){
    try {
      in=new BufferedReader(new InputStreamReader(System.in));
      System.out.print(solve());
      in.close();
    }
    catch(IOException e){
      System.exit(0);
    }
  }
  private String nextToken()throws IOException {
    return in.readLine();
  }
  private int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Runnable50B implements Runnable {
   attribute in : OclFile;
   operation solve() : OclAny
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ;
    var n : int ; n := nextInt() ; while i < n do ( (     var s : Sequence(String) ; s := nextToken()->split(":") ;
     var k : int ; k := 0 ;
    var m : int ; m := s->size() - 1 ;
    if (s[k+1]->isEmpty()) then (     k := k + 1 ) else skip ; 
    if (s[m+1]->isEmpty()) then (     m := m - 1 ) else skip ; 
        var j : int ; j := k ; while j <= m do ( (     if (s[j+1]->isEmpty()) then (         var l : int ; l := 1 ;
    var lim : int ; lim := 8 - m + k ; while l <= lim do ( (     sb := sb + StringLib.newString("0000") ; 
     if (l < lim) then (     sb := sb + StringLib.newString(':') ) else skip )  ;     l := l + 1 ) ) else (         var l : int ; l := s[j+1]->size() ; while l < 4 do ( (     sb := sb + StringLib.newString('0') )  ;     l := l + 1 ) ; 
     sb := sb + StringLib.newString(s[j+1]) ) ;  
     if (j < m) then (     sb := sb + StringLib.newString(':') ) else skip )  ;     j := j + 1 ) ; 
    sb := sb + StringLib.newString('
') ; 
 )  ;     i := i + 1 ) ; 
     return sb );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     ()50B.new()50B().run() );
      operation run() : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     OclFile["System.out"].print(solve()) ; 
     skip )   catch (e : IOException) do ( OclProcess.exit(0) )
 );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     return in.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  private static Scanner sc=new Scanner(System.in);
  static void p(String ans){
    System.out.println(ans);
  };
  static void p(int ans){
    System.out.println(ans);
  };
  static void p(long ans){
    System.out.println(ans);
  };
  static void p(double ans){
    System.out.println(ans);
  };
  static String s ;
  static String g ;
  static int a[]=new int[4];
  public static void main(String[] args){
    String N=sc.next();
    for(int i=0 ; i<4 ; i++){
      a[i]=N.charAt(i)-48 ;
    }
    if(dfs(1,a[0],"")){
      p(a[0]+""+g.charAt(0)+""+a[1]+""+g.charAt(1)+""+a[2]+""+g.charAt(2)+""+a[3]+"=7");
    }
  }
  static boolean dfs(int b,int sum,String v){
    g=v ;
    if(b==4)return sum==7 ;
    if(dfs(b+1,sum+a[b],v+"+"))return true ;
    if(dfs(b+1,sum-a[b],v+"-"))return true ;
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation p( ans : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : long) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : double) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   attribute s : String;
  static   attribute g : String;
  static   attribute a : int := Integer.subrange(1,4)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : String ; N := sc.getCurrent() ;
         var i : int ; i := 0 ; while i < 4 do ( (     a[i+1] := N->at(i+1) - 48 )  ;     i := i + 1 ) ; 
     if (dfs(1, a[0+1], "")) then (     execute p(a[0+1] + "" + g->at(0+1) + "" + a[1+1] + "" + g->at(1+1) + "" + a[2+1] + "" + g->at(2+1) + "" + a[3+1] + "=7") ) else skip );
  static   operation dfs( b : int, sum : int, v : String) : boolean
  pre: true
  post: true
  activity: (     g := v ; 
     if (b = 4) then     return sum = 7 else skip ; 
    if (dfs(b + 1, sum + a[b+1], v + "+")) then     return true else skip ; 
    if (dfs(b + 1, sum - a[b+1], v + "-")) then     return true else skip ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=10000 ;
  static int MAX_ELEMENT=50 ;
  static int[][][] dp=new int[MAX_ELEMENT][MAX_ELEMENT][MAX];
  static int Max_Xor(int arr[],int i,int j,int mask,int n){
    if(i>=n){
      if(j==0)return mask ;
      else return 0 ;
    }
    if(dp[i][j][mask]!=-1)return dp[i][j][mask];
    int ans=0 ;
    if(j>0)ans=Max_Xor(arr,i+1,j-1,mask ^ arr[i],n);
    ans=Math.max(ans,Max_Xor(arr,i+1,j,mask,n));
    return dp[i][j][mask]=ans ;
  }
  public static void main(String[] args){
    int arr[]={
      2,5,4,1,3,7,6,8 };
      int n=arr.length ;
      int k=3 ;
      for(int i=0 ; i<MAX_ELEMENT ; i++){
        for(int j=0 ; j<MAX_ELEMENT ; j++){
          for(int l=0 ; l<MAX ; l++)dp[i][j][l]=-1 ;
        }
      }
      System.out.println(Max_Xor(arr,0,k,0,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 10000;
  static   attribute MAX_ELEMENT : int := 50;
  static   attribute dp : Sequence(Sequence(Sequence(int))) := Integer.subrange(1,MAX_ELEMENT)->collect(Integer.subrange(1,MAX_ELEMENT)->collect(Integer.subrange(1,MAX)->collect(0)));
  static   operation Max_Xor( arr : Sequence(int), i : int, j : int, mask : int, n : int) : int
  pre: true
  post: true
  activity: (     if (i >= n) then (     if (j = 0) then     return mask else     return 0 ) else skip ; 
     if (dp[i+1][j+1][mask+1] /= -1) then     return dp[i+1][j+1][mask+1] else skip ; 
    var ans : int ; ans := 0 ;
    if (j > 0) then     ans := Max_Xor(arr, i + 1, j - 1, mask xor arr[i+1], n) ; else skip ; 
    ans := Set{ans, Max_Xor(arr, i + 1, j, mask, n)}->max() ; 
    return dp[i+1][j+1][mask+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,5,4,1,3,7,6,8} ;
     var n : int ; n := arr->size() ;
    var k : int ; k := 3 ;
        var i : int ; i := 0 ; while i < MAX_ELEMENT do ( (         var j : int ; j := 0 ; while j < MAX_ELEMENT do ( (         var l : int ; l := 0 ; while l < MAX do (     dp[i+1][j+1][l+1] := -1 ;  ;     l := l + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Max_Xor(arr, 0, k, 0, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MaxIncreasingSub(int arr[],int n,int k){
    int dp[][]=new int[n][k+1],ans=-1 ;
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<k+1 ; j++)dp[i][j]=-1 ;
    for(int i=0 ; i<n ; i++){
      dp[i][1]=arr[i];
    }
    for(int i=1 ; i<n ; i++){
      for(int j=0 ; j<i ; j++){
        if(arr[j]<arr[i]){
          for(int l=1 ; l<=k-1 ; l++){
            if(dp[j][l]!=-1){
              dp[i][l+1]=Math.max(dp[i][l+1],dp[j][l]+arr[i]);
            }
          }
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      if(ans<dp[i][k])ans=dp[i][k];
    }
    return(ans==-1)? 0 : ans ;
  }
  public static void main(String args[]){
    int n=8,k=3 ;
    int arr[]={
      8,5,9,10,5,6,21,8 };
      int ans=MaxIncreasingSub(arr,n,k);
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MaxIncreasingSub( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,k + 1)->collect(0)) ;
    var ans : int ; ans := -1 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < k + 1 do (     dp[i+1][j+1] := -1 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     dp[i+1][1+1] := arr[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 0 ; while j < i do ( (     if (arr[j+1] < arr[i+1]) then (         var l : int ; l := 1 ; while l <= k - 1 do ( (     if (dp[j+1][l+1] /= -1) then (     dp[i+1][l + 1+1] := Set{dp[i+1][l + 1+1], dp[j+1][l+1] + arr[i+1]}->max() ) else skip )  ;     l := l + 1 ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (ans < dp[i+1][k+1]) then     ans := dp[i+1][k+1] ; else skip )  ;     i := i + 1 ) ; 
    return if (ans = -1) then 0 else ans endif 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
    var k : int ; k := 3 ;
     var arr : Sequence(int) ; arr := Sequence{8,5,9,10,5,6,21,8} ;
     var ans : int ; ans := MaxIncreasingSub(arr, n, k) ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class First_Palin {
  static final int MAX_CHAR=26 ;
  static char stringPalindrome(String A,String B){
    int[] countA=new int[MAX_CHAR];
    int[] countB=new int[MAX_CHAR];
    int l1=A.length();
    int l2=B.length();
    for(int i=0 ; i<l1 ; i++)countA[A.charAt(i)-'a']++;
    for(int i=0 ; i<l2 ; i++)countB[B.charAt(i)-'a']++;
    for(int i=0 ; i<26 ; i++)if((countA[i]>1 && countB[i]==0))return 'A' ;
    return 'B' ;
  }
  public static void main(String args[]){
    String a="abcdea" ;
    String b="bcdesg" ;
    System.out.println(stringPalindrome(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class First_Palin {
  static    attribute MAX_CHAR : int := 26;
  static   operation stringPalindrome( A : String, B : String) : String
  pre: true
  post: true
  activity: (     var countA : Sequence(int) ; countA := Integer.subrange(1,MAX_CHAR)->collect(0) ;
     var countB : Sequence(int) ; countB := Integer.subrange(1,MAX_CHAR)->collect(0) ;
    var l1 : int ; l1 := A->size() ;
    var l2 : int ; l2 := B->size() ;
        var i : int ; i := 0 ; while i < l1 do (     countA[A->at(i+1) - ('a')->char2byte()+1] := countA[A->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < l2 do (     countB[B->at(i+1) - ('a')->char2byte()+1] := countB[B->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 26 do (     if ((countA[i+1] > 1 & countB[i+1] = 0)) then     return 'A' else skip ;  ;     i := i + 1 ) ; 
    return 'B' 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ; a := "abcdea" ;
     var b : String ; b := "bcdesg" ;
     OclFile["System.out"].println(stringPalindrome(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countPaths(int n){
    int zB=1 ;
    int zADC=0 ;
    for(int i=1 ; i<=n ; i++){
      int nzB=zADC*3 ;
      int nzADC=(zADC*2+zB);
      zB=nzB ;
      zADC=nzADC ;
    }
    return zB ;
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(countPaths(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPaths( n : int) : int
  pre: true
  post: true
  activity: (     var zB : int ; zB := 1 ;
     var zADC : int ; zADC := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     var nzB : int ; nzB := zADC * 3 ;
     var nzADC : int ; nzADC := (zADC * 2 + zB) ;
     zB := nzB ; 
     zADC := nzADC )  ;     i := i + 1 ) ; 
     return zB );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(countPaths(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    cityDay1199A();
  }
  public static void cityDay1199A(){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int x=scan.nextInt();
    int y=scan.nextInt();
    Boolean isNotsoRainyDay=true ;
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scan.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      isNotsoRainyDay=true ;
      for(int j=i+1 ; j<=i+y && j<n ; j++){
        if(a[i]>a[j]){
          isNotsoRainyDay=false ;
          break ;
        }
      }
      for(int k=i-1 ; k>=i-x && k>=0 && isNotsoRainyDay ; k--){
        if(a[i]>a[k]){
          isNotsoRainyDay=false ;
          break ;
        }
      }
      if(isNotsoRainyDay){
        System.out.println(i+1);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute cityDay1199A() );
  static   operation cityDay1199A() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var x : int ; x := scan.getCurrent()->toInteger() ;
    var y : int ; y := scan.getCurrent()->toInteger() ;
    var isNotsoRainyDay : Boolean ; isNotsoRainyDay := true ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     isNotsoRainyDay := true ; 
         var j : int ; j := i + 1 ; while j <= i + y & j < n do ( (     if (a[i+1] > a[j+1]) then (     isNotsoRainyDay := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
         var k : int ; k := i - 1 ; while k >= i - x & k >= 0 & isNotsoRainyDay do ( (     if (a[i+1] > a[k+1]) then (     isNotsoRainyDay := false ; 
     break ) else skip )  ;     k := k - 1 ) ; 
     if (isNotsoRainyDay) then (     OclFile["System.out"].println(i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class CityDay {
  public static void main(String[] args){
    FastReader fr=new FastReader();
    int n=fr.nextInt();
    int x=fr.nextInt();
    int y=fr.nextInt();
    long[] rain=new long[n];
    for(int i=0 ; i<n ; i++){
      rain[i]=fr.nextInt();
    }
    int ans=-1 ;
    for(int i=0 ; i<n ; i++){
      boolean left=true ;
      boolean right=true ;
      for(int j=i-1 ; j>=i-x && j>=0 ; j--){
        if(rain[j]<rain[i]){
          left=false ;
        }
      }
      for(int j=i+1 ; j<=i+y && j<=n-1 ; j++){
        if(rain[j]<rain[i]){
          right=false ;
        }
      }
      if(left && right){
        ans=i ;
        break ;
      }
    }
    System.out.println(ans+1);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CityDay {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fr : FastReader ; fr := FastReader.newFastReader() ;
     var n : int ; n := fr.nextInt() ;
    var x : int ; x := fr.nextInt() ;
    var y : int ; y := fr.nextInt() ;
    var rain : Sequence(long) ; rain := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     rain[i+1] := fr.nextInt() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var left : boolean ; left := true ;
     var right : boolean ; right := true ;
        var j : int ; j := i - 1 ; while j >= i - x & j >= 0 do ( (     if (rain[j+1] < rain[i+1]) then (     left := false ) else skip )  ;     j := j - 1 ) ; 
        var j : int ; j := i + 1 ; while j <= i + y & j <= n - 1 do ( (     if (rain[j+1] < rain[i+1]) then (     right := false ) else skip )  ;     j := j + 1 ) ; 
    if (left & right) then (     ans := i ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans + 1) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
class GFG {
  static int minChanges(int[] A,int n){
    int cnt=0 ;
    for(int i=0 ; i<n-2 ; ++i){
      if((i-1>=0)&& A[i-1]==1 && A[i+1]==1 && A[i]==0){
        A[i+1]=0 ;
        cnt++;
      }
    }
    return cnt ;
  }
  public static void main(String args[]){
    int[] A={
      1,1,0,1,1,0,1,0,1,0 };
      int n=A.length ;
      System.out.print(minChanges(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minChanges( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < n - 2 do ( (     if ((i - 1 >= 0) & A[i - 1+1] = 1 & A[i + 1+1] = 1 & A[i+1] = 0) then (     A[i + 1+1] := 0 ; 
     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{1,1,0,1,1,0,1,0,1,0} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].print(minChanges(A, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String balancedBrackets(String str){
    int dep=0 ;
    int minDep=0 ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)=='(')dep++;
      else dep--;
      if(minDep>dep)minDep=dep ;
    }
    if(minDep<0){
      for(int i=0 ; i<Math.abs(minDep); i++)str='('+str ; } dep=0 ; for(int i=0 ; i<str.length(); i++){ if(str.charAt(i)=='(')dep++; else dep--; } if(dep!=0){ for(int i=0 ; i<dep ; i++)str=str+')' ; } return str ; } public static void main(String[] args){ String str=")))()" ; System.out.println(balancedBrackets(str)); } }
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation balancedBrackets( str : String) : String
  pre: true
  post: true
  activity: (     var dep : int ; dep := 0 ;
     var minDep : int ; minDep := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '(') then     dep := dep + 1 else     dep := dep - 1 ; ;  
     if (minDep > dep) then     minDep := dep ; else skip )  ;     i := i + 1 ) ; 
    if (minDep < 0) then (         var i : int ; i := 0 ; while i < if minDep < 0 then -(minDep) else minDep endif do (     str := '(' + str ;  ;     i := i + 1 ) ) else skip ; 
    dep := 0 ; 
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '(') then     dep := dep + 1 ; else     dep := dep - 1 ; )  ;     i := i + 1 ) ; 
    if (dep /= 0) then (         var i : int ; i := 0 ; while i < dep do (     str := str + ')' ;  ;     i := i + 1 ) ) else skip ; 
    return str 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := ")))()" ;
     OclFile["System.out"].println(balancedBrackets(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    List<String>direc=new ArrayList<String>();
    direc.add("RIGHT");
    direc.add("LEFT");
    int n,m ;
    n=sc.nextInt();
    while(n!=0){
      int posX=1 ;
      int posY=1 ;
      int nowDirec=0 ;
      m=sc.nextInt();
      while(true){
        String instruct=sc.next();
        if(instruct.equals("STOP")){
          break ;
        }
        if(direc.contains(instruct)){
          if(instruct.equals(direc.get(0))){
            nowDirec++;
            nowDirec %=4 ;
          }
          else {
            nowDirec--;
            if(nowDirec==-1){
              nowDirec=3 ;
            }
          }
        }
        else {
          int step=sc.nextInt();
          if(instruct.equals("BACKWARD")){
            step=-step ;
          }
          if(nowDirec==0){
            posY+=step ;
            if(posY>m){
              posY=m ;
            }
            if(posY<1){
              posY=1 ;
            }
          }
          else if(nowDirec==1){
            posX+=step ;
            if(posX>n){
              posX=n ;
            }
            if(posX<1){
              posX=1 ;
            }
          }
          else if(nowDirec==2){
            posY-=step ;
            if(posY>m){
              posY=m ;
            }
            if(posY<1){
              posY=1 ;
            }
          }
          else if(nowDirec==3){
            posX-=step ;
            if(posX>n){
              posX=n ;
            }
            if(posX<1){
              posX=1 ;
            }
          }
        }
      }
      System.out.println(posX+" "+posY);
      n=sc.nextInt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var direc : Sequence(String) ; direc := Sequence{} ;
    direc := direc->including("RIGHT") ; 
    direc := direc->including("LEFT") ; 
    var n : int ;
    var m : int ;
    n := sc.getCurrent()->toInteger() ; 
    while (n /= 0) do (     var posX : int ; posX := 1 ;
     var posY : int ; posY := 1 ;
    var nowDirec : int ; nowDirec := 0 ;
    m := sc.getCurrent()->toInteger() ; 
    while (true) do (     var instruct : String ; instruct := sc.getCurrent() ;
     if (instruct = "STOP") then (     break ) else skip ; 
     if (direc->includes(instruct)) then (     if (instruct = direc->at(0+1)) then (     nowDirec := nowDirec + 1 ; 
     nowDirec := nowDirec mod 4 ) else (     nowDirec := nowDirec - 1 ; 
     if (nowDirec = -1) then (     nowDirec := 3 ) else skip ) ) else (     var step : int ; step := sc.getCurrent()->toInteger() ;
     if (instruct = "BACKWARD") then (     step := -step ) else skip ; 
     if (nowDirec = 0) then (     posY := posY+(step) ; 
     if (posY > m) then (     posY := m ) else skip ; 
     if (posY < 1) then (     posY := 1 ) else skip ) else     if (nowDirec = 1) then (     posX := posX+(step) ; 
     if (posX > n) then (     posX := n ) else skip ; 
     if (posX < 1) then (     posX := 1 ) else skip ) else     if (nowDirec = 2) then (     posY := posY-(step) ; 
     if (posY > m) then (     posY := m ) else skip ; 
     if (posY < 1) then (     posY := 1 ) else skip ) else     if (nowDirec = 3) then (     posX := posX-(step) ; 
     if (posX > n) then (     posX := n ) else skip ; 
     if (posX < 1) then (     posX := 1 ) else skip ) else skip ; ;  ;  ) ) ; 
    OclFile["System.out"].println(posX + " " + posY) ; 
    n := sc.getCurrent()->toInteger() ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPerfectSquare(int[] arr,int n){
    HashMap<Integer,Integer>umap=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(umap.containsKey(arr[i]))umap.put(arr[i],umap.get(arr[i])+1);
      else umap.put(arr[i],1);
    }
    Iterator<Map.Entry<Integer,Integer>>iterator=umap.entrySet().iterator();
    while(iterator.hasNext()){
      Map.Entry<Integer,Integer>entry=iterator.next();
      if(entry.getValue()% 2==1)return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    int arr[]={
      2,2,7,7 };
      int n=arr.length ;
      if(isPerfectSquare(arr,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPerfectSquare( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var umap : Map(int,int) ; umap := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (umap->keys()->includes(arr[i+1])) then     umap := umap->union(Map{arr[i+1] |-> umap->at(arr[i+1]) + 1}) ; else     umap := umap->union(Map{arr[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
    var iterator : OclIterator ; iterator := umap->asSet()->iterator() ;
    while (iterator.hasNext()) do (     var entry : Map(int,int) ; entry := iterator.next() ;
     if (entry->values->any() mod 2 = 1) then     return false else skip ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,2,7,7} ;
     var n : int ; n := arr->size() ;
     if (isPerfectSquare(arr, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countOne(int n){
    int count=0 ;
    while(n>0){
      n=n &(n-1);
      count++;
    }
    if(count % 2==0)return 1 ;
    else return 0 ;
  }
  static int sumDigits(int n){
    int sum=0 ;
    while(n!=0){
      sum+=n % 10 ;
      n/=10 ;
    }
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      4,9,15 };
      int n=arr.length ;
      int total_sum=0 ;
      for(int i=0 ; i<n ; i++){
        if(countOne(arr[i])==1)total_sum+=sumDigits(arr[i]);
      }
      System.out.println(total_sum);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countOne( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     n := n & (n - 1) ; 
     count := count + 1 ) ; 
     if (count mod 2 = 0) then     return 1 else     return 0 );
  static   operation sumDigits( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n /= 0) do (     sum := sum+(n mod 10) ; 
     n := n/(10) ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,9,15} ;
     var n : int ; n := arr->size() ;
    var total_sum : int ; total_sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (countOne(arr[i+1]) = 1) then     total_sum := total_sum+(sumDigits(arr[i+1])) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total_sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int __gcd(int a,int b){
    return b==0 ? a : __gcd(b,a % b);
  }
  static int digitGCD(int n){
    int gcd=0 ;
    while(n>0){
      gcd=__gcd(n % 10,gcd);
      if(gcd==1)return 1 ;
      n=n/10 ;
    }
    return gcd ;
  }
  public static void main(String[] args){
    int n=2448 ;
    System.out.print(digitGCD(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else __gcd(b, a mod b) endif );
  static   operation digitGCD( n : int) : int
  pre: true
  post: true
  activity: (     var gcd : int ; gcd := 0 ;
     while (n > 0) do (     gcd := __gcd(n mod 10, gcd) ; 
     if (gcd = 1) then     return 1 else skip ; 
     n := n / 10 ) ; 
     return gcd );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2448 ;
     OclFile["System.out"].print(digitGCD(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int dx[]={
      1,0 };
      int dy[]={
        0,1 };
        while(in.hasNext()){
          int H=in.nextInt();
          int W=in.nextInt();
          int cost[][]=new int[H][W];
          int map[][]=new int[H][W];
          LinkedList<String>que=new LinkedList<String>();
          for(int i=0 ; i<H ; i++){
            Arrays.fill(cost[i],1000);
            String st=in.next();
            for(int j=0 ; j<W ; j++)map[i][j]=Integer.valueOf(st.charAt(j)-'0');
          }
          cost[0][0]=0 ;
          que.add(0+" "+0);
          while(! que.isEmpty()){
            int size=que.size();
            for(int i=0 ; i<size ; i++){
              String now[]=que.poll().split(" ");
              int nh=Integer.valueOf(now[0]);
              int nw=Integer.valueOf(now[1]);
              for(int j=0 ; j<2 ; j++){
                int h=dy[j]+nh ;
                int w=dx[j]+nw ;
                if(h<H && w<W){
                  if(cost[h][w]>cost[nh][nw]+map[h][w]){
                    cost[h][w]=cost[nh][nw]+map[h][w];
                    que.add(h+" "+w);
                  }
                }
              }
            }
          }
          System.out.println(cost[H-1][W-1]);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dx : Sequence(int) ; dx := Sequence{1,0} ;
     var dy : Sequence(int) ; dy := Sequence{0,1} ;
     while (in.hasNext()) do (     var H : int ; H := in.getCurrent()->toInteger() ;
     var W : int ; W := in.getCurrent()->toInteger() ;
    var cost : Sequence(Sequence(int)) ; cost := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
    var que : Sequence(String) ; que := Sequence{} ;
        var i : int ; i := 0 ; while i < H do ( (     cost[i+1] := cost[i+1]->collect(1000) ; 
     var st : String ; st := in.getCurrent() ;
         var j : int ; j := 0 ; while j < W do (     map[i+1][j+1] := (st->at(j+1) - ('0')->char2byte())->toInteger() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    cost[0+1][0+1] := 0 ; 
    que := que->including(0 + " " + 0) ; 
    while (not(que->isEmpty())) do (     var size : int ; size := que->size() ;
         var i : int ; i := 0 ; while i < size do ( (     var now : Sequence(String) ; now := que->min()->split(" ") ;
     var nh : int ; nh := (now[0+1])->toInteger() ;
     var nw : int ; nw := (now[1+1])->toInteger() ;
         var j : int ; j := 0 ; while j < 2 do ( (     var h : int ; h := dy[j+1] + nh ;
     var w : int ; w := dx[j+1] + nw ;
     if (h < H & w < W) then (     if (cost[h+1][w+1] > cost[nh+1][nw+1] + map[h+1][w+1]) then (     cost[h+1][w+1] := cost[nh+1][nw+1] + map[h+1][w+1] ; 
     que := que->including(h + " " + w) ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) ; 
    OclFile["System.out"].println(cost[H - 1+1][W - 1+1]) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  static int INF=Integer.MAX_VALUE ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    line=br.readLine();
    int H,W ;
    H=parseInt(line.substring(0,line.indexOf(' ')));
    W=parseInt(line.substring(line.indexOf(' ')+1));
    int[][] dp=new int[H+2][W+2];
    for(int i=0 ; i<H+2 ; i++){
      for(int j=0 ; j<W+2 ; j++){
        dp[i][j]=INF ;
      }
    }
    dp[0][1]=0 ;
    dp[1][0]=0 ;
    for(int i=0 ; i<H ; i++){
      line=br.readLine();
      for(int j=0 ; j<W ; j++){
        dp[i+1][j+1]=line.charAt(j)-'0' ;
      }
    }
    for(int i=1 ; i<=H ; i++){
      for(int j=1 ; j<=W ; j++){
        dp[i][j]+=Math.min(dp[i][j-1],dp[i-1][j]);
      }
    }
    System.out.println(dp[H][W]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute INF : int := 2147483647;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    line := br.readLine() ; 
    var H : int ;
    var W : int ;
    H := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    W := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,H + 2)->collect(Integer.subrange(1,W + 2)->collect(0)) ;
        var i : int ; i := 0 ; while i < H + 2 do ( (         var j : int ; j := 0 ; while j < W + 2 do ( (     dp[i+1][j+1] := INF )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    dp[0+1][1+1] := 0 ; 
    dp[1+1][0+1] := 0 ; 
        var i : int ; i := 0 ; while i < H do ( (     line := br.readLine() ; 
         var j : int ; j := 0 ; while j < W do ( (     dp[i + 1+1][j + 1+1] := line->at(j+1) - ('0')->char2byte() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= H do ( (         var j : int ; j := 1 ; while j <= W do ( (     dp[i+1][j+1] := dp[i+1][j+1]+(Set{dp[i+1][j - 1+1], dp[i - 1+1][j+1]}->min()) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[H+1][W+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    String[] line=s.nextLine().split(" ");
    int height=Integer.parseInt(line[0]);
    int width=Integer.parseInt(line[1]);
    int[][] input=new int[width+1][height+1];
    for(int i=1 ; i<=height ; i++){
      String str=s.nextLine();
      for(int j=1 ; j<=width ; j++){
        input[j][i]=Integer.parseInt(str.substring(j-1,j));
      }
    }
    System.out.println(solve(height,width,input));
  }
  public static int solve(int height,int width,int[][] input){
    int[][] result=new int[width+1][height+1];
    for(int i=0 ; i<=width ; i++){
      result[i][0]=Integer.MAX_VALUE ;
    }
    for(int i=0 ; i<=height ; i++){
      result[0][i]=Integer.MAX_VALUE ;
    }
    result[0][1]=0 ;
    result[1][0]=0 ;
    for(int i=1 ; i<=width ; i++){
      for(int j=1 ; j<=height ; j++){
        if(result[i-1][j]>=result[i][j-1])result[i][j]=result[i][j-1]+input[i][j];
        else result[i][j]=result[i-1][j]+input[i][j];
      }
    }
    return result[width][height];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : Sequence(String) ; line := s.nextLine()->split(" ") ;
    var height : int ; height := (line[0+1])->toInteger() ;
    var width : int ; width := (line[1+1])->toInteger() ;
    var input : Sequence(Sequence(int)) ; input := Integer.subrange(1,width + 1)->collect(Integer.subrange(1,height + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= height do ( (     var str : String ; str := s.nextLine() ;
         var j : int ; j := 1 ; while j <= width do ( (     input[j+1][i+1] := (str.subrange((j)->char2byte() - 1+1,j))->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(height, width, input)) ; 
 );
  static   operation solve( height : int, width : int, input : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var result : Sequence(Sequence(int)) ; result := Integer.subrange(1,width + 1)->collect(Integer.subrange(1,height + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i <= width do ( (     result[i+1][0+1] := 2147483647 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= height do ( (     result[0+1][i+1] := 2147483647 )  ;     i := i + 1 ) ; 
    result[0+1][1+1] := 0 ; 
    result[1+1][0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= width do ( (         var j : int ; j := 1 ; while j <= height do ( (     if (result[i - 1+1][j+1] >= result[i+1][(j)->char2byte() - 1+1]) then     result[i+1][j+1] := result[i+1][(j)->char2byte() - 1+1] + input[i+1][j+1] ; else     result[i+1][j+1] := result[i - 1+1][j+1] + input[i+1][j+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return result[width+1][height+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    char[][] m=new char[h][w];
    int[][] c=new int[h][w];
    for(int i=0 ; i<h ; i++)m[i]=sc.next().toCharArray();
    for(int i=0 ; i<h ; i++)for(int j=0 ; j<w ; j++)c[i][j]=m[i][j]-'0' ;
    int[][] dp=new int[h][w];
    dp[h-1][w-1]=c[h-1][w-1];
    for(int j=w-2 ; j>=0 ; j--)dp[h-1][j]=dp[h-1][j+1]+c[h-1][j];
    for(int i=h-2 ; i>=0 ; i--)dp[i][w-1]=dp[i+1][w-1]+c[i][w-1];
    for(int i=h-2 ; i>=0 ; i--)for(int j=w-2 ; j>=0 ; j--)dp[i][j]=c[i][j]+Math.min(dp[i+1][j],dp[i][j+1]);
    System.out.println(dp[0][0]);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var m : Sequence(Sequence(String)) ; m := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do (     m[i+1] := sc.getCurrent()->characters() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < h do (         var j : int ; j := 0 ; while j < w do (     c[i+1][j+1] := m[i+1][j+1] - ('0')->char2byte() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    dp[h - 1+1][w - 1+1] := c[h - 1+1][w - 1+1] ; 
        var j : int ; j := w - 2 ; while j >= 0 do (     dp[h - 1+1][j+1] := dp[h - 1+1][j + 1+1] + c[h - 1+1][j+1] ;  ;     j := j - 1 ) ; 
        var i : int ; i := h - 2 ; while i >= 0 do (     dp[i+1][w - 1+1] := dp[i + 1+1][w - 1+1] + c[i+1][w - 1+1] ;  ;     i := i - 1 ) ; 
        var i : int ; i := h - 2 ; while i >= 0 do (         var j : int ; j := w - 2 ; while j >= 0 do (     dp[i+1][j+1] := c[i+1][j+1] + Set{dp[i + 1+1][j+1], dp[i+1][j + 1+1]}->min() ;  ;     j := j - 1 ) ;  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(dp[0+1][0+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int[][] map=new int[h][w];
    int[][] cost=new int[h][w];
    for(int i=0 ; i<h ; i++){
      char[] a=sc.next().toCharArray();
      for(int j=0 ; j<w ; j++)map[i][j]=(int)a[j]-48 ;
      Arrays.fill(cost[i],Integer.MAX_VALUE);
    }
    ArrayDeque<Integer>x=new ArrayDeque<Integer>();
    ArrayDeque<Integer>y=new ArrayDeque<Integer>();
    x.offer(0);
    y.offer(0);
    cost[0][0]=0 ;
    int p,q ;
    while(x.size()!=0){
      p=x.poll();
      q=y.poll();
      if(p!=w-1 && cost[q][p]+map[q][p+1]<cost[q][p+1]){
        x.offer(p+1);
        y.offer(q);
        cost[q][p+1]=cost[q][p]+map[q][p+1];
      }
      if(q!=h-1 && cost[q][p]+map[q+1][p]<cost[q+1][p]){
        x.offer(p);
        y.offer(q+1);
        cost[q+1][p]=cost[q][p]+map[q+1][p];
      }
    }
    System.out.println(cost[h-1][w-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    var cost : Sequence(Sequence(int)) ; cost := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (     var a : Sequence(String) ; a := sc.getCurrent()->characters() ;
         var j : int ; j := 0 ; while j < w do (     map[i+1][j+1] := a[j+1]->oclAsType(int) - 48 ;  ;     j := j + 1 ) ; 
     cost[i+1] := cost[i+1]->collect(2147483647) )  ;     i := i + 1 ) ; 
    var x : Sequence(int) ; x := ArrayDeque<int>.newArrayDeque() ;
    var y : Sequence(int) ; y := ArrayDeque<int>.newArrayDeque() ;
    x := x->including(0) ; 
    y := y->including(0) ; 
    cost[0+1][0+1] := 0 ; 
    var p : int ;
    var q : int ;
    while (x->size() /= 0) do (     p := x->min() ;     x := x->sort()->tail() ; 
     q := y->min() ;     y := y->sort()->tail() ; 
     if (p /= w - 1 & cost[q+1][p+1] + map[q+1][p + 1+1] < cost[q+1][p + 1+1]) then (     x := x->including(p + 1) ; 
     y := y->including(q) ; 
     cost[q+1][p + 1+1] := cost[q+1][p+1] + map[q+1][p + 1+1] ) else skip ; 
     if (q /= h - 1 & cost[q+1][p+1] + map[q + 1+1][p+1] < cost[q + 1+1][p+1]) then (     x := x->including(p) ; 
     y := y->including(q + 1) ; 
     cost[q + 1+1][p+1] := cost[q+1][p+1] + map[q + 1+1][p+1] ) else skip ) ; 
    OclFile["System.out"].println(cost[h - 1+1][w - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PensAndPencils {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int[][] ans=new int[t][];
    for(int i=0 ; i<t ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int d=sc.nextInt();
      int k=sc.nextInt();
      int pens=a/c ;
      int pencil=b/d ;
      int rem=a % c ;
      if(rem!=0)pens+=1 ;
      rem=b % d ;
      if(rem!=0)pencil+=1 ;
      if(pens+pencil<=k)ans[i]=(new int[] {
        pens,pencil }
);
        else ans[i]=(new int[] {
-1 }
);
        }
        for(int i=0 ; i<ans.length ; i++){
          for(int el : ans[i]){
            System.out.print(el+" ");
          }
          System.out.println();
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class PensAndPencils {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var ans : Sequence(Sequence(int)) ; ans := Integer.subrange(1,t)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < t do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var pens : int ; pens := a / c ;
    var pencil : int ; pencil := b / d ;
    var rem : int ; rem := a mod c ;
    if (rem /= 0) then     pens := pens+(1) ; else skip ; 
    rem := b mod d ; 
    if (rem /= 0) then     pencil := pencil+(1) ; else skip ; 
    if (pens + pencil <= k) then     ans[i+1] := (Sequence{pens,pencil}) else     ans[i+1] := (Sequence{-1}) ; ;  
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < ans->size() do ( (     for (el : ans[i+1]) do ( (     OclFile["System.out"].print(el + " ") )  ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int d=sc.nextInt();
      int k=sc.nextInt();
      int pen=1 ;
      while(c*pen<a){
        pen++;
      }
      int pencile=1 ;
      while(pencile*d<b){
        pencile++;
      }
      if(pen+pencile<=k)System.out.println(pen+" "+pencile);
      else System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var pen : int ; pen := 1 ;
    while (c * pen < a) do (     pen := pen + 1 ) ; 
    var pencile : int ; pencile := 1 ;
    while (pencile * d < b) do (     pencile := pencile + 1 ) ; 
    if (pen + pencile <= k) then     OclFile["System.out"].println(pen + " " + pencile) else     OclFile["System.out"].println(-1) ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.function.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int ABCD=s.nextInt();
    StringBuilder str=new StringBuilder();
    StringBuilder abcd=new StringBuilder(String.format("%04d",ABCD));
    for(int i=0 ; i<(1<<3); i++){
      int candidate=ABCD/1000 ;
      int tmp=ABCD ;
      for(int j=0 ; j<3 ; j++){
        if(((i>>j)& 1)==1){
          candidate+=tmp % 10 ;
          str.insert(0,"+");
        }
        else {
          candidate-=tmp % 10 ;
          str.insert(0,"-");
        }
        tmp/=10 ;
      }
      if(candidate==7){
        abcd.insert(1,str.charAt(0));
        abcd.insert(3,str.charAt(1));
        abcd.insert(5,str.charAt(2));
        abcd.append("=7");
        System.out.println(abcd.toString());
        return ;
      }
      str=new StringBuilder();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ABCD : int ; ABCD := s.getCurrent()->toInteger() ;
    var str : String ; str := StringLib.newString() ;
    var abcd : String ; abcd := StringLib.newString(StringLib.format("%04d",Sequence{ABCD})) ;
        var i : int ; i := 0 ; while i < ((1*(2->pow(3)))->oclAsType(long)) do ( (     var candidate : int ; candidate := ABCD / 1000 ;
     var tmp : int ; tmp := ABCD ;
        var j : int ; j := 0 ; while j < 3 do ( (     if ((((i/(2->pow(j)))->oclAsType(long)) & 1) = 1) then (     candidate := candidate+(tmp mod 10) ; 
     str := str.insertAt(0+1, StringLib.newString("+")) ) else (     candidate := candidate-(tmp mod 10) ; 
     str := str.insertAt(0+1, StringLib.newString("-")) ) ;  
     tmp := tmp/(10) )  ;     j := j + 1 ) ; 
    if (candidate = 7) then (     abcd := abcd.insertAt(1+1, StringLib.newString(str->at(0+1))) ; 
     abcd := abcd.insertAt(3+1, StringLib.newString(str->at(1+1))) ; 
    abcd := abcd.insertAt(5+1, StringLib.newString(str->at(2+1))) ; 
    abcd := abcd + StringLib.newString("=7") ; 
    OclFile["System.out"].println(abcd+"") ; 
    return 
 ) else skip ; 
    str := StringLib.newString() ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int n=sc.nextInt();
    int[][] field=new int[h][w];
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    int hh=0 ;
    int ww=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<arr[i]; j++){
        field[hh][ww]=i+1 ;
        if(hh % 2==0){
          if(ww==w-1){
            hh++;
          }
          else {
            ww++;
          }
        }
        else {
          if(ww==0){
            hh++;
          }
          else {
            ww--;
          }
        }
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        if(j!=0){
          sb.append(" ");
        }
        sb.append(field[i][j]);
      }
      sb.append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var field : Sequence(Sequence(int)) ; field := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var hh : int ; hh := 0 ;
    var ww : int ; ww := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < arr[i+1] do ( (     field[hh+1][ww+1] := i + 1 ; 
     if (hh mod 2 = 0) then (     if (ww = w - 1) then (     hh := hh + 1 ) else (     ww := ww + 1 ) ) else (     if (ww = 0) then (     hh := hh + 1 ) else (     ww := ww - 1 ) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (j /= 0) then (     sb := sb + StringLib.newString(" ") ) else skip ; 
     sb := sb + StringLib.newString(field[i+1][j+1]) )  ;     j := j + 1 ) ; 
     sb := sb + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Random ;
import java.util.StringTokenizer ;
public class B {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    int n=fs.nextInt();
    int[] maxes=new int[1_000_001];
    int[] mins=new int[1_000_001];
    long withAscent=0 ;
    for(int i=0 ; i<n ; i++){
      int l=fs.nextInt();
      int minSeen=Integer.MAX_VALUE,maxSeen=-1 ;
      boolean ascent=false ;
      for(int j=0 ; j<l ; j++){
        int next=fs.nextInt();
        if(next>minSeen){
          ascent=true ;
        }
        minSeen=Math.min(minSeen,next);
        maxSeen=Math.max(maxSeen,next);
      }
      if(ascent){
        withAscent++;
      }
      else {
        maxes[maxSeen]++;
        mins[minSeen]++;
      }
    }
    long ans=0 ;
    ans+=withAscent*n+(n-withAscent)*withAscent ;
    long maxSeen=0 ;
    for(int i=maxes.length-1 ; i>=0 ; i--){
      ans+=mins[i]*maxSeen ;
      maxSeen+=maxes[i];
    }
    System.out.println(ans);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreElements())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var n : int ; n := fs.nextInt() ;
    var maxes : Sequence(int) ; maxes := Integer.subrange(1,1_000_001)->collect(0) ;
    var mins : Sequence(int) ; mins := Integer.subrange(1,1_000_001)->collect(0) ;
    var withAscent : long ; withAscent := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var l : int ; l := fs.nextInt() ;
     var minSeen : int ; minSeen := 2147483647 ;
    var maxSeen : int ; maxSeen := -1 ;
    var ascent : boolean ; ascent := false ;
        var j : int ; j := 0 ; while j < l do ( (     var next : int ; next := fs.nextInt() ;
     if (next > minSeen) then (     ascent := true ) else skip ; 
     minSeen := Set{minSeen, next}->min() ; 
     maxSeen := Set{maxSeen, next}->max() )  ;     j := j + 1 ) ; 
    if (ascent) then (     withAscent := withAscent + 1 ) else (     maxes[maxSeen+1] := maxes[maxSeen+1] + 1 ; 
     mins[minSeen+1] := mins[minSeen+1] + 1 ) ;  
 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    ans := ans+(withAscent * n + (n - withAscent) * withAscent) ; 
    var maxSeen : long ; maxSeen := 0 ;
        var i : int ; i := maxes->size() - 1 ; while i >= 0 do ( (     ans := ans+(mins[i+1] * maxSeen) ; 
     maxSeen := maxSeen+(maxes[i+1]) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int lcm_fun(int a,int b){
    if(b==0)return a ;
    return lcm_fun(b,a % b);
  }
  static int digitLCM(int n){
    int lcm=1 ;
    while(n>0){
      lcm=(n % 10*lcm)/lcm_fun(n % 10,lcm);
      if(lcm==0)return 0 ;
      n=n/10 ;
    }
    return lcm ;
  }
  public static void main(String[] args){
    int n=397 ;
    System.out.println(digitLCM(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation lcm_fun( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return lcm_fun(b, a mod b) );
  static   operation digitLCM( n : int) : int
  pre: true
  post: true
  activity: (     var lcm : int ; lcm := 1 ;
     while (n > 0) do (     lcm := (n mod 10 * lcm) / lcm_fun(n mod 10, lcm) ; 
     if (lcm = 0) then     return 0 else skip ; 
     n := n / 10 ) ; 
     return lcm );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 397 ;
     OclFile["System.out"].println(digitLCM(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.*;
import java.awt.geom.Point2D ;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] $){
    int h=sc.nextInt();
    int w=sc.nextInt();
    int n=sc.nextInt();
    int[] a=new int[n];
    Point[] p=new Point[h*w];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    int count=0 ;
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        if(i % 2==0){
          p[count++]=new Point(i,j);
        }
        else {
          p[count++]=new Point(i,w-1-j);
        }
      }
    }
    int[][] c=new int[h][w];
    count=0 ;
    for(int i=0 ; i<n ; i++){
      int color=i+1 ;
      for(int j=0 ; j<a[i]; j++){
        c[p[count] .x][p[count] .y]=color ;
        count++;
      }
    }
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        out.print(c[i][j]);
        if(j<w-1)out.print(" ");
      }
      out.println();
    }
  }
  static class sc {
    static Scanner s=new Scanner(in);
    static String next(){
      return s.next();
    }
    static int nextInt(){
      return Integer.parseInt(s.next());
    }
    static long nextLong(){
      return Long.parseLong(s.next());
    }
    static double nextDouble(){
      return Double.parseDouble(s.next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var h : int ; h := sc.nextInt() ;
     var w : int ; w := sc.nextInt() ;
    var n : int ; n := sc.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var p : Sequence(Point) ; p := Integer.subrange(1,h * w)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (i mod 2 = 0) then (      p[count+1] := Point.newPoint(i, j)  ; count := count + 1 ) else (      p[count+1] := Point.newPoint(i, w - 1 - j)  ; count := count + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    count := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     var color : int ; color := i + 1 ;
         var j : int ; j := 0 ; while j < a[i+1] do ( (     c[p[count+1].x+1][p[count+1].y+1] := color ; 
     count := count + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     out.print(c[i+1][j+1]) ; 
     if (j < w - 1) then     out.print(" ") ; else skip )  ;     j := j + 1 ) ; 
     out.println() )  ;     i := i + 1 ) ; 
 );
  static class sc {
  static   attribute s : OclFile := OclFile.newOclFile_Read(in);
  static   operation next() : String
  pre: true
  post: true
  activity: (     return s.getCurrent() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toLong() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main m=new Main();
    m.answer();
  }
  private Scanner scan=new Scanner(System.in);
  private int H ;
  private int W ;
  private int N ;
  private int[] a ;
  public Main(){
    H=Integer.parseInt(scan.next());
    W=Integer.parseInt(scan.next());
    N=Integer.parseInt(scan.next());
    a=new int[N];
    for(int i=0 ; i<N ; i++){
      a[i]=Integer.parseInt(scan.next());
    }
    scan.close();
  }
  public final void answer(){
    int[] number=new int[H*W];
    int index=0 ;
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<a[i]; j++){
        number[index]=i+1 ;
        index++;
      }
    }
    StringBuilder str=new StringBuilder();
    for(int h=0 ; h<H ; h++){
      for(int w=0 ; w<W ; w++){
        if(h % 2==0){
          str.append(number[h*W+w]);
        }
        else {
          str.append(number[(h+1)*W-1-w]);
        }
        if(w<W-1)str.append(' ');
      }
      str.append('\n');
    }
    System.out.println(str.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.answer() );
   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute H : int;
   attribute W : int;
   attribute N : int;
   attribute a : Sequence(int);
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     H := (scan.getCurrent())->toInteger() ; 
     W := (scan.getCurrent())->toInteger() ; 
    N := (scan.getCurrent())->toInteger() ; 
    a := Integer.subrange(1,N)->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := (scan.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation answer() : void
  pre: true
  post: true
  activity: (     var number : Sequence(int) ; number := Integer.subrange(1,H * W)->collect(0) ;
     var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < a[i+1] do ( (     number[index+1] := i + 1 ; 
     index := index + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var str : String ; str := StringLib.newString() ;
        var h : int ; h := 0 ; while h < H do ( (         var w : int ; w := 0 ; while w < W do ( (     if (h mod 2 = 0) then (     str := str + StringLib.newString(number[h * W + w+1]) ) else (     str := str + StringLib.newString(number[(h + 1) * W - 1 - w+1]) ) ;  
     if (w < W - 1) then     str := str + StringLib.newString(' ') ; else skip )  ;     w := w + 1 ) ; 
     str := str + StringLib.newString('
') )  ;     h := h + 1 ) ; 
    OclFile["System.out"].println(str+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int h=scan.nextInt();
    int w=scan.nextInt();
    int n=scan.nextInt();
    int[] c=new int[n];
    for(int i=0 ; i<n ; i++){
      c[i]=scan.nextInt();
    }
    ArrayList<ArrayList<Integer>>a=new ArrayList<ArrayList<Integer>>();
    for(int i=0 ; i<h ; i++){
      ArrayList<Integer>b=new ArrayList<Integer>();
      a.add(b);
    }
    int f=1 ;
    int current=0 ;
    for(int i=0 ; i<n ; i++){
      int count=c[i];
      while(count>0){
        ArrayList<Integer>g=a.get(current);
        g.add(i+1);
        current+=f ;
        if(current==h){
          current=h-1 ;
          f=-1 ;
        }
        if(current==-1){
          current=0 ;
          f=1 ;
        }
        count-=1 ;
      }
    }
    for(int j=0 ; j<h ; j++){
      ArrayList<Integer>m=a.get(j);
      for(int k=0 ; k<w-1 ; k++){
        System.out.print(m.get(k)+" ");
      }
      System.out.println(m.get(w-1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := scan.getCurrent()->toInteger() ;
    var w : int ; w := scan.getCurrent()->toInteger() ;
    var n : int ; n := scan.getCurrent()->toInteger() ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var a : Sequence(Sequence(int)) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < h do ( (     var b : Sequence(int) ; b := Sequence{} ;
     a := a->including(b) )  ;     i := i + 1 ) ; 
    var f : int ; f := 1 ;
    var current : int ; current := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var count : int ; count := c[i+1] ;
     while (count > 0) do (     var g : Sequence(int) ; g := a->at(current+1) ;
     g := g->including(i + 1) ; 
    current := current+(f) ; 
    if (current = h) then (     current := h - 1 ; 
     f := -1 ) else skip ; 
    if (current = -1) then (     current := 0 ; 
     f := 1 ) else skip ; 
    count := count-(1) ; 
 ) )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < h do ( (     var m : Sequence(int) ; m := a->at(j+1) ;
         var k : int ; k := 0 ; while k < w - 1 do ( (     OclFile["System.out"].print(m->at(k+1) + " ") )  ;     k := k + 1 ) ; 
     OclFile["System.out"].println(m->at(w - 1+1)) )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int R=input.nextInt();
    int C=input.nextInt();
    int N=input.nextInt();
    int[] arr=new int[N+1];
    int[][] ans=new int[R][C];
    for(int i=1 ; i<=N ; i++){
      arr[i]=input.nextInt();
    }
    int index=1 ;
    for(int r=0 ; r<R ; r++){
      if(r % 2==0){
        for(int c=0 ; c<C ; c++){
          ans[r][c]=index ;
          arr[index]--;
          if(arr[index]==0)index++;
        }
      }
      else {
        for(int c=C-1 ; c>=0 ; c--){
          ans[r][c]=index ;
          arr[index]--;
          if(arr[index]==0)index++;
        }
      }
    }
    for(int i=0 ; i<R ; i++){
      for(int j=0 ; j<C ; j++){
        System.out.print(ans[i][j]+" ");
      }
      System.out.print("\n");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var R : int ; R := input.getCurrent()->toInteger() ;
    var C : int ; C := input.getCurrent()->toInteger() ;
    var N : int ; N := input.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,N + 1)->collect(0) ;
    var ans : Sequence(Sequence(int)) ; ans := Integer.subrange(1,R)->collect(Integer.subrange(1,C)->collect(0)) ;
        var i : int ; i := 1 ; while i <= N do ( (     arr[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var index : int ; index := 1 ;
        var r : int ; r := 0 ; while r < R do ( (     if (r mod 2 = 0) then (         var c : int ; c := 0 ; while c < C do ( (     ans[r+1][c+1] := index ; 
     arr[index+1] := arr[index+1] - 1 ; 
     if (arr[index+1] = 0) then     index := index + 1 ; else skip )  ;     c := c + 1 ) ) else (         var c : int ; c := C - 1 ; while c >= 0 do ( (     ans[r+1][c+1] := index ; 
     arr[index+1] := arr[index+1] - 1 ; 
     if (arr[index+1] = 0) then     index := index + 1 ; else skip )  ;     c := c - 1 ) ) )  ;     r := r + 1 ) ; 
        var i : int ; i := 0 ; while i < R do ( (         var j : int ; j := 0 ; while j < C do ( (     OclFile["System.out"].print(ans[i+1][j+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=scan.nextInt();
    }
    printOperations(n,k,arr);
  }
  public static void printOperations(int n,int k,int[] arr){
    if(n==1){
      System.out.println(0+" "+0);
      return ;
    }
    int[][] set=new int[n][2];
    for(int i=0 ; i<n ; i++){
      set[i]=new int[] {
        i+1,arr[i] };
      }
      int time=0 ;
      Arrays.sort(set,(a,b)->a[1]!=b[1] ? a[1]-b[1] : a[0]-b[0]);
      StringBuilder sb=new StringBuilder();
      while(time<k){
        int[] max=set[n-1];
        int[] min=set[0];
        if(max[1]-min[1]<=1){
          break ;
        }
        sb.append(max[0]).append(" ").append(min[0]).append("\n");
        max[1]--;
        min[1]++;
        Arrays.sort(set,(a,b)->a[1]!=b[1] ? a[1]-b[1] : a[0]-b[0]);
        time++;
      }
      System.out.println(set[n-1][1]-set[0][1]+" "+time);
      System.out.println(sb);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute printOperations(n, k, arr) ; 
 );
  static   operation printOperations( n : int, k : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (n = 1) then (     OclFile["System.out"].println(0 + " " + 0) ; 
     return ) else skip ; 
     var set : Sequence(Sequence(int)) ; set := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     set[i+1] := Sequence{i + 1,arr[i+1]} )  ;     i := i + 1 ) ; 
    var time : int ; time := 0 ;
    set := OclComparator.sortWith(set, lambda (a , b) : OclAny in if a[1+1] /= b[1+1] then a[1+1] - b[1+1] else a[0+1] - b[0+1] endif) ; 
    var sb : String ; sb := StringLib.newString() ;
    while (time < k) do (     var max : Sequence(int) ; max := set[n - 1+1] ;
     var min : Sequence(int) ; min := set[0+1] ;
    if (max[1+1] - min[1+1] <= 1) then (     break ) else skip ; 
    sb := sb + StringLib.newString(max[0+1]) + StringLib.newString(" ") + StringLib.newString(min[0+1]) + StringLib.newString("\n") ; 
    max[1+1] := max[1+1] - 1 ; 
    min[1+1] := min[1+1] + 1 ; 
    set := OclComparator.sortWith(set, lambda (a , b) : OclAny in if a[1+1] /= b[1+1] then a[1+1] - b[1+1] else a[0+1] - b[0+1] endif) ; 
    time := time + 1 ; 
 ) ; 
    OclFile["System.out"].println(set[n - 1+1][1+1] - set[0+1][1+1] + " " + time) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=scan.nextInt();
    }
    printOperations(n,k,arr);
  }
  public static void printOperations(int n,int k,int[] arr){
    if(n==1){
      System.out.println(0+" "+0);
      return ;
    }
    TreeSet<int[]>set=new TreeSet<>((a,b)->a[1]!=b[1] ? a[1]-b[1] : a[0]-b[0]);
    for(int i=0 ; i<n ; i++){
      set.add(new int[] {
        i+1,arr[i] }
);
      }
      int time=0 ;
      int diff=Integer.MAX_VALUE ;
      StringBuilder sb=new StringBuilder();
      while(time<k){
        int[] min=set.pollFirst();
        int[] max=set.pollLast();
        diff=max[1]-min[1];
        if(diff<=1){
          set.add(min);
          set.add(max);
          break ;
        }
        sb.append(max[0]).append(" ").append(min[0]).append("\n");
        max[1]--;
        min[1]++;
        set.add(min);
        set.add(max);
        time++;
      }
      int[] min=set.pollFirst();
      int[] max=set.pollLast();
      diff=max[1]-min[1];
      System.out.println(diff+" "+time);
      System.out.println(sb);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute printOperations(n, k, arr) ; 
 );
  static   operation printOperations( n : int, k : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (n = 1) then (     OclFile["System.out"].println(0 + " " + 0) ; 
     return ) else skip ; 
     var set : Set(Sequence(int)) ; set := Set{}->union(lambda (a , b) : OclAny in if a[1+1] /= b[1+1] then a[1+1] - b[1+1] else a[0+1] - b[0+1] endif) ;
        var i : int ; i := 0 ; while i < n do ( (     set := set->including(Sequence{i + 1,arr[i+1]}) )  ;     i := i + 1 ) ; 
    var time : int ; time := 0 ;
    var diff : int ; diff := 2147483647 ;
    var sb : String ; sb := StringLib.newString() ;
    while (time < k) do (     var min : Sequence(int) ; min := set->first() ;
     var max : Sequence(int) ; max := set->last() ;
    diff := max[1+1] - min[1+1] ; 
    if (diff <= 1) then (     set := set->including(min) ; 
     set := set->including(max) ; 
     break ) else skip ; 
    sb := sb + StringLib.newString(max[0+1]) + StringLib.newString(" ") + StringLib.newString(min[0+1]) + StringLib.newString("\n") ; 
    max[1+1] := max[1+1] - 1 ; 
    min[1+1] := min[1+1] + 1 ; 
    set := set->including(min) ; 
    set := set->including(max) ; 
    time := time + 1 ; 
 ) ; 
    var min : Sequence(int) ; min := set->first() ;
    var max : Sequence(int) ; max := set->last() ;
    diff := max[1+1] - min[1+1] ; 
    OclFile["System.out"].println(diff + " " + time) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class C {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(new File("C-large.in"));
    PrintWriter out=new PrintWriter(new FileWriter(new File("C-large.out")));
    int t=in.nextInt();
    for(int x=0 ; x<t ; x++){
      int n=in.nextInt();
      int[] xs=new int[n];
      int[] ys=new int[n];
      for(int y=0 ; y<n ; y++){
        xs[y]=in.nextInt();
        ys[y]=in.nextInt();
      }
      out.println("Case #"+(x+1)+":");
      for(int z=0 ; z<xs.length ; z++){
        ArrayList<Double>angles=new ArrayList<Double>();
        for(int a=0 ; a<xs.length ; a++){
          if(a!=z){
            double current=Math.atan2(ys[a]-ys[z],xs[a]-xs[z]);
            angles.add(current);
            angles.add(current+2.0*Math.PI);
          }
        }
        Collections.sort(angles);
        int index=0 ;
        int result=n ;
        for(int b=0 ; b<n ; b++){
          while(index<angles.size()&& angles.get(index)<angles.get(b)+Math.PI+1E-12){
            index++;
          }
          result=Math.min(result,n-(index-b)-1);
        }
        if(n==1){
          out.println(0);
        }
        else {
          out.println(result);
        }
      }
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("C-large.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile("C-large.out"))) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        var x : int ; x := 0 ; while x < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var xs : Sequence(int) ; xs := Integer.subrange(1,n)->collect(0) ;
    var ys : Sequence(int) ; ys := Integer.subrange(1,n)->collect(0) ;
        var y : int ; y := 0 ; while y < n do ( (     xs[y+1] := in.getCurrent()->toInteger() ; 
     ys[y+1] := in.getCurrent()->toInteger() )  ;     y := y + 1 ) ; 
    skip ; 
        var z : int ; z := 0 ; while z < xs->size() do ( (     var angles : Sequence(double) ; angles := Sequence{} ;
         var a : int ; a := 0 ; while a < xs->size() do ( (     if (a /= z) then (     var current : double ; current := atan2(ys[a+1] - ys[z+1], xs[a+1] - xs[z+1]) ;
     angles := angles->including(current) ; 
     angles := angles->including(current + 2.0 * 3.141592653589793) ) else skip )  ;     a := a + 1 ) ; 
    angles := angles->sort() ; 
    var index : int ; index := 0 ;
    var result : int ; result := n ;
        var b : int ; b := 0 ; while b < n do ( (     while (index < angles->size() & angles->at(index+1) < angles->at(b+1) + 3.141592653589793 + 1E-12) do (     index := index + 1 ) ; 
     result := Set{result, n - (index - b) - 1}->min() )  ;     b := b + 1 ) ; 
    if (n = 1) then (     skip ) else (     skip ) ;  
 )  ;     z := z + 1 ) ; 
 )  ;     x := x + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int ABCD=scn.nextInt();
    int A=ABCD/1000 ;
    int B=(ABCD % 1000)/100 ;
    int C=(ABCD % 100)/10 ;
    int D=ABCD % 10 ;
    if(A+B+C+D==7){
      System.out.println(A+"+"+B+"+"+C+"+"+D+"="+7);
      return ;
    }
    if(A+B+C-D==7){
      System.out.println(A+"+"+B+"+"+C+"-"+D+"="+7);
      return ;
    }
    if(A+B-C+D==7){
      System.out.println(A+"+"+B+"-"+C+"+"+D+"="+7);
      return ;
    }
    if(A+B-C-D==7){
      System.out.println(A+"+"+B+"-"+C+"-"+D+"="+7);
      return ;
    }
    if(A-B+C+D==7){
      System.out.println(A+"-"+B+"+"+C+"+"+D+"="+7);
      return ;
    }
    if(A-B+C-D==7){
      System.out.println(A+"-"+B+"+"+C+"-"+D+"="+7);
      return ;
    }
    if(A-B-C+D==7){
      System.out.println(A+"-"+B+"-"+C+"+"+D+"="+7);
      return ;
    }
    if(A-B-C-D==7){
      System.out.println(A+"-"+B+"-"+C+"-"+D+"="+7);
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ABCD : int ; ABCD := scn.getCurrent()->toInteger() ;
    var A : int ; A := ABCD / 1000 ;
    var B : int ; B := (ABCD mod 1000) / 100 ;
    var C : int ; C := (ABCD mod 100) / 10 ;
    var D : int ; D := ABCD mod 10 ;
    if (A + B + C + D = 7) then (     OclFile["System.out"].println(A + "+" + B + "+" + C + "+" + D + "=" + 7) ; 
     return ) else skip ; 
    if (A + B + C - D = 7) then (     OclFile["System.out"].println(A + "+" + B + "+" + C + "-" + D + "=" + 7) ; 
     return ) else skip ; 
    if (A + B - C + D = 7) then (     OclFile["System.out"].println(A + "+" + B + "-" + C + "+" + D + "=" + 7) ; 
     return ) else skip ; 
    if (A + B - C - D = 7) then (     OclFile["System.out"].println(A + "+" + B + "-" + C + "-" + D + "=" + 7) ; 
     return ) else skip ; 
    if (A - B + C + D = 7) then (     OclFile["System.out"].println(A + "-" + B + "+" + C + "+" + D + "=" + 7) ; 
     return ) else skip ; 
    if (A - B + C - D = 7) then (     OclFile["System.out"].println(A + "-" + B + "+" + C + "-" + D + "=" + 7) ; 
     return ) else skip ; 
    if (A - B - C + D = 7) then (     OclFile["System.out"].println(A + "-" + B + "-" + C + "+" + D + "=" + 7) ; 
     return ) else skip ; 
    if (A - B - C - D = 7) then (     OclFile["System.out"].println(A + "-" + B + "-" + C + "-" + D + "=" + 7) ; 
     return ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int FindMinNum(int arr[],int n){
    int pre[]=new int[n];
    pre[0]=arr[0];
    for(int i=1 ; i<n ; i++)pre[i]=pre[i-1]+arr[i];
    int k=Integer.MAX_VALUE ;
    for(int i=0 ; i<n-1 ; i++){
      int rightSum=pre[n-1]-pre[i];
      if(rightSum>=pre[i])k=Math.min(k,rightSum-pre[i]);
    }
    if(k!=Integer.MAX_VALUE)return k ;
    return-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      6,7,1,3,8,2,4 };
      int n=arr.length ;
      System.out.println(FindMinNum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation FindMinNum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var pre : Sequence(int) ; pre := Integer.subrange(1,n)->collect(0) ;
     pre[0+1] := arr[0+1] ; 
        var i : int ; i := 1 ; while i < n do (     pre[i+1] := pre[i - 1+1] + arr[i+1] ;  ;     i := i + 1 ) ; 
    var k : int ; k := 2147483647 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var rightSum : int ; rightSum := pre[n - 1+1] - pre[i+1] ;
     if (rightSum >= pre[i+1]) then     k := Set{k, rightSum - pre[i+1]}->min() ; else skip )  ;     i := i + 1 ) ; 
    if (k /= 2147483647) then     return k else skip ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,7,1,3,8,2,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(FindMinNum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static long gcd(long a,long b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static long divTermCount(long a,long b,long c,long num){
    return((num/a)+(num/b)+(num/c)-(num/((a*b)/gcd(a,b)))-(num/((c*b)/gcd(c,b)))-(num/((a*c)/gcd(a,c)))+(num/((a*b*c)/gcd(gcd(a,b),c))));
  }
  static public void main(String[] arr){
    long a=7,b=3,c=5,n=100 ;
    System.out.println(divTermCount(a,b,c,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation divTermCount( a : long, b : long, c : long, num : long) : long
  pre: true
  post: true
  activity: (     return ((num / a) + (num / b) + (num / c) - (num / ((a * b) / gcd(a, b))) - (num / ((c * b) / gcd(c, b))) - (num / ((a * c) / gcd(a, c))) + (num / ((a * b * c) / gcd(gcd(a, b), c)))) );
  static    operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ; a := 7 ;
    var b : long ; b := 3 ;
    var c : long ; c := 5 ;
    var n : long ; n := 100 ;
     OclFile["System.out"].println(divTermCount(a, b, c, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round3 ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class D {
  private int s ;
  private boolean[][] z ;
  private int d ;
  public static void main(String[] args)throws FileNotFoundException {
    Scanner in=new Scanner(new File(D.class.getSimpleName()+".in"));
    PrintWriter out=new PrintWriter(new File(D.class.getSimpleName()+".out"));
    int T=in.nextInt();
    for(int i=0 ; i<T ; i++){
      String s="Case #"+(i+1)+": "+new D().solve(in);
      out.println(s);
      System.out.println(s);
    }
    out.close();
  }
  private String solve(Scanner in){
    int n=in.nextInt();
    d=in.nextInt();
    s=0 ;
    z=new boolean[10][d];
    calc(n,0);
    return ""+s ;
  }
  private void calc(int n,int p){
    if(n==0){
      s++;
      return ;
    }
    for(int i=p+1 ; i<=n ; i++){
      int j=i ;
      int k=0 ;
      boolean ok=true ;
      while(j>0){
        if(z[k][j % d]){
          ok=false ;
          break ;
        }
        j/=d ;
        k++;
      }
      if(ok){
        j=i ;
        k=0 ;
        while(j>0){
          z[k][j % d]=true ;
          j/=d ;
          k++;
        }
        calc(n-i,i);
        j=i ;
        k=0 ;
        while(j>0){
          z[k][j % d]=false ;
          j/=d ;
          k++;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
   attribute s : int;
   attribute z : Sequence(Sequence(boolean));
   attribute d : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile(OclType["D"].getSimpleName() + ".in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile(OclType["D"].getSimpleName() + ".out")) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < T do ( (     var s : String ; s := "Case #" + (i + 1) + ": " + D.newD().solve(in) ;
     skip ; 
     OclFile["System.out"].println(s) )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation solve( in : OclFile) : String
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     d := in.getCurrent()->toInteger() ; 
    s := 0 ; 
    z := Integer.subrange(1,10)->collect(Integer.subrange(1,d)->collect(false)) ; 
    execute calc(n, 0) ; 
    return "" + s 
 );
   operation calc( n : int, p : int) : void
  pre: true
  post: true
  activity: (     if (n = 0) then (     s := s + 1 ; 
     return ) else skip ; 
         var i : int ; i := p + 1 ; while i <= n do ( (     var j : int ; j := i ;
     var k : int ; k := 0 ;
    var ok : boolean ; ok := true ;
    while (j > 0) do (     if (z[k+1][j mod d+1]) then (     ok := false ; 
     break ) else skip ; 
     j := j/(d) ; 
     k := k + 1 ) ; 
    if (ok) then (     j := i ; 
     k := 0 ; 
    while (j > 0) do (     z[k+1][j mod d+1] := true ; 
     j := j/(d) ; 
     k := k + 1 ) ; 
    execute calc((n)->char2byte() - i, i) ; 
    j := i ; 
    k := 0 ; 
    while (j > 0) do (     z[k+1][j mod d+1] := false ; 
     j := j/(d) ; 
     k := k + 1 ) ; 
 ) else skip ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int factorial(int n){
    if(n==0)return 1 ;
    return n*factorial(n-1);
  }
  static int LCMOfNeighbourFact(int n){
    return factorial(n+1);
  }
  public static void main(String args[]){
    int N=5 ;
    System.out.println(LCMOfNeighbourFact(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation factorial( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     return n * factorial(n - 1) );
  static   operation LCMOfNeighbourFact( n : int) : int
  pre: true
  post: true
  activity: (     return factorial(n + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     OclFile["System.out"].println(LCMOfNeighbourFact(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isSubsetSum(int set[],int n,int sum){
    if(sum==0)return true ;
    if(n==0 && sum!=0)return false ;
    if(set[n-1]>sum)return isSubsetSum(set,n-1,sum);
    return isSubsetSum(set,n-1,sum)|| isSubsetSum(set,n-1,sum-set[n-1]);
  }
  public static void main(String args[]){
    int set[]={
      3,34,4,12,5,2 };
      int sum=9 ;
      int n=set.length ;
      if(isSubsetSum(set,n,sum)==true)System.out.println("Found a subset"+" with given sum");
      else System.out.println("No subset with"+" given sum");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isSubsetSum( set : Sequence(int), n : int, sum : int) : boolean
  pre: true
  post: true
  activity: (     if (sum = 0) then     return true else skip ; 
     if (n = 0 & sum /= 0) then     return false else skip ; 
     if (set[n - 1+1] > sum) then     return isSubsetSum(set, n - 1, sum) else skip ; 
     return isSubsetSum(set, n - 1, sum) or isSubsetSum(set, n - 1, sum - set[n - 1+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var set : Sequence(int) ; set := Sequence{3,34,4,12,5,2} ;
     var sum : int ; sum := 9 ;
     var n : int ; n := set->size() ;
     if (isSubsetSum(set, n, sum) = true) then     OclFile["System.out"].println("Found a subset" + " with given sum") ; else     OclFile["System.out"].println("No subset with" + " given sum") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  void run(){
    int LA=readInt();
    int LB=readInt();
    int[] A=new int[LA];
    int[] B=new int[LB];
    for(int i=0 ; i<LA ; i++){
      A[i]=readInt();
    }
    for(int i=0 ; i<LB ; i++){
      B[i]=readInt();
    }
    int ans=0 ;
    for(int i=0 ; i<LB ; i++){
      int p=0 ;
      int k=i ;
      while(p<LA && k<LB){
        if(A[p]==B[k]){
++k ;
        }
        p++;
      }
      ans=Math.max(ans,k-i);
    }
    sysout.println(ans);
  }
  public static void main(String[] args){
    new Main().run();
  }
  PrintWriter sysout=new PrintWriter(System.out,true);
  BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer buffer=null ;
  String read(){
    if(buffer==null || ! buffer.hasMoreTokens()){
      try {
        buffer=new StringTokenizer(in.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return buffer.nextToken();
  }
  int readInt(){
    return Integer.parseInt(read());
  }
  long readLong(){
    return Long.parseLong(read());
  }
  double readDouble(){
    return Double.parseDouble(read());
  }
  String readLine(){
    buffer=null ;
    try {
      return in.readLine();
    }
    catch(IOException e){
      throw new RuntimeException(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var LA : int ; LA := readInt() ;
     var LB : int ; LB := readInt() ;
    var A : Sequence(int) ; A := Integer.subrange(1,LA)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,LB)->collect(0) ;
        var i : int ; i := 0 ; while i < LA do ( (     A[i+1] := readInt() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < LB do ( (     B[i+1] := readInt() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < LB do ( (     var p : int ; p := 0 ;
     var k : int ; k := i ;
     while (p < LA & k < LB) do (     if (A[p+1] = B[k+1]) then (     k := k + 1 ) else skip ; 
     p := p + 1 ) ; 
     ans := Set{ans, k - i}->max() )  ;     i := i + 1 ) ; 
    sysout.println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute sysout : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], true);
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute buffer : OclIterator := null;
   operation read() : String
  pre: true
  post: true
  activity: (     if (buffer = null or not(buffer.hasNext())) then (     try (     buffer := OclIterator.newOclIterator_String(in.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return buffer.next() );
   operation readInt() : int
  pre: true
  post: true
  activity: (     return (read())->toInteger() );
   operation readLong() : long
  pre: true
  post: true
  activity: (     return (read())->toLong() );
   operation readDouble() : double
  pre: true
  post: true
  activity: (     return (read())->toReal() );
   operation readLine() : String
  pre: true
  post: true
  activity: (     buffer := null ; 
     try (     return in.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final int A=sc.nextInt();
    final int B=sc.nextInt();
    short[] a_array=new short[A];
    short[] b_array=new short[B];
    for(int i=0 ; i<A ; i++){
      a_array[i]=sc.nextShort();
    }
    for(int i=0 ; i<B ; i++){
      b_array[i]=sc.nextShort();
    }
    short[][] dp=new short[A+1][B+1];
    int max=0 ;
    for(int i=0 ; i<A ; i++){
      for(int j=0 ; j<B ; j++){
        if(a_array[i]==b_array[j]){
          dp[i+1][j+1]=(short)(dp[i][j]+1);
        }
        else {
          dp[i+1][j+1]=dp[i][j+1];
        }
      }
    }
    for(int i=0 ; i<=B ; i++){
      max=Math.max(max,dp[A][i]);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var a_array : Sequence(int) ; a_array := Integer.subrange(1,A)->collect(0) ;
    var b_array : Sequence(int) ; b_array := Integer.subrange(1,B)->collect(0) ;
        var i : int ; i := 0 ; while i < A do ( (     a_array[i+1] := sc.nextShort() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < B do ( (     b_array[i+1] := sc.nextShort() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,A + 1)->collect(Integer.subrange(1,B + 1)->collect(0)) ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < A do ( (         var j : int ; j := 0 ; while j < B do ( (     if (a_array[i+1] = b_array[j+1]) then (     dp[i + 1+1][j + 1+1] := ((dp[i+1][j+1] + 1) mod 32768) ) else (     dp[i + 1+1][j + 1+1] := dp[i+1][j + 1+1] ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= B do ( (     max := Set{max, dp[A+1][i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    line=br.readLine();
    int A,B ;
    if(line.indexOf(' ')>=0){
      A=parseInt(line.substring(0,line.indexOf(' ')));
      B=parseInt(line.substring(line.indexOf(' ')+1));
    }
    else {
      A=parseInt(line);
      B=parseInt(br.readLine());
    }
    int[] CA=new int[A+1];
    int[] CB=new int[B+1];
    StringTokenizer st ;
    st=new StringTokenizer(br.readLine());
    for(int i=1 ; i<=A ; i++){
      CA[i]=parseInt(st.nextToken());
    }
    st=new StringTokenizer(br.readLine());
    for(int i=1 ; i<=B ; i++){
      CB[i]=parseInt(st.nextToken());
    }
    int[][] dp=new int[A+1][B+1];
    int ans=0 ;
    for(int i=1 ; i<=A ; i++){
      for(int j=1 ; j<=B ; j++){
        if(CA[i]==CB[j]){
          dp[i][j]=dp[i-1][j-1]+1 ;
        }
        else {
          dp[i][j]=dp[i-1][j];
        }
        ans=Math.max(ans,dp[i][j]);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    line := br.readLine() ; 
    var A : int ;
    var B : int ;
    if (line->indexOf(' ')-1 >= 0) then (     A := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
     B := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ) else (     A := (line + "")->toInteger() ; 
     B := (br.readLine() + "")->toInteger() ) ;  
    var CA : Sequence(int) ; CA := Integer.subrange(1,A + 1)->collect(0) ;
    var CB : Sequence(int) ; CB := Integer.subrange(1,B + 1)->collect(0) ;
    var st : OclIterator ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 1 ; while i <= A do ( (     CA[i+1] := (st.next() + "")->toInteger() )  ;     i := i + 1 ) ; 
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 1 ; while i <= B do ( (     CB[i+1] := (st.next() + "")->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,A + 1)->collect(Integer.subrange(1,B + 1)->collect(0)) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= A do ( (         var j : int ; j := 1 ; while j <= B do ( (     if (CA[i+1] = CB[j+1]) then (     dp[i+1][j+1] := dp[i - 1+1][j - 1+1] + 1 ) else (     dp[i+1][j+1] := dp[i - 1+1][j+1] ) ;  
     ans := Set{ans, dp[i+1][j+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt(),B=sc.nextInt();
    int[] a=new int[A];
    int[] b=new int[B];
    for(int i=0 ; i<A ; i++)a[i]=sc.nextInt();
    for(int i=0 ; i<B ; i++)b[i]=sc.nextInt();
    int[][] aa=new int[1001][];
    for(int i=1 ; i<=1000 ; i++){
      int cnt=0 ;
      for(int j=0 ; j<A ; j++)if(a[j]==i)cnt++;
      aa[i]=new int[cnt];
      int idx=0 ;
      for(int j=0 ; j<A ; j++)if(a[j]==i)aa[i][idx++]=j ;
    }
    int max=0 ;
    for(int start=0 ; start<B ; start++){
      int cnt=0,pos=-1 ;
      for(int i=start ; i<B ; i++){
        int before=cnt ;
        for(int j=0 ; j<aa[b[i] ] .length ; j++){
          if(aa[b[i] ][j]>pos){
            cnt++;
            pos=aa[b[i] ][j];
            break ;
          }
        }
        if(before==cnt)break ;
      }
      max=Math.max(max,cnt);
    }
    System.out.println(max);
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,A)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,B)->collect(0) ;
        var i : int ; i := 0 ; while i < A do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < B do (     b[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var aa : Sequence(Sequence(int)) ; aa := Integer.subrange(1,1001)->collect(Sequence{}) ;
        var i : int ; i := 1 ; while i <= 1000 do ( (     var cnt : int ; cnt := 0 ;
         var j : int ; j := 0 ; while j < A do (     if (a[j+1] = i) then     cnt := cnt + 1 ; else skip ;  ;     j := j + 1 ) ; 
    aa[i+1] := Integer.subrange(1,cnt)->collect(0) ; 
    var idx : int ; idx := 0 ;
        var j : int ; j := 0 ; while j < A do (     if (a[j+1] = i) then      aa[i+1][idx+1] := j  ; idx := idx + 1 ; else skip ;  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var start : int ; start := 0 ; while start < B do ( (     var cnt : int ; cnt := 0 ;
    var pos : int ; pos := -1 ;
         var i : int ; i := start ; while i < B do ( (     var before : int ; before := cnt ;
         var j : int ; j := 0 ; while j < aa[b[i+1]+1]->size() do ( (     if (aa[b[i+1]+1][j+1] > pos) then (     cnt := cnt + 1 ; 
     pos := aa[b[i+1]+1][j+1] ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (before = cnt) then     break else skip )  ;     i := i + 1 ) ; 
     max := Set{max, cnt}->max() )  ;     start := start + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[] A=new int[N];
    int[] B=new int[M];
    for(int i=0 ; i<N ; ++i){
      A[i]=sc.nextInt();
    }
    for(int i=0 ; i<M ; ++i){
      B[i]=sc.nextInt();
    }
    int[] dp=new int[M+1];
    for(int i=0 ; i<N ; ++i){
      for(int j=M-1 ; j>=0 ; --j){
        if(A[i]==B[j]){
          dp[j+1]=Math.max(dp[j+1],dp[j]+1);
        }
      }
    }
    int ans=0 ;
    for(int i=1 ; i<=M ; ++i){
      ans=Math.max(ans,dp[i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var M : int ; M := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     B[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,M + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := M - 1 ; while j >= 0 do ( (     if (A[i+1] = B[j+1]) then (     dp[j + 1+1] := Set{dp[j + 1+1], dp[j+1] + 1}->max() ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= M do ( (     ans := Set{ans, dp[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public static void main(String[] agrs){
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    int[] a=new int[n];
    float[] b=new float[n];
    float total=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      b[i]=sc.nextFloat();
      total+=b[i]/2.0 ;
    }
    float[][] dp=new float[n+1][10001];
    for(int i=0 ; i<=n ; i++)Arrays.fill(dp[i],-1);
    dp[0][0]=total ;
    for(int i=0 ; i<n ; i++){
      for(int k=n-1 ; k>=0 ; k--){
        for(int j=0 ; j<10001 ; j++){
          if(dp[k][j]==-1)continue ;
          dp[k+1][j+a[i] ]=(float)Math.max(dp[k+1][j+a[i] ],dp[k][j]+b[i]/2.0);
        }
      }
    }
    float max=0 ;
    for(int k=1 ; k<=n ; k++){
      max=0 ;
      for(int j=0 ; j<10001 ; j++){
        max=(float)Math.max(max,Math.min(dp[k][j],j));
      }
      out.print(max+" ");
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(double) ; b := Integer.subrange(1,n)->collect(0.0) ;
    var total : double ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.nextFloat() ; 
     total := total+(b[i+1] / 2.0) )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(double)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,10001)->collect(0.0)) ;
        var i : int ; i := 0 ; while i <= n do (     dp[i+1] := dp[i+1]->collect(-1) ;  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := total ; 
        var i : int ; i := 0 ; while i < n do ( (         var k : int ; k := n - 1 ; while k >= 0 do ( (         var j : int ; j := 0 ; while j < 10001 do ( (     if (dp[k+1][j+1] = -1) then     continue else skip ; 
     dp[k + 1+1][j + a[i+1]+1] := Set{dp[k + 1+1][j + a[i+1]+1], dp[k+1][j+1] + b[i+1] / 2.0}->max()->oclAsType(double) )  ;     j := j + 1 ) )  ;     k := k - 1 ) )  ;     i := i + 1 ) ; 
    var max : double ; max := 0 ;
        var k : int ; k := 1 ; while k <= n do ( (     max := 0 ; 
         var j : int ; j := 0 ; while j < 10001 do ( (     max := Set{max, Set{dp[k+1][j+1], j}->min()}->max()->oclAsType(double) )  ;     j := j + 1 ) ; 
     skip )  ;     k := k + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class dummy {
  public static void main(String args[])throws IOException {
    BufferedReader x=new BufferedReader(new InputStreamReader(System.in));
    String input[]=(x.readLine()).split(" ");
    int arr[]=new int[4];
    arr[0]=Integer.parseInt(input[0]);
    arr[1]=Integer.parseInt(input[1]);
    arr[2]=Integer.parseInt(input[2]);
    arr[3]=Integer.parseInt(input[3]);
    int largest=arr[0],middle=arr[1],smallest=arr[2],marsha=arr[3];
    if(smallest>marsha*2)System.out.println(-1);
    else if(marsha>smallest*2)System.out.println(-1);
    else if(marsha>=middle)System.out.println(-1);
    else {
      System.out.println((largest*2)+"\n"+(middle*2)+"\n"+Math.max(smallest,marsha));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class dummy {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : OclFile ; x := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : Sequence(String) ; input := (x.readLine())->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,4)->collect(0) ;
    arr[0+1] := (input[0+1])->toInteger() ; 
    arr[1+1] := (input[1+1])->toInteger() ; 
    arr[2+1] := (input[2+1])->toInteger() ; 
    arr[3+1] := (input[3+1])->toInteger() ; 
    var largest : int ; largest := arr[0+1] ;
    var middle : int ; middle := arr[1+1] ;
    var smallest : int ; smallest := arr[2+1] ;
    var marsha : int ; marsha := arr[3+1] ;
    if (smallest > marsha * 2) then     OclFile["System.out"].println(-1) else     if (marsha > smallest * 2) then     OclFile["System.out"].println(-1) else     if (marsha >= middle) then     OclFile["System.out"].println(-1) else (     OclFile["System.out"].println((largest * 2) + "\n" + (middle * 2) + "\n" + Set{smallest, marsha}->max()) ) ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class mAndBears {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int sizeB=in.nextInt();
    int sizeMo=in.nextInt();
    int sizeS=in.nextInt();
    int sizeMa=in.nextInt();
    in.close();
    int carB=0,carMo=0,carS=0 ;
    boolean possible=false ;
    for(int i=sizeS ; i<=sizeS*2 ; i++){
      if(sizeMa<=i &&(2*sizeMa)>=i){
        carS=i ;
        possible=true ;
        break ;
      }
    }
    if(possible){
      for(int i=sizeMo ; i<=sizeMo*2 ; i++){
        if(i>(carS*2)){
          carMo=i ;
          possible=true ;
          break ;
        }
        else {
          possible=false ;
        }
      }
    }
    if(possible){
      for(int i=sizeB ; i<=sizeB*2 ; i++){
        if(i>carMo){
          carB=i ;
          possible=true ;
          break ;
        }
        else {
          possible=false ;
        }
      }
    }
    if(possible){
      System.out.println(carB+"\n"+carMo+"\n"+carS);
    }
    else {
      System.out.println("-1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class mAndBears {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sizeB : int ; sizeB := in.getCurrent()->toInteger() ;
    var sizeMo : int ; sizeMo := in.getCurrent()->toInteger() ;
    var sizeS : int ; sizeS := in.getCurrent()->toInteger() ;
    var sizeMa : int ; sizeMa := in.getCurrent()->toInteger() ;
    skip ; 
    var carB : int ; carB := 0 ;
    var carMo : int ; carMo := 0 ;
    var carS : int ; carS := 0 ;
    var possible : boolean ; possible := false ;
        var i : int ; i := sizeS ; while i <= sizeS * 2 do ( (     if (sizeMa <= i & (2 * sizeMa) >= i) then (     carS := i ; 
     possible := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (possible) then (         var i : int ; i := sizeMo ; while i <= sizeMo * 2 do ( (     if (i > (carS * 2)) then (     carMo := i ; 
     possible := true ; 
     break ) else (     possible := false ) )  ;     i := i + 1 ) ) else skip ; 
    if (possible) then (         var i : int ; i := sizeB ; while i <= sizeB * 2 do ( (     if (i > carMo) then (     carB := i ; 
     possible := true ; 
     break ) else (     possible := false ) )  ;     i := i + 1 ) ) else skip ; 
    if (possible) then (     OclFile["System.out"].println(carB + "\n" + carMo + "\n" + carS) ) else (     OclFile["System.out"].println("-1") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(f.readLine());
    int big=Integer.parseInt(st.nextToken());
    int med=Integer.parseInt(st.nextToken());
    int sma=Integer.parseInt(st.nextToken());
    int masha=Integer.parseInt(st.nextToken());
    if(masha>sma*2 || masha*2<sma || masha>=med){
      System.out.println(-1);
    }
    else {
      System.out.println(big*2);
      System.out.println(med*2);
      if(masha<sma){
        System.out.println(sma);
      }
      else {
        System.out.println(sma*2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
    var big : int ; big := (st.next())->toInteger() ;
    var med : int ; med := (st.next())->toInteger() ;
    var sma : int ; sma := (st.next())->toInteger() ;
    var masha : int ; masha := (st.next())->toInteger() ;
    if (masha > sma * 2 or masha * 2 < sma or masha >= med) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(big * 2) ; 
     OclFile["System.out"].println(med * 2) ; 
     if (masha < sma) then (     OclFile["System.out"].println(sma) ) else (     OclFile["System.out"].println(sma * 2) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static StringBuilder sb=new StringBuilder();
  public static void main(String args[]){
    int n,m ;
    Scanner s=new Scanner(System.in);
    n=s.nextInt();
    m=s.nextInt();
    int ci[]=new int[n+1];
    int ti[]=new int[n+1];
    int songDuration[]=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      ci[i]=s.nextInt();
      ti[i]=s.nextInt();
      songDuration[i]=ci[i]*ti[i];
    }
    for(int i=1 ; i<=n ; i++){
      songDuration[i]=songDuration[i]+songDuration[i-1];
    }
    for(int i=1 ; i<=m ; i++){
      int target=s.nextInt();
      int si=1 ;
      int ei=n ;
      int ans=-1 ;
      while(si<=ei){
        int mid=si+(ei-si)/2 ;
        if(songDuration[mid]>=target){
          ei=mid-1 ;
          ans=mid ;
        }
        else {
          si=mid+1 ;
        }
      }
      sb.append(ans).append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sb : String := StringLib.newString();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var m : int ;
     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := s.getCurrent()->toInteger() ; 
    m := s.getCurrent()->toInteger() ; 
    var ci : Sequence(int) ; ci := Integer.subrange(1,n + 1)->collect(0) ;
    var ti : Sequence(int) ; ti := Integer.subrange(1,n + 1)->collect(0) ;
    var songDuration : Sequence(int) ; songDuration := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     ci[i+1] := s.getCurrent()->toInteger() ; 
     ti[i+1] := s.getCurrent()->toInteger() ; 
     songDuration[i+1] := ci[i+1] * ti[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     songDuration[i+1] := songDuration[i+1] + songDuration[i - 1+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= m do ( (     var target : int ; target := s.getCurrent()->toInteger() ;
     var si : int ; si := 1 ;
    var ei : int ; ei := n ;
    var ans : int ; ans := -1 ;
    while (si <= ei) do (     var mid : int ; mid := si + (ei - si) / 2 ;
     if (songDuration[mid+1] >= target) then (     ei := mid - 1 ; 
     ans := mid ) else (     si := mid + 1 ) ) ; 
    sb := sb + StringLib.newString(ans) + StringLib.newString("\n") ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    System.out.println(Math.min(n*a,b));
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(Set{n * a, b}->min()) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static StringBuilder sb=new StringBuilder();
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    long song_for_how_many_minutes[]=new long[n+1];
    long t[]=new long[n+1];
    long c[]=new long[n+1];
    long time_stamp[]=new long[m];
    for(int i=1 ; i<=n ; i++){
      c[i]=sc.nextLong();
      t[i]=sc.nextLong();
    }
    for(int i=1 ; i<=n ; i++){
      song_for_how_many_minutes[i]=song_for_how_many_minutes[i-1]+c[i]*t[i];
    }
    for(int i=0 ; i<m ; i++){
      time_stamp[i]=sc.nextLong();
      long target=time_stamp[i];
      int s=1 ;
      int e=song_for_how_many_minutes.length ;
      int ans=-1 ;
      while(s<=e){
        int mid=(s+e)/2 ;
        if(song_for_how_many_minutes[mid]<target){
          s=mid+1 ;
        }
        else {
          ans=mid ;
          e=mid-1 ;
        }
      }
      sb.append(ans).append("\n");
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sb : String := StringLib.newString();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var song_for_how_many_minutes : Sequence(long) ; song_for_how_many_minutes := Integer.subrange(1,n + 1)->collect(0) ;
    var t : Sequence(long) ; t := Integer.subrange(1,n + 1)->collect(0) ;
    var c : Sequence(long) ; c := Integer.subrange(1,n + 1)->collect(0) ;
    var time_stamp : Sequence(long) ; time_stamp := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     c[i+1] := sc.getCurrent()->toLong() ; 
     t[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     song_for_how_many_minutes[i+1] := song_for_how_many_minutes[i - 1+1] + c[i+1] * t[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     time_stamp[i+1] := sc.getCurrent()->toLong() ; 
     var target : long ; target := time_stamp[i+1] ;
    var s : int ; s := 1 ;
    var e : int ; e := song_for_how_many_minutes->size() ;
    var ans : int ; ans := -1 ;
    while (s <= e) do (     var mid : int ; mid := (s + e) / 2 ;
     if (song_for_how_many_minutes[mid+1] < target) then (     s := mid + 1 ) else (     ans := mid ; 
     e := mid - 1 ) ) ; 
    sb := sb + StringLib.newString(ans) + StringLib.newString("\n") ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int[] time=new int[n];
    int[] times=new int[n];
    for(int i=0 ; i<n ; i++){
      time[i]=in.nextInt();
      times[i]=in.nextInt();
    }
    int[] ftime=new int[m];
    for(int i=0 ; i<m ; i++){
      ftime[i]=in.nextInt();
    }
    int index=1 ;
    int stime=time[0]*times[0];
    for(int i=0 ; i<m ; i++){
      if(ftime[i]<=stime){
        System.out.println(index);
      }
      else {
        stime+=time[index]*times[index];
        index++;
        i--;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var time : Sequence(int) ; time := Integer.subrange(1,n)->collect(0) ;
    var times : Sequence(int) ; times := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     time[i+1] := in.getCurrent()->toInteger() ; 
     times[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ftime : Sequence(int) ; ftime := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     ftime[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var index : int ; index := 1 ;
    var stime : int ; stime := time[0+1] * times[0+1] ;
        var i : int ; i := 0 ; while i < m do ( (     if (ftime[i+1] <= stime) then (     OclFile["System.out"].println(index) ) else (     stime := stime+(time[index+1] * times[index+1]) ; 
     index := index + 1 ; 
     i := i - 1 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class fibonacci {
  static int fib(int n){
    int f[]=new int[n+2];
    int i ;
    f[0]=0 ;
    f[1]=1 ;
    for(i=2 ; i<=n ; i++){
      f[i]=f[i-1]+f[i-2];
    }
    return f[n];
  }
  public static void main(String args[]){
    int n=9 ;
    System.out.println(fib(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class fibonacci {
  static   operation fib( n : int) : int
  pre: true
  post: true
  activity: (     var f : Sequence(int) ; f := Integer.subrange(1,n + 2)->collect(0) ;
     var i : int ;
    f[0+1] := 0 ; 
    f[1+1] := 1 ; 
        i := 2 ; while i <= n do ( (     f[i+1] := f[i - 1+1] + f[i - 2+1] )  ;     i := i + 1 ) ; 
    return f[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     OclFile["System.out"].println(fib(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=1000 ;
  static int f[];
  public static int fib(int n){
    if(n==0)return 0 ;
    if(n==1 || n==2)return(f[n]=1);
    if(f[n]!=0)return f[n];
    int k=(n & 1)==1 ?(n+1)/2 : n/2 ;
    f[n]=(n & 1)==1 ?(fib(k)*fib(k)+fib(k-1)*fib(k-1)):(2*fib(k-1)+fib(k))*fib(k);
    return f[n];
  }
  public static void main(String[] args){
    int n=9 ;
    f=new int[MAX];
    System.out.println(fib(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 1000;
  static   attribute f : Sequence(int);
  static   operation fib( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else skip ; 
     if (n = 1 or n = 2) then     return (f[n+1]) else skip ; 
    if (f[n+1] /= 0) then     return f[n+1] else skip ; 
    var k : int ; k := if (MathLib.bitwiseAnd(n,1)) = 1 then (n + 1) / 2 else n / 2 endif ;
    f[n+1] := if (n & 1) = 1 then (fib(k) * fib(k) + fib(k - 1) * fib(k - 1)) else (2 * fib(k - 1) + fib(k)) * fib(k) endif ; 
    return f[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     f := Integer.subrange(1,MAX)->collect(0) ; 
     OclFile["System.out"].println(fib(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.*;
import java.awt.geom.*;
import java.io.*;
import java.util.*;
class Main {
  static int[][] map ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int minN=n ;
    int maxN=n ;
    while(true){
      boolean mnN=check(minN);
      boolean mxN=check(maxN);
      if(mnN){
        System.out.println(minN);
        break ;
      }
      if(mxN){
        System.out.println(maxN);
        break ;
      }
      minN--;
      maxN++;
    }
  }
  static boolean check(int a){
    char[] A=String.valueOf(a).toCharArray();
    char[] B=new char[A.length];
    for(int i=0 ; i<A.length ; i++){
      B[i]=A[A.length-i-1];
    }
    int b=Integer.parseInt(String.valueOf(B));
    return a==b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute map : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var minN : int ; minN := n ;
    var maxN : int ; maxN := n ;
    while (true) do (     var mnN : boolean ; mnN := check(minN) ;
     var mxN : boolean ; mxN := check(maxN) ;
    if (mnN) then (     OclFile["System.out"].println(minN) ; 
     break ) else skip ; 
    if (mxN) then (     OclFile["System.out"].println(maxN) ; 
     break ) else skip ; 
    minN := minN - 1 ; 
    maxN := maxN + 1 ; 
 ) ; 
 );
  static   operation check( a : int) : boolean
  pre: true
  post: true
  activity: (     var A : Sequence(String) ; A := ((a) + "")->characters() ;
     var B : Sequence(String) ; B := Integer.subrange(1,A->size())->collect(0) ;
        var i : int ; i := 0 ; while i < A->size() do ( (     B[i+1] := A[A->size() - i - 1+1] )  ;     i := i + 1 ) ; 
    var b : int ; b := ((B)->sum() )->toInteger() ;
    return a = b 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner rand=new Scanner(System.in);
    long n=rand.nextLong();
    System.out.println(solve(n));
  }
  static int solve(long n){
    int[] sum=String.valueOf(n).chars().map(ch->ch-'0').toArray();
    for(int i=0 ; i<sum.length-1 ; i++){
      sum[i]--;
      sum[i+1]+=10 ;
    }
    for(int i=sum.length-1 ; i>=1 ; i--){
      if(sum[i]==19){
        sum[i]-=10 ;
        sum[i-1]++;
      }
    }
    return Arrays.stream(sum).sum();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var rand : OclFile ; rand := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := rand.getCurrent()->toLong() ;
     OclFile["System.out"].println(solve(n)) );
  static   operation solve( n : long) : int
  pre: true
  post: true
  activity: (     var sum : Sequence(int) ; sum := ((n) + "").chars()->collect( _x1 | (lambda ch : OclAny in ch - ('0')->char2byte())->apply(_x1) )->asSequence() ;
         var i : int ; i := 0 ; while i < sum->size() - 1 do ( (     sum[i+1] := sum[i+1] - 1 ; 
     sum[i + 1+1] := sum[i + 1+1]+(10) )  ;     i := i + 1 ) ; 
         var i : int ; i := sum->size() - 1 ; while i >= 1 do ( (     if (sum[i+1] = 19) then (     sum[i+1] := sum[i+1]-(10) ; 
     sum[i - 1+1] := sum[i - 1+1] + 1 ) else skip )  ;     i := i - 1 ) ; 
     return stream(sum)->sum() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  static boolean[] palindrom=new boolean[10002];
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    for(int i=0 ; i<=9 ; i++){
      palindrom[i]=true ;
      palindrom[i*10+i]=true ;
    }
    for(int i=1 ; i<=9 ; i++){
      int p=i*101 ;
      palindrom[p]=true ;
      for(int j=0 ; j<=9 ; j++){
        int q=p+j*10 ;
        palindrom[q]=true ;
      }
    }
    for(int i=1 ; i<=9 ; i++){
      int p=i*1001 ;
      palindrom[p]=true ;
      for(int j=0 ; j<=9 ; j++){
        int q=p+j*100+j*10 ;
        palindrom[q]=true ;
      }
    }
    palindrom[10001]=true ;
    int n=parseInt(br.readLine());
    int ans=0 ;
    for(int i=0 ; ; i++){
      if(palindrom[n-i]){
        ans=n-i ;
        break ;
      }
      if(palindrom[n+i]){
        ans=n+i ;
        break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute palindrom : Sequence(boolean) := Integer.subrange(1,10002)->collect(false);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
        var i : int ; i := 0 ; while i <= 9 do ( (     palindrom[i+1] := true ; 
     palindrom[i * 10 + i+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 9 do ( (     var p : int ; p := i * 101 ;
     palindrom[p+1] := true ; 
         var j : int ; j := 0 ; while j <= 9 do ( (     var q : int ; q := p + j * 10 ;
     palindrom[q+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 9 do ( (     var p : int ; p := i * 1001 ;
     palindrom[p+1] := true ; 
         var j : int ; j := 0 ; while j <= 9 do ( (     var q : int ; q := p + j * 100 + j * 10 ;
     palindrom[q+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    palindrom[10001+1] := true ; 
    var n : int ; n := parseInt(br.readLine()) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while true do ( (     if (palindrom[n - i+1]) then (     ans := n - i ; 
     break ) else skip ; 
     if (palindrom[n + i+1]) then (     ans := n + i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  int n ;
  void run(){
    n=sc.nextInt();
    solve();
  }
  void solve(){
    for(int i=0 ; ; i++){
      String s=(n-i)+"" ;
      if(n-i>=0 && new StringBuilder(s).reverse().toString().equals(s)){
        println(s);
        return ;
      }
      s=(n+i)+"" ;
      if(new StringBuilder(s).reverse().toString().equals(s)){
        println(s);
        return ;
      }
    }
  }
  void println(String s){
    System.out.println(s);
  }
  void debug(Object...os){
    System.err.println(deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute n : int;
   operation run() : void
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
     execute solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while true do ( (     var s : String ; s := (n - i) + "" ;
     if (n - i >= 0 & StringLib.newString(s)->reverse()+"" = s) then (     execute println(s) ; 
     return ) else skip ; 
     s := (n + i) + "" ; 
     if (StringLib.newString(s)->reverse()+"" = s) then (     execute println(s) ; 
     return ) else skip )  ;     i := i + 1 ) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.Scanner ;
import java.util.TreeSet ;
import javax.print.attribute.standard.MediaSize.Other ;
import javax.xml.bind.ParseConversionEvent ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    ArrayList<Integer>palind=new ArrayList<Integer>();
    for(int i=0 ; i<=9 ; i++){
      palind.add(i);
    }
    for(int i=0 ; i<=10 ; i++){
      for(int pre=1 ; pre<=100 ; pre++){
        String p_=pre+"" ;
        StringBuilder sb=new StringBuilder();
        sb.append(p_);
        sb.reverse();
        palind.add(Integer.parseInt(pre+(i==10 ? "" : i+"")+sb.toString()));
      }
    }
    Collections.sort(palind);
    final int n=sc.nextInt();
    int b_search=Collections.binarySearch(palind,n);
    if(b_search>=0){
      System.out.println(n);
      return ;
    }
    int first=-(b_search+1);
    int second=-(b_search+2);
    if(second<0){
      System.out.println(palind.get(first));
    }
    else {
      if(Math.abs(n-palind.get(first))<Math.abs(n-palind.get(second))){
        System.out.println(palind.get(first));
      }
      else {
        System.out.println(palind.get(second));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var palind : Sequence(int) ; palind := Sequence{} ;
        var i : int ; i := 0 ; while i <= 9 do ( (     palind := palind->including(i) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= 10 do ( (         var pre : int ; pre := 1 ; while pre <= 100 do ( (     var p_ : String ; p_ := pre + "" ;
     var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString(p_) ; 
    sb := sb->reverse() ; 
    palind := palind->including((pre + (if i = 10 then "" else i + "" endif) + sb+"")->toInteger()) ; 
 )  ;     pre := pre + 1 ) )  ;     i := i + 1 ) ; 
    palind := palind->sort() ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var b_search : int ; b_search := .binarySearch(palind, n) ;
    if (b_search >= 0) then (     OclFile["System.out"].println(n) ; 
     return ) else skip ; 
    var first : int ; first := -(b_search + 1) ;
    var second : int ; second := -(b_search + 2) ;
    if (second < 0) then (     OclFile["System.out"].println(palind->at(first+1)) ) else (     if (if (n)->char2byte() - palind->at(first+1) < 0 then -((n)->char2byte() - palind->at(first+1)) else (n)->char2byte() - palind->at(first+1) endif < if (n)->char2byte() - palind->at(second+1) < 0 then -((n)->char2byte() - palind->at(second+1)) else (n)->char2byte() - palind->at(second+1) endif) then (     OclFile["System.out"].println(palind->at(first+1)) ) else (     OclFile["System.out"].println(palind->at(second+1)) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] a=new int[2];
    int x=sc.nextInt();
    sc.close();
    if(isH(x)){
      System.out.println(x);
      System.exit(0);
    }
    else {
      for(int i=x-1 ; i>=0 ; i--){
        if(isH(i)){
          a[0]=i ;
          break ;
        }
      }
      for(int i=x+1 ; i<15000 ; i++){
        if(isH(i)){
          a[1]=i ;
          break ;
        }
      }
    }
    if((Math.abs(a[0]-x))>(Math.abs(a[1]-x))){
      System.out.println(a[1]);
    }
    else if((Math.abs(a[0])-x)==(Math.abs(a[1])-x)){
      System.out.println(min(a[0],a[1]));
    }
    else {
      System.out.println(a[0]);
    }
  }
  static boolean isH(int x){
    int sum=0 ;
    int a=0 ;
    int x1=x ;
    while(x!=0){
      a=x % 10 ;
      sum=sum*10+a ;
      x/=10 ;
    }
    if(x1==sum)return true ;
    return false ;
  }
  static int min(int x,int y){
    if(x>y)return y ;
    return x ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,2)->collect(0) ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    skip ; 
    if (isH(x)) then (     OclFile["System.out"].println(x) ; 
 OclProcess.exit(0) ) else (         var i : int ; i := x - 1 ; while i >= 0 do ( (     if (isH(i)) then (     a[0+1] := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
         var i : int ; i := x + 1 ; while i < 15000 do ( (     if (isH(i)) then (     a[1+1] := i ; 
     break ) else skip )  ;     i := i + 1 ) ) ;  
    if ((if a[0+1] - x < 0 then -(a[0+1] - x) else a[0+1] - x endif) > (if a[1+1] - x < 0 then -(a[1+1] - x) else a[1+1] - x endif)) then (     OclFile["System.out"].println(a[1+1]) ) else     if ((if a[0+1] < 0 then -(a[0+1]) else a[0+1] endif - x) = (if a[1+1] < 0 then -(a[1+1]) else a[1+1] endif - x)) then (     OclFile["System.out"].println(Set{a[0+1], a[1+1]}->min()) ) else (     OclFile["System.out"].println(a[0+1]) ) ;  ;  
 );
  static   operation isH( x : int) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var a : int ; a := 0 ;
    var x1 : int ; x1 := x ;
    while (x /= 0) do (     a := x mod 10 ; 
     sum := sum * 10 + a ; 
     x := x/(10) ) ; 
    if (x1 = sum) then     return true else skip ; 
    return false 
 );
  static   operation min( x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (x > y) then     return y else skip ; 
     return x );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static void removeDuplicates(int[] arr){
    LinkedHashSet<Integer>set=new LinkedHashSet<Integer>();
    for(int i=0 ; i<arr.length ; i++)set.add(arr[i]);
    System.out.print(set);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,5,1,7,2,4,2 };
      removeDuplicates(arr);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation removeDuplicates( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var set : Set(int) ; set := Set{} ;
         var i : int ; i := 0 ; while i < arr->size() do (     set := set->including(arr[i+1]) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(set) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,5,1,7,2,4,2} ;
     execute removeDuplicates(arr) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    resolve(System.in,System.out);
  }
  static void resolve(InputStream is,PrintStream pw){
    Scanner sc=new Scanner(is);
    int n=Integer.parseInt(sc.next());
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    int train=a*n ;
    int taxi=b ;
    pw.println(Math.min(train,taxi));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute resolve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation resolve( is : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(is) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var a : int ; a := (sc.getCurrent())->toInteger() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    var train : int ; train := a * n ;
    var taxi : int ; taxi := b ;
    pw.println(Set{train, taxi}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minOperations(int n,int m){
    int a=0,k=1 ;
    int p=Math.max(n,m);
    while(n!=m){
      float s=(float)(p-n+p-m);
      float q=(float)((-1+Math.sqrt(8*s+1))/2);
      if(q-Math.floor(q)==0){
        a=(int)q ;
        n=m ;
      }
      p=p+1 ;
    }
    return a ;
  }
  public static void main(String[] args){
    int n=1,m=3 ;
    System.out.print(minOperations(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minOperations( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var a : int ; a := 0 ;
    var k : int ; k := 1 ;
     var p : int ; p := Set{n, m}->max() ;
     while (n /= m) do (     var s : double ; s := (p - n + p - m)->oclAsType(double) ;
     var q : double ; q := ((-1 + (8 * s + 1)->sqrt()) / 2)->oclAsType(double) ;
     if (q - (q)->floor() = 0) then (     a := q->oclAsType(int) ; 
     n := m ) else skip ; 
     p := p + 1 ) ; 
     return a );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1 ;
    var m : int ; m := 3 ;
     OclFile["System.out"].print(minOperations(n, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isVowel(char x){
    x=Character.toLowerCase(x);
    return(x=='a' || x=='e' || x=='i' || x=='o' || x=='u');
  }
  static String longestVowelSubsequence(String str){
    String answer="" ;
    int n=str.length();
    for(int i=0 ; i<n ; i++){
      if(isVowel(str.charAt(i))){
        answer+=str.charAt(i);
      }
    }
    return answer ;
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    System.out.print(longestVowelSubsequence(str)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isVowel( x : String) : boolean
  pre: true
  post: true
  activity: (     x := (x + "")->toLowerCase() ; 
     return (x = 'a' or x = 'e' or x = 'i' or x = 'o' or x = 'u') );
  static   operation longestVowelSubsequence( str : String) : String
  pre: true
  post: true
  activity: (     var answer : String ; answer := "" ;
     var n : int ; n := str->size() ;
         var i : int ; i := 0 ; while i < n do ( (     if (isVowel(str->at(i+1))) then (     answer := answer+(str->at(i+1)) ) else skip )  ;     i := i + 1 ) ; 
     return answer );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     OclFile["System.out"].print(longestVowelSubsequence(str) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s="" ;
    int n=0 ;
    int t=0 ;
    while(sc.hasNext()){
      s=sc.nextLine();
      if(s.startsWith("+")){
        n++;
      }
      else if(s.startsWith("-")){
        n--;
      }
      else {
        String document=s.substring(s.lastIndexOf(":")+1);
        t+=(n*document.length());
      }
    }
    System.out.println(t);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := "" ;
    var n : int ; n := 0 ;
    var t : int ; t := 0 ;
    while (sc.hasNext()) do (     s := sc.nextLine() ; 
     if (s->hasPrefix("+")) then (     n := n + 1 ) else     if (s->hasPrefix("-")) then (     n := n - 1 ) else (     var document : String ; document := s.subrange(s->lastIndexOf(":")-1 + 1+1,s->lastIndexOf(":")-1 + 1) ;
     t := t+((n * document->size())) ) ;  ) ; 
    OclFile["System.out"].println(t) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class max_sum {
  public static void main(String args[]){
    long s1,s2=0 ;
    long k=0 ;
    long n=0 ;
    int c=0 ;
    long sum=0 ;
    Scanner in=new Scanner(System.in);
    n=in.nextLong();
    k=n ;
    while(k>=1){
      c++;
      k=k/10 ;
    }
    for(int i=0 ; i<c-1 ; i++){
      s2=s2*10+9 ;
    }
    s1=n-s2 ;
    while(s1>=1){
      sum=sum+(s1 % 10);
      s1=s1/10 ;
    }
    while(s2>=1){
      sum=sum+(s2 % 10);
      s2=s2/10 ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class max_sum {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : long ;
    var s2 : long ; s2 := 0 ;
     var k : long ; k := 0 ;
    var n : long ; n := 0 ;
    var c : int ; c := 0 ;
    var sum : long ; sum := 0 ;
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := in.getCurrent()->toLong() ; 
    k := n ; 
    while (k >= 1) do (     c := c + 1 ; 
     k := k / 10 ) ; 
        var i : int ; i := 0 ; while i < c - 1 do ( (     s2 := s2 * 10 + 9 )  ;     i := i + 1 ) ; 
    s1 := n - s2 ; 
    while (s1 >= 1) do (     sum := sum + (s1 mod 10) ; 
     s1 := s1 / 10 ) ; 
    while (s2 >= 1) do (     sum := sum + (s2 mod 10) ; 
     s2 := s2 / 10 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedWriter ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.util.Scanner ;
public class Chat_Server_Outgoing_Traffic {
  public static void main(String[] args)throws IOException {
    Scanner scan=new Scanner(System.in);
    int users=0 ;
    int totalLength=0 ;
    while(scan.hasNextLine()){
      String line=scan.nextLine();
      if(line.charAt(0)=='+'){
        users++;
      }
      else if(line.charAt(0)=='-'){
        users--;
      }
      else {
        int temp=line.length()-(line.indexOf(':')+1);
        totalLength+=temp*users ;
      }
    }
    System.out.println(totalLength);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Chat_Server_Outgoing_Traffic {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var users : int ; users := 0 ;
    var totalLength : int ; totalLength := 0 ;
    while (scan.hasNextLine()) do (     var line : String ; line := scan.nextLine() ;
     if (line->at(0+1) = '+') then (     users := users + 1 ) else     if (line->at(0+1) = '-') then (     users := users - 1 ) else (     var temp : int ; temp := line->size() - (line->indexOf(':')-1 + 1) ;
     totalLength := totalLength+(temp * users) ) ;  ) ; 
    OclFile["System.out"].println(totalLength) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem5A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    final String END_INPUT="*" ;
    byte countCommands=0 ;
    byte countUsers=0 ;
    int totalBytes=0 ;
    while(scanner.hasNextLine()&& countCommands<=100){
      String command=scanner.nextLine();
      if(command.equals(END_INPUT))break ;
      countCommands++;
      if(command.startsWith("+"))countUsers++;
      else if(command.startsWith("-"))countUsers--;
      else {
        int colonIndex=command.indexOf(":");
        totalBytes+=(command.length()-colonIndex-1)*countUsers ;
      }
    }
    System.out.print(totalBytes);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem5A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var END_INPUT : String ; END_INPUT := "*" ;
    var countCommands : int ; countCommands := 0 ;
    var countUsers : int ; countUsers := 0 ;
    var totalBytes : int ; totalBytes := 0 ;
    while (scanner.hasNextLine() & countCommands <= 100) do (     var command : String ; command := scanner.nextLine() ;
     if (command = END_INPUT) then     break else skip ; 
     countCommands := countCommands + 1 ; 
     if (command->hasPrefix("+")) then     countUsers := countUsers + 1 ; else     if (command->hasPrefix("-")) then     countUsers := countUsers - 1 else (     var colonIndex : int ; colonIndex := command->indexOf(":")-1 ;
     totalBytes := totalBytes+((command->size() - (colonIndex)->char2byte() - 1) * countUsers) ) ;  ) ; 
    OclFile["System.out"].print(totalBytes) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem5A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    byte countCommands=0 ;
    byte countUsers=0 ;
    int totalBytes=0 ;
    while(scanner.hasNextLine()&& countCommands<=100){
      String command=scanner.nextLine();
      countCommands++;
      if(command.startsWith("+"))countUsers++;
      else if(command.startsWith("-"))countUsers--;
      else {
        int colonIndex=command.indexOf(":");
        totalBytes+=(command.length()-colonIndex-1)*countUsers ;
      }
    }
    System.out.print(totalBytes);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem5A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var countCommands : int ; countCommands := 0 ;
    var countUsers : int ; countUsers := 0 ;
    var totalBytes : int ; totalBytes := 0 ;
    while (scanner.hasNextLine() & countCommands <= 100) do (     var command : String ; command := scanner.nextLine() ;
     countCommands := countCommands + 1 ; 
     if (command->hasPrefix("+")) then     countUsers := countUsers + 1 ; else     if (command->hasPrefix("-")) then     countUsers := countUsers - 1 else (     var colonIndex : int ; colonIndex := command->indexOf(":")-1 ;
     totalBytes := totalBytes+((command->size() - (colonIndex)->char2byte() - 1) * countUsers) ) ;  ) ; 
    OclFile["System.out"].print(totalBytes) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
import java.io.*;
public class CodeforcesB {
  public void solve()throws IOException {
    FastScanner fs=new FastScanner();
    StringBuilder ans=new StringBuilder("");
    long n=fs.nextLong(),d=fs.nextLong(),m=fs.nextLong(),l=fs.nextLong();
    long x=0 ;
    while(x*d<=(n-1)*m+l){
      long h=x*d % m ;
      if(h>l)break ;
      x+=(l-h)/d+1 ;
    }
    ans.append(x*d);
    System.out.println(ans);
  }
  public static void main(String[] args)throws IOException {
    try {
      new CodeforcesB().solve();
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeforcesB {
   operation solve() : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var ans : String ; ans := StringLib.newString("") ;
    var n : long ; n := fs.nextLong() ;
    var d : long ; d := fs.nextLong() ;
    var m : long ; m := fs.nextLong() ;
    var l : long ; l := fs.nextLong() ;
    var x : long ; x := 0 ;
    while (x * d <= ((n)->char2byte() - 1) * m + l) do (     var h : long ; h := x * d mod m ;
     if (h > l) then     break else skip ; 
     x := x+(((l)->char2byte() - h) / d + 1) ) ; 
    ans := ans + StringLib.newString(x * d) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     CodeforcesB.newCodeforcesB().solve() )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CodeForces18B {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    long n=input.nextInt();
    long d=input.nextInt();
    long m=input.nextInt();
    long l=input.nextInt();
    for(int i=1 ; i<=n ; i++){
      long s1=(i-1)*m+l ;
      long s2=i*m ;
      long s3=(s1/d)*d+d ;
      if(i==n || s3<s2){
        System.out.println(s3);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces18B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := input.getCurrent()->toInteger() ;
    var d : long ; d := input.getCurrent()->toInteger() ;
    var m : long ; m := input.getCurrent()->toInteger() ;
    var l : long ; l := input.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= n do ( (     var s1 : long ; s1 := (i - 1) * m + l ;
     var s2 : long ; s2 := i * m ;
     var s3 : long ; s3 := (s1 / d) * d + d ;
     if (i = n or s3 < s2) then (     OclFile["System.out"].println(s3) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class B18 {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    int d=Integer.parseInt(st.nextToken());
    int m=Integer.parseInt(st.nextToken());
    int l=Integer.parseInt(st.nextToken());
    long start=0 ;
    long end=l ;
    long pos=(end/d)*d ;
    for(int i=1 ; i<n ; i++){
      start+=m ;
      end+=m ;
      if(pos+d<start){
        System.out.println(pos+d);
        return ;
      }
      pos=(end/d)*d ;
    }
    System.out.println(pos+d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B18 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var d : int ; d := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var l : int ; l := (st.next())->toInteger() ;
    var start : long ; start := 0 ;
    var end : long ; end := l ;
    var pos : long ; pos := (end / d) * d ;
        var i : int ; i := 1 ; while i < n do ( (     start := start+(m) ; 
     end := end+(m) ; 
     if (pos + d < start) then (     OclFile["System.out"].println(pos + d) ; 
     return ) else skip ; 
     pos := (end / d) * d )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(pos + d) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner scan=new Scanner(System.in);
    int num=scan.nextInt();
    int train=scan.nextInt();
    int taxi=scan.nextInt();
    if(num*train<taxi){
      System.out.println(num*train);
    }
    else if(num*train>taxi){
      System.out.println(taxi);
    }
    else {
      System.out.println(taxi);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := scan.getCurrent()->toInteger() ;
    var train : int ; train := scan.getCurrent()->toInteger() ;
    var taxi : int ; taxi := scan.getCurrent()->toInteger() ;
    if (num * train < taxi) then (     OclFile["System.out"].println(num * train) ) else     if (num * train > taxi) then (     OclFile["System.out"].println(taxi) ) else (     OclFile["System.out"].println(taxi) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long n=in.nextLong(),m=in.nextLong(),ans=0 ;
    char[] a=new char[(int)(n+1)],b=new char[(int)(n+1)];
    String s1=in.next();
    String s2=in.next();
    for(int i=1 ; i<=n ; i++){
      a[i]=s1.charAt(i-1);
      b[i]=s2.charAt(i-1);
    }
    long sum=-1 ;
    int t=1 ;
    while(t<=n && a[t]==b[t]){
      t++;
      ans++;
    }
    int f=1 ;
    for(int i=t ; i<=n && f==1 ; i++){
      sum=sum*2+(int)('b'-a[i])+(int)(b[i]-'a');
      if(sum+2>=m){
        ans+=(n-i+1)*m ;
        f=0 ;
      }
      else ans+=sum+2 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toLong() ;
    var m : long ; m := in.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
    var a : Sequence(String) ; a := Integer.subrange(1,(n + 1)->oclAsType(int))->collect(0) ;
    var b : Sequence(String) ; b := Integer.subrange(1,(n + 1)->oclAsType(int))->collect(0) ;
    var s1 : String ; s1 := in.getCurrent() ;
    var s2 : String ; s2 := in.getCurrent() ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := s1->at((i)->char2byte() - 1+1) ; 
     b[i+1] := s2->at((i)->char2byte() - 1+1) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := -1 ;
    var t : int ; t := 1 ;
    while (t <= n & a[t+1] = b[t+1]) do (     t := t + 1 ; 
     ans := ans + 1 ) ; 
    var f : int ; f := 1 ;
        var i : int ; i := t ; while i <= n & f = 1 do ( (     sum := sum * 2 + (('b')->char2byte() - a[i+1])->oclAsType(int) + (b[i+1] - ('a')->char2byte())->oclAsType(int) ; 
     if (sum + 2 >= m) then (     ans := ans+((n - (i)->char2byte() + 1) * m) ; 
     f := 0 ) else     ans := ans+(sum + 2) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
import java.io.StreamTokenizer ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=ini();
    int k=ini();
    char a[]=ins().toCharArray();
    char b[]=ins().toCharArray();
    long ans=0 ;
    long w=1 ;
    for(int i=0 ; i<n ; i++){
      w=w<<1 ;
      if(a[i]=='b')w--;
      if(b[i]=='a')w--;
      if(w>1000000000)w=1000000000 ;
      ans+=Math.min(w,k);
    }
    out.print(ans);
    out.flush();
  }
  static StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
  static PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  static int ini()throws IOException {
    in.nextToken();
    return(int)in.nval ;
  }
  static String ins()throws IOException {
    in.nextToken();
    return in.sval ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := ini() ;
    var k : int ; k := ini() ;
    var a : Sequence(String) ; a := ins()->characters() ;
    var b : Sequence(String) ; b := ins()->characters() ;
    var ans : long ; ans := 0 ;
    var w : long ; w := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     w := (w*(2->pow(1)))->oclAsType(long) ; 
     if (a[i+1] = 'b') then     w := w - 1 ; else skip ; 
    if (b[i+1] = 'a') then     w := w - 1 ; else skip ; 
    if (w > 1000000000) then     w := 1000000000 ; else skip ; 
    ans := ans+(Set{w, k}->min()) ; 
 )  ;     i := i + 1 ) ; 
    out.print(ans) ; 
    out.flush() ; 
 );
  static   attribute in : StreamTokenizer := StreamTokenizer.newStreamTokenizer(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])));
  static   operation ini() : int
  pre: true
  post: true
  activity: (     in.next() ; 
     return in.nval->oclAsType(int) );
  static   operation ins() : String
  pre: true
  post: true
  activity: (     in.next() ; 
     return in.sval );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
import java.io.StreamTokenizer ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=ini();
    int k=ini();
    char a[]=ins().toCharArray();
    char b[]=ins().toCharArray();
    long ans=0 ;
    long w=1 ;
    for(int i=0 ; i<n ; i++){
      w=w<<1 ;
      if(a[i]=='b')w--;
      if(b[i]=='a')w--;
      if(w>1000000000)w=1000000000 ;
      ans+=Math.min(w,k);
    }
    out.print(ans);
    out.flush();
  }
  static StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
  static PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  static int ini()throws IOException {
    in.nextToken();
    return(int)in.nval ;
  }
  static String ins()throws IOException {
    in.nextToken();
    return in.sval ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := ini() ;
    var k : int ; k := ini() ;
    var a : Sequence(String) ; a := ins()->characters() ;
    var b : Sequence(String) ; b := ins()->characters() ;
    var ans : long ; ans := 0 ;
    var w : long ; w := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     w := (w*(2->pow(1)))->oclAsType(long) ; 
     if (a[i+1] = 'b') then     w := w - 1 ; else skip ; 
    if (b[i+1] = 'a') then     w := w - 1 ; else skip ; 
    if (w > 1000000000) then     w := 1000000000 ; else skip ; 
    ans := ans+(Set{w, k}->min()) ; 
 )  ;     i := i + 1 ) ; 
    out.print(ans) ; 
    out.flush() ; 
 );
  static   attribute in : StreamTokenizer := StreamTokenizer.newStreamTokenizer(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])));
  static   operation ini() : int
  pre: true
  post: true
  activity: (     in.next() ; 
     return in.nval->oclAsType(int) );
  static   operation ins() : String
  pre: true
  post: true
  activity: (     in.next() ; 
     return in.sval );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class solution {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    long n=Long.parseLong(f.readLine());
    int digits=Long.toString(n).length();
    long val=0 ;
    for(int i=0 ; i<digits-1 ; i++){
      val+=Math.pow(10,i);
    }
    int ans=9*(digits-1)+sumDig(n-9*val);
    System.out.println(ans);
    f.close();
  }
  public static int sumDig(long n){
    int x='0' ;
    String s=Long.toString(n);
    int ans=0 ;
    for(int i=0 ; i<s.length(); i++){
      ans+=s.charAt(i)-x ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : long ; n := (f.readLine())->toLong() ;
    var digits : int ; digits := ((n) + "")->size() ;
    var val : long ; val := 0 ;
        var i : int ; i := 0 ; while i < digits - 1 do ( (     val := val+(10->pow(i)) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 9 * (digits - 1) + sumDig(n - 9 * val) ;
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
  static   operation sumDig( n : long) : int
  pre: true
  post: true
  activity: (     var x : int ; x := '0' ;
     var s : String ; s := ((n) + "") ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     ans := ans+(s->at(i+1) - x) )  ;     i := i + 1 ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    int a=2 ;
    double result=0 ;
    for(int i=1 ; i<=n ; i++){
      a=2 ;
      if(i<=k-1){
        while(a*i<k){
          a=a*2 ;
        }
        double b2=(double)1/n/a ;
        result+=b2 ;
      }
      else {
        double b1=(double)1/n ;
        result+=b1 ;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var a : int ; a := 2 ;
    var result : double ; result := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     a := 2 ; 
     if (i <= k - 1) then (     while (a * i < k) do (     a := a * 2 ) ; 
     var b2 : double ; b2 := 1->oclAsType(double) / n / a ;
     result := result+(b2) ) else (     var b1 : double ; b1 := 1->oclAsType(double) / n ;
     result := result+(b1) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    inputClass in=new inputClass(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CDiceAndCoin solver=new CDiceAndCoin();
    solver.solve(1,in,out);
    out.close();
  }
  static class CDiceAndCoin {
    static double pow(double x,long y,int p){
      double res=1 ;
      x=x % p ;
      while(y>0){
        if((y & 1)==1)res=(res*x)% p ;
        y=y>>1 ;
        x=(x*x)% p ;
      }
      return res ;
    }
    public void solve(int testNumber,inputClass sc,PrintWriter out){
      int n=sc.nextInt();
      int k=sc.nextInt();
      double res=0 ;
      double each=1d/n ;
      for(int i=1 ; i<=n ; i++){
        res+=each*pow(0.5,(int)Math.ceil(Math.log((double)k/i)/Math.log(2)),1000000009);
      }
      out.println(res);
    }
  }
  static class inputClass {
    BufferedReader br ;
    StringTokenizer st ;
    public inputClass(InputStream in){
      br=new BufferedReader(new InputStreamReader(in));
    }
    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());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : inputClass ; in := inputClass.newinputClass(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CDiceAndCoin ; solver := CDiceAndCoin.newCDiceAndCoin() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CDiceAndCoin {
  static   operation pow( x : double, y : long, p : int) : double
  pre: true
  post: true
  activity: (     var res : double ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     if ((y & 1) = 1) then     res := (res * x) mod p ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res );
   operation solve( testNumber : int, sc : inputClass, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var k : int ; k := sc.nextInt() ;
    var res : double ; res := 0 ;
    var each : double ; each := 1d / n ;
        var i : int ; i := 1 ; while i <= n do ( (     res := res+(each * pow(0.5, ((k->oclAsType(double) / i)->log() / (2)->log())->ceil()->oclAsType(int), 1000000009)) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class inputClass {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newinputClass( in : OclFile) : inputClass
  pre: true
  post: true
  activity:
  ( var self : inputClass ;
    self := createinputClass();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double n=sc.nextInt();
    double k=sc.nextInt();
    double ans[]=new double[(int)n+1];
    for(int i=1 ; i<=(int)n ; i++){
      double temp=(double)i ;
      int memo=0 ;
      while(true){
        if(temp>k-1){
          break ;
        }
        temp*=2 ;
        memo++;
      }
      ans[i]=1/n*pow(0.5,memo);
    }
    double res=0 ;
    for(int i=1 ; i<=(int)n ; i++){
      res+=ans[i];
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : double ; n := sc.getCurrent()->toInteger() ;
    var k : double ; k := sc.getCurrent()->toInteger() ;
    var ans : Sequence(double) ; ans := Integer.subrange(1,n->oclAsType(int) + 1)->collect(0.0) ;
        var i : int ; i := 1 ; while i <= n->oclAsType(int) do ( (     var temp : double ; temp := i->oclAsType(double) ;
     var memo : int ; memo := 0 ;
     while (true) do (     if (temp > k - 1) then (     break ) else skip ; 
     temp := temp*(2) ; 
     memo := memo + 1 ) ; 
     ans[i+1] := 1 / n * pow(0.5, memo) )  ;     i := i + 1 ) ; 
    var res : double ; res := 0 ;
        var i : int ; i := 1 ; while i <= n->oclAsType(int) do ( (     res := res+(ans[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CDiceAndCoin solver=new CDiceAndCoin();
    solver.solve(1,in,out);
    out.close();
  }
  static class CDiceAndCoin {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt(),k=in.nextInt();
      double ans=0 ;
      for(int i=1 ; i<=n ; ++i){
        double cur=1 ;
        int val=i ;
        while(val<k){
          val*=2 ;
          cur/=2 ;
        }
        ans+=cur/n ;
      }
      out.println(ans);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CDiceAndCoin ; solver := CDiceAndCoin.newCDiceAndCoin() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CDiceAndCoin {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
    var k : int ; k := in.nextInt() ;
     var ans : double ; ans := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     var cur : double ; cur := 1 ;
     var val : int ; val := i ;
     while (val < k) do (     val := val*(2) ; 
     cur := cur/(2) ) ; 
     ans := ans+(cur / n) )  ;     i := i + 1 ) ; 
     skip );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void substringConversions(String str,int k,int b){
    int i=0,sum=0,counter=k-1 ;
    for(i=0 ; i<k ; i++){
      sum=(int)(sum+((str.charAt(i)-'0')*Math.pow(b,counter)));
      counter--;
    }
    System.out.print(sum+" ");
    int prev=sum ;
    sum=0 ;
    counter=0 ;
    for(; i<str.length(); i++){
      sum=(int)(prev-((str.charAt(i-k)-'0')*Math.pow(b,k-1)));
      sum=sum*b ;
      sum=sum+(str.charAt(i)-'0');
      System.out.print(sum+" ");
      prev=sum ;
      counter++;
    }
  }
  public static void main(String[] args){
    String str="12212" ;
    int b=3,k=3 ;
    substringConversions(str,b,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation substringConversions( str : String, k : int, b : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var sum : int ; sum := 0 ;
    var counter : int ; counter := k - 1 ;
         i := 0 ; while i < k do ( (     sum := (sum + ((str->at(i+1) - ('0')->char2byte()) * b->pow(counter)))->oclAsType(int) ; 
     counter := counter - 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sum + " ") ; 
    var prev : int ; prev := sum ;
    sum := 0 ; 
    counter := 0 ; 
      while i < str->size() do ( (     sum := (prev - ((str->at(i - k+1) - ('0')->char2byte()) * b->pow(k - 1)))->oclAsType(int) ; 
     sum := sum * b ; 
    sum := sum + (str->at(i+1) - ('0')->char2byte()) ; 
    OclFile["System.out"].print(sum + " ") ; 
    prev := sum ; 
    counter := counter + 1 ; 
 )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "12212" ;
     var b : int ; b := 3 ;
    var k : int ; k := 3 ;
     execute substringConversions(str, b, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static float emi_calculator(float p,float r,float t){
    float emi ;
    r=r/(12*100);
    t=t*12 ;
    emi=(p*r*(float)Math.pow(1+r,t))/(float)(Math.pow(1+r,t)-1);
    return(emi);
  }
  static public void main(String[] args){
    float principal,rate,time,emi ;
    principal=10000 ;
    rate=10 ;
    time=2 ;
    emi=emi_calculator(principal,rate,time);
    System.out.println("Monthly EMI is="+emi);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation emi_calculator( p : double, r : double, t : double) : double
  pre: true
  post: true
  activity: (     var emi : double ;
     r := r / (12 * 100) ; 
    t := t * 12 ; 
    emi := (p * r * 1 + r->pow(t)->oclAsType(double)) / (1 + r->pow(t) - 1)->oclAsType(double) ; 
    return (emi) 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var principal : double ;
    var rate : double ;
    var time : double ;
    var emi : double ;
     principal := 10000 ; 
    rate := 10 ; 
    time := 2 ; 
    emi := emi_calculator(principal, rate, time) ; 
    OclFile["System.out"].println("Monthly EMI is=" + emi) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileNotFoundException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int A=sc.nextInt();
    int B=sc.nextInt();
    sc.close();
    System.out.println(Math.min(N*A,B));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    skip ; 
    OclFile["System.out"].println(Set{N * A, B}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int count_numbers(int k,int n,boolean flag){
    if(n==1){
      if(flag){
        return(k-1);
      }
      else {
        return 1 ;
      }
    }
    if(flag)return(k-1)*(count_numbers(k,n-1,false)+count_numbers(k,n-1,true));
    else return count_numbers(k,n-1,true);
  }
  public static void main(String[] args){
    int n=3 ;
    int k=10 ;
    System.out.println(count_numbers(k,n,true));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation count_numbers( k : int, n : int, flag : boolean) : int
  pre: true
  post: true
  activity: (     if (n = 1) then (     if (flag) then (     return (k - 1) ) else (     return 1 ) ) else skip ; 
     if (flag) then     return (k - 1) * (count_numbers(k, n - 1, false) + count_numbers(k, n - 1, true)) else     return count_numbers(k, n - 1, true) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var k : int ; k := 10 ;
     OclFile["System.out"].println(count_numbers(k, n, true)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc ;
  long L,R ;
  private static long MOD=1000000007L ;
  public Main(){
    sc=new Scanner(System.in);
  }
  private void calc(){
    L=sc.nextLong();
    R=sc.nextLong();
    System.out.println(count(0,0,63));
    System.out.flush();
  }
  private long count(long x,long y,int maskn){
    if((x | y)!=0 &&(y>>>1)>=x)return 0L ;
    if(R<x || R<y)return 0L ;
    long mask=(1L<<maskn)-1L ;
    if((y | mask)<L ||(x | mask)<L)return 0L ;
    if(L<=x &&(y | mask)<=R){
      if(maskn==0)return 1L ;
      return(3*count(x,y | mask,maskn-1))% MOD ;
    }
    maskn--;
    long nextBit=(mask>>>1)+1L ;
    long su=count(x | nextBit,y | nextBit,maskn);
    long sl=count(x,y,maskn);
    long sm=-1 ;
    if(x!=y)if(L<x)sm=su ;
    else if((y | mask)<R)sm=sl ;
    if(sm==-1)sm=count(x,y | nextBit,maskn);
    return(sl+sm+su)% MOD ;
  }
  public static void main(String[] args){
    new Main().calc();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute L : long;
  static   attribute MOD : long := 1000000007L;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation calc() : void
  pre: true
  post: true
  activity: (     L := sc.getCurrent()->toLong() ; 
     R := sc.getCurrent()->toLong() ; 
     OclFile["System.out"].println(count(0, 0, 63)) ; 
     OclFile["System.out"].flush() );
   operation count( x : long, y : long, maskn : int) : long
  pre: true
  post: true
  activity: (     if ((x or y) /= 0 & ((y/(2->pow(1)))->oclAsType(long)) >= x) then     return 0L else skip ; 
     if (R < x or R < y) then     return 0L else skip ; 
    var mask : long ; mask := ((1L*(2->pow(maskn)))->oclAsType(long)) - 1L ;
    if ((y or mask) < L or (x or mask) < L) then     return 0L else skip ; 
    if (L <= x & (y or mask) <= R) then (     if (maskn = 0) then     return 1L else skip ; 
     return (3 * count(x, y or mask, maskn - 1)) mod MOD ) else skip ; 
    maskn := maskn - 1 ; 
    var nextBit : long ; nextBit := ((mask/(2->pow(1)))->oclAsType(long)) + 1L ;
    var su : long ; su := count(x or nextBit, y or nextBit, maskn) ;
    var sl : long ; sl := count(x, y, maskn) ;
    var sm : long ; sm := -1 ;
    if (x /= y) then     if (L < x) then     sm := su else     if ((y or mask) < R) then     sm := sl ; else skip ; ;  else skip ; 
    if (sm = -1) then     sm := count(x, y or nextBit, maskn) ; else skip ; 
    return (sl + sm + su) mod MOD 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().calc() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import java.io.*;
public class Hello {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long num=in.nextLong();
    long nine=0 ;
    for(int i=0 ; i<=num ; i++){
      nine=(10*nine)+9 ;
      if(nine>=num){
        if(nine==num){
          nine=nine ;
        }
        else {
          nine=(long)(nine/10);
        }
        break ;
      }
    }
    long rem=num-nine ;
    pw.println(digit_Sum(rem)+digit_Sum(nine));
    pw.close();
  }
  static long digit_Sum(long n){
    long sum=0 ;
    while(n!=0){
      sum+=n % 10 ;
      n/=10 ;
    }
    return sum ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hello {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var num : long ; num := in.getCurrent()->toLong() ;
    var nine : long ; nine := 0 ;
        var i : int ; i := 0 ; while i <= num do ( (     nine := (10 * nine) + 9 ; 
     if (nine >= num) then (     if (nine = num) then (     nine := nine ) else (     nine := (nine / 10)->oclAsType(long) ) ;  
     break ) else skip )  ;     i := i + 1 ) ; 
    var rem : long ; rem := num - nine ;
    skip ; 
    skip ; 
 );
  static   operation digit_Sum( n : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     while (n /= 0) do (     sum := sum+(n mod 10) ; 
     n := n/(10) ) ; 
     return sum );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc ;
  long L,R ;
  private static long MOD=1000000007L ;
  private static final long[] MASK ;
  static {
    MASK=new long[64];
    MASK[0]=0L ;
    for(int i=1 ; i<64 ; i++)MASK[i]=MASK[i-1]*2+1 ;
  }
  private static final long[] POW3 ;
  static {
    POW3=new long[64];
    POW3[0]=1L ;
    for(int i=1 ; i<64 ; i++)POW3[i]=(POW3[i-1]*3L)% MOD ;
  }
  public Main(){
    sc=new Scanner(System.in);
  }
  private void calc(){
    L=sc.nextLong();
    R=sc.nextLong();
    System.out.println(count(0,0,63));
    System.out.flush();
  }
  private long count(long x,long y,int maskn){
    if((x | y)!=0 &&(y>>>1)>=x)return 0L ;
    if(R<x || R<y)return 0L ;
    if((y | MASK[maskn])<L ||(x | MASK[maskn])<L)return 0L ;
    if(L<=x &&(y | MASK[maskn])<=R)return POW3[maskn];
    maskn--;
    long nextBit=MASK[maskn]+1L ;
    long su=count(x | nextBit,y | nextBit,maskn);
    long sl=count(x,y,maskn);
    if(x==y)return(su+sl+count(x,y | nextBit,maskn))% MOD ;
    else if(L<x)return(2*su+sl)% MOD ;
    else if((y | MASK[maskn+1])<R)return(su+2*sl)% MOD ;
    return(su+sl+count(x,y | nextBit,maskn))% MOD ;
  }
  public static void main(String[] args){
    new Main().calc();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute L : long;
  static   attribute MOD : long := 1000000007L;
  static    attribute MASK : Sequence(long);
  static operation initialiseClass()
  pre: true post: true
  activity:     MASK := Integer.subrange(1,64)->collect(0) ; 
    MASK[0+1] := 0L ; 
        var i : int ; i := 1 ; while i < 64 do (     MASK[i+1] := MASK[i - 1+1] * 2 + 1 ;  ;     i := i + 1 ) ; 
;
  static    attribute POW3 : Sequence(long);
  static operation initialiseClass()
  pre: true post: true
  activity:     POW3 := Integer.subrange(1,64)->collect(0) ; 
    POW3[0+1] := 1L ; 
        var i : int ; i := 1 ; while i < 64 do (     POW3[i+1] := (POW3[i - 1+1] * 3L) mod MOD ;  ;     i := i + 1 ) ; 
;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation calc() : void
  pre: true
  post: true
  activity: (     L := sc.getCurrent()->toLong() ; 
     R := sc.getCurrent()->toLong() ; 
     OclFile["System.out"].println(count(0, 0, 63)) ; 
     OclFile["System.out"].flush() );
   operation count( x : long, y : long, maskn : int) : long
  pre: true
  post: true
  activity: (     if ((x or y) /= 0 & ((y/(2->pow(1)))->oclAsType(long)) >= x) then     return 0L else skip ; 
     if (R < x or R < y) then     return 0L else skip ; 
    if ((y or MASK[maskn+1]) < L or (x or MASK[maskn+1]) < L) then     return 0L else skip ; 
    if (L <= x & (y or MASK[maskn+1]) <= R) then     return POW3[maskn+1] else skip ; 
    maskn := maskn - 1 ; 
    var nextBit : long ; nextBit := MASK[maskn+1] + 1L ;
    var su : long ; su := count(x or nextBit, y or nextBit, maskn) ;
    var sl : long ; sl := count(x, y, maskn) ;
    if (x = y) then     return (su + sl + count(x, y or nextBit, maskn)) mod MOD else     if (L < x) then     return (2 * su + sl) mod MOD else     if ((y or MASK[maskn + 1+1]) < R) then     return (su + 2 * sl) mod MOD else skip ; ;  ;  
    return (su + sl + count(x, y or nextBit, maskn)) mod MOD 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().calc() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class SquareTiles {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(new File("input.txt"));
    PrintWriter out=new PrintWriter("output.txt");
    int test=Integer.parseInt(in.nextLine());
    for(int t=1 ; t<=test ; t++){
      String nums=in.nextLine();
      StringTokenizer st=new StringTokenizer(nums);
      int r=Integer.parseInt(st.nextToken());
      int c=Integer.parseInt(st.nextToken());
      char[][] map=new char[r][c];
      for(int i=0 ; i<r ; i++){
        String row=in.nextLine();
        map[i]=row.toCharArray();
      }
      for(int i=0 ; i<r-1 ; i++){
        for(int j=0 ; j<c-1 ; j++){
          if(map[i][j]=='#' && map[i][j+1]=='#' && map[i+1][j]=='#' && map[i+1][j+1]=='#'){
            map[i][j]='/' ;
            map[i+1][j+1]='/' ;
            map[i][j+1]='\\';map[i+1][j]='\\';}}}booleanok=true;for(inti=0;i<r;i++)for(intj=0;j<c;j++)if(map[i][j]=='#') ok=false ;
            out.println(" Case # "+t+" : ");
            if(! ok)out.println(" Impossible ");
            else {
              for(int i=0 ; i<r ; i++){
                for(int j=0 ; j<c ; j++)out.print(map[i][j]);
                out.println();
              }
            }
          }
          out.close();
        }
      }

------------------------------------------------------------
OCL File:
---------
 class SquareTiles {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("input.txt")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
    var test : int ; test := (in.nextLine())->toInteger() ;
        var t : int ; t := 1 ; while t <= test do ( (     var nums : String ; nums := in.nextLine() ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(nums) ;
    var r : int ; r := (st.next())->toInteger() ;
    var c : int ; c := (st.next())->toInteger() ;
    var map : Sequence(Sequence(String)) ; map := Integer.subrange(1,r)->collect(Integer.subrange(1,c)->collect(0)) ;
        var i : int ; i := 0 ; while i < r do ( (     var row : String ; row := in.nextLine() ;
     map[i+1] := row->characters() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < r - 1 do ( (         var j : int ; j := 0 ; while j < c - 1 do ( (     if (map[i+1][j+1] = '#' & map[i+1][j + 1+1] = '#' & map[i + 1+1][j+1] = '#' & map[i + 1+1][j + 1+1] = '#') then (     map[i+1][j+1] := '/' ; 
     map[i + 1+1][j + 1+1] := '/' ; 
     map[i+1][j + 1+1] := '\\' ; 
     map[i + 1+1][j+1] := '\\' ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    booleanok := true ; 
        inti := 0 ; while i < r do (         intj := 0 ; while j < c do (     if (map[i+1][j+1] = '#') then     ok := false ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    skip ; 
    if (not(ok)) then     skip else (         var i : int ; i := 0 ; while i < r do ( (         var j : int ; j := 0 ; while j < c do (     skip ;  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ) ;  
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class R1CA {
  public static void main(String[] args){
    try {
      new R1CA().solve();
    }
    catch(Exception e){
      e.printStackTrace();
      throw new IllegalStateException();
    }
  }
  private void solve()throws FileNotFoundException {
    Scanner in=new Scanner(new File("A-large.in"));
    PrintWriter out=new PrintWriter("A-large.out");
    int testCount=in.nextInt();
    for(int test=1 ; test<=testCount ; ++test){
      int n=in.nextInt();
      int m=in.nextInt();
      char[][] a=new char[n][];
      for(int i=0 ; i<n ; ++i){
        a[i]=in.next().toCharArray();
      }
      for(int i=0 ; i<n-1 ; ++i){
        for(int j=0 ; j<m-1 ; ++j){
          if(a[i][j]=='#' && a[i+1][j]=='#' && a[i][j+1]=='#' && a[i+1][j+1]=='#'){
            for(int di=0 ; di<2 ; ++di){
              for(int dj=0 ; dj<2 ; ++dj){
                a[i+di][j+dj]=((di+dj)% 2==0)? '/' : '\\';}}}}}booleanbad=false;for(inti=0;i<n;++i){for(intj=0;j<m;++j){if(a[i][j]=='#'){
                  bad=true ;
                }
              }
            }
            out.printf(" Case  # % d : \n ",test);
            if(bad){
              out.printf(" Impossible \n ");
            }
            else {
              for(int i=0 ; i<n ; ++i){
                out.println(a[i]);
              }
            }
          }
          out.flush();
        }
      }

------------------------------------------------------------
OCL File:
---------
 class R1CA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     R1CA.newR1CA().solve() )   catch (e : ProgramException) do (     e.printStackTrace() ; 
     error IncorrectElementException() )
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("A-large.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("A-large.out")) ;
    var testCount : int ; testCount := in.getCurrent()->toInteger() ;
        var test : int ; test := 1 ; while test <= testCount do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,n)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->characters() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := 0 ; while j < m - 1 do ( (     if (a[i+1][j+1] = '#' & a[i + 1+1][j+1] = '#' & a[i+1][j + 1+1] = '#' & a[i + 1+1][j + 1+1] = '#') then (         var di : int ; di := 0 ; while di < 2 do ( (         var dj : int ; dj := 0 ; while dj < 2 do ( (     a[i + di+1][j + dj+1] := if ((di + dj) mod 2 = 0) then '/' else '\\' endif )  ;     dj := dj + 1 ) )  ;     di := di + 1 ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    booleanbad := false ; 
        inti := 0 ; while i < n do ( (         intj := 0 ; while j < m do ( (     if (a[i+1][j+1] = '#') then (     bad := true ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    if (bad) then (     skip ) else (         var i : int ; i := 0 ; while i < n do ( (     skip )  ;     i := i + 1 ) ) ;  
 )  ;     test := test + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.nio.charset.StandardCharsets ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader reader=new InputStreamReader(System.in,StandardCharsets.UTF_8);
    BufferedReader in=new BufferedReader(reader);
    String S=in.readLine();
    int k=S.length();
    for(int i=1 ; i<S.length(); ++i){
      if(S.charAt(i-1)!=S.charAt(i)){
        k=Math.min(k,Math.max(i,S.length()-i));
      }
    }
    System.out.println(k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"], StandardCharsets.UTF_8) ;
     var in : OclFile ; in := OclFile.newOclFile_Read(reader) ;
    var S : String ; S := in.readLine() ;
    var k : int ; k := S->size() ;
        var i : int ; i := 1 ; while i < S->size() do ( (     if (S->at(i - 1+1) /= S->at(i+1)) then (     k := Set{k, Set{i, S->size() - i}->max()}->min() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(k) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  boolean[] bs ;
  public static void main(String args[]){
    new Main().run();
  }
  void run(){
    FastReader sc=new FastReader();
    char[] cs=sc.next().toCharArray();
    bs=new boolean[cs.length];
    for(int i=0 ; i<cs.length ; i++){
      bs[i]=cs[i]=='1' ;
    }
    solve();
  }
  void solve(){
    int ans=bs.length ;
    for(int i=0 ; i<bs.length-1 ; i++){
      if(bs[i] ^ bs[i+1]){
        ans=Math.min(ans,Math.max(i+1,bs.length-i-1));
      }
    }
    System.out.println(ans);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute bs : Sequence(boolean);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var cs : Sequence(String) ; cs := sc.next()->characters() ;
    bs := Integer.subrange(1,cs->size())->collect(false) ; 
        var i : int ; i := 0 ; while i < cs->size() do ( (     bs[i+1] := cs[i+1] = '1' )  ;     i := i + 1 ) ; 
    execute solve() ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := bs->size() ;
         var i : int ; i := 0 ; while i < bs->size() - 1 do ( (     if (bs[i+1] xor bs[i + 1+1]) then (     ans := Set{ans, Set{i + 1, bs->size() - i - 1}->max()}->min() ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner inp=new Scanner(System.in);
    do_(inp);
    inp.close();
  }
  public static void do_(Scanner inp){
    int a=inp.nextInt();
    int b=inp.nextInt();
    int c=inp.nextInt();
    System.out.println(Math.min(a*b,c));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inp : OclFile ; inp := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute do_(inp) ; 
     skip );
  static   operation do_( inp : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := inp.getCurrent()->toInteger() ;
     var b : int ; b := inp.getCurrent()->toInteger() ;
     var c : int ; c := inp.getCurrent()->toInteger() ;
     OclFile["System.out"].println(Set{a * b, c}->min()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      char[] s=scanner.next().toCharArray();
      int n=s.length ;
      System.out.println(IntStream.range(1,n).filter(i->s[i-1]!=s[i]).map(i->Math.max(i,n-i)).min().orElse(n));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var s : Sequence(String) ; s := scanner.getCurrent()->characters() ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].println(Integer.subrange(1, n-1)->select( _x1 | (lambda i : OclAny in s[i - 1+1] /= s[i+1])->apply(_x1) )->collect( _x1 | (lambda i : OclAny in Set{i, n - i}->max())->apply(_x1) ).min().orElse(n)) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean prime(int n){
    for(int i=2 ; i*i<=n ; i++){
      if(n % i==0)return false ;
    }
    return true ;
  }
  static void thirdNumber(int a,int b){
    int sum=0,temp=0 ;
    sum=a+b ;
    temp=1 ;
    if(sum==0){
      temp=2 ;
    }
    while(! prime(sum+temp)){
      temp+=2 ;
    }
    System.out.print(temp);
  }
  static public void main(String[] arr){
    int a=3,b=5 ;
    thirdNumber(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation prime( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation thirdNumber( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
    var temp : int ; temp := 0 ;
     sum := a + b ; 
    temp := 1 ; 
    if (sum = 0) then (     temp := 2 ) else skip ; 
    while (not(prime(sum + temp))) do (     temp := temp+(2) ) ; 
    OclFile["System.out"].print(temp) ; 
 );
  static    operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var b : int ; b := 5 ;
     execute thirdNumber(a, b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.stream.IntStream ;
import java.io.UncheckedIOException ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    LightScanner in=new LightScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    DWideFlip solver=new DWideFlip();
    solver.solve(1,in,out);
    out.close();
  }
  static class DWideFlip {
    public void solve(int testNumber,LightScanner in,PrintWriter out){
      int[] s=in.string().chars().map(i->i-'0').toArray();
      if(Arrays.stream(s).allMatch(i->i==1)){
        out.println(s.length);
      }
      else if(Arrays.stream(s).allMatch(i->i==0)){
        out.println(s.length);
      }
      else {
        int ans=Integer.MAX_VALUE ;
        for(int i=1 ; i<s.length ; i++){
          if(s[i-1]!=s[i]){
            ans=Math.min(ans,Math.max(i,s.length-i));
          }
        }
        out.println(ans);
      }
    }
  }
  static class LightScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public LightScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String string(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : LightScanner ; in := LightScanner.newLightScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : DWideFlip ; solver := DWideFlip.newDWideFlip() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class DWideFlip {
   operation solve( testNumber : int, in : LightScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : Sequence(int) ; s := in.string().chars()->collect( _x1 | (lambda i : OclAny in i - ('0')->char2byte())->apply(_x1) )->asSequence() ;
     if (stream(s)->forAll( _x2 | (lambda i : OclAny in i = 1)->apply(_x2) )) then (     skip ) else     if (stream(s)->forAll( _x2 | (lambda i : OclAny in i = 0)->apply(_x2) )) then (     skip ) else (     var ans : int ; ans := 2147483647 ;
         var i : int ; i := 1 ; while i < s->size() do ( (     if (s[i - 1+1] /= s[i+1]) then (     ans := Set{ans, Set{i, s->size() - i}->max()}->min() ) else skip )  ;     i := i + 1 ) ; 
     skip ) ;  );
}
  static class LightScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newLightScanner( in : OclFile) : LightScanner
  pre: true
  post: true
  activity:
  ( var self : LightScanner ;
    self := createLightScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation string() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main implements Runnable {
  public static void main(String[] args){
    new Thread(null,new Main(),"",128*1024*1024).start();
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int size=s.length();
    int[] sequence=new int[100000];
    int idx=0 ;
    int prevIdx=0 ;
    int prev=s.charAt(0)-'0' ;
    for(int i=1 ; i<size ; i++){
      int current=s.charAt(i)-'0' ;
      if(current!=prev){
        sequence[idx]=i-prevIdx ;
        prevIdx=i ;
        prev=current ;
        idx++;
      }
    }
    sequence[idx]=size-prevIdx ;
    int sum=0 ;
    int least=Integer.MAX_VALUE ;
    for(int i=0 ; i<=idx ; i++){
      sum+=sequence[i];
      least=Math.min(Math.max(sum,size-sum),least);
    }
    System.out.println(least);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(null, Main.newMain(), "", 128 * 1024 * 1024).start() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var size : int ; size := s->size() ;
    var sequence : Sequence(int) ; sequence := Integer.subrange(1,100000)->collect(0) ;
    var idx : int ; idx := 0 ;
    var prevIdx : int ; prevIdx := 0 ;
    var prev : int ; prev := s->at(0+1) - ('0')->char2byte() ;
        var i : int ; i := 1 ; while i < size do ( (     var current : int ; current := s->at(i+1) - ('0')->char2byte() ;
     if (current /= prev) then (     sequence[idx+1] := i - prevIdx ; 
     prevIdx := i ; 
     prev := current ; 
     idx := idx + 1 ) else skip )  ;     i := i + 1 ) ; 
    sequence[idx+1] := (size)->char2byte() - prevIdx ; 
    var sum : int ; sum := 0 ;
    var least : int ; least := 2147483647 ;
        var i : int ; i := 0 ; while i <= idx do ( (     sum := sum+(sequence[i+1]) ; 
     least := Set{Set{sum, (size)->char2byte() - sum}->max(), least}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(least) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countDistinct(int arr[],int n){
    int res=1 ;
    for(int i=1 ; i<n ; i++){
      int j=0 ;
      for(j=0 ; j<i ; j++)if(arr[i]==arr[j])break ;
      if(i==j)res++;
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      12,10,9,45,2,10,10,45 };
      int n=arr.length ;
      System.out.println(countDistinct(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countDistinct( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
         var i : int ; i := 1 ; while i < n do ( (     var j : int ; j := 0 ;
         j := 0 ; while j < i do (     if (arr[i+1] = arr[j+1]) then     break else skip ;  ;     j := j + 1 ) ; 
     if (i = j) then     res := res + 1 ; else skip )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,10,9,45,2,10,10,45} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countDistinct(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=128 ;
  static boolean isVowel(char x){
    return(x=='a' || x=='e' || x=='i' || x=='o' || x=='u' || x=='A' || x=='E' || x=='I' || x=='O' || x=='U');
  }
  static int KDistinctVowel(String s,int k){
    int n=s.length();
    int[] c=new int[MAX];
    int result=-1 ;
    for(int i=0,j=-1 ; i<n ; ++i){
      char x=s.charAt(i);
      if(isVowel(x)){
        if(++c[x]==1){
--k ;
        }
      }
      while(k<0){
        x=s.charAt(++j);
        if(isVowel(x)){
          if(--c[x]==0){
++k ;
          }
        }
      }
      if(k==0){
        result=Math.max(result,i-j);
      }
    }
    return result ;
  }
  public static void main(String[] args){
    String s="tHeracEBetwEEntheTwo" ;
    int k=1 ;
    System.out.println(KDistinctVowel(s,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 128;
  static   operation isVowel( x : String) : boolean
  pre: true
  post: true
  activity: (     return (x = 'a' or x = 'e' or x = 'i' or x = 'o' or x = 'u' or x = 'A' or x = 'E' or x = 'I' or x = 'O' or x = 'U') );
  static   operation KDistinctVowel( s : String, k : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var c : Sequence(int) ; c := Integer.subrange(1,MAX)->collect(0) ;
    var result : int ; result := -1 ;
        var i : int ; i := 0 ;
    var j : int ; j := -1 ; while i < n do ( (     var x : String ; x := s->at(i+1) ;
     if (isVowel(x)) then (     if ((c[x+1] + 1) = 1) then (     k := k - 1 ) else skip ) else skip ; 
     while (k < 0) do (     x := s->at((j + 1)+1) ; 
     if (isVowel(x)) then (     if ((c[x+1] - 1) = 0) then (     k := k + 1 ) else skip ) else skip ) ; 
     if (k = 0) then (     result := Set{result, i - j}->max() ) else skip )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "tHeracEBetwEEntheTwo" ;
     var k : int ; k := 1 ;
     OclFile["System.out"].println(KDistinctVowel(s, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  public static void main(String[] args){
    try(Scanner in=new Scanner(System.in)){
      int t=in.nextInt();
      while(t-->0){
        int n=in.nextInt();
        int maxX=0,maxY=0,minX=0,minY=0 ;
        for(int i=0 ; i<n ; i++){
          int x1=in.nextInt();
          int y1=in.nextInt();
          if(x1>maxX){
            maxX=x1 ;
          }
          if(x1<minX){
            minX=x1 ;
          }
          if(y1>maxY){
            maxY=y1 ;
          }
          if(y1<minY){
            minY=y1 ;
          }
        }
        System.out.println(2*(maxX+maxY-minY-minX));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var maxX : int ; maxX := 0 ;
    var maxY : int ; maxY := 0 ;
    var minX : int ; minX := 0 ;
    var minY : int ; minY := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var x1 : int ; x1 := in.getCurrent()->toInteger() ;
     var y1 : int ; y1 := in.getCurrent()->toInteger() ;
    if (x1 > maxX) then (     maxX := x1 ) else skip ; 
    if (x1 < minX) then (     minX := x1 ) else skip ; 
    if (y1 > maxY) then (     maxY := y1 ) else skip ; 
    if (y1 < minY) then (     minY := y1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(2 * (maxX + maxY - minY - minX)) ) ;  ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TravelingSalesmanProblem {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testCase=sc.nextInt();
    while(testCase-->0){
      int tung=0 ;
      int hoanh=0 ;
      int xMax=0 ;
      int yMax=0 ;
      int xMin=0 ;
      int yMin=0 ;
      int result=0 ;
      int n=sc.nextInt();
      for(int i=0 ; i<n ; i++){
        int x=sc.nextInt();
        int y=sc.nextInt();
        if(xMax<x){
          xMax=x ;
        }
        if(xMin>x){
          xMin=x ;
        }
        if(yMax<y){
          yMax=y ;
        }
        if(yMin>y){
          yMin=y ;
        }
      }
      if(xMax>0 && xMin<0){
        hoanh=(xMax-xMin)*2 ;
      }
      else if(xMax<=0 && xMin<0){
        hoanh=xMin*(-2);
      }
      else if(xMin>=0 && xMax>0){
        hoanh=xMax*2 ;
      }
      if(yMax>0 && yMin<0){
        tung=(yMax-yMin)*2 ;
      }
      else if(yMax<=0 && yMin<0){
        tung=yMin*(-2);
      }
      else if(yMin>=0 && yMax>0){
        tung=yMax*2 ;
      }
      result=tung+hoanh ;
      System.out.println(result);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class TravelingSalesmanProblem {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCase : int ; testCase := sc.getCurrent()->toInteger() ;
         while (testCase > 0) do (        testCase := testCase - 1 ;     skip ; (     var tung : int ; tung := 0 ;
     var hoanh : int ; hoanh := 0 ;
    var xMax : int ; xMax := 0 ;
    var yMax : int ; yMax := 0 ;
    var xMin : int ; xMin := 0 ;
    var yMin : int ; yMin := 0 ;
    var result : int ; result := 0 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    if (xMax < x) then (     xMax := x ) else skip ; 
    if (xMin > x) then (     xMin := x ) else skip ; 
    if (yMax < y) then (     yMax := y ) else skip ; 
    if (yMin > y) then (     yMin := y ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (xMax > 0 & xMin < 0) then (     hoanh := (xMax - xMin) * 2 ) else     if (xMax <= 0 & xMin < 0) then (     hoanh := xMin * (-2) ) else     if (xMin >= 0 & xMax > 0) then (     hoanh := xMax * 2 ) else skip ; ;  ;  
    if (yMax > 0 & yMin < 0) then (     tung := (yMax - yMin) * 2 ) else     if (yMax <= 0 & yMin < 0) then (     tung := yMin * (-2) ) else     if (yMin >= 0 & yMax > 0) then (     tung := yMax * 2 ) else skip ; ;  ;  
    result := tung + hoanh ; 
    OclFile["System.out"].println(result) ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      int right=0,left=0,up=0,down=0 ;
      for(int i=0 ; i<n ; i++){
        int x=input.nextInt();
        int y=input.nextInt();
        if(x>0 && y==0){
          right=Math.max(right,x);
        }
        else if(x<0 && y==0){
          left=Math.max(left,-x);
        }
        else if(x==0 && y>0){
          up=Math.max(up,y);
        }
        else {
          down=Math.max(down,-y);
        }
      }
      System.out.println(2L*(right+left+up+down));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := input.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.getCurrent()->toInteger() ;
     var right : int ; right := 0 ;
    var left : int ; left := 0 ;
    var up : int ; up := 0 ;
    var down : int ; down := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := input.getCurrent()->toInteger() ;
     var y : int ; y := input.getCurrent()->toInteger() ;
     if (x > 0 & y = 0) then (     right := Set{right, x}->max() ) else     if (x < 0 & y = 0) then (     left := Set{left, -x}->max() ) else     if (x = 0 & y > 0) then (     up := Set{up, y}->max() ) else (     down := Set{down, -y}->max() ) ;  ;  )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(2L * (right + left + up + down)) ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1713 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      int minX=0 ;
      int maxX=0 ;
      int minY=0 ;
      int maxY=0 ;
      for(int n=0 ; n<N ; n++){
        int x=in.nextInt();
        minX=Math.min(minX,x);
        maxX=Math.max(maxX,x);
        int y=in.nextInt();
        minY=Math.min(minY,y);
        maxY=Math.max(maxY,y);
      }
      int answer=2*(maxX+maxY-minX-minY);
      System.out.println(answer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1713 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var minX : int ; minX := 0 ;
    var maxX : int ; maxX := 0 ;
    var minY : int ; minY := 0 ;
    var maxY : int ; maxY := 0 ;
        var n : int ; n := 0 ; while n < N do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     minX := Set{minX, x}->min() ; 
    maxX := Set{maxX, x}->max() ; 
    var y : int ; y := in.getCurrent()->toInteger() ;
    minY := Set{minY, y}->min() ; 
    maxY := Set{maxY, y}->max() ; 
 )  ;     n := n + 1 ) ; 
    var answer : int ; answer := 2 * (maxX + maxY - minX - minY) ;
    OclFile["System.out"].println(answer) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int N=parseInt(br.readLine());
    List<Integer>list=new ArrayList<>();
    line=br.readLine();
    list.add(0);
    char prev=line.charAt(0);
    int sum=1 ;
    int max=1 ;
    for(int i=2 ; i<line.length(); i+=2){
      char next=line.charAt(i);
      if(prev!=next){
        sum++;
      }
      else {
        list.add(sum);
        sum=1 ;
      }
      prev=next ;
    }
    list.add(sum);
    list.add(0);
    for(int i=1 ; i<list.size()-1 ; i++){
      max=Math.max(max,list.get(i-1)+list.get(i)+list.get(i+1));
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var N : int ; N := parseInt(br.readLine()) ;
    var list : Sequence(int) ; list := Sequence{} ;
    line := br.readLine() ; 
    list := list->including(0) ; 
    var prev : String ; prev := line->at(0+1) ;
    var sum : int ; sum := 1 ;
    var max : int ; max := 1 ;
        var i : int ; i := 2 ; while i < line->size() do ( (     var next : String ; next := line->at(i+1) ;
     if (prev /= next) then (     sum := sum + 1 ) else (     list := list->including(sum) ; 
     sum := 1 ) ;  
     prev := next )  ;     i := i+(2) ) ; 
    list := list->including(sum) ; 
    list := list->including(0) ; 
        var i : int ; i := 1 ; while i < list->size() - 1 do ( (     max := Set{max, list->at((i)->char2byte() - 1+1) + list->at(i+1) + list->at(i + 1+1)}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  static int sum_of_series(int n){
    int result=0 ;
    for(int i=1 ; i<=n ; i++){
      if(i % 2==0)result=result-(int)Math.pow(i,2);
      else result=result+(int)Math.pow(i,2);
    }
    return result ;
  }
  public static void main(String args[]){
    int n=3 ;
    System.out.println(sum_of_series(n));
    n=10 ;
    System.out.println(sum_of_series(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sum_of_series( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     if (i mod 2 = 0) then     result := result - i->pow(2)->oclAsType(int) ; else     result := result + i->pow(2)->oclAsType(int) ; )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(sum_of_series(n)) ; 
     n := 10 ; 
     OclFile["System.out"].println(sum_of_series(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.StringTokenizer ;
public class Mike_Child {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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());
    }
    String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
  public static void main(String[] args){
    FastReader in=new FastReader();
    int n=in.nextInt();
    long arr[]=new long[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextLong();
    }
    HashMap<Long,Integer>hs=new HashMap<>();
    int max=1 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        long s=arr[i]+arr[j];
        if(hs.containsKey(s)){
          int get=hs.get(s);
++get ;
          max=Math.max(max,get);
          hs.put(s,get);
        }
        else {
          hs.put(s,1);
        }
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mike_Child {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var n : int ; n := in.nextInt() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.nextLong() )  ;     i := i + 1 ) ; 
    var hs : Map(long,int) ; hs := Map{} ;
    var max : int ; max := 1 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var s : long ; s := arr[i+1] + arr[j+1] ;
     if (hs->keys()->includes(s)) then (     var get : int ; get := hs->at(s) ;
     get := get + 1 ; 
     max := Set{max, get}->max() ; 
     hs := hs->union(Map{s |-> get}) ) else (     hs := hs->union(Map{s |-> 1}) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.text.*;
public class B {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    Scanner s=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=Integer.parseInt(f.readLine());
    for(int cnt=0 ; cnt<n ; cnt++){
      String line=f.readLine();
      if(line.equals("::")){
        out.println("0000:0000:0000:0000:0000:0000:0000:0000");
        continue ;
      }
      String[] split=line.split(":");
      int secCount=0 ;
      for(int i=0 ; i<split.length ; i++){
        if(split[i] .length()>0 && ! split[i] .equals("")){
          secCount++;
        }
      }
      char[] a=line.toCharArray();
      String ans="" ;
      String sofar="" ;
      char last=0 ;
      for(int i=0 ; i<a.length ; i++){
        if(a[i]==':' && last==a[i]){
          int add=8-secCount ;
          sofar="" ;
          for(int j=0 ; j<add ; j++)sofar+="0000"+":" ;
          if(i==a.length-1)ans+=sofar.substring(0,sofar.length()-1);
          else ans+=sofar ;
          sofar="" ;
          continue ;
        }
        if(a[i]!=':')sofar+=a[i];
        if((a[i]==':' || i==a.length-1)&& sofar.length()!=0){
          while(sofar.length()!=4){
            sofar="0"+sofar ;
          }
          if(i==a.length-1)ans+=sofar ;
          else ans+=sofar+":" ;
          sofar="" ;
        }
        last=a[i];
      }
      out.println(ans);
      out.flush();
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (f.readLine())->toInteger() ;
        var cnt : int ; cnt := 0 ; while cnt < n do ( (     var line : String ; line := f.readLine() ;
     if (line = "::") then (     skip ; 
     continue ) else skip ; 
    var split : Sequence(String) ; split := line->split(":") ;
    var secCount : int ; secCount := 0 ;
        var i : int ; i := 0 ; while i < split->size() do ( (     if (split[i+1]->size() > 0 & not(split[i+1] = "")) then (     secCount := secCount + 1 ) else skip )  ;     i := i + 1 ) ; 
    var a : Sequence(String) ; a := line->characters() ;
    var ans : String ; ans := "" ;
    var sofar : String ; sofar := "" ;
    var last : String ; last := 0 ;
        var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] = ':' & last = a[i+1]) then (     var add : int ; add := 8 - secCount ;
     sofar := "" ; 
        var j : int ; j := 0 ; while j < add do (     sofar := sofar+("0000" + ":") ;  ;     j := j + 1 ) ; 
    if (i = a->size() - 1) then     ans := ans+(sofar.subrange(0+1,sofar->size() - 1)) else     ans := ans+(sofar) ; ;  
    sofar := "" ; 
    continue 
 ) else skip ; 
     if (a[i+1] /= ':') then     sofar := sofar+(a[i+1]) ; else skip ; 
     if ((a[i+1] = ':' or i = a->size() - 1) & sofar->size() /= 0) then (     while (sofar->size() /= 4) do (     sofar := "0" + sofar ) ; 
     if (i = a->size() - 1) then     ans := ans+(sofar) else     ans := ans+(sofar + ":") ; ;  
     sofar := "" ) else skip ; 
     last := a[i+1] )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 )  ;     cnt := cnt + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    long mod=(long)1e9+7 ;
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    sc.close();
    ArrayList<Integer>len=new ArrayList<>();
    int l=1 ;
    while(l<=n){
      int r=n/(n/l);
      len.add(r-l+1);
      l=r+1 ;
    }
    int q=len.size();
    long[] dp=new long[k*(q+1)];
    for(int j=1 ; j<=q ; j++){
      dp[j]=len.get(j-1)+dp[j-1];
    }
    for(int i=1 ; i<k ; i++){
      for(int j=1 ; j<=q ; j++){
        dp[i*(q+1)+j]=dp[i*(q+1)+j-1]+dp[(i-1)*(q+1)+q-j+1]*len.get(j-1);
        dp[i*(q+1)+j] %=mod ;
      }
    }
    System.out.println(dp[k*(q+1)-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mod : long ; mod := 1e9->oclAsType(long) + 7 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    skip ; 
    var len : Sequence(int) ; len := Sequence{} ;
    var l : int ; l := 1 ;
    while (l <= n) do (     var r : int ; r := n / (n / l) ;
     len := len->including(r - l + 1) ; 
     l := r + 1 ) ; 
    var q : int ; q := len->size() ;
    var dp : Sequence(long) ; dp := Integer.subrange(1,k * (q + 1))->collect(0) ;
        var j : int ; j := 1 ; while j <= q do ( (     dp[j+1] := len->at(j - 1+1) + dp[j - 1+1] )  ;     j := j + 1 ) ; 
        var i : int ; i := 1 ; while i < k do ( (         var j : int ; j := 1 ; while j <= q do ( (     dp[i * (q + 1) + j+1] := dp[i * (q + 1) + j - 1+1] + dp[(i - 1) * (q + 1) + q - j + 1+1] * len->at(j - 1+1) ; 
     dp[i * (q + 1) + j+1] := dp[i * (q + 1) + j+1] mod mod )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[k * (q + 1) - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int b0=0,b1=0,b2=1 ;
    int max=1 ;
    int prev=sc.nextInt();
    for(int i=1 ; i<N ; i++){
      int x=sc.nextInt();
      if(x!=prev){
        b2++;
      }
      else {
        int len=b0+b1+b2 ;
        if(max<len)max=len ;
        b0=b1 ;
        b1=b2 ;
        b2=1 ;
      }
      prev=x ;
    }
    int len=b0+b1+b2 ;
    if(max<len)max=len ;
    System.out.printf("%d\n",max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var b0 : int ; b0 := 0 ;
    var b1 : int ; b1 := 0 ;
    var b2 : int ; b2 := 1 ;
    var max : int ; max := 1 ;
    var prev : int ; prev := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i < N do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x /= prev) then (     b2 := b2 + 1 ) else (     var len : int ; len := b0 + b1 + b2 ;
     if (max < len) then     max := len ; else skip ; 
    b0 := b1 ; 
    b1 := b2 ; 
    b2 := 1 ; 
 ) ;  
     prev := x )  ;     i := i + 1 ) ; 
    var len : int ; len := b0 + b1 + b2 ;
    if (max < len) then     max := len ; else skip ; 
    OclFile["System.out"].printf("%d\n", max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean hasEvenNumberOfFactors(int n){
    double root_n=Math.sqrt(n);
    if((root_n*root_n)==n)return false ;
    return true ;
  }
  static void printStatusOfDoors(int n){
    for(int i=1 ; i<=n ; i++){
      if(hasEvenNumberOfFactors(i))System.out.print("closed"+" ");
      else System.out.print("open"+" ");
    }
  }
  public static void main(String[] args){
    int n=5 ;
    printStatusOfDoors(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation hasEvenNumberOfFactors( n : int) : boolean
  pre: true
  post: true
  activity: (     var root_n : double ; root_n := (n)->sqrt() ;
     if ((root_n * root_n) = n) then     return false else skip ; 
     return true );
  static   operation printStatusOfDoors( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= n do ( (     if (hasEvenNumberOfFactors(i)) then     OclFile["System.out"].print("closed" + " ") ; else     OclFile["System.out"].print("open" + " ") ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute printStatusOfDoors(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Nth {
  public int nthTerm(int N){
    if(N<=1)return 1 ;
    int i,fact=1 ;
    for(i=1 ; i<N ; i++)fact=fact*i ;
    return fact ;
  }
}
class GFG {
  public static void main(String[] args){
    int N=3 ;
    Nth a=new Nth();
    System.out.println(a.nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Nth {
   operation nthTerm( N : int) : int
  pre: true
  post: true
  activity: (     if (N <= 1) then     return 1 else skip ; 
     var i : int ;
    var fact : int ; fact := 1 ;
         i := 1 ; while i < N do (     fact := fact * i ;  ;     i := i + 1 ) ; 
     return fact );
}
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
     var a : Nth ; a := Nth.newNth() ;
     OclFile["System.out"].println(a.nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int get_permutation(int arr[],int n){
    Arrays.sort(arr);
    int result=0 ;
    for(int i=0 ; i<n ; i++){
      result+=Math.abs(arr[i]-(i+1));
    }
    return result ;
  }
  public static void main(String[] args){
    int arr[]={
      0,2,3,4,1,6,8,9 };
      int n=arr.length ;
      System.out.print(get_permutation(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation get_permutation( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     result := result+(if arr[i+1] - (i + 1) < 0 then -(arr[i+1] - (i + 1)) else arr[i+1] - (i + 1) endif) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,2,3,4,1,6,8,9} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(get_permutation(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int make_permutation(int arr[],int n){
    Arrays.sort(arr);
    int ans=0 ;
    for(int i=0 ; i<n ; i++)ans+=Math.abs(i+1-arr[i]);
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      5,3,8,1,1 };
      int n=arr.length ;
      System.out.print(make_permutation(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation make_permutation( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do (     ans := ans+(if i + 1 - arr[i+1] < 0 then -(i + 1 - arr[i+1]) else i + 1 - arr[i+1] endif) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,3,8,1,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(make_permutation(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  void doIt(){
    Scanner stdIn=new Scanner(System.in);
    while(true){
      int n=stdIn.nextInt();
      int m=stdIn.nextInt();
      if(n==0 && m==0)break ;
      double[][] table=new double[n][n];
      for(int r=0 ; r<n ; r++){
        for(int c=0 ; c<n ; c++){
          table[r][c]=stdIn.nextDouble();
        }
      }
      double[][] dp=new double[m][n];
      Arrays.fill(dp[0],1);
      for(int k=1 ; k<m ; k++){
        for(int r=0 ; r<n ; r++){
          for(int c=0 ; c<n ; c++){
            dp[k][c]=Math.max(dp[k][c],dp[k-1][r]*table[r][c]);
          }
        }
      }
      double ans=-1 ;
      for(int r=0 ; r<n ; r++){
        ans=Math.max(ans,dp[dp.length-1][r]);
      }
      System.out.printf("%.2f\n",ans);
    }
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     var m : int ; m := stdIn.getCurrent()->toInteger() ;
    if (n = 0 & m = 0) then     break else skip ; 
    var table : Sequence(Sequence(double)) ; table := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0.0)) ;
        var r : int ; r := 0 ; while r < n do ( (         var c : int ; c := 0 ; while c < n do ( (     table[r+1][c+1] := stdIn.getCurrent()->toReal() )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    var dp : Sequence(Sequence(double)) ; dp := Integer.subrange(1,m)->collect(Integer.subrange(1,n)->collect(0.0)) ;
    dp[0+1] := dp[0+1]->collect(1) ; 
        var k : int ; k := 1 ; while k < m do ( (         var r : int ; r := 0 ; while r < n do ( (         var c : int ; c := 0 ; while c < n do ( (     dp[k+1][c+1] := Set{dp[k+1][c+1], dp[k - 1+1][r+1] * table[r+1][c+1]}->max() )  ;     c := c + 1 ) )  ;     r := r + 1 ) )  ;     k := k + 1 ) ; 
    var ans : double ; ans := -1 ;
        var r : int ; r := 0 ; while r < n do ( (     ans := Set{ans, dp[dp->size() - 1+1][r+1]}->max() )  ;     r := r + 1 ) ; 
    OclFile["System.out"].printf("%.2f\n", ans) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if((n | m)==0)return ;
      double[][] g=new double[n][n];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          g[i][j]=sc.nextDouble();
        }
      }
      double[][] dp=new double[m][n];
      for(int i=0 ; i<n ; i++)dp[0][i]=1 ;
      for(int i=0 ; i<m-1 ; i++){
        for(int j=0 ; j<n ; j++){
          for(int k=0 ; k<n ; k++){
            dp[i+1][k]=Math.max(dp[i+1][k],dp[i][j]*g[j][k]);
          }
        }
      }
      double max=0 ;
      for(int i=0 ; i<n ; i++)max=Math.max(max,dp[m-1][i]);
      BigDecimal bd=new BigDecimal(max);
      System.out.println(bd.setScale(2,BigDecimal.ROUND_HALF_UP));
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
  void debug2(double[][] array){
    for(int i=0 ; i<array.length ; i++){
      for(int j=0 ; j<array[i] .length ; j++){
        System.out.print(array[i][j]);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,m)) = 0) then     return else skip ; 
    var g : Sequence(Sequence(double)) ; g := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     g[i+1][j+1] := sc.getCurrent()->toReal() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(double)) ; dp := Integer.subrange(1,m)->collect(Integer.subrange(1,n)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < n do (     dp[0+1][i+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m - 1 do ( (         var j : int ; j := 0 ; while j < n do ( (         var k : int ; k := 0 ; while k < n do ( (     dp[i + 1+1][k+1] := Set{dp[i + 1+1][k+1], dp[i+1][j+1] * g[j+1][k+1]}->max() )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : double ; max := 0 ;
        var i : int ; i := 0 ; while i < n do (     max := Set{max, dp[m - 1+1][i+1]}->max() ;  ;     i := i + 1 ) ; 
    var bd : double ; bd := double(max) ;
    OclFile["System.out"].println(bd.setScale(2, ROUND_HALF_UP)) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
   operation debug2( array : Sequence(Sequence(double))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < array->size() do ( (         var j : int ; j := 0 ; while j < array[i+1]->size() do ( (     OclFile["System.out"].print(array[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import static java.lang.Integer.parseInt ;
import static java.lang.Double.parseDouble ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n,m ;
      n=parseInt(line.substring(0,line.indexOf(' ')));
      m=parseInt(line.substring(line.indexOf(' ')+1));
      if(n==0 && m==0)break ;
      double[][] vs=new double[n][n];
      double[][] dp=new double[m][n];
      for(int i=0 ; i<n ; i++){
        String[] words=br.readLine().split(" ");
        for(int j=0 ; j<n ; j++){
          vs[i][j]=parseDouble(words[j]);
        }
      }
      Arrays.fill(dp[0],1);
      for(int i=1 ; i<m ; i++){
        for(int j=0 ; j<n ; j++){
          for(int k=0 ; k<n ; k++){
            dp[i][k]=Math.max(dp[i][k],dp[i-1][j]*vs[j][k]);
          }
        }
      }
      double max=0 ;
      for(int i=0 ; i<n ; i++){
        max=Math.max(max,dp[m-1][i]);
      }
      System.out.println(String.format("%.2f",max));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ;
    var m : int ;
     n := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    m := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    if (n = 0 & m = 0) then     break else skip ; 
    var vs : Sequence(Sequence(double)) ; vs := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0.0)) ;
    var dp : Sequence(Sequence(double)) ; dp := Integer.subrange(1,m)->collect(Integer.subrange(1,n)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var words : Sequence(String) ; words := br.readLine()->split(" ") ;
         var j : int ; j := 0 ; while j < n do ( (     vs[i+1][j+1] := parseDouble(words[j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    dp[0+1] := dp[0+1]->collect(1) ; 
        var i : int ; i := 1 ; while i < m do ( (         var j : int ; j := 0 ; while j < n do ( (         var k : int ; k := 0 ; while k < n do ( (     dp[i+1][k+1] := Set{dp[i+1][k+1], dp[i - 1+1][j+1] * vs[j+1][k+1]}->max() )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : double ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     max := Set{max, dp[(m)->char2byte() - 1+1][i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(StringLib.format("%.2f",Sequence{max})) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int day ;
  static int Hn ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      Hn=in.nextInt();
      day=in.nextInt();
      if(day+Hn==0)break ;
      double[][] hyou=new double[Hn][Hn];
      for(int s=0 ; s<Hn ; s++)for(int i=0 ; i<Hn ; i++)hyou[s][i]=in.nextDouble();
      double[][] dp=new double[Hn][day];
      for(int i=0 ; i<Hn ; i++)dp[i][0]=1.0 ;
      for(int hi=1 ; hi<day ; hi++){
        for(int i=0 ; i<Hn ; i++){
          double max=0 ;
          for(int k=0 ; k<Hn ; k++){
            max=Math.max(max,hyou[k][i]*dp[k][hi-1]);
          }
          dp[i][hi]=max ;
        }
      }
      double max=0 ;
      for(int i=0 ; i<Hn ; i++)max=Math.max(max,dp[i][day-1]);
      System.out.printf("%.2f\n",max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute day : int;
  static   attribute Hn : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     Hn := in.getCurrent()->toInteger() ; 
     day := in.getCurrent()->toInteger() ; 
    if (day + Hn = 0) then     break else skip ; 
    var hyou : Sequence(Sequence(double)) ; hyou := Integer.subrange(1,Hn)->collect(Integer.subrange(1,Hn)->collect(0.0)) ;
        var s : int ; s := 0 ; while s < Hn do (         var i : int ; i := 0 ; while i < Hn do (     hyou[s+1][i+1] := in.getCurrent()->toReal() ;  ;     i := i + 1 ) ;  ;     s := s + 1 ) ; 
    var dp : Sequence(Sequence(double)) ; dp := Integer.subrange(1,Hn)->collect(Integer.subrange(1,day)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < Hn do (     dp[i+1][0+1] := 1.0 ;  ;     i := i + 1 ) ; 
        var hi : int ; hi := 1 ; while hi < day do ( (         var i : int ; i := 0 ; while i < Hn do ( (     var max : double ; max := 0 ;
         var k : int ; k := 0 ; while k < Hn do ( (     max := Set{max, hyou[k+1][i+1] * dp[k+1][hi - 1+1]}->max() )  ;     k := k + 1 ) ; 
     dp[i+1][hi+1] := max )  ;     i := i + 1 ) )  ;     hi := hi + 1 ) ; 
    var max : double ; max := 0 ;
        var i : int ; i := 0 ; while i < Hn do (     max := Set{max, dp[i+1][day - 1+1]}->max() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.2f\n", max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  Scanner sc ;
  Main(){
    sc=new Scanner(System.in);
  }
  int n,m ;
  double[][] gl ;
  double[][] dp ;
  boolean init(){
    n=sc.nextInt();
    m=sc.nextInt();
    if(n==0 && m==0)return false ;
    gl=new double[n][n];
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)gl[i][j]=sc.nextDouble();
    dp=new double[n][m+1];
    for(int i=0 ; i<n ; i++)Arrays.fill(dp[i],-1);
    return true ;
  }
  double solve(double g,int prev,int rem){
    if(rem==0)return g ;
    if(dp[prev][rem]!=-1)return g*dp[prev][rem];
    double max=0.0 ;
    for(int i=0 ; i<n ; i++)max=Math.max(max,solve(gl[prev][i],i,rem-1));
    dp[prev][rem]=max ;
    return g*max ;
  }
  void run(){
    while(init()){
      double max=0 ;
      for(int i=0 ; i<n ; i++)max=Math.max(max,solve(1.0,i,m-1));
      System.out.printf("%.2f\n",Math.round(max*100)/100.0);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   attribute n : int;
   attribute gl : Sequence(Sequence(double));
   attribute dp : Sequence(Sequence(double));
   operation init() : boolean
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
     m := sc.getCurrent()->toInteger() ; 
    if (n = 0 & m = 0) then     return false else skip ; 
    gl := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0.0)) ; 
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (     gl[i+1][j+1] := sc.getCurrent()->toReal() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    dp := Integer.subrange(1,n)->collect(Integer.subrange(1,m + 1)->collect(0.0)) ; 
        var i : int ; i := 0 ; while i < n do (     dp[i+1] := dp[i+1]->collect(-1) ;  ;     i := i + 1 ) ; 
    return true 
 );
   operation solve( g : double, prev : int, rem : int) : double
  pre: true
  post: true
  activity: (     if (rem = 0) then     return g else skip ; 
     if (dp[prev+1][rem+1] /= -1) then     return g * dp[prev+1][rem+1] else skip ; 
    var max : double ; max := 0.0 ;
        var i : int ; i := 0 ; while i < n do (     max := Set{max, solve(gl[prev+1][i+1], i, rem - 1)}->max() ;  ;     i := i + 1 ) ; 
    dp[prev+1][rem+1] := max ; 
    return g * max 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     while (init()) do (     var max : double ; max := 0 ;
         var i : int ; i := 0 ; while i < n do (     max := Set{max, solve(1.0, i, m - 1)}->max() ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].printf("%.2f\n", (max * 100)->round() / 100.0) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  static long MOD=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long k=sc.nextLong();
    HashMap<Long,Boolean>map=new HashMap<>();
    ArrayList<Long>list=new ArrayList<>();
    for(int i=1 ; i*i<=n ; i++){
      if(! map.containsKey(i)){
        map.put((long)i,true);
        list.add((long)i);
      }
      if(! map.containsKey(n/i)){
        map.put((long)(n/i),true);
        list.add(n/i);
      }
    }
    Collections.sort(list);
    int m=list.size();
    long[][] dp=new long[(int)k+1][m];
    for(int i=0 ; i<m ; i++){
      dp[0][i]=1 ;
    }
    for(int j=0 ; j<(int)k ; j++){
      dp[j+1][m-1]=dp[j][0];
      for(int i=m-2 ; i>=0 ; i--){
        dp[j+1][i]=(dp[j+1][i+1]+(list.get(m-i-1)-list.get(m-i-2))*dp[j][m-i-1])% MOD ;
      }
    }
    System.out.println(dp[(int)k][0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : long := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var map : Map(long,Boolean) ; map := Map{} ;
    var list : Sequence(long) ; list := Sequence{} ;
        var i : int ; i := 1 ; while i * i <= n do ( (     if (not(map->keys()->includes(i))) then (     map := map->union(Map{i->oclAsType(long) |-> true}) ; 
     list := list->including(i->oclAsType(long)) ) else skip ; 
     if (not(map->keys()->includes(n / i))) then (     map := map->union(Map{(n / i)->oclAsType(long) |-> true}) ; 
     list := list->including(n / i) ) else skip )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var m : int ; m := list->size() ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,k->oclAsType(int) + 1)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (     dp[0+1][i+1] := 1 )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < k->oclAsType(int) do ( (     dp[j + 1+1][m - 1+1] := dp[j+1][0+1] ; 
         var i : int ; i := m - 2 ; while i >= 0 do ( (     dp[j + 1+1][i+1] := (dp[j + 1+1][i + 1+1] + (list->at(m - i - 1+1) - list->at(m - i - 2+1)) * dp[j+1][m - i - 1+1]) mod MOD )  ;     i := i - 1 ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(dp[k->oclAsType(int)+1][0+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] $){
    Scanner sc=new Scanner(in);
    int n=sc.nextInt();
    int a=sc.nextInt(),b=sc.nextInt(),c=sc.nextInt();
    int[] l=new int[n];
    for(int i=0 ; i<n ; i++)l[i]=sc.nextInt();
    int ans=Integer.MAX_VALUE ;
    for(int i=0 ; i<(1<<n); i++){
      for(int j=0 ; j<(1<<n); j++){
        int la=0,lb=0,lc=0,mp=0 ;
        for(int k=0 ; k<n ; k++){
          int bit1=(i>>k)& 1 ;
          int bit2=(j>>k)& 1 ;
          if(bit1==1 && bit2==1){
            if(la>0)mp+=10 ;
            la+=l[k];
          }
          else if(bit1==1 && bit2==0){
            if(lb>0)mp+=10 ;
            lb+=l[k];
          }
          else if(bit1==0 && bit2==1){
            if(lc>0)mp+=10 ;
            lc+=l[k];
          }
        }
        if(la>0 && lb>0 && lc>0){
          ans=min(ans,mp+abs(a-la)+abs(b-lb)+abs(c-lc));
        }
      }
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     l[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i < ((1*(2->pow(n)))->oclAsType(long)) do ( (         var j : int ; j := 0 ; while j < ((1*(2->pow(n)))->oclAsType(long)) do ( (     var la : int ; la := 0 ;
    var lb : int ; lb := 0 ;
    var lc : int ; lc := 0 ;
    var mp : int ; mp := 0 ;
         var k : int ; k := 0 ; while k < n do ( (     var bit1 : int ; bit1 := MathLib.bitwiseAnd(((i/(2->pow(k)))->oclAsType(long)),1) ;
     var bit2 : int ; bit2 := MathLib.bitwiseAnd(((j/(2->pow(k)))->oclAsType(long)),1) ;
     if (bit1 = 1 & bit2 = 1) then (     if (la > 0) then     mp := mp+(10) ; else skip ; 
     la := la+(l[k+1]) ) else     if (bit1 = 1 & bit2 = 0) then (     if (lb > 0) then     mp := mp+(10) ; else skip ; 
     lb := lb+(l[k+1]) ) else     if (bit1 = 0 & bit2 = 1) then (     if (lc > 0) then     mp := mp+(10) ; else skip ; 
     lc := lc+(l[k+1]) ) else skip ; ;  )  ;     k := k + 1 ) ; 
     if (la > 0 & lb > 0 & lc > 0) then (     ans := Set{ans, mp + abs(a - la) + abs(b - lb) + abs(c - lc)}->min() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean checkPrime(int numberToCheck){
    if(numberToCheck==1){
      return false ;
    }
    for(int i=2 ; i*i<=numberToCheck ; i++){
      if(numberToCheck % i==0){
        return false ;
      }
    }
    return true ;
  }
  static int primeSum(int l,int r){
    int sum=0 ;
    for(int i=r ; i>=l ; i--){
      boolean isPrime=checkPrime(i);
      if(isPrime){
        sum=sum+i ;
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int l=4,r=13 ;
    System.out.println(primeSum(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkPrime( numberToCheck : int) : boolean
  pre: true
  post: true
  activity: (     if (numberToCheck = 1) then (     return false ) else skip ; 
         var i : int ; i := 2 ; while i * i <= numberToCheck do ( (     if (numberToCheck mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation primeSum( l : int, r : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := r ; while i >= l do ( (     var isPrime : boolean ; isPrime := checkPrime(i) ;
     if (isPrime) then (     sum := sum + i ) else skip )  ;     i := i - 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 4 ;
    var r : int ; r := 13 ;
     OclFile["System.out"].println(primeSum(l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPrime(int n){
    int i ;
    if(n==1){
      return false ;
    }
    for(i=2 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        return false ;
      }
    }
    return true ;
  }
  static boolean check_frequency(char[] s){
    HashMap<Character,Integer>m=new HashMap<Character,Integer>();
    for(int i=0 ; i<s.length ; i++){
      if(m.containsKey(s[i])){
        m.put(s[i],m.get(s[i])+1);
      }
      else {
        m.put(s[i],1);
      }
    }
    for(char ch='a' ; ch<='z' ; ch++){
      if(m.get(ch)!=null && m.get(ch)>0 && ! isPrime(m.get(ch))){
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    String s="geeksforgeeks" ;
    if(check_frequency(s.toCharArray())){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ;
     if (n = 1) then (     return false ) else skip ; 
         i := 2 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation check_frequency( s : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     var m : Map(String,int) ; m := Map{} ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (m->keys()->includes(s[i+1])) then (     m := m->union(Map{s[i+1] |-> m->at(s[i+1]) + 1}) ) else (     m := m->union(Map{s[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
         var ch : String ; ch := 'a' ; while ch <= 'z' do ( (     if (m->at(ch) /= null & m->at(ch) > 0 & not(isPrime(m->at(ch)))) then (     return false ) else skip )  ;     ch := ch + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     if (check_frequency(s->characters())) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class codeforceNastia {
  public static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      long prime=1000000007 ;
      int n=sc.nextInt();
      int arr[]=new int[n];
      for(int j=0 ; j<n ; j++){
        arr[j]=sc.nextInt();
      }
      int idx=-1,min=Integer.MAX_VALUE ;
      for(int j=0 ; j<n ; j++){
        if(min>arr[j]){
          min=arr[j];
          idx=j ;
        }
      }
      int start=1,opration=n/2 ;
      if(idx % 2!=0){
        start=0 ;
        opration=(n+1)/2 ;
      }
      System.out.println(opration);
      for(int j=0 ; j<opration ; j++){
        System.out.print((idx+1)+" "+(start+1)+" "+arr[idx]+" "+prime);
        start+=2 ;
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforceNastia {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var prime : long ; prime := 1000000007 ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     arr[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    var idx : int ; idx := -1 ;
    var min : int ; min := 2147483647 ;
        var j : int ; j := 0 ; while j < n do ( (     if (min > arr[j+1]) then (     min := arr[j+1] ; 
     idx := j ) else skip )  ;     j := j + 1 ) ; 
    var start : int ; start := 1 ;
    var opration : int ; opration := n / 2 ;
    if (idx mod 2 /= 0) then (     start := 0 ; 
     opration := (n + 1) / 2 ) else skip ; 
    OclFile["System.out"].println(opration) ; 
        var j : int ; j := 0 ; while j < opration do ( (     OclFile["System.out"].print((idx + 1) + " " + (start + 1) + " " + arr[idx+1] + " " + prime) ; 
     start := start+(2) ; 
     OclFile["System.out"].println() )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class LetsGoHiking_706B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++)nums[i]=sc.nextInt();
    sc.close();
    int[] left=new int[n];
    int ct=1,maxCount=1,max=1 ;
    left[0]=1 ;
    for(int i=1 ; i<n ; i++){
      if(nums[i]>nums[i-1]){
        ct++;
      }
      else {
        ct=1 ;
      }
      if(ct>max){
        maxCount=0 ;
        max=ct ;
      }
      if(ct==max)maxCount++;
      left[i]=ct ;
    }
    if(max % 2==0 || maxCount!=1){
      System.out.println(0);
      return ;
    }
    ct=1 ;
    boolean found=false ;
    for(int i=n-2 ; i>-1 ; i--){
      if(nums[i]>nums[i+1]){
        ct++;
      }
      else {
        ct=1 ;
      }
      if(ct>max || ct==max && left[i]!=max){
        System.out.println(0);
        return ;
      }
      if(ct==max)found=true ;
    }
    if(found){
      System.out.println(1);
    }
    else {
      System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class LetsGoHiking_706B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     nums[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    skip ; 
    var left : Sequence(int) ; left := Integer.subrange(1,n)->collect(0) ;
    var ct : int ; ct := 1 ;
    var maxCount : int ; maxCount := 1 ;
    var max : int ; max := 1 ;
    left[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < n do ( (     if (nums[i+1] > nums[i - 1+1]) then (     ct := ct + 1 ) else (     ct := 1 ) ;  
     if (ct > max) then (     maxCount := 0 ; 
     max := ct ) else skip ; 
     if (ct = max) then     maxCount := maxCount + 1 ; else skip ; 
     left[i+1] := ct )  ;     i := i + 1 ) ; 
    if (max mod 2 = 0 or maxCount /= 1) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    ct := 1 ; 
    var found : boolean ; found := false ;
        var i : int ; i := n - 2 ; while i > -1 do ( (     if (nums[i+1] > nums[i + 1+1]) then (     ct := ct + 1 ) else (     ct := 1 ) ;  
     if (ct > max or ct = max & left[i+1] /= max) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
     if (ct = max) then     found := true ; else skip )  ;     i := i - 1 ) ; 
    if (found) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(0) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    int n=Integer.parseInt(f.readLine());
    StringTokenizer st=new StringTokenizer(f.readLine());
    int[] p=new int[n];
    for(int i=0 ; i<n ; i++){
      p[i]=Integer.parseInt(st.nextToken());
    }
    int[] left=new int[n];
    left[0]=1 ;
    for(int i=1 ; i<n ; i++){
      if(p[i]>p[i-1]){
        left[i]=left[i-1]+1 ;
      }
      else {
        left[i]=1 ;
      }
    }
    int[] right=new int[n];
    right[n-1]=1 ;
    for(int i=n-2 ; i>=0 ; i--){
      if(p[i]>p[i+1]){
        right[i]=right[i+1]+1 ;
      }
      else {
        right[i]=1 ;
      }
    }
    int max=0 ;
    boolean flag=false ;
    for(int i=0 ; i<n ; i++){
      int temp=Math.max(left[i],right[i]);
      if(temp>max){
        max=temp ;
        flag=(Math.min(left[i],right[i])+1)/2*2<=temp ;
      }
      else if(temp==max){
        flag=true ;
      }
    }
    out.println(max % 2==0 || flag ? 0 : 1);
    f.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    var n : int ; n := (f.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    var left : Sequence(int) ; left := Integer.subrange(1,n)->collect(0) ;
    left[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < n do ( (     if (p[i+1] > p[i - 1+1]) then (     left[i+1] := left[i - 1+1] + 1 ) else (     left[i+1] := 1 ) )  ;     i := i + 1 ) ; 
    var right : Sequence(int) ; right := Integer.subrange(1,n)->collect(0) ;
    right[n - 1+1] := 1 ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (p[i+1] > p[i + 1+1]) then (     right[i+1] := right[i + 1+1] + 1 ) else (     right[i+1] := 1 ) )  ;     i := i - 1 ) ; 
    var max : int ; max := 0 ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : int ; temp := Set{left[i+1], right[i+1]}->max() ;
     if (temp > max) then (     max := temp ; 
     flag := (Set{left[i+1], right[i+1]}->min() + 1) / 2 * 2 <= temp ) else     if (temp = max) then (     flag := true ) else skip ; )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static SortedSet<Integer>t=new TreeSet<Integer>();
  static void performQueryOne(int num){
    t.add(num);
  }
  static void performQueryTwo(int num){
    t.remove(num);
  }
  static int performQueryThree(){
    int mini=t.first();
    int maxi=t.last();
    return maxi-mini ;
  }
  public static void main(String[] args){
    int num=3 ;
    performQueryOne(num);
    num=5 ;
    performQueryOne(num);
    num=6 ;
    performQueryOne(num);
    num=5 ;
    performQueryTwo(num);
    num=2 ;
    performQueryOne(num);
    System.out.println(performQueryThree());
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute t : Set(int) := Set{};
  static   operation performQueryOne( num : int) : void
  pre: true
  post: true
  activity: (     t := t->including(num) );
  static   operation performQueryTwo( num : int) : void
  pre: true
  post: true
  activity: (     t := t->excludingFirst(num) );
  static   operation performQueryThree() : int
  pre: true
  post: true
  activity: (     var mini : int ; mini := t->first() ;
     var maxi : int ; maxi := t->last() ;
     return maxi - mini );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 3 ;
     execute performQueryOne(num) ; 
    num := 5 ; 
    execute performQueryOne(num) ; 
    num := 6 ; 
    execute performQueryOne(num) ; 
    num := 5 ; 
    execute performQueryTwo(num) ; 
    num := 2 ; 
    execute performQueryOne(num) ; 
    OclFile["System.out"].println(performQueryThree()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean findGreater(int x,int y){
    if(x>y){
      return false ;
    }
    else {
      return true ;
    }
  }
  public static void main(String[] args){
    int x=4 ;
    int y=9 ;
    if(findGreater(x,y))System.out.println("1");
    else System.out.println("2");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findGreater( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     if (x > y) then (     return false ) else (     return true ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 4 ;
     var y : int ; y := 9 ;
     if (findGreater(x, y)) then     OclFile["System.out"].println("1") ; else     OclFile["System.out"].println("2") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int __gcd(int a,int b){
    return b==0 ? a : __gcd(b,a % b);
  }
  static boolean coprime(int a,int b){
    return(__gcd(a,b)==1);
  }
  static void pairSum(int n){
    int mid=n/2 ;
    for(int i=mid ; i>=1 ; i--){
      if(coprime(i,n-i)==true){
        System.out.print(i+" "+(n-i));
        break ;
      }
    }
  }
  public static void main(String args[]){
    int n=11 ;
    pairSum(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else __gcd(b, a mod b) endif );
  static   operation coprime( a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     return (__gcd(a, b) = 1) );
  static   operation pairSum( n : int) : void
  pre: true
  post: true
  activity: (     var mid : int ; mid := n / 2 ;
         var i : int ; i := mid ; while i >= 1 do ( (     if (coprime(i, n - i) = true) then (     OclFile["System.out"].print(i + " " + (n - i)) ; 
     break ) else skip )  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 11 ;
     execute pairSum(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int solve(int arr[],int n){
    Arrays.sort(arr);
    int a=0,b=0 ;
    for(int i=0 ; i<n ; i++){
      if(i % 2!=0)a=a*10+arr[i];
      else b=b*10+arr[i];
    }
    return a+b ;
  }
  public static void main(String[] args){
    int arr[]={
      6,8,4,5,2,3 };
      int n=arr.length ;
      System.out.print("Sum is "+solve(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var a : int ; a := 0 ;
    var b : int ; b := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 /= 0) then     a := a * 10 + arr[i+1] ; else     b := b * 10 + arr[i+1] ; )  ;     i := i + 1 ) ; 
     return a + b );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,8,4,5,2,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print("Sum is " + solve(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class FileName {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String str=sc.next();
    int count=0 ;
    int total=0 ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)=='x'){
        count++;
        continue ;
      }
      else {
        if(count>=3){
          total+=count-2 ;
          count=0 ;
        }
        count=0 ;
      }
    }
    if(count>=3){
      total+=count-2 ;
      count=0 ;
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class FileName {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var str : String ; str := sc.getCurrent() ;
    var count : int ; count := 0 ;
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = 'x') then (     count := count + 1 ; 
     continue ) else (     if (count >= 3) then (     total := total+((count)->char2byte() - 2) ; 
     count := 0 ) else skip ; 
     count := 0 ) )  ;     i := i + 1 ) ; 
    if (count >= 3) then (     total := total+((count)->char2byte() - 2) ; 
     count := 0 ) else skip ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPrime(long n){
    if(n<2)return false ;
    for(long i=2 ; i<=Math.sqrt(n); i++){
      if(n % i==0)return false ;
    }
    return true ;
  }
  static String reverse(String s){
    String s1="" ;
    for(int i=s.length()-1 ; i>=0 ; i--)s1+=s.charAt(i);
    return s1 ;
  }
  static long nextPrimePalindrome(long N){
    for(long k=1 ; k<1000000l ; k++){
      String s=""+k ;
      String z ;
      z=reverse(s);
      long x=Long.parseLong(s+z.substring(1,z.length()));
      if(x>=N && isPrime(x))return x ;
      s=""+(k);
      z=s ;
      z=reverse(z);
      x=Long.parseLong(s+z);
      if(x>=N && isPrime(x))return x ;
    }
    return-1 ;
  }
  public static void main(String args[]){
    long N=7000000000l ;
    System.out.println(nextPrimePalindrome(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n < 2) then     return false else skip ; 
         var i : long ; i := 2 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation reverse( s : String) : String
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "" ;
         var i : int ; i := s->size() - 1 ; while i >= 0 do (     s1 := s1+(s->at(i+1)) ;  ;     i := i - 1 ) ; 
     return s1 );
  static   operation nextPrimePalindrome( N : long) : long
  pre: true
  post: true
  activity: (         var k : long ; k := 1 ; while k < 1000000l do ( (     var s : String ; s := "" + k ;
     var z : String ;
    z := reverse(s) ; 
    var x : long ; x := (s + z.subrange(1+1,z->size()))->toLong() ;
    if (x >= N & isPrime(x)) then     return x else skip ; 
    s := "" + (k) ; 
    z := s ; 
    z := reverse(z) ; 
    x := (s + z)->toLong() ; 
    if (x >= N & isPrime(x)) then     return x else skip ; 
 )  ;     k := k + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := 7000000000l ;
     OclFile["System.out"].println(nextPrimePalindrome(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static int N ;
  public static int A ;
  public static int B ;
  public static int C ;
  public static int[] l ;
  public static int mp ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    A=sc.nextInt();
    B=sc.nextInt();
    C=sc.nextInt();
    l=new int[N];
    for(int i=0 ; i<N ; i++){
      l[i]=sc.nextInt();
    }
    sc.close();
    mp=99999999 ;
    dfs(0,0,0,0,0,0,0);
    System.out.println(mp);
  }
  public static void dfs(int i,int a,int b,int c,int acount,int bcount,int ccount){
    if(i==N){
      int mp_=0 ;
      if(a!=0 && b!=0 && c!=0){
        if(acount!=0){
          mp_+=(acount-1)*10 ;
        }
        if(bcount!=0){
          mp_+=(bcount-1)*10 ;
        }
        if(ccount!=0){
          mp_+=(ccount-1)*10 ;
        }
        mp_+=Math.abs(a-A)+Math.abs(b-B)+Math.abs(c-C);
        mp=Math.min(mp,mp_);
      }
      return ;
    }
    dfs(i+1,a,b,c,acount,bcount,ccount);
    dfs(i+1,a+l[i],b,c,acount+1,bcount,ccount);
    dfs(i+1,a,b+l[i],c,acount,bcount+1,ccount);
    dfs(i+1,a,b,c+l[i],acount,bcount,ccount+1);
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute A : int;
  static   attribute B : int;
  static   attribute C : int;
  static   attribute l : Sequence(int);
  static   attribute mp : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
    A := sc.getCurrent()->toInteger() ; 
    B := sc.getCurrent()->toInteger() ; 
    C := sc.getCurrent()->toInteger() ; 
    l := Integer.subrange(1,N)->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     l[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    mp := 99999999 ; 
    execute dfs(0, 0, 0, 0, 0, 0, 0) ; 
    OclFile["System.out"].println(mp) ; 
 );
  static   operation dfs( i : int, a : int, b : int, c : int, acount : int, bcount : int, ccount : int) : void
  pre: true
  post: true
  activity: (     if (i = N) then (     var mp_ : int ; mp_ := 0 ;
     if (a /= 0 & b /= 0 & c /= 0) then (     if (acount /= 0) then (     mp_ := mp_+((acount - 1) * 10) ) else skip ; 
     if (bcount /= 0) then (     mp_ := mp_+((bcount - 1) * 10) ) else skip ; 
    if (ccount /= 0) then (     mp_ := mp_+((ccount - 1) * 10) ) else skip ; 
    mp_ := mp_+(if a - A < 0 then -(a - A) else a - A endif + if b - B < 0 then -(b - B) else b - B endif + if c - C < 0 then -(c - C) else c - C endif) ; 
    mp := Set{mp, mp_}->min() ; 
 ) else skip ; 
     return ) else skip ; 
     execute dfs(i + 1, a, b, c, acount, bcount, ccount) ; 
    execute dfs(i + 1, a + l[i+1], b, c, acount + 1, bcount, ccount) ; 
    execute dfs(i + 1, a, b + l[i+1], c, acount, bcount + 1, ccount) ; 
    execute dfs(i + 1, a, b, c + l[i+1], acount, bcount, ccount + 1) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maxLen=30 ;
  static int findCnt(int arr[],int n,int k){
    int ans=0 ;
    for(int i=1 ; i<n ; i++){
      arr[i]+=arr[i-1];
      if(arr[i]>k || arr[i]<-1*k)ans++;
    }
    if(arr[0]>k || arr[0]<-1*k)ans++;
    Arrays.sort(arr);
    for(int i=0 ; i<n ; i++)ans+=n-upper_bound(arr,0,n,arr[i]+k);
    return ans ;
  }
  static int upper_bound(int[] a,int low,int high,int element){
    while(low<high){
      int middle=low+(high-low)/2 ;
      if(a[middle]>element)high=middle ;
      else low=middle+1 ;
    }
    return low ;
  }
  public static void main(String[] args){
    int arr[]={
-1,4,-5,6 };
      int n=arr.length ;
      int k=0 ;
      System.out.println(findCnt(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute maxLen : int := 30;
  static   operation findCnt( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     arr[i+1] := arr[i+1]+(arr[i - 1+1]) ; 
     if (arr[i+1] > k or arr[i+1] < -1 * k) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (arr[0+1] > k or arr[0+1] < -1 * k) then     ans := ans + 1 ; else skip ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n do (     ans := ans+(n - upper_bound(arr, 0, n, arr[i+1] + k)) ;  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation upper_bound( a : Sequence(int), low : int, high : int, element : int) : int
  pre: true
  post: true
  activity: (     while (low < high) do (     var middle : int ; middle := low + (high - low) / 2 ;
     if (a[middle+1] > element) then     high := middle ; else     low := middle + 1 ; ) ; 
     return low );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-1,4,-5,6} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 0 ;
     OclFile["System.out"].println(findCnt(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    try {
      File file=new File("input.txt");
      BufferedReader br=new BufferedReader(new FileReader(file));
      String st=br.readLine();
      int temp=Integer.parseInt(st);
      while((st=br.readLine())!=null){
        int pos1=Integer.parseInt(st.charAt(0)+"");
        int pos2=Integer.parseInt(st.charAt(2)+"");
        if(pos1==temp){
          temp=pos2 ;
        }
        else if(pos2==temp){
          temp=pos1 ;
        }
      }
      PrintWriter out=new PrintWriter(new FileWriter("output.txt"));
      out.println(temp);
      out.close();
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     try (     var file : OclFile ; file := OclFile("input.txt") ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) ;
    var st : String ; st := br.readLine() ;
    var temp : int ; temp := (st)->toInteger() ;
        st := br.readLine() ;
    while ((st) /= null) do (    skip ; (     var pos1 : int ; pos1 := (st->at(0+1) + "")->toInteger() ;
     var pos2 : int ; pos2 := (st->at(2+1) + "")->toInteger() ;
     if (pos1 = temp) then (     temp := pos2 ) else     if (pos2 = temp) then (     temp := pos1 ) else skip ; ) ;     st := br.readLine() ;
 ) ;  
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt"))) ;
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ShellGame {
  public static void solve(Scanner sc,PrintWriter pw){
    int t=sc.nextInt();
    int[] board=new int[4];
    Arrays.fill(board,0);
    board[t]=1 ;
    int a,b,temp ;
    for(int i=0 ; i<3 ; i++){
      a=sc.nextInt();
      b=sc.nextInt();
      temp=board[a];
      board[a]=board[b];
      board[b]=temp ;
    }
    for(int i=1 ; i<=3 ; i++){
      if(board[i]==1){
        pw.println(i);
        return ;
      }
    }
  }
  public static void main(String[] args)throws Exception {
    int t ;
    Scanner sc=new Scanner(new FileReader("input.txt"));
    PrintWriter pw=new PrintWriter(new FileWriter("output.txt"));
    solve(sc,pw);
    pw.flush();
    sc.close();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ShellGame {
  static   operation solve( sc : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.nextInt() ;
     var board : Sequence(int) ; board := Integer.subrange(1,4)->collect(0) ;
    board := board->collect(0) ; 
    board[t+1] := 1 ; 
    var a : int ;
    var b : int ;
    var temp : int ;
        var i : int ; i := 0 ; while i < 3 do ( (     a := sc.nextInt() ; 
     b := sc.nextInt() ; 
    temp := board[a+1] ; 
    board[a+1] := board[b+1] ; 
    board[b+1] := temp ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 3 do ( (     if (board[i+1] = 1) then (     pw.println(i) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ;
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt"))) ;
    execute solve(sc, pw) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Tests {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner in=new Scanner(new FileReader("input.txt"));
    PrintStream out=new PrintStream(new File("output.txt"));
    int n=in.nextInt();
    for(int i=0 ; i<3 ; i++){
      int x=in.nextInt();
      int y=in.nextInt();
      if(x==n){
        n=y ;
      }
      else if(y==n){
        n=x ;
      }
    }
    out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Tests {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("output.txt")) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < 3 do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var y : int ; y := in.getCurrent()->toInteger() ;
     if (x = n) then (     n := y ) else     if (y = n) then (     n := x ) else skip ; )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Scanner ;
public class ShellGame {
  public static void main(String[] args){
    Scanner in=null ;
    PrintWriter out=null ;
    try {
      in=new Scanner(new File("input.txt"));
      OutputStream os=new FileOutputStream("output.txt");
      OutputStreamWriter osw=new OutputStreamWriter(os);
      out=new PrintWriter(osw,true);
    }
    catch(IOException x){
      System.err.format("IOException: %s%n",x);
    }
    int ball=in.nextInt();
    int[] pos=new int[3];
    pos[0]=1 ;
    pos[1]=2 ;
    pos[2]=3 ;
    for(int i=0 ; i<3 ; i++){
      int a=in.nextInt();
      int b=in.nextInt();
      int tmp=pos[a-1];
      pos[a-1]=pos[b-1];
      pos[b-1]=tmp ;
    }
    for(int i=0 ; i<3 ; i++){
      if(pos[i]==ball){
        out.printf("%d\n",i+1);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ShellGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := null ;
     var out : OclFile ; out := null ;
    try (     in := OclFile.newOclFile_Read(OclFile("input.txt")) ; 
     var os : OclFile ; os := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
     var osw : OclFile ; osw := OclFile.newOclFile_Write(os) ;
     out := OclFile.newOclFile_Write(osw, true) )   catch (x : IOException) do (     OclFile["System.err"].format("IOException: %s%n", x) )
    var ball : int ; ball := in.getCurrent()->toInteger() ;
    var pos : Sequence(int) ; pos := Integer.subrange(1,3)->collect(0) ;
    pos[0+1] := 1 ; 
    pos[1+1] := 2 ; 
    pos[2+1] := 3 ; 
        var i : int ; i := 0 ; while i < 3 do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    var tmp : int ; tmp := pos[a - 1+1] ;
    pos[a - 1+1] := pos[b - 1+1] ; 
    pos[b - 1+1] := tmp ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do ( (     if (pos[i+1] = ball) then (     skip ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class CkeckSorted {
  static int arraySortedOrNot(int arr[],int n){
    if(n==1 || n==0)return 1 ;
    if(arr[n-1]<arr[n-2])return 0 ;
    return arraySortedOrNot(arr,n-1);
  }
  public static void main(String[] args){
    int arr[]={
      20,23,23,45,78,88 };
      int n=arr.length ;
      if(arraySortedOrNot(arr,n)!=0)System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
class CkeckSorted {
  static   operation arraySortedOrNot( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1 or n = 0) then     return 1 else skip ; 
     if (arr[n - 1+1] < arr[n - 2+1]) then     return 0 else skip ; 
     return arraySortedOrNot(arr, n - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{20,23,23,45,78,88} ;
     var n : int ; n := arr->size() ;
     if (arraySortedOrNot(arr, n) /= 0) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char[] s=in.nextLine().toCharArray();
    in.close();
    String chs="HQ9" ;
    for(int i=0 ; i<s.length ; i++)if(chs.indexOf(s[i])!=-1){
      System.out.println("YES");
      chs=null ;
      break ;
    }
    if(chs!=null)System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := in.nextLine()->characters() ;
    skip ; 
    var chs : String ; chs := "HQ9" ;
        var i : int ; i := 0 ; while i < s->size() do (     if (chs->indexOf(s[i+1])-1 /= -1) then (     OclFile["System.out"].println("YES") ; 
     chs := null ; 
     break ) else skip ;  ;     i := i + 1 ) ; 
    if (chs /= null) then     OclFile["System.out"].println("NO") ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class HQ9Plus {
  public static void main(String[] args)throws IOException {
    FastIO io=new FastIO();
    String s=io.nextLine();
    boolean doesPrint=false ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='H' || s.charAt(i)=='Q' || s.charAt(i)=='9'){
        doesPrint=true ;
        break ;
      }
    }
    io.println(doesPrint ? "YES" : "NO");
    io.close();
  }
  static class FastIO extends PrintWriter {
    private BufferedReader br ;
    private StringTokenizer st ;
    public FastIO(){
      this(System.in,System.out);
    }
    public FastIO(InputStream in,OutputStream out){
      super(out);
      br=new BufferedReader(new InputStreamReader(in));
    }
    public FastIO(String problemName)throws IOException {
      super(new FileWriter(problemName+".out"));
      br=new BufferedReader(new FileReader(problemName+".in"));
    }
    public String next(){
      try {
        while(st==null || ! st.hasMoreTokens()){
          st=new StringTokenizer(br.readLine());
        }
        return st.nextToken();
      }
      catch(Exception e){
      }
      return null ;
    }
    public String nextLine(){
      try {
        return br.readLine();
      }
      catch(Exception e){
      }
      return null ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public boolean nextBoolean(){
      return Boolean.parseBoolean(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HQ9Plus {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : FastIO ; io := FastIO.newFastIO() ;
     var s : String ; s := io.nextLine() ;
    var doesPrint : boolean ; doesPrint := false ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'H' or s->at(i+1) = 'Q' or s->at(i+1) = '9') then (     doesPrint := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    io.println(if doesPrint then "YES" else "NO" endif) ; 
    io.close() ; 
 );
  static class FastIO extends OclFile {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastIO() : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile["System.in"], OclFile["System.out"]) );
   static operation newFastIO( in : OclFile, out : OclFile) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(in, out);
    return self );
  operation initialise( in : OclFile, out : OclFile) : void
  pre: true  post: true
  activity: (     execute super(out) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   static operation newFastIO( problemName : String) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(problemName);
    return self );
  operation initialise( problemName : String) : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Write(problemName + ".out")) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(problemName + ".in")) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() )   catch (e : ProgramException) do skip
     return null );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : ProgramException) do skip
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextBoolean() : boolean
  pre: true
  post: true
  activity: (     return parseBoolean(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int Squares(int n,int m,int a){
    return((m+a-1)/a)*((n+a-1)/a);
  }
  public static void main(String arr[]){
    int n=6,m=6,a=4 ;
    System.out.println(Squares(n,m,a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation Squares( n : int, m : int, a : int) : int
  pre: true
  post: true
  activity: (     return ((m + a - 1) / a) * ((n + a - 1) / a) );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
    var m : int ; m := 6 ;
    var a : int ; a := 4 ;
     OclFile["System.out"].println(Squares(n, m, a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Codesolver {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str ;
    str=sc.nextLine();
    if(str.contains("Q")|| str.contains("H")|| str.contains("9")){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codesolver {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ;
    str := sc.nextLine() ; 
    if (str->includes("Q") or str->includes("H") or str->includes("9")) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import gcj.GCJ ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Osmos {
  public static void main(String[] args){
    Scanner s=GCJ.createScanner('A',true);
    int T=s.nextInt();
    for(int i=1 ; i<=T ; i++){
      int size=s.nextInt();
      int N=s.nextInt();
      int[] m=new int[N];
      for(int j=0 ; j<N ; j++){
        m[j]=s.nextInt();
      }
      Arrays.sort(m);
      int min=N ;
      if(size>1){
        int cnt=0 ;
        for(int j=0 ; j<N ; j++){
          while(size<=m[j]){
            cnt++;
            size+=size-1 ;
          }
          size+=m[j];
          min=Math.min(min,cnt+N-j-1);
        }
      }
      GCJ.out(i,Integer.toString(min));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Osmos {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := GCJ.createScanner('A', true) ;
     var T : int ; T := s.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= T do ( (     var size : int ; size := s.getCurrent()->toInteger() ;
     var N : int ; N := s.getCurrent()->toInteger() ;
    var m : Sequence(int) ; m := Integer.subrange(1,N)->collect(0) ;
        var j : int ; j := 0 ; while j < N do ( (     m[j+1] := s.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    m := m->sort() ; 
    var min : int ; min := N ;
    if (size > 1) then (     var cnt : int ; cnt := 0 ;
         var j : int ; j := 0 ; while j < N do ( (     while (size <= m[j+1]) do (     cnt := cnt + 1 ; 
     size := size+(size - 1) ) ; 
     size := size+(m[j+1]) ; 
     min := Set{min, cnt + N - j - 1}->min() )  ;     j := j + 1 ) ) else skip ; 
    GCJ.out(i, ((min) + "")) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class pair {
    int first,second ;
    public pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static int countTriplets(int n,Vector<pair>points){
    Set<pair>pts=new HashSet<pair>();
    int ct=0 ;
    for(int i=0 ; i<n ; i++)pts.add(points.get(i));
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++){
      int x=points.get(i).first+points.get(j).first ;
      int y=points.get(i).second+points.get(j).second ;
      if(x % 2==0 && y % 2==0)if(! pts.contains(new pair(x/2,y/2)))ct++;
    }
    return ct ;
  }
  public static void main(String args[]){
    Vector<pair>points=new Vector<>();
    points.add(new pair(1,1));
    points.add(new pair(2,2));
    points.add(new pair(3,3));
    int n=points.size();
    System.out.println(countTriplets(n,points));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class pair {
   attribute first : int;
   static operation newpair( first : int, second : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation countTriplets( n : int, points : Sequence(pair)) : int
  pre: true
  post: true
  activity: (     var pts : Set(pair) ; pts := Set{} ;
     var ct : int ; ct := 0 ;
        var i : int ; i := 0 ; while i < n do (     pts := pts->including(points->at(i+1)) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do ( (     var x : int ; x := points->at(i+1)->at("first") + points->at(j+1)->at("first") ;
     var y : int ; y := points->at(i+1)->at("second") + points->at(j+1)->at("second") ;
     if (x mod 2 = 0 & y mod 2 = 0) then     if (not(pts->includes(pair.newpair(x / 2, y / 2)))) then     ct := ct + 1 ; else skip ; else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return ct 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var points : Sequence(pair) ; points := Sequence{} ;
     points := points->including(pair.newpair(1, 1)) ; 
    points := points->including(pair.newpair(2, 2)) ; 
    points := points->including(pair.newpair(3, 3)) ; 
    var n : int ; n := points->size() ;
    OclFile["System.out"].println(countTriplets(n, points)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int k=sc.nextInt();
      k=k % 4 ;
      if(k==0){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
        for(int i=1 ; i<n ; i+=2){
          if(k==2 && i % 4!=3){
            System.out.println((i+1)+" "+i);
          }
          else {
            System.out.println(i+" "+(i+1));
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     k := k mod 4 ; 
     if (k = 0) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ; 
         var i : int ; i := 1 ; while i < n do ( (     if (k = 2 & i mod 4 /= 3) then (     OclFile["System.out"].println((i + 1) + " " + i) ) else (     OclFile["System.out"].println(i + " " + (i + 1)) ) )  ;     i := i+(2) ) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static boolean unsat(String str){
    boolean check1=false,check2=false,check3=false ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)=='3')check3=true ;
      else if(str.charAt(i)=='1')check1=true ;
      else if(str.charAt(i)=='2')check2=true ;
    }
    return !(check3 && check1 && check2);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt(),A=sc.nextInt(),B=sc.nextInt(),C=sc.nextInt();
    int[] l=new int[N];
    for(int i=0 ; i<N ; i++)l[i]=sc.nextInt();
    int ans=Integer.MAX_VALUE ;
    for(int i=0 ; i<(1<<(2*N)); i++){
      String set=Integer.toString(i,4);
      while(set.length()<N)set="0"+set ;
      if(unsat(set))continue ;
      int tmp=0,tmpA=0,tmpB=0,tmpC=0 ;
      for(int j=0 ; j<set.length(); j++){
        if(set.charAt(j)=='1'){
          if(tmpA!=0)tmp+=10 ;
          tmpA+=l[j];
        }
        else if(set.charAt(j)=='2'){
          if(tmpB!=0)tmp+=10 ;
          tmpB+=l[j];
        }
        else if(set.charAt(j)=='3'){
          if(tmpC!=0)tmp+=10 ;
          tmpC+=l[j];
        }
      }
      tmp+=Math.abs(tmpA-A)+Math.abs(tmpB-B)+Math.abs(tmpC-C);
      ans=Math.min(ans,tmp);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation unsat( str : String) : boolean
  pre: true
  post: true
  activity: (     var check1 : boolean ; check1 := false ;
    var check2 : boolean ; check2 := false ;
    var check3 : boolean ; check3 := false ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '3') then     check3 := true ; else     if (str->at(i+1) = '1') then     check1 := true else     if (str->at(i+1) = '2') then     check2 := true ; else skip ; ;  )  ;     i := i + 1 ) ; 
     return not((check3 & check1 & check2)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     l[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i < ((1*(2->pow((2 * N))))->oclAsType(long)) do ( (     var set : String ; set := ((i) + "") ;
     while (set->size() < N) do     set := "0" + set ; ; 
    if (unsat(set)) then     continue else skip ; 
    var tmp : int ; tmp := 0 ;
    var tmpA : int ; tmpA := 0 ;
    var tmpB : int ; tmpB := 0 ;
    var tmpC : int ; tmpC := 0 ;
        var j : int ; j := 0 ; while j < set->size() do ( (     if (set->at(j+1) = '1') then (     if (tmpA /= 0) then     tmp := tmp+(10) ; else skip ; 
     tmpA := tmpA+(l[j+1]) ) else     if (set->at(j+1) = '2') then (     if (tmpB /= 0) then     tmp := tmp+(10) ; else skip ; 
     tmpB := tmpB+(l[j+1]) ) else     if (set->at(j+1) = '3') then (     if (tmpC /= 0) then     tmp := tmp+(10) ; else skip ; 
     tmpC := tmpC+(l[j+1]) ) else skip ; ;  )  ;     j := j + 1 ) ; 
    tmp := tmp+(if (tmpA)->char2byte() - A < 0 then -((tmpA)->char2byte() - A) else (tmpA)->char2byte() - A endif + if (tmpB)->char2byte() - B < 0 then -((tmpB)->char2byte() - B) else (tmpB)->char2byte() - B endif + if (tmpC)->char2byte() - C < 0 then -((tmpC)->char2byte() - C) else (tmpC)->char2byte() - C endif) ; 
    ans := Set{ans, tmp}->min() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  private static String fileName=A.class.getSimpleName().replaceFirst("_.*","").toLowerCase();
  private static String inputFileName=fileName+".in" ;
  private static String outputFileName=fileName+".out" ;
  private static Scanner in ;
  private static PrintWriter out ;
  private void solve(){
    long s=in.nextInt();
    int n=in.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    Arrays.sort(a);
    int ans=n ;
    int created=0 ;
    for(int i=0 ; i<n ; i++){
      if(s==1){
        break ;
      }
      while(s<=a[i]){
        created++;
        s+=s-1 ;
      }
      s+=a[i];
      ans=Math.min(ans,created+n-i-1);
    }
    out.println(ans);
  }
  public static void main(String[] args)throws IOException {
    Locale.setDefault(Locale.US);
    if(args.length>=2){
      inputFileName=args[0];
      outputFileName=args[1];
    }
    in=new Scanner(new FileReader(inputFileName));
    out=new PrintWriter(outputFileName);
    int tests=in.nextInt();
    in.nextLine();
    for(int t=1 ; t<=tests ; t++){
      out.print("Case #"+t+": ");
      new A().solve();
      System.out.println("Case #"+t+": solved");
    }
    in.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute fileName : String := OclType["A"].getSimpleName().replaceFirstMatch("_.*", "")->toLowerCase();
  static   attribute inputFileName : String := fileName + ".in";
  static   attribute outputFileName : String := fileName + ".out";
  static   attribute in : OclFile;
  static   attribute out : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     var s : long ; s := in.getCurrent()->toInteger() ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var ans : int ; ans := n ;
    var created : int ; created := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s = 1) then (     break ) else skip ; 
     while (s <= a[i+1]) do (     created := created + 1 ; 
     s := s+(s - 1) ) ; 
     s := s+(a[i+1]) ; 
     ans := Set{ans, created + n - i - 1}->min() )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.US) ; 
     if (args->size() >= 2) then (     inputFileName := args[0+1] ; 
     outputFileName := args[1+1] ) else skip ; 
    in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(inputFileName))) ; 
    out := OclFile.newOclFile_Write(OclFile.newOclFile(outputFileName)) ; 
    var tests : int ; tests := in.getCurrent()->toInteger() ;
    skip ; 
        var t : int ; t := 1 ; while t <= tests do ( (     skip ; 
     A.newA().solve() ; 
     OclFile["System.out"].println("Case #" + t + ": solved") )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round1b ;
import java.io.FileInputStream ;
import java.io.FileNotFoundException ;
import java.io.FileOutputStream ;
import java.util.Arrays ;
public class A {
  public static void main(String[] args)throws FileNotFoundException {
    Kattio io ;
    io=new Kattio(new FileInputStream("src/round1b/A-large.in"),new FileOutputStream("src/round1b/A-large.out"));
    int cases=io.getInt();
    for(int i=1 ; i<=cases ; i++){
      io.print("Case #"+i+": ");
      new A().solve(io);
    }
    io.close();
  }
  private void solve(Kattio io){
    int mySize=io.getInt();
    int n=io.getInt();
    int size[]=new int[n];
    for(int i=0 ; i<n ; i++){
      size[i]=io.getInt();
    }
    Arrays.sort(size);
    if(mySize==1){
      io.println(n);
      return ;
    }
    int best=Integer.MAX_VALUE ;
    for(int rem=0 ; rem<=n ; rem++){
      int cur=mySize,added=0 ;
      for(int i=0 ; i<n-rem ; i++){
        if(cur<=size[i]){
          cur+=(cur-1);
          added++;
          i--;
        }
        else {
          cur+=size[i];
        }
      }
      best=Math.min(best,rem+added);
    }
    io.println(best);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : Kattio ;
     io := Kattio.newKattio(OclFile.newOclFile_Read(OclFile.newOclFile("src/round1b/A-large.in")), OclFile.newOclFile_Write(OclFile.newOclFile("src/round1b/A-large.out"))) ; 
    var cases : int ; cases := io.getInt() ;
        var i : int ; i := 1 ; while i <= cases do ( (     io.print("Case #" + i + ": ") ; 
     A.newA().solve(io) )  ;     i := i + 1 ) ; 
    io.close() ; 
 );
   operation solve( io : Kattio) : void
  pre: true
  post: true
  activity: (     var mySize : int ; mySize := io.getInt() ;
     var n : int ; n := io.getInt() ;
    var size : Sequence(int) ; size := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     size[i+1] := io.getInt() )  ;     i := i + 1 ) ; 
    size := size->sort() ; 
    if (mySize = 1) then (     io.println(n) ; 
     return ) else skip ; 
    var best : int ; best := 2147483647 ;
        var rem : int ; rem := 0 ; while rem <= n do ( (     var cur : int ; cur := mySize ;
    var added : int ; added := 0 ;
         var i : int ; i := 0 ; while i < n - rem do ( (     if (cur <= size[i+1]) then (     cur := cur+((cur - 1)) ; 
     added := added + 1 ; 
     i := i - 1 ) else (     cur := cur+(size[i+1]) ) )  ;     i := i + 1 ) ; 
     best := Set{best, rem + added}->min() )  ;     rem := rem + 1 ) ; 
    io.println(best) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  static long[][] dp ;
  public static void main(String[] args)throws Exception {
    Scanner scan=new Scanner(System.in);
    int taskCount=scan.nextInt();
    dp=new long[101][201];
    for(int taskIndex=1 ; taskIndex<=taskCount ; taskIndex++){
      int A=scan.nextInt();
      int N=scan.nextInt();
      int[] arr=new int[N];
      for(int i=0 ; i<N ; i++){
        arr[i]=scan.nextInt();
      }
      Arrays.sort(arr);
      for(int i=0 ; i<=N ; i++){
        for(int j=0 ; j<=200 ; j++){
          dp[i][j]=-1 ;
        }
      }
      dp[0][0]=A ;
      for(int i=1 ; i<=N ; i++){
        long current=arr[i-1];
        for(int j=0 ; j<=200 ; j++){
          if(dp[i-1][j]==-1){
            continue ;
          }
          dp[i][j+1]=Math.max(dp[i][j+1],dp[i-1][j]);
          if(dp[i-1][j]<=1){
            continue ;
          }
          long temp=dp[i-1][j];
          int add=0 ;
          while(temp<=current){
            temp+=temp-1 ;
            add++;
          }
          dp[i][j+add]=Math.max(dp[i][j+add],temp+current);
        }
      }
      int res=-1 ;
      for(int i=0 ; i<=200 ; i++){
        if(dp[N][i]>=0){
          res=i ;
          break ;
        }
      }
      System.out.println(String.format("Case #%d: %d",taskIndex,res));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dp : Sequence(Sequence(long));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var taskCount : int ; taskCount := scan.getCurrent()->toInteger() ;
     dp := Integer.subrange(1,101)->collect(Integer.subrange(1,201)->collect(0)) ; 
         var taskIndex : int ; taskIndex := 1 ; while taskIndex <= taskCount do ( (     var A : int ; A := scan.getCurrent()->toInteger() ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i <= N do ( (         var j : int ; j := 0 ; while j <= 200 do ( (     dp[i+1][j+1] := -1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := A ; 
        var i : int ; i := 1 ; while i <= N do ( (     var current : long ; current := arr[i - 1+1] ;
         var j : int ; j := 0 ; while j <= 200 do ( (     if (dp[i - 1+1][j+1] = -1) then (     continue ) else skip ; 
     dp[i+1][j + 1+1] := Set{dp[i+1][j + 1+1], dp[i - 1+1][j+1]}->max() ; 
    if (dp[i - 1+1][j+1] <= 1) then (     continue ) else skip ; 
    var temp : long ; temp := dp[i - 1+1][j+1] ;
    var add : int ; add := 0 ;
    while (temp <= current) do (     temp := temp+(temp - 1) ; 
     add := add + 1 ) ; 
    dp[i+1][j + add+1] := Set{dp[i+1][j + add+1], temp + current}->max() ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : int ; res := -1 ;
        var i : int ; i := 0 ; while i <= 200 do ( (     if (dp[N+1][i+1] >= 0) then (     res := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(StringLib.format("Case #%d: %d",Sequence{taskIndex,res})) ; 
 )  ;     taskIndex := taskIndex + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class A {
  int calc(int a,int[] b){
    int i=0 ;
    int res=0 ;
    if(a==1){
      return 100000 ;
    }
    while(i<b.length){
      if(b[i]<a){
        a+=b[i];
        i++;
      }
      else {
        a+=a-1 ;
        res++;
      }
    }
    return res ;
  }
  void solve(int a,int[] b){
    Arrays.sort(b);
    int best=b.length ;
    for(int i=0 ; i<=b.length ; i++){
      best=Math.min(best,calc(a,Arrays.copyOf(b,i))+(b.length-i));
    }
    System.out.println(best);
  }
  void run(){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int it=0 ; it<t ; it++){
      System.out.print("Case #"+(it+1)+": ");
      int a=in.nextInt();
      int n=in.nextInt();
      int[] b=new int[n];
      for(int i=0 ; i<n ; i++){
        b[i]=in.nextInt();
      }
      solve(a,b);
    }
  }
  public static void main(String[] args){
    new A().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   operation calc( a : int, b : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var res : int ; res := 0 ;
    if (a = 1) then (     return 100000 ) else skip ; 
    while (i < b->size()) do (     if (b[i+1] < a) then (     a := a+(b[i+1]) ; 
     i := i + 1 ) else (     a := a+(a - 1) ; 
     res := res + 1 ) ) ; 
    return res 
 );
   operation solve( a : int, b : Sequence(int)) : void
  pre: true
  post: true
  activity: (     b := b->sort() ; 
     var best : int ; best := b->size() ;
         var i : int ; i := 0 ; while i <= b->size() do ( (     best := Set{best, calc(a, b.subrange(1,i)) + (b->size() - i)}->min() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(best) );
   operation run() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var it : int ; it := 0 ; while it < t do ( (     OclFile["System.out"].print("Case #" + (it + 1) + ": ") ; 
     var a : int ; a := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute solve(a, b) ; 
 )  ;     it := it + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     A.newA().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    try {
      int N=scan.nextInt();
      int M=scan.nextInt();
      int[] X_=new int[M];
      for(int i=0 ; i<M ; i++){
        X_[i]=scan.nextInt();
      }
      Arrays.sort(X_);
      int dist=getDistance(X_,M,N);
      System.out.println(dist);
    }
    finally {
      scan.close();
    }
  }
  static int getDistance(int[] A,int m,int n){
    int[] B=new int[m-1];
    for(int i=0 ; i<m-1 ; i++){
      B[i]=A[i+1]-A[i];
    }
    Arrays.sort(B);
    int sum=0 ;
    for(int i=0 ; i<m-n ; i++){
      sum+=B[i];
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     try (     var N : int ; N := scan.getCurrent()->toInteger() ;
     var M : int ; M := scan.getCurrent()->toInteger() ;
    var X_ : Sequence(int) ; X_ := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     X_[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    X_ := X_->sort() ; 
    var dist : int ; dist := getDistance(X_, M, N) ;
    OclFile["System.out"].println(dist) ; 
 )   finally (     skip )
 );
  static   operation getDistance( A : Sequence(int), m : int, n : int) : int
  pre: true
  post: true
  activity: (     var B : Sequence(int) ; B := Integer.subrange(1,m - 1)->collect(0) ;
         var i : int ; i := 0 ; while i < m - 1 do ( (     B[i+1] := A[i + 1+1] - A[i+1] )  ;     i := i + 1 ) ; 
    B := B->sort() ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < m - n do ( (     sum := sum+(B[i+1]) )  ;     i := i + 1 ) ; 
    return sum 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class TwoRegularPolygons {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt(),m=sc.nextInt();
      System.out.println((n % m)==0 ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TwoRegularPolygons {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if (n mod m) = 0 then "YES" else "NO" endif) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.System.in ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    int[] x=new int[m];
    for(int i=0 ; i<m ; i++)x[i]=sc.nextInt();
    Arrays.sort(x);
    int ans=help(n,m,x);
    System.out.println(ans);
  }
  static int help(int n,int m,int[] x){
    if(n>=m)return 0 ;
    int[] dif=new int[m-1];
    for(int i=0 ; i<m-1 ; i++)dif[i]=x[i+1]-x[i];
    int sum=0 ;
    Arrays.sort(dif);
    for(int i=0 ; i<m-n ; i++)sum+=dif[i];
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     x[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    x := x->sort() ; 
    var ans : int ; ans := help(n, m, x) ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation help( n : int, m : int, x : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (n >= m) then     return 0 else skip ; 
     var dif : Sequence(int) ; dif := Integer.subrange(1,m - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < m - 1 do (     dif[i+1] := x[i + 1+1] - x[i+1] ;  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    dif := dif->sort() ; 
        var i : int ; i := 0 ; while i < m - n do (     sum := sum+(dif[i+1]) ;  ;     i := i + 1 ) ; 
    return sum 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in);
){
      new Main().solve(sc);
    }
  }
  void solve(Scanner sc){
    int n=sc.nextInt();
    int m=sc.nextInt();
    if(n>=m){
      System.out.println(0);
      return ;
    }
    int[] xs=new int[m];
    for(int i=0 ; i<m ; i++){
      xs[i]=sc.nextInt();
    }
    Arrays.sort(xs);
    Integer[] ds=new Integer[m-1];
    for(int i=0 ; i<m-1 ; i++){
      ds[i]=Math.abs(xs[i+1]-xs[i]);
    }
    Arrays.sort(ds,Collections.reverseOrder());
    int ans=0 ;
    for(int i=n-1 ; i<m-1 ; i++){
      ans+=ds[i];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     Main.newMain().solve(sc) ))  );
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if (n >= m) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var xs : Sequence(int) ; xs := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     xs[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    xs := xs->sort() ; 
    var ds : Sequence(int) ; ds := Integer.subrange(1,m - 1)->collect(null) ;
        var i : int ; i := 0 ; while i < m - 1 do ( (     ds[i+1] := if xs[i + 1+1] - xs[i+1] < 0 then -(xs[i + 1+1] - xs[i+1]) else xs[i + 1+1] - xs[i+1] endif )  ;     i := i + 1 ) ; 
    ds := OclComparator.sortWith(ds, reverseOrder()) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := n - 1 ; while i < m - 1 do ( (     ans := ans+(ds[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    ArrayList<Integer>List=new ArrayList<>();
    for(int a=0 ; a<M ; a++)List.add(sc.nextInt());
    Collections.sort(List,Comparator.reverseOrder());
    ArrayList<Integer>dis_List=new ArrayList<>();
    for(int a=0 ; a<List.size()-1 ; a++){
      int dis=List.get(a)-List.get(a+1);
      dis_List.add(dis);
    }
    Collections.sort(dis_List,Comparator.reverseOrder());
    for(int a=0 ; a<N-1 ; a++){
      if(dis_List.size()==0)break ;
      dis_List.remove(0);
    }
    int sum=0 ;
    for(int a=0 ; a<dis_List.size(); a++)sum+=dis_List.get(a);
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var List : Sequence(int) ; List := Sequence{} ;
        var a : int ; a := 0 ; while a < M do (     List := List->including(sc.getCurrent()->toInteger()) ;  ;     a := a + 1 ) ; 
    List, Comparator.reverseOrder() := List, Comparator.reverseOrder()->sort() ; 
    var dis_List : Sequence(int) ; dis_List := Sequence{} ;
        var a : int ; a := 0 ; while a < List->size() - 1 do ( (     var dis : int ; dis := List->at(a+1) - List->at(a + 1+1) ;
     dis_List := dis_List->including(dis) )  ;     a := a + 1 ) ; 
    dis_List, Comparator.reverseOrder() := dis_List, Comparator.reverseOrder()->sort() ; 
        var a : int ; a := 0 ; while a < N - 1 do ( (     if (dis_List->size() = 0) then     break else skip ; 
     dis_List := dis_List->excludingAt(0+1) )  ;     a := a + 1 ) ; 
    var sum : int ; sum := 0 ;
        var a : int ; a := 0 ; while a < dis_List->size() do (     sum := sum+(dis_List->at(a+1)) ;  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    if(N>=M){
      System.out.println(0);
      System.exit(0);
    }
    int x[]=new int[M];
    for(int i=0 ; i<M ; i++){
      x[i]=sc.nextInt();
    }
    Arrays.sort(x);
    int l[]=new int[M-1];
    for(int i=0 ; i<M-1 ; i++){
      l[i]=x[i+1]-x[i];
    }
    int length=x[M-1]-x[0];
    Arrays.sort(l);
    for(int i=0 ; i<N-1 ; i++){
      length=length-l[M-2-i];
    }
    System.out.println(length);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    if (N >= M) then (     OclFile["System.out"].println(0) ; 
 OclProcess.exit(0) ) else skip ; 
    var x : Sequence(int) ; x := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     x[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    x := x->sort() ; 
    var l : Sequence(int) ; l := Integer.subrange(1,M - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < M - 1 do ( (     l[i+1] := x[i + 1+1] - x[i+1] )  ;     i := i + 1 ) ; 
    var length : int ; length := x[M - 1+1] - x[0+1] ;
    l := l->sort() ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     length := length - l[M - 2 - i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(length) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[]){
    FastReader input=new FastReader();
    PrintWriter out=new PrintWriter(System.out);
    int T=1 ;
    while(T-->0){
      long n=input.nextLong();
      long q=input.nextLong();
      for(int i=0 ; i<q ; i++){
        long x=input.nextLong();
        if(x % 2!=0){
          out.println(x/2+1);
        }
        else {
          long d=n-1 ;
          long y=x/2 ;
          d=d-(y-1);
          while(true){
            x=x+d ;
            if(d % 2!=0){
              break ;
            }
            d=d/2 ;
          }
          out.println(x/2+1);
        }
      }
    }
    out.close();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastReader ; input := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := 1 ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     var n : long ; n := input.nextLong() ;
     var q : long ; q := input.nextLong() ;
         var i : int ; i := 0 ; while i < q do ( (     var x : long ; x := input.nextLong() ;
     if (x mod 2 /= 0) then (     skip ) else (     var d : long ; d := n - 1 ;
     var y : long ; y := x / 2 ;
    d := d - (y - 1) ; 
    while (true) do (     x := x + d ; 
     if (d mod 2 /= 0) then (     break ) else skip ; 
     d := d / 2 ) ; 
    skip ; 
 ) )  ;     i := i + 1 ) ) ;  ) ;  
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static int sum(List<Integer>bamboos){
    int ans=0 ;
    for(int x : bamboos)ans+=x ;
    return ans ;
  }
  static int magicPoint(List<Integer>bamboos,int target){
    if(bamboos.isEmpty())return 1000000 ;
    return 10*(bamboos.size()-1)+Math.abs(sum(bamboos)-target);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    int[] allBamboos=new int[N];
    for(int n=0 ; n<N ; n++)allBamboos[n]=sc.nextInt();
    int ans=1000000 ;
    for(int i=1 ; i<65536 ; i++){
      List<Integer>aBamboos=new ArrayList<>();
      List<Integer>bBamboos=new ArrayList<>();
      List<Integer>cBamboos=new ArrayList<>();
      for(int n=0 ; n<N ; n++){
        switch((i>>(2*n))& 3){
          case 1 : aBamboos.add(allBamboos[n]);
          break ;
          case 2 : bBamboos.add(allBamboos[n]);
          break ;
          case 3 : cBamboos.add(allBamboos[n]);
          break ;
        }
      }
      if(aBamboos.isEmpty()&& bBamboos.isEmpty()&& cBamboos.isEmpty())break ;
      int mp=magicPoint(aBamboos,A)+magicPoint(bBamboos,B)+magicPoint(cBamboos,C);
      ans=Math.min(ans,mp);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation sum( bamboos : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     for (x : bamboos) do (     ans := ans+(x) ;  ) ; 
     return ans );
  static   operation magicPoint( bamboos : Sequence(int), target : int) : int
  pre: true
  post: true
  activity: (     if (bamboos->isEmpty()) then     return 1000000 else skip ; 
     return 10 * (bamboos->size() - 1) + if sum(bamboos) - target < 0 then -(sum(bamboos) - target) else sum(bamboos) - target endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var allBamboos : Sequence(int) ; allBamboos := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do (     allBamboos[n+1] := sc.getCurrent()->toInteger() ;  ;     n := n + 1 ) ; 
    var ans : int ; ans := 1000000 ;
        var i : int ; i := 1 ; while i < 65536 do ( (     var aBamboos : Sequence(int) ; aBamboos := Sequence{} ;
     var bBamboos : Sequence(int) ; bBamboos := Sequence{} ;
    var cBamboos : Sequence(int) ; cBamboos := Sequence{} ;
        var n : int ; n := 0 ; while n < N do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (((i/(2->pow((2 * n))))->oclAsType(long)) & 3) ; 
       if _switchval = 1 then
     aBamboos := aBamboos->including(allBamboos[n+1]) ; 
    break 
   else skip ;
       if _switchval = 2 then
     bBamboos := bBamboos->including(allBamboos[n+1]) ; 
    break 
   else skip ;
       if _switchval = 3 then
     cBamboos := cBamboos->including(allBamboos[n+1]) ; 
    break 
   else skip ;
 )
 )  ;     n := n + 1 ) ; 
    if (aBamboos->isEmpty() & bBamboos->isEmpty() & cBamboos->isEmpty()) then     break else skip ; 
    var mp : int ; mp := magicPoint(aBamboos, A) + magicPoint(bBamboos, B) + magicPoint(cBamboos, C) ;
    ans := Set{ans, mp}->min() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedOutputStream ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class B949 {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    long[] pow2=new long[61];
    pow2[0]=1 ;
    for(int i=1 ; i<61 ; i++){
      pow2[i]=pow2[i-1]*2 ;
    }
    StringTokenizer st=new StringTokenizer(br.readLine());
    long n=Long.parseLong(st.nextToken());
    long total=n*2-1 ;
    int q=Integer.parseInt(st.nextToken());
    for(; q-->0 ; ){
      long pos=Long.parseLong(br.readLine());
      if(pos % 2==1){
        out.println((pos+1)/2);
      }
      else {
        long nr=total-pos+1 ;
        for(int i=60 ; i>=0 ; i--){
          if(nr % pow2[i]==0){
            long a=nr/pow2[i];
            if(a*pow2[i]-1+pos==total){
              out.println((total-a)/2L+1L);
              break ;
            }
          }
        }
      }
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B949 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var pow2 : Sequence(long) ; pow2 := Integer.subrange(1,61)->collect(0) ;
    pow2[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < 61 do ( (     pow2[i+1] := pow2[i - 1+1] * 2 )  ;     i := i + 1 ) ; 
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : long ; n := (st.next())->toLong() ;
    var total : long ; total := n * 2 - 1 ;
    var q : int ; q := (st.next())->toInteger() ;
      while q > 0 do ( (     var pos : long ; pos := (br.readLine())->toLong() ;
     if (pos mod 2 = 1) then (     skip ) else (     var nr : long ; nr := total - pos + 1 ;
         var i : int ; i := 60 ; while i >= 0 do ( (     if (nr mod pow2[i+1] = 0) then (     var a : long ; a := nr / pow2[i+1] ;
     if (a * pow2[i+1] - 1 + pos = total) then (     skip ; 
     break ) else skip ) else skip )  ;     i := i - 1 ) ) )  ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int numPerson=in.nextInt();
    int[] arr1=new int[numPerson];
    int[] arr2=new int[numPerson];
    String ans="" ;
    int previous=Integer.MAX_VALUE ;
    for(int i=0 ; i<numPerson ; i++){
      arr1[i]=in.nextInt();
      arr2[i]=in.nextInt();
      if(arr1[i]!=arr2[i]){
        ans="rated" ;
        out.println(ans);
        out.close();
        System.exit(0);
      }
    }
    ans="maybe" ;
    for(int i=0 ; i<numPerson ; i++){
      if(previous<arr1[i]){
        ans="unrated" ;
        break ;
      }
      previous=arr1[i];
    }
    out.println(ans);
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new FileReader("sub.in"));
      }
      catch(FileNotFoundException ex){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException ex){
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException ex){
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var numPerson : int ; numPerson := in.nextInt() ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,numPerson)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,numPerson)->collect(0) ;
    var ans : String ; ans := "" ;
    var previous : int ; previous := 2147483647 ;
        var i : int ; i := 0 ; while i < numPerson do ( (     arr1[i+1] := in.nextInt() ; 
     arr2[i+1] := in.nextInt() ; 
     if (arr1[i+1] /= arr2[i+1]) then (     ans := "rated" ; 
     skip ; 
     skip ; 
 OclProcess.exit(0) ) else skip )  ;     i := i + 1 ) ; 
    ans := "maybe" ; 
        var i : int ; i := 0 ; while i < numPerson do ( (     if (previous < arr1[i+1]) then (     ans := "unrated" ; 
     break ) else skip ; 
     previous := arr1[i+1] )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("sub.in"))) )   catch (ex : FileNotFoundException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (ex : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (ex : IOException) do skip
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    int b[]=new int[n];
    int r=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
      if(a[i]!=b[i])r=1 ;
    }
    if(r==1){
      System.out.println("rated");
      System.exit(0);
    }
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++)if(a[i]<a[j])r=-1 ;
    }
    if(r==-1)System.out.println("unrated");
    else System.out.println("maybe");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var r : int ; r := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() ; 
     if (a[i+1] /= b[i+1]) then     r := 1 ; else skip )  ;     i := i + 1 ) ; 
    if (r = 1) then (     OclFile["System.out"].println("rated") ; 
 OclProcess.exit(0) ) else skip ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do (     if (a[i+1] < a[j+1]) then     r := -1 ; else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (r = -1) then     OclFile["System.out"].println("unrated") else     OclFile["System.out"].println("maybe") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    int b[]=new int[n];
    int r=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
      if(a[i]!=b[i])r=1 ;
    }
    if(r==1){
      System.out.println("rated");
      System.exit(0);
    }
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++)if(a[i]<a[j])r=-1 ;
    }
    if(r==-1)System.out.println("unrated");
    else System.out.println("maybe");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var r : int ; r := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() ; 
     if (a[i+1] /= b[i+1]) then     r := 1 ; else skip )  ;     i := i + 1 ) ; 
    if (r = 1) then (     OclFile["System.out"].println("rated") ; 
 OclProcess.exit(0) ) else skip ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do (     if (a[i+1] < a[j+1]) then     r := -1 ; else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (r = -1) then     OclFile["System.out"].println("unrated") else     OclFile["System.out"].println("maybe") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1312 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      int n=scanner.nextInt();
      int m=scanner.nextInt();
      if(n % m==0 || m % n==0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1312 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
     if (n mod m = 0 or m mod n = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder stringBuilder=new StringBuilder();
    StringTokenizer st ;
    int n=parseInt(in.readLine());
    int[] a=new int[n];
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++){
      st=new StringTokenizer(in.readLine());
      a[i]=parseInt(st.nextToken());
      b[i]=parseInt(st.nextToken());
      if(a[i]!=b[i]){
        System.out.println("rated");
        return ;
      }
    }
    for(int i=0 ; i<n-1 ; i++){
      if(a[i+1]>a[i]){
        System.out.println("unrated");
        return ;
      }
    }
    System.out.println("maybe");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var stringBuilder : String ; stringBuilder := StringLib.newString() ;
    var st : OclIterator ;
    var n : int ; n := parseInt(in.readLine()) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     st := OclIterator.newOclIterator_String(in.readLine()) ; 
     a[i+1] := (st.next() + "")->toInteger() ; 
     b[i+1] := (st.next() + "")->toInteger() ; 
     if (a[i+1] /= b[i+1]) then (     OclFile["System.out"].println("rated") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (a[i + 1+1] > a[i+1]) then (     OclFile["System.out"].println("unrated") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("maybe") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    int brr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      brr[i]=sc.nextInt();
    }
    int flag=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]!=brr[i]){
        flag=1 ;
        break ;
      }
    }
    if(flag==1){
      System.out.println("rated");
    }
    else {
      for(int i=0 ; i<n-1 ; i++){
        if(arr[i]<arr[i+1]){
          flag=2 ;
          break ;
        }
      }
      if(flag==2){
        System.out.println("unrated");
      }
      else {
        System.out.println("maybe");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var brr : Sequence(int) ; brr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     brr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] /= brr[i+1]) then (     flag := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 1) then (     OclFile["System.out"].println("rated") ) else (         var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] < arr[i + 1+1]) then (     flag := 2 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (flag = 2) then (     OclFile["System.out"].println("unrated") ) else (     OclFile["System.out"].println("maybe") ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findEvenPair(int A[],int N){
    int count=0 ;
    for(int i=0 ; i<N ; i++){
      if(A[i] % 2!=0)count++;
    }
    int totalPairs=(N*(N-1)/2);
    int oddEvenPairs=count*(N-count);
    return totalPairs-oddEvenPairs ;
  }
  public static void main(String[] args){
    int a[]={
      5,4,7,2,1 };
      int n=a.length ;
      System.out.println(findEvenPair(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findEvenPair( A : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     if (A[i+1] mod 2 /= 0) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    var totalPairs : int ; totalPairs := (N * (N - 1) / 2) ;
    var oddEvenPairs : int ; oddEvenPairs := count * (N - count) ;
    return totalPairs - oddEvenPairs 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{5,4,7,2,1} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(findEvenPair(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import java.util.*;
import java.io.*;
public class StonedGame {
  public static void main(String omkar[])throws Exception {
    BufferedReader infile=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(infile.readLine());
    int T=Integer.parseInt(st.nextToken());
    StringBuilder sb=new StringBuilder();
    while(T-->0){
      st=new StringTokenizer(infile.readLine());
      int N=Integer.parseInt(st.nextToken());
      int[] arr=readArr(N,infile,st);
      int sum=0 ;
      for(int x : arr)sum+=x ;
      Arrays.sort(arr);
      int max=arr[N-1];
      if(sum-max<max)sb.append("T\n");
      else {
        if(sum % 2==1)sb.append("T\n");
        else sb.append("HL\n");
      }
    }
    System.out.print(sb);
  }
  public static int[] readArr(int N,BufferedReader infile,StringTokenizer st)throws Exception {
    int[] arr=new int[N];
    st=new StringTokenizer(infile.readLine());
    for(int i=0 ; i<N ; i++)arr[i]=Integer.parseInt(st.nextToken());
    return arr ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class StonedGame {
  static   operation main( omkar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var infile : OclFile ; infile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(infile.readLine()) ;
    var T : int ; T := (st.next())->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     st := OclIterator.newOclIterator_String(infile.readLine()) ; 
     var N : int ; N := (st.next())->toInteger() ;
    var arr : Sequence(int) ; arr := readArr(N, infile, st) ;
    var sum : int ; sum := 0 ;
    for (x : arr) do (     sum := sum+(x) ;  ) ; 
    arr := arr->sort() ; 
    var max : int ; max := arr[(N)->char2byte() - 1+1] ;
    if (sum - max < max) then     sb := sb + StringLib.newString("T\n") else (     if (sum mod 2 = 1) then     sb := sb + StringLib.newString("T\n") ; else     sb := sb + StringLib.newString("HL\n") ; ) ;  
 ) ;  ) ;  
    OclFile["System.out"].print(sb) ; 
 );
  static   operation readArr( N : int, infile : OclFile, st : OclIterator) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
     st := OclIterator.newOclIterator_String(infile.readLine()) ; 
         var i : int ; i := 0 ; while i < N do (     arr[i+1] := (st.next())->toInteger() ;  ;     i := i + 1 ) ; 
     return arr );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static MyReader scan=new MyReader();
  public static void main(String[] args)throws Exception {
    Main m=new Main();
    int q=scan.nextInt();
    while(q-->0)m.solve();
  }
  void solve()throws Exception {
    int n=scan.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=scan.nextInt();
    }
    if(n==1){
      System.out.println("T");
    }
    else if(n==2){
      if(arr[0]==arr[1]){
        System.out.println("HL");
      }
      else {
        System.out.println("T");
      }
    }
    else {
      Arrays.sort(arr);
      int sum=Arrays.stream(arr).sum();
      if(arr[n-1]>sum-arr[n-1] || sum % 2==1){
        System.out.println("T");
      }
      else {
        System.out.println("HL");
      }
    }
  }
}
class MyReader {
  private BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
  private StringTokenizer tokenizer=new StringTokenizer("");
  private String innerNextLine(){
    try {
      return reader.readLine();
    }
    catch(IOException ex){
      return null ;
    }
  }
  public boolean hasNext(){
    while(! tokenizer.hasMoreTokens()){
      String nextLine=innerNextLine();
      if(nextLine==null){
        return false ;
      }
      tokenizer=new StringTokenizer(nextLine);
    }
    return true ;
  }
  public String nextLine(){
    tokenizer=new StringTokenizer("");
    return innerNextLine();
  }
  public String next(){
    hasNext();
    return tokenizer.nextToken();
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public Long nextLong(){
    return Long.parseLong(next());
  }
  public double nextDouble(){
    return Double.parseDouble(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : MyReader := MyReader.newMyReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     var q : int ; q := scan.nextInt() ;
         while (q > 0) do (        q := q - 1 ;     skip ;     m.solve() ; ;  ) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := scan.nextInt() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scan.nextInt() )  ;     i := i + 1 ) ; 
     if (n = 1) then (     OclFile["System.out"].println("T") ) else     if (n = 2) then (     if (arr[0+1] = arr[1+1]) then (     OclFile["System.out"].println("HL") ) else (     OclFile["System.out"].println("T") ) ) else (     arr := arr->sort() ; 
     var sum : int ; sum := stream(arr)->sum() ;
     if (arr[n - 1+1] > sum - arr[n - 1+1] or sum mod 2 = 1) then (     OclFile["System.out"].println("T") ) else (     OclFile["System.out"].println("HL") ) ) ;  );
}
class MyReader {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute tokenizer : OclIterator := OclIterator.newOclIterator_String("");
   operation innerNextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (ex : IOException) do (     return null )
 );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     var nextLine : String ; nextLine := innerNextLine() ;
     if (nextLine = null) then (     return false ) else skip ; 
     tokenizer := OclIterator.newOclIterator_String(nextLine) ) ; 
     return true );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     tokenizer := OclIterator.newOclIterator_String("") ; 
     return innerNextLine() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute hasNext() ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int cntPairs(int a[],int n){
    int odd=0,even=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i] % 2==1)odd++;
      else if((a[i]/2)% 2==1)even++;
    }
    int ans=odd*even+(odd*(odd-1))/2 ;
    return ans ;
  }
  public static void main(String[] args){
    int a[]={
      4,2,7,11,14,15,18 };
      int n=a.length ;
      System.out.println(cntPairs(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation cntPairs( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var odd : int ; odd := 0 ;
    var even : int ; even := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] mod 2 = 1) then     odd := odd + 1 ; else     if ((a[i+1] / 2) mod 2 = 1) then     even := even + 1 ; else skip ; )  ;     i := i + 1 ) ; 
     var ans : int ; ans := odd * even + (odd * (odd - 1)) / 2 ;
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{4,2,7,11,14,15,18} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(cntPairs(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int minOperations(int n,int m){
    if(m % n!=0)return-1 ;
    int minOperations=0 ;
    int q=m/n ;
    while(q % 2==0){
      q=q/2 ;
      minOperations++;
    }
    while(q % 3==0){
      q=q/3 ;
      minOperations++;
    }
    if(q==1)return minOperations ;
    return-1 ;
  }
  public static void main(String[] args){
    int n=120,m=51840 ;
    System.out.println(minOperations(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation minOperations( n : int, m : int) : int
  pre: true
  post: true
  activity: (     if (m mod n /= 0) then     return -1 else skip ; 
     var minOperations : int ; minOperations := 0 ;
    var q : int ; q := m / n ;
    while (q mod 2 = 0) do (     q := q / 2 ; 
     minOperations := minOperations + 1 ) ; 
    while (q mod 3 = 0) do (     q := q / 3 ; 
     minOperations := minOperations + 1 ) ; 
    if (q = 1) then     return minOperations else skip ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 120 ;
    var m : int ; m := 51840 ;
     OclFile["System.out"].println(minOperations(n, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n+1];
    int[] b=new int[n+1];
    int count=0 ;
    int ans=0 ;
    a[0]=0 ;
    for(int i=1 ; i<=n ; i++)a[i]=sc.nextInt();
    for(int i=n ; i>=1 ; i--){
      for(int j=2 ; j*i<=n ; j++){
        if(b[i*j]==1)count++;
      }
      if(count % 2!=a[i]){
        b[i]=1 ;
        ans++;
      }
      count=0 ;
    }
    System.out.println(ans);
    StringBuilder sb=new StringBuilder();
    for(int i=1 ; i<=n ; i++){
      if(b[i]==1)sb.append(String.valueOf(i)+' ');
    }
    System.out.println(new String(sb));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n + 1)->collect(0) ;
    var count : int ; count := 0 ;
    var ans : int ; ans := 0 ;
    a[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := n ; while i >= 1 do ( (         var j : int ; j := 2 ; while j * i <= n do ( (     if (b[i * j+1] = 1) then     count := count + 1 ; else skip )  ;     j := j + 1 ) ; 
     if (count mod 2 /= a[i+1]) then (     b[i+1] := 1 ; 
     ans := ans + 1 ) else skip ; 
     count := 0 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 1 ; while i <= n do ( (     if (b[i+1] = 1) then     sb := sb + StringLib.newString(((i) + "") + ' ') ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(StringLib.newString(sb)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  static int n ;
  static boolean[] a ;
  static Boolean[] memo ;
  static int count=0 ;
  public static void main(String[] $){
    n=scanner.nextInt();
    a=new boolean[n];
    memo=new Boolean[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scanner.nextInt()==1 ;
    }
    for(int i=1 ; i<=n ; i++){
      f(i);
    }
    System.out.println(count);
    for(int i=0 ; i<n ; i++){
      if(memo[i]){
        System.out.println(i+1);
      }
    }
  }
  static boolean f(int i){
    if(memo[i-1]!=null){
      return memo[i-1];
    }
    boolean b=a[i-1];
    int j=2 ;
    while(i*j<=n){
      if(f(i*j)){
        b=! b ;
      }
      j++;
    }
    if(b){
      count++;
    }
    return memo[i-1]=b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   attribute a : Sequence(boolean);
  static   attribute memo : Sequence(Boolean);
  static   attribute count : int := 0;
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := scanner.getCurrent()->toInteger() ; 
     a := Integer.subrange(1,n)->collect(false) ; 
    memo := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() = 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     execute f(i) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (memo[i+1]) then (     OclFile["System.out"].println(i + 1) ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation f( i : int) : boolean
  pre: true
  post: true
  activity: (     if (memo[i - 1+1] /= null) then (     return memo[i - 1+1] ) else skip ; 
     var b : boolean ; b := a[i - 1+1] ;
    var j : int ; j := 2 ;
    while (i * j <= n) do (     if (f(i * j)) then (     b := not(b) ) else skip ; 
     j := j + 1 ) ; 
    if (b) then (     count := count + 1 ) else skip ; 
    return memo[i - 1+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int ii=1 ; ii<=t ; ii++){
      int a=in.nextInt(),b=in.nextInt();
      if(a % b==0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
  static boolean isPrime(long num){
    if(num<=2){
      return false ;
    }
    if(num % 2==0){
      return false ;
    }
    for(int i=3 ; i*i<=num ; i++){
      if(num % i==0){
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var ii : int ; ii := 1 ; while ii <= t do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
     if (a mod b = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) )  ;     ii := ii + 1 ) );
  static   operation isPrime( num : long) : boolean
  pre: true
  post: true
  activity: (     if (num <= 2) then (     return false ) else skip ; 
     if (num mod 2 = 0) then (     return false ) else skip ; 
         var i : int ; i := 3 ; while i * i <= num do ( (     if (num mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    Solver solver=new Solver();
    solver.init();
    solver.readHead(in.readLine());
    solver.readA(in.readLine());
  }
}
class Solver {
  int N ;
  int cnt ;
  public void init(){
    N=0 ;
    cnt=0 ;
  }
  public void readHead(String str){
    String[] strArr=str.split("\\s+");
    N=Integer.parseInt(strArr[0]);
  }
  public void readA(String str){
    String[] strArr=str.split("\\s+");
    int[] A=new int[N+1];
    for(int i=1 ; i<=N ; i++)A[i]=Integer.parseInt(strArr[i-1]);
    HashSet<Integer>B=new HashSet<Integer>();
    for(int i=N ; i>=1 ; i--){
      int b=A[i];
      for(int j=i*2 ; j<=N ; j=j+i){
        if(B.contains(j)){
          if(b==0)b=1 ;
          else b=0 ;
        }
      }
      if(b==1)B.add(i);
    }
    System.out.println(B.size());
    String sep="" ;
    for(int n : B){
      System.out.print(sep);
      if("".equals(sep))sep=" " ;
      System.out.print(n);
    }
    System.out.println();
  }
  public boolean hasNext(){
    return cnt<N ;
  }
  public void readBody(String str){
    cnt++;
  }
  public void solve(){
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var solver : Solver ; solver := Solver.newSolver() ;
    solver.init() ; 
    solver.readHead(in.readLine()) ; 
    solver.readA(in.readLine()) ; 
 );
}
class Solver {
   attribute N : int;
   attribute cnt : int;
   operation init() : void
  pre: true
  post: true
  activity: (     N := 0 ; 
     cnt := 0 );
   operation readHead( str : String) : void
  pre: true
  post: true
  activity: (     var strArr : Sequence(String) ; strArr := str->split("\\s+") ;
     N := (strArr[0+1])->toInteger() );
   operation readA( str : String) : void
  pre: true
  post: true
  activity: (     var strArr : Sequence(String) ; strArr := str->split("\\s+") ;
     var A : Sequence(int) ; A := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do (     A[i+1] := (strArr[i - 1+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var B : Set(int) ; B := Set{} ;
        var i : int ; i := N ; while i >= 1 do ( (     var b : int ; b := A[i+1] ;
         var j : int ; j := i * 2 ; while j <= N do ( (     if (B->includes(j)) then (     if (b = 0) then     b := 1 ; else     b := 0 ; ) else skip )  ;     j := j + i ) ; 
     if (b = 1) then     B := B->including(i) ; else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(B->size()) ; 
    var sep : String ; sep := "" ;
    for (n : B) do ( (     OclFile["System.out"].print(sep) ; 
     if ("" = sep) then     sep := " " ; else skip ; 
     OclFile["System.out"].print(n) )  ) ; 
    OclFile["System.out"].println() ; 
 );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return cnt < N );
   operation readBody( str : String) : void
  pre: true
  post: true
  activity: (     cnt := cnt + 1 );
   operation solve() : void
  pre: true
  post: true
  activity: skip;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int l=sc.nextInt();
    List<Boolean>a=new ArrayList<>();
    List<Boolean>result=new ArrayList<>();
    for(int i=0 ; i<l ; i++){
      a.add(sc.nextInt()==1 ? true : false);
      result.add(false);
    }
    for(int i=l ; i>0 ; i--){
      int loopNum=l/i ;
      boolean isEven=false ;
      for(int j=loopNum*i ; j>i ; j-=i){
        if(result.get(j-1)){
          isEven=isEven ? false : true ;
        }
      }
      result.set(i-1,isEven ^ a.get(i-1));
    }
    int count=0 ;
    StringBuffer sb=new StringBuffer();
    for(int i=0 ; i<l ; i++){
      if(result.get(i)){
        count++;
        sb.append((i+1)+" ");
      }
    }
    if(sb.length()>0){
      sb.setLength(sb.length()-1);
      System.out.println(count);
      System.out.println(sb.toString());
    }
    else {
      System.out.println("0");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var a : Sequence(Boolean) ; a := Sequence{} ;
    var result : Sequence(Boolean) ; result := Sequence{} ;
        var i : int ; i := 0 ; while i < l do ( (     a := a->including(if sc.getCurrent()->toInteger() = 1 then true else false endif) ; 
     result := result->including(false) )  ;     i := i + 1 ) ; 
        var i : int ; i := l ; while i > 0 do ( (     var loopNum : int ; loopNum := l / i ;
     var isEven : boolean ; isEven := false ;
         var j : int ; j := loopNum * i ; while j > i do ( (     if (result->at(j - 1+1)) then (     isEven := if isEven then false else true endif ) else skip )  ;     j := j-(i) ) ; 
     result := result.setAt(i - 1+1,MathLib.bitwiseXor(isEven,a->at(i - 1+1))) )  ;     i := i - 1 ) ; 
    var count : int ; count := 0 ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < l do ( (     if (result->at(i+1)) then (     count := count + 1 ; 
     sb := sb + StringLib.newString((i + 1) + " ") ) else skip )  ;     i := i + 1 ) ; 
    if (sb->size() > 0) then (     sb := sb.subrange(1,sb->size() - 1) ; 
     OclFile["System.out"].println(count) ; 
     OclFile["System.out"].println(sb+"") ) else (     OclFile["System.out"].println("0") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Map.Entry ;
class Main {
  static int mod=(int)(Math.pow(10,9)+7);
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] a=new int[N];
    int[] b=new int[N];
    int M=0 ;
    int k=0 ;
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextInt();
    }
    for(int i=N ; i>0 ; i--){
      int sum=0 ;
      for(int j=i ; j<N+1 ; j=j+i){
        if(b[j-1]==1){
          sum++;
        }
      }
      if(sum % 2!=a[i-1]){
        b[i-1]=1 ;
        M++;
      }
    }
    System.out.println(M);
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<N ; i++){
      if(b[i]==1){
        if(i==N-1){
          sb.append(i+1);
        }
        else {
          sb.append(i+1);
          sb.append(" ");
        }
      }
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := (10->pow(9) + 7)->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,N)->collect(0) ;
    var M : int ; M := 0 ;
    var k : int ; k := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := N ; while i > 0 do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := i ; while j < N + 1 do ( (     if (b[j - 1+1] = 1) then (     sum := sum + 1 ) else skip )  ;     j := j + i ) ; 
     if (sum mod 2 /= a[i - 1+1]) then (     b[i - 1+1] := 1 ; 
     M := M + 1 ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(M) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < N do ( (     if (b[i+1] = 1) then (     if (i = N - 1) then (     sb := sb + StringLib.newString(i + 1) ) else (     sb := sb + StringLib.newString(i + 1) ; 
     sb := sb + StringLib.newString(" ") ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isDivisible(int arr[],int n){
    int lastDigit=arr[n-1] % 10 ;
    if(lastDigit==0)return true ;
    return false ;
  }
  static public void main(String[] arg){
    int arr[]={
      12,65,46,37,99 };
      int n=arr.length ;
      if(isDivisible(arr,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isDivisible( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var lastDigit : int ; lastDigit := arr[n - 1+1] mod 10 ;
     if (lastDigit = 0) then     return true else skip ; 
     return false );
  static    operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,65,46,37,99} ;
     var n : int ; n := arr->size() ;
     if (isDivisible(arr, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.nextLine());
    String s=sc.nextLine();
    char before=s.charAt(0);
    int ans=1 ;
    for(int i=1 ; i<n ; i++){
      if(s.charAt(i)!=before){
        before=s.charAt(i);
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.nextLine())->toInteger() ;
    var s : String ; s := sc.nextLine() ;
    var before : String ; before := s->at(0+1) ;
    var ans : int ; ans := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     if (s->at(i+1) /= before) then (     before := s->at(i+1) ; 
     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    String S=sc.next();
    sc.close();
    StringBuilder sb=new StringBuilder();
    String S1=S.substring(0,1);
    sb.append(S1);
    for(int i=1 ; i<N ; i++){
      if(! S1.equals(S.substring(i,i+1))){
        S1=S.substring(i,i+1);
        sb.append(S1);
      }
    }
    PrintWriter out=new PrintWriter(System.out);
    out.println(sb.length());
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var S : String ; S := sc.getCurrent() ;
    skip ; 
    var sb : String ; sb := StringLib.newString() ;
    var S1 : String ; S1 := S.subrange(0+1,1) ;
    sb := sb + StringLib.newString(S1) ; 
        var i : int ; i := 1 ; while i < N do ( (     if (not(S1 = S.subrange(i+1,i + 1))) then (     S1 := S.subrange(i+1,i + 1) ; 
     sb := sb + StringLib.newString(S1) ) else skip )  ;     i := i + 1 ) ; 
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=sc.nextInt();
    String s=sc.next();
    Stack<Character>stack=new Stack<>();
    for(int i=0 ; i<n ; i++){
      if(stack.isEmpty())stack.add(s.charAt(i));
      else {
        char c=stack.peek();
        if(c!=s.charAt(i))stack.add(s.charAt(i));
      }
    }
    System.out.println(stack.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var stack : Sequence(String) ; stack := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (stack->isEmpty()) then     stack := stack->including(s->at(i+1)) ; else (     var c : String ; c := stack->min() ;
     if (c /= s->at(i+1)) then     stack := stack->including(s->at(i+1)) ; else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(stack->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countUnsetBits(int n){
    int cnt=0 ;
    for(int i=1 ; i<=n ; i++){
      int temp=i ;
      while(temp>0){
        if(temp % 2==0){
          cnt=cnt+1 ;
        }
        temp=temp/2 ;
      }
    }
    return cnt ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(countUnsetBits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countUnsetBits( n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     var temp : int ; temp := i ;
     while (temp > 0) do (     if (temp mod 2 = 0) then (     cnt := cnt + 1 ) else skip ; 
     temp := temp / 2 ) )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(countUnsetBits(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int count=0 ;
    boolean sw=false ;
    int max=Integer.MIN_VALUE ;
    int min=Integer.MAX_VALUE ;
    double dMax=Double.MIN_VALUE ;
    double dMin=Double.MAX_VALUE ;
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    String ss[]=new String[n];
    for(int i=0 ; i<n ; ++i)ss[i]=s.substring(i,i+1);
    String ans="" ;
    for(int i=0 ; i<n-1 ; ++i){
      if(! ss[i] .equals(ss[i+1])){
        ans+=ss[i];
      }
    }
    System.out.println(ans.length()+1);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var sw : boolean ; sw := false ;
    var max : int ; max := -2147483648 ;
    var min : int ; min := 2147483647 ;
    var dMax : double ; dMax := 2->pow(-1074) ;
    var dMin : double ; dMin := (2 - 2->pow(-52))*(2->pow(1023)) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var ss : Sequence(String) ; ss := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     ss[i+1] := s.subrange(i+1,i + 1) ;  ;     i := i + 1 ) ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (not(ss[i+1] = ss[i + 1+1])) then (     ans := ans+(ss[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans->size() + 1) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileNotFoundException ;
import java.math.BigInteger ;
import java.util.Arrays ;
import java.util.Random ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    long startTime=System.currentTimeMillis();
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int ans=0 ;
    String S=sc.next();
    for(int i=0 ; i<N ; ++i){
      int j=i ;
      while(j+1<N && S.charAt(i)==S.charAt(j+1)){
++j ;
      }
      i=j ;
++ans ;
    }
    System.out.println(ans);
  }
  static void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var startTime : long ; startTime := OclDate.getSystemTime() ;
     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    var S : String ; S := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < N do ( (     var j : int ; j := i ;
     while (j + 1 < N & S->at(i+1) = S->at(j + 1+1)) do (     j := j + 1 ) ; 
     i := j ; 
     ans := ans + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class RegularPolygon {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int tc=scanner.nextInt();
    while(tc-->0){
      int n=scanner.nextInt();
      int m=scanner.nextInt();
      if(n % m==0){
        System.out.println("YES");
      }
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class RegularPolygon {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := scanner.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
     if (n mod m = 0) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printPattern(int n,int m,boolean flag){
    System.out.print(m+" ");
    if(flag==false && n==m)return ;
    if(flag){
      if(m-5>0)printPattern(n,m-5,true);
      else printPattern(n,m-5,false);
    }
    else printPattern(n,m+5,false);
  }
  public static void main(String[] args){
    int n=16 ;
    printPattern(n,n,true);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printPattern( n : int, m : int, flag : boolean) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(m + " ") ; 
     if (flag = false & n = m) then     return else skip ; 
     if (flag) then (     if (m - 5 > 0) then     execute printPattern(n, m - 5, true) ; else     execute printPattern(n, m - 5, false) ; ) else     execute printPattern(n, m + 5, false) ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 16 ;
     execute printPattern(n, n, true) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),m=in.nextInt(),q=in.nextInt();
    int[][] state=new int[n][m];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++)state[i][j]=in.nextInt();
    }
    int[] ans=new int[n];
    for(int i=0 ; i<n ; i++){
      ans[i]=getConseSum(state,i,m);
    }
    for(int k=0 ; k<q ; k++){
      int i=in.nextInt()-1,j=in.nextInt()-1 ;
      if(state[i][j]==0){
        state[i][j]=1 ;
        ans[i]+=1 ;
      }
      else {
        state[i][j]=0 ;
        ans[i]-=1 ;
      }
      ans[i]=getConseSum(state,i,m);
      int max=0 ;
      for(int ii=0 ; ii<n ; ii++)max=Math.max(max,ans[ii]);
      pw.println(max);
    }
    pw.close();
  }
  static int getConseSum(int[][] state,int r,int m){
    int Max=0 ;
    int cnt=0 ;
    for(int i=0 ; i<m ; i++){
      if(state[r][i]==1)cnt++;
      if(state[r][i]==0){
        Max=Math.max(Max,cnt);
        cnt=0 ;
      }
    }
    Max=Math.max(cnt,Max);
    return Max ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var q : int ; q := in.getCurrent()->toInteger() ;
    var state : Sequence(Sequence(int)) ; state := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do (     state[i+1][j+1] := in.getCurrent()->toInteger() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ans[i+1] := getConseSum(state, i, m) )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < q do ( (     var i : int ; i := in.getCurrent()->toInteger() - 1 ;
    var j : int ; j := in.getCurrent()->toInteger() - 1 ;
     if (state[i+1][j+1] = 0) then (     state[i+1][j+1] := 1 ; 
     ans[i+1] := ans[i+1]+(1) ) else (     state[i+1][j+1] := 0 ; 
     ans[i+1] := ans[i+1]-(1) ) ;  
    ans[i+1] := getConseSum(state, i, m) ; 
    var max : int ; max := 0 ;
        var ii : int ; ii := 0 ; while ii < n do (     max := Set{max, ans[ii+1]}->max() ;  ;     ii := ii + 1 ) ; 
    skip ; 
 )  ;     k := k + 1 ) ; 
    skip ; 
 );
  static   operation getConseSum( state : Sequence(Sequence(int)), r : int, m : int) : int
  pre: true
  post: true
  activity: (     var Max : int ; Max := 0 ;
     var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     if (state[r+1][i+1] = 1) then     cnt := cnt + 1 ; else skip ; 
     if (state[r+1][i+1] = 0) then (     Max := Set{Max, cnt}->max() ; 
     cnt := 0 ) else skip )  ;     i := i + 1 ) ; 
    Max := Set{cnt, Max}->max() ; 
    return Max 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B548 {
  static Scanner sc=null ;
  public static void main(String[] args){
    sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int q=sc.nextInt();
    int mat[][]=new int[n+1][m+1];
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=m ; j++){
        mat[i][j]=sc.nextInt();
      }
    }
    int count[]=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      int ans=0 ;
      int coun=0 ;
      for(int j=1 ; j<=m ; j++){
        if(mat[i][j]==1){
          coun+=1 ;
        }
        else {
          coun=0 ;
        }
        ans=Math.max(ans,coun);
      }
      count[i]=ans ;
    }
    while(q-->0){
      int r=sc.nextInt();
      int c=sc.nextInt();
      if(mat[r][c]==1)mat[r][c]=0 ;
      else mat[r][c]=1 ;
      int coun=0 ;
      int ans=0 ;
      int ncount[]=new int[n+1];
      for(int i=1 ; i<=m ; i++){
        if(mat[r][i]==1){
          coun+=1 ;
        }
        else {
          coun=0 ;
        }
        ans=Math.max(coun,ans);
      }
      count[r]=ans ;
      for(int i=0 ; i<=n ; i++){
        ncount[i]=count[i];
      }
      Arrays.sort(ncount);
      System.out.println(ncount[n]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B548 {
  static   attribute sc : OclFile := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var mat : Sequence(Sequence(int)) ; mat := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= m do ( (     mat[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : Sequence(int) ; count := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     var ans : int ; ans := 0 ;
     var coun : int ; coun := 0 ;
         var j : int ; j := 1 ; while j <= m do ( (     if (mat[i+1][j+1] = 1) then (     coun := coun+(1) ) else (     coun := 0 ) ;  
     ans := Set{ans, coun}->max() )  ;     j := j + 1 ) ; 
     count[i+1] := ans )  ;     i := i + 1 ) ; 
        while (q > 0) do (        q := q - 1 ;     skip ; (     var r : int ; r := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
    if (mat[r+1][c+1] = 1) then     mat[r+1][c+1] := 0 else     mat[r+1][c+1] := 1 ; ;  
    var coun : int ; coun := 0 ;
    var ans : int ; ans := 0 ;
    var ncount : Sequence(int) ; ncount := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= m do ( (     if (mat[r+1][i+1] = 1) then (     coun := coun+(1) ) else (     coun := 0 ) ;  
     ans := Set{coun, ans}->max() )  ;     i := i + 1 ) ; 
    count[r+1] := ans ; 
        var i : int ; i := 0 ; while i <= n do ( (     ncount[i+1] := count[i+1] )  ;     i := i + 1 ) ; 
    ncount := ncount->sort() ; 
    OclFile["System.out"].println(ncount[n+1]) ; 
 ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] c=new int[n];
    int[] s=new int[n];
    int[] f=new int[n];
    for(int i=0 ; i<n-1 ; i++){
      c[i]=sc.nextInt();
      s[i]=sc.nextInt();
      f[i]=sc.nextInt();
    }
    s[n-1]=Integer.MAX_VALUE ;
    int[] a=new int[n];
    a[n-1]=0 ;
    for(int i=0 ; i<n ; i++){
      int t=0 ;
      for(int j=i ; j<n-1 ; j++){
        if(t<=s[j]){
          t=s[j]+c[j];
        }
        else {
          if(t % f[j]==0)t+=c[j];
          else t+=f[j]-(t % f[j])+c[j];
        }
      }
      a[i]=t ;
    }
    for(int i=0 ; i<n ; i++){
      System.out.println(a[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
    var f : Sequence(int) ; f := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     c[i+1] := sc.getCurrent()->toInteger() ; 
     s[i+1] := sc.getCurrent()->toInteger() ; 
     f[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    s[n - 1+1] := 2147483647 ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    a[n - 1+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     var t : int ; t := 0 ;
         var j : int ; j := i ; while j < n - 1 do ( (     if (t <= s[j+1]) then (     t := s[j+1] + c[j+1] ) else (     if (t mod f[j+1] = 0) then     t := t+(c[j+1]) ; else     t := t+(f[j+1] - (t mod f[j+1]) + c[j+1]) ; ) )  ;     j := j + 1 ) ; 
     a[i+1] := t )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(a[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner stdin=new Scanner(System.in);
    int inN=stdin.nextInt();
    int[] inC=new int[inN-1];
    int[] inS=new int[inN-1];
    int[] inF=new int[inN-1];
    for(int i=0 ; i<(inN-1); i++){
      inC[i]=stdin.nextInt();
      inS[i]=stdin.nextInt();
      inF[i]=stdin.nextInt();
    }
    for(int i=0 ; i<inN ; i++){
      int time=0 ;
      for(int station=i ; station<(inN-1); station++){
        if(time<=inS[station]){
          time=inS[station];
        }
        else if((time % inF[station])>0){
          time+=(inF[station]-(time % inF[station]));
        }
        time+=inC[station];
      }
      System.out.println(time);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inN : int ; inN := stdin.getCurrent()->toInteger() ;
    var inC : Sequence(int) ; inC := Integer.subrange(1,inN - 1)->collect(0) ;
    var inS : Sequence(int) ; inS := Integer.subrange(1,inN - 1)->collect(0) ;
    var inF : Sequence(int) ; inF := Integer.subrange(1,inN - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < (inN - 1) do ( (     inC[i+1] := stdin.getCurrent()->toInteger() ; 
     inS[i+1] := stdin.getCurrent()->toInteger() ; 
     inF[i+1] := stdin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < inN do ( (     var time : int ; time := 0 ;
         var station : int ; station := i ; while station < (inN - 1) do ( (     if (time <= inS[station+1]) then (     time := inS[station+1] ) else     if ((time mod inF[station+1]) > 0) then (     time := time+((inF[station+1] - (time mod inF[station+1]))) ) else skip ; ;  
     time := time+(inC[station+1]) )  ;     station := station + 1 ) ; 
     OclFile["System.out"].println(time) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in),1);
    Integer n=Integer.parseInt(r.readLine());
    int[] c=new int[555];
    int[] s=new int[555];
    int[] f=new int[555];
    int[] a=new int[555];
    int goal=n ;
    for(int i=1 ; i<n ; i++){
      String[] z=r.readLine().split("[\\s]+");
      c[i]=Integer.parseInt(z[0]);
      s[i]=Integer.parseInt(z[1]);
      f[i]=Integer.parseInt(z[2]);
    }
    for(int start=1 ; start<=goal ; start++){
      a[start]=0 ;
      int now=0 ;
      for(int pos=start ; pos<goal ; pos++){
        if(now<s[pos]){
          now=s[pos]+c[pos];
        }
        else if(now % f[pos]==0){
          now+=c[pos];
        }
        else {
          now+=f[pos]-(now % f[pos])+c[pos];
        }
      }
      a[start]=now ;
    }
    for(int start=1 ; start<=goal ; start++){
      System.out.println(a[start]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 1) ;
     var n : int ; n := (r.readLine())->toInteger() ;
    var c : Sequence(int) ; c := Integer.subrange(1,555)->collect(0) ;
    var s : Sequence(int) ; s := Integer.subrange(1,555)->collect(0) ;
    var f : Sequence(int) ; f := Integer.subrange(1,555)->collect(0) ;
    var a : Sequence(int) ; a := Integer.subrange(1,555)->collect(0) ;
    var goal : int ; goal := n ;
        var i : int ; i := 1 ; while i < n do ( (     var z : Sequence(String) ; z := r.readLine()->split("[\\s]+") ;
     c[i+1] := (z[0+1])->toInteger() ; 
     s[i+1] := (z[1+1])->toInteger() ; 
     f[i+1] := (z[2+1])->toInteger() )  ;     i := i + 1 ) ; 
        var start : int ; start := 1 ; while start <= goal do ( (     a[start+1] := 0 ; 
     var now : int ; now := 0 ;
         var pos : int ; pos := start ; while pos < goal do ( (     if (now < s[pos+1]) then (     now := s[pos+1] + c[pos+1] ) else     if (now mod f[pos+1] = 0) then (     now := now+(c[pos+1]) ) else (     now := now+(f[pos+1] - (now mod f[pos+1]) + c[pos+1]) ) ;  )  ;     pos := pos + 1 ) ; 
     a[start+1] := now )  ;     start := start + 1 ) ; 
        var start : int ; start := 1 ; while start <= goal do ( (     OclFile["System.out"].println(a[start+1]) )  ;     start := start + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[][] dig=new long[N-1][3];
    int C=0 ;
    int S=0 ;
    int F=0 ;
    long unko=0 ;
    for(int i=0 ; i<N-1 ; i++){
      for(int j=0 ; j<3 ; j++){
        dig[i][j]=sc.nextLong();
      }
    }
    for(int i=0 ; i<N-1 ; i++){
      unko=0 ;
      for(int j=i ; j<N-1 ; j++){
        if(j==i){
          unko+=dig[j][1];
        }
        if(unko<dig[j][1]){
          unko=dig[j][1];
        }
        unko=(unko+dig[j][2]-1)/dig[j][2]*dig[j][2];
        unko+=dig[j][0];
      }
      System.out.println(unko);
    }
    System.out.println("0");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var dig : Sequence(Sequence(long)) ; dig := Integer.subrange(1,N - 1)->collect(Integer.subrange(1,3)->collect(0)) ;
    var C : int ; C := 0 ;
    var S : int ; S := 0 ;
    var F : int ; F := 0 ;
    var unko : long ; unko := 0 ;
        var i : int ; i := 0 ; while i < N - 1 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     dig[i+1][j+1] := sc.getCurrent()->toLong() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     unko := 0 ; 
         var j : int ; j := i ; while j < N - 1 do ( (     if (j = i) then (     unko := unko+(dig[j+1][1+1]) ) else skip ; 
     if (unko < dig[j+1][1+1]) then (     unko := dig[j+1][1+1] ) else skip ; 
     unko := (unko + dig[j+1][2+1] - 1) / dig[j+1][2+1] * dig[j+1][2+1] ; 
     unko := unko+(dig[j+1][0+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(unko) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("0") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in);
){
      solve(sc);
    }
  }
  public static void solve(Scanner sc){
    int n=sc.nextInt();
    int[] arrivalTime=new int[n];
    for(int i=0 ; i<n-1 ; i++){
      int spentTime=sc.nextInt();
      int startTime=sc.nextInt();
      int frequentTime=sc.nextInt();
      for(int j=0 ; j<=i ; j++){
        if(arrivalTime[j]<startTime){
          arrivalTime[j]=startTime ;
        }
        if(arrivalTime[j] % frequentTime!=0){
          arrivalTime[j]+=frequentTime-(arrivalTime[j] % frequentTime);
        }
        arrivalTime[j]+=spentTime ;
      }
    }
    for(int i=0 ; i<n ; i++){
      System.out.println(arrivalTime[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     execute solve(sc) ))  );
  static   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arrivalTime : Sequence(int) ; arrivalTime := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     var spentTime : int ; spentTime := sc.getCurrent()->toInteger() ;
     var startTime : int ; startTime := sc.getCurrent()->toInteger() ;
     var frequentTime : int ; frequentTime := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j <= i do ( (     if (arrivalTime[j+1] < startTime) then (     arrivalTime[j+1] := startTime ) else skip ; 
     if (arrivalTime[j+1] mod frequentTime /= 0) then (     arrivalTime[j+1] := arrivalTime[j+1]+(frequentTime - (arrivalTime[j+1] mod frequentTime)) ) else skip ; 
     arrivalTime[j+1] := arrivalTime[j+1]+(spentTime) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(arrivalTime[i+1]) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Arrays ;
public final class p104 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p104().run());
  }
  public String run(){
    int i=0 ;
    int a=0 ;
    int b=1 ;
    while(! isFound(i,a)){
      int c=(a+b)% 1000000000 ;
      a=b ;
      b=c ;
      i++;
    }
    return Integer.toString(i);
  }
  private static boolean isFound(int n,int fibMod){
    if(! isPandigital(Integer.toString(fibMod)))return false ;
    BigInteger fib=fibonacci(n)[0];
    if(fib.mod(BigInteger.valueOf(1000000000)).intValue()!=fibMod)throw new AssertionError();
    return isPandigital(leading9Digits(fib));
  }
  private static String leading9Digits(BigInteger x){
    int log10=(x.bitLength()-1)*3/10 ;
    x=x.divide(BigInteger.TEN.pow(Math.max(log10+1-9,0)));
    return x.toString().substring(0,9);
  }
  private static boolean isPandigital(String s){
    if(s.length()!=9)return false ;
    char[] temp=s.toCharArray();
    Arrays.sort(temp);
    return new String(temp).equals("123456789");
  }
  private static BigInteger[] fibonacci(int n){
    if(n<0)throw new IllegalArgumentException();
    else if(n==0)return new BigInteger[] {
      BigInteger.ZERO,BigInteger.ONE };
      else {
        BigInteger[] ab=fibonacci(n/2);
        BigInteger a=ab[0];
        BigInteger b=ab[1];
        BigInteger c=a.multiply(b.shiftLeft(1).subtract(a));
        BigInteger d=a.multiply(a).add(b.multiply(b));
        if(n % 2==0)return new BigInteger[] {
          c,d };
          else return new BigInteger[] {
            d,c.add(d)};
          }
        }
      }

------------------------------------------------------------
OCL File:
---------
 class p104 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p104.newp104().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var a : int ; a := 0 ;
    var b : int ; b := 1 ;
    while (not(isFound(i, a))) do (     var c : int ; c := (a + b) mod 1000000000 ;
     a := b ; 
     b := c ; 
     i := i + 1 ) ; 
    return ((i) + "") 
 );
  static   operation isFound( n : int, fibMod : int) : boolean
  pre: true
  post: true
  activity: (     if (not(isPandigital(((fibMod) + "")))) then     return false else skip ; 
     var fib : long ; fib := fibonacci(n)[0+1] ;
     if (fib.mod((1000000000 + "")->toLong())->oclAsType(int) /= fibMod) then     error AssertionException() ; else skip ; 
     return isPandigital(leading9Digits(fib)) );
  static   operation leading9Digits( x : long) : String
  pre: true
  post: true
  activity: (     var log10 : int ; log10 := (x.bitLength() - 1) * 3 / 10 ;
     x := x.divide(10.pow(Set{log10 + 1 - 9, 0}->max())) ; 
     return x+"".subrange(0+1,9) );
  static   operation isPandigital( s : String) : boolean
  pre: true
  post: true
  activity: (     if (s->size() /= 9) then     return false else skip ; 
     var temp : Sequence(String) ; temp := s->characters() ;
     temp := temp->sort() ; 
     return StringLib.newString(temp) = "123456789" );
  static   operation fibonacci( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     if (n < 0) then     error IllegalArgumentException.newIllegalArgumentException() ; else     if (n = 0) then     return Sequence{0,1} else (     var ab : Sequence(long) ; ab := fibonacci(n / 2) ;
     var a : long ; a := ab[0+1] ;
    var b : long ; b := ab[1+1] ;
    var c : long ; c := a.multiply(b.shiftLeft(1).subtract(a)) ;
    var d : long ; d := a.multiply(a)->excludes(b.multiply(b)) ;
    if (n mod 2 = 0) then     return Sequence{c,d} else     return Sequence{d,c->excludes(d)} ;  
 ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int count_setbits(int N){
    int cnt=0 ;
    while(N>0){
      cnt+=(N & 1);
      N=N>>1 ;
    }
    return cnt ;
  }
  static int countMultiples(int n){
    int multiple[]={
      2,3,5 };
      int count=0,mask=(int)Math.pow(2,3);
      for(int i=1 ; i<mask ; i++){
        int prod=1 ;
        for(int j=0 ; j<3 ; j++){
          if((i & 1<<j)>0)prod=prod*multiple[j];
        }
        if(count_setbits(i)% 2==1)count=count+n/prod ;
        else count=count-n/prod ;
      }
      return count ;
    }
    public static void main(String[] args){
      int n=10 ;
      System.out.println(countMultiples(n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation count_setbits( N : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     while (N > 0) do (     cnt := cnt+((N & 1)) ; 
     N := (N/(2->pow(1)))->oclAsType(long) ) ; 
     return cnt );
  static   operation countMultiples( n : int) : int
  pre: true
  post: true
  activity: (     var multiple : Sequence(int) ; multiple := Sequence{2,3,5} ;
     var count : int ; count := 0 ;
    var mask : int ; mask := 2->pow(3)->oclAsType(int) ;
         var i : int ; i := 1 ; while i < mask do ( (     var prod : int ; prod := 1 ;
         var j : int ; j := 0 ; while j < 3 do ( (     if ((MathLib.bitwiseAnd(i,(1*(2->pow(j)))->oclAsType(long))) > 0) then     prod := prod * multiple[j+1] ; else skip )  ;     j := j + 1 ) ; 
     if (count_setbits(i) mod 2 = 1) then     count := count + n / prod ; else     count := count - n / prod ; )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(countMultiples(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int AG ;
    AG=sc.nextInt();
    for(int i=0 ; i<AG ; i++){
      int K ;
      K=sc.nextInt();
      int L ;
      L=sc.nextInt();
      if(K % L==0){
        System.out.println("YES");
      }
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var AG : int ;
     AG := sc.getCurrent()->toInteger() ; 
         var i : int ; i := 0 ; while i < AG do ( (     var K : int ;
     K := sc.getCurrent()->toInteger() ; 
    var L : int ;
    L := sc.getCurrent()->toInteger() ; 
    if (K mod L = 0) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double areaCuboid(double l,double h,double w){
    return(l*h*w);
  }
  static double surfaceAreaCuboid(double l,double h,double w){
    return(2*l*w+2*w*h+2*l*h);
  }
  public static void main(String[] args){
    double l=1 ;
    double h=5 ;
    double w=7 ;
    System.out.println("Area="+areaCuboid(l,h,w));
    System.out.println("Total Surface Area="+surfaceAreaCuboid(l,h,w));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation areaCuboid( l : double, h : double, w : double) : double
  pre: true
  post: true
  activity: (     return (l * h * w) );
  static   operation surfaceAreaCuboid( l : double, h : double, w : double) : double
  pre: true
  post: true
  activity: (     return (2 * l * w + 2 * w * h + 2 * l * h) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : double ; l := 1 ;
     var h : double ; h := 5 ;
    var w : double ; w := 7 ;
    OclFile["System.out"].println("Area=" + areaCuboid(l, h, w)) ; 
    OclFile["System.out"].println("Total Surface Area=" + surfaceAreaCuboid(l, h, w)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isEqualBlock(int n){
    int first_bit=n % 2 ;
    int first_count=1 ;
    n=n/2 ;
    while(n % 2==first_bit && n>0){
      n=n/2 ;
      first_count++;
    }
    if(n==0)return false ;
    while(n>0){
      first_bit=n % 2 ;
      int curr_count=1 ;
      n=n/2 ;
      while(n % 2==first_bit){
        n=n/2 ;
        curr_count++;
      }
      if(curr_count!=first_count)return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    int n=51 ;
    if(isEqualBlock(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isEqualBlock( n : int) : boolean
  pre: true
  post: true
  activity: (     var first_bit : int ; first_bit := n mod 2 ;
     var first_count : int ; first_count := 1 ;
    n := n / 2 ; 
    while (n mod 2 = first_bit & n > 0) do (     n := n / 2 ; 
     first_count := first_count + 1 ) ; 
    if (n = 0) then     return false else skip ; 
    while (n > 0) do (     first_bit := n mod 2 ; 
     var curr_count : int ; curr_count := 1 ;
    n := n / 2 ; 
    while (n mod 2 = first_bit) do (     n := n / 2 ; 
     curr_count := curr_count + 1 ) ; 
    if (curr_count /= first_count) then     return false else skip ; 
 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 51 ;
     if (isEqualBlock(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
class GFG {
  static double countNumbers(int N){
    return(Math.pow(10,N)-1)-(Math.pow(10,N)-Math.pow(8,N))/2 ;
  }
  static public void main(String args[]){
    int n=2 ;
    System.out.println(countNumbers(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countNumbers( N : int) : double
  pre: true
  post: true
  activity: (     return (10->pow(N) - 1) - (10->pow(N) - 8->pow(N)) / 2 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(countNumbers(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countNumbers(int N){
    return(int)(Math.pow(10,N)-Math.pow(8,N))/2 ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(countNumbers(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countNumbers( N : int) : int
  pre: true
  post: true
  activity: (     return (10->pow(N) - 8->pow(N))->oclAsType(int) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(countNumbers(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPalindrome(String str,int low,int high){
    while(low<high){
      if(str.charAt(low)!=str.charAt(high))return false ;
      low++;
      high--;
    }
    return true ;
  }
  static int possiblePalinByRemovingOneChar(String str){
    int low=0,high=str.length()-1 ;
    while(low<high){
      if(str.charAt(low)==str.charAt(high)){
        low++;
        high--;
      }
      else {
        if(isPalindrome(str,low+1,high))return low ;
        if(isPalindrome(str,low,high-1))return high ;
        return-1 ;
      }
    }
    return-2 ;
  }
  public static void main(String[] args){
    String str="abecbea" ;
    int idx=possiblePalinByRemovingOneChar(str);
    if(idx==-1)System.out.println("Not Possible");
    else if(idx==-2)System.out.println("Possible without "+"removing any character");
    else System.out.println("Possible by removing"+" character at index "+idx);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPalindrome( str : String, low : int, high : int) : boolean
  pre: true
  post: true
  activity: (     while (low < high) do (     if (str->at(low+1) /= str->at(high+1)) then     return false else skip ; 
     low := low + 1 ; 
     high := high - 1 ) ; 
     return true );
  static   operation possiblePalinByRemovingOneChar( str : String) : int
  pre: true
  post: true
  activity: (     var low : int ; low := 0 ;
    var high : int ; high := str->size() - 1 ;
     while (low < high) do (     if (str->at(low+1) = str->at(high+1)) then (     low := low + 1 ; 
     high := high - 1 ) else (     if (isPalindrome(str, low + 1, high)) then     return low else skip ; 
     if (isPalindrome(str, low, high - 1)) then     return high else skip ; 
     return -1 ) ) ; 
     return -2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abecbea" ;
     var idx : int ; idx := possiblePalinByRemovingOneChar(str) ;
     if (idx = -1) then     OclFile["System.out"].println("Not Possible") ; else     if (idx = -2) then     OclFile["System.out"].println("Possible without " + "removing any character") else     OclFile["System.out"].println("Possible by removing" + " character at index " + idx) ; ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countPairsWithDiffK(int arr[],int n,int k){
    int count=0 ;
    Arrays.sort(arr);
    int l=0 ;
    int r=0 ;
    while(r<n){
      if(arr[r]-arr[l]==k){
        count++;
        l++;
        r++;
      }
      else if(arr[r]-arr[l]>k)l++;
      else r++;
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      1,5,3,4,2 };
      int n=arr.length ;
      int k=3 ;
      System.out.println("Count of pairs with given diff is "+countPairsWithDiffK(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPairsWithDiffK( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     arr := arr->sort() ; 
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    while (r < n) do (     if (arr[r+1] - arr[l+1] = k) then (     count := count + 1 ; 
     l := l + 1 ; 
     r := r + 1 ) else     if (arr[r+1] - arr[l+1] > k) then     l := l + 1 else     r := r + 1 ; ;  ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,3,4,2} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println("Count of pairs with given diff is " + countPairsWithDiffK(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class AAA {
  boolean getsum1(int n,int k){
    TreeSet<Integer>y=new TreeSet<Integer>();
    while(true){
      if(y.contains(n))return false ;
      y.add(n);
      int res=0 ;
      while(n!=0){
        res+=(n % k)*(n % k);
        n/=k ;
      }
      n=res ;
      if(n==1)return true ;
    }
  }
  TreeMap<Integer,Integer>result=new TreeMap<Integer,Integer>();
  void solve()throws IOException {
    Scanner in=new Scanner(new FileInputStream("input.txt"));
    PrintWriter out=new PrintWriter(new FileOutputStream("output.txt"));
    String s ;
    int n=in.nextInt();
    in.nextLine();
    for(int t=1 ; t<=n ; ++t){
      s=in.nextLine();
      if(s==null)break ;
      ArrayList<Integer>a=new ArrayList<Integer>();
      Scanner in2=new Scanner(s);
      while(in2.hasNextInt())a.add(in2.nextInt());
      int mask=0 ;
      for(int i=0 ; i<a.size(); ++i)mask+=1<<a.get(i);
      if(a.size()==9)result.put(mask,11814485);
      int tr=2 ;
      if(result.containsKey(mask)){
        tr=result.get(mask);
      }
      else {
        while(true){
          boolean good=true ;
          for(int i=a.size()-1 ; i>=0 ; --i)if(! getsum1(tr,a.get(i))){
            good=false ;
            break ;
          }
          if(good)break ;
          tr++;
        }
        result.put(mask,tr);
      }
      out.println("Case #"+t+": "+tr);
      out.flush();
    }
    out.close();
  }
  public static void main(String[] args)throws IOException {
    AAA a=new AAA();
    a.solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class AAA {
   operation getsum1( n : int, k : int) : boolean
  pre: true
  post: true
  activity: (     var y : Set(int) ; y := Set{} ;
     while (true) do (     if (y->includes(n)) then     return false else skip ; 
     y := y->including(n) ; 
    var res : int ; res := 0 ;
    while (n /= 0) do (     res := res+((n mod k) * (n mod k)) ; 
     n := n/(k) ) ; 
    n := res ; 
    if (n = 1) then     return true else skip ; 
 ) );
   attribute result : Map(int,int) := Map{};
   operation solve() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt"))) ;
    var s : String ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    skip ; 
        var t : int ; t := 1 ; while t <= n do ( (     s := in.nextLine() ; 
     if (s = null) then     break else skip ; 
    var a : Sequence(int) ; a := Sequence{} ;
    var in2 : OclFile ; in2 := OclFile.newOclFile_Read(OclFile.newOclFile(s)) ;
    while (in2.hasNextInt()) do     a := a->including(in2.getCurrent()->toInteger()) ; ; 
    var mask : int ; mask := 0 ;
        var i : int ; i := 0 ; while i < a->size() do (     mask := mask+((1*(2->pow(a->at(i+1))))->oclAsType(long)) ;  ;     i := i + 1 ) ; 
    if (a->size() = 9) then     result := result->union(Map{mask |-> 11814485}) ; else skip ; 
    var tr : int ; tr := 2 ;
    if (result->keys()->includes(mask)) then (     tr := result->at(mask) ) else (     while (true) do (     var good : boolean ; good := true ;
         var i : int ; i := a->size() - 1 ; while i >= 0 do (     if (not(getsum1(tr, a->at(i+1)))) then (     good := false ; 
     break ) else skip ;  ;     i := i - 1 ) ; 
     if (good) then     break else skip ; 
     tr := tr + 1 ) ; 
     result := result->union(Map{mask |-> tr}) ) ;  
    skip ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : AAA ; a := AAA.newAAA() ;
     a.solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  static int N,Q ;
  static Node[] ns ;
  static boolean type[];
  static int no[];
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String input[]=br.readLine().split("+");
      N=new Integer(input[0]);
      Q=new Integer(input[1]);
      if(N==0 & Q==0)break ;
      ns=new Node[N+1];
      type=new boolean[Q];
      no=new int[Q];
      ns[1]=new Node(0);
      ns[1] .marked=true ;
      for(int i=2 ; i<=N ; i++){
        ns[i]=new Node(new Integer(br.readLine()));
      }
      for(int i=0 ; i<Q ; i++){
        input=br.readLine().split("+");
        if(input[0] .equals("Q")){
          type[i]=true ;
        }
        else {
          type[i]=false ;
        }
        no[i]=new Integer(input[1]);
      }
      long sum=0 ;
      for(int i=0 ; i<Q ; i++){
        if(type[i]){
          sum+=findmark(no[i]);
        }
        else {
          ns[no[i] ] .marked=true ;
        }
      }
      System.out.println(sum);
    }
  }
  static int findmark(int no){
    while(true){
      if(ns[no] .marked)return no ;
      else no=ns[no] .par ;
    }
  }
}
class Node {
  int par ;
  boolean marked=false ;
  Node(int par){
    this.par=par ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute ns : Sequence(Node);
  static   attribute type : Sequence(boolean);
  static   attribute no : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var input : Sequence(String) ; input := br.readLine()->split("+") ;
     N := ("" + (input[0+1]))->toInteger() ; 
    Q := ("" + (input[1+1]))->toInteger() ; 
    if (N = 0 & Q = 0) then     break else skip ; 
    ns := Integer.subrange(1,N + 1)->collect(null) ; 
    type := Integer.subrange(1,Q)->collect(false) ; 
    no := Integer.subrange(1,Q)->collect(0) ; 
    ns[1+1] := Node.newNode(0) ; 
    ns[1+1].marked := true ; 
        var i : int ; i := 2 ; while i <= N do ( (     ns[i+1] := Node.newNode(("" + (br.readLine()))->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Q do ( (     input := br.readLine()->split("+") ; 
     if (input[0+1] = "Q") then (     type[i+1] := true ) else (     type[i+1] := false ) ;  
     no[i+1] := ("" + (input[1+1]))->toInteger() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < Q do ( (     if (type[i+1]) then (     sum := sum+(findmark(no[i+1])) ) else (     ns[no[i+1]+1].marked := true ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) );
  static   operation findmark( no : int) : int
  pre: true
  post: true
  activity: (     while (true) do (     if (ns[no+1].marked) then     return no else     no := ns[no+1].par ; ) );
}
class Node {
   attribute par : int;
   attribute marked : boolean := false;
   static operation newNode( par : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(par);
    return self );
  operation initialise( par : int) : void
  pre: true  post: true
  activity: (     self.par := par );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static int find(int cur_v,int cur_t,int[] time,int[] parent){
    if(time[cur_v]<cur_t)return cur_v ;
    if(parent[cur_v]==cur_v)return cur_v ;
    return parent[cur_v]=find(parent[cur_v],cur_t,time,parent);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int q=sc.nextInt();
      if(n==0 && q==0)return ;
      int[] parent=new int[n+1];
      int[] time=new int[n+1];
      Arrays.fill(time,Integer.MAX_VALUE);
      List<Integer>qt=new ArrayList<Integer>();
      List<Integer>vt=new ArrayList<Integer>();
      for(int i=2 ; i<=n ; i++){
        int v=sc.nextInt();
        parent[i]=v ;
      }
      parent[1]=1 ;
      long sum=0 ;
      for(int i=1 ; i<=q ; i++){
        String s=sc.next();
        int v=sc.nextInt();
        if(s.equals("M"))time[v]=Math.min(time[v],i);
        else {
          qt.add(i);
          vt.add(v);
        }
      }
      int q_ct=qt.size();
      for(int i=q_ct-1 ; i>=0 ; i--){
        int cur_v=vt.get(i);
        int cur_t=qt.get(i);
        sum+=find(cur_v,cur_t,time,parent);
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation find( cur_v : int, cur_t : int, time : Sequence(int), parent : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (time[cur_v+1] < cur_t) then     return cur_v else skip ; 
     if (parent[cur_v+1] = cur_v) then     return cur_v else skip ; 
     return parent[cur_v+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
    if (n = 0 & q = 0) then     return else skip ; 
    var parent : Sequence(int) ; parent := Integer.subrange(1,n + 1)->collect(0) ;
    var time : Sequence(int) ; time := Integer.subrange(1,n + 1)->collect(0) ;
    time := time->collect(2147483647) ; 
    var qt : Sequence(int) ; qt := Sequence{} ;
    var vt : Sequence(int) ; vt := Sequence{} ;
        var i : int ; i := 2 ; while i <= n do ( (     var v : int ; v := sc.getCurrent()->toInteger() ;
     parent[i+1] := v )  ;     i := i + 1 ) ; 
    parent[1+1] := 1 ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 1 ; while i <= q do ( (     var s : String ; s := sc.getCurrent() ;
     var v : int ; v := sc.getCurrent()->toInteger() ;
     if (s = "M") then     time[v+1] := Set{time[v+1], i}->min() ; else (     qt := qt->including(i) ; 
     vt := vt->including(v) ) )  ;     i := i + 1 ) ; 
    var q_ct : int ; q_ct := qt->size() ;
        var i : int ; i := q_ct - 1 ; while i >= 0 do ( (     var cur_v : int ; cur_v := vt->at(i+1) ;
     var cur_t : int ; cur_t := qt->at(i+1) ;
     sum := sum+(find(cur_v, cur_t, time, parent)) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Problem1 {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int t=Integer.parseInt(f.readLine());
    while(t-->0){
      StringTokenizer st=new StringTokenizer(f.readLine());
      long a=Long.parseLong(st.nextToken());
      long b=Long.parseLong(st.nextToken());
      long diff=Math.abs(b-a);
      if(Math.min(a,b)<diff){
        out.println("NO");
        continue ;
      }
      if(a>b){
        a-=2*diff ;
        b-=diff ;
      }
      else {
        a-=diff ;
        b-=2*diff ;
      }
      if(a % 3==0 && b % 3==0){
        out.println("YES");
      }
      else {
        out.println("NO");
      }
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var t : int ; t := (f.readLine())->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
     var a : long ; a := (st.next())->toLong() ;
    var b : long ; b := (st.next())->toLong() ;
    var diff : long ; diff := if b - a < 0 then -(b - a) else b - a endif ;
    if (Set{a, b}->min() < diff) then (     skip ; 
     continue ) else skip ; 
    if (a > b) then (     a := a-(2 * diff) ; 
     b := b-(diff) ) else (     a := a-(diff) ; 
     b := b-(2 * diff) ) ;  
    if (a mod 3 = 0 & b mod 3 = 0) then (     skip ) else (     skip ) ;  
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countCubes(int a,int b){
    int cnt=0 ;
    for(int i=a ; i<=b ; i++)for(int j=1 ; j*j*j<=i ; j++)if(j*j*j==i)cnt++;
    return cnt ;
  }
  public static void main(String[] args){
    int a=7,b=30 ;
    System.out.print("Count of Cubes is "+countCubes(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countCubes( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := a ; while i <= b do (         var j : int ; j := 1 ; while j * j * j <= i do (     if (j * j * j = i) then     cnt := cnt + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 7 ;
    var b : int ; b := 30 ;
     OclFile["System.out"].print("Count of Cubes is " + countCubes(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    Main main=new Main();
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int N,Q ;
      N=parseInt(line.substring(0,line.indexOf(' ')));
      Q=parseInt(line.substring(line.indexOf(' ')+1));
      if((N | Q)==0)break ;
      Node[] nodes=new Node[N+1];
      for(int i=0 ; i<nodes.length ; i++){
        nodes[i]=main.new Node(i);
      }
      nodes[1] .p=nodes[0];
      for(int i=2 ; i<=N ; i++){
        int p=parseInt(br.readLine());
        nodes[i] .p=nodes[p];
      }
      nodes[1] .marked=true ;
      long sum=0 ;
      for(int i=0 ; i<Q ; i++){
        line=br.readLine();
        char o=line.charAt(0);
        int v=parseInt(line.substring(line.indexOf(' ')+1));
        if(o=='M'){
          nodes[v] .marked=true ;
        }
        else {
          Node node=nodes[v];
          while(node.id!=0 && ! node.marked){
            node=node.p ;
          }
          sum+=node.id ;
        }
      }
      System.out.println(sum);
    }
  }
  class Node {
    int id ;
    boolean marked=false ;
    Node p ;
    Node(int id){
      this.id=id ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var main : Main ; main := Main.newMain() ;
        line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var N : int ;
    var Q : int ;
     N := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    Q := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    if ((MathLib.bitwiseOr(N,Q)) = 0) then     break else skip ; 
    var nodes : Sequence(Node) ; nodes := Integer.subrange(1,N + 1)->collect(null) ;
        var i : int ; i := 0 ; while i < nodes->size() do ( (     nodes[i+1] := (main).newNode(i) )  ;     i := i + 1 ) ; 
    nodes[1+1].p := nodes[0+1] ; 
        var i : int ; i := 2 ; while i <= N do ( (     var p : int ; p := parseInt(br.readLine()) ;
     nodes[i+1].p := nodes[p+1] )  ;     i := i + 1 ) ; 
    nodes[1+1].marked := true ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < Q do ( (     line := br.readLine() ; 
     var o : String ; o := line->at(0+1) ;
     var v : int ; v := parseInt(line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1)) ;
     if (o = 'M') then (     nodes[v+1].marked := true ) else (     var node : Node ; node := nodes[v+1] ;
     while (node.id /= 0 & not(node.marked)) do (     node := node.p ) ; 
     sum := sum+(node.id) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;     line := br.readLine() ;
 ) ;  
 );
 class Node {
   attribute id : int;
   attribute marked : boolean := false;
   attribute p : Node;
   static operation newNode( id : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(id);
    return self );
  operation initialise( id : int) : void
  pre: true  post: true
  activity: (     self.id := id );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      int q=sc.nextInt();
      if((n | q)==0)break ;
      UnionFind uf=new UnionFind(n);
      if(n!=1){
        for(int i=2 ; i<=n ; i++){
          int p=sc.nextInt();
          uf.par[i]=p ;
        }
      }
      long ans=0 ;
      for(int i=0 ; i<q ; i++){
        String t=sc.next();
        int v=sc.nextInt();
        if(t.equals("M"))uf.mark[v]=true ;
        else ans+=uf.find(v);
      }
      System.out.println(ans);
    }
  }
}
class UnionFind {
  public int par[];
  public boolean mark[];
  UnionFind(int n){
    par=new int[n+1];
    mark=new boolean[n+1];
    mark[0]=true ;
    mark[1]=true ;
    par[1]=1 ;
  }
  public int find(int x){
    while(true){
      if(mark[x]){
        return x ;
      }
      else {
        x=par[x];
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,q)) = 0) then     break else skip ; 
    var uf : UnionFind ; uf := UnionFind.newUnionFind(n) ;
    if (n /= 1) then (         var i : int ; i := 2 ; while i <= n do ( (     var p : int ; p := sc.getCurrent()->toInteger() ;
     uf.par[i+1] := p )  ;     i := i + 1 ) ) else skip ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < q do ( (     var t : String ; t := sc.getCurrent() ;
     var v : int ; v := sc.getCurrent()->toInteger() ;
     if (t = "M") then     uf.mark[v+1] := true ; else     ans := ans+(uf.find(v)) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}
class UnionFind {
   attribute par : Sequence(int);
   attribute mark : Sequence(boolean);
   static operation newUnionFind( n : int) : UnionFind
  pre: true
  post: true
  activity:
  ( var self : UnionFind ;
    self := createUnionFind();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     par := Integer.subrange(1,n + 1)->collect(0) ; 
     mark := Integer.subrange(1,n + 1)->collect(false) ; 
    mark[0+1] := true ; 
    mark[1+1] := true ; 
    par[1+1] := 1 ; 
 );
   operation find( x : int) : int
  pre: true
  post: true
  activity: (     while (true) do (     if (mark[x+1]) then (     return x ) else (     x := par[x+1] ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String input=br.readLine();
      if(input==null){
        break ;
      }
      String[] tmpArray=input.split(" ");
      int n=Integer.parseInt(tmpArray[0]);
      int q=Integer.parseInt(tmpArray[1]);
      if(n==0 && q==0){
        break ;
      }
      Node[] nodes=new Node[n+1];
      nodes[0]=new Node(0,-1);
      nodes[0] .marked=true ;
      nodes[1]=new Node(1,0);
      nodes[1] .marked=true ;
      for(int i=2 ; i<=n ; i++){
        int num=Integer.parseInt(br.readLine());
        nodes[i]=new Node(i,num);
      }
      long sum=0 ;
      for(int i=0 ; i<q ; i++){
        tmpArray=br.readLine().split(" ");
        int tmp=Integer.parseInt(tmpArray[1]);
        if(tmpArray[0] .equals("M")){
          nodes[tmp] .marked=true ;
        }
        else {
          sum+=nearest(nodes,tmp);
        }
      }
      System.out.println(sum);
    }
  }
  static int nearest(Node[] nodes,int id){
    while(true){
      if(nodes[id] .marked){
        return id ;
      }
      id=nodes[id] .parent ;
    }
  }
}
class Node {
  int id ;
  int parent ;
  boolean marked=false ;
  public Node(int id,int parent){
    this.id=id ;
    this.parent=parent ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var input : String ; input := br.readLine() ;
     if (input = null) then (     break ) else skip ; 
    var tmpArray : Sequence(String) ; tmpArray := input->split(" ") ;
    var n : int ; n := (tmpArray[0+1])->toInteger() ;
    var q : int ; q := (tmpArray[1+1])->toInteger() ;
    if (n = 0 & q = 0) then (     break ) else skip ; 
    var nodes : Sequence(Node) ; nodes := Integer.subrange(1,n + 1)->collect(null) ;
    nodes[0+1] := Node.newNode(0, -1) ; 
    nodes[0+1].marked := true ; 
    nodes[1+1] := Node.newNode(1, 0) ; 
    nodes[1+1].marked := true ; 
        var i : int ; i := 2 ; while i <= n do ( (     var num : int ; num := (br.readLine())->toInteger() ;
     nodes[i+1] := Node.newNode(i, num) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < q do ( (     tmpArray := br.readLine()->split(" ") ; 
     var tmp : int ; tmp := (tmpArray[1+1])->toInteger() ;
     if (tmpArray[0+1] = "M") then (     nodes[tmp+1].marked := true ) else (     sum := sum+(nearest(nodes, tmp)) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) );
  static   operation nearest( nodes : Sequence(Node), id : int) : int
  pre: true
  post: true
  activity: (     while (true) do (     if (nodes[id+1].marked) then (     return id ) else skip ; 
     id := nodes[id+1].parent ) );
}
class Node {
   attribute id : int;
   attribute parent : int;
   attribute marked : boolean := false;
   static operation newNode( id : int, parent : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(id, parent);
    return self );
  operation initialise( id : int, parent : int) : void
  pre: true  post: true
  activity: (     self.id := id ; 
     self.parent := parent );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int factorial(int n){
    int f=1 ;
    for(int i=2 ; i<=n ; i++)f*=i ;
    return f ;
  }
  static void series(int A,int X,int n){
    int nFact=factorial(n);
    for(int i=0 ; i<n+1 ; i++){
      int niFact=factorial(n-i);
      int iFact=factorial(i);
      int aPow=(int)Math.pow(A,n-i);
      int xPow=(int)Math.pow(X,i);
      System.out.print((nFact*aPow*xPow)/(niFact*iFact)+" ");
    }
  }
  public static void main(String[] args){
    int A=3,X=4,n=5 ;
    series(A,X,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation factorial( n : int) : int
  pre: true
  post: true
  activity: (     var f : int ; f := 1 ;
         var i : int ; i := 2 ; while i <= n do (     f := f*(i) ;  ;     i := i + 1 ) ; 
     return f );
  static   operation series( A : int, X : int, n : int) : void
  pre: true
  post: true
  activity: (     var nFact : int ; nFact := factorial(n) ;
         var i : int ; i := 0 ; while i < n + 1 do ( (     var niFact : int ; niFact := factorial(n - i) ;
     var iFact : int ; iFact := factorial(i) ;
    var aPow : int ; aPow := A->pow(n - i)->oclAsType(int) ;
    var xPow : int ; xPow := X->pow(i)->oclAsType(int) ;
    OclFile["System.out"].print((nFact * aPow * xPow) / (niFact * iFact) + " ") ; 
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 3 ;
    var X : int ; X := 4 ;
    var n : int ; n := 5 ;
     execute series(A, X, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int floorSqrt(int x){
    if(x==0 || x==1)return x ;
    int i=1,result=1 ;
    while(result<=x){
      i++;
      result=i*i ;
    }
    return i-1 ;
  }
  public static void main(String[] args){
    int x=11 ;
    System.out.print(floorSqrt(x));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation floorSqrt( x : int) : int
  pre: true
  post: true
  activity: (     if (x = 0 or x = 1) then     return x else skip ; 
     var i : int ; i := 1 ;
    var result : int ; result := 1 ;
     while (result <= x) do (     i := i + 1 ; 
     result := i * i ) ; 
     return i - 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 11 ;
     OclFile["System.out"].print(floorSqrt(x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int a=scan.nextInt();
    int b=scan.nextInt();
    int c=scan.nextInt();
    int d=scan.nextInt();
    if(a==b && c==d || a==c && b==d || a==d && c==b){
      System.out.println("yes");
    }
    else {
      System.out.println("no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    var c : int ; c := scan.getCurrent()->toInteger() ;
    var d : int ; d := scan.getCurrent()->toInteger() ;
    if (a = b & c = d or a = c & b = d or a = d & c = b) then (     OclFile["System.out"].println("yes") ) else (     OclFile["System.out"].println("no") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    if(a==b && c==d || a==c && b==d || a==d && b==c)System.out.println("yes");
    else System.out.println("no");
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    if (a = b & c = d or a = c & b = d or a = d & b = c) then     OclFile["System.out"].println("yes") else     OclFile["System.out"].println("no") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    StringTokenizer st=new StringTokenizer(br.readLine());
    int[] sides=new int[4];
    int total=0 ;
    for(int i=0 ; i<4 ; i++){
      sides[i]=parseInt(st.nextToken());
      total+=sides[i];
    }
    Arrays.sort(sides);
    if(sides[0]==sides[1] && sides[2]==sides[3]){
      System.out.println("yes");
    }
    else {
      System.out.println("no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var sides : Sequence(int) ; sides := Integer.subrange(1,4)->collect(0) ;
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     sides[i+1] := (st.next() + "")->toInteger() ; 
     total := total+(sides[i+1]) )  ;     i := i + 1 ) ; 
    sides := sides->sort() ; 
    if (sides[0+1] = sides[1+1] & sides[2+1] = sides[3+1]) then (     OclFile["System.out"].println("yes") ) else (     OclFile["System.out"].println("no") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Map<Integer,Integer>m=new HashMap<>();
    for(int i=0 ; i<4 ; i++){
      int n=sc.nextInt();
      if(m.containsKey(n)){
        m.put(n,m.get(n)+1);
      }
      else {
        m.put(n,1);
      }
    }
    int c=0 ;
    for(Map.Entry<Integer,Integer>e : m.entrySet()){
      if(e.getValue()==4){
        c=2 ;
      }
      if(e.getValue()==2){
        c++;
      }
    }
    System.out.println(c==2 ? "yes" : "no");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : Map(int,int) ; m := Map{} ;
        var i : int ; i := 0 ; while i < 4 do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (m->keys()->includes(n)) then (     m := m->union(Map{n |-> m->at(n) + 1}) ) else (     m := m->union(Map{n |-> 1}) ) )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
    for (e : m->asSet()) do ( (     if (e.getValue() = 4) then (     c := 2 ) else skip ; 
     if (e.getValue() = 2) then (     c := c + 1 ) else skip )  ) ; 
    OclFile["System.out"].println(if c = 2 then "yes" else "no" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(is);
    String str ;
    if((str=br.readLine())!=null){
      String[] sp=str.split(" ");
      int a=Integer.parseInt(sp[0]);
      int b=Integer.parseInt(sp[1]);
      int c=Integer.parseInt(sp[2]);
      int d=Integer.parseInt(sp[3]);
      if(a==b && c==d){
        System.out.println("yes");
      }
      else if(a==c && b==d){
        System.out.println("yes");
      }
      else if(a==d && b==c){
        System.out.println("yes");
      }
      else {
        System.out.println("no");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(is) ;
     var str : String ;
     if ((str) /= null) then (     var sp : Sequence(String) ; sp := str->split(" ") ;
     var a : int ; a := (sp[0+1])->toInteger() ;
    var b : int ; b := (sp[1+1])->toInteger() ;
    var c : int ; c := (sp[2+1])->toInteger() ;
    var d : int ; d := (sp[3+1])->toInteger() ;
    if (a = b & c = d) then (     OclFile["System.out"].println("yes") ) else     if (a = c & b = d) then (     OclFile["System.out"].println("yes") ) else     if (a = d & b = c) then (     OclFile["System.out"].println("yes") ) else (     OclFile["System.out"].println("no") ) ;  ;  ;  
 ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B250 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    StringBuilder out=new StringBuilder();
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      String s=in.next();
      int idx=s.indexOf("::");
      if(idx==-1){
        String[] parts=s.split(":");
        for(int i=0 ; i<parts.length ; i++){
          if(i!=0){
            out.append(':');
          }
          out.append(process(parts[i]));
        }
      }
      else {
        String start=s.substring(0,idx);
        String end=s.substring(idx+2);
        String[] parts1=start.isEmpty()? new String[0] : start.split(":");
        String[] parts2=end.isEmpty()? new String[0] : end.split(":");
        boolean first=true ;
        for(String part : parts1){
          if(! first){
            out.append(':');
          }
          first=false ;
          out.append(process(part));
        }
        for(int i=parts1.length+parts2.length ; i<8 ; i++){
          if(! first){
            out.append(':');
          }
          first=false ;
          out.append("0000");
        }
        for(String part : parts2){
          if(! first){
            out.append(':');
          }
          first=false ;
          out.append(process(part));
        }
      }
      out.append('\n');
    }
    System.out.print(out);
  }
  static String process(String part){
    while(part.length()<4){
      part='0'+part ;
    }
    return part ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B250 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : String ; out := StringLib.newString() ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < T do ( (     var s : String ; s := in.getCurrent() ;
     var idx : int ; idx := s->indexOf("::")-1 ;
     if (idx = -1) then (     var parts : Sequence(String) ; parts := s->split(":") ;
         var i : int ; i := 0 ; while i < parts->size() do ( (     if (i /= 0) then (     out := out + StringLib.newString(':') ) else skip ; 
     out := out + StringLib.newString(process(parts[i+1])) )  ;     i := i + 1 ) ) else (     var start : String ; start := s.subrange(0+1,idx) ;
     var end : String ; end := s.subrange(idx + 2+1,idx + 2) ;
    var parts1 : Sequence(String) ; parts1 := if start->isEmpty() then Integer.subrange(1,0)->collect(null) else start->split(":") endif ;
    var parts2 : Sequence(String) ; parts2 := if end->isEmpty() then Integer.subrange(1,0)->collect(null) else end->split(":") endif ;
    var first : boolean ; first := true ;
    for (part : parts1) do ( (     if (not(first)) then (     out := out + StringLib.newString(':') ) else skip ; 
     first := false ; 
     out := out + StringLib.newString(process(part)) )  ) ; 
        var i : int ; i := parts1->size() + parts2->size() ; while i < 8 do ( (     if (not(first)) then (     out := out + StringLib.newString(':') ) else skip ; 
     first := false ; 
     out := out + StringLib.newString("0000") )  ;     i := i + 1 ) ; 
    for (part : parts2) do ( (     if (not(first)) then (     out := out + StringLib.newString(':') ) else skip ; 
     first := false ; 
     out := out + StringLib.newString(process(part)) )  ) ; 
 ) ;  
     out := out + StringLib.newString('
') )  ;     t := t + 1 ) ; 
    OclFile["System.out"].print(out) ; 
 );
  static   operation process( part : String) : String
  pre: true
  post: true
  activity: (     while (part->size() < 4) do (     part := '0' + part ) ; 
     return part );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] oddList=new int[100001];
    int[] evenList=new int[100001];
    for(int i=1 ; i<n+1 ; i++){
      int v=sc.nextInt();
      if(i % 2==1)oddList[v]++;
      if(i % 2==0)evenList[v]++;
    }
    int maxOdd=0,maxEven=0,secondmaxOdd=0,secondmaxEven=0,countOdd=0,countEven=0 ;
    for(int i=1 ; i<100001 ; i++){
      maxOdd=Math.max(oddList[i],maxOdd);
      maxEven=Math.max(evenList[i],maxEven);
    }
    int oddnum=0,evennum=0 ;
    for(int i=1 ; i<100001 ; i++){
      if(oddList[i]==maxOdd){
        oddnum=i ;
        countOdd++;
      }
      if(evenList[i]==maxEven){
        evennum=i ;
        countEven++;
      }
    }
    for(int i=1 ; i<100001 ; i++){
      if(oddList[i]!=maxOdd){
        secondmaxOdd=Math.max(oddList[i],secondmaxOdd);
      }
      if(evenList[i]!=maxEven){
        secondmaxEven=Math.max(evenList[i],secondmaxEven);
      }
    }
    if(countOdd>=2)secondmaxOdd=maxOdd ;
    if(countEven>=2)secondmaxEven=maxEven ;
    for(int i=1 ; i<100001 ; i++){
      if(oddList[i]==maxOdd)oddnum=i ;
      if(evenList[i]==maxEven)evennum=i ;
    }
    if(oddnum==evennum){
      if(maxOdd>maxEven){
        maxEven=secondmaxEven ;
      }
      else if(maxOdd<maxEven){
        maxOdd=secondmaxOdd ;
      }
      else {
        maxEven=Math.max(secondmaxOdd,secondmaxEven);
      }
    }
    int ans=n-maxOdd-maxEven ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var oddList : Sequence(int) ; oddList := Integer.subrange(1,100001)->collect(0) ;
    var evenList : Sequence(int) ; evenList := Integer.subrange(1,100001)->collect(0) ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     var v : int ; v := sc.getCurrent()->toInteger() ;
     if (i mod 2 = 1) then     oddList[v+1] := oddList[v+1] + 1 ; else skip ; 
     if (i mod 2 = 0) then     evenList[v+1] := evenList[v+1] + 1 ; else skip )  ;     i := i + 1 ) ; 
    var maxOdd : int ; maxOdd := 0 ;
    var maxEven : int ; maxEven := 0 ;
    var secondmaxOdd : int ; secondmaxOdd := 0 ;
    var secondmaxEven : int ; secondmaxEven := 0 ;
    var countOdd : int ; countOdd := 0 ;
    var countEven : int ; countEven := 0 ;
        var i : int ; i := 1 ; while i < 100001 do ( (     maxOdd := Set{oddList[i+1], maxOdd}->max() ; 
     maxEven := Set{evenList[i+1], maxEven}->max() )  ;     i := i + 1 ) ; 
    var oddnum : int ; oddnum := 0 ;
    var evennum : int ; evennum := 0 ;
        var i : int ; i := 1 ; while i < 100001 do ( (     if (oddList[i+1] = maxOdd) then (     oddnum := i ; 
     countOdd := countOdd + 1 ) else skip ; 
     if (evenList[i+1] = maxEven) then (     evennum := i ; 
     countEven := countEven + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < 100001 do ( (     if (oddList[i+1] /= maxOdd) then (     secondmaxOdd := Set{oddList[i+1], secondmaxOdd}->max() ) else skip ; 
     if (evenList[i+1] /= maxEven) then (     secondmaxEven := Set{evenList[i+1], secondmaxEven}->max() ) else skip )  ;     i := i + 1 ) ; 
    if (countOdd >= 2) then     secondmaxOdd := maxOdd ; else skip ; 
    if (countEven >= 2) then     secondmaxEven := maxEven ; else skip ; 
        var i : int ; i := 1 ; while i < 100001 do ( (     if (oddList[i+1] = maxOdd) then     oddnum := i ; else skip ; 
     if (evenList[i+1] = maxEven) then     evennum := i ; else skip )  ;     i := i + 1 ) ; 
    if (oddnum = evennum) then (     if (maxOdd > maxEven) then (     maxEven := secondmaxEven ) else     if (maxOdd < maxEven) then (     maxOdd := secondmaxOdd ) else (     maxEven := Set{secondmaxOdd, secondmaxEven}->max() ) ;  ) else skip ; 
    var ans : int ; ans := n - maxOdd - maxEven ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int m=sc.nextInt();
      while(n!=m && n>0 && m>0){
        if(n>m){
          int diff=n-m ;
          if(diff % 2!=0){
            diff++;
          }
          n-=diff ;
          m-=diff/2 ;
        }
        else if(n<m){
          int diff=m-n ;
          if(diff % 2!=0){
            diff++;
          }
          m-=diff ;
          n-=diff/2 ;
        }
      }
      if(n==m && n % 3==0)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     while (n /= m & n > 0 & m > 0) do (     if (n > m) then (     var diff : int ; diff := n - m ;
     if (diff mod 2 /= 0) then (     diff := diff + 1 ) else skip ; 
     n := n-(diff) ; 
     m := m-(diff / 2) ) else     if (n < m) then (     var diff : int ; diff := m - n ;
     if (diff mod 2 /= 0) then (     diff := diff + 1 ) else skip ; 
     m := m-(diff) ; 
     n := n-(diff / 2) ) else skip ; ) ; 
     if (n = m & n mod 3 = 0) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] a=new int[n+2];
    int[] b=new int[n+1];
    for(int i=1 ; i<=n+1 ; i++){
      a[i]=in.nextInt();
    }
    for(int i=1 ; i<=n ; i++){
      b[i]=in.nextInt();
    }
    long beated=0 ;
    for(int i=1 ; i<=n ; i++){
      if(a[i]>=b[i]){
        beated+=b[i];
        a[i]-=b[i];
        b[i]=0 ;
      }
      else if(a[i]<b[i]){
        beated+=a[i];
        b[i]-=a[i];
        a[i]=0 ;
        if(a[i+1]>=b[i]){
          beated+=b[i];
          a[i+1]-=b[i];
          b[i]=0 ;
        }
        else if(a[i+1]<b[i]){
          beated+=a[i+1];
          b[i]-=a[i+1];
          a[i+1]=0 ;
        }
      }
    }
    System.out.println(beated);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 2)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n + 1 do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     b[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var beated : long ; beated := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (a[i+1] >= b[i+1]) then (     beated := beated+(b[i+1]) ; 
     a[i+1] := a[i+1]-(b[i+1]) ; 
     b[i+1] := 0 ) else     if (a[i+1] < b[i+1]) then (     beated := beated+(a[i+1]) ; 
     b[i+1] := b[i+1]-(a[i+1]) ; 
     a[i+1] := 0 ; 
     if (a[i + 1+1] >= b[i+1]) then (     beated := beated+(b[i+1]) ; 
     a[i + 1+1] := a[i + 1+1]-(b[i+1]) ; 
     b[i+1] := 0 ) else     if (a[i + 1+1] < b[i+1]) then (     beated := beated+(a[i + 1+1]) ; 
     b[i+1] := b[i+1]-(a[i + 1+1]) ; 
     a[i + 1+1] := 0 ) else skip ; ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(beated) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n+1];
    for(int i=0 ; i<a.length ; i++){
      a[i]=sc.nextInt();
    }
    int[] b=new int[n];
    for(int i=0 ; i<b.length ; i++){
      b[i]=sc.nextInt();
    }
    sc.close();
    long ans=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(a[i+1]+a[i]<b[i]){
        ans+=a[i+1]+a[i];
        a[i]=0 ;
      }
      else {
        ans+=b[i];
        if(a[i+1]<b[i]){
          a[i]-=b[i]-a[i+1];
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < b->size() do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (a[i + 1+1] + a[i+1] < b[i+1]) then (     ans := ans+(a[i + 1+1] + a[i+1]) ; 
     a[i+1] := 0 ) else (     ans := ans+(b[i+1]) ; 
     if (a[i + 1+1] < b[i+1]) then (     a[i+1] := a[i+1]-(b[i+1] - a[i + 1+1]) ) else skip ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    Long[] A=new Long[N+1];
    Long[] B=new Long[N];
    for(int i=0 ; i<=N ; i++){
      A[i]=sc.nextLong();
    }
    for(int i=0 ; i<N ; i++){
      B[i]=sc.nextLong();
    }
    Long count=0L ;
    for(int i=0 ; i<N ; i++){
      Long current=A[i];
      Long next=A[i+1];
      if(current<=B[i]){
        B[i]-=current ;
        A[i]=0L ;
      }
      else {
        A[i]-=B[i];
        B[i]=0L ;
      }
      if(B[i]>0){
        if(next<=B[i]){
          B[i]-=next ;
          A[i+1]=0L ;
        }
        else {
          A[i+1]-=B[i];
          B[i]=0L ;
        }
      }
      count+=current-A[i]+next-A[i+1];
    }
    println(count);
  }
  static void println(Object o){
    System.out.println(o);
  }
  static void print(Object o){
    System.out.print(o);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N + 1)->collect(null) ;
    var B : Sequence(long) ; B := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i <= N do ( (     A[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     B[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var count : long ; count := 0L ;
        var i : int ; i := 0 ; while i < N do ( (     var current : long ; current := A[i+1] ;
     var next : long ; next := A[i + 1+1] ;
    if (current <= B[i+1]) then (     B[i+1] := B[i+1]-(current) ; 
     A[i+1] := 0L ) else (     A[i+1] := A[i+1]-(B[i+1]) ; 
     B[i+1] := 0L ) ;  
    if (B[i+1] > 0) then (     if (next <= B[i+1]) then (     B[i+1] := B[i+1]-(next) ; 
     A[i + 1+1] := 0L ) else (     A[i + 1+1] := A[i + 1+1]-(B[i+1]) ; 
     B[i+1] := 0L ) ) else skip ; 
    count := count+(current - A[i+1] + next - A[i + 1+1]) ; 
 )  ;     i := i + 1 ) ; 
    execute println(count) ; 
 );
  static   operation println( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation print( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static void main(String args[])throws IOException {
    double n,max=0,i ;
    Scanner sc=new Scanner(System.in);
    n=sc.nextDouble();
    double a[]=new double[(int)n+1];
    double b[]=new double[(int)n];
    for(i=0 ; i<n+1 ; i++){
      a[(int)i]=sc.nextDouble();
    }
    for(i=0 ; i<n ; i++)b[(int)i]=sc.nextDouble();
    for(i=n-1 ; i>=0 ; i--){
      if(b[(int)i]<=a[(int)i+1]){
        max+=b[(int)i];
        a[(int)i+1]-=b[(int)i];
        b[(int)i]=0 ;
      }
      else if(b[(int)i]>a[(int)i+1]){
        max+=a[(int)i+1];
        b[(int)i]-=a[(int)i+1];
        a[(int)i+1]=0 ;
        if(b[(int)i]<=a[(int)i]){
          max+=b[(int)i];
          a[(int)i]-=b[(int)i];
          b[(int)i]=0 ;
        }
        else if(b[(int)i]>a[(int)i]){
          max+=a[(int)i];
          b[(int)i]-=a[(int)i];
          a[(int)i]=0 ;
        }
      }
    }
    System.out.println((long)max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ;
    var max : double ; max := 0 ;
    var i : double ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := sc.getCurrent()->toReal() ; 
    var a : Sequence(double) ; a := Integer.subrange(1,n->oclAsType(int) + 1)->collect(0.0) ;
    var b : Sequence(double) ; b := Integer.subrange(1,n->oclAsType(int))->collect(0.0) ;
        i := 0 ; while i < n + 1 do ( (     a[i->oclAsType(int)+1] := sc.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do (     b[i->oclAsType(int)+1] := sc.getCurrent()->toReal() ;  ;     i := i + 1 ) ; 
        i := n - 1 ; while i >= 0 do ( (     if (b[i->oclAsType(int)+1] <= a[i->oclAsType(int) + 1+1]) then (     max := max+(b[i->oclAsType(int)+1]) ; 
     a[i->oclAsType(int) + 1+1] := a[i->oclAsType(int) + 1+1]-(b[i->oclAsType(int)+1]) ; 
     b[i->oclAsType(int)+1] := 0 ) else     if (b[i->oclAsType(int)+1] > a[i->oclAsType(int) + 1+1]) then (     max := max+(a[i->oclAsType(int) + 1+1]) ; 
     b[i->oclAsType(int)+1] := b[i->oclAsType(int)+1]-(a[i->oclAsType(int) + 1+1]) ; 
     a[i->oclAsType(int) + 1+1] := 0 ; 
     if (b[i->oclAsType(int)+1] <= a[i->oclAsType(int)+1]) then (     max := max+(b[i->oclAsType(int)+1]) ; 
     a[i->oclAsType(int)+1] := a[i->oclAsType(int)+1]-(b[i->oclAsType(int)+1]) ; 
     b[i->oclAsType(int)+1] := 0 ) else     if (b[i->oclAsType(int)+1] > a[i->oclAsType(int)+1]) then (     max := max+(a[i->oclAsType(int)+1]) ; 
     b[i->oclAsType(int)+1] := b[i->oclAsType(int)+1]-(a[i->oclAsType(int)+1]) ; 
     a[i->oclAsType(int)+1] := 0 ) else skip ; ) else skip ; )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(max->oclAsType(long)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    long[] a=new long[100005];
    long[] b=new long[100005];
    for(int i=0 ; i<n+1 ; ++i){
      a[i]=input.nextLong();
    }
    for(int i=0 ; i<n ; ++i){
      b[i]=input.nextLong();
    }
    long sum=0 ;
    for(int i=0 ; i<n ; ++i){
      if(a[i]<=b[i]){
        sum+=a[i];
        b[i]-=a[i];
      }
      else {
        sum+=b[i];
        b[i]=0 ;
      }
      if(a[i+1]<=b[i]){
        sum+=a[i+1];
        b[i]-=a[i+1];
        a[i+1]=0 ;
      }
      else {
        sum+=b[i];
        a[i+1]-=b[i];
        b[i]=0 ;
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,100005)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,100005)->collect(0) ;
        var i : int ; i := 0 ; while i < n + 1 do ( (     a[i+1] := input.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := input.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] <= b[i+1]) then (     sum := sum+(a[i+1]) ; 
     b[i+1] := b[i+1]-(a[i+1]) ) else (     sum := sum+(b[i+1]) ; 
     b[i+1] := 0 ) ;  
     if (a[i + 1+1] <= b[i+1]) then (     sum := sum+(a[i + 1+1]) ; 
     b[i+1] := b[i+1]-(a[i + 1+1]) ; 
     a[i + 1+1] := 0 ) else (     sum := sum+(b[i+1]) ; 
     a[i + 1+1] := a[i + 1+1]-(b[i+1]) ; 
     b[i+1] := 0 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.stream.IntStream ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.util.InputMismatchException ;
import java.util.BitSet ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskC solver=new TaskC();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskC {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int[] a=in.nextIntArray(n);
      int sum=Arrays.stream(a).sum();
      BitSet bitSet=new BitSet();
      bitSet.set(sum);
      for(int i=0 ; i<n ; i++){
        bitSet.or(bitSet.get(a[i],sum+1));
      }
      out.println(bitSet.nextSetBit((sum+1)/2));
    }
  }
  static class InputReader {
    BufferedReader in ;
    StringTokenizer tok ;
    public String nextString(){
      while(! tok.hasMoreTokens()){
        try {
          tok=new StringTokenizer(in.readLine()," ");
        }
        catch(IOException e){
          throw new InputMismatchException();
        }
      }
      return tok.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(nextString());
    }
    public int[] nextIntArray(int n){
      int[] res=new int[n];
      for(int i=0 ; i<n ; i++){
        res[i]=nextInt();
      }
      return res ;
    }
    public InputReader(InputStream inputStream){
      in=new BufferedReader(new InputStreamReader(inputStream));
      tok=new StringTokenizer("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskC ; solver := TaskC.newTaskC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskC {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var a : Sequence(int) ; a := in.nextIntArray(n) ;
    var sum : int ; sum := stream(a)->sum() ;
    var bitSet : Sequence(boolean) ; bitSet := MathLib.toBitSequence() ;
    bitSet := bitSet.setAt(sum+1, true) ; 
        var i : int ; i := 0 ; while i < n do ( (     bitSet := bitSet.or(bitSet->at(a[i+1], sum + 1+1)) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute in : OclFile;
   attribute tok : OclIterator;
   operation nextString() : String
  pre: true
  post: true
  activity: (     while (not(tok.hasNext())) do (     try (     tok := OclIterator.newOclIterator_String_String(in.readLine(), " ") )   catch (e : IOException) do (     error IncorrectElementException() )
 ) ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextString())->toInteger() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return res );
   static operation newInputReader( inputStream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) ; 
     tok := OclIterator.newOclIterator_String("") );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    int[] A=new int[N];
    int sum=0 ;
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
      sum+=A[i];
    }
    if(N==1){
      System.out.println(sum);
      return ;
    }
    long[] exist=new long[(sum+63)/64];
    exist[0]=1L ;
    long[] tmp=new long[exist.length];
    for(int i=0 ; i<N ; i++){
      Arrays.fill(tmp,0L);
      for(int j=0 ; j<exist.length ; j++){
        if(A[i] % 64==0){
          if(j+A[i]/64<tmp.length)tmp[j+A[i]/64] |=exist[j];
        }
        else {
          if(j+A[i]/64<tmp.length)tmp[j+A[i]/64] |=exist[j]<<(A[i] % 64);
          if(j+A[i]/64+1<tmp.length)tmp[j+A[i]/64+1] |=exist[j]>>>(64-A[i] % 64);
        }
        exist[j] |=tmp[j];
      }
      exist[A[i]/64] |=1L<<(A[i] % 64);
    }
    for(int i=(sum+1)/2 ; ; i++){
      if((exist[i/64] &(1L<<i % 64))!=0){
        System.out.println(i);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(A[i+1]) )  ;     i := i + 1 ) ; 
    if (N = 1) then (     OclFile["System.out"].println(sum) ; 
     return ) else skip ; 
    var exist : Sequence(long) ; exist := Integer.subrange(1,(sum + 63) / 64)->collect(0) ;
    exist[0+1] := 1L ; 
    var tmp : Sequence(long) ; tmp := Integer.subrange(1,exist->size())->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     tmp := tmp->collect(0L) ; 
         var j : int ; j := 0 ; while j < exist->size() do ( (     if (A[i+1] mod 64 = 0) then (     if (j + A[i+1] / 64 < tmp->size()) then     tmp[j + A[i+1] / 64+1] := MathLib.bitwiseOr(tmp[j + A[i+1] / 64+1], exist[j+1]) ; else skip ) else (     if (j + A[i+1] / 64 < tmp->size()) then     tmp[j + A[i+1] / 64+1] := MathLib.bitwiseOr(tmp[j + A[i+1] / 64+1], (exist[j+1]*(2->pow((A[i+1] mod 64))))->oclAsType(long)) ; else skip ; 
     if (j + A[i+1] / 64 + 1 < tmp->size()) then     tmp[j + A[i+1] / 64 + 1+1] := MathLib.bitwiseOr(tmp[j + A[i+1] / 64 + 1+1], (exist[j+1]/(2->pow((64 - A[i+1] mod 64))))->oclAsType(long)) ; else skip ) ;  
     exist[j+1] := MathLib.bitwiseOr(exist[j+1], tmp[j+1]) )  ;     j := j + 1 ) ; 
     exist[A[i+1] / 64+1] := MathLib.bitwiseOr(exist[A[i+1] / 64+1], (1L*(2->pow((A[i+1] mod 64))))->oclAsType(long)) )  ;     i := i + 1 ) ; 
        var i : int ; i := (sum + 1) / 2 ; while true do ( (     if ((exist[i / 64+1] & ((1L*(2->pow(i mod 64)))->oclAsType(long))) /= 0) then (     OclFile["System.out"].println(i) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  int n,a[];
  private void solve()throws IOException {
    n=nextInt();
    a=new int[n+1];
    int sum=0 ;
    for(int i=1 ; i<=n ; i++){
      a[i]=nextInt();
      sum+=a[i];
    }
    int maxn=4000000 ;
    BitSet dp=new BitSet(maxn+1);
    dp.set(maxn);
    for(int i=1 ; i<=n ; i++)dp.or(dp.get(a[i],maxn+1));
    for(int i=(sum+1)/2 ; i<=maxn ; i++)if(dp.get(maxn-i)){
      out.println(i);
      return ;
    }
  }
  public void run()throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    st=null ;
    out=new PrintWriter(System.out);
    solve();
    br.close();
    out.close();
  }
  public static void main(String args[])throws IOException {
    new Main().run();
  }
  BufferedReader br ;
  StringTokenizer st ;
  PrintWriter out ;
  String nextToken()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  String nextLine()throws IOException {
    return br.readLine();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   operation solve() : void
  pre: true
  post: true
  activity: (     n := nextInt() ; 
     a := Integer.subrange(1,n + 1)->collect(0) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := nextInt() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    var maxn : int ; maxn := 4000000 ;
    var dp : Sequence(boolean) ; dp := MathLib.toBitSequence(maxn + 1) ;
    dp := dp.setAt(maxn+1, true) ; 
        var i : int ; i := 1 ; while i <= n do (     dp := dp.or(dp->at(a[i+1], maxn + 1+1)) ;  ;     i := i + 1 ) ; 
        var i : int ; i := (sum + 1) / 2 ; while i <= maxn do (     if (dp->at(maxn - i+1)) then (     out.println(i) ; 
     return ) else skip ;  ;     i := i + 1 ) ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := null ; 
    out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    br.close() ; 
    out.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute br : OclFile;
   attribute st : OclIterator;
   attribute out : OclFile;
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
public class Main {
  public static void main(String[] g){
    Scanner c=new Scanner(System.in);
    int n=c.nextInt();
    int[] a=IntStream.range(0,n).map(i->c.nextInt()).toArray();
    int s=Arrays.stream(a).sum();
    BitSet b=new BitSet();
    b.set(s);
    IntStream.range(0,n).forEach(i->b.or(b.get(a[i],s+1)));
    System.out.println(b.nextSetBit((s+1)/2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( g : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var c : OclFile ; c := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := c.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(0, n-1)->collect( _x1 | (lambda i : OclAny in c.getCurrent()->toInteger())->apply(_x1) )->asSequence() ;
    var s : int ; s := stream(a)->sum() ;
    var b : Sequence(boolean) ; b := MathLib.toBitSequence() ;
    b := b.setAt(s+1, true) ; 
    for i : Integer.subrange(0, n-1) do
    (    b := b.or(b->at(a[i+1], s + 1+1))) ; 
    OclFile["System.out"].println(b.nextSetBit((s + 1) / 2)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.util.stream.Collectors.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    HashMap<Integer,Integer>hashE=new HashMap<>();
    HashMap<Integer,Integer>hashO=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int in=sc.nextInt();
      if(i % 2==0){
        hashE.put(in,hashE.getOrDefault(in,0)+1);
      }
      else {
        hashO.put(in,hashO.getOrDefault(in,0)+1);
      }
    }
    List<Map.Entry<Integer,Integer>>listE=hashE.entrySet().stream().sorted(Map.Entry.comparingByValue(Comparator.reverseOrder())).collect(toList());
    List<Map.Entry<Integer,Integer>>listO=hashO.entrySet().stream().sorted(Map.Entry.comparingByValue(Comparator.reverseOrder())).collect(toList());
    Map.Entry<Integer,Integer>e1=listE.get(0);
    Map.Entry<Integer,Integer>e2=1<listE.size()? listE.get(1): new AbstractMap.SimpleEntry<>(-1,0);
    Map.Entry<Integer,Integer>o1=listO.get(0);
    Map.Entry<Integer,Integer>o2=1<listO.size()? listO.get(1): new AbstractMap.SimpleEntry<>(-1,0);
    if(e1.getKey().equals(o1.getKey())){
      System.out.println(n-Math.max(e1.getValue()+o2.getValue(),e2.getValue()+o1.getValue()));
    }
    else {
      System.out.println(n-e1.getValue()-o1.getValue());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var hashE : Map(int,int) ; hashE := Map{} ;
    var hashO : Map(int,int) ; hashO := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var in : int ; in := sc.getCurrent()->toInteger() ;
     if (i mod 2 = 0) then (     hashE := hashE->union(Map{in |-> (if hashE->keys()->contains(in) then hashE->at(in) else 0 endif) + 1}) ) else (     hashO := hashO->union(Map{in |-> (if hashO->keys()->contains(in) then hashO->at(in) else 0 endif) + 1}) ) )  ;     i := i + 1 ) ; 
    var listE : Sequence(Map(int,int)) ; listE := hashE->asSet()->sort().collect(toList()) ;
    var listO : Sequence(Map(int,int)) ; listO := hashO->asSet()->sort().collect(toList()) ;
    var e1 : Map(int,int) ; e1 := listE->at(0+1) ;
    var e2 : Map(int,int) ; e2 := if 1 < listE->size() then listE->at(1+1) else SimpleEntry<OclAny>.newSimpleEntry(-1, 0) endif ;
    var o1 : Map(int,int) ; o1 := listO->at(0+1) ;
    var o2 : Map(int,int) ; o2 := if 1 < listO->size() then listO->at(1+1) else SimpleEntry<OclAny>.newSimpleEntry(-1, 0) endif ;
    if (e1->keys()->any() = o1->keys()->any()) then (     OclFile["System.out"].println(n - Set{e1->values->any() + o2->values->any(), e2->values->any() + o1->values->any()}->max()) ) else (     OclFile["System.out"].println(n - e1->values->any() - o1->values->any()) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.math.BigInteger ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskC solver=new TaskC();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskC {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int[] a=new int[n];
      int s=0 ;
      for(int i=0 ; i<n ; ++i){
        a[i]=in.nextInt();
        s+=a[i];
      }
      int half=s/2 ;
      BigInteger mask=BigInteger.ONE.shiftLeft(half+1).subtract(BigInteger.ONE);
      BigInteger can=BigInteger.ONE ;
      for(int x : a){
        can=can.or(can.shiftLeft(x)).and(mask);
      }
      int x=can.bitLength()-1 ;
      out.println(s-x);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskC ; solver := TaskC.newTaskC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskC {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var s : int ; s := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.nextInt() ; 
     s := s+(a[i+1]) )  ;     i := i + 1 ) ; 
    var half : int ; half := s / 2 ;
    var mask : long ; mask := 1.shiftLeft(half + 1).subtract(1) ;
    var can : long ; can := 1 ;
    for (x : a) do ( (     can := can.or(can.shiftLeft(x)).and(mask) )  ) ; 
    var x : int ; x := can.bitLength() - 1 ;
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.sql.Array ;
import java.util.*;
public class Hi {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n-->0){
      int a=sc.nextInt();
      int b=sc.nextInt();
      if(Math.max(a,b)>2*Math.min(a,b))System.out.println("no");
      else if((a+b)% 3==0)System.out.println("yes");
      else System.out.println("no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hi {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (Set{a, b}->max() > 2 * Set{a, b}->min()) then     OclFile["System.out"].println("no") ; else     if ((a + b) mod 3 = 0) then     OclFile["System.out"].println("yes") else     OclFile["System.out"].println("no") ; ;  ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int d=sc.nextInt();
      if(d==0){
        break ;
      }
      int n=sc.nextInt();
      int m=sc.nextInt();
      int[] store=new int[n+1];
      store[n]=d ;
      for(int i=1 ; i<n ; i++){
        store[i]=sc.nextInt();
      }
      int[] deliv=new int[m];
      for(int i=0 ; i<m ; i++){
        deliv[i]=sc.nextInt();
      }
      System.out.println(solve(store,deliv,d));
    }
  }
  static int solve(int[] store,int[] deliv,int d){
    int result=0 ;
    Arrays.sort(store);
    for(int i=0 ; i<deliv.length ; i++){
      int index=Arrays.binarySearch(store,deliv[i]);
      if(index>=0){
        continue ;
      }
      else {
        index++;
        index*=-1 ;
        result+=Math.min(deliv[i]-store[index-1],store[index]-deliv[i]);
      }
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var d : int ; d := sc.getCurrent()->toInteger() ;
     if (d = 0) then (     break ) else skip ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var store : Sequence(int) ; store := Integer.subrange(1,n + 1)->collect(0) ;
    store[n+1] := d ; 
        var i : int ; i := 1 ; while i < n do ( (     store[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var deliv : Sequence(int) ; deliv := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     deliv[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(store, deliv, d)) ; 
 ) );
  static   operation solve( store : Sequence(int), deliv : Sequence(int), d : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     store := store->sort() ; 
         var i : int ; i := 0 ; while i < deliv->size() do ( (     var index : int ; index := (store->indexOf(deliv[i+1]) - 1) ;
     if (index >= 0) then (     continue ) else (     index := index + 1 ; 
     index := index*(-1) ; 
     result := result+(Set{deliv[i+1] - store[index - 1+1], store[index+1] - deliv[i+1]}->min()) ) )  ;     i := i + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int d=parseInt(line);
      if(d==0)break ;
      int n=parseInt(br.readLine());
      int m=parseInt(br.readLine());
      int[] stores=new int[n+1];
      for(int i=1 ; i<n ; i++){
        int pos=parseInt(br.readLine());
        stores[i]=pos ;
      }
      stores[n]=d ;
      Arrays.sort(stores);
      int sum=0 ;
      for(int i=0 ; i<m ; i++){
        int pos=parseInt(br.readLine());
        int min=0,max=n-1,mid ;
        while(min<=max){
          mid=(max+min)/2 ;
          if(pos<stores[mid]){
            max=mid-1 ;
          }
          else if(stores[mid+1]<pos){
            min=mid+1 ;
          }
          else {
            sum+=Math.min(pos-stores[mid],stores[mid+1]-pos);
            break ;
          }
        }
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var d : int ; d := parseInt(line) ;
     if (d = 0) then     break else skip ; 
    var n : int ; n := parseInt(br.readLine()) ;
    var m : int ; m := parseInt(br.readLine()) ;
    var stores : Sequence(int) ; stores := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i < n do ( (     var pos : int ; pos := parseInt(br.readLine()) ;
     stores[i+1] := pos )  ;     i := i + 1 ) ; 
    stores[n+1] := d ; 
    stores := stores->sort() ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var pos : int ; pos := parseInt(br.readLine()) ;
     var min : int ; min := 0 ;
    var max : int ; max := n - 1 ;
    var mid : int ;
     while (min <= max) do (     mid := (max + min) / 2 ; 
     if (pos < stores[mid+1]) then (     max := mid - 1 ) else     if (stores[mid + 1+1] < pos) then (     min := mid + 1 ) else (     sum := sum+(Set{pos - stores[mid+1], stores[mid + 1+1] - pos}->min()) ; 
     break ) ;  ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      int d=scan.nextInt();
      if(d==0)break ;
      int n=scan.nextInt();
      int m=scan.nextInt();
      Piza p=new Piza(d);
      for(int i=1 ; i<n ; i++)p.addStore(scan.nextInt());
      p.sort();
      int result=0 ;
      for(int i=0 ; i<m ; i++)result+=p.addDeliver(scan.nextInt());
      System.out.println(result);
    }
    scan.close();
    System.exit(0);
  }
}
class Piza {
  public Piza(int d){
    store.add(0);
    store.add(d);
  }
  public void sort(){
    store.sort(null);
  }
  public int addDeliver(int k){
    int i=store.size()/2 ;
    int s=i/2 ;
    while(true){
      if(store.get(i)==k)break ;
      else if(store.get(i)>k)i-=s ;
      else if(store.get(i+1)>=k)break ;
      else i+=s ;
      if(s>1)s/=2 ;
    }
    return(Math.min(k-store.get(i),store.get(i+1)-k));
  }
  public void addStore(int d){
    store.add(d);
  }
  List<Integer>store=new ArrayList<Integer>();
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var d : int ; d := scan.getCurrent()->toInteger() ;
     if (d = 0) then     break else skip ; 
    var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var p : Piza ; p := Piza.newPiza(d) ;
        var i : int ; i := 1 ; while i < n do (     p.addStore(scan.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    p.sort() ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < m do (     result := result+(p.addDeliver(scan.getCurrent()->toInteger())) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ) ; 
     skip ; 
 OclProcess.exit(0) );
}
class Piza {
   static operation newPiza( d : int) : Piza
  pre: true
  post: true
  activity:
  ( var self : Piza ;
    self := createPiza();
    self.initialise(d);
    return self );
  operation initialise( d : int) : void
  pre: true  post: true
  activity: (     store->excludes(0) ; 
     store->excludes(d) );
   operation sort() : void
  pre: true
  post: true
  activity: (     store.sort(null) );
   operation addDeliver( k : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := store->size() / 2 ;
     var s : int ; s := i / 2 ;
     while (true) do (     if (store->at(i+1) = k) then     break else     if (store->at(i+1) > k) then     i := i-(s) else     if (store->at(i + 1+1) >= k) then     break else     i := i+(s) ; ;  ;  ;  
     if (s > 1) then     s := s/(2) ; else skip ) ; 
     return (Set{k - store->at(i+1), store->at(i + 1+1) - k}->min()) );
   operation addStore( d : int) : void
  pre: true
  post: true
  activity: (     store->excludes(d) );
   attribute store : Sequence(int) := Sequence{};
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static int n,a[];
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      int d=in.nextInt();
      if(d==0)return ;
      n=in.nextInt();
      int m=in.nextInt();
      a=new int[n+1];
      int ans=0 ;
      a[0]=0 ;
      for(int i=1 ; i<n ; ++i)a[i]=in.nextInt();
      a[n]=d ;
      Arrays.sort(a);
      for(int i=0 ; i<m ; ++i){
        int k=in.nextInt();
        ans+=binary(k);
      }
      System.out.println(ans);
    }
  }
  static public int binary(int ob){
    int ri=n-1 ;
    int le=0 ;
    int res=0 ;
    while(ri>=le){
      int mid=(le+ri)/2 ;
      if(a[mid]>ob)ri=mid-1 ;
      else le=mid+1 ;
    }
    res=Math.min(Math.abs(ob-a[ri]),Math.abs(a[le]-ob));
    return res ;
  }
  static public void debug(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var d : int ; d := in.getCurrent()->toInteger() ;
     if (d = 0) then     return else skip ; 
    n := in.getCurrent()->toInteger() ; 
    var m : int ; m := in.getCurrent()->toInteger() ;
    a := Integer.subrange(1,n + 1)->collect(0) ; 
    var ans : int ; ans := 0 ;
    a[0+1] := 0 ; 
        var i : int ; i := 1 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a[n+1] := d ; 
    a := a->sort() ; 
        var i : int ; i := 0 ; while i < m do ( (     var k : int ; k := in.getCurrent()->toInteger() ;
     ans := ans+(binary(k)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ) );
  static    operation binary( ob : int) : int
  pre: true
  post: true
  activity: (     var ri : int ; ri := n - 1 ;
     var le : int ; le := 0 ;
    var res : int ; res := 0 ;
    while (ri >= le) do (     var mid : int ; mid := (le + ri) / 2 ;
     if (a[mid+1] > ob) then     ri := mid - 1 ; else     le := mid + 1 ; ) ; 
    res := Set{if ob - a[ri+1] < 0 then -(ob - a[ri+1]) else ob - a[ri+1] endif, if a[le+1] - ob < 0 then -(a[le+1] - ob) else a[le+1] - ob endif}->min() ; 
    return res 
 );
  static    operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
public class GfG {
  public static boolean is_possible(String s){
    int l=s.length();
    int one=0,zero=0 ;
    for(int i=0 ; i<l ; i++){
      if(s.charAt(i)=='0')zero++;
      else one++;
    }
    if(l % 2==0)return(one==zero);
    else return(Math.abs(one-zero)==1);
  }
  public static void main(String[] args){
    String s="100110" ;
    if(is_possible(s))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation is_possible( s : String) : boolean
  pre: true
  post: true
  activity: (     var l : int ; l := s->size() ;
     var one : int ; one := 0 ;
    var zero : int ; zero := 0 ;
         var i : int ; i := 0 ; while i < l do ( (     if (s->at(i+1) = '0') then     zero := zero + 1 ; else     one := one + 1 ; )  ;     i := i + 1 ) ; 
     if (l mod 2 = 0) then     return (one = zero) else     return (if one - zero < 0 then -(one - zero) else one - zero endif = 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "100110" ;
     if (is_possible(s)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class odd_set {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      int odd=0 ;
      int even=0 ;
      int[] a=new int[2*n];
      for(int i=0 ; i<2*n ; i++){
        a[i]=sc.nextInt();
      }
      for(int i=0 ; i<2*n ; i++){
        if(a[i] % 2==0){
          even++;
        }
        else {
          odd++;
        }
      }
      if(even==odd){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class odd_set {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var odd : int ; odd := 0 ;
    var even : int ; even := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,2 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 2 * n do ( (     if (a[i+1] mod 2 = 0) then (     even := even + 1 ) else (     odd := odd + 1 ) )  ;     i := i + 1 ) ; 
    if (even = odd) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class oddSet {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int c=0 ;
      int[] arr=new int[2*n];
      for(int j=0 ; j<2*n ; j++){
        arr[j]=sc.nextInt();
      }
      for(int j=0 ; j<2*n ; j++){
        if(arr[j] % 2!=0)c++;
      }
      if(c==n)System.out.println("Yes");
      else System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class oddSet {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var c : int ; c := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,2 * n)->collect(0) ;
        var j : int ; j := 0 ; while j < 2 * n do ( (     arr[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < 2 * n do ( (     if (arr[j+1] mod 2 /= 0) then     c := c + 1 ; else skip )  ;     j := j + 1 ) ; 
    if (c = n) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int[] v=new int[100010];
    for(int i=0 ; i<n ; i++){
      v[i]=Integer.parseInt(sc.next());
    }
    Integer[] vo=new Integer[100010];
    Integer[] ve=new Integer[100010];
    Integer[] vt=new Integer[100010];
    Arrays.fill(vo,0);
    Arrays.fill(ve,0);
    Arrays.fill(vt,0);
    for(int i=0 ; i<n ; i++){
      vt[v[i] ]++;
      if(i % 2==0){
        ve[v[i] ]++;
      }
      else {
        vo[v[i] ]++;
      }
    }
    Arrays.sort(vo,Collections.reverseOrder());
    Arrays.sort(ve,Collections.reverseOrder());
    Arrays.sort(vt,Collections.reverseOrder());
    int ans=0 ;
    if(vo[0]+ve[0]==vt[0]){
      ans=Math.min(n-vo[0]-ve[1],n-vo[1]-ve[0]);
    }
    else {
      ans=n-vo[0]-ve[0];
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var v : Sequence(int) ; v := Integer.subrange(1,100010)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     v[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var vo : Sequence(int) ; vo := Integer.subrange(1,100010)->collect(null) ;
    var ve : Sequence(int) ; ve := Integer.subrange(1,100010)->collect(null) ;
    var vt : Sequence(int) ; vt := Integer.subrange(1,100010)->collect(null) ;
    vo := vo->collect(0) ; 
    ve := ve->collect(0) ; 
    vt := vt->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     vt[v[i+1]+1] := vt[v[i+1]+1] + 1 ; 
     if (i mod 2 = 0) then (     ve[v[i+1]+1] := ve[v[i+1]+1] + 1 ) else (     vo[v[i+1]+1] := vo[v[i+1]+1] + 1 ) )  ;     i := i + 1 ) ; 
    vo := OclComparator.sortWith(vo, reverseOrder()) ; 
    ve := OclComparator.sortWith(ve, reverseOrder()) ; 
    vt := OclComparator.sortWith(vt, reverseOrder()) ; 
    var ans : int ; ans := 0 ;
    if (vo[0+1] + ve[0+1] = vt[0+1]) then (     ans := Set{n - vo[0+1] - ve[1+1], n - vo[1+1] - ve[0+1]}->min() ) else (     ans := n - vo[0+1] - ve[0+1] ) ;  
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test169 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int o=0,e=0 ;
      int n=in.nextInt();
      for(int i=0 ; i<n*2 ; i++){
        if(in.nextInt()% 2==0){
          e++;
        }
        else {
          o++;
        }
      }
      if(o==e){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test169 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var o : int ; o := 0 ;
    var e : int ; e := 0 ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n * 2 do ( (     if (in.getCurrent()->toInteger() mod 2 = 0) then (     e := e + 1 ) else (     o := o + 1 ) )  ;     i := i + 1 ) ; 
     if (o = e) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1542A_OddSet {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      final int len=parseInt(input.nextLine());
      int odds=0 ;
      int evens=0 ;
      for(int i=0 ; i<2*len ; i++){
        int num=input.nextInt();
        if(num % 2==0){
          evens++;
        }
        else {
          odds++;
        }
      }
      input.nextLine();
      if(evens==odds){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1542A_OddSet {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var len : int ; len := parseInt(input.nextLine()) ;
     var odds : int ; odds := 0 ;
    var evens : int ; evens := 0 ;
        var i : int ; i := 0 ; while i < 2 * len do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
     if (num mod 2 = 0) then (     evens := evens + 1 ) else (     odds := odds + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    if (evens = odds) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  Main(){
    sc=new Scanner(System.in);
  }
  void run(){
    for(; ; ){
      double in=sc.nextDouble();
      if(in==0){
        break ;
      }
      int denom=1 ;
      boolean ok=false ;
      for(; ; ){
        for(int i=(int)(denom*Math.PI); i<denom*Math.PI+1 ; i++){
          if(Math.abs((double)i/denom-Math.PI)<in){
            ok=true ;
          }
        }
        if(ok){
          break ;
        }
        denom++;
      }
      double min=in ;
      int index=0 ;
      for(int i=(int)(denom*Math.PI); i<denom*Math.PI+1 ; i++){
        if(Math.abs((double)i/denom-Math.PI)<min){
          min=Math.abs((double)i/denom-Math.PI);
          index=i ;
        }
      }
      System.out.println(index+"/"+denom);
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var in : double ; in := sc.getCurrent()->toReal() ;
     if (in = 0) then (     break ) else skip ; 
    var denom : int ; denom := 1 ;
    var ok : boolean ; ok := false ;
      while true do ( (         var i : int ; i := (denom * 3.141592653589793)->oclAsType(int) ; while i < denom * 3.141592653589793 + 1 do ( (     if (if i->oclAsType(double) / denom - 3.141592653589793 < 0 then -(i->oclAsType(double) / denom - 3.141592653589793) else i->oclAsType(double) / denom - 3.141592653589793 endif < in) then (     ok := true ) else skip )  ;     i := i + 1 ) ; 
     if (ok) then (     break ) else skip ; 
     denom := denom + 1 )  ) ; 
    var min : double ; min := in ;
    var index : int ; index := 0 ;
        var i : int ; i := (denom * 3.141592653589793)->oclAsType(int) ; while i < denom * 3.141592653589793 + 1 do ( (     if (if i->oclAsType(double) / denom - 3.141592653589793 < 0 then -(i->oclAsType(double) / denom - 3.141592653589793) else i->oclAsType(double) / denom - 3.141592653589793 endif < min) then (     min := if i->oclAsType(double) / denom - 3.141592653589793 < 0 then -(i->oclAsType(double) / denom - 3.141592653589793) else i->oclAsType(double) / denom - 3.141592653589793 endif ; 
     index := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(index + "/" + denom) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewClass53 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int s=0 ;
      int p=0 ;
      int o=0 ;
      int u=0 ;
      int a=in.nextInt();
      int x[]=new int[a*2];
      for(int i=0 ; i<a*2 ; i++){
        x[i]=in.nextInt();
        if(x[i] % 2==0)s++;
        else {
          p++;
        }
      }
      if(s==p){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass53 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : int ; s := 0 ;
     var p : int ; p := 0 ;
    var o : int ; o := 0 ;
    var u : int ; u := 0 ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,a * 2)->collect(0) ;
        var i : int ; i := 0 ; while i < a * 2 do ( (     x[i+1] := in.getCurrent()->toInteger() ; 
     if (x[i+1] mod 2 = 0) then     s := s + 1 ; else (     p := p + 1 ) )  ;     i := i + 1 ) ; 
    if (s = p) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,v,left=0,color=0 ;
    n=sc.nextInt();
    int[] ans=new int[n];
    List<List<Integer>>id=new ArrayList<>();
    for(int i=0 ; i<=n ; i++){
      id.add(new ArrayList<>());
    }
    for(int i=0 ; i<n ; i++){
      v=sc.nextInt();
      id.get(n-v).add(i);
    }
    for(int i=1 ; i<=n ; i++){
      if(id.get(i).size()% i>0){
        System.out.println("Impossible");
        return ;
      }
      for(int num : id.get(i)){
        if(left==0){
          left=i ;
          color++;
        }
        ans[num]=color ;
        left--;
      }
    }
    System.out.println("Possible");
    for(int num : ans){
      System.out.print(num+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var v : int ;
    var left : int ; left := 0 ;
    var color : int ; color := 0 ;
    n := sc.getCurrent()->toInteger() ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
    var id : Sequence(Sequence(int)) ; id := Sequence{} ;
        var i : int ; i := 0 ; while i <= n do ( (     id := id->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     v := sc.getCurrent()->toInteger() ; 
     id->at(n - v+1)->excludes(i) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (id->at(i+1)->size() mod i > 0) then (     OclFile["System.out"].println("Impossible") ; 
     return ) else skip ; 
     for (num : id->at(i+1)) do ( (     if (left = 0) then (     left := i ; 
     color := color + 1 ) else skip ; 
     ans[num+1] := color ; 
     left := left - 1 )  ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Possible") ; 
    for (num : ans) do ( (     OclFile["System.out"].print(num + " ") )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class CF_1081B {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Integer>[] id=new ArrayList[n+1];
    for(int i=0 ; i<id.length ; i++){
      id[i]=new ArrayList<>();
    }
    for(int i=0 ; i<n ; i++){
      int v=sc.nextInt();
      id[n-v] .add(i);
    }
    int left=0 ;
    int color=0 ;
    int[] ret=new int[n];
    for(int c=1 ; c<=n ; c++){
      if(id[c] .size()% c>0){
        System.out.println("Impossible");
        return ;
      }
      for(Integer i : id[c]){
        if(left==0){
          left=c ;
          color++;
        }
        ret[i]=color ;
        left--;
      }
    }
    StringBuilder str=new StringBuilder("Possible\n");
    for(int i : ret)str.append(i).append(' ');
    System.out.println(str);
    sc.close();
    writer.flush();
    writer.close();
    reader.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF_1081B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var id : Sequence(Sequence(int)) ; id := Integer.subrange(1,n + 1)->collect(null) ;
        var i : int ; i := 0 ; while i < id->size() do ( (     id[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := sc.getCurrent()->toInteger() ;
     id[n - v+1]->excludes(i) )  ;     i := i + 1 ) ; 
    var left : int ; left := 0 ;
    var color : int ; color := 0 ;
    var ret : Sequence(int) ; ret := Integer.subrange(1,n)->collect(0) ;
        var c : int ; c := 1 ; while c <= n do ( (     if (id[c+1]->size() mod c > 0) then (     OclFile["System.out"].println("Impossible") ; 
     return ) else skip ; 
     for (i : id[c+1]) do ( (     if (left = 0) then (     left := c ; 
     color := color + 1 ) else skip ; 
     ret[i+1] := color ; 
     left := left - 1 )  ) )  ;     c := c + 1 ) ; 
    var str : String ; str := StringLib.newString("Possible\n") ;
    for (i : ret) do (     str := str + StringLib.newString(i) + StringLib.newString(' ') ;  ) ; 
    OclFile["System.out"].println(str) ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class B1081 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    List<Integer>[] groups=new List[N+1];
    for(int n=1 ; n<=N ; n++){
      groups[n]=new ArrayList<>();
    }
    for(int n=1 ; n<=N ; n++){
      int different=in.nextInt();
      int same=N-different ;
      groups[same] .add(n);
    }
    boolean possible=true ;
    for(int n=1 ; n<=N ; n++){
      if(groups[n] .size()% n!=0){
        possible=false ;
        break ;
      }
    }
    if(possible){
      System.out.println("Possible");
      int lastGroup=0 ;
      int[] G=new int[N];
      for(int n=1 ; n<=N ; n++){
        List<Integer>group=groups[n];
        for(int i=0 ; i<group.size(); i++){
          if(i % n==0){
            lastGroup++;
          }
          int member=group.get(i);
          G[member-1]=lastGroup ;
        }
      }
      StringBuilder out=new StringBuilder();
      for(int g : G){
        out.append(g).append(' ');
      }
      System.out.println(out);
    }
    else {
      System.out.println("Impossible");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1081 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var groups : Sequence(Sequence(int)) ; groups := Integer.subrange(1,N + 1)->collect(null) ;
        var n : int ; n := 1 ; while n <= N do ( (     groups[n+1] := Sequence{} )  ;     n := n + 1 ) ; 
        var n : int ; n := 1 ; while n <= N do ( (     var different : int ; different := in.getCurrent()->toInteger() ;
     var same : int ; same := N - different ;
     groups[same+1]->excludes(n) )  ;     n := n + 1 ) ; 
    var possible : boolean ; possible := true ;
        var n : int ; n := 1 ; while n <= N do ( (     if (groups[n+1]->size() mod n /= 0) then (     possible := false ; 
     break ) else skip )  ;     n := n + 1 ) ; 
    if (possible) then (     OclFile["System.out"].println("Possible") ; 
     var lastGroup : int ; lastGroup := 0 ;
    var G : Sequence(int) ; G := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 1 ; while n <= N do ( (     var group : Sequence(int) ; group := groups[n+1] ;
         var i : int ; i := 0 ; while i < group->size() do ( (     if (i mod n = 0) then (     lastGroup := lastGroup + 1 ) else skip ; 
     var member : int ; member := group->at(i+1) ;
     G[member - 1+1] := lastGroup )  ;     i := i + 1 ) )  ;     n := n + 1 ) ; 
    var out : String ; out := StringLib.newString() ;
    for (g : G) do ( (     out := out + StringLib.newString(g) + StringLib.newString(' ') )  ) ; 
    OclFile["System.out"].println(out) ; 
 ) else (     OclFile["System.out"].println("Impossible") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int CountAllPairs(int N,int K){
    int count=0 ;
    if(N>K){
      count=N-K ;
      for(int i=K+1 ; i<=N ; i++)count=count+((N-K)/i);
    }
    return count ;
  }
  public static void main(String[] args){
    int N=11,K=5 ;
    System.out.println(CountAllPairs(N,K));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation CountAllPairs( N : int, K : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     if (N > K) then (     count := N - K ; 
         var i : int ; i := K + 1 ; while i <= N do (     count := count + ((N - K) / i) ;  ;     i := i + 1 ) ) else skip ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 11 ;
    var K : int ; K := 5 ;
     OclFile["System.out"].println(CountAllPairs(N, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int L=scanner.nextInt();
    int N=scanner.nextInt();
    int[] x=new int[N];
    int[] y=new int[N];
    for(int i=0 ; i<N ; i++){
      x[i]=scanner.nextInt();
      y[N-i-1]=L-x[i];
    }
    long[] x2=new long[N+1];
    long[] y2=new long[N+1];
    for(int i=1 ; i<=N ; i++)x2[i]=x2[i-1]+x[i-1]*2L ;
    for(int i=1 ; i<=N ; i++)y2[i]=y2[i-1]+y[i-1]*2L ;
    long max=x[N-1];
    for(int n=N-1 ; n>0 ; n--){
      int m=N-n ;
      max=Math.max(max,Math.max(x2[n-1]-x2[Math.max(n-m-1,0)]+y2[m]-y2[Math.max(m-n,0)]+x[n-1],x2[n]-x2[Math.max(n-m,0)]+y2[m-1]-y2[Math.max(m-n-1,0)]+y[m-1]));
    }
    max=Math.max(max,y[N-1]);
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var L : int ; L := scanner.getCurrent()->toInteger() ;
    var N : int ; N := scanner.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,N)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     x[i+1] := scanner.getCurrent()->toInteger() ; 
     y[N - i - 1+1] := L - x[i+1] )  ;     i := i + 1 ) ; 
    var x2 : Sequence(long) ; x2 := Integer.subrange(1,N + 1)->collect(0) ;
    var y2 : Sequence(long) ; y2 := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do (     x2[i+1] := x2[i - 1+1] + x[i - 1+1] * 2L ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do (     y2[i+1] := y2[i - 1+1] + y[i - 1+1] * 2L ;  ;     i := i + 1 ) ; 
    var max : long ; max := x[N - 1+1] ;
        var n : int ; n := N - 1 ; while n > 0 do ( (     var m : int ; m := N - n ;
     max := Set{max, Set{x2[n - 1+1] - x2[Set{n - m - 1, 0}->max()+1] + y2[m+1] - y2[Set{m - n, 0}->max()+1] + x[n - 1+1], x2[n+1] - x2[Set{n - m, 0}->max()+1] + y2[m - 1+1] - y2[Set{m - n - 1, 0}->max()+1] + y[m - 1+1]}->max()}->max() )  ;     n := n - 1 ) ; 
    max := Set{max, y[N - 1+1]}->max() ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int L=scanner.nextInt();
    int N=scanner.nextInt();
    int[] x=new int[N];
    int[] y=new int[N];
    for(int i=0 ; i<N ; i++){
      x[i]=scanner.nextInt();
      y[N-i-1]=L-x[i];
    }
    long[] x2=new long[N+1];
    long[] y2=new long[N+1];
    for(int i=1 ; i<=N ; i++)x2[i]=x2[i-1]+x[i-1]*2L ;
    for(int i=1 ; i<=N ; i++)y2[i]=y2[i-1]+y[i-1]*2L ;
    long max=x[N-1];
    for(int n=N-1 ; n>0 ; n--){
      int m=N-n ;
      max=Math.max(max,Math.max(x2[n-1]-x2[Math.max(n-m-1,0)]+y2[m]-y2[Math.max(m-n,0)]+x[n-1],x2[n]-x2[Math.max(n-m,0)]+y2[m-1]-y2[Math.max(m-n-1,0)]+y[m-1]));
    }
    max=Math.max(max,y[N-1]);
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var L : int ; L := scanner.getCurrent()->toInteger() ;
    var N : int ; N := scanner.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,N)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     x[i+1] := scanner.getCurrent()->toInteger() ; 
     y[N - i - 1+1] := L - x[i+1] )  ;     i := i + 1 ) ; 
    var x2 : Sequence(long) ; x2 := Integer.subrange(1,N + 1)->collect(0) ;
    var y2 : Sequence(long) ; y2 := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do (     x2[i+1] := x2[i - 1+1] + x[i - 1+1] * 2L ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do (     y2[i+1] := y2[i - 1+1] + y[i - 1+1] * 2L ;  ;     i := i + 1 ) ; 
    var max : long ; max := x[N - 1+1] ;
        var n : int ; n := N - 1 ; while n > 0 do ( (     var m : int ; m := N - n ;
     max := Set{max, Set{x2[n - 1+1] - x2[Set{n - m - 1, 0}->max()+1] + y2[m+1] - y2[Set{m - n, 0}->max()+1] + x[n - 1+1], x2[n+1] - x2[Set{n - m, 0}->max()+1] + y2[m - 1+1] - y2[Set{m - n - 1, 0}->max()+1] + y[m - 1+1]}->max()}->max() )  ;     n := n - 1 ) ; 
    max := Set{max, y[N - 1+1]}->max() ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test193 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    char a[]=in.next().toCharArray();
    int sum=0,x=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]=='x'){
        x++;
      }
      else {
        x=0 ;
      }
      if(x>2){
        sum++;
      }
    }
    System.out.println(sum);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test193 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(String) ; a := in.getCurrent()->characters() ;
    var sum : int ; sum := 0 ;
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = 'x') then (     x := x + 1 ) else (     x := 0 ) ;  
     if (x > 2) then (     sum := sum + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long l=sc.nextLong();
    int n=sc.nextInt();
    long[] dis=new long[n+1];
    long[] sum=new long[n+1];
    for(int i=1 ; i<=n ; i++){
      dis[i]=sc.nextLong();
      sum[i]=sum[i-1]+dis[i];
    }
    long ans=0 ;
    for(int i=1 ; i<=n ; i++){
      int right=Math.min(i-1,n-i);
      int left=Math.min(i,n-i);
      ans=Math.max(ans,dis[i]+(sum[i-1]-sum[i-1-right])*2+left*2*l-2*(sum[left+i]-sum[i]));
      right=Math.min(i-1,n-i+1);
      left=Math.min(n-i,i-1);
      ans=Math.max(ans,l-dis[i]+(sum[i-1]-sum[i-1-right])*2+left*2*l-2*(sum[left+i]-sum[i]));
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : long ; l := sc.getCurrent()->toLong() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var dis : Sequence(long) ; dis := Integer.subrange(1,n + 1)->collect(0) ;
    var sum : Sequence(long) ; sum := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     dis[i+1] := sc.getCurrent()->toLong() ; 
     sum[i+1] := sum[i - 1+1] + dis[i+1] )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var right : int ; right := Set{i - 1, n - i}->min() ;
     var left : int ; left := Set{i, n - i}->min() ;
    ans := Set{ans, dis[i+1] + (sum[i - 1+1] - sum[i - 1 - right+1]) * 2 + left * 2 * l - 2 * (sum[left + i+1] - sum[i+1])}->max() ; 
    right := Set{i - 1, n - i + 1}->min() ; 
    left := Set{n - i, i - 1}->min() ; 
    ans := Set{ans, l - dis[i+1] + (sum[i - 1+1] - sum[i - 1 - right+1]) * 2 + left * 2 * l - 2 * (sum[left + i+1] - sum[i+1])}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.System.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    int l=sc.nextInt();
    int n=sc.nextInt();
    int[] x=new int[n];
    for(int i=0 ; i<n ; i++)x[i]=sc.nextInt();
    long ans=Math.max(x[n-1],l-x[0]);
    long now=x[n-1];
    for(int i=2 ; i<=n ; i++){
      now+=l ;
      now-=(x[n-i/2]-x[n-i])*2 ;
      if(i % 2==1)now+=(x[n-i/2]-x[n-i/2-1]);
      ans=Math.max(ans,now);
    }
    now=l-x[0];
    for(int i=0 ; i<n-1 ; i++){
      now+=l ;
      now-=(x[i+1]-x[i/2])*2 ;
      if(i % 2==1)now+=(x[i/2+1]-x[i/2]);
      ans=Math.max(ans,now);
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     x[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := Set{x[n - 1+1], l - x[0+1]}->max() ;
    var now : long ; now := x[n - 1+1] ;
        var i : int ; i := 2 ; while i <= n do ( (     now := now+(l) ; 
     now := now-((x[n - i / 2+1] - x[n - i+1]) * 2) ; 
     if (i mod 2 = 1) then     now := now+((x[n - i / 2+1] - x[n - i / 2 - 1+1])) ; else skip ; 
     ans := Set{ans, now}->max() )  ;     i := i + 1 ) ; 
    now := l - x[0+1] ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     now := now+(l) ; 
     now := now-((x[i + 1+1] - x[i / 2+1]) * 2) ; 
     if (i mod 2 = 1) then     now := now+((x[i / 2 + 1+1] - x[i / 2+1])) ; else skip ; 
     ans := Set{ans, now}->max() )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  final static int N=2 ;
  final static int M=3 ;
  static int traverseMatrix(int arr[][],int current_row,int current_col){
    if(current_col>=M)return 0 ;
    if(current_row>=N)return 1 ;
    System.out.print(arr[current_row][current_col]+",");
    if(traverseMatrix(arr,current_row,current_col+1)==1)return 1 ;
    return traverseMatrix(arr,current_row+1,0);
  }
  public static void main(String[] args){
    int arr[][]={
      {
        1,2,3 },{
          4,5,6 }
        };
        traverseMatrix(arr,0,0);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 2;
  static   attribute M : int := 3;
  static   operation traverseMatrix( arr : Sequence(Sequence(int)), current_row : int, current_col : int) : int
  pre: true
  post: true
  activity: (     if (current_col >= M) then     return 0 else skip ; 
     if (current_row >= N) then     return 1 else skip ; 
    OclFile["System.out"].print(arr[current_row+1][current_col+1] + ",") ; 
    if (traverseMatrix(arr, current_row, current_col + 1) = 1) then     return 1 else skip ; 
    return traverseMatrix(arr, current_row + 1, 0) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,2,3},Sequence{4,5,6}} ;
     execute traverseMatrix(arr, 0, 0) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  double pi=Math.PI ;
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(true){
      double n=sc.nextDouble();
      if(n==0.0)break ;
      for(int i=1 ; ; i++){
        double x=pi*i ;
        int[] res=new int[] {
(int)Math.floor(x),(int)Math.ceil(x)};
          boolean flg=false ;
          for(int j=0 ; j<2 ; j++){
            double now=Math.abs(pi-((double)res[j]/i));
            if(now<=n){
              System.out.println(res[j]+"/"+i);
              flg=true ;
              break ;
            }
          }
          if(flg)break ;
        }
      }
    }
    public static void main(String[] args){
      new Main().doit();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute pi : double := 3.141592653589793;
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : double ; n := sc.getCurrent()->toReal() ;
     if (n = 0.0) then     break else skip ; 
         var i : int ; i := 1 ; while true do ( (     var x : double ; x := pi * i ;
     var res : Sequence(int) ; res := Sequence{(x)->floor()->oclAsType(int),(x)->ceil()->oclAsType(int)} ;
    var flg : boolean ; flg := false ;
        var j : int ; j := 0 ; while j < 2 do ( (     var now : double ; now := if pi - (res[j+1]->oclAsType(double) / i) < 0 then -(pi - (res[j+1]->oclAsType(double) / i)) else pi - (res[j+1]->oclAsType(double) / i) endif ;
     if (now <= n) then (     OclFile["System.out"].println(res[j+1] + "/" + i) ; 
     flg := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (flg) then     break else skip ; 
 )  ;     i := i + 1 ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int N=100005 ;
  static void SieveOfEratosthenes(boolean prime[],int p_size){
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=p_size ; p++){
      if(prime[p]){
        for(int i=p*2 ; i<=p_size ; i+=p)prime[i]=false ;
      }
    }
  }
  static int longestPrimeSubsequence(int arr[],int n){
    boolean[] prime=new boolean[N+1];
    Arrays.fill(prime,true);
    SieveOfEratosthenes(prime,N);
    int answer=0 ;
    for(int i=0 ; i<n ; i++){
      if(prime[arr[i] ]){
        answer++;
      }
    }
    return answer ;
  }
  public static void main(String[] args){
    int arr[]={
      3,4,11,2,9,21 };
      int n=arr.length ;
      System.out.print(longestPrimeSubsequence(arr,n)+"\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute N : int := 100005;
  static   operation SieveOfEratosthenes( prime : Sequence(boolean), p_size : int) : void
  pre: true
  post: true
  activity: (     prime[0+1] := false ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p <= p_size do ( (     if (prime[p+1]) then (         var i : int ; i := p * 2 ; while i <= p_size do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation longestPrimeSubsequence( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,N + 1)->collect(false) ;
     prime := prime->collect(true) ; 
    execute SieveOfEratosthenes(prime, N) ; 
    var answer : int ; answer := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (prime[arr[i+1]+1]) then (     answer := answer + 1 ) else skip )  ;     i := i + 1 ) ; 
    return answer 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,4,11,2,9,21} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(longestPrimeSubsequence(arr, n) + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    long n=s.nextInt();
    long a=s.nextInt();
    long b=s.nextInt();
    long c=s.nextInt();
    long needed=4-n % 4 ;
    long min=0 ;
    if(needed==0){
      System.out.println(0);
      return ;
    }
    else if(needed==3){
      min=3*a ;
      if(min>c)min=c ;
      if(min>b+a)min=b+a ;
    }
    else if(needed==2){
      min=2*a ;
      if(min>b)min=b ;
      if(min>2*c)min=2*c ;
    }
    else if(needed==1){
      min=a ;
      if(min>3*c)min=3*c ;
      if(min>b+c)min=b+c ;
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := s.getCurrent()->toInteger() ;
    var a : long ; a := s.getCurrent()->toInteger() ;
    var b : long ; b := s.getCurrent()->toInteger() ;
    var c : long ; c := s.getCurrent()->toInteger() ;
    var needed : long ; needed := 4 - n mod 4 ;
    var min : long ; min := 0 ;
    if (needed = 0) then (     OclFile["System.out"].println(0) ; 
     return ) else     if (needed = 3) then (     min := 3 * a ; 
     if (min > c) then     min := c ; else skip ; 
     if (min > b + a) then     min := b + a ; else skip ) else     if (needed = 2) then (     min := 2 * a ; 
     if (min > b) then     min := b ; else skip ; 
     if (min > 2 * c) then     min := 2 * c ; else skip ) else     if (needed = 1) then (     min := a ; 
     if (min > 3 * c) then     min := 3 * c ; else skip ; 
     if (min > b + c) then     min := b + c ; else skip ) else skip ; ;  ;  ;  
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Alyonaandcopybooks {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    long n=scn.nextLong();
    long a=scn.nextLong();
    long b=scn.nextLong();
    long c=scn.nextLong();
    int remain=(int)(4-(n % 4));
    long rob=0 ;
    switch(remain){
      case 0 : rob=0 ;
      break ;
      case 1 : rob=Math.min(a,Math.min(b+c,3*c));
      break ;
      case 2 : rob=Math.min(2*a,Math.min(b,2*c));
      break ;
      case 3 : rob=Math.min(3*a,Math.min(a+b,c));
    }
    System.out.println(rob);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Alyonaandcopybooks {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := scn.getCurrent()->toLong() ;
    var a : long ; a := scn.getCurrent()->toLong() ;
    var b : long ; b := scn.getCurrent()->toLong() ;
    var c : long ; c := scn.getCurrent()->toLong() ;
    var remain : int ; remain := (4 - (n mod 4))->oclAsType(int) ;
    var rob : long ; rob := 0 ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (remain) ; 
       if _switchval = 0 then
     rob := 0 ; 
    break 
   else skip ;
       if _switchval = 1 then
     rob := Set{a, Set{b + c, 3 * c}->min()}->min() ; 
    break 
   else skip ;
       if _switchval = 2 then
     rob := Set{2 * a, Set{b, 2 * c}->min()}->min() ; 
    break 
   else skip ;
       if _switchval = 3 then
     rob := Set{3 * a, Set{a + b, c}->min()}->min() ; 
   else skip ;
 )
    OclFile["System.out"].println(rob) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner input=new Scanner(System.in);
    long n=input.nextLong();
    long a=input.nextLong();
    long b=input.nextLong();
    long c=input.nextLong();
    long sum=0,min=0 ;
    if(n % 4==0)min=0 ;
    else if(n % 4==1){
      min=3*a ;
      if(min>b+a)min=b+a ;
      if(min>c)min=c ;
    }
    else if(n % 4==2){
      min=a*2 ;
      if(min>b*1)min=b ;
      if(min>c*2)min=c*2 ;
      if(min>a+b+c)min=a+b+c ;
    }
    else {
      min=a ;
      if(min>b+c)min=b+c ;
      if(min>3*c)min=3*c ;
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := input.getCurrent()->toLong() ;
    var a : long ; a := input.getCurrent()->toLong() ;
    var b : long ; b := input.getCurrent()->toLong() ;
    var c : long ; c := input.getCurrent()->toLong() ;
    var sum : long ; sum := 0 ;
    var min : long ; min := 0 ;
    if (n mod 4 = 0) then     min := 0 else     if (n mod 4 = 1) then (     min := 3 * a ; 
     if (min > b + a) then     min := b + a ; else skip ; 
     if (min > c) then     min := c ; else skip ) else     if (n mod 4 = 2) then (     min := a * 2 ; 
     if (min > b * 1) then     min := b ; else skip ; 
     if (min > c * 2) then     min := c * 2 ; else skip ; 
     if (min > a + b + c) then     min := a + b + c ; else skip ) else (     min := a ; 
     if (min > b + c) then     min := b + c ; else skip ; 
     if (min > 3 * c) then     min := 3 * c ; else skip ) ;  ;  ;  
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class C {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long n=in.nextLong(),a=in.nextLong(),b=in.nextLong(),c=in.nextLong();
    long ans=Long.MAX_VALUE ;
    for(long A=0 ; A<4 ; A++){
      for(long B=0 ; B<4 ; B++){
        for(long C=0 ; C<4 ; C++){
          if((n+A+B*2+C*3)% 4==0){
            ans=Math.min(ans,A*a+B*b+C*c);
          }
        }
      }
    }
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := in.getCurrent()->toLong() ;
    var a : long ; a := in.getCurrent()->toLong() ;
    var b : long ; b := in.getCurrent()->toLong() ;
    var c : long ; c := in.getCurrent()->toLong() ;
    var ans : long ; ans := "9223372036854775807"->toLong() ;
        var A : long ; A := 0 ; while A < 4 do ( (         var B : long ; B := 0 ; while B < 4 do ( (         var C : long ; C := 0 ; while C < 4 do ( (     if ((n + A + B * 2 + C * 3) mod 4 = 0) then (     ans := Set{ans, A * a + B * b + C * c}->min() ) else skip )  ;     C := C + 1 ) )  ;     B := B + 1 ) )  ;     A := A + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n/2];
    int[] b=new int[n/2];
    for(int i=0 ; i<n/2 ; i++){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
    }
    int ans_a1=1 ;
    int ans_a2=1 ;
    int ans_b1=1 ;
    int ans_b2=1 ;
    Arrays.sort(a);
    Arrays.sort(b);
    int k=1 ;
    int l=1 ;
    int x1=a[0];
    int y1=b[0];
    for(int i=1 ; i<n/2 ; i++){
      if(a[i]==a[i-1]){
        k++;
        if(ans_a1<=k){
          ans_a2=ans_a1 ;
          ans_a1=k ;
          x1=a[i-1];
        }
        else if(ans_a2<=k)ans_a2=k ;
      }
      else k=1 ;
    }
    for(int i=1 ; i<n/2 ; i++){
      if(b[i]==b[i-1]){
        l++;
        if(ans_b1<=l){
          ans_b2=ans_b1 ;
          ans_b1=l ;
          y1=b[i-1];
        }
        else if(ans_b2<=l)ans_b2=l ;
      }
      else l=1 ;
    }
    int ans=n-(ans_a1+ans_b1);
    if(ans_a1==n/2)ans_a2=0 ;
    if(ans_b1==n/2)ans_b2=0 ;
    if(x1==y1)ans=Math.min(n-(ans_a1+ans_b2),n-(ans_b1+ans_a2));
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n / 2)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n / 2)->collect(0) ;
        var i : int ; i := 0 ; while i < n / 2 do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans_a1 : int ; ans_a1 := 1 ;
    var ans_a2 : int ; ans_a2 := 1 ;
    var ans_b1 : int ; ans_b1 := 1 ;
    var ans_b2 : int ; ans_b2 := 1 ;
    a := a->sort() ; 
    b := b->sort() ; 
    var k : int ; k := 1 ;
    var l : int ; l := 1 ;
    var x1 : int ; x1 := a[0+1] ;
    var y1 : int ; y1 := b[0+1] ;
        var i : int ; i := 1 ; while i < n / 2 do ( (     if (a[i+1] = a[i - 1+1]) then (     k := k + 1 ; 
     if (ans_a1 <= k) then (     ans_a2 := ans_a1 ; 
     ans_a1 := k ; 
     x1 := a[i - 1+1] ) else     if (ans_a2 <= k) then     ans_a2 := k ; else skip ; ) else     k := 1 ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n / 2 do ( (     if (b[i+1] = b[i - 1+1]) then (     l := l + 1 ; 
     if (ans_b1 <= l) then (     ans_b2 := ans_b1 ; 
     ans_b1 := l ; 
     y1 := b[i - 1+1] ) else     if (ans_b2 <= l) then     ans_b2 := l ; else skip ; ) else     l := 1 ; )  ;     i := i + 1 ) ; 
    var ans : int ; ans := n - (ans_a1 + ans_b1) ;
    if (ans_a1 = n / 2) then     ans_a2 := 0 ; else skip ; 
    if (ans_b1 = n / 2) then     ans_b2 := 0 ; else skip ; 
    if (x1 = y1) then     ans := Set{n - (ans_a1 + ans_b2), n - (ans_b1 + ans_a2)}->min() ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p120 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p120().run());
  }
  public String run(){
    int sum=0 ;
    for(int a=3 ; a<=1000 ; a++)sum+=a*(a-(a % 2==0 ? 2 : 1));
    return Integer.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
class p120 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p120.newp120().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var a : int ; a := 3 ; while a <= 1000 do (     sum := sum+(a * (a - (if a mod 2 = 0 then 2 else 1 endif))) ;  ;     a := a + 1 ) ; 
     return ((sum) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int count_carry(String a,String b){
    int carry=0 ;
    int count=0 ;
    int len_a=a.length(),len_b=b.length();
    while(len_a!=0 || len_b!=0){
      int x=0,y=0 ;
      if(len_a>0){
        x=a.charAt(len_a-1)-'0' ;
        len_a--;
      }
      if(len_b>0){
        y=b.charAt(len_b-1)-'0' ;
        len_b--;
      }
      int sum=x+y+carry ;
      if(sum>=10){
        carry=1 ;
        count++;
      }
      else carry=0 ;
    }
    return count ;
  }
  public static void main(String[] args){
    String a="9555",b="555" ;
    int count=count_carry(a,b);
    if(count==0)System.out.println("0\n");
    else if(count==1)System.out.println("1\n");
    else System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count_carry( a : String, b : String) : int
  pre: true
  post: true
  activity: (     var carry : int ; carry := 0 ;
     var count : int ; count := 0 ;
    var len_a : int ; len_a := a->size() ;
    var len_b : int ; len_b := b->size() ;
    while (len_a /= 0 or len_b /= 0) do (     var x : int ; x := 0 ;
    var y : int ; y := 0 ;
     if (len_a > 0) then (     x := a->at(len_a - 1+1) - ('0')->char2byte() ; 
     len_a := len_a - 1 ) else skip ; 
    if (len_b > 0) then (     y := b->at(len_b - 1+1) - ('0')->char2byte() ; 
     len_b := len_b - 1 ) else skip ; 
    var sum : int ; sum := x + y + carry ;
    if (sum >= 10) then (     carry := 1 ; 
     count := count + 1 ) else     carry := 0 ; ;  
 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ; a := "9555" ;
    var b : String ; b := "555" ;
     var count : int ; count := count_carry(a, b) ;
     if (count = 0) then     OclFile["System.out"].println("0\n") ; else     if (count = 1) then     OclFile["System.out"].println("1\n") else     OclFile["System.out"].println(count) ; ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void shortestDistance(String S,char X){
    int prev=Integer.MAX_VALUE ;
    Vector<Integer>ans=new Vector<>();
    for(int i=0 ; i<S.length(); i++){
      if(S.charAt(i)==X)prev=i ;
      ans.add(i-prev);
    }
    prev=Integer.MAX_VALUE ;
    for(int i=S.length()-1 ; i>=0 ; i--){
      if(S.charAt(i)==X)prev=i ;
      ans.set(i,Math.min(ans.get(i),prev-i));
    }
    for(Integer val : ans)System.out.print(val+" ");
  }
  public static void main(String[] args){
    String S="geeksforgeeks" ;
    char X='g' ;
    shortestDistance(S,X);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation shortestDistance( S : String, X : String) : void
  pre: true
  post: true
  activity: (     var prev : int ; prev := 2147483647 ;
     var ans : Sequence(int) ; ans := Sequence{} ;
        var i : int ; i := 0 ; while i < S->size() do ( (     if (S->at(i+1) = X) then     prev := i ; else skip ; 
     ans := ans->including(i - prev) )  ;     i := i + 1 ) ; 
    prev := 2147483647 ; 
        var i : int ; i := S->size() - 1 ; while i >= 0 do ( (     if (S->at(i+1) = X) then     prev := i ; else skip ; 
     ans := ans.setAt(i+1,Set{ans->at(i+1), prev - i}->min()) )  ;     i := i - 1 ) ; 
    for (val : ans) do (     OclFile["System.out"].print(val + " ") ;  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := "geeksforgeeks" ;
     var X : String ; X := 'g' ;
     execute shortestDistance(S, X) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int zz=0 ; zz<t ; zz++){
      int n=in.nextInt();
      int k=in.nextInt();
      int[] a=new int[n];
      ArrayList<Integer>f=new ArrayList<>();
      ArrayList<Integer>s=new ArrayList<>();
      boolean x=true ;
      for(int i=0 ; i<n ; i++){
        a[i]=i+1 ;
        if(i % 2!=0){
          if(((a[i]+k)*a[i-1])% 4==0){
            f.add(a[i]);
            s.add(a[i-1]);
          }
          else if(((a[i-1]+k)*a[i])% 4==0){
            f.add(a[(i-1)]);
            s.add(a[i]);
          }
          else {
            x=false ;
          }
        }
      }
      if(x){
        System.out.println("YES");
        for(int i=0 ; i<n/2 ; i++){
          System.out.println(f.get(i)+" "+s.get(i));
        }
      }
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var zz : int ; zz := 0 ; while zz < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var f : Sequence(int) ; f := Sequence{} ;
    var s : Sequence(int) ; s := Sequence{} ;
    var x : boolean ; x := true ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := i + 1 ; 
     if (i mod 2 /= 0) then (     if (((a[i+1] + k) * a[i - 1+1]) mod 4 = 0) then (     f := f->including(a[i+1]) ; 
     s := s->including(a[i - 1+1]) ) else     if (((a[i - 1+1] + k) * a[i+1]) mod 4 = 0) then (     f := f->including(a[(i - 1)+1]) ; 
     s := s->including(a[i+1]) ) else (     x := false ) ;  ) else skip )  ;     i := i + 1 ) ; 
    if (x) then (     OclFile["System.out"].println("YES") ; 
         var i : int ; i := 0 ; while i < n / 2 do ( (     OclFile["System.out"].println(f->at(i+1) + " " + s->at(i+1)) )  ;     i := i + 1 ) ) else     OclFile["System.out"].println("NO") ; ;  
 )  ;     zz := zz + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.ListIterator ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      final String input=sc.next();
      if("0.0".equals(input)){
        break ;
      }
      final double error=Double.parseDouble(input);
      final double upper_bound=Math.PI+error ;
      final double lower_bound=Math.PI-error ;
      for(int denom=1 ; ; denom++){
        int lower=(int)(Math.ceil(lower_bound*denom));
        int upper=(int)(upper_bound*denom);
        final double denom_d=(double)denom ;
        final double low_d=lower/denom_d ;
        final double high_d=upper/denom_d ;
        if(upper_bound>=low_d && low_d>=lower_bound){
          System.out.println(lower+"/"+denom);
          break ;
        }
        else if(upper_bound>=high_d && high_d>=upper_bound){
          System.out.println(upper+"/"+denom);
          break ;
        }
      }
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var input : String ; input := sc.getCurrent() ;
     if ("0.0" = input) then (     break ) else skip ; 
    var error : double ; error := (input)->toReal() ;
    var upper_bound : double ; upper_bound := 3.141592653589793 + error ;
    var lower_bound : double ; lower_bound := 3.141592653589793 - (error)->char2byte() ;
        var denom : int ; denom := 1 ; while true do ( (     var lower : int ; lower := ((lower_bound * denom)->ceil())->oclAsType(int) ;
     var upper : int ; upper := (upper_bound * denom)->oclAsType(int) ;
    var denom_d : double ; denom_d := denom->oclAsType(double) ;
    var low_d : double ; low_d := lower / denom_d ;
    var high_d : double ; high_d := upper / denom_d ;
    if (upper_bound >= low_d & low_d >= lower_bound) then (     OclFile["System.out"].println(lower + "/" + denom) ; 
     break ) else     if (upper_bound >= high_d & high_d >= upper_bound) then (     OclFile["System.out"].println(upper + "/" + denom) ; 
     break ) else skip ; ;  
 )  ;     denom := denom + 1 ) ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_Panoramix_s_Prediction {
  public static void main(String[] args){
    Scanner sn=new Scanner(System.in);
    int a=sn.nextInt();
    int b=sn.nextInt();
    int count=0 ;
    boolean flag=false ;
    ;
    if(isPrime(a)&& isPrime(b))flag=true ;
    for(int i=a ; i<=b ; i++){
      if(isPrime(i))count++;
    }
    if(count==2 && flag==true)System.out.println("YES");
    else System.out.println("NO");
  }
  public static boolean isPrime(int n){
    if(n<=1)return false ;
    else if(n==2)return true ;
    else if(n % 2==0)return false ;
    for(int i=3 ; i<=Math.sqrt(n); i+=2){
      if(n % i==0)return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Panoramix_s_Prediction {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sn : OclFile ; sn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sn.getCurrent()->toInteger() ;
    var b : int ; b := sn.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var flag : boolean ; flag := false ;
    if (isPrime(a) & isPrime(b)) then     flag := true ; else skip ; 
        var i : int ; i := a ; while i <= b do ( (     if (isPrime(i)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (count = 2 & flag = true) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else     if (n = 2) then     return true else     if (n mod 2 = 0) then     return false else skip ; ;  ;  
         var i : int ; i := 3 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then     return false else skip )  ;     i := i+(2) ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class code {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int temp=0,flag=1,t=0 ;
    for(int i=2 ; i<51 ; i++){
      flag=1 ;
      for(int j=2 ; j<=i/2 ; j++){
        if(i % j==0){
          flag=0 ;
          break ;
        }
      }
      if(flag==1 && i>n){
        if(temp==0)temp=i ;
        if(i==m && temp==i){
          t=1 ;
          break ;
        }
      }
    }
    if(t==1)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var temp : int ; temp := 0 ;
    var flag : int ; flag := 1 ;
    var t : int ; t := 0 ;
        var i : int ; i := 2 ; while i < 51 do ( (     flag := 1 ; 
         var j : int ; j := 2 ; while j <= i / 2 do ( (     if (i mod j = 0) then (     flag := 0 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (flag = 1 & i > n) then (     if (temp = 0) then     temp := i ; else skip ; 
     if (i = m & temp = i) then (     t := 1 ; 
     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (t = 1) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A80 {
  static Scanner sc=new Scanner();
  public static void main(String[] args){
    solve();
  }
  public static void solve(){
    int n=sc.nextInt(),m=sc.nextInt();
    int i=n ;
    while(true){
      int cnt=0 ;
      i++;
      for(int k=2 ; k<i ; k++){
        if(i % k==0){
          cnt++;
        }
      }
      if(cnt==0){
        break ;
      }
    }
    System.out.print((i==m)? "YES" : "NO");
  }
  static class Scanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A80 {
  static   attribute sc : OclFile := (arguments ( ));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
     var i : int ; i := n ;
     while (true) do (     var cnt : int ; cnt := 0 ;
     i := i + 1 ; 
         var k : int ; k := 2 ; while k < i do ( (     if (i mod k = 0) then (     cnt := cnt + 1 ) else skip )  ;     k := k + 1 ) ; 
     if (cnt = 0) then (     break ) else skip ) ; 
     OclFile["System.out"].print(if (i = m) then "YES" else "NO" endif) );
  static class Scanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    char[] c=s.toCharArray();
    char temp=' ' ;
    int count1=0 ;
    int count2=0 ;
    for(int i=0 ; i<n ; i++){
      if(c[i]!=temp){
        count2++;
        if(count2==2){
          count1++;
          count2=0 ;
          temp=' ' ;
        }
        else temp=c[i];
      }
    }
    System.out.println(count1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var c : Sequence(String) ; c := s->characters() ;
    var temp : String ; temp := ' ' ;
    var count1 : int ; count1 := 0 ;
    var count2 : int ; count2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (c[i+1] /= temp) then (     count2 := count2 + 1 ; 
     if (count2 = 2) then (     count1 := count1 + 1 ; 
     count2 := 0 ; 
     temp := ' ' ) else     temp := c[i+1] ; ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] f1=new int[100001];
    int[] f2=new int[100001];
    int[] arr=new int[n];
    StringBuffer sb=new StringBuffer();
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      if(i % 2==0)f1[arr[i] ]++;
      else f2[arr[i] ]++;
    }
    int l11=0,l12=0,l21=0,l22=0 ;
    int i11=0,i12=0,i21=0,i22=0 ;
    for(int i=0 ; i<=100000 ; i++){
      if(f1[i]>=l11){
        l11=f1[i];
        i11=i ;
      }
      if(f2[i]>=l21){
        l21=f2[i];
        i21=i ;
      }
    }
    for(int i=0 ; i<=100000 ; i++){
      if(i!=i11){
        if(f1[i]>=l12){
          l12=f1[i];
          i12=i ;
        }
      }
      if(i!=i21){
        if(f2[i]>=l22){
          l22=f2[i];
          i22=i ;
        }
      }
    }
    if(i11!=i21)System.out.println(n/2-l11+n/2-l21);
    else {
      int x=Math.max(l11+l22,l12+l21);
      System.out.println(n-x);
    }
  }
  static boolean check(int n){
    int x=n % 10 ;
    n/=10 ;
    if(n % 10!=x)return false ;
    n/=10 ;
    if(n % 10!=x)return false ;
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var f1 : Sequence(int) ; f1 := Integer.subrange(1,100001)->collect(0) ;
    var f2 : Sequence(int) ; f2 := Integer.subrange(1,100001)->collect(0) ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (i mod 2 = 0) then     f1[arr[i+1]+1] := f1[arr[i+1]+1] + 1 ; else     f2[arr[i+1]+1] := f2[arr[i+1]+1] + 1 ; )  ;     i := i + 1 ) ; 
    var l11 : int ; l11 := 0 ;
    var l12 : int ; l12 := 0 ;
    var l21 : int ; l21 := 0 ;
    var l22 : int ; l22 := 0 ;
    var i11 : int ; i11 := 0 ;
    var i12 : int ; i12 := 0 ;
    var i21 : int ; i21 := 0 ;
    var i22 : int ; i22 := 0 ;
        var i : int ; i := 0 ; while i <= 100000 do ( (     if (f1[i+1] >= l11) then (     l11 := f1[i+1] ; 
     i11 := i ) else skip ; 
     if (f2[i+1] >= l21) then (     l21 := f2[i+1] ; 
     i21 := i ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= 100000 do ( (     if (i /= i11) then (     if (f1[i+1] >= l12) then (     l12 := f1[i+1] ; 
     i12 := i ) else skip ) else skip ; 
     if (i /= i21) then (     if (f2[i+1] >= l22) then (     l22 := f2[i+1] ; 
     i22 := i ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (i11 /= i21) then     OclFile["System.out"].println(n / 2 - l11 + n / 2 - l21) else (     var x : int ; x := Set{l11 + l22, l12 + l21}->max() ;
     OclFile["System.out"].println(n - x) ) ;  
 );
  static   operation check( n : int) : boolean
  pre: true
  post: true
  activity: (     var x : int ; x := n mod 10 ;
     n := n/(10) ; 
    if (n mod 10 /= x) then     return false else skip ; 
    n := n/(10) ; 
    if (n mod 10 /= x) then     return false else skip ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    String S=sc.next();
    List<Character>list=new ArrayList<Character>();
    char[] C=S.toCharArray();
    for(int i=0 ; i<N ; i++){
      list.add(C[i]);
    }
    int count=0 ;
    for(int i=0 ; i<N-1 ; i++){
      if(!(list.get(i).equals(list.get(i+1)))){
        count++;
        i++;
      }
    }
    System.out.println(count);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var S : String ; S := sc.getCurrent() ;
    var list : Sequence(String) ; list := Sequence{} ;
    var C : Sequence(String) ; C := S->characters() ;
        var i : int ; i := 0 ; while i < N do ( (     list := list->including(C[i+1]) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     if (not((list->at(i+1) = list->at(i + 1+1)))) then (     count := count + 1 ; 
     i := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int count=0 ;
    try {
      String N=br.readLine();
      int n=Integer.parseInt(N);
      String ox=br.readLine();
      String[] o_x=ox.split("");
      for(int i=0 ; i<ox.length(); i++){
        if(i==n-1){
          continue ;
        }
        if(ox.charAt(i)!=ox.charAt(i+1)){
          count++;
          i++;
        }
        else {
        }
      }
      System.out.println(count);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var count : int ; count := 0 ;
     try (     var N : String ; N := br.readLine() ;
     var n : int ; n := (N)->toInteger() ;
    var ox : String ; ox := br.readLine() ;
    var o_x : Sequence(String) ; o_x := ox->split("") ;
        var i : int ; i := 0 ; while i < ox->size() do ( (     if (i = (n)->char2byte() - 1) then (     continue ) else skip ; 
     if (ox->at(i+1) /= ox->at(i + 1+1)) then (     count := count + 1 ; 
     i := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char stmp[]=new char[n];
    String str=sc.next();
    int count=0 ;
    for(int i=0 ; i<n ; i++)stmp[i]=str.charAt(i);
    char lastc=stmp[0];
    for(int i=1 ; i<n ; i++){
      if(i==n-1 && stmp[i]!=lastc)count++;
      else if(stmp[i]!=lastc){
        count++;
        lastc=stmp[i+1];
        i++;
      }
      else lastc=stmp[i];
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var stmp : Sequence(String) ; stmp := Integer.subrange(1,n)->collect(0) ;
    var str : String ; str := sc.getCurrent() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do (     stmp[i+1] := str->at(i+1) ;  ;     i := i + 1 ) ; 
    var lastc : String ; lastc := stmp[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     if (i = n - 1 & stmp[i+1] /= lastc) then     count := count + 1 ; else     if (stmp[i+1] /= lastc) then (     count := count + 1 ; 
     lastc := stmp[i + 1+1] ; 
     i := i + 1 ) else     lastc := stmp[i+1] ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,m,r ;
    n=sc.nextInt();
    m=sc.nextInt();
    r=sc.nextInt();
    if(r-n*m<0){
      System.out.println("0");
      return ;
    }
    BigInteger ZERO=BigInteger.ZERO ;
    BigInteger ONE=BigInteger.ONE ;
    BigInteger b=ONE,k ;
    BigInteger lb=new BigInteger(Integer.toString(r-n*m));
    k=new BigInteger(Integer.toString(r-n*m+n-1));
    while(k.compareTo(lb)>0){
      b=b.multiply(k);
      k=k.subtract(ONE);
    }
    k=new BigInteger(Integer.toString(n-1));
    while(k.compareTo(ZERO)>0){
      b=b.divide(k);
      k=k.subtract(ONE);
    }
    System.out.println(b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var m : int ;
    var r : int ;
    n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
    r := sc.getCurrent()->toInteger() ; 
    if (r - n * m < 0) then (     OclFile["System.out"].println("0") ; 
     return ) else skip ; 
    var ZERO : long ; ZERO := 0 ;
    var ONE : long ; ONE := 1 ;
    var b : long ; b := ONE ;
    var k : long ;
    var lb : long ; lb := long(((r - n * m) + "")) ;
    k := long(((r - n * m + n - 1) + "")) ; 
    while (k->compareTo(lb) > 0) do (     b := b.multiply(k) ; 
     k := k.subtract(ONE) ) ; 
    k := long(((n - 1) + "")) ; 
    while (k->compareTo(ZERO) > 0) do (     b := b.divide(k) ; 
     k := k.subtract(ONE) ) ; 
    OclFile["System.out"].println(b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
public class Main {
  public static final int BIG_NUM=2000000000 ;
  public static final int MOD=1000000007 ;
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String input_str[]=new String[3];
      input_str=br.readLine().split("\\s+");
      int N=Integer.parseInt(input_str[0]);
      int M=Integer.parseInt(input_str[1]);
      int R=Integer.parseInt(input_str[2]);
      if(N*M>R){
        System.out.println(0);
        return ;
      }
      int num=R-M*N+N-1 ;
      int[] bunbo=new int[N];
      for(int i=0 ; i<N-1 ; i++){
        bunbo[i]=num-i ;
      }
      int tmp,common ;
      for(int i=N-1 ; i>=2 ; i--){
        tmp=i ;
        for(int k=0 ; k<N-1 ; k++){
          if(bunbo[k]==1)continue ;
          common=gcd(tmp,bunbo[k]);
          if(common==1)continue ;
          tmp/=common ;
          bunbo[k]/=common ;
          if(tmp==1)break ;
        }
      }
      BigInteger ANS=new BigInteger("1");
      for(int i=0 ; i<N-1 ; i++){
        ANS=ANS.multiply(new BigInteger(Integer.toString(bunbo[i])));
      }
      System.out.println(ANS.toString());
    }
    catch(NumberFormatException e){
      e.printStackTrace();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  public static int gcd(int A,int B){
    if(A<B){
      int tmp=B ;
      B=A ;
      A=tmp ;
    }
    if(B==0){
      return A ;
    }
    else {
      return gcd(B,A % B);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BIG_NUM : int := 2000000000;
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var input_str : Sequence(String) ; input_str := Integer.subrange(1,3)->collect(null) ;
     input_str := br.readLine()->split("\\s+") ; 
    var N : int ; N := (input_str[0+1])->toInteger() ;
    var M : int ; M := (input_str[1+1])->toInteger() ;
    var R : int ; R := (input_str[2+1])->toInteger() ;
    if (N * M > R) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var num : int ; num := R - M * N + N - 1 ;
    var bunbo : Sequence(int) ; bunbo := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < (N)->char2byte() - 1 do ( (     bunbo[i+1] := num - i )  ;     i := i + 1 ) ; 
    var tmp : int ;
    var common : int ;
        var i : int ; i := (N)->char2byte() - 1 ; while i >= 2 do ( (     tmp := i ; 
         var k : int ; k := 0 ; while k < (N)->char2byte() - 1 do ( (     if (bunbo[k+1] = 1) then     continue else skip ; 
     common := gcd(tmp, bunbo[k+1]) ; 
    if (common = 1) then     continue else skip ; 
    tmp := tmp/(common) ; 
    bunbo[k+1] := bunbo[k+1]/(common) ; 
    if (tmp = 1) then     break else skip ; 
 )  ;     k := k + 1 ) )  ;     i := i - 1 ) ; 
    var ANS : long ; ANS := long("1") ;
        var i : int ; i := 0 ; while i < (N)->char2byte() - 1 do ( (     ANS := ANS.multiply(long(((bunbo[i+1]) + ""))) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ANS+"") ; 
 )   catch (e : IncorrectElementException) do (     e.printStackTrace() )
   catch (e : IOException) do (     e.printStackTrace() )
 );
  static   operation gcd( A : int, B : int) : int
  pre: true
  post: true
  activity: (     if (A < B) then (     var tmp : int ; tmp := B ;
     B := A ; 
     A := tmp ) else skip ; 
     if (B = 0) then (     return A ) else (     return gcd(B, A mod B) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.math.BigDecimal ;
class Main {
  static String permutation(int x,int y,int z){
    if(z>y){
      int tmp=y ;
      y=z ;
      z=tmp ;
    }
    BigDecimal result=BigDecimal.ONE ;
    int counter=1 ;
    for(int i=y+1 ; i<=x ; i++){
      result=result.multiply(new BigDecimal(String.valueOf(i)));
      if(counter<=z){
        result=result.divide(new BigDecimal(String.valueOf(counter)));
        counter++;
      }
    }
    for(int i=counter ; i<=z ; i++){
      result=result.divide(new BigDecimal(String.valueOf(counter)));
    }
    return result.toString();
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] input=br.readLine().split(" ");
    int n=Integer.parseInt(input[0]);
    int m=Integer.parseInt(input[1]);
    int r=Integer.parseInt(input[2]);
    int nm=n*m ;
    if(r<nm){
      System.out.println("0");
      return ;
    }
    int beads=r-nm ;
    System.out.println(permutation(beads+n-1,beads,n-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation permutation( x : int, y : int, z : int) : String
  pre: true
  post: true
  activity: (     if (z > y) then (     var tmp : int ; tmp := y ;
     y := z ; 
     z := tmp ) else skip ; 
     var result : double ; result := 1.0 ;
    var counter : int ; counter := 1 ;
        var i : int ; i := y + 1 ; while i <= x do ( (     result := result.multiply(double(((i) + ""))) ; 
     if (counter <= z) then (     result := result.divide(double(((counter) + ""))) ; 
     counter := counter + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := counter ; while i <= z do ( (     result := result.divide(double(((counter) + ""))) )  ;     i := i + 1 ) ; 
    return result+"" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : Sequence(String) ; input := br.readLine()->split(" ") ;
    var n : int ; n := (input[0+1])->toInteger() ;
    var m : int ; m := (input[1+1])->toInteger() ;
    var r : int ; r := (input[2+1])->toInteger() ;
    var nm : int ; nm := n * m ;
    if (r < nm) then (     OclFile["System.out"].println("0") ; 
     return ) else skip ; 
    var beads : int ; beads := r - nm ;
    OclFile["System.out"].println(permutation(beads + n - 1, beads, n - 1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.PrintWriter ;
import java.math.BigInteger ;
class Main {
  void solve(){
    int N=cin.nextInt();
    int M=cin.nextInt();
    int R=cin.nextInt();
    if(N*M>R){
      cout.println(0);
      return ;
    }
    int RR=R-N*M ;
    BigInteger ans=new BigInteger("1");
    for(int i=2 ; i<=RR+N-1 ; i++){
      ans=ans.multiply(new BigInteger(""+i));
    }
    for(int i=2 ; i<=RR ; i++){
      ans=ans.divide(new BigInteger(""+i));
    }
    for(int i=2 ; i<=N-1 ; i++){
      ans=ans.divide(new BigInteger(""+i));
    }
    cout.println(ans);
  }
  public static void main(String args[]){
    cin=new Inputer();
    cout=new PrintWriter(System.out);
    new Main().solve();
    cout.flush();
  }
  static class Inputer {
    private static Scanner sc ;
    Inputer(){
      sc=new Scanner(System.in);
    }
    String next(){
      return sc.next();
    }
    int nextInt(){
      return Integer.parseInt(sc.next());
    }
    long nextLong(){
      return Long.parseLong(sc.next());
    }
    double nextDouble(){
      return Double.parseDouble(sc.next());
    }
    char[] nextCharArray(){
      return sc.next().toCharArray();
    }
  }
  private static Inputer cin ;
  private static PrintWriter cout ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : int ; N := cin.nextInt() ;
     var M : int ; M := cin.nextInt() ;
    var R : int ; R := cin.nextInt() ;
    if (N * M > R) then (     cout.println(0) ; 
     return ) else skip ; 
    var RR : int ; RR := R - N * M ;
    var ans : long ; ans := long("1") ;
        var i : int ; i := 2 ; while i <= RR + N - 1 do ( (     ans := ans.multiply(long("" + i)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= RR do ( (     ans := ans.divide(long("" + i)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= N - 1 do ( (     ans := ans.divide(long("" + i)) )  ;     i := i + 1 ) ; 
    cout.println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     cin := Inputer.newInputer() ; 
     cout := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     Main.newMain().solve() ; 
     cout.flush() );
  static class Inputer {
  static   attribute sc : OclFile;
   static operation newInputer() : Inputer
  pre: true
  post: true
  activity:
  ( var self : Inputer ;
    self := createInputer();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation next() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (sc.getCurrent())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (sc.getCurrent())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (sc.getCurrent())->toReal() );
   operation nextCharArray() : Sequence(String)
  pre: true
  post: true
  activity: (     return sc.getCurrent()->characters() );
}
  static   attribute cin : Inputer;
  static   attribute cout : OclFile;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      while(scanner.hasNextLine()){
        String[] tmp=scanner.nextLine().split(" ");
        int n=Integer.valueOf(tmp[0]);
        int m=Integer.valueOf(tmp[1]);
        int r=Integer.valueOf(tmp[2]);
        System.out.println(solver(n,m,r));
      }
    }
  }
  private static BigInteger solver(int n,int m,int r){
    if(n*m>r){
      return new BigInteger("0");
    }
    if(n*m==r){
      return new BigInteger("1");
    }
    return hcombination(n,r-(n*m));
  }
  private static BigInteger hcombination(int n,int r){
    BigInteger fact_a=fact(n+r-1);
    BigInteger fact_b=fact(r);
    BigInteger fact_c=fact(n-1);
    return fact_a.divide(fact_b.multiply(fact_c));
  }
  private static BigInteger fact(int n){
    BigInteger ans=new BigInteger("1");
    for(int i=n ; i>1 ; i--){
      ans=ans.multiply(new BigInteger(String.valueOf(i)));
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (scanner.hasNextLine()) do (     var tmp : Sequence(String) ; tmp := scanner.nextLine()->split(" ") ;
     var n : int ; n := (tmp[0+1])->toInteger() ;
    var m : int ; m := (tmp[1+1])->toInteger() ;
    var r : int ; r := (tmp[2+1])->toInteger() ;
    OclFile["System.out"].println(solver(n, m, r)) ; 
 ) ))  );
  static   operation solver( n : int, m : int, r : int) : long
  pre: true
  post: true
  activity: (     if (n * m > r) then (     return long("0") ) else skip ; 
     if (n * m = r) then (     return long("1") ) else skip ; 
     return hcombination(n, r - (n * m)) );
  static   operation hcombination( n : int, r : int) : long
  pre: true
  post: true
  activity: (     var fact_a : long ; fact_a := fact(n + r - 1) ;
     var fact_b : long ; fact_b := fact(r) ;
     var fact_c : long ; fact_c := fact(n - 1) ;
     return fact_a.divide(fact_b.multiply(fact_c)) );
  static   operation fact( n : int) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := long("1") ;
         var i : int ; i := n ; while i > 1 do ( (     ans := ans.multiply(long(((i) + ""))) )  ;     i := i - 1 ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static void SubString(String str,int n){
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<=n ; j++)System.out.println(str.substring(i,j));
  }
  public static void main(String[] args){
    String str="abcd" ;
    SubString(str,str.length());
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation SubString( str : String, n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j <= n do (     OclFile["System.out"].println(str.subrange(i+1,j)) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abcd" ;
     execute SubString(str, str->size()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX_INT=1000000 ;
  static int solve(int[] array,int N){
    int[][] pos=new int[5][10000];
    int[] pref=new int[5];
    if(array[0]==0){
      pref[0]=1 ;
      pos[0][pos[0] .length-1]=0 ;
    }
    int ans=MAX_INT ;
    for(int i=1 ; i<N ; i++){
      if(array[i]==0){
        pref[0]++;
        pos[0][pos[0] .length-1]=i ;
      }
      else {
        if(pref[array[i]-1]>0){
          pref[array[i] ]++;
          pos[array[i] ][pos[array[i] ] .length-1]=i ;
          if(array[i]==4){
            int end=i ;
            int start=i ;
            for(int j=3 ; j>=0 ; j--){
              int s=0 ;
              int e=pos[j] .length-1 ;
              int temp=-1 ;
              while(s<=e){
                int m=(s+e)/2 ;
                if(pos[j][m]<=start){
                  temp=pos[j][m];
                  s=m+1 ;
                }
                else e=m-1 ;
              }
              start=temp ;
            }
            ans=Math.min(ans,end-start+1);
          }
        }
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int[] array={
      0,1,2,3,4,2,0,3,4 };
      int N=array.length ;
      System.out.println(solve(array,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX_INT : int := 1000000;
  static   operation solve( array : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var pos : Sequence(Sequence(int)) ; pos := Integer.subrange(1,5)->collect(Integer.subrange(1,10000)->collect(0)) ;
     var pref : Sequence(int) ; pref := Integer.subrange(1,5)->collect(0) ;
    if (array[0+1] = 0) then (     pref[0+1] := 1 ; 
     pos[0+1][pos[0+1]->size() - 1+1] := 0 ) else skip ; 
    var ans : int ; ans := MAX_INT ;
        var i : int ; i := 1 ; while i < N do ( (     if (array[i+1] = 0) then (     pref[0+1] := pref[0+1] + 1 ; 
     pos[0+1][pos[0+1]->size() - 1+1] := i ) else (     if (pref[array[i+1] - 1+1] > 0) then (     pref[array[i+1]+1] := pref[array[i+1]+1] + 1 ; 
     pos[array[i+1]+1][pos[array[i+1]+1]->size() - 1+1] := i ; 
     if (array[i+1] = 4) then (     var end : int ; end := i ;
     var start : int ; start := i ;
         var j : int ; j := 3 ; while j >= 0 do ( (     var s : int ; s := 0 ;
     var e : int ; e := pos[j+1]->size() - 1 ;
    var temp : int ; temp := -1 ;
    while (s <= e) do (     var m : int ; m := (s + e) / 2 ;
     if (pos[j+1][m+1] <= start) then (     temp := pos[j+1][m+1] ; 
     s := m + 1 ) else     e := m - 1 ; ) ; 
    start := temp ; 
 )  ;     j := j - 1 ) ; 
     ans := Set{ans, end - start + 1}->min() ) else skip ) else skip ) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Sequence{0,1,2,3,4,2,0,3,4} ;
     var N : int ; N := array->size() ;
     OclFile["System.out"].println(solve(array, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void perfectSquares(int l,int r){
    for(int i=l ; i<=r ; i++){
      if(Math.sqrt(i)==(int)Math.sqrt(i))System.out.print(i+" ");
    }
  }
  public static void main(String[] args){
    int l=2,r=24 ;
    perfectSquares(l,r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation perfectSquares( l : int, r : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := l ; while i <= r do ( (     if ((i)->sqrt() = (i)->sqrt()->oclAsType(int)) then     OclFile["System.out"].print(i + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 2 ;
    var r : int ; r := 24 ;
     execute perfectSquares(l, r) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void solve(long a,long b){
    if(a>0 && b>0){
      System.out.println("Positive");
    }
    else if(a<=0 && b>=0){
      System.out.println("Zero");
    }
    else {
      long n=Math.abs(a-b)+1 ;
      if(n % 2==0){
        System.out.println("Positive");
      }
      else {
        System.out.println("Negative");
      }
    }
  }
  public static void main(String[] args){
    int a=-10,b=-2 ;
    solve(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( a : long, b : long) : void
  pre: true
  post: true
  activity: (     if (a > 0 & b > 0) then (     OclFile["System.out"].println("Positive") ) else     if (a <= 0 & b >= 0) then (     OclFile["System.out"].println("Zero") ) else (     var n : long ; n := if a - b < 0 then -(a - b) else a - b endif + 1 ;
     if (n mod 2 = 0) then (     OclFile["System.out"].println("Positive") ) else (     OclFile["System.out"].println("Negative") ) ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := -10 ;
    var b : int ; b := -2 ;
     execute solve(a, b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Solution {
  public static void main(String[] args)throws IOException {
    BufferedReader bufferReader=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    StringTokenizer st=new StringTokenizer(bufferReader.readLine());
    int n=Integer.parseInt(st.nextToken());
    int max=0 ;
    Map<Integer,Set<Integer>>map=new HashMap<>();
    Map<Integer,Integer>lastIndex=new HashMap<>();
    List<int[]>ans=new ArrayList<>();
    st=new StringTokenizer(bufferReader.readLine());
    for(int i=1 ; i<=n ; i++){
      int cur=Integer.parseInt(st.nextToken());
      max=Math.max(max,cur);
      if(! map.containsKey(cur)){
        map.put(cur,new HashSet<>());
      }
      else {
        Set<Integer>indexes=map.get(cur);
        indexes.add(i-lastIndex.get(cur));
      }
      lastIndex.put(cur,i);
    }
    for(int i=1 ; i<=max ; i++){
      if(map.containsKey(i)&& map.get(i).size()<=1){
        ans.add(new int[] {
          i,map.get(i).size()==0 ? 0 : map.get(i).iterator().next()}
);
        }
      }
      out.println(ans.size());
      for(int[] cur : ans)out.println(cur[0]+" "+cur[1]);
      out.flush();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bufferReader : OclFile ; bufferReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(bufferReader.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var max : int ; max := 0 ;
    var map : Map(int,Set(int)) ; map := Map{} ;
    var lastIndex : Map(int,int) ; lastIndex := Map{} ;
    var ans : Sequence(Sequence(int)) ; ans := Sequence{} ;
    st := OclIterator.newOclIterator_String(bufferReader.readLine()) ; 
        var i : int ; i := 1 ; while i <= n do ( (     var cur : int ; cur := (st.next())->toInteger() ;
     max := Set{max, cur}->max() ; 
     if (not(map->keys()->includes(cur))) then (     map := map->union(Map{cur |-> Set{}}) ) else (     var indexes : Set(int) ; indexes := map->at(cur) ;
     indexes := indexes->including(i - lastIndex->at(cur)) ) ;  
     lastIndex := lastIndex->union(Map{cur |-> i}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= max do ( (     if (map->keys()->includes(i) & map->at(i)->size() <= 1) then (     ans := ans->including(Sequence{i,if map->at(i)->size() = 0 then 0 else map->at(i)->iterator().next() endif}) ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    for (cur : ans) do (     skip ;  ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void solve(String s){
    String z=s ;
    int l=s.length();
    int i ;
    String str ;
    if(s.indexOf('+')!=-1){
      i=s.indexOf('+');
      str=s.replace('+','-');
    }
    else {
      i=s.indexOf('-');
      str=s.replace('-','+');
    }
    System.out.println("Conjugate of "+z+"="+str);
  }
  public static void main(String[] args){
    String s="3-4i" ;
    solve(s);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( s : String) : void
  pre: true
  post: true
  activity: (     var z : String ; z := s ;
     var l : int ; l := s->size() ;
    var i : int ;
    var str : String ;
    if (s->indexOf('+')-1 /= -1) then (     i := s->indexOf('+')-1 ; 
     str := s.replace('+', '-') ) else (     i := s->indexOf('-')-1 ; 
     str := s.replace('-', '+') ) ;  
    OclFile["System.out"].println("Conjugate of " + z + "=" + str) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "3-4i" ;
     execute solve(s) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  public static void main(String[] args){
    Scanner kali=new Scanner(System.in);
    String lucky_num=kali.next();
    int count=0 ;
    for(int i=0 ; i<lucky_num.length(); i++){
      if(lucky_num.charAt(i)=='4' || lucky_num.charAt(i)=='7'){
        count++;
      }
    }
    String temp=count+"" ;
    if(temp.contains("4")|| temp.contains("7")){
      System.out.println("YES");
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var kali : OclFile ; kali := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var lucky_num : String ; lucky_num := kali.getCurrent() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < lucky_num->size() do ( (     if (lucky_num->at(i+1) = '4' or lucky_num->at(i+1) = '7') then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    var temp : String ; temp := count + "" ;
    if (temp->includes("4") or temp->includes("7")) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Codesolver {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n ;
    n=sc.nextLong();
    long carry=0 ;
    int sum=0 ;
    while(n!=0){
      carry=n % 10 ;
      if(carry==4 || carry==7){
        sum++;
      }
      n=n/10 ;
    }
    System.out.println((sum==7 || sum==4)? "YES" : "NO");
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codesolver {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ;
    n := sc.getCurrent()->toLong() ; 
    var carry : long ; carry := 0 ;
    var sum : int ; sum := 0 ;
    while (n /= 0) do (     carry := n mod 10 ; 
     if (carry = 4 or carry = 7) then (     sum := sum + 1 ) else skip ; 
     n := n / 10 ) ; 
    OclFile["System.out"].println(if (sum = 7 or sum = 4) then "YES" else "NO" endif) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    double EPS=1e-10 ;
    for(; ; ){
      double R=sc.nextDouble();
      if(R==0)break ;
      int n=1,d=1 ;
      double min=1<<29 ;
      int an=0,ad=1<<29 ;
      while(d<=ad){
        double r=Math.PI-n*1.0/d ;
        double e=Math.abs(r);
        if(e<R+EPS && e<min){
          min=e ;
          an=n ;
          ad=d ;
        }
        if(r<0)d++;
        else n++;
      }
      System.out.println(an+"/"+ad);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var EPS : double ; EPS := 1e-10 ;
       while true do ( (     var R : double ; R := sc.getCurrent()->toReal() ;
     if (R = 0) then     break else skip ; 
    var n : int ; n := 1 ;
    var d : int ; d := 1 ;
    var min : double ; min := (1*(2->pow(29)))->oclAsType(long) ;
    var an : int ; an := 0 ;
    var ad : int ; ad := (1*(2->pow(29)))->oclAsType(long) ;
    while (d <= ad) do (     var r : double ; r := 3.141592653589793 - n * 1.0 / d ;
     var e : double ; e := if r < 0 then -(r) else r endif ;
     if (e < R + EPS & e < min) then (     min := e ; 
     an := n ; 
     ad := d ) else skip ; 
     if (r < 0) then     d := d + 1 ; else     n := n + 1 ; ) ; 
    OclFile["System.out"].println(an + "/" + ad) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Code_110A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int count=0 ;
    long n=sc.nextLong();
    while(n!=0){
      int temp=(int)(n % 10);
      if(temp==4 || temp==7)count++;
      n/=10 ;
    }
    System.out.println((count==4 || count==7)? "YES" : "NO");
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code_110A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := 0 ;
    var n : long ; n := sc.getCurrent()->toLong() ;
    while (n /= 0) do (     var temp : int ; temp := (n mod 10)->oclAsType(int) ;
     if (temp = 4 or temp = 7) then     count := count + 1 ; else skip ; 
     n := n/(10) ) ; 
    OclFile["System.out"].println(if (count = 4 or count = 7) then "YES" else "NO" endif) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args)throws Exception {
    FastReader sc=new FastReader();
    long n=sc.nextLong();
    boolean flag=true ;
    int cnt=0 ;
    while(n!=0){
      long res=n % 10 ;
      if(res==4 || res==7)cnt++;
      n=n/10 ;
    }
    if(cnt==0)flag=false ;
    while(cnt!=0){
      int res=cnt % 10 ;
      if(!(res==4 || res==7)){
        flag=false ;
        break ;
      }
      cnt=cnt/10 ;
    }
    if(flag)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : long ; n := sc.nextLong() ;
    var flag : boolean ; flag := true ;
    var cnt : int ; cnt := 0 ;
    while (n /= 0) do (     var res : long ; res := n mod 10 ;
     if (res = 4 or res = 7) then     cnt := cnt + 1 ; else skip ; 
     n := n / 10 ) ; 
    if (cnt = 0) then     flag := false ; else skip ; 
    while (cnt /= 0) do (     var res : int ; res := cnt mod 10 ;
     if (not((res = 4 or res = 7))) then (     flag := false ; 
     break ) else skip ; 
     cnt := cnt / 10 ) ; 
    if (flag) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPrime(int n){
    if(n<=1)return false ;
    for(int i=2 ; i<n ; i++){
      if(n % i==0)return false ;
    }
    return true ;
  }
  static void countPrimePosition(int arr[]){
    int c0=0,c1=0 ;
    int n=arr.length ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==0 && isPrime(i))c0++;
      if(arr[i]==1 && isPrime(i))c1++;
    }
    System.out.println("Number of 0s="+c0);
    System.out.println("Number of 1s="+c1);
  }
  public static void main(String[] args){
    int[] arr={
      1,0,1,0,1 };
      countPrimePosition(arr);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
         var i : int ; i := 2 ; while i < n do ( (     if (n mod i = 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation countPrimePosition( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var c0 : int ; c0 := 0 ;
    var c1 : int ; c1 := 0 ;
     var n : int ; n := arr->size() ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 0 & isPrime(i)) then     c0 := c0 + 1 ; else skip ; 
     if (arr[i+1] = 1 & isPrime(i)) then     c1 := c1 + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Number of 0s=" + c0) ; 
    OclFile["System.out"].println("Number of 1s=" + c1) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,0,1,0,1} ;
     execute countPrimePosition(arr) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class broo {
  public static void main(String[] args){
    Scanner real=new Scanner(System.in);
    String a=real.nextLine();
    int count=0 ;
    for(int i=0 ; i<a.length(); i++){
      if(a.charAt(i)=='7' || a.charAt(i)=='4'){
        count++;
      }
    }
    if(count==7 || count==4){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class broo {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var real : OclFile ; real := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := real.nextLine() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < a->size() do ( (     if (a->at(i+1) = '7' or a->at(i+1) = '4') then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (count = 7 or count = 4) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B965 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int K=in.nextInt();
    boolean[][] grid=new boolean[N][N];
    for(int r=0 ; r<N ; r++){
      char[] S=in.next().toCharArray();
      for(int c=0 ; c<N ; c++){
        if(S[c]=='.'){
          grid[r][c]=true ;
        }
      }
    }
    int[][] stat=new int[N][N];
    for(int r=0 ; r<N ; r++){
      for(int c=0 ; c<N ; c++){
        if(r+K<=N){
          boolean ok=true ;
          for(int k=0 ; k<K ; k++){
            ok &=grid[r+k][c];
          }
          if(ok){
            for(int k=0 ; k<K ; k++){
              stat[r+k][c]++;
            }
          }
        }
        if(c+K<=N){
          boolean ok=true ;
          for(int k=0 ; k<K ; k++){
            ok &=grid[r][c+k];
          }
          if(ok){
            for(int k=0 ; k<K ; k++){
              stat[r][c+k]++;
            }
          }
        }
      }
    }
    int bestR=-1 ;
    int bestC=-1 ;
    int best=-1 ;
    for(int r=0 ; r<N ; r++){
      for(int c=0 ; c<N ; c++){
        int count=stat[r][c];
        if(count>best){
          best=count ;
          bestR=r ;
          bestC=c ;
        }
      }
    }
    System.out.println((bestR+1)+" "+(bestC+1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B965 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    var grid : Sequence(Sequence(boolean)) ; grid := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(false)) ;
        var r : int ; r := 0 ; while r < N do ( (     var S : Sequence(String) ; S := in.getCurrent()->characters() ;
         var c : int ; c := 0 ; while c < N do ( (     if (S[c+1] = '.') then (     grid[r+1][c+1] := true ) else skip )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    var stat : Sequence(Sequence(int)) ; stat := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
        var r : int ; r := 0 ; while r < N do ( (         var c : int ; c := 0 ; while c < N do ( (     if (r + K <= N) then (     var ok : boolean ; ok := true ;
         var k : int ; k := 0 ; while k < K do ( (     ok := MathLib.bitwiseAnd(ok, grid[r + k+1][c+1]) )  ;     k := k + 1 ) ; 
     if (ok) then (         var k : int ; k := 0 ; while k < K do ( (     stat[r + k+1][c+1] := stat[r + k+1][c+1] + 1 )  ;     k := k + 1 ) ) else skip ) else skip ; 
     if (c + K <= N) then (     var ok : boolean ; ok := true ;
         var k : int ; k := 0 ; while k < K do ( (     ok := MathLib.bitwiseAnd(ok, grid[r+1][c + k+1]) )  ;     k := k + 1 ) ; 
     if (ok) then (         var k : int ; k := 0 ; while k < K do ( (     stat[r+1][c + k+1] := stat[r+1][c + k+1] + 1 )  ;     k := k + 1 ) ) else skip ) else skip )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    var bestR : int ; bestR := -1 ;
    var bestC : int ; bestC := -1 ;
    var best : int ; best := -1 ;
        var r : int ; r := 0 ; while r < N do ( (         var c : int ; c := 0 ; while c < N do ( (     var count : int ; count := stat[r+1][c+1] ;
     if (count > best) then (     best := count ; 
     bestR := r ; 
     bestC := c ) else skip )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    OclFile["System.out"].println((bestR + 1) + " " + (bestC + 1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isprime(int x){
    for(int i=2 ; i*i<=x ; i++)if(x % i==0)return false ;
    return true ;
  }
  static boolean isNSqMinusnMSqPrime(int m,int n){
    if(n-m==1 && isprime(m+n))return true ;
    else return false ;
  }
  public static void main(String[] args){
    int m=13,n=16 ;
    if(isNSqMinusnMSqPrime(m,n))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isprime( x : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= x do (     if (x mod i = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation isNSqMinusnMSqPrime( m : int, n : int) : boolean
  pre: true
  post: true
  activity: (     if (n - m = 1 & isprime(m + n)) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 13 ;
    var n : int ; n := 16 ;
     if (isNSqMinusnMSqPrime(m, n)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Solution {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(reader.readLine());
    double[] poss=new double[n];
    StringTokenizer sToken=new StringTokenizer(reader.readLine());
    for(int i=0 ; i<n ; i++)poss[i]=Double.parseDouble(sToken.nextToken());
    double[][][] dp=new double[n][n+1][2];
    double max=0.0 ;
    for(int i=0 ; i<n ; i++){
      double p1=poss[i],p0=1.0-poss[i];
      for(int amount=1 ; amount<=n ; amount++){
        double res1=p1,res0=p0 ;
        for(int j=0 ; j<i ; j++){
          if(res1<dp[j][amount-1][1]*p0+dp[j][amount-1][0]*p1){
            res1=dp[j][amount-1][1]*p0+dp[j][amount-1][0]*p1 ;
            res0=dp[j][amount-1][0]*p0 ;
          }
        }
        dp[i][amount]=new double[] {
          res0,res1 };
          max=Math.max(max,res1);
        }
      }
      System.out.println(max);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (reader.readLine())->toInteger() ;
    var poss : Sequence(double) ; poss := Integer.subrange(1,n)->collect(0.0) ;
    var sToken : OclIterator ; sToken := OclIterator.newOclIterator_String(reader.readLine()) ;
        var i : int ; i := 0 ; while i < n do (     poss[i+1] := (sToken.next())->toReal() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(Sequence(double))) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,n + 1)->collect(Integer.subrange(1,2)->collect(0.0))) ;
    var max : double ; max := 0.0 ;
        var i : int ; i := 0 ; while i < n do ( (     var p1 : double ; p1 := poss[i+1] ;
    var p0 : double ; p0 := 1.0 - poss[i+1] ;
         var amount : int ; amount := 1 ; while amount <= n do ( (     var res1 : double ; res1 := p1 ;
    var res0 : double ; res0 := p0 ;
         var j : int ; j := 0 ; while j < i do ( (     if (res1 < dp[j+1][amount - 1+1][1+1] * p0 + dp[j+1][amount - 1+1][0+1] * p1) then (     res1 := dp[j+1][amount - 1+1][1+1] * p0 + dp[j+1][amount - 1+1][0+1] * p1 ; 
     res0 := dp[j+1][amount - 1+1][0+1] * p0 ) else skip )  ;     j := j + 1 ) ; 
     dp[i+1][amount+1] := Sequence{res0,res1} ; 
     max := Set{max, res1}->max() )  ;     amount := amount + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    FastScanner in=new FastScanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    new Main().run(in,out);
    out.close();
  }
  int N ;
  double[] d ;
  void run(FastScanner in,PrintWriter out){
    N=in.nextInt();
    d=new double[N];
    for(int i=0 ; i<N ; i++)d[i]=Double.valueOf(in.next());
    Arrays.sort(d);
    double max=d[N-1];
    double max2=0 ;
    int i=0 ;
    for(i=0 ; i<N && d[i]<=0.5d ; i++);
    i--;
    int halfIndex=i ;
    for(; i>=0 ; i--){
      double curr=0 ;
      for(int j=i ; j<=halfIndex ; j++){
        double p=1 ;
        for(int k=i ; k<=halfIndex ; k++){
          if(j==k)p*=d[k];
          else p*=(1-d[k]);
        }
        curr+=p ;
      }
      if(curr>=0.5d)break ;
      max2=Math.max(max2,curr);
    }
    out.println(String.format("%.10f",Math.max(max,max2)));
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(InputStream in){
      br=new BufferedReader(new InputStreamReader(in));
      st=null ;
    }
    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());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     Main.newMain().run(in, out) ; 
     skip );
   attribute N : int;
   attribute d : Sequence(double);
   operation run( in : FastScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     N := in.nextInt() ; 
     d := Integer.subrange(1,N)->collect(0.0) ; 
        var i : int ; i := 0 ; while i < N do (     d[i+1] := (in.next())->toReal() ;  ;     i := i + 1 ) ; 
    d := d->sort() ; 
    var max : double ; max := d[N - 1+1] ;
    var max2 : double ; max2 := 0 ;
    var i : int ; i := 0 ;
        i := 0 ; while i < N & d[i+1] <= 0.5d do (   ;     i := i + 1 ) ; 
    i := i - 1 ; 
    var halfIndex : int ; halfIndex := i ;
      while i >= 0 do ( (     var curr : double ; curr := 0 ;
         var j : int ; j := i ; while j <= halfIndex do ( (     var p : double ; p := 1 ;
         var k : int ; k := i ; while k <= halfIndex do ( (     if (j = k) then     p := p*(d[k+1]) ; else     p := p*((1 - d[k+1])) ; )  ;     k := k + 1 ) ; 
     curr := curr+(p) )  ;     j := j + 1 ) ; 
     if (curr >= 0.5d) then     break else skip ; 
     max2 := Set{max2, curr}->max() )  ;     i := i - 1 ) ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     st := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int m,i,h ;
    while(true){
      String c=stdIn.next();
      if(c.equals("-"))break ;
      m=stdIn.nextInt();
      for(i=0 ; i<m ; i++){
        h=stdIn.nextInt();
        String t=c.substring(0,h);
        c=c.substring(h,c.length())+t ;
      }
      System.out.println(c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ;
    var i : int ;
    var h : int ;
     while (true) do (     var c : String ; c := stdIn.getCurrent() ;
     if (c = "-") then     break else skip ; 
    m := stdIn.getCurrent()->toInteger() ; 
        i := 0 ; while i < m do ( (     h := stdIn.getCurrent()->toInteger() ; 
     var t : String ; t := c.subrange(0+1,h) ;
     c := c.subrange(h+1,c->size()) + t )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static String shuffle(String card,int num){
    String ans="" ;
    for(int i=num ; i<card.length(); i++){
      ans+=card.charAt(i);
    }
    return ans+card.substring(0,num);
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    ArrayList<String>ans=new ArrayList<String>();
    String card ;
    int shuffle ;
    while(true){
      card=br.readLine();
      if(card.equals("-"))break ;
      shuffle=Integer.parseInt(br.readLine());
      for(int i=1 ; i<=shuffle ; i++)card=shuffle(card,Integer.parseInt(br.readLine()));
      ans.add(card);
    }
    for(String s : ans){
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation shuffle( card : String, num : int) : String
  pre: true
  post: true
  activity: (     var ans : String ; ans := "" ;
         var i : int ; i := num ; while i < card->size() do ( (     ans := ans+(card->at(i+1)) )  ;     i := i + 1 ) ; 
     return ans + card.subrange(0+1,num) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var ans : Sequence(String) ; ans := Sequence{} ;
    var card : String ;
    var shuffle : int ;
    while (true) do (     card := br.readLine() ; 
     if (card = "-") then     break else skip ; 
    shuffle := (br.readLine())->toInteger() ; 
        var i : int ; i := 1 ; while i <= shuffle do (     card := shuffle(card, (br.readLine())->toInteger()) ;  ;     i := i + 1 ) ; 
    ans := ans->including(card) ; 
 ) ; 
    for (s : ans) do ( (     OclFile["System.out"].println(s) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  private static Scanner sc=new Scanner(System.in);
  private static ArrayList<Integer>numCardsShuffle=new ArrayList<Integer>();
  private static ArrayList<String>result=new ArrayList<String>();
  public static void main(String[] args){
    doShuffles();
    printResult(result);
  }
  public static void doShuffles(){
    while(sc.hasNext()){
      String cards=getCards();
      if(cards==null){
        break ;
      }
      setShuffleDetail();
      result.add(getCardsShuffled(cards,numCardsShuffle));
      numCardsShuffle.clear();
    }
  }
  private static String getCards(){
    String cards=sc.next();
    if(cards.compareTo("-")==0){
      return null ;
    }
    return cards ;
  }
  private static void setShuffleDetail(){
    int numShuffle=sc.nextInt();
    for(int i=0 ; i<numShuffle ; i++){
      numCardsShuffle.add(sc.nextInt());
    }
  }
  public static String getCardsShuffled(String str,ArrayList<Integer>num){
    String deck=str ;
    for(int i=0 ; i<num.size(); i++){
      String downDeck=deck.substring(0,num.get(i));
      String upDeck=deck.substring(num.get(i),str.length());
      deck=upDeck+downDeck ;
    }
    return deck ;
  }
  private static void printResult(ArrayList<String>result){
    for(int i=0 ; i<result.size(); i++){
      System.out.println(result.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute numCardsShuffle : Sequence(int) := Sequence{};
  static   attribute result : Sequence(String) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doShuffles() ; 
     execute printResult(result) );
  static   operation doShuffles() : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     var cards : String ; cards := getCards() ;
     if (cards = null) then (     break ) else skip ; 
    execute setShuffleDetail() ; 
    result := result->including(getCardsShuffled(cards, numCardsShuffle)) ; 
    numCardsShuffle := numCardsShuffle->intersection(Set{}) ; 
 ) );
  static   operation getCards() : String
  pre: true
  post: true
  activity: (     var cards : String ; cards := sc.getCurrent() ;
     if (cards->compareTo("-") = 0) then (     return null ) else skip ; 
     return cards );
  static   operation setShuffleDetail() : void
  pre: true
  post: true
  activity: (     var numShuffle : int ; numShuffle := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < numShuffle do ( (     numCardsShuffle := numCardsShuffle->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) );
  static   operation getCardsShuffled( str : String, num : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var deck : String ; deck := str ;
         var i : int ; i := 0 ; while i < num->size() do ( (     var downDeck : String ; downDeck := deck.subrange(0+1,num->at(i+1)) ;
     var upDeck : String ; upDeck := deck.subrange(num->at(i+1)+1,str->size()) ;
     deck := upDeck + downDeck )  ;     i := i + 1 ) ; 
     return deck );
  static   operation printResult( result : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < result->size() do ( (     OclFile["System.out"].println(result->at(i+1)) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public static void main(String[] args){
    for(int i=1 ; i<10 ; i++){
      for(int j=1 ; j<10 ; j++){
        System.out.println(i+"x"+j+"="+i*j);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < 10 do ( (         var j : int ; j := 1 ; while j < 10 do ( (     OclFile["System.out"].println(i + "x" + j + "=" + i * j) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      try {
        String line=reader.readLine();
        if(line.charAt(0)=='-')break ;
        int num=Integer.parseInt(reader.readLine());
        for(int i=0 ; i<num ; i++){
          int j=Integer.parseInt(reader.readLine());
          String sub1=line.substring(0,j);
          String sub2=line.substring(j);
          line=sub2.concat(sub1);
        }
        System.out.println(line);
      }
      catch(IOException e){
        System.out.println(e);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     try (     var line : String ; line := reader.readLine() ;
     if (line->at(0+1) = '-') then     break else skip ; 
    var num : int ; num := (reader.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < num do ( (     var j : int ; j := (reader.readLine())->toInteger() ;
     var sub1 : String ; sub1 := line.subrange(0+1,j) ;
     var sub2 : String ; sub2 := line.subrange(j+1,j) ;
     line := sub2+sub1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(line) ; 
 )   catch (e : IOException) do (     OclFile["System.out"].println(e) )
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void angleextcycquad(int z){
    System.out.print("The exterior angle of the"+" cyclic quadrilateral is "+z+" degrees");
  }
  public static void main(String[] args){
    int z=48 ;
    angleextcycquad(z);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation angleextcycquad( z : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("The exterior angle of the" + " cyclic quadrilateral is " + z + " degrees") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var z : int ; z := 48 ;
     execute angleextcycquad(z) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    int length ;
    int sh ;
    int a ;
    StringBuffer sb=new StringBuffer();
    while(true){
      String str=in.readLine();
      if(str.equals("-")==true)break ;
      length=Integer.parseInt(in.readLine());
      sh=0 ;
      for(int i=0 ; i<length ; i++){
        sh+=Integer.parseInt(in.readLine());
      }
      for(int i=0 ; i<str.length(); i++){
        a=(sh+i)% str.length();
        sb.append(str.charAt(a));
      }
      sb.append("\n");
    }
    System.out.print(sb);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var length : int ;
    var sh : int ;
    var a : int ;
    var sb : String ; sb := StringLib.newString() ;
    while (true) do (     var str : String ; str := in.readLine() ;
     if (str = "-" = true) then     break else skip ; 
    length := (in.readLine())->toInteger() ; 
    sh := 0 ; 
        var i : int ; i := 0 ; while i < length do ( (     sh := sh+((in.readLine())->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < str->size() do ( (     a := (sh + i) mod str->size() ; 
     sb := sb + StringLib.newString(str->at(a+1)) )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString("\n") ; 
 ) ; 
    OclFile["System.out"].print(sb) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int count=scan.nextInt();
    while(count>0){
      int[][] arr=new int[count][2];
      for(int i=0 ; i<count ; i++){
        char[] input=scan.next().toCharArray();
        arr[i][0]=input.length ;
        arr[i][1]=input[input.length-1];
      }
      Func.ite=0 ;
      Func.arr=arr ;
      System.out.println(new Func().calc());
      count=scan.nextInt();
    }
  }
}
class Func {
  static int ite ;
  static int[][] arr ;
  char mark ;
  ArrayList<Func>list ;
  Func(){
    mark=(char)arr[ite][1];
    switch(arr[ite][1]){
      case '+' : case '*' : int deep=arr[ite][0];
      ite++;
      list=new ArrayList<>();
      while(ite<arr.length && arr[ite][0]>deep){
        list.add(new Func());
      }
      break ;
      default : ite++;
      break ;
    }
  }
  int calc(){
    int sum=0 ;
    switch(mark){
      case '+' : for(Func _f : list){
        sum+=_f.calc();
      }
      return sum ;
      case '*' : sum=1 ;
      for(Func _f : list){
        sum*=_f.calc();
      }
      return sum ;
      default : return(int)(mark-'0');
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := scan.getCurrent()->toInteger() ;
     while (count > 0) do (     var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,count)->collect(Integer.subrange(1,2)->collect(0)) ;
         var i : int ; i := 0 ; while i < count do ( (     var input : Sequence(String) ; input := scan.getCurrent()->characters() ;
     arr[i+1][0+1] := input->size() ; 
     arr[i+1][1+1] := input[input->size() - 1+1] )  ;     i := i + 1 ) ; 
    Func.ite := 0 ; 
    Func.arr := arr ; 
    OclFile["System.out"].println(Func.newFunc().calc()) ; 
    count := scan.getCurrent()->toInteger() ; 
 ) );
}
class Func {
  static   attribute ite : int;
  static   attribute arr : Sequence(Sequence(int));
   attribute mark : String;
   attribute list : Sequence(Func);
   static operation newFunc() : Func
  pre: true
  post: true
  activity:
  ( var self : Func ;
    self := createFunc();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     mark := arr[ite+1][1+1]->oclAsType(String) ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (arr[ite+1][1+1]) ; 
    if _switchval = '+' or _switchval = '*' then
    var deep : int ; deep := arr[ite+1][0+1] ;
    ite := ite + 1 ; 
    list := Sequence{} ; 
    while (ite < arr->size() & arr[ite+1][0+1] > deep) do (     list := list->including(Func.newFunc()) ) ; 
    break 
   else skip ;
       if true then
     ite := ite + 1 ; 
    break 
   else skip ;
 )
 );
   operation calc() : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (mark) ; 
       if _switchval = '+' then
     for (_f : list) do ( (     sum := sum+(_f.calc()) )  ) ; 
    return sum 
   else skip ;
       if _switchval = '*' then
     sum := 1 ; 
    for (_f : list) do ( (     sum := sum*(_f.calc()) )  ) ; 
    return sum 
   else skip ;
       if true then
     return ((mark)->char2byte() - ('0')->char2byte())->oclAsType(int) 
   else skip ;
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int n ;
  static char[][] buff=new char[17][10];
  static int[] length=new int[17];
  static int calc(int line){
    char c ;
    int level,val ;
    int arg ;
    level=length[line]-1 ;
    c=buff[line][level];
    if(c=='*'){
      line++;
      val=1 ;
      while(true){
        if(length[line]-1<=level)break ;
        if(length[line]-1==level+1){
          arg=calc(line);
          val*=arg ;
        }
        line++;
        if(line>=n)break ;
      }
      return val ;
    }
    else if(c=='+'){
      line++;
      val=0 ;
      while(true){
        if(length[line]-1<=level)break ;
        if(length[line]-1==level+1){
          arg=calc(line);
          val+=arg ;
        }
        line++;
        if(line>=n)break ;
      }
      return val ;
    }
    return c-'0' ;
  }
  public static void main(String args[]){
    try(Scanner sc=new Scanner(System.in)){
      while(sc.hasNext()){
        n=sc.nextInt();
        if(n==0)break ;
        for(int i=0 ; i<n ; i++){
          String str=sc.next();
          length[i]=str.length();
          for(int j=0 ; j<str.length(); j++){
            buff[i][j]=str.charAt(j);
          }
        }
        System.out.println(calc(0));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute buff : Sequence(Sequence(String)) := Integer.subrange(1,17)->collect(Integer.subrange(1,10)->collect(0));
  static   attribute length : Sequence(int) := Integer.subrange(1,17)->collect(0);
  static   operation calc( line : int) : int
  pre: true
  post: true
  activity: (     var c : String ;
     var level : int ;
    var val : int ;
    var arg : int ;
    level := length[line+1] - 1 ; 
    c := buff[line+1][level+1] ; 
    if (c = '*') then (     line := line + 1 ; 
     val := 1 ; 
     while (true) do (     if (length[line+1] - 1 <= level) then     break else skip ; 
     if (length[line+1] - 1 = level + 1) then (     arg := calc(line) ; 
     val := val*(arg) ) else skip ; 
     line := line + 1 ; 
     if (line >= n) then     break else skip ) ; 
     return val ) else     if (c = '+') then (     line := line + 1 ; 
     val := 0 ; 
     while (true) do (     if (length[line+1] - 1 <= level) then     break else skip ; 
     if (length[line+1] - 1 = level + 1) then (     arg := calc(line) ; 
     val := val+(arg) ) else skip ; 
     line := line + 1 ; 
     if (line >= n) then     break else skip ) ; 
     return val ) else skip ; ;  
    return (c)->char2byte() - ('0')->char2byte() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (sc.hasNext()) do (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := sc.getCurrent() ;
     length[i+1] := str->size() ; 
         var j : int ; j := 0 ; while j < str->size() do ( (     buff[i+1][j+1] := str->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(calc(0)) ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ICPCCalculator solver=new ICPCCalculator();
    try {
      int testNumber=1 ;
      while(true)solver.solve(testNumber++,in,out);
    }
    catch(UnknownError e){
      out.close();
    }
  }
  static class ICPCCalculator {
    int n ;
    String[] S ;
    boolean[] visited ;
    public void solve(int testNumber,Scanner in,PrintWriter out){
      n=in.nextInt();
      if(n==0)throw new UnknownError();
      S=new String[n];
      visited=new boolean[n];
      Arrays.fill(visited,false);
      for(int i=0 ; i<n ; i++){
        S[i]=in.next();
      }
      if(n==1){
        out.println(S[0]);
        return ;
      }
      out.println(dfs(0,0,false));
    }
    private int dfs(int now,int dot,boolean ope){
      int ans=ope ? 1 : 0 ;
      for(int i=now ; i<n ; i++){
        if(S[i] .length()<=dot)break ;
        final char c=S[i] .charAt(dot);
        if(Character.isDigit(c)){
          if(ope){
            ans*=c-'0' ;
          }
          else {
            ans+=c-'0' ;
          }
        }
        else if(c=='+' || c=='*'){
          if(ope){
            ans*=dfs(i+1,dot+1,c=='*');
          }
          else {
            ans+=dfs(i+1,dot+1,c=='*');
          }
        }
        else if(c=='.'){
          continue ;
        }
        else {
          throw new Error();
        }
      }
      return ans ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ICPCCalculator ; solver := ICPCCalculator.newICPCCalculator() ;
    try (     var testNumber : int ; testNumber := 1 ;
     while (true) do     solver.solve(testNumber, in, out) ; )   catch (e : UnknownError) do (     skip )
 );
  static class ICPCCalculator {
   attribute n : int;
   attribute S : Sequence(String);
   attribute visited : Sequence(boolean);
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     n := in.getCurrent()->toInteger() ; 
     if (n = 0) then     error UnknownError.newUnknownError() ; else skip ; 
    S := Integer.subrange(1,n)->collect(null) ; 
    visited := Integer.subrange(1,n)->collect(false) ; 
    visited := visited->collect(false) ; 
        var i : int ; i := 0 ; while i < n do ( (     S[i+1] := in.getCurrent() )  ;     i := i + 1 ) ; 
    if (n = 1) then (     skip ; 
     return ) else skip ; 
    skip ; 
 );
   operation dfs( now : int, dot : int, ope : boolean) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := if ope then 1 else 0 endif ;
         var i : int ; i := now ; while i < n do ( (     if (S[i+1]->size() <= dot) then     break else skip ; 
     var c : String ; c := S[i+1]->at(dot+1) ;
     if ((c + "")->isMatch("[0-9]")) then (     if (ope) then (     ans := ans*((c)->char2byte() - ('0')->char2byte()) ) else (     ans := ans+((c)->char2byte() - ('0')->char2byte()) ) ) else     if (c = '+' or c = '*') then (     if (ope) then (     ans := ans*(dfs(i + 1, dot + 1, c = '*')) ) else (     ans := ans+(dfs(i + 1, dot + 1, c = '*')) ) ) else     if (c = '.') then (     continue ) else (     error SystemException() ) ;  ;  )  ;     i := i + 1 ) ; 
     return ans );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Deque ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  private static int n ;
  private static Deque<Deque<String>>stack ;
  public static void main(String...args){
    Scanner scanner=new Scanner(System.in);
    while((n=scanner.nextInt())!=0){
      stack=new ArrayDeque<>();
      IntStream.range(0,n).forEach(i->{
        String l=scanner.next();
        int level=l.replaceFirst("[^.] ","").length();
        if(stack.size()<=level){
          stack.add(new ArrayDeque<String>());
        }
        calc(level);
        stack.peekLast().add(l.substring(l.length()-1));
      }
);
      calc(0);
      System.out.println(stack.pop().pop());
    }
  }
  private static void calc(int level){
    while(stack.size()>level+1){
      Deque<String>args=stack.pollLast();
      if(stack.isEmpty())break ;
      String operator=stack.peekLast().pollLast();
      if(operator.equals("*")){
        stack.peekLast().push(String.valueOf(args.stream().reduce(1l,(Long sum,String a)->sum*Long.parseLong(a),(Long a,Long b)->a*b)));
      }
      else if(operator.equals("+")){
        stack.peekLast().push(String.valueOf(args.stream().reduce(0l,(Long sum,String a)->sum+Long.parseLong(a),(Long a,Long b)->a+b)));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute stack : Sequence(Sequence(String));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         n := scanner.getCurrent()->toInteger() ;
    while ((n) /= 0) do (    skip ; (     stack := ArrayDeque<OclAny>.newArrayDeque() ; 
     for i : Integer.subrange(0, n-1) do
    (    skip) ; 
     execute calc(0) ; 
     OclFile["System.out"].println(stack->last()->last()) ) ;     n := scanner.getCurrent()->toInteger() ;
 ) );
  static   operation calc( level : int) : void
  pre: true
  post: true
  activity: (     while (stack->size() > level + 1) do (     var args : Sequence(String) ; args := stack->last() ;
     if (stack->isEmpty()) then     break else skip ; 
     var operator : String ; operator := stack.peekLast()->last() ;
     if (operator = "*") then (     stack := stack.peekLast()->append(((args->iterate( _var; _acc : OclAny | 1l, lambda  sum : long, a : String : OclAny in sum * (a)->toLong(), lambda  a : long, b : long : OclAny in a * b->apply((_acc,_var)) )) + "")) ) else     if (operator = "+") then (     stack := stack.peekLast()->append(((args->iterate( _var; _acc : OclAny | 0l, lambda  sum : long, a : String : OclAny in sum + (a)->toLong(), lambda  a : long, b : long : OclAny in a + b->apply((_acc,_var)) )) + "")) ) else skip ; ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
import static java.lang.Integer.parseInt ;
public class Main {
  static final char NOOP=' ' ;
  static final char PLUS='+' ;
  static final char MULTI='*' ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    Main main=new Main();
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=parseInt(line);
      if(n==0)break ;
      Exp exp=main.new Exp(null,-1,PLUS);
      Exp parent=exp ;
      for(int i=0 ; i<n ; i++){
        line=br.readLine();
        int lv=0 ;
        for(char c : line.toCharArray()){
          if(c=='.'){
            lv++;
          }
          else {
            while(parent.lv>=lv){
              parent=parent.parent ;
            }
            Exp sub=main.new Exp(parent,lv,c);
            parent.exps.add(sub);
            if(c==PLUS || c==MULTI)parent=sub ;
          }
        }
      }
      System.out.println(exp.value());
    }
  }
  class Exp {
    int lv ;
    char op ;
    int value ;
    Exp parent ;
    List<Exp>exps ;
    Exp(Exp parent,int lv,char c){
      this.parent=parent ;
      this.lv=lv ;
      if(c!=PLUS && c!=MULTI){
        this.op=NOOP ;
        this.value=c-'0' ;
      }
      else {
        this.op=c ;
        exps=new ArrayList<Exp>();
      }
    }
    int value(){
      if(op==PLUS){
        value=0 ;
        for(Exp exp : exps)value+=exp.value();
      }
      else if(op==MULTI){
        value=1 ;
        for(Exp exp : exps)value*=exp.value();
      }
      return value ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute NOOP : String := ' ';
  static    attribute PLUS : String := '+';
  static    attribute MULTI : String := '*';
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var main : Main ; main := Main.newMain() ;
        line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := parseInt(line) ;
     if (n = 0) then     break else skip ; 
    var exp : Exp ; exp := (main).newExp(null, -1, PLUS) ;
    var parent : Exp ; parent := exp ;
        var i : int ; i := 0 ; while i < n do ( (     line := br.readLine() ; 
     var lv : int ; lv := 0 ;
     for (c : line->characters()) do ( (     if (c = '.') then (     lv := lv + 1 ) else (     while (parent.lv >= lv) do (     parent := parent.parent ) ; 
     var sub : Exp ; sub := (main).newExp(parent, lv, c) ;
     parent.exps->excludes(sub) ; 
     if (c = PLUS or c = MULTI) then     parent := sub ; else skip ) )  ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(exp.value()) ; 
 ) ;     line := br.readLine() ;
 ) ;  
 );
 class Exp {
   attribute lv : int;
   attribute op : String;
   attribute value : int;
   attribute parent : Exp;
   attribute exps : Sequence(Exp);
   static operation newExp( parent : Exp, lv : int, c : String) : Exp
  pre: true
  post: true
  activity:
  ( var self : Exp ;
    self := createExp();
    self.initialise(parent, lv,c);
    return self );
  operation initialise( parent : Exp, lv : int, c : String) : void
  pre: true  post: true
  activity: (     self.parent := parent ; 
     self.lv := lv ; 
     if (c /= PLUS & c /= MULTI) then (     self.op := NOOP ; 
     self.value := c - ('0')->char2byte() ) else (     self.op := c ; 
     exps := Sequence{} ) );
   operation value() : int
  pre: true
  post: true
  activity: (     if (op = PLUS) then (     value := 0 ; 
     for (exp : exps) do (     value := value+(exp.value()) ;  ) ) else     if (op = MULTI) then (     value := 1 ; 
     for (exp : exps) do (     value := value*(exp.value()) ;  ) ) else skip ; ;  
     return value );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    Scanner scanner=new Scanner(System.in);
    while(true){
      me=scanner.nextInt();
      if(me==0)break ;
      n=scanner.nextInt();
      a=new int[n+2];
      for(int i=1 ; i<=n ; i++)a[i]=scanner.nextInt();
      n+=2 ;
      boolean[] vis=new boolean[n];
      bfs(0,vis);
      if(! vis[n-1]){
        System.out.println("NG");
        continue ;
      }
      boolean ok=true ;
      for(int s=1 ; s<n-1 ; s++){
        if(vis[s]){
          boolean[] vis2=new boolean[n];
          bfs(s,vis2);
          if(! vis2[n-1]){
            ok=false ;
            break ;
          }
        }
      }
      System.out.println(ok ? "OK" : "NG");
    }
  }
  private void bfs(int s,boolean[] vis){
    for(int i=0 ; i<n ; i++)vis[i]=(i==s);
    int[] Q=new int[n];
    int head=0 ;
    int tail=0 ;
    Q[tail++]=s ;
    while(head<tail){
      int x=Q[head++];
      for(int d=1 ; d<=me ; d++){
        int xx=Math.min(x+d,n-1);
        xx=Math.max(Math.min(xx+a[xx],n-1),0);
        if(! vis[xx]){
          vis[xx]=true ;
          Q[tail++]=xx ;
        }
      }
    }
  }
  int n,me ;
  int[] a ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     me := scanner.getCurrent()->toInteger() ; 
     if (me = 0) then     break else skip ; 
    n := scanner.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,n + 2)->collect(0) ; 
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    n := n+(2) ; 
    var vis : Sequence(boolean) ; vis := Integer.subrange(1,n)->collect(false) ;
    execute bfs(0, vis) ; 
    if (not(vis[n - 1+1])) then (     OclFile["System.out"].println("NG") ; 
     continue ) else skip ; 
    var ok : boolean ; ok := true ;
        var s : int ; s := 1 ; while s < n - 1 do ( (     if (vis[s+1]) then (     var vis2 : Sequence(boolean) ; vis2 := Integer.subrange(1,n)->collect(false) ;
     execute bfs(s, vis2) ; 
     if (not(vis2[n - 1+1])) then (     ok := false ; 
     break ) else skip ) else skip )  ;     s := s + 1 ) ; 
    OclFile["System.out"].println(if ok then "OK" else "NG" endif) ; 
 ) );
   operation bfs( s : int, vis : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     vis[i+1] := (i = s) ;  ;     i := i + 1 ) ; 
     var Q : Sequence(int) ; Q := Integer.subrange(1,n)->collect(0) ;
    var head : int ; head := 0 ;
    var tail : int ; tail := 0 ;
     Q[tail+1] := s  ; tail := tail + 1 ; 
    while (head < tail) do (     var x : int ; x := Q[head+1] ;
         var d : int ; d := 1 ; while d <= me do ( (     var xx : int ; xx := Set{x + d, n - 1}->min() ;
     xx := Set{Set{xx + a[xx+1], n - 1}->min(), 0}->max() ; 
     if (not(vis[xx+1])) then (     vis[xx+1] := true ; 
      Q[tail+1] := xx  ; tail := tail + 1 ) else skip )  ;     d := d + 1 ) ) ; 
 );
   attribute n : int;
   attribute a : Sequence(int);
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Deque ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    Scanner scanner=new Scanner(System.in);
    while(true){
      me=scanner.nextInt();
      if(me==0)break ;
      n=scanner.nextInt();
      a=new int[n+2];
      for(int i=1 ; i<=n ; i++)a[i]=scanner.nextInt();
      n+=2 ;
      boolean[] vis=new boolean[n];
      bfs(0,vis);
      if(! vis[n-1]){
        System.out.println("NG");
        continue ;
      }
      boolean ok=true ;
      for(int s=1 ; s<n-1 ; s++){
        if(vis[s]){
          boolean[] vis2=new boolean[n];
          bfs(s,vis2);
          if(! vis2[n-1]){
            ok=false ;
            break ;
          }
        }
      }
      System.out.println(ok ? "OK" : "NG");
    }
  }
  private void bfs(int s,boolean[] vis){
    for(int i=0 ; i<n ; i++)vis[i]=(i==s);
    Deque<Integer>deque=new ArrayDeque<Integer>();
    deque.push(s);
    while(! deque.isEmpty()){
      int x=deque.poll();
      for(int d=1 ; d<=me ; d++){
        int xx=Math.min(x+d,n-1);
        xx=Math.max(Math.min(xx+a[xx],n-1),0);
        if(! vis[xx]){
          vis[xx]=true ;
          deque.push(xx);
        }
      }
    }
  }
  int n,me ;
  int[] a ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     me := scanner.getCurrent()->toInteger() ; 
     if (me = 0) then     break else skip ; 
    n := scanner.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,n + 2)->collect(0) ; 
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    n := n+(2) ; 
    var vis : Sequence(boolean) ; vis := Integer.subrange(1,n)->collect(false) ;
    execute bfs(0, vis) ; 
    if (not(vis[n - 1+1])) then (     OclFile["System.out"].println("NG") ; 
     continue ) else skip ; 
    var ok : boolean ; ok := true ;
        var s : int ; s := 1 ; while s < n - 1 do ( (     if (vis[s+1]) then (     var vis2 : Sequence(boolean) ; vis2 := Integer.subrange(1,n)->collect(false) ;
     execute bfs(s, vis2) ; 
     if (not(vis2[n - 1+1])) then (     ok := false ; 
     break ) else skip ) else skip )  ;     s := s + 1 ) ; 
    OclFile["System.out"].println(if ok then "OK" else "NG" endif) ; 
 ) );
   operation bfs( s : int, vis : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     vis[i+1] := (i = s) ;  ;     i := i + 1 ) ; 
     var deque : Sequence(int) ; deque := ArrayDeque<int>.newArrayDeque() ;
     deque := deque->append(s) ; 
     while (not(deque->isEmpty())) do (     var x : int ; x := deque->min() ;
         var d : int ; d := 1 ; while d <= me do ( (     var xx : int ; xx := Set{x + d, n - 1}->min() ;
     xx := Set{Set{xx + a[xx+1], n - 1}->min(), 0}->max() ; 
     if (not(vis[xx+1])) then (     vis[xx+1] := true ; 
     deque := deque->append(xx) ) else skip )  ;     d := d + 1 ) ) );
   attribute n : int;
   attribute a : Sequence(int);
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Deque ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    Scanner scanner=new Scanner(System.in);
    while(true){
      me=scanner.nextInt();
      if(me==0)break ;
      n=scanner.nextInt();
      a=new int[n+2];
      for(int i=1 ; i<=n ; i++)a[i]=scanner.nextInt();
      n+=2 ;
      boolean[] vis=new boolean[n];
      bfs(0,vis);
      if(! vis[n-1]){
        System.out.println("NG");
        continue ;
      }
      boolean ok=true ;
      for(int s=1 ; s<n-1 ; s++){
        if(vis[s]){
          boolean[] vis2=new boolean[n];
          vis2[s]=true ;
          bfs(s,vis2);
          if(! vis2[n-1]){
            ok=false ;
            break ;
          }
        }
      }
      System.out.println(ok ? "OK" : "NG");
    }
  }
  private void bfs(int s,boolean[] vis){
    Deque<Integer>deque=new ArrayDeque<Integer>();
    deque.push(s);
    while(! deque.isEmpty()){
      int x=deque.poll();
      for(int d=1 ; d<=me ; d++){
        int xx=Math.min(x+d,n-1);
        xx=Math.max(Math.min(xx+a[xx],n-1),0);
        if(! vis[xx]){
          vis[xx]=true ;
          deque.push(xx);
        }
      }
    }
  }
  int n,me ;
  int[] a ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     me := scanner.getCurrent()->toInteger() ; 
     if (me = 0) then     break else skip ; 
    n := scanner.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,n + 2)->collect(0) ; 
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    n := n+(2) ; 
    var vis : Sequence(boolean) ; vis := Integer.subrange(1,n)->collect(false) ;
    execute bfs(0, vis) ; 
    if (not(vis[n - 1+1])) then (     OclFile["System.out"].println("NG") ; 
     continue ) else skip ; 
    var ok : boolean ; ok := true ;
        var s : int ; s := 1 ; while s < n - 1 do ( (     if (vis[s+1]) then (     var vis2 : Sequence(boolean) ; vis2 := Integer.subrange(1,n)->collect(false) ;
     vis2[s+1] := true ; 
     execute bfs(s, vis2) ; 
     if (not(vis2[n - 1+1])) then (     ok := false ; 
     break ) else skip ) else skip )  ;     s := s + 1 ) ; 
    OclFile["System.out"].println(if ok then "OK" else "NG" endif) ; 
 ) );
   operation bfs( s : int, vis : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (     var deque : Sequence(int) ; deque := ArrayDeque<int>.newArrayDeque() ;
     deque := deque->append(s) ; 
     while (not(deque->isEmpty())) do (     var x : int ; x := deque->min() ;
         var d : int ; d := 1 ; while d <= me do ( (     var xx : int ; xx := Set{x + d, n - 1}->min() ;
     xx := Set{Set{xx + a[xx+1], n - 1}->min(), 0}->max() ; 
     if (not(vis[xx+1])) then (     vis[xx+1] := true ; 
     deque := deque->append(xx) ) else skip )  ;     d := d + 1 ) ) );
   attribute n : int;
   attribute a : Sequence(int);
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  public static void main(String[] a){
    for(int i=1 ; i<10 ; i++){
      for(int j=1 ; j<10 ; j++){
        System.out.println(i+"x"+j+"="+kuku(i,j));
      }
    }
  }
  public static int kuku(int a,int b){
    return a*b ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < 10 do ( (         var j : int ; j := 1 ; while j < 10 do ( (     OclFile["System.out"].println(i + "x" + j + "=" + kuku(i, j)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation kuku( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return a * b );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void printMinIndexChar(String str,String patt){
    int minIndex=Integer.MAX_VALUE ;
    int m=str.length();
    int n=patt.length();
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(patt.charAt(i)==str.charAt(j)&& j<minIndex){
          minIndex=j ;
          break ;
        }
      }
    }
    if(minIndex!=Integer.MAX_VALUE)System.out.println("Minimum Index Character="+str.charAt(minIndex));
    else System.out.println("No character present");
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    String patt="set" ;
    printMinIndexChar(str,patt);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printMinIndexChar( str : String, patt : String) : void
  pre: true
  post: true
  activity: (     var minIndex : int ; minIndex := 2147483647 ;
     var m : int ; m := str->size() ;
    var n : int ; n := patt->size() ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (patt->at(i+1) = str->at(j+1) & j < minIndex) then (     minIndex := j ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (minIndex /= 2147483647) then     OclFile["System.out"].println("Minimum Index Character=" + str->at(minIndex+1)) else     OclFile["System.out"].println("No character present") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var patt : String ; patt := "set" ;
     execute printMinIndexChar(str, patt) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Deque ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    Scanner scanner=new Scanner(System.in);
    while(true){
      max=scanner.nextInt();
      if(max==0)break ;
      n=scanner.nextInt();
      map=new int[n+2];
      for(int i=1 ; i<=n ; i++)map[i]=scanner.nextInt();
      n+=2 ;
      boolean[] vis=new boolean[n];
      vis[0]=true ;
      dfs(0,vis);
      if(! vis[n-1]){
        System.out.println("NG");
        continue ;
      }
      boolean flag=true ;
      for(int s=1 ; s<n-1 ; s++){
        if(! vis[s])continue ;
        boolean[] vis2=new boolean[n];
        vis2[s]=true ;
        dfs(s,vis2);
        if(! vis2[n-1]){
          flag=false ;
          break ;
        }
      }
      System.out.println(flag ? "OK" : "NG");
    }
  }
  private void dfs(int s,boolean[] vis){
    Deque<Integer>deque=new ArrayDeque<Integer>();
    deque.push(s);
    while(! deque.isEmpty()){
      int x=deque.poll();
      for(int i=1 ; i<=max ; i++){
        int nx=Math.min(x+i,n-1);
        nx=Math.max(Math.min(nx+map[nx],n-1),0);
        if(! vis[nx]){
          vis[nx]=true ;
          deque.push(nx);
        }
      }
    }
  }
  int max,n ;
  int[] map ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     max := scanner.getCurrent()->toInteger() ; 
     if (max = 0) then     break else skip ; 
    n := scanner.getCurrent()->toInteger() ; 
    map := Integer.subrange(1,n + 2)->collect(0) ; 
        var i : int ; i := 1 ; while i <= n do (     map[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    n := n+(2) ; 
    var vis : Sequence(boolean) ; vis := Integer.subrange(1,n)->collect(false) ;
    vis[0+1] := true ; 
    execute dfs(0, vis) ; 
    if (not(vis[n - 1+1])) then (     OclFile["System.out"].println("NG") ; 
     continue ) else skip ; 
    var flag : boolean ; flag := true ;
        var s : int ; s := 1 ; while s < n - 1 do ( (     if (not(vis[s+1])) then     continue else skip ; 
     var vis2 : Sequence(boolean) ; vis2 := Integer.subrange(1,n)->collect(false) ;
    vis2[s+1] := true ; 
    execute dfs(s, vis2) ; 
    if (not(vis2[n - 1+1])) then (     flag := false ; 
     break ) else skip ; 
 )  ;     s := s + 1 ) ; 
    OclFile["System.out"].println(if flag then "OK" else "NG" endif) ; 
 ) );
   operation dfs( s : int, vis : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (     var deque : Sequence(int) ; deque := ArrayDeque<int>.newArrayDeque() ;
     deque := deque->append(s) ; 
     while (not(deque->isEmpty())) do (     var x : int ; x := deque->min() ;
         var i : int ; i := 1 ; while i <= max do ( (     var nx : int ; nx := Set{x + i, n - 1}->min() ;
     nx := Set{Set{nx + map[nx+1], n - 1}->min(), 0}->max() ; 
     if (not(vis[nx+1])) then (     vis[nx+1] := true ; 
     deque := deque->append(nx) ) else skip )  ;     i := i + 1 ) ) );
   attribute max : int;
   attribute map : Sequence(int);
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    while(true){
      final int max=sc.nextInt();
      if(max==0){
        break ;
      }
      final int n=sc.nextInt();
      final int size=n+2 ;
      int[] map=new int[size];
      for(int i=1 ; i<=n ; i++){
        map[i]=sc.nextInt();
      }
      boolean[][] adj=new boolean[size][size];
      for(int i=0 ; i<size ; i++){
        for(int j=0 ; j<max ; j++){
          if(i==size-1){
            adj[i][i]=true ;
            continue ;
          }
          final int num=j+1 ;
          final int to=Math.min(size-1,Math.max(0,i+num));
          final int dist=Math.min(size-1,Math.max(0,to+map[to]));
          adj[i][dist]=true ;
        }
      }
      for(int k=0 ; k<size ; k++){
        for(int i=0 ; i<size ; i++){
          for(int j=0 ; j<size ; j++){
            adj[i][j]=adj[i][j] ||(adj[i][k] && adj[k][j]);
          }
        }
      }
      boolean flag=true ;
      for(int i=0 ; i<size ; i++){
        if(adj[0][i] && ! adj[i][size-1]){
          System.out.println("NG");
          flag=false ;
          break ;
        }
      }
      if(flag){
        System.out.println("OK");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var max : int ; max := sc.getCurrent()->toInteger() ;
     if (max = 0) then (     break ) else skip ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var size : int ; size := n + 2 ;
    var map : Sequence(int) ; map := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     map[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var adj : Sequence(Sequence(boolean)) ; adj := Integer.subrange(1,size)->collect(Integer.subrange(1,size)->collect(false)) ;
        var i : int ; i := 0 ; while i < size do ( (         var j : int ; j := 0 ; while j < max do ( (     if (i = size - 1) then (     adj[i+1][i+1] := true ; 
     continue ) else skip ; 
     var num : int ; num := j + 1 ;
    var to : int ; to := Set{size - 1, Set{0, i + num}->max()}->min() ;
    var dist : int ; dist := Set{size - 1, Set{0, to + map[to+1]}->max()}->min() ;
    adj[i+1][dist+1] := true ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < size do ( (         var i : int ; i := 0 ; while i < size do ( (         var j : int ; j := 0 ; while j < size do ( (     adj[i+1][j+1] := adj[i+1][j+1] or (adj[i+1][k+1] & adj[k+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < size do ( (     if (adj[0+1][i+1] & not(adj[i+1][size - 1+1])) then (     OclFile["System.out"].println("NG") ; 
     flag := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then (     OclFile["System.out"].println("OK") ) else skip ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    String str=s.nextLine();
    char[] ch=str.toCharArray();
    int m=s.nextInt();
    int frequency[]=new int[(ch.length)/2];
    for(int i=0 ; i<m ; i++){
      int x=s.nextInt();
      frequency[x-1]++;
    }
    int sum=0 ;
    for(int i=0 ; i<(ch.length)/2 ; i++){
      sum+=frequency[i];
      if(sum % 2!=0){
        char temp=ch[i];
        ch[i]=ch[ch.length-i-1];
        ch[ch.length-i-1]=temp ;
      }
    }
    for(int i=0 ; i<ch.length ; i++){
      System.out.print(ch[i]+"");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := s.nextLine() ;
    var ch : Sequence(String) ; ch := str->characters() ;
    var m : int ; m := s.getCurrent()->toInteger() ;
    var frequency : Sequence(int) ; frequency := Integer.subrange(1,(ch->size()) / 2)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := s.getCurrent()->toInteger() ;
     frequency[x - 1+1] := frequency[x - 1+1] + 1 )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < (ch->size()) / 2 do ( (     sum := sum+(frequency[i+1]) ; 
     if (sum mod 2 /= 0) then (     var temp : String ; temp := ch[i+1] ;
     ch[i+1] := ch[ch->size() - i - 1+1] ; 
     ch[ch->size() - i - 1+1] := temp ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < ch->size() do ( (     OclFile["System.out"].print(ch[i+1] + "") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Mostsociallydistancedsubsequence {
  public static void main(String args[]){
    int i,j,k,t,n ;
    Scanner sc=new Scanner(System.in);
    t=sc.nextInt();
    while(t-->0){
      n=sc.nextInt();
      int a[]=new int[n];
      for(i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      LinkedHashMap<Integer,Integer>hm=new LinkedHashMap<>();
      ArrayList<Integer>list=new ArrayList<Integer>();
      list.add(a[0]);
      int fas=0 ;
      if(a[0]>a[1]){
        fas=1 ;
      }
      int flag=0 ;
      for(i=0 ; i<n ; i++){
        for(j=i+1 ; j<n ; j++){
          if(fas==0){
            if(a[j]<a[j-1]){
              list.add(a[j-1]);
              i=j-2 ;
              fas=1 ;
              break ;
            }
          }
          else {
            if(a[j]>a[j-1]){
              list.add(a[j-1]);
              i=j-2 ;
              fas=0 ;
              break ;
            }
          }
          if(j==n-1){
            flag=1 ;
          }
        }
        if(flag==1){
          break ;
        }
      }
      list.add(a[n-1]);
      System.out.println(list.size());
      for(i=0 ; i<list.size(); i++){
        System.out.print(list.get(i)+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mostsociallydistancedsubsequence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var k : int ;
    var t : int ;
    var n : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     t := sc.getCurrent()->toInteger() ; 
         while (t > 0) do (        t := t - 1 ;     skip ; (     n := sc.getCurrent()->toInteger() ; 
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var hm : Map(int,int) ; hm := Map{} ;
    var list : Sequence(int) ; list := Sequence{} ;
    list := list->including(a[0+1]) ; 
    var fas : int ; fas := 0 ;
    if (a[0+1] > a[1+1]) then (     fas := 1 ) else skip ; 
    var flag : int ; flag := 0 ;
        i := 0 ; while i < n do ( (         j := i + 1 ; while j < n do ( (     if (fas = 0) then (     if (a[j+1] < a[j - 1+1]) then (     list := list->including(a[j - 1+1]) ; 
     i := j - 2 ; 
     fas := 1 ; 
     break ) else skip ) else (     if (a[j+1] > a[j - 1+1]) then (     list := list->including(a[j - 1+1]) ; 
     i := j - 2 ; 
     fas := 0 ; 
     break ) else skip ) ;  
     if (j = n - 1) then (     flag := 1 ) else skip )  ;     j := j + 1 ) ; 
     if (flag = 1) then (     break ) else skip )  ;     i := i + 1 ) ; 
    list := list->including(a[n - 1+1]) ; 
    OclFile["System.out"].println(list->size()) ; 
        i := 0 ; while i < list->size() do ( (     OclFile["System.out"].print(list->at(i+1) + " ") )  ;     i := i + 1 ) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.util.*;
public class Main {
  public static String s,ans="Yes" ;
  public static HashMap<Character,Integer>h=new HashMap<Character,Integer>();
  public static void main(String[] args)throws FileNotFoundException {
    Scanner in=new Scanner(System.in);
    s=in.next();
    char[] sa=s.toCharArray();
    for(char c : sa){
      if(! h.containsKey(c))h.put(c,1);
      else h.put(c,h.get(c)+1);
    }
    for(char c : h.keySet()){
      if(h.get(c)% 2==1){
        ans="No" ;
        break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : String;
  static   attribute h : Map(String,int) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     s := in.getCurrent() ; 
    var sa : Sequence(String) ; sa := s->characters() ;
    for (c : sa) do ( (     if (not(h->keys()->includes(c))) then     h := h->union(Map{c |-> 1}) ; else     h := h->union(Map{c |-> h->at(c) + 1}) ; )  ) ; 
    for (c : h->keys()) do ( (     if (h->at(c) mod 2 = 1) then (     ans := "No" ; 
     break ) else skip )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String keyBoard=sc.next();
    int inputSize=keyBoard.length();
    boolean beautifulFlag=true ;
    List<String>wordList=new ArrayList<String>();
    for(int i=0 ; i<inputSize ; i++){
      wordList.add(keyBoard.substring(i,i+1));
    }
    Collections.sort(wordList);
    for(int i=0 ; i<wordList.size(); i++){
      String word=wordList.get(0);
      int wordCount=wordList.lastIndexOf(word)+1 ;
      if(wordCount % 2!=0){
        System.out.println("No");
        beautifulFlag=false ;
        break ;
      }
      for(int j=0 ; j<wordCount ; j++){
        wordList.remove(0);
      }
    }
    if(beautifulFlag){
      System.out.println("Yes");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var keyBoard : String ; keyBoard := sc.getCurrent() ;
    var inputSize : int ; inputSize := keyBoard->size() ;
    var beautifulFlag : boolean ; beautifulFlag := true ;
    var wordList : Sequence(String) ; wordList := Sequence{} ;
        var i : int ; i := 0 ; while i < inputSize do ( (     wordList := wordList->including(keyBoard.subrange(i+1,i + 1)) )  ;     i := i + 1 ) ; 
    wordList := wordList->sort() ; 
        var i : int ; i := 0 ; while i < wordList->size() do ( (     var word : String ; word := wordList->at(0+1) ;
     var wordCount : int ; wordCount := wordList->lastIndexOf(word)-1 + 1 ;
     if (wordCount mod 2 /= 0) then (     OclFile["System.out"].println("No") ; 
     beautifulFlag := false ; 
     break ) else skip ; 
         var j : int ; j := 0 ; while j < wordCount do ( (     wordList := wordList->excludingAt(0+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (beautifulFlag) then (     OclFile["System.out"].println("Yes") ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.Map.Entry ;
public class Main {
  public static void main(String[] args){
    try {
      InputStreamReader isr=new InputStreamReader(System.in);
      BufferedReader br=new BufferedReader(isr);
      String w=br.readLine();
      HashMap<String,Integer>map=new HashMap<String,Integer>();
      for(int i=0 ; i<w.length(); i++){
        String tmp=w.substring(i,i+1);
        if(map.containsKey(tmp)){
          int val=map.get(tmp);
          map.put(tmp,val+1);
        }
        else {
          map.put(tmp,1);
        }
      }
      boolean flag=true ;
      for(Entry<String,Integer>ent : map.entrySet()){
        int val=ent.getValue();
        if(val % 2!=0){
          flag=false ;
          break ;
        }
      }
      if(flag){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
    var w : String ; w := br.readLine() ;
    var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < w->size() do ( (     var tmp : String ; tmp := w.subrange(i+1,i + 1) ;
     if (map->keys()->includes(tmp)) then (     var val : int ; val := map->at(tmp) ;
     map := map->union(Map{tmp |-> val + 1}) ) else (     map := map->union(Map{tmp |-> 1}) ) )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := true ;
    for (ent : map->asSet()) do ( (     var val : int ; val := ent.getValue() ;
     if (val mod 2 /= 0) then (     flag := false ; 
     break ) else skip )  ) ; 
    if (flag) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in),32768);
  static PrintWriter out=new PrintWriter(System.out);
  static StringTokenizer t ;
  static String sn(){
    while(t==null || ! t.hasMoreTokens()){
      try {
        t=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        throw new RuntimeException();
      }
    }
    return t.nextToken();
  }
  static int ni(){
    return Integer.parseInt(sn());
  }
  static long nlo(){
    return Long.parseLong(sn());
  }
  public static void main(String args[]){
    int t=1 ;
    while(t-->0){
      solve();
    }
    out.close();
  }
  static long mod=998244353 ;
  static long pro(long a,long b){
    return(a % mod*b % mod)% mod ;
  }
  static long add(long a,long b){
    return(a+b)% mod ;
  }
  static int maxn=200005 ;
  static void solve(){
    char c[]=sn().toCharArray();
    int n=c.length ;
    int f[]=new int[26];
    for(int i=0 ; i<n ; i++)f[c[i]-'a']++;
    int ff=0 ;
    for(int i=0 ; i<26 ; i++){
      if(f[i]>0 && f[i] % 2!=0){
        ff=1 ;
        out.println("No");
        break ;
      }
    }
    if(ff==0)out.println("Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 32768);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute t : OclIterator;
  static   operation sn() : String
  pre: true
  post: true
  activity: (     while (t = null or not(t.hasNext())) do (     try (     t := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     error ProgramException() )
 ) ; 
     return t.next() );
  static   operation ni() : int
  pre: true
  post: true
  activity: (     return (sn())->toInteger() );
  static   operation nlo() : long
  pre: true
  post: true
  activity: (     return (sn())->toLong() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) ;  
     skip );
  static   attribute mod : long := 998244353;
  static   operation pro( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a mod mod * b mod mod) mod mod );
  static   operation add( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a + b) mod mod );
  static   attribute maxn : int := 200005;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var c : Sequence(String) ; c := sn()->characters() ;
     var n : int ; n := c->size() ;
    var f : Sequence(int) ; f := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     f[c[i+1] - ('a')->char2byte()+1] := f[c[i+1] - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    var ff : int ; ff := 0 ;
        var i : int ; i := 0 ; while i < 26 do ( (     if (f[i+1] > 0 & f[i+1] mod 2 /= 0) then (     ff := 1 ; 
     skip ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (ff = 0) then     skip ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.HashMap ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String w=sc.next();
    char[] c=w.toCharArray();
    HashMap<Character,Integer>map=new HashMap<Character,Integer>();
    for(int i=0 ; i<w.length(); i++){
      if(map.containsKey(c[i])){
        map.put(c[i],map.get(c[i])+1);
        continue ;
      }
      map.put(c[i],1);
    }
    for(Character key : map.keySet()){
      if(map.get(key)% 2==1){
        System.out.println("No");
        return ;
      }
    }
    System.out.println("Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : String ; w := sc.getCurrent() ;
    var c : Sequence(String) ; c := w->characters() ;
    var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < w->size() do ( (     if (map->keys()->includes(c[i+1])) then (     map := map->union(Map{c[i+1] |-> map->at(c[i+1]) + 1}) ; 
     continue ) else skip ; 
     map := map->union(Map{c[i+1] |-> 1}) )  ;     i := i + 1 ) ; 
    for (key : map->keys()) do ( (     if (map->at(key) mod 2 = 1) then (     OclFile["System.out"].println("No") ; 
     return ) else skip )  ) ; 
    OclFile["System.out"].println("Yes") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class demo1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt()-1 ;
    int a=1 ;
    int b=0 ;
    String ax=sc.next();
    String bx=null ;
    while(n-->0){
      String k=sc.next();
      if(! k.equals(ax)){
        b++;
        if(bx==null)bx=k ;
      }
      else {
        a++;
      }
    }
    System.out.println(a>b ? ax : bx);
  }
}
------------------------------------------------------------
OCL File:
---------
 class demo1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() - 1 ;
    var a : int ; a := 1 ;
    var b : int ; b := 0 ;
    var ax : String ; ax := sc.getCurrent() ;
    var bx : String ; bx := null ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var k : String ; k := sc.getCurrent() ;
     if (not(k = ax)) then (     b := b + 1 ; 
     if (bx = null) then     bx := k ; else skip ) else (     a := a + 1 ) ) ;  ) ;  
    OclFile["System.out"].println(if a > b then ax else bx endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPrime(int n){
    int flag=1 ;
    for(int i=2 ; i*i<=n ; i++){
      if(n % i==0){
        flag=0 ;
        break ;
      }
    }
    return(flag==1 ? true : false);
  }
  static boolean isPerfectSquare(int x){
    double sr=Math.sqrt(x);
    return((sr-Math.floor(sr))==0);
  }
  static int countInterestingPrimes(int n){
    int answer=0 ;
    for(int i=2 ; i<=n ; i++){
      if(isPrime(i)){
        for(int j=1 ; j*j*j*j<=i ; j++){
          if(isPerfectSquare(i-j*j*j*j)){
            answer++;
            break ;
          }
        }
      }
    }
    return answer ;
  }
  public static void main(String[] args){
    int N=10 ;
    System.out.print(countInterestingPrimes(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     var flag : int ; flag := 1 ;
         var i : int ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     flag := 0 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     return (if flag = 1 then true else false endif) );
  static   operation isPerfectSquare( x : int) : boolean
  pre: true
  post: true
  activity: (     var sr : double ; sr := (x)->sqrt() ;
     return ((sr - (sr)->floor()) = 0) );
  static   operation countInterestingPrimes( n : int) : int
  pre: true
  post: true
  activity: (     var answer : int ; answer := 0 ;
         var i : int ; i := 2 ; while i <= n do ( (     if (isPrime(i)) then (         var j : int ; j := 1 ; while j * j * j * j <= i do ( (     if (isPerfectSquare(i - j * j * j * j)) then (     answer := answer + 1 ; 
     break ) else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
     return answer );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 10 ;
     OclFile["System.out"].print(countInterestingPrimes(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    Distance[] dis=new Distance[n+1];
    for(int i=1 ; i<=n ; i++)dis[i]=new Distance();
    for(int i=0 ; i<2*n ; i++){
      int a=in.nextInt();
      if(dis[a] .f==0)dis[a] .f=(i+1);
      else dis[a] .s=(i+1);
    }
    long ans=0 ;
    long prev=1 ;
    for(int i=1 ; i<=n ; i++){
      ans+=Math.abs(dis[i] .f-prev);
      prev=dis[i] .f ;
    }
    prev=1 ;
    for(int i=1 ; i<=n ; i++){
      ans+=Math.abs(dis[i] .s-prev);
      prev=dis[i] .s ;
    }
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
  static class Distance {
    long f,s ;
    Distance(){
      f=0 ;
      s=0 ;
    }
    @ Override public String toString(){
      return f+" "+s ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var dis : Sequence(Distance) ; dis := Integer.subrange(1,n + 1)->collect(null) ;
        var i : int ; i := 1 ; while i <= n do (     dis[i+1] := Distance.newDistance() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 2 * n do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     if (dis[a+1].f = 0) then     dis[a+1].f := (i + 1) ; else     dis[a+1].s := (i + 1) ; )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var prev : long ; prev := 1 ;
        var i : int ; i := 1 ; while i <= n do ( (     ans := ans+(if dis[i+1].f - prev < 0 then -(dis[i+1].f - prev) else dis[i+1].f - prev endif) ; 
     prev := dis[i+1].f )  ;     i := i + 1 ) ; 
    prev := 1 ; 
        var i : int ; i := 1 ; while i <= n do ( (     ans := ans+(if dis[i+1].s - prev < 0 then -(dis[i+1].s - prev) else dis[i+1].s - prev endif) ; 
     prev := dis[i+1].s )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
  static class Distance {
   attribute f : long;
   static operation newDistance() : Distance
  pre: true
  post: true
  activity:
  ( var self : Distance ;
    self := createDistance();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     f := 0 ; 
     s := 0 );
      operation toString() : String
  pre: true
  post: true
  activity: (     return f + " " + s );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner in=new Scanner(System.in)){
      solve(in);
    }
  }
  private static void solve(Scanner in){
    for(int i=1 ; i<=9 ; i++){
      for(int j=1 ; j<=9 ; j++){
        System.out.println(i+"x"+j+"="+i*j);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     execute solve(in) ))  );
  static   operation solve( in : OclFile) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= 9 do ( (         var j : int ; j := 1 ; while j <= 9 do ( (     OclFile["System.out"].println(i + "x" + j + "=" + i * j) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import sun.font.FontRunIterator ;
import java.util.*;
import java.util.ArrayList ;
public class codforce {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int x=scan.nextInt();
    String[] arr=new String[x];
    for(int i=0 ; i<x ; i++){
      arr[i]=scan.next();
    }
    Arrays.sort(arr);
    String g=arr[0];
    String g1=arr[arr.length-1];
    int count=0,count1=0 ;
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i] .equals(g)){
        count++;
      }
      else {
        count1++;
      }
    }
    if(count>count1){
      System.out.println(g);
    }
    else {
      System.out.println(g1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codforce {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := scan.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := Integer.subrange(1,x)->collect(null) ;
        var i : int ; i := 0 ; while i < x do ( (     arr[i+1] := scan.getCurrent() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var g : String ; g := arr[0+1] ;
    var g1 : String ; g1 := arr[arr->size() - 1+1] ;
    var count : int ; count := 0 ;
    var count1 : int ; count1 := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = g) then (     count := count + 1 ) else (     count1 := count1 + 1 ) )  ;     i := i + 1 ) ; 
    if (count > count1) then (     OclFile["System.out"].println(g) ) else (     OclFile["System.out"].println(g1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Problem_43A_Football {
  public static FastScanner fs=new FastScanner();
  public static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    out.println(solve());
    out.close();
  }
  public static String solve(){
    int n=fs.nextInt();
    String team1=fs.next();
    if(n==1)return team1 ;
    int score1=1,score2=0 ;
    String team2=new String();
    for(int i=2 ; i<=n ; i++){
      String teamScored=fs.next();
      if(teamScored.equals(team1))score1++;
      else {
        team2=teamScored ;
        score2++;
      }
    }
    if(team2.equals(null))return team1 ;
    return(score1>score2)? team1 : team2 ;
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  public static String toString(char[] a){
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<a.length ; i++){
      sb.append(a[i]);
    }
    return sb.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem_43A_Football {
  static   attribute fs : FastScanner := FastScanner.newFastScanner();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     skip ; 
     skip );
  static   operation solve() : String
  pre: true
  post: true
  activity: (     var n : int ; n := fs.nextInt() ;
     var team1 : String ; team1 := fs.next() ;
    if (n = 1) then     return team1 else skip ; 
    var score1 : int ; score1 := 1 ;
    var score2 : int ; score2 := 0 ;
    var team2 : String ; team2 := StringLib.newString() ;
        var i : int ; i := 2 ; while i <= n do ( (     var teamScored : String ; teamScored := fs.next() ;
     if (teamScored = team1) then     score1 := score1 + 1 ; else (     team2 := teamScored ; 
     score2 := score2 + 1 ) )  ;     i := i + 1 ) ; 
    if (team2 = null) then     return team1 else skip ; 
    return if (score1 > score2) then team1 else team2 endif 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   operation toString( a : Sequence(String)) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < a->size() do ( (     sb := sb + StringLib.newString(a[i+1]) )  ;     i := i + 1 ) ; 
     return sb+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
public class string {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    HashMap<String,Integer>map=new HashMap<>();
    while(n-->0){
      String s=br.readLine();
      if(map.containsKey(s)){
        map.put(s,map.get(s)+1);
      }
      else {
        map.put(s,1);
      }
    }
    Object[] val=map.values().toArray();
    int max=Integer.MIN_VALUE ;
    for(int i=0 ; i<val.length ; i++){
      if((int)val[i]>max){
        max=(int)val[i];
      }
    }
    for(String key : map.keySet()){
      if(max==map.get(key)){
        System.out.println(key);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class string {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var map : Map(String,int) ; map := Map{} ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var s : String ; s := br.readLine() ;
     if (map->keys()->includes(s)) then (     map := map->union(Map{s |-> map->at(s) + 1}) ) else (     map := map->union(Map{s |-> 1}) ) ) ;  ) ;  
    var val : Sequence(OclAny) ; val := map->values()->asSequence() ;
    var max : int ; max := -2147483648 ;
        var i : int ; i := 0 ; while i < val->size() do ( (     if (val[i+1]->oclAsType(int) > max) then (     max := val[i+1]->oclAsType(int) ) else skip )  ;     i := i + 1 ) ; 
    for (key : map->keys()) do ( (     if (max = map->at(key)) then (     OclFile["System.out"].println(key) ; 
     return ) else skip )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class kfc {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt()-1 ;
    String str=sc.next();
    String tt=null ;
    int cnt1=0 ;
    int cnt2=1 ;
    while(a-->0){
      String te=sc.next();
      if(! te.equals(str)){
        cnt1++;
        if(tt==null)tt=te ;
      }
      else {
        cnt2++;
      }
    }
    System.out.println(cnt2>cnt1 ? str : tt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class kfc {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
    var str : String ; str := sc.getCurrent() ;
    var tt : String ; tt := null ;
    var cnt1 : int ; cnt1 := 0 ;
    var cnt2 : int ; cnt2 := 1 ;
        while (a > 0) do (        a := a - 1 ;     skip ; (     var te : String ; te := sc.getCurrent() ;
     if (not(te = str)) then (     cnt1 := cnt1 + 1 ; 
     if (tt = null) then     tt := te ; else skip ) else (     cnt2 := cnt2 + 1 ) ) ;  ) ;  
    OclFile["System.out"].println(if cnt2 > cnt1 then str else tt endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(true){
      int n=in.nextInt();
      if(n==0)break ;
      String W[]=new String[n];
      for(int i=0 ; i<n ; i++)W[i]=in.next();
      int tanku[]={
        5,7,5,7,7 },i ;
        for(i=0 ; i<n-4 ; i++){
          boolean ck=true ;
          int sum=0,j=i,k=0 ;
          while(true){
            if(k==5)break ;
            sum+=W[j] .length();
            j++;
            if(sum>tanku[k]){
              ck=false ;
              break ;
            }
            else if(sum==tanku[k]){
              k++;
              sum=0 ;
            }
          }
          if(ck)break ;
        }
        System.out.println(i+1);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var W : Sequence(String) ; W := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     W[i+1] := in.getCurrent() ;  ;     i := i + 1 ) ; 
    var tanku : Sequence(int) ; tanku := Sequence{5,7,5,7,7} ;
    var i : int ;
        i := 0 ; while i < n - 4 do ( (     var ck : boolean ; ck := true ;
     var sum : int ; sum := 0 ;
    var j : int ; j := i ;
    var k : int ; k := 0 ;
     while (true) do (     if (k = 5) then     break else skip ; 
     sum := sum+(W[j+1]->size()) ; 
     j := j + 1 ; 
     if (sum > tanku[k+1]) then (     ck := false ; 
     break ) else     if (sum = tanku[k+1]) then (     k := k + 1 ; 
     sum := 0 ) else skip ; ) ; 
     if (ck) then     break else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(i + 1) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  private static boolean match(int[] pattern,int[] s,int pos){
    int sp=0 ;
    int cr=0 ;
    for(int i=pos ; i<s.length ; ++i){
      cr+=s[i];
      if(pattern[sp]<cr)break ;
      if(pattern[sp]==cr){
++sp ;
        cr=0 ;
        if(sp==pattern.length)return true ;
      }
    }
    return false ;
  }
  private static int match(int[] pattern,int[] s){
    for(int i=0 ; i<s.length ; ++i){
      if(match(pattern,s,i))return i ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    try(java.util.Scanner sc=new java.util.Scanner(System.in)){
      for(; ; ){
        final int[] w=new int[sc.nextInt()];
        if(w.length==0)break ;
        for(int i=0 ; i<w.length ; ++i){
          w[i]=sc.next().length();
        }
        System.out.println(match(new int[] {
          5,7,5,7,7 },w)+1);
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation match( pattern : Sequence(int), s : Sequence(int), pos : int) : boolean
  pre: true
  post: true
  activity: (     var sp : int ; sp := 0 ;
     var cr : int ; cr := 0 ;
         var i : int ; i := pos ; while i < s->size() do ( (     cr := cr+(s[i+1]) ; 
     if (pattern[sp+1] < cr) then     break else skip ; 
     if (pattern[sp+1] = cr) then (     sp := sp + 1 ; 
     cr := 0 ; 
     if (sp = pattern->size()) then     return true else skip ) else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation match( pattern : Sequence(int), s : Sequence(int)) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() do ( (     if (match(pattern, s, i)) then     return i else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : Scanner := Scanner.newScanner(OclFile["System.in"]) ;
 (       while true do ( (     var w : Sequence(int) ; w := Integer.subrange(1,sc.nextInt())->collect(0) ;
     if (w->size() = 0) then     break else skip ; 
         var i : int ; i := 0 ; while i < w->size() do ( (     w[i+1] := sc.next()->size() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(match(Sequence{5,7,5,7,7}, w) + 1) )  ) ))  );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  static final Scanner s=new Scanner(System.in);
  static int getInt(){
    return Integer.parseInt(s.next());
  }
  static IntStream REPS(int l){
    return IntStream.range(0,l);
  }
  static List<Integer>hoge=Arrays.asList(5,12,17,24,31);
  public static void main(String[] __){
    ArrayDeque<Integer>d=new ArrayDeque<>();
    cases : while(true){
      int n=getInt();
      if(n==0)return ;
      int[] in=REPS(n).map(i->s.next().length()).toArray();
      int[] psum=new int[n+1];
      for(int i=0 ; i<n ; i++)psum[i+1]=in[i];
      Arrays.parallelPrefix(psum,Integer :: sum);
      for(int i=1 ; i<=n ; i++){
        d.clear();
        d.addAll(hoge);
        int v=psum[i-1];
        IntStream.rangeClosed(i,n).map(w->psum[w]-v).forEach(w->{
          if(! d.isEmpty()&& d.peekFirst()==w)d.pollFirst();
        }
);
        if(d.isEmpty()){
          System.out.println(i);
          continue cases ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation REPS( l : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, l-1) );
  static   attribute hoge : Sequence(int) := Sequence{5,12,17,24,31};
  static   operation main( __ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : Sequence(int) ; d := ArrayDeque<OclAny>.newArrayDeque() ;
     while (true) do (     var n : int ; n := getInt() ;
     if (n = 0) then     return else skip ; 
    var in : Sequence(int) ; in := REPS(n)->collect( _x1 | (lambda i : OclAny in s.getCurrent()->size())->apply(_x1) )->asSequence() ;
    var psum : Sequence(int) ; psum := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     psum[i + 1+1] := in[i+1] ;  ;     i := i + 1 ) ; 
parallelPrefix(psum, lambda _pars : OclAny in Integer.newInteger().sum(_pars)) ; 
        var i : int ; i := 1 ; while i <= n do ( (     d := d->intersection(Set{}) ; 
     d := d->union(hoge) ; 
    var v : int ; v := psum[i - 1+1] ;
    for w : Integer.subrange(i, n)->collect( _x1 | (lambda w : OclAny in psum[w+1] - v)->apply(_x1) ) do
    (    skip) ; 
    if (d->isEmpty()) then (     OclFile["System.out"].println(i) ; 
     continue ) else skip ; 
 )  ;     i := i + 1 ) ; 
 ) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  static final int CHARS=31 ;
  static final int[] WORDS=new int[] {
    5,7,5,7,7 };
    public static void main(String[] args)throws IOException {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String line ;
      while((line=br.readLine())!=null && ! line.isEmpty()){
        int n=parseInt(line);
        if(n==0)break ;
        int[] words=new int[n+1];
        for(int i=1 ; i<=n ; i++){
          words[i]=br.readLine().length();
          words[i]+=words[i-1];
        }
        int k=0 ;
        outer : for(int i=1 ;
        i<=n ;
        i++){
          for(int j=n ; j>=i ; j--){
            if(words[j]-words[i-1]==CHARS){
              if(check(words,i,j)){
                k=i ;
                break outer ;
              }
            }
          }
        }
        System.out.println(k);
      }
    }
    static boolean check(int[] words,int from,int to){
      boolean ret=true ;
      int _j=from ;
      for(int i=0 ; i<WORDS.length ; i++){
        for(int j=_j ; j<=to ; j++){
          int len=words[j]-words[_j-1];
          if(len==WORDS[i]){
            _j=j+1 ;
            break ;
          }
          else if(len>WORDS[i]){
            ret &=false ;
          }
        }
      }
      return ret ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute CHARS : int := 31;
  static    attribute WORDS : Sequence(int) := Sequence{5,7,5,7,7};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := parseInt(line) ;
     if (n = 0) then     break else skip ; 
    var words : Sequence(int) ; words := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     words[i+1] := br.readLine()->size() ; 
     words[i+1] := words[i+1]+(words[i - 1+1]) )  ;     i := i + 1 ) ; 
    var k : int ; k := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := n ; while j >= i do ( (     if (words[j+1] - words[i - 1+1] = CHARS) then (     if (check(words, i, j)) then (     k := i ; 
     break ) else skip ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(k) ; 
 ) ;     line := br.readLine() ;
 ) );
  static   operation check( words : Sequence(int), from : int, to : int) : boolean
  pre: true
  post: true
  activity: (     var ret : boolean ; ret := true ;
     var _j : int ; _j := from ;
         var i : int ; i := 0 ; while i < WORDS->size() do ( (         var j : int ; j := _j ; while j <= to do ( (     var len : int ; len := words[j+1] - words[_j - 1+1] ;
     if (len = WORDS[i+1]) then (     _j := j + 1 ; 
     break ) else     if (len > WORDS[i+1]) then (     ret := MathLib.bitwiseAnd(ret, false) ) else skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int check(int[] letters,int start,int type){
    int len=0 ;
    for(int i=start ; i<letters.length && len<type ; i++){
      len+=letters[i];
      if(len==type){
        return i+1 ;
      }
    }
    return-1 ;
  }
  static boolean tanku(int[] letters,int start){
    int[] ku={
      5,7,5,7,7 };
      for(int type : ku){
        start=check(letters,start,type);
        if(start==-1)return false ;
      }
      return true ;
    }
    public static void main(String[] args){
      Scanner sc=new Scanner(System.in);
      while(true){
        int n=sc.nextInt();
        if(n==0)break ;
        String[] words=new String[n];
        int[] letters=new int[n];
        for(int i=0 ; i<n ; i++){
          words[i]=sc.next();
          letters[i]=words[i] .length();
        }
        int flag=0 ;
        for(int i=0 ; i<n && flag==0 ; i++){
          if(tanku(letters,i)){
            System.out.println(i+1);
            flag=-1 ;
            break ;
          }
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation check( letters : Sequence(int), start : int, type : int) : int
  pre: true
  post: true
  activity: (     var len : int ; len := 0 ;
         var i : int ; i := start ; while i < letters->size() & len < type do ( (     len := len+(letters[i+1]) ; 
     if (len = type) then (     return i + 1 ) else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation tanku( letters : Sequence(int), start : int) : boolean
  pre: true
  post: true
  activity: (     var ku : Sequence(int) ; ku := Sequence{5,7,5,7,7} ;
     for (type : ku) do ( (     start := check(letters, start, type) ; 
     if (start = -1) then     return false else skip )  ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var words : Sequence(String) ; words := Integer.subrange(1,n)->collect(null) ;
    var letters : Sequence(int) ; letters := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     words[i+1] := sc.getCurrent() ; 
     letters[i+1] := words[i+1]->size() )  ;     i := i + 1 ) ; 
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < n & flag = 0 do ( (     if (tanku(letters, i)) then (     OclFile["System.out"].println(i + 1) ; 
     flag := -1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class TwoCakes {
  public static void main(String[] args){
    FastReader in=new FastReader();
    int n=in.nextInt();
    int a[]=new int[n+1];
    int b[]=new int[n+1];
    for(int i=1 ; i<=2*n ; i++){
      int c=in.nextInt();
      if(a[c]==0)a[c]=i ;
      else b[c]=i ;
    }
    long ans=0 ;
    long p=1,q=1 ;
    for(int i=1 ; i<=n ; i++){
      ans+=Math.abs(p-a[i]);
      p=a[i];
      ans+=Math.abs(q-b[i]);
      q=b[i];
    }
    System.out.println(ans);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TwoCakes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var n : int ; n := in.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= 2 * n do ( (     var c : int ; c := in.nextInt() ;
     if (a[c+1] = 0) then     a[c+1] := i ; else     b[c+1] := i ; )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var p : long ; p := 1 ;
    var q : long ; q := 1 ;
        var i : int ; i := 1 ; while i <= n do ( (     ans := ans+(if p - a[i+1] < 0 then -(p - a[i+1]) else p - a[i+1] endif) ; 
     p := a[i+1] ; 
     ans := ans+(if q - b[i+1] < 0 then -(q - b[i+1]) else q - b[i+1] endif) ; 
     q := b[i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int n=3 ;
  static class pair {
    int first,second ;
    public pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static void findPrefixCount(int p_arr[][],boolean arr[][]){
    for(int i=0 ; i<n ; i++)for(int j=n-1 ; j>=0 ; j--){
      if(arr[i][j])continue ;
      if(j!=n-1)p_arr[i][j]+=p_arr[i][j+1];
      p_arr[i][j]+=(arr[i][j]==false ? 1 : 0);
    }
  }
  static int matrixOrValueOne(boolean arr[][]){
    int[][] p_arr=new int[n][n];
    findPrefixCount(p_arr,arr);
    int count_zero_submatrices=0 ;
    for(int j=0 ; j<n ; j++){
      int i=n-1 ;
      Stack<pair>q=new Stack<pair>();
      int to_sum=0 ;
      while(i>=0){
        int c=0 ;
        while(q.size()!=0 && q.peek().first>p_arr[i][j]){
          to_sum-=(q.peek().second+1)*(q.peek().first-p_arr[i][j]);
          c+=q.peek().second+1 ;
          q.pop();
        }
        to_sum+=p_arr[i][j];
        count_zero_submatrices+=to_sum ;
        q.add(new pair(p_arr[i][j],c));
        i--;
      }
    }
    return(n*(n+1)*n*(n+1))/4-count_zero_submatrices ;
  }
  public static void main(String[] args){
    boolean arr[][]={
      {
        false,false,false },{
          false,true,false },{
            false,false,false }
          };
          System.out.println(matrixOrValueOne(arr));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute n : int := 3;
  static class pair {
   attribute first : int;
   static operation newpair( first : int, second : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation findPrefixCount( p_arr : Sequence(Sequence(int)), arr : Sequence(Sequence(boolean))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (         var j : int ; j := n - 1 ; while j >= 0 do ( (     if (arr[i+1][j+1]) then     continue else skip ; 
     if (j /= n - 1) then     p_arr[i+1][j+1] := p_arr[i+1][j+1]+(p_arr[i+1][j + 1+1]) ; else skip ; 
     p_arr[i+1][j+1] := p_arr[i+1][j+1]+((if arr[i+1][j+1] = false then 1 else 0 endif)) )  ;     j := j - 1 ) ;  ;     i := i + 1 ) );
  static   operation matrixOrValueOne( arr : Sequence(Sequence(boolean))) : int
  pre: true
  post: true
  activity: (     var p_arr : Sequence(Sequence(int)) ; p_arr := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
     execute findPrefixCount(p_arr, arr) ; 
    var count_zero_submatrices : int ; count_zero_submatrices := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     var i : int ; i := n - 1 ;
     var q : Sequence(pair) ; q := Sequence{} ;
     var to_sum : int ; to_sum := 0 ;
     while (i >= 0) do (     var c : int ; c := 0 ;
     while (q->size() /= 0 & q->min()->at("first") > p_arr[i+1][j+1]) do (     to_sum := to_sum-((q->min()->at("second") + 1) * (q->min()->at("first") - p_arr[i+1][j+1])) ; 
     c := c+(q->min()->at("second") + 1) ; 
     q := q->front() ) ; 
    to_sum := to_sum+(p_arr[i+1][j+1]) ; 
    count_zero_submatrices := count_zero_submatrices+(to_sum) ; 
    q := q->including(pair.newpair(p_arr[i+1][j+1], c)) ; 
    i := i - 1 ; 
 ) )  ;     j := j + 1 ) ; 
    return (n * (n + 1) * n * (n + 1)) / 4 - count_zero_submatrices 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(boolean)) ; arr := Sequence{Sequence{false,false,false},Sequence{false,true,false},Sequence{false,false,false}} ;
     OclFile["System.out"].println(matrixOrValueOne(arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  public static void main(String[] a){
    int x=0 ;
    int y=0 ;
    int z=0 ;
    for(x=1 ; x<=9 ; x++){
      for(y=1 ; y<=9 ; y++){
        z=x*y ;
        System.out.println(x+"x"+y+"="+z);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 0 ;
     var y : int ; y := 0 ;
     var z : int ; z := 0 ;
         x := 1 ; while x <= 9 do ( (         y := 1 ; while y <= 9 do ( (     z := x * y ; 
     OclFile["System.out"].println(x + "x" + y + "=" + z) )  ;     y := y + 1 ) )  ;     x := x + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=1000000 ;
    boolean[] map=new boolean[N+1];
    for(int i=1 ; i<=N ; i*=2){
      for(int j=1 ; i*j<=N ; j*=3){
        for(int k=1 ; i*j*k<=N ; k*=5){
          int s=i*j*k ;
          map[s]=true ;
        }
      }
    }
    int c=0 ;
    int[] num=new int[N+1];
    for(int i=1 ; i<=N ; i++){
      if(map[i])c++;
      num[i]=c ;
    }
    while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      int m=scanner.nextInt();
      System.out.println(num[m]-num[n-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := 1000000 ;
    var map : Sequence(boolean) ; map := Integer.subrange(1,N + 1)->collect(false) ;
        var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := 1 ; while i * j <= N do ( (         var k : int ; k := 1 ; while i * j * k <= N do ( (     var s : int ; s := i * j * k ;
     map[s+1] := true )  ;     k := k*(5) ) )  ;     j := j*(3) ) )  ;     i := i*(2) ) ; 
    var c : int ; c := 0 ;
    var num : Sequence(int) ; num := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do ( (     if (map[i+1]) then     c := c + 1 ; else skip ; 
     num[i+1] := c )  ;     i := i + 1 ) ; 
    while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
     var m : int ; m := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(num[m+1] - num[n - 1+1]) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    final int SIZE=1000000+10 ;
    boolean[] is=new boolean[SIZE];
    is[1]=true ;
    int[] count=new int[SIZE];
    for(int i=1 ; i<SIZE ; i++){
      if(is[i]){
        if(i*2<SIZE)is[i*2]=true ;
        if(i*3<SIZE)is[i*3]=true ;
        if(i*5<SIZE)is[i*5]=true ;
      }
      count[i]=count[i-1]+(is[i] ? 1 : 0);
    }
    for(; sc.hasNext(); ){
      int from=sc.nextInt();
      if(from==0)break ;
      int to=sc.nextInt();
      int ans=count[to]-count[from-1];
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var SIZE : int ; SIZE := 1000000 + 10 ;
     var is : Sequence(boolean) ; is := Integer.subrange(1,SIZE)->collect(false) ;
    is[1+1] := true ; 
    var count : Sequence(int) ; count := Integer.subrange(1,SIZE)->collect(0) ;
        var i : int ; i := 1 ; while i < SIZE do ( (     if (is[i+1]) then (     if (i * 2 < SIZE) then     is[i * 2+1] := true ; else skip ; 
     if (i * 3 < SIZE) then     is[i * 3+1] := true ; else skip ; 
     if (i * 5 < SIZE) then     is[i * 5+1] := true ; else skip ) else skip ; 
     count[i+1] := count[i - 1+1] + (if is[i+1] then 1 else 0 endif) )  ;     i := i + 1 ) ; 
      while sc.hasNext() do ( (     var from : int ; from := sc.getCurrent()->toInteger() ;
     if (from = 0) then     break else skip ; 
    var to : int ; to := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := count[to+1] - count[from - 1+1] ;
    OclFile["System.out"].println(ans) ; 
 )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader reader=new BufferedReader(isr);
    String string ;
    int count ;
    boolean hamming[]=new boolean[1000001];
    hamming[1]=true ;
    int num[]=new int[] {
      2,3,5 };
      for(int i=0 ; i<3 ; i++){
        for(int j=1 ; j*num[i]<1000001 ; j++){
          if(hamming[j*num[i] ])continue ;
          if(j*num[i] % num[i]==0 && hamming[j*num[i]/num[i] ])hamming[j*num[i] ]=true ;
        }
      }
      while(!(string=reader.readLine()).equals("0")){
        count=0 ;
        for(int i=Integer.valueOf(string.split(" ")[0]); i<=Integer.valueOf(string.split(" ")[1]); i++){
          if(hamming[i])count++;
        }
        System.out.println(count);
      }
      reader.close();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(isr) ;
    var string : String ;
    var count : int ;
    var hamming : Sequence(boolean) ; hamming := Integer.subrange(1,1000001)->collect(false) ;
    hamming[1+1] := true ; 
    var num : Sequence(int) ; num := Sequence{2,3,5} ;
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 1 ; while j * num[i+1] < 1000001 do ( (     if (hamming[j * num[i+1]+1]) then     continue else skip ; 
     if (j * num[i+1] mod num[i+1] = 0 & hamming[j * num[i+1] / num[i+1]+1]) then     hamming[j * num[i+1]+1] := true ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    while (not((string) = "0")) do (     count := 0 ; 
         var i : int ; i := (string->split(" ")[0+1])->toInteger() ; while i <= (string->split(" ")[1+1])->toInteger() do ( (     if (hamming[i+1]) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    int max=1000001 ;
    int[] memo=new int[max];
    boolean[] f=new boolean[max];
    LinkedList<Integer>que=new LinkedList<Integer>();
    que.offer(1);
    f[1]=true ;
    int[] ms={
      2,3,5 };
      for(; ! que.isEmpty(); ){
        int n=que.poll();
        for(int m : ms){
          if(n*m<max && ! f[m*n]){
            que.offer(n*m);
            f[n*m]=true ;
          }
        }
      }
      for(int i=1 ; i<max ; i++){
        memo[i]=memo[i-1]+(f[i] ? 1 : 0);
      }
      for(; ; ){
        int m=sc.nextInt();
        if(m==0){
          break ;
        }
        int n=sc.nextInt();
        println(""+(memo[n]-memo[m-1]));
      }
    }
    void debug(Object...os){
      System.err.println(Arrays.deepToString(os));
    }
    void print(String s){
      System.out.print(s);
    }
    void println(String s){
      System.out.println(s);
    }
    public static void main(String[] args){
      new Main().run();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     var max : int ; max := 1000001 ;
     var memo : Sequence(int) ; memo := Integer.subrange(1,max)->collect(0) ;
    var f : Sequence(boolean) ; f := Integer.subrange(1,max)->collect(false) ;
    var que : Sequence(int) ; que := Sequence{} ;
    que := que->including(1) ; 
    f[1+1] := true ; 
    var ms : Sequence(int) ; ms := Sequence{2,3,5} ;
      while not(que->isEmpty()) do ( (     var n : int ; n := que->min() ;
     for (m : ms) do ( (     if (n * m < max & not(f[m * n+1])) then (     que := que->including(n * m) ; 
     f[n * m+1] := true ) else skip )  ) )  ) ; 
        var i : int ; i := 1 ; while i < max do ( (     memo[i+1] := memo[i - 1+1] + (if f[i+1] then 1 else 0 endif) )  ;     i := i + 1 ) ; 
      while true do ( (     var m : int ; m := sc.getCurrent()->toInteger() ;
     if (m = 0) then (     break ) else skip ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
     execute println("" + (memo[n+1] - memo[m - 1+1])) )  ) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(stdIn.hasNext()){
      int s=stdIn.nextInt();
      if(s==0){
        break ;
      }
      int t=stdIn.nextInt();
      Queue<Integer>que1=new ArrayDeque<Integer>();
      Queue<Integer>que2=new ArrayDeque<Integer>();
      boolean[] flag1=new boolean[t+1];
      boolean[] flag2=new boolean[s+1];
      int count1=0 ;
      int count2=0 ;
      if(s==1){
++count1 ;
      }
      que1.add(1);
      while(! que1.isEmpty()){
        int n=que1.poll();
        if(n*2<=t && ! flag1[n*2]){
          flag1[n*2]=true ;
          que1.add(n*2);
++count1 ;
        }
        if(n*3<=t && ! flag1[n*3]){
          flag1[n*3]=true ;
          que1.add(n*3);
++count1 ;
        }
        if(n*5<=t && ! flag1[n*5]){
          flag1[n*5]=true ;
          que1.add(n*5);
++count1 ;
        }
      }
      que2.add(1);
      while(! que2.isEmpty()){
        int n=que2.poll();
        if(n*2<s && ! flag2[n*2]){
          flag2[n*2]=true ;
          que2.add(n*2);
++count2 ;
        }
        if(n*3<s && ! flag2[n*3]){
          flag2[n*3]=true ;
          que2.add(n*3);
++count2 ;
        }
        if(n*5<s && ! flag2[n*5]){
          flag2[n*5]=true ;
          que2.add(n*5);
++count2 ;
        }
      }
      System.out.println(count1-count2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (stdIn.hasNext()) do (     var s : int ; s := stdIn.getCurrent()->toInteger() ;
     if (s = 0) then (     break ) else skip ; 
    var t : int ; t := stdIn.getCurrent()->toInteger() ;
    var que1 : Sequence(int) ; que1 := ArrayDeque<int>.newArrayDeque() ;
    var que2 : Sequence(int) ; que2 := ArrayDeque<int>.newArrayDeque() ;
    var flag1 : Sequence(boolean) ; flag1 := Integer.subrange(1,t + 1)->collect(false) ;
    var flag2 : Sequence(boolean) ; flag2 := Integer.subrange(1,s + 1)->collect(false) ;
    var count1 : int ; count1 := 0 ;
    var count2 : int ; count2 := 0 ;
    if (s = 1) then (     count1 := count1 + 1 ) else skip ; 
    que1 := que1->including(1) ; 
    while (not(que1->isEmpty())) do (     var n : int ; n := que1->min() ;
     if (n * 2 <= t & not(flag1[n * 2+1])) then (     flag1[n * 2+1] := true ; 
     que1 := que1->including(n * 2) ; 
     count1 := count1 + 1 ) else skip ; 
     if (n * 3 <= t & not(flag1[n * 3+1])) then (     flag1[n * 3+1] := true ; 
     que1 := que1->including(n * 3) ; 
     count1 := count1 + 1 ) else skip ; 
     if (n * 5 <= t & not(flag1[n * 5+1])) then (     flag1[n * 5+1] := true ; 
     que1 := que1->including(n * 5) ; 
     count1 := count1 + 1 ) else skip ) ; 
    que2 := que2->including(1) ; 
    while (not(que2->isEmpty())) do (     var n : int ; n := que2->min() ;
     if (n * 2 < s & not(flag2[n * 2+1])) then (     flag2[n * 2+1] := true ; 
     que2 := que2->including(n * 2) ; 
     count2 := count2 + 1 ) else skip ; 
     if (n * 3 < s & not(flag2[n * 3+1])) then (     flag2[n * 3+1] := true ; 
     que2 := que2->including(n * 3) ; 
     count2 := count2 + 1 ) else skip ; 
     if (n * 5 < s & not(flag2[n * 5+1])) then (     flag2[n * 5+1] := true ; 
     que2 := que2->including(n * 5) ; 
     count2 := count2 + 1 ) else skip ) ; 
    OclFile["System.out"].println(count1 - count2) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int counter=0 ;
    int n=sc.nextInt();
    int[] s=new int[n];
    for(int i=0 ; i<s.length ; i++){
      s[i]=sc.nextInt();
    }
    int q=sc.nextInt();
    int[] t=new int[q];
    for(int i=0 ; i<t.length ; i++){
      t[i]=sc.nextInt();
    }
    for(int i=0 ; i<t.length ; i++){
      for(int j=0 ; j<s.length ; j++){
        if(t[i]==s[j]){
          counter++;
          break ;
        }
      }
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var counter : int ; counter := 0 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     s[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,q)->collect(0) ;
        var i : int ; i := 0 ; while i < t->size() do ( (     t[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < t->size() do ( (         var j : int ; j := 0 ; while j < s->size() do ( (     if (t[i+1] = s[j+1]) then (     counter := counter + 1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int count=0 ;
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner sc2=new Scanner(System.in);
    boolean[] check=new boolean[10000000];
    for(int i=0 ; i<check.length ; i++)check[i]=false ;
    int n=Integer.parseInt(sc2.nextLine());
    String[] s=sc2.nextLine().split("[\\s]+");
    for(int i=0 ; i<n ; i++)check[Integer.parseInt(s[i])]=true ;
    int n2=Integer.parseInt(sc2.nextLine());
    String[] s2=sc2.nextLine().trim().split("[\\s]+");
    for(int i=0 ; i<n2 ; i++){
      if(check[Integer.parseInt(s2[i])]){
        count++;
        check[Integer.parseInt(s2[i])]=false ;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute count : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc2 : OclFile ; sc2 := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var check : Sequence(boolean) ; check := Integer.subrange(1,10000000)->collect(false) ;
        var i : int ; i := 0 ; while i < check->size() do (     check[i+1] := false ;  ;     i := i + 1 ) ; 
    var n : int ; n := (sc2.nextLine())->toInteger() ;
    var s : Sequence(String) ; s := sc2.nextLine()->split("[\\s]+") ;
        var i : int ; i := 0 ; while i < n do (     check[(s[i+1])->toInteger()+1] := true ;  ;     i := i + 1 ) ; 
    var n2 : int ; n2 := (sc2.nextLine())->toInteger() ;
    var s2 : Sequence(String) ; s2 := sc2.nextLine()->trim()->split("[\\s]+") ;
        var i : int ; i := 0 ; while i < n2 do ( (     if (check[(s2[i+1])->toInteger()+1]) then (     count := count + 1 ; 
     check[(s2[i+1])->toInteger()+1] := false ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(){
    java.util.Scanner sc=new java.util.Scanner(System.in);
    java.util.Set<Integer>lis=new java.util.TreeSet<Integer>();
    int res=0 ;
    int n ;
    int i ;
    n=sc.nextInt();
    for(i=0 ; i<n ; ++i)lis.add(sc.nextInt());
    n=sc.nextInt();
    for(i=0 ; i<n ; ++i)if(lis.contains(sc.nextInt()))++res ;
    System.out.println(res);
    return ;
  }
  public static void main(String[] args){
(new Main()).run();
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(OclFile["System.in"]) ;
     var lis : Set<int> ; lis := TreeSet<int>.newTreeSet() ;
    var res : int ; res := 0 ;
    var n : int ;
    var i : int ;
    n := sc.nextInt() ; 
        i := 0 ; while i < n do (     lis->excludes(sc.nextInt()) ;  ;     i := i + 1 ) ; 
    n := sc.nextInt() ; 
        i := 0 ; while i < n do (     if (lis->includes(sc.nextInt())) then     res := res + 1 ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
    return 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run() ; 
     return );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import java.awt.Point ;
import java.io.*;
public class Exercise {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int array[][]=new int[2][n+1];
    for(int i=1 ; i<=n*2 ; i++){
      int nm=sc.nextInt();
      if(array[0][nm]==0)array[0][nm]=i ;
      else array[1][nm]=i ;
    }
    int idxo=1,idxt=1 ;
    long sumo=0,sumt=0 ;
    for(int i=1 ; i<=n ; i++){
      sumo+=abs(array[0][i]-idxo);
      sumt+=abs(array[1][i]-idxt);
      idxo=array[0][i];
      idxt=array[1][i];
    }
    System.out.println(sumo+sumt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Exercise {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var array : Sequence(Sequence(int)) ; array := Integer.subrange(1,2)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n * 2 do ( (     var nm : int ; nm := sc.getCurrent()->toInteger() ;
     if (array[0+1][nm+1] = 0) then     array[0+1][nm+1] := i ; else     array[1+1][nm+1] := i ; )  ;     i := i + 1 ) ; 
    var idxo : int ; idxo := 1 ;
    var idxt : int ; idxt := 1 ;
    var sumo : long ; sumo := 0 ;
    var sumt : long ; sumt := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     sumo := sumo+(abs(array[0+1][i+1] - idxo)) ; 
     sumt := sumt+(abs(array[1+1][i+1] - idxt)) ; 
     idxo := array[0+1][i+1] ; 
     idxt := array[1+1][i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sumo + sumt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.BitSet ;
import java.util.Scanner ;
public class Main {
  private static BitSet S=new BitSet();
  private static BitSet T=new BitSet();
  public static void main(String[] args)throws IOException {
    S.clear();
    T.clear();
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    while(n-->0){
      S.set(in.nextInt());
    }
    int q=in.nextInt();
    while(q-->0){
      T.set(in.nextInt());
    }
    S.and(T);
    System.out.println(S.cardinality());
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute S : Sequence(boolean) := MathLib.toBitSequence();
  static   attribute T : Sequence(boolean) := MathLib.toBitSequence();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     S := S->intersection(Set{}) ; 
     T := T->intersection(Set{}) ; 
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     S := S.setAt(in.getCurrent()->toInteger()+1, true) ) ;  ) ;  
    var q : int ; q := in.getCurrent()->toInteger() ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     T := T.setAt(in.getCurrent()->toInteger()+1, true) ) ;  ) ;  
    S := S.and(T) ; 
    OclFile["System.out"].println(S.cardinality()) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  private static int[] parseIntAll(String[] strings){
    int[] result=new int[strings.length];
    for(int i=0 ; i<strings.length ; i++){
      result[i]=Integer.parseInt(strings[i]);
    }
    return result ;
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(r.readLine());
    int[] s=parseIntAll(r.readLine().split(" "));
    int q=Integer.parseInt(r.readLine());
    int[] t=parseIntAll(r.readLine().split(" "));
    Arrays.sort(s);
    int c=0 ;
    for(int x : t){
      if(Arrays.binarySearch(s,x)>=0){
        c++;
      }
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation parseIntAll( strings : Sequence(String)) : Sequence(int)
  pre: true
  post: true
  activity: (     var result : Sequence(int) ; result := Integer.subrange(1,strings->size())->collect(0) ;
         var i : int ; i := 0 ; while i < strings->size() do ( (     result[i+1] := (strings[i+1])->toInteger() )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (r.readLine())->toInteger() ;
    var s : Sequence(int) ; s := parseIntAll(r.readLine()->split(" ")) ;
    var q : int ; q := (r.readLine())->toInteger() ;
    var t : Sequence(int) ; t := parseIntAll(r.readLine()->split(" ")) ;
    s := s->sort() ; 
    var c : int ; c := 0 ;
    for (x : t) do ( (     if ((s->indexOf(x) - 1) >= 0) then (     c := c + 1 ) else skip )  ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    solve();
  }
  public static void solve(){
    for(int i=1 ; i<=9 ; i++){
      for(int j=1 ; j<=9 ; j++){
        System.out.printf("%dx%d=%d\n",i,j,i*j);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= 9 do ( (         var j : int ; j := 1 ; while j <= 9 do ( (     OclFile["System.out"].printf("%dx%d=%d\n", i, j, i * j) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int MOD=32768 ;
    int T=Integer.parseInt(sc.next());
    while(T-->0){
      int number=Integer.parseInt(sc.next());
      int res=Integer.MAX_VALUE ;
      for(int add=0 ; add<=15 ; add++){
        for(int mul=0 ; mul<=15 ; mul++){
          if((number+add)*Math.pow(2,mul)% MOD==0){
            res=Math.min(res,add+mul);
          }
        }
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var MOD : int ; MOD := 32768 ;
     var T : int ; T := (sc.getCurrent())->toInteger() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     var number : int ; number := (sc.getCurrent())->toInteger() ;
     var res : int ; res := 2147483647 ;
         var add : int ; add := 0 ; while add <= 15 do ( (         var mul : int ; mul := 0 ; while mul <= 15 do ( (     if ((number + add) * 2->pow(mul) mod MOD = 0) then (     res := Set{res, add + mul}->min() ) else skip )  ;     mul := mul + 1 ) )  ;     add := add + 1 ) ; 
     OclFile["System.out"].println(res) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1405 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t,n,i ;
    t=sc.nextInt();
    while(t-->0){
      n=sc.nextInt();
      int arr[]=new int[n];
      for(i=0 ; i<n ; i++)arr[i]=sc.nextInt();
      for(i=n-1 ; i>=0 ; i--)System.out.print(arr[i]+" ");
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1405 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ;
    var n : int ;
    var i : int ;
     t := sc.getCurrent()->toInteger() ; 
         while (t > 0) do (        t := t - 1 ;     skip ; (     n := sc.getCurrent()->toInteger() ; 
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        i := n - 1 ; while i >= 0 do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i - 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication75 {
  public static void main(String[] args){
    Scanner read=new Scanner(System.in);
    int t=read.nextInt();
    while(t-->0){
      int n=read.nextInt();
      int[] ar=new int[n];
      for(int i=0 ; i<n ; i++)ar[i]=read.nextInt();
      for(int i=n-1 ; i>-1 ; i--)System.out.print(ar[i]+" ");
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication75 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : OclFile ; read := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := read.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := read.getCurrent()->toInteger() ;
     var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     ar[i+1] := read.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i > -1 do (     OclFile["System.out"].print(ar[i+1] + " ") ;  ;     i := i - 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Test {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    while(t-->0){
      int n=input.nextInt();
      int[] p=new int[n];
      for(int i=0 ; i<n ; i++){
        p[i]=input.nextInt();
      }
      for(int i=n-1 ; i>=0 ; i--){
        System.out.print(p[i]+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := input.getCurrent()->toInteger() ;
     var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     OclFile["System.out"].print(p[i+1] + " ") )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1405 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      int n=scanner.nextInt();
      int[] p=new int[n];
      for(int i=0 ; i<n ; i++){
        p[i]=scanner.nextInt();
      }
      for(int i=n-1 ; i>=0 ; i--){
        System.out.print(p[i]+" ");
      }
      System.out.println();
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1405 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     OclFile["System.out"].print(p[i+1] + " ") )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int factorial(int n){
    if(n==0)return 1 ;
    return n*factorial(n-1);
  }
  public static void main(String[] args){
    int num=5 ;
    System.out.println("Factorial of "+num+" is "+factorial(5));
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation factorial( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     return n * factorial(n - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 5 ;
     OclFile["System.out"].println("Factorial of " + num + " is " + factorial(5)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printMaxSum(int arr[],int n){
    int dp[]=new int[n];
    Arrays.fill(dp,0);
    for(int i=0 ; i<n ; i++){
      dp[i]=arr[i];
      int maxi=0 ;
      for(int j=1 ; j<=Math.sqrt(i+1); j++){
        if(((i+1)% j==0)&&(i+1)!=j){
          if(dp[j-1]>maxi)maxi=dp[j-1];
          if(dp[(i+1)/j-1]>maxi && j!=1)maxi=dp[(i+1)/j-1];
        }
      }
      dp[i]+=maxi ;
    }
    for(int i=0 ; i<n ; i++)System.out.print(dp[i]+" ");
  }
  public static void main(String[] args){
    int arr[]={
      2,3,1,4,6,5 };
      int n=arr.length ;
      printMaxSum(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printMaxSum( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
     dp := dp->collect(0) ; 
         var i : int ; i := 0 ; while i < n do ( (     dp[i+1] := arr[i+1] ; 
     var maxi : int ; maxi := 0 ;
         var j : int ; j := 1 ; while j <= (i + 1)->sqrt() do ( (     if (((i + 1) mod j = 0) & (i + 1) /= j) then (     if (dp[j - 1+1] > maxi) then     maxi := dp[j - 1+1] ; else skip ; 
     if (dp[(i + 1) / j - 1+1] > maxi & j /= 1) then     maxi := dp[(i + 1) / j - 1+1] ; else skip ) else skip )  ;     j := j + 1 ) ; 
     dp[i+1] := dp[i+1]+(maxi) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(dp[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,1,4,6,5} ;
     var n : int ; n := arr->size() ;
     execute printMaxSum(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int MOD=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    boolean[] isNotPrimes=new boolean[1000001];
    isNotPrimes[0]=true ;
    isNotPrimes[1]=true ;
    for(int i=2 ; i<isNotPrimes.length ; i++){
      if(isNotPrimes[i]){
        continue ;
      }
      for(int j=2 ; j*i<isNotPrimes.length ; j++){
        isNotPrimes[i*j]=true ;
      }
    }
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    int[][] dp=new int[n][2];
    if(! isNotPrimes[arr[0] ]){
      dp[0][0]=1 ;
    }
    for(int i=1 ; i<n ; i++){
      dp[i][1]+=dp[i-1][0];
      dp[i][1] %=MOD ;
      if(! isNotPrimes[arr[i] ]){
        if(i>=2 && arr[i-2]<arr[i]){
          dp[i][0]+=dp[i-1][1];
          dp[i][0] %=MOD ;
        }
        if(arr[i-1]<arr[i]){
          dp[i][0]+=dp[i-1][0];
          dp[i][0] %=MOD ;
        }
      }
    }
    System.out.println((dp[n-1][0]+dp[n-1][1])% MOD);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var isNotPrimes : Sequence(boolean) ; isNotPrimes := Integer.subrange(1,1000001)->collect(false) ;
    isNotPrimes[0+1] := true ; 
    isNotPrimes[1+1] := true ; 
        var i : int ; i := 2 ; while i < isNotPrimes->size() do ( (     if (isNotPrimes[i+1]) then (     continue ) else skip ; 
         var j : int ; j := 2 ; while j * i < isNotPrimes->size() do ( (     isNotPrimes[i * j+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
    if (not(isNotPrimes[arr[0+1]+1])) then (     dp[0+1][0+1] := 1 ) else skip ; 
        var i : int ; i := 1 ; while i < n do ( (     dp[i+1][1+1] := dp[i+1][1+1]+(dp[i - 1+1][0+1]) ; 
     dp[i+1][1+1] := dp[i+1][1+1] mod MOD ; 
     if (not(isNotPrimes[arr[i+1]+1])) then (     if (i >= 2 & arr[i - 2+1] < arr[i+1]) then (     dp[i+1][0+1] := dp[i+1][0+1]+(dp[i - 1+1][1+1]) ; 
     dp[i+1][0+1] := dp[i+1][0+1] mod MOD ) else skip ; 
     if (arr[i - 1+1] < arr[i+1]) then (     dp[i+1][0+1] := dp[i+1][0+1]+(dp[i - 1+1][0+1]) ; 
     dp[i+1][0+1] := dp[i+1][0+1] mod MOD ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((dp[n - 1+1][0+1] + dp[n - 1+1][1+1]) mod MOD) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void Cholesky_Decomposition(int[][] matrix,int n){
    int[][] lower=new int[n][n];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<=i ; j++){
        int sum=0 ;
        if(j==i){
          for(int k=0 ; k<j ; k++)sum+=(int)Math.pow(lower[j][k],2);
          lower[j][j]=(int)Math.sqrt(matrix[j][j]-sum);
        }
        else {
          for(int k=0 ; k<j ; k++)sum+=(lower[i][k]*lower[j][k]);
          lower[i][j]=(matrix[i][j]-sum)/lower[j][j];
        }
      }
    }
    System.out.println(" Lower Triangular\t Transpose");
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++)System.out.print(lower[i][j]+"\t");
      System.out.print("");
      for(int j=0 ; j<n ; j++)System.out.print(lower[j][i]+"\t");
      System.out.println();
    }
  }
  public static void main(String[] args){
    int n=3 ;
    int[][] matrix=new int[][] {
      {
        4,12,-16 },{
          12,37,-43 },{
-16,-43,98 }
          };
          Cholesky_Decomposition(matrix,n);
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Cholesky_Decomposition( matrix : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (     var lower : Sequence(Sequence(int)) ; lower := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j <= i do ( (     var sum : int ; sum := 0 ;
     if (j = i) then (         var k : int ; k := 0 ; while k < j do (     sum := sum+(lower[j+1][k+1]->pow(2)->oclAsType(int)) ;  ;     k := k + 1 ) ; 
     lower[j+1][j+1] := (matrix[j+1][j+1] - sum)->sqrt()->oclAsType(int) ) else (         var k : int ; k := 0 ; while k < j do (     sum := sum+((lower[i+1][k+1] * lower[j+1][k+1])) ;  ;     k := k + 1 ) ; 
     lower[i+1][j+1] := (matrix[i+1][j+1] - sum) / lower[j+1][j+1] ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(" Lower Triangular\t Transpose") ; 
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do (     OclFile["System.out"].print(lower[i+1][j+1] + "\t") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].print("") ; 
         var j : int ; j := 0 ; while j < n do (     OclFile["System.out"].print(lower[j+1][i+1] + "\t") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var matrix : Sequence(Sequence(int)) ; matrix := Sequence{Sequence{4,12,-16},Sequence{12,37,-43},Sequence{-16,-43,98}} ;
     execute Cholesky_Decomposition(matrix, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void CheckSubarray(int arr[],int N){
    int[] presum=new int[N+1];
    for(int i=1 ; i<=N ; i+=1){
      presum[i]=presum[i-1]+arr[i-1];
    }
    Vector<Integer>[] moduloclass=new Vector[N];
    for(int i=0 ; i<N ; i+=1){
      moduloclass[i]=new Vector<>();
    }
    for(int i=1 ; i<=N ; i+=1){
      moduloclass[presum[i] % N] .add(i-1);
    }
    if(moduloclass[0] .size()>0){
      System.out.print(0+" "+moduloclass[0] .get(0));
      return ;
    }
    for(int i=1 ; i<N ; i+=1){
      if(moduloclass[i] .size()>=2){
        System.out.print(moduloclass[i] .get(0)+1+" "+moduloclass[i] .get(1));
        return ;
      }
    }
  }
  public static void main(String args[]){
    int arr[]={
      7,3,5,2 };
      int N=arr.length ;
      CheckSubarray(arr,N);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation CheckSubarray( arr : Sequence(int), N : int) : void
  pre: true
  post: true
  activity: (     var presum : Sequence(int) ; presum := Integer.subrange(1,N + 1)->collect(0) ;
         var i : int ; i := 1 ; while i <= N do ( (     presum[i+1] := presum[i - 1+1] + arr[i - 1+1] )  ;     i := i+(1) ) ; 
    var moduloclass : Sequence(Sequence(int)) ; moduloclass := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     moduloclass[i+1] := Sequence{} )  ;     i := i+(1) ) ; 
        var i : int ; i := 1 ; while i <= N do ( (     moduloclass[presum[i+1] mod N+1]->excludes(i - 1) )  ;     i := i+(1) ) ; 
    if (moduloclass[0+1]->size() > 0) then (     OclFile["System.out"].print(0 + " " + moduloclass[0+1]->at(0+1)) ; 
     return ) else skip ; 
        var i : int ; i := 1 ; while i < N do ( (     if (moduloclass[i+1]->size() >= 2) then (     OclFile["System.out"].print(moduloclass[i+1]->at(0+1) + 1 + " " + moduloclass[i+1]->at(1+1)) ; 
     return ) else skip )  ;     i := i+(1) ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{7,3,5,2} ;
     var N : int ; N := arr->size() ;
     execute CheckSubarray(arr, N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static void MakePreSum(int[] arr,int[] presum,int n){
    presum[0]=arr[0];
    for(int i=1 ; i<n ; i++)presum[i]=presum[i-1]+arr[i];
  }
  static int BinaryLifting(int[] presum,int n,int x){
    int pos=0 ;
    int LOGN=(int)Math.log(n);
    if(x<=presum[0])return 0 ;
    for(int i=LOGN ; i>=0 ; i--){
      if(pos+(1<<i)<n && presum[pos+(1<<i)]<x){
        pos+=(1<<i);
      }
    }
    return pos+1 ;
  }
  public static void main(String args[]){
    int[] arr={
      2,5,7,1,6,9,12,4,6 };
      int x=8 ;
      int n=arr.length ;
      int[] presum=new int[n];
      Arrays.fill(presum,0);
      MakePreSum(arr,presum,n);
      System.out.println(BinaryLifting(presum,n,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation MakePreSum( arr : Sequence(int), presum : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     presum[0+1] := arr[0+1] ; 
         var i : int ; i := 1 ; while i < n do (     presum[i+1] := presum[i - 1+1] + arr[i+1] ;  ;     i := i + 1 ) );
  static   operation BinaryLifting( presum : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var pos : int ; pos := 0 ;
     var LOGN : int ; LOGN := (n)->log()->oclAsType(int) ;
    if (x <= presum[0+1]) then     return 0 else skip ; 
        var i : int ; i := LOGN ; while i >= 0 do ( (     if (pos + ((1*(2->pow(i)))->oclAsType(long)) < n & presum[pos + ((1*(2->pow(i)))->oclAsType(long))+1] < x) then (     pos := pos+(((1*(2->pow(i)))->oclAsType(long))) ) else skip )  ;     i := i - 1 ) ; 
    return pos + 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,5,7,1,6,9,12,4,6} ;
     var x : int ; x := 8 ;
    var n : int ; n := arr->size() ;
    var presum : Sequence(int) ; presum := Integer.subrange(1,n)->collect(0) ;
    presum := presum->collect(0) ; 
    execute MakePreSum(arr, presum, n) ; 
    OclFile["System.out"].println(BinaryLifting(presum, n, x)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    boolean[] num=new boolean[n+1];
    int[] prime=new int[n+1];
    Arrays.fill(num,true);
    for(int i=2 ; i<=n/2 ; i++){
      if(isPrime(i))for(int j=2*i ;
      j<=n ;
      j+=i){
        num[j]=false ;
      }
    }
    int j=0 ;
    for(int i=2 ; i<=n ; i++){
      if(num[i])prime[j++]=i ;
    }
    int value=0 ;
    for(int i=0 ; i<j ; i++){
      for(int z=0 ; z<i ; z++){
        if(prime[z]+prime[z+1]+1==prime[i]){
          value++;
          break ;
        }
      }
    }
    if(value<k)System.out.println("NO");
    else System.out.println("YES");
  }
  public static boolean isPrime(int x){
    if(x==2 || x==3)return true ;
    for(int k=2 ; k<=Math.sqrt(x); k++){
      if(x % k==0)return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var num : Sequence(boolean) ; num := Integer.subrange(1,n + 1)->collect(false) ;
    var prime : Sequence(int) ; prime := Integer.subrange(1,n + 1)->collect(0) ;
    num := num->collect(true) ; 
        var i : int ; i := 2 ; while i <= n / 2 do ( (     if (isPrime(i)) then         var j : int ; j := 2 * i ; while j <= n do ( (     num[j+1] := false )  ;     j := j+(i) ) ; else skip )  ;     i := i + 1 ) ; 
    var j : int ; j := 0 ;
        var i : int ; i := 2 ; while i <= n do ( (     if (num[i+1]) then      prime[j+1] := i  ; j := j + 1 ; else skip )  ;     i := i + 1 ) ; 
    var value : int ; value := 0 ;
        var i : int ; i := 0 ; while i < j do ( (         var z : int ; z := 0 ; while z < i do ( (     if (prime[z+1] + prime[z + 1+1] + 1 = prime[i+1]) then (     value := value + 1 ; 
     break ) else skip )  ;     z := z + 1 ) )  ;     i := i + 1 ) ; 
    if (value < k) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  
 );
  static   operation isPrime( x : int) : boolean
  pre: true
  post: true
  activity: (     if (x = 2 or x = 3) then     return true else skip ; 
         var k : int ; k := 2 ; while k <= (x)->sqrt() do ( (     if (x mod k = 0) then     return false else skip )  ;     k := k + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    boolean[] num=new boolean[n+1];
    int[] prime=new int[n+1];
    Arrays.fill(num,true);
    for(int i=2 ; i<=n/2 ; i++){
      if(isPrime(i))for(int j=2*i ;
      j<=n ;
      j+=i){
        num[j]=false ;
      }
    }
    int j=0 ;
    for(int i=2 ; i<=n ; i++){
      if(num[i])prime[j++]=i ;
    }
    int value=0 ;
    for(int i=0 ; i<j ; i++){
      for(int z=0 ; z<i ; z++){
        if(prime[z]+prime[z+1]+1==prime[i]){
          value++;
          break ;
        }
      }
    }
    if(value<k)System.out.println("NO");
    else System.out.println("YES");
  }
  public static boolean isPrime(int x){
    if(x==2 || x==3)return true ;
    for(int k=2 ; k<=Math.sqrt(x); k++){
      if(x % k==0)return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var num : Sequence(boolean) ; num := Integer.subrange(1,n + 1)->collect(false) ;
    var prime : Sequence(int) ; prime := Integer.subrange(1,n + 1)->collect(0) ;
    num := num->collect(true) ; 
        var i : int ; i := 2 ; while i <= n / 2 do ( (     if (isPrime(i)) then         var j : int ; j := 2 * i ; while j <= n do ( (     num[j+1] := false )  ;     j := j+(i) ) ; else skip )  ;     i := i + 1 ) ; 
    var j : int ; j := 0 ;
        var i : int ; i := 2 ; while i <= n do ( (     if (num[i+1]) then      prime[j+1] := i  ; j := j + 1 ; else skip )  ;     i := i + 1 ) ; 
    var value : int ; value := 0 ;
        var i : int ; i := 0 ; while i < j do ( (         var z : int ; z := 0 ; while z < i do ( (     if (prime[z+1] + prime[z + 1+1] + 1 = prime[i+1]) then (     value := value + 1 ; 
     break ) else skip )  ;     z := z + 1 ) )  ;     i := i + 1 ) ; 
    if (value < k) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  
 );
  static   operation isPrime( x : int) : boolean
  pre: true
  post: true
  activity: (     if (x = 2 or x = 3) then     return true else skip ; 
         var k : int ; k := 2 ; while k <= (x)->sqrt() do ( (     if (x mod k = 0) then     return false else skip )  ;     k := k + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int[] nums=new int[10];
    String s ;
    while(sc.hasNext()){
      s=sc.next();
      for(int i=0 ; i<10 ; i++){
        nums[i]=Character.getNumericValue(s.charAt(i));
      }
      for(int i=0 ; i<9 ; i++){
        for(int j=0 ; j<9-i ; j++){
          nums[j]=(nums[j]+nums[j+1])% 10 ;
        }
      }
      out.println(nums[0]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var nums : Sequence(int) ; nums := Integer.subrange(1,10)->collect(0) ;
     var s : String ;
     while (sc.hasNext()) do (     s := sc.getCurrent() ; 
         var i : int ; i := 0 ; while i < 10 do ( (     nums[i+1] := ("" + s->at(i+1))->toInteger() )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < 9 do ( (         var j : int ; j := 0 ; while j < 9 - (i)->char2byte() do ( (     nums[j+1] := (nums[j+1] + nums[j + 1+1]) mod 10 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     out.println(nums[0+1]) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    String s ;
    char[] c ;
    int i,j ;
    c=new char[10];
    for(; sc.hasNext(); ){
      s=sc.next();
      for(i=0 ; i<10 ; i++)c[i]=(char)(s.charAt(i)-'0');
      for(i=0 ; i<10-1 ; i++){
        for(j=0 ; j<9-i ; j++){
          c[j]+=c[j+1];
          c[j]=(char)(c[j] % 10);
        }
      }
      out.println((char)(c[0]+'0'));
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var s : String ;
    var c : Sequence(String) ;
    var i : int ;
    var j : int ;
    c := Integer.subrange(1,10)->collect(0) ; 
      while sc.hasNext() do ( (     s := sc.next() ; 
         i := 0 ; while i < 10 do (     c[i+1] := (s->at(i+1) - ('0')->char2byte())->oclAsType(String) ;  ;     i := i + 1 ) ; 
         i := 0 ; while i < 10 - 1 do ( (         j := 0 ; while j < 9 - i do ( (     c[j+1] := c[j+1]+(c[j + 1+1]) ; 
     c[j+1] := (c[j+1] mod 10)->oclAsType(String) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     out.println((c[0+1] + '0')->oclAsType(String)) )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static int solve(char[] c){
    if(c.length==1)return c[0]-'0' ;
    String ret="" ;
    for(int i=0 ; i<c.length-1 ; i++)ret+=((c[i]-'0')+(c[i+1]-'0'))% 10 ;
    return solve(ret.toCharArray());
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null){
      System.out.println(solve(line.toCharArray()));
      line=null ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( c : Sequence(String)) : int
  pre: true
  post: true
  activity: (     if (c->size() = 1) then     return c[0+1] - ('0')->char2byte() else skip ; 
     var ret : String ; ret := "" ;
         var i : int ; i := 0 ; while i < c->size() - 1 do (     ret := ret+(((c[i+1] - ('0')->char2byte()) + (c[i + 1+1] - ('0')->char2byte())) mod 10) ;  ;     i := i + 1 ) ; 
     return solve(ret->characters()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     OclFile["System.out"].println(solve(line->characters())) ; 
     line := null ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    for(; scanner.hasNext(); ){
      String input=scanner.next();
      ArrayList<Integer>n=new ArrayList<>();
      for(int i=0 ; i<input.length(); i++){
        n.add(Integer.parseInt(input.substring(i,i+1)));
      }
      for(; ; ){
        ArrayList<Integer>m=new ArrayList<>();
        for(int i=0 ; i<n.size()-1 ; i++){
          m.add((n.get(i)+n.get(i+1))% 10);
        }
        n=m ;
        if(m.size()==1){
          System.out.println(m.get(0));
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while scanner.hasNext() do ( (     var input : String ; input := scanner.getCurrent() ;
     var n : Sequence(int) ; n := Sequence{} ;
         var i : int ; i := 0 ; while i < input->size() do ( (     n := n->including((input.subrange(i+1,i + 1))->toInteger()) )  ;     i := i + 1 ) ; 
       while true do ( (     var m : Sequence(int) ; m := Sequence{} ;
         var i : int ; i := 0 ; while i < n->size() - 1 do ( (     m := m->including((n->at(i+1) + n->at(i + 1+1)) mod 10) )  ;     i := i + 1 ) ; 
     n := m ; 
     if (m->size() = 1) then (     OclFile["System.out"].println(m->at(0+1)) ; 
     break ) else skip )  ) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int[] compute_lps(String s){
    int n=s.length();
    int[] lps=new int[n];
    int len=0 ;
    lps[0]=0 ;
    int i=1 ;
    while(i<n){
      if(s.charAt(i)==s.charAt(len)){
        len++;
        lps[i]=len ;
        i++;
      }
      else {
        if(len!=0)len=lps[len-1];
        else {
          lps[i]=0 ;
          i++;
        }
      }
    }
    return lps ;
  }
  static void Longestsubstring(String s){
    int[] lps=compute_lps(s);
    int n=s.length();
    if(lps[n-1]==0){
      System.out.println(-1);
      return ;
    }
    for(int i=0 ; i<n-1 ; i++){
      if(lps[i]==lps[n-1]){
        System.out.println(s.substring(0,lps[i]));
        return ;
      }
    }
    if(lps[lps[n-1]-1]==0)System.out.println(-1);
    else System.out.println(s.substring(0,lps[lps[n-1]-1]));
  }
  public static void main(String[] args){
    String s="fixprefixsuffix" ;
    Longestsubstring(s);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation compute_lps( s : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var lps : Sequence(int) ; lps := Integer.subrange(1,n)->collect(0) ;
    var len : int ; len := 0 ;
    lps[0+1] := 0 ; 
    var i : int ; i := 1 ;
    while (i < n) do (     if (s->at(i+1) = s->at(len+1)) then (     len := len + 1 ; 
     lps[i+1] := len ; 
     i := i + 1 ) else (     if (len /= 0) then     len := lps[len - 1+1] ; else (     lps[i+1] := 0 ; 
     i := i + 1 ) ) ) ; 
    return lps 
 );
  static   operation Longestsubstring( s : String) : void
  pre: true
  post: true
  activity: (     var lps : Sequence(int) ; lps := compute_lps(s) ;
     var n : int ; n := s->size() ;
    if (lps[n - 1+1] = 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (lps[i+1] = lps[n - 1+1]) then (     OclFile["System.out"].println(s.subrange(0+1,lps[i+1])) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    if (lps[lps[n - 1+1] - 1+1] = 0) then     OclFile["System.out"].println(-1) else     OclFile["System.out"].println(s.subrange(0+1,lps[lps[n - 1+1] - 1+1])) ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "fixprefixsuffix" ;
     execute Longestsubstring(s) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    try {
      System.setIn(new FileInputStream("src/xxxyyyy/input.txt"));
      System.setOut(new PrintStream(new FileOutputStream("src/xxxyyyy/result.txt")));
    }
    catch(FileNotFoundException e){
    }
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String s=sc.next();
      int array[]=new int[10];
      for(int i=0 ; i<10 ; i++){
        array[i]=s.charAt(i)-'0' ;
      }
      for(int row=1 ; row<10 ; row++){
        int next[]=new int[10];
        for(int i=0 ; i<10-row ; i++){
          next[i]=(array[i]+array[i+1])% 10 ;
        }
        array=next ;
      }
      System.out.println(array[0]);
    }
  }
  void debug(Object...os){
    System.err.println(deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("src/xxxyyyy/input.txt"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("src/xxxyyyy/result.txt")))) )   catch (e : FileNotFoundException) do skip
     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var s : String ; s := sc.getCurrent() ;
     var array : Sequence(int) ; array := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < 10 do ( (     array[i+1] := s->at(i+1) - ('0')->char2byte() )  ;     i := i + 1 ) ; 
        var row : int ; row := 1 ; while row < 10 do ( (     var next : Sequence(int) ; next := Integer.subrange(1,10)->collect(0) ;
         var i : int ; i := 0 ; while i < 10 - row do ( (     next[i+1] := (array[i+1] + array[i + 1+1]) mod 10 )  ;     i := i + 1 ) ; 
     array := next )  ;     row := row + 1 ) ; 
    OclFile["System.out"].println(array[0+1]) ; 
 ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s="qwertyuiopasdfghjkl;zxcvbnm,./" ;
    String dir=in.next();
    String str=in.next();
    String res="" ;
    for(int i=0 ; i<str.length(); i++){
      if(dir.equals("R")){
        res+=s.charAt(s.indexOf(str.charAt(i))-1);
      }
      else {
        res+=s.charAt(s.indexOf(str.charAt(i))+1);
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := "qwertyuiopasdfghjkl;zxcvbnm,./" ;
    var dir : String ; dir := in.getCurrent() ;
    var str : String ; str := in.getCurrent() ;
    var res : String ; res := "" ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (dir = "R") then (     res := res+(s->at(s->indexOf(str->at(i+1))-1 - 1+1)) ) else (     res := res+(s->at(s->indexOf(str->at(i+1))-1 + 1+1)) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char direction=sc.nextLine().charAt(0);
    String s=sc.nextLine();
    StringBuilder org=new StringBuilder("");
    String[] kb={
      "qwertyuiop","asdfghjkl;","zxcvbnm,./" };
      for(int i=0 ; i<s.length(); i++){
        char c=s.charAt(i);
        for(int j=0 ; j<kb.length ; j++){
          int index=kb[j] .indexOf(c);
          if(index!=-1){
            if(direction=='R')index-=1 ;
            else index+=1 ;
            org.append(kb[j] .charAt(index));
          }
        }
      }
      System.out.println(org);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var direction : String ; direction := sc.nextLine()->at(0+1) ;
    var s : String ; s := sc.nextLine() ;
    var org : String ; org := StringLib.newString("") ;
    var kb : Sequence(String) ; kb := Sequence{"qwertyuiop","asdfghjkl;","zxcvbnm,./"} ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var c : String ; c := s->at(i+1) ;
         var j : int ; j := 0 ; while j < kb->size() do ( (     var index : int ; index := kb[j+1]->indexOf(c)-1 ;
     if (index /= -1) then (     if (direction = 'R') then     index := index-(1) else     index := index+(1) ; ;  
     org := org + StringLib.newString(kb[j+1]->at(index+1)) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(org) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String S="qwertyuiopasdfghjkl;zxcvbnm,./" ;
    char D=input.next().charAt(0);
    String R=input.next();
    int a ;
    char check ;
    if(D=='R'){
      for(int i=0 ; i<R.length(); i++){
        check=R.charAt(i);
        a=S.indexOf(check)-1 ;
        System.out.print(S.charAt(a));
      }
    }
    else {
      for(int i=0 ; i<R.length(); i++){
        check=R.charAt(i);
        a=S.indexOf(check)+1 ;
        System.out.print(S.charAt(a));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := "qwertyuiopasdfghjkl;zxcvbnm,./" ;
    var D : String ; D := input.getCurrent()->at(0+1) ;
    var R : String ; R := input.getCurrent() ;
    var a : int ;
    var check : String ;
    if (D = 'R') then (         var i : int ; i := 0 ; while i < R->size() do ( (     check := R->at(i+1) ; 
     a := S->indexOf(check)-1 - 1 ; 
     OclFile["System.out"].print(S->at(a+1)) )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < R->size() do ( (     check := R->at(i+1) ; 
     a := S->indexOf(check)-1 + 1 ; 
     OclFile["System.out"].print(S->at(a+1)) )  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int Permutations(int n,int k){
    int ans=1 ;
    if(k>=2)ans+=(n)*(n-1)/2 ;
    if(k>=3)ans+=(n)*(n-1)*(n-2)*2/6 ;
    if(k>=4)ans+=(n)*(n-1)*(n-2)*(n-3)*9/24 ;
    return ans ;
  }
  public static void main(String[] args){
    int n=5,k=2 ;
    System.out.println(Permutations(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Permutations( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
     if (k >= 2) then     ans := ans+((n) * (n - 1) / 2) ; else skip ; 
    if (k >= 3) then     ans := ans+((n) * (n - 1) * (n - 2) * 2 / 6) ; else skip ; 
    if (k >= 4) then     ans := ans+((n) * (n - 1) * (n - 2) * (n - 3) * 9 / 24) ; else skip ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var k : int ; k := 2 ;
     OclFile["System.out"].println(Permutations(n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s="qwertyuiopasdfghjkl;zxcvbnm,./" ;
    String x=sc.next();
    String y=sc.next();
    String ans="" ;
    char temp ;
    int c ;
    for(int i=0 ; i<y.length(); i++){
      if(x.equals("R")){
        temp=y.charAt(i);
        for(int j=0 ; j<s.length(); j++){
          if(temp==s.charAt(j)){
            c=j-1 ;
            ans+=s.charAt(c);
          }
        }
      }
      else {
        temp=y.charAt(i);
        for(int j=0 ; j<s.length(); j++){
          if(temp==s.charAt(j)){
            c=j+1 ;
            ans+=s.charAt(c);
          }
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := "qwertyuiopasdfghjkl;zxcvbnm,./" ;
    var x : String ; x := sc.getCurrent() ;
    var y : String ; y := sc.getCurrent() ;
    var ans : String ; ans := "" ;
    var temp : String ;
    var c : int ;
        var i : int ; i := 0 ; while i < y->size() do ( (     if (x = "R") then (     temp := y->at(i+1) ; 
         var j : int ; j := 0 ; while j < s->size() do ( (     if (temp = s->at(j+1)) then (     c := j - 1 ; 
     ans := ans+(s->at(c+1)) ) else skip )  ;     j := j + 1 ) ) else (     temp := y->at(i+1) ; 
         var j : int ; j := 0 ; while j < s->size() do ( (     if (temp = s->at(j+1)) then (     c := j + 1 ; 
     ans := ans+(s->at(c+1)) ) else skip )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A474 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String ch=sc.nextLine();
    String s=sc.nextLine();
    char[] keyboard={
      'q','w','e','r','t','y','u','i','o','p','a','s','d','f','g','h','j','k','l',';','z','x','c','v','b','n','m',',','.','/' };
      if(ch.contains("R")){
        for(int i=0 ; i<s.length(); i++){
          for(int k=0 ; k<keyboard.length ; k++){
            if(s.charAt(i)==keyboard[k]){
              System.out.print(keyboard[k-1]);
            }
          }
        }
      }
      else {
        for(int i=0 ; i<s.length(); i++){
          for(int k=0 ; k<keyboard.length ; k++){
            if(s.charAt(i)==keyboard[k]){
              System.out.print(keyboard[k+1]);
            }
          }
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class A474 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ch : String ; ch := sc.nextLine() ;
    var s : String ; s := sc.nextLine() ;
    var keyboard : Sequence(String) ; keyboard := Sequence{'q','w','e','r','t','y','u','i','o','p','a','s','d','f','g','h','j','k','l',';','z','x','c','v','b','n','m',',','.','/'} ;
    if (ch->includes("R")) then (         var i : int ; i := 0 ; while i < s->size() do ( (         var k : int ; k := 0 ; while k < keyboard->size() do ( (     if (s->at(i+1) = keyboard[k+1]) then (     OclFile["System.out"].print(keyboard[k - 1+1]) ) else skip )  ;     k := k + 1 ) )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < s->size() do ( (         var k : int ; k := 0 ; while k < keyboard->size() do ( (     if (s->at(i+1) = keyboard[k+1]) then (     OclFile["System.out"].print(keyboard[k + 1+1]) ) else skip )  ;     k := k + 1 ) )  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static final int MAX_CHAR=26 ;
  static boolean areKAnagrams(String str1,String str2,int k){
    int n=str1.length();
    if(str2.length()!=n)return false ;
    int[] hash_str1=new int[MAX_CHAR];
    for(int i=0 ; i<n ; i++)hash_str1[str1.charAt(i)-'a']++;
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(hash_str1[str2.charAt(i)-'a']>0)hash_str1[str2.charAt(i)-'a']--;
      else count++;
      if(count>k)return false ;
    }
    return true ;
  }
  public static void main(String args[]){
    String str1="fodr" ;
    String str2="gork" ;
    int k=2 ;
    if(areKAnagrams(str1,str2,k)==true)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX_CHAR : int := 26;
  static   operation areKAnagrams( str1 : String, str2 : String, k : int) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := str1->size() ;
     if (str2->size() /= n) then     return false else skip ; 
    var hash_str1 : Sequence(int) ; hash_str1 := Integer.subrange(1,MAX_CHAR)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     hash_str1[str1->at(i+1) - ('a')->char2byte()+1] := hash_str1[str1->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (hash_str1[str2->at(i+1) - ('a')->char2byte()+1] > 0) then     hash_str1[str2->at(i+1) - ('a')->char2byte()+1] := hash_str1[str2->at(i+1) - ('a')->char2byte()+1] - 1 else     count := count + 1 ; ;  
     if (count > k) then     return false else skip )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "fodr" ;
     var str2 : String ; str2 := "gork" ;
     var k : int ; k := 2 ;
     if (areKAnagrams(str1, str2, k) = true) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    Scanner sc=new Scanner(System.in);
    String cases=sc.nextLine();
    String[] nums=cases.split(" ");
    System.out.println(main.solution(Integer.parseInt(nums[0]),Integer.parseInt(nums[1]),Integer.parseInt(nums[2])));
  }
  public int solution(int yellow,int blue,int red){
    int counter ;
    int min=Math.min(Math.min(yellow,blue),red);
    if(min==red){
      counter=(red*3)-3 ;
    }
    else if(min==blue){
      counter=blue*3 ;
    }
    else {
      counter=(yellow+1==blue)?(blue==red ?(red*3)-3 :(yellow*3)+3):((yellow+1==red)?(red*3)-3 :(yellow*3)+3);
    }
    return counter ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var cases : String ; cases := sc.nextLine() ;
    var nums : Sequence(String) ; nums := cases->split(" ") ;
    OclFile["System.out"].println(main.solution((nums[0+1])->toInteger(), (nums[1+1])->toInteger(), (nums[2+1])->toInteger())) ; 
 );
   operation solution( yellow : int, blue : int, red : int) : int
  pre: true
  post: true
  activity: (     var counter : int ;
     var min : int ; min := Set{Set{yellow, blue}->min(), red}->min() ;
     if (min = red) then (     counter := (red * 3) - 3 ) else     if (min = blue) then (     counter := blue * 3 ) else (     counter := if (yellow + 1 = blue) then (if blue = red then (red * 3) - 3 else (yellow * 3) + 3 endif) else (if (yellow + 1 = red) then (red * 3) - 3 else (yellow * 3) + 3 endif) endif ) ;  ;  
     return counter );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class P1091A {
  public static void main(String[] args)throws IOException {
    BufferedReader io=new BufferedReader(new InputStreamReader(System.in));
    String[] ybr=io.readLine().split(" ");
    Integer y=Integer.valueOf(ybr[0]);
    Integer b=Integer.valueOf(ybr[1]);
    Integer r=Integer.valueOf(ybr[2]);
    Integer rs=0 ;
    for(int i=1 ; i<=y ; i++){
      if(!((i+1)<=b &&(i+2)<=r)){
        break ;
      }
      else {
        rs=i ;
      }
    }
    System.out.println((rs)*3+3);
  }
}
------------------------------------------------------------
OCL File:
---------
 class P1091A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var ybr : Sequence(String) ; ybr := io.readLine()->split(" ") ;
    var y : int ; y := (ybr[0+1])->toInteger() ;
    var b : int ; b := (ybr[1+1])->toInteger() ;
    var r : int ; r := (ybr[2+1])->toInteger() ;
    var rs : int ; rs := 0 ;
        var i : int ; i := 1 ; while i <= y do ( (     if (not(((i + 1) <= b & (i + 2) <= r))) then (     break ) else (     rs := i ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((rs) * 3 + 3) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    int count=0,max=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='x'){
        count++;
        if(count>2){
          max=max+1 ;
        }
      }
      else {
        count=0 ;
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var count : int ; count := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'x') then (     count := count + 1 ; 
     if (count > 2) then (     max := max + 1 ) else skip ) else (     count := 0 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    int a=fs.nextInt();
    int b=fs.nextInt();
    int c=fs.nextInt();
    int res=Math.min(a,Math.min(b-1,c-2));
    System.out.println(res*3+3);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! 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());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var a : int ; a := fs.nextInt() ;
    var b : int ; b := fs.nextInt() ;
    var c : int ; c := fs.nextInt() ;
    var res : int ; res := Set{a, Set{b - 1, c - 2}->min()}->min() ;
    OclFile["System.out"].println(res * 3 + 3) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int y=sc.nextInt();
    int b=sc.nextInt();
    int r=sc.nextInt();
    int total=0 ;
    if(y<=b-1 && y<=r-2){
      total=3*y+3 ;
    }
    else if(b-1<=y && b-1<=r-2){
      total=3*b ;
    }
    else if(r-2<=y && r-2<=b-1){
      total=3*r-3 ;
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var total : int ; total := 0 ;
    if (y <= b - 1 & y <= r - 2) then (     total := 3 * y + 3 ) else     if (b - 1 <= y & b - 1 <= r - 2) then (     total := 3 * b ) else     if (r - 2 <= y & r - 2 <= b - 1) then (     total := 3 * r - 3 ) else skip ; ;  ;  
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean isComposite(int n){
    if(n<=1)return false ;
    if(n<=3)return false ;
    if(n % 2==0 || n % 3==0)return true ;
    for(int i=5 ; i*i<=n ; i=i+6)if(n % i==0 || n %(i+2)==0)return true ;
    return false ;
  }
  static boolean isDigitSumOne(int nm){
    while(nm>9){
      int sum_digit=0 ;
      while(nm>0){
        int digit=nm % 10 ;
        sum_digit=sum_digit+digit ;
        nm=nm/10 ;
      }
      nm=sum_digit ;
    }
    if(nm==1)return true ;
    else return false ;
  }
  static void printValidNums(int l,int r){
    for(int i=l ; i<=r ; i++){
      if(isComposite(i)&& isDigitSumOne(i))System.out.print(i+" ");
    }
  }
  public static void main(String arg[]){
    int l=10,r=100 ;
    printValidNums(l,r);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isComposite( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return false else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return true else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return true else skip ;  ;     i := i + 6 ) ; 
    return false 
 );
  static   operation isDigitSumOne( nm : int) : boolean
  pre: true
  post: true
  activity: (     while (nm > 9) do (     var sum_digit : int ; sum_digit := 0 ;
     while (nm > 0) do (     var digit : int ; digit := nm mod 10 ;
     sum_digit := sum_digit + digit ; 
     nm := nm / 10 ) ; 
     nm := sum_digit ) ; 
     if (nm = 1) then     return true else     return false );
  static   operation printValidNums( l : int, r : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := l ; while i <= r do ( (     if (isComposite(i) & isDigitSumOne(i)) then     OclFile["System.out"].print(i + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 10 ;
    var r : int ; r := 100 ;
     execute printValidNums(l, r) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maxProduct(int arr[],int n){
    int ans=-1 ;
    for(int i=0 ; i<n-2 ; i++){
      for(int j=i+1 ; j<n-1 ; j++){
        for(int k=j+1 ; k<n ; k++){
          if(arr[i]<arr[j] && arr[j]>arr[k])ans=Math.max(ans,arr[i]*arr[j]*arr[k]);
        }
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      1,8,3,7 };
      int n=arr.length ;
      System.out.print(maxProduct(arr,n)+"\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxProduct( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := -1 ;
         var i : int ; i := 0 ; while i < n - 2 do ( (         var j : int ; j := i + 1 ; while j < n - 1 do ( (         var k : int ; k := j + 1 ; while k < n do ( (     if (arr[i+1] < arr[j+1] & arr[j+1] > arr[k+1]) then     ans := Set{ans, arr[i+1] * arr[j+1] * arr[k+1]}->max() ; else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,8,3,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(maxProduct(arr, n) + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector ;
class Test {
  static final int MAXN=100001 ;
  static int spf[]=new int[MAXN];
  static void sieve(){
    spf[1]=1 ;
    for(int i=2 ; i<MAXN ; i++)spf[i]=i ;
    for(int i=4 ; i<MAXN ; i+=2)spf[i]=2 ;
    for(int i=3 ; i*i<MAXN ; i++){
      if(spf[i]==i){
        for(int j=i*i ; j<MAXN ; j+=i)if(spf[j]==j)spf[j]=i ;
      }
    }
  }
  static Vector<Integer>getFactorization(int x){
    Vector<Integer>ret=new Vector<>();
    while(x!=1){
      ret.add(spf[x]);
      x=x/spf[x];
    }
    return ret ;
  }
  public static void main(String args[]){
    sieve();
    int x=12246 ;
    System.out.print("prime factorization for "+x+" : ");
    Vector<Integer>p=getFactorization(x);
    for(int i=0 ; i<p.size(); i++)System.out.print(p.get(i)+" ");
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static    attribute MAXN : int := 100001;
  static   attribute spf : int := Integer.subrange(1,MAXN)->collect(0);
  static   operation sieve() : void
  pre: true
  post: true
  activity: (     spf[1+1] := 1 ; 
         var i : int ; i := 2 ; while i < MAXN do (     spf[i+1] := i ;  ;     i := i + 1 ) ; 
         var i : int ; i := 4 ; while i < MAXN do (     spf[i+1] := 2 ;  ;     i := i+(2) ) ; 
         var i : int ; i := 3 ; while i * i < MAXN do ( (     if (spf[i+1] = i) then (         var j : int ; j := i * i ; while j < MAXN do (     if (spf[j+1] = j) then     spf[j+1] := i ; else skip ;  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) );
  static   operation getFactorization( x : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ret : Sequence(int) ; ret := Sequence{} ;
     while (x /= 1) do (     ret := ret->including(spf[x+1]) ; 
     x := x / spf[x+1] ) ; 
     return ret );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute sieve() ; 
     var x : int ; x := 12246 ;
    OclFile["System.out"].print("prime factorization for " + x + " : ") ; 
    var p : Sequence(int) ; p := getFactorization(x) ;
        var i : int ; i := 0 ; while i < p->size() do (     OclFile["System.out"].print(p->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[]){
    FastReader input=new FastReader();
    PrintWriter out=new PrintWriter(System.out);
    int T=input.nextInt();
    while(T-->0){
      int n=input.nextInt();
      int m=input.nextInt();
      int k=input.nextInt();
      int min=n-1 ;
      long max=(long)n*(long)(n-1)/2 ;
      if(m<min || m>max){
        out.println("NO");
      }
      else {
        k-=2 ;
        if(n==1){
          if(k<0)out.println("NO");
          else out.println("YES");
        }
        else {
          if(m==max){
            if(k<1)out.println("NO");
            else out.println("YES");
          }
          else {
            if(k<2)out.println("NO");
            else out.println("YES");
          }
        }
      }
    }
    out.close();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastReader ; input := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := input.nextInt() ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := input.nextInt() ;
     var m : int ; m := input.nextInt() ;
    var k : int ; k := input.nextInt() ;
    var min : int ; min := n - 1 ;
    var max : long ; max := n->oclAsType(long) * (n - 1)->oclAsType(long) / 2 ;
    if (m < min or m > max) then (     skip ) else (     k := k-(2) ; 
     if (n = 1) then (     if (k < 0) then     skip ; else     skip ; ) else (     if (m = max) then (     if (k < 1) then     skip ; else     skip ; ) else (     if (k < 2) then     skip ; else     skip ; ) ) ) ;  
 ) ;  ) ;  
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Test {
  private static char findExtraCharacter(String s1,String s2){
    String smallStr ;
    String largeStr ;
    if(s1.length()>s2.length()){
      smallStr=s2 ;
      largeStr=s1 ;
    }
    else {
      smallStr=s1 ;
      largeStr=s2 ;
    }
    int smallStrCodeTotal=0 ;
    int largeStrCodeTotal=0 ;
    int i=0 ;
    for(; i<smallStr.length(); i++){
      smallStrCodeTotal+=smallStr.charAt(i);
      largeStrCodeTotal+=largeStr.charAt(i);
    }
    largeStrCodeTotal+=largeStr.charAt(i);
    int intChar=largeStrCodeTotal-smallStrCodeTotal ;
    return(char)intChar ;
  }
  public static void main(String[] args){
    String s1="abcd" ;
    String s2="cbdae" ;
    char extraChar=findExtraCharacter(s1,s2);
    System.out.println("Extra character: "+extraChar);
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation findExtraCharacter( s1 : String, s2 : String) : String
  pre: true
  post: true
  activity: (     var smallStr : String ;
     var largeStr : String ;
    if (s1->size() > s2->size()) then (     smallStr := s2 ; 
     largeStr := s1 ) else (     smallStr := s1 ; 
     largeStr := s2 ) ;  
    var smallStrCodeTotal : int ; smallStrCodeTotal := 0 ;
    var largeStrCodeTotal : int ; largeStrCodeTotal := 0 ;
    var i : int ; i := 0 ;
      while i < smallStr->size() do ( (     smallStrCodeTotal := smallStrCodeTotal+(smallStr->at(i+1)) ; 
     largeStrCodeTotal := largeStrCodeTotal+(largeStr->at(i+1)) )  ;     i := i + 1 ) ; 
    largeStrCodeTotal := largeStrCodeTotal+(largeStr->at(i+1)) ; 
    var intChar : int ; intChar := largeStrCodeTotal - (smallStrCodeTotal)->char2byte() ;
    return intChar->oclAsType(String) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "abcd" ;
     var s2 : String ; s2 := "cbdae" ;
     var extraChar : String ; extraChar := findExtraCharacter(s1, s2) ;
     OclFile["System.out"].println("Extra character: " + extraChar) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class C {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(new FileInputStream("src/C-large.in"))));
    String output="" ;
    int t=sc.nextInt();
    sc.nextLine();
    for(int i=1 ; i<=t ; i++){
      int n=sc.nextInt();
      int j=sc.nextInt();
      long num=(1l<<(n-1))+1 ;
      int count=0 ;
      output+="Case #"+i+":\n" ;
      while(count<j){
        String s=Long.toBinaryString(num);
        boolean found=true ;
        ArrayList<Integer>factors=new ArrayList<Integer>();
        for(int k=2 ; k<=10 ; k++){
          BigInteger big=new BigInteger(s,k);
          if(big.isProbablePrime(10)){
            found=false ;
            break ;
          }
          int factor=-1 ;
          for(int m=3 ; m<1000 ; m+=2){
            if(big.mod(new BigInteger(""+m)).equals(BigInteger.ZERO)){
              factor=m ;
              break ;
            }
          }
          if(factor==-1){
            found=false ;
            break ;
          }
          factors.add(factor);
        }
        if(found){
          count++;
          output+=s ;
          for(int k : factors){
            output+=" "+k ;
          }
          output+="\n" ;
        }
        num+=2 ;
      }
    }
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/C-large.out"),"utf-8"));
    bw.write(output);
    bw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("src/C-large.in"))))) ;
     var output : String ; output := "" ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    skip ; 
        var i : int ; i := 1 ; while i <= t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var j : int ; j := sc.getCurrent()->toInteger() ;
    var num : long ; num := ((1l*(2->pow((n - 1))))->oclAsType(long)) + 1 ;
    var count : int ; count := 0 ;
    output := output+("Case #" + i + ":\n") ; 
    while (count < j) do (     var s : String ; s := (MathLib.decimal2binary(num) + "") ;
     var found : boolean ; found := true ;
    var factors : Sequence(int) ; factors := Sequence{} ;
        var k : int ; k := 2 ; while k <= 10 do ( (     var big : long ; big := long(s, k) ;
     if (big.isProbablePrime(10)) then (     found := false ; 
     break ) else skip ; 
    var factor : int ; factor := -1 ;
        var m : int ; m := 3 ; while m < 1000 do ( (     if (big.mod(long("" + m)) = 0) then (     factor := m ; 
     break ) else skip )  ;     m := m+(2) ) ; 
    if (factor = -1) then (     found := false ; 
     break ) else skip ; 
    factors := factors->including(factor) ; 
 )  ;     k := k + 1 ) ; 
    if (found) then (     count := count + 1 ; 
     output := output+(s) ; 
     for (k : factors) do ( (     output := output+(" " + k) )  ) ; 
     output := output+("\n") ) else skip ; 
    num := num+(2) ; 
 ) ; 
 )  ;     i := i + 1 ) ; 
    var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("src/C-large.out")), "utf-8")) ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package lab6zp ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Lab6ZP {
  public static String makeit(int i){
    String s="11" ;
    int k=14 ;
    while(k>0){
      k--;
      if(i % 2==0){
        s+="11" ;
      }
      else {
        s+="00" ;
      }
      i/=2 ;
    }
    s+="11" ;
    return s ;
  }
  public static void main(String[] args){
    System.out.println("Case #1:");
    for(int i=0 ; i<500 ; i++){
      String s=makeit(i);
      System.out.println(s+" 3 4 5 6 7 8 9 10 11");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Lab6ZP {
  static   operation makeit( i : int) : String
  pre: true
  post: true
  activity: (     var s : String ; s := "11" ;
     var k : int ; k := 14 ;
    while (k > 0) do (     k := k - 1 ; 
     if (i mod 2 = 0) then (     s := s+("11") ) else (     s := s+("00") ) ;  
     i := i/(2) ) ; 
    s := s+("11") ; 
    return s 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Case #1:") ; 
         var i : int ; i := 0 ; while i < 500 do ( (     var s : String ; s := makeit(i) ;
     OclFile["System.out"].println(s + " 3 4 5 6 7 8 9 10 11") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public class C {
  public static void main(String[] args){
    int N=32 ;
    int J=500 ;
    System.out.println("Case #1:");
    for(int i=0 ; i<J ; i++){
      String bitmask=Integer.toBinaryString(i);
      while(bitmask.length()+2<N/2){
        bitmask='0'+bitmask ;
      }
      String divisor=String.format("1%s1",bitmask);
      String jamcoin=divisor+divisor ;
      System.out.print(jamcoin);
      for(int base=2 ; base<=10 ; base++){
        System.out.print(" "+new BigInteger(divisor,base));
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 32 ;
     var J : int ; J := 500 ;
     OclFile["System.out"].println("Case #1:") ; 
         var i : int ; i := 0 ; while i < J do ( (     var bitmask : String ; bitmask := (MathLib.decimal2binary(i) + "") ;
     while (bitmask->size() + 2 < N / 2) do (     bitmask := '0' + bitmask ) ; 
    var divisor : String ; divisor := StringLib.format("1%s1",Sequence{bitmask}) ;
    var jamcoin : String ; jamcoin := divisor + divisor ;
    OclFile["System.out"].print(jamcoin) ; 
        var base : int ; base := 2 ; while base <= 10 do ( (     OclFile["System.out"].print(" " + long(divisor, base)) )  ;     base := base + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    for(int i=0 ; i<n ; i++){
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      if(b<a){
        System.out.println("Happy Alex");
        return ;
      }
    }
    System.out.println("Poor Alex");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
     if (b < a) then (     OclFile["System.out"].println("Happy Alex") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Poor Alex") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class CoinJam {
  public static final PrintStream out=System.out ;
  public static final BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  public int numCases ;
  public void doCase(int caseNumber)throws Exception {
    String line=in.readLine();
    Scanner scan=new Scanner(line);
    int N=scan.nextInt();
    int J=scan.nextInt();
    String divisor="1" ;
    for(int i=0 ; i<N/2-1 ; i++){
      divisor+="0" ;
    }
    divisor+="1" ;
    for(int i=0 ; i<J ; i++){
      String coin="1" ;
      coin+=pad(Integer.toString(i,2),N/2-2);
      coin+="11" ;
      coin+=pad(Integer.toString(i,2),N/2-2);
      coin+="1" ;
      System.out.print(coin);
      for(int base=2 ; base<=10 ; base++){
        System.out.print(" ");
        System.out.print(new BigInteger(divisor,base));
      }
      System.out.println();
    }
  }
  String pad(String s,int len){
    String res="" ;
    for(int i=s.length(); i<len ; i++){
      res+="0" ;
    }
    res+=s ;
    return res ;
  }
  public void run()throws Exception {
    numCases=Integer.parseInt(in.readLine().trim());
    for(int i=1 ; i<=numCases ; i++){
      out.print("Case #"+i+":\n");
      doCase(i);
    }
  }
  public static void main(String[] args)throws Exception {
    new CoinJam().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CoinJam {
  static    attribute out : OclFile := OclFile["System.out"];
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute numCases : int;
   operation doCase( caseNumber : int) : void
  pre: true
  post: true
  activity: (     var line : String ; line := in.readLine() ;
     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile(line)) ;
    var N : int ; N := scan.getCurrent()->toInteger() ;
    var J : int ; J := scan.getCurrent()->toInteger() ;
    var divisor : String ; divisor := "1" ;
        var i : int ; i := 0 ; while i < N / 2 - 1 do ( (     divisor := divisor+("0") )  ;     i := i + 1 ) ; 
    divisor := divisor+("1") ; 
        var i : int ; i := 0 ; while i < J do ( (     var coin : String ; coin := "1" ;
     coin := coin+(pad(((i) + ""), N / 2 - 2)) ; 
    coin := coin+("11") ; 
    coin := coin+(pad(((i) + ""), N / 2 - 2)) ; 
    coin := coin+("1") ; 
    OclFile["System.out"].print(coin) ; 
        var base : int ; base := 2 ; while base <= 10 do ( (     OclFile["System.out"].print(" ") ; 
     OclFile["System.out"].print(long(divisor, base)) )  ;     base := base + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) ; 
 );
   operation pad( s : String, len : int) : String
  pre: true
  post: true
  activity: (     var res : String ; res := "" ;
         var i : int ; i := s->size() ; while i < len do ( (     res := res+("0") )  ;     i := i + 1 ) ; 
     res := res+(s) ; 
     return res );
   operation run() : void
  pre: true
  post: true
  activity: (     numCases := (in.readLine()->trim())->toInteger() ; 
         var i : int ; i := 1 ; while i <= numCases do ( (     skip ; 
     execute doCase(i) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     CoinJam.newCoinJam().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class C {
  static long value(int i,int m,int b){
    long n=1 ;
    for(int k=0 ; k<m ; k++){
      n=n*b+i % 2 ;
      i/=2 ;
    }
    return n*b+1 ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int T=Integer.parseInt(br.readLine());
    for(int t=1 ; t<=T ; t++){
      StringTokenizer st=new StringTokenizer(br.readLine());
      int n=Integer.parseInt(st.nextToken());
      int j=Integer.parseInt(st.nextToken());
      pw.println("Case #"+t+":");
      int m=n/2-2 ;
      for(int i=0 ; i<j ; i++){
        StringBuilder sb=new StringBuilder();
        sb.append("1");
        for(int k=0 ; k<m ; k++)sb.append((i & 1<<k)==0 ? "0" : "1");
        sb.append("11");
        for(int k=0 ; k<m ; k++)sb.append((i & 1<<k)==0 ? "0" : "1");
        sb.append("1");
        for(int b=2 ; b<=10 ; b++)sb.append(" "+value(i,m,b));
        pw.println(sb);
      }
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation value( i : int, m : int, b : int) : long
  pre: true
  post: true
  activity: (     var n : long ; n := 1 ;
         var k : int ; k := 0 ; while k < m do ( (     n := n * b + i mod 2 ; 
     i := i/(2) )  ;     k := k + 1 ) ; 
     return n * b + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := (br.readLine())->toInteger() ;
        var t : int ; t := 1 ; while t <= T do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var n : int ; n := (st.next())->toInteger() ;
    var j : int ; j := (st.next())->toInteger() ;
    skip ; 
    var m : int ; m := n / 2 - 2 ;
        var i : int ; i := 0 ; while i < j do ( (     var sb : String ; sb := StringLib.newString() ;
     sb := sb + StringLib.newString("1") ; 
        var k : int ; k := 0 ; while k < m do (     sb := sb + StringLib.newString(if (MathLib.bitwiseAnd(i,(1*(2->pow(k)))->oclAsType(long))) = 0 then "0" else "1" endif) ;  ;     k := k + 1 ) ; 
    sb := sb + StringLib.newString("11") ; 
        var k : int ; k := 0 ; while k < m do (     sb := sb + StringLib.newString(if (MathLib.bitwiseAnd(i,(1*(2->pow(k)))->oclAsType(long))) = 0 then "0" else "1" endif) ;  ;     k := k + 1 ) ; 
    sb := sb + StringLib.newString("1") ; 
        var b : int ; b := 2 ; while b <= 10 do (     sb := sb + StringLib.newString(" " + value(i, m, b)) ;  ;     b := b + 1 ) ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMinNumber(int n){
    int count=0,ans=1 ;
    while(n % 2==0){
      count++;
      n/=2 ;
    }
    if(count % 3!=0)ans*=Math.pow(2,(count % 3));
    for(int i=3 ; i<=Math.sqrt(n); i+=2){
      count=0 ;
      while(n % i==0){
        count++;
        n/=i ;
      }
      if(count % 3!=0)ans*=Math.pow(i,(count % 3));
    }
    if(n>2)ans*=n ;
    return ans ;
  }
  public static void main(String[] args){
    int n=128 ;
    System.out.print(findMinNumber(n)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMinNumber( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
    var ans : int ; ans := 1 ;
     while (n mod 2 = 0) do (     count := count + 1 ; 
     n := n/(2) ) ; 
    if (count mod 3 /= 0) then     ans := ans*(2->pow((count mod 3))) ; else skip ; 
        var i : int ; i := 3 ; while i <= (n)->sqrt() do ( (     count := 0 ; 
     while (n mod i = 0) do (     count := count + 1 ; 
     n := n/(i) ) ; 
     if (count mod 3 /= 0) then     ans := ans*(i->pow((count mod 3))) ; else skip )  ;     i := i+(2) ) ; 
    if (n > 2) then     ans := ans*(n) ; else skip ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 128 ;
     OclFile["System.out"].print(findMinNumber(n) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMinNumber(int n){
    int count=0,ans=1 ;
    while(n % 2==0){
      count++;
      n/=2 ;
    }
    if(count % 2==1)ans*=2 ;
    for(int i=3 ; i<=Math.sqrt(n); i+=2){
      count=0 ;
      while(n % i==0){
        count++;
        n/=i ;
      }
      if(count % 2==1)ans*=i ;
    }
    if(n>2)ans*=n ;
    return ans ;
  }
  public static void main(String[] args){
    int n=72 ;
    System.out.println(findMinNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMinNumber( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
    var ans : int ; ans := 1 ;
     while (n mod 2 = 0) do (     count := count + 1 ; 
     n := n/(2) ) ; 
    if (count mod 2 = 1) then     ans := ans*(2) ; else skip ; 
        var i : int ; i := 3 ; while i <= (n)->sqrt() do ( (     count := 0 ; 
     while (n mod i = 0) do (     count := count + 1 ; 
     n := n/(i) ) ; 
     if (count mod 2 = 1) then     ans := ans*(i) ; else skip )  ;     i := i+(2) ) ; 
    if (n > 2) then     ans := ans*(n) ; else skip ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 72 ;
     OclFile["System.out"].println(findMinNumber(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Eleven {
  public static void main(String[] args)throws IOException {
    FastScanner sc=new FastScanner();
    int n=sc.nextInt();
    List<Integer>list=new ArrayList<>();
    list.add(1);
    int ans=1+1 ;
    int i=2 ;
    while(ans<=n){
      list.add(ans);
      ans=list.get(i-1)+list.get(i-2);
      i++;
    }
    HashSet<Integer>set=new HashSet<>(list);
    String res="" ;
    for(int j=1 ; j<=n ; j++){
      if(set.contains(j))res+='O' ;
      else res+='o' ;
    }
    System.out.println(res);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Eleven {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner() ;
     var n : int ; n := sc.nextInt() ;
    var list : Sequence(int) ; list := Sequence{} ;
    list := list->including(1) ; 
    var ans : int ; ans := 1 + 1 ;
    var i : int ; i := 2 ;
    while (ans <= n) do (     list := list->including(ans) ; 
     ans := list->at(i - 1+1) + list->at(i - 2+1) ; 
     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{}->union(list) ;
    var res : String ; res := "" ;
        var j : int ; j := 1 ; while j <= n do ( (     if (set->includes(j)) then     res := res+('O') ; else     res := res+('o') ; )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class FiboName {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=1,b=1 ;
    String ans="" ;
    for(int i=1 ; i<=n ; i++){
      if(i==b){
        ans+='O' ;
        int temp=b ;
        b+=a ;
        a=temp ;
      }
      else ans+='o' ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class FiboName {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := 1 ;
    var b : int ; b := 1 ;
    var ans : String ; ans := "" ;
        var i : int ; i := 1 ; while i <= n do ( (     if (i = b) then (     ans := ans+('O') ; 
     var temp : int ; temp := b ;
     b := b+(a) ; 
     a := temp ) else     ans := ans+('o') ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
import java.util.Set ;
public class P918A {
  public static void main(String[] args)throws IOException {
    BufferedReader io=new BufferedReader(new InputStreamReader(System.in));
    Integer n=Integer.valueOf(io.readLine());
    int i=1 ;
    int j=1 ;
    Set<Integer>set=new HashSet<Integer>();
    set.add(1);
    while(j<=n){
      j=i+j ;
      i=j-i ;
      set.add(j);
    }
    StringBuffer rs=new StringBuffer();
    int len=1 ;
    while(len<=n){
      if(set.contains(Integer.valueOf(len))){
        rs.append("O");
      }
      else {
        rs.append("o");
      }
      len++;
    }
    System.out.println(rs.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class P918A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (io.readLine())->toInteger() ;
    var i : int ; i := 1 ;
    var j : int ; j := 1 ;
    var set : Set(int) ; set := Set{} ;
    set := set->including(1) ; 
    while (j <= n) do (     j := i + j ; 
     i := j - i ; 
     set := set->including(j) ) ; 
    var rs : String ; rs := StringLib.newString() ;
    var len : int ; len := 1 ;
    while (len <= n) do (     if (set->includes((len)->toInteger())) then (     rs := rs + StringLib.newString("O") ) else (     rs := rs + StringLib.newString("o") ) ;  
     len := len + 1 ) ; 
    OclFile["System.out"].println(rs+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void printHutStar(int n){
    int i,j ;
    for(i=0 ; i<n ; i++){
      for(j=i+1 ; j<n ; j++)System.out.print(" ");
      for(j=0 ; j<(2*i+1); j++)System.out.print("*");
      System.out.println();
    }
    for(i=0 ; i<3 ; i++){
      for(j=0 ; j<3 ; j++)System.out.print("*");
      for(j=0 ; j<(2*n-7); j++)System.out.print(" ");
      for(j=0 ; j<3 ; j++)System.out.print("*");
      System.out.println();
    }
  }
  public static void main(String args[]){
    int n=7 ;
    printHutStar(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printHutStar( n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := 0 ; while i < n do ( (         j := i + 1 ; while j < n do (     OclFile["System.out"].print(" ") ;  ;     j := j + 1 ) ; 
         j := 0 ; while j < (2 * i + 1) do (     OclFile["System.out"].print("*") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
         i := 0 ; while i < 3 do ( (         j := 0 ; while j < 3 do (     OclFile["System.out"].print("*") ;  ;     j := j + 1 ) ; 
         j := 0 ; while j < (2 * n - 7) do (     OclFile["System.out"].print(" ") ;  ;     j := j + 1 ) ; 
         j := 0 ; while j < 3 do (     OclFile["System.out"].print("*") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     execute printHutStar(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findNthRoot(double x,int n){
    double low,high ;
    if(x>=0 && x<=1){
      low=x ;
      high=1 ;
    }
    else {
      low=1 ;
      high=x ;
    }
    double epsilon=0.00000001 ;
    double guess=(low+high)/2 ;
    while(Math.abs((Math.pow(guess,n))-x)>=epsilon){
      if(Math.pow(guess,n)>x){
        high=guess ;
      }
      else {
        low=guess ;
      }
      guess=(low+high)/2 ;
    }
    System.out.println(guess);
  }
  public static void main(String[] args){
    double x=5 ;
    int n=2 ;
    findNthRoot(x,n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNthRoot( x : double, n : int) : void
  pre: true
  post: true
  activity: (     var low : double ;
    var high : double ;
     if (x >= 0 & x <= 1) then (     low := x ; 
     high := 1 ) else (     low := 1 ; 
     high := x ) ;  
    var epsilon : double ; epsilon := 0.00000001 ;
    var guess : double ; guess := (low + high) / 2 ;
    while (if (guess->pow(n)) - x < 0 then -((guess->pow(n)) - x) else (guess->pow(n)) - x endif >= epsilon) do (     if (guess->pow(n) > x) then (     high := guess ) else (     low := guess ) ;  
     guess := (low + high) / 2 ) ; 
    OclFile["System.out"].println(guess) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : double ; x := 5 ;
     var n : int ; n := 2 ;
     execute findNthRoot(x, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printStrings(String s,int l,int m){
    Set<String>c=new LinkedHashSet<>();
    s=s+s ;
    for(int i=0 ; i<l ; i++){
      c.add(s.substring(i,i+m));
    }
    Iterator itr=c.iterator();
    while(itr.hasNext()){
      String a=(String)itr.next();
      System.out.print(a+" ");
    }
    c.clear();
  }
  public static void main(String[] args){
    String str="saurav" ;
    int N=str.length();
    int M=4 ;
    printStrings(str,N,M);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printStrings( s : String, l : int, m : int) : void
  pre: true
  post: true
  activity: (     var c : Set(String) ; c := Set{} ;
     s := s + s ; 
        var i : int ; i := 0 ; while i < l do ( (     c := c->including(s.subrange(i+1,i + m)) )  ;     i := i + 1 ) ; 
    var itr : OclIterator ; itr := c->iterator() ;
    while (itr.hasNext()) do (     var a : String ; a := itr.next()->oclAsType(String) ;
     OclFile["System.out"].print(a + " ") ) ; 
    c := c->intersection(Set{}) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "saurav" ;
     var N : int ; N := str->size() ;
     var M : int ; M := 4 ;
     execute printStrings(str, N, M) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    for(int i=0 ; i<n ; i++){
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      if(b<a){
        System.out.println("Happy Alex");
        return ;
      }
    }
    System.out.println("Poor Alex");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
     if (b < a) then (     OclFile["System.out"].println("Happy Alex") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Poor Alex") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class BinarySearch {
  int binarySearch(int arr[],int l,int r,int x){
    if(r>=l){
      int mid=l+(r-l)/2 ;
      if(arr[mid]==x)return mid ;
      if(arr[mid]>x)return binarySearch(arr,l,mid-1,x);
      return binarySearch(arr,mid+1,r,x);
    }
    return-1 ;
  }
  public static void main(String args[]){
    BinarySearch ob=new BinarySearch();
    int arr[]={
      2,3,4,10,40 };
      int n=arr.length ;
      int x=10 ;
      int result=ob.binarySearch(arr,0,n-1,x);
      if(result==-1)System.out.println("Element not present");
      else System.out.println("Element found at index "+result);
    }
  }

------------------------------------------------------------
OCL File:
---------
class BinarySearch {
   operation binarySearch( arr : Sequence(int), l : int, r : int, x : int) : int
  pre: true
  post: true
  activity: (     if (r >= l) then (     var mid : int ; mid := l + (r - l) / 2 ;
     if (arr[mid+1] = x) then     return mid else skip ; 
     if (arr[mid+1] > x) then     return binarySearch(arr, l, mid - 1, x) else skip ; 
     return binarySearch(arr, mid + 1, r, x) ) else skip ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ob : BinarySearch ; ob := BinarySearch.newBinarySearch() ;
     var arr : Sequence(int) ; arr := Sequence{2,3,4,10,40} ;
    var n : int ; n := arr->size() ;
    var x : int ; x := 10 ;
    var result : int ; result := ob.binarySearch(arr, 0, n - 1, x) ;
    if (result = -1) then     OclFile["System.out"].println("Element not present") else     OclFile["System.out"].println("Element found at index " + result) ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class BinarySearch {
  int binarySearch(int arr[],int x){
    int l=0,r=arr.length-1 ;
    while(l<=r){
      int m=l+(r-l)/2 ;
      if(arr[m]==x)return m ;
      if(arr[m]<x)l=m+1 ;
      else r=m-1 ;
    }
    return-1 ;
  }
  public static void main(String args[]){
    BinarySearch ob=new BinarySearch();
    int arr[]={
      2,3,4,10,40 };
      int n=arr.length ;
      int x=10 ;
      int result=ob.binarySearch(arr,x);
      if(result==-1)System.out.println("Element not present");
      else System.out.println("Element found at "+"index "+result);
    }
  }

------------------------------------------------------------
OCL File:
---------
class BinarySearch {
   operation binarySearch( arr : Sequence(int), x : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
    var r : int ; r := arr->size() - 1 ;
     while (l <= r) do (     var m : int ; m := l + (r - l) / 2 ;
     if (arr[m+1] = x) then     return m else skip ; 
     if (arr[m+1] < x) then     l := m + 1 ; else     r := m - 1 ; ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ob : BinarySearch ; ob := BinarySearch.newBinarySearch() ;
     var arr : Sequence(int) ; arr := Sequence{2,3,4,10,40} ;
    var n : int ; n := arr->size() ;
    var x : int ; x := 10 ;
    var result : int ; result := ob.binarySearch(arr, x) ;
    if (result = -1) then     OclFile["System.out"].println("Element not present") else     OclFile["System.out"].println("Element found at " + "index " + result) ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class A {
  public static void main(String[] args){
    int x=(new Scanner(System.in)).nextInt();
    String s=Integer.toString(++x);
    while(true){
      boolean b=false ;
      for(int i=0 ; i<s.length(); i++){
        if(s.charAt(i)=='8')b=true ;
      }
      if(b)break ;
      s=Integer.toString(Integer.parseInt(s)+1);
    }
    out.println(Integer.parseInt(s)-(--x));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := (OclFile.newOclFile_Read(OclFile["System.in"])).nextInt() ;
     var s : String ; s := (((x + 1)) + "") ;
     while (true) do (     var b : boolean ; b := false ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '8') then     b := true ; else skip )  ;     i := i + 1 ) ; 
     if (b) then     break else skip ; 
     s := (((s)->toInteger() + 1) + "") ) ; 
     x := x - 1 ;
    out.println((s)->toInteger() - (x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Code {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long diff=0 ;
    boolean flag=false ;
    for(int i=(int)n+1 ; i<n+20 && ! flag ; i++){
      flag=isLuckyNumber((long)i);
      if(flag){
        diff=i-n ;
      }
    }
    System.out.println(diff);
  }
  public static boolean isLuckyNumber(long n){
    n=Math.abs(n);
    while(n>0){
      long r=n % 10 ;
      if(r==8){
        return true ;
      }
      n=n/10 ;
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var diff : long ; diff := 0 ;
    var flag : boolean ; flag := false ;
        var i : int ; i := n->oclAsType(int) + 1 ; while i < n + 20 & not(flag) do ( (     flag := isLuckyNumber(i->oclAsType(long)) ; 
     if (flag) then (     diff := i - n ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(diff) ; 
 );
  static   operation isLuckyNumber( n : long) : boolean
  pre: true
  post: true
  activity: (     n := if n < 0 then -(n) else n endif ; 
     while (n > 0) do (     var r : long ; r := n mod 10 ;
     if (r = 8) then (     return true ) else skip ; 
     n := n / 10 ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Code {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long diff=0 ;
    boolean flag=false ;
    for(int i=(int)n+1 ; i<n+20 && ! flag ; i++){
      flag=isLuckyNumber((long)i);
      if(flag){
        diff=i-n ;
      }
    }
    System.out.println(diff);
  }
  public static boolean isLuckyNumber(long n){
    n=Math.abs(n);
    String str=Long.toString(n);
    int idx=str.indexOf('8');
    if(idx==-1){
      return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var diff : long ; diff := 0 ;
    var flag : boolean ; flag := false ;
        var i : int ; i := n->oclAsType(int) + 1 ; while i < n + 20 & not(flag) do ( (     flag := isLuckyNumber(i->oclAsType(long)) ; 
     if (flag) then (     diff := i - n ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(diff) ; 
 );
  static   operation isLuckyNumber( n : long) : boolean
  pre: true
  post: true
  activity: (     n := if n < 0 then -(n) else n endif ; 
     var str : String ; str := ((n) + "") ;
    var idx : int ; idx := str->indexOf('8')-1 ;
    if (idx = -1) then (     return false ) else skip ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    int cnt=0 ;
    long val=8888888888L ;
    while(n<=val){
      if(check(n)&& cnt>0){
        break ;
      }
      else {
        n++;
        cnt++;
      }
    }
    System.out.println(cnt);
  }
  static boolean check(Long n){
    if(n<0)n=n*-1 ;
    while(n>0){
      if(n % 10==8)return true ;
      n=n/10 ;
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var cnt : int ; cnt := 0 ;
    var val : long ; val := 8888888888L ;
    while (n <= val) do (     if (check(n) & cnt > 0) then (     break ) else (     n := n + 1 ; 
     cnt := cnt + 1 ) ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
  static   operation check( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n < 0) then     n := n * -1 ; else skip ; 
     while (n > 0) do (     if (n mod 10 = 8) then     return true else skip ; 
     n := n / 10 ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package fly ;
public class Point {
  public double x ;
  public double y ;
  public Point(double x,double y){
    this.x=x ;
    this.y=y ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Point {
   attribute x : double;
   attribute y : double;
   static operation newPoint( x : double, y : double) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    StringTokenizer st=new StringTokenizer(f.readLine());
    long k=Long.parseLong(st.nextToken());
    long d=Long.parseLong(st.nextToken());
    long t=Long.parseLong(st.nextToken())*2 ;
    long temp ;
    if(k<=d){
      temp=d ;
    }
    else {
      temp=k/d*d ;
      if(temp<k){
        temp+=d ;
      }
    }
    long temp2=k+temp ;
    long temp3=t/temp2 ;
    long temp4=t-temp3*temp2 ;
    double temp5 ;
    if(temp4<=k*2){
      temp5=temp4/2.0 ;
    }
    else {
      temp5=temp4-k ;
    }
    out.println(temp*temp3+temp5);
    f.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
    var k : long ; k := (st.next())->toLong() ;
    var d : long ; d := (st.next())->toLong() ;
    var t : long ; t := (st.next())->toLong() * 2 ;
    var temp : long ;
    if (k <= d) then (     temp := d ) else (     temp := k / d * d ; 
     if (temp < k) then (     temp := temp+(d) ) else skip ) ;  
    var temp2 : long ; temp2 := k + temp ;
    var temp3 : long ; temp3 := t / temp2 ;
    var temp4 : long ; temp4 := t - temp3 * temp2 ;
    var temp5 : double ;
    if (temp4 <= k * 2) then (     temp5 := temp4 / 2.0 ) else (     temp5 := temp4 - k ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  int[] memo ;
  ArrayList<Integer>lh,lr ;
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)return ;
      lh=new ArrayList<Integer>();
      lr=new ArrayList<Integer>();
      for(int i=0 ; i<n ; i++){
        lh.add(sc.nextInt());
        lr.add(sc.nextInt());
      }
      int m=sc.nextInt();
      for(int i=0 ; i<m ; i++){
        lh.add(sc.nextInt());
        lr.add(sc.nextInt());
      }
      memo=new int[lh.size()];
      Arrays.fill(memo,-1);
      int max=0 ;
      for(int i=0 ; i<lh.size(); i++)max=Math.max(max,solve(i));
      System.out.println(++max);
    }
  }
  int solve(int ii){
    if(memo[ii]!=-1)return memo[ii];
    int res=0 ;
    for(int i=0 ; i<lh.size(); i++){
      if(lh.get(i)<lh.get(ii)&& lr.get(i)<lr.get(ii))res=Math.max(res,solve(i)+1);
    }
    return memo[ii]=res ;
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute memo : Sequence(int);
   attribute lh : Sequence(int);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    lh := Sequence{} ; 
    lr := Sequence{} ; 
        var i : int ; i := 0 ; while i < n do ( (     lh := lh->including(sc.getCurrent()->toInteger()) ; 
     lr->excludes(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     lh := lh->including(sc.getCurrent()->toInteger()) ; 
     lr->excludes(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    memo := Integer.subrange(1,lh->size())->collect(0) ; 
    memo := memo->collect(-1) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < lh->size() do (     max := Set{max, solve(i)}->max() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((max + 1)) ; 
 )  ) );
   operation solve( ii : int) : int
  pre: true
  post: true
  activity: (     if (memo[ii+1] /= -1) then     return memo[ii+1] else skip ; 
     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < lh->size() do ( (     if (lh->at(i+1) < lh->at(ii+1) & lr->at(i+1) < lr->at(ii+1)) then     res := Set{res, solve(i) + 1}->max() ; else skip )  ;     i := i + 1 ) ; 
     return memo[ii+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  static int maxNewElements(int[] a,int n){
    int gcd=a[0];
    int mx=a[0];
    for(int i=1 ; i<n ; i++){
      gcd=__gcd(gcd,a[i]);
      mx=Math.max(mx,a[i]);
    }
    int total_terms=mx/gcd ;
    return total_terms-n ;
  }
  public static void main(String args[]){
    int a[]={
      4,6,10 };
      int n=a.length ;
      System.out.print(maxNewElements(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation maxNewElements( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var gcd : int ; gcd := a[0+1] ;
     var mx : int ; mx := a[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     gcd := __gcd(gcd, a[i+1]) ; 
     mx := Set{mx, a[i+1]}->max() )  ;     i := i + 1 ) ; 
    var total_terms : int ; total_terms := mx / gcd ;
    return total_terms - n 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{4,6,10} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(maxNewElements(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static ArrayList md=new ArrayList();
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] a=new int[n];
    int[] b=new int[n];
    int temp=0 ;
    int q=0 ;
    int w=0,e=0 ;
    boolean f=false ;
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
      b[i]=in.nextInt();
      if(temp<a[i]){
        if(q>b[i]){
          f=true ;
        }
        q=b[i];
        temp=a[i];
      }
      if(temp>a[i]){
        if(q<b[i]){
          f=true ;
        }
        q=b[i];
        temp=a[i];
      }
      if(a[i]>w){
        w=a[i];
        if(b[i]<e){
          f=true ;
        }
        e=b[i];
      }
      if(a[i]<w){
        if(b[i]>e){
          f=true ;
        }
      }
    }
    if(f==true){
      System.out.println("Happy Alex");
    }
    else System.out.println("Poor Alex");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute md : Sequence := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var temp : int ; temp := 0 ;
    var q : int ; q := 0 ;
    var w : int ; w := 0 ;
    var e : int ; e := 0 ;
    var f : boolean ; f := false ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     b[i+1] := in.getCurrent()->toInteger() ; 
    if (temp < a[i+1]) then (     if (q > b[i+1]) then (     f := true ) else skip ; 
     q := b[i+1] ; 
     temp := a[i+1] ) else skip ; 
    if (temp > a[i+1]) then (     if (q < b[i+1]) then (     f := true ) else skip ; 
     q := b[i+1] ; 
     temp := a[i+1] ) else skip ; 
    if (a[i+1] > w) then (     w := a[i+1] ; 
     if (b[i+1] < e) then (     f := true ) else skip ; 
     e := b[i+1] ) else skip ; 
    if (a[i+1] < w) then (     if (b[i+1] > e) then (     f := true ) else skip ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (f = true) then (     OclFile["System.out"].println("Happy Alex") ) else     OclFile["System.out"].println("Poor Alex") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.Arrays ;
class GFG {
  static boolean check(String s,int l){
    int freq[]=new int[26];
    Arrays.fill(freq,0);
    for(int i=0 ; i<l ; i++){
      freq[s.charAt(i)-'a']++;
    }
    for(int i=0 ; i<26 ; i++){
      if(freq[i]>=2)return true ;
    }
    return false ;
  }
  public static void main(String args[]){
    String s="geeksforgeeks" ;
    int l=s.length();
    if(check(s,l))System.out.print("YES");
    else System.out.print("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( s : String, l : int) : boolean
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
     freq := freq->collect(0) ; 
        var i : int ; i := 0 ; while i < l do ( (     freq[s->at(i+1) - ('a')->char2byte()+1] := freq[s->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 26 do ( (     if (freq[i+1] >= 2) then     return true else skip )  ;     i := i + 1 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     var l : int ; l := s->size() ;
     if (check(s, l)) then     OclFile["System.out"].print("YES") ; else     OclFile["System.out"].print("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] s=sc.next().toCharArray();
    int n=s.length ;
    int[] a=new int[128];
    for(int i=0 ; i<n ; i++){
      a[s[i] ]++;
    }
    int odd=0 ;
    int sum=0 ;
    for(int i=0 ; i<128 ; i++){
      if(a[i] % 2==1){
        odd++;
        a[i]--;
      }
      a[i]/=2 ;
      sum+=a[i];
    }
    if(odd>=2){
      System.out.println(0);
      return ;
    }
    long[] fact=new long[41];
    fact[0]=1 ;
    for(int i=1 ; i<=40 ; i++){
      fact[i]=fact[i-1]*i ;
    }
    long ans=fact[sum];
    for(int i=0 ; i<128 ; i++){
      ans/=fact[a[i] ];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var n : int ; n := s->size() ;
    var a : Sequence(int) ; a := Integer.subrange(1,128)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[s[i+1]+1] := a[s[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var odd : int ; odd := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 128 do ( (     if (a[i+1] mod 2 = 1) then (     odd := odd + 1 ; 
     a[i+1] := a[i+1] - 1 ) else skip ; 
     a[i+1] := a[i+1]/(2) ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    if (odd >= 2) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var fact : Sequence(long) ; fact := Integer.subrange(1,41)->collect(0) ;
    fact[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= 40 do ( (     fact[i+1] := fact[i - 1+1] * i )  ;     i := i + 1 ) ; 
    var ans : long ; ans := fact[sum+1] ;
        var i : int ; i := 0 ; while i < 128 do ( (     ans := ans/(fact[a[i+1]+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  static BigInteger[] facts ;
  public static void main(String[] args)throws IOException {
    facts=new BigInteger[27];
    facts[0]=BigInteger.ONE ;
    for(int i=1 ; i<=26 ; i++){
      facts[i]=facts[i-1] .multiply(BigInteger.valueOf(i));
    }
    char[] s=new BufferedReader(new InputStreamReader(System.in)).readLine().toCharArray();
    int[] a=new int[26];
    for(char c : s){
++a[c-'a'];
    }
    System.out.println(s.length % 2==0 ? evenCase(a): oddCase(a));
  }
  static BigInteger evenCase(int[] a){
    BigInteger y=BigInteger.ONE ;
    int n=0 ;
    for(int x : a){
      if(x % 2!=0){
        return BigInteger.ZERO ;
      }
      n+=x/2 ;
      y=y.multiply(facts[x/2]);
    }
    return facts[n] .divide(y);
  }
  static BigInteger oddCase(int[] a){
    for(int i=0 ; i<26 ; i++){
      if(a[i] % 2!=1){
        continue ;
      }
--a[i];
      return evenCase(a);
    }
    return BigInteger.ZERO ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute facts : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     facts := Integer.subrange(1,27)->collect(null) ; 
     facts[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= 26 do ( (     facts[i+1] := facts[i - 1+1].multiply((i + "")->toLong()) )  ;     i := i + 1 ) ; 
    var s : Sequence(String) ; s := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])).readLine()->characters() ;
    var a : Sequence(int) ; a := Integer.subrange(1,26)->collect(0) ;
    for (c : s) do ( (     a[c - ('a')->char2byte()+1] := a[c - ('a')->char2byte()+1] + 1 )  ) ; 
    OclFile["System.out"].println(if s->size() mod 2 = 0 then evenCase(a) else oddCase(a) endif) ; 
 );
  static   operation evenCase( a : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var y : long ; y := 1 ;
     var n : int ; n := 0 ;
     for (x : a) do ( (     if (x mod 2 /= 0) then (     return 0 ) else skip ; 
     n := n+(x / 2) ; 
     y := y.multiply(facts[x / 2+1]) )  ) ; 
     return facts[n+1].divide(y) );
  static   operation oddCase( a : Sequence(int)) : long
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 26 do ( (     if (a[i+1] mod 2 /= 1) then (     continue ) else skip ; 
     a[i+1] := a[i+1] - 1 ; 
     return evenCase(a) )  ;     i := i + 1 ) ; 
     return 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.StringBuffer ;
class Main {
  public static long fact(int n){
    long ret=1 ;
    for(int i=n ; i>=1 ; i--){
      ret*=i ;
    }
    return ret ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=new String(in.next());
    int[] count=new int[26];
    for(int i=0 ; i<s.length(); i++){
      count[s.charAt(i)-'a']++;
    }
    int nOdd=0 ;
    long div=1 ;
    for(int i=0 ; i<26 ; i++){
      if(count[i] % 2==1){
        nOdd++;
      }
      div*=fact(count[i]/2);
    }
    if(nOdd!=s.length()% 2){
      System.out.println(0);
    }
    else {
      System.out.println(fact(s.length()/2)/div);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation fact( n : int) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := 1 ;
         var i : int ; i := n ; while i >= 1 do ( (     ret := ret*(i) )  ;     i := i - 1 ) ; 
     return ret );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := StringLib.newString(in.getCurrent()) ;
    var count : Sequence(int) ; count := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     count[s->at(i+1) - ('a')->char2byte()+1] := count[s->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    var nOdd : int ; nOdd := 0 ;
    var div : long ; div := 1 ;
        var i : int ; i := 0 ; while i < 26 do ( (     if (count[i+1] mod 2 = 1) then (     nOdd := nOdd + 1 ) else skip ; 
     div := div*(fact(count[i+1] / 2)) )  ;     i := i + 1 ) ; 
    if (nOdd /= s->size() mod 2) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(fact(s->size() / 2) / div) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String s=in.readLine();
    int[] alpha=new int[30];
    for(int i=0 ; i<30 ; i++)alpha[i]=0 ;
    for(int i=0 ; i<s.length(); i++)alpha[s.charAt(i)-'a']++;
    int cnt=0 ;
    for(int i=0 ; i<27 ; i++){
      if(alpha[i] % 2==1)cnt++;
      if(cnt>=2)break ;
    }
    if(cnt>=2){
      System.out.println("0");
    }
    else {
      int n=0 ;
      int[] counter=new int[28];
      int index=0 ;
      for(int i=0 ; i<28 ; i++){
        if(alpha[i]==0)continue ;
        if(alpha[i] % 2==1)alpha[i]--;
        counter[index++]=alpha[i]/2 ;
        n+=alpha[i]/2 ;
        counter[index]=-1 ;
      }
      BigInteger N=new BigInteger("1");
      BigInteger abc=new BigInteger("1");
      for(int i=2 ; i<=n ; i++)N=N.multiply(new BigInteger(Integer.toString(i)));
      for(int i=0 ; i<28 ; i++){
        if(counter[i]==-1)break ;
        for(int j=2 ; j<=counter[i]; j++){
          abc=abc.multiply(new BigInteger(Integer.toString(j)));
        }
      }
      System.out.println(N.divide(abc));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := in.readLine() ;
    var alpha : Sequence(int) ; alpha := Integer.subrange(1,30)->collect(0) ;
        var i : int ; i := 0 ; while i < 30 do (     alpha[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < s->size() do (     alpha[s->at(i+1) - ('a')->char2byte()+1] := alpha[s->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < 27 do ( (     if (alpha[i+1] mod 2 = 1) then     cnt := cnt + 1 ; else skip ; 
     if (cnt >= 2) then     break else skip )  ;     i := i + 1 ) ; 
    if (cnt >= 2) then (     OclFile["System.out"].println("0") ) else (     var n : int ; n := 0 ;
     var counter : Sequence(int) ; counter := Integer.subrange(1,28)->collect(0) ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < 28 do ( (     if (alpha[i+1] = 0) then     continue else skip ; 
     if (alpha[i+1] mod 2 = 1) then     alpha[i+1] := alpha[i+1] - 1 ; else skip ; 
     counter[index+1] := alpha[i+1] / 2  ; index := index + 1 ; 
    n := n+(alpha[i+1] / 2) ; 
    counter[index+1] := -1 ; 
 )  ;     i := i + 1 ) ; 
    var N : long ; N := long("1") ;
    var abc : long ; abc := long("1") ;
        var i : int ; i := 2 ; while i <= n do (     N := N.multiply(long(((i) + ""))) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 28 do ( (     if (counter[i+1] = -1) then     break else skip ; 
         var j : int ; j := 2 ; while j <= counter[i+1] do ( (     abc := abc.multiply(long(((j) + ""))) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(N.divide(abc)) ; 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  long[] kaijo ;
  int[] a ;
  String s ;
  int len ;
  void init(){
    kaijo=new long[21];
    kaijo[0]=1 ;
    for(int i=1 ; i<kaijo.length ; i++){
      kaijo[i]=kaijo[i-1]*i ;
    }
  }
  void run(){
    init();
    Scanner sc=new Scanner(System.in);
    a=new int[256];
    s=sc.next();
    len=s.length();
    for(int i=0 ; i<len ; i++)a[s.charAt(i)]++;
    System.out.println(count(s));
  }
  long count(String s){
    long res=kaijo[len/2];
    if(len % 2==0){
      for(int i=0 ; i<a.length ; i++)if(a[i] % 2==1)return 0L ;
      for(int i=0 ; i<a.length ; i++){
        if(a[i]>=2)res/=kaijo[a[i]/2];
      }
    }
    else {
      int k=0 ;
      char c='#' ;
      for(int i=0 ; i<a.length ; i++){
        if(a[i] % 2==1){
          c=(char)i ;
          k++;
        }
      }
      if(k!=1)return 0L ;
      a[c]--;
      for(int i=0 ; i<a.length ; i++){
        if(a[i]>=2)res/=kaijo[a[i]/2];
      }
    }
    return res ;
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute kaijo : Sequence(long);
   attribute a : Sequence(int);
   attribute s : String;
   attribute len : int;
   operation init() : void
  pre: true
  post: true
  activity: (     kaijo := Integer.subrange(1,21)->collect(0) ; 
     kaijo[0+1] := 1 ; 
         var i : int ; i := 1 ; while i < kaijo->size() do ( (     kaijo[i+1] := kaijo[i - 1+1] * i )  ;     i := i + 1 ) );
   operation run() : void
  pre: true
  post: true
  activity: (     execute init() ; 
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    a := Integer.subrange(1,256)->collect(0) ; 
    s := sc.getCurrent() ; 
    len := s->size() ; 
        var i : int ; i := 0 ; while i < len do (     a[s->at(i+1)+1] := a[s->at(i+1)+1] + 1 ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count(s)) ; 
 );
   operation count( s : String) : long
  pre: true
  post: true
  activity: (     var res : long ; res := kaijo[len / 2+1] ;
     if (len mod 2 = 0) then (         var i : int ; i := 0 ; while i < a->size() do (     if (a[i+1] mod 2 = 1) then     return 0L else skip ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] >= 2) then     res := res/(kaijo[a[i+1] / 2+1]) ; else skip )  ;     i := i + 1 ) ) else (     var k : int ; k := 0 ;
     var c : String ; c := '#' ;
        var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] mod 2 = 1) then (     c := i->oclAsType(String) ; 
     k := k + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (k /= 1) then     return 0L else skip ; 
    a[c+1] := a[c+1] - 1 ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] >= 2) then     res := res/(kaijo[a[i+1] / 2+1]) ; else skip )  ;     i := i + 1 ) ; 
 ) ;  
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class Node {
    int data ;
    Node next ;
  };
  static Node push(Node head_ref,int new_data){
    Node new_node=new Node();
    new_node.data=new_data ;
    new_node.next=head_ref ;
    head_ref=new_node ;
    return head_ref ;
  }
  static void printList(Node head){
    while(head!=null){
      System.out.print(head.data+"->");
      head=head.next ;
    }
  }
  static void sortlist(int arr[],int N,Node head){
    HashMap<Integer,Integer>hash=new HashMap<Integer,Integer>();
    Node temp=head ;
    while(temp!=null){
      if(hash.containsKey(temp.data))hash.put(temp.data,hash.get(temp.data)+1);
      else hash.put(temp.data,1);
      temp=temp.next ;
    }
    temp=head ;
    for(int i=0 ; i<N ; i++){
      int frequency=hash.get(arr[i]);
      while(frequency-->0){
        temp.data=arr[i];
        temp=temp.next ;
      }
    }
  }
  public static void main(String[] args){
    Node head=null ;
    int arr[]={
      5,1,3,2,8 };
      int N=arr.length ;
      head=push(head,3);
      head=push(head,2);
      head=push(head,5);
      head=push(head,8);
      head=push(head,5);
      head=push(head,2);
      head=push(head,1);
      sortlist(arr,N,head);
      System.out.print("Sorted List:"+"\n");
      printList(head);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   operation push( head_ref : Node, new_data : int) : Node
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode() ;
     new_node.data := new_data ; 
    new_node.next := head_ref ; 
    head_ref := new_node ; 
    return head_ref 
 );
  static   operation printList( head : Node) : void
  pre: true
  post: true
  activity: (     while (head /= null) do (     OclFile["System.out"].print(head.data + "->") ; 
     head := head.next ) );
  static   operation sortlist( arr : Sequence(int), N : int, head : Node) : void
  pre: true
  post: true
  activity: (     var hash : Map(int,int) ; hash := Map{} ;
     var temp : Node ; temp := head ;
    while (temp /= null) do (     if (hash->keys()->includes(temp.data)) then     hash := hash->union(Map{temp.data |-> hash->at(temp.data) + 1}) else     hash := hash->union(Map{temp.data |-> 1}) ; ;  
     temp := temp.next ) ; 
    temp := head ; 
        var i : int ; i := 0 ; while i < N do ( (     var frequency : int ; frequency := hash->at(arr[i+1]) ;
         while (frequency > 0) do (        frequency := frequency - 1 ;     skip ; (     temp.data := arr[i+1] ; 
     temp := temp.next ) ;  ) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := null ;
     var arr : Sequence(int) ; arr := Sequence{5,1,3,2,8} ;
    var N : int ; N := arr->size() ;
    head := push(head, 3) ; 
    head := push(head, 2) ; 
    head := push(head, 5) ; 
    head := push(head, 8) ; 
    head := push(head, 5) ; 
    head := push(head, 2) ; 
    head := push(head, 1) ; 
    execute sortlist(arr, N, head) ; 
    OclFile["System.out"].print("Sorted List:" + "\n") ; 
    execute printList(head) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int k=sc.nextInt();
      long a[]=new long[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextLong();
      }
      long b[]=new long[n];
      for(int i=0 ; i<n ; i++){
        b[(i+1)% k]=Math.max(b[(i+1)% k],a[i]);
      }
      long sum=0 ;
      for(int i=0 ; i<k ; i++){
        sum+=b[i];
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     b[(i + 1) mod k+1] := Set{b[(i + 1) mod k+1], a[i+1]}->max() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     sum := sum+(b[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class s {
  public static void main(String[] args)throws Exception {
    BufferedReader infile=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(infile.readLine());
    int t=Integer.parseInt(st.nextToken());
    while(t-->0){
      st=new StringTokenizer(infile.readLine());
      int n=Integer.parseInt(st.nextToken());
      int k=Integer.parseInt(st.nextToken());
      int[] arr=new int[n];
      st=new StringTokenizer(infile.readLine());
      for(int i=0 ; i<n ; i++){
        arr[i]=Integer.parseInt(st.nextToken());
      }
      long res=0 ;
      PriorityQueue<Integer>pq=new PriorityQueue<>();
      int[] ans=new int[k];
      for(int i=0 ; i<n ; i++){
        if(ans[i % k]<arr[i]){
          ans[i % k]=arr[i];
        }
      }
      for(int i=0 ; i<k ; i++){
        res+=ans[i];
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class s {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var infile : OclFile ; infile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(infile.readLine()) ;
     var t : int ; t := (st.next())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     st := OclIterator.newOclIterator_String(infile.readLine()) ; 
     var n : int ; n := (st.next())->toInteger() ;
    var k : int ; k := (st.next())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    st := OclIterator.newOclIterator_String(infile.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
    var pq : Sequence(int) ; pq := Sequence{} ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     if (ans[i mod k+1] < arr[i+1]) then (     ans[i mod k+1] := arr[i+1] ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do ( (     res := res+(ans[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    while(n-->0){
      int a=input.nextInt();
      int b=input.nextInt();
      if(a<b){
        System.out.println("Happy Alex");
        System.exit(0);
      }
    }
    System.out.println("Poor Alex");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var a : int ; a := input.getCurrent()->toInteger() ;
     var b : int ; b := input.getCurrent()->toInteger() ;
     if (a < b) then (     OclFile["System.out"].println("Happy Alex") ; 
 OclProcess.exit(0) ) else skip ) ;  ) ;  
     OclFile["System.out"].println("Poor Alex") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class ConsecutiveSum {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    long output[]=new long[t];
    for(int i=0 ; i<t ; i++){
      output[i]=0 ;
      int n=sc.nextInt();
      int a[]=new int[n];
      int k=sc.nextInt();
      int elements[]=new int[k];
      Arrays.fill(elements,0);
      for(int j=0 ; j<n ; j++){
        a[j]=sc.nextInt();
        int remainder=j % k ;
        if(elements[remainder]<a[j]){
          elements[remainder]=a[j];
        }
      }
      for(int j=0 ; j<k ; j++){
        output[i]+=elements[j];
      }
    }
    for(int i=0 ; i<t ; i++){
      System.out.println(output[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ConsecutiveSum {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var output : Sequence(long) ; output := Integer.subrange(1,t)->collect(0) ;
        var i : int ; i := 0 ; while i < t do ( (     output[i+1] := 0 ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var elements : Sequence(int) ; elements := Integer.subrange(1,k)->collect(0) ;
    elements := elements->collect(0) ; 
        var j : int ; j := 0 ; while j < n do ( (     a[j+1] := sc.getCurrent()->toInteger() ; 
     var remainder : int ; remainder := j mod k ;
     if (elements[remainder+1] < a[j+1]) then (     elements[remainder+1] := a[j+1] ) else skip )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < k do ( (     output[i+1] := output[i+1]+(elements[j+1]) )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < t do ( (     OclFile["System.out"].println(output[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int k=sc.nextInt();
      long a[]=new long[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextLong();
      }
      long b[]=new long[k];
      for(int i=0 ; i<n ; i++){
        b[i % k]=Math.max(b[i % k],a[i]);
      }
      long sum=0 ;
      for(long i : b)sum+=i ;
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var b : Sequence(long) ; b := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     b[i mod k+1] := Set{b[i mod k+1], a[i+1]}->max() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    for (i : b) do (     sum := sum+(i) ;  ) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    System.out.print(n+" ");
    for(int i=1 ; i<=n-1 ; i++){
      System.out.println(i+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
     OclFile["System.out"].print(n + " ") ; 
         var i : int ; i := 1 ; while i <= n - 1 do ( (     OclFile["System.out"].println(i + " ") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class fiftyfour {
  public static void main(String args[])throws Exception {
    BufferedReader inp=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(inp.readLine());
    System.out.print(n+" ");
    for(int i=1 ; i<n ; i++)System.out.print(i+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class fiftyfour {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inp : OclFile ; inp := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (inp.readLine())->toInteger() ;
     OclFile["System.out"].print(n + " ") ; 
         var i : int ; i := 1 ; while i < n do (     OclFile["System.out"].print(i + " ") ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
import java.util.SortedSet ;
import java.util.TreeSet ;
public class ObservationWheel {
  static Scanner sc ;
  static PrintWriter out ;
  public static void main(String[] args)throws IOException {
    sc=new Scanner(new FileReader("D-small-attempt0.in"));
    out=new PrintWriter(new FileWriter("D-small-attempt0.out"));
    int testCases=sc.nextInt();
    for(int testCase=1 ; testCase<=testCases ; testCase++){
      out.println(String.format("Case #%s: %s",testCase,solveCase()));
    }
    out.close();
  }
  static double solveCase(){
    String bits=sc.next();
    N=bits.length();
    memo=new double[1<<N];
    Arrays.fill(memo,-1.0);
    int init=0 ;
    for(int i=0 ; i<N ; i++)if(bits.charAt(i)=='X')init |=1<<i ;
    return solve(init);
  }
  static double solve(int mask){
    if(mask==(1<<N)-1){
      return 0 ;
    }
    if(memo[mask]<-0.5){
      double res=0.0 ;
      for(int index=0 ; index<N ; index++){
        for(int wait=0 ; wait<N ; wait++){
          int exactIndex=(index+wait)% N ;
          if((mask>>exactIndex & 1)==0){
            res+=(N-wait+solve(mask | 1<<exactIndex))/N ;
            break ;
          }
        }
      }
      memo[mask]=res ;
    }
    return memo[mask];
  }
  static double[] memo ;
  static int N ;
}
------------------------------------------------------------
OCL File:
---------
 class ObservationWheel {
  static   attribute sc : OclFile;
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("D-small-attempt0.in"))) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("D-small-attempt0.out"))) ; 
    var testCases : int ; testCases := sc.getCurrent()->toInteger() ;
        var testCase : int ; testCase := 1 ; while testCase <= testCases do ( (     skip )  ;     testCase := testCase + 1 ) ; 
    skip ; 
 );
  static   operation solveCase() : double
  pre: true
  post: true
  activity: (     var bits : String ; bits := sc.getCurrent() ;
     N := bits->size() ; 
    memo := Integer.subrange(1,(1*(2->pow(N)))->oclAsType(long))->collect(0.0) ; 
    memo := memo->collect(-1.0) ; 
    var init : int ; init := 0 ;
        var i : int ; i := 0 ; while i < N do (     if (bits->at(i+1) = 'X') then     init := MathLib.bitwiseOr(init, (1*(2->pow(i)))->oclAsType(long)) ; else skip ;  ;     i := i + 1 ) ; 
    return solve(init) 
 );
  static   operation solve( mask : int) : double
  pre: true
  post: true
  activity: (     if (mask = ((1*(2->pow(N)))->oclAsType(long)) - 1) then (     return 0 ) else skip ; 
     if (memo[mask+1] < -0.5) then (     var res : double ; res := 0.0 ;
         var index : int ; index := 0 ; while index < N do ( (         var wait : int ; wait := 0 ; while wait < N do ( (     var exactIndex : int ; exactIndex := (index + wait) mod N ;
     if ((MathLib.bitwiseAnd((mask/(2->pow(exactIndex)))->oclAsType(long),1)) = 0) then (     res := res+((N - wait + solve(mask or (1*(2->pow(exactIndex)))->oclAsType(long))) / N) ; 
     break ) else skip )  ;     wait := wait + 1 ) )  ;     index := index + 1 ) ; 
     memo[mask+1] := res ) else skip ; 
     return memo[mask+1] );
  static   attribute memo : Sequence(double);
  static   attribute N : int;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class D {
  static boolean bit_set(int set,int bit){
    return((set>>>bit)& 1)==1 ;
  }
  static Double[][] DP=new Double[21][1<<20];
  static double f(int n,int used){
    if(used==(1<<n)-1)return 0 ;
    if(DP[n][used]!=null)return DP[n][used];
    double ans=0 ;
    for(int i=0 ; i<n ; i++){
      int nxt=i ;
      int money=n ;
      while(bit_set(used,nxt)){
        nxt=(nxt+1)% n ;
        money--;
      }
      ans+=1.0/n*(money+f(n,used | 1<<nxt));
    }
    return DP[n][used]=ans ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int cas=1 ; cas<=T ; cas++){
      char[] S=in.next().toCharArray();
      int used=0 ;
      for(int i=0 ; i<S.length ; i++)if(S[i]=='X')used |=1<<i ;
      System.out.printf("Case #%d: %.10f\n",cas,f(S.length,used));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   operation bit_set( set : int, bit : int) : boolean
  pre: true
  post: true
  activity: (     return (((set/(2->pow(bit)))->oclAsType(long)) & 1) = 1 );
  static   attribute DP : Sequence(Sequence(double)) := Integer.subrange(1,21)->collect(Integer.subrange(1,(1*(2->pow(20)))->oclAsType(long))->collect(null));
  static   operation f( n : int, used : int) : double
  pre: true
  post: true
  activity: (     if (used = ((1*(2->pow(n)))->oclAsType(long)) - 1) then     return 0 else skip ; 
     if (DP[n+1][used+1] /= null) then     return DP[n+1][used+1] else skip ; 
    var ans : double ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var nxt : int ; nxt := i ;
     var money : int ; money := n ;
     while (bit_set(used, nxt)) do (     nxt := (nxt + 1) mod n ; 
     money := money - 1 ) ; 
     ans := ans+(1.0 / n * (money + f(n, used or (1*(2->pow(nxt)))->oclAsType(long)))) )  ;     i := i + 1 ) ; 
    return DP[n+1][used+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var cas : int ; cas := 1 ; while cas <= T do ( (     var S : Sequence(String) ; S := in.getCurrent()->characters() ;
     var used : int ; used := 0 ;
         var i : int ; i := 0 ; while i < S->size() do (     if (S[i+1] = 'X') then     used := MathLib.bitwiseOr(used, (1*(2->pow(i)))->oclAsType(long)) ; else skip ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].printf("Case #%d: %.10f\n", cas, f(S->size(), used)) )  ;     cas := cas + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class D {
  private static String fileName=D.class.getSimpleName().replaceFirst("_.*","").toLowerCase();
  private static String inputFileName=fileName+".in" ;
  private static String outputFileName=fileName+".out" ;
  private static Scanner in ;
  private static PrintWriter out ;
  private void solve(){
    String s=in.next();
    int n=s.length();
    int init=0 ;
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='.'){
        init |=1<<i ;
      }
    }
    double[] a=new double[1<<n];
    for(int mask=1 ; mask<=init ; mask++){
      for(int i=0 ; i<n ; i++){
        int j=0 ;
        int k=i ;
        for(; ; ){
          if(((mask>>k)& 1)==1){
            break ;
          }
          j++;
          k++;
          if(k==n){
            k=0 ;
          }
        }
        int nm=mask ^(1<<k);
        a[mask]+=(n-j+a[nm])/n ;
      }
    }
    out.println(a[init]);
  }
  public static void main(String[] args)throws IOException {
    Locale.setDefault(Locale.US);
    if(args.length>=2){
      inputFileName=args[0];
      outputFileName=args[1];
    }
    in=new Scanner(new File(inputFileName));
    out=new PrintWriter(outputFileName);
    int tests=in.nextInt();
    in.nextLine();
    for(int t=1 ; t<=tests ; t++){
      out.print("Case #"+t+": ");
      new D().solve();
      System.out.println("Case #"+t+": solved");
    }
    in.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   attribute fileName : String := OclType["D"].getSimpleName().replaceFirstMatch("_.*", "")->toLowerCase();
  static   attribute inputFileName : String := fileName + ".in";
  static   attribute outputFileName : String := fileName + ".out";
  static   attribute in : OclFile;
  static   attribute out : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.getCurrent() ;
     var n : int ; n := s->size() ;
    var init : int ; init := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = '.') then (     init := MathLib.bitwiseOr(init, (1*(2->pow(i)))->oclAsType(long)) ) else skip )  ;     i := i + 1 ) ; 
    var a : Sequence(double) ; a := Integer.subrange(1,(1*(2->pow(n)))->oclAsType(long))->collect(0.0) ;
        var mask : int ; mask := 1 ; while mask <= init do ( (         var i : int ; i := 0 ; while i < n do ( (     var j : int ; j := 0 ;
     var k : int ; k := i ;
      while true do ( (     if ((((mask/(2->pow(k)))->oclAsType(long)) & 1) = 1) then (     break ) else skip ; 
     j := j + 1 ; 
     k := k + 1 ; 
     if (k = n) then (     k := 0 ) else skip )  ) ; 
    var nm : int ; nm := MathLib.bitwiseXor(mask,((1*(2->pow(k)))->oclAsType(long))) ;
    a[mask+1] := a[mask+1]+(((n)->char2byte() - j + a[nm+1]) / n) ; 
 )  ;     i := i + 1 ) )  ;     mask := mask + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.US) ; 
     if (args->size() >= 2) then (     inputFileName := args[0+1] ; 
     outputFileName := args[1+1] ) else skip ; 
    in := OclFile.newOclFile_Read(OclFile(inputFileName)) ; 
    out := OclFile.newOclFile_Write(OclFile.newOclFile(outputFileName)) ; 
    var tests : int ; tests := in.getCurrent()->toInteger() ;
    skip ; 
        var t : int ; t := 1 ; while t <= tests do ( (     skip ; 
     D.newD().solve() ; 
     OclFile["System.out"].println("Case #" + t + ": solved") )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.util.*;
public class D {
  Scanner sc=new Scanner(System.in);
  int N ;
  char[] oc ;
  void read(){
    oc=sc.next().toCharArray();
    N=oc.length ;
  }
  void solve(){
    double[] dp=new double[1<<N];
    for(int i=(1<<N)-1 ; i>=0 ; i--){
      for(int j=0 ; j<N ; j++){
        for(int k=0 ; k<N ; k++)if((i>>((j+k)% N)& 1)==0){
          dp[i]+=(dp[i | 1<<((j+k)% N)]+N-k)/N ;
          break ;
        }
      }
    }
    int r=0 ;
    for(int i=0 ; i<N ; i++)if(oc[i]=='X')r |=1<<i ;
    System.out.printf("%.10f%n",dp[r]);
  }
  void run(){
    int caseN=sc.nextInt();
    for(int caseID=1 ; caseID<=caseN ; caseID++){
      read();
      System.out.printf("Case #%d: ",caseID);
      solve();
      System.out.flush();
    }
  }
  void debug(Object...os){
    System.err.println(deepToString(os));
  }
  public static void main(String[] args){
    try {
      System.setIn(new BufferedInputStream(new FileInputStream(args.length>0 ? args[0] :(D.class.getName()+".in"))));
    }
    catch(Exception e){
    }
    new D().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute N : int;
   attribute oc : Sequence(String);
   operation read() : void
  pre: true
  post: true
  activity: (     oc := sc.getCurrent()->characters() ; 
     N := oc->size() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var dp : Sequence(double) ; dp := Integer.subrange(1,(1*(2->pow(N)))->oclAsType(long))->collect(0.0) ;
         var i : int ; i := ((1*(2->pow(N)))->oclAsType(long)) - 1 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < N do ( (         var k : int ; k := 0 ; while k < N do (     if ((MathLib.bitwiseAnd((i/(2->pow(((j + k) mod N))))->oclAsType(long),1)) = 0) then (     dp[i+1] := dp[i+1]+((dp[MathLib.bitwiseOr(i,(1*(2->pow(((j + k) mod N))))->oclAsType(long))+1] + N - k) / N) ; 
     break ) else skip ;  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    var r : int ; r := 0 ;
        var i : int ; i := 0 ; while i < N do (     if (oc[i+1] = 'X') then     r := MathLib.bitwiseOr(r, (1*(2->pow(i)))->oclAsType(long)) ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.10f%n", dp[r+1]) ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     var caseN : int ; caseN := sc.getCurrent()->toInteger() ;
         var caseID : int ; caseID := 1 ; while caseID <= caseN do ( (     execute read() ; 
     OclFile["System.out"].printf("Case #%d: ", caseID) ; 
     execute solve() ; 
     OclFile["System.out"].flush() )  ;     caseID := caseID + 1 ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile_Read(if args->size() > 0 then args[0+1] else (OclType["D"].getName() + ".in") endif))) )   catch (e : ProgramException) do skip
     D.newD().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import java.io.*;
public class D {
  public static void p(Object...args){
    System.out.println(Arrays.deepToString(args));
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int zz=1 ; zz<=T ; zz++){
      String start=in.next();
      N=start.length();
      int st=0 ;
      for(int i=0 ; i<N ; i++){
        if(start.charAt(i)=='X')st |=1<<i ;
      }
      DP=new double[1<<N];
      Arrays.fill(DP,-1);
      DP[(1<<N)-1]=0 ;
      System.out.format("Case #%d: %.12f\n",zz,compute(st));
    }
  }
  static int N ;
  static double[] DP ;
  static double compute(int at){
    if(DP[at]!=-1)return DP[at];
    double ans=0.0 ;
    for(int i=0 ; i<N ; i++){
      int cost=N ;
      int j=i ;
      while(get(at,j)){
        j++;
        cost--;
        if(j==N)j=0 ;
      }
      ans+=cost+compute(at |(1<<j));
    }
    ans/=N ;
    DP[at]=ans ;
    return ans ;
  }
  static boolean get(int num,int bit){
    return(num &(1<<bit))!=0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   operation p( args : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((args + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var zz : int ; zz := 1 ; while zz <= T do ( (     var start : String ; start := in.getCurrent() ;
     N := start->size() ; 
    var st : int ; st := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (start->at(i+1) = 'X') then     st := MathLib.bitwiseOr(st, (1*(2->pow(i)))->oclAsType(long)) ; else skip )  ;     i := i + 1 ) ; 
    DP := Integer.subrange(1,(1*(2->pow(N)))->oclAsType(long))->collect(0.0) ; 
    DP := DP->collect(-1) ; 
    DP[((1*(2->pow(N)))->oclAsType(long)) - 1+1] := 0 ; 
    OclFile["System.out"].format("Case #%d: %.12f\n", zz, compute(st)) ; 
 )  ;     zz := zz + 1 ) );
  static   attribute N : int;
  static   attribute DP : Sequence(double);
  static   operation compute( at : int) : double
  pre: true
  post: true
  activity: (     if (DP[at+1] /= -1) then     return DP[at+1] else skip ; 
     var ans : double ; ans := 0.0 ;
        var i : int ; i := 0 ; while i < N do ( (     var cost : int ; cost := N ;
     var j : int ; j := i ;
     while (at(at, j+1)) do (     j := j + 1 ; 
     cost := cost - 1 ; 
     if (j = N) then     j := 0 ; else skip ) ; 
     ans := ans+(cost + compute(at or ((1*(2->pow(j)))->oclAsType(long)))) )  ;     i := i + 1 ) ; 
    ans := ans/(N) ; 
    DP[at+1] := ans ; 
    return ans 
 );
  static   operation get( num : int, bit : int) : boolean
  pre: true
  post: true
  activity: (     return (num & ((1*(2->pow(bit)))->oclAsType(long))) /= 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean prevPermutation(char[] str){
    int n=str.length-1 ;
    int i=n ;
    while(i>0 && str[i-1]<=str[i]){
      i--;
    }
    if(i<=0){
      return false ;
    }
    int j=i-1 ;
    while(j+1<=n && str[j+1]<=str[i-1]){
      j++;
    }
    swap(str,i-1,j);
    StringBuilder sb=new StringBuilder(String.valueOf(str));
    sb.reverse();
    str=sb.toString().toCharArray();
    return true ;
  }
  static String swap(char[] ch,int i,int j){
    char temp=ch[i];
    ch[i]=ch[j];
    ch[j]=temp ;
    return String.valueOf(ch);
  }
  public static void main(String[] args){
    char[] str="4321".toCharArray();
    if(prevPermutation(str)){
      System.out.println("Previous permutation is "+String.valueOf(str));
    }
    else {
      System.out.println("Previous permutation"+"doesn't exist");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation prevPermutation( str : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() - 1 ;
     var i : int ; i := n ;
    while (i > 0 & str[i - 1+1] <= str[i+1]) do (     i := i - 1 ) ; 
    if (i <= 0) then (     return false ) else skip ; 
    var j : int ; j := i - 1 ;
    while (j + 1 <= n & str[j + 1+1] <= str[i - 1+1]) do (     j := j + 1 ) ; 
    execute swap(str, i - 1, j) ; 
    var sb : String ; sb := StringLib.newString(((str) + "")) ;
    sb := sb->reverse() ; 
    str := sb+""->characters() ; 
    return true 
 );
  static   operation swap( ch : Sequence(String), i : int, j : int) : String
  pre: true
  post: true
  activity: (     var temp : String ; temp := ch[i+1] ;
     ch[i+1] := ch[j+1] ; 
     ch[j+1] := temp ; 
     return ((ch) + "") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := "4321"->characters() ;
     if (prevPermutation(str)) then (     OclFile["System.out"].println("Previous permutation is " + (str)->sum() ) ) else (     OclFile["System.out"].println("Previous permutation" + "doesn't exist") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package bribetheprisoners ;
import java.io.IOException ;
import java.util.Arrays ;
public class Main extends Base {
  int P,Q ;
  int free[];
  int bribe[][];
  public static void main(String[] args)throws IOException {
    Main m=new Main();
    m.run("C","large");
  }
  @ Override void init(){
  }
  @ Override void load()throws IOException {
    String s[]=br.readLine().split(" ");
    P=Integer.parseInt(s[0]);
    Q=Integer.parseInt(s[1]);
    free=new int[Q+2];
    free[0]=0 ;
    free[Q+1]=P+1 ;
    s=br.readLine().split(" ");
    for(int i=0 ; i<Q ; i++){
      free[i+1]=Integer.parseInt(s[i]);
    }
    Arrays.sort(free);
    bribe=new int[free.length][free.length];
  }
  void compute(int i,int j){
    if(i==j){
      bribe[i][j]=0 ;
      return ;
    }
    int best=-1 ;
    for(int k=i+1 ; k<j ; k++){
      int cur=bribe[i][k]+bribe[k][j]+(free[j]-free[i]-2);
      if(best==-1 || cur<=best)best=cur ;
    }
    if(best==-1)best=0 ;
    bribe[i][j]=best ;
  }
  @ Override void solve(){
    for(int iv=0 ; iv<free.length ; iv++){
      for(int i=0 ; i<free.length ; i++){
        int j=i+iv ;
        if(j>=free.length)break ;
        compute(i,j);
      }
    }
    printResult(""+bribe[0][Q+1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends Base {
   attribute P : int;
   attribute free : Sequence(int);
   attribute bribe : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run("C", "large") );
     operation init() : void
  pre: true
  post: true
  activity: skip;
     operation load() : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
     P := (s[0+1])->toInteger() ; 
    Q := (s[1+1])->toInteger() ; 
    free := Integer.subrange(1,Q + 2)->collect(0) ; 
    free[0+1] := 0 ; 
    free[Q + 1+1] := P + 1 ; 
    s := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < Q do ( (     free[i + 1+1] := (s[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    free := free->sort() ; 
    bribe := Integer.subrange(1,free->size())->collect(Integer.subrange(1,free->size())->collect(0)) ; 
 );
   operation compute( i : int, j : int) : void
  pre: true
  post: true
  activity: (     if (i = j) then (     bribe[i+1][j+1] := 0 ; 
     return ) else skip ; 
     var best : int ; best := -1 ;
        var k : int ; k := i + 1 ; while k < j do ( (     var cur : int ; cur := bribe[i+1][k+1] + bribe[k+1][j+1] + (free[j+1] - free[i+1] - 2) ;
     if (best = -1 or cur <= best) then     best := cur ; else skip )  ;     k := k + 1 ) ; 
    if (best = -1) then     best := 0 ; else skip ; 
    bribe[i+1][j+1] := best ; 
 );
     operation solve() : void
  pre: true
  post: true
  activity: (         var iv : int ; iv := 0 ; while iv < free->size() do ( (         var i : int ; i := 0 ; while i < free->size() do ( (     var j : int ; j := i + iv ;
     if (j >= free->size()) then     break else skip ; 
     execute compute(i, j) )  ;     i := i + 1 ) )  ;     iv := iv + 1 ) ; 
     execute printResult("" + bribe[0+1][Q + 1+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
class GFG {
  static int maxnumber(int n,int k){
    for(int j=0 ; j<k ; j++){
      int ans=0 ;
      int i=1 ;
      while(n/i>0){
        int temp=(n/(i*10))*i+(n % i);
        i*=10 ;
        ans=Math.max(ans,temp);
      }
      n=ans ;
    }
    return n ;
  }
  public static void main(String[] args){
    int n=6358 ;
    int k=1 ;
    System.out.println(maxnumber(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxnumber( n : int, k : int) : int
  pre: true
  post: true
  activity: (         var j : int ; j := 0 ; while j < k do ( (     var ans : int ; ans := 0 ;
     var i : int ; i := 1 ;
     while (n / i > 0) do (     var temp : int ; temp := (n / (i * 10)) * i + (n mod i) ;
     i := i*(10) ; 
     ans := Set{ans, temp}->max() ) ; 
     n := ans )  ;     j := j + 1 ) ; 
     return n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6358 ;
     var k : int ; k := 1 ;
     OclFile["System.out"].println(maxnumber(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      int[][] ns=new int[n][2];
      while(n-->0){
        ns[n][0]=scanner.nextInt();
        ns[n][1]=scanner.nextInt();
      }
      int m=scanner.nextInt();
      int[][] ms=new int[m][2];
      while(m-->0){
        ms[m][0]=scanner.nextInt();
        ms[m][1]=scanner.nextInt();
      }
      int len=ns.length+ms.length ;
      int[][] num=Arrays.copyOf(ns,len);
      System.arraycopy(ms,0,num,ns.length,ms.length);
      Arrays.sort(num,new Comparator<int[]>(){
        @ Override public int compare(int[] a,int[] b){
          if(a[0]==b[0]){
            return a[1]-b[1];
          }
          return a[0]-b[0];
        }
      }
);
      int[] dp=new int[len];
      Arrays.fill(dp,1);
      for(int i=0 ; i<len ; i++){
        for(int j=0 ; j<i ; j++){
          if(num[i][0]<=num[j][0] || num[i][1]<=num[j][1])continue ;
          dp[i]=Math.max(dp[i],dp[j]+1);
        }
      }
      int ans=0 ;
      for(int i=0 ; i<len ; i++){
        ans=Math.max(ans,dp[i]);
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var ns : Sequence(Sequence(int)) ; ns := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     ns[n+1][0+1] := scanner.getCurrent()->toInteger() ; 
     ns[n+1][1+1] := scanner.getCurrent()->toInteger() ) ;  ) ;  
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var ms : Sequence(Sequence(int)) ; ms := Integer.subrange(1,m)->collect(Integer.subrange(1,2)->collect(0)) ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     ms[m+1][0+1] := scanner.getCurrent()->toInteger() ; 
     ms[m+1][1+1] := scanner.getCurrent()->toInteger() ) ;  ) ;  
    var len : int ; len := ns->size() + ms->size() ;
    var num : Sequence(Sequence(int)) ; num := ns.subrange(1,len) ;
    for _x : Integer.subrange(1,ms->size()) do num[ns->size() + _x] := ms[0 + _x] ; 
    num := OclComparator.sortWith(num, OclComparator<Sequence(int)>.newOclComparator()) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,len)->collect(0) ;
    dp := dp->collect(1) ; 
        var i : int ; i := 0 ; while i < len do ( (         var j : int ; j := 0 ; while j < i do ( (     if (num[i+1][0+1] <= num[j+1][0+1] or num[i+1][1+1] <= num[j+1][1+1]) then     continue else skip ; 
     dp[i+1] := Set{dp[i+1], dp[j+1] + 1}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < len do ( (     ans := Set{ans, dp[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
class GFG {
  static int MAX=100001 ;
  static double dp[]=new double[MAX];
  static double probability(int k,int n){
    double ans=0.0 ;
    for(int i=k ; i<=n ; ++i){
      double res=dp[n]-dp[i]-dp[n-i]-n ;
      ans+=Math.pow(2.0,res);
    }
    return ans ;
  }
  static void precompute(){
    for(int i=2 ; i<MAX ; ++i)dp[i]=(Math.log(i)/Math.log(2))+dp[i-1];
  }
  public static void main(String args[]){
    precompute();
    System.out.println(probability(2,3));
    System.out.println(probability(3,6));
    System.out.println(probability(500,1000));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100001;
  static   attribute dp : double := Integer.subrange(1,MAX)->collect(0.0);
  static   operation probability( k : int, n : int) : double
  pre: true
  post: true
  activity: (     var ans : double ; ans := 0.0 ;
         var i : int ; i := k ; while i <= n do ( (     var res : double ; res := dp[n+1] - dp[i+1] - dp[n - i+1] - n ;
     ans := ans+(2.0->pow(res)) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation precompute() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i < MAX do (     dp[i+1] := ((i)->log() / (2)->log()) + dp[i - 1+1] ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute precompute() ; 
     OclFile["System.out"].println(probability(2, 3)) ; 
     OclFile["System.out"].println(probability(3, 6)) ; 
     OclFile["System.out"].println(probability(500, 1000)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean find(String s1,String s2){
    int len=s1.length(),len_1=s2.length();
    if(len!=len_1){
      return false ;
    }
    int d[]=new int[len];
    d[0]=s2.charAt(0)-s1.charAt(0);
    for(int i=1 ; i<len ; i++){
      if(s1.charAt(i)>s2.charAt(i)){
        return false ;
      }
      else {
        d[i]=s2.charAt(i)-s1.charAt(i);
      }
    }
    for(int i=0 ; i<len-1 ; i++){
      if(d[i]<d[i+1]){
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    String s1="abcd",s2="bcdd" ;
    if(find(s1,s2)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find( s1 : String, s2 : String) : boolean
  pre: true
  post: true
  activity: (     var len : int ; len := s1->size() ;
    var len    var len    var len :  ; len := s1->size() :  ; len    var len :  ; len := s1->size() := s2->size() : int ; len    var len    var len :  ; len := s1->size() :  ; len    var len :  ; len := s1->size() := s2->size() := s2->size() ;
     if (len /= len_1) then (     return false ) else skip ; 
    var d : Sequence(int) ; d := Integer.subrange(1,len)->collect(0) ;
    d[0+1] := s2->at(0+1) - s1->at(0+1) ; 
        var i : int ; i := 1 ; while i < len do ( (     if (s1->at(i+1) > s2->at(i+1)) then (     return false ) else (     d[i+1] := s2->at(i+1) - s1->at(i+1) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < len - 1 do ( (     if (d[i+1] < d[i + 1+1]) then (     return false ) else skip )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "abcd" ;
    var s2 : String ; s2 := "bcdd" ;
     if (find(s1, s2)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int arr[]={
    1,2,3,4,5,6 };
    static int multiply(int a[],int n){
      if(n==0)return(a[n]);
      else return(a[n]*multiply(a,n-1));
    }
    public static void main(String[] args){
      System.out.println(multiply(arr,arr.length-1));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute arr : int := Sequence{1,2,3,4,5,6};
  static   operation multiply( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return (a[n+1]) else     return (a[n+1] * multiply(a, n - 1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(multiply(arr, arr->size() - 1)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static private Scanner sc=new Scanner(System.in);
  static private int n,k ;
  static private int[] w ;
  public static void main(String[] args){
    input();
    int p=solve();
    System.out.println(p);
  }
  private static int solve(){
    int l=0 ;
    int r=10000*n/k+10 ;
    int p ;
    while(l<r){
      p=(r+l)/2 ;
      if(check(p)){
        r=p ;
      }
      else {
        l=p+1 ;
      }
    }
    return l ;
  }
  private static boolean check(int p){
    int c=0 ;
    int t=1 ;
    for(int i=0 ; i<n ; i++){
      if(w[i]>p){
        return false ;
      }
      if(c+w[i]<=p){
        c+=w[i];
      }
      else {
        t+=1 ;
        c=w[i];
      }
    }
    return t<=k ;
  }
  private static void input(){
    n=sc.nextInt();
    k=sc.nextInt();
    w=new int[100000];
    for(int i=0 ; i<n ; i++){
      w[i]=sc.nextInt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute n : int;
  static    attribute w : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute input() ; 
     var p : int ; p := solve() ;
     OclFile["System.out"].println(p) );
  static   operation solve() : int
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
     var r : int ; r := 10000 * n / k + 10 ;
    var p : int ;
    while (l < r) do (     p := (r + l) / 2 ; 
     if (check(p)) then (     r := p ) else (     l := p + 1 ) ) ; 
    return l 
 );
  static   operation check( p : int) : boolean
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
     var t : int ; t := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (w[i+1] > p) then (     return false ) else skip ; 
     if (c + w[i+1] <= p) then (     c := c+(w[i+1]) ) else (     t := t+(1) ; 
     c := w[i+1] ) )  ;     i := i + 1 ) ; 
     return t <= k );
  static   operation input() : void
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
     k := sc.getCurrent()->toInteger() ; 
     w := Integer.subrange(1,100000)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do ( (     w[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class Main {
  public static boolean possible(List<Integer>w,int n,int k,int P){
    int current=0 ;
    k--;
    for(int c : w){
      if(current+c>P){
        if(k>0){
          k--;
          if(c<=P)current=c ;
          else return false ;
        }
        else {
          return false ;
        }
      }
      else {
        current+=c ;
      }
    }
    return true ;
  }
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] line=br.readLine().split(" ");
    int n=Integer.parseInt(line[0]);
    int k=Integer.parseInt(line[1]);
    List<Integer>w=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++)w.add(Integer.parseInt(br.readLine()));
    int u=1000000000,l=1 ;
    while(u-l>1){
      int mid=(u+l)/2-1 ;
      if(possible(w,n,k,mid))u=mid+1 ;
      else l=mid+1 ;
    }
    System.out.println(l);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation possible( w : Sequence(int), n : int, k : int, P : int) : boolean
  pre: true
  post: true
  activity: (     var current : int ; current := 0 ;
     k := k - 1 ; 
     for (c : w) do ( (     if (current + c > P) then (     if (k > 0) then (     k := k - 1 ; 
     if (c <= P) then     current := c ; else     return false ) else (     return false ) ) else (     current := current+(c) ) )  ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var n : int ; n := (line[0+1])->toInteger() ;
    var k : int ; k := (line[1+1])->toInteger() ;
    var w : Sequence(int) ; w := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     w := w->including((br.readLine())->toInteger()) ;  ;     i := i + 1 ) ; 
    var u : int ; u := 1000000000 ;
    var l : int ; l := 1 ;
    while (u - l > 1) do (     var mid : int ; mid := (u + l) / 2 - 1 ;
     if (possible(w, n, k, mid)) then     u := mid + 1 ; else     l := mid + 1 ; ) ; 
    OclFile["System.out"].println(l) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static ArrayList<Integer>packages=new ArrayList<>();
  static int trucks ;
  static int total ;
  public static void main(String[] args){
    Scanner inp=new Scanner(System.in);
    total=inp.nextInt();
    trucks=inp.nextInt();
    int sum=0 ;
    for(int i=0 ; i<total ; i++){
      int item=inp.nextInt();
      packages.add(item);
      sum+=item ;
    }
    int lower=0 ;
    int answer=sum ;
    while(lower<=sum){
      int mid=(sum+lower)/2 ;
      if(check(mid)){
        answer=mid ;
        sum=mid-1 ;
      }
      else {
        lower=mid+1 ;
      }
    }
    System.out.println(answer);
  }
  static boolean check(int p){
    int cntTruck=1,currentTruck=0 ;
    for(int i=0 ; i<total ; i++){
      if(currentTruck+packages.get(i)<=p){
        currentTruck+=packages.get(i);
      }
      else {
        if(cntTruck>=trucks)return false ;
        cntTruck++;
        if(packages.get(i)>p)return false ;
        currentTruck=packages.get(i);
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute packages : Sequence(int) := Sequence{};
  static   attribute trucks : int;
  static   attribute total : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inp : OclFile ; inp := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     total := inp.getCurrent()->toInteger() ; 
    trucks := inp.getCurrent()->toInteger() ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < total do ( (     var item : int ; item := inp.getCurrent()->toInteger() ;
     packages := packages->including(item) ; 
     sum := sum+(item) )  ;     i := i + 1 ) ; 
    var lower : int ; lower := 0 ;
    var answer : int ; answer := sum ;
    while (lower <= sum) do (     var mid : int ; mid := (sum + lower) / 2 ;
     if (check(mid)) then (     answer := mid ; 
     sum := mid - 1 ) else (     lower := mid + 1 ) ) ; 
    OclFile["System.out"].println(answer) ; 
 );
  static   operation check( p : int) : boolean
  pre: true
  post: true
  activity: (     var cntTruck : int ; cntTruck := 1 ;
    var currentTruck : int ; currentTruck := 0 ;
         var i : int ; i := 0 ; while i < total do ( (     if (currentTruck + packages->at(i+1) <= p) then (     currentTruck := currentTruck+(packages->at(i+1)) ) else (     if (cntTruck >= trucks) then     return false else skip ; 
     cntTruck := cntTruck + 1 ; 
     if (packages->at(i+1) > p) then     return false else skip ; 
     currentTruck := packages->at(i+1) ) )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=0 ;
    int k=0 ;
    int[] weights=null ;
    try {
      String[] in=br.readLine().split(" ");
      n=Integer.parseInt(in[0]);
      k=Integer.parseInt(in[1]);
      weights=new int[n];
      for(int i=0 ; i<n ; i++){
        weights[i]=Integer.parseInt(br.readLine());
      }
      br.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
    int low=0 ;
    int high=Integer.MAX_VALUE ;
    int mid=0 ;
    while(low<high-1){
      mid=(low+high)/2 ;
      int portable=howManyPortable(weights,n,k,mid);
      if(portable<n){
        low=mid ;
      }
      else {
        high=mid ;
      }
    }
    System.out.println(high);
  }
  private static int howManyPortable(int[] weights,int n,int k,int p){
    int index=0 ;
    while(k>0){
      long sum=0 ;
      while(true){
        if(index==n){
          k=0 ;
          break ;
        }
        sum+=weights[index];
        if(sum>p){
          k--;
          break ;
        }
        else {
          index++;
        }
      }
    }
    return index ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := 0 ;
    var k : int ; k := 0 ;
    var weights : Sequence(int) ; weights := null ;
    try (     var in : Sequence(String) ; in := br.readLine()->split(" ") ;
     n := (in[0+1])->toInteger() ; 
    k := (in[1+1])->toInteger() ; 
    weights := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     weights[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
    var low : int ; low := 0 ;
    var high : int ; high := 2147483647 ;
    var mid : int ; mid := 0 ;
    while (low < high - 1) do (     mid := (low + high) / 2 ; 
     var portable : int ; portable := howManyPortable(weights, n, k, mid) ;
     if (portable < n) then (     low := mid ) else (     high := mid ) ) ; 
    OclFile["System.out"].println(high) ; 
 );
  static   operation howManyPortable( weights : Sequence(int), n : int, k : int, p : int) : int
  pre: true
  post: true
  activity: (     var index : int ; index := 0 ;
     while (k > 0) do (     var sum : long ; sum := 0 ;
     while (true) do (     if (index = n) then (     k := 0 ; 
     break ) else skip ; 
     sum := sum+(weights[index+1]) ; 
     if (sum > p) then (     k := k - 1 ; 
     break ) else (     index := index + 1 ) ) ) ; 
     return index );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int minimum_cost(int a[],int n){
    int mn=Integer.MAX_VALUE ;
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      mn=Math.min(a[i],mn);
      sum+=a[i];
    }
    return mn*(sum-mn);
  }
  public static void main(String[] args){
    int a[]={
      4,3,2,5 };
      int n=a.length ;
      System.out.println(minimum_cost(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimum_cost( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var mn : int ; mn := 2147483647 ;
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     mn := Set{a[i+1], mn}->min() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
     return mn * (sum - mn) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{4,3,2,5} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(minimum_cost(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  PrintStream log=new PrintStream(new OutputStream(){
    public void write(int b){
    }
  }
);
  PrintStream result=System.out ;
  Scanner sc=new Scanner(System.in);
  void main()throws IOException {
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[] w=new int[N];
    for(int i=0 ; i<M ; i++){
      int a=sc.nextInt();
      int L=sc.nextInt();
      for(int j=0 ; j<L ; j++){
        w[(a+j)% N]=1 ;
      }
    }
    int[] t=new int[N+1];
    int s=0 ;
    int f=0 ;
    int s0=0 ;
    int i ;
    for(i=0 ; i<N ; i++){
      if(f==0 && w[i]==1){
        s=i ;
        f=1 ;
      }
      else if(f==1 && w[i]==0){
        f=0 ;
        if(s==0){
          s0=i ;
        }
        else {
          t[i-s]++;
        }
      }
    }
    if(f==1){
      t[i-s+s0]++;
    }
    else if(s0!=0){
      t[s0]++;
    }
    for(i=N ; i>0 ; i--){
      if(t[i]>0){
        result.println(i+" "+t[i]);
      }
    }
  }
  public static void main(String[] args)throws IOException {
    new Main().main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute log : OclFile := OclFile.newOclFile_Write(OclFile());
   attribute result : OclFile := OclFile["System.out"];
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation main() : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var M : int ; M := sc.getCurrent()->toInteger() ;
    var w : Sequence(int) ; w := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var L : int ; L := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < L do ( (     w[(a + j) mod N+1] := 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var t : Sequence(int) ; t := Integer.subrange(1,N + 1)->collect(0) ;
    var s : int ; s := 0 ;
    var f : int ; f := 0 ;
    var s0 : int ; s0 := 0 ;
    var i : int ;
        i := 0 ; while i < N do ( (     if (f = 0 & w[i+1] = 1) then (     s := i ; 
     f := 1 ) else     if (f = 1 & w[i+1] = 0) then (     f := 0 ; 
     if (s = 0) then (     s0 := i ) else (     t[i - s+1] := t[i - s+1] + 1 ) ) else skip ; )  ;     i := i + 1 ) ; 
    if (f = 1) then (     t[i - s + s0+1] := t[i - s + s0+1] + 1 ) else     if (s0 /= 0) then (     t[s0+1] := t[s0+1] + 1 ) else skip ; ;  
        i := N ; while i > 0 do ( (     if (t[i+1] > 0) then (     skip ) else skip )  ;     i := i - 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().main() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int findTransitionPoint(int arr[],int n){
    int lb=0,ub=n-1 ;
    while(lb<=ub){
      int mid=(lb+ub)/2 ;
      if(arr[mid]==0)lb=mid+1 ;
      else if(arr[mid]==1){
        if(arr[mid-1]==0)return mid ;
        ub=mid-1 ;
      }
    }
    return-1 ;
  }
  public static void main(String args[]){
    int arr[]={
      0,0,0,0,1,1 };
      int point=findTransitionPoint(arr,arr.length);
      System.out.println(point>=0 ? "Transition point is "+point : "There is no transition point");
    }
  }

------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation findTransitionPoint( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var lb : int ; lb := 0 ;
    var ub : int ; ub := n - 1 ;
     while (lb <= ub) do (     var mid : int ; mid := (lb + ub) / 2 ;
     if (arr[mid+1] = 0) then     lb := mid + 1 ; else     if (arr[mid+1] = 1) then (     if (arr[mid - 1+1] = 0) then     return mid else skip ; 
     ub := mid - 1 ) else skip ; ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,0,0,0,1,1} ;
     var point : int ; point := findTransitionPoint(arr, arr->size()) ;
     OclFile["System.out"].println(if point >= 0 then "Transition point is " + point else "There is no transition point" endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int DP(int xy[][],int DP[][]){
    for(int i=1 ; i<1001 ; i++){
      for(int j=1 ; j<1001 ; j++){
        if(xy[i][j]==1){
          if(DP[i][j-1]<DP[i-1][j]){
            DP[i][j]=DP[i][j-1]+1 ;
          }
          else {
            DP[i][j]=DP[i-1][j]+1 ;
          }
        }
        else {
          if(DP[i][j-1]<DP[i-1][j]){
            DP[i][j]=DP[i-1][j];
          }
          else {
            DP[i][j]=DP[i][j-1];
          }
        }
      }
    }
    return DP[1000][1000];
  }
  void doIt(){
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int xy[][]=new int[1001][1001];
      int DP[][]=new int[1001][1001];
      for(int i=0 ; i<n ; i++){
        int a=sc.nextInt();
        int b=sc.nextInt();
        xy[a][b]=1 ;
      }
      int m=sc.nextInt();
      for(int i=0 ; i<m ; i++){
        int a=sc.nextInt();
        int b=sc.nextInt();
        xy[a][b]=1 ;
      }
      System.out.println(DP(xy,DP));
    }
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation DP( xy : Sequence(Sequence(int)), DP : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < 1001 do ( (         var j : int ; j := 1 ; while j < 1001 do ( (     if (xy[i+1][j+1] = 1) then (     if (DP[i+1][j - 1+1] < DP[i - 1+1][j+1]) then (     DP[i+1][j+1] := DP[i+1][j - 1+1] + 1 ) else (     DP[i+1][j+1] := DP[i - 1+1][j+1] + 1 ) ) else (     if (DP[i+1][j - 1+1] < DP[i - 1+1][j+1]) then (     DP[i+1][j+1] := DP[i - 1+1][j+1] ) else (     DP[i+1][j+1] := DP[i+1][j - 1+1] ) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return DP[1000+1][1000+1] );
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var xy : Sequence(Sequence(int)) ; xy := Integer.subrange(1,1001)->collect(Integer.subrange(1,1001)->collect(0)) ;
    var DP : Sequence(Sequence(int)) ; DP := Integer.subrange(1,1001)->collect(Integer.subrange(1,1001)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     xy[a+1][b+1] := 1 )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     xy[a+1][b+1] := 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(DP(xy, DP)) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int dp[][]=new int[n][n];
    for(int i=0 ; i<n ; i++)dp[0][i]=sc.nextInt();
    for(int i=1 ; i<n ; i++){
      for(int j=0 ; j<n-i ; j++)dp[i][j]=dp[i-1][j] ^ dp[i-1][j+1];
    }
    for(int i=1 ; i<n ; i++){
      for(int j=0 ; j<n-i ; j++)dp[i][j]=Math.max(dp[i][j],Math.max(dp[i-1][j],dp[i-1][j+1]));
    }
    int q=sc.nextInt();
    while(q-->0){
      int l=sc.nextInt();
      int r=sc.nextInt();
      System.out.println(dp[r-l][l-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do (     dp[0+1][i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 0 ; while j < n - i do (     dp[i+1][j+1] := dp[i - 1+1][j+1] xor dp[i - 1+1][j + 1+1] ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 0 ; while j < n - i do (     dp[i+1][j+1] := Set{dp[i+1][j+1], Set{dp[i - 1+1][j+1], dp[i - 1+1][j + 1+1]}->max()}->max() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(dp[r - l+1][l - 1+1]) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int dp[][]=new int[n][n];
    for(int i=0 ; i<n ; i++)dp[0][i]=sc.nextInt();
    for(int i=1 ; i<n ; i++){
      for(int j=0 ; j<n-i ; j++)dp[i][j]=dp[i-1][j] ^ dp[i-1][j+1];
    }
    for(int i=1 ; i<n ; i++){
      for(int j=0 ; j<n-i ; j++)dp[i][j]=Math.max(dp[i][j],Math.max(dp[i-1][j],dp[i-1][j+1]));
    }
    int q=sc.nextInt();
    while(q-->0){
      int l=sc.nextInt();
      int r=sc.nextInt();
      System.out.println(dp[r-l][l-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do (     dp[0+1][i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 0 ; while j < n - i do (     dp[i+1][j+1] := dp[i - 1+1][j+1] xor dp[i - 1+1][j + 1+1] ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 0 ; while j < n - i do (     dp[i+1][j+1] := Set{dp[i+1][j+1], Set{dp[i - 1+1][j+1], dp[i - 1+1][j + 1+1]}->max()}->max() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(dp[r - l+1][l - 1+1]) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void main(String[] args){
    int a=2 ;
    float b=2.0f ;
    double c=2.0003 ;
    char d='D' ;
    System.out.printf("Integer value is=%d",a);
    System.out.printf("\nFloat value is=%f",b);
    System.out.printf("\nDouble value is=%f",c);
    System.out.printf("\nChar value is=%c",d);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2 ;
     var b : double ; b := 2.0f ;
    var c : double ; c := 2.0003 ;
    var d : String ; d := 'D' ;
    OclFile["System.out"].printf("Integer value is=%d", a) ; 
    OclFile["System.out"].printf("\nFloat value is=%f", b) ; 
    OclFile["System.out"].printf("\nDouble value is=%f", c) ; 
    OclFile["System.out"].printf("\nChar value is=%c", d) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class CsAcademy {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    String s=cin.next();
    int ans=0 ;
    int i=0 ;
    int mx=0 ;
    PriorityQueue<Character>queue=new PriorityQueue<>();
    for(i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='('){
        queue.add(s.charAt(i));
      }
      else {
        if(queue.size()>=1){
          mx+=2 ;
          queue.remove();
        }
      }
    }
    ans=Math.max(ans,mx);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CsAcademy {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := cin.getCurrent() ;
    var ans : int ; ans := 0 ;
    var i : int ; i := 0 ;
    var mx : int ; mx := 0 ;
    var queue : Sequence(String) ; queue := Sequence{} ;
        i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '(') then (     queue := queue->including(s->at(i+1)) ) else (     if (queue->size() >= 1) then (     mx := mx+(2) ; 
     queue := queue.remove() ) else skip ) )  ;     i := i + 1 ) ; 
    ans := Set{ans, mx}->max() ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class CsAcademy {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    String s=cin.next();
    int ans=0 ;
    int i=0 ;
    int mx=0 ;
    PriorityQueue<Character>queue=new PriorityQueue<>();
    for(i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='('){
        queue.add(s.charAt(i));
      }
      else {
        if(queue.size()>=1){
          mx+=2 ;
          queue.remove();
        }
      }
    }
    ans=Math.max(ans,mx);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CsAcademy {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := cin.getCurrent() ;
    var ans : int ; ans := 0 ;
    var i : int ; i := 0 ;
    var mx : int ; mx := 0 ;
    var queue : Sequence(String) ; queue := Sequence{} ;
        i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '(') then (     queue := queue->including(s->at(i+1)) ) else (     if (queue->size() >= 1) then (     mx := mx+(2) ; 
     queue := queue.remove() ) else skip ) )  ;     i := i + 1 ) ; 
    ans := Set{ans, mx}->max() ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class CsAcademy {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    String s=cin.next();
    int dp[]=new int[s.length()];
    int ans=0 ;
    int i=0 ;
    int mx=0 ;
    PriorityQueue<Character>priorityQueue=new PriorityQueue<>();
    for(i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='('){
        priorityQueue.add(s.charAt(i));
      }
      else {
        if(priorityQueue.size()>=1){
          mx+=2 ;
          priorityQueue.remove();
        }
      }
    }
    System.out.println(mx);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CsAcademy {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := cin.getCurrent() ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,s->size())->collect(0) ;
    var ans : int ; ans := 0 ;
    var i : int ; i := 0 ;
    var mx : int ; mx := 0 ;
    var priorityQueue : Sequence(String) ; priorityQueue := Sequence{} ;
        i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '(') then (     priorityQueue := priorityQueue->including(s->at(i+1)) ) else (     if (priorityQueue->size() >= 1) then (     mx := mx+(2) ; 
     priorityQueue := priorityQueue.remove() ) else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(mx) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public static void main(String[] args)throws IOException {
    FastReader fr=new FastReader();
    BufferedWriter output=new BufferedWriter(new OutputStreamWriter(System.out));
    StringBuilder sb=new StringBuilder();
    String s=fr.next();
    int sum1=0,sum2=0,del1=0,del2=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='(')sum1++;
      else sum1--;
      if(sum1==-1){
        del1++;
        sum1=0 ;
      }
    }
    sb.append(s.length()-(sum1+del1));
    output.write(sb.toString());
    output.flush();
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    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 {
      if(st.hasMoreTokens()){
        str=st.nextToken("\n");
      }
      else {
        str=br.readLine();
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return str ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fr : FastReader ; fr := FastReader.newFastReader() ;
     var output : OclFile ; output := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var sb : String ; sb := StringLib.newString() ;
    var s : String ; s := fr.next() ;
    var sum1 : int ; sum1 := 0 ;
    var sum2 : int ; sum2 := 0 ;
    var del1 : int ; del1 := 0 ;
    var del2 : int ; del2 := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '(') then     sum1 := sum1 + 1 else     sum1 := sum1 - 1 ; ;  
     if (sum1 = -1) then (     del1 := del1 + 1 ; 
     sum1 := 0 ) else skip )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(s->size() - (sum1 + del1)) ; 
    skip ; 
    skip ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class ListB {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n,k,ans=0 ;
    n=sc.nextInt();
    k=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    Arrays.sort(arr);
    for(int i=n-1 ; i>=0 ; i-=k){
      ans+=(arr[i]-1)*2 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ListB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var k : int ;
    var ans : int ; ans := 0 ;
    n := sc.getCurrent()->toInteger() ; 
    k := sc.getCurrent()->toInteger() ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     ans := ans+((arr[i+1] - 1) * 2) )  ;     i := i-(k) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    boolean[] painted=new boolean[n];
    for(int i=0 ; i<m ; i++){
      int a=sc.nextInt();
      int l=sc.nextInt();
      for(int j=0 ; j<l ; j++){
        painted[(a+j)% n]=true ;
      }
    }
    int start=0 ;
    for(int i=0 ; i<n ; i++){
      if(! painted[i]){
        start=i ;
        break ;
      }
    }
    boolean[] p2=new boolean[n+1];
    for(int i=0 ; i<n ; i++){
      p2[i]=painted[(start+i)% n];
    }
    int[] count=new int[n+1];
    int len=0 ;
    for(int i=0 ; i<=n ; i++){
      if(p2[i]){
        len++;
      }
      else {
        count[len]++;
        len=0 ;
      }
    }
    for(int i=n ; i>=1 ; i--){
      if(count[i]>=1){
        System.out.println(i+" "+count[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var painted : Sequence(boolean) ; painted := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < l do ( (     painted[(a + j) mod n+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var start : int ; start := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (not(painted[i+1])) then (     start := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var p2 : Sequence(boolean) ; p2 := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     p2[i+1] := painted[(start + i) mod n+1] )  ;     i := i + 1 ) ; 
    var count : Sequence(int) ; count := Integer.subrange(1,n + 1)->collect(0) ;
    var len : int ; len := 0 ;
        var i : int ; i := 0 ; while i <= n do ( (     if (p2[i+1]) then (     len := len + 1 ) else (     count[len+1] := count[len+1] + 1 ; 
     len := 0 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := n ; while i >= 1 do ( (     if (count[i+1] >= 1) then (     OclFile["System.out"].println(i + " " + count[i+1]) ) else skip )  ;     i := i - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Test {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int n=cin.nextInt();
    int k=cin.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=cin.nextInt();
    }
    Arrays.sort(a);
    int suma=0 ;
    int begin=n-1 ;
    while(begin>=0){
      int temp=k ;
      int start=1 ;
      while(temp!=0 && begin>=0){
        suma+=Math.abs(start-a[begin]);
        start=a[begin--];
        temp--;
      }
      suma+=start-1 ;
    }
    System.out.println(suma);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := cin.getCurrent()->toInteger() ;
    var k : int ; k := cin.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := cin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var suma : int ; suma := 0 ;
    var begin : int ; begin := n - 1 ;
    while (begin >= 0) do (     var temp : int ; temp := k ;
     var start : int ; start := 1 ;
     while (temp /= 0 & begin >= 0) do (     suma := suma+(if start - a[begin+1] < 0 then -(start - a[begin+1]) else start - a[begin+1] endif) ; 
      start := a[begin+1]  ; begin := begin - 1 ; 
     temp := temp - 1 ) ; 
     suma := suma+(start - 1) ) ; 
    OclFile["System.out"].println(suma) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),k=in.nextInt(),sum=0 ;
    int ara[]=new int[n];
    for(int i=0 ; i<n ; i++){
      ara[i]=in.nextInt();
    }
    Arrays.sort(ara);
    for(int i=n-1 ; i>=0 ; i=i-k){
      sum=sum+2*(ara[i]-1);
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var ara : Sequence(int) ; ara := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ara[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    ara := ara->sort() ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     sum := sum + 2 * (ara[i+1] - 1) )  ;     i := i - k ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      List<Doll>dolls=new ArrayList<Doll>();
      dolls.add(new Doll(0,0));
      for(int i=0 ; i<n ; i++){
        dolls.add(new Doll(sc.nextInt(),sc.nextInt()));
      }
      int m=sc.nextInt();
      for(int i=0 ; i<m ; i++){
        dolls.add(new Doll(sc.nextInt(),sc.nextInt()));
      }
      int dp[][]=new int[n+m+1][n+m+1];
      int ans=0 ;
      Arrays.fill(dp[1],1);
      for(int i=1 ; i<n+m ; i++){
        for(int j=1 ; j<=n+m ; j++){
          if(dp[i][j]==0){
            dp[i+1][j]=0 ;
          }
          else {
            int max=0 ;
            Doll d1=dolls.get(j);
            for(int k=1 ; k<=n+m ; k++){
              if(j==k)continue ;
              Doll d2=dolls.get(k);
              if(d1.h>d2.h && d1.r>d2.r)max=Math.max(max,dp[i][k]);
            }
            dp[i+1][j]=max+1 ;
            ans=Math.max(ans,max+1);
          }
        }
      }
      System.out.println(ans);
    }
  }
}
class Doll {
  int h ;
  int r ;
  Doll(int h,int r){
    this.h=h ;
    this.r=r ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var dolls : Sequence(Doll) ; dolls := Sequence{} ;
    dolls := dolls->including(Doll.newDoll(0, 0)) ; 
        var i : int ; i := 0 ; while i < n do ( (     dolls := dolls->including(Doll.newDoll(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     dolls := dolls->including(Doll.newDoll(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + m + 1)->collect(Integer.subrange(1,n + m + 1)->collect(0)) ;
    var ans : int ; ans := 0 ;
    dp[1+1] := dp[1+1]->collect(1) ; 
        var i : int ; i := 1 ; while i < n + m do ( (         var j : int ; j := 1 ; while j <= n + m do ( (     if (dp[i+1][j+1] = 0) then (     dp[i + 1+1][j+1] := 0 ) else (     var max : int ; max := 0 ;
     var d1 : Doll ; d1 := dolls->at(j+1) ;
        var k : int ; k := 1 ; while k <= n + m do ( (     if (j = k) then     continue else skip ; 
     var d2 : Doll ; d2 := dolls->at(k+1) ;
     if (d1.h > d2.h & d1.r > d2.r) then     max := Set{max, dp[i+1][k+1]}->max() ; else skip )  ;     k := k + 1 ) ; 
    dp[i + 1+1][j+1] := max + 1 ; 
    ans := Set{ans, max + 1}->max() ; 
 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}
class Doll {
   attribute h : int;
   attribute r : int;
   static operation newDoll( h : int, r : int) : Doll
  pre: true
  post: true
  activity:
  ( var self : Doll ;
    self := createDoll();
    self.initialise(h, r);
    return self );
  operation initialise( h : int, r : int) : void
  pre: true  post: true
  activity: (     self.h := h ; 
     self.r := r );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.*;
import static java.util.Arrays.sort ;
import javafx.util.Pair ;
public class Main {
  static void sort(int a[]){
    Random ran=new Random();
    for(int i=0 ; i<a.length ; i++){
      int r=ran.nextInt(a.length);
      int temp=a[r];
      a[r]=a[i];
      a[i]=temp ;
    }
    Arrays.sort(a);
  }
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int n=input.nextInt();
    int k=input.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=input.nextInt();
    }
    long ans=0 ;
    sort(a);
    int i=n-1 ;
    work : while(i>=0){
      int count=k ;
      int max=Integer.MIN_VALUE ;
      while(i>=0 && count-->0){
        max=Math.max(max,a[i]);
        i--;
      }
      ans+=((max-1)*2);
    }
    System.out.println(ans);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var ran : OclRandom ; ran := OclRandom.newOclRandom() ;
         var i : int ; i := 0 ; while i < a->size() do ( (     var r : int ; r := ran.nextInt(a->size()) ;
     var temp : int ; temp := a[r+1] ;
     a[r+1] := a[i+1] ; 
     a[i+1] := temp )  ;     i := i + 1 ) ; 
     a := a->sort() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var n : int ; n := input.nextInt() ;
    var k : int ; k := input.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.nextInt() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    execute sort(a) ; 
    var i : int ; i := n - 1 ;
    while (i >= 0) do (     var count : int ; count := k ;
     var max : int ; max := -2147483648 ;
         while (i >= 0 & count > 0) do (    skip ; (     max := Set{max, a[i+1]}->max() ; 
     i := i - 1 ) ;  ) ;  
     ans := ans+(((max - 1) * 2)) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    Arrays.sort(arr);
    int i=n-1 ;
    int ans=0 ;
    while(i>=0){
      ans+=(arr[i]-1)*2 ;
      i-=k ;
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var i : int ; i := n - 1 ;
    var ans : int ; ans := 0 ;
    while (i >= 0) do (     ans := ans+((arr[i+1] - 1) * 2) ; 
     i := i-(k) ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class stem {
  public static String findstem(String arr[]){
    int n=arr.length ;
    String s=arr[0];
    int len=s.length();
    String res="" ;
    for(int i=0 ; i<len ; i++){
      for(int j=i+1 ; j<=len ; j++){
        String stem=s.substring(i,j);
        int k=1 ;
        for(k=1 ; k<n ; k++)if(! arr[k] .contains(stem))break ;
        if(k==n && res.length()<stem.length())res=stem ;
      }
    }
    return res ;
  }
  public static void main(String args[]){
    String arr[]={
      "grace","graceful","disgraceful","gracefully" };
      String stems=findstem(arr);
      System.out.println(stems);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class stem {
  static   operation findstem( arr : Sequence(String)) : String
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
     var s : String ; s := arr[0+1] ;
    var len : int ; len := s->size() ;
    var res : String ; res := "" ;
        var i : int ; i := 0 ; while i < len do ( (         var j : int ; j := i + 1 ; while j <= len do ( (     var stem : String ; stem := s.subrange(i+1,j) ;
     var k : int ; k := 1 ;
         k := 1 ; while k < n do (     if (not(arr[k+1]->includes(stem))) then     break else skip ;  ;     k := k + 1 ) ; 
     if (k = n & res->size() < stem->size()) then     res := stem ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"grace","graceful","disgraceful","gracefully"} ;
     var stems : String ; stems := findstem(arr) ;
     OclFile["System.out"].println(stems) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int Rank(int Edges,int Vertices){
    int result=0 ;
    result=Edges-Vertices+1 ;
    return result ;
  }
  public static void main(String[] args){
    int Edges=7,Vertices=5 ;
    System.out.println("Circuit Rank="+Rank(Edges,Vertices));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Rank( Edges : int, Vertices : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     result := Edges - Vertices + 1 ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Edges : int ; Edges := 7 ;
    var Vertices : int ; Vertices := 5 ;
     OclFile["System.out"].println("Circuit Rank=" + Rank(Edges, Vertices)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),m=(int)Math.pow(2,n)-1 ;
    PrintWriter out=new PrintWriter(System.out);
    for(int i=0 ; i<=m ; i++){
      String str=Integer.toBinaryString(i);
      List<Integer>ls=new ArrayList<>();
      for(int j=0 ; j<str.length(); j++){
        if(str.charAt(str.length()-1-j)=='1')ls.add(j);
      }
      out.print(i+":");
      for(int j=0 ; j<ls.size(); j++)out.print(" "+ls.get(j));
      out.println();
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := 2->pow(n)->oclAsType(int) - 1 ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
        var i : int ; i := 0 ; while i <= m do ( (     var str : String ; str := (MathLib.decimal2binary(i) + "") ;
     var ls : Sequence(int) ; ls := Sequence{} ;
        var j : int ; j := 0 ; while j < str->size() do ( (     if (str->at(str->size() - 1 - j+1) = '1') then     ls := ls->including(j) ; else skip )  ;     j := j + 1 ) ; 
    skip ; 
        var j : int ; j := 0 ; while j < ls->size() do (     skip ;  ;     j := j + 1 ) ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Deque ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  static int n ;
  static int count=0 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    System.out.println("0:");
    boolean[] array=new boolean[n+1];
    int max=0 ;
    while(max<n){
      array[max]=true ;
      System.out.print(++count+": ");
      int index=0 ;
      int count=0 ;
      for(int i=0 ; i<max ; i++){
        if(array[i]){
          System.out.print(i+" ");
++count ;
        }
      }
      System.out.println(max);
      for(int i=0 ; i<max ; i++){
        if(! array[i]){
          array[i]=true ;
          index=i ;
          break ;
        }
      }
      for(int j=0 ; j<n-2 ; j++){
        for(int i=0 ; i<index ; i++){
          if(array[i]){
            array[i]=false ;
            break ;
          }
        }
      }
      if(count>=max){
++max ;
        array=new boolean[n+1];
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute count : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    OclFile["System.out"].println("0:") ; 
    var array : Sequence(boolean) ; array := Integer.subrange(1,n + 1)->collect(false) ;
    var max : int ; max := 0 ;
    while (max < n) do (     array[max+1] := true ; 
     OclFile["System.out"].print((count + 1) + ": ") ; 
    var index : int ; index := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < max do ( (     if (array[i+1]) then (     OclFile["System.out"].print(i + " ") ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
        var i : int ; i := 0 ; while i < max do ( (     if (not(array[i+1])) then (     array[i+1] := true ; 
     index := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < n - 2 do ( (         var i : int ; i := 0 ; while i < index do ( (     if (array[i+1]) then (     array[i+1] := false ; 
     break ) else skip )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    if (count >= max) then (     max := max + 1 ; 
     array := Integer.subrange(1,n + 1)->collect(false) ) else skip ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int n,i,j,factorial ;
    String str ;
    try(Scanner sc=new Scanner(System.in)){
      n=sc.nextInt();
      factorial=(int)(Math.pow(2,n));
      char[] cha=new char[n];
      for(i=0 ; i<factorial ; i++){
        str=Integer.toBinaryString(i);
        for(j=0 ; j<str.length(); j++){
          cha[j]=str.charAt(j);
        }
        System.out.print(i+":");
        for(j=0 ; j<str.length(); j++){
          if(cha[str.length()-j-1]=='1'){
            System.out.print(" "+j);
          }
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var i : int ;
    var j : int ;
    var factorial : int ;
     var str : String ;
     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     n := sc.getCurrent()->toInteger() ; 
     factorial := (2->pow(n))->oclAsType(int) ; 
     var cha : Sequence(String) ; cha := Integer.subrange(1,n)->collect(0) ;
         i := 0 ; while i < factorial do ( (     str := (MathLib.decimal2binary(i) + "") ; 
         j := 0 ; while j < str->size() do ( (     cha[j+1] := str->at(j+1) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].print(i + ":") ; 
        j := 0 ; while j < str->size() do ( (     if (cha[str->size() - j - 1+1] = '1') then (     OclFile["System.out"].print(" " + j) ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final int N=sc.nextInt();
    final int M=sc.nextInt();
    boolean[] colored=new boolean[N];
    for(int i=0 ; i<M ; i++){
      final int a=sc.nextInt();
      final int L=sc.nextInt();
      for(int j=0 ; j<L ; j++){
        final int index=(a+j)% N ;
        colored[index]=true ;
      }
    }
    int false_pos=-1 ;
    for(int i=0 ; i<N ; i++){
      if(! colored[i]){
        false_pos=i ;
        break ;
      }
    }
    if(false_pos==-1){
      System.out.println(N+" "+1);
      return ;
    }
    int[] counts=new int[N];
    int count=0 ;
    boolean prev=false ;
    for(int i=0 ; i<N ; i++){
      final int index=(i+false_pos)% N ;
      if(colored[index]){
        if(! prev){
          prev=true ;
        }
        count++;
      }
      else {
        if(prev){
          prev=false ;
          counts[count]++;
          count=0 ;
        }
      }
    }
    if(count!=0){
      counts[count]++;
      count=0 ;
    }
    for(int i=N-1 ; i>=0 ; i--){
      if(counts[i]>0){
        System.out.println(i+" "+counts[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var colored : Sequence(boolean) ; colored := Integer.subrange(1,N)->collect(false) ;
        var i : int ; i := 0 ; while i < M do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var L : int ; L := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < L do ( (     var index : int ; index := (a + j) mod N ;
     colored[index+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var false_pos : int ; false_pos := -1 ;
        var i : int ; i := 0 ; while i < N do ( (     if (not(colored[i+1])) then (     false_pos := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (false_pos = -1) then (     OclFile["System.out"].println(N + " " + 1) ; 
     return ) else skip ; 
    var counts : Sequence(int) ; counts := Integer.subrange(1,N)->collect(0) ;
    var count : int ; count := 0 ;
    var prev : boolean ; prev := false ;
        var i : int ; i := 0 ; while i < N do ( (     var index : int ; index := (i + false_pos) mod N ;
     if (colored[index+1]) then (     if (not(prev)) then (     prev := true ) else skip ; 
     count := count + 1 ) else (     if (prev) then (     prev := false ; 
     counts[count+1] := counts[count+1] + 1 ; 
     count := 0 ) else skip ) )  ;     i := i + 1 ) ; 
    if (count /= 0) then (     counts[count+1] := counts[count+1] + 1 ; 
     count := 0 ) else skip ; 
        var i : int ; i := N - 1 ; while i >= 0 do ( (     if (counts[i+1] > 0) then (     OclFile["System.out"].println(i + " " + counts[i+1]) ) else skip )  ;     i := i - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long max=(1<<n);
    StringBuilder sb=new StringBuilder();
    for(long i=0 ; i<max ; i++){
      sb.append(i).append(":");
      long x=i ;
      for(int j=0 ; j<=18 && x>0 ; j++){
        if(x % 2==1){
          sb.append(" ").append(j);
        }
        x>>=1 ;
      }
      sb.append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var max : long ; max := ((1*(2->pow(n)))->oclAsType(long)) ;
    var sb : String ; sb := StringLib.newString() ;
        var i : long ; i := 0 ; while i < max do ( (     sb := sb + StringLib.newString(i) + StringLib.newString(":") ; 
     var x : long ; x := i ;
         var j : int ; j := 0 ; while j <= 18 & x > 0 do ( (     if (x mod 2 = 1) then (     sb := sb + StringLib.newString(" ") + StringLib.newString(j) ) else skip ; 
     x := x/(2->pow(1)) )  ;     j := j + 1 ) ; 
     sb := sb + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      for(int bit=0 ; bit<(1<<n); bit++){
        System.out.print(bit+":");
        for(int j=0 ; j<n ; j++){
          if(((bit>>j)& 1)==1){
            System.out.print(" "+j);
          }
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var bit : int ; bit := 0 ; while bit < ((1*(2->pow(n)))->oclAsType(long)) do ( (     OclFile["System.out"].print(bit + ":") ; 
         var j : int ; j := 0 ; while j < n do ( (     if ((((bit/(2->pow(j)))->oclAsType(long)) & 1) = 1) then (     OclFile["System.out"].print(" " + j) ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     bit := bit + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
class GFG {
  static int gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    if(a==b)return a ;
    if(a>b)return gcd(a-b,b);
    return gcd(a,b-a);
  }
  static int LCM(int x,int y,int z){
    int ans=((x*y)/(gcd(x,y)));
    return((z*ans)/(gcd(ans,z)));
  }
  static int findDivisible(int n,int x,int y,int z){
    int lcm=LCM(x,y,z);
    int largestNDigitNum=(int)Math.pow(10,n)-1 ;
    int remainder=largestNDigitNum % lcm ;
    if(remainder==0)return largestNDigitNum ;
    largestNDigitNum-=remainder ;
    if(largestNDigitNum>=(int)Math.pow(10,n-1))return largestNDigitNum ;
    else return 0 ;
  }
  public static void main(String args[]){
    int n=2,x=3,y=4,z=6 ;
    int res=findDivisible(n,x,y,z);
    if(res!=0)System.out.println(res);
    else System.out.println("Not possible");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
    if (a = b) then     return a else skip ; 
    if (a > b) then     return gcd(a - b, b) else skip ; 
    return gcd(a, b - a) 
 );
  static   operation LCM( x : int, y : int, z : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := ((x * y) / (gcd(x, y))) ;
     return ((z * ans) / (gcd(ans, z))) );
  static   operation findDivisible( n : int, x : int, y : int, z : int) : int
  pre: true
  post: true
  activity: (     var lcm : int ; lcm := LCM(x, y, z) ;
     var largestNDigitNum : int ; largestNDigitNum := 10->pow(n)->oclAsType(int) - 1 ;
    var remainder : int ; remainder := largestNDigitNum mod lcm ;
    if (remainder = 0) then     return largestNDigitNum else skip ; 
    largestNDigitNum := largestNDigitNum-(remainder) ; 
    if (largestNDigitNum >= 10->pow(n - 1)->oclAsType(int)) then     return largestNDigitNum else     return 0 ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
    var x : int ; x := 3 ;
    var y : int ; y := 4 ;
    var z : int ; z := 6 ;
     var res : int ; res := findDivisible(n, x, y, z) ;
     if (res /= 0) then     OclFile["System.out"].println(res) ; else     OclFile["System.out"].println("Not possible") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  final static int MOD=1000000007 ;
  static long modInv(long a){
    long p=MOD-2 ;
    long s=1 ;
    while(p!=1){
      if(p % 2==1)s=(s*a)% MOD ;
      a=(a*a)% MOD ;
      p/=2 ;
    }
    return(a*s)% MOD ;
  }
  static long findCnt(char x,String y){
    long ans=0 ;
    long fact[]=new long[y.length()+1];
    for(int i=0 ; i<y.length()+1 ; i++)fact[i]=1 ;
    for(int i=1 ; i<=y.length(); i++)fact[i]=(fact[i-1]*i)% MOD ;
    for(int i=0 ; i<y.length(); i++){
      if(y.charAt(i)==x){
        ans+=(modInv(fact[i])*modInv(fact[y.length()-i-1]))% MOD ;
        ans %=MOD ;
      }
    }
    ans*=fact[(y.length()-1)];
    ans %=MOD ;
    return ans ;
  }
  public static void main(String[] args){
    char x='a' ;
    String y="xxayy" ;
    System.out.println(findCnt(x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MOD : int := 1000000007;
  static   operation modInv( a : long) : long
  pre: true
  post: true
  activity: (     var p : long ; p := MOD - 2 ;
     var s : long ; s := 1 ;
     while (p /= 1) do (     if (p mod 2 = 1) then     s := (s * a) mod MOD ; else skip ; 
     a := (a * a) mod MOD ; 
     p := p/(2) ) ; 
     return (a * s) mod MOD );
  static   operation findCnt( x : String, y : String) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
     var fact : Sequence(long) ; fact := Integer.subrange(1,y->size() + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < y->size() + 1 do (     fact[i+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= y->size() do (     fact[i+1] := (fact[i - 1+1] * i) mod MOD ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < y->size() do ( (     if (y->at(i+1) = x) then (     ans := ans+((modInv(fact[i+1]) * modInv(fact[y->size() - i - 1+1])) mod MOD) ; 
     ans := ans mod MOD ) else skip )  ;     i := i + 1 ) ; 
    ans := ans*(fact[(y->size() - 1)+1]) ; 
    ans := ans mod MOD ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : String ; x := 'a' ;
     var y : String ; y := "xxayy" ;
     OclFile["System.out"].println(findCnt(x, y)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Subarray {
  static int calculate(int a[],int n){
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      int r=i+1 ;
      for(int j=r ; j<n ; j++){
        if(a[i]==a[j])r+=1 ;
        else break ;
      }
      int d=r-i ;
      ans+=(d*(d+1)/2);
      i=r-1 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int a[]={
      2,4,5,3,3,3 };
      System.out.println(calculate(a,a.length));
    }
  }

------------------------------------------------------------
OCL File:
---------
class Subarray {
  static   operation calculate( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var r : int ; r := i + 1 ;
         var j : int ; j := r ; while j < n do ( (     if (a[i+1] = a[j+1]) then     r := r+(1) ; else     break )  ;     j := j + 1 ) ; 
    var d : int ; d := r - i ;
    ans := ans+((d * (d + 1) / 2)) ; 
    i := r - 1 ; 
 )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,4,5,3,3,3} ;
     OclFile["System.out"].println(calculate(a, a->size())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int INF=1<<29 ;
    int W=sc.nextInt();
    int[] A=new int[W];
    for(int i=0 ; i<W ; ++i){
      A[i]=Integer.parseInt(sc.next());
    }
    int[][] c=new int[2][W];
    for(int loop=0 ; loop<2 ; ++loop){
      int exit=-1 ;
      int time=INF ;
      for(int i=0 ; i<W ; ++i){
        if(A[i]==0){
          exit=i ;
          time=INF ;
        }
        else if(A[i]<0){
          if(exit!=-1)time=Math.min(time,-A[i]+i-exit);
        }
        else {
          if(exit!=-1)c[loop][i]=Math.max(0,Math.min(A[i],time-(i-exit)));
        }
      }
      for(int i=0 ; i<W/2 ; ++i){
        int tmp=A[i];
        A[i]=A[W-1-i];
        A[W-1-i]=tmp ;
      }
    }
    int ans=0 ;
    for(int i=0 ; i<W ; ++i){
      ans+=Math.max(c[0][i],c[1][W-1-i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var INF : int ; INF := (1*(2->pow(29)))->oclAsType(long) ;
     var W : int ; W := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,W)->collect(0) ;
        var i : int ; i := 0 ; while i < W do ( (     A[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,2)->collect(Integer.subrange(1,W)->collect(0)) ;
        var loop : int ; loop := 0 ; while loop < 2 do ( (     var exit : int ; exit := -1 ;
     var time : int ; time := INF ;
         var i : int ; i := 0 ; while i < W do ( (     if (A[i+1] = 0) then (     exit := i ; 
     time := INF ) else     if (A[i+1] < 0) then (     if (exit /= -1) then     time := Set{time, -A[i+1] + i - exit}->min() ; else skip ) else (     if (exit /= -1) then     c[loop+1][i+1] := Set{0, Set{A[i+1], time - (i - exit)}->min()}->max() ; else skip ) ;  )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < W / 2 do ( (     var tmp : int ; tmp := A[i+1] ;
     A[i+1] := A[W - 1 - i+1] ; 
     A[W - 1 - i+1] := tmp )  ;     i := i + 1 ) )  ;     loop := loop + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < W do ( (     ans := ans+(Set{c[0+1][i+1], c[1+1][W - 1 - i+1]}->max()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printBinStr(int[] str,int len){
    for(int i=0 ; i<len ; i++){
      System.out.print(str[i]);
    }
    System.out.println();
  }
  static void generateBinStr(int[] str,int len,int currlen,int occur,int nextbit){
    if(currlen==len){
      if(occur==2 && nextbit==0){
        printBinStr(str,len);
      }
      return ;
    }
    if(currlen==0){
      str[0]=nextbit ;
      generateBinStr(str,len,currlen+1,occur,0);
      generateBinStr(str,len,currlen+1,occur,1);
    }
    else if(occur<2){
      str[currlen]=nextbit ;
      if(str[currlen-1]==0 && nextbit==1){
        occur+=1 ;
      }
      generateBinStr(str,len,currlen+1,occur,0);
      generateBinStr(str,len,currlen+1,occur,1);
    }
    else if(str[currlen-1]==0 && nextbit==1){
      return ;
    }
    else {
      str[currlen]=nextbit ;
      generateBinStr(str,len,currlen+1,occur,0);
      generateBinStr(str,len,currlen+1,occur,1);
    }
  }
  public static void main(String[] args){
    int n=5 ;
    if(n<4){
      System.out.print(-1);
    }
    else {
      int[] str=new int[n];
      generateBinStr(str,n,0,0,0);
      generateBinStr(str,n,0,0,1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printBinStr( str : Sequence(int), len : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < len do ( (     OclFile["System.out"].print(str[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation generateBinStr( str : Sequence(int), len : int, currlen : int, occur : int, nextbit : int) : void
  pre: true
  post: true
  activity: (     if (currlen = len) then (     if (occur = 2 & nextbit = 0) then (     execute printBinStr(str, len) ) else skip ; 
     return ) else skip ; 
     if (currlen = 0) then (     str[0+1] := nextbit ; 
     execute generateBinStr(str, len, currlen + 1, occur, 0) ; 
     execute generateBinStr(str, len, currlen + 1, occur, 1) ) else     if (occur < 2) then (     str[currlen+1] := nextbit ; 
     if (str[currlen - 1+1] = 0 & nextbit = 1) then (     occur := occur+(1) ) else skip ; 
     execute generateBinStr(str, len, currlen + 1, occur, 0) ; 
     execute generateBinStr(str, len, currlen + 1, occur, 1) ) else     if (str[currlen - 1+1] = 0 & nextbit = 1) then (     return ) else (     str[currlen+1] := nextbit ; 
     execute generateBinStr(str, len, currlen + 1, occur, 0) ; 
     execute generateBinStr(str, len, currlen + 1, occur, 1) ) ;  ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     if (n < 4) then (     OclFile["System.out"].print(-1) ) else (     var str : Sequence(int) ; str := Integer.subrange(1,n)->collect(0) ;
     execute generateBinStr(str, n, 0, 0, 0) ; 
     execute generateBinStr(str, n, 0, 0, 1) ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=26 ;
  static void performQueries(String str,int q,int type[],char ch[],int freq[]){
    int n=str.length();
    int[][] L=new int[MAX][n];
    int[][] F=new int[MAX][n];
    int[] cnt=new int[MAX];
    for(int i=0 ; i<n ; i++){
      int k=str.charAt(i)-'a' ;
      cnt[k]++;
      for(int j=0 ; j<MAX ; j++){
        if(k==j){
          L[j][cnt[j] ]=i ;
          F[j][cnt[j] ]=i ;
        }
        else L[j][cnt[j] ]=L[j][cnt[j] ]+1 ;
      }
    }
    for(int i=0 ; i<q ; i++){
      if(type[i]==1){
        System.out.print(L[ch[i]-'a'][freq[i] ]);
      }
      else {
        System.out.print(F[ch[i]-'a'][freq[i] ]);
      }
      System.out.print("\n");
    }
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    int type[]={
      1,2 };
      char ch[]={
        'e','k' };
        int freq[]={
          2,2 };
          int q=type.length ;
          performQueries(str,q,type,ch,freq);
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 26;
  static   operation performQueries( str : String, q : int, type : Sequence(int), ch : Sequence(String), freq : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var L : Sequence(Sequence(int)) ; L := Integer.subrange(1,MAX)->collect(Integer.subrange(1,n)->collect(0)) ;
    var F : Sequence(Sequence(int)) ; F := Integer.subrange(1,MAX)->collect(Integer.subrange(1,n)->collect(0)) ;
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,MAX)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var k : int ; k := str->at(i+1) - ('a')->char2byte() ;
     cnt[k+1] := cnt[k+1] + 1 ; 
         var j : int ; j := 0 ; while j < MAX do ( (     if (k = j) then (     L[j+1][cnt[j+1]+1] := i ; 
     F[j+1][cnt[j+1]+1] := i ) else     L[j+1][cnt[j+1]+1] := L[j+1][cnt[j+1]+1] + 1 ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     if (type[i+1] = 1) then (     OclFile["System.out"].print(L[ch[i+1] - ('a')->char2byte()+1][freq[i+1]+1]) ) else (     OclFile["System.out"].print(F[ch[i+1] - ('a')->char2byte()+1][freq[i+1]+1]) ) ;  
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var type : Sequence(int) ; type := Sequence{1,2} ;
    var ch : Sequence(String) ; ch := Sequence{'e','k'} ;
    var freq : Sequence(int) ; freq := Sequence{2,2} ;
    var q : int ; q := type->size() ;
    execute performQueries(str, q, type, ch, freq) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public static void main(String[] args){
    int i,j ;
    int val=new java.util.Scanner(System.in).nextInt();
    int a=2 ;
    System.out.print(val+":");
    while(val>=a*a){
      if(val % a==0){
        System.out.print(" "+a);
        val/=a ;
      }
      else {
        a++;
      }
    }
    System.out.println(" "+val);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var val : int ; val := Scanner.newScanner(OclFile["System.in"]).nextInt() ;
    var a : int ; a := 2 ;
    OclFile["System.out"].print(val + ":") ; 
    while (val >= a * a) do (     if (val mod a = 0) then (     OclFile["System.out"].print(" " + a) ; 
     val := val/(a) ) else (     a := a + 1 ) ) ; 
    OclFile["System.out"].println(" " + val) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    List<Long>unko=new ArrayList<Long>();
    int unko2=sc.nextInt();
    fra(unko2,unko);
    int[] Ns=new int[32];
    int cnt=0 ;
    for(int i=0 ; i<unko.size(); i++){
      long tmp=unko.get(i);
      if(tmp>1){
        Ns[cnt]=(int)tmp ;
        cnt++;
      }
    }
    int[] kai=new int[cnt];
    for(int i=0 ; i<cnt ; i++){
      kai[i]=Ns[i];
    }
    Arrays.sort(kai);
    String buri="" ;
    buri=buri+unko2+": " ;
    for(int i=0 ; i<cnt-1 ; i++){
      buri=buri+kai[i]+" " ;
    }
    buri=buri+kai[cnt-1];
    System.out.println(buri);
  }
  public static void fra(int a,List<Integer>p){
    for(int i=2 ; i*i<=a ; i++){
      if(a % i==0){
        p.add(i);
        fra(a/i,p);
        return ;
      }
    }
    p.add(a);
  }
  public static void fra(long a,List<Long>p){
    for(long i=2 ; i*i<=a ; i++){
      if(a % i==0){
        p.add(i);
        fra(a/i,p);
        return ;
      }
    }
    p.add(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var unko : Sequence(long) ; unko := Sequence{} ;
    var unko2 : int ; unko2 := sc.getCurrent()->toInteger() ;
    execute fra(unko2, unko) ; 
    var Ns : Sequence(int) ; Ns := Integer.subrange(1,32)->collect(0) ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < unko->size() do ( (     var tmp : long ; tmp := unko->at(i+1) ;
     if (tmp > 1) then (     Ns[cnt+1] := tmp->oclAsType(int) ; 
     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    var kai : Sequence(int) ; kai := Integer.subrange(1,cnt)->collect(0) ;
        var i : int ; i := 0 ; while i < cnt do ( (     kai[i+1] := Ns[i+1] )  ;     i := i + 1 ) ; 
    kai := kai->sort() ; 
    var buri : String ; buri := "" ;
    buri := buri + unko2 + ": " ; 
        var i : int ; i := 0 ; while i < cnt - 1 do ( (     buri := buri + kai[i+1] + " " )  ;     i := i + 1 ) ; 
    buri := buri + kai[cnt - 1+1] ; 
    OclFile["System.out"].println(buri) ; 
 );
  static   operation fra( a : int, p : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= a do ( (     if (a mod i = 0) then (     p->excludes(i) ; 
     execute fra(a / i, p) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     p->excludes(a) );
  static   operation fra( a : long, p : Sequence(long)) : void
  pre: true
  post: true
  activity: (         var i : long ; i := 2 ; while i * i <= a do ( (     if (a mod i = 0) then (     p->excludes(i) ; 
     execute fra(a / i, p) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     p->excludes(a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner io=new Scanner(System.in);
    int n=io.nextInt();
    int[] a=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      a[i]=io.nextInt();
    }
    long sum=0 ;
    long now=0 ;
    long border=1 ;
    long end=0 ;
    long ans_p=0 ;
    for(int i=1 ; i<=n ; i++){
      sum+=a[i];
      end=border-sum ;
      if(border>0){
        if(now<end){
          ans_p+=Math.abs(now-end);
          now=end ;
        }
      }
      else {
        if(now>end){
          ans_p+=Math.abs(now-end);
          now=end ;
        }
      }
      border=-border ;
    }
    sum=0 ;
    now=0 ;
    border=-1 ;
    end=0 ;
    long ans_m=0 ;
    for(int i=1 ; i<=n ; i++){
      sum+=a[i];
      end=border-sum ;
      if(border>0){
        if(now<end){
          ans_m+=Math.abs(now-end);
          now=end ;
        }
      }
      else {
        if(now>end){
          ans_m+=Math.abs(now-end);
          now=end ;
        }
      }
      border=-border ;
    }
    System.out.println(Math.min(ans_p,ans_m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := io.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := io.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    var now : long ; now := 0 ;
    var border : long ; border := 1 ;
    var end : long ; end := 0 ;
    var ans_p : long ; ans_p := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     sum := sum+(a[i+1]) ; 
     end := border - sum ; 
     if (border > 0) then (     if (now < end) then (     ans_p := ans_p+(if now - end < 0 then -(now - end) else now - end endif) ; 
     now := end ) else skip ) else (     if (now > end) then (     ans_p := ans_p+(if now - end < 0 then -(now - end) else now - end endif) ; 
     now := end ) else skip ) ;  
     border := -border )  ;     i := i + 1 ) ; 
    sum := 0 ; 
    now := 0 ; 
    border := -1 ; 
    end := 0 ; 
    var ans_m : long ; ans_m := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     sum := sum+(a[i+1]) ; 
     end := border - sum ; 
     if (border > 0) then (     if (now < end) then (     ans_m := ans_m+(if now - end < 0 then -(now - end) else now - end endif) ; 
     now := end ) else skip ) else (     if (now > end) then (     ans_m := ans_m+(if now - end < 0 then -(now - end) else now - end endif) ; 
     now := end ) else skip ) ;  
     border := -border )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{ans_p, ans_m}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      long n=Long.parseLong(br.readLine());
      printFactor(n);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  private static void printFactor(long n){
    System.out.print(n+":");
    factorize(n,3);
  }
  private static void factorize(long n,long r){
    if(n==1){
      System.out.println();
      return ;
    }
    System.out.print(" ");
    if(isPrime(n)){
      System.out.print(n);
      System.out.println();
      return ;
    }
    else if(n % 2==0){
      System.out.print(2);
      n=n/(long)2 ;
    }
    else {
      for(long i=r ; i<=n ; i+=2){
        if(n % i==0){
          r=i ;
          System.out.print(i);
          n=n/i ;
          break ;
        }
      }
    }
    factorize(n,r);
  }
  private static boolean isPrime(long n){
    if(n==2){
      return true ;
    }
    if(n<2 || n % 2==0){
      return false ;
    }
    int i=3 ;
    while(i<=Math.sqrt((double)n)){
      if(n % i==0){
        return false ;
      }
      i=i+2 ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var n : long ; n := (br.readLine())->toLong() ;
     execute printFactor(n) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
  static   operation printFactor( n : long) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(n + ":") ; 
     execute factorize(n, 3) );
  static   operation factorize( n : long, r : long) : void
  pre: true
  post: true
  activity: (     if (n = 1) then (     OclFile["System.out"].println() ; 
     return ) else skip ; 
     OclFile["System.out"].print(" ") ; 
     if (isPrime(n)) then (     OclFile["System.out"].print(n) ; 
     OclFile["System.out"].println() ; 
     return ) else     if (n mod 2 = 0) then (     OclFile["System.out"].print(2) ; 
     n := n / 2->oclAsType(long) ) else (         var i : long ; i := r ; while i <= n do ( (     if (n mod i = 0) then (     r := i ; 
     OclFile["System.out"].print(i) ; 
     n := n / i ; 
     break ) else skip )  ;     i := i+(2) ) ) ;  ;  
     execute factorize(n, r) );
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n = 2) then (     return true ) else skip ; 
     if (n < 2 or n mod 2 = 0) then (     return false ) else skip ; 
    var i : int ; i := 3 ;
    while (i <= (n->oclAsType(double))->sqrt()) do (     if (n mod i = 0) then (     return false ) else skip ; 
     i := i + 2 ) ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    PrimeNumberGenerator pg=new PrimeNumberGenerator();
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    ArrayList<Integer>list=new ArrayList<Integer>();
    int n2=n ;
    while(true){
      boolean divided=false ;
      int limit=(int)Math.sqrt(n2);
      for(int i=2 ; i<=limit ; i++){
        if(! pg.isPrime(i)){
          continue ;
        }
        if(n2 % i==0){
          n2/=i ;
          list.add(i);
          divided=true ;
          break ;
        }
      }
      if(! divided){
        list.add(n2);
        break ;
      }
    }
    System.out.print(n+":");
    for(int i=0 ; i<list.size(); i++){
      System.out.print(" "+list.get(i));
    }
    System.out.println();
  }
}
class PrimeNumberGenerator {
  private boolean[] isPrime=new boolean[100001];
  public PrimeNumberGenerator(){
    Arrays.fill(isPrime,true);
    isPrime[0]=false ;
    isPrime[1]=false ;
    isPrime[2]=true ;
    int limit=(int)Math.sqrt(isPrime.length);
    for(int i=3 ; i<=limit ; i+=2){
      if(isPrime[i]==false){
        continue ;
      }
      for(int j=i*2 ; j<=isPrime.length-1 ; j+=i){
        isPrime[j]=false ;
      }
    }
  }
  public boolean isPrime(int index){
    if(index % 2==0 && index!=2){
      return false ;
    }
    return isPrime[index];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var pg : PrimeNumberGenerator ; pg := PrimeNumberGenerator.newPrimeNumberGenerator() ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
    var n2 : int ; n2 := n ;
    while (true) do (     var divided : boolean ; divided := false ;
     var limit : int ; limit := (n2)->sqrt()->oclAsType(int) ;
         var i : int ; i := 2 ; while i <= limit do ( (     if (not(pg.isPrime(i))) then (     continue ) else skip ; 
     if (n2 mod i = 0) then (     n2 := n2/(i) ; 
     list := list->including(i) ; 
     divided := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (not(divided)) then (     list := list->including(n2) ; 
     break ) else skip ) ; 
    OclFile["System.out"].print(n + ":") ; 
        var i : int ; i := 0 ; while i < list->size() do ( (     OclFile["System.out"].print(" " + list->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}
class PrimeNumberGenerator {
   attribute isPrime : Sequence(boolean) := Integer.subrange(1,100001)->collect(false);
   static operation newPrimeNumberGenerator() : PrimeNumberGenerator
  pre: true
  post: true
  activity:
  ( var self : PrimeNumberGenerator ;
    self := createPrimeNumberGenerator();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     isPrime := isPrime->collect(true) ; 
     isPrime[0+1] := false ; 
    isPrime[1+1] := false ; 
    isPrime[2+1] := true ; 
    var limit : int ; limit := (isPrime->size())->sqrt()->oclAsType(int) ;
        var i : int ; i := 3 ; while i <= limit do ( (     if (isPrime[i+1] = false) then (     continue ) else skip ; 
         var j : int ; j := i * 2 ; while j <= isPrime->size() - 1 do ( (     isPrime[j+1] := false )  ;     j := j+(i) ) )  ;     i := i+(2) ) ; 
 );
   operation isPrime( index : int) : boolean
  pre: true
  post: true
  activity: (     if (index mod 2 = 0 & index /= 2) then (     return false ) else skip ; 
     return isPrime[index+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws Exception {
    FastScanner scanner=new FastScanner(System.in);
    int n=(int)scanner.nextInt();
    StringBuffer str=new StringBuffer();
    str.append(n+":");
    for(int i=2 ; i*i<=n ; i++){
      while(n % i==0){
        n=n/i ;
        str.append(" "+i);
      }
    }
    if(n>1){
      str.append(" "+n);
    }
    PrintWriter printWriter=new PrintWriter(System.out);
    printWriter.printf("%s\n",str.toString());
    printWriter.close();
  }
  static class FastScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public FastScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
      tokenizer=null ;
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public long nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : FastScanner ; scanner := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var n : int ; n := scanner.nextInt()->oclAsType(int) ;
    var str : String ; str := StringLib.newString() ;
    str := str + StringLib.newString(n + ":") ; 
        var i : int ; i := 2 ; while i * i <= n do ( (     while (n mod i = 0) do (     n := n / i ; 
     str := str + StringLib.newString(" " + i) ) )  ;     i := i + 1 ) ; 
    if (n > 1) then (     str := str + StringLib.newString(" " + n) ) else skip ; 
    var printWriter : OclFile ; printWriter := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : long
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isDigitPresent(int x,int d){
    while(x>0){
      if(x % 10==d)break ;
      x=x/10 ;
    }
    return(x>0);
  }
  static void printNumbers(int n,int d){
    for(int i=0 ; i<=n ; i++)if(i==d || isDigitPresent(i,d))System.out.print(i+" ");
  }
  public static void main(String[] args){
    int n=47,d=7 ;
    printNumbers(n,d);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isDigitPresent( x : int, d : int) : boolean
  pre: true
  post: true
  activity: (     while (x > 0) do (     if (x mod 10 = d) then     break else skip ; 
     x := x / 10 ) ; 
     return (x > 0) );
  static   operation printNumbers( n : int, d : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= n do (     if (i = d or isDigitPresent(i, d)) then     OclFile["System.out"].print(i + " ") ; else skip ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 47 ;
    var d : int ; d := 7 ;
     execute printNumbers(n, d) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class DegreeOfVertex {
  static class Graph {
    int v,e ;
    int[][] dir ;
    Graph(int v,int e){
      this.v=v ;
      this.e=e ;
      dir=new int[v][];
      for(int i=0 ; i<v ; i++)dir[i]=new int[v];
    }
  }
  static Graph createGraph(int v,int e){
    Graph G=new Graph(v,e);
    G.dir[0][1]=1 ;
    G.dir[0][2]=1 ;
    G.dir[0][3]=1 ;
    G.dir[1][0]=1 ;
    G.dir[1][3]=1 ;
    G.dir[2][0]=1 ;
    G.dir[2][3]=1 ;
    G.dir[3][0]=1 ;
    G.dir[3][1]=1 ;
    G.dir[3][2]=1 ;
    return G ;
  }
  static int findDegree(Graph G,int ver){
    int degree=0 ;
    for(int i=0 ; i<G.v ; i++){
      if(G.dir[ver][i]==1)degree++;
    }
    return degree ;
  }
  public static void main(String[] args){
    int vertices=4 ;
    int edges=5 ;
    Graph G=createGraph(vertices,edges);
    int ver=0 ;
    int degree=findDegree(G,ver);
    System.out.println(degree);
  }
}
------------------------------------------------------------
OCL File:
---------
class DegreeOfVertex {
  static class Graph {
   attribute v : int;
   attribute dir : Sequence(Sequence(int));
   static operation newGraph( v : int, e : int) : Graph
  pre: true
  post: true
  activity:
  ( var self : Graph ;
    self := createGraph();
    self.initialise(v, e);
    return self );
  operation initialise( v : int, e : int) : void
  pre: true  post: true
  activity: (     self.v := v ; 
     self.e := e ; 
     dir := Integer.subrange(1,v)->collect(Sequence{}) ; 
         var i : int ; i := 0 ; while i < v do (     dir[i+1] := Integer.subrange(1,v)->collect(0) ;  ;     i := i + 1 ) );
}
  static   operation createGraph( v : int, e : int) : Graph
  pre: true
  post: true
  activity: (     var G : Graph ; G := Graph.newGraph(v, e) ;
     G.dir[0+1][1+1] := 1 ; 
    G.dir[0+1][2+1] := 1 ; 
    G.dir[0+1][3+1] := 1 ; 
    G.dir[1+1][0+1] := 1 ; 
    G.dir[1+1][3+1] := 1 ; 
    G.dir[2+1][0+1] := 1 ; 
    G.dir[2+1][3+1] := 1 ; 
    G.dir[3+1][0+1] := 1 ; 
    G.dir[3+1][1+1] := 1 ; 
    G.dir[3+1][2+1] := 1 ; 
    return G 
 );
  static   operation findDegree( G : Graph, ver : int) : int
  pre: true
  post: true
  activity: (     var degree : int ; degree := 0 ;
         var i : int ; i := 0 ; while i < G.v do ( (     if (G.dir[ver+1][i+1] = 1) then     degree := degree + 1 ; else skip )  ;     i := i + 1 ) ; 
     return degree );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var vertices : int ; vertices := 4 ;
     var edges : int ; edges := 5 ;
    var G : Graph ; G := createGraph(vertices, edges) ;
    var ver : int ; ver := 0 ;
    var degree : int ; degree := findDegree(G, ver) ;
    OclFile["System.out"].println(degree) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int findElement(int arr[],int size){
    int right_sum=0,left_sum=0 ;
    for(int i=1 ; i<size ; i++)right_sum+=arr[i];
    for(int i=0,j=1 ; j<size ; i++,j++){
      right_sum-=arr[j];
      left_sum+=arr[i];
      if(left_sum==right_sum)return arr[i+1];
    }
    return-1 ;
  }
  public static void main(String args[]){
    int arr[]={
      2,3,4,1,4,5 };
      int size=arr.length ;
      System.out.println(findElement(arr,size));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findElement( arr : Sequence(int), size : int) : int
  pre: true
  post: true
  activity: (     var right_sum : int ; right_sum := 0 ;
    var left_sum : int ; left_sum := 0 ;
         var i : int ; i := 1 ; while i < size do (     right_sum := right_sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ;
    var j : int ; j := 1 ; while j < size do ( (     right_sum := right_sum-(arr[j+1]) ; 
     left_sum := left_sum+(arr[i+1]) ; 
     if (left_sum = right_sum) then     return arr[i + 1+1] else skip )  ;     i := i + 1 ;     j := j + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4,1,4,5} ;
     var size : int ; size := arr->size() ;
     OclFile["System.out"].println(findElement(arr, size)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Stack ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int[] parent=new int[n+1];
    for(int i=2 ; i<=n ; i++){
      parent[i]=scanner.nextInt();
    }
    int q=n ;
    Stack<Integer>stack=new Stack<>();
    while(q!=0){
      stack.push(q);
      q=parent[q];
    }
    while(! stack.isEmpty()){
      System.out.print(stack.pop()+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var parent : Sequence(int) ; parent := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 2 ; while i <= n do ( (     parent[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var q : int ; q := n ;
    var stack : Sequence(int) ; stack := Sequence{} ;
    while (q /= 0) do (     stack := stack->append(q) ; 
     q := parent[q+1] ) ; 
    while (not(stack->isEmpty())) do (     OclFile["System.out"].print(stack->last() + " ") ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class BmailComputerNetwork {
  public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    String number=scanner.nextLine();
    int n=Integer.parseInt(number);
    String[] array=scanner.nextLine().split(" ");
    int routerNumber=2 ;
    Map<Integer,Set<Integer>>map=new HashMap<>();
    Map<Integer,Integer>visitedToFrom=new HashMap<>();
    for(String str : array){
      int routerConnectionTo=Integer.parseInt(str);
      map.putIfAbsent(routerConnectionTo,new HashSet<>());
      map.putIfAbsent(routerNumber,new HashSet<>());
      map.get(routerConnectionTo).add(routerNumber);
      map.get(routerNumber).add(routerConnectionTo);
      routerNumber++;
    }
    int start=1 ;
    Queue<Integer>queue=new LinkedList<>();
    queue.offer(start);
    Stack<Integer>stack=new Stack<>();
    boolean foundN=false ;
    while(queue.size()>0){
      int current=queue.poll();
      for(int next : map.get(current)){
        if(visitedToFrom.containsKey(next))continue ;
        visitedToFrom.put(next,current);
        queue.offer(next);
        if(next==n){
          foundN=true ;
          break ;
        }
      }
      if(foundN){
        stack.push(n);
        break ;
      }
    }
    int destination=n ;
    while(visitedToFrom.containsKey(destination)&& destination!=1){
      stack.push(visitedToFrom.get(destination));
      destination=stack.peek();
    }
    while(stack.size()>0)System.out.print(stack.pop()+(stack.size()==0 ? "" : " "));
  }
}
------------------------------------------------------------
OCL File:
---------
 class BmailComputerNetwork {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : String ; number := scanner.nextLine() ;
    var n : int ; n := (number)->toInteger() ;
    var array : Sequence(String) ; array := scanner.nextLine()->split(" ") ;
    var routerNumber : int ; routerNumber := 2 ;
    var map : Map(int,Set(int)) ; map := Map{} ;
    var visitedToFrom : Map(int,int) ; visitedToFrom := Map{} ;
    for (str : array) do ( (     var routerConnectionTo : int ; routerConnectionTo := (str)->toInteger() ;
     if map->keys()->includes(routerConnectionTo) then skip else map := map->union(Map{routerConnectionTo |-> Set{}}) ; 
    if map->keys()->includes(routerNumber) then skip else map := map->union(Map{routerNumber |-> Set{}}) ; 
    map->at(routerConnectionTo)->excludes(routerNumber) ; 
    map->at(routerNumber)->excludes(routerConnectionTo) ; 
    routerNumber := routerNumber + 1 ; 
 )  ) ; 
    var start : int ; start := 1 ;
    var queue : Sequence(int) ; queue := Sequence{} ;
    queue := queue->including(start) ; 
    var stack : Sequence(int) ; stack := Sequence{} ;
    var foundN : boolean ; foundN := false ;
    while (queue->size() > 0) do (     var current : int ; current := queue->min() ;
     for (next : map->at(current)) do ( (     if (visitedToFrom->keys()->includes(next)) then     continue else skip ; 
     visitedToFrom := visitedToFrom->union(Map{next |-> current}) ; 
     queue := queue->including(next) ; 
     if (next = n) then (     foundN := true ; 
     break ) else skip )  ) ; 
     if (foundN) then (     stack := stack->append(n) ; 
     break ) else skip ) ; 
    var destination : int ; destination := n ;
    while (visitedToFrom->keys()->includes(destination) & destination /= 1) do (     stack := stack->append(visitedToFrom->at(destination)) ; 
     destination := stack->min() ) ; 
    while (stack->size() > 0) do     OclFile["System.out"].print(stack->last() + (if stack->size() = 0 then "" else " " endif)) ; ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class bmails {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] parent=new int[n+1];
    for(int i=2 ; i<=n ; i++)parent[i]=sc.nextInt();
    int q=n ;
    Stack<Integer>st=new Stack<>();
    while(q!=0){
      st.push(q);
      q=parent[q];
    }
    while(! st.isEmpty())System.out.print(st.pop()+" ");
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class bmails {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var parent : Sequence(int) ; parent := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 2 ; while i <= n do (     parent[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var q : int ; q := n ;
    var st : Sequence(int) ; st := Sequence{} ;
    while (q /= 0) do (     st := st->append(q) ; 
     q := parent[q+1] ) ; 
    while (not(st->isEmpty())) do     OclFile["System.out"].print(st->last() + " ") ; ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
    int n=Integer.parseInt(in.readLine());
    int[] ps=new int[n];
    ps[0]=-1 ;
    String[] sps=in.readLine().split(" ");
    for(int i=1 ; i<n ; i++){
      ps[i]=Integer.parseInt(sps[i-1])-1 ;
    }
    int current=n-1 ;
    ArrayList<Integer>ans=new ArrayList<>();
    while(current!=-1){
      ans.add(current);
      current=ps[current];
    }
    for(int i=ans.size()-1 ; i>=0 ; i--){
      if(i!=ans.size()-1){
        out.write(" ");
      }
      out.write((ans.get(i)+1)+"");
    }
    out.write("\n");
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := (in.readLine())->toInteger() ;
    var ps : Sequence(int) ; ps := Integer.subrange(1,n)->collect(0) ;
    ps[0+1] := -1 ; 
    var sps : Sequence(String) ; sps := in.readLine()->split(" ") ;
        var i : int ; i := 1 ; while i < n do ( (     ps[i+1] := (sps[i - 1+1])->toInteger() - 1 )  ;     i := i + 1 ) ; 
    var current : int ; current := n - 1 ;
    var ans : Sequence(int) ; ans := Sequence{} ;
    while (current /= -1) do (     ans := ans->including(current) ; 
     current := ps[current+1] ) ; 
        var i : int ; i := ans->size() - 1 ; while i >= 0 do ( (     if (i /= ans->size() - 1) then (     skip ) else skip ; 
     skip )  ;     i := i - 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      int n=Integer.parseInt(br.readLine());
      StringTokenizer str=new StringTokenizer(br.readLine()," ");
      long[] A=new long[n];
      for(int i=0 ; i<n ; i++){
        A[i]=Integer.parseInt(str.nextToken());
      }
      long c=func(A,n);
      System.out.println(c);
    }
    catch(IOException e){
      System.out.println("error");
    }
  }
  static long func(long[] A,int n){
    long sum=0 ;
    long c1=0,c2=0 ;
    for(int i=0 ; i<n ; i++){
      if(i % 2==0 && sum+A[i]>=0){
        c1+=(sum+A[i]+1);
        sum=-1 ;
      }
      else if(i % 2!=0 && sum+A[i]<=0){
        c1+=1+(-sum-A[i]);
        sum=1 ;
      }
      else {
        sum+=A[i];
      }
    }
    sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(i % 2==0 && sum+A[i]<=0){
        c2+=(-sum-A[i]+1);
        sum=1 ;
      }
      else if(i % 2!=0 && sum+A[i]>=0){
        c2+=1+sum+A[i];
        sum=-1 ;
      }
      else {
        sum+=A[i];
      }
    }
    return Math.min(c1,c2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var str : OclIterator ; str := OclIterator.newOclIterator_String_String(br.readLine(), " ") ;
    var A : Sequence(long) ; A := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := (str.next())->toInteger() )  ;     i := i + 1 ) ; 
    var c : long ; c := func(A, n) ;
    OclFile["System.out"].println(c) ; 
 )   catch (e : IOException) do (     OclFile["System.out"].println("error") )
 );
  static   operation func( A : Sequence(long), n : int) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     var c1 : long ; c1 := 0 ;
    var c2 : long ; c2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0 & sum + A[i+1] >= 0) then (     c1 := c1+((sum + A[i+1] + 1)) ; 
     sum := -1 ) else     if (i mod 2 /= 0 & sum + A[i+1] <= 0) then (     c1 := c1+(1 + (-sum - A[i+1])) ; 
     sum := 1 ) else (     sum := sum+(A[i+1]) ) ;  )  ;     i := i + 1 ) ; 
    sum := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0 & sum + A[i+1] <= 0) then (     c2 := c2+((-sum - A[i+1] + 1)) ; 
     sum := 1 ) else     if (i mod 2 /= 0 & sum + A[i+1] >= 0) then (     c2 := c2+(1 + sum + A[i+1]) ; 
     sum := -1 ) else (     sum := sum+(A[i+1]) ) ;  )  ;     i := i + 1 ) ; 
    return Set{c1, c2}->min() 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=26 ;
  static String countingsort(char[] s){
    int[] count=new int[MAX];
    for(int i=0 ; i<s.length ; i++){
      count[s[i]-'a']++;
    }
    int index=0 ;
    for(int i=0 ; i<MAX ; i++){
      int j=0 ;
      while(j<count[i]){
        s[index++]=(char)(i+'a');
        j++;
      }
    }
    return String.valueOf(s);
  }
  static boolean isPossible(Vector<String>v,String str){
    str=countingsort(str.toCharArray());
    for(int i=0 ; i<v.size()-1 ; i++){
      for(int j=i+1 ; j<v.size(); j++){
        String temp=v.get(i)+v.get(j);
        temp=countingsort(temp.toCharArray());
        if(temp.equals(str)){
          return true ;
        }
      }
    }
    return false ;
  }
  public static void main(String[] args){
    String str="amazon" ;
    String[] arr={
      "fds","oxq","zoa","epw","amn" };
      Vector<String>v=new Vector<String>(Arrays.asList(arr));
      if(isPossible(v,str))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 26;
  static   operation countingsort( s : Sequence(String)) : String
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,MAX)->collect(0) ;
         var i : int ; i := 0 ; while i < s->size() do ( (     count[s[i+1] - ('a')->char2byte()+1] := count[s[i+1] - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < MAX do ( (     var j : int ; j := 0 ;
     while (j < count[i+1]) do (      s[index+1] := (i + 'a')->oclAsType(String)  ; index := index + 1 ; 
     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return ((s) + "") 
 );
  static   operation isPossible( v : Sequence(String), str : String) : boolean
  pre: true
  post: true
  activity: (     str := countingsort(str->characters()) ; 
         var i : int ; i := 0 ; while i < v->size() - 1 do ( (         var j : int ; j := i + 1 ; while j < v->size() do ( (     var temp : String ; temp := v->at(i+1) + v->at(j+1) ;
     temp := countingsort(temp->characters()) ; 
     if (temp = str) then (     return true ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "amazon" ;
     var arr : Sequence(String) ; arr := Sequence{"fds","oxq","zoa","epw","amn"} ;
     var v : Sequence(String) ; v := Sequence{}->union(arr) ;
     if (isPossible(v, str)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int h=sc.nextInt();
    int v=sc.nextInt();
    h=sc.nextInt()-h ;
    v=sc.nextInt()-v ;
    String s=sc.next();
    if(h==0 && v==0){
      System.out.println(0);
      return ;
    }
    int t=-1 ;
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='N'){
        if(v>0){
          v--;
        }
      }
      else if(s.charAt(i)=='E'){
        if(h>0){
          h--;
        }
      }
      else if(s.charAt(i)=='S'){
        if(v<0){
          v++;
        }
      }
      else if(s.charAt(i)=='W'){
        if(h<0){
          h++;
        }
      }
      if(h==0 && v==0){
        t=i+1 ;
        break ;
      }
    }
    System.out.println(t);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var v : int ; v := sc.getCurrent()->toInteger() ;
    h := sc.getCurrent()->toInteger() - h ; 
    v := sc.getCurrent()->toInteger() - v ; 
    var s : String ; s := sc.getCurrent() ;
    if (h = 0 & v = 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var t : int ; t := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = 'N') then (     if (v > 0) then (     v := v - 1 ) else skip ) else     if (s->at(i+1) = 'E') then (     if (h > 0) then (     h := h - 1 ) else skip ) else     if (s->at(i+1) = 'S') then (     if (v < 0) then (     v := v + 1 ) else skip ) else     if (s->at(i+1) = 'W') then (     if (h < 0) then (     h := h + 1 ) else skip ) else skip ; ;  ;  ;  
     if (h = 0 & v = 0) then (     t := i + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(t) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sc.nextInt();
    int sx=sc.nextInt();
    int sy=sc.nextInt();
    int ex=sc.nextInt();
    int ey=sc.nextInt();
    String s=sc.next();
    System.out.println(solve(s,sx,sy,ex,ey));
    sc.close();
  }
  static int solve(String s,int sx,int sy,int ex,int ey){
    int distance=computeDistance(sx,sy,ex,ey);
    int x=sx ;
    int y=sy ;
    for(int i=0 ; i<s.length(); ++i){
      char c=s.charAt(i);
      int nextX=x ;
      int nextY=y ;
      if(c=='E'){
++nextX ;
      }
      else if(c=='S'){
--nextY ;
      }
      else if(c=='W'){
--nextX ;
      }
      else {
++nextY ;
      }
      int nextDistance=computeDistance(nextX,nextY,ex,ey);
      if(nextDistance<distance){
        distance=nextDistance ;
        x=nextX ;
        y=nextY ;
        if(distance==0){
          return i+1 ;
        }
      }
    }
    return-1 ;
  }
  static int computeDistance(int x1,int y1,int x2,int y2){
    return Math.abs(x1-x2)+Math.abs(y1-y2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var sx : int ; sx := sc.getCurrent()->toInteger() ;
    var sy : int ; sy := sc.getCurrent()->toInteger() ;
    var ex : int ; ex := sc.getCurrent()->toInteger() ;
    var ey : int ; ey := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    OclFile["System.out"].println(solve(s, sx, sy, ex, ey)) ; 
    skip ; 
 );
  static   operation solve( s : String, sx : int, sy : int, ex : int, ey : int) : int
  pre: true
  post: true
  activity: (     var distance : int ; distance := computeDistance(sx, sy, ex, ey) ;
     var x : int ; x := sx ;
    var y : int ; y := sy ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var c : String ; c := s->at(i+1) ;
     var nextX : int ; nextX := x ;
    var nextY : int ; nextY := y ;
    if (c = 'E') then (     nextX := nextX + 1 ) else     if (c = 'S') then (     nextY := nextY - 1 ) else     if (c = 'W') then (     nextX := nextX - 1 ) else (     nextY := nextY + 1 ) ;  ;  ;  
    var nextDistance : int ; nextDistance := computeDistance(nextX, nextY, ex, ey) ;
    if (nextDistance < distance) then (     distance := nextDistance ; 
     x := nextX ; 
     y := nextY ; 
     if (distance = 0) then (     return i + 1 ) else skip ) else skip ; 
 )  ;     i := i + 1 ) ; 
    return -1 
 );
  static   operation computeDistance( x1 : int, y1 : int, x2 : int, y2 : int) : int
  pre: true
  post: true
  activity: (     return if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif + if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class D21195 {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int a[]=new int[n+5];
    int b[]=new int[n+5];
    int c[]=new int[n+5];
    for(int i=1 ; i<=n ; i++){
      a[i]=scan.nextInt();
    }
    for(int i=1 ; i<=n ; i++){
      b[i]=scan.nextInt();
      c[b[i] ]=i ;
    }
    if(c[1]>=1){
      int i=0 ;
      for(i=2 ; c[i]==c[1]+i-1 ; i++);
      if(c[i-1]==n){
        int j ;
        for(j=i ; j<=n && c[j]<=(j-i); j++);
        if(j>n){
          System.out.println(n-i+1);
          return ;
        }
      }
    }
    int ans=0 ;
    for(int i=1 ; i<=n ; i++){
      ans=Math.max(ans,c[i]-i+1+n);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class D21195 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 5)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n + 5)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n + 5)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     b[i+1] := scan.getCurrent()->toInteger() ; 
     c[b[i+1]+1] := i )  ;     i := i + 1 ) ; 
    if (c[1+1] >= 1) then (     var i : int ; i := 0 ;
         i := 2 ; while c[i+1] = c[1+1] + i - 1 do (   ;     i := i + 1 ) ; 
     if (c[i - 1+1] = n) then (     var j : int ;
         j := i ; while j <= n & c[j+1] <= (j - i) do (   ;     j := j + 1 ) ; 
     if (j > n) then (     OclFile["System.out"].println(n - i + 1) ; 
     return ) else skip ) else skip ) else skip ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     ans := Set{ans, c[i+1] - i + 1 + n}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class NewClass {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt(),sx=in.nextInt(),sy=in.nextInt(),ex=in.nextInt(),ey=in.nextInt();
    String str=in.next();
    int x=ex-sx,y=ey-sy ;
    int i=0 ;
    for(; i<str.length(); i++){
      char ch=str.charAt(i);
      if(ch=='N' && y>0)y--;
      else if(ch=='S' && y<0)y++;
      else if(ch=='E' && x>0)x--;
      else if(ch=='W' && x<0)x++;
      else if(y==0 && x==0)break ;
    }
    System.out.println((y==0 && x==0)? i :-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var sx : int ; sx := in.getCurrent()->toInteger() ;
    var sy : int ; sy := in.getCurrent()->toInteger() ;
    var ex : int ; ex := in.getCurrent()->toInteger() ;
    var ey : int ; ey := in.getCurrent()->toInteger() ;
    var str : String ; str := in.getCurrent() ;
    var x : int ; x := ex - sx ;
    var y : int ; y := ey - sy ;
    var i : int ; i := 0 ;
      while i < str->size() do ( (     var ch : String ; ch := str->at(i+1) ;
     if (ch = 'N' & y > 0) then     y := y - 1 ; else     if (ch = 'S' & y < 0) then     y := y + 1 else     if (ch = 'E' & x > 0) then     x := x - 1 else     if (ch = 'W' & x < 0) then     x := x + 1 else     if (y = 0 & x = 0) then     break else skip ; ;  ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if (y = 0 & x = 0) then i else -1 endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    long sx=in.nextLong(),sy=in.nextLong(),ex=in.nextLong(),ey=in.nextLong();
    String s=in.next();
    long tim=-1 ;
    for(int i=0 ; i<n ; i++){
      switch(s.charAt(i)){
        case 'S' : if(ey<sy){
          sy-=1 ;
        }
        break ;
        case 'E' : if(sx<ex){
          sx+=1 ;
        }
        break ;
        case 'W' : if(ex<sx){
          sx-=1 ;
        }
        break ;
        case 'N' : if(ey>sy){
          sy+=1 ;
        }
        break ;
        default : break ;
      }
      if(sx==ex && sy==ey){
        tim=i+1 ;
        break ;
      }
    }
    System.out.println(tim);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var sx : long ; sx := in.getCurrent()->toLong() ;
    var sy : long ; sy := in.getCurrent()->toLong() ;
    var ex : long ; ex := in.getCurrent()->toLong() ;
    var ey : long ; ey := in.getCurrent()->toLong() ;
    var s : String ; s := in.getCurrent() ;
    var tim : long ; tim := -1 ;
        var i : int ; i := 0 ; while i < n do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (s->at(i+1)) ; 
       if _switchval = 'S' then
     if (ey < sy) then (     sy := sy-(1) ) else skip ; 
    break 
   else skip ;
       if _switchval = 'E' then
     if (sx < ex) then (     sx := sx+(1) ) else skip ; 
    break 
   else skip ;
       if _switchval = 'W' then
     if (ex < sx) then (     sx := sx-(1) ) else skip ; 
    break 
   else skip ;
       if _switchval = 'N' then
     if (ey > sy) then (     sy := sy+(1) ) else skip ; 
    break 
   else skip ;
       if true then
     break 
   else skip ;
 )
     if (sx = ex & sy = ey) then (     tim := i + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(tim) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class StringEqualizer {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    while(q-->0){
      String s=sc.next();
      String t=sc.next();
      boolean f=false ;
      for(int i=0 ; i<s.length(); i++){
        if(t.contains(s.substring(i,i+1))){
          f=true ;
          break ;
        }
      }
      if(f)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class StringEqualizer {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
         while (q > 0) do (        q := q - 1 ;     skip ; (     var s : String ; s := sc.getCurrent() ;
     var t : String ; t := sc.getCurrent() ;
    var f : boolean ; f := false ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (t->includes(s.subrange(i+1,i + 1))) then (     f := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (f) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class StringsEqualization {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int q=in.nextInt();
    in.nextLine();
    for(int i=0 ; i<q ; i++){
      String s=in.nextLine();
      String t=in.nextLine();
      int l=s.length();
      int[] ar=new int[26+1];
      for(int j=0 ; j<l ; j++){
        char c=s.charAt(j);
        int nu=(c-97);
        ar[nu]++;
      }
      boolean yes=false ;
      l=s.length();
      for(int j=0 ; j<l ; j++){
        char c=t.charAt(j);
        int nu=(c-97);
        if(ar[nu]>0){
          yes=true ;
          break ;
        }
      }
      if(yes)System.out.println("Yes");
      else System.out.println("no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class StringsEqualization {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := in.getCurrent()->toInteger() ;
     skip ; 
         var i : int ; i := 0 ; while i < q do ( (     var s : String ; s := in.nextLine() ;
     var t : String ; t := in.nextLine() ;
    var l : int ; l := s->size() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,26 + 1)->collect(0) ;
        var j : int ; j := 0 ; while j < l do ( (     var c : String ; c := s->at(j+1) ;
     var nu : int ; nu := ((c)->char2byte() - 97) ;
     ar[nu+1] := ar[nu+1] + 1 )  ;     j := j + 1 ) ; 
    var yes : boolean ; yes := false ;
    l := s->size() ; 
        var j : int ; j := 0 ; while j < l do ( (     var c : String ; c := t->at(j+1) ;
     var nu : int ; nu := ((c)->char2byte() - 97) ;
     if (ar[nu+1] > 0) then (     yes := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (yes) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("no") ; ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Scanner ;
public class FileName {
  int number ;
  public FileName(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  public void input(String s){
    LinkedList<Integer>list=new LinkedList<>();
    int count=0 ;
    for(int i=0 ; i<getNumber(); i++){
      if(s.charAt(i)=='x'){
        count++;
        if(i==getNumber()-1){
          list.add(count);
        }
      }
      else {
        list.add(count);
        count=0 ;
      }
    }
    int cResult=0 ;
    for(int l : list){
      if(l>=3){
        cResult+=(l-2);
      }
    }
    System.out.println(cResult);
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    FileName instance=new FileName(number);
    String sName=input.next();
    instance.input(sName);
  }
}
------------------------------------------------------------
OCL File:
---------
 class FileName {
   attribute number : int;
   static operation newFileName( number : int) : FileName
  pre: true
  post: true
  activity:
  ( var self : FileName ;
    self := createFileName();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
   operation input( s : String) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < getNumber() do ( (     if (s->at(i+1) = 'x') then (     count := count + 1 ; 
     if (i = getNumber() - 1) then (     list := list->including(count) ) else skip ) else (     list := list->including(count) ; 
     count := 0 ) )  ;     i := i + 1 ) ; 
    var cResult : int ; cResult := 0 ;
    for (l : list) do ( (     if (l >= 3) then (     cResult := cResult+((l - 2)) ) else skip )  ) ; 
    OclFile["System.out"].println(cResult) ; 
 );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
    var instance : FileName ; instance := FileName.newFileName(number) ;
    var sName : String ; sName := input.getCurrent() ;
    instance.input(sName) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class B1223 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader in=new FastReader();
    int t=1 ;
    t=in.nextInt();
    while(t-->0){
      String S1=in.nextLine();
      String S2=in.nextLine();
      if(S1.length()!=S2.length())System.out.println("NO");
      else {
        HashSet<Integer>hset=new HashSet<>();
        for(int i=0 ; i<S1.length(); i++){
          hset.add((int)S1.charAt(i));
        }
        int flag=0 ;
        for(int i=0 ; i<S2.length(); i++){
          if((hset.contains((int)S2.charAt(i)))){
            System.out.println("YES");
            flag=1 ;
            break ;
          }
        }
        if(flag==0)System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1223 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var t : int ; t := 1 ;
     t := in.nextInt() ; 
         while (t > 0) do (        t := t - 1 ;     skip ; (     var S1 : String ; S1 := in.nextLine() ;
     var S2 : String ; S2 := in.nextLine() ;
     if (S1->size() /= S2->size()) then     OclFile["System.out"].println("NO") ; else (     var hset : Set(int) ; hset := Set{} ;
         var i : int ; i := 0 ; while i < S1->size() do ( (     hset := hset->including(S1->at(i+1)->oclAsType(int)) )  ;     i := i + 1 ) ; 
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < S2->size() do ( (     if ((hset->includes(S2->at(i+1)->oclAsType(int)))) then (     OclFile["System.out"].println("YES") ; 
     flag := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 0) then     OclFile["System.out"].println("NO") ; else skip ; 
 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class StringsEqualization {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    a : while(t-->0){
      String a=scan.next();
      String b=scan.next();
      int n=a.length();
      int[] k=new int[26];
      for(int i=0 ; i<n ; i++){
++k[a.charAt(i)-'a'];
      }
      for(int i=0 ; i<n ; i++){
        if(k[b.charAt(i)-'a']>=1){
          System.out.println("Yes");
          continue a ;
        }
      }
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class StringsEqualization {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : String ; a := scan.getCurrent() ;
     var b : String ; b := scan.getCurrent() ;
    var n : int ; n := a->size() ;
    var k : Sequence(int) ; k := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     k[a->at(i+1) - ('a')->char2byte()+1] := k[a->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (k[b->at(i+1) - ('a')->char2byte()+1] >= 1) then (     OclFile["System.out"].println("Yes") ; 
     continue ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("No") ; 
 ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStreamReader ;
import java.io.IOException ;
import java.util.StringTokenizer ;
import javax.swing.plaf.synth.SynthMenuItemUI ;
import java.io.BufferedReader ;
import java.io.PrintWriter ;
public class Peter {
  public static void main(String[] args)throws IOException {
    PrintWriter pw=new PrintWriter(System.out);
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st_1=new StringTokenizer(br.readLine());
    int d=Integer.parseInt(st_1.nextToken());
    int sumTime=Integer.parseInt(st_1.nextToken());
    int low_sum=0,high_sum=0 ;
    int lo[]=new int[d];
    int hi[]=new int[d];
    for(int i=0 ; i<d ; i++){
      StringTokenizer st=new StringTokenizer(br.readLine());
      int low=Integer.parseInt(st.nextToken());
      low_sum+=low ;
      lo[i]=low ;
      int high=Integer.parseInt(st.nextToken());
      high_sum+=high ;
      hi[i]=high ;
    }
    if(sumTime>high_sum || sumTime<low_sum){
      pw.println("NO");
    }
    else {
      pw.println("YES");
      int diff=sumTime-low_sum ;
      for(int i=0 ; i<d ; i++){
        int one_diff=hi[i]-lo[i];
        if(diff>one_diff){
          pw.print(hi[i]);
          pw.print(" ");
          diff-=one_diff ;
        }
        else if(diff==0){
          pw.print(lo[i]);
          pw.print(" ");
        }
        else {
          pw.print(diff+lo[i]);
          pw.print(" ");
          diff=0 ;
        }
      }
    }
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Peter {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var st    var stOclIterator : OclFile ; stOclIterator := OclIterator.newOclIterator_String(br.readLine()) : OclIterator ; st    var stOclIterator : OclFile ; stOclIterator := OclIterator.newOclIterator_String(br.readLine()) := OclIterator.newOclIterator_String(br.readLine()) ;
    var d : int ; d := (stst(st(stst(std.next() + "")->toInteger().next().next())->toInteger().next() + "")->toInteger().next().next())->toInteger() ;
    var sumTime : int ; sumTime := (stst(st(stst(stsumTime.next() + "")->toInteger().next().next())->toInteger().next() + "")->toInteger().next().next())->toInteger() ;
    var low_sum : int ; low_sum := 0 ;
    var high_sum : int ; high_sum := 0 ;
    var lo : Sequence(int) ; lo := Integer.subrange(1,d)->collect(0) ;
    var hi : Sequence(int) ; hi := Integer.subrange(1,d)->collect(0) ;
        var i : int ; i := 0 ; while i < d do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var low : int ; low := (st.next())->toInteger() ;
    low_sum := low_sum+(low) ; 
    lo[i+1] := low ; 
    var high : int ; high := (st.next())->toInteger() ;
    high_sum := high_sum+(high) ; 
    hi[i+1] := high ; 
 )  ;     i := i + 1 ) ; 
    if (sumTime > high_sum or sumTime < low_sum) then (     skip ) else (     skip ; 
     var diff : int ; diff := sumTime - low_sum ;
         var i : int ; i := 0 ; while i < d do ( (     var one_diff : int ; one_diff := hi[i+1] - lo[i+1] ;
     if (diff > one_diff) then (     skip ; 
     skip ; 
     diff := diff-(one_diff) ) else     if (diff = 0) then (     skip ; 
     skip ) else (     skip ; 
     skip ; 
     diff := 0 ) ;  )  ;     i := i + 1 ) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int sumtime=sc.nextInt();
    int maxtime=0 ;
    int mintime=0 ;
    int a[]=new int[n];
    int b[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
      mintime+=a[i];
      maxtime+=b[i];
    }
    if(sumtime<mintime || sumtime>maxtime){
      System.out.println("NO");
      return ;
    }
    System.out.println("YES");
    for(int i=0 ; i<n ; i++){
      System.out.print(Math.min(b[i],a[i]+sumtime-mintime)+" ");
      sumtime-=Math.min(b[i],a[i]+sumtime-mintime);
      mintime-=a[i];
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var sumtime : int ; sumtime := sc.getCurrent()->toInteger() ;
    var maxtime : int ; maxtime := 0 ;
    var mintime : int ; mintime := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() ; 
     mintime := mintime+(a[i+1]) ; 
     maxtime := maxtime+(b[i+1]) )  ;     i := i + 1 ) ; 
    if (sumtime < mintime or sumtime > maxtime) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    OclFile["System.out"].println("YES") ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(Set{b[i+1], a[i+1] + sumtime - mintime}->min() + " ") ; 
     sumtime := sumtime-(Set{b[i+1], a[i+1] + sumtime - mintime}->min()) ; 
     mintime := mintime-(a[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Cf4A {
  BufferedReader br ;
  StringTokenizer in ;
  PrintWriter out ;
  public String nextToken()throws IOException {
    while(in==null || ! in.hasMoreTokens()){
      in=new StringTokenizer(br.readLine());
    }
    return in.nextToken();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  public static void main(String[] args)throws IOException {
    new Cf4A().run();
  }
  public void solve()throws IOException {
    int d=nextInt();
    int st=nextInt();
    int[] min=new int[d];
    int[] max=new int[d];
    int totalMin=0 ;
    int totalMax=0 ;
    for(int i=0 ; i<d ; i++){
      min[i]=nextInt();
      max[i]=nextInt();
      totalMin+=min[i];
      totalMax+=max[i];
    }
    if(st<totalMin || st>totalMax){
      out.println("NO");
    }
    else {
      while(totalMin<st){
        for(int i=0 ; i<d ; i++){
          if(min[i]<max[i]){
            min[i]++;
            totalMin++;
            break ;
          }
        }
      }
      out.println("YES");
      for(int i=0 ; i<d ; i++){
        out.print(min[i]+" ");
      }
    }
  }
  public void run(){
    try {
      br=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(System.out);
      solve();
      out.close();
    }
    catch(IOException e){
      e.printStackTrace();
      System.exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cf4A {
   attribute br : OclFile;
   attribute in : OclIterator;
   attribute out : OclFile;
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (in = null or not(in.hasNext())) do (     in := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return in.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Cf4A.newCf4A().run() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var d : int ; d := nextInt() ;
     var st : int ; st := nextInt() ;
    var min : Sequence(int) ; min := Integer.subrange(1,d)->collect(0) ;
    var max : Sequence(int) ; max := Integer.subrange(1,d)->collect(0) ;
    var totalMin : int ; totalMin := 0 ;
    var totalMax : int ; totalMax := 0 ;
        var i : int ; i := 0 ; while i < d do ( (     min[i+1] := nextInt() ; 
     max[i+1] := nextInt() ; 
     totalMin := totalMin+(min[i+1]) ; 
     totalMax := totalMax+(max[i+1]) )  ;     i := i + 1 ) ; 
    if (st < totalMin or st > totalMax) then (     skip ) else (     while (totalMin < st) do (         var i : int ; i := 0 ; while i < d do ( (     if (min[i+1] < max[i+1]) then (     min[i+1] := min[i+1] + 1 ; 
     totalMin := totalMin + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ) ; 
     skip ; 
         var i : int ; i := 0 ; while i < d do ( (     skip )  ;     i := i + 1 ) ) ;  
 );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     execute solve() ; 
     skip )   catch (e : IOException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashSet ;
import java.util.List ;
import java.util.PriorityQueue ;
public class Solution {
  static int[] nodeColors ;
  static boolean[] visited ;
  static List<Integer>[] neighbors ;
  static String[][] neighborstring ;
  static List<Integer>[] startIndices ;
  static int[] edgesToPrint ;
  static int mod=998244353 ;
  static int[] parents ;
  static HashSet<Integer>cycleSet ;
  static PriorityQueue<Integer>[] neighborPriority ;
  public static void main(String[] args)throws IOException {
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    int tests=Integer.parseInt(bufferedReader.readLine());
    StringBuilder stringBuilder=new StringBuilder();
    for(int test=0 ; test<tests ; test++){
      String[] inp=bufferedReader.readLine().split(" ");
      long nodes=Long.parseLong(inp[0]);
      long edges=Long.parseLong(inp[1]);
      long constant=Long.parseLong(inp[2]);
      if(edges<nodes-1 || edges>(nodes*(nodes-1))/2){
        stringBuilder.append("NO").append("\n");
        continue ;
      }
      int diameter=0 ;
      if(edges==(nodes*(nodes-1))/2){
        diameter=1 ;
      }
      else {
        diameter=2 ;
      }
      if(nodes==1){
        diameter=0 ;
      }
      if(diameter<constant-1){
        stringBuilder.append("YES").append("\n");
      }
      else {
        stringBuilder.append("NO").append("\n");
      }
    }
    System.out.println(stringBuilder);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute nodeColors : Sequence(int);
  static   attribute visited : Sequence(boolean);
  static   attribute neighbors : Sequence(Sequence(int));
  static   attribute neighborstring : Sequence(Sequence(String));
  static   attribute startIndices : Sequence(Sequence(int));
  static   attribute edgesToPrint : Sequence(int);
  static   attribute mod : int := 998244353;
  static   attribute parents : Sequence(int);
  static   attribute cycleSet : Set(int);
  static   attribute neighborPriority : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tests : int ; tests := (bufferedReader.readLine())->toInteger() ;
    var stringBuilder : String ; stringBuilder := StringLib.newString() ;
        var test : int ; test := 0 ; while test < tests do ( (     var inp : Sequence(String) ; inp := bufferedReader.readLine()->split(" ") ;
     var nodes : long ; nodes := (inp[0+1])->toLong() ;
    var edges : long ; edges := (inp[1+1])->toLong() ;
    var constant : long ; constant := (inp[2+1])->toLong() ;
    if (edges < nodes - 1 or edges > (nodes * (nodes - 1)) / 2) then (     stringBuilder := stringBuilder + StringLib.newString("NO") + StringLib.newString("\n") ; 
     continue ) else skip ; 
    var diameter : int ; diameter := 0 ;
    if (edges = (nodes * (nodes - 1)) / 2) then (     diameter := 1 ) else (     diameter := 2 ) ;  
    if (nodes = 1) then (     diameter := 0 ) else skip ; 
    if (diameter < constant - 1) then (     stringBuilder := stringBuilder + StringLib.newString("YES") + StringLib.newString("\n") ) else (     stringBuilder := stringBuilder + StringLib.newString("NO") + StringLib.newString("\n") ) ;  
 )  ;     test := test + 1 ) ; 
    OclFile["System.out"].println(stringBuilder) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.abs ;
import java.util.*;
class GFG {
  static int solution(Vector<Integer>arr,int x){
    Collections.sort(arr);
    int closestSum=Integer.MAX_VALUE ;
    for(int i=0 ; i<arr.size()-2 ; i++){
      int ptr1=i+1,ptr2=arr.size()-1 ;
      while(ptr1<ptr2){
        int sum=arr.get(i)+arr.get(ptr1)+arr.get(ptr2);
        if(abs(x-sum)<abs(x-closestSum)){
          closestSum=sum ;
        }
        if(sum>x){
          ptr2--;
        }
        else {
          ptr1++;
        }
      }
    }
    return closestSum ;
  }
  public static void main(String[] args){
    Vector arr=new Vector(Arrays.asList(-1,2,1,-4));
    int x=1 ;
    System.out.println(solution(arr,x));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solution( arr : Sequence(int), x : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var closestSum : int ; closestSum := 2147483647 ;
         var i : int ; i := 0 ; while i < arr->size() - 2 do ( (     var ptr1 : int ; ptr1 := i + 1 ;
    var ptr2 : int ; ptr2 := arr->size() - 1 ;
     while (ptr1 < ptr2) do (     var sum : int ; sum := arr->at(i+1) + arr->at(ptr1+1) + arr->at(ptr2+1) ;
     if (abs(x - sum) < abs(x - closestSum)) then (     closestSum := sum ) else skip ; 
     if (sum > x) then (     ptr2 := ptr2 - 1 ) else (     ptr1 := ptr1 + 1 ) ) )  ;     i := i + 1 ) ; 
     return closestSum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence ; arr := Sequence{}->union(Sequence{-1,2,1,-4}) ;
     var x : int ; x := 1 ;
     OclFile["System.out"].println(solution(arr, x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int days=sc.nextInt();
    int sumTime=sc.nextInt();
    int min[]=new int[days];
    int max[]=new int[days];
    int maxTime=0 ;
    int minTime=0 ;
    for(int i=0 ; i<days ; i++){
      min[i]=sc.nextInt();
      minTime+=min[i];
      max[i]=sc.nextInt();
      maxTime+=max[i];
    }
    if(sumTime>maxTime || sumTime<minTime){
      System.out.print("NO");
    }
    else {
      System.out.println("YES");
      sumTime-=minTime ;
      for(int i=0 ; i<days ; i++){
        if(max[i]-min[i]<sumTime){
          System.out.print(max[i]+" ");
          sumTime-=max[i]-min[i];
        }
        else {
          System.out.print((min[i]+sumTime)+" ");
          sumTime=0 ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var days : int ; days := sc.getCurrent()->toInteger() ;
    var sumTime : int ; sumTime := sc.getCurrent()->toInteger() ;
    var min : Sequence(int) ; min := Integer.subrange(1,days)->collect(0) ;
    var max : Sequence(int) ; max := Integer.subrange(1,days)->collect(0) ;
    var maxTime : int ; maxTime := 0 ;
    var minTime : int ; minTime := 0 ;
        var i : int ; i := 0 ; while i < days do ( (     min[i+1] := sc.getCurrent()->toInteger() ; 
     minTime := minTime+(min[i+1]) ; 
     max[i+1] := sc.getCurrent()->toInteger() ; 
     maxTime := maxTime+(max[i+1]) )  ;     i := i + 1 ) ; 
    if (sumTime > maxTime or sumTime < minTime) then (     OclFile["System.out"].print("NO") ) else (     OclFile["System.out"].println("YES") ; 
     sumTime := sumTime-(minTime) ; 
         var i : int ; i := 0 ; while i < days do ( (     if (max[i+1] - min[i+1] < sumTime) then (     OclFile["System.out"].print(max[i+1] + " ") ; 
     sumTime := sumTime-(max[i+1] - min[i+1]) ) else (     OclFile["System.out"].print((min[i+1] + sumTime) + " ") ; 
     sumTime := 0 ) )  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean canBePicked(int digits[],int num){
    int copyDigits[]=digits.clone();
    while(num>0){
      int digit=num % 10 ;
      if(copyDigits[digit]==0)return false ;
      else copyDigits[digit]--;
      num/=10 ;
    }
    return true ;
  }
  static int countAlphabets(int n){
    int i,count=0 ;
    int digits[]=new int[10];
    while(n>0){
      int digit=n % 10 ;
      digits[digit]++;
      n/=10 ;
    }
    for(i='a' ; i<='z' ; i++)if(canBePicked(digits,i))count++;
    for(i='A' ; i<='Z' ; i++)if(canBePicked(digits,i))count++;
    return count ;
  }
  public static void main(String[] args){
    int n=1623455078 ;
    System.out.println(countAlphabets(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation canBePicked( digits : Sequence(int), num : int) : boolean
  pre: true
  post: true
  activity: (     var copyDigits : Sequence(int) ; copyDigits := digits->copy() ;
     while (num > 0) do (     var digit : int ; digit := num mod 10 ;
     if (copyDigits[digit+1] = 0) then     return false else     copyDigits[digit+1] := copyDigits[digit+1] - 1 ; ;  
     num := num/(10) ) ; 
     return true );
  static   operation countAlphabets( n : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var count : int ; count := 0 ;
     var digits : Sequence(int) ; digits := Integer.subrange(1,10)->collect(0) ;
    while (n > 0) do (     var digit : int ; digit := n mod 10 ;
     digits[digit+1] := digits[digit+1] + 1 ; 
     n := n/(10) ) ; 
        i := 'a' ; while i <= 'z' do (     if (canBePicked(digits, i)) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
        i := 'A' ; while i <= 'Z' do (     if (canBePicked(digits, i)) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1623455078 ;
     OclFile["System.out"].println(countAlphabets(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    int[] ar=new int[n];
    for(int i=0 ; i<n ; i++)ar[i]=sc.nextInt();
    long minA=0 ;
    long sumA=0 ;
    for(int i=0 ; i<n ; i++){
      sumA+=ar[i];
      if(i % 2==0){
        if(sumA<=0){
          minA+=Math.abs(sumA)+1 ;
          sumA+=Math.abs(sumA)+1 ;
        }
      }
      else {
        if(sumA>=0){
          minA+=Math.abs(sumA)+1 ;
          sumA-=Math.abs(sumA)+1 ;
        }
      }
    }
    long minB=0 ;
    long sumB=0 ;
    for(int i=0 ; i<n ; i++){
      sumB+=ar[i];
      if(i % 2!=0){
        if(sumB<=0){
          minB+=Math.abs(sumB)+1 ;
          sumB+=Math.abs(sumB)+1 ;
        }
      }
      else {
        if(sumB>=0){
          minB+=Math.abs(sumB)+1 ;
          sumB-=Math.abs(sumB)+1 ;
        }
      }
    }
    System.out.println(Math.min(minA,minB));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     ar[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var minA : long ; minA := 0 ;
    var sumA : long ; sumA := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sumA := sumA+(ar[i+1]) ; 
     if (i mod 2 = 0) then (     if (sumA <= 0) then (     minA := minA+(if sumA < 0 then -(sumA) else sumA endif + 1) ; 
     sumA := sumA+(if sumA < 0 then -(sumA) else sumA endif + 1) ) else skip ) else (     if (sumA >= 0) then (     minA := minA+(if sumA < 0 then -(sumA) else sumA endif + 1) ; 
     sumA := sumA-(if sumA < 0 then -(sumA) else sumA endif + 1) ) else skip ) )  ;     i := i + 1 ) ; 
    var minB : long ; minB := 0 ;
    var sumB : long ; sumB := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sumB := sumB+(ar[i+1]) ; 
     if (i mod 2 /= 0) then (     if (sumB <= 0) then (     minB := minB+(if sumB < 0 then -(sumB) else sumB endif + 1) ; 
     sumB := sumB+(if sumB < 0 then -(sumB) else sumB endif + 1) ) else skip ) else (     if (sumB >= 0) then (     minB := minB+(if sumB < 0 then -(sumB) else sumB endif + 1) ; 
     sumB := sumB-(if sumB < 0 then -(sumB) else sumB endif + 1) ) else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{minA, minB}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void getNumbers(int a[],int n){
    HashMap<Integer,Integer>freq=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++)if(freq.containsKey(a[i])){
      freq.put(a[i],freq.get(a[i])+1);
    }
    else {
      freq.put(a[i],1);
    }
    int maxi1=Arrays.stream(a).max().getAsInt();
    for(int i=1 ; i*i<=maxi1 ; i++){
      if(maxi1 % i==0 && freq.containsKey(i)&& freq.get(i)!=0){
        freq.put(i,freq.get(i)-1);
        if(i!=(maxi1/i)&& freq.containsKey(maxi1/i)&& freq.get(maxi1/i)!=0)freq.put(maxi1/i,freq.get(maxi1/i)-1);
      }
    }
    int maxi2=-1 ;
    for(int i=0 ; i<n ; i++){
      if(freq.get(a[i])!=0)maxi2=Math.max(maxi2,a[i]);
    }
    System.out.print(maxi1+" "+maxi2);
  }
  public static void main(String[] args){
    int a[]={
      10,2,8,1,2,4,1,20,4,5 };
      int n=a.length ;
      getNumbers(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getNumbers( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var freq : Map(int,int) ; freq := Map{} ;
         var i : int ; i := 0 ; while i < n do (     if (freq->keys()->includes(a[i+1])) then (     freq := freq->union(Map{a[i+1] |-> freq->at(a[i+1]) + 1}) ) else (     freq := freq->union(Map{a[i+1] |-> 1}) ) ;   ;     i := i + 1 ) ; 
    var maxi1 : int ; maxi1 := stream(a).max().getAsInt() ;
        var i : int ; i := 1 ; while i * i <= maxi1 do ( (     if (maxi1 mod i = 0 & freq->keys()->includes(i) & freq->at(i) /= 0) then (     freq := freq->union(Map{i |-> freq->at(i) - 1}) ; 
     if (i /= (maxi1 / i) & freq->keys()->includes(maxi1 / i) & freq->at(maxi1 / i) /= 0) then     freq := freq->union(Map{maxi1 / i |-> freq->at(maxi1 / i) - 1}) ; else skip ) else skip )  ;     i := i + 1 ) ; 
    var maxi2 : int ; maxi2 := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (freq->at(a[i+1]) /= 0) then     maxi2 := Set{maxi2, a[i+1]}->max() ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(maxi1 + " " + maxi2) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{10,2,8,1,2,4,1,20,4,5} ;
     var n : int ; n := a->size() ;
     execute getNumbers(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int N=s.nextInt();
    int K=s.nextInt();
    int sum=0 ;
    int xs[]=new int[N];
    for(int i=0 ; i<N ; i++){
      xs[i]=s.nextInt();
    }
    for(int k=0 ; k<N ; k++){
      if(Math.abs(xs[k])>Math.abs(K-xs[k])){
        sum+=2*Math.abs(K-xs[k]);
      }
      else {
        sum+=2*xs[k];
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := s.getCurrent()->toInteger() ;
    var K : int ; K := s.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var xs : Sequence(int) ; xs := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     xs[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < N do ( (     if (if xs[k+1] < 0 then -(xs[k+1]) else xs[k+1] endif > if K - xs[k+1] < 0 then -(K - xs[k+1]) else K - xs[k+1] endif) then (     sum := sum+(2 * if K - xs[k+1] < 0 then -(K - xs[k+1]) else K - xs[k+1] endif) ) else (     sum := sum+(2 * xs[k+1]) ) )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      int n=Integer.parseInt(br.readLine());
      int k=Integer.parseInt(br.readLine());
      String[] tmp=br.readLine().split(" ");
      int distance=0 ;
      for(String t : tmp){
        int x=Integer.parseInt(t);
        if(k-x<x){
          distance+=(k-x)*2 ;
        }
        else {
          distance+=x*2 ;
        }
      }
      System.out.println(distance);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var n : int ; n := (br.readLine())->toInteger() ;
     var k : int ; k := (br.readLine())->toInteger() ;
    var tmp : Sequence(String) ; tmp := br.readLine()->split(" ") ;
    var distance : int ; distance := 0 ;
    for (t : tmp) do ( (     var x : int ; x := (t)->toInteger() ;
     if (k - x < x) then (     distance := distance+((k - x) * 2) ) else (     distance := distance+(x * 2) ) )  ) ; 
    OclFile["System.out"].println(distance) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    try {
      InputStreamReader isr=new InputStreamReader(System.in);
      BufferedReader br=new BufferedReader(isr);
      int n=Integer.parseInt(br.readLine());
      int k=Integer.parseInt(br.readLine());
      int sum=0 ;
      String str[]=br.readLine().split(" ");
      for(int i=0 ; i<n ; i++){
        int x=Integer.parseInt(str[i]);
        int tmp=Math.abs(x-k);
        if(x<tmp){
          sum+=x*2 ;
        }
        else {
          sum+=tmp*2 ;
        }
      }
      System.out.println(sum);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var k : int ; k := (br.readLine())->toInteger() ;
    var sum : int ; sum := 0 ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := (str[i+1])->toInteger() ;
     var tmp : int ; tmp := if x - k < 0 then -(x - k) else x - k endif ;
     if (x < tmp) then (     sum := sum+(x * 2) ) else (     sum := sum+(tmp * 2) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
class Main {
  public static void main(String[] $){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt(),k=s.nextInt();
    System.out.println(IntStream.range(0,n).map(o->s.nextInt()).map(o->Math.min(o,k-o)).sum()*2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var k : int ; k := s.getCurrent()->toInteger() ;
     OclFile["System.out"].println(Integer.subrange(0, n-1)->collect( _x1 | (lambda o : OclAny in s.getCurrent()->toInteger())->apply(_x1) )->collect( _x1 | (lambda o : OclAny in Set{o, k - o}->min())->apply(_x1) )->sum() * 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main m=new Main();
    m.answer();
  }
  private Scanner scan=new Scanner(System.in);
  private final int N ;
  private final int K ;
  private final int[] x ;
  public Main(){
    N=Integer.parseInt(scan.next());
    K=Integer.parseInt(scan.next());
    x=new int[N];
    for(int i=0 ; i<N ; i++){
      x[i]=Integer.parseInt(scan.next());
    }
    scan.close();
  }
  public final void answer(){
    int ans=Arrays.stream(x).map(x->2*Integer.min(x,K-x)).sum();
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.answer() );
   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute N : int;
   attribute K : int;
   attribute x : Sequence(int);
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     N := (scan.getCurrent())->toInteger() ; 
     K := (scan.getCurrent())->toInteger() ; 
    x := Integer.subrange(1,N)->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     x[i+1] := (scan.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation answer() : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := stream(x)->collect( _x1 | (lambda x : OclAny in 2 * Set{x, K - x}->min())->apply(_x1) )->sum() ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.text.DecimalFormat ;
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;
import java.util.stream.Stream ;
public class Main {
  static FastScanner fs=new FastScanner();
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int Int(){
      return Integer.parseInt(next());
    }
    long Long(){
      return Long.parseLong(next());
    }
    String Str(){
      return next();
    }
  }
  public static void main(String[] args)throws java.lang.Exception {
    PrintWriter out=new PrintWriter(System.out);
    int T=1 ;
    for(int t=0 ; t<T ; t++){
      String a=Str();
      String b=Str();
      Solution sol=new Solution();
      sol.solution(out,a,b);
    }
    out.flush();
  }
  public static int Int(){
    return fs.Int();
  }
  public static long Long(){
    return fs.Long();
  }
  public static String Str(){
    return fs.Str();
  }
}
class Solution {
  public void solution(PrintWriter out,String s,String t){
    int cnt=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='1')cnt++;
    }
    if(cnt % 2==1){
      cnt++;
    }
    for(int i=0 ; i<t.length(); i++){
      if(t.charAt(i)=='1')cnt--;
    }
    if(cnt<0){
      out.println("NO");
    }
    else {
      out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute fs : FastScanner := FastScanner.newFastScanner();
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation Int() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation Long() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation Str() : String
  pre: true
  post: true
  activity: (     return next() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var T : int ; T := 1 ;
         var t : int ; t := 0 ; while t < T do ( (     var a : String ; a := Str() ;
     var b : String ; b := Str() ;
     var sol : Solution ; sol := Solution.newSolution() ;
     sol.solution(out, a, b) )  ;     t := t + 1 ) ; 
     skip );
  static   operation Int() : int
  pre: true
  post: true
  activity: (     return fs.Int() );
  static   operation Long() : long
  pre: true
  post: true
  activity: (     return fs.Long() );
  static   operation Str() : String
  pre: true
  post: true
  activity: (     return fs.Str() );
}
class Solution {
   operation solution( out : OclFile, s : String, t : String) : void
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '1') then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (cnt mod 2 = 1) then (     cnt := cnt + 1 ) else skip ; 
        var i : int ; i := 0 ; while i < t->size() do ( (     if (t->at(i+1) = '1') then     cnt := cnt - 1 ; else skip )  ;     i := i + 1 ) ; 
    if (cnt < 0) then (     skip ) else (     skip ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class codeforces {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    for(int z=0 ; z<t ; z++){
      int n=s.nextInt();
      int c=s.nextInt();
      int arr[]=new int[n];
      int arr1[]=new int[101];
      for(int i=0 ; i<n ; i++){
        arr[i]=s.nextInt();
        arr1[arr[i] ]++;
      }
      int ans=0 ;
      for(int i=1 ; i<101 ; i++){
        if(arr1[i]>c)ans=ans+c ;
        else ans=ans+arr1[i];
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         var z : int ; z := 0 ; while z < t do ( (     var n : int ; n := s.getCurrent()->toInteger() ;
     var c : int ; c := s.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,101)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() ; 
     arr1[arr[i+1]+1] := arr1[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < 101 do ( (     if (arr1[i+1] > c) then     ans := ans + c ; else     ans := ans + arr1[i+1] ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     z := z + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class P297A {
  private static void solve(){
    char[] c1=next().toCharArray();
    char[] c2=next().toCharArray();
    int cnt1=0 ;
    for(int i=0 ; i<c1.length ; i++){
      if(c1[i]=='1')cnt1++;
    }
    int cnt2=0 ;
    for(int i=0 ; i<c2.length ; i++){
      if(c2[i]=='1')cnt2++;
    }
    if((cnt1 % 2==0 && cnt2>cnt1)||(cnt1 % 2!=0 && cnt2>cnt1+1)){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
    }
  }
  private static void run(){
    br=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(System.out);
    solve();
    out.close();
  }
  private static StringTokenizer st ;
  private static BufferedReader br ;
  private static PrintWriter out ;
  private static String next(){
    while(st==null || ! st.hasMoreElements()){
      String s ;
      try {
        s=br.readLine();
      }
      catch(IOException e){
        return null ;
      }
      st=new StringTokenizer(s);
    }
    return st.nextToken();
  }
  private static int nextInt(){
    return Integer.parseInt(next());
  }
  private static long nextLong(){
    return Long.parseLong(next());
  }
  public static void main(String[] args){
    run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class P297A {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var c1 : Sequence(String) ; c1 := next()->characters() ;
     var c2 : Sequence(String) ; c2 := next()->characters() ;
    var cnt1 : int ; cnt1 := 0 ;
        var i : int ; i := 0 ; while i < c1->size() do ( (     if (c1[i+1] = '1') then     cnt1 := cnt1 + 1 ; else skip )  ;     i := i + 1 ) ; 
    var cnt2 : int ; cnt2 := 0 ;
        var i : int ; i := 0 ; while i < c2->size() do ( (     if (c2[i+1] = '1') then     cnt2 := cnt2 + 1 ; else skip )  ;     i := i + 1 ) ; 
    if ((cnt1 mod 2 = 0 & cnt2 > cnt1) or (cnt1 mod 2 /= 0 & cnt2 > cnt1 + 1)) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 );
  static   operation run() : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     execute solve() ; 
     out.close() );
  static   attribute st : OclIterator;
  static   attribute br : OclFile;
  static   attribute out : OclFile;
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     var s : String ;
     try (     s := br.readLine() )   catch (e : IOException) do (     return null )
     st := OclIterator.newOclIterator_String(s) ) ; 
     return st.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      long[] a=new long[n];
      IntStream.range(0,n).forEach(i->a[i]=scanner.nextLong());
      int[] sum1=new int[n],sum2=new int[n];
      Arrays.fill(sum1,1);
      Arrays.fill(sum2,-1);
      IntStream.range(0,n/2).forEach(i->{
        sum1[2*i+1]=-1 ;
        sum2[2*i+1]=1 ;
      }
);
      System.out.println(Math.min(getResult(a,sum1),getResult(a,sum2)));
    }
  }
  private static long getResult(final long[] a,final int[] sum){
    int n=a.length ;
    long now=0,result=0 ;
    for(int i=0 ; i<n ; i++){
      now+=a[i];
      if(sum[i]*now<=0){
        result+=Math.abs(sum[i]-now);
        now=sum[i];
      }
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    for i : Integer.subrange(0, n-1) do
    (    a[i+1] := scanner.getCurrent()->toLong()) ; 
    var sum1 : Sequence(int) ; sum1 := Integer.subrange(1,n)->collect(0) ;
    var sum2 : Sequence(int) ; sum2 := Integer.subrange(1,n)->collect(0) ;
    sum1 := sum1->collect(1) ; 
    sum2 := sum2->collect(-1) ; 
    for i : Integer.subrange(0, n / 2-1) do
    (    skip) ; 
    OclFile["System.out"].println(Set{getResult(a, sum1), getResult(a, sum2)}->min()) ; 
 ))  );
  static   operation getResult( a : Sequence(long), sum : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() ;
     var now : long ; now := 0 ;
    var result : long ; result := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     now := now+(a[i+1]) ; 
     if (sum[i+1] * now <= 0) then (     result := result+(if sum[i+1] - now < 0 then -(sum[i+1] - now) else sum[i+1] - now endif) ; 
     now := sum[i+1] ) else skip )  ;     i := i + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Odd {
  public static int oddSum(int n){
    return(n*n);
  }
  public static void main(String[] args){
    int n=20 ;
    System.out.println(" Sum of first "+n+" Odd Numbers is: "+oddSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Odd {
  static   operation oddSum( n : int) : int
  pre: true
  post: true
  activity: (     return (n * n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 20 ;
     OclFile["System.out"].println(" Sum of first " + n + " Odd Numbers is: " + oddSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int n=4 ;
  static int count(int arr[][]){
    int diag1=0,diag2=0 ;
    int row=0,col=0,count=0 ;
    for(int i=0,j=n-1 ; i<n ; i++,j--){
      diag1+=arr[i][i];
      diag2+=arr[i][j];
    }
    for(int i=0 ; i<n ; i++){
      row=0 ;
      col=0 ;
      for(int j=0 ; j<n ; j++){
        row=row+arr[i][j];
      }
      for(int j=0 ; j<n ; j++){
        col=col+arr[j][i];
      }
      if((row==diag1)||(row==diag2))count++;
      if((col==diag1)||(col==diag2))count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[][]={
      {
        7,2,3,5 },{
          4,5,6,3 },{
            7,9,10,12 },{
              1,5,4,3 }
            };
            System.out.println(count(arr));
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute n : int := 4;
  static   operation count( arr : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var diag1 : int ; diag1 := 0 ;
    var diag2 : int ; diag2 := 0 ;
     var row : int ; row := 0 ;
    var col : int ; col := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ;
    var j : int ; j := n - 1 ; while i < n do ( (     diag1 := diag1+(arr[i+1][i+1]) ; 
     diag2 := diag2+(arr[i+1][j+1]) )  ;     i := i + 1 ;     j := j - 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     row := 0 ; 
     col := 0 ; 
        var j : int ; j := 0 ; while j < n do ( (     row := row + arr[i+1][j+1] )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     col := col + arr[j+1][i+1] )  ;     j := j + 1 ) ; 
    if ((row = diag1) or (row = diag2)) then     count := count + 1 ; else skip ; 
    if ((col = diag1) or (col = diag2)) then     count := count + 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{7,2,3,5},Sequence{4,5,6,3},Sequence{7,9,10,12},Sequence{1,5,4,3}} ;
     OclFile["System.out"].println(count(arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=32 ;
  static int countSetBits(int n){
    int count=0 ;
    while(n>0){
      n &=(n-1);
      count++;
    }
    return count ;
  }
  static int pairs(int arr[],int n,int k){
    int count=0 ;
    int[] f=new int[MAX+1];
    for(int i=0 ; i<n ; i++)f[countSetBits(arr[i])]++;
    for(int i=0 ; i<=MAX ; i++){
      for(int j=i ; j<=MAX ; j++){
        if(i+j==k){
          if(i==j)count+=((f[i]*(f[i]-1))/2);
          else count+=(f[i]*f[j]);
        }
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5 };
      int n=arr.length ;
      int k=4 ;
      System.out.println(pairs(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 32;
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     n := MathLib.bitwiseAnd(n, (n - 1)) ; 
     count := count + 1 ) ; 
     return count );
  static   operation pairs( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var f : Sequence(int) ; f := Integer.subrange(1,MAX + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     f[countSetBits(arr[i+1])+1] := f[countSetBits(arr[i+1])+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= MAX do ( (         var j : int ; j := i ; while j <= MAX do ( (     if (i + j = k) then (     if (i = j) then     count := count+(((f[i+1] * (f[i+1] - 1)) / 2)) ; else     count := count+((f[i+1] * f[j+1])) ; ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 4 ;
     OclFile["System.out"].println(pairs(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    char[] s=in.next().toCharArray();
    Arrays.sort(s);
    for(char c : s)pw.print(c);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := in.getCurrent()->characters() ;
    s := s->sort() ; 
    for (c : s) do (     skip ;  ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args)throws IOException,InterruptedException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(reader.readLine());
    String s=reader.readLine();
    char[] array=s.toCharArray();
    Arrays.sort(array);
    System.out.println(new String(array));
    sc.close();
    writer.flush();
    writer.close();
    reader.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := (reader.readLine())->toInteger() ;
    var s : String ; s := reader.readLine() ;
    var array : Sequence(String) ; array := s->characters() ;
    array := array->sort() ; 
    OclFile["System.out"].println(StringLib.newString(array)) ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class palindrome {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    char[] c=s.toCharArray();
    Arrays.sort(c);
    System.out.println(toString(c));
  }
  public static String toString(char[] a){
    String string=new String(a);
    return string ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class palindrome {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var c : Sequence(String) ; c := s->characters() ;
    c := c->sort() ; 
    OclFile["System.out"].println(toString(c)) ; 
 );
  static   operation toString( a : Sequence(String)) : String
  pre: true
  post: true
  activity: (     var string : String ; string := StringLib.newString(a) ;
     return string );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class CF1064_D2_C {
  public static void main(String[] args){
    FastScanner scanner=new FastScanner();
    int n=scanner.nextInt();
    char[] arr=scanner.next().toCharArray();
    Arrays.sort(arr);
    System.out.println(String.valueOf(arr));
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      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 ;
    }
    int[] nextArray(int n){
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=nextInt();
      }
      return arr ;
    }
    Integer[] nextArray(int n,boolean object){
      Integer[] arr=new Integer[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=nextInt();
      }
      return arr ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF1064_D2_C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : FastScanner ; scanner := FastScanner.newFastScanner() ;
     var n : int ; n := scanner.nextInt() ;
    var arr : Sequence(String) ; arr := scanner.next()->characters() ;
    arr := arr->sort() ; 
    OclFile["System.out"].println((arr)->sum() ) ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return arr );
   operation nextArray( n : int, object : boolean) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return arr );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class AvgHeigth {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      List<Integer>yo=new ArrayList<>();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
        if((arr[i] & 1)==1){
          yo.add(arr[i]);
        }
      }
      for(int i=0 ; i<n ; i++){
        if((arr[i] & 1)==0){
          yo.add(arr[i]);
        }
      }
      for(int x : yo){
        System.out.print(x+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AvgHeigth {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var yo : Sequence(int) ; yo := Sequence{} ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if ((arr[i+1] & 1) = 1) then (     yo := yo->including(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if ((arr[i+1] & 1) = 0) then (     yo := yo->including(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    for (x : yo) do ( (     OclFile["System.out"].print(x + " ") )  ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int t=cin.nextInt(),k,i ;
    for(k=0 ; k<t ; k++){
      int n=cin.nextInt(),a[]=new int[n];
      int j1=0,j2=n-1 ;
      for(i=0 ; i<n ; i++){
        int x=cin.nextInt();
        if(x % 2==0)a[j1++]=x ;
        else a[j2--]=x ;
      }
      for(i=0 ; i<n ; i++)System.out.print(a[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := cin.getCurrent()->toInteger() ;
    var k : int ;
    var i : int ;
         k := 0 ; while k < t do ( (     var n : int ; n := cin.getCurrent()->toInteger() ;
    var a : Sequence(void) ; a := Integer.subrange(1,n)->collect(0) ;
     var j1 : int ; j1 := 0 ;
    var j2 : int ; j2 := n - 1 ;
         i := 0 ; while i < n do ( (     var x : int ; x := cin.getCurrent()->toInteger() ;
     if (x mod 2 = 0) then      a[j1+1] := x  ; j1 := j1 + 1 ; else      a[j2+1] := x  ; j2 := j2 - 1 ; )  ;     i := i + 1 ) ; 
         i := 0 ; while i < n do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) )  ;     k := k + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Tttest {
  public static int fun(int[] arr,int b){
    HashMap<Integer,Integer>hm=new LinkedHashMap<>();
    for(int i=0 ; i<arr.length ; i++){
      if(hm.containsKey(arr[i])){
        int of=hm.get(arr[i]);
        of++;
        hm.put(arr[i],of);
        continue ;
      }
      hm.put(arr[i],1);
    }
    int ans=0 ;
    for(Integer i : hm.keySet()){
      ans+=Math.min(b,hm.get(i));
    }
    return ans ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int[] arr=new int[a];
      for(int i=0 ; i<arr.length ; i++){
        arr[i]=sc.nextInt();
      }
      System.out.println(fun(arr,b));
      t--;
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Tttest {
  static   operation fun( arr : Sequence(int), b : int) : int
  pre: true
  post: true
  activity: (     var hm : Map(int,int) ; hm := Map{} ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     if (hm->keys()->includes(arr[i+1])) then (     var of : int ; of := hm->at(arr[i+1]) ;
     of := of + 1 ; 
     hm := hm->union(Map{arr[i+1] |-> of}) ; 
     continue ) else skip ; 
     hm := hm->union(Map{arr[i+1] |-> 1}) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (i : hm->keys()) do ( (     ans := ans+(Set{b, hm->at(i)}->min()) )  ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,a)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(fun(arr, b)) ; 
    t := t - 1 ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long a[]=new long[(int)n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
    }
    long sum=a[0];
    long ans1=0 ;
    if(sum==0){
      sum=1 ;
      ans1++;
    }
    for(int i=1 ; i<n ; i++){
      if(sum>0){
        if(sum+a[i]>=0){
          ans1+=sum+a[i]+1 ;
          sum=-1 ;
        }
        else {
          sum=sum+a[i];
        }
      }
      else {
        if(sum+a[i]<=0){
          ans1+=Math.abs(a[i]+sum)+1 ;
          sum=1 ;
        }
        else {
          sum=sum+a[i];
        }
      }
    }
    long ans2=Math.abs(a[0])+1 ;
    if(a[0]>=0){
      sum=-1 ;
    }
    else if(a[0]<0){
      sum=1 ;
    }
    for(int i=1 ; i<n ; i++){
      if(sum>0){
        if(sum+a[i]>=0){
          ans2+=sum+a[i]+1 ;
          sum=-1 ;
        }
        else {
          sum=sum+a[i];
        }
      }
      else {
        if(sum+a[i]<=0){
          ans2+=Math.abs(a[i]+sum)+1 ;
          sum=1 ;
        }
        else {
          sum=sum+a[i];
        }
      }
    }
    System.out.println(Math.min(ans1,ans2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n->oclAsType(int))->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := a[0+1] ;
    var ans1 : long ; ans1 := 0 ;
    if (sum = 0) then (     sum := 1 ; 
     ans1 := ans1 + 1 ) else skip ; 
        var i : int ; i := 1 ; while i < n do ( (     if (sum > 0) then (     if (sum + a[i+1] >= 0) then (     ans1 := ans1+(sum + a[i+1] + 1) ; 
     sum := -1 ) else (     sum := sum + a[i+1] ) ) else (     if (sum + a[i+1] <= 0) then (     ans1 := ans1+(if a[i+1] + sum < 0 then -(a[i+1] + sum) else a[i+1] + sum endif + 1) ; 
     sum := 1 ) else (     sum := sum + a[i+1] ) ) )  ;     i := i + 1 ) ; 
    var ans2 : long ; ans2 := if a[0+1] < 0 then -(a[0+1]) else a[0+1] endif + 1 ;
    if (a[0+1] >= 0) then (     sum := -1 ) else     if (a[0+1] < 0) then (     sum := 1 ) else skip ; ;  
        var i : int ; i := 1 ; while i < n do ( (     if (sum > 0) then (     if (sum + a[i+1] >= 0) then (     ans2 := ans2+(sum + a[i+1] + 1) ; 
     sum := -1 ) else (     sum := sum + a[i+1] ) ) else (     if (sum + a[i+1] <= 0) then (     ans2 := ans2+(if a[i+1] + sum < 0 then -(a[i+1] + sum) else a[i+1] + sum endif + 1) ; 
     sum := 1 ) else (     sum := sum + a[i+1] ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{ans1, ans2}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class A1509 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      int n=scanner.nextInt();
      List<Integer>oddList=new ArrayList<Integer>();
      List<Integer>evenList=new ArrayList<Integer>();
      while(n-->0){
        int x=scanner.nextInt();
        if(x % 2==0){
          evenList.add(x);
        }
        else {
          oddList.add(x);
        }
      }
      for(int i : oddList)System.out.print(i+" ");
      for(int i : evenList)System.out.print(i+" ");
      System.out.println();
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1509 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var oddList : Sequence(int) ; oddList := Sequence{} ;
    var evenList : Sequence(int) ; evenList := Sequence{} ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var x : int ; x := scanner.getCurrent()->toInteger() ;
     if (x mod 2 = 0) then (     evenList := evenList->including(x) ) else (     oddList := oddList->including(x) ) ) ;  ) ;  
    for (i : oddList) do (     OclFile["System.out"].print(i + " ") ;  ) ; 
    for (i : evenList) do (     OclFile["System.out"].print(i + " ") ;  ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test276 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int a[]=new int[n];
      int b[]=new int[n];
      int c[]=new int[n];
      int e=0,o=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
        if(a[i] % 2==0){
          b[e++]=a[i];
        }
        else {
          c[o++]=a[i];
        }
      }
      for(int i=0 ; i<e ; i++){
        System.out.print(b[i]+" ");
      }
      for(int i=0 ; i<o ; i++){
        System.out.print(c[i]+" ");
      }
      System.out.println();
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test276 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    var e : int ; e := 0 ;
    var o : int ; o := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     if (a[i+1] mod 2 = 0) then (      b[e+1] := a[i+1]  ; e := e + 1 ) else (      c[o+1] := a[i+1]  ; o := o + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < e do ( (     OclFile["System.out"].print(b[i+1] + " ") )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < o do ( (     OclFile["System.out"].print(c[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication68 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num1=sc.nextInt();
    int num2=sc.nextInt();
    int r1=0 ;
    int r2=0 ;
    int r3=0 ;
    for(int i=1 ; i<7 ; i++){
      if(Math.abs(num1-i)>Math.abs(num2-i)){
        r1++;
      }
      else if(Math.abs(num1-i)<Math.abs(num2-i)){
        r3++;
      }
      else {
        r2++;
      }
    }
    System.out.println(r3+" "+r2+" "+r1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication68 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num1 : int ; num1 := sc.getCurrent()->toInteger() ;
    var num2 : int ; num2 := sc.getCurrent()->toInteger() ;
    var r1 : int ; r1 := 0 ;
    var r2 : int ; r2 := 0 ;
    var r3 : int ; r3 := 0 ;
        var i : int ; i := 1 ; while i < 7 do ( (     if (if num1 - i < 0 then -(num1 - i) else num1 - i endif > if num2 - i < 0 then -(num2 - i) else num2 - i endif) then (     r1 := r1 + 1 ) else     if (if num1 - i < 0 then -(num1 - i) else num1 - i endif < if num2 - i < 0 then -(num2 - i) else num2 - i endif) then (     r3 := r3 + 1 ) else (     r2 := r2 + 1 ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(r3 + " " + r2 + " " + r1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int win=0 ;
    int draw=0 ;
    int lose=0 ;
    for(int j=1 ; j<=6 ; j++){
      if(Math.abs(j-a)==Math.abs(j-b))draw++;
      else {
        if(Math.abs(j-a)<Math.abs(j-b))win++;
        else lose++;
      }
    }
    System.out.println(win);
    System.out.println(draw);
    System.out.println(lose);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var win : int ; win := 0 ;
    var draw : int ; draw := 0 ;
    var lose : int ; lose := 0 ;
        var j : int ; j := 1 ; while j <= 6 do ( (     if (if j - a < 0 then -(j - a) else j - a endif = if j - b < 0 then -(j - b) else j - b endif) then     draw := draw + 1 ; else (     if (if j - a < 0 then -(j - a) else j - a endif < if j - b < 0 then -(j - b) else j - b endif) then     win := win + 1 ; else     lose := lose + 1 ; ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(win) ; 
    OclFile["System.out"].println(draw) ; 
    OclFile["System.out"].println(lose) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  public static void main(String[] args){
    new A().solve();
  }
  Scanner in ;
  private void solve(){
    in=new Scanner(System.in);
    int a=in.nextInt();
    int b=in.nextInt();
    int aWins=0 ;
    int bWins=0 ;
    int draw=0 ;
    for(int i=1 ; i<7 ; i++){
      int fromA=Math.abs(i-a);
      int fromB=Math.abs(i-b);
      if(fromA<fromB){
++aWins ;
      }
      else if(fromA>fromB){
++bWins ;
      }
      else {
++draw ;
      }
    }
    System.out.println(aWins+" "+draw+" "+bWins);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     A.newA().solve() );
   attribute in : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var aWins : int ; aWins := 0 ;
    var bWins : int ; bWins := 0 ;
    var draw : int ; draw := 0 ;
        var i : int ; i := 1 ; while i < 7 do ( (     var fromA : int ; fromA := if i - a < 0 then -(i - a) else i - a endif ;
     var fromB : int ; fromB := if i - b < 0 then -(i - b) else i - b endif ;
     if (fromA < fromB) then (     aWins := aWins + 1 ) else     if (fromA > fromB) then (     bWins := bWins + 1 ) else (     draw := draw + 1 ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(aWins + " " + draw + " " + bWins) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _378A_PlayingWithDice {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int a=input.nextInt();
    int b=input.nextInt();
    int first=0 ;
    int second=0 ;
    for(int i=1 ; i<=6 ; i++){
      int aDistance=Math.abs(a-i);
      int bDistance=Math.abs(b-i);
      if(aDistance<bDistance){
        first++;
      }
      else if(aDistance>bDistance){
        second++;
      }
    }
    int draw=6-first-second ;
    System.out.println(String.format("%d %d %d",first,draw,second));
  }
}
------------------------------------------------------------
OCL File:
---------
 class _378A_PlayingWithDice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := input.getCurrent()->toInteger() ;
    var b : int ; b := input.getCurrent()->toInteger() ;
    var first : int ; first := 0 ;
    var second : int ; second := 0 ;
        var i : int ; i := 1 ; while i <= 6 do ( (     var aDistance : int ; aDistance := if a - i < 0 then -(a - i) else a - i endif ;
     var bDistance : int ; bDistance := if b - i < 0 then -(b - i) else b - i endif ;
     if (aDistance < bDistance) then (     first := first + 1 ) else     if (aDistance > bDistance) then (     second := second + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    var draw : int ; draw := 6 - first - second ;
    OclFile["System.out"].println(StringLib.format("%d %d %d",Sequence{first,draw,second})) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
class GFG {
  public static int countOddSquares(int n,int m){
    return(int)Math.pow((double)m,0.5)-(int)Math.pow((double)n-1,0.5);
  }
  public static void main(String[] args){
    int n=5,m=100 ;
    System.out.print("Count is "+countOddSquares(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countOddSquares( n : int, m : int) : int
  pre: true
  post: true
  activity: (     return m->oclAsType(double)->pow(0.5)->oclAsType(int) - n->oclAsType(double) - 1->pow(0.5)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var m : int ; m := 100 ;
     OclFile["System.out"].print("Count is " + countOddSquares(n, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String year=sc.nextLine();
    for(int i=1000 ; i<=9000 ; i++){
      year=String.valueOf(Integer.parseInt(year)+1);
      if(year.charAt(0)!=year.charAt(1)&& year.charAt(0)!=year.charAt(2)&& year.charAt(0)!=year.charAt(3)&& year.charAt(1)!=year.charAt(2)&& year.charAt(1)!=year.charAt(3)&& year.charAt(2)!=year.charAt(3)){
        break ;
      }
    }
    System.out.println((year));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var year : String ; year := sc.nextLine() ;
         var i : int ; i := 1000 ; while i <= 9000 do ( (     year := (((year)->toInteger() + 1) + "") ; 
     if (year->at(0+1) /= year->at(1+1) & year->at(0+1) /= year->at(2+1) & year->at(0+1) /= year->at(3+1) & year->at(1+1) /= year->at(2+1) & year->at(1+1) /= year->at(3+1) & year->at(2+1) /= year->at(3+1)) then (     break ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println((year)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class BeautifulYear {
  public static void main(String[] args)throws IOException {
    FastIO io=new FastIO();
    int y=io.nextInt()+1 ;
    while(! isUnique(y)){
      y++;
    }
    io.println(y);
    io.close();
  }
  private static boolean isUnique(int a){
    int[] count=new int[10];
    while(a>0){
      count[a % 10]++;
      a/=10 ;
    }
    for(int freq : count){
      if(freq>1){
        return false ;
      }
    }
    return true ;
  }
  static class FastIO extends PrintWriter {
    private BufferedReader br ;
    private StringTokenizer st ;
    public FastIO(){
      this(System.in,System.out);
    }
    public FastIO(InputStream in,OutputStream out){
      super(out);
      br=new BufferedReader(new InputStreamReader(in));
    }
    public FastIO(String problemName)throws IOException {
      super(new FileWriter(problemName+".out"));
      br=new BufferedReader(new FileReader(problemName+".in"));
    }
    public String next(){
      try {
        while(st==null || ! st.hasMoreTokens()){
          st=new StringTokenizer(br.readLine());
        }
        return st.nextToken();
      }
      catch(Exception e){
      }
      return null ;
    }
    public String nextLine(){
      try {
        return br.readLine();
      }
      catch(Exception e){
      }
      return null ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public boolean nextBoolean(){
      return Boolean.parseBoolean(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BeautifulYear {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : FastIO ; io := FastIO.newFastIO() ;
     var y : int ; y := io.nextInt() + 1 ;
    while (not(isUnique(y))) do (     y := y + 1 ) ; 
    io.println(y) ; 
    io.close() ; 
 );
  static   operation isUnique( a : int) : boolean
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,10)->collect(0) ;
     while (a > 0) do (     count[a mod 10+1] := count[a mod 10+1] + 1 ; 
     a := a/(10) ) ; 
     for (freq : count) do ( (     if (freq > 1) then (     return false ) else skip )  ) ; 
     return true );
  static class FastIO extends OclFile {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastIO() : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile["System.in"], OclFile["System.out"]) );
   static operation newFastIO( in : OclFile, out : OclFile) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(in, out);
    return self );
  operation initialise( in : OclFile, out : OclFile) : void
  pre: true  post: true
  activity: (     execute super(out) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   static operation newFastIO( problemName : String) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(problemName);
    return self );
  operation initialise( problemName : String) : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Write(problemName + ".out")) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(problemName + ".in")) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() )   catch (e : ProgramException) do skip
     return null );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : ProgramException) do skip
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextBoolean() : boolean
  pre: true
  post: true
  activity: (     return parseBoolean(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class nurda {
  public static void main(String[] args){
    Scanner real=new Scanner(System.in);
    int n=real.nextInt();
    for(; ; ){
      n++;
      int b=n/1000 ;
      int c=(n/100)% 10 ;
      int d=(n/10)% 10 ;
      int e=n % 10 ;
      if(b!=c && b!=d && b!=e && c!=d && c!=e && d!=e){
        break ;
      }
    }
    System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class nurda {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var real : OclFile ; real := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := real.getCurrent()->toInteger() ;
       while true do ( (     n := n + 1 ; 
     var b : int ; b := n / 1000 ;
    var c : int ; c := (n / 100) mod 10 ;
    var d : int ; d := (n / 10) mod 10 ;
    var e : int ; e := n mod 10 ;
    if (b /= c & b /= d & b /= e & c /= d & c /= e & d /= e) then (     break ) else skip ; 
 )  ) ; 
     OclFile["System.out"].println(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
class Main {
  public static void main(String[] argv){
    Scanner sc=new Scanner(System.in);
    int tests=sc.nextInt();
    for(int t=1 ; t<=tests ; t++){
      int p=sc.nextInt(),q=sc.nextInt();
      int[] cells=new int[q];
      for(int i=0 ; i<q ; i++){
        cells[i]=sc.nextInt();
      }
      int[] nums=new int[q+1];
      nums[0]=cells[0]-1 ;
      for(int i=1 ; i<q ; i++){
        nums[i]=cells[i]-cells[i-1]-1 ;
      }
      nums[q]=p-cells[q-1];
      int[][] fromto=new int[q+1][q+1];
      for(int start=0 ; start<=q ; start++){
      }
      for(int d=1 ; d<=q ; d++){
        for(int start=0 ; start<=q-d ; start++){
          int min=p*p ;
          int all=0 ;
          for(int i=0 ; i<=d ; i++){
            all+=nums[start+i];
          }
          all+=d-1 ;
          for(int i=0 ; i<d ; i++){
            int sum=all+fromto[start][start+i]+fromto[start+i+1][start+d];
            if(sum<min){
              min=sum ;
            }
          }
          fromto[start][start+d]=min ;
        }
      }
      for(int i=0 ; i<=q ; i++){
        for(int j=i ; j<=q ; j++){
        }
      }
      System.err.println(t);
      System.out.printf("Case #%d: %d\n",t,fromto[0][q]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( argv : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tests : int ; tests := sc.getCurrent()->toInteger() ;
         var t : int ; t := 1 ; while t <= tests do ( (     var p : int ; p := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
     var cells : Sequence(int) ; cells := Integer.subrange(1,q)->collect(0) ;
        var i : int ; i := 0 ; while i < q do ( (     cells[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var nums : Sequence(int) ; nums := Integer.subrange(1,q + 1)->collect(0) ;
    nums[0+1] := cells[0+1] - 1 ; 
        var i : int ; i := 1 ; while i < q do ( (     nums[i+1] := cells[i+1] - cells[i - 1+1] - 1 )  ;     i := i + 1 ) ; 
    nums[q+1] := p - cells[q - 1+1] ; 
    var fromto : Sequence(Sequence(int)) ; fromto := Integer.subrange(1,q + 1)->collect(Integer.subrange(1,q + 1)->collect(0)) ;
        var start : int ; start := 0 ; while start <= q do ( skip  ;     start := start + 1 ) ; 
        var d : int ; d := 1 ; while d <= q do ( (         var start : int ; start := 0 ; while start <= q - d do ( (     var min : int ; min := p * p ;
     var all : int ; all := 0 ;
        var i : int ; i := 0 ; while i <= d do ( (     all := all+(nums[start + i+1]) )  ;     i := i + 1 ) ; 
    all := all+(d - 1) ; 
        var i : int ; i := 0 ; while i < d do ( (     var sum : int ; sum := all + fromto[start+1][start + i+1] + fromto[start + i + 1+1][start + d+1] ;
     if (sum < min) then (     min := sum ) else skip )  ;     i := i + 1 ) ; 
    fromto[start+1][start + d+1] := min ; 
 )  ;     start := start + 1 ) )  ;     d := d + 1 ) ; 
        var i : int ; i := 0 ; while i <= q do ( (         var j : int ; j := i ; while j <= q do ( skip  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.err"].println(t) ; 
    OclFile["System.out"].printf("Case #%d: %d\n", t, fromto[0+1][q+1]) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class AAA {
  static int get_last_two_digit(long N){
    if(N<=10){
      long ans=0,fac=1 ;
      for(int i=1 ; i<=N ; i++){
        fac=fac*i ;
        ans+=fac ;
      }
      return(int)ans % 100 ;
    }
    else return 13 ;
  }
  public static void main(String[] args){
    long N=1 ;
    for(N=1 ; N<=10 ; N++)System.out.println("For N="+N+" : "+get_last_two_digit(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class AAA {
  static   operation get_last_two_digit( N : long) : int
  pre: true
  post: true
  activity: (     if (N <= 10) then (     var ans : long ; ans := 0 ;
    var fac : long ; fac := 1 ;
         var i : int ; i := 1 ; while i <= N do ( (     fac := fac * i ; 
     ans := ans+(fac) )  ;     i := i + 1 ) ; 
     return ans->oclAsType(int) mod 100 ) else     return 13 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := 1 ;
         N := 1 ; while N <= 10 do (     OclFile["System.out"].println("For N=" + N + " : " + get_last_two_digit(N)) ;  ;     N := N + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class _823A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; ++i){
      int n=in.nextInt();
      int c=in.nextInt();
      int sum=0 ;
      int a[]=new int[n];
      int o[]=new int[101];
      for(int j=0 ; j<n ; ++j){
        a[j]=in.nextInt();
        o[a[j] ]++;
      }
      for(int j=0 ; j<o.length ; ++j){
        if(o[j]>=c)sum+=c ;
        else sum+=o[j];
      }
      if(sum<n)System.out.println(sum);
      else System.out.println(n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _823A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var c : int ; c := in.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var o : Sequence(int) ; o := Integer.subrange(1,101)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     a[j+1] := in.getCurrent()->toInteger() ; 
     o[a[j+1]+1] := o[a[j+1]+1] + 1 )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < o->size() do ( (     if (o[j+1] >= c) then     sum := sum+(c) ; else     sum := sum+(o[j+1]) ; )  ;     j := j + 1 ) ; 
    if (sum < n) then     OclFile["System.out"].println(sum) else     OclFile["System.out"].println(n) ; ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    while(true){
      a++;
      int n1=a/1000,n2=a/100 % 10,n3=a/10 % 10,n4=a % 10 ;
      if(n1!=n2 && n2!=n3 && n3!=n4 && n1!=n3 && n1!=n4 && n2!=n3 && n2!=n4){
        break ;
      }
    }
    System.out.print(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     while (true) do (     a := a + 1 ; 
     var n1 : int ; n1 := a / 1000 ;
    var n2 : int ; n2 := a / 100 mod 10 ;
    var n3 : int ; n3 := a / 10 mod 10 ;
    var n4 : int ; n4 := a mod 10 ;
     if (n1 /= n2 & n2 /= n3 & n3 /= n4 & n1 /= n3 & n1 /= n4 & n2 /= n3 & n2 /= n4) then (     break ) else skip ) ; 
     OclFile["System.out"].print(a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Codesolver {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=0 ;
    boolean ans=false ;
    while(! ans){
      boolean ar[]=new boolean[10];
      int l=0,j=0 ;
      n++;
      m=n ;
      while(m!=0){
        int r=m % 10 ;
        l++;
        if(! ar[r]){
          ar[r]=true ;
          j++;
        }
        else {
          break ;
        }
        m=m/10 ;
      }
      if(l==j){
        ans=true ;
      }
    }
    System.out.println(n);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codesolver {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := 0 ;
    var ans : boolean ; ans := false ;
    while (not(ans)) do (     var ar : Sequence(boolean) ; ar := Integer.subrange(1,10)->collect(false) ;
     var l : int ; l := 0 ;
    var j : int ; j := 0 ;
    n := n + 1 ; 
    m := n ; 
    while (m /= 0) do (     var r : int ; r := m mod 10 ;
     l := l + 1 ; 
     if (not(ar[r+1])) then (     ar[r+1] := true ; 
     j := j + 1 ) else (     break ) ;  
     m := m / 10 ) ; 
    if (l = j) then (     ans := true ) else skip ; 
 ) ; 
    OclFile["System.out"].println(n) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float noOfYears(int t1,int n1,int t2){
    float years=((t2-1)*n1/(float)(t1-1));
    return years ;
  }
  public static void main(String[] args){
    int T1=3,N1=5,T2=6 ;
    System.out.println(noOfYears(T1,N1,T2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation noOfYears( t1 : int, n1 : int, t2 : int) : double
  pre: true
  post: true
  activity: (     var years : double ; years := ((t2 - 1) * n1 / (t1 - 1)->oclAsType(double)) ;
     return years );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T1 : int ; T1 := 3 ;
    var N1 : int ; N1 := 5 ;
    var T2 : int ; T2 := 6 ;
     OclFile["System.out"].println(noOfYears(T1, N1, T2)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void printVector(Vector<Integer>v){
    System.out.println(v.size());
    for(int i=0 ; i<v.size(); i++)System.out.print(v.get(i)+" ");
    System.out.println();
  }
  static void findTwoGroup(int n){
    int sum=n*(n+1)/2 ;
    int group1Sum=sum/2 ;
    Vector<Integer>group1=new Vector<Integer>();
    Vector<Integer>group2=new Vector<Integer>();
    for(int i=n ; i>0 ; i--){
      if(group1Sum-i>=0){
        group1.add(i);
        group1Sum-=i ;
      }
      else {
        group2.add(i);
      }
    }
    printVector(group1);
    printVector(group2);
  }
  public static void main(String[] args){
    int n=5 ;
    findTwoGroup(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printVector( v : Sequence(int)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(v->size()) ; 
         var i : int ; i := 0 ; while i < v->size() do (     OclFile["System.out"].print(v->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation findTwoGroup( n : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := n * (n + 1) / 2 ;
     var group1Sum : int ; group1Sum := sum / 2 ;
    var group1 : Sequence(int) ; group1 := Sequence{} ;
    var group2 : Sequence(int) ; group2 := Sequence{} ;
        var i : int ; i := n ; while i > 0 do ( (     if (group1Sum - i >= 0) then (     group1 := group1->including(i) ; 
     group1Sum := group1Sum-(i) ) else (     group2 := group2->including(i) ) )  ;     i := i - 1 ) ; 
    execute printVector(group1) ; 
    execute printVector(group2) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute findTwoGroup(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class App {
  static class Sort implements Comparable<Sort>{
    double val ;
    int ind ;
    public int compareTo(Sort o){
      if(this.val!=o.val){
        return(this.val<o.val)?-1 : 1 ;
      }
      else {
        return(this.ind>o.ind)?-1 : 1 ;
      }
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t1=sc.nextInt();
    int t2=sc.nextInt();
    double k=sc.nextInt()/100.0 ;
    Sort[] S=new Sort[n+1];
    for(int i=1 ; i<=n ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      S[i]=new Sort();
      S[i] .val=Math.max(a*t1*(1-k)+b*t2,b*t1*(1-k)+a*t2);
      S[i] .ind=i ;
    }
    Arrays.sort(S,1,n+1);
    for(int i=n ; i>=1 ; i--){
      System.out.print(S[i] .ind+" ");
      System.out.printf("%.2f\n",S[i] .val);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static class Sort implements Comparable<Sort> {
   attribute val : double;
   attribute ind : int;
   operation compareTo( o : Sort) : int
  pre: true
  post: true
  activity: (     if (self.val /= o.val) then (     return if (self.val < o.val) then -1 else 1 endif ) else (     return if (self.ind > o.ind) then -1 else 1 endif ) );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t1 : int ; t1 := sc.getCurrent()->toInteger() ;
    var t2 : int ; t2 := sc.getCurrent()->toInteger() ;
    var k : double ; k := sc.getCurrent()->toInteger() / 100.0 ;
    var S : Sequence(Sort) ; S := Integer.subrange(1,n + 1)->collect(null) ;
        var i : int ; i := 1 ; while i <= n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    S[i+1] := Sort.newSort() ; 
    S[i+1].val := Set{a * t1 * (1 - k) + b * t2, b * t1 * (1 - k) + a * t2}->max() ; 
    S[i+1].ind := i ; 
 )  ;     i := i + 1 ) ; 
    S := S.subrange(1,1)^(S.subrange(1+1,n + 1)->sort())^S.subrange(n + 1+1,S.size) ; 
        var i : int ; i := n ; while i >= 1 do ( (     OclFile["System.out"].print(S[i+1].ind + " ") ; 
     OclFile["System.out"].printf("%.2f\n", S[i+1].val) )  ;     i := i - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int Distinct_Prime_factors(Vector<Integer>a){
    HashSet<Integer>m=new HashSet<Integer>();
    for(int i=0 ; i<a.size(); i++){
      int sq=(int)Math.sqrt(a.get(i));
      for(int j=2 ; j<=sq ; j++){
        if(a.get(i)% j==0){
          m.add(j);
          while(a.get(i)% j==0){
            a.set(i,a.get(i)/j);
          }
        }
      }
      if(a.get(i)>1){
        m.add(a.get(i));
      }
    }
    return m.size();
  }
  public static void main(String args[]){
    Vector<Integer>a=new Vector<Integer>();
    a.add(1);
    a.add(2);
    a.add(3);
    a.add(4);
    a.add(5);
    System.out.println(Distinct_Prime_factors(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Distinct_Prime_factors( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var m : Set(int) ; m := Set{} ;
         var i : int ; i := 0 ; while i < a->size() do ( (     var sq : int ; sq := (a->at(i+1))->sqrt()->oclAsType(int) ;
         var j : int ; j := 2 ; while j <= sq do ( (     if (a->at(i+1) mod j = 0) then (     m := m->including(j) ; 
     while (a->at(i+1) mod j = 0) do (     a := a.setAt(i+1, a->at(i+1) / j) ) ) else skip )  ;     j := j + 1 ) ; 
     if (a->at(i+1) > 1) then (     m := m->including(a->at(i+1)) ) else skip )  ;     i := i + 1 ) ; 
     return m->size() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{} ;
     a := a->including(1) ; 
    a := a->including(2) ; 
    a := a->including(3) ; 
    a := a->including(4) ; 
    a := a->including(5) ; 
    OclFile["System.out"].println(Distinct_Prime_factors(a)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class MergeSort {
  void merge(int arr[],int l,int m,int r){
    int n1=m-l+1 ;
    int n2=r-m ;
    int L[]=new int[n1];
    int R[]=new int[n2];
    for(int i=0 ; i<n1 ; ++i)L[i]=arr[l+i];
    for(int j=0 ; j<n2 ; ++j)R[j]=arr[m+1+j];
    int i=0,j=0 ;
    int k=l ;
    while(i<n1 && j<n2){
      if(L[i]<=R[j]){
        arr[k]=L[i];
        i++;
      }
      else {
        arr[k]=R[j];
        j++;
      }
      k++;
    }
    while(i<n1){
      arr[k]=L[i];
      i++;
      k++;
    }
    while(j<n2){
      arr[k]=R[j];
      j++;
      k++;
    }
  }
  void sort(int arr[],int l,int r){
    if(l<r){
      int m=(l+r)/2 ;
      sort(arr,l,m);
      sort(arr,m+1,r);
      merge(arr,l,m,r);
    }
  }
  static void printArray(int arr[]){
    int n=arr.length ;
    for(int i=0 ; i<n ; ++i)System.out.print(arr[i]+" ");
    System.out.println();
  }
  public static void main(String args[]){
    int arr[]={
      12,11,13,5,6,7 };
      System.out.println("Given Array");
      printArray(arr);
      MergeSort ob=new MergeSort();
      ob.sort(arr,0,arr.length-1);
      System.out.println("\nSorted array");
      printArray(arr);
    }
  }

------------------------------------------------------------
OCL File:
---------
class MergeSort {
   operation merge( arr : Sequence(int), l : int, m : int, r : int) : void
  pre: true
  post: true
  activity: (     var n1 : int ; n1 := m - l + 1 ;
     var n2 : int ; n2 := r - m ;
    var L : Sequence(int) ; L := Integer.subrange(1,n1)->collect(0) ;
    var R : Sequence(int) ; R := Integer.subrange(1,n2)->collect(0) ;
        var i : int ; i := 0 ; while i < n1 do (     L[i+1] := arr[l + i+1] ;  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < n2 do (     R[j+1] := arr[m + 1 + j+1] ;  ;     j := j + 1 ) ; 
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    var k : int ; k := l ;
    while (i < n1 & j < n2) do (     if (L[i+1] <= R[j+1]) then (     arr[k+1] := L[i+1] ; 
     i := i + 1 ) else (     arr[k+1] := R[j+1] ; 
     j := j + 1 ) ;  
     k := k + 1 ) ; 
    while (i < n1) do (     arr[k+1] := L[i+1] ; 
     i := i + 1 ; 
     k := k + 1 ) ; 
    while (j < n2) do (     arr[k+1] := R[j+1] ; 
     j := j + 1 ; 
     k := k + 1 ) ; 
 );
   operation sort( arr : Sequence(int), l : int, r : int) : void
  pre: true
  post: true
  activity: (     if (l < r) then (     var m : int ; m := (l + r) / 2 ;
     execute sort(arr, l, m) ; 
     execute sort(arr, m + 1, r) ; 
     execute merge(arr, l, m, r) ) else skip );
  static   operation printArray( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,11,13,5,6,7} ;
     OclFile["System.out"].println("Given Array") ; 
    execute printArray(arr) ; 
    var ob : MergeSort ; ob := MergeSort.newMergeSort() ;
    ob.sort(arr, 0, arr->size() - 1) ; 
    OclFile["System.out"].println("\nSorted array") ; 
    execute printArray(arr) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class newyear {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer s=new StringTokenizer(in.readLine());
    long n=Long.parseLong(s.nextToken());
    long m=Long.parseLong(s.nextToken());
    int ans=0 ;
    for(int i=1 ; i<=60 ; i++)for(int j=0 ; j<=i-2 ; j++){
      long temp=(((1L<<i))-1-((1L<<j)));
      if(temp>=n && temp<=m){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class newyear {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : OclIterator ; s := OclIterator.newOclIterator_String(in.readLine()) ;
    var n : long ; n := (s.next())->toLong() ;
    var m : long ; m := (s.next())->toLong() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= 60 do (         var j : int ; j := 0 ; while j <= i - 2 do ( (     var temp : long ; temp := ((((1L*(2->pow(i)))->oclAsType(long))) - 1 - (((1L*(2->pow(j)))->oclAsType(long)))) ;
     if (temp >= n & temp <= m) then (     ans := ans + 1 ) else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static void main(String args[]){
    String binaryNumber="1001" ;
    System.out.println(Integer.parseInt(binaryNumber,2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var binaryNumber : String ; binaryNumber := "1001" ;
     OclFile["System.out"].println((binaryNumber)->toInteger()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    long a=scan.nextLong();
    long b=scan.nextLong();
    int counter=0 ;
    long n=0 ;
    for(int i=1 ; i<=60 ; i++){
      for(int j=0 ; j<=i-2 ; j++){
        n=(1L<<i)-(1L<<j)-1 ;
        if(n>=a && n<=b){
          counter++;
        }
      }
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := scan.getCurrent()->toLong() ;
    var b : long ; b := scan.getCurrent()->toLong() ;
    var counter : int ; counter := 0 ;
    var n : long ; n := 0 ;
        var i : int ; i := 1 ; while i <= 60 do ( (         var j : int ; j := 0 ; while j <= i - 2 do ( (     n := ((1L*(2->pow(i)))->oclAsType(long)) - ((1L*(2->pow(j)))->oclAsType(long)) - 1 ; 
     if (n >= a & n <= b) then (     counter := counter + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static int N=105 ;
  static int[] a=new int[N];
  static int[] cnt=new int[N];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0){
      Arrays.fill(cnt,0);
      int n=sc.nextInt(),c=sc.nextInt();
      for(int i=1 ; i<=n ; i++){
        int x=sc.nextInt();
        a[i]=x ;
        cnt[x]++;
      }
      int ans=0 ;
      for(int i=1 ; i<N ; i++){
        if(cnt[i]!=0){
          int s=cnt[i];
          ans+=Math.min(s,c);
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int := 105;
  static   attribute a : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static   attribute cnt : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     cnt := cnt->collect(0) ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     a[i+1] := x ; 
     cnt[x+1] := cnt[x+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < N do ( (     if (cnt[i+1] /= 0) then (     var s : int ; s := cnt[i+1] ;
     ans := ans+(Set{s, c}->min()) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Arc {
  static double arcLength(double diameter,double angle){
    double pi=22.0/7.0 ;
    double arc ;
    if(angle>=360){
      System.out.println("Angle cannot"+" be formed");
      return 0 ;
    }
    else {
      arc=(pi*diameter)*(angle/360.0);
      return arc ;
    }
  }
  public static void main(String args[]){
    double diameter=25.0 ;
    double angle=45.0 ;
    double arc_len=arcLength(diameter,angle);
    System.out.println(arc_len);
  }
}
------------------------------------------------------------
OCL File:
---------
class Arc {
  static   operation arcLength( diameter : double, angle : double) : double
  pre: true
  post: true
  activity: (     var pi : double ; pi := 22.0 / 7.0 ;
     var arc : double ;
     if (angle >= 360) then (     OclFile["System.out"].println("Angle cannot" + " be formed") ; 
     return 0 ) else (     arc := (pi * diameter) * (angle / 360.0) ; 
     return arc ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var diameter : double ; diameter := 25.0 ;
     var angle : double ; angle := 45.0 ;
     var arc_len : double ; arc_len := arcLength(diameter, angle) ;
     OclFile["System.out"].println(arc_len) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int find_count(Vector<Integer>ele){
    int count=0 ;
    for(int i=0 ; i<ele.size(); i++){
      Vector<Integer>p=new Vector<Integer>();
      int c=0 ;
      for(int j=ele.size()-1 ; j>=(ele.size()-1-i)&& j>=0 ; j--){
        p.add(ele.get(j));
      }
      int j=ele.size()-1,k=0 ;
      while(j>=0){
        if(ele.get(j)!=p.get(k)){
          break ;
        }
        j--;
        k++;
        if(k==p.size()){
          c++;
          k=0 ;
        }
      }
      count=Math.max(count,c);
    }
    return count ;
  }
  static void solve(int n){
    int count=1 ;
    Vector<Integer>ele=new Vector<Integer>();
    for(int i=0 ; i<n ; i++){
      System.out.print(count+",");
      ele.add(count);
      count=find_count(ele);
    }
  }
  public static void main(String[] args){
    int n=10 ;
    solve(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation find_count( ele : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < ele->size() do ( (     var p : Sequence(int) ; p := Sequence{} ;
     var c : int ; c := 0 ;
        var j : int ; j := ele->size() - 1 ; while j >= (ele->size() - 1 - i) & j >= 0 do ( (     p := p->including(ele->at(j+1)) )  ;     j := j - 1 ) ; 
    var j : int ; j := ele->size() - 1 ;
    var k : int ; k := 0 ;
    while (j >= 0) do (     if (ele->at(j+1) /= p->at(k+1)) then (     break ) else skip ; 
     j := j - 1 ; 
     k := k + 1 ; 
     if (k = p->size()) then (     c := c + 1 ; 
     k := 0 ) else skip ) ; 
    count := Set{count, c}->max() ; 
 )  ;     i := i + 1 ) ; 
     return count );
  static   operation solve( n : int) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 1 ;
     var ele : Sequence(int) ; ele := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(count + ",") ; 
     ele := ele->including(count) ; 
     count := find_count(ele) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     execute solve(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int strScore(String str[],String s,int n){
    int score=0,index=0 ;
    for(int i=0 ; i<n ; i++){
      if(str[i]==s){
        for(int j=0 ; j<s.length(); j++)score+=s.charAt(j)-'a'+1 ;
        index=i+1 ;
        break ;
      }
    }
    score=score*index ;
    return score ;
  }
  public static void main(String[] args){
    String str[]={
      "sahil","shashanak","sanjit","abhinav","mohit" };
      String s="abhinav" ;
      int n=str.length ;
      int score=strScore(str,s,n);
      System.out.println(score);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation strScore( str : Sequence(String), s : String, n : int) : int
  pre: true
  post: true
  activity: (     var score : int ; score := 0 ;
    var index : int ; index := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (str[i+1] = s) then (         var j : int ; j := 0 ; while j < s->size() do (     score := score+(s->at(j+1) - ('a')->char2byte() + 1) ;  ;     j := j + 1 ) ; 
     index := i + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     score := score * index ; 
     return score );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := Sequence{"sahil","shashanak","sanjit","abhinav","mohit"} ;
     var s : String ; s := "abhinav" ;
    var n : int ; n := str->size() ;
    var score : int ; score := strScore(str, s, n) ;
    OclFile["System.out"].println(score) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
public class Main {
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int[] data=new int[n];
      for(int i=0 ; i<n ; i++){
        data[i]=sc.nextInt();
      }
      long count=0 ;
      int now=0 ;
      int left=0,right=0 ;
      while(true){
        if(left>=n){
          break ;
        }
        while(right<n){
          int res=now ^ data[right];
          int res2=now | data[right];
          if(res!=res2){
            break ;
          }
          now=now ^ data[right];
          right++;
        }
        count+=right-left ;
        now=now ^(now & data[left]);
        left++;
      }
      System.out.println(count);
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var data : Sequence(int) ; data := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     data[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : long ; count := 0 ;
    var now : int ; now := 0 ;
    var left : int ; left := 0 ;
    var right : int ; right := 0 ;
    while (true) do (     if (left >= n) then (     break ) else skip ; 
     while (right < n) do (     var res : int ; res := MathLib.bitwiseXor(now,data[right+1]) ;
     var res2 : int ; res2 := MathLib.bitwiseOr(now,data[right+1]) ;
    if (res /= res2) then (     break ) else skip ; 
    now := MathLib.bitwiseXor(now,data[right+1]) ; 
    right := right + 1 ; 
 ) ; 
    count := count+(right - left) ; 
    now := MathLib.bitwiseXor(now,(MathLib.bitwiseAnd(now,data[left+1]))) ; 
    left := left + 1 ; 
 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    int rep=1 ;
    if(args.length>0){
      rep=Integer.parseInt(args[0]);
    }
(new Main()).__solve(rep);
  }
  void __solve(int rep){
    try(Scanner cin=new Scanner(System.in);
){
      for(int i=0 ; i<rep ; ++i){
        __solve(cin);
      }
    }
  }
  void __solve(Scanner cin){
    int N=cin.nextInt();
    int array[]=new int[N];
    for(int i=0 ; i<N ; ++i){
      array[i]=cin.nextInt();
    }
    int L=0 ;
    int sum=0 ;
    long ret=0 ;
    for(int R=0 ; R<N ; ++R){
      while((sum & array[R])!=0){
        sum ^=array[L++];
      }
      sum ^=array[R];
      ret+=(R-L+1);
    }
    System.out.println(ret);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var rep : int ; rep := 1 ;
     if (args->size() > 0) then (     rep := (args[0+1])->toInteger() ) else skip ; 
     (Main.newMain()).__solve(rep) );
   operation __solve( rep : int) : void
  pre: true
  post: true
  activity: (     try (    var cin : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (         var i : int ; i := 0 ; while i < rep do ( (     execute __solve(cin) )  ;     i := i + 1 ) ))  );
   operation __solve( cin : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := cin.getCurrent()->toInteger() ;
     var array : Sequence(int) ; array := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     array[i+1] := cin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var L : int ; L := 0 ;
    var sum : int ; sum := 0 ;
    var ret : long ; ret := 0 ;
        var R : int ; R := 0 ; while R < N do ( (     while ((MathLib.bitwiseAnd(sum,array[R+1])) /= 0) do (     sum := MathLib.bitwiseXor(sum,array[L+1]) ) ; 
     sum := MathLib.bitwiseXor(sum,array[R+1]) ; 
     ret := ret+((R - L + 1)) )  ;     R := R + 1 ) ; 
    OclFile["System.out"].println(ret) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  static Scanner scanner=new Scanner();
  public static void main(String[] $){
    int n=scanner.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scanner.nextInt();
    }
    int xor=a[0];
    int sum=a[0];
    int l=0,r=0 ;
    long ans=0 ;
    while(l<n){
      while(r+1<n &&(xor ^ a[r+1])==sum+a[r+1]){
        r++;
        xor ^=a[r];
        sum+=a[r];
      }
      ans+=r-l+1 ;
      xor ^=a[l];
      sum-=a[l];
      l++;
    }
    System.out.println(ans);
  }
  static class Scanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),1<<15);
    StringTokenizer tokenizer ;
    String next(){
      try {
        while(tokenizer==null || ! tokenizer.hasMoreTokens()){
          tokenizer=new StringTokenizer(reader.readLine());
        }
      }
      catch(IOException ignored){
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := (arguments ( ));
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var xor : int ; xor := a[0+1] ;
    var sum : int ; sum := a[0+1] ;
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    var ans : long ; ans := 0 ;
    while (l < n) do (     while (r + 1 < n & (MathLib.bitwiseXor(xor,a[r + 1+1])) = sum + a[r + 1+1]) do (     r := r + 1 ; 
     xor := MathLib.bitwiseXor(xor,a[r+1]) ; 
     sum := sum+(a[r+1]) ) ; 
     ans := ans+(r - l + 1) ; 
    xor := MathLib.bitwiseXor(xor,a[l+1]) ; 
    sum := sum-(a[l+1]) ; 
    l := l + 1 ; 
 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class Scanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (1*(2->pow(15)))->oclAsType(long));
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (ignored : IOException) do skip
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=sc.nextInt();
    int[] vals=new int[N];
    for(int i=0 ; i<vals.length ; i++){
      vals[i]=sc.nextInt();
    }
    long ans=0,xor=0,acum=0,lastOk=0 ;
    for(int i=0 ; i<N ; i++){
      xor ^=vals[i];
      acum+=vals[i];
      while(xor!=acum){
        xor ^=vals[(int)lastOk];
        acum-=vals[(int)lastOk];
        lastOk++;
      }
      ans+=i-lastOk+1 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var vals : Sequence(int) ; vals := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < vals->size() do ( (     vals[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var xor : long ; xor := 0 ;
    var acum : long ; acum := 0 ;
    var lastOk : long ; lastOk := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     xor := MathLib.bitwiseXor(xor,vals[i+1]) ; 
     acum := acum+(vals[i+1]) ; 
     while (xor /= acum) do (     xor := MathLib.bitwiseXor(xor,vals[lastOk->oclAsType(int)+1]) ; 
     acum := acum-(vals[lastOk->oclAsType(int)+1]) ; 
     lastOk := lastOk + 1 ) ; 
     ans := ans+(i - lastOk + 1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPossible(float x,float y,float z){
    float a=x*x+y*y+z*z ;
    if(Math.ceil(a)==1 && Math.floor(a)==1)return true ;
    return false ;
  }
  public static void main(String args[]){
    float l=0.70710678f,m=0.5f,n=0.5f ;
    if(isPossible(l,m,n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPossible( x : double, y : double, z : double) : boolean
  pre: true
  post: true
  activity: (     var a : double ; a := x * x + y * y + z * z ;
     if ((a)->ceil() = 1 & (a)->floor() = 1) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : double ; l := 0.70710678f ;
    var m : double ; m := 0.5f ;
    var n : double ; n := 0.5f ;
     if (isPossible(l, m, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p076 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p076().run());
  }
  public String run(){
    return partitions(100,1).subtract(BigInteger.ONE).toString();
  }
  private static BigInteger partitions(int n,int k){
    BigInteger[][] table=new BigInteger[n+1][n+1];
    for(int i=0 ; i<=n ; i++){
      for(int j=n ; j>=0 ; j--){
        if(j==i)table[i][j]=BigInteger.ONE ;
        else if(j>i)table[i][j]=BigInteger.ZERO ;
        else if(j==0)table[i][j]=table[i][j+1];
        else table[i][j]=table[i][j+1] .add(table[i-j][j]);
      }
    }
    return table[n][k];
  }
}
------------------------------------------------------------
OCL File:
---------
 class p076 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p076.newp076().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     return partitions(100, 1).subtract(1)+"" );
  static   operation partitions( n : int, k : int) : long
  pre: true
  post: true
  activity: (     var table : Sequence(Sequence(long)) ; table := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(null)) ;
         var i : int ; i := 0 ; while i <= n do ( (         var j : int ; j := n ; while j >= 0 do ( (     if (j = i) then     table[i+1][j+1] := 1 ; else     if (j > i) then     table[i+1][j+1] := 0 else     if (j = 0) then     table[i+1][j+1] := table[i+1][j + 1+1] else     table[i+1][j+1] := table[i+1][j + 1+1]->excludes(table[i - j+1][j+1]) ; ;  ;  )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
     return table[n+1][k+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int largestOddDigit(int n){
    int maxOdd=-1 ;
    while(n>0){
      int digit=n % 10 ;
      if(digit % 2==1 && digit>maxOdd)maxOdd=digit ;
      n=n/10 ;
    }
    return maxOdd ;
  }
  static int getProduct(int n){
    int maxOdd=largestOddDigit(n);
    if(maxOdd==-1)return-1 ;
    return(n*maxOdd);
  }
  public static void main(String[] args){
    int n=12345 ;
    System.out.println(getProduct(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation largestOddDigit( n : int) : int
  pre: true
  post: true
  activity: (     var maxOdd : int ; maxOdd := -1 ;
     while (n > 0) do (     var digit : int ; digit := n mod 10 ;
     if (digit mod 2 = 1 & digit > maxOdd) then     maxOdd := digit ; else skip ; 
     n := n / 10 ) ; 
     return maxOdd );
  static   operation getProduct( n : int) : int
  pre: true
  post: true
  activity: (     var maxOdd : int ; maxOdd := largestOddDigit(n) ;
     if (maxOdd = -1) then     return -1 else skip ; 
     return (n * maxOdd) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12345 ;
     OclFile["System.out"].println(getProduct(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String newString(String s,int k){
    String X="" ;
    while(s.length()>0){
      char temp=s.charAt(0);
      for(int i=1 ; i<k && i<s.length(); i++){
        if(s.charAt(i)<temp){
          temp=s.charAt(i);
        }
      }
      X=X+temp ;
      for(int i=0 ; i<k ; i++){
        if(s.charAt(i)==temp){
          s=s.substring(0,i)+s.substring(i+1);
          break ;
        }
      }
    }
    return X ;
  }
  public static void main(String[] args){
    String s="gaurang" ;
    int k=3 ;
    System.out.println(newString(s,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation newString( s : String, k : int) : String
  pre: true
  post: true
  activity: (     var X : String ; X := "" ;
     while (s->size() > 0) do (     var temp : String ; temp := s->at(0+1) ;
         var i : int ; i := 1 ; while i < k & i < s->size() do ( (     if (s->at(i+1) < temp) then (     temp := s->at(i+1) ) else skip )  ;     i := i + 1 ) ; 
     X := X + temp ; 
         var i : int ; i := 0 ; while i < k do ( (     if (s->at(i+1) = temp) then (     s := s.subrange(0+1,i) + s.subrange(i + 1+1,i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ) ; 
     return X );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "gaurang" ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println(newString(s, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void subsetSums(int[] arr,int l,int r,int sum){
    if(l>r){
      System.out.print(sum+" ");
      return ;
    }
    subsetSums(arr,l+1,r,sum+arr[l]);
    subsetSums(arr,l+1,r,sum);
  }
  public static void main(String[] args){
    int[] arr={
      5,4,3 };
      int n=arr.length ;
      subsetSums(arr,0,n-1,0);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation subsetSums( arr : Sequence(int), l : int, r : int, sum : int) : void
  pre: true
  post: true
  activity: (     if (l > r) then (     OclFile["System.out"].print(sum + " ") ; 
     return ) else skip ; 
     execute subsetSums(arr, l + 1, r, sum + arr[l+1]) ; 
     execute subsetSums(arr, l + 1, r, sum) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,4,3} ;
     var n : int ; n := arr->size() ;
     execute subsetSums(arr, 0, n - 1, 0) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.StringTokenizer ;
public class B305 {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    long p=Long.parseLong(st.nextToken());
    long q=Long.parseLong(st.nextToken());
    int n=Integer.parseInt(br.readLine());
    List<Long>quotients=new ArrayList<>();
    st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<n ; i++){
      quotients.add(Long.parseLong(st.nextToken()));
    }
    if(n>1 && quotients.get(n-1)==1){
      long update=quotients.get(n-2)+1 ;
      quotients.remove(n-1);
      quotients.remove(n-2);
      quotients.add(update);
      n--;
    }
    int start=0 ;
    while(q!=0){
      long quotient=p/q ;
      long remainder=p % q ;
      if(start==n || quotients.get(start)!=quotient){
        System.out.println("NO");
        return ;
      }
      p=q ;
      q=remainder ;
      start++;
    }
    if(start==n){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B305 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var p : long ; p := (st.next())->toLong() ;
    var q : long ; q := (st.next())->toLong() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var quotients : Sequence(long) ; quotients := Sequence{} ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     quotients := quotients->including((st.next())->toLong()) )  ;     i := i + 1 ) ; 
    if (n > 1 & quotients->at(n - 1+1) = 1) then (     var update : long ; update := quotients->at(n - 2+1) + 1 ;
     quotients := quotients->excludingFirst(n - 1) ; 
    quotients := quotients->excludingFirst(n - 2) ; 
    quotients := quotients->including(update) ; 
    n := n - 1 ; 
 ) else skip ; 
    var start : int ; start := 0 ;
    while (q /= 0) do (     var quotient : long ; quotient := p / q ;
     var remainder : long ; remainder := p mod q ;
    if (start = n or quotients->at(start+1) /= quotient) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    p := q ; 
    q := remainder ; 
    start := start + 1 ; 
 ) ; 
    if (start = n) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
import java.util.Scanner ;
public class Main {
  static long a[]=new long[500];
  public static int n ;
  public static BigDecimal f(int index){
    if(index==n)return BigDecimal.valueOf(a[index]).divide(BigDecimal.ONE,45,BigDecimal.ROUND_HALF_DOWN);
    else return BigDecimal.valueOf(a[index]).add(BigDecimal.ONE.divide(f(index+1),45,BigDecimal.ROUND_HALF_DOWN));
  }
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    BigDecimal p,q ;
    p=cin.nextBigDecimal();
    q=cin.nextBigDecimal();
    n=cin.nextInt();
    for(int i=1 ; i<=n ; i++){
      a[i]=cin.nextLong();
    }
    BigDecimal s1=p.divide(q,45,BigDecimal.ROUND_HALF_DOWN);
    BigDecimal s2=f(1);
    if(s1.equals(s2)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a : long := Integer.subrange(1,500)->collect(0);
  static   attribute n : int;
  static   operation f( index : int) : double
  pre: true
  post: true
  activity: (     if (index = n) then     return (a[index+1] + "")->toReal().divide(1.0, 45, ROUND_HALF_DOWN) else     return (a[index+1] + "")->toReal()->excludes(1.0.divide(f(index + 1), 45, ROUND_HALF_DOWN)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : double ;
    var q : double ;
    p := cin.nextBigDecimal() ; 
    q := cin.nextBigDecimal() ; 
    n := cin.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := cin.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var s1 : double ; s1 := p.divide(q, 45, ROUND_HALF_DOWN) ;
    var s2 : double ; s2 := f(1) ;
    if (s1 = s2) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Solution {
  public void dfs(int[][] M,int[] visited,int i){
    for(int j=0 ; j<M.length ; j++){
      if(M[i][j]==1 && visited[j]==0){
        visited[j]=1 ;
        dfs(M,visited,j);
      }
    }
  }
  public int findCircleNum(int[][] M){
    int[] visited=new int[M.length];
    int count=0 ;
    for(int i=0 ; i<M.length ; i++){
      if(visited[i]==0){
        dfs(M,visited,i);
        count++;
      }
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation dfs( M : Sequence(Sequence(int)), visited : Sequence(int), i : int) : void
  pre: true
  post: true
  activity: (         var j : int ; j := 0 ; while j < M->size() do ( (     if (M[i+1][j+1] = 1 & visited[j+1] = 0) then (     visited[j+1] := 1 ; 
     execute dfs(M, visited, j) ) else skip )  ;     j := j + 1 ) );
   operation findCircleNum( M : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var visited : Sequence(int) ; visited := Integer.subrange(1,M->size())->collect(0) ;
     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < M->size() do ( (     if (visited[i+1] = 0) then (     execute dfs(M, visited, i) ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     return count );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long factorial(long n){
    long res=1 ;
    for(int i=1 ; i<=n ; i++)res=res*i ;
    return res ;
  }
  static long count(String word){
    int freq[]=new int[27];
    for(int i=0 ; i<27 ; i++)freq[i]=0 ;
    long vowel=0,consonant=0 ;
    for(int i=0 ; i<word.length(); i++){
      freq[word.charAt(i)-'A']++;
      if(word.charAt(i)=='A' || word.charAt(i)=='E' || word.charAt(i)=='I' || word.charAt(i)=='O' || word.charAt(i)=='U'){
        vowel++;
      }
      else consonant++;
    }
    long vowelArrange ;
    vowelArrange=factorial(vowel);
    vowelArrange/=factorial(freq[0]);
    vowelArrange/=factorial(freq[4]);
    vowelArrange/=factorial(freq[8]);
    vowelArrange/=factorial(freq[14]);
    vowelArrange/=factorial(freq[20]);
    long consonantArrange ;
    consonantArrange=factorial(consonant);
    for(int i=0 ; i<26 ; i++){
      if(i!=0 && i!=4 && i!=8 && i!=14 && i!=20)consonantArrange/=factorial(freq[i]);
    }
    long total=vowelArrange*consonantArrange ;
    return total ;
  }
  public static void main(String[] args){
    String word="COMPUTER" ;
    long ans=count(word);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation factorial( n : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : int ; i := 1 ; while i <= n do (     res := res * i ;  ;     i := i + 1 ) ; 
     return res );
  static   operation count( word : String) : long
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,27)->collect(0) ;
         var i : int ; i := 0 ; while i < 27 do (     freq[i+1] := 0 ;  ;     i := i + 1 ) ; 
    var vowel : long ; vowel := 0 ;
    var consonant : long ; consonant := 0 ;
        var i : int ; i := 0 ; while i < word->size() do ( (     freq[word->at(i+1) - ('A')->char2byte()+1] := freq[word->at(i+1) - ('A')->char2byte()+1] + 1 ; 
     if (word->at(i+1) = 'A' or word->at(i+1) = 'E' or word->at(i+1) = 'I' or word->at(i+1) = 'O' or word->at(i+1) = 'U') then (     vowel := vowel + 1 ) else     consonant := consonant + 1 ; )  ;     i := i + 1 ) ; 
    var vowelArrange : long ;
    vowelArrange := factorial(vowel) ; 
    vowelArrange := vowelArrange/(factorial(freq[0+1])) ; 
    vowelArrange := vowelArrange/(factorial(freq[4+1])) ; 
    vowelArrange := vowelArrange/(factorial(freq[8+1])) ; 
    vowelArrange := vowelArrange/(factorial(freq[14+1])) ; 
    vowelArrange := vowelArrange/(factorial(freq[20+1])) ; 
    var consonantArrange : long ;
    consonantArrange := factorial(consonant) ; 
        var i : int ; i := 0 ; while i < 26 do ( (     if (i /= 0 & i /= 4 & i /= 8 & i /= 14 & i /= 20) then     consonantArrange := consonantArrange/(factorial(freq[i+1])) ; else skip )  ;     i := i + 1 ) ; 
    var total : long ; total := vowelArrange * consonantArrange ;
    return total 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var word : String ; word := "COMPUTER" ;
     var ans : long ; ans := count(word) ;
     OclFile["System.out"].println(ans) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p037 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p037().run());
  }
  public String run(){
    long sum=0 ;
    for(int count=0,n=10 ; count<11 ; n++){
      if(isTruncatablePrime(n)){
        sum+=n ;
        count++;
      }
    }
    return Long.toString(sum);
  }
  private static boolean isTruncatablePrime(int n){
    for(long i=10 ; i<=n ; i*=10){
      if(! Library.isPrime(n %(int)i))return false ;
    }
    for(; n!=0 ; n/=10){
      if(! Library.isPrime(n))return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p037 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p037.newp037().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var count : int ; count := 0 ;
    var n : int ; n := 10 ; while count < 11 do ( (     if (isTruncatablePrime(n)) then (     sum := sum+(n) ; 
     count := count + 1 ) else skip )  ;     n := n + 1 ) ; 
     return ((sum) + "") );
  static   operation isTruncatablePrime( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : long ; i := 10 ; while i <= n do ( (     if (not(Library.isPrime(n mod i->oclAsType(int)))) then     return false else skip )  ;     i := i*(10) ) ; 
       while n /= 0 do ( (     if (not(Library.isPrime(n))) then     return false else skip )  ;     n := n/(10) ) ; 
     return true );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MahmoudEhabMEX {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),x=in.nextInt(),i,j=0,a[]=new int[101],c=0 ;
    for(i=0 ; i<n ; i++)a[in.nextInt()]++;
    in.close();
    for(i=0 ; i<x ; i++)c+=a[i];
    System.out.println(a[x]==1 ? x-c+1 : x-c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MahmoudEhabMEX {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
    var i : int ;
    var j : int ; j := 0 ;
    var a : Sequence(void) ; a := Integer.subrange(1,101)->collect(0) ;
    var c : int ; c := 0 ;
        i := 0 ; while i < n do (     a[in.getCurrent()->toInteger()+1] := a[in.getCurrent()->toInteger()+1] + 1 ;  ;     i := i + 1 ) ; 
    skip ; 
        i := 0 ; while i < x do (     c := c+(a[i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if a[x+1] = 1 then x - c + 1 else x - c endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAX=1000000 ;
  static int MOD=10000007 ;
  static int[] result=new int[MAX+1];
  static int[] fact=new int[MAX+1];
  static void preCompute(){
    fact[0]=1 ;
    result[0]=1 ;
    for(int i=1 ; i<=MAX ; i++){
      fact[i]=((fact[i-1] % MOD)*i)% MOD ;
      result[i]=((result[i-1] % MOD)*(fact[i] % MOD))% MOD ;
    }
  }
  static void performQueries(int q[],int n){
    preCompute();
    for(int i=0 ; i<n ; i++)System.out.println(result[q[i] ]);
  }
  public static void main(String[] args){
    int q[]={
      4,5 };
      int n=q.length ;
      performQueries(q,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 1000000;
  static   attribute MOD : int := 10000007;
  static   attribute result : Sequence(int) := Integer.subrange(1,MAX + 1)->collect(0);
  static   attribute fact : Sequence(int) := Integer.subrange(1,MAX + 1)->collect(0);
  static   operation preCompute() : void
  pre: true
  post: true
  activity: (     fact[0+1] := 1 ; 
     result[0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= MAX do ( (     fact[i+1] := ((fact[i - 1+1] mod MOD) * i) mod MOD ; 
     result[i+1] := ((result[i - 1+1] mod MOD) * (fact[i+1] mod MOD)) mod MOD )  ;     i := i + 1 ) );
  static   operation performQueries( q : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     execute preCompute() ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].println(result[q[i+1]+1]) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var q : Sequence(int) ; q := Sequence{4,5} ;
     var n : int ; n := q->size() ;
     execute performQueries(q, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int count(int S[],int m,int n){
    if(n==0)return 1 ;
    if(n<0)return 0 ;
    if(m<=0 && n>=1)return 0 ;
    return count(S,m-1,n)+count(S,m,n-S[m-1]);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3 };
      int m=arr.length ;
      System.out.println(count(arr,m,4));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count( S : Sequence(int), m : int, n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     if (n < 0) then     return 0 else skip ; 
     if (m <= 0 & n >= 1) then     return 0 else skip ; 
     return count(S, m - 1, n) + count(S, m, n - S[m - 1+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3} ;
     var m : int ; m := arr->size() ;
     OclFile["System.out"].println(count(arr, m, 4)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int count(int S[],int m,int n){
    if(n==0)return 1 ;
    if(n<0)return 0 ;
    if(m<=0 && n>=1)return 0 ;
    return count(S,m-1,n)+count(S,m,n-S[m-1]);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3 };
      int m=arr.length ;
      System.out.println(count(arr,m,4));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count( S : Sequence(int), m : int, n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     if (n < 0) then     return 0 else skip ; 
     if (m <= 0 & n >= 1) then     return 0 else skip ; 
     return count(S, m - 1, n) + count(S, m, n - S[m - 1+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3} ;
     var m : int ; m := arr->size() ;
     OclFile["System.out"].println(count(arr, m, 4)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MainClass {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    String s=st.nextToken();
    String[] t=new String[5];
    st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<5 ; i++){
      t[i]=st.nextToken();
    }
    HashMap<Character,Integer>map=new HashMap<>();
    map.put(s.charAt(0),1);
    map.put(s.charAt(1),1);
    boolean flag=false ;
    for(int i=0 ; i<5 ; i++){
      String r=t[i];
      char rch=r.charAt(0);
      char gch=r.charAt(1);
      if(map.containsKey(rch)|| map.containsKey(gch)){
        flag=true ;
      }
    }
    if(flag){
      System.out.println("YES");
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var s : String ; s := st.next() ;
    var t : Sequence(String) ; t := Integer.subrange(1,5)->collect(null) ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < 5 do ( (     t[i+1] := st.next() )  ;     i := i + 1 ) ; 
    var map : Map(String,int) ; map := Map{} ;
    map := map->union(Map{s->at(0+1) |-> 1}) ; 
    map := map->union(Map{s->at(1+1) |-> 1}) ; 
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < 5 do ( (     var r : String ; r := t[i+1] ;
     var rch : String ; rch := r->at(0+1) ;
     var gch : String ; gch := r->at(1+1) ;
     if (map->keys()->includes(rch) or map->keys()->includes(gch)) then (     flag := true ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int N=1000005 ;
  static int primeFactors[]=new int[N];
  static void findPrimeFactors(){
    for(int i=2 ; i<N ; i++)if(primeFactors[i]==0)for(int j=i ; j<N ; j+=i)primeFactors[j]=primeFactors[j/i]+1 ;
    for(int i=1 ; i<N ; i++)primeFactors[i]+=primeFactors[i-1];
  }
  public static void main(String[] args){
    findPrimeFactors();
    int a=6,b=3 ;
    System.out.println(primeFactors[a]-primeFactors[b]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 1000005;
  static   attribute primeFactors : int := Integer.subrange(1,N)->collect(0);
  static   operation findPrimeFactors() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i < N do (     if (primeFactors[i+1] = 0) then         var j : int ; j := i ; while j < N do (     primeFactors[j+1] := primeFactors[j / i+1] + 1 ;  ;     j := j+(i) ) ; else skip ;  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i < N do (     primeFactors[i+1] := primeFactors[i+1]+(primeFactors[i - 1+1]) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute findPrimeFactors() ; 
     var a : int ; a := 6 ;
    var b : int ; b := 3 ;
     OclFile["System.out"].println(primeFactors[a+1] - primeFactors[b+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class geneddyAndCardGame800 {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String ontable=sc.next();
    String[] hand=new String[5];
    boolean canPlay=false ;
    for(int i=0 ; i<5 ; i++){
      hand[i]=sc.next();
      if(hand[i] .charAt(0)==ontable.charAt(0)|| hand[i] .charAt(1)==ontable.charAt(1)){
        canPlay=true ;
      }
    }
    if(canPlay)System.out.println("YES");
    else System.out.println("NO");
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class geneddyAndCardGame800 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ontable : String ; ontable := sc.getCurrent() ;
    var hand : Sequence(String) ; hand := Integer.subrange(1,5)->collect(null) ;
    var canPlay : boolean ; canPlay := false ;
        var i : int ; i := 0 ; while i < 5 do ( (     hand[i+1] := sc.getCurrent() ; 
     if (hand[i+1]->at(0+1) = ontable->at(0+1) or hand[i+1]->at(1+1) = ontable->at(1+1)) then (     canPlay := true ) else skip )  ;     i := i + 1 ) ; 
    if (canPlay) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class GennadyCardGame {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String tCard=sc.next();
    for(int i=0 ; i<5 ; i++){
      String hCard=sc.next();
      if(tCard.charAt(1)==hCard.charAt(1)|| tCard.charAt(0)==hCard.charAt(0)||(tCard.charAt(0)=='A' && hCard.charAt(0)=='K')||(tCard.charAt(0)=='A' && hCard.charAt(0)=='A')){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GennadyCardGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tCard : String ; tCard := sc.getCurrent() ;
         var i : int ; i := 0 ; while i < 5 do ( (     var hCard : String ; hCard := sc.getCurrent() ;
     if (tCard->at(1+1) = hCard->at(1+1) or tCard->at(0+1) = hCard->at(0+1) or (tCard->at(0+1) = 'A' & hCard->at(0+1) = 'K') or (tCard->at(0+1) = 'A' & hCard->at(0+1) = 'A')) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("NO") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class CP22 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String n1=sc.nextLine(),n2=sc.nextLine();
    boolean f=false ;
    for(int i=0 ; i<2 ; i++){
      String s=""+n1.charAt(i);
      if(n2.contains(s)){
        f=true ;
      }
    }
    if(f){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CP22 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n1 : String ; n1 := sc.nextLine() ;
    var n2 : String ; n2 := sc.nextLine() ;
    var f : boolean ; f := false ;
        var i : int ; i := 0 ; while i < 2 do ( (     var s : String ; s := "" + n1->at(i+1) ;
     if (n2->includes(s)) then (     f := true ) else skip )  ;     i := i + 1 ) ; 
    if (f) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CodeForces {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String num=input.nextLine();
    System.out.println(num.matches("(1||14||144)+")? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : String ; num := input.nextLine() ;
     OclFile["System.out"].println(if num->isMatch("(1||14||144)+") then "YES" else "NO" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Magic {
  public void input(String s){
    String let="" ;
    boolean b=true ;
    for(int i=0 ; i<s.length(); i++){
      if(let==""){
        if(s.charAt(i)=='1'){
          let+=s.charAt(i);
        }
        else {
          b=false ;
          break ;
        }
      }
      else {
        if(s.charAt(i)=='4'){
          let+=s.charAt(i);
        }
        else if(s.charAt(i)=='1'){
          let="" ;
          let+=s.charAt(i);
        }
        else {
          b=false ;
          break ;
        }
        if(let.equals("144")){
          let="" ;
        }
      }
    }
    if(b==true){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    Magic instance=new Magic();
    String s=input.next();
    instance.input(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Magic {
   operation input( s : String) : void
  pre: true
  post: true
  activity: (     var let : String ; let := "" ;
     var b : boolean ; b := true ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (let = "") then (     if (s->at(i+1) = '1') then (     let := let+(s->at(i+1)) ) else (     b := false ; 
     break ) ) else (     if (s->at(i+1) = '4') then (     let := let+(s->at(i+1)) ) else     if (s->at(i+1) = '1') then (     let := "" ; 
     let := let+(s->at(i+1)) ) else (     b := false ; 
     break ) ;  ;  
     if (let = "144") then (     let := "" ) else skip ) )  ;     i := i + 1 ) ; 
     if (b = true) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var instance : Magic ; instance := Magic.newMagic() ;
     var s : String ; s := input.getCurrent() ;
     instance.input(s) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class D {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0){
      int n=sc.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      Arrays.sort(a);
      long mini=0 ;
      long ans=0 ;
      for(int i=1 ; i<n ; i++){
        long diff=a[i]-a[i-1];
        mini=mini+(-1)*diff*i ;
        ans+=mini ;
      }
      System.out.println(ans+a[n-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var mini : long ; mini := 0 ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     var diff : long ; diff := a[i+1] - a[i - 1+1] ;
     mini := mini + (-1) * diff * i ; 
     ans := ans+(mini) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans + a[n - 1+1]) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class A_Magic_Numbers {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int N=reader.nextInt();
    boolean ans=true ;
    String s=Integer.toString(N);
    int consecutiveFours=0 ;
    for(int i=0 ; i<s.length(); i++){
      char ch=s.charAt(i);
      if((ch!='1' && ch!='4')){
        ans=false ;
        break ;
      }
      else if(ch=='1'){
        consecutiveFours=0 ;
        continue ;
      }
      else {
        consecutiveFours++;
        if(consecutiveFours>2 || i==0){
          ans=false ;
          break ;
        }
      }
    }
    System.out.println(ans==false ? "NO" : "YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Magic_Numbers {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var N : int ; N := reader.nextInt() ;
    var ans : boolean ; ans := true ;
    var s : String ; s := ((N) + "") ;
    var consecutiveFours : int ; consecutiveFours := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var ch : String ; ch := s->at(i+1) ;
     if ((ch /= '1' & ch /= '4')) then (     ans := false ; 
     break ) else     if (ch = '1') then (     consecutiveFours := 0 ; 
     continue ) else (     consecutiveFours := consecutiveFours + 1 ; 
     if (consecutiveFours > 2 or i = 0) then (     ans := false ; 
     break ) else skip ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if ans = false then "NO" else "YES" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  static int MOD=1000000007 ;
  static int[] arr=new int[100001];
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    solve(s);
  }
  public static void solve(Scanner s){
    String str=s.next();
    for(char c : str.toCharArray()){
      if(c!='1' && c!='4'){
        System.out.println("NO");
        return ;
      }
    }
    Set<String>check=new HashSet<>();
    check.add("1");
    check.add("14");
    check.add("144");
    int i=0 ;
    while(i<str.length()){
      if(i<str.length()-2 && check.contains(str.substring(i,i+3))){
        i+=3 ;
      }
      else if(i<str.length()-1 && check.contains(str.substring(i,i+2))){
        i+=2 ;
      }
      else if(check.contains(str.substring(i,i+1))){
        i+=1 ;
      }
      else {
        System.out.println("NO");
        return ;
      }
    }
    if(i==str.length()-2){
      if(! str.substring(i,i+2).equals("14")){
        System.out.println("NO");
        return ;
      }
    }
    if(i==str.length()-1){
      if(! str.substring(i,i+1).equals("1")){
        System.out.println("NO");
        return ;
      }
    }
    System.out.println("YES");
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   attribute MOD : int := 1000000007;
  static   attribute arr : Sequence(int) := Integer.subrange(1,100001)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute solve(s) );
  static   operation solve( s : OclFile) : void
  pre: true
  post: true
  activity: (     var str : String ; str := s.getCurrent() ;
     for (c : str->characters()) do ( (     if (c /= '1' & c /= '4') then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ) ; 
    var check : Set(String) ; check := Set{} ;
    check := check->including("1") ; 
    check := check->including("14") ; 
    check := check->including("144") ; 
    var i : int ; i := 0 ;
    while (i < str->size()) do (     if (i < str->size() - 2 & check->includes(str.subrange(i+1,i + 3))) then (     i := i+(3) ) else     if (i < str->size() - 1 & check->includes(str.subrange(i+1,i + 2))) then (     i := i+(2) ) else     if (check->includes(str.subrange(i+1,i + 1))) then (     i := i+(1) ) else (     OclFile["System.out"].println("NO") ; 
     return ) ;  ;  ) ; 
    if (i = str->size() - 2) then (     if (not(str.subrange(i+1,i + 2) = "14")) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ) else skip ; 
    if (i = str->size() - 1) then (     if (not(str.subrange(i+1,i + 1) = "1")) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ) else skip ; 
    OclFile["System.out"].println("YES") ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  static void minCost(int[] arr,int n){
    int cost=Integer.MAX_VALUE ;
    int element=0 ;
    int XOR=0 ;
    for(int i=0 ; i<n ; i++)XOR ^=arr[i];
    for(int i=0 ; i<n ; i++){
      if(cost>Math.abs((XOR ^ arr[i])-arr[i])){
        cost=Math.abs((XOR ^ arr[i])-arr[i]);
        element=arr[i];
      }
    }
    System.out.println("Element="+element);
    System.out.println("Operation required="+Math.abs(cost));
  }
  public static void main(String[] args){
    int[] arr={
      2,8,4,16 };
      int n=arr.length ;
      minCost(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minCost( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var cost : int ; cost := 2147483647 ;
     var element : int ; element := 0 ;
    var XOR : int ; XOR := 0 ;
        var i : int ; i := 0 ; while i < n do (     XOR := MathLib.bitwiseXor(XOR,arr[i+1]) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (cost > if (MathLib.bitwiseXor(XOR,arr[i+1])) - arr[i+1] < 0 then -((MathLib.bitwiseXor(XOR,arr[i+1])) - arr[i+1]) else (MathLib.bitwiseXor(XOR,arr[i+1])) - arr[i+1] endif) then (     cost := if (MathLib.bitwiseXor(XOR,arr[i+1])) - arr[i+1] < 0 then -((MathLib.bitwiseXor(XOR,arr[i+1])) - arr[i+1]) else (MathLib.bitwiseXor(XOR,arr[i+1])) - arr[i+1] endif ; 
     element := arr[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Element=" + element) ; 
    OclFile["System.out"].println("Operation required=" + if cost < 0 then -(cost) else cost endif) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,8,4,16} ;
     var n : int ; n := arr->size() ;
     execute minCost(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int XorAscii(String str,int len){
    int ans=(str.charAt(0));
    for(int i=1 ; i<len ; i++){
      ans=(ans ^((str.charAt(i))));
    }
    return ans ;
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    int len=str.length();
    System.out.print(XorAscii(str,len)+"\n");
    str="GfG" ;
    len=str.length();
    System.out.print(XorAscii(str,len));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation XorAscii( str : String, len : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := (str->at(0+1)) ;
         var i : int ; i := 1 ; while i < len do ( (     ans := (MathLib.bitwiseXor(ans,((str->at(i+1))))) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var len : int ; len := str->size() ;
    OclFile["System.out"].print(XorAscii(str, len) + "\n") ; 
    str := "GfG" ; 
    len := str->size() ; 
    OclFile["System.out"].print(XorAscii(str, len)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Scanner ;
import java.lang.Math ;
public class JvForces {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int cs=0 ; cs<t ; cs++){
      int n=sc.nextInt();
      TreeMap<Integer,Integer>a=new TreeMap<Integer,Integer>();
      for(int i=1 ; i<=n ; i++){
        int x=sc.nextInt();
        a.put(x,i);
      }
      TreeMap<Integer,Integer>b=new TreeMap<Integer,Integer>();
      for(int i=1 ; i<=n ; i++){
        int x=sc.nextInt();
        b.put(x,i);
      }
      Set<Map.Entry<Integer,Integer>>aent=a.entrySet();
      Set<Map.Entry<Integer,Integer>>bent=b.entrySet();
      int ind=1000000007 ;
      int ans=1000000007 ;
      Iterator<Map.Entry<Integer,Integer>>iterator=aent.iterator();
      Map.Entry<Integer,Integer>temp2=null ;
      for(Map.Entry<Integer,Integer>temp : bent){
        temp2=iterator.next();
        ind=Math.min(temp2.getValue(),ind);
        int anst=temp.getValue()-1 ;
        anst+=ind-1 ;
        ans=Math.min(ans,anst);
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JvForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var cs : int ; cs := 0 ; while cs < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Map(int,int) ; a := Map{} ;
        var i : int ; i := 1 ; while i <= n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     a := a->union(Map{x |-> i}) )  ;     i := i + 1 ) ; 
    var b : Map(int,int) ; b := Map{} ;
        var i : int ; i := 1 ; while i <= n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     b := b->union(Map{x |-> i}) )  ;     i := i + 1 ) ; 
    var aent : Set(Map(int,int)) ; aent := a->asSet() ;
    var bent : Set(Map(int,int)) ; bent := b->asSet() ;
    var ind : int ; ind := 1000000007 ;
    var ans : int ; ans := 1000000007 ;
    var iterator : OclIterator ; iterator := aent->iterator() ;
    var temp2 : Map(int,int) ; temp2 := null ;
    for (temp : bent) do ( (     temp2 := iterator.next() ; 
     ind := Set{temp2->values->any(), ind}->min() ; 
    var anst : int ; anst := temp.getValue() - 1 ;
    anst := anst+(ind - 1) ; 
    ans := Set{ans, anst}->min() ; 
 )  ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     cs := cs + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class pair {
    int first,second ;
    public pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static void init(int degree[],pair[] edges,int n){
    for(int i=0 ; i<n ; i++){
      degree[i]=0 ;
    }
    for(int i=0 ; i<edges.length ; i++){
      degree[edges[i] .first]++;
      degree[edges[i] .second]++;
    }
  }
  static void performQueries(pair[] edges,int[] q,int n){
    int[] degree=new int[n];
    init(degree,edges,n);
    for(int i=0 ; i<q.length ; i++){
      int node=q[i];
      if(node==0){
        System.out.println("No");
        continue ;
      }
      if(degree[node]==1)System.out.println("Yes");
      else System.out.println("No");
    }
  }
  public static void main(String[] args){
    int n=6 ;
    pair[] edges={
      new pair(0,1),new pair(0,2),new pair(1,3),new pair(1,4),new pair(4,5)};
      int[] q={
        0,3,4,5 };
        performQueries(edges,q,n);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class pair {
   attribute first : int;
   static operation newpair( first : int, second : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation init( degree : Sequence(int), edges : Sequence(pair), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     degree[i+1] := 0 )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < edges->size() do ( (     degree[edges[i+1]->at("first")+1] := degree[edges[i+1]->at("first")+1] + 1 ; 
     degree[edges[i+1]->at("second")+1] := degree[edges[i+1]->at("second")+1] + 1 )  ;     i := i + 1 ) );
  static   operation performQueries( edges : Sequence(pair), q : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var degree : Sequence(int) ; degree := Integer.subrange(1,n)->collect(0) ;
     execute init(degree, edges, n) ; 
         var i : int ; i := 0 ; while i < q->size() do ( (     var node : int ; node := q[i+1] ;
     if (node = 0) then (     OclFile["System.out"].println("No") ; 
     continue ) else skip ; 
     if (degree[node+1] = 1) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     var edges : Sequence(pair) ; edges := Sequence{pair.newpair(0, 1),pair.newpair(0, 2),pair.newpair(1, 3),pair.newpair(1, 4),pair.newpair(4, 5)} ;
     var q : Sequence(int) ; q := Sequence{0,3,4,5} ;
     execute performQueries(edges, q, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Solution {
  static void printArray(int arr[],int n){
    Arrays.sort(arr);
    int l=0,r=n-1,flag=0,i ;
    int k=2 ;
    while(l<=r){
      if(flag==0){
        for(i=l ; i<l+k && i<=r ; i++)System.out.print(arr[i]+" ");
        flag=1 ;
        l=i ;
      }
      else {
        for(i=r ; i>r-k && i>=l ; i--)System.out.print(arr[i]+" ");
        flag=0 ;
        r=i ;
      }
      k++;
    }
  }
  public static void main(String args[]){
    int n=6 ;
    int arr[]={
      1,2,3,4,5,6 };
      printArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation printArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var l : int ; l := 0 ;
    var r : int ; r := n - 1 ;
    var flag : int ; flag := 0 ;
    var i : int ;
     var k : int ; k := 2 ;
     while (l <= r) do (     if (flag = 0) then (         i := l ; while i < l + k & i <= r do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
     flag := 1 ; 
     l := i ) else (         i := r ; while i > r - k & i >= l do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i - 1 ) ; 
     flag := 0 ; 
     r := i ) ;  
     k := k + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6} ;
     execute printArray(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int MAX=1000 ;
  static int f[]=new int[MAX];
  static int fib(int n){
    Arrays.fill(f,0);
    if(n==0)return 0 ;
    if(n==1 || n==2)return(f[n]=1);
    if(f[n]==1)return f[n];
    int k ;
    if((n & 1)==1)k=(n+1)/2 ;
    else k=n/2 ;
    if((n & 1)==1)f[n]=(fib(k)*fib(k)+fib(k-1)*fib(k-1));
    else f[n]=(2*fib(k-1)+fib(k))*fib(k);
    return f[n];
  }
  static int calculateSum(int n){
    return fib(n+2)-1 ;
  }
  public static void main(String args[]){
    int n=4 ;
    System.out.println("Sum of Fibonacci numbers is : "+calculateSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 1000;
  static   attribute f : int := Integer.subrange(1,MAX)->collect(0);
  static   operation fib( n : int) : int
  pre: true
  post: true
  activity: (     f := f->collect(0) ; 
     if (n = 0) then     return 0 else skip ; 
    if (n = 1 or n = 2) then     return (f[n+1]) else skip ; 
    if (f[n+1] = 1) then     return f[n+1] else skip ; 
    var k : int ;
    if ((n & 1) = 1) then     k := (n + 1) / 2 else     k := n / 2 ; ;  
    if ((n & 1) = 1) then     f[n+1] := (fib(k) * fib(k) + fib(k - 1) * fib(k - 1)) else     f[n+1] := (2 * fib(k - 1) + fib(k)) * fib(k) ; ;  
    return f[n+1] 
 );
  static   operation calculateSum( n : int) : int
  pre: true
  post: true
  activity: (     return fib(n + 2) - 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println("Sum of Fibonacci numbers is : " + calculateSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class c {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int tc=sc.nextInt();
    while(tc-->0){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      if(n==1)System.out.println(0);
      else {
        Arrays.sort(a);
        long[] cnt=new long[n-1];
        for(int i=0 ; i<n-1 ; i++)cnt[i]=a[i+1]-a[i];
        long ans=0L ;
        for(int i=0 ; i<n-1 ; i++)ans-=(cnt[i]*(i+1)*(n-i-1));
        for(long c : cnt)ans+=c ;
        System.out.println(ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class c {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var tc : int ; tc := sc.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     if (n = 1) then     OclFile["System.out"].println(0) ; else (     a := a->sort() ; 
     var cnt : Sequence(long) ; cnt := Integer.subrange(1,n - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n - 1 do (     cnt[i+1] := a[i + 1+1] - a[i+1] ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0L ;
        var i : int ; i := 0 ; while i < n - 1 do (     ans := ans-((cnt[i+1] * (i + 1) * (n - i - 1))) ;  ;     i := i + 1 ) ; 
    for (c : cnt) do (     ans := ans+(c) ;  ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args)throws Exception {
    String str=sc.next();
    int wPos=str.indexOf('w');
    String pre=str.substring(0,wPos-1);
    String suf=str.substring(wPos+2);
    int[][] dp=new int[pre.length()+1][suf.length()+1];
    for(int i=1 ; i<=pre.length(); ++i){
      for(int j=1 ; j<=suf.length(); ++j){
        dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
        if(syn(pre.charAt(i-1),suf.charAt(suf.length()-j))){
          dp[i][j]=Math.max(dp[i][j],dp[i-1][j-1]+2);
        }
      }
    }
    System.out.println(dp[pre.length()][suf.length()]+3);
  }
  static boolean syn(char c1,char c2){
    if(c1=='(' && c2==')'){
      return true ;
    }
    if(c1==')' && c2=='('){
      return true ;
    }
    if(c1=='{' && c2=='}'){
      return true ;
    }
    if(c1=='}' && c2=='{'){
      return true ;
    }
    if(c1=='[' && c2==']'){
      return true ;
    }
    if(c1==']' && c2=='['){
      return true ;
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := sc.getCurrent() ;
     var wPos : int ; wPos := str->indexOf('w')-1 ;
    var pre : String ; pre := str.subrange(0+1,(wPos)->char2byte() - 1) ;
    var suf : String ; suf := str.subrange(wPos + 2+1,wPos + 2) ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,pre->size() + 1)->collect(Integer.subrange(1,suf->size() + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= pre->size() do ( (         var j : int ; j := 1 ; while j <= suf->size() do ( (     dp[i+1][j+1] := Set{dp[i - 1+1][j+1], dp[i+1][j - 1+1]}->max() ; 
     if (syn(pre->at(i - 1+1), suf->at(suf->size() - j+1))) then (     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i - 1+1][j - 1+1] + 2}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[pre->size()+1][suf->size()+1] + 3) ; 
 );
  static   operation syn( c1 : String, c2 : String) : boolean
  pre: true
  post: true
  activity: (     if (c1 = '(' & c2 = ')') then (     return true ) else skip ; 
     if (c1 = ')' & c2 = '(') then (     return true ) else skip ; 
    if (c1 = '{' & c2 = '}') then (     return true ) else skip ; 
    if (c1 = '}' & c2 = '{') then (     return true ) else skip ; 
    if (c1 = '[' & c2 = ']') then (     return true ) else skip ; 
    if (c1 = ']' & c2 = '[') then (     return true ) else skip ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static char[] arr ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    arr=sc.next().toCharArray();
    System.out.println(getLength(0,arr.length-1));
  }
  static int getLength(int left,int right){
    if(arr[left]=='i' || arr[right]=='i'){
      return 3 ;
    }
    if(arr[left]=='('){
      if(arr[right]==')'){
        return getLength(left+1,right-1)+2 ;
      }
    }
    else if(arr[left]=='{'){
      if(arr[right]=='}'){
        return getLength(left+1,right-1)+2 ;
      }
    }
    else if(arr[left]=='['){
      if(arr[right]==']'){
        return getLength(left+1,right-1)+2 ;
      }
    }
    else if(arr[left]==')'){
      if(arr[right]=='('){
        return getLength(left+1,right-1)+2 ;
      }
    }
    else if(arr[left]=='}'){
      if(arr[right]=='{'){
        return getLength(left+1,right-1)+2 ;
      }
    }
    else if(arr[left]==']'){
      if(arr[right]=='['){
        return getLength(left+1,right-1)+2 ;
      }
    }
    return Math.max(getLength(left+1,right),getLength(left,right-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute arr : Sequence(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     arr := sc.getCurrent()->characters() ; 
     OclFile["System.out"].println(getLength(0, arr->size() - 1)) );
  static   operation getLength( left : int, right : int) : int
  pre: true
  post: true
  activity: (     if (arr[left+1] = 'i' or arr[right+1] = 'i') then (     return 3 ) else skip ; 
     if (arr[left+1] = '(') then (     if (arr[right+1] = ')') then (     return getLength(left + 1, right - 1) + 2 ) else skip ) else     if (arr[left+1] = '{') then (     if (arr[right+1] = '}') then (     return getLength(left + 1, right - 1) + 2 ) else skip ) else     if (arr[left+1] = '[') then (     if (arr[right+1] = ']') then (     return getLength(left + 1, right - 1) + 2 ) else skip ) else     if (arr[left+1] = ')') then (     if (arr[right+1] = '(') then (     return getLength(left + 1, right - 1) + 2 ) else skip ) else     if (arr[left+1] = '}') then (     if (arr[right+1] = '{') then (     return getLength(left + 1, right - 1) + 2 ) else skip ) else     if (arr[left+1] = ']') then (     if (arr[right+1] = '[') then (     return getLength(left + 1, right - 1) + 2 ) else skip ) else skip ; ;  ;  ;  ;  ;  
     return Set{getLength(left + 1, right), getLength(left, right - 1)}->max() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isDivisibleby17(int n){
    if(n==0 || n==17)return true ;
    if(n<17)return false ;
    return isDivisibleby17((int)(n>>4)-(int)(n & 15));
  }
  public static void main(String[] args){
    int n=35 ;
    if(isDivisibleby17(n)==true)System.out.printf("%d is divisible by 17",n);
    else System.out.printf("%d is not divisible by 17",n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isDivisibleby17( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 0 or n = 17) then     return true else skip ; 
     if (n < 17) then     return false else skip ; 
     return isDivisibleby17(((n/(2->pow(4)))->oclAsType(long))->oclAsType(int) - (MathLib.bitwiseAnd(n,15))->oclAsType(int)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 35 ;
     if (isDivisibleby17(n) = true) then     OclFile["System.out"].printf("%d is divisible by 17", n) ; else     OclFile["System.out"].printf("%d is not divisible by 17", n) ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long squareSum(long N){
    long sum=(long)(N*(N+1)*(2*N+1))/6 ;
    return sum ;
  }
  static long findMaxN(long X){
    long low=1,high=100000 ;
    int N=0 ;
    while(low<=high){
      long mid=(high+low)/2 ;
      if(squareSum(mid)<=X){
        N=(int)mid ;
        low=mid+1 ;
      }
      else high=mid-1 ;
    }
    return N ;
  }
  public static void main(String[] args){
    long X=25 ;
    System.out.println(findMaxN(X));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation squareSum( N : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := (N * (N + 1) * (2 * N + 1))->oclAsType(long) / 6 ;
     return sum );
  static   operation findMaxN( X : long) : long
  pre: true
  post: true
  activity: (     var low : long ; low := 1 ;
    var high : long ; high := 100000 ;
     var N : int ; N := 0 ;
     while (low <= high) do (     var mid : long ; mid := (high + low) / 2 ;
     if (squareSum(mid) <= X) then (     N := mid->oclAsType(int) ; 
     low := mid + 1 ) else     high := mid - 1 ; ) ; 
     return N );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : long ; X := 25 ;
     OclFile["System.out"].println(findMaxN(X)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    System.out.println("thu:fri:sat:sun:mon:tue:wed".split(":")[sc.nextInt()% 7]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println("thu:fri:sat:sun:mon:tue:wed"->split(":")[sc.getCurrent()->toInteger() mod 7+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ProblemD2 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    int[] result=new int[t];
    for(int i=0 ; i<t ; i++){
      int n=in.nextInt();
      int[] order=new int[2*n+1];
      for(int j=0 ; j<n ; j++){
        order[in.nextInt()]=j ;
      }
      for(int j=0 ; j<n ; j++){
        order[in.nextInt()]=j ;
      }
      result[i]=Integer.MAX_VALUE ;
      int l=n-1 ;
      for(int j=2*n ; j>0 ; j--){
        if(j % 2==1){
          result[i]=Math.min(result[i],order[j]+l);
        }
        else {
          l=Math.min(l,order[j]);
        }
      }
    }
    for(int i=0 ; i<t ; i++){
      System.out.println(result[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemD2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var result : Sequence(int) ; result := Integer.subrange(1,t)->collect(0) ;
        var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var order : Sequence(int) ; order := Integer.subrange(1,2 * n + 1)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     order[in.getCurrent()->toInteger()+1] := j )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     order[in.getCurrent()->toInteger()+1] := j )  ;     j := j + 1 ) ; 
    result[i+1] := 2147483647 ; 
    var l : int ; l := n - 1 ;
        var j : int ; j := 2 * n ; while j > 0 do ( (     if (j mod 2 = 1) then (     result[i+1] := Set{result[i+1], order[j+1] + l}->min() ) else (     l := Set{l, order[j+1]}->min() ) )  ;     j := j - 1 ) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < t do ( (     OclFile["System.out"].println(result[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      int x=Integer.parseInt(reader.readLine());
      if(x==1 || x==8 || x==15 || x==22 || x==29){
        System.out.println("fri");
      }
      else if(x==2 || x==9 || x==16 || x==23 || x==30){
        System.out.println("sat");
      }
      else if(x==3 || x==10 || x==17 || x==24 || x==31){
        System.out.println("sun");
      }
      else if(x==4 || x==11 || x==18 || x==25){
        System.out.println("mon");
      }
      else if(x==5 || x==12 || x==19 || x==26){
        System.out.println("tue");
      }
      else if(x==6 || x==13 || x==20 || x==27){
        System.out.println("wed");
      }
      else if(x==7 || x==14 || x==21 || x==28){
        System.out.println("thu");
      }
      reader.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  static int gcd(int a,int b){
    return b>0 ? gcd(b,a % b): a ;
  }
  static int lcm(int a,int b){
    return a*b/gcd(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var x : int ; x := (reader.readLine())->toInteger() ;
     if (x = 1 or x = 8 or x = 15 or x = 22 or x = 29) then (     OclFile["System.out"].println("fri") ) else     if (x = 2 or x = 9 or x = 16 or x = 23 or x = 30) then (     OclFile["System.out"].println("sat") ) else     if (x = 3 or x = 10 or x = 17 or x = 24 or x = 31) then (     OclFile["System.out"].println("sun") ) else     if (x = 4 or x = 11 or x = 18 or x = 25) then (     OclFile["System.out"].println("mon") ) else     if (x = 5 or x = 12 or x = 19 or x = 26) then (     OclFile["System.out"].println("tue") ) else     if (x = 6 or x = 13 or x = 20 or x = 27) then (     OclFile["System.out"].println("wed") ) else     if (x = 7 or x = 14 or x = 21 or x = 28) then (     OclFile["System.out"].println("thu") ) else skip ; ;  ;  ;  ;  ;  ;  
     skip )   catch (e : IOException) do (     e.printStackTrace() )
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b > 0 then gcd(b, a mod b) else a endif );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return a * b / gcd(a, b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=(x-9)% 7 ;
    if(y<0){
      y+=7 ;
    }
    switch(y){
      case 0 : System.out.println("sat");
      break ;
      case 1 : System.out.println("sun");
      break ;
      case 2 : System.out.println("mon");
      break ;
      case 3 : System.out.println("tue");
      break ;
      case 4 : System.out.println("wed");
      break ;
      case 5 : System.out.println("thu");
      break ;
      case 6 : System.out.println("fri");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := (x - 9) mod 7 ;
    if (y < 0) then (     y := y+(7) ) else skip ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (y) ; 
       if _switchval = 0 then
     OclFile["System.out"].println("sat") ; 
    break 
   else skip ;
       if _switchval = 1 then
     OclFile["System.out"].println("sun") ; 
    break 
   else skip ;
       if _switchval = 2 then
     OclFile["System.out"].println("mon") ; 
    break 
   else skip ;
       if _switchval = 3 then
     OclFile["System.out"].println("tue") ; 
    break 
   else skip ;
       if _switchval = 4 then
     OclFile["System.out"].println("wed") ; 
    break 
   else skip ;
       if _switchval = 5 then
     OclFile["System.out"].println("thu") ; 
    break 
   else skip ;
       if _switchval = 6 then
     OclFile["System.out"].println("fri") ; 
   else skip ;
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  static IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static IntStream REPS(int l,int r){
    return IntStream.rangeClosed(l,r);
  }
  static IntStream INS(int n){
    return REPS(n).map(i->getInt());
  }
  static Scanner s=new Scanner(System.in);
  static int getInt(){
    return Integer.parseInt(s.next());
  }
  public static void main(String[] $){
    String[] d={
      "mon","tue","wed","thu","fri","sat","sun" };
      System.out.println(d[(getInt()+3)% 7]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static   operation REPS( l : int, r : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(l, r) );
  static   operation INS( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return REPS(n)->collect( _x1 | (lambda i : OclAny in getInt())->apply(_x1) ) );
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : Sequence(String) ; d := Sequence{"mon","tue","wed","thu","fri","sat","sun"} ;
     OclFile["System.out"].println(d[(getInt() + 3) mod 7+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.time.LocalDate ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    LocalDate ld=LocalDate.of(2017,9,sc.nextInt());
    switch(ld.getDayOfWeek()){
      case FRIDAY : System.out.println("fri");
      break ;
      case MONDAY : System.out.println("mon");
      break ;
      case SATURDAY : System.out.println("sat");
      break ;
      case SUNDAY : System.out.println("sun");
      break ;
      case THURSDAY : System.out.println("thu");
      break ;
      case TUESDAY : System.out.println("tue");
      break ;
      case WEDNESDAY : System.out.println("wed");
      break ;
      default : break ;
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ld : LocalDate ; ld := LocalDate.of(2017, 9, sc.getCurrent()->toInteger()) ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (ld.getDayOfWeek()) ; 
       if _switchval = FRIDAY then
     OclFile["System.out"].println("fri") ; 
    break 
   else skip ;
       if _switchval = MONDAY then
     OclFile["System.out"].println("mon") ; 
    break 
   else skip ;
       if _switchval = SATURDAY then
     OclFile["System.out"].println("sat") ; 
    break 
   else skip ;
       if _switchval = SUNDAY then
     OclFile["System.out"].println("sun") ; 
    break 
   else skip ;
       if _switchval = THURSDAY then
     OclFile["System.out"].println("thu") ; 
    break 
   else skip ;
       if _switchval = TUESDAY then
     OclFile["System.out"].println("tue") ; 
    break 
   else skip ;
       if _switchval = WEDNESDAY then
     OclFile["System.out"].println("wed") ; 
    break 
   else skip ;
       if true then
     break 
   else skip ;
 )
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    while(s.hasNext()){
      int[] l={
        1,2,3,4,5,6,7,8,9,10 };
        int[] a=new int[3];
        for(int i=0 ; i<3 ; i++)a[i]=s.nextInt();
        for(int i=0 ; i<10 ; i++){
          if(a[0]==l[i] || a[1]==l[i] || a[2]==l[i])l[i]=100 ;
        }
        int b=0 ;
        for(int i=0 ; i<10 ; i++){
          if(l[i]<=20-a[0]-a[1])b++;
        }
        if(b>3)System.out.println("YES");
        else System.out.println("NO");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (s.hasNext()) do (     var l : Sequence(int) ; l := Sequence{1,2,3,4,5,6,7,8,9,10} ;
     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do (     a[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 10 do ( (     if (a[0+1] = l[i+1] or a[1+1] = l[i+1] or a[2+1] = l[i+1]) then     l[i+1] := 100 ; else skip )  ;     i := i + 1 ) ; 
    var b : int ; b := 0 ;
        var i : int ; i := 0 ; while i < 10 do ( (     if (l[i+1] <= 20 - a[0+1] - a[1+1]) then     b := b + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (b > 3) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class AQW {
  static int fib[]=new int[43];
  static void fibonacci(){
    fib[0]=1 ;
    fib[1]=2 ;
    for(int i=2 ; i<43 ; i++)fib[i]=fib[i-1]+fib[i-2];
  }
  static int rec(int x,int y,int last){
    if(y==0){
      if(x==0)return 1 ;
      return 0 ;
    }
    int sum=0 ;
    for(int i=last ; i>=0 && fib[i]*y>=x ; i--){
      if(fib[i]>x)continue ;
      sum+=rec(x-fib[i],y-1,i);
    }
    return sum ;
  }
  public static void main(String[] args){
    fibonacci();
    int n=13,k=3 ;
    System.out.println("Possible ways are: "+rec(n,k,42));
  }
}
------------------------------------------------------------
OCL File:
---------
class AQW {
  static   attribute fib : int := Integer.subrange(1,43)->collect(0);
  static   operation fibonacci() : void
  pre: true
  post: true
  activity: (     fib[0+1] := 1 ; 
     fib[1+1] := 2 ; 
         var i : int ; i := 2 ; while i < 43 do (     fib[i+1] := fib[i - 1+1] + fib[i - 2+1] ;  ;     i := i + 1 ) );
  static   operation rec( x : int, y : int, last : int) : int
  pre: true
  post: true
  activity: (     if (y = 0) then (     if (x = 0) then     return 1 else skip ; 
     return 0 ) else skip ; 
     var sum : int ; sum := 0 ;
         var i : int ; i := last ; while i >= 0 & fib[i+1] * y >= x do ( (     if (fib[i+1] > x) then     continue else skip ; 
     sum := sum+(rec(x - fib[i+1], y - 1, i)) )  ;     i := i - 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute fibonacci() ; 
     var n : int ; n := 13 ;
    var k : int ; k := 3 ;
     OclFile["System.out"].println("Possible ways are: " + rec(n, k, 42)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class B_Summer_sell_off {
  public static void main(String[] args){
    long sum=0 ;
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),f=in.nextInt();
    Day[] plan=new Day[n];
    while(n-->0){
      plan[n]=new Day();
      plan[n] .products=in.nextInt();
      plan[n] .customers=in.nextInt();
    }
    Arrays.sort(plan);
    for(Day day : plan){
      if(f-->0){
        sum+=day.soldProductsInSellOut();
      }
      else sum+=day.soldProducts();
    }
    System.out.println(sum);
  }
}
class Day implements Comparable<Day>{
  int products,customers ;
  @ Override public int compareTo(Day day){
    long temp1=this.soldProductsInSellOut()-this.soldProducts(),temp2=day.soldProductsInSellOut()-day.soldProducts();
    if(temp1>temp2)return-1 ;
    else if(temp1<temp2)return 1 ;
    return 0 ;
  }
  int soldProducts(){
    return Math.min(this.products,customers);
  }
  int soldProductsInSellOut(){
    return Math.min(this.products*2,customers);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Summer_sell_off {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var f : int ; f := in.getCurrent()->toInteger() ;
    var plan : Sequence(Day) ; plan := Integer.subrange(1,n)->collect(null) ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     plan[n+1] := Day.newDay() ; 
     plan[n+1].products := in.getCurrent()->toInteger() ; 
     plan[n+1].customers := in.getCurrent()->toInteger() ) ;  ) ;  
    plan := plan->sort() ; 
    for (day : plan) do ( (     if (f > 0) then (     sum := sum+(day.soldProductsInSellOut()) ) else     sum := sum+(day.soldProducts()) ; )  ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}
class Day implements Comparable<Day> {
   attribute products : int;
      operation compareTo( day : Day) : int
  pre: true
  post: true
  activity: (     var temp1 : long ; temp1 := self.soldProductsInSellOut() - self.soldProducts() ;
    var temp2 : long ; temp2 := day.soldProductsInSellOut() - day.soldProducts() ;
     if (temp1 > temp2) then     return -1 else     if (temp1 < temp2) then     return 1 else skip ; ;  
     return 0 );
   operation soldProducts() : int
  pre: true
  post: true
  activity: (     return Set{self.products, customers}->min() );
   operation soldProductsInSellOut() : int
  pre: true
  post: true
  activity: (     return Set{self.products * 2, customers}->min() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean sameLength(int A,int B){
    while((A>0)&&(B>0)){
      A=A/10 ;
      B=B/10 ;
    }
    if((A==0)&&(B==0))return true ;
    return false ;
  }
  public static void main(String[] args){
    int A=21,B=1 ;
    if(sameLength(A,B))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sameLength( A : int, B : int) : boolean
  pre: true
  post: true
  activity: (     while ((A > 0) & (B > 0)) do (     A := A / 10 ; 
     B := B / 10 ) ; 
     if ((A = 0) & (B = 0)) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 21 ;
    var B : int ; B := 1 ;
     if (sameLength(A, B)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minimumAdjacentDifference(int a[],int n,int k){
    int minDiff=Integer.MAX_VALUE ;
    for(int i=0 ; i<=k ; i++){
      int maxDiff=Integer.MIN_VALUE ;
      for(int j=0 ; j<n-k-1 ; j++){
        for(int p=i ; p<=i+j ; p++){
          maxDiff=Math.max(maxDiff,a[p+1]-a[p]);
        }
      }
      minDiff=Math.min(minDiff,maxDiff);
    }
    return minDiff ;
  }
  public static void main(String[] args){
    int n=5 ;
    int k=2 ;
    int[] a={
      3,7,8,10,14 };
      System.out.println(minimumAdjacentDifference(a,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minimumAdjacentDifference( a : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var minDiff : int ; minDiff := 2147483647 ;
         var i : int ; i := 0 ; while i <= k do ( (     var maxDiff : int ; maxDiff := -2147483648 ;
         var j : int ; j := 0 ; while j < n - k - 1 do ( (         var p : int ; p := i ; while p <= i + j do ( (     maxDiff := Set{maxDiff, a[p + 1+1] - a[p+1]}->max() )  ;     p := p + 1 ) )  ;     j := j + 1 ) ; 
     minDiff := Set{minDiff, maxDiff}->min() )  ;     i := i + 1 ) ; 
     return minDiff );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var k : int ; k := 2 ;
     var a : Sequence(int) ; a := Sequence{3,7,8,10,14} ;
     OclFile["System.out"].println(minimumAdjacentDifference(a, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=1 ;
    for(int itr=0 ; itr<t ; ++itr){
      int n=in.nextInt();
      long maxx=Long.MIN_VALUE ;
      long minx=Long.MAX_VALUE ;
      long maxy=Long.MIN_VALUE ;
      long miny=Long.MAX_VALUE ;
      for(int i=0 ; i<n ; ++i){
        long x=in.nextLong();
        long y=in.nextLong();
        maxx=Math.max(x,maxx);
        minx=Math.min(x,minx);
        maxy=Math.max(y,maxy);
        miny=Math.min(y,miny);
      }
      long m=Math.max(1,(Math.max(maxx-minx,maxy-miny)));
      System.out.println(1l*m*m);
    }
  }
  private static int gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    if(a==b)return a ;
    if(a>b)return gcd(a-b,b);
    return gcd(a,b-a);
  }
}
class Pair implements Comparable<Pair>{
  int fi,se ;
  Pair(int fi,int se){
    this.fi=fi ;
    this.se=se ;
  }
  public int compareTo(Pair p){
    return this.fi-p.fi ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
         var itr : int ; itr := 0 ; while itr < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var maxx : long ; maxx := "-9223372036854775808"->toLong() ;
    var minx : long ; minx := "9223372036854775807"->toLong() ;
    var maxy : long ; maxy := "-9223372036854775808"->toLong() ;
    var miny : long ; miny := "9223372036854775807"->toLong() ;
        var i : int ; i := 0 ; while i < n do ( (     var x : long ; x := in.getCurrent()->toLong() ;
     var y : long ; y := in.getCurrent()->toLong() ;
    maxx := Set{x, maxx}->max() ; 
    minx := Set{x, minx}->min() ; 
    maxy := Set{y, maxy}->max() ; 
    miny := Set{y, miny}->min() ; 
 )  ;     i := i + 1 ) ; 
    var m : long ; m := Set{1, (Set{maxx - minx, maxy - miny}->max())}->max() ;
    OclFile["System.out"].println(1l * m * m) ; 
 )  ;     itr := itr + 1 ) );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
    if (a = b) then     return a else skip ; 
    if (a > b) then     return gcd(a - b, b) else skip ; 
    return gcd(a, b - a) 
 );
}
class Pair implements Comparable<Map> {
   attribute fi : int;
   static operation newPair( fi : int, se : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(fi, se);
    return self );
  operation initialise( fi : int, se : int) : void
  pre: true  post: true
  activity: (     self.fi := fi ; 
     self.se := se );
   operation compareTo( p : Map) : int
  pre: true
  post: true
  activity: (     return self.fi - p.fi );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isSubSequence(String str1,String str2){
    int m=str1.length(),n=str2.length();
    int j=0 ;
    for(int i=0 ; i<n && j<m ; i++){
      if(str1.charAt(j)==str2.charAt(i)){
        j++;
      }
    }
    return(j==m);
  }
  static String findLongestString(Vector<String>dict,String str){
    String result="" ;
    int length=0 ;
    for(String word : dict){
      if(length<word.length()&& isSubSequence(word,str)){
        result=word ;
        length=word.length();
      }
    }
    return result ;
  }
  public static void main(String[] args){
    String[] arr={
      "ale","apple","monkey","plea" };
      Vector dict=new Vector(Arrays.asList(arr));
      String str="abpcplea" ;
      System.out.println(findLongestString(dict,str));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isSubSequence( str1 : String, str2 : String) : boolean
  pre: true
  post: true
  activity: (     var m : int ; m := str1->size() ;
    var n : int ; n := str2->size() ;
     var j : int ; j := 0 ;
         var i : int ; i := 0 ; while i < n & j < m do ( (     if (str1->at(j+1) = str2->at(i+1)) then (     j := j + 1 ) else skip )  ;     i := i + 1 ) ; 
     return (j = m) );
  static   operation findLongestString( dict : Sequence(String), str : String) : String
  pre: true
  post: true
  activity: (     var result : String ; result := "" ;
     var length : int ; length := 0 ;
     for (word : dict) do ( (     if (length < word->size() & isSubSequence(word, str)) then (     result := word ; 
     length := word->size() ) else skip )  ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"ale","apple","monkey","plea"} ;
     var dict : Sequence ; dict := Sequence{}->union(arr) ;
     var str : String ; str := "abpcplea" ;
     OclFile["System.out"].println(findLongestString(dict, str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int __gcd(int a,int b){
    return b==0 ? a : __gcd(b,a % b);
  }
  static void solveProportion(int a,int b1,int b2,int c){
    int A=a*b2 ;
    int B=b1*b2 ;
    int C=b1*c ;
    int gcd=__gcd(__gcd(A,B),C);
    System.out.print(A/gcd+":"+B/gcd+":"+C/gcd);
  }
  public static void main(String args[]){
    int a,b1,b2,c ;
    a=3 ;
    b1=4 ;
    b2=8 ;
    c=9 ;
    solveProportion(a,b1,b2,c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else __gcd(b, a mod b) endif );
  static   operation solveProportion( a : int, b1 : int, b2 : int, c : int) : void
  pre: true
  post: true
  activity: (     var A : int ; A := a * b2 ;
     var B : int ; B := b1 * b2 ;
    var C : int ; C := b1 * c ;
    var gcd : int ; gcd := __gcd(__gcd(A, B), C) ;
    OclFile["System.out"].print(A / gcd + ":" + B / gcd + ":" + C / gcd) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ;
    var b1 : int ;
    var b2 : int ;
    var c : int ;
     a := 3 ; 
    b1 := 4 ; 
    b2 := 8 ; 
    c := 9 ; 
    execute solveProportion(a, b1, b2, c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int n,res ;
  int[] now,ans ;
  void f(int k,int cnt){
    if(res<=cnt)return ;
    if(k==n){
      res=cnt ;
      return ;
    }
    if(now[k]==ans[k])f(k+1,cnt);
    else {
      int dif=ans[k]-now[k];
      if(dif<0)dif+=10 ;
      for(int j=k ; j<n ; j++){
        now[j]=(now[j]+dif)% 10 ;
        f(k+1,cnt+1);
      }
      for(int j=k ; j<n ; j++)now[j]=(now[j]+10-dif)% 10 ;
    }
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      n=sc.nextInt();
      if(n==0)break ;
      now=new int[n];
      ans=new int[n];
      char[] s=sc.next().toCharArray();
      for(int i=0 ; i<n ; i++)now[i]=s[i]-'0' ;
      s=sc.next().toCharArray();
      for(int i=0 ; i<n ; i++)ans[i]=s[i]-'0' ;
      res=n ;
      f(0,0);
      System.out.println(res);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute now : Sequence(int);
   operation f( k : int, cnt : int) : void
  pre: true
  post: true
  activity: (     if (res <= cnt) then     return else skip ; 
     if (k = n) then (     res := cnt ; 
     return ) else skip ; 
     if (now[k+1] = ans[k+1]) then     execute f(k + 1, cnt) ; else (     var dif : int ; dif := ans[k+1] - now[k+1] ;
     if (dif < 0) then     dif := dif+(10) ; else skip ; 
         var j : int ; j := k ; while j < n do ( (     now[j+1] := (now[j+1] + dif) mod 10 ; 
     execute f(k + 1, cnt + 1) )  ;     j := j + 1 ) ; 
         var j : int ; j := k ; while j < n do (     now[j+1] := (now[j+1] + 10 - dif) mod 10 ;  ;     j := j + 1 ) ) );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
    now := Integer.subrange(1,n)->collect(0) ; 
    ans := Integer.subrange(1,n)->collect(0) ; 
    var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
        var i : int ; i := 0 ; while i < n do (     now[i+1] := s[i+1] - ('0')->char2byte() ;  ;     i := i + 1 ) ; 
    s := sc.getCurrent()->characters() ; 
        var i : int ; i := 0 ; while i < n do (     ans[i+1] := s[i+1] - ('0')->char2byte() ;  ;     i := i + 1 ) ; 
    res := n ; 
    execute f(0, 0) ; 
    OclFile["System.out"].println(res) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int n=input.nextInt();
    String s=input.next()+"a" ;
    int count=0 ;
    long ans=0 ;
    for(int i=0 ; i<n+1 ; i++){
      if(s.charAt(i)=='x'){
        count++;
      }
      else {
        ans+=Math.max(0,count-2);
        count=0 ;
      }
    }
    System.out.println(ans);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var n : int ; n := input.nextInt() ;
    var s : String ; s := input.next() + "a" ;
    var count : int ; count := 0 ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n + 1 do ( (     if (s->at(i+1) = 'x') then (     count := count + 1 ) else (     ans := ans+(Set{0, (count)->char2byte() - 2}->max()) ; 
     count := 0 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int ans,n ;
  int[] garr ;
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(true){
      n=sc.nextInt();
      if(n==0)break ;
      char[] s=sc.next().toCharArray();
      char[] g=sc.next().toCharArray();
      int[] sarr=new int[n];
      for(int i=0 ; i<n ; i++){
        sarr[i]=s[i]-'0' ;
      }
      garr=new int[n];
      for(int i=0 ; i<n ; i++){
        garr[i]=g[i]-'0' ;
      }
      ans=1<<24 ;
      dfs(sarr,0);
      System.out.println(ans);
    }
  }
  private void dfs(int[] arr,int deep){
    if(Arrays.equals(arr,garr)){
      ans=Math.min(ans,deep);
      return ;
    }
    else if(deep==n)return ;
    if(ans<=deep)return ;
    int pos ;
    for(pos=deep ; pos<n ; pos++){
      if(garr[pos]!=arr[pos])break ;
    }
    int diff1=(garr[pos]-arr[pos]+10)% 10 ;
    for(int i=pos ; i<n ; i++){
      for(int j=pos ; j<=i ; j++){
        arr[j]=(arr[j]+diff1)% 10 ;
      }
      dfs(arr,deep+1);
      for(int j=pos ; j<=i ; j++){
        arr[j]=(arr[j]-diff1+10)% 10 ;
      }
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute ans : int;
   attribute garr : Sequence(int);
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
    var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var g : Sequence(String) ; g := sc.getCurrent()->characters() ;
    var sarr : Sequence(int) ; sarr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     sarr[i+1] := s[i+1] - ('0')->char2byte() )  ;     i := i + 1 ) ; 
    garr := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     garr[i+1] := g[i+1] - ('0')->char2byte() )  ;     i := i + 1 ) ; 
    ans := (1*(2->pow(24)))->oclAsType(long) ; 
    execute dfs(sarr, 0) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
   operation dfs( arr : Sequence(int), deep : int) : void
  pre: true
  post: true
  activity: (     if (arr = garr) then (     ans := Set{ans, deep}->min() ; 
     return ) else     if (deep = n) then     return else skip ; ;  
     if (ans <= deep) then     return else skip ; 
    var pos : int ;
        pos := deep ; while pos < n do ( (     if (garr[pos+1] /= arr[pos+1]) then     break else skip )  ;     pos := pos + 1 ) ; 
    var diff1 : int ; diff1 := (garr[pos+1] - arr[pos+1] + 10) mod 10 ;
        var i : int ; i := pos ; while i < n do ( (         var j : int ; j := pos ; while j <= i do ( (     arr[j+1] := (arr[j+1] + diff1) mod 10 )  ;     j := j + 1 ) ; 
     execute dfs(arr, deep + 1) ; 
         var j : int ; j := pos ; while j <= i do ( (     arr[j+1] := (arr[j+1] - diff1 + 10) mod 10 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static int dfs(final int n,int deep,int[] array,int[] ans){
    if(n==deep){
      return 0 ;
    }
    else if(array[deep]==ans[deep]){
      return dfs(n,deep+1,array,ans);
    }
    else {
      final int diff=ans[deep]-array[deep];
      int ret=Integer.MAX_VALUE ;
      for(int k=deep+1 ; k<=n ; k++){
        for(int i=deep ; i<k ; i++){
          array[i]=(10+array[i]+diff)% 10 ;
        }
        ret=Math.min(ret,dfs(n,deep+1,array,ans));
        for(int i=deep ; i<k ; i++){
          array[i]=(10+array[i]-diff)% 10 ;
        }
      }
      return ret+1 ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] array=new int[10];
    int[] ans=new int[10];
    while(true){
      final int n=sc.nextInt();
      if(n==0){
        break ;
      }
      char[] input1=sc.next().toCharArray();
      for(int i=0 ; i<n ; i++){
        array[i]=input1[i]-'0' ;
      }
      char[] input2=sc.next().toCharArray();
      for(int i=0 ; i<n ; i++){
        ans[i]=input2[i]-'0' ;
      }
      System.out.println(dfs(n,0,array,ans));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation dfs( n : int, deep : int, array : Sequence(int), ans : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (n = deep) then (     return 0 ) else     if (array[deep+1] = ans[deep+1]) then (     return dfs(n, deep + 1, array, ans) ) else (     var diff : int ; diff := ans[deep+1] - array[deep+1] ;
     var ret : int ; ret := 2147483647 ;
         var k : int ; k := deep + 1 ; while k <= n do ( (         var i : int ; i := deep ; while i < k do ( (     array[i+1] := (10 + array[i+1] + diff) mod 10 )  ;     i := i + 1 ) ; 
     ret := Set{ret, dfs(n, deep + 1, array, ans)}->min() ; 
         var i : int ; i := deep ; while i < k do ( (     array[i+1] := (10 + array[i+1] - diff) mod 10 )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
     return ret + 1 ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var array : Sequence(int) ; array := Integer.subrange(1,10)->collect(0) ;
     var ans : Sequence(int) ; ans := Integer.subrange(1,10)->collect(0) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var input1 : Sequence(String) ; input1 := sc.getCurrent()->characters() ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := input1[i+1] - ('0')->char2byte() )  ;     i := i + 1 ) ; 
    var input2 : Sequence(String) ; input2 := sc.getCurrent()->characters() ;
        var i : int ; i := 0 ; while i < n do ( (     ans[i+1] := input2[i+1] - ('0')->char2byte() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dfs(n, 0, array, ans)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] arg){
    while(true){
      int K=sc.nextInt();
      if(K==0)break ;
      String s=sc.next();
      String t=sc.next();
      int[] d=new int[K];
      for(int i=0 ; i<K ; ++i){
        d[i]=(10+t.charAt(i)-s.charAt(i))% 10 ;
      }
      System.out.println(solve(d,0));
    }
  }
  static int solve(int[] d,int pos){
    if(pos==d.length)return 0 ;
    if(d[pos]==0)return solve(d,pos+1);
    int prev=d[pos];
    int ret=99 ;
    for(int i=pos ; i<d.length ; ++i){
      d[i]=(d[i]+10-prev)% 10 ;
      ret=Math.min(ret,solve(d,pos+1)+1);
    }
    for(int i=pos ; i<d.length ; ++i){
      d[i]=(d[i]+prev)% 10 ;
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var K : int ; K := sc.getCurrent()->toInteger() ;
     if (K = 0) then     break else skip ; 
    var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var d : Sequence(int) ; d := Integer.subrange(1,K)->collect(0) ;
        var i : int ; i := 0 ; while i < K do ( (     d[i+1] := (10 + t->at(i+1) - s->at(i+1)) mod 10 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(d, 0)) ; 
 ) );
  static   operation solve( d : Sequence(int), pos : int) : int
  pre: true
  post: true
  activity: (     if (pos = d->size()) then     return 0 else skip ; 
     if (d[pos+1] = 0) then     return solve(d, pos + 1) else skip ; 
    var prev : int ; prev := d[pos+1] ;
    var ret : int ; ret := 99 ;
        var i : int ; i := pos ; while i < d->size() do ( (     d[i+1] := (d[i+1] + 10 - prev) mod 10 ; 
     ret := Set{ret, solve(d, pos + 1) + 1}->min() )  ;     i := i + 1 ) ; 
        var i : int ; i := pos ; while i < d->size() do ( (     d[i+1] := (d[i+1] + prev) mod 10 )  ;     i := i + 1 ) ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A_602 {
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    int bx=sc.nextInt();
    long num1=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      int in=sc.nextInt();
      num1+=(in)*Math.pow(bx,i);
    }
    int n2=sc.nextInt();
    int by=sc.nextInt();
    long num2=0 ;
    for(int i=n2-1 ; i>=0 ; i--){
      int in=sc.nextInt();
      num2+=(in)*Math.pow(by,i);
    }
    String ans=num1>num2 ? ">" : num1==num2 ? "=" : "<" ;
    System.out.println(ans);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_602 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : int ; n := sc.nextInt() ;
    var bx : int ; bx := sc.nextInt() ;
    var num1 : long ; num1 := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     var in : int ; in := sc.nextInt() ;
     num1 := num1+((in) * bx->pow(i)) )  ;     i := i - 1 ) ; 
    var n2 : int ; n2 := sc.nextInt() ;
    var by : int ; by := sc.nextInt() ;
    var num2 : long ; num2 := 0 ;
        var i : int ; i := n2 - 1 ; while i >= 0 do ( (     var in : int ; in := sc.nextInt() ;
     num2 := num2+((in) * by->pow(i)) )  ;     i := i - 1 ) ; 
    var ans : String ; ans := if num1 > num2 then ">" else if num1 = num2 then "=" else "<" endif endif ;
    OclFile["System.out"].println(ans) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return (str) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TwoBases {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    if(scanner.hasNext()){
      long x=0,y=0 ;
      int n=scanner.nextInt();
      int p=scanner.nextInt();
      for(; n>0 ; x+=Math.pow(p,--n)*scanner.nextInt());
      n=scanner.nextInt();
      p=scanner.nextInt();
      for(; n>0 ; y+=Math.pow(p,--n)*scanner.nextInt());
      if(x>y){
        System.out.println(">");
      }
      else if(x==y){
        System.out.println("=");
      }
      else {
        System.out.println("<");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TwoBases {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     if (scanner.hasNext()) then (     var x : long ; x := 0 ;
    var y : long ; y := 0 ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var p : int ; p := scanner.getCurrent()->toInteger() ;
      while n > 0 do (   ;     x := x+(p->pow((n - 1)) * scanner.getCurrent()->toInteger()) ) ; 
    n := scanner.getCurrent()->toInteger() ; 
    p := scanner.getCurrent()->toInteger() ; 
      while n > 0 do (   ;     y := y+(p->pow((n - 1)) * scanner.getCurrent()->toInteger()) ) ; 
    if (x > y) then (     OclFile["System.out"].println(">") ) else     if (x = y) then (     OclFile["System.out"].println("=") ) else (     OclFile["System.out"].println("<") ) ;  ;  
 ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] amit)throws Exception {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int bx=in.nextInt();
    long X=0 ;
    for(int i=0 ; i<n ; i++){
      X*=bx ;
      X+=in.nextInt();
    }
    int m=in.nextInt();
    int by=in.nextInt();
    long Y=0 ;
    for(int i=0 ; i<m ; i++){
      Y*=by ;
      Y+=in.nextInt();
    }
    if(X==Y){
      System.out.println("=");
    }
    else if(X<Y){
      System.out.println("<");
    }
    else {
      System.out.println(">");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( amit : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var bx : int ; bx := in.getCurrent()->toInteger() ;
    var X : long ; X := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     X := X*(bx) ; 
     X := X+(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var m : int ; m := in.getCurrent()->toInteger() ;
    var by : int ; by := in.getCurrent()->toInteger() ;
    var Y : long ; Y := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     Y := Y*(by) ; 
     Y := Y+(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    if (X = Y) then (     OclFile["System.out"].println("=") ) else     if (X < Y) then (     OclFile["System.out"].println("<") ) else (     OclFile["System.out"].println(">") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p078 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p078().run());
  }
  private static final int MODULUS=Library.pow(10,6);
  public String run(){
    for(int limit=1 ; ; limit*=2){
      int result=search(limit);
      if(result!=-1)return Integer.toString(result);
    }
  }
  private static int search(int limit){
    int[] partitions=new int[limit];
    partitions[0]=1 ;
    for(int i=1 ; i<limit ; i++){
      for(int j=i ; j<limit ; j++)partitions[j]=(partitions[j]+partitions[j-i])% MODULUS ;
    }
    for(int i=0 ; i<limit ; i++){
      if(partitions[i]==0)return i ;
    }
    return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p078 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p078.newp078().run()) );
  static    attribute MODULUS : int := Library.pow(10, 6);
   operation run() : String
  pre: true
  post: true
  activity: (         var limit : int ; limit := 1 ; while true do ( (     var result : int ; result := search(limit) ;
     if (result /= -1) then     return ((result) + "") else skip )  ;     limit := limit*(2) ) );
  static   operation search( limit : int) : int
  pre: true
  post: true
  activity: (     var partitions : Sequence(int) ; partitions := Integer.subrange(1,limit)->collect(0) ;
     partitions[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < limit do ( (         var j : int ; j := i ; while j < limit do (     partitions[j+1] := (partitions[j+1] + partitions[j - i+1]) mod MODULUS ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < limit do ( (     if (partitions[i+1] = 0) then     return i else skip )  ;     i := i + 1 ) ; 
    return -1 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Deque ;
import java.util.HashMap ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Map ;
import java.util.stream.Stream ;
public class CasimirString {
  static BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws NumberFormatException,IOException {
    int cases=Integer.parseInt(reader.readLine());
    while(cases-->0){
      String[] firstLine=reader.readLine().split(" ");
      long n=Long.parseLong(firstLine[0]);
      long m=Long.parseLong(firstLine[1]);
      long k=Long.parseLong(firstLine[2]);
      long maxEdges=n*(n-1)/2 ;
      long diameter=k-2 ;
      if(diameter<0 || m>maxEdges){
        printNo();
      }
      else if(n==1 && m==0){
        printYes();
      }
      else if(m==maxEdges && diameter>=1){
        printYes();
      }
      else if(diameter>=2){
        n-=diameter+1 ;
        m-=diameter ;
        m-=n ;
        if(m>=0)printYes();
        else printNo();
      }
      else {
        printNo();
      }
    }
    out.flush();
  }
  public static int[] convertToIntArray(String[] str){
    return Stream.of(str).mapToInt(Integer :: parseInt).toArray();
  }
  public static void printYes()throws IOException {
    out.append("YES"+"\n");
  }
  public static void printNo()throws IOException {
    out.append("NO"+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class CasimirString {
  static   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cases : int ; cases := (reader.readLine())->toInteger() ;
         while (cases > 0) do (        cases := cases - 1 ;     skip ; (     var firstLine : Sequence(String) ; firstLine := reader.readLine()->split(" ") ;
     var n : long ; n := (firstLine[0+1])->toLong() ;
    var m : long ; m := (firstLine[1+1])->toLong() ;
    var k : long ; k := (firstLine[2+1])->toLong() ;
    var maxEdges : long ; maxEdges := n * (n - 1) / 2 ;
    var diameter : long ; diameter := k - 2 ;
    if (diameter < 0 or m > maxEdges) then (     execute printNo() ) else     if (n = 1 & m = 0) then (     execute printYes() ) else     if (m = maxEdges & diameter >= 1) then (     execute printYes() ) else     if (diameter >= 2) then (     n := n-(diameter + 1) ; 
     m := m-(diameter) ; 
     m := m-(n) ; 
     if (m >= 0) then     execute printYes() ; else     execute printNo() ; ) else (     execute printNo() ) ;  ;  ;  ;  
 ) ;  ) ;  
     skip );
  static   operation convertToIntArray( str : Sequence(String)) : Sequence(int)
  pre: true
  post: true
  activity: (     return Sequence{str}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() );
  static   operation printYes() : void
  pre: true
  post: true
  activity: (     skip );
  static   operation printNo() : void
  pre: true
  post: true
  activity: (     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p010 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p010().run());
  }
  private static final int LIMIT=2000000 ;
  public String run(){
    long sum=0 ;
    for(int p : Library.listPrimes(LIMIT-1))sum+=p ;
    return Long.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
class p010 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p010.newp010().run()) );
  static    attribute LIMIT : int := 2000000;
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     for (p : Library.listPrimes(LIMIT - 1)) do (     sum := sum+(p) ;  ) ; 
     return ((sum) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void generate(Set<String>st,String s){
    if(s.length()==0){
      return ;
    }
    if(! st.contains(s)){
      st.add(s);
      for(int i=0 ; i<s.length(); i++){
        String t=s ;
        t=t.substring(0,i)+t.substring(i+1);
        generate(st,t);
      }
    }
    return ;
  }
  public static void main(String args[]){
    String s="xyz" ;
    TreeSet<String>st=new TreeSet<>();
    generate(st,s);
    for(String str : st){
      System.out.println(str);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation generate( st : Set(String), s : String) : void
  pre: true
  post: true
  activity: (     if (s->size() = 0) then (     return ) else skip ; 
     if (not(st->includes(s))) then (     st->excludes(s) ; 
         var i : int ; i := 0 ; while i < s->size() do ( (     var t : String ; t := s ;
     t := t.subrange(0+1,i) + t.subrange(i + 1+1,i + 1) ; 
     execute generate(st, t) )  ;     i := i + 1 ) ) else skip ; 
     return );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "xyz" ;
     var st : Set(String) ; st := Set{} ;
     execute generate(st, s) ; 
     for (str : st) do ( (     OclFile["System.out"].println(str) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int divisible(String num){
    int n=num.length();
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=(int)(num.charAt(i));
    if(sum % 3==0)return 0 ;
    if(n==1)return-1 ;
    for(int i=0 ; i<n ; i++)if(sum % 3==(num.charAt(i)-'0')% 3)return 1 ;
    if(n==2)return-1 ;
    return 2 ;
  }
  public static void main(String[] args){
    String num="1234" ;
    System.out.println(divisible(num));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation divisible( num : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := num->size() ;
     var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (     sum := sum+((num->at(i+1))->oclAsType(int)) ;  ;     i := i + 1 ) ; 
    if (sum mod 3 = 0) then     return 0 else skip ; 
    if (n = 1) then     return -1 else skip ; 
        var i : int ; i := 0 ; while i < n do (     if (sum mod 3 = (num->at(i+1) - ('0')->char2byte()) mod 3) then     return 1 else skip ;  ;     i := i + 1 ) ; 
    if (n = 2) then     return -1 else skip ; 
    return 2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : String ; num := "1234" ;
     OclFile["System.out"].println(divisible(num)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=100000 ;
  static int countPairsWithProductK(int arr[],int n,int k){
    int count=0 ;
    int i ;
    boolean hashmap[]=new boolean[MAX];
    for(i=0 ; i<n ; i++)hashmap[arr[i] ]=true ;
    for(i=0 ; i<n ; i++){
      int x=arr[i];
      double index=1.0*k/arr[i];
      if(index>=0 &&((index-(int)(index))==0)&& hashmap[k/x])count++;
      hashmap[x]=false ;
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      1,5,3,4,2 };
      int N=arr.length ;
      int K=3 ;
      System.out.print(countPairsWithProductK(arr,N,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100000;
  static   operation countPairsWithProductK( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var i : int ;
    var hashmap : Sequence(boolean) ; hashmap := Integer.subrange(1,MAX)->collect(false) ;
        i := 0 ; while i < n do (     hashmap[arr[i+1]+1] := true ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     var x : int ; x := arr[i+1] ;
     var index : double ; index := 1.0 * k / arr[i+1] ;
     if (index >= 0 & ((index - (index)->oclAsType(int)) = 0) & hashmap[k / x+1]) then     count := count + 1 ; else skip ; 
     hashmap[x+1] := false )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,3,4,2} ;
     var N : int ; N := arr->size() ;
     var K : int ; K := 3 ;
     OclFile["System.out"].print(countPairsWithProductK(arr, N, K)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int sum(int a,int b){
    int sum=0 ;
    for(int i=1 ; i<=Math.min(a,b); i++)if(a % i==0 && b % i==0)sum+=i ;
    return sum ;
  }
  public static void main(String[] args){
    int A=10,B=15 ;
    System.out.print("Sum="+sum(A,B));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sum( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= Set{a, b}->min() do (     if (a mod i = 0 & b mod i = 0) then     sum := sum+(i) ; else skip ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 10 ;
    var B : int ; B := 15 ;
     OclFile["System.out"].print("Sum=" + sum(A, B)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int swapNibbles(int x){
    return((x & 0x0F)<<4 |(x & 0xF0)>>4);
  }
  public static void main(String arg[]){
    int x=100 ;
    System.out.print(swapNibbles(x));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation swapNibbles( x : int) : int
  pre: true
  post: true
  activity: (     return (MathLib.bitwiseOr(((x & 0x0F)*(2->pow(4)))->oclAsType(long),((x & 0xF0)/(2->pow(4)))->oclAsType(long))) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 100 ;
     OclFile["System.out"].print(swapNibbles(x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.List ;
class Solution {
  public String[] reorderLogFiles(String[] logs){
    Arrays.sort(logs,(log1,log2)->{
      String[] split1=log1.split(" ",2);
      String[] split2=log2.split(" ",2);
      boolean isDigit1=Character.isDigit(split1[1] .charAt(0));
      boolean isDigit2=Character.isDigit(split2[1] .charAt(0));
      if(! isDigit1 && ! isDigit2){
        int cmp=split1[1] .compareTo(split2[1]);
        if(cmp!=0)return cmp ;
        return split1[0] .compareTo(split2[0]);
      }
      return isDigit1 ?(isDigit2 ? 0 : 1):-1 ;
    }
);
    return logs ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
   operation reorderLogFiles( logs : Sequence(String)) : Sequence(String)
  pre: true
  post: true
  activity: (     logs := OclComparator.sortWith(logs, lambda (log1 , log2) : OclAny in (     var split1 : Sequence(String) ; split1 := log1->split(" ") ;
     var split2 : Sequence(String) ; split2 := log2->split(" ") ;
    var isDigit1 : boolean ; isDigit1 := (split1[1+1]->at(0+1) + "")->isMatch("[0-9]") ;
    var isDigit2 : boolean ; isDigit2 := (split2[1+1]->at(0+1) + "")->isMatch("[0-9]") ;
    if (not(isDigit1) & not(isDigit2)) then (     var cmp : int ; cmp := split1[1+1]->compareTo(split2[1+1]) ;
     if (cmp /= 0) then     return cmp else skip ; 
     return split1[0+1]->compareTo(split2[0+1]) ) else skip ; 
    return if isDigit1 then (if isDigit2 then 0 else 1 endif) else -1 endif 
 )) ; 
     return logs );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class Test {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    ArrayList<Long>arr=new ArrayList<>();
    ArrayList<Long>ans=new ArrayList<>();
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      arr.add(in.nextLong());
    }
    int swap=0 ;
    long m=Collections.min(arr);
    for(int i=0 ; i<arr.size(); i++){
      if(arr.get(i)==m){
        arr.set(i,Long.MAX_VALUE-1000);
        m=Collections.min(arr);
      }
      else {
        swap++;
        ans.add((long)i);
        long temp=arr.get(i);
        ans.add((long)arr.indexOf(m));
        arr.set(arr.indexOf(m),temp);
        arr.set(i,Long.MAX_VALUE-1000);
        m=Collections.min(arr);
      }
    }
    System.out.println(swap);
    for(int i=0 ; i<ans.size(); i++){
      System.out.print(ans.get(i)+" ");
      if(i % 2!=0 && i!=0)System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(long) ; arr := Sequence{} ;
    var ans : Sequence(long) ; ans := Sequence{} ;
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     arr := arr->including(in.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    var swap : int ; swap := 0 ;
    var m : long ; m := .min(arr) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr->at(i+1) = m) then (     arr := arr.setAt(i+1,"9223372036854775807"->toLong() - 1000) ; 
     m := arr->min() ) else (     swap := swap + 1 ; 
     ans := ans->including(i->oclAsType(long)) ; 
    var temp : long ; temp := arr->at(i+1) ;
    ans := ans->including(arr->indexOf(m)-1->oclAsType(long)) ; 
    arr := arr.setAt(arr->indexOf(m)-1+1,temp) ; 
    arr := arr.setAt(i+1,"9223372036854775807"->toLong() - 1000) ; 
    m := arr->min() ; 
 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(swap) ; 
        var i : int ; i := 0 ; while i < ans->size() do ( (     OclFile["System.out"].print(ans->at(i+1) + " ") ; 
     if (i mod 2 /= 0 & i /= 0) then     OclFile["System.out"].println() ; else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
import java.util.StringTokenizer ;
import java.lang.StringBuilder ;
import java.lang.Math ;
import java.util.HashSet ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int k=0 ;
    int[] a=new int[n];
    StringTokenizer st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<n ; i++)a[i]=Integer.parseInt(st.nextToken());
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      int min=a[i];
      int index=i ;
      for(int j=i ; j<n ; j++){
        if(min>a[j]){
          min=a[j];
          index=j ;
        }
      }
      if(index!=i){
        sb.append(i+" "+index);
        sb.append("\n");
        k++;
      }
      int t=a[i];
      a[i]=a[index];
      a[index]=t ;
    }
    System.out.println(k);
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var k : int ; k := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (st.next())->toInteger() ;  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     var min : int ; min := a[i+1] ;
     var index : int ; index := i ;
        var j : int ; j := i ; while j < n do ( (     if (min > a[j+1]) then (     min := a[j+1] ; 
     index := j ) else skip )  ;     j := j + 1 ) ; 
    if (index /= i) then (     sb := sb + StringLib.newString(i + " " + index) ; 
     sb := sb + StringLib.newString("\n") ; 
     k := k + 1 ) else skip ; 
    var t : int ; t := a[i+1] ;
    a[i+1] := a[index+1] ; 
    a[index+1] := t ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(k) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void swap(int[] arr,int l,int r){
    int temp=arr[l];
    arr[l]=arr[r];
    arr[r]=temp ;
  }
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      int[] c=new int[n];
      int[] b=new int[n];
      int cnt=0 ;
      for(int i=0 ; i<n ; i++){
        b[i]=0 ;
        c[i]=0 ;
      }
      for(int i=0 ; i<n-1 ; i++){
        int temp=a[i];
        int mn=Integer.MAX_VALUE ;
        for(int j=i ; j<n ; j++){
          mn=Math.min(mn,a[j]);
        }
        for(int j=i ; j<n ; j++){
          if(mn==a[j]){
            swap(a,i,j);
            if(a[i]==temp){
              break ;
            }
            cnt++;
            b[cnt]=i ;
            c[cnt]=j ;
            break ;
          }
        }
      }
      System.out.println(cnt);
      for(int i=1 ; i<=cnt ; i++){
        System.out.println(b[i]+" "+c[i]);
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation swap( arr : Sequence(int), l : int, r : int) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := arr[l+1] ;
     arr[l+1] := arr[r+1] ; 
     arr[r+1] := temp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := 0 ; 
     c[i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var temp : int ; temp := a[i+1] ;
     var mn : int ; mn := 2147483647 ;
         var j : int ; j := i ; while j < n do ( (     mn := Set{mn, a[j+1]}->min() )  ;     j := j + 1 ) ; 
         var j : int ; j := i ; while j < n do ( (     if (mn = a[j+1]) then (     execute swap(a, i, j) ; 
     if (a[i+1] = temp) then (     break ) else skip ; 
    cnt := cnt + 1 ; 
    b[cnt+1] := i ; 
    c[cnt+1] := j ; 
    break 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
        var i : int ; i := 1 ; while i <= cnt do ( (     OclFile["System.out"].println(b[i+1] + " " + c[i+1]) )  ;     i := i + 1 ) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ValuableResources {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    if(scanner.hasNext()){
      int n=scanner.nextInt();
      int lx=-1000000000 ;
      int hx=1000000000 ;
      int ly=-1000000000 ;
      int hy=1000000000 ;
      while(n-->0){
        int x=scanner.nextInt();
        int y=scanner.nextInt();
        lx=Math.max(lx,x);
        hx=Math.min(hx,x);
        ly=Math.max(ly,y);
        hy=Math.min(hy,y);
      }
      int p=Math.max((lx-hx),(ly-hy));
      System.out.println((long)p*p);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ValuableResources {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     if (scanner.hasNext()) then (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var lx : int ; lx := -1000000000 ;
    var hx : int ; hx := 1000000000 ;
    var ly : int ; ly := -1000000000 ;
    var hy : int ; hy := 1000000000 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var x : int ; x := scanner.getCurrent()->toInteger() ;
     var y : int ; y := scanner.getCurrent()->toInteger() ;
    lx := Set{lx, x}->max() ; 
    hx := Set{hx, x}->min() ; 
    ly := Set{ly, y}->max() ; 
    hy := Set{hy, y}->min() ; 
 ) ;  ) ;  
    var p : int ; p := Set{(lx - hx), (ly - hy)}->max() ;
    OclFile["System.out"].println(p->oclAsType(long) * p) ; 
 ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String tes=null ;
    char c=0 ;
    ArrayList<Integer>al=new ArrayList<Integer>();
    ArrayList<Integer>al2=new ArrayList<Integer>();
    ArrayList<Integer>al3=new ArrayList<Integer>();
    while(true){
      try {
        tes=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      if(tes==null){
        break ;
      }
      if(tes.equals("")){
        break ;
      }
      try {
        String[] fruit=tes.split(" ",0);
        al.add(Integer.parseInt(fruit[0]));
        al2.add(Integer.parseInt(fruit[1]));
        al3.add(Integer.parseInt(fruit[2]));
      }
      catch(NumberFormatException e){
        break ;
      }
    }
    for(int r=0 ; r<al.size(); r++){
      boolean e=false ;
      int pri=0 ;
      for(int i=1 ; i<=10 ; i++){
        if(al.get(r)==i || al2.get(r)==i || al3.get(r)==i){
          continue ;
        }
        if(al.get(r)+al2.get(r)+i<=20){
          pri++;
        }
      }
      if(pri<=3){
        e=true ;
      }
      if(e){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tes : String ; tes := null ;
    var c : String ; c := 0 ;
    var al : Sequence(int) ; al := Sequence{} ;
    var al2 : Sequence(int) ; al2 := Sequence{} ;
    var al3 : Sequence(int) ; al3 := Sequence{} ;
    while (true) do (     try (     tes := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     if (tes = null) then (     break ) else skip ; 
     if (tes = "") then (     break ) else skip ; 
     try (     var fruit : Sequence(String) ; fruit := tes->split(" ") ;
     al := al->including((fruit[0+1])->toInteger()) ; 
     al2 := al2->including((fruit[1+1])->toInteger()) ; 
     al3 := al3->including((fruit[2+1])->toInteger()) )   catch (e : IncorrectElementException) do (     break )
 ) ; 
        var r : int ; r := 0 ; while r < al->size() do ( (     var e : boolean ; e := false ;
     var pri : int ; pri := 0 ;
        var i : int ; i := 1 ; while i <= 10 do ( (     if (al->at(r+1) = i or al2->at(r+1) = i or al3->at(r+1) = i) then (     continue ) else skip ; 
     if (al->at(r+1) + al2->at(r+1) + i <= 20) then (     pri := pri + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (pri <= 3) then (     e := true ) else skip ; 
    if (e) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 )  ;     r := r + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class ch1 {
  public static void main(String[] args){
    int n,k ;
    Scanner reader=new Scanner(System.in);
    n=reader.nextInt();
    k=reader.nextInt();
    char[] b=new char[n];
    int i,j,l=0 ;
    String str=reader.next();
    boolean flag2=true ;
    for(i=0 ; i<n ; ++i){
      boolean flag=true ;
      for(j=0 ; j<k-1 ; ++j){
        if(i+1==n){
          flag=false ;
++i ;
          break ;
        }
        if(str.charAt(i)!=str.charAt(++i)){
          flag=false ;
          break ;
        }
      }
      if(flag){
        b[l++]=str.charAt(i);
        flag2=false ;
      }
      else--i ;
    }
    if(flag2)System.out.println("0");
    else {
      Arrays.sort(b,0,l);
      int max=1,max1=1 ;
      for(i=0 ; i<l-1 ; ++i){
        if(b[i]==b[i+1])++max1 ;
        else {
          if(max<max1)max=max1 ;
          max1=1 ;
        }
      }
      System.out.println(max>max1 ? max : max1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ch1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var k : int ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := reader.getCurrent()->toInteger() ; 
    k := reader.getCurrent()->toInteger() ; 
    var b : Sequence(String) ; b := Integer.subrange(1,n)->collect(0) ;
    var i : int ;
    var j : int ;
    var l : int ; l := 0 ;
    var str : String ; str := reader.getCurrent() ;
    var flag2 : boolean ; flag2 := true ;
        i := 0 ; while i < n do ( (     var flag : boolean ; flag := true ;
         j := 0 ; while j < k - 1 do ( (     if (i + 1 = n) then (     flag := false ; 
     i := i + 1 ; 
     break ) else skip ; 
     if (str->at(i+1) /= str->at((i + 1)+1)) then (     flag := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (flag) then (      b[l+1] := str->at(i+1)  ; l := l + 1 ; 
     flag2 := false ) else     i := i - 1 ; )  ;     i := i + 1 ) ; 
    if (flag2) then     OclFile["System.out"].println("0") else (     b := b.subrange(1,0)^(b.subrange(0+1,l)->sort())^b.subrange(l+1,b.size) ; 
     var max : int ; max := 1 ;
    var max1 : int ; max1 := 1 ;
         i := 0 ; while i < l - 1 do ( (     if (b[i+1] = b[i + 1+1]) then     max1 := max1 + 1 ; else (     if (max < max1) then     max := max1 ; else skip ; 
     max1 := 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if max > max1 then max else max1 endif) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  static int[] arr ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),k=in.nextInt();
    char[] s=in.next().toCharArray();
    pw.println(solve(n,k,s));
    pw.close();
  }
  static int solve(int n,int k,char[] s){
    int res=0 ;
    for(int i=0 ; i<26 ; i++){
      char c=(char)('a'+i);
      int cnt=0 ;
      int demoRes=0 ;
      for(int j=0 ; j<n ; j++){
        if(s[j]==c){
          cnt++;
        }
        else cnt=0 ;
        if(cnt==k){
          demoRes++;
          cnt=0 ;
        }
      }
      res=Math.max(demoRes,res);
    }
    return res ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute arr : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := in.getCurrent()->characters() ;
    skip ; 
    skip ; 
 );
  static   operation solve( n : int, k : int, s : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < 26 do ( (     var c : String ; c := ('a' + i)->oclAsType(String) ;
     var cnt : int ; cnt := 0 ;
    var demoRes : int ; demoRes := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     if (s[j+1] = c) then (     cnt := cnt + 1 ) else     cnt := 0 ; ;  
     if (cnt = k) then (     demoRes := demoRes + 1 ; 
     cnt := 0 ) else skip )  ;     j := j + 1 ) ; 
    res := Set{demoRes, res}->max() ; 
 )  ;     i := i + 1 ) ; 
     return res );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  private static boolean isValidString(String str,int n){
    int index=str.indexOf("b");
    if(index==0)return false ;
    while(index!=-1){
      if(str.charAt(index-1)!='a')return false ;
      if(index+1<n && str.charAt(index+1)!='b')return false ;
      if(index+2<n && str.charAt(index+2)=='b')return false ;
      if(index==n-1)return false ;
      index=str.indexOf("b",index+2);
    }
    return true ;
  }
  public static void main(String[] args){
    String str="abbaaabbabba" ;
    int n=str.length();
    System.out.println(isValidString(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isValidString( str : String, n : int) : boolean
  pre: true
  post: true
  activity: (     var index : int ; index := str->indexOf("b")-1 ;
     if (index = 0) then     return false else skip ; 
     while (index /= -1) do (     if (str->at(index - 1+1) /= 'a') then     return false else skip ; 
     if (index + 1 < n & str->at(index + 1+1) /= 'b') then     return false else skip ; 
    if (index + 2 < n & str->at(index + 2+1) = 'b') then     return false else skip ; 
    if (index = n - 1) then     return false else skip ; 
    index := str.subrange(index + 2+1)->indexOf("b"+"") + index + 2 - 1  ; 
 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abbaaabbabba" ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].println(isValidString(str, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static class TriTree {
    Node root=new Node();
    class Node {
      ArrayList<Node>child=new ArrayList<>();
      char c ;
      long depth ;
      public void add(Node node){
        child.add(node);
      }
      public Node(){
      }
      public Node(char c,long depth){
        this.c=c ;
        this.depth=depth ;
      }
      public long xorGrundy(){
        long xor=0 ;
        for(Node node : child)xor ^=node.xorGrundy();
        if(child.size()==1)xor ^=grundy(L-depth);
        return xor ;
      }
    }
    public void addLeaf(String s){
      Node cur=root ;
      for(int i=0 ; i<s.length(); i++){
        boolean found=false ;
        for(Node child : cur.child){
          if(child.c==s.charAt(i)){
            cur=child ;
            found=true ;
            break ;
          }
        }
        if(! found){
          Node next=new Node(s.charAt(i),i+1);
          cur.add(next);
          cur=next ;
        }
      }
    }
    public long xorGrundy(){
      return root.xorGrundy();
    }
  }
  static long L ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    L=sc.nextLong();
    TriTree tree=new TriTree();
    for(int i=0 ; i<N ; i++)tree.addLeaf(sc.next());
    System.out.println(tree.xorGrundy()==0 ? "Bob" : "Alice");
    sc.close();
  }
  static long grundy(long n){
    long ans=1 ;
    while(n % ans==0)ans<<=1 ;
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class TriTree {
   attribute root : Node := Node.newNode();
 class Node {
   attribute child : Sequence(Node) := Sequence{};
   attribute c : String;
   attribute depth : long;
   operation add( node : Node) : void
  pre: true
  post: true
  activity: (     child := child->including(node) );
   static operation newNode() : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   static operation newNode( c : String, depth : long) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(c, depth);
    return self );
  operation initialise( c : String, depth : long) : void
  pre: true  post: true
  activity: (     self.c := c ; 
     self.depth := depth );
   operation xorGrundy() : long
  pre: true
  post: true
  activity: (     var xor : long ; xor := 0 ;
     for (node : child) do (     xor := MathLib.bitwiseXor(xor,node.xorGrundy()) ;  ) ; 
     if (child->size() = 1) then     xor := MathLib.bitwiseXor(xor,grundy(L - depth)) ; else skip ; 
     return xor );
}
   operation addLeaf( s : String) : void
  pre: true
  post: true
  activity: (     var cur : Node ; cur := root ;
         var i : int ; i := 0 ; while i < s->size() do ( (     var found : boolean ; found := false ;
     for (child : cur.child) do ( (     if (child.c = s->at(i+1)) then (     cur := child ; 
     found := true ; 
     break ) else skip )  ) ; 
     if (not(found)) then (     var next : Node ; next := Node.newNode(s->at(i+1), i + 1) ;
     cur->excludes(next) ; 
     cur := next ) else skip )  ;     i := i + 1 ) );
   operation xorGrundy() : long
  pre: true
  post: true
  activity: (     return root.xorGrundy() );
}
  static   attribute L : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    L := sc.getCurrent()->toLong() ; 
    var tree : TriTree ; tree := TriTree.newTriTree() ;
        var i : int ; i := 0 ; while i < N do (     tree.addLeaf(sc.getCurrent()) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if tree.xorGrundy() = 0 then "Bob" else "Alice" endif) ; 
    skip ; 
 );
  static   operation grundy( n : long) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
     while (n mod ans = 0) do     ans := ans*(2->pow(1)) ; ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int N,Q ;
      N=Integer.parseInt(line.substring(0,line.indexOf(' ')));
      Q=Integer.parseInt(line.substring(line.indexOf(' ')+1));
      int[] years=new int[51];
      String[] names=new String[N+1];
      int yearPrev=1 ;
      int idxPrev=0 ;
      names[idxPrev]="kogakubu10gokan" ;
      for(int i=0 ; i<N ; i++){
        line=br.readLine();
        int yearNext=Integer.parseInt(line.substring(0,line.indexOf(' ')));
        names[idxPrev+1]=line.substring(line.indexOf(' ')+1);
        for(int j=yearPrev ; j<yearNext ; j++){
          years[j]=idxPrev ;
        }
        yearPrev=yearNext ;
        idxPrev++;
      }
      for(int j=yearPrev ; j<51 ; j++){
        years[j]=idxPrev ;
      }
      System.out.println(names[years[Q] ]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var N : int ;
    var Q : int ;
     N := (line.subrange(0+1,line->indexOf(' ')-1))->toInteger() ; 
    Q := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1))->toInteger() ; 
    var years : Sequence(int) ; years := Integer.subrange(1,51)->collect(0) ;
    var names : Sequence(String) ; names := Integer.subrange(1,N + 1)->collect(null) ;
    var yearPrev : int ; yearPrev := 1 ;
    var idxPrev : int ; idxPrev := 0 ;
    names[idxPrev+1] := "kogakubu10gokan" ; 
        var i : int ; i := 0 ; while i < N do ( (     line := br.readLine() ; 
     var yearNext : int ; yearNext := (line.subrange(0+1,line->indexOf(' ')-1))->toInteger() ;
    names[idxPrev + 1+1] := line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) ; 
        var j : int ; j := yearPrev ; while j < yearNext do ( (     years[j+1] := idxPrev )  ;     j := j + 1 ) ; 
    yearPrev := yearNext ; 
    idxPrev := idxPrev + 1 ; 
 )  ;     i := i + 1 ) ; 
        var j : int ; j := yearPrev ; while j < 51 do ( (     years[j+1] := idxPrev )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(names[years[Q+1]+1]) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,q,i ;
    int[] y ;
    String[] name ;
    n=sc.nextInt();
    q=sc.nextInt();
    y=new int[n];
    name=new String[n];
    for(i=0 ; i<n ; i++){
      y[i]=sc.nextInt();
      name[i]=sc.next();
    }
    for(i=0 ; i<n ; i++)if(q<y[i]){
      if(i==0)out.println("kogakubu10gokan");
      else out.println(name[i-1]);
      break ;
    }
    if(i==n)out.println(name[i-1]);
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var q : int ;
    var i : int ;
    var y : Sequence(int) ;
    var name : Sequence(String) ;
    n := sc.nextInt() ; 
    q := sc.nextInt() ; 
    y := Integer.subrange(1,n)->collect(0) ; 
    name := Integer.subrange(1,n)->collect(null) ; 
        i := 0 ; while i < n do ( (     y[i+1] := sc.nextInt() ; 
     name[i+1] := sc.next() )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do (     if (q < y[i+1]) then (     if (i = 0) then     out.println("kogakubu10gokan") else     out.println(name[i - 1+1]) ; ;  
     break ) else skip ;  ;     i := i + 1 ) ; 
    if (i = n) then     out.println(name[i - 1+1]) ; else skip ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int q=sc.nextInt();
    boolean f=false ;
    String ans="" ;
    String pre="kogakubu10gokan" ;
    for(int i=0 ; i<n ; i++){
      int y=sc.nextInt();
      String nex=sc.next();
      if(! f && y>q){
        f=true ;
        ans=pre ;
      }
      pre=nex ;
    }
    if(ans.equals(""))ans=pre ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var f : boolean ; f := false ;
    var ans : String ; ans := "" ;
    var pre : String ; pre := "kogakubu10gokan" ;
        var i : int ; i := 0 ; while i < n do ( (     var y : int ; y := sc.getCurrent()->toInteger() ;
     var nex : String ; nex := sc.getCurrent() ;
     if (not(f) & y > q) then (     f := true ; 
     ans := pre ) else skip ; 
     pre := nex )  ;     i := i + 1 ) ; 
    if (ans = "") then     ans := pre ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  static int max ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int q=sc.nextInt();
    Data[] list=new Data[n+1];
    Calendar cal=Calendar.getInstance();
    cal.clear();
    cal.set(Calendar.YEAR,1989);
    list[0]=new Data(cal,"kogakubu10gokan");
    int ans=0 ;
    Calendar check=Calendar.getInstance();
    check.clear();
    check.set(Calendar.YEAR,q+1988);
    for(int i=1 ; i<=n ; i++){
      cal=Calendar.getInstance();
      cal.clear();
      cal.set(Calendar.YEAR,1988+sc.nextInt());
      if(check.compareTo(cal)>=0)ans=i ;
      list[i]=new Data(cal,sc.next());
    }
    System.out.println(list[ans] .name);
  }
  static class Data {
    Calendar cal ;
    String name ;
    Data(Calendar a,String b){
      cal=a ;
      name=b ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute max : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var list : Sequence(Data) ; list := Integer.subrange(1,n + 1)->collect(null) ;
    var cal : OclDate ; cal := OclDate.newOclDate() ;
    cal := cal->intersection(Set{}) ; 
    cal := cal.setAt(YEAR+1, 1989) ; 
    list[0+1] := Data.newData(cal, "kogakubu10gokan") ; 
    var ans : int ; ans := 0 ;
    var check : OclDate ; check := OclDate.newOclDate() ;
    check := check->intersection(Set{}) ; 
    check := check.setAt(YEAR+1, q + 1988) ; 
        var i : int ; i := 1 ; while i <= n do ( (     cal := OclDate.newOclDate() ; 
     cal := cal->intersection(Set{}) ; 
    cal := cal.setAt(YEAR+1, 1988 + sc.getCurrent()->toInteger()) ; 
    if (check.compareTo(cal) >= 0) then     ans := i ; else skip ; 
    list[i+1] := Data.newData(cal, sc.getCurrent()) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(list[ans+1].name) ; 
 );
  static class Data {
   attribute cal : OclDate;
   attribute name : String;
   static operation newData( a : OclDate, b : String) : Data
  pre: true
  post: true
  activity:
  ( var self : Data ;
    self := createData();
    self.initialise(a, b);
    return self );
  operation initialise( a : OclDate, b : String) : void
  pre: true  post: true
  activity: (     cal := a ; 
     name := b );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    int Q=sc.nextInt();
    int[] Y=new int[N+2];
    String[] name=new String[N+1];
    name[0]="kogakubu10gokan" ;
    for(int i=0 ; i<N ; ++i){
      Y[i+1]=sc.nextInt();
      name[i+1]=sc.next();
    }
    Y[N+1]=100 ;
    for(int i=0 ; i<N+1 ; ++i){
      if(Y[i]<=Q && Q<Y[i+1]){
        System.out.println(name[i]);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var Q : int ; Q := sc.getCurrent()->toInteger() ;
    var Y : Sequence(int) ; Y := Integer.subrange(1,N + 2)->collect(0) ;
    var name : Sequence(String) ; name := Integer.subrange(1,N + 1)->collect(null) ;
    name[0+1] := "kogakubu10gokan" ; 
        var i : int ; i := 0 ; while i < N do ( (     Y[i + 1+1] := sc.getCurrent()->toInteger() ; 
     name[i + 1+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    Y[N + 1+1] := 100 ; 
        var i : int ; i := 0 ; while i < N + 1 do ( (     if (Y[i+1] <= Q & Q < Y[i + 1+1]) then (     OclFile["System.out"].println(name[i+1]) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static void findgcd(int n,int x,int y){
    int g=gcd(x,y);
    for(int i=0 ; i<g ; i++)System.out.print(n);
  }
  public static void main(String[] args){
    int n=123,x=5,y=2 ;
    findgcd(n,x,y);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation findgcd( n : int, x : int, y : int) : void
  pre: true
  post: true
  activity: (     var g : int ; g := gcd(x, y) ;
         var i : int ; i := 0 ; while i < g do (     OclFile["System.out"].print(n) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 123 ;
    var x : int ; x := 5 ;
    var y : int ; y := 2 ;
     execute findgcd(n, x, y) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Q22222 {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    Deque<Integer>q1=new ArrayDeque<>();
    Deque<Integer>q2=new ArrayDeque<>();
    int N=input.nextInt();
    int C=input.nextInt();
    for(int i=0 ; i<N ; i++){
      q1.addLast(input.nextInt());
      q2.addLast(i+1);
    }
    while(q2.size()>1){
      if(q1.peek()-C>=1){
        q1.addLast(q1.pop()-C);
        q2.addLast(q2.pop());
      }
      else {
        q1.removeFirst();
        q2.removeFirst();
      }
      if(q1.size()==1)break ;
    }
    System.out.println(q2.peek());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Q22222 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q1 : Sequence(int) ; q1 := ArrayDeque<OclAny>.newArrayDeque() ;
    var q2 : Sequence(int) ; q2 := ArrayDeque<OclAny>.newArrayDeque() ;
    var N : int ; N := input.getCurrent()->toInteger() ;
    var C : int ; C := input.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < N do ( (     q1 := q1->append(input.getCurrent()->toInteger()) ; 
     q2 := q2->append(i + 1) )  ;     i := i + 1 ) ; 
    while (q2->size() > 1) do (     if (q1->min() - C >= 1) then (     q1 := q1->append(q1->last() - C) ; 
     q2 := q2->append(q2->last()) ) else (     q1 := q1->tail() ; 
     q2 := q2->tail() ) ;  
     if (q1->size() = 1) then     break else skip ) ; 
    OclFile["System.out"].println(q2->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  final static int number_of_cards=10 ;
  final static int max_number=20 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int card1=sc.nextInt();
      int card2=sc.nextInt();
      int card3=sc.nextInt();
      int sum=card1+card2 ;
      boolean used_card[]=new boolean[number_of_cards+1];
      used_card[card1]=true ;
      used_card[card2]=true ;
      used_card[card3]=true ;
      int count=0 ;
      for(int i=1 ; i<=number_of_cards ; ++i){
        if(! used_card[i] && sum+i<=max_number){
++count ;
        }
      }
      System.out.println(judge(count));
    }
  }
  private static String judge(int count){
    return((double)count/(double)(number_of_cards-3)>=0.5)? "YES" : "NO" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute number_of_cards : int := 10;
  static   attribute max_number : int := 20;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var card1 : int ; card1 := sc.getCurrent()->toInteger() ;
     var card2 : int ; card2 := sc.getCurrent()->toInteger() ;
    var card3 : int ; card3 := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := card1 + card2 ;
    var used_card : Sequence(boolean) ; used_card := Integer.subrange(1,number_of_cards + 1)->collect(false) ;
    used_card[card1+1] := true ; 
    used_card[card2+1] := true ; 
    used_card[card3+1] := true ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= number_of_cards do ( (     if (not(used_card[i+1]) & sum + i <= max_number) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(judge(count)) ; 
 ) );
  static   operation judge( count : int) : String
  pre: true
  post: true
  activity: (     return if (count->oclAsType(double) / (number_of_cards - 3)->oclAsType(double) >= 0.5) then "YES" else "NO" endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeforces {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[][]=new int[n][2];
    int min=Integer.MAX_VALUE ;
    int max=Integer.MIN_VALUE ;
    int i ;
    for(i=0 ; i<n ; i++){
      a[i][0]=sc.nextInt();
      a[i][1]=sc.nextInt();
      min=Math.min(min,a[i][0]);
      max=Math.max(max,a[i][0]);
    }
    long ans=(long)(max-min)*(max-min);
    min=Integer.MAX_VALUE ;
    max=Integer.MIN_VALUE ;
    for(i=0 ; i<n ; i++){
      min=Math.min(min,a[i][1]);
      max=Math.max(max,a[i][1]);
    }
    ans=Math.max(ans,(long)(max-min)*(max-min));
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
    var min : int ; min := 2147483647 ;
    var max : int ; max := -2147483648 ;
    var i : int ;
        i := 0 ; while i < n do ( (     a[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     a[i+1][1+1] := sc.getCurrent()->toInteger() ; 
     min := Set{min, a[i+1][0+1]}->min() ; 
     max := Set{max, a[i+1][0+1]}->max() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := (max - min)->oclAsType(long) * (max - min) ;
    min := 2147483647 ; 
    max := -2147483648 ; 
        i := 0 ; while i < n do ( (     min := Set{min, a[i+1][1+1]}->min() ; 
     max := Set{max, a[i+1][1+1]}->max() )  ;     i := i + 1 ) ; 
    ans := Set{ans, (max - min)->oclAsType(long) * (max - min)}->max() ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static final int MP=200010 ;
  public static final int MSN=100010 ;
  public static class p {
    int bp ;
    int dp ;
  }
  public static void main(String[] args){
    int P1=0,P2=0 ;
    p[] pas=new p[MP];
    int[] igo=new int[MSN];
    int[] agon=new int[MSN];
    int[] agoff=new int[MSN];
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    for(int i=0 ; i<n ; i++){
      pas[i]=new p();
      pas[i] .bp=Integer.parseInt(sc.next());
      pas[i] .dp=Integer.parseInt(sc.next());
      igo[pas[i] .bp]++;
      igo[pas[i] .dp]--;
      agon[pas[i] .bp]++;
      agoff[pas[i] .dp]++;
    }
    for(int j=1 ; j<MSN ; j++){
      igo[j]+=igo[j-1];
      agon[j]+=agon[j-1];
      agoff[j]+=agoff[j-1];
      if(P2<igo[j]){
        P2=igo[j];
      }
    }
    for(int k=0 ; k<n ; k++){
      if(P1<(agon[pas[k] .dp-1]-agoff[pas[k] .bp])){
        P1=agon[pas[k] .dp-1]-agoff[pas[k] .bp];
      }
    }
    System.out.println(P1+" "+P2);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MP : int := 200010;
  static    attribute MSN : int := 100010;
  static class p {
   attribute bp : int;
   attribute dp : int;
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var P1 : int ; P1 := 0 ;
    var P2 : int ; P2 := 0 ;
     var pas : Sequence(p) ; pas := Integer.subrange(1,MP)->collect(null) ;
    var igo : Sequence(int) ; igo := Integer.subrange(1,MSN)->collect(0) ;
    var agon : Sequence(int) ; agon := Integer.subrange(1,MSN)->collect(0) ;
    var agoff : Sequence(int) ; agoff := Integer.subrange(1,MSN)->collect(0) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := (sc.getCurrent())->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     pas[i+1] := p.newp() ; 
     pas[i+1].bp := (sc.getCurrent())->toInteger() ; 
    pas[i+1].dp := (sc.getCurrent())->toInteger() ; 
    igo[pas[i+1].bp+1] := igo[pas[i+1].bp+1] + 1 ; 
    igo[pas[i+1].dp+1] := igo[pas[i+1].dp+1] - 1 ; 
    agon[pas[i+1].bp+1] := agon[pas[i+1].bp+1] + 1 ; 
    agoff[pas[i+1].dp+1] := agoff[pas[i+1].dp+1] + 1 ; 
 )  ;     i := i + 1 ) ; 
        var j : int ; j := 1 ; while j < MSN do ( (     igo[j+1] := igo[j+1]+(igo[j - 1+1]) ; 
     agon[j+1] := agon[j+1]+(agon[j - 1+1]) ; 
     agoff[j+1] := agoff[j+1]+(agoff[j - 1+1]) ; 
     if (P2 < igo[j+1]) then (     P2 := igo[j+1] ) else skip )  ;     j := j + 1 ) ; 
        var k : int ; k := 0 ; while k < n do ( (     if (P1 < (agon[pas[k+1].dp - 1+1] - agoff[pas[k+1].bp+1])) then (     P1 := agon[pas[k+1].dp - 1+1] - agoff[pas[k+1].bp+1] ) else skip )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(P1 + " " + P2) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    char[] N=sc.next().toCharArray();
    int ans=0 ;
    int acum=0 ;
    for(int i=0 ; i<N.length ; i++){
      acum+=N[i]-'0' ;
      ans=Math.max(ans,acum);
      ans=Math.max(ans,acum-1+(N.length-i-1)*9);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : Sequence(String) ; N := sc.getCurrent()->characters() ;
    var ans : int ; ans := 0 ;
    var acum : int ; acum := 0 ;
        var i : int ; i := 0 ; while i < N->size() do ( (     acum := acum+(N[i+1] - ('0')->char2byte()) ; 
     ans := Set{ans, acum}->max() ; 
     ans := Set{ans, acum - 1 + (N->size() - i - 1) * 9}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String str=in.nextLine();
    if(str.length()==1){
      System.out.println(str);
      return ;
    }
    long num=Long.parseLong(str.substring(1));
    int ans=Integer.parseInt(str.substring(0,1))+9*(str.length()-1);
    if(num<Math.pow(10,str.length()-1)-1){
      ans--;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := in.nextLine() ;
    if (str->size() = 1) then (     OclFile["System.out"].println(str) ; 
     return ) else skip ; 
    var num : long ; num := (str.subrange(1+1,1))->toLong() ;
    var ans : int ; ans := (str.subrange(0+1,1))->toInteger() + 9 * (str->size() - 1) ;
    if (num < 10->pow(str->size() - 1) - 1) then (     ans := ans - 1 ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    Reader.init(System.in);
    String N=Reader.next();
    int p=1 ;
    String tem=""+N.charAt(0);
    for(int i=0 ; i<N.length()-1 ; i++){
      tem+="9" ;
    }
    if(tem.equals(N)){
      System.out.println((9*(N.length()-1)+(N.charAt(0)-'0')));
    }
    else {
      System.out.println((9*(N.length()-1)+(N.charAt(0)-'1')));
    }
  }
}
class Reader {
  static BufferedReader reader ;
  static StringTokenizer tokenizer ;
  static void init(InputStream input){
    reader=new BufferedReader(new InputStreamReader(input));
    tokenizer=new StringTokenizer("");
  }
  static String nextToken(){
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        tokenizer=new StringTokenizer(reader.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }
  static String next()throws IOException {
    while(! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  static long nextLong(){
    return Long.parseLong(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Reader.init(OclFile["System.in"]) ; 
     var N : String ; N := Reader.next() ;
    var p : int ; p := 1 ;
    var tem : String ; tem := "" + N->at(0+1) ;
        var i : int ; i := 0 ; while i < N->size() - 1 do ( (     tem := tem+("9") )  ;     i := i + 1 ) ; 
    if (tem = N) then (     OclFile["System.out"].println((9 * (N->size() - 1) + (N->at(0+1) - ('0')->char2byte()))) ) else (     OclFile["System.out"].println((9 * (N->size() - 1) + (N->at(0+1) - ('1')->char2byte()))) ) ;  
 );
}
class Reader {
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   operation init( input : OclFile) : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(input)) ; 
     tokenizer := OclIterator.newOclIterator_String("") );
  static   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.out ;
import java.awt.image.IndexColorModel ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    long N=sc.nextLong();
    ArrayList<Integer>list=new ArrayList();
    String[] str=String.valueOf(N).split("");
    int length=str.length ;
    int[] array=createInt(str,length);
    list.add(plusN(array,length));
    boolean flag=length==1 ;
    list.add(squat(length-1,array));
    System.out.println(Math.max(list.get(0),list.get(1)));
  }
  static int squat(int length,int[] array){
    return array[0]+length*9-1 ;
  }
  static int[] createInt(String[] str,int length){
    int[] array=new int[length];
    int i=0 ;
    for(String s : str){
      array[i++]=Integer.parseInt(s);
    }
    return array ;
  }
  static int plusN(int[] str,int length){
    int count=0 ;
    for(int s : str){
      count+=s ;
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := sc.getCurrent()->toLong() ;
     var list : Sequence(int) ; list := Sequence{} ;
    var str : Sequence(String) ; str := ((N) + "")->split("") ;
    var length : int ; length := str->size() ;
    var array : Sequence(int) ; array := createInt(str, length) ;
    list := list->including(plusN(array, length)) ; 
    var flag : boolean ; flag := length = 1 ;
    list := list->including(squat(length - 1, array)) ; 
    OclFile["System.out"].println(Set{list->at(0+1), list->at(1+1)}->max()) ; 
 );
  static   operation squat( length : int, array : Sequence(int)) : int
  pre: true
  post: true
  activity: (     return array[0+1] + length * 9 - 1 );
  static   operation createInt( str : Sequence(String), length : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Integer.subrange(1,length)->collect(0) ;
     var i : int ; i := 0 ;
     for (s : str) do ( (      array[i+1] := (s)->toInteger()  ; i := i + 1 )  ) ; 
     return array );
  static   operation plusN( str : Sequence(int), length : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     for (s : str) do ( (     count := count+(s) )  ) ; 
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static Scanner sc ;
  private static Printer pr ;
  private static void solve(){
    long n=sc.nextLong();
    int max=cnt(n);
    for(int i=1 ; true ; i++){
      long tmp=n+1 ;
      for(int j=0 ; j<i ; j++){
        tmp/=10 ;
      }
      tmp-=1 ;
      if(tmp<0){
        break ;
      }
      for(int j=0 ; j<i ; j++){
        tmp*=10 ;
        tmp+=9 ;
      }
      max=Math.max(max,cnt(tmp));
    }
    pr.println(max);
  }
  private static int cnt(long n){
    int cnt=0 ;
    long tmp=n ;
    while(tmp>0){
      cnt+=tmp % 10 ;
      tmp/=10 ;
    }
    return cnt ;
  }
  public static void main(String[] args){
    sc=new Scanner(System.in);
    pr=new Printer(System.out);
    solve();
    pr.close();
    sc.close();
  }
  private static class Printer extends PrintWriter {
    Printer(PrintStream out){
      super(out);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile;
  static   attribute pr : Printer;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.getCurrent()->toLong() ;
     var max : int ; max := cnt(n) ;
         var i : int ; i := 1 ; while true do ( (     var tmp : long ; tmp := n + 1 ;
         var j : int ; j := 0 ; while j < i do ( (     tmp := tmp/(10) )  ;     j := j + 1 ) ; 
    tmp := tmp-(1) ; 
    if (tmp < 0) then (     break ) else skip ; 
        var j : int ; j := 0 ; while j < i do ( (     tmp := tmp*(10) ; 
     tmp := tmp+(9) )  ;     j := j + 1 ) ; 
    max := Set{max, cnt(tmp)}->max() ; 
 )  ;     i := i + 1 ) ; 
     pr.println(max) );
  static   operation cnt( n : long) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var tmp : long ; tmp := n ;
     while (tmp > 0) do (     cnt := cnt+(tmp mod 10) ; 
     tmp := tmp/(10) ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     pr := Printer.newPrinter(OclFile["System.out"]) ; 
    execute solve() ; 
    pr.close() ; 
    skip ; 
 );
  static class Printer extends OclFile {
   static operation newPrinter( out : OclFile) : Printer
  pre: true
  post: true
  activity:
  ( var self : Printer ;
    self := createPrinter();
    self.initialise(out);
    return self );
  operation initialise( out : OclFile) : void
  pre: true  post: true
  activity: (     execute super(out) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void PowerOfTwo(int[] x,int n){
    Arrays.sort(x);
    ArrayList<Integer>res=new ArrayList<Integer>();
    for(int i=0 ; i<n ; ++i){
      for(int j=1 ; j<31 ; ++j){
        int lx=x[i]-(1<<j);
        int rx=x[i]+(1<<j);
        boolean isl=Arrays.binarySearch(x,lx)<0 ? false : true ;
        boolean isr=Arrays.binarySearch(x,rx)<0 ? false : true ;
        if(isl && isr && res.size()<3){
          res.clear();
          res.add(lx);
          res.add(x[i]);
          res.add(rx);
        }
        if(isl && res.size()<2){
          res.clear();
          res.add(lx);
          res.add(x[i]);
        }
        if(isr && res.size()<2){
          res.clear();
          res.add(x[i]);
          res.add(rx);
        }
      }
    }
    if(res.size()==0){
      System.out.println("-1");
      return ;
    }
    for(int i=0 ; i<res.size(); i++)System.out.print(res.get(i)+" ");
  }
  public static void main(String[] args){
    int[] a={
      3,4,5,6,7 };
      int n=a.length ;
      PowerOfTwo(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation PowerOfTwo( x : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     x := x->sort() ; 
     var res : Sequence(int) ; res := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 1 ; while j < 31 do ( (     var lx : int ; lx := x[i+1] - ((1*(2->pow(j)))->oclAsType(long)) ;
     var rx : int ; rx := x[i+1] + ((1*(2->pow(j)))->oclAsType(long)) ;
    var isl : boolean ; isl := if (x->indexOf(lx) - 1) < 0 then false else true endif ;
    var isr : boolean ; isr := if (x->indexOf(rx) - 1) < 0 then false else true endif ;
    if (isl & isr & res->size() < 3) then (     res := res->intersection(Set{}) ; 
     res := res->including(lx) ; 
     res := res->including(x[i+1]) ; 
     res := res->including(rx) ) else skip ; 
    if (isl & res->size() < 2) then (     res := res->intersection(Set{}) ; 
     res := res->including(lx) ; 
     res := res->including(x[i+1]) ) else skip ; 
    if (isr & res->size() < 2) then (     res := res->intersection(Set{}) ; 
     res := res->including(x[i+1]) ; 
     res := res->including(rx) ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (res->size() = 0) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < res->size() do (     OclFile["System.out"].print(res->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{3,4,5,6,7} ;
     var n : int ; n := a->size() ;
     execute PowerOfTwo(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int[] dp=new int[1024];
  static int get_binary(int u){
    int ans=0 ;
    while(u>0){
      int rem=u % 10 ;
      ans |=(1<<rem);
      u/=10 ;
    }
    return ans ;
  }
  static int recur(int u,int[] array,int n){
    if(u==0)return 0 ;
    if(dp[u]!=-1)return dp[u];
    for(int i=0 ; i<n ; i++){
      int mask=get_binary(array[i]);
      if((mask | u)==u){
        dp[u]=Math.max(Math.max(0,dp[u ^ mask])+array[i],dp[u]);
      }
    }
    return dp[u];
  }
  static int solve(int[] array,int n){
    for(int i=0 ; i<(1<<10); i++){
      dp[i]=-1 ;
    }
    int ans=0 ;
    for(int i=0 ; i<(1<<10); i++){
      ans=Math.max(ans,recur(i,array,n));
    }
    return ans ;
  }
  static public void main(String[] args){
    int[] array={
      22,132,4,45,12,223 };
      int n=array.length ;
      System.out.println(solve(array,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute dp : Sequence(int) := Integer.subrange(1,1024)->collect(0);
  static   operation get_binary( u : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     while (u > 0) do (     var rem : int ; rem := u mod 10 ;
     ans := MathLib.bitwiseOr(ans, ((1*(2->pow(rem)))->oclAsType(long))) ; 
     u := u/(10) ) ; 
     return ans );
  static   operation recur( u : int, array : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (u = 0) then     return 0 else skip ; 
     if (dp[u+1] /= -1) then     return dp[u+1] else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     var mask : int ; mask := get_binary(array[i+1]) ;
     if ((MathLib.bitwiseOr(mask,u)) = u) then (     dp[u+1] := Set{Set{0, dp[u xor mask+1]}->max() + array[i+1], dp[u+1]}->max() ) else skip )  ;     i := i + 1 ) ; 
     return dp[u+1] );
  static   operation solve( array : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < ((1*(2->pow(10)))->oclAsType(long)) do ( (     dp[i+1] := -1 )  ;     i := i + 1 ) ; 
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < ((1*(2->pow(10)))->oclAsType(long)) do ( (     ans := Set{ans, recur(i, array, n)}->max() )  ;     i := i + 1 ) ; 
     return ans );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Sequence{22,132,4,45,12,223} ;
     var n : int ; n := array->size() ;
     OclFile["System.out"].println(solve(array, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int a ;
    int[] check ;
    int i,sum ;
    check=new int[10];
    for(; sc.hasNext(); ){
      for(i=0 ; i<10 ; i++)check[i]=0 ;
      sum=0 ;
      a=sc.nextInt();
      sum+=a ;
      for(i=0 ; i<10 ; i++)if(a==i+1)check[a-1]++;
      a=sc.nextInt();
      sum+=a ;
      for(i=0 ; i<10 ; i++)if(a==i+1)check[a-1]++;
      a=sc.nextInt();
      for(i=0 ; i<10 ; i++)if(a==i+1)check[a-1]++;
      a=0 ;
      for(i=0 ; i<10 ; i++)if(i+1<=20-sum && check[i]==0)a++;
      if(a>3)out.println("YES");
      else out.println("NO");
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var a : int ;
    var check : Sequence(int) ;
    var i : int ;
    var sum : int ;
    check := Integer.subrange(1,10)->collect(0) ; 
      while sc.hasNext() do ( (         i := 0 ; while i < 10 do (     check[i+1] := 0 ;  ;     i := i + 1 ) ; 
     sum := 0 ; 
    a := sc.nextInt() ; 
    sum := sum+(a) ; 
        i := 0 ; while i < 10 do (     if (a = i + 1) then     check[a - 1+1] := check[a - 1+1] + 1 ; else skip ;  ;     i := i + 1 ) ; 
    a := sc.nextInt() ; 
    sum := sum+(a) ; 
        i := 0 ; while i < 10 do (     if (a = i + 1) then     check[a - 1+1] := check[a - 1+1] + 1 ; else skip ;  ;     i := i + 1 ) ; 
    a := sc.nextInt() ; 
        i := 0 ; while i < 10 do (     if (a = i + 1) then     check[a - 1+1] := check[a - 1+1] + 1 ; else skip ;  ;     i := i + 1 ) ; 
    a := 0 ; 
        i := 0 ; while i < 10 do (     if (i + 1 <= 20 - sum & check[i+1] = 0) then     a := a + 1 ; else skip ;  ;     i := i + 1 ) ; 
    if (a > 3) then     out.println("YES") else     out.println("NO") ; ;  
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findMaxOddSubarraySum(int arr[],int n){
    int min_odd=Integer.MAX_VALUE ;
    boolean isOdd=false ;
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]>0)sum=sum+arr[i];
      if(arr[i] % 2!=0){
        isOdd=true ;
        if(min_odd>Math.abs(arr[i]))min_odd=Math.abs(arr[i]);
      }
    }
    if(isOdd==false)return-1 ;
    if(sum % 2==0)sum=sum-min_odd ;
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      2,-3,5,-1,4 };
      int n=arr.length ;
      System.out.println(findMaxOddSubarraySum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMaxOddSubarraySum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var min_odd : int ; min_odd := 2147483647 ;
     var isOdd : boolean ; isOdd := false ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] > 0) then     sum := sum + arr[i+1] ; else skip ; 
     if (arr[i+1] mod 2 /= 0) then (     isOdd := true ; 
     if (min_odd > if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif) then     min_odd := if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif ; else skip ) else skip )  ;     i := i + 1 ) ; 
    if (isOdd = false) then     return -1 else skip ; 
    if (sum mod 2 = 0) then     sum := sum - min_odd ; else skip ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,-3,5,-1,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMaxOddSubarraySum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean allBitsSetInTheGivenRange(int n,int l,int r){
    int num=((1<<r)-1)^((1<<(l-1))-1);
    int new_num=n & num ;
    if(new_num==0)return true ;
    return false ;
  }
  public static void main(String[] args){
    int n=17 ;
    int l=2,r=4 ;
    if(allBitsSetInTheGivenRange(n,l,r))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation allBitsSetInTheGivenRange( n : int, l : int, r : int) : boolean
  pre: true
  post: true
  activity: (     var num : int ; num := MathLib.bitwiseXor((((1*(2->pow(r)))->oclAsType(long)) - 1),(((1*(2->pow((l - 1))))->oclAsType(long)) - 1)) ;
     var new_num : int ; new_num := MathLib.bitwiseAnd(n,num) ;
     if (new_num = 0) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 17 ;
     var l : int ; l := 2 ;
    var r : int ; r := 4 ;
     if (allBitsSetInTheGivenRange(n, l, r)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int cs=sc.nextInt();
    for(int dz=0 ; dz<cs ; dz++){
      int time=sc.nextInt();
      int[][] section=new int[time][2];
      for(int dz1=0 ; dz1<time ; dz1++){
        section[dz1][0]=sc.nextInt();
        section[dz1][1]=sc.nextInt();
      }
      for(int dz1=0 ; dz1<time ; dz1++){
        if(section[dz1][0]==section[dz1][1])System.out.println(section[dz1][0]+" "+section[dz1][0]+" "+section[dz1][0]);
        else {
          HashSet<Integer>set=new HashSet<>();
          for(int dz2=section[dz1][0]; dz2<=section[dz1][1]; dz2++)set.add(dz2);
          for(int dz2=0 ; dz2<time ; dz2++){
            if(dz2==dz1)continue ;
            if(section[dz2][0]>=section[dz1][0] && section[dz2][1]<=section[dz1][1]){
              for(int dz3=section[dz2][0]; dz3<=section[dz2][1]; dz3++){
                if(set.contains(dz3))set.remove(dz3);
                if(set.size()==1)break ;
              }
            }
          }
          for(int a : set)System.out.println(section[dz1][0]+" "+section[dz1][1]+" "+a);
        }
      }
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cs : int ; cs := sc.getCurrent()->toInteger() ;
         var dz : int ; dz := 0 ; while dz < cs do ( (     var time : int ; time := sc.getCurrent()->toInteger() ;
     var section : Sequence(Sequence(int)) ; section := Integer.subrange(1,time)->collect(Integer.subrange(1,2)->collect(0)) ;
         var dz1 : int ; dz1 := 0 ; while dz1 < time do ( (     section[dz1+1][0+1] := sc.getCurrent()->toInteger() ; 
     section[dz1+1][1+1] := sc.getCurrent()->toInteger() )  ;     dz1 := dz1 + 1 ) ; 
         var dz1 : int ; dz1 := 0 ; while dz1 < time do ( (     if (section[dz1+1][0+1] = section[dz1+1][1+1]) then     OclFile["System.out"].println(section[dz1+1][0+1] + " " + section[dz1+1][0+1] + " " + section[dz1+1][0+1]) ; else (     var set : Set(int) ; set := Set{} ;
         var dz2 : int ; dz2 := section[dz1+1][0+1] ; while dz2 <= section[dz1+1][1+1] do (     set := set->including(dz2) ;  ;     dz2 := dz2 + 1 ) ; 
         var dz2 : int ; dz2 := 0 ; while dz2 < time do ( (     if (dz2 = dz1) then     continue else skip ; 
     if (section[dz2+1][0+1] >= section[dz1+1][0+1] & section[dz2+1][1+1] <= section[dz1+1][1+1]) then (         var dz3 : int ; dz3 := section[dz2+1][0+1] ; while dz3 <= section[dz2+1][1+1] do ( (     if (set->includes(dz3)) then     set := set->excludingAt(dz3+1) ; else skip ; 
     if (set->size() = 1) then     break else skip )  ;     dz3 := dz3 + 1 ) ) else skip )  ;     dz2 := dz2 + 1 ) ; 
     for (a : set) do (     OclFile["System.out"].println(section[dz1+1][0+1] + " " + section[dz1+1][1+1] + " " + a) ;  ) ) )  ;     dz1 := dz1 + 1 ) )  ;     dz := dz + 1 ) ; 
     return );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Test3 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long k=sc.nextLong();
    while(k-->0){
      if(n % 10==0){
        n/=10 ;
      }
      else {
        n--;
      }
    }
    System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
        while (k > 0) do (        k := k - 1 ;     skip ; (     if (n mod 10 = 0) then (     n := n/(10) ) else (     n := n - 1 ) ) ;  ) ;  
    OclFile["System.out"].println(n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner var=new Scanner(System.in);
    int v1=var.nextInt();
    int v2=var.nextInt();
    int restante=0 ;
    for(int i=0 ; i<v2 ; i++){
      restante=v1 % 10 ;
      if(restante!=0){
        v1=v1-1 ;
      }
      else if(restante==0){
        v1=v1/10 ;
      }
    }
    System.out.println(v1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var var : OclFile ; var := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var v1 : int ; v1 := var.getCurrent()->toInteger() ;
    var v2 : int ; v2 := var.getCurrent()->toInteger() ;
    var restante : int ; restante := 0 ;
        var i : int ; i := 0 ; while i < v2 do ( (     restante := v1 mod 10 ; 
     if (restante /= 0) then (     v1 := v1 - 1 ) else     if (restante = 0) then (     v1 := v1 / 10 ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(v1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner leer=new Scanner(System.in);
    long entrada1=leer.nextLong();
    int entrada2=leer.nextInt();
    for(int i=1 ; i<=entrada2 ; i++){
      long n=entrada1 % 10 ;
      if(n==0){
        entrada1=entrada1/10 ;
      }
      else {
        entrada1=entrada1-1 ;
      }
    }
    System.out.println(entrada1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var leer : OclFile ; leer := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var entrada1 : long ; entrada1 := leer.getCurrent()->toLong() ;
    var entrada2 : int ; entrada2 := leer.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= entrada2 do ( (     var n : long ; n := entrada1 mod 10 ;
     if (n = 0) then (     entrada1 := entrada1 / 10 ) else (     entrada1 := entrada1 - 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(entrada1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner entrada=new Scanner(System.in);
    long a=entrada.nextLong();
    int b=entrada.nextInt();
    for(int i=1 ; i<=b ; i++){
      long n=a % 10 ;
      if(n==0){
        a=a/10 ;
      }
      else {
        a=a-1 ;
      }
    }
    System.out.println(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var entrada : OclFile ; entrada := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := entrada.getCurrent()->toLong() ;
    var b : int ; b := entrada.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= b do ( (     var n : long ; n := a mod 10 ;
     if (n = 0) then (     a := a / 10 ) else (     a := a - 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    try {
      int a,b ;
      String num ;
      a=sc.nextInt();
      b=sc.nextInt();
      num=a+"" ;
      while(b!=0){
        if(num.charAt(num.length()-1)!='0'){
          a--;
          num=a+"" ;
        }
        else {
          num=num.substring(0,num.length()-1);
          a=Integer.valueOf(num);
        }
        b--;
      }
      System.out.println(a);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     try (     var a : int ;
    var b : int ;
     var num : String ;
    a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    num := a + "" ; 
    while (b /= 0) do (     if (num->at(num->size() - 1+1) /= '0') then (     a := a - 1 ; 
     num := a + "" ) else (     num := num.subrange(0+1,num->size() - 1) ; 
     a := (num)->toInteger() ) ;  
     b := b - 1 ) ; 
    OclFile["System.out"].println(a) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.io.*;
class GFG {
  static int CalculateMax(int arr[],int n){
    Arrays.sort(arr);
    int min_sum=arr[0]+arr[1];
    int max_sum=arr[n-1]+arr[n-2];
    return(Math.abs(max_sum-min_sum));
  }
  public static void main(String[] args){
    int arr[]={
      6,7,1,11 };
      int n=arr.length ;
      System.out.println(CalculateMax(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation CalculateMax( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var min_sum : int ; min_sum := arr[0+1] + arr[1+1] ;
     var max_sum : int ; max_sum := arr[n - 1+1] + arr[n - 2+1] ;
     return (if max_sum - min_sum < 0 then -(max_sum - min_sum) else max_sum - min_sum endif) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,7,1,11} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(CalculateMax(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int d=sc.nextInt();
    sc.close();
    System.out.println((n+d*2)/(d*2+1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    skip ; 
    OclFile["System.out"].println((n + d * 2) / (d * 2 + 1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static int segregate(int arr[],int size){
    int j=0,i ;
    for(i=0 ; i<size ; i++){
      if(arr[i]<=0){
        int temp ;
        temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp ;
        j++;
      }
    }
    return j ;
  }
  static int findMissingPositive(int arr[],int size){
    int i ;
    for(i=0 ; i<size ; i++){
      int x=Math.abs(arr[i]);
      if(x-1<size && arr[x-1]>0)arr[x-1]=-arr[x-1];
    }
    for(i=0 ; i<size ; i++)if(arr[i]>0)return i+1 ;
    return size+1 ;
  }
  static int findMissing(int arr[],int size){
    int shift=segregate(arr,size);
    int arr2[]=new int[size-shift];
    int j=0 ;
    for(int i=shift ; i<size ; i++){
      arr2[j]=arr[i];
      j++;
    }
    return findMissingPositive(arr2,j);
  }
  public static void main(String[] args){
    int arr[]={
      0,10,2,-10,-20 };
      int arr_size=arr.length ;
      int missing=findMissing(arr,arr_size);
      System.out.println("The smallest positive missing number is "+missing);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation segregate( arr : Sequence(int), size : int) : int
  pre: true
  post: true
  activity: (     var j : int ; j := 0 ;
    var i : int ;
         i := 0 ; while i < size do ( (     if (arr[i+1] <= 0) then (     var temp : int ;
     temp := arr[i+1] ; 
    arr[i+1] := arr[j+1] ; 
    arr[j+1] := temp ; 
    j := j + 1 ; 
 ) else skip )  ;     i := i + 1 ) ; 
     return j );
  static   operation findMissingPositive( arr : Sequence(int), size : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
         i := 0 ; while i < size do ( (     var x : int ; x := if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif ;
     if (x - 1 < size & arr[x - 1+1] > 0) then     arr[x - 1+1] := -arr[x - 1+1] ; else skip )  ;     i := i + 1 ) ; 
         i := 0 ; while i < size do (     if (arr[i+1] > 0) then     return i + 1 else skip ;  ;     i := i + 1 ) ; 
     return size + 1 );
  static   operation findMissing( arr : Sequence(int), size : int) : int
  pre: true
  post: true
  activity: (     var shift : int ; shift := segregate(arr, size) ;
     var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,size - shift)->collect(0) ;
    var j : int ; j := 0 ;
        var i : int ; i := shift ; while i < size do ( (     arr2[j+1] := arr[i+1] ; 
     j := j + 1 )  ;     i := i + 1 ) ; 
    return findMissingPositive(arr2, j) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,10,2,-10,-20} ;
     var arr_size : int ; arr_size := arr->size() ;
     var missing : int ; missing := findMissing(arr, arr_size) ;
     OclFile["System.out"].println("The smallest positive missing number is " + missing) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve(args);
  }
  public void solve(String[] args){
    MyScanner scanner=new MyScanner();
    int n=scanner.nextInt();
    int d=scanner.nextInt();
    int ans ;
    int tmp ;
    tmp=d*2+1 ;
    ans=n/tmp ;
    if(n % tmp!=0){
      ans++;
    }
    System.out.println(ans);
  }
  private static long gcd(long m,long n){
    if(m<n)return gcd(n,m);
    if(n==0)return m ;
    return gcd(n,m % n);
  }
  private static long lcm(long m,long n){
    return m*n/gcd(m,n);
  }
  private class MyScanner {
    String[] s ;
    int i ;
    BufferedReader br ;
    String reg=" " ;
    MyScanner(){
      s=new String[0];
      i=0 ;
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public String next(){
      try {
        if(i<s.length)return s[i++];
        String line=br.readLine();
        while(line.equals("")){
          line=br.readLine();
        }
        s=line.split(reg,0);
        i=0 ;
        return s[i++];
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return null ;
    }
    public int nextInt(){
      try {
        return Integer.parseInt(next());
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return-1 ;
    }
    public double nextDouble(){
      try {
        return Double.parseDouble(next());
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return-1 ;
    }
    public long nextLong(){
      try {
        return Long.parseLong(next());
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return-1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve(args) );
   operation solve( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : MyScanner ; scanner := MyScanner.newMyScanner() ;
     var n : int ; n := scanner.nextInt() ;
    var d : int ; d := scanner.nextInt() ;
    var ans : int ;
    var tmp : int ;
    tmp := d * 2 + 1 ; 
    ans := n / tmp ; 
    if (n mod tmp /= 0) then (     ans := ans + 1 ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation gcd( m : long, n : long) : long
  pre: true
  post: true
  activity: (     if (m < n) then     return gcd(n, m) else skip ; 
     if (n = 0) then     return m else skip ; 
     return gcd(n, m mod n) );
  static   operation lcm( m : long, n : long) : long
  pre: true
  post: true
  activity: (     return m * n / gcd(m, n) );
 class MyScanner {
   attribute s : Sequence(String);
   attribute i : int;
   attribute br : OclFile;
   attribute reg : String := " ";
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     s := Integer.subrange(1,0)->collect(null) ; 
     i := 0 ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     if (i < s->size()) then     return s[i+1] else skip ; 
     var line : String ; line := br.readLine() ;
    while (line = "") do (     line := br.readLine() ) ; 
    s := line->split(reg) ; 
    i := 0 ; 
    return s[i+1] 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     try (     return (next())->toInteger() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return -1 );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     try (     return (next())->toReal() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return -1 );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     try (     return (next())->toLong() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return -1 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.nio.charset.StandardCharsets ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader reader=new InputStreamReader(System.in,StandardCharsets.UTF_8);
    BufferedReader in=new BufferedReader(reader);
    String[] tokens=in.readLine().split(" ");
    int N=Integer.parseInt(tokens[0]);
    int D=Integer.parseInt(tokens[1]);
    int result=(N/(2*D+1));
    if(N %(2*D+1)!=0){
      result++;
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"], StandardCharsets.UTF_8) ;
     var in : OclFile ; in := OclFile.newOclFile_Read(reader) ;
    var tokens : Sequence(String) ; tokens := in.readLine()->split(" ") ;
    var N : int ; N := (tokens[0+1])->toInteger() ;
    var D : int ; D := (tokens[1+1])->toInteger() ;
    var result : int ; result := (N / (2 * D + 1)) ;
    if (N mod (2 * D + 1) /= 0) then (     result := result + 1 ) else skip ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class little_elephant {
  public static void main(String args[]){
    int[][] m=new int[3][3];
    Scanner in=new Scanner(System.in);
    int[] a=new int[3];
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<3 ; j++){
        m[i][j]=in.nextInt();
        a[i]+=m[i][j];
      }
    }
    int sum=(a[0]+a[1]+a[2])/2 ;
    m[0][0]=sum-a[0];
    m[1][1]=sum-a[1];
    m[2][2]=sum-a[2];
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<3 ; j++){
        System.out.print(m[i][j]+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class little_elephant {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Sequence(Sequence(int)) ; m := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     m[i+1][j+1] := in.getCurrent()->toInteger() ; 
     a[i+1] := a[i+1]+(m[i+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := (a[0+1] + a[1+1] + a[2+1]) / 2 ;
    m[0+1][0+1] := sum - a[0+1] ; 
    m[1+1][1+1] := sum - a[1+1] ; 
    m[2+1][2+1] := sum - a[2+1] ; 
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     OclFile["System.out"].print(m[i+1][j+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  static final long MOD=1000000007 ;
  public static void main(String[] args){
    final Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int d=scanner.nextInt();
    d=d+d+1 ;
    if(n % d==0){
      System.out.println(n/d);
    }
    else {
      System.out.println(n/d+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var d : int ; d := scanner.getCurrent()->toInteger() ;
    d := d + d + 1 ; 
    if (n mod d = 0) then (     OclFile["System.out"].println(n / d) ) else (     OclFile["System.out"].println(n / d + 1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  static final PrintStream out=System.out ;
  static Scanner sc=new Scanner(System.in);
  static final long Mod=1000_000_007L ;
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
    System.exit(0);
  }
  void solve(){
    int N=sc.nextInt();
    int D=sc.nextInt();
    int surveil=D*2+1 ;
    int res=N/surveil+1 ;
    if(N % surveil==0)res--;
    out.println(res);
  }
  public int[] nextIntArray(int n){
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public long[] nextLongArray(int n){
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=nextLong();
    return a ;
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
  public String next(){
    return sc.next();
  }
  long gcd(long m,long n){
    if(m<n)return gcd(n,m);
    if(n==0)return m ;
    return gcd(n,m % n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute out : OclFile := OclFile["System.out"];
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute Mod : long := 1000_000_007L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() ; 
 OclProcess.exit(0) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var D : int ; D := sc.getCurrent()->toInteger() ;
    var surveil : int ; surveil := D * 2 + 1 ;
    var res : int ; res := N / surveil + 1 ;
    if (N mod surveil = 0) then     res := res - 1 ; else skip ; 
    skip ; 
 );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation next() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
   operation gcd( m : long, n : long) : long
  pre: true
  post: true
  activity: (     if (m < n) then     return gcd(n, m) else skip ; 
     if (n = 0) then     return m else skip ; 
     return gcd(n, m mod n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public class P {
    public double x ;
    public double y ;
    public P(double x,double y){
      this.x=x ;
      this.y=y ;
    }
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int r,a ;
    int angle=0 ;
    P p=new P(0,0);
    while(true){
      String[] str=sc.next().split(",");
      r=Integer.parseInt(str[0]);
      a=Integer.parseInt(str[1]);
      if(r==0 && a==0){
        break ;
      }
      p.x=p.x+r*Math.sin(angle*Math.PI/180);
      p.y=p.y+r*Math.cos(angle*Math.PI/180);
      angle+=a ;
    }
    System.out.println((int)p.x);
    System.out.println((int)p.y);
    sc.close();
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class P {
   attribute x : double;
   attribute y : double;
   static operation newP( x : double, y : double) : P
  pre: true
  post: true
  activity:
  ( var self : P ;
    self := createP();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ;
    var a : int ;
    var angle : int ; angle := 0 ;
    var p : P ; p := P.newP(0, 0) ;
    while (true) do (     var str : Sequence(String) ; str := sc.getCurrent()->split(",") ;
     r := (str[0+1])->toInteger() ; 
    a := (str[1+1])->toInteger() ; 
    if (r = 0 & a = 0) then (     break ) else skip ; 
    p.x := p.x + r * (angle * 3.141592653589793 / 180)->sin() ; 
    p.y := p.y + r * (angle * 3.141592653589793 / 180)->cos() ; 
    angle := angle+(a) ; 
 ) ; 
    OclFile["System.out"].println(p.x->oclAsType(int)) ; 
    OclFile["System.out"].println(p.y->oclAsType(int)) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    try {
      BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
      String st ;
      int d,t=0 ;
      double x=0.0,y=0.0,deg ;
      while(true){
        st=sc.readLine();
        if(st.equals("0,0"))break ;
        String[] s=st.split(",");
        d=Integer.valueOf(s[0]);
        deg=Math.toRadians(t);
        x+=d*Math.sin(deg);
        y+=d*Math.cos(deg);
        t+=Integer.valueOf(s[1]);
      }
      System.out.printf("%d\n%d\n",(int)x,(int)y);
    }
    catch(Exception e){
      System.out.println("Error");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : String ;
    var d : int ;
    var t : int ; t := 0 ;
    var x : double ; x := 0.0 ;
    var y : double ; y := 0.0 ;
    var deg : double ;
    while (true) do (     st := sc.readLine() ; 
     if (st = "0,0") then     break else skip ; 
    var s : Sequence(String) ; s := st->split(",") ;
    d := (s[0+1])->toInteger() ; 
    deg := (0.017453292519943295*(t)) ; 
    x := x+(d * (deg)->sin()) ; 
    y := y+(d * (deg)->cos()) ; 
    t := t+((s[1+1])->toInteger()) ; 
 ) ; 
    OclFile["System.out"].printf("%d\n%d\n", x->oclAsType(int), y->oclAsType(int)) ; 
 )   catch (e : ProgramException) do (     OclFile["System.out"].println("Error") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.io.*;
import java.math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(isr);
    int r ;
    boolean flag=true ;
    double x=0,y=0,theta=0 ;
    String stL=br.readLine();
    String[] st=stL.split(",");
    r=Integer.parseInt(st[0]);
    if("0".equals(st[0])&& "0".equals(st[1]))flag=false ;
    while(flag){
      x+=r*(Math.cos(theta));
      y+=r*(Math.sin(theta));
      theta+=Math.toRadians(Integer.parseInt(st[1]));
      stL=br.readLine();
      st=stL.split(",");
      r=Integer.parseInt(st[0]);
      if("0".equals(st[0])&& "0".equals(st[1]))flag=false ;
    }
    System.out.println((int)y);
    System.out.println((int)x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
    var r : int ;
    var flag : boolean ; flag := true ;
    var x : double ; x := 0 ;
    var y : double ; y := 0 ;
    var theta : double ; theta := 0 ;
    var stL : String ; stL := br.readLine() ;
    var st : Sequence(String) ; st := stL->split(",") ;
    r := (st[0+1])->toInteger() ; 
    if ("0" = st[0+1] & "0" = st[1+1]) then     flag := false ; else skip ; 
    while (flag) do (     x := x+(r * ((theta)->cos())) ; 
     y := y+(r * ((theta)->sin())) ; 
    theta := theta+((0.017453292519943295*((st[1+1])->toInteger()))) ; 
    stL := br.readLine() ; 
    st := stL->split(",") ; 
    r := (st[0+1])->toInteger() ; 
    if ("0" = st[0+1] & "0" = st[1+1]) then     flag := false ; else skip ; 
 ) ; 
    OclFile["System.out"].println(y->oclAsType(int)) ; 
    OclFile["System.out"].println(x->oclAsType(int)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    Position currentPosition=new Position();
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String input ;
    while((input=br.readLine())!=null){
      String[] i=input.split(",");
      int distance=Integer.parseInt(i[0]);
      int angle=Integer.parseInt(i[1]);
      if(distance==0 && angle==0)break ;
      currentPosition.move(distance,angle);
    }
    System.out.println(currentPosition);
    br.close();
  }
}
class Position {
  private double x ;
  private double y ;
  private int currentAngle ;
  public Position(){
    x=0.0 ;
    y=0.0 ;
    currentAngle=90 ;
  }
  public void move(int distance,int angle){
    x+=distance*Math.cos(Math.toRadians(currentAngle));
    y+=distance*Math.sin(Math.toRadians(currentAngle));
    currentAngle-=angle ;
  }
  @ Override public String toString(){
    return(int)x+"\n"+(int)y ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var currentPosition : Position ; currentPosition := Position.newPosition() ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var input : String ;
        input := br.readLine() ;
    while ((input) /= null) do (    skip ; (     var i : Sequence(String) ; i := input->split(",") ;
     var distance : int ; distance := (i[0+1])->toInteger() ;
    var angle : int ; angle := (i[1+1])->toInteger() ;
    if (distance = 0 & angle = 0) then     break else skip ; 
    currentPosition.move(distance, angle) ; 
 ) ;     input := br.readLine() ;
 ) ;  
    OclFile["System.out"].println(currentPosition) ; 
    skip ; 
 );
}
class Position {
   attribute x : double;
   attribute y : double;
   attribute currentAngle : int;
   static operation newPosition() : Position
  pre: true
  post: true
  activity:
  ( var self : Position ;
    self := createPosition();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     x := 0.0 ; 
     y := 0.0 ; 
     currentAngle := 90 );
   operation move( distance : int, angle : int) : void
  pre: true
  post: true
  activity: (     x := x+(distance * ((0.017453292519943295*(currentAngle)))->cos()) ; 
     y := y+(distance * ((0.017453292519943295*(currentAngle)))->sin()) ; 
     currentAngle := currentAngle-(angle) );
      operation toString() : String
  pre: true
  post: true
  activity: (     return x->oclAsType(int) + "\n" + y->oclAsType(int) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    char c=s.charAt(0);
    System.out.println(++c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
     var c : String ; c := s->at(0+1) ;
     OclFile["System.out"].println((c + 1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] a=new int[17];
    int[] out=new int[101];
    int[] time=new int[] {
      19,39,25,36,22,42 };
      ArrayList<Integer>wait=new ArrayList<Integer>();
      Arrays.fill(a,-1);
      int p,q ;
      boolean flag ;
      boolean check ;
      for(int i=0 ; i<567 ; i++){
        for(int j=0 ; j<17 ; j++){
          if(a[j]==i)a[j]=-1 ;
        }
        if(i % 5==0)wait.add(i/5);
        while(wait.size()!=0){
          check=false ;
          p=wait.get(0);
          q=2 ;
          if(p % 5==1)q=5 ;
          for(int j=0 ; j<18-q ; j++){
            flag=true ;
            for(int k=0 ; k<q ; k++){
              if(a[j+k]!=-1)flag=false ;
            }
            if(flag==true){
              out[p]=i+time[p % 6];
              for(int k=0 ; k<q ; k++)a[j+k]=out[p];
              check=true ;
              wait.remove(0);
              break ;
            }
          }
          if(check==false)break ;
        }
      }
      while(sc.hasNext()){
        int n=sc.nextInt();
        System.out.println(out[n]-time[n % 6]-n*5);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,17)->collect(0) ;
    var out : Sequence(int) ; out := Integer.subrange(1,101)->collect(0) ;
    var time : Sequence(int) ; time := Sequence{19,39,25,36,22,42} ;
    var wait : Sequence(int) ; wait := Sequence{} ;
    a := a->collect(-1) ; 
    var p : int ;
    var q : int ;
    var flag : boolean ;
    var check : boolean ;
        var i : int ; i := 0 ; while i < 567 do ( (         var j : int ; j := 0 ; while j < 17 do ( (     if (a[j+1] = i) then     a[j+1] := -1 ; else skip )  ;     j := j + 1 ) ; 
     if (i mod 5 = 0) then     wait := wait->including(i / 5) ; else skip ; 
     while (wait->size() /= 0) do (     check := false ; 
     p := wait->at(0+1) ; 
    q := 2 ; 
    if (p mod 5 = 1) then     q := 5 ; else skip ; 
        var j : int ; j := 0 ; while j < 18 - q do ( (     flag := true ; 
         var k : int ; k := 0 ; while k < q do ( (     if (a[j + k+1] /= -1) then     flag := false ; else skip )  ;     k := k + 1 ) ; 
     if (flag = true) then (     out[p+1] := i + time[p mod 6+1] ; 
         var k : int ; k := 0 ; while k < q do (     a[j + k+1] := out[p+1] ;  ;     k := k + 1 ) ; 
    check := true ; 
    wait := wait->excludingAt(0+1) ; 
    break 
 ) else skip )  ;     j := j + 1 ) ; 
    if (check = false) then     break else skip ; 
 ) )  ;     i := i + 1 ) ; 
    while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(out[n+1] - time[n mod 6+1] - n * 5) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n ;
    int z[];
    int wait[];
    Queue<Integer>g=new LinkedList<Integer>();
    z=new int[17];
    Arrays.fill(z,-1);
    wait=new int[100];
    for(int i=0 ; i<600 ; i++){
      for(int j=0 ; j<17 ; j++){
        if(z[j]==i){
          z[j]=-1 ;
        }
      }
      if(i % 5==0){
        g.add(i/5);
      }
      boolean flag=true ;
      while(g.peek()!=null && flag){
        flag=false ;
        int m=g.peek()% 5==1 ? 5 : 2 ;
        int l=g.peek();
        int index=0 ;
        boolean flag2=false ;
        for(int j=0 ; j<17 ; j++){
          flag2=true ;
          for(int k=0 ; k<m ; k++){
            if(17<=j+k || 0<=z[j+k]){
              flag2=false ;
            }
          }
          if(flag2){
            index=j ;
            break ;
          }
        }
        if(flag2){
          for(int j=0 ; j<m ; j++){
            z[index+j]=i+17*(l % 2)+3*(l % 3)+19 ;
          }
          g.poll();
          flag=true ;
        }
      }
      for(int x : g){
        if(x<100){
          wait[x]++;
        }
      }
    }
    while(sc.hasNext()){
      n=sc.nextInt();
      System.out.println(wait[n]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var z : Sequence(int) ;
    var wait : Sequence(int) ;
    var g : Sequence(int) ; g := Sequence{} ;
    z := Integer.subrange(1,17)->collect(0) ; 
    z := z->collect(-1) ; 
    wait := Integer.subrange(1,100)->collect(0) ; 
        var i : int ; i := 0 ; while i < 600 do ( (         var j : int ; j := 0 ; while j < 17 do ( (     if (z[j+1] = i) then (     z[j+1] := -1 ) else skip )  ;     j := j + 1 ) ; 
     if (i mod 5 = 0) then (     g := g->including(i / 5) ) else skip ; 
    var flag : boolean ; flag := true ;
    while (g->min() /= null & flag) do (     flag := false ; 
     var m : int ; m := if g->min() mod 5 = 1 then 5 else 2 endif ;
    var l : int ; l := g->min() ;
    var index : int ; index := 0 ;
    var flag2 : boolean ; flag2 := false ;
        var j : int ; j := 0 ; while j < 17 do ( (     flag2 := true ; 
         var k : int ; k := 0 ; while k < m do ( (     if (17 <= j + k or 0 <= z[j + k+1]) then (     flag2 := false ) else skip )  ;     k := k + 1 ) ; 
     if (flag2) then (     index := j ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (flag2) then (         var j : int ; j := 0 ; while j < m do ( (     z[index + j+1] := i + 17 * (l mod 2) + 3 * (l mod 3) + 19 )  ;     j := j + 1 ) ; 
     g := g->sort()->tail() ; 
     flag := true ) else skip ; 
 ) ; 
    for (x : g) do ( (     if (x < 100) then (     wait[x+1] := wait[x+1] + 1 ) else skip )  ) ; 
 )  ;     i := i + 1 ) ; 
    while (sc.hasNext()) do (     n := sc.getCurrent()->toInteger() ; 
     OclFile["System.out"].println(wait[n+1]) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void distSumRec(int arr[],int n,int sum,int currindex,HashSet<Integer>s){
    if(currindex>n)return ;
    if(currindex==n){
      s.add(sum);
      return ;
    }
    distSumRec(arr,n,sum+arr[currindex],currindex+1,s);
    distSumRec(arr,n,sum,currindex+1,s);
  }
  static void printDistSum(int arr[],int n){
    HashSet<Integer>s=new HashSet<>();
    distSumRec(arr,n,0,0,s);
    for(int i : s)System.out.print(i+" ");
  }
  public static void main(String[] args){
    int arr[]={
      2,3,4,5,6 };
      int n=arr.length ;
      printDistSum(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation distSumRec( arr : Sequence(int), n : int, sum : int, currindex : int, s : Set(int)) : void
  pre: true
  post: true
  activity: (     if (currindex > n) then     return else skip ; 
     if (currindex = n) then (     s->excludes(sum) ; 
     return ) else skip ; 
     execute distSumRec(arr, n, sum + arr[currindex+1], currindex + 1, s) ; 
     execute distSumRec(arr, n, sum, currindex + 1, s) );
  static   operation printDistSum( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
     execute distSumRec(arr, n, 0, 0, s) ; 
     for (i : s) do (     OclFile["System.out"].print(i + " ") ;  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4,5,6} ;
     var n : int ; n := arr->size() ;
     execute printDistSum(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a[][]=new int[3][3];
    for(int i=0 ; i<3 ; i++)for(int j=0 ; j<3 ; j++)a[i][j]=sc.nextInt();
    a[1][1]=(a[0][1]+a[2][1])/2 ;
    int T=a[0][1]+a[1][1]+a[2][1];
    a[0][0]=T-(a[1][0]+a[2][0]);
    a[2][2]=T-(a[0][2]+a[1][2]);
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<3 ; j++){
        System.out.print(a[i][j]+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < 3 do (         var j : int ; j := 0 ; while j < 3 do (     a[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    a[1+1][1+1] := (a[0+1][1+1] + a[2+1][1+1]) / 2 ; 
    var T : int ; T := a[0+1][1+1] + a[1+1][1+1] + a[2+1][1+1] ;
    a[0+1][0+1] := T - (a[1+1][0+1] + a[2+1][0+1]) ; 
    a[2+1][2+1] := T - (a[0+1][2+1] + a[1+1][2+1]) ; 
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     OclFile["System.out"].print(a[i+1][j+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printSumSeries(int N){
    float sum=0 ;
    for(int i=1 ; i<=N ; i++){
      sum+=1.0/(2*i-1);
    }
    System.out.println(sum);
  }
  public static void main(String[] args){
    int N=6 ;
    printSumSeries(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printSumSeries( N : int) : void
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
         var i : int ; i := 1 ; while i <= N do ( (     sum := sum+(1.0 / (2 * i - 1)) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sum) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 6 ;
     execute printSumSeries(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int CountPair(int arr[],int n){
    int result=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++)if(i*arr[i]>j*arr[j])result++;
    }
    return result ;
  }
  public static void main(String[] args){
    int arr[]={
      5,0,10,2,4,1,6 };
      int n=arr.length ;
      System.out.println("Count of Pairs : "+CountPair(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation CountPair( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do (     if (i * arr[i+1] > j * arr[j+1]) then     result := result + 1 ; else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,0,10,2,4,1,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Count of Pairs : " + CountPair(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void fibonacci(double n){
    double fib ;
    for(double i=0 ; i<n ; i++){
      fib=(Math.pow((1+Math.sqrt(5)),i)-Math.pow((1-Math.sqrt(5)),i))/(Math.pow(2,i)*Math.sqrt(5));
      System.out.print((int)fib+" ");
    }
  }
  public static void main(String[] args){
    double n=8 ;
    fibonacci(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation fibonacci( n : double) : void
  pre: true
  post: true
  activity: (     var fib : double ;
         var i : double ; i := 0 ; while i < n do ( (     fib := ((1 + (5)->sqrt())->pow(i) - (1 - (5)->sqrt())->pow(i)) / (2->pow(i) * (5)->sqrt()) ; 
     OclFile["System.out"].print(fib->oclAsType(int) + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 8 ;
     execute fibonacci(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.io.*;
class GFG {
  static int items(int n,int a[]){
    Arrays.sort(a);
    int z=a[n-1];
    int x=1 ;
    int s=0 ;
    for(int i=0 ; i<n-1 ; i++){
      s+=a[i];
      if(s<=z)x+=1 ;
      else break ;
    }
    return x ;
  }
  public static void main(String[] args){
    int n=5 ;
    int a[]={
      5,3,1,5,6 };
      System.out.println(items(n,a));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation items( n : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var z : int ; z := a[n - 1+1] ;
    var x : int ; x := 1 ;
    var s : int ; s := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     s := s+(a[i+1]) ; 
     if (s <= z) then     x := x+(1) ; else     break )  ;     i := i + 1 ) ; 
    return x 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var a : Sequence(int) ; a := Sequence{5,3,1,5,6} ;
     OclFile["System.out"].println(items(n, a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static long maxOR(long arr[],int n,int k,int x){
    long preSum[]=new long[n+1];
    long suffSum[]=new long[n+1];
    long res=0,pow=1 ;
    for(int i=0 ; i<k ; i++)pow*=x ;
    preSum[0]=0 ;
    for(int i=0 ; i<n ; i++)preSum[i+1]=preSum[i] | arr[i];
    suffSum[n]=0 ;
    for(int i=n-1 ; i>=0 ; i--)suffSum[i]=suffSum[i+1] | arr[i];
    res=0 ;
    for(int i=0 ; i<n ; i++)res=Math.max(res,preSum[i] |(arr[i]*pow)| suffSum[i+1]);
    return res ;
  }
  public static void main(String args[]){
    long arr[]={
      1,2,4,8 };
      int n=4 ;
      int k=2,x=3 ;
      long ans=maxOR(arr,n,k,x);
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxOR( arr : Sequence(long), n : int, k : int, x : int) : long
  pre: true
  post: true
  activity: (     var preSum : Sequence(long) ; preSum := Integer.subrange(1,n + 1)->collect(0) ;
     var suffSum : Sequence(long) ; suffSum := Integer.subrange(1,n + 1)->collect(0) ;
    var res : long ; res := 0 ;
    var pow : long ; pow := 1 ;
        var i : int ; i := 0 ; while i < k do (     pow := pow*(x) ;  ;     i := i + 1 ) ; 
    preSum[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do (     preSum[i + 1+1] := preSum[i+1] or arr[i+1] ;  ;     i := i + 1 ) ; 
    suffSum[n+1] := 0 ; 
        var i : int ; i := n - 1 ; while i >= 0 do (     suffSum[i+1] := suffSum[i + 1+1] or arr[i+1] ;  ;     i := i - 1 ) ; 
    res := 0 ; 
        var i : int ; i := 0 ; while i < n do (     res := Set{res, preSum[i+1] or (arr[i+1] * pow) or suffSum[i + 1+1]}->max() ;  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(long) ; arr := Sequence{1,2,4,8} ;
     var n : int ; n := 4 ;
    var k : int ; k := 2 ;
    var x : int ; x := 3 ;
    var ans : long ; ans := maxOR(arr, n, k, x) ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextLine()){
      int n=Integer.parseInt(sc.nextLine());
      int count=0 ;
      for(int i=0 ; i<10 ; i++){
        for(int u=0 ; u<10 ; u++){
          for(int y=0 ; y<10 ; y++){
            for(int t=0 ; t<10 ; t++){
              if(i+u+y+t==n){
                count++;
              }
            }
          }
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextLine()) do (     var n : int ; n := (sc.nextLine())->toInteger() ;
     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < 10 do ( (         var u : int ; u := 0 ; while u < 10 do ( (         var y : int ; y := 0 ; while y < 10 do ( (         var t : int ; t := 0 ; while t < 10 do ( (     if (i + u + y + t = n) then (     count := count + 1 ) else skip )  ;     t := t + 1 ) )  ;     y := y + 1 ) )  ;     u := u + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.FileOutputStream ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
import java.util.*;
import java.lang.Math ;
import java.awt.Point ;
import java.awt.geom.*;
public class Main {
  public static void main(String args[]){
    try {
      FastReader s=new FastReader();
      BufferedWriter w=new BufferedWriter(new OutputStreamWriter(System.out));
      int m,n,t,i,j,max,x,y,min,ans ;
      long a,b ;
      String str=s.next();
      char c=str.charAt(0);
      c++;
      w.write(c+"\n");
      w.close();
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    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 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var s : FastReader ; s := FastReader.newFastReader() ;
     var w : OclFile ; w := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var m : int ;
    var n : int ;
    var t : int ;
    var i : int ;
    var j : int ;
    var max : int ;
    var x : int ;
    var y : int ;
    var min : int ;
    var ans : int ;
    var a : long ;
    var b : long ;
    var str : String ; str := s.next() ;
    var c : String ; c := str->at(0+1) ;
    c := c + 1 ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  int[] nums1 ;
  int[] nums2 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; sc.hasNext(); ){
      nums1=new int[51];
      nums2=new int[51];
      int n=sc.nextInt();
      for(int i=0 ; i<10 ; i++){
        for(int j=0 ; j<10 ; j++){
          nums1[i+j]++;
          if(n-i-j>=0)nums2[n-i-j]++;
        }
      }
      int cnt=0 ;
      for(int i=0 ; i<51 ; i++){
        cnt+=nums1[i]*nums2[i];
      }
      System.out.println(cnt);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute nums1 : Sequence(int);
   attribute nums2 : Sequence(int);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while sc.hasNext() do ( (     nums1 := Integer.subrange(1,51)->collect(0) ; 
     nums2 := Integer.subrange(1,51)->collect(0) ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < 10 do ( (     nums1[i + j+1] := nums1[i + j+1] + 1 ; 
     if (n - i - j >= 0) then     nums2[n - i - j+1] := nums2[n - i - j+1] + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < 51 do ( (     cnt := cnt+(nums1[i+1] * nums2[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s="" ;
    ArrayList<Integer>lines=new ArrayList<Integer>();
    try {
      while(null!=(s=br.readLine())){
        lines.add(Integer.valueOf(s));
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
    finally {
      try {
        br.close();
      }
      catch(IOException e){
        e.printStackTrace();
      }
    }
    for(Integer n : lines){
      if(n<0){
        continue ;
      }
      else if(n>36){
        System.out.println(0);
      }
      else {
        try {
          int count=0 ;
          for(int a=0 ; a<=9 ; a++){
            if(n-a>9*3)continue ;
            for(int b=0 ; b<=(n-a)&& b<=9 ; b++){
              if(n-a-b>9*2)continue ;
              for(int c=0 ; c<=(n-a-b)&& c<=9 ; c++){
                if(n-a-b-c>9)continue ;
                count++;
              }
            }
          }
          System.out.println(count);
        }
        catch(NumberFormatException e){
          e.printStackTrace();
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := "" ;
    var lines : Sequence(int) ; lines := Sequence{} ;
    try (         s := br.readLine() ;
    while (null /= (s)) do (    skip ; (     lines := lines->including((s)->toInteger()) ) ;     s := br.readLine() ;
 ) )   catch (e : IOException) do (     e.printStackTrace() )
   finally (     try (     skip )   catch (e : IOException) do (     e.printStackTrace() )
 )
    for (n : lines) do ( (     if (n < 0) then (     continue ) else     if (n > 36) then (     OclFile["System.out"].println(0) ) else (     try (     var count : int ; count := 0 ;
         var a : int ; a := 0 ; while a <= 9 do ( (     if (n - a > 9 * 3) then     continue else skip ; 
         var b : int ; b := 0 ; while b <= (n - a) & b <= 9 do ( (     if (n - a - b > 9 * 2) then     continue else skip ; 
         var c : int ; c := 0 ; while c <= (n - a - b) & c <= 9 do ( (     if (n - a - b - c > 9) then     continue else skip ; 
     count := count + 1 )  ;     c := c + 1 ) )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
     OclFile["System.out"].println(count) )   catch (e : IncorrectElementException) do (     e.printStackTrace() )
 ) ;  )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static void main(String[] args){
    HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();
    for(int i=0 ; i<10 ; ++i){
      for(int j=0 ; j<10 ; ++j){
        if(! map.containsKey(i+j))map.put(i+j,1);
        else map.put(i+j,map.get(i+j)+1);
      }
    }
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    String str ;
    try {
      while((str=bf.readLine())!=null){
        int ans=0 ;
        int n=Integer.parseInt(str);
        for(Map.Entry<Integer,Integer>e : map.entrySet()){
          Integer v=map.get(n-e.getKey());
          ans+=(v==null ? 0 : v)*e.getValue();
        }
        System.out.println(ans);
      }
    }
    catch(IOException ex){
      System.out.println(ex);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var map : Map(int,int) ; map := Map{} ;
         var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < 10 do ( (     if (not(map->keys()->includes(i + j))) then     map := map->union(Map{i + j |-> 1}) ; else     map := map->union(Map{i + j |-> map->at(i + j) + 1}) ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var str : String ;
    try (         str := bf.readLine() ;
    while ((str) /= null) do (    skip ; (     var ans : int ; ans := 0 ;
     var n : int ; n := (str)->toInteger() ;
     for (e : map->asSet()) do ( (     var v : int ; v := map->at(n - e.getKey()) ;
     ans := ans+((if v = null then 0 else v endif) * e.getValue()) )  ) ; 
     OclFile["System.out"].println(ans) ) ;     str := bf.readLine() ;
 ) )   catch (ex : IOException) do (     OclFile["System.out"].println(ex) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    String line=null ;
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    while((line=reader.readLine())!=null){
      int input=Integer.parseInt(line);
      System.out.println(calculateNumberOfCombination(input));
    }
    if(reader!=null){
      reader.close();
    }
  }
  protected static int calculateNumberOfCombination(int input){
    int count=0 ;
    for(int i=0 ; i<10 ; i++){
      for(int j=0 ; j<10 ; j++){
        for(int k=0 ; k<10 ; k++){
          for(int l=0 ; l<10 ; l++){
            if(i+j+k+l==input){
              count++;
            }
          }
        }
      }
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var line : String ; line := null ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     var input : int ; input := (line)->toInteger() ;
     OclFile["System.out"].println(calculateNumberOfCombination(input)) ) ;     line := reader.readLine() ;
 ) ;  
     if (reader /= null) then (     skip ) else skip );
   static   operation calculateNumberOfCombination( input : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < 10 do ( (         var k : int ; k := 0 ; while k < 10 do ( (         var l : int ; l := 0 ; while l < 10 do ( (     if (i + j + k + l = input) then (     count := count + 1 ) else skip )  ;     l := l + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int arr[][]=new int[3][3];
    int sum=0 ;
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<3 ; j++){
        int k=scn.nextInt();
        arr[i][j]=k ;
        sum=sum+k ;
      }
    }
    int val=sum/2 ;
    for(int i=0 ; i<3 ; i++){
      int row=0 ;
      for(int j=0 ; j<3 ; j++){
        row=row+arr[i][j];
      }
      arr[i][i]=val-row ;
    }
    for(int i=0 ; i<3 ; i++){
      int row=0 ;
      for(int j=0 ; j<3 ; j++){
        System.out.print(arr[i][j]+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     var k : int ; k := scn.getCurrent()->toInteger() ;
     arr[i+1][j+1] := k ; 
     sum := sum + k )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var val : int ; val := sum / 2 ;
        var i : int ; i := 0 ; while i < 3 do ( (     var row : int ; row := 0 ;
         var j : int ; j := 0 ; while j < 3 do ( (     row := row + arr[i+1][j+1] )  ;     j := j + 1 ) ; 
     arr[i+1][i+1] := val - row )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do ( (     var row : int ; row := 0 ;
         var j : int ; j := 0 ; while j < 3 do ( (     OclFile["System.out"].print(arr[i+1][j+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float heightCalculate(int H,int n,int m){
    float N=(float)(n*1.0);
    float M=(float)(m*1.0);
    float h=H*(float)Math.sqrt(N/(N+M));
    return h ;
  }
  public static void main(String[] args){
    int H=10,n=3,m=4 ;
    System.out.print(heightCalculate(H,n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation heightCalculate( H : int, n : int, m : int) : double
  pre: true
  post: true
  activity: (     var N : double ; N := (n * 1.0)->oclAsType(double) ;
     var M : double ; M := (m * 1.0)->oclAsType(double) ;
     var h : double ; h := H * (N / (N + M))->sqrt()->oclAsType(double) ;
     return h );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var H : int ; H := 10 ;
    var n : int ; n := 3 ;
    var m : int ; m := 4 ;
     OclFile["System.out"].print(heightCalculate(H, n, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class B {
  private static int parse(String s){
    BigInteger integer=new BigInteger(s);
    integer=integer.mod(BigInteger.valueOf(210));
    return integer.intValue();
  }
  public static void main(String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int N=scanner.nextInt();
    for(int testCase=1 ; testCase<=N ; ++testCase){
      final String line=scanner.next();
      final int n=line.length();
      final int[][] partsTable=new int[n][n+1];
      for(int begin=0 ; begin<n ; ++begin){
        for(int end=begin+1 ; end<=n ; ++end){
          partsTable[begin][end]=parse(line.substring(begin,end));
        }
      }
      final long[][] memo=new long[n+1][210];
++memo[0][0];
      for(int endIndex=1 ; endIndex<=n ; ++endIndex){
        for(int beginIndex=0 ; beginIndex<endIndex ; ++beginIndex){
          {
            for(int prevMod=0 ; prevMod<210 ; ++prevMod){
              final int nextMod=(prevMod+partsTable[beginIndex][endIndex])% 210 ;
              memo[endIndex][nextMod]+=memo[beginIndex][prevMod];
            }
          }
          if(beginIndex!=0){
            for(int prevMod=0 ; prevMod<210 ; ++prevMod){
              final int nextMod=(prevMod-partsTable[beginIndex][endIndex]+210)% 210 ;
              memo[endIndex][nextMod]+=memo[beginIndex][prevMod];
            }
          }
        }
      }
      long answer=0 ;
      for(int mod=0 ; mod<210 ; ++mod){
        if(mod % 2==0 || mod % 3==0 || mod % 5==0 || mod % 7==0){
          answer+=memo[n][mod];
        }
      }
      System.out.printf("Case #%d: %d\n",testCase,answer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation parse( s : String) : int
  pre: true
  post: true
  activity: (     var integer : long ; integer := long(s) ;
     integer := integer.mod((210 + "")->toLong()) ; 
     return integer->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
         var testCase : int ; testCase := 1 ; while testCase <= N do ( (     var line : String ; line := scanner.getCurrent() ;
     var n : int ; n := line->size() ;
    var partsTable : Sequence(Sequence(int)) ; partsTable := Integer.subrange(1,n)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var begin : int ; begin := 0 ; while begin < n do ( (         var end : int ; end := begin + 1 ; while end <= n do ( (     partsTable[begin+1][end+1] := parse(line.subrange(begin+1,end)) )  ;     end := end + 1 ) )  ;     begin := begin + 1 ) ; 
    var memo : Sequence(Sequence(long)) ; memo := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,210)->collect(0)) ;
    memo[0+1][0+1] := memo[0+1][0+1] + 1 ; 
        var endIndex : int ; endIndex := 1 ; while endIndex <= n do ( (         var beginIndex : int ; beginIndex := 0 ; while beginIndex < endIndex do ( ( (         var prevMod : int ; prevMod := 0 ; while prevMod < 210 do ( (     var nextMod : int ; nextMod := (prevMod + partsTable[beginIndex+1][endIndex+1]) mod 210 ;
     memo[endIndex+1][nextMod+1] := memo[endIndex+1][nextMod+1]+(memo[beginIndex+1][prevMod+1]) )  ;     prevMod := prevMod + 1 ) ) 
     if (beginIndex /= 0) then (         var prevMod : int ; prevMod := 0 ; while prevMod < 210 do ( (     var nextMod : int ; nextMod := (prevMod - partsTable[beginIndex+1][endIndex+1] + 210) mod 210 ;
     memo[endIndex+1][nextMod+1] := memo[endIndex+1][nextMod+1]+(memo[beginIndex+1][prevMod+1]) )  ;     prevMod := prevMod + 1 ) ) else skip )  ;     beginIndex := beginIndex + 1 ) )  ;     endIndex := endIndex + 1 ) ; 
    var answer : long ; answer := 0 ;
        var mod : int ; mod := 0 ; while mod < 210 do ( (     if (mod mod 2 = 0 or mod mod 3 = 0 or mod mod 5 = 0 or mod mod 7 = 0) then (     answer := answer+(memo[n+1][mod+1]) ) else skip )  ;     mod := mod + 1 ) ; 
    OclFile["System.out"].printf("Case #%d: %d\n", testCase, answer) ; 
 )  ;     testCase := testCase + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class b {
  long sol=0 ;
  String s ;
  long nrt ;
  long calc(int lop,long bef,long now){
    switch(lop){
      case 0 : return now ;
      case 1 : return bef+now ;
      case 2 : return bef-now ;
    }
    return 0 ;
  }
  boolean ugly(long x){
    if(x<0)x=-x ;
    if(x % 2==0)return true ;
    if(x % 3==0)return true ;
    if(x % 5==0)return true ;
    if(x % 7==0)return true ;
    return false ;
  }
  void count(int poz,int lop,long bef,long now){
    if(poz==s.length()-1){
      if(ugly(calc(lop,bef,now)))sol++;
      else {
      }
    }
    else {
      long c=(long)(s.charAt(poz+1)-'0');
      count(poz+1,lop,bef,10*now+c);
      if(poz!=s.length()-1){
        count(poz+1,1,calc(lop,bef,now),c);
        count(poz+1,2,calc(lop,bef,now),c);
      }
    }
  }
  b(){
    try {
      File f=new File("B-small-attempt1.in");
      BufferedReader input=new BufferedReader(new FileReader(f));
      BufferedWriter out=new BufferedWriter(new FileWriter("small.out"));
      long nrtests=Integer.parseInt(input.readLine());
      for(nrt=0 ; nrt<nrtests ; nrt++){
        s=input.readLine();
        sol=0 ;
        count(0,0,0,(long)(s.charAt(0)-'0'));
        out.write("Case #"+(nrt+1)+": "+sol+"\n");
      }
      out.close();
    }
    catch(IOException e){
    }
  }
  public static void main(String[] args){
    new b();
  }
}
------------------------------------------------------------
OCL File:
---------
 class b {
   attribute sol : long := 0;
   attribute s : String;
   attribute nrt : long;
   operation calc( lop : int, bef : long, now : long) : long
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (lop) ; 
       if _switchval = 0 then
     return now 
   else skip ;
       if _switchval = 1 then
     return bef + now 
   else skip ;
       if _switchval = 2 then
     return bef - now 
   else skip ;
 )
     return 0 );
   operation ugly( x : long) : boolean
  pre: true
  post: true
  activity: (     if (x < 0) then     x := -x ; else skip ; 
     if (x mod 2 = 0) then     return true else skip ; 
    if (x mod 3 = 0) then     return true else skip ; 
    if (x mod 5 = 0) then     return true else skip ; 
    if (x mod 7 = 0) then     return true else skip ; 
    return false 
 );
   operation count( poz : int, lop : int, bef : long, now : long) : void
  pre: true
  post: true
  activity: (     if (poz = s->size() - 1) then (     if (ugly(calc(lop, bef, now))) then     sol := sol + 1 ; else skip ) else (     var c : long ; c := (s->at(poz + 1+1) - ('0')->char2byte())->oclAsType(long) ;
     execute count(poz + 1, lop, bef, 10 * now + c) ; 
     if (poz /= s->size() - 1) then (     execute count(poz + 1, 1, calc(lop, bef, now), c) ; 
     execute count(poz + 1, 2, calc(lop, bef, now), c) ) else skip ) );
   static operation newb() : b
  pre: true
  post: true
  activity:
  ( var self : b ;
    self := createb();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     var f : OclFile ; f := OclFile("B-small-attempt1.in") ;
     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(f)) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("small.out"))) ;
    var nrtests : long ; nrtests := (input.readLine())->toInteger() ;
        nrt := 0 ; while nrt < nrtests do ( (     s := input.readLine() ; 
     sol := 0 ; 
     execute count(0, 0, 0, (s->at(0+1) - ('0')->char2byte())->oclAsType(long)) ; 
     skip )  ;     nrt := nrt + 1 ) ; 
    skip ; 
 )   catch (e : IOException) do skip
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( b.newb() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Parade733B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int left[]=new int[n];
    int right[]=new int[n];
    int l_max=0 ;
    int r_max=0 ;
    for(int i=0 ; i<n ; i++){
      left[i]=in.nextInt();
      right[i]=in.nextInt();
      l_max+=left[i];
      r_max+=right[i];
    }
    int b=Math.abs(l_max-r_max);
    int index=0 ;
    for(int i=0 ; i<n ; i++){
      if(Math.abs((l_max-left[i]+right[i])-(r_max-right[i]+left[i]))>b){
        b=Math.abs((l_max-left[i]+right[i])-(r_max-right[i]+left[i]));
        index=i+1 ;
      }
    }
    System.out.println(index);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Parade733B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var left : Sequence(int) ; left := Integer.subrange(1,n)->collect(0) ;
    var right : Sequence(int) ; right := Integer.subrange(1,n)->collect(0) ;
    var l_max : int ; l_max := 0 ;
    var r_max : int ; r_max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     left[i+1] := in.getCurrent()->toInteger() ; 
     right[i+1] := in.getCurrent()->toInteger() ; 
     l_max := l_max+(left[i+1]) ; 
     r_max := r_max+(right[i+1]) )  ;     i := i + 1 ) ; 
    var b : int ; b := if l_max - r_max < 0 then -(l_max - r_max) else l_max - r_max endif ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (if (l_max - left[i+1] + right[i+1]) - (r_max - right[i+1] + left[i+1]) < 0 then -((l_max - left[i+1] + right[i+1]) - (r_max - right[i+1] + left[i+1])) else (l_max - left[i+1] + right[i+1]) - (r_max - right[i+1] + left[i+1]) endif > b) then (     b := if (l_max - left[i+1] + right[i+1]) - (r_max - right[i+1] + left[i+1]) < 0 then -((l_max - left[i+1] + right[i+1]) - (r_max - right[i+1] + left[i+1])) else (l_max - left[i+1] + right[i+1]) - (r_max - right[i+1] + left[i+1]) endif ; 
     index := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(index) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.max ;
import static java.lang.Math.min ;
import static java.lang.Math.abs ;
import java.util.*;
import java.io.*;
import java.math.*;
public class B {
  public static void main(String hi[])throws Exception {
    BufferedReader infile=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(infile.readLine());
    int N=Integer.parseInt(st.nextToken());
    int[] left=new int[N];
    int[] right=new int[N];
    for(int i=0 ; i<N ; i++){
      st=new StringTokenizer(infile.readLine());
      left[i]=Integer.parseInt(st.nextToken());
      right[i]=Integer.parseInt(st.nextToken());
    }
    int x=0 ;
    int y=0 ;
    for(int a : left)x+=a ;
    for(int a : right)y+=a ;
    int res=abs(x-y);
    int dex=0 ;
    for(int i=0 ; i<N ; i++){
      x+=right[i]-left[i];
      y+=left[i]-right[i];
      if(res<abs(x-y)){
        res=abs(x-y);
        dex=i+1 ;
      }
      x-=right[i]-left[i];
      y-=left[i]-right[i];
    }
    System.out.println(dex);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( hi : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var infile : OclFile ; infile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(infile.readLine()) ;
    var N : int ; N := (st.next())->toInteger() ;
    var left : Sequence(int) ; left := Integer.subrange(1,N)->collect(0) ;
    var right : Sequence(int) ; right := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     st := OclIterator.newOclIterator_String(infile.readLine()) ; 
     left[i+1] := (st.next())->toInteger() ; 
     right[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    for (a : left) do (     x := x+(a) ;  ) ; 
    for (a : right) do (     y := y+(a) ;  ) ; 
    var res : int ; res := abs(x - y) ;
    var dex : int ; dex := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     x := x+(right[i+1] - left[i+1]) ; 
     y := y+(left[i+1] - right[i+1]) ; 
    if (res < abs(x - y)) then (     res := abs(x - y) ; 
     dex := i + 1 ) else skip ; 
    x := x-(right[i+1] - left[i+1]) ; 
    y := y-(left[i+1] - right[i+1]) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dex) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.List ;
import java.util.ArrayList ;
import java.util.Comparator ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String C=scan.next();
    String alphabet[]={
      "a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z" };
      for(int i=0 ; i<25 ; i++){
        if(C.equals(alphabet[i])){
          System.out.println(alphabet[i+1]);
          return ;
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var C : String ; C := scan.getCurrent() ;
     var alphabet : Sequence(String) ; alphabet := Sequence{"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"} ;
         var i : int ; i := 0 ; while i < 25 do ( (     if (C = alphabet[i+1]) then (     OclFile["System.out"].println(alphabet[i + 1+1]) ; 
     return ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;
public class cc2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int l[]=new int[t];
    int r[]=new int[t];
    int left=0,right=0 ;
    for(int i=0 ; i<t ; i++){
      l[i]=sc.nextInt();
      r[i]=sc.nextInt();
      left+=l[i];
      right+=r[i];
    }
    int max=(int)Math.abs(left-right);
    int idx=0 ;
    for(int i=0 ; i<t ; i++){
      int c=left-l[i]+r[i];
      int d=right-r[i]+l[i];
      int abs1=(int)Math.abs(c-d);
      if(abs1>max){
        max=abs1 ;
        idx=i+1 ;
      }
    }
    System.out.println(idx);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cc2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Integer.subrange(1,t)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,t)->collect(0) ;
    var left : int ; left := 0 ;
    var right : int ; right := 0 ;
        var i : int ; i := 0 ; while i < t do ( (     l[i+1] := sc.getCurrent()->toInteger() ; 
     r[i+1] := sc.getCurrent()->toInteger() ; 
     left := left+(l[i+1]) ; 
     right := right+(r[i+1]) )  ;     i := i + 1 ) ; 
    var max : int ; max := if left - right < 0 then -(left - right) else left - right endif->oclAsType(int) ;
    var idx : int ; idx := 0 ;
        var i : int ; i := 0 ; while i < t do ( (     var c : int ; c := left - l[i+1] + r[i+1] ;
     var d : int ; d := right - r[i+1] + l[i+1] ;
     var abs1 : int ; abs1 := if c - d < 0 then -(c - d) else c - d endif->oclAsType(int) ;
     if (abs1 > max) then (     max := abs1 ; 
     idx := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(idx) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int sum1=0 ;
    int sum2=0 ;
    int L[]=new int[n];
    int R[]=new int[n];
    for(int i=0 ; i<n ; i++){
      int l=sc.nextInt();
      L[i]=l ;
      int r=sc.nextInt();
      R[i]=r ;
      sum1+=l ;
      sum2+=r ;
    }
    int beauty=0 ;
    int beauty1=0 ;
    int ans=0 ;
    beauty=Math.abs(sum1-sum2);
    int temp1=sum1 ;
    int temp2=sum2 ;
    for(int i=0 ; i<n ; i++){
      sum1=temp1+R[i]-L[i];
      sum2=temp2+L[i]-R[i];
      beauty1=Math.abs(sum1-sum2);
      if(beauty1>beauty){
        beauty=beauty1 ;
        ans=i+1 ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var sum1 : int ; sum1 := 0 ;
    var sum2 : int ; sum2 := 0 ;
    var L : Sequence(int) ; L := Integer.subrange(1,n)->collect(0) ;
    var R : Sequence(int) ; R := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var l : int ; l := sc.getCurrent()->toInteger() ;
     L[i+1] := l ; 
    var r : int ; r := sc.getCurrent()->toInteger() ;
    R[i+1] := r ; 
    sum1 := sum1+(l) ; 
    sum2 := sum2+(r) ; 
 )  ;     i := i + 1 ) ; 
    var beauty : int ; beauty := 0 ;
    var beauty1 : int ; beauty1 := 0 ;
    var ans : int ; ans := 0 ;
    beauty := if sum1 - sum2 < 0 then -(sum1 - sum2) else sum1 - sum2 endif ; 
    var temp1 : int ; temp1 := sum1 ;
    var temp2 : int ; temp2 := sum2 ;
        var i : int ; i := 0 ; while i < n do ( (     sum1 := temp1 + R[i+1] - L[i+1] ; 
     sum2 := temp2 + L[i+1] - R[i+1] ; 
     beauty1 := if sum1 - sum2 < 0 then -(sum1 - sum2) else sum1 - sum2 endif ; 
     if (beauty1 > beauty) then (     beauty := beauty1 ; 
     ans := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    long a[]=new long[n+1],b[]=new long[n+1];
    long sumA=0,sumB=0 ;
    for(int i=1 ; i<=n ; i++){
      a[i]=in.nextLong();
      sumA+=a[i];
      b[i]=in.nextLong();
      sumB+=b[i];
    }
    long sub=Math.abs(sumA-sumB);
    long ans=0 ;
    for(int i=1 ; i<=n ; i++){
      long ta=sumA+b[i]-a[i];
      long tb=sumB+a[i]-b[i];
      long temp=Math.abs(ta-tb);
      if(temp>sub){
        ans=i ;
        sub=temp ;
      }
    }
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var b : Sequence(void) ; b := Integer.subrange(1,n + 1)->collect(0) ;
    var sumA : long ; sumA := 0 ;
    var sumB : long ; sumB := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := in.getCurrent()->toLong() ; 
     sumA := sumA+(a[i+1]) ; 
     b[i+1] := in.getCurrent()->toLong() ; 
     sumB := sumB+(b[i+1]) )  ;     i := i + 1 ) ; 
    var sub : long ; sub := if sumA - sumB < 0 then -(sumA - sumB) else sumA - sumB endif ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var ta : long ; ta := sumA + b[i+1] - a[i+1] ;
     var tb : long ; tb := sumB + a[i+1] - b[i+1] ;
     var temp : long ; temp := if ta - tb < 0 then -(ta - tb) else ta - tb endif ;
     if (temp > sub) then (     ans := i ; 
     sub := temp ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    int n=sc.nextInt();
    int saisyo=0 ;
    int hozon=0 ;
    int saidai=0 ;
    int saigo=0 ;
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      if(saidai<a-hozon){
        saidai=a-hozon ;
      }
      if(i==0){
        saisyo=a ;
      }
      if(i==n-1){
        saigo=a ;
      }
      hozon=a ;
    }
    int kotae2=k-saidai ;
    int kotae3=saigo-saisyo ;
    if(kotae2<kotae3){
      System.out.println(kotae2);
    }
    else {
      System.out.println(kotae3);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var saisyo : int ; saisyo := 0 ;
    var hozon : int ; hozon := 0 ;
    var saidai : int ; saidai := 0 ;
    var saigo : int ; saigo := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (saidai < a - hozon) then (     saidai := a - hozon ) else skip ; 
    if (i = 0) then (     saisyo := a ) else skip ; 
    if (i = n - 1) then (     saigo := a ) else skip ; 
    hozon := a ; 
 )  ;     i := i + 1 ) ; 
    var kotae2 : int ; kotae2 := k - saidai ;
    var kotae3 : int ; kotae3 := saigo - saisyo ;
    if (kotae2 < kotae3) then (     OclFile["System.out"].println(kotae2) ) else (     OclFile["System.out"].println(kotae3) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException,InterruptedException {
    Scanner sc=new Scanner();
    PrintWriter out=new PrintWriter(System.out);
    int k=sc.nextInt(),n=sc.nextInt(),a[]=sc.nextIntArray(n);
    int ans=a[n-1]-a[0];
    for(int i=1 ; i<n ; i++)ans=Math.min(ans,k-a[i]+a[i-1]);
    out.println(ans);
    out.flush();
    out.close();
  }
  static class Scanner {
    BufferedReader br ;
    StringTokenizer st ;
    boolean ready()throws IOException {
      return br.ready();
    }
    double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    Scanner(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    int nextChar()throws IOException {
      return next().charAt(0);
    }
    int[] nextIntArray(int n)throws IOException {
      int[] ans=new int[n];
      for(int i=0 ; i<n ; i++)ans[i]=nextInt();
      return ans ;
    }
    long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := (arguments ( )) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(void) ; a := sc.nextIntArray(n) ;
    var ans : int ; ans := a[n - 1+1] - a[0+1] ;
        var i : int ; i := 1 ; while i < n do (     ans := Set{ans, k - a[i+1] + a[i - 1+1]}->min() ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   static operation newScanner() : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextChar() : int
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     ans[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return ans );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MagicSquare259B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int arr[][]=new int[3][3];
    int sum=0 ;
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<3 ; j++){
        arr[i][j]=in.nextInt();
        sum+=arr[i][j];
      }
    }
    if(sum % 2==0)sum=sum/2 ;
    arr[0][0]=sum-arr[1][0]-arr[2][0];
    arr[1][1]=sum-arr[0][1]-arr[2][1];
    arr[2][2]=sum-arr[0][2]-arr[1][2];
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<3 ; j++){
        System.out.print(arr[i][j]+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MagicSquare259B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     arr[i+1][j+1] := in.getCurrent()->toInteger() ; 
     sum := sum+(arr[i+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (sum mod 2 = 0) then     sum := sum / 2 ; else skip ; 
    arr[0+1][0+1] := sum - arr[1+1][0+1] - arr[2+1][0+1] ; 
    arr[1+1][1+1] := sum - arr[0+1][1+1] - arr[2+1][1+1] ; 
    arr[2+1][2+1] := sum - arr[0+1][2+1] - arr[1+1][2+1] ; 
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     OclFile["System.out"].print(arr[i+1][j+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int K=scanner.nextInt();
    int N=scanner.nextInt();
    int locations[]=new int[N];
    for(int i=0 ; i<locations.length ; i++){
      locations[i]=scanner.nextInt();
    }
    int sumDistance=0 ;
    int maxDistance=locations[1]-locations[0];
    sumDistance+=maxDistance ;
    for(int i=2 ; i<=locations.length ; i++){
      int distance ;
      if(i==locations.length){
        distance=Math.abs(K-locations[i-1])+locations[0];
      }
      else {
        distance=Math.abs(locations[i-1]-locations[i]);
      }
      sumDistance+=distance ;
      if(distance>maxDistance){
        maxDistance=distance ;
      }
    }
    sumDistance-=maxDistance ;
    System.out.println(sumDistance);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var K : int ; K := scanner.getCurrent()->toInteger() ;
    var N : int ; N := scanner.getCurrent()->toInteger() ;
    var locations : Sequence(int) ; locations := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < locations->size() do ( (     locations[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sumDistance : int ; sumDistance := 0 ;
    var maxDistance : int ; maxDistance := locations[1+1] - locations[0+1] ;
    sumDistance := sumDistance+(maxDistance) ; 
        var i : int ; i := 2 ; while i <= locations->size() do ( (     var distance : int ;
     if (i = locations->size()) then (     distance := if K - locations[i - 1+1] < 0 then -(K - locations[i - 1+1]) else K - locations[i - 1+1] endif + locations[0+1] ) else (     distance := if locations[i - 1+1] - locations[i+1] < 0 then -(locations[i - 1+1] - locations[i+1]) else locations[i - 1+1] - locations[i+1] endif ) ;  
     sumDistance := sumDistance+(distance) ; 
     if (distance > maxDistance) then (     maxDistance := distance ) else skip )  ;     i := i + 1 ) ; 
    sumDistance := sumDistance-(maxDistance) ; 
    OclFile["System.out"].println(sumDistance) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int k=Integer.parseInt(sc.next());
    int n=Integer.parseInt(sc.next());
    int[] a=new int[n];
    int[] b=new int[n];
    int result=0 ;
    for(int i=0 ; i<n ; i++)a[i]=Integer.parseInt(sc.next());
    for(int i=n-1 ; i>0 ; i--)b[i]=a[i]-a[i-1];
    b[0]=k-a[n-1]+a[0];
    Arrays.sort(b);
    for(int i=0 ; i<n-1 ; i++)result+=b[i];
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := (sc.getCurrent())->toInteger() ;
    var n : int ; n := (sc.getCurrent())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (sc.getCurrent())->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i > 0 do (     b[i+1] := a[i+1] - a[i - 1+1] ;  ;     i := i - 1 ) ; 
    b[0+1] := k - a[n - 1+1] + a[0+1] ; 
    b := b->sort() ; 
        var i : int ; i := 0 ; while i < n - 1 do (     result := result+(b[i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner kb=new Scanner(System.in);
    int length=kb.nextInt(),numhouses=kb.nextInt();
    int[] houses=new int[numhouses];
    for(int i=0 ; i<numhouses ; i++){
      houses[i]=kb.nextInt();
    }
    int max=houses[0]+(length-houses[numhouses-1]);
    for(int i=1 ; i<numhouses ; i++){
      if(max<houses[i]-houses[i-1]){
        max=houses[i]-houses[i-1];
      }
    }
    System.out.println(length-max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var kb : OclFile ; kb := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var length : int ; length := kb.getCurrent()->toInteger() ;
    var numhouses : int ; numhouses := kb.getCurrent()->toInteger() ;
    var houses : Sequence(int) ; houses := Integer.subrange(1,numhouses)->collect(0) ;
        var i : int ; i := 0 ; while i < numhouses do ( (     houses[i+1] := kb.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var max : int ; max := houses[0+1] + (length - houses[numhouses - 1+1]) ;
        var i : int ; i := 1 ; while i < numhouses do ( (     if (max < houses[i+1] - houses[i - 1+1]) then (     max := houses[i+1] - houses[i - 1+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(length - max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void subsetBitwiseORk(int arr[],int n,int k){
    ArrayList<Integer>v=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      if((arr[i] | k)==k){
        v.add(arr[i]);
      }
    }
    int ans=0 ;
    for(int i=0 ; i<v.size(); i++)ans=ans | v.get(i);
    if(ans!=k){
      System.out.println("Subset does"+" not exist");
      return ;
    }
    for(int i=0 ; i<v.size(); i++)System.out.print(v.get(i)+" ");
  }
  public static void main(String[] args){
    int k=3 ;
    int arr[]={
      1,4,2 };
      int n=arr.length ;
      subsetBitwiseORk(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation subsetBitwiseORk( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     if ((arr[i+1] or k) = k) then (     v := v->including(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < v->size() do (     ans := MathLib.bitwiseOr(ans,v->at(i+1)) ;  ;     i := i + 1 ) ; 
    if (ans /= k) then (     OclFile["System.out"].println("Subset does" + " not exist") ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < v->size() do (     OclFile["System.out"].print(v->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 3 ;
     var arr : Sequence(int) ; arr := Sequence{1,4,2} ;
     var n : int ; n := arr->size() ;
     execute subsetBitwiseORk(arr, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.PrintWriter ;
import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.Math.*;
import static java.lang.System.*;
public class Main {
  public static final int MOD=1000000007 ;
  public static void main(String[] args){
    int i,j ;
    Scanner sc=new Scanner(in);
    char[] s=sc.next().toCharArray();
    sc.close();
    out.println((char)(s[0]+1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
    var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    skip ; 
    out.println((s[0+1] + 1)->oclAsType(String)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CodeForces992B {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int l=input.nextInt();
    int r=input.nextInt();
    int x=input.nextInt();
    int y=input.nextInt();
    if(y % x!=0){
      System.out.println(0);
    }
    else {
      int ans=0 ;
      int n=y/x ;
      for(int d=1 ; d*d<=n ; d++){
        if(n % d==0){
          int c=n/d ;
          if(l<=c*x && c*x<=r && l<=d*x && d*x<=r && gcd(c,d)==1){
            if(d*d==n){
              ans++;
            }
            else {
              ans+=2 ;
            }
          }
        }
      }
      System.out.println(ans);
    }
  }
  public static int gcd(int a,int b){
    while(b>0){
      int t=a % b ;
      a=b ;
      b=t ;
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces992B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := input.getCurrent()->toInteger() ;
    var r : int ; r := input.getCurrent()->toInteger() ;
    var x : int ; x := input.getCurrent()->toInteger() ;
    var y : int ; y := input.getCurrent()->toInteger() ;
    if (y mod x /= 0) then (     OclFile["System.out"].println(0) ) else (     var ans : int ; ans := 0 ;
     var n : int ; n := y / x ;
         var d : int ; d := 1 ; while d * d <= n do ( (     if (n mod d = 0) then (     var c : int ; c := n / d ;
     if (l <= c * x & c * x <= r & l <= d * x & d * x <= r & gcd(c, d) = 1) then (     if (d * d = n) then (     ans := ans + 1 ) else (     ans := ans+(2) ) ) else skip ) else skip )  ;     d := d + 1 ) ; 
     OclFile["System.out"].println(ans) ) ;  
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     while (b > 0) do (     var t : int ; t := a mod b ;
     a := b ; 
     b := t ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import com.sun.org.apache.bcel.internal.generic.BIPUSH ;
import com.sun.org.apache.xpath.internal.axes.SelfIteratorNoPredicate ;
import org.omg.PortableInterceptor.SYSTEM_EXCEPTION ;
import sun.awt.image.BufferedImageGraphicsConfig ;
import java.math.*;
import java.math.BigDecimal ;
import java.math.BigInteger ;
import java.util.Scanner ;
import java.math.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long l=sc.nextLong();
    long r=sc.nextLong();
    long x=sc.nextLong();
    long y=sc.nextLong();
    long num=y/x ;
    if(y % x!=0){
      System.out.println(0);
      return ;
    }
    long ans=0 ;
    for(long i=1 ; i*i<=num ; i++){
      long j=num/i ;
      if(num % i==0 && gd(i,j)==1 && l<=i*x && i*x<=r && l<=j*x && j*x<=r)ans+=i==j ? 1 : 2 ;
    }
    System.out.println(ans);
  }
  static long gd(long a,long b){
    if(b==0)return a ;
    return gd(b,a % b);
  }
  private static BigDecimal sqrt(BigDecimal x,int n){
    BigDecimal l=BigDecimal.ZERO,r=x,mid ;
    BigDecimal two=BigDecimal.valueOf(2);
    for(int i=0 ; i<=n ; i++){
      mid=l.add(r).divide(two);
      if(mid.pow(2).compareTo(x)<=0)l=mid ;
      else r=mid ;
    }
    return l ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : long ; l := sc.getCurrent()->toLong() ;
    var r : long ; r := sc.getCurrent()->toLong() ;
    var x : long ; x := sc.getCurrent()->toLong() ;
    var y : long ; y := sc.getCurrent()->toLong() ;
    var num : long ; num := y / x ;
    if (y mod x /= 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var ans : long ; ans := 0 ;
        var i : long ; i := 1 ; while i * i <= num do ( (     var j : long ; j := num / i ;
     if (num mod i = 0 & gd(i, j) = 1 & l <= i * x & i * x <= r & l <= j * x & j * x <= r) then     ans := ans+(if i = j then 1 else 2 endif) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation gd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gd(b, a mod b) );
  static   operation sqrt( x : double, n : int) : double
  pre: true
  post: true
  activity: (     var l : double ; l := 0.0 ;
    var r : double ; r := x ;
    var mid : double ;
     var two : double ; two := (2 + "")->toReal() ;
         var i : int ; i := 0 ; while i <= n do ( (     mid := l->excludes(r).divide(two) ; 
     if (mid.pow(2)->compareTo(x) <= 0) then     l := mid ; else     r := mid ; )  ;     i := i + 1 ) ; 
     return l );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    double l=s.nextInt();
    double r=s.nextInt();
    double x=s.nextInt();
    double y=s.nextInt();
    if(y % x!=0){
      System.out.println(0);
    }
    else {
      double val=y/x ;
      long count=0 ;
      for(long i=1 ; i<=Math.sqrt(val); i++){
        if(val % i==0){
          double c=i ;
          double d=val/i ;
          if(gcd(c,d)==1 && c>=l/x && d<=r/x){
            if(c==d)count++;
            else count=count+2 ;
          }
        }
      }
      System.out.println(count);
    }
  }
  public static double gcd(double a,double b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : double ; l := s.getCurrent()->toInteger() ;
    var r : double ; r := s.getCurrent()->toInteger() ;
    var x : double ; x := s.getCurrent()->toInteger() ;
    var y : double ; y := s.getCurrent()->toInteger() ;
    if (y mod x /= 0) then (     OclFile["System.out"].println(0) ) else (     var val : double ; val := y / x ;
     var count : long ; count := 0 ;
         var i : long ; i := 1 ; while i <= (val)->sqrt() do ( (     if (val mod i = 0) then (     var c : double ; c := i ;
     var d : double ; d := val / i ;
     if (gcd(c, d) = 1 & c >= l / x & d <= r / x) then (     if (c = d) then     count := count + 1 ; else     count := count + 2 ; ) else skip ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) ) ;  
 );
  static   operation gcd( a : double, b : double) : double
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxSum(int arr[],int n,int k){
    if(n<k){
      return-1 ;
    }
    int res=0 ;
    for(int i=0 ; i<k ; i++)res+=arr[i];
    int curr_sum=res ;
    for(int i=k ; i<n ; i++){
      curr_sum+=arr[i]-arr[i-k];
      res=Math.max(res,curr_sum);
    }
    return res ;
  }
  static int solve(int arr[],int n,int k){
    int max_len=0,l=0,r=n,m ;
    while(l<=r){
      m=(l+r)/2 ;
      if(maxSum(arr,n,m)>k)r=m-1 ;
      else {
        l=m+1 ;
        max_len=m ;
      }
    }
    return max_len ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5 };
      int n=arr.length ;
      int k=10 ;
      System.out.println(solve(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxSum( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     if (n < k) then (     return -1 ) else skip ; 
     var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < k do (     res := res+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    var curr_sum : int ; curr_sum := res ;
        var i : int ; i := k ; while i < n do ( (     curr_sum := curr_sum+(arr[i+1] - arr[i - k+1]) ; 
     res := Set{res, curr_sum}->max() )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation solve( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var max_len : int ; max_len := 0 ;
    var l : int ; l := 0 ;
    var r : int ; r := n ;
    var m : int ;
     while (l <= r) do (     m := (l + r) / 2 ; 
     if (maxSum(arr, n, m) > k) then     r := m - 1 ; else (     l := m + 1 ; 
     max_len := m ) ) ; 
     return max_len );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 10 ;
     OclFile["System.out"].println(solve(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int a=scan.nextInt();
    int b=scan.nextInt();
    int c=scan.nextInt();
    double d=Math.cos(Math.toRadians(c));
    double e=Math.sin(Math.toRadians(c));
    double S=0,L=0,h=0,t=0 ;
    t=Math.sqrt(Math.pow(a,2)+Math.pow(b,2)-(2*a*b*d));
    S=(a*b*e)/2 ;
    L=a+b+t ;
    h=b*e ;
    System.out.printf("%.11f\n",S);
    System.out.printf("%.11f\n",L);
    System.out.printf("%.11f\n",h);
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    var c : int ; c := scan.getCurrent()->toInteger() ;
    var d : double ; d := ((0.017453292519943295*(c)))->cos() ;
    var e : double ; e := ((0.017453292519943295*(c)))->sin() ;
    var S : double ; S := 0 ;
    var L : double ; L := 0 ;
    var h : double ; h := 0 ;
    var t : double ; t := 0 ;
    t := (a->pow(2) + b->pow(2) - (2 * a * b * d))->sqrt() ; 
    S := (a * b * e) / 2 ; 
    L := a + b + t ; 
    h := b * e ; 
    OclFile["System.out"].printf("%.11f\n", S) ; 
    OclFile["System.out"].printf("%.11f\n", L) ; 
    OclFile["System.out"].printf("%.11f\n", h) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    try {
      BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
      String[] line=input.readLine().split(" ");
      String lb=System.getProperty("line.separator");
      int a=Integer.parseInt(line[0]);
      int b=Integer.parseInt(line[1]);
      double c=toRadians(Integer.parseInt(line[2]));
      double area=(a*b*sin(c))/2 ;
      double perimeter=a+b+pow(a*a+b*b-2*a*b*cos(c),0.5);
      double height=b*sin(c);
      System.out.println(new StringBuilder().append(String.valueOf(area)).append(lb).append(String.valueOf(perimeter)).append(lb).append(String.valueOf(height)).toString());
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : Sequence(String) ; line := input.readLine()->split(" ") ;
    var lb : String ; lb := OclProcess.getEnvironmentProperty("line.separator") ;
    var a : int ; a := (line[0+1])->toInteger() ;
    var b : int ; b := (line[1+1])->toInteger() ;
    var c : double ; c := toRadians((line[2+1])->toInteger()) ;
    var area : double ; area := (a * b * sin(c)) / 2 ;
    var perimeter : double ; perimeter := a + b + pow(a * a + b * b - 2 * a * b * cos(c), 0.5) ;
    var height : double ; height := b * sin(c) ;
    OclFile["System.out"].println(StringLib.newString() + StringLib.newString(((area) + "")) + StringLib.newString(lb) + StringLib.newString(((perimeter) + "")) + StringLib.newString(lb) + StringLib.newString(((height) + ""))+"") ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Test {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n,m ;
      n=sc.nextInt();
      m=sc.nextInt();
      int max=Integer.MIN_VALUE ;
      int a=0,b=0 ;
      int[][] mat=new int[n][m];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<m ; j++){
          mat[i][j]=sc.nextInt();
          if(mat[i][j]>max){
            max=mat[i][j];
            a=(i+1);
            b=(j+1);
          }
        }
      }
      System.out.println(Math.max(a,n-a+1)*Math.max(b,m-b+1));
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ;
    var m : int ;
     n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
    var max : int ; max := -2147483648 ;
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
    var mat : Sequence(Sequence(int)) ; mat := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     mat[i+1][j+1] := sc.getCurrent()->toInteger() ; 
     if (mat[i+1][j+1] > max) then (     max := mat[i+1][j+1] ; 
     a := (i + 1) ; 
     b := (j + 1) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{a, n - a + 1}->max() * Set{b, m - b + 1}->max()) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    Scanner scan=new Scanner(System.in);
    double a=scan.nextDouble();
    double b=scan.nextDouble();
    double C=scan.nextDouble();
    double Crad=Math.toRadians(C);
    double keisan=0.0 ;
    keisan=a*b*Math.sin(Crad)/2 ;
    System.out.println(keisan);
    keisan=(a+b)+Math.sqrt(a*a+b*b-2*a*b*Math.cos(Crad));
    System.out.println(keisan);
    keisan=b*Math.sin(Crad);
    System.out.println(keisan);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : double ; a := scan.getCurrent()->toReal() ;
    var b : double ; b := scan.getCurrent()->toReal() ;
    var C : double ; C := scan.getCurrent()->toReal() ;
    var Crad : double ; Crad := (0.017453292519943295*(C)) ;
    var keisan : double ; keisan := 0.0 ;
    keisan := a * b * (Crad)->sin() / 2 ; 
    OclFile["System.out"].println(keisan) ; 
    keisan := (a + b) + (a * a + b * b - 2 * a * b * (Crad)->cos())->sqrt() ; 
    OclFile["System.out"].println(keisan) ; 
    keisan := b * (Crad)->sin() ; 
    OclFile["System.out"].println(keisan) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    final int a=sc.nextInt();
    final int b=sc.nextInt();
    final int C=sc.nextInt();
    final double h=Math.sin(Math.toRadians(C))*b ;
    final double rest_a=a-Math.cos(Math.toRadians(C))*b ;
    final double c=Math.sqrt(h*h+rest_a*rest_a);
    System.out.printf("%.7f\n%.7f\n%.7f\n",a*h/2,a+b+c,h);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var h : double ; h := ((0.017453292519943295*(C)))->sin() * b ;
    var rest_a : double ; rest_a := a - ((0.017453292519943295*(C)))->cos() * b ;
    var c : double ; c := (h * h + rest_a * rest_a)->sqrt() ;
    OclFile["System.out"].printf("%.7f\n%.7f\n%.7f\n", a * h / 2, a + b + c, h) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class Main {
  public void exec()throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    String[] inStr=br.readLine().split(" ");
    int a=Integer.parseInt(inStr[0]);
    int b=Integer.parseInt(inStr[1]);
    double c=Integer.parseInt(inStr[2])*Math.PI/180 ;
    double h=b*Math.sin(c);
    double d=a-b*Math.cos(c);
    out.printf("%.4f\n",h*a/2);
    out.printf("%.4f\n",Math.sqrt(d*d+h*h)+a+b);
    out.printf("%.4f\n",h);
    out.flush();
  }
  public static void main(String[] args)throws IOException {
    new Main().exec();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation exec() : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var inStr : Sequence(String) ; inStr := br.readLine()->split(" ") ;
    var a : int ; a := (inStr[0+1])->toInteger() ;
    var b : int ; b := (inStr[1+1])->toInteger() ;
    var c : double ; c := (inStr[2+1])->toInteger() * 3.141592653589793 / 180 ;
    var h : double ; h := b * (c)->sin() ;
    var d : double ; d := a - b * (c)->cos() ;
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().exec() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in),1);
    String s ;
    String sl[];
    s=r.readLine();
    System.out.printf("%c",s.charAt(0)+1);
  }
}
class RemRing {
  long module ;
  public RemRing(long module){
    this.module=module ;
  }
  public long sum(long a,long b){
    return(a+b+module)% module ;
  }
  public long sub(long a,long b){
    return(a-b+module)% module ;
  }
  public long prod(long a,long b){
    return(a*b)% module ;
  }
  public long div(long a,long b){
    return(a*inv(b))% module ;
  }
  public long inv(long a){
    long b=this.module ;
    long u=1 ;
    long v=0 ;
    while(b>0){
      long t=a/b ;
      a-=t*b ;
      u-=t*v ;
      long z=a ;
      a=b ;
      b=z ;
      z=u ;
      u=v ;
      v=z ;
    }
    u %=this.module ;
    if(u<0)u+=this.module ;
    return u ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 1) ;
     var s : String ;
    var sl : Sequence(String) ;
    s := r.readLine() ; 
    OclFile["System.out"].printf("%c", s->at(0+1) + 1) ; 
 );
}
class RemRing {
   attribute module : long;
   static operation newRemRing( module : long) : RemRing
  pre: true
  post: true
  activity:
  ( var self : RemRing ;
    self := createRemRing();
    self.initialise(module);
    return self );
  operation initialise( module : long) : void
  pre: true  post: true
  activity: (     self.module := module );
   operation sum( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a + b + module) mod module );
   operation sub( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a - b + module) mod module );
   operation prod( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a * b) mod module );
   operation div( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a * inv(b)) mod module );
   operation inv( a : long) : long
  pre: true
  post: true
  activity: (     var b : long ; b := self.module ;
     var u : long ; u := 1 ;
    var v : long ; v := 0 ;
    while (b > 0) do (     var t : long ; t := a / b ;
     a := a-(t * b) ; 
    u := u-(t * v) ; 
    var z : long ; z := a ;
    a := b ; 
    b := z ; 
    z := u ; 
    u := v ; 
    v := z ; 
 ) ; 
    u := u mod self.module ; 
    if (u < 0) then     u := u+(self.module) ; else skip ; 
    return u 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class contest {
  public static void main(String[] arguments){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int in=0 ; in<t ; in++){
      int n=sc.nextInt();
      int ar[]=new int[n*2];
      for(int i=0 ; i<2*n ; i++)ar[i]=sc.nextInt();
      ArrayList<Integer>odd=new ArrayList<>();
      ArrayList<Integer>eve=new ArrayList<>();
      for(int i=0 ; i<2*n ; i++){
        if(ar[i] % 2==0){
          eve.add(1+i);
        }
        else {
          odd.add(1+i);
        }
      }
      int c=0 ;
      for(int i=0 ; i<odd.size()&& c<n-1 ; i+=2){
        if(odd.size()-i>1){
          System.out.println(odd.get(i)+" "+odd.get(i+1));
          c++;
        }
      }
      for(int i=0 ; i<eve.size()&& c<n-1 ; i+=2){
        if(eve.size()-i>1){
          System.out.println(eve.get(i)+" "+eve.get(i+1));
          c++;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class contest {
  static   operation main( arguments : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var in : int ; in := 0 ; while in < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ar : Sequence(int) ; ar := Integer.subrange(1,n * 2)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 * n do (     ar[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var odd : Sequence(int) ; odd := Sequence{} ;
    var eve : Sequence(int) ; eve := Sequence{} ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     if (ar[i+1] mod 2 = 0) then (     eve := eve->including(1 + i) ) else (     odd := odd->including(1 + i) ) )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < odd->size() & c < n - 1 do ( (     if (odd->size() - i > 1) then (     OclFile["System.out"].println(odd->at(i+1) + " " + odd->at(i + 1+1)) ; 
     c := c + 1 ) else skip )  ;     i := i+(2) ) ; 
        var i : int ; i := 0 ; while i < eve->size() & c < n - 1 do ( (     if (eve->size() - i > 1) then (     OclFile["System.out"].println(eve->at(i+1) + " " + eve->at(i + 1+1)) ; 
     c := c + 1 ) else skip )  ;     i := i+(2) ) ; 
 )  ;     in := in + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class cp {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t-->0){
      String[] str=br.readLine().split(" ");
      long n=Integer.parseInt(str[0]);
      int even=0,odd=0 ;
      int count=1 ;
      String[] str1=br.readLine().split(" ");
      for(int i=0 ; i<2*n ; i++){
        int x=Integer.parseInt(str1[i]);
        if(x % 2==0){
          if(even!=0){
            if(count!=n){
              pw.println(even+" "+(i+1));
              count++;
            }
            even=0 ;
          }
          else {
            even=i+1 ;
          }
        }
        else {
          if(odd!=0){
            if(count!=n){
              pw.println(odd+" "+(i+1));
              count++;
            }
            odd=0 ;
          }
          else {
            odd=i+1 ;
          }
        }
      }
    }
    pw.flush();
  }
  public static ArrayList<Integer>findSquare(int n){
    ArrayList<Integer>ans=new ArrayList<>();
    int i=0 ;
    while(i*i<=2*(n-1)){
      ans.add(i*i);
      i++;
    }
    return ans ;
  }
  public static ArrayList<Long>findAllFactors(long num){
    ArrayList<Long>factors=new ArrayList<Long>();
    for(long i=1 ; i<=num/i ; ++i){
      if(num % i==0){
        factors.add(i);
        factors.add(num/i);
      }
    }
    Collections.sort(factors);
    return factors ;
  }
  public static long gcd(long a,long b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     var n : long ; n := (str[0+1])->toInteger() ;
    var even : int ; even := 0 ;
    var odd : int ; odd := 0 ;
    var count : int ; count := 1 ;
    var str1 : Sequence(String) ; str1 := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     var x : int ; x := (str1[i+1])->toInteger() ;
     if (x mod 2 = 0) then (     if (even /= 0) then (     if (count /= n) then (     skip ; 
     count := count + 1 ) else skip ; 
     even := 0 ) else (     even := i + 1 ) ) else (     if (odd /= 0) then (     if (count /= n) then (     skip ; 
     count := count + 1 ) else skip ; 
     odd := 0 ) else (     odd := i + 1 ) ) )  ;     i := i + 1 ) ; 
 ) ;  ) ;  
    skip ; 
 );
  static   operation findSquare( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Sequence{} ;
     var i : int ; i := 0 ;
     while (i * i <= 2 * (n - 1)) do (     ans := ans->including(i * i) ; 
     i := i + 1 ) ; 
     return ans );
  static   operation findAllFactors( num : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var factors : Sequence(long) ; factors := Sequence{} ;
         var i : long ; i := 1 ; while i <= num / i do ( (     if (num mod i = 0) then (     factors := factors->including(i) ; 
     factors := factors->including(num / i) ) else skip )  ;     i := i + 1 ) ; 
     factors := factors->sort() ; 
     return factors );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeSixtyTwo {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int m=input.nextInt();
    int d=input.nextInt();
    int k=8-d ;
    if(m==1 || m==3 || m==5 || m==7 || m==8 || m==10 || m==12){
      int o=31-k ;
      if(o>28){
        System.out.println(6);
      }
      else {
        System.out.println(5);
      }
    }
    if(m==4 || m==6 || m==9 || m==11){
      int p=30-k ;
      if(p>28){
        System.out.println(6);
      }
      else {
        System.out.println(5);
      }
    }
    if(m==2){
      if(d==1){
        System.out.println(4);
      }
      else {
        System.out.println(5);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeSixtyTwo {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := input.getCurrent()->toInteger() ;
    var d : int ; d := input.getCurrent()->toInteger() ;
    var k : int ; k := 8 - d ;
    if (m = 1 or m = 3 or m = 5 or m = 7 or m = 8 or m = 10 or m = 12) then (     var o : int ; o := 31 - k ;
     if (o > 28) then (     OclFile["System.out"].println(6) ) else (     OclFile["System.out"].println(5) ) ) else skip ; 
    if (m = 4 or m = 6 or m = 9 or m = 11) then (     var p : int ; p := 30 - k ;
     if (p > 28) then (     OclFile["System.out"].println(6) ) else (     OclFile["System.out"].println(5) ) ) else skip ; 
    if (m = 2) then (     if (d = 1) then (     OclFile["System.out"].println(4) ) else (     OclFile["System.out"].println(5) ) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static final int[] monthLengths={
    31,28,31,30,31,30,31,31,30,31,30,31 };
    public static void main(String[] args){
      Scanner scan=new Scanner(System.in);
      int month=scan.nextInt();
      int day=scan.nextInt();
      int colomnCount=1 ;
      for(int i=0 ; i<monthLengths[month-1]; i++){
        if(day>7){
          day=1 ;
          colomnCount++;
        }
        day++;
      }
      System.out.println(colomnCount);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute monthLengths : Sequence(int) := Sequence{31,28,31,30,31,30,31,31,30,31,30,31};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var month : int ; month := scan.getCurrent()->toInteger() ;
    var day : int ; day := scan.getCurrent()->toInteger() ;
    var colomnCount : int ; colomnCount := 1 ;
        var i : int ; i := 0 ; while i < monthLengths[month - 1+1] do ( (     if (day > 7) then (     day := 1 ; 
     colomnCount := colomnCount + 1 ) else skip ; 
     day := day + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(colomnCount) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class One {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String s=scanner.nextLine();
    int[] monthDays=new int[] {
      31,28,31,30,31,30,31,31,30,31,30,31 };
      int m=Integer.parseInt(s.split(" ")[0]);
      int d=Integer.parseInt(s.split(" ")[1]);
      int totalDays=monthDays[m-1];
      int startingWeak=7-d+1 ;
      int remainingDays=totalDays-startingWeak ;
      int weeks=(int)Math.ceil((double)remainingDays/7);
      System.out.println(weeks+1);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class One {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scanner.nextLine() ;
    var monthDays : Sequence(int) ; monthDays := Sequence{31,28,31,30,31,30,31,31,30,31,30,31} ;
    var m : int ; m := (s->split(" ")[0+1])->toInteger() ;
    var d : int ; d := (s->split(" ")[1+1])->toInteger() ;
    var totalDays : int ; totalDays := monthDays[m - 1+1] ;
    var startingWeak : int ; startingWeak := 7 - d + 1 ;
    var remainingDays : int ; remainingDays := totalDays - startingWeak ;
    var weeks : int ; weeks := (remainingDays->oclAsType(double) / 7)->ceil()->oclAsType(int) ;
    OclFile["System.out"].println(weeks + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class PetrCalender {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] md=br.readLine().split(" ");
    int m=Integer.parseInt(md[0]);
    int d=Integer.parseInt(md[1]);
    int res=0 ;
    switch(m){
      case 1 : res=getDays(d,31);
      break ;
      case 2 : res=getDays(d,28);
      break ;
      case 3 : res=getDays(d,31);
      break ;
      case 4 : res=getDays(d,30);
      break ;
      case 5 : res=getDays(d,31);
      break ;
      case 6 : res=getDays(d,30);
      break ;
      case 7 : res=getDays(d,31);
      break ;
      case 8 : res=getDays(d,31);
      break ;
      case 9 : res=getDays(d,30);
      break ;
      case 10 : res=getDays(d,31);
      break ;
      case 11 : res=getDays(d,30);
      break ;
      case 12 : res=getDays(d,31);
      break ;
    }
    System.out.println(res);
  }
  public static int getDays(int d,int m){
    int days=7-d+1 ;
    int res=(int)Math.ceil(((m-days)*1.0)/7.0);
    return res+1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class PetrCalender {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var md : Sequence(String) ; md := br.readLine()->split(" ") ;
    var m : int ; m := (md[0+1])->toInteger() ;
    var d : int ; d := (md[1+1])->toInteger() ;
    var res : int ; res := 0 ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (m) ; 
       if _switchval = 1 then
     res := getDays(d, 31) ; 
    break 
   else skip ;
       if _switchval = 2 then
     res := getDays(d, 28) ; 
    break 
   else skip ;
       if _switchval = 3 then
     res := getDays(d, 31) ; 
    break 
   else skip ;
       if _switchval = 4 then
     res := getDays(d, 30) ; 
    break 
   else skip ;
       if _switchval = 5 then
     res := getDays(d, 31) ; 
    break 
   else skip ;
       if _switchval = 6 then
     res := getDays(d, 30) ; 
    break 
   else skip ;
       if _switchval = 7 then
     res := getDays(d, 31) ; 
    break 
   else skip ;
       if _switchval = 8 then
     res := getDays(d, 31) ; 
    break 
   else skip ;
       if _switchval = 9 then
     res := getDays(d, 30) ; 
    break 
   else skip ;
       if _switchval = 10 then
     res := getDays(d, 31) ; 
    break 
   else skip ;
       if _switchval = 11 then
     res := getDays(d, 30) ; 
    break 
   else skip ;
       if _switchval = 12 then
     res := getDays(d, 31) ; 
    break 
   else skip ;
 )
    OclFile["System.out"].println(res) ; 
 );
  static   operation getDays( d : int, m : int) : int
  pre: true
  post: true
  activity: (     var days : int ; days := 7 - d + 1 ;
     var res : int ; res := (((m - days) * 1.0) / 7.0)->ceil()->oclAsType(int) ;
     return res + 1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  private static final long MOD=1_000_000_007L ;
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt(),m=scanner.nextInt();
      long[] factorial=new long[m+1];
      factorial[0]=1 ;
      IntStream.rangeClosed(1,m).forEach(i->factorial[i]=factorial[i-1]*i % MOD);
      long[] revFactorial=new long[m+1];
      revFactorial[m]=modPow(factorial[m],MOD-2);
      IntStream.rangeClosed(1,m).map(i->m-i).forEach(i->revFactorial[i]=revFactorial[i+1]*(i+1)% MOD);
      long answer=0L ;
      for(int i=0 ; i<=n ; i++){
        long result=((0==(i & 1))? 1 :-1)*factorial[n] % MOD*revFactorial[i] % MOD*revFactorial[n-i] % MOD ;
        result=(result+MOD)% MOD ;
        result=result*factorial[m] % MOD*revFactorial[m-i] % MOD*factorial[m-i] % MOD*factorial[m-i] % MOD*revFactorial[m-n] % MOD*revFactorial[m-n] % MOD ;
        answer=(answer+result)% MOD ;
      }
      System.out.println(answer);
    }
  }
  private static long modPow(long n,long m){
    long result=1L ;
    while(m>0){
      if(1==(m & 1)){
        result=result*n % MOD ;
      }
      n=n*n % MOD ;
      m>>=1 ;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 1_000_000_007L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
     var factorial : Sequence(long) ; factorial := Integer.subrange(1,m + 1)->collect(0) ;
    factorial[0+1] := 1 ; 
    for i : Integer.subrange(1, m) do
    (    factorial[i+1] := factorial[i - 1+1] * i mod MOD) ; 
    var revFactorial : Sequence(long) ; revFactorial := Integer.subrange(1,m + 1)->collect(0) ;
    revFactorial[m+1] := modPow(factorial[m+1], MOD - 2) ; 
    for i : Integer.subrange(1, m)->collect( _x1 | (lambda i : OclAny in m - i)->apply(_x1) ) do
    (    revFactorial[i+1] := revFactorial[i + 1+1] * (i + 1) mod MOD) ; 
    var answer : long ; answer := 0L ;
        var i : int ; i := 0 ; while i <= n do ( (     var result : long ; result := (if (0 = (MathLib.bitwiseAnd(i,1))) then 1 else -1 endif) * factorial[n+1] mod MOD * revFactorial[i+1] mod MOD * revFactorial[n - i+1] mod MOD ;
     result := (result + MOD) mod MOD ; 
     result := result * factorial[m+1] mod MOD * revFactorial[m - i+1] mod MOD * factorial[m - i+1] mod MOD * factorial[m - i+1] mod MOD * revFactorial[m - n+1] mod MOD * revFactorial[m - n+1] mod MOD ; 
     answer := (answer + result) mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 ))  );
  static   operation modPow( n : long, m : long) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 1L ;
     while (m > 0) do (     if (1 = (MathLib.bitwiseAnd(m,1))) then (     result := result * n mod MOD ) else skip ; 
     n := n * n mod MOD ; 
     m := m/(2->pow(1)) ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Subsrectangle {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int max=Integer.MIN_VALUE ;
      int h=0,w=0 ;
      for(int i=1 ; i<=n ; i++){
        for(int j=1 ; j<=m ; j++){
          int x=sc.nextInt();
          if(x>max){
            max=x ;
            h=i ;
            w=j ;
          }
        }
      }
      int r=Math.max(h,n-h+1);
      int rr=Math.max(w,m-w+1);
      System.out.println(r*rr);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Subsrectangle {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var max : int ; max := -2147483648 ;
    var h : int ; h := 0 ;
    var w : int ; w := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= m do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x > max) then (     max := x ; 
     h := i ; 
     w := j ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var r : int ; r := Set{h, n - h + 1}->max() ;
    var rr : int ; rr := Set{w, m - w + 1}->max() ;
    OclFile["System.out"].println(r * rr) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static long MOD=(long)Math.pow(10,9)+7 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    long[] kai=new long[5000001];
    kai[0]=1 ;
    for(long i=1 ; i<5000001 ; i++){
      kai[(int)i]=(i*kai[(int)(i-1)])% MOD ;
    }
    long ans=0 ;
    for(int k=0 ; k<=n ; k++){
      long t1=kai[n];
      t1=(t1*func(kai[n-k],MOD-2))% MOD ;
      t1=(t1*func(kai[k],MOD-2))% MOD ;
      long t2=kai[m];
      t2=(t2*func(kai[m-k],MOD-2))% MOD ;
      long t3=kai[m-k];
      t3=(t3*func(kai[m-n],MOD-2))% MOD ;
      t3=(t3*t3)% MOD ;
      long t=(t1*t2)% MOD ;
      t=(t*t3)% MOD ;
      if((k % 2)==0){
        ans=(ans+t)% MOD ;
      }
      else {
        ans=(ans-t+MOD)% MOD ;
      }
    }
    System.out.println(ans);
  }
  public static long func(long a,long x){
    if(x==0)return 1 ;
    if((x % 2)==0){
      long t=func(a,x/2);
      return(t*t)% MOD ;
    }
    else {
      return(a*func(a,x-1))% MOD ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : long := 10->pow(9)->oclAsType(long) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var kai : Sequence(long) ; kai := Integer.subrange(1,5000001)->collect(0) ;
    kai[0+1] := 1 ; 
        var i : long ; i := 1 ; while i < 5000001 do ( (     kai[i->oclAsType(int)+1] := (i * kai[(i - 1)->oclAsType(int)+1]) mod MOD )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var k : int ; k := 0 ; while k <= n do ( (     var t1 : long ; t1 := kai[n+1] ;
     t1 := (t1 * func(kai[n - k+1], MOD - 2)) mod MOD ; 
    t1 := (t1 * func(kai[k+1], MOD - 2)) mod MOD ; 
    var t2 : long ; t2 := kai[m+1] ;
    t2 := (t2 * func(kai[m - k+1], MOD - 2)) mod MOD ; 
    var t3 : long ; t3 := kai[m - k+1] ;
    t3 := (t3 * func(kai[m - n+1], MOD - 2)) mod MOD ; 
    t3 := (t3 * t3) mod MOD ; 
    var t : long ; t := (t1 * t2) mod MOD ;
    t := (t * t3) mod MOD ; 
    if ((k mod 2) = 0) then (     ans := (ans + t) mod MOD ) else (     ans := (ans - t + MOD) mod MOD ) ;  
 )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation func( a : long, x : long) : long
  pre: true
  post: true
  activity: (     if (x = 0) then     return 1 else skip ; 
     if ((x mod 2) = 0) then (     var t : long ; t := func(a, x / 2) ;
     return (t * t) mod MOD ) else (     return (a * func(a, x - 1)) mod MOD ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static void countCurrency(int amount){
    int[] notes=new int[] {
      2000,500,200,100,50,20,10,5,1 };
      int[] noteCounter=new int[9];
      for(int i=0 ; i<9 ; i++){
        if(amount>=notes[i]){
          noteCounter[i]=amount/notes[i];
          amount=amount-noteCounter[i]*notes[i];
        }
      }
      System.out.println("Currency Count->");
      for(int i=0 ; i<9 ; i++){
        if(noteCounter[i]!=0){
          System.out.println(notes[i]+" : "+noteCounter[i]);
        }
      }
    }
    public static void main(String argc[]){
      int amount=868 ;
      countCurrency(amount);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation countCurrency( amount : int) : void
  pre: true
  post: true
  activity: (     var notes : Sequence(int) ; notes := Sequence{2000,500,200,100,50,20,10,5,1} ;
     var noteCounter : Sequence(int) ; noteCounter := Integer.subrange(1,9)->collect(0) ;
        var i : int ; i := 0 ; while i < 9 do ( (     if (amount >= notes[i+1]) then (     noteCounter[i+1] := amount / notes[i+1] ; 
     amount := amount - noteCounter[i+1] * notes[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Currency Count->") ; 
        var i : int ; i := 0 ; while i < 9 do ( (     if (noteCounter[i+1] /= 0) then (     OclFile["System.out"].println(notes[i+1] + " : " + noteCounter[i+1]) ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var amount : int ; amount := 868 ;
     execute countCurrency(amount) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(true){
      String a=in.next();
      char[] num=a.toCharArray();
      if(num[0]=='0')break ;
      int A=0,B=0 ;
      for(int i=1 ; i<num.length ; i++){
        if(num[i]=='A'){
          A++;
        }
        else {
          B++;
        }
      }
      if(A>B)A++;
      else B++;
      System.out.println(A+" "+B);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var a : String ; a := in.getCurrent() ;
     var num : Sequence(String) ; num := a->characters() ;
    if (num[0+1] = '0') then     break else skip ; 
    var A : int ; A := 0 ;
    var B : int ; B := 0 ;
        var i : int ; i := 1 ; while i < num->size() do ( (     if (num[i+1] = 'A') then (     A := A + 1 ) else (     B := B + 1 ) )  ;     i := i + 1 ) ; 
    if (A > B) then     A := A + 1 else     B := B + 1 ; ;  
    OclFile["System.out"].println(A + " " + B) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Solution {
  public TreeNode mergeTrees(TreeNode t1,TreeNode t2){
    if(t1==null)return t2 ;
    if(t2==null)return t1 ;
    t1.val+=t2.val ;
    t1.left=mergeTrees(t1.left,t2.left);
    t1.right=mergeTrees(t1.right,t2.right);
    return t1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation mergeTrees( t1 : TreeNode, t2 : TreeNode) : TreeNode
  pre: true
  post: true
  activity: (     if (t1 = null) then     return t2 else skip ; 
     if (t2 = null) then     return t1 else skip ; 
    t1.val := t1.val+(t2.val) ; 
    t1.left := mergeTrees(t1.left, t2.left) ; 
    t1.right := mergeTrees(t1.right, t2.right) ; 
    return t1 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
class Interval {
  int buy,sell ;
}
class StockBuySell {
  void stockBuySell(int price[],int n){
    if(n==1)return ;
    int count=0 ;
    ArrayList<Interval>sol=new ArrayList<Interval>();
    int i=0 ;
    while(i<n-1){
      while((i<n-1)&&(price[i+1]<=price[i]))i++;
      if(i==n-1)break ;
      Interval e=new Interval();
      e.buy=i++;
      while((i<n)&&(price[i]>=price[i-1]))i++;
      e.sell=i-1 ;
      sol.add(e);
      count++;
    }
    if(count==0)System.out.println("There is no day when buying the stock "+"will make profit");
    else for(int j=0 ;
    j<count ;
    j++)System.out.println("Buy on day: "+sol.get(j).buy+"        "+"Sell on day : "+sol.get(j).sell);
    return ;
  }
  public static void main(String args[]){
    StockBuySell stock=new StockBuySell();
    int price[]={
      100,180,260,310,40,535,695 };
      int n=price.length ;
      stock.stockBuySell(price,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Interval {
   attribute buy : int;
}
class StockBuySell {
   operation stockBuySell( price : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     if (n = 1) then     return else skip ; 
     var count : int ; count := 0 ;
    var sol : Sequence(Interval) ; sol := Sequence{} ;
    var i : int ; i := 0 ;
    while (i < n - 1) do (     while ((i < n - 1) & (price[i + 1+1] <= price[i+1])) do     i := i + 1 ; ; 
     if (i = n - 1) then     break else skip ; 
    var e : Interval ; e := Interval.newInterval() ;
     e.buy := i  ; i := i + 1 ; 
    while ((i < n) & (price[i+1] >= price[i - 1+1])) do     i := i + 1 ; ; 
    e.sell := i - 1 ; 
    sol := sol->including(e) ; 
    count := count + 1 ; 
 ) ; 
    if (count = 0) then     OclFile["System.out"].println("There is no day when buying the stock " + "will make profit") else         var j : int ; j := 0 ; while j < count do (     OclFile["System.out"].println("Buy on day: " + sol->at(j+1).buy + "        " + "Sell on day : " + sol->at(j+1).sell) ;  ;     j := j + 1 ) ; ;  
    return 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stock : StockBuySell ; stock := StockBuySell.newStockBuySell() ;
     var price : Sequence(int) ; price := Sequence{100,180,260,310,40,535,695} ;
     var n : int ; n := price->size() ;
     stock.stockBuySell(price, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class SortString {
  static final int MAX_CHAR=26 ;
  static void sortString(String str){
    int letters[]=new int[MAX_CHAR];
    for(char x : str.toCharArray()){
      letters[x-'a']++;
    }
    for(int i=0 ; i<MAX_CHAR ; i++){
      for(int j=0 ; j<letters[i]; j++){
        System.out.print((char)(i+'a'));
      }
    }
  }
  public static void main(String[] args){
    sortString("geeksforgeeks");
  }
}
------------------------------------------------------------
OCL File:
---------
class SortString {
  static    attribute MAX_CHAR : int := 26;
  static   operation sortString( str : String) : void
  pre: true
  post: true
  activity: (     var letters : Sequence(int) ; letters := Integer.subrange(1,MAX_CHAR)->collect(0) ;
     for (x : str->characters()) do ( (     letters[x - ('a')->char2byte()+1] := letters[x - ('a')->char2byte()+1] + 1 )  ) ; 
         var i : int ; i := 0 ; while i < MAX_CHAR do ( (         var j : int ; j := 0 ; while j < letters[i+1] do ( (     OclFile["System.out"].print((i + 'a')->oclAsType(String)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute sortString("geeksforgeeks") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int uniqueMorseRepresentations(String[] words){
    String[] MORSE=new String[] {
      ".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.." };
      Set<String>seen=new HashSet();
      for(String word : words){
        StringBuilder code=new StringBuilder();
        for(char c : word.toCharArray())code.append(MORSE[c-'a']);
        seen.add(code.toString());
      }
      return seen.size();
    }
  }

------------------------------------------------------------
OCL File:
---------
class Solution {
   operation uniqueMorseRepresentations( words : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var MORSE : Sequence(String) ; MORSE := Sequence{".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."} ;
     var seen : Set(String) ; seen := Set{} ;
     for (word : words) do ( (     var code : String ; code := StringLib.newString() ;
     for (c : word->characters()) do (     code := code + StringLib.newString(MORSE[c - ('a')->char2byte()+1]) ;  ) ; 
     seen := seen->including(code+"") )  ) ; 
     return seen->size() );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class MajorityElement {
  void printMajority(int a[],int size){
    int cand=findCandidate(a,size);
    if(isMajority(a,size,cand))System.out.println(" "+cand+" ");
    else System.out.println("No Majority Element");
  }
  int findCandidate(int a[],int size){
    int maj_index=0,count=1 ;
    int i ;
    for(i=1 ; i<size ; i++){
      if(a[maj_index]==a[i])count++;
      else count--;
      if(count==0){
        maj_index=i ;
        count=1 ;
      }
    }
    return a[maj_index];
  }
  boolean isMajority(int a[],int size,int cand){
    int i,count=0 ;
    for(i=0 ; i<size ; i++){
      if(a[i]==cand)count++;
    }
    if(count>size/2)return true ;
    else return false ;
  }
  public static void main(String[] args){
    MajorityElement majorelement=new MajorityElement();
    int a[]=new int[] {
      1,3,3,1,2 };
      int size=a.length ;
      majorelement.printMajority(a,size);
    }
  }

------------------------------------------------------------
OCL File:
---------
class MajorityElement {
   operation printMajority( a : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (     var cand : int ; cand := findCandidate(a, size) ;
     if (isMajority(a, size, cand)) then     OclFile["System.out"].println(" " + cand + " ") ; else     OclFile["System.out"].println("No Majority Element") ; );
   operation findCandidate( a : Sequence(int), size : int) : int
  pre: true
  post: true
  activity: (     var maj_index : int ; maj_index := 0 ;
    var count : int ; count := 1 ;
     var i : int ;
         i := 1 ; while i < size do ( (     if (a[maj_index+1] = a[i+1]) then     count := count + 1 else     count := count - 1 ; ;  
     if (count = 0) then (     maj_index := i ; 
     count := 1 ) else skip )  ;     i := i + 1 ) ; 
     return a[maj_index+1] );
   operation isMajority( a : Sequence(int), size : int, cand : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ;
    var count : int ; count := 0 ;
         i := 0 ; while i < size do ( (     if (a[i+1] = cand) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     if (count > size / 2) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var majorelement : MajorityElement ; majorelement := MajorityElement.newMajorityElement() ;
     var a : Sequence(int) ; a := Sequence{1,3,3,1,2} ;
     var size : int ; size := a->size() ;
     majorelement.printMajority(a, size) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.Math ;
import java.util.Arrays ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] aCity=new int[n];
    int[] bCity=new int[m];
    int x=sc.nextInt();
    int y=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      aCity[i]=sc.nextInt();
    }
    for(int i=0 ; i<m ; i++){
      bCity[i]=sc.nextInt();
    }
    Arrays.sort(aCity);
    Arrays.sort(bCity);
    int aRightEdge=aCity[n-1];
    int bLeftEdge=bCity[0];
    if(aRightEdge>bLeftEdge){
      System.out.println("War");
      return ;
    }
    boolean f=false ;
    for(int i=aRightEdge ; i<=bLeftEdge ; i++){
      int z=i ;
      if(x<z && z<=y){
        if(aRightEdge<z && z<=bLeftEdge){
          f=true ;
          break ;
        }
      }
    }
    if(f){
      System.out.println("No War");
    }
    else {
      System.out.println("War");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var aCity : Sequence(int) ; aCity := Integer.subrange(1,n)->collect(0) ;
    var bCity : Sequence(int) ; bCity := Integer.subrange(1,m)->collect(0) ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     aCity[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     bCity[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    aCity := aCity->sort() ; 
    bCity := bCity->sort() ; 
    var aRightEdge : int ; aRightEdge := aCity[n - 1+1] ;
    var bLeftEdge : int ; bLeftEdge := bCity[0+1] ;
    if (aRightEdge > bLeftEdge) then (     OclFile["System.out"].println("War") ; 
     return ) else skip ; 
    var f : boolean ; f := false ;
        var i : int ; i := aRightEdge ; while i <= bLeftEdge do ( (     var z : int ; z := i ;
     if (x < z & z <= y) then (     if (aRightEdge < z & z <= bLeftEdge) then (     f := true ; 
     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (f) then (     OclFile["System.out"].println("No War") ) else (     OclFile["System.out"].println("War") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    int M=Integer.parseInt(sc.next());
    int X=Integer.parseInt(sc.next());
    int Y=Integer.parseInt(sc.next());
    int x=-1000 ;
    for(int i=0 ; i<N ; i++){
      int n=Integer.parseInt(sc.next());
      x=x<n ? n : x ;
    }
    int y=1000 ;
    for(int i=0 ; i<M ; i++){
      int n=Integer.parseInt(sc.next());
      y=y>n ? n : y ;
    }
    String ans="War" ;
    for(int i=x ; i<=y ; i++){
      if(X<i && x<i && i<=Y && i<=y){
        ans="No War" ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var M : int ; M := (sc.getCurrent())->toInteger() ;
    var X : int ; X := (sc.getCurrent())->toInteger() ;
    var Y : int ; Y := (sc.getCurrent())->toInteger() ;
    var x : int ; x := -1000 ;
        var i : int ; i := 0 ; while i < N do ( (     var n : int ; n := (sc.getCurrent())->toInteger() ;
     x := if x < n then n else x endif )  ;     i := i + 1 ) ; 
    var y : int ; y := 1000 ;
        var i : int ; i := 0 ; while i < M do ( (     var n : int ; n := (sc.getCurrent())->toInteger() ;
     y := if y > n then n else y endif )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "War" ;
        var i : int ; i := x ; while i <= y do ( (     if (X < i & x < i & i <= Y & i <= y) then (     ans := "No War" ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String fst[]=in.readLine().split(" ");
    String[] At=in.readLine().split(" ");
    String[] Bt=in.readLine().split(" ");
    int maxA=Integer.parseInt(fst[2]);
    int minB=Integer.parseInt(fst[3]);
    for(int index=0 ; index<At.length ; index++){
      maxA=Math.max(maxA,Integer.parseInt(At[index]));
    }
    for(int index=0 ; index<Bt.length ; index++){
      minB=Math.min(minB,Integer.parseInt(Bt[index]));
    }
    if(maxA==minB || maxA>minB){
      System.out.println("War");
    }
    else {
      System.out.println("No War");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var fst : Sequence(String) ; fst := in.readLine()->split(" ") ;
    var At : Sequence(String) ; At := in.readLine()->split(" ") ;
    var Bt : Sequence(String) ; Bt := in.readLine()->split(" ") ;
    var maxA : int ; maxA := (fst[2+1])->toInteger() ;
    var minB : int ; minB := (fst[3+1])->toInteger() ;
        var index : int ; index := 0 ; while index < At->size() do ( (     maxA := Set{maxA, (At[index+1])->toInteger()}->max() )  ;     index := index + 1 ) ; 
        var index : int ; index := 0 ; while index < Bt->size() do ( (     minB := Set{minB, (Bt[index+1])->toInteger()}->min() )  ;     index := index + 1 ) ; 
    if (maxA = minB or maxA > minB) then (     OclFile["System.out"].println("War") ) else (     OclFile["System.out"].println("No War") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class pair {
    int first,second ;
    public pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static void pairWithEqualSum(int A[],int n){
    Map<Integer,Vector<pair>>mp=new HashMap<>();
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        pair p=new pair(A[i],A[j]);
        Vector<pair>pp=new Vector<pair>();
        if(mp.containsKey(A[i]+A[j]))pp.addAll(mp.get(A[i]+A[j]));
        pp.add(p);
        mp.put(A[i]+A[j],pp);
      }
    }
    for(Map.Entry<Integer,Vector<pair>>itr : mp.entrySet()){
      if(itr.getValue().size()>1){
        System.out.print("Pairs : ");
        for(int i=0 ; i<itr.getValue().size(); i++){
          System.out.print("("+itr.getValue().get(i).first+","+itr.getValue().get(i).second+")");
        }
        System.out.print(" have sum : "+itr.getKey()+"\n");
      }
    }
  }
  public static void main(String[] args){
    int A[]={
      6,4,12,10,22,54,32,42,21,11,8,2 };
      int n=A.length ;
      pairWithEqualSum(A,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class pair {
   attribute first : int;
   static operation newpair( first : int, second : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation pairWithEqualSum( A : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var mp : Map(int,Sequence(pair)) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var p : pair ; p := pair.newpair(A[i+1], A[j+1]) ;
     var pp : Sequence(pair) ; pp := Sequence{} ;
    if (mp->keys()->includes(A[i+1] + A[j+1])) then     pp := pp->union(mp->at(A[i+1] + A[j+1])) ; else skip ; 
    pp := pp->including(p) ; 
    mp := mp->union(Map{A[i+1] + A[j+1] |-> pp}) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     for (itr : mp->asSet()) do ( (     if (itr.getValue()->size() > 1) then (     OclFile["System.out"].print("Pairs : ") ; 
         var i : int ; i := 0 ; while i < itr.getValue()->size() do ( (     OclFile["System.out"].print("(" + itr.getValue()->at(i+1)->at("first") + "," + itr.getValue()->at(i+1)->at("second") + ")") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(" have sum : " + itr.getKey() + "\n") ) else skip )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{6,4,12,10,22,54,32,42,21,11,8,2} ;
     var n : int ; n := A->size() ;
     execute pairWithEqualSum(A, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Solution {
  static PrintWriter pw ;
  static FastScanner s ;
  public static void main(String[] args)throws Exception {
    pw=new PrintWriter(System.out);
    s=new FastScanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt(),m=s.nextInt();
      int a[][]=new int[n][m];
      int max=Integer.MIN_VALUE ;
      int maxi=0 ;
      int maxj=0 ;
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<m ; j++){
        a[i][j]=s.nextInt();
        if(max<a[i][j]){
          max=a[i][j];
          maxi=i ;
          maxj=j ;
        }
      }
      int x=Math.max(n-1-maxi,maxi)+1 ;
      int y=Math.max(m-1-maxj,maxj)+1 ;
      pw.println(x*y);
    }
    pw.flush();
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public FastScanner(String s)throws Exception {
    br=new BufferedReader(new FileReader(new File(s)));
  }
  public String next()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(next());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute pw : OclFile;
  static   attribute s : FastScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     pw := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     s := FastScanner.newFastScanner(OclFile["System.in"]) ; 
    var t : int ; t := s.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.nextInt() ;
    var m : int ; m := s.nextInt() ;
     var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var max : int ; max := -2147483648 ;
    var maxi : int ; maxi := 0 ;
    var maxj : int ; maxj := 0 ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < m do ( (     a[i+1][j+1] := s.nextInt() ; 
     if (max < a[i+1][j+1]) then (     max := a[i+1][j+1] ; 
     maxi := i ; 
     maxj := j ) else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var x : int ; x := Set{n - 1 - maxi, maxi}->max() + 1 ;
    var y : int ; y := Set{m - 1 - maxj, maxj}->max() + 1 ;
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  static final int mod=1000000007 ;
  static int digitNumber(long n){
    if(n==0)return 1 ;
    if(n==1)return 9 ;
    if(n % 2!=0){
      int temp=digitNumber((n-1)/2)% mod ;
      return(9*(temp*temp)% mod)% mod ;
    }
    else {
      int temp=digitNumber(n/2)% mod ;
      return(temp*temp)% mod ;
    }
  }
  static int countExcluding(int n,int d){
    if(d==0)return(9*digitNumber(n-1))% mod ;
    else return(8*digitNumber(n-1))% mod ;
  }
  public static void main(String[] args){
    int d=9 ;
    int n=3 ;
    System.out.println(countExcluding(n,d));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute mod : int := 1000000007;
  static   operation digitNumber( n : long) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     if (n = 1) then     return 9 else skip ; 
     if (n mod 2 /= 0) then (     var temp : int ; temp := digitNumber((n - 1) / 2) mod mod ;
     return (9 * (temp * temp) mod mod) mod mod ) else (     var temp : int ; temp := digitNumber(n / 2) mod mod ;
     return (temp * temp) mod mod ) );
  static   operation countExcluding( n : int, d : int) : int
  pre: true
  post: true
  activity: (     if (d = 0) then     return (9 * digitNumber(n - 1)) mod mod else     return (8 * digitNumber(n - 1)) mod mod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : int ; d := 9 ;
     var n : int ; n := 3 ;
     OclFile["System.out"].println(countExcluding(n, d)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.IOException ;
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Deque ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int X=sc.nextInt();
    X++;
    int Y=sc.nextInt();
    int[] x=new int[N];
    int[] y=new int[M];
    for(int i=0 ; i<N ; i++)x[i]=sc.nextInt();
    for(int i=0 ; i<M ; i++)y[i]=sc.nextInt();
    int max_x=-101 ;
    int min_y=101 ;
    for(int i=0 ; i<N ; i++)if(max_x<x[i])max_x=x[i];
    max_x++;
    for(int i=0 ; i<M ; i++)if(min_y>y[i])min_y=y[i];
    boolean ans=false ;
    if(X<=Y && max_x<=min_y &&((Y>=max_x && Y<=min_y)||(min_y>=X && min_y<=Y)))ans=true ;
    System.out.println(ans ? "No War" : "War");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var X : int ; X := sc.getCurrent()->toInteger() ;
    X := X + 1 ; 
    var Y : int ; Y := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,N)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     x[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do (     y[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var max_x : int ; max_x := -101 ;
    var min_y : int ; min_y := 101 ;
        var i : int ; i := 0 ; while i < N do (     if (max_x < x[i+1]) then     max_x := x[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    max_x := max_x + 1 ; 
        var i : int ; i := 0 ; while i < M do (     if (min_y > y[i+1]) then     min_y := y[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    var ans : boolean ; ans := false ;
    if (X <= Y & max_x <= min_y & ((Y >= max_x & Y <= min_y) or (min_y >= X & min_y <= Y))) then     ans := true ; else skip ; 
    OclFile["System.out"].println(if ans then "No War" else "War" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int X=sc.nextInt();
    int Y=sc.nextInt();
    int[] x=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=sc.nextInt();
    }
    int[] y=new int[m];
    for(int i=0 ; i<m ; i++){
      y[i]=sc.nextInt();
    }
    Arrays.sort(x);
    Arrays.sort(y);
    if(x[n-1]<y[0] && X<y[0] && x[n-1]<Y){
      out.println("No War");
    }
    else {
      out.println("War");
    }
  }
  static long fact(long a){
    long b=1 ;
    for(long i=1 ; i<=a ; i++){
      b*=i ;
    }
    return b ;
  }
  static int gcd(int a,int b){
    int temp ;
    while((temp=a % b)!=0){
      a=b ;
      b=temp ;
    }
    return b ;
  }
  static long combi(long a,long b){
    b=min(a-b,b);
    return permu(a,b)/fact(b);
  }
  static long permu(long a,long b){
    long temp=1 ;
    for(long i=a ; i>a-b ; i--){
      temp*=i ;
    }
    return temp ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var X : int ; X := sc.getCurrent()->toInteger() ;
    var Y : int ; Y := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var y : Sequence(int) ; y := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     y[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    x := x->sort() ; 
    y := y->sort() ; 
    if (x[n - 1+1] < y[0+1] & X < y[0+1] & x[n - 1+1] < Y) then (     out.println("No War") ) else (     out.println("War") ) ;  
 );
  static   operation fact( a : long) : long
  pre: true
  post: true
  activity: (     var b : long ; b := 1 ;
         var i : long ; i := 1 ; while i <= a do ( (     b := b*(i) )  ;     i := i + 1 ) ; 
     return b );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var temp : int ;
         temp := a mod b ;
    while ((temp) /= 0) do (    skip ; (     a := b ; 
     b := temp ) ;     temp := a mod b ;
 ) ;  
     return b );
  static   operation combi( a : long, b : long) : long
  pre: true
  post: true
  activity: (     b := Set{a - b, b}->min() ; 
     return permu(a, b) / fact(b) );
  static   operation permu( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var temp : long ; temp := 1 ;
         var i : long ; i := a ; while i > a - b do ( (     temp := temp*(i) )  ;     i := i - 1 ) ; 
     return temp );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class KDigitSquare {
  public static long firstkdigits(int n,int k){
    double product=n*Math.log10(n);
    double decimal_part=product-Math.floor(product);
    decimal_part=Math.pow(10,decimal_part);
    double digits=Math.pow(10,k-1),i=0 ;
    return((long)(decimal_part*digits));
  }
  public static void main(String[] args){
    int n=1450 ;
    int k=6 ;
    System.out.println(firstkdigits(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class KDigitSquare {
  static   operation firstkdigits( n : int, k : int) : long
  pre: true
  post: true
  activity: (     var product : double ; product := n * (n)->log10() ;
     var decimal_part : double ; decimal_part := product - (product)->floor() ;
    decimal_part := 10->pow(decimal_part) ; 
    var digits : double ; digits := 10->pow(k - 1) ;
    var i : double ; i := 0 ;
    return ((decimal_part * digits)->oclAsType(long)) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1450 ;
     var k : int ; k := 6 ;
     OclFile["System.out"].println(firstkdigits(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class HelloWorld {
  public static void solve(int n,int m,int k){
    System.out.println((n<=m && n<=k ? "Yes" : "No"));
  }
  public static void sol(int n){
    int ans=0 ;
    for(int i=1 ; i<n ; ++i){
      if(n % i==0){
        ans++;
      }
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    System.out.println(n*9+" "+(n*8));
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation solve( n : int, m : int, k : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((if n <= m & n <= k then "Yes" else "No" endif)) );
  static   operation sol( n : int) : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     if (n mod i = 0) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(n * 9 + " " + (n * 8)) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codechef {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    int temp ;
    for(int i=0 ; i<n-1 ; i++){
      for(int j=0 ; j<n-i-1 ; j++){
        if(arr[j]>arr[j+1]){
          temp=arr[j];
          arr[j]=arr[j+1];
          arr[j+1]=temp ;
        }
      }
    }
    int count=0 ;
    for(int i=0 ; i<n-1 ; i=i+2){
      if(arr[i]!=arr[i+1]){
        count+=Math.abs(arr[i+1]-arr[i]);
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var temp : int ;
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := 0 ; while j < n - i - 1 do ( (     if (arr[j+1] > arr[j + 1+1]) then (     temp := arr[j+1] ; 
     arr[j+1] := arr[j + 1+1] ; 
     arr[j + 1+1] := temp ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] /= arr[i + 1+1]) then (     count := count+(if arr[i + 1+1] - arr[i+1] < 0 then -(arr[i + 1+1] - arr[i+1]) else arr[i + 1+1] - arr[i+1] endif) ) else skip )  ;     i := i + 2 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigDecimal ;
import java.math.RoundingMode ;
import java.util.*;
public class ProblemC {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    String line[]=br.readLine().split(" ");
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=Integer.parseInt(line[i]);
    Arrays.sort(arr);
    int res=0 ;
    for(int i=0 ; i<n ; i+=2)res+=(arr[i+1]-arr[i]);
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemC {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := (line[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do (     res := res+((arr[i + 1+1] - arr[i+1])) ;  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] nums=new int[n];
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      nums[i]=sc.nextInt();
    }
    Arrays.sort(nums);
    for(int i=0 ; i<n-1 ; i+=2){
      ans+=nums[i+1]-nums[i];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    nums := nums->sort() ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     ans := ans+(nums[i + 1+1] - nums[i+1]) )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),i ;
    int a[]=new int[n];
    for(i=0 ; i<n ; i++)a[i]=sc.nextInt();
    Arrays.sort(a);
    int ans=0 ;
    for(i=0 ; i<n ; i+=2){
      int max=Math.max(a[i],a[i+1]);
      ans=ans+(max-a[i])+(max-a[i+1]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var i : int ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var ans : int ; ans := 0 ;
        i := 0 ; while i < n do ( (     var max : int ; max := Set{a[i+1], a[i + 1+1]}->max() ;
     ans := ans + (max - a[i+1]) + (max - a[i + 1+1]) )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class test313 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    Arrays.sort(a);
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(i % 2==1){
        while(a[i]>a[i-1]){
          sum++;
          a[i-1]++;
        }
      }
    }
    System.out.println(sum);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test313 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 1) then (     while (a[i+1] > a[i - 1+1]) do (     sum := sum + 1 ; 
     a[i - 1+1] := a[i - 1+1] + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Node {
    int data ;
    Node children[];
    Node(int n,int data){
      children=new Node[n];
      this.data=data ;
    }
  }
  static void inorder(Node node){
    if(node==null)return ;
    int total=node.children.length ;
    for(int i=0 ; i<total-1 ; i++)inorder(node.children[i]);
    System.out.print(""+node.data+" ");
    inorder(node.children[total-1]);
  }
  public static void main(String[] args){
    int n=3 ;
    Node root=new Node(n,1);
    root.children[0]=new Node(n,2);
    root.children[1]=new Node(n,3);
    root.children[2]=new Node(n,4);
    root.children[0] .children[0]=new Node(n,5);
    root.children[0] .children[1]=new Node(n,6);
    root.children[0] .children[2]=new Node(n,7);
    inorder(root);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute children : Sequence(Node);
   static operation newNode( n : int, data : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(n, data);
    return self );
  operation initialise( n : int, data : int) : void
  pre: true  post: true
  activity: (     children := Integer.subrange(1,n)->collect(null) ; 
     self.data := data );
}
  static   operation inorder( node : Node) : void
  pre: true
  post: true
  activity: (     if (node = null) then     return else skip ; 
     var total : int ; total := node.children->size() ;
        var i : int ; i := 0 ; while i < total - 1 do (     execute inorder(node.children[i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("" + node.data + " ") ; 
    execute inorder(node.children[total - 1+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var root : Node ; root := Node.newNode(n, 1) ;
    root.children[0+1] := Node.newNode(n, 2) ; 
    root.children[1+1] := Node.newNode(n, 3) ; 
    root.children[2+1] := Node.newNode(n, 4) ; 
    root.children[0+1].children[0+1] := Node.newNode(n, 5) ; 
    root.children[0+1].children[1+1] := Node.newNode(n, 6) ; 
    root.children[0+1].children[2+1] := Node.newNode(n, 7) ; 
    execute inorder(root) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.lang.Math ;
import java.util.Scanner ;
import java.io.*;
import java.util.*;
import java.util.StringTokenizer ;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args)throws Exception {
    FastReader sc=new FastReader();
    BufferedWriter ou=new BufferedWriter(new OutputStreamWriter(System.out));
    int t=sc.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=sc.nextInt();
      int[] ar=new int[n];
      for(int i=0 ; i<n ; i++){
        ar[i]=sc.nextInt();
      }
      if(ar[0]+ar[1]>ar[n-1]){
        ou.write(-1+"\n");
      }
      else {
        ou.write(1+" "+2+" "+n+"\n");
      }
    }
    ou.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var ou : OclFile ; ou := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var t : int ; t := sc.nextInt() ;
        var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := sc.nextInt() ;
     var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
     if (ar[0+1] + ar[1+1] > ar[n - 1+1]) then (     skip ) else (     skip ) )  ;     o := o + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p197 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p197().run());
  }
  private static long ITERATIONS=1000000000000L ;
  public String run(){
    double x=-1 ;
    double y=-1 ;
    long i=0 ;
    for(; i<ITERATIONS ; i++){
      if(i>0 && x==y)break ;
      x=f(x);
      y=f(f(y));
    }
    long remain=(ITERATIONS-i)% i ;
    for(; remain>0 ; remain--)x=f(x);
    double answer=x+f(x);
    answer=Math.floor(answer*1e9)/1e9 ;
    return String.format("%.9f",answer);
  }
  private static double f(double x){
    return Math.floor(Math.pow(2,30.403243784-x*x))/1e9 ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p197 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p197.newp197().run()) );
  static   attribute ITERATIONS : long := 1000000000000L;
   operation run() : String
  pre: true
  post: true
  activity: (     var x : double ; x := -1 ;
     var y : double ; y := -1 ;
    var i : long ; i := 0 ;
      while i < ITERATIONS do ( (     if (i > 0 & x = y) then     break else skip ; 
     x := f(x) ; 
     y := f(f(y)) )  ;     i := i + 1 ) ; 
    var remain : long ; remain := (ITERATIONS - i) mod i ;
      while remain > 0 do (     x := f(x) ;  ;     remain := remain - 1 ) ; 
    var answer : double ; answer := x + f(x) ;
    answer := (answer * 1e9)->floor() / 1e9 ; 
    return StringLib.format("%.9f",Sequence{answer}) 
 );
  static   operation f( x : double) : double
  pre: true
  post: true
  activity: (     return (2->pow(30.403243784 - x * x))->floor() / 1e9 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=2 ;
  static boolean isValid(int c[][],int n){
    int X[]={
      0,-1,0,1 };
      int Y[]={
        1,0,-1,0 };
        boolean isValid=true ;
        for(int i=0 ; i<n ; i++){
          for(int j=0 ; j<n ; j++){
            for(int k=0 ; k<4 ; k++){
              int newX=i+X[k];
              int newY=j+Y[k];
              if(newX<n && newY<n && newX>=0 && newY>=0 && c[newX][newY]==c[i][j]){
                isValid=false ;
              }
            }
          }
        }
        return isValid ;
      }
      public static void main(String[] args){
        int n=2 ;
        int[][] c={
          {
            1,0 },{
              0,1 }
            };
            if(isValid(c,n))System.out.println("Yes");
            else System.out.println("No");
          }
        }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 2;
  static   operation isValid( c : Sequence(Sequence(int)), n : int) : boolean
  pre: true
  post: true
  activity: (     var X : Sequence(int) ; X := Sequence{0,-1,0,1} ;
     var Y : Sequence(int) ; Y := Sequence{1,0,-1,0} ;
    var isValid : boolean ; isValid := true ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (         var k : int ; k := 0 ; while k < 4 do ( (     var newX : int ; newX := i + X[k+1] ;
     var newY : int ; newY := j + Y[k+1] ;
     if (newX < n & newY < n & newX >= 0 & newY >= 0 & c[newX+1][newY+1] = c[i+1][j+1]) then (     isValid := false ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return isValid 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     var c : Sequence(Sequence(int)) ; c := Sequence{Sequence{1,0},Sequence{0,1}} ;
     if (isValid(c, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String find_number(int N,int K){
    String r ;
    if(N % 100==0){
      N+=1 ;
      r=String.valueOf(N);
    }
    else {
      r=String.valueOf(N);
    }
    for(int i=1 ; i<=K ; i++)r+="00" ;
    return r ;
  }
  public static void main(String[] args){
    int N=1000,K=2 ;
    String ans=find_number(N,K);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation find_number( N : int, K : int) : String
  pre: true
  post: true
  activity: (     var r : String ;
     if (N mod 100 = 0) then (     N := N+(1) ; 
     r := ((N) + "") ) else (     r := ((N) + "") ) ;  
         var i : int ; i := 1 ; while i <= K do (     r := r+("00") ;  ;     i := i + 1 ) ; 
     return r );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 1000 ;
    var K : int ; K := 2 ;
     var ans : String ; ans := find_number(N, K) ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line=br.readLine();
    char[] c=line.toCharArray();
    int n=c.length-2 ;
    System.out.println(c[0]+""+n+""+c[c.length-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := br.readLine() ;
    var c : Sequence(String) ; c := line->characters() ;
    var n : int ; n := c->size() - 2 ;
    OclFile["System.out"].println(c[0+1] + "" + n + "" + c[c->size() - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=false ;
  private static PrintWriter _out=new PrintWriter(System.out);
  private static PrintWriter _err=new PrintWriter(System.err);
  private void solve(Scanner sc){
    String s=sc.nextLine();
    _out.println(new StringBuilder().append(s.charAt(0)).append(s.length()-2).append(s.charAt(s.length()-1)));
  }
  private static BigInteger C(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    for(long i=r ; i>1 ; --i){
      res=res.divide(BigInteger.valueOf(i));
    }
    return res ;
  }
  private static BigInteger P(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    return res ;
  }
  public static void main(String[] args){
    long S=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    new Main().solve(sc);
    _out.flush();
    long G=System.currentTimeMillis();
    if(elapsed){
      _err.println((G-S)+"ms");
    }
    _err.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := false;
  static   attribute _out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute _err : OclFile := OclFile.newOclFile_Write(OclFile["System.err"]);
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := sc.nextLine() ;
     skip );
  static   operation C( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
         var i : long ; i := r ; while i > 1 do ( (     res := res.divide((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation P( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    Main.newMain().solve(sc) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s=br.readLine();
    int x=s.length();
    String f=s.substring(0,1);
    String e=s.substring(x-1);
    System.out.println(f+(x-2)+e);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := br.readLine() ;
    var x : int ; x := s->size() ;
    var f : String ; f := s.subrange(0+1,1) ;
    var e : String ; e := s.subrange((x)->char2byte() - 1+1,(x)->char2byte() - 1) ;
    OclFile["System.out"].println(f + ((x)->char2byte() - 2) + e) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  @ SuppressWarnings("resource")public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    String s=scanner.next();
    System.out.println(s.charAt(0)+String.valueOf(s.length()-2)+s.charAt(s.length()-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scanner.getCurrent() ;
     OclFile["System.out"].println(s->at(0+1) + ((s->size() - 2) + "") + s->at(s->size() - 1+1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final String s=sc.next();
    sc.close();
    String ans=""+s.charAt(0)+(s.length()-2)+s.charAt(s.length()-1);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    skip ; 
    var ans : String ; ans := "" + s->at(0+1) + (s->size() - 2) + s->at(s->size() - 1+1) ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public List<String>subdomainVisits(String[] cpdomains){
    Map<String,Integer>map=new HashMap();
    for(String cpdomain : cpdomains){
      int i=cpdomain.indexOf(' ');
      int n=Integer.valueOf(cpdomain.substring(0,i));
      String domain=cpdomain.substring(i+1);
      for(i=0 ; i<domain.length(); ++i){
        if(domain.charAt(i)=='.'){
          String d=domain.substring(i+1);
          map.put(d,map.getOrDefault(d,0)+n);
        }
      }
      map.put(domain,map.getOrDefault(domain,0)+n);
    }
    List<String>res=new ArrayList();
    for(String domain : map.keySet())res.add(map.get(domain)+" "+domain);
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation subdomainVisits( cpdomains : Sequence(String)) : Sequence(String)
  pre: true
  post: true
  activity: (     var map : Map(String,int) ; map := Map{} ;
     for (cpdomain : cpdomains) do ( (     var i : int ; i := cpdomain->indexOf(' ')-1 ;
     var n : int ; n := (cpdomain.subrange(0+1,i))->toInteger() ;
    var domain : String ; domain := cpdomain.subrange(i + 1+1,i + 1) ;
        i := 0 ; while i < domain->size() do ( (     if (domain->at(i+1) = '.') then (     var d : String ; d := domain.subrange(i + 1+1,i + 1) ;
     map := map->union(Map{d |-> (if map->keys()->contains(d) then map->at(d) else 0 endif) + n}) ) else skip )  ;     i := i + 1 ) ; 
    map := map->union(Map{domain |-> (if map->keys()->contains(domain) then map->at(domain) else 0 endif) + n}) ; 
 )  ) ; 
    var res : Sequence(String) ; res := Sequence{} ;
    for (domain : map->keys()) do (     res := res->including(map->at(domain) + " " + domain) ;  ) ; 
    return res 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static final int MAX=50 ;
  static int solve(int dp[][],int a[],int low,int high,int turn){
    if(low==high){
      return a[low]*turn ;
    }
    if(dp[low][high]!=0){
      return dp[low][high];
    }
    dp[low][high]=Math.max(a[low]*turn+solve(dp,a,low+1,high,turn+1),a[high]*turn+solve(dp,a,low,high-1,turn+1));
    return dp[low][high];
  }
  public static void main(String args[]){
    int arr[]={
      1,3,1,5,2 };
      int n=arr.length ;
      int dp[][]=new int[MAX][MAX];
      System.out.println(solve(dp,arr,0,n-1,1));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 50;
  static   operation solve( dp : Sequence(Sequence(int)), a : Sequence(int), low : int, high : int, turn : int) : int
  pre: true
  post: true
  activity: (     if (low = high) then (     return a[low+1] * turn ) else skip ; 
     if (dp[low+1][high+1] /= 0) then (     return dp[low+1][high+1] ) else skip ; 
     dp[low+1][high+1] := Set{a[low+1] * turn + solve(dp, a, low + 1, high, turn + 1), a[high+1] * turn + solve(dp, a, low, high - 1, turn + 1)}->max() ; 
     return dp[low+1][high+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,1,5,2} ;
     var n : int ; n := arr->size() ;
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,MAX)->collect(Integer.subrange(1,MAX)->collect(0)) ;
     OclFile["System.out"].println(solve(dp, arr, 0, n - 1, 1)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.lang.Math ;
import java.util.Scanner ;
import java.io.*;
import java.util.*;
import java.util.StringTokenizer ;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args)throws Exception {
    FastReader sc=new FastReader();
    BufferedWriter ou=new BufferedWriter(new OutputStreamWriter(System.out));
    int t=sc.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=sc.nextInt();
      int[] ar=new int[n];
      for(int i=0 ; i<n ; i++){
        ar[i]=sc.nextInt();
      }
      if(ar[0]+ar[1]>ar[n-1]){
        ou.write(-1+"\n");
      }
      else {
        ou.write(1+" "+2+" "+n+"\n");
      }
    }
    ou.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var ou : OclFile ; ou := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var t : int ; t := sc.nextInt() ;
        var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := sc.nextInt() ;
     var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
     if (ar[0+1] + ar[1+1] > ar[n - 1+1]) then (     skip ) else (     skip ) )  ;     o := o + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int stepRequired(int n){
    return Integer.bitCount(n-1);
  }
  public static void main(String[] args){
    int n=94 ;
    System.out.println(stepRequired(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation stepRequired( n : int) : int
  pre: true
  post: true
  activity: (     return bitCount(n - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 94 ;
     OclFile["System.out"].println(stepRequired(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maxLen=10 ;
  static int dp[]=new int[maxLen];
  static boolean[] visit=new boolean[maxLen];
  static int maxSum(int arr[],int i,int n,int k){
    if(i>=n)return 0 ;
    if(visit[i])return dp[i];
    visit[i]=true ;
    int tot=0 ;
    dp[i]=maxSum(arr,i+1,n,k);
    for(int j=i ; j<(i+k)&&(j<n); j++){
      tot+=arr[j];
      dp[i]=Math.max(dp[i],tot+maxSum(arr,j+2,n,k));
    }
    return dp[i];
  }
  public static void main(String[] args){
    int arr[]={
-1,2,-3,4,5 };
      int k=2 ;
      int n=arr.length ;
      System.out.println(maxSum(arr,0,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute maxLen : int := 10;
  static   attribute dp : int := Integer.subrange(1,maxLen)->collect(0);
  static   attribute visit : Sequence(boolean) := Integer.subrange(1,maxLen)->collect(false);
  static   operation maxSum( arr : Sequence(int), i : int, n : int, k : int) : int
  pre: true
  post: true
  activity: (     if (i >= n) then     return 0 else skip ; 
     if (visit[i+1]) then     return dp[i+1] else skip ; 
    visit[i+1] := true ; 
    var tot : int ; tot := 0 ;
    dp[i+1] := maxSum(arr, i + 1, n, k) ; 
        var j : int ; j := i ; while j < (i + k) & (j < n) do ( (     tot := tot+(arr[j+1]) ; 
     dp[i+1] := Set{dp[i+1], tot + maxSum(arr, j + 2, n, k)}->max() )  ;     j := j + 1 ) ; 
    return dp[i+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-1,2,-3,4,5} ;
     var k : int ; k := 2 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxSum(arr, 0, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int maxPrefix(String s,String t){
    int count=0 ;
    for(int i=0 ; i<t.length(); i++){
      if(count==s.length())break ;
      if(t.charAt(i)==s.charAt(count))count++;
    }
    return count ;
  }
  public static void main(String args[]){
    String S="digger" ;
    String T="biggerdiagram" ;
    System.out.println(maxPrefix(S,T));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxPrefix( s : String, t : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < t->size() do ( (     if (count = s->size()) then     break else skip ; 
     if (t->at(i+1) = s->at(count+1)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := "digger" ;
     var T : String ; T := "biggerdiagram" ;
     OclFile["System.out"].println(maxPrefix(S, T)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getNumber(int n,int k){
    int[] arr=new int[n];
    int i=0 ;
    int odd=1 ;
    while(odd<=n){
      arr[i++]=odd ;
      odd+=2 ;
    }
    int even=2 ;
    while(even<=n){
      arr[i++]=even ;
      even+=2 ;
    }
    return arr[k-1];
  }
  public static void main(String[] args){
    int n=8,k=5 ;
    System.out.println(getNumber(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getNumber( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
     var i : int ; i := 0 ;
    var odd : int ; odd := 1 ;
    while (odd <= n) do (      arr[i+1] := odd  ; i := i + 1 ; 
     odd := odd+(2) ) ; 
    var even : int ; even := 2 ;
    while (even <= n) do (      arr[i+1] := even  ; i := i + 1 ; 
     even := even+(2) ) ; 
    return arr[k - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
    var k : int ; k := 5 ;
     OclFile["System.out"].println(getNumber(n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
public class BearAndDisplayedFriends {
  public static void main(String[] args){
    FastReader in=new FastReader();
    int n=in.nextInt();
    int k=in.nextInt();
    int q=in.nextInt();
    long a[]=new long[n+1];
    TreeSet<Long>treeSet=new TreeSet<>();
    for(int i=1 ; i<=n ; i++){
      a[i]=in.nextLong();
    }
    for(int i=1 ; i<=q ; i++){
      int c=in.nextInt();
      int id=in.nextInt();
      if(c==1){
        treeSet.add(a[id]);
        if(treeSet.size()>k)treeSet.pollFirst();
      }
      else {
        if(!(treeSet.contains(a[id])))System.out.println("NO");
        else System.out.println("YES");
      }
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BearAndDisplayedFriends {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var n : int ; n := in.nextInt() ;
    var k : int ; k := in.nextInt() ;
    var q : int ; q := in.nextInt() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var treeSet : Set(long) ; treeSet := Set{} ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := in.nextLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= q do ( (     var c : int ; c := in.nextInt() ;
     var id : int ; id := in.nextInt() ;
     if (c = 1) then (     treeSet := treeSet->including(a[id+1]) ; 
     if (treeSet->size() > k) then     treeSet := treeSet->tail() ; else skip ) else (     if (not((treeSet->includes(a[id+1])))) then     OclFile["System.out"].println("NO") ; else     OclFile["System.out"].println("YES") ; ) )  ;     i := i + 1 ) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.PriorityQueue ;
import java.util.Set ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
public class BearandDisplayedFriends {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int q=sc.nextInt();
    int arr[]=new int[n+1];
    for(int i=1 ; i<n+1 ; i++){
      arr[i]=sc.nextInt();
    }
    PriorityQueue<Integer>online=new PriorityQueue<Integer>();
    int cnt=0 ;
    while(q-->0){
      int t=sc.nextInt();
      int idx=sc.nextInt();
      if(t==2){
        out.println(online.contains(arr[idx])? "YES" : "NO");
      }
      else {
        online.add(arr[idx]);
        cnt+=1 ;
        if(cnt>k){
          online.poll();
          cnt-=1 ;
        }
      }
    }
    out.flush();
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BearandDisplayedFriends {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var online : Sequence(int) ; online := Sequence{} ;
    var cnt : int ; cnt := 0 ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var idx : int ; idx := sc.getCurrent()->toInteger() ;
     if (t = 2) then (     skip ) else (     online := online->including(arr[idx+1]) ; 
     cnt := cnt+(1) ; 
     if (cnt > k) then (     online := online->sort()->tail() ; 
     cnt := cnt-(1) ) else skip ) ) ;  ) ;  
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.PriorityQueue ;
import java.util.Set ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
public class BearandDisplayedFriends {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int q=sc.nextInt();
    int arr[]=new int[n+1];
    for(int i=1 ; i<n+1 ; i++){
      arr[i]=sc.nextInt();
    }
    PriorityQueue<Integer>online=new PriorityQueue<Integer>();
    while(q-->0){
      int t=sc.nextInt();
      int idx=sc.nextInt();
      if(t==2){
        out.println(online.contains(arr[idx])? "YES" : "NO");
      }
      else {
        online.add(arr[idx]);
        if(online.size()>k){
          online.poll();
        }
      }
    }
    out.flush();
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BearandDisplayedFriends {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var online : Sequence(int) ; online := Sequence{} ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var idx : int ; idx := sc.getCurrent()->toInteger() ;
     if (t = 2) then (     skip ) else (     online := online->including(arr[idx+1]) ; 
     if (online->size() > k) then (     online := online->sort()->tail() ) else skip ) ) ;  ) ;  
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.PriorityQueue ;
import java.util.Set ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
public class BearandDisplayedFriends {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int q=sc.nextInt();
    int arr[]=new int[n+1];
    for(int i=1 ; i<n+1 ; i++){
      arr[i]=sc.nextInt();
    }
    PriorityQueue<Integer>online=new PriorityQueue<Integer>();
    while(q-->0){
      int t=sc.nextInt();
      int idx=sc.nextInt();
      if(t==2){
        System.out.println(online.contains(arr[idx])? "YES" : "NO");
      }
      else {
        online.add(arr[idx]);
        if(online.size()>k){
          online.poll();
        }
      }
    }
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BearandDisplayedFriends {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var online : Sequence(int) ; online := Sequence{} ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var idx : int ; idx := sc.getCurrent()->toInteger() ;
     if (t = 2) then (     OclFile["System.out"].println(if online->includes(arr[idx+1]) then "YES" else "NO" endif) ) else (     online := online->including(arr[idx+1]) ; 
     if (online->size() > k) then (     online := online->sort()->tail() ) else skip ) ) ;  ) ;  
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.beans.PropertyEditorManager ;
import java.util.*;
public class code {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x=sc.nextInt();
    int t=sc.nextInt();
    PriorityQueue<Integer>pq=new PriorityQueue<>();
    ArrayList<Integer>arr=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      arr.add(sc.nextInt());
    }
    for(int i=0 ; i<t ; i++){
      int f=sc.nextInt();
      int s=sc.nextInt();
      if(f==1){
        pq.add(arr.get(s-1));
        if(pq.size()>x)pq.remove();
      }
      else {
        if(pq.contains(arr.get(s-1)))System.out.println("YES");
        else System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var pq : Sequence(int) ; pq := Sequence{} ;
    var arr : Sequence(int) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr := arr->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < t do ( (     var f : int ; f := sc.getCurrent()->toInteger() ;
     var s : int ; s := sc.getCurrent()->toInteger() ;
     if (f = 1) then (     pq := pq->including(arr->at(s - 1+1)) ; 
     if (pq->size() > x) then     pq := pq.remove() ; else skip ) else (     if (pq->includes(arr->at(s - 1+1))) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Again {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String q=sc.nextLine();
    String[] arr={
      "Danil","Olya","Slava","Ann","Nikita" };
      int tot=0 ;
      for(String s : arr){
        int co=0 ;
        co=count(s,q);
        if(tot>1)break ;
        tot+=co ;
      }
      System.out.println((tot==1)? "YES" : "NO");
    }
    public static int count(String w,String seq){
      int index=0,count=0 ;
      index=seq.indexOf(w,index);
      if(index<0){
        return count ;
      }
      else {
        count++;
        index+=w.length();
        while(index<seq.length()){
          index=seq.indexOf(w,index);
          if(index<0){
            return count ;
          }
          count++;
          index+=w.length();
          if(count>1)return count ;
        }
      }
      return count ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Again {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : String ; q := sc.nextLine() ;
    var arr : Sequence(String) ; arr := Sequence{"Danil","Olya","Slava","Ann","Nikita"} ;
    var tot : int ; tot := 0 ;
    for (s : arr) do ( (     var co : int ; co := 0 ;
     co := count(s, q) ; 
     if (tot > 1) then     break else skip ; 
     tot := tot+(co) )  ) ; 
    OclFile["System.out"].println(if (tot = 1) then "YES" else "NO" endif) ; 
 );
  static   operation count( w : String, seq : String) : int
  pre: true
  post: true
  activity: (     var index : int ; index := 0 ;
    var count : int ; count := 0 ;
     index := seq.subrange(index+1)->indexOf(w+"") + index - 1  ; 
     if (index < 0) then (     return count ) else (     count := count + 1 ; 
     index := index+(w->size()) ; 
     while (index < seq->size()) do (     index := seq.subrange(index+1)->indexOf(w+"") + index - 1  ; 
     if (index < 0) then (     return count ) else skip ; 
    count := count + 1 ; 
    index := index+(w->size()) ; 
    if (count > 1) then     return count else skip ; 
 ) ) ;  
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.lang.Math ;
import java.util.Scanner ;
import java.io.*;
import java.util.*;
import java.util.StringTokenizer ;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args)throws Exception {
    FastReader sc=new FastReader();
    BufferedWriter ou=new BufferedWriter(new OutputStreamWriter(System.out));
    int t=sc.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=sc.nextInt();
      int[] ar=new int[n];
      for(int i=0 ; i<n ; i++){
        ar[i]=sc.nextInt();
      }
      boolean no=true ;
      for(int i=0 ; i<n-2 ; i++){
        if(ar[i]+ar[i+1]<=ar[n-1-i]){
          ou.write((i+1)+" "+(i+2)+" "+(n-i)+"\n");
          no=false ;
          break ;
        }
      }
      if(no){
        ou.write("-1"+"\n");
      }
    }
    ou.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var ou : OclFile ; ou := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var t : int ; t := sc.nextInt() ;
        var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := sc.nextInt() ;
     var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    var no : boolean ; no := true ;
        var i : int ; i := 0 ; while i < n - 2 do ( (     if (ar[i+1] + ar[i + 1+1] <= ar[n - 1 - i+1]) then (     skip ; 
     no := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (no) then (     skip ) else skip ; 
 )  ;     o := o + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Cr576 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    int sum=get(s,"Danil")+get(s,"Olya")+get(s,"Slava")+get(s,"Ann")+get(s,"Nikita");
    if(sum==1)System.out.println("YES");
    else System.out.println("NO");
  }
  private static int get(String in,String var){
    int lastIndex=0 ;
    int count=0 ;
    while(lastIndex!=-1){
      lastIndex=in.indexOf(var,lastIndex);
      if(lastIndex!=-1){
        count++;
        lastIndex+=var.length();
      }
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cr576 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
     var sum : int ; sum := get(s, "Danil") + get(s, "Olya") + get(s, "Slava") + get(s, "Ann") + get(s, "Nikita") ;
     if (sum = 1) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
  static   operation get( in : String, var : String) : int
  pre: true
  post: true
  activity: (     var lastIndex : int ; lastIndex := 0 ;
     var count : int ; count := 0 ;
     while (lastIndex /= -1) do (     lastIndex := in.subrange(lastIndex+1)->indexOf(var+"") + lastIndex - 1  ; 
     if (lastIndex /= -1) then (     count := count + 1 ; 
     lastIndex := lastIndex+(var->size()) ) else skip ) ; 
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class Rextester {
  public static void main(String[] args)throws IOException {
    String[] names={
      "Danil","Olya","Ann","Nikita","Slava" };
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String s=br.readLine();
      br.close();
      int n=0 ;
      for(int i=0 ; i<=s.length()-3 ; i++){
        for(int j=0 ; j<names.length ; j++){
          if(names[j] .length()+i<=s.length()){
            if(names[j] .equals(s.substring(i,i+names[j] .length()))){
              n++;
            }
          }
        }
      }
      if(n==1){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Rextester {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var names : Sequence(String) ; names := Sequence{"Danil","Olya","Ann","Nikita","Slava"} ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var s : String ; s := br.readLine() ;
    skip ; 
    var n : int ; n := 0 ;
        var i : int ; i := 0 ; while i <= s->size() - 3 do ( (         var j : int ; j := 0 ; while j < names->size() do ( (     if (names[j+1]->size() + i <= s->size()) then (     if (names[j+1] = s.subrange(i+1,i + names[j+1]->size())) then (     n := n + 1 ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (n = 1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void nondecdigits(String s){
    int m=s.length();
    int[] a=new int[m+1];
    for(int i=0 ; i<m ; i++)a[i]=(int)s.charAt(i)-(int)'0' ;
    int level=m-1 ;
    for(int i=m-1 ; i>0 ; i--){
      if(a[i]<a[i-1]){
        a[i-1]--;
        level=i-1 ;
      }
    }
    if(a[0]!=0){
      for(int i=0 ; i<=level ; i++)System.out.print(a[i]);
      for(int i=level+1 ; i<m ; i++)System.out.print("9");
    }
    else {
      for(int i=1 ; i<level ; i++)System.out.print(a[i]);
      for(int i=level+1 ; i<m ; i++)System.out.print("9");
    }
  }
  public static void main(String[] args){
    String n="200" ;
    nondecdigits(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nondecdigits( s : String) : void
  pre: true
  post: true
  activity: (     var m : int ; m := s->size() ;
     var a : Sequence(int) ; a := Integer.subrange(1,m + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     a[i+1] := s->at(i+1)->oclAsType(int) - ('0')->char2byte() ;  ;     i := i + 1 ) ; 
    var level : int ; level := m - 1 ;
        var i : int ; i := m - 1 ; while i > 0 do ( (     if (a[i+1] < a[i - 1+1]) then (     a[i - 1+1] := a[i - 1+1] - 1 ; 
     level := i - 1 ) else skip )  ;     i := i - 1 ) ; 
    if (a[0+1] /= 0) then (         var i : int ; i := 0 ; while i <= level do (     OclFile["System.out"].print(a[i+1]) ;  ;     i := i + 1 ) ; 
         var i : int ; i := level + 1 ; while i < m do (     OclFile["System.out"].print("9") ;  ;     i := i + 1 ) ) else (         var i : int ; i := 1 ; while i < level do (     OclFile["System.out"].print(a[i+1]) ;  ;     i := i + 1 ) ; 
         var i : int ; i := level + 1 ; while i < m do (     OclFile["System.out"].print("9") ;  ;     i := i + 1 ) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : String ; n := "200" ;
     execute nondecdigits(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String[] arr=new String[8];
    for(int i=0 ; i<8 ; i++)arr[i]=sc.next();
    int bsum=0 ;
    int wsum=0 ;
    for(int i=0 ; i<8 ; i++){
      String temp=arr[i];
      for(int j=0 ; j<8 ; j++){
        if(Character.isUpperCase(temp.charAt(j))){
          if(temp.charAt(j)=='Q')wsum+=9 ;
          if(temp.charAt(j)=='R')wsum+=5 ;
          if(temp.charAt(j)=='B')wsum+=3 ;
          if(temp.charAt(j)=='N')wsum+=3 ;
          if(temp.charAt(j)=='P')wsum+=1 ;
        }
        else {
          if(temp.charAt(j)=='q')bsum+=9 ;
          if(temp.charAt(j)=='r')bsum+=5 ;
          if(temp.charAt(j)=='b')bsum+=3 ;
          if(temp.charAt(j)=='n')bsum+=3 ;
          if(temp.charAt(j)=='p')bsum+=1 ;
        }
      }
    }
    if(wsum>bsum)System.out.println("White");
    else if(bsum>wsum)System.out.println("Black");
    else System.out.println("Draw");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(String) ; arr := Integer.subrange(1,8)->collect(null) ;
        var i : int ; i := 0 ; while i < 8 do (     arr[i+1] := sc.getCurrent() ;  ;     i := i + 1 ) ; 
    var bsum : int ; bsum := 0 ;
    var wsum : int ; wsum := 0 ;
        var i : int ; i := 0 ; while i < 8 do ( (     var temp : String ; temp := arr[i+1] ;
         var j : int ; j := 0 ; while j < 8 do ( (     if ((temp->at(j+1)->toUpperCase() = temp->at(j+1))) then (     if (temp->at(j+1) = 'Q') then     wsum := wsum+(9) ; else skip ; 
     if (temp->at(j+1) = 'R') then     wsum := wsum+(5) ; else skip ; 
    if (temp->at(j+1) = 'B') then     wsum := wsum+(3) ; else skip ; 
    if (temp->at(j+1) = 'N') then     wsum := wsum+(3) ; else skip ; 
    if (temp->at(j+1) = 'P') then     wsum := wsum+(1) ; else skip ; 
 ) else (     if (temp->at(j+1) = 'q') then     bsum := bsum+(9) ; else skip ; 
     if (temp->at(j+1) = 'r') then     bsum := bsum+(5) ; else skip ; 
    if (temp->at(j+1) = 'b') then     bsum := bsum+(3) ; else skip ; 
    if (temp->at(j+1) = 'n') then     bsum := bsum+(3) ; else skip ; 
    if (temp->at(j+1) = 'p') then     bsum := bsum+(1) ; else skip ; 
 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (wsum > bsum) then     OclFile["System.out"].println("White") else     if (bsum > wsum) then     OclFile["System.out"].println("Black") else     OclFile["System.out"].println("Draw") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class c519A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    char[][] n=new char[8][8];
    for(int i=0 ; i<8 ; i++){
      String line=scan.next();
      for(int j=0 ; j<8 ; j++){
        n[i][j]=line.charAt(j);
      }
    }
    int a=0 ;
    int b=0 ;
    for(int i=0 ; i<8 ; i++){
      for(int j=0 ; j<8 ; j++){
        if(n[i][j]=='Q'){
          a+=9 ;
        }
        else if(n[i][j]=='q'){
          b+=9 ;
        }
        else if(n[i][j]=='R'){
          a+=5 ;
        }
        else if(n[i][j]=='r'){
          b+=5 ;
        }
        else if(n[i][j]=='B'){
          a+=3 ;
        }
        else if(n[i][j]=='b'){
          b+=3 ;
        }
        else if(n[i][j]=='N'){
          a+=3 ;
        }
        else if(n[i][j]=='n'){
          b+=3 ;
        }
        else if(n[i][j]=='P'){
          a+=1 ;
        }
        else if(n[i][j]=='p'){
          b+=1 ;
        }
      }
    }
    if(a>b){
      System.out.println("White");
    }
    else if(a==b){
      System.out.println("Draw");
    }
    else {
      System.out.println("Black");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class c519A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : Sequence(Sequence(String)) ; n := Integer.subrange(1,8)->collect(Integer.subrange(1,8)->collect(0)) ;
        var i : int ; i := 0 ; while i < 8 do ( (     var line : String ; line := scan.getCurrent() ;
         var j : int ; j := 0 ; while j < 8 do ( (     n[i+1][j+1] := line->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
        var i : int ; i := 0 ; while i < 8 do ( (         var j : int ; j := 0 ; while j < 8 do ( (     if (n[i+1][j+1] = 'Q') then (     a := a+(9) ) else     if (n[i+1][j+1] = 'q') then (     b := b+(9) ) else     if (n[i+1][j+1] = 'R') then (     a := a+(5) ) else     if (n[i+1][j+1] = 'r') then (     b := b+(5) ) else     if (n[i+1][j+1] = 'B') then (     a := a+(3) ) else     if (n[i+1][j+1] = 'b') then (     b := b+(3) ) else     if (n[i+1][j+1] = 'N') then (     a := a+(3) ) else     if (n[i+1][j+1] = 'n') then (     b := b+(3) ) else     if (n[i+1][j+1] = 'P') then (     a := a+(1) ) else     if (n[i+1][j+1] = 'p') then (     b := b+(1) ) else skip ; ;  ;  ;  ;  ;  ;  ;  ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (a > b) then (     OclFile["System.out"].println("White") ) else     if (a = b) then (     OclFile["System.out"].println("Draw") ) else (     OclFile["System.out"].println("Black") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Chess {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int w=0,b=0 ;
    for(int i=0 ; i<8 ; i++){
      String y=s.next();
      for(int j=0 ; j<8 ; j++){
        char x=y.charAt(j);
        if(x=='q')b+=9 ;
        else if(x=='r')b+=5 ;
        else if(x=='b' || x=='n')b+=3 ;
        else if(x=='p')b+=1 ;
        else if(x=='Q')w+=9 ;
        else if(x=='R')w+=5 ;
        else if(x=='B' || x=='N')w+=3 ;
        else if(x=='P')w+=1 ;
      }
    }
    if(w>b)System.out.println("White");
    else if(w<b)System.out.println("Black");
    else System.out.println("Draw");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Chess {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := 0 ;
    var b : int ; b := 0 ;
         var i : int ; i := 0 ; while i < 8 do ( (     var y : String ; y := s.getCurrent() ;
         var j : int ; j := 0 ; while j < 8 do ( (     var x : String ; x := y->at(j+1) ;
     if (x = 'q') then     b := b+(9) ; else     if (x = 'r') then     b := b+(5) else     if (x = 'b' or x = 'n') then     b := b+(3) else     if (x = 'p') then     b := b+(1) else     if (x = 'Q') then     w := w+(9) else     if (x = 'R') then     w := w+(5) else     if (x = 'B' or x = 'N') then     w := w+(3) else     if (x = 'P') then     w := w+(1) ; else skip ; ;  ;  ;  ;  ;  ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (w > b) then     OclFile["System.out"].println("White") ; else     if (w < b) then     OclFile["System.out"].println("Black") else     OclFile["System.out"].println("Draw") ; ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int numberOfDigits(int n){
    int cnt=0 ;
    while(n>0){
      cnt++;
      n/=10 ;
    }
    return cnt ;
  }
  static void cal(int num){
    int digits=numberOfDigits(num);
    int powTen=(int)Math.pow(10,digits-1);
    for(int i=0 ; i<digits-1 ; i++){
      int firstDigit=num/powTen ;
      int left=((num*10)+firstDigit)-(firstDigit*powTen*10);
      System.out.print(left+" ");
      num=left ;
    }
  }
  public static void main(String[] args){
    int num=1445 ;
    cal(num);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation numberOfDigits( n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     while (n > 0) do (     cnt := cnt + 1 ; 
     n := n/(10) ) ; 
     return cnt );
  static   operation cal( num : int) : void
  pre: true
  post: true
  activity: (     var digits : int ; digits := numberOfDigits(num) ;
     var powTen : int ; powTen := 10->pow(digits - 1)->oclAsType(int) ;
         var i : int ; i := 0 ; while i < digits - 1 do ( (     var firstDigit : int ; firstDigit := num / powTen ;
     var left : int ; left := ((num * 10) + firstDigit) - (firstDigit * powTen * 10) ;
     OclFile["System.out"].print(left + " ") ; 
     num := left )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 1445 ;
     execute cal(num) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void solve(String s){
    HashMap<Character,Integer>m=new HashMap<>();
    for(int i=0 ; i<s.length(); i++){
      if(m.containsKey(s.charAt(i)))m.put(s.charAt(i),m.get(s.charAt(i))+1);
      else m.put(s.charAt(i),1);
    }
    String new_string="" ;
    for(int i=0 ; i<s.length(); i++){
      if(m.get(s.charAt(i))% 2==0)continue ;
      new_string=new_string+s.charAt(i);
    }
    System.out.println(new_string);
  }
  public static void main(String[] args){
    String s="aabbbddeeecc" ;
    solve(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( s : String) : void
  pre: true
  post: true
  activity: (     var m : Map(String,int) ; m := Map{} ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (m->keys()->includes(s->at(i+1))) then     m := m->union(Map{s->at(i+1) |-> m->at(s->at(i+1)) + 1}) ; else     m := m->union(Map{s->at(i+1) |-> 1}) ; )  ;     i := i + 1 ) ; 
    var new_string : String ; new_string := "" ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (m->at(s->at(i+1)) mod 2 = 0) then     continue else skip ; 
     new_string := new_string + s->at(i+1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(new_string) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "aabbbddeeecc" ;
     execute solve(s) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long factorial(int n){
    if(n==0)return 1 ;
    if(n<0)return-1 ;
    long res=1 ;
    for(int i=2 ; i<n+1 ; ++i)res*=i ;
    return res ;
  }
  static int nCr(int n,int r){
    if(r>n)return-1 ;
    if(n==r)return 1 ;
    if(r==0)return 1 ;
    return nCr(n-1,r-1)+nCr(n-1,r);
  }
  static long stirlingNumber(int r,int n){
    if(n>r)return-1 ;
    if(n==0)return 0 ;
    if(r==n)return 1 ;
    if(n==1)return factorial(r-1);
    if(r-n==1)return nCr(r,2);
    else return stirlingNumber(r-1,n-1)+(r-1)*stirlingNumber(r-1,n);
  }
  public static void main(String[] args){
    int r=9,n=2 ;
    long val=stirlingNumber(r,n);
    if(val==-1)System.out.println(" No stirling number");
    else System.out.println("The Stirling Number s("+r+","+n+")is : "+val);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation factorial( n : int) : long
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     if (n < 0) then     return -1 else skip ; 
    var res : long ; res := 1 ;
        var i : int ; i := 2 ; while i < n + 1 do (     res := res*(i) ;  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation nCr( n : int, r : int) : int
  pre: true
  post: true
  activity: (     if (r > n) then     return -1 else skip ; 
     if (n = r) then     return 1 else skip ; 
     if (r = 0) then     return 1 else skip ; 
     return nCr(n - 1, r - 1) + nCr(n - 1, r) );
  static   operation stirlingNumber( r : int, n : int) : long
  pre: true
  post: true
  activity: (     if (n > r) then     return -1 else skip ; 
     if (n = 0) then     return 0 else skip ; 
    if (r = n) then     return 1 else skip ; 
    if (n = 1) then     return factorial(r - 1) else skip ; 
    if (r - n = 1) then     return nCr(r, 2) else     return stirlingNumber(r - 1, n - 1) + (r - 1) * stirlingNumber(r - 1, n) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : int ; r := 9 ;
    var n : int ; n := 2 ;
     var val : long ; val := stirlingNumber(r, n) ;
     if (val = -1) then     OclFile["System.out"].println(" No stirling number") ; else     OclFile["System.out"].println("The Stirling Number s(" + r + "," + n + ")is : " + val) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B991 {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    StringTokenizer st=new StringTokenizer(br.readLine());
    double[] arr=new double[n];
    double sum=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(st.nextToken());
      sum+=arr[i];
    }
    Arrays.sort(arr);
    int count=0,result=0 ;
    while(sum/n<4.5){
      double old=arr[count];
      arr[count]=5 ;
      sum+=5-old ;
      count++;
      result++;
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B991 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var arr : Sequence(double) ; arr := Integer.subrange(1,n)->collect(0.0) ;
    var sum : double ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (st.next())->toInteger() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var count : int ; count := 0 ;
    var result : int ; result := 0 ;
    while (sum / n < 4.5) do (     var old : double ; old := arr[count+1] ;
     arr[count+1] := 5 ; 
    sum := sum+(5 - old) ; 
    count := count + 1 ; 
    result := result + 1 ; 
 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  BufferedReader in ;
  PrintWriter out ;
  Main(){
    in=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(System.out);
  }
  void close()throws IOException {
    in.close();
    out.flush();
    out.close();
  }
  class Item implements Comparable<Item>{
    int v ;
    int i ;
    Item(int v,int i){
      this.v=v ;
      this.i=i ;
    }
    @ Override public int compareTo(Item o){
      return Integer.compare(v,o.v);
    }
  }
  void solve()throws IOException {
    int t=Integer.parseInt(in.readLine());
    while(t>0){
      int n=Integer.parseInt(in.readLine());
      Item[] is=new Item[n];
      StringTokenizer st=new StringTokenizer(in.readLine());
      for(int i=0 ; i<n ; i++){
        int v=Integer.parseInt(st.nextToken());
        is[i]=new Item(v,i);
      }
      Arrays.sort(is);
      if(is[0] .v+is[1] .v<=is[n-1] .v){
        int[] ids=new int[3];
        ids[0]=is[0] .i ;
        ids[1]=is[1] .i ;
        ids[2]=is[n-1] .i ;
        Arrays.sort(ids);
        out.append(String.format("%d %d %d\n",ids[0]+1,ids[1]+1,ids[2]+1));
      }
      else {
        out.append("-1\n");
      }
      t--;
    }
  }
  public static void main(String[] args)throws IOException {
    Main m=new Main();
    m.solve();
    m.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile;
   attribute out : OclFile;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) );
   operation close() : void
  pre: true
  post: true
  activity: (     skip ; 
     skip ; 
     skip );
 class Item implements Comparable<Item> {
   attribute v : int;
   attribute i : int;
   static operation newItem( v : int, i : int) : Item
  pre: true
  post: true
  activity:
  ( var self : Item ;
    self := createItem();
    self.initialise(v, i);
    return self );
  operation initialise( v : int, i : int) : void
  pre: true  post: true
  activity: (     self.v := v ; 
     self.i := i );
      operation compareTo( o : Item) : int
  pre: true
  post: true
  activity: (     return compare(v, o.v) );
}
   operation solve() : void
  pre: true
  post: true
  activity: (     var t : int ; t := (in.readLine())->toInteger() ;
     while (t > 0) do (     var n : int ; n := (in.readLine())->toInteger() ;
     var is : Sequence(Item) ; is := Integer.subrange(1,n)->collect(null) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(in.readLine()) ;
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := (st.next())->toInteger() ;
     is[i+1] := Item.newItem(v, i) )  ;     i := i + 1 ) ; 
    is := is->sort() ; 
    if (is[0+1].v + is[1+1].v <= is[n - 1+1].v) then (     var ids : Sequence(int) ; ids := Integer.subrange(1,3)->collect(0) ;
     ids[0+1] := is[0+1].i ; 
    ids[1+1] := is[1+1].i ; 
    ids[2+1] := is[n - 1+1].i ; 
    ids := ids->sort() ; 
    skip ; 
 ) else (     skip ) ;  
    t := t - 1 ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.solve() ; 
     m.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Getting991B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int arr[]=new int[n];
    float sum=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
      sum+=arr[i];
    }
    float grade=sum/n ;
    if(grade>=4.5){
      System.out.println('0');
      return ;
    }
    Arrays.sort(arr);
    for(int i=0 ; i<n ; i++){
      sum+=(5-arr[i]);
      grade=sum/n ;
      if(grade>=4.5){
        System.out.println(i+1);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Getting991B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : double ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    var grade : double ; grade := sum / n ;
    if (grade >= 4.5) then (     OclFile["System.out"].println('0') ; 
     return ) else skip ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+((5 - arr[i+1])) ; 
     grade := sum / n ; 
     if (grade >= 4.5) then (     OclFile["System.out"].println(i + 1) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class A {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int n=Integer.parseInt(bf.readLine());
    int[] arr=new int[n];
    String[] ars=bf.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(ars[i]);
    }
    double average=average(arr);
    if(average>=4.5){
      pw.println("0");
    }
    else {
      int sol=0 ;
      while(average(arr)<4.5){
        int x=min(arr);
        sol++;
        arr[x]=5 ;
      }
      pw.println(sol);
    }
    pw.close();
  }
  private static int min(int[] arr){
    int min=0 ;
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]<arr[min]){
        min=i ;
      }
    }
    return min ;
  }
  private static double average(int[] arr){
    double sum=0 ;
    double len=arr.length ;
    for(int i=0 ; i<len ; i++){
      sum+=arr[i];
    }
    return sum/len ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (bf.readLine())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var ars : Sequence(String) ; ars := bf.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (ars[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var average : double ; average := average(arr) ;
    if (average >= 4.5) then (     skip ) else (     var sol : int ; sol := 0 ;
     while (average(arr) < 4.5) do (     var x : int ; x := min(arr) ;
     sol := sol + 1 ; 
     arr[x+1] := 5 ) ; 
     skip ) ;  
    skip ; 
 );
  static   operation min( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var min : int ; min := 0 ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] < arr[min+1]) then (     min := i ) else skip )  ;     i := i + 1 ) ; 
     return min );
  static   operation average( arr : Sequence(int)) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
     var len : double ; len := arr->size() ;
         var i : int ; i := 0 ; while i < len do ( (     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
     return sum / len );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getFirstSetBitPos(int n){
    return(int)(Math.log(n &-n)/Math.log(2))+1 ;
  }
  static int previousSmallerInteger(int n){
    int pos=getFirstSetBitPos(n);
    return(n & ~(1<<(pos-1)));
  }
  public static void main(String[] args){
    int n=25 ;
    System.out.print("Previous smaller Integer="+previousSmallerInteger(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getFirstSetBitPos( n : int) : int
  pre: true
  post: true
  activity: (     return ((n & -n)->log() / (2)->log())->oclAsType(int) + 1 );
  static   operation previousSmallerInteger( n : int) : int
  pre: true
  post: true
  activity: (     var pos : int ; pos := getFirstSetBitPos(n) ;
     return (n & -(((1*(2->pow((pos - 1))))->oclAsType(long)) + 1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 25 ;
     OclFile["System.out"].print("Previous smaller Integer=" + previousSmallerInteger(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String maxNumber(String str,int n){
    int[] freq=new int[2];
    for(int i=0 ; i<n ; i++){
      if(str.charAt(i)=='z')freq[0]++;
      else if(str.charAt(i)=='n')freq[1]++;
    }
    String num="" ;
    for(int i=0 ; i<freq[1]; i++)num+='1' ;
    for(int i=0 ; i<freq[0]; i++)num+='0' ;
    return num ;
  }
  public static void main(String[] args){
    String str="roenenzooe" ;
    int n=str.length();
    System.out.println(maxNumber(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxNumber( str : String, n : int) : String
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,2)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     if (str->at(i+1) = 'z') then     freq[0+1] := freq[0+1] + 1 ; else     if (str->at(i+1) = 'n') then     freq[1+1] := freq[1+1] + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    var num : String ; num := "" ;
        var i : int ; i := 0 ; while i < freq[1+1] do (     num := num+('1') ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < freq[0+1] do (     num := num+('0') ;  ;     i := i + 1 ) ; 
    return num 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "roenenzooe" ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].println(maxNumber(str, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=100 ;
  static void printPrincipalDiagonal(int mat[][],int n){
    System.out.print("Principal Diagonal: ");
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(i==j){
          System.out.print(mat[i][j]+",");
        }
      }
    }
    System.out.println("");
  }
  static void printSecondaryDiagonal(int mat[][],int n){
    System.out.print("Secondary Diagonal: ");
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if((i+j)==(n-1)){
          System.out.print(mat[i][j]+",");
        }
      }
    }
    System.out.println("");
  }
  public static void main(String args[]){
    int n=4 ;
    int a[][]={
      {
        1,2,3,4 },{
          5,6,7,8 },{
            1,2,3,4 },{
              5,6,7,8 }
            };
            printPrincipalDiagonal(a,n);
            printSecondaryDiagonal(a,n);
          }
        }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100;
  static   operation printPrincipalDiagonal( mat : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("Principal Diagonal: ") ; 
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (i = j) then (     OclFile["System.out"].print(mat[i+1][j+1] + ",") ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("") );
  static   operation printSecondaryDiagonal( mat : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("Secondary Diagonal: ") ; 
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if ((i + j) = (n - 1)) then (     OclFile["System.out"].print(mat[i+1][j+1] + ",") ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var a : Sequence(Sequence(int)) ; a := Sequence{Sequence{1,2,3,4},Sequence{5,6,7,8},Sequence{1,2,3,4},Sequence{5,6,7,8}} ;
     execute printPrincipalDiagonal(a, n) ; 
     execute printSecondaryDiagonal(a, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAX=100 ;
  static void printPrincipalDiagonal(int mat[][],int n){
    System.out.print("Principal Diagonal: ");
    for(int i=0 ; i<n ; i++){
      System.out.print(mat[i][i]+",");
    }
    System.out.println();
  }
  static void printSecondaryDiagonal(int mat[][],int n){
    System.out.print("Secondary Diagonal: ");
    for(int i=0 ; i<n ; i++){
      System.out.print(mat[i][n-i-1]+",");
    }
    System.out.println();
  }
  public static void main(String[] args){
    int n=4 ;
    int a[][]={
      {
        1,2,3,4 },{
          5,6,7,8 },{
            1,2,3,4 },{
              5,6,7,8 }
            };
            printPrincipalDiagonal(a,n);
            printSecondaryDiagonal(a,n);
          }
        }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 100;
  static   operation printPrincipalDiagonal( mat : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("Principal Diagonal: ") ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(mat[i+1][i+1] + ",") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation printSecondaryDiagonal( mat : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("Secondary Diagonal: ") ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(mat[i+1][n - i - 1+1] + ",") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var a : Sequence(Sequence(int)) ; a := Sequence{Sequence{1,2,3,4},Sequence{5,6,7,8},Sequence{1,2,3,4},Sequence{5,6,7,8}} ;
     execute printPrincipalDiagonal(a, n) ; 
     execute printSecondaryDiagonal(a, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Codeforce19 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int x=0 ; x<t ; x++){
      long n=sc.nextLong();
      long m=sc.nextLong();
      if((n+m)% 2==0)System.out.println("Tonya");
      else System.out.println("Burenka");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforce19 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var x : int ; x := 0 ; while x < t do ( (     var n : long ; n := sc.getCurrent()->toLong() ;
     var m : long ; m := sc.getCurrent()->toLong() ;
     if ((n + m) mod 2 = 0) then     OclFile["System.out"].println("Tonya") ; else     OclFile["System.out"].println("Burenka") ; )  ;     x := x + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Solution {
  static PrintWriter pw ;
  static FastScanner s ;
  public static void main(String[] args)throws Exception {
    pw=new PrintWriter(System.out);
    s=new FastScanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      long n=s.nextLong();
      long m=s.nextLong();
      long sum=n+m ;
      if(sum % 2==0){
        pw.println("Tonya");
      }
      else pw.println("Burenka");
    }
    pw.flush();
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public FastScanner(String s)throws Exception {
    br=new BufferedReader(new FileReader(new File(s)));
  }
  public String next()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(next());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute pw : OclFile;
  static   attribute s : FastScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     pw := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     s := FastScanner.newFastScanner(OclFile["System.in"]) ; 
    var t : int ; t := s.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := s.nextLong() ;
     var m : long ; m := s.nextLong() ;
     var sum : long ; sum := n + m ;
     if (sum mod 2 = 0) then (     skip ) else     skip ; ) ;  ) ;  
    skip ; 
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
import java.math.BigInteger ;
public class ChipGame {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int testNumber=sc.nextInt();
    while(testNumber>0){
      BigInteger n=sc.nextBigInteger();
      BigInteger m=sc.nextBigInteger();
      BigInteger e=new BigInteger("2");
      BigInteger zero=new BigInteger("0");
      BigInteger comp=n.add(m).mod(e);
      if(comp.compareTo(zero)==0){
        System.out.println("Tonya");
      }
      else System.out.println("Burenka");
      testNumber--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ChipGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testNumber : int ; testNumber := sc.getCurrent()->toInteger() ;
     while (testNumber > 0) do (     var n : long ; n := sc.nextBigInteger() ;
     var m : long ; m := sc.nextBigInteger() ;
    var e : long ; e := long("2") ;
    var zero : long ; zero := long("0") ;
    var comp : long ; comp := n->excludes(m).mod(e) ;
    if (comp->compareTo(zero) = 0) then (     OclFile["System.out"].println("Tonya") ) else     OclFile["System.out"].println("Burenka") ; ;  
    testNumber := testNumber - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int tc=input.nextInt();
    work : while(tc-->0){
      long n=input.nextLong();
      long m=input.nextLong();
      if(n==1 && m==1){
        System.out.println("Tonya");
      }
      else if(n % 2==1 && m==1){
        System.out.println("Tonya");
      }
      else if(n==1 && m % 2!=0){
        System.out.println("Tonya");
      }
      else if(n % 2==0 && m % 2==0){
        System.out.println("Tonya");
      }
      else if(n % 2==1 && m % 2==1){
        System.out.println("Tonya");
      }
      else {
        System.out.println("Burenka");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := input.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : long ; n := input.getCurrent()->toLong() ;
     var m : long ; m := input.getCurrent()->toLong() ;
     if (n = 1 & m = 1) then (     OclFile["System.out"].println("Tonya") ) else     if (n mod 2 = 1 & m = 1) then (     OclFile["System.out"].println("Tonya") ) else     if (n = 1 & m mod 2 /= 0) then (     OclFile["System.out"].println("Tonya") ) else     if (n mod 2 = 0 & m mod 2 = 0) then (     OclFile["System.out"].println("Tonya") ) else     if (n mod 2 = 1 & m mod 2 = 1) then (     OclFile["System.out"].println("Tonya") ) else (     OclFile["System.out"].println("Burenka") ) ;  ;  ;  ;  ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test231 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      if(n>2){
        if(a[0]+a[1]<=a[n-1]){
          System.out.println("1 2 "+n);
        }
        else {
          System.out.println(-1);
        }
      }
      else {
        System.out.println(-1);
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test231 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     if (n > 2) then (     if (a[0+1] + a[1+1] <= a[n - 1+1]) then (     OclFile["System.out"].println("1 2 " + n) ) else (     OclFile["System.out"].println(-1) ) ) else (     OclFile["System.out"].println(-1) ) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if((n % 2==0 && m % 2==0)||(n % 2!=0 && m % 2!=0))System.out.println("Tonya");
      else System.out.println("Burenka");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     if ((n mod 2 = 0 & m mod 2 = 0) or (n mod 2 /= 0 & m mod 2 /= 0)) then     OclFile["System.out"].println("Tonya") ; else     OclFile["System.out"].println("Burenka") ; )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    int len=S.length();
    long ans=0 ;
    for(int i=0 ; i<len ; i++){
      long d=Long.parseLong(String.valueOf(S.charAt(i)));
      for(int j=0 ; j<=len-i-1 ; j++){
        if(j<len-i-1)ans+=(d*(long)Math.pow(10,j))*(long)Math.pow(2,i)*(long)Math.pow(2,len-i-2-j);
        if(j==len-i-1)ans+=(d*(long)Math.pow(10,j))*(long)Math.pow(2,i);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    var len : int ; len := S->size() ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < len do ( (     var d : long ; d := (((S->at(i+1)) + ""))->toLong() ;
         var j : int ; j := 0 ; while j <= (len)->char2byte() - i - 1 do ( (     if (j < (len)->char2byte() - i - 1) then     ans := ans+((d * 10->pow(j)->oclAsType(long)) * 2->pow(i)->oclAsType(long) * 2->pow((len)->char2byte() - i - 2 - j)->oclAsType(long)) ; else skip ; 
     if (j = (len)->char2byte() - i - 1) then     ans := ans+((d * 10->pow(j)->oclAsType(long)) * 2->pow(i)->oclAsType(long)) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  char[] data ;
  boolean[] flg ;
  long dfsres ;
  private void dfs(int ind,int start,int max){
    if(max==ind){
      long nowsum=0 ;
      long temp=0 ;
      for(int i=0 ; i<data.length ; i++){
        nowsum+=(long)(data[i]-'0');
        if(i==data.length-1)break ;
        if(! flg[i]){
          nowsum*=10 ;
        }
        else {
          temp+=nowsum ;
          nowsum=0 ;
        }
      }
      temp+=nowsum ;
      dfsres+=temp ;
      return ;
    }
    for(int i=start ; i<data.length-1 ; i++){
      if(flg[i])continue ;
      flg[i]=true ;
      dfs(ind+1,i+1,max);
      flg[i]=false ;
    }
    return ;
  }
  private void doit(){
    Scanner sc=new Scanner(System.in);
    long mod=1000000007 ;
    while(sc.hasNext()){
      data=sc.next().toCharArray();
      int len=data.length ;
      flg=new boolean[len];
      dfsres=0 ;
      for(int i=0 ; i<len ; i++){
        dfs(0,0,i);
      }
      System.out.println(dfsres);
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute data : Sequence(String);
   attribute flg : Sequence(boolean);
   attribute dfsres : long;
   operation dfs( ind : int, start : int, max : int) : void
  pre: true
  post: true
  activity: (     if (max = ind) then (     var nowsum : long ; nowsum := 0 ;
     var temp : long ; temp := 0 ;
        var i : int ; i := 0 ; while i < data->size() do ( (     nowsum := nowsum+((data[i+1] - ('0')->char2byte())->oclAsType(long)) ; 
     if (i = data->size() - 1) then     break else skip ; 
     if (not(flg[i+1])) then (     nowsum := nowsum*(10) ) else (     temp := temp+(nowsum) ; 
     nowsum := 0 ) )  ;     i := i + 1 ) ; 
    temp := temp+(nowsum) ; 
    dfsres := dfsres+(temp) ; 
    return 
 ) else skip ; 
         var i : int ; i := start ; while i < data->size() - 1 do ( (     if (flg[i+1]) then     continue else skip ; 
     flg[i+1] := true ; 
     execute dfs(ind + 1, i + 1, max) ; 
     flg[i+1] := false )  ;     i := i + 1 ) ; 
     return );
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var mod : long ; mod := 1000000007 ;
     while (sc.hasNext()) do (     data := sc.getCurrent()->characters() ; 
     var len : int ; len := data->size() ;
    flg := Integer.subrange(1,len)->collect(false) ; 
    dfsres := 0 ; 
        var i : int ; i := 0 ; while i < len do ( (     execute dfs(0, 0, i) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dfsres) ; 
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    ManyFormulas game=new ManyFormulas();
    game.run();
  }
}
class ManyFormulas {
  String S ;
  String[] nums ;
  ManyFormulas(){
    Scanner cin=new Scanner(System.in);
    this.S=cin.nextLine();
    this.nums=new String[S.length()];
    char[] tmp=S.toCharArray();
    for(int i=0 ; i<S.length(); i++){
      nums[i]=String.valueOf(tmp[i]);
    }
  }
  void run(){
    boolean[] contained=new boolean[nums.length];
    long allSum=dfs(0,contained);
    System.out.println(allSum);
  }
  long dfs(int depth,boolean[] contained){
    if(depth==nums.length-1){
      return calculateSum(contained);
    }
    return dfs(depth+1,copyArray(contained))+dfs(depth+1,setFlagAtIndex(contained,depth));
  }
  long calculateSum(boolean[] contained){
    long sum=0 ;
    long tmpNum=0 ;
    int digit=1 ;
    for(int i=contained.length-1 ; i>=0 ; i--){
      if(contained[i]){
        sum+=tmpNum ;
        digit=1 ;
        tmpNum=0 ;
      }
      tmpNum+=Long.valueOf(nums[i])*digit ;
      digit*=10 ;
    }
    sum+=tmpNum ;
    return sum ;
  }
  boolean[] setFlagAtIndex(boolean[] arr,int index){
    boolean[] newArr=copyArray(arr);
    newArr[index]=true ;
    return newArr ;
  }
  boolean[] copyArray(boolean[] arr){
    boolean[] newArr=new boolean[arr.length];
    for(int i=0 ; i<arr.length ; i++){
      newArr[i]=arr[i];
    }
    return newArr ;
  }
  void printArray(boolean[] arr){
    for(int i=0 ; i<arr.length ; i++){
      System.out.print(arr[i]+" ");
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var game : ManyFormulas ; game := ManyFormulas.newManyFormulas() ;
     game.run() );
}
class ManyFormulas {
   attribute S : String;
   attribute nums : Sequence(String);
   static operation newManyFormulas() : ManyFormulas
  pre: true
  post: true
  activity:
  ( var self : ManyFormulas ;
    self := createManyFormulas();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     self.S := cin.nextLine() ; 
    self.nums := Integer.subrange(1,S->size())->collect(null) ; 
    var tmp : Sequence(String) ; tmp := S->characters() ;
        var i : int ; i := 0 ; while i < S->size() do ( (     nums[i+1] := ((tmp[i+1]) + "") )  ;     i := i + 1 ) ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     var contained : Sequence(boolean) ; contained := Integer.subrange(1,nums->size())->collect(false) ;
     var allSum : long ; allSum := dfs(0, contained) ;
     OclFile["System.out"].println(allSum) );
   operation dfs( depth : int, contained : Sequence(boolean)) : long
  pre: true
  post: true
  activity: (     if (depth = nums->size() - 1) then (     return calculateSum(contained) ) else skip ; 
     return dfs(depth + 1, copyArray(contained)) + dfs(depth + 1, setFlagAtIndex(contained, depth)) );
   operation calculateSum( contained : Sequence(boolean)) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     var tmpNum : long ; tmpNum := 0 ;
    var digit : int ; digit := 1 ;
        var i : int ; i := contained->size() - 1 ; while i >= 0 do ( (     if (contained[i+1]) then (     sum := sum+(tmpNum) ; 
     digit := 1 ; 
     tmpNum := 0 ) else skip ; 
     tmpNum := tmpNum+((nums[i+1])->toLong() * digit) ; 
     digit := digit*(10) )  ;     i := i - 1 ) ; 
    sum := sum+(tmpNum) ; 
    return sum 
 );
   operation setFlagAtIndex( arr : Sequence(boolean), index : int) : Sequence(boolean)
  pre: true
  post: true
  activity: (     var newArr : Sequence(boolean) ; newArr := copyArray(arr) ;
     newArr[index+1] := true ; 
     return newArr );
   operation copyArray( arr : Sequence(boolean)) : Sequence(boolean)
  pre: true
  post: true
  activity: (     var newArr : Sequence(boolean) ; newArr := Integer.subrange(1,arr->size())->collect(false) ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     newArr[i+1] := arr[i+1] )  ;     i := i + 1 ) ; 
     return newArr );
   operation printArray( arr : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < arr->size() do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class bit {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x=0 ;
    String s ;
    for(int i=0 ; i<n ; i++){
      s=sc.next();
      if(s.charAt(1)=='+')x++;
      else x--;
    }
    System.out.println(x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class bit {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := 0 ;
    var s : String ;
        var i : int ; i := 0 ; while i < n do ( (     s := sc.getCurrent() ; 
     if (s->at(1+1) = '+') then     x := x + 1 ; else     x := x - 1 ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(x) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    long s=sc.nextLong();
    long[] a=new long[11];
    long[] b=new long[11];
    long ans=0 ;
    b[0]=1 ;
    int j=1 ;
    for(int i=0 ; i<10 ; i++){
      a[i]=s % 10 ;
      s/=10 ;
      if(i>0){
        b[i]=b[i-1]*10+j ;
        j*=2 ;
      }
    }
    ans=a[0];
    int k=1 ;
    while(a[k]!=0){
      ans=ans*2+a[k]*b[k];
      k++;
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var s : long ; s := sc.getCurrent()->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,11)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,11)->collect(0) ;
    var ans : long ; ans := 0 ;
    b[0+1] := 1 ; 
    var j : int ; j := 1 ;
        var i : int ; i := 0 ; while i < 10 do ( (     a[i+1] := s mod 10 ; 
     s := s/(10) ; 
     if (i > 0) then (     b[i+1] := b[i - 1+1] * 10 + j ; 
     j := j*(2) ) else skip )  ;     i := i + 1 ) ; 
    ans := a[0+1] ; 
    var k : int ; k := 1 ;
    while (a[k+1] /= 0) do (     ans := ans * 2 + a[k+1] * b[k+1] ; 
     k := k + 1 ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    long yy=compu(s,0,s.length()-1);
    System.out.println(yy);
  }
  public static long compu(String s,int i,int j){
    if(i>j || i>=s.length())return 0 ;
    if(i==j)return s.charAt(i)-'0' ;
    else {
      long sd=0 ;
      for(int x=i ; x<=j ; x++){
        if(j>x)sd=sd+((int)Math.pow(2,j-x-1))*(Long.parseLong(s.substring(i,x+1)))+compu(s,x+1,j);
        else sd+=Long.parseLong(s.substring(i,x+1));
      }
      return sd ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
     var yy : long ; yy := compu(s, 0, s->size() - 1) ;
     OclFile["System.out"].println(yy) );
  static   operation compu( s : String, i : int, j : int) : long
  pre: true
  post: true
  activity: (     if (i > j or i >= s->size()) then     return 0 else skip ; 
     if (i = j) then     return s->at(i+1) - ('0')->char2byte() else (     var sd : long ; sd := 0 ;
         var x : int ; x := i ; while x <= j do ( (     if (j > x) then     sd := sd + (2->pow(j - x - 1)->oclAsType(int)) * ((s.subrange(i+1,x + 1))->toLong()) + compu(s, x + 1, j) ; else     sd := sd+((s.subrange(i+1,x + 1))->toLong()) ; )  ;     x := x + 1 ) ; 
     return sd ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int minXOR(int arr[],int n){
    Arrays.parallelSort(arr);
    int minXor=Integer.MAX_VALUE ;
    int val=0 ;
    for(int i=0 ; i<n-1 ; i++){
      val=arr[i] ^ arr[i+1];
      minXor=Math.min(minXor,val);
    }
    return minXor ;
  }
  public static void main(String args[]){
    int arr[]={
      9,5,3 };
      int n=arr.length ;
      System.out.println(minXOR(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minXOR( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var minXor : int ; minXor := 2147483647 ;
    var val : int ; val := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     val := arr[i+1] xor arr[i + 1+1] ; 
     minXor := Set{minXor, val}->min() )  ;     i := i + 1 ) ; 
    return minXor 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{9,5,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minXOR(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Enhancement {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int rem=x % 4 ;
    if(rem==1)System.out.println(0+" A");
    else if(rem==2)System.out.println(1+" B");
    else if(rem==3)System.out.println(2+" A");
    else System.out.println(1+" A");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Enhancement {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     var rem : int ; rem := x mod 4 ;
     if (rem = 1) then     OclFile["System.out"].println(0 + " A") ; else     if (rem = 2) then     OclFile["System.out"].println(1 + " B") else     if (rem = 3) then     OclFile["System.out"].println(2 + " A") else     OclFile["System.out"].println(1 + " A") ; ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class div_2_573_a {
  public static void main(String args[]){
    FScanner in=new FScanner();
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt();
    if(n % 4==0)out.println("1 "+'A');
    else if(n % 4==1)out.println("0 "+'A');
    else if(n % 4==2)out.println("1 "+'B');
    else out.println("2 "+'A');
    out.close();
  }
  static class FScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer sb=new StringTokenizer("");
    String next(){
      while(! sb.hasMoreTokens()){
        try {
          sb=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
        }
      }
      return sb.nextToken();
    }
    String nextLine(){
      try {
        return br.readLine();
      }
      catch(IOException e){
      }
      return "" ;
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    int[] readArray(int n){
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    float nextFloat(){
      return Float.parseFloat(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class div{
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FScanner ; in := FScanner.newFScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.nextInt() ;
    if (n mod 4 = 0) then     skip else     if (n mod 4 = 1) then     skip else     if (n mod 4 = 2) then     skip else     skip ; ;  ;  ;  
    skip ; 
 );
  static class FScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute sb : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(sb.hasNext())) do (     try (     sb := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ) ; 
     return sb.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do skip
     return "" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}
_573_a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FScanner ; in := FScanner.newFScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.nextInt() ;
    if (n mod 4 = 0) then     skip else     if (n mod 4 = 1) then     skip else     if (n mod 4 = 2) then     skip else     skip ; ;  ;  ;  
    skip ; 
 );
  static class FScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute sb : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(sb.hasNext())) do (     try (     sb := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ) ; 
     return sb.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do skip
     return "" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void convert12(String str){
    int h1=(int)str.charAt(0)-'0' ;
    int h2=(int)str.charAt(1)-'0' ;
    int hh=h1*10+h2 ;
    String Meridien ;
    if(hh<12){
      Meridien="AM" ;
    }
    else Meridien="PM" ;
    hh %=12 ;
    if(hh==0){
      System.out.print("12");
      for(int i=2 ; i<8 ; ++i){
        System.out.print(str.charAt(i));
      }
    }
    else {
      System.out.print(hh);
      for(int i=2 ; i<8 ; ++i){
        System.out.print(str.charAt(i));
      }
    }
    System.out.println(" "+Meridien);
  }
  public static void main(String ar[]){
    String str="17:35:20" ;
    convert12(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation convert12( str : String) : void
  pre: true
  post: true
  activity: (     var h1 : int ; h1 := str->at(0+1)->oclAsType(int) - ('0')->char2byte() ;
     var h2 : int ; h2 := str->at(1+1)->oclAsType(int) - ('0')->char2byte() ;
    var hh : int ; hh := h1 * 10 + h2 ;
    var Meridien : String ;
    if (hh < 12) then (     Meridien := "AM" ) else     Meridien := "PM" ; ;  
    hh := hh mod 12 ; 
    if (hh = 0) then (     OclFile["System.out"].print("12") ; 
         var i : int ; i := 2 ; while i < 8 do ( (     OclFile["System.out"].print(str->at(i+1)) )  ;     i := i + 1 ) ) else (     OclFile["System.out"].print(hh) ; 
         var i : int ; i := 2 ; while i < 8 do ( (     OclFile["System.out"].print(str->at(i+1)) )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(" " + Meridien) ; 
 );
  static   operation main( ar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "17:35:20" ;
     execute convert12(str) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[])throws Exception {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    if(n % 4==1){
      System.out.println(0+" "+"A");
    }
    else if(n % 4==2){
      System.out.println(1+" "+"B");
    }
    else if(n % 4==3){
      System.out.println(2+" "+"A");
    }
    else {
      System.out.println(1+" "+"A");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n mod 4 = 1) then (     OclFile["System.out"].println(0 + " " + "A") ) else     if (n mod 4 = 2) then (     OclFile["System.out"].println(1 + " " + "B") ) else     if (n mod 4 = 3) then (     OclFile["System.out"].println(2 + " " + "A") ) else (     OclFile["System.out"].println(1 + " " + "A") ) ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int N ;
  public static void main(String[] args){
    N=sc.nextInt();
    double[] x=new double[3],y=new double[3];
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<3 ; j++){
        x[j]=sc.nextDouble();
        y[j]=sc.nextDouble();
      }
      double a=Math.hypot(x[0]-x[1],y[0]-y[1]),b=Math.hypot(x[1]-x[2],y[1]-y[2]),c=Math.hypot(x[2]-x[0],y[2]-y[0]),R=a*b*c/(Math.sqrt((a+b+c)*(-a+b+c)*(a-b+c)*(a+b-c))),aA=Math.acos((b*b+c*c-a*a)/(2.0*b*c)),aB=Math.acos((c*c+a*a-b*b)/(2.0*c*a)),aC=Math.acos((a*a+b*b-c*c)/(2.0*a*b)),A=Math.sin(2.0*aA),B=Math.sin(2.0*aB),C=Math.sin(2.0*aC),xp=((x[2]*A+x[0]*B+x[1]*C)/(A+B+C)),yp=((y[2]*A+y[0]*B+y[1]*C)/(A+B+C));
      System.out.printf("%.3f %.3f %.3f\n",xp,yp,R);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     var x : Sequence(double) ; x := Integer.subrange(1,3)->collect(0.0) ;
    var y : Sequence(double) ; y := Integer.subrange(1,3)->collect(0.0) ;
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < 3 do ( (     x[j+1] := sc.getCurrent()->toReal() ; 
     y[j+1] := sc.getCurrent()->toReal() )  ;     j := j + 1 ) ; 
     var a : double ; a := hypot(x[0+1] - x[1+1], y[0+1] - y[1+1]) ;
    var b : double ; b := hypot(x[1+1] - x[2+1], y[1+1] - y[2+1]) ;
    var c : double ; c := hypot(x[2+1] - x[0+1], y[2+1] - y[0+1]) ;
    var R : double ; R := a * b * c / (((a + b + c) * (-a + b + c) * (a - b + c) * (a + b - c))->sqrt()) ;
    var aA : double ; aA := ((b * b + c * c - a * a) / (2.0 * b * c))->acos() ;
    var aB : double ; aB := ((c * c + a * a - b * b) / (2.0 * c * a))->acos() ;
    var aC : double ; aC := ((a * a + b * b - c * c) / (2.0 * a * b))->acos() ;
    var A : double ; A := (2.0 * aA)->sin() ;
    var B : double ; B := (2.0 * aB)->sin() ;
    var C : double ; C := (2.0 * aC)->sin() ;
    var xp : double ; xp := ((x[2+1] * A + x[0+1] * B + x[1+1] * C) / (A + B + C)) ;
    var yp : double ; yp := ((y[2+1] * A + y[0+1] * B + y[1+1] * C) / (A + B + C)) ;
     OclFile["System.out"].printf("%.3f %.3f %.3f\n", xp, yp, R) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private Scanner sc ;
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    sc=new Scanner(System.in);
    int lim=Integer.parseInt(sc.next());
    for(int i=0 ; i<lim ; i++){
      double[] point=new double[6];
      for(int j=0 ; j<6 ; j++){
        point[j]=Double.parseDouble(sc.next());
      }
      double[] m=new double[4];
      m[0]=(point[0]+point[2])/2 ;
      m[1]=(point[1]+point[3])/2 ;
      m[2]=(point[2]+point[4])/2 ;
      m[3]=(point[3]+point[5])/2 ;
      double a=m[0]-point[0];
      double b=m[1]-point[1];
      double c=m[2]-point[2];
      double d=m[3]-point[3];
      double p=a*m[0]+b*m[1];
      double q=c*m[2]+d*m[3];
      double det=a*d-b*c ;
      double x=(p*d+q*(-b))/det ;
      double y=(p*(-c)+q*a)/det ;
      if(a==0.0)y=m[1];
      if(b==0.0)x=m[0];
      if(c==0.0)y=m[3];
      if(d==0.0)x=m[2];
      double r=Math.sqrt((x-point[0])*(x-point[0])+(y-point[1])*(y-point[1]));
      System.out.printf("%.3f %.3f %.3f\n",x,y,r);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var lim : int ; lim := (sc.getCurrent())->toInteger() ;
         var i : int ; i := 0 ; while i < lim do ( (     var point : Sequence(double) ; point := Integer.subrange(1,6)->collect(0.0) ;
         var j : int ; j := 0 ; while j < 6 do ( (     point[j+1] := (sc.getCurrent())->toReal() )  ;     j := j + 1 ) ; 
    var m : Sequence(double) ; m := Integer.subrange(1,4)->collect(0.0) ;
    m[0+1] := (point[0+1] + point[2+1]) / 2 ; 
    m[1+1] := (point[1+1] + point[3+1]) / 2 ; 
    m[2+1] := (point[2+1] + point[4+1]) / 2 ; 
    m[3+1] := (point[3+1] + point[5+1]) / 2 ; 
    var a : double ; a := m[0+1] - point[0+1] ;
    var b : double ; b := m[1+1] - point[1+1] ;
    var c : double ; c := m[2+1] - point[2+1] ;
    var d : double ; d := m[3+1] - point[3+1] ;
    var p : double ; p := a * m[0+1] + b * m[1+1] ;
    var q : double ; q := c * m[2+1] + d * m[3+1] ;
    var det : double ; det := a * d - b * c ;
    var x : double ; x := (p * d + q * (-b)) / det ;
    var y : double ; y := (p * (-c) + q * a) / det ;
    if (a = 0.0) then     y := m[1+1] ; else skip ; 
    if (b = 0.0) then     x := m[0+1] ; else skip ; 
    if (c = 0.0) then     y := m[3+1] ; else skip ; 
    if (d = 0.0) then     x := m[2+1] ; else skip ; 
    var r : double ; r := ((x - point[0+1]) * (x - point[0+1]) + (y - point[1+1]) * (y - point[1+1]))->sqrt() ;
    OclFile["System.out"].printf("%.3f %.3f %.3f\n", x, y, r) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n ;
    double x1,x2,x3,y1,y2,y3,px,py,r ;
    int i ;
    double ax,ay,bx,by,l1x,l1y,l2x,l2y ;
    n=sc.nextInt();
    for(i=0 ; i<n ; i++){
      x1=sc.nextDouble();
      y1=sc.nextDouble();
      x2=sc.nextDouble();
      y2=sc.nextDouble();
      x3=sc.nextDouble();
      y3=sc.nextDouble();
      ax=(x1+x2)/2.0 ;
      ay=(y1+y2)/2.0 ;
      bx=(x1+x3)/2.0 ;
      by=(y1+y3)/2.0 ;
      l1x=x1-x2 ;
      l1y=y1-y2 ;
      l2x=x1-x3 ;
      l2y=y1-y3 ;
      px=((ax*l1x+ay*l1y)*l2y+(bx*l2x+by*l2y)*(-l1y))/(l1x*l2y-l2x*l1y);
      py=((ax*l1x+ay*l1y)*(-l2x)+(bx*l2x+by*l2y)*l1x)/(l1x*l2y-l2x*l1y);
      r=Math.sqrt((px-x1)*(px-x1)+(py-y1)*(py-y1));
      System.out.printf("%.3f %.3f %.3f%n",px,py,r);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var x1 : double ;
    var x2 : double ;
    var x3 : double ;
    var y1 : double ;
    var y2 : double ;
    var y3 : double ;
    var px : double ;
    var py : double ;
    var r : double ;
    var i : int ;
    var ax : double ;
    var ay : double ;
    var bx : double ;
    var by : double ;
    var l1x : double ;
    var l1y : double ;
    var l2x : double ;
    var l2y : double ;
    n := sc.nextInt() ; 
        i := 0 ; while i < n do ( (     x1 := sc.nextDouble() ; 
     y1 := sc.nextDouble() ; 
    x2 := sc.nextDouble() ; 
    y2 := sc.nextDouble() ; 
    x3 := sc.nextDouble() ; 
    y3 := sc.nextDouble() ; 
    ax := (x1 + x2) / 2.0 ; 
    ay := (y1 + y2) / 2.0 ; 
    bx := (x1 + x3) / 2.0 ; 
    by := (y1 + y3) / 2.0 ; 
    l1x := x1 - x2 ; 
    l1y := y1 - y2 ; 
    l2x := x1 - x3 ; 
    l2y := y1 - y3 ; 
    px := ((ax * l1x + ay * l1y) * l2y + (bx * l2x + by * l2y) * (-l1y)) / (l1x * l2y - l2x * l1y) ; 
    py := ((ax * l1x + ay * l1y) * (-l2x) + (bx * l2x + by * l2y) * l1x) / (l1x * l2y - l2x * l1y) ; 
    r := ((px - x1) * (px - x1) + (py - y1) * (py - y1))->sqrt() ; 
    OclFile["System.out"].printf("%.3f %.3f %.3f%n", px, py, r) ; 
 )  ;     i := i + 1 ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.text.DecimalFormat ;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    for(int i=sc.nextInt(); i>0 ; i--){
      double x1=sc.nextFloat();
      double y1=sc.nextFloat();
      double x2=sc.nextFloat();
      double y2=sc.nextFloat();
      double x3=sc.nextFloat();
      double y3=sc.nextFloat();
      double la ;
      double lhx ;
      double lhy ;
      if(y1!=y2){
        la=-1.0*(x1-x2)/(y1-y2);
        lhx=(x1+x2)/2.0 ;
        lhy=(y1+y2)/2.0 ;
      }
      else {
        la=-1.0*(x3-x2)/(y3-y2);
        lhx=(x3+x2)/2.0 ;
        lhy=(y3+y2)/2.0 ;
      }
      double ma ;
      double mhx ;
      double mhy ;
      if(y1!=y3){
        ma=-1.0*(x1-x3)/(y1-y3);
        mhx=(x1+x3)/2.0 ;
        mhy=(y1+y3)/2.0 ;
      }
      else {
        ma=-1.0*(x3-x2)/(y3-y2);
        mhx=(x3+x2)/2.0 ;
        mhy=(y3+y2)/2.0 ;
      }
      double x=(lhy-mhy+ma*mhx-la*lhx)/(ma-la);
      double y=la*(x-lhx)+lhy ;
      DecimalFormat df=new DecimalFormat();
      df.applyLocalizedPattern("0.000");
      System.out.print(df.format(x)+" "+df.format(y)+" ");
      System.out.println(df.format(Math.sqrt((x-x1)*(x-x1)+(y-y1)*(y-y1))));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var i : int ; i := sc.getCurrent()->toInteger() ; while i > 0 do ( (     var x1 : double ; x1 := sc.nextFloat() ;
     var y1 : double ; y1 := sc.nextFloat() ;
    var x2 : double ; x2 := sc.nextFloat() ;
    var y2 : double ; y2 := sc.nextFloat() ;
    var x3 : double ; x3 := sc.nextFloat() ;
    var y3 : double ; y3 := sc.nextFloat() ;
    var la : double ;
    var lhx : double ;
    var lhy : double ;
    if (y1 /= y2) then (     la := -1.0 * (x1 - x2) / (y1 - y2) ; 
     lhx := (x1 + x2) / 2.0 ; 
     lhy := (y1 + y2) / 2.0 ) else (     la := -1.0 * (x3 - x2) / (y3 - y2) ; 
     lhx := (x3 + x2) / 2.0 ; 
     lhy := (y3 + y2) / 2.0 ) ;  
    var ma : double ;
    var mhx : double ;
    var mhy : double ;
    if (y1 /= y3) then (     ma := -1.0 * (x1 - x3) / (y1 - y3) ; 
     mhx := (x1 + x3) / 2.0 ; 
     mhy := (y1 + y3) / 2.0 ) else (     ma := -1.0 * (x3 - x2) / (y3 - y2) ; 
     mhx := (x3 + x2) / 2.0 ; 
     mhy := (y3 + y2) / 2.0 ) ;  
    var x : double ; x := (lhy - mhy + ma * mhx - la * lhx) / (ma - la) ;
    var y : double ; y := la * (x - lhx) + lhy ;
    var df : DecimalFormat ; df := DecimalFormat.newDecimalFormat() ;
    df.applyLocalizedPattern("0.000") ; 
    OclFile["System.out"].print(df.format(x) + " " + df.format(y) + " ") ; 
    OclFile["System.out"].println(df.format(((x - x1) * (x - x1) + (y - y1) * (y - y1))->sqrt())) ; 
 )  ;     i := i - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class p11 {
  public static int Bit(String e){
    int x=0 ;
    if(e.equals("X++")|| e.equals("++X")){
      x+=1 ;
    }
    else if(e.equals("X--")|| e.equals("--X")){
      x-=1 ;
    }
    return x ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int r=in.nextInt();
    int ans=0 ;
    for(int i=0 ; i<=r ; i++){
      String s=(String)in.nextLine();
      ans+=Bit(s);
    }
    System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p11 {
  static   operation Bit( e : String) : int
  pre: true
  post: true
  activity: (     var x : int ; x := 0 ;
     if (e = "X++" or e = "++X") then (     x := x+(1) ) else     if (e = "X--" or e = "--X") then (     x := x-(1) ) else skip ; ;  
     return x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := in.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i <= r do ( (     var s : String ; s := in.nextLine()->oclAsType(String) ;
     ans := ans+(Bit(s)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      int lineNum=Integer.parseInt(br.readLine());
      for(int i=0 ; i<lineNum ; i++){
        String line=br.readLine();
        String[] temp=line.split(" ");
        float x1=Float.parseFloat(temp[0]);
        float y1=Float.parseFloat(temp[1]);
        float x2=Float.parseFloat(temp[2]);
        float y2=Float.parseFloat(temp[3]);
        float x3=Float.parseFloat(temp[4]);
        float y3=Float.parseFloat(temp[5]);
        Circle circle=new Circle(x1,y1,x2,y2,x3,y3);
        System.out.printf("%.3f %.3f %.3f\n",circle.getCenterX(),circle.getCenterY(),circle.getRadius());
      }
    }
  }
  public static class Circle {
    private float centerX ;
    private float centerY ;
    private float radius ;
    public Circle(float x1,float y1,float x2,float y2,float x3,float y3){
      x2=x2-x1 ;
      y2=y2-y1 ;
      x3=x3-x1 ;
      y3=y3-y1 ;
      centerX=((x3*x3+y3*y3)*y2-(x2*x2+y2*y2)*y3)/(2.0f*(x3*y2-x2*y3));
      centerY=((x3*x3+y3*y3)*x2-(x2*x2+y2*y2)*x3)/(2.0f*(y3*x2-y2*x3));
      radius=(float)Math.sqrt(centerX*centerX+centerY*centerY);
      centerX+=x1 ;
      centerY+=y1 ;
    }
    public float getCenterX(){
      return centerX ;
    }
    public float getCenterY(){
      return centerY ;
    }
    public float getRadius(){
      return radius ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var lineNum : int ; lineNum := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < lineNum do ( (     var line : String ; line := br.readLine() ;
     var temp : Sequence(String) ; temp := line->split(" ") ;
    var x1 : double ; x1 := parseFloat(temp[0+1]) ;
    var y1 : double ; y1 := parseFloat(temp[1+1]) ;
    var x2 : double ; x2 := parseFloat(temp[2+1]) ;
    var y2 : double ; y2 := parseFloat(temp[3+1]) ;
    var x3 : double ; x3 := parseFloat(temp[4+1]) ;
    var y3 : double ; y3 := parseFloat(temp[5+1]) ;
    var circle : Circle ; circle := Circle.newCircle(x1, y1, x2, y2, x3, y3) ;
    OclFile["System.out"].printf("%.3f %.3f %.3f\n", circle.getCenterX(), circle.getCenterY(), circle.getRadius()) ; 
 )  ;     i := i + 1 ) ))  );
  static class Circle {
   attribute centerX : double;
   attribute centerY : double;
   attribute radius : double;
   static operation newCircle( x1 : double, y1 : double, x2 : double, y2 : double, x3 : double, y3 : double) : Circle
  pre: true
  post: true
  activity:
  ( var self : Circle ;
    self := createCircle();
    self.initialise(x1, y1,x2,y2,x3,y3);
    return self );
  operation initialise( x1 : double, y1 : double, x2 : double, y2 : double, x3 : double, y3 : double) : void
  pre: true  post: true
  activity: (     x2 := x2 - x1 ; 
     y2 := y2 - y1 ; 
    x3 := x3 - x1 ; 
    y3 := y3 - y1 ; 
    centerX := ((x3 * x3 + y3 * y3) * y2 - (x2 * x2 + y2 * y2) * y3) / (2.0f * (x3 * y2 - x2 * y3)) ; 
    centerY := ((x3 * x3 + y3 * y3) * x2 - (x2 * x2 + y2 * y2) * x3) / (2.0f * (y3 * x2 - y2 * x3)) ; 
    radius := (centerX * centerX + centerY * centerY)->sqrt()->oclAsType(double) ; 
    centerX := centerX+(x1) ; 
    centerY := centerY+(y1) ; 
 );
   operation getCenterX() : double
  pre: true
  post: true
  activity: (     return centerX );
   operation getCenterY() : double
  pre: true
  post: true
  activity: (     return centerY );
   operation getRadius() : double
  pre: true
  post: true
  activity: (     return radius );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    System.out.println(solve(s)? "YES" : "NO");
    sc.close();
  }
  static boolean solve(String s){
    return IntStream.range(0,s.length()).allMatch(i->isVowel(s.charAt(i))|| s.charAt(i)=='n' ||(i+1<s.length()&& isVowel(s.charAt(i+1))));
  }
  static boolean isVowel(char letter){
    return "aeiou".indexOf(letter)>=0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
     OclFile["System.out"].println(if solve(s) then "YES" else "NO" endif) ; 
     skip );
  static   operation solve( s : String) : boolean
  pre: true
  post: true
  activity: (     return Integer.subrange(0, s->size()-1)->forAll( _x2 | (lambda i : OclAny in isVowel(s->at(i+1)) or s->at(i+1) = 'n' or (i + 1 < s->size() & isVowel(s->at(i + 1+1))))->apply(_x2) ) );
  static   operation isVowel( letter : String) : boolean
  pre: true
  post: true
  activity: (     return "aeiou"->indexOf(letter)-1 >= 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Romaji {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String text=scanner.next();
    String litter="aouie" ;
    int res=0 ;
    if(text.length()!=1){
      for(int i=0 ; i<text.length(); i++){
        if(! litter.contains(text.charAt(i)+"")&& text.charAt(i)!='n'){
          if(text.lastIndexOf(text.charAt(i))==(text.length()-1)){
            if(! litter.contains(text.charAt(i)+"")){
              res++;
            }
          }
          else if(! litter.contains(text.charAt(i+1)+"")){
            res++;
          }
        }
      }
    }
    else {
      if(! litter.contains(text)&& ! text.equals("n")){
        res++;
      }
    }
    if(res==0){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Romaji {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var text : String ; text := scanner.getCurrent() ;
    var litter : String ; litter := "aouie" ;
    var res : int ; res := 0 ;
    if (text->size() /= 1) then (         var i : int ; i := 0 ; while i < text->size() do ( (     if (not(litter->includes(text->at(i+1) + "")) & text->at(i+1) /= 'n') then (     if (text->lastIndexOf(text->at(i+1))-1 = (text->size() - 1)) then (     if (not(litter->includes(text->at(i+1) + ""))) then (     res := res + 1 ) else skip ) else     if (not(litter->includes(text->at(i + 1+1) + ""))) then (     res := res + 1 ) else skip ; ) else skip )  ;     i := i + 1 ) ) else (     if (not(litter->includes(text)) & not(text = "n")) then (     res := res + 1 ) else skip ) ;  
    if (res = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s1=in.next();
    char[] a=s1.toCharArray();
    try {
      for(int i=0 ; i<a.length ; i++){
        if(a[i]=='i' || a[i]=='o' || a[i]=='u' || a[i]=='e' || a[i]=='a' || a[i]=='n'){
          continue ;
        }
        else {
          if(a[i+1]=='a' || a[i+1]=='e' || a[i+1]=='i' || a[i+1]=='o' || a[i+1]=='u'){
            continue ;
          }
          else {
            System.out.println("NO");
            return ;
          }
        }
      }
      System.out.println("YES");
    }
    catch(Exception e){
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := in.getCurrent() ;
     var a : Sequence(String) ; a := s1->characters() ;
     try (         var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] = 'i' or a[i+1] = 'o' or a[i+1] = 'u' or a[i+1] = 'e' or a[i+1] = 'a' or a[i+1] = 'n') then (     continue ) else (     if (a[i + 1+1] = 'a' or a[i + 1+1] = 'e' or a[i + 1+1] = 'i' or a[i + 1+1] = 'o' or a[i + 1+1] = 'u') then (     continue ) else (     OclFile["System.out"].println("NO") ; 
     return ) ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("YES") )   catch (e : ProgramException) do (     OclFile["System.out"].println("NO") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean check(String s,int k){
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)!=s.charAt(i % k)){
        return false ;
      }
    }
    return true ;
  }
  static int countCommonDivisors(String a,String b){
    int ct=0 ;
    int n=a.length(),m=b.length();
    for(int i=1 ; i<=Math.min(n,m); i++){
      if(n % i==0 && m % i==0){
        if(a.substring(0,i).equals(b.substring(0,i))){
          if(check(a,i)&& check(b,i)){
            ct++;
          }
        }
      }
    }
    return ct ;
  }
  public static void main(String[] args){
    String a="xaxa",b="xaxaxaxa" ;
    System.out.println(countCommonDivisors(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation check( s : String, k : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) /= s->at(i mod k+1)) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation countCommonDivisors( a : String, b : String) : int
  pre: true
  post: true
  activity: (     var ct : int ; ct := 0 ;
     var n : int ; n := a->size() ;
    var m : int ; m := b->size() ;
         var i : int ; i := 1 ; while i <= Set{n, m}->min() do ( (     if (n mod i = 0 & m mod i = 0) then (     if (a.subrange(0+1,i) = b.subrange(0+1,i)) then (     if (check(a, i) & check(b, i)) then (     ct := ct + 1 ) else skip ) else skip ) else skip )  ;     i := i + 1 ) ; 
     return ct );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ; a := "xaxa" ;
    var b : String ; b := "xaxaxaxa" ;
     OclFile["System.out"].println(countCommonDivisors(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s1=in.next();
    char[] a=s1.toCharArray();
    if(s1.length()==1){
      if(a[0]=='i' || a[0]=='o' || a[0]=='u' || a[0]=='e' || a[0]=='a' || a[0]=='n')System.out.println("YES");
      else System.out.println("NO");
      return ;
    }
    try {
      for(int i=0 ; i<a.length ; i++){
        if(a[i]=='i' || a[i]=='o' || a[i]=='u' || a[i]=='e' || a[i]=='a' || a[i]=='n'){
          continue ;
        }
        else {
          if(a[i+1]=='a' || a[i+1]=='e' || a[i+1]=='i' || a[i+1]=='o' || a[i+1]=='u'){
            continue ;
          }
          else {
            System.out.println("NO");
            return ;
          }
        }
      }
      System.out.println("YES");
    }
    catch(Exception e){
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := in.getCurrent() ;
    var a : Sequence(String) ; a := s1->characters() ;
    if (s1->size() = 1) then (     if (a[0+1] = 'i' or a[0+1] = 'o' or a[0+1] = 'u' or a[0+1] = 'e' or a[0+1] = 'a' or a[0+1] = 'n') then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
     return ) else skip ; 
    try (         var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] = 'i' or a[i+1] = 'o' or a[i+1] = 'u' or a[i+1] = 'e' or a[i+1] = 'a' or a[i+1] = 'n') then (     continue ) else (     if (a[i + 1+1] = 'a' or a[i + 1+1] = 'e' or a[i + 1+1] = 'i' or a[i + 1+1] = 'o' or a[i + 1+1] = 'u') then (     continue ) else (     OclFile["System.out"].println("NO") ; 
     return ) ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("YES") )   catch (e : ProgramException) do (     OclFile["System.out"].println("NO") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countPairs(int N){
    int count=0 ;
    for(int i=1 ; i<=(int)Math.sqrt(N); i++){
      int sq=i*i ;
      int diff=N-sq ;
      int sqrtDiff=(int)Math.sqrt(diff);
      if(sqrtDiff*sqrtDiff==diff)count++;
    }
    return count ;
  }
  public static void main(String[] args){
    for(int i=1 ; i<=10 ; i++)System.out.println("For n="+i+","+countPairs(i)+" pair exists\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPairs( N : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i <= (N)->sqrt()->oclAsType(int) do ( (     var sq : int ; sq := i * i ;
     var diff : int ; diff := N - sq ;
     var sqrtDiff : int ; sqrtDiff := (diff)->sqrt()->oclAsType(int) ;
     if (sqrtDiff * sqrtDiff = diff) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= 10 do (     OclFile["System.out"].println("For n=" + i + "," + countPairs(i) + " pair exists\n") ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPrime(int n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static int nextPrime(int N){
    if(N<=1)return 2 ;
    int prime=N ;
    boolean found=false ;
    while(! found){
      prime++;
      if(isPrime(prime))found=true ;
    }
    return prime ;
  }
  public static void main(String[] args){
    int N=3 ;
    System.out.println(nextPrime(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation nextPrime( N : int) : int
  pre: true
  post: true
  activity: (     if (N <= 1) then     return 2 else skip ; 
     var prime : int ; prime := N ;
    var found : boolean ; found := false ;
    while (not(found)) do (     prime := prime + 1 ; 
     if (isPrime(prime)) then     found := true ; else skip ) ; 
    return prime 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
     OclFile["System.out"].println(nextPrime(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    char[] keys=new char[26];
    int res=0 ;
    for(int i=0 ; i<s.length(); i+=1){
      keys[s.charAt(i)-'a']++;
      i+=1 ;
      if(keys[s.charAt(i)-'A']>0){
        keys[s.charAt(i)-'A']--;
      }
      else res++;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var keys : Sequence(String) ; keys := Integer.subrange(1,26)->collect(0) ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     keys[s->at(i+1) - ('a')->char2byte()+1] := keys[s->at(i+1) - ('a')->char2byte()+1] + 1 ; 
     i := i+(1) ; 
     if (keys[s->at(i+1) - ('A')->char2byte()+1] > 0) then (     keys[s->at(i+1) - ('A')->char2byte()+1] := keys[s->at(i+1) - ('A')->char2byte()+1] - 1 ) else     res := res + 1 ; )  ;     i := i+(1) ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforce3 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String str=sc.next();
    int count=0 ;
    HashMap<Character,Integer>h=new HashMap<Character,Integer>();
    for(int i=0 ; i<str.length(); i+=2){
      char ch=Character.toUpperCase(str.charAt(i));
      h.put(ch,h.getOrDefault(ch,0)+1);
      if(h.containsKey(str.charAt(i+1))){
        char a=str.charAt(i+1);
        h.put(a,h.get(a)-1);
        if(h.get(a)==0)h.remove(a);
      }
      else count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforce3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var str : String ; str := sc.getCurrent() ;
    var count : int ; count := 0 ;
    var h : Map(String,int) ; h := Map{} ;
        var i : int ; i := 0 ; while i < str->size() do ( (     var ch : String ; ch := (str->at(i+1) + "")->toUpperCase() ;
     h := h->union(Map{ch |-> (if h->keys()->contains(ch) then h->at(ch) else 0 endif) + 1}) ; 
     if (h->keys()->includes(str->at(i + 1+1))) then (     var a : String ; a := str->at(i + 1+1) ;
     h := h->union(Map{a |-> h->at(a) - 1}) ; 
     if (h->at(a) = 0) then     h := h->antirestrict(Set{a}) ; else skip ) else     count := count + 1 ; )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.PriorityQueue ;
import java.util.StringTokenizer ;
public class Airport {
  public static void main(String[] args)throws FileNotFoundException {
    FastReader in=new FastReader();
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    int n=in.nextInt();
    int m=in.nextInt();
    PriorityQueue<Integer>max=new PriorityQueue<>();
    PriorityQueue<Integer>min=new PriorityQueue<>(((o1,o2)->o2-o1));
    for(int i=0 ; i<m ; i++){
      int x=in.nextInt();
      max.add(x);
      min.add(x);
    }
    int resMax=0 ;
    int resMin=0 ;
    int x=0 ;
    while(0<n){
      x=max.poll();
      resMax+=x ;
      if(0<x-1)max.add(x-1);
      x=min.poll();
      resMin+=x ;
      if(0<x-1)min.add(x-1);
      n--;
    }
    out.println(resMin+" "+resMax);
    out.close();
  }
  private static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    FastReader()throws FileNotFoundException {
      br=new BufferedReader(new InputStreamReader(System.getProperty("ONLINE_JUDGE")==null ? new FileInputStream("input.txt"): 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Airport {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := in.nextInt() ;
    var m : int ; m := in.nextInt() ;
    var max : Sequence(int) ; max := Sequence{} ;
    var min : Sequence(int) ; min := Sequence{}->union((lambda (o1 , o2) : OclAny in o2 - o1)) ;
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := in.nextInt() ;
     max := max->including(x) ; 
     min := min->including(x) )  ;     i := i + 1 ) ; 
    var resMax : int ; resMax := 0 ;
    var resMin : int ; resMin := 0 ;
    var x : int ; x := 0 ;
    while (0 < n) do (     x := max->min() ;     max := max->sort()->tail() ; 
     resMax := resMax+(x) ; 
    if (0 < x - 1) then     max := max->including(x - 1) ; else skip ; 
    x := min->min() ;     min := min->sort()->tail() ; 
    resMin := resMin+(x) ; 
    if (0 < x - 1) then     min := min->including(x - 1) ; else skip ; 
    n := n - 1 ; 
 ) ; 
    skip ; 
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(if OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null then OclFile.newOclFile_Read(OclFile.newOclFile("input.txt")) else OclFile["System.in"] endif)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BitPlus {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int length=sc.nextInt();
    int sum=0 ;
    for(int i=0 ; i<length ; i++){
      String input=sc.next();
      if(input.equals("++X")|| input.equals("X++")){
        sum++;
      }
      else if(input.equals("--X")|| input.equals("X--")){
        sum--;
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class BitPlus {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var length : int ; length := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < length do ( (     var input : String ; input := sc.getCurrent() ;
     if (input = "++X" or input = "X++") then (     sum := sum + 1 ) else     if (input = "--X" or input = "X--") then (     sum := sum - 1 ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Code {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    int arr1[]=new int[m];
    int arr2[]=new int[m+1];
    for(int i=0 ; i<m ; i++){
      arr1[i]=scan.nextInt();
      arr2[i]=arr1[i];
    }
    int max=0 ;
    for(int i=0 ; i<n ; i++){
      Arrays.sort(arr1);
      max+=arr1[m-1];
      arr1[m-1]-=1 ;
    }
    int min=0 ;
    int j=0 ;
    for(int i=0 ; i<n ; i++){
      Arrays.sort(arr2);
      if(arr2[j]==0){
        j++;
      }
      min+=arr2[j];
      arr2[j]-=1 ;
    }
    System.out.println(max+" "+min);
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,m)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,m + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     arr1[i+1] := scan.getCurrent()->toInteger() ; 
     arr2[i+1] := arr1[i+1] )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr1 := arr1->sort() ; 
     max := max+(arr1[m - 1+1]) ; 
     arr1[m - 1+1] := arr1[m - 1+1]-(1) )  ;     i := i + 1 ) ; 
    var min : int ; min := 0 ;
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr2 := arr2->sort() ; 
     if (arr2[j+1] = 0) then (     j := j + 1 ) else skip ; 
     min := min+(arr2[j+1]) ; 
     arr2[j+1] := arr2[j+1]-(1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max + " " + min) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Collection ;
import java.util.Collections ;
import java.util.PriorityQueue ;
public class fiftynine {
  public static void main(String args[])throws Exception {
    BufferedReader inp=new BufferedReader(new InputStreamReader(System.in));
    int[] arr=Arrays.stream(inp.readLine().split("\\s+")).mapToInt(Integer :: parseInt).toArray();
    int n=arr[0],m=arr[1];
    int[] pass=Arrays.stream(inp.readLine().split("\\s+")).mapToInt(Integer :: parseInt).toArray();
    PriorityQueue<Integer>max=new PriorityQueue<>(Collections.reverseOrder());
    PriorityQueue<Integer>min=new PriorityQueue<>();
    int maxV=0,minV=0 ;
    for(int i : pass){
      max.add(i);
      min.add(i);
    }
    int k=0 ;
    while(k<n){
      int a=max.poll(),b=min.poll();
      maxV+=a ;
      minV+=b ;
      a-=1 ;
      b-=1 ;
      if(a>0){
        max.add(a);
      }
      if(b>0){
        min.add(b);
      }
      k++;
    }
    System.out.println(maxV+" "+minV);
  }
}
------------------------------------------------------------
OCL File:
---------
 class fiftynine {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inp : OclFile ; inp := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var arr : Sequence(int) ; arr := stream(inp.readLine()->split("\\s+"))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var n : int ; n := arr[0+1] ;
    var m : int ; m := arr[1+1] ;
    var pass : Sequence(int) ; pass := stream(inp.readLine()->split("\\s+"))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var max : Sequence(int) ; max := Sequence{}->union(reverseOrder()) ;
    var min : Sequence(int) ; min := Sequence{} ;
    var maxV : int ; maxV := 0 ;
    var minV : int ; minV := 0 ;
    for (i : pass) do ( (     max := max->including(i) ; 
     min := min->including(i) )  ) ; 
    var k : int ; k := 0 ;
    while (k < n) do (     var a : int ; a := max->min() ;
    var b : int ; b := min->min() ;
     maxV := maxV+(a) ; 
    minV := minV+(b) ; 
    a := a-(1) ; 
    b := b-(1) ; 
    if (a > 0) then (     max := max->including(a) ) else skip ; 
    if (b > 0) then (     min := min->including(b) ) else skip ; 
    k := k + 1 ; 
 ) ; 
    OclFile["System.out"].println(maxV + " " + minV) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Airport_218 {
  public static void main(String[] args)throws UnsupportedEncodingException,IOException {
    PriorityQueue<Integer>pq=new PriorityQueue<>();
    Reader.init(System.in);
    String[] firstLine=Reader.nextLine().trim().split("\\s+");
    int numOfPass=Integer.parseInt(firstLine[0]);
    int numOfPlanes=Integer.parseInt(firstLine[1]);
    PriorityQueue<Integer>pqR=new PriorityQueue<>(Collections.reverseOrder());
    for(int i=0 ; i<numOfPlanes ; i++){
      int input=Reader.nextInt();
      pq.add(input);
      pqR.add(input);
    }
    int max=0 ;
    int min=0 ;
    int inMax=0 ;
    int inMin=0 ;
    for(int i=0 ; i<numOfPass ; i++){
      inMax=pqR.poll();
      inMin=pq.poll();
      max+=inMax ;
      min+=inMin ;
--inMax ;
--inMin ;
      if(inMax!=0)pqR.add(inMax);
      if(inMin!=0)pq.add(inMin);
    }
    System.out.println(max+" "+min);
  }
}
class Reader {
  static StringTokenizer tokenizer ;
  static BufferedReader reader ;
  public static void init(InputStream input)throws UnsupportedEncodingException {
    reader=new BufferedReader(new InputStreamReader(input,"UTF-8"));
    tokenizer=new StringTokenizer("");
  }
  public static String next()throws IOException {
    while(! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  public static String nextLine()throws IOException {
    return reader.readLine();
  }
  public static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public static long nextLong()throws IOException {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Airport{
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var pq : Sequence(int) ; pq := Sequence{} ;
     Reader.init(OclFile["System.in"]) ; 
    var firstLine : Sequence(String) ; firstLine := Reader.nextLine()->trim()->split("\\s+") ;
    var numOfPass : int ; numOfPass := (firstLine[0+1])->toInteger() ;
    var numOfPlanes : int ; numOfPlanes := (firstLine[1+1])->toInteger() ;
    var pqR : Sequence(int) ; pqR := Sequence{}->union(reverseOrder()) ;
        var i : int ; i := 0 ; while i < numOfPlanes do ( (     var input : int ; input := Reader.nextInt() ;
     pq := pq->including(input) ; 
     pqR := pqR->including(input) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var min : int ; min := 0 ;
    var inMax : int ; inMax := 0 ;
    var inMin : int ; inMin := 0 ;
        var i : int ; i := 0 ; while i < numOfPass do ( (     inMax := pqR->min() ;     pqR := pqR->sort()->tail() ; 
     inMin := pq->min() ;     pq := pq->sort()->tail() ; 
    max := max+(inMax) ; 
    min := min+(inMin) ; 
    inMax := inMax - 1 ; 
    inMin := inMin - 1 ; 
    if (inMax /= 0) then     pqR := pqR->including(inMax) ; else skip ; 
    if (inMin /= 0) then     pq := pq->including(inMin) ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max + " " + min) ; 
 );
}
18 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var pq : Sequence(int) ; pq := Sequence{} ;
     Reader.init(OclFile["System.in"]) ; 
    var firstLine : Sequence(String) ; firstLine := Reader.nextLine()->trim()->split("\\s+") ;
    var numOfPass : int ; numOfPass := (firstLine[0+1])->toInteger() ;
    var numOfPlanes : int ; numOfPlanes := (firstLine[1+1])->toInteger() ;
    var pqR : Sequence(int) ; pqR := Sequence{}->union(reverseOrder()) ;
        var i : int ; i := 0 ; while i < numOfPlanes do ( (     var input : int ; input := Reader.nextInt() ;
     pq := pq->including(input) ; 
     pqR := pqR->including(input) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var min : int ; min := 0 ;
    var inMax : int ; inMax := 0 ;
    var inMin : int ; inMin := 0 ;
        var i : int ; i := 0 ; while i < numOfPass do ( (     inMax := pqR->min() ;     pqR := pqR->sort()->tail() ; 
     inMin := pq->min() ;     pq := pq->sort()->tail() ; 
    max := max+(inMax) ; 
    min := min+(inMin) ; 
    inMax := inMax - 1 ; 
    inMin := inMin - 1 ; 
    if (inMax /= 0) then     pqR := pqR->including(inMax) ; else skip ; 
    if (inMin /= 0) then     pq := pq->including(inMin) ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max + " " + min) ; 
 );
}
class Reader {
  static   attribute tokenizer : OclIterator;
  static   attribute reader : OclFile;
  static   operation init( input : OclFile) : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(input, "UTF-8")) ; 
     tokenizer := OclIterator.newOclIterator_String("") );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     return reader.readLine() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int max(int a,int b){
    return(a>b)? a : b ;
  }
  static void printknapSack(int W,int wt[],int val[],int n){
    int i,w ;
    int K[][]=new int[n+1][W+1];
    for(i=0 ; i<=n ; i++){
      for(w=0 ; w<=W ; w++){
        if(i==0 || w==0)K[i][w]=0 ;
        else if(wt[i-1]<=w)K[i][w]=Math.max(val[i-1]+K[i-1][w-wt[i-1] ],K[i-1][w]);
        else K[i][w]=K[i-1][w];
      }
    }
    int res=K[n][W];
    System.out.println(res);
    w=W ;
    for(i=n ; i>0 && res>0 ; i--){
      if(res==K[i-1][w])continue ;
      else {
        System.out.print(wt[i-1]+" ");
        res=res-val[i-1];
        w=w-wt[i-1];
      }
    }
  }
  public static void main(String arg[]){
    int val[]={
      60,100,120 };
      int wt[]={
        10,20,30 };
        int W=50 ;
        int n=val.length ;
        printknapSack(W,wt,val,n);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation max( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if (a > b) then a else b endif );
  static   operation printknapSack( W : int, wt : Sequence(int), val : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var w : int ;
     var K : Sequence(Sequence(int)) ; K := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,W + 1)->collect(0)) ;
        i := 0 ; while i <= n do ( (         w := 0 ; while w <= W do ( (     if (i = 0 or w = 0) then     K[i+1][w+1] := 0 ; else     if (wt[i - 1+1] <= w) then     K[i+1][w+1] := Set{val[i - 1+1] + K[i - 1+1][w - wt[i - 1+1]+1], K[i - 1+1][w+1]}->max() else     K[i+1][w+1] := K[i - 1+1][w+1] ; ;  )  ;     w := w + 1 ) )  ;     i := i + 1 ) ; 
    var res : int ; res := K[n+1][W+1] ;
    OclFile["System.out"].println(res) ; 
    w := W ; 
        i := n ; while i > 0 & res > 0 do ( (     if (res = K[i - 1+1][w+1]) then     continue else (     OclFile["System.out"].print(wt[i - 1+1] + " ") ; 
     res := res - val[i - 1+1] ; 
     w := w - wt[i - 1+1] ) )  ;     i := i - 1 ) ; 
 );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var val : Sequence(int) ; val := Sequence{60,100,120} ;
     var wt : Sequence(int) ; wt := Sequence{10,20,30} ;
    var W : int ; W := 50 ;
    var n : int ; n := val->size() ;
    execute printknapSack(W, wt, val, n) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Codekar {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] arr=new int[m];
    int[] b=new int[m];
    int maxtemp=arr[0],mintemp=arr[0],indexmx=0,indexmn=0 ;
    int max=0,min=0 ;
    for(int i=0 ; i<m ; i++){
      arr[i]=sc.nextInt();
    }
    for(int i=0 ; i<m ; i++){
      b[i]=arr[i];
    }
    for(int i=0 ; i<n ; i++){
      maxtemp=0 ;
      for(int j=0 ; j<m ; j++){
        if(arr[j]>maxtemp){
          maxtemp=arr[j];
          indexmx=j ;
        }
      }
      max+=maxtemp ;
      arr[indexmx]=arr[indexmx]-1 ;
    }
    for(int i=0 ; i<n ; i++){
      mintemp=1001 ;
      for(int j=0 ; j<m ; j++){
        if(b[j]<mintemp && b[j]!=0){
          mintemp=b[j];
          indexmn=j ;
        }
      }
      min+=mintemp ;
      b[indexmn]=b[indexmn]-1 ;
    }
    System.out.println(max+" "+min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codekar {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,m)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
    var maxtemp : int ; maxtemp := arr[0+1] ;
    var mintemp : int ; mintemp := arr[0+1] ;
    var indexmx : int ; indexmx := 0 ;
    var indexmn : int ; indexmn := 0 ;
    var max : int ; max := 0 ;
    var min : int ; min := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := arr[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     maxtemp := 0 ; 
         var j : int ; j := 0 ; while j < m do ( (     if (arr[j+1] > maxtemp) then (     maxtemp := arr[j+1] ; 
     indexmx := j ) else skip )  ;     j := j + 1 ) ; 
     max := max+(maxtemp) ; 
     arr[indexmx+1] := arr[indexmx+1] - 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     mintemp := 1001 ; 
         var j : int ; j := 0 ; while j < m do ( (     if (b[j+1] < mintemp & b[j+1] /= 0) then (     mintemp := b[j+1] ; 
     indexmn := j ) else skip )  ;     j := j + 1 ) ; 
     min := min+(mintemp) ; 
     b[indexmn+1] := b[indexmn+1] - 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max + " " + min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int N=4 ;
  static void diagonalBoundarySum(int arr[][]){
    int requiredSum=0 ;
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        if(i==j ||(i+j)==N-1){
          requiredSum+=arr[i][j];
        }
        else if(i==0 || j==0 || i==N-1 || j==N-1){
          requiredSum+=arr[i][j];
        }
      }
    }
    System.out.println(requiredSum);
  }
  public static void main(String args[]){
    int arr[][]={
      {
        1,2,3,4 },{
          1,2,3,4 },{
            1,2,3,4 },{
              1,2,3,4 }
            };
            diagonalBoundarySum(arr);
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 4;
  static   operation diagonalBoundarySum( arr : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var requiredSum : int ; requiredSum := 0 ;
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     if (i = j or (i + j) = N - 1) then (     requiredSum := requiredSum+(arr[i+1][j+1]) ) else     if (i = 0 or j = 0 or i = N - 1 or j = N - 1) then (     requiredSum := requiredSum+(arr[i+1][j+1]) ) else skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(requiredSum) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,2,3,4},Sequence{1,2,3,4},Sequence{1,2,3,4},Sequence{1,2,3,4}} ;
     execute diagonalBoundarySum(arr) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  Scanner sc ;
  int N ;
  long M ;
  int[] A ;
  long[] s ;
  private void calc(){
    sc=new Scanner(System.in);
    N=sc.nextInt();
    M=sc.nextLong();
    A=new int[N+1];
    for(int i=1 ; i<=N ; i++)A[i]=sc.nextInt();
    Arrays.sort(A,1,N+1);
    for(int i=0 ; i<N/2 ; i++){
      int tmp=A[i+1];
      A[i+1]=A[N-i];
      A[N-i]=tmp ;
    }
    s=new long[N+1];
    s[0]=A[0];
    for(int i=1 ; i<=N ; i++)s[i]=s[i-1]+A[i];
    System.out.println(binSearch());
  }
  private long[] ansOfSum(int sum){
    long ans=0 ;
    long cnt=0 ;
    int b=N ;
    for(int a=1 ; a<=N ; a++){
      while(A[a]+A[b]<sum && b>0)b--;
      if(b==0)break ;
      ans+=(long)b*A[a]+s[b];
      cnt+=b ;
    }
    return new long[] {
      ans,cnt };
    }
    private long binSearch(){
      int l=0 ;
      int r=200000 ;
      long[] mv=null ;
      while(l<=r){
        int m=(l+r)>>>1 ;
        mv=ansOfSum(m);
        if(mv[1]>M)l=m+1 ;
        else if(mv[1]<M)r=m-1 ;
        else {
          return mv[0];
        }
      }
      return mv[0]+(l-1)*(M-mv[1]);
    }
    public static void main(String[] args){
      new Main().calc();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute N : int;
   attribute M : long;
   attribute A : Sequence(int);
   attribute s : Sequence(long);
   operation calc() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     N := sc.getCurrent()->toInteger() ; 
    M := sc.getCurrent()->toLong() ; 
    A := Integer.subrange(1,N + 1)->collect(0) ; 
        var i : int ; i := 1 ; while i <= N do (     A[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    A := A.subrange(1,1)^(A.subrange(1+1,N + 1)->sort())^A.subrange(N + 1+1,A.size) ; 
        var i : int ; i := 0 ; while i < N / 2 do ( (     var tmp : int ; tmp := A[i + 1+1] ;
     A[i + 1+1] := A[N - i+1] ; 
     A[N - i+1] := tmp )  ;     i := i + 1 ) ; 
    s := Integer.subrange(1,N + 1)->collect(0) ; 
    s[0+1] := A[0+1] ; 
        var i : int ; i := 1 ; while i <= N do (     s[i+1] := s[i - 1+1] + A[i+1] ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(binSearch()) ; 
 );
   operation ansOfSum( sum : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
     var cnt : long ; cnt := 0 ;
    var b : int ; b := N ;
        var a : int ; a := 1 ; while a <= N do ( (     while (A[a+1] + A[b+1] < sum & b > 0) do     b := b - 1 ; ; 
     if (b = 0) then     break else skip ; 
     ans := ans+(b->oclAsType(long) * A[a+1] + s[b+1]) ; 
     cnt := cnt+(b) )  ;     a := a + 1 ) ; 
    return Sequence{ans,cnt} 
 );
   operation binSearch() : long
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
     var r : int ; r := 200000 ;
    var mv : Sequence(long) ; mv := null ;
    while (l <= r) do (     var m : int ; m := ((l + r)/(2->pow(1)))->oclAsType(long) ;
     mv := ansOfSum(m) ; 
     if (mv[1+1] > M) then     l := m + 1 ; else     if (mv[1+1] < M) then     r := m - 1 else (     return mv[0+1] ) ;  ) ; 
    return mv[0+1] + (l - 1) * (M - mv[1+1]) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().calc() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public Main(){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    long M=scanner.nextLong();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=scanner.nextInt();
    }
    Arrays.sort(A);
    int L=-1,R=A[N-1]*2 ;
    while(R-L>1){
      int mid=L+(R-L)/2 ;
      long num=0 ;
      for(int i=0 ; i<N ; i++){
        num+=N-binarySearch(A,mid-A[i]);
      }
      if(num<M)R=mid ;
      else L=mid ;
    }
    long[] S=new long[N+1];
    for(int i=0 ; i<N ; i++)S[i+1]=S[i]+A[i];
    long count=0,result=0 ;
    for(int i=0 ; i<N ; i++){
      int num=binarySearch(A,R-A[i]);
      count+=N-num ;
      result+=((long)A[i])*((long)(N-num))+S[N]-S[num];
    }
    if(M-count>0)result+=L*(M-count);
    else if(M-count<0)result-=R*(count-M);
    System.out.println(result);
  }
  int binarySearch(int[] A,int key){
    int L=-1,R=A.length ;
    while(R-L>1){
      int mid=L+(R-L)/2 ;
      if(A[mid]>=key)R=mid ;
      else L=mid ;
    }
    return R ;
  }
  public static void main(String args[])throws Exception {
    Main main=new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var M : long ; M := scanner.getCurrent()->toLong() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    var L : int ; L := -1 ;
    var R : int ; R := A[N - 1+1] * 2 ;
    while (R - L > 1) do (     var mid : int ; mid := L + (R - L) / 2 ;
     var num : long ; num := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     num := num+(N - binarySearch(A, mid - A[i+1])) )  ;     i := i + 1 ) ; 
     if (num < M) then     R := mid ; else     L := mid ; ) ; 
    var S : Sequence(long) ; S := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     S[i + 1+1] := S[i+1] + A[i+1] ;  ;     i := i + 1 ) ; 
    var count : long ; count := 0 ;
    var result : long ; result := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var num : int ; num := binarySearch(A, R - A[i+1]) ;
     count := count+(N - num) ; 
     result := result+((A[i+1]->oclAsType(long)) * ((N - num)->oclAsType(long)) + S[N+1] - S[num+1]) )  ;     i := i + 1 ) ; 
    if (M - count > 0) then     result := result+(L * (M - count)) else     if (M - count < 0) then     result := result-(R * (count - M)) ; else skip ; ;  
    OclFile["System.out"].println(result) ; 
 );
   operation binarySearch( A : Sequence(int), key : int) : int
  pre: true
  post: true
  activity: (     var L : int ; L := -1 ;
    var R : int ; R := A->size() ;
     while (R - L > 1) do (     var mid : int ; mid := L + (R - L) / 2 ;
     if (A[mid+1] >= key) then     R := mid ; else     L := mid ; ) ; 
     return R );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isToOneRec(int n,HashSet<Integer>s){
    if(n==1){
      return true ;
    }
    if(s.contains(n)){
      return false ;
    }
    return(n % 2==1)? isToOneRec(3*n+1,s): isToOneRec(n/2,s);
  }
  static boolean isToOne(int n){
    HashSet<Integer>s=new HashSet<Integer>();
    return isToOneRec(n,s);
  }
  public static void main(String[] args){
    int n=5 ;
    if(isToOne(n)){
      System.out.print("Yes");
    }
    else {
      System.out.print("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isToOneRec( n : int, s : Set(int)) : boolean
  pre: true
  post: true
  activity: (     if (n = 1) then (     return true ) else skip ; 
     if (s->includes(n)) then (     return false ) else skip ; 
     return if (n mod 2 = 1) then isToOneRec(3 * n + 1, s) else isToOneRec(n / 2, s) endif );
  static   operation isToOne( n : int) : boolean
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
     return isToOneRec(n, s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     if (isToOne(n)) then (     OclFile["System.out"].print("Yes") ) else (     OclFile["System.out"].print("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        int a=sc.nextInt();
        int b=sc.nextInt();
        int c=sc.nextInt();
        int sum=0 ;
        while(b>=1 && c>=2){
          sum+=3 ;
          b-=1 ;
          c-=2 ;
        }
        while(a>=1 && b>=2){
          sum+=3 ;
          a-=1 ;
          b-=2 ;
        }
        System.out.println(sum);
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    while (b >= 1 & c >= 2) do (     sum := sum+(3) ; 
     b := b-(1) ; 
     c := c-(2) ) ; 
    while (a >= 1 & b >= 2) do (     sum := sum+(3) ; 
     a := a-(1) ; 
     b := b-(2) ) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int a=sc.nextInt(),b=sc.nextInt(),c=sc.nextInt();
      int moves=Math.min(c/2,b);
      b-=moves ;
      moves+=Math.min(b/2,a);
      out.println(moves*3);
    }
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
     var moves : int ; moves := Set{c / 2, b}->min() ;
    b := b-(moves) ; 
    moves := moves+(Set{b / 2, a}->min()) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int X,n ;
    X=0 ;
    n=scan.nextInt();
    for(int i=0 ; i<=n ; i++){
      String s=scan.nextLine();
      if(s.equals("++X")|| s.equals("X++")){
        X++;
      }
      else if(s.equals("--X")|| s.equals("X--"))X--;
    }
    System.out.println(X);
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : int ;
    var n : int ;
    X := 0 ; 
    n := scan.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i <= n do ( (     var s : String ; s := scan.nextLine() ;
     if (s = "++X" or s = "X++") then (     X := X + 1 ) else     if (s = "--X" or s = "X--") then     X := X - 1 ; else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(X) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int factorial(int n){
    int fact=1 ;
    for(int i=2 ; i<=n ; i++)fact=fact*i ;
    return fact ;
  }
  static int ncr(int n,int r){
    return factorial(n)/(factorial(r)*factorial(n-r));
  }
  public static void main(String[] args){
    int m=3,n=4,k=5 ;
    int totalTriangles=ncr(m+n+k,3)-ncr(m,3)-ncr(n,3)-ncr(k,3);
    System.out.println(totalTriangles);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation factorial( n : int) : int
  pre: true
  post: true
  activity: (     var fact : int ; fact := 1 ;
         var i : int ; i := 2 ; while i <= n do (     fact := fact * i ;  ;     i := i + 1 ) ; 
     return fact );
  static   operation ncr( n : int, r : int) : int
  pre: true
  post: true
  activity: (     return factorial(n) / (factorial(r) * factorial(n - r)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 3 ;
    var n : int ; n := 4 ;
    var k : int ; k := 5 ;
     var totalTriangles : int ; totalTriangles := ncr(m + n + k, 3) - ncr(m, 3) - ncr(n, 3) - ncr(k, 3) ;
     OclFile["System.out"].println(totalTriangles) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void canMake(int n,int ar[]){
    int sum=0,maxx=-1 ;
    for(int i=0 ; i<n ; i++){
      sum+=ar[i];
      maxx=Math.max(maxx,ar[i]);
    }
    if(n==1 || sum % 2==1 || sum-maxx<maxx){
      System.out.print("No\n");
    }
    else {
      System.out.print("Yes\n");
    }
  }
  public static void main(String[] args){
    int n=6 ;
    int arr[]={
      1,1,2,3,6,11 };
      canMake(n,arr);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation canMake( n : int, ar : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
    var maxx : int ; maxx := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(ar[i+1]) ; 
     maxx := Set{maxx, ar[i+1]}->max() )  ;     i := i + 1 ) ; 
     if (n = 1 or sum mod 2 = 1 or sum - maxx < maxx) then (     OclFile["System.out"].print("No\n") ) else (     OclFile["System.out"].print("Yes\n") ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     var arr : Sequence(int) ; arr := Sequence{1,1,2,3,6,11} ;
     execute canMake(n, arr) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int z=n*2 ;
    int c=0 ;
    int arr[]=new int[z];
    ArrayList<Integer>ff=new ArrayList<>();
    ArrayList<Integer>ss=new ArrayList<>();
    while(n-->0){
      ff.add(sc.nextInt());
      ss.add(sc.nextInt());
    }
    int pp=ff.size();
    for(int i=0 ; i<pp ; i++){
      for(int j=0 ; j<pp ; j++){
        if(ff.get(i)==ss.get(j)){
          c++;
        }
        else {
          continue ;
        }
      }
    }
    System.out.print(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var z : int ; z := n * 2 ;
    var c : int ; c := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,z)->collect(0) ;
    var ff : Sequence(int) ; ff := Sequence{} ;
    var ss : Sequence(int) ; ss := Sequence{} ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     ff := ff->including(sc.getCurrent()->toInteger()) ; 
     ss := ss->including(sc.getCurrent()->toInteger()) ) ;  ) ;  
    var pp : int ; pp := ff->size() ;
        var i : int ; i := 0 ; while i < pp do ( (         var j : int ; j := 0 ; while j < pp do ( (     if (ff->at(i+1) = ss->at(j+1)) then (     c := c + 1 ) else (     continue ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void removeSpecialCharacter(String str){
    char[] s=str.toCharArray();
    int j=0 ;
    for(int i=0 ; i<s.length ; i++){
      if((s[i]>='A' && s[i]<='Z')||(s[i]>='a' && s[i]<='z')){
        s[j]=s[i];
        j++;
      }
    }
    System.out.println(String.valueOf(s).substring(0,j));
  }
  public static void main(String[] args){
    String s="$Gee*k;s..fo,r'Ge^eks?" ;
    removeSpecialCharacter(s);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation removeSpecialCharacter( str : String) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := str->characters() ;
     var j : int ; j := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if ((s[i+1] >= 'A' & s[i+1] <= 'Z') or (s[i+1] >= 'a' & s[i+1] <= 'z')) then (     s[j+1] := s[i+1] ; 
     j := j + 1 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println((s)->sum() .subrange(0+1,j)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "$Gee*k;s..fo,r'Ge^eks?" ;
     execute removeSpecialCharacter(s) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int[] arr=new int[n];
      HashMap<Integer,Integer>map=new HashMap<>();
      for(int j=0 ; j<n ; j++){
        arr[j]=sc.nextInt();
        if(map.containsKey(arr[j])){
          map.put(arr[j],map.get(arr[j])+1);
        }
        else {
          map.put(arr[j],1);
        }
      }
      int c=0 ;
      for(Map.Entry<Integer,Integer>entry : map.entrySet()){
        if(entry.getValue()>=3){
          System.out.println(entry.getKey());
          c++;
          break ;
        }
      }
      if(c==0){
        System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var map : Map(int,int) ; map := Map{} ;
        var j : int ; j := 0 ; while j < n do ( (     arr[j+1] := sc.getCurrent()->toInteger() ; 
     if (map->keys()->includes(arr[j+1])) then (     map := map->union(Map{arr[j+1] |-> map->at(arr[j+1]) + 1}) ) else (     map := map->union(Map{arr[j+1] |-> 1}) ) )  ;     j := j + 1 ) ; 
    var c : int ; c := 0 ;
    for (entry : map->asSet()) do ( (     if (entry.getValue() >= 3) then (     OclFile["System.out"].println(entry.getKey()) ; 
     c := c + 1 ; 
     break ) else skip )  ) ; 
    if (c = 0) then (     OclFile["System.out"].println(-1) ) else skip ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class test203 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      HashMap<Integer,Integer>a=new HashMap<Integer,Integer>();
      int c=-1 ;
      for(int i=0 ; i<n ; i++){
        int b=in.nextInt();
        if(a.get(b)==null){
          a.put(b,1);
        }
        else {
          a.put(b,a.get(b)+1);
        }
        if(a.get(b)==3){
          c=b ;
        }
      }
      System.out.println(c);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test203 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Map(int,int) ; a := Map{} ;
    var c : int ; c := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var b : int ; b := in.getCurrent()->toInteger() ;
     if (a->at(b) = null) then (     a := a->union(Map{b |-> 1}) ) else (     a := a->union(Map{b |-> a->at(b) + 1}) ) ;  
     if (a->at(b) = 3) then (     c := b ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1669B_Triple {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int len=parseInt(input.nextLine());
      TreeMap<Integer,Integer>map=new TreeMap<>();
      int result=-1 ;
      for(int i=0 ; i<len ; i++){
        int num=input.nextInt();
        int value=map.getOrDefault(num,0)+1 ;
        map.put(num,value);
      }
      input.nextLine();
      for(Map.Entry<Integer,Integer>en : map.entrySet()){
        if(en.getValue()>=3){
          result=en.getKey();
          break ;
        }
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1669B_Triple {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var len : int ; len := parseInt(input.nextLine()) ;
     var map : Map(int,int) ; map := Map{} ;
    var result : int ; result := -1 ;
        var i : int ; i := 0 ; while i < len do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
     var value : int ; value := (if map->keys()->contains(num) then map->at(num) else 0 endif) + 1 ;
     map := map->union(Map{num |-> value}) )  ;     i := i + 1 ) ; 
    skip ; 
    for (en : map->asSet()) do ( (     if (en.getValue() >= 3) then (     result := en.getKey() ; 
     break ) else skip )  ) ; 
    OclFile["System.out"].println(result) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t--!=0){
      int n=in.nextInt();
      int[] arr=new int[n];
      int[] freq=new int[n+1];
      int ans=-1 ;
      for(int i=0 ; i<n ; i++){
        freq[arr[i]=in.nextInt()]++;
        if(freq[arr[i] ]>=3)ans=arr[i];
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var freq : Sequence(int) ; freq := Integer.subrange(1,n + 1)->collect(0) ;
    var ans : int ; ans := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     freq[arr[i+1]+1] := freq[arr[i+1]+1] + 1 ; 
     if (freq[arr[i+1]+1] >= 3) then     ans := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Tttest {
  public static int fun(int[] arr){
    HashMap<Integer,Integer>hm=new LinkedHashMap<>();
    for(int i=0 ; i<arr.length ; i++){
      if(hm.containsKey(arr[i])){
        int of=hm.get(arr[i]);
        of++;
        hm.put(arr[i],of);
        continue ;
      }
      hm.put(arr[i],1);
    }
    int ans=-1 ;
    for(Integer i : hm.keySet()){
      if(hm.get(i)>=3){
        ans=i ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int a=sc.nextInt();
      int[] arr=new int[a];
      for(int i=0 ; i<arr.length ; i++){
        arr[i]=sc.nextInt();
      }
      System.out.println(fun(arr));
      t--;
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Tttest {
  static   operation fun( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var hm : Map(int,int) ; hm := Map{} ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     if (hm->keys()->includes(arr[i+1])) then (     var of : int ; of := hm->at(arr[i+1]) ;
     of := of + 1 ; 
     hm := hm->union(Map{arr[i+1] |-> of}) ; 
     continue ) else skip ; 
     hm := hm->union(Map{arr[i+1] |-> 1}) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -1 ;
    for (i : hm->keys()) do ( (     if (hm->at(i) >= 3) then (     ans := i ) else skip )  ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,a)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(fun(arr)) ; 
    t := t - 1 ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  public static long fact[];
  public static long inverse[];
  public static long pow(long a,long n){
    long res=1 ;
    while(n>0){
      if(n % 2==1){
        res=(res*a)% mod ;
      }
      a=(a*a)% mod ;
      n>>=1 ;
    }
    return res ;
  }
  public static long modinv(long n){
    return pow(n,mod-2);
  }
  public static long comb(int n,int k){
    if(n<0 || k<0 || n<k)return 0 ;
    return(fact[n]*((inverse[k]*inverse[n-k])% mod))% mod ;
  }
  public static long mod=(long)1e9+7 ;
  public static void main(String args[])throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int k=Integer.parseInt(reader.readLine());
    String str=reader.readLine();
    int n=str.length();
    inverse=new long[n+k+1];
    fact=new long[n+k+1];
    fact[0]=1 ;
    inverse[0]=1 ;
    for(int i=1 ; i<=n+k ; ++i){
      fact[i]=(fact[i-1]*(long)i)% mod ;
      inverse[i]=modinv(fact[i]);
    }
    long res=0 ;
    long p=1 ;
    for(int i=0 ; i<=k ; i++){
      res=(res+comb(n+k,i)*p)% mod ;
      p=(p*25)% mod ;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute fact : Sequence(long);
  static   attribute inverse : Sequence(long);
  static   operation pow( a : long, n : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     while (n > 0) do (     if (n mod 2 = 1) then (     res := (res * a) mod mod ) else skip ; 
     a := (a * a) mod mod ; 
     n := n/(2->pow(1)) ) ; 
     return res );
  static   operation modinv( n : long) : long
  pre: true
  post: true
  activity: (     return pow(n, mod - 2) );
  static   operation comb( n : int, k : int) : long
  pre: true
  post: true
  activity: (     if (n < 0 or k < 0 or n < k) then     return 0 else skip ; 
     return (fact[n+1] * ((inverse[k+1] * inverse[n - k+1]) mod mod)) mod mod );
  static   attribute mod : long := 1e9->oclAsType(long) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var k : int ; k := (reader.readLine())->toInteger() ;
    var str : String ; str := reader.readLine() ;
    var n : int ; n := str->size() ;
    inverse := Integer.subrange(1,n + k + 1)->collect(0) ; 
    fact := Integer.subrange(1,n + k + 1)->collect(0) ; 
    fact[0+1] := 1 ; 
    inverse[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n + k do ( (     fact[i+1] := (fact[i - 1+1] * i->oclAsType(long)) mod mod ; 
     inverse[i+1] := modinv(fact[i+1]) )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
    var p : long ; p := 1 ;
        var i : int ; i := 0 ; while i <= k do ( (     res := (res + comb(n + k, i) * p) mod mod ; 
     p := (p * 25) mod mod )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scr=new Scanner(System.in);
    int n=Integer.parseInt(scr.nextLine());
    int result=0 ;
    for(int i=0 ; i<n ; i++){
      String str=scr.nextLine();
      if(str.equals("X++")|| str.equals("++X"))result++;
      else result--;
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scr : OclFile ; scr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (scr.nextLine())->toInteger() ;
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := scr.nextLine() ;
     if (str = "X++" or str = "++X") then     result := result + 1 ; else     result := result - 1 ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static int mod=1000000007 ;
  public static void main(String[] main)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    PrintWriter out=new PrintWriter(System.out);
    int k=Integer.parseInt(st.nextToken());
    st=new StringTokenizer(br.readLine());
    String s=st.nextToken();
    long[] fact=new long[2000001];
    fact[0]=1 ;
    for(int i=1 ; i<2000001 ; i++)fact[i]=(fact[i-1]*i)% mod ;
    long[] pow25=new long[1000001];
    long[] pow26=new long[1000001];
    pow25[0]=1 ;
    pow26[0]=1 ;
    for(int i=1 ; i<1000001 ; i++){
      pow25[i]=(pow25[i-1]*25)% mod ;
      pow26[i]=(pow26[i-1]*26)% mod ;
    }
    long ans=pow26[k];
    long prev=1 ;
    for(int i=1 ; i<=k ; i++){
      prev=multiply(prev,multiply(s.length()+i-1,pow(i,mod-2)));
      ans=(ans+prev*multiply(pow25[i],pow26[k-i]))% mod ;
    }
    out.println(ans);
    out.close();
  }
  static long multiply(long a,long b){
    return(a*b)% mod ;
  }
  static long pow(long l,int p){
    if(p==0)return 1 ;
    if(p==1 || l==1)return l ;
    long temp=pow(l,p/2);
    long temp1=(temp*temp)% mod ;
    if(p % 2==1)temp1=(temp1*l)% mod ;
    return temp1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := 1000000007;
  static   operation main( main : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var k : int ; k := (st.next())->toInteger() ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    var s : String ; s := st.next() ;
    var fact : Sequence(long) ; fact := Integer.subrange(1,2000001)->collect(0) ;
    fact[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < 2000001 do (     fact[i+1] := (fact[i - 1+1] * i) mod mod ;  ;     i := i + 1 ) ; 
    var pow25 : Sequence(long) ; pow25 := Integer.subrange(1,1000001)->collect(0) ;
    var pow26 : Sequence(long) ; pow26 := Integer.subrange(1,1000001)->collect(0) ;
    pow25[0+1] := 1 ; 
    pow26[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < 1000001 do ( (     pow25[i+1] := (pow25[i - 1+1] * 25) mod mod ; 
     pow26[i+1] := (pow26[i - 1+1] * 26) mod mod )  ;     i := i + 1 ) ; 
    var ans : long ; ans := pow26[k+1] ;
    var prev : long ; prev := 1 ;
        var i : int ; i := 1 ; while i <= k do ( (     prev := multiply(prev, multiply(s->size() + i - 1, pow(i, mod - 2))) ; 
     ans := (ans + prev * multiply(pow25[i+1], pow26[k - i+1])) mod mod )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation multiply( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a * b) mod mod );
  static   operation pow( l : long, p : int) : long
  pre: true
  post: true
  activity: (     if (p = 0) then     return 1 else skip ; 
     if (p = 1 or l = 1) then     return l else skip ; 
    var temp : long ; temp := pow(l, p / 2) ;
    var temp1 : long ; temp1 := (temp * temp) mod mod ;
    if (p mod 2 = 1) then     temp1 := (temp1 * l) mod mod ; else skip ; 
    return temp1 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  String[] ss ;
  void run(){
    ss=new String[3];
    for(; ; ){
      ss[0]=sc.next();
      if(ss[0] .equals("0")){
        break ;
      }
      ss[1]=sc.next();
      ss[2]=sc.next();
      solve();
    }
  }
  void solve(){
    for(int j=0 ; j<3 ; j++){
      int a=0,b=0 ;
      for(int i=0 ; i<ss[j] .length()-1 ; i++){
        if(ss[j] .charAt(i+1)=='A'){
          a++;
        }
        else {
          b++;
        }
      }
      if((a+1==11 && b<=9)||(a+1>=12 && a+1==b+2)){
        a++;
      }
      else {
        b++;
      }
      println(a+" "+b);
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   attribute ss : Sequence(String);
   operation run() : void
  pre: true
  post: true
  activity: (     ss := Integer.subrange(1,3)->collect(null) ; 
       while true do ( (     ss[0+1] := sc.getCurrent() ; 
     if (ss[0+1] = "0") then (     break ) else skip ; 
    ss[1+1] := sc.getCurrent() ; 
    ss[2+1] := sc.getCurrent() ; 
    execute solve() ; 
 )  ) );
   operation solve() : void
  pre: true
  post: true
  activity: (         var j : int ; j := 0 ; while j < 3 do ( (     var a : int ; a := 0 ;
    var b : int ; b := 0 ;
         var i : int ; i := 0 ; while i < ss[j+1]->size() - 1 do ( (     if (ss[j+1]->at(i + 1+1) = 'A') then (     a := a + 1 ) else (     b := b + 1 ) )  ;     i := i + 1 ) ; 
     if ((a + 1 = 11 & b <= 9) or (a + 1 >= 12 & a + 1 = b + 2)) then (     a := a + 1 ) else (     b := b + 1 ) ;  
     execute println(a + " " + b) )  ;     j := j + 1 ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  private static final long MOD=1_000_000_007L ;
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int k=scanner.nextInt();
      int n=scanner.next().length();
      int m=k+n ;
      long[] factorial=new long[m+1];
      factorial[0]=1 ;
      IntStream.rangeClosed(1,m).forEach(i->factorial[i]=factorial[i-1]*i % MOD);
      long[] revFactorial=new long[m+1];
      revFactorial[m]=modPow(factorial[m],MOD-2);
      IntStream.rangeClosed(1,m).map(i->m-i).forEach(i->revFactorial[i]=revFactorial[i+1]*(i+1)% MOD);
      long answer=0L ;
      for(int i=n ; i<=m ; i++){
        long result=factorial[i-1]*revFactorial[n-1] % MOD*revFactorial[i-n] % MOD ;
        result=result*modPow(25,k-(m-i))% MOD*modPow(26,m-i)% MOD ;
        answer=(answer+result)% MOD ;
      }
      System.out.println(answer);
    }
  }
  private static long modPow(long n,long m){
    long result=1L ;
    while(m>0){
      if(1==(m & 1)){
        result=result*n % MOD ;
      }
      n=n*n % MOD ;
      m>>=1 ;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 1_000_000_007L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var k : int ; k := scanner.getCurrent()->toInteger() ;
     var n : int ; n := scanner.getCurrent()->size() ;
    var m : int ; m := k + n ;
    var factorial : Sequence(long) ; factorial := Integer.subrange(1,m + 1)->collect(0) ;
    factorial[0+1] := 1 ; 
    for i : Integer.subrange(1, m) do
    (    factorial[i+1] := factorial[i - 1+1] * i mod MOD) ; 
    var revFactorial : Sequence(long) ; revFactorial := Integer.subrange(1,m + 1)->collect(0) ;
    revFactorial[m+1] := modPow(factorial[m+1], MOD - 2) ; 
    for i : Integer.subrange(1, m)->collect( _x1 | (lambda i : OclAny in m - i)->apply(_x1) ) do
    (    revFactorial[i+1] := revFactorial[i + 1+1] * (i + 1) mod MOD) ; 
    var answer : long ; answer := 0L ;
        var i : int ; i := n ; while i <= m do ( (     var result : long ; result := factorial[i - 1+1] * revFactorial[n - 1+1] mod MOD * revFactorial[i - n+1] mod MOD ;
     result := result * modPow(25, k - (m - i)) mod MOD * modPow(26, m - i) mod MOD ; 
     answer := (answer + result) mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 ))  );
  static   operation modPow( n : long, m : long) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 1L ;
     while (m > 0) do (     if (1 = (MathLib.bitwiseAnd(m,1))) then (     result := result * n mod MOD ) else skip ; 
     n := n * n mod MOD ; 
     m := m/(2->pow(1)) ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.PrintWriter ;
public class Main {
  static long[] fact ;
  static long[] inv ;
  static long mod=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    String s=sc.next();
    fact=new long[s.length()+k+1];
    fact[0]=1 ;
    fact[1]=1 ;
    for(int i=2 ; i<=s.length()+k ; i++){
      fact[i]=(fact[i-1]*i)% mod ;
    }
    inv=new long[s.length()+k+1];
    inv[s.length()+k]=pow(fact[s.length()+k],mod-2);
    for(int i=s.length()+k-1 ; i>=0 ; i--){
      inv[i]=(inv[i+1]*(i+1))% mod ;
    }
    long ans=0 ;
    for(int i=0 ; i<=k ; i++){
      ans=(ans+(((pow(26,k-i)*pow(25,i))% mod)*comb(s.length()+i-1,i)% mod))% mod ;
    }
    System.out.println(ans);
  }
  static long comb(int t,int y){
    long re=1 ;
    re*=fact[t];
    re*=inv[y];
    re %=mod ;
    re*=inv[t-y];
    return re % mod ;
  }
  static long pow(long p,long q){
    long res=1 ;
    while(q>0){
      if((q & 1)==1){
        res*=p ;
        res %=mod ;
      }
      q>>=1 ;
      p*=p ;
      p %=mod ;
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute fact : Sequence(long);
  static   attribute inv : Sequence(long);
  static   attribute mod : long := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    fact := Integer.subrange(1,s->size() + k + 1)->collect(0) ; 
    fact[0+1] := 1 ; 
    fact[1+1] := 1 ; 
        var i : int ; i := 2 ; while i <= s->size() + k do ( (     fact[i+1] := (fact[(i)->char2byte() - 1+1] * i) mod mod )  ;     i := i + 1 ) ; 
    inv := Integer.subrange(1,s->size() + k + 1)->collect(0) ; 
    inv[s->size() + k+1] := pow(fact[s->size() + k+1], mod - 2) ; 
        var i : int ; i := s->size() + k - 1 ; while i >= 0 do ( (     inv[i+1] := (inv[i + 1+1] * (i + 1)) mod mod )  ;     i := i - 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i <= k do ( (     ans := (ans + (((pow(26, k - (i)->char2byte()) * pow(25, i)) mod mod) * comb(s->size() + i - 1, i) mod mod)) mod mod )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation comb( t : int, y : int) : long
  pre: true
  post: true
  activity: (     var re : long ; re := 1 ;
     re := re*(fact[t+1]) ; 
    re := re*(inv[y+1]) ; 
    re := re mod mod ; 
    re := re*(inv[t - y+1]) ; 
    return re mod mod 
 );
  static   operation pow( p : long, q : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     while (q > 0) do (     if ((q & 1) = 1) then (     res := res*(p) ; 
     res := res mod mod ) else skip ; 
     q := q/(2->pow(1)) ; 
     p := p*(p) ; 
     p := p mod mod ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    int n=parseInt(br.readLine());
    int m=parseInt(br.readLine());
    int max=m ;
    for(int i=0 ; i<n ; i++){
      line=br.readLine();
      int a=parseInt(line.substring(0,line.indexOf(' ')));
      int b=parseInt(line.substring(line.indexOf(' ')+1));
      m=m+a-b ;
      if(m<0){
        max=0 ;
        break ;
      }
      else {
        max=Math.max(max,m);
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var n : int ; n := parseInt(br.readLine()) ;
    var m : int ; m := parseInt(br.readLine()) ;
    var max : int ; max := m ;
        var i : int ; i := 0 ; while i < n do ( (     line := br.readLine() ; 
     var a : int ; a := parseInt(line.subrange(0+1,line->indexOf(' ')-1)) ;
    var b : int ; b := parseInt(line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1)) ;
    m := m + a - b ; 
    if (m < 0) then (     max := 0 ; 
     break ) else (     max := Set{max, m}->max() ) ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.Map ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final int n=sc.nextInt();
    int cur=sc.nextInt();
    int max=cur ;
    for(int i=0 ; i<n ; i++){
      final int in=sc.nextInt();
      final int out=sc.nextInt();
      cur=cur+in-out ;
      if(cur<0){
        System.out.println(0);
        return ;
      }
      max=Math.max(max,cur);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var cur : int ; cur := sc.getCurrent()->toInteger() ;
    var max : int ; max := cur ;
        var i : int ; i := 0 ; while i < n do ( (     var in : int ; in := sc.getCurrent()->toInteger() ;
     var out : int ; out := sc.getCurrent()->toInteger() ;
    cur := cur + in - out ; 
    if (cur < 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    max := Set{max, cur}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    int max=0,tunnel=0,in=0,out=0 ;
    int time=0 ;
    boolean first=true ;
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String line ;
      while((line=br.readLine())!=null){
        if(first){
          time=Integer.parseInt(line);
          tunnel=Integer.parseInt(br.readLine());
          max=tunnel ;
          first=false ;
        }
        else {
          String[] str=line.split(" ");
          in=Integer.parseInt(str[0]);
          out=Integer.parseInt(str[1]);
          if(in+tunnel-out<0){
            System.out.println(0);
            return ;
          }
          else {
            tunnel=in+tunnel-out ;
            if(max<tunnel){
              max=tunnel ;
            }
          }
        }
        time--;
        if(time<0){
          break ;
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var max : int ; max := 0 ;
    var tunnel : int ; tunnel := 0 ;
    var in : int ; in := 0 ;
    var out : int ; out := 0 ;
     var time : int ; time := 0 ;
     var first : boolean ; first := true ;
     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     if (first) then (     time := (line)->toInteger() ; 
     tunnel := (br.readLine())->toInteger() ; 
     max := tunnel ; 
     first := false ) else (     var str : Sequence(String) ; str := line->split(" ") ;
     in := (str[0+1])->toInteger() ; 
     out := (str[1+1])->toInteger() ; 
     if (in + tunnel - out < 0) then (     OclFile["System.out"].println(0) ; 
     return ) else (     tunnel := in + tunnel - out ; 
     if (max < tunnel) then (     max := tunnel ) else skip ) ) ;  
     time := time - 1 ; 
     if (time < 0) then (     break ) else skip ) ;     line := br.readLine() ;
 ) ;  
     OclFile["System.out"].println(max) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
class Main {
  public static void main(String[] args){
    BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
    try {
      int n=Integer.valueOf(sc.readLine());
      int inside=Integer.valueOf(sc.readLine());
      int max=inside,flag=0 ;
      for(int i=0 ; i<n ; i++){
        String[] st=sc.readLine().split(" ");
        int now=Integer.valueOf(st[0])-Integer.valueOf(st[1]);
        inside+=now ;
        max=Math.max(max,inside);
        if(inside<0)flag=1 ;
      }
      if(flag==1)System.out.println(0);
      else System.out.println(max);
    }
    catch(Exception e){
      System.out.println("Error");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var n : int ; n := (sc.readLine())->toInteger() ;
     var inside : int ; inside := (sc.readLine())->toInteger() ;
    var max : int ; max := inside ;
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var st : Sequence(String) ; st := sc.readLine()->split(" ") ;
     var now : int ; now := (st[0+1])->toInteger() - (st[1+1])->toInteger() ;
    inside := inside+(now) ; 
    max := Set{max, inside}->max() ; 
    if (inside < 0) then     flag := 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
    if (flag = 1) then     OclFile["System.out"].println(0) else     OclFile["System.out"].println(max) ; ;  
 )   catch (e : ProgramException) do (     OclFile["System.out"].println("Error") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    int ans=m ;
    for(int i=0 ; i<n ; i++){
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      m+=a-b ;
      if(m<0){
        System.out.println(0);
        return ;
      }
      ans=Math.max(ans,m);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var ans : int ; ans := m ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
    m := m+(a - b) ; 
    if (m < 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    ans := Set{ans, m}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sticks[]={
    6,7,4,6,5,4,6,5,2,4,4,3,6,6,6,5,7,6,5,3,5,4,6,4,3,4 };
    static int number[]={
      6,2,5,5,4,5,6,3,7,6 };
      static int countSticks(String str){
        int cnt=0 ;
        for(int i=0 ; i<str.length(); i++){
          char ch=str.charAt(i);
          if(ch>='A' && ch<='Z'){
            cnt+=sticks[ch-'A'];
          }
          else {
            cnt+=number[ch-'0'];
          }
        }
        return cnt ;
      }
      public static void main(String[] args){
        String str="GEEKSFORGEEKS" ;
        System.out.println(countSticks(str));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute sticks : int := Sequence{6,7,4,6,5,4,6,5,2,4,4,3,6,6,6,5,7,6,5,3,5,4,6,4,3,4};
  static   attribute number : int := Sequence{6,2,5,5,4,5,6,3,7,6};
  static   operation countSticks( str : String) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     var ch : String ; ch := str->at(i+1) ;
     if (ch >= 'A' & ch <= 'Z') then (     cnt := cnt+(sticks[(ch)->char2byte() - ('A')->char2byte()+1]) ) else (     cnt := cnt+(number[(ch)->char2byte() - ('0')->char2byte()+1]) ) )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GEEKSFORGEEKS" ;
     OclFile["System.out"].println(countSticks(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static boolean prime[]=new boolean[100005];
  static void SieveOfEratosthenes(int n){
    Arrays.fill(prime,true);
    prime[1]=false ;
    for(int p=2 ; p*p<n ; p++){
      if(prime[p]){
        for(int i=p*2 ; i<n ; i+=p){
          prime[i]=false ;
        }
      }
    }
  }
  static int xorPrimes(int arr[],int n){
    SieveOfEratosthenes(100005);
    int xorVal=0 ;
    for(int i=0 ; i<n ; i++){
      if(prime[arr[i] ]){
        xorVal=xorVal ^ arr[i];
      }
    }
    return xorVal ;
  }
  public static void main(String[] args){
    int arr[]={
      4,3,2,6,100,17 };
      int n=arr.length ;
      System.out.println(xorPrimes(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute prime : boolean := Integer.subrange(1,100005)->collect(false);
  static   operation SieveOfEratosthenes( n : int) : void
  pre: true
  post: true
  activity: (     prime := prime->collect(true) ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p < n do ( (     if (prime[p+1]) then (         var i : int ; i := p * 2 ; while i < n do ( (     prime[i+1] := false )  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation xorPrimes( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes(100005) ; 
     var xorVal : int ; xorVal := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (prime[arr[i+1]+1]) then (     xorVal := MathLib.bitwiseXor(xorVal,arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
     return xorVal );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,3,2,6,100,17} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(xorPrimes(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int missingNumber(int[] nums){
    int res=nums.length ;
    for(int i=0 ; i<nums.length ; i++){
      res ^=i ;
      res ^=nums[i];
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation missingNumber( nums : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var res : int ; res := nums->size() ;
         var i : int ; i := 0 ; while i < nums->size() do ( (     res := MathLib.bitwiseXor(res,i) ; 
     res := MathLib.bitwiseXor(res,nums[i+1]) )  ;     i := i + 1 ) ; 
     return res );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class C {
  PrintWriter out ;
  Scanner in ;
  String testCase="c2" ;
  public static void main(String[] args)throws Exception {
    new C().solve();
  }
  int INF=1000000000 ;
  int P,Q ;
  int[] a ;
  int[][] mem ;
  int findMax(int left,int right){
    if(mem[left][right]!=INF){
      return mem[left][right];
    }
    int ans=INF ;
    for(int i=left+1 ; i<right ; ++i){
      int newSol=a[right]-a[left]-2+findMax(left,i)+findMax(i,right);
      ans=Math.min(ans,newSol);
    }
    if(ans==INF){
      ans=0 ;
    }
    mem[left][right]=ans ;
    return ans ;
  }
  void solve()throws Exception {
    Locale.setDefault(Locale.ENGLISH);
    out=new PrintWriter(new FileOutputStream(testCase+".out"));
    in=new Scanner(new BufferedReader(new InputStreamReader(new FileInputStream(testCase+".in"))));
    int N=in.nextInt();
    for(int t=1 ; t<=N ; ++t){
      out.print("Case #"+t+": ");
      P=in.nextInt();
      Q=in.nextInt();
      a=new int[Q+2];
      a[0]=0 ;
      for(int i=0 ; i<Q ; ++i){
        a[i+1]=in.nextInt();
      }
      a[Q+1]=P+1 ;
      Arrays.sort(a);
      mem=new int[Q+2][Q+2];
      for(int i=0 ; i<=Q+1 ; ++i){
        for(int j=0 ; j<=Q+1 ; ++j){
          mem[i][j]=INF ;
        }
      }
      out.println(findMax(0,Q+1));
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
   attribute out : OclFile;
   attribute in : OclFile;
   attribute testCase : String := "c2";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     C.newC().solve() );
   attribute INF : int := 1000000000;
   attribute P : int;
   attribute a : Sequence(int);
   attribute mem : Sequence(Sequence(int));
   operation findMax( left : int, right : int) : int
  pre: true
  post: true
  activity: (     if (mem[left+1][right+1] /= INF) then (     return mem[left+1][right+1] ) else skip ; 
     var ans : int ; ans := INF ;
        var i : int ; i := left + 1 ; while i < right do ( (     var newSol : int ; newSol := a[right+1] - a[left+1] - 2 + findMax(left, i) + findMax(i, right) ;
     ans := Set{ans, newSol}->min() )  ;     i := i + 1 ) ; 
    if (ans = INF) then (     ans := 0 ) else skip ; 
    mem[left+1][right+1] := ans ; 
    return ans 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.ENGLISH) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(testCase + ".out")) ; 
    in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(testCase + ".in")))) ; 
    var N : int ; N := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= N do ( (     skip ; 
     P := in.getCurrent()->toInteger() ; 
    Q := in.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,Q + 2)->collect(0) ; 
    a[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < Q do ( (     a[i + 1+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a[Q + 1+1] := P + 1 ; 
    a := a->sort() ; 
    mem := Integer.subrange(1,Q + 2)->collect(Integer.subrange(1,Q + 2)->collect(0)) ; 
        var i : int ; i := 0 ; while i <= Q + 1 do ( (         var j : int ; j := 0 ; while j <= Q + 1 do ( (     mem[i+1][j+1] := INF )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int z=n*2 ;
    int c=0 ;
    int arr[]=new int[z];
    ArrayList<Integer>ff=new ArrayList<>();
    ArrayList<Integer>ss=new ArrayList<>();
    while(n-->0){
      ff.add(sc.nextInt());
      ss.add(sc.nextInt());
    }
    int pp=ff.size();
    for(int i=0 ; i<pp ; i++){
      for(int j=0 ; j<pp ; j++){
        if(i!=j){
          if(ff.get(i)==ss.get(j)){
            c++;
          }
        }
        else {
          continue ;
        }
      }
    }
    System.out.print(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var z : int ; z := n * 2 ;
    var c : int ; c := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,z)->collect(0) ;
    var ff : Sequence(int) ; ff := Sequence{} ;
    var ss : Sequence(int) ; ss := Sequence{} ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     ff := ff->including(sc.getCurrent()->toInteger()) ; 
     ss := ss->including(sc.getCurrent()->toInteger()) ) ;  ) ;  
    var pp : int ; pp := ff->size() ;
        var i : int ; i := 0 ; while i < pp do ( (         var j : int ; j := 0 ; while j < pp do ( (     if (i /= j) then (     if (ff->at(i+1) = ss->at(j+1)) then (     c := c + 1 ) else skip ) else (     continue ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int k=sc.nextInt();
      while(k-->0){
        int a=sc.nextInt();
        int b=sc.nextInt();
        int c=sc.nextInt();
        int d=sc.nextInt();
        System.out.println(Math.max(a+b,c+d));
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
         while (k > 0) do (        k := k - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(Set{a + b, c + d}->max()) ; 
 ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] arg){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int max=0 ;
      int start=0 ;
      String sa=in.next();
      String sb=in.next();
      StringBuilder sbb=new StringBuilder();
      int s=sa.length()+sb.length()-1 ;
      for(int i=0 ; i<s ; i++){
        if(i<sb.length()){
          sbb.insert(0,sb.charAt(sb.length()-i-1));
        }
        else {
          sbb.insert(0,' ');
          start++;
        }
        if(i>=sa.length()){
          sbb.setLength(sbb.length()-1);
        }
        int count=0 ;
        for(int posi=start ; posi<sbb.length(); posi++){
          if(sa.charAt(posi)==sbb.charAt(posi)){
            count++;
          }
          else if(count!=0){
            count=0 ;
          }
          max=Math.max(count,max);
        }
      }
      System.out.println(max);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var max : int ; max := 0 ;
     var start : int ; start := 0 ;
    var sa : String ; sa := in.getCurrent() ;
    var sb : String ; sb := in.getCurrent() ;
    var sbb : String ; sbb := StringLib.newString() ;
    var s : int ; s := sa->size() + sb->size() - 1 ;
        var i : int ; i := 0 ; while i < s do ( (     if (i < sb->size()) then (     sbb := sbb.insertAt(0+1, StringLib.newString(sb->at(sb->size() - i - 1+1))) ) else (     sbb := sbb.insertAt(0+1, StringLib.newString(' ')) ; 
     start := start + 1 ) ;  
     if (i >= sa->size()) then (     sbb := sbb.subrange(1,sbb->size() - 1) ) else skip ; 
     var count : int ; count := 0 ;
         var posi : int ; posi := start ; while posi < sbb->size() do ( (     if (sa->at(posi+1) = sbb->at(posi+1)) then (     count := count + 1 ) else     if (count /= 0) then (     count := 0 ) else skip ; ;  
     max := Set{count, max}->max() )  ;     posi := posi + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(scanner.hasNext()){
      String a=scanner.next();
      String b=scanner.next();
      int p1=a.length();
      int p2=0 ;
      int ans=0 ;
      while(p1!=0 || p2<=b.length()){
        if(p1!=0)p1--;
        else p2++;
        ans=Math.max(ans,slove(a,b,p1,p2));
      }
      System.out.println(ans);
    }
  }
  private int slove(String a,String b,int p1,int p2){
    int tmp=0 ;
    int res=0 ;
    int len=Math.min(b.length()-p2,a.length()-p1);
    for(int i=0 ; i<len ; i++){
      if(a.charAt(p1+i)!=b.charAt(p2+i)){
        res=Math.max(res,tmp);
        tmp=0 ;
      }
      else tmp++;
    }
    return Math.max(tmp,res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scanner.hasNext()) do (     var a : String ; a := scanner.getCurrent() ;
     var b : String ; b := scanner.getCurrent() ;
    var p1 : int ; p1 := a->size() ;
    var p2 : int ; p2 := 0 ;
    var ans : int ; ans := 0 ;
    while (p1 /= 0 or p2 <= b->size()) do (     if (p1 /= 0) then     p1 := p1 - 1 else     p2 := p2 + 1 ; ;  
     ans := Set{ans, slove(a, b, p1, p2)}->max() ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
   operation slove( a : String, b : String, p1 : int, p2 : int) : int
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := 0 ;
     var res : int ; res := 0 ;
    var len : int ; len := Set{b->size() - p2, a->size() - (p1)->char2byte()}->min() ;
        var i : int ; i := 0 ; while i < len do ( (     if (a->at(p1 + i+1) /= b->at(p2 + i+1)) then (     res := Set{res, tmp}->max() ; 
     tmp := 0 ) else     tmp := tmp + 1 ; )  ;     i := i + 1 ) ; 
    return Set{tmp, res}->max() 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String[] str={
        sc.next(),sc.next()};
        String max=str[0] .length()>str[1] .length()? str[0] : str[1];
        String min=str[0] .length()>str[1] .length()? str[1] : str[0];
        short[][] dp=new short[max.length()+1][min.length()+1];
        int count=0 ;
        for(int i=0 ; i<max.length(); i++){
          for(int j=0 ; j<min.length(); j++){
            if(max.charAt(i)==min.charAt(j)){
              dp[i+1][j+1]=(short)(dp[i][j]+1);
              count=Math.max(count,dp[i+1][j+1]);
            }
          }
        }
        System.out.println(count);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var str : Sequence(String) ; str := Sequence{sc.getCurrent(),sc.getCurrent()} ;
     var max : String ; max := if str[0+1]->size() > str[1+1]->size() then str[0+1] else str[1+1] endif ;
    var min : String ; min := if str[0+1]->size() > str[1+1]->size() then str[1+1] else str[0+1] endif ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,max->size() + 1)->collect(Integer.subrange(1,min->size() + 1)->collect(0)) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < max->size() do ( (         var j : int ; j := 0 ; while j < min->size() do ( (     if (max->at(i+1) = min->at(j+1)) then (     dp[i + 1+1][j + 1+1] := ((dp[i+1][j+1] + 1) mod 32768) ; 
     count := Set{count, dp[i + 1+1][j + 1+1]}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=br.readLine();
    while(str!=null){
      String[] strA=str.split("");
      str=br.readLine();
      String[] strB=str.split("");
      int lengthA=strA.length ;
      int lengthB=strB.length ;
      int maxn=0 ;
      for(int i=0 ; i<lengthA ; i++){
        int n=0 ;
        int p=0 ;
        while(p<lengthA && i+p<lengthB){
          if(strA[p] .equals(strB[i+p])){
            n++;
            if(maxn<n)maxn=n ;
          }
          else {
            n=0 ;
          }
          p++;
        }
      }
      for(int i=0 ; i<lengthB ; i++){
        int n=0 ;
        int p=0 ;
        while(p<lengthB && i+p<lengthA){
          if(strB[p] .equals(strA[i+p])){
            n++;
            if(maxn<n)maxn=n ;
          }
          else {
            n=0 ;
          }
          p++;
        }
      }
      System.out.println(maxn);
      str=br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := br.readLine() ;
     while (str /= null) do (     var strA : Sequence(String) ; strA := str->split("") ;
     str := br.readLine() ; 
    var strB : Sequence(String) ; strB := str->split("") ;
    var lengthA : int ; lengthA := strA->size() ;
    var lengthB : int ; lengthB := strB->size() ;
    var maxn : int ; maxn := 0 ;
        var i : int ; i := 0 ; while i < lengthA do ( (     var n : int ; n := 0 ;
     var p : int ; p := 0 ;
     while (p < lengthA & i + p < lengthB) do (     if (strA[p+1] = strB[i + p+1]) then (     n := n + 1 ; 
     if (maxn < n) then     maxn := n ; else skip ) else (     n := 0 ) ;  
     p := p + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < lengthB do ( (     var n : int ; n := 0 ;
     var p : int ; p := 0 ;
     while (p < lengthB & i + p < lengthA) do (     if (strB[p+1] = strA[i + p+1]) then (     n := n + 1 ; 
     if (maxn < n) then     maxn := n ; else skip ) else (     n := 0 ) ;  
     p := p + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(maxn) ; 
    str := br.readLine() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      String a=scan.next();
      String b=scan.next();
      System.out.println(run(a,b));
    }
    scan.close();
    System.exit(0);
  }
  private static int run(String a,String b){
    return Math.max(len(a,b),len(b,a));
  }
  private static int len(String a,String b){
    int max=0 ;
    for(int i=0 ; i<=a.length(); i++){
      int c=0 ;
      for(int j=i,k=0 ; j<a.length()&& k<b.length(); j++,k++)if(a.charAt(j)==b.charAt(k))c++;
      else {
        if(c>max)max=c ;
        c=0 ;
      }
      if(c>max)max=c ;
    }
    return max ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var a : String ; a := scan.getCurrent() ;
     var b : String ; b := scan.getCurrent() ;
     OclFile["System.out"].println(run(a, b)) ) ; 
     skip ; 
 OclProcess.exit(0) );
  static   operation run( a : String, b : String) : int
  pre: true
  post: true
  activity: (     return Set{len(a, b), len(b, a)}->max() );
  static   operation len( a : String, b : String) : int
  pre: true
  post: true
  activity: (     var max : int ; max := 0 ;
         var i : int ; i := 0 ; while i <= a->size() do ( (     var c : int ; c := 0 ;
         var j : int ; j := i ;
    var k : int ; k := 0 ; while j < a->size() & k < b->size() do (     if (a->at(j+1) = b->at(k+1)) then     c := c + 1 else (     if (c > max) then     max := c ; else skip ; 
     c := 0 ) ;   ;     j := j + 1 ;     k := k + 1 ) ; 
     if (c > max) then     max := c ; else skip )  ;     i := i + 1 ) ; 
     return max );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int count(int n){
    int cnt=0 ;
    int p=1 ;
    while(p<=n){
      cnt++;
      p*=2 ;
    }
    return cnt ;
  }
  public static void main(String args[]){
    int n=7 ;
    System.out.print(count(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation count( n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var p : int ; p := 1 ;
     while (p <= n) do (     cnt := cnt + 1 ; 
     p := p*(2) ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     OclFile["System.out"].print(count(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Codeforces {
  static int res ;
  public static int dfs(int node,String[] arr){
    int cur=0,l=0,r=0 ;
    if(node-2>=0)cur=Integer.parseInt(arr[node-2]);
    if((2*node)-2<arr.length)l=dfs(2*node,arr);
    if((2*node)-1<arr.length)r=dfs((2*node)+1,arr);
    if(Math.abs(l-r)>0)res+=Math.abs(l-r);
    return Math.max(l,r)+cur ;
  }
  public static void main(String[] args)throws Exception {
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    res=0 ;
    int n=Integer.parseInt(bf.readLine());
    String[] input=bf.readLine().split(" ");
    int m=input.length ;
    dfs(1,input);
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   attribute res : int;
  static   operation dfs( node : int, arr : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var cur : int ; cur := 0 ;
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
     if (node - 2 >= 0) then     cur := (arr[node - 2+1])->toInteger() ; else skip ; 
    if ((2 * node) - 2 < arr->size()) then     l := dfs(2 * node, arr) ; else skip ; 
    if ((2 * node) - 1 < arr->size()) then     r := dfs((2 * node) + 1, arr) ; else skip ; 
    if (if l - r < 0 then -(l - r) else l - r endif > 0) then     res := res+(if l - r < 0 then -(l - r) else l - r endif) ; else skip ; 
    return Set{l, r}->max() + cur 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     res := 0 ; 
    var n : int ; n := (bf.readLine())->toInteger() ;
    var input : Sequence(String) ; input := bf.readLine()->split(" ") ;
    var m : int ; m := input->size() ;
    execute dfs(1, input) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
import java.util.Map.*;
public class Main {
  static BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  static StreamTokenizer sc=new StreamTokenizer(in);
  static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
  static Scanner scan=new Scanner(System.in);
  static int zhong[]={
-1,1,0,0,-1,-1,1,1 };
    static int hen[]={
      0,0,-1,1,-1,1,-1,1 };
      static int inf=Integer.MAX_VALUE ;
      static int N=(int)2e3 ;
      public static void main(String[] args)throws IOException {
        int n=ini();
        int t=(1<<(n+1))-1 ;
        int a[]=new int[t+10];
        for(int i=2 ; i<=t ; i++){
          a[i]=ini();
        }
        long ans=0 ;
        for(int i=(t>>1); i>=1 ; i--){
          a[i]+=Math.max(a[i<<1],a[i<<1 | 1]);
          ans+=Math.abs(a[i<<1]-a[i<<1 | 1]);
        }
        out.println(ans);
        out.flush();
      }
      static int ini()throws IOException {
        sc.nextToken();
        return(int)sc.nval ;
      }
      static long inl()throws IOException {
        sc.nextToken();
        return(long)sc.nval ;
      }
      static double ind()throws IOException {
        sc.nextToken();
        return sc.nval ;
      }
      static String ins()throws IOException {
        sc.nextToken();
        return sc.sval ;
      }
      static String rel()throws IOException {
        return in.readLine();
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute sc : StreamTokenizer := StreamTokenizer.newStreamTokenizer(in);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute zhong : int := Sequence{-1,1,0,0,-1,-1,1,1};
  static   attribute hen : int := Sequence{0,0,-1,1,-1,1,-1,1};
  static   attribute inf : int := 2147483647;
  static   attribute N : int := 2e3->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := ini() ;
     var t : int ; t := ((1*(2->pow((n + 1))))->oclAsType(long)) - 1 ;
    var a : Sequence(int) ; a := Integer.subrange(1,t + 10)->collect(0) ;
        var i : int ; i := 2 ; while i <= t do ( (     a[i+1] := ini() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := ((t/(2->pow(1)))->oclAsType(long)) ; while i >= 1 do ( (     a[i+1] := a[i+1]+(Set{a[(i*(2->pow(1)))->oclAsType(long)+1], a[MathLib.bitwiseOr((i*(2->pow(1)))->oclAsType(long),1)+1]}->max()) ; 
     ans := ans+(if a[(i*(2->pow(1)))->oclAsType(long)+1] - a[MathLib.bitwiseOr((i*(2->pow(1)))->oclAsType(long),1)+1] < 0 then -(a[(i*(2->pow(1)))->oclAsType(long)+1] - a[MathLib.bitwiseOr((i*(2->pow(1)))->oclAsType(long),1)+1]) else a[(i*(2->pow(1)))->oclAsType(long)+1] - a[MathLib.bitwiseOr((i*(2->pow(1)))->oclAsType(long),1)+1] endif) )  ;     i := i - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation ini() : int
  pre: true
  post: true
  activity: (     sc.next() ; 
     return sc.nval->oclAsType(int) );
  static   operation inl() : long
  pre: true
  post: true
  activity: (     sc.next() ; 
     return sc.nval->oclAsType(long) );
  static   operation ind() : double
  pre: true
  post: true
  activity: (     sc.next() ; 
     return sc.nval );
  static   operation ins() : String
  pre: true
  post: true
  activity: (     sc.next() ; 
     return sc.sval );
  static   operation rel() : String
  pre: true
  post: true
  activity: (     return in.readLine() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
import java.util.Map.*;
public class Main {
  static BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  static StreamTokenizer sc=new StreamTokenizer(in);
  static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
  static Scanner scan=new Scanner(System.in);
  static int zhong[]={
-1,1,0,0,-1,-1,1,1 };
    static int hen[]={
      0,0,-1,1,-1,1,-1,1 };
      static int inf=Integer.MAX_VALUE ;
      static int N=(int)2e3 ;
      public static void main(String[] args)throws IOException {
        int n=ini();
        int t=(1<<(n+1))-1 ;
        int a[]=new int[t+10];
        for(int i=2 ; i<=t ; i++){
          a[i]=ini();
        }
        long ans=0 ;
        for(int i=(t>>1); i>=1 ; i--){
          a[i]+=Math.max(a[i<<1],a[i<<1 | 1]);
          ans+=Math.abs(a[i<<1]-a[i<<1 | 1]);
        }
        out.println(ans);
        out.flush();
      }
      static int ini()throws IOException {
        sc.nextToken();
        return(int)sc.nval ;
      }
      static long inl()throws IOException {
        sc.nextToken();
        return(long)sc.nval ;
      }
      static double ind()throws IOException {
        sc.nextToken();
        return sc.nval ;
      }
      static String ins()throws IOException {
        sc.nextToken();
        return sc.sval ;
      }
      static String rel()throws IOException {
        return in.readLine();
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute sc : StreamTokenizer := StreamTokenizer.newStreamTokenizer(in);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute zhong : int := Sequence{-1,1,0,0,-1,-1,1,1};
  static   attribute hen : int := Sequence{0,0,-1,1,-1,1,-1,1};
  static   attribute inf : int := 2147483647;
  static   attribute N : int := 2e3->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := ini() ;
     var t : int ; t := ((1*(2->pow((n + 1))))->oclAsType(long)) - 1 ;
    var a : Sequence(int) ; a := Integer.subrange(1,t + 10)->collect(0) ;
        var i : int ; i := 2 ; while i <= t do ( (     a[i+1] := ini() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := ((t/(2->pow(1)))->oclAsType(long)) ; while i >= 1 do ( (     a[i+1] := a[i+1]+(Set{a[(i*(2->pow(1)))->oclAsType(long)+1], a[MathLib.bitwiseOr((i*(2->pow(1)))->oclAsType(long),1)+1]}->max()) ; 
     ans := ans+(if a[(i*(2->pow(1)))->oclAsType(long)+1] - a[MathLib.bitwiseOr((i*(2->pow(1)))->oclAsType(long),1)+1] < 0 then -(a[(i*(2->pow(1)))->oclAsType(long)+1] - a[MathLib.bitwiseOr((i*(2->pow(1)))->oclAsType(long),1)+1]) else a[(i*(2->pow(1)))->oclAsType(long)+1] - a[MathLib.bitwiseOr((i*(2->pow(1)))->oclAsType(long),1)+1] endif) )  ;     i := i - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation ini() : int
  pre: true
  post: true
  activity: (     sc.next() ; 
     return sc.nval->oclAsType(int) );
  static   operation inl() : long
  pre: true
  post: true
  activity: (     sc.next() ; 
     return sc.nval->oclAsType(long) );
  static   operation ind() : double
  pre: true
  post: true
  activity: (     sc.next() ; 
     return sc.nval );
  static   operation ins() : String
  pre: true
  post: true
  activity: (     sc.next() ; 
     return sc.sval );
  static   operation rel() : String
  pre: true
  post: true
  activity: (     return in.readLine() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Games {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.nextLine());
    int result=0 ;
    int[] h=new int[n];
    int[] g=new int[n];
    for(int i=0 ; i<n ; i++){
      h[i]=sc.nextInt();
      g[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)if(h[i]==g[j])result++;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Games {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.nextLine())->toInteger() ;
    var result : int ; result := 0 ;
    var h : Sequence(int) ; h := Integer.subrange(1,n)->collect(0) ;
    var g : Sequence(int) ; g := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     h[i+1] := sc.getCurrent()->toInteger() ; 
     g[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (     if (h[i+1] = g[j+1]) then     result := result + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      String st[]=in.next().split("\\+");
      String st2[]=st[1] .split("=");
      String a=st[0];
      String b=st2[0];
      String c=st2[1];
      int ans=-1 ;
      for(int i=0 ; i<10 ; i++){
        String x=a ;
        String y=b ;
        String z=c ;
        if(i==0){
          if(x.length()>1)if(x.charAt(0)=='X')continue ;
          if(y.length()>1)if(y.charAt(0)=='X')continue ;
          if(z.length()>1)if(z.charAt(0)=='X')continue ;
        }
        x=x.replaceAll("X",String.valueOf(i));
        y=y.replaceAll("X",String.valueOf(i));
        z=z.replaceAll("X",String.valueOf(i));
        BigInteger x2=new BigInteger(x);
        BigInteger y2=new BigInteger(y);
        BigInteger z2=new BigInteger(z);
        if((x2.add(y2)).equals(z2)){
          ans=i ;
          break ;
        }
      }
      System.out.println(ans==-1 ? "NA" : ans);
    }
  }
  static public void debug(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var st : Sequence(String) ; st := in.getCurrent()->split("\\+") ;
     var st2 : Sequence(String) ; st2 := st[1+1]->split("=") ;
    var a : String ; a := st[0+1] ;
    var b : String ; b := st2[0+1] ;
    var c : String ; c := st2[1+1] ;
    var ans : int ; ans := -1 ;
        var i : int ; i := 0 ; while i < 10 do ( (     var x : String ; x := a ;
     var y : String ; y := b ;
    var z : String ; z := c ;
    if (i = 0) then (     if (x->size() > 1) then     if (x->at(0+1) = 'X') then     continue else skip ; else skip ; 
     if (y->size() > 1) then     if (y->at(0+1) = 'X') then     continue else skip ; else skip ; 
     if (z->size() > 1) then     if (z->at(0+1) = 'X') then     continue else skip ; else skip ) else skip ; 
    x := x.replaceAllMatches("X", ((i) + "") ) ; 
    y := y.replaceAllMatches("X", ((i) + "") ) ; 
    z := z.replaceAllMatches("X", ((i) + "") ) ; 
    var x2 : long ; x2 := long(x) ;
    var y2 : long ; y2 := long(y) ;
    var z2 : long ; z2 := long(z) ;
    if ((x2->excludes(y2)) = z2) then (     ans := i ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if ans = -1 then "NA" else ans endif) ; 
 ) );
  static    operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      System.out.println(Math.max(sc.nextInt()+sc.nextInt(),sc.nextInt()+sc.nextInt()));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     OclFile["System.out"].println(Set{sc.getCurrent()->toInteger() + sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger() + sc.getCurrent()->toInteger()}->max()) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.*;
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
import javax.naming.BinaryRefAddr ;
public class Main {
  int k,ans ;
  boolean[] used ;
  private void dfs(int deep){
    if(deep==k){
      ans++;
    }
    for(int i=0 ; i<k ; i++){
      if(deep==i)continue ;
      if(used[i])continue ;
      used[i]=true ;
      dfs(deep+1);
      used[i]=false ;
    }
  }
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String[] s=sc.next().split("[\\+=] ");
      BigInteger[] b=new BigInteger[s.length];
      boolean flg=true ;
      for(int num=0 ; num<=9 ; num++){
        if(num==0){
          boolean f=true ;
          for(int i=0 ; i<s.length ; i++){
            if(s[i] .length()>1 && s[i] .charAt(0)=='X'){
              f=false ;
              break ;
            }
          }
          if(! f)continue ;
        }
        for(int i=0 ; i<s.length ; i++){
          b[i]=new BigInteger(s[i] .replaceAll("X",num+""));
        }
        if(b[2] .compareTo(b[1] .add(b[0]))==0){
          System.out.println(num);
          flg=false ;
          break ;
        }
      }
      if(flg){
        System.out.println("NA");
      }
    }
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute k : int;
   attribute used : Sequence(boolean);
   operation dfs( deep : int) : void
  pre: true
  post: true
  activity: (     if (deep = k) then (     ans := ans + 1 ) else skip ; 
         var i : int ; i := 0 ; while i < k do ( (     if (deep = i) then     continue else skip ; 
     if (used[i+1]) then     continue else skip ; 
    used[i+1] := true ; 
    execute dfs(deep + 1) ; 
    used[i+1] := false ; 
 )  ;     i := i + 1 ) );
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var s : Sequence(String) ; s := sc.getCurrent()->split("[\\+=] ") ;
     var b : Sequence(long) ; b := Integer.subrange(1,s->size())->collect(null) ;
    var flg : boolean ; flg := true ;
        var num : int ; num := 0 ; while num <= 9 do ( (     if (num = 0) then (     var f : boolean ; f := true ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s[i+1]->size() > 1 & s[i+1]->at(0+1) = 'X') then (     f := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (not(f)) then     continue else skip ) else skip ; 
         var i : int ; i := 0 ; while i < s->size() do ( (     b[i+1] := long(s[i+1].replaceAllMatches("X", num + "" )) )  ;     i := i + 1 ) ; 
     if (b[2+1]->compareTo(b[1+1]->excludes(b[0+1])) = 0) then (     OclFile["System.out"].println(num) ; 
     flg := false ; 
     break ) else skip )  ;     num := num + 1 ) ; 
    if (flg) then (     OclFile["System.out"].println("NA") ) else skip ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static char[] s ;
  static int id ;
  static boolean exp(){
    int a=fact();
    if(a==-1)return false ;
    while(true){
      char c=s[id++];
      if(c=='=')break ;
      int x=fact();
      if(x==-1)return false ;
      a+=x ;
    }
    int b=fact();
    if(b==-1)return false ;
    return a==b ;
  }
  static int fact(){
    int x=s[id++]-'0' ;
    if(x==0 && Character.isDigit(s[id]))return-1 ;
    while(Character.isDigit(s[id])){
      x*=10 ;
      x+=s[id++]-'0' ;
    }
    return x ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String r=sc.next();
      String ans="NA" ;
      for(int i=0 ; i<10 ; i++){
        s=(r.replace("X",(char)(i+'0')+"")+"$").toCharArray();
        id=0 ;
        if(exp()){
          ans=i+"" ;
          break ;
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : Sequence(String);
  static   attribute id : int;
  static   operation exp() : boolean
  pre: true
  post: true
  activity: (     var a : int ; a := fact() ;
     if (a = -1) then     return false else skip ; 
    while (true) do (     var c : String ; c := s[id+1] ;
     if (c = '=') then     break else skip ; 
    var x : int ; x := fact() ;
    if (x = -1) then     return false else skip ; 
    a := a+(x) ; 
 ) ; 
    var b : int ; b := fact() ;
    if (b = -1) then     return false else skip ; 
    return a = b 
 );
  static   operation fact() : int
  pre: true
  post: true
  activity: (     var x : int ; x := s[id+1] - ('0')->char2byte() ;
     if (x = 0 & (s[id+1] + "")->isMatch("[0-9]")) then     return -1 else skip ; 
     while ((s[id+1] + "")->isMatch("[0-9]")) do (     x := x*(10) ; 
      x := x + s[id+1] - ('0')->char2byte()  ; id := id + 1 ) ; 
     return x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var r : String ; r := sc.getCurrent() ;
     var ans : String ; ans := "NA" ;
         var i : int ; i := 0 ; while i < 10 do ( (     s := (r.replace("X", (i + '0')->oclAsType(String) + "") + "$")->characters() ; 
     id := 0 ; 
     if (exp()) then (     ans := i + "" ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.util.*;
import java.io.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    try {
      System.setIn(new FileInputStream("src/aoj0110/input.txt"));
      System.setOut(new PrintStream(new FileOutputStream("src/aojxxxx/result.txt")));
    }
    catch(FileNotFoundException e){
    }
    new Main().run();
  }
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; sc.hasNext(); ){
      String str=sc.next();
      str=str.replace('+','=');
      String[] ss=str.split("=");
      int ans=-1 ;
      for(int x=0 ; x<10 ; x++){
        String A=ss[0] .replace('X',(char)('0'+x));
        String B=ss[1] .replace('X',(char)('0'+x));
        String C=ss[2] .replace('X',(char)('0'+x));
        if(new BigInteger(A).add(new BigInteger(B)).equals(new BigInteger(C))){
          if(A.length()>=2 && A.charAt(0)=='0' || B.length()>=2 && B.charAt(0)=='0' || C.length()>=2 && C.charAt(0)=='0'){
          }
          else {
            ans=x ;
          }
        }
      }
      if(ans==-1)System.out.println("NA");
      else System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("src/aoj0110/input.txt"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("src/aojxxxx/result.txt")))) )   catch (e : FileNotFoundException) do skip
     Main.newMain().run() );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var str : String ; str := sc.getCurrent() ;
     str := str.replace('+', '=') ; 
    var ss : Sequence(String) ; ss := str->split("=") ;
    var ans : int ; ans := -1 ;
        var x : int ; x := 0 ; while x < 10 do ( (     var A : String ; A := ss[0+1].replace('X', ('0' + x)->oclAsType(String)) ;
     var B : String ; B := ss[1+1].replace('X', ('0' + x)->oclAsType(String)) ;
     var C : String ; C := ss[2+1].replace('X', ('0' + x)->oclAsType(String)) ;
     if (long(A)->excludes(long(B)) = long(C)) then (     if (A->size() >= 2 & A->at(0+1) = '0' or B->size() >= 2 & B->at(0+1) = '0' or C->size() >= 2 & C->at(0+1) = '0') then skip else (     ans := x ) ) else skip )  ;     x := x + 1 ) ; 
    if (ans = -1) then     OclFile["System.out"].println("NA") else     OclFile["System.out"].println(ans) ; ;  
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String str=br.readLine();
      if(str==null){
        break ;
      }
      String[] tmpArray=str.split("\\+");
      String str1=tmpArray[0];
      tmpArray=tmpArray[1] .split("=");
      String str2=tmpArray[0];
      String str3=tmpArray[1];
      boolean solve=false ;
      for(int i=0 ; i<=9 ; i++){
        BigInteger a=replaceXtoNumber(str1,i);
        BigInteger b=replaceXtoNumber(str2,i);
        BigInteger c=replaceXtoNumber(str3,i);
        if(a!=null && b!=null && c!=null){
          if(a.add(b).compareTo(c)==0){
            System.out.println(i);
            solve=true ;
            break ;
          }
        }
      }
      if(! solve){
        System.out.println("NA");
      }
    }
  }
  static BigInteger replaceXtoNumber(String str,int n){
    if(str.length()>=2 && str.charAt(0)=='X' && n==0){
      return null ;
    }
    String tmp=new String(str);
    tmp=tmp.replace('X',(char)('0'+n));
    return new BigInteger(tmp);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var str : String ; str := br.readLine() ;
     if (str = null) then (     break ) else skip ; 
    var tmpArray : Sequence(String) ; tmpArray := str->split("\\+") ;
    var str1 : String ; str1 := tmpArray[0+1] ;
    tmpArray := tmpArray[1+1]->split("=") ; 
    var str2 : String ; str2 := tmpArray[0+1] ;
    var str3 : String ; str3 := tmpArray[1+1] ;
    var solve : boolean ; solve := false ;
        var i : int ; i := 0 ; while i <= 9 do ( (     var a : long ; a := replaceXtoNumber(str1, i) ;
     var b : long ; b := replaceXtoNumber(str2, i) ;
     var c : long ; c := replaceXtoNumber(str3, i) ;
     if (a /= null & b /= null & c /= null) then (     if (a->excludes(b)->compareTo(c) = 0) then (     OclFile["System.out"].println(i) ; 
     solve := true ; 
     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (not(solve)) then (     OclFile["System.out"].println("NA") ) else skip ; 
 ) );
  static   operation replaceXtoNumber( str : String, n : int) : long
  pre: true
  post: true
  activity: (     if (str->size() >= 2 & str->at(0+1) = 'X' & n = 0) then (     return null ) else skip ; 
     var tmp : String ; tmp := StringLib.newString(str) ;
     tmp := tmp.replace('X', ('0' + n)->oclAsType(String)) ; 
     return long(tmp) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double square(double a){
    if(a<0)return-1 ;
    double x=0.464*a ;
    return x ;
  }
  public static void main(String[] args){
    double a=5 ;
    System.out.println(square(a));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation square( a : double) : double
  pre: true
  post: true
  activity: (     if (a < 0) then     return -1 else skip ; 
     var x : double ; x := 0.464 * a ;
     return x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 5 ;
     OclFile["System.out"].println(square(a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
public class CD2B38 {
  public static void main(String args[])throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String input1[]=br.readLine().split(" ");
    int n=Integer.parseInt(input1[0]);
    int m=Integer.parseInt(input1[1]);
    int d=Integer.parseInt(input1[2]);
    int data[]=new int[n*m];
    for(int i=0 ; i<n ; i++){
      input1=br.readLine().split(" ");
      for(int j=0 ; j<m ; j++){
        data[i*m+j]=Integer.parseInt(input1[j]);
      }
    }
    int len=n*m ;
    boolean np=false ;
    for(int i=0 ; i<len ; i++){
      if(data[i] % d!=data[0] % d){
        np=true ;
        break ;
      }
    }
    if(np){
      System.out.println(-1);
    }
    else {
      Arrays.sort(data);
      int med=len/2 ;
      int ans=0 ;
      for(int i=0 ; i<len ; i++){
        ans+=(Math.max(data[med],data[i])-Math.min(data[med],data[i]))/d ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CD2B38 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input1 : Sequence(String) ; input1 := br.readLine()->split(" ") ;
    var n : int ; n := (input1[0+1])->toInteger() ;
    var m : int ; m := (input1[1+1])->toInteger() ;
    var d : int ; d := (input1[2+1])->toInteger() ;
    var data : Sequence(int) ; data := Integer.subrange(1,n * m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     input1 := br.readLine()->split(" ") ; 
         var j : int ; j := 0 ; while j < m do ( (     data[i * m + j+1] := (input1[j+1])->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var len : int ; len := n * m ;
    var np : boolean ; np := false ;
        var i : int ; i := 0 ; while i < len do ( (     if (data[i+1] mod d /= data[0+1] mod d) then (     np := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (np) then (     OclFile["System.out"].println(-1) ) else (     data := data->sort() ; 
     var med : int ; med := len / 2 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < len do ( (     ans := ans+((Set{data[med+1], data[i+1]}->max() - Set{data[med+1], data[i+1]}->min()) / d) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.*;
public class temp {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int d=sc.nextInt();
    int aa[]=new int[n*m];
    int bb[]=new int[n*m];
    int idx=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        aa[idx]=sc.nextInt();
        bb[idx]=aa[idx];
        idx++;
      }
    }
    int mindiff=Integer.MAX_VALUE ;
    boolean flag=false ;
    for(int i=0 ; i<n*m ; i++){
      int diff=0 ;
      for(int j=0 ; j<n*m ; j++){
        if(i!=j){
          int currdiff=Math.abs(aa[i]-bb[j]);
          if((currdiff % d)!=0){
            flag=true ;
            break ;
          }
          else {
            diff+=currdiff/d ;
          }
        }
      }
      if(mindiff>diff){
        mindiff=diff ;
      }
    }
    if(! flag){
      System.out.println(mindiff);
    }
    else {
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class temp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var aa : Sequence(int) ; aa := Integer.subrange(1,n * m)->collect(0) ;
    var bb : Sequence(int) ; bb := Integer.subrange(1,n * m)->collect(0) ;
    var idx : int ; idx := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     aa[idx+1] := sc.getCurrent()->toInteger() ; 
     bb[idx+1] := aa[idx+1] ; 
     idx := idx + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var mindiff : int ; mindiff := 2147483647 ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < n * m do ( (     var diff : int ; diff := 0 ;
         var j : int ; j := 0 ; while j < n * m do ( (     if (i /= j) then (     var currdiff : int ; currdiff := if aa[i+1] - bb[j+1] < 0 then -(aa[i+1] - bb[j+1]) else aa[i+1] - bb[j+1] endif ;
     if ((currdiff mod d) /= 0) then (     flag := true ; 
     break ) else (     diff := diff+(currdiff / d) ) ) else skip )  ;     j := j + 1 ) ; 
     if (mindiff > diff) then (     mindiff := diff ) else skip )  ;     i := i + 1 ) ; 
    if (not(flag)) then (     OclFile["System.out"].println(mindiff) ) else (     OclFile["System.out"].println(-1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner a=new Scanner(System.in);
    int n=a.nextInt();
    int m=a.nextInt();
    int div=a.nextInt();
    int[] arr=new int[n*m];
    for(int i=0 ; i<arr.length ; i++)arr[i]=a.nextInt();
    Arrays.sort(arr);
    System.out.println(check(arr,div));
  }
  public static int check(int[] arr,int div){
    int mod=arr[0] % div ;
    for(int i=1 ; i<arr.length ; i++)if(arr[i] % div!=mod)return-1 ;
    int median=-1 ;
    if(arr.length % 2==1)median=arr[arr.length/2];
    else median=arr[(arr.length/2)-1];
    int ans=0 ;
    for(int i=0 ; i<arr.length ; i++){
      ans+=Math.abs(arr[i]-median);
    }
    return ans/div ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : OclFile ; a := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := a.getCurrent()->toInteger() ;
    var m : int ; m := a.getCurrent()->toInteger() ;
    var div : int ; div := a.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n * m)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do (     arr[i+1] := a.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    OclFile["System.out"].println(check(arr, div)) ; 
 );
  static   operation check( arr : Sequence(int), div : int) : int
  pre: true
  post: true
  activity: (     var mod : int ; mod := arr[0+1] mod div ;
         var i : int ; i := 1 ; while i < arr->size() do (     if (arr[i+1] mod div /= mod) then     return -1 else skip ;  ;     i := i + 1 ) ; 
    var median : int ; median := -1 ;
    if (arr->size() mod 2 = 1) then     median := arr[arr->size() / 2+1] else     median := arr[(arr->size() / 2) - 1+1] ; ;  
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     ans := ans+(if arr[i+1] - median < 0 then -(arr[i+1] - median) else arr[i+1] - median endif) )  ;     i := i + 1 ) ; 
    return ans / div 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int numTeams=in.nextInt();
    int[] hosts=new int[numTeams];
    int[] guests=new int[numTeams];
    for(int i=0 ; i<numTeams ; i++){
      hosts[i]=in.nextInt();
      guests[i]=in.nextInt();
    }
    int ans=0 ;
    for(int i=0 ; i<numTeams ; i++){
      for(int j=0 ; j<numTeams ; j++){
        if(hosts[i]==guests[j])ans++;
      }
    }
    out.println(ans);
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new FileReader("sub.in"));
      }
      catch(FileNotFoundException ex){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException ex){
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException ex){
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var numTeams : int ; numTeams := in.nextInt() ;
    var hosts : Sequence(int) ; hosts := Integer.subrange(1,numTeams)->collect(0) ;
    var guests : Sequence(int) ; guests := Integer.subrange(1,numTeams)->collect(0) ;
        var i : int ; i := 0 ; while i < numTeams do ( (     hosts[i+1] := in.nextInt() ; 
     guests[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < numTeams do ( (         var j : int ; j := 0 ; while j < numTeams do ( (     if (hosts[i+1] = guests[j+1]) then     ans := ans + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("sub.in"))) )   catch (ex : FileNotFoundException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (ex : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (ex : IOException) do skip
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double pie=3.1415926535897 ;
  static double findsolution(double d,double h,double m,double n){
    double k=(4*m)/(pie*d*d);
    if(n>k)return-1 ;
    double ans=(h/(k-n));
    return ans ;
  }
  public static void main(String[] args){
    double d=1,h=1,m=1,n=1 ;
    System.out.printf("%.5f",findsolution(d,h,m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute pie : double := 3.1415926535897;
  static   operation findsolution( d : double, h : double, m : double, n : double) : double
  pre: true
  post: true
  activity: (     var k : double ; k := (4 * m) / (pie * d * d) ;
     if (n > k) then     return -1 else skip ; 
     var ans : double ; ans := (h / (k - n)) ;
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : double ; d := 1 ;
    var h : double ; h := 1 ;
    var m : double ; m := 1 ;
    var n : double ; n := 1 ;
     OclFile["System.out"].printf("%.5f", findsolution(d, h, m, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),k=in.nextInt();
    PriorityQueue<Long>pq=new PriorityQueue<>(Collections.reverseOrder());
    for(int i=0 ; i<n ; i++)pq.add(in.nextLong());
    PriorityQueue<Long>ans=new PriorityQueue<>();
    boolean notFirstTime=false ;
    ArrayList<Long>ans2=new ArrayList<>();
    while(! pq.isEmpty()){
      for(int i=0 ; i<k ; i++){
        if(pq.isEmpty())break ;
        if(notFirstTime){
          long v=pq.remove();
          long x=ans.remove();
          x+=v ;
          ans2.add(x);
          continue ;
        }
        ans.add(pq.remove());
        if(i==(k-1))notFirstTime=true ;
      }
    }
    if(ans.isEmpty())ans.add(-1L);
    if(ans2.isEmpty())ans2.add(-1L);
    long res=Collections.max(ans);
    long res2=Collections.max(ans2);
    pw.println(Math.max(res,res2));
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var pq : Sequence(long) ; pq := Sequence{}->union(reverseOrder()) ;
        var i : int ; i := 0 ; while i < n do (     pq := pq->including(in.getCurrent()->toLong()) ;  ;     i := i + 1 ) ; 
    var ans : Sequence(long) ; ans := Sequence{} ;
    var notFirstTime : boolean ; notFirstTime := false ;
    var ans2 : Sequence(long) ; ans2 := Sequence{} ;
    while (not(pq->isEmpty())) do (         var i : int ; i := 0 ; while i < k do ( (     if (pq->isEmpty()) then     break else skip ; 
     if (notFirstTime) then (     var v : long ; v := pq.remove() ;
     var x : long ; x := ans.remove() ;
    x := x+(v) ; 
    ans2 := ans2->including(x) ; 
    continue 
 ) else skip ; 
     ans := ans->including(pq.remove()) ; 
     if (i = (k - 1)) then     notFirstTime := true ; else skip )  ;     i := i + 1 ) ) ; 
    if (ans->isEmpty()) then     ans := ans->including(-1L) ; else skip ; 
    if (ans2->isEmpty()) then     ans2 := ans2->including(-1L) ; else skip ; 
    var res : long ; res := .max(ans) ;
    var res2 : long ; res2 := .max(ans2) ;
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class PalinInd {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int d=sc.nextInt();
      int s=a+b ;
      int s1=c+d ;
      if(s>s1)System.out.println(s);
      else System.out.println(s1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PalinInd {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var s : int ; s := a + b ;
    var s1 : int ; s1 := c + d ;
    if (s > s1) then     OclFile["System.out"].println(s) else     OclFile["System.out"].println(s1) ; ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Practice {
  static Scanner scn=new Scanner(System.in);
  static StringBuilder sb=new StringBuilder();
  public static void main(String[] ScoobyDoobyDo){
    int t=1 ;
    for(int tests=0 ; tests<t ; tests++)solve();
    System.out.println(sb);
  }
  public static void solve(){
    int n=scn.nextInt(),k=scn.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=scn.nextInt();
    long min=0,max=Long.MAX_VALUE,res=max ;
    for(long i : a)min=max(min,i);
    while(min<max){
      long mid=min+(max-min)/2 ;
      if(! possible(a,mid,k,n)){
        min=mid+1 ;
      }
      else {
        res=min(res,mid);
        max=mid ;
      }
    }
    sb.append(res);
    sb.append("\n");
  }
  public static boolean possible(long[] a,long mid,int k,int n){
    int i=0,j=n-1 ;
    while(i<=j){
      if(i==j){
        k--;
        i++;
      }
      else {
        if(a[i]+a[j]<=mid){
          i++;
          j--;
          k--;
        }
        else if(a[j]<=mid){
          j--;
          k--;
        }
        else {
          i++;
          k--;
        }
      }
    }
    return k>=0 ;
  }
  public static class Pair {
    long data ;
    int bells ;
    public Pair(long data,int bells){
      this.data=data ;
      this.bells=bells ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   attribute scn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute sb : String := StringLib.newString();
  static   operation main( ScoobyDoobyDo : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
         var tests : int ; tests := 0 ; while tests < t do (     execute solve() ;  ;     tests := tests + 1 ) ; 
     OclFile["System.out"].println(sb) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := scn.getCurrent()->toInteger() ;
    var k : int ; k := scn.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := scn.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var min : long ; min := 0 ;
    var max : long ; max := "9223372036854775807"->toLong() ;
    var res : long ; res := max ;
    for (i : a) do (     min := Set{min, i}->max() ;  ) ; 
    while (min < max) do (     var mid : long ; mid := min + (max - min) / 2 ;
     if (not(possible(a, mid, k, n))) then (     min := mid + 1 ) else (     res := Set{res, mid}->min() ; 
     max := mid ) ) ; 
    sb := sb + StringLib.newString(res) ; 
    sb := sb + StringLib.newString("\n") ; 
 );
  static   operation possible( a : Sequence(long), mid : long, k : int, n : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var j : int ; j := n - 1 ;
     while (i <= j) do (     if (i = j) then (     k := k - 1 ; 
     i := i + 1 ) else (     if (a[i+1] + a[j+1] <= mid) then (     i := i + 1 ; 
     j := j - 1 ; 
     k := k - 1 ) else     if (a[j+1] <= mid) then (     j := j - 1 ; 
     k := k - 1 ) else (     i := i + 1 ; 
     k := k - 1 ) ;  ) ) ; 
     return k >= 0 );
  static class Pair {
   attribute data : long;
   attribute bells : int;
   static operation newPair( data : long, bells : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(data, bells);
    return self );
  operation initialise( data : long, bells : int) : void
  pre: true  post: true
  activity: (     self.data := data ; 
     self.bells := bells );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX_LEN=1005 ;
  static int MAX_CHAR=26 ;
  static int[][] cnt=new int[MAX_LEN][MAX_CHAR];
  static void preProcess(String s){
    int n=s.length();
    for(int i=0 ; i<n ; i++)cnt[i][s.charAt(i)-'a']++;
    for(int i=1 ; i<n ; i++){
      for(int j=0 ; j<26 ; j++)cnt[i][j]+=cnt[i-1][j];
    }
  }
  static int findCharFreq(int l,int r,char c){
    return(cnt[r][(c)-97]-cnt[l][(c)-97]);
  }
  public static void main(String[] args){
    String s="geeksforgeeks" ;
    int Q=4 ;
    preProcess(s);
    System.out.println(findCharFreq(0,5,'e'));
    System.out.println(findCharFreq(2,6,'f'));
    System.out.println(findCharFreq(4,7,'m'));
    System.out.println(findCharFreq(0,12,'e'));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX_LEN : int := 1005;
  static   attribute MAX_CHAR : int := 26;
  static   attribute cnt : Sequence(Sequence(int)) := Integer.subrange(1,MAX_LEN)->collect(Integer.subrange(1,MAX_CHAR)->collect(0));
  static   operation preProcess( s : String) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
         var i : int ; i := 0 ; while i < n do (     cnt[i+1][s->at(i+1) - ('a')->char2byte()+1] := cnt[i+1][s->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 0 ; while j < 26 do (     cnt[i+1][j+1] := cnt[i+1][j+1]+(cnt[i - 1+1][j+1]) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation findCharFreq( l : int, r : int, c : String) : int
  pre: true
  post: true
  activity: (     return (cnt[r+1][(c) - 97+1] - cnt[l+1][(c) - 97+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     var Q : int ; Q := 4 ;
    execute preProcess(s) ; 
    OclFile["System.out"].println(findCharFreq(0, 5, 'e')) ; 
    OclFile["System.out"].println(findCharFreq(2, 6, 'f')) ; 
    OclFile["System.out"].println(findCharFreq(4, 7, 'm')) ; 
    OclFile["System.out"].println(findCharFreq(0, 12, 'e')) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countSub(int arr[],int n,int x){
    int st=0 ;
    int end=0 ;
    int sum=0 ;
    int cnt=0 ;
    while(end<n){
      sum+=arr[end];
      while(st<=end && sum>x){
        sum-=arr[st];
        st++;
      }
      cnt+=(end-st+1);
      end++;
    }
    return cnt ;
  }
  static int findSubSumLtoR(int arr[],int n,int L,int R){
    int Rcnt=countSub(arr,n,R);
    int Lcnt=countSub(arr,n,L-1);
    return Rcnt-Lcnt ;
  }
  public static void main(String[] args){
    int arr[]={
      1,4,6 };
      int n=arr.length ;
      int L=3 ;
      int R=8 ;
      System.out.println(findSubSumLtoR(arr,n,L,R));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSub( arr : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var st : int ; st := 0 ;
     var end : int ; end := 0 ;
    var sum : int ; sum := 0 ;
    var cnt : int ; cnt := 0 ;
    while (end < n) do (     sum := sum+(arr[end+1]) ; 
     while (st <= end & sum > x) do (     sum := sum-(arr[st+1]) ; 
     st := st + 1 ) ; 
     cnt := cnt+((end - st + 1)) ; 
     end := end + 1 ) ; 
    return cnt 
 );
  static   operation findSubSumLtoR( arr : Sequence(int), n : int, L : int, R : int) : int
  pre: true
  post: true
  activity: (     var Rcnt : int ; Rcnt := countSub(arr, n, R) ;
     var Lcnt : int ; Lcnt := countSub(arr, n, L - 1) ;
     return Rcnt - Lcnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,4,6} ;
     var n : int ; n := arr->size() ;
    var L : int ; L := 3 ;
    var R : int ; R := 8 ;
    OclFile["System.out"].println(findSubSumLtoR(arr, n, L, R)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long v=sc.nextLong();
    ArrayList<Integer>ans=new ArrayList<>();
    for(int i=1 ; i<=n ; i++){
      int obj=sc.nextInt();
      int count=0 ;
      for(int j=0 ; j<obj ; j++){
        Long s=sc.nextLong();
        if(v>s){
          count++;
        }
      }
      if(count>0)ans.add(i);
    }
    if(ans.size()==0)System.out.println("0");
    else {
      System.out.println(ans.size());
      for(Integer each : ans){
        System.out.print(each+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var v : long ; v := sc.getCurrent()->toLong() ;
    var ans : Sequence(int) ; ans := Sequence{} ;
        var i : int ; i := 1 ; while i <= n do ( (     var obj : int ; obj := sc.getCurrent()->toInteger() ;
     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < obj do ( (     var s : long ; s := sc.getCurrent()->toLong() ;
     if (v > s) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (count > 0) then     ans := ans->including(i) ; else skip )  ;     i := i + 1 ) ; 
    if (ans->size() = 0) then     OclFile["System.out"].println("0") else (     OclFile["System.out"].println(ans->size()) ; 
     for (each : ans) do ( (     OclFile["System.out"].print(each + " ") )  ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class probB {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),price=in.nextInt();
    ArrayList<Integer>l=new ArrayList<Integer>();
    for(int i=1 ; i<=n ; i++){
      int k=in.nextInt();
      int a[]=new int[k];
      for(int j=0 ; j<k ; j++){
        int v=in.nextInt();
        if(price>v){
          l.add(i);
        }
      }
    }
    HashSet<Integer>set=new HashSet<Integer>(l);
    l=new ArrayList<Integer>(set);
    pw.println(set.size());
    Collections.sort(l);
    for(int i=0 ; i<set.size(); i++){
      pw.print(l.get(i)+" ");
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class probB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var price : int ; price := in.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Sequence{} ;
        var i : int ; i := 1 ; while i <= n do ( (     var k : int ; k := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,k)->collect(0) ;
         var j : int ; j := 0 ; while j < k do ( (     var v : int ; v := in.getCurrent()->toInteger() ;
     if (price > v) then (     l := l->including(i) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{}->union(l) ;
    l := Sequence{}->union(set) ; 
    skip ; 
    l := l->sort() ; 
        var i : int ; i := 0 ; while i < set->size() do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
import java.util.*;
public class Test {
  static Scanner sc=new Scanner(System.in);
  static BufferedWriter write=new BufferedWriter(new OutputStreamWriter(System.out));
  static PrintWriter out=new PrintWriter(write);
  public static void main(String[] args)throws java.lang.Exception {
    long n=sc.nextLong();
    long v=sc.nextLong();
    ArrayList<Integer>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      int t=sc.nextInt();
      int x=-1 ;
      for(int j=0 ; j<t ; j++){
        long num=sc.nextLong();
        if(num<v)x=i+1 ;
      }
      if(x!=-1)list.add(x);
    }
    out.println(list.size());
    for(int i : list)out.print(i+" ");
    out.println();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute write : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(write);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.getCurrent()->toLong() ;
     var v : long ; v := sc.getCurrent()->toLong() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var x : int ; x := -1 ;
         var j : int ; j := 0 ; while j < t do ( (     var num : long ; num := sc.getCurrent()->toLong() ;
     if (num < v) then     x := i + 1 ; else skip )  ;     j := j + 1 ) ; 
     if (x /= -1) then     list := list->including(x) ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
    for (i : list) do (     skip ;  ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class MergeTwoSortedArrays {
  private static int nextGap(int gap){
    if(gap<=1)return 0 ;
    return(gap/2)+(gap % 2);
  }
  private static void merge(int[] arr1,int[] arr2,int n,int m){
    int i,j,gap=n+m ;
    for(gap=nextGap(gap); gap>0 ; gap=nextGap(gap)){
      for(i=0 ; i+gap<n ; i++)if(arr1[i]>arr1[i+gap]){
        int temp=arr1[i];
        arr1[i]=arr1[i+gap];
        arr1[i+gap]=temp ;
      }
      for(j=gap>n ? gap-n : 0 ; i<n && j<m ; i++,j++)if(arr1[i]>arr2[j]){
        int temp=arr1[i];
        arr1[i]=arr2[j];
        arr2[j]=temp ;
      }
      if(j<m){
        for(j=0 ; j+gap<m ; j++)if(arr2[j]>arr2[j+gap]){
          int temp=arr2[j];
          arr2[j]=arr2[j+gap];
          arr2[j+gap]=temp ;
        }
      }
    }
  }
  public static void main(String[] args){
    int[] a1={
      10,27,38,43,82 };
      int[] a2={
        3,9 };
        merge(a1,a2,a1.length,a2.length);
        System.out.print("First Array: ");
        for(int i=0 ; i<a1.length ; i++){
          System.out.print(a1[i]+" ");
        }
        System.out.println();
        System.out.print("Second Array: ");
        for(int i=0 ; i<a2.length ; i++){
          System.out.print(a2[i]+" ");
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
class MergeTwoSortedArrays {
  static   operation nextGap( gap : int) : int
  pre: true
  post: true
  activity: (     if (gap <= 1) then     return 0 else skip ; 
     return (gap / 2) + (gap mod 2) );
  static   operation merge( arr1 : Sequence(int), arr2 : Sequence(int), n : int, m : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var gap : int ; gap := n + m ;
         gap := nextGap(gap) ; while gap > 0 do ( (         i := 0 ; while i + gap < n do (     if (arr1[i+1] > arr1[i + gap+1]) then (     var temp : int ; temp := arr1[i+1] ;
     arr1[i+1] := arr1[i + gap+1] ; 
     arr1[i + gap+1] := temp ) else skip ;  ;     i := i + 1 ) ; 
         j := if gap > n then gap - n else 0 endif ; while i < n & j < m do (     if (arr1[i+1] > arr2[j+1]) then (     var temp : int ; temp := arr1[i+1] ;
     arr1[i+1] := arr2[j+1] ; 
     arr2[j+1] := temp ) else skip ;  ;     i := i + 1 ;     j := j + 1 ) ; 
     if (j < m) then (         j := 0 ; while j + gap < m do (     if (arr2[j+1] > arr2[j + gap+1]) then (     var temp : int ; temp := arr2[j+1] ;
     arr2[j+1] := arr2[j + gap+1] ; 
     arr2[j + gap+1] := temp ) else skip ;  ;     j := j + 1 ) ) else skip )  ;     gap := nextGap(gap) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a1 : Sequence(int) ; a1 := Sequence{10,27,38,43,82} ;
     var a2 : Sequence(int) ; a2 := Sequence{3,9} ;
    execute merge(a1, a2, a1->size(), a2->size()) ; 
    OclFile["System.out"].print("First Array: ") ; 
        var i : int ; i := 0 ; while i < a1->size() do ( (     OclFile["System.out"].print(a1[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    OclFile["System.out"].print("Second Array: ") ; 
        var i : int ; i := 0 ; while i < a2->size() do ( (     OclFile["System.out"].print(a2[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int z=n*2 ;
    int c=0 ;
    int arr[]=new int[z];
    ArrayList<Integer>ff=new ArrayList<>();
    ArrayList<Integer>ss=new ArrayList<>();
    while(n-->0){
      ff.add(sc.nextInt());
      ss.add(sc.nextInt());
    }
    int pp=ff.size();
    for(int i=0 ; i<pp ; i++){
      for(int j=0 ; j<pp ; j++){
        if(ff.get(i)==ss.get(j)){
          c++;
        }
      }
    }
    System.out.print(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var z : int ; z := n * 2 ;
    var c : int ; c := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,z)->collect(0) ;
    var ff : Sequence(int) ; ff := Sequence{} ;
    var ss : Sequence(int) ; ss := Sequence{} ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     ff := ff->including(sc.getCurrent()->toInteger()) ; 
     ss := ss->including(sc.getCurrent()->toInteger()) ) ;  ) ;  
    var pp : int ; pp := ff->size() ;
        var i : int ; i := 0 ; while i < pp do ( (         var j : int ; j := 0 ; while j < pp do ( (     if (ff->at(i+1) = ss->at(j+1)) then (     c := c + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int countunsetbits(int n){
    int count=0 ;
    for(int x=1 ; x<=n ; x=x<<1)if((x & n)==0)count++;
    return count ;
  }
  public static void main(String[] args){
    int n=17 ;
    System.out.println(countunsetbits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countunsetbits( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var x : int ; x := 1 ; while x <= n do (     if ((MathLib.bitwiseAnd(x,n)) = 0) then     count := count + 1 ; else skip ;  ;     x := (x*(2->pow(1)))->oclAsType(long) ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 17 ;
     OclFile["System.out"].println(countunsetbits(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int findMaxRec(int A[],int n){
    if(n==1)return A[0];
    return Math.max(A[n-1],findMaxRec(A,n-1));
  }
  public static void main(String args[]){
    int A[]={
      1,4,45,6,-50,10,2 };
      int n=A.length ;
      System.out.println(findMaxRec(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMaxRec( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return A[0+1] else skip ; 
     return Set{A[n - 1+1], findMaxRec(A, n - 1)}->max() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{1,4,45,6,-50,10,2} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].println(findMaxRec(A, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int[][] dp=new int[1001][1001];
  static int find_max(int i,int sum,int[] v,int k){
    if(i==v.length)return 0 ;
    if(dp[i][sum]!=-1)return dp[i][sum];
    int ans=0 ;
    if((sum+find_max(i+1,sum,v,k))% k==0)ans=find_max(i+1,sum,v,k);
    if((sum+v[i]+find_max(i+1,(sum+v[i])% k,v,k))% k==0)ans=Math.max(ans,v[i]+find_max(i+1,(sum+v[i])% k,v,k));
    return dp[i][sum]=ans ;
  }
  public static void main(String[] args){
    int[] arr={
      43,1,17,26,15 };
      int k=16 ;
      for(int i=0 ; i<1001 ; i++)for(int j=0 ; j<1001 ; j++)dp[i][j]=-1 ;
      System.out.print(find_max(0,0,arr,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute dp : Sequence(Sequence(int)) := Integer.subrange(1,1001)->collect(Integer.subrange(1,1001)->collect(0));
  static   operation find_max( i : int, sum : int, v : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     if (i = v->size()) then     return 0 else skip ; 
     if (dp[i+1][sum+1] /= -1) then     return dp[i+1][sum+1] else skip ; 
    var ans : int ; ans := 0 ;
    if ((sum + find_max(i + 1, sum, v, k)) mod k = 0) then     ans := find_max(i + 1, sum, v, k) ; else skip ; 
    if ((sum + v[i+1] + find_max(i + 1, (sum + v[i+1]) mod k, v, k)) mod k = 0) then     ans := Set{ans, v[i+1] + find_max(i + 1, (sum + v[i+1]) mod k, v, k)}->max() ; else skip ; 
    return dp[i+1][sum+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{43,1,17,26,15} ;
     var k : int ; k := 16 ;
         var i : int ; i := 0 ; while i < 1001 do (         var j : int ; j := 0 ; while j < 1001 do (     dp[i+1][j+1] := -1 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(find_max(0, 0, arr, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maxSubarrayLength(int[] A,int N){
    int maxLen=0 ;
    int curr_sum=0 ;
    HashMap<Integer,Integer>hash=new HashMap<Integer,Integer>();
    for(int i=0 ; i<N ; i++){
      if(A[i] % 2==0)curr_sum-=1 ;
      else curr_sum+=1 ;
      if(curr_sum==0)maxLen=Math.max(maxLen,i+1);
      if(hash.containsKey(curr_sum))maxLen=Math.max(maxLen,i-hash.get(curr_sum));
      else {
        hash.put(curr_sum,i);
      }
    }
    return maxLen ;
  }
  public static void main(String[] args){
    int arr[]={
      12,4,7,8,9,2,11,0,2,13 };
      int n=arr.length ;
      System.out.print(maxSubarrayLength(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSubarrayLength( A : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var maxLen : int ; maxLen := 0 ;
     var curr_sum : int ; curr_sum := 0 ;
    var hash : Map(int,int) ; hash := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     if (A[i+1] mod 2 = 0) then     curr_sum := curr_sum-(1) else     curr_sum := curr_sum+(1) ; ;  
     if (curr_sum = 0) then     maxLen := Set{maxLen, i + 1}->max() ; else skip ; 
     if (hash->keys()->includes(curr_sum)) then     maxLen := Set{maxLen, i - hash->at(curr_sum)}->max() ; else (     hash := hash->union(Map{curr_sum |-> i}) ) )  ;     i := i + 1 ) ; 
    return maxLen 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,4,7,8,9,2,11,0,2,13} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(maxSubarrayLength(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int H=sc.nextInt();
      int W=sc.nextInt();
      if(H==0 && W==0){
        break ;
      }
      for(int i=0 ; i<H ; i++){
        for(int j=0 ; j<W ; j++){
          if(i % 2==0){
            if(j % 2==0){
              System.out.print("#");
            }
            else {
              System.out.print(".");
            }
          }
          else {
            if(j % 2==0){
              System.out.print(".");
            }
            else {
              System.out.print("#");
            }
          }
        }
        System.out.println();
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var H : int ; H := sc.getCurrent()->toInteger() ;
     var W : int ; W := sc.getCurrent()->toInteger() ;
    if (H = 0 & W = 0) then (     break ) else skip ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (i mod 2 = 0) then (     if (j mod 2 = 0) then (     OclFile["System.out"].print("#") ) else (     OclFile["System.out"].print(".") ) ) else (     if (j mod 2 = 0) then (     OclFile["System.out"].print(".") ) else (     OclFile["System.out"].print("#") ) ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    while(true){
      String[] str=br.readLine().split(" ");
      int H=Integer.parseInt(str[0]);
      int W=Integer.parseInt(str[1]);
      if(H==0 && W==0){
        break ;
      }
      for(int i=0 ; i<H ; i++){
        for(int j=0 ; j<W ; j++){
          if((i+j)% 2==0){
            sb.append("#");
          }
          else {
            sb.append(".");
          }
        }
        sb.append("\n");
      }
      sb.append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
     while (true) do (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     var H : int ; H := (str[0+1])->toInteger() ;
    var W : int ; W := (str[1+1])->toInteger() ;
    if (H = 0 & W = 0) then (     break ) else skip ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if ((i + j) mod 2 = 0) then (     sb := sb + StringLib.newString("#") ) else (     sb := sb + StringLib.newString(".") ) )  ;     j := j + 1 ) ; 
     sb := sb + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString("\n") ; 
 ) ; 
     OclFile["System.out"].print(sb) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int h=sc.nextInt();
      int w=sc.nextInt();
      if((h!=0)&&(w!=0)){
        for(int i=1 ; i<=h ; i++){
          for(int j=1 ; j<=w ; j++){
            if(j!=w){
              if(i % 2!=0 && j % 2!=0)System.out.printf("#");
              else if(i % 2!=0 && j % 2==0)System.out.printf(".");
              else if(i % 2==0 && j % 2!=0)System.out.printf(".");
              else if(i % 2==0 && j % 2==0)System.out.printf("#");
            }
            else if(i % 2!=0 && j % 2!=0)System.out.printf("#\n");
            else if(i % 2!=0 && j % 2==0)System.out.printf(".\n");
            else if(i % 2==0 && j % 2!=0)System.out.printf(".\n");
            else if(i % 2==0 && j % 2==0)System.out.printf("#\n");
          }
        }
      }
      else break ;
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var h : int ; h := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
     if ((h /= 0) & (w /= 0)) then (         var i : int ; i := 1 ; while i <= h do ( (         var j : int ; j := 1 ; while j <= w do ( (     if (j /= w) then (     if (i mod 2 /= 0 & j mod 2 /= 0) then     OclFile["System.out"].printf("#") ; else     if (i mod 2 /= 0 & j mod 2 = 0) then     OclFile["System.out"].printf(".") else     if (i mod 2 = 0 & j mod 2 /= 0) then     OclFile["System.out"].printf(".") else     if (i mod 2 = 0 & j mod 2 = 0) then     OclFile["System.out"].printf("#") ; else skip ; ;  ;  ) else     if (i mod 2 /= 0 & j mod 2 /= 0) then     OclFile["System.out"].printf("#\n") else     if (i mod 2 /= 0 & j mod 2 = 0) then     OclFile["System.out"].printf(".\n") else     if (i mod 2 = 0 & j mod 2 /= 0) then     OclFile["System.out"].printf(".\n") else     if (i mod 2 = 0 & j mod 2 = 0) then     OclFile["System.out"].printf("#\n") ; else skip ; ;  ;  ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) else     break ;  
     OclFile["System.out"].println() ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int h,w ;
    int i,j,k=0 ;
    String n=System.getProperty("line.separator");
    Scanner scanner=new Scanner(System.in);
    String nu ;
    while(true){
      nu=scanner.next();
      h=Integer.parseInt(nu);
      nu=scanner.next();
      w=Integer.parseInt(nu);
      if(h==0 && w==0)break ;
      else {
        for(i=0 ; i<h ; i++){
          for(j=0 ; j<w ; j++){
            if((j+i)% 2==0){
              System.out.print("#");
            }
            else System.out.print(".");
          }
          System.out.print(n);
        }
      }
      k=0 ;
      System.out.print(n);
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var h : int ;
    var w : int ;
     var i : int ;
    var j : int ;
    var k : int ; k := 0 ;
    var n : String ; n := OclProcess.getEnvironmentProperty("line.separator") ;
    var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var nu : String ;
    while (true) do (     nu := scanner.getCurrent() ; 
     h := (nu)->toInteger() ; 
    nu := scanner.getCurrent() ; 
    w := (nu)->toInteger() ; 
    if (h = 0 & w = 0) then     break else (         i := 0 ; while i < h do ( (         j := 0 ; while j < w do ( (     if ((j + i) mod 2 = 0) then (     OclFile["System.out"].print("#") ) else     OclFile["System.out"].print(".") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print(n) )  ;     i := i + 1 ) ) ;  
    k := 0 ; 
    OclFile["System.out"].print(n) ; 
 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args)throws IOException {
    int x,y,i,j ;
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String[] str=br.readLine().split(" ");
      x=Integer.parseInt(str[0]);
      y=Integer.parseInt(str[1]);
      if(x==0 && y==0){
        break ;
      }
      for(i=0 ; i<x ; i++){
        for(j=0 ; j<y ; j++){
          if(i % 2==0){
            if(j % 2==0){
              System.out.printf("#");
            }
            else {
              System.out.printf(".");
            }
          }
          else {
            if(j % 2==1){
              System.out.printf("#");
            }
            else {
              System.out.printf(".");
            }
          }
        }
        System.out.printf("\n");
      }
      System.out.printf("\n");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ;
    var y : int ;
    var i : int ;
    var j : int ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     x := (str[0+1])->toInteger() ; 
    y := (str[1+1])->toInteger() ; 
    if (x = 0 & y = 0) then (     break ) else skip ; 
        i := 0 ; while i < x do ( (         j := 0 ; while j < y do ( (     if (i mod 2 = 0) then (     if (j mod 2 = 0) then (     OclFile["System.out"].printf("#") ) else (     OclFile["System.out"].printf(".") ) ) else (     if (j mod 2 = 1) then (     OclFile["System.out"].printf("#") ) else (     OclFile["System.out"].printf(".") ) ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].printf("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("\n") ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
import java.io.*;
public class codeforces {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    HashSet<Integer>hs=new HashSet<>();
    hs.add(b-a);
    hs.add(c-b);
    hs.add(d-c);
    if(hs.size()==1)System.out.println(d+(d-c));
    else {
      HashSet<Double>hs1=new HashSet<>();
      hs1.add((double)b/a);
      hs1.add((double)c/b);
      hs1.add((double)d/c);
      if(hs1.size()!=1)System.out.println("42");
      else {
        double x=d*(double)d/c ;
        if(x==(int)x)System.out.println((int)x);
        else System.out.println("42");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var hs : Set(int) ; hs := Set{} ;
    hs := hs->including(b - a) ; 
    hs := hs->including(c - b) ; 
    hs := hs->including(d - c) ; 
    if (hs->size() = 1) then     OclFile["System.out"].println(d + (d - c)) else (     var hs1 : Set(double) ; hs1 := Set{} ;
     hs1 := hs1->including(b->oclAsType(double) / a) ; 
    hs1 := hs1->including(c->oclAsType(double) / b) ; 
    hs1 := hs1->including(d->oclAsType(double) / c) ; 
    if (hs1->size() /= 1) then     OclFile["System.out"].println("42") else (     var x : double ; x := d * d->oclAsType(double) / c ;
     if (x = x->oclAsType(int)) then     OclFile["System.out"].println(x->oclAsType(int)) ; else     OclFile["System.out"].println("42") ; ) ;  
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void indexedSequentialSearch(int arr[],int n,int k){
    int elements[]=new int[20];
    int indices[]=new int[20];
    int temp,i ;
    int j=0,ind=0,start=0,end=0 ;
    for(i=0 ; i<n ; i+=3){
      elements[ind]=arr[i];
      indices[ind]=i ;
      ind++;
    }
    if(k<elements[0]){
      System.out.println("Not found");
      return ;
    }
    else {
      for(i=1 ; i<=ind ; i++)if(k<elements[i]){
        start=indices[i-1];
        end=indices[i];
        break ;
      }
    }
    for(i=start ; i<=end ; i++){
      if(k==arr[i]){
        j=1 ;
        break ;
      }
    }
    if(j==1)System.out.println("Found at index "+i);
    else System.out.println("Not found");
  }
  public static void main(String[] args){
    int arr[]={
      6,7,8,9,10 };
      int n=arr.length ;
      int k=8 ;
      indexedSequentialSearch(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation indexedSequentialSearch( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var elements : Sequence(int) ; elements := Integer.subrange(1,20)->collect(0) ;
     var indices : Sequence(int) ; indices := Integer.subrange(1,20)->collect(0) ;
    var temp : int ;
    var i : int ;
    var j : int ; j := 0 ;
    var ind : int ; ind := 0 ;
    var start : int ; start := 0 ;
    var end : int ; end := 0 ;
        i := 0 ; while i < n do ( (     elements[ind+1] := arr[i+1] ; 
     indices[ind+1] := i ; 
     ind := ind + 1 )  ;     i := i+(3) ) ; 
    if (k < elements[0+1]) then (     OclFile["System.out"].println("Not found") ; 
     return ) else (         i := 1 ; while i <= ind do (     if (k < elements[i+1]) then (     start := indices[i - 1+1] ; 
     end := indices[i+1] ; 
     break ) else skip ;  ;     i := i + 1 ) ) ;  
        i := start ; while i <= end do ( (     if (k = arr[i+1]) then (     j := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (j = 1) then     OclFile["System.out"].println("Found at index " + i) else     OclFile["System.out"].println("Not found") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,7,8,9,10} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 8 ;
     execute indexedSequentialSearch(arr, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class ArithmeticOrGeometric {
  private static BufferedReader bufferedReader ;
  private static StringTokenizer st ;
  public static void main(String[] args)throws IOException {
    bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    int a1=Integer.parseInt(next());
    int a2=Integer.parseInt(next());
    int a3=Integer.parseInt(next());
    int a4=Integer.parseInt(next());
    int d=a2-a1 ;
    if(d==a3-a2 && d==a4-a3){
      System.out.println(a4+d);
    }
    else if(a1*a3==a2*a2 && a2*a4==a3*a3 && a4*a4 % a3==0){
      System.out.println((a4*a4)/a3);
    }
    else {
      System.out.println(42);
    }
  }
  static String next()throws IOException {
    while(st==null || ! st.hasMoreElements()){
      st=new StringTokenizer(bufferedReader.readLine());
    }
    return st.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ArithmeticOrGeometric {
  static   attribute bufferedReader : OclFile;
  static   attribute st : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     var a1 : int ; a1 := (next())->toInteger() ;
    var a2 : int ; a2 := (next())->toInteger() ;
    var a3 : int ; a3 := (next())->toInteger() ;
    var a4 : int ; a4 := (next())->toInteger() ;
    var d : int ; d := a2 - a1 ;
    if (d = a3 - a2 & d = a4 - a3) then (     OclFile["System.out"].println(a4 + d) ) else     if (a1 * a3 = a2 * a2 & a2 * a4 = a3 * a3 & a4 * a4 mod a3 = 0) then (     OclFile["System.out"].println((a4 * a4) / a3) ) else (     OclFile["System.out"].println(42) ) ;  ;  
 );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(bufferedReader.readLine()) ) ; 
     return st.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.text.DecimalFormat ;
import java.util.StringTokenizer ;
public class ArithmeticOrGeometric {
  private static BufferedReader bufferedReader ;
  private static StringTokenizer st ;
  public static void main(String[] args)throws IOException {
    bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    int a1=Integer.parseInt(next());
    int a2=Integer.parseInt(next());
    int a3=Integer.parseInt(next());
    int a4=Integer.parseInt(next());
    int d=a2-a1 ;
    double r=(double)a2/a1 ;
    if(d==a3-a2 && d==a4-a3){
      System.out.println(a4+d);
    }
    else if(a1*a3==a2*a2 && a2*a4==a3*a3 && a4*a4 % a3==0){
      DecimalFormat decimalFormat=new DecimalFormat("######");
      System.out.println(decimalFormat.format(a4*r));
    }
    else {
      System.out.println(42);
    }
  }
  static String next()throws IOException {
    while(st==null || ! st.hasMoreElements()){
      st=new StringTokenizer(bufferedReader.readLine());
    }
    return st.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ArithmeticOrGeometric {
  static   attribute bufferedReader : OclFile;
  static   attribute st : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     var a1 : int ; a1 := (next())->toInteger() ;
    var a2 : int ; a2 := (next())->toInteger() ;
    var a3 : int ; a3 := (next())->toInteger() ;
    var a4 : int ; a4 := (next())->toInteger() ;
    var d : int ; d := a2 - a1 ;
    var r : double ; r := a2->oclAsType(double) / a1 ;
    if (d = a3 - a2 & d = a4 - a3) then (     OclFile["System.out"].println(a4 + d) ) else     if (a1 * a3 = a2 * a2 & a2 * a4 = a3 * a3 & a4 * a4 mod a3 = 0) then (     var decimalFormat : DecimalFormat ; decimalFormat := DecimalFormat.newDecimalFormat("######") ;
     OclFile["System.out"].println(decimalFormat.format(a4 * r)) ) else (     OclFile["System.out"].println(42) ) ;  ;  
 );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(bufferedReader.readLine()) ) ; 
     return st.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Week_2 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    int b=in.nextInt();
    int c=in.nextInt();
    int d=in.nextInt();
    if(b-a==c-b && c-b==d-c){
      System.out.println(d+(d-c));
    }
    else if(a*c==b*b && b*d==c*c &&(d*d)% c==0){
      System.out.println(d*d/c);
    }
    else System.out.println("42");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Week{
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    if (b - a = c - b & c - b = d - c) then (     OclFile["System.out"].println(d + (d - c)) ) else     if (a * c = b * b & b * d = c * c & (d * d) mod c = 0) then (     OclFile["System.out"].println(d * d / c) ) else     OclFile["System.out"].println("42") ; ;  ;  
 );
}
 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    if (b - a = c - b & c - b = d - c) then (     OclFile["System.out"].println(d + (d - c)) ) else     if (a * c = b * b & b * d = c * c & (d * d) mod c = 0) then (     OclFile["System.out"].println(d * d / c) ) else     OclFile["System.out"].println("42") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int h=sc.nextInt();
      int w=sc.nextInt();
      if((h | w)==0)break ;
      char[][] m=new char[h][w];
      for(int i=0 ; i<h ; i++)m[i]=sc.next().toCharArray();
      int[][] c=new int[h][w];
      for(int i=0 ; i<h ; i++){
        int x=1 ;
        for(int j=w-1 ; j>=0 ; j--){
          if(m[i][j]=='.'){
            c[i][j]=x++;
          }
          else {
            c[i][j]=0 ;
            x=1 ;
          }
        }
      }
      int max=0 ;
      for(int i=0 ; i<h ; i++){
        for(int j=0 ; j<w ; j++){
          if(0<i && c[i][j]==c[i-1][j] || c[i][j]==0)continue ;
          int k=1 ;
          int min=c[i][j];
          max=Math.max(max,k*min);
          while(i+k<h && c[i+k][j]>0){
            min=Math.min(min,c[i+k][j]);
            k++;
            max=Math.max(max,k*min);
          }
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var h : int ; h := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(h,w)) = 0) then     break else skip ; 
    var m : Sequence(Sequence(String)) ; m := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do (     m[i+1] := sc.getCurrent()->characters() ;  ;     i := i + 1 ) ; 
    var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (     var x : int ; x := 1 ;
         var j : int ; j := w - 1 ; while j >= 0 do ( (     if (m[i+1][j+1] = '.') then (      c[i+1][j+1] := x  ; x := x + 1 ) else (     c[i+1][j+1] := 0 ; 
     x := 1 ) )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (0 < i & c[i+1][j+1] = c[i - 1+1][j+1] or c[i+1][j+1] = 0) then     continue else skip ; 
     var k : int ; k := 1 ;
    var min : int ; min := c[i+1][j+1] ;
    max := Set{max, k * min}->max() ; 
    while (i + k < h & c[i + k+1][j+1] > 0) do (     min := Set{min, c[i + k+1][j+1]}->min() ; 
     k := k + 1 ; 
     max := Set{max, k * min}->max() ) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class sol {
  static boolean isPossible(int l,int m,int x,int y){
    if(l*m==x+y)return true ;
    return false ;
  }
  public static void main(String args[]){
    int l=3,m=2,x=4,y=2 ;
    if(isPossible(l,m,x,y))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class sol {
  static   operation isPossible( l : int, m : int, x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     if (l * m = x + y) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 3 ;
    var m : int ; m := 2 ;
    var x : int ; x := 4 ;
    var y : int ; y := 2 ;
     if (isPossible(l, m, x, y)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  Scanner sc ;
  int H,W ;
  char[][] rect ;
  int[][] xmax ;
  Main(){
    sc=new Scanner(System.in);
  }
  boolean init(){
    H=sc.nextInt();
    W=sc.nextInt();
    if(H==0 && W==0)return false ;
    rect=new char[H][W];
    for(int i=0 ; i<H ; i++)rect[i]=sc.next().toCharArray();
    return true ;
  }
  void run(){
    while(init()){
      xmax=new int[H][W];
      for(int i=0 ; i<H ; i++){
        if(rect[i][0]=='.')xmax[i][0]=1 ;
        else xmax[i][0]=0 ;
        for(int j=1 ; j<W ; j++){
          if(rect[i][j]=='.'){
            xmax[i][j]=xmax[i][j-1]+1 ;
          }
          else {
            xmax[i][j]=0 ;
          }
        }
      }
      int max_area=0 ;
      for(int i=0 ; i<H ; i++){
        for(int j=0 ; j<W ; j++){
          int min_xmax=xmax[i][j];
          for(int y=i ; y>=0 ; y--){
            min_xmax=Math.min(min_xmax,xmax[y][j]);
            max_area=Math.max(max_area,min_xmax*(i-y+1));
          }
        }
      }
      System.out.println(max_area);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute H : int;
   attribute rect : Sequence(Sequence(String));
   attribute xmax : Sequence(Sequence(int));
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation init() : boolean
  pre: true
  post: true
  activity: (     H := sc.getCurrent()->toInteger() ; 
     W := sc.getCurrent()->toInteger() ; 
    if (H = 0 & W = 0) then     return false else skip ; 
    rect := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ; 
        var i : int ; i := 0 ; while i < H do (     rect[i+1] := sc.getCurrent()->characters() ;  ;     i := i + 1 ) ; 
    return true 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     while (init()) do (     xmax := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ; 
         var i : int ; i := 0 ; while i < H do ( (     if (rect[i+1][0+1] = '.') then     xmax[i+1][0+1] := 1 else     xmax[i+1][0+1] := 0 ; ;  
         var j : int ; j := 1 ; while j < W do ( (     if (rect[i+1][j+1] = '.') then (     xmax[i+1][j+1] := xmax[i+1][j - 1+1] + 1 ) else (     xmax[i+1][j+1] := 0 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max_area : int ; max_area := 0 ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     var min_xmax : int ; min_xmax := xmax[i+1][j+1] ;
         var y : int ; y := i ; while y >= 0 do ( (     min_xmax := Set{min_xmax, xmax[y+1][j+1]}->min() ; 
     max_area := Set{max_area, min_xmax * (i - y + 1)}->max() )  ;     y := y - 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max_area) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().main();
  }
  void main(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int h=sc.nextInt();
      int w=sc.nextInt();
      if(h==0 && w==0)break ;
      char[][] rec=new char[h+1][w+1];
      for(int i=1 ; i<=h ; i++){
        String s=sc.next();
        for(int j=1 ; j<=w ; j++){
          rec[i][j]=s.charAt(j-1);
        }
      }
      int[][] row=new int[h+1][w+1];
      for(int i=1 ; i<=h ; i++){
        for(int j=1 ; j<=w ; j++){
          if(rec[i][j]=='.'){
            row[i][j]=row[i][j-1]+1 ;
          }
          else {
            row[i][j]=0 ;
          }
        }
      }
      int[][] dp=new int[h+1][w+1];
      for(int i=1 ; i<=h ; i++){
        for(int j=1 ; j<=w ; j++){
          int rmin=row[i][j];
          for(int k=i ; k>=1 ; k--){
            rmin=Math.min(row[k][j],rmin);
            dp[i][j]=Math.max(rmin*(i-k+1),dp[i][j]);
          }
        }
      }
      int max=0 ;
      for(int i=1 ; i<=h ; i++){
        for(int j=1 ; j<=w ; j++){
          max=Math.max(dp[i][j],max);
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().main() );
   operation main() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var h : int ; h := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    if (h = 0 & w = 0) then     break else skip ; 
    var rec : Sequence(Sequence(String)) ; rec := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= h do ( (     var s : String ; s := sc.getCurrent() ;
         var j : int ; j := 1 ; while j <= w do ( (     rec[i+1][j+1] := s->at((j)->char2byte() - 1+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var row : Sequence(Sequence(int)) ; row := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= h do ( (         var j : int ; j := 1 ; while j <= w do ( (     if (rec[i+1][j+1] = '.') then (     row[i+1][j+1] := row[i+1][(j)->char2byte() - 1+1] + 1 ) else (     row[i+1][j+1] := 0 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= h do ( (         var j : int ; j := 1 ; while j <= w do ( (     var rmin : int ; rmin := row[i+1][j+1] ;
         var k : int ; k := i ; while k >= 1 do ( (     rmin := Set{row[k+1][j+1], rmin}->min() ; 
     dp[i+1][j+1] := Set{rmin * (i - k + 1), dp[i+1][j+1]}->max() )  ;     k := k - 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i <= h do ( (         var j : int ; j := 1 ; while j <= w do ( (     max := Set{dp[i+1][j+1], max}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  char[][] board ;
  int W,H ;
  void run(){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      H=in.nextInt();
      W=in.nextInt();
      if(H==0 && W==0)return ;
      board=new char[H][];
      for(int i=0 ; i<H ; i++){
        board[i]=in.next().toCharArray();
      }
      System.out.println(solve());
    }
  }
  int solve(){
    int[][] accum=new int[H][W+1];
    int ans=0 ;
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        accum[i][j+1]=accum[i][j]+(board[i][j]=='*' ? 1 : 0);
      }
    }
    for(int j=0 ; j<W ; j++)for(int k=j+1 ; k<=W ; k++){
      int len=0,cur=0 ;
      for(int i=0 ; i<H ; i++){
        if(accum[i][k]-accum[i][j]==0){
          cur++;
        }
        else {
          cur=0 ;
        }
        if(len<cur){
          len=cur ;
        }
      }
      ans=Math.max(ans,(k-j)*len);
    }
    return ans ;
  }
  public static void main(String args[]){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute board : Sequence(Sequence(String));
   attribute W : int;
   operation run() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     H := in.getCurrent()->toInteger() ; 
     W := in.getCurrent()->toInteger() ; 
    if (H = 0 & W = 0) then     return else skip ; 
    board := Integer.subrange(1,H)->collect(Sequence{}) ; 
        var i : int ; i := 0 ; while i < H do ( (     board[i+1] := in.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve()) ; 
 )  ) );
   operation solve() : int
  pre: true
  post: true
  activity: (     var accum : Sequence(Sequence(int)) ; accum := Integer.subrange(1,H)->collect(Integer.subrange(1,W + 1)->collect(0)) ;
     var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     accum[i+1][j + 1+1] := accum[i+1][j+1] + (if board[i+1][j+1] = '*' then 1 else 0 endif) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < W do (         var k : int ; k := j + 1 ; while k <= W do ( (     var len : int ; len := 0 ;
    var cur : int ; cur := 0 ;
         var i : int ; i := 0 ; while i < H do ( (     if (accum[i+1][k+1] - accum[i+1][j+1] = 0) then (     cur := cur + 1 ) else (     cur := 0 ) ;  
     if (len < cur) then (     len := cur ) else skip )  ;     i := i + 1 ) ; 
     ans := Set{ans, (k - j) * len}->max() )  ;     k := k + 1 ) ;  ;     j := j + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int h=sc.nextInt();
      int w=sc.nextInt();
      if((h | w)==0)break ;
      int[][] map=new int[h+1][w+1];
      for(int i=1 ; i<=h ; i++){
        String str=sc.next();
        for(int j=1 ; j<=w ; j++){
          if(str.charAt(j-1)=='*')map[i][j]=0 ;
          else map[i][j]=map[i][j-1]+1 ;
        }
      }
      int max=0 ;
      for(int j=1 ; j<=w ; j++)for(int i=1 ; i<=h ; i++){
        if(map[i][j]>0){
          int ww=INF ;
          for(int k=i ; k<=h ; k++){
            ww=min(ww,map[k][j]);
            max=max(max,ww*(k-i+1));
          }
        }
      }
      System.out.println(max);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var h : int ; h := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(h,w)) = 0) then     break else skip ; 
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= h do ( (     var str : String ; str := sc.getCurrent() ;
         var j : int ; j := 1 ; while j <= w do ( (     if (str->at((j)->char2byte() - 1+1) = '*') then     map[i+1][j+1] := 0 ; else     map[i+1][j+1] := map[i+1][(j)->char2byte() - 1+1] + 1 ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var j : int ; j := 1 ; while j <= w do (         var i : int ; i := 1 ; while i <= h do ( (     if (map[i+1][j+1] > 0) then (     var ww : int ; ww := INF ;
         var k : int ; k := i ; while k <= h do ( (     ww := Set{ww, map[k+1][j+1]}->min() ; 
     max := Set{max, ww * (k - i + 1)}->max() )  ;     k := k + 1 ) ) else skip )  ;     i := i + 1 ) ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countFreq(String pat,String txt){
    int M=pat.length();
    int N=txt.length();
    int res=0 ;
    for(int i=0 ; i<=N-M ; i++){
      int j ;
      for(j=0 ; j<M ; j++){
        if(txt.charAt(i+j)!=pat.charAt(j)){
          break ;
        }
      }
      if(j==M){
        res++;
        j=0 ;
      }
    }
    return res ;
  }
  static public void main(String[] args){
    String txt="dhimanman" ;
    String pat="man" ;
    System.out.println(countFreq(pat,txt));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countFreq( pat : String, txt : String) : int
  pre: true
  post: true
  activity: (     var M : int ; M := pat->size() ;
     var N : int ; N := txt->size() ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i <= N - M do ( (     var j : int ;
         j := 0 ; while j < M do ( (     if (txt->at(i + j+1) /= pat->at(j+1)) then (     break ) else skip )  ;     j := j + 1 ) ; 
     if (j = M) then (     res := res + 1 ; 
     j := 0 ) else skip )  ;     i := i + 1 ) ; 
    return res 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var txt : String ; txt := "dhimanman" ;
     var pat : String ; pat := "man" ;
     OclFile["System.out"].println(countFreq(pat, txt)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int larrgestPalindrome(int n){
    int upper_limit=0 ;
    for(int i=1 ; i<=n ; i++){
      upper_limit*=10 ;
      upper_limit+=9 ;
    }
    int lower_limit=1+upper_limit/10 ;
    int max_product=0 ;
    for(int i=upper_limit ; i>=lower_limit ; i--){
      for(int j=i ; j>=lower_limit ; j--){
        int product=i*j ;
        if(product<max_product)break ;
        int number=product ;
        int reverse=0 ;
        while(number!=0){
          reverse=reverse*10+number % 10 ;
          number/=10 ;
        }
        if(product==reverse && product>max_product)max_product=product ;
      }
    }
    return max_product ;
  }
  public static void main(String[] args){
    int n=2 ;
    System.out.print(larrgestPalindrome(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation larrgestPalindrome( n : int) : int
  pre: true
  post: true
  activity: (     var upper_limit : int ; upper_limit := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     upper_limit := upper_limit*(10) ; 
     upper_limit := upper_limit+(9) )  ;     i := i + 1 ) ; 
    var lower_limit : int ; lower_limit := 1 + upper_limit / 10 ;
    var max_product : int ; max_product := 0 ;
        var i : int ; i := upper_limit ; while i >= lower_limit do ( (         var j : int ; j := i ; while j >= lower_limit do ( (     var product : int ; product := i * j ;
     if (product < max_product) then     break else skip ; 
    var number : int ; number := product ;
    var reverse : int ; reverse := 0 ;
    while (number /= 0) do (     reverse := reverse * 10 + number mod 10 ; 
     number := number/(10) ) ; 
    if (product = reverse & product > max_product) then     max_product := product ; else skip ; 
 )  ;     j := j - 1 ) )  ;     i := i - 1 ) ; 
    return max_product 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].print(larrgestPalindrome(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BProblemsForRound solver=new BProblemsForRound();
    solver.solve(1,in,out);
    out.close();
  }
  static class BProblemsForRound {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int m=in.nextInt();
      int low=1 ;
      int high=n ;
      int a,b ;
      while(m-->0){
        a=in.nextInt();
        b=in.nextInt();
        if(a>b){
          int temp=a ;
          a=b ;
          b=temp ;
        }
        low=Math.max(low,a);
        high=Math.min(high,b);
      }
      out.println(Math.max(0,high-low));
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BProblemsForRound ; solver := BProblemsForRound.newBProblemsForRound() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BProblemsForRound {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var m : int ; m := in.nextInt() ;
    var low : int ; low := 1 ;
    var high : int ; high := n ;
    var a : int ;
    var b : int ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     a := in.nextInt() ; 
     b := in.nextInt() ; 
    if (a > b) then (     var temp : int ; temp := a ;
     a := b ; 
     b := temp ) else skip ; 
    low := Set{low, a}->max() ; 
    high := Set{high, b}->min() ; 
 ) ;  ) ;  
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CodeForce {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static StringBuilder sb=new StringBuilder();
  public static int checkreverse(int[][] arr,int n){
    if(n % 2==1)return n ;
    for(int i=n/2-1 ; i>=0 ; i--){
      for(int j=0 ; j<arr[0] .length ; j++){
        if(arr[i][j]!=arr[n-i-1][j])return n ;
      }
    }
    return checkreverse(arr,n/2);
  }
  static boolean flag=false ;
  static int next(String[] sr,int ind){
    return Integer.parseInt(sr[ind]);
  }
  public static void main(String[] args)throws IOException {
    String[] sr=br.readLine().split(" ");
    int n=next(sr,0);
    int m=next(sr,1);
    if(m==0){
      System.out.println(n-1);
      return ;
    }
    int min=Integer.MAX_VALUE ;
    int max=Integer.MIN_VALUE ;
    for(int i=0 ; i<m ; i++){
      sr=br.readLine().split(" ");
      int a=next(sr,0);
      int b=next(sr,1);
      min=Math.min(min,Math.max(a,b));
      max=Math.max(max,Math.min(a,b));
    }
    if(max>=min){
      System.out.println(0);
      return ;
    }
    int k=min-max-1 ;
    System.out.println(1+k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForce {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute sb : String := StringLib.newString();
  static   operation checkreverse( arr : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 = 1) then     return n else skip ; 
         var i : int ; i := n / 2 - 1 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < arr[0+1]->size() do ( (     if (arr[i+1][j+1] /= arr[n - i - 1+1][j+1]) then     return n else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
     return checkreverse(arr, n / 2) );
  static   attribute flag : boolean := false;
  static   operation next( sr : Sequence(String), ind : int) : int
  pre: true
  post: true
  activity: (     return (sr[ind+1])->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sr : Sequence(String) ; sr := br.readLine()->split(" ") ;
     var n : int ; n := next(sr, 0) ;
    var m : int ; m := next(sr, 1) ;
    if (m = 0) then (     OclFile["System.out"].println(n - 1) ; 
     return ) else skip ; 
    var min : int ; min := 2147483647 ;
    var max : int ; max := -2147483648 ;
        var i : int ; i := 0 ; while i < m do ( (     sr := br.readLine()->split(" ") ; 
     var a : int ; a := next(sr, 0) ;
    var b : int ; b := next(sr, 1) ;
    min := Set{min, Set{a, b}->max()}->min() ; 
    max := Set{max, Set{a, b}->min()}->max() ; 
 )  ;     i := i + 1 ) ; 
    if (max >= min) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var k : int ; k := min - max - 1 ;
    OclFile["System.out"].println(1 + k) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int unitnumber(int x,int y){
    x=x % 10 ;
    if(y!=0)y=y % 4+4 ;
    return(((int)(Math.pow(x,y)))% 10);
  }
  public static void main(String[] args){
    int x=133,y=5 ;
    System.out.println(unitnumber(x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation unitnumber( x : int, y : int) : int
  pre: true
  post: true
  activity: (     x := x mod 10 ; 
     if (y /= 0) then     y := y mod 4 + 4 ; else skip ; 
     return (((x->pow(y))->oclAsType(int)) mod 10) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 133 ;
    var y : int ; y := 5 ;
     OclFile["System.out"].println(unitnumber(x, y)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int mas[]=new int[n];
    int mas1[]=new int[n];
    for(int i=0 ; i<n ; i++){
      mas1[i]=in.nextInt();
    }
    int c=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      mas[c]=mas1[i];
      c++;
    }
    int answer=0 ;
    HashMap<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(map.get(mas[i])==null){
        answer=mas[i];
        map.put(mas[i],1);
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var mas : Sequence(int) ; mas := Integer.subrange(1,n)->collect(0) ;
    var mas1 : Sequence(int) ; mas1 := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     mas1[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     mas[c+1] := mas1[i+1] ; 
     c := c + 1 )  ;     i := i - 1 ) ; 
    var answer : int ; answer := 0 ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (map->at(mas[i+1]) = null) then (     answer := mas[i+1] ; 
     map := map->union(Map{mas[i+1] |-> 1}) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.Set ;
public final class B_886_Vlad_and_Cafes {
  private B_886_Vlad_and_Cafes(){
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int numberOf=in.nextInt();
    int[] indicies=new int[numberOf];
    for(int i=0 ; i<numberOf ; i++){
      indicies[i]=in.nextInt();
    }
    Map<Integer,Integer>index=new HashMap();
    Set<Integer>diffIndic=new HashSet<Integer>();
    for(int cur : indicies){
      if(! diffIndic.contains(cur)){
        diffIndic.add(cur);
        index.put(cur,0);
      }
    }
    for(int i=numberOf-1 ; i>=0 ; i--){
      if(diffIndic.contains(indicies[i])){
        index.replace(indicies[i],0,i);
        diffIndic.remove(indicies[i]);
      }
    }
    int best=0,min=Integer.MAX_VALUE ;
    for(int i=0 ; i<numberOf ; i++){
      if(index.get(indicies[i])<min){
        min=index.get(indicies[i]);
        best=indicies[i];
      }
    }
    System.out.println(best);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_886_Vlad_and_Cafes {
   static operation newB_886_Vlad_and_Cafes() : B_886_Vlad_and_Cafes
  pre: true
  post: true
  activity:
  ( var self : B_886_Vlad_and_Cafes ;
    self := createB_886_Vlad_and_Cafes();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numberOf : int ; numberOf := in.getCurrent()->toInteger() ;
    var indicies : Sequence(int) ; indicies := Integer.subrange(1,numberOf)->collect(0) ;
        var i : int ; i := 0 ; while i < numberOf do ( (     indicies[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var index : Map(int,int) ; index := Map{} ;
    var diffIndic : Set(int) ; diffIndic := Set{} ;
    for (cur : indicies) do ( (     if (not(diffIndic->includes(cur))) then (     diffIndic := diffIndic->including(cur) ; 
     index := index->union(Map{cur |-> 0}) ) else skip )  ) ; 
        var i : int ; i := numberOf - 1 ; while i >= 0 do ( (     if (diffIndic->includes(indicies[i+1])) then (     index := index.replace(indicies[i+1], 0, i) ; 
     diffIndic := diffIndic->excludingFirst(indicies[i+1]) ) else skip )  ;     i := i - 1 ) ; 
    var best : int ; best := 0 ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < numberOf do ( (     if (index->at(indicies[i+1]) < min) then (     min := index->at(indicies[i+1]) ; 
     best := indicies[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(best) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int X=sc.nextInt();
    int[] arr=new int[X];
    for(int i=0 ; i<X ; i++)arr[i]=sc.nextInt();
    HashMap<String,Boolean>hashmap=new HashMap<String,Boolean>();
    int best=-1 ;
    for(int i=X-1 ; i>-1 ; i--){
      if(! hashmap.containsKey(String.valueOf(arr[i]))){
        best=arr[i];
        hashmap.put(String.valueOf(arr[i]),Boolean.TRUE);
      }
    }
    System.out.println(best);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : int ; X := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,X)->collect(0) ;
        var i : int ; i := 0 ; while i < X do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var hashmap : Map(String,Boolean) ; hashmap := Map{} ;
    var best : int ; best := -1 ;
        var i : int ; i := X - 1 ; while i > -1 do ( (     if (not(hashmap->keys()->includes(((arr[i+1]) + "")))) then (     best := arr[i+1] ; 
     hashmap := hashmap->union(Map{((arr[i+1]) + "") |-> true}) ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(best) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int check(long dp[],long a){
    int start=0 ;
    int end=dp.length-1 ;
    while(true){
      if(dp[start]>=a)return start ;
      else if(dp[end]<=a)return end ;
      else {
        if(start+1==end)return end ;
        else {
          int mid=(start+end)/2 ;
          if(dp[mid]==a)return mid ;
          else if(dp[mid]>a)end=mid ;
          else start=mid ;
        }
      }
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long a[]=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextLong();
    long dp[]=new long[n];
    for(int i=0 ; i<n ; i++){
      dp[i]=1000000001 ;
    }
    dp[0]=a[0];
    for(int i=1 ; i<n ; i++)dp[check(dp,a[i])]=a[i];
    for(int i=0 ; i<n ; i++){
      if(dp[i]>1000000000){
        System.out.println(i);
        break ;
      }
      if(i==n-1)System.out.println(n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation check( dp : Sequence(long), a : long) : int
  pre: true
  post: true
  activity: (     var start : int ; start := 0 ;
     var end : int ; end := dp->size() - 1 ;
     while (true) do (     if (dp[start+1] >= a) then     return start else     if (dp[end+1] <= a) then     return end else (     if (start + 1 = end) then     return end else (     var mid : int ; mid := (start + end) / 2 ;
     if (dp[mid+1] = a) then     return mid else     if (dp[mid+1] > a) then     end := mid else     start := mid ; ;  ) ) ;  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(long) ; dp := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     dp[i+1] := 1000000001 )  ;     i := i + 1 ) ; 
    dp[0+1] := a[0+1] ; 
        var i : int ; i := 1 ; while i < n do (     dp[check(dp, a[i+1])+1] := a[i+1] ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (dp[i+1] > 1000000000) then (     OclFile["System.out"].println(i) ; 
     break ) else skip ; 
     if (i = n - 1) then     OclFile["System.out"].println(n) ; else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void NicomachuTheorum_sum(int n){
    int sum=0 ;
    for(int k=1 ; k<=n ; k++)sum+=k*k*k ;
    int triNo=n*(n+1)/2 ;
    if(sum==triNo*triNo)System.out.println("Yes");
    else System.out.println("No");
  }
  public static void main(String[] args){
    int n=5 ;
    NicomachuTheorum_sum(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation NicomachuTheorum_sum( n : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var k : int ; k := 1 ; while k <= n do (     sum := sum+(k * k * k) ;  ;     k := k + 1 ) ; 
     var triNo : int ; triNo := n * (n + 1) / 2 ;
     if (sum = triNo * triNo) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute NicomachuTheorum_sum(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Tttest {
  public static String fun(String s){
    int sum1=0 ;
    int sum2=0 ;
    for(int i=0 ; i<s.length(); i++){
      char ch=s.charAt(i);
      if(i<3){
        sum1+=(ch-'0');
      }
      else {
        sum2+=(ch-'0');
      }
    }
    if(sum1==sum2){
      return "YES" ;
    }
    return "NO" ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      String s=sc.next();
      System.out.println(fun(s));
      t--;
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Tttest {
  static   operation fun( s : String) : String
  pre: true
  post: true
  activity: (     var sum1 : int ; sum1 := 0 ;
     var sum2 : int ; sum2 := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var ch : String ; ch := s->at(i+1) ;
     if (i < 3) then (     sum1 := sum1+(((ch)->char2byte() - ('0')->char2byte())) ) else (     sum2 := sum2+(((ch)->char2byte() - ('0')->char2byte())) ) )  ;     i := i + 1 ) ; 
    if (sum1 = sum2) then (     return "YES" ) else skip ; 
    return "NO" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var s : String ; s := sc.getCurrent() ;
     OclFile["System.out"].println(fun(s)) ; 
     t := t - 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Acm {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int sum1=0 ;
    int sum2=0 ;
    for(int i=0 ; i<n ; i++){
      String name=scan.next();
      if(name.charAt(0)+name.charAt(1)+name.charAt(2)==name.charAt(3)+name.charAt(4)+name.charAt(5))System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Acm {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var sum1 : int ; sum1 := 0 ;
    var sum2 : int ; sum2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var name : String ; name := scan.getCurrent() ;
     if (name->at(0+1) + name->at(1+1) + name->at(2+1) = name->at(3+1) + name->at(4+1) + name->at(5+1)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewClass33 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      long a=in.nextLong();
      long s=0 ;
      long d=a ;
      long ss=0 ;
      for(int i=0 ; i<6 ; i++){
        if(i<3){
          s+=a % 10 ;
          a/=10 ;
        }
        else {
          ss+=a % 10 ;
          a/=10 ;
        }
      }
      if(ss==s){
        System.out.println("YES");
      }
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass33 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : long ; a := in.getCurrent()->toLong() ;
     var s : long ; s := 0 ;
    var d : long ; d := a ;
    var ss : long ; ss := 0 ;
        var i : int ; i := 0 ; while i < 6 do ( (     if (i < 3) then (     s := s+(a mod 10) ; 
     a := a/(10) ) else (     ss := ss+(a mod 10) ; 
     a := a/(10) ) )  ;     i := i + 1 ) ; 
    if (ss = s) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Acm {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int sum1=0 ;
    int sum2=0 ;
    for(int i=0 ; i<n ; i++){
      String name=scan.next();
      int number=Integer.parseInt(name);
      if(name.charAt(0)+name.charAt(1)+name.charAt(2)==name.charAt(3)+name.charAt(4)+name.charAt(5))System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Acm {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var sum1 : int ; sum1 := 0 ;
    var sum2 : int ; sum2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var name : String ; name := scan.getCurrent() ;
     var number : int ; number := (name)->toInteger() ;
     if (name->at(0+1) + name->at(1+1) + name->at(2+1) = name->at(3+1) + name->at(4+1) + name->at(5+1)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class LuckyDigits {
  public static void main(String...strings){
    try(Scanner sc=new Scanner(System.in)){
      int testCase=sc.nextInt();
      for(int i=0 ; i<testCase ; i++){
        char[] digits=sc.next().toCharArray();
        int firstThreeNumbers=0 ;
        int secondThreeNumbers=0 ;
        for(int j=0 ; j<3 ; j++){
          firstThreeNumbers+=digits[j];
        }
        for(int k=3 ; k<6 ; k++){
          secondThreeNumbers+=digits[k];
        }
        if(firstThreeNumbers==secondThreeNumbers){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class LuckyDigits {
  static   operation main( strings : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var testCase : int ; testCase := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < testCase do ( (     var digits : Sequence(String) ; digits := sc.getCurrent()->characters() ;
     var firstThreeNumbers : int ; firstThreeNumbers := 0 ;
    var secondThreeNumbers : int ; secondThreeNumbers := 0 ;
        var j : int ; j := 0 ; while j < 3 do ( (     firstThreeNumbers := firstThreeNumbers+(digits[j+1]) )  ;     j := j + 1 ) ; 
        var k : int ; k := 3 ; while k < 6 do ( (     secondThreeNumbers := secondThreeNumbers+(digits[k+1]) )  ;     k := k + 1 ) ; 
    if (firstThreeNumbers = secondThreeNumbers) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     i := i + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findSplitPoint(int arr[],int n){
    int leftSum=0 ;
    for(int i=0 ; i<n ; i++){
      leftSum+=arr[i];
      int rightSum=0 ;
      for(int j=i+1 ; j<n ; j++)rightSum+=arr[j];
      if(leftSum==rightSum)return i+1 ;
    }
    return-1 ;
  }
  static void printTwoParts(int arr[],int n){
    int splitPoint=findSplitPoint(arr,n);
    if(splitPoint==-1 || splitPoint==n){
      System.out.println("Not Possible");
      return ;
    }
    for(int i=0 ; i<n ; i++){
      if(splitPoint==i)System.out.println();
      System.out.print(arr[i]+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,5 };
      int n=arr.length ;
      printTwoParts(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSplitPoint( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var leftSum : int ; leftSum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     leftSum := leftSum+(arr[i+1]) ; 
     var rightSum : int ; rightSum := 0 ;
         var j : int ; j := i + 1 ; while j < n do (     rightSum := rightSum+(arr[j+1]) ;  ;     j := j + 1 ) ; 
     if (leftSum = rightSum) then     return i + 1 else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation printTwoParts( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var splitPoint : int ; splitPoint := findSplitPoint(arr, n) ;
     if (splitPoint = -1 or splitPoint = n) then (     OclFile["System.out"].println("Not Possible") ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     if (splitPoint = i) then     OclFile["System.out"].println() ; else skip ; 
     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,5} ;
     var n : int ; n := arr->size() ;
     execute printTwoParts(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isReverseEqual(String s1,String s2){
    if(s1.length()!=s2.length())return false ;
    int len=s1.length();
    for(int i=0 ; i<len ; i++)if(s1.charAt(i)!=s2.charAt(len-i-1))return false ;
    return true ;
  }
  static String getWord(String str[],int n){
    for(int i=0 ; i<n-1 ; i++)for(int j=i+1 ; j<n ; j++)if(isReverseEqual(str[i],str[j]))return str[i];
    return "-1" ;
  }
  public static void main(String[] args){
    String str[]={
      "geeks","for","skeeg" };
      int n=str.length ;
      System.out.print(getWord(str,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isReverseEqual( s1 : String, s2 : String) : boolean
  pre: true
  post: true
  activity: (     if (s1->size() /= s2->size()) then     return false else skip ; 
     var len : int ; len := s1->size() ;
         var i : int ; i := 0 ; while i < len do (     if (s1->at(i+1) /= s2->at(len - i - 1+1)) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation getWord( str : Sequence(String), n : int) : String
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n - 1 do (         var j : int ; j := i + 1 ; while j < n do (     if (isReverseEqual(str[i+1], str[j+1])) then     return str[i+1] else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return "-1" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := Sequence{"geeks","for","skeeg"} ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].print(getWord(str, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printWords(int h,int m){
    String nums[]={
      "zero","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen","twenty","twenty one","twenty two","twenty three","twenty four","twenty five","twenty six","twenty seven","twenty eight","twenty nine",};
      if(m==0)System.out.println(nums[h]+" o' clock ");
      else if(m==1)System.out.println("one minute past "+nums[h]);
      else if(m==59)System.out.println("one minute to "+nums[(h % 12)+1]);
      else if(m==15)System.out.println("quarter past "+nums[h]);
      else if(m==30)System.out.println("half past "+nums[h]);
      else if(m==45)System.out.println("quarter to "+nums[(h % 12)+1]);
      else if(m<=30)System.out.println(nums[m]+" minutes past "+nums[h]);
      else if(m>30)System.out.println(nums[60-m]+" minutes to "+nums[(h % 12)+1]);
    }
    public static void main(String[] args){
      int h=6 ;
      int m=24 ;
      printWords(h,m);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printWords( h : int, m : int) : void
  pre: true
  post: true
  activity: (     var nums : Sequence(String) ; nums := Sequence{"zero","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen","twenty","twenty one","twenty two","twenty three","twenty four","twenty five","twenty six","twenty seven","twenty eight","twenty nine",} ;
     if (m = 0) then     OclFile["System.out"].println(nums[h+1] + " o' clock ") ; else     if (m = 1) then     OclFile["System.out"].println("one minute past " + nums[h+1]) else     if (m = 59) then     OclFile["System.out"].println("one minute to " + nums[(h mod 12) + 1+1]) else     if (m = 15) then     OclFile["System.out"].println("quarter past " + nums[h+1]) else     if (m = 30) then     OclFile["System.out"].println("half past " + nums[h+1]) else     if (m = 45) then     OclFile["System.out"].println("quarter to " + nums[(h mod 12) + 1+1]) else     if (m <= 30) then     OclFile["System.out"].println(nums[m+1] + " minutes past " + nums[h+1]) else     if (m > 30) then     OclFile["System.out"].println(nums[60 - m+1] + " minutes to " + nums[(h mod 12) + 1+1]) ; else skip ; ;  ;  ;  ;  ;  ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var h : int ; h := 6 ;
     var m : int ; m := 24 ;
     execute printWords(h, m) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),m=(int)Math.pow(2,n)-1 ;
    int k=in.nextInt();
    List<Integer>T=new ArrayList<>();
    for(int i=0 ; i<k ; i++)T.add(Integer.parseInt(in.next()));
    PrintWriter out=new PrintWriter(System.out);
    for(int i=0 ; i<=m ; i++){
      String str=Integer.toBinaryString(i);
      List<Integer>ls=new ArrayList<>();
      for(int j=0 ; j<str.length(); j++){
        if(str.charAt(str.length()-1-j)=='1')ls.add(j);
      }
      if(ls.size()>=T.size()&& ls.containsAll(T)){
        out.print(i+":");
        for(int j=0 ; j<ls.size(); j++)out.print(" "+ls.get(j));
        out.println();
      }
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := 2->pow(n)->oclAsType(int) - 1 ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var T : Sequence(int) ; T := Sequence{} ;
        var i : int ; i := 0 ; while i < k do (     T := T->including((in.getCurrent())->toInteger()) ;  ;     i := i + 1 ) ; 
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
        var i : int ; i := 0 ; while i <= m do ( (     var str : String ; str := (MathLib.decimal2binary(i) + "") ;
     var ls : Sequence(int) ; ls := Sequence{} ;
         var j : int ; j := 0 ; while j < str->size() do ( (     if (str->at(str->size() - 1 - j+1) = '1') then     ls := ls->including(j) ; else skip )  ;     j := j + 1 ) ; 
     if (ls->size() >= T->size() & ls->includesAll(T)) then (     skip ; 
         var j : int ; j := 0 ; while j < ls->size() do (     skip ;  ;     j := j + 1 ) ; 
     skip ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Comparator ;
import java.util.Collections ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    LIS solver=new LIS();
    solver.solve(1,in,out);
    out.close();
  }
  static class LIS {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=Integer.parseInt(in.next());
      int[] a=new int[n];
      Arrays.setAll(a,i->Integer.parseInt(in.next()));
      Integer[] dp=new Integer[n+1];
      final int INF=Integer.MAX_VALUE ;
      Arrays.fill(dp,INF);
      List<Integer>dpList=Arrays.asList(dp);
      Comparator<Integer>lowerBound=(x,y)->x.compareTo(y)>=0 ? 1 :-1 ;
      for(int i=0 ; i<n ; i++){
        int replaced=~ Collections.binarySearch(dpList,a[i],lowerBound);
        if(replaced>=0){
          dp[replaced]=a[i];
        }
      }
      int ans=-1 ;
      for(int i=n ; i>=0 ; i--){
        if(dp[i]<INF){
          ans=i+1 ;
          break ;
        }
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : LIS ; solver := LIS.newLIS() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class LIS {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (in.getCurrent())->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
setAll(a, lambda i : OclAny in (in.getCurrent())->toInteger()) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(null) ;
    var INF : int ; INF := 2147483647 ;
    dp := dp->collect(INF) ; 
    var dpList : Sequence(int) ; dpList := dp ;
    var lowerBound : Function(<int>,(<int>,boolean)) ; lowerBound := lambda (x , y) : OclAny in if x->compareTo(y) >= 0 then 1 else -1 endif ;
        var i : int ; i := 0 ; while i < n do ( (     var replaced : int ; replaced := -(.binarySearch(dpList, a[i+1], lowerBound) + 1) ;
     if (replaced >= 0) then (     dp[replaced+1] := a[i+1] ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -1 ;
        var i : int ; i := n ; while i >= 0 do ( (     if (dp[i+1] < INF) then (     ans := i + 1 ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    String[] str=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    BitSet bs=new BitSet(n);
    str=br.readLine().split(" ");
    int k=Integer.parseInt(str[0]);
    for(int i=0 ; i<k ; i++){
      int b=Integer.parseInt(str[i+1]);
      bs.set(b);
    }
    for(int i=0 ; i<(1<<n); i++){
      boolean flag=true ;
      for(int j=0 ; j<n ; j++){
        if(! bs.get(j))continue ;
        if((i &(1<<j))==0)flag=false ;
      }
      if(! flag)continue ;
      int sum=0 ;
      int pow2=1 ;
      ArrayList<Integer>a=new ArrayList<Integer>();
      for(int j=0 ; j<n ; j++){
        if((i &(1<<j))!=0){
          sum+=pow2 ;
          a.add(j);
        }
        pow2*=2 ;
      }
      pw.print(sum+":");
      if(i>0)pw.print(" ");
      for(int j=0 ; j<a.size(); j++){
        pw.print(a.get(j));
        if(j!=a.size()-1)pw.print(" ");
      }
      pw.print("\n");
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var bs : Sequence(boolean) ; bs := MathLib.toBitSequence(n) ;
    str := br.readLine()->split(" ") ; 
    var k : int ; k := (str[0+1])->toInteger() ;
        var i : int ; i := 0 ; while i < k do ( (     var b : int ; b := (str[i + 1+1])->toInteger() ;
     bs := bs.setAt(b+1, true) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < ((1*(2->pow(n)))->oclAsType(long)) do ( (     var flag : boolean ; flag := true ;
         var j : int ; j := 0 ; while j < n do ( (     if (not(bs->at(j+1))) then     continue else skip ; 
     if ((MathLib.bitwiseAnd(i,((1*(2->pow(j)))->oclAsType(long)))) = 0) then     flag := false ; else skip )  ;     j := j + 1 ) ; 
    if (not(flag)) then     continue else skip ; 
    var sum : int ; sum := 0 ;
    var pow2 : int ; pow2 := 1 ;
    var a : Sequence(int) ; a := Sequence{} ;
        var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd(i,((1*(2->pow(j)))->oclAsType(long)))) /= 0) then (     sum := sum+(pow2) ; 
     a := a->including(j) ) else skip ; 
     pow2 := pow2*(2) )  ;     j := j + 1 ) ; 
    skip ; 
    if (i > 0) then     skip ; else skip ; 
        var j : int ; j := 0 ; while j < a->size() do ( (     skip ; 
     if (j /= a->size() - 1) then     skip ; else skip )  ;     j := j + 1 ) ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeSet ;
public class Main {
  static int n ;
  static int count=0 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    boolean[] array=new boolean[n+1];
    int max=0 ;
    int k=sc.nextInt();
    Set<Integer>b=new TreeSet<>();
    for(int i=0 ; i<k ; i++){
      b.add(sc.nextInt());
    }
    if(k<=0){
      System.out.println("0:");
    }
    while(max<n){
      array[max]=true ;
      String str=++count+": " ;
      int index=0 ;
      int count=0 ;
      Set<Integer>tmpList=new TreeSet<>();
      for(int i=0 ; i<max ; i++){
        if(array[i]){
          str+=i+" " ;
++count ;
          tmpList.add(i);
        }
      }
      str+=max ;
      tmpList.add(max);
      for(int i=0 ; i<max ; i++){
        if(! array[i]){
          array[i]=true ;
          index=i ;
          break ;
        }
      }
      for(int j=0 ; j<n-2 ; j++){
        for(int i=0 ; i<index ; i++){
          if(array[i]){
            array[i]=false ;
            break ;
          }
        }
      }
      if(tmpList.containsAll(b)){
        System.out.println(str);
      }
      if(count>=max){
++max ;
        array=new boolean[n+1];
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute count : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    var array : Sequence(boolean) ; array := Integer.subrange(1,n + 1)->collect(false) ;
    var max : int ; max := 0 ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var b : Set(int) ; b := Set{} ;
        var i : int ; i := 0 ; while i < k do ( (     b := b->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    if (k <= 0) then (     OclFile["System.out"].println("0:") ) else skip ; 
    while (max < n) do (     array[max+1] := true ; 
     var str : String ;     count := count + 1 ;
str := count + ": " ;
    var index : int ; index := 0 ;
    var count : int ; count := 0 ;
    var tmpList : Set(int) ; tmpList := Set{} ;
        var i : int ; i := 0 ; while i < max do ( (     if (array[i+1]) then (     str := str+(i + " ") ; 
     count := count + 1 ; 
     tmpList := tmpList->including(i) ) else skip )  ;     i := i + 1 ) ; 
    str := str+(max) ; 
    tmpList := tmpList->including(max) ; 
        var i : int ; i := 0 ; while i < max do ( (     if (not(array[i+1])) then (     array[i+1] := true ; 
     index := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < n - 2 do ( (         var i : int ; i := 0 ; while i < index do ( (     if (array[i+1]) then (     array[i+1] := false ; 
     break ) else skip )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    if (tmpList->includesAll(b)) then (     OclFile["System.out"].println(str) ) else skip ; 
    if (count >= max) then (     max := max + 1 ; 
     array := Integer.subrange(1,n + 1)->collect(false) ) else skip ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long max=(1L<<n);
    int k=sc.nextInt();
    long base=0 ;
    for(int i=0 ; i<k ; i++){
      base+=(1L<<sc.nextInt());
    }
    StringBuilder sb=new StringBuilder();
    for(long i=0 ; i<max ; i++){
      if((base & i)!=base){
        continue ;
      }
      sb.append(i).append(":");
      long x=i ;
      for(int j=0 ; j<=18 && x>0 ; j++){
        if(x % 2==1){
          sb.append(" ").append(j);
        }
        x>>=1 ;
      }
      sb.append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var max : long ; max := ((1L*(2->pow(n)))->oclAsType(long)) ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var base : long ; base := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     base := base+(((1L*(2->pow(sc.getCurrent()->toInteger())))->oclAsType(long))) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : long ; i := 0 ; while i < max do ( (     if ((MathLib.bitwiseAnd(base,i)) /= base) then (     continue ) else skip ; 
     sb := sb + StringLib.newString(i) + StringLib.newString(":") ; 
    var x : long ; x := i ;
        var j : int ; j := 0 ; while j <= 18 & x > 0 do ( (     if (x mod 2 = 1) then (     sb := sb + StringLib.newString(" ") + StringLib.newString(j) ) else skip ; 
     x := x/(2->pow(1)) )  ;     j := j + 1 ) ; 
    sb := sb + StringLib.newString("\n") ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int n,i,j,factorial,k ;
    String str ;
    try(Scanner sc=new Scanner(System.in)){
      n=sc.nextInt();
      factorial=(int)(Math.pow(2,n));
      k=sc.nextInt();
      int[] b=new int[k];
      int[] a=new int[n];
      for(i=0 ; i<k ; i++){
        b[i]=sc.nextInt();
      }
      for(i=0 ; i<factorial ; i++){
        str=Integer.toBinaryString(i);
        for(j=0 ; j<str.length(); j++){
          a[j]=Character.getNumericValue(str.charAt(str.length()-j-1));
        }
        boolean bool=false ;
        for(j=0 ; j<k ; j++){
          if(a[b[j] ]==0){
            bool=true ;
          }
        }
        if(bool)continue ;
        System.out.print(i+":");
        for(j=0 ; j<str.length(); j++){
          if(a[j]==1){
            System.out.print(" "+j);
          }
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var i : int ;
    var j : int ;
    var factorial : int ;
    var k : int ;
     var str : String ;
     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     n := sc.getCurrent()->toInteger() ; 
     factorial := (2->pow(n))->oclAsType(int) ; 
    k := sc.getCurrent()->toInteger() ; 
    var b : Sequence(int) ; b := Integer.subrange(1,k)->collect(0) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < k do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        i := 0 ; while i < factorial do ( (     str := (MathLib.decimal2binary(i) + "") ; 
         j := 0 ; while j < str->size() do ( (     a[j+1] := ("" + str->at(str->size() - j - 1+1))->toInteger() )  ;     j := j + 1 ) ; 
    var bool : boolean ; bool := false ;
        j := 0 ; while j < k do ( (     if (a[b[j+1]+1] = 0) then (     bool := true ) else skip )  ;     j := j + 1 ) ; 
    if (bool) then     continue else skip ; 
    OclFile["System.out"].print(i + ":") ; 
        j := 0 ; while j < str->size() do ( (     if (a[j+1] = 1) then (     OclFile["System.out"].print(" " + j) ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findArea(float a,float b){
    float Area ;
    Area=(float)3.142*a*b ;
    System.out.println("Area: "+Area);
  }
  public static void main(String[] args){
    float a=5,b=4 ;
    findArea(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findArea( a : double, b : double) : void
  pre: true
  post: true
  activity: (     var Area : double ;
     Area := 3.142->oclAsType(double) * a * b ; 
     OclFile["System.out"].println("Area: " + Area) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 5 ;
    var b : double ; b := 4 ;
     execute findArea(a, b) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.io.*;
class GFG {
  static boolean check(int H,int S){
    return H*H>=4*S ;
  }
  static int findPairs(int H[],int n,int S[],int m){
    int count=0 ;
    Arrays.sort(H);
    Arrays.sort(S);
    int index=-1 ;
    for(int i=0 ; i<n ; i++){
      int start=0 ;
      int end=m-1 ;
      while(start<=end){
        int mid=start+(end-start)/2 ;
        if(check(H[i],S[mid])){
          index=mid ;
          start=mid+1 ;
        }
        else {
          end=mid-1 ;
        }
      }
      if(index!=-1){
        count+=index+1 ;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int H[]={
      1,6,4 };
      int n=H.length ;
      int S[]={
        23,3,42,14 };
        int m=S.length ;
        System.out.println(findPairs(H,n,S,m));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( H : int, S : int) : boolean
  pre: true
  post: true
  activity: (     return H * H >= 4 * S );
  static   operation findPairs( H : Sequence(int), n : int, S : Sequence(int), m : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     H := H->sort() ; 
    S := S->sort() ; 
    var index : int ; index := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var start : int ; start := 0 ;
     var end : int ; end := m - 1 ;
     while (start <= end) do (     var mid : int ; mid := start + (end - start) / 2 ;
     if (check(H[i+1], S[mid+1])) then (     index := mid ; 
     start := mid + 1 ) else (     end := mid - 1 ) ) ; 
     if (index /= -1) then (     count := count+(index + 1) ) else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var H : Sequence(int) ; H := Sequence{1,6,4} ;
     var n : int ; n := H->size() ;
    var S : Sequence(int) ; S := Sequence{23,3,42,14} ;
    var m : int ; m := S->size() ;
    OclFile["System.out"].println(findPairs(H, n, S, m)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double p=((1+Math.sqrt(5))/2);
  static double q=((1-Math.sqrt(5))/2);
  static int fib(int n){
    int i=n-1 ;
    int x=(int)((Math.pow(p,i)-Math.pow(q,i))/(p-q));
    return x ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(fib(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute p : double := ((1 + (5)->sqrt()) / 2);
  static   attribute q : double := ((1 - (5)->sqrt()) / 2);
  static   operation fib( n : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := n - 1 ;
     var x : int ; x := ((p->pow(i) - q->pow(i)) / (p - q))->oclAsType(int) ;
     return x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(fib(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findSplitPoint(int arr[],int n){
    int leftSum=0 ;
    for(int i=0 ; i<n ; i++)leftSum+=arr[i];
    int rightSum=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      rightSum+=arr[i];
      leftSum-=arr[i];
      if(rightSum==leftSum)return i ;
    }
    return-1 ;
  }
  static void printTwoParts(int arr[],int n){
    int splitPoint=findSplitPoint(arr,n);
    if(splitPoint==-1 || splitPoint==n){
      System.out.println("Not Possible");
      return ;
    }
    for(int i=0 ; i<n ; i++){
      if(splitPoint==i)System.out.println();
      System.out.print(arr[i]+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,5 };
      int n=arr.length ;
      printTwoParts(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSplitPoint( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var leftSum : int ; leftSum := 0 ;
         var i : int ; i := 0 ; while i < n do (     leftSum := leftSum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    var rightSum : int ; rightSum := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     rightSum := rightSum+(arr[i+1]) ; 
     leftSum := leftSum-(arr[i+1]) ; 
     if (rightSum = leftSum) then     return i else skip )  ;     i := i - 1 ) ; 
    return -1 
 );
  static   operation printTwoParts( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var splitPoint : int ; splitPoint := findSplitPoint(arr, n) ;
     if (splitPoint = -1 or splitPoint = n) then (     OclFile["System.out"].println("Not Possible") ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     if (splitPoint = i) then     OclFile["System.out"].println() ; else skip ; 
     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,5} ;
     var n : int ; n := arr->size() ;
     execute printTwoParts(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    String result="Good" ;
    String[] split=s.split("",0);
    for(int i=0 ; i<3 ; i++){
      if(split[i] .equals(split[i+1])){
        result="Bad" ;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var result : String ; result := "Good" ;
    var split : Sequence(String) ; split := s->split("") ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (split[i+1] = split[i + 1+1]) then (     result := "Bad" ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int gcd(int a,int b){
    return b>0 ? gcd(b,a % b): a ;
  }
  static int lcm(int a,int b){
    return a*b/gcd(a,b);
  }
  public static int lower_bound(int vector[],int key){
    return 0 ;
  }
  public static int max(int a,int b){
    if(a>b){
      return a ;
    }
    else {
      return b ;
    }
  }
  public static int min(int a,int b){
    if(a<b){
      return a ;
    }
    else {
      return b ;
    }
  }
  public static boolean isPrime(int n){
    if(n==2)return true ;
    if(n<2 || n % 2==0)return false ;
    double d=Math.sqrt(n);
    for(int i=3 ; i<=d ; i+=2)if(n % i==0){
      return false ;
    }
    return true ;
  }
  public static long factorial(int i){
    if(i==1){
      return 1 ;
    }
    else {
      return i*factorial(i-1);
    }
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String str=scan.next();
    char ch1=str.charAt(0),ch2=str.charAt(1),ch3=str.charAt(2),ch4=str.charAt(3);
    if(ch1==ch2 || ch2==ch3 || ch3==ch4){
      System.out.println("Bad");
    }
    else {
      System.out.println("Good");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b > 0 then gcd(b, a mod b) else a endif );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return a * b / gcd(a, b) );
  static   operation lower_bound( vector : Sequence(int), key : int) : int
  pre: true
  post: true
  activity: (     return 0 );
  static   operation max( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a > b) then (     return a ) else (     return b ) );
  static   operation min( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a < b) then (     return a ) else (     return b ) );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 2) then     return true else skip ; 
     if (n < 2 or n mod 2 = 0) then     return false else skip ; 
    var d : double ; d := (n)->sqrt() ;
        var i : int ; i := 3 ; while i <= d do (     if (n mod i = 0) then (     return false ) else skip ;  ;     i := i+(2) ) ; 
    return true 
 );
  static   operation factorial( i : int) : long
  pre: true
  post: true
  activity: (     if (i = 1) then (     return 1 ) else (     return i * factorial(i - 1) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := scan.getCurrent() ;
     var ch1 : String ; ch1 := str->at(0+1) ;
    var ch2 : String ; ch2 := str->at(1+1) ;
    var ch3 : String ; ch3 := str->at(2+1) ;
    var ch4 : String ; ch4 := str->at(3+1) ;
     if (ch1 = ch2 or ch2 = ch3 or ch3 = ch4) then (     OclFile["System.out"].println("Bad") ) else (     OclFile["System.out"].println("Good") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String...args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String password=null ;
    try {
      password=br.readLine();
      br.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
    System.out.println(isDifficultToInput(password)? "Bad" : "Good");
  }
  private static boolean isDifficultToInput(String word){
    String[] splitWord=word.split("");
    for(int i=0 ; i<splitWord.length-1 ; i++){
      String rear=splitWord[i];
      String front=splitWord[i+1];
      if(front.equals(rear)){
        return true ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var password : String ; password := null ;
     try (     password := br.readLine() ; 
     skip )   catch (e : IOException) do (     e.printStackTrace() )
     OclFile["System.out"].println(if isDifficultToInput(password) then "Bad" else "Good" endif) );
  static   operation isDifficultToInput( word : String) : boolean
  pre: true
  post: true
  activity: (     var splitWord : Sequence(String) ; splitWord := word->split("") ;
         var i : int ; i := 0 ; while i < splitWord->size() - 1 do ( (     var rear : String ; rear := splitWord[i+1] ;
     var front : String ; front := splitWord[i + 1+1] ;
     if (front = rear) then (     return true ) else skip )  ;     i := i + 1 ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    char before=' ' ;
    String ans="Good" ;
    for(char c : s.toCharArray()){
      if(c==before){
        ans="Bad" ;
        break ;
      }
      before=c ;
    }
    System.out.println(ans);
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var before : String ; before := ' ' ;
    var ans : String ; ans := "Good" ;
    for (c : s->characters()) do ( (     if (c = before) then (     ans := "Bad" ; 
     break ) else skip ; 
     before := c )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int S=sc.nextInt();
    int a=S % 10 ;
    int b=S % 100 ;
    int c=S % 1000 ;
    if((S-c)/1000==(c-b)/100){
      System.out.println("Bad");
    }
    else if((c-b)/100==(b-a)/10){
      System.out.println("Bad");
    }
    else if((b-a)/10==a){
      System.out.println("Bad");
    }
    else {
      System.out.println("Good");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : int ; S := sc.getCurrent()->toInteger() ;
    var a : int ; a := S mod 10 ;
    var b : int ; b := S mod 100 ;
    var c : int ; c := S mod 1000 ;
    if ((S - c) / 1000 = (c - b) / 100) then (     OclFile["System.out"].println("Bad") ) else     if ((c - b) / 100 = (b - a) / 10) then (     OclFile["System.out"].println("Bad") ) else     if ((b - a) / 10 = a) then (     OclFile["System.out"].println("Bad") ) else (     OclFile["System.out"].println("Good") ) ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printPermutation(int n,int k){
    for(int i=1 ; i<=n ; i++){
      int x=2*i-1 ;
      int y=2*i ;
      if(i<=k)System.out.print(y+" "+x+" ");
      else System.out.print(x+" "+y+" ");
    }
  }
  public static void main(String[] args){
    int n=2,k=1 ;
    printPermutation(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printPermutation( n : int, k : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= n do ( (     var x : int ; x := 2 * i - 1 ;
     var y : int ; y := 2 * i ;
     if (i <= k) then     OclFile["System.out"].print(y + " " + x + " ") ; else     OclFile["System.out"].print(x + " " + y + " ") ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
    var k : int ; k := 1 ;
     execute printPermutation(n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    FastReader sc=new FastReader();
    PrintWriter pw=new PrintWriter(System.out);
    pw.println((long)Math.pow(sc.nextInt(),2));
    pw.close();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     skip ; 
     skip );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    int r=scanner.nextInt();
    scanner.close();
    System.out.println(r*r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := scanner.getCurrent()->toInteger() ;
     skip ; 
     OclFile["System.out"].println(r * r) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int r=Integer.parseInt(sc.next());
    int result=r*r ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := (sc.getCurrent())->toInteger() ;
     var result : int ; result := r * r ;
     OclFile["System.out"].println(result) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.math.BigDecimal ;
import java.math.BigInteger ;
import java.math.RoundingMode ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.StringTokenizer ;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 class Pair {
    int p ;
    int q ;
    Pair(int p,int q){
      this.p=p ;
      this.q=q ;
    }
  }
  static int gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  static boolean check(char x){
    if(x=='a' || x=='e' || x=='i' || x=='o' || x=='u')return false ;
    return true ;
  }
  public static void main(String[] args){
    OutputStream outputStream=System.out ;
    FastReader sc=new FastReader();
    PrintWriter out=new PrintWriter(outputStream);
    int a=sc.nextInt();
    out.println(a*a);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static class Pair {
   attribute p : int;
   attribute q : int;
   static operation newPair( p : int, q : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(p, q);
    return self );
  operation initialise( p : int, q : int) : void
  pre: true  post: true
  activity: (     self.p := p ; 
     self.q := q );
}
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation check( x : String) : boolean
  pre: true
  post: true
  activity: (     if (x = 'a' or x = 'e' or x = 'i' or x = 'o' or x = 'u') then     return false else skip ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
     var sc : FastReader ; sc := FastReader.newFastReader() ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile(outputStream)) ;
    var a : int ; a := sc.nextInt() ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  static int MOD,N ;
  static int[][] table ;
  public static void main(String[] args)throws IOException {
    MyScanner sc=new MyScanner();
    PrintWriter out=new PrintWriter(System.out);
    N=sc.nextInt();
    MOD=sc.nextInt();
    table=new int[N+1][N+1];
    for(int rem=0 ; rem<N+1 ; rem++){
      table[N][rem]=rem ;
    }
    for(int pos=N-1 ; pos>=1 ; pos--){
      for(int rem=0 ; rem<N+1 ; rem++){
        table[pos][rem]=table[pos+1][rem];
        int factor=Math.min(pos,N+1-pos);
        if(factor<rem){
          table[pos][rem]+=table[pos][rem-factor];
          table[pos][rem] %=MOD ;
        }
      }
    }
    out.println(table[1][N]);
    out.flush();
  }
  static class MyScanner {
    private BufferedReader br ;
    private StringTokenizer tokenizer ;
    public MyScanner(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : int;
  static   attribute table : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    N := sc.nextInt() ; 
    MOD := sc.nextInt() ; 
    table := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ; 
        var rem : int ; rem := 0 ; while rem < N + 1 do ( (     table[N+1][rem+1] := rem )  ;     rem := rem + 1 ) ; 
        var pos : int ; pos := N - 1 ; while pos >= 1 do ( (         var rem : int ; rem := 0 ; while rem < N + 1 do ( (     table[pos+1][rem+1] := table[pos + 1+1][rem+1] ; 
     var factor : int ; factor := Set{pos, N + 1 - pos}->min() ;
     if (factor < rem) then (     table[pos+1][rem+1] := table[pos+1][rem+1]+(table[pos+1][rem - factor+1]) ; 
     table[pos+1][rem+1] := table[pos+1][rem+1] mod MOD ) else skip )  ;     rem := rem + 1 ) )  ;     pos := pos - 1 ) ; 
    skip ; 
    skip ; 
 );
  static class MyScanner {
   attribute br : OclFile;
   attribute tokenizer : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int r=sc.nextInt();
    sc.close();
    int p=3 ;
    int x=p*r*r ;
    int a=x/p ;
    System.out.println(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    skip ; 
    var p : int ; p := 3 ;
    var x : int ; x := p * r * r ;
    var a : int ; a := x / p ;
    OclFile["System.out"].println(a) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static class LIS {
    int[] arr ;
    public LIS(int[] arr){
      this.arr=arr ;
    }
    public int solve(){
      if(arr==null || arr.length==0){
        return 0 ;
      }
      int[] tailTable=new int[arr.length];
      tailTable[0]=arr[0];
      int len=1 ;
      for(int i=1 ; i<arr.length ; i++){
        if(arr[i]>tailTable[len-1]){
          tailTable[len++]=arr[i];
        }
        else if(arr[i]<tailTable[len-1]){
          int insertionIdx=Arrays.binarySearch(tailTable,0,len,arr[i]);
          if(insertionIdx<0){
            insertionIdx=-(insertionIdx+1);
          }
          tailTable[insertionIdx]=arr[i];
        }
      }
      return len ;
    }
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=scanner.nextInt();
    }
    LIS lis=new LIS(arr);
    System.out.println(lis.solve());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class LIS {
   attribute arr : Sequence(int);
   static operation newLIS( arr : Sequence(int)) : LIS
  pre: true
  post: true
  activity:
  ( var self : LIS ;
    self := createLIS();
    self.initialise(arr);
    return self );
  operation initialise( arr : Sequence(int)) : void
  pre: true  post: true
  activity: (     self.arr := arr );
   operation solve() : int
  pre: true
  post: true
  activity: (     if (arr = null or arr->size() = 0) then (     return 0 ) else skip ; 
     var tailTable : Sequence(int) ; tailTable := Integer.subrange(1,arr->size())->collect(0) ;
    tailTable[0+1] := arr[0+1] ; 
    var len : int ; len := 1 ;
        var i : int ; i := 1 ; while i < arr->size() do ( (     if (arr[i+1] > tailTable[len - 1+1]) then (      tailTable[len+1] := arr[i+1]  ; len := len + 1 ) else     if (arr[i+1] < tailTable[len - 1+1]) then (     var insertionIdx : int ; insertionIdx := (tailTable->indexOf(arr[i+1]) - 1) ;
     if (insertionIdx < 0) then (     insertionIdx := -(insertionIdx + 1) ) else skip ; 
     tailTable[insertionIdx+1] := arr[i+1] ) else skip ; )  ;     i := i + 1 ) ; 
    return len 
 );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var lis : LIS ; lis := LIS.newLIS(arr) ;
    OclFile["System.out"].println(lis.solve()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigDecimal ;
import java.math.RoundingMode ;
class Main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int l=scn.nextInt();
    double third=(double)l/3 ;
    BigDecimal bd=new BigDecimal(third*third*third);
    System.out.println(bd.setScale(12,RoundingMode.HALF_UP));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := scn.getCurrent()->toInteger() ;
    var third : double ; third := l->oclAsType(double) / 3 ;
    var bd : double ; bd := double(third * third * third) ;
    OclFile["System.out"].println(bd.setScale(12, RoundingMode.HALF_UP)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.*;
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    FastReader sc=new FastReader();
    double l=sc.nextDouble();
    double ans=(l*l*l)/(3*3*3);
    System.out.println(ans);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var l : double ; l := sc.nextDouble() ;
     var ans : double ; ans := (l * l * l) / (3 * 3 * 3) ;
     OclFile["System.out"].println(ans) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.BigDecimal ;
import java.math.RoundingMode ;
class Main {
  public static void main(String args[])throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      double input=Double.parseDouble(br.readLine());
      BigDecimal num=new BigDecimal(input);
      BigDecimal three=new BigDecimal(3);
      BigDecimal x=num.divide(three,6,RoundingMode.HALF_UP);
      BigDecimal answer=x.multiply(x).multiply(x);
      double result=answer.doubleValue();
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var input : double ; input := (br.readLine())->toReal() ;
     var num : double ; num := double(input) ;
    var three : double ; three := double(3) ;
    var x : double ; x := num.divide(three, 6, RoundingMode.HALF_UP) ;
    var answer : double ; answer := x.multiply(x).multiply(x) ;
    var result : double ; result := answer->oclAsType(double) ;
    OclFile["System.out"].println(result) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double n=sc.nextDouble();
    double l=n/3 ;
    System.out.println(Math.pow(l,3));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : double ; n := sc.getCurrent()->toReal() ;
     var l : double ; l := n / 3 ;
     OclFile["System.out"].println(l->pow(3)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int MOD=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double L=sc.nextDouble();
    double ans=Math.pow(L/3.0,3);
    System.out.println(String.format("%.12f",ans));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var L : double ; L := sc.getCurrent()->toReal() ;
     var ans : double ; ans := L / 3.0->pow(3) ;
     OclFile["System.out"].println(StringLib.format("%.12f",Sequence{ans})) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_EhabAndAnotherConstructionProblem {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=i ; j++){
        if(i % j==0){
          if(i*j>n){
            if(i/j<n){
              System.out.println(i+" "+j);
              System.exit(0);
            }
            else {
              continue ;
            }
          }
          else continue ;
        }
        else continue ;
      }
    }
    System.out.println("-1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_EhabAndAnotherConstructionProblem {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= i do ( (     if (i mod j = 0) then (     if (i * j > n) then (     if (i / j < n) then (     OclFile["System.out"].println(i + " " + j) ; 
 OclProcess.exit(0) ) else (     continue ) ) else     continue ) else     continue )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("-1") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args)throws java.lang.Exception {
    FastReader sc=new FastReader();
    int x=sc.nextInt();
    if(x==1)System.out.println("-1");
    else System.out.println(x+" "+x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var x : int ; x := sc.nextInt() ;
     if (x = 1) then     OclFile["System.out"].println("-1") ; else     OclFile["System.out"].println(x + " " + x) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int nCr(int n,int r){
    return fact(n)/(fact(r)*fact(n-r));
  }
  static int fact(int n){
    int res=1 ;
    for(int i=2 ; i<=n ; i++)res=res*i ;
    return res ;
  }
  public static void main(String[] args){
    int n=5,r=3 ;
    System.out.println(nCr(n,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nCr( n : int, r : int) : int
  pre: true
  post: true
  activity: (     return fact(n) / (fact(r) * fact(n - r)) );
  static   operation fact( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
         var i : int ; i := 2 ; while i <= n do (     res := res * i ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var r : int ; r := 3 ;
     OclFile["System.out"].println(nCr(n, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int MOD=1000000007 ;
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] aArr=new int[m];
    int[] bArr=new int[m];
    for(int i=0 ; i<m ; i++){
      aArr[i]=sc.nextInt()-1 ;
      bArr[i]=sc.nextInt()-1 ;
    }
    int q=sc.nextInt();
    int[][] dp=new int[11][n];
    int[] colors=new int[q+1];
    for(int i=1 ; i<=q ; i++){
      int x=sc.nextInt()-1 ;
      int y=sc.nextInt();
      dp[y][x]=i ;
      colors[i]=sc.nextInt();
    }
    for(int i=9 ; i>=0 ; i--){
      for(int j=0 ; j<n ; j++){
        dp[i][j]=Math.max(dp[i][j],dp[i+1][j]);
      }
      for(int j=0 ; j<m ; j++){
        dp[i][aArr[j] ]=Math.max(dp[i][aArr[j] ],dp[i+1][bArr[j] ]);
        dp[i][bArr[j] ]=Math.max(dp[i][bArr[j] ],dp[i+1][aArr[j] ]);
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      sb.append(colors[dp[0][i] ]).append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var aArr : Sequence(int) ; aArr := Integer.subrange(1,m)->collect(0) ;
    var bArr : Sequence(int) ; bArr := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     aArr[i+1] := sc.getCurrent()->toInteger() - 1 ; 
     bArr[i+1] := sc.getCurrent()->toInteger() - 1 )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,11)->collect(Integer.subrange(1,n)->collect(0)) ;
    var colors : Sequence(int) ; colors := Integer.subrange(1,q + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= q do ( (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     dp[y+1][x+1] := i ; 
     colors[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 9 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < n do ( (     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i + 1+1][j+1]}->max() )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < m do ( (     dp[i+1][aArr[j+1]+1] := Set{dp[i+1][aArr[j+1]+1], dp[i + 1+1][bArr[j+1]+1]}->max() ; 
     dp[i+1][bArr[j+1]+1] := Set{dp[i+1][bArr[j+1]+1], dp[i + 1+1][aArr[j+1]+1]}->max() )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     sb := sb + StringLib.newString(colors[dp[0+1][i+1]+1]) + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxProfit(int[] price,int n,int k){
    int[][] profit=new int[k+1][n+1];
    for(int i=0 ; i<=k ; i++)profit[i][0]=0 ;
    for(int j=0 ; j<=n ; j++)profit[0][j]=0 ;
    for(int i=1 ; i<=k ; i++){
      for(int j=1 ; j<n ; j++){
        int max_so_far=0 ;
        for(int m=0 ; m<j ; m++)max_so_far=Math.max(max_so_far,price[j]-price[m]+profit[i-1][m]);
        profit[i][j]=Math.max(profit[i][j-1],max_so_far);
      }
    }
    return profit[k][n-1];
  }
  public static void main(String[] args){
    int k=2 ;
    int[] price={
      10,22,5,75,65,80 };
      int n=price.length ;
      System.out.println("Maximum profit is: "+maxProfit(price,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxProfit( price : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var profit : Sequence(Sequence(int)) ; profit := Integer.subrange(1,k + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i <= k do (     profit[i+1][0+1] := 0 ;  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j <= n do (     profit[0+1][j+1] := 0 ;  ;     j := j + 1 ) ; 
        var i : int ; i := 1 ; while i <= k do ( (         var j : int ; j := 1 ; while j < n do ( (     var max_so_far : int ; max_so_far := 0 ;
         var m : int ; m := 0 ; while m < j do (     max_so_far := Set{max_so_far, price[j+1] - price[m+1] + profit[i - 1+1][m+1]}->max() ;  ;     m := m + 1 ) ; 
     profit[i+1][j+1] := Set{profit[i+1][j - 1+1], max_so_far}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return profit[k+1][n - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 2 ;
     var price : Sequence(int) ; price := Sequence{10,22,5,75,65,80} ;
     var n : int ; n := price->size() ;
     OclFile["System.out"].println("Maximum profit is: " + maxProfit(price, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class C {
  static Map<Prison,Integer>cache=new HashMap<Prison,Integer>();
  static class Prison {
    int start,end ;
    Prison(int s,int e){
      this.start=s ;
      this.end=e ;
    }
    public int hashCode(){
      return start*10001+end ;
    }
    public boolean equals(Object o){
      return o.hashCode()==hashCode();
    }
    int solve(){
      Integer solution=cache.get(this);
      if(solution!=null)return solution ;
      solution=solve0();
      cache.put(this,solution);
      return solution ;
    }
    int solve0(){
      if(length()==0)return 0 ;
      int answer=Integer.MAX_VALUE ;
      for(int q : Q){
        if(q<start || q>end)continue ;
        Prison left=new Prison(start,q-1);
        Prison right=new Prison(q+1,end);
        int sol=left.length()+right.length()+left.solve()+right.solve();
        if(sol<answer)answer=sol ;
      }
      if(answer==Integer.MAX_VALUE)return 0 ;
      return answer ;
    }
    int length(){
      return end-start+1 ;
    }
  }
  static List<Integer>Q=new ArrayList<Integer>();
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    s.useDelimiter("\\s+");
    int testCases=s.nextInt();
    for(int t=0 ; t<testCases ; t++){
      Q.clear();
      int p=s.nextInt();
      int q=s.nextInt();
      for(int i=0 ; i<q ; i++){
        Q.add(s.nextInt());
      }
      Prison prison=new Prison(1,p);
      cache.clear();
      int sol=prison.solve();
      System.out.printf("Case #%d: %d\n",t+1,sol);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   attribute cache : Map(Prison,int) := Map{};
  static class Prison {
   attribute start : int;
   static operation newPrison( s : int, e : int) : Prison
  pre: true
  post: true
  activity:
  ( var self : Prison ;
    self := createPrison();
    self.initialise(s, e);
    return self );
  operation initialise( s : int, e : int) : void
  pre: true  post: true
  activity: (     self.start := s ; 
     self.end := e );
   operation hashCode() : int
  pre: true
  post: true
  activity: (     return start * 10001 + end );
   operation equals( o : OclAny) : boolean
  pre: true
  post: true
  activity: (     return o.hashCode() = hashCode() );
   operation solve() : int
  pre: true
  post: true
  activity: (     var solution : int ; solution := cache->at(self) ;
     if (solution /= null) then     return solution else skip ; 
    solution := solve0() ; 
    cache := cache->union(Map{self |-> solution}) ; 
    return solution 
 );
   operation solve0() : int
  pre: true
  post: true
  activity: (     if (size = 0) then     return 0 else skip ; 
     var answer : int ; answer := 2147483647 ;
    for (q : Q) do ( (     if (q < start or q > end) then     continue else skip ; 
     var left : Prison ; left := Prison.newPrison(start, q - 1) ;
    var right : Prison ; right := Prison.newPrison(q + 1, end) ;
    var sol : int ; sol := left->size() + right->size() + left.solve() + right.solve() ;
    if (sol < answer) then     answer := sol ; else skip ; 
 )  ) ; 
    if (answer = 2147483647) then     return 0 else skip ; 
    return answer 
 );
   operation length() : int
  pre: true
  post: true
  activity: (     return end - start + 1 );
}
  static   attribute Q : Sequence(int) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
     var testCases : int ; testCases := s.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < testCases do ( (     Q := Q->intersection(Set{}) ; 
     var p : int ; p := s.getCurrent()->toInteger() ;
    var q : int ; q := s.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     Q := Q->including(s.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var prison : Prison ; prison := Prison.newPrison(1, p) ;
    cache := cache->intersection(Map{}) ; 
    var sol : int ; sol := prison.solve() ;
    OclFile["System.out"].printf("Case #%d: %d\n", t + 1, sol) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Scanner ;
import java.util.concurrent.LinkedBlockingDeque ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      String str=sc.next();
      if("0".equals(str)){
        return ;
      }
      char[] one=str.toCharArray();
      char[] two=sc.next().toCharArray();
      char[] three=sc.next().toCharArray();
      int a1=0,a2=0,a_3=0,b1=0,b2=0,b3=0 ;
      for(int i=1 ; i<one.length ; i++){
        if(one[i]=='A'){
          a1++;
        }
        else if(one[i]=='B'){
          b1++;
        }
      }
      if(two[0]=='A'){
        a1++;
      }
      else if(two[0]=='B'){
        b1++;
      }
      for(int i=1 ; i<two.length ; i++){
        if(two[i]=='A'){
          a2++;
        }
        else if(two[i]=='B'){
          b2++;
        }
      }
      if(three[0]=='A'){
        a2++;
      }
      else if(three[0]=='B'){
        b2++;
      }
      for(int i=1 ; i<three.length ; i++){
        if(three[i]=='A'){
          a3++;
        }
        else if(three[i]=='B'){
          b3++;
        }
      }
      if(a3>b3){
        a3++;
      }
      else {
        b3++;
      }
      System.out.println(a1+" "+b1);
      System.out.println(a2+" "+b2);
      System.out.println(a3+" "+b3);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var str : String ; str := sc.getCurrent() ;
     if ("0" = str) then (     return ) else skip ; 
    var one : Sequence(String) ; one := str->characters() ;
    var two : Sequence(String) ; two := sc.getCurrent()->characters() ;
    var three : Sequence(String) ; three := sc.getCurrent()->characters() ;
    var a1 : int ; a1 := 0 ;
    var a2 : int ; a2 := 0 ;
    var a_3 : int ; a_3 := 0 ;
    var b1 : int ; b1 := 0 ;
    var b2 : int ; b2 := 0 ;
    var b3 : int ; b3 := 0 ;
        var i : int ; i := 1 ; while i < one->size() do ( (     if (one[i+1] = 'A') then (     a1 := a1 + 1 ) else     if (one[i+1] = 'B') then (     b1 := b1 + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    if (two[0+1] = 'A') then (     a1 := a1 + 1 ) else     if (two[0+1] = 'B') then (     b1 := b1 + 1 ) else skip ; ;  
        var i : int ; i := 1 ; while i < two->size() do ( (     if (two[i+1] = 'A') then (     a2 := a2 + 1 ) else     if (two[i+1] = 'B') then (     b2 := b2 + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    if (three[0+1] = 'A') then (     a2 := a2 + 1 ) else     if (three[0+1] = 'B') then (     b2 := b2 + 1 ) else skip ; ;  
        var i : int ; i := 1 ; while i < three->size() do ( (     if (three[i+1] = 'A') then (     a3 := a3 + 1 ) else     if (three[i+1] = 'B') then (     b3 := b3 + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    if (a3 > b3) then (     a3 := a3 + 1 ) else (     b3 := b3 + 1 ) ;  
    OclFile["System.out"].println(a1 + " " + b1) ; 
    OclFile["System.out"].println(a2 + " " + b2) ; 
    OclFile["System.out"].println(a3 + " " + b3) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[] a=new int[M];
    int[] b=new int[M];
    for(int i=0 ; i<M ; i++){
      a[i]=sc.nextInt()-1 ;
      b[i]=sc.nextInt()-1 ;
    }
    int MAXD=10 ;
    int[][] dp=new int[N][MAXD+1];
    int Q=sc.nextInt();
    int[] c=new int[Q+1];
    for(int i=0 ; i<Q ; i++){
      int v=sc.nextInt()-1 ;
      int d=sc.nextInt();
      c[i+1]=sc.nextInt();
      dp[v][d]=Math.max(dp[v][d],i+1);
    }
    for(int i=MAXD ; i>0 ; i--){
      for(int j=0 ; j<M ; j++){
        dp[a[j] ][i-1]=Math.max(dp[a[j] ][i-1],dp[b[j] ][i]);
        dp[b[j] ][i-1]=Math.max(dp[b[j] ][i-1],dp[a[j] ][i]);
      }
      for(int j=0 ; j<N ; j++){
        dp[j][i-1]=Math.max(dp[j][i-1],dp[j][i]);
      }
    }
    for(int i=0 ; i<N ; i++)pw.println(c[dp[i][0] ]);
    sc.close();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,M)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     a[i+1] := sc.getCurrent()->toInteger() - 1 ; 
     b[i+1] := sc.getCurrent()->toInteger() - 1 )  ;     i := i + 1 ) ; 
    var MAXD : int ; MAXD := 10 ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,N)->collect(Integer.subrange(1,MAXD + 1)->collect(0)) ;
    var Q : int ; Q := sc.getCurrent()->toInteger() ;
    var c : Sequence(int) ; c := Integer.subrange(1,Q + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < Q do ( (     var v : int ; v := sc.getCurrent()->toInteger() - 1 ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
     c[i + 1+1] := sc.getCurrent()->toInteger() ; 
     dp[v+1][d+1] := Set{dp[v+1][d+1], i + 1}->max() )  ;     i := i + 1 ) ; 
        var i : int ; i := MAXD ; while i > 0 do ( (         var j : int ; j := 0 ; while j < M do ( (     dp[a[j+1]+1][i - 1+1] := Set{dp[a[j+1]+1][i - 1+1], dp[b[j+1]+1][i+1]}->max() ; 
     dp[b[j+1]+1][i - 1+1] := Set{dp[b[j+1]+1][i - 1+1], dp[a[j+1]+1][i+1]}->max() )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < N do ( (     dp[j+1][i - 1+1] := Set{dp[j+1][i - 1+1], dp[j+1][i+1]}->max() )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < N do (     skip ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int N=3 ;
  static final int M=3 ;
  static int sumOddOccurring(int arr[][]){
    Map<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<M ; j++){
        if(mp.get(arr[i][j])==null)mp.put(arr[i][j],1);
        else mp.put(arr[i][j],(mp.get(arr[i][j])+1));
      }
    }
    int sum=0 ;
    Set<Map.Entry<Integer,Integer>>st=mp.entrySet();
    for(Map.Entry<Integer,Integer>me : st){
      if(me.getValue()% 2==0){
        int x=me.getValue();
        sum+=(me.getKey())*(me.getValue());
      }
    }
    return sum ;
  }
  public static void main(String args[]){
    int mat[][]={
      {
        1,2,3 },{
          1,3,2 },{
            1,5,6 }
          };
          System.out.print(sumOddOccurring(mat));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute N : int := 3;
  static    attribute M : int := 3;
  static   operation sumOddOccurring( arr : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < M do ( (     if (mp->at(arr[i+1][j+1]) = null) then     mp := mp->union(Map{arr[i+1][j+1] |-> 1}) ; else     mp := mp->union(Map{arr[i+1][j+1] |-> (mp->at(arr[i+1][j+1]) + 1)}) ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var st : Set(Map(int,int)) ; st := mp->asSet() ;
    for (me : st) do ( (     if (me.getValue() mod 2 = 0) then (     var x : int ; x := me.getValue() ;
     sum := sum+((me.getKey()) * (me.getValue())) ) else skip )  ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,2,3},Sequence{1,3,2},Sequence{1,5,6}} ;
     OclFile["System.out"].print(sumOddOccurring(mat)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int steps(int N,int M){
    if(N==1)return 0 ;
    else if(N==2)return M ;
    return 2*M+(N-3);
  }
  public static void main(String[] args){
    int N=4,M=4 ;
    System.out.print(steps(N,M));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation steps( N : int, M : int) : int
  pre: true
  post: true
  activity: (     if (N = 1) then     return 0 else     if (N = 2) then     return M else skip ; ;  
     return 2 * M + (N - 3) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
    var M : int ; M := 4 ;
     OclFile["System.out"].print(steps(N, M)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String s ;
  static void reverseStr(int l,int h){
    int n=h-l ;
    for(int i=0 ; i<n/2 ; i++){
      s=swap(i+l,n-i-1+l);
    }
  }
  static void reverseString(int A[],int n){
    reverseStr(0,A[0]);
    for(int i=1 ; i<n ; i++)reverseStr(A[i-1],A[i]);
    reverseStr(A[n-1],s.length());
  }
  static String swap(int i,int j){
    char ch[]=s.toCharArray();
    char temp=ch[i];
    ch[i]=ch[j];
    ch[j]=temp ;
    return String.valueOf(ch);
  }
  public static void main(String[] args){
    s="abcdefgh" ;
    int A[]={
      2,4,6 };
      int n=A.length ;
      reverseString(A,n);
      System.out.print(s);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute s : String;
  static   operation reverseStr( l : int, h : int) : void
  pre: true
  post: true
  activity: (     var n : int ; n := h - l ;
         var i : int ; i := 0 ; while i < n / 2 do ( (     s := swap(i + l, n - i - 1 + l) )  ;     i := i + 1 ) );
  static   operation reverseString( A : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     execute reverseStr(0, A[0+1]) ; 
         var i : int ; i := 1 ; while i < n do (     execute reverseStr(A[i - 1+1], A[i+1]) ;  ;     i := i + 1 ) ; 
     execute reverseStr(A[n - 1+1], s->size()) );
  static   operation swap( i : int, j : int) : String
  pre: true
  post: true
  activity: (     var ch : Sequence(String) ; ch := s->characters() ;
     var temp : String ; temp := ch[i+1] ;
    ch[i+1] := ch[j+1] ; 
    ch[j+1] := temp ; 
    return ((ch) + "") 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     s := "abcdefgh" ; 
     var A : Sequence(int) ; A := Sequence{2,4,6} ;
    var n : int ; n := A->size() ;
    execute reverseString(A, n) ; 
    OclFile["System.out"].print(s) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication101 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    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 sum=0 ;
    for(int i=0 ; i<arr.length ; i++){
      sum+=arr[i];
    }
    sum=Math.abs(sum);
    int ans=sum/k ;
    if(sum % k!=0){
      ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication101 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    sum := if sum < 0 then -(sum) else sum endif ; 
    var ans : int ; ans := sum / k ;
    if (sum mod k /= 0) then (     ans := ans + 1 ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class VanyaAndCards {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    short n=s.nextShort();
    short x=s.nextShort();
    int sum=0 ;
    for(short i=0 ; i<n ; i++)sum+=s.nextInt();
    if(sum==0){
      System.out.println("0");
    }
    else if(sum<0){
      sum=Math.abs(sum);
      System.out.println((int)(Math.ceil(1.0*sum/x)));
    }
    else {
      System.out.println((int)(Math.ceil(1.0*sum/x)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class VanyaAndCards {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.nextShort() ;
    var x : int ; x := s.nextShort() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (     sum := sum+(s.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    if (sum = 0) then (     OclFile["System.out"].println("0") ) else     if (sum < 0) then (     sum := if sum < 0 then -(sum) else sum endif ; 
     OclFile["System.out"].println(((1.0 * sum / x)->ceil())->oclAsType(int)) ) else (     OclFile["System.out"].println(((1.0 * sum / x)->ceil())->oclAsType(int)) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Codeforces {
  public static void main(String[] args){
    MyScanner scanner=new MyScanner();
    int n=scanner.nextInt();
    int x=scanner.nextInt();
    int sum=0 ;
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=scanner.nextInt();
      sum+=arr[i];
    }
    int res=Math.abs(sum/x);
    res+=sum % x==0 ? 0 : 1 ;
    System.out.println(res);
  }
  static class MyScanner {
    private BufferedReader br ;
    private 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : MyScanner ; scanner := MyScanner.newMyScanner() ;
     var n : int ; n := scanner.nextInt() ;
    var x : int ; x := scanner.nextInt() ;
    var sum : int ; sum := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scanner.nextInt() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    var res : int ; res := if sum / x < 0 then -(sum / x) else sum / x endif ;
    res := res+(if sum mod x = 0 then 0 else 1 endif) ; 
    OclFile["System.out"].println(res) ; 
 );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int __gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static void MaxLCM(int n){
    if(n % 2!=0)System.out.print(n+" "+(n-1)+" "+(n-2));
    else if(__gcd(n,(n-3))==1)System.out.print(n+" "+(n-1)+" "+(n-3));
    else System.out.print((n-1)+" "+(n-2)+" "+(n-3));
  }
  public static void main(String[] args){
    int n=12 ;
    MaxLCM(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
    if (a = b) then     return a else skip ; 
    if (a > b) then     return __gcd(a - b, b) else skip ; 
    return __gcd(a, b - a) 
 );
  static   operation MaxLCM( n : int) : void
  pre: true
  post: true
  activity: (     if (n mod 2 /= 0) then     OclFile["System.out"].print(n + " " + (n - 1) + " " + (n - 2)) ; else     if (__gcd(n, (n - 3)) = 1) then     OclFile["System.out"].print(n + " " + (n - 1) + " " + (n - 3)) else     OclFile["System.out"].print((n - 1) + " " + (n - 2) + " " + (n - 3)) ; ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     execute MaxLCM(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Ladder {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int days[]=new int[3002];
    int n=scanner.nextInt();
    int v=scanner.nextInt();
    for(int i=0 ; i<n ; i++){
      int day=scanner.nextInt();
      int friuts=scanner.nextInt();
      days[day]+=friuts ;
    }
    int ret=0 ;
    for(int i=1 ; i<3002 ; i++){
      int gain=0 ;
      gain+=Math.min(days[i-1],v);
      if(gain<v){
        int temp=Math.min(v-gain,days[i]);
        gain+=temp ;
        days[i]-=temp ;
      }
      ret+=gain ;
    }
    System.out.println(ret);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ladder {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var days : Sequence(int) ; days := Integer.subrange(1,3002)->collect(0) ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var v : int ; v := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var day : int ; day := scanner.getCurrent()->toInteger() ;
     var friuts : int ; friuts := scanner.getCurrent()->toInteger() ;
     days[day+1] := days[day+1]+(friuts) )  ;     i := i + 1 ) ; 
    var ret : int ; ret := 0 ;
        var i : int ; i := 1 ; while i < 3002 do ( (     var gain : int ; gain := 0 ;
     gain := gain+(Set{days[i - 1+1], v}->min()) ; 
     if (gain < v) then (     var temp : int ; temp := Set{v - gain, days[i+1]}->min() ;
     gain := gain+(temp) ; 
     days[i+1] := days[i+1]-(temp) ) else skip ; 
     ret := ret+(gain) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ret) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean canMakeEqual(int a[],int n){
    for(int i=0 ; i<n ; i++){
      while(a[i] % 5==0){
        a[i]/=5 ;
      }
      while(a[i] % 3==0){
        a[i]/=3 ;
      }
    }
    int last=a[0];
    for(int i=1 ; i<n ; i++){
      if(a[i]!=last){
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    int arr[]={
      18,30,54,90,162 };
      int n=arr.length ;
      if(canMakeEqual(arr,n)){
        System.out.print("YES"+"\n");
      }
      else {
        System.out.print("NO"+"\n");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation canMakeEqual( a : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     while (a[i+1] mod 5 = 0) do (     a[i+1] := a[i+1]/(5) ) ; 
     while (a[i+1] mod 3 = 0) do (     a[i+1] := a[i+1]/(3) ) )  ;     i := i + 1 ) ; 
     var last : int ; last := a[0+1] ;
         var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] /= last) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{18,30,54,90,162} ;
     var n : int ; n := arr->size() ;
     if (canMakeEqual(arr, n)) then (     OclFile["System.out"].print("YES" + "\n") ) else (     OclFile["System.out"].print("NO" + "\n") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().solve();
  }
  void solve(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    System.out.println(LIS(a));
  }
  int LIS(int[] a){
    int n=a.length ;
    ArrayList<Integer>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      if(list.isEmpty()|| a[i]>list.get(list.size()-1)){
        list.add(a[i]);
      }
      else if(list.get(list.size()-1)==a[i]){
        continue ;
      }
      else {
        int first=0 ;
        int last=list.size()-1 ;
        while(first+1!=last && !(first==0 && last==0)){
          int mid=(first+last)/2 ;
          if(list.get(mid)>a[i]){
            last=mid ;
          }
          else {
            first=mid ;
          }
        }
        if(list.get(first)>a[i]){
          list.set(first,a[i]);
        }
        else if(list.get(first)!=a[i])list.set(last,a[i]);
      }
    }
    return list.size();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(LIS(a)) ; 
 );
   operation LIS( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() ;
     var list : Sequence(int) ; list := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (list->isEmpty() or a[i+1] > list->at(list->size() - 1+1)) then (     list := list->including(a[i+1]) ) else     if (list->at(list->size() - 1+1) = a[i+1]) then (     continue ) else (     var first : int ; first := 0 ;
     var last : int ; last := list->size() - 1 ;
     while (first + 1 /= last & not((first = 0 & last = 0))) do (     var mid : int ; mid := (first + last) / 2 ;
     if (list->at(mid+1) > a[i+1]) then (     last := mid ) else (     first := mid ) ) ; 
     if (list->at(first+1) > a[i+1]) then (     list := list.setAt(first+1,a[i+1]) ) else     if (list->at(first+1) /= a[i+1]) then     list := list.setAt(last+1,a[i+1]) ; else skip ; ) ;  )  ;     i := i + 1 ) ; 
     return list->size() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int[] sq=new int[20001];
  public static void main(String[] args){
    for(int i=1 ; i*i<20000 ; ++i){
      sq[i*i]=i ;
    }
    int N=sc.nextInt();
    for(int i=0 ; i<N ; ++i){
      int m=sc.nextInt();
      int n=sc.nextInt();
      System.out.println(solve(m,n)? "P" : "C");
    }
  }
  static boolean solve(int M,int N){
    int D=M*M+N*N ;
    for(int i=2 ; i*i<=D ; ++i){
      if(D % i!=0)continue ;
      for(int p=1 ; p*p<=i ; ++p){
        int q=sq[i-p*p];
        if(p*p!=i && q==0)continue ;
        if((M*p+N*q)% i==0 &&(M*q-N*p)% i==0)return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute sq : Sequence(int) := Integer.subrange(1,20001)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i * i < 20000 do ( (     sq[i * i+1] := i )  ;     i := i + 1 ) ; 
     var N : int ; N := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < N do ( (     var m : int ; m := sc.getCurrent()->toInteger() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if solve(m, n) then "P" else "C" endif) )  ;     i := i + 1 ) );
  static   operation solve( M : int, N : int) : boolean
  pre: true
  post: true
  activity: (     var D : int ; D := M * M + N * N ;
         var i : int ; i := 2 ; while i * i <= D do ( (     if (D mod i /= 0) then     continue else skip ; 
         var p : int ; p := 1 ; while p * p <= i do ( (     var q : int ; q := sq[i - p * p+1] ;
     if (p * p /= i & q = 0) then     continue else skip ; 
     if ((M * p + N * q) mod i = 0 & (M * q - N * p) mod i = 0) then     return false else skip )  ;     p := p + 1 ) )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int sizeSubSet(int a[],int k,int n){
    Arrays.sort(a);
    HashMap<Integer,Integer>s=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      if(a[i] % k!=0 || s.get(a[i]/k)==null)s.put(a[i],s.get(a[i])==null ? 1 : s.get(a[i])+1);
    }
    return s.size();
  }
  public static void main(String args[]){
    int a[]={
      1,2,3,4,5,6,7,8,9,10 };
      int n=a.length ;
      int k=2 ;
      System.out.println(sizeSubSet(a,k,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sizeSubSet( a : Sequence(int), k : int, n : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var s : Map(int,int) ; s := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] mod k /= 0 or s->at(a[i+1] / k) = null) then     s := s->union(Map{a[i+1] |-> if s->at(a[i+1]) = null then 1 else s->at(a[i+1]) + 1 endif}) ; else skip )  ;     i := i + 1 ) ; 
     return s.size() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,4,5,6,7,8,9,10} ;
     var n : int ; n := a->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(sizeSubSet(a, k, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int calculate(int a[],int n){
    int maximum=Arrays.stream(a).max().getAsInt();
    int frequency[]=new int[maximum+1];
    for(int i=0 ; i<n ; i++){
      frequency[a[i] ]+=1 ;
    }
    int answer=0 ;
    for(int i=0 ; i<(maximum)+1 ; i++){
      answer=answer+frequency[i]*(frequency[i]-1);
    }
    return answer/2 ;
  }
  public static void main(String[] args){
    int a[]={
      1,2,1,2,4 };
      int n=a.length ;
      System.out.println(calculate(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculate( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var maximum : int ; maximum := stream(a).max().getAsInt() ;
     var frequency : Sequence(int) ; frequency := Integer.subrange(1,maximum + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     frequency[a[i+1]+1] := frequency[a[i+1]+1]+(1) )  ;     i := i + 1 ) ; 
    var answer : int ; answer := 0 ;
        var i : int ; i := 0 ; while i < (maximum) + 1 do ( (     answer := answer + frequency[i+1] * (frequency[i+1] - 1) )  ;     i := i + 1 ) ; 
    return answer / 2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,1,2,4} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(calculate(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=26 ;
  static boolean canBeMadeEqual(String str1,String str2){
    int len1=str1.length();
    int len2=str2.length();
    if(len1==len2){
      int freq[]=new int[MAX];
      for(int i=0 ; i<len1 ; i++){
        freq[str1.charAt(i)-'a']++;
      }
      for(int i=0 ; i<len2 ; i++){
        if(freq[str2.charAt(i)-'a']>0)return true ;
      }
    }
    return false ;
  }
  public static void main(String[] args){
    String str1="abc",str2="defa" ;
    if(canBeMadeEqual(str1,str2))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 26;
  static   operation canBeMadeEqual( str1 : String, str2 : String) : boolean
  pre: true
  post: true
  activity: (     var len1 : int ; len1 := str1->size() ;
     var len2 : int ; len2 := str2->size() ;
     if (len1 = len2) then (     var freq : Sequence(int) ; freq := Integer.subrange(1,MAX)->collect(0) ;
         var i : int ; i := 0 ; while i < len1 do ( (     freq[str1->at(i+1) - ('a')->char2byte()+1] := freq[str1->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < len2 do ( (     if (freq[str2->at(i+1) - ('a')->char2byte()+1] > 0) then     return true else skip )  ;     i := i + 1 ) ) else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "abc" ;
    var str2 : String ; str2 := "defa" ;
     if (canBeMadeEqual(str1, str2)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.io.*;
class GFG {
  static void pendulumArrangement(int arr[],int n){
    Arrays.sort(arr);
    int odd,temp,in,pos ;
    pos=n-1 ;
    if(n % 2==0)odd=n-1 ;
    else odd=n-2 ;
    while(odd>0){
      temp=arr[odd];
      in=odd ;
      while(in!=pos){
        arr[in]=arr[in+1];
        in++;
      }
      arr[in]=temp ;
      odd=odd-2 ;
      pos=pos-1 ;
    }
    int start=0,end=(n-1)/2 ;
    for(; start<end ; start++,end--){
      temp=arr[start];
      arr[start]=arr[end];
      arr[end]=temp ;
    }
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String[] args){
    int arr[]={
      11,2,4,55,6,8 };
      int n=arr.length ;
      pendulumArrangement(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pendulumArrangement( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var odd : int ;
    var temp : int ;
    var in : int ;
    var pos : int ;
    pos := n - 1 ; 
    if (n mod 2 = 0) then     odd := n - 1 else     odd := n - 2 ; ;  
    while (odd > 0) do (     temp := arr[odd+1] ; 
     in := odd ; 
    while (in /= pos) do (     arr[in+1] := arr[in + 1+1] ; 
     in := in + 1 ) ; 
    arr[in+1] := temp ; 
    odd := odd - 2 ; 
    pos := pos - 1 ; 
 ) ; 
    var start : int ; start := 0 ;
    var end : int ; end := (n - 1) / 2 ;
      while start < end do ( (     temp := arr[start+1] ; 
     arr[start+1] := arr[end+1] ; 
     arr[end+1] := temp )  ;     start := start + 1 ;     end := end - 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{11,2,4,55,6,8} ;
     var n : int ; n := arr->size() ;
     execute pendulumArrangement(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void checkEqualMatrix(int arr[][],int n,int m,int k){
    int c=0,cnt1=0,cnt2=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(c % 2==0){
          if(arr[i][j]==k){
            cnt1++;
          }
        }
        else {
          if(arr[i][j]==k){
            cnt2++;
          }
        }
        c=c+1 ;
      }
    }
    if(cnt1>=1 && cnt2>=1){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
  public static void main(String[] args){
    int arr[][]={
      {
        1,8,3 },{
          1,2,2 },{
            4,1,9 }
          };
          int k=2 ;
          checkEqualMatrix(arr,3,3,k);
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkEqualMatrix( arr : Sequence(Sequence(int)), n : int, m : int, k : int) : void
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
    var cnt1 : int ; cnt1 := 0 ;
    var cnt2 : int ; cnt2 := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (c mod 2 = 0) then (     if (arr[i+1][j+1] = k) then (     cnt1 := cnt1 + 1 ) else skip ) else (     if (arr[i+1][j+1] = k) then (     cnt2 := cnt2 + 1 ) else skip ) ;  
     c := c + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (cnt1 >= 1 & cnt2 >= 1) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,8,3},Sequence{1,2,2},Sequence{4,1,9}} ;
     var k : int ; k := 2 ;
     execute checkEqualMatrix(arr, 3, 3, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class expression {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int temp=0 ;
    if(b==1){
      temp=Math.min(a,c)+b ;
      if(Math.max(a,c)==1)temp+=Math.max(a,c);
      else temp*=Math.max(a,c);
    }
    if(b!=1){
      if(Math.min(a,c)==1){
        temp+=Math.min(a,c)+b ;
        if(Math.max(a,c)==1)temp+=Math.max(a,c);
        else temp*=Math.max(a,c);
      }
      else temp=b*Math.min(a,c)*Math.max(a,c);
    }
    System.out.println(temp);
  }
}
------------------------------------------------------------
OCL File:
---------
 class expression {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var temp : int ; temp := 0 ;
    if (b = 1) then (     temp := Set{a, c}->min() + b ; 
     if (Set{a, c}->max() = 1) then     temp := temp+(Set{a, c}->max()) ; else     temp := temp*(Set{a, c}->max()) ; ) else skip ; 
    if (b /= 1) then (     if (Set{a, c}->min() = 1) then (     temp := temp+(Set{a, c}->min() + b) ; 
     if (Set{a, c}->max() = 1) then     temp := temp+(Set{a, c}->max()) ; else     temp := temp*(Set{a, c}->max()) ; ) else     temp := b * Set{a, c}->min() * Set{a, c}->max() ; ) else skip ; 
    OclFile["System.out"].println(temp) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Mridul8 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    if(a!=1 && b!=1 && c!=1){
      System.out.println(a*b*c);
    }
    else {
      int v=a+b+c ;
      int u=(a+b)*c ;
      int z=(b+c)*a ;
      int x=Math.max(u,z);
      int y=Math.max(v,x);
      System.out.println(y);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mridul8 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    if (a /= 1 & b /= 1 & c /= 1) then (     OclFile["System.out"].println(a * b * c) ) else (     var v : int ; v := a + b + c ;
     var u : int ; u := (a + b) * c ;
    var z : int ; z := (b + c) * a ;
    var x : int ; x := Set{u, z}->max() ;
    var y : int ; y := Set{v, x}->max() ;
    OclFile["System.out"].println(y) ; 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class QQQ {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    int b=in.nextInt();
    int c=in.nextInt();
    int[] q=new int[6];
    q[0]=a+(b*c);
    q[1]=a*(b+c);
    q[2]=a*(b*c);
    q[3]=a+(b+c);
    q[4]=(a*b)+c ;
    q[5]=(a+b)*c ;
    Arrays.sort(q);
    System.out.println(q[q.length-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class QQQ {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var q : Sequence(int) ; q := Integer.subrange(1,6)->collect(0) ;
    q[0+1] := a + (b * c) ; 
    q[1+1] := a * (b + c) ; 
    q[2+1] := a * (b * c) ; 
    q[3+1] := a + (b + c) ; 
    q[4+1] := (a * b) + c ; 
    q[5+1] := (a + b) * c ; 
    q := q->sort() ; 
    OclFile["System.out"].println(q[q->size() - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class FastFoodRestaurant {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    while(test-->0){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      if(a==0 && b==0 && c==0){
        System.out.println(0);
      }
      else {
        if(b>c && b>a){
          int k=a ;
          a=b ;
          b=k ;
        }
        if(c>b && c>a){
          int k=a ;
          a=c ;
          c=k ;
        }
        int res=0 ;
        if(a>=1){
          a--;
          res++;
        }
        if(b>=1){
          b--;
          res++;
        }
        if(c>=1){
          c--;
          res++;
        }
        if(a>=1 && b>=1){
          a--;
          b--;
          res++;
        }
        if(a>=1 && c>=1){
          a--;
          c--;
          res++;
        }
        if(c>=1 && b>=1){
          c--;
          b--;
          res++;
        }
        if(a>=1 && b>=1 && c>=1)res++;
        System.out.println(res);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class FastFoodRestaurant {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
     if (a = 0 & b = 0 & c = 0) then (     OclFile["System.out"].println(0) ) else (     if (b > c & b > a) then (     var k : int ; k := a ;
     a := b ; 
     b := k ) else skip ; 
     if (c > b & c > a) then (     var k : int ; k := a ;
     a := c ; 
     c := k ) else skip ; 
    var res : int ; res := 0 ;
    if (a >= 1) then (     a := a - 1 ; 
     res := res + 1 ) else skip ; 
    if (b >= 1) then (     b := b - 1 ; 
     res := res + 1 ) else skip ; 
    if (c >= 1) then (     c := c - 1 ; 
     res := res + 1 ) else skip ; 
    if (a >= 1 & b >= 1) then (     a := a - 1 ; 
     b := b - 1 ; 
     res := res + 1 ) else skip ; 
    if (a >= 1 & c >= 1) then (     a := a - 1 ; 
     c := c - 1 ; 
     res := res + 1 ) else skip ; 
    if (c >= 1 & b >= 1) then (     c := c - 1 ; 
     b := b - 1 ; 
     res := res + 1 ) else skip ; 
    if (a >= 1 & b >= 1 & c >= 1) then     res := res + 1 ; else skip ; 
    OclFile["System.out"].println(res) ; 
 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Integer.max ;
import java.util.*;
public class Expression479A {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt(),b=in.nextInt(),c=in.nextInt();
    int v1=a+b*c ;
    int v2=a*(b+c);
    int v3=a*b*c ;
    int v4=(a+b)*c ;
    int v5=a+b+c ;
    int v=max(max(v3,v4),v5);
    System.out.println(max(max(v1,v2),v));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Expression479A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var v1 : int ; v1 := a + b * c ;
    var v2 : int ; v2 := a * (b + c) ;
    var v3 : int ; v3 := a * b * c ;
    var v4 : int ; v4 := (a + b) * c ;
    var v5 : int ; v5 := a + b + c ;
    var v : int ; v := max(Set{v3, v4}->max(), v5) ;
    OclFile["System.out"].println(Set{Set{v1, v2}->max(), v}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Rough {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a=sc.nextInt();
    long b=sc.nextInt();
    long c=sc.nextInt();
    long v=a+(b*c);
    long d=a*(b+c);
    long m=a*b*c ;
    long n=(a+b)*c ;
    long x=a+b+c ;
    long vk=Math.max(v,d);
    vk=Math.max(vk,m);
    vk=Math.max(vk,n);
    vk=Math.max(vk,x);
    System.out.println(vk);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Rough {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toInteger() ;
    var b : long ; b := sc.getCurrent()->toInteger() ;
    var c : long ; c := sc.getCurrent()->toInteger() ;
    var v : long ; v := a + (b * c) ;
    var d : long ; d := a * (b + c) ;
    var m : long ; m := a * b * c ;
    var n : long ; n := (a + b) * c ;
    var x : long ; x := a + b + c ;
    var vk : long ; vk := Set{v, d}->max() ;
    vk := Set{vk, m}->max() ; 
    vk := Set{vk, n}->max() ; 
    vk := Set{vk, x}->max() ; 
    OclFile["System.out"].println(vk) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  Scanner sc=new Scanner(in);
  int isSquare(int n){
    for(int i=(int)Math.sqrt(n); i*i<=n ; i++){
      if(i*i==n)return i ;
    }
    return-1 ;
  }
  void run(){
    int a=sc.nextInt();
    for(int i=0 ; i<a ; i++){
      int p=sc.nextInt(),q=sc.nextInt();
      int pq2=p*p+q*q ;
      if(pq2<=1){
        out.println("C");
      }
      else {
        boolean flag=false ;
        J : for(int j=2 ;
        j*j<=pq2 ;
        j++){
          if(pq2 % j==0){
            for(int m=0 ; m*m<=j ; m++){
              int n ;
              if((n=isSquare(j-m*m))>0){
                if((m*p+n*q)%(m*m+n*n)==0 &&(m*q-n*p)%(m*m+n*n)==0){
                  flag=true ;
                  break J ;
                }
              }
            }
          }
        }
        if(flag)out.println("C");
        else out.println("P");
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   operation isSquare( n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := (n)->sqrt()->oclAsType(int) ; while i * i <= n do ( (     if (i * i = n) then     return i else skip )  ;     i := i + 1 ) ; 
     return -1 );
   operation run() : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < a do ( (     var p : int ; p := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
     var pq2 : int ; pq2 := p * p + q * q ;
     if (pq2 <= 1) then (     out.println("C") ) else (     var flag : boolean ; flag := false ;
         var j : int ; j := 2 ; while j * j <= pq2 do ( (     if (pq2 mod j = 0) then (         var m : int ; m := 0 ; while m * m <= j do ( (     var n : int ;
     if ((n) > 0) then (     if ((m * p + n * q) mod (m * m + n * n) = 0 & (m * q - n * p) mod (m * m + n * n) = 0) then (     flag := true ; 
     break ) else skip ) else skip )  ;     m := m + 1 ) ) else skip )  ;     j := j + 1 ) ; 
     if (flag) then     out.println("C") ; else     out.println("P") ; ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static long getPowMod(long n,long mod){
    if(n==0)return 1L % mod ;
    if(n==1)return 3L % mod ;
    long res=getPowMod(n/2,mod)% mod ;
    if(n % 2==0)return(res*res)% mod ;
    return(res*res*3L)% mod ;
  }
  public static void main(String[] arg){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    System.out.println((getPowMod(n,m)+m-1)% m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation getPowMod( n : long, mod : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1L mod mod else skip ; 
     if (n = 1) then     return 3L mod mod else skip ; 
    var res : long ; res := getPowMod(n / 2, mod) mod mod ;
    if (n mod 2 = 0) then     return (res * res) mod mod else skip ; 
    return (res * res * 3L) mod mod 
 );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println((getPowMod(n, m) + m - 1) mod m) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static long getPowMod(long n,long mod){
    if(n==0)return 1L % mod ;
    if(n==1)return 3L % mod ;
    long res=getPowMod(n/2,mod)% mod ;
    if(n % 2==0)return(res*res)% mod ;
    return(res*res*3L)% mod ;
  }
  public static void main(String[] arg){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    if(m==1){
      System.out.println(0);
      return ;
    }
    long res=getPowMod(n,m);
    if(res==0){
      System.out.println((m-1));
    }
    else {
      System.out.println((res-1)% m);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation getPowMod( n : long, mod : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1L mod mod else skip ; 
     if (n = 1) then     return 3L mod mod else skip ; 
    var res : long ; res := getPowMod(n / 2, mod) mod mod ;
    if (n mod 2 = 0) then     return (res * res) mod mod else skip ; 
    return (res * res * 3L) mod mod 
 );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    if (m = 1) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var res : long ; res := getPowMod(n, m) ;
    if (res = 0) then (     OclFile["System.out"].println((m - 1)) ) else (     OclFile["System.out"].println((res - 1) mod m) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class C {
  private static long binPow(long a,long n,long m){
    if(n==0){
      return 1 ;
    }
    if(n==1){
      return a % m ;
    }
    if(n % 2==0){
      long c=binPow(a,n/2,m)% m ;
      return(c*c)% m ;
    }
    else {
      return(binPow(a,n-1,m)*a)% m ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong(),m=sc.nextLong();
    long ans=binPow(3,n,m)-1 ;
    if(ans<0)ans+=m ;
    System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation binPow( a : long, n : long, m : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then (     return 1 ) else skip ; 
     if (n = 1) then (     return a mod m ) else skip ; 
     if (n mod 2 = 0) then (     var c : long ; c := binPow(a, n / 2, m) mod m ;
     return (c * c) mod m ) else (     return (binPow(a, n - 1, m) * a) mod m ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var m : long ; m := sc.getCurrent()->toLong() ;
    var ans : long ; ans := binPow(3, n, m) - 1 ;
    if (ans < 0) then     ans := ans+(m) ; else skip ; 
    OclFile["System.out"].print(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CF_226A solver=new CF_226A();
    solver.solve(1,in,out);
    out.close();
  }
  static class CF_226A {
    public void solve(int testNumber,Scanner input,PrintWriter out){
      ShortScanner in=new ShortScanner(input);
      int n=in.i(),m=in.i();
      long ans=(((3 % m)*(exp(3,n-1,m)-1)% m)% m+2 % m)% m ;
      out.println((ans+m)% m);
    }
    long exp(long x,int e,int m){
      long rs=1 ;
      while(e>0){
        if(e % 2>0){
          rs=(rs % m*(x % m))% m ;
        }
        x=(x*x)% m ;
        e>>=1 ;
      }
      return(long)(rs % m);
    }
    class ShortScanner {
      Scanner in ;
      ShortScanner(Scanner in){
        this.in=in ;
      }
      int i(){
        return in.nextInt();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CF    var solver : OclFile ; solver := CF()26A.newCF()26A()26A ; solver := CF()26A.newCF()26A() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CF{
   operation solve( testNumber : int, input : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var in : ShortScanner ; in := ShortScanner.newShortScanner(input) ;
     var n : int ; n := in.i() ;
    var m : int ; m := in.i() ;
     var ans : long ; ans := (((3 mod m) * (exp(3, n - 1, m) - 1) mod m) mod m + 2 mod m) mod m ;
     skip );
   operation exp( x : long, e : int, m : int) : long
  pre: true
  post: true
  activity: (     var rs : long ; rs := 1 ;
     while (e > 0) do (     if (e mod 2 > 0) then (     rs := (rs mod m * (x mod m)) mod m ) else skip ; 
     x := (x * x) mod m ; 
     e := e/(2->pow(1)) ) ; 
     return (rs mod m)->oclAsType(long) );
 class ShortScanner {
   attribute in : OclFile;
   static operation newShortScanner( in : OclFile) : ShortScanner
  pre: true
  post: true
  activity:
  ( var self : ShortScanner ;
    self := createShortScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     self.in := in );
   operation i() : int
  pre: true
  post: true
  activity: (     return in.getCurrent()->toInteger() );
}
}
26A {
   operation solve( testNumber : int, input : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var in : ShortScanner ; in := ShortScanner.newShortScanner(input) ;
     var n : int ; n := in.i() ;
    var m : int ; m := in.i() ;
     var ans : long ; ans := (((3 mod m) * (exp(3, n - 1, m) - 1) mod m) mod m + 2 mod m) mod m ;
     skip );
   operation exp( x : long, e : int, m : int) : long
  pre: true
  post: true
  activity: (     var rs : long ; rs := 1 ;
     while (e > 0) do (     if (e mod 2 > 0) then (     rs := (rs mod m * (x mod m)) mod m ) else skip ; 
     x := (x * x) mod m ; 
     e := e/(2->pow(1)) ) ; 
     return (rs mod m)->oclAsType(long) );
 class ShortScanner {
   attribute in : OclFile;
   static operation newShortScanner( in : OclFile) : ShortScanner
  pre: true
  post: true
  activity:
  ( var self : ShortScanner ;
    self := createShortScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     self.in := in );
   operation i() : int
  pre: true
  post: true
  activity: (     return in.getCurrent()->toInteger() );
}
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class FlyingSaucerSegments {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    long n=in.nextLong();
    long mod=in.nextLong();
    long ans=fastPow(3,n,mod)-1 ;
    if(ans==-1)ans+=mod ;
    out.println(ans);
    out.close();
  }
  static long fastPow(long a,long b,long mod){
    if(b==0)return 1L ;
    long val=fastPow(a,b/2,mod);
    if(b % 2==0)return val*val % mod ;
    else return val*val % mod*a % mod ;
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class FlyingSaucerSegments {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var n : long ; n := in.nextLong() ;
    var mod : long ; mod := in.nextLong() ;
    var ans : long ; ans := fastPow(3, n, mod) - 1 ;
    if (ans = -1) then     ans := ans+(mod) ; else skip ; 
    skip ; 
    skip ; 
 );
  static   operation fastPow( a : long, b : long, mod : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return 1L else skip ; 
     var val : long ; val := fastPow(a, b / 2, mod) ;
     if (b mod 2 = 0) then     return val * val mod mod else     return val * val mod mod * a mod mod );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileWriter ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class GCJ_2013_C1 {
  public static long solve(String s,long n){
    long bef_cont=0 ;
    long bef_noncont=0 ;
    long endpart=0 ;
    System.out.println();
    for(int i=0 ; i<s.length(); i++){
      long bef_cont_prev=bef_cont ;
      long bef_noncont_prev=bef_noncont ;
      char c=s.charAt(i);
      boolean cns=!((c=='a')||(c=='e')||(c=='i')||(c=='o')||(c=='u'));
      bef_noncont=bef_noncont_prev+bef_cont_prev ;
      if(cns){
        endpart++;
        if(endpart>=n){
          bef_cont=(i-n+2);
        }
        else {
          bef_cont=bef_cont_prev ;
        }
      }
      else {
        bef_cont=bef_cont_prev ;
        endpart=0 ;
      }
    }
    return bef_cont+bef_noncont ;
  }
  public static void main(String[] args)throws Exception {
    String fname="A_large" ;
    File file=new File(fname+"_in.txt");
    Scanner scanner=new Scanner(file);
    FileWriter outFile=new FileWriter(fname+"_out.txt");
    PrintWriter outp=new PrintWriter(outFile);
    int T=scanner.nextInt();
    scanner.nextLine();
    for(int i=1 ; i<=T ; i++){
      String s=scanner.nextLine();
      String sin=s.split(" ")[0];
      int n=Integer.parseInt(s.split(" ")[1]);
      outp.printf("Case #%d: %d\n",i,solve(sin,n));
    }
    outp.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class GCJ{
  static   operation solve( s : String, n : long) : long
  pre: true
  post: true
  activity: (     var bef_cont : long ; bef_cont := 0 ;
     var bef_noncont : long ; bef_noncont := 0 ;
    var endpart : long ; endpart := 0 ;
    OclFile["System.out"].println() ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     var bef_cont_prev : long ; bef_cont_prev := bef_cont ;
     var bef_noncont_prev : long ; bef_noncont_prev := bef_noncont ;
    var c : String ; c := s->at(i+1) ;
    var cns : boolean ; cns := not(((c = 'a') or (c = 'e') or (c = 'i') or (c = 'o') or (c = 'u'))) ;
    bef_noncont := bef_noncont_prev + bef_cont_prev ; 
    if (cns) then (     endpart := endpart + 1 ; 
     if (endpart >= n) then (     bef_cont := (i - n + 2) ) else (     bef_cont := bef_cont_prev ) ) else (     bef_cont := bef_cont_prev ; 
     endpart := 0 ) ;  
 )  ;     i := i + 1 ) ; 
    return bef_cont + bef_noncont 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fname : String ; fname := "A_large" ;
     var file : OclFile ; file := OclFile(fname + "_in.txt") ;
    var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile.newOclFile(file)) ;
    var outFile : OclFile ; outFile := OclFile.newOclFile_Write(fname + "_out.txt") ;
    var outp : OclFile ; outp := OclFile.newOclFile_Write(outFile) ;
    var T : int ; T := scanner.getCurrent()->toInteger() ;
    skip ; 
        var i : int ; i := 1 ; while i <= T do ( (     var s : String ; s := scanner.nextLine() ;
     var sin : String ; sin := s->split(" ")[0+1] ;
     var n : int ; n := (s->split(" ")[1+1])->toInteger() ;
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
013_C1 {
  static   operation solve( s : String, n : long) : long
  pre: true
  post: true
  activity: (     var bef_cont : long ; bef_cont := 0 ;
     var bef_noncont : long ; bef_noncont := 0 ;
    var endpart : long ; endpart := 0 ;
    OclFile["System.out"].println() ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     var bef_cont_prev : long ; bef_cont_prev := bef_cont ;
     var bef_noncont_prev : long ; bef_noncont_prev := bef_noncont ;
    var c : String ; c := s->at(i+1) ;
    var cns : boolean ; cns := not(((c = 'a') or (c = 'e') or (c = 'i') or (c = 'o') or (c = 'u'))) ;
    bef_noncont := bef_noncont_prev + bef_cont_prev ; 
    if (cns) then (     endpart := endpart + 1 ; 
     if (endpart >= n) then (     bef_cont := (i - n + 2) ) else (     bef_cont := bef_cont_prev ) ) else (     bef_cont := bef_cont_prev ; 
     endpart := 0 ) ;  
 )  ;     i := i + 1 ) ; 
    return bef_cont + bef_noncont 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fname : String ; fname := "A_large" ;
     var file : OclFile ; file := OclFile(fname + "_in.txt") ;
    var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile.newOclFile(file)) ;
    var outFile : OclFile ; outFile := OclFile.newOclFile_Write(fname + "_out.txt") ;
    var outp : OclFile ; outp := OclFile.newOclFile_Write(outFile) ;
    var T : int ; T := scanner.getCurrent()->toInteger() ;
    skip ; 
        var i : int ; i := 1 ; while i <= T do ( (     var s : String ; s := scanner.nextLine() ;
     var sin : String ; sin := s->split(" ")[0+1] ;
     var n : int ; n := (s->split(" ")[1+1])->toInteger() ;
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int tt=1 ; tt<=t ; tt++){
      Integer ara[]=new Integer[3];
      Arrays.setAll(ara,i->in.nextInt());
      Arrays.sort(ara,Collections.reverseOrder());
      int a=ara[0],b=ara[1],c=ara[2];
      int count=0 ;
      if(a!=0){
        a--;
        count++;
      }
      if(b!=0){
        b--;
        count++;
      }
      if(c!=0){
        c--;
        count++;
      }
      if(a!=0 && b!=0){
        a--;
        b--;
        count++;
      }
      if(a!=0 && c!=0){
        a--;
        c--;
        count++;
      }
      if(b!=0 && c!=0){
        b--;
        c--;
        count++;
      }
      if(a!=0 && b!=0 && c!=0){
        count++;
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var tt : int ; tt := 1 ; while tt <= t do ( (     var ara : Sequence(int) ; ara := Integer.subrange(1,3)->collect(null) ;
 setAll(ara, lambda i : OclAny in in.getCurrent()->toInteger()) ; 
    ara := OclComparator.sortWith(ara, reverseOrder()) ; 
    var a : int ; a := ara[0+1] ;
    var b : int ; b := ara[1+1] ;
    var c : int ; c := ara[2+1] ;
    var count : int ; count := 0 ;
    if (a /= 0) then (     a := a - 1 ; 
     count := count + 1 ) else skip ; 
    if (b /= 0) then (     b := b - 1 ; 
     count := count + 1 ) else skip ; 
    if (c /= 0) then (     c := c - 1 ; 
     count := count + 1 ) else skip ; 
    if (a /= 0 & b /= 0) then (     a := a - 1 ; 
     b := b - 1 ; 
     count := count + 1 ) else skip ; 
    if (a /= 0 & c /= 0) then (     a := a - 1 ; 
     c := c - 1 ; 
     count := count + 1 ) else skip ; 
    if (b /= 0 & c /= 0) then (     b := b - 1 ; 
     c := c - 1 ; 
     count := count + 1 ) else skip ; 
    if (a /= 0 & b /= 0 & c /= 0) then (     count := count + 1 ) else skip ; 
    OclFile["System.out"].println(count) ; 
 )  ;     tt := tt + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.LineNumberReader ;
public class A {
  static long result(String name,int n){
    int len=name.length();
    boolean hasPrev=false ;
    int curr=0 ;
    int prevStart=0 ;
    long res=0 ;
    int pos=0 ;
    while(pos<len){
      boolean is="aeiou".indexOf(name.charAt(pos++))<0 ;
      if(is){
        curr++;
        if(curr>=n){
          hasPrev=true ;
          prevStart=pos-n ;
          res+=1+pos-n ;
          continue ;
        }
      }
      else {
        curr=0 ;
      }
      if(hasPrev){
        res+=1+prevStart ;
      }
    }
    return res ;
  }
  static void go(String inputFile)throws Exception {
    LineNumberReader in=new LineNumberReader(new FileReader(inputFile));
    FileWriter out=new FileWriter(inputFile+".out");
    int nCases=Integer.parseInt(in.readLine());
    for(int c=1 ; c<=nCases ; c++){
      String[] tmp=in.readLine().split(" ");
      long res=result(tmp[0],Integer.parseInt(tmp[1]));
      String line="Case #"+c+": "+res ;
      System.out.println(line);
      out.write(line+"\n");
    }
    out.close();
  }
  public static void main(String[] args)throws Exception {
    LineNumberReader sysIn=new LineNumberReader(new InputStreamReader(System.in));
    String line ;
    while((line=sysIn.readLine())!=null){
      go(line.trim());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation result( name : String, n : int) : long
  pre: true
  post: true
  activity: (     var len : int ; len := name->size() ;
     var hasPrev : boolean ; hasPrev := false ;
    var curr : int ; curr := 0 ;
    var prevStart : int ; prevStart := 0 ;
    var res : long ; res := 0 ;
    var pos : int ; pos := 0 ;
    while (pos < len) do (     var is : boolean ; is := "aeiou"->indexOf(name->at(pos+1))-1 < 0 ;
     if (is) then (     curr := curr + 1 ; 
     if (curr >= n) then (     hasPrev := true ; 
     prevStart := pos - n ; 
     res := res+(1 + pos - n) ; 
     continue ) else skip ) else (     curr := 0 ) ;  
     if (hasPrev) then (     res := res+(1 + prevStart) ) else skip ) ; 
    return res 
 );
  static   operation go( inputFile : String) : void
  pre: true
  post: true
  activity: (     var in : LineNumberReader ; in := LineNumberReader.newLineNumberReader(OclFile.newOclFile_Read(inputFile)) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(inputFile + ".out") ;
    var nCases : int ; nCases := (in.readLine())->toInteger() ;
        var c : int ; c := 1 ; while c <= nCases do ( (     var tmp : Sequence(String) ; tmp := in.readLine()->split(" ") ;
     var res : long ; res := result(tmp[0+1], (tmp[1+1])->toInteger()) ;
    var line : String ; line := "Case #" + c + ": " + res ;
    OclFile["System.out"].println(line) ; 
    skip ; 
 )  ;     c := c + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sysIn : LineNumberReader ; sysIn := LineNumberReader.newLineNumberReader(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := sysIn.readLine() ;
    while ((line) /= null) do (    skip ; (     execute go(line->trim()) ) ;     line := sysIn.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Round1C_2013_A {
  private static void jam(String inFile,String outFile)throws Exception {
    BufferedReader brIn=new BufferedReader(new FileReader(inFile));
    BufferedWriter bwOut=new BufferedWriter(new FileWriter(outFile));
    String sLine ;
    int ca=1 ;
    brIn.readLine();
    int[] starts=new int[1000000];
    int[] ends=new int[1000000];
    while((sLine=brIn.readLine())!=null){
      String[] fields=sLine.split(" ");
      if(fields.length!=2){
        System.out.println("skipping mis-parse: "+sLine);
        continue ;
      }
      String s=fields[0];
      int n=Integer.parseInt(fields[1]);
      int numSets=0 ;
      int seqNum=0 ;
      for(int i=0 ; i<s.length(); i++){
        char c=s.charAt(i);
        if(c!='a' && c!='e' && c!='i' && c!='o' && c!='u'){
          seqNum++;
          if(seqNum>=n){
            starts[numSets]=i+1-n ;
            ends[numSets]=i+1 ;
            numSets++;
          }
        }
        else {
          seqNum=0 ;
        }
      }
      int lastStart=-1 ;
      long sum=0 ;
      for(int i=0 ; i<numSets ; i++){
        int choicesLeft=starts[i]-lastStart ;
        int choicesRight=1+s.length()-ends[i];
        sum+=(long)choicesLeft*(long)choicesRight ;
        lastStart=starts[i];
      }
      String msg=""+sum ;
      System.out.println(""+s.length());
      bwOut.write("Case #"+ca+": "+msg+"\r\n");
      ca++;
    }
    brIn.close();
    bwOut.close();
  }
  public static void main(String[] args)throws Exception {
    jam(args[0],args[1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Round1C{
  static   operation jam( inFile : String, outFile : String) : void
  pre: true
  post: true
  activity: (     var brIn : OclFile ; brIn := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inFile)) ;
     var bwOut : OclFile ; bwOut := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outFile)) ;
    var sLine : String ;
    var ca : int ; ca := 1 ;
    skip ; 
    var starts : Sequence(int) ; starts := Integer.subrange(1,1000000)->collect(0) ;
    var ends : Sequence(int) ; ends := Integer.subrange(1,1000000)->collect(0) ;
        sLine := brIn.readLine() ;
    while ((sLine) /= null) do (    skip ; (     var fields : Sequence(String) ; fields := sLine->split(" ") ;
     if (fields->size() /= 2) then (     OclFile["System.out"].println("skipping mis-parse: " + sLine) ; 
     continue ) else skip ; 
    var s : String ; s := fields[0+1] ;
    var n : int ; n := (fields[1+1])->toInteger() ;
    var numSets : int ; numSets := 0 ;
    var seqNum : int ; seqNum := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var c : String ; c := s->at(i+1) ;
     if (c /= 'a' & c /= 'e' & c /= 'i' & c /= 'o' & c /= 'u') then (     seqNum := seqNum + 1 ; 
     if (seqNum >= n) then (     starts[numSets+1] := i + 1 - (n)->char2byte() ; 
     ends[numSets+1] := i + 1 ; 
     numSets := numSets + 1 ) else skip ) else (     seqNum := 0 ) )  ;     i := i + 1 ) ; 
    var lastStart : int ; lastStart := -1 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < numSets do ( (     var choicesLeft : int ; choicesLeft := starts[i+1] - (lastStart)->char2byte() ;
     var choicesRight : int ; choicesRight := 1 + s->size() - ends[i+1] ;
     sum := sum+(choicesLeft->oclAsType(long) * choicesRight->oclAsType(long)) ; 
     lastStart := starts[i+1] )  ;     i := i + 1 ) ; 
    var msg : String ; msg := "" + sum ;
    OclFile["System.out"].println("" + s->size()) ; 
    skip ; 
    ca := ca + 1 ; 
 ) ;     sLine := brIn.readLine() ;
 ) ;  
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute jam(args[0+1], args[1+1]) );
}
013_A {
  static   operation jam( inFile : String, outFile : String) : void
  pre: true
  post: true
  activity: (     var brIn : OclFile ; brIn := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inFile)) ;
     var bwOut : OclFile ; bwOut := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outFile)) ;
    var sLine : String ;
    var ca : int ; ca := 1 ;
    skip ; 
    var starts : Sequence(int) ; starts := Integer.subrange(1,1000000)->collect(0) ;
    var ends : Sequence(int) ; ends := Integer.subrange(1,1000000)->collect(0) ;
        sLine := brIn.readLine() ;
    while ((sLine) /= null) do (    skip ; (     var fields : Sequence(String) ; fields := sLine->split(" ") ;
     if (fields->size() /= 2) then (     OclFile["System.out"].println("skipping mis-parse: " + sLine) ; 
     continue ) else skip ; 
    var s : String ; s := fields[0+1] ;
    var n : int ; n := (fields[1+1])->toInteger() ;
    var numSets : int ; numSets := 0 ;
    var seqNum : int ; seqNum := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var c : String ; c := s->at(i+1) ;
     if (c /= 'a' & c /= 'e' & c /= 'i' & c /= 'o' & c /= 'u') then (     seqNum := seqNum + 1 ; 
     if (seqNum >= n) then (     starts[numSets+1] := i + 1 - (n)->char2byte() ; 
     ends[numSets+1] := i + 1 ; 
     numSets := numSets + 1 ) else skip ) else (     seqNum := 0 ) )  ;     i := i + 1 ) ; 
    var lastStart : int ; lastStart := -1 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < numSets do ( (     var choicesLeft : int ; choicesLeft := starts[i+1] - (lastStart)->char2byte() ;
     var choicesRight : int ; choicesRight := 1 + s->size() - ends[i+1] ;
     sum := sum+(choicesLeft->oclAsType(long) * choicesRight->oclAsType(long)) ; 
     lastStart := starts[i+1] )  ;     i := i + 1 ) ; 
    var msg : String ; msg := "" + sum ;
    OclFile["System.out"].println("" + s->size()) ; 
    skip ; 
    ca := ca + 1 ; 
 ) ;     sLine := brIn.readLine() ;
 ) ;  
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute jam(args[0+1], args[1+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;
public class A {
  static BufferedReader br ;
  static StringTokenizer st ;
  static PrintWriter pw ;
  public static void main(String[] args)throws IOException {
    br=new BufferedReader(new FileReader("a.in"));
    pw=new PrintWriter(new BufferedWriter(new FileWriter("a.out")));
    final int MAX_CASES=readInt();
    String vowel="aeiou" ;
    for(int casenum=1 ; casenum<=MAX_CASES ; casenum++){
      pw.printf("Case #%d: ",casenum);
      String str=nextToken();
      int count=readInt();
      long ret=0 ;
      int curr=0 ;
      int lastStart=-1 ;
      for(int i=0 ; i<str.length(); i++){
        if(vowel.indexOf(str.charAt(i)+"")==-1){
          curr++;
        }
        else {
          curr=0 ;
        }
        if(curr>=count){
          int begin=i-count+1 ;
          int goAfter=i ;
          ret+=(begin-lastStart)*1L*(str.length()-goAfter);
          lastStart=begin ;
        }
      }
      pw.println(ret);
    }
    pw.close();
  }
  public static int readInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public static long readLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  public static double readDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  public static String nextToken()throws IOException {
    while(st==null || ! st.hasMoreTokens()){
      if(! br.ready()){
        pw.close();
        System.exit(0);
      }
      st=new StringTokenizer(br.readLine());
    }
    return st.nextToken();
  }
  public static String readLine()throws IOException {
    st=null ;
    return br.readLine();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute br : OclFile;
  static   attribute st : OclIterator;
  static   attribute pw : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("a.in"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("a.out")))) ; 
    var MAX_CASES : int ; MAX_CASES := readInt() ;
    var vowel : String ; vowel := "aeiou" ;
        var casenum : int ; casenum := 1 ; while casenum <= MAX_CASES do ( (     skip ; 
     var str : String ; str := nextToken() ;
    var count : int ; count := readInt() ;
    var ret : long ; ret := 0 ;
    var curr : int ; curr := 0 ;
    var lastStart : int ; lastStart := -1 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (vowel->indexOf(str->at(i+1) + "")-1 = -1) then (     curr := curr + 1 ) else (     curr := 0 ) ;  
     if (curr >= count) then (     var begin : int ; begin := i - (count)->char2byte() + 1 ;
     var goAfter : int ; goAfter := i ;
     ret := ret+((begin - lastStart) * 1L * (str->size() - goAfter)) ; 
     lastStart := begin ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     casenum := casenum + 1 ) ; 
    skip ; 
 );
  static   operation readInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
  static   operation readLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
  static   operation readDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
  static   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     if (not(br.canRead())) then (     skip ; 
 OclProcess.exit(0) ) else skip ; 
     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() );
  static   operation readLine() : String
  pre: true
  post: true
  activity: (     st := null ; 
     return br.readLine() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class App {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] s=new int[n];
    for(int i=0 ; i<n ; i++){
      s[i]=input.nextInt();
    }
    System.out.println(A_Curriculum_Vitae(n,s));
  }
  public static int A_Curriculum_Vitae(int n,int[] s){
    int[] dp=new int[n];
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      dp[i]=1 ;
      for(int j=0 ; j<i ; j++){
        if(s[i]>=s[j]){
          dp[i]=Math.max(dp[i],dp[j]+1);
        }
      }
      ans=Math.max(ans,dp[i]);
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(A_Curriculum_Vitae(n, s)) ; 
 );
  static   operation A_Curriculum_Vitae( n : int, s : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     dp[i+1] := 1 ; 
         var j : int ; j := 0 ; while j < i do ( (     if (s[i+1] >= s[j+1]) then (     dp[i+1] := Set{dp[i+1], dp[j+1] + 1}->max() ) else skip )  ;     j := j + 1 ) ; 
     ans := Set{ans, dp[i+1]}->max() )  ;     i := i + 1 ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A846 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int ones=0 ;
    int[] A=new int[N];
    for(int n=0 ; n<N ; n++){
      int a=in.nextInt();
      ones+=a ;
      A[n]=a ;
    }
    int zeros=0 ;
    int answer=ones ;
    for(int n=0 ; n<N ; n++){
      if(A[n]==0){
        int seenOnes=n-zeros ;
        int remainingOnes=ones-seenOnes ;
        zeros++;
        answer=Math.max(answer,remainingOnes+zeros);
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A846 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var ones : int ; ones := 0 ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     ones := ones+(a) ; 
     A[n+1] := a )  ;     n := n + 1 ) ; 
    var zeros : int ; zeros := 0 ;
    var answer : int ; answer := ones ;
        var n : int ; n := 0 ; while n < N do ( (     if (A[n+1] = 0) then (     var seenOnes : int ; seenOnes := n - zeros ;
     var remainingOnes : int ; remainingOnes := ones - seenOnes ;
     zeros := zeros + 1 ; 
     answer := Set{answer, remainingOnes + zeros}->max() ) else skip )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxProfit(int profitA[],int profitB[],int n){
    int preSum[]=new int[n];
    preSum[0]=profitA[0];
    for(int i=1 ; i<n ; i++){
      preSum[i]=preSum[i-1]+profitA[i];
    }
    int suffSum[]=new int[n];
    suffSum[n-1]=profitB[n-1];
    for(int i=n-2 ; i>=0 ; i--){
      suffSum[i]=suffSum[i+1]+profitB[i];
    }
    int res=preSum[n-1];
    for(int i=1 ; i<n-1 ; i++){
      res=Math.max(res,preSum[i]+suffSum[i+1]);
    }
    res=Math.max(res,suffSum[0]);
    return res ;
  }
  public static void main(String[] args){
    int profitA[]={
      2,3,2 };
      int profitB[]={
        10,30,40 };
        int n=profitA.length ;
        System.out.println(maxProfit(profitA,profitB,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxProfit( profitA : Sequence(int), profitB : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var preSum : Sequence(int) ; preSum := Integer.subrange(1,n)->collect(0) ;
     preSum[0+1] := profitA[0+1] ; 
        var i : int ; i := 1 ; while i < n do ( (     preSum[i+1] := preSum[i - 1+1] + profitA[i+1] )  ;     i := i + 1 ) ; 
    var suffSum : Sequence(int) ; suffSum := Integer.subrange(1,n)->collect(0) ;
    suffSum[n - 1+1] := profitB[n - 1+1] ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     suffSum[i+1] := suffSum[i + 1+1] + profitB[i+1] )  ;     i := i - 1 ) ; 
    var res : int ; res := preSum[n - 1+1] ;
        var i : int ; i := 1 ; while i < n - 1 do ( (     res := Set{res, preSum[i+1] + suffSum[i + 1+1]}->max() )  ;     i := i + 1 ) ; 
    res := Set{res, suffSum[0+1]}->max() ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var profitA : Sequence(int) ; profitA := Sequence{2,3,2} ;
     var profitB : Sequence(int) ; profitB := Sequence{10,30,40} ;
     var n : int ; n := profitA->size() ;
     OclFile["System.out"].println(maxProfit(profitA, profitB, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      String S=sc.next();
      int max=0 ;
      int count=0 ;
      for(int i=0 ; i<S.length(); i++){
        if(S.charAt(i)=='R'){
          count++;
        }
        else {
          max=Math.max(max,count);
          count=0 ;
        }
      }
      max=Math.max(max,count);
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var S : String ; S := sc.getCurrent() ;
     var max : int ; max := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < S->size() do ( (     if (S->at(i+1) = 'R') then (     count := count + 1 ) else (     max := Set{max, count}->max() ; 
     count := 0 ) )  ;     i := i + 1 ) ; 
    max := Set{max, count}->max() ; 
    OclFile["System.out"].println(max) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    String input=s.nextLine();
    List<Character>cl=new ArrayList<>();
    for(int i=0 ; i<input.length(); i++){
      cl.add(input.charAt(i));
    }
    boolean flag=false ;
    if(Collections.frequency(cl,'S')==3){
      System.out.println("0");
    }
    else if(Collections.frequency(cl,'R')==3){
      System.out.println("3");
    }
    else {
      for(int i=0 ; i<input.length()-1 ; i++){
        if(cl.get(i)=='R' && cl.get(i+1)=='R'){
          flag=true ;
        }
      }
      if(flag==true){
        System.out.println("2");
      }
      else {
        System.out.println("1");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : String ; input := s.nextLine() ;
    var cl : Sequence(String) ; cl := Sequence{} ;
        var i : int ; i := 0 ; while i < input->size() do ( (     cl := cl->including(input->at(i+1)) )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := false ;
    if (frequency(cl, 'S') = 3) then (     OclFile["System.out"].println("0") ) else     if (frequency(cl, 'R') = 3) then (     OclFile["System.out"].println("3") ) else (         var i : int ; i := 0 ; while i < input->size() - 1 do ( (     if (cl->at(i+1) = 'R' & cl->at(i + 1+1) = 'R') then (     flag := true ) else skip )  ;     i := i + 1 ) ; 
     if (flag = true) then (     OclFile["System.out"].println("2") ) else (     OclFile["System.out"].println("1") ) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Solution788A {
  public static int[] arr=new int[100001];
  public static int[] dist=new int[100001];
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    StringTokenizer st=new StringTokenizer(br.readLine()," ");
    for(int i=1 ; i<=n ; i++){
      arr[i]=Integer.parseInt(st.nextToken());
    }
    long finalMax=0 ;
    for(int start=1 ; start<3 ; start++){
      long max=0 ;
      long sum=0 ;
      boolean add=true ;
      for(int i=start ; i<n ; i++){
        dist[i]=Math.abs(arr[i]-arr[i+1]);
        if(add){
          sum+=dist[i];
          max=sum>max ? sum : max ;
          add=false ;
        }
        else {
          sum-=dist[i];
          add=true ;
        }
        if(sum<0){
          sum=0 ;
          add=true ;
        }
      }
      finalMax=max>finalMax ? max : finalMax ;
    }
    System.out.println(finalMax);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution788A {
  static   attribute arr : Sequence(int) := Integer.subrange(1,100001)->collect(0);
  static   attribute dist : Sequence(int) := Integer.subrange(1,100001)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String_String(br.readLine(), " ") ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    var finalMax : long ; finalMax := 0 ;
        var start : int ; start := 1 ; while start < 3 do ( (     var max : long ; max := 0 ;
     var sum : long ; sum := 0 ;
    var add : boolean ; add := true ;
        var i : int ; i := start ; while i < n do ( (     dist[i+1] := if arr[i+1] - arr[i + 1+1] < 0 then -(arr[i+1] - arr[i + 1+1]) else arr[i+1] - arr[i + 1+1] endif ; 
     if (add) then (     sum := sum+(dist[i+1]) ; 
     max := if sum > max then sum else max endif ; 
     add := false ) else (     sum := sum-(dist[i+1]) ; 
     add := true ) ;  
     if (sum < 0) then (     sum := 0 ; 
     add := true ) else skip )  ;     i := i + 1 ) ; 
    finalMax := if max > finalMax then max else finalMax endif ; 
 )  ;     start := start + 1 ) ; 
    OclFile["System.out"].println(finalMax) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner s=new Scanner(System.in);
    String word=s.next();
    int max=0,cnt=0 ;
    for(int i=0 ; i<word.length(); i++){
      if(word.charAt(i)=='S'){
        max=Math.max(max,cnt);
        cnt=0 ;
      }
      else cnt++;
    }
    max=Math.max(max,cnt);
    System.out.println(max);
  }
}
class Scanner {
  StringTokenizer st ;
  BufferedReader br ;
  public Scanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public String nextLine()throws IOException {
    return br.readLine();
  }
  public double nextDouble()throws IOException {
    String x=next();
    StringBuilder sb=new StringBuilder("0");
    double res=0,f=1 ;
    boolean dec=false,neg=false ;
    int start=0 ;
    if(x.charAt(0)=='-'){
      neg=true ;
      start++;
    }
    for(int i=start ; i<x.length(); i++)if(x.charAt(i)=='.'){
      res=Long.parseLong(sb.toString());
      sb=new StringBuilder("0");
      dec=true ;
    }
    else {
      sb.append(x.charAt(i));
      if(dec)f*=10 ;
    }
    res+=Long.parseLong(sb.toString())/f ;
    return res*(neg ?-1 : 1);
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var word : String ; word := s.getCurrent() ;
    var max : int ; max := 0 ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < word->size() do ( (     if (word->at(i+1) = 'S') then (     max := Set{max, cnt}->max() ; 
     cnt := 0 ) else     cnt := cnt + 1 ; )  ;     i := i + 1 ) ; 
    max := Set{max, cnt}->max() ; 
    OclFile["System.out"].println(max) ; 
 );
}
class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     var x : String ; x := next() ;
     var sb : String ; sb := StringLib.newString("0") ;
    var res : double ; res := 0 ;
    var f : double ; f := 1 ;
    var dec : boolean ; dec := false ;
    var neg : boolean ; neg := false ;
    var start : int ; start := 0 ;
    if (x->at(0+1) = '-') then (     neg := true ; 
     start := start + 1 ) else skip ; 
        var i : int ; i := start ; while i < x->size() do (     if (x->at(i+1) = '.') then (     res := (sb+"")->toLong() ; 
     sb := StringLib.newString("0") ; 
     dec := true ) else (     sb := sb + StringLib.newString(x->at(i+1)) ; 
     if (dec) then     f := f*(10) ; else skip ) ;   ;     i := i + 1 ) ; 
    res := res+((sb+"")->toLong() / f) ; 
    return res * (if neg then -1 else 1 endif) 
 );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public void solve(){
    Scanner scan=new Scanner(System.in);
    String S=scan.next();
    if(S.equals("SSS"))System.out.println(0);
    if(S.equals("SSR"))System.out.println(1);
    if(S.equals("SRS"))System.out.println(1);
    if(S.equals("RSS"))System.out.println(1);
    if(S.equals("RRS"))System.out.println(2);
    if(S.equals("RSR"))System.out.println(1);
    if(S.equals("SRR"))System.out.println(2);
    if(S.equals("RRR"))System.out.println(3);
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := scan.getCurrent() ;
    if (S = "SSS") then     OclFile["System.out"].println(0) ; else skip ; 
    if (S = "SSR") then     OclFile["System.out"].println(1) ; else skip ; 
    if (S = "SRS") then     OclFile["System.out"].println(1) ; else skip ; 
    if (S = "RSS") then     OclFile["System.out"].println(1) ; else skip ; 
    if (S = "RRS") then     OclFile["System.out"].println(2) ; else skip ; 
    if (S = "RSR") then     OclFile["System.out"].println(1) ; else skip ; 
    if (S = "SRR") then     OclFile["System.out"].println(2) ; else skip ; 
    if (S = "RRR") then     OclFile["System.out"].println(3) ; else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    String x=scan.next();
    String a,b,c ;
    a=x.substring(0,1);
    b=x.substring(1,2);
    c=x.substring(2,3);
    if(a.equals("R")&& b.equals("R")&& c.equals("R")){
      System.out.println("3");
    }
    else if(a.equals("R")&& b.equals("R")&& c.equals("S")){
      System.out.println("2");
    }
    else if(a.equals("S")&& b.equals("R")&& c.equals("R")){
      System.out.println("2");
    }
    else if(a.equals("R")&& b.equals("S")&& c.equals("S")){
      System.out.println("1");
    }
    else if(a.equals("S")&& b.equals("R")&& c.equals("S")){
      System.out.println("1");
    }
    else if(a.equals("S")&& b.equals("S")&& c.equals("R")){
      System.out.println("1");
    }
    else if(a.equals("R")&& b.equals("S")&& c.equals("R")){
      System.out.println("1");
    }
    else if(a.equals("S")&& b.equals("S")&& c.equals("S")){
      System.out.println("0");
    }
    else {
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : String ; x := scan.getCurrent() ;
    var a : String ;
    var b : String ;
    var c : String ;
    a := x.subrange(0+1,1) ; 
    b := x.subrange(1+1,2) ; 
    c := x.subrange(2+1,3) ; 
    if (a = "R" & b = "R" & c = "R") then (     OclFile["System.out"].println("3") ) else     if (a = "R" & b = "R" & c = "S") then (     OclFile["System.out"].println("2") ) else     if (a = "S" & b = "R" & c = "R") then (     OclFile["System.out"].println("2") ) else     if (a = "R" & b = "S" & c = "S") then (     OclFile["System.out"].println("1") ) else     if (a = "S" & b = "R" & c = "S") then (     OclFile["System.out"].println("1") ) else     if (a = "S" & b = "S" & c = "R") then (     OclFile["System.out"].println("1") ) else     if (a = "R" & b = "S" & c = "R") then (     OclFile["System.out"].println("1") ) else     if (a = "S" & b = "S" & c = "S") then (     OclFile["System.out"].println("0") ) else skip ;  ;  ;  ;  ;  ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static Boolean isPentagonal(int N){
    double n=(1+Math.sqrt(24*N+1))/6 ;
    return(n-(int)n)==0 ;
  }
  public static void main(String[] args){
    int N=19 ;
    if(isPentagonal(N))System.out.println(N+" is pentagonal ");
    else System.out.println(N+" is not pentagonal");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPentagonal( N : int) : Boolean
  pre: true
  post: true
  activity: (     var n : double ; n := (1 + (24 * N + 1)->sqrt()) / 6 ;
     return (n - n->oclAsType(int)) = 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 19 ;
     if (isPentagonal(N)) then     OclFile["System.out"].println(N + " is pentagonal ") ; else     OclFile["System.out"].println(N + " is not pentagonal") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private void doit(){
    Scanner sc=new Scanner(System.in);
    int dataset=sc.nextInt();
    while(dataset-->0){
      int p=sc.nextInt();
      int q=sc.nextInt();
      int maxrange=Math.max(p,Math.max(-p,Math.max(q,-q)));
      int minrange=Math.min(p,Math.min(-p,Math.min(q,-q)));
      int count=0 ;
      for(int m=minrange ; m<=maxrange ; m++){
        for(int n=minrange ; n<=maxrange ; n++){
          if(m==0 && n==0)continue ;
          int a=m*p+n*q ;
          int b=m*q-n*p ;
          int mn=m*m+n*n ;
          if(a % mn==0 && b % mn==0){
            count++;
          }
        }
      }
      System.out.println(count==8 ? "P" : "C");
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dataset : int ; dataset := sc.getCurrent()->toInteger() ;
         while (dataset > 0) do (        dataset := dataset - 1 ;     skip ; (     var p : int ; p := sc.getCurrent()->toInteger() ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
    var maxrange : int ; maxrange := Set{p, Set{-p, Set{q, -q}->max()}->max()}->max() ;
    var minrange : int ; minrange := Set{p, Set{-p, Set{q, -q}->min()}->min()}->min() ;
    var count : int ; count := 0 ;
        var m : int ; m := minrange ; while m <= maxrange do ( (         var n : int ; n := minrange ; while n <= maxrange do ( (     if (m = 0 & n = 0) then     continue else skip ; 
     var a : int ; a := m * p + n * q ;
    var b : int ; b := m * q - n * p ;
    var mn : int ; mn := m * m + n * n ;
    if (a mod mn = 0 & b mod mn = 0) then (     count := count + 1 ) else skip ; 
 )  ;     n := n + 1 ) )  ;     m := m + 1 ) ; 
    OclFile["System.out"].println(if count = 8 then "P" else "C" endif) ; 
 ) ;  ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextInt();
    long a=1 ;
    long b=10*10*10*10*10*10*10*10*10+7 ;
    for(long i=1 ; i<=N ; i++){
      a=a*i % b ;
      if(i==N){
        System.out.println(a);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toInteger() ;
    var a : long ; a := 1 ;
    var b : long ; b := 10 * 10 * 10 * 10 * 10 * 10 * 10 * 10 * 10 + 7 ;
        var i : long ; i := 1 ; while i <= N do ( (     a := a * i mod b ; 
     if (i = N) then (     OclFile["System.out"].println(a) ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    long N=Long.parseLong(input.readLine());
    BigInteger result=new BigInteger("1");
    BigInteger divider=new BigInteger("1000000007");
    for(int i=1 ; i<=N ; i++){
      result=result.multiply(new BigInteger(Integer.toString(i))).mod(divider);
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var N : long ; N := (input.readLine())->toLong() ;
    var result : long ; result := long("1") ;
    var divider : long ; divider := long("1000000007") ;
        var i : int ; i := 1 ; while i <= N do ( (     result := result.multiply(long(((i) + ""))).mod(divider) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.LongStream ;
public class Main {
  public static void main(String[] args){
    System.out.println(LongStream.rangeClosed(1,Integer.parseInt((new Scanner(System.in)).next())).reduce(1,(x,y)->(x*y)% 1000000007));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(Integer.subrange(1, ((OclFile.newOclFile_Read(OclFile["System.in"])).next())->toInteger())->iterate( _var; _acc : OclAny | 1, lambda (x , y) : OclAny in (x * y) mod 1000000007->apply((_acc,_var)) )) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int N=input(System.in);
    long power=proc(N);
    System.out.println(power);
  }
  static int input(InputStream in){
    int result=0 ;
    try(Scanner sc=new Scanner(in)){
      result=sc.nextInt();
    }
    return result ;
  }
  static long proc(int N){
    long unit=(long)(Math.pow(10,9))+7 ;
    long power=1 ;
    for(int i=1 ; i<=N ; i++){
      power=power*i % unit ;
    }
    return power ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := input(OclFile["System.in"]) ;
     var power : long ; power := proc(N) ;
     OclFile["System.out"].println(power) );
  static   operation input( in : OclFile) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     try (    var sc : OclFile := OclFile.newOclFile_Read(in) ;
 (     result := sc.getCurrent()->toInteger() ))  
     return result );
  static   operation proc( N : int) : long
  pre: true
  post: true
  activity: (     var unit : long ; unit := (10->pow(9))->oclAsType(long) + 7 ;
     var power : long ; power := 1 ;
         var i : int ; i := 1 ; while i <= N do ( (     power := power * i mod unit )  ;     i := i + 1 ) ; 
     return power );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileInputStream ;
import java.util.NoSuchElementException ;
import java.util.Scanner ;
import java.io.IOException ;
import java.io.InputStream ;
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.Deque ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map.Entry ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long ans=1 ;
    long MOD=1000000007 ;
    for(int i=1 ; i<=N ; i++)ans=(ans*i)% MOD ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var ans : long ; ans := 1 ;
    var MOD : long ; MOD := 1000000007 ;
        var i : int ; i := 1 ; while i <= N do (     ans := (ans * i) mod MOD ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class FunctionsAgain {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    long[] diff1=new long[N-1];
    long[] diff2=new long[N-1];
    int first=in.nextInt();
    int second ;
    for(int i=0 ; i<N-1 ; i++){
      second=in.nextInt();
      diff1[i]=Math.abs(second-first)*(i % 2==0 ?-1 : 1);
      diff2[i]=Math.abs(second-first)*(i % 2==0 ? 1 :-1);
      first=second ;
    }
    long max=0 ;
    int high=0 ;
    long counter=0 ;
    while(high<N-1){
      counter+=diff1[high];
      if(counter<=0){
        counter=0 ;
      }
      else {
        max=Math.max(max,counter);
      }
      high++;
    }
    high=0 ;
    counter=0 ;
    while(high<N-1){
      counter+=diff2[high];
      if(counter<=0){
        counter=0 ;
      }
      else {
        max=Math.max(max,counter);
      }
      high++;
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class FunctionsAgain {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var diff1 : Sequence(long) ; diff1 := Integer.subrange(1,N - 1)->collect(0) ;
    var diff2 : Sequence(long) ; diff2 := Integer.subrange(1,N - 1)->collect(0) ;
    var first : int ; first := in.getCurrent()->toInteger() ;
    var second : int ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     second := in.getCurrent()->toInteger() ; 
     diff1[i+1] := if second - first < 0 then -(second - first) else second - first endif * (if i mod 2 = 0 then -1 else 1 endif) ; 
     diff2[i+1] := if second - first < 0 then -(second - first) else second - first endif * (if i mod 2 = 0 then 1 else -1 endif) ; 
     first := second )  ;     i := i + 1 ) ; 
    var max : long ; max := 0 ;
    var high : int ; high := 0 ;
    var counter : long ; counter := 0 ;
    while (high < N - 1) do (     counter := counter+(diff1[high+1]) ; 
     if (counter <= 0) then (     counter := 0 ) else (     max := Set{max, counter}->max() ) ;  
     high := high + 1 ) ; 
    high := 0 ; 
    counter := 0 ; 
    while (high < N - 1) do (     counter := counter+(diff2[high+1]) ; 
     if (counter <= 0) then (     counter := 0 ) else (     max := Set{max, counter}->max() ) ;  
     high := high + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Eulerian {
  public static String fibWord(int n){
    String Sn_1="0" ;
    String Sn="01" ;
    String tmp ;
    for(int i=2 ; i<=n ; i++){
      tmp=Sn ;
      Sn+=Sn_1 ;
      Sn_1=tmp ;
    }
    return Sn ;
  }
  public static void main(String[] args){
    int n=6 ;
    System.out.print(fibWord(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Eulerian {
  static   operation fibWord( n : int) : String
  pre: true
  post: true
  activity: (     var Sn    var SnString :  ; SnString := "0" : String ; Sn    var SnString :  ; SnString := "0" := "0" ;
     var Sn : String ; Sn := "01" ;
    var tmp : String ;
        var i : int ; i := 2 ; while i <= n do ( (     tmp := Sn ; 
     Sn := Sn+(SnSn) ; 
     SnSn    SnSn    tmp := Sn ; 
 := tmp ; := tmp )  ;     i := i + 1 ) ; 
    return Sn 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].print(fibWord(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int xorPairSum(int ar[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)sum=sum ^(ar[i]+ar[j]);
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3 };
      int n=arr.length ;
      System.out.print(xorPairSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation xorPairSum( ar : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (     sum := MathLib.bitwiseXor(sum,(ar[i+1] + ar[j+1])) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(xorPairSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int mod=(int)(1e9+7);
  static int power(int x,int y,int p){
    int res=1 ;
    x=x % p ;
    while(y>0){
      if((y & 1)==1)res=(res*x)% p ;
      y=y>>1 ;
      x=(x*x)% p ;
    }
    return res ;
  }
  static int findCount(int N){
    int count=power(2,N,mod);
    return count ;
  }
  public static void main(String[] args){
    int N=25 ;
    System.out.println(findCount(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute mod : int := (1e9 + 7)->oclAsType(int);
  static   operation power( x : int, y : int, p : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     if ((y & 1) = 1) then     res := (res * x) mod p ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res );
  static   operation findCount( N : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := power(2, N, mod) ;
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 25 ;
     OclFile["System.out"].println(findCount(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class maxima {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t,j,i,n,a,b,p,q ;
    t=sc.nextInt();
    for(j=1 ; j<=t ; j++){
      n=sc.nextInt();
      a=sc.nextInt();
      b=sc.nextInt();
      p=1 ;
      q=n ;
      if(a==b && a<=(n-2)/2){
        System.out.print((p++)+" ");
        for(i=1 ; i<=a ; i++)System.out.print((q--)+" "+(p++)+" ");
        for(i=p ; i<=q ; i++)System.out.print(i+" ");
      }
      else if((a-b)==1 && a<=(int)Math.ceil((n-2)/2.0)){
        for(i=1 ; i<=a ; i++)System.out.print((p++)+" "+(q--)+" ");
        for(i=q ; i>=p ; i--)System.out.print(i+" ");
      }
      else if((b-a)==1 && b<=(int)Math.ceil((n-2)/2.0)){
        for(i=1 ; i<=b ; i++)System.out.print((q--)+" "+(p++)+" ");
        for(i=p ; i<=q ; i++)System.out.print(i+" ");
      }
      else System.out.print(-1);
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class maxima {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ;
    var j : int ;
    var i : int ;
    var n : int ;
    var a : int ;
    var b : int ;
    var p : int ;
    var q : int ;
     t := sc.getCurrent()->toInteger() ; 
         j := 1 ; while j <= t do ( (     n := sc.getCurrent()->toInteger() ; 
     a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    p := 1 ; 
    q := n ; 
    if (a = b & a <= (n - 2) / 2) then (     OclFile["System.out"].print((p) + " ") ; 
         i := 1 ; while i <= a do (     OclFile["System.out"].print((q) + " " + (p) + " ") ;  ;     i := i + 1 ) ; 
         i := p ; while i <= q do (     OclFile["System.out"].print(i + " ") ;  ;     i := i + 1 ) ) else     if ((a - b) = 1 & a <= ((n - 2) / 2.0)->ceil()->oclAsType(int)) then (         i := 1 ; while i <= a do (     OclFile["System.out"].print((p) + " " + (q) + " ") ;  ;     i := i + 1 ) ; 
         i := q ; while i >= p do (     OclFile["System.out"].print(i + " ") ;  ;     i := i - 1 ) ) else     if ((b - a) = 1 & b <= ((n - 2) / 2.0)->ceil()->oclAsType(int)) then (         i := 1 ; while i <= b do (     OclFile["System.out"].print((q) + " " + (p) + " ") ;  ;     i := i + 1 ) ; 
         i := p ; while i <= q do (     OclFile["System.out"].print(i + " ") ;  ;     i := i + 1 ) ) else     OclFile["System.out"].print(-1) ; ;  ;  ;  
    OclFile["System.out"].println() ; 
 )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.*;
import java.math.BigInteger ;
public class A {
  public static void main(String[] args)throws Throwable {
    Scanner in=new Scanner(new File("in.txt"));
    PrintStream out=new PrintStream(new File("out.txt"));
    int t=in.nextInt();
    in.nextLine();
    for(int c=1 ; c<=t ; c++){
      out.print("Case #");
      out.print(c);
      out.print(": ");
      out.println(getSolution(in));
    }
  }
  private static String getSolution(Scanner in){
    long n ;
    int pd,pg ;
    n=in.nextLong();
    pd=in.nextInt();
    pg=in.nextInt();
    int factor=gcf(100,pd);
    if(100/factor>n)return "Broken" ;
    if((pg==100 && pd!=100)||(pg==0 && pd!=0))return "Broken" ;
    return "Possible" ;
  }
  public static int gcf(int a,int b){
    int s ;
    if(a>b)s=b ;
    else s=a ;
    for(int i=s ; i>0 ; i--){
      if((a % i==0)&&(b % i==0))return i ;
    }
    return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("in.txt")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("out.txt")) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
    skip ; 
        var c : int ; c := 1 ; while c <= t do ( (     skip ; 
     skip ; 
     skip ; 
     skip )  ;     c := c + 1 ) ; 
 );
  static   operation getSolution( in : OclFile) : String
  pre: true
  post: true
  activity: (     var n : long ;
     var pd : int ;
    var pg : int ;
    n := in.getCurrent()->toLong() ; 
    pd := in.getCurrent()->toInteger() ; 
    pg := in.getCurrent()->toInteger() ; 
    var factor : int ; factor := gcf(100, pd) ;
    if (100 / factor > n) then     return "Broken" else skip ; 
    if ((pg = 100 & pd /= 100) or (pg = 0 & pd /= 0)) then     return "Broken" else skip ; 
    return "Possible" 
 );
  static   operation gcf( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var s : int ;
     if (a > b) then     s := b else     s := a ; ;  
         var i : int ; i := s ; while i > 0 do ( (     if ((a mod i = 0) & (b mod i = 0)) then     return i else skip )  ;     i := i - 1 ) ; 
     return -1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    while(N-->0){
      int m=in.nextInt();
      int n=in.nextInt();
      Ginko gi=new Ginko(m,n);
      boolean flg=true ;
      for(int i=0 ; i<150 ; i++){
        for(int j=0 ; j<150 ; j++){
          if(i*i+j*j>gi.m*gi.m+gi.n*gi.n || i*i+j*j==0)continue ;
          if(check(i,j,gi)|| check(i,-j,gi)|| check(-i,j,gi)|| check(-i,-j,gi)){
            flg=false ;
            break ;
          }
        }
        if(! flg)break ;
      }
      System.out.println(flg ? "P" : "C");
    }
  }
  static boolean check(int m,int n,Ginko in){
    if(m==1 && n==0 || m==0 && n==1 || m==-1 && n==0 || m==0 && n==-1 || m==in.m && n==in.n || m==-in.n && n==in.m || m==-in.m && n==-in.n || m==in.n && n==-in.m)return false ;
    int a=m*in.m+n*in.n ;
    int b=m*in.n-n*in.m ;
    int mn=m*m+n*n ;
    if(a % mn==0 && b % mn==0)return true ;
    else return false ;
  }
}
class Ginko {
  int m ;
  int n ;
  Ginko(int m,int n){
    this.m=m ;
    this.n=n ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
         while (N > 0) do (        N := N - 1 ;     skip ; (     var m : int ; m := in.getCurrent()->toInteger() ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var gi : Ginko ; gi := Ginko.newGinko(m, n) ;
    var flg : boolean ; flg := true ;
        var i : int ; i := 0 ; while i < 150 do ( (         var j : int ; j := 0 ; while j < 150 do ( (     if (i * i + j * j > gi.m * gi.m + gi.n * gi.n or i * i + j * j = 0) then     continue else skip ; 
     if (check(i, j, gi) or check(i, -j, gi) or check(-i, j, gi) or check(-i, -j, gi)) then (     flg := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (not(flg)) then     break else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if flg then "P" else "C" endif) ; 
 ) ;  ) );
  static   operation check( m : int, n : int, in : Ginko) : boolean
  pre: true
  post: true
  activity: (     if (m = 1 & n = 0 or m = 0 & n = 1 or m = -1 & n = 0 or m = 0 & n = -1 or m = inm & n = inn or m = -inn & n = inm or m = -inm & n = -inn or m = inn & n = -inm) then     return false else skip ; 
     var a : int ; a := m * inm + n * inn ;
    var b : int ; b := m * inn - n * inm ;
    var mn : int ; mn := m * m + n * n ;
    if (a mod mn = 0 & b mod mn = 0) then     return true else     return false ;  
 );
}
class Ginko {
   attribute m : int;
   attribute n : int;
   static operation newGinko( m : int, n : int) : Ginko
  pre: true
  post: true
  activity:
  ( var self : Ginko ;
    self := createGinko();
    self.initialise(m, n);
    return self );
  operation initialise( m : int, n : int) : void
  pre: true  post: true
  activity: (     self.m := m ; 
     self.n := n );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round1a ;
import java.io.File ;
import java.util.ArrayList ;
import java.util.Scanner ;
public class A {
  int caseNo ;
  double epsilon=0.00000001 ;
  boolean equals(double a,double b){
    return(Math.abs(a-b)<epsilon);
  }
  public void test(Scanner in){
    long maxGamesToday=in.nextLong();
    int rateToday=in.nextInt();
    int rateTotal=in.nextInt();
    boolean possible=true ;
    if(maxGamesToday<100){
      boolean found=false ;
      if(maxGamesToday>=1){
        found |=(rateToday % 100==0);
      }
      if(maxGamesToday>=2){
        found |=(rateToday % 50==0);
      }
      if(maxGamesToday>=4){
        found |=(rateToday % 25==0);
      }
      if(maxGamesToday>=5){
        found |=(rateToday % 20==0);
      }
      if(maxGamesToday>=10){
        found |=(rateToday % 10==0);
      }
      if(maxGamesToday>=20){
        found |=(rateToday % 5==0);
      }
      if(maxGamesToday>=25){
        found |=(rateToday % 4==0);
      }
      if(maxGamesToday>=50){
        found |=(rateToday % 2==0);
      }
      possible=found ;
    }
    if(possible){
      if(rateTotal==0 && rateToday!=0)possible=false ;
      if(rateTotal==100 && rateToday!=100)possible=false ;
    }
    if(possible)System.out.println("Case #"+caseNo+": Possible");
    else System.out.println("Case #"+caseNo+": Broken");
  }
  public static void main(String[] args)throws Exception {
(new A()).test();
  }
  public void test()throws Exception {
    Scanner s=new Scanner(new File("A-large.in"));
    int numTests=s.nextInt();
    for(caseNo=1 ; caseNo<=numTests ; caseNo++){
      test(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   attribute caseNo : int;
   attribute epsilon : double := 0.00000001;
   operation equals( a : double, b : double) : boolean
  pre: true
  post: true
  activity: (     return (if a - b < 0 then -(a - b) else a - b endif < epsilon) );
   operation test( in : OclFile) : void
  pre: true
  post: true
  activity: (     var maxGamesToday : long ; maxGamesToday := in.nextLong() ;
     var rateToday : int ; rateToday := in.nextInt() ;
    var rateTotal : int ; rateTotal := in.nextInt() ;
    var possible : boolean ; possible := true ;
    if (maxGamesToday < 100) then (     var found : boolean ; found := false ;
     if (maxGamesToday >= 1) then (     found := MathLib.bitwiseOr(found, (rateToday mod 100 = 0)) ) else skip ; 
    if (maxGamesToday >= 2) then (     found := MathLib.bitwiseOr(found, (rateToday mod 50 = 0)) ) else skip ; 
    if (maxGamesToday >= 4) then (     found := MathLib.bitwiseOr(found, (rateToday mod 25 = 0)) ) else skip ; 
    if (maxGamesToday >= 5) then (     found := MathLib.bitwiseOr(found, (rateToday mod 20 = 0)) ) else skip ; 
    if (maxGamesToday >= 10) then (     found := MathLib.bitwiseOr(found, (rateToday mod 10 = 0)) ) else skip ; 
    if (maxGamesToday >= 20) then (     found := MathLib.bitwiseOr(found, (rateToday mod 5 = 0)) ) else skip ; 
    if (maxGamesToday >= 25) then (     found := MathLib.bitwiseOr(found, (rateToday mod 4 = 0)) ) else skip ; 
    if (maxGamesToday >= 50) then (     found := MathLib.bitwiseOr(found, (rateToday mod 2 = 0)) ) else skip ; 
    possible := found ; 
 ) else skip ; 
    if (possible) then (     if (rateTotal = 0 & rateToday /= 0) then     possible := false ; else skip ; 
     if (rateTotal = 100 & rateToday /= 100) then     possible := false ; else skip ) else skip ; 
    if (possible) then     OclFile["System.out"].println("Case #" + caseNo + ": Possible") else     OclFile["System.out"].println("Case #" + caseNo + ": Broken") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (A.newA()).test() );
   operation test() : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile("A-large.in")) ;
     var numTests : int ; numTests := s.getCurrent()->toInteger() ;
         caseNo := 1 ; while caseNo <= numTests do ( (     execute test(s) )  ;     caseNo := caseNo + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package jam2011 ;
import java.io.*;
import java.util.*;
public class AA {
  public static void main(String[] args)throws Exception {
    BufferedReader inputFile=new BufferedReader(new InputStreamReader(new FileInputStream(args[0])));
    int cases=Integer.parseInt(inputFile.readLine());
    PrintStream outFile=new PrintStream(new FileOutputStream(args[1]));
    for(int i=1 ; i<=cases ; i++){
      String lineT[]=tokenize(inputFile.readLine());
      long n=Long.parseLong(lineT[0]);
      long pd=Long.parseLong(lineT[1]);
      long pg=Long.parseLong(lineT[2]);
      String out=null ;
      if(pg==0)out=pd==0 ? "Possible" : "Broken" ;
      else if(pg==100)out=pd==100 ? "Possible" : "Broken" ;
      else {
        if(n>=100)out="Possible" ;
        else {
          int nnn=100 ;
          while(pd % 2==0 && nnn % 2==0 || pd % 5==0 && nnn % 5==0){
            if(pd % 2==0 && nnn % 2==0){
              nnn/=2 ;
              pd/=2 ;
            }
            if(pd % 5==0 && nnn % 5==0){
              nnn/=5 ;
              pd/=5 ;
            }
          }
          out=nnn<=n ? "Possible" : "Broken" ;
        }
      }
      outFile.println("Case #"+i+": "+out);
    }
    outFile.close();
    inputFile.close();
  }
  public static String[] tokenize(String input){
    StringTokenizer st=new StringTokenizer(input);
    String[] k=new String[st.countTokens()];
    for(int i=0 ; i<k.length ; i++)k[i]=st.nextToken();
    return k ;
  }
  public static String[] tokenize(String input,String sep){
    StringTokenizer st=new StringTokenizer(input,sep);
    String[] k=new String[st.countTokens()];
    for(int i=0 ; i<k.length ; i++)k[i]=st.nextToken();
    return k ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class AA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputFile : OclFile ; inputFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(args[0+1]))) ;
     var cases : int ; cases := (inputFile.readLine())->toInteger() ;
    var outFile : OclFile ; outFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(args[1+1])) ;
        var i : int ; i := 1 ; while i <= cases do ( (     var lineT : Sequence(String) ; lineT := tokenize(inputFile.readLine()) ;
     var n : long ; n := (lineT[0+1])->toLong() ;
    var pd : long ; pd := (lineT[1+1])->toLong() ;
    var pg : long ; pg := (lineT[2+1])->toLong() ;
    var out : String ; out := null ;
    if (pg = 0) then     out := if pd = 0 then "Possible" else "Broken" endif else     if (pg = 100) then     out := if pd = 100 then "Possible" else "Broken" endif else (     if (n >= 100) then     out := "Possible" ; else (     var nnn : int ; nnn := 100 ;
     while (pd mod 2 = 0 & nnn mod 2 = 0 or pd mod 5 = 0 & nnn mod 5 = 0) do (     if (pd mod 2 = 0 & nnn mod 2 = 0) then (     nnn := nnn/(2) ; 
     pd := pd/(2) ) else skip ; 
     if (pd mod 5 = 0 & nnn mod 5 = 0) then (     nnn := nnn/(5) ; 
     pd := pd/(5) ) else skip ) ; 
     out := if nnn <= n then "Possible" else "Broken" endif ) ) ;  ;  
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation tokenize( input : String) : Sequence(String)
  pre: true
  post: true
  activity: (     var st : OclIterator ; st := OclIterator.newOclIterator_String(input) ;
     var k : Sequence(String) ; k := Integer.subrange(1,st.elements->size())->collect(null) ;
         var i : int ; i := 0 ; while i < k->size() do (     k[i+1] := st.next() ;  ;     i := i + 1 ) ; 
     return k );
  static   operation tokenize( input : String, sep : String) : Sequence(String)
  pre: true
  post: true
  activity: (     var st : OclIterator ; st := OclIterator.newOclIterator_String_String(input, sep) ;
     var k : Sequence(String) ; k := Integer.subrange(1,st.elements->size())->collect(null) ;
         var i : int ; i := 0 ; while i < k->size() do (     k[i+1] := st.next() ;  ;     i := i + 1 ) ; 
     return k );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package r1a ;
import java.util.Scanner ;
public class A {
  static long gcd(long a,long b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  static boolean solve(long N,long PD,long PG){
    long dcoeff=100/gcd(100,PD);
    long gcoeff=100/gcd(100,PG);
    long dw=dcoeff*PD/100 ;
    long gw=gcoeff*PG/100 ;
    long dl=dcoeff-dw ;
    long gl=gcoeff-gw ;
    if(gw==0 && dw!=0)return false ;
    if(gl==0 && dl!=0)return false ;
    if(dcoeff>N)return false ;
    return true ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    for(int cn=1 ; cn<=T ; ++cn){
      long N=sc.nextLong();
      int PD=sc.nextInt();
      int PG=sc.nextInt();
      if(solve(N,PD,PG)){
        System.out.printf("Case #%d: Possible\n",cn);
      }
      else {
        System.out.printf("Case #%d: Broken\n",cn);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation solve( N : long, PD : long, PG : long) : boolean
  pre: true
  post: true
  activity: (     var dcoeff : long ; dcoeff := 100 / gcd(100, PD) ;
     var gcoeff : long ; gcoeff := 100 / gcd(100, PG) ;
    var dw : long ; dw := dcoeff * PD / 100 ;
    var gw : long ; gw := gcoeff * PG / 100 ;
    var dl : long ; dl := dcoeff - dw ;
    var gl : long ; gl := gcoeff - gw ;
    if (gw = 0 & dw /= 0) then     return false else skip ; 
    if (gl = 0 & dl /= 0) then     return false else skip ; 
    if (dcoeff > N) then     return false else skip ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var cn : int ; cn := 1 ; while cn <= T do ( (     var N : long ; N := sc.getCurrent()->toLong() ;
     var PD : int ; PD := sc.getCurrent()->toInteger() ;
     var PG : int ; PG := sc.getCurrent()->toInteger() ;
     if (solve(N, PD, PG)) then (     OclFile["System.out"].printf("Case #%d: Possible\n", cn) ) else (     OclFile["System.out"].printf("Case #%d: Broken\n", cn) ) )  ;     cn := cn + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SameParitySummands {
  private static void print(int n,int k,int base){
    if(n<k*base){
      System.out.println("NO");
      return ;
    }
    System.out.println("YES");
    StringBuilder stringBuilder=new StringBuilder();
    for(int j=0 ; j<k-1 ; j++){
      if(stringBuilder.length()>0)stringBuilder.append(" ");
      stringBuilder.append(base);
    }
    if(stringBuilder.length()>0)stringBuilder.append(" ");
    stringBuilder.append(n-(k-1)*base);
    System.out.println(stringBuilder);
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=scanner.nextInt(),k=scanner.nextInt();
      if(k % 2==0){
        if(n % 2==1)System.out.println("NO");
        else {
          print(n,k,1);
        }
      }
      else {
        if(n % 2==1){
          print(n,k,1);
        }
        else {
          print(n,k,2);
        }
      }
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class SameParitySummands {
  static   operation print( n : int, k : int, base : int) : void
  pre: true
  post: true
  activity: (     if (n < k * base) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
     OclFile["System.out"].println("YES") ; 
    var stringBuilder : String ; stringBuilder := StringLib.newString() ;
        var j : int ; j := 0 ; while j < k - 1 do ( (     if (stringBuilder->size() > 0) then     stringBuilder := stringBuilder + StringLib.newString(" ") ; else skip ; 
     stringBuilder := stringBuilder + StringLib.newString(base) )  ;     j := j + 1 ) ; 
    if (stringBuilder->size() > 0) then     stringBuilder := stringBuilder + StringLib.newString(" ") ; else skip ; 
    stringBuilder := stringBuilder + StringLib.newString(n - (k - 1) * base) ; 
    OclFile["System.out"].println(stringBuilder) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
     if (k mod 2 = 0) then (     if (n mod 2 = 1) then     OclFile["System.out"].println("NO") ; else (     execute print(n, k, 1) ) ) else (     if (n mod 2 = 1) then (     execute print(n, k, 1) ) else (     execute print(n, k, 2) ) ) )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Zmeigorynich {
  public static void main(String[] args){
    Kattio io=new Kattio();
    int t=io.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=io.nextInt();
      int heads=io.nextInt();
      int maxdamage=0 ;
      int maxtotaldamage=0 ;
      for(int j=0 ; j<n ; j++){
        int damage=io.nextInt();
        maxdamage=Math.max(damage,maxdamage);
        int regen=io.nextInt();
        maxtotaldamage=Math.max(maxtotaldamage,damage-regen);
      }
      if(maxtotaldamage<=0 && heads>maxdamage){
        io.println(-1);
      }
      else {
        if(maxdamage>=heads){
          io.println(1);
        }
        else if((heads-maxdamage)% maxtotaldamage==0){
          io.println((heads-maxdamage)/maxtotaldamage+1);
        }
        else {
          io.println((heads-maxdamage)/maxtotaldamage+2);
        }
      }
    }
    io.close();
  }
  static class Kattio extends PrintWriter {
    private BufferedReader r ;
    private StringTokenizer st ;
    public Kattio(){
      this(System.in,System.out);
    }
    public Kattio(InputStream i,OutputStream o){
      super(o);
      r=new BufferedReader(new InputStreamReader(i));
    }
    public Kattio(String problemName)throws IOException {
      super(problemName+".out");
      r=new BufferedReader(new FileReader(problemName+".in"));
    }
    public String next(){
      try {
        while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(r.readLine());
        return st.nextToken();
      }
      catch(Exception e){
      }
      return null ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Zmeigorynich {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : Kattio ; io := Kattio.newKattio() ;
     var t : int ; t := io.nextInt() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := io.nextInt() ;
     var heads : int ; heads := io.nextInt() ;
    var maxdamage : int ; maxdamage := 0 ;
    var maxtotaldamage : int ; maxtotaldamage := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     var damage : int ; damage := io.nextInt() ;
     maxdamage := Set{damage, maxdamage}->max() ; 
     var regen : int ; regen := io.nextInt() ;
     maxtotaldamage := Set{maxtotaldamage, damage - regen}->max() )  ;     j := j + 1 ) ; 
    if (maxtotaldamage <= 0 & heads > maxdamage) then (     io.println(-1) ) else (     if (maxdamage >= heads) then (     io.println(1) ) else     if ((heads - maxdamage) mod maxtotaldamage = 0) then (     io.println((heads - maxdamage) / maxtotaldamage + 1) ) else (     io.println((heads - maxdamage) / maxtotaldamage + 2) ) ;  ) ;  
 )  ;     i := i + 1 ) ; 
     io.close() );
  static class Kattio extends OclFile {
   attribute r : OclFile;
   attribute st : OclIterator;
   static operation newKattio() : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile["System.in"], OclFile["System.out"]) );
   static operation newKattio( i : OclFile, o : OclFile) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(i, o);
    return self );
  operation initialise( i : OclFile, o : OclFile) : void
  pre: true  post: true
  activity: (     execute super(o) ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(i)) );
   static operation newKattio( problemName : String) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(problemName);
    return self );
  operation initialise( problemName : String) : void
  pre: true  post: true
  activity: (     execute super(problemName + ".out") ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(problemName + ".in")) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(r.readLine()) ; ; 
     return st.next() )   catch (e : ProgramException) do skip
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class zmeigorynich {
  static int n ;
  static long x ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int t=Integer.parseInt(st.nextToken());
    long[] out=new long[t];
    for(int i=0 ; i<t ; i++){
      st=new StringTokenizer(br.readLine());
      n=Integer.parseInt(st.nextToken());
      x=Long.parseLong(st.nextToken());
      long[] d=new long[n+1];
      long[] h=new long[n+1];
      long maxd=Long.MIN_VALUE ;
      long maxdiff=Long.MIN_VALUE ;
      for(int j=1 ; j<=n ; j++){
        st=new StringTokenizer(br.readLine());
        d[j]=Long.parseLong(st.nextToken());
        h[j]=Long.parseLong(st.nextToken());
        maxd=Math.max(maxd,d[j]);
        maxdiff=Math.max(maxdiff,d[j]-h[j]);
      }
      if(maxd>=x){
        out[i]=1 ;
        continue ;
      }
      if(maxdiff<=0){
        out[i]=-1 ;
        continue ;
      }
      long lo=1 ;
      long hi=(long)1e9 ;
      while(lo!=hi){
        long mid=(lo+hi)/2 ;
        if(x-maxdiff*mid<=maxd){
          hi=mid ;
        }
        else {
          lo=mid+1 ;
        }
      }
      out[i]=lo+1 ;
    }
    br.close();
    for(long v : out){
      System.out.println(v);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class zmeigorynich {
  static   attribute n : int;
  static   attribute x : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var t : int ; t := (st.next())->toInteger() ;
    var out : Sequence(long) ; out := Integer.subrange(1,t)->collect(0) ;
        var i : int ; i := 0 ; while i < t do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     n := (st.next())->toInteger() ; 
    x := (st.next())->toLong() ; 
    var d : Sequence(long) ; d := Integer.subrange(1,n + 1)->collect(0) ;
    var h : Sequence(long) ; h := Integer.subrange(1,n + 1)->collect(0) ;
    var maxd : long ; maxd := "-9223372036854775808"->toLong() ;
    var maxdiff : long ; maxdiff := "-9223372036854775808"->toLong() ;
        var j : int ; j := 1 ; while j <= n do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     d[j+1] := (st.next())->toLong() ; 
    h[j+1] := (st.next())->toLong() ; 
    maxd := Set{maxd, d[j+1]}->max() ; 
    maxdiff := Set{maxdiff, d[j+1] - h[j+1]}->max() ; 
 )  ;     j := j + 1 ) ; 
    if (maxd >= x) then (     out[i+1] := 1 ; 
     continue ) else skip ; 
    if (maxdiff <= 0) then (     out[i+1] := -1 ; 
     continue ) else skip ; 
    var lo : long ; lo := 1 ;
    var hi : long ; hi := 1e9->oclAsType(long) ;
    while (lo /= hi) do (     var mid : long ; mid := (lo + hi) / 2 ;
     if (x - maxdiff * mid <= maxd) then (     hi := mid ) else (     lo := mid + 1 ) ) ; 
    out[i+1] := lo + 1 ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    for (v : out) do ( (     OclFile["System.out"].println(v) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class ZmeiGorynich {
  public static void main(String[] args){
    InputReader ir=new InputReader(System.in);
    StringBuilder sb=new StringBuilder();
    int t=ir.nextInt();
    while(t-->0){
      int n=ir.nextInt();
      int x=ir.nextInt();
      int maxDiff=0 ;
      int maxHit=0 ;
      int i=0 ;
      while(i<n){
        int d=ir.nextInt();
        int h=ir.nextInt();
        maxHit=Math.max(maxHit,d);
        maxDiff=Math.max(maxDiff,d-h);
        i++;
      }
      if(maxHit>=x){
        sb.append('1');
      }
      else if(maxDiff>0){
        sb.append((int)Math.ceil((double)(x-maxHit)/maxDiff)+1);
      }
      else {
        sb.append("-1");
      }
      sb.append("\n");
    }
    System.out.println(sb);
  }
  static class InputReader {
    BufferedReader reader ;
    StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream));
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ZmeiGorynich {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ir : InputReader ; ir := InputReader.newInputReader(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
    var t : int ; t := ir.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := ir.nextInt() ;
     var x : int ; x := ir.nextInt() ;
    var maxDiff : int ; maxDiff := 0 ;
    var maxHit : int ; maxHit := 0 ;
    var i : int ; i := 0 ;
    while (i < n) do (     var d : int ; d := ir.nextInt() ;
     var h : int ; h := ir.nextInt() ;
    maxHit := Set{maxHit, d}->max() ; 
    maxDiff := Set{maxDiff, d - h}->max() ; 
    i := i + 1 ; 
 ) ; 
    if (maxHit >= x) then (     sb := sb + StringLib.newString('1') ) else     if (maxDiff > 0) then (     sb := sb + StringLib.newString(((x - maxHit)->oclAsType(double) / maxDiff)->ceil()->oclAsType(int) + 1) ) else (     sb := sb + StringLib.newString("-1") ) ;  ;  
    sb := sb + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    label : for(int x=0 ;
    x<t ;
    x++){
      int n=Integer.parseInt(br.readLine());
      String[] sa=br.readLine().split(" ");
      long[] a=new long[n];
      for(int i=0 ; i<n ; i++){
        a[i]=Long.parseLong(sa[i]);
      }
      char[] s=br.readLine().toCharArray();
      for(int i=n-1 ; i>=0 ; i--){
        if(s[i]=='0'){
          for(int k=0 ; k<61 ; k++){
            if((a[i]>>k & 1)==1){
              for(int j=0 ; j<n ; j++){
                if(i!=j &&(a[j]>>k & 1)==1){
                  a[j] ^=a[i];
                }
              }
            }
          }
        }
        else {
          if(a[i]!=0){
            System.out.println(1);
            continue label ;
          }
        }
      }
      System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         var x : int ; x := 0 ; while x < t do ( (     var n : int ; n := (br.readLine())->toInteger() ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sa[i+1])->toLong() )  ;     i := i + 1 ) ; 
    var s : Sequence(String) ; s := br.readLine()->characters() ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (s[i+1] = '0') then (         var k : int ; k := 0 ; while k < 61 do ( (     if ((MathLib.bitwiseAnd((a[i+1]/(2->pow(k)))->oclAsType(long),1)) = 1) then (         var j : int ; j := 0 ; while j < n do ( (     if (i /= j & (MathLib.bitwiseAnd((a[j+1]/(2->pow(k)))->oclAsType(long),1)) = 1) then (     a[j+1] := MathLib.bitwiseXor(a[j+1],a[i+1]) ) else skip )  ;     j := j + 1 ) ) else skip )  ;     k := k + 1 ) ) else (     if (a[i+1] /= 0) then (     OclFile["System.out"].println(1) ; 
     continue ) else skip ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(0) ; 
 )  ;     x := x + 1 ) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    for(int i=0 ; i<T ; i++){
      int N=sc.nextInt();
      long[] A=new long[N];
      for(int j=0 ; j<N ; j++)A[j]=sc.nextLong();
      char[] s=sc.next().toCharArray();
      System.out.println(solve(A,s));
    }
    sc.close();
  }
  static int solve(long[] A,char[] s){
    int N=A.length ;
    long[] m=new long[N];
    int size=0 ;
    for(int i=N-1 ; i>=0 ; i--){
      if(s[i]=='0'){
        m[size]=A[i];
        size++;
      }
      else {
        long[] work=new long[size+1];
        work[0]=A[i];
        for(int j=0 ; j<size ; j++)work[j+1]=m[j];
        if(! couldBeZero(work)){
          return 1 ;
        }
      }
    }
    return 0 ;
  }
  static boolean couldBeZero(long[] m){
    int N=m.length ;
    for(int i=0 ; i<60 ; i++){
      int baseIndex=-1 ;
      for(int j=1 ; j<N ; j++){
        if((m[j] &(1l<<i))!=0){
          baseIndex=j ;
          break ;
        }
      }
      if(baseIndex<0)continue ;
      long base=m[baseIndex];
      for(int j=0 ; j<N ; j++){
        if((m[j] &(1l<<i))!=0){
          m[j] ^=base ;
        }
      }
    }
    return m[0]==0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < T do ( (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
        var j : int ; j := 0 ; while j < N do (     A[j+1] := sc.getCurrent()->toLong() ;  ;     j := j + 1 ) ; 
    var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    OclFile["System.out"].println(solve(A, s)) ; 
 )  ;     i := i + 1 ) ; 
     skip );
  static   operation solve( A : Sequence(long), s : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var N : int ; N := A->size() ;
     var m : Sequence(long) ; m := Integer.subrange(1,N)->collect(0) ;
    var size : int ; size := 0 ;
        var i : int ; i := N - 1 ; while i >= 0 do ( (     if (s[i+1] = '0') then (     m[size+1] := A[i+1] ; 
     size := size + 1 ) else (     var work : Sequence(long) ; work := Integer.subrange(1,size + 1)->collect(0) ;
     work[0+1] := A[i+1] ; 
         var j : int ; j := 0 ; while j < size do (     work[j + 1+1] := m[j+1] ;  ;     j := j + 1 ) ; 
     if (not(couldBeZero(work))) then (     return 1 ) else skip ) )  ;     i := i - 1 ) ; 
    return 0 
 );
  static   operation couldBeZero( m : Sequence(long)) : boolean
  pre: true
  post: true
  activity: (     var N : int ; N := m->size() ;
         var i : int ; i := 0 ; while i < 60 do ( (     var baseIndex : int ; baseIndex := -1 ;
         var j : int ; j := 1 ; while j < N do ( (     if ((m[j+1] & ((1l*(2->pow(i)))->oclAsType(long))) /= 0) then (     baseIndex := j ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (baseIndex < 0) then     continue else skip ; 
    var base : long ; base := m[baseIndex+1] ;
        var j : int ; j := 0 ; while j < N do ( (     if ((m[j+1] & ((1l*(2->pow(i)))->oclAsType(long))) /= 0) then (     m[j+1] := MathLib.bitwiseXor(m[j+1],base) ) else skip )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
     return m[0+1] = 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean checkPerfectcube(int n){
    int d=(int)Math.cbrt(n);
    if(d*d*d==n)return true ;
    return false ;
  }
  static int smallestPerfectCube(int a[],int n){
    int mini=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(checkPerfectcube(a[i])){
        mini=Math.min(a[i],mini);
      }
    }
    return mini ;
  }
  public static void main(String[] args){
    int a[]={
      16,8,25,2,3,10 };
      int n=a.length ;
      System.out.print(smallestPerfectCube(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkPerfectcube( n : int) : boolean
  pre: true
  post: true
  activity: (     var d : int ; d := (n)->cbrt()->oclAsType(int) ;
     if (d * d * d = n) then     return true else skip ; 
     return false );
  static   operation smallestPerfectCube( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var mini : int ; mini := 2147483647 ;
         var i : int ; i := 0 ; while i < n do ( (     if (checkPerfectcube(a[i+1])) then (     mini := Set{a[i+1], mini}->min() ) else skip )  ;     i := i + 1 ) ; 
     return mini );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{16,8,25,2,3,10} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(smallestPerfectCube(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int sum(int n){
    int sum=0 ;
    while(n>0){
      sum=sum+n % 10 ;
      n=n/10 ;
    }
    return sum ;
  }
  static void firstN(int n){
    int num=19,cnt=1 ;
    while(cnt!=n){
      if(sum(num)==10){
        System.out.print(num+" ");
        cnt++;
      }
      num+=9 ;
    }
  }
  public static void main(String[] args){
    int n=10 ;
    firstN(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n > 0) do (     sum := sum + n mod 10 ; 
     n := n / 10 ) ; 
     return sum );
  static   operation firstN( n : int) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 19 ;
    var cnt : int ; cnt := 1 ;
     while (cnt /= n) do (     if (sum(num) = 10) then (     OclFile["System.out"].print(num + " ") ; 
     cnt := cnt + 1 ) else skip ; 
     num := num+(9) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     execute firstN(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void pairwiseProduct(int[] arr,int n){
    int prod=1 ;
    for(int i=0 ; i<n-1 ; i++){
      prod=arr[i]*arr[i+1];
      System.out.print(prod+" ");
    }
  }
  public static void main(String[] args){
    int[] arr={
      4,10,15,5,6 };
      int n=arr.length ;
      pairwiseProduct(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pairwiseProduct( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var prod : int ; prod := 1 ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     prod := arr[i+1] * arr[i + 1+1] ; 
     OclFile["System.out"].print(prod + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,10,15,5,6} ;
     var n : int ; n := arr->size() ;
     execute pairwiseProduct(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static final int FAVOURITE_NUMBER=753 ;
  public static int process(TestCase testCase){
    String S=testCase.S ;
    int min=Integer.MAX_VALUE ;
    for(int i=2,length=S.length(); i<length ; ++i){
      final int num=Integer.valueOf(S.substring(i-2,i+1));
      min=Math.min(min,diff(num));
    }
    return min ;
  }
  private static int diff(int num){
    return Math.abs(FAVOURITE_NUMBER-num);
  }
  public static void main(String[] args){
    TestCase testCase=readFromInput();
    final int result=process(testCase);
    output(result);
  }
  private static TestCase readFromInput(){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    sc.close();
    return new TestCase(S);
  }
  private static void output(int result){
    System.out.println(result);
  }
  public static class TestCase {
    final String S ;
    public TestCase(String S){
      this.S=S ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute FAVOURITE_NUMBER : int := 753;
  static   operation process( testCase : TestCase) : int
  pre: true
  post: true
  activity: (     var S : String ; S := testCase.S ;
     var min : int ; min := 2147483647 ;
         var i : int ; i := 2 ;
    var length : int ; length := S->size() ; while i < length do ( (     var num : int ; num := (S.subrange(i - 2+1,i + 1))->toInteger() ;
     min := Set{min, diff(num)}->min() )  ;     i := i + 1 ) ; 
     return min );
  static   operation diff( num : int) : int
  pre: true
  post: true
  activity: (     return if FAVOURITE_NUMBER - num < 0 then -(FAVOURITE_NUMBER - num) else FAVOURITE_NUMBER - num endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var testCase : TestCase ; testCase := readFromInput() ;
     var result : int ; result := process(testCase) ;
     execute output(result) );
  static   operation readFromInput() : TestCase
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
     skip ; 
     return TestCase.newTestCase(S) );
  static   operation output( result : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(result) );
  static class TestCase {
   attribute S : String;
   static operation newTestCase( S : String) : TestCase
  pre: true
  post: true
  activity:
  ( var self : TestCase ;
    self := createTestCase();
    self.initialise(S);
    return self );
  operation initialise( S : String) : void
  pre: true  post: true
  activity: (     self.S := S );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String A ;
    int num[]=new int[3];
    int ans=0 ;
    int answer=0 ;
    int result=1000 ;
    String slist[]=s.split("");
    for(int i=2 ; i<slist.length ; i++){
      A=slist[i-2]+slist[i-1]+slist[i];
      ans=Integer.parseInt(A);
      answer=Math.abs(753-ans);
      if(answer<result){
        result=answer ;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var A : String ;
    var num : Sequence(int) ; num := Integer.subrange(1,3)->collect(0) ;
    var ans : int ; ans := 0 ;
    var answer : int ; answer := 0 ;
    var result : int ; result := 1000 ;
    var slist : Sequence(String) ; slist := s->split("") ;
        var i : int ; i := 2 ; while i < slist->size() do ( (     A := slist[(i)->char2byte() - 2+1] + slist[(i)->char2byte() - 1+1] + slist[i+1] ; 
     ans := (A)->toInteger() ; 
     answer := if 753 - ans < 0 then -(753 - ans) else 753 - ans endif ; 
     if (answer < result) then (     result := answer ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileNotFoundException ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class B {
  public static void main(String[] args)throws FileNotFoundException {
    FastReader fr=new FastReader();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder st=new StringBuilder("");
    int t=fr.nextInt();
    while(t-->0){
      int n=fr.nextInt();
      int nn=n ;
      int k=fr.nextInt();
      nn-=k-1 ;
      boolean bo=false ;
      if(nn % 2==1 && nn>=1){
        bo=true ;
        st.append("YES\n");
        for(int i=0 ; i<k-1 ; i++){
          st.append(1+" ");
        }
        st.append(nn+"\n");
      }
      else {
        n-=2*(k-1);
        if(n % 2==0 && n>=2){
          bo=true ;
          st.append("YES\n");
          for(int i=0 ; i<k-1 ; i++){
            st.append(2+" ");
          }
          st.append(n+"\n");
        }
      }
      if(! bo){
        st.append("NO\n");
      }
    }
    out.print(st);
    out.close();
  }
  static class FastReader {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
      }
      return st.nextToken();
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fr : FastReader ; fr := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var st : String ; st := StringLib.newString("") ;
    var t : int ; t := fr.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := fr.nextInt() ;
     var nn : int ; nn := n ;
    var k : int ; k := fr.nextInt() ;
    nn := nn-(k - 1) ; 
    var bo : boolean ; bo := false ;
    if (nn mod 2 = 1 & nn >= 1) then (     bo := true ; 
     st := st + StringLib.newString("YES\n") ; 
         var i : int ; i := 0 ; while i < k - 1 do ( (     st := st + StringLib.newString(1 + " ") )  ;     i := i + 1 ) ; 
     st := st + StringLib.newString(nn + "\n") ) else (     n := n-(2 * (k - 1)) ; 
     if (n mod 2 = 0 & n >= 2) then (     bo := true ; 
     st := st + StringLib.newString("YES\n") ; 
         var i : int ; i := 0 ; while i < k - 1 do ( (     st := st + StringLib.newString(2 + " ") )  ;     i := i + 1 ) ; 
     st := st + StringLib.newString(n + "\n") ) else skip ) ;  
    if (not(bo)) then (     st := st + StringLib.newString("NO\n") ) else skip ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ; 
     return st.next() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static final int number=753 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.nextLine();
    int max=Integer.MAX_VALUE ;
    for(int a=0 ; a<=S.length()-3 ; a++){
      int k=Integer.parseInt(S.substring(a,a+3));
      max=Math.min(max,Math.abs(k-number));
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute number : int := 753;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.nextLine() ;
    var max : int ; max := 2147483647 ;
        var a : int ; a := 0 ; while a <= S->size() - 3 do ( (     var k : int ; k := (S.subrange(a+1,a + 3))->toInteger() ;
     max := Set{max, if k - number < 0 then -(k - number) else k - number endif}->min() )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    while(scanner.hasNextLine()){
      String s=scanner.nextLine();
      int min=1000000 ;
      for(int i=0 ; i<=s.length()-3 ; i++){
        String c=s.substring(i,i+3);
        int p=Integer.parseInt(c);
        min=Math.min(Math.abs(p-753),min);
      }
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scanner.hasNextLine()) do (     var s : String ; s := scanner.nextLine() ;
     var min : int ; min := 1000000 ;
         var i : int ; i := 0 ; while i <= s->size() - 3 do ( (     var c : String ; c := s.subrange(i+1,i + 3) ;
     var p : int ; p := (c)->toInteger() ;
     min := Set{if (p)->char2byte() - 753 < 0 then -((p)->char2byte() - 753) else (p)->char2byte() - 753 endif, min}->min() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(min) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static void main(String args[]){
    float P=1,R=1,T=1 ;
    float SI=(P*T*R)/100 ;
    System.out.println("Simple interest="+SI);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var P : double ; P := 1 ;
    var R : double ; R := 1 ;
    var T : double ; T := 1 ;
     var SI : double ; SI := (P * T * R) / 100 ;
     OclFile["System.out"].println("Simple interest=" + SI) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    long mod=(long)Math.pow(10,9)+7 ;
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long a=sc.nextLong();
    long b=sc.nextLong();
    long ans=rep2(2,n,mod)-1 ;
    long alla=1 ;
    long allb=1 ;
    long diva=1 ;
    long divb=1 ;
    for(int i=0 ; i<a ; i++){
      alla*=(n-i);
      alla %=mod ;
      diva*=(a-i);
      diva %=mod ;
    }
    for(int i=0 ; i<b ; i++){
      allb*=(n-i);
      allb %=mod ;
      divb*=(b-i);
      divb %=mod ;
    }
    alla*=rep2(diva,(long)Math.pow(10,9)+5,mod)% mod ;
    alla %=mod ;
    allb*=rep2(divb,(long)Math.pow(10,9)+5,mod)% mod ;
    allb %=mod ;
    ans-=(alla+allb);
    while(ans<0){
      ans+=mod ;
    }
    System.out.println(ans % mod);
  }
  private static long rep2(long b,long n,long mod){
    if(n==0)return 1 ;
    if(n==1)return b ;
    long bn=rep2(b,n/2,mod)% mod ;
    if(n % 2==0){
      return(long)(bn % mod*bn % mod)% mod ;
    }
    else {
      return(long)(bn % mod*bn % mod)% mod*b % mod ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mod : long ; mod := 10->pow(9)->oclAsType(long) + 7 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : long ; n := sc.getCurrent()->toLong() ;
    var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var ans : long ; ans := rep2(2, n, mod) - 1 ;
    var alla : long ; alla := 1 ;
    var allb : long ; allb := 1 ;
    var diva : long ; diva := 1 ;
    var divb : long ; divb := 1 ;
        var i : int ; i := 0 ; while i < a do ( (     alla := alla*((n - i)) ; 
     alla := alla mod mod ; 
     diva := diva*((a - i)) ; 
     diva := diva mod mod )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < b do ( (     allb := allb*((n - i)) ; 
     allb := allb mod mod ; 
     divb := divb*((b - i)) ; 
     divb := divb mod mod )  ;     i := i + 1 ) ; 
    alla := alla*(rep2(diva, 10->pow(9)->oclAsType(long) + 5, mod) mod mod) ; 
    alla := alla mod mod ; 
    allb := allb*(rep2(divb, 10->pow(9)->oclAsType(long) + 5, mod) mod mod) ; 
    allb := allb mod mod ; 
    ans := ans-((alla + allb)) ; 
    while (ans < 0) do (     ans := ans+(mod) ) ; 
    OclFile["System.out"].println(ans mod mod) ; 
 );
  static   operation rep2( b : long, n : long, mod : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     if (n = 1) then     return b else skip ; 
     var bn : long ; bn := rep2(b, n / 2, mod) mod mod ;
     if (n mod 2 = 0) then (     return (bn mod mod * bn mod mod)->oclAsType(long) mod mod ) else (     return (bn mod mod * bn mod mod)->oclAsType(long) mod mod * b mod mod ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.net.CookieHandler ;
import java.util.*;
public class Main {
  static PrintWriter out=new PrintWriter(System.out);
  static Scanner sc=new Scanner(System.in);
  static BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
  long[] frac ;
  long mod=1000000000+7 ;
  public static void main(String[] args)throws IOException {
    Main main=new Main();
    main.solve();
  }
  void solve()throws IOException {
    int n=sc.nextInt(),a=sc.nextInt(),b=sc.nextInt();
    frac=new long[b+1];
    frac[0]=1 ;
    for(int i=1 ; i<=b ; i++)frac[i]=frac[i-1]*i % mod ;
    long ans=power(2,n)+mod-1 ;
    ans %=mod ;
    ans-=helper(n-a+1,n)*inv(a)% mod ;
    ans-=helper(n-b+1,n)*inv(b)% mod ;
    ans=(ans+10*mod)% mod ;
    System.out.println(ans);
  }
  long inv(int m){
    if(m==0)return 1 ;
    return power(frac[m],mod-2);
  }
  long power(long base,long p){
    long ans=1 ;
    while(p>0){
      if(p % 2==1)ans=ans*base % mod ;
      base=base*base % mod ;
      p/=2 ;
    }
    return ans ;
  }
  long helper(long from,long to){
    if(from>to){
      long mid=to ;
      to=from ;
      from=mid ;
    }
    long ans=from ;
    for(long i=from+1 ; i<=to ; i++){
      ans=ans*i % mod ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute frac : Sequence(long);
   attribute mod : long := 1000000000 + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
     frac := Integer.subrange(1,b + 1)->collect(0) ; 
    frac[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= b do (     frac[i+1] := frac[i - 1+1] * i mod mod ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := power(2, n) + mod - 1 ;
    ans := ans mod mod ; 
    ans := ans-(helper(n - a + 1, n) * inv(a) mod mod) ; 
    ans := ans-(helper(n - b + 1, n) * inv(b) mod mod) ; 
    ans := (ans + 10 * mod) mod mod ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation inv( m : int) : long
  pre: true
  post: true
  activity: (     if (m = 0) then     return 1 else skip ; 
     return power(frac[m+1], mod - 2) );
   operation power( base : long, p : long) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
     while (p > 0) do (     if (p mod 2 = 1) then     ans := ans * base mod mod ; else skip ; 
     base := base * base mod mod ; 
     p := p/(2) ) ; 
     return ans );
   operation helper( from : long, to : long) : long
  pre: true
  post: true
  activity: (     if (from > to) then (     var mid : long ; mid := to ;
     to := from ; 
     from := mid ) else skip ; 
     var ans : long ; ans := from ;
         var i : long ; i := from + 1 ; while i <= to do ( (     ans := ans * i mod mod )  ;     i := i + 1 ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    final int n=scanner.nextInt();
    final int a=scanner.nextInt();
    final int b=scanner.nextInt();
    int result=((modpow(2,n)-1-comb(n,a))% PRIME-comb(n,b))% PRIME ;
    while(result<0){
      result+=PRIME ;
    }
    System.out.println(result);
  }
  static int modpow(int n,int p){
    long res=1 ;
    long a=n ;
    for(a %=PRIME ; p>0 ; a=a*a % PRIME,p>>=1)if((p & 1)>0)res=res*a % PRIME ;
    return(int)res ;
  }
  static int tower2(int n){
    if(n==1)return 2 ;
    return(int)((long)tower2(n/2)*tower2(n-n/2)% PRIME);
  }
  static int fact(int n){
    if(n==1)return 1 ;
    return(int)((long)n*fact(n-1)% PRIME);
  }
  static int comb(int n,int k){
    long numer=1,denom=1 ;
    for(int i=0 ; i<k ; i++){
      numer=numer*(n-i)% PRIME ;
      denom=denom*(i+1)% PRIME ;
    }
    return(int)(numer*inverse((int)denom)% PRIME);
  }
  static int inverse(int denom){
    if(denom==0)return 0 ;
    int a=PRIME ;
    int b=denom ;
    int x=0 ;
    int y=1 ;
    int temp ;
    while(a % b!=0){
      x-=a/b*y ;
      temp=x ;
      x=y ;
      y=temp ;
      temp=a % b ;
      a=b ;
      b=temp ;
    }
    return y ;
  }
  static final int PRIME=1000000007 ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var result : int ; result := ((modpow(2, n) - 1 - comb(n, a)) mod PRIME - comb(n, b)) mod PRIME ;
    while (result < 0) do (     result := result+(PRIME) ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation modpow( n : int, p : int) : int
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     var a : long ; a := n ;
         a := a mod PRIME ; while p > 0 do (     if ((p & 1) > 0) then     res := res * a mod PRIME ; else skip ;  ;     a := a * a mod PRIME ;     p := p/(2->pow(1)) ) ; 
     return res->oclAsType(int) );
  static   operation tower2( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 2 else skip ; 
     return (tower2(n / 2)->oclAsType(long) * tower2(n - n / 2) mod PRIME)->oclAsType(int) );
  static   operation fact( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 1 else skip ; 
     return (n->oclAsType(long) * fact(n - 1) mod PRIME)->oclAsType(int) );
  static   operation comb( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var numer : long ; numer := 1 ;
    var denom : long ; denom := 1 ;
         var i : int ; i := 0 ; while i < k do ( (     numer := numer * (n - i) mod PRIME ; 
     denom := denom * (i + 1) mod PRIME )  ;     i := i + 1 ) ; 
     return (numer * inverse(denom->oclAsType(int)) mod PRIME)->oclAsType(int) );
  static   operation inverse( denom : int) : int
  pre: true
  post: true
  activity: (     if (denom = 0) then     return 0 else skip ; 
     var a : int ; a := PRIME ;
    var b : int ; b := denom ;
    var x : int ; x := 0 ;
    var y : int ; y := 1 ;
    var temp : int ;
    while (a mod b /= 0) do (     x := x-(a / b * y) ; 
     temp := x ; 
    x := y ; 
    y := temp ; 
    temp := a mod b ; 
    a := b ; 
    b := temp ; 
 ) ; 
    return y 
 );
  static    attribute PRIME : int := 1000000007;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printPattern(int n){
    int t ;
    for(int i=1 ; i<=n ; i++){
      for(int j=i ; j<n ; j++)System.out.print("\t");
      t=i ;
      for(int k=1 ; k<=i ; k++){
        System.out.print(t+"\t\t");
        t=t+n-k ;
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    int n=6 ;
    printPattern(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printPattern( n : int) : void
  pre: true
  post: true
  activity: (     var t : int ;
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i ; while j < n do (     OclFile["System.out"].print("\t") ;  ;     j := j + 1 ) ; 
     t := i ; 
         var k : int ; k := 1 ; while k <= i do ( (     OclFile["System.out"].print(t + "\t\t") ; 
     t := t + n - k )  ;     k := k + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     execute printPattern(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static long inv[];
  static int mod=1_000_000_007 ;
  static long pow(long a,int n){
    long res=1 ;
    while(n>0){
      if((n-n/2*2)==1){
        res=res*a % mod ;
      }
      a=a*a % mod ;
      n>>=1 ;
    }
    return res ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    inv=new long[b+1];
    inv[1]=1 ;
    for(int i=2 ; i<=b ; i++){
      inv[i]=inv[mod % i]*(mod-mod/i)% mod ;
    }
    long comb[]=new long[b+1];
    comb[0]=1 ;
    for(int i=1 ; i<=b ; i++){
      comb[i]=comb[i-1]*((n-i+1)% mod);
      comb[i] %=mod ;
      comb[i]*=inv[i];
      comb[i] %=mod ;
    }
    long ans=pow(2,n);
    ans-=1 ;
    ans %=mod ;
    ans-=comb[a];
    if(ans<0){
      ans+=mod ;
    }
    ans %=mod ;
    ans-=comb[b];
    if(ans<0){
      ans+=mod ;
    }
    ans %=mod ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute inv : Sequence(long);
  static   attribute mod : int := 1_000_000_007;
  static   operation pow( a : long, n : int) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     while (n > 0) do (     if ((n - n / 2 * 2) = 1) then (     res := res * a mod mod ) else skip ; 
     a := a * a mod mod ; 
     n := n/(2->pow(1)) ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    inv := Integer.subrange(1,b + 1)->collect(0) ; 
    inv[1+1] := 1 ; 
        var i : int ; i := 2 ; while i <= b do ( (     inv[i+1] := inv[mod mod i+1] * (mod - mod / i) mod mod )  ;     i := i + 1 ) ; 
    var comb : Sequence(long) ; comb := Integer.subrange(1,b + 1)->collect(0) ;
    comb[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= b do ( (     comb[i+1] := comb[i - 1+1] * ((n - i + 1) mod mod) ; 
     comb[i+1] := comb[i+1] mod mod ; 
     comb[i+1] := comb[i+1]*(inv[i+1]) ; 
     comb[i+1] := comb[i+1] mod mod )  ;     i := i + 1 ) ; 
    var ans : long ; ans := pow(2, n) ;
    ans := ans-(1) ; 
    ans := ans mod mod ; 
    ans := ans-(comb[a+1]) ; 
    if (ans < 0) then (     ans := ans+(mod) ) else skip ; 
    ans := ans mod mod ; 
    ans := ans-(comb[b+1]) ; 
    if (ans < 0) then (     ans := ans+(mod) ) else skip ; 
    ans := ans mod mod ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    solve(System.in,System.out);
  }
  static final int MOD=(int)Math.pow(10,9)+7 ;
  static void solve(InputStream is,PrintStream os){
    Scanner scan=new Scanner(is);
    int n=scan.nextInt();
    int a=scan.nextInt();
    int b=scan.nextInt();
    long ret=powMod(2,n)-1-combinationMod(n,a)-combinationMod(n,b);
    ret %=MOD ;
    os.println(ret<0 ? ret+MOD : ret);
  }
  static long powMod(long seed,long n){
    long ret=1 ;
    while(n>0){
      if((n & 1)==1)ret=seed*ret % MOD ;
      seed=seed*seed % MOD ;
      n=n>>1 ;
    }
    return ret ;
  }
  static long combinationMod(long n,long k){
    long ret=1 ;
    for(long i=n ; i>=n-k+1 ; i--){
      ret=ret*i % MOD ;
      BigInteger inv=new BigInteger(String.valueOf(n-i+1)).modInverse(BigInteger.valueOf(MOD));
      ret=ret*inv.longValue()% MOD ;
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve(OclFile["System.in"], OclFile["System.out"]) );
  static    attribute MOD : int := 10->pow(9)->oclAsType(int) + 7;
  static   operation solve( is : OclFile, os : OclFile) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(is) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    var ret : long ; ret := powMod(2, n) - 1 - combinationMod(n, a) - combinationMod(n, b) ;
    ret := ret mod MOD ; 
    os.println(if ret < 0 then ret + MOD else ret endif) ; 
 );
  static   operation powMod( seed : long, n : long) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := 1 ;
     while (n > 0) do (     if ((MathLib.bitwiseAnd(n,1)) = 1) then     ret := seed * ret mod MOD ; else skip ; 
     seed := seed * seed mod MOD ; 
     n := (n/(2->pow(1)))->oclAsType(long) ) ; 
     return ret );
  static   operation combinationMod( n : long, k : long) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := 1 ;
         var i : long ; i := n ; while i >= n - k + 1 do ( (     ret := ret * i mod MOD ; 
     var inv : long ; inv := long(((n - i + 1) + "")).modInverse((MOD + "")->toLong()) ;
     ret := ret * inv->oclAsType(long) mod MOD )  ;     i := i - 1 ) ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.Math ;
public class cp {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String args[])throws Exception {
    FastReader sc=new FastReader();
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int k=sc.nextInt();
      int sumodd=n-k+1 ;
      int sumev=n-2*k+2 ;
      if(sumodd % 2!=0 && sumodd>0){
        System.out.println("YES");
        for(int i=0 ; i<k-1 ; i++)System.out.print("1 ");
        System.out.println(sumodd);
      }
      else if(sumev % 2==0 && sumev>0){
        System.out.println("YES");
        for(int i=0 ; i<k-1 ; i++)System.out.print("2 ");
        System.out.println(sumev);
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var t : int ; t := sc.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.nextInt() ;
     var k : int ; k := sc.nextInt() ;
    var sumodd : int ; sumodd := n - k + 1 ;
    var sumev : int ; sumev := n - 2 * k + 2 ;
    if (sumodd mod 2 /= 0 & sumodd > 0) then (     OclFile["System.out"].println("YES") ; 
         var i : int ; i := 0 ; while i < k - 1 do (     OclFile["System.out"].print("1 ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sumodd) ) else     if (sumev mod 2 = 0 & sumev > 0) then (     OclFile["System.out"].println("YES") ; 
         var i : int ; i := 0 ; while i < k - 1 do (     OclFile["System.out"].print("2 ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sumev) ) else (     OclFile["System.out"].println("NO") ) ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.Math ;
public class Reconnaissance {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,d ;
    int count=0 ;
    n=sc.nextInt();
    d=sc.nextInt();
    int[] arr ;
    arr=new int[1001];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    for(int j=0 ; j<n ; j++){
      for(int k=0 ; k<n ; k++){
        int m=Math.abs(arr[j]-arr[k]);
        if(m<=d && j!=k){
          count++;
        }
      }
    }
    System.out.println(count);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Reconnaissance {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var d : int ;
    var count : int ; count := 0 ;
    n := sc.getCurrent()->toInteger() ; 
    d := sc.getCurrent()->toInteger() ; 
    var arr : Sequence(int) ;
    arr := Integer.subrange(1,1001)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (         var k : int ; k := 0 ; while k < n do ( (     var m : int ; m := if arr[j+1] - arr[k+1] < 0 then -(arr[j+1] - arr[k+1]) else arr[j+1] - arr[k+1] endif ;
     if (m <= d & j /= k) then (     count := count + 1 ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.rmi.server.RemoteServer ;
import java.security.cert.CollectionCertStoreParameters ;
import java.util.*;
import javax.xml.transform.SourceLocator ;
public class A_Reconnaissance {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    long k=s.nextLong();
    long arr[]=new long[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=s.nextLong();
    }
    int count=0 ;
    Arrays.sort(arr);
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        if(Math.abs(arr[i]-arr[j])<=k){
          count+=2 ;
        }
        if(Math.abs(arr[i]-arr[j])>k)break ;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Reconnaissance {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var k : long ; k := s.getCurrent()->toLong() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (if arr[i+1] - arr[j+1] < 0 then -(arr[i+1] - arr[j+1]) else arr[i+1] - arr[j+1] endif <= k) then (     count := count+(2) ) else skip ; 
     if (if arr[i+1] - arr[j+1] < 0 then -(arr[i+1] - arr[j+1]) else arr[i+1] - arr[j+1] endif > k) then     break else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int d=Integer.parseInt(sc.next());
    sc.nextLine();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(sc.next());
    }
    int res=0 ;
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        if(Math.abs(arr[i]-arr[j])<=d){
          res++;
        }
      }
    }
    System.out.println(res*2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var d : int ; d := (sc.getCurrent())->toInteger() ;
    skip ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (if arr[i+1] - arr[j+1] < 0 then -(arr[i+1] - arr[j+1]) else arr[i+1] - arr[j+1] endif <= d) then (     res := res + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res * 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  static final int INF=0x3f3f3f3f ;
  static final long LNF=0x3f3f3f3f3f3f3f3fL ;
  public static void main(String[] args)throws IOException {
    initReader();
    long a=nextInt(),b=nextInt();
    long c[]=new long[(int)a];
    for(int i=0 ; i<a ; i++){
      c[i]=nextLong();
    }
    Arrays.sort(c);
    int num=0 ;
    for(int i=0 ; i<a ; i++){
      int j=i+1 ;
      while(j<a){
        if(c[j]-c[i]<=b){
          num++;
          j++;
        }
        else break ;
      }
    }
    pw.println(2*num);
    pw.close();
  }
  static BufferedReader reader ;
  static StringTokenizer tokenizer ;
  static PrintWriter pw ;
  public static void initReader()throws IOException {
    reader=new BufferedReader(new InputStreamReader(System.in));
    tokenizer=new StringTokenizer("");
    pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  }
  public static boolean hasNext(){
    try {
      while(! tokenizer.hasMoreTokens()){
        tokenizer=new StringTokenizer(reader.readLine());
      }
    }
    catch(Exception e){
      return false ;
    }
    return true ;
  }
  public static String next()throws IOException {
    while(! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  public static String nextLine(){
    try {
      return reader.readLine();
    }
    catch(Exception e){
      return null ;
    }
  }
  public static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public static long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public static char nextChar()throws IOException {
    return next().charAt(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := 0x3f3f3f3f;
  static    attribute LNF : long := 0x3f3f3f3f3f3f3f3fL;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute initReader() ; 
     var a : long ; a := nextInt() ;
    var b : long ; b := nextInt() ;
    var c : Sequence(long) ; c := Integer.subrange(1,a->oclAsType(int))->collect(0) ;
        var i : int ; i := 0 ; while i < a do ( (     c[i+1] := nextLong() )  ;     i := i + 1 ) ; 
    c := c->sort() ; 
    var num : int ; num := 0 ;
        var i : int ; i := 0 ; while i < a do ( (     var j : int ; j := i + 1 ;
     while (j < a) do (     if (c[j+1] - c[i+1] <= b) then (     num := num + 1 ; 
     j := j + 1 ) else     break ) )  ;     i := i + 1 ) ; 
    pw.println(2 * num) ; 
    pw.close() ; 
 );
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   attribute pw : OclFile;
  static   operation initReader() : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := OclIterator.newOclIterator_String("") ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) );
  static   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     try (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (e : ProgramException) do (     return false )
     return true );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : ProgramException) do (     return null )
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean checkDivisibility(String num){
    int length=num.length();
    if(length==1 && num.charAt(0)=='0')return true ;
    if(length % 3==1){
      num+="00" ;
      length+=2 ;
    }
    else if(length % 3==2){
      num+="0" ;
      length+=1 ;
    }
    int sum=0,p=1 ;
    for(int i=length-1 ; i>=0 ; i--){
      int group=0 ;
      group+=num.charAt(i--)-'0' ;
      group+=(num.charAt(i--)-'0')*10 ;
      group+=(num.charAt(i)-'0')*100 ;
      sum=sum+group*p ;
      p*=(-1);
    }
    sum=Math.abs(sum);
    return(sum % 13==0);
  }
  public static void main(String[] args){
    String number="83959092724" ;
    if(checkDivisibility(number))System.out.println(number+" is divisible by 13.");
    else System.out.println(number+" is not divisibe by 13.");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkDivisibility( num : String) : boolean
  pre: true
  post: true
  activity: (     var length : int ; length := num->size() ;
     if (length = 1 & num->at(0+1) = '0') then     return true else skip ; 
    if (length mod 3 = 1) then (     num := num+("00") ; 
     length := length+(2) ) else     if (length mod 3 = 2) then (     num := num+("0") ; 
     length := length+(1) ) else skip ; ;  
    var sum : int ; sum := 0 ;
    var p : int ; p := 1 ;
        var i : int ; i := length - 1 ; while i >= 0 do ( (     var group : int ; group := 0 ;
     group := group+(num->at(i+1) - ('0')->char2byte()) ; 
    group := group+((num->at(i+1) - ('0')->char2byte()) * 10) ; 
    group := group+((num->at(i+1) - ('0')->char2byte()) * 100) ; 
    sum := sum + group * p ; 
    p := p*((-1)) ; 
 )  ;     i := i - 1 ) ; 
    sum := if sum < 0 then -(sum) else sum endif ; 
    return (sum mod 13 = 0) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var number : String ; number := "83959092724" ;
     if (checkDivisibility(number)) then     OclFile["System.out"].println(number + " is divisible by 13.") ; else     OclFile["System.out"].println(number + " is not divisibe by 13.") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  static Boolean isOverflow(long a,long b){
    if(a==0 || b==0)return false ;
    long result=a*b ;
    if(a==result/b)return false ;
    else return true ;
  }
  public static void main(String argc[]){
    long a=Long.parseLong("10000000000");
    long b=Long.parseLong("-10000000000");
    if(isOverflow(a,b))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation isOverflow( a : long, b : long) : Boolean
  pre: true
  post: true
  activity: (     if (a = 0 or b = 0) then     return false else skip ; 
     var result : long ; result := a * b ;
     if (a = result / b) then     return false else     return true );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ; a := ("10000000000")->toLong() ;
     var b : long ; b := ("-10000000000")->toLong() ;
     if (isOverflow(a, b)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    int t=fs.nextInt();
    while(t-->0){
      long l=fs.nextLong();
      long r=fs.nextLong();
      if(l*2>r)System.out.println("YES");
      else System.out.println("NO");
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! 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());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var t : int ; t := fs.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var l : long ; l := fs.nextLong() ;
     var r : long ; r := fs.nextLong() ;
     if (l * 2 > r) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) ;  ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF_1437A_MarketingScheme {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int count=scanner.nextInt();
    for(int i=0 ; i<count ; i++){
      int l=scanner.nextInt();
      int r=scanner.nextInt();
      if(2*l>r){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF_1437A_MarketingScheme {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < count do ( (     var l : int ; l := scanner.getCurrent()->toInteger() ;
     var r : int ; r := scanner.getCurrent()->toInteger() ;
     if (2 * l > r) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Point {
    int x,y ;
  }
  static boolean doOverlap(Point l1,Point r1,Point l2,Point r2){
    if(l1.x>=r2.x || l2.x>=r1.x){
      return false ;
    }
    if(l1.y<=r2.y || l2.y<=r1.y){
      return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    Point l1=new Point(),r1=new Point(),l2=new Point(),r2=new Point();
    l1.x=0 ;
    l1.y=10 ;
    r1.x=10 ;
    r1.y=0 ;
    l2.x=5 ;
    l2.y=5 ;
    r2.x=15 ;
    r2.y=0 ;
    if(doOverlap(l1,r1,l2,r2)){
      System.out.println("Rectangles Overlap");
    }
    else {
      System.out.println("Rectangles Don't Overlap");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Point {
   attribute x : int;
}
  static   operation doOverlap( l1 : Point, r1 : Point, l2 : Point, r2 : Point) : boolean
  pre: true
  post: true
  activity: (     if (l1.x >= r2.x or l2.x >= r1.x) then (     return false ) else skip ; 
     if (l1.y <= r2.y or l2.y <= r1.y) then (     return false ) else skip ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l1 : Point ; l1 := Point.newPoint() ;
    var r1 : Point ; r1 := Point.newPoint() ;
    var l2 : Point ; l2 := Point.newPoint() ;
    var r2 : Point ; r2 := Point.newPoint() ;
     l1.x := 0 ; 
    l1.y := 10 ; 
    r1.x := 10 ; 
    r1.y := 0 ; 
    l2.x := 5 ; 
    l2.y := 5 ; 
    r2.x := 15 ; 
    r2.y := 0 ; 
    if (doOverlap(l1, r1, l2, r2)) then (     OclFile["System.out"].println("Rectangles Overlap") ) else (     OclFile["System.out"].println("Rectangles Don't Overlap") ) ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static int dp[];
  public static int MM=1000001 ;
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    dp=new int[MM];
    for(int i=0 ; i<MM ; i++){
      dp[i]=-1 ;
    }
    while(true){
      int N=sc.nextInt();
      if(N==0){
        break ;
      }
      System.out.println(recursion(N));
    }
  }
  public static int recursion(int in){
    if(in==1){
      return 0 ;
    }
    if(in<MM){
      if(dp[in]!=-1){
        return dp[in];
      }
      else {
        if(in % 2==1){
          return dp[in]=recursion(in*3+1)+1 ;
        }
        else {
          return dp[in]=recursion(in/2)+1 ;
        }
      }
    }
    else {
      if(in % 2==1){
        return recursion(in*3+1)+1 ;
      }
      else {
        return recursion(in/2)+1 ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dp : Sequence(int);
  static   attribute MM : int := 1000001;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     dp := Integer.subrange(1,MM)->collect(0) ; 
         var i : int ; i := 0 ; while i < MM do ( (     dp[i+1] := -1 )  ;     i := i + 1 ) ; 
     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then (     break ) else skip ; 
     OclFile["System.out"].println(recursion(N)) ) );
  static   operation recursion( in : int) : int
  pre: true
  post: true
  activity: (     if (in = 1) then (     return 0 ) else skip ; 
     if (in < MM) then (     if (dp[in+1] /= -1) then (     return dp[in+1] ) else (     if (in mod 2 = 1) then (     return dp[in+1] ) else (     return dp[in+1] ) ) ) else (     if (in mod 2 = 1) then (     return recursion(in * 3 + 1) + 1 ) else (     return recursion(in / 2) + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int k=sc.nextInt();
      int n1=n-k ;
      if(n1>=0 && n1 % 2==0){
        System.out.println("YES");
        for(int j=0 ; j<k-1 ; j++){
          System.out.print("1 ");
        }
        System.out.println((1+n1));
        continue ;
      }
      int n2=n-2*k ;
      if(n2>=0 && n2 % 2==0){
        System.out.println("YES");
        for(int j=0 ; j<k-1 ; j++){
          System.out.print("2 ");
        }
        System.out.println((2+n2));
        continue ;
      }
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var n1 : int ; n1 := n - k ;
    if (n1 >= 0 & n1 mod 2 = 0) then (     OclFile["System.out"].println("YES") ; 
         var j : int ; j := 0 ; while j < k - 1 do ( (     OclFile["System.out"].print("1 ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println((1 + n1)) ; 
     continue ) else skip ; 
    var n2 : int ; n2 := n - 2 * k ;
    if (n2 >= 0 & n2 mod 2 = 0) then (     OclFile["System.out"].println("YES") ; 
         var j : int ; j := 0 ; while j < k - 1 do ( (     OclFile["System.out"].print("2 ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println((2 + n2)) ; 
     continue ) else skip ; 
    OclFile["System.out"].println("NO") ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,count ;
    for(; ; out.println(count)){
      n=sc.nextInt();
      if(n==0)break ;
      for(count=0 ; n!=1 ; count++){
        if(n % 2==0)n/=2 ;
        else n=n*3+1 ;
      }
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var count : int ;
       while true do ( (     n := sc.nextInt() ; 
     if (n = 0) then     break else skip ; 
         count := 0 ; while n /= 1 do ( (     if (n mod 2 = 0) then     n := n/(2) ; else     n := n * 3 + 1 ; )  ;     count := count + 1 ) )  ;     out.println(count) ) ; 
     sc.close() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str="" ;
    while((str=br.readLine())!=null){
      int ans=Integer.parseInt(str);
      if(ans==0)break ;
      int cnt=0 ;
      while(true){
        if(ans==1)break ;
        if(ans % 2==0){
          ans/=2 ;
        }
        else {
          ans=ans*3+1 ;
        }
        cnt++;
      }
      System.out.println(cnt);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := "" ;
         str := br.readLine() ;
    while ((str) /= null) do (    skip ; (     var ans : int ; ans := (str)->toInteger() ;
     if (ans = 0) then     break else skip ; 
    var cnt : int ; cnt := 0 ;
    while (true) do (     if (ans = 1) then     break else skip ; 
     if (ans mod 2 = 0) then (     ans := ans/(2) ) else (     ans := ans * 3 + 1 ) ;  
     cnt := cnt + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 ) ;     str := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static int[] dp ;
  static int f(int n){
    if(dp[n]!=-1)return dp[n];
    if(n % 2==0)return dp[n]=f(n/2)+1 ;
    else return dp[n]=f(n*3+1)+1 ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    dp=new int[1000001];
    Arrays.fill(dp,-1);
    dp[1]=0 ;
    while(true){
      int x=sc.nextInt();
      if(x==0)break ;
      System.out.println(f(x));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dp : Sequence(int);
  static   operation f( n : int) : int
  pre: true
  post: true
  activity: (     if (dp[n+1] /= -1) then     return dp[n+1] else skip ; 
     if (n mod 2 = 0) then     return dp[n+1] else     return dp[n+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     dp := Integer.subrange(1,1000001)->collect(0) ; 
    dp := dp->collect(-1) ; 
    dp[1+1] := 0 ; 
    while (true) do (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x = 0) then     break else skip ; 
     OclFile["System.out"].println(f(x)) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int n ;
  public static void main(String[] args){
    while(read()){
      slove();
    }
  }
  static boolean read(){
    n=sc.nextInt();
    if(n!=0)return true ;
    return false ;
  }
  static void slove(){
    int i=0 ;
    while(n!=1){
      if(n % 2==0){
        n=n/2 ;
      }
      else {
        n=n*3+1 ;
      }
      i++;
    }
    System.out.println(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (read()) do (     execute slove() ) );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
     if (n /= 0) then     return true else skip ; 
     return false );
  static   operation slove() : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     while (n /= 1) do (     if (n mod 2 = 0) then (     n := n / 2 ) else (     n := n * 3 + 1 ) ;  
     i := i + 1 ) ; 
     OclFile["System.out"].println(i) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  static FastReader sc=null ;
  public static void main(String[] args){
    sc=new FastReader();
    int t=1 ;
    for(int tt=0 ; tt<t ; tt++){
      int w=sc.nextInt(),l=sc.nextInt(),c=sc.nextInt();
      if(c>0 && w+c>=l && l+c>=w)System.out.println("?");
      else {
        if(c==0 && w==l)System.out.println("0");
        else if(w>l)System.out.println("+");
        else System.out.println("-");
      }
    }
  }
  static int[] ruffleSort(int a[]){
    ArrayList<Integer>al=new ArrayList<>();
    for(int i : a)al.add(i);
    Collections.sort(al);
    for(int i=0 ; i<a.length ; i++)a[i]=al.get(i);
    return a ;
  }
  static void print(int a[]){
    for(int e : a){
      System.out.print(e+" ");
    }
    System.out.println();
  }
  static class FastReader {
    StringTokenizer st=new StringTokenizer("");
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String next(){
      while(! st.hasMoreTokens())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());
    }
    int[] readArray(int n){
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute sc : FastReader := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := FastReader.newFastReader() ; 
     var t : int ; t := 1 ;
         var tt : int ; tt := 0 ; while tt < t do ( (     var w : int ; w := sc.nextInt() ;
    var l : int ; l := sc.nextInt() ;
    var c : int ; c := sc.nextInt() ;
     if (c > 0 & w + c >= l & l + c >= w) then     OclFile["System.out"].println("?") ; else (     if (c = 0 & w = l) then     OclFile["System.out"].println("0") ; else     if (w > l) then     OclFile["System.out"].println("+") else     OclFile["System.out"].println("-") ; ;  ) )  ;     tt := tt + 1 ) );
  static   operation ruffleSort( a : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var al : Sequence(int) ; al := Sequence{} ;
     for (i : a) do (     al := al->including(i) ;  ) ; 
    al := al->sort() ; 
        var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := al->at(i+1) ;  ;     i := i + 1 ) ; 
    return a 
 );
  static   operation print( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     for (e : a) do ( (     OclFile["System.out"].print(e + " ") )  ) ; 
     OclFile["System.out"].println() );
  static class FastReader {
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] arg){
    Scanner sc=new Scanner(System.in);
    int up=sc.nextInt(),down=sc.nextInt(),un=sc.nextInt();
    if(up-down>0 && un<up-down)System.out.println("+");
    else if(up-down<0 && un<down-up)System.out.println("-");
    else if(up-down==0 && un==0)System.out.println("0");
    else System.out.println("?");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var up : int ; up := sc.getCurrent()->toInteger() ;
    var down : int ; down := sc.getCurrent()->toInteger() ;
    var un : int ; un := sc.getCurrent()->toInteger() ;
     if (up - down > 0 & un < up - down) then     OclFile["System.out"].println("+") ; else     if (up - down < 0 & un < down - up) then     OclFile["System.out"].println("-") else     if (up - down = 0 & un = 0) then     OclFile["System.out"].println("0") else     OclFile["System.out"].println("?") ; ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] arg){
    Scanner sc=new Scanner(System.in);
    int up=sc.nextInt(),down=sc.nextInt(),un=sc.nextInt();
    if(Math.abs(up-down)>0 && un>=Math.abs(up-down)|| Math.abs(up-down)==0 && un>Math.abs(up-down))System.out.println("?");
    else if(up-down>0 && un<up-down)System.out.println("+");
    else if(up-down<0 && un<down-up)System.out.println("-");
    else if(up-down==0 && un==0)System.out.println("0");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var up : int ; up := sc.getCurrent()->toInteger() ;
    var down : int ; down := sc.getCurrent()->toInteger() ;
    var un : int ; un := sc.getCurrent()->toInteger() ;
     if (if up - down < 0 then -(up - down) else up - down endif > 0 & un >= if up - down < 0 then -(up - down) else up - down endif or if up - down < 0 then -(up - down) else up - down endif = 0 & un > if up - down < 0 then -(up - down) else up - down endif) then     OclFile["System.out"].println("?") ; else     if (up - down > 0 & un < up - down) then     OclFile["System.out"].println("+") else     if (up - down < 0 & un < down - up) then     OclFile["System.out"].println("-") else     if (up - down = 0 & un = 0) then     OclFile["System.out"].println("0") ; else skip ; ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean match_words(String dictionary[],String sentence[],int n,int m){
    Map<String,Integer>mp=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(mp.containsKey(dictionary[i])){
        mp.put(dictionary[i],mp.get(dictionary[i])+1);
      }
      else {
        mp.put(dictionary[i],1);
      }
    }
    for(int i=0 ; i<m ; i++){
      if(mp.containsKey(sentence[i]))mp.put(sentence[i],mp.get(sentence[i])-1);
      else return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    String dictionary[]={
      "find","a","geeks","all","for","on","geeks","answers","inter" };
      int n=dictionary.length ;
      String sentence[]={
        "find","all","answers","on","geeks","for","geeks" };
        int m=sentence.length ;
        if(match_words(dictionary,sentence,n,m))System.out.println("YES");
        else System.out.println("NO");
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation match_words( dictionary : Sequence(String), sentence : Sequence(String), n : int, m : int) : boolean
  pre: true
  post: true
  activity: (     var mp : Map(String,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (mp->keys()->includes(dictionary[i+1])) then (     mp := mp->union(Map{dictionary[i+1] |-> mp->at(dictionary[i+1]) + 1}) ) else (     mp := mp->union(Map{dictionary[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < m do ( (     if (mp->keys()->includes(sentence[i+1])) then     mp := mp->union(Map{sentence[i+1] |-> mp->at(sentence[i+1]) - 1}) ; else     return false )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var dictionary : Sequence(String) ; dictionary := Sequence{"find","a","geeks","all","for","on","geeks","answers","inter"} ;
     var n : int ; n := dictionary->size() ;
    var sentence : Sequence(String) ; sentence := Sequence{"find","all","answers","on","geeks","for","geeks"} ;
    var m : int ; m := sentence->size() ;
    if (match_words(dictionary, sentence, n, m)) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  private class LargerNumberComparator implements Comparator<String>{
    @ Override public int compare(String a,String b){
      String order1=a+b ;
      String order2=b+a ;
      return order2.compareTo(order1);
    }
  }
  public String largestNumber(int[] nums){
    String[] asStrs=new String[nums.length];
    for(int i=0 ; i<nums.length ; i++){
      asStrs[i]=String.valueOf(nums[i]);
    }
    Arrays.sort(asStrs,new LargerNumberComparator());
    if(asStrs[0] .equals("0")){
      return "0" ;
    }
    String largestNumberStr=new String();
    for(String numAsStr : asStrs){
      largestNumberStr+=numAsStr ;
    }
    return largestNumberStr ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
 class LargerNumberComparator implements Function(<String>,(<String>,boolean)) {
      operation compare( a : String, b : String) : int
  pre: true
  post: true
  activity: (     var order1 : String ; order1 := a + b ;
     var order2 : String ; order2 := b + a ;
     return order2->compareTo(order1) );
}
   operation largestNumber( nums : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var asStrs : Sequence(String) ; asStrs := Integer.subrange(1,nums->size())->collect(null) ;
         var i : int ; i := 0 ; while i < nums->size() do ( (     asStrs[i+1] := ((nums[i+1]) + "") )  ;     i := i + 1 ) ; 
    asStrs := OclComparator.sortWith(asStrs, LargerNumberComparator.newLargerNumberComparator()) ; 
    if (asStrs[0+1] = "0") then (     return "0" ) else skip ; 
    var largestNumberStr : String ; largestNumberStr := StringLib.newString() ;
    for (numAsStr : asStrs) do ( (     largestNumberStr := largestNumberStr+(numAsStr) )  ) ; 
    return largestNumberStr 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int R=3 ;
  static final int C=3 ;
  static final int MAX_K=100 ;
  static int[][][] dp=new int[R][C][MAX_K];
  static int pathCountDPRecDP(int[][] mat,int m,int n,int k){
    if(m<0 || n<0)return 0 ;
    if(m==0 && n==0)return(k==mat[m][n] ? 1 : 0);
    if(dp[m][n][k]!=-1)return dp[m][n][k];
    dp[m][n][k]=pathCountDPRecDP(mat,m-1,n,k-mat[m][n])+pathCountDPRecDP(mat,m,n-1,k-mat[m][n]);
    return dp[m][n][k];
  }
  static int pathCountDP(int[][] mat,int k){
    for(int i=0 ; i<R ; i++)for(int j=0 ; j<C ; j++)for(int l=0 ; l<MAX_K ; l++)dp[i][j][l]=-1 ;
    return pathCountDPRecDP(mat,R-1,C-1,k);
  }
  public static void main(String[] args){
    int k=12 ;
    int[][] mat=new int[][] {
      new int[] {
        1,2,3 },new int[] {
          4,6,5 },new int[] {
            3,2,1 }
          };
          System.out.println(pathCountDP(mat,k));
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute R : int := 3;
  static    attribute C : int := 3;
  static    attribute MAX_K : int := 100;
  static   attribute dp : Sequence(Sequence(Sequence(int))) := Integer.subrange(1,R)->collect(Integer.subrange(1,C)->collect(Integer.subrange(1,MAX_K)->collect(0)));
  static   operation pathCountDPRecDP( mat : Sequence(Sequence(int)), m : int, n : int, k : int) : int
  pre: true
  post: true
  activity: (     if (m < 0 or n < 0) then     return 0 else skip ; 
     if (m = 0 & n = 0) then     return (if k = mat[m+1][n+1] then 1 else 0 endif) else skip ; 
    if (dp[m+1][n+1][k+1] /= -1) then     return dp[m+1][n+1][k+1] else skip ; 
    dp[m+1][n+1][k+1] := pathCountDPRecDP(mat, m - 1, n, k - mat[m+1][n+1]) + pathCountDPRecDP(mat, m, n - 1, k - mat[m+1][n+1]) ; 
    return dp[m+1][n+1][k+1] 
 );
  static   operation pathCountDP( mat : Sequence(Sequence(int)), k : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < R do (         var j : int ; j := 0 ; while j < C do (         var l : int ; l := 0 ; while l < MAX_K do (     dp[i+1][j+1][l+1] := -1 ;  ;     l := l + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return pathCountDPRecDP(mat, R - 1, C - 1, k) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 12 ;
     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,2,3},Sequence{4,6,5},Sequence{3,2,1}} ;
     OclFile["System.out"].println(pathCountDP(mat, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    String previous=scan.next();
    String next ;
    Set<String>used_words=new HashSet<String>();
    used_words.add(previous);
    while(N>1){
      next=scan.next();
      if(!((previous.charAt(previous.length()-1)==next.charAt(0))&& used_words.add(next))){
        System.out.println("No");
        scan.close();
        return ;
      }
      previous=next ;
      N--;
    }
    scan.close();
    System.out.println("Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var previous : String ; previous := scan.getCurrent() ;
    var next : String ;
    var used_words : Set(String) ; used_words := Set{} ;
    used_words := used_words->including(previous) ; 
    while (N > 1) do (     next := scan.getCurrent() ; 
     if (not(((previous->at(previous->size() - 1+1) = next->at(0+1)) & used_words->excludes(next)))) then (     OclFile["System.out"].println("No") ; 
     skip ; 
     return ) else skip ; 
     previous := next ; 
     N := N - 1 ) ; 
    skip ; 
    OclFile["System.out"].println("Yes") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maximumXor(int arr[],int n){
    Stack<Integer>sForward=new Stack<Integer>(),sBackward=new Stack<Integer>();
    int ans=-1 ;
    for(int i=0 ; i<n ; i++){
      while(! sForward.isEmpty()&& arr[i]<arr[sForward.peek()]){
        ans=Math.max(ans,arr[i] ^ arr[sForward.peek()]);
        sForward.pop();
      }
      sForward.add(i);
      while(! sBackward.isEmpty()&& arr[n-i-1]<arr[sBackward.peek()]){
        ans=Math.max(ans,arr[n-i-1] ^ arr[sBackward.peek()]);
        sBackward.pop();
      }
      sBackward.add(n-i-1);
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      8,1,2 };
      int n=arr.length ;
      System.out.print(maximumXor(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maximumXor( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sForward : Sequence(int) ; sForward := Sequence{} ;
    var sBackward : Sequence(int) ; sBackward := Sequence{} ;
     var ans : int ; ans := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     while (not(sForward->isEmpty()) & arr[i+1] < arr[sForward->min()+1]) do (     ans := Set{ans, arr[i+1] xor arr[sForward->min()+1]}->max() ; 
     sForward := sForward->front() ) ; 
     sForward := sForward->including(i) ; 
     while (not(sBackward->isEmpty()) & arr[n - i - 1+1] < arr[sBackward->min()+1]) do (     ans := Set{ans, arr[n - i - 1+1] xor arr[sBackward->min()+1]}->max() ; 
     sBackward := sBackward->front() ) ; 
     sBackward->excludes(n - i - 1) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,1,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(maximumXor(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  static double PI=3.14159265 ;
  public static double area_cicumscribed(double c){
    return(c*c*(PI/4));
  }
  public static void main(String[] args){
    double c=8.0 ;
    System.out.println(area_cicumscribed(c));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute PI : double := 3.14159265;
  static   operation area_cicumscribed( c : double) : double
  pre: true
  post: true
  activity: (     return (c * c * (PI / 4)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var c : double ; c := 8.0 ;
     OclFile["System.out"].println(area_cicumscribed(c)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isValidSeq(int[] a,int n){
    int nodes=n+2 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]<1 || a[i]>nodes)return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    int a[]={
      4,1,3,4 };
      int n=a.length ;
      if(isValidSeq(a,n))System.out.println("Valid");
      else System.out.print("Invalid");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isValidSeq( a : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var nodes : int ; nodes := n + 2 ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] < 1 or a[i+1] > nodes) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{4,1,3,4} ;
     var n : int ; n := a->size() ;
     if (isValidSeq(a, n)) then     OclFile["System.out"].println("Valid") ; else     OclFile["System.out"].print("Invalid") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
public class GFG {
  static double INF=1e9 ;
  static int MAX=50 ;
  static void minMaxValues(int[] arr,int n,int m){
    int sum=0 ;
    for(int i=0 ; i<(n+m); i++){
      sum+=arr[i];
      arr[i]+=50 ;
    }
    boolean dp[][]=new boolean[MAX+1][MAX*MAX+1];
    dp[0][0]=true ;
    for(int i=0 ; i<(n+m); i++){
      for(int k=Math.min(n,i+1); k>=1 ; k--){
        for(int j=0 ; j<MAX*MAX+1 ; j++){
          if(dp[k-1][j])dp[k][j+arr[i] ]=true ;
        }
      }
    }
    double max_value=-1*INF,min_value=INF ;
    for(int i=0 ; i<MAX*MAX+1 ; i++){
      if(dp[n][i]){
        int temp=i-50*n ;
        max_value=Math.max(max_value,temp*(sum-temp));
        min_value=Math.min(min_value,temp*(sum-temp));
      }
    }
    System.out.print("Maximum Value: "+(int)max_value+"\n"+"Minimum Value: "+(int)min_value+"\n");
  }
  public static void main(String args[]){
    int n=2,m=2 ;
    int[] arr={
      1,2,3,4 };
      minMaxValues(arr,n,m);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute INF : double := 1e9;
  static   attribute MAX : int := 50;
  static   operation minMaxValues( arr : Sequence(int), n : int, m : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < (n + m) do ( (     sum := sum+(arr[i+1]) ; 
     arr[i+1] := arr[i+1]+(50) )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(boolean)) ; dp := Integer.subrange(1,MAX + 1)->collect(Integer.subrange(1,MAX * MAX + 1)->collect(false)) ;
    dp[0+1][0+1] := true ; 
        var i : int ; i := 0 ; while i < (n + m) do ( (         var k : int ; k := Set{n, i + 1}->min() ; while k >= 1 do ( (         var j : int ; j := 0 ; while j < MAX * MAX + 1 do ( (     if (dp[k - 1+1][j+1]) then     dp[k+1][j + arr[i+1]+1] := true ; else skip )  ;     j := j + 1 ) )  ;     k := k - 1 ) )  ;     i := i + 1 ) ; 
    var max_value : double ; max_value := -1 * INF ;
    var min_value : double ; min_value := INF ;
        var i : int ; i := 0 ; while i < MAX * MAX + 1 do ( (     if (dp[n+1][i+1]) then (     var temp : int ; temp := i - 50 * n ;
     max_value := Set{max_value, temp * (sum - temp)}->max() ; 
     min_value := Set{min_value, temp * (sum - temp)}->min() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("Maximum Value: " + max_value->oclAsType(int) + "\n" + "Minimum Value: " + min_value->oclAsType(int) + "\n") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
    var m : int ; m := 2 ;
     var arr : Sequence(int) ; arr := Sequence{1,2,3,4} ;
     execute minMaxValues(arr, n, m) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Stack ;
class GFG {
  static void reverse(String k){
    Stack<String>s=new Stack<>();
    String[] token=k.split(" ");
    for(int i=0 ; i<token.length ; i++){
      s.push(token[i]);
    }
    while(! s.empty()){
      System.out.print(s.peek()+" ");
      s.pop();
    }
  }
  public static void main(String[] args){
    String k="geeks for geeks" ;
    reverse(k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation reverse( k : String) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := Sequence{} ;
     var token : Sequence(String) ; token := k->split(" ") ;
         var i : int ; i := 0 ; while i < token->size() do ( (     s := s->append(token[i+1]) )  ;     i := i + 1 ) ; 
     while (not(s->isEmpty())) do (     OclFile["System.out"].print(s->min() + " ") ; 
     s := s->front() ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : String ; k := "geeks for geeks" ;
     execute reverse(k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int divisorSum(int n){
    int sum=0 ;
    for(int i=1 ; i<=n ; ++i){
      for(int j=1 ; j*j<=i ; ++j){
        if(i % j==0){
          if(i/j==j)sum+=j ;
          else sum+=j+i/j ;
        }
      }
    }
    return sum ;
  }
  public static void main(String args[]){
    int n=4 ;
    System.out.println(divisorSum(n));
    n=5 ;
    System.out.println(divisorSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation divisorSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j * j <= i do ( (     if (i mod j = 0) then (     if (i / j = j) then     sum := sum+(j) ; else     sum := sum+(j + i / j) ; ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(divisorSum(n)) ; 
     n := 5 ; 
     OclFile["System.out"].println(divisorSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static final int MAX=100 ;
  static boolean allones(String s,int n){
    int co=0 ;
    for(int i=0 ; i<s.length(); i++)if(s.charAt(i)=='1')co+=1 ;
    return(co==n);
  }
  static int findlength(int arr[],String s,int n,int ind,int st,int dp[][]){
    if(ind>=n)return 0 ;
    if(dp[ind][st]!=-1)return dp[ind][st];
    if(st==0)return dp[ind][st]=Math.max(arr[ind]+findlength(arr,s,n,ind+1,1,dp),findlength(arr,s,n,ind+1,0,dp));
    else return dp[ind][st]=Math.max(arr[ind]+findlength(arr,s,n,ind+1,1,dp),0);
  }
  static int maxLen(String s,int n){
    if(allones(s,n))return-1 ;
    int arr[]=new int[MAX];
    for(int i=0 ; i<n ; i++)arr[i]=(s.charAt(i)=='0' ? 1 :-1);
    int dp[][]=new int[MAX][3];
    for(int[] row : dp)Arrays.fill(row,-1);
    return findlength(arr,s,n,0,0,dp);
  }
  public static void main(String[] args){
    String s="11000010001" ;
    int n=11 ;
    System.out.println(maxLen(s,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX : int := 100;
  static   operation allones( s : String, n : int) : boolean
  pre: true
  post: true
  activity: (     var co : int ; co := 0 ;
         var i : int ; i := 0 ; while i < s->size() do (     if (s->at(i+1) = '1') then     co := co+(1) ; else skip ;  ;     i := i + 1 ) ; 
     return (co = n) );
  static   operation findlength( arr : Sequence(int), s : String, n : int, ind : int, st : int, dp : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     if (ind >= n) then     return 0 else skip ; 
     if (dp[ind+1][st+1] /= -1) then     return dp[ind+1][st+1] else skip ; 
     if (st = 0) then     return dp[ind+1][st+1] else     return dp[ind+1][st+1] );
  static   operation maxLen( s : String, n : int) : int
  pre: true
  post: true
  activity: (     if (allones(s, n)) then     return -1 else skip ; 
     var arr : Sequence(int) ; arr := Integer.subrange(1,MAX)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := (if s->at(i+1) = '0' then 1 else -1 endif) ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,MAX)->collect(Integer.subrange(1,3)->collect(0)) ;
    for (row : dp) do (     row := row->collect(-1) ;  ) ; 
    return findlength(arr, s, n, 0, 0, dp) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "11000010001" ;
     var n : int ; n := 11 ;
     OclFile["System.out"].println(maxLen(s, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static class Pair implements Comparable<Pair>{
    int first,second ;
    Pair(int f,int s){
      first=f ;
      second=s ;
    }
    @ Override public int compareTo(Pair o){
      if(this.second>o.second)return 1 ;
      else if(this.second==o.second)return 0 ;
      return-1 ;
    }
  }
  static int prime[]=new int[100002];
  static void SieveOfEratosthenes(){
    Arrays.fill(prime,0);
    prime[0]=0 ;
    prime[1]=0 ;
    for(int p=2 ; p*p<=100001 ; p++){
      if(prime[p]==0){
        prime[p]++;
        for(int i=p*p ; i<=100001 ; i+=p)prime[i]++;
      }
    }
  }
  static void sortArr(int arr[],int n){
    Pair v[]=new Pair[n];
    for(int i=0 ; i<n ; i++){
      v[i]=new Pair(arr[i],prime[arr[i] ]);
    }
    Arrays.sort(v);
    for(int i=0 ; i<n ; i++)System.out.print(v[i] .first+" ");
    System.out.println();
  }
  public static void main(String args[]){
    SieveOfEratosthenes();
    int arr[]={
      30,2,1024,210,3,6 };
      int n=arr.length ;
      sortArr(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Pair implements Comparable<Map> {
   attribute first : int;
   static operation newPair( f : int, s : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(f, s);
    return self );
  operation initialise( f : int, s : int) : void
  pre: true  post: true
  activity: (     first := f ; 
     second := s );
      operation compareTo( o : Map) : int
  pre: true
  post: true
  activity: (     if (self->at("second") > o->at("second")) then     return 1 else     if (self->at("second") = o->at("second")) then     return 0 else skip ; ;  
     return -1 );
}
  static   attribute prime : int := Integer.subrange(1,100002)->collect(0);
  static   operation SieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (     prime := prime->collect(0) ; 
     prime[0+1] := 0 ; 
     prime[1+1] := 0 ; 
         var p : int ; p := 2 ; while p * p <= 100001 do ( (     if (prime[p+1] = 0) then (     prime[p+1] := prime[p+1] + 1 ; 
         var i : int ; i := p * p ; while i <= 100001 do (     prime[i+1] := prime[i+1] + 1 ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation sortArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var v : Sequence(Map) ; v := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do ( (     v[i+1] := Map(arr[i+1], prime[arr[i+1]+1]) )  ;     i := i + 1 ) ; 
    v := v->sort() ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(v[i+1]->at("first") + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes() ; 
     var arr : Sequence(int) ; arr := Sequence{30,2,1024,210,3,6} ;
     var n : int ; n := arr->size() ;
     execute sortArr(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findSum(int n){
    int ans=0 ;
    for(int i=1 ; i<=n ; i++)for(int j=1 ; j<=n ; j++)ans+=(i/j);
    return ans ;
  }
  public static void main(String[] args){
    int N=2 ;
    System.out.println(findSum(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSum( n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i <= n do (         var j : int ; j := 1 ; while j <= n do (     ans := ans+((i / j)) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 2 ;
     OclFile["System.out"].println(findSum(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int max_element(int arr[]){
    int max_e=Integer.MIN_VALUE ;
    for(int i=0 ; i<arr.length ; i++){
      max_e=Math.max(max_e,arr[i]);
    }
    return max_e ;
  }
  static int nonPrimeSum(int arr[],int n){
    int max_val=max_element(arr);
    boolean prime[]=new boolean[max_val+1];
    for(int i=0 ; i<prime.length ; i++)prime[i]=true ;
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=max_val ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=max_val ; i+=p)prime[i]=false ;
      }
    }
    int sum=0 ;
    for(int i=0 ; i<n ; i++)if(! prime[arr[i] ])sum+=arr[i];
    return sum ;
  }
  public static void main(String args[]){
    int arr[]={
      1,3,7,4,9,8 };
      int n=arr.length ;
      System.out.println(nonPrimeSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation max_element( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var max_e : int ; max_e := -2147483648 ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     max_e := Set{max_e, arr[i+1]}->max() )  ;     i := i + 1 ) ; 
     return max_e );
  static   operation nonPrimeSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max_val : int ; max_val := max_element(arr) ;
     var prime : Sequence(boolean) ; prime := Integer.subrange(1,max_val + 1)->collect(false) ;
        var i : int ; i := 0 ; while i < prime->size() do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
    prime[0+1] := false ; 
    prime[1+1] := false ; 
        var p : int ; p := 2 ; while p * p <= max_val do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= max_val do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (not(prime[arr[i+1]+1])) then     sum := sum+(arr[i+1]) ; else skip ;  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,7,4,9,8} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(nonPrimeSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Interchange {
  static void interchangeFirstLast(int m[][]){
    int rows=m.length ;
    for(int i=0 ; i<m[0] .length ; i++){
      int t=m[0][i];
      m[0][i]=m[rows-1][i];
      m[rows-1][i]=t ;
    }
  }
  public static void main(String args[])throws IOException {
    int m[][]={
      {
        8,9,7,6 },{
          4,7,6,5 },{
            3,2,1,8 },{
              9,9,7,7 }
            };
            interchangeFirstLast(m);
            for(int i=0 ; i<m.length ; i++){
              for(int j=0 ; j<m[0] .length ; j++)System.out.print(m[i][j]+" ");
              System.out.println();
            }
          }
        }

------------------------------------------------------------
OCL File:
---------
 class Interchange {
  static   operation interchangeFirstLast( m : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var rows : int ; rows := m->size() ;
         var i : int ; i := 0 ; while i < m[0+1]->size() do ( (     var t : int ; t := m[0+1][i+1] ;
     m[0+1][i+1] := m[rows - 1+1][i+1] ; 
     m[rows - 1+1][i+1] := t )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Sequence(Sequence(int)) ; m := Sequence{Sequence{8,9,7,6},Sequence{4,7,6,5},Sequence{3,2,1,8},Sequence{9,9,7,7}} ;
     execute interchangeFirstLast(m) ; 
         var i : int ; i := 0 ; while i < m->size() do ( (         var j : int ; j := 0 ; while j < m[0+1]->size() do (     OclFile["System.out"].print(m[i+1][j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static String input ;
  public static void main(String[] args){
    while(read()){
    }
  }
  static boolean read(){
    if(sc.hasNextInt())return false ;
    input=sc.next();
    solveFirstGame();
    for(int i=1 ; i<3 ; i++){
      input=sc.next();
      solveFirstGame();
    }
    return true ;
  }
  static void solveFirstGame(){
    int A=0,B=0 ;
    for(int i=1 ; i<input.length(); i++){
      if(input.charAt(i)=='A')A++;
      if(input.charAt(i)=='B')B++;
    }
    if(A>B){
      A++;
    }
    else {
      B++;
    }
    System.out.println(A+" "+B);
  }
  static void solve(){
    int A=0,B=0 ;
    System.out.println(A+" "+B);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute input : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (read()) do skip );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     if (sc.hasNextInt()) then     return false else skip ; 
     input := sc.getCurrent() ; 
    execute solveFirstGame() ; 
        var i : int ; i := 1 ; while i < 3 do ( (     input := sc.getCurrent() ; 
     execute solveFirstGame() )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation solveFirstGame() : void
  pre: true
  post: true
  activity: (     var A : int ; A := 0 ;
    var B : int ; B := 0 ;
         var i : int ; i := 1 ; while i < input->size() do ( (     if (input->at(i+1) = 'A') then     A := A + 1 ; else skip ; 
     if (input->at(i+1) = 'B') then     B := B + 1 ; else skip )  ;     i := i + 1 ) ; 
     if (A > B) then (     A := A + 1 ) else (     B := B + 1 ) ;  
     OclFile["System.out"].println(A + " " + B) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var A : int ; A := 0 ;
    var B : int ; B := 0 ;
     OclFile["System.out"].println(A + " " + B) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean Move(int a,int x,int b){
    if((((b-a)% x==0)||((b-a-1)% x==0)&& a+1!=b)&& b>=a)return true ;
    return false ;
  }
  public static void main(String[] args){
    int a=3,x=2,b=7 ;
    if(Move(a,x,b))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Move( a : int, x : int, b : int) : boolean
  pre: true
  post: true
  activity: (     if ((((b - a) mod x = 0) or ((b - a - 1) mod x = 0) & a + 1 /= b) & b >= a) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var x : int ; x := 2 ;
    var b : int ; b := 7 ;
     if (Move(a, x, b)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static long startTime=System.currentTimeMillis();
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    long A=sc.nextLong();
    long B=sc.nextLong();
    for(long i=B+1 ; ; i++){
      if((i & 0xFF)==0 && System.currentTimeMillis()-startTime>3500)break ;
      long ca=i/A+i % A ;
      long remb=i % B ;
      long cb=i/B+remb/A+remb % A ;
      if(ca<cb){
        System.out.println(i);
        return ;
      }
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute startTime : long := OclDate.getSystemTime();
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : long ; A := sc.getCurrent()->toLong() ;
     var B : long ; B := sc.getCurrent()->toLong() ;
         var i : long ; i := B + 1 ; while true do ( (     if ((MathLib.bitwiseAnd(i,0xFF)) = 0 & OclDate.getSystemTime() - startTime > 3500) then     break else skip ; 
     var ca : long ; ca := i / A + i mod A ;
    var remb : long ; remb := i mod B ;
    var cb : long ; cb := i / B + remb / A + remb mod A ;
    if (ca < cb) then (     OclFile["System.out"].println(i) ; 
     return ) else skip ; 
 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(-1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public boolean isOneBitCharacter(int[] bits){
    int pos=0 ;
    while(pos<bits.length-1){
      pos+=bits[pos]+1 ;
    }
    return pos==bits.length-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation isOneBitCharacter( bits : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var pos : int ; pos := 0 ;
     while (pos < bits->size() - 1) do (     pos := pos+(bits[pos+1] + 1) ) ; 
     return pos = bits->size() - 1 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static int solve(int low,int high,int T){
    while(low<=high){
      int mid=(low+high)/2 ;
      if((mid*(mid+1))==T)return mid ;
      if(mid>0 &&(mid*(mid+1))>T &&(mid*(mid-1))<=T)return mid-1 ;
      if((mid*(mid+1))>T)high=mid-1 ;
      else low=mid+1 ;
    }
    return-1 ;
  }
  public static void main(String argc[]){
    int T=15 ;
    int ans=solve(1,T,2*T);
    if(ans!=-1)ans--;
    System.out.println("Number of stair steps="+ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation solve( low : int, high : int, T : int) : int
  pre: true
  post: true
  activity: (     while (low <= high) do (     var mid : int ; mid := (low + high) / 2 ;
     if ((mid * (mid + 1)) = T) then     return mid else skip ; 
     if (mid > 0 & (mid * (mid + 1)) > T & (mid * (mid - 1)) <= T) then     return mid - 1 else skip ; 
     if ((mid * (mid + 1)) > T) then     high := mid - 1 ; else     low := mid + 1 ; ) ; 
     return -1 );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := 15 ;
     var ans : int ; ans := solve(1, T, 2 * T) ;
     if (ans /= -1) then     ans := ans - 1 ; else skip ; 
     OclFile["System.out"].println("Number of stair steps=" + ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MaximumHeight(int[] a,int n){
    int result=1 ;
    for(int i=1 ; i<=n ; ++i){
      int y=(i*(i+1))/2 ;
      if(y<n)result=i ;
      else break ;
    }
    return result ;
  }
  public static void main(String[] args){
    int[] arr={
      40,100,20,30 };
      int n=arr.length ;
      System.out.println(MaximumHeight(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MaximumHeight( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (     var y : int ; y := (i * (i + 1)) / 2 ;
     if (y < n) then     result := i ; else     break )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{40,100,20,30} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(MaximumHeight(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int D=scanner.nextInt();
    int A=scanner.nextInt();
    Monster[] monsters=new Monster[N];
    for(int i=0 ; i<N ; i++){
      int x=scanner.nextInt();
      int h=scanner.nextInt();
      monsters[i]=new Monster(x,(h-1)/A+1);
    }
    Arrays.sort(monsters,Comparator.comparingLong(m->m.x));
    long cum=0 ;
    int[] delta=new int[N];
    int j=0 ;
    for(int i=0 ; i<N ; i++){
      while(j<i && monsters[j] .x+2*D<monsters[i] .x){
        cum-=delta[j];
        j++;
      }
      if(monsters[i] .h>cum)delta[i]=monsters[i] .h-(int)cum ;
      cum+=delta[i];
    }
    long res=0 ;
    for(int i=0 ; i<N ; i++)res+=delta[i];
    System.out.println(res);
  }
  private static class Monster {
    private final long x ;
    private final int h ;
    private Monster(int x,int h){
      this.x=x ;
      this.h=h ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var D : int ; D := scanner.getCurrent()->toInteger() ;
    var A : int ; A := scanner.getCurrent()->toInteger() ;
    var monsters : Sequence(Monster) ; monsters := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     var x : int ; x := scanner.getCurrent()->toInteger() ;
     var h : int ; h := scanner.getCurrent()->toInteger() ;
     monsters[i+1] := Monster.newMonster(x, (h - 1) / A + 1) )  ;     i := i + 1 ) ; 
    monsters := OclComparator.sortWith(monsters, Comparator.comparingLong(lambda m : OclAny in m.x)) ; 
    var cum : long ; cum := 0 ;
    var delta : Sequence(int) ; delta := Integer.subrange(1,N)->collect(0) ;
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     while (j < i & monsters[j+1].x + 2 * D < monsters[i+1].x) do (     cum := cum-(delta[j+1]) ; 
     j := j + 1 ) ; 
     if (monsters[i+1].h > cum) then     delta[i+1] := monsters[i+1].h - cum->oclAsType(int) ; else skip ; 
     cum := cum+(delta[i+1]) )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < N do (     res := res+(delta[i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static class Monster {
   attribute x : long;
   attribute h : int;
   static operation newMonster( x : int, h : int) : Monster
  pre: true
  post: true
  activity:
  ( var self : Monster ;
    self := createMonster();
    self.initialise(x, h);
    return self );
  operation initialise( x : int, h : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.h := h );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
import java.io.*;
class Monster implements Comparable<Monster>{
  final long x,h ;
  Monster(long x,long h){
    this.x=x ;
    this.h=h ;
  }
  public int compareTo(Monster m){
    return Long.compare(this.x,m.x);
  }
}
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] in1=br.readLine().split(" ");
    long N=Long.parseLong(in1[0]);
    long D=Long.parseLong(in1[1]);
    long A=Long.parseLong(in1[2]);
    List<Monster>monsters=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      in1=br.readLine().split(" ");
      long X=Long.parseLong(in1[0]);
      long H=Long.parseLong(in1[1]);
      monsters.add(new Monster(X,H));
    }
    br.close();
    Collections.sort(monsters);
    Queue<long[]>position=new ArrayDeque<>();
    long tmp_attack_count=0L ;
    long total_attack_count=0L ;
    for(int n=0 ; n<N ; n++){
      long now_x=monsters.get(n).x ;
      long now_h=monsters.get(n).h ;
      while(! position.isEmpty()&& position.peek()[0]+2*D<now_x){
        tmp_attack_count-=position.poll()[1];
      }
      long attack_count=(now_h-tmp_attack_count*A+A-1L)/A ;
      if(attack_count<=0)continue ;
      total_attack_count+=attack_count ;
      tmp_attack_count+=attack_count ;
      position.add(new long[] {
        now_x,attack_count }
);
      }
      System.out.println(total_attack_count);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Monster implements Comparable<Monster> {
   attribute x : long;
   static operation newMonster( x : long, h : long) : Monster
  pre: true
  post: true
  activity:
  ( var self : Monster ;
    self := createMonster();
    self.initialise(x, h);
    return self );
  operation initialise( x : long, h : long) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.h := h );
   operation compareTo( m : Monster) : int
  pre: true
  post: true
  activity: (     return compare(self.x, m.x) );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var in1 : Sequence(String) ; in1 := br.readLine()->split(" ") ;
    var N : long ; N := (in1[0+1])->toLong() ;
    var D : long ; D := (in1[1+1])->toLong() ;
    var A : long ; A := (in1[2+1])->toLong() ;
    var monsters : Sequence(Monster) ; monsters := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     in1 := br.readLine()->split(" ") ; 
     var X : long ; X := (in1[0+1])->toLong() ;
     var H : long ; H := (in1[1+1])->toLong() ;
     monsters := monsters->including(Monster.newMonster(X, H)) )  ;     i := i + 1 ) ; 
    skip ; 
    monsters := monsters->sort() ; 
    var position : Sequence(Sequence(long)) ; position := ArrayDeque<OclAny>.newArrayDeque() ;
    var tmp_attack_count : long ; tmp_attack_count := 0L ;
    var total_attack_count : long ; total_attack_count := 0L ;
        var n : int ; n := 0 ; while n < N do ( (     var now_x : long ; now_x := monsters->at(n+1).x ;
     var now_h : long ; now_h := monsters->at(n+1).h ;
    while (not(position->isEmpty()) & position->min()[0+1] + 2 * D < now_x) do (     tmp_attack_count := tmp_attack_count-(position->min()[1+1]) ) ; 
    var attack_count : long ; attack_count := (now_h - tmp_attack_count * A + A - 1L) / A ;
    if (attack_count <= 0) then     continue else skip ; 
    total_attack_count := total_attack_count+(attack_count) ; 
    tmp_attack_count := tmp_attack_count+(attack_count) ; 
    position := position->including(Sequence{now_x,attack_count}) ; 
 )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(total_attack_count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Stack ;
import javax.swing.tree.TreeNode ;
class Solution {
  public int sumOfLeftLeaves(TreeNode root){
    int res=0 ;
    Stack<TreeNode>stack=new Stack<>();
    stack.push(root);
    while(! stack.isEmpty()){
      TreeNode node=stack.pop();
      if(node!=null){
        if(node.left!=null && node.left.left==null && node.left.right==null)res+=node.left.val ;
        stack.push(node.right);
        stack.push(node.left);
      }
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
   operation sumOfLeftLeaves( root : TreeNode) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     var stack : Sequence(TreeNode) ; stack := Sequence{} ;
    stack := stack->append(root) ; 
    while (not(stack->isEmpty())) do (     var node : TreeNode ; node := stack->last() ;
     if (node /= null) then (     if (node.left /= null & node.left.left = null & node.left.right = null) then     res := res+(node.left.val) ; else skip ; 
     stack := stack->append(node.right) ; 
     stack := stack->append(node.left) ) else skip ) ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CustomisingTheTrack {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int numTestCases=in.nextInt();
    while(numTestCases-->0){
      int numSubTrack=in.nextInt();
      long sum=0 ;
      for(int i=0 ; i<numSubTrack ; i++){
        int temp=in.nextInt();
        sum+=temp ;
      }
      sum %=numSubTrack ;
      long num=numSubTrack-sum ;
      out.append(num*sum+"\n");
    }
    out.flush();
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new FileReader("sub.in"));
      }
      catch(FileNotFoundException ex){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException ex){
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException ex){
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CustomisingTheTrack {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var numTestCases : int ; numTestCases := in.nextInt() ;
        while (numTestCases > 0) do (        numTestCases := numTestCases - 1 ;     skip ; (     var numSubTrack : int ; numSubTrack := in.nextInt() ;
     var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < numSubTrack do ( (     var temp : int ; temp := in.nextInt() ;
     sum := sum+(temp) )  ;     i := i + 1 ) ; 
    sum := sum mod numSubTrack ; 
    var num : long ; num := numSubTrack - sum ;
    skip ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("sub.in"))) )   catch (ex : FileNotFoundException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (ex : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (ex : IOException) do skip
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    long t=sc.nextLong();
    while(t-->0){
      int n=sc.nextInt();
      List<Long>list=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        list.add(sc.nextLong());
      }
      long sum=0 ;
      for(int i=0 ; i<n ; i++){
        sum=sum+list.get(i);
      }
      long a=sum % n ;
      if(a==0)System.out.println(0);
      else System.out.println((n-a)*a);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : long ; t := sc.getCurrent()->toLong() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var list : Sequence(long) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(sc.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum + list->at(i+1) )  ;     i := i + 1 ) ; 
    var a : long ; a := sum mod n ;
    if (a = 0) then     OclFile["System.out"].println(0) else     OclFile["System.out"].println((n - a) * a) ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void decToHexa(int n){
    char[] hexaDeciNum=new char[100];
    int i=0 ;
    while(n!=0){
      int temp=0 ;
      temp=n % 16 ;
      if(temp<10){
        hexaDeciNum[i]=(char)(temp+48);
        i++;
      }
      else {
        hexaDeciNum[i]=(char)(temp+55);
        i++;
      }
      n=n/16 ;
    }
    for(int j=i-1 ; j>=0 ; j--)System.out.print(hexaDeciNum[j]);
  }
  public static void main(String[] args){
    int n=2545 ;
    decToHexa(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation decToHexa( n : int) : void
  pre: true
  post: true
  activity: (     var hexaDeciNum : Sequence(String) ; hexaDeciNum := Integer.subrange(1,100)->collect(0) ;
     var i : int ; i := 0 ;
     while (n /= 0) do (     var temp : int ; temp := 0 ;
     temp := n mod 16 ; 
     if (temp < 10) then (     hexaDeciNum[i+1] := (temp + 48)->oclAsType(String) ; 
     i := i + 1 ) else (     hexaDeciNum[i+1] := (temp + 55)->oclAsType(String) ; 
     i := i + 1 ) ;  
     n := n / 16 ) ; 
         var j : int ; j := i - 1 ; while j >= 0 do (     OclFile["System.out"].print(hexaDeciNum[j+1]) ;  ;     j := j - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2545 ;
     execute decToHexa(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public final class Test {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      long[] arr=new long[n];
      long sum=0 ;
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextLong();
        sum+=arr[i];
      }
      long k=sum % n ;
      System.out.println(k*(n-k));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toLong() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    var k : long ; k := sum mod n ;
    OclFile["System.out"].println(k * (n - k)) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int Race(int B,int C){
    int result=0 ;
    result=((C*100)/B);
    return 100-result ;
  }
  public static void main(String[] args){
    int B=10 ;
    int C=28 ;
    B=100-B ;
    C=100-C ;
    System.out.println(Race(B,C)+" meters");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Race( B : int, C : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     result := ((C * 100) / B) ; 
     return 100 - result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var B : int ; B := 10 ;
     var C : int ; C := 28 ;
    B := 100 - B ; 
    C := 100 - C ; 
    OclFile["System.out"].println(Race(B, C) + " meters") ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String even_or_odd(String N){
    int len=N.length();
    if(N.charAt(len-1)=='0' || N.charAt(len-1)=='2' || N.charAt(len-1)=='4' || N.charAt(len-1)=='6' || N.charAt(len-1)=='8' || N.charAt(len-1)=='A' || N.charAt(len-1)=='C' || N.charAt(len-1)=='E')return("Even");
    else return("Odd");
  }
  public static void main(String[] args){
    String N="AB3454D" ;
    System.out.print(even_or_odd(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation even_or_odd( N : String) : String
  pre: true
  post: true
  activity: (     var len : int ; len := N->size() ;
     if (N->at(len - 1+1) = '0' or N->at(len - 1+1) = '2' or N->at(len - 1+1) = '4' or N->at(len - 1+1) = '6' or N->at(len - 1+1) = '8' or N->at(len - 1+1) = 'A' or N->at(len - 1+1) = 'C' or N->at(len - 1+1) = 'E') then     return ("Even") else     return ("Odd") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : String ; N := "AB3454D" ;
     OclFile["System.out"].print(even_or_odd(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF1543B {
  public static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int test=scanner.nextInt();
    for(int i=0 ; i<test ; i++){
      int n=scanner.nextInt();
      long sum=0 ;
      for(int j=0 ; j<n ; j++){
        sum+=scanner.nextInt();
      }
      long equalParts=sum % n ;
      long nonEqualParts=(n-equalParts);
      System.out.println(equalParts*nonEqualParts);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF1543B {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var test : int ; test := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < test do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var sum : long ; sum := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     sum := sum+(scanner.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
    var equalParts : long ; equalParts := sum mod n ;
    var nonEqualParts : long ; nonEqualParts := (n - equalParts) ;
    OclFile["System.out"].println(equalParts * nonEqualParts) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int N=sc.nextInt();
      int[] p=new int[N];
      int max=0,sum=0 ;
      for(int i=0 ; i<N ; i++){
        p[i]=sc.nextInt();
        sum+=p[i];
        max=Math.max(max,p[i]);
      }
      System.out.println(sum-max/2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var p : Sequence(int) ; p := Integer.subrange(1,N)->collect(0) ;
    var max : int ; max := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     p[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(p[i+1]) ; 
     max := Set{max, p[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum - max / 2) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve(args);
  }
  public void solve(String[] args){
    MyScanner scanner=new MyScanner();
    int s=scanner.nextInt();
    int max=0 ;
    int tmp=0 ;
    int sum=0 ;
    for(int i=0 ; i<s ; i++){
      tmp=scanner.nextInt();
      if(max<=tmp){
        max=tmp ;
      }
      sum+=tmp ;
    }
    System.out.println((sum-max+(max/2)));
  }
  private class MyScanner {
    String[] s ;
    int i ;
    BufferedReader br ;
    String reg=" " ;
    MyScanner(){
      s=new String[0];
      i=0 ;
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public String next(){
      try {
        if(i<s.length)return s[i++];
        String line=br.readLine();
        while(line.equals("")){
          line=br.readLine();
        }
        s=line.split(reg,0);
        i=0 ;
        return s[i++];
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return null ;
    }
    public int nextInt(){
      try {
        return Integer.parseInt(next());
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return-1 ;
    }
    public double nextDouble(){
      try {
        return Double.parseDouble(next());
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return-1 ;
    }
    public long nextLong(){
      try {
        return Long.parseLong(next());
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return-1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve(args) );
   operation solve( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : MyScanner ; scanner := MyScanner.newMyScanner() ;
     var s : int ; s := scanner.nextInt() ;
    var max : int ; max := 0 ;
    var tmp : int ; tmp := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < s do ( (     tmp := scanner.nextInt() ; 
     if (max <= tmp) then (     max := tmp ) else skip ; 
     sum := sum+(tmp) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((sum - max + (max / 2))) ; 
 );
 class MyScanner {
   attribute s : Sequence(String);
   attribute i : int;
   attribute br : OclFile;
   attribute reg : String := " ";
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     s := Integer.subrange(1,0)->collect(null) ; 
     i := 0 ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     if (i < s->size()) then     return s[i+1] else skip ; 
     var line : String ; line := br.readLine() ;
    while (line = "") do (     line := br.readLine() ) ; 
    s := line->split(reg) ; 
    i := 0 ; 
    return s[i+1] 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     try (     return (next())->toInteger() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return -1 );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     try (     return (next())->toReal() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return -1 );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     try (     return (next())->toLong() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return -1 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int N=sc.nextInt();
  static int[] p=new int[N];
  static {
    Arrays.setAll(p,i->sc.nextInt());
  }
  public static void main(String[] args){
    Arrays.sort(p);
    int ans=0 ;
    for(int i=0 ; i<p.length ; i++){
      if(i==p.length-1){
        ans+=p[i]/2 ;
      }
      else {
        ans+=p[i];
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int := sc.getCurrent()->toInteger();
  static   attribute p : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static operation initialiseClass()
  pre: true post: true
  activity: setAll(p, lambda i : OclAny in sc.getCurrent()->toInteger()) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     p := p->sort() ; 
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < p->size() do ( (     if (i = p->size() - 1) then (     ans := ans+(p[i+1] / 2) ) else (     ans := ans+(p[i+1]) ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] p=new int[n];
    for(int i=0 ; i<n ; i++){
      p[i]=sc.nextInt();
    }
    int result=0 ;
    int max=0 ;
    int index=0 ;
    for(int i=0 ; i<n ; i++){
      max=max(max,p[i]);
      if(max==p[i])index=i ;
    }
    for(int i=0 ; i<n ; i++){
      if(i==index){
        result+=max/2 ;
      }
      else {
        result+=p[i];
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
    var max : int ; max := 0 ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     max := Set{max, p[i+1]}->max() ; 
     if (max = p[i+1]) then     index := i ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i = index) then (     result := result+(max / 2) ) else (     result := result+(p[i+1]) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    ArrayList<Integer>a=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      a.add(scan.nextInt());
    }
    int max=a.remove(a.indexOf(Collections.max(a,null)))/2 ;
    int sum=max ;
    for(int x : a){
      sum+=x ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     a := a->including(scan.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var max : int ; max := a->includes(a->indexOf( a, null->max())-1) / 2 ;
    var sum : int ; sum := max ;
    for (x : a) do ( (     sum := sum+(x) )  ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.HashMap ;
class OddOccurrence {
  static int getOddOccurrence(int arr[],int n){
    HashMap<Integer,Integer>hmap=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(hmap.containsKey(arr[i])){
        int val=hmap.get(arr[i]);
        hmap.put(arr[i],val+1);
      }
      else hmap.put(arr[i],1);
    }
    for(Integer a : hmap.keySet()){
      if(hmap.get(a)% 2!=0)return a ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    int arr[]=new int[] {
      2,3,5,4,5,2,4,3,5,2,4,4,2 };
      int n=arr.length ;
      System.out.println(getOddOccurrence(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class OddOccurrence {
  static   operation getOddOccurrence( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var hmap : Map(int,int) ; hmap := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (hmap->keys()->includes(arr[i+1])) then (     var val : int ; val := hmap->at(arr[i+1]) ;
     hmap := hmap->union(Map{arr[i+1] |-> val + 1}) ) else     hmap := hmap->union(Map{arr[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
     for (a : hmap->keys()) do ( (     if (hmap->at(a) mod 2 /= 0) then     return a else skip )  ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,5,4,5,2,4,3,5,2,4,4,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(getOddOccurrence(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int sumOfDigits(int n){
    int sum=0 ;
    while(n!=0){
      sum=sum+n % 10 ;
      n=n/10 ;
    }
    return sum ;
  }
  static int countTheNumbers(int l,int r,int y){
    int count=0 ;
    for(int i=l ; i<=r ; i++){
      if(sumOfDigits(i)==y)count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int l=0,r=10,y=1 ;
    System.out.println(countTheNumbers(l,r,y));
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation sumOfDigits( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n /= 0) do (     sum := sum + n mod 10 ; 
     n := n / 10 ) ; 
     return sum );
  static   operation countTheNumbers( l : int, r : int, y : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := l ; while i <= r do ( (     if (sumOfDigits(i) = y) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
    var r : int ; r := 10 ;
    var y : int ; y := 1 ;
     OclFile["System.out"].println(countTheNumbers(l, r, y)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),s=in.nextInt();
    ArrayList<Integer>ls=new ArrayList<>();
    for(int i=0 ; i<n ; i++)ls.add(in.nextInt());
    Collections.sort(ls);
    int otherHalf=(n/2);
    otherHalf++;
    long ans=0 ;
    for(int i=otherHalf ; i<n ; i++){
      ans+=Math.max(0,s-ls.get(i));
    }
    for(int i=0 ; i<(otherHalf-1); i++)ans+=Math.max(0,ls.get(i)-s);
    ans+=Math.abs(ls.get((otherHalf-1))-s);
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var s : int ; s := in.getCurrent()->toInteger() ;
    var ls : Sequence(int) ; ls := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     ls := ls->including(in.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    ls := ls->sort() ; 
    var otherHalf : int ; otherHalf := (n / 2) ;
    otherHalf := otherHalf + 1 ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := otherHalf ; while i < n do ( (     ans := ans+(Set{0, s - ls->at(i+1)}->max()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < (otherHalf - 1) do (     ans := ans+(Set{0, ls->at(i+1) - s}->max()) ;  ;     i := i + 1 ) ; 
    ans := ans+(if ls->at((otherHalf - 1)+1) - s < 0 then -(ls->at((otherHalf - 1)+1) - s) else ls->at((otherHalf - 1)+1) - s endif) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ReachMedian {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    long s=scan.nextLong();
    Long[] nums=new Long[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=scan.nextLong();
    }
    Arrays.sort(nums);
    long ans=0 ;
    for(int i=n/2 ; i<n ; i++){
      if(nums[i]<s){
        ans+=Math.abs(s-nums[i]);
      }
    }
    for(int i=0 ; i<=n/2 ; i++){
      if(nums[i]>s){
        ans+=nums[i]-s ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ReachMedian {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var s : long ; s := scan.getCurrent()->toLong() ;
    var nums : Sequence(long) ; nums := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := scan.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    nums := nums->sort() ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := n / 2 ; while i < n do ( (     if (nums[i+1] < s) then (     ans := ans+(if s - nums[i+1] < 0 then -(s - nums[i+1]) else s - nums[i+1] endif) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= n / 2 do ( (     if (nums[i+1] > s) then (     ans := ans+(nums[i+1] - s) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int num=scan.nextInt();
    for(int i=0 ; i<num ; i++){
      String[] str=new String[2];
      int[] ans=new int[2];
      for(int j=0 ; j<2 ; j++){
        ans[j]=0 ;
        str[j]=scan.next();
        for(int k=0 ; k<str[j] .length(); k=k+2){
          String hoge=String.valueOf(str[j] .charAt(k));
          try {
            String huga=String.valueOf(str[j] .charAt(k+1));
            ans[j]=ans[j]+Integer.parseInt(hoge)*changeChar(huga);
          }
          catch(Exception e){
            ans[j]=ans[j]+changeChar(hoge);
            k--;
          }
        }
      }
      System.out.println(returnChar(ans[0]+ans[1]));
    }
  }
  public static String returnChar(int n){
    String str="" ;
    int data=1000 ;
    while(true){
      if(n/data>=1){
        if(n/data>=2){
          str=str+n/data ;
        }
        if(data==1000){
          str=str+"m" ;
        }
        if(data==100){
          str=str+"c" ;
        }
        if(data==10){
          str=str+"x" ;
        }
        if(data==1){
          str=str+"i" ;
        }
        n=n-(n/data)*data ;
      }
      if(data==1){
        break ;
      }
      data=data/10 ;
    }
    return str ;
  }
  public static int changeChar(String str){
    if(str.equals("m")){
      return 1000 ;
    }
    if(str.equals("c")){
      return 100 ;
    }
    if(str.equals("x")){
      return 10 ;
    }
    return 1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < num do ( (     var str : Sequence(String) ; str := Integer.subrange(1,2)->collect(null) ;
     var ans : Sequence(int) ; ans := Integer.subrange(1,2)->collect(0) ;
         var j : int ; j := 0 ; while j < 2 do ( (     ans[j+1] := 0 ; 
     str[j+1] := scan.getCurrent() ; 
         var k : int ; k := 0 ; while k < str[j+1]->size() do ( (     var hoge : String ; hoge := ((str[j+1]->at(k+1)) + "") ;
     try (     var huga : String ; huga := ((str[j+1]->at(k + 1+1)) + "") ;
     ans[j+1] := ans[j+1] + (hoge)->toInteger() * changeChar(huga) )   catch (e : ProgramException) do (     ans[j+1] := ans[j+1] + changeChar(hoge) ; 
     k := k - 1 )
 )  ;     k := k + 2 ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(returnChar(ans[0+1] + ans[1+1])) )  ;     i := i + 1 ) );
  static   operation returnChar( n : int) : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     var data : int ; data := 1000 ;
     while (true) do (     if (n / data >= 1) then (     if (n / data >= 2) then (     str := str + n / data ) else skip ; 
     if (data = 1000) then (     str := str + "m" ) else skip ; 
    if (data = 100) then (     str := str + "c" ) else skip ; 
    if (data = 10) then (     str := str + "x" ) else skip ; 
    if (data = 1) then (     str := str + "i" ) else skip ; 
    n := n - (n / data) * data ; 
 ) else skip ; 
     if (data = 1) then (     break ) else skip ; 
     data := data / 10 ) ; 
     return str );
  static   operation changeChar( str : String) : int
  pre: true
  post: true
  activity: (     if (str = "m") then (     return 1000 ) else skip ; 
     if (str = "c") then (     return 100 ) else skip ; 
     if (str = "x") then (     return 10 ) else skip ; 
     return 1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    long s=scanner.nextLong();
    long[] arr=new long[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=scanner.nextLong();
    }
    Arrays.sort(arr);
    int min=-1 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(arr[i]<=s){
        min=i ;
        break ;
      }
    }
    long ans=0 ;
    if(min>=(n-1)/2){
      for(int i=(n-1)/2 ; i<=min ; i++){
        ans+=s-arr[i];
      }
    }
    else {
      for(int i=min+1 ; i<=(n-1)/2 ; i++){
        ans+=arr[i]-s ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var s : long ; s := scanner.getCurrent()->toLong() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scanner.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var min : int ; min := -1 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (arr[i+1] <= s) then (     min := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    var ans : long ; ans := 0 ;
    if (min >= (n - 1) / 2) then (         var i : int ; i := (n - 1) / 2 ; while i <= min do ( (     ans := ans+(s - arr[i+1]) )  ;     i := i + 1 ) ) else (         var i : int ; i := min + 1 ; while i <= (n - 1) / 2 do ( (     ans := ans+(arr[i+1] - s) )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int s=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<a.length ; i++){
      a[i]=sc.nextInt();
    }
    System.out.println(solve(a,s));
    sc.close();
  }
  static long solve(int[] a,int s){
    Arrays.sort(a);
    int index=a.length/2 ;
    return Math.abs(a[index]-s)+IntStream.range(0,index).map(i->Math.max(0,a[i]-s)).asLongStream().sum()+IntStream.range(index+1,a.length).map(i->Math.max(0,s-a[i])).asLongStream().sum();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(a, s)) ; 
    skip ; 
 );
  static   operation solve( a : Sequence(int), s : int) : long
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var index : int ; index := a->size() / 2 ;
     return if a[index+1] - s < 0 then -(a[index+1] - s) else a[index+1] - s endif + Integer.subrange(0, index-1)->collect( _x1 | (lambda i : OclAny in Set{0, a[i+1] - s}->max())->apply(_x1) )->sum() + Integer.subrange(index + 1, a->size()-1)->collect( _x1 | (lambda i : OclAny in Set{0, s - a[i+1]}->max())->apply(_x1) )->sum() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void main(String[] args){
    int matrix[][]=new int[5][5],row_index,column_index,x=0,size=5 ;
    for(row_index=0 ; row_index<size ; row_index++){
      for(column_index=0 ; column_index<size ; column_index++){
        matrix[row_index][column_index]=++x ;
      }
    }
    System.out.printf("The matrix is\n");
    for(row_index=0 ; row_index<size ; row_index++){
      for(column_index=0 ; column_index<size ; column_index++){
        System.out.printf("%d\t",matrix[row_index][column_index]);
      }
      System.out.printf("\n");
    }
    System.out.printf("\nMain diagonal elements are:\n");
    for(row_index=0 ; row_index<size ; row_index++){
      for(column_index=0 ; column_index<size ; column_index++){
        if(row_index==column_index){
          System.out.printf("%d,",matrix[row_index][column_index]);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var matrix : Sequence(Sequence(void)) ; matrix := Integer.subrange(1,5)->collect(Integer.subrange(1,5)->collect(0)) ;
    var row_index : int ;
    var column_index : int ;
    var x : int ; x := 0 ;
    var size : int ; size := 5 ;
         row_index := 0 ; while row_index < size do ( (         column_index := 0 ; while column_index < size do ( (         x := x + 1 ;
 matrix[row_index+1][column_index+1] := x  )  ;     column_index := column_index + 1 ) )  ;     row_index := row_index + 1 ) ; 
    OclFile["System.out"].printf("The matrix is\n") ; 
        row_index := 0 ; while row_index < size do ( (         column_index := 0 ; while column_index < size do ( (     OclFile["System.out"].printf("%d\t", matrix[row_index+1][column_index+1]) )  ;     column_index := column_index + 1 ) ; 
     OclFile["System.out"].printf("\n") )  ;     row_index := row_index + 1 ) ; 
    OclFile["System.out"].printf("\nMain diagonal elements are:\n") ; 
        row_index := 0 ; while row_index < size do ( (         column_index := 0 ; while column_index < size do ( (     if (row_index = column_index) then (     OclFile["System.out"].printf("%d,", matrix[row_index+1][column_index+1]) ) else skip )  ;     column_index := column_index + 1 ) )  ;     row_index := row_index + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void main(String args[]){
    int matrix[][]=new int[5][5],row_index,column_index,x=0,size=5 ;
    for(row_index=0 ; row_index<size ; row_index++){
      for(column_index=0 ; column_index<size ; column_index++){
        matrix[row_index][column_index]=++x ;
      }
    }
    System.out.printf("The matrix is\n");
    for(row_index=0 ; row_index<size ; row_index++){
      for(column_index=0 ; column_index<size ; column_index++){
        System.out.printf("%d\t",matrix[row_index][column_index]);
      }
      System.out.printf("\n");
    }
    System.out.printf("\nElements above Main diagonal elements are:\n");
    for(row_index=0 ; row_index<size ; row_index++){
      for(column_index=0 ; column_index<size ; column_index++){
        if(row_index<column_index){
          System.out.printf("%d,",matrix[row_index][column_index]);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var matrix : Sequence(Sequence(void)) ; matrix := Integer.subrange(1,5)->collect(Integer.subrange(1,5)->collect(0)) ;
    var row_index : int ;
    var column_index : int ;
    var x : int ; x := 0 ;
    var size : int ; size := 5 ;
         row_index := 0 ; while row_index < size do ( (         column_index := 0 ; while column_index < size do ( (         x := x + 1 ;
 matrix[row_index+1][column_index+1] := x  )  ;     column_index := column_index + 1 ) )  ;     row_index := row_index + 1 ) ; 
    OclFile["System.out"].printf("The matrix is\n") ; 
        row_index := 0 ; while row_index < size do ( (         column_index := 0 ; while column_index < size do ( (     OclFile["System.out"].printf("%d\t", matrix[row_index+1][column_index+1]) )  ;     column_index := column_index + 1 ) ; 
     OclFile["System.out"].printf("\n") )  ;     row_index := row_index + 1 ) ; 
    OclFile["System.out"].printf("\nElements above Main diagonal elements are:\n") ; 
        row_index := 0 ; while row_index < size do ( (         column_index := 0 ; while column_index < size do ( (     if (row_index < column_index) then (     OclFile["System.out"].printf("%d,", matrix[row_index+1][column_index+1]) ) else skip )  ;     column_index := column_index + 1 ) )  ;     row_index := row_index + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void main(String[] args){
    int[][] matrix=new int[5][5];
    int row_index,column_index,x=0,size=5 ;
    for(row_index=0 ; row_index<size ; row_index++){
      for(column_index=0 ; column_index<size ; column_index++){
        matrix[row_index][column_index]=++x ;
      }
    }
    System.out.printf("The matrix is\n");
    for(row_index=0 ; row_index<size ; row_index++){
      for(column_index=0 ; column_index<size ; column_index++){
        System.out.printf("%d\t",matrix[row_index][column_index]);
      }
      System.out.printf("\n");
    }
    System.out.printf("\nCorner Elements are:\n");
    for(row_index=0 ; row_index<size ; row_index++){
      for(column_index=0 ; column_index<size ; column_index++){
        if((row_index==0 || row_index==size-1)&&(column_index==0 || column_index==size-1))System.out.printf("%d,",matrix[row_index][column_index]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var matrix : Sequence(Sequence(int)) ; matrix := Integer.subrange(1,5)->collect(Integer.subrange(1,5)->collect(0)) ;
     var row_index : int ;
    var column_index : int ;
    var x : int ; x := 0 ;
    var size : int ; size := 5 ;
        row_index := 0 ; while row_index < size do ( (         column_index := 0 ; while column_index < size do ( (         x := x + 1 ;
 matrix[row_index+1][column_index+1] := x  )  ;     column_index := column_index + 1 ) )  ;     row_index := row_index + 1 ) ; 
    OclFile["System.out"].printf("The matrix is\n") ; 
        row_index := 0 ; while row_index < size do ( (         column_index := 0 ; while column_index < size do ( (     OclFile["System.out"].printf("%d\t", matrix[row_index+1][column_index+1]) )  ;     column_index := column_index + 1 ) ; 
     OclFile["System.out"].printf("\n") )  ;     row_index := row_index + 1 ) ; 
    OclFile["System.out"].printf("\nCorner Elements are:\n") ; 
        row_index := 0 ; while row_index < size do ( (         column_index := 0 ; while column_index < size do ( (     if ((row_index = 0 or row_index = size - 1) & (column_index = 0 or column_index = size - 1)) then     OclFile["System.out"].printf("%d,", matrix[row_index+1][column_index+1]) ; else skip )  ;     column_index := column_index + 1 ) )  ;     row_index := row_index + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void main(String[] args){
    int[][] matrix=new int[5][5];
    int row_index,column_index,x=0,size=5 ;
    for(row_index=0 ; row_index<size ; row_index++){
      for(column_index=0 ; column_index<size ; column_index++){
        matrix[row_index][column_index]=++x ;
      }
    }
    System.out.printf("The matrix is\n");
    for(row_index=0 ; row_index<size ; row_index++){
      for(column_index=0 ; column_index<size ; column_index++){
        System.out.printf("%d\t",matrix[row_index][column_index]);
      }
      System.out.printf("\n");
    }
    System.out.printf("\nElements below Secondary"+" diagonal are:\n");
    for(row_index=0 ; row_index<size ; row_index++){
      for(column_index=0 ; column_index<size ; column_index++){
        if((row_index+column_index)>size-1)System.out.printf("%d,",matrix[row_index][column_index]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var matrix : Sequence(Sequence(int)) ; matrix := Integer.subrange(1,5)->collect(Integer.subrange(1,5)->collect(0)) ;
     var row_index : int ;
    var column_index : int ;
    var x : int ; x := 0 ;
    var size : int ; size := 5 ;
        row_index := 0 ; while row_index < size do ( (         column_index := 0 ; while column_index < size do ( (         x := x + 1 ;
 matrix[row_index+1][column_index+1] := x  )  ;     column_index := column_index + 1 ) )  ;     row_index := row_index + 1 ) ; 
    OclFile["System.out"].printf("The matrix is\n") ; 
        row_index := 0 ; while row_index < size do ( (         column_index := 0 ; while column_index < size do ( (     OclFile["System.out"].printf("%d\t", matrix[row_index+1][column_index+1]) )  ;     column_index := column_index + 1 ) ; 
     OclFile["System.out"].printf("\n") )  ;     row_index := row_index + 1 ) ; 
    OclFile["System.out"].printf("\nElements below Secondary" + " diagonal are:\n") ; 
        row_index := 0 ; while row_index < size do ( (         column_index := 0 ; while column_index < size do ( (     if ((row_index + column_index) > size - 1) then     OclFile["System.out"].printf("%d,", matrix[row_index+1][column_index+1]) ; else skip )  ;     column_index := column_index + 1 ) )  ;     row_index := row_index + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  InputStream in=System.in ;
  PrintStream out=System.out ;
  public void _main(String[] args){
    Scanner sc=new Scanner(in);
    int N=sc.nextInt();
    int[] z=new int[100000];
    for(int i=0 ; i<N ; i++){
      z[sc.nextInt()]++;
    }
    sc.close();
    int ans=0 ;
    for(int X=0 ; X<z.length ; X++){
      int b=z[X];
      if(X>0)b+=z[X-1];
      if(X<z.length-1)b+=z[X+1];
      ans=Math.max(ans,b);
    }
    out.println(ans);
  }
  public static void main(String[] args){
    new Main()._main(args);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile["System.in"];
   attribute out : OclFile := OclFile["System.out"];
   operation _main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var z : Sequence(int) ; z := Integer.subrange(1,100000)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     z[sc.getCurrent()->toInteger()+1] := z[sc.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : int ; ans := 0 ;
        var X : int ; X := 0 ; while X < z->size() do ( (     var b : int ; b := z[X+1] ;
     if (X > 0) then     b := b+(z[X - 1+1]) ; else skip ; 
     if (X < z->size() - 1) then     b := b+(z[X + 1+1]) ; else skip ; 
     ans := Set{ans, b}->max() )  ;     X := X + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain()._main(args) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void main(String[] args){
    int[][] matrix=new int[5][5];
    int row_index,column_index,x=0,size=5 ;
    for(row_index=0 ; row_index<size ; row_index++){
      for(column_index=0 ; column_index<size ; column_index++){
        matrix[row_index][column_index]=++x ;
      }
    }
    System.out.printf("The matrix is\n");
    for(row_index=0 ; row_index<size ; row_index++){
      for(column_index=0 ; column_index<size ; column_index++){
        System.out.printf("%d\t",matrix[row_index][column_index]);
      }
      System.out.printf("\n");
    }
    System.out.printf("\nElements above Secondary"+" diagonal are:\n");
    for(row_index=0 ; row_index<size ; row_index++){
      for(column_index=0 ; column_index<size ; column_index++){
        if((row_index+column_index)<size-1)System.out.printf("%d,",matrix[row_index][column_index]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var matrix : Sequence(Sequence(int)) ; matrix := Integer.subrange(1,5)->collect(Integer.subrange(1,5)->collect(0)) ;
     var row_index : int ;
    var column_index : int ;
    var x : int ; x := 0 ;
    var size : int ; size := 5 ;
        row_index := 0 ; while row_index < size do ( (         column_index := 0 ; while column_index < size do ( (         x := x + 1 ;
 matrix[row_index+1][column_index+1] := x  )  ;     column_index := column_index + 1 ) )  ;     row_index := row_index + 1 ) ; 
    OclFile["System.out"].printf("The matrix is\n") ; 
        row_index := 0 ; while row_index < size do ( (         column_index := 0 ; while column_index < size do ( (     OclFile["System.out"].printf("%d\t", matrix[row_index+1][column_index+1]) )  ;     column_index := column_index + 1 ) ; 
     OclFile["System.out"].printf("\n") )  ;     row_index := row_index + 1 ) ; 
    OclFile["System.out"].printf("\nElements above Secondary" + " diagonal are:\n") ; 
        row_index := 0 ; while row_index < size do ( (         column_index := 0 ; while column_index < size do ( (     if ((row_index + column_index) < size - 1) then     OclFile["System.out"].printf("%d,", matrix[row_index+1][column_index+1]) ; else skip )  ;     column_index := column_index + 1 ) )  ;     row_index := row_index + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class helloWorld {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int ar[]=new int[n+1];
    boolean[] parent=new boolean[n+1];
    String ans="Yes" ;
    for(int i=2 ; i<=n ; i++){
      ar[i]=in.nextInt();
      parent[ar[i] ]=true ;
    }
    for(int i=1 ; i<=n ; i++){
      if(parent[i]){
        int a=0 ;
        for(int j=2 ; j<=n ; j++)if(ar[j]==i && ! parent[j])a++;
        if(a<3)ans="No" ;
      }
    }
    System.out.println(ans);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class helloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,n + 1)->collect(0) ;
    var parent : Sequence(boolean) ; parent := Integer.subrange(1,n + 1)->collect(false) ;
    var ans : String ; ans := "Yes" ;
        var i : int ; i := 2 ; while i <= n do ( (     ar[i+1] := in.getCurrent()->toInteger() ; 
     parent[ar[i+1]+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (parent[i+1]) then (     var a : int ; a := 0 ;
         var j : int ; j := 2 ; while j <= n do (     if (ar[j+1] = i & not(parent[j+1])) then     a := a + 1 ; else skip ;  ;     j := j + 1 ) ; 
     if (a < 3) then     ans := "No" ; else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ChristmasSpruce {
  static ArrayList<Integer>[] adj ;
  static int[] out ;
  static boolean[] leaf ;
  static int[] par ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    adj=new ArrayList[n+1];
    for(int i=0 ; i<=n ; i++)adj[i]=new ArrayList<>();
    out=new int[n+1];
    par=new int[n+1];
    leaf=new boolean[n+1];
    for(int i=1 ; i<=n-1 ; i++){
      int x=in.nextInt();
      adj[x] .add(i+1);
      par[i+1]=x ;
    }
    boolean good=true ;
    dfs(1);
    for(int i=1 ; i<=n ; i++){
      good &=(leaf[i] ||(out[i]>=3));
    }
    if(good)pw.println("YES");
    else pw.println("NO");
    pw.close();
  }
  static void dfs(int u){
    if(adj[u] .size()==0 && par[u]!=0){
      leaf[u]=true ;
    }
    for(int v : adj[u]){
      dfs(v);
      if(leaf[v])out[u]++;
    }
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class ChristmasSpruce {
  static   attribute adj : Sequence(Sequence(int));
  static   attribute out : Sequence(int);
  static   attribute leaf : Sequence(boolean);
  static   attribute par : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    adj := Integer.subrange(1,n + 1)->collect(null) ; 
        var i : int ; i := 0 ; while i <= n do (     adj[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
    out := Integer.subrange(1,n + 1)->collect(0) ; 
    par := Integer.subrange(1,n + 1)->collect(0) ; 
    leaf := Integer.subrange(1,n + 1)->collect(false) ; 
        var i : int ; i := 1 ; while i <= n - 1 do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     adj[x+1]->excludes(i + 1) ; 
     par[i + 1+1] := x )  ;     i := i + 1 ) ; 
    var good : boolean ; good := true ;
    execute dfs(1) ; 
        var i : int ; i := 1 ; while i <= n do ( (     good := MathLib.bitwiseAnd(good, (leaf[i+1] or (out[i+1] >= 3))) )  ;     i := i + 1 ) ; 
    if (good) then     skip else     skip ; ;  
    skip ; 
 );
  static   operation dfs( u : int) : void
  pre: true
  post: true
  activity: (     if (adj[u+1]->size() = 0 & par[u+1] /= 0) then (     leaf[u+1] := true ) else skip ; 
     for (v : adj[u+1]) do ( (     execute dfs(v) ; 
     if (leaf[v+1]) then     out[u+1] := out[u+1] + 1 ; else skip )  ) );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class DP {
  static int n ;
  static List<Integer>adj[];
  static int mod=(int)1e9+7 ;
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    n=sc.nextInt();
    adj=new ArrayList[n];
    for(int i=0 ; i<n ; i++)adj[i]=new ArrayList<>();
    for(int i=1 ; i<n ; i++){
      adj[sc.nextInt()-1] .add(i);
    }
    boolean check=dfs(0);
    System.out.println(check==true ? "Yes" : "No");
    out.close();
  }
  private static boolean dfs(int u){
    int c=0 ;
    for(int v : adj[u]){
      if(adj[v] .size()==0){
        c++;
      }
      else if(! dfs(v)){
        return false ;
      }
    }
    return c>=3 ;
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(String s)throws FileNotFoundException {
      br=new BufferedReader(new FileReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DP {
  static   attribute n : int;
  static   attribute adj : Sequence(Sequence(int));
  static   attribute mod : int := 1e9->oclAsType(int) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    n := sc.getCurrent()->toInteger() ; 
    adj := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do (     adj[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     adj[sc.getCurrent()->toInteger() - 1+1]->excludes(i) )  ;     i := i + 1 ) ; 
    var check : boolean ; check := dfs(0) ;
    OclFile["System.out"].println(if check = true then "Yes" else "No" endif) ; 
    skip ; 
 );
  static   operation dfs( u : int) : boolean
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
     for (v : adj[u+1]) do ( (     if (adj[v+1]->size() = 0) then (     c := c + 1 ) else     if (not(dfs(v))) then (     return false ) else skip ; )  ) ; 
     return c >= 3 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( s : String) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  static char flag[]=new char[] {
    'm','c','x','i' };
    static int num[]=new int[] {
      1000,100,10,1 };
      public static void main(String[] args)throws IOException {
        InputStreamReader isr=new InputStreamReader(System.in);
        BufferedReader reader=new BufferedReader(isr);
        Main app=new Main();
        int n=Integer.valueOf(reader.readLine());
        for(int i=0 ; i<n ; i++){
          System.out.println((app.change(app.sum(reader.readLine()))));
        }
        reader.close();
      }
      public int sum(String str){
        String s[]=str.split(" ");
        int res=0,hoge=1 ;
        char c ;
        for(int i=0 ; i<2 ; i++){
          for(int j=0 ; j<s[i] .length(); j++){
            c=s[i] .charAt(j);
            if('2'<=c && c<='9'){
              hoge=c-'0' ;
              continue ;
            }
            else {
              res+=hoge*set(c);
            }
            hoge=1 ;
          }
        }
        return res ;
      }
      public String change(int n){
        String res="" ;
        int hoge=0 ;
        for(int i=0 ; i<4 ; i++){
          while(n>=num[i]){
            n-=num[i];
            hoge++;
          }
          if(hoge==1){
            res+=flag[i];
          }
          else if(hoge!=0){
            res+=String.valueOf(hoge)+flag[i];
          }
          hoge=0 ;
        }
        return res ;
      }
      public int set(char c){
        switch(c){
          case 'm' : return 1000 ;
          case 'c' : return 100 ;
          case 'x' : return 10 ;
          case 'i' : return 1 ;
        }
        return 0 ;
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute flag : String := Sequence{'m','c','x','i'};
  static   attribute num : int := Sequence{1000,100,10,1};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(isr) ;
    var app : Main ; app := Main.newMain() ;
    var n : int ; n := (reader.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println((app.change(app.sum(reader.readLine())))) )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation sum( str : String) : int
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := str->split(" ") ;
     var res : int ; res := 0 ;
    var hoge : int ; hoge := 1 ;
    var c : String ;
        var i : int ; i := 0 ; while i < 2 do ( (         var j : int ; j := 0 ; while j < s[i+1]->size() do ( (     c := s[i+1]->at(j+1) ; 
     if ('2' <= c & c <= '9') then (     hoge := (c)->char2byte() - ('0')->char2byte() ; 
     continue ) else (     res := res+(hoge * set(c)) ) ;  
     hoge := 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return res 
 );
   operation change( n : int) : String
  pre: true
  post: true
  activity: (     var res : String ; res := "" ;
     var hoge : int ; hoge := 0 ;
         var i : int ; i := 0 ; while i < 4 do ( (     while (n >= num[i+1]) do (     n := n-(num[i+1]) ; 
     hoge := hoge + 1 ) ; 
     if (hoge = 1) then (     res := res+(flag[i+1]) ) else     if (hoge /= 0) then (     res := res+(((hoge) + "") + flag[i+1]) ) else skip ; ;  
     hoge := 0 )  ;     i := i + 1 ) ; 
     return res );
   operation set( c : String) : int
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
       if _switchval = 'm' then
     return 1000 
   else skip ;
       if _switchval = 'c' then
     return 100 
   else skip ;
       if _switchval = 'x' then
     return 10 
   else skip ;
       if _switchval = 'i' then
     return 1 
   else skip ;
 )
     return 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class NationalProject {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t!=0){
      solve(br,pr);
      t--;
    }
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    String[] temp=br.readLine().split(" ");
    int n=Integer.parseInt(temp[0]);
    int g=Integer.parseInt(temp[1]);
    int b=Integer.parseInt(temp[2]);
    int min=(n+1)/2 ;
    long left=n ;
    long right=Long.MAX_VALUE ;
    while(left<=right){
      long mid=left+(right-left)/2 ;
      if(countGood(mid,g,b)<min){
        left=mid+1 ;
      }
      else {
        right=mid-1 ;
      }
    }
    pr.println(left);
  }
  public static long countGood(long day,int g,int b){
    long totalCycle=day/(g+b);
    long good=totalCycle*g ;
    long extra=day-(g+b)*totalCycle ;
    good+=Math.min(extra,g);
    return good ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class NationalProject {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
    while (t /= 0) do (     execute solve(br, pr) ; 
     t := t - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
     var n : int ; n := (temp[0+1])->toInteger() ;
    var g : int ; g := (temp[1+1])->toInteger() ;
    var b : int ; b := (temp[2+1])->toInteger() ;
    var min : int ; min := (n + 1) / 2 ;
    var left : long ; left := n ;
    var right : long ; right := "9223372036854775807"->toLong() ;
    while (left <= right) do (     var mid : long ; mid := left + (right - left) / 2 ;
     if (countGood(mid, g, b) < min) then (     left := mid + 1 ) else (     right := mid - 1 ) ) ; 
    skip ; 
 );
  static   operation countGood( day : long, g : int, b : int) : long
  pre: true
  post: true
  activity: (     var totalCycle : long ; totalCycle := day / (g + b) ;
     var good : long ; good := totalCycle * g ;
    var extra : long ; extra := day - (g + b) * totalCycle ;
    good := good+(Set{extra, g}->min()) ; 
    return good 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class asphalt {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t,j,i ;
    long n,g,b,k,p,d ;
    t=sc.nextInt();
    for(j=1 ; j<=t ; j++){
      n=sc.nextLong();
      g=sc.nextLong();
      b=sc.nextLong();
      k=(long)Math.ceil(n/2.0);
      p=(long)Math.ceil(k/(double)g);
      d=k+(p-1)*b+(((n-k)-((p-1)*b))>0 ?((n-k)-((p-1)*b)): 0);
      System.out.println(d);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class asphalt {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ;
    var j : int ;
    var i : int ;
    var n : long ;
    var g : long ;
    var b : long ;
    var k : long ;
    var p : long ;
    var d : long ;
    t := sc.getCurrent()->toInteger() ; 
        j := 1 ; while j <= t do ( (     n := sc.getCurrent()->toLong() ; 
     g := sc.getCurrent()->toLong() ; 
    b := sc.getCurrent()->toLong() ; 
    k := (n / 2.0)->ceil()->oclAsType(long) ; 
    p := (k / g->oclAsType(double))->ceil()->oclAsType(long) ; 
    d := k + (p - 1) * b + (if ((n - k) - ((p - 1) * b)) > 0 then ((n - k) - ((p - 1) * b)) else 0 endif) ; 
    OclFile["System.out"].println(d) ; 
 )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    int max=(int)10e6+1 ;
    while(t-->0){
      String str[]=br.readLine().split(" ");
      long n=Long.parseLong(str[0]);
      long g=Long.parseLong(str[1]);
      long b=Long.parseLong(str[2]);
      long req=(long)Math.ceil((double)n/2);
      long rg=(long)Math.ceil((double)req/g);
      long x=0 ;
      if((rg-1)*b>=(n-req)){
        x=(rg-1)*b ;
      }
      else {
        x=(rg-1)*b+(n-req-(rg-1)*b);
      }
      System.out.println(x+req);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
     var max : int ; max := 10e6->oclAsType(int) + 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     var n : long ; n := (str[0+1])->toLong() ;
    var g : long ; g := (str[1+1])->toLong() ;
    var b : long ; b := (str[2+1])->toLong() ;
    var req : long ; req := (n->oclAsType(double) / 2)->ceil()->oclAsType(long) ;
    var rg : long ; rg := (req->oclAsType(double) / g)->ceil()->oclAsType(long) ;
    var x : long ; x := 0 ;
    if ((rg - 1) * b >= ((n)->char2byte() - req)) then (     x := (rg - 1) * b ) else (     x := (rg - 1) * b + ((n)->char2byte() - req - (rg - 1) * b) ) ;  
    OclFile["System.out"].println(x + req) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void findSeries(int num,int first,int sec){
    System.out.print(first+" "+sec+" ");
    int counter=0,sum ;
    while(counter<num-2){
      sum=first+sec ;
      System.out.print(sum+" ");
      first=sec ;
      sec=sum ;
      counter++;
    }
  }
  public static void main(String[] args){
    int n=5,first=2,sec=4 ;
    findSeries(n,first,sec);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSeries( num : int, first : int, sec : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(first + " " + sec + " ") ; 
     var counter : int ; counter := 0 ;
    var sum : int ;
     while (counter < num - 2) do (     sum := first + sec ; 
     OclFile["System.out"].print(sum + " ") ; 
    first := sec ; 
    sec := sum ; 
    counter := counter + 1 ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var first : int ; first := 2 ;
    var sec : int ; sec := 4 ;
     execute findSeries(n, first, sec) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findDigitsInFactorial(int n){
    if(n<0)return 0 ;
    if(n<=1)return 1 ;
    double x=((n*Math.log10(n/Math.E)+Math.log10(2*Math.PI*n)/2.0));
    return(int)(Math.floor(x)+1);
  }
  static int findNum(int n){
    int low=0,hi=2*n ;
    if(n<=0)return-1 ;
    if(findDigitsInFactorial(low)==n)return low ;
    while(low<=hi){
      int mid=(low+hi)/2 ;
      if(findDigitsInFactorial(mid)>=n && findDigitsInFactorial(mid-1)<n)return mid ;
      else if(findDigitsInFactorial(mid)<n)low=mid+1 ;
      else hi=mid-1 ;
    }
    return low ;
  }
  public static void main(String[] args){
    System.out.println(findNum(1));
    System.out.println(findNum(2));
    System.out.println(findNum(5));
    System.out.println(findNum(24));
    System.out.println(findNum(100));
    System.out.println(findNum(1221));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findDigitsInFactorial( n : int) : int
  pre: true
  post: true
  activity: (     if (n < 0) then     return 0 else skip ; 
     if (n <= 1) then     return 1 else skip ; 
     var x : double ; x := ((n * (n / 2.718281828459045)->log10() + (2 * 3.141592653589793 * n)->log10() / 2.0)) ;
     return ((x)->floor() + 1)->oclAsType(int) );
  static   operation findNum( n : int) : int
  pre: true
  post: true
  activity: (     var low : int ; low := 0 ;
    var hi : int ; hi := 2 * n ;
     if (n <= 0) then     return -1 else skip ; 
    if (findDigitsInFactorial(low) = n) then     return low else skip ; 
    while (low <= hi) do (     var mid : int ; mid := (low + hi) / 2 ;
     if (findDigitsInFactorial(mid) >= n & findDigitsInFactorial(mid - 1) < n) then     return mid else     if (findDigitsInFactorial(mid) < n) then     low := mid + 1 else     hi := mid - 1 ; ;  ) ; 
    return low 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(findNum(1)) ; 
     OclFile["System.out"].println(findNum(2)) ; 
    OclFile["System.out"].println(findNum(5)) ; 
    OclFile["System.out"].println(findNum(24)) ; 
    OclFile["System.out"].println(findNum(100)) ; 
    OclFile["System.out"].println(findNum(1221)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main m=new Main();
    m.answer();
  }
  private Scanner scan=new Scanner(System.in);
  private static final int MAX=100000 ;
  private final int[] count ;
  public Main(){
    count=new int[MAX+1];
    int N=Integer.parseInt(scan.next());
    for(int i=0 ; i<N ; i++){
      int a=Integer.parseInt(scan.next());
      count[a]++;
    }
    scan.close();
  }
  public final void answer(){
    int[] result=new int[MAX+1];
    for(int i=0 ; i<=MAX ; i++){
      result[i]=count[i];
      if(i>0)result[i]+=count[i-1];
      if(i<MAX)result[i]+=count[i+1];
    }
    Arrays.sort(result);
    System.out.println(result[MAX]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.answer() );
   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute MAX : int := 100000;
   attribute count : Sequence(int);
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     count := Integer.subrange(1,MAX + 1)->collect(0) ; 
     var N : int ; N := (scan.getCurrent())->toInteger() ;
         var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := (scan.getCurrent())->toInteger() ;
     count[a+1] := count[a+1] + 1 )  ;     i := i + 1 ) ; 
     skip );
   operation answer() : void
  pre: true
  post: true
  activity: (     var result : Sequence(int) ; result := Integer.subrange(1,MAX + 1)->collect(0) ;
         var i : int ; i := 0 ; while i <= MAX do ( (     result[i+1] := count[i+1] ; 
     if (i > 0) then     result[i+1] := result[i+1]+(count[i - 1+1]) ; else skip ; 
     if (i < MAX) then     result[i+1] := result[i+1]+(count[i + 1+1]) ; else skip )  ;     i := i + 1 ) ; 
     result := result->sort() ; 
     OclFile["System.out"].println(result[MAX+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class GFG {
  public static void sortSquares(int arr[]){
    int n=arr.length ;
    int k ;
    for(k=0 ; k<n ; k++){
      if(arr[k]>=0)break ;
    }
    int i=k-1 ;
    int j=k ;
    int ind=0 ;
    int[] temp=new int[n];
    while(i>=0 && j<n){
      if(arr[i]*arr[i]<arr[j]*arr[j]){
        temp[ind]=arr[i]*arr[i];
        i--;
      }
      else {
        temp[ind]=arr[j]*arr[j];
        j++;
      }
      ind++;
    }
    while(i>=0){
      temp[ind++]=arr[i]*arr[i];
      i--;
    }
    while(j<n){
      temp[ind++]=arr[j]*arr[j];
      j++;
    }
    for(int x=0 ; x<n ; x++)arr[x]=temp[x];
  }
  public static void main(String[] args){
    int arr[]={
-6,-3,-1,2,4,5 };
      int n=arr.length ;
      System.out.println("Before sort ");
      for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
      sortSquares(arr);
      System.out.println("");
      System.out.println("After Sort ");
      for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sortSquares( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
     var k : int ;
        k := 0 ; while k < n do ( (     if (arr[k+1] >= 0) then     break else skip )  ;     k := k + 1 ) ; 
    var i : int ; i := k - 1 ;
    var j : int ; j := k ;
    var ind : int ; ind := 0 ;
    var temp : Sequence(int) ; temp := Integer.subrange(1,n)->collect(0) ;
    while (i >= 0 & j < n) do (     if (arr[i+1] * arr[i+1] < arr[j+1] * arr[j+1]) then (     temp[ind+1] := arr[i+1] * arr[i+1] ; 
     i := i - 1 ) else (     temp[ind+1] := arr[j+1] * arr[j+1] ; 
     j := j + 1 ) ;  
     ind := ind + 1 ) ; 
    while (i >= 0) do (      temp[ind+1] := arr[i+1] * arr[i+1]  ; ind := ind + 1 ; 
     i := i - 1 ) ; 
    while (j < n) do (      temp[ind+1] := arr[j+1] * arr[j+1]  ; ind := ind + 1 ; 
     j := j + 1 ) ; 
        var x : int ; x := 0 ; while x < n do (     arr[x+1] := temp[x+1] ;  ;     x := x + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-6,-3,-1,2,4,5} ;
     var n : int ; n := arr->size() ;
    OclFile["System.out"].println("Before sort ") ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
    execute sortSquares(arr) ; 
    OclFile["System.out"].println("") ; 
    OclFile["System.out"].println("After Sort ") ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int maxProduct(int arr[],int n){
    if(n<3){
      return-1 ;
    }
    Arrays.sort(arr);
    return Math.max(arr[0]*arr[1]*arr[n-1],arr[n-1]*arr[n-2]*arr[n-3]);
  }
  public static void main(String[] args){
    int arr[]={
-10,-3,5,6,-20 };
      int n=arr.length ;
      int max=maxProduct(arr,n);
      if(max==-1){
        System.out.println("No Triplet Exists");
      }
      else {
        System.out.println("Maximum product is "+max);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxProduct( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n < 3) then (     return -1 ) else skip ; 
     arr := arr->sort() ; 
     return Set{arr[0+1] * arr[1+1] * arr[n - 1+1], arr[n - 1+1] * arr[n - 2+1] * arr[n - 3+1]}->max() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-10,-3,5,6,-20} ;
     var n : int ; n := arr->size() ;
     var max : int ; max := maxProduct(arr, n) ;
     if (max = -1) then (     OclFile["System.out"].println("No Triplet Exists") ) else (     OclFile["System.out"].println("Maximum product is " + max) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Deserium {
  static int countDigits(int n){
    int c=0 ;
    do {
      c++;
      n=n/10 ;
    }
    while(n!=0);
    return c ;
  }
  static boolean isDeserium(int x){
    int temp=x ;
    int p=countDigits(x);
    int sum=0 ;
    while(x!=0){
      int digit=x % 10 ;
      sum+=Math.pow(digit,p);
      p--;
      x=x/10 ;
    }
    return(sum==temp);
  }
  public static void main(String[] args){
    int x=135 ;
    if(isDeserium(x))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Deserium {
  static   operation countDigits( n : int) : int
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
   while true do ((     c := c + 1 ; 
     n := n / 10 ) ;
    if (n /= 0) then skip else break) ; 
     return c );
  static   operation isDeserium( x : int) : boolean
  pre: true
  post: true
  activity: (     var temp : int ; temp := x ;
     var p : int ; p := countDigits(x) ;
    var sum : int ; sum := 0 ;
    while (x /= 0) do (     var digit : int ; digit := x mod 10 ;
     sum := sum+(digit->pow(p)) ; 
     p := p - 1 ; 
     x := x / 10 ) ; 
    return (sum = temp) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 135 ;
     if (isDeserium(x)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getMinimumSum(int arr[],int n){
    int fMin=Integer.MAX_VALUE,sMin=Integer.MAX_VALUE,tMin=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]<fMin){
        tMin=sMin ;
        sMin=fMin ;
        fMin=arr[i];
      }
      else if(arr[i]<sMin){
        tMin=sMin ;
        sMin=arr[i];
      }
      else if(arr[i]<tMin){
        tMin=arr[i];
      }
    }
    return(fMin+sMin+tMin);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,-1,5,-2 };
      int n=arr.length ;
      System.out.print(getMinimumSum(arr,n)+"\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getMinimumSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var fMin : int ; fMin := 2147483647 ;
    var sMin : int ; sMin := 2147483647 ;
    var tMin : int ; tMin := 2147483647 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] < fMin) then (     tMin := sMin ; 
     sMin := fMin ; 
     fMin := arr[i+1] ) else     if (arr[i+1] < sMin) then (     tMin := sMin ; 
     sMin := arr[i+1] ) else     if (arr[i+1] < tMin) then (     tMin := arr[i+1] ) else skip ; ;  )  ;     i := i + 1 ) ; 
     return (fMin + sMin + tMin) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,-1,5,-2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(getMinimumSum(arr, n) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int gen(int n){
    if(n==0)return 0 ;
    else if(n==1)return 1 ;
    else if(n % 2==0)return 4*gen(n/2);
    else if(n % 2==1)return 4*gen(n/2)+1 ;
    return 0 ;
  }
  public static void moserDeBruijn(int n){
    for(int i=0 ; i<n ; i++)System.out.print(gen(i)+" ");
    System.out.println();
  }
  public static void main(String args[]){
    int n=15 ;
    System.out.println("First "+n+" terms of "+"Moser-de Bruijn Sequence : ");
    moserDeBruijn(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gen( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else     if (n = 1) then     return 1 else     if (n mod 2 = 0) then     return 4 * gen(n / 2) else     if (n mod 2 = 1) then     return 4 * gen(n / 2) + 1 else skip ; ;  ;  ;  
     return 0 );
  static   operation moserDeBruijn( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(gen(i) + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     OclFile["System.out"].println("First " + n + " terms of " + "Moser-de Bruijn Sequence : ") ; 
     execute moserDeBruijn(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  Main(){
    sc=new Scanner(System.in);
  }
  int ni(){
    return sc.nextInt();
  }
  public static void main(String[] args){
    new Main().run();
  }
  static int[] LUT ;
  static {
    LUT=new int[10001];
    LUT['m']=1000 ;
    LUT['c']=100 ;
    LUT['x']=10 ;
    LUT['i']=1 ;
    LUT[1000]='m' ;
    LUT[100]='c' ;
    LUT[10]='x' ;
    LUT[1]='i' ;
  }
  int encode(String str){
    int sum=0 ;
    int stack=1 ;
    for(char c : str.toCharArray()){
      switch(c){
        case 'm' : case 'c' : case 'x' : case 'i' : sum+=stack*LUT[c];
        stack=1 ;
        break ;
        default : stack=c-'0' ;
      }
    }
    return sum ;
  }
  String decode(int num){
    String str="" ;
    for(int i=1000 ; 0<i ; i/=10){
      int k=num/i ;
      if(k>1){
        str+=k ;
      }
      if(k!=0){
        str+=(char)LUT[i];
      }
      num %=i ;
    }
    return str ;
  }
  void run(){
    int n=ni();
    for(int i=0 ; i<n ; ++i){
      String left=sc.next();
      String right=sc.next();
      System.out.println(decode(encode(left)+encode(right)));
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
  static   attribute LUT : Sequence(int);
  static operation initialiseClass()
  pre: true post: true
  activity:     LUT := Integer.subrange(1,10001)->collect(0) ; 
    LUT['m'+1] := 1000 ; 
    LUT['c'+1] := 100 ; 
    LUT['x'+1] := 10 ; 
    LUT['i'+1] := 1 ; 
    LUT[1000+1] := 'm' ; 
    LUT[100+1] := 'c' ; 
    LUT[10+1] := 'x' ; 
    LUT[1+1] := 'i' ; 
;
   operation encode( str : String) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var stack : int ; stack := 1 ;
     for (c : str->characters()) do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
    if _switchval = 'm' or _switchval = 'c' or _switchval = 'x' or _switchval = 'i' then
    sum := sum+(stack * LUT[c+1]) ; 
    stack := 1 ; 
    break 
   else skip ;
       if true then
     stack := c - ('0')->char2byte() ; 
   else skip ;
 )
 )  ) ; 
     return sum );
   operation decode( num : int) : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
         var i : int ; i := 1000 ; while 0 < i do ( (     var k : int ; k := num / i ;
     if (k > 1) then (     str := str+(k) ) else skip ; 
     if (k /= 0) then (     str := str+(LUT[i+1]->oclAsType(String)) ) else skip ; 
     num := num mod i )  ;     i := i/(10) ) ; 
     return str );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := ni() ;
         var i : int ; i := 0 ; while i < n do ( (     var left : String ; left := sc.getCurrent() ;
     var right : String ; right := sc.getCurrent() ;
     OclFile["System.out"].println(decode(encode(left) + encode(right))) )  ;     i := i + 1 ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if(n==0 && m==0)break ;
      int[] map=new int[n];
      int[] th=new int[m];
      for(int i=0 ; i<n ; i++)map[i]=sc.nextInt();
      for(int i=0 ; i<m ; i++)th[i]=sc.nextInt();
      int now=0 ;
      int idx=0 ;
      int ans=0 ;
      while(now<n-1){
        ans++;
        now+=th[idx++];
        if(now>=n-1)break ;
        now+=map[now];
        if(now<0)now=0 ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if (n = 0 & m = 0) then     break else skip ; 
    var map : Sequence(int) ; map := Integer.subrange(1,n)->collect(0) ;
    var th : Sequence(int) ; th := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     map[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     th[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var now : int ; now := 0 ;
    var idx : int ; idx := 0 ;
    var ans : int ; ans := 0 ;
    while (now < n - 1) do (     ans := ans + 1 ; 
      now := now + th[idx+1]  ; idx := idx + 1 ; 
    if (now >= n - 1) then     break else skip ; 
    now := now+(map[now+1]) ; 
    if (now < 0) then     now := 0 ; else skip ; 
 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  int n,m ;
  int[] b,a ;
  void run(){
    for(; ; ){
      n=sc.nextInt();
      m=sc.nextInt();
      if((n | m)==0){
        break ;
      }
      b=new int[n];
      a=new int[m];
      for(int i=0 ; i<n ; i++){
        b[i]=sc.nextInt();
      }
      for(int i=0 ; i<m ; i++){
        a[i]=sc.nextInt();
      }
      solve();
    }
  }
  void solve(){
    int p=0 ;
    int i ;
    for(i=0 ; i<m ; i++){
      p+=a[i];
      if(p>=n-1){
        break ;
      }
      p+=b[p];
      if(p>=n-1){
        break ;
      }
    }
    println(""+(i+1));
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   attribute n : int;
   attribute b : Sequence(int);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     n := sc.getCurrent()->toInteger() ; 
     m := sc.getCurrent()->toInteger() ; 
    if ((MathLib.bitwiseOr(n,m)) = 0) then (     break ) else skip ; 
    b := Integer.subrange(1,n)->collect(0) ; 
    a := Integer.subrange(1,m)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute solve() ; 
 )  ) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var p : int ; p := 0 ;
     var i : int ;
         i := 0 ; while i < m do ( (     p := p+(a[i+1]) ; 
     if (p >= n - 1) then (     break ) else skip ; 
     p := p+(b[p+1]) ; 
     if (p >= n - 1) then (     break ) else skip )  ;     i := i + 1 ) ; 
     execute println("" + (i + 1)) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    for(; ; ){
      String[] readGame=br.readLine().split(" ");
      int sugorokuNum=Integer.parseInt(readGame[0]);
      int saikoroCnt=Integer.parseInt(readGame[1]);
      int[] sugorokuMasu=new int[sugorokuNum];
      if(sugorokuNum==0){
        break ;
      }
      for(int i=0 ; i<sugorokuNum ; i++){
        int factorCount=Integer.parseInt(br.readLine());
        sugorokuMasu[i]=factorCount ;
      }
      int cnt=0 ;
      int position=0 ;
      for(int i=0 ; i<saikoroCnt ; i++){
        int factorCount=Integer.parseInt(br.readLine());
        cnt++;
        if(position+factorCount>=sugorokuNum-1 || position+factorCount+sugorokuMasu[position+factorCount]>=sugorokuNum-1){
          break ;
        }
        else {
          position+=factorCount+sugorokuMasu[position+factorCount];
        }
      }
      for(int i=0 ; i<saikoroCnt-cnt ; i++){
        br.readLine();
      }
      System.out.println(cnt);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
       while true do ( (     var readGame : Sequence(String) ; readGame := br.readLine()->split(" ") ;
     var sugorokuNum : int ; sugorokuNum := (readGame[0+1])->toInteger() ;
    var saikoroCnt : int ; saikoroCnt := (readGame[1+1])->toInteger() ;
    var sugorokuMasu : Sequence(int) ; sugorokuMasu := Integer.subrange(1,sugorokuNum)->collect(0) ;
    if (sugorokuNum = 0) then (     break ) else skip ; 
        var i : int ; i := 0 ; while i < sugorokuNum do ( (     var factorCount : int ; factorCount := (br.readLine())->toInteger() ;
     sugorokuMasu[i+1] := factorCount )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    var position : int ; position := 0 ;
        var i : int ; i := 0 ; while i < saikoroCnt do ( (     var factorCount : int ; factorCount := (br.readLine())->toInteger() ;
     cnt := cnt + 1 ; 
     if (position + factorCount >= sugorokuNum - 1 or position + factorCount + sugorokuMasu[position + factorCount+1] >= sugorokuNum - 1) then (     break ) else (     position := position+(factorCount + sugorokuMasu[position + factorCount+1]) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < saikoroCnt - cnt do ( (     skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] data=br.readLine().split(" ");
    int[] num=new int[100000];
    for(int i=0 ; i<n ; i++){
      num[Integer.parseInt(data[i])]++;
    }
    int temp=0 ;
    int max=0 ;
    for(int i=0 ; i<=99997 ; i++){
      temp=num[i]+num[i+1]+num[i+2];
      if(temp>max){
        max=temp ;
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var data : Sequence(String) ; data := br.readLine()->split(" ") ;
    var num : Sequence(int) ; num := Integer.subrange(1,100000)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     num[(data[i+1])->toInteger()+1] := num[(data[i+1])->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
    var temp : int ; temp := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i <= 99997 do ( (     temp := num[i+1] + num[i + 1+1] + num[i + 2+1] ; 
     if (temp > max) then (     max := temp ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if((n | m)==0)break ;
      int map[]=new int[n];
      int sai[]=new int[m];
      for(int i=0 ; i<n ; i++)map[i]=sc.nextInt();
      for(int i=0 ; i<m ; i++)sai[i]=sc.nextInt();
      int cnt,p=0 ;
      for(cnt=0 ; cnt<m ; cnt++){
        if(sai[cnt]+p>=n-1)break ;
        p+=sai[cnt]+map[sai[cnt]+p];
        if(p>=n-1){
          break ;
        }
      }
      if(cnt==m)cnt--;
      System.out.println(cnt+1);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,m)) = 0) then     break else skip ; 
    var map : Sequence(int) ; map := Integer.subrange(1,n)->collect(0) ;
    var sai : Sequence(int) ; sai := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     map[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     sai[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var cnt : int ;
    var p : int ; p := 0 ;
        cnt := 0 ; while cnt < m do ( (     if (sai[cnt+1] + p >= n - 1) then     break else skip ; 
     p := p+(sai[cnt+1] + map[sai[cnt+1] + p+1]) ; 
     if (p >= n - 1) then (     break ) else skip )  ;     cnt := cnt + 1 ) ; 
    if (cnt = m) then     cnt := cnt - 1 ; else skip ; 
    OclFile["System.out"].println(cnt + 1) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findMostOccurringChar(Vector<String>str){
    int[] hash=new int[26];
    for(int i=0 ; i<str.size(); i++){
      for(int j=0 ; j<str.get(i).length(); j++){
        hash[str.get(i).charAt(j)-97]++;
      }
    }
    int max=0 ;
    for(int i=0 ; i<26 ; i++){
      max=hash[i]>hash[max] ? i : max ;
    }
    System.out.print((char)(max+97)+"\n");
  }
  public static void main(String[] args){
    Vector<String>str=new Vector<String>();
    str.add("animal");
    str.add("zebra");
    str.add("lion");
    str.add("giraffe");
    findMostOccurringChar(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMostOccurringChar( str : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var hash : Sequence(int) ; hash := Integer.subrange(1,26)->collect(0) ;
         var i : int ; i := 0 ; while i < str->size() do ( (         var j : int ; j := 0 ; while j < str->at(i+1)->size() do ( (     hash[str->at(i+1)->at(j+1) - 97+1] := hash[str->at(i+1)->at(j+1) - 97+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < 26 do ( (     max := if hash[i+1] > hash[max+1] then i else max endif )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print((max + 97)->oclAsType(String) + "\n") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := Sequence{} ;
     str := str->including("animal") ; 
    str := str->including("zebra") ; 
    str := str->including("lion") ; 
    str := str->including("giraffe") ; 
    execute findMostOccurringChar(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int val(char c){
    if(c>='0' && c<='9')return(int)c-'0' ;
    else return(int)c-'A'+10 ;
  }
  static int toDeci(String str,int base){
    int len=str.length();
    int power=1 ;
    int num=0 ;
    int i ;
    for(i=len-1 ; i>=0 ; i--){
      if(val(str.charAt(i))>=base){
        System.out.println("Invalid Number");
        return-1 ;
      }
      num+=val(str.charAt(i))*power ;
      power=power*base ;
    }
    return num ;
  }
  public static void main(String[] args){
    String str="11A" ;
    int base=16 ;
    System.out.println("Decimal equivalent of "+str+" in base "+base+" is "+" "+toDeci(str,base));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation val( c : String) : int
  pre: true
  post: true
  activity: (     if (c >= '0' & c <= '9') then     return c->oclAsType(int) - ('0')->char2byte() else     return c->oclAsType(int) - ('A')->char2byte() + 10 );
  static   operation toDeci( str : String, base : int) : int
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     var power : int ; power := 1 ;
    var num : int ; num := 0 ;
    var i : int ;
        i := len - 1 ; while i >= 0 do ( (     if (val(str->at(i+1)) >= base) then (     OclFile["System.out"].println("Invalid Number") ; 
     return -1 ) else skip ; 
     num := num+(val(str->at(i+1)) * power) ; 
     power := power * base )  ;     i := i - 1 ) ; 
    return num 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "11A" ;
     var base : int ; base := 16 ;
     OclFile["System.out"].println("Decimal equivalent of " + str + " in base " + base + " is " + " " + toDeci(str, base)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float pi=3.14159f ;
  static float volume(float r){
    float vol ;
    vol=((float)4/(float)3)*(pi*r*r*r);
    return vol ;
  }
  static float surface_area(float r){
    float sur_ar ;
    sur_ar=4*pi*r*r ;
    return sur_ar ;
  }
  public static void main(String[] args){
    float radius=12 ;
    float vol,sur_area ;
    vol=volume(radius);
    sur_area=surface_area(radius);
    System.out.println("Volume Of Sphere :"+vol);
    System.out.println("Surface Area Of Sphere :"+sur_area);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute pi : double := 3.14159f;
  static   operation volume( r : double) : double
  pre: true
  post: true
  activity: (     var vol : double ;
     vol := (4->oclAsType(double) / 3->oclAsType(double)) * (pi * r * r * r) ; 
     return vol );
  static   operation surface_area( r : double) : double
  pre: true
  post: true
  activity: (     var sur_ar : double ;
     sur_ar := 4 * pi * r * r ; 
     return sur_ar );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var radius : double ; radius := 12 ;
     var vol : double ;
    var sur_area : double ;
    vol := volume(radius) ; 
    sur_area := surface_area(radius) ; 
    OclFile["System.out"].println("Volume Of Sphere :" + vol) ; 
    OclFile["System.out"].println("Surface Area Of Sphere :" + sur_area) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int count(int arr[],int n,int k){
    Arrays.sort(arr);
    int cnt=0 ;
    int i=0,j=1 ;
    while(i<n && j<n){
      j=(j<=i)?(i+1): j ;
      while(j<n &&(arr[j]-arr[i])<k)j++;
      cnt+=(n-j);
      i++;
    }
    return cnt ;
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3,4 };
      int n=arr.length ;
      int k=2 ;
      System.out.println(count(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation count( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var cnt : int ; cnt := 0 ;
    var i : int ; i := 0 ;
    var j : int ; j := 1 ;
    while (i < n & j < n) do (     j := if (j <= i) then (i + 1) else j endif ; 
     while (j < n & (arr[j+1] - arr[i+1]) < k) do     j := j + 1 ; ; 
     cnt := cnt+((n - j)) ; 
     i := i + 1 ) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(count(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.List ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.math.BigDecimal ;
import java.math.RoundingMode ;
import java.text.DecimalFormat ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collection ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class main {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    int n=in.nextInt(),p=in.nextInt();
    int unit[]=new int[n],stored[]=new int[n];
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      unit[i]=in.nextInt();
      sum+=unit[i];
      stored[i]=in.nextInt();
    }
    if(sum<=p){
      System.out.println("-1");
      return ;
    }
    double l=0,r=1e10+1 ;
    int total=200 ;
    while(total-->0){
      double mid=(l+r)/2 ;
      double need=0 ;
      for(int i=0 ; i<n ; i++){
        need+=Math.max(0,(double)unit[i]*mid-stored[i]);
      }
      if(need>mid*p){
        r=mid ;
      }
      else l=mid ;
    }
    System.out.println(l);
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(){
    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());
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var n : int ; n := in.nextInt() ;
    var p : int ; p := in.nextInt() ;
    var unit : Sequence(int) ; unit := Integer.subrange(1,n)->collect(0) ;
    var stored : Sequence(void) ; stored := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     unit[i+1] := in.nextInt() ; 
     sum := sum+(unit[i+1]) ; 
     stored[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    if (sum <= p) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
    var l : double ; l := 0 ;
    var r : double ; r := 1e10 + 1 ;
    var total : int ; total := 200 ;
        while (total > 0) do (        total := total - 1 ;     skip ; (     var mid : double ; mid := (l + r) / 2 ;
     var need : double ; need := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     need := need+(Set{0, unit[i+1]->oclAsType(double) * mid - stored[i+1]}->max()) )  ;     i := i + 1 ) ; 
     if (need > mid * p) then (     r := mid ) else     l := mid ; ) ;  ) ;  
    OclFile["System.out"].println(l) ; 
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new aoj1137().doIt();
  }
  class aoj1137 {
    char keta[]={
      'i','x','c','m' };
      char keta2[]={
        '2','3','4','5','6','7','8','9' };
        int number(char ctr[]){
          int result=0 ;
          int num2=1 ;
          int num=1 ;
          for(int i=0 ; i<ctr.length ; i++){
            for(int j=0 ; j<4 ; j++){
              if(keta[j]==ctr[i]){
                result=result+(num*num2);
                num2=1 ;
                break ;
              }
              num=num*10 ;
            }
            num=1 ;
            for(int j=0 ; j<8 ; j++){
              if(keta2[j]==ctr[i])num2=num2*(j+2);
            }
          }
          return result ;
        }
        void doIt(){
          int n=sc.nextInt();
          for(int i=0 ; i<n ; i++){
            String a=sc.next();
            String b=sc.next();
            char ctra[]=a.toCharArray();
            char ctrb[]=b.toCharArray();
            int sum=number(ctra)+number(ctrb);
            int m=1000 ;
            for(int j=3 ; j>=0 ; j--){
              int ans=sum/m ;
              if(ans>1){
                System.out.print(ans);
                System.out.print(keta[j]);
              }
              else if(ans==1){
                System.out.print(keta[j]);
              }
              sum=sum % m ;
              m=m/10 ;
            }
            System.out.println();
          }
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     aoj1137.newaoj1137().doIt() );
 class aoj1137 {
   attribute keta : String := Sequence{'i','x','c','m'};
   attribute keta2 : String := Sequence{'2','3','4','5','6','7','8','9'};
   operation number( ctr : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var num2 : int ; num2 := 1 ;
    var num : int ; num := 1 ;
        var i : int ; i := 0 ; while i < ctr->size() do ( (         var j : int ; j := 0 ; while j < 4 do ( (     if (keta[j+1] = ctr[i+1]) then (     result := result + (num * num2) ; 
     num2 := 1 ; 
     break ) else skip ; 
     num := num * 10 )  ;     j := j + 1 ) ; 
     num := 1 ; 
         var j : int ; j := 0 ; while j < 8 do ( (     if (keta2[j+1] = ctr[i+1]) then     num2 := num2 * (j + 2) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return result 
 );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : String ; a := sc.getCurrent() ;
     var b : String ; b := sc.getCurrent() ;
    var ctra : Sequence(String) ; ctra := a->characters() ;
    var ctrb : Sequence(String) ; ctrb := b->characters() ;
    var sum : int ; sum := number(ctra) + number(ctrb) ;
    var m : int ; m := 1000 ;
        var j : int ; j := 3 ; while j >= 0 do ( (     var ans : int ; ans := sum / m ;
     if (ans > 1) then (     OclFile["System.out"].print(ans) ; 
     OclFile["System.out"].print(keta[j+1]) ) else     if (ans = 1) then (     OclFile["System.out"].print(keta[j+1]) ) else skip ; ;  
     sum := sum mod m ; 
     m := m / 10 )  ;     j := j - 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeTwentySix {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int c=input.nextInt();
    int l=input.nextInt();
    int r=input.nextInt();
    int count=0 ;
    int t=input.nextInt();
    int[] array=new int[t];
    for(int i=0 ; i<t ; i++){
      array[i]=input.nextInt();
    }
    for(int i=0 ; i<t ; i++){
      if(array[i]<r & array[i]>l){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeTwentySix {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : int ; c := input.getCurrent()->toInteger() ;
    var l : int ; l := input.getCurrent()->toInteger() ;
    var r : int ; r := input.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var t : int ; t := input.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,t)->collect(0) ;
        var i : int ; i := 0 ; while i < t do ( (     array[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < t do ( (     if (array[i+1] < r & array[i+1] > l) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int p=s.nextInt();
    int l=s.nextInt();
    int r=s.nextInt();
    int n=s.nextInt();
    int counter=0 ;
    for(int i=0 ; i<n ; i++){
      int a=s.nextInt();
      if(l<a && a<r){
        counter++;
      }
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : int ; p := s.getCurrent()->toInteger() ;
    var l : int ; l := s.getCurrent()->toInteger() ;
    var r : int ; r := s.getCurrent()->toInteger() ;
    var n : int ; n := s.getCurrent()->toInteger() ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := s.getCurrent()->toInteger() ;
     if (l < a & a < r) then (     counter := counter + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Five {
  public static void main(String[] args)throws IOException {
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer stringTokenizer=new StringTokenizer(bufferedReader.readLine());
    int a=Integer.parseInt(stringTokenizer.nextToken());
    int b=Integer.parseInt(stringTokenizer.nextToken());
    int c=Integer.parseInt(stringTokenizer.nextToken());
    int n=Integer.parseInt(bufferedReader.readLine());
    stringTokenizer=new StringTokenizer(bufferedReader.readLine());
    int j=0 ;
    int sum=0 ;
    while(j++<n){
      int val=Integer.parseInt(stringTokenizer.nextToken());
      if(val>b && val<c)sum++;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Five {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var stringTokenizer : OclIterator ; stringTokenizer := OclIterator.newOclIterator_String(bufferedReader.readLine()) ;
    var a : int ; a := (stringTokenizer.next())->toInteger() ;
    var b : int ; b := (stringTokenizer.next())->toInteger() ;
    var c : int ; c := (stringTokenizer.next())->toInteger() ;
    var n : int ; n := (bufferedReader.readLine())->toInteger() ;
    stringTokenizer := OclIterator.newOclIterator_String(bufferedReader.readLine()) ; 
    var j : int ; j := 0 ;
    var sum : int ; sum := 0 ;
        while (j < n) do (        j := j + 1 ;     skip ; (     var val : int ; val := (stringTokenizer.next())->toInteger() ;
     if (val > b & val < c) then     sum := sum + 1 ; else skip ) ;  ) ;  
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
    }
    System.out.println(solve(N,A));
  }
  private static int solve(int N,int[] A){
    Arrays.sort(A);
    int max=-1 ;
    int prev2=0 ;
    int prev1=0 ;
    int current=0 ;
    int current_a=-1 ;
    for(int i=0 ; i<N ; i++){
      int a=A[i];
      if(a!=current_a){
        max=Math.max(prev2+prev1+current,max);
        if(current_a+1==a){
          prev2=prev1 ;
          prev1=current ;
        }
        else if(current_a+2==a){
          prev2=current ;
          prev1=0 ;
        }
        else {
          prev2=0 ;
          prev1=0 ;
        }
        current_a=a ;
        current=1 ;
      }
      else {
        current++;
      }
    }
    max=Math.max(prev2+prev1+current,max);
    return max ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(N, A)) ; 
 );
  static   operation solve( N : int, A : Sequence(int)) : int
  pre: true
  post: true
  activity: (     A := A->sort() ; 
     var max : int ; max := -1 ;
    var prev2 : int ; prev2 := 0 ;
    var prev1 : int ; prev1 := 0 ;
    var current : int ; current := 0 ;
    var current_a : int ; current_a := -1 ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := A[i+1] ;
     if (a /= current_a) then (     max := Set{prev2 + prev1 + current, max}->max() ; 
     if (current_a + 1 = a) then (     prev2 := prev1 ; 
     prev1 := current ) else     if (current_a + 2 = a) then (     prev2 := current ; 
     prev1 := 0 ) else (     prev2 := 0 ; 
     prev1 := 0 ) ;  ;  
     current_a := a ; 
     current := 1 ) else (     current := current + 1 ) )  ;     i := i + 1 ) ; 
    max := Set{prev2 + prev1 + current, max}->max() ; 
    return max 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.*;
public class App {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws Exception {
    if(System.getProperty("ONLINE_JUDGE")==null){
      File inputFile=new File("/Users/vipinjain/self/cp/input.txt");
      File outputFile=new File("/Users/vipinjain/self/cp/output.txt");
      br=new BufferedReader(new FileReader(inputFile));
      bw=new BufferedWriter(new FileWriter(outputFile));
    }
    int tests ;
    tests=1 ;
    while(tests-->0){
      solve();
    }
    bw.flush();
    bw.close();
    br.close();
  }
  static int getNumberOfDays(int month){
    switch(month){
      case 1 : case 3 : case 5 : case 7 : case 8 : case 10 : case 12 : return 31 ;
      case 2 : return 28 ;
      default : return 30 ;
    }
  }
  static void solve()throws Exception {
    String[] tmp=br.readLine().split(" ");
    int a=Integer.parseInt(tmp[0]);
    int b=Integer.parseInt(tmp[1]);
    int c=Integer.parseInt(tmp[2]);
    int n=Integer.parseInt(br.readLine());
    int[] arr=Stream.of(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    int money=0 ;
    for(int num : arr){
      if(num>b && num<c){
        money++;
      }
    }
    bw.write(money+"");
    bw.write("\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null) then (     var inputFile : OclFile ; inputFile := OclFile("/Users/vipinjain/self/cp/input.txt") ;
     var outputFile : OclFile ; outputFile := OclFile("/Users/vipinjain/self/cp/output.txt") ;
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputFile)) ; 
     bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputFile)) ) else skip ; 
     var tests : int ;
    tests := 1 ; 
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation getNumberOfDays( month : int) : int
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (month) ; 
    if _switchval = 1 or _switchval = 3 or _switchval = 5 or _switchval = 7 or _switchval = 8 then
   if _switchval = 10 then
   if _switchval = 12 then
    return 31 
   else skip ;
       if _switchval = 2 then
     return 28 
   else skip ;
       if true then
     return 30 
   else skip ;
 )
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var tmp : Sequence(String) ; tmp := br.readLine()->split(" ") ;
     var a : int ; a := (tmp[0+1])->toInteger() ;
    var b : int ; b := (tmp[1+1])->toInteger() ;
    var c : int ; c := (tmp[2+1])->toInteger() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var arr : Sequence(int) ; arr := Sequence{br.readLine()->split(" ")}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var money : int ; money := 0 ;
    for (num : arr) do ( (     if (num > b & num < c) then (     money := money + 1 ) else skip )  ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    System.out.println(solve(S)? "Yes" : "No");
    sc.close();
  }
  static boolean solve(String S){
    return S.chars().distinct().count()==3 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
     OclFile["System.out"].println(if solve(S) then "Yes" else "No" endif) ; 
     skip );
  static   operation solve( S : String) : boolean
  pre: true
  post: true
  activity: (     return S.chars()->asOrderedSet()->size() = 3 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws Exception {
    String line=readLine();
    StringTokenizer st=new StringTokenizer(line,"");
    String s=(String)st.nextToken();
    String[] strArray=s.split("");
    String a=strArray[0];
    String b=strArray[1];
    String c=strArray[2];
    if((a.equals(b))||(a.equals(c))||(b.equals(c))){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
    }
  }
  private static String readLine()throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    return br.readLine();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var line : String ; line := readLine() ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String_String(line, "") ;
    var s : String ; s := st.next()->oclAsType(String) ;
    var strArray : Sequence(String) ; strArray := s->split("") ;
    var a : String ; a := strArray[0+1] ;
    var b : String ; b := strArray[1+1] ;
    var c : String ; c := strArray[2+1] ;
    if ((a = b) or (a = c) or (b = c)) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) ;  
 );
  static   operation readLine() : String
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     return br.readLine() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  static char[][] map ;
  static int N ;
  static int M ;
  static boolean flag ;
  static int ans ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String string=sc.next();
    char[] cs=string.toCharArray();
    boolean[] flag=new boolean[3];
    for(int i=0 ; i<3 ; i++){
      if(cs[i]=='a'){
        flag[0]=true ;
      }
      else if(cs[i]=='b'){
        flag[1]=true ;
      }
      else if(cs[i]=='c'){
        flag[2]=true ;
      }
    }
    if(flag[0] && flag[1] && flag[2]){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
class Pair implements Comparable {
  String from ;
  int end ;
  @ Override public int compareTo(Object other){
    Pair otherpair=(Pair)other ;
    return end-otherpair.end ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute map : Sequence(Sequence(String));
  static   attribute N : int;
  static   attribute M : int;
  static   attribute flag : boolean;
  static   attribute ans : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var string : String ; string := sc.getCurrent() ;
    var cs : Sequence(String) ; cs := string->characters() ;
    var flag : Sequence(boolean) ; flag := Integer.subrange(1,3)->collect(false) ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (cs[i+1] = 'a') then (     flag[0+1] := true ) else     if (cs[i+1] = 'b') then (     flag[1+1] := true ) else     if (cs[i+1] = 'c') then (     flag[2+1] := true ) else skip ; ;  )  ;     i := i + 1 ) ; 
    if (flag[0+1] & flag[1+1] & flag[2+1]) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}
class Pair implements OclAny {
   attribute from : String;
   attribute end : int;
      operation compareTo( other : OclAny) : int
  pre: true
  post: true
  activity: (     var otherpair : Map ; otherpair := other->oclAsType(Map) ;
     return end - otherpair.end );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String[] ss=s.split("");
    Arrays.sort(ss);
    if(String.join("",ss).equals("abc")){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var ss : Sequence(String) ; ss := s->split("") ;
    ss := ss->sort() ; 
    if (join("", ss) = "abc") then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder s=new StringBuilder();
    s.append(br.readLine());
    System.out.println(new Problem(s).solve());
    br.close();
  }
}
class Problem {
  StringBuilder s ;
  public Problem(StringBuilder s){
    this.s=s ;
  }
  public String solve(){
    String result="No" ;
    if(s.toString().contains("a")&& s.toString().contains("b")&& s.toString().contains("c")){
      result="Yes" ;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := StringLib.newString() ;
    s := s + StringLib.newString(br.readLine()) ; 
    OclFile["System.out"].println(Problem.newProblem(s).solve()) ; 
    skip ; 
 );
}
class Problem {
   attribute s : String;
   static operation newProblem( s : String) : Problem
  pre: true
  post: true
  activity:
  ( var self : Problem ;
    self := createProblem();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     self.s := s );
   operation solve() : String
  pre: true
  post: true
  activity: (     var result : String ; result := "No" ;
     if (s+""->includes("a") & s+""->includes("b") & s+""->includes("c")) then (     result := "Yes" ) else skip ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class LittleRobberGirlZoo {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      arr[i]=sc.nextInt();
    }
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<n ; j++){
        if(arr[j]>arr[j+1]){
          int temp=arr[j];
          arr[j]=arr[j+1];
          arr[j+1]=temp ;
          System.out.println(j+" "+(j+1));
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class LittleRobberGirlZoo {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j < n do ( (     if (arr[j+1] > arr[j + 1+1]) then (     var temp : int ; temp := arr[j+1] ;
     arr[j+1] := arr[j + 1+1] ; 
     arr[j + 1+1] := temp ; 
     OclFile["System.out"].println(j + " " + (j + 1)) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.geom.*;
import java.io.*;
public class Main {
  private void doit(){
    Scanner sc=new Scanner(System.in);
    int dataset=sc.nextInt();
    while(dataset-->0){
      String a=sc.next();
      String b=sc.next();
      int anum=solve(a);
      int bnum=solve(b);
      String c=tostr(anum+bnum);
      System.out.println(c);
    }
  }
  private int solve(String a){
    int mul=1 ;
    int res=0 ;
    int[] value=new int[26];
    value['m'-'a']=1000 ;
    value['c'-'a']=100 ;
    value['x'-'a']=10 ;
    value['i'-'a']=1 ;
    for(int i=0 ; i<a.length(); i++){
      if(Character.isDigit(a.charAt(i))){
        mul=a.charAt(i)-'0' ;
      }
      else {
        res+=value[a.charAt(i)-'a']*mul ;
        mul=1 ;
      }
    }
    return res ;
  }
  private String tostr(int num){
    StringBuilder sb=new StringBuilder();
    String[] c={
      "m","c","x","i" };
      for(int i=1000,count=0 ; i!=0 ; i=i/10,count++){
        if(num/i==0){
          continue ;
        }
        int temp=num/i ;
        if(temp!=1){
          sb.append(num/i);
        }
        sb.append(c[count]);
        num=num % i ;
      }
      return sb.toString();
    }
    private void debug(Object...o){
      System.out.println("debug="+Arrays.deepToString(o));
    }
    public static void main(String[] args){
      new Main().doit();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dataset : int ; dataset := sc.getCurrent()->toInteger() ;
         while (dataset > 0) do (        dataset := dataset - 1 ;     skip ; (     var a : String ; a := sc.getCurrent() ;
     var b : String ; b := sc.getCurrent() ;
    var anum : int ; anum := solve(a) ;
    var bnum : int ; bnum := solve(b) ;
    var c : String ; c := tostr(anum + bnum) ;
    OclFile["System.out"].println(c) ; 
 ) ;  ) );
   operation solve( a : String) : int
  pre: true
  post: true
  activity: (     var mul : int ; mul := 1 ;
     var res : int ; res := 0 ;
    var value : Sequence(int) ; value := Integer.subrange(1,26)->collect(0) ;
    value[('m')->char2byte() - ('a')->char2byte()+1] := 1000 ; 
    value[('c')->char2byte() - ('a')->char2byte()+1] := 100 ; 
    value[('x')->char2byte() - ('a')->char2byte()+1] := 10 ; 
    value[('i')->char2byte() - ('a')->char2byte()+1] := 1 ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     if ((a->at(i+1) + "")->isMatch("[0-9]")) then (     mul := a->at(i+1) - ('0')->char2byte() ) else (     res := res+(value[a->at(i+1) - ('a')->char2byte()+1] * mul) ; 
     mul := 1 ) )  ;     i := i + 1 ) ; 
    return res 
 );
   operation tostr( num : int) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     var c : Sequence(String) ; c := Sequence{"m","c","x","i"} ;
         var i : int ; i := 1000 ;
    var count : int ; count := 0 ; while i /= 0 do ( (     if (num / i = 0) then (     continue ) else skip ; 
     var temp : int ; temp := num / i ;
    if (temp /= 1) then (     sb := sb + StringLib.newString(num / i) ) else skip ; 
    sb := sb + StringLib.newString(c[count+1]) ; 
    num := num mod i ; 
 )  ;     i := i / 10 ;     count := count + 1 ) ; 
     return sb+"" );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class div_2_359_b {
  public static void main(String args[]){
    FScanner in=new FScanner();
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt();
    int a[]=in.readArray(n);
    for(int i=n-1 ; i>=0 ; i--){
      for(int j=0 ; j<i ; j++){
        if(a[j]>a[j+1]){
          int temp=a[j];
          a[j]=a[j+1];
          a[j+1]=temp ;
          out.println((j+1)+" "+(j+2));
        }
      }
    }
    out.close();
  }
  static class FScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer sb=new StringTokenizer("");
    String next(){
      while(! sb.hasMoreTokens()){
        try {
          sb=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
        }
      }
      return sb.nextToken();
    }
    String nextLine(){
      try {
        return br.readLine();
      }
      catch(IOException e){
      }
      return "" ;
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    int[] readArray(int n){
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    float nextFloat(){
      return Float.parseFloat(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class div{
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FScanner ; in := FScanner.newFScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.nextInt() ;
    var a : Sequence(int) ; a := in.readArray(n) ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < i do ( (     if (a[j+1] > a[j + 1+1]) then (     var temp : int ; temp := a[j+1] ;
     a[j+1] := a[j + 1+1] ; 
     a[j + 1+1] := temp ; 
     skip ) else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    skip ; 
 );
  static class FScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute sb : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(sb.hasNext())) do (     try (     sb := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ) ; 
     return sb.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do skip
     return "" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}
_359_b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FScanner ; in := FScanner.newFScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.nextInt() ;
    var a : Sequence(int) ; a := in.readArray(n) ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < i do ( (     if (a[j+1] > a[j + 1+1]) then (     var temp : int ; temp := a[j+1] ;
     a[j+1] := a[j + 1+1] ; 
     a[j + 1+1] := temp ; 
     skip ) else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    skip ; 
 );
  static class FScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute sb : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(sb.hasNext())) do (     try (     sb := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ) ; 
     return sb.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do skip
     return "" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class LittleRobberGirlsZoo {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int temp=0 ;
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      for(int j=1 ; j<(n-i); j++){
        if(arr[j-1]>arr[j]){
          temp=arr[j-1];
          arr[j-1]=arr[j];
          arr[j]=temp ;
          System.out.println((j)+" "+(j+1));
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class LittleRobberGirlsZoo {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var temp : int ; temp := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 1 ; while j < (n - i) do ( (     if (arr[j - 1+1] > arr[j+1]) then (     temp := arr[j - 1+1] ; 
     arr[j - 1+1] := arr[j+1] ; 
     arr[j+1] := temp ; 
     OclFile["System.out"].println((j) + " " + (j + 1)) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    while(in.hasNextLine()){
      int R=in.nextInt();
      int C=in.nextInt();
      if(R==0 && C==0)break ;
      HashMap<Character,Loc>hm=new HashMap<Character,Loc>();
      for(int i=0 ; i<R ; i++){
        String str=in.next();
        for(int j=0 ; j<C ; j++){
          char c=str.charAt(j);
          if(c=='_')continue ;
          hm.put(c,new Loc(i,j));
        }
      }
      String str=in.next();
      int iPos=0 ;
      int jPos=0 ;
      int count=str.length();
      for(int i=0 ; i<str.length(); i++){
        Loc loc=hm.get(str.charAt(i));
        count+=Math.abs(iPos-loc.i)+Math.abs(jPos-loc.j);
        iPos=loc.i ;
        jPos=loc.j ;
      }
      System.out.println(count);
    }
  }
  public static class Loc {
    int i ;
    int j ;
    public Loc(int i,int j){
      this.i=i ;
      this.j=j ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNextLine()) do (     var R : int ; R := in.getCurrent()->toInteger() ;
     var C : int ; C := in.getCurrent()->toInteger() ;
    if (R = 0 & C = 0) then     break else skip ; 
    var hm : Map(String,Loc) ; hm := Map{} ;
        var i : int ; i := 0 ; while i < R do ( (     var str : String ; str := in.getCurrent() ;
         var j : int ; j := 0 ; while j < C do ( (     var c : String ; c := str->at(j+1) ;
     if (c = '_') then     continue else skip ; 
     hm := hm->union(Map{c |-> Loc.newLoc(i, j)}) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var str : String ; str := in.getCurrent() ;
    var iPos : int ; iPos := 0 ;
    var jPos : int ; jPos := 0 ;
    var count : int ; count := str->size() ;
        var i : int ; i := 0 ; while i < str->size() do ( (     var loc : Loc ; loc := hm->at(str->at(i+1)) ;
     count := count+(if (iPos)->char2byte() - loc.i < 0 then -((iPos)->char2byte() - loc.i) else (iPos)->char2byte() - loc.i endif + if jPos - loc.j < 0 then -(jPos - loc.j) else jPos - loc.j endif) ; 
     iPos := loc.i ; 
     jPos := loc.j )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
  static class Loc {
   attribute i : int;
   attribute j : int;
   static operation newLoc( i : int, j : int) : Loc
  pre: true
  post: true
  activity:
  ( var self : Loc ;
    self := createLoc();
    self.initialise(i, j);
    return self );
  operation initialise( i : int, j : int) : void
  pre: true  post: true
  activity: (     self.i := i ; 
     self.j := j );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class amd {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int m=s.nextInt();
      HashSet<Integer>hs=new HashSet<>();
      for(int i=1 ; i<=m ; i++){
        int a=s.nextInt();
        int b=s.nextInt();
        int c=s.nextInt();
        hs.add(b);
      }
      int node=0 ;
      for(int i=1 ; i<=n ; i++){
        if(! hs.contains(i)){
          node=i ;
          break ;
        }
      }
      for(int i=1 ; i<=n ; i++){
        if(i!=node)System.out.println(node+" "+i);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class amd {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var m : int ; m := s.getCurrent()->toInteger() ;
    var hs : Set(int) ; hs := Set{} ;
        var i : int ; i := 1 ; while i <= m do ( (     var a : int ; a := s.getCurrent()->toInteger() ;
     var b : int ; b := s.getCurrent()->toInteger() ;
     var c : int ; c := s.getCurrent()->toInteger() ;
     hs := hs->including(b) )  ;     i := i + 1 ) ; 
    var node : int ; node := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (not(hs->includes(i))) then (     node := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (i /= node) then     OclFile["System.out"].println(node + " " + i) ; else skip )  ;     i := i + 1 ) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1583 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      int M=in.nextInt();
      boolean[] used=new boolean[N];
      for(int m=0 ; m<M ; m++){
        in.nextInt();
        int b=in.nextInt()-1 ;
        in.nextInt();
        used[b]=true ;
      }
      int center=0 ;
      while(used[center])center++;
      StringBuilder output=new StringBuilder();
      for(int n=0 ; n<N ; n++){
        if(n!=center){
          output.append((n+1)+" "+(center+1)+"\n");
        }
      }
      System.out.print(output);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1583 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var M : int ; M := in.getCurrent()->toInteger() ;
    var used : Sequence(boolean) ; used := Integer.subrange(1,N)->collect(false) ;
        var m : int ; m := 0 ; while m < M do ( (     skip ; 
     var b : int ; b := in.getCurrent()->toInteger() - 1 ;
     skip ; 
     used[b+1] := true )  ;     m := m + 1 ) ; 
    var center : int ; center := 0 ;
    while (used[center+1]) do     center := center + 1 ; ; 
    var output : String ; output := StringLib.newString() ;
        var n : int ; n := 0 ; while n < N do ( (     if (n /= center) then (     output := output + StringLib.newString((n + 1) + " " + (center + 1) + "\n") ) else skip )  ;     n := n + 1 ) ; 
    OclFile["System.out"].print(output) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  public static final Long mod=Long.valueOf(998244353);
  public static final int N=200020 ;
  public static Long[] ch=new Long[N];
  public static int[] deg=new int[N];
  public static void main(String args[]){
    Scanner in ;
    PrintStream out ;
    try {
      in=new Scanner(new FileInputStream("java.in"));
      out=new PrintStream("java.out");
    }
    catch(FileNotFoundException e){
      in=new Scanner(new BufferedInputStream(System.in));
      out=System.out ;
    }
    ch[0]=Long.valueOf(1);
    for(int i=1 ; i<N ; i++){
      ch[i]=(ch[i-1]*i)% mod ;
    }
    int n=in.nextInt();
    Long ans=Long.valueOf(n);
    for(int i=1,u,v ; i<n ; i++){
      u=in.nextInt();
      v=in.nextInt();
      deg[u]++;
      deg[v]++;
    }
    for(int i=1 ; i<=n ; i++){
      ans=ans*ch[deg[i] ] % mod ;
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute mod : long := (998244353)->toLong();
  static    attribute N : int := 200020;
  static   attribute ch : Sequence(long) := Integer.subrange(1,N)->collect(null);
  static   attribute deg : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ;
     var out : OclFile ;
    try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("java.in"))) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile("java.out")) )   catch (e : FileNotFoundException) do (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile["System.out"] )
    ch[0+1] := (1)->toLong() ; 
        var i : int ; i := 1 ; while i < N do ( (     ch[i+1] := (ch[i - 1+1] * i) mod mod )  ;     i := i + 1 ) ; 
    var n : int ; n := in.getCurrent()->toInteger() ;
    var ans : long ; ans := (n)->toLong() ;
        var i : int ; i := 1 ;
    var u : int ;
    var v : int ; while i < n do ( (     u := in.getCurrent()->toInteger() ; 
     v := in.getCurrent()->toInteger() ; 
     deg[u+1] := deg[u+1] + 1 ; 
     deg[v+1] := deg[v+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     ans := ans * ch[deg[i+1]+1] mod mod )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  public static final Long mod=Long.valueOf(998244353);
  public static final int N=200020 ;
  public static Long[] ch=new Long[N];
  public static int[] deg=new int[N];
  public static void main(String args[]){
    Scanner in ;
    PrintStream out ;
    in=new Scanner(new BufferedInputStream(System.in));
    out=System.out ;
    ch[0]=Long.valueOf(1);
    for(int i=1 ; i<N ; i++){
      ch[i]=(ch[i-1]*i)% mod ;
    }
    int n=in.nextInt();
    Long ans=Long.valueOf(n);
    for(int i=1,u,v ; i<n ; i++){
      u=in.nextInt();
      v=in.nextInt();
      deg[u]++;
      deg[v]++;
    }
    for(int i=1 ; i<=n ; i++){
      ans=ans*ch[deg[i] ] % mod ;
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute mod : long := (998244353)->toLong();
  static    attribute N : int := 200020;
  static   attribute ch : Sequence(long) := Integer.subrange(1,N)->collect(null);
  static   attribute deg : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ;
     var out : OclFile ;
    in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
    out := OclFile["System.out"] ; 
    ch[0+1] := (1)->toLong() ; 
        var i : int ; i := 1 ; while i < N do ( (     ch[i+1] := (ch[i - 1+1] * i) mod mod )  ;     i := i + 1 ) ; 
    var n : int ; n := in.getCurrent()->toInteger() ;
    var ans : long ; ans := (n)->toLong() ;
        var i : int ; i := 1 ;
    var u : int ;
    var v : int ; while i < n do ( (     u := in.getCurrent()->toInteger() ; 
     v := in.getCurrent()->toInteger() ; 
     deg[u+1] := deg[u+1] + 1 ; 
     deg[v+1] := deg[v+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     ans := ans * ch[deg[i+1]+1] mod mod )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[]){
    FastReader input=new FastReader();
    PrintWriter out=new PrintWriter(System.out);
    int T=1 ;
    while(T-->0){
      int n=input.nextInt();
      long m=998244353 ;
      int deg[]=new int[n+1];
      for(int i=0 ; i<n-1 ; i++){
        int u=input.nextInt();
        int v=input.nextInt();
        deg[u]++;
        deg[v]++;
      }
      long fac[]=new long[n+1];
      fac[0]=1 ;
      for(int i=1 ; i<=n ; i++){
        fac[i]=(fac[i-1]*i)% m ;
      }
      long ans=1 ;
      for(int i=1 ; i<=n ; i++){
        ans=(ans*fac[deg[i] ])% m ;
      }
      ans=(ans*n)% m ;
      out.println(ans);
    }
    out.close();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastReader ; input := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := 1 ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := input.nextInt() ;
     var m : long ; m := 998244353 ;
    var deg : Sequence(int) ; deg := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var u : int ; u := input.nextInt() ;
     var v : int ; v := input.nextInt() ;
     deg[u+1] := deg[u+1] + 1 ; 
     deg[v+1] := deg[v+1] + 1 )  ;     i := i + 1 ) ; 
    var fac : Sequence(long) ; fac := Integer.subrange(1,n + 1)->collect(0) ;
    fac[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do ( (     fac[i+1] := (fac[i - 1+1] * i) mod m )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 1 ;
        var i : int ; i := 1 ; while i <= n do ( (     ans := (ans * fac[deg[i+1]+1]) mod m )  ;     i := i + 1 ) ; 
    ans := (ans * n) mod m ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void solve(){
    boolean flg=false ;
    boolean flag=false ;
    String pass=sc.next();
    int n=sc.nextInt();
    String arr[]=new String[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.next();
      if(arr[i] .compareTo(pass)==0)flg=true ;
    }
    if(flg){
      System.out.println("YES");
      return ;
    }
    for(int i=0 ; i<n ; i++){
      if(arr[i] .charAt(1)==pass.charAt(0))flg=true ;
      if(arr[i] .charAt(0)==pass.charAt(1))flag=true ;
      if(flg && flag)break ;
    }
    if(flg && flag)System.out.println("YES");
    else System.out.println("NO");
  }
  public static void main(String[] args){
    int t=1 ;
    while(t-->0)solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var flg : boolean ; flg := false ;
     var flag : boolean ; flag := false ;
    var pass : String ; pass := sc.getCurrent() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent() ; 
     if (arr[i+1]->compareTo(pass) = 0) then     flg := true ; else skip )  ;     i := i + 1 ) ; 
    if (flg) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1]->at(1+1) = pass->at(0+1)) then     flg := true ; else skip ; 
     if (arr[i+1]->at(0+1) = pass->at(1+1)) then     flag := true ; else skip ; 
     if (flg & flag) then     break else skip )  ;     i := i + 1 ) ; 
    if (flg & flag) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ;     execute solve() ; ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _868A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    int t=sc.nextInt();
    boolean first=false,second=false ;
    sc.nextLine();
    while(t--!=0){
      String v=sc.nextLine();
      if(v.equals(s)){
        first=true ;
        second=true ;
      }
      if(v.charAt(0)==s.charAt(1)){
        second=true ;
      }
      if(v.charAt(1)==s.charAt(0)){
        first=true ;
      }
      if(first && second){
        break ;
      }
    }
    if(first && second){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _868A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var first : boolean ; first := false ;
    var second : boolean ; second := false ;
    skip ; 
        while (t /= 0) do (    skip ; (     var v : String ; v := sc.nextLine() ;
     if (v = s) then (     first := true ; 
     second := true ) else skip ; 
    if (v->at(0+1) = s->at(1+1)) then (     second := true ) else skip ; 
    if (v->at(1+1) = s->at(0+1)) then (     first := true ) else skip ; 
    if (first & second) then (     break ) else skip ; 
 ) ;  ) ;  
    if (first & second) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package gcj;
import java.util.*;
import java.io.*;
public class Swinging {
    final static String PROBLEM_NAME = "swing";
    final static String WORK_DIR = "D:\\Gcj\\" + PROBLEM_NAME + "\\";
    static void preprocess() {}
    void solve(Scanner sc, PrintWriter pw) {
        int N = sc.nextInt();
        int[] dist = new int[N];
        int[] len = new int[N];
        for (int i = 0; i < N; i++) {
            dist[i] = sc.nextInt();
            len[i] = sc.nextInt();
        }
        int D = sc.nextInt();
        int[] maxH = new int[N];
        Arrays.fill(maxH, -1);
        maxH[0] = dist[0];
        for (int i = 0; i < N; i++) {
            if (maxH[i] == -1) continue;
            if (D - dist[i] <= maxH[i]) {
                pw.println("YES");
                return;
            }
            for (int j = i + 1; j < N; j++) {
                if (dist[j] - dist[i] <= maxH[i]) {
                    maxH[j] = Math.max(maxH[j], Math.min(len[j], dist[j] - dist[i]));
                }
            }
        }
        pw.println("NO");
    }
    public static void main(String[] args) throws Exception {
        preprocess();
        Scanner sc = new Scanner(new FileReader(WORK_DIR + "input.txt"));
        PrintWriter pw = new PrintWriter(new FileWriter(WORK_DIR + "output.txt"));
        int caseCnt = sc.nextInt();
        for (int caseNum = 0; caseNum < caseCnt; caseNum++) {
            System.out.println("Processing test case " + (caseNum + 1));
            pw.print("Case #" + (caseNum + 1) + ": ");
            new Swinging().solve(sc, pw);
        }
        pw.flush();
        pw.close();
        sc.close();
    }
}

------------------------------------------------------------
OCL File:
---------
 class Swinging {
  static   attribute PROBLEM_NAME : String := "swing";
  static   attribute WORK_DIR : String := "D:\\Gcj\\" + PROBLEM_NAME + "\\";
  static   operation preprocess() : void
  pre: true
  post: true
  activity: skip;
   operation solve( sc : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.nextInt() ;
     var dist : Sequence(int) ; dist := Integer.subrange(1,N)->collect(0) ;
    var len : Sequence(int) ; len := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     dist[i+1] := sc.nextInt() ; 
     len[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    var D : int ; D := sc.nextInt() ;
    var maxH : Sequence(int) ; maxH := Integer.subrange(1,N)->collect(0) ;
    maxH := maxH->collect(-1) ; 
    maxH[0+1] := dist[0+1] ; 
        var i : int ; i := 0 ; while i < N do ( (     if (maxH[i+1] = -1) then     continue else skip ; 
     if (D - dist[i+1] <= maxH[i+1]) then (     pw.println("YES") ; 
     return ) else skip ; 
         var j : int ; j := i + 1 ; while j < N do ( (     if (dist[j+1] - dist[i+1] <= maxH[i+1]) then (     maxH[j+1] := Set{maxH[j+1], Set{len[j+1], dist[j+1] - dist[i+1]}->min()}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    pw.println("NO") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute preprocess() ; 
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(WORK_DIR + "input.txt")) ;
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(WORK_DIR + "output.txt")) ;
    var caseCnt : int ; caseCnt := sc.getCurrent()->toInteger() ;
        var caseNum : int ; caseNum := 0 ; while caseNum < caseCnt do ( (     OclFile["System.out"].println("Processing test case " + (caseNum + 1)) ; 
     skip ; 
     Swinging.newSwinging().solve(sc, pw) )  ;     caseNum := caseNum + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BarkToUnlock {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String one=scan.next();
    int n=scan.nextInt();
    String bark[]=new String[n];
    String rev[]=new String[n];
    String all="" ;
    int count=0 ;
    int countt=0 ;
    int counttt=0 ;
    for(int i=0 ; i<bark.length ; i++){
      bark[i]=scan.next();
      rev[i]=""+bark[i] .charAt(1)+bark[i] .charAt(0);
      if(one.charAt(0)==bark[i] .charAt(1)){
        countt++;
      }
      if(one.charAt(1)==bark[i] .charAt(0)){
        counttt++;
      }
      if(bark[i] .equals(one)){
        count++;
        System.out.println("YES");
        break ;
      }
      else if(rev[i] .equals(one)){
        count++;
        System.out.println("YES");
        break ;
      }
    }
    int i ;
    if(count==0){
      if(countt>=1 && counttt>=1)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BarkToUnlock {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var one : String ; one := scan.getCurrent() ;
    var n : int ; n := scan.getCurrent()->toInteger() ;
    var bark : Sequence(String) ; bark := Integer.subrange(1,n)->collect(null) ;
    var rev : Sequence(String) ; rev := Integer.subrange(1,n)->collect(null) ;
    var all : String ; all := "" ;
    var count : int ; count := 0 ;
    var countt : int ; countt := 0 ;
    var counttt : int ; counttt := 0 ;
        var i : int ; i := 0 ; while i < bark->size() do ( (     bark[i+1] := scan.getCurrent() ; 
     rev[i+1] := "" + bark[i+1]->at(1+1) + bark[i+1]->at(0+1) ; 
    if (one->at(0+1) = bark[i+1]->at(1+1)) then (     countt := countt + 1 ) else skip ; 
    if (one->at(1+1) = bark[i+1]->at(0+1)) then (     counttt := counttt + 1 ) else skip ; 
    if (bark[i+1] = one) then (     count := count + 1 ; 
     OclFile["System.out"].println("YES") ; 
     break ) else     if (rev[i+1] = one) then (     count := count + 1 ; 
     OclFile["System.out"].println("YES") ; 
     break ) else skip ; ;  
 )  ;     i := i + 1 ) ; 
    var i : int ;
    if (count = 0) then (     if (countt >= 1 & counttt >= 1) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
  Scanner sc=new Scanner(System.in);
  void run(){
    int n=sc.nextInt();
    if(n==1){
      System.out.println("Hello World");
    }
    else {
      int a=sc.nextInt();
      int b=sc.nextInt();
      System.out.println(a+b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 1) then (     OclFile["System.out"].println("Hello World") ) else (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(a + b) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class A868 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String answer=scanner.nextLine();
    int inputCount=Integer.parseInt(scanner.nextLine());
    ArrayList<String>input=new ArrayList<>();
    for(int i=0 ; i<inputCount ; i++){
      input.add(scanner.nextLine());
    }
    for(int i=0 ; i<inputCount ; i++){
      for(int j=0 ; j<inputCount ; j++){
        String tempString=input.get(i)+input.get(j);
        if(tempString.contains(answer)){
          System.out.println("YES");
          return ;
        }
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A868 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var answer : String ; answer := scanner.nextLine() ;
    var inputCount : int ; inputCount := (scanner.nextLine())->toInteger() ;
    var input : Sequence(String) ; input := Sequence{} ;
        var i : int ; i := 0 ; while i < inputCount do ( (     input := input->including(scanner.nextLine()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < inputCount do ( (         var j : int ; j := 0 ; while j < inputCount do ( (     var tempString : String ; tempString := input->at(i+1) + input->at(j+1) ;
     if (tempString->includes(answer)) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    FastReader in=new FastReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskB solver=new TaskB();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskB {
    public void solve(int testNumber,FastReader in,PrintWriter out){
      int n=in.nextInt();
      boolean ans=true ;
      int c=0 ;
      int count=0 ;
      for(int i=0 ; i<=n ; i++){
        if(i<n)c=in.nextInt();
        if(i==n || c==0){
          ans=ans &&(count % 2==0);
          count=0 ;
        }
        else {
          count+=c ;
        }
      }
      out.print(ans ? "YES" : "NO");
    }
  }
  static class FastReader {
    private final BufferedReader reader ;
    private StringTokenizer token ;
    public FastReader(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in),1<<20);
    }
    String next(){
      while(token==null || ! token.hasMoreElements()){
        try {
          token=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return token.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : FastReader ; in := FastReader.newFastReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskB ; solver := TaskB.newTaskB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskB {
   operation solve( testNumber : int, in : FastReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var ans : boolean ; ans := true ;
    var c : int ; c := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i <= n do ( (     if (i < n) then     c := in.nextInt() ; else skip ; 
     if (i = n or c = 0) then (     ans := ans & (count mod 2 = 0) ; 
     count := 0 ) else (     count := count+(c) ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class FastReader {
   attribute reader : OclFile;
   attribute token : OclIterator;
   static operation newFastReader( in : OclFile) : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in), (1*(2->pow(20)))->oclAsType(long)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (token = null or not(token.hasNext())) do (     try (     token := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return token.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int i,count=0,temp ;
    for(i=0 ; i<n ; i++){
      temp=scan.nextInt();
      if(temp % 2!=0){
        if(count==0)count=1 ;
        else count=0 ;
      }
      else if(temp==0){
        if(count==1)break ;
      }
    }
    if(count==0)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var i : int ;
    var count : int ; count := 0 ;
    var temp : int ;
        i := 0 ; while i < n do ( (     temp := scan.getCurrent()->toInteger() ; 
     if (temp mod 2 /= 0) then (     if (count = 0) then     count := 1 ; else     count := 0 ; ) else     if (temp = 0) then (     if (count = 1) then     break else skip ) else skip ; )  ;     i := i + 1 ) ; 
    if (count = 0) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public final class Solution {
  static int[] arr ;
  public static void main(String[] args){
    Reader input=new Reader();
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    int n=input.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=input.nextInt();
    for(int i=0 ; i<n ; i++){
      if(arr[i]<0){
        out.println("NO");
        out.close();
        return ;
      }
      arr[i] %=2 ;
      if(arr[i]==0)continue ;
      else {
        if(i+1==n){
          out.println("NO");
          out.close();
          return ;
        }
        else arr[i+1]--;
      }
    }
    out.println("YES");
    out.close();
  }
  public static class Reader {
    BufferedReader br ;
    StringTokenizer st ;
    public Reader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public String next(){
      try {
        if(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      }
      catch(IOException ex){
        ex.printStackTrace();
        System.exit(1);
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public String nextLine(){
      try {
        return br.readLine();
      }
      catch(IOException ex){
        ex.printStackTrace();
        System.exit(1);
      }
      return "" ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute arr : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := input.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := input.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] < 0) then (     skip ; 
     skip ; 
     return ) else skip ; 
     arr[i+1] := arr[i+1] mod 2 ; 
     if (arr[i+1] = 0) then     continue else (     if (i + 1 = n) then (     skip ; 
     skip ; 
     return ) else     arr[i + 1+1] := arr[i + 1+1] - 1 ; ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class Reader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newReader() : Reader
  pre: true
  post: true
  activity:
  ( var self : Reader ;
    self := createReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     if (st = null or not(st.hasNext())) then     st := OclIterator.newOclIterator_String(br.readLine()) ; else skip )   catch (ex : IOException) do (     ex.printStackTrace() ; 
 OclProcess.exit(1) )
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (ex : IOException) do (     ex.printStackTrace() ; 
 OclProcess.exit(1) )
     return "" );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String s=scan.nextLine();
    int n=scan.nextInt();
    minCount(s,n);
  }
  public static void minCount(String s,int n){
    int len=s.length();
    if(n>=len){
      StringBuilder sb=new StringBuilder(s);
      while(len<n){
        sb.append("a");
        len++;
      }
      System.out.println(1);
      System.out.println(sb);
      return ;
    }
    int max=0 ;
    int kind=0 ;
    int[] map=new int[26];
    for(char c : s.toCharArray()){
      int idx=c-'a' ;
      map[idx]++;
      if(map[idx]==1){
        kind++;
      }
      max=Math.max(max,map[idx]);
    }
    if(kind>n){
      System.out.println(-1);
      return ;
    }
    int L=1 ;
    int R=max ;
    while(L<=R){
      int M=(L+R)>>1 ;
      if(check(map,n,M)){
        R=M-1 ;
      }
      else {
        L=M+1 ;
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<26 ; i++){
      char c=(char)('a'+i);
      int need=(map[i]+L-1)/L ;
      for(int j=0 ; j<need ; j++){
        sb.append(c);
      }
    }
    int size=sb.length();
    while(size++<n){
      sb.append("a");
    }
    System.out.println(L);
    System.out.println(sb);
  }
  public static boolean check(int[] map,int N,int limit){
    int count=0 ;
    for(int num : map){
      count+=(num+limit-1)/limit ;
    }
    return count<=N ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scan.nextLine() ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
     execute minCount(s, n) );
  static   operation minCount( s : String, n : int) : void
  pre: true
  post: true
  activity: (     var len : int ; len := s->size() ;
     if (n >= len) then (     var sb : String ; sb := StringLib.newString(s) ;
     while (len < n) do (     sb := sb + StringLib.newString("a") ; 
     len := len + 1 ) ; 
    OclFile["System.out"].println(1) ; 
    OclFile["System.out"].println(sb) ; 
    return 
 ) else skip ; 
    var max : int ; max := 0 ;
    var kind : int ; kind := 0 ;
    var map : Sequence(int) ; map := Integer.subrange(1,26)->collect(0) ;
    for (c : s->characters()) do ( (     var idx : int ; idx := c - ('a')->char2byte() ;
     map[idx+1] := map[idx+1] + 1 ; 
     if (map[idx+1] = 1) then (     kind := kind + 1 ) else skip ; 
     max := Set{max, map[idx+1]}->max() )  ) ; 
    if (kind > n) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var L : int ; L := 1 ;
    var R : int ; R := max ;
    while (L <= R) do (     var M : int ; M := ((L + R)/(2->pow(1)))->oclAsType(long) ;
     if (check(map, n, M)) then (     R := M - 1 ) else (     L := M + 1 ) ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < 26 do ( (     var c : String ; c := ('a' + i)->oclAsType(String) ;
     var need : int ; need := (map[i+1] + L - 1) / L ;
         var j : int ; j := 0 ; while j < need do ( (     sb := sb + StringLib.newString(c) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var size : int ; size := sb->size() ;
        while (size < n) do (        size := size + 1 ;     skip ; (     sb := sb + StringLib.newString("a") ) ;  ) ;  
    OclFile["System.out"].println(L) ; 
    OclFile["System.out"].println(sb) ; 
 );
  static   operation check( map : Sequence(int), N : int, limit : int) : boolean
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     for (num : map) do ( (     count := count+((num + limit - 1) / limit) )  ) ; 
     return count <= N );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Banana {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s=br.readLine();
    int n=Integer.parseInt(br.readLine());
    int occ[]=new int[26];
    int distinctChars=0 ;
    for(int i=0 ; i<s.length(); i++){
      int c=s.charAt(i)-'a' ;
      occ[c]++;
      if(occ[c]==1)distinctChars++;
    }
    if(distinctChars>n){
      System.out.println(-1);
      return ;
    }
    int noOfSheets=1 ;
    while(true){
      int nNeeded=0 ;
      for(int i=0 ; i<26 ; i++){
        nNeeded+=Math.ceil(occ[i]*1.0/noOfSheets);
      }
      if(nNeeded<=n){
        StringBuilder sb=new StringBuilder();
        for(int i=0 ; i<26 ; i++){
          int occInSticker=(int)Math.ceil(occ[i]*1.0/noOfSheets);
          char c=(char)('a'+i);
          for(int j=0 ; j<occInSticker ; j++){
            sb.append(c);
          }
        }
        for(int i=sb.length(); i<n ; i++){
          sb.append('a');
        }
        System.out.println(noOfSheets);
        System.out.println(sb);
        return ;
      }
      noOfSheets++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Banana {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := br.readLine() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var occ : Sequence(int) ; occ := Integer.subrange(1,26)->collect(0) ;
    var distinctChars : int ; distinctChars := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var c : int ; c := s->at(i+1) - ('a')->char2byte() ;
     occ[c+1] := occ[c+1] + 1 ; 
     if (occ[c+1] = 1) then     distinctChars := distinctChars + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (distinctChars > n) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var noOfSheets : int ; noOfSheets := 1 ;
    while (true) do (     var nNeeded : int ; nNeeded := 0 ;
         var i : int ; i := 0 ; while i < 26 do ( (     nNeeded := nNeeded+((occ[i+1] * 1.0 / noOfSheets)->ceil()) )  ;     i := i + 1 ) ; 
     if (nNeeded <= n) then (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < 26 do ( (     var occInSticker : int ; occInSticker := (occ[i+1] * 1.0 / noOfSheets)->ceil()->oclAsType(int) ;
     var c : String ; c := ('a' + i)->oclAsType(String) ;
         var j : int ; j := 0 ; while j < occInSticker do ( (     sb := sb + StringLib.newString(c) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := sb->size() ; while i < n do ( (     sb := sb + StringLib.newString('a') )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(noOfSheets) ; 
    OclFile["System.out"].println(sb) ; 
    return 
 ) else skip ; 
     noOfSheets := noOfSheets + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A335 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char[] S=in.next().toCharArray();
    int N=in.nextInt();
    int[] stat=new int[26];
    for(char c : S){
      stat[c-'a']++;
    }
    int letters=0 ;
    for(int count : stat){
      if(count!=0){
        letters++;
      }
    }
    if(letters>N){
      System.out.println("-1");
      return ;
    }
    int low=1 ;
    int high=S.length ;
    while(low<high){
      int mid=(low+high)/2 ;
      int onSheet=0 ;
      for(int count : stat){
        onSheet+=(count+mid-1)/mid ;
      }
      if(onSheet>N){
        low=mid+1 ;
      }
      else {
        high=mid ;
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<26 ; i++){
      char c=(char)('a'+i);
      for(int j=0 ; j<(stat[i]+low-1)/low ; j++){
        sb.append(c);
      }
    }
    while(sb.length()<N){
      sb.append('x');
    }
    System.out.println(low);
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A335 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : Sequence(String) ; S := in.getCurrent()->characters() ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var stat : Sequence(int) ; stat := Integer.subrange(1,26)->collect(0) ;
    for (c : S) do ( (     stat[c - ('a')->char2byte()+1] := stat[c - ('a')->char2byte()+1] + 1 )  ) ; 
    var letters : int ; letters := 0 ;
    for (count : stat) do ( (     if (count /= 0) then (     letters := letters + 1 ) else skip )  ) ; 
    if (letters > N) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
    var low : int ; low := 1 ;
    var high : int ; high := S->size() ;
    while (low < high) do (     var mid : int ; mid := (low + high) / 2 ;
     var onSheet : int ; onSheet := 0 ;
     for (count : stat) do ( (     onSheet := onSheet+((count + mid - 1) / mid) )  ) ; 
     if (onSheet > N) then (     low := mid + 1 ) else (     high := mid ) ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < 26 do ( (     var c : String ; c := ('a' + i)->oclAsType(String) ;
         var j : int ; j := 0 ; while j < (stat[i+1] + low - 1) / low do ( (     sb := sb + StringLib.newString(c) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    while (sb->size() < N) do (     sb := sb + StringLib.newString('x') ) ; 
    OclFile["System.out"].println(low) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isOperand(char x){
    return(x>='a' && x<='z')||(x>='A' && x<='Z');
  }
  static String getInfix(String exp){
    Stack<String>s=new Stack<String>();
    for(int i=0 ; i<exp.length(); i++){
      if(isOperand(exp.charAt(i))){
        s.push(exp.charAt(i)+"");
      }
      else {
        String op1=s.peek();
        s.pop();
        String op2=s.peek();
        s.pop();
        s.push("("+op2+exp.charAt(i)+op1+")");
      }
    }
    return s.peek();
  }
  public static void main(String args[]){
    String exp="ab*c+" ;
    System.out.println(getInfix(exp));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isOperand( x : String) : boolean
  pre: true
  post: true
  activity: (     return (x >= 'a' & x <= 'z') or (x >= 'A' & x <= 'Z') );
  static   operation getInfix( exp : String) : String
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := Sequence{} ;
         var i : int ; i := 0 ; while i < exp->size() do ( (     if (isOperand(exp->at(i+1))) then (     s := s->append(exp->at(i+1) + "") ) else (     var op1 : String ; op1 := s->min() ;
     s := s->front() ; 
    var op2 : String ; op2 := s->min() ;
    s := s->front() ; 
    s := s->append("(" + op2 + exp->at(i+1) + op1 + ")") ; 
 ) )  ;     i := i + 1 ) ; 
     return s->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var exp : String ; exp := "ab*c+" ;
     OclFile["System.out"].println(getInfix(exp)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String a=sc.next();
    if(a.equals("SUN")){
      System.out.print("7");
    }
    if(a.equals("MON")){
      System.out.print("6");
    }
    if(a.equals("TUE")){
      System.out.print("5");
    }
    if(a.equals("WED")){
      System.out.print("4");
    }
    if(a.equals("THU")){
      System.out.print("3");
    }
    if(a.equals("FRI")){
      System.out.print("2");
    }
    if(a.equals("SAT")){
      System.out.print("1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := sc.getCurrent() ;
    if (a = "SUN") then (     OclFile["System.out"].print("7") ) else skip ; 
    if (a = "MON") then (     OclFile["System.out"].print("6") ) else skip ; 
    if (a = "TUE") then (     OclFile["System.out"].print("5") ) else skip ; 
    if (a = "WED") then (     OclFile["System.out"].print("4") ) else skip ; 
    if (a = "THU") then (     OclFile["System.out"].print("3") ) else skip ; 
    if (a = "FRI") then (     OclFile["System.out"].print("2") ) else skip ; 
    if (a = "SAT") then (     OclFile["System.out"].print("1") ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class A {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner in=new Scanner(new File(A.class.getSimpleName()+".in"));
    PrintWriter out=new PrintWriter(new File(A.class.getSimpleName()+".out"));
    int T=in.nextInt();
    for(int i=0 ; i<T ; i++){
      String s="Case #"+(i+1)+": "+new A().solve(in);
      out.println(s);
      System.out.println(s);
    }
    out.close();
  }
  private String solve(Scanner in){
    int n=in.nextInt();
    int[] d=new int[n+1];
    int[] l=new int[n+1];
    for(int i=0 ; i<n ; i++){
      d[i]=in.nextInt();
      l[i]=in.nextInt();
    }
    d[n]=in.nextInt();
    int[] z=new int[n+1];
    z[0]=d[0];
    for(int i=0 ; i<n ; i++){
      z[i]=Math.min(z[i],l[i]);
      for(int j=i+1 ; j<=n ; j++){
        if(d[j]<=d[i]+z[i]){
          z[j]=Math.max(z[j],d[j]-d[i]);
        }
      }
    }
    return z[n]>0 ? "YES" : "NO" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile(OclType["A"].getSimpleName() + ".in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile(OclType["A"].getSimpleName() + ".out")) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < T do ( (     var s : String ; s := "Case #" + (i + 1) + ": " + A.newA().solve(in) ;
     skip ; 
     OclFile["System.out"].println(s) )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation solve( in : OclFile) : String
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var d : Sequence(int) ; d := Integer.subrange(1,n + 1)->collect(0) ;
    var l : Sequence(int) ; l := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     d[i+1] := in.getCurrent()->toInteger() ; 
     l[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    d[n+1] := in.getCurrent()->toInteger() ; 
    var z : Sequence(int) ; z := Integer.subrange(1,n + 1)->collect(0) ;
    z[0+1] := d[0+1] ; 
        var i : int ; i := 0 ; while i < n do ( (     z[i+1] := Set{z[i+1], l[i+1]}->min() ; 
         var j : int ; j := i + 1 ; while j <= n do ( (     if (d[j+1] <= d[i+1] + z[i+1]) then (     z[j+1] := Set{z[j+1], d[j+1] - d[i+1]}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return if z[n+1] > 0 then "YES" else "NO" endif 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class MikeAndChildren {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=in.nextInt();
    pw.println(solve(a,n));
    pw.close();
  }
  static int solve(int[] a,int n){
    int ans=0 ;
    int max=Integer.MIN_VALUE ;
    for(int i : a){
      max=Math.max(max,i);
    }
    int[] dp=new int[max*2+1];
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        int sum=a[i]+a[j];
        dp[sum]++;
      }
    }
    for(int i : dp)ans=Math.max(i,ans);
    return ans ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class MikeAndChildren {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var max : int ; max := -2147483648 ;
    for (i : a) do ( (     max := Set{max, i}->max() )  ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,max * 2 + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var sum : int ; sum := a[i+1] + a[j+1] ;
     dp[sum+1] := dp[sum+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    for (i : dp) do (     ans := Set{i, ans}->max() ;  ) ; 
    return ans 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    HashMap<Integer,String>map=new HashMap<>();
    for(int i=0 ; i<N ; i++){
      map.put(i,sc.next());
    }
    boolean ans=true ;
    HashMap<Integer,String>past=new HashMap<>();
    String next="" ;
    for(int i=0 ; i<N ; i++){
      if(past.containsValue(map.get(i))){
        ans=false ;
        break ;
      }
      past.put(i,map.get(i));
      if(i!=0){
        if(! next.equals(map.get(i).substring(0,1))){
          ans=false ;
          break ;
        }
      }
      next=map.get(i).substring(map.get(i).length()-1,map.get(i).length());
    }
    if(ans){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var map : Map(int,String) ; map := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     map := map->union(Map{i |-> sc.getCurrent()}) )  ;     i := i + 1 ) ; 
    var ans : boolean ; ans := true ;
    var past : Map(int,String) ; past := Map{} ;
    var next : String ; next := "" ;
        var i : int ; i := 0 ; while i < N do ( (     if (past->values()->includes(map->at(i))) then (     ans := false ; 
     break ) else skip ; 
     past := past->union(Map{i |-> map->at(i)}) ; 
     if (i /= 0) then (     if (not(next = map->at(i).subrange(0+1,1))) then (     ans := false ; 
     break ) else skip ) else skip ; 
     next := map->at(i).subrange(map->at(i)->size() - 1+1,map->at(i)->size()) )  ;     i := i + 1 ) ; 
    if (ans) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.stream.*;
public class Main {
  private static BufferedReader br=null ;
  public static void main(String[] args){
    int n=Integer.parseInt(read(1)[0]);
    if(n==1){
      System.out.println("Hello World");
    }
    else {
      String[] strs=read(2);
      System.out.println(Integer.parseInt(strs[0])+Integer.parseInt(strs[1]));
    }
  }
  private static String[] read(int len){
    List<String>strList=new ArrayList<>();
    try {
      if(br==null){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
      for(int i=0 ; i<len ; i++){
        strList.add(br.readLine());
      }
    }
    catch(IOException e){
    }
    return strList.toArray(new String[0]);
  }
  private static void close(){
    try {
      if(br!=null){
        br.close();
      }
    }
    catch(IOException e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (read(1)[0+1])->toInteger() ;
     if (n = 1) then (     OclFile["System.out"].println("Hello World") ) else (     var strs : Sequence(String) ; strs := read(2) ;
     OclFile["System.out"].println((strs[0+1])->toInteger() + (strs[1+1])->toInteger()) ) );
  static   operation read( len : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var strList : Sequence(String) ; strList := Sequence{} ;
     try (     if (br = null) then (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ) else skip ; 
         var i : int ; i := 0 ; while i < len do ( (     strList := strList->including(br.readLine()) )  ;     i := i + 1 ) )   catch (e : IOException) do skip
     return strList->asSequence() );
  static   operation close() : void
  pre: true
  post: true
  activity: (     try (     if (br /= null) then (     skip ) else skip )   catch (e : IOException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String in=br.readLine();
      String[] day={
        "SAT","FRI","THU","WED","TUE","MON","SUN" };
        for(int i=0 ; i<day.length ; i++){
          if(in.equals(day[i])){
            System.out.println(i+1);
            break ;
          }
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var in : String ; in := br.readLine() ;
     var day : Sequence(String) ; day := Sequence{"SAT","FRI","THU","WED","TUE","MON","SUN"} ;
         var i : int ; i := 0 ; while i < day->size() do ( (     if (in = day[i+1]) then (     OclFile["System.out"].println(i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    String s=scan.next();
    HashMap<String,Integer>map=new HashMap<>();
    map.put("SUN",7);
    map.put("MON",6);
    map.put("TUE",5);
    map.put("WED",4);
    map.put("THU",3);
    map.put("FRI",2);
    map.put("SAT",1);
    System.out.println(map.get(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var s : String ; s := scan.getCurrent() ;
    var map : Map(String,int) ; map := Map{} ;
    map := map->union(Map{"SUN" |-> 7}) ; 
    map := map->union(Map{"MON" |-> 6}) ; 
    map := map->union(Map{"TUE" |-> 5}) ; 
    map := map->union(Map{"WED" |-> 4}) ; 
    map := map->union(Map{"THU" |-> 3}) ; 
    map := map->union(Map{"FRI" |-> 2}) ; 
    map := map->union(Map{"SAT" |-> 1}) ; 
    OclFile["System.out"].println(map->at(s)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static String[] days={
    "SUN","SAT","FRI","THU","WED","TUE","MON" };
    public static void main(String[] args){
      Scanner sc=new Scanner(System.in);
      String day=sc.next();
      for(int i=0 ; i<days.length ; i++){
        if(day.equals(days[i])){
          System.out.println(i==0 ? 7 : i);
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute days : Sequence(String) := Sequence{"SUN","SAT","FRI","THU","WED","TUE","MON"};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var day : String ; day := sc.getCurrent() ;
         var i : int ; i := 0 ; while i < days->size() do ( (     if (day = days[i+1]) then (     OclFile["System.out"].println(if i = 0 then 7 else i endif) ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String dow=sc.next();
    ArrayList<String>week=new ArrayList<>(Arrays.asList("SUN","MON","TUE","WED","THU","FRI","SAT"));
    int result=7-week.indexOf(dow);
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dow : String ; dow := sc.getCurrent() ;
    var week : Sequence(String) ; week := Sequence{}->union(Sequence{"SUN","MON","TUE","WED","THU","FRI","SAT"}) ;
    var result : int ; result := 7 - week->indexOf(dow)-1 ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String prevNum(String str){
    int len=str.length();
    int index=-1 ;
    for(int i=len-2 ; i>=0 ; i--){
      if(str.charAt(i)>str.charAt(i+1)){
        index=i ;
        break ;
      }
    }
    int smallGreatDgt=-1 ;
    for(int i=len-1 ; i>index ; i--){
      if(str.charAt(i)<str.charAt(index)){
        if(smallGreatDgt==-1){
          smallGreatDgt=i ;
        }
        else if(str.charAt(i)>=str.charAt(smallGreatDgt)){
          smallGreatDgt=i ;
        }
      }
    }
    if(index==-1){
      return "-1" ;
    }
    if(smallGreatDgt!=-1){
      str=swap(str,index,smallGreatDgt);
      return str ;
    }
    return "-1" ;
  }
  static String swap(String str,int i,int j){
    char ch[]=str.toCharArray();
    char temp=ch[i];
    ch[i]=ch[j];
    ch[j]=temp ;
    return String.valueOf(ch);
  }
  public static void main(String[] args){
    String str="34125" ;
    System.out.println(prevNum(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation prevNum( str : String) : String
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     var index : int ; index := -1 ;
        var i : int ; i := len - 2 ; while i >= 0 do ( (     if (str->at(i+1) > str->at(i + 1+1)) then (     index := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    var smallGreatDgt : int ; smallGreatDgt := -1 ;
        var i : int ; i := len - 1 ; while i > index do ( (     if (str->at(i+1) < str->at(index+1)) then (     if (smallGreatDgt = -1) then (     smallGreatDgt := i ) else     if (str->at(i+1) >= str->at(smallGreatDgt+1)) then (     smallGreatDgt := i ) else skip ; ) else skip )  ;     i := i - 1 ) ; 
    if (index = -1) then (     return "-1" ) else skip ; 
    if (smallGreatDgt /= -1) then (     str := swap(str, index, smallGreatDgt) ; 
     return str ) else skip ; 
    return "-1" 
 );
  static   operation swap( str : String, i : int, j : int) : String
  pre: true
  post: true
  activity: (     var ch : Sequence(String) ; ch := str->characters() ;
     var temp : String ; temp := ch[i+1] ;
    ch[i+1] := ch[j+1] ; 
    ch[j+1] := temp ; 
    return ((ch) + "") 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "34125" ;
     OclFile["System.out"].println(prevNum(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isOperand(char c){
    return(c>='0' && c<='9');
  }
  static int value(char c){
    return(int)(c-'0');
  }
  static int evaluate(String exp){
    if(exp.length()==0)return-1 ;
    int res=value(exp.charAt(0));
    for(int i=1 ; i<exp.length(); i+=2){
      char opr=exp.charAt(i),opd=exp.charAt(i+1);
      if(isOperand(opd)==false)return-1 ;
      if(opr=='+')res+=value(opd);
      else if(opr=='-')res-=value(opd);
      else if(opr=='*')res*=value(opd);
      else if(opr=='/')res/=value(opd);
      else return-1 ;
    }
    return res ;
  }
  public static void main(String[] args){
    String expr1="1+2*5+3" ;
    int res=evaluate(expr1);
    if(res==-1)System.out.println(expr1+" is Invalid");
    else System.out.println("Value of "+expr1+" is "+res);
    String expr2="1+2*3" ;
    res=evaluate(expr2);
    if(res==-1)System.out.println(expr2+" is Invalid");
    else System.out.println("Value of "+expr2+" is "+res);
    String expr3="4-2+6*3" ;
    res=evaluate(expr3);
    if(res==-1)System.out.println(expr3+" is Invalid");
    else System.out.println("Value of "+expr3+" is "+res);
    String expr4="1++2" ;
    res=evaluate(expr4);
    if(res==-1)System.out.println(expr4+" is Invalid");
    else System.out.println("Value of "+expr4+" is "+res);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isOperand( c : String) : boolean
  pre: true
  post: true
  activity: (     return (c >= '0' & c <= '9') );
  static   operation value( c : String) : int
  pre: true
  post: true
  activity: (     return (c - ('0')->char2byte())->oclAsType(int) );
  static   operation evaluate( exp : String) : int
  pre: true
  post: true
  activity: (     if (exp->size() = 0) then     return -1 else skip ; 
     var res : int ; res := value(exp->at(0+1)) ;
         var i : int ; i := 1 ; while i < exp->size() do ( (     var opr : String ; opr := exp->at(i+1) ;
    var opd : String ; opd := exp->at(i + 1+1) ;
     if (isOperand(opd) = false) then     return -1 else skip ; 
     if (opr = '+') then     res := res+(value(opd)) ; else     if (opr = '-') then     res := res-(value(opd)) else     if (opr = '*') then     res := res*(value(opd)) else     if (opr = '/') then     res := res/(value(opd)) else     return -1 ;  ;  ;  )  ;     i := i+(2) ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var expr1 : String ; expr1 := "1+2*5+3" ;
     var res : int ; res := evaluate(expr1) ;
    if (res = -1) then     OclFile["System.out"].println(expr1 + " is Invalid") else     OclFile["System.out"].println("Value of " + expr1 + " is " + res) ; ;  
    var expr2 : String ; expr2 := "1+2*3" ;
    res := evaluate(expr2) ; 
    if (res = -1) then     OclFile["System.out"].println(expr2 + " is Invalid") else     OclFile["System.out"].println("Value of " + expr2 + " is " + res) ; ;  
    var expr3 : String ; expr3 := "4-2+6*3" ;
    res := evaluate(expr3) ; 
    if (res = -1) then     OclFile["System.out"].println(expr3 + " is Invalid") else     OclFile["System.out"].println("Value of " + expr3 + " is " + res) ; ;  
    var expr4 : String ; expr4 := "1++2" ;
    res := evaluate(expr4) ; 
    if (res = -1) then     OclFile["System.out"].println(expr4 + " is Invalid") else     OclFile["System.out"].println("Value of " + expr4 + " is " + res) ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class D {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(new File("D-large.in"));
    PrintWriter out=new PrintWriter(new FileWriter(new File("D-large.out")));
    int t=in.nextInt();
    for(int x=0 ; x<t ; x++){
      int n=in.nextInt();
      double[] naomi=new double[n];
      for(int y=0 ; y<n ; y++){
        naomi[y]=in.nextDouble();
      }
      double[] ken=new double[n];
      for(int z=0 ; z<n ; z++){
        ken[z]=in.nextDouble();
      }
      Arrays.sort(naomi);
      Arrays.sort(ken);
      int index=0 ;
      int win1=0 ;
      for(int a=0 ; a<ken.length ; a++){
        while(index<n && naomi[index]<ken[a]){
          index++;
        }
        if(index<n){
          win1++;
          index++;
        }
      }
      index=0 ;
      int win2=0 ;
      for(int b=0 ; b<naomi.length ; b++){
        while(index<n && ken[index]<naomi[b]){
          index++;
          win2++;
        }
        index++;
      }
      out.println("Case #"+(x+1)+": "+win1+" "+win2);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("D-large.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile("D-large.out"))) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        var x : int ; x := 0 ; while x < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var naomi : Sequence(double) ; naomi := Integer.subrange(1,n)->collect(0.0) ;
        var y : int ; y := 0 ; while y < n do ( (     naomi[y+1] := in.getCurrent()->toReal() )  ;     y := y + 1 ) ; 
    var ken : Sequence(double) ; ken := Integer.subrange(1,n)->collect(0.0) ;
        var z : int ; z := 0 ; while z < n do ( (     ken[z+1] := in.getCurrent()->toReal() )  ;     z := z + 1 ) ; 
    naomi := naomi->sort() ; 
    ken := ken->sort() ; 
    var index : int ; index := 0 ;
    var win1 : int ; win1 := 0 ;
        var a : int ; a := 0 ; while a < ken->size() do ( (     while (index < n & naomi[index+1] < ken[a+1]) do (     index := index + 1 ) ; 
     if (index < n) then (     win1 := win1 + 1 ; 
     index := index + 1 ) else skip )  ;     a := a + 1 ) ; 
    index := 0 ; 
    var win2 : int ; win2 := 0 ;
        var b : int ; b := 0 ; while b < naomi->size() do ( (     while (index < n & ken[index+1] < naomi[b+1]) do (     index := index + 1 ; 
     win2 := win2 + 1 ) ; 
     index := index + 1 )  ;     b := b + 1 ) ; 
    skip ; 
 )  ;     x := x + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedWriter ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.util.Scanner ;
public class War {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(new FileReader("jam.in"));
    BufferedWriter bw=new BufferedWriter(new FileWriter("jam.out"));
    int cases ;
    cases=sc.nextInt();
    for(int z=1 ; z<=cases ; z++){
      int n=sc.nextInt();
      double[] nami=new double[n];
      double[] ken=new double[n];
      int i,j ;
      for(i=0 ; i<n ; i++)nami[i]=sc.nextDouble();
      for(i=0 ; i<n ; i++)ken[i]=sc.nextDouble();
      for(i=0 ; i<n ; i++)for(j=i+1 ; j<n ; j++){
        double t ;
        if(nami[i]>nami[j]){
          t=nami[i];
          nami[i]=nami[j];
          nami[j]=t ;
        }
        if(ken[i]>ken[j]){
          t=ken[i];
          ken[i]=ken[j];
          ken[j]=t ;
        }
      }
      int q1=0 ;
      int q2=n-1 ;
      int ans1=0 ;
      for(i=0 ; i<n ; i++)if(nami[i]>ken[q1]){
        ans1++;
        q1++;
      }
      else {
        q2--;
      }
      int ans2=0 ;
      q1=0 ;
      for(i=0 ; i<n ; i++){
        while(q1<n && ken[q1]<nami[i])q1++;
        if(q1==n)break ;
        ans2++;
        q1++;
      }
      bw.write("Case #"+z+": ");
      bw.write(""+ans1+" "+(n-ans2)+"\n");
    }
    sc.close();
    bw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class War {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("jam.in"))) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("jam.out"))) ;
    var cases : int ;
    cases := sc.getCurrent()->toInteger() ; 
        var z : int ; z := 1 ; while z <= cases do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var nami : Sequence(double) ; nami := Integer.subrange(1,n)->collect(0.0) ;
    var ken : Sequence(double) ; ken := Integer.subrange(1,n)->collect(0.0) ;
    var i : int ;
    var j : int ;
        i := 0 ; while i < n do (     nami[i+1] := sc.getCurrent()->toReal() ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do (     ken[i+1] := sc.getCurrent()->toReal() ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do (         j := i + 1 ; while j < n do ( (     var t : double ;
     if (nami[i+1] > nami[j+1]) then (     t := nami[i+1] ; 
     nami[i+1] := nami[j+1] ; 
     nami[j+1] := t ) else skip ; 
     if (ken[i+1] > ken[j+1]) then (     t := ken[i+1] ; 
     ken[i+1] := ken[j+1] ; 
     ken[j+1] := t ) else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var q1 : int ; q1 := 0 ;
    var q2 : int ; q2 := n - 1 ;
    var ans1 : int ; ans1 := 0 ;
        i := 0 ; while i < n do (     if (nami[i+1] > ken[q1+1]) then (     ans1 := ans1 + 1 ; 
     q1 := q1 + 1 ) else (     q2 := q2 - 1 ) ;   ;     i := i + 1 ) ; 
    var ans2 : int ; ans2 := 0 ;
    q1 := 0 ; 
        i := 0 ; while i < n do ( (     while (q1 < n & ken[q1+1] < nami[i+1]) do     q1 := q1 + 1 ; ; 
     if (q1 = n) then     break else skip ; 
     ans2 := ans2 + 1 ; 
     q1 := q1 + 1 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 )  ;     z := z + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedWriter ;
import java.io.File ;
import java.io.FileWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Exe4 {
  public static void main(String[] args)throws Exception {
    Scanner input=new Scanner(new File("input"));
    BufferedWriter output=new BufferedWriter(new FileWriter(new File("output")));
    int T=input.nextInt();
    for(int i=0 ; i<T ; i++){
      int N=input.nextInt();
      double[] Noemi=new double[N];
      double[] Ken=new double[N];
      for(int j=0 ; j<N ; j++){
        Noemi[j]=input.nextDouble();
      }
      for(int j=0 ; j<N ; j++){
        Ken[j]=input.nextDouble();
      }
      Arrays.sort(Noemi);
      Arrays.sort(Ken);
      int ans1=0 ;
      int ans2=0 ;
      int k ;
      int j ;
      k=0 ;
      j=0 ;
      while(k<N){
        while(k<N && Noemi[j]>Ken[k]){
          k++;
        }
        if(k<N){
          j++;
          k++;
        }
      }
      ans1=N-j ;
      k=0 ;
      j=0 ;
      while(j<N){
        while(j<N && Noemi[j]<Ken[k]){
          j++;
        }
        if(j<N){
          j++;
          k++;
        }
      }
      ans2=k ;
      output.write("Case #"+(i+1)+": "+ans2+" "+ans1);
      output.newLine();
      output.flush();
    }
    output.flush();
    input.close();
    output.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Exe4 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile("input")) ;
     var output : OclFile ; output := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile("output"))) ;
    var T : int ; T := input.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < T do ( (     var N : int ; N := input.getCurrent()->toInteger() ;
     var Noemi : Sequence(double) ; Noemi := Integer.subrange(1,N)->collect(0.0) ;
    var Ken : Sequence(double) ; Ken := Integer.subrange(1,N)->collect(0.0) ;
        var j : int ; j := 0 ; while j < N do ( (     Noemi[j+1] := input.getCurrent()->toReal() )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < N do ( (     Ken[j+1] := input.getCurrent()->toReal() )  ;     j := j + 1 ) ; 
    Noemi := Noemi->sort() ; 
    Ken := Ken->sort() ; 
    var ans1 : int ; ans1 := 0 ;
    var ans2 : int ; ans2 := 0 ;
    var k : int ;
    var j : int ;
    k := 0 ; 
    j := 0 ; 
    while (k < N) do (     while (k < N & Noemi[j+1] > Ken[k+1]) do (     k := k + 1 ) ; 
     if (k < N) then (     j := j + 1 ; 
     k := k + 1 ) else skip ) ; 
    ans1 := N - j ; 
    k := 0 ; 
    j := 0 ; 
    while (j < N) do (     while (j < N & Noemi[j+1] < Ken[k+1]) do (     j := j + 1 ) ; 
     if (j < N) then (     j := j + 1 ; 
     k := k + 1 ) else skip ) ; 
    ans2 := k ; 
    skip ; 
    skip ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class D {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int inputs=in.nextInt();
    for(int caseNum=1 ; caseNum<=inputs ; caseNum++){
      int blocks=in.nextInt();
      double[] naomi=new double[blocks];
      double[] ken=new double[blocks];
      for(int i=0 ; i<blocks ; i++){
        naomi[i]=in.nextDouble();
      }
      for(int i=0 ; i<blocks ; i++){
        ken[i]=in.nextDouble();
      }
      Arrays.sort(ken);
      Arrays.sort(naomi);
      int normal=0 ;
      int i=0 ;
      int j=0 ;
      while(i<blocks && j<blocks){
        if(naomi[i]<ken[j]){
          i++;
          j++;
          normal++;
        }
        else {
          j++;
        }
      }
      normal=blocks-normal ;
      int cheat=0 ;
      i=0 ;
      j=0 ;
      while(i<blocks && j<blocks){
        if(naomi[i]>ken[j]){
          i++;
          j++;
          cheat++;
        }
        else {
          i++;
        }
      }
      System.out.printf("Case #%d: %d %d\n",caseNum,cheat,normal);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inputs : int ; inputs := in.getCurrent()->toInteger() ;
         var caseNum : int ; caseNum := 1 ; while caseNum <= inputs do ( (     var blocks : int ; blocks := in.getCurrent()->toInteger() ;
     var naomi : Sequence(double) ; naomi := Integer.subrange(1,blocks)->collect(0.0) ;
    var ken : Sequence(double) ; ken := Integer.subrange(1,blocks)->collect(0.0) ;
        var i : int ; i := 0 ; while i < blocks do ( (     naomi[i+1] := in.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < blocks do ( (     ken[i+1] := in.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
    ken := ken->sort() ; 
    naomi := naomi->sort() ; 
    var normal : int ; normal := 0 ;
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    while (i < blocks & j < blocks) do (     if (naomi[i+1] < ken[j+1]) then (     i := i + 1 ; 
     j := j + 1 ; 
     normal := normal + 1 ) else (     j := j + 1 ) ) ; 
    normal := blocks - normal ; 
    var cheat : int ; cheat := 0 ;
    i := 0 ; 
    j := 0 ; 
    while (i < blocks & j < blocks) do (     if (naomi[i+1] > ken[j+1]) then (     i := i + 1 ; 
     j := j + 1 ; 
     cheat := cheat + 1 ) else (     i := i + 1 ) ) ; 
    OclFile["System.out"].printf("Case #%d: %d %d\n", caseNum, cheat, normal) ; 
 )  ;     caseNum := caseNum + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.*;
import java.io.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    if(a==1)System.out.println("Hello World");
    else if(a==2){
      int b=sc.nextInt();
      int c=sc.nextInt();
      System.out.println(b+c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (a = 1) then     OclFile["System.out"].println("Hello World") ; else     if (a = 2) then (     var b : int ; b := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(b + c) ) else skip ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileInputStream ;
import java.io.FileOutputStream ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class A {
  Scanner in ;
  PrintWriter out ;
  void doit(int tnum){
    int n=in.nextInt();
    long[] d=new long[n];
    long[] l=new long[n];
    for(int i=0 ; i<n ; ++i){
      d[i]=in.nextLong();
      l[i]=in.nextLong();
    }
    long D=in.nextLong();
    long[] ans=new long[n];
    ans[0]=d[0];
    boolean ok=false ;
    for(int i=1 ; i<n ; ++i)ans[i]=-1 ;
    for(int i=0 ; i<n ; ++i){
      if(D-d[i]<=ans[i])ok=true ;
      for(int j=i+1 ; j<n ; ++j){
        if((d[j]-d[i])<=ans[i]){
          long attempt=Math.min(l[j],d[j]-d[i]);
          if(ans[j]==-1)ans[j]=attempt ;
          if(ans[j]<attempt)ans[j]=attempt ;
        }
      }
    }
    out.println("Case #"+tnum+": "+(ok ? "YES" : "NO"));
    System.err.println("Case #"+tnum+": "+(ok ? "YES" : "NO"));
  }
  public void doit()throws IOException {
    out=new PrintWriter(new FileOutputStream("output.txt"));
    in=new Scanner(new FileInputStream("A-large.in"));
    int T=in.nextInt();
    for(int i=0 ; i<T ; ++i){
      doit(i+1);
    }
    out.close();
  }
  public static void main(String[] args)throws IOException {
    new A().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   attribute in : OclFile;
   attribute out : OclFile;
   operation doit( tnum : int) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var d : Sequence(long) ; d := Integer.subrange(1,n)->collect(0) ;
    var l : Sequence(long) ; l := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     d[i+1] := in.getCurrent()->toLong() ; 
     l[i+1] := in.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var D : long ; D := in.getCurrent()->toLong() ;
    var ans : Sequence(long) ; ans := Integer.subrange(1,n)->collect(0) ;
    ans[0+1] := d[0+1] ; 
    var ok : boolean ; ok := false ;
        var i : int ; i := 1 ; while i < n do (     ans[i+1] := -1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (D - d[i+1] <= ans[i+1]) then     ok := true ; else skip ; 
         var j : int ; j := i + 1 ; while j < n do ( (     if ((d[j+1] - d[i+1]) <= ans[i+1]) then (     var attempt : long ; attempt := Set{l[j+1], d[j+1] - d[i+1]}->min() ;
     if (ans[j+1] = -1) then     ans[j+1] := attempt ; else skip ; 
     if (ans[j+1] < attempt) then     ans[j+1] := attempt ; else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.err"].println("Case #" + tnum + ": " + (if ok then "YES" else "NO" endif)) ; 
 );
   operation doit() : void
  pre: true
  post: true
  activity: (     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt"))) ; 
     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("A-large.in"))) ; 
    var T : int ; T := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < T do ( (     execute doit(i + 1) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     A.newA().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class d {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int T=input.nextInt();
    for(int t=0 ; t<T ; t++){
      System.out.printf("Case #%d: ",t+1);
      int n=input.nextInt();
      double[] as=new double[n],bs=new double[n];
      TreeSet<Double>second=new TreeSet<Double>();
      for(int i=0 ; i<n ; i++)as[i]=input.nextDouble();
      for(int i=0 ; i<n ; i++)bs[i]=input.nextDouble();
      for(double d : bs)second.add(d);
      Arrays.sort(as);
      Arrays.sort(bs);
      int res1=0,res2=0 ;
      for(int i=0 ; i<n ; i++){
        Double cur=second.ceiling(as[i]);
        if(cur==null){
          res2++;
          second.remove(second.first());
        }
        else second.remove(cur);
      }
      res1=0 ;
      for(int elim=0 ; elim<n ; elim++){
        int count=0 ;
        for(int i=elim ; i<n ; i++){
          if(as[i]>bs[i-elim])count++;
        }
        res1=Math.max(res1,count);
      }
      System.out.println(res1+" "+res2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class d {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := input.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     OclFile["System.out"].printf("Case #%d: ", t + 1) ; 
     var n : int ; n := input.getCurrent()->toInteger() ;
    var as : Sequence(double) ; as := Integer.subrange(1,n)->collect(0.0) ;
    var bs : Sequence(double) ; bs := Integer.subrange(1,n)->collect(0.0) ;
    var second : Set(double) ; second := Set{} ;
        var i : int ; i := 0 ; while i < n do (     as[i+1] := input.getCurrent()->toReal() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     bs[i+1] := input.getCurrent()->toReal() ;  ;     i := i + 1 ) ; 
    for (d : bs) do (     second := second->including(d) ;  ) ; 
    as := as->sort() ; 
    bs := bs->sort() ; 
    var res1 : int ; res1 := 0 ;
    var res2 : int ; res2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var cur : double ; cur := second.ceiling(as[i+1]) ;
     if (cur = null) then (     res2 := res2 + 1 ; 
     second := second->excludingFirst(second->first()) ) else     second := second->excludingFirst(cur) ; )  ;     i := i + 1 ) ; 
    res1 := 0 ; 
        var elim : int ; elim := 0 ; while elim < n do ( (     var count : int ; count := 0 ;
         var i : int ; i := elim ; while i < n do ( (     if (as[i+1] > bs[i - elim+1]) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     res1 := Set{res1, count}->max() )  ;     elim := elim + 1 ) ; 
    OclFile["System.out"].println(res1 + " " + res2) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int p=sc.nextInt();
    String str=sc.next();
    int[] s=new int[n];
    for(int i=0 ; i<n ; i++){
      s[i]=str.charAt(i)-'0' ;
    }
    int[] u=new int[n+1];
    long[] modCount=new long[p];
    int ten=1 ;
    for(int i=n-1 ; i>=0 ; i--){
      u[i]=(u[i+1]+s[i]*ten)% p ;
      ten=(ten*10)% p ;
    }
    for(int i=0 ; i<=n ; i++){
      modCount[u[i] ]++;
    }
    long ans=0 ;
    if(p==2 || p==5){
      for(int i=n-1 ; i>=0 ; i--){
        if((s[i] % p)==0){
          ans+=i+1 ;
        }
      }
    }
    else {
      for(int i=0 ; i<p ; i++){
        ans+=modCount[i]*(modCount[i]-1)/2 ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
    var str : String ; str := sc.getCurrent() ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := str->at(i+1) - ('0')->char2byte() )  ;     i := i + 1 ) ; 
    var u : Sequence(int) ; u := Integer.subrange(1,n + 1)->collect(0) ;
    var modCount : Sequence(long) ; modCount := Integer.subrange(1,p)->collect(0) ;
    var ten : int ; ten := 1 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     u[i+1] := (u[i + 1+1] + s[i+1] * ten) mod p ; 
     ten := (ten * 10) mod p )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i <= n do ( (     modCount[u[i+1]+1] := modCount[u[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    if (p = 2 or p = 5) then (         var i : int ; i := n - 1 ; while i >= 0 do ( (     if ((s[i+1] mod p) = 0) then (     ans := ans+(i + 1) ) else skip )  ;     i := i - 1 ) ) else (         var i : int ; i := 0 ; while i < p do ( (     ans := ans+(modCount[i+1] * (modCount[i+1] - 1) / 2) )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int n=sc.nextInt();
  long p=sc.nextInt();
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    char[] s=sc.next().toCharArray();
    long ans=0 ;
    long sumMod=0 ;
    Map<Long,Long>map=new HashMap<>();
    if(p==2 || p==5){
      for(int i=n-1 ; 0<=i ; i--){
        if((s[i]-'0')% p==0)ans+=i+1 ;
      }
      System.out.println(ans);
      return ;
    }
    for(int i=n-1 ; 0<=i ; i--){
      long tmp=s[i]-'0' ;
      tmp*=modPow(10,n-1-i);
      tmp %=p ;
      sumMod+=tmp ;
      sumMod %=p ;
      if(map.containsKey(sumMod)){
        map.put(sumMod,map.get(sumMod)+(long)1);
      }
      else {
        map.put(sumMod,(long)1);
      }
    }
    for(Long t : map.values()){
      ans+=t*(t-1)/2 ;
    }
    if(map.get((long)0)==null){
      System.out.println(ans);
    }
    else {
      System.out.println(ans+map.get((long)0));
    }
  }
  long modPow(long x,long n){
    long sum=1 ;
    while(n>0){
      if((n & 1)==1){
        sum*=x ;
        sum %=p ;
      }
      x*=x ;
      x %=p ;
      n>>=1 ;
    }
    return sum % p ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute n : int := sc.getCurrent()->toInteger();
   attribute p : long := sc.getCurrent()->toInteger();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
     var ans : long ; ans := 0 ;
    var sumMod : long ; sumMod := 0 ;
    var map : Map(long,long) ; map := Map{} ;
    if (p = 2 or p = 5) then (         var i : int ; i := n - 1 ; while 0 <= i do ( (     if ((s[i+1] - ('0')->char2byte()) mod p = 0) then     ans := ans+(i + 1) ; else skip )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println(ans) ; 
     return ) else skip ; 
        var i : int ; i := n - 1 ; while 0 <= i do ( (     var tmp : long ; tmp := s[i+1] - ('0')->char2byte() ;
     tmp := tmp*(modPow(10, n - 1 - i)) ; 
    tmp := tmp mod p ; 
    sumMod := sumMod+(tmp) ; 
    sumMod := sumMod mod p ; 
    if (map->keys()->includes(sumMod)) then (     map := map->union(Map{sumMod |-> map->at(sumMod) + 1->oclAsType(long)}) ) else (     map := map->union(Map{sumMod |-> 1->oclAsType(long)}) ) ;  
 )  ;     i := i - 1 ) ; 
    for (t : map->values()) do ( (     ans := ans+(t * (t - 1) / 2) )  ) ; 
    if (map->at(0->oclAsType(long)) = null) then (     OclFile["System.out"].println(ans) ) else (     OclFile["System.out"].println(ans + map->at(0->oclAsType(long))) ) ;  
 );
   operation modPow( x : long, n : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 1 ;
     while (n > 0) do (     if ((MathLib.bitwiseAnd(n,1)) = 1) then (     sum := sum*(x) ; 
     sum := sum mod p ) else skip ; 
     x := x*(x) ; 
     x := x mod p ; 
     n := n/(2->pow(1)) ) ; 
     return sum mod p );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(final String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int n=scanner.nextInt();
    final int p=scanner.nextInt();
    final String s=scanner.next();
    final List<Integer>list=IntStream.range(0,n).mapToObj(i->s.charAt(i)-'0').collect(Collectors.toList());
    long count=0 ;
    if(p==2 || p==5){
      for(int i=0 ; i<list.size(); i++){
        final int digit=list.get(i);
        if(digit % p==0){
          count+=i+1 ;
        }
      }
    }
    else {
      final Map<Long,Long>counter=new HashMap<>();
      long base=1 ;
      long current=0 ;
      Collections.reverse(list);
      for(final int digit : list){
        current=(current+digit*base)% p ;
        base=base*10 % p ;
        if(current % p==0){
          count++;
        }
        if(counter.get(current)!=null){
          count+=counter.get(current);
        }
        counter.compute(current,(k,v)->v==null ? 1 : v+1);
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var p : int ; p := scanner.getCurrent()->toInteger() ;
    var s : String ; s := scanner.getCurrent() ;
    var list : Sequence(int) ; list := Integer.subrange(0, n-1).mapToObj(lambda i : OclAny in s->at(i+1) - ('0')->char2byte()).collect(Collectors.toList()) ;
    var count : long ; count := 0 ;
    if (p = 2 or p = 5) then (         var i : int ; i := 0 ; while i < list->size() do ( (     var digit : int ; digit := list->at(i+1) ;
     if (digit mod p = 0) then (     count := count+(i + 1) ) else skip )  ;     i := i + 1 ) ) else (     var counter : Map(long,long) ; counter := Map{} ;
     var base : long ; base := 1 ;
    var current : long ; current := 0 ;
    list := list->reverse() ; 
    for (digit : list) do ( (     current := (current + digit * base) mod p ; 
     base := base * 10 mod p ; 
    if (current mod p = 0) then (     count := count + 1 ) else skip ; 
    if (counter->at(current) /= null) then (     count := count+(counter->at(current)) ) else skip ; 
    counter := counter.compute(current, lambda (k , v) : OclAny in if v = null then 1 else v + 1 endif) ; 
 )  ) ; 
 ) ;  
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args)throws Exception {
    int N=sc.nextInt();
    int P=sc.nextInt();
    String S=sc.next();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=S.charAt(i)-'0' ;
    }
    long ans=0 ;
    if(P==2 || P==5){
      int c=0 ;
      for(int i=N-1 ; i>=0 ; i--){
        if(A[i] % P==0){
          c++;
        }
        ans+=c ;
      }
    }
    else {
      int m=0 ;
      int k=1 ;
      Map<Integer,Integer>count=new HashMap<>();
      count.put(0,1);
      for(int i=N-1 ; i>=0 ; i--){
        m=(A[i]*k+m)% P ;
        Integer c=count.get(m);
        if(c==null){
          c=1 ;
        }
        else {
          ans+=c ;
          c++;
        }
        count.put(m,c);
        k=(k*10)% P ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var P : int ; P := sc.getCurrent()->toInteger() ;
    var S : String ; S := sc.getCurrent() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := S->at(i+1) - ('0')->char2byte() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    if (P = 2 or P = 5) then (     var c : int ; c := 0 ;
         var i : int ; i := N - 1 ; while i >= 0 do ( (     if (A[i+1] mod P = 0) then (     c := c + 1 ) else skip ; 
     ans := ans+(c) )  ;     i := i - 1 ) ) else (     var m : int ; m := 0 ;
     var k : int ; k := 1 ;
    var count : Map(int,int) ; count := Map{} ;
    count := count->union(Map{0 |-> 1}) ; 
        var i : int ; i := N - 1 ; while i >= 0 do ( (     m := (A[i+1] * k + m) mod P ; 
     var c : int ; c := count->at(m) ;
    if (c = null) then (     c := 1 ) else (     ans := ans+(c) ; 
     c := c + 1 ) ;  
    count := count->union(Map{m |-> c}) ; 
    k := (k * 10) mod P ; 
 )  ;     i := i - 1 ) ; 
 ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt(),p=scanner.nextInt();
      char[] s=scanner.next().toCharArray();
      int[] s2=new int[n];
      IntStream.range(0,n).forEach(i->s2[i]=s[i]-'0');
      int[] m=new int[p];
      long answer=0L ;
      if((2==p)||(5==p)){
        answer=IntStream.range(0,n).mapToLong(i->(0==s2[i] % p)? i+1 : 0L).sum();
      }
      else {
        int now=0 ;
        int digit=1 ;
        m[0]=1 ;
        for(int i=n-1 ; i>=0 ; i--){
          now+=s2[i]*digit ;
          now %=p ;
          answer+=m[now];
          m[now]++;
          digit*=10 ;
          digit %=p ;
        }
      }
      System.out.println(answer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var p : int ; p := scanner.getCurrent()->toInteger() ;
     var s : Sequence(String) ; s := scanner.getCurrent()->characters() ;
    var s2 : Sequence(int) ; s2 := Integer.subrange(1,n)->collect(0) ;
    for i : Integer.subrange(0, n-1) do
    (    s2[i+1] := s[i+1] - ('0')->char2byte()) ; 
    var m : Sequence(int) ; m := Integer.subrange(1,p)->collect(0) ;
    var answer : long ; answer := 0L ;
    if ((2 = p) or (5 = p)) then (     answer := Integer.subrange(0, n-1)->collect( _x1 | (lambda i : OclAny in if (0 = s2[i+1] mod p) then i + 1 else 0L endif)->apply(_x1) )->sum() ) else (     var now : int ; now := 0 ;
     var digit : int ; digit := 1 ;
     m[0+1] := 1 ; 
         var i : int ; i := n - 1 ; while i >= 0 do ( (     now := now+(s2[i+1] * digit) ; 
     now := now mod p ; 
    answer := answer+(m[now+1]) ; 
    m[now+1] := m[now+1] + 1 ; 
    digit := digit*(10) ; 
    digit := digit mod p ; 
 )  ;     i := i - 1 ) ) ;  
    OclFile["System.out"].println(answer) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class Node {
    int data ;
    Node next ;
  }
  static boolean isCircular(Node head){
    if(head==null)return true ;
    Node node=head.next ;
    while(node!=null && node!=head)node=node.next ;
    return(node==head);
  }
  static Node newNode(int data){
    Node temp=new Node();
    temp.data=data ;
    temp.next=null ;
    return temp ;
  }
  public static void main(String args[]){
    Node head=newNode(1);
    head.next=newNode(2);
    head.next.next=newNode(3);
    head.next.next.next=newNode(4);
    System.out.print(isCircular(head)? "Yes\n" : "No\n");
    head.next.next.next.next=head ;
    System.out.print(isCircular(head)? "Yes\n" : "No\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   operation isCircular( head : Node) : boolean
  pre: true
  post: true
  activity: (     if (head = null) then     return true else skip ; 
     var node : Node ; node := head.next ;
     while (node /= null & node /= head) do     node := node.next ; ; 
     return (node = head) );
  static   operation newNode( data : int) : Node
  pre: true
  post: true
  activity: (     var temp : Node ; temp := Node.newNode() ;
     temp.data := data ; 
     temp.next := null ; 
     return temp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := newNode(1) ;
     head.next := newNode(2) ; 
    head.next.next := newNode(3) ; 
    head.next.next.next := newNode(4) ; 
    OclFile["System.out"].print(if isCircular(head) then "Yes\n" else "No\n" endif) ; 
    head.next.next.next.next := head ; 
    OclFile["System.out"].print(if isCircular(head) then "Yes\n" else "No\n" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countOdd(int[] arr,int n){
    int odd=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] % 2==1)odd++;
    }
    return odd ;
  }
  static int countValidPairs(int[] arr,int n){
    int odd=countOdd(arr,n);
    return(odd*(odd-1))/2 ;
  }
  public static void main(String[] args){
    int[] arr={
      1,2,3,4,5 };
      int n=arr.length ;
      System.out.println(countValidPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countOdd( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var odd : int ; odd := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 = 1) then     odd := odd + 1 ; else skip )  ;     i := i + 1 ) ; 
     return odd );
  static   operation countValidPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var odd : int ; odd := countOdd(arr, n) ;
     return (odd * (odd - 1)) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countValidPairs(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class PaymentWithChange {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long a=sc.nextLong();
      long b=sc.nextLong();
      long n=sc.nextLong();
      long s=sc.nextLong();
      if(s/n<=a && s % n<=b)System.out.println("YES");
      else if(s/n>=a &&((((s/n-a)*n)+s % n)<=b))System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PaymentWithChange {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
    var n : long ; n := sc.getCurrent()->toLong() ;
    var s : long ; s := sc.getCurrent()->toLong() ;
    if (s / n <= a & s mod n <= b) then     OclFile["System.out"].println("YES") else     if (s / n >= a & ((((s / n - a) * n) + s mod n) <= b)) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      String buffer=sc.next();
      if(buffer.equals("0")){
        break ;
      }
      int p[]=new int[2];
      int v=0 ;
      for(char ch : buffer.substring(1).toCharArray()){
        v=ch-'A' ;
        p[v]++;
      }
      if(p[0]>p[1]){
        p[0]++;
      }
      else {
        p[1]++;
      }
      System.out.println(p[0]+" "+p[1]);
      buffer=sc.next();
      p=new int[2];
      for(char ch : buffer.substring(1).toCharArray()){
        v=ch-'A' ;
        p[v]++;
      }
      if(p[0]>p[1]){
        p[0]++;
      }
      else {
        p[1]++;
      }
      System.out.println(p[0]+" "+p[1]);
      buffer=sc.next();
      p=new int[2];
      for(char ch : buffer.substring(1).toCharArray()){
        v=ch-'A' ;
        p[v]++;
      }
      if(p[0]>p[1]){
        p[0]++;
      }
      else {
        p[1]++;
      }
      System.out.println(p[0]+" "+p[1]);
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var buffer : String ; buffer := sc.getCurrent() ;
     if (buffer = "0") then (     break ) else skip ; 
    var p : Sequence(int) ; p := Integer.subrange(1,2)->collect(0) ;
    var v : int ; v := 0 ;
    for (ch : buffer.subrange(1+1,1)->characters()) do ( (     v := ch - ('A')->char2byte() ; 
     p[v+1] := p[v+1] + 1 )  ) ; 
    if (p[0+1] > p[1+1]) then (     p[0+1] := p[0+1] + 1 ) else (     p[1+1] := p[1+1] + 1 ) ;  
    OclFile["System.out"].println(p[0+1] + " " + p[1+1]) ; 
    buffer := sc.getCurrent() ; 
    p := Integer.subrange(1,2)->collect(0) ; 
    for (ch : buffer.subrange(1+1,1)->characters()) do ( (     v := ch - ('A')->char2byte() ; 
     p[v+1] := p[v+1] + 1 )  ) ; 
    if (p[0+1] > p[1+1]) then (     p[0+1] := p[0+1] + 1 ) else (     p[1+1] := p[1+1] + 1 ) ;  
    OclFile["System.out"].println(p[0+1] + " " + p[1+1]) ; 
    buffer := sc.getCurrent() ; 
    p := Integer.subrange(1,2)->collect(0) ; 
    for (ch : buffer.subrange(1+1,1)->characters()) do ( (     v := ch - ('A')->char2byte() ; 
     p[v+1] := p[v+1] + 1 )  ) ; 
    if (p[0+1] > p[1+1]) then (     p[0+1] := p[0+1] + 1 ) else (     p[1+1] := p[1+1] + 1 ) ;  
    OclFile["System.out"].println(p[0+1] + " " + p[1+1]) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class lolwa_gamer {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    for(int w=0 ; w<t ; w++){
      int a=s.nextInt();
      int b=s.nextInt();
      int n=s.nextInt();
      long S=s.nextLong();
      if(a>=S/n)S=(S % n);
      else S=S-a*n ;
      if(b>=S){
        System.out.println("YES");
      }
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class lolwa_gamer {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         var w : int ; w := 0 ; while w < t do ( (     var a : int ; a := s.getCurrent()->toInteger() ;
     var b : int ; b := s.getCurrent()->toInteger() ;
    var n : int ; n := s.getCurrent()->toInteger() ;
    var S : long ; S := s.getCurrent()->toLong() ;
    if (a >= S / n) then     S := (S mod n) else     S := S - a * n ; ;  
    if (b >= S) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 )  ;     w := w + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class A {
  static int n ;
  static long[] D ;
  static long[] L ;
  static int[] P ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int cas=1 ; cas<=T ; cas++){
      n=in.nextInt();
      D=new long[n+2];
      L=new long[n+2];
      P=new int[n+2];
      D[0]=0 ;
      L[0]=0 ;
      for(int i=0 ; i<n ; i++){
        D[i+1]=in.nextLong();
        L[i+1]=in.nextLong();
      }
      D[n+1]=in.nextLong();
      L[n+1]=0 ;
      for(int i=0 ; i<n+2 ; i++)P[i]=n+10 ;
      P[1]=0 ;
      for(int c=1 ; c<n+2 ; c++){
        if(P[c]==n+10)continue ;
        long my_len=Math.min(L[c],D[c]-D[P[c] ]);
        for(int nxt=c+1 ; nxt<n+2 && D[nxt]-D[c]<=my_len ; nxt++){
          P[nxt]=Math.min(P[nxt],c);
        }
      }
      System.out.printf("Case #%d: %s\n",cas,P[n+1]==n+10 ? "NO" : "YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute n : int;
  static   attribute D : Sequence(long);
  static   attribute L : Sequence(long);
  static   attribute P : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var cas : int ; cas := 1 ; while cas <= T do ( (     n := in.getCurrent()->toInteger() ; 
     D := Integer.subrange(1,n + 2)->collect(0) ; 
    L := Integer.subrange(1,n + 2)->collect(0) ; 
    P := Integer.subrange(1,n + 2)->collect(0) ; 
    D[0+1] := 0 ; 
    L[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     D[i + 1+1] := in.getCurrent()->toLong() ; 
     L[i + 1+1] := in.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    D[n + 1+1] := in.getCurrent()->toLong() ; 
    L[n + 1+1] := 0 ; 
        var i : int ; i := 0 ; while i < n + 2 do (     P[i+1] := n + 10 ;  ;     i := i + 1 ) ; 
    P[1+1] := 0 ; 
        var c : int ; c := 1 ; while c < n + 2 do ( (     if (P[c+1] = n + 10) then     continue else skip ; 
     var my_len : long ; my_len := Set{L[c+1], D[c+1] - D[P[c+1]+1]}->min() ;
         var nxt : int ; nxt := c + 1 ; while nxt < n + 2 & D[nxt+1] - D[c+1] <= my_len do ( (     P[nxt+1] := Set{P[nxt+1], c}->min() )  ;     nxt := nxt + 1 ) )  ;     c := c + 1 ) ; 
    OclFile["System.out"].printf("Case #%d: %s\n", cas, if P[n + 1+1] = n + 10 then "NO" else "YES" endif) ; 
 )  ;     cas := cas + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PaymentWithoutChange {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      long a=in.nextLong();
      long b=in.nextLong();
      long n=in.nextLong();
      long s=in.nextLong();
      long x=s/n ;
      if(x>=a)x=a ;
      if((x*n)+b>=s)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PaymentWithoutChange {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : long ; a := in.getCurrent()->toLong() ;
     var b : long ; b := in.getCurrent()->toLong() ;
    var n : long ; n := in.getCurrent()->toLong() ;
    var s : long ; s := in.getCurrent()->toLong() ;
    var x : long ; x := s / n ;
    if (x >= a) then     x := a ; else skip ; 
    if ((x * n) + b >= s) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class PaymentWithoutChange {
  public static void main(String[] args)throws FileNotFoundException {
    FastReader in=new FastReader();
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    int t=in.nextInt();
    while(t-->0){
      int a=in.nextInt();
      int b=in.nextInt();
      int n=in.nextInt();
      int s=in.nextInt();
      int mod=s % n ;
      if(mod>b)out.println("NO");
      else if((long)a*n+b>=s)out.println("YES");
      else out.println("NO");
    }
    out.close();
  }
  private static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    FastReader()throws FileNotFoundException {
      br=new BufferedReader(new InputStreamReader(System.getProperty("ONLINE_JUDGE")==null ? new FileInputStream("input.txt"): 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PaymentWithoutChange {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var t : int ; t := in.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := in.nextInt() ;
     var b : int ; b := in.nextInt() ;
    var n : int ; n := in.nextInt() ;
    var s : int ; s := in.nextInt() ;
    var mod : int ; mod := s mod n ;
    if (mod > b) then     skip else     if (a->oclAsType(long) * n + b >= s) then     skip else     skip ; ;  ;  
 ) ;  ) ;  
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(if OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null then OclFile.newOclFile_Read(OclFile.newOclFile("input.txt")) else OclFile["System.in"] endif)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
      boolean found=false ;
      for(int i : arr){
        if(Math.pow(Math.floor(Math.sqrt(i)),2)!=i){
          found=true ;
          break ;
        }
      }
      if(found)System.out.println("YES");
      else System.out.println("NO");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var found : boolean ; found := false ;
    for (i : arr) do ( (     if (((i)->sqrt())->floor()->pow(2) /= i) then (     found := true ; 
     break ) else skip )  ) ; 
    if (found) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      boolean flag=false ;
      int n=sc.nextInt();
      for(int i=0 ; i<n ; i++){
        int a=sc.nextInt();
        int sq=(int)Math.sqrt(a);
        if(sq*sq!=a)flag=true ;
      }
      System.out.println(flag ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var flag : boolean ; flag := false ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var sq : int ; sq := (a)->sqrt()->oclAsType(int) ;
     if (sq * sq /= a) then     flag := true ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if flag then "YES" else "NO" endif) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test309 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      boolean x=true ;
      for(int i=0 ; i<n ; i++){
        int a=in.nextInt();
        int z=(int)Math.sqrt(a);
        if(z*z!=a){
          x=false ;
        }
      }
      if(x){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test309 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var x : boolean ; x := true ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var z : int ; z := (a)->sqrt()->oclAsType(int) ;
     if (z * z /= a) then (     x := false ) else skip )  ;     i := i + 1 ) ; 
     if (x) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isArmstrong(int x,int n){
    int sum1=0 ;
    int temp=x ;
    while(temp>0){
      int digit=temp % 10 ;
      sum1+=Math.pow(digit,n);
      temp/=10 ;
    }
    return sum1==x ;
  }
  static void CalculateXORandOR(int n){
    int CalculateXOR=0 ;
    int CalculateOR=0 ;
    int start=(int)Math.pow(10,n-1);
    int end=(int)(Math.pow(10,n))-1 ;
    for(int i=start ; i<end+1 ; i++){
      if(isArmstrong(i,n)){
        CalculateXOR=CalculateXOR ^ i ;
        CalculateOR=CalculateOR | i ;
      }
    }
    System.out.println("XOR="+CalculateXOR);
    System.out.println("OR="+CalculateOR);
  }
  public static void main(String[] args){
    int n=4 ;
    CalculateXORandOR(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isArmstrong( x : int, n : int) : boolean
  pre: true
  post: true
  activity: (     var sum1 : int ; sum1 := 0 ;
     var temp : int ; temp := x ;
     while (temp > 0) do (     var digit : int ; digit := temp mod 10 ;
     sum1 := sum1+(digit->pow(n)) ; 
     temp := temp/(10) ) ; 
     return sum1 = x );
  static   operation CalculateXORandOR( n : int) : void
  pre: true
  post: true
  activity: (     var CalculateXOR : int ; CalculateXOR := 0 ;
     var CalculateOR : int ; CalculateOR := 0 ;
    var start : int ; start := 10->pow(n - 1)->oclAsType(int) ;
    var end : int ; end := (10->pow(n))->oclAsType(int) - 1 ;
        var i : int ; i := start ; while i < end + 1 do ( (     if (isArmstrong(i, n)) then (     CalculateXOR := MathLib.bitwiseXor(CalculateXOR,i) ; 
     CalculateOR := MathLib.bitwiseOr(CalculateOR,i) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("XOR=" + CalculateXOR) ; 
    OclFile["System.out"].println("OR=" + CalculateOR) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     execute CalculateXORandOR(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Vector<Integer>c=new Vector<>();
  static int ans=0 ;
  static void subsetSum(int i,int curr){
    if(i==c.size()){
      ans+=curr ;
      return ;
    }
    subsetSum(i+1,curr+c.elementAt(i));
    subsetSum(i+1,curr);
  }
  static void subsetGen(int[] arr,int i,int n){
    if(i==n){
      subsetSum(0,0);
      return ;
    }
    subsetGen(arr,i+1,n);
    c.add(arr[i]);
    subsetGen(arr,i+1,n);
    c.remove(c.size()-1);
  }
  public static void main(String[] args){
    int[] arr={
      1,1 };
      int n=arr.length ;
      subsetGen(arr,0,n);
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute c : Sequence(int) := Sequence{};
  static   attribute ans : int := 0;
  static   operation subsetSum( i : int, curr : int) : void
  pre: true
  post: true
  activity: (     if (i = c->size()) then (     ans := ans+(curr) ; 
     return ) else skip ; 
     execute subsetSum(i + 1, curr + c->at(i+1)) ; 
     execute subsetSum(i + 1, curr) );
  static   operation subsetGen( arr : Sequence(int), i : int, n : int) : void
  pre: true
  post: true
  activity: (     if (i = n) then (     execute subsetSum(0, 0) ; 
     return ) else skip ; 
     execute subsetGen(arr, i + 1, n) ; 
    c := c->including(arr[i+1]) ; 
    execute subsetGen(arr, i + 1, n) ; 
    c := c->excludingFirst(c->size() - 1) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1} ;
     var n : int ; n := arr->size() ;
     execute subsetGen(arr, 0, n) ; 
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class LoginVerification {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String newLogin=in.next().toLowerCase().replace("o","0").replace("l","1").replace("i","1");
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      String existingLogin=in.next().toLowerCase().replace("o","0").replace("l","1").replace("i","1");
      if(newLogin.equals(existingLogin)){
        System.out.println("No");
        return ;
      }
    }
    System.out.println("Yes");
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class LoginVerification {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var newLogin : String ; newLogin := in.getCurrent()->toLowerCase().replace("o", "0").replace("l", "1").replace("i", "1") ;
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var existingLogin : String ; existingLogin := in.getCurrent()->toLowerCase().replace("o", "0").replace("l", "1").replace("i", "1") ;
     if (newLogin = existingLogin) then (     OclFile["System.out"].println("No") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Yes") ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class A928 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String S=normalize(in.next());
    int N=in.nextInt();
    Set<String>set=new HashSet<>();
    for(int n=0 ; n<N ; n++){
      set.add(normalize(in.next()));
    }
    System.out.println(set.contains(S)? "No" : "Yes");
  }
  private static String normalize(String s){
    s=s.toUpperCase();
    s=s.replace('O','0');
    s=s.replace('L','1');
    s=s.replace('I','1');
    return s ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A928 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := normalize(in.getCurrent()) ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var set : Set(String) ; set := Set{} ;
        var n : int ; n := 0 ; while n < N do ( (     set := set->including(normalize(in.getCurrent())) )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(if set->includes(S) then "No" else "Yes" endif) ; 
 );
  static   operation normalize( s : String) : String
  pre: true
  post: true
  activity: (     s := s->toUpperCase() ; 
     s := s.replace('O', '0') ; 
    s := s.replace('L', '1') ; 
    s := s.replace('I', '1') ; 
    return s 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class LoginVer {
  static class InputReader {
    BufferedReader reader ;
    StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
  }
  static InputReader r=new InputReader(System.in);
  static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args){
    String s=convert(r.next());
    int n=r.nextInt();
    String[] arr=new String[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=convert(r.next());
    }
    pw.println(check(s,arr)? "Yes" : "No");
    pw.close();
  }
  public static boolean check(String s,String[] arr){
    for(String str : arr){
      if(s.equals(str)){
        return false ;
      }
    }
    return true ;
  }
  public static String convert(String s){
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<s.length(); i++){
      char c=s.charAt(i);
      if(c=='O' || c=='o'){
        sb.append('0');
      }
      else if(c=='l' || c=='L' || c=='i' || c=='I'){
        sb.append('1');
      }
      else {
        sb.append(c);
      }
    }
    return sb.toString().toUpperCase();
  }
}
------------------------------------------------------------
OCL File:
---------
 class LoginVer {
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
  static   attribute r : InputReader := InputReader.newInputReader(OclFile["System.in"]);
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := convert(r.next()) ;
     var n : int ; n := r.nextInt() ;
    var arr : Sequence(String) ; arr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := convert(r.next()) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation check( s : String, arr : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     for (str : arr) do ( (     if (s = str) then (     return false ) else skip )  ) ; 
     return true );
  static   operation convert( s : String) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < s->size() do ( (     var c : String ; c := s->at(i+1) ;
     if (c = 'O' or c = 'o') then (     sb := sb + StringLib.newString('0') ) else     if (c = 'l' or c = 'L' or c = 'i' or c = 'I') then (     sb := sb + StringLib.newString('1') ) else (     sb := sb + StringLib.newString(c) ) ;  )  ;     i := i + 1 ) ; 
     return sb+""->toUpperCase() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minPower(int n,int x){
    if(x==1)return n ;
    int ans=0 ;
    while(n>0){
      ans+=(n % x);
      n/=x ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int n=5,x=3 ;
    System.out.println(minPower(n,x));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minPower( n : int, x : int) : int
  pre: true
  post: true
  activity: (     if (x = 1) then     return n else skip ; 
     var ans : int ; ans := 0 ;
     while (n > 0) do (     ans := ans+((n mod x)) ; 
     n := n/(x) ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var x : int ; x := 3 ;
     OclFile["System.out"].println(minPower(n, x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class A {
  static Scanner sc=new Scanner(System.in);
  static class Solver {
    int N ;
    int[] ds ;
    int[] ls ;
    int D ;
    boolean solve(){
      N=sc.nextInt();
      ds=new int[N];
      ls=new int[N];
      for(int i=0 ; i<N ; ++i){
        ds[i]=sc.nextInt();
        ls[i]=sc.nextInt();
      }
      D=sc.nextInt();
      int[] reach=new int[N];
      Arrays.fill(reach,-1);
      if(ds[0]>ls[0])return false ;
      reach[0]=ds[0];
      for(int i=0 ; i<N ; ++i){
        if(reach[i]<0)continue ;
        if(reach[i]>=D-ds[i])return true ;
        for(int j=i+1 ; j<N ; ++j){
          if(reach[j]>=0)continue ;
          if(ds[j]>ds[i]+reach[i])break ;
          reach[j]=Math.min(ds[j]-ds[i],ls[j]);
        }
      }
      return false ;
    }
  }
  public static void main(String[] args){
    int T=sc.nextInt();
    for(int i=1 ; i<=T ; ++i){
      System.out.print("Case #"+i+": ");
      Solver solver=new Solver();
      System.out.println(solver.solve()? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static class Solver {
   attribute N : int;
   attribute ds : Sequence(int);
   attribute ls : Sequence(int);
   attribute D : int;
   operation solve() : boolean
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     ds := Integer.subrange(1,N)->collect(0) ; 
    ls := Integer.subrange(1,N)->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     ds[i+1] := sc.getCurrent()->toInteger() ; 
     ls[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    D := sc.getCurrent()->toInteger() ; 
    var reach : Sequence(int) ; reach := Integer.subrange(1,N)->collect(0) ;
    reach := reach->collect(-1) ; 
    if (ds[0+1] > ls[0+1]) then     return false else skip ; 
    reach[0+1] := ds[0+1] ; 
        var i : int ; i := 0 ; while i < N do ( (     if (reach[i+1] < 0) then     continue else skip ; 
     if (reach[i+1] >= D - ds[i+1]) then     return true else skip ; 
         var j : int ; j := i + 1 ; while j < N do ( (     if (reach[j+1] >= 0) then     continue else skip ; 
     if (ds[j+1] > ds[i+1] + reach[i+1]) then     break else skip ; 
     reach[j+1] := Set{ds[j+1] - ds[i+1], ls[j+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return false 
 );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= T do ( (     OclFile["System.out"].print("Case #" + i + ": ") ; 
     var solver : Solver ; solver := Solver.newSolver() ;
     OclFile["System.out"].println(if solver.solve() then "YES" else "NO" endif) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
class GFG {
  static boolean isVowel(char x){
    if(x=='a' || x=='e' || x=='i' || x=='o' || x=='u')return true ;
    else return false ;
  }
  static String updateSandwichedVowels(String a){
    int n=a.length();
    String updatedString="" ;
    for(int i=0 ; i<n ; i++){
      if(i==0 || i==n-1){
        updatedString+=a.charAt(i);
        continue ;
      }
      if(isVowel(a.charAt(i))==true && isVowel(a.charAt(i-1))==false && isVowel(a.charAt(i+1))==false){
        continue ;
      }
      updatedString+=a.charAt(i);
    }
    return updatedString ;
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    String updatedString=updateSandwichedVowels(str);
    System.out.print(updatedString);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isVowel( x : String) : boolean
  pre: true
  post: true
  activity: (     if (x = 'a' or x = 'e' or x = 'i' or x = 'o' or x = 'u') then     return true else     return false );
  static   operation updateSandwichedVowels( a : String) : String
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() ;
     var updatedString : String ; updatedString := "" ;
         var i : int ; i := 0 ; while i < n do ( (     if (i = 0 or i = n - 1) then (     updatedString := updatedString+(a->at(i+1)) ; 
     continue ) else skip ; 
     if (isVowel(a->at(i+1)) = true & isVowel(a->at((i)->char2byte() - 1+1)) = false & isVowel(a->at(i + 1+1)) = false) then (     continue ) else skip ; 
     updatedString := updatedString+(a->at(i+1)) )  ;     i := i + 1 ) ; 
     return updatedString );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var updatedString : String ; updatedString := updateSandwichedVowels(str) ;
     OclFile["System.out"].print(updatedString) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int max_element(int[] arr){
    int max=arr[0];
    for(int ele : arr)if(max<ele)max=ele ;
    return max ;
  }
  static int calculateDifference(int[] arr,int n){
    int max_val=max_element(arr);
    boolean[] prime=new boolean[max_val+1];
    Arrays.fill(prime,true);
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=max_val ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=max_val ; i+=p)prime[i]=false ;
      }
    }
    int x1=1,x2=1 ;
    for(int i=0 ; i<n ; i++){
      if(prime[arr[i] ])x1 ^=arr[i];
      else if(arr[i]!=1)x2 ^=arr[i];
    }
    return Math.abs(x1-x2);
  }
  public static void main(String[] args){
    int[] arr={
      1,3,5,10,15,7 };
      int n=arr.length ;
      System.out.println(calculateDifference(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation max_element( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var max : int ; max := arr[0+1] ;
     for (ele : arr) do (     if (max < ele) then     max := ele ; else skip ;  ) ; 
     return max );
  static   operation calculateDifference( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max_val : int ; max_val := max_element(arr) ;
     var prime : Sequence(boolean) ; prime := Integer.subrange(1,max_val + 1)->collect(false) ;
    prime := prime->collect(true) ; 
    prime[0+1] := false ; 
    prime[1+1] := false ; 
        var p : int ; p := 2 ; while p * p <= max_val do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= max_val do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var x1 : int ; x1 := 1 ;
    var x2 : int ; x2 := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (prime[arr[i+1]+1]) then     x1 := MathLib.bitwiseXor(x1,arr[i+1]) ; else     if (arr[i+1] /= 1) then     x2 := MathLib.bitwiseXor(x2,arr[i+1]) ; else skip ; )  ;     i := i + 1 ) ; 
    return if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,5,10,15,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(calculateDifference(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CircleMetro {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int x=sc.nextInt();
    int b=sc.nextInt();
    int y=sc.nextInt();
    a--;
    b--;
    x--;
    y--;
    while(true){
      if(a==b){
        System.out.println("YES");
        return ;
      }
      if(a==x || b==y){
        break ;
      }
      a=(a+1)% n ;
      b=(b-1+n)% n ;
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class CircleMetro {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    a := a - 1 ; 
    b := b - 1 ; 
    x := x - 1 ; 
    y := y - 1 ; 
    while (true) do (     if (a = b) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
     if (a = x or b = y) then (     break ) else skip ; 
     a := (a + 1) mod n ; 
     b := (b - 1 + n) mod n ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CircleMetro {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int x=sc.nextInt();
    int b=sc.nextInt();
    int y=sc.nextInt();
    a--;
    b--;
    x--;
    y--;
    while(true){
      if(a==b){
        System.out.println("YES");
        return ;
      }
      if(a==x || b==y){
        break ;
      }
      a=(a+1)% n ;
      b=(b-1+n)% n ;
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class CircleMetro {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    a := a - 1 ; 
    b := b - 1 ; 
    x := x - 1 ; 
    y := y - 1 ; 
    while (true) do (     if (a = b) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
     if (a = x or b = y) then (     break ) else skip ; 
     a := (a + 1) mod n ; 
     b := (b - 1 + n) mod n ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPrime(int n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static int findSmallest(int N){
    if(N==0)return 2 ;
    if(N==1)return 1 ;
    int prime=N,counter=0 ;
    boolean found=false ;
    while(! found){
      if(isPrime(prime))found=true ;
      else {
        prime++;
        counter++;
      }
    }
    return counter ;
  }
  public static void main(String[] args){
    int N=10 ;
    System.out.print(findSmallest(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation findSmallest( N : int) : int
  pre: true
  post: true
  activity: (     if (N = 0) then     return 2 else skip ; 
     if (N = 1) then     return 1 else skip ; 
    var prime : int ; prime := N ;
    var counter : int ; counter := 0 ;
    var found : boolean ; found := false ;
    while (not(found)) do (     if (isPrime(prime)) then     found := true ; else (     prime := prime + 1 ; 
     counter := counter + 1 ) ) ; 
    return counter 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 10 ;
     OclFile["System.out"].print(findSmallest(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPowerOfTwo(int n){
    return(n>0 &&((n &(n-1))==0))? true : false ;
  }
  static int findPosition(int n){
    if(! isPowerOfTwo(n))return-1 ;
    int i=1,pos=1 ;
    while((i & n)==0){
      i=i<<1 ;
++pos ;
    }
    return pos ;
  }
  public static void main(String[] args){
    int n=16 ;
    int pos=findPosition(n);
    if(pos==-1)System.out.println("n="+n+",Invalid number");
    else System.out.println("n="+n+",Position "+pos);
    n=12 ;
    pos=findPosition(n);
    if(pos==-1)System.out.println("n="+n+",Invalid number");
    else System.out.println("n="+n+",Position "+pos);
    n=128 ;
    pos=findPosition(n);
    if(pos==-1)System.out.println("n="+n+",Invalid number");
    else System.out.println("n="+n+",Position "+pos);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPowerOfTwo( n : int) : boolean
  pre: true
  post: true
  activity: (     return if (n > 0 & ((n & (n - 1)) = 0)) then true else false endif );
  static   operation findPosition( n : int) : int
  pre: true
  post: true
  activity: (     if (not(isPowerOfTwo(n))) then     return -1 else skip ; 
     var i : int ; i := 1 ;
    var pos : int ; pos := 1 ;
     while ((MathLib.bitwiseAnd(i,n)) = 0) do (     i := (i*(2->pow(1)))->oclAsType(long) ; 
     pos := pos + 1 ) ; 
     return pos );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 16 ;
     var pos : int ; pos := findPosition(n) ;
    if (pos = -1) then     OclFile["System.out"].println("n=" + n + ",Invalid number") else     OclFile["System.out"].println("n=" + n + ",Position " + pos) ; ;  
    n := 12 ; 
    pos := findPosition(n) ; 
    if (pos = -1) then     OclFile["System.out"].println("n=" + n + ",Invalid number") else     OclFile["System.out"].println("n=" + n + ",Position " + pos) ; ;  
    n := 128 ; 
    pos := findPosition(n) ; 
    if (pos = -1) then     OclFile["System.out"].println("n=" + n + ",Invalid number") else     OclFile["System.out"].println("n=" + n + ",Position " + pos) ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n==1){
      System.out.println("Hello World");
      return ;
    }
    if(n==2){
      int a=sc.nextInt();
      int b=sc.nextInt();
      System.out.println(a+b);
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 1) then (     OclFile["System.out"].println("Hello World") ; 
     return ) else skip ; 
     if (n = 2) then (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(a + b) ; 
     return ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean canPlace(int a[],int n,int p,int sep){
    int prisoners_placed=1 ;
    int last_prisoner_placed=a[0];
    for(int i=1 ; i<n ; i++){
      int current_cell=a[i];
      if(current_cell-last_prisoner_placed>=sep){
        prisoners_placed++;
        last_prisoner_placed=current_cell ;
        if(prisoners_placed==p){
          return true ;
        }
      }
    }
    return false ;
  }
  static int maxDistance(int cell[],int n,int p){
    Arrays.sort(cell);
    int start=0 ;
    int end=cell[n-1]-cell[0];
    int ans=0 ;
    while(start<=end){
      int mid=start+((end-start)/2);
      if(canPlace(cell,n,p,mid)){
        ans=mid ;
        start=mid+1 ;
      }
      else {
        end=mid-1 ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int cell[]={
      1,2,8,4,9 };
      int n=cell.length ;
      int p=3 ;
      System.out.println(maxDistance(cell,n,p));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation canPlace( a : Sequence(int), n : int, p : int, sep : int) : boolean
  pre: true
  post: true
  activity: (     var prisoners_placed : int ; prisoners_placed := 1 ;
     var last_prisoner_placed : int ; last_prisoner_placed := a[0+1] ;
         var i : int ; i := 1 ; while i < n do ( (     var current_cell : int ; current_cell := a[i+1] ;
     if (current_cell - last_prisoner_placed >= sep) then (     prisoners_placed := prisoners_placed + 1 ; 
     last_prisoner_placed := current_cell ; 
     if (prisoners_placed = p) then (     return true ) else skip ) else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation maxDistance( cell : Sequence(int), n : int, p : int) : int
  pre: true
  post: true
  activity: (     cell := cell->sort() ; 
     var start : int ; start := 0 ;
    var end : int ; end := cell[n - 1+1] - cell[0+1] ;
    var ans : int ; ans := 0 ;
    while (start <= end) do (     var mid : int ; mid := start + ((end - start) / 2) ;
     if (canPlace(cell, n, p, mid)) then (     ans := mid ; 
     start := mid + 1 ) else (     end := mid - 1 ) ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cell : Sequence(int) ; cell := Sequence{1,2,8,4,9} ;
     var n : int ; n := cell->size() ;
     var p : int ; p := 3 ;
     OclFile["System.out"].println(maxDistance(cell, n, p)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  static int sum_of_series(int n){
    int result=0 ;
    if(n % 2==0){
      result=-(n*(n+1))/2 ;
    }
    else {
      result=(n*(n+1))/2 ;
    }
    return result ;
  }
  public static void main(String args[]){
    int n=3 ;
    System.out.println(sum_of_series(n));
    n=10 ;
    System.out.println(sum_of_series(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sum_of_series( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     if (n mod 2 = 0) then (     result := -(n * (n + 1)) / 2 ) else (     result := (n * (n + 1)) / 2 ) ;  
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(sum_of_series(n)) ; 
     n := 10 ; 
     OclFile["System.out"].println(sum_of_series(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void find_max(int[] A,int N,int K){
    HashMap<Integer,Integer>Count=new HashMap<>();
    for(int i=0 ; i<K-1 ; i++)if(Count.containsKey(A[i]))Count.put(A[i],1+Count.get(A[i]));
    else Count.put(A[i],1);
    TreeSet<Integer>Myset=new TreeSet<Integer>();
    for(Map.Entry x : Count.entrySet()){
      if(Integer.parseInt(String.valueOf(x.getValue()))==1)Myset.add(Integer.parseInt(String.valueOf(x.getKey())));
    }
    for(int i=K-1 ; i<N ; i++){
      if(Count.containsKey(A[i]))Count.put(A[i],1+Count.get(A[i]));
      else Count.put(A[i],1);
      if(Integer.parseInt(String.valueOf(Count.get(A[i])))==1)Myset.add(A[i]);
      else Myset.remove(A[i]);
      if(Myset.size()==0)System.out.println("Nothing");
      else System.out.println(Myset.last());
      int x=A[i-K+1];
      Count.put(x,Count.get(x)-1);
      if(Integer.parseInt(String.valueOf(Count.get(x)))==1)Myset.add(x);
      if(Integer.parseInt(String.valueOf(Count.get(x)))==0)Myset.remove(x);
    }
  }
  public static void main(String args[]){
    int[] a={
      1,2,2,3,3 };
      int n=a.length ;
      int k=3 ;
      find_max(a,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation find_max( A : Sequence(int), N : int, K : int) : void
  pre: true
  post: true
  activity: (     var Count : Map(int,int) ; Count := Map{} ;
         var i : int ; i := 0 ; while i < K - 1 do (     if (Count->keys()->includes(A[i+1])) then     Count := Count->union(Map{A[i+1] |-> 1 + Count->at(A[i+1])}) else     Count := Count->union(Map{A[i+1] |-> 1}) ; ;   ;     i := i + 1 ) ; 
    var Myset : Set(int) ; Myset := Set{} ;
    for (x : Count->asSet()) do ( (     if ((((x.getValue()) + ""))->toInteger() = 1) then     Myset := Myset->including((((x.getKey()) + ""))->toInteger()) ; else skip )  ) ; 
        var i : int ; i := K - 1 ; while i < N do ( (     if (Count->keys()->includes(A[i+1])) then     Count := Count->union(Map{A[i+1] |-> 1 + Count->at(A[i+1])}) else     Count := Count->union(Map{A[i+1] |-> 1}) ; ;  
     if ((((Count->at(A[i+1])) + ""))->toInteger() = 1) then     Myset := Myset->including(A[i+1]) else     Myset := Myset->excludingFirst(A[i+1]) ; ;  
    if (Myset->size() = 0) then     OclFile["System.out"].println("Nothing") else     OclFile["System.out"].println(Myset->last()) ; ;  
    var x : int ; x := A[i - K + 1+1] ;
    Count := Count->union(Map{x |-> Count->at(x) - 1}) ; 
    if ((((Count->at(x)) + ""))->toInteger() = 1) then     Myset := Myset->including(x) ; else skip ; 
    if ((((Count->at(x)) + ""))->toInteger() = 0) then     Myset := Myset->excludingAt(x+1) ; else skip ; 
 )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,2,3,3} ;
     var n : int ; n := a->size() ;
     var k : int ; k := 3 ;
     execute find_max(a, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int x=sc.nextInt();
    int cnt=0 ;
    for(int i=0 ; i<=a ; i++){
      for(int j=0 ; j<=b ; j++){
        for(int k=0 ; k<=c ; k++){
          if(500*i+100*j+50*k==x){
            cnt++;
          }
        }
      }
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i <= a do ( (         var j : int ; j := 0 ; while j <= b do ( (         var k : int ; k := 0 ; while k <= c do ( (     if (500 * i + 100 * j + 50 * k = x) then (     cnt := cnt + 1 ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static boolean isPalindrome(float num){
    String s=String.valueOf(num);
    int low=0 ;
    int high=s.length()-1 ;
    while(low<high){
      if(s.charAt(low)!=s.charAt(high))return false ;
      low++;
      high--;
    }
    return true ;
  }
  public static void main(String args[]){
    float n=123.321f ;
    if(isPalindrome(n))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPalindrome( num : double) : boolean
  pre: true
  post: true
  activity: (     var s : String ; s := ((num) + "") ;
     var low : int ; low := 0 ;
    var high : int ; high := s->size() - 1 ;
    while (low < high) do (     if (s->at(low+1) /= s->at(high+1)) then     return false else skip ; 
     low := low + 1 ; 
     high := high - 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 123.321f ;
     if (isPalindrome(n)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ABC087BCoins solver=new ABC087BCoins();
    solver.solve(1,in,out);
    out.close();
  }
  static class ABC087BCoins {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int a=in.nextInt();
      int b=in.nextInt();
      int c=in.nextInt();
      int x=in.nextInt();
      int ans=0 ;
      for(int i=0 ; i<=a ; i++){
        for(int j=0 ; j<=b ; j++){
          for(int k=0 ; k<=c ; k++){
            int total=(500*i)+(100*j)+(50*k);
            if(total==x)ans++;
          }
        }
      }
      System.out.println(String.valueOf(ans));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ABC087BCoins ; solver := ABC087BCoins.newABC087BCoins() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ABC087BCoins {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i <= a do ( (         var j : int ; j := 0 ; while j <= b do ( (         var k : int ; k := 0 ; while k <= c do ( (     var total : int ; total := (500 * i) + (100 * j) + (50 * k) ;
     if (total = x) then     ans := ans + 1 ; else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(((ans) + "")) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  int A=0 ;
  int B=0 ;
  int C=0 ;
  int X=0 ;
  int count=0 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    A=sc.nextInt();
    B=sc.nextInt();
    C=sc.nextInt();
    X=sc.nextInt();
    for(int i=0 ; i<=A ; i++){
      for(int j=0 ; j<=B ; j++){
        for(int k=0 ; k<=C ; k++){
          if(i*500+j*100+k*50==X){
            count++;
          }
        }
      }
    }
    System.out.println(count);
    sc.close();
  }
  void debug(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute A : int := 0;
   attribute B : int := 0;
   attribute C : int := 0;
   attribute X : int := 0;
   attribute count : int := 0;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     A := sc.getCurrent()->toInteger() ; 
    B := sc.getCurrent()->toInteger() ; 
    C := sc.getCurrent()->toInteger() ; 
    X := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i <= A do ( (         var j : int ; j := 0 ; while j <= B do ( (         var k : int ; k := 0 ; while k <= C do ( (     if (i * 500 + j * 100 + k * 50 = X) then (     count := count + 1 ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    skip ; 
 );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int A=0 ;
    int B=0 ;
    int C=0 ;
    int X=0 ;
    int difference=0 ;
    int judge=0 ;
    Scanner scanner=new Scanner(System.in);
    A=scanner.nextInt();
    B=scanner.nextInt();
    C=scanner.nextInt();
    X=scanner.nextInt();
    for(int i=0 ; i<=A ; i++){
      for(int j=0 ; j<=B ; j++){
        difference=(X-(500*i+100*j))/50 ;
        if(difference>=0 && difference<=C){
          judge++;
        }
      }
    }
    System.out.println(judge);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 0 ;
     var B : int ; B := 0 ;
    var C : int ; C := 0 ;
    var X : int ; X := 0 ;
    var difference : int ; difference := 0 ;
    var judge : int ; judge := 0 ;
    var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    A := scanner.getCurrent()->toInteger() ; 
    B := scanner.getCurrent()->toInteger() ; 
    C := scanner.getCurrent()->toInteger() ; 
    X := scanner.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i <= A do ( (         var j : int ; j := 0 ; while j <= B do ( (     difference := (X - (500 * i + 100 * j)) / 50 ; 
     if (difference >= 0 & difference <= C) then (     judge := judge + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(judge) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=Integer.parseInt(sc.next());
    int B=Integer.parseInt(sc.next());
    int C=Integer.parseInt(sc.next());
    int X=Integer.parseInt(sc.next());
    int res=0 ;
    for(int a=0 ; a<=A ; a++){
      for(int b=0 ; b<=B ; b++){
        int c=(X-a*500-b*100)/50 ;
        if(c>=0 && c<=C)res++;
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := (sc.getCurrent())->toInteger() ;
    var B : int ; B := (sc.getCurrent())->toInteger() ;
    var C : int ; C := (sc.getCurrent())->toInteger() ;
    var X : int ; X := (sc.getCurrent())->toInteger() ;
    var res : int ; res := 0 ;
        var a : int ; a := 0 ; while a <= A do ( (         var b : int ; b := 0 ; while b <= B do ( (     var c : int ; c := (X - a * 500 - b * 100) / 50 ;
     if (c >= 0 & c <= C) then     res := res + 1 ; else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class PushZero {
  static void pushZerosToEnd(int arr[],int n){
    int count=0 ;
    for(int i=0 ; i<n ; i++)if(arr[i]!=0)arr[count++]=arr[i];
    while(count<n)arr[count++]=0 ;
  }
  public static void main(String[] args){
    int arr[]={
      1,9,8,4,0,0,2,7,0,6,0,9 };
      int n=arr.length ;
      pushZerosToEnd(arr,n);
      System.out.println("Array after pushing zeros to the back: ");
      for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class PushZero {
  static   operation pushZerosToEnd( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do (     if (arr[i+1] /= 0) then      arr[count+1] := arr[i+1]  ; count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     while (count < n) do      arr[count+1] := 0  ; count := count + 1 ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,9,8,4,0,0,2,7,0,6,0,9} ;
     var n : int ; n := arr->size() ;
    execute pushZerosToEnd(arr, n) ; 
    OclFile["System.out"].println("Array after pushing zeros to the back: ") ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int extractMaximum(String str){
    int num=0,res=0 ;
    for(int i=0 ; i<str.length(); i++){
      if(Character.isDigit(str.charAt(i)))num=num*10+(str.charAt(i)-'0');
      else {
        res=Math.max(res,num);
        num=0 ;
      }
    }
    return Math.max(res,num);
  }
  public static void main(String[] args){
    String str="100klh564abc365bg" ;
    System.out.println(extractMaximum(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation extractMaximum( str : String) : int
  pre: true
  post: true
  activity: (     var num : int ; num := 0 ;
    var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if ((str->at(i+1) + "")->isMatch("[0-9]")) then     num := num * 10 + (str->at(i+1) - ('0')->char2byte()) ; else (     res := Set{res, num}->max() ; 
     num := 0 ) )  ;     i := i + 1 ) ; 
     return Set{res, num}->max() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "100klh564abc365bg" ;
     OclFile["System.out"].println(extractMaximum(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class Test {
  static int arr[]=new int[] {
    1,2,3,4,5 };
    static void rotate(){
      int x=arr[arr.length-1],i ;
      for(i=arr.length-1 ; i>0 ; i--)arr[i]=arr[i-1];
      arr[0]=x ;
    }
    public static void main(String[] args){
      System.out.println("Given Array is");
      System.out.println(Arrays.toString(arr));
      rotate();
      System.out.println("Rotated Array is");
      System.out.println(Arrays.toString(arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Test {
  static   attribute arr : int := Sequence{1,2,3,4,5};
  static   operation rotate() : void
  pre: true
  post: true
  activity: (     var x : int ; x := arr[arr->size() - 1+1] ;
    var i : int ;
         i := arr->size() - 1 ; while i > 0 do (     arr[i+1] := arr[i - 1+1] ;  ;     i := i - 1 ) ; 
     arr[0+1] := x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Given Array is") ; 
     OclFile["System.out"].println((arr + "")) ; 
    execute rotate() ; 
    OclFile["System.out"].println("Rotated Array is") ; 
    OclFile["System.out"].println((arr + "")) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.System ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextInt()){
      int d=sc.nextInt();
      int sum=0 ;
      for(int i=d ; i<=(600-d); i+=d){
        sum+=i*i*d ;
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextInt()) do (     var d : int ; d := sc.getCurrent()->toInteger() ;
     var sum : int ; sum := 0 ;
         var i : int ; i := d ; while i <= (600 - d) do ( (     sum := sum+(i * i * d) )  ;     i := i+(d) ) ; 
     OclFile["System.out"].println(sum) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class Main {
  static int Y_MIN=0 ;
  static int X_MAX=600 ;
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int X_TANI=sc.nextInt();
      int MENSEKI=0 ;
      for(int i=X_TANI ; i<X_MAX ; i+=X_TANI){
        MENSEKI+=X_TANI*i*i ;
      }
      System.out.println(MENSEKI);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute Y_MIN : int := 0;
  static   attribute X_MAX : int := 600;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var X_TANI : int ; X_TANI := sc.getCurrent()->toInteger() ;
     var MENSEKI : int ; MENSEKI := 0 ;
         var i : int ; i := X_TANI ; while i < X_MAX do ( (     MENSEKI := MENSEKI+(X_TANI * i * i) )  ;     i := i+(X_TANI) ) ; 
     OclFile["System.out"].println(MENSEKI) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String input ;
    int d ;
    while((input=br.readLine())!=null){
      d=Integer.parseInt(input);
      System.out.println(100*(600-d)*(1200-d));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : String ;
     var d : int ;
         input := br.readLine() ;
    while ((input) /= null) do (    skip ; (     d := (input)->toInteger() ; 
     OclFile["System.out"].println(100 * (600 - (d)->char2byte()) * (1200 - (d)->char2byte())) ) ;     input := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int d,s ;
    int i ;
    for(; sc.hasNext(); ){
      d=sc.nextInt();
      s=0 ;
      for(i=d ; i<600 ; i+=d)s+=d*i*i ;
      System.out.println(s);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var d : int ;
    var s : int ;
    var i : int ;
      while sc.hasNext() do ( (     d := sc.nextInt() ; 
     s := 0 ; 
         i := d ; while i < 600 do (     s := s+(d * i * i) ;  ;     i := i+(d) ) ; 
     OclFile["System.out"].println(s) )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long squareDigitSum(String s){
    long lengthN=s.length();
    long result=(lengthN/9)*81+(long)Math.pow((lengthN % 9),2);
    return result ;
  }
  public static void main(String[] args){
    String s="1111" ;
    System.out.println(squareDigitSum(s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation squareDigitSum( s : String) : long
  pre: true
  post: true
  activity: (     var lengthN : long ; lengthN := s->size() ;
     var result : long ; result := (lengthN / 9) * 81 + (lengthN mod 9)->pow(2)->oclAsType(long) ;
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "1111" ;
     OclFile["System.out"].println(squareDigitSum(s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  private static int my_pow(int a){
    return a*a ;
  }
  private static int l_square(int size){
    int sum=0,count=1 ;
    for(int i=size ; i<=600-size ; i=i+size){
      sum=sum+my_pow(count*size)*size ;
      count++;
    }
    return sum ;
  }
  public static void main(String args[])throws IOException {
    ArrayList<Integer>inp=new ArrayList<Integer>();
    ArrayList<Integer>sq_size=new ArrayList<Integer>();
    ArrayList<Integer>res=new ArrayList<Integer>();
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      String str1=scan.next();
      inp.add(Integer.valueOf(str1).intValue());
    }
    for(int i=0 ; i<inp.size(); i++){
      res.add(l_square(inp.get(i)));
    }
    for(int i=0 ; i<res.size(); i++){
      System.out.println(res.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation my_pow( a : int) : int
  pre: true
  post: true
  activity: (     return a * a );
  static   operation l_square( size : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
    var count : int ; count := 1 ;
         var i : int ; i := size ; while i <= 600 - size do ( (     sum := sum + my_pow(count * size) * size ; 
     count := count + 1 )  ;     i := i + size ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inp : Sequence(int) ; inp := Sequence{} ;
     var sq_size : Sequence(int) ; sq_size := Sequence{} ;
    var res : Sequence(int) ; res := Sequence{} ;
    var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (scan.hasNext()) do (     var str1 : String ; str1 := scan.getCurrent() ;
     inp := inp->including((str1)->toInteger()->oclAsType(int)) ) ; 
        var i : int ; i := 0 ; while i < inp->size() do ( (     res := res->including(l_square(inp->at(i+1))) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < res->size() do ( (     OclFile["System.out"].println(res->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPalindrome(String str,int l,int r){
    while(l<r){
      if(str.charAt(l)!=str.charAt(r))return false ;
      l++;
      r--;
    }
    return true ;
  }
  static int CyclicShifts(String str){
    int n=str.length();
    int left=0 ;
    int right=n-1 ;
    str=str+str ;
    int cnt=0 ;
    while(right<2*n-1){
      if(isPalindrome(str,left,right))break ;
      cnt++;
      left++;
      right++;
    }
    return cnt ;
  }
  public static void main(String[] args){
    String str="bccbbaab" ;
    System.out.println(CyclicShifts(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPalindrome( str : String, l : int, r : int) : boolean
  pre: true
  post: true
  activity: (     while (l < r) do (     if (str->at(l+1) /= str->at(r+1)) then     return false else skip ; 
     l := l + 1 ; 
     r := r - 1 ) ; 
     return true );
  static   operation CyclicShifts( str : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var left : int ; left := 0 ;
    var right : int ; right := n - 1 ;
    str := str + str ; 
    var cnt : int ; cnt := 0 ;
    while (right < 2 * n - 1) do (     if (isPalindrome(str, left, right)) then     break else skip ; 
     cnt := cnt + 1 ; 
     left := left + 1 ; 
     right := right + 1 ) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "bccbbaab" ;
     OclFile["System.out"].println(CyclicShifts(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findNumbers(int n){
    String ans="" ;
    for(int i=0 ; i<n-1 ; i++)ans+='7' ;
    String even=ans+'6' ;
    String odd=ans+'7' ;
    System.out.println("Even : "+even);
    System.out.println("Odd : "+odd);
  }
  public static void main(String args[]){
    int n=4 ;
    findNumbers(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNumbers( n : int) : void
  pre: true
  post: true
  activity: (     var ans : String ; ans := "" ;
         var i : int ; i := 0 ; while i < n - 1 do (     ans := ans+('7') ;  ;     i := i + 1 ) ; 
    var even : String ; even := ans + '6' ;
    var odd : String ; odd := ans + '7' ;
    OclFile["System.out"].println("Even : " + even) ; 
    OclFile["System.out"].println("Odd : " + odd) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     execute findNumbers(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SpykeTalks {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int numS=scanner.nextInt();
    int[] numC=new int[numS];
    int[] nArry=new int[numC.length];
    for(int i=0 ; i<numC.length ; i++){
      int id=scanner.nextInt();
      numC[i]=id ;
    }
    sortIntegerArraySelection(numC);
    for(int i=0 ; i<nArry.length ; i++){
      nArry[i]=numC[i];
    }
    int cnt=countPairs(nArry);
    System.out.println(cnt);
  }
  private static void sortIntegerArraySelection(int[] array){
    for(int Srd=0 ; Srd<array.length-1 ; Srd++){
      for(int Sbr=Srd+1 ; Sbr<array.length ; Sbr++){
        if(array[Srd]>array[Sbr]){
          int valorRojo=array[Srd];
          int valorAzul=array[Sbr];
          array[Srd]=valorAzul ;
          array[Sbr]=valorRojo ;
        }
      }
    }
  }
  private static int countPairs(int[] arry){
    int prj=0 ;
    for(int i=1 ; i<arry.length ; i++){
      if(arry[i]==arry[i-1] && arry[i]!=0){
        prj++;
        if(arry.length-i>1){
          if(arry[i]==arry[i-1] && arry[i]==arry[i+1]){
            return-1 ;
          }
        }
      }
    }
    return prj ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class SpykeTalks {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numS : int ; numS := scanner.getCurrent()->toInteger() ;
    var numC : Sequence(int) ; numC := Integer.subrange(1,numS)->collect(0) ;
    var nArry : Sequence(int) ; nArry := Integer.subrange(1,numC->size())->collect(0) ;
        var i : int ; i := 0 ; while i < numC->size() do ( (     var id : int ; id := scanner.getCurrent()->toInteger() ;
     numC[i+1] := id )  ;     i := i + 1 ) ; 
    execute sortIntegerArraySelection(numC) ; 
        var i : int ; i := 0 ; while i < nArry->size() do ( (     nArry[i+1] := numC[i+1] )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := countPairs(nArry) ;
    OclFile["System.out"].println(cnt) ; 
 );
  static   operation sortIntegerArraySelection( array : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var Srd : int ; Srd := 0 ; while Srd < array->size() - 1 do ( (         var Sbr : int ; Sbr := Srd + 1 ; while Sbr < array->size() do ( (     if (array[Srd+1] > array[Sbr+1]) then (     var valorRojo : int ; valorRojo := array[Srd+1] ;
     var valorAzul : int ; valorAzul := array[Sbr+1] ;
     array[Srd+1] := valorAzul ; 
     array[Sbr+1] := valorRojo ) else skip )  ;     Sbr := Sbr + 1 ) )  ;     Srd := Srd + 1 ) );
  static   operation countPairs( arry : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var prj : int ; prj := 0 ;
         var i : int ; i := 1 ; while i < arry->size() do ( (     if (arry[i+1] = arry[i - 1+1] & arry[i+1] /= 0) then (     prj := prj + 1 ; 
     if (arry->size() - i > 1) then (     if (arry[i+1] = arry[i - 1+1] & arry[i+1] = arry[i + 1+1]) then (     return -1 ) else skip ) else skip ) else skip )  ;     i := i + 1 ) ; 
     return prj );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
public class ProblemaB {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] secondLine=br.readLine().split(" ");
    br.close();
    ArrayList<Integer>myIds=new ArrayList<>();
    for(String s : secondLine){
      if(! s.equals("0"))myIds.add(Integer.parseInt(s));
    }
    int par=0 ;
    int totalSize=myIds.size();
    while(myIds.size()>0 && par!=-1){
      myIds.removeAll(Arrays.asList(myIds.get(0)));
      if(totalSize-myIds.size()>2){
        par=-1 ;
      }
      else if(totalSize-myIds.size()==2){
        par++;
      }
      totalSize=myIds.size();
    }
    System.out.println(par);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemaB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var secondLine : Sequence(String) ; secondLine := br.readLine()->split(" ") ;
    skip ; 
    var myIds : Sequence(int) ; myIds := Sequence{} ;
    for (s : secondLine) do ( (     if (not(s = "0")) then     myIds := myIds->including((s)->toInteger()) ; else skip )  ) ; 
    var par : int ; par := 0 ;
    var totalSize : int ; totalSize := myIds->size() ;
    while (myIds->size() > 0 & par /= -1) do (     myIds := myIds - myIds->at(0+1) ; 
     if (totalSize - myIds->size() > 2) then (     par := -1 ) else     if (totalSize - myIds->size() = 2) then (     par := par + 1 ) else skip ; ;  
     totalSize := myIds->size() ) ; 
    OclFile["System.out"].println(par) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SpikeTalks {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int result=0 ;
    int nSecretary=sc.nextInt();
    int[] arr=new int[nSecretary];
    for(int i=0 ; i<nSecretary ; i++){
      arr[i]=sc.nextInt();
    }
    if(nSecretary==1){
      result=0 ;
    }
    else {
      booblesSort(arr);
      for(int i=1 ; i<arr.length ; ++i){
        if(arr[i]!=0 && arr[i]==arr[i-1]){
          result++;
          if(i+1<arr.length && arr[i]==arr[i+1]){
            result=-1 ;
            break ;
          }
        }
      }
    }
    System.out.println(result);
  }
  public static void booblesSort(int[] arr){
    for(int i=0 ; i<arr.length ; i++){
      for(int j=1 ; j<arr.length-i ; j++){
        if(arr[j]<arr[j-1]){
          int actual=arr[j];
          int anterior=arr[j-1];
          arr[j-1]=actual ;
          arr[j]=anterior ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SpikeTalks {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var nSecretary : int ; nSecretary := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,nSecretary)->collect(0) ;
        var i : int ; i := 0 ; while i < nSecretary do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (nSecretary = 1) then (     result := 0 ) else (     execute booblesSort(arr) ; 
         var i : int ; i := 1 ; while i < arr->size() do ( (     if (arr[i+1] /= 0 & arr[i+1] = arr[i - 1+1]) then (     result := result + 1 ; 
     if (i + 1 < arr->size() & arr[i+1] = arr[i + 1+1]) then (     result := -1 ; 
     break ) else skip ) else skip )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(result) ; 
 );
  static   operation booblesSort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < arr->size() do ( (         var j : int ; j := 1 ; while j < arr->size() - i do ( (     if (arr[j+1] < arr[j - 1+1]) then (     var actual : int ; actual := arr[j+1] ;
     var anterior : int ; anterior := arr[j - 1+1] ;
     arr[j - 1+1] := actual ; 
     arr[j+1] := anterior ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.*;
public class GFG {
  static int countPairs(int arr[],int n){
    int twoCount=0,twoGrCount=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==2)twoCount++;
      else if(arr[i]>2)twoGrCount++;
    }
    return twoCount*twoGrCount+(twoGrCount*(twoGrCount-1))/2 ;
  }
  public static void main(String args[]){
    int arr[]={
      3,4,5 };
      int n=arr.length ;
      System.out.println(countPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var twoCount : int ; twoCount := 0 ;
    var twoGrCount : int ; twoGrCount := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 2) then     twoCount := twoCount + 1 ; else     if (arr[i+1] > 2) then     twoGrCount := twoGrCount + 1 ; else skip ; )  ;     i := i + 1 ) ; 
     return twoCount * twoGrCount + (twoGrCount * (twoGrCount - 1)) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,4,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countPairs(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class cp {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int T=Integer.parseInt(br.readLine());
    while(T-->0){
      String[] str=br.readLine().split(" ");
      int n=Integer.parseInt(str[0]);
      String[] str1=br.readLine().split(" ");
      long[] arr=new long[n+1];
      long zeros=0 ;
      long sum=0 ;
      boolean flag=false ;
      for(int i=0 ; i<n ; i++){
        arr[i]=Long.parseLong(str1[i]);
        if(i!=n-1)sum+=arr[i];
        if(arr[i]==0 && flag)zeros++;
        if(arr[i]!=0)flag=true ;
      }
      if(arr[n-1]==0 && sum!=0)pw.println(sum+zeros-1);
      else pw.println(sum+zeros);
    }
    pw.flush();
  }
  public static ArrayList<Long>findAllFactors(long num){
    ArrayList<Long>factors=new ArrayList<Long>();
    for(long i=1 ; i<=num/i ; ++i){
      if(num % i==0){
        factors.add(i);
        factors.add(num/i);
      }
    }
    Collections.sort(factors);
    return factors ;
  }
  public static long gcd(long a,long b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := (br.readLine())->toInteger() ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     var n : int ; n := (str[0+1])->toInteger() ;
    var str1 : Sequence(String) ; str1 := br.readLine()->split(" ") ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
    var zeros : long ; zeros := 0 ;
    var sum : long ; sum := 0 ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (str1[i+1])->toLong() ; 
     if (i /= n - 1) then     sum := sum+(arr[i+1]) ; else skip ; 
     if (arr[i+1] = 0 & flag) then     zeros := zeros + 1 ; else skip ; 
     if (arr[i+1] /= 0) then     flag := true ; else skip )  ;     i := i + 1 ) ; 
    if (arr[n - 1+1] = 0 & sum /= 0) then     skip else     skip ; ;  
 ) ;  ) ;  
    skip ; 
 );
  static   operation findAllFactors( num : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var factors : Sequence(long) ; factors := Sequence{} ;
         var i : long ; i := 1 ; while i <= num / i do ( (     if (num mod i = 0) then (     factors := factors->including(i) ; 
     factors := factors->including(num / i) ) else skip )  ;     i := i + 1 ) ; 
     factors := factors->sort() ; 
     return factors );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      int a[]=new int[n];
      int zero=0 ;
      long sum=0 ;
      boolean start=false ;
      for(int i=0 ; i<n ; i++){
        a[i]=input.nextInt();
        if(i!=n-1)sum+=a[i];
        if(a[i]>0 && ! start){
          start=true ;
        }
        if(start && a[i]==0 && i!=n-1){
          zero++;
        }
      }
      System.out.println(zero+sum);
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var tc : int ; tc := input.nextInt() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var zero : int ; zero := 0 ;
    var sum : long ; sum := 0 ;
    var start : boolean ; start := false ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.nextInt() ; 
     if (i /= n - 1) then     sum := sum+(a[i+1]) ; else skip ; 
     if (a[i+1] > 0 & not(start)) then (     start := true ) else skip ; 
     if (start & a[i+1] = 0 & i /= n - 1) then (     zero := zero + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(zero + sum) ; 
 ) ;  ) ;  );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int getFirstSetBitPos(int n){
    return(int)((Math.log10(n &-n))/Math.log10(2))+1 ;
  }
  public static void main(String[] args){
    int n=12 ;
    System.out.println(getFirstSetBitPos(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getFirstSetBitPos( n : int) : int
  pre: true
  post: true
  activity: (     return (((n & -n)->log10()) / (2)->log10())->oclAsType(int) + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     OclFile["System.out"].println(getFirstSetBitPos(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
class GfG {
  static int sumFirst(int a[],int n){
    HashMap<Integer,Integer>mp=new HashMap<>();
    int suf=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      suf+=a[i];
      mp.put(suf,i);
    }
    int pre=0,maxi=-1 ;
    for(int i=0 ; i<n ; i++){
      pre+=a[i];
      if(mp.containsKey(pre)&& mp.get(pre)>i){
        if(pre>maxi){
          maxi=pre ;
        }
      }
    }
    if(maxi==-1)return 0 ;
    else return maxi ;
  }
  public static void main(String[] args){
    int a[]={
      1,3,2,1,4 };
      int n=a.length ;
      System.out.println(sumFirst(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation sumFirst( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
     var suf : int ; suf := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     suf := suf+(a[i+1]) ; 
     mp := mp->union(Map{suf |-> i}) )  ;     i := i - 1 ) ; 
    var pre : int ; pre := 0 ;
    var maxi : int ; maxi := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     pre := pre+(a[i+1]) ; 
     if (mp->keys()->includes(pre) & mp->at(pre) > i) then (     if (pre > maxi) then (     maxi := pre ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (maxi = -1) then     return 0 else     return maxi ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,3,2,1,4} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(sumFirst(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class primesquare {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      for(int j=0 ; j<n ; j++){
        for(int k=0 ; k<n ; k++){
          if(k==j || k==(j+1)% n)System.out.println("1");
          else System.out.println("0");
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class primesquare {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < n do ( (         var k : int ; k := 0 ; while k < n do ( (     if (k = j or k = (j + 1) mod n) then     OclFile["System.out"].println("1") ; else     OclFile["System.out"].println("0") ; )  ;     k := k + 1 ) ; 
     OclFile["System.out"].println() )  ;     j := j + 1 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int countX(int n){
    String binary=Integer.toBinaryString(n);
    int count=0 ;
    for(int i=0 ; i<binary.length(); i++){
      if(binary.charAt(i)=='1')count++;
    }
    int answer=(int)Math.pow(2,count);
    return answer ;
  }
  public static void main(String args[]){
    int n=5 ;
    int answer=countX(n);
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countX( n : int) : int
  pre: true
  post: true
  activity: (     var binary : String ; binary := (MathLib.decimal2binary(n) + "") ;
     var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < binary->size() do ( (     if (binary->at(i+1) = '1') then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    var answer : int ; answer := 2->pow(count)->oclAsType(int) ;
    return answer 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var answer : int ; answer := countX(n) ;
     OclFile["System.out"].println(answer) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class KyoyaPhotobook {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] string=sc.next().toCharArray();
    HashSet<String>stringsPossible=new HashSet<>();
    for(int insertPosition=0 ; insertPosition<=string.length ; insertPosition++){
      for(char c='a' ; c<='z' ; c++){
        StringBuilder sb=new StringBuilder();
        for(int i=0 ; i<insertPosition ; i++){
          sb.append(string[i]);
        }
        sb.append(c);
        for(int i=insertPosition ; i<string.length ; i++){
          sb.append(string[i]);
        }
        stringsPossible.add(sb.toString());
      }
    }
    System.out.println(stringsPossible.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class KyoyaPhotobook {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var string : Sequence(String) ; string := sc.getCurrent()->characters() ;
    var stringsPossible : Set(String) ; stringsPossible := Set{} ;
        var insertPosition : int ; insertPosition := 0 ; while insertPosition <= string->size() do ( (         var c : String ; c := 'a' ; while c <= 'z' do ( (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < insertPosition do ( (     sb := sb + StringLib.newString(string[i+1]) )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(c) ; 
        var i : int ; i := insertPosition ; while i < string->size() do ( (     sb := sb + StringLib.newString(string[i+1]) )  ;     i := i + 1 ) ; 
    stringsPossible := stringsPossible->including(sb+"") ; 
 )  ;     c := c + 1 ) )  ;     insertPosition := insertPosition + 1 ) ; 
    OclFile["System.out"].println(stringsPossible->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static void printElements(int arr[],int n){
    for(int i=1 ; i<n-1 ; i++){
      if(arr[i]>arr[i-1] && arr[i]>arr[i+1])System.out.print(arr[i]+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      2,3,1,5,4,9,8,7,5 };
      int n=arr.length ;
      printElements(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation printElements( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < n - 1 do ( (     if (arr[i+1] > arr[i - 1+1] & arr[i+1] > arr[i + 1+1]) then     OclFile["System.out"].print(arr[i+1] + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,1,5,4,9,8,7,5} ;
     var n : int ; n := arr->size() ;
     execute printElements(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class MissingLetter {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    HashSet<String>hs=new HashSet<>();
    for(int i=0 ; i<=s.length(); i++){
      for(char c='a' ; c<='z' ; c++){
        hs.add(s.substring(0,i)+c+s.substring(i));
      }
    }
    System.out.println(hs.size());
    System.exit(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MissingLetter {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
    var hs : Set(String) ; hs := Set{} ;
        var i : int ; i := 0 ; while i <= s->size() do ( (         var c : String ; c := 'a' ; while c <= 'z' do ( (     hs := hs->including(s.subrange(0+1,i) + c + s.subrange(i+1,i)) )  ;     c := c + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(hs->size()) ; 
OclProcess.exit(0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Code {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=26 ;
    String str=input.next();
    System.out.println(n+25*str.length());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := 26 ;
     var str : String ; str := input.getCurrent() ;
     OclFile["System.out"].println(n + 25 * str->size()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String s=input.next();
    int a=(s.length()+1)*26-s.length();
    System.out.println(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := input.getCurrent() ;
     var a : int ; a := (s->size() + 1) * 26 - s->size() ;
     OclFile["System.out"].println(a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    int n=s.length();
    int k=(n+1)*26-n ;
    System.out.println(k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
    var n : int ; n := s->size() ;
    var k : int ; k := (n + 1) * 26 - (n)->char2byte() ;
    OclFile["System.out"].println(k) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int cntWays(int arr[],int n){
    if(n==1){
      return 0 ;
    }
    int tot_sum=0,sum=0,ans=0 ;
    for(int i=0 ; i<n ; i++){
      tot_sum+=arr[i];
    }
    for(int i=0 ; i<n-1 ; i++){
      sum+=arr[i];
      if(sum==tot_sum/2){
        ans++;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      1,-1,1,-1,1,-1 };
      int n=arr.length ;
      System.out.println(cntWays(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation cntWays( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then (     return 0 ) else skip ; 
     var tot_sum : int ; tot_sum := 0 ;
    var sum : int ; sum := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     tot_sum := tot_sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     sum := sum+(arr[i+1]) ; 
     if (sum = tot_sum / 2) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,-1,1,-1,1,-1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(cntWays(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static int minNumber(int a[],int n,int x){
    int l=0,h=0,e=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]==x)e++;
      else if(a[i]>x)h++;
      else if(a[i]<x)l++;
    }
    int ans=0 ;
    if(l>h)ans=l-h ;
    else if(l<h)ans=h-l-1 ;
    return ans+1-e ;
  }
  public static void main(String[] args){
    int x=10 ;
    int a[]={
      10,20,30 };
      int n=a.length ;
      System.out.println(minNumber(a,n,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minNumber( a : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
    var h : int ; h := 0 ;
    var e : int ; e := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = x) then     e := e + 1 ; else     if (a[i+1] > x) then     h := h + 1 else     if (a[i+1] < x) then     l := l + 1 ; else skip ; ;  )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    if (l > h) then     ans := l - h else     if (l < h) then     ans := h - l - 1 ; else skip ; ;  
    return ans + 1 - e 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 10 ;
     var a : Sequence(int) ; a := Sequence{10,20,30} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(minNumber(a, n, x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isSquarePossible(int arr[],int n,int l){
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]>=l)cnt++;
      if(cnt>=l)return true ;
    }
    return false ;
  }
  static int maxArea(int arr[],int n){
    int l=0,r=n ;
    int len=0 ;
    while(l<=r){
      int m=l+((r-l)/2);
      if(isSquarePossible(arr,n,m)){
        len=m ;
        l=m+1 ;
      }
      else r=m-1 ;
    }
    return(len*len);
  }
  public static void main(String[] args){
    int arr[]={
      1,3,4,5,5 };
      int n=arr.length ;
      System.out.println(maxArea(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isSquarePossible( arr : Sequence(int), n : int, l : int) : boolean
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] >= l) then     cnt := cnt + 1 ; else skip ; 
     if (cnt >= l) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation maxArea( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
    var r : int ; r := n ;
     var len : int ; len := 0 ;
     while (l <= r) do (     var m : int ; m := l + ((r - l) / 2) ;
     if (isSquarePossible(arr, n, m)) then (     len := m ; 
     l := m + 1 ) else     r := m - 1 ; ) ; 
     return (len * len) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,4,5,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxArea(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static void main(String[] args){
    int n=5 ;
    printPascal(n);
  }
  public static void printPascal(int n){
    int[][] arr=new int[n][n];
    for(int line=0 ; line<n ; line++){
      for(int i=0 ; i<=line ; i++){
        if(line==i || i==0)arr[line][i]=1 ;
        else arr[line][i]=arr[line-1][i-1]+arr[line-1][i];
        System.out.print(arr[line][i]);
      }
      System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute printPascal(n) );
  static   operation printPascal( n : int) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
         var line : int ; line := 0 ; while line < n do ( (         var i : int ; i := 0 ; while i <= line do ( (     if (line = i or i = 0) then     arr[line+1][i+1] := 1 else     arr[line+1][i+1] := arr[line - 1+1][i - 1+1] + arr[line - 1+1][i+1] ; ;  
     OclFile["System.out"].print(arr[line+1][i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("") )  ;     line := line + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String printLargestString(String s,int l,int r){
    int freq[]=new int[26];
    l--;
    r--;
    for(int i=Math.min(l,r); i<=Math.max(l,r); i++){
      freq[s.charAt(i)-'a']++;
    }
    String ans="" ;
    for(int i=25 ; i>=0 ; i--){
      while(freq[i]>0){
        ans+=(char)('a'+i);
        freq[i]--;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    String s="striver" ;
    int l=3,r=5 ;
    System.out.println(printLargestString(s,l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printLargestString( s : String, l : int, r : int) : String
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
     l := l - 1 ; 
    r := r - 1 ; 
        var i : int ; i := Set{l, r}->min() ; while i <= Set{l, r}->max() do ( (     freq[s->at(i+1) - ('a')->char2byte()+1] := freq[s->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 25 ; while i >= 0 do ( (     while (freq[i+1] > 0) do (     ans := ans+(('a' + i)->oclAsType(String)) ; 
     freq[i+1] := freq[i+1] - 1 ) )  ;     i := i - 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "striver" ;
     var l : int ; l := 3 ;
    var r : int ; r := 5 ;
     OclFile["System.out"].println(printLargestString(s, l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf60A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    int lo=1 ;
    int hi=n ;
    for(int i=0 ; i<m ; i++){
      scan.next();
      scan.next();
      String dir=scan.next();
      scan.next();
      int num=scan.nextInt();
      if(dir.equals("left")){
        hi=Math.min(hi,num-1);
      }
      else {
        lo=Math.max(lo,num+1);
      }
    }
    if(hi-lo<0){
      System.out.println(-1);
    }
    else {
      System.out.println(hi-lo+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf60A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var lo : int ; lo := 1 ;
    var hi : int ; hi := n ;
        var i : int ; i := 0 ; while i < m do ( (     skip ; 
     skip ; 
    var dir : String ; dir := scan.getCurrent() ;
    skip ; 
    var num : int ; num := scan.getCurrent()->toInteger() ;
    if (dir = "left") then (     hi := Set{hi, (num)->char2byte() - 1}->min() ) else (     lo := Set{lo, num + 1}->max() ) ;  
 )  ;     i := i + 1 ) ; 
    if (hi - lo < 0) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(hi - lo + 1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int valueofX(int ar[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum=sum+ar[i];
    }
    if(sum % n==0){
      return sum/n ;
    }
    else {
      int A=sum/n,B=sum/n+1 ;
      int ValueA=0,ValueB=0 ;
      for(int i=0 ; i<n ; i++){
        ValueA+=(ar[i]-A)*(ar[i]-A);
        ValueB+=(ar[i]-B)*(ar[i]-B);
      }
      if(ValueA<ValueB){
        return A ;
      }
      else {
        return B ;
      }
    }
  }
  public static void main(String args[]){
    int n=7 ;
    int arr[]={
      6,9,1,6,1,3,7 };
      System.out.println(valueofX(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation valueofX( ar : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum + ar[i+1] )  ;     i := i + 1 ) ; 
     if (sum mod n = 0) then (     return sum / n ) else (     var A : int ; A := sum / n ;
    var B : int ; B := sum / n + 1 ;
     var ValueA : int ; ValueA := 0 ;
    var ValueB : int ; ValueB := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     ValueA := ValueA+((ar[i+1] - A) * (ar[i+1] - A)) ; 
     ValueB := ValueB+((ar[i+1] - B) * (ar[i+1] - B)) )  ;     i := i + 1 ) ; 
     if (ValueA < ValueB) then (     return A ) else (     return B ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     var arr : Sequence(int) ; arr := Sequence{6,9,1,6,1,3,7} ;
     OclFile["System.out"].println(valueofX(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf60A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    int left=1 ;
    int right=n ;
    for(int i=0 ; i<m ; i++){
      scan.next();
      scan.next();
      String dir=scan.next();
      scan.next();
      int num=scan.nextInt();
      if(dir.equals("left")){
        right=Math.min(right,num-1);
      }
      else {
        left=Math.max(left,num+1);
      }
    }
    if(left>right){
      System.out.println(-1);
    }
    else {
      System.out.println(right-left+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf60A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var left : int ; left := 1 ;
    var right : int ; right := n ;
        var i : int ; i := 0 ; while i < m do ( (     skip ; 
     skip ; 
    var dir : String ; dir := scan.getCurrent() ;
    skip ; 
    var num : int ; num := scan.getCurrent()->toInteger() ;
    if (dir = "left") then (     right := Set{right, (num)->char2byte() - 1}->min() ) else (     left := Set{left, num + 1}->max() ) ;  
 )  ;     i := i + 1 ) ; 
    if (left > right) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(right - left + 1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf60A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    int[] intArr=new int[n];
    Arrays.fill(intArr,1);
    for(int i=0 ; i<m ; i++){
      String str=scan.next();
      String str1=scan.next();
      String str2=scan.next();
      String str3=scan.next();
      int a=scan.nextInt();
      if(str2.equals("left")){
        for(int b=a-1 ; b<n ; b++){
          intArr[b]=0 ;
        }
      }
      else if(str2.equals("right")){
        for(int b=0 ; b<a ; b++){
          intArr[b]=0 ;
        }
      }
    }
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=intArr[i];
    }
    if(sum==0){
      System.out.println(-1);
    }
    else {
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf60A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var intArr : Sequence(int) ; intArr := Integer.subrange(1,n)->collect(0) ;
    intArr := intArr->collect(1) ; 
        var i : int ; i := 0 ; while i < m do ( (     var str : String ; str := scan.getCurrent() ;
     var str1 : String ; str1 := scan.getCurrent() ;
    var str2 : String ; str2 := scan.getCurrent() ;
    var str3 : String ; str3 := scan.getCurrent() ;
    var a : int ; a := scan.getCurrent()->toInteger() ;
    if (str2 = "left") then (         var b : int ; b := (a)->char2byte() - 1 ; while b < n do ( (     intArr[b+1] := 0 )  ;     b := b + 1 ) ) else     if (str2 = "right") then (         var b : int ; b := 0 ; while b < a do ( (     intArr[b+1] := 0 )  ;     b := b + 1 ) ) else skip ; ;  
 )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(intArr[i+1]) )  ;     i := i + 1 ) ; 
    if (sum = 0) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(sum) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class WhereAreMyFlakes {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int lo=1 ;
    int hi=scan.nextInt();
    int hintCnt=scan.nextInt();
    for(int i=0 ; i<hintCnt ; i++){
      scan.next();
      scan.next();
      String dir=scan.next();
      scan.next();
      int num=scan.nextInt();
      if(dir.equals("right")){
        lo=Math.max(lo,num+1);
      }
      else {
        hi=Math.min(hi,num-1);
      }
    }
    if(lo>hi){
      System.out.println(-1);
    }
    else {
      System.out.println(hi-lo+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class WhereAreMyFlakes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var lo : int ; lo := 1 ;
    var hi : int ; hi := scan.getCurrent()->toInteger() ;
    var hintCnt : int ; hintCnt := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < hintCnt do ( (     skip ; 
     skip ; 
    var dir : String ; dir := scan.getCurrent() ;
    skip ; 
    var num : int ; num := scan.getCurrent()->toInteger() ;
    if (dir = "right") then (     lo := Set{lo, num + 1}->max() ) else (     hi := Set{hi, (num)->char2byte() - 1}->min() ) ;  
 )  ;     i := i + 1 ) ; 
    if (lo > hi) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(hi - lo + 1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf60A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    int lo=1 ;
    int hi=n ;
    for(int i=0 ; i<m ; i++){
      scan.next();
      scan.next();
      String dir=scan.next();
      scan.next();
      int num=scan.nextInt();
      if(dir.equals("left")){
        hi=Math.min(hi,num-1);
      }
      else {
        lo=Math.max(lo,num+1);
      }
    }
    if(hi-lo+1<=0){
      System.out.println(-1);
    }
    else {
      System.out.println(hi-lo+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf60A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var lo : int ; lo := 1 ;
    var hi : int ; hi := n ;
        var i : int ; i := 0 ; while i < m do ( (     skip ; 
     skip ; 
    var dir : String ; dir := scan.getCurrent() ;
    skip ; 
    var num : int ; num := scan.getCurrent()->toInteger() ;
    if (dir = "left") then (     hi := Set{hi, (num)->char2byte() - 1}->min() ) else (     lo := Set{lo, num + 1}->max() ) ;  
 )  ;     i := i + 1 ) ; 
    if (hi - lo + 1 <= 0) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(hi - lo + 1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1323 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int M=in.nextInt();
    int K=in.nextInt();
    int[] A=new int[N+1];
    for(int n=0 ; n<N ; n++){
      A[n]=in.nextInt();
    }
    int[] B=new int[M+1];
    for(int m=0 ; m<M ; m++){
      B[m]=in.nextInt();
    }
    long[] aSegments=new long[N+1];
    int ones=0 ;
    for(int a : A){
      if(a==0){
        for(int i=1 ; i<=ones ; i++){
          aSegments[i]+=ones+1-i ;
        }
        ones=0 ;
      }
      else {
        ones++;
      }
    }
    long[] bSegments=new long[M+1];
    ones=0 ;
    for(int b : B){
      if(b==0){
        for(int i=1 ; i<=ones ; i++){
          bSegments[i]+=ones+1-i ;
        }
        ones=0 ;
      }
      else {
        ones++;
      }
    }
    long answer=0 ;
    for(int d=1 ; d*d<=K ; d++){
      if(K % d==0){
        int dd=K/d ;
        if(d<=N && dd<=M){
          answer+=aSegments[d]*bSegments[dd];
        }
        if(d!=dd && d<=M && dd<=N){
          answer+=aSegments[dd]*bSegments[d];
        }
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1323 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var M : int ; M := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N + 1)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var B : Sequence(int) ; B := Integer.subrange(1,M + 1)->collect(0) ;
        var m : int ; m := 0 ; while m < M do ( (     B[m+1] := in.getCurrent()->toInteger() )  ;     m := m + 1 ) ; 
    var aSegments : Sequence(long) ; aSegments := Integer.subrange(1,N + 1)->collect(0) ;
    var ones : int ; ones := 0 ;
    for (a : A) do ( (     if (a = 0) then (         var i : int ; i := 1 ; while i <= ones do ( (     aSegments[i+1] := aSegments[i+1]+(ones + 1 - i) )  ;     i := i + 1 ) ; 
     ones := 0 ) else (     ones := ones + 1 ) )  ) ; 
    var bSegments : Sequence(long) ; bSegments := Integer.subrange(1,M + 1)->collect(0) ;
    ones := 0 ; 
    for (b : B) do ( (     if (b = 0) then (         var i : int ; i := 1 ; while i <= ones do ( (     bSegments[i+1] := bSegments[i+1]+(ones + 1 - i) )  ;     i := i + 1 ) ; 
     ones := 0 ) else (     ones := ones + 1 ) )  ) ; 
    var answer : long ; answer := 0 ;
        var d : int ; d := 1 ; while d * d <= K do ( (     if (K mod d = 0) then (     var dd : int ; dd := K / d ;
     if (d <= N & dd <= M) then (     answer := answer+(aSegments[d+1] * bSegments[dd+1]) ) else skip ; 
     if (d /= dd & d <= M & dd <= N) then (     answer := answer+(aSegments[dd+1] * bSegments[d+1]) ) else skip ) else skip )  ;     d := d + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int n=in.nextInt();
      if(n==0)break ;
      int xmax=0,xmin=0,ymax=0,ymin=0 ;
      ArrayList<Integer>x=new ArrayList<Integer>();
      ArrayList<Integer>y=new ArrayList<Integer>();
      x.add(0);
      y.add(0);
      for(int i=1 ; i<n ; i++){
        int id=in.nextInt();
        switch(in.nextInt()){
          case 0 : x.add(x.get(id)-1);
          y.add(y.get(id));
          break ;
          case 1 : x.add(x.get(id));
          y.add(y.get(id)-1);
          break ;
          case 2 : x.add(x.get(id)+1);
          y.add(y.get(id));
          break ;
          case 3 : x.add(x.get(id));
          y.add(y.get(id)+1);
          break ;
        }
        xmax=Math.max(xmax,x.get(i));
        xmin=Math.min(xmin,x.get(i));
        ymax=Math.max(ymax,y.get(i));
        ymin=Math.min(ymin,y.get(i));
      }
      System.out.println((xmax-xmin+1)+" "+(ymax-ymin+1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var xmax : int ; xmax := 0 ;
    var xmin : int ; xmin := 0 ;
    var ymax : int ; ymax := 0 ;
    var ymin : int ; ymin := 0 ;
    var x : Sequence(int) ; x := Sequence{} ;
    var y : Sequence(int) ; y := Sequence{} ;
    x := x->including(0) ; 
    y := y->including(0) ; 
        var i : int ; i := 1 ; while i < n do ( (     var id : int ; id := in.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (in.getCurrent()->toInteger()) ; 
       if _switchval = 0 then
     x := x->including(x->at(id+1) - 1) ; 
    y := y->including(y->at(id+1)) ; 
    break 
   else skip ;
       if _switchval = 1 then
     x := x->including(x->at(id+1)) ; 
    y := y->including(y->at(id+1) - 1) ; 
    break 
   else skip ;
       if _switchval = 2 then
     x := x->including(x->at(id+1) + 1) ; 
    y := y->including(y->at(id+1)) ; 
    break 
   else skip ;
       if _switchval = 3 then
     x := x->including(x->at(id+1)) ; 
    y := y->including(y->at(id+1) + 1) ; 
    break 
   else skip ;
 )
    xmax := Set{xmax, x->at(i+1)}->max() ; 
    xmin := Set{xmin, x->at(i+1)}->min() ; 
    ymax := Set{ymax, y->at(i+1)}->max() ; 
    ymin := Set{ymin, y->at(i+1)}->min() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((xmax - xmin + 1) + " " + (ymax - ymin + 1)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int[] vx={
-1,0,1,0 };
    int[] vy={
      0,1,0,-1 };
      private void doit(){
        Scanner sc=new Scanner(System.in);
        while(true){
          int n=sc.nextInt();
          if(n==0)break ;
          int[] x=new int[n];
          int[] y=new int[n];
          for(int i=1 ; i<n ; i++){
            int ni=sc.nextInt();
            int d=sc.nextInt();
            x[i]=x[ni]+vx[d];
            y[i]=y[ni]+vy[d];
          }
          int maxx=x[0],maxy=y[0],minx=x[0],miny=y[0];
          for(int i=1 ; i<n ; i++){
            maxx=Math.max(maxx,x[i]);
            maxy=Math.max(maxy,y[i]);
            minx=Math.min(minx,x[i]);
            miny=Math.min(miny,y[i]);
          }
          System.out.println((maxx-minx+1)+" "+(maxy-miny+1));
        }
      }
      public static void main(String[] args){
        Main obj=new Main();
        obj.doit();
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute vx : Sequence(int) := Sequence{-1,0,1,0};
   attribute vy : Sequence(int) := Sequence{0,1,0,-1};
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 1 ; while i < n do ( (     var ni : int ; ni := sc.getCurrent()->toInteger() ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
     x[i+1] := x[ni+1] + vx[d+1] ; 
     y[i+1] := y[ni+1] + vy[d+1] )  ;     i := i + 1 ) ; 
    var maxx : int ; maxx := x[0+1] ;
    var maxy : int ; maxy := y[0+1] ;
    var minx : int ; minx := x[0+1] ;
    var miny : int ; miny := y[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     maxx := Set{maxx, x[i+1]}->max() ; 
     maxy := Set{maxy, y[i+1]}->max() ; 
     minx := Set{minx, x[i+1]}->min() ; 
     miny := Set{miny, y[i+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((maxx - minx + 1) + " " + (maxy - miny + 1)) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean checkTriangularSumRepresentation(int n){
    HashSet<Integer>tri=new HashSet<>();
    int i=1 ;
    while(true){
      int x=i*(i+1)/2 ;
      if(x>=n){
        break ;
      }
      tri.add(x);
      i++;
    }
    for(Integer tm : tri){
      if(tri.contains(n-tm)&&(n-tm)!=(int)tri.toArray()[tri.size()-1]){
        return true ;
      }
    }
    return false ;
  }
  public static void main(String[] args){
    int n=24 ;
    if(checkTriangularSumRepresentation(n)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkTriangularSumRepresentation( n : int) : boolean
  pre: true
  post: true
  activity: (     var tri : Set(int) ; tri := Set{} ;
     var i : int ; i := 1 ;
    while (true) do (     var x : int ; x := i * (i + 1) / 2 ;
     if (x >= n) then (     break ) else skip ; 
     tri := tri->including(x) ; 
     i := i + 1 ) ; 
    for (tm : tri) do ( (     if (tri->includes(n - tm) & (n - tm) /= tri->asSequence()[tri->size() - 1+1]->oclAsType(int)) then (     return true ) else skip )  ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 24 ;
     if (checkTriangularSumRepresentation(n)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static Position[] direction={
    new Position(-1,0),new Position(0,-1),new Position(1,0),new Position(0,1)};
    public static void main(String args[]){
      int N,number,tmp_dire,right,left,top,bottom ;
      Position[] square_pos ;
      while((N=sc.nextInt())!=0){
        right=0 ;
        left=0 ;
        top=0 ;
        bottom=0 ;
        square_pos=new Position[N];
        square_pos[0]=new Position(0,0);
        for(int i=1 ; i<N ; i++){
          number=sc.nextInt();
          tmp_dire=sc.nextInt();
          square_pos[i]=new Position(square_pos[number] .x,square_pos[number] .y);
          square_pos[i] .movePosition(direction[tmp_dire]);
        }
        for(int j=0 ; j<square_pos.length ; j++){
          if(square_pos[j] .x<left)left=square_pos[j] .x ;
          else if(square_pos[j] .x>right)right=square_pos[j] .x ;
          if(square_pos[j] .y<bottom)bottom=square_pos[j] .y ;
          else if(square_pos[j] .y>top)top=square_pos[j] .y ;
        }
        System.out.println((right-left+1)+" "+(top-bottom+1));
      }
    }
    static class Position {
      int x,y ;
      Position(int x,int y){
        this.x=x ;
        this.y=y ;
      }
      void movePosition(Position tmp){
        x+=tmp.x ;
        y+=tmp.y ;
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute direction : Sequence(Position) := Sequence{Position.newPosition(-1, 0),Position.newPosition(0, -1),Position.newPosition(1, 0),Position.newPosition(0, 1)};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ;
    var number : int ;
    var tmp_dire : int ;
    var right : int ;
    var left : int ;
    var top : int ;
    var bottom : int ;
     var square_pos : Sequence(Position) ;
         N := sc.getCurrent()->toInteger() ;
    while ((N) /= 0) do (    skip ; (     right := 0 ; 
     left := 0 ; 
    top := 0 ; 
    bottom := 0 ; 
    square_pos := Integer.subrange(1,N)->collect(null) ; 
    square_pos[0+1] := Position.newPosition(0, 0) ; 
        var i : int ; i := 1 ; while i < N do ( (     number := sc.getCurrent()->toInteger() ; 
     tmp_dire := sc.getCurrent()->toInteger() ; 
     square_pos[i+1] := Position.newPosition(square_pos[number+1].x, square_pos[number+1].y) ; 
     square_pos[i+1].movePosition(direction[tmp_dire+1]) )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < square_pos->size() do ( (     if (square_pos[j+1].x < left) then     left := square_pos[j+1].x else     if (square_pos[j+1].x > right) then     right := square_pos[j+1].x ; else skip ; ;  
     if (square_pos[j+1].y < bottom) then     bottom := square_pos[j+1].y ; else     if (square_pos[j+1].y > top) then     top := square_pos[j+1].y ; else skip ; )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println((right - left + 1) + " " + (top - bottom + 1)) ; 
 ) ;     N := sc.getCurrent()->toInteger() ;
 ) );
  static class Position {
   attribute x : int;
   static operation newPosition( x : int, y : int) : Position
  pre: true
  post: true
  activity:
  ( var self : Position ;
    self := createPosition();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation movePosition( tmp : Position) : void
  pre: true
  post: true
  activity: (     x := x+(tmp.x) ; 
     y := y+(tmp.y) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public final class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int l=sc.nextInt();
      String s="" ;
      int[] arr=new int[l];
      for(int j=0 ; j<n ; j++){
        String temp=Integer.toBinaryString(sc.nextInt());
        while(temp.length()<l)temp='0'+temp ;
        for(int k=0 ; k<l ; k++){
          if(k<temp.length()&& temp.charAt(k)=='1')arr[k]+=1 ;
        }
      }
      for(int j=0 ; j<l ; j++){
        if(n-arr[j]>=arr[j])s+=0 ;
        else s+=1 ;
      }
      System.out.println(Integer.parseInt(s,2));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var s : String ; s := "" ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,l)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     var temp : String ; temp := (MathLib.decimal2binary(sc.getCurrent()->toInteger()) + "") ;
     while (temp->size() < l) do     temp := '0' + temp ; ; 
         var k : int ; k := 0 ; while k < l do ( (     if (k < temp->size() & temp->at(k+1) = '1') then     arr[k+1] := arr[k+1]+(1) ; else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < l do ( (     if (n - arr[j+1] >= arr[j+1]) then     s := s+(0) ; else     s := s+(1) ; )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println((s)->toInteger()) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.HashMap ;
public class Main {
  public static void main(String[] args){
    while(true){
      int n=nextInt();
      if(n==0){
        break ;
      }
      HashMap<Integer,Integer[]>hashMap=new HashMap<Integer,Integer[]>();
      Integer[] zero={
        0,0 };
        hashMap.put(0,zero);
        int x_max=0,x_min=0,y_max=0,y_min=0 ;
        for(int i=1 ; i<n ; i++){
          int base=nextInt();
          int x=hashMap.get(base)[0];
          int y=hashMap.get(base)[1];
          int direction=nextInt();
          switch(direction){
            case 0 : x--;
            break ;
            case 1 : y--;
            break ;
            case 2 : x++;
            break ;
            case 3 : y++;
            break ;
            default : break ;
          }
          Integer[] axis={
            x,y };
            hashMap.put(i,axis);
            x_max=Math.max(x_max,x);
            x_min=Math.min(x_min,x);
            y_max=Math.max(y_max,y);
            y_min=Math.min(y_min,y);
          }
          int width=x_max-x_min+1 ;
          int height=y_max-y_min+1 ;
          System.out.println(width+" "+height);
        }
      }
      static int nextInt(){
        int c ;
        try {
          c=System.in.read();
          while(c!='-' &&(c<'0' || c>'9'))c=System.in.read();
          if(c=='-')return-nextInt();
          int res=0 ;
          while(c>='0' && c<='9'){
            res=res*10+c-'0' ;
            c=System.in.read();
          }
          return res ;
        }
        catch(IOException e){
          e.printStackTrace();
        }
        return-1 ;
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := nextInt() ;
     if (n = 0) then (     break ) else skip ; 
    var hashMap : Map(int,Sequence(int)) ; hashMap := Map{} ;
    var zero : Sequence(int) ; zero := Sequence{0,0} ;
    hashMap := hashMap->union(Map{0 |-> zero}) ; 
    var x_max : int ; x_max := 0 ;
    var x_min : int ; x_min := 0 ;
    var y_max : int ; y_max := 0 ;
    var y_min : int ; y_min := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     var base : int ; base := nextInt() ;
     var x : int ; x := hashMap->at(base)[0+1] ;
    var y : int ; y := hashMap->at(base)[1+1] ;
    var direction : int ; direction := nextInt() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (direction) ; 
       if _switchval = 0 then
     x := x - 1 ; 
    break 
   else skip ;
       if _switchval = 1 then
     y := y - 1 ; 
    break 
   else skip ;
       if _switchval = 2 then
     x := x + 1 ; 
    break 
   else skip ;
       if _switchval = 3 then
     y := y + 1 ; 
    break 
   else skip ;
       if true then
     break 
   else skip ;
 )
    var axis : Sequence(int) ; axis := Sequence{x,y} ;
    hashMap := hashMap->union(Map{i |-> axis}) ; 
    x_max := Set{x_max, x}->max() ; 
    x_min := Set{x_min, x}->min() ; 
    y_max := Set{y_max, y}->max() ; 
    y_min := Set{y_min, y}->min() ; 
 )  ;     i := i + 1 ) ; 
    var width : int ; width := x_max - x_min + 1 ;
    var height : int ; height := y_max - y_min + 1 ;
    OclFile["System.out"].println(width + " " + height) ; 
 ) );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     var c : int ;
     try (     c := OclFile["System.in"].read() ; 
     while (c /= '-' & (c < '0' or c > '9')) do     c := OclFile["System.in"].read() ; ; 
    if (c = '-') then     return -nextInt() else skip ; 
    var res : int ; res := 0 ;
    while (c >= '0' & c <= '9') do (     res := res * 10 + c - ('0')->char2byte() ; 
     c := OclFile["System.in"].read() ) ; 
    return res 
 )   catch (e : IOException) do (     e.printStackTrace() )
     return -1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static boolean solve(Integer[] arr,int n){
    if(n==1){
      return arr[0]==1 ;
    }
    return arr[n-1]-arr[n-2]<=1 ;
  }
  public static void main(String[] args){
    MyScanner scanner=new MyScanner();
    int numOfTests=scanner.nextInt();
    for(int i=1 ; i<=numOfTests ; i++){
      int n=scanner.nextInt();
      Integer[] arr=new Integer[n];
      for(int j=0 ; j<n ; j++){
        arr[j]=scanner.nextInt();
      }
      Arrays.sort(arr);
      boolean res=solve(arr,n);
      out.println(res ? "YES" : "NO");
    }
    out.close();
  }
  public static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 1) then (     return arr[0+1] = 1 ) else skip ; 
     return arr[n - 1+1] - arr[n - 2+1] <= 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : MyScanner ; scanner := MyScanner.newMyScanner() ;
     var numOfTests : int ; numOfTests := scanner.nextInt() ;
         var i : int ; i := 1 ; while i <= numOfTests do ( (     var n : int ; n := scanner.nextInt() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(null) ;
        var j : int ; j := 0 ; while j < n do ( (     arr[j+1] := scanner.nextInt() )  ;     j := j + 1 ) ; 
    arr := arr->sort() ; 
    var res : boolean ; res := solve(arr, n) ;
    out.println(if res then "YES" else "NO" endif) ; 
 )  ;     i := i + 1 ) ; 
     out.close() );
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javax.swing.text.html.parser.Entity ;
import javax.xml.stream.events.EntityReference ;
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(is);
    Scanner sc=new Scanner(System.in);
    long test_case=sc.nextLong();
    for(long test=0 ; test<test_case ; test++){
      int n=sc.nextInt();
      long arr[]=new long[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextLong();
      }
      if(n==1){
        if(arr[0]==1){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
      else {
        Arrays.sort(arr);
        if(arr[n-1]-arr[n-2]<=1){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(is) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var test_case : long ; test_case := sc.getCurrent()->toLong() ;
        var test : long ; test := 0 ; while test < test_case do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
     if (n = 1) then (     if (arr[0+1] = 1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else (     arr := arr->sort() ; 
     if (arr[n - 1+1] - arr[n - 2+1] <= 1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) )  ;     test := test + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  static FastReader sc=null ;
  public static void main(String[] args){
    sc=new FastReader();
    int t=sc.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      int n=sc.nextInt();
      int a[]=sc.readArray(n);
      if(n==1){
        System.out.println(a[0]==1 ? "YES" : "NO");
      }
      else {
        ruffleSort(a);
        int d=a[n-1]-a[n-2];
        System.out.println(d>1 ? "NO" : "YES");
      }
    }
  }
  static int[] ruffleSort(int a[]){
    ArrayList<Integer>al=new ArrayList<>();
    for(int i : a)al.add(i);
    Collections.sort(al);
    for(int i=0 ; i<a.length ; i++)a[i]=al.get(i);
    return a ;
  }
  static void print(int a[]){
    for(int e : a){
      System.out.print(e+" ");
    }
    System.out.println();
  }
  static class FastReader {
    StringTokenizer st=new StringTokenizer("");
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String next(){
      while(! st.hasMoreTokens())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());
    }
    int[] readArray(int n){
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute sc : FastReader := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := FastReader.newFastReader() ; 
     var t : int ; t := sc.nextInt() ;
         var tt : int ; tt := 0 ; while tt < t do ( (     var n : int ; n := sc.nextInt() ;
     var a : Sequence(int) ; a := sc.readArray(n) ;
     if (n = 1) then (     OclFile["System.out"].println(if a[0+1] = 1 then "YES" else "NO" endif) ) else (     execute ruffleSort(a) ; 
     var d : int ; d := a[n - 1+1] - a[n - 2+1] ;
     OclFile["System.out"].println(if d > 1 then "NO" else "YES" endif) ) )  ;     tt := tt + 1 ) );
  static   operation ruffleSort( a : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var al : Sequence(int) ; al := Sequence{} ;
     for (i : a) do (     al := al->including(i) ;  ) ; 
    al := al->sort() ; 
        var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := al->at(i+1) ;  ;     i := i + 1 ) ; 
    return a 
 );
  static   operation print( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     for (e : a) do ( (     OclFile["System.out"].print(e + " ") )  ) ; 
     OclFile["System.out"].println() );
  static class FastReader {
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n ;
      n=sc.nextInt();
      int arr[]=new int[n];
      int fhigh=0 ;
      int shigh=0 ;
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
        if(shigh<=arr[i]){
          if(fhigh<=arr[i]){
            shigh=fhigh ;
            fhigh=arr[i];
          }
          else {
            shigh=arr[i];
          }
        }
      }
      if(fhigh-shigh<2){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ;
     n := sc.getCurrent()->toInteger() ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var fhigh : int ; fhigh := 0 ;
    var shigh : int ; shigh := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (shigh <= arr[i+1]) then (     if (fhigh <= arr[i+1]) then (     shigh := fhigh ; 
     fhigh := arr[i+1] ) else (     shigh := arr[i+1] ) ) else skip )  ;     i := i + 1 ) ; 
    if (fhigh - shigh < 2) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class test254 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      if(n==1){
        if(a[0]<=1){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
      else {
        Arrays.sort(a);
        if(a[n-1]-a[n-2]<=1){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test254 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     if (n = 1) then (     if (a[0+1] <= 1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else (     a := a->sort() ; 
     if (a[n - 1+1] - a[n - 2+1] <= 1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int[] sortArrayByParityII(int[] A){
    int j=1 ;
    for(int i=0 ; i<A.length ; i+=2)if(A[i] % 2==1){
      while(A[j] % 2==1)j+=2 ;
      int tmp=A[i];
      A[i]=A[j];
      A[j]=tmp ;
    }
    return A ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation sortArrayByParityII( A : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var j : int ; j := 1 ;
         var i : int ; i := 0 ; while i < A->size() do (     if (A[i+1] mod 2 = 1) then (     while (A[j+1] mod 2 = 1) do     j := j+(2) ; ; 
     var tmp : int ; tmp := A[i+1] ;
     A[i+1] := A[j+1] ; 
     A[j+1] := tmp ) else skip ;  ;     i := i+(2) ) ; 
     return A );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int[] a=new int[2];
    while(true){
      for(int i=0 ; i<2 ; i++){
        a[i]=cin.nextInt();
      }
      if(a[0]==0 && a[1]==0){
        break ;
      }
      Arrays.sort(a);
      System.out.printf("%d %d\n",a[0],a[1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,2)->collect(0) ;
     while (true) do (         var i : int ; i := 0 ; while i < 2 do ( (     a[i+1] := cin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     if (a[0+1] = 0 & a[1+1] = 0) then (     break ) else skip ; 
     a := a->sort() ; 
     OclFile["System.out"].printf("%d %d\n", a[0+1], a[1+1]) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  @ SuppressWarnings("unchecked")public static void main(String[] args){
    try(java.util.Scanner sc=new java.util.Scanner(System.in)){
      while(sc.hasNextInt()){
        for(java.util.Map<Integer,Integer>map : new java.util.Map[] { new java.util.HashMap<>()} ){
            if(map.put(0,sc.nextInt())==null){
            }
            if(map.put(1,sc.nextInt())==null){
            }
            if(map.get(0)==0 && map.get(1)==0){
            }
            else {
              if(java.util.Arrays.stream(new String[] {
                String.valueOf(Math.min(map.get(0),map.get(1)))," ",String.valueOf(Math.max(map.get(0),map.get(1))),"\n" }
).peek(System.out :: print).count()==0){
                }
              }
            }
          }
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
class Main {
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : Scanner := Scanner.newScanner(OclFile["System.in"]) ;
 (     while (sc.hasNextInt()) do (     for (map : Sequence{HashMap<OclAny>.newHashMap()}) do ( (     if (map->at(0, sc.nextInt()) = null) then skip else skip ; 
     if (map->at(1, sc.nextInt()) = null) then skip else skip ; 
     if (map->at(0+1) = 0 & map->at(1+1) = 0) then skip else (     if (java.util.Arrays.stream(Sequence{((Set{map->at(0+1), map->at(1+1)}->min()) + "")," ",((Set{map->at(0+1), map->at(1+1)}->max()) + ""),"\n"}).peek(lambda _pars : OclAny in OclFile["System.out"].print(_pars))->size() = 0) then skip else skip ) )  ) ) ))  );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Fraction {
  int num,den ;
  Fraction(int n,int d){
    num=n ;
    den=d ;
  }
  static Fraction maxFraction(Fraction first,Fraction sec){
    int a=first.num ;
    int b=first.den ;
    int c=sec.num ;
    int d=sec.den ;
    int Y=a*d-b*c ;
    return(Y>0)? first : sec ;
  }
  public static void main(String[] args){
    Fraction first=new Fraction(3,2);
    Fraction sec=new Fraction(3,4);
    Fraction res=maxFraction(first,sec);
    System.out.println(res.num+"/"+res.den);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Fraction {
   attribute num : int;
   static operation newFraction( n : int, d : int) : Fraction
  pre: true
  post: true
  activity:
  ( var self : Fraction ;
    self := createFraction();
    self.initialise(n, d);
    return self );
  operation initialise( n : int, d : int) : void
  pre: true  post: true
  activity: (     num := n ; 
     den := d );
  static   operation maxFraction( first : Fraction, sec : Fraction) : Fraction
  pre: true
  post: true
  activity: (     var a : int ; a := first.num ;
     var b : int ; b := first.den ;
    var c : int ; c := sec.num ;
    var d : int ; d := sec.den ;
    var Y : int ; Y := a * d - b * c ;
    return if (Y > 0) then first else sec endif 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var first : Fraction ; first := Fraction.newFraction(3, 2) ;
     var sec : Fraction ; sec := Fraction.newFraction(3, 4) ;
     var res : Fraction ; res := maxFraction(first, sec) ;
     OclFile["System.out"].println(res.num + "/" + res.den) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.stream.*;
public class Main {
  private static BufferedReader br=null ;
  public static void main(String[] args){
    int n=Integer.parseInt(read(1)[0]);
    String[] w=read(n);
    String result="Yes" ;
    Set<String>wSet=Arrays.stream(w).collect(Collectors.toSet());
    if(wSet.size()!=w.length){
      result="No" ;
    }
    else {
      for(int i=1 ; i<w.length ; i++){
        if(w[i-1] .charAt(w[i-1] .length()-1)!=w[i] .charAt(0)){
          result="No" ;
        }
      }
    }
    System.out.println(result);
    close();
  }
  private static String[] read(int len){
    List<String>strList=new ArrayList<>();
    try {
      if(br==null){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
      for(int i=0 ; i<len ; i++){
        strList.add(br.readLine());
      }
    }
    catch(IOException e){
    }
    return strList.toArray(new String[0]);
  }
  private static void close(){
    try {
      if(br!=null){
        br.close();
      }
    }
    catch(IOException e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (read(1)[0+1])->toInteger() ;
     var w : Sequence(String) ; w := read(n) ;
    var result : String ; result := "Yes" ;
    var wSet : Set(String) ; wSet := stream(w).collect(Collectors.toSet()) ;
    if (wSet->size() /= w->size()) then (     result := "No" ) else (         var i : int ; i := 1 ; while i < w->size() do ( (     if (w[i - 1+1]->at(w[i - 1+1]->size() - 1+1) /= w[i+1]->at(0+1)) then (     result := "No" ) else skip )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(result) ; 
    execute close() ; 
 );
  static   operation read( len : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var strList : Sequence(String) ; strList := Sequence{} ;
     try (     if (br = null) then (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ) else skip ; 
         var i : int ; i := 0 ; while i < len do ( (     strList := strList->including(br.readLine()) )  ;     i := i + 1 ) )   catch (e : IOException) do skip
     return strList->asSequence() );
  static   operation close() : void
  pre: true
  post: true
  activity: (     try (     if (br /= null) then (     skip ) else skip )   catch (e : IOException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
public class practice2 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int l=sc.nextInt();
      int c[]=new int[l];
      for(int i=0 ; i<n ; i++){
        int x=sc.nextInt();
        for(int j=0 ; j<l ; j++)c[j]+=(x>>j)& 1 ;
      }
      int ans=0 ;
      for(int i=0 ; i<l ; i++)if(c[i]>n-c[i])ans |=1<<i ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var c : Sequence(int) ; c := Integer.subrange(1,l)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < l do (     c[j+1] := c[j+1]+(((x/(2->pow(j)))->oclAsType(long)) & 1) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < l do (     if (c[i+1] > n - c[i+1]) then     ans := MathLib.bitwiseOr(ans, (1*(2->pow(i)))->oclAsType(long)) ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    try {
      ArrayList<String>list=new ArrayList<String>();
      BufferedReader d=new BufferedReader(new InputStreamReader(System.in));
      while(true){
        String s=d.readLine();
        if(s!=null && s!="" && ! s.equals("0 0")){
          list.add(s);
        }
        else {
          break ;
        }
      }
      for(int i=0 ; i<list.size(); i++){
        String s=list.get(i);
        StringTokenizer sz=new StringTokenizer(s);
        int a=Integer.parseInt(sz.nextToken());
        int b=Integer.parseInt(sz.nextToken());
        int tmp,tmp2 ;
        tmp=a<b ? a : b ;
        tmp2=a>b ? a : b ;
        System.out.println(tmp+" "+tmp2);
      }
    }
    catch(Throwable e){
      e.printStackTrace();
      System.out.println("Input Error");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var list : Sequence(String) ; list := Sequence{} ;
     var d : OclFile ; d := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var s : String ; s := d.readLine() ;
     if (s /= null & s /= "" & not(s = "0 0")) then (     list := list->including(s) ) else (     break ) ) ; 
         var i : int ; i := 0 ; while i < list->size() do ( (     var s : String ; s := list->at(i+1) ;
     var sz : OclIterator ; sz := OclIterator.newOclIterator_String(s) ;
    var a : int ; a := (sz.next())->toInteger() ;
    var b : int ; b := (sz.next())->toInteger() ;
    var tmp : int ;
    var tmp2 : int ;
    tmp := if a < b then a else b endif ; 
    tmp2 := if a > b then a else b endif ; 
    OclFile["System.out"].println(tmp + " " + tmp2) ; 
 )  ;     i := i + 1 ) )   catch (e : OclException) do (     e.printStackTrace() ; 
     OclFile["System.out"].println("Input Error") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  void run(){
    sc=new Scanner(System.in);
    for(; ; ){
      int x=sc.nextInt();
      int y=sc.nextInt();
      if(x==0 && y==0)break ;
      println(min(x,y)+" "+max(x,y));
    }
    sc.close();
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
       while true do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     if (x = 0 & y = 0) then     break else skip ; 
     execute println(Set{x, y}->min() + " " + Set{x, y}->max()) )  ) ; 
     skip );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    int i,j,swap ;
    Scanner in=new Scanner(System.in);
    ArrayList<Integer>array=new ArrayList<Integer>();
    ArrayList<Integer>array2=new ArrayList<Integer>();
    for(i=0 ; in.hasNext(); i++){
      array.add(in.nextInt());
      if(i % 2==1)if(array.get(i-1)==0 && array.get(i)==0)break ;
    }
    for(j=0 ; j<i-1 ; j=j+2){
      if(array.get(j)<=array.get(j+1))System.out.println(array.get(j)+" "+array.get(j+1));
      else System.out.println(array.get(j+1)+" "+array.get(j));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var swap : int ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var array : Sequence(int) ; array := Sequence{} ;
    var array2 : Sequence(int) ; array2 := Sequence{} ;
        i := 0 ; while in.hasNext() do ( (     array := array->including(in.getCurrent()->toInteger()) ; 
     if (i mod 2 = 1) then     if (array->at(i - 1+1) = 0 & array->at(i+1) = 0) then     break else skip ; else skip )  ;     i := i + 1 ) ; 
        j := 0 ; while j < i - 1 do ( (     if (array->at(j+1) <= array->at(j + 1+1)) then     OclFile["System.out"].println(array->at(j+1) + " " + array->at(j + 1+1)) ; else     OclFile["System.out"].println(array->at(j + 1+1) + " " + array->at(j+1)) ; )  ;     j := j + 2 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int[] n=new int[9];
      char[] list=sc.nextLine().toCharArray();
      for(int i : list){
        n[i-'1']++;
      }
      List<Integer>result=new ArrayList<>();
      for(int i=0 ; i<9 ; i++){
        for(int j=0 ; j<9 ; j++){
          if(n[i]<4 &&(n[j]>=2 || n[i]>=1)){
            int[] temp=n.clone();
            temp[i]++;
            temp[j]-=2 ;
            for(int k=0 ; k<7 ; k++){
              if((temp[k]==1 || temp[k]==4)&& temp[k+1]>0 && temp[k+2]>0){
                temp[k]--;
                temp[k+1]--;
                temp[k+2]--;
              }
              if(temp[k]==2 && temp[k+1]>=2 && temp[k+2]>=2){
                temp[k]-=2 ;
                temp[k+1]-=2 ;
                temp[k+2]-=2 ;
              }
            }
            boolean f=true ;
            for(int k : temp){
              if(k % 3!=0){
                f=false ;
                break ;
              }
            }
            if(f){
              result.add(i+1);
              break ;
            }
          }
        }
      }
      if(result.isEmpty()){
        System.out.println(0);
      }
      else {
        for(int i=0 ; i<result.size(); i++){
          System.out.print(i<result.size()-1 ? result.get(i)+" " : result.get(i)+"\n");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : Sequence(int) ; n := Integer.subrange(1,9)->collect(0) ;
     var list : Sequence(String) ; list := sc.nextLine()->characters() ;
    for (i : list) do ( (     n[i - ('1')->char2byte()+1] := n[i - ('1')->char2byte()+1] + 1 )  ) ; 
    var result : Sequence(int) ; result := Sequence{} ;
        var i : int ; i := 0 ; while i < 9 do ( (         var j : int ; j := 0 ; while j < 9 do ( (     if (n[i+1] < 4 & (n[j+1] >= 2 or n[i+1] >= 1)) then (     var temp : Sequence(int) ; temp := n->copy() ;
     temp[i+1] := temp[i+1] + 1 ; 
    temp[j+1] := temp[j+1]-(2) ; 
        var k : int ; k := 0 ; while k < 7 do ( (     if ((temp[k+1] = 1 or temp[k+1] = 4) & temp[k + 1+1] > 0 & temp[k + 2+1] > 0) then (     temp[k+1] := temp[k+1] - 1 ; 
     temp[k + 1+1] := temp[k + 1+1] - 1 ; 
     temp[k + 2+1] := temp[k + 2+1] - 1 ) else skip ; 
     if (temp[k+1] = 2 & temp[k + 1+1] >= 2 & temp[k + 2+1] >= 2) then (     temp[k+1] := temp[k+1]-(2) ; 
     temp[k + 1+1] := temp[k + 1+1]-(2) ; 
     temp[k + 2+1] := temp[k + 2+1]-(2) ) else skip )  ;     k := k + 1 ) ; 
    var f : boolean ; f := true ;
    for (k : temp) do ( (     if (k mod 3 /= 0) then (     f := false ; 
     break ) else skip )  ) ; 
    if (f) then (     result := result->including(i + 1) ; 
     break ) else skip ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (result->isEmpty()) then (     OclFile["System.out"].println(0) ) else (         var i : int ; i := 0 ; while i < result->size() do ( (     OclFile["System.out"].print(if i < result->size() - 1 then result->at(i+1) + " " else result->at(i+1) + "\n" endif) )  ;     i := i + 1 ) ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int[] n=new int[9];
      char[] list=sc.nextLine().toCharArray();
      for(int i : list){
        n[i-'1']++;
      }
      List<Integer>result=new ArrayList<>();
      for(int i=0 ; i<9 ; i++){
        next : for(int j=0 ;
        j<9 ;
        j++){
          if(n[i]<4 &&(n[j]>=2 || n[i]>=1)){
            int[] temp=n.clone();
            temp[i]++;
            temp[j]-=2 ;
            for(int k=0 ; k<7 ; k++){
              process(temp,k,1);
              process(temp,k,2);
              if(temp[k] % 3!=0){
                continue next ;
              }
            }
            if(temp[7] % 3==0){
              result.add(i+1);
              break ;
            }
          }
        }
      }
      if(result.isEmpty()){
        System.out.println(0);
      }
      else {
        for(int i=0 ; i<result.size(); i++){
          System.out.print(result.get(i)+(i<result.size()-1 ? " " : "\n"));
        }
      }
    }
  }
  static void process(int[] a,int p,int n){
    if(a[p] % 3==n && a[p+1]>=n && a[p+2]>=n){
      a[p]-=n ;
      a[p+1]-=n ;
      a[p+2]-=n ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : Sequence(int) ; n := Integer.subrange(1,9)->collect(0) ;
     var list : Sequence(String) ; list := sc.nextLine()->characters() ;
    for (i : list) do ( (     n[i - ('1')->char2byte()+1] := n[i - ('1')->char2byte()+1] + 1 )  ) ; 
    var result : Sequence(int) ; result := Sequence{} ;
        var i : int ; i := 0 ; while i < 9 do ( (         var j : int ; j := 0 ; while j < 9 do ( (     if (n[i+1] < 4 & (n[j+1] >= 2 or n[i+1] >= 1)) then (     var temp : Sequence(int) ; temp := n->copy() ;
     temp[i+1] := temp[i+1] + 1 ; 
    temp[j+1] := temp[j+1]-(2) ; 
        var k : int ; k := 0 ; while k < 7 do ( (     execute process(temp, k, 1) ; 
     execute process(temp, k, 2) ; 
     if (temp[k+1] mod 3 /= 0) then (     continue ) else skip )  ;     k := k + 1 ) ; 
    if (temp[7+1] mod 3 = 0) then (     result := result->including(i + 1) ; 
     break ) else skip ; 
 ) else skip )  ;     j := j + 1 ) ; )  ;     i := i + 1 ) ; 
    if (result->isEmpty()) then (     OclFile["System.out"].println(0) ) else (         var i : int ; i := 0 ; while i < result->size() do ( (     OclFile["System.out"].print(result->at(i+1) + (if i < result->size() - 1 then " " else "\n" endif)) )  ;     i := i + 1 ) ) ;  
 ) );
  static   operation process( a : Sequence(int), p : int, n : int) : void
  pre: true
  post: true
  activity: (     if (a[p+1] mod 3 = n & a[p + 1+1] >= n & a[p + 2+1] >= n) then (     a[p+1] := a[p+1]-(n) ; 
     a[p + 1+1] := a[p + 1+1]-(n) ; 
     a[p + 2+1] := a[p + 2+1]-(n) ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null){
      int[] num=new int[10];
      boolean flag=false ;
      String ans="0" ;
      for(int i=0 ; i<13 ; i++){
        num[(int)(line.charAt(i)-'0')]++;
      }
      outside : for(int i=1 ;
      i<=9 ;
      i++){
        if(num[i]==4){
          continue ;
        }
        for(int j=1 ; j<=9 ; j++){
          int[] n=num.clone();
          n[i]++;
          if(n[j]<2){
            continue ;
          }
          n[j]-=2 ;
          if(check(n)){
            if(! flag){
              System.out.print(i);
              ans="" ;
              flag=true ;
            }
            else {
              System.out.print(" "+i);
            }
            continue outside ;
          }
        }
      }
      System.out.println(ans);
    }
  }
  private static boolean check(int[] n){
    int amari=0 ;
    for(int i=1 ; i<=7 ; i++){
      if(n[i]<0){
        return false ;
      }
      amari=n[i] % 3 ;
      n[i]-=amari ;
      n[i+1]-=amari ;
      n[i+2]-=amari ;
    }
    if((n[8]==3 || n[8]==0)&&(n[9]==3 || n[9]==0)){
      return true ;
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     var num : Sequence(int) ; num := Integer.subrange(1,10)->collect(0) ;
     var flag : boolean ; flag := false ;
    var ans : String ; ans := "0" ;
        var i : int ; i := 0 ; while i < 13 do ( (     num[(line->at(i+1) - ('0')->char2byte())->oclAsType(int)+1] := num[(line->at(i+1) - ('0')->char2byte())->oclAsType(int)+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 9 do ( (     if (num[i+1] = 4) then (     continue ) else skip ; 
         var j : int ; j := 1 ; while j <= 9 do ( (     var n : Sequence(int) ; n := num->copy() ;
     n[i+1] := n[i+1] + 1 ; 
    if (n[j+1] < 2) then (     continue ) else skip ; 
    n[j+1] := n[j+1]-(2) ; 
    if (check(n)) then (     if (not(flag)) then (     OclFile["System.out"].print(i) ; 
     ans := "" ; 
     flag := true ) else (     OclFile["System.out"].print(" " + i) ) ;  
     continue ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;     line := br.readLine() ;
 ) );
  static   operation check( n : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var amari : int ; amari := 0 ;
         var i : int ; i := 1 ; while i <= 7 do ( (     if (n[i+1] < 0) then (     return false ) else skip ; 
     amari := n[i+1] mod 3 ; 
    n[i+1] := n[i+1]-(amari) ; 
    n[i + 1+1] := n[i + 1+1]-(amari) ; 
    n[i + 2+1] := n[i + 2+1]-(amari) ; 
 )  ;     i := i + 1 ) ; 
     if ((n[8+1] = 3 or n[8+1] = 0) & (n[9+1] = 3 or n[9+1] = 0)) then (     return true ) else skip ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  static char[] array=new char[13];
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line=null ;
    try {
      while((line=br.readLine())!=null){
        line=line.trim();
        array=line.toCharArray();
        int[] numCount=new int[10];
        for(int i=0 ; i<array.length ; i++){
          numCount[array[i]-'0']++;
        }
        String ans="0" ;
        for(int i=1 ; i<=9 ; i++){
          if(numCount[i]==4)continue ;
          searchHead : for(int j=1 ;
          j<=9 ;
          j++){
            int[] num=numCount.clone();
            num[i]++;
            if(num[j]-2<0)continue ;
            num[j]-=2 ;
            for(int k=1 ; k<=7 ; k++){
              if(num[k]<0)continue searchHead ;
              int surplus=num[k] % 3 ;
              if(surplus!=0){
                num[k]-=surplus ;
                num[k+1]-=surplus ;
                num[k+2]-=surplus ;
              }
            }
            if(((num[8] % 3)+(num[9] % 3))==0 && num[8]>=0 && num[9]>=0){
              if(ans.equals("0")){
                ans=Integer.toString(i);
              }
              else {
                ans+=" "+Integer.toString(i);
              }
              break searchHead ;
            }
          }
        }
        System.out.println(ans);
      }
      br.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute array : Sequence(String) := Integer.subrange(1,13)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := null ;
     try (         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     line := line->trim() ; 
     array := line->characters() ; 
    var numCount : Sequence(int) ; numCount := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < array->size() do ( (     numCount[array[i+1] - ('0')->char2byte()+1] := numCount[array[i+1] - ('0')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "0" ;
        var i : int ; i := 1 ; while i <= 9 do ( (     if (numCount[i+1] = 4) then     continue else skip ; 
         var j : int ; j := 1 ; while j <= 9 do ( (     var num : Sequence(int) ; num := numCount->copy() ;
     num[i+1] := num[i+1] + 1 ; 
    if (num[j+1] - 2 < 0) then     continue else skip ; 
    num[j+1] := num[j+1]-(2) ; 
        var k : int ; k := 1 ; while k <= 7 do ( (     if (num[k+1] < 0) then     continue else skip ; 
     var surplus : int ; surplus := num[k+1] mod 3 ;
     if (surplus /= 0) then (     num[k+1] := num[k+1]-(surplus) ; 
     num[k + 1+1] := num[k + 1+1]-(surplus) ; 
     num[k + 2+1] := num[k + 2+1]-(surplus) ) else skip )  ;     k := k + 1 ) ; 
    if (((num[8+1] mod 3) + (num[9+1] mod 3)) = 0 & num[8+1] >= 0 & num[9+1] >= 0) then (     if (ans = "0") then (     ans := ((i) + "") ) else (     ans := ans+(" " + ((i) + "")) ) ;  
     break ) else skip ; 
 )  ;     j := j + 1 ) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;     line := br.readLine() ;
 ) ;  
     skip )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.io.IOException ;
public class A {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    int n=Integer.parseInt(br.readLine());
    String s=br.readLine();
    int ans=n ;
    for(int i=0 ; i<n-1 ; i++){
      if((s.charAt(i)=='U' && s.charAt(i+1)=='R')||(s.charAt(i)=='R' && s.charAt(i+1)=='U')){
        ans--;
        i++;
      }
    }
    out.println(ans);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var s : String ; s := br.readLine() ;
    var ans : int ; ans := n ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if ((s->at(i+1) = 'U' & s->at(i + 1+1) = 'R') or (s->at(i+1) = 'R' & s->at(i + 1+1) = 'U')) then (     ans := ans - 1 ; 
     i := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String S=sc.next();
    sc.close();
    char[] s=S.toCharArray();
    int answer=n ;
    for(int i=0 ; i<n-1 ; i++){
      if(s[i]!=s[i+1]){
        i++;
        answer--;
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var S : String ; S := sc.getCurrent() ;
    skip ; 
    var s : Sequence(String) ; s := S->characters() ;
    var answer : int ; answer := n ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (s[i+1] /= s[i + 1+1]) then (     i := i + 1 ; 
     answer := answer - 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int sL=s.length();
    String sT=s ;
    for(int i=0 ; i<s.length()/2 ; i++){
      sL-=2 ;
      sT=sT.substring(0,sL);
      if(sT.substring(0,sL/2).equals(sT.substring(sL/2))){
        System.out.println(sL);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var sL : int ; sL := s->size() ;
    var sT : String ; sT := s ;
        var i : int ; i := 0 ; while i < s->size() / 2 do ( (     sL := sL-(2) ; 
     sT := sT.subrange(0+1,sL) ; 
     if (sT.subrange(0+1,sL / 2) = sT.subrange(sL / 2+1,sL / 2)) then (     OclFile["System.out"].println(sL) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p265 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p265().run());
  }
  private static final int N=5 ;
  private static final int TWO_POW_N=1<<N ;
  public String run(){
    long sum=0 ;
    int start=(1<<(TWO_POW_N-N-1))+1 ;
    int end=1<<(TWO_POW_N-N);
    for(int i=start ; i<end ; i+=2){
      if(checkArrangement(i))sum+=i ;
    }
    return Long.toString(sum);
  }
  private static final int MASK=TWO_POW_N-1 ;
  private static final int FULL_SET=(int)(1L<<TWO_POW_N)-1 ;
  private static boolean checkArrangement(int digits){
    int seen=0 ;
    long temp=(digits & 0xFFFFFFFFL)|((digits & 0xFFFFFFFFL)<<TWO_POW_N);
    for(int i=0 ; i<TWO_POW_N ; i++)seen |=1<<((int)(temp>>>i)& MASK);
    return seen==FULL_SET ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p265 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p265.newp265().run()) );
  static    attribute N : int := 5;
  static    attribute TWO_POW_N : int := (1*(2->pow(N)))->oclAsType(long);
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     var start : int ; start := ((1*(2->pow((TWO_POW_N - N - 1))))->oclAsType(long)) + 1 ;
    var end : int ; end := (1*(2->pow((TWO_POW_N - N))))->oclAsType(long) ;
        var i : int ; i := start ; while i < end do ( (     if (checkArrangement(i)) then     sum := sum+(i) ; else skip )  ;     i := i+(2) ) ; 
    return ((sum) + "") 
 );
  static    attribute MASK : int := TWO_POW_N - 1;
  static    attribute FULL_SET : int := ((1L*(2->pow(TWO_POW_N)))->oclAsType(long))->oclAsType(int) - 1;
  static   operation checkArrangement( digits : int) : boolean
  pre: true
  post: true
  activity: (     var seen : int ; seen := 0 ;
     var temp : long ; temp := MathLib.bitwiseOr((MathLib.bitwiseAnd(digits,0xFFFFFFFFL)),(((MathLib.bitwiseAnd(digits,0xFFFFFFFFL))*(2->pow(TWO_POW_N)))->oclAsType(long))) ;
         var i : int ; i := 0 ; while i < TWO_POW_N do (     seen := MathLib.bitwiseOr(seen, (1*(2->pow((MathLib.bitwiseAnd(((temp/(2->pow(i)))->oclAsType(long))->oclAsType(int),MASK)))))->oclAsType(long)) ;  ;     i := i + 1 ) ; 
     return seen = FULL_SET );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    int n=nextInt();
    String s=next();
    s=s.replaceAll("UR|RU","D");
    out.println(s.length());
    out.close();
  }
  static BufferedReader br ;
  static StringTokenizer st=new StringTokenizer("");
  static String next()throws IOException {
    while(! st.hasMoreTokens()){
      st=new StringTokenizer(br.readLine());
    }
    return st.nextToken();
  }
  static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  static long nextLong()throws IOException {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := nextInt() ;
    var s : String ; s := next() ;
    s := s.replaceAllMatches("UR|RU", "D" ) ; 
    skip ; 
    skip ; 
 );
  static   attribute br : OclFile;
  static   attribute st : OclIterator := OclIterator.newOclIterator_String("");
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class road {
  static int row ;
  static int col ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char ch[]=sc.next().toCharArray();
    int sum=0 ;
    int i=0 ;
    for(i=0 ; i<n-1 ; i++){
      if(ch[i]=='U' && ch[i+1]=='R'){
        sum++;
        i++;
      }
      else if(ch[i]=='R' && ch[i+1]=='U'){
        sum++;
        i++;
      }
    }
    System.out.println(n-sum);
  }
  public static void dfs(boolean b[],int i,ArrayList<ArrayList<Integer>>arr){
    b[i]=true ;
    for(int j : arr.get(i)){
      if(! b[j]){
        dfs(b,j,arr);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class road {
  static   attribute row : int;
  static   attribute col : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ch : Sequence(String) ; ch := sc.getCurrent()->characters() ;
    var sum : int ; sum := 0 ;
    var i : int ; i := 0 ;
        i := 0 ; while i < n - 1 do ( (     if (ch[i+1] = 'U' & ch[i + 1+1] = 'R') then (     sum := sum + 1 ; 
     i := i + 1 ) else     if (ch[i+1] = 'R' & ch[i + 1+1] = 'U') then (     sum := sum + 1 ; 
     i := i + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n - (sum)->char2byte()) ; 
 );
  static   operation dfs( b : Sequence(boolean), i : int, arr : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     b[i+1] := true ; 
     for (j : arr->at(i+1)) do ( (     if (not(b[j+1])) then (     execute dfs(b, j, arr) ) else skip )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static final int N=100005 ;
  static int[] phi ;
  static int[] S ;
  static void computeTotient(){
    for(int i=1 ; i<N ; i++)phi[i]=i ;
    for(int p=2 ; p<N ; p++){
      if(phi[p]==p){
        phi[p]=p-1 ;
        for(int i=2*p ; i<N ; i+=p){
          phi[i]=(phi[i]/p)*(p-1);
        }
      }
    }
  }
  static void CoPrimes(){
    computeTotient();
    for(int i=1 ; i<N ; i++)S[i]=S[i-1]+phi[i];
  }
  public static void main(String args[]){
    phi=new int[N];
    S=new int[N];
    CoPrimes();
    int q[]={
      3,4 };
      int n=q.length ;
      for(int i=0 ; i<n ; i++)System.out.println("Number of unordered coprime\n"+"pairs of integers from 1 to "+q[i]+" are "+S[q[i] ]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute N : int := 100005;
  static   attribute phi : Sequence(int);
  static   attribute S : Sequence(int);
  static   operation computeTotient() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < N do (     phi[i+1] := i ;  ;     i := i + 1 ) ; 
         var p : int ; p := 2 ; while p < N do ( (     if (phi[p+1] = p) then (     phi[p+1] := p - 1 ; 
         var i : int ; i := 2 * p ; while i < N do ( (     phi[i+1] := (phi[i+1] / p) * (p - 1) )  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation CoPrimes() : void
  pre: true
  post: true
  activity: (     execute computeTotient() ; 
         var i : int ; i := 1 ; while i < N do (     S[i+1] := S[i - 1+1] + phi[i+1] ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     phi := Integer.subrange(1,N)->collect(0) ; 
     S := Integer.subrange(1,N)->collect(0) ; 
    execute CoPrimes() ; 
    var q : Sequence(int) ; q := Sequence{3,4} ;
    var n : int ; n := q->size() ;
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].println("Number of unordered coprime\n" + "pairs of integers from 1 to " + q[i+1] + " are " + S[q[i+1]+1]) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Map.Entry ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      TreeMap<Integer,Integer>product=new TreeMap<Integer,Integer>();
      int n=Integer.parseInt(line);
      int name,quant,delim ;
      for(int i=0 ; i<n ; i++){
        line=br.readLine();
        delim=line.indexOf(' ');
        name=stoi(line.substring(0,delim));
        quant=Integer.parseInt(line.substring(delim+1));
        if(product.containsKey(name)){
          product.put(name,product.get(name)+quant);
        }
        else {
          product.put(name,quant);
        }
      }
      StringBuilder sb=new StringBuilder();
      for(Entry<Integer,Integer>e : product.entrySet()){
        sb.append(itos(e.getKey().intValue())+" "+e.getValue().toString()+"\n");
      }
      System.out.print(sb.toString());
    }
  }
  static int stoi(String str){
    int result=0 ;
    for(int i=0 ; i<str.length(); i++){
      result<<=5 ;
      result+=(str.charAt(i)-'@');
    }
    return result ;
  }
  static String itos(int num){
    char[] str=new char[5];
    int c,len=0 ;
    for(int i=4 ; i>=0 ; i--){
      c=num>>5*i & 31 ;
      if(c!=0){
        str[len]=(char)(c+'@');
        len++;
      }
    }
    return(new String(Arrays.copyOf(str,len)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var product : Map(int,int) ; product := Map{} ;
     var n : int ; n := (line)->toInteger() ;
    var name : int ;
    var quant : int ;
    var delim : int ;
        var i : int ; i := 0 ; while i < n do ( (     line := br.readLine() ; 
     delim := line->indexOf(' ')-1 ; 
    name := stoi(line.subrange(0+1,delim)) ; 
    quant := (line.subrange(delim + 1+1,delim + 1))->toInteger() ; 
    if (product->keys()->includes(name)) then (     product := product->union(Map{name |-> product->at(name) + quant}) ) else (     product := product->union(Map{name |-> quant}) ) ;  
 )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    for (e : product->asSet()) do ( (     sb := sb + StringLib.newString(itos(e.getKey()->oclAsType(int)) + " " + e.getValue()+"" + "\n") )  ) ; 
    OclFile["System.out"].print(sb+"") ; 
 ) ;     line := br.readLine() ;
 ) );
  static   operation stoi( str : String) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     result := result*(2->pow(5)) ; 
     result := result+((str->at(i+1) - ('@')->char2byte())) )  ;     i := i + 1 ) ; 
     return result );
  static   operation itos( num : int) : String
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := Integer.subrange(1,5)->collect(0) ;
     var c : int ;
    var len : int ; len := 0 ;
         var i : int ; i := 4 ; while i >= 0 do ( (     c := MathLib.bitwiseAnd((num/(2->pow(5 * i)))->oclAsType(long),31) ; 
     if (c /= 0) then (     str[len+1] := (c + '@')->oclAsType(String) ; 
     len := len + 1 ) else skip )  ;     i := i - 1 ) ; 
     return (StringLib.newString(str.subrange(1,len))) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    TreeMap<String,Integer>map=new TreeMap<>();
    List<String>key=new ArrayList<>();
    String s ;
    int a ;
    for(int i=0 ; i<n ; i++){
      s=sc.next();
      a=sc.nextInt();
      if(! map.containsKey(s)){
        map.put(s,a);
        key.add(s);
      }
      else {
        map.put(s,map.get(s)+a);
      }
    }
    key.sort(Comparator.comparingInt(String :: length).thenComparing(Comparator.naturalOrder()));
    key.forEach(e->out.println(e+" "+map.get(e)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var map : Map(String,int) ; map := Map{} ;
    var key : Sequence(String) ; key := Sequence{} ;
    var s : String ;
    var a : int ;
        var i : int ; i := 0 ; while i < n do ( (     s := sc.getCurrent() ; 
     a := sc.getCurrent()->toInteger() ; 
     if (not(map->keys()->includes(s))) then (     map := map->union(Map{s |-> a}) ; 
     key := key->including(s) ) else (     map := map->union(Map{s |-> map->at(s) + a}) ) )  ;     i := i + 1 ) ; 
    key := key.sort(Comparator.comparingInt(lambda _pars : OclAny in String.newString().length(_pars)).thenComparing(Comparator.naturalOrder())) ; 
    for e : key do
    (    out.println(e + " " + map->at(e))) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    ArrayList<String>m=new ArrayList<String>();
    int s[]=new int[n];
    m.add(scan.next());
    s[0]=scan.nextInt();
    boolean t=false ;
    for(int i=1 ; i<n ; i++){
      String mm=scan.next();
      for(int j=0 ; j<m.size(); j++){
        if(m.get(j).equals(mm)){
          s[j]+=scan.nextInt();
          t=true ;
          break ;
        }
      }
      if(t==false){
        m.add(mm);
        s[m.size()-1]=scan.nextInt();
      }
      t=false ;
    }
    Map<String,Integer>map=new HashMap<String,Integer>();
    for(int i=0 ; i<m.size(); i++){
      map.put(m.get(i),(Integer)s[i]);
    }
    Collections.sort(m);
    for(int i=0 ; i<m.size(); i++){
      for(int j=0 ; j<m.size()-1-i ; j++){
        if(m.get(j).length()>m.get(j+1).length()){
          String o=m.get(j);
          m.set(j,m.get(j+1));
          m.set(j+1,o);
        }
      }
    }
    for(int i=0 ; i<m.size(); i++){
      System.out.println(m.get(i)+" "+map.get(m.get(i)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : Sequence(String) ; m := Sequence{} ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
    m := m->including(scan.getCurrent()) ; 
    s[0+1] := scan.getCurrent()->toInteger() ; 
    var t : boolean ; t := false ;
        var i : int ; i := 1 ; while i < n do ( (     var mm : String ; mm := scan.getCurrent() ;
         var j : int ; j := 0 ; while j < m->size() do ( (     if (m->at(j+1) = mm) then (     s[j+1] := s[j+1]+(scan.getCurrent()->toInteger()) ; 
     t := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (t = false) then (     m := m->including(mm) ; 
     s[m->size() - 1+1] := scan.getCurrent()->toInteger() ) else skip ; 
     t := false )  ;     i := i + 1 ) ; 
    var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < m->size() do ( (     map := map->union(Map{m->at(i+1) |-> s[i+1]->oclAsType(int)}) )  ;     i := i + 1 ) ; 
    m := m->sort() ; 
        var i : int ; i := 0 ; while i < m->size() do ( (         var j : int ; j := 0 ; while j < m->size() - 1 - i do ( (     if (m->at(j+1)->size() > m->at(j + 1+1)->size()) then (     var o : String ; o := m->at(j+1) ;
     m := m.setAt(j+1,m->at(j + 1+1)) ; 
     m := m.setAt(j + 1+1,o) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m->size() do ( (     OclFile["System.out"].println(m->at(i+1) + " " + map->at(m->at(i+1))) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Comparator ;
import java.util.Map.Entry ;
import java.util.Scanner ;
import java.util.SortedMap ;
import java.util.TreeMap ;
public class Main {
  final static C SINGLE_C=new C();
  static class C implements Comparator<String>{
    private C(){
    };
    @ Override public int compare(String o1,String o2){
      int result=o1.length()-o2.length();
      if(result==0){
        result=o1.compareTo(o2);
      }
      return result ;
    }
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] value=new int[n];
    int nextIndex=0 ;
    SortedMap<String,Integer>indexMap=new TreeMap<String,Integer>(SINGLE_C);
    while(n-->0){
      String name=in.next();
      int index ;
      if(! indexMap.containsKey(name)){
        index=nextIndex ;
        indexMap.put(name,Integer.valueOf(nextIndex++));
      }
      else {
        index=indexMap.get(name).intValue();
      }
      value[index]+=in.nextInt();
    }
    for(Entry<String,Integer>e : indexMap.entrySet()){
      System.out.println(e.getKey()+" "+value[e.getValue().intValue()]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute SINGLE_C : C := C.newC();
  static class C implements Function(<String>,(<String>,boolean)) {
   static operation newC() : C
  pre: true
  post: true
  activity:
  ( var self : C ;
    self := createC();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
      operation compare( o1 : String, o2 : String) : int
  pre: true
  post: true
  activity: (     var result : int ; result := o1->size() - o2->size() ;
     if (result = 0) then (     result := o1->compareTo(o2) ) else skip ; 
     return result );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var value : Sequence(int) ; value := Integer.subrange(1,n)->collect(0) ;
    var nextIndex : int ; nextIndex := 0 ;
    var indexMap : Map(String,int) ; indexMap := Map{}->union(SINGLE_C) ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var name : String ; name := in.getCurrent() ;
     var index : int ;
     if (not(indexMap->keys()->includes(name))) then (     index := nextIndex ; 
     indexMap := indexMap->union(Map{name |-> (nextIndex)->toInteger()}) ) else (     index := indexMap->at(name)->oclAsType(int) ) ;  
     value[index+1] := value[index+1]+(in.getCurrent()->toInteger()) ) ;  ) ;  
    for (e : indexMap->asSet()) do ( (     OclFile["System.out"].println(e.getKey() + " " + value[e.getValue()->oclAsType(int)+1]) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    HashMap<String,Integer>map=new HashMap<String,Integer>();
    for(int i=0 ; i<n ; i++){
      String key=sc.next();
      int val=sc.nextInt();
      if(map.containsKey(key))map.put(key,map.get(key)+val);
      else map.put(key,val);
    }
    V[] vs=new V[map.size()];
    int i=0 ;
    for(Map.Entry<String,Integer>entry : map.entrySet()){
      vs[i++]=new V(entry.getKey(),entry.getValue());
    }
    sort(vs);
    for(int j=0 ; j<vs.length ; j++){
      System.out.println(vs[j] .s+" "+vs[j] .t);
    }
  }
  class V implements Comparable<V>{
    String s ;
    int t ;
    V(String s,int t){
      this.s=s ;
      this.t=t ;
    }
    @ Override public int compareTo(V o){
      if(s.length()==o.s.length())return s.compareTo(o.s);
      return s.length()-o.s.length();
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var key : String ; key := sc.getCurrent() ;
     var val : int ; val := sc.getCurrent()->toInteger() ;
     if (map->keys()->includes(key)) then     map := map->union(Map{key |-> map->at(key) + val}) ; else     map := map->union(Map{key |-> val}) ; )  ;     i := i + 1 ) ; 
    var vs : Sequence(V) ; vs := Integer.subrange(1,map.size())->collect(null) ;
    var i : int ; i := 0 ;
    for (entry : map->asSet()) do ( (      vs[i+1] := V.newV(entry.getKey(), entry.getValue())  ; i := i + 1 )  ) ; 
    execute sort(vs) ; 
        var j : int ; j := 0 ; while j < vs->size() do ( (     OclFile["System.out"].println(vs[j+1].s + " " + vs[j+1].t) )  ;     j := j + 1 ) ; 
 );
 class V implements Comparable<V> {
   attribute s : String;
   attribute t : int;
   static operation newV( s : String, t : int) : V
  pre: true
  post: true
  activity:
  ( var self : V ;
    self := createV();
    self.initialise(s, t);
    return self );
  operation initialise( s : String, t : int) : void
  pre: true  post: true
  activity: (     self.s := s ; 
     self.t := t );
      operation compareTo( o : V) : int
  pre: true
  post: true
  activity: (     if (s->size() = o.s->size()) then     return s->compareTo(o.s) else skip ; 
     return s->size() - o.s->size() );
}
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class a {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=n<<1 ;
    ArrayList<Long>ar=new ArrayList<Long>();
    for(int i=0 ; i<m ; i++)ar.add(in.nextLong());
    Collections.sort(ar);
    long min1=(ar.get(n-1)-ar.get(0))*(ar.get(m-1)-ar.get(n));
    long min2=Long.MAX_VALUE ;
    long extreme=ar.get(m-1)-ar.get(0);
    for(int i=0 ; i<=n ; i++){
      long x=ar.get(n+i-1)-ar.get(i);
      min2=Math.min(min2,x);
    }
    min2=extreme*min2 ;
    System.out.println(Math.min(min1,min2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := (n*(2->pow(1)))->oclAsType(long) ;
    var ar : Sequence(long) ; ar := Sequence{} ;
        var i : int ; i := 0 ; while i < m do (     ar := ar->including(in.getCurrent()->toLong()) ;  ;     i := i + 1 ) ; 
    ar := ar->sort() ; 
    var min1 : long ; min1 := (ar->at(n - 1+1) - ar->at(0+1)) * (ar->at(m - 1+1) - ar->at(n+1)) ;
    var min2 : long ; min2 := "9223372036854775807"->toLong() ;
    var extreme : long ; extreme := ar->at(m - 1+1) - ar->at(0+1) ;
        var i : int ; i := 0 ; while i <= n do ( (     var x : long ; x := ar->at(n + i - 1+1) - ar->at(i+1) ;
     min2 := Set{min2, x}->min() )  ;     i := i + 1 ) ; 
    min2 := extreme * min2 ; 
    OclFile["System.out"].println(Set{min1, min2}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(1,in,out);
    out.close();
  }
  static class Task {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      String S=in.next();
      for(int i=S.length()-2 ; i>=0 ; i-=2){
        if(S.substring(0,i/2).equals((S.substring(i/2,i)))){
          out.println(i);
          break ;
        }
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public char nextChar(){
      return next().charAt(0);
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var S : String ; S := in.next() ;
         var i : int ; i := S->size() - 2 ; while i >= 0 do ( (     if (S.subrange(0+1,i / 2) = (S.subrange(i / 2+1,i))) then (     skip ; 
     break ) else skip )  ;     i := i-(2) ) );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class CodeForce1012A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt()*2 ;
    long[] data=new long[n];
    for(int i=0 ; i<n ; ++i){
      data[i]=scanner.nextInt();
    }
    Arrays.sort(data);
    int half=n/2 ;
    long min=(data[half-1]-data[0])*(data[n-1]-data[half]);
    long w=data[n-1]-data[0];
    for(int i=1 ; i<half ; ++i){
      long h=data[i+half-1]-data[i];
      if(min>w*h){
        min=w*h ;
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForce1012A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() * 2 ;
    var data : Sequence(long) ; data := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     data[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    data := data->sort() ; 
    var half : int ; half := n / 2 ;
    var min : long ; min := (data[half - 1+1] - data[0+1]) * (data[n - 1+1] - data[half+1]) ;
    var w : long ; w := data[n - 1+1] - data[0+1] ;
        var i : int ; i := 1 ; while i < half do ( (     var h : long ; h := data[i + half - 1+1] - data[i+1] ;
     if (min > w * h) then (     min := w * h ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.List ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    LunlunNumber solver=new LunlunNumber();
    solver.solve(1,in,out);
    out.close();
  }
  static final class LunlunNumber {
    public void solve(int __,InputReader in,PrintWriter out){
      int n=in.nextInt();
      List<Long>queue=new ArrayList<>(n);
      for(long i=1 ; i<10 ; ++i){
        queue.add(i);
      }
      for(int head=0 ; queue.size()<n ; ++head){
        long current=queue.get(head);
        if(current % 10!=0){
          queue.add(current*10+(current % 10-1));
        }
        queue.add(current*10+(current % 10));
        if(current % 10!=9){
          queue.add(current*10+(current % 10+1));
        }
      }
      out.println(queue.get(n-1));
    }
  }
  static class InputReader {
    private final BufferedReader reader ;
    private StringTokenizer tokenizer ;
    public InputReader(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        tokenizer=new StringTokenizer(readLine());
      }
      return tokenizer.nextToken();
    }
    public String readLine(){
      String line ;
      try {
        line=reader.readLine();
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
      return line ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : LunlunNumber ; solver := LunlunNumber.newLunlunNumber() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static  class LunlunNumber {
   operation solve( __ : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var queue : Sequence(long) ; queue := Sequence{} ;
        var i : long ; i := 1 ; while i < 10 do ( (     queue := queue->including(i) )  ;     i := i + 1 ) ; 
        var head : int ; head := 0 ; while queue->size() < n do ( (     var current : long ; current := queue->at(head+1) ;
     if (current mod 10 /= 0) then (     queue := queue->including(current * 10 + (current mod 10 - 1)) ) else skip ; 
     queue := queue->including(current * 10 + (current mod 10)) ; 
     if (current mod 10 /= 9) then (     queue := queue->including(current * 10 + (current mod 10 + 1)) ) else skip )  ;     head := head + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( in : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(readLine()) ) ; 
     return tokenizer.next() );
   operation readLine() : String
  pre: true
  post: true
  activity: (     var line : String ;
     try (     line := reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
     return line );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class A1012 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    Integer[] A=new Integer[2*N];
    for(int n=0 ; n<A.length ; n++){
      A[n]=in.nextInt();
    }
    Arrays.sort(A);
    long w=A[N-1]-A[0];
    long h=A[2*N-1]-A[N];
    long answer=w*h ;
    w=A[2*N-1]-A[0];
    for(int n=1 ; n<N ; n++){
      h=A[n+N-1]-A[n];
      answer=Math.min(answer,h*w);
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1012 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,2 * N)->collect(null) ;
        var n : int ; n := 0 ; while n < A->size() do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    A := A->sort() ; 
    var w : long ; w := A[N - 1+1] - A[0+1] ;
    var h : long ; h := A[2 * N - 1+1] - A[N+1] ;
    var answer : long ; answer := w * h ;
    w := A[2 * N - 1+1] - A[0+1] ; 
        var n : int ; n := 1 ; while n < N do ( (     h := A[n + N - 1+1] - A[n+1] ; 
     answer := Set{answer, h * w}->min() )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  private static final FastReader fr=new FastReader();
  public static void main(String[] args)throws IOException {
    BufferedWriter output=new BufferedWriter(new OutputStreamWriter(System.out));
    StringBuilder sb=new StringBuilder();
    int testCases=fr.nextInt();
    for(int testCase=1 ; testCase<=testCases ; testCase++){
      int n=fr.nextInt();
      if(solve(n))sb.append("YES\n");
      else sb.append("NO\n");
    }
    output.write(sb.toString());
    output.flush();
  }
  private static boolean solve(int n){
    if(n % 11==0)return true ;
    for(int i=0 ; i<=10 ; i++){
      for(int j=0 ; j<=10 ; j++){
        for(int k=0 ; k<=10 ; k++){
          if(n-i*111-j*11111-k*1111111<0)break ;
          if((n-i*111-j*11111-k*1111111)% 11==0)return true ;
        }
      }
    }
    return false ;
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    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 {
      if(st.hasMoreTokens()){
        str=st.nextToken("\n");
      }
      else {
        str=br.readLine();
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return str ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static    attribute fr : FastReader := FastReader.newFastReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var output : OclFile ; output := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var testCases : int ; testCases := fr.nextInt() ;
        var testCase : int ; testCase := 1 ; while testCase <= testCases do ( (     var n : int ; n := fr.nextInt() ;
     if (solve(n)) then     sb := sb + StringLib.newString("YES\n") ; else     sb := sb + StringLib.newString("NO\n") ; )  ;     testCase := testCase + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n mod 11 = 0) then     return true else skip ; 
         var i : int ; i := 0 ; while i <= 10 do ( (         var j : int ; j := 0 ; while j <= 10 do ( (         var k : int ; k := 0 ; while k <= 10 do ( (     if (n - i * 111 - j * 11111 - k * 1111111 < 0) then     break else skip ; 
     if ((n - i * 111 - j * 11111 - k * 1111111) mod 11 = 0) then     return true else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return false );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Z_ccc_6_2 {
  static int t ;
  static int x ;
  static String ans[];
  public static void main(String args[])throws IOException {
    InputStreamReader r=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(r);
    t=Integer.parseInt(br.readLine());
    ans=new String[t];
    for(int i=0 ; i<t ; i++){
      boolean boo=false ;
      x=Integer.parseInt(br.readLine());
      for(int j=0 ; j*111<=x ; j++){
        if((x-111*j)% 11==0){
          boo=true ;
          break ;
        }
      }
      if(boo){
        ans[i]="YES" ;
      }
      else {
        ans[i]="NO" ;
      }
    }
    for(int i=0 ; i<t ; i++){
      System.out.println(ans[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Z_ccc_6{
  static   attribute t : int;
  static   attribute x : int;
  static   attribute ans : Sequence(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(r) ;
    t := (br.readLine())->toInteger() ; 
    ans := Integer.subrange(1,t)->collect(null) ; 
        var i : int ; i := 0 ; while i < t do ( (     var boo : boolean ; boo := false ;
     x := (br.readLine())->toInteger() ; 
         var j : int ; j := 0 ; while j * 111 <= x do ( (     if ((x - 111 * j) mod 11 = 0) then (     boo := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (boo) then (     ans[i+1] := "YES" ) else (     ans[i+1] := "NO" ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < t do ( (     OclFile["System.out"].println(ans[i+1]) )  ;     i := i + 1 ) ; 
 );
}
 {
  static   attribute t : int;
  static   attribute x : int;
  static   attribute ans : Sequence(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(r) ;
    t := (br.readLine())->toInteger() ; 
    ans := Integer.subrange(1,t)->collect(null) ; 
        var i : int ; i := 0 ; while i < t do ( (     var boo : boolean ; boo := false ;
     x := (br.readLine())->toInteger() ; 
         var j : int ; j := 0 ; while j * 111 <= x do ( (     if ((x - 111 * j) mod 11 = 0) then (     boo := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (boo) then (     ans[i+1] := "YES" ) else (     ans[i+1] := "NO" ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < t do ( (     OclFile["System.out"].println(ans[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.nextLine();
    StringBuilder s1=new StringBuilder(s);
    for(int i=s.length()-1 ; i>=0 ; i--){
      s1.append(s.charAt(i));
    }
    System.out.println(s1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.nextLine() ;
    var s1 : String ; s1 := StringLib.newString(s) ;
        var i : int ; i := s->size() - 1 ; while i >= 0 do ( (     s1 := s1 + StringLib.newString(s->at(i+1)) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(s1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    String s=sc.next();
    out.println(s+new StringBuilder(s).reverse());
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : String ; s := sc.getCurrent() ;
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Test {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String str=sc.next();
      str+=getReverse(str);
      System.out.println(str);
    }
    sc.close();
  }
  private static String getReverse(String str){
    String revString="" ;
    for(int i=str.length()-1 ; i>=0 ; i--)revString+=str.charAt(i)+"" ;
    return revString ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var str : String ; str := sc.getCurrent() ;
     str := str+(getReverse(str)) ; 
     OclFile["System.out"].println(str) ) ; 
     skip );
  static   operation getReverse( str : String) : String
  pre: true
  post: true
  activity: (     var revString : String ; revString := "" ;
         var i : int ; i := str->size() - 1 ; while i >= 0 do (     revString := revString+(str->at(i+1) + "") ;  ;     i := i - 1 ) ; 
     return revString );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    String str=s.next();
    String rev="" ;
    for(int i=0 ; i<str.length(); i++){
      rev=str.charAt(i)+rev ;
    }
    str=str+rev ;
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := s.getCurrent() ;
    var rev : String ; rev := "" ;
        var i : int ; i := 0 ; while i < str->size() do ( (     rev := str->at(i+1) + rev )  ;     i := i + 1 ) ; 
    str := str + rev ; 
    OclFile["System.out"].println(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static int fact(int N){
    int i,product=1 ;
    for(i=1 ; i<=N ; i++)product=product*i ;
    return product ;
  }
  public static int nthTerm(int N){
    return(N*N)*fact(N);
  }
  public static void main(String[] args){
    int N=4 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fact( N : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var product : int ; product := 1 ;
         i := 1 ; while i <= N do (     product := product * i ;  ;     i := i + 1 ) ; 
     return product );
  static   operation nthTerm( N : int) : int
  pre: true
  post: true
  activity: (     return (N * N) * fact(N) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ThreeSwimmers {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      long p=sc.nextLong();
      long a=sc.nextLong();
      long b=sc.nextLong();
      long c=sc.nextLong();
      long x=a-p % a ;
      long y=b-p % b ;
      long z=c-p % c ;
      if(p % a==0 || p % b==0 || p % c==0){
        System.out.println("0");
      }
      else {
        long result=Math.min(Math.min(x,y),z);
        long res=(long)result ;
        System.out.println(res);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ThreeSwimmers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var p : long ; p := sc.getCurrent()->toLong() ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var c : long ; c := sc.getCurrent()->toLong() ;
    var x : long ; x := a - p mod a ;
    var y : long ; y := b - p mod b ;
    var z : long ; z := c - p mod c ;
    if (p mod a = 0 or p mod b = 0 or p mod c = 0) then (     OclFile["System.out"].println("0") ) else (     var result : long ; result := Set{Set{x, y}->min(), z}->min() ;
     var res : long ; res := result->oclAsType(long) ;
     OclFile["System.out"].println(res) ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1492 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      long p=scanner.nextLong();
      long a=scanner.nextLong();
      long b=scanner.nextLong();
      long c=scanner.nextLong();
      long a1=(p % a==0)? 0 : a-p % a ;
      long b1=(p % b==0)? 0 : b-p % b ;
      long c1=(p % c==0)? 0 : c-p % c ;
      System.out.println(Math.min(Math.min(a1,b1),c1));
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1492 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var p : long ; p := scanner.getCurrent()->toLong() ;
     var a : long ; a := scanner.getCurrent()->toLong() ;
    var b : long ; b := scanner.getCurrent()->toLong() ;
    var c : long ; c := scanner.getCurrent()->toLong() ;
    var a1 : long ; a1 := if (p mod a = 0) then 0 else a - p mod a endif ;
    var b1 : long ; b1 := if (p mod b = 0) then 0 else b - p mod b endif ;
    var c1 : long ; c1 := if (p mod c = 0) then 0 else c - p mod c endif ;
    OclFile["System.out"].println(Set{Set{a1, b1}->min(), c1}->min()) ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int head=0 ;
  static void f(int i,char[] r){
    if(i==head){
      if(r[i]=='9'){
++head ;
        f(i+1,r);
        r[i]=(char)Math.max('0',r[i+1]-1);
      }
      else {
++r[i];
      }
    }
    else if(r[i]=='9' || Math.abs(++r[i]-r[i+1])>1){
      f(i+1,r);
      r[i]=(char)Math.max('0',r[i+1]-1);
    }
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    char[] r=new char[11];
    Arrays.fill(r,'0');
    for(int k=s.nextInt(); k>0 ; --k){
      f(0,r);
    }
    System.out.println(new StringBuilder(String.valueOf(r)).reverse().toString().replaceFirst("^0+",""));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute head : int := 0;
  static   operation f( i : int, r : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (i = head) then (     if (r[i+1] = '9') then (     head := head + 1 ; 
     execute f(i + 1, r) ; 
     r[i+1] := Set{'0', r[i + 1+1] - 1}->max()->oclAsType(String) ) else (     r[i+1] := r[i+1] + 1 ) ) else     if (r[i+1] = '9' or if r[i+1] - r[i + 1+1] < 0 then -(r[i+1] - r[i + 1+1]) else r[i+1] - r[i + 1+1] endif > 1) then (     execute f(i + 1, r) ; 
     r[i+1] := Set{'0', r[i + 1+1] - 1}->max()->oclAsType(String) ) else skip ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : Sequence(String) ; r := Integer.subrange(1,11)->collect(0) ;
    r := r->collect('0') ; 
        var k : int ; k := s.getCurrent()->toInteger() ; while k > 0 do ( (     execute f(0, r) )  ;     k := k - 1 ) ; 
    OclFile["System.out"].println(StringLib.newString((r)->sum() )->reverse()+"".replaceFirstMatch("^0+", "")) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A1492 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long p=sc.nextLong();
      long a=sc.nextLong();
      long b=sc.nextLong();
      long c=sc.nextLong();
      System.out.println(Math.min((a-p % a)% a,Math.min((b-p % b)% b,(c-p % c)% c)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1492 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var p : long ; p := sc.getCurrent()->toLong() ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var c : long ; c := sc.getCurrent()->toLong() ;
    OclFile["System.out"].println(Set{(a - p mod a) mod a, Set{(b - p mod b) mod b, (c - p mod c) mod c}->min()}->min()) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      long p=sc.nextLong();
      long ans=(long)1e18 ;
      for(int i=0 ; i<3 ; ++i){
        long a=sc.nextLong();
        ans=Math.min(ans,((p+a-1)/a)*a-p);
      }
      out.println(ans);
    }
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var p : long ; p := sc.getCurrent()->toLong() ;
     var ans : long ; ans := 1e18->oclAsType(long) ;
         var i : int ; i := 0 ; while i < 3 do ( (     var a : long ; a := sc.getCurrent()->toLong() ;
     ans := Set{ans, ((p + a - 1) / a) * a - p}->min() )  ;     i := i + 1 ) ; 
     skip ) ;  ) ;  
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int t=in.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      long P=in.nextLong();
      long A=in.nextLong();
      long B=in.nextLong();
      long C=in.nextLong();
      long a=P % A ;
      long b=P % B ;
      long c=P % C ;
      a=(a==0)? 0 :(A-a);
      b=(b==0)? 0 :(B-b);
      c=(c==0)? 0 :(C-c);
      long answer=Math.min(a,Math.min(b,c));
      System.out.println(answer);
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        var tt : int ; tt := 0 ; while tt < t do ( (     var P : long ; P := in.getCurrent()->toLong() ;
     var A : long ; A := in.getCurrent()->toLong() ;
    var B : long ; B := in.getCurrent()->toLong() ;
    var C : long ; C := in.getCurrent()->toLong() ;
    var a : long ; a := P mod A ;
    var b : long ; b := P mod B ;
    var c : long ; c := P mod C ;
    a := if (a = 0) then 0 else (A - a) endif ; 
    b := if (b = 0) then 0 else (B - b) endif ; 
    c := if (c = 0) then 0 else (C - c) endif ; 
    var answer : long ; answer := Set{a, Set{b, c}->min()}->min() ;
    OclFile["System.out"].println(answer) ; 
 )  ;     tt := tt + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; tc++){
      int n=sc.nextInt();
      int k=sc.nextInt();
      System.out.println(solve(n,k));
    }
    sc.close();
  }
  static String solve(int n,int k){
    return IntStream.range(0,n).mapToObj(i->(char)(i % k+'a')).collect(StringBuilder :: new,StringBuilder :: append,StringBuilder :: append).toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(n, k)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( n : int, k : int) : String
  pre: true
  post: true
  activity: (     return Integer.subrange(0, n-1).mapToObj(lambda i : OclAny in (i mod k + 'a')->oclAsType(String)).collect(lambda _pars : OclAny in String.newString().new(_pars), lambda _pars : OclAny in StringBuilder.newStringBuilder().append(_pars), lambda _pars : OclAny in StringBuilder.newStringBuilder().append(_pars))+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt(),k=sc.nextInt();
      StringBuilder sb=new StringBuilder();
      for(int i=0 ; i<n ; ++i)sb.append((char)('a'+(i % k)));
      out.println(sb);
    }
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < n do (     sb := sb + StringLib.newString(('a' + (i mod k))->oclAsType(String)) ;  ;     i := i + 1 ) ; 
     skip ) ;  ) ;  
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class P1092A {
  public static void main(String[] args)throws IOException {
    BufferedReader io=new BufferedReader(new InputStreamReader(System.in));
    Integer cnt=Integer.valueOf(io.readLine());
    List<String>rs=new ArrayList<String>();
    while(cnt>0){
      cnt--;
      String[] input=io.readLine().split(" ");
      Integer n=Integer.valueOf(input[0]);
      Integer k=Integer.valueOf(input[1]);
      StringBuffer tmp=new StringBuffer();
      int i=0 ;
      while(tmp.length()<n){
        tmp.append((char)(97+i));
        i++;
        if(i %(k)==0){
          i=0 ;
        }
      }
      rs.add(tmp.toString());
    }
    for(String string : rs){
      System.out.println(string);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P1092A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var cnt : int ; cnt := (io.readLine())->toInteger() ;
    var rs : Sequence(String) ; rs := Sequence{} ;
    while (cnt > 0) do (     cnt := cnt - 1 ; 
     var input : Sequence(String) ; input := io.readLine()->split(" ") ;
    var n : int ; n := (input[0+1])->toInteger() ;
    var k : int ; k := (input[1+1])->toInteger() ;
    var tmp : String ; tmp := StringLib.newString() ;
    var i : int ; i := 0 ;
    while (tmp->size() < n) do (     tmp := tmp + StringLib.newString((97 + i)->oclAsType(String)) ; 
     i := i + 1 ; 
     if (i mod (k) = 0) then (     i := 0 ) else skip ) ; 
    rs := rs->including(tmp+"") ; 
 ) ; 
    for (string : rs) do ( (     OclFile["System.out"].println(string) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigDecimal ;
import java.math.RoundingMode ;
import java.util.*;
public class ProblemC {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int test=Integer.parseInt(br.readLine());
    while(test-->0){
      String line[]=br.readLine().split(" ");
      int n=Integer.parseInt(line[0]);
      int k=Integer.parseInt(line[1]);
      String res="" ;
      char c='a',t=(char)('a'+(k-1));
      for(int i=0 ; i<n ; i++){
        res+=c ;
        c++;
        if(c>t)c='a' ;
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemC {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
     var test : int ; test := (br.readLine())->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
     var n : int ; n := (line[0+1])->toInteger() ;
    var k : int ; k := (line[1+1])->toInteger() ;
    var res : String ; res := "" ;
    var c : String ; c := 'a' ;
    var t : String ; t := ('a' + (k - 1))->oclAsType(String) ;
        var i : int ; i := 0 ; while i < n do ( (     res := res+(c) ; 
     c := c + 1 ; 
     if (c > t) then     c := 'a' ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String ln=br.readLine();
    String ans=getAnswerString(ln);
    System.out.println(ans.length());
  }
  private static String getAnswerString(String st){
    int st_len=st.length();
    st=delOneChar(st);
    while(! isDoubled(st)){
      st=delOneChar(st);
    }
    return st ;
  }
  private static boolean isDoubled(String st){
    int st_len=st.length();
    if(st_len==1){
      return true ;
    }
    if(st_len % 2!=0){
      return false ;
    }
    int start1=0 ;
    int start2=st_len/2 ;
    while(start1<st_len/2){
      char st1=st.charAt(start1);
      char st2=st.charAt(start2);
      if(st1!=st2){
        return false ;
      }
      start1++;
      start2++;
    }
    return true ;
  }
  private static String delOneChar(String st){
    return st.substring(0,st.length()-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var ln : String ; ln := br.readLine() ;
     var ans : String ; ans := getAnswerString(ln) ;
     OclFile["System.out"].println(ans->size()) );
  static   operation getAnswerString( st : String) : String
  pre: true
  post: true
  activity: (     var st_len : int ; st_len := st->size() ;
     st := delOneChar(st) ; 
     while (not(isDoubled(st))) do (     st := delOneChar(st) ) ; 
     return st );
  static   operation isDoubled( st : String) : boolean
  pre: true
  post: true
  activity: (     var st_len : int ; st_len := st->size() ;
     if (st_len = 1) then (     return true ) else skip ; 
    if (st_len mod 2 /= 0) then (     return false ) else skip ; 
    var start1 : int ; start1 := 0 ;
    var start2 : int ; start2 := st_len / 2 ;
    while (start1 < st_len / 2) do (     var st1 : String ; st1 := st->at(start1+1) ;
     var st2 : String ; st2 := st->at(start2+1) ;
    if (st1 /= st2) then (     return false ) else skip ; 
    start1 := start1 + 1 ; 
    start2 := start2 + 1 ; 
 ) ; 
    return true 
 );
  static   operation delOneChar( st : String) : String
  pre: true
  post: true
  activity: (     return st.subrange(0+1,st->size() - 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  private static int gcd(int reduceNum,int b){
    return b==0 ? reduceNum : gcd(b,reduceNum % b);
  }
  private static int reduceB(int a,String b){
    int result=0 ;
    for(int i=0 ; i<b.length(); i++){
      result=(result*10+b.charAt(i)-'0')% a ;
    }
    return result ;
  }
  private static int gcdLarge(int a,String b){
    int num=reduceB(a,b);
    return gcd(num,a);
  }
  public static void main(String[] args){
    int a=1221 ;
    String b="19837658191095787329" ;
    if(a==0)System.out.println(b);
    else System.out.println(gcdLarge(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gcd( reduceNum : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then reduceNum else gcd(b, reduceNum mod b) endif );
  static   operation reduceB( a : int, b : String) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < b->size() do ( (     result := (result * 10 + b->at(i+1) - ('0')->char2byte()) mod a )  ;     i := i + 1 ) ; 
     return result );
  static   operation gcdLarge( a : int, b : String) : int
  pre: true
  post: true
  activity: (     var num : int ; num := reduceB(a, b) ;
     return gcd(num, a) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 1221 ;
     var b : String ; b := "19837658191095787329" ;
     if (a = 0) then     OclFile["System.out"].println(b) ; else     OclFile["System.out"].println(gcdLarge(a, b)) ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  static long mod=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int place1=0 ;
    int place2=0 ;
    int[] a=new int[n];
    Arrays.fill(a,-1);
    for(int i=0 ; i<n+1 ; i++){
      int b=sc.nextInt()-1 ;
      if(a[b]==-1){
        a[b]=i ;
      }
      else {
        place1=a[b];
        place2=i ;
      }
    }
    long[] pow=new long[n+2];
    pow[0]=1 ;
    for(int i=1 ; i<=n+1 ; i++){
      pow[i]=pow[i-1]*i ;
      pow[i] %=mod ;
    }
    long[] mp=new long[n+2];
    mp[0]=1 ;
    for(int i=1 ; i<=n+1 ; i++){
      mp[i]=modpow(pow[i],mod-2);
    }
    int c=place2-place1+1 ;
    for(int i=1 ; i<=n+1 ; i++){
      long c1=(((pow[n+1]*mp[n+1-i])% mod)*mp[i])% mod ;
      long c2=0 ;
      if(n+2-c-i>=0){
        c2=(((pow[n+1-c]*mp[n+2-c-i])% mod)*mp[i-1])% mod ;
      }
      System.out.println((c1-c2+mod)% mod);
    }
  }
  static long modpow(long left,long right){
    long ans=1 ;
    while(right>0){
      if((right & 1)==1){
        ans*=left ;
      }
      right>>=1 ;
      left*=left ;
      ans %=mod ;
      left %=mod ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var place1 : int ; place1 := 0 ;
    var place2 : int ; place2 := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    a := a->collect(-1) ; 
        var i : int ; i := 0 ; while i < n + 1 do ( (     var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
     if (a[b+1] = -1) then (     a[b+1] := i ) else (     place1 := a[b+1] ; 
     place2 := i ) )  ;     i := i + 1 ) ; 
    var pow : Sequence(long) ; pow := Integer.subrange(1,n + 2)->collect(0) ;
    pow[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n + 1 do ( (     pow[i+1] := pow[i - 1+1] * i ; 
     pow[i+1] := pow[i+1] mod mod )  ;     i := i + 1 ) ; 
    var mp : Sequence(long) ; mp := Integer.subrange(1,n + 2)->collect(0) ;
    mp[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n + 1 do ( (     mp[i+1] := modpow(pow[i+1], mod - 2) )  ;     i := i + 1 ) ; 
    var c : int ; c := place2 - place1 + 1 ;
        var i : int ; i := 1 ; while i <= n + 1 do ( (     var c1 : long ; c1 := (((pow[n + 1+1] * mp[n + 1 - i+1]) mod mod) * mp[i+1]) mod mod ;
     var c2 : long ; c2 := 0 ;
     if (n + 2 - c - i >= 0) then (     c2 := (((pow[n + 1 - c+1] * mp[n + 2 - c - i+1]) mod mod) * mp[i - 1+1]) mod mod ) else skip ; 
     OclFile["System.out"].println((c1 - c2 + mod) mod mod) )  ;     i := i + 1 ) ; 
 );
  static   operation modpow( left : long, right : long) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
     while (right > 0) do (     if ((right & 1) = 1) then (     ans := ans*(left) ) else skip ; 
     right := right/(2->pow(1)) ; 
    left := left*(left) ; 
    ans := ans mod mod ; 
    left := left mod mod ; 
 ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Problem1444a {
  static long pi ;
  static long qi ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      pi=sc.nextLong();
      qi=sc.nextLong();
      long tmpp=pi ;
      long tmpq=qi ;
      long ans=0 ;
      for(int i=2 ; i<=(long)(Math.sqrt(tmpq)); i++){
        tmpp=pi ;
        while(tmpq % i==0){
          if(tmpp % qi!=0){
            ans=Math.max(ans,tmpp);
          }
          else if(tmpp % i!=0){
          }
          else {
            tmpp/=i ;
            continue ;
          }
          tmpq/=i ;
        }
      }
      if(tmpq>=2){
        long x=pi ;
        while(true){
          if(x % qi!=0){
            ans=Math.max(ans,x);
            break ;
          }
          if(x % tmpq!=0){
            break ;
          }
          else x/=tmpq ;
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem1444a {
  static   attribute pi : long;
  static   attribute qi : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     pi := sc.getCurrent()->toLong() ; 
     qi := sc.getCurrent()->toLong() ; 
    var tmpp : long ; tmpp := pi ;
    var tmpq : long ; tmpq := qi ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 2 ; while i <= ((tmpq)->sqrt())->oclAsType(long) do ( (     tmpp := pi ; 
     while (tmpq mod i = 0) do (     if (tmpp mod qi /= 0) then (     ans := Set{ans, tmpp}->max() ) else     if (tmpp mod i /= 0) then skip else (     tmpp := tmpp/(i) ; 
     continue ) ;  ;  
     tmpq := tmpq/(i) ) )  ;     i := i + 1 ) ; 
    if (tmpq >= 2) then (     var x : long ; x := pi ;
     while (true) do (     if (x mod qi /= 0) then (     ans := Set{ans, x}->max() ; 
     break ) else skip ; 
     if (x mod tmpq /= 0) then (     break ) else     x := x/(tmpq) ; ) ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  static int isSumDivides(int N){
    int temp=N ;
    int sum=0 ;
    while(temp>0){
      sum+=temp % 10 ;
      temp/=10 ;
    }
    if(N % sum==0)return 1 ;
    else return 0 ;
  }
  public static void main(String args[]){
    int N=12 ;
    if(isSumDivides(N)==1)System.out.print("YES");
    else System.out.print("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isSumDivides( N : int) : int
  pre: true
  post: true
  activity: (     var temp : int ; temp := N ;
     var sum : int ; sum := 0 ;
     while (temp > 0) do (     sum := sum+(temp mod 10) ; 
     temp := temp/(10) ) ; 
     if (N mod sum = 0) then     return 1 else     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 12 ;
     if (isSumDivides(N) = 1) then     OclFile["System.out"].print("YES") ; else     OclFile["System.out"].print("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int checkBitonic(int arr[],int n){
    int i,j ;
    for(i=1 ; i<n ; i++){
      if(arr[i]>arr[i-1])continue ;
      if(arr[i]<=arr[i-1])break ;
    }
    if(i==n-1)return 1 ;
    for(j=i+1 ; j<n ; j++){
      if(arr[j]<arr[j-1])continue ;
      if(arr[j]>=arr[j-1])break ;
    }
    i=j ;
    if(i!=n)return 0 ;
    return 1 ;
  }
  public static void main(String args[]){
    int arr[]={
-3,9,7,20,17,5,1 };
      int n=arr.length ;
      System.out.println((checkBitonic(arr,n)==1)? "YES" : "NO");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkBitonic( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := 1 ; while i < n do ( (     if (arr[i+1] > arr[i - 1+1]) then     continue else skip ; 
     if (arr[i+1] <= arr[i - 1+1]) then     break else skip )  ;     i := i + 1 ) ; 
    if (i = n - 1) then     return 1 else skip ; 
        j := i + 1 ; while j < n do ( (     if (arr[j+1] < arr[j - 1+1]) then     continue else skip ; 
     if (arr[j+1] >= arr[j - 1+1]) then     break else skip )  ;     j := j + 1 ) ; 
    i := j ; 
    if (i /= n) then     return 0 else skip ; 
    return 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-3,9,7,20,17,5,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(if (checkBitonic(arr, n) = 1) then "YES" else "NO" endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.Collectors ;
public class Main {
  static List<List<Long>>cnts=new ArrayList<>();
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int K=sc.nextInt();
    List<Long>k1=Arrays.asList(1L,2L,3L,4L,5L,6L,7L,8L,9L);
    cnts.add(k1);
    gen(10);
    System.out.println(cnts.stream().flatMap(p->p.stream()).limit(K).collect(Collectors.toList()).get(K-1));
  }
  private static void gen(int keta){
    if(cnts.size()<keta){
      gen(keta-1);
    }
    List<Long>ket=cnts.get(keta-1).stream().flatMap(p->{
      List<Long>ret=new ArrayList<>();
      long last=p % 10 ;
      if(last>0){
        ret.add(p*10+last-1);
      }
      ret.add(p*10+last);
      if(last<9){
        ret.add(p*10+last+1);
      }
      return ret.stream();
    }
).collect(Collectors.toList());
    cnts.add(ket);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute cnts : Sequence(Sequence(long)) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    var k1 : Sequence(long) ; k1 := Sequence{1L,2L,3L,4L,5L,6L,7L,8L,9L} ;
    cnts := cnts->including(k1) ; 
    execute gen(10) ; 
    OclFile["System.out"].println(cnts->concatenateAll( _x1 | (lambda p : OclAny in p)->apply(_x1) ).subrange(1,K).collect(Collectors.toList())->at(K - 1+1)) ; 
 );
  static   operation gen( keta : int) : void
  pre: true
  post: true
  activity: (     if (cnts->size() < keta) then (     execute gen(keta - 1) ) else skip ; 
     var ket : Sequence(long) ; ket := cnts->at(keta - 1+1)->concatenateAll( _x1 | (lambda p : OclAny in (     var ret : Sequence(long) ; ret := Sequence{} ;
     var last : long ; last := p mod 10 ;
    if (last > 0) then (     ret := ret->including(p * 10 + last - 1) ) else skip ; 
    ret := ret->including(p * 10 + last) ; 
    if (last < 9) then (     ret := ret->including(p * 10 + last + 1) ) else skip ; 
    return ret 
 ))->apply(_x1) ).collect(Collectors.toList()) ;
     cnts := cnts->including(ket) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      long p=sc.nextLong();
      int q=sc.nextInt();
      System.out.println(solve(p,q));
    }
    sc.close();
  }
  static long solve(long p,int q){
    if(p % q!=0){
      return p ;
    }
    long result=0 ;
    for(int i=2 ; i*i<=q ; ++i){
      if(q % i==0){
        int exponent=0 ;
        while(q % i==0){
++exponent ;
          q/=i ;
        }
        long x=p ;
        while(x % i==0){
          x/=i ;
        }
        for(int j=0 ; j<exponent-1 ; ++j){
          x*=i ;
        }
        result=Math.max(result,x);
      }
    }
    if(q!=1){
      long x=p ;
      while(x % q==0){
        x/=q ;
      }
      result=Math.max(result,x);
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var p : long ; p := sc.getCurrent()->toLong() ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(p, q)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( p : long, q : int) : long
  pre: true
  post: true
  activity: (     if (p mod q /= 0) then (     return p ) else skip ; 
     var result : long ; result := 0 ;
        var i : int ; i := 2 ; while i * i <= q do ( (     if (q mod i = 0) then (     var exponent : int ; exponent := 0 ;
     while (q mod i = 0) do (     exponent := exponent + 1 ; 
     q := q/(i) ) ; 
    var x : long ; x := p ;
    while (x mod i = 0) do (     x := x/(i) ) ; 
        var j : int ; j := 0 ; while j < exponent - 1 do ( (     x := x*(i) )  ;     j := j + 1 ) ; 
    result := Set{result, x}->max() ; 
 ) else skip )  ;     i := i + 1 ) ; 
    if (q /= 1) then (     var x : long ; x := p ;
     while (x mod q = 0) do (     x := x/(q) ) ; 
     result := Set{result, x}->max() ) else skip ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int n=0 ;
  static List<Integer>b=null ;
  public static void main(String[] args){
    n=sc.nextInt();
    b=new ArrayList<>();
    for(int i=0 ; i<n ; ++i)b.add(sc.nextInt());
    List<Integer>trace=findTrace();
    if(trace==null){
      System.out.println(-1);
      return ;
    }
    for(int i=trace.size()-1 ; i>=0 ; --i){
      System.out.println(trace.get(i));
    }
  }
  static List<Integer>findTrace(){
    List<Integer>res=new ArrayList<>();
    while(b.size()>0){
      for(int i=b.size()-1 ; i>=0 ; --i){
        if(b.get(i)-1==i){
          res.add(b.get(i));
          b.remove(i);
          break ;
        }
        if(i==0)return null ;
      }
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int := 0;
  static   attribute b : Sequence(int) := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
     b := Sequence{} ; 
        var i : int ; i := 0 ; while i < n do (     b := b->including(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    var trace : Sequence(int) ; trace := findTrace() ;
    if (trace = null) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
        var i : int ; i := trace->size() - 1 ; while i >= 0 do ( (     OclFile["System.out"].println(trace->at(i+1)) )  ;     i := i - 1 ) ; 
 );
  static   operation findTrace() : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Sequence{} ;
     while (b->size() > 0) do (         var i : int ; i := b->size() - 1 ; while i >= 0 do ( (     if (b->at(i+1) - 1 = i) then (     res := res->including(b->at(i+1)) ; 
     b := b->excludingAt(i+1) ; 
     break ) else skip ; 
     if (i = 0) then     return null else skip )  ;     i := i - 1 ) ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Integer>list=new LinkedList<>();
    for(int i=0 ; i<n ; i++){
      int b=sc.nextInt();
      b--;
      list.add(b);
    }
    List<Integer>ansList=new ArrayList<>();
    outer : for(int i=0 ;
    i<n ;
    i++){
      for(int j=list.size()-1 ; j>=0 ; j--){
        int num=list.get(j);
        if(j==num){
          list.remove(j);
          ansList.add(num);
          continue outer ;
        }
      }
      break ;
    }
    if(list.isEmpty()){
      Collections.reverse(ansList);
      for(int num : ansList)System.out.println(num+1);
    }
    else {
      System.out.println(-1);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var b : int ; b := sc.getCurrent()->toInteger() ;
     b := b - 1 ; 
     list := list->including(b) )  ;     i := i + 1 ) ; 
    var ansList : Sequence(int) ; ansList := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := list->size() - 1 ; while j >= 0 do ( (     var num : int ; num := list->at(j+1) ;
     if (j = num) then (     list := list->excludingAt(j+1) ; 
     ansList := ansList->including(num) ; 
     continue ) else skip )  ;     j := j - 1 ) ; 
     break )  ;     i := i + 1 ) ; 
    if (list->isEmpty()) then (     ansList := ansList->reverse() ; 
     for (num : ansList) do (     OclFile["System.out"].println(num + 1) ;  ) ) else (     OclFile["System.out"].println(-1) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Vector ;
import java.util.Scanner ;
import java.util.Stack ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ALimitedInsertion solver=new ALimitedInsertion();
    solver.solve(1,in,out);
    out.close();
  }
  static class ALimitedInsertion {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      ArrayList<Integer>al=new ArrayList<>();
      Stack<Integer>st=new Stack<>();
      for(int i=0 ; i<n ; i++){
        al.add(in.nextInt());
      }
      while(! al.isEmpty()){
        boolean f=true ;
        for(int i=al.size()-1 ; i>=0 ; i--){
          if(al.get(i)==i+1){
            f=false ;
            st.add(al.get(i));
            al.remove(i);
            break ;
          }
        }
        if(f){
          out.println(-1);
          return ;
        }
      }
      while(! st.isEmpty()){
        out.println(st.pop());
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ALimitedInsertion ; solver := ALimitedInsertion.newALimitedInsertion() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ALimitedInsertion {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var al : Sequence(int) ; al := Sequence{} ;
    var st : Sequence(int) ; st := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     al := al->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    while (not(al->isEmpty())) do (     var f : boolean ; f := true ;
         var i : int ; i := al->size() - 1 ; while i >= 0 do ( (     if (al->at(i+1) = i + 1) then (     f := false ; 
     st := st->including(al->at(i+1)) ; 
     al := al->excludingAt(i+1) ; 
     break ) else skip )  ;     i := i - 1 ) ; 
     if (f) then (     skip ; 
     return ) else skip ) ; 
    while (not(st->isEmpty())) do (     skip ) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    char[] s=sc.next().toCharArray();
    sc.close();
    label : for(int i=s.length-1 ;
    i>0 ;
    i--){
      if(i % 2==0){
        int i2=i/2 ;
        for(int j=0 ; j<i2 ; j++){
          if(s[j]!=s[j+i2]){
            continue label ;
          }
        }
        System.out.println(i);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
     skip ; 
         var i : int ; i := s->size() - 1 ; while i > 0 do ( (     if (i mod 2 = 0) then (     var i2 : int ; i2 := i / 2 ;
         var j : int ; j := 0 ; while j < i2 do ( (     if (s[j+1] /= s[j + i2+1]) then (     continue ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(i) ; 
     return ) else skip )  ;     i := i - 1 ) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Deque ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Stack ;
class Task {
  List<Integer>list ;
  Deque<Integer>process ;
  Task(List<Integer>list,Deque<Integer>process){
    this.list=list ;
    this.process=process ;
  }
}
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Integer>b=new LinkedList<>();
    for(int i=0 ; i<n ; i++){
      b.add(sc.nextInt());
    }
    Deque<Integer>ans=null ;
    Stack<Task>stack=new Stack<>();
    stack.add(new Task(b,new ArrayDeque<Integer>()));
    loop : while(! stack.isEmpty()){
      Task task=stack.pop();
      List<Integer>tmp=task.list ;
      Deque<Integer>tmpprocess=task.process ;
      if(tmp.size()==0){
        ans=tmpprocess ;
        break ;
      }
      for(int i=0 ; i<tmp.size(); i++){
        if(tmp.get(i)==i+1){
          List<Integer>list=new LinkedList<>();
          for(int j=0 ; j<tmp.size(); j++){
            int x=tmp.get(j);
            if(x>j+1)continue loop ;
            list.add(x);
          }
          list.remove(i);
          Deque<Integer>process=new ArrayDeque<>();
          for(int x : tmpprocess){
            process.addLast(x);
          }
          process.addFirst(i+1);
          stack.add(new Task(list,process));
        }
      }
    }
    if(ans==null){
      System.out.println(-1);
    }
    else {
      for(int x : ans){
        System.out.println(x);
      }
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Task {
   attribute list : Sequence(int);
   attribute process : Sequence(int);
   static operation newTask( list : Sequence(int), process : Sequence(int)) : Task
  pre: true
  post: true
  activity:
  ( var self : Task ;
    self := createTask();
    self.initialise(list, process);
    return self );
  operation initialise( list : Sequence(int), process : Sequence(int)) : void
  pre: true  post: true
  activity: (     self.list := list ; 
     self.process := process );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     b := b->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := null ;
    var stack : Sequence(Task) ; stack := Sequence{} ;
    stack := stack->including(Task.newTask(b, ArrayDeque<int>.newArrayDeque())) ; 
    while (not(stack->isEmpty())) do (     var task : Task ; task := stack->last() ;
     var tmp : Sequence(int) ; tmp := task.list ;
    var tmpprocess : Sequence(int) ; tmpprocess := task.process ;
    if (tmp->size() = 0) then (     ans := tmpprocess ; 
     break ) else skip ; 
        var i : int ; i := 0 ; while i < tmp->size() do ( (     if (tmp->at(i+1) = i + 1) then (     var list : Sequence(int) ; list := Sequence{} ;
         var j : int ; j := 0 ; while j < tmp->size() do ( (     var x : int ; x := tmp->at(j+1) ;
     if (x > j + 1) then     continue else skip ; 
     list := list->including(x) )  ;     j := j + 1 ) ; 
    list := list->excludingAt(i+1) ; 
    var process : Sequence(int) ; process := ArrayDeque<OclAny>.newArrayDeque() ;
    for (x : tmpprocess) do ( (     process := process->append(x) )  ) ; 
    process := process->prepend(i + 1) ; 
    stack := stack->including(Task.newTask(list, process)) ; 
 ) else skip )  ;     i := i + 1 ) ; 
 ) ; 
    if (ans = null) then (     OclFile["System.out"].println(-1) ) else (     for (x : ans) do ( (     OclFile["System.out"].println(x) )  ) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.List ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  private static java.util.Scanner scanner=new java.util.Scanner(System.in);
  public static void main(String[] args){
    int n=scanner.nextInt(),ans[]=new int[n];
    List<Integer>b=IntStream.range(0,n).mapToObj(i->scanner.nextInt()).collect(Collectors.toList());
    while(n>0)for(int i=n,d=0 ;
    i>0 && n>d ;
    i--)switch(Integer.compare(b.get(i-1),i)){
      case 1 : System.out.println(-1);
      return ;
      case 0 : ans[--n]=b.get(i-1);
      b.remove(i-1);
      continue ;
      case-1 : d=Math.max(d,n-i+b.get(i-1));
    }
    for(int i : ans)System.out.println(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : Scanner := Scanner.newScanner(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.nextInt() ;
    var ans : Sequence(void) ; ans := Integer.subrange(1,n)->collect(0) ;
     var b : Sequence(int) ; b := Integer.subrange(0, n-1).mapToObj(lambda i : OclAny in scanner.nextInt()).collect(Collectors.toList()) ;
     while (n > 0) do         var i : int ; i := n ;
    var d : int ; d := 0 ; while i > 0 & n > d do ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (compare(b->at(i - 1+1), i)) ; 
       if _switchval = 1 then
     OclFile["System.out"].println(-1) ; 
    return 
   else skip ;
       if _switchval = 0 then
         n := n - 1 ;
 ans[n+1] := b->at(i - 1+1)  ; 
    b := b->excludingFirst(i - 1) ; 
    continue 
   else skip ;
       if _switchval = -1 then
     d := Set{d, n - i + b->at(i - 1+1)}->max() ; 
   else skip ;
 )
  ;     i := i - 1 ) ; ; 
     for (i : ans) do (     OclFile["System.out"].println(i) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    HashMap<Character,Integer>mp=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      String s=sc.next();
      mp.put(s.charAt(0),mp.getOrDefault(s.charAt(0),0)+1);
    }
    int ans=0 ;
    for(char x : mp.keySet()){
      int res=mp.get(x);
      if(res>1){
        if(res % 2==0){
          int b=fun(res/2);
          ans+=2*b ;
        }
        else {
          int a=(res+1)/2 ;
          ans+=fun(a)+fun(res-a);
        }
      }
    }
    System.out.println(ans);
  }
  public static int fun(int n){
    int ans=n*(n-1);
    return ans/2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var mp : Map(String,int) ; mp := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
     mp := mp->union(Map{s->at(0+1) |-> (if mp->keys()->contains(s->at(0+1)) then mp->at(s->at(0+1)) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (x : mp->keys()) do ( (     var res : int ; res := mp->at(x) ;
     if (res > 1) then (     if (res mod 2 = 0) then (     var b : int ; b := fun(res / 2) ;
     ans := ans+(2 * b) ) else (     var a : int ; a := (res + 1) / 2 ;
     ans := ans+(fun(a) + fun(res - a)) ) ) else skip )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation fun( n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := n * (n - 1) ;
     return ans / 2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class CF1166A {
  public static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int test=scanner.nextInt();
    long[] c1=new long[26];
    long[] c2=new long[26];
    for(int i=0 ; i<test ; i++){
      int ch=scanner.next().charAt(0)-'a' ;
      if(c1[ch]>c2[ch])c2[ch]++;
      else c1[ch]++;
    }
    long res=0 ;
    for(int i=0 ; i<c1.length ; i++){
      if(c1[i]>=2)res+=(c1[i]*(c1[i]-1))/2 ;
      if(c2[i]>=2)res+=(c2[i]*(c2[i]-1))/2 ;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF1166A {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var test : int ; test := scanner.getCurrent()->toInteger() ;
    var c1 : Sequence(long) ; c1 := Integer.subrange(1,26)->collect(0) ;
    var c2 : Sequence(long) ; c2 := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < test do ( (     var ch : int ; ch := scanner.getCurrent()->at(0+1) - ('a')->char2byte() ;
     if (c1[ch+1] > c2[ch+1]) then     c2[ch+1] := c2[ch+1] + 1 ; else     c1[ch+1] := c1[ch+1] + 1 ; )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < c1->size() do ( (     if (c1[i+1] >= 2) then     res := res+((c1[i+1] * (c1[i+1] - 1)) / 2) ; else skip ; 
     if (c2[i+1] >= 2) then     res := res+((c2[i+1] * (c2[i+1] - 1)) / 2) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static int sumOfNum(int n){
    int sum=0 ;
    for(int i=1 ; i<n ; i++)sum+=i ;
    return sum ;
  }
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      int j=0,sum=0 ;
      char[] chat=new char[t];
      HashMap<Character,Integer>map=new HashMap<>();
      while(t-->0){
        String s=sc.next();
        char ch=s.charAt(0);
        chat[j++]=ch ;
        map.put(ch,map.getOrDefault(ch,0)+1);
      }
      for(char key : map.keySet()){
        int n=map.get(key);
        int chk=n/2 ;
        int s1=sumOfNum(chk);
        if(n % 2==0)sum+=s1+s1 ;
        else sum+=s1+s1+chk ;
      }
      System.out.println(sum);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation sumOfNum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i < n do (     sum := sum+(i) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var j : int ; j := 0 ;
    var sum : int ; sum := 0 ;
    var chat : Sequence(String) ; chat := Integer.subrange(1,t)->collect(0) ;
    var map : Map(String,int) ; map := Map{} ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var s : String ; s := sc.getCurrent() ;
     var ch : String ; ch := s->at(0+1) ;
      chat[j+1] := ch  ; j := j + 1 ; 
     map := map->union(Map{ch |-> (if map->keys()->contains(ch) then map->at(ch) else 0 endif) + 1}) ) ;  ) ;  
    for (key : map->keys()) do ( (     var n : int ; n := map->at(key) ;
     var chk : int ; chk := n / 2 ;
     var s1 : int ; s1 := sumOfNum(chk) ;
     if (n mod 2 = 0) then     sum := sum+(s1 + s1) ; else     sum := sum+(s1 + s1 + chk) ; )  ) ; 
    OclFile["System.out"].println(sum) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findLen(int[] arr,int n,int m){
    Vector<Integer>filter=new Vector<>();
    for(int i=0 ; i<n ; i++)if((arr[i] & m)==m)filter.add(arr[i]);
    if(filter.size()==0)return 0 ;
    int c_and=filter.get(0);
    for(int i=1 ; i<filter.size(); i++)c_and &=filter.get(i);
    if(c_and==m)return filter.size();
    return 0 ;
  }
  public static void main(String[] args){
    int arr[]={
      7,3,3,1,3 };
      int n=arr.length ;
      int m=3 ;
      System.out.println(findLen(arr,n,m));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findLen( arr : Sequence(int), n : int, m : int) : int
  pre: true
  post: true
  activity: (     var filter : Sequence(int) ; filter := Sequence{} ;
         var i : int ; i := 0 ; while i < n do (     if ((arr[i+1] & m) = m) then     filter := filter->including(arr[i+1]) ; else skip ;  ;     i := i + 1 ) ; 
    if (filter->size() = 0) then     return 0 else skip ; 
    var c_and : int ; c_and := filter->at(0+1) ;
        var i : int ; i := 1 ; while i < filter->size() do (     c_and := MathLib.bitwiseAnd(c_and, filter->at(i+1)) ;  ;     i := i + 1 ) ; 
    if (c_and = m) then     return filter->size() else skip ; 
    return 0 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{7,3,3,1,3} ;
     var n : int ; n := arr->size() ;
     var m : int ; m := 3 ;
     OclFile["System.out"].println(findLen(arr, n, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.stream.LongStream ;
import java.io.IOException ;
import java.util.Deque ;
import java.util.stream.Collectors ;
import java.io.InputStreamReader ;
import java.util.stream.Stream ;
import java.util.StringTokenizer ;
import java.io.BufferedReader ;
import java.util.ArrayDeque ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    MyScanner in=new MyScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    D solver=new D();
    solver.solve(1,in,out);
    out.close();
  }
  static class D {
    public void solve(int testNumber,MyScanner in,PrintWriter out){
      int K=in.nextInt();
      Deque<Long>que=new ArrayDeque<>(LongStream.rangeClosed(1,9).boxed().collect(Collectors.toSet()));
      while(--K>0){
        long q=que.removeFirst();
        long l=q % 10 ;
        if(l>0)que.add(q*10+l-1);
        que.add(q*10+l);
        if(l<9)que.add(q*10+l+1);
      }
      out.println(que.removeFirst());
    }
  }
  static class MyScanner {
    private BufferedReader in ;
    private StringTokenizer st ;
    public MyScanner(InputStream stream){
      in=new BufferedReader(new InputStreamReader(stream));
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          String rl=in.readLine();
          if(rl==null){
            return null ;
          }
          st=new StringTokenizer(rl);
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : MyScanner ; in := MyScanner.newMyScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : D ; solver := D.newD() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class D {
   operation solve( testNumber : int, in : MyScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var K : int ; K := in.nextInt() ;
     var que : Sequence(long) ; que := ArrayDeque<OclAny>.newArrayDeque(Integer.subrange(1, 9).collect(Collectors.toSet())) ;
         K := K - 1 ;
    while ((K - 1) > 0) do (        K := K - 1 ;     skip ; (     var q : long ; q := que->first() ;
     var l : long ; l := q mod 10 ;
    if (l > 0) then     que := que->including(q * 10 + l - 1) ; else skip ; 
    que := que->including(q * 10 + l) ; 
    if (l < 9) then     que := que->including(q * 10 + l + 1) ; else skip ; 
 ) ;     K := K - 1 ;
 ) ;  
     skip );
}
  static class MyScanner {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner( stream : OclFile) : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     var rl : String ; rl := in.readLine() ;
     if (rl = null) then (     return null ) else skip ; 
     st := OclIterator.newOclIterator_String(rl) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int setBits(int n){
    int count=0 ;
    while(n>0){
      n=n &(n-1);
      count++;
    }
    return count ;
  }
  static int countPairs(int a[],int n){
    int count=0 ;
    for(int i=0 ; i<n-1 ; i++){
      int setbits_x=setBits(a[i]);
      for(int j=i+1 ; j<n ; j++){
        int setbits_y=setBits(a[j]);
        int setbits_xor_xy=setBits(a[i] ^ a[j]);
        if(setbits_x+setbits_y==setbits_xor_xy)count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int[] a={
      2,3,4,5,6 };
      int n=a.length ;
      System.out.println(countPairs(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation setBits( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     n := n & (n - 1) ; 
     count := count + 1 ) ; 
     return count );
  static   operation countPairs( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     var setbits_x : int ; setbits_x := setBits(a[i+1]) ;
         var j : int ; j := i + 1 ; while j < n do ( (     var setbits_y : int ; setbits_y := setBits(a[j+1]) ;
     var setbits_xor_xy : int ; setbits_xor_xy := setBits(a[i+1] xor a[j+1]) ;
     if (setbits_x + setbits_y = setbits_xor_xy) then     count := count + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,3,4,5,6} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(countPairs(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long x=sc.nextLong();
    long a=0,b=0 ;
    boolean flag=false ;
    for(a=0 ; a<200 ; a++){
      for(b=0 ; b<200 ; b++){
        if(a*a*a*a*a-b*b*b*b*b==x){
          flag=true ;
          break ;
        }
        else if(a*a*a*a*a+b*b*b*b*b==x){
          b*=-1 ;
          flag=true ;
          break ;
        }
        else if(-a*a*a*a*a-b*b*b*b*b==x){
          a*=-1 ;
          flag=true ;
          break ;
        }
        else if(-a*a*a*a*a+b*b*b*b*b==x){
          a*=-1 ;
          b*=-1 ;
          flag=true ;
          break ;
        }
      }
      if(flag){
        break ;
      }
    }
    System.out.println(a+" "+b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := sc.getCurrent()->toLong() ;
    var a : long ; a := 0 ;
    var b : long ; b := 0 ;
    var flag : boolean ; flag := false ;
        a := 0 ; while a < 200 do ( (         b := 0 ; while b < 200 do ( (     if (a * a * a * a * a - b * b * b * b * b = x) then (     flag := true ; 
     break ) else     if (a * a * a * a * a + b * b * b * b * b = x) then (     b := b*(-1) ; 
     flag := true ; 
     break ) else     if (-a * a * a * a * a - b * b * b * b * b = x) then (     a := a*(-1) ; 
     flag := true ; 
     break ) else     if (-a * a * a * a * a + b * b * b * b * b = x) then (     a := a*(-1) ; 
     b := b*(-1) ; 
     flag := true ; 
     break ) else skip ; ;  ;  )  ;     b := b + 1 ) ; 
     if (flag) then (     break ) else skip )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(a + " " + b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public final class Main {
  public static void main(String[] args){
    final Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    final int x=in.nextInt();
    int t=0 ;
    final Map<Long,Integer>map=new HashMap<>();
    while(Math.pow(t,5)<1e18){
      map.put((long)Math.pow(t,5),t);
      map.put((long)Math.pow(-t,5),-t);
      t++;
    }
    twoSum(x,map);
  }
  public static void twoSum(int target,Map<Long,Integer>map){
    for(long num : map.keySet()){
      if(map.containsKey(target+num)){
        System.out.println(map.get(target+num)+" "+map.get(num));
        return ;
      }
      else if(map.containsKey(num-target)){
        System.out.println(map.get(num)+" "+map.get(num-target));
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var x : int ; x := in.getCurrent()->toInteger() ;
    var t : int ; t := 0 ;
    var map : Map(long,int) ; map := Map{} ;
    while (t->pow(5) < 1e18) do (     map := map->union(Map{t->pow(5)->oclAsType(long) |-> t}) ; 
     map := map->union(Map{-t->pow(5)->oclAsType(long) |-> -t}) ; 
     t := t + 1 ) ; 
    execute twoSum(x, map) ; 
 );
  static   operation twoSum( target : int, map : Map(long,int)) : void
  pre: true
  post: true
  activity: (     for (num : map->keys()) do ( (     if (map->keys()->includes(target + num)) then (     OclFile["System.out"].println(map->at(target + num) + " " + map->at(num)) ; 
     return ) else     if (map->keys()->includes(num - target)) then (     OclFile["System.out"].println(map->at(num) + " " + map->at(num - target)) ; 
     return ) else skip ; )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    try {
      InputStreamReader isr=new InputStreamReader(System.in);
      BufferedReader br=new BufferedReader(isr);
      String str=br.readLine();
      for(int i=1 ; i<str.length(); i++){
        String tmpStr=str.substring(0,str.length()-i);
        int tmpLen=tmpStr.length();
        if(tmpLen % 2!=0){
          continue ;
        }
        String tmp1=tmpStr.substring(0,tmpLen/2);
        String tmp2=tmpStr.substring(tmpLen/2,tmpLen);
        if(tmp1.equals(tmp2)){
          System.out.println(tmpLen);
          break ;
        }
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
     var str : String ; str := br.readLine() ;
         var i : int ; i := 1 ; while i < str->size() do ( (     var tmpStr : String ; tmpStr := str.subrange(0+1,str->size() - (i)->char2byte()) ;
     var tmpLen : int ; tmpLen := tmpStr->size() ;
    if (tmpLen mod 2 /= 0) then (     continue ) else skip ; 
    var tmp1 : String ; tmp1 := tmpStr.subrange(0+1,tmpLen / 2) ;
    var tmp2 : String ; tmp2 := tmpStr.subrange(tmpLen / 2+1,tmpLen) ;
    if (tmp1 = tmp2) then (     OclFile["System.out"].println(tmpLen) ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scan=new Scanner(System.in)){
      int X=scan.nextInt();
      long A=0 ;
      long B=0 ;
      long x=0 ;
      long y=0 ;
      ArrayList<Integer>yakusu=enum_div(X);
      for(int i=0 ; i<yakusu.size(); i++){
        A=yakusu.get(i);
        B=X/A ;
        x=0 ;
        while(true){
          long z=x*x*x*x*x-(x-A)*(x-A)*(x-A)*(x-A)*(x-A);
          if(z==X){
            System.out.println(x);
            System.out.println(x-A);
            System.exit(0);
          }
          if(x==10000)break ;
          x++;
        }
      }
    }
  }
  private static ArrayList<Integer>enum_div(int n){
    ArrayList<Integer>ret=new ArrayList<Integer>();
    for(int i=1 ; i*i<=n ; i++){
      if(n % i==0){
        ret.add(i);
        if(i*i!=n){
          ret.add(n/i);
        }
      }
    }
    Collections.sort(ret);
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var X : int ; X := scan.getCurrent()->toInteger() ;
     var A : long ; A := 0 ;
    var B : long ; B := 0 ;
    var x : long ; x := 0 ;
    var y : long ; y := 0 ;
    var yakusu : Sequence(int) ; yakusu := enum_div(X) ;
        var i : int ; i := 0 ; while i < yakusu->size() do ( (     A := yakusu->at(i+1) ; 
     B := X / A ; 
     x := 0 ; 
     while (true) do (     var z : long ; z := x * x * x * x * x - (x - A) * (x - A) * (x - A) * (x - A) * (x - A) ;
     if (z = X) then (     OclFile["System.out"].println(x) ; 
     OclFile["System.out"].println(x - A) ; 
 OclProcess.exit(0) ) else skip ; 
     if (x = 10000) then     break else skip ; 
     x := x + 1 ) )  ;     i := i + 1 ) ; 
 ))  );
  static   operation enum_div( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ret : Sequence(int) ; ret := Sequence{} ;
         var i : int ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     ret := ret->including(i) ; 
     if (i * i /= n) then (     ret := ret->including(n / i) ) else skip ) else skip )  ;     i := i + 1 ) ; 
     ret := ret->sort() ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static final int MOD=1_000_000_007 ;
  private static final String YES="Yes" ;
  private static final String NO="No" ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int X=sc.nextInt();
    System.out.println(solve(X));
  }
  private static String solve(long X){
    for(long i=0 ; i<=1000 ; i++){
      for(long j=-2000 ; j<=2000 ; j++){
        long tmp=(long)Math.pow(i,5)-(long)Math.pow(j,5);
        if(tmp==X){
          return i+" "+j ;
        }
      }
    }
    return null ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1_000_000_007;
  static    attribute YES : String := "Yes";
  static    attribute NO : String := "No";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : int ; X := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(X)) );
  static   operation solve( X : long) : String
  pre: true
  post: true
  activity: (         var i : long ; i := 0 ; while i <= 1000 do ( (         var j : long ; j := -2000 ; while j <= 2000 do ( (     var tmp : long ; tmp := i->pow(5)->oclAsType(long) - j->pow(5)->oclAsType(long) ;
     if (tmp = X) then (     return i + " " + j ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return null );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static long x=sc.nextLong();
  static long num[]=new long[123];
  public static void main(String[] args){
    int i=-1 ;
    while(++i<num.length){
      if(i==0){
        num[0]=0 ;
        continue ;
      }
      num[i]=(long)Math.pow(i,5);
    }
    for(int j=0 ; j<num.length ; j++){
      for(int k=0 ; k<num.length ; k++){
        if(num[j]-num[k]==x){
          System.out.println(j+" "+k);
          return ;
        }
        else if(-num[j]-num[k]==x){
          System.out.println(-j+" "+k);
          return ;
        }
        else if(num[j]+num[k]==x){
          System.out.println(j+" "+-k);
          return ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute x : long := sc.getCurrent()->toLong();
  static   attribute num : long := Integer.subrange(1,123)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := -1 ;
         i := i + 1 ;
    while ((i + 1) < num->size()) do (        i := i + 1 ; length`preSideEffect    num.length ; (     if (i = 0) then (     num[0+1] := 0 ; 
     continue ) else skip ; 
     num[i+1] := i->pow(5)->oclAsType(long) ) ;     i := i + 1 ;
 ) ;  
         var j : int ; j := 0 ; while j < num->size() do ( (         var k : int ; k := 0 ; while k < num->size() do ( (     if (num[j+1] - num[k+1] = x) then (     OclFile["System.out"].println(j + " " + k) ; 
     return ) else     if (-num[j+1] - num[k+1] = x) then (     OclFile["System.out"].println(-j + " " + k) ; 
     return ) else     if (num[j+1] + num[k+1] = x) then (     OclFile["System.out"].println(j + " " + -k) ; 
     return ) else skip ; ;  )  ;     k := k + 1 ) )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void findNumbers(int arr[],int n){
    int sumN=(n*(n+1))/2 ;
    int sumSqN=(n*(n+1)*(2*n+1))/6 ;
    int sum=0,sumSq=0,i ;
    for(i=0 ; i<n ; i++){
      sum+=arr[i];
      sumSq+=Math.pow(arr[i],2);
    }
    int B=(((sumSq-sumSqN)/(sum-sumN))+sumN-sum)/2 ;
    int A=sum-sumN+B ;
    System.out.println("A="+A+"\nB="+B);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,2,3,4 };
      int n=arr.length ;
      findNumbers(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNumbers( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var sumN : int ; sumN := (n * (n + 1)) / 2 ;
     var sumSqN : int ; sumSqN := (n * (n + 1) * (2 * n + 1)) / 6 ;
    var sum : int ; sum := 0 ;
    var sumSq : int ; sumSq := 0 ;
    var i : int ;
        i := 0 ; while i < n do ( (     sum := sum+(arr[i+1]) ; 
     sumSq := sumSq+(arr[i+1]->pow(2)) )  ;     i := i + 1 ) ; 
    var B : int ; B := (((sumSq - sumSqN) / (sum - sumN)) + sumN - sum) / 2 ;
    var A : int ; A := sum - sumN + B ;
    OclFile["System.out"].println("A=" + A + "\nB=" + B) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,2,3,4} ;
     var n : int ; n := arr->size() ;
     execute findNumbers(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class acmp {
  public static void main(String[] args){
    Scanner css=new Scanner(System.in);
    int t=css.nextInt();
    while(t-->0){
      int n=css.nextInt(),k=css.nextInt();
      String str=css.next();
      StringBuilder stringBuilder=new StringBuilder(str);
      if(str.equals(stringBuilder.reverse().toString())|| k==0){
        System.out.println(1);
      }
      else System.out.println(2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class acmp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var css : OclFile ; css := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := css.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := css.getCurrent()->toInteger() ;
    var k : int ; k := css.getCurrent()->toInteger() ;
     var str : String ; str := css.getCurrent() ;
     var stringBuilder : String ; stringBuilder := StringLib.newString(str) ;
     if (str = stringBuilder->reverse()+"" or k = 0) then (     OclFile["System.out"].println(1) ) else     OclFile["System.out"].println(2) ; ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class ReverseAndConcatenate {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine().split(" ")[0]);
    PrintWriter pr=new PrintWriter(System.out);
    while(t>0){
      t--;
      String[] ints=br.readLine().split(" ");
      int n=Integer.parseInt(ints[0]);
      int k=Integer.parseInt(ints[1]);
      String s=br.readLine();
      boolean isPalindrome=true ;
      for(int i=0 ; i<n/2 ; i++){
        if(s.charAt(i)!=s.charAt(n-i-1)){
          isPalindrome=false ;
          break ;
        }
      }
      if(isPalindrome){
        pr.println(1);
      }
      else {
        if(k>0)pr.println(2);
        else pr.println(1);
      }
    }
    pr.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ReverseAndConcatenate {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine()->split(" ")[0+1])->toInteger() ;
    var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    while (t > 0) do (     t := t - 1 ; 
     var ints : Sequence(String) ; ints := br.readLine()->split(" ") ;
    var n : int ; n := (ints[0+1])->toInteger() ;
    var k : int ; k := (ints[1+1])->toInteger() ;
    var s : String ; s := br.readLine() ;
    var isPalindrome : boolean ; isPalindrome := true ;
        var i : int ; i := 0 ; while i < n / 2 do ( (     if (s->at(i+1) /= s->at(n - i - 1+1)) then (     isPalindrome := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (isPalindrome) then (     skip ) else (     if (k > 0) then     skip ; else     skip ; ) ;  
 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p113 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p113().run());
  }
  private static final int DIGITS=100 ;
  public String run(){
    BigInteger increasing=Library.binomial(DIGITS+9,9).subtract(BigInteger.ONE);
    BigInteger decreasing=Library.binomial(DIGITS+10,10).subtract(BigInteger.valueOf(DIGITS+1));
    BigInteger flat=BigInteger.valueOf(DIGITS*9);
    return increasing.add(decreasing).subtract(flat).toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class p113 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p113.newp113().run()) );
  static    attribute DIGITS : int := 100;
   operation run() : String
  pre: true
  post: true
  activity: (     var increasing : long ; increasing := Library.binomial(DIGITS + 9, 9).subtract(1) ;
     var decreasing : long ; decreasing := Library.binomial(DIGITS + 10, 10).subtract((DIGITS + 1 + "")->toLong()) ;
     var flat : long ; flat := (DIGITS * 9 + "")->toLong() ;
     return increasing->excludes(decreasing).subtract(flat)+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long x=sc.nextLong();
    Deque<Long>que=new ArrayDeque<Long>();
    long count=0 ;
    for(long i=1 ; i<10 ; i++){
      que.add(i);
    }
    long temp ;
    while(true){
      temp=que.pop();
      count++;
      if(count==x){
        System.out.println(temp);
        return ;
      }
      if(temp % 10!=0){
        que.add(10*temp+temp % 10-1);
      }
      que.add(10*temp+temp % 10);
      if(temp % 10!=9){
        que.add(10*temp+temp % 10+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := sc.getCurrent()->toLong() ;
    var que : Sequence(long) ; que := ArrayDeque<long>.newArrayDeque() ;
    var count : long ; count := 0 ;
        var i : long ; i := 1 ; while i < 10 do ( (     que := que->including(i) )  ;     i := i + 1 ) ; 
    var temp : long ;
    while (true) do (     temp := que->last() ;     que := que->front() ; 
     count := count + 1 ; 
    if (count = x) then (     OclFile["System.out"].println(temp) ; 
     return ) else skip ; 
    if (temp mod 10 /= 0) then (     que := que->including(10 * temp + temp mod 10 - 1) ) else skip ; 
    que := que->including(10 * temp + temp mod 10) ; 
    if (temp mod 10 /= 9) then (     que := que->including(10 * temp + temp mod 10 + 1) ) else skip ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxSum(int arr1[],int arr2[],int n){
    int initialParity=0,finalParity=0 ;
    int sum=0,minPositive=Integer.MAX_VALUE,maxNegative=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      initialParity+=arr2[i];
      if(arr1[i]>=0){
        finalParity+=1 ;
        sum+=arr1[i];
        minPositive=Math.min(minPositive,arr1[i]);
      }
      else {
        maxNegative=Math.max(maxNegative,arr1[i]);
      }
    }
    if(initialParity % 2==finalParity % 2){
      return sum ;
    }
    else {
      if(minPositive+maxNegative>=0){
        return sum+maxNegative ;
      }
      else {
        return sum-minPositive ;
      }
    }
  }
  public static void main(String[] args){
    int arr1[]={
      2,-4,5,3 };
      int arr2[]={
        0,1,0,1 };
        int n=arr1.length ;
        System.out.println(maxSum(arr1,arr2,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxSum( arr1 : Sequence(int), arr2 : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var initialParity : int ; initialParity := 0 ;
    var finalParity : int ; finalParity := 0 ;
     var sum : int ; sum := 0 ;
    var minPositive : int ; minPositive := 2147483647 ;
    var maxNegative : int ; maxNegative := -2147483648 ;
         var i : int ; i := 0 ; while i < n do ( (     initialParity := initialParity+(arr2[i+1]) ; 
     if (arr1[i+1] >= 0) then (     finalParity := finalParity+(1) ; 
     sum := sum+(arr1[i+1]) ; 
     minPositive := Set{minPositive, arr1[i+1]}->min() ) else (     maxNegative := Set{maxNegative, arr1[i+1]}->max() ) )  ;     i := i + 1 ) ; 
     if (initialParity mod 2 = finalParity mod 2) then (     return sum ) else (     if (minPositive + maxNegative >= 0) then (     return sum + maxNegative ) else (     return sum - minPositive ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{2,-4,5,3} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{0,1,0,1} ;
     var n : int ; n := arr1->size() ;
     OclFile["System.out"].println(maxSum(arr1, arr2, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Colorful_Field {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int k=sc.nextInt();
    int l=sc.nextInt();
    pair[] arr=new pair[k];
    for(int i=0 ; i<k ; i++){
      arr[i]=new pair(sc.nextInt()-1,sc.nextInt()-1);
    }
    Arrays.sort(arr);
    o : for(int i=0 ;
    i<l ;
    i++){
      int x=sc.nextInt()-1 ;
      int y=sc.nextInt()-1 ;
      int res=x*m+y ;
      for(int j=0 ; j<arr.length ; j++){
        if(arr[j] .x<x ||(arr[j] .x==x && arr[j] .y<y))res--;
        else if(arr[j] .x==x && arr[j] .y==y){
          System.out.println("Waste");
          continue o ;
        }
        else break ;
      }
      res %=3 ;
      System.out.println(res==0 ? "Carrots" : res==1 ? "Kiwis" : "Grapes");
    }
  }
  static class pair implements Comparable<pair>{
    int x ;
    int y ;
    pair(int a,int b){
      x=a ;
      y=b ;
    }
    public int compareTo(pair o){
      if(this.x!=o.x)return this.x-o.x ;
      else return this.y-o.y ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Colorful_Field {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var arr : Sequence(pair) ; arr := Integer.subrange(1,k)->collect(null) ;
        var i : int ; i := 0 ; while i < k do ( (     arr[i+1] := pair.newpair(sc.getCurrent()->toInteger() - 1, sc.getCurrent()->toInteger() - 1) )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < l do ( (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
     var y : int ; y := sc.getCurrent()->toInteger() - 1 ;
    var res : int ; res := x * m + y ;
        var j : int ; j := 0 ; while j < arr->size() do ( (     if (arr[j+1].x < x or (arr[j+1].x = x & arr[j+1].y < y)) then     res := res - 1 ; else     if (arr[j+1].x = x & arr[j+1].y = y) then (     OclFile["System.out"].println("Waste") ; 
     continue ) else     break ;  )  ;     j := j + 1 ) ; 
    res := res mod 3 ; 
    OclFile["System.out"].println(if res = 0 then "Carrots" else if res = 1 then "Kiwis" else "Grapes" endif endif) ; 
 )  ;     i := i + 1 ) ; 
 );
  static class pair implements Comparable<pair> {
   attribute x : int;
   attribute y : int;
   static operation newpair( a : int, b : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     x := a ; 
     y := b );
   operation compareTo( o : pair) : int
  pre: true
  post: true
  activity: (     if (self.x /= o.x) then     return self.x - o.x else     return self.y - o.y );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GFG {
  public static int findNth(int n){
    int count=0 ;
    for(int curr=19 ; ; curr+=9){
      int sum=0 ;
      for(int x=curr ; x>0 ; x=x/10)sum=sum+x % 10 ;
      if(sum==10)count++;
      if(count==n)return curr ;
    }
  }
  public static void main(String[] args){
    System.out.print(findNth(5));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNth( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var curr : int ; curr := 19 ; while true do ( (     var sum : int ; sum := 0 ;
         var x : int ; x := curr ; while x > 0 do (     sum := sum + x mod 10 ;  ;     x := x / 10 ) ; 
     if (sum = 10) then     count := count + 1 ; else skip ; 
     if (count = n) then     return curr else skip )  ;     curr := curr+(9) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(findNth(5)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String p[]={
      "101","000000","000011","10010001","010001","000001","100101","10011010","0101","0001","110","01001","10011011","010000","0111","10011000","0110","00100","10011001","10011110","00101","111","10011111","1000","00110","00111","10011100","10011101","000010","10010010","10010011","10010000" };
      String c=" ',-.?ABCDEFGHIJKLMNOPQRSTUVWXYZ" ;
      String q[]={
        "11010","11110","11100","11101","11011","11111","00000","00001","00010","00011","00100","00101","00110","00111","01000","01001","01010","01011","01100","01101","01110","01111","10000","10001","10010","10011","10100","10101","10110","10111","11000","11001" };
        while(sc.hasNext()){
          String result="" ;
          char[] s=sc.nextLine().toCharArray();
          for(char t1 : s){
            for(int i=0 ; i<c.length(); i++){
              if(t1==c.charAt(i)){
                result+=p[i];
              }
            }
          }
          for(int i=0 ; i<result.length()% 5 ; i++){
            result+="0" ;
          }
          String result2="" ;
          for(int i=0 ; i<result.length(); i+=5){
            for(int j=0 ; j<q.length ; j++){
              if(result.substring(i,i+5).equals(q[j])){
                result2+=c.charAt(j);
              }
            }
          }
          System.out.println(result2);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : Sequence(String) ; p := Sequence{"101","000000","000011","10010001","010001","000001","100101","10011010","0101","0001","110","01001","10011011","010000","0111","10011000","0110","00100","10011001","10011110","00101","111","10011111","1000","00110","00111","10011100","10011101","000010","10010010","10010011","10010000"} ;
    var c : String ; c := " ',-.?ABCDEFGHIJKLMNOPQRSTUVWXYZ" ;
    var q : Sequence(String) ; q := Sequence{"11010","11110","11100","11101","11011","11111","00000","00001","00010","00011","00100","00101","00110","00111","01000","01001","01010","01011","01100","01101","01110","01111","10000","10001","10010","10011","10100","10101","10110","10111","11000","11001"} ;
    while (sc.hasNext()) do (     var result : String ; result := "" ;
     var s : Sequence(String) ; s := sc.nextLine()->characters() ;
    for (t1 : s) do ( (         var i : int ; i := 0 ; while i < c->size() do ( (     if (t1 = c->at(i+1)) then (     result := result+(p[i+1]) ) else skip )  ;     i := i + 1 ) )  ) ; 
        var i : int ; i := 0 ; while i < result->size() mod 5 do ( (     result := result+("0") )  ;     i := i + 1 ) ; 
    var result2 : String ; result2 := "" ;
        var i : int ; i := 0 ; while i < result->size() do ( (         var j : int ; j := 0 ; while j < q->size() do ( (     if (result.subrange(i+1,i + 5) = q[j+1]) then (     result2 := result2+(c->at(j+1)) ) else skip )  ;     j := j + 1 ) )  ;     i := i+(5) ) ; 
    OclFile["System.out"].println(result2) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF_1447A_AddCandies {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int count=scanner.nextInt();
    for(int i=0 ; i<count ; i++){
      int n=scanner.nextInt();
      System.out.println(n-1);
      for(int j=2 ; j<=n ; j++){
        System.out.print(j);
        if(j<n){
          System.out.print(" ");
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF_1447A_AddCandies {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < count do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(n - 1) ; 
         var j : int ; j := 2 ; while j <= n do ( (     OclFile["System.out"].print(j) ; 
     if (j < n) then (     OclFile["System.out"].print(" ") ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class DL {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t>0){
      int n=s.nextInt();
      System.out.println(n);
      for(int i=0 ; i<n ; i++){
        System.out.print(i+1+" ");
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DL {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := s.getCurrent()->toInteger() ;
     OclFile["System.out"].println(n) ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(i + 1 + " ") )  ;     i := i + 1 ) ; 
     t := t - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
class Ward implements Comparable<Ward>{
  public String s ;
  public int cnt=1 ;
  Ward(String s){
    this.s=s ;
  }
  public int compareTo(Ward w){
    int ret ;
    ret=w.cnt-this.cnt ;
    if(ret==0){
      ret=this.s.compareTo(w.s);
    }
    return ret ;
  }
  public boolean equals(Object obj){
    Ward w=(Ward)obj ;
    return this.s.equals(w.s);
  }
}
public class Main {
  public static void main(String[] args){
    final int END=0 ;
    ArrayList<Ward>in=new ArrayList<Ward>();
    Ward wrd ;
    int n,idx,max ;
    String ward,k ;
    String[] s ;
    Scanner sc=new Scanner(System.in);
    while(true){
      n=Integer.parseInt(sc.nextLine());
      if(n==END){
        break ;
      }
      in.clear();
      while(n-->0){
        s=sc.nextLine().split("\\s");
        for(int i=0 ; i<s.length ; i++){
          wrd=new Ward(s[i]);
          if((idx=in.indexOf(wrd))!=-1){
            in.get(idx).cnt++;
          }
          else {
            in.add(wrd);
          }
        }
      }
      k=sc.nextLine();
      Collections.sort(in);
      max=0 ;
      for(int i=0 ; i<in.size()&& max<5 ; i++){
        ward=in.get(i).s ;
        if(ward.startsWith(k)){
          if(max>0){
            System.out.print(" ");
          }
          System.out.print(ward);
          max++;
        }
      }
      if(max==0){
        System.out.print("NA");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ward implements Comparable<Ward> {
   attribute s : String;
   attribute cnt : int := 1;
   static operation newWard( s : String) : Ward
  pre: true
  post: true
  activity:
  ( var self : Ward ;
    self := createWard();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     self.s := s );
   operation compareTo( w : Ward) : int
  pre: true
  post: true
  activity: (     var ret : int ;
     ret := w.cnt - self.cnt ; 
     if (ret = 0) then (     ret := self.s->compareTo(w.s) ) else skip ; 
     return ret );
   operation equals( obj : OclAny) : boolean
  pre: true
  post: true
  activity: (     var w : Ward ; w := obj->oclAsType(Ward) ;
     return self.s = w.s );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var END : int ; END := 0 ;
     var in : Sequence(Ward) ; in := Sequence{} ;
    var wrd : Ward ;
    var n : int ;
    var idx : int ;
    var max : int ;
    var ward : String ;
    var k : String ;
    var s : Sequence(String) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (true) do (     n := (sc.nextLine())->toInteger() ; 
     if (n = END) then (     break ) else skip ; 
    in := in->intersection(Set{}) ; 
        while (n > 0) do (        n := n - 1 ;     skip ; (     s := sc.nextLine()->split("\\s") ; 
         var i : int ; i := 0 ; while i < s->size() do ( (     wrd := Ward.newWard(s[i+1]) ; 
     if ((idx) /= -1) then (     in->at(idx+1).cnt := in->at(idx+1).cnt + 1 ) else (     in := in->including(wrd) ) )  ;     i := i + 1 ) ) ;  ) ;  
    k := sc.nextLine() ; 
    in := in->sort() ; 
    max := 0 ; 
        var i : int ; i := 0 ; while i < in->size() & max < 5 do ( (     ward := in->at(i+1).s ; 
     if (ward->hasPrefix(k)) then (     if (max > 0) then (     OclFile["System.out"].print(" ") ) else skip ; 
     OclFile["System.out"].print(ward) ; 
     max := max + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (max = 0) then (     OclFile["System.out"].print("NA") ) else skip ; 
    OclFile["System.out"].println() ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      int n=sc.nextInt();
      sc.nextLine();
      if(n==0)break ;
      Map<String,Integer>count=new HashMap<String,Integer>();
      for(int i=0 ; i<n ; i++){
        String[] words=sc.nextLine().split(" ");
        for(String w : words){
          Integer k=count.get(w);
          if(k==null){
            k=0 ;
          }
          k++;
          count.put(w,k);
        }
      }
      char c=sc.next().charAt(0);
      ArrayList<P>ps=new ArrayList<P>();
      for(String w : count.keySet()){
        if(w.charAt(0)==c){
          P p=new P();
          p.w=w ;
          p.count=count.get(w);
          ps.add(p);
        }
      }
      Collections.sort(ps);
      if(ps.size()==0){
        System.out.println("NA");
      }
      else {
        System.out.print(ps.get(0).w);
        for(int i=1 ; i<Math.min(ps.size(),5); i++){
          System.out.print(" "+ps.get(i).w);
        }
        System.out.println();
      }
    }
  }
  class P implements Comparable<P>{
    int count ;
    String w ;
    @ Override public int compareTo(P o){
      if(count!=o.count)return-count+o.count ;
      return w.compareTo(o.w);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     skip ; 
    if (n = 0) then     break else skip ; 
    var count : Map(String,int) ; count := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var words : Sequence(String) ; words := sc.nextLine()->split(" ") ;
     for (w : words) do ( (     var k : int ; k := count->at(w) ;
     if (k = null) then (     k := 0 ) else skip ; 
     k := k + 1 ; 
     count := count->union(Map{w |-> k}) )  ) )  ;     i := i + 1 ) ; 
    var c : String ; c := sc.getCurrent()->at(0+1) ;
    var ps : Sequence(P) ; ps := Sequence{} ;
    for (w : count->keys()) do ( (     if (w->at(0+1) = c) then (     var p : P ; p := P.newP() ;
     p.w := w ; 
     p.count := count->at(w) ; 
     ps := ps->including(p) ) else skip )  ) ; 
    ps := ps->sort() ; 
    if (ps->size() = 0) then (     OclFile["System.out"].println("NA") ) else (     OclFile["System.out"].print(ps->at(0+1).w) ; 
         var i : int ; i := 1 ; while i < Set{ps->size(), 5}->min() do ( (     OclFile["System.out"].print(" " + ps->at(i+1).w) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ;  
 )  ) );
 class P implements Comparable<P> {
   attribute count : int;
   attribute w : String;
      operation compareTo( o : P) : int
  pre: true
  post: true
  activity: (     if (count /= o.count) then     return -count + o.count else skip ; 
     return w->compareTo(o.w) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int a ;
    while(true){
      a=s.nextInt();
      if(a==0)System.exit(0);
      s.nextLine();
      String c="" ;
      HashMap<String,Integer>map=new HashMap<String,Integer>();
      String wolf[]=new String[100000];
      int ind=0 ;
      int m=1 ;
      for(int i=0 ; i<a ; i++){
        String b=s.nextLine();
        String[] d=b.split(" ");
        for(int j=0 ; j<d.length ; j++){
          if(map.containsKey(d[j])){
            map.put(d[j],map.get(d[j])+1);
            m=Math.max(m,map.get(d[j]));
          }
          else {
            map.put(d[j],1);
            wolf[ind++]=d[j];
          }
        }
      }
      Arrays.sort(wolf,0,ind);
      String p=s.next();
      int count=0 ;
      for(int i=m ; i>0 ; i--){
        if(count==5)break ;
        for(int j=0 ; j<ind ; j++){
          if(count==5)break ;
          if(p.charAt(0)==wolf[j] .charAt(0)&& map.get(wolf[j])==i){
            if(count>0)System.out.print(" ");
            System.out.print(wolf[j]);
            count++;
          }
        }
      }
      if(count==0)System.out.println("NA");
      else System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ;
     while (true) do (     a := s.getCurrent()->toInteger() ; 
     if (a = 0) then OclProcess.exit(0) ; else skip ; 
    skip ; 
    var c : String ; c := "" ;
    var map : Map(String,int) ; map := Map{} ;
    var wolf : Sequence(String) ; wolf := Integer.subrange(1,100000)->collect(null) ;
    var ind : int ; ind := 0 ;
    var m : int ; m := 1 ;
        var i : int ; i := 0 ; while i < a do ( (     var b : String ; b := s.nextLine() ;
     var d : Sequence(String) ; d := b->split(" ") ;
         var j : int ; j := 0 ; while j < d->size() do ( (     if (map->keys()->includes(d[j+1])) then (     map := map->union(Map{d[j+1] |-> map->at(d[j+1]) + 1}) ; 
     m := Set{m, map->at(d[j+1])}->max() ) else (     map := map->union(Map{d[j+1] |-> 1}) ; 
      wolf[ind+1] := d[j+1]  ; ind := ind + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    wolf := wolf.subrange(1,0)^(wolf.subrange(0+1,ind)->sort())^wolf.subrange(ind+1,wolf.size) ; 
    var p : String ; p := s.getCurrent() ;
    var count : int ; count := 0 ;
        var i : int ; i := m ; while i > 0 do ( (     if (count = 5) then     break else skip ; 
         var j : int ; j := 0 ; while j < ind do ( (     if (count = 5) then     break else skip ; 
     if (p->at(0+1) = wolf[j+1]->at(0+1) & map->at(wolf[j+1]) = i) then (     if (count > 0) then     OclFile["System.out"].print(" ") ; else skip ; 
     OclFile["System.out"].print(wolf[j+1]) ; 
     count := count + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    if (count = 0) then     OclFile["System.out"].println("NA") else     OclFile["System.out"].println() ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static Boolean divisibleBy20(String num){
    int lastTwoDigits=Integer.parseInt(num.substring(num.length()-2,num.length()));
    return((lastTwoDigits % 5==0)&&(lastTwoDigits % 4==0));
  }
  public static void main(String[] args){
    String num="63284689320" ;
    if(divisibleBy20(num)==true)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation divisibleBy20( num : String) : Boolean
  pre: true
  post: true
  activity: (     var lastTwoDigits : int ; lastTwoDigits := (num.subrange(num->size() - 2+1,num->size()))->toInteger() ;
     return ((lastTwoDigits mod 5 = 0) & (lastTwoDigits mod 4 = 0)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : String ; num := "63284689320" ;
     if (divisibleBy20(num) = true) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  static int countNumbers(int X,int Y,int N){
    int divisibleByX=N/X ;
    int divisibleByY=N/Y ;
    int LCM=(X*Y)/gcd(X,Y);
    int divisibleByLCM=N/LCM ;
    int divisibleByXorY=divisibleByX+divisibleByY-divisibleByLCM ;
    int divisibleByXnotY=divisibleByXorY-divisibleByY ;
    return divisibleByXnotY ;
  }
  public static void main(String[] args){
    int X=2,Y=3,N=10 ;
    System.out.println(countNumbers(X,Y,N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation countNumbers( X : int, Y : int, N : int) : int
  pre: true
  post: true
  activity: (     var divisibleByX : int ; divisibleByX := N / X ;
     var divisibleByY : int ; divisibleByY := N / Y ;
    var LCM : int ; LCM := (X * Y) / gcd(X, Y) ;
    var divisibleByLCM : int ; divisibleByLCM := N / LCM ;
    var divisibleByXorY : int ; divisibleByXorY := divisibleByX + divisibleByY - divisibleByLCM ;
    var divisibleByXnotY : int ; divisibleByXnotY := divisibleByXorY - divisibleByY ;
    return divisibleByXnotY 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 2 ;
    var Y : int ; Y := 3 ;
    var N : int ; N := 10 ;
     OclFile["System.out"].println(countNumbers(X, Y, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GFG {
  public static int findNth(int n){
    int count=0 ;
    for(int curr=1 ; ; curr++){
      int sum=0 ;
      for(int x=curr ; x>0 ; x=x/10)sum=sum+x % 10 ;
      if(sum==10)count++;
      if(count==n)return curr ;
    }
  }
  public static void main(String[] args){
    System.out.print(findNth(5));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNth( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var curr : int ; curr := 1 ; while true do ( (     var sum : int ; sum := 0 ;
         var x : int ; x := curr ; while x > 0 do (     sum := sum + x mod 10 ;  ;     x := x / 10 ) ; 
     if (sum = 10) then     count := count + 1 ; else skip ; 
     if (count = n) then     return curr else skip )  ;     curr := curr + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(findNth(5)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      while(true){
        int n=sc.nextInt(),s=sc.nextInt();
        if(n==0 && s==0)break ;
        System.out.println(dfs(0,0,s,n));
      }
    }
  }
  public static int dfs(int total,int addv,int target,int n){
    if(n==0)return total==target ? 1 : 0 ;
    else if(addv>9)return 0 ;
    else return dfs(total+addv,addv+1,target,n-1)+dfs(total,addv+1,target,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
     if (n = 0 & s = 0) then     break else skip ; 
     OclFile["System.out"].println(dfs(0, 0, s, n)) ) ))  );
  static   operation dfs( total : int, addv : int, target : int, n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return if total = target then 1 else 0 endif else     if (addv > 9) then     return 0 else     return dfs(total + addv, addv + 1, target, n - 1) + dfs(total, addv + 1, target, n) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
final class Main {
  private Main(){
  }
  public static void main(final String[] argv)throws IOException {
    final BufferedReader inputReader=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String input=inputReader.readLine();
      if(input==null || input.equals("0 0")){
        break ;
      }
      String[] inputs=input.split(" ");
      int n=Integer.parseInt(inputs[0]);
      int s=Integer.parseInt(inputs[1]);
      System.out.println(solv(n,s));
    }
  }
  private static int solv(final int n,final int s){
    return solv(n,s,0);
  }
  private static int solv(final int n,final int s,final int min){
    if(n==0){
      return s==0 ? 1 : 0 ;
    }
    int count=0 ;
    for(int i=min ; i<10 && i<=s ; i++){
      count+=solv(n-1,s-i,i+1);
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
  static   operation main( argv : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputReader : OclFile ; inputReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var input : String ; input := inputReader.readLine() ;
     if (input = null or input = "0 0") then (     break ) else skip ; 
    var inputs : Sequence(String) ; inputs := input->split(" ") ;
    var n : int ; n := (inputs[0+1])->toInteger() ;
    var s : int ; s := (inputs[1+1])->toInteger() ;
    OclFile["System.out"].println(solv(n, s)) ; 
 ) );
  static   operation solv( n : int, s : int) : int
  pre: true
  post: true
  activity: (     return solv(n, s, 0) );
  static   operation solv( n : int, s : int, min : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then (     return if s = 0 then 1 else 0 endif ) else skip ; 
     var count : int ; count := 0 ;
         var i : int ; i := min ; while i < 10 & i <= s do ( (     count := count+(solv(n - 1, s - i, i + 1)) )  ;     i := i + 1 ) ; 
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,s ;
    for(; ; ){
      n=sc.nextInt();
      s=sc.nextInt();
      if(n==0 && s==0)break ;
      else if(s>45)out.println(0);
      else out.println(solve(n,s,9));
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
  private static int solve(int n,int s,int r){
    if(n==0 && s==0)return 1 ;
    else if(n==0 || s<0 || r==-1)return 0 ;
    else return solve(n,s,r-1)+solve(n-1,s-r,r-1);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var s : int ;
       while true do ( (     n := sc.nextInt() ; 
     s := sc.nextInt() ; 
     if (n = 0 & s = 0) then     break else     if (s > 45) then     out.println(0) else     out.println(solve(n, s, 9)) ; ;  )  ) ; 
     sc.close() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
  static   operation solve( n : int, s : int, r : int) : int
  pre: true
  post: true
  activity: (     if (n = 0 & s = 0) then     return 1 else     if (n = 0 or s < 0 or r = -1) then     return 0 else     return solve(n, s, r - 1) + solve(n - 1, s - r, r - 1) ;  );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String buf ;
    try {
      while("0 0".equals(buf=br.readLine())==false){
        StringTokenizer st=new StringTokenizer(buf);
        int n=Integer.parseInt(st.nextToken());
        int s=Integer.parseInt(st.nextToken());
        System.out.println(solve(n,s,0));
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  public static int solve(int n,int s,int r){
    if(n==0){
      if(s==0)return 1 ;
      else return 0 ;
    }
    else {
      int count=0 ;
      for(int i=r ; i<=9 ; i++){
        count+=solve(n-1,s-i,i+1);
      }
      return count ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var buf : String ;
     try (     while ("0 0" = buf = false) do (     var st : OclIterator ; st := OclIterator.newOclIterator_String(buf) ;
     var n : int ; n := (st.next())->toInteger() ;
     var s : int ; s := (st.next())->toInteger() ;
     OclFile["System.out"].println(solve(n, s, 0)) ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
  static   operation solve( n : int, s : int, r : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then (     if (s = 0) then     return 1 else     return 0 ) else (     var count : int ; count := 0 ;
         var i : int ; i := r ; while i <= 9 do ( (     count := count+(solve(n - 1, s - i, i + 1)) )  ;     i := i + 1 ) ; 
     return count ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int M[][];
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=Integer.parseInt(in.next());
    M=new int[n][n];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++)M[i][j]=Integer.parseInt(in.next());
    }
    int INF=2000000001,d[]=new int[n],p[]=new int[n];
    char color[]=new char[n];
    for(int i=0 ; i<n ; i++){
      color[i]='W' ;
      d[i]=INF ;
    }
    d[0]=0 ;
    p[0]=-1 ;
    while(true){
      int mincost=INF,u=-1 ;
      for(int i=0 ; i<n ; i++){
        if(color[i]!='B' && d[i]<mincost){
          mincost=d[i];
          u=i ;
        }
      }
      if(u==-1)break ;
      color[u]='B' ;
      for(int v=0 ; v<n ; v++){
        if(color[v]!='B' && M[u][v]!=-1){
          if(M[u][v]<d[v]){
            d[v]=M[u][v];
            color[v]='G' ;
          }
        }
      }
    }
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(d[i]!=-1)sum+=d[i];
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute M : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (in.getCurrent())->toInteger() ;
    M := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do (     M[i+1][j+1] := (in.getCurrent())->toInteger() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var INF : int ; INF := 2000000001 ;
    var d : Sequence(void) ; d := Integer.subrange(1,n)->collect(0) ;
    var p : Sequence(void) ; p := Integer.subrange(1,n)->collect(0) ;
    var color : Sequence(String) ; color := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     color[i+1] := 'W' ; 
     d[i+1] := INF )  ;     i := i + 1 ) ; 
    d[0+1] := 0 ; 
    p[0+1] := -1 ; 
    while (true) do (     var mincost : int ; mincost := INF ;
    var u : int ; u := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (color[i+1] /= 'B' & d[i+1] < mincost) then (     mincost := d[i+1] ; 
     u := i ) else skip )  ;     i := i + 1 ) ; 
    if (u = -1) then     break else skip ; 
    color[u+1] := 'B' ; 
        var v : int ; v := 0 ; while v < n do ( (     if (color[v+1] /= 'B' & M[u+1][v+1] /= -1) then (     if (M[u+1][v+1] < d[v+1]) then (     d[v+1] := M[u+1][v+1] ; 
     color[v+1] := 'G' ) else skip ) else skip )  ;     v := v + 1 ) ; 
 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (d[i+1] /= -1) then     sum := sum+(d[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.PriorityQueue ;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    ArrayList<ArrayList<Edge>>edges=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      String str[]=br.readLine().split(" ");
      edges.add(new ArrayList<>());
      for(int j=0 ; j<n ; j++){
        int a=Integer.parseInt(str[j+1]);
        if(a==-1)a=Integer.MAX_VALUE ;
        edges.get(i).add(new Edge(j,a));
      }
    }
    int ans=prime(edges,n);
    System.out.println(ans);
  }
  static int prime(ArrayList<ArrayList<Edge>>edges,int n){
    PriorityQueue<Edge>pq=new PriorityQueue<>();
    boolean used[]=new boolean[n];
    int sum=0 ;
    pq.add(new Edge(0,0));
    while(! pq.isEmpty()){
      Edge e=pq.poll();
      if(used[e.to])continue ;
      used[e.to]=true ;
      sum+=e.cost ;
      pq.addAll(edges.get(e.to));
    }
    return sum ;
  }
}
class Edge implements Comparable<Edge>{
  int to ;
  int cost ;
  public Edge(int to,int cost){
    this.to=to ;
    this.cost=cost ;
  }
  @ Override public int compareTo(Edge e){
    return this.cost-e.cost ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var edges : Sequence(Sequence(Edge)) ; edges := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     edges := edges->including(Sequence{}) ; 
         var j : int ; j := 0 ; while j < n do ( (     var a : int ; a := (str[j + 1+1])->toInteger() ;
     if (a = -1) then     a := 2147483647 ; else skip ; 
     edges->at(i+1)->excludes(Edge.newEdge(j, a)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := prime(edges, n) ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation prime( edges : Sequence(Sequence(Edge)), n : int) : int
  pre: true
  post: true
  activity: (     var pq : Sequence(Edge) ; pq := Sequence{} ;
     var used : Sequence(boolean) ; used := Integer.subrange(1,n)->collect(false) ;
    var sum : int ; sum := 0 ;
    pq := pq->including(Edge.newEdge(0, 0)) ; 
    while (not(pq->isEmpty())) do (     var e : Edge ; e := pq->min() ;
     if (used[e.to+1]) then     continue else skip ; 
    used[e.to+1] := true ; 
    sum := sum+(e.cost) ; 
    pq := pq->union(edges->at(e.to+1)) ; 
 ) ; 
    return sum 
 );
}
class Edge implements Comparable<Edge> {
   attribute to : int;
   attribute cost : int;
   static operation newEdge( to : int, cost : int) : Edge
  pre: true
  post: true
  activity:
  ( var self : Edge ;
    self := createEdge();
    self.initialise(to, cost);
    return self );
  operation initialise( to : int, cost : int) : void
  pre: true  post: true
  activity: (     self.to := to ; 
     self.cost := cost );
      operation compareTo( e : Edge) : int
  pre: true
  post: true
  activity: (     return self.cost - e.cost );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int MAX=Integer.MAX_VALUE ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[][] w=new int[n+1][n+1];
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=n ; j++){
        int k=sc.nextInt();
        w[i][j]=k==-1 ? MAX : k ;
      }
    }
    int sumCost=0 ;
    boolean[] used=new boolean[n+1];
    int[] minCostFromTempMST=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      minCostFromTempMST[i]=MAX ;
    }
    minCostFromTempMST[1]=0 ;
    while(true){
      int next=-1 ;
      int minCost=MAX ;
      for(int i=1 ; i<=n ; i++){
        if(! used[i] && minCostFromTempMST[i]<minCost){
          next=i ;
          minCost=minCostFromTempMST[i];
        }
      }
      if(next==-1)break ;
      used[next]=true ;
      sumCost+=minCostFromTempMST[next];
      for(int i=1 ; i<=n ; i++){
        if(! used[i] && w[next][i]!=MAX){
          minCostFromTempMST[i]=Math.min(minCostFromTempMST[i],w[next][i]);
        }
      }
    }
    System.out.println(sumCost);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 2147483647;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var w : Sequence(Sequence(int)) ; w := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     var k : int ; k := sc.getCurrent()->toInteger() ;
     w[i+1][j+1] := if k = -1 then MAX else k endif )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sumCost : int ; sumCost := 0 ;
    var used : Sequence(boolean) ; used := Integer.subrange(1,n + 1)->collect(false) ;
    var minCostFromTempMST : Sequence(int) ; minCostFromTempMST := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     minCostFromTempMST[i+1] := MAX )  ;     i := i + 1 ) ; 
    minCostFromTempMST[1+1] := 0 ; 
    while (true) do (     var next : int ; next := -1 ;
     var minCost : int ; minCost := MAX ;
        var i : int ; i := 1 ; while i <= n do ( (     if (not(used[i+1]) & minCostFromTempMST[i+1] < minCost) then (     next := i ; 
     minCost := minCostFromTempMST[i+1] ) else skip )  ;     i := i + 1 ) ; 
    if (next = -1) then     break else skip ; 
    used[next+1] := true ; 
    sumCost := sumCost+(minCostFromTempMST[next+1]) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (not(used[i+1]) & w[next+1][i+1] /= MAX) then (     minCostFromTempMST[i+1] := Set{minCostFromTempMST[i+1], w[next+1][i+1]}->min() ) else skip )  ;     i := i + 1 ) ; 
 ) ; 
    OclFile["System.out"].println(sumCost) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.test();
  }
  int n ;
  private void test(){
    Scanner input=new Scanner(System.in);
    n=input.nextInt();
    int[][] us=new int[n+1][n+1];
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=n ; j++){
        int v=input.nextInt();
        us[i][j]=v==-1 ? Integer.MAX_VALUE : v ;
      }
      us[i][i]=0 ;
    }
    int[] f=new int[n+1];
    f[1]=1 ;
    int t=calc(us,f);
    System.out.println(t);
  }
  int calc(int[][] us,int[] f){
    int a=0 ;
    int v=Integer.MAX_VALUE ;
    for(int i=1 ; i<=n ; i++){
      if(f[i]==1){
        for(int j=1 ; j<=n ; j++){
          if(i!=j && f[j]!=1 && us[i][j]<v){
            a=j ;
            v=us[i][j];
          }
        }
      }
    }
    f[a]=1 ;
    if(f[0]==1)return 0 ;
    return v+calc(us,f);
  }
}
class Scanner {
  BufferedReader r ;
  StreamTokenizer st ;
  public Scanner(InputStream in){
    r=new BufferedReader(new InputStreamReader(in));
    st=new StreamTokenizer(r);
  }
  public String next(){
    nextToken();
    return st.sval ;
  }
  public Integer nextInt(){
    nextToken();
    return(int)st.nval ;
  }
  private int nextToken(){
    int token=st.TT_EOF ;
    try {
      token=st.nextToken();
    }
    catch(IOException e){
    }
    return token ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.test() );
   attribute n : int;
   operation test() : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := input.getCurrent()->toInteger() ; 
    var us : Sequence(Sequence(int)) ; us := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     var v : int ; v := input.getCurrent()->toInteger() ;
     us[i+1][j+1] := if v = -1 then 2147483647 else v endif )  ;     j := j + 1 ) ; 
     us[i+1][i+1] := 0 )  ;     i := i + 1 ) ; 
    var f : Sequence(int) ; f := Integer.subrange(1,n + 1)->collect(0) ;
    f[1+1] := 1 ; 
    var t : int ; t := calc(us, f) ;
    OclFile["System.out"].println(t) ; 
 );
   operation calc( us : Sequence(Sequence(int)), f : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var a : int ; a := 0 ;
     var v : int ; v := 2147483647 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (f[i+1] = 1) then (         var j : int ; j := 1 ; while j <= n do ( (     if (i /= j & f[j+1] /= 1 & us[i+1][j+1] < v) then (     a := j ; 
     v := us[i+1][j+1] ) else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    f[a+1] := 1 ; 
    if (f[0+1] = 1) then     return 0 else skip ; 
    return v + calc(us, f) 
 );
}
class Scanner {
   attribute r : OclFile;
   attribute st : StreamTokenizer;
   static operation newScanner( in : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     st := StreamTokenizer.newStreamTokenizer(r) );
   operation next() : String
  pre: true
  post: true
  activity: (     execute nextToken() ; 
     return st.sval );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     execute nextToken() ; 
     return st.nval->oclAsType(int) );
   operation nextToken() : int
  pre: true
  post: true
  activity: (     var token : int ; token := st.TT_EOF ;
     try (     token := st.next() )   catch (e : IOException) do skip
     return token );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int t=scanner.nextInt();
    int s=scanner.nextInt();
    int[] a=new int[n];
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scanner.nextInt();
      b[i]=scanner.nextInt();
    }
    int[] dp=new int[t+1];
    int ans=0 ;
    for(int i=0 ; i<n ; i++)for(int j=t ; j-b[i]>=0 ; j--){
      if(j-b[i]>=s || s>=j)dp[j]=Math.max(dp[j],dp[j-b[i] ]+a[i]);
      ans=Math.max(ans,dp[j]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var t : int ; t := scanner.getCurrent()->toInteger() ;
    var s : int ; s := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() ; 
     b[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,t + 1)->collect(0) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := t ; while j - b[i+1] >= 0 do ( (     if (j - b[i+1] >= s or s >= j) then     dp[j+1] := Set{dp[j+1], dp[j - b[i+1]+1] + a[i+1]}->max() ; else skip ; 
     ans := Set{ans, dp[j+1]}->max() )  ;     j := j - 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countNumber(int N,int S){
    int countElements=0 ;
    int currSum=0 ;
    while(currSum<=S){
      currSum+=N ;
      N--;
      countElements++;
    }
    return countElements ;
  }
  public static void main(String[] args){
    int N,S ;
    N=5 ;
    S=11 ;
    int count=countNumber(N,S);
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countNumber( N : int, S : int) : int
  pre: true
  post: true
  activity: (     var countElements : int ; countElements := 0 ;
     var currSum : int ; currSum := 0 ;
     while (currSum <= S) do (     currSum := currSum+(N) ; 
     N := N - 1 ; 
     countElements := countElements + 1 ) ; 
     return countElements );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ;
    var S : int ;
     N := 5 ; 
    S := 11 ; 
    var count : int ; count := countNumber(N, S) ;
    OclFile["System.out"].println(count) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private final static int WHITE=0 ;
  private final static int BLACK=1 ;
  private static int[][] mat ;
  private static int n ;
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    int i,j ;
    n=sc.nextInt();
    mat=new int[n][n];
    for(i=0 ; i<n ; i++){
      for(j=0 ; j<n ; j++){
        mat[i][j]=sc.nextInt();
        if(mat[i][j]==-1)mat[i][j]=Integer.MAX_VALUE ;
      }
    }
    System.out.println(Prim());
  }
  public static int Prim(){
    int sum=0 ;
    int u,min,i,j ;
    int[] d=new int[100];
    int[] p=new int[100];
    int[] color=new int[100];
    for(i=0 ; i<n ; i++){
      d[i]=Integer.MAX_VALUE ;
      p[i]=-1 ;
      color[i]=WHITE ;
    }
    d[0]=0 ;
    while(true){
      min=Integer.MAX_VALUE ;
      u=-1 ;
      for(i=0 ; i<n ; i++){
        if(min>d[i] && color[i]!=BLACK){
          u=i ;
          min=d[i];
        }
      }
      if(u==-1)break ;
      color[u]=BLACK ;
      for(j=0 ; j<n ; j++){
        if(color[j]!=BLACK && mat[u][j]!=Integer.MAX_VALUE){
          if(d[j]>mat[u][j]){
            d[j]=mat[u][j];
            p[j]=u ;
          }
        }
      }
    }
    for(i=0 ; i<n ; i++)if(p[i]!=-1)sum+=mat[i][p[i] ];
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute WHITE : int := 0;
  static   attribute BLACK : int := 1;
  static   attribute mat : Sequence(Sequence(int));
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ;
    var j : int ;
    n := sc.getCurrent()->toInteger() ; 
    mat := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
        i := 0 ; while i < n do ( (         j := 0 ; while j < n do ( (     mat[i+1][j+1] := sc.getCurrent()->toInteger() ; 
     if (mat[i+1][j+1] = -1) then     mat[i+1][j+1] := 2147483647 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Prim()) ; 
 );
  static   operation Prim() : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var u : int ;
    var min : int ;
    var i : int ;
    var j : int ;
    var d : Sequence(int) ; d := Integer.subrange(1,100)->collect(0) ;
    var p : Sequence(int) ; p := Integer.subrange(1,100)->collect(0) ;
    var color : Sequence(int) ; color := Integer.subrange(1,100)->collect(0) ;
        i := 0 ; while i < n do ( (     d[i+1] := 2147483647 ; 
     p[i+1] := -1 ; 
     color[i+1] := WHITE )  ;     i := i + 1 ) ; 
    d[0+1] := 0 ; 
    while (true) do (     min := 2147483647 ; 
     u := -1 ; 
        i := 0 ; while i < n do ( (     if (min > d[i+1] & color[i+1] /= BLACK) then (     u := i ; 
     min := d[i+1] ) else skip )  ;     i := i + 1 ) ; 
    if (u = -1) then     break else skip ; 
    color[u+1] := BLACK ; 
        j := 0 ; while j < n do ( (     if (color[j+1] /= BLACK & mat[u+1][j+1] /= 2147483647) then (     if (d[j+1] > mat[u+1][j+1]) then (     d[j+1] := mat[u+1][j+1] ; 
     p[j+1] := u ) else skip ) else skip )  ;     j := j + 1 ) ; 
 ) ; 
        i := 0 ; while i < n do (     if (p[i+1] /= -1) then     sum := sum+(mat[i+1][p[i+1]+1]) ; else skip ;  ;     i := i + 1 ) ; 
    return sum 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Problem3 {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(new FileReader("Problem3.in"));
    PrintWriter out=new PrintWriter(new BufferedWriter(new FileWriter("Problem3.out")));
    int c=in.nextInt();
    for(int cn=0 ; cn<c ; cn++){
      int n=in.nextInt();
      int m=in.nextInt();
      long x=in.nextInt();
      long y=in.nextInt();
      long z=in.nextInt();
      long sub[]=new long[n];
      BigInteger ans[]=new BigInteger[n];
      long array[]=new long[m];
      for(int i=0 ; i<m ; i++)array[i]=in.nextInt();
      for(int i=0 ; i<n ; i++){
        sub[i]=array[i % m];
        array[i % m]=(x*array[i % m]+y*(i+1))% z ;
      }
      Arrays.fill(ans,BigInteger.ONE);
      for(int i=1 ; i<n ; i++)for(int j=0 ; j<i ; j++){
        if(sub[j]<sub[i])ans[i]=ans[i] .add(ans[j]);
      }
      BigInteger sum=BigInteger.ZERO ;
      for(int i=0 ; i<n ; i++)sum=sum.add(ans[i]);
      sum=sum.remainder(new BigInteger("1000000007"));
      out.write("Case #"+(cn+1)+": "+sum.toString()+"\n");
    }
    in.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("Problem3.in"))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("Problem3.out")))) ;
    var c : int ; c := in.getCurrent()->toInteger() ;
        var cn : int ; cn := 0 ; while cn < c do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var x : long ; x := in.getCurrent()->toInteger() ;
    var y : long ; y := in.getCurrent()->toInteger() ;
    var z : long ; z := in.getCurrent()->toInteger() ;
    var sub : Sequence(long) ; sub := Integer.subrange(1,n)->collect(0) ;
    var ans : Sequence(long) ; ans := Integer.subrange(1,n)->collect(null) ;
    var array : Sequence(long) ; array := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     array[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     sub[i+1] := array[i mod m+1] ; 
     array[i mod m+1] := (x * array[i mod m+1] + y * (i + 1)) mod z )  ;     i := i + 1 ) ; 
    ans := ans->collect(1) ; 
        var i : int ; i := 1 ; while i < n do (         var j : int ; j := 0 ; while j < i do ( (     if (sub[j+1] < sub[i+1]) then     ans[i+1] := ans[i+1]->excludes(ans[j+1]) ; else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (     sum := sum->excludes(ans[i+1]) ;  ;     i := i + 1 ) ; 
    sum := sum.remainder(long("1000000007")) ; 
    skip ; 
 )  ;     cn := cn + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package Andra ;
import java.util.*;
public class CumulativeTable {
  public static final long MOD=1000000007 ;
  private long[] sum ;
  private int[] degreeTwo ;
  private int n ;
  public CumulativeTable(int n){
    this.n=n ;
    this.sum=new long[n+1];
    this.degreeTwo=new int[n+1];
    calculateDegrees();
  }
  private void calculateDegrees(){
    degreeTwo[0]=1 ;
    degreeTwo[1]=1 ;
    for(int i=2 ; i<=n ; i++){
      if((i & 1)==0)degreeTwo[i]=degreeTwo[i>>1]*2 ;
      else degreeTwo[i]=1 ;
    }
  }
  public void reset(){
    for(int i=0 ; i<n ; i++)sum[i]=0 ;
  }
  public void add(int index,long value){
    int i=index ;
    while(i<=n){
      sum[i]=(sum[i]+value)% MOD ;
      i=i+degreeTwo[i];
    }
  }
  public long count(int index){
    int i=index ;
    long toReturn=0 ;
    while(i>=0){
      toReturn=(toReturn+sum[i])% MOD ;
      i=i-degreeTwo[i];
    }
    return toReturn ;
  }
  public static void main(String[] args){
    Random rnd=new Random();
    int n=100 ;
    int[] a=new int[n];
    CumulativeTable ct=new CumulativeTable(n);
    for(int i=0 ; i<n ; i++)a[i]=0 ;
    for(int i=0 ; i<10 ; i++){
      int index=rnd.nextInt(n);
      int value=rnd.nextInt(1000);
      a[index]=a[index]+value ;
      ct.add(index,value);
      int sum=0 ;
      for(int j=0 ; j<=index ; j++)sum+=a[j];
      System.out.println(sum);
      System.out.println(ct.count(index));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CumulativeTable {
  static    attribute MOD : long := 1000000007;
   attribute sum : Sequence(long);
   attribute degreeTwo : Sequence(int);
   attribute n : int;
   static operation newCumulativeTable( n : int) : CumulativeTable
  pre: true
  post: true
  activity:
  ( var self : CumulativeTable ;
    self := createCumulativeTable();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     self.n := n ; 
     self.sum := Integer.subrange(1,n + 1)->collect(0) ; 
     self.degreeTwo := Integer.subrange(1,n + 1)->collect(0) ; 
     execute calculateDegrees() );
   operation calculateDegrees() : void
  pre: true
  post: true
  activity: (     degreeTwo[0+1] := 1 ; 
     degreeTwo[1+1] := 1 ; 
         var i : int ; i := 2 ; while i <= n do ( (     if ((MathLib.bitwiseAnd(i,1)) = 0) then     degreeTwo[i+1] := degreeTwo[(i/(2->pow(1)))->oclAsType(long)+1] * 2 ; else     degreeTwo[i+1] := 1 ; )  ;     i := i + 1 ) );
   operation reset() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     sum[i+1] := 0 ;  ;     i := i + 1 ) );
   operation add( index : int, value : long) : void
  pre: true
  post: true
  activity: (     var i : int ; i := index ;
     while (i <= n) do (     sum[i+1] := (sum[i+1] + value) mod MOD ; 
     i := i + degreeTwo[i+1] ) );
   operation count( index : int) : long
  pre: true
  post: true
  activity: (     var i : int ; i := index ;
     var toReturn : long ; toReturn := 0 ;
     while (i >= 0) do (     toReturn := (toReturn + sum[i+1]) mod MOD ; 
     i := i - degreeTwo[i+1] ) ; 
     return toReturn );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var rnd : OclRandom ; rnd := OclRandom.newOclRandom() ;
     var n : int ; n := 100 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var ct : CumulativeTable ; ct := CumulativeTable.newCumulativeTable(n) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 10 do ( (     var index : int ; index := rnd.nextInt(n) ;
     var value : int ; value := rnd.nextInt(1000) ;
    a[index+1] := a[index+1] + value ; 
    ct->excludes(index, value) ; 
    var sum : int ; sum := 0 ;
        var j : int ; j := 0 ; while j <= index do (     sum := sum+(a[j+1]) ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
    OclFile["System.out"].println(ct.count(index)) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package codejam2c ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(new FileReader("c-small.in"));
    PrintWriter out=new PrintWriter(new FileWriter("c-small-out.out"));
    final long M=1000000007 ;
    int T=in.nextInt();
    for(int x=1 ; x<=T ; x++){
      int n=in.nextInt(),m=in.nextInt(),X=in.nextInt(),Y=in.nextInt(),Z=in.nextInt();
      int i,j ;
      int[] a=new int[n],A=new int[m];
      long[] nr=new long[n];
      long S=0 ;
      for(i=0 ; i<m ; i++){
        A[i]=in.nextInt();
      }
      for(i=0 ; i<n ; i++){
        a[i]=A[i % m];
        A[i % m]=(int)(((long)((long)X*A[i % m]+(long)Y*(i+1)))%(long)Z);
      }
      nr[0]=1 ;
      S=1 ;
      for(i=1 ; i<n ; i++){
        nr[i]=1 ;
        for(j=0 ; j<i ; j++)if(a[j]<a[i]){
          nr[i]+=nr[j];
          nr[i] %=M ;
        }
        S+=nr[i];
        S %=M ;
      }
      out.printf("Case #%d: %d%n",x,S);
    }
    in.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("c-small.in"))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("c-small-out.out"))) ;
    var M : long ; M := 1000000007 ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var x : int ; x := 1 ; while x <= T do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var X : int ; X := in.getCurrent()->toInteger() ;
    var Y : int ; Y := in.getCurrent()->toInteger() ;
    var Z : int ; Z := in.getCurrent()->toInteger() ;
     var i : int ;
    var j : int ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var A : Sequence(int) ; A := Integer.subrange(1,m)->collect(0) ;
    var nr : Sequence(long) ; nr := Integer.subrange(1,n)->collect(0) ;
    var S : long ; S := 0 ;
        i := 0 ; while i < m do ( (     A[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     a[i+1] := A[i mod m+1] ; 
     A[i mod m+1] := (((X->oclAsType(long) * A[i mod m+1] + Y->oclAsType(long) * (i + 1))->oclAsType(long)) mod Z->oclAsType(long))->oclAsType(int) )  ;     i := i + 1 ) ; 
    nr[0+1] := 1 ; 
    S := 1 ; 
        i := 1 ; while i < n do ( (     nr[i+1] := 1 ; 
         j := 0 ; while j < i do (     if (a[j+1] < a[i+1]) then (     nr[i+1] := nr[i+1]+(nr[j+1]) ; 
     nr[i+1] := nr[i+1] mod M ) else skip ;  ;     j := j + 1 ) ; 
     S := S+(nr[i+1]) ; 
     S := S mod M )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     x := x + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ProblemC {
  public static void main(final String[] args){
    final Scanner sc=new Scanner(System.in);
    final int cases=sc.nextInt();
    for(int cc=1 ; cc<=cases ; cc++){
      final int n=sc.nextInt();
      final int m=sc.nextInt();
      final long x=sc.nextLong(),y=sc.nextLong(),z=sc.nextLong();
      final int[] h=new int[n];
      final int[] a=new int[n];
      for(int i=0 ; i<m ; i++)h[i]=sc.nextInt();
      for(int i=0 ; i<n ; i++){
        a[i]=h[i % m];
        h[i % m]=(int)((x*h[i % m]+y*(i+1))% z);
      }
      final int[] s=new int[n];
      for(int i=0 ; i<n ; i++){
        s[i]=1 ;
        for(int j=0 ; j<i ; j++)if(a[j]<a[i])s[i]=(s[i]+s[j])% 1000000007 ;
      }
      int count=0 ;
      for(int i=0 ; i<n ; i++)count=(count+s[i])% 1000000007 ;
      System.out.printf("Case #%s: %s\n",cc,count);
    }
    System.out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemC {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cases : int ; cases := sc.getCurrent()->toInteger() ;
         var cc : int ; cc := 1 ; while cc <= cases do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : long ; x := sc.getCurrent()->toLong() ;
    var y : long ; y := sc.getCurrent()->toLong() ;
    var z : long ; z := sc.getCurrent()->toLong() ;
    var h : Sequence(int) ; h := Integer.subrange(1,n)->collect(0) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     h[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := h[i mod m+1] ; 
     h[i mod m+1] := ((x * h[i mod m+1] + y * (i + 1)) mod z)->oclAsType(int) )  ;     i := i + 1 ) ; 
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := 1 ; 
         var j : int ; j := 0 ; while j < i do (     if (a[j+1] < a[i+1]) then     s[i+1] := (s[i+1] + s[j+1]) mod 1000000007 ; else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do (     count := (count + s[i+1]) mod 1000000007 ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("Case #%s: %s\n", cc, count) ; 
 )  ;     cc := cc + 1 ) ; 
     OclFile["System.out"].flush() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  Scanner in ;
  PrintWriter out ;
  String IFILE="c-small-attempt0.in" ;
  String OFILE="c-small-attempt0.out" ;
  final long MOD=1000000007 ;
  public void run()throws IOException {
    in=new Scanner(new File(IFILE));
    out=new PrintWriter(OFILE);
    int nt=in.nextInt();
    for(int it=0 ; it<nt ; it++){
      int n=in.nextInt();
      int m=in.nextInt();
      long x=in.nextInt();
      long y=in.nextInt();
      long z=in.nextInt();
      long[] a=new long[m];
      for(int i=0 ; i<m ; i++)a[i]=in.nextLong();
      long[] mas=new long[n];
      for(int i=0 ; i<n ; i++){
        mas[i]=a[i % m];
        a[i % m]=(x*a[i % m]+y*(i+1))% z ;
      }
      long[] f=new long[n];
      Arrays.fill(f,1);
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<i ; j++)if(mas[j]<mas[i])f[i]=(f[i]+f[j])% MOD ;
      long ans=0 ;
      for(int i=0 ; i<n ; i++)ans=(ans+f[i])% MOD ;
      out.println("Case #"+(it+1)+": "+ans);
    }
    out.close();
  }
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile;
   attribute out : OclFile;
   attribute IFILE : String := "c-small-attempt0.in";
   attribute OFILE : String := "c-small-attempt0.out";
   attribute MOD : long := 1000000007;
   operation run() : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile(IFILE)) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile(OFILE)) ; 
    var nt : int ; nt := in.getCurrent()->toInteger() ;
        var it : int ; it := 0 ; while it < nt do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var x : long ; x := in.getCurrent()->toInteger() ;
    var y : long ; y := in.getCurrent()->toInteger() ;
    var z : long ; z := in.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     a[i+1] := in.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var mas : Sequence(long) ; mas := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     mas[i+1] := a[i mod m+1] ; 
     a[i mod m+1] := (x * a[i mod m+1] + y * (i + 1)) mod z )  ;     i := i + 1 ) ; 
    var f : Sequence(long) ; f := Integer.subrange(1,n)->collect(0) ;
    f := f->collect(1) ; 
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < i do (     if (mas[j+1] < mas[i+1]) then     f[i+1] := (f[i+1] + f[j+1]) mod MOD ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do (     ans := (ans + f[i+1]) mod MOD ;  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     it := it + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] a)throws Exception {
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(r.readLine());
    String[] str=r.readLine().split(" ");
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(str[i]);
    }
    arr=buildHeap(arr);
    int tmp ;
    for(int i=n-1 ; i>=1 ; i--){
      tmp=arr[0];
      arr[0]=arr[i];
      arr[i]=tmp ;
      heapify(arr,0,i);
    }
    StringBuilder s=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      s.append(arr[i]);
      if(i!=n-1){
        s.append(" ");
      }
    }
    System.out.println(s);
  }
  private static int[] buildHeap(int[] arr){
    int[] result=new int[arr.length];
    for(int i=arr.length/2-1 ; i>=0 ; i--){
      result=heapify(arr,i,arr.length);
    }
    return result ;
  }
  private static int[] heapify(int[] arr,int index,int maxIndex){
    int leftIndex=2*index+1 ;
    int rightIndex=2*index+2 ;
    int largestIndex=index ;
    if(leftIndex<maxIndex && arr[leftIndex]>arr[index]){
      largestIndex=leftIndex ;
    }
    if(rightIndex<maxIndex && arr[rightIndex]>arr[largestIndex]){
      largestIndex=rightIndex ;
    }
    if(largestIndex!=index){
      int tmp=arr[index];
      arr[index]=arr[largestIndex];
      arr[largestIndex]=tmp ;
      heapify(arr,largestIndex,maxIndex);
    }
    return arr ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (r.readLine())->toInteger() ;
    var str : Sequence(String) ; str := r.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (str[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    arr := buildHeap(arr) ; 
    var tmp : int ;
        var i : int ; i := n - 1 ; while i >= 1 do ( (     tmp := arr[0+1] ; 
     arr[0+1] := arr[i+1] ; 
     arr[i+1] := tmp ; 
     execute heapify(arr, 0, i) )  ;     i := i - 1 ) ; 
    var s : String ; s := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     s := s + StringLib.newString(arr[i+1]) ; 
     if (i /= n - 1) then (     s := s + StringLib.newString(" ") ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 );
  static   operation buildHeap( arr : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var result : Sequence(int) ; result := Integer.subrange(1,arr->size())->collect(0) ;
         var i : int ; i := arr->size() / 2 - 1 ; while i >= 0 do ( (     result := heapify(arr, i, arr->size()) )  ;     i := i - 1 ) ; 
     return result );
  static   operation heapify( arr : Sequence(int), index : int, maxIndex : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var leftIndex : int ; leftIndex := 2 * index + 1 ;
     var rightIndex : int ; rightIndex := 2 * index + 2 ;
    var largestIndex : int ; largestIndex := index ;
    if (leftIndex < maxIndex & arr[leftIndex+1] > arr[index+1]) then (     largestIndex := leftIndex ) else skip ; 
    if (rightIndex < maxIndex & arr[rightIndex+1] > arr[largestIndex+1]) then (     largestIndex := rightIndex ) else skip ; 
    if (largestIndex /= index) then (     var tmp : int ; tmp := arr[index+1] ;
     arr[index+1] := arr[largestIndex+1] ; 
     arr[largestIndex+1] := tmp ; 
     execute heapify(arr, largestIndex, maxIndex) ) else skip ; 
    return arr 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  private static void radixSort(int[] a){
    ArrayList<ArrayDeque<Integer>>buckets=new ArrayList<ArrayDeque<Integer>>(10);
    for(int i=0 ; i<10 ; i++){
      buckets.add(new ArrayDeque<Integer>());
    }
    for(int b : a){
      buckets.get(9).add(b);
    }
    int cur=1 ;
    while(buckets.get(0).size()<a.length){
      for(ArrayDeque<Integer>deque : buckets){
        int size=deque.size();
        for(int s=0 ; s<size ; s++){
          int p=deque.poll();
          int digit=p/cur ;
          digit %=10 ;
          buckets.get(digit).add(p);
        }
      }
      cur*=10 ;
    }
    for(int i=0 ; i<a.length ; i++){
      a[i]=buckets.get(0).poll();
    }
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int[] a=new int[N];
    for(int i=0 ; i<a.length ; i++){
      a[i]=scanner.nextInt();
    }
    Arrays.sort(a);
    StringBuilder builder=new StringBuilder();
    for(int i=0 ; i<a.length ; i++){
      if(i>0){
        builder.append(" ");
      }
      builder.append(a[i]);
    }
    System.out.println(builder.toString());
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation radixSort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var buckets : Sequence(Sequence(int)) ; buckets := Sequence{} ;
         var i : int ; i := 0 ; while i < 10 do ( (     buckets := buckets->including(ArrayDeque<int>.newArrayDeque()) )  ;     i := i + 1 ) ; 
    for (b : a) do ( (     buckets->at(9+1)->excludes(b) )  ) ; 
    var cur : int ; cur := 1 ;
    while (buckets->at(0+1)->size() < a->size()) do (     for (deque : buckets) do ( (     var size : int ; size := deque->size() ;
         var s : int ; s := 0 ; while s < size do ( (     var p : int ; p := deque->min() ;
     var digit : int ; digit := p / cur ;
     digit := digit mod 10 ; 
     buckets->at(digit+1)->excludes(p) )  ;     s := s + 1 ) )  ) ; 
     cur := cur*(10) ) ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := buckets->at(0+1)->min() ;     buckets->at(0+1) := buckets->at(0+1)->sort()->tail() )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var builder : String ; builder := StringLib.newString() ;
        var i : int ; i := 0 ; while i < a->size() do ( (     if (i > 0) then (     builder := builder + StringLib.newString(" ") ) else skip ; 
     builder := builder + StringLib.newString(a[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(builder+"") ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static void QuickSort(int[] arr,int left,int right){
    if(left<=right){
      int pivot=arr[(left+right)/2],l=left,r=right ;
      while(l<=r){
        while(arr[l]<pivot)l++;
        while(arr[r]>pivot)r--;
        if(l<=r){
          int tmp=arr[l];
          arr[l]=arr[r];
          arr[r]=tmp ;
          l++;
          r--;
        }
      }
      QuickSort(arr,left,r);
      QuickSort(arr,l,right);
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] data=new int[1000000];
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++)data[i]=sc.nextInt();
    QuickSort(data,0,n-1);
    for(int i=0 ; i<n-1 ; i++)System.out.print(data[i]+" ");
    System.out.println(data[n-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation QuickSort( arr : Sequence(int), left : int, right : int) : void
  pre: true
  post: true
  activity: (     if (left <= right) then (     var pivot : int ; pivot := arr[(left + right) / 2+1] ;
    var l : int ; l := left ;
    var r : int ; r := right ;
     while (l <= r) do (     while (arr[l+1] < pivot) do     l := l + 1 ; ; 
     while (arr[r+1] > pivot) do     r := r - 1 ; ; 
     if (l <= r) then (     var tmp : int ; tmp := arr[l+1] ;
     arr[l+1] := arr[r+1] ; 
    arr[r+1] := tmp ; 
    l := l + 1 ; 
    r := r - 1 ; 
 ) else skip ) ; 
     execute QuickSort(arr, left, r) ; 
     execute QuickSort(arr, l, right) ) else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var data : Sequence(int) ; data := Integer.subrange(1,1000000)->collect(0) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do (     data[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    execute QuickSort(data, 0, n - 1) ; 
        var i : int ; i := 0 ; while i < n - 1 do (     OclFile["System.out"].print(data[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(data[n - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String[] W=new String[n];
    ArrayList<String>ans=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      W[i]=sc.next();
      if(! ans.contains(W[i])){
        ans.add(W[i]);
      }
    }
    int cou=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if(W[i] .charAt(W[i] .length()-1)!=(W[i+1] .charAt(0))){
        cou++;
      }
    }
    if(ans.size()!=n){
      System.out.println("No");
    }
    else if(cou!=0){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var W : Sequence(String) ; W := Integer.subrange(1,n)->collect(null) ;
    var ans : Sequence(String) ; ans := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     W[i+1] := sc.getCurrent() ; 
     if (not(ans->includes(W[i+1]))) then (     ans := ans->including(W[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    var cou : int ; cou := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (W[i+1]->at(W[i+1]->size() - 1+1) /= (W[i + 1+1]->at(0+1))) then (     cou := cou + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (ans->size() /= n) then (     OclFile["System.out"].println("No") ) else     if (cou /= 0) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class GFG {
  static boolean strmatch(String str,String pattern,int n,int m){
    if(m==0)return(n==0);
    boolean[][] lookup=new boolean[n+1][m+1];
    for(int i=0 ; i<n+1 ; i++)Arrays.fill(lookup[i],false);
    lookup[0][0]=true ;
    for(int j=1 ; j<=m ; j++)if(pattern.charAt(j-1)=='*')lookup[0][j]=lookup[0][j-1];
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=m ; j++){
        if(pattern.charAt(j-1)=='*')lookup[i][j]=lookup[i][j-1] || lookup[i-1][j];
        else if(pattern.charAt(j-1)=='?' || str.charAt(i-1)==pattern.charAt(j-1))lookup[i][j]=lookup[i-1][j-1];
        else lookup[i][j]=false ;
      }
    }
    return lookup[n][m];
  }
  public static void main(String args[]){
    String str="baaabab" ;
    String pattern="*****ba*****ab" ;
    if(strmatch(str,pattern,str.length(),pattern.length()))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation strmatch( str : String, pattern : String, n : int, m : int) : boolean
  pre: true
  post: true
  activity: (     if (m = 0) then     return (n = 0) else skip ; 
     var lookup : Sequence(Sequence(boolean)) ; lookup := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(false)) ;
        var i : int ; i := 0 ; while i < n + 1 do (     lookup[i+1] := lookup[i+1]->collect(false) ;  ;     i := i + 1 ) ; 
    lookup[0+1][0+1] := true ; 
        var j : int ; j := 1 ; while j <= m do (     if (pattern->at(j - 1+1) = '*') then     lookup[0+1][j+1] := lookup[0+1][j - 1+1] ; else skip ;  ;     j := j + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= m do ( (     if (pattern->at(j - 1+1) = '*') then     lookup[i+1][j+1] := lookup[i+1][j - 1+1] or lookup[i - 1+1][j+1] ; else     if (pattern->at(j - 1+1) = '?' or str->at(i - 1+1) = pattern->at(j - 1+1)) then     lookup[i+1][j+1] := lookup[i - 1+1][j - 1+1] else     lookup[i+1][j+1] := false ; ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return lookup[n+1][m+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "baaabab" ;
     var pattern : String ; pattern := "*****ba*****ab" ;
     if (strmatch(str, pattern, str->size(), pattern->size())) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int t=scanner.nextInt();
    int s=scanner.nextInt();
    int[] a=new int[n];
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scanner.nextInt();
      b[i]=scanner.nextInt();
    }
    int[] dp=new int[t+1];
    int ans=0 ;
    for(int i=0 ; i<n ; i++)for(int j=t ; j-b[i]>=0 ; j--){
      if(j-b[i]>=s || s>=j)dp[j]=Math.max(dp[j],dp[j-b[i] ]+a[i]);
    }
    for(int i=0 ; i<=t ; i++)ans=Math.max(ans,dp[i]);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var t : int ; t := scanner.getCurrent()->toInteger() ;
    var s : int ; s := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() ; 
     b[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,t + 1)->collect(0) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := t ; while j - b[i+1] >= 0 do ( (     if (j - b[i+1] >= s or s >= j) then     dp[j+1] := Set{dp[j+1], dp[j - b[i+1]+1] + a[i+1]}->max() ; else skip )  ;     j := j - 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= t do (     ans := Set{ans, dp[i+1]}->max() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader buf=new BufferedReader(new InputStreamReader(System.in));
    String line_1=buf.readLine();
    int n=Integer.parseInt(line_1);
    int[] scores=new int[n];
    String[] line_2=buf.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      scores[i]=Integer.parseInt(line_2[i]);
    }
    Arrays.sort(scores);
    StringBuilder t=new StringBuilder();
    t.append(scores[0]);
    for(int j=1 ; j<n ; j++){
      t.append(" "+scores[j]);
    }
    System.out.println(t);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var buf : OclFile ; buf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line    var lineString : OclFile ; lineString := buf.readLine() : String ; line    var lineString : OclFile ; lineString := buf.readLine() := buf.readLine() ;
    var n : int ; n := (lineline(line(lineline(linen + "")->toInteger())->toInteger() + "")->toInteger())->toInteger() ;
    var scores : Sequence(int) ; scores := Integer.subrange(1,n)->collect(0) ;
    var linebuf.readLine()->split(" ") : Sequence(String) ; linebuf.readLine()->split(" ") := buf.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < n do ( (     scores[i+1] := (linei[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    scores := scores->sort() ; 
    var t : String ; t := StringLib.newString() ;
    t := t + StringLib.newString(scores[0+1]) ; 
        var j : int ; j := 1 ; while j < n do ( (     t := t + StringLib.newString(" " + scores[j+1]) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(t) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.Map ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String[] tmp=in.readLine().split(" ");
    Integer h=Integer.parseInt(tmp[0]);
    Integer w=Integer.parseInt(tmp[1]);
    Integer n=Integer.parseInt(tmp[2]);
    Integer a,b ;
    Map<String,Integer>candidates=new HashMap<>();
    long[] result=new long[10];
    for(int i=0 ; i<n ; i++){
      tmp=in.readLine().split(" ");
      a=Integer.parseInt(tmp[0]);
      b=Integer.parseInt(tmp[1]);
      for(int x=2 ; x>=0 ; x--){
        for(int y=2 ; y>=0 ; y--){
          if(a-x>=1 && b-y>=1 &&(a-x+2)<=h &&(b-y+2)<=w){
            String key=(a-x)+"+"+(b-y);
            if(candidates.containsKey(key)){
              candidates.put(key,candidates.get(key)+1);
            }
            else {
              candidates.put(key,1);
            }
          }
        }
      }
    }
    result[0]=(long)(h-2)*(w-2)-candidates.size();
    for(Map.Entry<String,Integer>candidate : candidates.entrySet()){
      result[candidate.getValue()]++;
    }
    for(int j=0 ; j<=9 ; j++){
      System.out.println(result[j]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmp : Sequence(String) ; tmp := in.readLine()->split(" ") ;
    var h : int ; h := (tmp[0+1])->toInteger() ;
    var w : int ; w := (tmp[1+1])->toInteger() ;
    var n : int ; n := (tmp[2+1])->toInteger() ;
    var a : int ;
    var b : int ;
    var candidates : Map(String,int) ; candidates := Map{} ;
    var result : Sequence(long) ; result := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     tmp := in.readLine()->split(" ") ; 
     a := (tmp[0+1])->toInteger() ; 
     b := (tmp[1+1])->toInteger() ; 
         var x : int ; x := 2 ; while x >= 0 do ( (         var y : int ; y := 2 ; while y >= 0 do ( (     if (a - x >= 1 & b - y >= 1 & (a - x + 2) <= h & (b - y + 2) <= w) then (     var key : String ; key := (a - x) + "+" + (b - y) ;
     if (candidates->keys()->includes(key)) then (     candidates := candidates->union(Map{key |-> candidates->at(key) + 1}) ) else (     candidates := candidates->union(Map{key |-> 1}) ) ) else skip )  ;     y := y - 1 ) )  ;     x := x - 1 ) )  ;     i := i + 1 ) ; 
    result[0+1] := (h - 2)->oclAsType(long) * (w - 2) - candidates.size() ; 
    for (candidate : candidates->asSet()) do ( (     result[candidate.getValue()+1] := result[candidate.getValue()+1] + 1 )  ) ; 
        var j : int ; j := 0 ; while j <= 9 do ( (     OclFile["System.out"].println(result[j+1]) )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Objects ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int H=scanner.nextInt();
    int W=scanner.nextInt();
    int N=scanner.nextInt();
    HashMap<Point,Integer>freq=new HashMap<>();
    for(int i=0 ; i<N ; i++){
      int x=scanner.nextInt();
      int y=scanner.nextInt();
      for(int j=-1 ; j<=1 ; j++){
        for(int k=-1 ; k<=1 ; k++){
          int sx=x+j ;
          int sy=y+k ;
          if(sx>1 && sx<H && sy>1 && sy<W){
            Point p=new Point(sx,sy);
            freq.put(p,freq.getOrDefault(p,0)+1);
          }
        }
      }
    }
    long[] total=new long[10];
    total[0]=(long)(H-2)*(W-2)-freq.size();
    for(int f : freq.values())total[f]++;
    for(long t : total){
      System.out.println(t);
    }
  }
  private static class Point {
    public final int x ;
    public final int y ;
    private Point(int x,int y){
      this.x=x ;
      this.y=y ;
    }
    @ Override public boolean equals(Object o){
      if(this==o)return true ;
      if(o==null || getClass()!=o.getClass())return false ;
      Point point=(Point)o ;
      return x==point.x && y==point.y ;
    }
    @ Override public int hashCode(){
      return Objects.hash(x,y);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := scanner.getCurrent()->toInteger() ;
    var W : int ; W := scanner.getCurrent()->toInteger() ;
    var N : int ; N := scanner.getCurrent()->toInteger() ;
    var freq : Map(Point,int) ; freq := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     var x : int ; x := scanner.getCurrent()->toInteger() ;
     var y : int ; y := scanner.getCurrent()->toInteger() ;
         var j : int ; j := -1 ; while j <= 1 do ( (         var k : int ; k := -1 ; while k <= 1 do ( (     var sx : int ; sx := x + j ;
     var sy : int ; sy := y + k ;
     if (sx > 1 & sx < H & sy > 1 & sy < W) then (     var p : Point ; p := Point.newPoint(sx, sy) ;
     freq := freq->union(Map{p |-> (if freq->keys()->contains(p) then freq->at(p) else 0 endif) + 1}) ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var total : Sequence(long) ; total := Integer.subrange(1,10)->collect(0) ;
    total[0+1] := (H - 2)->oclAsType(long) * (W - 2) - freq.size() ; 
    for (f : freq->values()) do (     total[f+1] := total[f+1] + 1 ;  ) ; 
    for (t : total) do ( (     OclFile["System.out"].println(t) )  ) ; 
 );
  static class Point {
   attribute x : int;
   attribute y : int;
   static operation newPoint( x : int, y : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
      operation equals( o : OclAny) : boolean
  pre: true
  post: true
  activity: (     if (self = o) then     return true else skip ; 
     if (o = null or getClass() /= o->oclType()) then     return false else skip ; 
     var point : Point ; point := o->oclAsType(Point) ;
     return x = point.x & y = point.y );
      operation hashCode() : int
  pre: true
  post: true
  activity: (     return Objects.hash(x, y) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main extends PrintWriter {
  Main(){
    super(System.out,true);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    Main o=new Main();
    o.main();
    o.flush();
  }
  static class V {
    int i,j ;
    V(int i,int j){
      this.i=i ;
      this.j=j ;
    }
  }
  void main(){
    int n=sc.nextInt();
    int m=sc.nextInt();
    int k=sc.nextInt();
    int k_=k*9 ;
    V[] vv=new V[k_];
    k_=0 ;
    while(k-->0){
      int a=sc.nextInt();
      int b=sc.nextInt();
      for(int i=a-2 ; i<=a ; i++)for(int j=b-2 ; j<=b ; j++)if(i>=1 && j>=1 && i+2<=n && j+2<=m)vv[k_++]=new V(i,j);
    }
    Arrays.sort(vv,0,k_,(u,v)->u.i!=v.i ? u.i-v.i : u.j-v.j);
    int[] kk=new int[10];
    for(int u=0,v ; u<k_ ; u=v){
      int i=vv[u] .i,j=vv[u] .j ;
      v=u+1 ;
      while(v<k_ && vv[v] .i==i && vv[v] .j==j)v++;
      kk[v-u]++;
    }
    long z=(long)(n-2)*(m-2);
    for(int h=1 ; h<10 ; h++)z-=kk[h];
    println(z);
    for(int h=1 ; h<10 ; h++)println(kk[h]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends OclFile {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"], true) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : Main ; o := Main.newMain() ;
     o.main() ; 
     o.flush() );
  static class V {
   attribute i : int;
   static operation newV( i : int, j : int) : V
  pre: true
  post: true
  activity:
  ( var self : V ;
    self := createV();
    self.initialise(i, j);
    return self );
  operation initialise( i : int, j : int) : void
  pre: true  post: true
  activity: (     self.i := i ; 
     self.j := j );
}
   operation main() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var k_ : int ; k_ := k * 9 ;
    var vv : Sequence(V) ; vv := Integer.subrange(1,k_)->collect(null) ;
    k_ := 0 ; 
        while (k > 0) do (        k := k - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
         var i : int ; i := a - 2 ; while i <= a do (         var j : int ; j := b - 2 ; while j <= b do (     if (i >= 1 & j >= 1 & i + 2 <= n & j + 2 <= m) then      vv[k_+1] := V.newV(i, j)  ; k_ := k_ + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ) ;  ) ;  
    vv, 0, k_, lambda (u , v) : OclAny in if u.i /= v.i then u.i - v.i else u.j - v.j endif := vv, 0, k_, lambda (u , v) : OclAny in if u.i /= v.i then u.i - v.i else u.j - v.j endif->sort() ; 
    var kk : Sequence(int) ; kk := Integer.subrange(1,10)->collect(0) ;
        var u : int ; u := 0 ;
    var v : int ; while u < k_ do ( (     var i : int ; i := vv[u+1].i ;
    var j : int ; j := vv[u+1].j ;
     v := u + 1 ; 
     while (v < k_ & vv[v+1].i = i & vv[v+1].j = j) do     v := v + 1 ; ; 
     kk[v - u+1] := kk[v - u+1] + 1 )  ;     u := v ) ; 
    var z : long ; z := (n - 2)->oclAsType(long) * (m - 2) ;
        var h : int ; h := 1 ; while h < 10 do (     z := z-(kk[h+1]) ;  ;     h := h + 1 ) ; 
    execute println(z) ; 
        var h : int ; h := 1 ; while h < 10 do (     execute println(kk[h+1]) ;  ;     h := h + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long H=sc.nextLong();
    long W=sc.nextLong();
    int N=sc.nextInt();
    int a[]=new int[N];
    int b[]=new int[N];
    HashMap<Long,Integer>map=new HashMap<Long,Integer>();
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextInt()-1 ;
      b[i]=sc.nextInt()-1 ;
      long l=b[i]+a[i]*W ;
      out : for(int y=0 ;
      y<3 ;
      y++){
        if(a[i]-y<0 || a[i]-y>=H-2)continue out ;
        in : for(int x=0 ;
        x<3 ;
        x++){
          if(b[i]-x<0 || b[i]-x>=W-2)continue in ;
          if(map.containsKey(l-x-y*W)){
            map.put(l-x-y*W,map.get(l-x-y*W)+1);
          }
          else {
            map.put(l-x-y*W,1);
          }
        }
      }
    }
    long ans[]=new long[10];
    int cnt=0 ;
    for(long key : map.keySet()){
      ans[map.get(key)]++;
      cnt++;
    }
    ans[0]=(H-2)*(W-2)-cnt ;
    for(int i=0 ; i<10 ; i++){
      System.out.println(ans[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : long ; H := sc.getCurrent()->toLong() ;
    var W : long ; W := sc.getCurrent()->toLong() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,N)->collect(0) ;
    var map : Map(long,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toInteger() - 1 ; 
     b[i+1] := sc.getCurrent()->toInteger() - 1 ; 
     var l : long ; l := b[i+1] + a[i+1] * W ;
         var y : int ; y := 0 ; while y < 3 do ( (     if (a[i+1] - y < 0 or a[i+1] - y >= H - 2) then     continue else skip ; 
         var x : int ; x := 0 ; while x < 3 do ( (     if (b[i+1] - x < 0 or b[i+1] - x >= W - 2) then     continue else skip ; 
     if (map->keys()->includes(l - x - y * W)) then (     map := map->union(Map{l - x - y * W |-> map->at(l - x - y * W) + 1}) ) else (     map := map->union(Map{l - x - y * W |-> 1}) ) )  ;     x := x + 1 ) ; )  ;     y := y + 1 ) ; )  ;     i := i + 1 ) ; 
    var ans : Sequence(long) ; ans := Integer.subrange(1,10)->collect(0) ;
    var cnt : int ; cnt := 0 ;
    for (key : map->keys()) do ( (     ans[map->at(key)+1] := ans[map->at(key)+1] + 1 ; 
     cnt := cnt + 1 )  ) ; 
    ans[0+1] := (H - 2) * (W - 2) - cnt ; 
        var i : int ; i := 0 ; while i < 10 do ( (     OclFile["System.out"].println(ans[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int n=sc.nextInt();
    int[] arrA=new int[n];
    int[] arrB=new int[n];
    for(int i=0 ; i<n ; i++){
      arrA[i]=sc.nextInt();
      arrB[i]=sc.nextInt();
    }
    sc.close();
    HashMap<String,Integer>result=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int a=arrA[i];
      int b=arrB[i];
      putBlack(result,a,b,h,w);
    }
    long[] count=new long[10];
    Arrays.fill(count,0);
    count[0]=(long)(h-2)*(long)(w-2);
    for(int val : result.values()){
      count[val]+=1 ;
      count[0]-=1 ;
    }
    for(int i=0 ; i<=9 ; i++){
      System.out.println(count[i]);
    }
  }
  private static void putBlack(HashMap<String,Integer>result,int a,int b,int h,int w){
    for(int x=a-2 ; x<=a ; x++){
      if(x<1 || x>h-2){
        continue ;
      }
      for(int y=b-2 ; y<=b ; y++){
        if(y<1 || y>w-2){
          continue ;
        }
        String point=x+" "+y ;
        if(! result.containsKey(point)){
          result.put(point,Integer.valueOf(1));
        }
        else {
          int count=result.get(point);
          result.put(point,count+1);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var arrA : Sequence(int) ; arrA := Integer.subrange(1,n)->collect(0) ;
    var arrB : Sequence(int) ; arrB := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arrA[i+1] := sc.getCurrent()->toInteger() ; 
     arrB[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var result : Map(String,int) ; result := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := arrA[i+1] ;
     var b : int ; b := arrB[i+1] ;
     execute putBlack(result, a, b, h, w) )  ;     i := i + 1 ) ; 
    var count : Sequence(long) ; count := Integer.subrange(1,10)->collect(0) ;
    count := count->collect(0) ; 
    count[0+1] := (h - 2)->oclAsType(long) * (w - 2)->oclAsType(long) ; 
    for (val : result->values()) do ( (     count[val+1] := count[val+1]+(1) ; 
     count[0+1] := count[0+1]-(1) )  ) ; 
        var i : int ; i := 0 ; while i <= 9 do ( (     OclFile["System.out"].println(count[i+1]) )  ;     i := i + 1 ) ; 
 );
  static   operation putBlack( result : Map(String,int), a : int, b : int, h : int, w : int) : void
  pre: true
  post: true
  activity: (         var x : int ; x := a - 2 ; while x <= a do ( (     if (x < 1 or x > h - 2) then (     continue ) else skip ; 
         var y : int ; y := b - 2 ; while y <= b do ( (     if (y < 1 or y > w - 2) then (     continue ) else skip ; 
     var point : String ; point := x + " " + y ;
     if (not(result->keys()->includes(point))) then (     result := result->union(Map{point |-> (1)->toInteger()}) ) else (     var count : int ; count := result->at(point) ;
     result := result->union(Map{point |-> count + 1}) ) )  ;     y := y + 1 ) )  ;     x := x + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BCowsAndPokerGame {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int a=0,i=0 ;
    String s=in.next();
    for(char x : s.toCharArray()){
      if(x=='A')++a ;
      else if(x=='I')++i ;
    }
    System.out.print(i==1 ? 1 : i==0 ? a : 0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class BCowsAndPokerGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : int ; a := 0 ;
    var i : int ; i := 0 ;
    var s : String ; s := in.getCurrent() ;
    for (x : s->characters()) do ( (     if (x = 'A') then     a := a + 1 ; else     if (x = 'I') then     i := i + 1 ; else skip ; )  ) ; 
    OclFile["System.out"].print(if i = 1 then 1 else if i = 0 then a else 0 endif endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    Integer n=s.nextInt();
    String hands=s.next();
    Long a=hands.chars().filter(c->c=='A').count();
    Long i=hands.chars().filter(c->c=='I').count();
    Long f=hands.chars().filter(c->c=='F').count();
    Integer result=i>1 ? 0 : i==1 ? 1 : a.intValue();
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var hands : String ; hands := s.getCurrent() ;
    var a : long ; a := hands.chars()->select( _x1 | (lambda c : OclAny in c = 'A')->apply(_x1) )->size() ;
    var i : long ; i := hands.chars()->select( _x1 | (lambda c : OclAny in c = 'I')->apply(_x1) )->size() ;
    var f : long ; f := hands.chars()->select( _x1 | (lambda c : OclAny in c = 'F')->apply(_x1) )->size() ;
    var result : int ; result := if i > 1 then 0 else if i = 1 then 1 else a->oclAsType(int) endif endif ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class ExtractNumbers {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=br.readLine();
    String[] token=str.split("[,;] ",-1);
    getWords(token);
  }
  private static void getWords(String[] stringList){
    StringBuilder asb=new StringBuilder();
    boolean flaga=false ;
    boolean flagb=false ;
    StringBuilder bsb=new StringBuilder();
    for(String s : stringList){
      if(isInteger(s)){
        if(flaga){
          asb.append(","+s);
        }
        else {
          flaga=true ;
          asb.append(s);
        }
      }
      else {
        if(flagb){
          bsb.append(","+s);
        }
        else {
          flagb=true ;
          bsb.append(s);
        }
      }
    }
    String a=asb.toString();
    String b=bsb.toString();
    System.out.println((! flaga)? "-" :("\""+a+"\""));
    System.out.println((! flagb)? "-" :("\""+b+"\""));
  }
  private static boolean isInteger(String s){
    try {
      if(s.length()<=9){
        int i=Integer.parseInt(s);
        if(Integer.toString(i).equals(s)){
          return true ;
        }
        return false ;
      }
      else {
        if(s.startsWith("0")){
          return false ;
        }
        for(int i=0 ; i<s.length(); i++){
          if(((s.charAt(i)-'0')<0)||(s.charAt(i)-'0')>9){
            return false ;
          }
        }
        return true ;
      }
    }
    catch(Exception ex){
      return false ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ExtractNumbers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := br.readLine() ;
     var token : Sequence(String) ; token := str->split("[,;] ") ;
     execute getWords(token) );
  static   operation getWords( stringList : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var asb : String ; asb := StringLib.newString() ;
     var flaga : boolean ; flaga := false ;
    var flagb : boolean ; flagb := false ;
    var bsb : String ; bsb := StringLib.newString() ;
    for (s : stringList) do ( (     if (isInteger(s)) then (     if (flaga) then (     asb := asb + StringLib.newString("," + s) ) else (     flaga := true ; 
     asb := asb + StringLib.newString(s) ) ) else (     if (flagb) then (     bsb := bsb + StringLib.newString("," + s) ) else (     flagb := true ; 
     bsb := bsb + StringLib.newString(s) ) ) )  ) ; 
    var a : String ; a := asb+"" ;
    var b : String ; b := bsb+"" ;
    OclFile["System.out"].println(if (not(flaga)) then "-" else ("\"" + a + "\"") endif) ; 
    OclFile["System.out"].println(if (not(flagb)) then "-" else ("\"" + b + "\"") endif) ; 
 );
  static   operation isInteger( s : String) : boolean
  pre: true
  post: true
  activity: (     try (     if (s->size() <= 9) then (     var i : int ; i := (s)->toInteger() ;
     if (((i) + "") = s) then (     return true ) else skip ; 
     return false ) else (     if (s->hasPrefix("0")) then (     return false ) else skip ; 
         var i : int ; i := 0 ; while i < s->size() do ( (     if (((s->at(i+1) - ('0')->char2byte()) < 0) or (s->at(i+1) - ('0')->char2byte()) > 9) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true ) )   catch (ex : ProgramException) do (     return false )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static void largestInColumn(int cols,int[][] arr){
    for(int i=0 ; i<cols ; i++){
      int maxm=arr[0][i];
      for(int j=1 ; j<arr[i] .length ; j++)if(arr[j][i]>maxm)maxm=arr[j][i];
      System.out.println(maxm);
    }
  }
  public static void main(String[] args){
    int[][] arr=new int[][] {
      {
        3,4,1,8 },{
          1,4,9,11 },{
            76,34,21,1 },{
              2,1,4,5 }
            };
            largestInColumn(4,arr);
          }
        }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation largestInColumn( cols : int, arr : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < cols do ( (     var maxm : int ; maxm := arr[0+1][i+1] ;
         var j : int ; j := 1 ; while j < arr[i+1]->size() do (     if (arr[j+1][i+1] > maxm) then     maxm := arr[j+1][i+1] ; else skip ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(maxm) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{3,4,1,8},Sequence{1,4,9,11},Sequence{76,34,21,1},Sequence{2,1,4,5}} ;
     execute largestInColumn(4, arr) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static int INF=2<<27 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    int s=sc.nextInt();
    int[] a=new int[n];
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
    }
    long[][] dp=new long[n+1][t+1];
    for(int i=0 ; i<n+1 ; i++){
      dp[i][0]=0 ;
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<=t ; j++){
        dp[i+1][j]=Math.max(dp[i][j],dp[i+1][j]);
        int tmp=j+b[i];
        if(tmp>t)continue ;
        if(tmp>s && j<s){
          dp[i+1][s]=Math.max(dp[i+1][s],dp[i][j]);
        }
        else {
          dp[i+1][tmp]=Math.max(dp[i+1][tmp],dp[i][j]+a[i]);
        }
      }
    }
    long ans=0 ;
    for(int i=0 ; i<=t ; i++){
      ans=Math.max(ans,dp[n][i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute INF : int := (2*(2->pow(27)))->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,t + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < n + 1 do ( (     dp[i+1][0+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j <= t do ( (     dp[i + 1+1][j+1] := Set{dp[i+1][j+1], dp[i + 1+1][j+1]}->max() ; 
     var tmp : int ; tmp := j + b[i+1] ;
     if (tmp > t) then     continue else skip ; 
     if (tmp > s & j < s) then (     dp[i + 1+1][s+1] := Set{dp[i + 1+1][s+1], dp[i+1][j+1]}->max() ) else (     dp[i + 1+1][tmp+1] := Set{dp[i + 1+1][tmp+1], dp[i+1][j+1] + a[i+1]}->max() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i <= t do ( (     ans := Set{ans, dp[n+1][i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
class GFG {
  static void countDigit(int n){
    int temp=n,sum=0,product=1 ;
    while(temp!=0){
      int d=temp % 10 ;
      temp/=10 ;
      if(d>0 && n % d==0){
        sum+=d ;
        product*=d ;
      }
    }
    System.out.print("Sum="+sum);
    System.out.print("\nProduct="+product);
  }
  public static void main(String args[]){
    int n=1012 ;
    countDigit(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDigit( n : int) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := n ;
    var sum : int ; sum := 0 ;
    var product : int ; product := 1 ;
     while (temp /= 0) do (     var d : int ; d := temp mod 10 ;
     temp := temp/(10) ; 
     if (d > 0 & n mod d = 0) then (     sum := sum+(d) ; 
     product := product*(d) ) else skip ) ; 
     OclFile["System.out"].print("Sum=" + sum) ; 
     OclFile["System.out"].print("\nProduct=" + product) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1012 ;
     execute countDigit(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minCost(char[] s){
    boolean alphabets[]=new boolean[26];
    for(int i=0 ; i<s.length ; i++){
      alphabets[(int)s[i]-97]=true ;
    }
    int count=0 ;
    for(int i=0 ; i<26 ; i++){
      if(alphabets[i]){
        count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    String s="geeksforgeeks" ;
    System.out.println("Total cost to construct "+s+" is "+minCost(s.toCharArray()));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minCost( s : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var alphabets : Sequence(boolean) ; alphabets := Integer.subrange(1,26)->collect(false) ;
         var i : int ; i := 0 ; while i < s->size() do ( (     alphabets[s[i+1]->oclAsType(int) - 97+1] := true )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < 26 do ( (     if (alphabets[i+1]) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     OclFile["System.out"].println("Total cost to construct " + s + " is " + minCost(s->characters())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int L=sc.nextInt();
      int a=sc.nextInt();
      int[] t=new int[n];
      int[] l=new int[n];
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        t[i]=sc.nextInt();
        l[i]=sc.nextInt();
      }
      int s=0,ans=0 ;
      for(int i=0 ; i<n ; i++){
        ans+=(t[i]-s)/a ;
        s=t[i]+l[i];
      }
      ans+=(L-s)/a ;
      System.out.println(ans);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var L : int ; L := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
    var l : Sequence(int) ; l := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     t[i+1] := sc.getCurrent()->toInteger() ; 
     l[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var s : int ; s := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans+((t[i+1] - s) / a) ; 
     s := t[i+1] + l[i+1] )  ;     i := i + 1 ) ; 
    ans := ans+((L - s) / a) ; 
    OclFile["System.out"].println(ans) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class test {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int L=sc.nextInt();
    int a=sc.nextInt();
    if(n>0){
      long ctr=0,cnt=0 ;
      for(long i=0 ; i<n ; i++){
        int t=sc.nextInt();
        int l=sc.nextInt();
        long diff=t-ctr ;
        if(diff>=a){
          cnt+=(diff/a);
        }
        int nextctr=t+l ;
        ctr=nextctr ;
      }
      if(ctr<L){
        long nn=L-ctr ;
        cnt+=(nn/a);
      }
      System.out.println(cnt);
    }
    else {
      System.out.println(L/a);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var L : int ; L := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    if (n > 0) then (     var ctr : long ; ctr := 0 ;
    var cnt : long ; cnt := 0 ;
         var i : long ; i := 0 ; while i < n do ( (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var diff : long ; diff := t - ctr ;
    if (diff >= a) then (     cnt := cnt+((diff / a)) ) else skip ; 
    var nextctr : int ; nextctr := t + l ;
    ctr := nextctr ; 
 )  ;     i := i + 1 ) ; 
     if (ctr < L) then (     var nn : long ; nn := L - ctr ;
     cnt := cnt+((nn / a)) ) else skip ; 
     OclFile["System.out"].println(cnt) ) else (     OclFile["System.out"].println(L / a) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner M=new Scanner(System.in);
    int guke=M.nextInt();
    int zongshichang=M.nextInt();
    int xiuxi=M.nextInt();
    int cishu=0 ;
    int kaishi=0 ;
    int last=0 ;
    int shichang=0 ;
    for(int i=0 ; i<guke ; i++){
      kaishi=M.nextInt();
      shichang=M.nextInt();
      cishu=cishu+(kaishi-last)/xiuxi ;
      last=kaishi+shichang ;
    }
    cishu=cishu+(zongshichang-last)/xiuxi ;
    System.out.print(cishu);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var M : OclFile ; M := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var guke : int ; guke := M.getCurrent()->toInteger() ;
    var zongshichang : int ; zongshichang := M.getCurrent()->toInteger() ;
    var xiuxi : int ; xiuxi := M.getCurrent()->toInteger() ;
    var cishu : int ; cishu := 0 ;
    var kaishi : int ; kaishi := 0 ;
    var last : int ; last := 0 ;
    var shichang : int ; shichang := 0 ;
        var i : int ; i := 0 ; while i < guke do ( (     kaishi := M.getCurrent()->toInteger() ; 
     shichang := M.getCurrent()->toInteger() ; 
     cishu := cishu + (kaishi - last) / xiuxi ; 
     last := kaishi + shichang )  ;     i := i + 1 ) ; 
    cishu := cishu + (zongshichang - last) / xiuxi ; 
    OclFile["System.out"].print(cishu) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      String s=sc.next();
      s=s+"A" ;
      List<Character>alpha=new ArrayList<>();
      char c ;
      String ans="" ;
      for(c='a' ; c<='z' ; c++){
        alpha.add(c);
      }
      int[] freq=new int[26];
      Arrays.fill(freq,0);
      for(int i=0 ; i<s.length()-1 ; i++){
        char w=s.charAt(i);
        if(freq[alpha.indexOf(w)]==1)continue ;
        if(s.charAt(i+1)==w){
          freq[alpha.indexOf(w)]=2 ;
          i=i+1 ;
        }
        else freq[alpha.indexOf(w)]=1 ;
      }
      for(int i=0 ; i<26 ; i++){
        if(freq[i]==1)ans=ans+alpha.get(i);
      }
      if(s.length()==1)System.out.println(s);
      else System.out.println(ans);
    }
  }
  static boolean isPrime(long n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static long gcd(long a,long b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static long lcm(long a,long b){
    return(a/gcd(a,b))*b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : String ; s := sc.getCurrent() ;
     s := s + "A" ; 
    var alpha : Sequence(String) ; alpha := Sequence{} ;
    var c : String ;
    var ans : String ; ans := "" ;
        c := 'a' ; while c <= 'z' do ( (     alpha := alpha->including(c) )  ;     c := c + 1 ) ; 
    var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
    freq := freq->collect(0) ; 
        var i : int ; i := 0 ; while i < s->size() - 1 do ( (     var w : String ; w := s->at(i+1) ;
     if (freq[alpha->indexOf(w)-1+1] = 1) then     continue else skip ; 
     if (s->at(i + 1+1) = w) then (     freq[alpha->indexOf(w)-1+1] := 2 ; 
     i := i + 1 ) else     freq[alpha->indexOf(w)-1+1] := 1 ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 26 do ( (     if (freq[i+1] = 1) then     ans := ans + alpha->at(i+1) ; else skip )  ;     i := i + 1 ) ; 
    if (s->size() = 1) then     OclFile["System.out"].println(s) else     OclFile["System.out"].println(ans) ; ;  
 ) ;  ) );
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a / gcd(a, b)) * b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    boolean[] is_prime=new boolean[1000001];
    for(int i=2 ; i<1000001 ; i++){
      is_prime[i]=true ;
    }
    for(int i=2 ; i<=1000 ; i++){
      if(is_prime[i]){
        for(int j=2*i ; j<1000001 ; j+=i){
          is_prime[j]=false ;
        }
      }
    }
    while(true){
      final int a=sc.nextInt();
      final int b=sc.nextInt();
      if(a==0 && b==0){
        break ;
      }
      int a_sum=0 ;
      int a_max=0 ;
      for(int i=2 ; i<=a ; i++){
        if(! is_prime[i]){
          continue ;
        }
        else if(a % i!=0){
          continue ;
        }
        a_sum+=i ;
        a_max=i ;
      }
      int a_key=a_max+a_max-a_sum ;
      int b_sum=0 ;
      int b_max=0 ;
      for(int i=2 ; i<=b ; i++){
        if(! is_prime[i]){
          continue ;
        }
        else if(b % i!=0){
          continue ;
        }
        b_sum+=i ;
        b_max=i ;
      }
      int b_key=b_max+b_max-b_sum ;
      if(a_key>b_key){
        System.out.println("a");
      }
      else {
        System.out.println("b");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var is_prime : Sequence(boolean) ; is_prime := Integer.subrange(1,1000001)->collect(false) ;
        var i : int ; i := 2 ; while i < 1000001 do ( (     is_prime[i+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= 1000 do ( (     if (is_prime[i+1]) then (         var j : int ; j := 2 * i ; while j < 1000001 do ( (     is_prime[j+1] := false )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    while (true) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    if (a = 0 & b = 0) then (     break ) else skip ; 
    var a_sum : int ; a_sum := 0 ;
    var a_max : int ; a_max := 0 ;
        var i : int ; i := 2 ; while i <= a do ( (     if (not(is_prime[i+1])) then (     continue ) else     if (a mod i /= 0) then (     continue ) else skip ; ;  
     a_sum := a_sum+(i) ; 
     a_max := i )  ;     i := i + 1 ) ; 
    var a_key : int ; a_key := a_max + a_max - a_sum ;
    var b_sum : int ; b_sum := 0 ;
    var b_max : int ; b_max := 0 ;
        var i : int ; i := 2 ; while i <= b do ( (     if (not(is_prime[i+1])) then (     continue ) else     if (b mod i /= 0) then (     continue ) else skip ; ;  
     b_sum := b_sum+(i) ; 
     b_max := i )  ;     i := i + 1 ) ; 
    var b_key : int ; b_key := b_max + b_max - b_sum ;
    if (a_key > b_key) then (     OclFile["System.out"].println("a") ) else (     OclFile["System.out"].println("b") ) ;  
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Snowball {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int w=sc.nextInt();
    int h=sc.nextInt();
    int u1=sc.nextInt();
    int d1=sc.nextInt();
    int u2=sc.nextInt();
    int d2=sc.nextInt();
    while(h>0){
      w+=h ;
      if(d1==h){
        if(u1>w)w=0 ;
        else w-=u1 ;
      }
      else if(d2==h){
        if(u2>w)w=0 ;
        else w-=u2 ;
      }
      h--;
    }
    System.out.println(w);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Snowball {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var u1 : int ; u1 := sc.getCurrent()->toInteger() ;
    var d1 : int ; d1 := sc.getCurrent()->toInteger() ;
    var u2 : int ; u2 := sc.getCurrent()->toInteger() ;
    var d2 : int ; d2 := sc.getCurrent()->toInteger() ;
    while (h > 0) do (     w := w+(h) ; 
     if (d1 = h) then (     if (u1 > w) then     w := 0 ; else     w := w-(u1) ; ) else     if (d2 = h) then (     if (u2 > w) then     w := 0 ; else     w := w-(u2) ; ) else skip ; ;  
     h := h - 1 ) ; 
    OclFile["System.out"].println(w) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class P1099A {
  public static void main(String[] args)throws IOException {
    BufferedReader io=new BufferedReader(new InputStreamReader(System.in));
    String[] wh=io.readLine().split(" ");
    Integer w=Integer.valueOf(wh[0]);
    Integer h=Integer.valueOf(wh[1]);
    String[] s1=io.readLine().split(" ");
    Integer u1=Integer.valueOf(s1[0]);
    Integer d1=Integer.valueOf(s1[1]);
    String[] s2=io.readLine().split(" ");
    Integer u2=Integer.valueOf(s2[0]);
    Integer d2=Integer.valueOf(s2[1]);
    while(h>=0){
      w=w+h ;
      if(d1.equals(h)){
        w=w-u1 ;
        if(w.compareTo(0)<0){
          w=0 ;
        }
      }
      if(d2.equals(h)){
        w=w-u2 ;
        if(w.compareTo(0)<0){
          w=0 ;
        }
      }
      h--;
    }
    System.out.println(w);
  }
}
------------------------------------------------------------
OCL File:
---------
 class P1099A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var wh : Sequence(String) ; wh := io.readLine()->split(" ") ;
    var w : int ; w := (wh[0+1])->toInteger() ;
    var h : int ; h := (wh[1+1])->toInteger() ;
    var s1 : Sequence(String) ; s1 := io.readLine()->split(" ") ;
    var u1 : int ; u1 := (s1[0+1])->toInteger() ;
    var d1 : int ; d1 := (s1[1+1])->toInteger() ;
    var s2 : Sequence(String) ; s2 := io.readLine()->split(" ") ;
    var u2 : int ; u2 := (s2[0+1])->toInteger() ;
    var d2 : int ; d2 := (s2[1+1])->toInteger() ;
    while (h >= 0) do (     w := w + h ; 
     if (d1 = h) then (     w := w - u1 ; 
     if (w->compareTo(0) < 0) then (     w := 0 ) else skip ) else skip ; 
     if (d2 = h) then (     w := w - u2 ; 
     if (w->compareTo(0) < 0) then (     w := 0 ) else skip ) else skip ; 
     h := h - 1 ) ; 
    OclFile["System.out"].println(w) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),T=sc.nextInt(),S=sc.nextInt();
    int[] a=new int[n],b=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
    }
    int[][] dp=new int[n][T+1];
    for(int j=b[0]; j<=T ; j++){
      dp[0][j]=dp[0][j-1];
      if(!(j-b[0]<S && S<j))dp[0][j]=a[0];
    }
    for(int i=1 ; i<n ; i++)for(int t=1 ; t<=T ; t++){
      dp[i][t]=Math.max(dp[i-1][t],dp[i][t-1]);
      if(b[i]<=t && !(t-b[i]<S && S<t))dp[i][t]=Math.max(dp[i][t],dp[i-1][t-b[i] ]+a[i]);
    }
    System.out.println(dp[n-1][T]);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
    var S : int ; S := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,T + 1)->collect(0)) ;
        var j : int ; j := b[0+1] ; while j <= T do ( (     dp[0+1][j+1] := dp[0+1][j - 1+1] ; 
     if (not((j - b[0+1] < S & S < j))) then     dp[0+1][j+1] := a[0+1] ; else skip )  ;     j := j + 1 ) ; 
        var i : int ; i := 1 ; while i < n do (         var t : int ; t := 1 ; while t <= T do ( (     dp[i+1][t+1] := Set{dp[i - 1+1][t+1], dp[i+1][t - 1+1]}->max() ; 
     if (b[i+1] <= t & not((t - b[i+1] < S & S < t))) then     dp[i+1][t+1] := Set{dp[i+1][t+1], dp[i - 1+1][t - b[i+1]+1] + a[i+1]}->max() ; else skip )  ;     t := t + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[n - 1+1][T+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    int[] b=new int[n];
    int[] c=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      b[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      c[i]=sc.nextInt();
    }
    Arrays.sort(a);
    Arrays.sort(b);
    Arrays.sort(c);
    long[] bc=new long[n];
    {
      int j=0 ;
      for(int i=0 ; i<n ; i++){
        while(j<n && b[i]>=c[j]){
          j++;
        }
        bc[i]=n-j ;
      }
    }
    long ret=0 ;
    for(int i=n-1 ; i>0 ; i--){
      bc[i-1]+=bc[i];
    }
    {
      int j=0 ;
      for(int i=0 ; i<n ; i++){
        while(j<n && a[i]>=b[j]){
          j++;
        }
        ret+=j<n ? bc[j] : 0 ;
      }
    }
    System.out.println(ret);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    c := c->sort() ; 
    var bc : Sequence(long) ; bc := Integer.subrange(1,n)->collect(0) ;
(     var j : int ; j := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     while (j < n & b[i+1] >= c[j+1]) do (     j := j + 1 ) ; 
     bc[i+1] := n - j )  ;     i := i + 1 ) ) 
    var ret : long ; ret := 0 ;
        var i : int ; i := n - 1 ; while i > 0 do ( (     bc[i - 1+1] := bc[i - 1+1]+(bc[i+1]) )  ;     i := i - 1 ) ; 
(     var j : int ; j := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     while (j < n & a[i+1] >= b[j+1]) do (     j := j + 1 ) ; 
     ret := ret+(if j < n then bc[j+1] else 0 endif) )  ;     i := i + 1 ) ) 
    OclFile["System.out"].println(ret) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskC solver=new TaskC();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskC {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int[] a=new int[n];
      int[] b=new int[n];
      int[] c=new int[n];
      for(int i=0 ; i<n ; ++i)a[i]=in.nextInt();
      for(int i=0 ; i<n ; ++i)b[i]=in.nextInt();
      for(int i=0 ; i<n ; ++i)c[i]=in.nextInt();
      Arrays.sort(a);
      Arrays.sort(b);
      Arrays.sort(c);
      long[] dp1=new long[n];
      Arrays.fill(dp1,0);
      int u=0 ;
      for(int d=0 ; d<n ; ++d){
        while(u<n && a[u]<b[d])++u ;
        if(d==0){
          dp1[d]=u ;
        }
        else {
          dp1[d]=dp1[d-1]+u ;
        }
      }
      u=0 ;
      long res=0 ;
      for(int d=0 ; d<n ; ++d){
        while(u<n && b[u]<c[d])++u ;
        if(u>0){
          res+=dp1[u-1];
        }
      }
      out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskC ; solver := TaskC.newTaskC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskC {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     b[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     c[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    c := c->sort() ; 
    var dp1 : Sequence(long) ; dp1 := Integer.subrange(1,n)->collect(0) ;
    dp1 := dp1->collect(0) ; 
    var u : int ; u := 0 ;
        var d : int ; d := 0 ; while d < n do ( (     while (u < n & a[u+1] < b[d+1]) do     u := u + 1 ; ; 
     if (d = 0) then (     dp1[d+1] := u ) else (     dp1[d+1] := dp1[d - 1+1] + u ) )  ;     d := d + 1 ) ; 
    u := 0 ; 
    var res : long ; res := 0 ;
        var d : int ; d := 0 ; while d < n do ( (     while (u < n & b[u+1] < c[d+1]) do     u := u + 1 ; ; 
     if (u > 0) then (     res := res+(dp1[u - 1+1]) ) else skip )  ;     d := d + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    int n=sc.nextInt();
    Integer[] a=new Integer[n];
    Integer[] b=new Integer[n];
    Integer[] c=new Integer[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      b[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      c[i]=sc.nextInt();
    }
    Arrays.sort(a);
    Arrays.sort(c);
    long ans=0,aa,cc ;
    for(int i=0 ; i<n ; i++){
      aa=~ Arrays.binarySearch(a,b[i],(x,y)->x.compareTo(y)>=0 ? 1 :-1);
      cc=n-~ Arrays.binarySearch(c,b[i],(x,y)->x.compareTo(y)>0 ? 1 :-1);
      ans+=aa*cc ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(null) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(null) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    c := c->sort() ; 
    var ans : long ; ans := 0 ;
    var aa : long ;
    var cc : long ;
        var i : int ; i := 0 ; while i < n do ( (     aa := -((a->indexOf(lambda (x , y) : OclAny in if x->compareTo(y) >= 0 then 1 else -1 endif) - 1) + 1) ; 
     cc := (n)->char2byte() - -((c->indexOf(lambda (x , y) : OclAny in if x->compareTo(y) > 0 then 1 else -1 endif) - 1) + 1) ; 
     ans := ans+(aa * cc) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=Integer.parseInt(sc.next());
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++)b[i]=Integer.parseInt(sc.next());
    int[] c=new int[n];
    for(int i=0 ; i<n ; i++)c[i]=Integer.parseInt(sc.next());
    Arrays.sort(a);
    Arrays.sort(b);
    Arrays.sort(c);
    long ret=0 ;
    int s=0,t=-1 ;
    for(int i=0 ; i<n ; i++){
      while(s<n && c[s]<=b[i])s++;
      while(t<n-1 && a[t+1]<b[i])t++;
      ret+=(long)(n-s)*(t+1);
    }
    System.out.println(ret);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (sc.getCurrent())->toInteger() ;  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     b[i+1] := (sc.getCurrent())->toInteger() ;  ;     i := i + 1 ) ; 
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     c[i+1] := (sc.getCurrent())->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    c := c->sort() ; 
    var ret : long ; ret := 0 ;
    var s : int ; s := 0 ;
    var t : int ; t := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     while (s < n & c[s+1] <= b[i+1]) do     s := s + 1 ; ; 
     while (t < n - 1 & a[t + 1+1] < b[i+1]) do     t := t + 1 ; ; 
     ret := ret+((n - s)->oclAsType(long) * (t + 1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ret) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int countDigits(int num){
    int cnt=0 ;
    while(num>0){
      cnt++;
      num/=10 ;
    }
    return cnt ;
  }
  public static int sumFromStart(int num,int n,int rem){
    num/=((int)Math.pow(10,rem));
    int sum=0 ;
    while(num>0){
      sum+=(num % 10);
      num/=10 ;
    }
    return sum ;
  }
  public static int sumFromEnd(int num,int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=(num % 10);
      num/=10 ;
    }
    return sum ;
  }
  public static float getAverage(int n,int k,int l){
    int totalDigits=countDigits(n);
    if(totalDigits<(k+l))return-1 ;
    int sum1=sumFromEnd(n,l);
    int sum2=sumFromStart(n,k,totalDigits-k);
    return((float)(sum1+sum2)/(float)(k+l));
  }
  public static void main(String args[]){
    int n=123456,k=2,l=3 ;
    System.out.print(getAverage(n,k,l));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countDigits( num : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     while (num > 0) do (     cnt := cnt + 1 ; 
     num := num/(10) ) ; 
     return cnt );
  static   operation sumFromStart( num : int, n : int, rem : int) : int
  pre: true
  post: true
  activity: (     num := num/((10->pow(rem)->oclAsType(int))) ; 
     var sum : int ; sum := 0 ;
     while (num > 0) do (     sum := sum+((num mod 10)) ; 
     num := num/(10) ) ; 
     return sum );
  static   operation sumFromEnd( num : int, n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+((num mod 10)) ; 
     num := num/(10) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation getAverage( n : int, k : int, l : int) : double
  pre: true
  post: true
  activity: (     var totalDigits : int ; totalDigits := countDigits(n) ;
     if (totalDigits < (k + l)) then     return -1 else skip ; 
    var sum1 : int ; sum1 := sumFromEnd(n, l) ;
    var sum2 : int ; sum2 := sumFromStart(n, k, totalDigits - k) ;
    return ((sum1 + sum2)->oclAsType(double) / (k + l)->oclAsType(double)) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 123456 ;
    var k : int ; k := 2 ;
    var l : int ; l := 3 ;
     OclFile["System.out"].print(getAverage(n, k, l)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class GFG {
  static int nthTerm(int n){
    int d=2,a1=0 ;
    int An=a1+(n-1)*d ;
    return(int)Math.pow(An,3);
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(nthTerm(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nthTerm( n : int) : int
  pre: true
  post: true
  activity: (     var d : int ; d := 2 ;
    var a1 : int ; a1 := 0 ;
     var An : int ; An := a1 + (n - 1) * d ;
     return An->pow(3)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(nthTerm(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  Scanner sc ;
  Main(){
    sc=new Scanner(System.in);
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
  int a,b ;
  boolean init(){
    a=sc.nextInt();
    b=sc.nextInt();
    if(a==0 && b==0)return false ;
    return true ;
  }
  ArrayList<Integer>factor(int n){
    ArrayList<Integer>ret=new ArrayList<Integer>();
    for(int i=2 ; i<=n ; i++){
      if(n % i==0){
        ret.add(i);
        while(n % i==0){
          n/=i ;
        }
      }
    }
    return ret ;
  }
  int key(int n){
    ArrayList<Integer>factors=factor(n);
    int sum=0 ;
    for(int f : factors){
      sum+=f ;
    }
    int biggest=factors.get(factors.size()-1);
    sum-=biggest ;
    return biggest-sum ;
  }
  void run(){
    while(init()){
      System.out.println(key(a)>key(b)? "a" : "b");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
   attribute a : int;
   operation init() : boolean
  pre: true
  post: true
  activity: (     a := sc.getCurrent()->toInteger() ; 
     b := sc.getCurrent()->toInteger() ; 
     if (a = 0 & b = 0) then     return false else skip ; 
     return true );
   operation factor( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ret : Sequence(int) ; ret := Sequence{} ;
         var i : int ; i := 2 ; while i <= n do ( (     if (n mod i = 0) then (     ret := ret->including(i) ; 
     while (n mod i = 0) do (     n := n/(i) ) ) else skip )  ;     i := i + 1 ) ; 
     return ret );
   operation key( n : int) : int
  pre: true
  post: true
  activity: (     var factors : Sequence(int) ; factors := factor(n) ;
     var sum : int ; sum := 0 ;
    for (f : factors) do ( (     sum := sum+(f) )  ) ; 
    var biggest : int ; biggest := factors->at(factors->size() - 1+1) ;
    sum := sum-(biggest) ; 
    return biggest - sum 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     while (init()) do (     OclFile["System.out"].println(if key(a) > key(b) then "a" else "b" endif) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Map.Entry ;
class Main {
  static int mod=(int)(Math.pow(10,9)+7);
  static List<ArrayList<Integer>>list=new ArrayList<ArrayList<Integer>>();
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    int[][] c=new int[H][W];
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        c[i][j]=sc.nextInt();
      }
    }
    StringBuffer ans=new StringBuffer();
    int cnt=0 ;
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        if(c[i][j] % 2==1){
          if(j==W-1){
            if(i!=H-1){
              c[i+1][j]++;
              ans.append(i+1);
              ans.append(" ");
              ans.append(j+1);
              ans.append(" ");
              ans.append(i+2);
              ans.append(" ");
              ans.append(j+1);
              ans.append("\n");
              cnt++;
            }
          }
          else {
            c[i][j+1]++;
            ans.append(i+1);
            ans.append(" ");
            ans.append(j+1);
            ans.append(" ");
            ans.append(i+1);
            ans.append(" ");
            ans.append(j+2);
            ans.append("\n");
            cnt++;
          }
        }
      }
    }
    System.out.println(cnt);
    System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := (10->pow(9) + 7)->oclAsType(int);
  static   attribute list : Sequence(Sequence(int)) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     c[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := StringLib.newString() ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (c[i+1][j+1] mod 2 = 1) then (     if (j = W - 1) then (     if (i /= H - 1) then (     c[i + 1+1][j+1] := c[i + 1+1][j+1] + 1 ; 
     ans := ans + StringLib.newString(i + 1) ; 
    ans := ans + StringLib.newString(" ") ; 
    ans := ans + StringLib.newString(j + 1) ; 
    ans := ans + StringLib.newString(" ") ; 
    ans := ans + StringLib.newString(i + 2) ; 
    ans := ans + StringLib.newString(" ") ; 
    ans := ans + StringLib.newString(j + 1) ; 
    ans := ans + StringLib.newString("\n") ; 
    cnt := cnt + 1 ; 
 ) else skip ) else (     c[i+1][j + 1+1] := c[i+1][j + 1+1] + 1 ; 
     ans := ans + StringLib.newString(i + 1) ; 
    ans := ans + StringLib.newString(" ") ; 
    ans := ans + StringLib.newString(j + 1) ; 
    ans := ans + StringLib.newString(" ") ; 
    ans := ans + StringLib.newString(i + 1) ; 
    ans := ans + StringLib.newString(" ") ; 
    ans := ans + StringLib.newString(j + 2) ; 
    ans := ans + StringLib.newString("\n") ; 
    cnt := cnt + 1 ; 
 ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
    OclFile["System.out"].print(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int height=sc.nextInt();
    int width=sc.nextInt();
    boolean oddCoin[][]=new boolean[height][width];
    for(int i=0 ; i<height ; i++){
      for(int j=0 ; j<width ; j++){
        oddCoin[i][j]=sc.nextInt()% 2==1 ;
      }
    }
    int count=0 ;
    ArrayList<String>output=new ArrayList<String>();
    for(int i=0 ; i<height-1 ; i++){
      for(int j=0 ; j<width ; j++){
        if(oddCoin[i][j]){
          count++;
          oddCoin[i][j]=! oddCoin[i][j];
          oddCoin[i+1][j]=! oddCoin[i+1][j];
          output.add((i+1)+" "+(j+1)+" "+(i+1+1)+" "+(j+1));
        }
      }
    }
    for(int j=0 ; j<width-1 ; j++){
      if(oddCoin[height-1][j]){
        count++;
        oddCoin[height-1][j]=! oddCoin[height-1][j];
        oddCoin[height-1][j+1]=! oddCoin[height-1][j+1];
        output.add(height+" "+(j+1)+" "+height+" "+(j+2));
      }
    }
    System.out.println(count);
    for(int i=0 ; i<output.size(); i++){
      System.out.println(output.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var height : int ; height := sc.getCurrent()->toInteger() ;
    var width : int ; width := sc.getCurrent()->toInteger() ;
    var oddCoin : Sequence(Sequence(boolean)) ; oddCoin := Integer.subrange(1,height)->collect(Integer.subrange(1,width)->collect(false)) ;
        var i : int ; i := 0 ; while i < height do ( (         var j : int ; j := 0 ; while j < width do ( (     oddCoin[i+1][j+1] := sc.getCurrent()->toInteger() mod 2 = 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var output : Sequence(String) ; output := Sequence{} ;
        var i : int ; i := 0 ; while i < height - 1 do ( (         var j : int ; j := 0 ; while j < width do ( (     if (oddCoin[i+1][j+1]) then (     count := count + 1 ; 
     oddCoin[i+1][j+1] := not(oddCoin[i+1][j+1]) ; 
     oddCoin[i + 1+1][j+1] := not(oddCoin[i + 1+1][j+1]) ; 
     output := output->including((i + 1) + " " + (j + 1) + " " + (i + 1 + 1) + " " + (j + 1)) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < width - 1 do ( (     if (oddCoin[height - 1+1][j+1]) then (     count := count + 1 ; 
     oddCoin[height - 1+1][j+1] := not(oddCoin[height - 1+1][j+1]) ; 
     oddCoin[height - 1+1][j + 1+1] := not(oddCoin[height - 1+1][j + 1+1]) ; 
     output := output->including(height + " " + (j + 1) + " " + height + " " + (j + 2)) ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(count) ; 
        var i : int ; i := 0 ; while i < output->size() do ( (     OclFile["System.out"].println(output->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int[][] a=new int[h][w];
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        a[i][j]=sc.nextInt();
      }
    }
    sc.close();
    String space=" " ;
    List<String>ans=new ArrayList<String>(h*w);
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w-1 ; j++){
        if(a[i][j] % 2==1){
          a[i][j]--;
          a[i][j+1]++;
          StringBuilder sb=new StringBuilder();
          sb.append(i+1).append(space).append(j+1).append(space).append(i+1).append(space).append(j+2);
          ans.add(sb.toString());
        }
      }
    }
    for(int i=0 ; i<h-1 ; i++){
      if(a[i][w-1] % 2==1){
        a[i][w-1]--;
        a[i+1][w-1]++;
        StringBuilder sb=new StringBuilder();
        sb.append(i+1).append(space).append(w).append(space).append(i+2).append(space).append(w);
        ans.add(sb.toString());
      }
    }
    System.out.println(ans.size());
    for(String s : ans){
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     a[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    var space : String ; space := " " ;
    var ans : Sequence(String) ; ans := Sequence{}->union(h * w) ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w - 1 do ( (     if (a[i+1][j+1] mod 2 = 1) then (     a[i+1][j+1] := a[i+1][j+1] - 1 ; 
     a[i+1][j + 1+1] := a[i+1][j + 1+1] + 1 ; 
    var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString(i + 1) + StringLib.newString(space) + StringLib.newString(j + 1) + StringLib.newString(space) + StringLib.newString(i + 1) + StringLib.newString(space) + StringLib.newString(j + 2) ; 
    ans := ans->including(sb+"") ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < h - 1 do ( (     if (a[i+1][w - 1+1] mod 2 = 1) then (     a[i+1][w - 1+1] := a[i+1][w - 1+1] - 1 ; 
     a[i + 1+1][w - 1+1] := a[i + 1+1][w - 1+1] + 1 ; 
    var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString(i + 1) + StringLib.newString(space) + StringLib.newString(w) + StringLib.newString(space) + StringLib.newString(i + 2) + StringLib.newString(space) + StringLib.newString(w) ; 
    ans := ans->including(sb+"") ; 
 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans->size()) ; 
    for (s : ans) do ( (     OclFile["System.out"].println(s) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    int T=sc.nextInt();
    int S=sc.nextInt();
    int[] A=new int[N];
    int[] B=new int[N];
    for(int i=0 ; i<N ; ++i){
      A[i]=sc.nextInt();
      B[i]=sc.nextInt();
    }
    int[][] dp=new int[T+1][N+1];
    for(int i=0 ; i<T ; ++i){
      for(int j=0 ; j<N ; ++j){
        int n=i+B[j];
        if((S<=i || n<=S)&& n<=T){
          dp[n][j+1]=Math.max(dp[n][j+1],dp[i][j]+A[j]);
        }
        dp[i][j+1]=Math.max(dp[i][j+1],dp[i][j]);
        dp[i+1][j+1]=Math.max(dp[i+1][j+1],dp[i][j+1]);
      }
    }
    int ans=0 ;
    for(int i=0 ; i<=T ; ++i){
      for(int j=0 ; j<=N ; ++j){
        ans=Math.max(ans,dp[i][j]);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
    var S : int ; S := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() ; 
     B[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,T + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < T do ( (         var j : int ; j := 0 ; while j < N do ( (     var n : int ; n := i + B[j+1] ;
     if ((S <= i or n <= S) & n <= T) then (     dp[n+1][j + 1+1] := Set{dp[n+1][j + 1+1], dp[i+1][j+1] + A[j+1]}->max() ) else skip ; 
     dp[i+1][j + 1+1] := Set{dp[i+1][j + 1+1], dp[i+1][j+1]}->max() ; 
     dp[i + 1+1][j + 1+1] := Set{dp[i + 1+1][j + 1+1], dp[i+1][j + 1+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i <= T do ( (         var j : int ; j := 0 ; while j <= N do ( (     ans := Set{ans, dp[i+1][j+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int[][] map=new int[h][w];
    ArrayList<String>list=new ArrayList<>();
    int sum=0 ;
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        map[i][j]=sc.nextInt();
      }
    }
    boolean jud=false ;
    for(int i=0 ; i<h ; i++){
      if(i % 2==0){
        for(int j=0 ; j<w ; j++){
          if(jud){
            if(j==0){
              list.add(i+" "+(j+1)+" "+(i+1)+" "+(j+1));
              sum++;
            }
            else {
              list.add((i+1)+" "+j+" "+(i+1)+" "+(j+1));
              sum++;
            }
          }
          if(map[i][j] % 2==1){
            jud=! jud ;
          }
        }
      }
      else {
        for(int j=w-1 ; j>=0 ; j--){
          if(jud){
            if(j==w-1){
              list.add(i+" "+(j+1)+" "+(i+1)+" "+(j+1));
              sum++;
            }
            else {
              list.add((i+1)+" "+(j+2)+" "+(i+1)+" "+(j+1));
              sum++;
            }
          }
          if(map[i][j] % 2==1){
            jud=! jud ;
          }
        }
      }
    }
    System.out.println(sum);
    for(String i : list){
      System.out.println(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    var list : Sequence(String) ; list := Sequence{} ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     map[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var jud : boolean ; jud := false ;
        var i : int ; i := 0 ; while i < h do ( (     if (i mod 2 = 0) then (         var j : int ; j := 0 ; while j < w do ( (     if (jud) then (     if (j = 0) then (     list := list->including(i + " " + (j + 1) + " " + (i + 1) + " " + (j + 1)) ; 
     sum := sum + 1 ) else (     list := list->including((i + 1) + " " + j + " " + (i + 1) + " " + (j + 1)) ; 
     sum := sum + 1 ) ) else skip ; 
     if (map[i+1][j+1] mod 2 = 1) then (     jud := not(jud) ) else skip )  ;     j := j + 1 ) ) else (         var j : int ; j := w - 1 ; while j >= 0 do ( (     if (jud) then (     if (j = w - 1) then (     list := list->including(i + " " + (j + 1) + " " + (i + 1) + " " + (j + 1)) ; 
     sum := sum + 1 ) else (     list := list->including((i + 1) + " " + (j + 2) + " " + (i + 1) + " " + (j + 1)) ; 
     sum := sum + 1 ) ) else skip ; 
     if (map[i+1][j+1] mod 2 = 1) then (     jud := not(jud) ) else skip )  ;     j := j - 1 ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
    for (i : list) do ( (     OclFile["System.out"].println(i) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.System.*;
import static java.lang.Math.*;
public class pre6 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int count=0 ;
    int n=obj.nextInt();
    for(int i=1 ; i<=n ; i++){
      for(int j=i+1 ; j<=n ; j++){
        int k=i ^ j ;
        if(k>j && k<=n &&(i+j)>k &&(i+k)>j &&(j+k)>i){
          count++;
        }
      }
    }
    out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre6 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var count : int ; count := 0 ;
    var n : int ; n := obj.nextInt() ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i + 1 ; while j <= n do ( (     var k : int ; k := MathLib.bitwiseXor(i,j) ;
     if (k > j & k <= n & (i + j) > k & (i + k) > j & (j + k) > i) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    out.println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class forest {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int c=0 ;
    int counter=0 ;
    for(int a=1 ; a<=n ; a++){
      for(int b=a ; b<=n ; b++){
        c=a ^ b ;
        if(c<=n &&(c<(a+b))&&(a ^ b ^ c)==0 && c>b){
          counter++;
        }
      }
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class forest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
    var counter : int ; counter := 0 ;
        var a : int ; a := 1 ; while a <= n do ( (         var b : int ; b := a ; while b <= n do ( (     c := MathLib.bitwiseXor(a,b) ; 
     if (c <= n & (c < (a + b)) & (MathLib.bitwiseXor(MathLib.bitwiseXor(a,b),c)) = 0 & c > b) then (     counter := counter + 1 ) else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Demo2 {
  public static void main(String[] args){
    int n,res=0 ;
    Scanner scanner=new Scanner(System.in);
    n=scanner.nextInt();
    for(int i=1 ; i<n ; i++){
      for(int j=i+1 ; j<=n ; j++){
        int k=i ^ j ;
        if(k<i+j && k+i>j && k<=n)res++;
      }
    }
    System.out.println(res/3);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Demo2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var res : int ; res := 0 ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := scanner.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := i + 1 ; while j <= n do ( (     var k : int ; k := MathLib.bitwiseXor(i,j) ;
     if (k < i + j & k + i > j & k <= n) then     res := res + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res / 3) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class div_2_572_a {
  public static void main(String args[]){
    FScanner in=new FScanner();
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt();
    String s=in.next();
    int c=0 ;
    for(int i=0 ; i<n ; i++){
      char ch=s.charAt(i);
      if(ch=='1')c++;
      else c--;
    }
    if(c!=0){
      out.println("1");
      out.println(s);
    }
    else {
      out.println("2");
      out.println(s.substring(0,1)+" "+s.substring(1));
    }
    out.close();
  }
  static class FScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer sb=new StringTokenizer("");
    String next(){
      while(! sb.hasMoreTokens()){
        try {
          sb=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
        }
      }
      return sb.nextToken();
    }
    String nextLine(){
      try {
        return br.readLine();
      }
      catch(IOException e){
      }
      return "" ;
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    int[] readArray(int n){
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    float nextFloat(){
      return Float.parseFloat(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class div{
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FScanner ; in := FScanner.newFScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.nextInt() ;
    var s : String ; s := in.next() ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var ch : String ; ch := s->at(i+1) ;
     if (ch = '1') then     c := c + 1 ; else     c := c - 1 ; )  ;     i := i + 1 ) ; 
    if (c /= 0) then (     skip ; 
     skip ) else (     skip ; 
     skip ) ;  
    skip ; 
 );
  static class FScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute sb : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(sb.hasNext())) do (     try (     sb := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ) ; 
     return sb.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do skip
     return "" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}
_572_a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FScanner ; in := FScanner.newFScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.nextInt() ;
    var s : String ; s := in.next() ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var ch : String ; ch := s->at(i+1) ;
     if (ch = '1') then     c := c + 1 ; else     c := c - 1 ; )  ;     i := i + 1 ) ; 
    if (c /= 0) then (     skip ; 
     skip ) else (     skip ; 
     skip ) ;  
    skip ; 
 );
  static class FScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute sb : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(sb.hasNext())) do (     try (     sb := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ) ; 
     return sb.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do skip
     return "" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int longestSubArray(int arr[],int n){
    boolean isZeroPresent=false ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==0){
        isZeroPresent=true ;
        break ;
      }
    }
    if(isZeroPresent)return n ;
    return 0 ;
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3,0,1,2,0 };
      int n=arr.length ;
      System.out.print(longestSubArray(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation longestSubArray( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var isZeroPresent : boolean ; isZeroPresent := false ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 0) then (     isZeroPresent := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (isZeroPresent) then     return n else skip ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,0,1,2,0} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(longestSubArray(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class HelloWorld {
  public static void solve(int n,int m,int k){
    System.out.println((n<=m && n<=k ? "Yes" : "No"));
  }
  public static void sol(int n){
    int ans=0 ;
    for(int i=1 ; i<n ; ++i){
      if(n % i==0){
        ans++;
      }
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    int cnt=0 ;
    for(int i=0 ; i<n ; ++i){
      if(s.charAt(i)=='1'){
        cnt++;
      }
    }
    if(cnt==n-cnt){
      System.out.println(2);
      String res=s.substring(1);
      System.out.println(s.charAt(0)+" "+res);
    }
    else {
      System.out.println(1);
      System.out.println(s);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation solve( n : int, m : int, k : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((if n <= m & n <= k then "Yes" else "No" endif)) );
  static   operation sol( n : int) : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     if (n mod i = 0) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = '1') then (     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (cnt = n - (cnt)->char2byte()) then (     OclFile["System.out"].println(2) ; 
     var res : String ; res := s.subrange(1+1,1) ;
     OclFile["System.out"].println(s->at(0+1) + " " + res) ) else (     OclFile["System.out"].println(1) ; 
     OclFile["System.out"].println(s) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printGP(int a,int r,int n){
    int curr_term ;
    for(int i=0 ; i<n ; i++){
      curr_term=a*(int)Math.pow(r,i);
      System.out.print(curr_term+" ");
    }
  }
  public static void main(String[] args){
    int a=2 ;
    int r=3 ;
    int n=5 ;
    printGP(a,r,n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printGP( a : int, r : int, n : int) : void
  pre: true
  post: true
  activity: (     var curr_term : int ;
         var i : int ; i := 0 ; while i < n do ( (     curr_term := a * r->pow(i)->oclAsType(int) ; 
     OclFile["System.out"].print(curr_term + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2 ;
     var r : int ; r := 3 ;
     var n : int ; n := 5 ;
     execute printGP(a, r, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void midpoint(int x1,int x2,int y1,int y2){
    System.out.print((x1+x2)/2+","+(y1+y2)/2);
  }
  public static void main(String[] args){
    int x1=-1,y1=2 ;
    int x2=3,y2=-6 ;
    midpoint(x1,x2,y1,y2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation midpoint( x1 : int, x2 : int, y1 : int, y2 : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print((x1 + x2) / 2 + "," + (y1 + y2) / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x1 : int ; x1 := -1 ;
    var y1 : int ; y1 := 2 ;
     var x2 : int ; x2 := 3 ;
    var y2 : int ; y2 := -6 ;
     execute midpoint(x1, x2, y1, y2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  static int ceilSearch(int arr[],int low,int high,int x){
    int mid ;
    if(x<=arr[low])return low ;
    if(x>arr[high])return-1 ;
    mid=(low+high)/2 ;
    if(arr[mid]==x)return mid ;
    else if(arr[mid]<x){
      if(mid+1<=high && x<=arr[mid+1])return mid+1 ;
      else return ceilSearch(arr,mid+1,high,x);
    }
    else {
      if(mid-1>=low && x>arr[mid-1])return mid ;
      else return ceilSearch(arr,low,mid-1,x);
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,2,8,10,10,12,19 };
      int n=arr.length ;
      int x=8 ;
      int index=ceilSearch(arr,0,n-1,x);
      if(index==-1)System.out.println("Ceiling of "+x+" doesn't exist in array");
      else System.out.println("ceiling of "+x+" is "+arr[index]);
    }
  }

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation ceilSearch( arr : Sequence(int), low : int, high : int, x : int) : int
  pre: true
  post: true
  activity: (     var mid : int ;
     if (x <= arr[low+1]) then     return low else skip ; 
    if (x > arr[high+1]) then     return -1 else skip ; 
    mid := (low + high) / 2 ; 
    if (arr[mid+1] = x) then     return mid else     if (arr[mid+1] < x) then (     if (mid + 1 <= high & x <= arr[mid + 1+1]) then     return mid + 1 else     return ceilSearch(arr, mid + 1, high, x) ) else (     if (mid - 1 >= low & x > arr[mid - 1+1]) then     return mid else     return ceilSearch(arr, low, mid - 1, x) ) ;  ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,8,10,10,12,19} ;
     var n : int ; n := arr->size() ;
    var x : int ; x := 8 ;
    var index : int ; index := ceilSearch(arr, 0, n - 1, x) ;
    if (index = -1) then     OclFile["System.out"].println("Ceiling of " + x + " doesn't exist in array") else     OclFile["System.out"].println("ceiling of " + x + " is " + arr[index+1]) ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Iterator ;
import java.util.Scanner ;
import java.util.Set ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    long[] a=new long[(1<<N)];
    for(int i=0 ; i<(1<<N); ++i)a[i]=scan.nextLong();
    PrintWriter out=new PrintWriter(System.out);
    long bef=0 ;
    for(int K=1 ; K<(1<<N); ++K){
      long max1=-1 ;
      long max2=-1 ;
      for(int j=K ; j>=0 ; --j){
        j &=K ;
        if(a[j]>max1){
          max2=max1 ;
          max1=a[j];
        }
        else if(a[j]>max2){
          max2=a[j];
        }
      }
      bef=Math.max(bef,max1+max2);
      out.println(bef);
    }
    out.flush();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,((1*(2->pow(N)))->oclAsType(long)))->collect(0) ;
        var i : int ; i := 0 ; while i < ((1*(2->pow(N)))->oclAsType(long)) do (     a[i+1] := scan.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var bef : long ; bef := 0 ;
        var K : int ; K := 1 ; while K < ((1*(2->pow(N)))->oclAsType(long)) do ( (     var max1 : long ; max1 := -1 ;
     var max2 : long ; max2 := -1 ;
        var j : int ; j := K ; while j >= 0 do ( (     j := MathLib.bitwiseAnd(j, K) ; 
     if (a[j+1] > max1) then (     max2 := max1 ; 
     max1 := a[j+1] ) else     if (a[j+1] > max2) then (     max2 := a[j+1] ) else skip ; )  ;     j := j - 1 ) ; 
    bef := Set{bef, max1 + max2}->max() ; 
    skip ; 
 )  ;     K := K + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Set ;
public final class p347 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p347().run());
  }
  private static final int LIMIT=10000000 ;
  public String run(){
    Set<Integer>possible=new HashSet<>();
    int[] primes=Library.listPrimes(LIMIT/2);
    for(int i=0,end=Library.sqrt(LIMIT); i<primes.length ; i++){
      int p=primes[i];
      if(p>end)break ;
      for(int j=i+1 ; j<primes.length ; j++){
        int q=primes[j];
        int lcm=p*q ;
        if(lcm>LIMIT)break ;
        int multLimit=LIMIT/lcm ;
        int multiplier=1 ;
        while(multiplier*p<=multLimit)multiplier*=p ;
        int maxMult=multiplier ;
        while(multiplier % p==0){
          multiplier/=p ;
          while(multiplier*q<=multLimit)multiplier*=q ;
          maxMult=Math.max(multiplier,maxMult);
        }
        possible.add(maxMult*lcm);
      }
    }
    long sum=0 ;
    for(int x : possible)sum+=x ;
    return Long.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p347 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p347.newp347().run()) );
  static    attribute LIMIT : int := 10000000;
   operation run() : String
  pre: true
  post: true
  activity: (     var possible : Set(int) ; possible := Set{} ;
     var primes : Sequence(int) ; primes := Library.listPrimes(LIMIT / 2) ;
        var i : int ; i := 0 ;
    var end : int ; end := Library.sqrt(LIMIT) ; while i < primes->size() do ( (     var p : int ; p := primes[i+1] ;
     if (p > end) then     break else skip ; 
         var j : int ; j := i + 1 ; while j < primes->size() do ( (     var q : int ; q := primes[j+1] ;
     var lcm : int ; lcm := p * q ;
    if (lcm > LIMIT) then     break else skip ; 
    var multLimit : int ; multLimit := LIMIT / lcm ;
    var multiplier : int ; multiplier := 1 ;
    while (multiplier * p <= multLimit) do     multiplier := multiplier*(p) ; ; 
    var maxMult : int ; maxMult := multiplier ;
    while (multiplier mod p = 0) do (     multiplier := multiplier/(p) ; 
     while (multiplier * q <= multLimit) do     multiplier := multiplier*(q) ; ; 
     maxMult := Set{multiplier, maxMult}->max() ) ; 
    possible := possible->including(maxMult * lcm) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    for (x : possible) do (     sum := sum+(x) ;  ) ; 
    return ((sum) + "") 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] h=new int[n];
    for(int i=0 ; i<n ; i++)h[i]=sc.nextInt();
    int count=0 ;
    for(int i=0 ; i<n ; i++)if(h[i]>=k)count++;
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var h : Sequence(int) ; h := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     h[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (h[i+1] >= k) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      if(x>=k)count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x >= k) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    System.out.println(IntStream.range(0,N).filter(i->sc.nextInt()>=K).count());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(Integer.subrange(0, N-1)->select( _x1 | (lambda i : OclAny in sc.getCurrent()->toInteger() >= K)->apply(_x1) )->size()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  final int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    final int MAX=1000*1000+1 ;
    boolean isPrime[]=new boolean[MAX];
    Arrays.fill(isPrime,true);
    int[] primes=new int[MAX];
    int idx=0 ;
    for(int i=2 ; i<MAX ; i++){
      if(isPrime[i]){
        primes[idx++]=i ;
        for(int j=i+i ; j<MAX ; j+=i){
          isPrime[j]=false ;
        }
      }
    }
    while(true){
      int a=sc.nextInt();
      int b=sc.nextInt();
      if((a | b)==0)break ;
      int i=0 ;
      int sum=0 ;
      int last=0 ;
      int a_key=0 ;
      while(true){
        if(primes[i]>a || primes[i]==0){
          a_key=last-sum ;
          break ;
        }
        if(a % primes[i]==0){
          sum+=last ;
          last=primes[i];
        }
        i++;
      }
      sum=0 ;
      last=0 ;
      i=0 ;
      int b_key=0 ;
      while(true){
        if(primes[i]>b || primes[i]==0){
          b_key=last-sum ;
          break ;
        }
        if(b % primes[i]==0){
          sum+=last ;
          last=primes[i];
        }
        i++;
      }
      System.out.println(a_key>b_key ? "a" : "b");
    }
  }
  public static void main(String[] args)throws Exception {
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var MAX : int ; MAX := 1000 * 1000 + 1 ;
    var isPrime : Sequence(boolean) ; isPrime := Integer.subrange(1,MAX)->collect(false) ;
    isPrime := isPrime->collect(true) ; 
    var primes : Sequence(int) ; primes := Integer.subrange(1,MAX)->collect(0) ;
    var idx : int ; idx := 0 ;
        var i : int ; i := 2 ; while i < MAX do ( (     if (isPrime[i+1]) then (      primes[idx+1] := i  ; idx := idx + 1 ; 
         var j : int ; j := i + i ; while j < MAX do ( (     isPrime[j+1] := false )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    while (true) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(a,b)) = 0) then     break else skip ; 
    var i : int ; i := 0 ;
    var sum : int ; sum := 0 ;
    var last : int ; last := 0 ;
    var a_key : int ; a_key := 0 ;
    while (true) do (     if (primes[i+1] > a or primes[i+1] = 0) then (     a_key := last - sum ; 
     break ) else skip ; 
     if (a mod primes[i+1] = 0) then (     sum := sum+(last) ; 
     last := primes[i+1] ) else skip ; 
     i := i + 1 ) ; 
    sum := 0 ; 
    last := 0 ; 
    i := 0 ; 
    var b_key : int ; b_key := 0 ;
    while (true) do (     if (primes[i+1] > b or primes[i+1] = 0) then (     b_key := last - sum ; 
     break ) else skip ; 
     if (b mod primes[i+1] = 0) then (     sum := sum+(last) ; 
     last := primes[i+1] ) else skip ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println(if a_key > b_key then "a" else "b" endif) ; 
 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Solver {
  private final int K ;
  Solver(Scanner in){
    int N=in.nextInt();
    K=in.nextInt();
    int count=0 ;
    for(int i=0 ; i<N ; i++){
      if(in.nextInt()>=K)count++;
    }
    System.out.println(count);
  }
  void solve(){
  }
}
class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    new Solver(in).solve();
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solver {
   attribute K : int;
   static operation newSolver( in : OclFile) : Solver
  pre: true
  post: true
  activity:
  ( var self : Solver ;
    self := createSolver();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     var N : int ; N := in.nextInt() ;
     K := in.nextInt() ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (in.nextInt() >= K) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: skip;
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Solver.newSolver(in).solve() ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] h=new int[n];
    int result=0 ;
    for(int i=0 ; i<n ; i++){
      h[i]=sc.nextInt();
      if(h[i]>=k)result++;
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var h : Sequence(int) ; h := Integer.subrange(1,n)->collect(0) ;
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     h[i+1] := sc.getCurrent()->toInteger() ; 
     if (h[i+1] >= k) then     result := result + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Improve {
  static boolean isVowel(char c){
    String vowel="aeiou" ;
    for(int i=0 ; i<vowel.length(); ++i)if(vowel.charAt(i)==c)return true ;
    return false ;
  }
  static boolean printRLE(String str,String typed){
    int n=str.length(),m=typed.length();
    int j=0 ;
    for(int i=0 ; i<n ; i++){
      if(str.charAt(i)!=typed.charAt(j))return false ;
      if(isVowel(str.charAt(i))==false){
        j++;
        continue ;
      }
      int count1=1 ;
      while(i<n-1 && str.charAt(i)==str.charAt(i+1)){
        count1++;
        i++;
      }
      int count2=1 ;
      while(j<m-1 && typed.charAt(j)==str.charAt(i)){
        count2++;
        j++;
      }
      if(count1>count2)return false ;
    }
    return true ;
  }
  public static void main(String args[]){
    String name="alex",typed="aaalaeex" ;
    if(printRLE(name,typed))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class Improve {
  static   operation isVowel( c : String) : boolean
  pre: true
  post: true
  activity: (     var vowel : String ; vowel := "aeiou" ;
         var i : int ; i := 0 ; while i < vowel->size() do (     if (vowel->at(i+1) = c) then     return true else skip ;  ;     i := i + 1 ) ; 
     return false );
  static   operation printRLE( str : String, typed : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
    var m : int ; m := typed->size() ;
     var j : int ; j := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (str->at(i+1) /= typed->at(j+1)) then     return false else skip ; 
     if (isVowel(str->at(i+1)) = false) then (     j := j + 1 ; 
     continue ) else skip ; 
    var count1 : int ; count1 := 1 ;
    while (i < n - 1 & str->at(i+1) = str->at(i + 1+1)) do (     count1 := count1 + 1 ; 
     i := i + 1 ) ; 
    var count2 : int ; count2 := 1 ;
    while (j < m - 1 & typed->at(j+1) = str->at(i+1)) do (     count2 := count2 + 1 ; 
     j := j + 1 ) ; 
    if (count1 > count2) then     return false else skip ; 
 )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var name : String ; name := "alex" ;
    var typed : String ; typed := "aaalaeex" ;
     if (printRLE(name, typed)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int N=2 ;
  static Boolean isVowel(char ch){
    return(ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u');
  }
  static void performQueries(String str,int len,int queries[][],int q){
    int[] pre=new int[len];
    if(isVowel(str.charAt(0)))pre[0]=1 ;
    else pre[0]=0 ;
    for(int i=1 ; i<len ; i++){
      if(isVowel(str.charAt(i)))pre[i]=1+pre[i-1];
      else pre[i]=pre[i-1];
    }
    for(int i=0 ; i<q ; i++){
      if(queries[i][0]==0){
        System.out.println(pre[queries[i][1] ]);
      }
      else {
        System.out.println((pre[queries[i][1] ]-pre[queries[i][0]-1]));
      }
    }
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    int len=str.length();
    int queries[][]={
      {
        1,3 },{
          2,4 },{
            1,9 }
          };
          int q=queries.length ;
          performQueries(str,len,queries,q);
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute N : int := 2;
  static   operation isVowel( ch : String) : Boolean
  pre: true
  post: true
  activity: (     return (ch = 'a' or ch = 'e' or ch = 'i' or ch = 'o' or ch = 'u') );
  static   operation performQueries( str : String, len : int, queries : Sequence(Sequence(int)), q : int) : void
  pre: true
  post: true
  activity: (     var pre : Sequence(int) ; pre := Integer.subrange(1,len)->collect(0) ;
     if (isVowel(str->at(0+1))) then     pre[0+1] := 1 else     pre[0+1] := 0 ; ;  
         var i : int ; i := 1 ; while i < len do ( (     if (isVowel(str->at(i+1))) then     pre[i+1] := 1 + pre[i - 1+1] ; else     pre[i+1] := pre[i - 1+1] ; )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < q do ( (     if (queries[i+1][0+1] = 0) then (     OclFile["System.out"].println(pre[queries[i+1][1+1]+1]) ) else (     OclFile["System.out"].println((pre[queries[i+1][1+1]+1] - pre[queries[i+1][0+1] - 1+1])) ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var len : int ; len := str->size() ;
    var queries : Sequence(Sequence(int)) ; queries := Sequence{Sequence{1,3},Sequence{2,4},Sequence{1,9}} ;
    var q : int ; q := queries->size() ;
    execute performQueries(str, len, queries, q) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static final int MAX_CHAR=26 ;
  static boolean arekAnagrams(String str1,String str2,int k){
    int n=str1.length();
    if(str2.length()!=n)return false ;
    int[] count1=new int[MAX_CHAR];
    int[] count2=new int[MAX_CHAR];
    int count=0 ;
    for(int i=0 ; i<n ; i++)count1[str1.charAt(i)-'a']++;
    for(int i=0 ; i<n ; i++)count2[str2.charAt(i)-'a']++;
    for(int i=0 ; i<MAX_CHAR ; i++)if(count1[i]>count2[i])count=count+Math.abs(count1[i]-count2[i]);
    return(count<=k);
  }
  public static void main(String args[]){
    String str1="anagram" ;
    String str2="grammar" ;
    int k=2 ;
    if(arekAnagrams(str1,str2,k))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX_CHAR : int := 26;
  static   operation arekAnagrams( str1 : String, str2 : String, k : int) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := str1->size() ;
     if (str2->size() /= n) then     return false else skip ; 
    var count1 : Sequence(int) ; count1 := Integer.subrange(1,MAX_CHAR)->collect(0) ;
    var count2 : Sequence(int) ; count2 := Integer.subrange(1,MAX_CHAR)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do (     count1[str1->at(i+1) - ('a')->char2byte()+1] := count1[str1->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     count2[str2->at(i+1) - ('a')->char2byte()+1] := count2[str2->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < MAX_CHAR do (     if (count1[i+1] > count2[i+1]) then     count := count + if count1[i+1] - count2[i+1] < 0 then -(count1[i+1] - count2[i+1]) else count1[i+1] - count2[i+1] endif ; else skip ;  ;     i := i + 1 ) ; 
    return (count <= k) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "anagram" ;
     var str2 : String ; str2 := "grammar" ;
     var k : int ; k := 2 ;
     if (arekAnagrams(str1, str2, k)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int[] BitsSetTable256=new int[256];
  public static void initialize(){
    BitsSetTable256[0]=0 ;
    for(int i=0 ; i<256 ; i++){
      BitsSetTable256[i]=(i & 1)+BitsSetTable256[i/2];
    }
  }
  public static int countSetBits(int n){
    return(BitsSetTable256[n & 0xff]+BitsSetTable256[(n>>8)& 0xff]+BitsSetTable256[(n>>16)& 0xff]+BitsSetTable256[n>>24]);
  }
  public static void main(String[] args){
    initialize();
    int n=9 ;
    System.out.print(countSetBits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute BitsSetTable256 : Sequence(int) := Integer.subrange(1,256)->collect(0);
  static   operation initialize() : void
  pre: true
  post: true
  activity: (     BitsSetTable256[0+1] := 0 ; 
         var i : int ; i := 0 ; while i < 256 do ( (     BitsSetTable256[i+1] := (MathLib.bitwiseAnd(i,1)) + BitsSetTable256[i / 2+1] )  ;     i := i + 1 ) );
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     return (BitsSetTable256[n & 0xff+1] + BitsSetTable256[((n/(2->pow(8)))->oclAsType(long)) & 0xff+1] + BitsSetTable256[((n/(2->pow(16)))->oclAsType(long)) & 0xff+1] + BitsSetTable256[(n/(2->pow(24)))->oclAsType(long)+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute initialize() ; 
     var n : int ; n := 9 ;
     OclFile["System.out"].print(countSetBits(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    PriorityQueue<Long>qH=new PriorityQueue<>();
    PriorityQueue<Long>qW=new PriorityQueue<>();
    for(int i=0 ; i<h ; i++){
      qH.add(sc.nextLong());
    }
    for(int i=0 ; i<h ; i++){
      qW.add(sc.nextLong());
    }
    long total=0 ;
    while(qH.size()>0 && qW.size()>0){
      if(qH.peek()>qW.peek()){
        total+=qH.size()*qW.poll();
      }
      else {
        total+=qW.size()*qH.poll();
      }
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var qH : Sequence(long) ; qH := Sequence{} ;
    var qW : Sequence(long) ; qW := Sequence{} ;
        var i : int ; i := 0 ; while i < h do ( (     qH := qH->including(sc.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < h do ( (     qW := qW->including(sc.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    var total : long ; total := 0 ;
    while (qH->size() > 0 & qW->size() > 0) do (     if (qH->min() > qW->min()) then (     total := total+(qH->size() * qW->min()) ) else (     total := total+(qW->size() * qH->min()) ) ) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countSwap(String str){
    int n=str.length();
    char s[]=str.toCharArray();
    int count=0 ;
    for(int i=0 ; i<n/2 ; i++){
      int left=i ;
      int right=n-left-1 ;
      while(left<right){
        if(s[left]==s[right]){
          break ;
        }
        else {
          right--;
        }
      }
      if(left==right){
        return-1 ;
      }
      else {
        for(int j=right ; j<n-left-1 ; j++){
          char t=s[j];
          s[j]=s[j+1];
          s[j+1]=t ;
          count++;
        }
      }
    }
    return count ;
  }
  public static void main(String[] args){
    String s="geeksfgeeks" ;
    int count=countSwap(s);
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSwap( str : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var s : Sequence(String) ; s := str->characters() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n / 2 do ( (     var left : int ; left := i ;
     var right : int ; right := n - left - 1 ;
     while (left < right) do (     if (s[left+1] = s[right+1]) then (     break ) else (     right := right - 1 ) ) ; 
     if (left = right) then (     return -1 ) else (         var j : int ; j := right ; while j < n - left - 1 do ( (     var t : String ; t := s[j+1] ;
     s[j+1] := s[j + 1+1] ; 
     s[j + 1+1] := t ; 
     count := count + 1 )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksfgeeks" ;
     var count : int ; count := countSwap(s) ;
     OclFile["System.out"].println(count) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSC(int N){
    int res=(int)Math.sqrt(N)+(int)Math.cbrt(N)-(int)(Math.sqrt(Math.cbrt(N)));
    return res ;
  }
  public static void main(String[] args){
    int N=20 ;
    System.out.println("Number of squares "+"and cubes is "+countSC(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSC( N : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := (N)->sqrt()->oclAsType(int) + (N)->cbrt()->oclAsType(int) - (((N)->cbrt())->sqrt())->oclAsType(int) ;
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 20 ;
     OclFile["System.out"].println("Number of squares " + "and cubes is " + countSC(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.HashMap ;
import java.util.Vector ;
class GFG {
  static String lucas_sequence(String s,int n){
    HashMap<Character,Integer>m=new HashMap<>();
    for(int i=0 ; i<n ; i++)m.put(s.charAt(i),m.get(s.charAt(i))==null ? 1 : m.get(s.charAt(i))+1);
    Vector<Integer>v1=new Vector<>();
    Vector<Integer>v2=new Vector<>();
    for(HashMap.Entry<Character,Integer>entry : m.entrySet())v1.add(entry.getValue());
    Collections.sort(v1);
    if(v1.elementAt(0)==1 && v1.elementAt(1)==2){
      v1.set(0,2);
      v1.set(1,1);
    }
    else return "NO" ;
    int a=2,b=1 ;
    int c ;
    v2.add(a);
    v2.add(b);
    for(int i=0 ; i<v1.size()-2 ; i++){
      v2.add(a+b);
      c=a+b ;
      a=b ;
      b=c ;
    }
    int flag=1 ;
    for(int i=0 ; i<v1.size(); i++){
      if(v1.elementAt(i)!=v2.elementAt(i)){
        flag=0 ;
        break ;
      }
    }
    if(flag==1)return "YES" ;
    else return "NO" ;
  }
  public static void main(String[] args){
    String s="oooeeeeqkk" ;
    int n=s.length();
    System.out.println(lucas_sequence(s,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation lucas_sequence( s : String, n : int) : String
  pre: true
  post: true
  activity: (     var m : Map(String,int) ; m := Map{} ;
         var i : int ; i := 0 ; while i < n do (     m := m->union(Map{s->at(i+1) |-> if m->at(s->at(i+1)) = null then 1 else m->at(s->at(i+1)) + 1 endif}) ;  ;     i := i + 1 ) ; 
    var v1 : Sequence(int) ; v1 := Sequence{} ;
    var v2 : Sequence(int) ; v2 := Sequence{} ;
    for (entry : m->asSet()) do (     v1 := v1->including(entry.getValue()) ;  ) ; 
    v1 := v1->sort() ; 
    if (v1->at(0+1) = 1 & v1->at(1+1) = 2) then (     v1 := v1.setAt(0+1,2) ; 
     v1 := v1.setAt(1+1,1) ) else     return "NO" ;  
    var a : int ; a := 2 ;
    var b : int ; b := 1 ;
    var c : int ;
    v2 := v2->including(a) ; 
    v2 := v2->including(b) ; 
        var i : int ; i := 0 ; while i < v1->size() - 2 do ( (     v2 := v2->including(a + b) ; 
     c := a + b ; 
     a := b ; 
     b := c )  ;     i := i + 1 ) ; 
    var flag : int ; flag := 1 ;
        var i : int ; i := 0 ; while i < v1->size() do ( (     if (v1->at(i+1) /= v2->at(i+1)) then (     flag := 0 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 1) then     return "YES" else     return "NO" ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "oooeeeeqkk" ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].println(lucas_sequence(s, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int pm=1000000 ;
    boolean[] prime=new boolean[pm+1000];
    for(int i=2 ; i<=pm ; i++)prime[i]=true ;
    for(int i=2 ; i<=pm+1 ; i++){
      for(int j=i+i ; j<=pm ; j+=i){
        prime[j]=false ;
      }
    }
    while(true){
      int[] in=new int[2];
      in[0]=sc.nextInt();
      in[1]=sc.nextInt();
      if(in[0]==0 && in[1]==0)break ;
      int[] m=new int[2];
      for(int i=0 ; i<2 ; i++){
        int max=-1 ;
        for(int j=in[i]; j>1 ; j--){
          if(prime[j] && in[i] % j==0){
            if(max==-1)max=j ;
            else m[i]+=j ;
          }
        }
        m[i]=max-m[i];
      }
      if(m[0]>m[1])System.out.println("a");
      else System.out.println("b");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pm : int ; pm := 1000000 ;
    var prime : Sequence(boolean) ; prime := Integer.subrange(1,pm + 1000)->collect(false) ;
        var i : int ; i := 2 ; while i <= pm do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= pm + 1 do ( (         var j : int ; j := i + i ; while j <= pm do ( (     prime[j+1] := false )  ;     j := j+(i) ) )  ;     i := i + 1 ) ; 
    while (true) do (     var in : Sequence(int) ; in := Integer.subrange(1,2)->collect(0) ;
     in[0+1] := sc.getCurrent()->toInteger() ; 
    in[1+1] := sc.getCurrent()->toInteger() ; 
    if (in[0+1] = 0 & in[1+1] = 0) then     break else skip ; 
    var m : Sequence(int) ; m := Integer.subrange(1,2)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 do ( (     var max : int ; max := -1 ;
         var j : int ; j := in[i+1] ; while j > 1 do ( (     if (prime[j+1] & in[i+1] mod j = 0) then (     if (max = -1) then     max := j ; else     m[i+1] := m[i+1]+(j) ; ) else skip )  ;     j := j - 1 ) ; 
     m[i+1] := max - m[i+1] )  ;     i := i + 1 ) ; 
    if (m[0+1] > m[1+1]) then     OclFile["System.out"].println("a") else     OclFile["System.out"].println("b") ; ;  
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int findRepeatFirstN2(String s){
    int p=-1,i,j ;
    for(i=0 ; i<s.length(); i++){
      for(j=i+1 ; j<s.length(); j++){
        if(s.charAt(i)==s.charAt(j)){
          p=i ;
          break ;
        }
      }
      if(p!=-1)break ;
    }
    return p ;
  }
  static public void main(String[] args){
    String str="geeksforgeeks" ;
    int pos=findRepeatFirstN2(str);
    if(pos==-1)System.out.println("Not found");
    else System.out.println(str.charAt(pos));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findRepeatFirstN2( s : String) : int
  pre: true
  post: true
  activity: (     var p : int ; p := -1 ;
    var i : int ;
    var j : int ;
         i := 0 ; while i < s->size() do ( (         j := i + 1 ; while j < s->size() do ( (     if (s->at(i+1) = s->at(j+1)) then (     p := i ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (p /= -1) then     break else skip )  ;     i := i + 1 ) ; 
     return p );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var pos : int ; pos := findRepeatFirstN2(str) ;
     if (pos = -1) then     OclFile["System.out"].println("Not found") ; else     OclFile["System.out"].println(str->at(pos+1)) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void relativeComplement(int arr1[],int arr2[],int n,int m){
    int i=0,j=0 ;
    while(i<n && j<m){
      if(arr1[i]<arr2[j]){
        System.out.print(arr1[i]+" ");
        i++;
      }
      else if(arr1[i]>arr2[j]){
        j++;
      }
      else if(arr1[i]==arr2[j]){
        i++;
        j++;
      }
    }
    while(i<n)System.out.print(arr1[i]+" ");
  }
  public static void main(String[] args){
    int arr1[]={
      3,6,10,12,15 };
      int arr2[]={
        1,3,5,10,16 };
        int n=arr1.length ;
        int m=arr2.length ;
        relativeComplement(arr1,arr2,n,m);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation relativeComplement( arr1 : Sequence(int), arr2 : Sequence(int), n : int, m : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var j : int ; j := 0 ;
     while (i < n & j < m) do (     if (arr1[i+1] < arr2[j+1]) then (     OclFile["System.out"].print(arr1[i+1] + " ") ; 
     i := i + 1 ) else     if (arr1[i+1] > arr2[j+1]) then (     j := j + 1 ) else     if (arr1[i+1] = arr2[j+1]) then (     i := i + 1 ; 
     j := j + 1 ) else skip ; ;  ) ; 
     while (i < n) do     OclFile["System.out"].print(arr1[i+1] + " ") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{3,6,10,12,15} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{1,3,5,10,16} ;
    var n : int ; n := arr1->size() ;
    var m : int ; m := arr2->size() ;
    execute relativeComplement(arr1, arr2, n, m) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Solution {
  public int lengthOfLongestSubstring(String s){
    int[] charMap=new int[256];
    Arrays.fill(charMap,-1);
    int i=0,maxLen=0 ;
    for(int j=0 ; j<s.length(); j++){
      if(charMap[s.charAt(j)]>=i){
        i=charMap[s.charAt(j)]+1 ;
      }
      charMap[s.charAt(j)]=j ;
      maxLen=Math.max(j-i+1,maxLen);
    }
    return maxLen ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation lengthOfLongestSubstring( s : String) : int
  pre: true
  post: true
  activity: (     var charMap : Sequence(int) ; charMap := Integer.subrange(1,256)->collect(0) ;
     charMap := charMap->collect(-1) ; 
    var i : int ; i := 0 ;
    var maxLen : int ; maxLen := 0 ;
        var j : int ; j := 0 ; while j < s->size() do ( (     if (charMap[s->at(j+1)+1] >= i) then (     i := charMap[s->at(j+1)+1] + 1 ) else skip ; 
     charMap[s->at(j+1)+1] := j ; 
     maxLen := Set{j - i + 1, maxLen}->max() )  ;     j := j + 1 ) ; 
    return maxLen 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int arr[]=new int[n];
      int arr1[]=new int[m];
      for(int i=0 ; i<n ; i++){
        arr1[sc.nextInt()% m]++;
      }
      int ans=0 ;
      if(arr1[0]>0)ans++;
      for(int i=1 ; i<=m/2 ; i++){
        int temp=Math.abs(arr1[i]-arr1[m-i]);
        if(temp==0 && arr1[i]!=0)ans++;
        else ans+=temp ;
      }
      System.out.println(ans);
    }
  }
  public static boolean isPowerOfTen(long input){
    if(input % 10!=0 || input==0){
      return false ;
    }
    if(input==10){
      return true ;
    }
    return isPowerOfTen(input/10);
  }
  static boolean isPrime(long n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static long gcd(long a,long b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static long lcm(long a,long b){
    return(a/gcd(a,b))*b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr1[sc.getCurrent()->toInteger() mod m+1] := arr1[sc.getCurrent()->toInteger() mod m+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    if (arr1[0+1] > 0) then     ans := ans + 1 ; else skip ; 
        var i : int ; i := 1 ; while i <= m / 2 do ( (     var temp : int ; temp := if arr1[i+1] - arr1[m - i+1] < 0 then -(arr1[i+1] - arr1[m - i+1]) else arr1[i+1] - arr1[m - i+1] endif ;
     if (temp = 0 & arr1[i+1] /= 0) then     ans := ans + 1 ; else     ans := ans+(temp) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
  static   operation isPowerOfTen( input : long) : boolean
  pre: true
  post: true
  activity: (     if (input mod 10 /= 0 or input = 0) then (     return false ) else skip ; 
     if (input = 10) then (     return true ) else skip ; 
     return isPowerOfTen(input / 10) );
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a / gcd(a, b)) * b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long mod=(long)(1e9+7);
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),m=in.nextInt(),k=in.nextInt()+1 ;
    int a[]=new int[n];
    ArrayList<Integer>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      list.add(in.nextInt());
    }
    Collections.sort(list);
    int max=list.get(n-1),min=list.get(n-2);
    long div=m/k ;
    long sub=m-div ;
    sub=sub*max ;
    div*=min ;
    long sum=div+sub ;
    pw.println(sum);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := (1e9 + 7)->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() + 1 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var max : int ; max := list->at(n - 1+1) ;
    var min : int ; min := list->at(n - 2+1) ;
    var div : long ; div := m / k ;
    var sub : long ; sub := m - div ;
    sub := sub * max ; 
    div := div*(min) ; 
    var sum : long ; sum := div + sub ;
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MathsSecondAttempt {
  public static void main(String[] args){
    Emotes();
  }
  public static void Emotes(){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    int k=scan.nextInt();
    int largest=Integer.MIN_VALUE ;
    int larger=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      int x=scan.nextInt();
      if(x>largest){
        larger=largest ;
        largest=x ;
      }
      else if(x>larger)larger=x ;
    }
    long minusage=m/(k+1);
    long maxusage=m-minusage ;
    long out=(maxusage*largest)+(minusage*larger);
    System.out.println(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MathsSecondAttempt {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute Emotes() );
  static   operation Emotes() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var largest : int ; largest := -2147483648 ;
    var larger : int ; larger := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := scan.getCurrent()->toInteger() ;
     if (x > largest) then (     larger := largest ; 
     largest := x ) else     if (x > larger) then     larger := x ; else skip ; )  ;     i := i + 1 ) ; 
    var minusage : long ; minusage := m / (k + 1) ;
    var maxusage : long ; maxusage := m - minusage ;
    var out : long ; out := (maxusage * largest) + (minusage * larger) ;
    OclFile["System.out"].println(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static double floatError(double no){
    double sum=0.0 ;
    for(int i=0 ; i<10 ; i++){
      sum=sum+no ;
    }
    return sum ;
  }
  public static void main(String[] args){
    System.out.println(floatError(0.1));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation floatError( no : double) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0.0 ;
         var i : int ; i := 0 ; while i < 10 do ( (     sum := sum + no )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(floatError(0.1)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int H=scan.nextInt();
    int W=scan.nextInt();
    long A[]=new long[H+1];
    long B[]=new long[W+1];
    A[0]=0 ;
    for(int i=1 ; i<=H ; i++){
      A[i]=-scan.nextInt();
    }
    B[0]=0 ;
    for(int i=1 ; i<=W ; i++){
      B[i]=-scan.nextInt();
    }
    Arrays.sort(A);
    Arrays.sort(B);
    int pos1=0,pos2=0 ;
    long ans=0 ;
    for(int loop=0 ; loop<H+W ; loop++){
      if(A[pos1]<B[pos2]){
        ans+=pos2*A[pos1];
        pos1+=1 ;
      }
      else {
        ans+=pos1*B[pos2];
        pos2+=1 ;
      }
    }
    System.out.println(-ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := scan.getCurrent()->toInteger() ;
    var W : int ; W := scan.getCurrent()->toInteger() ;
    var A : Sequence(long) ; A := Integer.subrange(1,H + 1)->collect(0) ;
    var B : Sequence(long) ; B := Integer.subrange(1,W + 1)->collect(0) ;
    A[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= H do ( (     A[i+1] := -scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    B[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= W do ( (     B[i+1] := -scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    B := B->sort() ; 
    var pos1 : int ; pos1 := 0 ;
    var pos2 : int ; pos2 := 0 ;
    var ans : long ; ans := 0 ;
        var loop : int ; loop := 0 ; while loop < H + W do ( (     if (A[pos1+1] < B[pos2+1]) then (     ans := ans+(pos2 * A[pos1+1]) ; 
     pos1 := pos1+(1) ) else (     ans := ans+(pos1 * B[pos2+1]) ; 
     pos2 := pos2+(1) ) )  ;     loop := loop + 1 ) ; 
    OclFile["System.out"].println(-ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int oddFib(int n){
    n=(3*n+1)/2 ;
    int a=-1,b=1,c=0,i ;
    for(i=1 ; i<=n ; i++){
      c=a+b ;
      a=b ;
      b=c ;
    }
    return c ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(oddFib(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation oddFib( n : int) : int
  pre: true
  post: true
  activity: (     n := (3 * n + 1) / 2 ; 
     var a : int ; a := -1 ;
    var b : int ; b := 1 ;
    var c : int ; c := 0 ;
    var i : int ;
         i := 1 ; while i <= n do ( (     c := a + b ; 
     a := b ; 
     b := c )  ;     i := i + 1 ) ; 
     return c );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(oddFib(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    while(N-->0){
      String s[]=in.next().split(":");
      double S=Double.valueOf(s[0]);
      double L=Double.valueOf(s[1]);
      S=360*(60*S+L)/720.0 ;
      L=360.0*L/60.0 ;
      double dif=Math.min(Math.abs(S-L),360-Math.abs(S-L));
      System.out.println(0<=dif && dif<30 ? "alert" : 90<=dif && dif<=180 ? "safe" : "warning");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
         while (N > 0) do (        N := N - 1 ;     skip ; (     var s : Sequence(String) ; s := in.getCurrent()->split(":") ;
     var S : double ; S := (s[0+1])->toReal() ;
    var L : double ; L := (s[1+1])->toReal() ;
    S := 360 * (60 * S + L) / 720.0 ; 
    L := 360.0 * L / 60.0 ; 
    var dif : double ; dif := Set{if (S)->char2byte() - L < 0 then -((S)->char2byte() - L) else (S)->char2byte() - L endif, 360 - if (S)->char2byte() - L < 0 then -((S)->char2byte() - L) else (S)->char2byte() - L endif}->min() ;
    OclFile["System.out"].println(if 0 <= dif & dif < 30 then "alert" else if 90 <= dif & dif <= 180 then "safe" else "warning" endif endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int nCr(int n,int r){
    int fac[]=new int[100];
    for(int i=0 ; i<n ; i++)fac[i]=1 ;
    for(int i=1 ; i<n+1 ; i++){
      fac[i]=fac[i-1]*i ;
    }
    int ans=fac[n]/(fac[n-r]*fac[r]);
    return ans ;
  }
  public static void main(String[] args){
    int n=3 ;
    int k=3 ;
    int ans=nCr(n+k-1,k)+nCr(k-1,n-1);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nCr( n : int, r : int) : int
  pre: true
  post: true
  activity: (     var fac : Sequence(int) ; fac := Integer.subrange(1,100)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     fac[i+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n + 1 do ( (     fac[i+1] := fac[i - 1+1] * i )  ;     i := i + 1 ) ; 
    var ans : int ; ans := fac[n+1] / (fac[n - r+1] * fac[r+1]) ;
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var k : int ; k := 3 ;
     var ans : int ; ans := nCr(n + k - 1, k) + nCr(k - 1, n - 1) ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public void solve()throws IOException {
    int n=nextInt();
    for(int i=0 ; i<n ; i++){
      String[] s=nextToken().split(":");
      int[] hand=new int[2];
      hand[0]=Integer.parseInt(s[0]);
      hand[1]=Integer.parseInt(s[1]);
      double key=Math.abs(hand[1]*6-(hand[0]*30+(double)hand[1]/2));
      key=Math.min(key,360-key);
      if(key<30){
        writer.println("alert");
      }
      else if(key<90){
        writer.println("warning");
      }
      else {
        writer.println("safe");
      }
      writer.flush();
    }
  }
  public static void main(String args[])throws IOException {
    new Main().run();
  }
  BufferedReader reader ;
  StringTokenizer tokenizer ;
  PrintWriter writer ;
  public void run()throws IOException {
    try {
      reader=new BufferedReader(new InputStreamReader(System.in));
      tokenizer=null ;
      writer=new PrintWriter(System.out);
      solve();
      reader.close();
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public String nextToken()throws IOException {
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
         var i : int ; i := 0 ; while i < n do ( (     var s : Sequence(String) ; s := nextToken()->split(":") ;
     var hand : Sequence(int) ; hand := Integer.subrange(1,2)->collect(0) ;
    hand[0+1] := (s[0+1])->toInteger() ; 
    hand[1+1] := (s[1+1])->toInteger() ; 
    var key : double ; key := if hand[1+1] * 6 - (hand[0+1] * 30 + hand[1+1]->oclAsType(double) / 2) < 0 then -(hand[1+1] * 6 - (hand[0+1] * 30 + hand[1+1]->oclAsType(double) / 2)) else hand[1+1] * 6 - (hand[0+1] * 30 + hand[1+1]->oclAsType(double) / 2) endif ;
    key := Set{key, 360 - key}->min() ; 
    if (key < 30) then (     writer.println("alert") ) else     if (key < 90) then (     writer.println("warning") ) else (     writer.println("safe") ) ;  ;  
    writer.flush() ; 
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   attribute writer : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     try (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := null ; 
    writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    int cnt=parseCnt();
    while(cnt-->0){
      double diff=parseDiffAngle();
      if(diff<30.0 || 330.0<diff){
        System.out.println("alert");
      }
      else if(90.0<=diff && diff<=270.0){
        System.out.println("safe");
      }
      else {
        System.out.println("warning");
      }
    }
  }
  private static double parseDiffAngle(){
    double diff=0 ;
    double tmp1=0 ;
    double tmp2=0 ;
    String time=null ;
    if((time=parseStdin())!=null){
      String[] lines=time.split(":");
      tmp1=Double.parseDouble(lines[1])/30.0 ;
      tmp2=(Double.parseDouble(lines[0])*60.0+Double.parseDouble(lines[1]))/360.0 ;
      diff=(tmp1>tmp2)? tmp1-tmp2 : tmp2-tmp1 ;
    }
    return diff*180.0 ;
  }
  private static int parseCnt(){
    int cnt=0 ;
    String str=null ;
    if((str=parseStdin())!=null){
      cnt=Integer.parseInt(str);
    }
    return cnt ;
  }
  private static String parseStdin(){
    String stdin=null ;
    try {
      String tmp=br.readLine();
      if(tmp!=null){
        if(! tmp.isEmpty())stdin=tmp ;
      }
    }
    catch(IOException e){
    }
    return stdin ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := parseCnt() ;
         while (cnt > 0) do (        cnt := cnt - 1 ;     skip ; (     var diff : double ; diff := parseDiffAngle() ;
     if (diff < 30.0 or 330.0 < diff) then (     OclFile["System.out"].println("alert") ) else     if (90.0 <= diff & diff <= 270.0) then (     OclFile["System.out"].println("safe") ) else (     OclFile["System.out"].println("warning") ) ;  ) ;  ) );
  static   operation parseDiffAngle() : double
  pre: true
  post: true
  activity: (     var diff : double ; diff := 0 ;
     var tmp1 : double ; tmp1 := 0 ;
    var tmp2 : double ; tmp2 := 0 ;
    var time : String ; time := null ;
    if ((time) /= null) then (     var lines : Sequence(String) ; lines := time->split(":") ;
     tmp1 := (lines[1+1])->toReal() / 30.0 ; 
     tmp2 := ((lines[0+1])->toReal() * 60.0 + (lines[1+1])->toReal()) / 360.0 ; 
     diff := if (tmp1 > tmp2) then tmp1 - tmp2 else tmp2 - tmp1 endif ) else skip ; 
    return diff * 180.0 
 );
  static   operation parseCnt() : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var str : String ; str := null ;
     if ((str) /= null) then (     cnt := (str)->toInteger() ) else skip ; 
     return cnt );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var stdin : String ; stdin := null ;
     try (     var tmp : String ; tmp := br.readLine() ;
     if (tmp /= null) then (     if (not(tmp->isEmpty())) then     stdin := tmp ; else skip ) else skip )   catch (e : IOException) do skip
     return stdin );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  class time {
    int h ;
    int m ;
    int deg ;
    time(String hm){
      String ti[]=hm.split(":");
      h=Integer.parseInt(ti[0]);
      m=Integer.parseInt(ti[1]);
      deg=Math.abs((h*60+m-m*12));
      deg=Math.min(deg,12*60-deg);
    }
    @ Override public String toString(){
      if(deg<((30)*(12*60)/360)){
        return "alert" ;
      }
      if(deg>=((90)*(12*60)/360)){
        return "safe" ;
      }
      return "warning" ;
    }
  }
  void run(){
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      System.out.println(new time(sc.next()));
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
 class time {
   attribute h : int;
   attribute m : int;
   attribute deg : int;
   static operation newtime( hm : String) : time
  pre: true
  post: true
  activity:
  ( var self : time ;
    self := createtime();
    self.initialise(hm);
    return self );
  operation initialise( hm : String) : void
  pre: true  post: true
  activity: (     var ti : Sequence(String) ; ti := hm->split(":") ;
     h := (ti[0+1])->toInteger() ; 
    m := (ti[1+1])->toInteger() ; 
    deg := if (h * 60 + m - m * 12) < 0 then -((h * 60 + m - m * 12)) else (h * 60 + m - m * 12) endif ; 
    deg := Set{deg, 12 * 60 - deg}->min() ; 
 );
      operation toString() : String
  pre: true
  post: true
  activity: (     if (deg < ((30) * (12 * 60) / 360)) then (     return "alert" ) else skip ; 
     if (deg >= ((90) * (12 * 60) / 360)) then (     return "safe" ) else skip ; 
     return "warning" );
}
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(time.newtime(sc.getCurrent())) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    for(int i=0 ; i<n ; i++){
      String[] input=br.readLine().split(":");
      int hour=Integer.parseInt(input[0]);
      int min=Integer.parseInt(input[1]);
      double lhand=(hour*60+min)/2.0 ;
      double shand=(min*6.0);
      double deg=Math.abs(lhand-shand);
      if((0<=deg && deg<30)||(330<deg && deg<=360)){
        System.out.println("alert");
      }
      else if((90<=deg && deg<=180)||(180<=deg && deg<=270)){
        System.out.println("safe");
      }
      else {
        System.out.println("warning");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var input : Sequence(String) ; input := br.readLine()->split(":") ;
     var hour : int ; hour := (input[0+1])->toInteger() ;
    var min : int ; min := (input[1+1])->toInteger() ;
    var lhand : double ; lhand := (hour * 60 + min) / 2.0 ;
    var shand : double ; shand := (min * 6.0) ;
    var deg : double ; deg := if lhand - shand < 0 then -(lhand - shand) else lhand - shand endif ;
    if ((0 <= deg & deg < 30) or (330 < deg & deg <= 360)) then (     OclFile["System.out"].println("alert") ) else     if ((90 <= deg & deg <= 180) or (180 <= deg & deg <= 270)) then (     OclFile["System.out"].println("safe") ) else (     OclFile["System.out"].println("warning") ) ;  ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isTriangular(int num){
    if(num<0)return false ;
    int sum=0 ;
    for(int n=1 ; sum<=num ; n++){
      sum=sum+n ;
      if(sum==num)return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    int n=55 ;
    if(isTriangular(n))System.out.print("The number "+"is a triangular number");
    else System.out.print("The number"+" is NOT a triangular number");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isTriangular( num : int) : boolean
  pre: true
  post: true
  activity: (     if (num < 0) then     return false else skip ; 
     var sum : int ; sum := 0 ;
         var n : int ; n := 1 ; while sum <= num do ( (     sum := sum + n ; 
     if (sum = num) then     return true else skip )  ;     n := n + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 55 ;
     if (isTriangular(n)) then     OclFile["System.out"].print("The number " + "is a triangular number") ; else     OclFile["System.out"].print("The number" + " is NOT a triangular number") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sumOfTheSeries(int n){
    int sum_n=(n*(n+1)/2);
    int sum_sq_n=(n*(n+1)/2)*(2*n+1)/3 ;
    return(sum_n+sum_sq_n);
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.printf("Sum=%d",sumOfTheSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumOfTheSeries( n : int) : int
  pre: true
  post: true
  activity: (     var sum_n : int ; sum_n := (n * (n + 1) / 2) ;
     var sum_sq_n : int ; sum_sq_n := (n * (n + 1) / 2) * (2 * n + 1) / 3 ;
     return (sum_n + sum_sq_n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].printf("Sum=%d", sumOfTheSeries(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findDistinctOddSum(int n,int k){
    if((k*k)<=n &&(n+k)% 2==0){
      int val=1 ;
      int sum=0 ;
      for(int i=1 ; i<k ; i++){
        System.out.print(val+" ");
        sum+=val ;
        val+=2 ;
      }
      System.out.print(n-sum+"\n");
    }
    else System.out.print("NO \n");
  }
  public static void main(String[] args){
    int n=100 ;
    int k=4 ;
    findDistinctOddSum(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findDistinctOddSum( n : int, k : int) : void
  pre: true
  post: true
  activity: (     if ((k * k) <= n & (n + k) mod 2 = 0) then (     var val : int ; val := 1 ;
     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i < k do ( (     OclFile["System.out"].print(val + " ") ; 
     sum := sum+(val) ; 
     val := val+(2) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(n - sum + "\n") ) else     OclFile["System.out"].print("NO \n") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 100 ;
     var k : int ; k := 4 ;
     execute findDistinctOddSum(n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewClass48 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    while(n-->0){
      int a=in.nextInt();
      if(a>2){
        for(int i=2 ; i<a+1 ; i++){
          System.out.print(i+" ");
        }
        System.out.println(1);
      }
      else {
        for(int i=a ; i>=1 ; i--){
          System.out.print(i);
          System.out.print(" ");
        }
        System.out.println("");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass48 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var a : int ; a := in.getCurrent()->toInteger() ;
     if (a > 2) then (         var i : int ; i := 2 ; while i < a + 1 do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(1) ) else (         var i : int ; i := a ; while i >= 1 do ( (     OclFile["System.out"].print(i) ; 
     OclFile["System.out"].print(" ") )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println("") ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class BearAndForgottenTree3 {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int d=input.nextInt();
    int h=input.nextInt();
    if(d>2*h ||(d==1 && n!=2)){
      System.out.println(-1);
      return ;
    }
    for(int i=1 ; i<=h ; ++i){
      System.out.print(i+" "+(i+1)+"\n");
    }
    int x=1 ;
    for(int i=1 ; i<=(d-h); ++i){
      int y=h+1+i ;
      System.out.print(x+" "+y+"\n");
      x=y ;
    }
    int v=(d==h)? 2 : 1 ;
    for(int i=d+2 ; i<=n ; ++i){
      System.out.print(i+" "+v+"\n");
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class BearAndForgottenTree3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var d : int ; d := input.getCurrent()->toInteger() ;
    var h : int ; h := input.getCurrent()->toInteger() ;
    if (d > 2 * h or (d = 1 & n /= 2)) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
        var i : int ; i := 1 ; while i <= h do ( (     OclFile["System.out"].print(i + " " + (i + 1) + "\n") )  ;     i := i + 1 ) ; 
    var x : int ; x := 1 ;
        var i : int ; i := 1 ; while i <= (d - h) do ( (     var y : int ; y := h + 1 + i ;
     OclFile["System.out"].print(x + " " + y + "\n") ; 
     x := y )  ;     i := i + 1 ) ; 
    var v : int ; v := if (d = h) then 2 else 1 endif ;
        var i : int ; i := d + 2 ; while i <= n do ( (     OclFile["System.out"].print(i + " " + v + "\n") )  ;     i := i + 1 ) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Ex3 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int oo=0 ; oo<t ; oo++){
      int n=in.nextInt();
      if(n==2){
        System.out.println("2 1");
      }
      else {
        ArrayList<Integer>arr=new ArrayList<>();
        for(int i=0 ; i<n ; i++){
          arr.add(i+1);
        }
        arr.sort(Collections.reverseOrder());
        int ar[]=new int[n];
        for(int i=0 ; i<n ; i++){
          ar[i]=arr.get(i);
        }
        int temp=ar[n/2];
        ar[n/2]=ar[n/2+1];
        ar[n/2+1]=temp ;
        for(int i=0 ; i<ar.length ; i++){
          System.out.print(ar[i]+" ");
        }
        System.out.println();
      }
    }
  }
  public class ListNode<E>{
    private E value ;
    private ListNode next ;
    public ListNode(E newVal,ListNode<E>newNext){
      value=newVal ;
      next=newNext ;
    }
    public E getValue(){
      return value ;
    }
    public ListNode<E>getNext(){
      return next ;
    }
    public void setValue(E newValue){
      value=newValue ;
    }
    public void setNext(ListNode<E>newNext){
      next=newNext ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ex3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var oo : int ; oo := 0 ; while oo < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 2) then (     OclFile["System.out"].println("2 1") ) else (     var arr : Sequence(int) ; arr := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     arr := arr->including(i + 1) )  ;     i := i + 1 ) ; 
    arr := arr.sort(reverseOrder()) ; 
    var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := arr->at(i+1) )  ;     i := i + 1 ) ; 
    var temp : int ; temp := ar[n / 2+1] ;
    ar[n / 2+1] := ar[n / 2 + 1+1] ; 
    ar[n / 2 + 1+1] := temp ; 
        var i : int ; i := 0 ; while i < ar->size() do ( (     OclFile["System.out"].print(ar[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) )  ;     oo := oo + 1 ) );
 class ListNode<E> {
   attribute value : E;
   attribute next : ListNode;
   static operation newListNode( newVal : E, newNext : ListNode<E>) : ListNode
  pre: true
  post: true
  activity:
  ( var self : ListNode ;
    self := createListNode();
    self.initialise(newVal, newNext);
    return self );
  operation initialise( newVal : E, newNext : ListNode<E>) : void
  pre: true  post: true
  activity: (     value := newVal ; 
     next := newNext );
   operation getValue() : E
  pre: true
  post: true
  activity: (     return value );
   operation getNext() : ListNode<E>
  pre: true
  post: true
  activity: (     return next );
   operation setValue( newValue : E) : void
  pre: true
  post: true
  activity: (     value := newValue );
   operation setNext( newNext : ListNode<E>) : void
  pre: true
  post: true
  activity: (     next := newNext );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    Arrays.sort(a);
    int min=Integer.MAX_VALUE ;
    int ans=0 ;
    for(int i=0 ; i<n-1 ; i++){
      int sa=Math.abs(a[n-1]-a[i]*2);
      if(sa<min){
        min=sa ;
        ans=a[i];
      }
    }
    System.out.print(a[n-1]+" ");
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var min : int ; min := 2147483647 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var sa : int ; sa := if a[n - 1+1] - a[i+1] * 2 < 0 then -(a[n - 1+1] - a[i+1] * 2) else a[n - 1+1] - a[i+1] * 2 endif ;
     if (sa < min) then (     min := sa ; 
     ans := a[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(a[n - 1+1] + " ") ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int t=1 ; t<=test ; t++){
      int n=in.nextInt();
      if(n % 2==0){
        for(int i=2 ; i<=n ; i+=2){
          pw.print(i+" "+(i-1)+" ");
        }
        pw.println();
      }
      else {
        pw.print(n+" ");
        for(int i=1 ; i<=n-1 ; i++){
          pw.print(i+" ");
        }
        pw.println();
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= test do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (         var i : int ; i := 2 ; while i <= n do ( (     skip )  ;     i := i+(2) ) ; 
     skip ) else (     skip ; 
         var i : int ; i := 1 ; while i <= n - 1 do ( (     skip )  ;     i := i + 1 ) ; 
     skip ) )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF1454A {
  public static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int test=scanner.nextInt();
    while(test-->0){
      int n=scanner.nextInt();
      for(int i=2 ; i<=n ; i++){
        System.out.print(i+" ");
      }
      System.out.println(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF1454A {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var test : int ; test := scanner.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 2 ; while i <= n do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(1) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1454 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      if((n & 1)==0){
        for(int i=n ; i>1 ; i--){
          System.out.print(i+" ");
        }
        System.out.println(1);
      }
      else {
        for(int i=n ; i>(n+1)/2 ; i--){
          System.out.print(i+" ");
        }
        System.out.print(1+" ");
        for(int i=(n+1)/2 ; i>2 ; i--){
          System.out.print(i+" ");
        }
        if(n>2){
          System.out.println(2);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1454 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseAnd(n,1)) = 0) then (         var i : int ; i := n ; while i > 1 do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println(1) ) else (         var i : int ; i := n ; while i > (n + 1) / 2 do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i - 1 ) ; 
     OclFile["System.out"].print(1 + " ") ; 
         var i : int ; i := (n + 1) / 2 ; while i > 2 do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i - 1 ) ; 
     if (n > 2) then (     OclFile["System.out"].println(2) ) else skip ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int check(String s,int K){
    for(int ch=0 ; ch<26 ; ch++){
      char c=(char)('a'+ch);
      int last=-1 ;
      boolean found=true ;
      for(int i=0 ; i<K ; i++)if(s.charAt(i)==c)last=i ;
      if(last==-1)continue ;
      for(int i=K ; i<s.length(); i++){
        if(s.charAt(i)==c)last=i ;
        if(last<=(i-K)){
          found=false ;
          break ;
        }
      }
      if(found)return 1 ;
    }
    return 0 ;
  }
  static int binarySearch(String s){
    int low=1,high=s.length();
    int ans=0 ;
    while(low<=high){
      int mid=(high+low)>>1 ;
      if(check(s,mid)==1){
        ans=mid ;
        high=mid-1 ;
      }
      else low=mid+1 ;
    }
    return ans ;
  }
  public static void main(String args[]){
    String s="abcde" ;
    System.out.println(binarySearch(s));
    s="aaaa" ;
    System.out.println(binarySearch(s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation check( s : String, K : int) : int
  pre: true
  post: true
  activity: (         var ch : int ; ch := 0 ; while ch < 26 do ( (     var c : String ; c := ('a' + ch)->oclAsType(String) ;
     var last : int ; last := -1 ;
    var found : boolean ; found := true ;
        var i : int ; i := 0 ; while i < K do (     if (s->at(i+1) = c) then     last := i ; else skip ;  ;     i := i + 1 ) ; 
    if (last = -1) then     continue else skip ; 
        var i : int ; i := K ; while i < s->size() do ( (     if (s->at(i+1) = c) then     last := i ; else skip ; 
     if (last <= (i - K)) then (     found := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (found) then     return 1 else skip ; 
 )  ;     ch := ch + 1 ) ; 
     return 0 );
  static   operation binarySearch( s : String) : int
  pre: true
  post: true
  activity: (     var low : int ; low := 1 ;
    var high : int ; high := s->size() ;
     var ans : int ; ans := 0 ;
     while (low <= high) do (     var mid : int ; mid := ((high + low)/(2->pow(1)))->oclAsType(long) ;
     if (check(s, mid) = 1) then (     ans := mid ; 
     high := mid - 1 ) else     low := mid + 1 ; ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abcde" ;
     OclFile["System.out"].println(binarySearch(s)) ; 
     s := "aaaa" ; 
     OclFile["System.out"].println(binarySearch(s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import static java.lang.Math.max ;
public class Main {
  static class Solution {
  }
  static public boolean isValid(int total,int remain){
    return remain*2-total<=1 ;
  }
  static public long solve(int cur,int remain,long[][] dp,long[] arr){
    if(! isValid(cur,remain)){
      return Long.MIN_VALUE ;
    }
    if(remain<=0){
      return 0L ;
    }
    int state=cur/remain ;
    if(dp[cur][state]!=Long.MIN_VALUE)return dp[cur][state];
    long ans=Long.MIN_VALUE ;
    if(isValid(cur-1,remain)){
      ans=max(ans,solve(cur-1,remain,dp,arr));
    }
    ans=max(ans,solve(cur-2,remain-1,dp,arr)+arr[cur]);
    dp[cur][state]=ans ;
    return ans ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] arr=new long[n+1];
    long[][] dp=new long[n+1][5];
    for(int i=1 ; i<=n ; ++i){
      arr[i]=sc.nextLong();
    }
    for(int i=1 ; i<=n ; ++i){
      for(int j=0 ; j<5 ; ++j){
        dp[i][j]=Long.MIN_VALUE ;
      }
    }
    long ans=solve(n,n/2,dp,arr);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Solution { }
  static    operation isValid( total : int, remain : int) : boolean
  pre: true
  post: true
  activity: (     return remain * 2 - total <= 1 );
  static    operation solve( cur : int, remain : int, dp : Sequence(Sequence(long)), arr : Sequence(long)) : long
  pre: true
  post: true
  activity: (     if (not(isValid(cur, remain))) then (     return "-9223372036854775808"->toLong() ) else skip ; 
     if (remain <= 0) then (     return 0L ) else skip ; 
    var state : int ; state := cur / remain ;
    if (dp[cur+1][state+1] /= "-9223372036854775808"->toLong()) then     return dp[cur+1][state+1] else skip ; 
    var ans : long ; ans := "-9223372036854775808"->toLong() ;
    if (isValid(cur - 1, remain)) then (     ans := Set{ans, solve(cur - 1, remain, dp, arr)}->max() ) else skip ; 
    ans := Set{ans, solve(cur - 2, remain - 1, dp, arr) + arr[cur+1]}->max() ; 
    dp[cur+1][state+1] := ans ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,5)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 0 ; while j < 5 do ( (     dp[i+1][j+1] := "-9223372036854775808"->toLong() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := solve(n, n / 2, dp, arr) ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static long find_max(int i,int N,int[] A,long[] dp){
    return i==N-1 ? 0 : Long.max(dp[i+1],A[i]+find_max(i+2,N,A,dp));
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int[] A=new int[N];
    long[] dp=new long[N+1];
    for(int i=0 ; i<N ; i++){
      A[i]=scanner.nextInt();
    }
    dp[N-1]=A[N-1];
    int i=N-3 ;
    while(i>=0){
      dp[i]=dp[i+2]+A[i];
      i-=2 ;
    }
    i=N-2 ;
    while(i>=0){
      dp[i]=Long.max(dp[i+1],A[i]+dp[i+2]);
      i-=2 ;
    }
    System.out.println(N % 2==0 ? dp[0] : find_max(0,N,A,dp));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation find_max( i : int, N : int, A : Sequence(int), dp : Sequence(long)) : long
  pre: true
  post: true
  activity: (     return if i = N - 1 then 0 else Set{dp[i + 1+1], A[i+1] + find_max(i + 2, N, A, dp)}->max() endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var dp : Sequence(long) ; dp := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    dp[N - 1+1] := A[N - 1+1] ; 
    var i : int ; i := N - 3 ;
    while (i >= 0) do (     dp[i+1] := dp[i + 2+1] + A[i+1] ; 
     i := i-(2) ) ; 
    i := N - 2 ; 
    while (i >= 0) do (     dp[i+1] := Set{dp[i + 1+1], A[i+1] + dp[i + 2+1]}->max() ; 
     i := i-(2) ) ; 
    OclFile["System.out"].println(if N mod 2 = 0 then dp[0+1] else find_max(0, N, A, dp) endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Map<Long,Long>mp=new HashMap<>();
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[] A=new long[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextLong();
    }
    System.out.println(helper(A,0,N/2));
  }
  private static long helper(long[] A,int ofs,int cnt){
    long key=ofs*3_000_00+cnt ;
    if(mp.containsKey(key)){
      return mp.get(key);
    }
    if(cnt==0){
      return 0 ;
    }
    int size=(A.length-ofs);
    if(size==1 && cnt==1){
      return A[ofs];
    }
    if(size==2 && cnt==1){
      return Math.max(A[ofs],A[ofs+1]);
    }
    if(size % 2==1 && size/2+1==cnt){
      long ans=A[ofs]+helper(A,ofs+2,cnt-1);
      ;
      mp.put(key,ans);
      return ans ;
    }
    long use=A[ofs]+helper(A,ofs+2,cnt-1);
    long nouse=helper(A,ofs+1,cnt);
    long ans=Math.max(use,nouse);
    ;
    mp.put(key,ans);
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mp : Map(long,long) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(helper(A, 0, N / 2)) ; 
 );
  static   operation helper( A : Sequence(long), ofs : int, cnt : int) : long
  pre: true
  post: true
  activity: (     var key : long ; key := ofs * 3_000_00 + cnt ;
     if (mp->keys()->includes(key)) then (     return mp->at(key) ) else skip ; 
    if (cnt = 0) then (     return 0 ) else skip ; 
    var size : int ; size := (A->size() - ofs) ;
    if (size = 1 & cnt = 1) then (     return A[ofs+1] ) else skip ; 
    if (size = 2 & cnt = 1) then (     return Set{A[ofs+1], A[ofs + 1+1]}->max() ) else skip ; 
    if (size mod 2 = 1 & size / 2 + 1 = cnt) then (     var ans : long ; ans := A[ofs+1] + helper(A, ofs + 2, cnt - 1) ;
     mp := mp->union(Map{key |-> ans}) ; 
     return ans ) else skip ; 
    var use : long ; use := A[ofs+1] + helper(A, ofs + 2, cnt - 1) ;
    var nouse : long ; nouse := helper(A, ofs + 1, cnt) ;
    var ans : long ; ans := Set{use, nouse}->max() ;
    mp := mp->union(Map{key |-> ans}) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int D=sc.nextInt();
    int X=sc.nextInt();
    int[] A=new int[N];
    int sum=0 ;
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
    }
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<D ; j++){
        if(j*A[i]+1<=D){
          sum+=1 ;
        }
        else {
          break ;
        }
      }
    }
    System.out.println(sum+X);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var D : int ; D := sc.getCurrent()->toInteger() ;
    var X : int ; X := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < D do ( (     if (j * A[i+1] + 1 <= D) then (     sum := sum+(1) ) else (     break ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum + X) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  static int a1[]={
    0,-1,0,1 };
    static int b1[]={
-1,0,1,0 };
      private static Scanner sc=new Scanner(System.in);
      static int K,N ;
      static int mod=1000000007 ;
      public static void main(String[] args){
        int N=sc.nextInt();
        int D=sc.nextInt();
        int X=sc.nextInt();
        int ans=X ;
        for(int i=0 ; i<N ; i++){
          int A=sc.nextInt();
          int B=1 ;
          while(B<=D){
            ans++;
            B+=A ;
          }
        }
        p(ans);
      }
      static void p(String ans){
        System.out.println(ans);
      };
      static void p(int ans){
        System.out.println(ans);
      };
      static void p(){
        System.out.println();
      };
      static void p(long ans){
        System.out.println(ans);
      };
      static void p(double ans){
        System.out.println(ans);
      };
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a1 : int := Sequence{0,-1,0,1};
  static   attribute b1 : int := Sequence{-1,0,1,0};
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute K : int;
  static   attribute mod : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var D : int ; D := sc.getCurrent()->toInteger() ;
    var X : int ; X := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := X ;
        var i : int ; i := 0 ; while i < N do ( (     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := 1 ;
     while (B <= D) do (     ans := ans + 1 ; 
     B := B+(A) ) )  ;     i := i + 1 ) ; 
    execute p(ans) ; 
 );
  static   operation p( ans : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( ans : long) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : double) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class codeforce5 {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int d=scan.nextInt();
    int h=scan.nextInt();
    if(d>2*h ||(d==1 && n!=2)){
      System.out.println(-1);
      return ;
    }
    for(int i=1 ; i<=h ; ++i){
      System.out.print(i+" "+(i+1)+"\n");
    }
    int x=1 ;
    for(int i=1 ; i<=(d-h); ++i){
      int y=h+1+i ;
      System.out.print(x+" "+y+"\n");
      x=y ;
    }
    int v=(d==h)? 2 : 1 ;
    for(int i=d+2 ; i<=n ; ++i){
      System.out.print(i+" "+v+"\n");
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforce5 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var d : int ; d := scan.getCurrent()->toInteger() ;
    var h : int ; h := scan.getCurrent()->toInteger() ;
    if (d > 2 * h or (d = 1 & n /= 2)) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
        var i : int ; i := 1 ; while i <= h do ( (     OclFile["System.out"].print(i + " " + (i + 1) + "\n") )  ;     i := i + 1 ) ; 
    var x : int ; x := 1 ;
        var i : int ; i := 1 ; while i <= (d - h) do ( (     var y : int ; y := h + 1 + i ;
     OclFile["System.out"].print(x + " " + y + "\n") ; 
     x := y )  ;     i := i + 1 ) ; 
    var v : int ; v := if (d = h) then 2 else 1 endif ;
        var i : int ; i := d + 2 ; while i <= n do ( (     OclFile["System.out"].print(i + " " + v + "\n") )  ;     i := i + 1 ) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int n ;
  List<Integer>a=new ArrayList<>();
  int max,result ;
  private Main(Scanner in){
    n=Integer.parseInt(in.nextLine());
    String[] tokens=in.nextLine().split(" ");
    for(int i=0 ; i<n ; ++i){
      a.add(Integer.parseInt(tokens[i]));
    }
  }
  private void calc(){
    max=a.stream().max(new Comparator<Integer>(){
      @ Override public int compare(Integer o1,Integer o2){
        if(o1<o2){
          return-1 ;
        }
        else if(o1>o2){
          return 1 ;
        }
        else {
          return 0 ;
        }
      }
    }
).get().intValue();
    double half=(double)max/2.0 ;
    result=-1 ;
    double diff=Double.MAX_VALUE ;
    for(Integer val : a){
      if(val!=max && diff>Math.abs((double)val-half)){
        diff=Math.abs((double)val-half);
        result=val ;
      }
    }
  }
  private void show(){
    System.out.println(max+" "+result);
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    Main ins=new Main(in);
    in.close();
    ins.calc();
    ins.show();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute a : Sequence(int) := Sequence{};
   attribute max : int;
   static operation newMain( in : OclFile) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     n := (in.nextLine())->toInteger() ; 
     var tokens : Sequence(String) ; tokens := in.nextLine()->split(" ") ;
         var i : int ; i := 0 ; while i < n do ( (     a := a->including((tokens[i+1])->toInteger()) )  ;     i := i + 1 ) );
   operation calc() : void
  pre: true
  post: true
  activity: (     max := a->max().get()->oclAsType(int) ; 
     var half : double ; half := max->oclAsType(double) / 2.0 ;
    result := -1 ; 
    var diff : double ; diff := (2 - 2->pow(-52))*(2->pow(1023)) ;
    for (val : a) do ( (     if (val /= max & diff > if val->oclAsType(double) - half < 0 then -(val->oclAsType(double) - half) else val->oclAsType(double) - half endif) then (     diff := if val->oclAsType(double) - half < 0 then -(val->oclAsType(double) - half) else val->oclAsType(double) - half endif ; 
     result := val ) else skip )  ) ; 
 );
   operation show() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(max + " " + result) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ins : Main ; ins := Main.newMain(in) ;
    skip ; 
    ins.calc() ; 
    ins.show() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    final int N=Integer.parseInt(sc.next());
    final int D=Integer.parseInt(sc.next());
    final int X=Integer.parseInt(sc.next());
    int[] a=new int[N];
    int chocolate=0 ;
    for(int i=0 ; i<N ; i++){
      a[i]=Integer.parseInt(sc.next());
    }
    for(int i=0 ; i<N ; i++){
      int times=0 ;
      int days=1 ;
      while(days<=D){
        chocolate++;
        times++;
        days=times*a[i]+1 ;
      }
    }
    out.println(chocolate+X);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := (sc.getCurrent())->toInteger() ;
    var D : int ; D := (sc.getCurrent())->toInteger() ;
    var X : int ; X := (sc.getCurrent())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var chocolate : int ; chocolate := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var times : int ; times := 0 ;
     var days : int ; days := 1 ;
     while (days <= D) do (     chocolate := chocolate + 1 ; 
     times := times + 1 ; 
     days := times * a[i+1] + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Iterator ;
import java.util.List ;
import java.util.Map.Entry ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
class Main {
  static final int MOD=1000000007 ;
  static final int INF=1<<30 ;
  Main(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int D=sc.nextInt();
    int X=sc.nextInt();
    int ans=0 ;
    for(int i=0 ; i<N ; i++){
      int num=sc.nextInt();
      for(int k=0 ; k<100 ; k++)if(k*num+1<=D)ans++;
      else break ;
    }
    System.out.println(ans+X);
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1000000007;
  static    attribute INF : int := (1*(2->pow(30)))->oclAsType(long);
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var D : int ; D := sc.getCurrent()->toInteger() ;
    var X : int ; X := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var num : int ; num := sc.getCurrent()->toInteger() ;
         var k : int ; k := 0 ; while k < 100 do (     if (k * num + 1 <= D) then     ans := ans + 1 else     break ;   ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans + X) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    int D=Integer.parseInt(sc.next());
    int X=Integer.parseInt(sc.next());
    int ans=X+N ;
    for(int i=0 ; i<N ; i++){
      int n=Integer.parseInt(sc.next());
      for(int j=n+1 ; j<=D ; j+=n){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var D : int ; D := (sc.getCurrent())->toInteger() ;
    var X : int ; X := (sc.getCurrent())->toInteger() ;
    var ans : int ; ans := X + N ;
        var i : int ; i := 0 ; while i < N do ( (     var n : int ; n := (sc.getCurrent())->toInteger() ;
         var j : int ; j := n + 1 ; while j <= D do ( (     ans := ans + 1 )  ;     j := j+(n) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class GFG {
  static int maxPrimefactorNum(int N){
    int arr[]=new int[N+5];
    Arrays.fill(arr,0);
    for(int i=2 ; i*i<=N ; i++){
      if(arr[i]==0){
        for(int j=2*i ; j<=N ; j+=i){
          arr[j]++;
        }
      }
      arr[i]=1 ;
    }
    int maxval=0,maxint=1 ;
    for(int i=1 ; i<=N ; i++){
      if(arr[i]>maxval){
        maxval=arr[i];
        maxint=i ;
      }
    }
    return maxint ;
  }
  public static void main(String[] args){
    int N=40 ;
    System.out.println(maxPrimefactorNum(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxPrimefactorNum( N : int) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,N + 5)->collect(0) ;
     arr := arr->collect(0) ; 
        var i : int ; i := 2 ; while i * i <= N do ( (     if (arr[i+1] = 0) then (         var j : int ; j := 2 * i ; while j <= N do ( (     arr[j+1] := arr[j+1] + 1 )  ;     j := j+(i) ) ) else skip ; 
     arr[i+1] := 1 )  ;     i := i + 1 ) ; 
    var maxval : int ; maxval := 0 ;
    var maxint : int ; maxint := 1 ;
        var i : int ; i := 1 ; while i <= N do ( (     if (arr[i+1] > maxval) then (     maxval := arr[i+1] ; 
     maxint := i ) else skip )  ;     i := i + 1 ) ; 
    return maxint 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 40 ;
     OclFile["System.out"].println(maxPrimefactorNum(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static List<Integer>getPerfectcubes(int n){
    List<Integer>perfectcubes=new ArrayList<Integer>();
    int current=1 ;
    int i=1 ;
    while(current<=n){
      perfectcubes.add(current);
      i+=1 ;
      current=(int)(Math.pow(i,3));
    }
    return perfectcubes ;
  }
  static int maxPairSum(int[] arr){
    int n=arr.length ;
    int max=0 ;
    int secondMax=0 ;
    if(arr[0]>arr[1]){
      max=arr[0];
      secondMax=arr[1];
    }
    else {
      max=arr[1];
      secondMax=arr[0];
    }
    for(int i=2 ; i<n ; i++){
      if(arr[i]>max){
        secondMax=max ;
        max=arr[i];
      }
      else if(arr[i]>secondMax){
        secondMax=arr[i];
      }
    }
    return(max+secondMax);
  }
  static int countPairsWith(int n,List<Integer>perfectcubes,List<Integer>nums){
    int count=0 ;
    for(int i=0 ; i<perfectcubes.size(); i++){
      int temp=perfectcubes.get(i)-n ;
      if(temp>n &&(nums.contains(temp)))count+=1 ;
    }
    return count ;
  }
  static int countPairs(int[] arr){
    int n=arr.length ;
    int max=maxPairSum(arr);
    List<Integer>perfectcubes=getPerfectcubes(max);
    List<Integer>nums=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      nums.add(arr[i]);
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      count+=countPairsWith(arr[i],perfectcubes,nums);
    }
    return count ;
  }
  public static void main(String[] agrs){
    int[] arr={
      2,6,18,9,999,1 };
      System.out.print(countPairs(arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getPerfectcubes( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var perfectcubes : Sequence(int) ; perfectcubes := Sequence{} ;
     var current : int ; current := 1 ;
    var i : int ; i := 1 ;
    while (current <= n) do (     perfectcubes := perfectcubes->including(current) ; 
     i := i+(1) ; 
     current := (i->pow(3))->oclAsType(int) ) ; 
    return perfectcubes 
 );
  static   operation maxPairSum( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
     var max : int ; max := 0 ;
    var secondMax : int ; secondMax := 0 ;
    if (arr[0+1] > arr[1+1]) then (     max := arr[0+1] ; 
     secondMax := arr[1+1] ) else (     max := arr[1+1] ; 
     secondMax := arr[0+1] ) ;  
        var i : int ; i := 2 ; while i < n do ( (     if (arr[i+1] > max) then (     secondMax := max ; 
     max := arr[i+1] ) else     if (arr[i+1] > secondMax) then (     secondMax := arr[i+1] ) else skip ; )  ;     i := i + 1 ) ; 
    return (max + secondMax) 
 );
  static   operation countPairsWith( n : int, perfectcubes : Sequence(int), nums : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < perfectcubes->size() do ( (     var temp : int ; temp := perfectcubes->at(i+1) - n ;
     if (temp > n & (nums->includes(temp))) then     count := count+(1) ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation countPairs( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
     var max : int ; max := maxPairSum(arr) ;
    var perfectcubes : Sequence(int) ; perfectcubes := getPerfectcubes(max) ;
    var nums : Sequence(int) ; nums := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     nums := nums->including(arr[i+1]) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     count := count+(countPairsWith(arr[i+1], perfectcubes, nums)) )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,6,18,9,999,1} ;
     OclFile["System.out"].print(countPairs(arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeforces500B {
  static ArrayList<Integer>[] adj ;
  static int[] arr ;
  static PriorityQueue<Integer>vals ;
  static PriorityQueue<Integer>nodes ;
  static boolean[] visited ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    arr=new int[n];
    adj=new ArrayList[n];
    StringTokenizer st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(st.nextToken())-1 ;
      adj[i]=new ArrayList<>();
    }
    for(int a=0 ; a<n ; a++){
      String str=br.readLine();
      for(int b=0 ; b<n ; b++){
        if(str.charAt(b)=='1'){
          adj[a] .add(b);
        }
      }
    }
    visited=new boolean[n];
    Arrays.fill(visited,false);
    int[] answer=new int[n];
    vals=new PriorityQueue<>();
    nodes=new PriorityQueue<>();
    for(int i=0 ; i<n ; i++){
      if(! visited[i]){
        dfs(i);
        while(! vals.isEmpty()){
          int a=vals.poll();
          int b=nodes.poll();
          answer[b]=a+1 ;
        }
      }
    }
    StringBuilder ans=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      ans.append(answer[i]+" ");
    }
    System.out.println(ans);
  }
  static void dfs(int node){
    visited[node]=true ;
    nodes.add(node);
    vals.add(arr[node]);
    for(int next : adj[node]){
      if(! visited[next]){
        dfs(next);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces500B {
  static   attribute adj : Sequence(Sequence(int));
  static   attribute arr : Sequence(int);
  static   attribute vals : Sequence(int);
  static   attribute nodes : Sequence(int);
  static   attribute visited : Sequence(boolean);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    arr := Integer.subrange(1,n)->collect(0) ; 
    adj := Integer.subrange(1,n)->collect(null) ; 
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (st.next())->toInteger() - 1 ; 
     adj[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var a : int ; a := 0 ; while a < n do ( (     var str : String ; str := br.readLine() ;
         var b : int ; b := 0 ; while b < n do ( (     if (str->at(b+1) = '1') then (     adj[a+1]->excludes(b) ) else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    visited := Integer.subrange(1,n)->collect(false) ; 
    visited := visited->collect(false) ; 
    var answer : Sequence(int) ; answer := Integer.subrange(1,n)->collect(0) ;
    vals := Sequence{} ; 
    nodes := Sequence{} ; 
        var i : int ; i := 0 ; while i < n do ( (     if (not(visited[i+1])) then (     execute dfs(i) ; 
     while (not(vals->isEmpty())) do (     var a : int ; a := vals->min() ;
     var b : int ; b := nodes->min() ;
     answer[b+1] := a + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    var ans : String ; ans := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans + StringLib.newString(answer[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation dfs( node : int) : void
  pre: true
  post: true
  activity: (     visited[node+1] := true ; 
     nodes := nodes->including(node) ; 
     vals := vals->including(arr[node+1]) ; 
     for (next : adj[node+1]) do ( (     if (not(visited[next+1])) then (     execute dfs(next) ) else skip )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class GFG {
  static double heptdiagonal(double a){
    if(a<0)return-1 ;
    double d=1.802*a ;
    return d ;
  }
  public static void main(String[] args){
    int a=6 ;
    System.out.println(heptdiagonal(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation heptdiagonal( a : double) : double
  pre: true
  post: true
  activity: (     if (a < 0) then     return -1 else skip ; 
     var d : double ; d := 1.802 * a ;
     return d );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 6 ;
     OclFile["System.out"].println(heptdiagonal(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class GFG {
  static double decdiagonal(double a){
    if(a<0)return-1 ;
    double d=1.902*a ;
    return d ;
  }
  public static void main(String[] args){
    int a=9 ;
    System.out.println(decdiagonal(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation decdiagonal( a : double) : double
  pre: true
  post: true
  activity: (     if (a < 0) then     return -1 else skip ; 
     var d : double ; d := 1.902 * a ;
     return d );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 9 ;
     OclFile["System.out"].println(decdiagonal(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.*;
import java.util.*;
public class Main {
  static Scanner s=new Scanner(System.in);
  static int g(){
    return Integer.parseInt(s.next());
  }
  public static void main(String[] $){
    Point st=new Point(g(),g()),go=new Point(g(),g());
    if(st.y>go.y){
      Point buf=go ;
      go=st ;
      st=buf ;
    }
    Comparator<Point>c=Comparator.comparingDouble(Point :: getX);
    TreeSet<Point>p=new TreeSet<>(st.x<go.x ? c : c.reversed());
    for(int i=g(); i>0 ; --i){
      int x=g(),y=g();
      if(st.y<=y && y<=go.y)p.add(new Point(x,y));
    }
    int v=lis(p.subSet(st,true,go,true));
    System.out.println((Math.abs(st.x-go.x)+Math.abs(st.y-go.y))*100L+v*-20+(v==Math.min(go.y-st.y,Math.abs(go.x-st.x))+1 ? v+1 : v)*5*Math.PI);
  }
  static int lis(NavigableSet<Point>p){
    ArrayList<Integer>l=new ArrayList<>();
    l.add(Integer.MIN_VALUE);
    while(! p.isEmpty()){
      int y=p.pollFirst().y ;
      if(l.get(l.size()-1)<y)l.add(y);
      else {
        int v=Collections.binarySearch(l,y);
        if(v<0)l.set(~ v,y);
      }
    }
    return l.size()-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation g() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var st : Point ; st := Point.newPoint(g(), g()) ;
    var go : Point ; go := Point.newPoint(g(), g()) ;
     if (st.y > go.y) then (     var buf : Point ; buf := go ;
     go := st ; 
     st := buf ) else skip ; 
    var c : Function(<Point>,(<Point>,boolean)) ; c := Comparator.comparingDouble(lambda _pars : OclAny in Point.newPoint().getX(_pars)) ;
    var p : Set(Point) ; p := Set{}->union(if st.x < go.x then c else c.reversed() endif) ;
        var i : int ; i := g() ; while i > 0 do ( (     var x : int ; x := g() ;
    var y : int ; y := g() ;
     if (st.y <= y & y <= go.y) then     p := p->including(Point.newPoint(x, y)) ; else skip )  ;     i := i - 1 ) ; 
    var v : int ; v := lis(p->select( _x0 | _x0 >= st & _x0 < true )) ;
    OclFile["System.out"].println((if st.x - go.x < 0 then -(st.x - go.x) else st.x - go.x endif + if st.y - go.y < 0 then -(st.y - go.y) else st.y - go.y endif) * 100L + v * -20 + (if v = Set{go.y - st.y, if go.x - st.x < 0 then -(go.x - st.x) else go.x - st.x endif}->min() + 1 then v + 1 else v endif) * 5 * 3.141592653589793) ; 
 );
  static   operation lis( p : NavigableSet<Point>) : int
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     l := l->including(-2147483648) ; 
     while (not(p->isEmpty())) do (     var y : int ; y := p->first().y ;
     if (l->at(l->size() - 1+1) < y) then     l := l->including(y) ; else (     var v : int ; v := .binarySearch(l, y) ;
     if (v < 0) then     l := l.setAt(-(v + 1)+1,y) ; else skip ) ) ; 
     return l->size() - 1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static void convert(int n,String a,String b){
    int[] l=new int[n];
    int i ;
    for(i=0 ; i<n ; i++)l[i]=0 ;
    for(i=0 ; i<n ; i++){
      if(a.charAt(i)!=b.charAt(i))l[i]=1 ;
    }
    int cc=0 ;
    int vl=0 ;
    for(i=0 ; i<n ; i++){
      if(l[i]==0){
        if(vl!=0)cc+=1 ;
        vl=0 ;
      }
      else vl+=1 ;
    }
    if(vl!=0)cc+=1 ;
    System.out.println(cc);
  }
  public static void main(String args[]){
    String a="101010" ;
    String b="110011" ;
    int n=a.length();
    convert(n,a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation convert( n : int, a : String, b : String) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Integer.subrange(1,n)->collect(0) ;
     var i : int ;
        i := 0 ; while i < n do (     l[i+1] := 0 ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     if (a->at(i+1) /= b->at(i+1)) then     l[i+1] := 1 ; else skip )  ;     i := i + 1 ) ; 
    var cc : int ; cc := 0 ;
    var vl : int ; vl := 0 ;
        i := 0 ; while i < n do ( (     if (l[i+1] = 0) then (     if (vl /= 0) then     cc := cc+(1) ; else skip ; 
     vl := 0 ) else     vl := vl+(1) ; )  ;     i := i + 1 ) ; 
    if (vl /= 0) then     cc := cc+(1) ; else skip ; 
    OclFile["System.out"].println(cc) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ; a := "101010" ;
     var b : String ; b := "110011" ;
     var n : int ; n := a->size() ;
     execute convert(n, a, b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] main){
    Scanner sc=new Scanner(System.in);
    int numOfWord=Integer.parseInt(sc.nextLine());
    Set<String>wordSet=new HashSet<>();
    boolean followTheRules=true ;
    String prevEndChar=null ;
    for(int i=0 ; i<numOfWord ; i++){
      String word=sc.nextLine();
      if(wordSet.contains(word)){
        followTheRules=false ;
        break ;
      }
      if(prevEndChar!=null && ! prevEndChar.equals(String.valueOf(word.charAt(0)))){
        followTheRules=false ;
        break ;
      }
      prevEndChar=String.valueOf(word.charAt(word.length()-1));
      wordSet.add(word);
    }
    String result=followTheRules ? "Yes" : "No" ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( main : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numOfWord : int ; numOfWord := (sc.nextLine())->toInteger() ;
    var wordSet : Set(String) ; wordSet := Set{} ;
    var followTheRules : boolean ; followTheRules := true ;
    var prevEndChar : String ; prevEndChar := null ;
        var i : int ; i := 0 ; while i < numOfWord do ( (     var word : String ; word := sc.nextLine() ;
     if (wordSet->includes(word)) then (     followTheRules := false ; 
     break ) else skip ; 
    if (prevEndChar /= null & not(prevEndChar = ((word->at(0+1)) + ""))) then (     followTheRules := false ; 
     break ) else skip ; 
    prevEndChar := ((word->at(word->size() - 1+1)) + "") ; 
    wordSet := wordSet->including(word) ; 
 )  ;     i := i + 1 ) ; 
    var result : String ; result := if followTheRules then "Yes" else "No" endif ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int n=scanner.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=scanner.nextInt();
    Arrays.sort(a);
    int r=upperBound(a,a[n-1]/2);
    if(r+1<n-1 && Math.abs(a[r+1]*2-a[n-1])<Math.abs(a[r]*2-a[n-1]))r=a[r+1];
    else r=a[r];
    System.out.printf("%d %d\n",a[n-1],r);
  }
  public static int upperBound(int[] a,int k){
    int left=-1 ;
    int right=a.length ;
    while(right-left>1){
      int mid=(left+right)/2 ;
      if(a[mid]<=k){
        left=mid ;
      }
      else {
        right=mid ;
      }
    }
    return left ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var r : int ; r := upperBound(a, a[n - 1+1] / 2) ;
    if (r + 1 < n - 1 & if a[r + 1+1] * 2 - a[n - 1+1] < 0 then -(a[r + 1+1] * 2 - a[n - 1+1]) else a[r + 1+1] * 2 - a[n - 1+1] endif < if a[r+1] * 2 - a[n - 1+1] < 0 then -(a[r+1] * 2 - a[n - 1+1]) else a[r+1] * 2 - a[n - 1+1] endif) then     r := a[r + 1+1] else     r := a[r+1] ; ;  
    OclFile["System.out"].printf("%d %d\n", a[n - 1+1], r) ; 
 );
  static   operation upperBound( a : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     var left : int ; left := -1 ;
     var right : int ; right := a->size() ;
     while (right - left > 1) do (     var mid : int ; mid := (left + right) / 2 ;
     if (a[mid+1] <= k) then (     left := mid ) else (     right := mid ) ) ; 
     return left );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String SA=sc.next();
    String SB=sc.next();
    String SC=sc.next();
    int ia=0 ;
    int ib=0 ;
    int ic=0 ;
    char next='a' ;
    String ans="" ;
    while(true){
      if(next=='a'){
        if(ia==SA.length()){
          ans="A" ;
          break ;
        }
        next=SA.charAt(ia);
        ia++;
      }
      else if(next=='b'){
        if(ib==SB.length()){
          ans="B" ;
          break ;
        }
        next=SB.charAt(ib);
        ib++;
      }
      else {
        if(ic==SC.length()){
          ans="C" ;
          break ;
        }
        next=SC.charAt(ic);
        ic++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var SA : String ; SA := sc.getCurrent() ;
    var SB : String ; SB := sc.getCurrent() ;
    var SC : String ; SC := sc.getCurrent() ;
    var ia : int ; ia := 0 ;
    var ib : int ; ib := 0 ;
    var ic : int ; ic := 0 ;
    var next : String ; next := 'a' ;
    var ans : String ; ans := "" ;
    while (true) do (     if (next = 'a') then (     if (ia = SA->size()) then (     ans := "A" ; 
     break ) else skip ; 
     next := SA->at(ia+1) ; 
     ia := ia + 1 ) else     if (next = 'b') then (     if (ib = SB->size()) then (     ans := "B" ; 
     break ) else skip ; 
     next := SB->at(ib+1) ; 
     ib := ib + 1 ) else (     if (ic = SC->size()) then (     ans := "C" ; 
     break ) else skip ; 
     next := SC->at(ic+1) ; 
     ic := ic + 1 ) ;  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigDecimal ;
import java.nio.charset.StandardCharsets ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    char[] A=sc.next().toCharArray();
    char[] B=sc.next().toCharArray();
    char[] C=sc.next().toCharArray();
    List<String>aArray=new ArrayList<>();
    List<String>bArray=new ArrayList<>();
    List<String>cArray=new ArrayList<>();
    for(char c : A){
      String s=String.valueOf(c);
      aArray.add(s);
    }
    for(char c : B){
      String s=String.valueOf(c);
      bArray.add(s);
    }
    for(char c : C){
      String s=String.valueOf(c);
      cArray.add(s);
    }
    String next=aArray.get(0);
    aArray.remove(0);
    String ans="" ;
    while(true){
      if(next.equals("a")){
        if(aArray.size()==0){
          ans="A" ;
          break ;
        }
        next=aArray.get(0);
        aArray.remove(0);
      }
      else if(next.equals("b")){
        if(bArray.size()==0){
          ans="B" ;
          break ;
        }
        next=bArray.get(0);
        bArray.remove(0);
      }
      else {
        if(cArray.size()==0){
          ans="C" ;
          break ;
        }
        next=cArray.get(0);
        cArray.remove(0);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : Sequence(String) ; A := sc.getCurrent()->characters() ;
    var B : Sequence(String) ; B := sc.getCurrent()->characters() ;
    var C : Sequence(String) ; C := sc.getCurrent()->characters() ;
    var aArray : Sequence(String) ; aArray := Sequence{} ;
    var bArray : Sequence(String) ; bArray := Sequence{} ;
    var cArray : Sequence(String) ; cArray := Sequence{} ;
    for (c : A) do ( (     var s : String ; s := ((c) + "") ;
     aArray := aArray->including(s) )  ) ; 
    for (c : B) do ( (     var s : String ; s := ((c) + "") ;
     bArray := bArray->including(s) )  ) ; 
    for (c : C) do ( (     var s : String ; s := ((c) + "") ;
     cArray := cArray->including(s) )  ) ; 
    var next : String ; next := aArray->at(0+1) ;
    aArray := aArray->excludingAt(0+1) ; 
    var ans : String ; ans := "" ;
    while (true) do (     if (next = "a") then (     if (aArray->size() = 0) then (     ans := "A" ; 
     break ) else skip ; 
     next := aArray->at(0+1) ; 
     aArray := aArray->excludingAt(0+1) ) else     if (next = "b") then (     if (bArray->size() = 0) then (     ans := "B" ; 
     break ) else skip ; 
     next := bArray->at(0+1) ; 
     bArray := bArray->excludingAt(0+1) ) else (     if (cArray->size() = 0) then (     ans := "C" ; 
     break ) else skip ; 
     next := cArray->at(0+1) ; 
     cArray := cArray->excludingAt(0+1) ) ;  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int anum=1 ;
  int bnum=0 ;
  int cnum=0 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    String a=sc.next();
    String b=sc.next();
    String c=sc.next();
    char turn=a.charAt(0);
    while(true){
      if(turn=='a'){
        if(anum==a.length()){
          System.out.println("A");
          break ;
        }
        turn=a.charAt(anum);
        anum++;
      }
      else if(turn=='b'){
        if(bnum==b.length()){
          System.out.println("B");
          break ;
        }
        turn=b.charAt(bnum);
        bnum++;
      }
      else {
        if(cnum==c.length()){
          System.out.println("C");
          break ;
        }
        turn=c.charAt(cnum);
        cnum++;
      }
    }
    sc.close();
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute anum : int := 1;
   attribute bnum : int := 0;
   attribute cnum : int := 0;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := sc.getCurrent() ;
    var b : String ; b := sc.getCurrent() ;
    var c : String ; c := sc.getCurrent() ;
    var turn : String ; turn := a->at(0+1) ;
    while (true) do (     if (turn = 'a') then (     if (anum = a->size()) then (     OclFile["System.out"].println("A") ; 
     break ) else skip ; 
     turn := a->at(anum+1) ; 
     anum := anum + 1 ) else     if (turn = 'b') then (     if (bnum = b->size()) then (     OclFile["System.out"].println("B") ; 
     break ) else skip ; 
     turn := b->at(bnum+1) ; 
     bnum := bnum + 1 ) else (     if (cnum = c->size()) then (     OclFile["System.out"].println("C") ; 
     break ) else skip ; 
     turn := c->at(cnum+1) ; 
     cnum := cnum + 1 ) ;  ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String sa=scanner.next();
    String sb=scanner.next();
    String sc=scanner.next();
    int currentPlayer=0 ;
    while(true){
      char nextPlayer='a' ;
      switch(currentPlayer){
        case 0 : {
          if(sa.isEmpty()){
            System.out.print("A");
            return ;
          }
          nextPlayer=sa.charAt(0);
          sa=sa.substring(1);
          break ;
        }
        case 1 : {
          if(sb.isEmpty()){
            System.out.print("B");
            return ;
          }
          nextPlayer=sb.charAt(0);
          sb=sb.substring(1);
          break ;
        }
        case 2 : {
          if(sc.isEmpty()){
            System.out.print("C");
            return ;
          }
          nextPlayer=sc.charAt(0);
          sc=sc.substring(1);
          break ;
        }
      }
      if(nextPlayer=='a'){
        currentPlayer=0 ;
      }
      else if(nextPlayer=='b'){
        currentPlayer=1 ;
      }
      else if(nextPlayer=='c'){
        currentPlayer=2 ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sa : String ; sa := scanner.getCurrent() ;
    var sb : String ; sb := scanner.getCurrent() ;
    var sc : String ; sc := scanner.getCurrent() ;
    var currentPlayer : int ; currentPlayer := 0 ;
    while (true) do (     var nextPlayer : String ; nextPlayer := 'a' ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (currentPlayer) ; 
       if _switchval = 0 then
 (     if (sa->isEmpty()) then (     OclFile["System.out"].print("A") ; 
     return ) else skip ; 
     nextPlayer := sa->at(0+1) ; 
     sa := sa.subrange(1+1,1) ; 
     break ) 
   else skip ;
       if _switchval = 1 then
 (     if (sb->isEmpty()) then (     OclFile["System.out"].print("B") ; 
     return ) else skip ; 
     nextPlayer := sb->at(0+1) ; 
     sb := sb.subrange(1+1,1) ; 
     break ) 
   else skip ;
       if _switchval = 2 then
 (     if (sc->isEmpty()) then (     OclFile["System.out"].print("C") ; 
     return ) else skip ; 
     nextPlayer := sc->at(0+1) ; 
     sc := sc.subrange(1+1,1) ; 
     break ) 
   else skip ;
 )
     if (nextPlayer = 'a') then (     currentPlayer := 0 ) else     if (nextPlayer = 'b') then (     currentPlayer := 1 ) else     if (nextPlayer = 'c') then (     currentPlayer := 2 ) else skip ; ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    String a=sc.next();
    String b=sc.next();
    String c=sc.next();
    String[] abc=new String[] {
      a,b,c };
      int t=0 ;
      for(; ; ){
        String e=abc[t];
        if(e.length()==0){
          break ;
        }
        int next=abc[t] .charAt(0)-'a' ;
        abc[t]=abc[t] .substring(1);
        t=next ;
      }
      System.out.println(new String[] {
        "A","B","C" }
[t]);
      }
      int ni(){
        return Integer.parseInt(sc.next());
      }
      void debug(Object...os){
        System.err.println(Arrays.deepToString(os));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var a : String ; a := sc.getCurrent() ;
     var b : String ; b := sc.getCurrent() ;
    var c : String ; c := sc.getCurrent() ;
    var abc : Sequence(String) ; abc := Sequence{a,b,c} ;
    var t : int ; t := 0 ;
      while true do ( (     var e : String ; e := abc[t+1] ;
     if (e->size() = 0) then (     break ) else skip ; 
    var next : int ; next := abc[t+1]->at(0+1) - ('a')->char2byte() ;
    abc[t+1] := abc[t+1].subrange(1+1,1) ; 
    t := next ; 
 )  ) ; 
    OclFile["System.out"].println(Sequence{"A","B","C"}[t+1]) ; 
 );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (sc.getCurrent())->toInteger() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int R=3 ;
  static int C=4 ;
  static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  static void replacematrix(int[][] mat,int n,int m){
    int[] rgcd=new int[R];
    int[] cgcd=new int[C];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        rgcd[i]=gcd(rgcd[i],mat[i][j]);
        cgcd[j]=gcd(cgcd[j],mat[i][j]);
      }
    }
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<m ; j++)mat[i][j]=Math.max(rgcd[i],cgcd[j]);
  }
  static public void main(String[] args){
    int[][] m={
      {
        1,2,3,3 },{
          4,5,6,6 },{
            7,8,9,9 },};
            replacematrix(m,R,C);
            for(int i=0 ; i<R ; i++){
              for(int j=0 ; j<C ; j++)System.out.print(m[i][j]+" ");
              System.out.println();
            }
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute R : int := 3;
  static   attribute C : int := 4;
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation replacematrix( mat : Sequence(Sequence(int)), n : int, m : int) : void
  pre: true
  post: true
  activity: (     var rgcd : Sequence(int) ; rgcd := Integer.subrange(1,R)->collect(0) ;
     var cgcd : Sequence(int) ; cgcd := Integer.subrange(1,C)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     rgcd[i+1] := gcd(rgcd[i+1], mat[i+1][j+1]) ; 
     cgcd[j+1] := gcd(cgcd[j+1], mat[i+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < m do (     mat[i+1][j+1] := Set{rgcd[i+1], cgcd[j+1]}->max() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Sequence(Sequence(int)) ; m := Sequence{Sequence{1,2,3,3},Sequence{4,5,6,6},Sequence{7,8,9,9},} ;
     execute replacematrix(m, R, C) ; 
         var i : int ; i := 0 ; while i < R do ( (         var j : int ; j := 0 ; while j < C do (     OclFile["System.out"].print(m[i+1][j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
import java.util.stream.IntStream ;
import javafx.util.Pair ;
public class Main {
  static void sort(int a[]){
    Random ran=new Random();
    for(int i=0 ; i<a.length ; i++){
      int r=ran.nextInt(a.length);
      int temp=a[r];
      a[r]=a[i];
      a[i]=temp ;
    }
    Arrays.sort(a);
  }
  public static void main(String[] args)throws IOException {
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int a[]=new int[6];
    a[0]=input.nextInt();
    a[1]=input.nextInt();
    a[2]=input.nextInt();
    a[3]=input.nextInt();
    a[4]=input.nextInt();
    a[5]=input.nextInt();
    int result[]=new int[3];
    result[0]=Math.min(a[1],n-a[2]-a[4]);
    n-=result[0];
    result[1]=Math.min(a[3],n-a[4]);
    result[2]=n-result[1];
    System.out.println(result[0]+" "+result[1]+" "+result[2]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var ran : OclRandom ; ran := OclRandom.newOclRandom() ;
         var i : int ; i := 0 ; while i < a->size() do ( (     var r : int ; r := ran.nextInt(a->size()) ;
     var temp : int ; temp := a[r+1] ;
     a[r+1] := a[i+1] ; 
     a[i+1] := temp )  ;     i := i + 1 ) ; 
     a := a->sort() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,6)->collect(0) ;
    a[0+1] := input.getCurrent()->toInteger() ; 
    a[1+1] := input.getCurrent()->toInteger() ; 
    a[2+1] := input.getCurrent()->toInteger() ; 
    a[3+1] := input.getCurrent()->toInteger() ; 
    a[4+1] := input.getCurrent()->toInteger() ; 
    a[5+1] := input.getCurrent()->toInteger() ; 
    var result : Sequence(int) ; result := Integer.subrange(1,3)->collect(0) ;
    result[0+1] := Set{a[1+1], n - a[2+1] - a[4+1]}->min() ; 
    n := n-(result[0+1]) ; 
    result[1+1] := Set{a[3+1], n - a[4+1]}->min() ; 
    result[2+1] := n - result[1+1] ; 
    OclFile["System.out"].println(result[0+1] + " " + result[1+1] + " " + result[2+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class one {
  public static void main(String[] args)throws IOException {
    BufferedReader xx=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(xx.readLine());
    String input1[]=xx.readLine().split(" ");
    int min1=Integer.parseInt(input1[0]);
    int max1=Integer.parseInt(input1[1]);
    String input2[]=xx.readLine().split(" ");
    int min2=Integer.parseInt(input2[0]);
    int max2=Integer.parseInt(input2[1]);
    String input3[]=xx.readLine().split(" ");
    int min3=Integer.parseInt(input3[0]);
    int max3=Integer.parseInt(input3[1]);
    int ans1=0,ans2=0,ans3=0 ;
    n=n-(min1+min2+min3);
    ans1=min1 ;
    ans2=min2 ;
    ans3=min3 ;
    if(n+min1>=max1){
      n=n-max1+min1 ;
      ans1=max1 ;
    }
    else {
      ans1=ans1+n ;
      n=0 ;
    }
    if(n+min2>=max2){
      n=n-max2+min2 ;
      ans2=max2 ;
    }
    else {
      ans2=ans2+n ;
      n=0 ;
    }
    ans3=ans3+n ;
    System.out.println(ans1+" "+ans2+" "+ans3);
  }
}
------------------------------------------------------------
OCL File:
---------
 class one {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var xx : OclFile ; xx := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (xx.readLine())->toInteger() ;
    var input1 : Sequence(String) ; input1 := xx.readLine()->split(" ") ;
    var min1 : int ; min1 := (input1[0+1])->toInteger() ;
    var max1 : int ; max1 := (input1[1+1])->toInteger() ;
    var input2 : Sequence(String) ; input2 := xx.readLine()->split(" ") ;
    var min2 : int ; min2 := (input2[0+1])->toInteger() ;
    var max2 : int ; max2 := (input2[1+1])->toInteger() ;
    var input3 : Sequence(String) ; input3 := xx.readLine()->split(" ") ;
    var min3 : int ; min3 := (input3[0+1])->toInteger() ;
    var max3 : int ; max3 := (input3[1+1])->toInteger() ;
    var ans1 : int ; ans1 := 0 ;
    var ans2 : int ; ans2 := 0 ;
    var ans3 : int ; ans3 := 0 ;
    n := n - (min1 + min2 + min3) ; 
    ans1 := min1 ; 
    ans2 := min2 ; 
    ans3 := min3 ; 
    if (n + min1 >= max1) then (     n := n - max1 + min1 ; 
     ans1 := max1 ) else (     ans1 := ans1 + n ; 
     n := 0 ) ;  
    if (n + min2 >= max2) then (     n := n - max2 + min2 ; 
     ans2 := max2 ) else (     ans2 := ans2 + n ; 
     n := 0 ) ;  
    ans3 := ans3 + n ; 
    OclFile["System.out"].println(ans1 + " " + ans2 + " " + ans3) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    HashMap<Integer,Integer>map=new HashMap<>();
    int n=in.nextInt();
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      int name=in.nextInt();
      int pie=in.nextInt();
      map.put(name,pie);
      sum=sum+pie ;
    }
    n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      int name=in.nextInt();
      int pie=in.nextInt();
      if(map.get(name)==null){
        sum=sum+pie ;
      }
      else {
        int s=map.get(name);
        if(s<pie){
          sum=sum+pie-s ;
        }
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var map : Map(int,int) ; map := Map{} ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var name : int ; name := in.getCurrent()->toInteger() ;
     var pie : int ; pie := in.getCurrent()->toInteger() ;
     map := map->union(Map{name |-> pie}) ; 
     sum := sum + pie )  ;     i := i + 1 ) ; 
    n := in.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     var name : int ; name := in.getCurrent()->toInteger() ;
     var pie : int ; pie := in.getCurrent()->toInteger() ;
     if (map->at(name) = null) then (     sum := sum + pie ) else (     var s : int ; s := map->at(name) ;
     if (s < pie) then (     sum := sum + pie - s ) else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BinomialCoefficients solver=new BinomialCoefficients();
    solver.solve(1,in,out);
    out.close();
  }
  static class BinomialCoefficients {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      long[] a=new long[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextLong();
      }
      Arrays.sort(a);
      long ans=a[n-1];
      if(ans % 2==0){
        long mid=ans/2 ;
        long min=Long.MAX_VALUE ;
        long ans2=0 ;
        for(int i=0 ; i<n ; i++){
          if(a[i]==ans){
            continue ;
          }
          long tmp=Math.abs(mid-a[i]);
          if(tmp<min){
            min=tmp ;
            ans2=a[i];
          }
        }
        out.print(ans+" "+ans2);
      }
      else {
        long mid1=ans/2 ;
        long mid2=mid1+1 ;
        long min=Long.MAX_VALUE ;
        long ans2=0 ;
        for(int i=0 ; i<n ; i++){
          if(a[i]==ans){
            continue ;
          }
          long tmp=Math.min(Math.abs(mid1-a[i]),Math.abs(mid2-a[i]));
          if(tmp<min){
            min=tmp ;
            ans2=a[i];
          }
        }
        out.print(ans+" "+ans2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BinomialCoefficients ; solver := BinomialCoefficients.newBinomialCoefficients() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BinomialCoefficients {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var ans : long ; ans := a[n - 1+1] ;
    if (ans mod 2 = 0) then (     var mid : long ; mid := ans / 2 ;
     var min : long ; min := "9223372036854775807"->toLong() ;
    var ans2 : long ; ans2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = ans) then (     continue ) else skip ; 
     var tmp : long ; tmp := if mid - a[i+1] < 0 then -(mid - a[i+1]) else mid - a[i+1] endif ;
     if (tmp < min) then (     min := tmp ; 
     ans2 := a[i+1] ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 ) else (     var mid1 : long ; mid1 := ans / 2 ;
     var mid2 : long ; mid2 := mid1 + 1 ;
    var min : long ; min := "9223372036854775807"->toLong() ;
    var ans2 : long ; ans2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = ans) then (     continue ) else skip ; 
     var tmp : long ; tmp := Set{if mid1 - a[i+1] < 0 then -(mid1 - a[i+1]) else mid1 - a[i+1] endif, if mid2 - a[i+1] < 0 then -(mid2 - a[i+1]) else mid2 - a[i+1] endif}->min() ;
     if (tmp < min) then (     min := tmp ; 
     ans2 := a[i+1] ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static int kPrimeFactor(int n,int k){
    while(n % 2==0){
      k--;
      n=n/2 ;
      if(k==0)return 2 ;
    }
    for(int i=3 ; i<=Math.sqrt(n); i=i+2){
      while(n % i==0){
        if(k==1)return i ;
        k--;
        n=n/i ;
      }
    }
    if(n>2 && k==1)return n ;
    return-1 ;
  }
  public static void main(String args[]){
    int n=12,k=3 ;
    System.out.println(kPrimeFactor(n,k));
    n=14 ;
    k=3 ;
    System.out.println(kPrimeFactor(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation kPrimeFactor( n : int, k : int) : int
  pre: true
  post: true
  activity: (     while (n mod 2 = 0) do (     k := k - 1 ; 
     n := n / 2 ; 
     if (k = 0) then     return 2 else skip ) ; 
         var i : int ; i := 3 ; while i <= (n)->sqrt() do ( (     while (n mod i = 0) do (     if (k = 1) then     return i else skip ; 
     k := k - 1 ; 
     n := n / i ) )  ;     i := i + 2 ) ; 
     if (n > 2 & k = 1) then     return n else skip ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
    var k : int ; k := 3 ;
     OclFile["System.out"].println(kPrimeFactor(n, k)) ; 
    n := 14 ; 
    k := 3 ; 
    OclFile["System.out"].println(kPrimeFactor(n, k)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class homework4 {
  public static void main(String[] args){
    Scanner read=new Scanner(System.in);
    int n=read.nextInt(),d=read.nextInt(),h=read.nextInt();
    if(d>2*h ||(d==1 && n!=2)){
      System.out.println(-1);
      return ;
    }
    for(int i=1 ; i<=h ; ++i){
      System.out.print(i+" "+(i+1)+"\n");
    }
    int x=1 ;
    for(int i=1 ; i<=(d-h); ++i){
      int y=h+1+i ;
      System.out.print(x+" "+y+"\n");
      x=y ;
    }
    int v=(d==h)? 2 : 1 ;
    for(int i=d+2 ; i<=n ; ++i){
      System.out.print(i+" "+v+"\n");
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class homework4 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : OclFile ; read := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := read.getCurrent()->toInteger() ;
    var d : int ; d := read.getCurrent()->toInteger() ;
    var h : int ; h := read.getCurrent()->toInteger() ;
    if (d > 2 * h or (d = 1 & n /= 2)) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
        var i : int ; i := 1 ; while i <= h do ( (     OclFile["System.out"].print(i + " " + (i + 1) + "\n") )  ;     i := i + 1 ) ; 
    var x : int ; x := 1 ;
        var i : int ; i := 1 ; while i <= (d - h) do ( (     var y : int ; y := h + 1 + i ;
     OclFile["System.out"].print(x + " " + y + "\n") ; 
     x := y )  ;     i := i + 1 ) ; 
    var v : int ; v := if (d = h) then 2 else 1 endif ;
        var i : int ; i := d + 2 ; while i <= n do ( (     OclFile["System.out"].print(i + " " + v + "\n") )  ;     i := i + 1 ) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.util.*;
public class Main {
  static class Pair {
    int a ;
    int b ;
    int c ;
    public Pair(int a,int b,int c){
      this.a=a ;
      this.b=b ;
      this.c=c ;
    }
  }
  static class SortA implements Comparator<Pair>{
    public int compare(Pair s1,Pair s2){
      if(s1.b<s2.b){
        return-1 ;
      }
      else if(s1.b>s2.b){
        return 1 ;
      }
      else if(s1.b==s2.b){
        if(s1.c<s2.c){
          return-1 ;
        }
        else if(s1.c>s2.c){
          return 1 ;
        }
        else {
          if(s1.a<s2.a){
            return-1 ;
          }
          else if(s1.a>s2.a){
            return 1 ;
          }
        }
      }
      return 0 ;
    }
  }
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int z=(m+1);
    PriorityQueue<Pair>pq=new PriorityQueue<>(new SortA());
    for(int i=1 ; i<=m ; i++){
      int k=Math.abs((m+1)-2*i);
      pq.add(new Pair(i,0,k));
    }
    for(int i=0 ; i<n ; i++){
      Pair z1=pq.poll();
      System.out.print(z1.a+" ");
      pq.add(new Pair(z1.a,z1.b+1,z1.c));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Pair {
   attribute a : int;
   attribute b : int;
   attribute c : int;
   static operation newPair( a : int, b : int, c : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(a, b,c);
    return self );
  operation initialise( a : int, b : int, c : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b ; 
     self.c := c );
}
  static class SortA implements Function(<Map>,(<Map>,boolean)) {
   operation compare( s1 : Map, s2 : Map) : int
  pre: true
  post: true
  activity: (     if (s1.b < s2.b) then (     return -1 ) else     if (s1.b > s2.b) then (     return 1 ) else     if (s1.b = s2.b) then (     if (s1.c < s2.c) then (     return -1 ) else     if (s1.c > s2.c) then (     return 1 ) else (     if (s1.a < s2.a) then (     return -1 ) else     if (s1.a > s2.a) then (     return 1 ) else skip ; ) ;  ) else skip ; ;  ;  
     return 0 );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var z : int ; z := (m + 1) ;
    var pq : Sequence(Map) ; pq := Sequence{}->union(SortA.newSortA()) ;
        var i : int ; i := 1 ; while i <= m do ( (     var k : int ; k := if (m + 1) - 2 * i < 0 then -((m + 1) - 2 * i) else (m + 1) - 2 * i endif ;
     pq := pq->including(Map(i, 0, k)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var z1 : Map ; z1 := pq->min() ;
     OclFile["System.out"].print(z1.a + " ") ; 
     pq := pq->including(Map(z1.a, z1.b + 1, z1.c)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class B195 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int M=in.nextInt();
    Integer[] A=new Integer[M];
    for(int m=0 ; m<M ; m++){
      A[m]=m+1 ;
    }
    Arrays.sort(A,new Comparator<Integer>(){
      @ Override public int compare(Integer o1,Integer o2){
        double d1=Math.abs((M+1)/2.0-o1);
        double d2=Math.abs((M+1)/2.0-o2);
        if(d1==d2){
          return o1-o2 ;
        }
        else {
          return(int)Math.signum(d1-d2);
        }
      }
    }
);
    StringBuilder output=new StringBuilder();
    for(int n=0 ; n<N ; n++){
      output.append(A[n % M]).append('\n');
    }
    System.out.print(output);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B195 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var M : int ; M := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,M)->collect(null) ;
        var m : int ; m := 0 ; while m < M do ( (     A[m+1] := m + 1 )  ;     m := m + 1 ) ; 
    A := OclComparator.sortWith(A, OclComparator<int>.newOclComparator()) ; 
    var output : String ; output := StringLib.newString() ;
        var n : int ; n := 0 ; while n < N do ( (     output := output + StringLib.newString(A[n mod M+1]) + StringLib.newString('
') )  ;     n := n + 1 ) ; 
    OclFile["System.out"].print(output) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DifferentIsGood {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    String str=input.next();
    System.out.println(str.length()>26 ?-1 : n-str.chars().distinct().count());
  }
}
------------------------------------------------------------
OCL File:
---------
 class DifferentIsGood {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
     var str : String ; str := input.getCurrent() ;
     OclFile["System.out"].println(if str->size() > 26 then -1 else n - str.chars()->asOrderedSet()->size() endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class DifferentisGood {
  static public void print(String s){
    HashSet<Character>set=new HashSet<>();
    for(int i=0 ; i<s.length(); i++){
      set.add(s.charAt(i));
    }
    int diff=26-set.size();
    set=new HashSet<>();
    int count=0 ;
    boolean flag=false ;
    for(int i=0 ; i<s.length(); i++){
      if(diff>0 && set.contains(s.charAt(i))){
        diff--;
        count++;
      }
      else {
        if(set.contains(s.charAt(i))){
          flag=true ;
        }
      }
      set.add(s.charAt(i));
    }
    if(flag){
      System.out.println(-1);
    }
    else {
      System.out.println(count);
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    print(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class DifferentisGood {
  static    operation print( s : String) : void
  pre: true
  post: true
  activity: (     var set : Set(String) ; set := Set{} ;
         var i : int ; i := 0 ; while i < s->size() do ( (     set := set->including(s->at(i+1)) )  ;     i := i + 1 ) ; 
    var diff : int ; diff := 26 - set->size() ;
    set := Set{} ; 
    var count : int ; count := 0 ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (diff > 0 & set->includes(s->at(i+1))) then (     diff := diff - 1 ; 
     count := count + 1 ) else (     if (set->includes(s->at(i+1))) then (     flag := true ) else skip ) ;  
     set := set->including(s->at(i+1)) )  ;     i := i + 1 ) ; 
    if (flag) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(count) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
     execute print(s) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class good {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char s[]=sc.next().toCharArray();
    int res=0 ;
    if(n>26)System.out.println(-1);
    else {
      int cnt[]=new int[26];
      for(int i=0 ; i<n ; i++){
        int pos=s[i]-'a' ;
        cnt[pos]++;
        if(cnt[pos]>1){
          res++;
          cnt[pos]=1 ;
        }
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class good {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var res : int ; res := 0 ;
    if (n > 26) then     OclFile["System.out"].println(-1) else (     var cnt : Sequence(int) ; cnt := Integer.subrange(1,26)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     var pos : int ; pos := s[i+1] - ('a')->char2byte() ;
     cnt[pos+1] := cnt[pos+1] + 1 ; 
     if (cnt[pos+1] > 1) then (     res := res + 1 ; 
     cnt[pos+1] := 1 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(res) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Mohammad {
  public static void Mohammad_AboHasan()throws IOException {
    FastReader fr=new FastReader();
    int n=fr.nextInt();
    if(n>26){
      System.out.println(-1);
      return ;
    }
    String s=fr.next();
    Set<Character>set=new HashSet<>();
    for(int i=0 ; i<s.length(); i++)set.add(s.charAt(i));
    System.out.println(n-set.size());
  }
  public static void main(String[] args)throws IOException {
    Mohammad_AboHasan();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next()throws IOException {
      while(st==null || ! st.hasMoreElements()){
        st=new StringTokenizer(br.readLine());
      }
      return st.nextToken();
    }
    int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    String nextLine()throws IOException {
      String s=br.readLine();
      return s ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mohammad {
  static   operation Mohammad_AboHasan() : void
  pre: true
  post: true
  activity: (     var fr : FastReader ; fr := FastReader.newFastReader() ;
     var n : int ; n := fr.nextInt() ;
    if (n > 26) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var s : String ; s := fr.next() ;
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := 0 ; while i < s->size() do (     set := set->including(s->at(i+1)) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n - set->size()) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute Mohammad_AboHasan() );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var s : String ; s := br.readLine() ;
     return s );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class kickStart {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    scanner.nextLine();
    char[] chars=scanner.nextLine().toCharArray();
    int distinct=0 ;
    if(chars.length==1)System.out.println(0);
    else if(chars.length>26)System.out.println(-1);
    else {
      Arrays.sort(chars);
      for(int i=1 ; i<chars.length ; i++){
        if(chars[i]!=chars[i-1]){
          distinct++;
        }
      }
      System.out.println(chars.length-(distinct+1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class kickStart {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    skip ; 
    var chars : Sequence(String) ; chars := scanner.nextLine()->characters() ;
    var distinct : int ; distinct := 0 ;
    if (chars->size() = 1) then     OclFile["System.out"].println(0) else     if (chars->size() > 26) then     OclFile["System.out"].println(-1) else (     chars := chars->sort() ; 
         var i : int ; i := 1 ; while i < chars->size() do ( (     if (chars[i+1] /= chars[i - 1+1]) then (     distinct := distinct + 1 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(chars->size() - (distinct + 1)) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Map.Entry ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  static Scanner scan=new Scanner(System.in);
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    TreeMap<String,ArrayList<Integer>>map=new TreeMap<String,ArrayList<Integer>>();
    while(scan.hasNext()){
      String mozi=scan.next();
      int page=si();
      if(! map.containsKey(mozi)){
        ArrayList<Integer>list=new ArrayList<Integer>();
        list.add(page);
        map.put(mozi,list);
      }
      else {
        ArrayList<Integer>list=map.get(mozi);
        list.add(page);
        map.put(mozi,list);
      }
    }
    for(Entry<String,ArrayList<Integer>>e : map.entrySet()){
      out.println(e.getKey());
      ArrayList<Integer>list=e.getValue();
      Collections.sort(list);
      for(int i=0 ; i<list.size(); i++){
        if(i==list.size()-1)out.println(list.get(i));
        else out.print(list.get(i)+" ");
      }
    }
    out.flush();
  }
  static int si(){
    return Integer.parseInt(scan.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var map : Map(String,Sequence(int)) ; map := Map{} ;
     while (scan.hasNext()) do (     var mozi : String ; mozi := scan.getCurrent() ;
     var page : int ; page := si() ;
     if (not(map->keys()->includes(mozi))) then (     var list : Sequence(int) ; list := Sequence{} ;
     list := list->including(page) ; 
     map := map->union(Map{mozi |-> list}) ) else (     var list : Sequence(int) ; list := map->at(mozi) ;
     list := list->including(page) ; 
     map := map->union(Map{mozi |-> list}) ) ) ; 
     for (e : map->asSet()) do ( (     skip ; 
     var list : Sequence(int) ; list := e.getValue() ;
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < list->size() do ( (     if (i = list->size() - 1) then     skip ; else     skip ; )  ;     i := i + 1 ) )  ) ; 
     skip );
  static   operation si() : int
  pre: true
  post: true
  activity: (     return (scan.getCurrent())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Iterator ;
import java.util.Collections ;
import java.util.Comparator ;
class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int N ;
    N=scan.nextInt();
    ArrayList<Integer>a=new ArrayList<Integer>();
    for(int i=0 ; i<N ; i++)a.add(scan.nextInt());
    Collections.sort(a);
    double max=(double)a.get(N-1);
    double harfMax=max/2 ;
    double r_=max,r=a.get(0);
    for(int i=0 ; i<N-1 ; i++){
      if(r_>Math.abs((double)a.get(i)-harfMax)){
        r_=Math.abs((double)a.get(i)-harfMax);
        r=a.get(i);
      }
    }
    System.out.print((int)max+" "+(int)r);
  }
  public static void check(ArrayList<Integer>a){
    System.out.print("sorting->");
    for(int i=0 ; i<a.size(); i++)System.out.print(a.get(i)+" ");
    System.out.print(" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ;
    N := scan.getCurrent()->toInteger() ; 
    var a : Sequence(int) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < N do (     a := a->including(scan.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var max : double ; max := a->at(N - 1+1)->oclAsType(double) ;
    var harfMax : double ; harfMax := max / 2 ;
    var r_ : double ; r_ := max ;
    var r : double ; r := a->at(0+1) ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     if (r_ > if a->at(i+1)->oclAsType(double) - harfMax < 0 then -(a->at(i+1)->oclAsType(double) - harfMax) else a->at(i+1)->oclAsType(double) - harfMax endif) then (     r_ := if a->at(i+1)->oclAsType(double) - harfMax < 0 then -(a->at(i+1)->oclAsType(double) - harfMax) else a->at(i+1)->oclAsType(double) - harfMax endif ; 
     r := a->at(i+1) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(max->oclAsType(int) + " " + r->oclAsType(int)) ; 
 );
  static   operation check( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("sorting->") ; 
         var i : int ; i := 0 ; while i < a->size() do (     OclFile["System.out"].print(a->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(" ") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Word {
  String name ;
  int page[],size ;
  public Word(String n){
    name=n ;
    page=new int[100];
    size=0 ;
  }
  public void addPage(int p){
    page[size++]=p ;
  }
  public String getName(){
    return name ;
  }
  public void printWord(){
    int i ;
    Arrays.sort(page,0,size);
    System.out.println(name);
    for(i=0 ; i+1<size ; i++){
      System.out.print(page[i]+" ");
    }
    System.out.println(page[i]);
  }
}
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    Word w[]=new Word[100];
    int size=0 ;
    while(true){
      int i ;
      String s[];
      if(scan.hasNextLine()){
        s=scan.nextLine().split(" ");
      }
      else {
        break ;
      }
      for(i=0 ; i<size && ! s[0] .equals(w[i] .getName()); i++);
      if(i==size){
        w[size++]=new Word(s[0]);
      }
      w[i] .addPage(Integer.parseInt(s[1]));
    }
    for(int i=0 ; i<size-1 ; i++){
      for(int j=i+1 ; j<size ; j++){
        if(w[i] .getName().compareTo(w[j] .getName())>0){
          Word tmp=w[i];
          w[i]=w[j];
          w[j]=tmp ;
        }
      }
    }
    for(int i=0 ; i<size ; i++){
      w[i] .printWord();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Word {
   attribute name : String;
   attribute page : int;
   static operation newWord( n : String) : Word
  pre: true
  post: true
  activity:
  ( var self : Word ;
    self := createWord();
    self.initialise(n);
    return self );
  operation initialise( n : String) : void
  pre: true  post: true
  activity: (     name := n ; 
     page := Integer.subrange(1,100)->collect(0) ; 
     size := 0 );
   operation addPage( p : int) : void
  pre: true
  post: true
  activity: (      page[size+1] := p  ; size := size + 1 );
   operation getName() : String
  pre: true
  post: true
  activity: (     return name );
   operation printWord() : void
  pre: true
  post: true
  activity: (     var i : int ;
     page := page.subrange(1,0)^(page.subrange(0+1,size)->sort())^page.subrange(size+1,page.size) ; 
    OclFile["System.out"].println(name) ; 
        i := 0 ; while i + 1 < size do ( (     OclFile["System.out"].print(page[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(page[i+1]) ; 
 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : Sequence(Word) ; w := Integer.subrange(1,100)->collect(null) ;
    var size : int ; size := 0 ;
    while (true) do (     var i : int ;
     var s : Sequence(String) ;
    if (scan.hasNextLine()) then (     s := scan.nextLine()->split(" ") ) else (     break ) ;  
        i := 0 ; while i < size & not(s[0+1] = w[i+1].getName()) do (   ;     i := i + 1 ) ; 
    if (i = size) then (      w[size+1] := Word.newWord(s[0+1])  ; size := size + 1 ) else skip ; 
    w[i+1].addPage((s[1+1])->toInteger()) ; 
 ) ; 
        var i : int ; i := 0 ; while i < size - 1 do ( (         var j : int ; j := i + 1 ; while j < size do ( (     if (w[i+1].getName()->compareTo(w[j+1].getName()) > 0) then (     var tmp : Word ; tmp := w[i+1] ;
     w[i+1] := w[j+1] ; 
     w[j+1] := tmp ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < size do ( (     w[i+1].printWord() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  class index implements Comparable<index>{
    String key="" ;
    LinkedList<Integer>p=new LinkedList<Integer>();
    @ Override public int compareTo(index o){
      return this.key.compareTo(o.key);
    }
    @ Override public String toString(){
      String ret=key+"\n" ;
      Integer m[]=null ;
      m=p.toArray(new Integer[0]);
      Arrays.sort(m);
      String r2="" ;
      for(int a : m){
        r2+=" "+a ;
      }
      ret+=r2.trim();
      return ret ;
    }
    @ Override public boolean equals(Object obj){
      return this.key.equals(((index)obj).key);
    }
  }
  void run(){
    LinkedList<index>map=new LinkedList<Main.index>();
    for(; sc.hasNext(); ){
      String w=sc.next();
      int p=sc.nextInt();
      index o=new index();
      o.key=w ;
      o.p.add(p);
      int i=map.indexOf(o);
      if(i==-1){
        map.add(o);
      }
      else {
        map.get(i).p.add(p);
      }
    }
    index[] s=map.toArray(new index[0]);
    Arrays.sort(s);
    for(int i=0 ; i<s.length ; i++){
      System.out.println(s[i]);
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
 class index implements Comparable<index> {
   attribute key : String := "";
   attribute p : Sequence(int) := Sequence{};
      operation compareTo( o : index) : int
  pre: true
  post: true
  activity: (     return self.key->compareTo(o.key) );
      operation toString() : String
  pre: true
  post: true
  activity: (     var ret : String ; ret := key + "\n" ;
     var m : Sequence(int) ; m := null ;
    m := p->asSequence() ; 
    m := m->sort() ; 
    var r2 : String ; r2 := "" ;
    for (a : m) do ( (     r2 := r2+(" " + a) )  ) ; 
    ret := ret+(r2->trim()) ; 
    return ret 
 );
      operation equals( obj : OclAny) : boolean
  pre: true
  post: true
  activity: (     return self.key = (obj->oclAsType(index)).key );
}
   operation run() : void
  pre: true
  post: true
  activity: (     var map : Sequence(index) ; map := Sequence{} ;
       while sc.hasNext() do ( (     var w : String ; w := sc.getCurrent() ;
     var p : int ; p := sc.getCurrent()->toInteger() ;
    var o : index ; o := index.newindex() ;
    o.key := w ; 
    o.p->excludes(p) ; 
    var i : int ; i := map->indexOf(o)-1 ;
    if (i = -1) then (     map := map->including(o) ) else (     map->at(i+1).p->excludes(p) ) ;  
 )  ) ; 
    var s : Sequence(index) ; s := map->asSequence() ;
    s := s->sort() ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     OclFile["System.out"].println(s[i+1]) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Task5 {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int d=input.nextInt();
    int h=input.nextInt();
    if(n>=2 && n<=100000 && h>=1 && d>=h && n-1>=d){
      int i ;
      if(d>2*h){
        System.out.println("-1");
      }
      else if(d==h){
        if(d==1){
          if(n==2){
            System.out.println("1 2");
            System.exit(0);
          }
          else System.out.println("-1");
        }
        else if(d==n-1){
          for(i=1 ; i<n ; i++){
            System.out.println(i+" "+(i+1));
          }
        }
        else {
          for(i=1 ; i<=h ; i++){
            System.out.println(i+" "+(i+1));
          }
          i++;
          while(i<=n){
            System.out.println("2 "+(i++));
          }
        }
      }
      else {
        int j ;
        for(i=1 ; i<=h ; i++){
          System.out.println(i+" "+(i+1));
        }
        i++;
        while(i<=n){
          System.out.println("1 "+i);
          i++;
          for(j=1 ; j<d-h ; j++){
            if(i>n)break ;
            System.out.println((i-1)+" "+i);
            i++;
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Task5 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var d : int ; d := input.getCurrent()->toInteger() ;
    var h : int ; h := input.getCurrent()->toInteger() ;
    if (n >= 2 & n <= 100000 & h >= 1 & d >= h & n - 1 >= d) then (     var i : int ;
     if (d > 2 * h) then (     OclFile["System.out"].println("-1") ) else     if (d = h) then (     if (d = 1) then (     if (n = 2) then (     OclFile["System.out"].println("1 2") ; 
 OclProcess.exit(0) ) else     OclFile["System.out"].println("-1") ; ) else     if (d = n - 1) then (         i := 1 ; while i < n do ( (     OclFile["System.out"].println(i + " " + (i + 1)) )  ;     i := i + 1 ) ) else (         i := 1 ; while i <= h do ( (     OclFile["System.out"].println(i + " " + (i + 1)) )  ;     i := i + 1 ) ; 
     i := i + 1 ; 
     while (i <= n) do (     OclFile["System.out"].println("2 " + (i)) ) ) ;  ) else (     var j : int ;
         i := 1 ; while i <= h do ( (     OclFile["System.out"].println(i + " " + (i + 1)) )  ;     i := i + 1 ) ; 
     i := i + 1 ; 
     while (i <= n) do (     OclFile["System.out"].println("1 " + i) ; 
     i := i + 1 ; 
         j := 1 ; while j < d - h do ( (     if (i > n) then     break else skip ; 
     OclFile["System.out"].println((i - 1) + " " + i) ; 
     i := i + 1 )  ;     j := j + 1 ) ) ) ;  ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.HashMap ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
public class Main {
  Scanner in=new Scanner(System.in);
  void solve(){
    HashMap<String,ArrayList<String>>map=new HashMap<>();
    while(in.hasNextLine()){
      String[] s=in.nextLine().split(" ");
      if(map.containsKey(s[0])){
        map.get(s[0]).add(s[1]);
      }
      else {
        map.put(s[0],new ArrayList<>(Arrays.asList(s[1])));
      }
    }
    String[] p=map.keySet().toArray(new String[map.size()]);
    Arrays.sort(p);
    for(String s : p){
      System.out.println(s);
      ArrayList<String>list=map.get(s);
      list.sort(new Comparator<String>(){
        public int compare(String s1,String s2){
          return Integer.parseInt(s1)>Integer.parseInt(s2)? 1 :-1 ;
        }
      }
);
      System.out.println(String.join(" ",map.get(s)));
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation solve() : void
  pre: true
  post: true
  activity: (     var map : Map(String,Sequence(String)) ; map := Map{} ;
     while (in.hasNextLine()) do (     var s : Sequence(String) ; s := in.nextLine()->split(" ") ;
     if (map->keys()->includes(s[0+1])) then (     map->at(s[0+1])->excludes(s[1+1]) ) else (     map := map->union(Map{s[0+1] |-> Sequence{}->union(s[1+1])}) ) ) ; 
    var p : Sequence(String) ; p := map->keys()->asSequence() ;
    p := p->sort() ; 
    for (s : p) do ( (     OclFile["System.out"].println(s) ; 
     var list : Sequence(String) ; list := map->at(s) ;
     list := list.sort(OclComparator<String>.newOclComparator()) ; 
     OclFile["System.out"].println(join(" ", map->at(s))) )  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    class IndexData {
      String word ;
      List<Integer>page=new ArrayList<>();
    };
    List<IndexData>list=new ArrayList<>();
    Scanner scanner=new Scanner(System.in);
    for(; scanner.hasNext(); ){
      String word=scanner.next();
      int page=scanner.nextInt();
      boolean is_equals=false ;
      for(int i=0 ; i<list.size(); i++){
        IndexData index=list.get(i);
        if(word.equals(index.word)){
          is_equals=true ;
          index.page.add(page);
          list.set(i,index);
          break ;
        }
      }
      if(! is_equals){
        IndexData index=new IndexData();
        index.word=word ;
        index.page.add(page);
        list.add(index);
      }
    }
    Collections.sort(list,new Comparator<IndexData>(){
      @ Override public int compare(IndexData obj0,IndexData obj1){
        return obj0.word.compareTo(obj1.word);
      }
    }
);
    for(int i=0 ; i<list.size(); i++){
      IndexData index=list.get(i);
      System.out.println(index.word);
      Collections.sort(index.page,new Comparator<Integer>(){
        @ Override public int compare(Integer obj0,Integer obj1){
          return(obj0>obj1)? 1 :-1 ;
        }
      }
);
      for(int j=0 ; j<index.page.size(); j++){
        System.out.print((j>0 ? " " : "")+index.page.get(j));
      }
      System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( class IndexData {
   attribute word : String;
   attribute page : Sequence(int) := Sequence{};
}
    var list : Sequence(IndexData) ; list := Sequence{} ;
    var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
      while scanner.hasNext() do ( (     var word : String ; word := scanner.getCurrent() ;
     var page : int ; page := scanner.getCurrent()->toInteger() ;
    var is_equals : boolean ; is_equals := false ;
        var i : int ; i := 0 ; while i < list->size() do ( (     var index : IndexData ; index := list->at(i+1) ;
     if (word = index.word) then (     is_equals := true ; 
     index.page->excludes(page) ; 
     list := list.setAt(i+1,index) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (not(is_equals)) then (     var index : IndexData ; index := IndexData.newIndexData() ;
     index.word := word ; 
     index.page->excludes(page) ; 
     list := list->including(index) ) else skip ; 
 )  ) ; 
    list, OclComparator<IndexData>.newOclComparator() := list, OclComparator<IndexData>.newOclComparator()->sort() ; 
        var i : int ; i := 0 ; while i < list->size() do ( (     var index : IndexData ; index := list->at(i+1) ;
     OclFile["System.out"].println(index.word) ; 
    index.page, OclComparator<int>.newOclComparator() := index.page, OclComparator<int>.newOclComparator()->sort() ; 
        var j : int ; j := 0 ; while j < index.page->size() do ( (     OclFile["System.out"].print((if j > 0 then " " else "" endif) + index.page->at(j+1)) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println("") ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countNumbers(int l,int r){
    return((r/6)-(l-1)/6);
  }
  public static void main(String[] args){
    int l=1000,r=6000 ;
    System.out.println(countNumbers(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countNumbers( l : int, r : int) : int
  pre: true
  post: true
  activity: (     return ((r / 6) - (l - 1) / 6) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 1000 ;
    var r : int ; r := 6000 ;
     OclFile["System.out"].println(countNumbers(l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int find_greatest_divisor(int l,int r){
    if(l==r){
      return l ;
    }
    return 1 ;
  }
  public static void main(String[] args){
    int l=2,r=12 ;
    System.out.println(find_greatest_divisor(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find_greatest_divisor( l : int, r : int) : int
  pre: true
  post: true
  activity: (     if (l = r) then (     return l ) else skip ; 
     return 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 2 ;
    var r : int ; r := 12 ;
     OclFile["System.out"].println(find_greatest_divisor(l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findSumPairs(int a[],int n){
    Map<Integer,Integer>mpp=new HashMap<>();
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        mpp.put(a[i]+a[j],mpp.get(a[i]+a[j])==null ? 1 : mpp.get(a[i]+a[j])+1);
      }
    }
    int occur=0 ;
    for(Map.Entry<Integer,Integer>entry : mpp.entrySet()){
      if(entry.getValue()>occur){
        occur=entry.getValue();
      }
    }
    for(Map.Entry<Integer,Integer>entry : mpp.entrySet()){
      if(entry.getValue()==occur)System.out.println(entry.getKey());
    }
  }
  public static void main(String args[]){
    int a[]={
      1,8,3,11,4,9,2,7 };
      int n=a.length ;
      findSumPairs(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSumPairs( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var mpp : Map(int,int) ; mpp := Map{} ;
         var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     mpp := mpp->union(Map{a[i+1] + a[j+1] |-> if mpp->at(a[i+1] + a[j+1]) = null then 1 else mpp->at(a[i+1] + a[j+1]) + 1 endif}) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var occur : int ; occur := 0 ;
    for (entry : mpp->asSet()) do ( (     if (entry.getValue() > occur) then (     occur := entry.getValue() ) else skip )  ) ; 
    for (entry : mpp->asSet()) do ( (     if (entry.getValue() = occur) then     OclFile["System.out"].println(entry.getKey()) ; else skip )  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,8,3,11,4,9,2,7} ;
     var n : int ; n := a->size() ;
     execute findSumPairs(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static void twoParts(String str){
    int flag=0 ;
    String a="" ;
    char[] gfg=str.toCharArray();
    for(int i=0 ; i<str.length(); i++){
      if(gfg[i]=='4'){
        gfg[i]='3' ;
        a+='1' ;
        flag=1 ;
      }
      else if(flag!=0)a+='0' ;
    }
    str=new String(gfg);
    System.out.print(str+" "+a);
  }
  public static void main(String[] args){
    String str="9441" ;
    twoParts(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation twoParts( str : String) : void
  pre: true
  post: true
  activity: (     var flag : int ; flag := 0 ;
     var a : String ; a := "" ;
    var gfg : Sequence(String) ; gfg := str->characters() ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (gfg[i+1] = '4') then (     gfg[i+1] := '3' ; 
     a := a+('1') ; 
     flag := 1 ) else     if (flag /= 0) then     a := a+('0') ; else skip ; )  ;     i := i + 1 ) ; 
    str := StringLib.newString(gfg) ; 
    OclFile["System.out"].print(str + " " + a) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "9441" ;
     execute twoParts(str) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class AbsentRemainder {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    while(test-->0){
      int n=sc.nextInt();
      int minimum=Integer.MAX_VALUE ;
      int[] nums=new int[n];
      for(int i=0 ; i<n ; i++){
        nums[i]=sc.nextInt();
        minimum=Math.min(minimum,nums[i]);
      }
      for(int i=0,k=0 ; k<n/2 ; i++){
        if(nums[i]!=minimum){
          System.out.println(nums[i]+" "+minimum);
          k++;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AbsentRemainder {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var minimum : int ; minimum := 2147483647 ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := sc.getCurrent()->toInteger() ; 
     minimum := Set{minimum, nums[i+1]}->min() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ;
    var k : int ; k := 0 ; while k < n / 2 do ( (     if (nums[i+1] /= minimum) then (     OclFile["System.out"].println(nums[i+1] + " " + minimum) ; 
     k := k + 1 ) else skip )  ;     i := i + 1 ) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
class Main {
  public static void main(String...args){
    int N=IN.nextInt();
    int ans=0 ;
    for(int i=0 ; i<N ; i++){
      ans+=IN.nextInt();
    }
    puts(ans-N);
  }
  static final Scanner IN=new Scanner(System.in);
  static<T>void puts(T arg){
    System.out.println(arg);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := IN.nextInt() ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     ans := ans+(IN.nextInt()) )  ;     i := i + 1 ) ; 
     execute puts(ans - N) );
  static    attribute IN : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation puts<T>( arg : T) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(arg) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.Closeable ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.LinkedList ;
import java.util.Map.Entry ;
import java.util.PriorityQueue ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(final Scanner sc=new Scanner(System.in)){
      final int N=sc.nextInt();
      long answer=0 ;
      for(int i=0 ; i<N ; i++){
        answer+=sc.nextLong()-1 ;
      }
      System.out.println(answer);
    }
  }
  public static class Scanner implements Closeable {
    private BufferedReader br ;
    private StringTokenizer tok ;
    public Scanner(InputStream is)throws IOException {
      br=new BufferedReader(new InputStreamReader(is));
    }
    private void getLine()throws IOException {
      while(! hasNext()){
        tok=new StringTokenizer(br.readLine());
      }
    }
    private boolean hasNext(){
      return tok!=null && tok.hasMoreTokens();
    }
    public String next()throws IOException {
      getLine();
      return tok.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public int[] nextIntArray(int n)throws IOException {
      final int[] ret=new int[n];
      for(int i=0 ; i<n ; i++){
        ret[i]=this.nextInt();
      }
      return ret ;
    }
    public long[] nextLongArray(int n)throws IOException {
      final long[] ret=new long[n];
      for(int i=0 ; i<n ; i++){
        ret[i]=this.nextLong();
      }
      return ret ;
    }
    public void close()throws IOException {
      br.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile = OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var answer : long ; answer := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     answer := answer+(sc.getCurrent()->toLong() - 1) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(answer) ))  );
  static class Scanner implements Closeable {
   attribute br : OclFile;
   attribute tok : OclIterator;
   static operation newScanner( is : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
   operation getLine() : void
  pre: true
  post: true
  activity: (     while (not(hasNext())) do (     tok := OclIterator.newOclIterator_String(br.readLine()) ) );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return tok /= null & tok.hasNext() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute getLine() ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ret : Sequence(int) ; ret := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     ret[i+1] := self.nextInt() )  ;     i := i + 1 ) ; 
     return ret );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var ret : Sequence(long) ; ret := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     ret[i+1] := self.nextLong() )  ;     i := i + 1 ) ; 
     return ret );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  static int answer=0 ;
  static String str[];
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int length=Integer.parseInt(br.readLine());
    str=br.readLine().split(" ");
    for(String num : str){
      answer+=Integer.parseInt(num);
    }
    answer-=length ;
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute answer : int := 0;
  static   attribute str : Sequence(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var length : int ; length := (br.readLine())->toInteger() ;
    str := br.readLine()->split(" ") ; 
    for (num : str) do ( (     answer := answer+((num)->toInteger()) )  ) ; 
    answer := answer-(length) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder ans=new StringBuilder();
    ArrayList<String>lines=new ArrayList<>();
    String input=sc.nextLine();
    int max=input.length();
    boolean left=true ;
    lines.add(input);
    while(sc.hasNextLine()){
      input=sc.nextLine();
      lines.add(input);
      if(input.length()>max){
        max=input.length();
      }
    }
    for(int i=0 ; i<max+2 ; i++){
      ans.append('*');
    }
    ans.append('\n');
    for(String line : lines){
      double l=(max-line.length())/2.0 ;
      double r=(max-line.length())/2.0 ;
      if(left){
        r+=0.5 ;
      }
      else {
        l+=0.5 ;
      }
      if((int)l!=(int)r){
        left=! left ;
      }
      ans.append('*');
      for(int i=0 ; i<(int)l ; i++){
        ans.append(' ');
      }
      ans.append(line);
      for(int i=0 ; i<(int)r ; i++){
        ans.append(' ');
      }
      ans.append("*\n");
    }
    for(int i=0 ; i<max+2 ; i++){
      ans.append('*');
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ans : String ; ans := StringLib.newString() ;
    var lines : Sequence(String) ; lines := Sequence{} ;
    var input : String ; input := sc.nextLine() ;
    var max : int ; max := input->size() ;
    var left : boolean ; left := true ;
    lines := lines->including(input) ; 
    while (sc.hasNextLine()) do (     input := sc.nextLine() ; 
     lines := lines->including(input) ; 
     if (input->size() > max) then (     max := input->size() ) else skip ) ; 
        var i : int ; i := 0 ; while i < max + 2 do ( (     ans := ans + StringLib.newString('*') )  ;     i := i + 1 ) ; 
    ans := ans + StringLib.newString('
') ; 
    for (line : lines) do ( (     var l : double ; l := ((max)->char2byte() - line->size()) / 2.0 ;
     var r : double ; r := ((max)->char2byte() - line->size()) / 2.0 ;
    if (left) then (     r := r+(0.5) ) else (     l := l+(0.5) ) ;  
    if (l->oclAsType(int) /= r->oclAsType(int)) then (     left := not(left) ) else skip ; 
    ans := ans + StringLib.newString('*') ; 
        var i : int ; i := 0 ; while i < l->oclAsType(int) do ( (     ans := ans + StringLib.newString(' ') )  ;     i := i + 1 ) ; 
    ans := ans + StringLib.newString(line) ; 
        var i : int ; i := 0 ; while i < r->oclAsType(int) do ( (     ans := ans + StringLib.newString(' ') )  ;     i := i + 1 ) ; 
    ans := ans + StringLib.newString("*\n") ; 
 )  ) ; 
        var i : int ; i := 0 ; while i < max + 2 do ( (     ans := ans + StringLib.newString('*') )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    br.readLine();
    String str[]=br.readLine().split(" ");
    BigInteger d[]=new BigInteger[str.length];
    BigInteger v=BigInteger.ONE ;
    for(int i=0 ; i<str.length ; i++){
      d[i]=new BigInteger(str[i]);
      v=v.multiply(d[i]);
    }
    v=v.subtract(BigInteger.ONE);
    BigInteger t=BigInteger.ZERO ;
    for(int i=0 ; i<str.length ; i++){
      t=t.add(v.remainder(d[i]));
    }
    System.out.println(t);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     skip ; 
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var d : Sequence(long) ; d := Integer.subrange(1,str->size())->collect(null) ;
    var v : long ; v := 1 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     d[i+1] := long(str[i+1]) ; 
     v := v.multiply(d[i+1]) )  ;     i := i + 1 ) ; 
    v := v.subtract(1) ; 
    var t : long ; t := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     t := t->excludes(v.remainder(d[i+1])) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(t) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Map ;
import java.util.PriorityQueue ;
import java.util.Set ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    long res=0 ;
    for(int i=0 ; i<n ; i++){
      int num=sc.nextInt();
      res+=(num-1);
    }
    System.out.println(res);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : int ; n := sc.nextInt() ;
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := sc.nextInt() ;
     res := res+((num - 1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countMoves(int n){
    int ct=0 ;
    for(int i=1 ; i<=n ; i++)ct+=i*(n-i);
    ct+=n ;
    return ct ;
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(countMoves(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countMoves( n : int) : int
  pre: true
  post: true
  activity: (     var ct : int ; ct := 0 ;
         var i : int ; i := 1 ; while i <= n do (     ct := ct+(i * (n - i)) ;  ;     i := i + 1 ) ; 
     ct := ct+(n) ; 
     return ct );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(countMoves(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void gouldSequence(int n){
    for(int row_num=1 ; row_num<=n ; row_num++){
      int count=1 ;
      int c=1 ;
      for(int i=1 ; i<=row_num ; i++){
        c=c*(row_num-i)/i ;
        if(c % 2==1)count++;
      }
      System.out.print(count+" ");
    }
  }
  public static void main(String[] args){
    int n=16 ;
    gouldSequence(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gouldSequence( n : int) : void
  pre: true
  post: true
  activity: (         var row_num : int ; row_num := 1 ; while row_num <= n do ( (     var count : int ; count := 1 ;
     var c : int ; c := 1 ;
         var i : int ; i := 1 ; while i <= row_num do ( (     c := c * (row_num - i) / i ; 
     if (c mod 2 = 1) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(count + " ") )  ;     row_num := row_num + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 16 ;
     execute gouldSequence(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  static FastScanner in=new FastScanner();
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    int n=in.nextInt();
    char[] s=in.next().toCharArray();
    int[] arr=in.readArray(n);
    int count=0 ;
    boolean condi=false ;
    int l=0,r=1 ;
    int min=Integer.MAX_VALUE ;
    int temp=-1 ;
    for(int i=0 ; i<n ; i++){
      if(s[i]=='R')temp=arr[i];
      else if(s[i]=='L' && temp!=-1){
        min=Math.min(arr[i]-temp,min);
      }
    }
    out.println(min==Integer.MAX_VALUE ?-1 : min/2);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   attribute in : FastScanner := FastScanner.newFastScanner();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var s : Sequence(String) ; s := in.next()->characters() ;
    var arr : Sequence(int) ; arr := in.readArray(n) ;
    var count : int ; count := 0 ;
    var condi : boolean ; condi := false ;
    var l : int ; l := 0 ;
    var r : int ; r := 1 ;
    var min : int ; min := 2147483647 ;
    var temp : int ; temp := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] = 'R') then     temp := arr[i+1] ; else     if (s[i+1] = 'L' & temp /= -1) then (     min := Set{arr[i+1] - temp, min}->min() ) else skip ; )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.IllegalFormatCodePointException ;
import java.util.Scanner ;
public class Main {
  static ArrayList md=new ArrayList();
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String s=in.next();
    int[] x=new int[n];
    int d=0 ;
    int temp=0 ;
    for(int i=0 ; i<n ; i++){
      x[i]=in.nextInt();
    }
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='R' && i!=s.length()-1){
        if(s.charAt(i+1)=='L'){
          d=(x[i+1]-x[i])/2 ;
          if(d<temp || temp==0)temp=d ;
        }
      }
    }
    if(temp==0){
      System.out.println("-1");
    }
    else System.out.println(temp);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute md : Sequence := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var d : int ; d := 0 ;
    var temp : int ; temp := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'R' & i /= s->size() - 1) then (     if (s->at(i + 1+1) = 'L') then (     d := (x[i + 1+1] - x[i+1]) / 2 ; 
     if (d < temp or temp = 0) then     temp := d ; else skip ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (temp = 0) then (     OclFile["System.out"].println("-1") ) else     OclFile["System.out"].println(temp) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class _28 {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    while(t-->0){
      int n=input.nextInt();
      int[] arr=new int[n];
      int min=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; i++){
        int curr=input.nextInt();
        arr[i]=curr ;
        min=Math.min(min,curr);
      }
      n=n/2 ;
      int i=0 ;
      while(i<arr.length && n>0){
        if(arr[i]==min){
          i++;
        }
        else {
          System.out.println(arr[i]+" "+min);
          i++;
          n--;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := input.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     var curr : int ; curr := input.getCurrent()->toInteger() ;
     arr[i+1] := curr ; 
     min := Set{min, curr}->min() )  ;     i := i + 1 ) ; 
    n := n / 2 ; 
    var i : int ; i := 0 ;
    while (i < arr->size() & n > 0) do (     if (arr[i+1] = min) then (     i := i + 1 ) else (     OclFile["System.out"].println(arr[i+1] + " " + min) ; 
     i := i + 1 ; 
     n := n - 1 ) ) ; 
 ) ;  ) );
}
8 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := input.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     var curr : int ; curr := input.getCurrent()->toInteger() ;
     arr[i+1] := curr ; 
     min := Set{min, curr}->min() )  ;     i := i + 1 ) ; 
    n := n / 2 ; 
    var i : int ; i := 0 ;
    while (i < arr->size() & n > 0) do (     if (arr[i+1] = min) then (     i := i + 1 ) else (     OclFile["System.out"].println(arr[i+1] + " " + min) ; 
     i := i + 1 ; 
     n := n - 1 ) ) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import com.sun.security.jgss.GSSUtil ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    String str=input.next();
    Vector<Integer>v=new Vector<>();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=input.nextInt();
    int counter=0 ;
    for(int i=1 ; i<str.length(); i++){
      if(str.charAt(i-1)=='R' && str.charAt(i)=='L'){
        v.add((a[i]-a[i-1])/2);
      }
    }
    if(! v.isEmpty()){
      Collections.sort(v);
      System.out.println(v.get(0));
    }
    else System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var str : String ; str := input.getCurrent() ;
    var v : Sequence(int) ; v := Sequence{} ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := input.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var counter : int ; counter := 0 ;
        var i : int ; i := 1 ; while i < str->size() do ( (     if (str->at(i - 1+1) = 'R' & str->at(i+1) = 'L') then (     v := v->including((a[i+1] - a[i - 1+1]) / 2) ) else skip )  ;     i := i + 1 ) ; 
    if (not(v->isEmpty())) then (     v := v->sort() ; 
     OclFile["System.out"].println(v->at(0+1)) ) else     OclFile["System.out"].println(-1) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DS {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int c=s.nextInt()-1 ;
    String str=s.next();
    int y1=s.nextInt();
    int p=Integer.MAX_VALUE ;
    boolean b=true ;
    for(int i=0 ; i<c ; i++){
      int y2=s.nextInt();
      int pp=0 ;
      boolean f=false ;
      if(str.charAt(i)=='R' && str.charAt(i+1)=='L'){
        pp=(y2-y1)/2 ;
        f=true ;
        b=false ;
      }
      y1=y2 ;
      if(pp<p && f)p=pp ;
    }
    if(b)System.out.println(-1);
    else System.out.println(p);
  }
}
------------------------------------------------------------
OCL File:
---------
 class DS {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : int ; c := s.getCurrent()->toInteger() - 1 ;
    var str : String ; str := s.getCurrent() ;
    var y1 : int ; y1 := s.getCurrent()->toInteger() ;
    var p : int ; p := 2147483647 ;
    var b : boolean ; b := true ;
        var i : int ; i := 0 ; while i < c do ( (     var y2 : int ; y2 := s.getCurrent()->toInteger() ;
     var pp : int ; pp := 0 ;
    var f : boolean ; f := false ;
    if (str->at(i+1) = 'R' & str->at(i + 1+1) = 'L') then (     pp := (y2 - (y1)->char2byte()) / 2 ; 
     f := true ; 
     b := false ) else skip ; 
    y1 := y2 ; 
    if (pp < p & f) then     p := pp ; else skip ; 
 )  ;     i := i + 1 ) ; 
    if (b) then     OclFile["System.out"].println(-1) else     OclFile["System.out"].println(p) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF699_D2_A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int num=scanner.nextInt();
    int[] colliders=new int[num];
    scanner.nextLine();
    String directions=scanner.nextLine();
    int ans=999999999 ;
    for(int i=0 ; i<num ; i++){
      colliders[i]=scanner.nextInt();
    }
    for(int i=1 ; i<num ; i++){
      if(directions.charAt(i)=='L' && directions.charAt(i-1)=='R'){
        long time=(colliders[i]+colliders[i-1])/2 ;
        time=Math.abs(time-colliders[i-1]);
        if(time<ans)ans=(int)time ;
      }
    }
    if(ans==999999999){
      System.out.println(-1);
    }
    else {
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF699_D2_A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := scanner.getCurrent()->toInteger() ;
    var colliders : Sequence(int) ; colliders := Integer.subrange(1,num)->collect(0) ;
    skip ; 
    var directions : String ; directions := scanner.nextLine() ;
    var ans : int ; ans := 999999999 ;
        var i : int ; i := 0 ; while i < num do ( (     colliders[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < num do ( (     if (directions->at(i+1) = 'L' & directions->at(i - 1+1) = 'R') then (     var time : long ; time := (colliders[i+1] + colliders[i - 1+1]) / 2 ;
     time := if time - colliders[i - 1+1] < 0 then -(time - colliders[i - 1+1]) else time - colliders[i - 1+1] endif ; 
     if (time < ans) then     ans := time->oclAsType(int) ; else skip ) else skip )  ;     i := i + 1 ) ; 
    if (ans = 999999999) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(ans) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    int M=Integer.parseInt(sc.next());
    int[][] p=new int[M][3];
    for(int i=0 ; i<M ; i++){
      p[i][0]=i ;
      p[i][1]=Integer.parseInt(sc.next());
      p[i][2]=Integer.parseInt(sc.next());
    }
    sc.close();
    Arrays.sort(p,(o1,o2)->o1[1]==o2[1] ? o1[2]-o2[2] : o1[1]-o2[1]);
    Map<Integer,Integer[]>map=new HashMap<>();
    int now=0 ;
    int count=1 ;
    for(int i=0 ; i<M ; i++){
      if(now==p[i][1]){
        count++;
      }
      else {
        now=p[i][1];
        count=1 ;
      }
      Integer[] c={
        p[i][1],count };
        map.put(p[i][0],c);
      }
      PrintWriter out=new PrintWriter(System.out);
      for(int i=0 ; i<M ; i++){
        Integer[] r=map.get(i);
        out.println(String.format("%06d%06d",r[0],r[1]));
      }
      out.flush();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var M : int ; M := (sc.getCurrent())->toInteger() ;
    var p : Sequence(Sequence(int)) ; p := Integer.subrange(1,M)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < M do ( (     p[i+1][0+1] := i ; 
     p[i+1][1+1] := (sc.getCurrent())->toInteger() ; 
     p[i+1][2+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    p := OclComparator.sortWith(p, lambda (o1 , o2) : OclAny in if o1[1+1] = o2[1+1] then o1[2+1] - o2[2+1] else o1[1+1] - o2[1+1] endif) ; 
    var map : Map(int,Sequence(int)) ; map := Map{} ;
    var now : int ; now := 0 ;
    var count : int ; count := 1 ;
        var i : int ; i := 0 ; while i < M do ( (     if (now = p[i+1][1+1]) then (     count := count + 1 ) else (     now := p[i+1][1+1] ; 
     count := 1 ) ;  
     var c : Sequence(int) ; c := Sequence{p[i+1][1+1],count} ;
     map := map->union(Map{p[i+1][0+1] |-> c}) )  ;     i := i + 1 ) ; 
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
        var i : int ; i := 0 ; while i < M do ( (     var r : Sequence(int) ; r := map->at(i) ;
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder ans=new StringBuilder();
    ArrayList<String>lines=new ArrayList<>();
    String input=sc.readLine();
    int max=input.length();
    boolean left=true ;
    while(input!=null){
      lines.add(input);
      if(input.length()>max){
        max=input.length();
      }
      input=sc.readLine();
    }
    for(int i=0 ; i<max+2 ; i++){
      ans.append('*');
    }
    ans.append('\n');
    for(String line : lines){
      double l=(max-line.length())/2.0 ;
      double r=(max-line.length())/2.0 ;
      if(left){
        r+=0.5 ;
      }
      else {
        l+=0.5 ;
      }
      if((int)l!=(int)r){
        left=! left ;
      }
      ans.append('*');
      for(int i=0 ; i<(int)l ; i++){
        ans.append(' ');
      }
      ans.append(line);
      for(int i=0 ; i<(int)r ; i++){
        ans.append(' ');
      }
      ans.append("*\n");
    }
    for(int i=0 ; i<max+2 ; i++){
      ans.append('*');
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var ans : String ; ans := StringLib.newString() ;
    var lines : Sequence(String) ; lines := Sequence{} ;
    var input : String ; input := sc.readLine() ;
    var max : int ; max := input->size() ;
    var left : boolean ; left := true ;
    while (input /= null) do (     lines := lines->including(input) ; 
     if (input->size() > max) then (     max := input->size() ) else skip ; 
     input := sc.readLine() ) ; 
        var i : int ; i := 0 ; while i < max + 2 do ( (     ans := ans + StringLib.newString('*') )  ;     i := i + 1 ) ; 
    ans := ans + StringLib.newString('
') ; 
    for (line : lines) do ( (     var l : double ; l := ((max)->char2byte() - line->size()) / 2.0 ;
     var r : double ; r := ((max)->char2byte() - line->size()) / 2.0 ;
    if (left) then (     r := r+(0.5) ) else (     l := l+(0.5) ) ;  
    if (l->oclAsType(int) /= r->oclAsType(int)) then (     left := not(left) ) else skip ; 
    ans := ans + StringLib.newString('*') ; 
        var i : int ; i := 0 ; while i < l->oclAsType(int) do ( (     ans := ans + StringLib.newString(' ') )  ;     i := i + 1 ) ; 
    ans := ans + StringLib.newString(line) ; 
        var i : int ; i := 0 ; while i < r->oclAsType(int) do ( (     ans := ans + StringLib.newString(' ') )  ;     i := i + 1 ) ; 
    ans := ans + StringLib.newString("*\n") ; 
 )  ) ; 
        var i : int ; i := 0 ; while i < max + 2 do ( (     ans := ans + StringLib.newString('*') )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int p[]=new int[m];
    long y[]=new long[m];
    HashMap<Long,Long>map=new HashMap<Long,Long>();
    ;
    long num[]=new long[m];
    for(int i=0 ; i<m ; ++i){
      p[i]=sc.nextInt();
      y[i]=sc.nextLong();
      num[i]=10000000000L*p[i]+y[i];
    }
    Arrays.sort(num);
    long div=1 ;
    long counter=1 ;
    for(int i=0 ; i<m ; ++i){
      if(num[i]/10000000000L==div);
      else {
        div=num[i]/10000000000L ;
        counter=1 ;
      }
      map.put(num[i]-div*10000000000L,counter);
++counter ;
    }
    for(int i=0 ; i<m ; ++i){
      String s=String.valueOf((long)1000000+p[i]);
      String s2=String.valueOf(1000000+map.get(y[i]));
      System.out.println(s.substring(1)+s2.substring(1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,m)->collect(0) ;
    var y : Sequence(long) ; y := Integer.subrange(1,m)->collect(0) ;
    var map : Map(long,long) ; map := Map{} ;
    var num : Sequence(long) ; num := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     p[i+1] := sc.getCurrent()->toInteger() ; 
     y[i+1] := sc.getCurrent()->toLong() ; 
     num[i+1] := 10000000000L * p[i+1] + y[i+1] )  ;     i := i + 1 ) ; 
    num := num->sort() ; 
    var div : long ; div := 1 ;
    var counter : long ; counter := 1 ;
        var i : int ; i := 0 ; while i < m do ( (     if (num[i+1] / 10000000000L = div) then  else (     div := num[i+1] / 10000000000L ; 
     counter := 1 ) ;  
     map := map->union(Map{num[i+1] - div * 10000000000L |-> counter}) ; 
     counter := counter + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var s : String ; s := ((1000000->oclAsType(long) + p[i+1]) + "") ;
     var s2 : String ; s2 := ((1000000 + map->at(y[i+1])) + "") ;
     OclFile["System.out"].println(s.subrange(1+1,1) + s2.subrange(1+1,1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  InputStream in=System.in ;
  PrintStream out=System.out ;
  void solv(int[][] x){
    Arrays.sort(x,new Comparator<int[]>(){
      @ Override public int compare(int[] a,int[] b){
        int x=a[1]-b[1];
        if(x==0){
          return a[2]-b[2];
        }
        return x ;
      }
    }
);
    int prev=-1 ;
    int num=0 ;
    for(int i=0 ; i<x.length ; i++){
      if(x[i][1]!=prev){
        num=1 ;
        prev=x[i][1];
      }
      else {
        num++;
      }
      x[i][3]=num ;
    }
    Arrays.sort(x,(a,b)->a[0]-b[0]);
    StringBuilder sb=new StringBuilder();
    for(int[] a : x){
      sb.append(String.format("%06d%06d\n",a[1],a[3]));
    }
    out.print(sb);
  }
  public void _main(String[] args){
    Scanner sc=new Scanner(in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[][] x=new int[m][4];
    for(int i=0 ; i<m ; i++){
      x[i]=new int[] {
        i,sc.nextInt(),sc.nextInt(),-1 };
      }
      solv(x);
      sc.close();
    }
    public static void main(String[] args){
      new Main()._main(args);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile["System.in"];
   attribute out : OclFile := OclFile["System.out"];
   operation solv( x : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     x := OclComparator.sortWith(x, OclComparator<Sequence(int)>.newOclComparator()) ; 
     var prev : int ; prev := -1 ;
    var num : int ; num := 0 ;
        var i : int ; i := 0 ; while i < x->size() do ( (     if (x[i+1][1+1] /= prev) then (     num := 1 ; 
     prev := x[i+1][1+1] ) else (     num := num + 1 ) ;  
     x[i+1][3+1] := num )  ;     i := i + 1 ) ; 
    x := OclComparator.sortWith(x, lambda (a , b) : OclAny in a[0+1] - b[0+1]) ; 
    var sb : String ; sb := StringLib.newString() ;
    for (a : x) do ( (     sb := sb + StringLib.newString(StringLib.format("%06d%06d\n",Sequence{a[1+1],a[3+1]})) )  ) ; 
    skip ; 
 );
   operation _main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : Sequence(Sequence(int)) ; x := Integer.subrange(1,m)->collect(Integer.subrange(1,4)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (     x[i+1] := Sequence{i,sc.getCurrent()->toInteger(),sc.getCurrent()->toInteger(),-1} )  ;     i := i + 1 ) ; 
    execute solv(x) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain()._main(args) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    solve(System.in,System.out);
  }
  private static class City {
    int p ;
    int y ;
  }
  static void solve(InputStream is,PrintStream os){
    Scanner sc=new Scanner(is);
    int n=sc.nextInt();
    int m=sc.nextInt();
    List<City>cities=new ArrayList<>(m);
    for(int i=0 ; i<m ; i++){
      int p=sc.nextInt();
      int y=sc.nextInt();
      City c=new City();
      c.p=p ;
      c.y=y ;
      cities.add(c);
    }
    Map<Integer,List<City>>prefToCity=new HashMap<>();
    for(City c : cities){
      List<City>list=prefToCity.getOrDefault(c.p,new ArrayList<>());
      list.add(c);
      prefToCity.put(c.p,list);
    }
    Map<City,Integer>indexOfPref=new HashMap<>();
    for(List<City>list : prefToCity.values()){
      list.sort(Comparator.comparingInt(c->c.y));
      for(int i=0 ; i<list.size(); i++){
        indexOfPref.put(list.get(i),i+1);
      }
    }
    List<String>res=new ArrayList<>();
    for(int i=0 ; i<m ; i++){
      City c=cities.get(i);
      res.add(String.format("%06d%06d",c.p,indexOfPref.get(c)));
    }
    os.println(String.join(System.lineSeparator(),res));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve(OclFile["System.in"], OclFile["System.out"]) );
  static class City {
   attribute p : int;
   attribute y : int;
}
  static   operation solve( is : OclFile, os : OclFile) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(is) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var cities : Sequence(City) ; cities := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     var p : int ; p := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var c : City ; c := City.newCity() ;
    c.p := p ; 
    c.y := y ; 
    cities := cities->including(c) ; 
 )  ;     i := i + 1 ) ; 
    var prefToCity : Map(int,Sequence(City)) ; prefToCity := Map{} ;
    for (c : cities) do ( (     var list : Sequence(City) ; list := (if prefToCity->keys()->contains(c.p) then prefToCity->at(c.p) else Sequence{} endif) ;
     list := list->including(c) ; 
     prefToCity := prefToCity->union(Map{c.p |-> list}) )  ) ; 
    var indexOfPref : Map(City,int) ; indexOfPref := Map{} ;
    for (list : prefToCity->values()) do ( (     list := list.sort(Comparator.comparingInt(lambda c : OclAny in c.y)) ; 
         var i : int ; i := 0 ; while i < list->size() do ( (     indexOfPref := indexOfPref->union(Map{list->at(i+1) |-> i + 1}) )  ;     i := i + 1 ) )  ) ; 
    var res : Sequence(String) ; res := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     var c : City ; c := cities->at(i+1) ;
     res := res->including(StringLib.format("%06d%06d",Sequence{c.p,indexOfPref->at(c)})) )  ;     i := i + 1 ) ; 
    os.println(join(lineSeparator(), res)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.text.DecimalFormat ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int city[][]=new int[m+1][4];
    for(int id=1 ; id<=m ; id++){
      city[id][0]=id ;
      city[id][1]=in.nextInt();
      city[id][2]=in.nextInt();
    }
    Arrays.sort(city,(c1,c2)->{
      if(c1[1]!=c2[1])return c1[1]-c2[1];
      else return c1[2]-c2[2];
    }
);
    DecimalFormat df=new DecimalFormat("000000");
    String result[]=new String[m];
    int pref=-1 ;
    int num=0 ;
    for(int i=1 ; i<=m ; i++){
      pref=city[i][1];
      num=(pref==city[i-1][1] ? num+1 : 1);
      result[city[i][0]-1]=df.format(pref)+df.format(num);
    }
    StringBuilder sb=new StringBuilder();
    for(String s : result){
      sb.append(s).append("\n");
    }
    System.out.println(sb);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var city : Sequence(Sequence(int)) ; city := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,4)->collect(0)) ;
        var id : int ; id := 1 ; while id <= m do ( (     city[id+1][0+1] := id ; 
     city[id+1][1+1] := in.getCurrent()->toInteger() ; 
     city[id+1][2+1] := in.getCurrent()->toInteger() )  ;     id := id + 1 ) ; 
    city := OclComparator.sortWith(city, lambda (c1 , c2) : OclAny in (     if (c1[1+1] /= c2[1+1]) then     return c1[1+1] - c2[1+1] else     return c1[2+1] - c2[2+1] )) ; 
    var df : DecimalFormat ; df := DecimalFormat.newDecimalFormat("000000") ;
    var result : Sequence(String) ; result := Integer.subrange(1,m)->collect(null) ;
    var pref : int ; pref := -1 ;
    var num : int ; num := 0 ;
        var i : int ; i := 1 ; while i <= m do ( (     pref := city[i+1][1+1] ; 
     num := (if pref = city[i - 1+1][1+1] then num + 1 else 1 endif) ; 
     result[city[i+1][0+1] - 1+1] := df.format(pref) + df.format(num) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    for (s : result) do ( (     sb := sb + StringLib.newString(s) + StringLib.newString("\n") )  ) ; 
    OclFile["System.out"].println(sb) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class KanbanNumbers {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    int places=0 ;
    String[] once={
      "","One","Two","Three","Four","Five","Six","Seven","Eight","Nine" };
      String[] str={
        "","One","Two","Three","Four","Five","Six","Seven","Eight","Nine","Ten","Eleven","Twelve","Thirteen","Forteen","Fifteen","Sixteen","Seventeen","Eighteen","Nineteen","Twenty" };
        String[] twice={
          "","Ten","Twenty","Thirty","Forty","Fifty","Sixty","Seventy","Eighty","Ninety" };
          String answer="" ;
          if(test<=20){
            answer=str[test];
          }
          else {
            while(test>0){
              places++;
              int val=test % 10 ;
              test=test/10 ;
              if(places==1){
                answer=once[val]+" "+answer ;
              }
              else {
                answer=twice[val]+" "+answer ;
              }
            }
          }
          answer=answer.toLowerCase();
          if(answer.contains("k")|| answer.contains("a")|| answer.contains("n")){
            System.out.println("NO");
          }
          else {
            System.out.println("YES");
          }
        }
      }

------------------------------------------------------------
OCL File:
---------
 class KanbanNumbers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
    var places : int ; places := 0 ;
    var once : Sequence(String) ; once := Sequence{"","One","Two","Three","Four","Five","Six","Seven","Eight","Nine"} ;
    var str : Sequence(String) ; str := Sequence{"","One","Two","Three","Four","Five","Six","Seven","Eight","Nine","Ten","Eleven","Twelve","Thirteen","Forteen","Fifteen","Sixteen","Seventeen","Eighteen","Nineteen","Twenty"} ;
    var twice : Sequence(String) ; twice := Sequence{"","Ten","Twenty","Thirty","Forty","Fifty","Sixty","Seventy","Eighty","Ninety"} ;
    var answer : String ; answer := "" ;
    if (test <= 20) then (     answer := str[test+1] ) else (     while (test > 0) do (     places := places + 1 ; 
     var val : int ; val := test mod 10 ;
     test := test / 10 ; 
     if (places = 1) then (     answer := once[val+1] + " " + answer ) else (     answer := twice[val+1] + " " + answer ) ) ) ;  
    answer := answer->toLowerCase() ; 
    if (answer->includes("k") or answer->includes("a") or answer->includes("n")) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void checkIfSortRotated(int arr[],int n){
    int minEle=Integer.MAX_VALUE ;
    int maxEle=Integer.MIN_VALUE ;
    int minIndex=-1 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]<minEle){
        minEle=arr[i];
        minIndex=i ;
      }
    }
    boolean flag1=true ;
    for(int i=1 ; i<minIndex ; i++){
      if(arr[i]<arr[i-1]){
        flag1=false ;
        break ;
      }
    }
    boolean flag2=true ;
    for(int i=minIndex+1 ; i<n ; i++){
      if(arr[i]<arr[i-1]){
        flag2=false ;
        break ;
      }
    }
    if(minIndex==0){
      System.out.print("NO");
      return ;
    }
    if(flag1 && flag2 &&(arr[n-1]<arr[minIndex-1]))System.out.println("YES");
    else System.out.print("NO");
  }
  public static void main(String[] args){
    int arr[]={
      3,4,5,1,2 };
      int n=arr.length ;
      checkIfSortRotated(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkIfSortRotated( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var minEle : int ; minEle := 2147483647 ;
     var maxEle : int ; maxEle := -2147483648 ;
    var minIndex : int ; minIndex := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] < minEle) then (     minEle := arr[i+1] ; 
     minIndex := i ) else skip )  ;     i := i + 1 ) ; 
    var flag1 : boolean ; flag1 := true ;
        var i : int ; i := 1 ; while i < minIndex do ( (     if (arr[i+1] < arr[i - 1+1]) then (     flag1 := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var flag2 : boolean ; flag2 := true ;
        var i : int ; i := minIndex + 1 ; while i < n do ( (     if (arr[i+1] < arr[i - 1+1]) then (     flag2 := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (minIndex = 0) then (     OclFile["System.out"].print("NO") ; 
     return ) else skip ; 
    if (flag1 & flag2 & (arr[n - 1+1] < arr[minIndex - 1+1])) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].print("NO") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,4,5,1,2} ;
     var n : int ; n := arr->size() ;
     execute checkIfSortRotated(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    int n ;
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    int a=n % 10 ;
    int b=n/10 ;
    if(a==1 || a==7 || a==9 || b==1 && a!=2 || b==2 || b==7 || b==9)System.out.print("No");
    else System.out.println("Yes");
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := sc.getCurrent()->toInteger() ; 
    var a : int ; a := n mod 10 ;
    var b : int ; b := n / 10 ;
    if (a = 1 or a = 7 or a = 9 or b = 1 & a /= 2 or b = 2 or b = 7 or b = 9) then     OclFile["System.out"].print("No") else     OclFile["System.out"].println("Yes") ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class file {
  private static final Scanner sc=new Scanner(System.in);
  private static void foo(){
    int n=sc.nextInt();
    HashSet<Integer>set=new HashSet<>(Arrays.asList(1,7,9,10,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,31,37,39,41,447,49,51,57,59,61,67,69,71,72,73,74,75,76,77,78,79,81,87,89,90,91,92,93,94,95,96,97,98,99));
    if(set.contains(n))System.out.println("NO");
    else System.out.println("YES");
  }
  public static void main(String[] args){
    foo();
  }
}
------------------------------------------------------------
OCL File:
---------
 class file {
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation foo() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var set : Set(int) ; set := Set{}->union(Sequence{1,7,9,10,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,31,37,39,41,447,49,51,57,59,61,67,69,71,72,73,74,75,76,77,78,79,81,87,89,90,91,92,93,94,95,96,97,98,99}) ;
     if (set->includes(n)) then     OclFile["System.out"].println("NO") ; else     OclFile["System.out"].println("YES") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute foo() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public final class p032 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p032().run());
  }
  public String run(){
    int sum=0 ;
    for(int i=1 ; i<10000 ; i++){
      if(hasPandigitalProduct(i))sum+=i ;
    }
    return Integer.toString(sum);
  }
  private static boolean hasPandigitalProduct(int n){
    for(int i=1 ; i<=n ; i++){
      if(n % i==0 && isPandigital(""+n+i+n/i))return true ;
    }
    return false ;
  }
  private static boolean isPandigital(String s){
    if(s.length()!=9)return false ;
    char[] temp=s.toCharArray();
    Arrays.sort(temp);
    return new String(temp).equals("123456789");
  }
}
------------------------------------------------------------
OCL File:
---------
 class p032 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p032.newp032().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i < 10000 do ( (     if (hasPandigitalProduct(i)) then     sum := sum+(i) ; else skip )  ;     i := i + 1 ) ; 
     return ((sum) + "") );
  static   operation hasPandigitalProduct( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= n do ( (     if (n mod i = 0 & isPandigital("" + n + i + n / i)) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation isPandigital( s : String) : boolean
  pre: true
  post: true
  activity: (     if (s->size() /= 9) then     return false else skip ; 
     var temp : Sequence(String) ; temp := s->characters() ;
     temp := temp->sort() ; 
     return StringLib.newString(temp) = "123456789" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class Node {
    int data ;
    Node left ;
    Node right ;
    Node(int value){
      data=value ;
      left=null ;
      right=null ;
    }
  };
  static void specific_level_order_traversal(Node root){
    Queue<Node>q=new LinkedList<>();
    Stack<Vector<Integer>>s=new Stack<Vector<Integer>>();
    q.add(root);
    int sz ;
    while(q.size()>0){
      Vector<Integer>v=new Vector<Integer>();
      sz=q.size();
      for(int i=0 ; i<sz ; ++i){
        Node temp=q.peek();
        q.remove();
        v.add(temp.data);
        if(temp.left!=null)q.add(temp.left);
        if(temp.right!=null)q.add(temp.right);
      }
      s.push(v);
    }
    while(s.size()>0){
      Vector<Integer>v=s.peek();
      s.pop();
      for(int i=0,j=v.size()-1 ; i<j ; ++i){
        System.out.print(v.get(i)+" "+v.get(j)+" ");
        j--;
      }
    }
    System.out.println(root.data);
  }
  public static void main(String args[]){
    Node root=new Node(1);
    root.left=new Node(2);
    root.right=new Node(3);
    System.out.println("Specific Level Order traversal"+" of binary tree is");
    specific_level_order_traversal(root);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Node {
   attribute data : int;
   attribute left : Node;
   attribute right : Node;
   static operation newNode( value : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(value);
    return self );
  operation initialise( value : int) : void
  pre: true  post: true
  activity: (     data := value ; 
     left := null ; 
     right := null );
}
  static   operation specific_level_order_traversal( root : Node) : void
  pre: true
  post: true
  activity: (     var q : Sequence(Node) ; q := Sequence{} ;
     var s : Sequence(Sequence(int)) ; s := Sequence{} ;
    q := q->including(root) ; 
    var sz : int ;
    while (q->size() > 0) do (     var v : Sequence(int) ; v := Sequence{} ;
     sz := q->size() ; 
         var i : int ; i := 0 ; while i < sz do ( (     var temp : Node ; temp := q->min() ;
     q := q.remove() ; 
    v := v->including(temp.data) ; 
    if (temp.left /= null) then     q := q->including(temp.left) ; else skip ; 
    if (temp.right /= null) then     q := q->including(temp.right) ; else skip ; 
 )  ;     i := i + 1 ) ; 
     s := s->append(v) ) ; 
    while (s->size() > 0) do (     var v : Sequence(int) ; v := s->min() ;
     s := s->front() ; 
         var i : int ; i := 0 ;
    var j : int ; j := v->size() - 1 ; while i < j do ( (     OclFile["System.out"].print(v->at(i+1) + " " + v->at(j+1) + " ") ; 
     j := j - 1 )  ;     i := i + 1 ) ) ; 
    OclFile["System.out"].println(root.data) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var root : Node ; root := Node.newNode(1) ;
     root.left := Node.newNode(2) ; 
    root.right := Node.newNode(3) ; 
    OclFile["System.out"].println("Specific Level Order traversal" + " of binary tree is") ; 
    execute specific_level_order_traversal(root) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    new Main().run();
  }
  long MODULO=1_000_000_000+7 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[] f=new long[N+1];
    long[] cum=new long[N+1];
    Arrays.fill(f,-Integer.MAX_VALUE/16);
    Arrays.fill(cum,-Integer.MAX_VALUE/16);
    f[1]=N ;
    cum[1]=N ;
    for(int i=2 ; i<=N ; ++i){
      f[i]=f[i-1];
      f[i]=(f[i]+1L*(N-1)*(N-1)% MODULO)% MODULO ;
      if(i>3){
        f[i]=(f[i]+cum[i-3])% MODULO ;
      }
      f[i]=(f[i]+Math.min(0,i-3)-(i-N-1)+1)% MODULO ;
      cum[i]=(cum[i-1]+f[i])% MODULO ;
    }
    System.out.println(f[N]);
  }
  void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute MODULO : long := 1_000_000_000 + 7;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var f : Sequence(long) ; f := Integer.subrange(1,N + 1)->collect(0) ;
    var cum : Sequence(long) ; cum := Integer.subrange(1,N + 1)->collect(0) ;
    f := f->collect(-2147483647 / 16) ; 
    cum := cum->collect(-2147483647 / 16) ; 
    f[1+1] := N ; 
    cum[1+1] := N ; 
        var i : int ; i := 2 ; while i <= N do ( (     f[i+1] := f[i - 1+1] ; 
     f[i+1] := (f[i+1] + 1L * (N - 1) * (N - 1) mod MODULO) mod MODULO ; 
    if (i > 3) then (     f[i+1] := (f[i+1] + cum[i - 3+1]) mod MODULO ) else skip ; 
    f[i+1] := (f[i+1] + Set{0, i - 3}->min() - (i - N - 1) + 1) mod MODULO ; 
    cum[i+1] := (cum[i - 1+1] + f[i+1]) mod MODULO ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(f[N+1]) ; 
 );
   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Scanner ;
import java.util.Timer ;
import java.util.TimerTask ;
public class codeForces {
  static String str="start" ;
  public static void main(String[] args0)throws IOException {
    Scanner s=new Scanner(System.in);
    int max=0 ;
    boolean LR=true ;
    ArrayList<String>arr=new ArrayList<>();
    try {
      while(true){
        str=s.nextLine();
        arr.add(str);
        if(str.length()>max){
          max=str.length();
        }
      }
    }
    catch(java.util.NoSuchElementException x){
    }
    finally {
      for(int i=0 ; i<max+2 ; i++){
        System.out.print("*");
      }
      System.out.println();
      for(int i=0 ; i<arr.size(); i++){
        int size=max-arr.get(i).length();
        if((size)% 2==0){
          for(int j=0 ; j<size/2 ; j++){
            arr.set(i," "+arr.get(i)+" ");
          }
        }
        else {
          for(int j=0 ; j<size/2 ; j++){
            arr.set(i," "+arr.get(i)+" ");
          }
          if(LR)arr.set(i,arr.get(i)+" ");
          else arr.set(i," "+arr.get(i));
          LR=! LR ;
        }
        arr.set(i,"*"+arr.get(i)+"*");
        System.out.println(arr.get(i));
      }
      for(int i=0 ; i<max+2 ; i++){
        System.out.print("*");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeForces {
  static   attribute str : String := "start";
  static   operation main( args0 : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var max : int ; max := 0 ;
    var LR : boolean ; LR := true ;
    var arr : Sequence(String) ; arr := Sequence{} ;
    try (     while (true) do (     str := s.nextLine() ; 
     arr := arr->including(str) ; 
     if (str->size() > max) then (     max := str->size() ) else skip ) )   catch (x : IncorrectElementException) do skip
   finally (         var i : int ; i := 0 ; while i < max + 2 do ( (     OclFile["System.out"].print("*") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ; 
         var i : int ; i := 0 ; while i < arr->size() do ( (     var size : int ; size := max - arr->at(i+1)->size() ;
     if ((size) mod 2 = 0) then (         var j : int ; j := 0 ; while j < size / 2 do ( (     arr := arr.setAt(i+1," " + arr->at(i+1) + " ") )  ;     j := j + 1 ) ) else (         var j : int ; j := 0 ; while j < size / 2 do ( (     arr := arr.setAt(i+1," " + arr->at(i+1) + " ") )  ;     j := j + 1 ) ; 
     if (LR) then     arr := arr.setAt(i+1,arr->at(i+1) + " ") else     arr := arr.setAt(i+1," " + arr->at(i+1)) ; ;  
     LR := not(LR) ) ;  
     arr := arr.setAt(i+1,"*" + arr->at(i+1) + "*") ; 
     OclFile["System.out"].println(arr->at(i+1)) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < max + 2 do ( (     OclFile["System.out"].print("*") )  ;     i := i + 1 ) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long MOD=1000000007 ;
    long[] dp=new long[N+1];
    dp[0]=1 ;
    dp[1]=MOD-1 ;
    long cur=0 ;
    for(int i=0 ; i<N ; i++){
      cur=(cur+dp[i])% MOD ;
      if(i==N-1){
        dp[N]=(dp[N]+cur*N)% MOD ;
      }
      else {
        dp[i+1]=(dp[i+1]+cur)% MOD ;
        dp[i+2]=(dp[i+2]-cur+MOD)% MOD ;
        if(i+3<=N){
          dp[i+3]=(dp[i+3]+cur)% MOD ;
          dp[N]=(dp[N]+cur*(i+1))% MOD ;
        }
        else {
          dp[N]=(dp[N]+cur*(N-1))% MOD ;
        }
        dp[N]=(dp[N]+cur*((((long)N-1)*(N-1))% MOD))% MOD ;
      }
    }
    System.out.println((cur+dp[N])% MOD);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var MOD : long ; MOD := 1000000007 ;
    var dp : Sequence(long) ; dp := Integer.subrange(1,N + 1)->collect(0) ;
    dp[0+1] := 1 ; 
    dp[1+1] := MOD - 1 ; 
    var cur : long ; cur := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     cur := (cur + dp[i+1]) mod MOD ; 
     if (i = N - 1) then (     dp[N+1] := (dp[N+1] + cur * N) mod MOD ) else (     dp[i + 1+1] := (dp[i + 1+1] + cur) mod MOD ; 
     dp[i + 2+1] := (dp[i + 2+1] - cur + MOD) mod MOD ; 
     if (i + 3 <= N) then (     dp[i + 3+1] := (dp[i + 3+1] + cur) mod MOD ; 
     dp[N+1] := (dp[N+1] + cur * (i + 1)) mod MOD ) else (     dp[N+1] := (dp[N+1] + cur * (N - 1)) mod MOD ) ;  
     dp[N+1] := (dp[N+1] + cur * (((N->oclAsType(long) - 1) * (N - 1)) mod MOD)) mod MOD ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((cur + dp[N+1]) mod MOD) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int startingPoint(int Length,int Speed1,int Speed2){
    int result1=0,result2=0 ;
    int time1=Length/Speed1 ;
    int time2=Length/Speed2 ;
    result1=__gcd(time1,time2);
    result2=time1*time2/(result1);
    return result2 ;
  }
  static int __gcd(int a,int b){
    if(b==0){
      return a ;
    }
    return __gcd(b,a % b);
  }
  static float firstTime(int Length,int Speed1,int Speed2){
    float result=0 ;
    int relativeSpeed=Math.abs(Speed1-Speed2);
    result=((float)Length/relativeSpeed);
    return result ;
  }
  public static void main(String[] args){
    int L=30,S1=5,S2=2 ;
    float first_Time=firstTime(L,S1,S2);
    int starting_Point=startingPoint(L,S1,S2);
    System.out.println("Met first time after "+first_Time+" hrs");
    System.out.println("Met at starting point after "+starting_Point+" hrs");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation startingPoint( Length : int, Speed1 : int, Speed2 : int) : int
  pre: true
  post: true
  activity: (     var result1 : int ; result1 := 0 ;
    var result2 : int ; result2 := 0 ;
     var time1 : int ; time1 := Length / Speed1 ;
    var time2 : int ; time2 := Length / Speed2 ;
    result1 := __gcd(time1, time2) ; 
    result2 := time1 * time2 / (result1) ; 
    return result2 
 );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else skip ; 
     return __gcd(b, a mod b) );
  static   operation firstTime( Length : int, Speed1 : int, Speed2 : int) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
     var relativeSpeed : int ; relativeSpeed := if Speed1 - Speed2 < 0 then -(Speed1 - Speed2) else Speed1 - Speed2 endif ;
     result := (Length->oclAsType(double) / relativeSpeed) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 30 ;
    var S1 : int ; S1 := 5 ;
    var S2 : int ; S2 := 2 ;
     var first_Time : double ; first_Time := firstTime(L, S1, S2) ;
    var starting_Point : int ; starting_Point := startingPoint(L, S1, S2) ;
    OclFile["System.out"].println("Met first time after " + first_Time + " hrs") ; 
    OclFile["System.out"].println("Met at starting point after " + starting_Point + " hrs") ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void alphabetPattern(int N){
    int left=0,middle=N-1,right=N+1 ;
    for(int row=0 ; row<2*N-1 ; row++){
      if(row<N)System.out.print(++left);
      else System.out.print(--left);
      for(int col=1 ; col<N-1 ; col++){
        if(row!=N-1)System.out.print("  ");
        else System.out.print(" "+middle--);
      }
      if(row<N)System.out.print(" "+--right);
      else System.out.print(" "+++right);
      System.out.println();
    }
  }
  public static void main(String[] args){
    int N=4 ;
    alphabetPattern(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation alphabetPattern( N : int) : void
  pre: true
  post: true
  activity: (     var left : int ; left := 0 ;
    var middle : int ; middle := N - 1 ;
    var right : int ; right := N + 1 ;
         var row : int ; row := 0 ; while row < 2 * N - 1 do ( (     if (row < N) then     OclFile["System.out"].print((left + 1)) else     OclFile["System.out"].print((left - 1)) ; ;  
         var col : int ; col := 1 ; while col < N - 1 do ( (     if (row /= N - 1) then     OclFile["System.out"].print("  ") ; else     OclFile["System.out"].print(" " + middle) ; )  ;     col := col + 1 ) ; 
     if (row < N) then     OclFile["System.out"].print(" " + (right - 1)) else     OclFile["System.out"].print(" " + right) ; ;  
     OclFile["System.out"].println() )  ;     row := row + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     execute alphabetPattern(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void segregate0and1(int arr[],int n){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==0)count++;
    }
    for(int i=0 ; i<count ; i++)arr[i]=0 ;
    for(int i=count ; i<n ; i++)arr[i]=1 ;
  }
  static void print(int arr[],int n){
    System.out.print("Array after segregation is ");
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String[] args){
    int arr[]=new int[] {
      0,1,0,1,1,1 };
      int n=arr.length ;
      segregate0and1(arr,n);
      print(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation segregate0and1( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 0) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < count do (     arr[i+1] := 0 ;  ;     i := i + 1 ) ; 
         var i : int ; i := count ; while i < n do (     arr[i+1] := 1 ;  ;     i := i + 1 ) );
  static   operation print( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("Array after segregation is ") ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,1,0,1,1,1} ;
     var n : int ; n := arr->size() ;
     execute segregate0and1(arr, n) ; 
     execute print(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class AA {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      long k=sc.nextLong();
      int x=sc.nextInt();
      long f=k*9 ;
      for(int y=x ; y<9 ; y++){
        f--;
      }
      System.out.println(f);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var k : long ; k := sc.getCurrent()->toLong() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var f : long ; f := k * 9 ;
        var y : int ; y := x ; while y < 9 do ( (     f := f - 1 )  ;     y := y + 1 ) ; 
    OclFile["System.out"].println(f) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getValue(int n){
    int i=0,k=1 ;
    while(i<n){
      i=i+k ;
      k=k*2 ;
    }
    return k/2 ;
  }
  public static void main(String[] args){
    int n=9 ;
    System.out.println(getValue(n));
    n=1025 ;
    System.out.println(getValue(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getValue( n : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var k : int ; k := 1 ;
     while (i < n) do (     i := i + k ; 
     k := k * 2 ) ; 
     return k / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     OclFile["System.out"].println(getValue(n)) ; 
     n := 1025 ; 
     OclFile["System.out"].println(getValue(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    new Solver().run();
  }
}
class Point {
  int x ;
  int y ;
  public Point(int x,int y){
    this.x=x ;
    this.y=y ;
  }
  public int distanceTo(Point other){
    return Math.abs(x-other.x)+Math.abs(y-other.y);
  }
  public String toString(){
    return String.format("(%d,%d)",x,y);
  }
}
class Solver {
  private boolean reachable(int difft,int d){
    int diff=difft-d ;
    if(diff<0)return false ;
    if((diff % 2)==0)return true ;
    return false ;
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] t=new int[N];
    Point[] p=new Point[N];
    int sum=0 ;
    for(int i=0 ; i<N ; i++){
      t[i]=sc.nextInt();
      p[i]=new Point(sc.nextInt(),sc.nextInt());
    }
    int curt=0 ;
    Point curp=new Point(0,0);
    for(int i=0 ; i<N ; i++){
      int nxtt=t[i];
      Point dst=p[i];
      int d=curp.distanceTo(dst);
      if(! reachable(nxtt-curt,d)){
        System.out.println("No");
        return ;
      }
      curt=nxtt ;
      curp=dst ;
    }
    System.out.println("Yes");
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Solver.newSolver().run() );
}
class Point {
   attribute x : int;
   attribute y : int;
   static operation newPoint( x : int, y : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation distanceTo( other : Point) : int
  pre: true
  post: true
  activity: (     return if x - other.x < 0 then -(x - other.x) else x - other.x endif + if y - other.y < 0 then -(y - other.y) else y - other.y endif );
   operation toString() : String
  pre: true
  post: true
  activity: (     return StringLib.format("(%d,%d)",Sequence{x,y}) );
}
class Solver {
   operation reachable( difft : int, d : int) : boolean
  pre: true
  post: true
  activity: (     var diff : int ; diff := difft - d ;
     if (diff < 0) then     return false else skip ; 
     if ((diff mod 2) = 0) then     return true else skip ; 
     return false );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,N)->collect(0) ;
    var p : Sequence(Point) ; p := Integer.subrange(1,N)->collect(null) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     t[i+1] := sc.getCurrent()->toInteger() ; 
     p[i+1] := Point.newPoint(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var curt : int ; curt := 0 ;
    var curp : Point ; curp := Point.newPoint(0, 0) ;
        var i : int ; i := 0 ; while i < N do ( (     var nxtt : int ; nxtt := t[i+1] ;
     var dst : Point ; dst := p[i+1] ;
    var d : int ; d := curp.distanceTo(dst) ;
    if (not(reachable(nxtt - curt, d))) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
    curt := nxtt ; 
    curp := dst ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Yes") ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int row=sc.nextInt();
    int[][] index=new int[row][3];
    for(int i=0 ; i<row ; i++){
      index[i][0]=sc.nextInt();
      index[i][1]=sc.nextInt();
      index[i][2]=sc.nextInt();
    }
    int initX=Math.abs(index[0][1]);
    int initY=Math.abs(index[0][2]);
    int d=initX+initY ;
    if(d>index[0][0] || d % 2!=index[0][0] % 2){
      System.out.println("No");
      System.exit(0);
    }
    for(int i=1 ; i<row ; i++){
      int x=Math.abs(index[i][1]-index[i-1][1]);
      int y=Math.abs(index[i][2]-index[i-1][2]);
      int distance=x+y ;
      int s=index[i][0]-index[i-1][0];
      if(distance>s || distance % 2!=s % 2){
        System.out.println("No");
        System.exit(0);
      }
    }
    System.out.println("Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var row : int ; row := sc.getCurrent()->toInteger() ;
    var index : Sequence(Sequence(int)) ; index := Integer.subrange(1,row)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < row do ( (     index[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     index[i+1][1+1] := sc.getCurrent()->toInteger() ; 
     index[i+1][2+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var initX : int ; initX := if index[0+1][1+1] < 0 then -(index[0+1][1+1]) else index[0+1][1+1] endif ;
    var initY : int ; initY := if index[0+1][2+1] < 0 then -(index[0+1][2+1]) else index[0+1][2+1] endif ;
    var d : int ; d := initX + initY ;
    if (d > index[0+1][0+1] or d mod 2 /= index[0+1][0+1] mod 2) then (     OclFile["System.out"].println("No") ; 
 OclProcess.exit(0) ) else skip ; 
        var i : int ; i := 1 ; while i < row do ( (     var x : int ; x := if index[i+1][1+1] - index[i - 1+1][1+1] < 0 then -(index[i+1][1+1] - index[i - 1+1][1+1]) else index[i+1][1+1] - index[i - 1+1][1+1] endif ;
     var y : int ; y := if index[i+1][2+1] - index[i - 1+1][2+1] < 0 then -(index[i+1][2+1] - index[i - 1+1][2+1]) else index[i+1][2+1] - index[i - 1+1][2+1] endif ;
    var distance : int ; distance := x + y ;
    var s : int ; s := index[i+1][0+1] - index[i - 1+1][0+1] ;
    if (distance > s or distance mod 2 /= s mod 2) then (     OclFile["System.out"].println("No") ; 
 OclProcess.exit(0) ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Yes") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    String answer="Yes" ;
    int t1=0 ;
    int x1=0 ;
    int y1=0 ;
    for(int i=0 ; i<n ; i++){
      int t2=scn.nextInt();
      int x2=scn.nextInt();
      int y2=scn.nextInt();
      int difT=t2-t1 ;
      int difX=Math.abs(x1-x2);
      int difY=Math.abs(y1-y2);
      if(difT-(difX+difY)<0 ||(difT-(difX+difY))% 2==1){
        answer="No" ;
        break ;
      }
      else {
        t1=t2 ;
        x1=x2 ;
        y1=y2 ;
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var answer : String ; answer := "Yes" ;
    var t1 : int ; t1 := 0 ;
    var x1 : int ; x1 := 0 ;
    var y1 : int ; y1 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var t2 : int ; t2 := scn.getCurrent()->toInteger() ;
     var x2 : int ; x2 := scn.getCurrent()->toInteger() ;
    var y2 : int ; y2 := scn.getCurrent()->toInteger() ;
    var difT : int ; difT := t2 - (t1)->char2byte() ;
    var difX : int ; difX := if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif ;
    var difY : int ; difY := if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif ;
    if (difT - (difX + difY) < 0 or (difT - (difX + difY)) mod 2 = 1) then (     answer := "No" ; 
     break ) else (     t1 := t2 ; 
     x1 := x2 ; 
     y1 := y2 ) ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  static final String YES="Yes" ;
  static final String NO="No" ;
  public static void main(String[] args)throws Exception {
    final Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[][] txy=new int[N][3];
    for(int i=0 ; i<N ; i++){
      txy[i][0]=sc.nextInt();
      txy[i][1]=sc.nextInt();
      txy[i][2]=sc.nextInt();
    }
    Arrays.sort(txy,(a,b)->Long.compare(a[0],b[0]));
    int a=0,b=0 ;
    for(int i=0 ; i<N ; i++){
      int move=txy[i][0]-(i==0 ? 0 : txy[i-1][0]);
      int dist=d(txy[i][1],txy[i][2],a,b);
      if(move<dist ||(move-dist)% 2==1){
        System.out.println(NO);
        return ;
      }
      a=txy[i][1];
      b=txy[i][2];
    }
    System.out.println(YES);
  }
  private static int d(int x,int y,int x2,int y2){
    return Math.abs(x-x2)+Math.abs(y-y2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute YES : String := "Yes";
  static    attribute NO : String := "No";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var txy : Sequence(Sequence(int)) ; txy := Integer.subrange(1,N)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     txy[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     txy[i+1][1+1] := sc.getCurrent()->toInteger() ; 
     txy[i+1][2+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    txy := OclComparator.sortWith(txy, lambda (a , b) : OclAny in compare(a[0+1], b[0+1])) ; 
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var move : int ; move := txy[i+1][0+1] - (if i = 0 then 0 else txy[i - 1+1][0+1] endif) ;
     var dist : int ; dist := d(txy[i+1][1+1], txy[i+1][2+1], a, b) ;
    if (move < dist or (move - dist) mod 2 = 1) then (     OclFile["System.out"].println(NO) ; 
     return ) else skip ; 
    a := txy[i+1][1+1] ; 
    b := txy[i+1][2+1] ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(YES) ; 
 );
  static   operation d( x : int, y : int, x2 : int, y2 : int) : int
  pre: true
  post: true
  activity: (     return if x - x2 < 0 then -(x - x2) else x - x2 endif + if y - y2 < 0 then -(y - y2) else y - y2 endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner stdin=new Scanner(System.in);
    int num=stdin.nextInt();
    int prevT=0 ;
    int prevX=0 ;
    int prevY=0 ;
    for(int i=0 ; i<num ; i++){
      int t=stdin.nextInt();
      int x=stdin.nextInt();
      int y=stdin.nextInt();
      int time=t-prevT ;
      int move=Math.abs(x-prevX)+Math.abs(y-prevY);
      if((time<move)||((time-move)% 2>0)){
        System.out.println("No");
        return ;
      }
      prevT=t ;
      prevX=x ;
      prevY=y ;
    }
    System.out.println("Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := stdin.getCurrent()->toInteger() ;
    var prevT : int ; prevT := 0 ;
    var prevX : int ; prevX := 0 ;
    var prevY : int ; prevY := 0 ;
        var i : int ; i := 0 ; while i < num do ( (     var t : int ; t := stdin.getCurrent()->toInteger() ;
     var x : int ; x := stdin.getCurrent()->toInteger() ;
    var y : int ; y := stdin.getCurrent()->toInteger() ;
    var time : int ; time := t - prevT ;
    var move : int ; move := if x - prevX < 0 then -(x - prevX) else x - prevX endif + if y - prevY < 0 then -(y - prevY) else y - prevY endif ;
    if ((time < move) or ((time - move) mod 2 > 0)) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
    prevT := t ; 
    prevX := x ; 
    prevY := y ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Yes") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Solution3 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    List<String>strs=new ArrayList<>();
    int maxLen=0 ;
    while(scanner.hasNextLine()){
      String str=scanner.nextLine();
      if(str.length()>maxLen)maxLen=str.length();
      strs.add(str);
    }
    for(int i=0 ; i<maxLen+2 ; ++i){
      System.out.print('*');
    }
    System.out.println();
    int flag=0 ;
    StringBuilder sb=new StringBuilder();
    for(String str : strs){
      int len=maxLen-str.length();
      int left=(len+flag)/2 ;
      int right=len-left ;
      if(len % 2!=0){
        flag=1-flag ;
      }
      sb.append('*');
      for(int i=0 ; i<left ; ++i){
        sb.append(' ');
      }
      sb.append(str);
      for(int i=0 ; i<right ; ++i){
        sb.append(' ');
      }
      sb.append("*\n");
    }
    System.out.print(sb.toString());
    for(int i=0 ; i<maxLen+2 ; ++i){
      System.out.print('*');
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var strs : Sequence(String) ; strs := Sequence{} ;
    var maxLen : int ; maxLen := 0 ;
    while (scanner.hasNextLine()) do (     var str : String ; str := scanner.nextLine() ;
     if (str->size() > maxLen) then     maxLen := str->size() ; else skip ; 
     strs := strs->including(str) ) ; 
        var i : int ; i := 0 ; while i < maxLen + 2 do ( (     OclFile["System.out"].print('*') )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    var flag : int ; flag := 0 ;
    var sb : String ; sb := StringLib.newString() ;
    for (str : strs) do ( (     var len : int ; len := maxLen - str->size() ;
     var left : int ; left := (len + flag) / 2 ;
    var right : int ; right := (len)->char2byte() - left ;
    if (len mod 2 /= 0) then (     flag := 1 - flag ) else skip ; 
    sb := sb + StringLib.newString('*') ; 
        var i : int ; i := 0 ; while i < left do ( (     sb := sb + StringLib.newString(' ') )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(str) ; 
        var i : int ; i := 0 ; while i < right do ( (     sb := sb + StringLib.newString(' ') )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString("*\n") ; 
 )  ) ; 
    OclFile["System.out"].print(sb+"") ; 
        var i : int ; i := 0 ; while i < maxLen + 2 do ( (     OclFile["System.out"].print('*') )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  final static int MAX=26 ;
  static int maxSubStr(char[] str1,int len1,char[] str2,int len2){
    if(len1>len2)return 0 ;
    int freq1[]=new int[MAX];
    for(int i=0 ; i<len1 ; i++)freq1[i]=0 ;
    for(int i=0 ; i<len1 ; i++)freq1[str1[i]-'a']++;
    int freq2[]=new int[MAX];
    for(int i=0 ; i<len2 ; i++)freq2[i]=0 ;
    for(int i=0 ; i<len2 ; i++)freq2[str2[i]-'a']++;
    int minPoss=Integer.MAX_VALUE ;
    for(int i=0 ; i<MAX ; i++){
      if(freq1[i]==0)continue ;
      if(freq1[i]>freq2[i])return 0 ;
      minPoss=Math.min(minPoss,freq2[i]/freq1[i]);
    }
    return minPoss ;
  }
  public static void main(String[] args){
    String str1="geeks",str2="gskefrgoekees" ;
    int len1=str1.length();
    int len2=str2.length();
    System.out.println(maxSubStr(str1.toCharArray(),len1,str2.toCharArray(),len2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 26;
  static   operation maxSubStr( str1 : Sequence(String), len1 : int, str2 : Sequence(String), len2 : int) : int
  pre: true
  post: true
  activity: (     if (len1 > len2) then     return 0 else skip ; 
     var freq1 : Sequence(int) ; freq1 := Integer.subrange(1,MAX)->collect(0) ;
        var i : int ; i := 0 ; while i < len1 do (     freq1[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < len1 do (     freq1[str1[i+1] - ('a')->char2byte()+1] := freq1[str1[i+1] - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    var freq2 : Sequence(int) ; freq2 := Integer.subrange(1,MAX)->collect(0) ;
        var i : int ; i := 0 ; while i < len2 do (     freq2[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < len2 do (     freq2[str2[i+1] - ('a')->char2byte()+1] := freq2[str2[i+1] - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    var minPoss : int ; minPoss := 2147483647 ;
        var i : int ; i := 0 ; while i < MAX do ( (     if (freq1[i+1] = 0) then     continue else skip ; 
     if (freq1[i+1] > freq2[i+1]) then     return 0 else skip ; 
     minPoss := Set{minPoss, freq2[i+1] / freq1[i+1]}->min() )  ;     i := i + 1 ) ; 
    return minPoss 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "geeks" ;
    var str2 : String ; str2 := "gskefrgoekees" ;
     var len1 : int ; len1 := str1->size() ;
     var len2 : int ; len2 := str2->size() ;
     OclFile["System.out"].println(maxSubStr(str1->characters(), len1, str2->characters(), len2)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,r,p,c ;
    int[] card=new int[50];
    int[] tmp=new int[50];
    while(true){
      n=sc.nextInt();
      r=sc.nextInt();
      if(n==0 && r==0)break ;
      for(int i=0 ; i<n ; i++){
        card[i]=n-i ;
      }
      for(int i=0 ; i<r ; i++){
        p=sc.nextInt();
        c=sc.nextInt();
        for(int j=0 ; j<c ; j++){
          tmp[j]=card[p-1+j];
        }
        for(int j=0 ; j<p-1 ; j++){
          card[p-2-j+c]=card[p-2-j];
        }
        for(int j=0 ; j<c ; j++){
          card[j]=tmp[j];
        }
      }
      System.out.println(card[0]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var r : int ;
    var p : int ;
    var c : int ;
    var card : Sequence(int) ; card := Integer.subrange(1,50)->collect(0) ;
    var tmp : Sequence(int) ; tmp := Integer.subrange(1,50)->collect(0) ;
    while (true) do (     n := sc.getCurrent()->toInteger() ; 
     r := sc.getCurrent()->toInteger() ; 
    if (n = 0 & r = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     card[i+1] := n - i )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < r do ( (     p := sc.getCurrent()->toInteger() ; 
     c := sc.getCurrent()->toInteger() ; 
        var j : int ; j := 0 ; while j < c do ( (     tmp[j+1] := card[p - 1 + j+1] )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < p - 1 do ( (     card[p - 2 - j + c+1] := card[p - 2 - j+1] )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < c do ( (     card[j+1] := tmp[j+1] )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(card[0+1]) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long gcd(long a,long b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static long powGCD(long a,long n,long b){
    for(int i=0 ; i<n ; i++)a=a*a ;
    return gcd(a,b);
  }
  public static void main(String[] args){
    long a=10,b=5,n=2 ;
    System.out.println(powGCD(a,n,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation powGCD( a : long, n : long, b : long) : long
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     a := a * a ;  ;     i := i + 1 ) ; 
     return gcd(a, b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ; a := 10 ;
    var b : long ; b := 5 ;
    var n : long ; n := 2 ;
     OclFile["System.out"].println(powGCD(a, n, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int r=sc.nextInt();
    while(n!=0 && r!=0){
      int[] fuda=new int[n+1];
      int[] ans=new int[n+1];
      for(int i=1 ; i<n+1 ; i++)fuda[i]=i ;
      for(int j=0 ; j<r ; j++){
        int p=sc.nextInt();
        int c=sc.nextInt();
        solve(fuda,ans,p,c);
      }
      System.out.println(ans[n]);
      n=sc.nextInt();
      r=sc.nextInt();
    }
  }
  public static void solve(int[] fuda,int[] ans,int p,int c){
    int count=1 ;
    for(int k=1 ; k<fuda.length ; k++){
      if(k<=fuda.length-p && k>=fuda.length-p-c+1)ans[k+p-1]=fuda[k];
      else ans[count++]=fuda[k];
    }
    for(int i=0 ; i<ans.length ; i++)fuda[i]=ans[i];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
     while (n /= 0 & r /= 0) do (     var fuda : Sequence(int) ; fuda := Integer.subrange(1,n + 1)->collect(0) ;
     var ans : Sequence(int) ; ans := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i < n + 1 do (     fuda[i+1] := i ;  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < r do ( (     var p : int ; p := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
     execute solve(fuda, ans, p, c) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans[n+1]) ; 
    n := sc.getCurrent()->toInteger() ; 
    r := sc.getCurrent()->toInteger() ; 
 ) );
  static   operation solve( fuda : Sequence(int), ans : Sequence(int), p : int, c : int) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 1 ;
         var k : int ; k := 1 ; while k < fuda->size() do ( (     if (k <= fuda->size() - p & k >= fuda->size() - p - c + 1) then     ans[k + p - 1+1] := fuda[k+1] ; else      ans[count+1] := fuda[k+1]  ; count := count + 1 ; )  ;     k := k + 1 ) ; 
         var i : int ; i := 0 ; while i < ans->size() do (     fuda[i+1] := ans[i+1] ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args){
    int i,m,kazu,k,a,count=0,c,d ;
    String kard ;
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      int[] kard1=new int[100];
      int[][] temp=new int[1000][100];
      while(true){
        kard=reader.readLine();
        String suuti[]=kard.split(" ");
        c=Integer.parseInt(suuti[0]);
        kazu=Integer.parseInt(suuti[1]);
        if(c==0){
          break ;
        }
        int e=c ;
        for(i=0 ; i<c ; i++){
          kard1[i]=e ;
          e--;
        }
        for(m=0 ; m<kazu ; m++){
          String al=reader.readLine();
          String suuti1[]=al.split(" ");
          a=Integer.parseInt(suuti1[0]);
          d=Integer.parseInt(suuti1[1]);
          k=0 ;
          for(i=a-1 ; i<a-1+d ; i++){
            temp[count][k]=kard1[i];
            k++;
          }
          for(i=0 ; i<a-1 ; i++){
            temp[count][k]=kard1[i];
            k++;
          }
          for(i=a+d-1 ; i<c ; i++){
            temp[count][k]=kard1[i];
            k++;
          }
          for(i=0 ; i<c ; i++){
            kard1[i]=temp[count][i];
          }
        }
        count++;
      }
      i=0 ;
      while(count>i){
        System.out.println(temp[i][0]);
        i++;
      }
    }
    catch(IOException e){
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var m : int ;
    var kazu : int ;
    var k : int ;
    var a : int ;
    var count : int ; count := 0 ;
    var c : int ;
    var d : int ;
     var kard : String ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var kard1 : Sequence(int) ; kard1 := Integer.subrange(1,100)->collect(0) ;
     var temp : Sequence(Sequence(int)) ; temp := Integer.subrange(1,1000)->collect(Integer.subrange(1,100)->collect(0)) ;
    while (true) do (     kard := reader.readLine() ; 
     var suuti : Sequence(String) ; suuti := kard->split(" ") ;
    c := (suuti[0+1])->toInteger() ; 
    kazu := (suuti[1+1])->toInteger() ; 
    if (c = 0) then (     break ) else skip ; 
    var e : int ; e := c ;
        i := 0 ; while i < c do ( (     kard1[i+1] := e ; 
     e := e - 1 )  ;     i := i + 1 ) ; 
        m := 0 ; while m < kazu do ( (     var al : String ; al := reader.readLine() ;
     var suuti1 : Sequence(String) ; suuti1 := al->split(" ") ;
    a := (suuti1[0+1])->toInteger() ; 
    d := (suuti1[1+1])->toInteger() ; 
    k := 0 ; 
        i := a - 1 ; while i < a - 1 + d do ( (     temp[count+1][k+1] := kard1[i+1] ; 
     k := k + 1 )  ;     i := i + 1 ) ; 
        i := 0 ; while i < a - 1 do ( (     temp[count+1][k+1] := kard1[i+1] ; 
     k := k + 1 )  ;     i := i + 1 ) ; 
        i := a + d - 1 ; while i < c do ( (     temp[count+1][k+1] := kard1[i+1] ; 
     k := k + 1 )  ;     i := i + 1 ) ; 
        i := 0 ; while i < c do ( (     kard1[i+1] := temp[count+1][i+1] )  ;     i := i + 1 ) ; 
 )  ;     m := m + 1 ) ; 
    count := count + 1 ; 
 ) ; 
    i := 0 ; 
    while (count > i) do (     OclFile["System.out"].println(temp[i+1][0+1]) ; 
     i := i + 1 ) ; 
 )   catch (e : IOException) do (     OclFile["System.out"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void work(){
    for(; ; ){
      int n=sc.nextInt();
      int r=sc.nextInt();
      if((n | r)==0){
        break ;
      }
      int[] input=new int[n];
      for(int i=0 ; i<n ; i++){
        input[i]=n-i ;
      }
      for(int i=0 ; i<r ; i++){
        int p=sc.nextInt()-1 ;
        int c=sc.nextInt();
        int[] deck=input.clone();
        for(int j=0 ; j<c ; j++){
          deck[j]=input[j+p];
        }
        for(int j=0 ; j<p ; j++){
          deck[j+c]=input[j];
        }
        input=deck ;
      }
      System.out.println(input[0]);
    }
  }
  public static void main(String[] args){
    Main Misson_work=new Main();
    Misson_work.work();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation work() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,r)) = 0) then (     break ) else skip ; 
    var input : Sequence(int) ; input := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     input[i+1] := n - i )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < r do ( (     var p : int ; p := sc.getCurrent()->toInteger() - 1 ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
    var deck : Sequence(int) ; deck := input->copy() ;
        var j : int ; j := 0 ; while j < c do ( (     deck[j+1] := input[j + p+1] )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < p do ( (     deck[j + c+1] := input[j+1] )  ;     j := j + 1 ) ; 
    input := deck ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(input[0+1]) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Misson_work : Main ; Misson_work := Main.newMain() ;
     Misson_work.work() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String[] tmpArray=br.readLine().split(" ");
      int n=Integer.parseInt(tmpArray[0]);
      int r=Integer.parseInt(tmpArray[1]);
      if(n==0 && r==0){
        break ;
      }
      int[] hanafuda=new int[n];
      for(int i=0 ; i<n ; i++){
        hanafuda[i]=i+1 ;
      }
      for(int i=0 ; i<r ; i++){
        tmpArray=br.readLine().split(" ");
        int p=Integer.parseInt(tmpArray[0]);
        int c=Integer.parseInt(tmpArray[1]);
        shuffleDeck(hanafuda,p,c);
      }
      System.out.println(hanafuda[hanafuda.length-1]);
    }
  }
  static void shuffleDeck(int[] deck,int p,int c){
    int[] tmpDeck ;
    tmpDeck=Arrays.copyOfRange(deck,deck.length-p-c+1,deck.length-p+1);
    for(int i=deck.length-p-c+1 ; i<=deck.length-c-1 ; i++){
      deck[i]=deck[i+c];
    }
    for(int i=deck.length-c ; i<deck.length ; i++){
      deck[i]=tmpDeck[i-deck.length+c];
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
     var n : int ; n := (tmpArray[0+1])->toInteger() ;
    var r : int ; r := (tmpArray[1+1])->toInteger() ;
    if (n = 0 & r = 0) then (     break ) else skip ; 
    var hanafuda : Sequence(int) ; hanafuda := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     hanafuda[i+1] := i + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < r do ( (     tmpArray := br.readLine()->split(" ") ; 
     var p : int ; p := (tmpArray[0+1])->toInteger() ;
     var c : int ; c := (tmpArray[1+1])->toInteger() ;
     execute shuffleDeck(hanafuda, p, c) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(hanafuda[hanafuda->size() - 1+1]) ; 
 ) );
  static   operation shuffleDeck( deck : Sequence(int), p : int, c : int) : void
  pre: true
  post: true
  activity: (     var tmpDeck : Sequence(int) ;
     tmpDeck := deck.subrange(deck->size() - p - c + 1+1,deck->size() - p + 1) ; 
         var i : int ; i := deck->size() - p - c + 1 ; while i <= deck->size() - c - 1 do ( (     deck[i+1] := deck[i + c+1] )  ;     i := i + 1 ) ; 
         var i : int ; i := deck->size() - c ; while i < deck->size() do ( (     deck[i+1] := tmpDeck[i - deck->size() + c+1] )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.*;
class GFG {
  static int log2(int N){
    int result=(int)(Math.log(N)/Math.log(2));
    return result ;
  }
  static int invertBits(int num){
    int x=log2(num)+1 ;
    for(int i=0 ; i<x ; i++)num=(num ^(1<<i));
    return num ;
  }
  static int totalPairs(int arr1[],int arr2[],int n,int m){
    HashSet<Integer>s1=new HashSet<Integer>();
    HashSet<Integer>s2=new HashSet<Integer>();
    for(int i=0 ; i<m ; i++)s2.add(arr2[i]);
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(! s1.contains(arr1[i])){
        if(s2.contains(invertBits(arr1[i]))){
          count++;
          s1.add(arr1[i]);
        }
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int arr1[]={
      43,7,1,99 };
      int arr2[]={
        5,1,28,20 };
        int n=arr1.length ;
        int m=arr2.length ;
        System.out.println(totalPairs(arr1,arr2,n,m));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation log2( N : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := ((N)->log() / (2)->log())->oclAsType(int) ;
     return result );
  static   operation invertBits( num : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := log2(num) + 1 ;
         var i : int ; i := 0 ; while i < x do (     num := (num xor ((1*(2->pow(i)))->oclAsType(long))) ;  ;     i := i + 1 ) ; 
     return num );
  static   operation totalPairs( arr1 : Sequence(int), arr2 : Sequence(int), n : int, m : int) : int
  pre: true
  post: true
  activity: (     var s1 : Set(int) ; s1 := Set{} ;
     var s2 : Set(int) ; s2 := Set{} ;
        var i : int ; i := 0 ; while i < m do (     s2 := s2->including(arr2[i+1]) ;  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (not(s1->includes(arr1[i+1]))) then (     if (s2->includes(invertBits(arr1[i+1]))) then (     count := count + 1 ; 
     s1 := s1->including(arr1[i+1]) ) else skip ) else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{43,7,1,99} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{5,1,28,20} ;
    var n : int ; n := arr1->size() ;
    var m : int ; m := arr2->size() ;
    OclFile["System.out"].println(totalPairs(arr1, arr2, n, m)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public Main(){
    int t=sc.nextInt();
    sc.nextLine();
    for(int i=0 ; i<t ; i++){
      int len=sc.nextInt();
      sc.nextLine();
      String s=sc.nextLine();
      if(s.startsWith("2020")|| s.endsWith("2020")||(s.charAt(0)=='2' && s.substring(s.length()-3).equals("020"))||(s.substring(0,3).equals("202")&& s.charAt(s.length()-1)=='0')||(s.substring(0,2).equals("20")&& s.substring(s.length()-2).equals("20"))){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
     skip ; 
         var i : int ; i := 0 ; while i < t do ( (     var len : int ; len := sc.getCurrent()->toInteger() ;
     skip ; 
     var s : String ; s := sc.nextLine() ;
     if (s->hasPrefix("2020") or s->hasSuffix("2020") or (s->at(0+1) = '2' & s.subrange(s->size() - 3+1,s->size() - 3) = "020") or (s.subrange(0+1,3) = "202" & s->at(s->size() - 1+1) = '0') or (s.subrange(0+1,2) = "20" & s.subrange(s->size() - 2+1,s->size() - 2) = "20")) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      String s=sc.next();
      boolean f=false ;
      f |=s.substring(0,4).equals("2020");
      f |=s.substring(n-4,n).equals("2020");
      f |=(s.charAt(0)+""+s.charAt(1)+""+s.charAt(n-2)+""+s.charAt(n-1)).equals("2020");
      f |=(s.charAt(0)+""+s.charAt(n-3)+""+s.charAt(n-2)+""+s.charAt(n-1)).equals("2020");
      f |=(s.charAt(0)+""+s.charAt(1)+""+s.charAt(2)+""+s.charAt(n-1)).equals("2020");
      System.out.println(f ? "YES" : "NO");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
    var f : boolean ; f := false ;
    f := MathLib.bitwiseOr(f, s.subrange(0+1,4) = "2020") ; 
    f := MathLib.bitwiseOr(f, s.subrange(n - 4+1,n) = "2020") ; 
    f := MathLib.bitwiseOr(f, (s->at(0+1) + "" + s->at(1+1) + "" + s->at(n - 2+1) + "" + s->at(n - 1+1)) = "2020") ; 
    f := MathLib.bitwiseOr(f, (s->at(0+1) + "" + s->at(n - 3+1) + "" + s->at(n - 2+1) + "" + s->at(n - 1+1)) = "2020") ; 
    f := MathLib.bitwiseOr(f, (s->at(0+1) + "" + s->at(1+1) + "" + s->at(2+1) + "" + s->at(n - 1+1)) = "2020") ; 
    OclFile["System.out"].println(if f then "YES" else "NO" endif) ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class LastYearSubString {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=Integer.parseInt(input.nextLine());
    while(test-->0){
      int len=Integer.parseInt(input.nextLine());
      String fullString=input.nextLine();
      len=fullString.length();
      boolean changeable=false ;
      if(len==4){
        changeable=fullString.equals("2020");
      }
      else if(len>4){
        for(int i=0 ; i<5 ; i++){
          StringBuilder strb=new StringBuilder(fullString);
          strb.replace(i,len-4+i,"");
          if(strb.toString().equals("2020")){
            changeable=true ;
            break ;
          }
        }
      }
      if(changeable){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class LastYearSubString {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := (input.nextLine())->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var len : int ; len := (input.nextLine())->toInteger() ;
     var fullString : String ; fullString := input.nextLine() ;
    len := fullString->size() ; 
    var changeable : boolean ; changeable := false ;
    if (len = 4) then (     changeable := fullString = "2020" ) else     if (len > 4) then (         var i : int ; i := 0 ; while i < 5 do ( (     var strb : String ; strb := StringLib.newString(fullString) ;
     strb.replace(i, len - 4 + i, "") ; 
     if (strb+"" = "2020") then (     changeable := true ; 
     break ) else skip )  ;     i := i + 1 ) ) else skip ; ;  
    if (changeable) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String srgs[]){
    Scanner sc=new Scanner(System.in);
    int k_leftA=0 ;
    int k_leftB=0 ;
    int k_leftC=0 ;
    int k_leftD=0 ;
    int k_rightA=0 ;
    int k_rightB=0 ;
    int k_rightC=0 ;
    int k_rightD=0 ;
    while(sc.hasNext()){
      double left=sc.nextDouble();
      double right=sc.nextDouble();
      if(1.1<=left){
        k_leftA++;
      }
      else if(0.6<=left){
        k_leftB++;
      }
      else if(0.2<=left){
        k_leftC++;
      }
      else {
        k_leftD++;
      }
      if(1.1<=right){
        k_rightA++;
      }
      else if(0.6<=right){
        k_rightB++;
      }
      else if(0.2<=right){
        k_rightC++;
      }
      else {
        k_rightD++;
      }
    }
    System.out.println(k_leftA+" "+k_rightA);
    System.out.println(k_leftB+" "+k_rightB);
    System.out.println(k_leftC+" "+k_rightC);
    System.out.println(k_leftD+" "+k_rightD);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( srgs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k_leftA : int ; k_leftA := 0 ;
    var k_leftB : int ; k_leftB := 0 ;
    var k_leftC : int ; k_leftC := 0 ;
    var k_leftD : int ; k_leftD := 0 ;
    var k_rightA : int ; k_rightA := 0 ;
    var k_rightB : int ; k_rightB := 0 ;
    var k_rightC : int ; k_rightC := 0 ;
    var k_rightD : int ; k_rightD := 0 ;
    while (sc.hasNext()) do (     var left : double ; left := sc.getCurrent()->toReal() ;
     var right : double ; right := sc.getCurrent()->toReal() ;
     if (1.1 <= left) then (     k_leftA := k_leftA + 1 ) else     if (0.6 <= left) then (     k_leftB := k_leftB + 1 ) else     if (0.2 <= left) then (     k_leftC := k_leftC + 1 ) else (     k_leftD := k_leftD + 1 ) ;  ;  ;  
     if (1.1 <= right) then (     k_rightA := k_rightA + 1 ) else     if (0.6 <= right) then (     k_rightB := k_rightB + 1 ) else     if (0.2 <= right) then (     k_rightC := k_rightC + 1 ) else (     k_rightD := k_rightD + 1 ) ;  ;  ) ; 
    OclFile["System.out"].println(k_leftA + " " + k_rightA) ; 
    OclFile["System.out"].println(k_leftB + " " + k_rightB) ; 
    OclFile["System.out"].println(k_leftC + " " + k_rightC) ; 
    OclFile["System.out"].println(k_leftD + " " + k_rightD) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p048 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p048().run());
  }
  public String run(){
    BigInteger modulus=BigInteger.TEN.pow(10);
    BigInteger sum=BigInteger.ZERO ;
    for(int i=1 ; i<=1000 ; i++)sum=sum.add(BigInteger.valueOf(i).modPow(BigInteger.valueOf(i),modulus));
    return sum.mod(modulus).toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class p048 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p048.newp048().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var modulus : long ; modulus := 10.pow(10) ;
     var sum : long ; sum := 0 ;
         var i : int ; i := 1 ; while i <= 1000 do (     sum := sum->excludes((i + "")->toLong().modPow((i + "")->toLong(), modulus)) ;  ;     i := i + 1 ) ; 
     return sum.mod(modulus)+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static int n ;
  public static int A[];
  public static int B[];
  public static int C[]=new int[10000];
  public static StringBuilder sb=new StringBuilder();
  public static void main(String[] args)throws NumberFormatException,IOException {
    Scanner scan=new Scanner(System.in);
    n=scan.nextInt();
    A=new int[n];
    B=new int[n];
    for(int i=0 ; i<n ; i++){
      A[i]=scan.nextInt();
      C[A[i] ]++;
    }
    for(int i=1 ; i<10000 ; i++){
      C[i]=C[i-1]+C[i];
    }
    for(int i=n-1 ; i>=0 ; i--){
      B[C[A[i] ]-1]=A[i];
      C[A[i] ]--;
    }
    for(int i=0 ; i<n-1 ; i++){
      sb.append(B[i]);
      sb.append(" ");
    }
    System.out.println(sb.toString()+B[n-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute A : Sequence(int);
  static   attribute B : Sequence(int);
  static   attribute C : int := Integer.subrange(1,10000)->collect(0);
  static   attribute sb : String := StringLib.newString();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := scan.getCurrent()->toInteger() ; 
    A := Integer.subrange(1,n)->collect(0) ; 
    B := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := scan.getCurrent()->toInteger() ; 
     C[A[i+1]+1] := C[A[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < 10000 do ( (     C[i+1] := C[i - 1+1] + C[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     B[C[A[i+1]+1] - 1+1] := A[i+1] ; 
     C[A[i+1]+1] := C[A[i+1]+1] - 1 )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     sb := sb + StringLib.newString(B[i+1]) ; 
     sb := sb + StringLib.newString(" ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"" + B[n - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static boolean isSlopeGood(double slope,int arr[],int n){
    Set<Double>setOfLines=new HashSet<Double>();
    for(int i=0 ; i<n ; i++)setOfLines.add(arr[i]-slope*(i));
    return setOfLines.size()==2 ;
  }
  static boolean checkForParallel(int arr[],int n){
    boolean slope1=isSlopeGood(arr[1]-arr[0],arr,n);
    boolean slope2=isSlopeGood(arr[2]-arr[1],arr,n);
    boolean slope3=isSlopeGood((arr[2]-arr[0])/2,arr,n);
    return(slope1==true || slope2==true || slope3==true);
  }
  public static void main(String[] args){
    int arr[]={
      1,6,3,8,5 };
      int n=arr.length ;
      if(checkForParallel(arr,n)==true)System.out.println("1");
      else System.out.println("0");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation isSlopeGood( slope : double, arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var setOfLines : Set(double) ; setOfLines := Set{} ;
         var i : int ; i := 0 ; while i < n do (     setOfLines := setOfLines->including(arr[i+1] - slope * (i)) ;  ;     i := i + 1 ) ; 
     return setOfLines->size() = 2 );
  static   operation checkForParallel( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var slope1 : boolean ; slope1 := isSlopeGood(arr[1+1] - arr[0+1], arr, n) ;
     var slope2 : boolean ; slope2 := isSlopeGood(arr[2+1] - arr[1+1], arr, n) ;
     var slope3 : boolean ; slope3 := isSlopeGood((arr[2+1] - arr[0+1]) / 2, arr, n) ;
     return (slope1 = true or slope2 = true or slope3 = true) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,6,3,8,5} ;
     var n : int ; n := arr->size() ;
     if (checkForParallel(arr, n) = true) then     OclFile["System.out"].println("1") ; else     OclFile["System.out"].println("0") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import com.sun.org.apache.regexp.internal.RE ;
import java.util.ArrayList ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    List<Restaurant>restaurants=new ArrayList<>();
    for(int i=1 ; i<=N ; i++){
      restaurants.add(new Restaurant(i,sc.next(),sc.nextInt()));
    }
    Comparator<Restaurant>restaurantComparator=Comparator.comparing(Restaurant :: getCity).thenComparing(Restaurant :: getPoint,Comparator.reverseOrder());
    restaurants.sort(restaurantComparator);
    for(Restaurant restaurant : restaurants){
      System.out.println(restaurant.index);
    }
  }
  class Restaurant {
    int index ;
    String city ;
    int point ;
    String getCity(){
      return city ;
    }
    int getPoint(){
      return point ;
    }
    Restaurant(int index,String city,int point){
      this.index=index ;
      this.city=city ;
      this.point=point ;
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var restaurants : Sequence(Restaurant) ; restaurants := Sequence{} ;
        var i : int ; i := 1 ; while i <= N do ( (     restaurants := restaurants->including(Restaurant.newRestaurant(i, sc.getCurrent(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var restaurantComparator : Function(<Restaurant>,(<Restaurant>,boolean)) ; restaurantComparator := Comparator.comparing(lambda _pars : OclAny in Restaurant.newRestaurant().getCity(_pars)).thenComparing(lambda _pars : OclAny in Restaurant.newRestaurant().getPoint(_pars), Comparator.reverseOrder()) ;
    restaurants := restaurants.sort(restaurantComparator) ; 
    for (restaurant : restaurants) do ( (     OclFile["System.out"].println(restaurant.index) )  ) ; 
 );
 class Restaurant {
   attribute index : int;
   attribute city : String;
   attribute point : int;
   operation getCity() : String
  pre: true
  post: true
  activity: (     return city );
   operation getPoint() : int
  pre: true
  post: true
  activity: (     return point );
   static operation newRestaurant( index : int, city : String, point : int) : Restaurant
  pre: true
  post: true
  activity:
  ( var self : Restaurant ;
    self := createRestaurant();
    self.initialise(index, city,point);
    return self );
  operation initialise( index : int, city : String, point : int) : void
  pre: true  post: true
  activity: (     self.index := index ; 
     self.city := city ; 
     self.point := point );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Restaurant implements Comparable<Restaurant>{
  String direc ;
  int num ;
  int i ;
  public Restaurant(String direc,int num,int i){
    this.direc=direc ;
    this.num=num ;
    this.i=i ;
  }
  public int compareTo(Restaurant other){
    int ans=direc.compareTo(other.direc);
    if(ans!=0)return ans ;
    return Integer.compare(other.num,num);
  }
}
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    List<Restaurant>list=new ArrayList<Restaurant>();
    int n=sc.nextInt();
    for(int i=1 ; i<=n ; i++){
      String direc=sc.next();
      int num=sc.nextInt();
      list.add(new Restaurant(direc,num,i));
    }
    Collections.sort(list);
    for(Restaurant restaulant : list){
      System.out.println(restaulant.i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Restaurant implements Comparable<Restaurant> {
   attribute direc : String;
   attribute num : int;
   attribute i : int;
   static operation newRestaurant( direc : String, num : int, i : int) : Restaurant
  pre: true
  post: true
  activity:
  ( var self : Restaurant ;
    self := createRestaurant();
    self.initialise(direc, num,i);
    return self );
  operation initialise( direc : String, num : int, i : int) : void
  pre: true  post: true
  activity: (     self.direc := direc ; 
     self.num := num ; 
     self.i := i );
   operation compareTo( other : Restaurant) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := direc->compareTo(other.direc) ;
     if (ans /= 0) then     return ans else skip ; 
     return compare(other.num, num) );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(Restaurant) ; list := Sequence{} ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= n do ( (     var direc : String ; direc := sc.getCurrent() ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
     list := list->including(Restaurant.newRestaurant(direc, num, i)) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    for (restaulant : list) do ( (     OclFile["System.out"].println(restaulant.i) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javax.crypto.Cipher ;
import java.util.*;
public class Main {
  public static void main(String args[]){
    List<City>cityList=new ArrayList<>();
    List<City>cityList2=new ArrayList<>();
    Scanner scanner=new Scanner(System.in);
    try {
      int n=scanner.nextInt();
      for(int i=0 ; i<n ; i++){
        String city=scanner.next();
        int score=scanner.nextInt();
        cityList.add(new City(city,score));
        cityList2.add(new City(city,score));
      }
      cityList.sort(new CityComparater());
      for(int i=0 ; i<n ; i++){
        System.out.println(cityList2.indexOf(cityList.get(i))+1);
      }
    }
    catch(Exception e){
      System.out.println(e.getMessage());
    }
    finally {
      scanner.close();
    }
  }
}
class CityComparater implements Comparator<City>{
  @ Override public int compare(City city1,City city2){
    if(city1.name.compareTo(city2.name)==0)return city1.score>city2.score ?-1 : 1 ;
    return city1.name.compareTo(city2.name);
  }
}
class City {
  String name ;
  int score ;
  City(String name,int score){
    this.name=name ;
    this.score=score ;
  }
  @ Override public boolean equals(Object o){
    if(this==o)return true ;
    if(o==null || getClass()!=o.getClass())return false ;
    City city=(City)o ;
    return score==city.score && Objects.equals(name,city.name);
  }
  @ Override public int hashCode(){
    return Objects.hash(name,score);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cityList : Sequence(City) ; cityList := Sequence{} ;
     var cityList2 : Sequence(City) ; cityList2 := Sequence{} ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     try (     var n : int ; n := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var city : String ; city := scanner.getCurrent() ;
     var score : int ; score := scanner.getCurrent()->toInteger() ;
     cityList := cityList->including(City.newCity(city, score)) ; 
     cityList2 := cityList2->including(City.newCity(city, score)) )  ;     i := i + 1 ) ; 
     cityList := cityList.sort(CityComparater.newCityComparater()) ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(cityList2->indexOf(cityList->at(i+1))-1 + 1) )  ;     i := i + 1 ) )   catch (e : ProgramException) do (     OclFile["System.out"].println(e.getMessage()) )
   finally (     skip )
 );
}
class CityComparater implements Function(<City>,(<City>,boolean)) {
      operation compare( city1 : City, city2 : City) : int
  pre: true
  post: true
  activity: (     if (city1.name->compareTo(city2.name) = 0) then     return if city1.score > city2.score then -1 else 1 endif else skip ; 
     return city1.name->compareTo(city2.name) );
}
class City {
   attribute name : String;
   attribute score : int;
   static operation newCity( name : String, score : int) : City
  pre: true
  post: true
  activity:
  ( var self : City ;
    self := createCity();
    self.initialise(name, score);
    return self );
  operation initialise( name : String, score : int) : void
  pre: true  post: true
  activity: (     self.name := name ; 
     self.score := score );
      operation equals( o : OclAny) : boolean
  pre: true
  post: true
  activity: (     if (self = o) then     return true else skip ; 
     if (o = null or getClass() /= o->oclType()) then     return false else skip ; 
     var city : City ; city := o->oclAsType(City) ;
     return score = city.score & Objects = name, city.name );
      operation hashCode() : int
  pre: true
  post: true
  activity: (     return Objects.hash(name, score) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    ArrayList<Person>al=new ArrayList<>();
    for(int i=1 ; i<=N ; i++){
      al.add(new Person(i,sc.next(),sc.nextInt()));
    }
    al.sort(Comparator.comparing(Person :: getNum).reversed());
    al.sort(Comparator.comparing(Person :: getName));
    for(int i=0 ; i<N ; i++){
      System.out.println(al.get(i).getId());
    }
  }
}
class Person {
  int id ;
  String name ;
  int num ;
  public Person(int id,String name,int num){
    this.id=id ;
    this.name=name ;
    this.num=num ;
  }
  public int getId(){
    return id ;
  }
  public String getName(){
    return name ;
  }
  public int getNum(){
    return num ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var al : Sequence(Person) ; al := Sequence{} ;
        var i : int ; i := 1 ; while i <= N do ( (     al := al->including(Person.newPerson(i, sc.getCurrent(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    al := al.sort(Comparator.comparing(lambda _pars : OclAny in Person.newPerson().getNum(_pars)).reversed()) ; 
    al := al.sort(Comparator.comparing(lambda _pars : OclAny in Person.newPerson().getName(_pars))) ; 
        var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].println(al->at(i+1).getId()) )  ;     i := i + 1 ) ; 
 );
}
class Person {
   attribute id : int;
   attribute name : String;
   attribute num : int;
   static operation newPerson( id : int, name : String, num : int) : Person
  pre: true
  post: true
  activity:
  ( var self : Person ;
    self := createPerson();
    self.initialise(id, name,num);
    return self );
  operation initialise( id : int, name : String, num : int) : void
  pre: true  post: true
  activity: (     self.id := id ; 
     self.name := name ; 
     self.num := num );
   operation getId() : int
  pre: true
  post: true
  activity: (     return id );
   operation getName() : String
  pre: true
  post: true
  activity: (     return name );
   operation getNum() : int
  pre: true
  post: true
  activity: (     return num );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    Map<String,List<Integer>>map=new TreeMap<>();
    List<Integer>order=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      String s=scanner.next();
      int p=scanner.nextInt();
      order.add(p);
      if(map.containsKey(s)){
        map.get(s).add(p);
      }
      else {
        List<Integer>set=new ArrayList<>();
        set.add(p);
        map.put(s,set);
      }
    }
    Comparator<Integer>comparator=new Comparator<Integer>(){
      @ Override public int compare(Integer o1,Integer o2){
        return o2-o1 ;
      }
    };
    for(List<Integer>value : map.values()){
      value.sort(comparator);
      for(Integer price : value){
        System.out.println(order.indexOf(price)+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var map : Map(String,Sequence(int)) ; map := Map{} ;
    var order : Sequence(int) ; order := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := scanner.getCurrent() ;
     var p : int ; p := scanner.getCurrent()->toInteger() ;
     order := order->including(p) ; 
     if (map->keys()->includes(s)) then (     map->at(s)->excludes(p) ) else (     var set : Sequence(int) ; set := Sequence{} ;
     set := set->including(p) ; 
     map := map->union(Map{s |-> set}) ) )  ;     i := i + 1 ) ; 
    var comparator : Function(<int>,(<int>,boolean)) ; comparator := OclComparator<int>.newOclComparator() ;
    for (value : map->values()) do ( (     value.sort(comparator) ; 
     for (price : value) do ( (     OclFile["System.out"].println(order->indexOf(price)-1 + 1) )  ) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static double maxEdges(double N){
    double edges=0 ;
    edges=Math.floor((N*N)/4);
    return edges ;
  }
  public static void main(String[] args){
    double N=5 ;
    System.out.println(maxEdges(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxEdges( N : double) : double
  pre: true
  post: true
  activity: (     var edges : double ; edges := 0 ;
     edges := ((N * N) / 4)->floor() ; 
     return edges );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : double ; N := 5 ;
     OclFile["System.out"].println(maxEdges(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int checkIfStartsWithVowels(char[] str){
    if(!(str[0]=='A' || str[0]=='a' || str[0]=='E' || str[0]=='e' || str[0]=='I' || str[0]=='i' || str[0]=='O' || str[0]=='o' || str[0]=='U' || str[0]=='u'))return 1 ;
    else return 0 ;
  }
  static void check(String str){
    if(checkIfStartsWithVowels(str.toCharArray())==1)System.out.print("Not Accepted\n");
    else System.out.print("Accepted\n");
  }
  public static void main(String[] args){
    String str="animal" ;
    check(str);
    str="zebra" ;
    check(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkIfStartsWithVowels( str : Sequence(String)) : int
  pre: true
  post: true
  activity: (     if (not((str[0+1] = 'A' or str[0+1] = 'a' or str[0+1] = 'E' or str[0+1] = 'e' or str[0+1] = 'I' or str[0+1] = 'i' or str[0+1] = 'O' or str[0+1] = 'o' or str[0+1] = 'U' or str[0+1] = 'u'))) then     return 1 else     return 0 );
  static   operation check( str : String) : void
  pre: true
  post: true
  activity: (     if (checkIfStartsWithVowels(str->characters()) = 1) then     OclFile["System.out"].print("Not Accepted\n") ; else     OclFile["System.out"].print("Accepted\n") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "animal" ;
     execute check(str) ; 
     str := "zebra" ; 
     execute check(str) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static final int MAX=10 ;
  static int minSum(int arr[],int n){
    int freq[]=new int[MAX];
    for(int i=0 ; i<n ; i++){
      freq[arr[i] ]++;
    }
    int k=0 ;
    for(int i=0 ; i<MAX ; i++){
      for(int j=0 ; j<freq[i]; j++){
        arr[k++]=i ;
      }
    }
    int num1=0 ;
    int num2=0 ;
    for(int i=0 ; i<n ; i++){
      if(i % 2==0)num1=num1*MAX+arr[i];
      else num2=num2*MAX+arr[i];
    }
    return num1+num2 ;
  }
  public static void main(String[] args){
    int arr[]={
      6,8,4,5,2,3 };
      int n=arr.length ;
      System.out.print(minSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 10;
  static   operation minSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,MAX)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     freq[arr[i+1]+1] := freq[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var k : int ; k := 0 ;
        var i : int ; i := 0 ; while i < MAX do ( (         var j : int ; j := 0 ; while j < freq[i+1] do ( (      arr[k+1] := i  ; k := k + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var num1 : int ; num1 := 0 ;
    var num2 : int ; num2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then     num1 := num1 * MAX + arr[i+1] ; else     num2 := num2 * MAX + arr[i+1] ; )  ;     i := i + 1 ) ; 
    return num1 + num2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,8,4,5,2,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(minSum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.HashMap ;
public class Main {
  static final int LEFT=0 ;
  static final int RIGHT=1 ;
  static final double[] eyeTable={
    1.1,0.6,0.2 };
    static int[][] numEye=new int[2][4];
    public static void main(String[] args)throws IOException {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String buf=null ;
      while((buf=br.readLine())!=null){
        String[] eye=buf.split(" ");
        String leftEyeClass=judgeEye(Double.parseDouble(eye[LEFT]));
        String rightEyeClass=judgeEye(Double.parseDouble(eye[RIGHT]));
        updateData(leftEyeClass,LEFT);
        updateData(rightEyeClass,RIGHT);
      }
      for(int i=0 ; i<numEye[0] .length ; i++){
        System.out.println(numEye[LEFT][i]+" "+numEye[RIGHT][i]);
      }
    }
    private static void updateData(String eye,int side){
      switch(eye.charAt(0)){
        case 'A' : numEye[side][0]++;
        break ;
        case 'B' : numEye[side][1]++;
        break ;
        case 'C' : numEye[side][2]++;
        break ;
        case 'D' : numEye[side][3]++;
        break ;
        default : }
      }
      private static String judgeEye(double eye){
        char eyeClass='D' ;
        for(int i=0 ; i<eyeTable.length ; i++){
          if(eye>=eyeTable[i]){
            eyeClass=(char)((int)'A'+i);
            break ;
          }
        }
        return String.valueOf(eyeClass);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute LEFT : int := 0;
  static    attribute RIGHT : int := 1;
  static    attribute eyeTable : Sequence(double) := Sequence{1.1,0.6,0.2};
  static   attribute numEye : Sequence(Sequence(int)) := Integer.subrange(1,2)->collect(Integer.subrange(1,4)->collect(0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var buf : String ; buf := null ;
         buf := br.readLine() ;
    while ((buf) /= null) do (    skip ; (     var eye : Sequence(String) ; eye := buf->split(" ") ;
     var leftEyeClass : String ; leftEyeClass := judgeEye((eye[LEFT+1])->toReal()) ;
    var rightEyeClass : String ; rightEyeClass := judgeEye((eye[RIGHT+1])->toReal()) ;
    execute updateData(leftEyeClass, LEFT) ; 
    execute updateData(rightEyeClass, RIGHT) ; 
 ) ;     buf := br.readLine() ;
 ) ;  
         var i : int ; i := 0 ; while i < numEye[0+1]->size() do ( (     OclFile["System.out"].println(numEye[LEFT+1][i+1] + " " + numEye[RIGHT+1][i+1]) )  ;     i := i + 1 ) );
  static   operation updateData( eye : String, side : int) : void
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (eye->at(0+1)) ; 
       if _switchval = 'A' then
     numEye[side+1][0+1] := numEye[side+1][0+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 'B' then
     numEye[side+1][1+1] := numEye[side+1][1+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 'C' then
     numEye[side+1][2+1] := numEye[side+1][2+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 'D' then
     numEye[side+1][3+1] := numEye[side+1][3+1] + 1 ; 
    break 
   else skip ;
   if true then
 )
 );
  static   operation judgeEye( eye : double) : String
  pre: true
  post: true
  activity: (     var eyeClass : String ; eyeClass := 'D' ;
         var i : int ; i := 0 ; while i < eyeTable->size() do ( (     if (eye >= eyeTable[i+1]) then (     eyeClass := (('A')->char2byte() + i)->oclAsType(String) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     return ((eyeClass) + "") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static void main(String[] args){
    InputStream stream=System.in ;
    InputReader input=new InputReader(stream);
    int N=input.nextInt();
    int[] A=new int[N+1];
    int[] B=new int[N+1];
    for(int i=0 ; i<N ; i++){
      A[i+1]=input.nextInt();
    }
    CountingSort(A,B,20000);
    PrintWriter out=new PrintWriter(System.out);
    for(int i=1 ; i<N ; i++){
      out.print(B[i]+" ");
    }
    out.println(B[N]);
    out.flush();
    out.close();
  }
  public static void CountingSort(int[] A,int[] B,int k){
    int[] C=new int[k+1];
    for(int j=1 ; j<A.length ; j++){
      C[A[j] ]++;
    }
    for(int i=1 ; i<=k ; i++){
      C[i]+=C[i-1];
    }
    for(int j=A.length-1 ; j>=0 ; j--){
      B[C[A[j] ] ]=A[j];
      C[A[j] ]--;
    }
  }
}
class InputReader {
  public BufferedReader reader ;
  public StringTokenizer tokenizer ;
  public InputReader(InputStream stream){
    reader=new BufferedReader(new InputStreamReader(stream),32768);
    tokenizer=null ;
  }
  public String next(){
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        tokenizer=new StringTokenizer(reader.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stream : OclFile ; stream := OclFile["System.in"] ;
     var input : InputReader ; input := InputReader.newInputReader(stream) ;
    var N : int ; N := input.nextInt() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N + 1)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i + 1+1] := input.nextInt() )  ;     i := i + 1 ) ; 
    execute CountingSort(A, B, 20000) ; 
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
        var i : int ; i := 1 ; while i < N do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation CountingSort( A : Sequence(int), B : Sequence(int), k : int) : void
  pre: true
  post: true
  activity: (     var C : Sequence(int) ; C := Integer.subrange(1,k + 1)->collect(0) ;
         var j : int ; j := 1 ; while j < A->size() do ( (     C[A[j+1]+1] := C[A[j+1]+1] + 1 )  ;     j := j + 1 ) ; 
         var i : int ; i := 1 ; while i <= k do ( (     C[i+1] := C[i+1]+(C[i - 1+1]) )  ;     i := i + 1 ) ; 
         var j : int ; j := A->size() - 1 ; while j >= 0 do ( (     B[C[A[j+1]+1]+1] := A[j+1] ; 
     C[A[j+1]+1] := C[A[j+1]+1] - 1 )  ;     j := j - 1 ) );
}
class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private void doit(){
    Scanner sc=new Scanner(System.in);
    int da=sc.nextInt();
    while(da-->0){
      long n=sc.nextLong();
      int count=0 ;
      long max=n ;
      while(true){
        if(max<10){
          System.out.println(count);
          break ;
        }
        max=solve(max);
        if(max>=n){
          System.out.println(-1);
          break ;
        }
        count++;
      }
    }
  }
  private int solve(Long num){
    String n=""+num ;
    int max=0 ;
    for(int i=1 ; i<n.length(); i++){
      int left=Integer.parseInt(n.substring(0,i));
      int right=Integer.parseInt(n.substring(i));
      int res=left*right ;
      max=Math.max(max,res);
    }
    return max ;
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var da : int ; da := sc.getCurrent()->toInteger() ;
         while (da > 0) do (        da := da - 1 ;     skip ; (     var n : long ; n := sc.getCurrent()->toLong() ;
     var count : int ; count := 0 ;
     var max : long ; max := n ;
     while (true) do (     if (max < 10) then (     OclFile["System.out"].println(count) ; 
     break ) else skip ; 
     max := solve(max) ; 
     if (max >= n) then (     OclFile["System.out"].println(-1) ; 
     break ) else skip ; 
     count := count + 1 ) ) ;  ) );
   operation solve( num : long) : int
  pre: true
  post: true
  activity: (     var n : String ; n := "" + num ;
     var max : int ; max := 0 ;
         var i : int ; i := 1 ; while i < n->size() do ( (     var left : int ; left := (n.subrange(0+1,i))->toInteger() ;
     var right : int ; right := (n.subrange(i+1,i))->toInteger() ;
     var res : int ; res := left * right ;
     max := Set{max, res}->max() )  ;     i := i + 1 ) ; 
     return max );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      int count=Integer.parseInt(br.readLine());
      int number[]=new int[count];
      int result[]=new int[count];
      for(int i=0 ; i<count ; i++){
        String s=br.readLine();
        number[i]=Integer.parseInt(s);
        while(true){
          if(number[i]<10)break ;
          s=String.valueOf(number[i]);
          int two[]=new int[s.length()-1];
          int max=0 ;
          for(int j=0 ; j<s.length()-1 ; j++){
            String s1=s.substring(0,j+1);
            String s2=s.substring(j+1,s.length());
            two[j]=Integer.parseInt(s1)*Integer.parseInt(s2);
          }
          for(int j=0 ; j<two.length ; j++){
            max=Math.max(max,two[j]);
          }
          number[i]=max ;
          result[i]++;
        }
      }
      for(int i=0 ; i<count ; i++){
        System.out.println(result[i]);
      }
      br.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var count : int ; count := (br.readLine())->toInteger() ;
     var number : Sequence(int) ; number := Integer.subrange(1,count)->collect(0) ;
    var result : Sequence(int) ; result := Integer.subrange(1,count)->collect(0) ;
        var i : int ; i := 0 ; while i < count do ( (     var s : String ; s := br.readLine() ;
     number[i+1] := (s)->toInteger() ; 
     while (true) do (     if (number[i+1] < 10) then     break else skip ; 
     s := ((number[i+1]) + "") ; 
    var two : Sequence(int) ; two := Integer.subrange(1,s->size() - 1)->collect(0) ;
    var max : int ; max := 0 ;
        var j : int ; j := 0 ; while j < s->size() - 1 do ( (     var s1 : String ; s1 := s.subrange(0+1,j + 1) ;
     var s2 : String ; s2 := s.subrange(j + 1+1,s->size()) ;
     two[j+1] := (s1)->toInteger() * (s2)->toInteger() )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < two->size() do ( (     max := Set{max, two[j+1]}->max() )  ;     j := j + 1 ) ; 
    number[i+1] := max ; 
    result[i+1] := result[i+1] + 1 ; 
 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < count do ( (     OclFile["System.out"].println(result[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static ArrayList<Integer>multipliedMaxNums ;
  static int numOfExe ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      String num=sc.next();
      multipliedMaxNums=new ArrayList<Integer>();
      numOfExe=0 ;
      solve(num);
      System.out.println(numOfExe);
    }
    sc.close();
  }
  public static void solve(String num){
    if(num.length()==1){
    }
    else {
      secondExe(num);
    }
  }
  public static void secondExe(String num){
    int digitNumber=num.length();
    int max=0 ;
    for(int i=0 ; i<digitNumber-1 ; i++){
      int multipledNum=Integer.parseInt(num.substring(0,(i+1)))*Integer.parseInt(num.substring((i+1),digitNumber));
      if(max<multipledNum){
        max=multipledNum ;
      }
    }
    if(multipliedMaxNums.contains(max)){
      numOfExe=-1 ;
    }
    else {
      numOfExe++;
      multipliedMaxNums.add(max);
      solve(String.valueOf(max));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute multipliedMaxNums : Sequence(int);
  static   attribute numOfExe : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < q do ( (     var num : String ; num := sc.getCurrent() ;
     multipliedMaxNums := Sequence{} ; 
    numOfExe := 0 ; 
    execute solve(num) ; 
    OclFile["System.out"].println(numOfExe) ; 
 )  ;     i := i + 1 ) ; 
     skip );
  static   operation solve( num : String) : void
  pre: true
  post: true
  activity: (     if (num->size() = 1) then skip else (     execute secondExe(num) ) );
  static   operation secondExe( num : String) : void
  pre: true
  post: true
  activity: (     var digitNumber : int ; digitNumber := num->size() ;
     var max : int ; max := 0 ;
         var i : int ; i := 0 ; while i < (digitNumber)->char2byte() - 1 do ( (     var multipledNum : int ; multipledNum := (num.subrange(0+1,(i + 1)))->toInteger() * (num.subrange((i + 1)+1,digitNumber))->toInteger() ;
     if (max < multipledNum) then (     max := multipledNum ) else skip )  ;     i := i + 1 ) ; 
     if (multipliedMaxNums->includes(max)) then (     numOfExe := -1 ) else (     numOfExe := numOfExe + 1 ; 
     multipliedMaxNums := multipliedMaxNums->including(max) ; 
     execute solve(((max) + "")) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,nl,nr,i,j,max,q,count,d ;
    int[] c ;
    String s ;
    for(q=sc.nextInt(); q-->0 ; out.println(count)){
      n=sc.nextInt();
      max=0 ;
      for(count=-1 ; max!=-1 ; count++){
        d=caldig(n);
        j=10 ;
        max=-1 ;
        for(i=1 ; i<d ; i++){
          nr=n % j ;
          nl=n/j ;
          if(max<nr*nl)max=nr*nl ;
          j*=10 ;
        }
        n=max ;
      }
    }
    sc.close();
  }
  private static int caldig(int n){
    int i ;
    for(i=1 ; i<10 ; i++){
      if(n/10==0)return i ;
      n=n/10 ;
    }
    return 0 ;
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var nl : int ;
    var nr : int ;
    var i : int ;
    var j : int ;
    var max : int ;
    var q : int ;
    var count : int ;
    var d : int ;
    var c : Sequence(int) ;
    var s : String ;
        q := sc.nextInt() ; while q > 0 do ( (     n := sc.nextInt() ; 
     max := 0 ; 
         count := -1 ; while max /= -1 do ( (     d := caldig(n) ; 
     j := 10 ; 
    max := -1 ; 
        i := 1 ; while i < d do ( (     nr := n mod j ; 
     nl := n / j ; 
     if (max < nr * nl) then     max := nr * nl ; else skip ; 
     j := j*(10) )  ;     i := i + 1 ) ; 
    n := max ; 
 )  ;     count := count + 1 ) )  ;     out.println(count) ) ; 
    sc.close() ; 
 );
  static   operation caldig( n : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
         i := 1 ; while i < 10 do ( (     if (n / 10 = 0) then     return i else skip ; 
     n := n / 10 )  ;     i := i + 1 ) ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=Integer.parseInt(sc.next());
    long m=Integer.parseInt(sc.next());
    long ret=0 ;
    if(n>1 && m>1){
      ret=(n-2)*(m-2);
    }
    else if(n==1 && m==1){
      ret=1 ;
    }
    else {
      ret=Math.max(n,m)-2 ;
    }
    System.out.println(ret);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := (sc.getCurrent())->toInteger() ;
    var m : long ; m := (sc.getCurrent())->toInteger() ;
    var ret : long ; ret := 0 ;
    if (n > 1 & m > 1) then (     ret := (n - 2) * (m - 2) ) else     if (n = 1 & m = 1) then (     ret := 1 ) else (     ret := Set{n, m}->max() - 2 ) ;  ;  
    OclFile["System.out"].println(ret) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    long M=sc.nextLong();
    long answer=(Math.abs(N-2))*(Math.abs(M-2));
    System.out.println(answer);
  }
  static int gcd(int a,int b){
    return b>0 ? gcd(b,a % b): a ;
  }
  static int lcm(int a,int b){
    return a*b/gcd(a,b);
  }
  static boolean isPrime(int n){
    if(n==2)return true ;
    if(n<2 || n % 2==0)return false ;
    double d=Math.sqrt(n);
    for(int i=3 ; i<=d ; i+=2)if(n % i==0){
      return false ;
    }
    return true ;
  }
  static boolean isMultiple(String s,int base,int m){
    int temp=0 ;
    for(int i=0 ; i<s.length(); i++){
      temp=(temp*base+Character.getNumericValue(s.charAt(i)))% m ;
    }
    if(temp==0){
      return true ;
    }
    return false ;
  }
  static long factorial(int i){
    if(i==1){
      return 1 ;
    }
    else {
      return i*factorial(i-1);
    }
  }
  static String toNbase(String sm,int m,int n){
    return Long.toString(Long.parseLong(sm,m),n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    var M : long ; M := sc.getCurrent()->toLong() ;
    var answer : long ; answer := (if N - 2 < 0 then -(N - 2) else N - 2 endif) * (if M - 2 < 0 then -(M - 2) else M - 2 endif) ;
    OclFile["System.out"].println(answer) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b > 0 then gcd(b, a mod b) else a endif );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return a * b / gcd(a, b) );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 2) then     return true else skip ; 
     if (n < 2 or n mod 2 = 0) then     return false else skip ; 
    var d : double ; d := (n)->sqrt() ;
        var i : int ; i := 3 ; while i <= d do (     if (n mod i = 0) then (     return false ) else skip ;  ;     i := i+(2) ) ; 
    return true 
 );
  static   operation isMultiple( s : String, base : int, m : int) : boolean
  pre: true
  post: true
  activity: (     var temp : int ; temp := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     temp := (temp * base + ("" + s->at(i+1))->toInteger()) mod m )  ;     i := i + 1 ) ; 
     if (temp = 0) then (     return true ) else skip ; 
     return false );
  static   operation factorial( i : int) : long
  pre: true
  post: true
  activity: (     if (i = 1) then (     return 1 ) else (     return i * factorial(i - 1) ) );
  static   operation toNbase( sm : String, m : int, n : int) : String
  pre: true
  post: true
  activity: (     return (((sm)->toLong()) + "") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    long n=sc.nextInt();
    long m=sc.nextInt();
    if(n<2 || m<2){
      if(n==1 && m==1){
        System.out.println(1);
      }
      else {
        long l=Math.max(n,m);
        System.out.println(l-2);
      }
    }
    else {
      BigInteger bign=new BigInteger("0");
      BigInteger bigm=new BigInteger("0");
      BigInteger ans=new BigInteger("0");
      bign=BigInteger.valueOf(n-2);
      bigm=BigInteger.valueOf(m-2);
      ans=bign.multiply(bigm);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toInteger() ;
     var m : long ; m := sc.getCurrent()->toInteger() ;
     if (n < 2 or m < 2) then (     if (n = 1 & m = 1) then (     OclFile["System.out"].println(1) ) else (     var l : long ; l := Set{n, m}->max() ;
     OclFile["System.out"].println(l - 2) ) ) else (     var bign : long ; bign := long("0") ;
     var bigm : long ; bigm := long("0") ;
    var ans : long ; ans := long("0") ;
    bign := (n - 2 + "")->toLong() ; 
    bigm := (m - 2 + "")->toLong() ; 
    ans := bign.multiply(bigm) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner stdin=new Scanner(System.in);
    long row=stdin.nextLong()-2 ;
    long column=stdin.nextLong()-2 ;
    System.out.println(Math.abs(row*column));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var row : long ; row := stdin.getCurrent()->toLong() - 2 ;
     var column : long ; column := stdin.getCurrent()->toLong() - 2 ;
     OclFile["System.out"].println(if row * column < 0 then -(row * column) else row * column endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    long M=sc.nextLong();
    long ans=0 ;
    if(N==1){
      if(M==1){
        ans=1 ;
      }
      else if(M==2){
        ans=0 ;
      }
      else {
        ans=M-2 ;
      }
    }
    else if(N==2){
      if(M==1){
        ans=0 ;
      }
      else if(M==2){
        ans=0 ;
      }
      else {
        ans=0 ;
      }
    }
    else {
      if(M==1){
        ans=N-2 ;
      }
      else if(M==2){
        ans=0 ;
      }
      else {
        ans=(N-2)*(M-2);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    var M : long ; M := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
    if (N = 1) then (     if (M = 1) then (     ans := 1 ) else     if (M = 2) then (     ans := 0 ) else (     ans := M - 2 ) ;  ) else     if (N = 2) then (     if (M = 1) then (     ans := 0 ) else     if (M = 2) then (     ans := 0 ) else (     ans := 0 ) ;  ) else (     if (M = 1) then (     ans := N - 2 ) else     if (M = 2) then (     ans := 0 ) else (     ans := (N - 2) * (M - 2) ) ;  ) ;  ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int findNum(int div[],int rem[],int N){
    int num=rem[N-1];
    for(int i=N-2 ; i>=0 ; i--){
      num=num*div[i]+rem[i];
    }
    return num ;
  }
  public static void main(String[] args){
    int div[]={
      8,3 };
      int rem[]={
        2,2 };
        int N=div.length ;
        System.out.println(findNum(div,rem,N));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNum( div : Sequence(int), rem : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := rem[N - 1+1] ;
         var i : int ; i := N - 2 ; while i >= 0 do ( (     num := num * div[i+1] + rem[i+1] )  ;     i := i - 1 ) ; 
     return num );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var div : Sequence(int) ; div := Sequence{8,3} ;
     var rem : Sequence(int) ; rem := Sequence{2,2} ;
     var N : int ; N := div->size() ;
     OclFile["System.out"].println(findNum(div, rem, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.OptionalInt ;
import java.util.regex.Pattern ;
import java.util.stream.Stream ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  public void run(){
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      int n=Integer.parseInt(br.readLine());
      String line=br.readLine();
      final Pattern delim=Pattern.compile(" ");
      int[] arrayS=delim.splitAsStream(line).parallel().mapToInt(Integer :: parseInt).toArray();
      OptionalInt max=Arrays.stream(arrayS).max();
      dispIntArray(countingSort(arrayS,max.getAsInt()));
    }
    catch(IOException e){
      System.out.println("IOException!");
    }
  }
  public int[] countingSort(int[] a,int k){
    int aLength=a.length ;
    int[] result=new int[aLength];
    int[] counter=new int[k+1];
    for(int var : a){
      counter[var]++;
    }
    for(int i=1,max=k+1 ; i<max ; i++){
      counter[i]+=counter[i-1];
    }
    for(int i=aLength-1,val=0 ; i>=0 ; i--){
      val=a[i];
      result[counter[val]-1]=val ;
      counter[val]--;
    }
    return result ;
  }
  public void dispIntArray(int[] target){
    StringBuilder s=new StringBuilder();
    for(int i : target){
      s.append(i).append(" ");
    }
    s.setLength(s.length()-1);
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var n : int ; n := (br.readLine())->toInteger() ;
     var line : String ; line := br.readLine() ;
    var delim : OclRegex ; delim := OclRegex.compile(" ") ;
    var arrayS : Sequence(int) ; arrayS := delim.splitAsStream(line)->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var max : OptionalInt ; max := stream(arrayS).max() ;
    execute dispIntArray(countingSort(arrayS, max.getAsInt())) ; 
 ))   catch (e : IOException) do (     OclFile["System.out"].println("IOException!") )
  );
   operation countingSort( a : Sequence(int), k : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var aLength : int ; aLength := a->size() ;
     var result : Sequence(int) ; result := Integer.subrange(1,aLength)->collect(0) ;
    var counter : Sequence(int) ; counter := Integer.subrange(1,k + 1)->collect(0) ;
    for (var : a) do ( (     counter[var+1] := counter[var+1] + 1 )  ) ; 
        var i : int ; i := 1 ;
    var max : int ; max := k + 1 ; while i < max do ( (     counter[i+1] := counter[i+1]+(counter[i - 1+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := aLength - 1 ;
    var val : int ; val := 0 ; while i >= 0 do ( (     val := a[i+1] ; 
     result[counter[val+1] - 1+1] := val ; 
     counter[val+1] := counter[val+1] - 1 )  ;     i := i - 1 ) ; 
    return result 
 );
   operation dispIntArray( target : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := StringLib.newString() ;
     for (i : target) do ( (     s := s + StringLib.newString(i) + StringLib.newString(" ") )  ) ; 
     s := s.subrange(1,s->size() - 1) ; 
     OclFile["System.out"].println(s) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  static double e=0.0000000001 ;
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    double a,b ;
    int[] l,r ;
    int i ;
    l=new int[4];
    r=new int[4];
    for(; sc.hasNext(); ){
      a=sc.nextDouble();
      b=sc.nextDouble();
      if(a>=1.1-e)l[0]++;
      else if(a>=0.6-e)l[1]++;
      else if(a>=0.2-e)l[2]++;
      else l[3]++;
      if(b>=1.1-e)r[0]++;
      else if(b>=0.6-e)r[1]++;
      else if(b>=0.2-e)r[2]++;
      else r[3]++;
    }
    for(i=0 ; i<4 ; i++)out.println(l[i]+" "+r[i]);
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   attribute e : double := 0.0000000001;
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var a : double ;
    var b : double ;
    var l : Sequence(int) ;
    var r : Sequence(int) ;
    var i : int ;
    l := Integer.subrange(1,4)->collect(0) ; 
    r := Integer.subrange(1,4)->collect(0) ; 
      while sc.hasNext() do ( (     a := sc.nextDouble() ; 
     b := sc.nextDouble() ; 
     if (a >= 1.1 - e) then     l[0+1] := l[0+1] + 1 else     if (a >= 0.6 - e) then     l[1+1] := l[1+1] + 1 else     if (a >= 0.2 - e) then     l[2+1] := l[2+1] + 1 else     l[3+1] := l[3+1] + 1 ; ;  ;  ;  
     if (b >= 1.1 - e) then     r[0+1] := r[0+1] + 1 ; else     if (b >= 0.6 - e) then     r[1+1] := r[1+1] + 1 else     if (b >= 0.2 - e) then     r[2+1] := r[2+1] + 1 else     r[3+1] := r[3+1] + 1 ; ;  ;  )  ) ; 
        i := 0 ; while i < 4 do (     out.println(l[i+1] + " " + r[i+1]) ;  ;     i := i + 1 ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Random ;
public class ReservoirSampling {
  static void selectKItems(int stream[],int n,int k){
    int i ;
    int reservoir[]=new int[k];
    for(i=0 ; i<k ; i++)reservoir[i]=stream[i];
    Random r=new Random();
    for(; i<n ; i++){
      int j=r.nextInt(i+1);
      if(j<k)reservoir[j]=stream[i];
    }
    System.out.println("Following are k randomly selected items");
    System.out.println(Arrays.toString(reservoir));
  }
  public static void main(String[] args){
    int stream[]={
      1,2,3,4,5,6,7,8,9,10,11,12 };
      int n=stream.length ;
      int k=5 ;
      selectKItems(stream,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class ReservoirSampling {
  static   operation selectKItems( stream : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
     var reservoir : Sequence(int) ; reservoir := Integer.subrange(1,k)->collect(0) ;
        i := 0 ; while i < k do (     reservoir[i+1] := stream[i+1] ;  ;     i := i + 1 ) ; 
    var r : OclRandom ; r := OclRandom.newOclRandom() ;
      while i < n do ( (     var j : int ; j := r.nextInt(i + 1) ;
     if (j < k) then     reservoir[j+1] := stream[i+1] ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Following are k randomly selected items") ; 
    OclFile["System.out"].println((reservoir + "")) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stream : Sequence(int) ; stream := Sequence{1,2,3,4,5,6,7,8,9,10,11,12} ;
     var n : int ; n := stream->size() ;
     var k : int ; k := 5 ;
     execute selectKItems(stream, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int CenteredDodecahedral_num(int n){
    return(2*n+1)*(5*n*n+5*n+1);
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.print(n+"th Centered "+"Dodecahedral number : ");
    System.out.println(CenteredDodecahedral_num(n));
    n=10 ;
    System.out.print(n+"th Centered "+"Dodecahedral number : ");
    System.out.println(CenteredDodecahedral_num(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation CenteredDodecahedral_num( n : int) : int
  pre: true
  post: true
  activity: (     return (2 * n + 1) * (5 * n * n + 5 * n + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].print(n + "th Centered " + "Dodecahedral number : ") ; 
    OclFile["System.out"].println(CenteredDodecahedral_num(n)) ; 
    n := 10 ; 
    OclFile["System.out"].print(n + "th Centered " + "Dodecahedral number : ") ; 
    OclFile["System.out"].println(CenteredDodecahedral_num(n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] a=new long[n];
    long b=0 ;
    long b2=0 ;
    long sum=0 ;
    long sum2=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong()-(i+1);
    }
    Arrays.sort(a);
    if(n % 2==0){
      b=(a[n/2]+a[n/2-1])/2 ;
      b2=b+1 ;
      for(int i=0 ; i<n ; i++){
        sum+=Math.abs(a[i]-b);
        sum2+=Math.abs(a[i]-b2);
      }
      sum=Math.min(sum,sum2);
    }
    else {
      b=a[(n+1)/2-1];
      for(int i=0 ; i<n ; i++){
        sum+=Math.abs(a[i]-b);
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : long ; b := 0 ;
    var b2 : long ; b2 := 0 ;
    var sum : long ; sum := 0 ;
    var sum2 : long ; sum2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() - (i + 1) )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    if (n mod 2 = 0) then (     b := (a[n / 2+1] + a[n / 2 - 1+1]) / 2 ; 
     b2 := b + 1 ; 
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(if a[i+1] - b < 0 then -(a[i+1] - b) else a[i+1] - b endif) ; 
     sum2 := sum2+(if a[i+1] - b2 < 0 then -(a[i+1] - b2) else a[i+1] - b2 endif) )  ;     i := i + 1 ) ; 
     sum := Set{sum, sum2}->min() ) else (     b := a[(n + 1) / 2 - 1+1] ; 
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(if a[i+1] - b < 0 then -(a[i+1] - b) else a[i+1] - b endif) )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Reader r=new Reader();
    int N=r.i();
    long[] A=r.ll();
    for(int i=0 ; i<N ; i++)A[i]-=i+1 ;
    Arrays.sort(A);
    long ans=0 ;
    long median=A[N/2];
    for(int i=0 ; i<N ; i++)ans+=Math.abs(median-A[i]);
    print(ans);
  }
  static void print(Object o){
    System.out.println(o.toString());
  }
  static class Reader extends BufferedReader {
    Reader(){
      super(new InputStreamReader(System.in));
    }
    String s()throws IOException {
      return readLine();
    }
    String[] ss()throws IOException {
      return s().split(" ");
    }
    int Int(String s){
      return Integer.parseInt(s);
    }
    int i()throws IOException {
      return Int(s());
    }
    int[] ii()throws IOException {
      String[] ss=ss();
      int size=ss.length ;
      int[] ii=new int[size];
      for(int j=0 ; j<size ; j++)ii[j]=Int(ss[j]);
      return ii ;
    }
    long Long(String s){
      return Long.parseLong(s);
    }
    long l()throws IOException {
      return Long(s());
    }
    long[] ll()throws IOException {
      String[] ss=ss();
      int size=ss.length ;
      long[] ll=new long[size];
      for(int j=0 ; j<size ; j++)ll[j]=Long(ss[j]);
      return ll ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile() ;
     var N : int ; N := r.i() ;
    var A : Sequence(long) ; A := r.ll() ;
        var i : int ; i := 0 ; while i < N do (     A[i+1] := A[i+1]-(i + 1) ;  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    var ans : long ; ans := 0 ;
    var median : long ; median := A[N / 2+1] ;
        var i : int ; i := 0 ; while i < N do (     ans := ans+(if median - A[i+1] < 0 then -(median - A[i+1]) else median - A[i+1] endif) ;  ;     i := i + 1 ) ; 
    execute print(ans) ; 
 );
  static   operation print( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o+"") );
  static class Reader extends OclFile {
   static operation newReader() : Reader
  pre: true
  post: true
  activity:
  ( var self : Reader ;
    self := createReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation s() : String
  pre: true
  post: true
  activity: (     return readLine() );
   operation ss() : Sequence(String)
  pre: true
  post: true
  activity: (     return s()->split(" ") );
   operation Int( s : String) : int
  pre: true
  post: true
  activity: (     return (s)->toInteger() );
   operation i() : int
  pre: true
  post: true
  activity: (     return Int(s()) );
   operation ii() : Sequence(int)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var size : int ; size := ss->size() ;
    var ii : Sequence(int) ; ii := Integer.subrange(1,size)->collect(0) ;
        var j : int ; j := 0 ; while j < size do (     ii[j+1] := Int(ss[j+1]) ;  ;     j := j + 1 ) ; 
    return ii 
 );
   operation Long( s : String) : long
  pre: true
  post: true
  activity: (     return (s)->toLong() );
   operation l() : long
  pre: true
  post: true
  activity: (     return Long(s()) );
   operation ll() : Sequence(long)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var size : int ; size := ss->size() ;
    var ll : Sequence(long) ; ll := Integer.subrange(1,size)->collect(0) ;
        var j : int ; j := 0 ; while j < size do (     ll[j+1] := Long(ss[j+1]) ;  ;     j := j + 1 ) ; 
    return ll 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Scanner ;
public final class Main {
  public static void main(String[] args){
    final Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    final int n=Integer.parseInt(in.nextLine());
    final int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
      arr[i]-=i+1 ;
    }
    in.nextLine();
    Arrays.sort(arr);
    System.out.println(f(arr,arr[n/2]));
  }
  private static long f(int[] arr,int median){
    long res=0 ;
    for(int value : arr){
      res+=Math.abs(value-median);
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var n : int ; n := (in.nextLine())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() ; 
     arr[i+1] := arr[i+1]-(i + 1) )  ;     i := i + 1 ) ; 
    skip ; 
    arr := arr->sort() ; 
    OclFile["System.out"].println(f(arr, arr[n / 2+1])) ; 
 );
  static   operation f( arr : Sequence(int), median : int) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 0 ;
     for (value : arr) do ( (     res := res+(if value - median < 0 then -(value - median) else value - median endif) )  ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.Collectors ;
import java.io.*;
import java.nio.charset.StandardCharsets ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader reader=new InputStreamReader(System.in,StandardCharsets.UTF_8);
    BufferedReader in=new BufferedReader(reader);
    Main ins=new Main(in);
    ins.calc();
    ins.showResult();
  }
  int N ;
  long[] A ;
  Main(BufferedReader in)throws IOException {
    N=Integer.parseInt(in.readLine());
    A=new long[N];
    String[] tokens=in.readLine().split(" ");
    for(int i=0 ; i<N ; ++i){
      A[i]=Long.parseLong(tokens[i])-(long)(i+1);
    }
    Arrays.sort(A);
    long med=getMedium();
    long result=Long.MAX_VALUE/2 ;
    for(long b=med-5 ; b<=med+5 ; ++b){
      result=Math.min(result,sub(b));
    }
    System.out.println(result);
  }
  long getMedium(){
    if(A.length==1){
      return A[0];
    }
    else if(A.length % 2==1){
      return A[A.length/2];
    }
    else {
      return(A[A.length/2-1]+A[A.length/2])/2 ;
    }
  }
  long sub(long b){
    long result=0 ;
    for(int i=0 ; i<N ; ++i){
      result+=Math.abs(A[i]-b);
    }
    return result ;
  }
  void calc(){
  }
  void showResult(){
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"], StandardCharsets.UTF_8) ;
     var in : OclFile ; in := OclFile.newOclFile_Read(reader) ;
    var ins : Main ; ins := Main.newMain(in) ;
    ins.calc() ; 
    ins.showResult() ; 
 );
   attribute N : int;
   attribute A : Sequence(long);
   static operation newMain( in : OclFile) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     N := (in.readLine())->toInteger() ; 
     A := Integer.subrange(1,N)->collect(0) ; 
    var tokens : Sequence(String) ; tokens := in.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := (tokens[i+1])->toLong() - (i + 1)->oclAsType(long) )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    var med : long ; med := getMedium() ;
    var result : long ; result := "9223372036854775807"->toLong() / 2 ;
        var b : long ; b := med - 5 ; while b <= med + 5 do ( (     result := Set{result, sub(b)}->min() )  ;     b := b + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
   operation getMedium() : long
  pre: true
  post: true
  activity: (     if (A->size() = 1) then (     return A[0+1] ) else     if (A->size() mod 2 = 1) then (     return A[A->size() / 2+1] ) else (     return (A[A->size() / 2 - 1+1] + A[A->size() / 2+1]) / 2 ) ;  );
   operation sub( b : long) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     result := result+(if A[i+1] - b < 0 then -(A[i+1] - b) else A[i+1] - b endif) )  ;     i := i + 1 ) ; 
     return result );
   operation calc() : void
  pre: true
  post: true
  activity: skip;
   operation showResult() : void
  pre: true
  post: true
  activity: skip;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int N=in.nextInt();
      int[] A=new int[N];
      for(int i=0 ; i<A.length ; ++i){
        A[i]=in.nextInt()-(i+1);
      }
      Arrays.sort(A);
      int mid=A[A.length/2];
      if(A.length % 2==0){
        mid=(mid+A[A.length/2-1])/2 ;
      }
      long minSadVal=0 ;
      for(int i=0 ; i<A.length ; ++i){
        minSadVal+=Math.abs(A[i]-mid);
      }
      System.out.println(minSadVal);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var N : int ; N := in.getCurrent()->toInteger() ;
     var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < A->size() do ( (     A[i+1] := in.getCurrent()->toInteger() - (i + 1) )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    var mid : int ; mid := A[A->size() / 2+1] ;
    if (A->size() mod 2 = 0) then (     mid := (mid + A[A->size() / 2 - 1+1]) / 2 ) else skip ; 
    var minSadVal : long ; minSadVal := 0 ;
        var i : int ; i := 0 ; while i < A->size() do ( (     minSadVal := minSadVal+(if A[i+1] - mid < 0 then -(A[i+1] - mid) else A[i+1] - mid endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(minSadVal) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int MOD=1000000007 ;
    int n=sc.nextInt();
    int k=sc.nextInt();
    for(int i=1 ; i<=k ; i++){
      if(n-k+1<i){
        System.out.println(0);
        continue ;
      }
      System.out.println(nCkMOD(n-k+1,i,MOD)*nCkMOD(k-1,i-1,MOD)% MOD);
    }
  }
  public static long nCkMOD(long n,long k,long mod){
    if(k>n-k)return nCkMOD(n,n-k,mod);
    long res=1 ;
    for(int i=0 ; i<k ; i++){
      res=(res*(n-i))% mod ;
    }
    for(int i=1 ; i<=k ; i++){
      res=(res*inverse(i,mod))% mod ;
    }
    return res % mod ;
  }
  private static long inverse(long a,long mod){
    return modpow(a,mod-2,mod);
  }
  private static long modpow(long a,long n,long mod){
    long res=1 ;
    while(n>0){
      if(n % 2==1)res=(res*a)% mod ;
      a=(a*a)% mod ;
      n>>=1 ;
    }
    return res % mod ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var MOD : int ; MOD := 1000000007 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= k do ( (     if (n - k + 1 < i) then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
     OclFile["System.out"].println(nCkMOD(n - k + 1, i, MOD) * nCkMOD(k - 1, i - 1, MOD) mod MOD) )  ;     i := i + 1 ) ; 
 );
  static   operation nCkMOD( n : long, k : long, mod : long) : long
  pre: true
  post: true
  activity: (     if (k > n - k) then     return nCkMOD(n, n - k, mod) else skip ; 
     var res : long ; res := 1 ;
        var i : int ; i := 0 ; while i < k do ( (     res := (res * (n - i)) mod mod )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= k do ( (     res := (res * inverse(i, mod)) mod mod )  ;     i := i + 1 ) ; 
    return res mod mod 
 );
  static   operation inverse( a : long, mod : long) : long
  pre: true
  post: true
  activity: (     return modpow(a, mod - 2, mod) );
  static   operation modpow( a : long, n : long, mod : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     while (n > 0) do (     if (n mod 2 = 1) then     res := (res * a) mod mod ; else skip ; 
     a := (a * a) mod mod ; 
     n := n/(2->pow(1)) ) ; 
     return res mod mod );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws Exception {
    Scanner sch=new Scanner(System.in);
    int q=sch.nextInt();
    int[] B=countingpaixu(q,sch);
    StringBuilder af=new StringBuilder("");
    af.append(B[0]);
    for(int i=1 ; i<B.length ; ++i){
      af.append(" ").append(B[i]);
    }
    System.out.println(af);
  }
  public static int[] countingpaixu(int n,Scanner aj){
    int k=0 ;
    int[] A=new int[n];
    for(int i=0 ; i<n ; i++){
      A[i]=aj.nextInt();
      if(A[i]>k){
        k=A[i];
      }
    }
    int[] P=new int[A.length];
    int i ;
    int[] C=new int[k+1];
    for(i=0 ; i<A.length ; i++){
      C[A[i] ]++;
    }
    for(i=1 ; i<=k ; ++i){
      C[i]+=C[i-1];
    }
    for(i=A.length-1 ; i>=0 ; i--){
      P[C[A[i] ]-1]=A[i];
      C[A[i] ]--;
    }
    return P ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sch : OclFile ; sch := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sch.getCurrent()->toInteger() ;
    var B : Sequence(int) ; B := countingpaixu(q, sch) ;
    var af : String ; af := StringLib.newString("") ;
    af := af + StringLib.newString(B[0+1]) ; 
        var i : int ; i := 1 ; while i < B->size() do ( (     af := af + StringLib.newString(" ") + StringLib.newString(B[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(af) ; 
 );
  static   operation countingpaixu( n : int, aj : OclFile) : Sequence(int)
  pre: true
  post: true
  activity: (     var k : int ; k := 0 ;
     var A : Sequence(int) ; A := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := aj.nextInt() ; 
     if (A[i+1] > k) then (     k := A[i+1] ) else skip )  ;     i := i + 1 ) ; 
    var P : Sequence(int) ; P := Integer.subrange(1,A->size())->collect(0) ;
    var i : int ;
    var C : Sequence(int) ; C := Integer.subrange(1,k + 1)->collect(0) ;
        i := 0 ; while i < A->size() do ( (     C[A[i+1]+1] := C[A[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
        i := 1 ; while i <= k do ( (     C[i+1] := C[i+1]+(C[(i)->char2byte() - 1+1]) )  ;     i := i + 1 ) ; 
        i := A->size() - 1 ; while i >= 0 do ( (     P[C[A[i+1]+1] - 1+1] := A[i+1] ; 
     C[A[i+1]+1] := C[A[i+1]+1] - 1 )  ;     i := i - 1 ) ; 
    return P 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static int[][] lenearsum(int numval,int sum){
    int sep=(int)Math.pow(10,9)+7 ;
    int[][] dp=new int[numval+1][sum+1];
    for(int i=0 ; i<sum+1 ; i++){
      dp[1][i]=1 ;
    }
    for(int i=2 ; i<numval+1 ; i++){
      for(int n=0 ; n<sum+1 ; n++){
        if(n==0)dp[i][n]=1 ;
        else dp[i][n]=((dp[i][n-1])% sep+(dp[i-1][n])% sep)% sep ;
      }
    }
    return dp ;
  }
  public static void calci(int K,int N,int i,int[][] dp){
    int sep=(int)Math.pow(10,9)+7 ;
    if(N-K-(i-1)<0){
      System.out.println(0);
      return ;
    }
    long ret=1 ;
    ret*=dp[i][K-i];
    ret %=sep ;
    ret*=dp[i+1][N-K-(i-1)];
    ret %=sep ;
    System.out.println(ret);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[][] dp=lenearsum(k+1,n+1);
    for(int i=1 ; i<=k ; i++){
      calci(k,n,i,dp);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation lenearsum( numval : int, sum : int) : Sequence(Sequence(int))
  pre: true
  post: true
  activity: (     var sep : int ; sep := 10->pow(9)->oclAsType(int) + 7 ;
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,numval + 1)->collect(Integer.subrange(1,sum + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < sum + 1 do ( (     dp[1+1][i+1] := 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i < numval + 1 do ( (         var n : int ; n := 0 ; while n < sum + 1 do ( (     if (n = 0) then     dp[i+1][n+1] := 1 ; else     dp[i+1][n+1] := ((dp[i+1][n - 1+1]) mod sep + (dp[i - 1+1][n+1]) mod sep) mod sep ; )  ;     n := n + 1 ) )  ;     i := i + 1 ) ; 
    return dp 
 );
  static   operation calci( K : int, N : int, i : int, dp : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var sep : int ; sep := 10->pow(9)->oclAsType(int) + 7 ;
     if (N - K - (i - 1) < 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var ret : long ; ret := 1 ;
    ret := ret*(dp[i+1][K - i+1]) ; 
    ret := ret mod sep ; 
    ret := ret*(dp[i + 1+1][N - K - (i - 1)+1]) ; 
    ret := ret mod sep ; 
    OclFile["System.out"].println(ret) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var dp : Sequence(Sequence(int)) ; dp := lenearsum(k + 1, n + 1) ;
        var i : int ; i := 1 ; while i <= k do ( (     execute calci(k, n, i, dp) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public void solve()throws IOException {
    int[][] result=new int[4][2];
    while(stdIn.hasNext()){
      double[] eye=new double[2];
      for(int i=0 ; i<2 ; i++){
        eye[i]=stdIn.nextDouble();
        if(eye[i]>=1.1){
          result[0][i]++;
        }
        else if(eye[i]>=0.6){
          result[1][i]++;
        }
        else if(eye[i]>=0.2){
          result[2][i]++;
        }
        else {
          result[3][i]++;
        }
      }
    }
    for(int[] x : result){
      writer.println(x[0]+" "+x[1]);
    }
    writer.flush();
  }
  public static void main(String args[])throws IOException {
    new Main().run();
  }
  Scanner stdIn ;
  PrintWriter writer ;
  public void run()throws IOException {
    stdIn=null ;
    try {
      stdIn=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
      writer=new PrintWriter(System.out);
      solve();
      stdIn.close();
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var result : Sequence(Sequence(int)) ; result := Integer.subrange(1,4)->collect(Integer.subrange(1,2)->collect(0)) ;
     while (stdIn.hasNext()) do (     var eye : Sequence(double) ; eye := Integer.subrange(1,2)->collect(0.0) ;
         var i : int ; i := 0 ; while i < 2 do ( (     eye[i+1] := stdIn.nextDouble() ; 
     if (eye[i+1] >= 1.1) then (     result[0+1][i+1] := result[0+1][i+1] + 1 ) else     if (eye[i+1] >= 0.6) then (     result[1+1][i+1] := result[1+1][i+1] + 1 ) else     if (eye[i+1] >= 0.2) then (     result[2+1][i+1] := result[2+1][i+1] + 1 ) else (     result[3+1][i+1] := result[3+1][i+1] + 1 ) ;  ;  )  ;     i := i + 1 ) ) ; 
     for (x : result) do ( (     writer.println(x[0+1] + " " + x[1+1]) )  ) ; 
     writer.flush() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute stdIn : OclFile;
   attribute writer : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     stdIn := null ; 
     try (     stdIn := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
     writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static int mod=1_000_000_007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    int K=Integer.parseInt(sc.next());
    int cnt=N-K+1 ;
    for(int i=1 ; i<=K ; i++){
      if(cnt>0){
        System.out.println(nCr(N-K+1,i)*nCr(K-1,i-1)% mod);
      }
      else {
        System.out.println(0);
      }
      cnt--;
    }
  }
  public static long factorial(int n){
    long tmp=1 ;
    for(int i=n ; i>0 ; i--){
      tmp=(tmp*i)% mod ;
    }
    return tmp ;
  }
  public static long pow(long a,int n){
    long res=1 ;
    while(n>0){
      if((n-n/2*2)==1){
        res=(res*a)% mod ;
      }
      a=(a*a)% mod ;
      n>>=1 ;
    }
    return res ;
  }
  public static long modinv(long n){
    return pow(n,mod-2);
  }
  public static long nCr(int n,int r){
    return factorial(n)*modinv(factorial(n-r))% mod*modinv(factorial(r))% mod ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var K : int ; K := (sc.getCurrent())->toInteger() ;
    var cnt : int ; cnt := N - K + 1 ;
        var i : int ; i := 1 ; while i <= K do ( (     if (cnt > 0) then (     OclFile["System.out"].println(nCr(N - K + 1, i) * nCr(K - 1, i - 1) mod mod) ) else (     OclFile["System.out"].println(0) ) ;  
     cnt := cnt - 1 )  ;     i := i + 1 ) ; 
 );
  static   operation factorial( n : int) : long
  pre: true
  post: true
  activity: (     var tmp : long ; tmp := 1 ;
         var i : int ; i := n ; while i > 0 do ( (     tmp := (tmp * i) mod mod )  ;     i := i - 1 ) ; 
     return tmp );
  static   operation pow( a : long, n : int) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     while (n > 0) do (     if ((n - n / 2 * 2) = 1) then (     res := (res * a) mod mod ) else skip ; 
     a := (a * a) mod mod ; 
     n := n/(2->pow(1)) ) ; 
     return res );
  static   operation modinv( n : long) : long
  pre: true
  post: true
  activity: (     return pow(n, mod - 2) );
  static   operation nCr( n : int, r : int) : long
  pre: true
  post: true
  activity: (     return factorial(n) * modinv(factorial(n - r)) mod mod * modinv(factorial(r)) mod mod );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static long minPerimeter(int n){
    int l=(int)Math.sqrt(n);
    int sq=l*l ;
    if(sq==n)return l*4 ;
    else {
      long row=n/l ;
      long perimeter=2*(l+row);
      if(n % l!=0)perimeter+=2 ;
      return perimeter ;
    }
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(minPerimeter(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minPerimeter( n : int) : long
  pre: true
  post: true
  activity: (     var l : int ; l := (n)->sqrt()->oclAsType(int) ;
     var sq : int ; sq := l * l ;
     if (sq = n) then     return l * 4 else (     var row : long ; row := n / l ;
     var perimeter : long ; perimeter := 2 * (l + row) ;
     if (n mod l /= 0) then     perimeter := perimeter+(2) ; else skip ; 
     return perimeter ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(minPerimeter(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Iterator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList list=new ArrayList();
    while(--n>-1){
      list.add(sc.nextInt());
    }
    int t=sc.nextInt();
    Integer[] arrs=(Integer[])list.toArray(new Integer[list.size()]);
    Arrays.sort(arrs);
    int count=0 ;
    int max=0 ;
    for(int i=0 ; i<list.size(); i++){
      count=0 ;
      for(int j=i ; j<list.size(); j++){
        if(arrs[j]-arrs[i]<(t+1)){
          count++;
        }
        if(count>max){
          max=count ;
        }
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var list : Sequence ; list := Sequence{} ;
        n := n - 1 ;
    while ((n - 1) > -1) do (        n := n - 1 ;  ; (     list := list->including(sc.getCurrent()->toInteger()) ) ;     n := n - 1 ;
 ) ;  
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var arrs : Sequence(int) ; arrs := list->asSequence()->oclAsType(Sequence(int)) ;
    arrs := arrs->sort() ; 
    var count : int ; count := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < list->size() do ( (     count := 0 ; 
         var j : int ; j := i ; while j < list->size() do ( (     if (arrs[j+1] - arrs[i+1] < (t + 1)) then (     count := count + 1 ) else skip ; 
     if (count > max) then (     max := count ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Iterator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList list=new ArrayList();
    while(--n>-1){
      list.add(sc.nextInt());
    }
    int t=sc.nextInt();
    Integer[] arrs=(Integer[])list.toArray(new Integer[list.size()]);
    Arrays.sort(arrs);
    int count=0 ;
    int max=0 ;
    for(int i=0 ; i<list.size(); i++){
      count=0 ;
      for(int j=i ; j<list.size(); j++){
        if(arrs[j]-arrs[i]<(t+1)){
          count++;
        }
        if(count>max){
          max=count ;
        }
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var list : Sequence ; list := Sequence{} ;
        n := n - 1 ;
    while ((n - 1) > -1) do (        n := n - 1 ;  ; (     list := list->including(sc.getCurrent()->toInteger()) ) ;     n := n - 1 ;
 ) ;  
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var arrs : Sequence(int) ; arrs := list->asSequence()->oclAsType(Sequence(int)) ;
    arrs := arrs->sort() ; 
    var count : int ; count := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < list->size() do ( (     count := 0 ; 
         var j : int ; j := i ; while j < list->size() do ( (     if (arrs[j+1] - arrs[i+1] < (t + 1)) then (     count := count + 1 ) else skip ; 
     if (count > max) then (     max := count ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    int t=sc.nextInt();
    Arrays.sort(arr);
    int result=0 ;
    for(int i=0,j=0,num=0 ; i<arr.length ; i++){
      if(arr[i]<=arr[j]+t){
        num++;
        result=Math.max(result,num);
      }
      else {
        num=0 ;
        j++;
        i=j-1 ;
      }
    }
    System.out.print(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var t : int ; t := sc.getCurrent()->toInteger() ;
    arr := arr->sort() ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    var num : int ; num := 0 ; while i < arr->size() do ( (     if (arr[i+1] <= arr[j+1] + t) then (     num := num + 1 ; 
     result := Set{result, num}->max() ) else (     num := 0 ; 
     j := j + 1 ; 
     i := j - 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.Collectors ;
public class Problem2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] ar=new int[n];
    for(int i=0 ; i<n ; i++)ar[i]=sc.nextInt();
    int T=sc.nextInt();
    Arrays.sort(ar);
    int i=0,j=i,max=0 ;
    while(i<n){
      while(j<n &&(ar[j]-ar[i])<=T)j++;
      max=Math.max(max,j-i);
      i++;
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     ar[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var T : int ; T := sc.getCurrent()->toInteger() ;
    ar := ar->sort() ; 
    var i : int ; i := 0 ;
    var j : int ; j := i ;
    var max : int ; max := 0 ;
    while (i < n) do (     while (j < n & (ar[j+1] - ar[i+1]) <= T) do     j := j + 1 ; ; 
     max := Set{max, j - i}->max() ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
    }
    int t=in.nextInt();
    Arrays.sort(arr);
    int max=-1 ;
    for(int i=0 ; i<n ; i++){
      int ans=1 ;
      for(int j=i+1 ; j<n ; j++){
        if(arr[j]-arr[i]<=t){
          ans++;
        }
        else {
          break ;
        }
      }
      max=Math.max(ans,max);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var t : int ; t := in.getCurrent()->toInteger() ;
    arr := arr->sort() ; 
    var max : int ; max := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var ans : int ; ans := 1 ;
         var j : int ; j := i + 1 ; while j < n do ( (     if (arr[j+1] - arr[i+1] <= t) then (     ans := ans + 1 ) else (     break ) )  ;     j := j + 1 ) ; 
     max := Set{ans, max}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int[] pref=new int[100001];
  static int checkArmstrong(int x){
    int n=String.valueOf(x).length();
    int sum1=0 ;
    int temp=x ;
    while(temp>0){
      int digit=temp % 10 ;
      sum1+=Math.pow(digit,n);
      temp/=10 ;
    }
    if(sum1==x)return x ;
    return 0 ;
  }
  static void preCompute(){
    for(int i=1 ; i<100001 ; i++){
      pref[i]=pref[i-1]+checkArmstrong(i);
    }
  }
  static void printSum(int L,int R){
    System.out.println(pref[R]-pref[L-1]);
  }
  static void printSumarmstrong(int[][] arr,int Q){
    preCompute();
    for(int i=0 ; i<Q ; i++){
      printSum(arr[i][0],arr[i][1]);
    }
  }
  public static void main(String[] args){
    int Q=2 ;
    int[][] arr={
      {
        1,13 },{
          121,211 }
        };
        printSumarmstrong(arr,Q);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute pref : Sequence(int) := Integer.subrange(1,100001)->collect(0);
  static   operation checkArmstrong( x : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := ((x) + "")->size() ;
     var sum1 : int ; sum1 := 0 ;
    var temp : int ; temp := x ;
    while (temp > 0) do (     var digit : int ; digit := temp mod 10 ;
     sum1 := sum1+(digit->pow(n)) ; 
     temp := temp/(10) ) ; 
    if (sum1 = x) then     return x else skip ; 
    return 0 
 );
  static   operation preCompute() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < 100001 do ( (     pref[i+1] := pref[i - 1+1] + checkArmstrong(i) )  ;     i := i + 1 ) );
  static   operation printSum( L : int, R : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(pref[R+1] - pref[L - 1+1]) );
  static   operation printSumarmstrong( arr : Sequence(Sequence(int)), Q : int) : void
  pre: true
  post: true
  activity: (     execute preCompute() ; 
         var i : int ; i := 0 ; while i < Q do ( (     execute printSum(arr[i+1][0+1], arr[i+1][1+1]) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Q : int ; Q := 2 ;
     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,13},Sequence{121,211}} ;
     execute printSumarmstrong(arr, Q) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  double nd(){
    return sc.nextDouble();
  }
  void io(){
    sc=new Scanner(System.in);
    int[][] num=new int[4][2];
    for(int[] e : num)Arrays.fill(e,0);
    int side=0 ;
    while(sc.hasNext()){
      double eye=nd();
      if(eye>=1.1)++num[0][side];
      else if(eye>=0.6)++num[1][side];
      else if(eye>=0.2)++num[2][side];
      else++num[3][side];
      side ^=1 ;
    }
    for(int i=0 ; i<4 ; ++i)System.out.println(num[i][0]+" "+num[i][1]);
    sc.close();
  }
  public static void main(String[] args){
    new Main().io();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   operation nd() : double
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toReal() );
   operation io() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var num : Sequence(Sequence(int)) ; num := Integer.subrange(1,4)->collect(Integer.subrange(1,2)->collect(0)) ;
    for (e : num) do (     e := e->collect(0) ;  ) ; 
    var side : int ; side := 0 ;
    while (sc.hasNext()) do (     var eye : double ; eye := nd() ;
     if (eye >= 1.1) then     num[0+1][side+1] := num[0+1][side+1] + 1 else     if (eye >= 0.6) then     num[1+1][side+1] := num[1+1][side+1] + 1 else     if (eye >= 0.2) then     num[2+1][side+1] := num[2+1][side+1] + 1 else     num[3+1][side+1] := num[3+1][side+1] + 1 ; ;  ;  ;  
     side := MathLib.bitwiseXor(side,1) ) ; 
        var i : int ; i := 0 ; while i < 4 do (     OclFile["System.out"].println(num[i+1][0+1] + " " + num[i+1][1+1]) ;  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().io() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int[] ingredient=new int[22];
  static int[] b=new int[22];
  static double min=10000000 ;
  static double res=0 ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int v=scanner.nextInt();
    for(int i=0 ; i<n ; i++){
      ingredient[i]=scanner.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      b[i]=scanner.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      min=Math.min(min,b[i]*1.0/ingredient[i]);
    }
    for(int i=0 ; i<n ; i++){
      res+=min*ingredient[i];
    }
    System.out.println(Math.min(res,v));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ingredient : Sequence(int) := Integer.subrange(1,22)->collect(0);
  static   attribute b : Sequence(int) := Integer.subrange(1,22)->collect(0);
  static   attribute min : double := 10000000;
  static   attribute res : double := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var v : int ; v := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     ingredient[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     min := Set{min, b[i+1] * 1.0 / ingredient[i+1]}->min() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     res := res+(min * ingredient[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{res, v}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    double v=sc.nextDouble(),k=0,m1=Double.MAX_VALUE ;
    double[] ing=new double[n];
    double[] vol=new double[n];
    for(int i=0 ; i<n ; i++){
      ing[i]=sc.nextDouble();
      k+=ing[i];
    }
    for(int i=0 ; i<n ; i++)vol[i]=sc.nextDouble();
    for(int i=0 ; i<n ; i++)m1=Math.min(vol[i]/ing[i],m1);
    System.out.println(Math.min(v,k*m1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var v : double ; v := sc.getCurrent()->toReal() ;
    var k : double ; k := 0 ;
    var m1 : double ; m1 := (2 - 2->pow(-52))*(2->pow(1023)) ;
    var ing : Sequence(double) ; ing := Integer.subrange(1,n)->collect(0.0) ;
    var vol : Sequence(double) ; vol := Integer.subrange(1,n)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do ( (     ing[i+1] := sc.getCurrent()->toReal() ; 
     k := k+(ing[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     vol[i+1] := sc.getCurrent()->toReal() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     m1 := Set{vol[i+1] / ing[i+1], m1}->min() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{v, k * m1}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Locale ;
import java.util.Scanner ;
public class A42 {
  public static void main(String[] args){
    Locale.setDefault(Locale.US);
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int V=in.nextInt();
    double[] A=new double[N];
    double sum=0 ;
    for(int n=0 ; n<N ; n++){
      int a=in.nextInt();
      A[n]=a ;
      sum+=a ;
    }
    double max=V/sum ;
    for(int n=0 ; n<N ; n++){
      int b=in.nextInt();
      max=Math.min(max,b/A[n]);
    }
    System.out.println(max*sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A42 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.US) ; 
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var V : int ; V := in.getCurrent()->toInteger() ;
    var A : Sequence(double) ; A := Integer.subrange(1,N)->collect(0.0) ;
    var sum : double ; sum := 0 ;
        var n : int ; n := 0 ; while n < N do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     A[n+1] := a ; 
     sum := sum+(a) )  ;     n := n + 1 ) ; 
    var max : double ; max := V / sum ;
        var n : int ; n := 0 ; while n < N do ( (     var b : int ; b := in.getCurrent()->toInteger() ;
     max := Set{max, b / A[n+1]}->min() )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(max * sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean checkPrime(String number){
    if(number.length()==0)return true ;
    int num=Integer.parseInt(number);
    for(int i=2 ; i*i<=num ; i++)if((num % i)==0)return false ;
    return true ;
  }
  static int splitIntoPrimes(String number){
    int numLen=number.length();
    int[] splitDP=new int[numLen+1];
    Arrays.fill(splitDP,-1);
    for(int i=1 ; i<=numLen ; i++){
      if(i<=6 && checkPrime(number.substring(0,i)))splitDP[i]=1 ;
      if(splitDP[i]!=-1){
        for(int j=1 ; j<=6 && i+j<=numLen ; j++){
          if(checkPrime(number.substring(i,i+j))){
            if(splitDP[i+j]==-1)splitDP[i+j]=1+splitDP[i];
            else splitDP[i+j]=Math.min(splitDP[i+j],1+splitDP[i]);
          }
        }
      }
    }
    return splitDP[numLen];
  }
  public static void main(String[] args){
    System.out.print(splitIntoPrimes("13499315")+"\n");
    System.out.print(splitIntoPrimes("43")+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkPrime( number : String) : boolean
  pre: true
  post: true
  activity: (     if (number->size() = 0) then     return true else skip ; 
     var num : int ; num := (number)->toInteger() ;
         var i : int ; i := 2 ; while i * i <= num do (     if ((num mod i) = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation splitIntoPrimes( number : String) : int
  pre: true
  post: true
  activity: (     var numLen : int ; numLen := number->size() ;
     var splitDP : Sequence(int) ; splitDP := Integer.subrange(1,numLen + 1)->collect(0) ;
    splitDP := splitDP->collect(-1) ; 
        var i : int ; i := 1 ; while i <= numLen do ( (     if (i <= 6 & checkPrime(number.subrange(0+1,i))) then     splitDP[i+1] := 1 ; else skip ; 
     if (splitDP[i+1] /= -1) then (         var j : int ; j := 1 ; while j <= 6 & i + j <= numLen do ( (     if (checkPrime(number.subrange(i+1,i + j))) then (     if (splitDP[i + j+1] = -1) then     splitDP[i + j+1] := 1 + splitDP[i+1] ; else     splitDP[i + j+1] := Set{splitDP[i + j+1], 1 + splitDP[i+1]}->min() ; ) else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    return splitDP[numLen+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(splitIntoPrimes("13499315") + "\n") ; 
     OclFile["System.out"].print(splitIntoPrimes("43") + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static int squareFree(int n){
    int cnt=0 ;
    for(int i=1 ; ; i++){
      boolean isSqFree=true ;
      for(int j=2 ; j*j<=i ; j++){
        if(i %(j*j)==0){
          isSqFree=false ;
          break ;
        }
      }
      if(isSqFree==true){
        cnt++;
        if(cnt==n)return i ;
      }
    }
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(""+squareFree(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation squareFree( n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 1 ; while true do ( (     var isSqFree : boolean ; isSqFree := true ;
         var j : int ; j := 2 ; while j * j <= i do ( (     if (i mod (j * j) = 0) then (     isSqFree := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (isSqFree = true) then (     cnt := cnt + 1 ; 
     if (cnt = n) then     return i else skip ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println("" + squareFree(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static boolean validate(long n){
    for(int i=0 ; i<10 ; i++){
      long temp=n ;
      int count=0 ;
      while(temp>0){
        if(temp % 10==i)count++;
        if(count>i)return false ;
        temp/=10 ;
      }
    }
    return true ;
  }
  static public void main(String[] args){
    long n=1552793 ;
    if(validate(n))System.out.println("True");
    else System.out.println("False");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation validate( n : long) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 10 do ( (     var temp : long ; temp := n ;
     var count : int ; count := 0 ;
     while (temp > 0) do (     if (temp mod 10 = i) then     count := count + 1 ; else skip ; 
     if (count > i) then     return false else skip ; 
     temp := temp/(10) ) )  ;     i := i + 1 ) ; 
     return true );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 1552793 ;
     if (validate(n)) then     OclFile["System.out"].println("True") ; else     OclFile["System.out"].println("False") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class GFG {
  static boolean sackRace(int p1,int s1,int p2,int s2){
    return((s1>s2 &&(p2-p1)%(s1-s2)==0)||(s2>s1 &&(p1-p2)%(s2-s1)==0));
  }
  public static void main(String args[]){
    int p1=4,s1=4,p2=8,s2=2 ;
    if(sackRace(p1,s1,p2,s2))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sackRace( p1 : int, s1 : int, p2 : int, s2 : int) : boolean
  pre: true
  post: true
  activity: (     return ((s1 > s2 & (p2 - p1) mod (s1 - s2) = 0) or (s2 > s1 & (p1 - p2) mod (s2 - s1) = 0)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p1 : int ; p1 := 4 ;
    var s1 : int ; s1 := 4 ;
    var p2 : int ; p2 := 8 ;
    var s2 : int ; s2 := 2 ;
     if (sackRace(p1, s1, p2, s2)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public static void main(String[] args){
    int x=new java.util.Scanner(System.in).nextInt();
    if(x==0){
      System.out.println("1");
    }
    else {
      System.out.println("0");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := Scanner.newScanner(OclFile["System.in"]).nextInt() ;
     if (x = 0) then (     OclFile["System.out"].println("1") ) else (     OclFile["System.out"].println("0") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int q=sc.nextInt();
    PriorityQueue<Event>queue=new PriorityQueue<>();
    for(int i=0 ; i<n ; i++){
      queue.add(new Event(sc.nextInt(),sc.nextInt(),sc.nextInt()));
    }
    TreeMap<Integer,Integer>map=new TreeMap<>();
    for(int i=0 ; i<q ; i++){
      map.put(sc.nextInt(),i);
    }
    int[] ans=new int[q];
    Arrays.fill(ans,-1);
    while(queue.size()>0){
      Event e=queue.poll();
      Map.Entry<Integer,Integer>x=map.ceilingEntry(e.start-e.point);
      while(x!=null && x.getKey()<e.end-e.point){
        ans[x.getValue()]=e.point ;
        map.remove(x.getKey());
        x=map.ceilingEntry(e.start-e.point);
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int x : ans){
      sb.append(x).append("\n");
    }
    System.out.print(sb);
  }
  static class Event implements Comparable<Event>{
    int start ;
    int end ;
    int point ;
    public Event(int start,int end,int point){
      this.start=start ;
      this.end=end ;
      this.point=point ;
    }
    public int compareTo(Event another){
      return point-another.point ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var queue : Sequence(Event) ; queue := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     queue := queue->including(Event.newEvent(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < q do ( (     map := map->union(Map{sc.getCurrent()->toInteger() |-> i}) )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,q)->collect(0) ;
    ans := ans->collect(-1) ; 
    while (queue->size() > 0) do (     var e : Event ; e := queue->min() ;
     var x : Map(int,int) ; x := map.ceilingEntry(e.start - e.point) ;
     while (x /= null & x->keys()->any() < e.end - e.point) do (     ans[x->values->any()+1] := e.point ; 
     map := map->antirestrict(Set{x->keys()->any()}) ; 
     x := map.ceilingEntry(e.start - e.point) ) ) ; 
    var sb : String ; sb := StringLib.newString() ;
    for (x : ans) do ( (     sb := sb + StringLib.newString(x) + StringLib.newString("\n") )  ) ; 
    OclFile["System.out"].print(sb) ; 
 );
  static class Event implements Comparable<Event> {
   attribute start : int;
   attribute end : int;
   attribute point : int;
   static operation newEvent( start : int, end : int, point : int) : Event
  pre: true
  post: true
  activity:
  ( var self : Event ;
    self := createEvent();
    self.initialise(start, end,point);
    return self );
  operation initialise( start : int, end : int, point : int) : void
  pre: true  post: true
  activity: (     self.start := start ; 
     self.end := end ; 
     self.point := point );
   operation compareTo( another : Event) : int
  pre: true
  post: true
  activity: (     return (point)->char2byte() - another.point );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args)throws Exception {
    try(Scanner sc=new Scanner(System.in)){
      int N=sc.nextInt();
      int Q=sc.nextInt();
      int[][] W=new int[N][3];
      for(int i=0 ; i<N ; i++){
        W[i][0]=sc.nextInt();
        W[i][1]=sc.nextInt();
        W[i][2]=sc.nextInt();
      }
      Arrays.sort(W,(o1,o2)->Integer.compare(o1[2],o2[2]));
      TreeMap<Integer,Integer>D=new TreeMap<>();
      for(int i=0 ; i<Q ; i++){
        D.put(sc.nextInt(),i);
      }
      int[] A=new int[Q];
      Arrays.fill(A,-1);
      for(int i=0 ; i<N ; i++){
        int s=W[i][0];
        int t=W[i][1];
        int x=W[i][2];
        while(true){
          Integer key=D.ceilingKey(s-x);
          if(key==null){
            break ;
          }
          if(key>=t-x){
            break ;
          }
          A[D.get(key)]=x ;
          D.remove(key);
        }
      }
      StringBuilder ans=new StringBuilder();
      for(int a : A){
        ans.append(a).append("\n");
      }
      System.out.print(ans.toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var Q : int ; Q := sc.getCurrent()->toInteger() ;
    var W : Sequence(Sequence(int)) ; W := Integer.subrange(1,N)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     W[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     W[i+1][1+1] := sc.getCurrent()->toInteger() ; 
     W[i+1][2+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    W := OclComparator.sortWith(W, lambda (o1 , o2) : OclAny in compare(o1[2+1], o2[2+1])) ; 
    var D : Map(int,int) ; D := Map{} ;
        var i : int ; i := 0 ; while i < Q do ( (     D := D->union(Map{sc.getCurrent()->toInteger() |-> i}) )  ;     i := i + 1 ) ; 
    var A : Sequence(int) ; A := Integer.subrange(1,Q)->collect(0) ;
    A := A->collect(-1) ; 
        var i : int ; i := 0 ; while i < N do ( (     var s : int ; s := W[i+1][0+1] ;
     var t : int ; t := W[i+1][1+1] ;
     var x : int ; x := W[i+1][2+1] ;
     while (true) do (     var key : int ; key := D.ceilingKey(s - x) ;
     if (key = null) then (     break ) else skip ; 
    if (key >= t - x) then (     break ) else skip ; 
    A[D->at(key)+1] := x ; 
    D := D->antirestrict(Set{key}) ; 
 ) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := StringLib.newString() ;
    for (a : A) do ( (     ans := ans + StringLib.newString(a) + StringLib.newString("\n") )  ) ; 
    OclFile["System.out"].print(ans+"") ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int[] seats=new int[] {
    1,2,4 };
    public static int maxAmount(int M,int N){
      PriorityQueue<Integer>q=new PriorityQueue<Integer>(Collections.reverseOrder());
      for(int i=0 ; i<M ; i++){
        q.add(seats[i]);
      }
      int ticketSold=0 ;
      int ans=0 ;
      while(ticketSold<N && q.peek()>0){
        ans=ans+q.peek();
        int temp=q.peek();
        q.poll();
        q.add(temp-1);
        ticketSold++;
      }
      return ans ;
    }
    public static void main(String[] args){
      int M=seats.length ;
      int N=3 ;
      System.out.print(maxAmount(M,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute seats : Sequence(int) := Sequence{1,2,4};
  static   operation maxAmount( M : int, N : int) : int
  pre: true
  post: true
  activity: (     var q : Sequence(int) ; q := Sequence{}->union(reverseOrder()) ;
         var i : int ; i := 0 ; while i < M do ( (     q := q->including(seats[i+1]) )  ;     i := i + 1 ) ; 
    var ticketSold : int ; ticketSold := 0 ;
    var ans : int ; ans := 0 ;
    while (ticketSold < N & q->min() > 0) do (     ans := ans + q->min() ; 
     var temp : int ; temp := q->min() ;
    q := q->sort()->tail() ; 
    q := q->including(temp - 1) ; 
    ticketSold := ticketSold + 1 ; 
 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var M : int ; M := seats->size() ;
     var N : int ; N := 3 ;
     OclFile["System.out"].print(maxAmount(M, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maxDifference(int arr[],int N,int k){
    int M,S=0,S1=0,max_difference=0 ;
    for(int i=0 ; i<N ; i++)S+=arr[i];
    int temp ;
    for(int i=0 ; i<N ; i++){
      for(int j=i+1 ; j<N ; j++){
        if(arr[i]<arr[j]){
          temp=arr[i];
          arr[i]=arr[j];
          arr[j]=temp ;
        }
      }
    }
    M=Math.max(k,N-k);
    for(int i=0 ; i<M ; i++)S1+=arr[i];
    max_difference=S1-(S-S1);
    return max_difference ;
  }
  public static void main(String args[]){
    int arr[]={
      8,4,5,2,10 };
      int N=arr.length ;
      int k=2 ;
      System.out.println(maxDifference(arr,N,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxDifference( arr : Sequence(int), N : int, k : int) : int
  pre: true
  post: true
  activity: (     var M : int ;
    var S : int ; S := 0 ;
    var S1 : int ; S1 := 0 ;
    var max_difference : int ; max_difference := 0 ;
         var i : int ; i := 0 ; while i < N do (     S := S+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    var temp : int ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := i + 1 ; while j < N do ( (     if (arr[i+1] < arr[j+1]) then (     temp := arr[i+1] ; 
     arr[i+1] := arr[j+1] ; 
     arr[j+1] := temp ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    M := Set{k, N - k}->max() ; 
        var i : int ; i := 0 ; while i < M do (     S1 := S1+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    max_difference := S1 - (S - S1) ; 
    return max_difference 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,4,5,2,10} ;
     var N : int ; N := arr->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(maxDifference(arr, N, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector ;
import java.util.Arrays ;
class GfG {
  static int checkBit(int pattern,Vector<Integer>arr,int n){
    int count=0 ;
    for(int i=0 ; i<n ; i++)if((pattern & arr.get(i))==pattern)count++;
    return count ;
  }
  static int largest(int arr[],int n){
    Vector<Integer>v=new Vector<>();
    for(Integer a : arr)v.add(a);
    v.add(Integer.MAX_VALUE);
    n++;
    int res=0 ;
    for(int bit=31 ; bit>=0 ; bit--){
      int count=checkBit(res |(1<<bit),v,n);
      if((count | 1)!=1)res |=(1<<bit);
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      4,8,6,2 };
      int n=arr.length ;
      System.out.println("Largest element="+largest(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation checkBit( pattern : int, arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do (     if ((pattern & arr->at(i+1)) = pattern) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return count );
  static   operation largest( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Sequence{} ;
     for (a : arr) do (     v := v->including(a) ;  ) ; 
    v := v->including(2147483647) ; 
    n := n + 1 ; 
    var res : int ; res := 0 ;
        var bit : int ; bit := 31 ; while bit >= 0 do ( (     var count : int ; count := checkBit(MathLib.bitwiseOr(res,((1*(2->pow(bit)))->oclAsType(long))), v, n) ;
     if ((MathLib.bitwiseOr(count,1)) /= 1) then     res := MathLib.bitwiseOr(res, ((1*(2->pow(bit)))->oclAsType(long))) ; else skip )  ;     bit := bit - 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,8,6,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Largest element=" + largest(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static long rectCount(int n,int m){
    return(m*n*(n+1)*(m+1))/4 ;
  }
  public static void main(String[] args){
    int n=5,m=4 ;
    System.out.println(rectCount(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation rectCount( n : int, m : int) : long
  pre: true
  post: true
  activity: (     return (m * n * (n + 1) * (m + 1)) / 4 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var m : int ; m := 4 ;
     OclFile["System.out"].println(rectCount(n, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class MaximumDiffrence {
  int maxDiff(int arr[],int n){
    int diff[]=new int[n-1];
    for(int i=0 ; i<n-1 ; i++)diff[i]=arr[i+1]-arr[i];
    int max_diff=diff[0];
    for(int i=1 ; i<n-1 ; i++){
      if(diff[i-1]>0)diff[i]+=diff[i-1];
      if(max_diff<diff[i])max_diff=diff[i];
    }
    return max_diff ;
  }
  public static void main(String[] args){
    MaximumDiffrence mxdif=new MaximumDiffrence();
    int arr[]={
      80,2,6,3,100 };
      int size=arr.length ;
      System.out.println(mxdif.maxDiff(arr,size));
    }
  }

------------------------------------------------------------
OCL File:
---------
class MaximumDiffrence {
   operation maxDiff( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var diff : Sequence(int) ; diff := Integer.subrange(1,n - 1)->collect(0) ;
         var i : int ; i := 0 ; while i < n - 1 do (     diff[i+1] := arr[i + 1+1] - arr[i+1] ;  ;     i := i + 1 ) ; 
    var max_diff : int ; max_diff := diff[0+1] ;
        var i : int ; i := 1 ; while i < n - 1 do ( (     if (diff[i - 1+1] > 0) then     diff[i+1] := diff[i+1]+(diff[i - 1+1]) ; else skip ; 
     if (max_diff < diff[i+1]) then     max_diff := diff[i+1] ; else skip )  ;     i := i + 1 ) ; 
    return max_diff 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mxdif : MaximumDiffrence ; mxdif := MaximumDiffrence.newMaximumDiffrence() ;
     var arr : Sequence(int) ; arr := Sequence{80,2,6,3,100} ;
     var size : int ; size := arr->size() ;
     OclFile["System.out"].println(mxdif.maxDiff(arr, size)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float y(float x){
    return 1/(1+x*x);
  }
  static float trapezoidal(float a,float b,float n){
    float h=(b-a)/n ;
    float s=y(a)+y(b);
    for(int i=1 ; i<n ; i++)s+=2*y(a+i*h);
    return(h/2)*s ;
  }
  public static void main(String[] args){
    float x0=0 ;
    float xn=1 ;
    int n=6 ;
    System.out.println("Value of integral is "+Math.round(trapezoidal(x0,xn,n)*10000.0)/10000.0);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation y( x : double) : double
  pre: true
  post: true
  activity: (     return 1 / (1 + x * x) );
  static   operation trapezoidal( a : double, b : double, n : double) : double
  pre: true
  post: true
  activity: (     var h : double ; h := (b - a) / n ;
     var s : double ; s := y(a) + y(b) ;
         var i : int ; i := 1 ; while i < n do (     s := s+(2 * y(a + i * h)) ;  ;     i := i + 1 ) ; 
     return (h / 2) * s );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x0 : double ; x0 := 0 ;
     var xn : double ; xn := 1 ;
     var n : int ; n := 6 ;
     OclFile["System.out"].println("Value of integral is " + (trapezoidal(x0, xn, n) * 10000.0)->round() / 10000.0) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static char[] s ;
  static int id ;
  static int len ;
  static String msg(){
    StringBuilder sb=new StringBuilder();
    int x=1 ;
    while(true){
      char ch=s[id++];
      if(Character.isDigit(ch)){
        id--;
        x=num();
      }
      else if(ch=='('){
        String t=msg();
        while(sb.length()<=len && x--!=0){
          for(int i=0 ; i<t.length(); i++){
            if(sb.length()>len)break ;
            sb.append(t.charAt(i));
          }
        }
        x=1 ;
      }
      else if(Character.isUpperCase(ch)){
        while(sb.length()<=len && x--!=0)sb.append(ch);
        x=1 ;
      }
      else break ;
    }
    return sb.toString();
  }
  static int num(){
    char ch=s[id++];
    int x=ch-'0' ;
    while(true){
      ch=s[id++];
      if(! Character.isDigit(ch))break ;
      x*=10 ;
      x+=ch-'0' ;
    }
    id--;
    return x ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      String ss=sc.next();
      len=sc.nextInt();
      if(ss.equals("0")&& len==0)break ;
      s=(ss+"#").toCharArray();
      id=0 ;
      len++;
      String genom=msg();
      System.out.println(genom.length()>=len ? genom.charAt(len-1): "0");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : Sequence(String);
  static   attribute id : int;
  static   attribute len : int;
  static   operation msg() : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     var x : int ; x := 1 ;
     while (true) do (     var ch : String ; ch := s[id+1] ;
     if ((ch + "")->isMatch("[0-9]")) then (     id := id - 1 ; 
     x := num() ) else     if (ch = '(') then (     var t : String ; t := msg() ;
         while (sb->size() <= len & x /= 0) do (    skip ; (         var i : int ; i := 0 ; while i < t->size() do ( (     if (sb->size() > len) then     break else skip ; 
     sb := sb + StringLib.newString(t->at(i+1)) )  ;     i := i + 1 ) ) ;  ) ;  
     x := 1 ) else     if ((ch->toUpperCase() = ch)) then (         while (sb->size() <= len & x /= 0) do (    skip ;     sb := sb + StringLib.newString(ch) ; ;  ) ;  
     x := 1 ) else     break ;  ;  ) ; 
     return sb+"" );
  static   operation num() : int
  pre: true
  post: true
  activity: (     var ch : String ; ch := s[id+1] ;
     var x : int ; x := (ch)->char2byte() - ('0')->char2byte() ;
    while (true) do (      ch := s[id+1]  ; id := id + 1 ; 
     if (not((ch + "")->isMatch("[0-9]"))) then     break else skip ; 
     x := x*(10) ; 
     x := x+((ch)->char2byte() - ('0')->char2byte()) ) ; 
    id := id - 1 ; 
    return x 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var ss : String ; ss := sc.getCurrent() ;
     len := sc.getCurrent()->toInteger() ; 
    if (ss = "0" & len = 0) then     break else skip ; 
    s := (ss + "#")->characters() ; 
    id := 0 ; 
    len := len + 1 ; 
    var genom : String ; genom := msg() ;
    OclFile["System.out"].println(if genom->size() >= len then genom->at(len - 1+1) else "0" endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static int n ;
  static int count ;
  static String str ;
  static boolean R ;
  static void solve(int a,int b){
    int now=0 ;
    for(int i=a ; i<=b ; i++){
      if('0'<=str.charAt(i)&& str.charAt(i)<='9'){
        now*=10 ;
        now+=(int)(str.charAt(i)-'0');
      }
      else if(str.charAt(i)=='('){
        if(now==0)now=1 ;
        int K=1 ;
        int j ;
        for(j=i+1 ; j<=b ; j++){
          if(str.charAt(j)=='(')K++;
          if(str.charAt(j)==')')K--;
          if(K==0)break ;
        }
        for(int k=0 ; k<now ; k++){
          solve(i+1,j-1);
          if(R)return ;
        }
        i=j ;
        now=0 ;
      }
      else {
        if(now==0)now=1 ;
        for(int j=0 ; j<now ; j++){
          if(count==n){
            System.out.println(str.charAt(i));
            R=true ;
            return ;
          }
          count++;
        }
        now=0 ;
      }
    }
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    while(true){
      str=s.next();
      int a=s.nextInt();
      n=a ;
      count=0 ;
      R=false ;
      if(str.equals("0"))break ;
      solve(0,str.length()-1);
      if(! R)System.out.println("0");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute count : int;
  static   attribute str : String;
  static   attribute R : boolean;
  static   operation solve( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var now : int ; now := 0 ;
         var i : int ; i := a ; while i <= b do ( (     if ('0' <= str->at(i+1) & str->at(i+1) <= '9') then (     now := now*(10) ; 
     now := now+((str->at(i+1) - ('0')->char2byte())->oclAsType(int)) ) else     if (str->at(i+1) = '(') then (     if (now = 0) then     now := 1 ; else skip ; 
     var K : int ; K := 1 ;
    var j : int ;
        j := i + 1 ; while j <= b do ( (     if (str->at(j+1) = '(') then     K := K + 1 ; else skip ; 
     if (str->at(j+1) = ')') then     K := K - 1 ; else skip ; 
     if (K = 0) then     break else skip )  ;     j := j + 1 ) ; 
        var k : int ; k := 0 ; while k < now do ( (     execute solve(i + 1, j - 1) ; 
     if (R) then     return else skip )  ;     k := k + 1 ) ; 
    i := j ; 
    now := 0 ; 
 ) else (     if (now = 0) then     now := 1 ; else skip ; 
         var j : int ; j := 0 ; while j < now do ( (     if (count = n) then (     OclFile["System.out"].println(str->at(i+1)) ; 
     R := true ; 
     return ) else skip ; 
     count := count + 1 )  ;     j := j + 1 ) ; 
     now := 0 ) ;  )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     str := s.getCurrent() ; 
     var a : int ; a := s.getCurrent()->toInteger() ;
    n := a ; 
    count := 0 ; 
    R := false ; 
    if (str = "0") then     break else skip ; 
    execute solve(0, str->size() - 1) ; 
    if (not(R)) then     OclFile["System.out"].println("0") ; else skip ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    FastReader sc=new FastReader();
    int x=sc.nextInt();
    if(x==1)System.out.println(0);
    else System.out.println(1);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var x : int ; x := sc.nextInt() ;
     if (x = 1) then     OclFile["System.out"].println(0) ; else     OclFile["System.out"].println(1) ; );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  String s ;
  char[] a,b ;
  int n ;
  int id,pos ;
  void A(){
    while(true){
      int start=pos ;
      int t=id ;
      int num=1 ;
      int goal ;
      while(Character.isDigit(a[id])==true)id++;
      if(id!=t)num=Integer.valueOf(s.substring(t,id));
      B();
      goal=pos ;
      for(int i=0 ; i<num-1 ; i++){
        for(int j=start ; j<goal ; j++){
          if(pos>n || j>n){
            i=num ;
            break ;
          }
          b[pos]=b[j];
          pos++;
        }
      }
      if(id==a.length || a[id]==')')break ;
    }
  }
  void B(){
    if(a[id]=='('){
      id++;
      A();
      id++;
    }
    else {
      int t=id ;
      while(id<s.length()&& Character.isUpperCase(a[id])==true)id++;
      if(id==a.length || a[id]==')' || Character.isDigit(a[id])==true){
        for(int i=t ; i<id ; i++){
          if(pos>n)break ;
          b[pos]=a[i];
          pos++;
        }
      }
    }
  }
  void solve(){
    Scanner sc=new Scanner(System.in);
    while(true){
      s=sc.next();
      a=s.toCharArray();
      n=sc.nextInt();
      if(a[0]=='0' && n==0)break ;
      b=new char[n+1];
      Arrays.fill(b,'0');
      id=0 ;
      pos=0 ;
      A();
      System.out.println(b[n]);
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute s : String;
   attribute a : Sequence(String);
   attribute n : int;
   attribute id : int;
   operation A() : void
  pre: true
  post: true
  activity: (     while (true) do (     var start : int ; start := pos ;
     var t : int ; t := id ;
    var num : int ; num := 1 ;
    var goal : int ;
    while ((a[id+1] + "")->isMatch("[0-9]") = true) do     id := id + 1 ; ; 
    if (id /= t) then     num := (s.subrange(t+1,id))->toInteger() ; else skip ; 
    execute B() ; 
    goal := pos ; 
        var i : int ; i := 0 ; while i < num - 1 do ( (         var j : int ; j := start ; while j < goal do ( (     if (pos > n or j > n) then (     i := num ; 
     break ) else skip ; 
     b[pos+1] := b[j+1] ; 
     pos := pos + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (id = a->size() or a[id+1] = ')') then     break else skip ; 
 ) );
   operation B() : void
  pre: true
  post: true
  activity: (     if (a[id+1] = '(') then (     id := id + 1 ; 
     execute A() ; 
     id := id + 1 ) else (     var t : int ; t := id ;
     while (id < s->size() & (a[id+1]->toUpperCase() = a[id+1]) = true) do     id := id + 1 ; ; 
     if (id = a->size() or a[id+1] = ')' or (a[id+1] + "")->isMatch("[0-9]") = true) then (         var i : int ; i := t ; while i < id do ( (     if (pos > n) then     break else skip ; 
     b[pos+1] := a[i+1] ; 
     pos := pos + 1 )  ;     i := i + 1 ) ) else skip ) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     s := sc.getCurrent() ; 
     a := s->characters() ; 
    n := sc.getCurrent()->toInteger() ; 
    if (a[0+1] = '0' & n = 0) then     break else skip ; 
    b := Integer.subrange(1,n + 1)->collect(0) ; 
    b := b->collect('0') ; 
    id := 0 ; 
    pos := 0 ; 
    execute A() ; 
    OclFile["System.out"].println(b[n+1]) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static String formula ;
  static int pos ;
  static int n ;
  static StringBuilder sb ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      formula=sc.next();
      n=sc.nextInt();
      if(formula.equals("0")&& n==0)break ;
      pos=0 ;
      sb=new StringBuilder();
      parse();
      if(n>=sb.length())System.out.println(0);
      else System.out.println(sb.charAt(n));
    }
    sc.close();
  }
  static void parse(){
    while(pos<formula.length()&& sb.length()<=n+1)term();
  }
  static void term(){
    if(sb.length()>n+1){
      pos=formula.length();
      return ;
    }
    if(Character.isUpperCase(formula.charAt(pos))){
      if(sb.length()<=n+1)sb.append(formula.charAt(pos));
      pos++;
      return ;
    }
    int n=number();
    if(formula.charAt(pos)!='('){
      for(int i=0 ; i<n ; i++)sb.append(formula.charAt(pos));
      pos++;
      return ;
    }
    pos++;
    for(int i=0 ; i<n-1 ; i++){
      int t=pos ;
      while(pos<formula.length()&& formula.charAt(pos)!=')')term();
      pos=t ;
    }
    while(pos<formula.length()&& formula.charAt(pos)!=')')term();
    pos++;
    return ;
  }
  static int number(){
    int result=0 ;
    while(Character.isDigit(formula.charAt(pos))){
      result*=10 ;
      result+=formula.charAt(pos++)-'0' ;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute formula : String;
  static   attribute pos : int;
  static   attribute n : int;
  static   attribute sb : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     formula := sc.getCurrent() ; 
     n := sc.getCurrent()->toInteger() ; 
    if (formula = "0" & n = 0) then     break else skip ; 
    pos := 0 ; 
    sb := StringLib.newString() ; 
    execute parse() ; 
    if (n >= sb->size()) then     OclFile["System.out"].println(0) else     OclFile["System.out"].println(sb->at(n+1)) ; ;  
 ) ; 
     skip );
  static   operation parse() : void
  pre: true
  post: true
  activity: (     while (pos < formula->size() & sb->size() <= n + 1) do     execute term() ; );
  static   operation term() : void
  pre: true
  post: true
  activity: (     if (sb->size() > n + 1) then (     pos := formula->size() ; 
     return ) else skip ; 
     if ((formula->at(pos+1)->toUpperCase() = formula->at(pos+1))) then (     if (sb->size() <= n + 1) then     sb := sb + StringLib.newString(formula->at(pos+1)) ; else skip ; 
     pos := pos + 1 ; 
     return ) else skip ; 
    var n : int ; n := number() ;
    if (formula->at(pos+1) /= '(') then (         var i : int ; i := 0 ; while i < n do (     sb := sb + StringLib.newString(formula->at(pos+1)) ;  ;     i := i + 1 ) ; 
     pos := pos + 1 ; 
     return ) else skip ; 
    pos := pos + 1 ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var t : int ; t := pos ;
     while (pos < formula->size() & formula->at(pos+1) /= ')') do     execute term() ; ; 
     pos := t )  ;     i := i + 1 ) ; 
    while (pos < formula->size() & formula->at(pos+1) /= ')') do     execute term() ; ; 
    pos := pos + 1 ; 
    return 
 );
  static   operation number() : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     while ((formula->at(pos+1) + "")->isMatch("[0-9]")) do (     result := result*(10) ; 
     result := result+(formula->at(pos+1) - ('0')->char2byte()) ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void balancedString(String str){
    int count=0,i ;
    int n=str.length();
    for(i=0 ; i<n ; i++){
      if(str.charAt(i)=='('){
        System.out.print(str.charAt(i));
        count++;
      }
      else if(str.charAt(i)==')' && count!=0){
        System.out.print(str.charAt(i));
        count--;
      }
      else if(str.charAt(i)!=')')System.out.print(str.charAt(i));
    }
    if(count!=0)for(i=0 ;
    i<count ;
    i++)System.out.print(")");
  }
  public static void main(String args[]){
    String str="gau)ra)v(ku(mar(rajput))" ;
    balancedString(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation balancedString( str : String) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
    var i : int ;
     var n : int ; n := str->size() ;
         i := 0 ; while i < n do ( (     if (str->at(i+1) = '(') then (     OclFile["System.out"].print(str->at(i+1)) ; 
     count := count + 1 ) else     if (str->at(i+1) = ')' & count /= 0) then (     OclFile["System.out"].print(str->at(i+1)) ; 
     count := count - 1 ) else     if (str->at(i+1) /= ')') then     OclFile["System.out"].print(str->at(i+1)) ; else skip ; ;  )  ;     i := i + 1 ) ; 
     if (count /= 0) then         i := 0 ; while i < count do (     OclFile["System.out"].print(")") ;  ;     i := i + 1 ) ; else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "gau)ra)v(ku(mar(rajput))" ;
     execute balancedString(str) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Count {
  public static int count4Divisibiles(int arr[],int n){
    int freq[]={
      0,0,0,0 };
      int i=0 ;
      int ans ;
      for(i=0 ; i<n ; i++)++freq[arr[i] % 4];
      ans=freq[0]*(freq[0]-1)/2 ;
      ans+=freq[2]*(freq[2]-1)/2 ;
      ans+=freq[1]*freq[3];
      return(ans);
    }
    public static void main(String[] args){
      int arr[]={
        2,2,1,7,5 };
        int n=5 ;
        System.out.print(count4Divisibiles(arr,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Count {
  static   operation count4Divisibiles( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Sequence{0,0,0,0} ;
     var i : int ; i := 0 ;
    var ans : int ;
        i := 0 ; while i < n do (     freq[arr[i+1] mod 4+1] := freq[arr[i+1] mod 4+1] + 1 ;  ;     i := i + 1 ) ; 
    ans := freq[0+1] * (freq[0+1] - 1) / 2 ; 
    ans := ans+(freq[2+1] * (freq[2+1] - 1) / 2) ; 
    ans := ans+(freq[1+1] * freq[3+1]) ; 
    return (ans) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,2,1,7,5} ;
     var n : int ; n := 5 ;
     OclFile["System.out"].print(count4Divisibiles(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=100 ;
  static void binomialCoeff(int n,int C[]){
    C[0]=1 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=Math.min(i,n); j>0 ; j--)C[j]=C[j]+C[j-1];
    }
  }
  static int summation(int n){
    int C[]=new int[MAX];
    for(int i=0 ; i<MAX ; i++)C[i]=0 ;
    binomialCoeff(n,C);
    int sum=0 ;
    for(int i=0 ; i<=n ; i++)sum+=(i*C[i]);
    return sum ;
  }
  public static void main(String args[]){
    int n=2 ;
    System.out.println(summation(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100;
  static   operation binomialCoeff( n : int, C : Sequence(int)) : void
  pre: true
  post: true
  activity: (     C[0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := Set{i, n}->min() ; while j > 0 do (     C[j+1] := C[j+1] + C[j - 1+1] ;  ;     j := j - 1 ) )  ;     i := i + 1 ) );
  static   operation summation( n : int) : int
  pre: true
  post: true
  activity: (     var C : Sequence(int) ; C := Integer.subrange(1,MAX)->collect(0) ;
         var i : int ; i := 0 ; while i < MAX do (     C[i+1] := 0 ;  ;     i := i + 1 ) ; 
    execute binomialCoeff(n, C) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i <= n do (     sum := sum+((i * C[i+1])) ;  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(summation(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAX=100 ;
  static void binomialCoeff(int C[],int n){
    C[0]=1 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=Math.min(i,n); j>0 ; j--)C[j]=C[j]+C[j-1];
    }
  }
  static int sumOfproduct(int n){
    int sum=0 ;
    int C[]=new int[MAX];
    binomialCoeff(C,n);
    for(int i=0 ; i<=n ; i++)sum+=C[i]*C[i+1];
    return sum ;
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(sumOfproduct(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100;
  static   operation binomialCoeff( C : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     C[0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := Set{i, n}->min() ; while j > 0 do (     C[j+1] := C[j+1] + C[j - 1+1] ;  ;     j := j - 1 ) )  ;     i := i + 1 ) );
  static   operation sumOfproduct( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var C : Sequence(int) ; C := Integer.subrange(1,MAX)->collect(0) ;
    execute binomialCoeff(C, n) ; 
        var i : int ; i := 0 ; while i <= n do (     sum := sum+(C[i+1] * C[i + 1+1]) ;  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(sumOfproduct(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int minimumCost(int cost[],int n){
    int dp[]=new int[n];
    if(n==1)return cost[0];
    dp[0]=cost[0];
    dp[1]=cost[1];
    for(int i=2 ; i<n ; i++){
      dp[i]=Math.min(dp[i-1],dp[i-2])+cost[i];
    }
    return Math.min(dp[n-2],dp[n-1]);
  }
  public static void main(String args[]){
    int a[]={
      16,19,10,12,18 };
      int n=a.length ;
      System.out.print(minimumCost(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumCost( cost : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
     if (n = 1) then     return cost[0+1] else skip ; 
    dp[0+1] := cost[0+1] ; 
    dp[1+1] := cost[1+1] ; 
        var i : int ; i := 2 ; while i < n do ( (     dp[i+1] := Set{dp[i - 1+1], dp[i - 2+1]}->min() + cost[i+1] )  ;     i := i + 1 ) ; 
    return Set{dp[n - 2+1], dp[n - 1+1]}->min() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{16,19,10,12,18} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(minimumCost(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double cyl(double r,double h){
    if(r<0 && h<0)return-1 ;
    double R=(2*r)/3 ;
    double H=(2*h)/3 ;
    double V=3.14*Math.pow(R,2)*H ;
    return V ;
  }
  public static void main(String[] args){
    double r=4,h=8 ;
    System.out.println(cyl(r,h));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation cyl( r : double, h : double) : double
  pre: true
  post: true
  activity: (     if (r < 0 & h < 0) then     return -1 else skip ; 
     var R : double ; R := (2 * r) / 3 ;
    var H : double ; H := (2 * h) / 3 ;
    var V : double ; V := 3.14 * R->pow(2) * H ;
    return V 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : double ; r := 4 ;
    var h : double ; h := 8 ;
     OclFile["System.out"].println(cyl(r, h)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.ArrayList ;
public class codforce {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x=sc.nextInt();
    int count=0 ;
    for(int i=1 ; i<=n ; i++){
      if((x % i)==0 && x/i<=n){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codforce {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if ((x mod i) = 0 & x / i <= n) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    Main m=new Main(sc);
    m.show(m.solve());
    sc.close();
  }
  Scanner sc ;
  int x ;
  Main(Scanner sc){
    this.sc=sc ;
    this.x=sc.nextInt();
  }
  private int solve(){
    int answer=0 ;
    if(x==0){
      answer=1 ;
    }
    return answer ;
  }
  public void show(int answer){
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : Main ; m := Main.newMain(sc) ;
     m.show(m.solve()) ; 
     skip );
   attribute sc : OclFile;
   attribute x : int;
   static operation newMain( sc : OclFile) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(sc);
    return self );
  operation initialise( sc : OclFile) : void
  pre: true  post: true
  activity: (     self.sc := sc ; 
     self.x := sc.getCurrent()->toInteger() );
   operation solve() : int
  pre: true
  post: true
  activity: (     var answer : int ; answer := 0 ;
     if (x = 0) then (     answer := 1 ) else skip ; 
     return answer );
   operation show( answer : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(answer) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MultiplicationTable {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    int counter=0 ;
    for(int i=1 ; i<=x ; i++){
      if(y % i!=0){
        continue ;
      }
      if(i*x==y){
        counter++;
        continue ;
      }
      for(int j=1 ; j<=x && i*j<=y ; j++){
        if((i*j)==y){
          counter++;
          break ;
        }
      }
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MultiplicationTable {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 1 ; while i <= x do ( (     if (y mod i /= 0) then (     continue ) else skip ; 
     if (i * x = y) then (     counter := counter + 1 ; 
     continue ) else skip ; 
         var j : int ; j := 1 ; while j <= x & i * j <= y do ( (     if ((i * j) = y) then (     counter := counter + 1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long x=sc.nextLong();
    int count=0 ;
    for(int i=1 ; i<=n ; i++){
      if(x % i==0 && x/i<=n)count++;
    }
    System.out.print(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : long ; x := sc.getCurrent()->toLong() ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (x mod i = 0 & x / i <= n) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A {
  public static void main(String args[]){
    Scanner Sc=new Scanner(System.in);
    int n=Sc.nextInt();
    int x=Sc.nextInt();
    int count=0 ;
    for(int i=n ; i>=1 ; i--){
      int q=x/i ;
      if(x % i==0 && q<i){
        count+=2 ;
      }
      else if(x % i==0 && q==i){
        count+=1 ;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Sc : OclFile ; Sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := Sc.getCurrent()->toInteger() ;
    var x : int ; x := Sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := n ; while i >= 1 do ( (     var q : int ; q := x / i ;
     if (x mod i = 0 & q < i) then (     count := count+(2) ) else     if (x mod i = 0 & q = i) then (     count := count+(1) ) else skip ; )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int res=0 ;
    Set<Integer>st=new HashSet<>();
    for(int i=1 ; i<=n ; i++){
      if(m % i==0){
        int x=m/i ;
        if(x<=n)res++;
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
    var st : Set(int) ; st := Set{} ;
        var i : int ; i := 1 ; while i <= n do ( (     if (m mod i = 0) then (     var x : int ; x := m / i ;
     if (x <= n) then     res := res + 1 ; else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    TreeSet<Integer>orSet=new TreeSet<>();
    ArrayList<Integer>andList=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      orSet.add(sc.nextInt());
    }
    for(int i=0 ; i<m ; i++){
      int x=sc.nextInt();
      if(orSet.contains(x)){
        andList.add(x);
      }
      else {
        orSet.add(x);
      }
    }
    StringBuilder sb=new StringBuilder();
    sb.append(andList.size()).append(" ").append(orSet.size()).append("\n");
    for(int x : andList){
      sb.append(x).append("\n");
    }
    for(int x : orSet){
      sb.append(x).append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var orSet : Set(int) ; orSet := Set{} ;
    var andList : Sequence(int) ; andList := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     orSet := orSet->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (orSet->includes(x)) then (     andList := andList->including(x) ) else (     orSet := orSet->including(x) ) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString(andList->size()) + StringLib.newString(" ") + StringLib.newString(orSet->size()) + StringLib.newString("\n") ; 
    for (x : andList) do ( (     sb := sb + StringLib.newString(x) + StringLib.newString("\n") )  ) ; 
    for (x : orSet) do ( (     sb := sb + StringLib.newString(x) + StringLib.newString("\n") )  ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  static Scanner input=new Scanner(System.in);
  private static java.io.PrintWriter out=new java.io.PrintWriter(System.out);
  private static void solve(){
    int n=input.nextInt();
    int m=input.nextInt();
    int[] a=arrayInput(n);
    int[] b=arrayInput(m);
    Map<Integer,Integer>map=new HashMap<>();
    for(int v : a){
      map.put(v,1);
    }
    for(int v : b){
      if(map.containsKey(v)){
        map.put(v,2);
      }
      else {
        map.put(v,1);
      }
    }
    List<Integer>and=new ArrayList<>();
    List<Integer>or=new ArrayList<>(map.keySet());
    for(Map.Entry<Integer,Integer>entry : map.entrySet()){
      if(entry.getValue()==2){
        and.add(entry.getKey());
      }
    }
    Collections.sort(and);
    Collections.sort(or);
    out.println(and.size()+" "+or.size());
    for(int v : and){
      out.println(v);
    }
    for(int v : or){
      out.println(v);
    }
  }
  public static void main(String[] args){
    solve();
    out.flush();
  }
  private static int[] arrayInput(int n){
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=input.nextInt();
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute input : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : PrintWriter := PrintWriter.newPrintWriter(OclFile["System.out"]);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := input.getCurrent()->toInteger() ;
     var m : int ; m := input.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := arrayInput(n) ;
    var b : Sequence(int) ; b := arrayInput(m) ;
    var map : Map(int,int) ; map := Map{} ;
    for (v : a) do ( (     map := map->union(Map{v |-> 1}) )  ) ; 
    for (v : b) do ( (     if (map->keys()->includes(v)) then (     map := map->union(Map{v |-> 2}) ) else (     map := map->union(Map{v |-> 1}) ) )  ) ; 
    var and : Sequence(int) ; and := Sequence{} ;
    var or : Sequence(int) ; or := Sequence{}->union(map->keys()) ;
    for (entry : map->asSet()) do ( (     if (entry.getValue() = 2) then (     and := and->including(entry.getKey()) ) else skip )  ) ; 
    and := and->sort() ; 
    or := or->sort() ; 
    out.println(and->size() + " " + or->size()) ; 
    for (v : and) do ( (     out.println(v) )  ) ; 
    for (v : or) do ( (     out.println(v) )  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() ; 
     out.flush() );
  static   operation arrayInput( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := input.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  static Scanner input=new Scanner(System.in);
  private static java.io.PrintWriter out=new java.io.PrintWriter(System.out);
  private static void solve(){
    int n=input.nextInt();
    int m=input.nextInt();
    int[] a=arrayInput(n);
    int[] b=arrayInput(m);
    Map<Integer,Integer>map=new HashMap<>();
    for(int v : a){
      map.put(v,1);
    }
    for(int v : b){
      if(map.containsKey(v)){
        map.put(v,2);
      }
      else {
        map.put(v,1);
      }
    }
    List<Integer>and=new ArrayList<>();
    List<Integer>or=new ArrayList<>(map.keySet());
    for(Map.Entry<Integer,Integer>entry : map.entrySet()){
      if(entry.getValue()==2){
        and.add(entry.getKey());
      }
    }
    Collections.sort(and);
    Collections.sort(or);
    out.println(and.size()+" "+or.size());
    for(int v : and){
      out.println(v);
    }
    for(int v : or){
      out.println(v);
    }
  }
  public static void main(String[] args){
    solve();
    out.flush();
  }
  private static int[] arrayInput(int n){
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=input.nextInt();
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute input : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : PrintWriter := PrintWriter.newPrintWriter(OclFile["System.out"]);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := input.getCurrent()->toInteger() ;
     var m : int ; m := input.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := arrayInput(n) ;
    var b : Sequence(int) ; b := arrayInput(m) ;
    var map : Map(int,int) ; map := Map{} ;
    for (v : a) do ( (     map := map->union(Map{v |-> 1}) )  ) ; 
    for (v : b) do ( (     if (map->keys()->includes(v)) then (     map := map->union(Map{v |-> 2}) ) else (     map := map->union(Map{v |-> 1}) ) )  ) ; 
    var and : Sequence(int) ; and := Sequence{} ;
    var or : Sequence(int) ; or := Sequence{}->union(map->keys()) ;
    for (entry : map->asSet()) do ( (     if (entry.getValue() = 2) then (     and := and->including(entry.getKey()) ) else skip )  ) ; 
    and := and->sort() ; 
    or := or->sort() ; 
    out.println(and->size() + " " + or->size()) ; 
    for (v : and) do ( (     out.println(v) )  ) ; 
    for (v : or) do ( (     out.println(v) )  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() ; 
     out.flush() );
  static   operation arrayInput( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := input.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    long x ;
    long y ;
    while(t-->0){
      x=sc.nextLong();
      y=sc.nextLong();
      System.out.println((x-y)==1 && isPrime(x+y)? "YES" : "NO");
    }
  }
  static boolean isPrime(long num){
    if(num<=1){
      return false ;
    }
    for(int i=2 ; i<=num/i ; i++){
      if((num % i)==0){
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var x : long ;
    var y : long ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     x := sc.getCurrent()->toLong() ; 
     y := sc.getCurrent()->toLong() ; 
     OclFile["System.out"].println(if (x - y) = 1 & isPrime(x + y) then "YES" else "NO" endif) ) ;  ) ;  
 );
  static   operation isPrime( num : long) : boolean
  pre: true
  post: true
  activity: (     if (num <= 1) then (     return false ) else skip ; 
         var i : int ; i := 2 ; while i <= num / i do ( (     if ((num mod i) = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeforces1033B {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int numCases=Integer.parseInt(br.readLine());
    while(numCases-->0){
      StringTokenizer st=new StringTokenizer(br.readLine());
      long a=Long.parseLong(st.nextToken());
      long b=Long.parseLong(st.nextToken());
      boolean bo=prime(a+b);
      if(a-b==1 && bo){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
  static boolean prime(long n){
    for(long i=2 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces1033B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var numCases : int ; numCases := (br.readLine())->toInteger() ;
         while (numCases > 0) do (        numCases := numCases - 1 ;     skip ; (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var a : long ; a := (st.next())->toLong() ;
    var b : long ; b := (st.next())->toLong() ;
    var bo : boolean ; bo := prime(a + b) ;
    if (a - b = 1 & bo) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
  static   operation prime( n : long) : boolean
  pre: true
  post: true
  activity: (         var i : long ; i := 2 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    int n=fs.nextInt();
    if(n==0){
      System.out.println(1);
    }
    else if(n==1){
      System.out.println(0);
    }
    else {
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var n : int ; n := fs.nextInt() ;
     if (n = 0) then (     OclFile["System.out"].println(1) ) else     if (n = 1) then (     OclFile["System.out"].println(0) ) else skip ;  );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long cnt=1 ;
    long mod=1000000007 ;
    char[] c1=sc.next().toCharArray();
    char[] c2=sc.next().toCharArray();
    int i=0 ;
    if(c1[0]==c2[0])cnt=3 ;
    if(c1[0]!=c2[0]){
      cnt=6 ;
      i++;
    }
    while(i<n-1){
      if(c1[i]!=c2[i] && c1[i+1]!=c2[i+1] && c1[i]!=c1[i+1])cnt=(cnt*3)% mod ;
      else if(c1[i]!=c2[i] && c1[i+1]==c2[i+1])cnt=cnt % mod ;
      else if(c1[i]==c2[i] && c1[i+1]!=c2[i+1])cnt=(cnt*2)% mod ;
      else if(c1[i]==c2[i] && c1[i+1]==c2[i+1])cnt=(cnt*2)% mod ;
      i++;
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var cnt : long ; cnt := 1 ;
    var mod : long ; mod := 1000000007 ;
    var c1 : Sequence(String) ; c1 := sc.getCurrent()->characters() ;
    var c2 : Sequence(String) ; c2 := sc.getCurrent()->characters() ;
    var i : int ; i := 0 ;
    if (c1[0+1] = c2[0+1]) then     cnt := 3 ; else skip ; 
    if (c1[0+1] /= c2[0+1]) then (     cnt := 6 ; 
     i := i + 1 ) else skip ; 
    while (i < n - 1) do (     if (c1[i+1] /= c2[i+1] & c1[i + 1+1] /= c2[i + 1+1] & c1[i+1] /= c1[i + 1+1]) then     cnt := (cnt * 3) mod mod else     if (c1[i+1] /= c2[i+1] & c1[i + 1+1] = c2[i + 1+1]) then     cnt := cnt mod mod else     if (c1[i+1] = c2[i+1] & c1[i + 1+1] /= c2[i + 1+1]) then     cnt := (cnt * 2) mod mod else     if (c1[i+1] = c2[i+1] & c1[i + 1+1] = c2[i + 1+1]) then     cnt := (cnt * 2) mod mod ; else skip ; ;  ;  ;  
     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static final int MOD=1_000_000_007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    char[][] d=new char[2][N];
    for(int i=0 ; i<2 ; i++){
      String s=sc.next();
      for(int j=0 ; j<N ; j++){
        d[i][j]=s.charAt(j);
      }
    }
    int prev ;
    int j=d[0][0]==d[1][0] ? 1 : 2 ;
    long ans=d[0][0]==d[1][0] ? 3 : 6 ;
    while(j<N){
      if(d[0][j]==d[1][j]){
        ans*=d[0][j-1]==d[1][j-1] ? 2 : 1 ;
        j++;
      }
      else {
        ans*=d[0][j-1]==d[1][j-1] ? 2 : 3 ;
        j+=2 ;
      }
      ans %=MOD ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var d : Sequence(Sequence(String)) ; d := Integer.subrange(1,2)->collect(Integer.subrange(1,N)->collect(0)) ;
        var i : int ; i := 0 ; while i < 2 do ( (     var s : String ; s := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < N do ( (     d[i+1][j+1] := s->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var prev : int ;
    var j : int ; j := if d[0+1][0+1] = d[1+1][0+1] then 1 else 2 endif ;
    var ans : long ; ans := if d[0+1][0+1] = d[1+1][0+1] then 3 else 6 endif ;
    while (j < N) do (     if (d[0+1][j+1] = d[1+1][j+1]) then (     ans := ans*(if d[0+1][(j)->char2byte() - 1+1] = d[1+1][(j)->char2byte() - 1+1] then 2 else 1 endif) ; 
     j := j + 1 ) else (     ans := ans*(if d[0+1][(j)->char2byte() - 1+1] = d[1+1][(j)->char2byte() - 1+1] then 2 else 3 endif) ; 
     j := j+(2) ) ;  
     ans := ans mod MOD ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] r1=sc.next().toCharArray();
    char[] r2=sc.next().toCharArray();
    sc.close();
    int i ;
    long count ;
    boolean prev ;
    if(r1[0]==r2[0]){
      i=1 ;
      count=3 ;
      prev=true ;
    }
    else {
      i=2 ;
      count=6 ;
      prev=false ;
    }
    for(; i<n ; i++){
      if(r1[i]==r2[i]){
        if(prev)count=mulmod(count,2);
        prev=true ;
      }
      else {
        if(prev)count=mulmod(count,2);
        else count=mulmod(count,3);
        prev=false ;
        i++;
      }
    }
    System.out.println(count);
  }
  private static long mulmod(long a,long b){
    final long MOD=1000000007 ;
    return((a % MOD)*(b % MOD))% MOD ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var r1 : Sequence(String) ; r1 := sc.getCurrent()->characters() ;
    var r2 : Sequence(String) ; r2 := sc.getCurrent()->characters() ;
    skip ; 
    var i : int ;
    var count : long ;
    var prev : boolean ;
    if (r1[0+1] = r2[0+1]) then (     i := 1 ; 
     count := 3 ; 
     prev := true ) else (     i := 2 ; 
     count := 6 ; 
     prev := false ) ;  
      while i < n do ( (     if (r1[i+1] = r2[i+1]) then (     if (prev) then     count := mulmod(count, 2) ; else skip ; 
     prev := true ) else (     if (prev) then     count := mulmod(count, 2) else     count := mulmod(count, 3) ; ;  
     prev := false ; 
     i := i + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation mulmod( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var MOD : long ; MOD := 1000000007 ;
     return ((a mod MOD) * (b mod MOD)) mod MOD );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    long MOD=1000000007 ;
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s1=sc.next();
    String s2=sc.next();
    long ans=1 ;
    int pos=0 ;
    int pre=0 ;
    if(n>1){
      if(s1.charAt(0)==s1.charAt(1)){
        ans=6 ;
        pos=2 ;
      }
      else {
        ans=3 ;
        pos=1 ;
        pre=1 ;
      }
      while(pos<n){
        if(pre==0){
          if(pos==n-1){
            pos++;
          }
          else {
            if(s1.charAt(pos)==s1.charAt(pos+1)){
              ans=(ans*3)% MOD ;
              pos+=2 ;
              pre=0 ;
            }
            else {
              pos++;
              pre=1 ;
            }
          }
        }
        else {
          if(pos==n-1){
            ans=(ans*2)% MOD ;
            pos++;
          }
          else {
            if(s1.charAt(pos)==s1.charAt(pos+1)){
              ans=(ans*2)% MOD ;
              pos+=2 ;
              pre=0 ;
            }
            else {
              ans=(ans*2)% MOD ;
              pos++;
              pre=1 ;
            }
          }
        }
      }
    }
    else {
      ans=3 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var MOD : long ; MOD := 1000000007 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var s1 : String ; s1 := sc.getCurrent() ;
    var s2 : String ; s2 := sc.getCurrent() ;
    var ans : long ; ans := 1 ;
    var pos : int ; pos := 0 ;
    var pre : int ; pre := 0 ;
    if (n > 1) then (     if (s1->at(0+1) = s1->at(1+1)) then (     ans := 6 ; 
     pos := 2 ) else (     ans := 3 ; 
     pos := 1 ; 
     pre := 1 ) ;  
     while (pos < n) do (     if (pre = 0) then (     if (pos = n - 1) then (     pos := pos + 1 ) else (     if (s1->at(pos+1) = s1->at(pos + 1+1)) then (     ans := (ans * 3) mod MOD ; 
     pos := pos+(2) ; 
     pre := 0 ) else (     pos := pos + 1 ; 
     pre := 1 ) ) ) else (     if (pos = n - 1) then (     ans := (ans * 2) mod MOD ; 
     pos := pos + 1 ) else (     if (s1->at(pos+1) = s1->at(pos + 1+1)) then (     ans := (ans * 2) mod MOD ; 
     pos := pos+(2) ; 
     pre := 0 ) else (     ans := (ans * 2) mod MOD ; 
     pos := pos + 1 ; 
     pre := 1 ) ) ) ) ) else (     ans := 3 ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  Scanner sc ;
  int N ;
  Vec[] v ;
  static class Vec implements Comparable<Vec>{
    double x,y ;
    double theta(){
      if(x==0d && y==0d)return 0d ;
      return Math.atan2(y,x);
    }
    @ Override public int compareTo(Vec t){
      return Double.compare(theta(),t.theta());
    }
  }
  Main(){
    sc=new Scanner(System.in);
  }
  void calc(){
    N=sc.nextInt();
    v=new Vec[N];
    for(int i=0 ; i<N ; i++){
      v[i]=new Vec();
      v[i] .x=sc.nextInt();
      v[i] .y=sc.nextInt();
    }
    Arrays.sort(v);
    double max=-1 ;
    for(int a=0 ; a<N ; a++){
      for(int b=a+1 ; b<a+1+N ; b++){
        double len=len(a,b);
        if(len>max)max=len ;
      }
    }
    System.out.println(max);
  }
  double len(int a,int b){
    double x=0d ;
    double y=0d ;
    for(int i=a ; i<b ; i++){
      x+=v[i % N] .x ;
      y+=v[i % N] .y ;
    }
    return Math.sqrt(x*x+y*y);
  }
  public static void main(String[] args){
    new Main().calc();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute N : int;
   attribute v : Sequence(Vec);
  static class Vec implements Comparable<Vec> {
   attribute x : double;
   operation theta() : double
  pre: true
  post: true
  activity: (     if (x = 0d & y = 0d) then     return 0d else skip ; 
     return atan2(y, x) );
      operation compareTo( t : Vec) : int
  pre: true
  post: true
  activity: (     return (theta())->compareTo(t.theta()) );
}
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation calc() : void
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     v := Integer.subrange(1,N)->collect(null) ; 
        var i : int ; i := 0 ; while i < N do ( (     v[i+1] := Vec.newVec() ; 
     v[i+1].x := sc.getCurrent()->toInteger() ; 
     v[i+1].y := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    v := v->sort() ; 
    var max : double ; max := -1 ;
        var a : int ; a := 0 ; while a < N do ( (         var b : int ; b := a + 1 ; while b < a + 1 + N do ( (     var len : double ; len := len(a, b) ;
     if (len > max) then     max := len ; else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
   operation len( a : int, b : int) : double
  pre: true
  post: true
  activity: (     var x : double ; x := 0d ;
     var y : double ; y := 0d ;
         var i : int ; i := a ; while i < b do ( (     x := x+(v[i mod N+1].x) ; 
     y := y+(v[i mod N+1].y) )  ;     i := i + 1 ) ; 
     return (x * x + y * y)->sqrt() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().calc() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[3];
    for(int i=0 ; i<n ; i++){
      a[sc.nextInt()% 3]++;
    }
    int max=1 ;
    if(a[1]>0){
      int score=0 ;
      int[] b=Arrays.copyOf(a,3);
      b[1]--;
      score++;
      while(true){
        if(b[1]<=0)break ;
        b[1]--;
        score++;
        if(b[2]<=0)break ;
        b[2]--;
        score++;
      }
      score+=b[0];
      if(b[1]>0 || b[2]>0)score++;
      max=Math.max(max,score);
    }
    if(a[2]>0){
      int score=0 ;
      int[] b=Arrays.copyOf(a,3);
      b[2]--;
      score++;
      while(true){
        if(b[2]<=0)break ;
        b[2]--;
        score++;
        if(b[1]<=0)break ;
        b[1]--;
        score++;
      }
      score+=b[0];
      if(b[1]>0 || b[2]>0)score++;
      max=Math.max(max,score);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[sc.getCurrent()->toInteger() mod 3+1] := a[sc.getCurrent()->toInteger() mod 3+1] + 1 )  ;     i := i + 1 ) ; 
    var max : int ; max := 1 ;
    if (a[1+1] > 0) then (     var score : int ; score := 0 ;
     var b : Sequence(int) ; b := a.subrange(1,3) ;
    b[1+1] := b[1+1] - 1 ; 
    score := score + 1 ; 
    while (true) do (     if (b[1+1] <= 0) then     break else skip ; 
     b[1+1] := b[1+1] - 1 ; 
    score := score + 1 ; 
    if (b[2+1] <= 0) then     break else skip ; 
    b[2+1] := b[2+1] - 1 ; 
    score := score + 1 ; 
 ) ; 
    score := score+(b[0+1]) ; 
    if (b[1+1] > 0 or b[2+1] > 0) then     score := score + 1 ; else skip ; 
    max := Set{max, score}->max() ; 
 ) else skip ; 
    if (a[2+1] > 0) then (     var score : int ; score := 0 ;
     var b : Sequence(int) ; b := a.subrange(1,3) ;
    b[2+1] := b[2+1] - 1 ; 
    score := score + 1 ; 
    while (true) do (     if (b[2+1] <= 0) then     break else skip ; 
     b[2+1] := b[2+1] - 1 ; 
    score := score + 1 ; 
    if (b[1+1] <= 0) then     break else skip ; 
    b[1+1] := b[1+1] - 1 ; 
    score := score + 1 ; 
 ) ; 
    score := score+(b[0+1]) ; 
    if (b[1+1] > 0 or b[2+1] > 0) then     score := score + 1 ; else skip ; 
    max := Set{max, score}->max() ; 
 ) else skip ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    try(Scanner sc=new Scanner(System.in)){
      int n=Integer.parseInt(sc.next());
      int[] a=new int[3];
      for(int i=0 ; i<n ; i++){
        int p=Integer.parseInt(sc.next());
        a[p % 3]++;
      }
      int cnt=0 ;
      if(a[1]!=0 || a[2]!=0){
        cnt+=a[0];
        if(a[1]>a[2]){
          cnt+=a[2]*2 ;
          cnt+=Math.min(3,a[1]-a[2]);
        }
        else {
          cnt+=a[1]*2 ;
          cnt+=Math.min(3,a[2]-a[1]);
        }
      }
      else {
        cnt=1 ;
      }
      System.out.println(cnt);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := (sc.getCurrent())->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var p : int ; p := (sc.getCurrent())->toInteger() ;
     a[p mod 3+1] := a[p mod 3+1] + 1 )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    if (a[1+1] /= 0 or a[2+1] /= 0) then (     cnt := cnt+(a[0+1]) ; 
     if (a[1+1] > a[2+1]) then (     cnt := cnt+(a[2+1] * 2) ; 
     cnt := cnt+(Set{3, a[1+1] - a[2+1]}->min()) ) else (     cnt := cnt+(a[1+1] * 2) ; 
     cnt := cnt+(Set{3, a[2+1] - a[1+1]}->min()) ) ) else (     cnt := 1 ) ;  
    OclFile["System.out"].println(cnt) ; 
 ))  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int N=sc.nextInt();
      int[] a=new int[3];
      for(int i=0 ; i<N ; i++){
        a[sc.nextInt()% 3]++;
      }
      if(a[1]==0 && a[2]==0){
        System.out.println(1);
      }
      else {
        int ans=a[0];
        ans+=Math.min(a[1],a[2])*2 ;
        ans+=Math.min(3,Math.max(a[1],a[2])-Math.min(a[1],a[2]));
        System.out.println(ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
         var i : int ; i := 0 ; while i < N do ( (     a[sc.getCurrent()->toInteger() mod 3+1] := a[sc.getCurrent()->toInteger() mod 3+1] + 1 )  ;     i := i + 1 ) ; 
     if (a[1+1] = 0 & a[2+1] = 0) then (     OclFile["System.out"].println(1) ) else (     var ans : int ; ans := a[0+1] ;
     ans := ans+(Set{a[1+1], a[2+1]}->min() * 2) ; 
     ans := ans+(Set{3, Set{a[1+1], a[2+1]}->max() - Set{a[1+1], a[2+1]}->min()}->min()) ; 
     OclFile["System.out"].println(ans) ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MyClass {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s[]=br.readLine().split(" ");
    int n=Integer.parseInt(s[0]);
    for(int i=0 ; i<n ; i++){
      s=br.readLine().split(" ");
      long k=Long.parseLong(s[0]);
      long x=Long.parseLong(s[1]);
      long ans=x+(k-1)*9 ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
     var n : int ; n := (s[0+1])->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     s := br.readLine()->split(" ") ; 
     var k : long ; k := (s[0+1])->toLong() ;
    var x : long ; x := (s[1+1])->toLong() ;
    var ans : long ; ans := x + (k - 1) * 9 ;
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] modCounts=new int[3];
    for(int i=0 ; i<n ; i++){
      modCounts[sc.nextInt()% 3]++;
    }
    if(modCounts[1]==0 && modCounts[2]==0){
      System.out.println(1);
    }
    else if(modCounts[1]==modCounts[2]){
      System.out.println(n);
    }
    else if(modCounts[1]<modCounts[2]){
      modCounts[2]-=modCounts[1];
      System.out.println(Math.min(n,n-(modCounts[2]-3)));
    }
    else {
      modCounts[1]-=modCounts[2];
      System.out.println(Math.min(n,n-(modCounts[1]-3)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var modCounts : Sequence(int) ; modCounts := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     modCounts[sc.getCurrent()->toInteger() mod 3+1] := modCounts[sc.getCurrent()->toInteger() mod 3+1] + 1 )  ;     i := i + 1 ) ; 
    if (modCounts[1+1] = 0 & modCounts[2+1] = 0) then (     OclFile["System.out"].println(1) ) else     if (modCounts[1+1] = modCounts[2+1]) then (     OclFile["System.out"].println(n) ) else     if (modCounts[1+1] < modCounts[2+1]) then (     modCounts[2+1] := modCounts[2+1]-(modCounts[1+1]) ; 
     OclFile["System.out"].println(Set{n, n - (modCounts[2+1] - 3)}->min()) ) else (     modCounts[1+1] := modCounts[1+1]-(modCounts[2+1]) ; 
     OclFile["System.out"].println(Set{n, n - (modCounts[1+1] - 3)}->min()) ) ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Divisible {
  public static int gcd(int a,int b){
    return b==0 ? a : gcd(b,a % b);
  }
  static boolean isDivisible(int x,int y){
    if(y==1)return true ;
    int z=gcd(x,y);
    if(z==1)return false ;
    return isDivisible(x,y/z);
  }
  public static void main(String[] args){
    int x=18,y=12 ;
    if(isDivisible(x,y))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class Divisible {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
  static   operation isDivisible( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     if (y = 1) then     return true else skip ; 
     var z : int ; z := gcd(x, y) ;
     if (z = 1) then     return false else skip ; 
     return isDivisible(x, y / z) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 18 ;
    var y : int ; y := 12 ;
     if (isDivisible(x, y)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int nthTerm(int N){
    int nth=0,first_term=4 ;
    int pi=1,po=1 ;
    int n=N ;
    while(n>1){
      pi*=n-1 ;
      n--;
      po*=2 ;
    }
    nth=(first_term*pi)/po ;
    return nth ;
  }
  public static void main(String[] args){
    int N=5 ;
    System.out.print(nthTerm(N)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nthTerm( N : int) : int
  pre: true
  post: true
  activity: (     var nth : int ; nth := 0 ;
    var first_term : int ; first_term := 4 ;
     var pi : int ; pi := 1 ;
    var po : int ; po := 1 ;
    var n : int ; n := N ;
    while (n > 1) do (     pi := pi*(n - 1) ; 
     n := n - 1 ; 
     po := po*(2) ) ; 
    nth := (first_term * pi) / po ; 
    return nth 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     OclFile["System.out"].print(nthTerm(N) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int sum(int N,int X,int Y){
    int S1,S2,S3 ;
    S1=((N/X))*(2*X+(N/X-1)*X)/2 ;
    S2=((N/Y))*(2*Y+(N/Y-1)*Y)/2 ;
    S3=((N/(X*Y)))*(2*(X*Y)+(N/(X*Y)-1)*(X*Y))/2 ;
    return S1+S2-S3 ;
  }
  public static void main(String[] args){
    int N=14 ;
    int X=3,Y=5 ;
    System.out.println(sum(N,X,Y));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sum( N : int, X : int, Y : int) : int
  pre: true
  post: true
  activity: (     var S1 : int ;
    var S2 : int ;
    var S3 : int ;
     S1 := ((N / X)) * (2 * X + (N / X - 1) * X) / 2 ; 
    S2 := ((N / Y)) * (2 * Y + (N / Y - 1) * Y) / 2 ; 
    S3 := ((N / (X * Y))) * (2 * (X * Y) + (N / (X * Y) - 1) * (X * Y)) / 2 ; 
    return S1 + S2 - S3 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 14 ;
     var X : int ; X := 3 ;
    var Y : int ; Y := 5 ;
     OclFile["System.out"].println(sum(N, X, Y)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isUnary(int n){
    if(n==1 || n==7)return true ;
    else if(n/10==0)return false ;
    int x,sum=0 ;
    while(n!=0){
      x=n % 10 ;
      sum=sum+x*x ;
      n=n/10 ;
    }
    return isUnary(sum);
  }
  static int countUnary(int a,int b){
    int count=0 ;
    for(int i=a ; i<=b ; i++){
      if(isUnary(i)==true)count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int a=1000,b=1099 ;
    System.out.println(countUnary(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isUnary( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 1 or n = 7) then     return true else     if (n / 10 = 0) then     return false else skip ; ;  
     var x : int ;
    var sum : int ; sum := 0 ;
     while (n /= 0) do (     x := n mod 10 ; 
     sum := sum + x * x ; 
     n := n / 10 ) ; 
     return isUnary(sum) );
  static   operation countUnary( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := a ; while i <= b do ( (     if (isUnary(i) = true) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 1000 ;
    var b : int ; b := 1099 ;
     OclFile["System.out"].println(countUnary(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findLength(String str){
    int n=str.length();
    int maxlen=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j+=2){
        int length=j-i+1 ;
        int leftsum=0,rightsum=0 ;
        for(int k=0 ; k<length/2 ; k++){
          leftsum+=(str.charAt(i+k)-'0');
          rightsum+=(str.charAt(i+k+length/2)-'0');
        }
        if(leftsum==rightsum && maxlen<length)maxlen=length ;
      }
    }
    return maxlen ;
  }
  public static void main(String[] args){
    String str="1538023" ;
    System.out.println("Length of the substring is "+findLength(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findLength( str : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var maxlen : int ; maxlen := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var length : int ; length := j - i + 1 ;
     var leftsum : int ; leftsum := 0 ;
    var rightsum : int ; rightsum := 0 ;
         var k : int ; k := 0 ; while k < length / 2 do ( (     leftsum := leftsum+((str->at(i + k+1) - ('0')->char2byte())) ; 
     rightsum := rightsum+((str->at(i + k + length / 2+1) - ('0')->char2byte())) )  ;     k := k + 1 ) ; 
     if (leftsum = rightsum & maxlen < length) then     maxlen := length ; else skip )  ;     j := j+(2) ) )  ;     i := i + 1 ) ; 
     return maxlen );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "1538023" ;
     OclFile["System.out"].println("Length of the substring is " + findLength(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static void findFirstAndLast(int arr[],int x){
    int n=arr.length ;
    int first=-1,last=-1 ;
    for(int i=0 ; i<n ; i++){
      if(x!=arr[i])continue ;
      if(first==-1)first=i ;
      last=i ;
    }
    if(first!=-1){
      System.out.println("First Occurrence="+first);
      System.out.println("Last Occurrence="+last);
    }
    else System.out.println("Not Found");
  }
  public static void main(String[] args){
    int arr[]={
      1,2,2,2,2,3,4,7,8,8 };
      int x=8 ;
      findFirstAndLast(arr,x);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findFirstAndLast( arr : Sequence(int), x : int) : void
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
     var first : int ; first := -1 ;
    var last : int ; last := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (x /= arr[i+1]) then     continue else skip ; 
     if (first = -1) then     first := i ; else skip ; 
     last := i )  ;     i := i + 1 ) ; 
     if (first /= -1) then (     OclFile["System.out"].println("First Occurrence=" + first) ; 
     OclFile["System.out"].println("Last Occurrence=" + last) ) else     OclFile["System.out"].println("Not Found") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,2,2,2,3,4,7,8,8} ;
     var x : int ; x := 8 ;
     execute findFirstAndLast(arr, x) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  private static String input ;
  public static void main(String[] args)throws IOException {
    input=in.readLine();
    boolean brackets=input.charAt(0)=='-' ;
    StringBuilder ans=new StringBuilder(".");
    int count=0 ;
    int last_int=-1 ;
    boolean flag=false ;
    for(int i=0 ; i<input.length()&& count<2 ; i++){
      if(input.charAt(i)=='.'){
        flag=true ;
        last_int=i-1 ;
      }
      if(flag && input.charAt(i)!='.'){
        ans.append(input.charAt(i));
        count++;
      }
    }
    while(ans.length()<3)ans.append('0');
    if(last_int==-1)last_int=input.length()-1 ;
    for(int i=last_int,j=1 ; i>=0 && input.charAt(i)!='-' ; i--,j++){
      ans.insert(0,input.charAt(i));
      if(j % 3==0 && i!=0){
        ans.insert(0,',');
        j=0 ;
      }
    }
    if(ans.charAt(0)==',')ans.delete(0,1);
    ans.insert(0,'$');
    if(brackets){
      ans.append(')');
      ans.insert(0,'(');
    }
    System.out.println(ans.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute input : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     input := in.readLine() ; 
     var brackets : boolean ; brackets := input->at(0+1) = '-' ;
    var ans : String ; ans := StringLib.newString(".") ;
    var count : int ; count := 0 ;
    var last_int : int ; last_int := -1 ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < input->size() & count < 2 do ( (     if (input->at(i+1) = '.') then (     flag := true ; 
     last_int := i - 1 ) else skip ; 
     if (flag & input->at(i+1) /= '.') then (     ans := ans + StringLib.newString(input->at(i+1)) ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    while (ans->size() < 3) do     ans := ans + StringLib.newString('0') ; ; 
    if (last_int = -1) then     last_int := input->size() - 1 ; else skip ; 
        var i : int ; i := last_int ;
    var j : int ; j := 1 ; while i >= 0 & input->at(i+1) /= '-' do ( (     ans := ans.insertAt(0+1, StringLib.newString(input->at(i+1))) ; 
     if (j mod 3 = 0 & i /= 0) then (     ans := ans.insertAt(0+1, StringLib.newString(',')) ; 
     j := 0 ) else skip )  ;     i := i - 1 ;     j := j + 1 ) ; 
    if (ans->at(0+1) = ',') then     ans := ans->antirestrict( Integer.subrange(0+1,1) ) ; else skip ; 
    ans := ans.insertAt(0+1, StringLib.newString('$')) ; 
    if (brackets) then (     ans := ans + StringLib.newString(')') ; 
     ans := ans.insertAt(0+1, StringLib.newString('(')) ) else skip ; 
    OclFile["System.out"].println(ans+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static class Engine {
    int x,y ;
    public Engine(int x,int y){
      this.x=x ;
      this.y=y ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    Engine[] engine=new Engine[N];
    for(int i=0 ; i<N ; i++){
      engine[i]=new Engine(sc.nextInt(),sc.nextInt());
    }
    Arrays.sort(engine,new Comparator<Engine>(){
      public int compare(Engine e1,Engine e2){
        if(e1.x==0){
          if(e1.y>=0){
            return-1 ;
          }
          else {
            return(e2.x==0 && e2.y>=0)|| e2.x<0 ? 1 :-1 ;
          }
        }
        if(e2.x==0){
          if(e2.y>=0){
            return 1 ;
          }
          else {
            return(e1.x==0 && e1.y>=0)|| e1.x<0 ?-1 : 1 ;
          }
        }
        if(e1.x<0 && e2.x>0){
          return-1 ;
        }
        if(e1.x>0 && e2.x<0){
          return 1 ;
        }
        return Long.compare((long)e2.x*e1.y,(long)e1.x*e2.y);
      }
    }
);
    double max=0 ;
    for(int i=0 ; i<N ; i++){
      long x=0 ;
      long y=0 ;
      for(int j=0 ; j<N ; j++){
        x+=engine[(i+j)% N] .x ;
        y+=engine[(i+j)% N] .y ;
        max=Math.max(max,Math.sqrt(x*x+y*y));
      }
    }
    System.out.println(max);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Engine {
   attribute x : int;
   static operation newEngine( x : int, y : int) : Engine
  pre: true
  post: true
  activity:
  ( var self : Engine ;
    self := createEngine();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var engine : Sequence(Engine) ; engine := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     engine[i+1] := Engine.newEngine(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    engine := OclComparator.sortWith(engine, OclComparator<Engine>.newOclComparator()) ; 
    var max : double ; max := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var x : long ; x := 0 ;
     var y : long ; y := 0 ;
         var j : int ; j := 0 ; while j < N do ( (     x := x+(engine[(i + j) mod N+1].x) ; 
     y := y+(engine[(i + j) mod N+1].y) ; 
     max := Set{max, (x * x + y * y)->sqrt()}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static void main(String args[]){
    int n=3 ;
    int a[]={
      1,2,3 };
      int i=0 ;
      long sum=0 ;
      for(i=0 ; i<n ; i++){
        sum+=a[i];
      }
      long x=sum/n ;
      if(x*n==sum)System.out.println(x);
      else System.out.println("-1");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var a : Sequence(int) ; a := Sequence{1,2,3} ;
    var i : int ; i := 0 ;
    var sum : long ; sum := 0 ;
        i := 0 ; while i < n do ( (     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    var x : long ; x := sum / n ;
    if (x * n = sum) then     OclFile["System.out"].println(x) else     OclFile["System.out"].println("-1") ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int x=Integer.parseInt(scan.next());
    boolean bool=x==1 ? true : false ;
    int result=! bool ? 1 : 0 ;
    PrintWriter out=new PrintWriter(System.out);
    out.println(result);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := (scan.getCurrent())->toInteger() ;
    var bool : boolean ; bool := if x = 1 then true else false endif ;
    var result : int ; result := if not(bool) then 1 else 0 endif ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static float squareArea(float l,float b,float h){
    if(l<0 || b<0 || h<0)return-1 ;
    float a=(l*b)/(l+b);
    return a*a ;
  }
  public static void main(String[] args){
    float l=5,b=12,h=13 ;
    System.out.println(squareArea(l,b,h));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation squareArea( l : double, b : double, h : double) : double
  pre: true
  post: true
  activity: (     if (l < 0 or b < 0 or h < 0) then     return -1 else skip ; 
     var a : double ; a := (l * b) / (l + b) ;
     return a * a );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : double ; l := 5 ;
    var b : double ; b := 12 ;
    var h : double ; h := 13 ;
     OclFile["System.out"].println(squareArea(l, b, h)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  public static long findWays(int m,int n,int x){
    long[][] table=new long[n+1][x+1];
    for(int j=1 ; j<=m && j<=x ; j++)table[1][j]=1 ;
    for(int i=2 ; i<=n ; i++){
      for(int j=1 ; j<=x ; j++){
        for(int k=1 ; k<j && k<=m ; k++)table[i][j]+=table[i-1][j-k];
      }
    }
    return table[n][x];
  }
  public static void main(String[] args){
    System.out.println(findWays(4,2,1));
    System.out.println(findWays(2,2,3));
    System.out.println(findWays(6,3,8));
    System.out.println(findWays(4,2,5));
    System.out.println(findWays(4,3,5));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findWays( m : int, n : int, x : int) : long
  pre: true
  post: true
  activity: (     var table : Sequence(Sequence(long)) ; table := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,x + 1)->collect(0)) ;
         var j : int ; j := 1 ; while j <= m & j <= x do (     table[1+1][j+1] := 1 ;  ;     j := j + 1 ) ; 
         var i : int ; i := 2 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= x do ( (         var k : int ; k := 1 ; while k < j & k <= m do (     table[i+1][j+1] := table[i+1][j+1]+(table[i - 1+1][j - k+1]) ;  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return table[n+1][x+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(findWays(4, 2, 1)) ; 
     OclFile["System.out"].println(findWays(2, 2, 3)) ; 
    OclFile["System.out"].println(findWays(6, 3, 8)) ; 
    OclFile["System.out"].println(findWays(4, 2, 5)) ; 
    OclFile["System.out"].println(findWays(4, 3, 5)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.util.InputMismatchException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.TreeSet ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskC solver=new TaskC();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskC {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      String s=in.nextString();
      int k=in.nextInt();
      TreeSet<String>treeSet=new TreeSet<>();
      for(int i=1 ; i<=k ; i++){
        for(int j=0 ; j+i<=s.length(); j++){
          treeSet.add(s.substring(j,j+i));
        }
      }
      for(int i=0 ; i<k-1 ; i++){
        treeSet.pollFirst();
      }
      out.println(treeSet.first());
    }
  }
  static class InputReader {
    BufferedReader in ;
    StringTokenizer tok ;
    public String nextString(){
      while(! tok.hasMoreTokens()){
        try {
          tok=new StringTokenizer(in.readLine()," ");
        }
        catch(IOException e){
          throw new InputMismatchException();
        }
      }
      return tok.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(nextString());
    }
    public InputReader(InputStream inputStream){
      in=new BufferedReader(new InputStreamReader(inputStream));
      tok=new StringTokenizer("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskC ; solver := TaskC.newTaskC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskC {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.nextString() ;
     var k : int ; k := in.nextInt() ;
    var treeSet : Set(String) ; treeSet := Set{} ;
        var i : int ; i := 1 ; while i <= k do ( (         var j : int ; j := 0 ; while j + i <= s->size() do ( (     treeSet := treeSet->including(s.subrange(j+1,j + i)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < (k)->char2byte() - 1 do ( (     treeSet := treeSet->tail() )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute in : OclFile;
   attribute tok : OclIterator;
   operation nextString() : String
  pre: true
  post: true
  activity: (     while (not(tok.hasNext())) do (     try (     tok := OclIterator.newOclIterator_String_String(in.readLine(), " ") )   catch (e : IOException) do (     error IncorrectElementException() )
 ) ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextString())->toInteger() );
   static operation newInputReader( inputStream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) ; 
     tok := OclIterator.newOclIterator_String("") );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String s=sc.next();
      int k=sc.nextInt();
      Set<String>set=new HashSet<>();
      for(int i=0 ; i<s.length(); i++){
        for(int j=1 ; j<=5 ; j++){
          if(i+j>s.length()){
            break ;
          }
          String sub=s.substring(i,i+j);
          set.add(sub);
        }
      }
      List<String>list=new ArrayList<>(set);
      Collections.sort(list);
      System.out.println(list.get(k-1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var s : String ; s := sc.getCurrent() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := 0 ; while i < s->size() do ( (         var j : int ; j := 1 ; while j <= 5 do ( (     if (i + j > s->size()) then (     break ) else skip ; 
     var sub : String ; sub := s.subrange(i+1,i + j) ;
     set := set->including(sub) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var list : Sequence(String) ; list := Sequence{}->union(set) ;
    list := list->sort() ; 
    OclFile["System.out"].println(list->at((k)->char2byte() - 1+1)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int k=sc.nextInt();
    ArrayList<String>ss=new ArrayList<>();
    int n=s.length();
    for(int i=0 ; i<n ; i++){
      for(int j=1 ; j<=k ; j++){
        if(i+j<=n){
          ss.add(s.substring(i,i+j));
        }
      }
    }
    List<String>us=ss.stream().sorted().distinct().collect(Collectors.toList());
    System.out.println(us.get(k-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var ss : Sequence(String) ; ss := Sequence{} ;
    var n : int ; n := s->size() ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 1 ; while j <= k do ( (     if (i + j <= n) then (     ss := ss->including(s.subrange(i+1,i + j)) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var us : Sequence(String) ; us := ss->sort()->asOrderedSet().collect(Collectors.toList()) ;
    OclFile["System.out"].println(us->at((k)->char2byte() - 1+1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.function.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    int N=S.length();
    int K=sc.nextInt();
    Set<String>substrings=new HashSet<>();
    for(int i=0 ; i<N ; i++)for(int l=1 ; l<=Math.min(N-i,K); l++){
      substrings.add(S.substring(i,i+l));
    }
    String[] a=substrings.toArray(new String[0]);
    Arrays.sort(a);
    System.out.println(a[K-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    var N : int ; N := S->size() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var substrings : Set(String) ; substrings := Set{} ;
        var i : int ; i := 0 ; while i < N do (         var l : int ; l := 1 ; while l <= Set{(N)->char2byte() - i, K}->min() do ( (     substrings := substrings->including(S.subrange(i+1,i + l)) )  ;     l := l + 1 ) ;  ;     i := i + 1 ) ; 
    var a : Sequence(String) ; a := substrings->asSequence() ;
    a := a->sort() ; 
    OclFile["System.out"].println(a[K - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Iterator ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    String s=sc.next();
    int k=sc.nextInt();
    TreeSet<String>ts=new TreeSet<>();
    for(int i=1 ; i<=5 && i<=s.length(); i++){
      for(int j=0 ; j<=s.length()-i ; j++){
        ts.add(s.substring(j,i+j));
      }
    }
    Iterator ite=ts.iterator();
    for(int i=0 ; i<k-1 ; i++){
      ite.next();
    }
    System.out.println(ite.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
    var s : String ; s := sc.getCurrent() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var ts : Set(String) ; ts := Set{} ;
        var i : int ; i := 1 ; while i <= 5 & i <= s->size() do ( (         var j : int ; j := 0 ; while j <= s->size() - i do ( (     ts := ts->including(s.subrange(j+1,i + j)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ite : OclIterator ; ite := ts->iterator() ;
        var i : int ; i := 0 ; while i < (k)->char2byte() - 1 do ( (     ite.next() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ite.next()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int N=3 ;
  static int M=7 ;
  static void printOriginalMatrix(int a[],int b[],int[][] mat){
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<M ; j++){
        if(mat[i][j]==1)System.out.print(Math.min(a[i],b[j])+" ");
        else System.out.print("0"+" ");
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    int a[]={
      2,1,3 };
      int b[]={
        2,3,0,0,2,0,1 };
        int[][] mat={
          {
            1,0,0,0,1,0,0 },{
              0,0,0,0,0,0,1 },{
                1,1,0,0,0,0,0 }
              };
              printOriginalMatrix(a,b,mat);
            }
          }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 3;
  static   attribute M : int := 7;
  static   operation printOriginalMatrix( a : Sequence(int), b : Sequence(int), mat : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < M do ( (     if (mat[i+1][j+1] = 1) then     OclFile["System.out"].print(Set{a[i+1], b[j+1]}->min() + " ") ; else     OclFile["System.out"].print("0" + " ") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,1,3} ;
     var b : Sequence(int) ; b := Sequence{2,3,0,0,2,0,1} ;
     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,0,0,0,1,0,0},Sequence{0,0,0,0,0,0,1},Sequence{1,1,0,0,0,0,0}} ;
     execute printOriginalMatrix(a, b, mat) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printPattern(int n){
    int i,j ;
    for(i=1 ; i<=n ; i++){
      for(j=1 ; j<2*n ; j++){
        if(j==(n-i+1)|| j==(n+i-1)){
          System.out.print("*");
        }
        else if((i>=4 && i<=n-4)&&(j==n-i+4 || j==n+i-4)){
          System.out.print("*");
        }
        else if(i==n ||(i==n-4 && j>=n-(n-2*4)&& j<=n+n-2*4)){
          System.out.print("*");
        }
        else {
          System.out.print(" "+" ");
        }
      }
      System.out.print("\n");
    }
  }
  public static void main(String[] args){
    int N=9 ;
    printPattern(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printPattern( n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := 1 ; while i <= n do ( (         j := 1 ; while j < 2 * n do ( (     if (j = (n - i + 1) or j = (n + i - 1)) then (     OclFile["System.out"].print("*") ) else     if ((i >= 4 & i <= n - 4) & (j = n - i + 4 or j = n + i - 4)) then (     OclFile["System.out"].print("*") ) else     if (i = n or (i = n - 4 & j >= n - (n - 2 * 4) & j <= n + n - 2 * 4)) then (     OclFile["System.out"].print("*") ) else (     OclFile["System.out"].print(" " + " ") ) ;  ;  )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 9 ;
     execute printPattern(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  class Node implements Comparable<Node>{
    double x,y ;
    public Node(double x,double y){
      this.x=x ;
      this.y=y ;
    }
    @ Override public int compareTo(Node o){
      return Double.compare(Math.atan2(y,x),Math.atan2(o.y,o.x));
    }
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    double[] X=new double[N];
    double[] Y=new double[N];
    Node[] nodes=new Node[N];
    for(int i=0 ; i<N ; ++i){
      X[i]=sc.nextDouble();
      Y[i]=sc.nextDouble();
      nodes[i]=new Node(X[i],Y[i]);
    }
    Arrays.sort(nodes);
    double ans=0 ;
    for(int i=0 ; i<N ; ++i){
      double curx=0,cury=0 ;
      for(int j=0 ; j<N ; ++j){
        curx+=nodes[(i+j)% N] .x ;
        cury+=nodes[(i+j)% N] .y ;
        ans=Math.max(ans,curx*curx+cury*cury);
      }
    }
    ans=Math.sqrt(ans);
    System.out.println(ans);
  }
  static void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
 class Node implements Comparable<Node> {
   attribute x : double;
   static operation newNode( x : double, y : double) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
      operation compareTo( o : Node) : int
  pre: true
  post: true
  activity: (     return (atan2(y, x))->compareTo(atan2(o.y, o.x)) );
}
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var X : Sequence(double) ; X := Integer.subrange(1,N)->collect(0.0) ;
    var Y : Sequence(double) ; Y := Integer.subrange(1,N)->collect(0.0) ;
    var nodes : Sequence(Node) ; nodes := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     X[i+1] := sc.getCurrent()->toReal() ; 
     Y[i+1] := sc.getCurrent()->toReal() ; 
     nodes[i+1] := Node.newNode(X[i+1], Y[i+1]) )  ;     i := i + 1 ) ; 
    nodes := nodes->sort() ; 
    var ans : double ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var curx : double ; curx := 0 ;
    var cury : double ; cury := 0 ;
         var j : int ; j := 0 ; while j < N do ( (     curx := curx+(nodes[(i + j) mod N+1].x) ; 
     cury := cury+(nodes[(i + j) mod N+1].y) ; 
     ans := Set{ans, curx * curx + cury * cury}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    ans := (ans)->sqrt() ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='8')count++;
    }
    System.out.println(Math.min(count,n/11));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = '8') then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{count, n / 11}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(true){
      int n=stdIn.nextInt();
      if(n==0){
        break ;
      }
      long ans=dfs(n);
      if(ans % 10==0){
        ans/=10 ;
      }
      else {
        ans/=10 ;
        ans+=1 ;
      }
      if(ans % 365==0){
        System.out.println(ans/365);
      }
      else {
        System.out.println(ans/365+1);
      }
    }
  }
  public static long dfs(int n){
    if(n==0){
      return 1 ;
    }
    if(n<0){
      return 0 ;
    }
    long ans=0 ;
    ans+=dfs(n-1);
    ans+=dfs(n-2);
    ans+=dfs(n-3);
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var ans : long ; ans := dfs(n) ;
    if (ans mod 10 = 0) then (     ans := ans/(10) ) else (     ans := ans/(10) ; 
     ans := ans+(1) ) ;  
    if (ans mod 365 = 0) then (     OclFile["System.out"].println(ans / 365) ) else (     OclFile["System.out"].println(ans / 365 + 1) ) ;  
 ) );
  static   operation dfs( n : int) : long
  pre: true
  post: true
  activity: (     if (n = 0) then (     return 1 ) else skip ; 
     if (n < 0) then (     return 0 ) else skip ; 
    var ans : long ; ans := 0 ;
    ans := ans+(dfs(n - 1)) ; 
    ans := ans+(dfs(n - 2)) ; 
    ans := ans+(dfs(n - 3)) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  private static int A[]=new int[31];
  public static void main(String[] args)throws Exception {
    A[0]=1 ;
    A[1]=1 ;
    A[2]=A[0]+A[1];
    for(int i=3 ; i<A.length ; i++){
      for(int j=0 ; j<3 ; j++){
        A[i]+=A[i+j-3];
      }
    }
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    for(; ; ){
      int N=Integer.parseInt(br.readLine());
      if(N==0)break ;
      System.out.println(year(N));
    }
  }
  private static int year(int n){
    double year=A[n]/10.0/365 ;
    return(int)Math.ceil(year);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute A : int := Integer.subrange(1,31)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     A[0+1] := 1 ; 
     A[1+1] := 1 ; 
    A[2+1] := A[0+1] + A[1+1] ; 
        var i : int ; i := 3 ; while i < A->size() do ( (         var j : int ; j := 0 ; while j < 3 do ( (     A[i+1] := A[i+1]+(A[i + j - 3+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
      while true do ( (     var N : int ; N := (br.readLine())->toInteger() ;
     if (N = 0) then     break else skip ; 
     OclFile["System.out"].println(year(N)) )  ) ; 
 );
  static   operation year( n : int) : int
  pre: true
  post: true
  activity: (     var year : double ; year := A[n+1] / 10.0 / 365 ;
     return (year)->ceil()->oclAsType(int) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    SC sc=new SC(System.in);
    long[] sum=new long[32];
    sum[0]=1 ;
    sum[1]=1 ;
    sum[2]=2 ;
    for(int i=3 ; i<=31 ; i++){
      sum[i]=sum[i-1]+sum[i-2]+sum[i-3];
    }
    while(true){
      int a=sc.nextInt();
      if(a==0){
        System.exit(0);
      }
      else {
        long yrs=(sum[a]+3649)/3650 ;
        pl(yrs);
      }
    }
  }
  public static void pl(Object o){
    System.out.println(o);
  }
  public static void pl(){
    System.out.println();
  }
  public static void p(Object o){
    System.out.print(o);
  }
  static class SC {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public SC(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        throw new UncheckedIOException(e);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : SC ; sc := SC.newSC(OclFile["System.in"]) ;
     var sum : Sequence(long) ; sum := Integer.subrange(1,32)->collect(0) ;
    sum[0+1] := 1 ; 
    sum[1+1] := 1 ; 
    sum[2+1] := 2 ; 
        var i : int ; i := 3 ; while i <= 31 do ( (     sum[i+1] := sum[i - 1+1] + sum[i - 2+1] + sum[i - 3+1] )  ;     i := i + 1 ) ; 
    while (true) do (     var a : int ; a := sc.nextInt() ;
     if (a = 0) then ( OclProcess.exit(0) ) else (     var yrs : long ; yrs := (sum[a+1] + 3649) / 3650 ;
     execute pl(yrs) ) ) ; 
 );
  static   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation pl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
  static class SC {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newSC( in : OclFile) : SC
  pre: true
  post: true
  activity:
  ( var self : SC ;
    self := createSC();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int n ;
  static long[][] dp=new long[31][31];
  public static void main(String[] args){
    makeDpTable();
    while(read()){
      solve();
    }
  }
  static void makeDpTable(){
    dp[0][0]=1 ;
    for(int i=1 ; i<dp.length ; i++){
      for(int j=1 ; j<dp[0] .length ; j++){
        for(int k=1 ; k<=3 ; k++){
          if(j-k<0)continue ;
          dp[i][j]+=dp[i-1][j-k];
        }
      }
    }
  }
  static boolean read(){
    n=sc.nextInt();
    if(n==0)return false ;
    return true ;
  }
  static void solve(){
    int res=0 ;
    for(int i=1 ; i<=n ; i++){
      res+=dp[i][n];
    }
    System.out.println((res/10-1)/365+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   attribute dp : Sequence(Sequence(long)) := Integer.subrange(1,31)->collect(Integer.subrange(1,31)->collect(0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute makeDpTable() ; 
     while (read()) do (     execute solve() ) );
  static   operation makeDpTable() : void
  pre: true
  post: true
  activity: (     dp[0+1][0+1] := 1 ; 
         var i : int ; i := 1 ; while i < dp->size() do ( (         var j : int ; j := 1 ; while j < dp[0+1]->size() do ( (         var k : int ; k := 1 ; while k <= 3 do ( (     if (j - k < 0) then     continue else skip ; 
     dp[i+1][j+1] := dp[i+1][j+1]+(dp[i - 1+1][j - k+1]) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     return false else skip ; 
     return true );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     res := res+(dp[i+1][n+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println((res / 10 - 1) / 365 + 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public void doIt(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n!=0){
      int[] list=new int[30+1];
      list[0]=1 ;
      for(int i=0 ; i<=30 ; i++){
        for(int j=1 ; j<=3 ; j++){
          if(i-j>=0){
            list[i]+=list[i-j];
          }
        }
      }
      int result=list[n];
      result=result/10 ;
      result=result/365+1 ;
      System.out.println(result);
      n=sc.nextInt();
    }
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     while (n /= 0) do (     var list : Sequence(int) ; list := Integer.subrange(1,30 + 1)->collect(0) ;
     list[0+1] := 1 ; 
        var i : int ; i := 0 ; while i <= 30 do ( (         var j : int ; j := 1 ; while j <= 3 do ( (     if (i - j >= 0) then (     list[i+1] := list[i+1]+(list[i - j+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var result : int ; result := list[n+1] ;
    result := result / 10 ; 
    result := result / 365 + 1 ; 
    OclFile["System.out"].println(result) ; 
    n := sc.getCurrent()->toInteger() ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static void main(String[] args){
    int x=10 ;
    int y=5 ;
    x=x*y ;
    y=x/y ;
    x=x/y ;
    System.out.println("After swaping:"+" x="+x+",y="+y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 10 ;
     var y : int ; y := 5 ;
    x := x * y ; 
    y := x / y ; 
    x := x / y ; 
    OclFile["System.out"].println("After swaping:" + " x=" + x + ",y=" + y) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  Scanner sc=new Scanner(in);
  int max(int[] a){
    int max=Integer.MIN_VALUE ;
    for(int i=0 ; i<a.length ; i++){
      if(max<a[i])max=a[i];
    }
    return max ;
  }
  void run(){
    int n,w ;
    while(true){
      n=sc.nextInt();
      w=sc.nextInt();
      if(n==0 && w==0)break ;
      int[] v=new int[n];
      for(int i=0 ; i<n ; i++)v[i]=sc.nextInt();
      int max=max(v);
      int num=max/w+1 ;
      int[] x=new int[num];
      for(int i : v)x[i/w]++;
      int m=max(x);
      double ans=0 ;
      for(int i=0 ; i<num ; i++){
        ans+=(double)(num-i-1)/(num-1)*x[i]/m ;
      }
      out.println(ans+0.01);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   operation max( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var max : int ; max := -2147483648 ;
         var i : int ; i := 0 ; while i < a->size() do ( (     if (max < a[i+1]) then     max := a[i+1] ; else skip )  ;     i := i + 1 ) ; 
     return max );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ;
    var w : int ;
     while (true) do (     n := sc.getCurrent()->toInteger() ; 
     w := sc.getCurrent()->toInteger() ; 
    if (n = 0 & w = 0) then     break else skip ; 
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     v[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var max : int ; max := max(v) ;
    var num : int ; num := max / w + 1 ;
    var x : Sequence(int) ; x := Integer.subrange(1,num)->collect(0) ;
    for (i : v) do (     x[i / w+1] := x[i / w+1] + 1 ;  ) ; 
    var m : int ; m := max(x) ;
    var ans : double ; ans := 0 ;
        var i : int ; i := 0 ; while i < num do ( (     ans := ans+((num - i - 1)->oclAsType(double) / (num - 1) * x[i+1] / m) )  ;     i := i + 1 ) ; 
    out.println(ans + 0.01) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  int n ;
  int w ;
  int[] h ;
  void run(){
    for(; ; ){
      n=sc.nextInt();
      w=sc.nextInt();
      if((n | w)==0){
        break ;
      }
      h=new int[20];
      int vMax=0 ;
      int hMax=0 ;
      for(int i=0 ; i<n ; i++){
        int v=sc.nextInt();
        h[v/w]++;
        vMax=Math.max(vMax,v);
        hMax=Math.max(hMax,h[v/w]);
      }
      int m=vMax/w+1 ;
      double ans=0 ;
      debug("test");
      for(int i=0 ; i<m ; i++){
        double a=(double)(m-1-i)/(m-1);
        double b=(double)h[i]/hMax ;
        ans+=a*b ;
        debug("i",i);
        debug("a",a);
        debug("b",b);
      }
      ans+=0.01 ;
      println(""+ans);
    }
  }
  void debug(Object...os){
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    try {
    }
    catch(Throwable e){
      e.printStackTrace();
    }
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   attribute n : int;
   attribute w : int;
   attribute h : Sequence(int);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     n := sc.getCurrent()->toInteger() ; 
     w := sc.getCurrent()->toInteger() ; 
    if ((MathLib.bitwiseOr(n,w)) = 0) then (     break ) else skip ; 
    h := Integer.subrange(1,20)->collect(0) ; 
    var vMax : int ; vMax := 0 ;
    var hMax : int ; hMax := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := sc.getCurrent()->toInteger() ;
     h[v / w+1] := h[v / w+1] + 1 ; 
     vMax := Set{vMax, v}->max() ; 
     hMax := Set{hMax, h[v / w+1]}->max() )  ;     i := i + 1 ) ; 
    var m : int ; m := vMax / w + 1 ;
    var ans : double ; ans := 0 ;
    execute debug("test") ; 
        var i : int ; i := 0 ; while i < m do ( (     var a : double ; a := (m - 1 - i)->oclAsType(double) / (m - 1) ;
     var b : double ; b := h[i+1]->oclAsType(double) / hMax ;
    ans := ans+(a * b) ; 
    execute debug("i", i) ; 
    execute debug("a", a) ; 
    execute debug("b", b) ; 
 )  ;     i := i + 1 ) ; 
    ans := ans+(0.01) ; 
    execute println("" + ans) ; 
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: skip;
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try skip   catch (e : OclException) do (     e.printStackTrace() )
     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,w,v,val,h ;
    double ink ;
    while(true){
      h=0 ;
      ink=0.01 ;
      n=sc.nextInt();
      w=sc.nextInt();
      if(n==0)break ;
      List<Integer>histogram=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        v=sc.nextInt();
        if(v/w>histogram.size()-1){
          while(v/w>histogram.size()-1)histogram.add(0);
        }
        val=histogram.get(v/w)+1 ;
        if(val>h)h=val ;
        histogram.set(v/w,val);
      }
      double brightness=histogram.size()-1 ;
      for(int i=0 ; i<histogram.size(); i++){
        ink+=(histogram.get(i)/(double)h)*((brightness-i)/brightness);
      }
      System.out.println(ink);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var w : int ;
    var v : int ;
    var val : int ;
    var h : int ;
     var ink : double ;
     while (true) do (     h := 0 ; 
     ink := 0.01 ; 
    n := sc.getCurrent()->toInteger() ; 
    w := sc.getCurrent()->toInteger() ; 
    if (n = 0) then     break else skip ; 
    var histogram : Sequence(int) ; histogram := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     v := sc.getCurrent()->toInteger() ; 
     if (v / w > histogram->size() - 1) then (     while (v / w > histogram->size() - 1) do     histogram := histogram->including(0) ; ) else skip ; 
    val := histogram->at(v / w+1) + 1 ; 
    if (val > h) then     h := val ; else skip ; 
    histogram := histogram.setAt(v / w+1,val) ; 
 )  ;     i := i + 1 ) ; 
    var brightness : double ; brightness := histogram->size() - 1 ;
        var i : int ; i := 0 ; while i < histogram->size() do ( (     ink := ink+((histogram->at(i+1) / h->oclAsType(double)) * ((brightness - i) / brightness)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ink) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void segregate0and1(int arr[]){
    int type0=0 ;
    int type1=arr.length-1 ;
    while(type0<type1){
      if(arr[type0]==1){
        arr[type1]=arr[type1]+arr[type0];
        arr[type0]=arr[type1]-arr[type0];
        arr[type1]=arr[type1]-arr[type0];
        type1--;
      }
      else {
        type0++;
      }
    }
  }
  public static void main(String[] args){
    int[] array={
      0,1,0,1,1,1 };
      segregate0and1(array);
      for(int a : array){
        System.out.print(a+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation segregate0and1( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var type0 : int ; type0 := 0 ;
     var type1 : int ; type1 := arr->size() - 1 ;
     while (type0 < type1) do (     if (arr[type0+1] = 1) then (     arr[type1+1] := arr[type1+1] + arr[type0+1] ; 
     arr[type0+1] := arr[type1+1] - arr[type0+1] ; 
     arr[type1+1] := arr[type1+1] - arr[type0+1] ; 
     type1 := type1 - 1 ) else (     type0 := type0 + 1 ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Sequence{0,1,0,1,1,1} ;
     execute segregate0and1(array) ; 
     for (a : array) do ( (     OclFile["System.out"].print(a + " ") )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import java.io.*;
public class Hello {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int length=in.nextInt();
    String s=in.next();
    int c=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='8'){
        c++;
      }
    }
    int div=length/11 ;
    pw.println(Math.min(c,div));
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hello {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var length : int ; length := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '8') then (     c := c + 1 ) else skip )  ;     i := i + 1 ) ; 
    var div : int ; div := length / 11 ;
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    List<Xy>l=new LinkedList<>();
    for(int i=0 ; i<n ; i++){
      l.add(new Xy(sc.nextInt(),sc.nextInt()));
    }
    l.sort(Xy :: hencom);
    long max2=0 ;
    for(int i=0 ; i<n ; i++){
      long rx=0 ;
      long ry=0 ;
      for(int j=0 ; j<n ; j++){
        rx+=l.get(j).x ;
        ry+=l.get(j).y ;
        max2=Math.max(rx*rx+ry*ry,max2);
      }
      Xy r=l.remove(0);
      l.add(r);
    }
    System.out.println(Math.sqrt(max2));
  }
  static class Xy {
    int x ;
    int y ;
    Xy(int x,int y){
      this.x=x ;
      this.y=y ;
    }
    public static int hencom(Xy s1,Xy s2){
      return(int)Math.signum(Math.atan2(s1.y,s1.x)-Math.atan2(s2.y,s2.x));
    }
    public String toString(){
      return "["+x+","+y+"] " ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var l : Sequence(Xy) ; l := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     l := l->including(Xy.newXy(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    l := l.sort(lambda _pars : OclAny in Xy.newXy().hencom(_pars)) ; 
    var max2 : long ; max2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var rx : long ; rx := 0 ;
     var ry : long ; ry := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     rx := rx+(l->at(j+1).x) ; 
     ry := ry+(l->at(j+1).y) ; 
     max2 := Set{rx * rx + ry * ry, max2}->max() )  ;     j := j + 1 ) ; 
    var r : Xy ; r := l->at(0+1) ;
    l := l->including(r) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((max2)->sqrt()) ; 
 );
  static class Xy {
   attribute x : int;
   attribute y : int;
   static operation newXy( x : int, y : int) : Xy
  pre: true
  post: true
  activity:
  ( var self : Xy ;
    self := createXy();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
  static   operation hencom( s1 : Xy, s2 : Xy) : int
  pre: true
  post: true
  activity: (     return signum(atan2(s1.y, s1.x) - atan2(s2.y, s2.x))->oclAsType(int) );
   operation toString() : String
  pre: true
  post: true
  activity: (     return "[" + x + "," + y + "] " );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static boolean solve(){
    int n=in.nextInt();
    int w=in.nextInt();
    if(n+w==0)return false ;
    int[] v=new int[n];
    int[] c=new int[120];
    for(int i=0 ; i<n ; i++){
      v[i]=in.nextInt();
      c[v[i]/w]++;
    }
    double max=0,idx=0 ;
    for(int i=0 ; i<120 ; i++){
      if(c[i]>0)idx=i ;
      max=Math.max(max,c[i]);
    }
    double ans=0 ;
    for(int i=0 ; i<120 ; i++){
      ans+=c[i]/max*(1-i/idx);
    }
    out.printf("%.6f\n",ans+0.01);
    return true ;
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    while(solve());
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var w : int ; w := in.getCurrent()->toInteger() ;
    if (n + w = 0) then     return false else skip ; 
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,120)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     v[i+1] := in.getCurrent()->toInteger() ; 
     c[v[i+1] / w+1] := c[v[i+1] / w+1] + 1 )  ;     i := i + 1 ) ; 
    var max : double ; max := 0 ;
    var idx : double ; idx := 0 ;
        var i : int ; i := 0 ; while i < 120 do ( (     if (c[i+1] > 0) then     idx := i ; else skip ; 
     max := Set{max, c[i+1]}->max() )  ;     i := i + 1 ) ; 
    var ans : double ; ans := 0 ;
        var i : int ; i := 0 ; while i < 120 do ( (     ans := ans+(c[i+1] / max * (1 - i / idx)) )  ;     i := i + 1 ) ; 
    skip ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    while (solve()) do  ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
class Main {
  public static Scanner sc=new Scanner(in);
  public static Random rand=new Random();
  public void run(){
    while(true){
      int n=sc.nextInt();
      int w=sc.nextInt();
      if(n==0)return ;
      int[] v=nextIntArray(n);
      int[] dat=new int[100/w+1];
      for(int i=0 ; i<v.length ; i++){
        dat[v[i]/w]++;
      }
      int max=0,l=0 ;
      for(int i=0 ; i<dat.length ; i++){
        if(dat[i]>max)max=dat[i];
        if(dat[i]!=0)l=i ;
      }
      double res=0 ;
      for(int i=0 ; i<l ; i++){
        res+=(double)dat[i]/max*(l-i)/(l);
      }
      res+=0.01 ;
      ln(res);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  public int[] nextIntArray(int n){
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=sc.nextInt();
    }
    return res ;
  }
  public static void pr(Object o){
    out.print(o);
  }
  public static void ln(Object o){
    out.println(o);
  }
  public static void ln(){
    out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(in);
  static   attribute rand : OclRandom := OclRandom.newOclRandom();
   operation run() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    if (n = 0) then     return else skip ; 
    var v : Sequence(int) ; v := nextIntArray(n) ;
    var dat : Sequence(int) ; dat := Integer.subrange(1,100 / w + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < v->size() do ( (     dat[v[i+1] / w+1] := dat[v[i+1] / w+1] + 1 )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var l : int ; l := 0 ;
        var i : int ; i := 0 ; while i < dat->size() do ( (     if (dat[i+1] > max) then     max := dat[i+1] ; else skip ; 
     if (dat[i+1] /= 0) then     l := i ; else skip )  ;     i := i + 1 ) ; 
    var res : double ; res := 0 ;
        var i : int ; i := 0 ; while i < l do ( (     res := res+(dat[i+1]->oclAsType(double) / max * (l - i) / (l)) )  ;     i := i + 1 ) ; 
    res := res+(0.01) ; 
    execute ln(res) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return res );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     out.println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=1000000 ;
  static boolean[] prime=new boolean[MAX];
  static void SieveOfEratosthenes(){
    for(int i=0 ; i<MAX ; i++)prime[i]=true ;
    for(int p=2 ; p*p<MAX ; p++){
      if(prime[p]){
        for(int i=p*p ; i<MAX ; i+=p)prime[i]=false ;
      }
    }
  }
  static int sumPrime(int k){
    SieveOfEratosthenes();
    Vector<Integer>v=new Vector<>();
    for(int i=2 ; i<MAX ; i++){
      if(prime[i])v.add(i);
    }
    int sum=0 ;
    int skip=(k*(k-1))/2 ;
    while(k>0){
      sum+=v.get(skip);
      skip++;
      k--;
    }
    return sum ;
  }
  public static void main(String[] args){
    int k=3 ;
    System.out.println(sumPrime(k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 1000000;
  static   attribute prime : Sequence(boolean) := Integer.subrange(1,MAX)->collect(false);
  static   operation SieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < MAX do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
         var p : int ; p := 2 ; while p * p < MAX do ( (     if (prime[p+1]) then (         var i : int ; i := p * p ; while i < MAX do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation sumPrime( k : int) : int
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes() ; 
     var v : Sequence(int) ; v := Sequence{} ;
        var i : int ; i := 2 ; while i < MAX do ( (     if (prime[i+1]) then     v := v->including(i) ; else skip )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var skip : int ; skip := (k * (k - 1)) / 2 ;
    while (k > 0) do (     sum := sum+(v->at(skip+1)) ; 
     skip := skip + 1 ; 
     k := k - 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 3 ;
     OclFile["System.out"].println(sumPrime(k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.*;
import java.io.*;
public class a171 {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    while(t>0){
      int n=Integer.parseInt(br.readLine());
      String[] s=br.readLine().split(" ");
      int[] arr=new int[n];
      long tsum=0 ;
      for(int i=0 ; i<n ; i++){
        arr[i]=Integer.parseInt(s[i]);
        tsum+=arr[i];
      }
      long sum=0 ;
      long ans=-1 ;
      for(int i=0 ; i<n-1 ; i++){
        if(sum+arr[i]>=0){
          sum+=arr[i];
          ans=Math.max(ans,sum);
        }
        else {
          sum=0 ;
        }
      }
      sum=0 ;
      for(int i=1 ; i<n ; i++){
        if(sum+arr[i]>=0){
          sum+=arr[i];
          ans=Math.max(ans,sum);
        }
        else {
          sum=0 ;
        }
      }
      if(tsum>ans){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class a171 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
     while (t > 0) do (     var n : int ; n := (br.readLine())->toInteger() ;
     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var tsum : long ; tsum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (s[i+1])->toInteger() ; 
     tsum := tsum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    var ans : long ; ans := -1 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (sum + arr[i+1] >= 0) then (     sum := sum+(arr[i+1]) ; 
     ans := Set{ans, sum}->max() ) else (     sum := 0 ) )  ;     i := i + 1 ) ; 
    sum := 0 ; 
        var i : int ; i := 1 ; while i < n do ( (     if (sum + arr[i+1] >= 0) then (     sum := sum+(arr[i+1]) ; 
     ans := Set{ans, sum}->max() ) else (     sum := 0 ) )  ;     i := i + 1 ) ; 
    if (tsum > ans) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cupcakes {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t,j,n,i,c,p,k ;
    long a[],s1,s2 ;
    t=sc.nextInt();
    for(j=1 ; j<=t ; j++){
      n=sc.nextInt();
      a=new long[n];
      s1=0 ;
      s2=0 ;
      c=0 ;
      p=-1 ;
      for(i=0 ; i<n ; i++)a[i]=sc.nextLong();
      for(i=0 ; i<n ; i++){
        if(a[i]>=0 && p==-1)p=i ;
        s1+=a[i];
      }
      if(p==-1){
        System.out.println("NO");
        continue ;
      }
      for(i=p ; i<n ; i++){
        if(i>0 && a[i]>0 && a[i-1]<0){
          if(s2<=0){
            p=i ;
            s2=0 ;
          }
        }
        s2+=a[i];
        if(s2>=s1)break ;
      }
      if(i==n ||(p==0 && i==n-1))System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cupcakes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ;
    var j : int ;
    var n : int ;
    var i : int ;
    var c : int ;
    var p : int ;
    var k : int ;
    var a : Sequence(void) ;
    var s1 : long ;
    var s2 : long ;
    t := sc.getCurrent()->toInteger() ; 
        j := 1 ; while j <= t do ( (     n := sc.getCurrent()->toInteger() ; 
     a := Integer.subrange(1,n)->collect(0) ; 
    s1 := 0 ; 
    s2 := 0 ; 
    c := 0 ; 
    p := -1 ; 
        i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     if (a[i+1] >= 0 & p = -1) then     p := i ; else skip ; 
     s1 := s1+(a[i+1]) )  ;     i := i + 1 ) ; 
    if (p = -1) then (     OclFile["System.out"].println("NO") ; 
     continue ) else skip ; 
        i := p ; while i < n do ( (     if (i > 0 & a[i+1] > 0 & a[i - 1+1] < 0) then (     if (s2 <= 0) then (     p := i ; 
     s2 := 0 ) else skip ) else skip ; 
     s2 := s2+(a[i+1]) ; 
     if (s2 >= s1) then     break else skip )  ;     i := i + 1 ) ; 
    if (i = n or (p = 0 & i = n - 1)) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0){
      int n=sc.nextInt();
      int[] table=new int[n];
      for(int i=0 ; i<n ; i++){
        table[i]=sc.nextInt();
      }
      boolean flag=false ;
      long sum=0 ;
      for(int i=0 ; i<n ; i++){
        sum+=(long)table[i];
        if(sum<=0){
          flag=true ;
        }
      }
      if(flag){
        System.out.println("NO");
        continue ;
      }
      sum=0 ;
      for(int i=n-1 ; i>=0 ; i--){
        sum+=(long)table[i];
        if(sum<=0){
          flag=true ;
        }
      }
      if(flag){
        System.out.println("NO");
        continue ;
      }
      System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var table : Sequence(int) ; table := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     table[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := false ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(table[i+1]->oclAsType(long)) ; 
     if (sum <= 0) then (     flag := true ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then (     OclFile["System.out"].println("NO") ; 
     continue ) else skip ; 
    sum := 0 ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     sum := sum+(table[i+1]->oclAsType(long)) ; 
     if (sum <= 0) then (     flag := true ) else skip )  ;     i := i - 1 ) ; 
    if (flag) then (     OclFile["System.out"].println("NO") ; 
     continue ) else skip ; 
    OclFile["System.out"].println("YES") ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Solution {
  static MyScanner str=new MyScanner();
  public static void main(String[] args)throws IOException {
    long T=l();
    while(T-->0){
      solve();
    }
  }
  static void solve()throws IOException {
    int n=i();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=i();
    }
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=a[i];
      if(sum<=0){
        System.out.println("NO");
        return ;
      }
    }
    sum=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      sum+=a[i];
      if(sum<=0){
        System.out.println("NO");
        return ;
      }
    }
    System.out.println("YES");
  }
  public static int i()throws IOException {
    return str.nextInt();
  }
  public static long l()throws IOException {
    return str.nextLong();
  }
  public static double d()throws IOException {
    return str.nextDouble();
  }
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute str : MyScanner := MyScanner.newMyScanner();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : long ; T := l() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := i() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := i() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(a[i+1]) ; 
     if (sum <= 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    sum := 0 ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     sum := sum+(a[i+1]) ; 
     if (sum <= 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
  static   operation i() : int
  pre: true
  post: true
  activity: (     return str.nextInt() );
  static   operation l() : long
  pre: true
  post: true
  activity: (     return str.nextLong() );
  static   operation d() : double
  pre: true
  post: true
  activity: (     return str.nextDouble() );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=1000005 ;
  static Vector<Boolean>prime=new Vector<>(MAX);
  static void vecIni(){
    for(int i=0 ; i<MAX ; i++){
      prime.add(i,true);
    }
  }
  static void seive(int N){
    prime.add(0,false);
    prime.add(1,false);
    for(int i=2 ; i<=N ; i++){
      if(prime.get(i)){
        for(int j=2 ; i*j<=N ; j++){
          prime.add(i*j,false);
        }
      }
    }
  }
  static int countLogNeeded(int N){
    int count=0 ;
    seive(N);
    for(int i=1 ; i<=N ; i++){
      if(prime.get(i)){
        count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    vecIni();
    int N=6 ;
    System.out.println(countLogNeeded(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 1000005;
  static   attribute prime : Sequence(Boolean) := Sequence{};
  static   operation vecIni() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < MAX do ( (     prime := prime.insertAt(i+1,true) )  ;     i := i + 1 ) );
  static   operation seive( N : int) : void
  pre: true
  post: true
  activity: (     prime := prime.insertAt(0+1,false) ; 
     prime := prime.insertAt(1+1,false) ; 
         var i : int ; i := 2 ; while i <= N do ( (     if (prime->at(i+1)) then (         var j : int ; j := 2 ; while i * j <= N do ( (     prime := prime.insertAt(i * j+1,false) )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) );
  static   operation countLogNeeded( N : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     execute seive(N) ; 
         var i : int ; i := 1 ; while i <= N do ( (     if (prime->at(i+1)) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute vecIni() ; 
     var N : int ; N := 6 ;
     OclFile["System.out"].println(countLogNeeded(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class New_Year_and_Counting_Cards {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String name=input.next();
    int count=0 ;
    for(int i=0 ; i<name.length(); i++){
      char ch=name.charAt(i);
      if(ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u' || ch=='1' || ch=='3' || ch=='5' || ch=='7' || ch=='9'){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class New_Year_and_Counting_Cards {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var name : String ; name := input.getCurrent() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < name->size() do ( (     var ch : String ; ch := name->at(i+1) ;
     if (ch = 'a' or ch = 'e' or ch = 'i' or ch = 'o' or ch = 'u' or ch = '1' or ch = '3' or ch = '5' or ch = '7' or ch = '9') then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Test {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String str=sc.next();
    int eightCount=0 ;
    for(int i=0 ; i<n ; i++){
      int val=Character.getNumericValue(str.charAt(i));
      if(val==8)eightCount+=1 ;
    }
    int counter=0 ;
    while(eightCount-->0 && n>=11){
      n-=11 ;
      counter+=1 ;
    }
    System.out.println(counter);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var str : String ; str := sc.getCurrent() ;
    var eightCount : int ; eightCount := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var val : int ; val := ("" + str->at(i+1))->toInteger() ;
     if (val = 8) then     eightCount := eightCount+(1) ; else skip )  ;     i := i + 1 ) ; 
    var counter : int ; counter := 0 ;
        while (eightCount > 0 & n >= 11) do (    skip ; (     n := n-(11) ; 
     counter := counter+(1) ) ;  ) ;  
    OclFile["System.out"].println(counter) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Partition {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String x=input.next();
    x=x.replaceAll("[a,e,i,o,u] ","a");
    x=x.replaceAll("[1,3,5,7,9] ","1");
    int c=0 ;
    for(int i=0 ; i<x.length(); i++){
      if(x.charAt(i)=='a'){
        c++;
      }
      else if(x.charAt(i)=='1'){
        c++;
      }
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Partition {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : String ; x := input.getCurrent() ;
    x := x.replaceAllMatches("[a,e,i,o,u] ", "a" ) ; 
    x := x.replaceAllMatches("[1,3,5,7,9] ", "1" ) ; 
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < x->size() do ( (     if (x->at(i+1) = 'a') then (     c := c + 1 ) else     if (x->at(i+1) = '1') then (     c := c + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public List<String>topKFrequent(String[] words,int k){
    Map<String,Integer>count=new HashMap();
    for(String word : words){
      count.put(word,count.getOrDefault(word,0)+1);
    }
    PriorityQueue<String>heap=new PriorityQueue<String>((w1,w2)->count.get(w1).equals(count.get(w2))? w2.compareTo(w1): count.get(w1)-count.get(w2));
    for(String word : count.keySet()){
      heap.offer(word);
      if(heap.size()>k)heap.poll();
    }
    List<String>ans=new ArrayList();
    while(! heap.isEmpty())ans.add(heap.poll());
    Collections.reverse(ans);
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation topKFrequent( words : Sequence(String), k : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var count : Map(String,int) ; count := Map{} ;
     for (word : words) do ( (     count := count->union(Map{word |-> (if count->keys()->contains(word) then count->at(word) else 0 endif) + 1}) )  ) ; 
    var heap : Sequence(String) ; heap := Sequence{}->union(lambda (w1 , w2) : OclAny in if count->at(w1) = count->at(w2) then w2->compareTo(w1) else count->at(w1) - count->at(w2) endif) ;
    for (word : count->keys()) do ( (     heap := heap->including(word) ; 
     if (heap->size() > k) then     heap := heap->sort()->tail() ; else skip )  ) ; 
    var ans : Sequence(String) ; ans := Sequence{} ;
    while (not(heap->isEmpty())) do     ans := ans->including(heap->min()) ; ; 
    ans := ans->reverse() ; 
    return ans 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewYearAndCountingCards {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String s=scan.nextLine();
    int c=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='a' || s.charAt(i)=='e' || s.charAt(i)=='i' || s.charAt(i)=='o' || s.charAt(i)=='u' || s.charAt(i)=='1' || s.charAt(i)=='3' || s.charAt(i)=='5' || s.charAt(i)=='7' || s.charAt(i)=='9'){
        c++;
      }
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewYearAndCountingCards {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scan.nextLine() ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'a' or s->at(i+1) = 'e' or s->at(i+1) = 'i' or s->at(i+1) = 'o' or s->at(i+1) = 'u' or s->at(i+1) = '1' or s->at(i+1) = '3' or s->at(i+1) = '5' or s->at(i+1) = '7' or s->at(i+1) = '9') then (     c := c + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CountCards {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    in.close();
    int c=0,i ;
    for(i=0 ; i<s.length(); i++){
      char v=s.charAt(i);
      if(v=='a' || v=='e' || v=='i' || v=='o' || v=='u' ||(Character.isDigit(v)&& Integer.parseInt(String.valueOf(v))% 2!=0)){
        c++;
      }
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CountCards {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
    skip ; 
    var c : int ; c := 0 ;
    var i : int ;
        i := 0 ; while i < s->size() do ( (     var v : String ; v := s->at(i+1) ;
     if (v = 'a' or v = 'e' or v = 'i' or v = 'o' or v = 'u' or ((v + "")->isMatch("[0-9]") & (((v) + ""))->toInteger() mod 2 /= 0)) then (     c := c + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class cf908a {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] arr=sc.next().toCharArray();
    sc.close();
    HashSet<Character>hs=new HashSet<>();
    hs.add('a');
    hs.add('e');
    hs.add('i');
    hs.add('o');
    hs.add('u');
    hs.add('1');
    hs.add('3');
    hs.add('5');
    hs.add('7');
    hs.add('9');
    int ans=0 ;
    for(int i=0 ; i<arr.length ; i++){
      ans+=hs.contains(arr[i])? 1 : 0 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf908a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
    skip ; 
    var hs : Set(String) ; hs := Set{} ;
    hs := hs->including('a') ; 
    hs := hs->including('e') ; 
    hs := hs->including('i') ; 
    hs := hs->including('o') ; 
    hs := hs->including('u') ; 
    hs := hs->including('1') ; 
    hs := hs->including('3') ; 
    hs := hs->including('5') ; 
    hs := hs->including('7') ; 
    hs := hs->including('9') ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     ans := ans+(if hs->includes(arr[i+1]) then 1 else 0 endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<HashMap<Integer,Integer>>graph=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      graph.add(new HashMap<>());
    }
    for(int i=0 ; i<n ; i++){
      int from=sc.nextInt();
      int count=sc.nextInt();
      for(int j=0 ; j<count ; j++){
        graph.get(from).put(sc.nextInt(),sc.nextInt());
      }
    }
    int[] costs=new int[n];
    Arrays.fill(costs,Integer.MAX_VALUE);
    PriorityQueue<Path>queue=new PriorityQueue<>();
    queue.add(new Path(0,0));
    while(queue.size()>0){
      Path p=queue.poll();
      if(costs[p.idx]<=p.value){
        continue ;
      }
      costs[p.idx]=p.value ;
      for(Map.Entry<Integer,Integer>entry : graph.get(p.idx).entrySet()){
        queue.add(new Path(entry.getKey(),entry.getValue()+p.value));
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      sb.append(i).append(" ").append(costs[i]).append("\n");
    }
    System.out.print(sb);
  }
  static class Path implements Comparable<Path>{
    int idx ;
    int value ;
    public Path(int idx,int value){
      this.idx=idx ;
      this.value=value ;
    }
    public int compareTo(Path another){
      return value-another.value ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var graph : Sequence(Map(int,int)) ; graph := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     graph := graph->including(Map{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var from : int ; from := sc.getCurrent()->toInteger() ;
     var count : int ; count := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < count do ( (     graph := graph->at(from+1)->union(Map{sc.getCurrent()->toInteger() |-> sc.getCurrent()->toInteger()}) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var costs : Sequence(int) ; costs := Integer.subrange(1,n)->collect(0) ;
    costs := costs->collect(2147483647) ; 
    var queue : Sequence(String) ; queue := Sequence{} ;
    queue := queue->including(String(0, 0)) ; 
    while (queue->size() > 0) do (     var p : String ; p := queue->min() ;
     if (costs[p.idx+1] <= p.value) then (     continue ) else skip ; 
     costs[p.idx+1] := p.value ; 
     for (entry : graph->at(p.idx+1)->asSet()) do ( (     queue := queue->including(String(entry.getKey(), entry.getValue() + p.value)) )  ) ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     sb := sb + StringLib.newString(i) + StringLib.newString(" ") + StringLib.newString(costs[i+1]) + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
  static class Path implements Comparable<String> {
   attribute idx : int;
   attribute value : int;
   static operation newPath( idx : int, value : int) : Path
  pre: true
  post: true
  activity:
  ( var self : Path ;
    self := createPath();
    self.initialise(idx, value);
    return self );
  operation initialise( idx : int, value : int) : void
  pre: true  post: true
  activity: (     self.idx := idx ; 
     self.value := value );
   operation compareTo( another : String) : int
  pre: true
  post: true
  activity: (     return value - another.value );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TextVolume {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.nextLine()),c=0,max=0 ;
    String[] s=sc.nextLine().split("\\s");
    for(int i=0 ; i<s.length ; i++){
      for(int j=0 ; j<s[i] .length(); j++){
        if(Character.isUpperCase(s[i] .charAt(j))){
          c++;
        }
      }
      if(c>max){
        max=c ;
      }
      c=0 ;
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class TextVolume {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.nextLine())->toInteger() ;
    var c : int ; c := 0 ;
    var max : int ; max := 0 ;
    var s : Sequence(String) ; s := sc.nextLine()->split("\\s") ;
        var i : int ; i := 0 ; while i < s->size() do ( (         var j : int ; j := 0 ; while j < s[i+1]->size() do ( (     if ((s[i+1]->at(j+1)->toUpperCase() = s[i+1]->at(j+1))) then (     c := c + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (c > max) then (     max := c ) else skip ; 
     c := 0 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Ishu {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n,i,ans=0,temp=0 ;
    String str ;
    n=scan.nextInt();
    scan.nextLine();
    str=scan.nextLine();
    for(i=0 ; i<n ; ++i){
      if(str.charAt(i)>='A' && str.charAt(i)<='Z')++temp ;
      else if(str.charAt(i)==' '){
        if(ans==0)ans=temp ;
        else if(ans<temp)ans=temp ;
        temp=0 ;
      }
      if(i==n-1){
        if(ans==0)ans=temp ;
        else if(ans<temp)ans=temp ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ishu {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var i : int ;
    var ans : int ; ans := 0 ;
    var temp : int ; temp := 0 ;
    var str : String ;
    n := scan.getCurrent()->toInteger() ; 
    skip ; 
    str := scan.nextLine() ; 
        i := 0 ; while i < n do ( (     if (str->at(i+1) >= 'A' & str->at(i+1) <= 'Z') then     temp := temp + 1 else     if (str->at(i+1) = ' ') then (     if (ans = 0) then     ans := temp else     if (ans < temp) then     ans := temp ; else skip ; ;  
     temp := 0 ) else skip ; ;  
     if (i = n - 1) then (     if (ans = 0) then     ans := temp ; else     if (ans < temp) then     ans := temp ; else skip ; ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Ex3 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int q=in.nextInt();
    for(int t=0 ; t<q ; t++){
      int x=in.nextInt();
      int arr[]=new int[x];
      for(int i=0 ; i<x ; i++){
        arr[i]=in.nextInt();
      }
      for(int i=0 ; i<x/2 ; i++){
        System.out.print(arr[i]+" "+arr[(x-1)-i]+" ");
      }
      if(x % 2!=0){
        System.out.print(arr[(x/2)]+" ");
      }
      System.out.println();
    }
  }
  public class ListNode<E>{
    private E value ;
    private ListNode next ;
    public ListNode(E newVal,ListNode<E>newNext){
      value=newVal ;
      next=newNext ;
    }
    public E getValue(){
      return value ;
    }
    public ListNode<E>getNext(){
      return next ;
    }
    public void setValue(E newValue){
      value=newValue ;
    }
    public void setNext(ListNode<E>newNext){
      next=newNext ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ex3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < q do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,x)->collect(0) ;
        var i : int ; i := 0 ; while i < x do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < x / 2 do ( (     OclFile["System.out"].print(arr[i+1] + " " + arr[(x - 1) - i+1] + " ") )  ;     i := i + 1 ) ; 
    if (x mod 2 /= 0) then (     OclFile["System.out"].print(arr[(x / 2)+1] + " ") ) else skip ; 
    OclFile["System.out"].println() ; 
 )  ;     t := t + 1 ) );
 class ListNode<E> {
   attribute value : E;
   attribute next : ListNode;
   static operation newListNode( newVal : E, newNext : ListNode<E>) : ListNode
  pre: true
  post: true
  activity:
  ( var self : ListNode ;
    self := createListNode();
    self.initialise(newVal, newNext);
    return self );
  operation initialise( newVal : E, newNext : ListNode<E>) : void
  pre: true  post: true
  activity: (     value := newVal ; 
     next := newNext );
   operation getValue() : E
  pre: true
  post: true
  activity: (     return value );
   operation getNext() : ListNode<E>
  pre: true
  post: true
  activity: (     return next );
   operation setValue( newValue : E) : void
  pre: true
  post: true
  activity: (     value := newValue );
   operation setNext( newNext : ListNode<E>) : void
  pre: true
  post: true
  activity: (     next := newNext );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.Math ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    if(n<11){
      System.out.println("0");
      return ;
    }
    input.nextLine();
    String[] digits=input.nextLine().split("");
    int total=digits.length ;
    int eights=0 ;
    for(String s : digits)if(s.equals("8"))eights++;
    int result=Math.min(eights,total/11);
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    if (n < 11) then (     OclFile["System.out"].println("0") ; 
     return ) else skip ; 
    skip ; 
    var digits : Sequence(String) ; digits := input.nextLine()->split("") ;
    var total : int ; total := digits->size() ;
    var eights : int ; eights := 0 ;
    for (s : digits) do (     if (s = "8") then     eights := eights + 1 ; else skip ;  ) ; 
    var result : int ; result := Set{eights, total / 11}->min() ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class SpeedRun {
  static int T ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    StringTokenizer st=new StringTokenizer(br.readLine());
    T=Integer.parseInt(st.nextToken());
    for(int t=0 ; t<T ; t++){
      st=new StringTokenizer(br.readLine());
      int N=Integer.parseInt(st.nextToken());
      int[] arr=new int[N];
      ArrayList<Integer>out=new ArrayList<>();
      st=new StringTokenizer(br.readLine());
      for(int i=0 ; i<N ; i++){
        arr[i]=Integer.parseInt(st.nextToken());
      }
      int r=N-1 ;
      int l=0 ;
      while(l<=r){
        out.add(arr[l++]);
        if(l-1==r)continue ;
        out.add(arr[r--]);
      }
      for(int i : out)pw.print(i+" ");
      pw.println();
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class SpeedRun {
  static   attribute T : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    T := (st.next())->toInteger() ; 
        var t : int ; t := 0 ; while t < T do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var N : int ; N := (st.next())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
    var out : Sequence(int) ; out := Sequence{} ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    var r : int ; r := N - 1 ;
    var l : int ; l := 0 ;
    while (l <= r) do (     out := out->including(arr[l+1]) ; 
     if (l - 1 = r) then     continue else skip ; 
     out := out->including(arr[r+1]) ) ; 
    for (i : out) do (     skip ;  ) ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int tests=scanner.nextInt();
    for(int test=0 ; test<tests ; test++)solve(scanner);
  }
  private static void solve(Scanner scanner){
    int number=scanner.nextInt();
    int[] arr=new int[number];
    for(int i=0 ; i<number ; i++){
      arr[i]=scanner.nextInt();
    }
    int lo=0,hi=number-1 ;
    System.out.println();
    while(lo<hi){
      System.out.print(arr[lo++]+" ");
      System.out.print(arr[hi--]+" ");
    }
    if(lo==hi)System.out.print(arr[lo]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tests : int ; tests := scanner.getCurrent()->toInteger() ;
         var test : int ; test := 0 ; while test < tests do (     execute solve(scanner) ;  ;     test := test + 1 ) );
  static   operation solve( scanner : OclFile) : void
  pre: true
  post: true
  activity: (     var number : int ; number := scanner.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,number)->collect(0) ;
        var i : int ; i := 0 ; while i < number do ( (     arr[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var lo : int ; lo := 0 ;
    var hi : int ; hi := number - 1 ;
    OclFile["System.out"].println() ; 
    while (lo < hi) do (     OclFile["System.out"].print(arr[lo+1] + " ") ; 
     OclFile["System.out"].print(arr[hi+1] + " ") ) ; 
    if (lo = hi) then     OclFile["System.out"].print(arr[lo+1]) ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static HashMap<String,Long>dic=new HashMap<>();
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long x=sc.nextLong();
    long layer=(long)(4*Math.pow(2,n)-3);
    dic.put(Long.toString(1),1L);
    long ans=helper(layer,x);
    System.out.println(ans);
  }
  static public long helper(long layer,long x){
    String k=Long.toString(layer)+"*"+Long.toString(x);
    long ans=0 ;
    if(dic.containsKey(k))return dic.get(k);
    if(x<=0 || layer==0)return 0 ;
    if(layer==1)return 1 ;
    if(x>layer)x=layer ;
    if(2*x+1<=layer){
      ans+=helper((layer-3)/2,x-1);
    }
    else {
      ans+=helper((layer-3)/2,(layer-3)/2);
      ans+=1 ;
      if(x==layer)x--;
      ans+=helper((layer-3)/2,x-(layer+1)/2);
    }
    dic.put(k,ans);
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dic : Map(String,long) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : long ; x := sc.getCurrent()->toLong() ;
    var layer : long ; layer := (4 * 2->pow(n) - 3)->oclAsType(long) ;
    dic := dic->union(Map{((1) + "") |-> 1L}) ; 
    var ans : long ; ans := helper(layer, x) ;
    OclFile["System.out"].println(ans) ; 
 );
  static    operation helper( layer : long, x : long) : long
  pre: true
  post: true
  activity: (     var k : String ; k := ((layer) + "") + "*" + ((x) + "") ;
     var ans : long ; ans := 0 ;
    if (dic->keys()->includes(k)) then     return dic->at(k) else skip ; 
    if (x <= 0 or layer = 0) then     return 0 else skip ; 
    if (layer = 1) then     return 1 else skip ; 
    if (x > layer) then     x := layer ; else skip ; 
    if (2 * x + 1 <= layer) then (     ans := ans+(helper((layer - 3) / 2, x - 1)) ) else (     ans := ans+(helper((layer - 3) / 2, (layer - 3) / 2)) ; 
     ans := ans+(1) ; 
     if (x = layer) then     x := x - 1 ; else skip ; 
     ans := ans+(helper((layer - 3) / 2, x - (layer + 1) / 2)) ) ;  
    dic := dic->union(Map{k |-> ans}) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner stdin=new Scanner(System.in);
    char[] inS=stdin.next().toCharArray();
    List<Integer>xList=new ArrayList<>();
    List<Integer>yList=new ArrayList<>();
    boolean moveX=true ;
    int move=0 ;
    for(char s : inS){
      if(s=='F'){
        move++;
      }
      else {
        if(moveX){
          xList.add(move);
          moveX=false ;
        }
        else {
          yList.add(move);
          moveX=true ;
        }
        move=0 ;
      }
    }
    if(move>0){
      if(moveX){
        xList.add(move);
      }
      else {
        yList.add(move);
      }
    }
    int inX=stdin.nextInt()-xList.remove(0);
    int inY=stdin.nextInt();
    Collections.sort(xList);
    Collections.reverse(xList);
    Collections.sort(yList);
    Collections.reverse(yList);
    String result="No" ;
    if(check(inX,xList)&& check(inY,yList)){
      result="Yes" ;
    }
    System.out.println(result);
  }
  private static boolean check(int target,List<Integer>list){
    for(int move : list){
      if(target>0){
        target-=move ;
      }
      else {
        target+=move ;
      }
    }
    return target==0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inS : Sequence(String) ; inS := stdin.getCurrent()->characters() ;
    var xList : Sequence(int) ; xList := Sequence{} ;
    var yList : Sequence(int) ; yList := Sequence{} ;
    var moveX : boolean ; moveX := true ;
    var move : int ; move := 0 ;
    for (s : inS) do ( (     if (s = 'F') then (     move := move + 1 ) else (     if (moveX) then (     xList := xList->including(move) ; 
     moveX := false ) else (     yList := yList->including(move) ; 
     moveX := true ) ;  
     move := 0 ) )  ) ; 
    if (move > 0) then (     if (moveX) then (     xList := xList->including(move) ) else (     yList := yList->including(move) ) ) else skip ; 
    var inX : int ; inX := stdin.getCurrent()->toInteger() - xList->at(0+1) ;
    var inY : int ; inY := stdin.getCurrent()->toInteger() ;
    xList := xList->sort() ; 
    xList := xList->reverse() ; 
    yList := yList->sort() ; 
    yList := yList->reverse() ; 
    var result : String ; result := "No" ;
    if (check(inX, xList) & check(inY, yList)) then (     result := "Yes" ) else skip ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation check( target : int, list : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     for (move : list) do ( (     if (target > 0) then (     target := target-(move) ) else (     target := target+(move) ) )  ) ; 
     return target = 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char s[]=sc.next().toCharArray();
    int x=sc.nextInt(),y=sc.nextInt();
    int dpx[]=new int[16010];
    int dpy[]=new int[16010];
    int cnt=0 ;
    int p=0 ;
    while(p<s.length && s[p]=='F'){
      cnt++;
      p++;
    }
    dpx[cnt+8000]=1 ;
    dpy[8000]=1 ;
    cnt=0 ;
    p++;
    int dir=1 ;
    for(; p<s.length ; p++){
      if(s[p]=='F')cnt++;
      else {
        if(dir==1)update(dpy,cnt);
        else update(dpx,cnt);
        cnt=0 ;
        dir=1-dir ;
      }
    }
    if(cnt!=0){
      if(dir==1)update(dpy,cnt);
      else update(dpx,cnt);
    }
    if(dpx[x+8000]==1 && dpy[y+8000]==1){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
  static void update(int dp[],int n){
    int arr[]=new int[dp.length];
    for(int i=0 ; i<arr.length ; i++){
      if(dp[i]==1){
        arr[i-n]=1 ;
        arr[i+n]=1 ;
      }
    }
    for(int i=0 ; i<dp.length ; i++){
      dp[i]=arr[i];
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var dpx : Sequence(int) ; dpx := Integer.subrange(1,16010)->collect(0) ;
    var dpy : Sequence(int) ; dpy := Integer.subrange(1,16010)->collect(0) ;
    var cnt : int ; cnt := 0 ;
    var p : int ; p := 0 ;
    while (p < s->size() & s[p+1] = 'F') do (     cnt := cnt + 1 ; 
     p := p + 1 ) ; 
    dpx[cnt + 8000+1] := 1 ; 
    dpy[8000+1] := 1 ; 
    cnt := 0 ; 
    p := p + 1 ; 
    var dir : int ; dir := 1 ;
      while p < s->size() do ( (     if (s[p+1] = 'F') then     cnt := cnt + 1 ; else (     if (dir = 1) then     execute update(dpy, cnt) else     execute update(dpx, cnt) ; ;  
     cnt := 0 ; 
     dir := 1 - dir ) )  ;     p := p + 1 ) ; 
    if (cnt /= 0) then (     if (dir = 1) then     execute update(dpy, cnt) ; else     execute update(dpx, cnt) ; ) else skip ; 
    if (dpx[x + 8000+1] = 1 & dpy[y + 8000+1] = 1) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
  static   operation update( dp : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,dp->size())->collect(0) ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     if (dp[i+1] = 1) then (     arr[i - n+1] := 1 ; 
     arr[i + n+1] := 1 ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < dp->size() do ( (     dp[i+1] := arr[i+1] )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] arr=sc.next().toCharArray();
    int x=sc.nextInt();
    int y=sc.nextInt();
    ArrayList<Integer>xValues=new ArrayList<>();
    ArrayList<Integer>yValues=new ArrayList<>();
    boolean isX=true ;
    boolean isFirst=true ;
    int value=0 ;
    for(char c : arr){
      if(c=='T'){
        if(isFirst){
          x-=value ;
          isX=false ;
          isFirst=false ;
        }
        else if(isX){
          xValues.add(value);
          isX=false ;
        }
        else {
          yValues.add(value);
          isX=true ;
        }
        value=0 ;
      }
      else {
        value++;
      }
    }
    if(isFirst){
      x-=value ;
    }
    else if(isX){
      xValues.add(value);
    }
    else {
      yValues.add(value);
    }
    Collections.sort(xValues);
    Collections.sort(yValues);
    for(int i=xValues.size()-1 ; i>=0 ; i--){
      if(x>=0){
        x-=xValues.get(i);
      }
      else {
        x+=xValues.get(i);
      }
    }
    for(int i=yValues.size()-1 ; i>=0 ; i--){
      if(y>=0){
        y-=yValues.get(i);
      }
      else {
        y+=yValues.get(i);
      }
    }
    if(x==0 && y==0){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var xValues : Sequence(int) ; xValues := Sequence{} ;
    var yValues : Sequence(int) ; yValues := Sequence{} ;
    var isX : boolean ; isX := true ;
    var isFirst : boolean ; isFirst := true ;
    var value : int ; value := 0 ;
    for (c : arr) do ( (     if (c = 'T') then (     if (isFirst) then (     x := x-(value) ; 
     isX := false ; 
     isFirst := false ) else     if (isX) then (     xValues := xValues->including(value) ; 
     isX := false ) else (     yValues := yValues->including(value) ; 
     isX := true ) ;  ;  
     value := 0 ) else (     value := value + 1 ) )  ) ; 
    if (isFirst) then (     x := x-(value) ) else     if (isX) then (     xValues := xValues->including(value) ) else (     yValues := yValues->including(value) ) ;  ;  
    xValues := xValues->sort() ; 
    yValues := yValues->sort() ; 
        var i : int ; i := xValues->size() - 1 ; while i >= 0 do ( (     if (x >= 0) then (     x := x-(xValues->at(i+1)) ) else (     x := x+(xValues->at(i+1)) ) )  ;     i := i - 1 ) ; 
        var i : int ; i := yValues->size() - 1 ; while i >= 0 do ( (     if (y >= 0) then (     y := y-(yValues->at(i+1)) ) else (     y := y+(yValues->at(i+1)) ) )  ;     i := i - 1 ) ; 
    if (x = 0 & y = 0) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    char[] s=scanner.next().toCharArray();
    int x=scanner.nextInt();
    int y=scanner.nextInt();
    List<Integer>[] a=new List[2];
    for(int i=0 ; i<2 ; i++)a[i]=new ArrayList<>();
    int i=0 ;
    while(i<s.length && s[i++]=='F')x--;
    int j=1 ;
    for(; i<s.length ; i++){
      int c=i ;
      while(i<s.length && s[i]=='F')i++;
      if(i>c)a[j] .add(i-c);
      j=1-j ;
    }
    if(solve(a[0],Math.abs(x))&& solve(a[1],Math.abs(y))){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
  private static boolean solve(List<Integer>a,int x){
    final int MAX=16001 ;
    boolean[][] dp=new boolean[a.size()+1][MAX];
    dp[0][0]=true ;
    for(int i=1 ; i<=a.size(); i++){
      for(int j=0 ; j<MAX ; j++){
        dp[i][j]=false ;
        int v=a.get(i-1);
        if(j-v>=0)dp[i][j] |=dp[i-1][j-v];
        if(j+v<MAX)dp[i][j] |=dp[i-1][j+v];
      }
    }
    return dp[a.size()][x];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := scanner.getCurrent()->characters() ;
    var x : int ; x := scanner.getCurrent()->toInteger() ;
    var y : int ; y := scanner.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,2)->collect(null) ;
        var i : int ; i := 0 ; while i < 2 do (     a[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
    var i : int ; i := 0 ;
        while (i < s->size() & s[i+1] = 'F') do (    skip ;     x := x - 1 ; ;  ) ;  
    var j : int ; j := 1 ;
      while i < s->size() do ( (     var c : int ; c := i ;
     while (i < s->size() & s[i+1] = 'F') do     i := i + 1 ; ; 
     if (i > c) then     a[j+1]->excludes(i - c) ; else skip ; 
     j := 1 - j )  ;     i := i + 1 ) ; 
    if (solve(a[0+1], if x < 0 then -(x) else x endif) & solve(a[1+1], if y < 0 then -(y) else y endif)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
  static   operation solve( a : Sequence(int), x : int) : boolean
  pre: true
  post: true
  activity: (     var MAX : int ; MAX := 16001 ;
     var dp : Sequence(Sequence(boolean)) ; dp := Integer.subrange(1,a->size() + 1)->collect(Integer.subrange(1,MAX)->collect(false)) ;
    dp[0+1][0+1] := true ; 
        var i : int ; i := 1 ; while i <= a->size() do ( (         var j : int ; j := 0 ; while j < MAX do ( (     dp[i+1][j+1] := false ; 
     var v : int ; v := a->at(i - 1+1) ;
     if (j - v >= 0) then     dp[i+1][j+1] := MathLib.bitwiseOr(dp[i+1][j+1], dp[i - 1+1][j - v+1]) ; else skip ; 
     if (j + v < MAX) then     dp[i+1][j+1] := MathLib.bitwiseOr(dp[i+1][j+1], dp[i - 1+1][j + v+1]) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return dp[a->size()+1][x+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if((n | m)==0)break ;
      String[] name=new String[n];
      int[] start=new int[n];
      int[] end=new int[n];
      for(int i=0 ; i<n ; i++){
        name[i]=sc.next();
        int a=sc.nextInt();
        end[i]=sc.nextInt();
        start[i]=end[i]-a+1 ;
      }
      for(int i=0 ; i<m ; i++){
        int yy=sc.nextInt();
        boolean flg=true ;
        for(int j=0 ; j<n ; j++){
          if(start[j]<=yy && yy<=end[j]){
            flg=false ;
            int res=yy-start[j]+1 ;
            System.out.println(name[j]+" "+res);
            break ;
          }
        }
        if(flg){
          System.out.println("Unknown");
        }
      }
    }
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,m)) = 0) then     break else skip ; 
    var name : Sequence(String) ; name := Integer.subrange(1,n)->collect(null) ;
    var start : Sequence(int) ; start := Integer.subrange(1,n)->collect(0) ;
    var end : Sequence(int) ; end := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     name[i+1] := sc.getCurrent() ; 
     var a : int ; a := sc.getCurrent()->toInteger() ;
     end[i+1] := sc.getCurrent()->toInteger() ; 
     start[i+1] := end[i+1] - a + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var yy : int ; yy := sc.getCurrent()->toInteger() ;
     var flg : boolean ; flg := true ;
         var j : int ; j := 0 ; while j < n do ( (     if (start[j+1] <= yy & yy <= end[j+1]) then (     flg := false ; 
     var res : int ; res := yy - start[j+1] + 1 ;
     OclFile["System.out"].println(name[j+1] + " " + res) ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (flg) then (     OclFile["System.out"].println("Unknown") ) else skip )  ;     i := i + 1 ) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  Scanner scanner=new Scanner(System.in);
  int n ;
  int q ;
  private class Data implements Comparable<Data>{
    String en ;
    int eby ;
    int wy ;
    private Data(String en,int eby,int wy){
      this.en=en ;
      this.eby=eby ;
      this.wy=wy ;
    }
    @ Override public int compareTo(Data o){
      return wy-o.wy ;
    }
  }
  Data[] db ;
  private void run(){
    for(; nq(); ){
      db=new Data[n];
      for(int i=0 ; i<db.length ; i++){
        db[i]=new Data(scanner.next(),scanner.nextInt(),scanner.nextInt());
      }
      Arrays.sort(db);
      for(int i=0 ; i<q ; i++){
        Data qry=new Data("",0,scanner.nextInt());
        int ip=Arrays.binarySearch(db,qry);
        if(ip<0){
          ip=-ip-1 ;
        }
        if(ip<db.length){
          qry.wy=qry.wy-db[ip] .wy+db[ip] .eby ;
          if(qry.wy>0){
            System.out.println(db[ip] .en+" "+qry.wy);
            continue ;
          }
        }
        System.out.println("Unknown");
      }
    }
  }
  private boolean nq(){
    n=scanner.nextInt();
    q=scanner.nextInt();
    return(n | q)!=0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute n : int;
   attribute q : int;
 class Data implements Comparable<Data> {
   attribute en : String;
   attribute eby : int;
   attribute wy : int;
   static operation newData( en : String, eby : int, wy : int) : Data
  pre: true
  post: true
  activity:
  ( var self : Data ;
    self := createData();
    self.initialise(en, eby,wy);
    return self );
  operation initialise( en : String, eby : int, wy : int) : void
  pre: true  post: true
  activity: (     self.en := en ; 
     self.eby := eby ; 
     self.wy := wy );
      operation compareTo( o : Data) : int
  pre: true
  post: true
  activity: (     return wy - o.wy );
}
   attribute db : Sequence(Data);
   operation run() : void
  pre: true
  post: true
  activity: (       while nq() do ( (     db := Integer.subrange(1,n)->collect(null) ; 
         var i : int ; i := 0 ; while i < db->size() do ( (     db[i+1] := Data.newData(scanner.getCurrent(), scanner.getCurrent()->toInteger(), scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
     db := db->sort() ; 
         var i : int ; i := 0 ; while i < q do ( (     var qry : Data ; qry := Data.newData("", 0, scanner.getCurrent()->toInteger()) ;
     var ip : int ; ip := (db->indexOf(qry) - 1) ;
    if (ip < 0) then (     ip := -ip - 1 ) else skip ; 
    if (ip < db->size()) then (     qry.wy := qry.wy - db[ip+1].wy + db[ip+1].eby ; 
     if (qry.wy > 0) then (     OclFile["System.out"].println(db[ip+1].en + " " + qry.wy) ; 
     continue ) else skip ) else skip ; 
    OclFile["System.out"].println("Unknown") ; 
 )  ;     i := i + 1 ) )  ) );
   operation nq() : boolean
  pre: true
  post: true
  activity: (     n := scanner.getCurrent()->toInteger() ; 
     q := scanner.getCurrent()->toInteger() ; 
     return (MathLib.bitwiseOr(n,q)) /= 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int N,Q ;
      N=parseInt(line.substring(0,line.indexOf(' ')));
      Q=parseInt(line.substring(line.indexOf(' ')+1));
      if((N | Q)==0)break ;
      NavigableMap<Integer,String>mins=new TreeMap<>();
      Map<String,Integer>maxs=new HashMap<>();
      mins.put(0,"Unknown");
      maxs.put("Unknown",0);
      StringTokenizer st ;
      for(int i=0 ; i<N ; i++){
        st=new StringTokenizer(br.readLine());
        String E ;
        int B,W ;
        E=st.nextToken();
        B=parseInt(st.nextToken());
        W=parseInt(st.nextToken());
        mins.put(W-B+1,E);
        maxs.put(E,W);
      }
      for(int i=0 ; i<Q ; i++){
        int q,w ;
        q=parseInt(br.readLine());
        w=q-mins.floorKey(q)+1 ;
        String e=mins.floorEntry(q).getValue();
        if(q<=maxs.get(e)){
          System.out.println(e+" "+w);
        }
        else {
          System.out.println("Unknown");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var N : int ;
    var Q : int ;
     N := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    Q := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    if ((MathLib.bitwiseOr(N,Q)) = 0) then     break else skip ; 
    var mins : NavigableMap<int,String> ; mins := Map{} ;
    var maxs : Map(String,int) ; maxs := Map{} ;
    mins := mins->union(Map{0 |-> "Unknown"}) ; 
    maxs := maxs->union(Map{"Unknown" |-> 0}) ; 
    var st : OclIterator ;
        var i : int ; i := 0 ; while i < N do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var E : String ;
    var B : int ;
    var W : int ;
    E := st.next() ; 
    B := (st.next() + "")->toInteger() ; 
    W := (st.next() + "")->toInteger() ; 
    mins := mins->union(Map{(W)->char2byte() - (B)->char2byte() + 1 |-> E}) ; 
    maxs := maxs->union(Map{E |-> W}) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Q do ( (     var q : int ;
    var w : int ;
     q := (br.readLine() + "")->toInteger() ; 
    w := q - mins.floorKey(q) + 1 ; 
    var e : String ; e := mins.floorEntry(q).getValue() ;
    if (q <= maxs->at(e)) then (     OclFile["System.out"].println(e + " " + w) ) else (     OclFile["System.out"].println("Unknown") ) ;  
 )  ;     i := i + 1 ) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1060A_PhoneNumber {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int len=parseInt(input.nextLine());
    String str=input.nextLine();
    List<Character>chars=new ArrayList<>();
    for(char c : str.toCharArray()){
      chars.add(c);
    }
    int eights=Collections.frequency(chars,'8');
    int possibleNums=len/11 ;
    if(eights>=possibleNums){
      System.out.println(possibleNums);
    }
    else {
      System.out.println(eights);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1060A_PhoneNumber {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := parseInt(input.nextLine()) ;
    var str : String ; str := input.nextLine() ;
    var chars : Sequence(String) ; chars := Sequence{} ;
    for (c : str->characters()) do ( (     chars := chars->including(c) )  ) ; 
    var eights : int ; eights := .frequency(chars, '8') ;
    var possibleNums : int ; possibleNums := len / 11 ;
    if (eights >= possibleNums) then (     OclFile["System.out"].println(possibleNums) ) else (     OclFile["System.out"].println(eights) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    while(true){
      final int Y=sc.nextInt();
      final int Q=sc.nextInt();
      if(Y==0 && Q==0){
        break ;
      }
      String names[]=new String[Y];
      int[] dec=new int[Y];
      int[] years=new int[Y];
      for(int i=0 ; i<Y ; i++){
        names[i]=sc.next();
        dec[i]=sc.nextInt();
        years[i]=sc.nextInt();
      }
      for(int i=0 ; i<Q ; i++){
        final int y=sc.nextInt();
        boolean found=false ;
        int pos=-1 ;
        for(int j=0 ; j<Y ; j++){
          if((years[j]-dec[j])<y && y<=years[j]){
            pos=j ;
            found=true ;
            break ;
          }
        }
        if(! found){
          System.out.println("Unknown");
        }
        else {
          System.out.println(names[pos]+" "+(y-(years[pos]-dec[pos])));
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var Y : int ; Y := sc.getCurrent()->toInteger() ;
     var Q : int ; Q := sc.getCurrent()->toInteger() ;
    if (Y = 0 & Q = 0) then (     break ) else skip ; 
    var names : Sequence(String) ; names := Integer.subrange(1,Y)->collect(null) ;
    var dec : Sequence(int) ; dec := Integer.subrange(1,Y)->collect(0) ;
    var years : Sequence(int) ; years := Integer.subrange(1,Y)->collect(0) ;
        var i : int ; i := 0 ; while i < Y do ( (     names[i+1] := sc.getCurrent() ; 
     dec[i+1] := sc.getCurrent()->toInteger() ; 
     years[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Q do ( (     var y : int ; y := sc.getCurrent()->toInteger() ;
     var found : boolean ; found := false ;
    var pos : int ; pos := -1 ;
        var j : int ; j := 0 ; while j < Y do ( (     if ((years[j+1] - dec[j+1]) < y & y <= years[j+1]) then (     pos := j ; 
     found := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (not(found)) then (     OclFile["System.out"].println("Unknown") ) else (     OclFile["System.out"].println(names[pos+1] + " " + (y - (years[pos+1] - dec[pos+1]))) ) ;  
 )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner s=new Scanner(System.in);
  static class calendarSystem implements Comparable<calendarSystem>{
    String EraName ;
    int EraBasedYear ;
    int WesternYear ;
    calendarSystem(String eraName,int eraBasedYear,int westernYear){
      EraName=eraName ;
      EraBasedYear=eraBasedYear ;
      WesternYear=westernYear ;
    }
    public int compareTo(calendarSystem x){
      return this.WesternYear-x.WesternYear ;
    }
  }
  public static void main(String[] args){
    while(true){
      int N=s.nextInt();
      int Q=s.nextInt();
      if(N==0 && Q==0)break ;
      calendarSystem[] eraYear=new calendarSystem[N];
      for(int i=0 ; i<N ; i++){
        String EraName=s.next();
        int EraBasedYear=s.nextInt();
        int WesternYear=s.nextInt();
        eraYear[i]=new calendarSystem(EraName,EraBasedYear,WesternYear);
      }
      Arrays.sort(eraYear);
      for(int i=0 ; i<Q ; i++){
        int Query=s.nextInt();
        convertingYear(Query,eraYear);
      }
    }
  }
  static void convertingYear(int Query,calendarSystem[] eraYear){
    for(int i=0 ; i<eraYear.length ; i++){
      int WesternYear=eraYear[i] .WesternYear ;
      int EraBasedYear=eraYear[i] .EraBasedYear ;
      String EraName=eraYear[i] .EraName ;
      if(Query<=WesternYear && Query>=WesternYear-EraBasedYear+1){
        int Year=EraBasedYear-(WesternYear-Query);
        System.out.println(EraName+" "+Year);
        return ;
      }
    }
    System.out.println("Unknown");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static class calendarSystem implements Comparable<calendarSystem> {
   attribute EraName : String;
   attribute EraBasedYear : int;
   attribute WesternYear : int;
   static operation newcalendarSystem( eraName : String, eraBasedYear : int, westernYear : int) : calendarSystem
  pre: true
  post: true
  activity:
  ( var self : calendarSystem ;
    self := createcalendarSystem();
    self.initialise(eraName, eraBasedYear,westernYear);
    return self );
  operation initialise( eraName : String, eraBasedYear : int, westernYear : int) : void
  pre: true  post: true
  activity: (     EraName := eraName ; 
     EraBasedYear := eraBasedYear ; 
     WesternYear := westernYear );
   operation compareTo( x : calendarSystem) : int
  pre: true
  post: true
  activity: (     return self.WesternYear - x.WesternYear );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var N : int ; N := s.getCurrent()->toInteger() ;
     var Q : int ; Q := s.getCurrent()->toInteger() ;
    if (N = 0 & Q = 0) then     break else skip ; 
    var eraYear : Sequence(calendarSystem) ; eraYear := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     var EraName : String ; EraName := s.getCurrent() ;
     var EraBasedYear : int ; EraBasedYear := s.getCurrent()->toInteger() ;
     var WesternYear : int ; WesternYear := s.getCurrent()->toInteger() ;
     eraYear[i+1] := calendarSystem.newcalendarSystem(EraName, EraBasedYear, WesternYear) )  ;     i := i + 1 ) ; 
    eraYear := eraYear->sort() ; 
        var i : int ; i := 0 ; while i < Q do ( (     var Query : int ; Query := s.getCurrent()->toInteger() ;
     execute convertingYear(Query, eraYear) )  ;     i := i + 1 ) ; 
 ) );
  static   operation convertingYear( Query : int, eraYear : Sequence(calendarSystem)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < eraYear->size() do ( (     var WesternYear : int ; WesternYear := eraYear[i+1].WesternYear ;
     var EraBasedYear : int ; EraBasedYear := eraYear[i+1].EraBasedYear ;
     var EraName : String ; EraName := eraYear[i+1].EraName ;
     if (Query <= WesternYear & Query >= WesternYear - (EraBasedYear)->char2byte() + 1) then (     var Year : int ; Year := (EraBasedYear)->char2byte() - (WesternYear - Query) ;
     OclFile["System.out"].println(EraName + " " + Year) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Unknown") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int max_bitwise_or(int L,int R){
    Vector<Integer>v1=new Vector<Integer>(),v2=new Vector<Integer>(),v3=new Vector<Integer>();
    int z=0,i,ans=0,cnt=1 ;
    while(L>0){
      v1.add(L % 2);
      L=L/2 ;
    }
    while(R>0){
      v2.add(R % 2);
      R=R/2 ;
    }
    while(v1.size()!=v2.size()){
      v1.add(0);
    }
    for(i=v2.size()-1 ; i>=0 ; i--){
      if(v2.get(i)==1 && v1.get(i)==0 && z==0){
        z=1 ;
        continue ;
      }
      if(z==1){
        v1.remove(i);
        v1.add(i,1);
      }
    }
    for(i=0 ; i<v2.size(); i++){
      v3.add(v2.get(i)| v1.get(i));
    }
    for(i=0 ; i<v2.size(); i++){
      if(v3.get(i)==1){
        ans+=cnt ;
      }
      cnt*=2 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int L=10,R=20 ;
    System.out.println(max_bitwise_or(L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation max_bitwise_or( L : int, R : int) : int
  pre: true
  post: true
  activity: (     var v1 : Sequence(int) ; v1 := Sequence{} ;
    var v2 : Sequence(int) ; v2 := Sequence{} ;
    var v3 : Sequence(int) ; v3 := Sequence{} ;
     var z : int ; z := 0 ;
    var i : int ;
    var ans : int ; ans := 0 ;
    var cnt : int ; cnt := 1 ;
    while (L > 0) do (     v1->excludes(L mod 2) ; 
     L := L / 2 ) ; 
    while (R > 0) do (     v2->excludes(R mod 2) ; 
     R := R / 2 ) ; 
    while (v1->size() /= v2->size()) do (     v1->excludes(0) ) ; 
        i := v2->size() - 1 ; while i >= 0 do ( (     if (v2->at(i+1) = 1 & v1->at(i+1) = 0 & z = 0) then (     z := 1 ; 
     continue ) else skip ; 
     if (z = 1) then (     v1 := v1->excludingFirst(i) ; 
     v1->excludes(i, 1) ) else skip )  ;     i := i - 1 ) ; 
        i := 0 ; while i < v2->size() do ( (     v3->excludes(v2->at(i+1) or v1->at(i+1)) )  ;     i := i + 1 ) ; 
        i := 0 ; while i < v2->size() do ( (     if (v3->at(i+1) = 1) then (     ans := ans+(cnt) ) else skip ; 
     cnt := cnt*(2) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 10 ;
    var R : int ; R := 20 ;
     OclFile["System.out"].println(max_bitwise_or(L, R)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String[] nx=sc.nextLine().split(" ");
    int n=Integer.parseInt(nx[0]);
    long x=Long.parseLong(nx[1]);
    List<Long>burger=new ArrayList<>();
    List<Long>putty=new ArrayList<>();
    burger.add(1L);
    putty.add(1L);
    for(int i=0 ; i<n ; i++){
      burger.add(2*burger.get(i)+3);
      putty.add(2*putty.get(i)+1);
    }
    System.out.println(fnx(n,x,burger,putty));
  }
  public static long fnx(int n,long x,List<Long>a,List<Long>p){
    if(n==0){
      return(x<=0)? 0 : 1 ;
    }
    if(x<=a.get(n-1)+1){
      return fnx(n-1,x-1,a,p);
    }
    if(x==a.get(n-1)+2){
      return p.get(n-1)+1 ;
    }
    if(a.get(n-1)+2<x && x<=a.get(n)+2){
      return p.get(n-1)+1+fnx(n-1,x-2-a.get(n-1),a,p);
    }
    return 2*p.get(n-1)+1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var nx : Sequence(String) ; nx := sc.nextLine()->split(" ") ;
    var n : int ; n := (nx[0+1])->toInteger() ;
    var x : long ; x := (nx[1+1])->toLong() ;
    var burger : Sequence(long) ; burger := Sequence{} ;
    var putty : Sequence(long) ; putty := Sequence{} ;
    burger := burger->including(1L) ; 
    putty := putty->including(1L) ; 
        var i : int ; i := 0 ; while i < n do ( (     burger := burger->including(2 * burger->at(i+1) + 3) ; 
     putty := putty->including(2 * putty->at(i+1) + 1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(fnx(n, x, burger, putty)) ; 
 );
  static   operation fnx( n : int, x : long, a : Sequence(long), p : Sequence(long)) : long
  pre: true
  post: true
  activity: (     if (n = 0) then (     return if (x <= 0) then 0 else 1 endif ) else skip ; 
     if (x <= a->at(n - 1+1) + 1) then (     return fnx(n - 1, x - 1, a, p) ) else skip ; 
    if (x = a->at(n - 1+1) + 2) then (     return p->at(n - 1+1) + 1 ) else skip ; 
    if (a->at(n - 1+1) + 2 < x & x <= a->at(n+1) + 2) then (     return p->at(n - 1+1) + 1 + fnx(n - 1, x - 2 - a->at(n - 1+1), a, p) ) else skip ; 
    return 2 * p->at(n - 1+1) + 1 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  static boolean isDivBy9(int n){
    if(n==0 || n==9)return true ;
    if(n<9)return false ;
    return isDivBy9((int)(n>>3)-(int)(n & 7));
  }
  public static void main(String arg[]){
    for(int i=0 ; i<100 ; i++)if(isDivBy9(i))System.out.print(i+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isDivBy9( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 0 or n = 9) then     return true else skip ; 
     if (n < 9) then     return false else skip ; 
     return isDivBy9(((n/(2->pow(3)))->oclAsType(long))->oclAsType(int) - (MathLib.bitwiseAnd(n,7))->oclAsType(int)) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 100 do (     if (isDivBy9(i)) then     OclFile["System.out"].print(i + " ") ; else skip ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GeeksforGeeks {
  public static void pattern(int n){
    for(int i=1 ; i<=n*2 ; i++)System.out.print(" ");
    System.out.print(0+"\n");
    for(int i=1 ; i<=(n*2)-1 ; i++){
      if(i<n){
        for(int j=1 ; j<=(n-i)*2 ; j++)System.out.print(" ");
      }
      else {
        for(int j=1 ; j<=(i % n)*2 ; j++)System.out.print(" ");
      }
      if(i<n){
        for(int j=0 ; j<=i % n ; j++)System.out.print(j+" ");
        for(int j=(i % n)-1 ; j>0 ; j--)System.out.print(j+" ");
        System.out.print(0);
      }
      else if(i>n){
        for(int j=0 ; j<=n-(i-n); j++)System.out.print(j+" ");
        for(int j=(n-(i-n))-1 ; j>0 ; j--)System.out.print(j+" ");
        System.out.print(0);
      }
      else {
        for(int j=0 ; j<=n ; j++)System.out.print(j+" ");
        for(int j=n-1 ; j>0 ; j--)System.out.print(j+" ");
        System.out.print(0);
      }
      System.out.print("\n");
    }
    for(int i=1 ; i<=n*2 ; i++)System.out.print(" ");
    System.out.print(0);
  }
  public static void main(String argc[]){
    int n=4 ;
    pattern(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GeeksforGeeks {
  static   operation pattern( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= n * 2 do (     OclFile["System.out"].print(" ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(0 + "\n") ; 
        var i : int ; i := 1 ; while i <= (n * 2) - 1 do ( (     if (i < n) then (         var j : int ; j := 1 ; while j <= (n - i) * 2 do (     OclFile["System.out"].print(" ") ;  ;     j := j + 1 ) ) else (         var j : int ; j := 1 ; while j <= (i mod n) * 2 do (     OclFile["System.out"].print(" ") ;  ;     j := j + 1 ) ) ;  
     if (i < n) then (         var j : int ; j := 0 ; while j <= i mod n do (     OclFile["System.out"].print(j + " ") ;  ;     j := j + 1 ) ; 
         var j : int ; j := (i mod n) - 1 ; while j > 0 do (     OclFile["System.out"].print(j + " ") ;  ;     j := j - 1 ) ; 
     OclFile["System.out"].print(0) ) else     if (i > n) then (         var j : int ; j := 0 ; while j <= n - (i - n) do (     OclFile["System.out"].print(j + " ") ;  ;     j := j + 1 ) ; 
         var j : int ; j := (n - (i - n)) - 1 ; while j > 0 do (     OclFile["System.out"].print(j + " ") ;  ;     j := j - 1 ) ; 
     OclFile["System.out"].print(0) ) else (         var j : int ; j := 0 ; while j <= n do (     OclFile["System.out"].print(j + " ") ;  ;     j := j + 1 ) ; 
         var j : int ; j := n - 1 ; while j > 0 do (     OclFile["System.out"].print(j + " ") ;  ;     j := j - 1 ) ; 
     OclFile["System.out"].print(0) ) ;  ;  
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n * 2 do (     OclFile["System.out"].print(" ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(0) ; 
 );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     execute pattern(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isPowerOfTwo(int n){
    if(n==0)return false ;
    while(n!=1){
      if(n % 2!=0)return false ;
      n=n/2 ;
    }
    return true ;
  }
  public static void main(String args[]){
    if(isPowerOfTwo(31))System.out.println("Yes");
    else System.out.println("No");
    if(isPowerOfTwo(64))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPowerOfTwo( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 0) then     return false else skip ; 
     while (n /= 1) do (     if (n mod 2 /= 0) then     return false else skip ; 
     n := n / 2 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (isPowerOfTwo(31)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
     if (isPowerOfTwo(64)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.*;
public class Solution {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    Set<String>set=new HashSet<>();
    int n=Integer.parseInt(br.readLine());
    String[] str=new String[n];
    for(int i=0 ; i<n ; i++){
      String s=br.readLine();
      if(set.contains(s)){
        str[i]="YES" ;
      }
      else {
        set.add(s);
        str[i]="NO" ;
      }
    }
    br.close();
    for(int i=0 ; i<n ; i++){
      System.out.println(str[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var set : Set(String) ; set := Set{} ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var str : Sequence(String) ; str := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := br.readLine() ;
     if (set->includes(s)) then (     str[i+1] := "YES" ) else (     set := set->including(s) ; 
     str[i+1] := "NO" ) )  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(str[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    ArrayList<String>list=new ArrayList<>();
    String str="" ;
    for(int i=0 ; i<n ; i++){
      str=input.next();
      System.out.println((list.contains(str)? "YES" : "NO"));
      list.add(str);
    }
    input.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var list : Sequence(String) ; list := Sequence{} ;
    var str : String ; str := "" ;
        var i : int ; i := 0 ; while i < n do ( (     str := input.getCurrent() ; 
     OclFile["System.out"].println((if list->includes(str) then "YES" else "NO" endif)) ; 
     list := list->including(str) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Set ;
import java.util.HashSet ;
public class A_Tom_Riddle_s_Diary {
  static Scanner in=new Scanner(System.in);
  public static void main(String[] amit){
    int n=in.nextInt();
    String s[]=new String[n+1];
    int ans=0 ;
    Set<String>set=new HashSet<>();
    for(int i=1 ; i<=n ; i++){
      s[i]=in.next();
      if(set.contains(s[i])){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
      set.add(s[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Tom_Riddle_s_Diary {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( amit : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var s : Sequence(String) ; s := Integer.subrange(1,n + 1)->collect(null) ;
    var ans : int ; ans := 0 ;
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := 1 ; while i <= n do ( (     s[i+1] := in.getCurrent() ; 
     if (set->includes(s[i+1])) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
     set := set->including(s[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sumOfDigit(int n,int b){
    int unitDigit,sum=0 ;
    while(n>0){
      unitDigit=n % b ;
      sum+=unitDigit ;
      n=n/b ;
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=50 ;
    int b=2 ;
    System.out.print(sumOfDigit(n,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumOfDigit( n : int, b : int) : int
  pre: true
  post: true
  activity: (     var unitDigit : int ;
    var sum : int ; sum := 0 ;
     while (n > 0) do (     unitDigit := n mod b ; 
     sum := sum+(unitDigit) ; 
     n := n / b ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 50 ;
     var b : int ; b := 2 ;
     OclFile["System.out"].print(sumOfDigit(n, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  static Scanner scan=new Scanner(System.in);
  public static void main(String args[]){
    int n=scan.nextInt();
    List<String>list=new ArrayList<String>();
    for(int i=0 ; i<n ; i++){
      String input=scan.next();
      if(list.contains(input)){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
        list.add(input);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var list : Sequence(String) ; list := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     var input : String ; input := scan.getCurrent() ;
     if (list->includes(input)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ; 
     list := list->including(input) ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static float surfaceArea(float a,float b,float h){
    return 5*a*b+5*b*h ;
  }
  static float volume(float b,float h){
    return(5*b*h)/2 ;
  }
  public static void main(String arr[]){
    float a=5 ;
    float b=3 ;
    float h=7 ;
    System.out.println("surface area="+surfaceArea(a,b,h)+",");
    System.out.println("volume="+volume(b,h));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation surfaceArea( a : double, b : double, h : double) : double
  pre: true
  post: true
  activity: (     return 5 * a * b + 5 * b * h );
  static   operation volume( b : double, h : double) : double
  pre: true
  post: true
  activity: (     return (5 * b * h) / 2 );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 5 ;
     var b : double ; b := 3 ;
    var h : double ; h := 7 ;
    OclFile["System.out"].println("surface area=" + surfaceArea(a, b, h) + ",") ; 
    OclFile["System.out"].println("volume=" + volume(b, h)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Run {
  public static int[] getCount(String s){
    int[] count=new int[26];
    int len=s.length();
    for(int i=0 ; i<len ; i++)++count[s.charAt(i)-'a'];
    return count ;
  }
  public static void main(String[] Z)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder op=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    String s=br.readLine();
    int m=Integer.parseInt(br.readLine());
    String[] names=new String[m];
    for(int i=0 ; i<m ; i++){
      names[i]=br.readLine();
    }
    ArrayList<ArrayList<Integer>>list=new ArrayList<>(26);
    for(int i=0 ; i<26 ; i++)list.add(new ArrayList<>());
    for(int i=0 ; i<n ; i++){
      char c=s.charAt(i);
      list.get(c-'a').add(i);
    }
    for(String name : names){
      int[] count=getCount(name);
      int ans=0 ;
      for(int i=0 ; i<26 ; ++i){
        int cnt=count[i];
        if(cnt==0)continue ;
        int currAns=list.get(i).get(cnt-1)+1 ;
        ans=Math.max(currAns,ans);
      }
      op.append(ans);
      op.append("\n");
    }
    System.out.println(op);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Run {
  static   operation getCount( s : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,26)->collect(0) ;
     var len : int ; len := s->size() ;
         var i : int ; i := 0 ; while i < len do (     count[s->at(i+1) - ('a')->char2byte()+1] := count[s->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
     return count );
  static   operation main( Z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var op : String ; op := StringLib.newString() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var s : String ; s := br.readLine() ;
    var m : int ; m := (br.readLine())->toInteger() ;
    var names : Sequence(String) ; names := Integer.subrange(1,m)->collect(null) ;
        var i : int ; i := 0 ; while i < m do ( (     names[i+1] := br.readLine() )  ;     i := i + 1 ) ; 
    var list : Sequence(Sequence(int)) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < 26 do (     list := list->including(Sequence{}) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var c : String ; c := s->at(i+1) ;
     list->at((c)->char2byte() - ('a')->char2byte()+1)->excludes(i) )  ;     i := i + 1 ) ; 
    for (name : names) do ( (     var count : Sequence(int) ; count := getCount(name) ;
     var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 26 do ( (     var cnt : int ; cnt := count[i+1] ;
     if (cnt = 0) then     continue else skip ; 
     var currAns : int ; currAns := list->at(i+1)->at(cnt - 1+1) + 1 ;
     ans := Set{currAns, ans}->max() )  ;     i := i + 1 ) ; 
    op := op + StringLib.newString(ans) ; 
    op := op + StringLib.newString("\n") ; 
 )  ) ; 
    OclFile["System.out"].println(op) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  class Cache {
    private long size ;
    private long pati ;
    public Cache(long size,long pati){
      this.size=size ;
      this.pati=pati ;
    }
    public long size(){
      return this.size ;
    }
    public long pati(){
      return this.pati ;
    }
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String[] line=scanner.nextLine().split(" ",2);
    long n=Long.parseLong(line[0]);
    long x=Long.parseLong(line[1]);
    new Main(x,0).main(n);
  }
  private long toEat ;
  private long pati ;
  private HashMap<Long,Cache>cacheMap ;
  public Main(long toEat,long pati){
    this.toEat=toEat ;
    this.pati=pati ;
    this.cacheMap=new HashMap<>();
  }
  public void main(long level){
    this.eat(level);
    System.out.println(this.pati);
  }
  public void eat(long level){
    if(toEat==0){
      return ;
    }
    if(level==0){
      this.toEat--;
      this.pati++;
    }
    else {
      Cache cache=this.cacheMap.get(level-1);
      long initToEat=this.toEat ;
      long initPati=this.pati ;
      this.toEat--;
      if(cache!=null && this.toEat>=cache.size){
        this.toEat-=cache.size ;
        this.pati+=cache.pati ;
      }
      else if(this.toEat>0){
        this.eat(level-1);
      }
      if(this.toEat>0){
        this.toEat--;
        this.pati++;
      }
      if(cache!=null && this.toEat>=cache.size){
        this.toEat-=cache.size ;
        this.pati+=cache.pati ;
      }
      else if(this.toEat>0){
        this.eat(level-1);
      }
      if(this.toEat>0){
        this.toEat--;
        this.cacheMap.put(level,new Cache(initToEat-toEat,pati-initPati));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class Cache {
   attribute size : long;
   attribute pati : long;
   static operation newCache( size : long, pati : long) : Cache
  pre: true
  post: true
  activity:
  ( var self : Cache ;
    self := createCache();
    self.initialise(size, pati);
    return self );
  operation initialise( size : long, pati : long) : void
  pre: true  post: true
  activity: (     self.size := size ; 
     self.pati := pati );
   operation size() : long
  pre: true
  post: true
  activity: (     return self.size );
   operation pati() : long
  pre: true
  post: true
  activity: (     return self.pati );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : Sequence(String) ; line := scanner.nextLine()->split(" ") ;
    var n : long ; n := (line[0+1])->toLong() ;
    var x : long ; x := (line[1+1])->toLong() ;
    Main.newMain(x, 0).main(n) ; 
 );
   attribute toEat : long;
   attribute pati : long;
   attribute cacheMap : Map(long,Cache);
   static operation newMain( toEat : long, pati : long) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(toEat, pati);
    return self );
  operation initialise( toEat : long, pati : long) : void
  pre: true  post: true
  activity: (     self.toEat := toEat ; 
     self.pati := pati ; 
     self.cacheMap := Map{} );
   operation main( level : long) : void
  pre: true
  post: true
  activity: (     self.eat(level) ; 
     OclFile["System.out"].println(self.pati) );
   operation eat( level : long) : void
  pre: true
  post: true
  activity: (     if (toEat = 0) then (     return ) else skip ; 
     if (level = 0) then (     self.toEat := self.toEat - 1 ; 
     self.pati := self.pati + 1 ) else (     var cache : Cache ; cache := self.cacheMap->at(level - 1+1) ;
     var initToEat : long ; initToEat := self.toEat ;
    var initPati : long ; initPati := self.pati ;
    self.toEat := self.toEat - 1 ; 
    if (cache /= null & self.toEat >= cache.size) then (     self.toEat := self.toEat-(cache.size) ; 
     self.pati := self.pati+(cache.pati) ) else     if (self.toEat > 0) then (     self.eat(level - 1) ) else skip ; ;  
    if (self.toEat > 0) then (     self.toEat := self.toEat - 1 ; 
     self.pati := self.pati + 1 ) else skip ; 
    if (cache /= null & self.toEat >= cache.size) then (     self.toEat := self.toEat-(cache.size) ; 
     self.pati := self.pati+(cache.pati) ) else     if (self.toEat > 0) then (     self.eat(level - 1) ) else skip ; ;  
    if (self.toEat > 0) then (     self.toEat := self.toEat - 1 ; 
     self := self.cacheMap->union(Map{level |-> Cache.newCache(initToEat - toEat, pati - initPati)}) ) else skip ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int sum=0 ;
    for(int i=0 ; i<10 ; i++)sum+=sc.nextInt();
    System.out.println(sum);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 10 do (     sum := sum+(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sn=new Scanner(System.in);
    int sum=0 ;
    while(sn.hasNext())sum+=sn.nextInt();
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sn : OclFile ; sn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sum : int ; sum := 0 ;
     while (sn.hasNext()) do     sum := sum+(sn.getCurrent()->toInteger()) ; ; 
     OclFile["System.out"].println(sum) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.pointCount();
    return ;
  }
  private void pointCount(){
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    try {
      int point=0 ;
      for(int i=0 ; i<10 ; i++){
        String inputStr=bufferedReader.readLine();
        int num=Integer.parseInt(inputStr);
        point+=num ;
      }
      System.out.println(point);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.pointCount() ; 
     return );
   operation pointCount() : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var point : int ; point := 0 ;
         var i : int ; i := 0 ; while i < 10 do ( (     var inputStr : String ; inputStr := bufferedReader.readLine() ;
     var num : int ; num := (inputStr)->toInteger() ;
     point := point+(num) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(point) )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  Main(){
    sc=new Scanner(System.in);
  }
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    int sum=0 ;
    for(int i=0 ; i<10 ; ++i){
      sum+=ni();
    }
    System.out.println(sum);
  }
  int ni(){
    return Integer.parseInt(sc.next());
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < 10 do ( (     sum := sum+(ni()) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sum) );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (sc.getCurrent())->toInteger() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  int s ;
  int[] a=new int[10];
  int b ;
  int d=0 ;
  public void kei(){
    for(b=0 ; b<a.length ; b++){
      s=sc.nextInt();
      d=d+s ;
    }
  }
  public void hyouji(){
    System.out.println(d);
  }
  public static void main(String[] args){
    Main go=new Main();
    go.kei();
    go.hyouji();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute s : int;
   attribute a : Sequence(int) := Integer.subrange(1,10)->collect(0);
   attribute b : int;
   attribute d : int := 0;
   operation kei() : void
  pre: true
  post: true
  activity: (         b := 0 ; while b < a->size() do ( (     s := sc.getCurrent()->toInteger() ; 
     d := d + s )  ;     b := b + 1 ) );
   operation hyouji() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(d) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var go : Main ; go := Main.newMain() ;
     go.kei() ; 
     go.hyouji() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printLargestDivisible(int n,int a[]){
    int i,c0=0,c5=0 ;
    for(i=0 ; i<n ; i++){
      if(a[i]==0)c0++;
      else c5++;
    }
    c5=(int)Math.floor(c5/9)*9 ;
    if(c0==0)System.out.print(-1);
    else if(c5==0)System.out.println(0);
    else {
      for(i=0 ; i<c5 ; i++)System.out.print(5);
      for(i=0 ; i<c0 ; i++)System.out.print(0);
    }
  }
  public static void main(String[] args){
    int a[]={
      5,5,5,5,5,5,5,5,0,5,5 };
      int n=a.length ;
      printLargestDivisible(n,a);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printLargestDivisible( n : int, a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var c0 : int ; c0 := 0 ;
    var c5 : int ; c5 := 0 ;
         i := 0 ; while i < n do ( (     if (a[i+1] = 0) then     c0 := c0 + 1 ; else     c5 := c5 + 1 ; )  ;     i := i + 1 ) ; 
     c5 := (c5 / 9)->floor()->oclAsType(int) * 9 ; 
     if (c0 = 0) then     OclFile["System.out"].print(-1) ; else     if (c5 = 0) then     OclFile["System.out"].println(0) else (         i := 0 ; while i < c5 do (     OclFile["System.out"].print(5) ;  ;     i := i + 1 ) ; 
         i := 0 ; while i < c0 do (     OclFile["System.out"].print(0) ;  ;     i := i + 1 ) ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{5,5,5,5,5,5,5,5,0,5,5} ;
     var n : int ; n := a->size() ;
     execute printLargestDivisible(n, a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int mod=998244353 ;
    int T=in.nextInt();
    while(T>0){
      int n=in.nextInt();
      long res=1 ;
      if(n % 2!=0){
        System.out.println("0");
        T--;
        continue ;
      }
      n=n/2 ;
      for(int i=2 ; i<=n ; i++){
        res*=i ;
        res %=mod ;
      }
      res=res*res % mod ;
      System.out.println(res);
      T--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var mod : int ; mod := 998244353 ;
     var T : int ; T := in.getCurrent()->toInteger() ;
     while (T > 0) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var res : long ; res := 1 ;
    if (n mod 2 /= 0) then (     OclFile["System.out"].println("0") ; 
     T := T - 1 ; 
     continue ) else skip ; 
    n := n / 2 ; 
        var i : int ; i := 2 ; while i <= n do ( (     res := res*(i) ; 
     res := res mod mod )  ;     i := i + 1 ) ; 
    res := res * res mod mod ; 
    OclFile["System.out"].println(res) ; 
    T := T - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        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().trim();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  static class FastWriter {
    private final BufferedWriter bw ;
    public FastWriter(){
      this.bw=new BufferedWriter(new OutputStreamWriter(System.out));
    }
    public void print(Object object)throws IOException {
      bw.append(""+object);
    }
    public void println(Object object)throws IOException {
      print(object);
      bw.append("\n");
    }
    public void close()throws IOException {
      bw.close();
    }
  }
  static int MOD=998244353 ;
  public static void main(String[] args){
    try {
      FastReader sc=new FastReader();
      FastWriter sout=new FastWriter();
      int testCases=sc.nextInt();
      while(testCases-->0){
        int n=sc.nextInt();
        if(n % 2!=0){
          sout.println(0);
        }
        else {
          long fact=factorial(n/2);
          fact=(fact*fact)% MOD ;
          sout.println(fact);
        }
      }
      sout.close();
    }
    catch(Exception e){
      return ;
    }
  }
  public static long factorial(int n){
    long ans=1 ;
    while(n>1){
      ans=(ans*n)% MOD ;
--n ;
    }
    return ans % MOD ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine()->trim() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return str );
}
  static class FastWriter {
   attribute bw : OclFile;
   static operation newFastWriter() : FastWriter
  pre: true
  post: true
  activity:
  ( var self : FastWriter ;
    self := createFastWriter();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) );
   operation print( object : OclAny) : void
  pre: true
  post: true
  activity: (     skip );
   operation println( object : OclAny) : void
  pre: true
  post: true
  activity: (     execute print(object) ; 
     skip );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
  static   attribute MOD : int := 998244353;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var sout : FastWriter ; sout := FastWriter.newFastWriter() ;
    var testCases : int ; testCases := sc.nextInt() ;
        while (testCases > 0) do (        testCases := testCases - 1 ;     skip ; (     var n : int ; n := sc.nextInt() ;
     if (n mod 2 /= 0) then (     sout.println(0) ) else (     var fact : long ; fact := factorial(n / 2) ;
     fact := (fact * fact) mod MOD ; 
     sout.println(fact) ) ) ;  ) ;  
    sout.close() ; 
 )   catch (e : ProgramException) do (     return )
 );
  static   operation factorial( n : int) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
     while (n > 1) do (     ans := (ans * n) mod MOD ; 
     n := n - 1 ) ; 
     return ans mod MOD );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF1658B {
  public static Scanner scanner ;
  public static int MOD=998244353 ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int test=scanner.nextInt();
    for(int i=0 ; i<test ; i++){
      int n=scanner.nextInt();
      if(n % 2==0){
        long res=facto(n/2)*facto(n/2);
        System.out.println(res % MOD);
      }
      else System.out.println(0);
    }
  }
  public static long facto(long n){
    if(n<=0)return 1 ;
    return(n*facto(n-1))% MOD ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF1658B {
  static   attribute scanner : OclFile;
  static   attribute MOD : int := 998244353;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var test : int ; test := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < test do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (     var res : long ; res := facto(n / 2) * facto(n / 2) ;
     OclFile["System.out"].println(res mod MOD) ) else     OclFile["System.out"].println(0) ; )  ;     i := i + 1 ) );
  static   operation facto( n : long) : long
  pre: true
  post: true
  activity: (     if (n <= 0) then     return 1 else skip ; 
     return (n * facto(n - 1)) mod MOD );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int N=8 ;
  static int INF=Integer.MAX_VALUE ;
  public static int shortestDist(int[][] graph){
    int[] dist=new int[N];
    dist[N-1]=0 ;
    for(int i=N-2 ; i>=0 ; i--){
      dist[i]=INF ;
      for(int j=i ; j<N ; j++){
        if(graph[i][j]==INF){
          continue ;
        }
        dist[i]=Math.min(dist[i],graph[i][j]+dist[j]);
      }
    }
    return dist[0];
  }
  public static void main(String[] args){
    int[][] graph=new int[][] {
      {
        INF,1,2,5,INF,INF,INF,INF },{
          INF,INF,INF,INF,4,11,INF,INF },{
            INF,INF,INF,INF,9,5,16,INF },{
              INF,INF,INF,INF,INF,INF,2,INF },{
                INF,INF,INF,INF,INF,INF,INF,18 },{
                  INF,INF,INF,INF,INF,INF,INF,13 },{
                    INF,INF,INF,INF,INF,INF,INF,2 }
                  };
                  System.out.println(shortestDist(graph));
                }
              }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 8;
  static   attribute INF : int := 2147483647;
  static   operation shortestDist( graph : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var dist : Sequence(int) ; dist := Integer.subrange(1,N)->collect(0) ;
     dist[N - 1+1] := 0 ; 
         var i : int ; i := N - 2 ; while i >= 0 do ( (     dist[i+1] := INF ; 
         var j : int ; j := i ; while j < N do ( (     if (graph[i+1][j+1] = INF) then (     continue ) else skip ; 
     dist[i+1] := Set{dist[i+1], graph[i+1][j+1] + dist[j+1]}->min() )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
     return dist[0+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var graph : Sequence(Sequence(int)) ; graph := Sequence{Sequence{INF,1,2,5,INF,INF,INF,INF},Sequence{INF,INF,INF,INF,4,11,INF,INF},Sequence{INF,INF,INF,INF,9,5,16,INF},Sequence{INF,INF,INF,INF,INF,INF,2,INF},Sequence{INF,INF,INF,INF,INF,INF,INF,18},Sequence{INF,INF,INF,INF,INF,INF,INF,13},Sequence{INF,INF,INF,INF,INF,INF,INF,2}} ;
     OclFile["System.out"].println(shortestDist(graph)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] agrs){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int l=in.nextInt();
    int[] a=new int[55];
    int[] b=new int[55];
    int[] aa=new int[55];
    int[] bb=new int[55];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    for(int i=1 ; i<n ; i++){
      aa[i]=a[i]-a[i-1];
    }
    aa[0]=a[0]+l-a[n-1];
    for(int i=0 ; i<n ; i++){
      b[i]=in.nextInt();
    }
    for(int i=1 ; i<n ; i++){
      bb[i]=b[i]-b[i-1];
    }
    bb[0]=b[0]+l-b[n-1];
    int flag=0 ;
    for(int i=0 ; i<n ; i++){
      int j ;
      for(j=0 ; j<n ; j++){
        if(aa[j]!=bb[(i+j)% n])break ;
      }
      if(j==n){
        flag=1 ;
        break ;
      }
    }
    if(flag==0)System.out.println("NO");
    else System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var l : int ; l := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,55)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,55)->collect(0) ;
    var aa : Sequence(int) ; aa := Integer.subrange(1,55)->collect(0) ;
    var bb : Sequence(int) ; bb := Integer.subrange(1,55)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     aa[i+1] := a[i+1] - a[i - 1+1] )  ;     i := i + 1 ) ; 
    aa[0+1] := a[0+1] + l - a[n - 1+1] ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     bb[i+1] := b[i+1] - b[i - 1+1] )  ;     i := i + 1 ) ; 
    bb[0+1] := b[0+1] + l - b[n - 1+1] ; 
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var j : int ;
         j := 0 ; while j < n do ( (     if (aa[j+1] /= bb[(i + j) mod n+1]) then     break else skip )  ;     j := j + 1 ) ; 
     if (j = n) then (     flag := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 0) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.*;
import java.awt.geom.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] $){
    Scanner sc=new Scanner(in);
    int n=sc.nextInt();
    long x=sc.nextLong();
    long[] a=new long[51];
    a[0]=1 ;
    long[] p=new long[51];
    p[0]=1 ;
    for(int i=0 ; i<50 ; i++){
      a[i+1]=2*a[i]+3 ;
      p[i+1]=2*p[i]+1 ;
    }
    out.println(f(a,p,n,x));
  }
  static long f(long[] a,long[] p,int n,long x){
    if(x==1)return n>0 ? 0 : 1 ;
    if(x==3+2*a[n-1])return p[n-1]*2+1 ;
    if(x==a[n-1]+2)return p[n-1]+1 ;
    if(1<x && x<=a[n-1]+1)return f(a,p,n-1,x-1);
    return p[n-1]+1+f(a,p,n-1,x-a[n-1]-2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : long ; x := sc.getCurrent()->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,51)->collect(0) ;
    a[0+1] := 1 ; 
    var p : Sequence(long) ; p := Integer.subrange(1,51)->collect(0) ;
    p[0+1] := 1 ; 
        var i : int ; i := 0 ; while i < 50 do ( (     a[i + 1+1] := 2 * a[i+1] + 3 ; 
     p[i + 1+1] := 2 * p[i+1] + 1 )  ;     i := i + 1 ) ; 
    out.println(f(a, p, n, x)) ; 
 );
  static   operation f( a : Sequence(long), p : Sequence(long), n : int, x : long) : long
  pre: true
  post: true
  activity: (     if (x = 1) then     return if n > 0 then 0 else 1 endif else skip ; 
     if (x = 3 + 2 * a[n - 1+1]) then     return p[n - 1+1] * 2 + 1 else skip ; 
    if (x = a[n - 1+1] + 2) then     return p[n - 1+1] + 1 else skip ; 
    if (1 < x & x <= a[n - 1+1] + 1) then     return f(a, p, n - 1, x - 1) else skip ; 
    return p[n - 1+1] + 1 + f(a, p, n - 1, x - a[n - 1+1] - 2) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Test12 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int l=sc.nextInt();
    int[] a=new int[n];
    int[] b=new int[n];
    ArrayList<Integer>list1=new ArrayList<>();
    ArrayList<Integer>list2=new ArrayList<>();
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    for(int i=0 ; i<n ; i++)b[i]=sc.nextInt();
    boolean f=false ;
    for(int i=0 ; i<(n-1); i++){
      list1.add(a[i+1]-a[i]);
      list2.add(b[i+1]-b[i]);
    }
    list1.add(l+a[0]-a[n-1]);
    list2.add(l+b[0]-b[n-1]);
    for(int i=0 ; i<n ; i++){
      boolean flag=true ;
      for(int j=0 ; j<n ; j++)flag=(list1.get(j)==list2.get((i+j)% n))&& flag ;
      f=(flag | f);
    }
    System.out.println(f ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test12 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var list1 : Sequence(int) ; list1 := Sequence{} ;
    var list2 : Sequence(int) ; list2 := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     b[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var f : boolean ; f := false ;
        var i : int ; i := 0 ; while i < (n - 1) do ( (     list1 := list1->including(a[i + 1+1] - a[i+1]) ; 
     list2 := list2->including(b[i + 1+1] - b[i+1]) )  ;     i := i + 1 ) ; 
    list1 := list1->including(l + a[0+1] - a[n - 1+1]) ; 
    list2 := list2->including(l + b[0+1] - b[n - 1+1]) ; 
        var i : int ; i := 0 ; while i < n do ( (     var flag : boolean ; flag := true ;
         var j : int ; j := 0 ; while j < n do (     flag := (list1->at(j+1) = list2->at((i + j) mod n+1)) & flag ;  ;     j := j + 1 ) ; 
     f := (MathLib.bitwiseOr(flag,f)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if f then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maximum(int x,int y){
    return((x+y+Math.abs(x-y))/2);
  }
  static int minimum(int x,int y){
    return((x+y-Math.abs(x-y))/2);
  }
  public static void main(String[] args){
    int x=99,y=18 ;
    System.out.println("Maximum: "+maximum(x,y));
    System.out.println("Minimum: "+minimum(x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maximum( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return ((x + y + if x - y < 0 then -(x - y) else x - y endif) / 2) );
  static   operation minimum( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return ((x + y - if x - y < 0 then -(x - y) else x - y endif) / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 99 ;
    var y : int ; y := 18 ;
     OclFile["System.out"].println("Maximum: " + maximum(x, y)) ; 
     OclFile["System.out"].println("Minimum: " + minimum(x, y)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double u_cal(double u,int n){
    double temp=u ;
    for(int i=1 ; i<n ; i++)temp=temp*(u-i);
    return temp ;
  }
  static int fact(int n){
    int f=1 ;
    for(int i=2 ; i<=n ; i++)f*=i ;
    return f ;
  }
  public static void main(String[] args){
    int n=4 ;
    double x[]={
      45,50,55,60 };
      double y[][]=new double[n][n];
      y[0][0]=0.7071 ;
      y[1][0]=0.7660 ;
      y[2][0]=0.8192 ;
      y[3][0]=0.8660 ;
      for(int i=1 ; i<n ; i++){
        for(int j=0 ; j<n-i ; j++)y[j][i]=y[j+1][i-1]-y[j][i-1];
      }
      for(int i=0 ; i<n ; i++){
        System.out.print(x[i]+"\t");
        for(int j=0 ; j<n-i ; j++)System.out.print(y[i][j]+"\t");
        System.out.println();
      }
      double value=52 ;
      double sum=y[0][0];
      double u=(value-x[0])/(x[1]-x[0]);
      for(int i=1 ; i<n ; i++){
        sum=sum+(u_cal(u,i)*y[0][i])/fact(i);
      }
      System.out.println("\n Value at "+value+" is "+String.format("%.6g%n",sum));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation u_cal( u : double, n : int) : double
  pre: true
  post: true
  activity: (     var temp : double ; temp := u ;
         var i : int ; i := 1 ; while i < n do (     temp := temp * (u - i) ;  ;     i := i + 1 ) ; 
     return temp );
  static   operation fact( n : int) : int
  pre: true
  post: true
  activity: (     var f : int ; f := 1 ;
         var i : int ; i := 2 ; while i <= n do (     f := f*(i) ;  ;     i := i + 1 ) ; 
     return f );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var x : Sequence(double) ; x := Sequence{45,50,55,60} ;
    var y : Sequence(Sequence(double)) ; y := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0.0)) ;
    y[0+1][0+1] := 0.7071 ; 
    y[1+1][0+1] := 0.7660 ; 
    y[2+1][0+1] := 0.8192 ; 
    y[3+1][0+1] := 0.8660 ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 0 ; while j < n - i do (     y[j+1][i+1] := y[j + 1+1][i - 1+1] - y[j+1][i - 1+1] ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(x[i+1] + "\t") ; 
         var j : int ; j := 0 ; while j < n - i do (     OclFile["System.out"].print(y[i+1][j+1] + "\t") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
    var value : double ; value := 52 ;
    var sum : double ; sum := y[0+1][0+1] ;
    var u : double ; u := (value - x[0+1]) / (x[1+1] - x[0+1]) ;
        var i : int ; i := 1 ; while i < n do ( (     sum := sum + (u_cal(u, i) * y[0+1][i+1]) / fact(i) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("\n Value at " + value + " is " + StringLib.format("%.6g%n",Sequence{sum})) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static void breakLine(){
    System.out.print("\n---------------------------------\n");
  }
  static int MAX=10 ;
  static int arr[]=new int[MAX],no ;
  static void nQueens(int k,int n){
    for(int i=1 ; i<=n ; i++){
      if(canPlace(k,i)){
        arr[k]=i ;
        if(k==n){
          display(n);
        }
        else {
          nQueens(k+1,n);
        }
      }
    }
  }
  static boolean canPlace(int k,int i){
    for(int j=1 ; j<=k-1 ; j++){
      if(arr[j]==i ||(Math.abs(arr[j]-i)==Math.abs(j-k))){
        return false ;
      }
    }
    return true ;
  }
  static void display(int n){
    breakLine();
    System.out.print("Arrangement No."+++no);
    breakLine();
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=n ; j++){
        if(arr[i]!=j){
          System.out.print("\t_");
        }
        else {
          System.out.print("\tQ");
        }
      }
      System.out.println("");
    }
    breakLine();
  }
  public static void main(String[] args){
    int n=4 ;
    nQueens(1,n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation breakLine() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("\n---------------------------------\n") );
  static   attribute MAX : int := 10;
  static   attribute arr : int := Integer.subrange(1,MAX)->collect(0);
  static   operation nQueens( k : int, n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= n do ( (     if (canPlace(k, i)) then (     arr[k+1] := i ; 
     if (k = n) then (     execute display(n) ) else (     execute nQueens(k + 1, n) ) ) else skip )  ;     i := i + 1 ) );
  static   operation canPlace( k : int, i : int) : boolean
  pre: true
  post: true
  activity: (         var j : int ; j := 1 ; while j <= k - 1 do ( (     if (arr[j+1] = i or (if arr[j+1] - i < 0 then -(arr[j+1] - i) else arr[j+1] - i endif = if j - k < 0 then -(j - k) else j - k endif)) then (     return false ) else skip )  ;     j := j + 1 ) ; 
     return true );
  static   operation display( n : int) : void
  pre: true
  post: true
  activity: (     execute breakLine() ; 
     OclFile["System.out"].print("Arrangement No." + no) ; 
    execute breakLine() ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     if (arr[i+1] /= j) then (     OclFile["System.out"].print("\t_") ) else (     OclFile["System.out"].print("\tQ") ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("") )  ;     i := i + 1 ) ; 
    execute breakLine() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     execute nQueens(1, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countWays(int n){
    int counter=0 ;
    for(int i=1 ; i<n ; i++)for(int j=i ; j<n ; j++)for(int k=j ; k<n ; k++)for(int l=k ; l<n ; l++)if(i+j+k+l==n)counter++;
    return counter ;
  }
  public static void main(String[] args){
    int n=8 ;
    System.out.println(countWays(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countWays( n : int) : int
  pre: true
  post: true
  activity: (     var counter : int ; counter := 0 ;
         var i : int ; i := 1 ; while i < n do (         var j : int ; j := i ; while j < n do (         var k : int ; k := j ; while k < n do (         var l : int ; l := k ; while l < n do (     if (i + j + k + l = n) then     counter := counter + 1 ; else skip ;  ;     l := l + 1 ) ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return counter );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     OclFile["System.out"].println(countWays(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class modify {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q,n,i,j,p,k ;
    String s,t,w,str ;
    q=sc.nextInt();
    for(j=1 ; j<=q ; j++){
      n=sc.nextInt();
      s=sc.next();
      str="" ;
      for(i=0 ; i<n ; i++)str=s.charAt(i)+str ;
      for(i=97 ; i<=122 ; i++){
        if(s.indexOf((char)i)>=0)break ;
      }
      p=1 ;
      k=i ;
      t=s ;
      if(n % 2==0){
        for(i=0 ; i<n ; i++){
          if(s.charAt(i)==(char)k){
            w=s.substring(i);
            if(i % 2==0)w=w+s.substring(0,i);
            else w=w+str.substring(n-i);
            if(w.compareTo(t)<0){
              p=(i+1);
              t=w ;
            }
          }
        }
      }
      else {
        for(i=0 ; i<n ; i++){
          if(s.charAt(i)==(char)k){
            w=s.substring(i);
            if(i % 2==1)w=w+s.substring(0,i);
            else w=w+str.substring(n-i);
            if(w.compareTo(t)<0){
              p=(i+1);
              t=w ;
            }
          }
        }
      }
      System.out.println(t);
      System.out.println(p);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class modify {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ;
    var n : int ;
    var i : int ;
    var j : int ;
    var p : int ;
    var k : int ;
    var s : String ;
    var t : String ;
    var w : String ;
    var str : String ;
    q := sc.getCurrent()->toInteger() ; 
        j := 1 ; while j <= q do ( (     n := sc.getCurrent()->toInteger() ; 
     s := sc.getCurrent() ; 
    str := "" ; 
        i := 0 ; while i < n do (     str := s->at(i+1) + str ;  ;     i := i + 1 ) ; 
        i := 97 ; while i <= 122 do ( (     if (s->indexOf(i->oclAsType(String))-1 >= 0) then     break else skip )  ;     i := i + 1 ) ; 
    p := 1 ; 
    k := i ; 
    t := s ; 
    if (n mod 2 = 0) then (         i := 0 ; while i < n do ( (     if (s->at(i+1) = k->oclAsType(String)) then (     w := s.subrange(i+1,i) ; 
     if (i mod 2 = 0) then     w := w + s.subrange(0+1,i) else     w := w + str.subrange(n - i+1,n - i) ; ;  
     if (w->compareTo(t) < 0) then (     p := (i + 1) ; 
     t := w ) else skip ) else skip )  ;     i := i + 1 ) ) else (         i := 0 ; while i < n do ( (     if (s->at(i+1) = k->oclAsType(String)) then (     w := s.subrange(i+1,i) ; 
     if (i mod 2 = 1) then     w := w + s.subrange(0+1,i) else     w := w + str.subrange(n - i+1,n - i) ; ;  
     if (w->compareTo(t) < 0) then (     p := (i + 1) ; 
     t := w ) else skip ) else skip )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(t) ; 
    OclFile["System.out"].println(p) ; 
 )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class StringModification {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t!=0){
      solve(br,pr);
      t--;
    }
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    String s=br.readLine();
    StringBuffer sBuffer=new StringBuffer(s);
    int k=1 ;
    String res=s ;
    sBuffer=new StringBuffer(s);
    for(int i=0 ; i<n ; i++){
      int tempK=i+1 ;
      String first=s.substring(tempK-1,n);
      StringBuffer second=new StringBuffer(s.substring(0,tempK-1));
      if(tempK % 2==n % 2){
        second=second.reverse();
        String sec=second.toString();
        String temp=first+sec ;
        if(temp.compareTo(res)<0){
          k=tempK ;
          res=temp ;
        }
      }
      else {
        String sec=second.toString();
        String temp=first+sec ;
        if(temp.compareTo(res)<0){
          k=tempK ;
          res=temp ;
        }
      }
    }
    StringBuffer total=new StringBuffer(s);
    total=total.reverse();
    if(total.toString().compareTo(res)<0){
      res=total.toString();
      k=n ;
    }
    pr.println(res);
    pr.println(k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class StringModification {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
    while (t /= 0) do (     execute solve(br, pr) ; 
     t := t - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var s : String ; s := br.readLine() ;
    var sBuffer : String ; sBuffer := StringLib.newString(s) ;
    var k : int ; k := 1 ;
    var res : String ; res := s ;
    sBuffer := StringLib.newString(s) ; 
        var i : int ; i := 0 ; while i < n do ( (     var tempK : int ; tempK := i + 1 ;
     var first : String ; first := s.subrange(tempK - 1+1,n) ;
     var second : String ; second := StringLib.newString(s.subrange(0+1,tempK - 1)) ;
     if (tempK mod 2 = n mod 2) then (     second := second->reverse() ;     second := second->reverse() ; 
     var sec : String ; sec := second+"" ;
     var temp : String ; temp := first + sec ;
     if (temp->compareTo(res) < 0) then (     k := tempK ; 
     res := temp ) else skip ) else (     var sec : String ; sec := second+"" ;
     var temp : String ; temp := first + sec ;
     if (temp->compareTo(res) < 0) then (     k := tempK ; 
     res := temp ) else skip ) )  ;     i := i + 1 ) ; 
    var total : String ; total := StringLib.newString(s) ;
    total := total->reverse() ;     total := total->reverse() ; 
    if (total+""->compareTo(res) < 0) then (     res := total+"" ; 
     k := n ) else skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    if(k==1){
      System.out.println("1");
      System.out.println("1");
    }
    else if(k==2){
      System.out.println("2");
      System.out.println("1 2");
      System.out.println("2 1");
    }
    else if(k==3){
      System.out.println("2");
      System.out.println("1 2");
      System.out.println("3 1");
    }
    else if(k==4){
      System.out.println("2");
      System.out.println("1 2");
      System.out.println("3 4");
    }
    else {
      int cut=4-k % 4 ;
      int n ;
      int amari ;
      if(cut!=4){
        n=(k+cut)/2 ;
      }
      else {
        n=k/2 ;
        cut=0 ;
      }
      System.out.println(n);
      for(int r=0 ; r<n ; r++){
        for(int c=0 ; c<n ; c++){
          if(r % 2==0){
            System.out.print((c+r)% n+1+" ");
          }
          else {
            amari=(c+r)% n ;
            if(amari==n-1 && cut>=1 || amari==n-2 && cut>=2 || amari==n-3 && cut>=3){
              System.out.print((c+r)% n+1+" ");
            }
            else {
              System.out.print((c+r)% n+n+1+" ");
            }
          }
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     if (k = 1) then (     OclFile["System.out"].println("1") ; 
     OclFile["System.out"].println("1") ) else     if (k = 2) then (     OclFile["System.out"].println("2") ; 
     OclFile["System.out"].println("1 2") ; 
     OclFile["System.out"].println("2 1") ) else     if (k = 3) then (     OclFile["System.out"].println("2") ; 
     OclFile["System.out"].println("1 2") ; 
     OclFile["System.out"].println("3 1") ) else     if (k = 4) then (     OclFile["System.out"].println("2") ; 
     OclFile["System.out"].println("1 2") ; 
     OclFile["System.out"].println("3 4") ) else (     var cut : int ; cut := 4 - k mod 4 ;
     var n : int ;
    var amari : int ;
    if (cut /= 4) then (     n := (k + cut) / 2 ) else (     n := k / 2 ; 
     cut := 0 ) ;  
    OclFile["System.out"].println(n) ; 
        var r : int ; r := 0 ; while r < n do ( (         var c : int ; c := 0 ; while c < n do ( (     if (r mod 2 = 0) then (     OclFile["System.out"].print((c + r) mod n + 1 + " ") ) else (     amari := (c + r) mod n ; 
     if (amari = n - 1 & cut >= 1 or amari = n - 2 & cut >= 2 or amari = n - 3 & cut >= 3) then (     OclFile["System.out"].print((c + r) mod n + 1 + " ") ) else (     OclFile["System.out"].print((c + r) mod n + n + 1 + " ") ) ) )  ;     c := c + 1 ) ; 
     OclFile["System.out"].println() )  ;     r := r + 1 ) ; 
 ) ;  ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    if(k==1){
      System.out.println(1);
      System.out.print(1);
      return ;
    }
    int n=2*((k+3)/4);
    int curt=n*2-k ;
    int[][] mat=new int[n][n];
    for(int r=0 ; r<n ; r++){
      for(int c=0 ; c<n ; c++){
        if(r % 2==1 &&(r+c)% n<n-curt){
          mat[r][c]=n+(r+c)% n ;
          mat[r][c]++;
        }
        else {
          mat[r][c]=(r+c)% n ;
          mat[r][c]++;
        }
      }
    }
    System.out.println(n);
    for(int[] row : mat){
      for(int x : row){
        System.out.print(x+" ");
      }
      System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    if (k = 1) then (     OclFile["System.out"].println(1) ; 
     OclFile["System.out"].print(1) ; 
     return ) else skip ; 
    var n : int ; n := 2 * ((k + 3) / 4) ;
    var curt : int ; curt := n * 2 - k ;
    var mat : Sequence(Sequence(int)) ; mat := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var r : int ; r := 0 ; while r < n do ( (         var c : int ; c := 0 ; while c < n do ( (     if (r mod 2 = 1 & (r + c) mod n < n - curt) then (     mat[r+1][c+1] := n + (r + c) mod n ; 
     mat[r+1][c+1] := mat[r+1][c+1] + 1 ) else (     mat[r+1][c+1] := (r + c) mod n ; 
     mat[r+1][c+1] := mat[r+1][c+1] + 1 ) )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    OclFile["System.out"].println(n) ; 
    for (row : mat) do ( (     for (x : row) do ( (     OclFile["System.out"].print(x + " ") )  ) ; 
     OclFile["System.out"].println("") )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    if(k==1){
      System.out.println(1);
      System.out.print(1);
      return ;
    }
    int n=2*((k+3)/4);
    int curt=n*2-k ;
    int[][] mat=new int[n][n];
    for(int r=0 ; r<n ; r++){
      for(int c=0 ; c<n ; c++){
        if(r % 2==1 &&(r+c)% n<n-curt){
          mat[r][c]=n+(r+c)% n ;
          mat[r][c]++;
        }
        else {
          mat[r][c]=(r+c)% n ;
          mat[r][c]++;
        }
      }
    }
    int rr=1 ;
    System.out.println(n);
    for(int[] row : mat){
      int cc=1 ;
      for(int x : row){
        System.out.print(x);
        if(cc<n)System.out.print(" ");
        cc++;
      }
      if(rr<n)System.out.println("");
      rr++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    if (k = 1) then (     OclFile["System.out"].println(1) ; 
     OclFile["System.out"].print(1) ; 
     return ) else skip ; 
    var n : int ; n := 2 * ((k + 3) / 4) ;
    var curt : int ; curt := n * 2 - k ;
    var mat : Sequence(Sequence(int)) ; mat := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var r : int ; r := 0 ; while r < n do ( (         var c : int ; c := 0 ; while c < n do ( (     if (r mod 2 = 1 & (r + c) mod n < n - curt) then (     mat[r+1][c+1] := n + (r + c) mod n ; 
     mat[r+1][c+1] := mat[r+1][c+1] + 1 ) else (     mat[r+1][c+1] := (r + c) mod n ; 
     mat[r+1][c+1] := mat[r+1][c+1] + 1 ) )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    var rr : int ; rr := 1 ;
    OclFile["System.out"].println(n) ; 
    for (row : mat) do ( (     var cc : int ; cc := 1 ;
     for (x : row) do ( (     OclFile["System.out"].print(x) ; 
     if (cc < n) then     OclFile["System.out"].print(" ") ; else skip ; 
     cc := cc + 1 )  ) ; 
     if (rr < n) then     OclFile["System.out"].println("") ; else skip ; 
     rr := rr + 1 )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
import static java.lang.System.exit ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  static void solve()throws Exception {
    int k=scanInt(),n ;
    if(k==1){
      n=1 ;
    }
    else {
      n=(k+3)/4*2 ;
    }
    out.println(n);
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        int d=(i+j)% n ;
        out.print((d<k-n && j % 2!=0 ? d+n : d)+1+" ");
      }
      out.println();
    }
  }
  static int scanInt()throws IOException {
    return parseInt(scanString());
  }
  static long scanLong()throws IOException {
    return parseLong(scanString());
  }
  static String scanString()throws IOException {
    while(tok==null || ! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  public static void main(String[] args){
    try {
      in=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(System.out);
      solve();
      in.close();
      out.close();
    }
    catch(Throwable e){
      e.printStackTrace();
      exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var k : int ; k := scanInt() ;
    var n : int ;
     if (k = 1) then (     n := 1 ) else (     n := (k + 3) / 4 * 2 ) ;  
     out.println(n) ; 
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     var d : int ; d := (i + j) mod n ;
     out.print((if d < k - n & j mod 2 /= 0 then d + n else d endif) + 1 + " ") )  ;     j := j + 1 ) ; 
     out.println() )  ;     i := i + 1 ) );
  static   operation scanInt() : int
  pre: true
  post: true
  activity: (     return (scanString() + "")->toInteger() );
  static   operation scanLong() : long
  pre: true
  post: true
  activity: (     return parseLong(scanString()) );
  static   operation scanString() : String
  pre: true
  post: true
  activity: (     while (tok = null or not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return tok.next() );
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
     execute exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  long patty[]=new long[51];
  long size[]=new long[51];
  public void main(Scanner sc){
    int n=sc.nextInt();
    long x=sc.nextLong();
    patty[0]=1 ;
    size[0]=1 ;
    for(int i=1 ; i<=50 ; i++){
      patty[i]=patty[i-1]*2+1 ;
      size[i]=patty[i]*2-1 ;
    }
    System.out.println(calc(n,x));
  }
  private long calc(int level,long x){
    if(x==0){
      return 0 ;
    }
    if(x>=size[level]){
      return patty[level];
    }
    if(x*2>size[level]){
      return patty[level-1]+1+calc(level-1,x-size[level-1]-2);
    }
    else {
      return calc(level-1,x-1);
    }
  }
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      new Main().main(sc);
    }
    catch(Exception e){
      throw e ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute patty : long := Integer.subrange(1,51)->collect(0);
   attribute size : long := Integer.subrange(1,51)->collect(0);
   operation main( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var x : long ; x := sc.nextLong() ;
    patty[0+1] := 1 ; 
    size[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= 50 do ( (     patty[i+1] := patty[i - 1+1] * 2 + 1 ; 
     size[i+1] := patty[i+1] * 2 - 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(calc(n, x)) ; 
 );
   operation calc( level : int, x : long) : long
  pre: true
  post: true
  activity: (     if (x = 0) then (     return 0 ) else skip ; 
     if (x >= size[level+1]) then (     return patty[level+1] ) else skip ; 
     if (x * 2 > size[level+1]) then (     return patty[level - 1+1] + 1 + calc(level - 1, x - size[level - 1+1] - 2) ) else (     return calc(level - 1, x - 1) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     Main.newMain().main(sc) ))   catch (e : ProgramException) do (     error e )
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int L=2*N-1 ;
    int[] a=new int[L];
    for(int i=0 ; i<L ; i++)a[i]=sc.nextInt();
    int min=1 ;
    int max=L ;
    boolean b[]=new boolean[L];
    while(min+1<max){
      int mid=(min+max)/2 ;
      for(int i=0 ; i<L ; i++)b[i]=a[i]>=mid ;
      if(satisfy(b))min=mid ;
      else max=mid ;
    }
    System.out.println(min);
    sc.close();
  }
  static boolean satisfy(boolean[] b){
    int L=b.length ;
    int N=(L+1)/2 ;
    int l=N-1 ;
    while(l>0 && b[l]!=b[l-1])l--;
    int r=N-1 ;
    while(r<L-1 && b[r]!=b[r+1])r++;
    if(l>0){
      if(r<L-1){
        if(b[l]==b[r])return b[l];
        else return(l+r)/2>=N-1 ? b[l] : b[r];
      }
      else {
        return b[l];
      }
    }
    else if(r<L-1){
      return b[r];
    }
    else {
      return b[N-1] ^ N % 2==0 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var L : int ; L := 2 * N - 1 ;
    var a : Sequence(int) ; a := Integer.subrange(1,L)->collect(0) ;
        var i : int ; i := 0 ; while i < L do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var min : int ; min := 1 ;
    var max : int ; max := L ;
    var b : Sequence(boolean) ; b := Integer.subrange(1,L)->collect(false) ;
    while (min + 1 < max) do (     var mid : int ; mid := (min + max) / 2 ;
         var i : int ; i := 0 ; while i < L do (     b[i+1] := a[i+1] >= mid ;  ;     i := i + 1 ) ; 
     if (satisfy(b)) then     min := mid ; else     max := mid ; ) ; 
    OclFile["System.out"].println(min) ; 
    skip ; 
 );
  static   operation satisfy( b : Sequence(boolean)) : boolean
  pre: true
  post: true
  activity: (     var L : int ; L := b->size() ;
     var N : int ; N := (L + 1) / 2 ;
    var l : int ; l := N - 1 ;
    while (l > 0 & b[l+1] /= b[l - 1+1]) do     l := l - 1 ; ; 
    var r : int ; r := N - 1 ;
    while (r < L - 1 & b[r+1] /= b[r + 1+1]) do     r := r + 1 ; ; 
    if (l > 0) then (     if (r < L - 1) then (     if (b[l+1] = b[r+1]) then     return b[l+1] else     return if (l + r) / 2 >= N - 1 then b[l+1] else b[r+1] endif ) else (     return b[l+1] ) ) else     if (r < L - 1) then (     return b[r+1] ) else (     return b[N - 1+1] xor N mod 2 = 0 ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class LinearSearch {
  static int countRotations(int arr[],int n){
    int min=arr[0],min_index=-1 ;
    for(int i=0 ; i<n ; i++){
      if(min>arr[i]){
        min=arr[i];
        min_index=i ;
      }
    }
    return min_index ;
  }
  public static void main(String[] args){
    int arr[]={
      15,18,2,3,6,12 };
      int n=arr.length ;
      System.out.println(countRotations(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class LinearSearch {
  static   operation countRotations( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var min : int ; min := arr[0+1] ;
    var min_index : int ; min_index := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (min > arr[i+1]) then (     min := arr[i+1] ; 
     min_index := i ) else skip )  ;     i := i + 1 ) ; 
     return min_index );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{15,18,2,3,6,12} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countRotations(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class sum_dig {
  static int countRec(int n,int sum){
    if(n==0)return sum==0 ? 1 : 0 ;
    if(sum==0)return 1 ;
    int ans=0 ;
    for(int i=0 ; i<=9 ; i++)if(sum-i>=0)ans+=countRec(n-1,sum-i);
    return ans ;
  }
  static int finalCount(int n,int sum){
    int ans=0 ;
    for(int i=1 ; i<=9 ; i++)if(sum-i>=0)ans+=countRec(n-1,sum-i);
    return ans ;
  }
  public static void main(String args[]){
    int n=2,sum=5 ;
    System.out.println(finalCount(n,sum));
  }
}
------------------------------------------------------------
OCL File:
---------
class sum_dig {
  static   operation countRec( n : int, sum : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return if sum = 0 then 1 else 0 endif else skip ; 
     if (sum = 0) then     return 1 else skip ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i <= 9 do (     if (sum - i >= 0) then     ans := ans+(countRec(n - 1, sum - i)) ; else skip ;  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation finalCount( n : int, sum : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i <= 9 do (     if (sum - i >= 0) then     ans := ans+(countRec(n - 1, sum - i)) ; else skip ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
    var sum : int ; sum := 5 ;
     OclFile["System.out"].println(finalCount(n, sum)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int numberOfMinutes(int S,int S1){
    int Min=0 ;
    Min=(int)(((S-S1)/Math.floor(S))*60);
    return Min ;
  }
  public static void main(String[] args){
    int S=30,S1=10 ;
    System.out.println(numberOfMinutes(S,S1)+" min");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation numberOfMinutes( S : int, S1 : int) : int
  pre: true
  post: true
  activity: (     var Min : int ; Min := 0 ;
     Min := (((S - S1) / (S)->floor()) * 60)->oclAsType(int) ; 
     return Min );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : int ; S := 30 ;
    var S1 : int ; S1 := 10 ;
     OclFile["System.out"].println(numberOfMinutes(S, S1) + " min") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class sum_dig {
  static int lookup[][]=new int[101][501];
  static int countRec(int n,int sum){
    if(n==0)return sum==0 ? 1 : 0 ;
    if(lookup[n][sum]!=-1)return lookup[n][sum];
    int ans=0 ;
    for(int i=0 ; i<10 ; i++)if(sum-i>=0)ans+=countRec(n-1,sum-i);
    return lookup[n][sum]=ans ;
  }
  static int finalCount(int n,int sum){
    for(int i=0 ; i<=100 ; ++i){
      for(int j=0 ; j<=500 ; ++j){
        lookup[i][j]=-1 ;
      }
    }
    int ans=0 ;
    for(int i=1 ; i<=9 ; i++)if(sum-i>=0)ans+=countRec(n-1,sum-i);
    return ans ;
  }
  public static void main(String args[]){
    int n=3,sum=5 ;
    System.out.println(finalCount(n,sum));
  }
}
------------------------------------------------------------
OCL File:
---------
class sum_dig {
  static   attribute lookup : int := Integer.subrange(1,101)->collect(Integer.subrange(1,501)->collect(0));
  static   operation countRec( n : int, sum : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return if sum = 0 then 1 else 0 endif else skip ; 
     if (lookup[n+1][sum+1] /= -1) then     return lookup[n+1][sum+1] else skip ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 10 do (     if (sum - i >= 0) then     ans := ans+(countRec(n - 1, sum - i)) ; else skip ;  ;     i := i + 1 ) ; 
    return lookup[n+1][sum+1] 
 );
  static   operation finalCount( n : int, sum : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= 100 do ( (         var j : int ; j := 0 ; while j <= 500 do ( (     lookup[i+1][j+1] := -1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i <= 9 do (     if (sum - i >= 0) then     ans := ans+(countRec(n - 1, sum - i)) ; else skip ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
    var sum : int ; sum := 5 ;
     OclFile["System.out"].println(finalCount(n, sum)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countIndices(int arr[],int n){
    int cnt=0 ;
    int max=0 ;
    for(int i=0 ; i<n ; i++){
      if(max<arr[i]){
        max=arr[i];
        cnt++;
      }
    }
    return cnt ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4 };
      int n=arr.length ;
      System.out.println(countIndices(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countIndices( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var max : int ; max := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (max < arr[i+1]) then (     max := arr[i+1] ; 
     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countIndices(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int slopeOfNum(String num,int n){
    int slope=0 ;
    for(int i=1 ; i<n-1 ; i++){
      if(num.charAt(i)>num.charAt(i-1)&& num.charAt(i)>num.charAt(i+1))slope++;
      else if(num.charAt(i)<num.charAt(i-1)&& num.charAt(i)<num.charAt(i+1))slope++;
    }
    return slope ;
  }
  public static void main(String[] args){
    String num="1213321" ;
    int n=num.length();
    System.out.println("Slope="+slopeOfNum(num,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation slopeOfNum( num : String, n : int) : int
  pre: true
  post: true
  activity: (     var slope : int ; slope := 0 ;
         var i : int ; i := 1 ; while i < n - 1 do ( (     if (num->at(i+1) > num->at(i - 1+1) & num->at(i+1) > num->at(i + 1+1)) then     slope := slope + 1 ; else     if (num->at(i+1) < num->at(i - 1+1) & num->at(i+1) < num->at(i + 1+1)) then     slope := slope + 1 ; else skip ; )  ;     i := i + 1 ) ; 
     return slope );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : String ; num := "1213321" ;
     var n : int ; n := num->size() ;
     OclFile["System.out"].println("Slope=" + slopeOfNum(num, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findNth(int N){
    int b=14 ;
    int i ;
    for(i=2 ; i<=N ; i++){
      if(i % 2==0)b=b*2 ;
      else b=b-8 ;
    }
    return b ;
  }
  public static void main(String[] args){
    int N=6 ;
    System.out.print(findNth(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNth( N : int) : int
  pre: true
  post: true
  activity: (     var b : int ; b := 14 ;
     var i : int ;
         i := 2 ; while i <= N do ( (     if (i mod 2 = 0) then     b := b * 2 ; else     b := b - 8 ; )  ;     i := i + 1 ) ; 
     return b );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 6 ;
     OclFile["System.out"].print(findNth(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int binarySearchCount(int arr[],int n,int key){
    int left=0,right=n ;
    int mid=0 ;
    while(left<right){
      mid=(right+left)>>1 ;
      if(arr[mid]==key){
        while(mid+1<n && arr[mid+1]==key)mid++;
        break ;
      }
      else if(arr[mid]>key)right=mid ;
      else left=mid+1 ;
    }
    while(mid>-1 && arr[mid]>key)mid--;
    return mid+1 ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,4,5,8,10 };
      int key=11 ;
      int n=arr.length ;
      System.out.print(binarySearchCount(arr,n,key));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation binarySearchCount( arr : Sequence(int), n : int, key : int) : int
  pre: true
  post: true
  activity: (     var left : int ; left := 0 ;
    var right : int ; right := n ;
     var mid : int ; mid := 0 ;
    while (left < right) do (     mid := ((right + left)/(2->pow(1)))->oclAsType(long) ; 
     if (arr[mid+1] = key) then (     while (mid + 1 < n & arr[mid + 1+1] = key) do     mid := mid + 1 ; ; 
     break ) else     if (arr[mid+1] > key) then     right := mid else     left := mid + 1 ; ;  ) ; 
    while (mid > -1 & arr[mid+1] > key) do     mid := mid - 1 ; ; 
    return mid + 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,4,5,8,10} ;
     var key : int ; key := 11 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(binarySearchCount(arr, n, key)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isPowerOfTwo(int x){
    return(x>0 &&(!((x &(x-1))>0)));
  }
  static void Count_pairs(int a[],int n){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(isPowerOfTwo(a[i]))count++;
    }
    int ans=(count*(count-1))/2 ;
    System.out.println(ans);
  }
  public static void main(String[] args){
    int a[]={
      2,5,8,16,128 };
      int n=a.length ;
      Count_pairs(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPowerOfTwo( x : int) : boolean
  pre: true
  post: true
  activity: (     return (x > 0 & (not(((x & (x - 1)) > 0)))) );
  static   operation Count_pairs( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (isPowerOfTwo(a[i+1])) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     var ans : int ; ans := (count * (count - 1)) / 2 ;
     OclFile["System.out"].println(ans) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,5,8,16,128} ;
     var n : int ; n := a->size() ;
     execute Count_pairs(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
import static java.lang.Math.max ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(--T>=0){
      int n=sc.nextInt();
      int cnt=0 ;
      for(int i=0 ; i<=29 ; ++i){
        if((n &(1<<i))!=0){
          cnt+=1 ;
        }
      }
      System.out.println((int)(Math.pow(2,cnt)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         T := T - 1 ;
    while ((T - 1) >= 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i <= 29 do ( (     if ((MathLib.bitwiseAnd(n,((1*(2->pow(i)))->oclAsType(long)))) /= 0) then (     cnt := cnt+(1) ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println((2->pow(cnt))->oclAsType(int)) ) ;     T := T - 1 ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int cntSubsets(int[] arr,int n){
    int max=(int)Math.pow(2,n);
    int result=0 ;
    for(int i=0 ; i<max ; i++){
      int counter=i ;
      if((counter &(counter>>1))>0)continue ;
      result++;
    }
    return result ;
  }
  static public void main(String[] arg){
    int arr[]={
      3,5,7 };
      int n=arr.length ;
      System.out.println(cntSubsets(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation cntSubsets( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max : int ; max := 2->pow(n)->oclAsType(int) ;
     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < max do ( (     var counter : int ; counter := i ;
     if ((MathLib.bitwiseAnd(counter,((counter/(2->pow(1)))->oclAsType(long)))) > 0) then     continue else skip ; 
     result := result + 1 )  ;     i := i + 1 ) ; 
     return result );
  static    operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,5,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(cntSubsets(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileInputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class Eipair {
  public static void main(String[] args)throws IOException {
    InputReader sc=new InputReader(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      long c=Long.bitCount(a);
      System.out.println((long)Math.pow(2,c));
    }
  }
  static class InputReader {
    StringTokenizer tokenizer ;
    BufferedReader reader ;
    String token ;
    String temp ;
    public InputReader(InputStream stream){
      tokenizer=null ;
      reader=new BufferedReader(new InputStreamReader(stream));
    }
    public InputReader(FileInputStream stream){
      tokenizer=null ;
      reader=new BufferedReader(new InputStreamReader(stream));
    }
    public String nextLine()throws IOException {
      return reader.readLine();
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          if(temp!=null){
            tokenizer=new StringTokenizer(temp);
            temp=null ;
          }
          else {
            tokenizer=new StringTokenizer(reader.readLine());
          }
        }
        catch(IOException e){
        }
      }
      return tokenizer.nextToken();
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Eipair {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : InputReader ; sc := InputReader.newInputReader(OclFile["System.in"]) ;
     var n : int ; n := sc.nextInt() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.nextInt() ;
     var c : long ; c := bitCount(a) ;
     OclFile["System.out"].println(2->pow(c)->oclAsType(long)) )  ;     i := i + 1 ) );
  static class InputReader {
   attribute tokenizer : OclIterator;
   attribute reader : OclFile;
   attribute token : String;
   attribute temp : String;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     tokenizer := null ; 
     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     tokenizer := null ; 
     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return reader.readLine() );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     if (temp /= null) then (     tokenizer := OclIterator.newOclIterator_String(temp) ; 
     temp := null ) else (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (e : IOException) do skip
 ) ; 
     return tokenizer.next() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B {
  public static void solve(int x){
    int c=0 ;
    for(int i=0 ; i<=31 ; i++){
      if((x &(1<<i))!=0)c++;
    }
    System.out.printf("%d\n",1<<c);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t ;
    t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int v=sc.nextInt();
      solve(v);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation solve( x : int) : void
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
         var i : int ; i := 0 ; while i <= 31 do ( (     if ((x & ((1*(2->pow(i)))->oclAsType(long))) /= 0) then     c := c + 1 ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].printf("%d\n", (1*(2->pow(c)))->oclAsType(long)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ;
     t := sc.getCurrent()->toInteger() ; 
         var i : int ; i := 0 ; while i < t do ( (     var v : int ; v := sc.getCurrent()->toInteger() ;
     execute solve(v) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Samyak {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long x=sc.nextLong();
      long y=sc.nextLong();
      System.out.println(y+(x-1)*9);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Samyak {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x : long ; x := sc.getCurrent()->toLong() ;
     var y : long ; y := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println(y + (x - 1) * 9) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class magic {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    long out[]=new long[t];
    for(int i=0 ; i<t ; i++){
      String str=Long.toBinaryString(sc.nextLong());
      int k=0 ;
      int n=str.length();
      for(int j=0 ; j<n ; j++){
        if(str.charAt(j)=='1')k++;
      }
      out[i]=(long)Math.pow(2,k);
    }
    for(int i=0 ; i<t ; i++){
      System.out.println(out[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class magic {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var out : Sequence(long) ; out := Integer.subrange(1,t)->collect(0) ;
        var i : int ; i := 0 ; while i < t do ( (     var str : String ; str := (MathLib.decimal2binary(sc.getCurrent()->toLong()) + "") ;
     var k : int ; k := 0 ;
    var n : int ; n := str->size() ;
        var j : int ; j := 0 ; while j < n do ( (     if (str->at(j+1) = '1') then     k := k + 1 ; else skip )  ;     j := j + 1 ) ; 
    out[i+1] := 2->pow(k)->oclAsType(long) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < t do ( (     OclFile["System.out"].println(out[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    int a,b,C ;
    double sin,cos,S,L,h ;
    Scanner scan=new Scanner(System.in);
    a=scan.nextInt();
    b=scan.nextInt();
    C=scan.nextInt();
    sin=Math.sin(Math.toRadians(C));
    cos=Math.cos(Math.toRadians(C));
    S=a*b*sin/2 ;
    L=a+b+Math.sqrt(a*a+b*b-2*a*b*cos);
    h=b*sin ;
    System.out.println(S);
    System.out.println(L);
    System.out.println(h);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ;
    var b : int ;
    var C : int ;
     var sin : double ;
    var cos : double ;
    var S : double ;
    var L : double ;
    var h : double ;
    var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    a := scan.getCurrent()->toInteger() ; 
    b := scan.getCurrent()->toInteger() ; 
    C := scan.getCurrent()->toInteger() ; 
    sin := ((0.017453292519943295*(C)))->sin() ; 
    cos := ((0.017453292519943295*(C)))->cos() ; 
    S := a * b * sin / 2 ; 
    L := a + b + (a * a + b * b - 2 * a * b * cos)->sqrt() ; 
    h := b * sin ; 
    OclFile["System.out"].println(S) ; 
    OclFile["System.out"].println(L) ; 
    OclFile["System.out"].println(h) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=br.readLine();
    String[] strArray=str.split(" ");
    double para[]=new double[3];
    double S,L,h ;
    for(int i=0 ; i<strArray.length ; i++){
      para[i]=Double.parseDouble(strArray[i]);
    }
    S=(para[0]*para[1]*Math.sin(Math.toRadians(para[2])))/2 ;
    L=para[0]+para[1]+Math.sqrt(Math.pow(para[0],2)+Math.pow(para[1],2)-2*para[0]*para[1]*Math.cos(Math.toRadians(para[2])));
    h=para[1]*Math.sin(Math.toRadians(para[2]));
    System.out.println(S);
    System.out.println(L);
    System.out.println(h);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := br.readLine() ;
    var strArray : Sequence(String) ; strArray := str->split(" ") ;
    var para : Sequence(double) ; para := Integer.subrange(1,3)->collect(0.0) ;
    var S : double ;
    var L : double ;
    var h : double ;
        var i : int ; i := 0 ; while i < strArray->size() do ( (     para[i+1] := (strArray[i+1])->toReal() )  ;     i := i + 1 ) ; 
    S := (para[0+1] * para[1+1] * ((0.017453292519943295*(para[2+1])))->sin()) / 2 ; 
    L := para[0+1] + para[1+1] + (para[0+1]->pow(2) + para[1+1]->pow(2) - 2 * para[0+1] * para[1+1] * ((0.017453292519943295*(para[2+1])))->cos())->sqrt() ; 
    h := para[1+1] * ((0.017453292519943295*(para[2+1])))->sin() ; 
    OclFile["System.out"].println(S) ; 
    OclFile["System.out"].println(L) ; 
    OclFile["System.out"].println(h) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    double a=in.nextDouble(),b=in.nextDouble(),C=in.nextDouble();
    C=Math.toRadians(C);
    double c=Math.sqrt(a*a+b*b-2*a*b*Math.cos(C));
    double S=0.5*a*b*Math.sin(C);
    double L=a+b+c ;
    double h=b*Math.sin(C);
    System.out.printf("%.8f\n",S);
    System.out.printf("%.8f\n",L);
    System.out.printf("%.8f\n",h);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : double ; a := in.getCurrent()->toReal() ;
    var b : double ; b := in.getCurrent()->toReal() ;
    var C : double ; C := in.getCurrent()->toReal() ;
    C := (0.017453292519943295*(C)) ; 
    var c : double ; c := (a * a + b * b - 2 * a * b * (C)->cos())->sqrt() ;
    var S : double ; S := 0.5 * a * b * (C)->sin() ;
    var L : double ; L := a + b + c ;
    var h : double ; h := b * (C)->sin() ;
    OclFile["System.out"].printf("%.8f\n", S) ; 
    OclFile["System.out"].printf("%.8f\n", L) ; 
    OclFile["System.out"].printf("%.8f\n", h) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int count=0 ;
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner sc2=new Scanner(System.in);
    String[] s=sc2.nextLine().split("[\\s]+");
    double a=Double.parseDouble(s[0]);
    double b=Double.parseDouble(s[1]);
    double theta=Double.parseDouble(s[2])*(Math.PI/180);
    double c=Math.sqrt(a*a+b*b-2*a*b*Math.cos(theta));
    double s1=0.5*a*b*Math.sin(theta);
    double h=(2*s1)/a ;
    System.out.println(s1);
    System.out.println(a+b+c);
    System.out.println(h);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute count : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc2 : OclFile ; sc2 := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc2.nextLine()->split("[\\s]+") ;
    var a : double ; a := (s[0+1])->toReal() ;
    var b : double ; b := (s[1+1])->toReal() ;
    var theta : double ; theta := (s[2+1])->toReal() * (3.141592653589793 / 180) ;
    var c : double ; c := (a * a + b * b - 2 * a * b * (theta)->cos())->sqrt() ;
    var s1 : double ; s1 := 0.5 * a * b * (theta)->sin() ;
    var h : double ; h := (2 * s1) / a ;
    OclFile["System.out"].println(s1) ; 
    OclFile["System.out"].println(a + b + c) ; 
    OclFile["System.out"].println(h) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String[] tmp=in.readLine().split(" ");
    double a=Double.parseDouble(tmp[0]);
    double b=Double.parseDouble(tmp[1]);
    double C=Math.PI*Double.parseDouble(tmp[2])/180.0 ;
    double h=b*Math.sin(C);
    double S=0.5*a*h ;
    double c=Math.sqrt(a*a+b*b-2*a*b*Math.cos(C));
    double L=a+b+c ;
    System.out.printf("%.5f\n",S);
    System.out.printf("%.5f\n",L);
    System.out.printf("%.5f\n",h);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmp : Sequence(String) ; tmp := in.readLine()->split(" ") ;
    var a : double ; a := (tmp[0+1])->toReal() ;
    var b : double ; b := (tmp[1+1])->toReal() ;
    var C : double ; C := 3.141592653589793 * (tmp[2+1])->toReal() / 180.0 ;
    var h : double ; h := b * (C)->sin() ;
    var S : double ; S := 0.5 * a * h ;
    var c : double ; c := (a * a + b * b - 2 * a * b * (C)->cos())->sqrt() ;
    var L : double ; L := a + b + c ;
    OclFile["System.out"].printf("%.5f\n", S) ; 
    OclFile["System.out"].printf("%.5f\n", L) ; 
    OclFile["System.out"].printf("%.5f\n", h) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] tmpArray=br.readLine().split(" ");
    int input[]=new int[n];
    int diff=0 ;
    for(int i=1 ; i<=n ; i++){
      input[i-1]=Integer.parseInt(tmpArray[i-1]);
      if(input[i-1]!=i){
        diff++;
      }
    }
    if(diff<=2){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
    var input : Sequence(int) ; input := Integer.subrange(1,n)->collect(0) ;
    var diff : int ; diff := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     input[i - 1+1] := (tmpArray[i - 1+1])->toInteger() ; 
     if (input[i - 1+1] /= i) then (     diff := diff + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (diff <= 2) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[])throws Exception {
    Scanner s=new Scanner(System.in);
    int N=s.nextInt();
    int i=1 ;
    String result="YES" ;
    int count=0 ;
    while(i<=N){
      int p=s.nextInt();
      count+=i!=p ? 1 : 0 ;
      if(count>2){
        result="NO" ;
        break ;
      }
      i++;
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := s.getCurrent()->toInteger() ;
    var i : int ; i := 1 ;
    var result : String ; result := "YES" ;
    var count : int ; count := 0 ;
    while (i <= N) do (     var p : int ; p := s.getCurrent()->toInteger() ;
     count := count+(if i /= p then 1 else 0 endif) ; 
     if (count > 2) then (     result := "NO" ; 
     break ) else skip ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A {
  public static String pref(String str,int ind){
    StringBuffer bf=new StringBuffer();
    int cnt=0 ;
    for(int i=ind-1 ; i>=0 && str.charAt(i)!='-' ; i--){
      if(cnt % 3==0 && cnt!=0){
        bf.append(',');
      }
      bf.append(str.charAt(i));
      cnt++;
    }
    return bf.reverse().toString();
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    StringBuffer bf=new StringBuffer();
    int ind=-1 ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)=='.'){
        ind=i ;
        break ;
      }
    }
    String prefix="",suffix="" ;
    if(ind==-1){
      prefix=pref(str,str.length());
      suffix=".00" ;
    }
    else {
      prefix=pref(str,ind);
      suffix+="." ;
      for(int i=ind+1 ; i<=ind+2 ; i++){
        if(i<str.length()){
          suffix+=str.charAt(i);
        }
        else {
          suffix+='0' ;
        }
      }
    }
    if(str.charAt(0)=='-'){
      prefix="($"+prefix ;
      suffix+=")" ;
    }
    else {
      prefix="$"+prefix ;
    }
    System.out.println(prefix+suffix);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation pref( str : String, ind : int) : String
  pre: true
  post: true
  activity: (     var bf : String ; bf := StringLib.newString() ;
     var cnt : int ; cnt := 0 ;
         var i : int ; i := ind - 1 ; while i >= 0 & str->at(i+1) /= '-' do ( (     if (cnt mod 3 = 0 & cnt /= 0) then (     bf := bf + StringLib.newString(',') ) else skip ; 
     bf := bf + StringLib.newString(str->at(i+1)) ; 
     cnt := cnt + 1 )  ;     i := i - 1 ) ; 
     return bf->reverse()+"" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var bf : String ; bf := StringLib.newString() ;
    var ind : int ; ind := -1 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '.') then (     ind := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var prefix : String ; prefix := "" ;
    var suffix : String ; suffix := "" ;
    if (ind = -1) then (     prefix := pref(str, str->size()) ; 
     suffix := ".00" ) else (     prefix := pref(str, ind) ; 
     suffix := suffix+(".") ; 
         var i : int ; i := ind + 1 ; while i <= ind + 2 do ( (     if (i < str->size()) then (     suffix := suffix+(str->at(i+1)) ) else (     suffix := suffix+('0') ) )  ;     i := i + 1 ) ) ;  
    if (str->at(0+1) = '-') then (     prefix := "($" + prefix ; 
     suffix := suffix+(")") ) else (     prefix := "$" + prefix ) ;  
    OclFile["System.out"].println(prefix + suffix) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char map[][]=new char[50][50];
    int r=sc.nextInt();
    int c=sc.nextInt();
    sc.nextLine();
    for(int y=0 ; y<r ; y++){
      String s=sc.nextLine();
      for(int x=0 ; x<c ; x++){
        map[y][x]=s.charAt(x);
      }
    }
    int minCount=Integer.MAX_VALUE ;
    int count ;
    for(int w_line=0 ; w_line<r-2 ; w_line++){
      count=0 ;
      for(int line=0 ; line<=w_line ; line++){
        count+=difCharLineCount(map[line],'W',c);
      }
      int t_cnt=count ;
      for(int r_line=w_line+2 ; r_line<r ; r_line++){
        for(int line=w_line+1 ; line<r_line ; line++){
          count+=difCharLineCount(map[line],'B',c);
        }
        for(int line=r_line ; line<r ; line++){
          count+=difCharLineCount(map[line],'R',c);
        }
        if(count<minCount){
          minCount=count ;
        }
        count=t_cnt ;
      }
    }
    System.out.println(minCount);
  }
  private static int difCharLineCount(char[] chars,char targetChar,int limit){
    int ret=0 ;
    for(int x=0 ; x<limit ; x++){
      if(chars[x]!=targetChar){
        ret++;
      }
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var map : Sequence(Sequence(String)) ; map := Integer.subrange(1,50)->collect(Integer.subrange(1,50)->collect(0)) ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    skip ; 
        var y : int ; y := 0 ; while y < r do ( (     var s : String ; s := sc.nextLine() ;
         var x : int ; x := 0 ; while x < c do ( (     map[y+1][x+1] := s->at(x+1) )  ;     x := x + 1 ) )  ;     y := y + 1 ) ; 
    var minCount : int ; minCount := 2147483647 ;
    var count : int ;
        var w_line : int ; w_line := 0 ; while w_line < (r)->char2byte() - 2 do ( (     count := 0 ; 
         var line : int ; line := 0 ; while line <= w_line do ( (     count := count+(difCharLineCount(map[line+1], 'W', c)) )  ;     line := line + 1 ) ; 
     var t_cnt : int ; t_cnt := count ;
         var r_line : int ; r_line := w_line + 2 ; while r_line < r do ( (         var line : int ; line := w_line + 1 ; while line < r_line do ( (     count := count+(difCharLineCount(map[line+1], 'B', c)) )  ;     line := line + 1 ) ; 
         var line : int ; line := r_line ; while line < r do ( (     count := count+(difCharLineCount(map[line+1], 'R', c)) )  ;     line := line + 1 ) ; 
     if (count < minCount) then (     minCount := count ) else skip ; 
     count := t_cnt )  ;     r_line := r_line + 1 ) )  ;     w_line := w_line + 1 ) ; 
    OclFile["System.out"].println(minCount) ; 
 );
  static   operation difCharLineCount( chars : Sequence(String), targetChar : String, limit : int) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
         var x : int ; x := 0 ; while x < limit do ( (     if (chars[x+1] /= targetChar) then (     ret := ret + 1 ) else skip )  ;     x := x + 1 ) ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class codechef_submission {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int k=sc.nextInt();
    int[] b=new int[n];
    if(n<k){
      System.out.println(n);
      return ;
    }
    for(int i=0 ; i<n ; i++){
      b[i]=sc.nextInt();
    }
    int[] d=new int[n-1];
    for(int i=0 ; i<n-1 ; i++){
      d[i]=b[i+1]-b[i]-1 ;
    }
    Arrays.sort(d);
    int sum=b[b.length-1]-b[0]+1 ;
    for(int i=d.length-1 ; i>d.length-1-(k-1); i--){
      sum-=d[i];
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codechef_submission {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    if (n < k) then (     OclFile["System.out"].println(n) ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var d : Sequence(int) ; d := Integer.subrange(1,n - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     d[i+1] := b[i + 1+1] - b[i+1] - 1 )  ;     i := i + 1 ) ; 
    d := d->sort() ; 
    var sum : int ; sum := b[b->size() - 1+1] - b[0+1] + 1 ;
        var i : int ; i := d->size() - 1 ; while i > d->size() - 1 - (k - 1) do ( (     sum := sum-(d[i+1]) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    B0Or1Swap solver=new B0Or1Swap();
    solver.solve(1,in,out);
    out.close();
  }
  static class B0Or1Swap {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int a[]=new int[n+1];
      int count=0 ;
      for(int i=1 ; i<=n ; i++)a[i]=in.nextInt();
      for(int i=1 ; i<=n ; i++){
        if(a[i]==i){
          continue ;
        }
        if(a[a[i] ]==i){
          count++;
          int temp=a[i];
          a[i]=i ;
          a[temp]=temp ;
          continue ;
        }
        out.println("NO");
        return ;
      }
      if(count<=1)out.println("YES");
      else {
        out.println("NO");
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : B0Or1Swap ; solver := B0Or1Swap.newB0Or1Swap() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class B0Or1Swap {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := in.nextInt() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (a[i+1] = i) then (     continue ) else skip ; 
     if (a[a[i+1]+1] = i) then (     count := count + 1 ; 
     var temp : int ; temp := a[i+1] ;
    a[i+1] := i ; 
    a[temp+1] := temp ; 
    continue 
 ) else skip ; 
     skip ; 
     return )  ;     i := i + 1 ) ; 
    if (count <= 1) then     skip else (     skip ) ;  
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Integer>initialList=new ArrayList();
    for(int i=0 ; i<n ; i++){
      initialList.add(sc.nextInt());
    }
    List<Integer>sortedList=initialList.stream().sorted().collect(Collectors.toList());
    int count=0 ;
    String message="YES" ;
    for(int i=0 ; i<n ; i++){
      if(initialList.get(i)!=sortedList.get(i)){
        count++;
        if(count>2){
          message="NO" ;
          break ;
        }
      }
    }
    System.out.println(message);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var initialList : Sequence(int) ; initialList := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     initialList := initialList->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var sortedList : Sequence(int) ; sortedList := initialList->sort().collect(Collectors.toList()) ;
    var count : int ; count := 0 ;
    var message : String ; message := "YES" ;
        var i : int ; i := 0 ; while i < n do ( (     if (initialList->at(i+1) /= sortedList->at(i+1)) then (     count := count + 1 ; 
     if (count > 2) then (     message := "NO" ; 
     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(message) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int ary[]=new int[n];
    for(int i=0 ; i<ary.length ; i++){
      ary[i]=Integer.parseInt(sc.next());
    }
    if(isAscendingOrder(ary)){
      System.out.print("YES");
    }
    else {
      System.out.print("NO");
    }
  }
  public static boolean isAscendingOrder(int[] ary){
    int x=0 ;
    int y=0 ;
    int k=0 ;
    for(int i=0 ; i<ary.length-1 ; i++){
      if(ary[i]>ary[i+1]){
        if(x==0){
          x=ary[i];
        }
        else if(y==0){
          y=ary[i+1];
        }
      }
    }
    for(int i=0 ; i<ary.length-1 ; i++){
      if(ary[i]>ary[i+1]){
        if(k==0){
          ary[i]=y ;
          k+=1 ;
        }
        else if(k==1){
          ary[i+1]=x ;
          k+=1 ;
        }
      }
    }
    for(int i=0 ; i<ary.length-1 ; i++){
      if(ary[i]>ary[i+1]){
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var ary : Sequence(int) ; ary := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < ary->size() do ( (     ary[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    if (isAscendingOrder(ary)) then (     OclFile["System.out"].print("YES") ) else (     OclFile["System.out"].print("NO") ) ;  
 );
  static   operation isAscendingOrder( ary : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var x : int ; x := 0 ;
     var y : int ; y := 0 ;
    var k : int ; k := 0 ;
        var i : int ; i := 0 ; while i < ary->size() - 1 do ( (     if (ary[i+1] > ary[i + 1+1]) then (     if (x = 0) then (     x := ary[i+1] ) else     if (y = 0) then (     y := ary[i + 1+1] ) else skip ; ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < ary->size() - 1 do ( (     if (ary[i+1] > ary[i + 1+1]) then (     if (k = 0) then (     ary[i+1] := y ; 
     k := k+(1) ) else     if (k = 1) then (     ary[i + 1+1] := x ; 
     k := k+(1) ) else skip ; ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < ary->size() - 1 do ( (     if (ary[i+1] > ary[i + 1+1]) then (     return false ) else skip )  ;     i := i + 1 ) ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int N=3 ;
  static int M=3 ;
  static int sumMaxOccurring(int arr[][]){
    Map<Integer,Integer>mp=new HashMap<>();
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<M ; j++){
        if(mp.containsKey(arr[i][j])){
          mp.put(arr[i][j],mp.get(arr[i][j])+1);
        }
        else {
          mp.put(arr[i][j],1);
        }
      }
    }
    int sum=0 ;
    int maxFreq=Integer.MIN_VALUE ;
    for(Map.Entry<Integer,Integer>itr : mp.entrySet()){
      if(itr.getValue()>maxFreq){
        maxFreq=itr.getValue();
      }
    }
    for(Map.Entry<Integer,Integer>itr : mp.entrySet()){
      if(itr.getValue()==maxFreq){
        sum+=(itr.getKey())*(itr.getValue());
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int mat[][]={
      {
        1,2,3 },{
          1,3,2 },{
            1,5,6 }
          };
          System.out.println(sumMaxOccurring(mat));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 3;
  static   attribute M : int := 3;
  static   operation sumMaxOccurring( arr : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < M do ( (     if (mp->keys()->includes(arr[i+1][j+1])) then (     mp := mp->union(Map{arr[i+1][j+1] |-> mp->at(arr[i+1][j+1]) + 1}) ) else (     mp := mp->union(Map{arr[i+1][j+1] |-> 1}) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var maxFreq : int ; maxFreq := -2147483648 ;
    for (itr : mp->asSet()) do ( (     if (itr.getValue() > maxFreq) then (     maxFreq := itr.getValue() ) else skip )  ) ; 
    for (itr : mp->asSet()) do ( (     if (itr.getValue() = maxFreq) then (     sum := sum+((itr.getKey()) * (itr.getValue())) ) else skip )  ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,2,3},Sequence{1,3,2},Sequence{1,5,6}} ;
     OclFile["System.out"].println(sumMaxOccurring(mat)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int N=3 ;
  static int M=3 ;
  static int sumOddOccurring(int arr[][]){
    Map<Integer,Integer>mp=new HashMap<>();
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<M ; j++){
        if(mp.containsKey(arr[i][j])){
          mp.put(arr[i][j],mp.get(arr[i][j])+1);
        }
        else {
          mp.put(arr[i][j],1);
        }
      }
    }
    int sum=0 ;
    for(Map.Entry<Integer,Integer>itr : mp.entrySet()){
      if(itr.getValue()% 2!=0){
        sum+=(itr.getKey())*(itr.getValue());
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int mat[][]={
      {
        1,2,3 },{
          1,3,2 },{
            1,5,6 }
          };
          System.out.println(sumOddOccurring(mat));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 3;
  static   attribute M : int := 3;
  static   operation sumOddOccurring( arr : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < M do ( (     if (mp->keys()->includes(arr[i+1][j+1])) then (     mp := mp->union(Map{arr[i+1][j+1] |-> mp->at(arr[i+1][j+1]) + 1}) ) else (     mp := mp->union(Map{arr[i+1][j+1] |-> 1}) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    for (itr : mp->asSet()) do ( (     if (itr.getValue() mod 2 /= 0) then (     sum := sum+((itr.getKey()) * (itr.getValue())) ) else skip )  ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,2,3},Sequence{1,3,2},Sequence{1,5,6}} ;
     OclFile["System.out"].println(sumOddOccurring(mat)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int SumOfDigits(String str,int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=(int)(str.charAt(i)-'0');
    return sum ;
  }
  static boolean Divisible(String str,int n){
    if(SumOfDigits(str,n)% 3==0 && str.charAt(n-1)=='0')return true ;
    return false ;
  }
  public static void main(String[] args){
    String str="263730746028908374890" ;
    int n=str.length();
    if(Divisible(str,n))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation SumOfDigits( str : String, n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+((str->at(i+1) - ('0')->char2byte())->oclAsType(int)) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation Divisible( str : String, n : int) : boolean
  pre: true
  post: true
  activity: (     if (SumOfDigits(str, n) mod 3 = 0 & str->at(n - 1+1) = '0') then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "263730746028908374890" ;
     var n : int ; n := str->size() ;
     if (Divisible(str, n)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int total=sc.nextInt();
    int[] need=new int[total-1];
    for(int i=0 ; i<need.length ; i++){
      need[i]=sc.nextInt();
    }
    int first=sc.nextInt();
    int end=sc.nextInt();
    int stay=0 ;
    for(int i=0,j=first-1 ; i<end-first ; i++,j++){
      stay+=need[j];
    }
    System.out.println(stay);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var total : int ; total := sc.getCurrent()->toInteger() ;
    var need : Sequence(int) ; need := Integer.subrange(1,total - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < need->size() do ( (     need[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var first : int ; first := sc.getCurrent()->toInteger() ;
    var end : int ; end := sc.getCurrent()->toInteger() ;
    var stay : int ; stay := 0 ;
        var i : int ; i := 0 ;
    var j : int ; j := first - 1 ; while i < end - first do ( (     stay := stay+(need[j+1]) )  ;     i := i + 1 ;     j := j + 1 ) ; 
    OclFile["System.out"].println(stay) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int ans=0 ;
    int[] d=new int[n];
    for(int i=0 ; i<n-1 ; i++){
      d[i]=sc.nextInt();
    }
    int a=sc.nextInt();
    int b=sc.nextInt();
    for(int i=0 ; i<n-1 ; i++){
      if(i>=a-1 && i<b-1){
        ans+=d[i];
      }
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     d[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (i >= a - 1 & i < b - 1) then (     ans := ans+(d[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class subArr {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int arr[]=new int[n];
    for(int i=1 ; i<n ; i++){
      arr[i]=in.nextInt();
    }
    int a=in.nextInt();
    int b=in.nextInt();
    int sum=0 ;
    for(int i=a ; i<b ; i++){
      sum+=arr[i];
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class subArr {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 1 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := a ; while i < b do ( (     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Sheet4ProblemC {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] ranksYears=new int[n-1];
    for(int i=0 ; i<n-1 ; i++){
      ranksYears[i]=input.nextInt();
    }
    int a=input.nextInt();
    int b=input.nextInt();
    int count=0 ;
    for(int i=a-1 ; i<b-1 ; i++)count+=ranksYears[i];
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sheet4ProblemC {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var ranksYears : Sequence(int) ; ranksYears := Integer.subrange(1,n - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     ranksYears[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var a : int ; a := input.getCurrent()->toInteger() ;
    var b : int ; b := input.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := a - 1 ; while i < b - 1 do (     count := count+(ranksYears[i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _32_Jzzhu_and_Children {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    Queue<Integer>q1=new LinkedList<>();
    Queue<Integer>q2=new LinkedList<>();
    for(int i=1 ; i<=n ; i++){
      q1.add(sc.nextInt());
      q2.add(i);
    }
    int ans=0 ;
    while(! q1.isEmpty()){
      if(q1.peek()<=m){
        q1.poll();
        ans=q2.poll();
      }
      else if(q1.peek()>m){
        int x=q1.poll();
        int val=x-m ;
        q1.add(val);
        int val2=q2.poll();
        q2.add(val2);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _32_Jzzhu_and_Children {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var q1 : Sequence(int) ; q1 := Sequence{} ;
    var q2 : Sequence(int) ; q2 := Sequence{} ;
        var i : int ; i := 1 ; while i <= n do ( (     q1 := q1->including(sc.getCurrent()->toInteger()) ; 
     q2 := q2->including(i) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    while (not(q1->isEmpty())) do (     if (q1->min() <= m) then (     q1 := q1->sort()->tail() ; 
     ans := q2->min() ;     q2 := q2->sort()->tail() ) else     if (q1->min() > m) then (     var x : int ; x := q1->min() ;
     var val : int ; val := x - m ;
    q1 := q1->including(val) ; 
    var val2 : int ; val2 := q2->min() ;
    q2 := q2->including(val2) ; 
 ) else skip ; ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.StringTokenizer ;
public class Run {
  public static void main(String[] Z)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer stz ;
    stz=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(stz.nextToken());
    int m=Integer.parseInt(stz.nextToken());
    int k=Integer.parseInt(stz.nextToken());
    stz=new StringTokenizer(br.readLine());
    int[] segments=new int[n];
    for(int i=0 ; i<n ; i++){
      segments[i]=Integer.parseInt(stz.nextToken());
    }
    ArrayList<Integer>diffs=new ArrayList<>(n);
    for(int i=1 ; i<n ; i++){
      diffs.add(segments[i]-segments[i-1]);
    }
    Collections.sort(diffs);
    int ans=n ;
    for(int i=0 ; i<n-k ; i++){
      ans+=diffs.get(i)-1 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Run {
  static   operation main( Z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var stz : OclIterator ;
    stz := OclIterator.newOclIterator_String(br.readLine()) ; 
    var n : int ; n := (stz.next())->toInteger() ;
    var m : int ; m := (stz.next())->toInteger() ;
    var k : int ; k := (stz.next())->toInteger() ;
    stz := OclIterator.newOclIterator_String(br.readLine()) ; 
    var segments : Sequence(int) ; segments := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     segments[i+1] := (stz.next())->toInteger() )  ;     i := i + 1 ) ; 
    var diffs : Sequence(int) ; diffs := Sequence{} ;
        var i : int ; i := 1 ; while i < n do ( (     diffs := diffs->including(segments[i+1] - segments[i - 1+1]) )  ;     i := i + 1 ) ; 
    diffs := diffs->sort() ; 
    var ans : int ; ans := n ;
        var i : int ; i := 0 ; while i < n - k do ( (     ans := ans+(diffs->at(i+1) - 1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  static final int W=0 ;
  static final int B=1 ;
  static final int R=2 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    line=br.readLine();
    int N,M ;
    N=parseInt(line.substring(0,line.indexOf(' ')));
    M=parseInt(line.substring(line.indexOf(' ')+1));
    int[][] wbr=new int[N][3];
    for(int i=0 ; i<N ; i++){
      line=br.readLine();
      for(char c : line.toCharArray()){
        switch(c){
          case 'W' : wbr[i][B]++;
          wbr[i][R]++;
          break ;
          case 'B' : wbr[i][W]++;
          wbr[i][R]++;
          break ;
          case 'R' : wbr[i][W]++;
          wbr[i][B]++;
          break ;
        }
      }
    }
    int min=N*M ;
    for(int i=1 ; i<N-1 ; i++){
      for(int j=i ; j<N-1 ; j++){
        int change=0 ;
        for(int k=1 ; k<N-1 ; k++){
          if(k<i){
            change+=wbr[k][W];
          }
          else if(i<=k && k<=j){
            change+=wbr[k][B];
          }
          else {
            change+=wbr[k][R];
          }
        }
        min=Math.min(min,change);
      }
    }
    System.out.println(wbr[0][W]+min+wbr[N-1][R]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute W : int := 0;
  static    attribute B : int := 1;
  static    attribute R : int := 2;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    line := br.readLine() ; 
    var N : int ;
    var M : int ;
    N := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    M := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var wbr : Sequence(Sequence(int)) ; wbr := Integer.subrange(1,N)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     line := br.readLine() ; 
     for (c : line->characters()) do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
       if _switchval = 'W' then
     wbr[i+1][B+1] := wbr[i+1][B+1] + 1 ; 
    wbr[i+1][R+1] := wbr[i+1][R+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 'B' then
     wbr[i+1][W+1] := wbr[i+1][W+1] + 1 ; 
    wbr[i+1][R+1] := wbr[i+1][R+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 'R' then
     wbr[i+1][W+1] := wbr[i+1][W+1] + 1 ; 
    wbr[i+1][B+1] := wbr[i+1][B+1] + 1 ; 
    break 
   else skip ;
 )
 )  ) )  ;     i := i + 1 ) ; 
    var min : int ; min := N * M ;
        var i : int ; i := 1 ; while i < (N)->char2byte() - 1 do ( (         var j : int ; j := i ; while j < (N)->char2byte() - 1 do ( (     var change : int ; change := 0 ;
         var k : int ; k := 1 ; while k < (N)->char2byte() - 1 do ( (     if (k < i) then (     change := change+(wbr[k+1][W+1]) ) else     if (i <= k & k <= j) then (     change := change+(wbr[k+1][B+1]) ) else (     change := change+(wbr[k+1][R+1]) ) ;  )  ;     k := k + 1 ) ; 
     min := Set{min, change}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(wbr[0+1][W+1] + min + wbr[(N)->char2byte() - 1+1][R+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int[] arr=new int[x];
    int l=arr.length-1 ;
    for(int i=0 ; i<l ; i++){
      arr[i]=sc.nextInt();
    }
    int m=sc.nextInt();
    int n=sc.nextInt();
    int sum=0 ;
    while(m!=n){
      sum+=arr[m-1];
      m++;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,x)->collect(0) ;
    var l : int ; l := arr->size() - 1 ;
        var i : int ; i := 0 ; while i < l do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    while (m /= n) do (     sum := sum+(arr[m - 1+1]) ; 
     m := m + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,i ;
    int[] a ;
    n=sc.nextInt();
    a=new int[n];
    for(i=0 ; i<n ; i++)a[i]=sc.nextInt();
    out.println(count(a,0,n));
    sc.close();
  }
  private static long count(int[] c,int l,int r){
    int m ;
    if(l+1>=r){
      if(l<r)return 0 ;
      return 1 ;
    }
    else {
      m=(l+r)/2 ;
      return(count(c,l,m)+count(c,m,r)+merge(c,l,m,r));
    }
  }
  private static long merge(int[] c,int l,int m,int r){
    int nl,nr ;
    int i,j,k ;
    int infi=1980000000 ;
    int[] cl,cr ;
    long count ;
    nl=m-l ;
    nr=r-m ;
    cl=new int[nl+1];
    cr=new int[nr+1];
    for(i=0 ; i<nl ; i++)cl[i]=c[l+i];
    for(i=0 ; i<nr ; i++)cr[i]=c[m+i];
    cl[nl]=infi ;
    cr[nr]=infi ;
    i=0 ;
    j=0 ;
    count=0 ;
    for(k=l ; k<r ; k++){
      if(cl[i]<cr[j])c[k]=cl[i++];
      else {
        c[k]=cr[j++];
        count+=(nl-i);
      }
    }
    return count ;
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var i : int ;
    var a : Sequence(int) ;
    n := sc.nextInt() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
        i := 0 ; while i < n do (     a[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
    out.println(count(a, 0, n)) ; 
    sc.close() ; 
 );
  static   operation count( c : Sequence(int), l : int, r : int) : long
  pre: true
  post: true
  activity: (     var m : int ;
     if (l + 1 >= r) then (     if (l < r) then     return 0 else skip ; 
     return 1 ) else (     m := (l + r) / 2 ; 
     return (count(c, l, m) + count(c, m, r) + merge(c, l, m, r)) ) );
  static   operation merge( c : Sequence(int), l : int, m : int, r : int) : long
  pre: true
  post: true
  activity: (     var nl : int ;
    var nr : int ;
     var i : int ;
    var j : int ;
    var k : int ;
    var infi : int ; infi := 1980000000 ;
    var cl : Sequence(int) ;
    var cr : Sequence(int) ;
    var count : long ;
    nl := m - l ; 
    nr := r - m ; 
    cl := Integer.subrange(1,nl + 1)->collect(0) ; 
    cr := Integer.subrange(1,nr + 1)->collect(0) ; 
        i := 0 ; while i < nl do (     cl[i+1] := c[l + i+1] ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < nr do (     cr[i+1] := c[m + i+1] ;  ;     i := i + 1 ) ; 
    cl[nl+1] := infi ; 
    cr[nr+1] := infi ; 
    i := 0 ; 
    j := 0 ; 
    count := 0 ; 
        k := l ; while k < r do ( (     if (cl[i+1] < cr[j+1]) then      c[k+1] := cl[i+1]  ; i := i + 1 ; else (      c[k+1] := cr[j+1]  ; j := j + 1 ; 
     count := count+((nl - i)) ) )  ;     k := k + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
public class Main {
  int SENTINEL=1234567890 ;
  long sum=0 ;
  void merge(int[] A,int left,int mid,int right){
    int n1=mid-left+1 ;
    int n2=right-mid ;
    int[] L=new int[n1+1];
    int[] R=new int[n2+1];
    for(int i=0 ; i<n1 ; i++){
      L[i]=A[left+i];
    }
    for(int i=0 ; i<n2 ; i++){
      R[i]=A[mid+1+i];
    }
    L[n1]=SENTINEL ;
    R[n2]=SENTINEL ;
    int i=0 ;
    int j=0 ;
    for(int k=left ; k<=right ; k++){
      if(L[i]<=R[j]){
        sum+=k-i-left ;
        A[k]=L[i];
        i=i+1 ;
      }
      else {
        A[k]=R[j];
        j=j+1 ;
      }
    }
  }
  void mergeSort(int[] A,int left,int right){
    if(left<right){
      int mid=(left+right)/2 ;
      mergeSort(A,left,mid);
      mergeSort(A,mid+1,right);
      merge(A,left,mid,right);
    }
  }
  void run()throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] str=br.readLine().split(" ");
    int[] A=new int[n];
    for(int i=0 ; i<n ; i++){
      A[i]=Integer.parseInt(str[i]);
    }
    mergeSort(A,0,n-1);
    System.out.println(sum);
  }
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute SENTINEL : int := 1234567890;
   attribute sum : long := 0;
   operation merge( A : Sequence(int), left : int, mid : int, right : int) : void
  pre: true
  post: true
  activity: (     var n1 : int ; n1 := mid - left + 1 ;
     var n2 : int ; n2 := right - mid ;
    var L : Sequence(int) ; L := Integer.subrange(1,n1 + 1)->collect(0) ;
    var R : Sequence(int) ; R := Integer.subrange(1,n2 + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n1 do ( (     L[i+1] := A[left + i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n2 do ( (     R[i+1] := A[mid + 1 + i+1] )  ;     i := i + 1 ) ; 
    L[n1+1] := SENTINEL ; 
    R[n2+1] := SENTINEL ; 
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
        var k : int ; k := left ; while k <= right do ( (     if (L[i+1] <= R[j+1]) then (     sum := sum+(k - i - left) ; 
     A[k+1] := L[i+1] ; 
     i := i + 1 ) else (     A[k+1] := R[j+1] ; 
     j := j + 1 ) )  ;     k := k + 1 ) ; 
 );
   operation mergeSort( A : Sequence(int), left : int, right : int) : void
  pre: true
  post: true
  activity: (     if (left < right) then (     var mid : int ; mid := (left + right) / 2 ;
     execute mergeSort(A, left, mid) ; 
     execute mergeSort(A, mid + 1, right) ; 
     execute merge(A, left, mid, right) ) else skip );
   operation run() : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var A : Sequence(int) ; A := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := (str[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    execute mergeSort(A, 0, n - 1) ; 
    OclFile["System.out"].println(sum) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static long count=0 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    mergeSort(a,0,n);
    System.out.println(count);
  }
  private static void mergeSort(int[] s,int left,int right){
    if(left+1<right){
      int mid=(left+right)/2 ;
      mergeSort(s,left,mid);
      mergeSort(s,mid,right);
      merge(s,left,mid,right);
    }
  }
  private static void merge(int[] s,int left,int mid,int right){
    int[] L=new int[mid-left+1];
    int[] R=new int[right-mid+1];
    System.arraycopy(s,left,L,0,L.length-1);
    System.arraycopy(s,mid,R,0,R.length-1);
    L[L.length-1]=Integer.MAX_VALUE ;
    R[R.length-1]=Integer.MAX_VALUE ;
    for(int i=0,j=0,k=left ; k<right ; k++){
      if(L[i]<=R[j]){
        s[k]=L[i];
        i++;
        count+=j ;
      }
      else {
        s[k]=R[j];
        j++;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute count : long := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute mergeSort(a, 0, n) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation mergeSort( s : Sequence(int), left : int, right : int) : void
  pre: true
  post: true
  activity: (     if (left + 1 < right) then (     var mid : int ; mid := (left + right) / 2 ;
     execute mergeSort(s, left, mid) ; 
     execute mergeSort(s, mid, right) ; 
     execute merge(s, left, mid, right) ) else skip );
  static   operation merge( s : Sequence(int), left : int, mid : int, right : int) : void
  pre: true
  post: true
  activity: (     var L : Sequence(int) ; L := Integer.subrange(1,mid - left + 1)->collect(0) ;
     var R : Sequence(int) ; R := Integer.subrange(1,right - mid + 1)->collect(0) ;
    for _x : Integer.subrange(1,L->size() - 1) do L[0 + _x] := s[left + _x] ; 
    for _x : Integer.subrange(1,R->size() - 1) do R[0 + _x] := s[mid + _x] ; 
    L[L->size() - 1+1] := 2147483647 ; 
    R[R->size() - 1+1] := 2147483647 ; 
        var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    var k : int ; k := left ; while k < right do ( (     if (L[i+1] <= R[j+1]) then (     s[k+1] := L[i+1] ; 
     i := i + 1 ; 
     count := count+(j) ) else (     s[k+1] := R[j+1] ; 
     j := j + 1 ) )  ;     k := k + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class Main {
  private static long inversions=0 ;
  public static void main(String[] args)throws java.lang.Exception {
    Scanner s=new Scanner(System.in);
    int arraySize=s.nextInt();
    int[] A=new int[arraySize];
    for(int i=0 ; i<arraySize ; i++){
      A[i]=s.nextInt();
    }
    mergeSort(A,0,A.length);
    System.out.println(inversions);
  }
  public static void mergeSort(int[] A,int left,int right){
    if(left+1>=right){
      return ;
    }
    int mid=(right+left)/2 ;
    mergeSort(A,left,mid);
    mergeSort(A,mid,right);
    merge(A,left,mid,right);
  }
  public static void merge(int[] A,int left,int mid,int right){
    int n1=mid-left ;
    int n2=right-mid ;
    int[] L=new int[n1];
    int[] R=new int[n2];
    for(int i=0 ; i<n1 ; i++){
      L[i]=A[left+i];
    }
    for(int i=0 ; i<n2 ; i++){
      R[i]=A[mid+i];
    }
    int i=0 ;
    int j=0 ;
    for(int k=left ; k<right ; k++){
      if(j>=n2){
        A[k]=L[i];
        i=i+1 ;
        continue ;
      }
      if(i>=n1){
        A[k]=R[j];
        inversions+=L.length-i ;
        j=j+1 ;
        continue ;
      }
      if(L[i]<=R[j]){
        A[k]=L[i];
        i=i+1 ;
      }
      else {
        A[k]=R[j];
        inversions+=L.length-i ;
        j=j+1 ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute inversions : long := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arraySize : int ; arraySize := s.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,arraySize)->collect(0) ;
        var i : int ; i := 0 ; while i < arraySize do ( (     A[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute mergeSort(A, 0, A->size()) ; 
    OclFile["System.out"].println(inversions) ; 
 );
  static   operation mergeSort( A : Sequence(int), left : int, right : int) : void
  pre: true
  post: true
  activity: (     if (left + 1 >= right) then (     return ) else skip ; 
     var mid : int ; mid := (right + left) / 2 ;
    execute mergeSort(A, left, mid) ; 
    execute mergeSort(A, mid, right) ; 
    execute merge(A, left, mid, right) ; 
 );
  static   operation merge( A : Sequence(int), left : int, mid : int, right : int) : void
  pre: true
  post: true
  activity: (     var n1 : int ; n1 := mid - left ;
     var n2 : int ; n2 := right - mid ;
    var L : Sequence(int) ; L := Integer.subrange(1,n1)->collect(0) ;
    var R : Sequence(int) ; R := Integer.subrange(1,n2)->collect(0) ;
        var i : int ; i := 0 ; while i < n1 do ( (     L[i+1] := A[left + i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n2 do ( (     R[i+1] := A[mid + i+1] )  ;     i := i + 1 ) ; 
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
        var k : int ; k := left ; while k < right do ( (     if (j >= n2) then (     A[k+1] := L[i+1] ; 
     i := i + 1 ; 
     continue ) else skip ; 
     if (i >= n1) then (     A[k+1] := R[j+1] ; 
     inversions := inversions+(L->size() - i) ; 
     j := j + 1 ; 
     continue ) else skip ; 
     if (L[i+1] <= R[j+1]) then (     A[k+1] := L[i+1] ; 
     i := i + 1 ) else (     A[k+1] := R[j+1] ; 
     inversions := inversions+(L->size() - i) ; 
     j := j + 1 ) )  ;     k := k + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int m,n ;
  static int[] dx={
-1,0,1,0 },dy={
      0,1,0,-1 };
      static int[][] field=new int[92][92];
      public static void main(String[] args){
        for(int i=0 ; i<field.length ; i++)fill(field[i],0);
        while(read())System.out.println(solve());
      }
      static boolean read(){
        m=sc.nextInt();
        n=sc.nextInt();
        if(m==0)return false ;
        for(int i=1 ; i<=n ; i++)for(int j=1 ; j<=m ; j++)field[i][j]=sc.nextInt();
        return true ;
      }
      static int solve(){
        int ans=0 ;
        for(int i=1 ; i<=n ; i++)for(int j=1 ; j<=m ; j++)if(field[i][j]==1)ans=max(ans,rec(j,i,1));
        return ans ;
      }
      static int rec(int x,int y,int step){
        int ret=0 ;
        for(int i=0 ; i<4 ; i++){
          int nx=x+dx[i],ny=y+dy[i];
          if(field[ny][nx]==1){
            field[y][x]=0 ;
            ret=max(ret,rec(nx,ny,step+1));
            field[y][x]=1 ;
          }
          else {
            ret=max(ret,step);
          }
        }
        return ret ;
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute m : int;
  static   attribute dx : Sequence(int) := Sequence{-1,0,1,0};
  static   attribute field : Sequence(Sequence(int)) := Integer.subrange(1,92)->collect(Integer.subrange(1,92)->collect(0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < field->size() do (     execute fill(field[i+1], 0) ;  ;     i := i + 1 ) ; 
     while (read()) do     OclFile["System.out"].println(solve()) ; );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     m := sc.getCurrent()->toInteger() ; 
     n := sc.getCurrent()->toInteger() ; 
    if (m = 0) then     return false else skip ; 
        var i : int ; i := 1 ; while i <= n do (         var j : int ; j := 1 ; while j <= m do (     field[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation solve() : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i <= n do (         var j : int ; j := 1 ; while j <= m do (     if (field[i+1][j+1] = 1) then     ans := Set{ans, rec(j, i, 1)}->max() ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation rec( x : int, y : int, step : int) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
         var i : int ; i := 0 ; while i < 4 do ( (     var nx : int ; nx := x + dx[i+1] ;
    var ny : int ; ny := y + dy[i+1] ;
     if (field[ny+1][nx+1] = 1) then (     field[y+1][x+1] := 0 ; 
     ret := Set{ret, rec(nx, ny, step + 1)}->max() ; 
     field[y+1][x+1] := 1 ) else (     ret := Set{ret, step}->max() ) )  ;     i := i + 1 ) ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  static int n,m ;
  static int[] dx={
    0,0,-1,1 },dy={
-1,1,0,0 };
      static boolean[][] map,check ;
      public static int dfs(int y,int x){
        int ret=0 ;
        for(int i=0 ; i<4 ; i++){
          int nextX=x+dx[i];
          int nextY=y+dy[i];
          if(0<=nextX && nextX<m && 0<=nextY && nextY<n && map[nextY][nextX] && ! check[nextY][nextX]){
            check[nextY][nextX]=true ;
            ret=Math.max(dfs(nextY,nextX)+1,ret);
            check[nextY][nextX]=false ;
          }
        }
        return ret ;
      }
      public static void main(String[] args)throws IOException {
        BufferedReader s=new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out=new PrintWriter(System.out);
        while(true){
          m=Integer.valueOf(s.readLine());
          n=Integer.valueOf(s.readLine());
          if(m==0 && n==0)break ;
          map=new boolean[n][m];
          for(int i=0 ; i<n ; i++){
            String[] data=s.readLine().split(" ");
            for(int j=0 ; j<m ; j++)map[i][j]=Integer.valueOf(data[j])==1 ;
          }
          int max=0 ;
          for(int i=0 ; i<n ; i++){
            for(int j=0 ; j<m ; j++){
              if(map[i][j]){
                check=new boolean[n][m];
                max=Math.max(max,dfs(i,j));
              }
            }
          }
          out.println(max);
        }
        out.flush();
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute dx : Sequence(int) := Sequence{0,0,-1,1};
  static   attribute map : Sequence(Sequence(boolean));
  static   operation dfs( y : int, x : int) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
         var i : int ; i := 0 ; while i < 4 do ( (     var nextX : int ; nextX := x + dx[i+1] ;
     var nextY : int ; nextY := y + dy[i+1] ;
     if (0 <= nextX & nextX < m & 0 <= nextY & nextY < n & map[nextY+1][nextX+1] & not(check[nextY+1][nextX+1])) then (     check[nextY+1][nextX+1] := true ; 
     ret := Set{dfs(nextY, nextX) + 1, ret}->max() ; 
     check[nextY+1][nextX+1] := false ) else skip )  ;     i := i + 1 ) ; 
     return ret );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     while (true) do (     m := (s.readLine())->toInteger() ; 
     n := (s.readLine())->toInteger() ; 
    if (m = 0 & n = 0) then     break else skip ; 
    map := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(false)) ; 
        var i : int ; i := 0 ; while i < n do ( (     var data : Sequence(String) ; data := s.readLine()->split(" ") ;
         var j : int ; j := 0 ; while j < m do (     map[i+1][j+1] := (data[j+1])->toInteger() = 1 ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (map[i+1][j+1]) then (     check := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(false)) ; 
     max := Set{max, dfs(i, j)}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int M,N ;
  static boolean[][] f ;
  static int ans ;
  static int[] DR={
    1,0,-1,0 };
    static int[] DC={
      0,1,0,-1 };
      static void dfs(int r,int c,int d){
        f[r][c]=false ;
        for(int i=0 ; i<4 ; ++i){
          int nr=r+DR[i];
          int nc=c+DC[i];
          if(nr<0 || N<=nr || nc<0 || M<=nc || ! f[nr][nc])continue ;
          dfs(nr,nc,d+1);
        }
        f[r][c]=true ;
        ans=Math.max(ans,d);
      }
      public static void main(String[] args){
        while(true){
          M=sc.nextInt();
          N=sc.nextInt();
          if(N==0)break ;
          f=new boolean[N][M];
          ans=0 ;
          for(int i=0 ; i<N ; ++i){
            for(int j=0 ; j<M ; ++j){
              f[i][j]=sc.next().equals("1");
            }
          }
          for(int i=0 ; i<N ; ++i){
            for(int j=0 ; j<M ; ++j){
              if(f[i][j])dfs(i,j,1);
            }
          }
          System.out.println(ans);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute M : int;
  static   attribute f : Sequence(Sequence(boolean));
  static   attribute ans : int;
  static   attribute DR : Sequence(int) := Sequence{1,0,-1,0};
  static   attribute DC : Sequence(int) := Sequence{0,1,0,-1};
  static   operation dfs( r : int, c : int, d : int) : void
  pre: true
  post: true
  activity: (     f[r+1][c+1] := false ; 
         var i : int ; i := 0 ; while i < 4 do ( (     var nr : int ; nr := r + DR[i+1] ;
     var nc : int ; nc := c + DC[i+1] ;
     if (nr < 0 or N <= nr or nc < 0 or M <= nc or not(f[nr+1][nc+1])) then     continue else skip ; 
     execute dfs(nr, nc, d + 1) )  ;     i := i + 1 ) ; 
     f[r+1][c+1] := true ; 
     ans := Set{ans, d}->max() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     M := sc.getCurrent()->toInteger() ; 
     N := sc.getCurrent()->toInteger() ; 
    if (N = 0) then     break else skip ; 
    f := Integer.subrange(1,N)->collect(Integer.subrange(1,M)->collect(false)) ; 
    ans := 0 ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < M do ( (     f[i+1][j+1] := sc.getCurrent() = "1" )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < M do ( (     if (f[i+1][j+1]) then     execute dfs(i, j, 1) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),m=in.nextInt(),k=in.nextInt();
    int[] a=new int[n];
    Arrays.setAll(a,i->in.nextInt());
    PriorityQueue<Integer>pq=new PriorityQueue<>();
    for(int i=1 ; i<n ; i++)pq.add((a[i]-a[i-1])-1);
    long res=n ;
    n-=k ;
    while(n-->0){
      int v=pq.remove();
      res+=v ;
    }
    pw.println(res);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
setAll(a, lambda i : OclAny in in.getCurrent()->toInteger()) ; 
    var pq : Sequence(int) ; pq := Sequence{} ;
        var i : int ; i := 1 ; while i < n do (     pq := pq->including((a[i+1] - a[i - 1+1]) - 1) ;  ;     i := i + 1 ) ; 
    var res : long ; res := n ;
    n := n-(k) ; 
        while (n > 0) do (        n := n - 1 ;     skip ; (     var v : int ; v := pq.remove() ;
     res := res+(v) ) ;  ) ;  
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      w=scanner.nextInt();
      h=scanner.nextInt();
      if((w | h)==0)break ;
      map=new boolean[h][w];
      for(int i=0 ; i<h ; i++)for(int j=0 ; j<w ; j++)map[i][j]=scanner.nextInt()==0 ;
      ans=0 ;
      for(int i=0 ; i<h ; i++)for(int j=0 ; j<w ; j++){
        if(map[i][j])continue ;
        map[i][j]=true ;
        dfs(i,j,1);
        map[i][j]=false ;
      }
      System.out.println(ans);
    }
  }
  private void dfs(int y,int x,int depth){
    ans=Math.max(ans,depth);
    for(int[] m : move){
      int ny=y+m[0];
      int nx=x+m[1];
      if(! isOK(ny,nx))continue ;
      if(map[ny][nx])continue ;
      map[ny][nx]=true ;
      dfs(ny,nx,depth+1);
      map[ny][nx]=false ;
    }
  }
  private boolean isOK(int y,int x){
    if(0<=y && y<h && 0<=x && x<w)return true ;
    return false ;
  }
  int h,w ;
  int[][] move={
    {
-1,0 },{
        0,-1 },{
          0,1 },{
            1,0 }
          };
          boolean[][] map ;
          int ans ;
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     w := scanner.getCurrent()->toInteger() ; 
     h := scanner.getCurrent()->toInteger() ; 
    if ((w or h) = 0) then     break else skip ; 
    map := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(false)) ; 
        var i : int ; i := 0 ; while i < h do (         var j : int ; j := 0 ; while j < w do (     map[i+1][j+1] := scanner.getCurrent()->toInteger() = 0 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    ans := 0 ; 
        var i : int ; i := 0 ; while i < h do (         var j : int ; j := 0 ; while j < w do ( (     if (map[i+1][j+1]) then     continue else skip ; 
     map[i+1][j+1] := true ; 
     execute dfs(i, j, 1) ; 
     map[i+1][j+1] := false )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
   operation dfs( y : int, x : int, depth : int) : void
  pre: true
  post: true
  activity: (     ans := Set{ans, depth}->max() ; 
     for (m : move) do ( (     var ny : int ; ny := y + m[0+1] ;
     var nx : int ; nx := x + m[1+1] ;
    if (not(isOK(ny, nx))) then     continue else skip ; 
    if (map[ny+1][nx+1]) then     continue else skip ; 
    map[ny+1][nx+1] := true ; 
    execute dfs(ny, nx, depth + 1) ; 
    map[ny+1][nx+1] := false ; 
 )  ) );
   operation isOK( y : int, x : int) : boolean
  pre: true
  post: true
  activity: (     if (0 <= y & y < h & 0 <= x & x < w) then     return true else skip ; 
     return false );
   attribute h : int;
   attribute move : Sequence(Sequence(int)) := Sequence{Sequence{-1,0},Sequence{0,-1},Sequence{0,1},Sequence{1,0}};
   attribute map : Sequence(Sequence(boolean));
   attribute ans : int;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  PrintStream log=new PrintStream(new OutputStream(){
    public void write(int b){
    }
  }
);
  PrintStream result=System.out ;
  Scanner sc=new Scanner(System.in);
  void main()throws IOException {
    int N=sc.nextInt();
    int M=sc.nextInt();
    sc.nextLine();
    String[] s=new String[N];
    for(int i=0 ; i<N ; i++){
      s[i]=sc.nextLine();
    }
    int min=Integer.MAX_VALUE ;
    for(int WL=1 ; WL<N-1 ; WL++){
      for(int BL=1 ; BL<N-WL ; BL++){
        int cnt=0 ;
        for(int n=0 ; n<N ; n++){
          char c='R' ;
          if(n<WL)c='W' ;
          else if(n<WL+BL)c='B' ;
          for(int m=0 ; m<s[n] .length(); m++){
            if(s[n] .charAt(m)!=c){
              cnt++;
            }
          }
        }
        log.printf("WL BL %d %d cnt=%d\n",WL,BL,cnt);
        min=Math.min(cnt,min);
      }
    }
    result.println(min);
  }
  public static void main(String[] args)throws IOException {
    new Main().main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute log : OclFile := OclFile.newOclFile_Write(OclFile());
   attribute result : OclFile := OclFile["System.out"];
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation main() : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var M : int ; M := sc.getCurrent()->toInteger() ;
    skip ; 
    var s : Sequence(String) ; s := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     s[i+1] := sc.nextLine() )  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
        var WL : int ; WL := 1 ; while WL < N - 1 do ( (         var BL : int ; BL := 1 ; while BL < N - WL do ( (     var cnt : int ; cnt := 0 ;
         var n : int ; n := 0 ; while n < N do ( (     var c : String ; c := 'R' ;
     if (n < WL) then     c := 'W' else     if (n < WL + BL) then     c := 'B' ; else skip ; ;  
         var m : int ; m := 0 ; while m < s[n+1]->size() do ( (     if (s[n+1]->at(m+1) /= c) then (     cnt := cnt + 1 ) else skip )  ;     m := m + 1 ) )  ;     n := n + 1 ) ; 
     skip ; 
     min := Set{cnt, min}->min() )  ;     BL := BL + 1 ) )  ;     WL := WL + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().main() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    while(true){
      int h=sc.nextInt();
      int w=sc.nextInt();
      if(h==0 && w==0){
        break ;
      }
      boolean[][] field=new boolean[h][w];
      for(int i=0 ; i<h ; i++){
        for(int j=0 ; j<w ; j++){
          field[i][j]=(sc.nextInt()==1);
        }
      }
      int max=0 ;
      for(int i=0 ; i<h ; i++){
        for(int j=0 ; j<w ; j++){
          if(field[i][j]){
            max=Math.max(max,getCount(i,j,field));
          }
        }
      }
      sb.append(max).append("\n");
    }
    System.out.print(sb);
  }
  static int getCount(int h,int w,boolean[][] field){
    if(h<0 || h>=field.length || w<0 || w>=field[0] .length || ! field[h][w]){
      return 0 ;
    }
    int max=0 ;
    field[h][w]=false ;
    max=Math.max(max,getCount(h-1,w,field));
    max=Math.max(max,getCount(h+1,w,field));
    max=Math.max(max,getCount(h,w-1,field));
    max=Math.max(max,getCount(h,w+1,field));
    field[h][w]=true ;
    return max+1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
     while (true) do (     var h : int ; h := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    if (h = 0 & w = 0) then (     break ) else skip ; 
    var field : Sequence(Sequence(boolean)) ; field := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(false)) ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     field[i+1][j+1] := (sc.getCurrent()->toInteger() = 1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (field[i+1][j+1]) then (     max := Set{max, getCount(i, j, field)}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(max) + StringLib.newString("\n") ; 
 ) ; 
     OclFile["System.out"].print(sb) );
  static   operation getCount( h : int, w : int, field : Sequence(Sequence(boolean))) : int
  pre: true
  post: true
  activity: (     if (h < 0 or h >= field->size() or w < 0 or w >= field[0+1]->size() or not(field[h+1][w+1])) then (     return 0 ) else skip ; 
     var max : int ; max := 0 ;
    field[h+1][w+1] := false ; 
    max := Set{max, getCount((h)->char2byte() - 1, w, field)}->max() ; 
    max := Set{max, getCount(h + 1, w, field)}->max() ; 
    max := Set{max, getCount(h, w - 1, field)}->max() ; 
    max := Set{max, getCount(h, w + 1, field)}->max() ; 
    field[h+1][w+1] := true ; 
    return max + 1 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Solve s=new Solve();
    s.solve();
  }
}
class Solve {
  Solve(){
  }
  Scanner in=new Scanner(System.in);
  void solve(){
    while(in.hasNext()){
      int n=in.nextInt(),k=in.nextInt();
      if(n==0 && k==0)return ;
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=in.nextInt();
      int ans=0,t ;
      for(int i=0 ; i<k ; i++){
        ans+=a[i];
      }
      t=ans ;
      int s=0 ;
      for(int i=k ; i<n ; i++){
        t=t+a[i]-a[s];
        s++;
        ans=Math.max(ans,t);
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Solve ; s := Solve.newSolve() ;
     s.solve() );
}
class Solve {
   static operation newSolve() : Solve
  pre: true
  post: true
  activity:
  ( var self : Solve ;
    self := createSolve();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation solve() : void
  pre: true
  post: true
  activity: (     while (in.hasNext()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
     if (n = 0 & k = 0) then     return else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var t : int ;
        var i : int ; i := 0 ; while i < k do ( (     ans := ans+(a[i+1]) )  ;     i := i + 1 ) ; 
    t := ans ; 
    var s : int ; s := 0 ;
        var i : int ; i := k ; while i < n do ( (     t := t + a[i+1] - a[s+1] ; 
     s := s + 1 ; 
     ans := Set{ans, t}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int cnt=-9 ;
    int range=-9 ;
    String line ;
    List<Integer>inputs=new ArrayList<>();
    while((line=br.readLine().trim())!=null && ! line.isEmpty()&& ! "0 0".equals(line)){
      if(cnt<0){
        List<Integer>list=Arrays.stream(line.split(" ")).map(Integer :: valueOf).collect(Collectors.toList());
        cnt=list.get(0);
        range=list.get(1);
      }
      else {
        inputs.add(Integer.valueOf(line));
        if(--cnt==0){
          output(inputs,range);
          inputs.clear();
          cnt=-9 ;
        }
      }
    }
  }
  public static void output(List<Integer>list,int range){
    int sum=IntStream.range(0,range).map(j->list.get(j)).sum();
    int max=sum ;
    for(int i=range ; i<list.size(); i++){
      sum=sum-list.get(i-range)+list.get(i);
      if(max<sum)max=sum ;
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var cnt : int ; cnt := -9 ;
    var range : int ; range := -9 ;
    var line : String ;
    var inputs : Sequence(int) ; inputs := Sequence{} ;
        line := br.readLine()->trim() ;
    while ((line) /= null & not(line->isEmpty()) & not("0 0" = line)) do (    skip ; (     if (cnt < 0) then (     var list : Sequence(int) ; list := stream(line->split(" "))->collect( _x1 | (lambda _pars : OclAny in Integer.newInteger().valueOf(_pars))->apply(_x1) ).collect(Collectors.toList()) ;
     cnt := list->at(0+1) ; 
     range := list->at(1+1) ) else (     inputs := inputs->including((line)->toInteger()) ; 
     if ((cnt - 1) = 0) then (     execute output(inputs, range) ; 
     inputs := inputs->intersection(Set{}) ; 
     cnt := -9 ) else skip ) ) ;     line := br.readLine()->trim() ;
 ) ;  
 );
  static   operation output( list : Sequence(int), range : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := Integer.subrange(0, range-1)->collect( _x1 | (lambda j : OclAny in list->at(j+1))->apply(_x1) )->sum() ;
     var max : int ; max := sum ;
         var i : int ; i := range ; while i < list->size() do ( (     sum := sum - list->at(i - range+1) + list->at(i+1) ; 
     if (max < sum) then     max := sum ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(max) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static class BIT {
    int[] dat ;
    public BIT(int n){
      dat=new int[n+1];
    }
    public void add(int k,int a){
      for(int i=k+1 ; i<dat.length ; i+=i &-i){
        dat[i]+=a ;
      }
    }
    public int sum(int s,int t){
      if(s>0)return sum(0,t)-sum(0,s);
      int ret=0 ;
      for(int i=t ; i>0 ; i-=i &-i){
        ret+=dat[i];
      }
      return ret ;
    }
    public int get(int k){
      int p=Integer.highestOneBit(dat.length-1);
      for(int q=p ; q>0 ; q>>=1,p |=q){
        if(p>=dat.length || k<dat[p])p ^=q ;
        else k-=dat[p];
      }
      return p ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      final int n=sc.nextInt();
      final int k=sc.nextInt();
      if(n==0 && k==0){
        break ;
      }
      BIT bit=new BIT(n);
      for(int i=0 ; i<n ; i++){
        bit.add(i,sc.nextInt());
      }
      int max=Integer.MIN_VALUE ;
      for(int start=0 ; start<n-k+1 ; start++){
        max=Math.max(max,bit.sum(start,start+k));
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class BIT {
   attribute dat : Sequence(int);
   static operation newBIT( n : int) : BIT
  pre: true
  post: true
  activity:
  ( var self : BIT ;
    self := createBIT();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     dat := Integer.subrange(1,n + 1)->collect(0) );
   operation add( k : int, a : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := k + 1 ; while i < dat->size() do ( (     dat[i+1] := dat[i+1]+(a) )  ;     i := i+(MathLib.bitwiseAnd(i,-i)) ) );
   operation sum( s : int, t : int) : int
  pre: true
  post: true
  activity: (     if (s > 0) then     return sum(0, t) - sum(0, s) else skip ; 
     var ret : int ; ret := 0 ;
         var i : int ; i := t ; while i > 0 do ( (     ret := ret+(dat[i+1]) )  ;     i := i-(MathLib.bitwiseAnd(i,-i)) ) ; 
     return ret );
   operation get( k : int) : int
  pre: true
  post: true
  activity: (     var p : int ; p := highestOneBit(dat->size() - 1) ;
         var q : int ; q := p ; while q > 0 do ( (     if (p >= dat->size() or k < dat[p+1]) then     p := MathLib.bitwiseXor(p,q) ; else     k := k-(dat[p+1]) ; )  ;     q := q/(2->pow(1)) ;     p := MathLib.bitwiseOr(p, q) ) ; 
     return p );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    if (n = 0 & k = 0) then (     break ) else skip ; 
    var bit : BIT ; bit := BIT.newBIT(n) ;
        var i : int ; i := 0 ; while i < n do ( (     bit->excludes(i, sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
        var start : int ; start := 0 ; while start < n - k + 1 do ( (     max := Set{max, bit.sum(start, start + k)}->max() )  ;     start := start + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    int k=stdIn.nextInt();
    int[] ans=new int[1000];
    int index=0 ;
    while(n!=0 || k!=0){
      int sum=0 ;
      int[] num=new int[n];
      for(int i=0 ; i<k ; i++){
        num[i]=stdIn.nextInt();
        sum+=num[i];
      }
      for(int i=k ; i<n ; i++){
        num[i]=stdIn.nextInt();
      }
      int max=sum ;
      for(int i=0 ; i<n-k ; i++){
        sum=sum-num[i]+num[i+k];
        if(sum>max){
          max=sum ;
        }
      }
      ans[index]=max ;
      index++;
      n=stdIn.nextInt();
      k=stdIn.nextInt();
    }
    for(int i=0 ; i<index ; i++){
      System.out.println(ans[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var k : int ; k := stdIn.getCurrent()->toInteger() ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,1000)->collect(0) ;
    var index : int ; index := 0 ;
    while (n /= 0 or k /= 0) do (     var sum : int ; sum := 0 ;
     var num : Sequence(int) ; num := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     num[i+1] := stdIn.getCurrent()->toInteger() ; 
     sum := sum+(num[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := k ; while i < n do ( (     num[i+1] := stdIn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var max : int ; max := sum ;
        var i : int ; i := 0 ; while i < n - k do ( (     sum := sum - num[i+1] + num[i + k+1] ; 
     if (sum > max) then (     max := sum ) else skip )  ;     i := i + 1 ) ; 
    ans[index+1] := max ; 
    index := index + 1 ; 
    n := stdIn.getCurrent()->toInteger() ; 
    k := stdIn.getCurrent()->toInteger() ; 
 ) ; 
        var i : int ; i := 0 ; while i < index do ( (     OclFile["System.out"].println(ans[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader reader=new BufferedReader(isr);
    String string ;
    int n,m,max,conflict,array[];
    while(!(string=reader.readLine()).equals("0 0")){
      n=Integer.valueOf(string.split(" ")[0]);
      m=Integer.valueOf(string.split(" ")[1]);
      array=new int[n];
      for(int i=0 ; i<n ; i++)array[i]=Integer.valueOf(reader.readLine());
      max=0 ;
      for(int i=0 ; i<m ; i++)max+=array[i];
      conflict=max ;
      for(int i=0 ; i<n-m-1 ; i++){
        conflict+=array[i+m]-array[i];
        if(max<conflict)max=conflict ;
      }
      System.out.println(max);
    }
    reader.readLine();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(isr) ;
    var string : String ;
    var n : int ;
    var m : int ;
    var max : int ;
    var conflict : int ;
    var array : Sequence(void) ;
    while (not((string) = "0 0")) do (     n := (string->split(" ")[0+1])->toInteger() ; 
     m := (string->split(" ")[1+1])->toInteger() ; 
    array := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     array[i+1] := (reader.readLine())->toInteger() ;  ;     i := i + 1 ) ; 
    max := 0 ; 
        var i : int ; i := 0 ; while i < m do (     max := max+(array[i+1]) ;  ;     i := i + 1 ) ; 
    conflict := max ; 
        var i : int ; i := 0 ; while i < (n)->char2byte() - (m)->char2byte() - 1 do ( (     conflict := conflict+(array[i + m+1] - array[i+1]) ; 
     if (max < conflict) then     max := conflict ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countDivisibleSubseq(String str,int n){
    int len=str.length();
    int dp[][]=new int[len][n];
    dp[0][(str.charAt(0)-'0')% n]++;
    for(int i=1 ; i<len ; i++){
      dp[i][(str.charAt(i)-'0')% n]++;
      for(int j=0 ; j<n ; j++){
        dp[i][j]+=dp[i-1][j];
        dp[i][(j*10+(str.charAt(i)-'0'))% n]+=dp[i-1][j];
      }
    }
    return dp[len-1][0];
  }
  public static void main(String[] args){
    String str="1234" ;
    int n=4 ;
    System.out.print(countDivisibleSubseq(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countDivisibleSubseq( str : String, n : int) : int
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,len)->collect(Integer.subrange(1,n)->collect(0)) ;
    dp[0+1][(str->at(0+1) - ('0')->char2byte()) mod n+1] := dp[0+1][(str->at(0+1) - ('0')->char2byte()) mod n+1] + 1 ; 
        var i : int ; i := 1 ; while i < len do ( (     dp[i+1][(str->at(i+1) - ('0')->char2byte()) mod n+1] := dp[i+1][(str->at(i+1) - ('0')->char2byte()) mod n+1] + 1 ; 
         var j : int ; j := 0 ; while j < n do ( (     dp[i+1][j+1] := dp[i+1][j+1]+(dp[i - 1+1][j+1]) ; 
     dp[i+1][(j * 10 + (str->at(i+1) - ('0')->char2byte())) mod n+1] := dp[i+1][(j * 10 + (str->at(i+1) - ('0')->char2byte())) mod n+1]+(dp[i - 1+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return dp[len - 1+1][0+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "1234" ;
     var n : int ; n := 4 ;
     OclFile["System.out"].print(countDivisibleSubseq(str, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Generate {
  static void printWellOrdered(int number,int x,int k){
    if(k==0){
      System.out.print(number+" ");
      return ;
    }
    for(int i=(x+1); i<10 ; i++)printWellOrdered(number*10+i,i,k-1);
  }
  static void generateWellOrdered(int k){
    printWellOrdered(0,0,k);
  }
  public static void main(String[] args){
    int k=3 ;
    generateWellOrdered(k);
  }
}
------------------------------------------------------------
OCL File:
---------
class Generate {
  static   operation printWellOrdered( number : int, x : int, k : int) : void
  pre: true
  post: true
  activity: (     if (k = 0) then (     OclFile["System.out"].print(number + " ") ; 
     return ) else skip ; 
         var i : int ; i := (x + 1) ; while i < 10 do (     execute printWellOrdered(number * 10 + i, i, k - 1) ;  ;     i := i + 1 ) );
  static   operation generateWellOrdered( k : int) : void
  pre: true
  post: true
  activity: (     execute printWellOrdered(0, 0, k) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 3 ;
     execute generateWellOrdered(k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.StringTokenizer ;
public class Run {
  public static void main(String[] Z)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer stz ;
    stz=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(stz.nextToken());
    int m=Integer.parseInt(stz.nextToken());
    int k=Integer.parseInt(stz.nextToken());
    stz=new StringTokenizer(br.readLine());
    int[] segments=new int[n];
    for(int i=0 ; i<n ; i++){
      segments[i]=Integer.parseInt(stz.nextToken());
    }
    ArrayList<Integer>diffs=new ArrayList<>(n);
    for(int i=1 ; i<n ; i++){
      diffs.add(segments[i]-segments[i-1]);
    }
    Collections.sort(diffs);
    int ans=n ;
    for(int i=0 ; i<n-k ; i++){
      ans+=diffs.get(i)-1 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Run {
  static   operation main( Z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var stz : OclIterator ;
    stz := OclIterator.newOclIterator_String(br.readLine()) ; 
    var n : int ; n := (stz.next())->toInteger() ;
    var m : int ; m := (stz.next())->toInteger() ;
    var k : int ; k := (stz.next())->toInteger() ;
    stz := OclIterator.newOclIterator_String(br.readLine()) ; 
    var segments : Sequence(int) ; segments := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     segments[i+1] := (stz.next())->toInteger() )  ;     i := i + 1 ) ; 
    var diffs : Sequence(int) ; diffs := Sequence{} ;
        var i : int ; i := 1 ; while i < n do ( (     diffs := diffs->including(segments[i+1] - segments[i - 1+1]) )  ;     i := i + 1 ) ; 
    diffs := diffs->sort() ; 
    var ans : int ; ans := n ;
        var i : int ; i := 0 ; while i < n - k do ( (     ans := ans+(diffs->at(i+1) - 1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Hello {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long n=in.nextLong(),k=in.nextLong();
    long sum=1 ;
    long ans=0 ;
    long c=1 ;
    while(true){
      sum=(c*(c+1))/2 ;
      if(sum-k==n-c){
        ans=sum-k ;
        break ;
      }
      c++;
    }
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hello {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := in.getCurrent()->toLong() ;
    var k : long ; k := in.getCurrent()->toLong() ;
    var sum : long ; sum := 1 ;
    var ans : long ; ans := 0 ;
    var c : long ; c := 1 ;
    while (true) do (     sum := (c * (c + 1)) / 2 ; 
     if (sum - k = n - c) then (     ans := sum - k ; 
     break ) else skip ; 
     c := c + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ESportMafia {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int moves=sc.nextInt()-1 ;
    int candies=sc.nextInt();
    int caja=1,pone=1,poneprev=1,come=0 ;
    while(moves>0){
      if(caja>candies){
        come++;
        caja--;
      }
      else {
        pone++;
        caja+=pone ;
      }
      moves--;
    }
    System.out.println(come);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ESportMafia {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var moves : int ; moves := sc.getCurrent()->toInteger() - 1 ;
    var candies : int ; candies := sc.getCurrent()->toInteger() ;
    var caja : int ; caja := 1 ;
    var pone : int ; pone := 1 ;
    var poneprev : int ; poneprev := 1 ;
    var come : int ; come := 0 ;
    while (moves > 0) do (     if (caja > candies) then (     come := come + 1 ; 
     caja := caja - 1 ) else (     pone := pone + 1 ; 
     caja := caja+(pone) ) ;  
     moves := moves - 1 ) ; 
    OclFile["System.out"].println(come) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Mridul6 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextInt();
    long k=sc.nextInt();
    if(n==1 && k==1){
      System.out.println(0);
    }
    else {
      long i=0 ;
      int no=0 ;
      while((i*(i+1))/2<k || no==0){
        i=i+1 ;
        if(((i*(i+1))/2)>k){
          if(((i*(i+1))/2)-k==n-i){
            no=1 ;
          }
        }
      }
      if(no==1){
        System.out.println(n-i);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mridul6 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toInteger() ;
     var k : long ; k := sc.getCurrent()->toInteger() ;
     if (n = 1 & k = 1) then (     OclFile["System.out"].println(0) ) else (     var i : long ; i := 0 ;
     var no : int ; no := 0 ;
     while ((i * (i + 1)) / 2 < k or no = 0) do (     i := i + 1 ; 
     if (((i * (i + 1)) / 2) > k) then (     if (((i * (i + 1)) / 2) - k = n - i) then (     no := 1 ) else skip ) else skip ) ; 
     if (no = 1) then (     OclFile["System.out"].println(n - i) ) else skip ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayDeque<Integer>list=new ArrayDeque<Integer>();
    int count=0 ;
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      list.push(sc.nextInt());
    }
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      if(list.contains(sc.nextInt())==true)count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(int) ; list := ArrayDeque<int>.newArrayDeque() ;
    var count : int ; count := 0 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->append(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     if (list->includes(sc.getCurrent()->toInteger()) = true) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.out ;
import static java.lang.Math.*;
class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int ary[]=new int[n];
    for(int i=0 ; i<n ; i++){
      ary[i]=scan.nextInt();
    }
    Arrays.sort(ary);
    int m=scan.nextInt(),j=0,rec=0 ;
    int q[]=new int[m];
    for(int i=0 ; i<m ; i++){
      q[i]=scan.nextInt();
    }
    Arrays.sort(q);
    for(int i=0 ; i<m ; i++){
      for(; j<n ; j++){
        if(ary[j]==q[i]){
          j++;
          rec++;
          break ;
        }
        else if(ary[j]>q[i])break ;
      }
    }
    out.println(rec);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var ary : Sequence(int) ; ary := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ary[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    ary := ary->sort() ; 
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var j : int ; j := 0 ;
    var rec : int ; rec := 0 ;
    var q : Sequence(int) ; q := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     q[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    q := q->sort() ; 
        var i : int ; i := 0 ; while i < m do ( (       while j < n do ( (     if (ary[j+1] = q[i+1]) then (     j := j + 1 ; 
     rec := rec + 1 ; 
     break ) else     if (ary[j+1] > q[i+1]) then     break else skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    out.println(rec) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static int count=0 ;
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner sc2=new Scanner(System.in);
    int n=Integer.parseInt(sc2.nextLine());
    String[] s=sc2.nextLine().split("[\\s]+");
    int[] x=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=Integer.parseInt(s[i]);
    }
    int n2=Integer.parseInt(sc2.nextLine());
    String[] s2=sc2.nextLine().split("[\\s]+");
    int[] x2=new int[n2];
    if(s2[0] .equals("")){
      for(int i=0 ; i<n2 ; i++){
        x2[i]=Integer.parseInt(s2[i+1]);
      }
    }
    else {
      for(int i=0 ; i<n2 ; i++){
        x2[i]=Integer.parseInt(s2[i]);
      }
    }
    List<Integer>list=new ArrayList<Integer>();
    for(int h=0 ; h<n ; h++){
      for(int g=0 ; g<n2 ; g++){
        if(x[h]==x2[g]){
          if(list.contains(x[h])){
            break ;
          }
          else {
            count++;
            list.add(x[h]);
          }
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute count : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc2 : OclFile ; sc2 := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc2.nextLine())->toInteger() ;
    var s : Sequence(String) ; s := sc2.nextLine()->split("[\\s]+") ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := (s[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var n2 : int ; n2 := (sc2.nextLine())->toInteger() ;
    var s2 : Sequence(String) ; s2 := sc2.nextLine()->split("[\\s]+") ;
    var x2 : Sequence(int) ; x2 := Integer.subrange(1,n2)->collect(0) ;
    if (s2[0+1] = "") then (         var i : int ; i := 0 ; while i < n2 do ( (     x2[i+1] := (s2[i + 1+1])->toInteger() )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < n2 do ( (     x2[i+1] := (s2[i+1])->toInteger() )  ;     i := i + 1 ) ) ;  
    var list : Sequence(int) ; list := Sequence{} ;
        var h : int ; h := 0 ; while h < n do ( (         var g : int ; g := 0 ; while g < n2 do ( (     if (x[h+1] = x2[g+1]) then (     if (list->includes(x[h+1])) then (     break ) else (     count := count + 1 ; 
     list := list->including(x[h+1]) ) ) else skip )  ;     g := g + 1 ) )  ;     h := h + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner kbd=new Scanner(System.in);
  public static void main(String[] args){
    int n=kbd.nextInt();
    int[] s=new int[n];
    int i ;
    for(i=0 ; i<n ; i++){
      s[i]=kbd.nextInt();
    }
    sort(s);
    int cnt=0 ;
    int m=kbd.nextInt();
    for(i=0 ; i<m ; i++){
      int x=kbd.nextInt();
      boolean a=search(s,x);
      if(a)cnt++;
    }
    System.out.println(cnt);
  }
  public static void sort(int[] s){
    int i,min,j,w ;
    for(i=0 ; i<s.length ; i++){
      min=i ;
      for(j=i ; j<s.length ; j++){
        if(s[min]>s[j])min=j ;
      }
      w=s[i];
      s[i]=s[min];
      s[min]=w ;
    }
  }
  public static boolean search(int[] s,int x){
    int low=0 ;
    int high=s.length-1 ;
    int middle=(high+low)/2 ;
    while(low<=high){
      if(s[middle]==x)return true ;
      else if(s[middle]<x)low=middle+1 ;
      else high=middle-1 ;
      middle=(high+low)/2 ;
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute kbd : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := kbd.getCurrent()->toInteger() ;
     var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
    var i : int ;
        i := 0 ; while i < n do ( (     s[i+1] := kbd.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute sort(s) ; 
    var cnt : int ; cnt := 0 ;
    var m : int ; m := kbd.getCurrent()->toInteger() ;
        i := 0 ; while i < m do ( (     var x : int ; x := kbd.getCurrent()->toInteger() ;
     var a : boolean ; a := search(s, x) ;
     if (a) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
  static   operation sort( s : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var min : int ;
    var j : int ;
    var w : int ;
         i := 0 ; while i < s->size() do ( (     min := i ; 
         j := i ; while j < s->size() do ( (     if (s[min+1] > s[j+1]) then     min := j ; else skip )  ;     j := j + 1 ) ; 
    w := s[i+1] ; 
    s[i+1] := s[min+1] ; 
    s[min+1] := w ; 
 )  ;     i := i + 1 ) );
  static   operation search( s : Sequence(int), x : int) : boolean
  pre: true
  post: true
  activity: (     var low : int ; low := 0 ;
     var high : int ; high := s->size() - 1 ;
    var middle : int ; middle := (high + low) / 2 ;
    while (low <= high) do (     if (s[middle+1] = x) then     return true else     if (s[middle+1] < x) then     low := middle + 1 else     high := middle - 1 ; ;  ;  
     middle := (high + low) / 2 ) ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n,q ;
    int cnt=0 ;
    ArrayList<Integer>S=new ArrayList<Integer>();
    ArrayList<Integer>list=new ArrayList<Integer>();
    n=Integer.parseInt(br.readLine());
    StringTokenizer st=new StringTokenizer(br.readLine()," ");
    for(int i=0 ; i<n ; i++)S.add(Integer.parseInt(st.nextToken()));
    q=Integer.parseInt(br.readLine());
    st=new StringTokenizer(br.readLine()," ");
    for(int i=0 ; i<q ; i++){
      int temp=Integer.parseInt(st.nextToken());
      if(S.contains(temp)&& ! list.contains(temp)){
        list.add(temp);
        cnt++;
      }
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ;
    var q : int ;
    var cnt : int ; cnt := 0 ;
    var S : Sequence(int) ; S := Sequence{} ;
    var list : Sequence(int) ; list := Sequence{} ;
    n := (br.readLine())->toInteger() ; 
    var st : OclIterator ; st := OclIterator.newOclIterator_String_String(br.readLine(), " ") ;
        var i : int ; i := 0 ; while i < n do (     S := S->including((st.next())->toInteger()) ;  ;     i := i + 1 ) ; 
    q := (br.readLine())->toInteger() ; 
    st := OclIterator.newOclIterator_String_String(br.readLine(), " ") ; 
        var i : int ; i := 0 ; while i < q do ( (     var temp : int ; temp := (st.next())->toInteger() ;
     if (S->includes(temp) & not(list->includes(temp))) then (     list := list->including(temp) ; 
     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int cnt=0 ;
      String arr[]=new String[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.next();
      }
      for(int i=0 ; i<n ; i++){
        if(arr[i] .charAt(m-1)=='R'){
          cnt++;
        }
      }
      for(int i=0 ; i<m ; i++){
        if(arr[n-1] .charAt(i)=='D'){
          cnt++;
        }
      }
      System.out.println(cnt);
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var cnt : int ; cnt := 0 ;
    var arr : Sequence(String) ; arr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1]->at(m - 1+1) = 'R') then (     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     if (arr[n - 1+1]->at(i+1) = 'D') then (     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.PriorityQueue ;
public class Tape {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    String[] temp=br.readLine().split(" ");
    int n=Integer.parseInt(temp[0]);
    int m=Integer.parseInt(temp[1]);
    int k=Integer.parseInt(temp[2]);
    int[] nums=new int[n];
    temp=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      nums[i]=Integer.parseInt(temp[i]);
    }
    if(k>=n){
      pr.println(n);
      return ;
    }
    PriorityQueue<Integer>gaps=new PriorityQueue<>();
    for(int i=0 ; i<n-1 ; i++){
      gaps.add(nums[i+1]-nums[i]-1);
    }
    int res=n ;
    int current=n ;
    while(current>k){
      res+=gaps.poll();
      current--;
    }
    pr.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Tape {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
     var n : int ; n := (temp[0+1])->toInteger() ;
    var m : int ; m := (temp[1+1])->toInteger() ;
    var k : int ; k := (temp[2+1])->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
    temp := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := (temp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    if (k >= n) then (     skip ; 
     return ) else skip ; 
    var gaps : Sequence(int) ; gaps := Sequence{} ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     gaps := gaps->including(nums[i + 1+1] - nums[i+1] - 1) )  ;     i := i + 1 ) ; 
    var res : int ; res := n ;
    var current : int ; current := n ;
    while (current > k) do (     res := res + gaps->min() ;     gaps := gaps->sort()->tail() ; 
     current := current - 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test288 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int m=in.nextInt();
      char[][] a=new char[n][];
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        char[] b=in.next().toCharArray();
        a[i]=b ;
      }
      for(int i=0 ; i<n ; i++){
        if(a[i][m-1]=='R'){
          sum++;
        }
      }
      for(int i=0 ; i<m ; i++){
        if(a[n-1][i]=='D'){
          sum++;
        }
      }
      System.out.println(sum);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test288 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,n)->collect(Sequence{}) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var b : Sequence(String) ; b := in.getCurrent()->characters() ;
     a[i+1] := b )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1][m - 1+1] = 'R') then (     sum := sum + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     if (a[n - 1+1][i+1] = 'D') then (     sum := sum + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Sol {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    for(int p=0 ; p<num ; p++){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int count=0 ;
      for(int i=0 ; i<n ; i++){
        String s=sc.next();
        if(i==n-1){
          for(int j=0 ; j<m ; j++){
            if(s.charAt(j)=='D')count++;
          }
        }
        if(s.charAt(m-1)=='R')count++;
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sol {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
         var p : int ; p := 0 ; while p < num do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
     if (i = n - 1) then (         var j : int ; j := 0 ; while j < m do ( (     if (s->at(j+1) = 'D') then     count := count + 1 ; else skip )  ;     j := j + 1 ) ) else skip ; 
     if (s->at(m - 1+1) = 'R') then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )  ;     p := p + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1391B_FixYou {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int row=input.nextInt();
      int col=input.nextInt();
      input.nextLine();
      List<Character>rightColumn=new ArrayList<>();
      List<Character>downRow=new ArrayList<>();
      for(int i=1 ; i<=row ; i++){
        String eachRow=input.nextLine();
        char c=eachRow.charAt(col-1);
        rightColumn.add(c);
        if(i==row){
          for(char ch : eachRow.toCharArray()){
            downRow.add(ch);
          }
        }
      }
      int a=Collections.frequency(rightColumn,'R');
      int b=Collections.frequency(downRow,'D');
      System.out.println(a+b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1391B_FixYou {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var row : int ; row := input.getCurrent()->toInteger() ;
     var col : int ; col := input.getCurrent()->toInteger() ;
    skip ; 
    var rightColumn : Sequence(String) ; rightColumn := Sequence{} ;
    var downRow : Sequence(String) ; downRow := Sequence{} ;
        var i : int ; i := 1 ; while i <= row do ( (     var eachRow : String ; eachRow := input.nextLine() ;
     var c : String ; c := eachRow->at(col - 1+1) ;
     rightColumn := rightColumn->including(c) ; 
     if (i = row) then (     for (ch : eachRow->characters()) do ( (     downRow := downRow->including(ch) )  ) ) else skip )  ;     i := i + 1 ) ; 
    var a : int ; a := .frequency(rightColumn, 'R') ;
    var b : int ; b := .frequency(downRow, 'D') ;
    OclFile["System.out"].println(a + b) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] w=new int[n];
    int[] b=new int[n];
    int[] r=new int[n];
    for(int i=0 ; i<n ; i++){
      String str=sc.next();
      for(int j=0 ; j<m ; j++){
        char c=str.charAt(j);
        if(c=='W'){
          w[i]++;
        }
        else if(c=='B'){
          b[i]++;
        }
        else {
          r[i]++;
        }
      }
    }
    int ans=100000000 ;
    for(int i=1 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        int tmp=0 ;
        for(int k=0 ; k<i ; k++){
          tmp+=m-w[k];
        }
        for(int k=i ; k<j ; k++){
          tmp+=m-b[k];
        }
        for(int k=j ; k<n ; k++){
          tmp+=m-r[k];
        }
        ans=Math.min(ans,tmp);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var w : Sequence(int) ; w := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < m do ( (     var c : String ; c := str->at(j+1) ;
     if (c = 'W') then (     w[i+1] := w[i+1] + 1 ) else     if (c = 'B') then (     b[i+1] := b[i+1] + 1 ) else (     r[i+1] := r[i+1] + 1 ) ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 100000000 ;
        var i : int ; i := 1 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var tmp : int ; tmp := 0 ;
         var k : int ; k := 0 ; while k < i do ( (     tmp := tmp+(m - w[k+1]) )  ;     k := k + 1 ) ; 
        var k : int ; k := i ; while k < j do ( (     tmp := tmp+(m - b[k+1]) )  ;     k := k + 1 ) ; 
        var k : int ; k := j ; while k < n do ( (     tmp := tmp+(m - r[k+1]) )  ;     k := k + 1 ) ; 
    ans := Set{ans, tmp}->min() ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MainClass {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int t=Integer.parseInt(st.nextToken());
    while(t-->0){
      st=new StringTokenizer(br.readLine());
      int n=Integer.parseInt(st.nextToken());
      int m=Integer.parseInt(st.nextToken());
      char[][] mat=new char[n][m];
      for(int i=0 ; i<n ; i++){
        st=new StringTokenizer(br.readLine());
        String s=st.nextToken();
        for(int j=0 ; j<m ; j++){
          mat[i][j]=s.charAt(j);
        }
      }
      int cnt=0 ;
      for(int i=0 ; i<n ; i++){
        if(mat[i][m-1]=='R')cnt++;
      }
      for(int i=0 ; i<m ; i++){
        if(mat[n-1][i]=='D')cnt++;
      }
      System.out.println(cnt);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var t : int ; t := (st.next())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var mat : Sequence(Sequence(String)) ; mat := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var s : String ; s := st.next() ;
         var j : int ; j := 0 ; while j < m do ( (     mat[i+1][j+1] := s->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (mat[i+1][m - 1+1] = 'R') then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     if (mat[n - 1+1][i+1] = 'D') then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ReplaceDigits {
  static int replace0with5(int number){
    return number+=calculateAddedValue(number);
  }
  private static int calculateAddedValue(int number){
    int result=0 ;
    int decimalPlace=1 ;
    if(number==0){
      result+=(5*decimalPlace);
    }
    while(number>0){
      if(number % 10==0)result+=(5*decimalPlace);
      number/=10 ;
      decimalPlace*=10 ;
    }
    return result ;
  }
  public static void main(String[] args){
    System.out.print(replace0with5(1020));
  }
}
------------------------------------------------------------
OCL File:
---------
class ReplaceDigits {
  static   operation replace0with5( number : int) : int
  pre: true
  post: true
  activity: (     return number );
  static   operation calculateAddedValue( number : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var decimalPlace : int ; decimalPlace := 1 ;
    if (number = 0) then (     result := result+((5 * decimalPlace)) ) else skip ; 
    while (number > 0) do (     if (number mod 10 = 0) then     result := result+((5 * decimalPlace)) ; else skip ; 
     number := number/(10) ; 
     decimalPlace := decimalPlace*(10) ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(replace0with5(1020)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int power(long x,long y,long p){
    long res=1 ;
    x=x % p ;
    while(y>0){
      if((y & 1)!=0)res=(res*x)% p ;
      y=y>>1 ;
      x=(x*x)% p ;
    }
    return(int)res ;
  }
  static void printLastKDigits(int a,int b,int k){
    System.out.print("Last "+k+" digits of "+a+"^"+b+"=");
    int temp=1 ;
    for(int i=1 ; i<=k ; i++)temp*=10 ;
    temp=power(a,b,temp);
    for(int i=0 ; i<k-Integer.toString(temp).length(); i++)System.out.print(0);
    if(temp!=0)System.out.print(temp);
  }
  public static void main(String[] args){
    int a=11 ;
    int b=3 ;
    int k=2 ;
    printLastKDigits(a,b,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation power( x : long, y : long, p : long) : int
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     if ((y & 1) /= 0) then     res := (res * x) mod p ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res->oclAsType(int) );
  static   operation printLastKDigits( a : int, b : int, k : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("Last " + k + " digits of " + a + "^" + b + "=") ; 
     var temp : int ; temp := 1 ;
        var i : int ; i := 1 ; while i <= k do (     temp := temp*(10) ;  ;     i := i + 1 ) ; 
    temp := power(a, b, temp) ; 
        var i : int ; i := 0 ; while i < k - ((temp) + "")->size() do (     OclFile["System.out"].print(0) ;  ;     i := i + 1 ) ; 
    if (temp /= 0) then     OclFile["System.out"].print(temp) ; else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 11 ;
     var b : int ; b := 3 ;
     var k : int ; k := 2 ;
     execute printLastKDigits(a, b, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  final static int MAX=26 ;
  static int minOperation(String str,int len){
    int first[]=new int[MAX];
    int last[]=new int[MAX];
    for(int i=0 ; i<MAX ; i++){
      first[i]=-1 ;
      last[i]=-1 ;
    }
    for(int i=0 ; i<len ; i++){
      int index=(str.charAt(i)-'a');
      if(first[index]==-1)first[index]=i ;
      last[index]=i ;
    }
    int minOp=-1 ;
    for(int i=0 ; i<MAX ; i++){
      if(first[i]==-1 || first[i]==last[i])continue ;
      int cnt=len-(last[i]-first[i]+1);
      if(minOp==-1 || cnt<minOp)minOp=cnt ;
    }
    return minOp ;
  }
  public static void main(String[] args){
    String str="abcda" ;
    int len=str.length();
    System.out.println(minOperation(str,len));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 26;
  static   operation minOperation( str : String, len : int) : int
  pre: true
  post: true
  activity: (     var first : Sequence(int) ; first := Integer.subrange(1,MAX)->collect(0) ;
     var last : Sequence(int) ; last := Integer.subrange(1,MAX)->collect(0) ;
        var i : int ; i := 0 ; while i < MAX do ( (     first[i+1] := -1 ; 
     last[i+1] := -1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < len do ( (     var index : int ; index := (str->at(i+1) - ('a')->char2byte()) ;
     if (first[index+1] = -1) then     first[index+1] := i ; else skip ; 
     last[index+1] := i )  ;     i := i + 1 ) ; 
    var minOp : int ; minOp := -1 ;
        var i : int ; i := 0 ; while i < MAX do ( (     if (first[i+1] = -1 or first[i+1] = last[i+1]) then     continue else skip ; 
     var cnt : int ; cnt := len - (last[i+1] - first[i+1] + 1) ;
     if (minOp = -1 or cnt < minOp) then     minOp := cnt ; else skip )  ;     i := i + 1 ) ; 
    return minOp 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abcda" ;
     var len : int ; len := str->size() ;
     OclFile["System.out"].println(minOperation(str, len)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MemoryTrident {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    if(scanner.hasNext()){
      String s=scanner.next();
      int x=0 ;
      int y=0 ;
      if(s.length()==1 || s.length()% 2!=0)System.out.println(-1);
      else {
        for(char ch : s.toCharArray()){
          if(ch=='U')x++;
          if(ch=='D')x--;
          if(ch=='L')y--;
          if(ch=='R')y++;
        }
        System.out.println((Math.abs(x)+Math.abs(y))/2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MemoryTrident {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     if (scanner.hasNext()) then (     var s : String ; s := scanner.getCurrent() ;
     var x : int ; x := 0 ;
     var y : int ; y := 0 ;
     if (s->size() = 1 or s->size() mod 2 /= 0) then     OclFile["System.out"].println(-1) ; else (     for (ch : s->characters()) do ( (     if (ch = 'U') then     x := x + 1 ; else skip ; 
     if (ch = 'D') then     x := x - 1 ; else skip ; 
     if (ch = 'L') then     y := y - 1 ; else skip ; 
     if (ch = 'R') then     y := y + 1 ; else skip )  ) ; 
     OclFile["System.out"].println((if x < 0 then -(x) else x endif + if y < 0 then -(y) else y endif) / 2) ) ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p040 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p040().run());
  }
  public String run(){
    StringBuilder sb=new StringBuilder();
    for(int i=1 ; i<1000000 ; i++)sb.append(i);
    int prod=1 ;
    for(int i=0 ; i<=6 ; i++)prod*=sb.charAt(Library.pow(10,i)-1)-'0' ;
    return Integer.toString(prod);
  }
}
------------------------------------------------------------
OCL File:
---------
class p040 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p040.newp040().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 1 ; while i < 1000000 do (     sb := sb + StringLib.newString(i) ;  ;     i := i + 1 ) ; 
    var prod : int ; prod := 1 ;
        var i : int ; i := 0 ; while i <= 6 do (     prod := prod*(sb->at(Library.pow(10, i) - 1+1) - ('0')->char2byte()) ;  ;     i := i + 1 ) ; 
    return ((prod) + "") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int onesComplement(int n){
    int number_of_bits=(int)(Math.floor(Math.log(n)/Math.log(2)))+1 ;
    return((1<<number_of_bits)-1)^ n ;
  }
  public static void main(String[] args){
    int n=22 ;
    System.out.print(onesComplement(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation onesComplement( n : int) : int
  pre: true
  post: true
  activity: (     var number_of_bits : int ; number_of_bits := (((n)->log() / (2)->log())->floor())->oclAsType(int) + 1 ;
     return (((1*(2->pow(number_of_bits)))->oclAsType(long)) - 1) xor n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 22 ;
     OclFile["System.out"].print(onesComplement(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class IfAtFirstYouDontSucceed {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    int b=in.nextInt();
    int c=in.nextInt();
    int n=in.nextInt();
    if(a>=n || b>=n || c>=n ||(a-c+b)>=n || a<c || b<c)System.out.println(-1);
    else System.out.println(n-(a-c+b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class IfAtFirstYouDontSucceed {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    if (a >= n or b >= n or c >= n or (a - c + b) >= n or a < c or b < c) then     OclFile["System.out"].println(-1) else     OclFile["System.out"].println(n - (a - c + b)) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt(),b=in.nextInt(),c=in.nextInt(),n=in.nextInt();
    System.out.println(getResult(a,b,c,n));
    in.close();
  }
  static int getResult(int a,int b,int c,int n){
    if(a>n || b>n || c>n)return-1 ;
    if(a<c || b<c)return-1 ;
    int res=n-(a+b-c);
    if(res<1)return-1 ;
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println(getResult(a, b, c, n)) ; 
     skip );
  static   operation getResult( a : int, b : int, c : int, n : int) : int
  pre: true
  post: true
  activity: (     if (a > n or b > n or c > n) then     return -1 else skip ; 
     if (a < c or b < c) then     return -1 else skip ; 
    var res : int ; res := n - (a + b - c) ;
    if (res < 1) then     return -1 else skip ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner console=new Scanner(System.in);
    int bd=console.nextInt(),bk=console.nextInt(),both=console.nextInt(),total=console.nextInt();
    int answer=bd+bk-(both);
    if(answer<0 || answer>=total || bk<both || bd<both)System.out.println(-1);
    else System.out.println(total-answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var console : OclFile ; console := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var bd : int ; bd := console.getCurrent()->toInteger() ;
    var bk : int ; bk := console.getCurrent()->toInteger() ;
    var both : int ; both := console.getCurrent()->toInteger() ;
    var total : int ; total := console.getCurrent()->toInteger() ;
     var answer : int ; answer := bd + bk - (both) ;
     if (answer < 0 or answer >= total or bk < both or bd < both) then     OclFile["System.out"].println(-1) ; else     OclFile["System.out"].println(total - answer) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int n=sc.nextInt();
      int lessPass=a-c ;
      int morePass=b-c ;
      int totalPassed=lessPass+morePass+c ;
      int ans=n-totalPassed ;
      if(ans<=0 || lessPass<0 || morePass<0)System.out.println(-1);
      else System.out.println(ans);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var lessPass : int ; lessPass := a - c ;
    var morePass : int ; morePass := b - c ;
    var totalPassed : int ; totalPassed := lessPass + morePass + c ;
    var ans : int ; ans := n - totalPassed ;
    if (ans <= 0 or lessPass < 0 or morePass < 0) then     OclFile["System.out"].println(-1) else     OclFile["System.out"].println(ans) ; ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector ;
class GFG {
  static void printPermutation(int N,int K){
    Vector<Integer>res=new Vector<>();
    int l=1,r=N,flag=0 ;
    for(int i=0 ; i<K ; i++){
      if(flag==0){
        res.add(l);
        l++;
      }
      else {
        res.add(r);
        r--;
      }
      flag ^=1 ;
    }
    if(flag!=1){
      for(int i=r ; i>=l ; i--){
        res.add(i);
      }
    }
    else {
      for(int i=l ; i<=r ; i++){
        res.add(i);
      }
    }
    for(Integer i : res){
      System.out.print(i+" ");
    }
  }
  public static void main(String[] args){
    int N=10,K=4 ;
    printPermutation(N,K);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printPermutation( N : int, K : int) : void
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Sequence{} ;
     var l : int ; l := 1 ;
    var r : int ; r := N ;
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < K do ( (     if (flag = 0) then (     res := res->including(l) ; 
     l := l + 1 ) else (     res := res->including(r) ; 
     r := r - 1 ) ;  
     flag := MathLib.bitwiseXor(flag,1) )  ;     i := i + 1 ) ; 
    if (flag /= 1) then (         var i : int ; i := r ; while i >= l do ( (     res := res->including(i) )  ;     i := i - 1 ) ) else (         var i : int ; i := l ; while i <= r do ( (     res := res->including(i) )  ;     i := i + 1 ) ) ;  
    for (i : res) do ( (     OclFile["System.out"].print(i + " ") )  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 10 ;
    var K : int ; K := 4 ;
     execute printPermutation(N, K) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedOutputStream ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Map ;
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
import java.util.TreeMap ;
public class Practice1 {
  public static void main(String[] args){
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    FastReader sc=new FastReader();
    int k=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int v=sc.nextInt();
    int min=Math.min(k,b+1);
    int count=0 ;
    while(a>0){
      int x=Math.min(k,Math.max(b+1,1));
      a-=x*v ;
      b-=x-1 ;
      count++;
    }
    out.println(count);
    out.close();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var sc : FastReader ; sc := FastReader.newFastReader() ;
    var k : int ; k := sc.nextInt() ;
    var a : int ; a := sc.nextInt() ;
    var b : int ; b := sc.nextInt() ;
    var v : int ; v := sc.nextInt() ;
    var min : int ; min := Set{k, b + 1}->min() ;
    var count : int ; count := 0 ;
    while (a > 0) do (     var x : int ; x := Set{k, Set{b + 1, 1}->max()}->min() ;
     a := a-(x * v) ; 
     b := b-(x - 1) ; 
     count := count + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int c=in.nextInt(),v0=in.nextInt(),v1=in.nextInt(),a=in.nextInt(),l=in.nextInt();
    int count=0 ;
    int j=0 ;
    while(c>0){
      c-=v0-j ;
      j=l ;
      v0=Math.min(v0+a,v1);
      count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : int ; c := in.getCurrent()->toInteger() ;
    var v0 : int ; v0 := in.getCurrent()->toInteger() ;
    var v1 : int ; v1 := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var l : int ; l := in.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var j : int ; j := 0 ;
    while (c > 0) do (     c := c-(v0 - j) ; 
     j := l ; 
     v0 := Set{v0 + a, v1}->min() ; 
     count := count + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedOutputStream ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Map ;
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
import java.util.TreeMap ;
public class Practice2 {
  public static void main(String[] args){
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    FastReader sc=new FastReader();
    int c=sc.nextInt();
    int vo=sc.nextInt();
    int v1=sc.nextInt();
    int a=sc.nextInt();
    int l=sc.nextInt();
    int count=1 ;
    int comp=vo ;
    while(comp<c){
      count++;
      vo=Math.min(v1,vo+a);
      comp+=(vo-l);
    }
    out.println(count);
    out.close();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var sc : FastReader ; sc := FastReader.newFastReader() ;
    var c : int ; c := sc.nextInt() ;
    var vo : int ; vo := sc.nextInt() ;
    var v1 : int ; v1 := sc.nextInt() ;
    var a : int ; a := sc.nextInt() ;
    var l : int ; l := sc.nextInt() ;
    var count : int ; count := 1 ;
    var comp : int ; comp := vo ;
    while (comp < c) do (     count := count + 1 ; 
     vo := Set{v1, vo + a}->min() ; 
     comp := comp+((vo - l)) ) ; 
    skip ; 
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _820A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int c=sc.nextInt(),v0=sc.nextInt(),v1=sc.nextInt(),a=sc.nextInt(),l=sc.nextInt();
    if(c==0){
      System.out.println(0);
      return ;
    }
    int days=1 ;
    int pages=v0 ;
    int capacity=v0 ;
    while(pages<c){
      capacity=Math.min(v1,capacity+a);
      pages+=capacity-l ;
      days++;
    }
    System.out.println(days);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _820A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
    var v0 : int ; v0 := sc.getCurrent()->toInteger() ;
    var v1 : int ; v1 := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    if (c = 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var days : int ; days := 1 ;
    var pages : int ; pages := v0 ;
    var capacity : int ; capacity := v0 ;
    while (pages < c) do (     capacity := Set{v1, capacity + a}->min() ; 
     pages := pages+(capacity - l) ; 
     days := days + 1 ) ; 
    OclFile["System.out"].println(days) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class IsDivisible {
  static boolean isDivisibleBy25(String str){
    int n=str.length();
    if(n==1)return false ;
    return((str.charAt(n-1)-'0'==0 && str.charAt(n-2)-'0'==0)||((str.charAt(n-2)-'0')*10+(str.charAt(n-1)-'0'))% 25==0);
  }
  public static void main(String[] args){
    String str="76955" ;
    if(isDivisibleBy25(str))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class IsDivisible {
  static   operation isDivisibleBy25( str : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     if (n = 1) then     return false else skip ; 
     return ((str->at(n - 1+1) - ('0')->char2byte() = 0 & str->at(n - 2+1) - ('0')->char2byte() = 0) or ((str->at(n - 2+1) - ('0')->char2byte()) * 10 + (str->at(n - 1+1) - ('0')->char2byte())) mod 25 = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "76955" ;
     if (isDivisibleBy25(str)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewClass27 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int w=in.nextInt();
      int h=in.nextInt();
      int n=in.nextInt();
      int sheet=1 ;
      while(w % 2==0){
        w/=2 ;
        sheet*=2 ;
      }
      while(h % 2==0){
        h/=2 ;
        sheet*=2 ;
      }
      if(sheet>=n){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass27 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var w : int ; w := in.getCurrent()->toInteger() ;
     var h : int ; h := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var sheet : int ; sheet := 1 ;
    while (w mod 2 = 0) do (     w := w/(2) ; 
     sheet := sheet*(2) ) ; 
    while (h mod 2 = 0) do (     h := h/(2) ; 
     sheet := sheet*(2) ) ; 
    if (sheet >= n) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
class GFG {
  static void printPair(int g,int l){
    int n=g*l ;
    for(int i=1 ; i*i<=n ; i++){
      if(n % i==0){
        int first=i ;
        int second=n/i ;
        int gcd=__gcd(first,second);
        if(gcd==g && l % first==0 && l % second==0){
          System.out.println(first+" "+second);
          return ;
        }
      }
    }
  }
  private static int __gcd(int a,int b){
    BigInteger b1=new BigInteger(""+a);
    BigInteger b2=new BigInteger(""+b);
    BigInteger gcd=b1.gcd(b2);
    return gcd.intValue();
  }
  public static void main(String[] args){
    int g=3,l=12 ;
    printPair(g,l);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printPair( g : int, l : int) : void
  pre: true
  post: true
  activity: (     var n : int ; n := g * l ;
         var i : int ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     var first : int ; first := i ;
     var second : int ; second := n / i ;
     var gcd : int ; gcd := __gcd(first, second) ;
     if (gcd = g & l mod first = 0 & l mod second = 0) then (     OclFile["System.out"].println(first + " " + second) ; 
     return ) else skip ) else skip )  ;     i := i + 1 ) );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var b1 : long ; b1 := long("" + a) ;
     var b2 : long ; b2 := long("" + b) ;
     var gcd : long ; gcd := b1.gcd(b2) ;
     return gcd->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : int ; g := 3 ;
    var l : int ; l := 12 ;
     execute printPair(g, l) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Vector<Integer>processQueries(int Q[],int m,int n){
    int[] a=new int[m+1];
    int[] pos=new int[m+1];
    for(int i=1 ; i<=m ; i++){
      a[i-1]=i ;
      pos[i]=i-1 ;
    }
    Vector<Integer>ans=new Vector<Integer>();
    for(int i=0 ; i<n ; i++){
      int q=Q[i];
      int p=pos[q];
      ans.add(p);
      for(int j=p ; j>0 ; j--){
        a[j]=a[j]+a[j-1];
        a[j-1]=a[j]-a[j-1];
        a[j]=a[j]-a[j-1];
        pos[a[j] ]=j ;
      }
      pos[a[0] ]=0 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int Q[]={
      3,1,2,1 };
      int n=Q.length ;
      int m=5 ;
      Vector<Integer>ans=new Vector<Integer>();
      ans=processQueries(Q,m,n);
      for(int i=0 ; i<ans.size(); i++)System.out.print(ans.get(i)+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation processQueries( Q : Sequence(int), m : int, n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,m + 1)->collect(0) ;
     var pos : Sequence(int) ; pos := Integer.subrange(1,m + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= m do ( (     a[i - 1+1] := i ; 
     pos[i+1] := i - 1 )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var q : int ; q := Q[i+1] ;
     var p : int ; p := pos[q+1] ;
    ans := ans->including(p) ; 
        var j : int ; j := p ; while j > 0 do ( (     a[j+1] := a[j+1] + a[j - 1+1] ; 
     a[j - 1+1] := a[j+1] - a[j - 1+1] ; 
     a[j+1] := a[j+1] - a[j - 1+1] ; 
     pos[a[j+1]+1] := j )  ;     j := j - 1 ) ; 
    pos[a[0+1]+1] := 0 ; 
 )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Q : Sequence(int) ; Q := Sequence{3,1,2,1} ;
     var n : int ; n := Q->size() ;
    var m : int ; m := 5 ;
    var ans : Sequence(int) ; ans := Sequence{} ;
    ans := processQueries(Q, m, n) ; 
        var i : int ; i := 0 ; while i < ans->size() do (     OclFile["System.out"].print(ans->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    int l=stdIn.nextInt();
    int[] t=new int[n];
    for(int i=0 ; i<n ; i++){
      t[i]=l+i ;
    }
    int min=Math.abs(t[0]);
    for(int i=1 ; i<n ; i++){
      if(min>Math.abs(t[i]))min=Math.abs(t[i]);
    }
    int total=0 ;
    for(int i=0 ; i<n ; i++){
      total+=t[i];
    }
    if(t[n-1]<0)System.out.println(total+min);
    else System.out.println(total-min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var l : int ; l := stdIn.getCurrent()->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     t[i+1] := l + i )  ;     i := i + 1 ) ; 
    var min : int ; min := if t[0+1] < 0 then -(t[0+1]) else t[0+1] endif ;
        var i : int ; i := 1 ; while i < n do ( (     if (min > if t[i+1] < 0 then -(t[i+1]) else t[i+1] endif) then     min := if t[i+1] < 0 then -(t[i+1]) else t[i+1] endif ; else skip )  ;     i := i + 1 ) ; 
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     total := total+(t[i+1]) )  ;     i := i + 1 ) ; 
    if (t[n - 1+1] < 0) then     OclFile["System.out"].println(total + min) else     OclFile["System.out"].println(total - min) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
public class Main {
  double EPS=10.e-08 ;
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int a=sc.nextInt();
      int[] data=new int[n];
      long sum=0 ;
      for(int i=0 ; i<n ; i++){
        data[i]=i+a ;
        sum+=data[i];
      }
      int min=Integer.MAX_VALUE ;
      int value=0 ;
      for(int i=0 ; i<n ; i++){
        if(min>Math.abs(data[i])){
          min=Math.abs(data[i]);
          value=data[i];
        }
      }
      System.out.println(sum-value);
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute EPS : double := 10.e-08;
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var data : Sequence(int) ; data := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     data[i+1] := i + a ; 
     sum := sum+(data[i+1]) )  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
    var value : int ; value := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (min > if data[i+1] < 0 then -(data[i+1]) else data[i+1] endif) then (     min := if data[i+1] < 0 then -(data[i+1]) else data[i+1] endif ; 
     value := data[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum - value) ; 
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    final int NUM=scan.nextInt();
    List<Integer>scores=new ArrayList<>();
    int delicious=scan.nextInt();
    for(int i=0 ; i<NUM ; i++){
      scores.add(delicious+i);
    }
    int sum=0 ;
    Collections.sort(scores,new Comparator<Integer>(){
      @ Override public int compare(Integer a,Integer b){
        return Math.abs(a)-Math.abs(b);
      }
    }
);
    scores.remove(0);
    for(Integer integer : scores){
      sum+=integer ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var NUM : int ; NUM := scan.getCurrent()->toInteger() ;
    var scores : Sequence(int) ; scores := Sequence{} ;
    var delicious : int ; delicious := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < NUM do ( (     scores := scores->including(delicious + i) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    scores, OclComparator<int>.newOclComparator() := scores, OclComparator<int>.newOclComparator()->sort() ; 
    scores := scores->excludingAt(0+1) ; 
    for (integer : scores) do ( (     sum := sum+(integer) )  ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int r,b,w,g ;
    Scanner sc=new Scanner(System.in);
    r=sc.nextInt();
    b=sc.nextInt();
    w=sc.nextInt();
    g=sc.nextInt();
    System.out.println(r+b+w+g);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : int ;
    var b : int ;
    var w : int ;
    var g : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    r := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    w := sc.getCurrent()->toInteger() ; 
    g := sc.getCurrent()->toInteger() ; 
    OclFile["System.out"].println(r + b + w + g) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.InputMismatchException ;
class Main {
  public static void main(String args[]){
    int N=0,L=0 ;
    Scanner scanner=new Scanner(System.in);
    N=scanner.nextInt();
    L=scanner.nextInt();
    scanner.close();
    int min=1000 ;
    int flag=0 ;
    for(int i=0 ; i<N ; i++){
      if(Math.abs(L+i)<min){
        min=Math.abs(L+i);
        if(L+i<0){
          flag=0 ;
        }
        else {
          flag=1 ;
        }
      }
    }
    int sum=0 ;
    for(int i=0 ; i<N ; i++){
      sum=sum+(L+i);
    }
    if(flag==0){
      sum=sum+min ;
    }
    else {
      sum=sum-min ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 0 ;
    var L : int ; L := 0 ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    N := scanner.getCurrent()->toInteger() ; 
    L := scanner.getCurrent()->toInteger() ; 
    skip ; 
    var min : int ; min := 1000 ;
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (if L + i < 0 then -(L + i) else L + i endif < min) then (     min := if L + i < 0 then -(L + i) else L + i endif ; 
     if (L + i < 0) then (     flag := 0 ) else (     flag := 1 ) ) else skip )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     sum := sum + (L + i) )  ;     i := i + 1 ) ; 
    if (flag = 0) then (     sum := sum + min ) else (     sum := sum - min ) ;  
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=scan.nextInt();
    int L=scan.nextInt();
    int[] apple=new int[N];
    int sum=0 ;
    for(int i=0 ; i<N ; i++){
      apple[i]=L+i+1-1 ;
      sum+=apple[i];
    }
    Arrays.sort(apple);
    int diff=Integer.MAX_VALUE ;
    int answer=Integer.MAX_VALUE ;
    for(int i=0 ; i<N ; i++){
      int taste=sum-apple[i];
      if(Math.abs(sum-taste)<diff){
        answer=taste ;
        diff=Math.abs(sum-taste);
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var L : int ; L := scan.getCurrent()->toInteger() ;
    var apple : Sequence(int) ; apple := Integer.subrange(1,N)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     apple[i+1] := L + i + 1 - 1 ; 
     sum := sum+(apple[i+1]) )  ;     i := i + 1 ) ; 
    apple := apple->sort() ; 
    var diff : int ; diff := 2147483647 ;
    var answer : int ; answer := 2147483647 ;
        var i : int ; i := 0 ; while i < N do ( (     var taste : int ; taste := sum - apple[i+1] ;
     if (if sum - taste < 0 then -(sum - taste) else sum - taste endif < diff) then (     answer := taste ; 
     diff := if sum - taste < 0 then -(sum - taste) else sum - taste endif ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int minSum(int arr[],int n){
    int sum=arr[0];
    for(int i=1 ; i<n ; i++){
      if(arr[i]==arr[i-1]){
        int j=i ;
        while(j<n && arr[j]<=arr[j-1]){
          arr[j]=arr[j]+1 ;
          j++;
        }
      }
      sum=sum+arr[i];
    }
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      2,2,3,5,6 };
      int n=arr.length ;
      System.out.println(minSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] = arr[i - 1+1]) then (     var j : int ; j := i ;
     while (j < n & arr[j+1] <= arr[j - 1+1]) do (     arr[j+1] := arr[j+1] + 1 ; 
     j := j + 1 ) ) else skip ; 
     sum := sum + arr[i+1] )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,2,3,5,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test144 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int a=in.nextInt();
      int b=in.nextInt();
      int n=in.nextInt();
      int sum=1 ;
      while(a % 2==0){
        sum+=sum ;
        a/=2 ;
        if(sum==n){
          break ;
        }
      }
      while(b % 2==0){
        sum+=sum ;
        b/=2 ;
        if(sum==n){
          break ;
        }
      }
      if(sum>=n){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test144 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var sum : int ; sum := 1 ;
    while (a mod 2 = 0) do (     sum := sum+(sum) ; 
     a := a/(2) ; 
     if (sum = n) then (     break ) else skip ) ; 
    while (b mod 2 = 0) do (     sum := sum+(sum) ; 
     b := b/(2) ; 
     if (sum = n) then (     break ) else skip ) ; 
    if (sum >= n) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void findTriplets(int arr[],int n,int sum){
    for(int i=0 ; i<n-2 ; i++){
      for(int j=i+1 ; j<n-1 ; j++){
        for(int k=j+1 ; k<n ; k++){
          if(arr[i]+arr[j]+arr[k]==sum){
            System.out.println(arr[i]+" "+arr[j]+" "+arr[k]);
          }
        }
      }
    }
  }
  public static void main(String[] args){
    int arr[]={
      0,-1,2,-3,1 };
      int n=arr.length ;
      findTriplets(arr,n,-2);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findTriplets( arr : Sequence(int), n : int, sum : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n - 2 do ( (         var j : int ; j := i + 1 ; while j < n - 1 do ( (         var k : int ; k := j + 1 ; while k < n do ( (     if (arr[i+1] + arr[j+1] + arr[k+1] = sum) then (     OclFile["System.out"].println(arr[i+1] + " " + arr[j+1] + " " + arr[k+1]) ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,-1,2,-3,1} ;
     var n : int ; n := arr->size() ;
     execute findTriplets(arr, n, -2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public final class Codechef {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int numTestcases=scanner.nextInt();
    for(int test=1 ; test<=numTestcases ; test++){
      int roomWidth=scanner.nextInt();
      int roomHeight=scanner.nextInt();
      int x1=scanner.nextInt();
      int y1=scanner.nextInt();
      int x2=scanner.nextInt();
      int y2=scanner.nextInt();
      int rectWidth=scanner.nextInt();
      int rectHeight=scanner.nextInt();
      System.out.println(findMin(roomWidth,roomHeight,x1,y1,x2,y2,rectWidth,rectHeight));
    }
  }
  private static double findMin(int roomWidth,int roomHeight,int x1,int y1,int x2,int y2,int rectWidth,int rectHeight){
    int remainingHeightAtTheTop=roomHeight-y2 ;
    int topMoveDistance=Integer.MAX_VALUE ;
    int bottomMoveDistance=Integer.MAX_VALUE ;
    int leftMoveDistance=Integer.MAX_VALUE ;
    int rightMoveDistance=Integer.MAX_VALUE ;
    if(rectHeight<=remainingHeightAtTheTop){
      return(double)0 ;
    }
    else {
      if(rectHeight+(y2-y1)<=roomHeight)topMoveDistance=rectHeight-remainingHeightAtTheTop ;
    }
    int remainingHeightAtTheBottom=y1 ;
    if(rectHeight<=remainingHeightAtTheBottom){
      return(double)0 ;
    }
    else {
      if(rectHeight+(y2-y1)<=roomHeight)bottomMoveDistance=rectHeight-remainingHeightAtTheBottom ;
    }
    int remainingWidthInTheLeft=x1 ;
    if(rectWidth<=remainingWidthInTheLeft){
      return(double)0 ;
    }
    else {
      if(rectWidth+(x2-x1)<=roomWidth)leftMoveDistance=rectWidth-remainingWidthInTheLeft ;
    }
    int remainingWidthInTheRight=roomWidth-x2 ;
    if(rectWidth<=remainingWidthInTheRight){
      return(double)0 ;
    }
    else {
      if(rectWidth+(x2-x1)<=roomWidth)rightMoveDistance=rectWidth-remainingWidthInTheRight ;
    }
    int minValue=Math.min(topMoveDistance,Math.min(bottomMoveDistance,Math.min(leftMoveDistance,rightMoveDistance)));
    return minValue==Integer.MAX_VALUE ?-1 :(double)minValue ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numTestcases : int ; numTestcases := scanner.getCurrent()->toInteger() ;
         var test : int ; test := 1 ; while test <= numTestcases do ( (     var roomWidth : int ; roomWidth := scanner.getCurrent()->toInteger() ;
     var roomHeight : int ; roomHeight := scanner.getCurrent()->toInteger() ;
    var x1 : int ; x1 := scanner.getCurrent()->toInteger() ;
    var y1 : int ; y1 := scanner.getCurrent()->toInteger() ;
    var x2 : int ; x2 := scanner.getCurrent()->toInteger() ;
    var y2 : int ; y2 := scanner.getCurrent()->toInteger() ;
    var rectWidth : int ; rectWidth := scanner.getCurrent()->toInteger() ;
    var rectHeight : int ; rectHeight := scanner.getCurrent()->toInteger() ;
    OclFile["System.out"].println(findMin(roomWidth, roomHeight, x1, y1, x2, y2, rectWidth, rectHeight)) ; 
 )  ;     test := test + 1 ) );
  static   operation findMin( roomWidth : int, roomHeight : int, x1 : int, y1 : int, x2 : int, y2 : int, rectWidth : int, rectHeight : int) : double
  pre: true
  post: true
  activity: (     var remainingHeightAtTheTop : int ; remainingHeightAtTheTop := roomHeight - y2 ;
     var topMoveDistance : int ; topMoveDistance := 2147483647 ;
    var bottomMoveDistance : int ; bottomMoveDistance := 2147483647 ;
    var leftMoveDistance : int ; leftMoveDistance := 2147483647 ;
    var rightMoveDistance : int ; rightMoveDistance := 2147483647 ;
    if (rectHeight <= remainingHeightAtTheTop) then (     return 0->oclAsType(double) ) else (     if (rectHeight + (y2 - y1) <= roomHeight) then     topMoveDistance := rectHeight - remainingHeightAtTheTop ; else skip ) ;  
    var remainingHeightAtTheBottom : int ; remainingHeightAtTheBottom := y1 ;
    if (rectHeight <= remainingHeightAtTheBottom) then (     return 0->oclAsType(double) ) else (     if (rectHeight + (y2 - y1) <= roomHeight) then     bottomMoveDistance := rectHeight - remainingHeightAtTheBottom ; else skip ) ;  
    var remainingWidthInTheLeft : int ; remainingWidthInTheLeft := x1 ;
    if (rectWidth <= remainingWidthInTheLeft) then (     return 0->oclAsType(double) ) else (     if (rectWidth + (x2 - x1) <= roomWidth) then     leftMoveDistance := rectWidth - remainingWidthInTheLeft ; else skip ) ;  
    var remainingWidthInTheRight : int ; remainingWidthInTheRight := roomWidth - x2 ;
    if (rectWidth <= remainingWidthInTheRight) then (     return 0->oclAsType(double) ) else (     if (rectWidth + (x2 - x1) <= roomWidth) then     rightMoveDistance := rectWidth - remainingWidthInTheRight ; else skip ) ;  
    var minValue : int ; minValue := Set{topMoveDistance, Set{bottomMoveDistance, Set{leftMoveDistance, rightMoveDistance}->min()}->min()}->min() ;
    return if minValue = 2147483647 then -1 else minValue->oclAsType(double) endif 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Double.min ;
import static java.lang.Double.max ;
public class ProblemSolving {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    int t=scanner.nextInt();
    while(t-->0){
      solve();
    }
  }
  public static void solve(){
    int W=scanner.nextInt(),H=scanner.nextInt();
    int x1=scanner.nextInt(),y1=scanner.nextInt(),x2=scanner.nextInt(),y2=scanner.nextInt();
    int w=scanner.nextInt(),h=scanner.nextInt();
    if(h+y2-y1>H && w+x2-x1>W){
      System.out.println(-1);
      return ;
    }
    double ans=1e9 ;
    if(h+y2-y1<=H){
      ans=min(ans,h-(H-y2));
      ans=min(ans,h-y1);
    }
    if(w+x2-x1<=W){
      ans=min(ans,w-(W-x2));
      ans=min(ans,w-x1);
    }
    ans=max(ans,0.0);
    System.out.printf("%.9f",ans);
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemSolving {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var W : int ; W := scanner.getCurrent()->toInteger() ;
    var H : int ; H := scanner.getCurrent()->toInteger() ;
     var x1 : int ; x1 := scanner.getCurrent()->toInteger() ;
    var y1 : int ; y1 := scanner.getCurrent()->toInteger() ;
    var x2 : int ; x2 := scanner.getCurrent()->toInteger() ;
    var y2 : int ; y2 := scanner.getCurrent()->toInteger() ;
    var w : int ; w := scanner.getCurrent()->toInteger() ;
    var h : int ; h := scanner.getCurrent()->toInteger() ;
    if (h + y2 - y1 > H & w + x2 - x1 > W) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var ans : double ; ans := 1e9 ;
    if (h + y2 - y1 <= H) then (     ans := Set{ans, h - (H - y2)}->min() ; 
     ans := Set{ans, h - y1}->min() ) else skip ; 
    if (w + x2 - x1 <= W) then (     ans := Set{ans, w - (W - x2)}->min() ; 
     ans := Set{ans, w - x1}->min() ) else skip ; 
    ans := Set{ans, 0.0}->max() ; 
    OclFile["System.out"].printf("%.9f", ans) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  MyScanner sc=new MyScanner();
  void run(){
    int H=sc.nextInt();
    int W=sc.nextInt();
    int[][] dp=new int[H][W];
    int max=0 ;
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        int c=sc.nextInt();
        dp[i][j]=(c==0)? 1 : 0 ;
        max=Math.max(max,dp[i][j]);
      }
    }
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        if(i==0 || j==0 || dp[i][j]==0)continue ;
        dp[i][j]=Math.min(dp[i-1][j],Math.min(dp[i][j-1],dp[i-1][j-1]))+1 ;
        max=Math.max(max,dp[i][j]);
      }
    }
    System.out.println(max*max);
  }
  public static void main(String[] args){
    new Main().run();
  }
  class MyScanner {
    int nextInt(){
      try {
        int c=System.in.read();
        while(c!='-' &&(c<'0' || '9'<c))c=System.in.read();
        if(c=='-')return-nextInt();
        int res=0 ;
        do {
          res*=10 ;
          res+=c-'0' ;
          c=System.in.read();
        }
        while('0'<=c && c<='9');
        return res ;
      }
      catch(Exception e){
        return-1 ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   attribute sc : MyScanner := MyScanner.newMyScanner();
   operation run() : void
  pre: true
  post: true
  activity: (     var H : int ; H := sc.nextInt() ;
     var W : int ; W := sc.nextInt() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     var c : int ; c := sc.nextInt() ;
     dp[i+1][j+1] := if (c = 0) then 1 else 0 endif ; 
     max := Set{max, dp[i+1][j+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (i = 0 or j = 0 or dp[i+1][j+1] = 0) then     continue else skip ; 
     dp[i+1][j+1] := Set{dp[i - 1+1][j+1], Set{dp[i+1][j - 1+1], dp[i - 1+1][j - 1+1]}->min()}->min() + 1 ; 
     max := Set{max, dp[i+1][j+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max * max) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
 class MyScanner {
   operation nextInt() : int
  pre: true
  post: true
  activity: (     try (     var c : int ; c := OclFile["System.in"].read() ;
     while (c /= '-' & (c < '0' or '9' < c)) do     c := OclFile["System.in"].read() ; ; 
    if (c = '-') then     return -nextInt() else skip ; 
    var res : int ; res := 0 ;
  while true do ((     res := res*(10) ; 
     res := res+(c - ('0')->char2byte()) ; 
     c := OclFile["System.in"].read() ) ;
    if ('0' <= c & c <= '9') then skip else break) ; 
    return res 
 )   catch (e : ProgramException) do (     return -1 )
 );
}
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int h=scan.nextInt();
    int w=scan.nextInt();
    scan.nextLine();
    int[][] arr=new int[h][w];
    for(int i=0 ; i<h ; i++){
      String[] line=scan.nextLine().split(" ");
      for(int j=0 ; j<w ; j++){
        arr[i][j]=Integer.parseInt(line[j]);
      }
    }
    int[][] ansArr=new int[h][w];
    int ans=0 ;
    for(int i=0 ; i<h ; i++)ansArr[i][0]=(arr[i][0]==0)? 1 : 0 ;
    for(int i=0 ; i<w ; i++)ansArr[0][i]=(arr[0][i]==0)? 1 : 0 ;
    for(int i=1 ; i<h ; i++){
      for(int j=1 ; j<w ; j++){
        ansArr[i][j]=(arr[i][j]==0)? Math.min(Math.min(ansArr[i-1][j],ansArr[i][j-1]),ansArr[i-1][j-1])+1 : 0 ;
      }
    }
    for(int[] _arr : ansArr)for(int num : _arr)ans=Math.max(ans,num);
    System.out.println(ans*ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := scan.getCurrent()->toInteger() ;
    var w : int ; w := scan.getCurrent()->toInteger() ;
    skip ; 
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (     var line : Sequence(String) ; line := scan.nextLine()->split(" ") ;
         var j : int ; j := 0 ; while j < w do ( (     arr[i+1][j+1] := (line[j+1])->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ansArr : Sequence(Sequence(int)) ; ansArr := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < h do (     ansArr[i+1][0+1] := if (arr[i+1][0+1] = 0) then 1 else 0 endif ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < w do (     ansArr[0+1][i+1] := if (arr[0+1][i+1] = 0) then 1 else 0 endif ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < h do ( (         var j : int ; j := 1 ; while j < w do ( (     ansArr[i+1][j+1] := if (arr[i+1][j+1] = 0) then Set{Set{ansArr[i - 1+1][j+1], ansArr[i+1][j - 1+1]}->min(), ansArr[i - 1+1][j - 1+1]}->min() + 1 else 0 endif )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    for (_arr : ansArr) do (     for (num : _arr) do (     ans := Set{ans, num}->max() ;  ) ;  ) ; 
    OclFile["System.out"].println(ans * ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    line=br.readLine();
    int H,W ;
    H=parseInt(line.substring(0,line.indexOf(' ')));
    W=parseInt(line.substring(line.indexOf(' ')+1));
    int[][] dp=new int[H+1][W+1];
    for(int i=1 ; i<=H ; i++){
      StringTokenizer st=new StringTokenizer(br.readLine());
      for(int j=1 ; j<=W ; j++){
        dp[i][j]=parseInt(st.nextToken())==1 ? 0 : 1 ;
      }
    }
    int max=0 ;
    for(int i=1 ; i<=H ; i++){
      for(int j=1 ; j<=W ; j++){
        if(dp[i][j]==1){
          dp[i][j]=Math.min(dp[i-1][j-1],Math.min(dp[i-1][j],dp[i][j-1]))+1 ;
          max=Math.max(max,dp[i][j]);
        }
      }
    }
    System.out.println(max*max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    line := br.readLine() ; 
    var H : int ;
    var W : int ;
    H := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    W := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,H + 1)->collect(Integer.subrange(1,W + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= H do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
         var j : int ; j := 1 ; while j <= W do ( (     dp[i+1][j+1] := if (st.next() + "")->toInteger() = 1 then 0 else 1 endif )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i <= H do ( (         var j : int ; j := 1 ; while j <= W do ( (     if (dp[i+1][j+1] = 1) then (     dp[i+1][j+1] := Set{dp[i - 1+1][j - 1+1], Set{dp[i - 1+1][j+1], dp[i+1][j - 1+1]}->min()}->min() + 1 ; 
     max := Set{max, dp[i+1][j+1]}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max * max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    Scanner sc=new Scanner(systemin);
    result.printf("%d\n",sc.nextInt()+sc.nextInt()+sc.nextInt()+sc.nextInt());
    sc.close();
    return false ;
  }
  PrintStream log ;
  PrintStream result=System.out ;
  BufferedReader systemin ;
  static Main instance=new Main();
  Main(){
    systemin=new BufferedReader(new InputStreamReader(System.in));
    log=new PrintStream(new OutputStream(){
      public void write(int b){
      }
    }
);
  }
  public static void main(String[] args)throws IOException {
    instance.main();
    instance.systemin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(systemin) ;
     result.printf("%d\n", sc.getCurrent()->toInteger() + sc.getCurrent()->toInteger() + sc.getCurrent()->toInteger() + sc.getCurrent()->toInteger()) ; 
     skip ; 
     return false );
   attribute log : OclFile;
   attribute result : OclFile := OclFile["System.out"];
   attribute systemin : OclFile;
  static   attribute instance : Main := Main.newMain();
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     systemin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     log := OclFile.newOclFile_Write(OclFile()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     instance.main() ; 
     instance.systemin.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int H=in.nextInt(),W=in.nextInt();
    int field[][]=new int[H][W];
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        field[i][j]=Integer.parseInt(in.next())==1 ? 0 : 1 ;
      }
    }
    int max=0 ;
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        if(field[i][j]>=1 && isBS(field,i,j)){
          field[i][j]=Math.min(field[i-1][j],Math.min(field[i][j-1],field[i-1][j-1]))+1 ;
        }
        max=Math.max(max,field[i][j]);
      }
    }
    System.out.println(max*max);
  }
  static boolean isBS(int A[][],int y,int x){
    if(y-1<0 || x-1<0)return false ;
    if(A[y-1][x]>=1 && A[y][x-1]>=1 && A[y-1][x-1]>=1){
      return true ;
    }
    else return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := in.getCurrent()->toInteger() ;
    var W : int ; W := in.getCurrent()->toInteger() ;
    var field : Sequence(Sequence(int)) ; field := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     field[i+1][j+1] := if (in.getCurrent())->toInteger() = 1 then 0 else 1 endif )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (field[i+1][j+1] >= 1 & isBS(field, i, j)) then (     field[i+1][j+1] := Set{field[i - 1+1][j+1], Set{field[i+1][j - 1+1], field[i - 1+1][j - 1+1]}->min()}->min() + 1 ) else skip ; 
     max := Set{max, field[i+1][j+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max * max) ; 
 );
  static   operation isBS( A : Sequence(Sequence(int)), y : int, x : int) : boolean
  pre: true
  post: true
  activity: (     if (y - 1 < 0 or x - 1 < 0) then     return false else skip ; 
     if (A[y - 1+1][x+1] >= 1 & A[y+1][x - 1+1] >= 1 & A[y - 1+1][x - 1+1] >= 1) then (     return true ) else     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int[][] dp=new int[h][w];
    int[][] map=new int[h][w];
    int max=0 ;
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        map[i][j]=sc.nextInt();
        if(map[i][j]==1){
          dp[i][j]=0 ;
        }
        else {
          dp[i][j]=1 ;
          max |=dp[i][j];
        }
      }
    }
    for(int i=1 ; i<h ; i++){
      for(int j=1 ; j<w ; j++){
        if(map[i][j]==1){
          dp[i][j]=0 ;
        }
        else {
          dp[i][j]=min(dp[i-1][j],min(dp[i-1][j-1],dp[i][j-1]))+1 ;
          max=max(max,dp[i][j]);
        }
      }
    }
    out.println(max*max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     map[i+1][j+1] := sc.getCurrent()->toInteger() ; 
     if (map[i+1][j+1] = 1) then (     dp[i+1][j+1] := 0 ) else (     dp[i+1][j+1] := 1 ; 
     max := MathLib.bitwiseOr(max, dp[i+1][j+1]) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < h do ( (         var j : int ; j := 1 ; while j < w do ( (     if (map[i+1][j+1] = 1) then (     dp[i+1][j+1] := 0 ) else (     dp[i+1][j+1] := Set{dp[i - 1+1][j+1], Set{dp[i - 1+1][j - 1+1], dp[i+1][j - 1+1]}->min()}->min() + 1 ; 
     max := Set{max, dp[i+1][j+1]}->max() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    out.println(max * max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int[] pref=new int[100010];
  static int isPerfectSquare(int x){
    double sr=Math.sqrt(x);
    return((sr-Math.floor(sr))==0)? x : 0 ;
  }
  static void compute(){
    for(int i=1 ; i<=100000 ; ++i){
      pref[i]=pref[i-1]+isPerfectSquare(i);
    }
  }
  static void printSum(int L,int R){
    int sum=pref[R]-pref[L-1];
    System.out.print(sum+" ");
  }
  public static void main(String[] args){
    compute();
    int Q=4 ;
    int arr[][]={
      {
        1,10 },{
          1,100 },{
            2,25 },{
              4,50 }
            };
            for(int i=0 ; i<Q ; i++){
              printSum(arr[i][0],arr[i][1]);
            }
          }
        }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute pref : Sequence(int) := Integer.subrange(1,100010)->collect(0);
  static   operation isPerfectSquare( x : int) : int
  pre: true
  post: true
  activity: (     var sr : double ; sr := (x)->sqrt() ;
     return if ((sr - (sr)->floor()) = 0) then x else 0 endif );
  static   operation compute() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= 100000 do ( (     pref[i+1] := pref[i - 1+1] + isPerfectSquare(i) )  ;     i := i + 1 ) );
  static   operation printSum( L : int, R : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := pref[R+1] - pref[L - 1+1] ;
     OclFile["System.out"].print(sum + " ") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute compute() ; 
     var Q : int ; Q := 4 ;
     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,10},Sequence{1,100},Sequence{2,25},Sequence{4,50}} ;
         var i : int ; i := 0 ; while i < Q do ( (     execute printSum(arr[i+1][0+1], arr[i+1][1+1]) )  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1472A_CardsforFriends {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int w=input.nextInt();
      int h=input.nextInt();
      int n=input.nextInt();
      int width=1 ;
      int height=1 ;
      for(int i=0 ; w % 2==0 ; i++){
        w/=2 ;
        width+=Math.pow(2,i);
      }
      for(int i=0 ; h % 2==0 ; i++){
        h/=2 ;
        height+=(int)Math.pow(2,i);
      }
      if(width*height>=n){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1472A_CardsforFriends {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var w : int ; w := input.getCurrent()->toInteger() ;
     var h : int ; h := input.getCurrent()->toInteger() ;
    var n : int ; n := input.getCurrent()->toInteger() ;
    var width : int ; width := 1 ;
    var height : int ; height := 1 ;
        var i : int ; i := 0 ; while w mod 2 = 0 do ( (     w := w/(2) ; 
     width := width+(2->pow(i)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while h mod 2 = 0 do ( (     h := h/(2) ; 
     height := height+(2->pow(i)->oclAsType(int)) )  ;     i := i + 1 ) ; 
    if (width * height >= n) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public void run(){
    while(sc.hasNext()){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int a=sc.nextInt();
      if(n==0 && m==0 && a==0)break ;
      calc(n,m,a);
    }
  }
  public void calc(int n,int m,int a){
    int[][] amida=new int[1001][n+1];
    int height=0 ;
    for(int i=0 ; i<m ; i++){
      int h=sc.nextInt();
      int p=sc.nextInt();
      int q=sc.nextInt();
      amida[h][p]=q ;
      amida[h][q]=p ;
      if(height<h)height=h ;
    }
    for(int i=height ; i>0 ; i--){
      if(amida[i][a]!=0)a=amida[i][a];
    }
    System.out.println(a);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    if (n = 0 & m = 0 & a = 0) then     break else skip ; 
    execute calc(n, m, a) ; 
 ) );
   operation calc( n : int, m : int, a : int) : void
  pre: true
  post: true
  activity: (     var amida : Sequence(Sequence(int)) ; amida := Integer.subrange(1,1001)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
     var height : int ; height := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var h : int ; h := sc.getCurrent()->toInteger() ;
     var p : int ; p := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    amida[h+1][p+1] := q ; 
    amida[h+1][q+1] := p ; 
    if (height < h) then     height := h ; else skip ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := height ; while i > 0 do ( (     if (amida[i+1][a+1] /= 0) then     a := amida[i+1][a+1] ; else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(a) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static class pair {
    int x ;
    char symbol ;
    pair(int x,char symbol){
      this.x=x ;
      this.symbol=symbol ;
    }
  }
  @ SuppressWarnings("unchecked")public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt(),m=sc.nextInt(),a=sc.nextInt();
      ArrayList<ArrayList<pair>>al=new ArrayList<ArrayList<pair>>();
      pair ini=new pair(-1,'+');
      ArrayList<pair>li_ini=new ArrayList<pair>();
      li_ini.add(ini);
      for(int i=0 ; i<n ; i++)al.add(li_ini);
      if((n | m | a)==0)break ;
      for(int i=0 ; i<m ; i++){
        int h=sc.nextInt(),p=sc.nextInt(),q=sc.nextInt();
        pair pa=new pair(h,'+');
        ArrayList<pair>li_pa=(ArrayList<pair>)al.get(p-1).clone();
        li_pa.add(pa);
        pair pa2=new pair(h,'-');
        ArrayList<pair>li_pa2=(ArrayList<pair>)al.get(q-1).clone();
        li_pa2.add(pa2);
        al.set(p-1,li_pa);
        al.set(q-1,li_pa2);
      }
      int height=1001 ;
      int wh=a ;
      while(true){
        ArrayList<pair>check=al.get(wh-1);
        pair target=null ;
        int max=0 ;
        for(pair check_pair : check){
          int temp=check_pair.x ;
          if(temp<height && temp>max){
            max=temp ;
            target=check_pair ;
          }
        }
        height=max ;
        if(target==null)break ;
        if(target.symbol=='+'){
          wh++;
        }
        else {
          wh--;
        }
      }
      System.out.println(wh);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class pair {
   attribute x : int;
   attribute symbol : String;
   static operation newpair( x : int, symbol : String) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(x, symbol);
    return self );
  operation initialise( x : int, symbol : String) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.symbol := symbol );
}
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
     var al : Sequence(Sequence(pair)) ; al := Sequence{} ;
    var ini : pair ; ini := pair.newpair(-1, '+') ;
    var li_ini : Sequence(pair) ; li_ini := Sequence{} ;
    li_ini := li_ini->including(ini) ; 
        var i : int ; i := 0 ; while i < n do (     al := al->including(li_ini) ;  ;     i := i + 1 ) ; 
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(n,m),a)) = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < m do ( (     var h : int ; h := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
     var pa : pair ; pa := pair.newpair(h, '+') ;
    var li_pa : Sequence(pair) ; li_pa := al->at(p - 1+1)->copy()->oclAsType(Sequence(pair)) ;
    li_pa := li_pa->including(pa) ; 
    var pa2 : pair ; pa2 := pair.newpair(h, '-') ;
    var li_pa2 : Sequence(pair) ; li_pa2 := al->at(q - 1+1)->copy()->oclAsType(Sequence(pair)) ;
    li_pa2 := li_pa2->including(pa2) ; 
    al := al.setAt(p - 1+1,li_pa) ; 
    al := al.setAt(q - 1+1,li_pa2) ; 
 )  ;     i := i + 1 ) ; 
    var height : int ; height := 1001 ;
    var wh : int ; wh := a ;
    while (true) do (     var check : Sequence(pair) ; check := al->at(wh - 1+1) ;
     var target : pair ; target := null ;
    var max : int ; max := 0 ;
    for (check_pair : check) do ( (     var temp : int ; temp := check_pair.x ;
     if (temp < height & temp > max) then (     max := temp ; 
     target := check_pair ) else skip )  ) ; 
    height := max ; 
    if (target = null) then     break else skip ; 
    if (target.symbol = '+') then (     wh := wh + 1 ) else (     wh := wh - 1 ) ;  
 ) ; 
    OclFile["System.out"].println(wh) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.security.acl.Group ;
import java.util.*;
public class Main {
  static class Bar implements Comparable<Bar>{
    int h ;
    int p ;
    int q ;
    public Bar(int h,int p,int q){
      this.h=h ;
      this.p=p ;
      this.q=q ;
    }
    @ Override public int compareTo(Bar o){
      return o.h-h ;
    }
  }
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    for(int loop=0 ; ; loop++){
      List<Bar>list=new ArrayList<Bar>();
      String s=reader.readLine();
      String[] sp=s.split(" ");
      int N=Integer.parseInt(sp[0]);
      int M=Integer.parseInt(sp[1]);
      int A=Integer.parseInt(sp[2]);
      if(N==0)break ;
      for(int i=0 ; i<M ; i++){
        s=reader.readLine();
        sp=s.split(" ");
        int h=Integer.parseInt(sp[0]);
        int p=Integer.parseInt(sp[1]);
        int q=Integer.parseInt(sp[2]);
        Bar bar=new Bar(h,p,q);
        list.add(bar);
      }
      Collections.sort(list);
      int pos=A ;
      for(int i=0 ; i<list.size(); i++){
        Bar bar=list.get(i);
        if(pos==bar.p){
          pos=bar.q ;
        }
        else if(pos==bar.q){
          pos=bar.p ;
        }
      }
      System.out.printf("%d\n",pos);
    }
    reader.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Bar implements Comparable<Bar> {
   attribute h : int;
   attribute p : int;
   attribute q : int;
   static operation newBar( h : int, p : int, q : int) : Bar
  pre: true
  post: true
  activity:
  ( var self : Bar ;
    self := createBar();
    self.initialise(h, p,q);
    return self );
  operation initialise( h : int, p : int, q : int) : void
  pre: true  post: true
  activity: (     self.h := h ; 
     self.p := p ; 
     self.q := q );
      operation compareTo( o : Bar) : int
  pre: true
  post: true
  activity: (     return o.h - h );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
         var loop : int ; loop := 0 ; while true do ( (     var list : Sequence(Bar) ; list := Sequence{} ;
     var s : String ; s := reader.readLine() ;
    var sp : Sequence(String) ; sp := s->split(" ") ;
    var N : int ; N := (sp[0+1])->toInteger() ;
    var M : int ; M := (sp[1+1])->toInteger() ;
    var A : int ; A := (sp[2+1])->toInteger() ;
    if (N = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < M do ( (     s := reader.readLine() ; 
     sp := s->split(" ") ; 
    var h : int ; h := (sp[0+1])->toInteger() ;
    var p : int ; p := (sp[1+1])->toInteger() ;
    var q : int ; q := (sp[2+1])->toInteger() ;
    var bar : Bar ; bar := Bar.newBar(h, p, q) ;
    list := list->including(bar) ; 
 )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var pos : int ; pos := A ;
        var i : int ; i := 0 ; while i < list->size() do ( (     var bar : Bar ; bar := list->at(i+1) ;
     if (pos = bar.p) then (     pos := bar.q ) else     if (pos = bar.q) then (     pos := bar.p ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%d\n", pos) ; 
 )  ;     loop := loop + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static boolean isPrime(int n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static int SumOfPrimeDivisors(int n){
    int sum=0 ;
    for(int i=1 ; i<=n ; i++){
      if(n % i==0){
        if(isPrime(i))sum+=i ;
      }
    }
    return sum ;
  }
  public static void main(String args[]){
    int n=60 ;
    System.out.print("Sum of prime divisors of 60 is "+SumOfPrimeDivisors(n)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation SumOfPrimeDivisors( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     if (n mod i = 0) then (     if (isPrime(i)) then     sum := sum+(i) ; else skip ) else skip )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 60 ;
     OclFile["System.out"].print("Sum of prime divisors of 60 is " + SumOfPrimeDivisors(n) + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int INT_BITS=32 ;
  static int leftRotate(int n,int d){
    return(n<<d)|(n>>(INT_BITS-d));
  }
  static int rightRotate(int n,int d){
    return(n>>d)|(n<<(INT_BITS-d));
  }
  public static void main(String arg[]){
    int n=16 ;
    int d=2 ;
    System.out.print("Left Rotation of "+n+" by "+d+" is ");
    System.out.print(leftRotate(n,d));
    System.out.print("\nRight Rotation of "+n+" by "+d+" is ");
    System.out.print(rightRotate(n,d));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute INT_BITS : int := 32;
  static   operation leftRotate( n : int, d : int) : int
  pre: true
  post: true
  activity: (     return ((n*(2->pow(d)))->oclAsType(long)) or ((n/(2->pow((INT_BITS - d))))->oclAsType(long)) );
  static   operation rightRotate( n : int, d : int) : int
  pre: true
  post: true
  activity: (     return ((n/(2->pow(d)))->oclAsType(long)) or ((n*(2->pow((INT_BITS - d))))->oclAsType(long)) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 16 ;
     var d : int ; d := 2 ;
    OclFile["System.out"].print("Left Rotation of " + n + " by " + d + " is ") ; 
    OclFile["System.out"].print(leftRotate(n, d)) ; 
    OclFile["System.out"].print("\nRight Rotation of " + n + " by " + d + " is ") ; 
    OclFile["System.out"].print(rightRotate(n, d)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    FastScanner sc=new FastScanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int ans=0 ;
    for(int i=0 ; i<4 ; i++){
      int input=sc.nextInt();
      ans+=input ;
    }
    out.println(ans);
    out.flush();
  }
  static class FastScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public FastScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
      tokenizer=null ;
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          return reader.readLine();
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken("\n");
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     var input : int ; input := sc.nextInt() ;
     ans := ans+(input) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.nextToken("\n") );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class App {
  static ArrayList<Long>luck=new ArrayList<>();
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char[] arr=in.next().toCharArray();
    long digitSlot=arr.length ;
    long ans=0 ;
    ans=(1<<digitSlot)-2 ;
    for(long i=digitSlot-1,count=0 ; i>=0 ; i--,count++){
      if(arr[(int)i]=='7'){
        ans+=(1<<count);
      }
    }
    System.out.println(ans+1);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   attribute luck : Sequence(long) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(String) ; arr := in.getCurrent()->characters() ;
    var digitSlot : long ; digitSlot := arr->size() ;
    var ans : long ; ans := 0 ;
    ans := ((1*(2->pow(digitSlot)))->oclAsType(long)) - 2 ; 
        var i : long ; i := digitSlot - 1 ;
    var count : long ; count := 0 ; while i >= 0 do ( (     if (arr[i->oclAsType(int)+1] = '7') then (     ans := ans+(((1*(2->pow(count)))->oclAsType(long))) ) else skip )  ;     i := i - 1 ;     count := count + 1 ) ; 
    OclFile["System.out"].println(ans + 1) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.text.DateFormat ;
import java.text.ParseException ;
import java.text.SimpleDateFormat ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      String a=in.next();
      int n=a.length();
      int s=0 ;
      int qq=1 ;
      for(int i=1 ; i<n ; i++){
        qq*=2 ;
        s=s+qq ;
      }
      String q="" ;
      for(int i=0 ; i<n ; i++){
        char c=a.charAt(i);
        if(c=='4')q=q+"0" ;
        else q=q+"1" ;
      }
      int w=Integer.parseInt(q,2);
      System.out.println(s+w+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var a : String ; a := in.getCurrent() ;
     var n : int ; n := a->size() ;
    var s : int ; s := 0 ;
    var qq : int ; qq := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     qq := qq*(2) ; 
     s := s + qq )  ;     i := i + 1 ) ; 
    var q : String ; q := "" ;
        var i : int ; i := 0 ; while i < n do ( (     var c : String ; c := a->at(i+1) ;
     if (c = '4') then     q := q + "0" ; else     q := q + "1" ; )  ;     i := i + 1 ) ; 
    var w : int ; w := (q)->toInteger() ;
    OclFile["System.out"].println(s + w + 1) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findPoint(int x1,int y1,int x2,int y2){
    System.out.println("("+(int)(2*x2-x1)+","+(int)(2*y2-y1)+")");
  }
  public static void main(String args[]){
    int x1=0,y1=0,x2=1,y2=1 ;
    findPoint(x1,y1,x2,y2);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findPoint( x1 : int, y1 : int, x2 : int, y2 : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("(" + (2 * x2 - x1)->oclAsType(int) + "," + (2 * y2 - y1)->oclAsType(int) + ")") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x1 : int ; x1 := 0 ;
    var y1 : int ; y1 := 0 ;
    var x2 : int ; x2 := 1 ;
    var y2 : int ; y2 := 1 ;
     execute findPoint(x1, y1, x2, y2) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF535B {
  public static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int res=0 ;
    int bitIndex=0 ;
    while(n!=0){
      int digit=n % 10 ;
      if(digit==4)res+=1<<bitIndex ;
      else res+=2*(1<<bitIndex);
      n/=10 ;
      bitIndex++;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF535B {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
    var bitIndex : int ; bitIndex := 0 ;
    while (n /= 0) do (     var digit : int ; digit := n mod 10 ;
     if (digit = 4) then     res := res+((1*(2->pow(bitIndex)))->oclAsType(long)) else     res := res+(2 * ((1*(2->pow(bitIndex)))->oclAsType(long))) ; ;  
     n := n/(10) ; 
     bitIndex := bitIndex + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void triangle(int n){
    int k=2*n-2 ;
    int ch=1 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<k ; j++)System.out.print(" ");
      k=k-1 ;
      for(int j=0 ; j<=i ; j++){
        System.out.print(ch+++" ");
      }
      System.out.println();
    }
  }
  static int maxHeight(int n){
    return(((int)Math.sqrt(1+8.0*n))-1)/2 ;
  }
  public static void main(String[] args){
    int N=9 ;
    triangle(maxHeight(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation triangle( n : int) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 2 * n - 2 ;
     var ch : int ; ch := 1 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < k do (     OclFile["System.out"].print(" ") ;  ;     j := j + 1 ) ; 
     k := k - 1 ; 
         var j : int ; j := 0 ; while j <= i do ( (     OclFile["System.out"].print(ch + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation maxHeight( n : int) : int
  pre: true
  post: true
  activity: (     return (((1 + 8.0 * n)->sqrt()->oclAsType(int)) - 1) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 9 ;
     execute triangle(maxHeight(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Hello {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int t=1 ; t<=test ; t++){
      String s1=in.next();
      String s2=in.next();
      String str1=s1 ;
      String str2=s2 ;
      while(str1.length()!=str2.length()){
        if(str1.length()<str2.length()){
          str1+=s1 ;
        }
        else {
          str2+=s2 ;
        }
      }
      if(str1.equals(str2)){
        pw.println(str1);
      }
      else {
        pw.println(-1);
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hello {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= test do ( (     var s1 : String ; s1 := in.getCurrent() ;
     var s2 : String ; s2 := in.getCurrent() ;
    var str1 : String ; str1 := s1 ;
    var str2 : String ; str2 := s2 ;
    while (str1->size() /= str2->size()) do (     if (str1->size() < str2->size()) then (     str1 := str1+(s1) ) else (     str2 := str2+(s2) ) ) ; 
    if (str1 = str2) then (     skip ) else (     skip ) ;  
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      String s1=sc.next();
      String s2=sc.next();
      int l1=s1.length();
      int l2=s2.length();
      int l=lcm(l1,l2);
      String lstr="" ;
      if(l1>l2){
        for(int i=1 ; i<=l/l2 ; i++){
          lstr=lstr+s2 ;
        }
        int flag=0,j=0,k=0 ;
        while(k<lstr.length()){
          if(j==l1)j=0 ;
          if(s1.charAt(j)!=lstr.charAt(k)){
            flag=1 ;
            break ;
          }
          else {
            j++;
            k++;
          }
        }
        if(flag==0)System.out.println(lstr);
        else System.out.println(-1);
      }
      else {
        for(int i=1 ; i<=l/l1 ; i++){
          lstr=lstr+s1 ;
        }
        int flag=0,j=0,k=0 ;
        while(k<lstr.length()){
          if(j==l2)j=0 ;
          if(s2.charAt(j)!=lstr.charAt(k)){
            flag=1 ;
            break ;
          }
          else {
            j++;
            k++;
            continue ;
          }
        }
        if(flag==0)System.out.println(lstr);
        else System.out.println(-1);
      }
    }
  }
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static int lcm(int a,int b){
    return(a/gcd(a,b))*b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s1 : String ; s1 := sc.getCurrent() ;
     var s2 : String ; s2 := sc.getCurrent() ;
    var l1 : int ; l1 := s1->size() ;
    var l2 : int ; l2 := s2->size() ;
    var l : int ; l := lcm(l1, l2) ;
    var lstr : String ; lstr := "" ;
    if (l1 > l2) then (         var i : int ; i := 1 ; while i <= l / l2 do ( (     lstr := lstr + s2 )  ;     i := i + 1 ) ; 
     var flag : int ; flag := 0 ;
    var j : int ; j := 0 ;
    var k : int ; k := 0 ;
     while (k < lstr->size()) do (     if (j = l1) then     j := 0 ; else skip ; 
     if (s1->at(j+1) /= lstr->at(k+1)) then (     flag := 1 ; 
     break ) else (     j := j + 1 ; 
     k := k + 1 ) ) ; 
     if (flag = 0) then     OclFile["System.out"].println(lstr) ; else     OclFile["System.out"].println(-1) ; ) else (         var i : int ; i := 1 ; while i <= l / l1 do ( (     lstr := lstr + s1 )  ;     i := i + 1 ) ; 
     var flag : int ; flag := 0 ;
    var j : int ; j := 0 ;
    var k : int ; k := 0 ;
     while (k < lstr->size()) do (     if (j = l2) then     j := 0 ; else skip ; 
     if (s2->at(j+1) /= lstr->at(k+1)) then (     flag := 1 ; 
     break ) else (     j := j + 1 ; 
     k := k + 1 ; 
     continue ) ) ; 
     if (flag = 0) then     OclFile["System.out"].println(lstr) ; else     OclFile["System.out"].println(-1) ; ) ;  
 ) ;  ) );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return (a / gcd(a, b)) * b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  static long pow(long a,long b){
    if(b==0){
      return 1 ;
    }
    long ans=0L ;
    if(b % 2==0){
      long val=pow(a,b/2);
      ans+=val*val ;
    }
    else {
      long val=pow(a,b/2);
      ans+=val*val*2 ;
    }
    return ans ;
  }
  static long gcd(int a,int b){
    if(b==0){
      return a ;
    }
    return gcd(b,a % b);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    sc.nextLine();
    while(t--!=0){
      String a=sc.nextLine();
      String b=sc.nextLine();
      int m=a.length(),n=b.length();
      if(m<n){
        String tmp=a ;
        a=b ;
        b=tmp ;
        int tt=m ;
        m=n ;
        n=tt ;
      }
      String ex=a ;
      int p=m ;
      while(m % n!=0){
        a+=ex ;
        m+=p ;
      }
      boolean flag=true ;
      for(int i=0 ; i<m ; i=i+n){
        if(! b.equals(a.substring(i,i+n))){
          flag=false ;
          break ;
        }
      }
      if(! flag){
        System.out.println(-1);
      }
      else {
        System.out.println(a);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation pow( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return 1 ) else skip ; 
     var ans : long ; ans := 0L ;
     if (b mod 2 = 0) then (     var val : long ; val := pow(a, b / 2) ;
     ans := ans+(val * val) ) else (     var val : long ; val := pow(a, b / 2) ;
     ans := ans+(val * val * 2) ) ;  
     return ans );
  static   operation gcd( a : int, b : int) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else skip ; 
     return gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     skip ; 
         while (t /= 0) do (    skip ; (     var a : String ; a := sc.nextLine() ;
     var b : String ; b := sc.nextLine() ;
    var m : int ; m := a->size() ;
    var n : int ; n := b->size() ;
    if (m < n) then (     var tmp : String ; tmp := a ;
     a := b ; 
    b := tmp ; 
    var tt : int ; tt := m ;
    m := n ; 
    n := tt ; 
 ) else skip ; 
    var ex : String ; ex := a ;
    var p : int ; p := m ;
    while (m mod n /= 0) do (     a := a+(ex) ; 
     m := m+(p) ) ; 
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < m do ( (     if (not(b = a.subrange(i+1,i + n))) then (     flag := false ; 
     break ) else skip )  ;     i := i + n ) ; 
    if (not(flag)) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(a) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args)throws IOException,InterruptedException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] p=new int[n];
    int min=Integer.MAX_VALUE ;
    int max=0 ;
    for(int i=0 ; i<n ; i++){
      p[i]=sc.nextInt();
      min=Math.min(p[i],min);
      max=Math.max(p[i],max);
    }
    if(max-min>k){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
      for(int i=0 ; i<n ; i++){
        int c=0 ;
        for(int j=0 ; j<p[i]; j++){
          System.out.print((c % k)+1+" ");
          c++;
        }
        System.out.println();
      }
    }
    sc.close();
    writer.flush();
    writer.close();
    reader.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    var min : int ; min := 2147483647 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := sc.getCurrent()->toInteger() ; 
     min := Set{p[i+1], min}->min() ; 
     max := Set{p[i+1], max}->max() )  ;     i := i + 1 ) ; 
    if (max - min > k) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ; 
         var i : int ; i := 0 ; while i < n do ( (     var c : int ; c := 0 ;
         var j : int ; j := 0 ; while j < p[i+1] do ( (     OclFile["System.out"].print((c mod k) + 1 + " ") ; 
     c := c + 1 )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ) ;  
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class LC {
  static class pair {
    int l,r ;
    public pair(int l,int r){
      this.l=l ;
      this.r=r ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int max=0,min=Integer.MAX_VALUE ;
    ArrayList<Integer>a=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      int temp=sc.nextInt();
      max=Math.max(max,temp);
      min=Math.min(min,temp);
      a.add(temp);
    }
    if(max-min-k<=0){
      System.out.println("YES");
      for(int i=0 ; i<n ; i++){
        int count=1 ;
        for(int j=0 ; j<a.get(i); j++){
          if(j<=min)System.out.print(1+" ");
          else {
            count++;
            System.out.print(count+" ");
          }
        }
        System.out.println();
      }
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class LC {
  static class pair {
   attribute l : int;
   static operation newpair( l : int, r : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(l, r);
    return self );
  operation initialise( l : int, r : int) : void
  pre: true  post: true
  activity: (     self.l := l ; 
     self.r := r );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var max : int ; max := 0 ;
    var min : int ; min := 2147483647 ;
    var a : Sequence(int) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : int ; temp := sc.getCurrent()->toInteger() ;
     max := Set{max, temp}->max() ; 
     min := Set{min, temp}->min() ; 
     a := a->including(temp) )  ;     i := i + 1 ) ; 
    if (max - min - k <= 0) then (     OclFile["System.out"].println("YES") ; 
         var i : int ; i := 0 ; while i < n do ( (     var count : int ; count := 1 ;
         var j : int ; j := 0 ; while j < a->at(i+1) do ( (     if (j <= min) then     OclFile["System.out"].print(1 + " ") ; else (     count := count + 1 ; 
     OclFile["System.out"].print(count + " ") ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws Exception {
    int result=0 ;
    try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in))){
      String[] numDog=reader.readLine().split(" ");
      for(int i=0 ; i<numDog.length ; i++){
        result+=Integer.parseInt(numDog[i]);
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     try (    var reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var numDog : Sequence(String) ; numDog := reader.readLine()->split(" ") ;
         var i : int ; i := 0 ; while i < numDog->size() do ( (     result := result+((numDog[i+1])->toInteger()) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(result) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeMap ;
import java.util.TreeSet ;
import javax.management.RuntimeErrorException ;
public class CodeforcesQuestions {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int k=s.nextInt();
    int arr[]=new int[n];
    int temp[]=new int[n];
    for(int i=0 ; i<n ; i++){
      int x=s.nextInt();
      arr[i]=x ;
      temp[i]=x ;
    }
    Arrays.sort(temp);
    int min=temp[0];
    if(k<temp[n-1]-temp[0]){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
      for(int i=0 ; i<n ; i++){
        int j ;
        for(j=1 ; j<=k && j<=arr[i]; j++){
          System.out.print(j+" ");
        }
        j=j-1 ;
        if(j==arr[i]){
          System.out.println();
          continue ;
        }
        int m=1 ;
        while(j!=arr[i]){
          System.out.print(m+" ");
          m++;
          j++;
          if(m>k)m=1 ;
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeforcesQuestions {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var k : int ; k := s.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var temp : Sequence(int) ; temp := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := s.getCurrent()->toInteger() ;
     arr[i+1] := x ; 
     temp[i+1] := x )  ;     i := i + 1 ) ; 
    temp := temp->sort() ; 
    var min : int ; min := temp[0+1] ;
    if (k < temp[n - 1+1] - temp[0+1]) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ; 
         var i : int ; i := 0 ; while i < n do ( (     var j : int ;
         j := 1 ; while j <= k & j <= arr[i+1] do ( (     OclFile["System.out"].print(j + " ") )  ;     j := j + 1 ) ; 
    j := j - 1 ; 
    if (j = arr[i+1]) then (     OclFile["System.out"].println() ; 
     continue ) else skip ; 
    var m : int ; m := 1 ;
    while (j /= arr[i+1]) do (     OclFile["System.out"].print(m + " ") ; 
     m := m + 1 ; 
     j := j + 1 ; 
     if (m > k) then     m := 1 ; else skip ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void maximumArea(int l,int b,int x,int y){
    int left,right,above,below ;
    left=x*b ;
    right=(l-x-1)*b ;
    above=l*y ;
    below=(b-y-1)*l ;
    System.out.print(Math.max(Math.max(left,right),Math.max(above,below)));
  }
  public static void main(String[] args){
    int L=8,B=8 ;
    int X=0,Y=0 ;
    maximumArea(L,B,X,Y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maximumArea( l : int, b : int, x : int, y : int) : void
  pre: true
  post: true
  activity: (     var left : int ;
    var right : int ;
    var above : int ;
    var below : int ;
     left := x * b ; 
    right := (l - x - 1) * b ; 
    above := l * y ; 
    below := (b - y - 1) * l ; 
    OclFile["System.out"].print(Set{Set{left, right}->max(), Set{above, below}->max()}->max()) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 8 ;
    var B : int ; B := 8 ;
     var X : int ; X := 0 ;
    var Y : int ; Y := 0 ;
     execute maximumArea(L, B, X, Y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static void sieve(boolean prime[],int n){
    for(int p=2 ; p*p<=n ; p++){
      if(prime[p]==false)for(int i=p*2 ;
      i<=n ;
      i+=p)prime[i]=true ;
    }
  }
  static int maxDigitInPrimes(int L,int R){
    boolean prime[]=new boolean[R+1];
    Arrays.fill(prime,false);
    sieve(prime,R);
    int freq[]=new int[10];
    int val ;
    for(int i=L ; i<=R ; i++){
      if(! prime[i]){
        int p=i ;
        while(p>0){
          freq[p % 10]++;
          p/=10 ;
        }
      }
    }
    int max=freq[0],ans=0 ;
    for(int j=1 ; j<10 ; j++){
      if(max<=freq[j]){
        max=freq[j];
        ans=j ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int L=1,R=20 ;
    System.out.println(maxDigitInPrimes(L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sieve( prime : Sequence(boolean), n : int) : void
  pre: true
  post: true
  activity: (         var p : int ; p := 2 ; while p * p <= n do ( (     if (prime[p+1] = false) then         var i : int ; i := p * 2 ; while i <= n do (     prime[i+1] := true ;  ;     i := i+(p) ) ; else skip )  ;     p := p + 1 ) );
  static   operation maxDigitInPrimes( L : int, R : int) : int
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,R + 1)->collect(false) ;
     prime := prime->collect(false) ; 
    execute sieve(prime, R) ; 
    var freq : Sequence(int) ; freq := Integer.subrange(1,10)->collect(0) ;
    var val : int ;
        var i : int ; i := L ; while i <= R do ( (     if (not(prime[i+1])) then (     var p : int ; p := i ;
     while (p > 0) do (     freq[p mod 10+1] := freq[p mod 10+1] + 1 ; 
     p := p/(10) ) ) else skip )  ;     i := i + 1 ) ; 
    var max : int ; max := freq[0+1] ;
    var ans : int ; ans := 0 ;
        var j : int ; j := 1 ; while j < 10 do ( (     if (max <= freq[j+1]) then (     max := freq[j+1] ; 
     ans := j ) else skip )  ;     j := j + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 1 ;
    var R : int ; R := 20 ;
     OclFile["System.out"].println(maxDigitInPrimes(L, R)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      if(n==1){
        System.out.println("1");
      }
      else {
        for(int i=2 ; i<=n ; i++){
          System.out.print(i+" ");
        }
        System.out.println("1");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := input.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.getCurrent()->toInteger() ;
     if (n = 1) then (     OclFile["System.out"].println("1") ) else (         var i : int ; i := 2 ; while i <= n do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("1") ) ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Solution {
  static MyScanner str=new MyScanner();
  public static void main(String[] args)throws IOException {
    int T=i();
    while(T-->0){
      solve();
    }
  }
  static void solve()throws IOException {
    int n=i();
    System.out.print(n+" ");
    for(int i=1 ; i<n ; i++){
      System.out.print(i+" ");
    }
    System.out.println();
  }
  public static int i()throws IOException {
    return str.nextInt();
  }
  public static long l()throws IOException {
    return str.nextLong();
  }
  public static double d()throws IOException {
    return str.nextDouble();
  }
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute str : MyScanner := MyScanner.newMyScanner();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := i() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := i() ;
     OclFile["System.out"].print(n + " ") ; 
         var i : int ; i := 1 ; while i < n do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation i() : int
  pre: true
  post: true
  activity: (     return str.nextInt() );
  static   operation l() : long
  pre: true
  post: true
  activity: (     return str.nextLong() );
  static   operation d() : double
  pre: true
  post: true
  activity: (     return str.nextDouble() );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import java.io.PrintWriter ;
public class MyClass {
  public static void main(String[] args){
    InputReader scanner=new InputReader(System.in);
    PrintWriter output=new PrintWriter(System.out);
    int T=scanner.nextInt();
    while(T-->0){
      int n=scanner.nextInt();
      output.print(n+" ");
      for(int i=1 ; i<n ; i++){
        output.print(i+" ");
      }
      output.println();
    }
    output.close();
  }
  static class InputReader {
    BufferedReader reader ;
    StringTokenizer tokenizer ;
    InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream));
      tokenizer=null ;
    }
    String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.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=reader.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : InputReader ; scanner := InputReader.newInputReader(OclFile["System.in"]) ;
     var output : OclFile ; output := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := scanner.nextInt() ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := scanner.nextInt() ;
     skip ; 
         var i : int ; i := 1 ; while i < n do ( (     skip )  ;     i := i + 1 ) ; 
     skip ) ;  ) ;  
    skip ; 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := reader.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Solution {
  static PrintWriter pw ;
  static FastScanner s ;
  public static void main(String[] args)throws Exception {
    pw=new PrintWriter(System.out);
    s=new FastScanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      if(n % 2==0){
        int i=1 ;
        while(i<=n){
          pw.print((i+1)+" "+(i)+" ");
          i+=2 ;
        }
      }
      else {
        pw.print(1+" ");
        int i=2 ;
        while(i<=n){
          pw.print((i+1)+" "+(i)+" ");
          i+=2 ;
        }
      }
      pw.println();
    }
    pw.flush();
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public FastScanner(String s)throws Exception {
    br=new BufferedReader(new FileReader(new File(s)));
  }
  public String next()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(next());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute pw : OclFile;
  static   attribute s : FastScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     pw := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     s := FastScanner.newFastScanner(OclFile["System.in"]) ; 
    var t : int ; t := s.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.nextInt() ;
     if (n mod 2 = 0) then (     var i : int ; i := 1 ;
     while (i <= n) do (     skip ; 
     i := i+(2) ) ) else (     skip ; 
     var i : int ; i := 2 ;
     while (i <= n) do (     skip ; 
     i := i+(2) ) ) ;  
     skip ) ;  ) ;  
    skip ; 
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isequal(String str){
    int n=str.length();
    int num=0,x=1,i=n-1 ;
    for(i=n-1 ; i>=0 ; i--){
      if('0'<=str.charAt(i)&& str.charAt(i)<='9'){
        num=(str.charAt(i)-'0')*x+num ;
        x=x*10 ;
        if(num>=n)return false ;
      }
      else break ;
    }
    return num==i+1 ;
  }
  static public void main(String[] args){
    String str="geeksforgeeks13" ;
    if(isequal(str))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isequal( str : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var num : int ; num := 0 ;
    var x : int ; x := 1 ;
    var i : int ; i := n - 1 ;
         i := n - 1 ; while i >= 0 do ( (     if ('0' <= str->at(i+1) & str->at(i+1) <= '9') then (     num := (str->at(i+1) - ('0')->char2byte()) * x + num ; 
     x := x * 10 ; 
     if (num >= n) then     return false else skip ) else     break )  ;     i := i - 1 ) ; 
     return num = i + 1 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks13" ;
     if (isequal(str)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static String decToBin(int n){
    if(n==0)return "0" ;
    String bin="" ;
    while(n>0){
      bin=((n & 1)==0 ? '0' : '1')+bin ;
      n>>=1 ;
    }
    return bin ;
  }
  public static void main(String[] args){
    int n=38 ;
    System.out.println(decToBin(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation decToBin( n : int) : String
  pre: true
  post: true
  activity: (     if (n = 0) then     return "0" else skip ; 
     var bin : String ; bin := "" ;
     while (n > 0) do (     bin := (if (n & 1) = 0 then '0' else '1' endif) + bin ; 
     n := n/(2->pow(1)) ) ; 
     return bin );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 38 ;
     OclFile["System.out"].println(decToBin(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void tower(int n,char sourcePole,char destinationPole,char auxiliaryPole){
    if(0==n)return ;
    tower(n-1,sourcePole,auxiliaryPole,destinationPole);
    System.out.printf("Move the disk %d from %c to %c\n",n,sourcePole,destinationPole);
    tower(n-1,auxiliaryPole,destinationPole,sourcePole);
  }
  public static void main(String[] args){
    tower(3,'S','D','A');
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation tower( n : int, sourcePole : String, destinationPole : String, auxiliaryPole : String) : void
  pre: true
  post: true
  activity: (     if (0 = n) then     return else skip ; 
     execute tower(n - 1, sourcePole, auxiliaryPole, destinationPole) ; 
     OclFile["System.out"].printf("Move the disk %d from %c to %c\n", n, sourcePole, destinationPole) ; 
     execute tower(n - 1, auxiliaryPole, destinationPole, sourcePole) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute tower(3, 'S', 'D', 'A') );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maxPeople(int p){
    int tmp=0,count=0 ;
    for(int i=1 ; i*i<=p ; i++){
      tmp=tmp+(i*i);
      if(tmp<=p)count++;
      else break ;
    }
    return count ;
  }
  public static void main(String args[]){
    int p=14 ;
    System.out.println(maxPeople(p));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxPeople( p : int) : int
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := 0 ;
    var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i * i <= p do ( (     tmp := tmp + (i * i) ; 
     if (tmp <= p) then     count := count + 1 ; else     break )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : int ; p := 14 ;
     OclFile["System.out"].println(maxPeople(p)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A {
  public static String pref(String str,int ind){
    StringBuffer bf=new StringBuffer();
    int cnt=0 ;
    for(int i=ind-1 ; i>=0 && str.charAt(i)!='-' ; i--){
      if(cnt % 3==0 && cnt!=0){
        bf.append(',');
      }
      bf.append(str.charAt(i));
      cnt++;
    }
    return bf.reverse().toString();
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    StringBuffer bf=new StringBuffer();
    int ind=-1 ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)=='.'){
        ind=i ;
        break ;
      }
    }
    String prefix="",suffix="" ;
    if(ind==-1){
      prefix=pref(str,str.length());
      suffix=".00" ;
    }
    else {
      prefix=pref(str,ind);
      suffix+="." ;
      for(int i=ind+1 ; i<=ind+2 ; i++){
        if(i<str.length()){
          suffix+=str.charAt(i);
        }
        else {
          suffix+='0' ;
        }
      }
    }
    if(str.charAt(0)=='-'){
      prefix="($"+prefix ;
      suffix+=")" ;
    }
    else {
      prefix="$"+prefix ;
    }
    System.out.println(prefix+suffix);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation pref( str : String, ind : int) : String
  pre: true
  post: true
  activity: (     var bf : String ; bf := StringLib.newString() ;
     var cnt : int ; cnt := 0 ;
         var i : int ; i := ind - 1 ; while i >= 0 & str->at(i+1) /= '-' do ( (     if (cnt mod 3 = 0 & cnt /= 0) then (     bf := bf + StringLib.newString(',') ) else skip ; 
     bf := bf + StringLib.newString(str->at(i+1)) ; 
     cnt := cnt + 1 )  ;     i := i - 1 ) ; 
     return bf->reverse()+"" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var bf : String ; bf := StringLib.newString() ;
    var ind : int ; ind := -1 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '.') then (     ind := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var prefix : String ; prefix := "" ;
    var suffix : String ; suffix := "" ;
    if (ind = -1) then (     prefix := pref(str, str->size()) ; 
     suffix := ".00" ) else (     prefix := pref(str, ind) ; 
     suffix := suffix+(".") ; 
         var i : int ; i := ind + 1 ; while i <= ind + 2 do ( (     if (i < str->size()) then (     suffix := suffix+(str->at(i+1)) ) else (     suffix := suffix+('0') ) )  ;     i := i + 1 ) ) ;  
    if (str->at(0+1) = '-') then (     prefix := "($" + prefix ; 
     suffix := suffix+(")") ) else (     prefix := "$" + prefix ) ;  
    OclFile["System.out"].println(prefix + suffix) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] d=new int[n];
    for(int i=0 ; i<n ; i++)d[i]=sc.nextInt();
    Arrays.sort(d);
    int ans=1 ;
    for(int i=0 ; i<n-1 ; i++){
      if(d[i]!=d[i+1])ans++;
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     d[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    d := d->sort() ; 
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (d[i+1] /= d[i + 1+1]) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int R=0,B=0,W=0,G=0 ;
    R=sc.nextInt();
    B=sc.nextInt();
    W=sc.nextInt();
    G=sc.nextInt();
    System.out.println((R+B+W+G));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var R : int ; R := 0 ;
    var B : int ; B := 0 ;
    var W : int ; W := 0 ;
    var G : int ; G := 0 ;
    R := sc.getCurrent()->toInteger() ; 
    B := sc.getCurrent()->toInteger() ; 
    W := sc.getCurrent()->toInteger() ; 
    G := sc.getCurrent()->toInteger() ; 
    OclFile["System.out"].println((R + B + W + G)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int maxLenSub(int arr[],int n){
    int mls[]=new int[n],max=0 ;
    for(int i=0 ; i<n ; i++)mls[i]=1 ;
    for(int i=1 ; i<n ; i++)for(int j=0 ; j<i ; j++)if(Math.abs(arr[i]-arr[j])<=1 && mls[i]<mls[j]+1)mls[i]=mls[j]+1 ;
    for(int i=0 ; i<n ; i++)if(max<mls[i])max=mls[i];
    return max ;
  }
  public static void main(String[] args){
    int arr[]={
      2,5,6,3,7,6,5,8 };
      int n=arr.length ;
      System.out.println("Maximum length subsequence="+maxLenSub(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxLenSub( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var mls : Sequence(int) ; mls := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := 0 ;
         var i : int ; i := 0 ; while i < n do (     mls[i+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do (         var j : int ; j := 0 ; while j < i do (     if (if arr[i+1] - arr[j+1] < 0 then -(arr[i+1] - arr[j+1]) else arr[i+1] - arr[j+1] endif <= 1 & mls[i+1] < mls[j+1] + 1) then     mls[i+1] := mls[j+1] + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     if (max < mls[i+1]) then     max := mls[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    return max 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,5,6,3,7,6,5,8} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Maximum length subsequence=" + maxLenSub(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countBits(int n){
    int count=0 ;
    while(n>0){
      count++;
      n>>=1 ;
    }
    return count ;
  }
  static int findNearestNumber(int n){
    int cnt=countBits(n);
    cnt-=1 ;
    if(cnt % 2==1){
      return 1<<(cnt+1);
    }
    else {
      int tempnum=0 ;
      for(int i=0 ; i<=cnt ; i+=2){
        tempnum+=1<<i ;
      }
      if(tempnum<n){
        return(1<<(cnt+2));
      }
      else if(tempnum==n){
        return n ;
      }
      for(int i=0 ; i<=cnt ; i+=2){
        tempnum-=(1<<i);
        if(tempnum<n){
          return tempnum+=(1<<i);
        }
      }
    }
    return Integer.MIN_VALUE ;
  }
  public static void main(String[] args){
    int n=19 ;
    System.out.println(findNearestNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countBits( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     count := count + 1 ; 
     n := n/(2->pow(1)) ) ; 
     return count );
  static   operation findNearestNumber( n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := countBits(n) ;
     cnt := cnt-(1) ; 
     if (cnt mod 2 = 1) then (     return (1*(2->pow((cnt + 1))))->oclAsType(long) ) else (     var tempnum : int ; tempnum := 0 ;
         var i : int ; i := 0 ; while i <= cnt do ( (     tempnum := tempnum+((1*(2->pow(i)))->oclAsType(long)) )  ;     i := i+(2) ) ; 
     if (tempnum < n) then (     return ((1*(2->pow((cnt + 2))))->oclAsType(long)) ) else     if (tempnum = n) then (     return n ) else skip ; ;  
         var i : int ; i := 0 ; while i <= cnt do ( (     tempnum := tempnum-(((1*(2->pow(i)))->oclAsType(long))) ; 
     if (tempnum < n) then (     return tempnum ) else skip )  ;     i := i+(2) ) ) ;  
     return -2147483648 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 19 ;
     OclFile["System.out"].println(findNearestNumber(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import javafx.util.Pair ;
public class Solver {
  public static void main(String[] args)throws IOException {
    BufferedReader x=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    StringTokenizer tk ;
    Stack<Character>s=new Stack<>();
    String a=x.readLine();
    char[] c=a.toCharArray();
    for(int i=c.length-1 ; i>=0 ; i--){
      if(s.isEmpty())s.push(c[i]);
      else if(s.peek()==c[i]){
        s.pop();
      }
      else {
        s.push(c[i]);
      }
    }
    for(int i=s.size()-1 ; i>=0 ; i--){
      out.print(s.pop());
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solver {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : OclFile ; x := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var tk : OclIterator ;
    var s : Sequence(String) ; s := Sequence{} ;
    var a : String ; a := x.readLine() ;
    var c : Sequence(String) ; c := a->characters() ;
        var i : int ; i := c->size() - 1 ; while i >= 0 do ( (     if (s->isEmpty()) then     s := s->append(c[i+1]) ; else     if (s->min() = c[i+1]) then (     s := s->front() ) else (     s := s->append(c[i+1]) ) ;  )  ;     i := i - 1 ) ; 
        var i : int ; i := s->size() - 1 ; while i >= 0 do ( (     skip )  ;     i := i - 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.util.Stack ;
public class JavaApplication1 {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
    StringBuilder ss=new StringBuilder(in.readLine());
    Stack<Character>s2=new Stack<>();
    for(int i=0 ; i<ss.length(); i++){
      if(i==0){
        s2.push(ss.charAt(i));
      }
      else {
        if(s2.size()!=0 && s2.peek()==ss.charAt(i)){
          s2.pop();
        }
        else {
          s2.push(ss.charAt(i));
        }
      }
    }
    for(int i=0 ; i<s2.size(); i++){
      out.write(s2.get(i));
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var ss : String ; ss := StringLib.newString(in.readLine()) ;
    var s2 : Sequence(String) ; s2 := Sequence{} ;
        var i : int ; i := 0 ; while i < ss->size() do ( (     if (i = 0) then (     s2 := s2->append(ss->at(i+1)) ) else (     if (s2->size() /= 0 & s2->min() = ss->at(i+1)) then (     s2 := s2->front() ) else (     s2 := s2->append(ss->at(i+1)) ) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < s2->size() do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Deque ;
import java.util.LinkedList ;
import java.io.*;
public class Plugin {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    String str=br.readLine();
    Deque<Character>queue=new LinkedList<>();
    for(char c : str.toCharArray()){
      if(! queue.isEmpty()){
        if(queue.peekLast()==c){
          queue.pollLast();
        }
        else {
          queue.addLast(c);
        }
      }
      else {
        queue.addLast(c);
      }
    }
    while(! queue.isEmpty()){
      pw.print(queue.pollFirst());
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Plugin {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    var str : String ; str := br.readLine() ;
    var queue : Sequence(String) ; queue := Sequence{} ;
    for (c : str->characters()) do ( (     if (not(queue->isEmpty())) then (     if (queue.peekLast() = c) then (     queue := queue->front() ) else (     queue := queue->append(c) ) ) else (     queue := queue->append(c) ) )  ) ; 
    while (not(queue->isEmpty())) do (     skip ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  public static void main(String[] args)throws Exception {
    String g=br.readLine();
    StringBuilder sb=new StringBuilder();
    Stack<Character>s=new Stack<>();
    for(int i=0 ; i<g.length(); i++){
      char c=g.charAt(i);
      if(s.size()>0 && s.peek()==c)s.pop();
      else s.push(c);
    }
    char[] arr=new char[s.size()];
    int i=s.size()-1 ;
    while(! s.isEmpty())arr[i--]=s.pop();
    for(char c : arr)pw.print(c);
    pw.println();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : String ; g := br.readLine() ;
     var sb : String ; sb := StringLib.newString() ;
    var s : Sequence(String) ; s := Sequence{} ;
        var i : int ; i := 0 ; while i < g->size() do ( (     var c : String ; c := g->at(i+1) ;
     if (s->size() > 0 & s->min() = c) then     s := s->front() ; else     s := s->append(c) ; )  ;     i := i + 1 ) ; 
    var arr : Sequence(String) ; arr := Integer.subrange(1,s->size())->collect(0) ;
    var i : int ; i := s->size() - 1 ;
    while (not(s->isEmpty())) do     arr[i+1] := s->last() ;     s := s->front() ; ; 
    for (c : arr) do (     skip ;  ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Stack ;
import java.util.StringTokenizer ;
public class Solve3 {
  public static void main(String[] args)throws IOException {
    PrintWriter pw=new PrintWriter(System.out);
    new Solve3().solve(pw);
    pw.flush();
    pw.close();
  }
  public void solve(PrintWriter pw)throws IOException {
    FastReader sc=new FastReader();
    Stack<Character>s=new Stack();
    char[] c=sc.next().toCharArray();
    for(int i=0 ; i<c.length ; i++){
      if(! s.isEmpty()&& c[i]==s.peek()){
        s.pop();
      }
      else {
        s.push(c[i]);
      }
    }
    StringBuilder ans=new StringBuilder();
    while(! s.isEmpty()){
      ans.append(s.pop());
    }
    pw.println(ans.reverse());
  }
  static public class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public String next()throws IOException {
      if(st==null || ! st.hasMoreTokens()){
        st=new StringTokenizer(br.readLine());
      }
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solve3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     Solve3.newSolve3().solve(pw) ; 
     skip ; 
     skip );
   operation solve( pw : OclFile) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var s : Sequence(String) ; s := Sequence{} ;
    var c : Sequence(String) ; c := sc.next()->characters() ;
        var i : int ; i := 0 ; while i < c->size() do ( (     if (not(s->isEmpty()) & c[i+1] = s->min()) then (     s := s->front() ) else (     s := s->append(c[i+1]) ) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := StringLib.newString() ;
    while (not(s->isEmpty())) do (     ans := ans + StringLib.newString(s->last()) ) ; 
    skip ; 
 );
  static  class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (st = null or not(st.hasNext())) then (     st := OclIterator.newOclIterator_String(br.readLine()) ) else skip ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
class Main {
  public static Scanner sc=new Scanner(in);
  public static Random rand=new Random();
  public void run(){
    int val=sc.nextInt();
    char exp=sc.next().charAt(0);
    while(exp!='='){
      int exp2=sc.nextInt();
      switch(exp){
        case '+' : val+=exp2 ;
        break ;
        case '-' : val-=exp2 ;
        break ;
        case '*' : val*=exp2 ;
        break ;
        case '/' : val/=exp2 ;
        break ;
      }
      exp=sc.next().charAt(0);
    }
    ln(val);
  }
  public static void main(String[] args){
    new Main().run();
  }
  public int[] nextIntArray(int n){
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=sc.nextInt();
    }
    return res ;
  }
  public static void pr(Object o){
    out.print(o);
  }
  public static void ln(Object o){
    out.println(o);
  }
  public static void ln(){
    out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(in);
  static   attribute rand : OclRandom := OclRandom.newOclRandom();
   operation run() : void
  pre: true
  post: true
  activity: (     var val : int ; val := sc.getCurrent()->toInteger() ;
     var exp : String ; exp := sc.getCurrent()->at(0+1) ;
     while (exp /= '=') do (     var exp2 : int ; exp2 := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (exp) ; 
       if _switchval = '+' then
     val := val+(exp2) ; 
    break 
   else skip ;
       if _switchval = '-' then
     val := val-(exp2) ; 
    break 
   else skip ;
       if _switchval = '*' then
     val := val*(exp2) ; 
    break 
   else skip ;
       if _switchval = '/' then
     val := val/(exp2) ; 
    break 
   else skip ;
 )
     exp := sc.getCurrent()->at(0+1) ) ; 
     execute ln(val) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return res );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     out.println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static long result=Long.parseLong(sc.nextLine());
  public static void main(String[] args){
    calculator();
  }
  private static void calculator(){
    do {
      String op=sc.nextLine();
      if(op.equals("=")){
        break ;
      }
      int num=Integer.parseInt(sc.nextLine());
      switch(op){
        case "+" : result+=num ;
        break ;
        case "-" : result-=num ;
        break ;
        case "*" : result*=num ;
        break ;
        case "/" : result/=num ;
        break ;
        default : break ;
      }
    }
    while(true);
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute result : long := (sc.nextLine())->toLong();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute calculator() );
  static   operation calculator() : void
  pre: true
  post: true
  activity: (   while true do ((     var op : String ; op := sc.nextLine() ;
     if (op = "=") then (     break ) else skip ; 
     var num : int ; num := (sc.nextLine())->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (op) ; 
       if _switchval = "+" then
     result := result+(num) ; 
    break 
   else skip ;
       if _switchval = "-" then
     result := result-(num) ; 
    break 
   else skip ;
       if _switchval = "*" then
     result := result*(num) ; 
    break 
   else skip ;
       if _switchval = "/" then
     result := result/(num) ; 
    break 
   else skip ;
       if true then
     break 
   else skip ;
 )
 ) ;
    if (true) then skip else break) ; 
     OclFile["System.out"].println(result) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int k=s.nextInt();
    int[][] peeledTile=new int[k][2];
    int center=n/2+1 ;
    for(int i=0 ; i<k ; i++){
      peeledTile[i][0]=s.nextInt();
      peeledTile[i][1]=s.nextInt();
    }
    for(int i=0 ; i<k ; i++){
      if(peeledTile[i][0]>n/2){
        peeledTile[i][0]=n-peeledTile[i][0]+1 ;
      }
      if(peeledTile[i][1]>n/2){
        peeledTile[i][1]=n-peeledTile[i][1]+1 ;
      }
      if(n % 2==1 && peeledTile[i][0]==center && peeledTile[i][1]==center){
        print(center % 3);
      }
      else if(peeledTile[i][0] % 3==peeledTile[i][1] % 3 || peeledTile[i][0]<peeledTile[i][1]){
        print(peeledTile[i][0] % 3);
      }
      else {
        print(peeledTile[i][1] % 3);
      }
    }
    s.close();
  }
  public static void print(int ans){
    if(ans==0)ans=3 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var k : int ; k := s.getCurrent()->toInteger() ;
    var peeledTile : Sequence(Sequence(int)) ; peeledTile := Integer.subrange(1,k)->collect(Integer.subrange(1,2)->collect(0)) ;
    var center : int ; center := n / 2 + 1 ;
        var i : int ; i := 0 ; while i < k do ( (     peeledTile[i+1][0+1] := s.getCurrent()->toInteger() ; 
     peeledTile[i+1][1+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do ( (     if (peeledTile[i+1][0+1] > n / 2) then (     peeledTile[i+1][0+1] := n - peeledTile[i+1][0+1] + 1 ) else skip ; 
     if (peeledTile[i+1][1+1] > n / 2) then (     peeledTile[i+1][1+1] := n - peeledTile[i+1][1+1] + 1 ) else skip ; 
     if (n mod 2 = 1 & peeledTile[i+1][0+1] = center & peeledTile[i+1][1+1] = center) then (     execute print(center mod 3) ) else     if (peeledTile[i+1][0+1] mod 3 = peeledTile[i+1][1+1] mod 3 or peeledTile[i+1][0+1] < peeledTile[i+1][1+1]) then (     execute print(peeledTile[i+1][0+1] mod 3) ) else (     execute print(peeledTile[i+1][1+1] mod 3) ) ;  )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation print( ans : int) : void
  pre: true
  post: true
  activity: (     if (ans = 0) then     ans := 3 ; else skip ; 
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayDeque ;
import java.util.Deque ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    Deque<Character>ops=new ArrayDeque<>();
    Deque<Integer>nums=new ArrayDeque<>();
    while((line=br.readLine())!=null && ! line.isEmpty()){
      if(line.equals("=")){
        System.out.println(nums.pop());
        break ;
      }
      switch(line.charAt(0)){
        case '+' : case '-' : case '*' : case '/' : ops.offer(line.charAt(0));
        break ;
        default : if(ops.size()>0){
          char op=ops.pop();
          int num1=nums.pop();
          int num2=parseInt(line);
          switch(op){
            case '+' : num1+=num2 ;
            break ;
            case '-' : num1-=num2 ;
            break ;
            case '*' : num1*=num2 ;
            break ;
            case '/' : num1/=num2 ;
            break ;
          }
          nums.offer(num1);
        }
        else {
          nums.offer(parseInt(line));
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var ops : Sequence(String) ; ops := ArrayDeque<OclAny>.newArrayDeque() ;
    var nums : Sequence(int) ; nums := ArrayDeque<OclAny>.newArrayDeque() ;
        line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     if (line = "=") then (     OclFile["System.out"].println(nums->last()) ; 
     break ) else skip ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (line->at(0+1)) ; 
    if _switchval = '+' or _switchval = '-' or _switchval = '*' or _switchval = '/' then
    ops := ops->including(line->at(0+1)) ; 
    break 
   else skip ;
       if true then
     if (ops->size() > 0) then (     var op : String ; op := ops->last() ;
     var num1 : int ; num1 := nums->last() ;
    var num2 : int ; num2 := parseInt(line) ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (op) ; 
       if _switchval = '+' then
     num1 := num1+(num2) ; 
    break 
   else skip ;
       if _switchval = '-' then
     num1 := num1-(num2) ; 
    break 
   else skip ;
       if _switchval = '*' then
     num1 := num1*(num2) ; 
    break 
   else skip ;
       if _switchval = '/' then
     num1 := num1/(num2) ; 
    break 
   else skip ;
 )
    nums := nums->including(num1) ; 
 ) else (     nums := nums->including((line + "")->toInteger()) ) ;  
   else skip ;
 )
 ) ;     line := br.readLine() ;
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GfG {
  private static int atMostK(int arr[],int n,int k){
    int count=0 ;
    int left=0 ;
    int right=0 ;
    HashMap<Integer,Integer>map=new HashMap<>();
    while(right<n){
      map.put(arr[right],map.getOrDefault(arr[right],0)+1);
      while(map.size()>k){
        map.put(arr[left],map.get(arr[left])-1);
        if(map.get(arr[left])==0)map.remove(arr[left]);
        left++;
      }
      count+=right-left+1 ;
      right++;
    }
    return count ;
  }
  private static int exactlyK(int arr[],int n,int k){
    return(atMostK(arr,n,k)-atMostK(arr,n,k-1));
  }
  public static void main(String[] args){
    int arr[]={
      2,1,2,1,6 };
      int n=arr.length ;
      int k=2 ;
      System.out.print(exactlyK(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation atMostK( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var left : int ; left := 0 ;
    var right : int ; right := 0 ;
    var map : Map(int,int) ; map := Map{} ;
    while (right < n) do (     map := map->union(Map{arr[right+1] |-> (if map->keys()->contains(arr[right+1]) then map->at(arr[right+1]) else 0 endif) + 1}) ; 
     while (map.size() > k) do (     map := map->union(Map{arr[left+1] |-> map->at(arr[left+1]) - 1}) ; 
     if (map->at(arr[left+1]) = 0) then     map := map->antirestrict(Set{arr[left+1]}) ; else skip ; 
     left := left + 1 ) ; 
     count := count+(right - left + 1) ; 
     right := right + 1 ) ; 
    return count 
 );
  static   operation exactlyK( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     return (atMostK(arr, n, k) - atMostK(arr, n, k - 1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,1,2,1,6} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].print(exactlyK(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.Map ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    boolean left_init=false ;
    int cur=0 ;
    while(true){
      String in=sc.next();
      if("=".equals(in)){
        System.out.println(cur);
        break ;
      }
      else if("+".equals(in)){
        int next=sc.nextInt();
        cur+=next ;
      }
      else if("-".equals(in)){
        int next=sc.nextInt();
        cur-=next ;
      }
      else if("*".equals(in)){
        int next=sc.nextInt();
        cur*=next ;
      }
      else if("/".equals(in)){
        int next=sc.nextInt();
        cur/=next ;
      }
      else {
        int input=Integer.parseInt(in);
        if(! left_init){
          cur=input ;
          left_init=true ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var left_init : boolean ; left_init := false ;
     var cur : int ; cur := 0 ;
     while (true) do (     var in : String ; in := sc.getCurrent() ;
     if ("=" = in) then (     OclFile["System.out"].println(cur) ; 
     break ) else     if ("+" = in) then (     var next : int ; next := sc.getCurrent()->toInteger() ;
     cur := cur+(next) ) else     if ("-" = in) then (     var next : int ; next := sc.getCurrent()->toInteger() ;
     cur := cur-(next) ) else     if ("*" = in) then (     var next : int ; next := sc.getCurrent()->toInteger() ;
     cur := cur*(next) ) else     if ("/" = in) then (     var next : int ; next := sc.getCurrent()->toInteger() ;
     cur := cur/(next) ) else (     var input : int ; input := (in)->toInteger() ;
     if (not(left_init)) then (     cur := input ; 
     left_init := true ) else skip ) ;  ;  ;  ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    String exp="("+sc.next()+sc.next()+sc.next()+")" ;
    while(true){
      String op=sc.next();
      if(op.equals("=")){
        break ;
      }
      exp="("+exp+op+sc.next()+")" ;
    }
    Parser parser=new Parser(exp);
    System.out.println(parser.expression());
  }
  public static void main(String[] args){
    new Main().run();
  }
}
class Parser {
  char[] exp ;
  int begin ;
  Parser(String str){
    this.exp=(str+"#").toCharArray();
  }
  int expression(){
    int ret=term();
    while(true){
      if(exp[begin]=='+'){
        begin++;
        ret+=term();
      }
      else if(exp[begin]=='-'){
        begin++;
        ret-=term();
      }
      else {
        break ;
      }
    }
    return ret ;
  }
  int term(){
    int ret=factor();
    while(true){
      if(exp[begin]=='*'){
        begin++;
        ret*=factor();
      }
      else if(exp[begin]=='/'){
        begin++;
        ret/=factor();
      }
      else {
        break ;
      }
    }
    return ret ;
  }
  int number(){
    int ret=0 ;
    while(Character.isDigit(exp[begin])){
      ret*=10 ;
      ret+=exp[begin]-'0' ;
      begin++;
    }
    return ret ;
  }
  int factor(){
    if(exp[begin]=='('){
      begin++;
      int ret=expression();
      begin++;
      return ret ;
    }
    else {
      return number();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var exp : String ; exp := "(" + sc.getCurrent() + sc.getCurrent() + sc.getCurrent() + ")" ;
    while (true) do (     var op : String ; op := sc.getCurrent() ;
     if (op = "=") then (     break ) else skip ; 
     exp := "(" + exp + op + sc.getCurrent() + ")" ) ; 
    var parser : Parser ; parser := Parser.newParser(exp) ;
    OclFile["System.out"].println(parser.expression()) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}
class Parser {
   attribute exp : Sequence(String);
   attribute begin : int;
   static operation newParser( str : String) : Parser
  pre: true
  post: true
  activity:
  ( var self : Parser ;
    self := createParser();
    self.initialise(str);
    return self );
  operation initialise( str : String) : void
  pre: true  post: true
  activity: (     self.exp := (str + "#")->characters() );
   operation expression() : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := term() ;
     while (true) do (     if (exp[begin+1] = '+') then (     begin := begin + 1 ; 
     ret := ret+(term()) ) else     if (exp[begin+1] = '-') then (     begin := begin + 1 ; 
     ret := ret-(term()) ) else (     break ) ;  ) ; 
     return ret );
   operation term() : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := factor() ;
     while (true) do (     if (exp[begin+1] = '*') then (     begin := begin + 1 ; 
     ret := ret*(factor()) ) else     if (exp[begin+1] = '/') then (     begin := begin + 1 ; 
     ret := ret/(factor()) ) else (     break ) ;  ) ; 
     return ret );
   operation number() : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
     while ((exp[begin+1] + "")->isMatch("[0-9]")) do (     ret := ret*(10) ; 
     ret := ret+(exp[begin+1] - ('0')->char2byte()) ; 
     begin := begin + 1 ) ; 
     return ret );
   operation factor() : int
  pre: true
  post: true
  activity: (     if (exp[begin+1] = '(') then (     begin := begin + 1 ; 
     var ret : int ; ret := expression() ;
     begin := begin + 1 ; 
     return ret ) else (     return number() ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void anglequichord(int z){
    System.out.println("The angle is "+z+" degrees");
  }
  public static void main(String[] args){
    int z=48 ;
    anglequichord(z);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation anglequichord( z : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("The angle is " + z + " degrees") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var z : int ; z := 48 ;
     execute anglequichord(z) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    out=new PrintWriter(new BufferedOutputStream(System.out));
    int l=sc.nextInt();
    int k=sc.nextInt();
    long[][] dp=new long[2][l+1];
    dp[0][0]=1 ;
    for(int i=1 ; i<=l ; ++i){
      dp[0][i]+=dp[1][i-1];
      dp[1][i]+=dp[0][i-1];
      if(i>=k)dp[1][i]+=dp[0][i-k];
    }
    long ans=0 ;
    for(int i=1 ; i<=l ; ++i)ans+=dp[1][i];
    out.println(ans);
    out.close();
  }
  public static PrintWriter out ;
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var l : int ; l := sc.nextInt() ;
    var k : int ; k := sc.nextInt() ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,l + 1)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= l do ( (     dp[0+1][i+1] := dp[0+1][i+1]+(dp[1+1][i - 1+1]) ; 
     dp[1+1][i+1] := dp[1+1][i+1]+(dp[0+1][i - 1+1]) ; 
     if (i >= k) then     dp[1+1][i+1] := dp[1+1][i+1]+(dp[0+1][i - k+1]) ; else skip )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= l do (     ans := ans+(dp[1+1][i+1]) ;  ;     i := i + 1 ) ; 
    out.println(ans) ; 
    out.close() ; 
 );
  static   attribute out : OclFile;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  int l,k ;
  long[] dp ;
  void run(){
    Scanner scan=new Scanner(System.in);
    l=scan.nextInt();
    k=scan.nextInt();
    dp=new long[l+1];
    System.out.println(dfs(l));
  }
  long dfs(int d){
    if(l==d)return dfs(d-1)+dfs(d-k);
    if(d<0)return 0 ;
    if(d<2)return 1 ;
    if(dp[d]!=0)return dp[d];
    dp[d]=dfs(d-2)+dfs(d-k-1)+1 ;
    return dp[d];
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute l : int;
   attribute dp : Sequence(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     l := scan.getCurrent()->toInteger() ; 
    k := scan.getCurrent()->toInteger() ; 
    dp := Integer.subrange(1,l + 1)->collect(0) ; 
    OclFile["System.out"].println(dfs(l)) ; 
 );
   operation dfs( d : int) : long
  pre: true
  post: true
  activity: (     if (l = d) then     return dfs(d - 1) + dfs(d - k) else skip ; 
     if (d < 0) then     return 0 else skip ; 
    if (d < 2) then     return 1 else skip ; 
    if (dp[d+1] /= 0) then     return dp[d+1] else skip ; 
    dp[d+1] := dfs(d - 2) + dfs(d - k - 1) + 1 ; 
    return dp[d+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int l=scan.nextInt();
    int k=scan.nextInt();
    long result=0 ;
    for(int thick=0 ; thick<=50 ; thick++){
      if(thick*k>l){
        break ;
      }
      for(int thin=0 ; thin<=50 ; thin++){
        int height=thick*k+thin+(thick+thin-1);
        if(height<=0){
          continue ;
        }
        if(height>l){
          break ;
        }
        result+=combination(thick+thin,thick);
      }
    }
    System.out.println(result);
  }
  static long combination(int n,int m){
    BigInteger result=new BigInteger("1");
    int j=m ;
    for(int i=0 ; i<m ; i++){
      result=result.multiply(BigInteger.valueOf(n-i));
    }
    for(int i=1 ; i<=m ; i++){
      result=result.divide(BigInteger.valueOf(i));
    }
    return result.longValue();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var result : long ; result := 0 ;
        var thick : int ; thick := 0 ; while thick <= 50 do ( (     if (thick * k > l) then (     break ) else skip ; 
         var thin : int ; thin := 0 ; while thin <= 50 do ( (     var height : int ; height := thick * k + thin + (thick + thin - 1) ;
     if (height <= 0) then (     continue ) else skip ; 
     if (height > l) then (     break ) else skip ; 
     result := result+(combination(thick + thin, thick)) )  ;     thin := thin + 1 ) )  ;     thick := thick + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation combination( n : int, m : int) : long
  pre: true
  post: true
  activity: (     var result : long ; result := long("1") ;
     var j : int ; j := m ;
        var i : int ; i := 0 ; while i < m do ( (     result := result.multiply((n - i + "")->toLong()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= m do ( (     result := result.divide((i + "")->toLong()) )  ;     i := i + 1 ) ; 
    return result->oclAsType(long) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    int n=sc.nextInt();
    int k=sc.nextInt();
    for(int i=0 ; i<k ; i++){
      int x=sc.nextInt()-1 ;
      int y=sc.nextInt()-1 ;
      int xx=min(x,n-1-x);
      int yy=min(y,n-1-y);
      println((min(xx,yy)% 3+1)+"");
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < k do ( (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
     var y : int ; y := sc.getCurrent()->toInteger() - 1 ;
    var xx : int ; xx := min(x, n - 1 - x) ;
    var yy : int ; yy := min(y, n - 1 - y) ;
    execute println((Set{xx, yy}->min() mod 3 + 1) + "") ; 
 )  ;     i := i + 1 ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int diff ;
    int c=2 ;
    int a=2 ;
    int sum=0 ;
    char answer[]=sc.next().toCharArray();
    char names[][]=new char[n][];
    for(int i=0 ; i<n ; i++){
      names[i]=sc.next().toCharArray();
    }
    for(int i=0 ; i<n ; i++){
      c=2 ;
      a=2 ;
      search : for(int k=0 ;
      k<names[i] .length ;
      k++){
        if(names[i][k]==answer[0]){
          for(int j=k+1 ; j<names[i] .length ; j++){
            if(names[i][j]==answer[1]){
              diff=j-k ;
              for(int h=j+diff ; h<names[i] .length ; h+=diff){
                if(a==answer.length){
                  sum++;
                  break search ;
                }
                else if(names[i][h]==answer[c]){
                  c++;
                  a++;
                }
                else {
                  c=2 ;
                  a=2 ;
                  break ;
                }
              }
              if(a==answer.length){
                sum++;
                break search ;
              }
            }
            else {
            }
          }
        }
        else {
        }
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var diff : int ;
    var c : int ; c := 2 ;
    var a : int ; a := 2 ;
    var sum : int ; sum := 0 ;
    var answer : Sequence(String) ; answer := sc.getCurrent()->characters() ;
    var names : Sequence(Sequence(String)) ; names := Integer.subrange(1,n)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < n do ( (     names[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     c := 2 ; 
     a := 2 ; 
         var k : int ; k := 0 ; while k < names[i+1]->size() do ( (     if (names[i+1][k+1] = answer[0+1]) then (         var j : int ; j := k + 1 ; while j < names[i+1]->size() do ( (     if (names[i+1][j+1] = answer[1+1]) then (     diff := j - k ; 
         var h : int ; h := j + diff ; while h < names[i+1]->size() do ( (     if (a = answer->size()) then (     sum := sum + 1 ; 
     break ) else     if (names[i+1][h+1] = answer[c+1]) then (     c := c + 1 ; 
     a := a + 1 ) else (     c := 2 ; 
     a := 2 ; 
     break ) ;  )  ;     h := h+(diff) ) ; 
     if (a = answer->size()) then (     sum := sum + 1 ; 
     break ) else skip ) else skip )  ;     j := j + 1 ) ) else skip )  ;     k := k + 1 ) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] shop=sc.next().toCharArray();
    String[] list=new String[n];
    boolean[] boo=new boolean[n];
    for(int i=0 ; i<n ; i++)list[i]=sc.next();
    int cnt=0 ;
    for(int i=0 ; i<50 ; i++){
      for(int k=0 ; k<n ; k++){
        if(boo[k])continue ;
        char[] c=list[k] .toCharArray();
        for(int l=0 ; l<c.length ; l++){
          for(int j=0 ; j<shop.length ; j++){
            int idx=i*j+j+l ;
            if(idx>=c.length)break ;
            if(c[idx]!=shop[j])break ;
            if(j==shop.length-1)boo[k]=true ;
          }
          if(boo[k])break ;
        }
      }
    }
    for(int i=0 ; i<boo.length ; i++){
      if(boo[i])cnt++;
    }
    System.out.println(cnt);
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var shop : Sequence(String) ; shop := sc.getCurrent()->characters() ;
    var list : Sequence(String) ; list := Integer.subrange(1,n)->collect(null) ;
    var boo : Sequence(boolean) ; boo := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n do (     list[i+1] := sc.getCurrent() ;  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < 50 do ( (         var k : int ; k := 0 ; while k < n do ( (     if (boo[k+1]) then     continue else skip ; 
     var c : Sequence(String) ; c := list[k+1]->characters() ;
         var l : int ; l := 0 ; while l < c->size() do ( (         var j : int ; j := 0 ; while j < shop->size() do ( (     var idx : int ; idx := i * j + j + l ;
     if (idx >= c->size()) then     break else skip ; 
     if (c[idx+1] /= shop[j+1]) then     break else skip ; 
     if (j = shop->size() - 1) then     boo[k+1] := true ; else skip )  ;     j := j + 1 ) ; 
     if (boo[k+1]) then     break else skip )  ;     l := l + 1 ) )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < boo->size() do ( (     if (boo[i+1]) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static String tidyNum(String str1,int len){
    char[] str=str1.toCharArray();
    for(int i=len-2 ; i>=0 ; i--){
      if(str[i]>str[i+1]){
        str[i]--;
        for(int j=i+1 ; j<len ; j++)str[j]='9' ;
      }
    }
    return String.valueOf(str);
  }
  public static void main(String[] args){
    String str="11333445538" ;
    int len=str.length();
    System.out.println(tidyNum(str,len));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation tidyNum( str1 : String, len : int) : String
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := str1->characters() ;
         var i : int ; i := len - 2 ; while i >= 0 do ( (     if (str[i+1] > str[i + 1+1]) then (     str[i+1] := str[i+1] - 1 ; 
         var j : int ; j := i + 1 ; while j < len do (     str[j+1] := '9' ;  ;     j := j + 1 ) ) else skip )  ;     i := i - 1 ) ; 
     return (str)->sum()  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "11333445538" ;
     var len : int ; len := str->size() ;
     OclFile["System.out"].println(tidyNum(str, len)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static boolean paddingcheck(String tar,String str,int n,int pad){
    boolean f=false ;
    for(int i=2 ; i<tar.length(); i++){
      if(n+i*pad>=str.length()){
        f=false ;
        break ;
      }
      if(tar.charAt(i)==str.charAt(n+i*pad))f=true ;
      else {
        f=false ;
        break ;
      }
    }
    return f ;
  }
  static boolean search(String tar,String str){
    boolean f=false ;
    for(int j=0 ; j<str.length(); j++){
      if(tar.equals(str))return true ;
      if(tar.charAt(0)==str.charAt(j)){
        int cnt=0 ;
        for(int i=j+1 ; i<str.length(); i++){
          cnt++;
          if(str.length()<j+cnt)continue ;
          if(tar.charAt(1)==str.charAt(i)){
            if((j+tar.length()-1*cnt)>str.length())break ;
            f=paddingcheck(tar,str,j,cnt);
            if(f==true)return f ;
          }
        }
      }
    }
    return f ;
  }
  void doIt(){
    int n=sc.nextInt();
    int ans=0 ;
    String tar=sc.next();
    for(int i=0 ; i<n ; ++i){
      String s=sc.next();
      if(search(tar,s))ans++;
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation paddingcheck( tar : String, str : String, n : int, pad : int) : boolean
  pre: true
  post: true
  activity: (     var f : boolean ; f := false ;
         var i : int ; i := 2 ; while i < tar->size() do ( (     if (n + i * pad >= str->size()) then (     f := false ; 
     break ) else skip ; 
     if (tar->at(i+1) = str->at(n + i * pad+1)) then     f := true ; else (     f := false ; 
     break ) )  ;     i := i + 1 ) ; 
     return f );
  static   operation search( tar : String, str : String) : boolean
  pre: true
  post: true
  activity: (     var f : boolean ; f := false ;
         var j : int ; j := 0 ; while j < str->size() do ( (     if (tar = str) then     return true else skip ; 
     if (tar->at(0+1) = str->at(j+1)) then (     var cnt : int ; cnt := 0 ;
         var i : int ; i := j + 1 ; while i < str->size() do ( (     cnt := cnt + 1 ; 
     if (str->size() < j + cnt) then     continue else skip ; 
     if (tar->at(1+1) = str->at(i+1)) then (     if ((j + tar->size() - 1 * cnt) > str->size()) then     break else skip ; 
     f := paddingcheck(tar, str, j, cnt) ; 
     if (f = true) then     return f else skip ) else skip )  ;     i := i + 1 ) ) else skip )  ;     j := j + 1 ) ; 
     return f );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ans : int ; ans := 0 ;
    var tar : String ; tar := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
     if (search(tar, s)) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int N=parseInt(br.readLine());
    String dst=br.readLine();
    char top=dst.charAt(0);
    int count=0 ;
    for(int i=0 ; i<N ; i++){
      String src=br.readLine();
      outer1 : for(int j=0 ;
      j<src.length();
      j++){
        outer2 : if(src.charAt(j)==top){
          for(int k=0 ; ; k++){
            for(int l=0 ; l<dst.length(); l++){
              if(j+l+(k*l)>=src.length()){
                break outer2 ;
              }
              if(dst.charAt(l)!=src.charAt(j+l+(k*l)))break ;
              if(l==dst.length()-1){
                count++;
                break outer1 ;
              }
            }
          }
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var N : int ; N := parseInt(br.readLine()) ;
    var dst : String ; dst := br.readLine() ;
    var top : String ; top := dst->at(0+1) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var src : String ; src := br.readLine() ;
         var j : int ; j := 0 ; while j < src->size() do ( (     if (src->at(j+1) = top) then (         var k : int ; k := 0 ; while true do ( (         var l : int ; l := 0 ; while l < dst->size() do ( (     if (j + l + (k * l) >= src->size()) then (     break ) else skip ; 
     if (dst->at(l+1) /= src->at(j + l + (k * l)+1)) then     break else skip ; 
     if (l = dst->size() - 1) then (     count := count + 1 ; 
     break ) else skip )  ;     l := l + 1 ) )  ;     k := k + 1 ) ) else skip ; )  ;     j := j + 1 ) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private boolean stringMach(char[] base,String boardStr){
    int boardStrlen=boardStr.length()-1 ;
    int baseIndex=0 ;
    for(int i=0 ; i<boardStrlen ; i++){
      if(base[baseIndex]==boardStr.charAt(i)){
        baseIndex++;
        for(int j=i+1 ; j<boardStrlen ; j++){
          if(base[baseIndex]==boardStr.charAt(j)){
            int margin=j-i ;
            baseIndex++;
            for(int k=j+margin ; k<=boardStrlen ; k+=margin){
              if(base[baseIndex]==boardStr.charAt(k)){
                baseIndex++;
              }
              else k=boardStrlen ;
              if(baseIndex==base.length){
                return true ;
              }
            }
          }
          baseIndex=1 ;
        }
      }
      baseIndex=0 ;
    }
    return false ;
  }
  public void doIt(){
    Scanner sc=new Scanner(System.in);
    int boardNam=sc.nextInt();
    String[] board=new String[boardNam];
    char base[]=sc.next().toCharArray();
    int trueNum=0 ;
    for(int i=0 ; i<boardNam ; i++){
      board[i]=sc.next();
    }
    for(int i=0 ; i<boardNam ; i++){
      if(stringMach(base,board[i])){
        trueNum++;
      }
    }
    System.out.println(trueNum);
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation stringMach( base : Sequence(String), boardStr : String) : boolean
  pre: true
  post: true
  activity: (     var boardStrlen : int ; boardStrlen := boardStr->size() - 1 ;
     var baseIndex : int ; baseIndex := 0 ;
         var i : int ; i := 0 ; while i < boardStrlen do ( (     if (base[baseIndex+1] = boardStr->at(i+1)) then (     baseIndex := baseIndex + 1 ; 
         var j : int ; j := i + 1 ; while j < boardStrlen do ( (     if (base[baseIndex+1] = boardStr->at(j+1)) then (     var margin : int ; margin := j - i ;
     baseIndex := baseIndex + 1 ; 
         var k : int ; k := j + margin ; while k <= boardStrlen do ( (     if (base[baseIndex+1] = boardStr->at(k+1)) then (     baseIndex := baseIndex + 1 ) else     k := boardStrlen ; ;  
     if (baseIndex = base->size()) then (     return true ) else skip )  ;     k := k+(margin) ) ) else skip ; 
     baseIndex := 1 )  ;     j := j + 1 ) ) else skip ; 
     baseIndex := 0 )  ;     i := i + 1 ) ; 
     return false );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var boardNam : int ; boardNam := sc.getCurrent()->toInteger() ;
    var board : Sequence(String) ; board := Integer.subrange(1,boardNam)->collect(null) ;
    var base : Sequence(String) ; base := sc.getCurrent()->characters() ;
    var trueNum : int ; trueNum := 0 ;
        var i : int ; i := 0 ; while i < boardNam do ( (     board[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < boardNam do ( (     if (stringMach(base, board[i+1])) then (     trueNum := trueNum + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(trueNum) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF218_D2_A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int peaksNum=scanner.nextInt();
    int modified=scanner.nextInt();
    int[] peaks=new int[peaksNum*2+1];
    for(int i=0 ; i<peaksNum*2+1 ; i++){
      peaks[i]=scanner.nextInt();
    }
    for(int i=peaksNum*2 ; i>=0 ; i--){
      if(modified!=0 && i % 2==1){
        if((peaks[i-1]<peaks[i]-1 && peaks[i]-1>peaks[i+1])){
          peaks[i]-=1 ;
          modified--;
        }
      }
    }
    for(int i=0 ; i<peaksNum*2+1 ; i++){
      System.out.print(peaks[i]+" ");
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF218_D2_A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var peaksNum : int ; peaksNum := scanner.getCurrent()->toInteger() ;
    var modified : int ; modified := scanner.getCurrent()->toInteger() ;
    var peaks : Sequence(int) ; peaks := Integer.subrange(1,peaksNum * 2 + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < peaksNum * 2 + 1 do ( (     peaks[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := peaksNum * 2 ; while i >= 0 do ( (     if (modified /= 0 & i mod 2 = 1) then (     if ((peaks[i - 1+1] < peaks[i+1] - 1 & peaks[i+1] - 1 > peaks[i + 1+1])) then (     peaks[i+1] := peaks[i+1]-(1) ; 
     modified := modified - 1 ) else skip ) else skip )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < peaksNum * 2 + 1 do ( (     OclFile["System.out"].print(peaks[i+1] + " ") )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int[] blood=new int[4];
    Arrays.fill(blood,0);
    while(sc.hasNext()){
      String[] str=sc.next().split(",");
      if(str[1] .equals("A")){
        blood[0]++;
      }
      else if(str[1] .equals("B")){
        blood[1]++;
      }
      else if(str[1] .equals("AB")){
        blood[2]++;
      }
      else {
        blood[3]++;
      }
    }
    for(int $=0 ; $<blood.length ; $++){
      System.out.println(blood[$]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var blood : Sequence(int) ; blood := Integer.subrange(1,4)->collect(0) ;
     blood := blood->collect(0) ; 
     while (sc.hasNext()) do (     var str : Sequence(String) ; str := sc.getCurrent()->split(",") ;
     if (str[1+1] = "A") then (     blood[0+1] := blood[0+1] + 1 ) else     if (str[1+1] = "B") then (     blood[1+1] := blood[1+1] + 1 ) else     if (str[1+1] = "AB") then (     blood[2+1] := blood[2+1] + 1 ) else (     blood[3+1] := blood[3+1] + 1 ) ;  ;  ) ; 
         var $ : int ; $ := 0 ; while $ < blood->size() do ( (     OclFile["System.out"].println(blood[$+1]) )  ;     $ := $ + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.*;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  static void tr(Object...os){
    System.err.println(deepToString(os));
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    Map<String,Integer>toi=new HashMap<String,Integer>();
    toi.put("A",0);
    toi.put("B",1);
    toi.put("AB",2);
    toi.put("O",3);
    int[] ans=new int[4];
    for(; sc.hasNext(); ){
      String[] s=sc.next().split(",");
++ans[toi.get(s[1])];
    }
    for(int i=0 ; i<4 ; i++){
      System.out.println(ans[i]);
    }
  }
  public static void main(String[] args)throws Exception {
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var toi : Map(String,int) ; toi := Map{} ;
    toi := toi->union(Map{"A" |-> 0}) ; 
    toi := toi->union(Map{"B" |-> 1}) ; 
    toi := toi->union(Map{"AB" |-> 2}) ; 
    toi := toi->union(Map{"O" |-> 3}) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,4)->collect(0) ;
      while sc.hasNext() do ( (     var s : Sequence(String) ; s := sc.getCurrent()->split(",") ;
     ans[toi->at(s[1+1])+1] := ans[toi->at(s[1+1])+1] + 1 )  ) ; 
        var i : int ; i := 0 ; while i < 4 do ( (     OclFile["System.out"].println(ans[i+1]) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    int i=0,length=0,dam=0 ;
    boolean first=true ;
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String line ;
      while((line=br.readLine())!=null){
        if(first){
          length=Integer.parseInt(line);
          first=false ;
          line=br.readLine();
          dam=Integer.parseInt(line);
        }
        else {
          String[] tokens=line.split(" ");
          int a=Integer.parseInt(tokens[0]);
          int b=Integer.parseInt(tokens[1]);
          if(length % 2==0){
            a=length/2<a ? length-a+1 : a ;
            b=length/2<b ? length-b+1 : b ;
          }
          else {
            if(length/2+1!=a){
              a=length/2<a ? length-a+1 : a ;
            }
            if(length/2+1!=b){
              b=length/2<b ? length-b+1 : b ;
            }
          }
          System.out.println(Integer.min(a,b)% 3==0 ? 3 : Integer.min(a,b)% 3);
          i++;
          if(i==dam){
            break ;
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var length : int ; length := 0 ;
    var dam : int ; dam := 0 ;
     var first : boolean ; first := true ;
     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     if (first) then (     length := (line)->toInteger() ; 
     first := false ; 
     line := br.readLine() ; 
     dam := (line)->toInteger() ) else (     var tokens : Sequence(String) ; tokens := line->split(" ") ;
     var a : int ; a := (tokens[0+1])->toInteger() ;
    var b : int ; b := (tokens[1+1])->toInteger() ;
    if (length mod 2 = 0) then (     a := if length / 2 < a then length - a + 1 else a endif ; 
     b := if length / 2 < b then length - b + 1 else b endif ) else (     if (length / 2 + 1 /= a) then (     a := if length / 2 < a then length - a + 1 else a endif ) else skip ; 
     if (length / 2 + 1 /= b) then (     b := if length / 2 < b then length - b + 1 else b endif ) else skip ) ;  
    OclFile["System.out"].println(if Set{a, b}->min() mod 3 = 0 then 3 else Set{a, b}->min() mod 3 endif) ; 
    i := i + 1 ; 
    if (i = dam) then (     break ) else skip ; 
 ) ) ;     line := br.readLine() ;
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    HashMap<String,Integer>map=new HashMap<String,Integer>();
    map.put("A",0);
    map.put("B",0);
    map.put("O",0);
    map.put("AB",0);
    while(true){
      String str=br.readLine();
      if(str==null){
        break ;
      }
      String[] tmpArray=str.split(",");
      String type=tmpArray[1];
      map.put(type,map.get(type)+1);
    }
    System.out.println(map.get("A"));
    System.out.println(map.get("B"));
    System.out.println(map.get("AB"));
    System.out.println(map.get("O"));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var map : Map(String,int) ; map := Map{} ;
    map := map->union(Map{"A" |-> 0}) ; 
    map := map->union(Map{"B" |-> 0}) ; 
    map := map->union(Map{"O" |-> 0}) ; 
    map := map->union(Map{"AB" |-> 0}) ; 
    while (true) do (     var str : String ; str := br.readLine() ;
     if (str = null) then (     break ) else skip ; 
    var tmpArray : Sequence(String) ; tmpArray := str->split(",") ;
    var type : String ; type := tmpArray[1+1] ;
    map := map->union(Map{type |-> map->at(type) + 1}) ; 
 ) ; 
    OclFile["System.out"].println(map->at("A")) ; 
    OclFile["System.out"].println(map->at("B")) ; 
    OclFile["System.out"].println(map->at("AB")) ; 
    OclFile["System.out"].println(map->at("O")) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  void run(){
    sc=new Scanner(System.in);
    int a=0,b=0,ab=0,o=0 ;
    for(; sc.hasNext(); ){
      String s=sc.nextLine().split(",")[1];
      if(s.equals("A"))a++;
      else if(s.equals("B"))b++;
      else if(s.equals("AB"))ab++;
      else o++;
    }
    println(a+"");
    println(b+"");
    println(ab+"");
    println(o+"");
    sc.close();
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var a : int ; a := 0 ;
    var b : int ; b := 0 ;
    var ab : int ; ab := 0 ;
    var o : int ; o := 0 ;
      while sc.hasNext() do ( (     var s : String ; s := sc.nextLine()->split(",")[1+1] ;
     if (s = "A") then     a := a + 1 ; else     if (s = "B") then     b := b + 1 else     if (s = "AB") then     ab := ab + 1 else     o := o + 1 ; ;  ;  )  ) ; 
    execute println(a + "") ; 
    execute println(b + "") ; 
    execute println(ab + "") ; 
    execute println(o + "") ; 
    skip ; 
 );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  static final int A=0 ;
  static final int B=1 ;
  static final int AB=2 ;
  static final int O=3 ;
  public static void main(String[] args){
    final Scanner stdin=new Scanner(System.in);
    int[] sum=new int[4];
    while(stdin.hasNextLine()){
      final String[] input=stdin.nextLine().split(",");
      if("A".equals(input[1])){
        sum[A]++;
      }
      else if("B".equals(input[1])){
        sum[B]++;
      }
      else if("AB".equals(input[1])){
        sum[AB]++;
      }
      else {
        sum[O]++;
      }
    }
    System.out.println(sum[A]);
    System.out.println(sum[B]);
    System.out.println(sum[AB]);
    System.out.println(sum[O]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute A : int := 0;
  static    attribute B : int := 1;
  static    attribute AB : int := 2;
  static    attribute O : int := 3;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sum : Sequence(int) ; sum := Integer.subrange(1,4)->collect(0) ;
    while (stdin.hasNextLine()) do (     var input : Sequence(String) ; input := stdin.nextLine()->split(",") ;
     if ("A" = input[1+1]) then (     sum[A+1] := sum[A+1] + 1 ) else     if ("B" = input[1+1]) then (     sum[B+1] := sum[B+1] + 1 ) else     if ("AB" = input[1+1]) then (     sum[AB+1] := sum[AB+1] + 1 ) else (     sum[O+1] := sum[O+1] + 1 ) ;  ;  ) ; 
    OclFile["System.out"].println(sum[A+1]) ; 
    OclFile["System.out"].println(sum[B+1]) ; 
    OclFile["System.out"].println(sum[AB+1]) ; 
    OclFile["System.out"].println(sum[O+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Solution {
  public ListNode addTwoNumbers(ListNode l1,ListNode l2){
    ListNode dummyHead=new ListNode(0);
    ListNode p=l1,q=l2,curr=dummyHead ;
    int carry=0 ;
    while(p!=null || q!=null){
      int x=(p!=null)? p.val : 0 ;
      int y=(q!=null)? q.val : 0 ;
      int digit=carry+x+y ;
      carry=digit/10 ;
      curr.next=new ListNode(digit % 10);
      curr=curr.next ;
      if(p!=null)p=p.next ;
      if(q!=null)q=q.next ;
    }
    if(carry>0){
      curr.next=new ListNode(carry);
    }
    return dummyHead.next ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation addTwoNumbers( l1 : ListNode, l2 : ListNode) : ListNode
  pre: true
  post: true
  activity: (     var dummyHead : ListNode ; dummyHead := ListNode.newListNode(0) ;
     var p : ListNode ; p := l1 ;
    var q : ListNode ; q := l2 ;
    var curr : ListNode ; curr := dummyHead ;
    var carry : int ; carry := 0 ;
    while (p /= null or q /= null) do (     var x : int ; x := if (p /= null) then p.val else 0 endif ;
     var y : int ; y := if (q /= null) then q.val else 0 endif ;
    var digit : int ; digit := carry + x + y ;
    carry := digit / 10 ; 
    curr.next := ListNode.newListNode(digit mod 10) ; 
    curr := curr.next ; 
    if (p /= null) then     p := p.next ; else skip ; 
    if (q /= null) then     q := q.next ; else skip ; 
 ) ; 
    if (carry > 0) then (     curr.next := ListNode.newListNode(carry) ) else skip ; 
    return dummyHead.next 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static long binomialCoeff(int n,int k){
    long res=1 ;
    if(k>n-k)k=n-k ;
    for(int i=0 ; i<k ; ++i){
      res*=(n-i);
      res/=(i+1);
    }
    return res ;
  }
  static long countPaths(int x1,int y1,int x2,int y2){
    int m=Math.abs(x1-x2);
    int n=Math.abs(y1-y2);
    return(binomialCoeff(m+n,n));
  }
  public static void main(String[] args){
    int x1=2,y1=3,x2=4,y2=5 ;
    System.out.println(countPaths(x1,y1,x2,y2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation binomialCoeff( n : int, k : int) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     if (k > n - k) then     k := n - k ; else skip ; 
         var i : int ; i := 0 ; while i < k do ( (     res := res*((n - i)) ; 
     res := res/((i + 1)) )  ;     i := i + 1 ) ; 
     return res );
  static   operation countPaths( x1 : int, y1 : int, x2 : int, y2 : int) : long
  pre: true
  post: true
  activity: (     var m : int ; m := if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif ;
     var n : int ; n := if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif ;
     return (binomialCoeff(m + n, n)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x1 : int ; x1 := 2 ;
    var y1 : int ; y1 := 3 ;
    var x2 : int ; x2 := 4 ;
    var y2 : int ; y2 := 5 ;
     OclFile["System.out"].println(countPaths(x1, y1, x2, y2)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int breakSum(int n){
    if(n==0 || n==1)return n ;
    return Math.max((breakSum(n/2)+breakSum(n/3)+breakSum(n/4)),n);
  }
  public static void main(String[] args){
    int n=12 ;
    System.out.println(breakSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation breakSum( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0 or n = 1) then     return n else skip ; 
     return Set{(breakSum(n / 2) + breakSum(n / 3) + breakSum(n / 4)), n}->max() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     OclFile["System.out"].println(breakSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class x809B {
  static BufferedReader infile ;
  public static void main(String hi[])throws Exception {
    infile=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(infile.readLine());
    N=Integer.parseInt(st.nextToken());
    st.nextToken();
    res=new ArrayList<Integer>();
    find(1,N);
    int first=res.get(0);
    if(first>1)find(1,first-1);
    if(first<N)find(first+1,N);
  }
  static int N ;
  static ArrayList<Integer>res ;
  public static void find(int left,int right)throws Exception {
    if(left==right){
      boolean works=true ;
      if(left>1 && query(left,left-1)==1)works=false ;
      if(left<N && query(left,left+1)==1)works=false ;
      if(works){
        res.add(left);
        if(res.size()==2){
          System.out.println("2 "+res.get(0)+" "+res.get(1));
          System.exit(0);
        }
      }
      return ;
    }
    int mid=(left+right)/2 ;
    if(query(mid,mid+1)==0)find(left,mid);
    else find(mid+1,right);
  }
  public static int query(int a,int b)throws Exception {
    System.out.println("1 "+a+" "+b);
    System.out.flush();
    String s=infile.readLine();
    if(s.charAt(0)=='T')return 0 ;
    return 1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class x809B {
  static   attribute infile : OclFile;
  static   operation main( hi : Sequence(String)) : void
  pre: true
  post: true
  activity: (     infile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     var st : OclIterator ; st := OclIterator.newOclIterator_String(infile.readLine()) ;
    N := (st.next())->toInteger() ; 
    st.next() ; 
    res := Sequence{} ; 
    execute find(1, N) ; 
    var first : int ; first := res->at(0+1) ;
    if (first > 1) then     execute find(1, first - 1) ; else skip ; 
    if (first < N) then     execute find(first + 1, N) ; else skip ; 
 );
  static   attribute N : int;
  static   attribute res : Sequence(int);
  static   operation find( left : int, right : int) : void
  pre: true
  post: true
  activity: (     if (left = right) then (     var works : boolean ; works := true ;
     if (left > 1 & query(left, left - 1) = 1) then     works := false ; else skip ; 
    if (left < N & query(left, left + 1) = 1) then     works := false ; else skip ; 
    if (works) then (     res := res->including(left) ; 
     if (res->size() = 2) then (     OclFile["System.out"].println("2 " + res->at(0+1) + " " + res->at(1+1)) ; 
 OclProcess.exit(0) ) else skip ) else skip ; 
    return 
 ) else skip ; 
     var mid : int ; mid := (left + right) / 2 ;
     if (query(mid, mid + 1) = 0) then     execute find(left, mid) ; else     execute find(mid + 1, right) ; );
  static   operation query( a : int, b : int) : int
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("1 " + a + " " + b) ; 
     OclFile["System.out"].flush() ; 
    var s : String ; s := infile.readLine() ;
    if (s->at(0+1) = 'T') then     return 0 else skip ; 
    return 1 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GladToSeeYou {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    int k=sc.nextInt();
    int i=search1(0,n);
    int j=search1(0,i-1);
    if(j==0 || ! query(j,i))j=search2(i,n);
    System.out.println("2 "+i+" "+j);
  }
  public static boolean query(int x,int y){
    System.out.println("1 "+x+" "+y);
    return sc.next().equals("TAK");
  }
  public static int search1(int x,int y){
    int low=x ;
    int high=y ;
    while(low+1<high){
      int i=(low+high)/2 ;
      if(query(i,i+1))high=i ;
      else low=i ;
    }
    return high ;
  }
  public static int search2(int x,int y){
    int low=x ;
    int high=y ;
    while(low+1<high){
      int i=(low+high)/2 ;
      if(query(i+1,i))low=i ;
      else high=i ;
    }
    return high ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class GladToSeeYou {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var i : int ; i := search1(0, n) ;
    var j : int ; j := search1(0, i - 1) ;
    if (j = 0 or not(query(j, i))) then     j := search2(i, n) ; else skip ; 
    OclFile["System.out"].println("2 " + i + " " + j) ; 
 );
  static   operation query( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("1 " + x + " " + y) ; 
     return sc.getCurrent() = "TAK" );
  static   operation search1( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var low : int ; low := x ;
     var high : int ; high := y ;
     while (low + 1 < high) do (     var i : int ; i := (low + high) / 2 ;
     if (query(i, i + 1)) then     high := i ; else     low := i ; ) ; 
     return high );
  static   operation search2( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var low : int ; low := x ;
     var high : int ; high := y ;
     while (low + 1 < high) do (     var i : int ; i := (low + high) / 2 ;
     if (query(i + 1, i)) then     low := i ; else     high := i ; ) ; 
     return high );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF809B extends PrintWriter {
  CF809B(){
    super(System.out,true);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    CF809B o=new CF809B();
    o.main();
    o.flush();
  }
  boolean query(int i,int j){
    println("1 "+i+" "+j);
    return sc.next().equals("TAK");
  }
  int search(int lower,int upper){
    while(upper-lower>1){
      int i=(lower+upper)/2 ;
      if(query(i,i+1))upper=i ;
      else lower=i ;
    }
    return upper ;
  }
  int search_(int lower,int upper){
    while(upper-lower>1){
      int i=(lower+upper)/2 ;
      if(query(i+1,i))lower=i ;
      else upper=i ;
    }
    return upper ;
  }
  void main(){
    int n=sc.nextInt();
    int k=sc.nextInt();
    int i=search(0,n);
    int j=search(0,i-1);
    if(j==0 || ! query(j,i))j=search_(i,n);
    println("2 "+i+" "+j);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF809B extends OclFile {
   static operation newCF809B() : CF809B
  pre: true
  post: true
  activity:
  ( var self : CF809B ;
    self := createCF809B();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"], true) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : CF809B ; o := CF809B.newCF809B() ;
     o.main() ; 
     o.flush() );
   operation query( i : int, j : int) : boolean
  pre: true
  post: true
  activity: (     execute println("1 " + i + " " + j) ; 
     return sc.getCurrent() = "TAK" );
   operation search( lower : int, upper : int) : int
  pre: true
  post: true
  activity: (     while (upper - lower > 1) do (     var i : int ; i := (lower + upper) / 2 ;
     if (query(i, i + 1)) then     upper := i ; else     lower := i ; ) ; 
     return upper );
   operation search_( lower : int, upper : int) : int
  pre: true
  post: true
  activity: (     while (upper - lower > 1) do (     var i : int ; i := (lower + upper) / 2 ;
     if (query(i + 1, i)) then     lower := i ; else     upper := i ; ) ; 
     return upper );
   operation main() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var i : int ; i := search(0, n) ;
    var j : int ; j := search(0, i - 1) ;
    if (j = 0 or not(query(j, i))) then     j := search_(i, n) ; else skip ; 
    execute println("2 " + i + " " + j) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int n=3 ;
  static void preComputeXor(int arr[][],int prefix_xor[][]){
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++){
      if(j==0)prefix_xor[i][j]=arr[i][j];
      else prefix_xor[i][j]=(prefix_xor[i][j-1] ^ arr[i][j]);
    }
    for(int i=0 ; i<n ; i++)for(int j=1 ; j<n ; j++)prefix_xor[j][i]=(prefix_xor[j-1][i] ^ prefix_xor[j][i]);
  }
  static int ansQuerie(int prefix_xor[][],int x1,int y1,int x2,int y2){
    int xor_1=0,xor_2=0,xor_3=0 ;
    if(x1!=0)xor_1=prefix_xor[x1-1][y2];
    if(y1!=0)xor_2=prefix_xor[x2][y1-1];
    if(x1!=0 && y1!=0)xor_3=prefix_xor[x1-1][y1-1];
    return((prefix_xor[x2][y2] ^ xor_1)^(xor_2 ^ xor_3));
  }
  public static void main(String[] args){
    int arr[][]=new int[][] {
      {
        1,2,3 },{
          4,5,6 },{
            7,8,9 }
          };
          int prefix_xor[][]=new int[n][n];
          preComputeXor(arr,prefix_xor);
          System.out.println(ansQuerie(prefix_xor,1,1,2,2));
          System.out.println(ansQuerie(prefix_xor,1,2,2,2));
        }
      }

------------------------------------------------------------
OCL File:
---------
class GfG {
  static   attribute n : int := 3;
  static   operation preComputeXor( arr : Sequence(Sequence(int)), prefix_xor : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do ( (     if (j = 0) then     prefix_xor[i+1][j+1] := arr[i+1][j+1] ; else     prefix_xor[i+1][j+1] := (prefix_xor[i+1][j - 1+1] xor arr[i+1][j+1]) ; )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 1 ; while j < n do (     prefix_xor[j+1][i+1] := (prefix_xor[j - 1+1][i+1] xor prefix_xor[j+1][i+1]) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) );
  static   operation ansQuerie( prefix_xor : Sequence(Sequence(int)), x1 : int, y1 : int, x2 : int, y2 : int) : int
  pre: true
  post: true
  activity: (     var xor    var xorint : int ; xorint := 0 : int ; xor    var xorint : int ; xorint := 0 := 0 ;
    var xor0 : int ; xor0 := 0 ;
    var xor_3 : int ; xor_3 := 0 ;
     if (x1 /= 0) then     xorxor_1 := prefix_xor[x1 - 1+1][y2+1] ; else skip ; 
    if (y1 /= 0) then     xorprefix_xor[x2+1][y1 - 1+1] := prefix_xor[x2+1][y1 - 1+1] ; else skip ; 
    if (x1 /= 0 & y1 /= 0) then     xor_3 := prefix_xor[x1 - 1+1][y1 - 1+1] ; else skip ; 
    return ((prefix_xor[x2+1][y2+1] xor xor_1) xor (MathLib.bitwiseXor(xorxor_3,xor_3))) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,2,3},Sequence{4,5,6},Sequence{7,8,9}} ;
     var prefix_xor : Sequence(Sequence(int)) ; prefix_xor := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    execute preComputeXor(arr, prefix_xor) ; 
    OclFile["System.out"].println(ansQuerie(prefix_xor, 1, 1, 2, 2)) ; 
    OclFile["System.out"].println(ansQuerie(prefix_xor, 1, 2, 2, 2)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    while(m-->0){
      int w=scanner.nextInt();
      int h=scanner.nextInt();
      int ans=Math.min(w,Math.min(n+1-w,Math.min(h,n+1-h)));
      ans %=3 ;
      System.out.println(ans==0 ? 3 : ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
         while (m > 0) do (        m := m - 1 ;     skip ; (     var w : int ; w := scanner.getCurrent()->toInteger() ;
     var h : int ; h := scanner.getCurrent()->toInteger() ;
    var ans : int ; ans := Set{w, Set{n + 1 - w, Set{h, n + 1 - h}->min()}->min()}->min() ;
    ans := ans mod 3 ; 
    OclFile["System.out"].println(if ans = 0 then 3 else ans endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int bellNumber(int n){
    int[][] bell=new int[n+1][n+1];
    bell[0][0]=1 ;
    for(int i=1 ; i<=n ; i++){
      bell[i][0]=bell[i-1][i-1];
      for(int j=1 ; j<=i ; j++)bell[i][j]=bell[i-1][j-1]+bell[i][j-1];
    }
    return bell[n][0];
  }
  public static void main(String[] args){
    for(int n=0 ; n<=5 ; n++)System.out.println("Bell Number "+n+" is "+bellNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation bellNumber( n : int) : int
  pre: true
  post: true
  activity: (     var bell : Sequence(Sequence(int)) ; bell := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
     bell[0+1][0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= n do ( (     bell[i+1][0+1] := bell[i - 1+1][i - 1+1] ; 
         var j : int ; j := 1 ; while j <= i do (     bell[i+1][j+1] := bell[i - 1+1][j - 1+1] + bell[i+1][j - 1+1] ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return bell[n+1][0+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var n : int ; n := 0 ; while n <= 5 do (     OclFile["System.out"].println("Bell Number " + n + " is " + bellNumber(n)) ;  ;     n := n + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean Survives(int n){
    for(int i=2 ; ; i++){
      if(i>n)return true ;
      if(n % i==0)return false ;
      n-=n/i ;
    }
  }
  public static void main(String[] args){
    int n=17 ;
    if(Survives(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Survives( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while true do ( (     if (i > n) then     return true else skip ; 
     if (n mod i = 0) then     return false else skip ; 
     n := n-(n / i) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 17 ;
     if (Survives(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isFactorial(int n){
    for(int i=1 ; ; i++){
      if(n % i==0){
        n/=i ;
      }
      else {
        break ;
      }
    }
    if(n==1){
      return true ;
    }
    else {
      return false ;
    }
  }
  public static void main(String[] args){
    int n=24 ;
    boolean ans=isFactorial(n);
    if(ans==true){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isFactorial( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while true do ( (     if (n mod i = 0) then (     n := n/(i) ) else (     break ) )  ;     i := i + 1 ) ; 
     if (n = 1) then (     return true ) else (     return false ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 24 ;
     var ans : boolean ; ans := isFactorial(n) ;
     if (ans = true) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean onlyFirstAndLastAreSet(int n){
    if(n==1)return true ;
    if(n==2)return false ;
    return(((n-1)&(n-2))==0);
  }
  public static void main(String[] args){
    int n=9 ;
    if(onlyFirstAndLastAreSet(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation onlyFirstAndLastAreSet( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 1) then     return true else skip ; 
     if (n = 2) then     return false else skip ; 
     return (((n - 1) & (n - 2)) = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     if (onlyFirstAndLastAreSet(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String target=(scanner.next()).toLowerCase();
    int result=0 ;
    String word="" ;
    while(true){
      word=scanner.next();
      if(word.equals("END_OF_TEXT")){
        break ;
      }
      word=word.toLowerCase();
      if(word.equals(target)){
        result++;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var target : String ; target := (scanner.getCurrent())->toLowerCase() ;
    var result : int ; result := 0 ;
    var word : String ; word := "" ;
    while (true) do (     word := scanner.getCurrent() ; 
     if (word = "END_OF_TEXT") then (     break ) else skip ; 
     word := word->toLowerCase() ; 
     if (word = target) then (     result := result + 1 ) else skip ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean adjacentSet(int n){
    int x=(n &(n>>1));
    if(x==1)return true ;
    else return false ;
  }
  public static void main(String args[]){
    int n=3 ;
    if(adjacentSet(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation adjacentSet( n : int) : boolean
  pre: true
  post: true
  activity: (     var x : int ; x := (MathLib.bitwiseAnd(n,((n/(2->pow(1)))->oclAsType(long)))) ;
     if (x = 1) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     if (adjacentSet(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printUncommon(String str1,String str2){
    int a1=0,a2=0 ;
    for(int i=0 ; i<str1.length(); i++){
      int ch=(str1.charAt(i))-'a' ;
      a1=a1 |(1<<ch);
    }
    for(int i=0 ; i<str2.length(); i++){
      int ch=(str2.charAt(i))-'a' ;
      a2=a2 |(1<<ch);
    }
    int ans=a1 ^ a2 ;
    int i=0 ;
    while(i<26){
      if(ans % 2==1){
        System.out.print((char)('a'+i));
      }
      ans=ans/2 ;
      i++;
    }
  }
  public static void main(String[] args){
    String str1="geeksforgeeks" ;
    String str2="geeksquiz" ;
    printUncommon(str1,str2);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printUncommon( str1 : String, str2 : String) : void
  pre: true
  post: true
  activity: (     var a1 : int ; a1 := 0 ;
    var a2 : int ; a2 := 0 ;
         var i : int ; i := 0 ; while i < str1->size() do ( (     var ch : int ; ch := (str1->at(i+1)) - ('a')->char2byte() ;
     a1 := MathLib.bitwiseOr(a1,((1*(2->pow(ch)))->oclAsType(long))) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < str2->size() do ( (     var ch : int ; ch := (str2->at(i+1)) - ('a')->char2byte() ;
     a2 := MathLib.bitwiseOr(a2,((1*(2->pow(ch)))->oclAsType(long))) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := MathLib.bitwiseXor(a1,a2) ;
    var i : int ; i := 0 ;
    while (i < 26) do (     if (ans mod 2 = 1) then (     OclFile["System.out"].print(('a' + i)->oclAsType(String)) ) else skip ; 
     ans := ans / 2 ; 
     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "geeksforgeeks" ;
     var str2 : String ; str2 := "geeksquiz" ;
     execute printUncommon(str1, str2) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class ClassroomWatch {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int num=in.nextInt();
    int copy=num ;
    List<Integer>result=new ArrayList<>();
    int copyOut=copy ;
    int math=Math.max(num-100,1);
    while(copy>=math){
      copy-=1 ;
      int sum=0 ;
      copyOut=copy ;
      while(copyOut>0){
        sum=sum+(copyOut % 10);
        copyOut=copyOut/10 ;
      }
      if((sum+copy)==num){
        result.add(copy);
      }
    }
    System.out.println(result.size());
    Collections.sort(result);
    for(int i=0 ; i<result.size(); i++){
      System.out.println(result.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ClassroomWatch {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := in.getCurrent()->toInteger() ;
    var copy : int ; copy := num ;
    var result : Sequence(int) ; result := Sequence{} ;
    var copyOut : int ; copyOut := copy ;
    var math : int ; math := Set{num - 100, 1}->max() ;
    while (copy >= math) do (     copy := copy-(1) ; 
     var sum : int ; sum := 0 ;
    copyOut := copy ; 
    while (copyOut > 0) do (     sum := sum + (copyOut mod 10) ; 
     copyOut := copyOut / 10 ) ; 
    if ((sum + copy) = num) then (     result := result->including(copy) ) else skip ; 
 ) ; 
    OclFile["System.out"].println(result->size()) ; 
    result := result->sort() ; 
        var i : int ; i := 0 ; while i < result->size() do ( (     OclFile["System.out"].println(result->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class ClassroomWatch {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int num=in.nextInt();
    int copy=num ;
    List<Integer>result=new ArrayList<>();
    int copyOut=copy ;
    int math=Math.max(num-100,1);
    while(copy>=math){
      copy-=1 ;
      int sum=0 ;
      copyOut=copy ;
      while(copyOut>0){
        sum=sum+(copyOut % 10);
        copyOut=copyOut/10 ;
      }
      if((sum+copy)==num){
        result.add(copy);
      }
    }
    System.out.println(result.size());
    Collections.sort(result);
    for(int i=0 ; i<result.size(); i++){
      System.out.println(result.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ClassroomWatch {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := in.getCurrent()->toInteger() ;
    var copy : int ; copy := num ;
    var result : Sequence(int) ; result := Sequence{} ;
    var copyOut : int ; copyOut := copy ;
    var math : int ; math := Set{num - 100, 1}->max() ;
    while (copy >= math) do (     copy := copy-(1) ; 
     var sum : int ; sum := 0 ;
    copyOut := copy ; 
    while (copyOut > 0) do (     sum := sum + (copyOut mod 10) ; 
     copyOut := copyOut / 10 ) ; 
    if ((sum + copy) = num) then (     result := result->including(copy) ) else skip ; 
 ) ; 
    OclFile["System.out"].println(result->size()) ; 
    result := result->sort() ; 
        var i : int ; i := 0 ; while i < result->size() do ( (     OclFile["System.out"].println(result->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class ClassroomWatch {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long n=in.nextLong();
    long sum ;
    ArrayList<Long>arrayList=new ArrayList<>();
    for(int i=100 ; i>0 ; i--){
      long j=n-i ;
      sum=sum(j);
      if(sum==i)arrayList.add(n-i);
    }
    System.out.println(arrayList.size());
    for(int i=0 ; i<arrayList.size(); i++)System.out.println(arrayList.get(i));
  }
  static long sum(long n){
    long sum=0 ;
    while(n!=0){
      long x=n % 10 ;
      sum+=x ;
      n/=10 ;
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ClassroomWatch {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toLong() ;
    var sum : long ;
    var arrayList : Sequence(long) ; arrayList := Sequence{} ;
        var i : int ; i := 100 ; while i > 0 do ( (     var j : long ; j := n - i ;
     sum := sum(j) ; 
     if (sum = i) then     arrayList := arrayList->including(n - i) ; else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(arrayList->size()) ; 
        var i : int ; i := 0 ; while i < arrayList->size() do (     OclFile["System.out"].println(arrayList->at(i+1)) ;  ;     i := i + 1 ) ; 
 );
  static   operation sum( n : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     while (n /= 0) do (     var x : long ; x := n mod 10 ;
     sum := sum+(x) ; 
     n := n/(10) ) ; 
     return sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    int l=scan.nextInt();
    int r=scan.nextInt();
    int sAll=scan.nextInt();
    int sk=scan.nextInt();
    int[] ans=getPoints(n,k,l,r,sAll,sk);
    for(int num : ans){
      System.out.print(num+" ");
    }
  }
  public static int[] getPoints(int n,int k,int l,int r,int sAll,int sk){
    int[] ans=new int[n];
    Arrays.fill(ans,l);
    sAll-=sk+(n-k)*l ;
    sk-=k*l ;
    while(sk>0){
      int idx=n-1 ;
      while(sk>0 && idx>=n-k){
        ans[idx--]++;
        sk--;
      }
    }
    while(sAll>0){
      int idx=0 ;
      while(sAll>0 && idx<n-k){
        ans[idx++]++;
        sAll--;
      }
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var l : int ; l := scan.getCurrent()->toInteger() ;
    var r : int ; r := scan.getCurrent()->toInteger() ;
    var sAll : int ; sAll := scan.getCurrent()->toInteger() ;
    var sk : int ; sk := scan.getCurrent()->toInteger() ;
    var ans : Sequence(int) ; ans := getPoints(n, k, l, r, sAll, sk) ;
    for (num : ans) do ( (     OclFile["System.out"].print(num + " ") )  ) ; 
 );
  static   operation getPoints( n : int, k : int, l : int, r : int, sAll : int, sk : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
     ans := ans->collect(l) ; 
    sAll := sAll-(sk + (n - k) * l) ; 
    sk := sk-(k * l) ; 
    while (sk > 0) do (     var idx : int ; idx := n - 1 ;
     while (sk > 0 & idx >= n - k) do (     ans[idx+1] := ans[idx+1] + 1 ; 
     sk := sk - 1 ) ) ; 
    while (sAll > 0) do (     var idx : int ; idx := 0 ;
     while (sAll > 0 & idx < n - k) do (     ans[idx+1] := ans[idx+1] + 1 ; 
     sAll := sAll - 1 ) ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ClassroomWatch {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    ArrayList<Integer>ans=solve(n);
    pw.println(ans.size());
    for(int i : ans)pw.println(i);
    pw.close();
  }
  static ArrayList<Integer>solve(int n){
    ArrayList<Integer>ans=new ArrayList<>();
    if(n<100){
      for(int i=0 ; i<=n ; i++){
        if(posi(i,n))ans.add(i);
      }
    }
    else {
      for(int i=n-100 ; i<=n ; i++){
        if(posi(i,n))ans.add(i);
      }
    }
    return ans ;
  }
  static boolean posi(int n,int N){
    int temp=n ;
    int ans=0 ;
    while(temp!=0){
      ans+=(temp % 10);
      temp/=10 ;
    }
    return(ans+n)==N ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class ClassroomWatch {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var ans : Sequence(int) ; ans := solve(n) ;
    skip ; 
    for (i : ans) do (     skip ;  ) ; 
    skip ; 
 );
  static   operation solve( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Sequence{} ;
     if (n < 100) then (         var i : int ; i := 0 ; while i <= n do ( (     if (posi(i, n)) then     ans := ans->including(i) ; else skip )  ;     i := i + 1 ) ) else (         var i : int ; i := n - 100 ; while i <= n do ( (     if (posi(i, n)) then     ans := ans->including(i) ; else skip )  ;     i := i + 1 ) ) ;  
     return ans );
  static   operation posi( n : int, N : int) : boolean
  pre: true
  post: true
  activity: (     var temp : int ; temp := n ;
     var ans : int ; ans := 0 ;
     while (temp /= 0) do (     ans := ans+((temp mod 10)) ; 
     temp := temp/(10) ) ; 
     return (ans + n) = N );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countFactors(int n){
    int factors=0 ;
    for(int i=2 ; i*i<=n ; i++){
      while(n % i==0){
        n/=i ;
        factors+=1 ;
      }
    }
    if(n!=1)factors++;
    return factors ;
  }
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  static int minOperations(int A,int B){
    int g=__gcd(A,B);
    A/=g ;
    B/=g ;
    return countFactors(A)+countFactors(B);
  }
  public static void main(String[] args){
    int A=10,B=15 ;
    System.out.println(minOperations(A,B));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countFactors( n : int) : int
  pre: true
  post: true
  activity: (     var factors : int ; factors := 0 ;
         var i : int ; i := 2 ; while i * i <= n do ( (     while (n mod i = 0) do (     n := n/(i) ; 
     factors := factors+(1) ) )  ;     i := i + 1 ) ; 
     if (n /= 1) then     factors := factors + 1 ; else skip ; 
     return factors );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation minOperations( A : int, B : int) : int
  pre: true
  post: true
  activity: (     var g : int ; g := __gcd(A, B) ;
     A := A/(g) ; 
     B := B/(g) ; 
     return countFactors(A) + countFactors(B) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 10 ;
    var B : int ; B := 15 ;
     OclFile["System.out"].println(minOperations(A, B)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int flipBit(int a){
    if(~ a==0){
      return 8*sizeof();
    }
    int currLen=0,prevLen=0,maxLen=0 ;
    while(a!=0){
      if((a & 1)==1){
        currLen++;
      }
      else if((a & 1)==0){
        prevLen=(a & 2)==0 ? 0 : currLen ;
        currLen=0 ;
      }
      maxLen=Math.max(prevLen+currLen,maxLen);
      a>>=1 ;
    }
    return maxLen+1 ;
  }
  static byte sizeof(){
    byte sizeOfInteger=8 ;
    return sizeOfInteger ;
  }
  public static void main(String[] args){
    System.out.println(flipBit(13));
    System.out.println(flipBit(1775));
    System.out.println(flipBit(15));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation flipBit( a : int) : int
  pre: true
  post: true
  activity: (     if (-(a + 1) = 0) then (     return 8 * sizeof() ) else skip ; 
     var currLen : int ; currLen := 0 ;
    var prevLen : int ; prevLen := 0 ;
    var maxLen : int ; maxLen := 0 ;
     while (a /= 0) do (     if ((a & 1) = 1) then (     currLen := currLen + 1 ) else     if ((a & 1) = 0) then (     prevLen := if (a & 2) = 0 then 0 else currLen endif ; 
     currLen := 0 ) else skip ; ;  
     maxLen := Set{prevLen + currLen, maxLen}->max() ; 
     a := a/(2->pow(1)) ) ; 
     return maxLen + 1 );
  static   operation sizeof() : int
  pre: true
  post: true
  activity: (     var sizeOfInteger : int ; sizeOfInteger := 8 ;
     return sizeOfInteger );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(flipBit(13)) ; 
     OclFile["System.out"].println(flipBit(1775)) ; 
     OclFile["System.out"].println(flipBit(15)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int printMinimumProduct(int arr[],int n){
    int first_min=Math.min(arr[0],arr[1]);
    int second_min=Math.max(arr[0],arr[1]);
    for(int i=2 ; i<n ; i++){
      if(arr[i]<first_min){
        second_min=first_min ;
        first_min=arr[i];
      }
      else if(arr[i]<second_min)second_min=arr[i];
    }
    return first_min*second_min ;
  }
  public static void main(String[] args){
    int a[]={
      11,8,5,7,5,100 };
      int n=a.length ;
      System.out.print(printMinimumProduct(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printMinimumProduct( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var first_min : int ; first_min := Set{arr[0+1], arr[1+1]}->min() ;
     var second_min : int ; second_min := Set{arr[0+1], arr[1+1]}->max() ;
         var i : int ; i := 2 ; while i < n do ( (     if (arr[i+1] < first_min) then (     second_min := first_min ; 
     first_min := arr[i+1] ) else     if (arr[i+1] < second_min) then     second_min := arr[i+1] ; else skip ; )  ;     i := i + 1 ) ; 
     return first_min * second_min );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{11,8,5,7,5,100} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(printMinimumProduct(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static String checkNumber(int N){
    int temp=N ;
    while(temp>0){
      if(temp % 1000==144)temp/=1000 ;
      else if(temp % 100==14)temp/=100 ;
      else if(temp % 10==1)temp/=10 ;
      else {
        return "NO" ;
      }
    }
    return "YES" ;
  }
  public static void main(String[] args){
    int N=1414 ;
    System.out.println(checkNumber(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkNumber( N : int) : String
  pre: true
  post: true
  activity: (     var temp : int ; temp := N ;
     while (temp > 0) do (     if (temp mod 1000 = 144) then     temp := temp/(1000) ; else     if (temp mod 100 = 14) then     temp := temp/(100) else     if (temp mod 10 = 1) then     temp := temp/(10) else (     return "NO" ) ;  ;  ) ; 
     return "YES" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 1414 ;
     OclFile["System.out"].println(checkNumber(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String W ;
    String T ;
    String str ;
    ArrayList<String>list=new ArrayList<String>();
    int count=0 ;
    str=br.readLine();
    W=str.toLowerCase();
    while(true){
      T=br.readLine();
      if(T.equals("END_OF_TEXT")){
        break ;
      }
      String strArray[]=T.split(" ");
      for(int i=0 ; i<strArray.length ; i++){
        list.add(strArray[i] .toLowerCase());
      }
    }
    for(int i=0 ; i<list.size(); i++){
      if(W.equals(list.get(i))){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var W : String ;
    var T : String ;
    var str : String ;
    var list : Sequence(String) ; list := Sequence{} ;
    var count : int ; count := 0 ;
    str := br.readLine() ; 
    W := str->toLowerCase() ; 
    while (true) do (     T := br.readLine() ; 
     if (T = "END_OF_TEXT") then (     break ) else skip ; 
     var strArray : Sequence(String) ; strArray := T->split(" ") ;
         var i : int ; i := 0 ; while i < strArray->size() do ( (     list := list->including(strArray[i+1]->toLowerCase()) )  ;     i := i + 1 ) ) ; 
        var i : int ; i := 0 ; while i < list->size() do ( (     if (W = list->at(i+1)) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class MyHashMap {
  final ListNode[] nodes=new ListNode[10000];
  public void put(int key,int value){
    int i=idx(key);
    if(nodes[i]==null)nodes[i]=new ListNode(-1,-1);
    ListNode prev=find(nodes[i],key);
    if(prev.next==null)prev.next=new ListNode(key,value);
    else prev.next.val=value ;
  }
  public int get(int key){
    int i=idx(key);
    if(nodes[i]==null)return-1 ;
    ListNode node=find(nodes[i],key);
    return node.next==null ?-1 : node.next.val ;
  }
  public void remove(int key){
    int i=idx(key);
    if(nodes[i]==null)return ;
    ListNode prev=find(nodes[i],key);
    if(prev.next==null)return ;
    prev.next=prev.next.next ;
  }
  int idx(int key){
    return Integer.hashCode(key)% nodes.length ;
  }
  ListNode find(ListNode bucket,int key){
    ListNode node=bucket,prev=null ;
    while(node!=null && node.key!=key){
      prev=node ;
      node=node.next ;
    }
    return prev ;
  }
  class ListNode {
    int key,val ;
    ListNode next ;
    ListNode(int key,int val){
      this.key=key ;
      this.val=val ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class MyHashMap {
   attribute nodes : Sequence(ListNode) := Integer.subrange(1,10000)->collect(null);
   operation put( key : int, value : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := idx(key) ;
     if (nodes[i+1] = null) then     nodes[i+1] := ListNode.newListNode(-1, -1) ; else skip ; 
     var prev : ListNode ; prev := find(nodes[i+1], key) ;
     if (prev.next = null) then     prev.next := ListNode.newListNode(key, value) ; else     prev.next.val := value ; );
   operation get( key : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := idx(key) ;
     if (nodes[i+1] = null) then     return -1 else skip ; 
     var node : ListNode ; node := find(nodes[i+1], key) ;
     return if node.next = null then -1 else node.next.val endif );
   operation remove( key : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := idx(key) ;
     if (nodes[i+1] = null) then     return else skip ; 
    var prev : ListNode ; prev := find(nodes[i+1], key) ;
    if (prev.next = null) then     return else skip ; 
    prev.next := prev.next.next ; 
 );
   operation idx( key : int) : int
  pre: true
  post: true
  activity: (     return hashCode(key) mod nodes->size() );
   operation find( bucket : ListNode, key : int) : ListNode
  pre: true
  post: true
  activity: (     var node : ListNode ; node := bucket ;
    var prev : ListNode ; prev := null ;
     while (node /= null & node.key /= key) do (     prev := node ; 
     node := node.next ) ; 
     return prev );
 class ListNode {
   attribute key : int;
   attribute next : ListNode;
   static operation newListNode( key : int, val : int) : ListNode
  pre: true
  post: true
  activity:
  ( var self : ListNode ;
    self := createListNode();
    self.initialise(key, val);
    return self );
  operation initialise( key : int, val : int) : void
  pre: true  post: true
  activity: (     self.key := key ; 
     self.val := val );
}
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n+2];
    for(int i=1 ; i<=n ; i++){
      arr[i]=sc.nextInt();
      arr[i]=Math.min(arr[i],arr[i-1]+1);
    }
    for(int i=n ; i>0 ; i--){
      arr[i]=Math.min(arr[i],arr[i+1]+1);
    }
    System.out.println(Arrays.stream(arr).max().getAsInt());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 2)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     arr[i+1] := Set{arr[i+1], arr[i - 1+1] + 1}->min() )  ;     i := i + 1 ) ; 
        var i : int ; i := n ; while i > 0 do ( (     arr[i+1] := Set{arr[i+1], arr[i + 1+1] + 1}->min() )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(stream(arr).max().getAsInt()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n+2];
    for(int i=1 ; i<=n ; i++){
      arr[i]=sc.nextInt();
    }
    int[] temp=new int[n+2];
    Arrays.fill(temp,Integer.MAX_VALUE);
    temp[0]=0 ;
    temp[n+1]=0 ;
    for(int i=1 ; i<=n ; i++){
      temp[i]=Math.min(arr[i],temp[i-1]+1);
    }
    for(int i=n ; i>=1 ; i--){
      temp[i]=Math.min(temp[i],temp[i+1]+1);
    }
    int res=0 ;
    for(int i=1 ; i<=n ; i++){
      res=Math.max(res,temp[i]);
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 2)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var temp : Sequence(int) ; temp := Integer.subrange(1,n + 2)->collect(0) ;
    temp := temp->collect(2147483647) ; 
    temp[0+1] := 0 ; 
    temp[n + 1+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (     temp[i+1] := Set{arr[i+1], temp[i - 1+1] + 1}->min() )  ;     i := i + 1 ) ; 
        var i : int ; i := n ; while i >= 1 do ( (     temp[i+1] := Set{temp[i+1], temp[i + 1+1] + 1}->min() )  ;     i := i - 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     res := Set{res, temp[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),p=in.nextInt(),l=in.nextInt(),r=in.nextInt(),sall=in.nextInt(),sp=in.nextInt();
    if(n-p!=0)loop(sall-sp,n-p);
    if(p!=0)loop(sp,p);
  }
  static void loop(int sum,int n){
    int k=sum/n ;
    for(int i=0,j=sum-k*n ; i<n ; i++,j--)System.out.print(k+(j>0 ? 1 : 0)+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var p : int ; p := in.getCurrent()->toInteger() ;
    var l : int ; l := in.getCurrent()->toInteger() ;
    var r : int ; r := in.getCurrent()->toInteger() ;
    var sall : int ; sall := in.getCurrent()->toInteger() ;
    var sp : int ; sp := in.getCurrent()->toInteger() ;
     if (n - p /= 0) then     execute loop(sall - sp, n - p) ; else skip ; 
     if (p /= 0) then     execute loop(sp, p) ; else skip );
  static   operation loop( sum : int, n : int) : void
  pre: true
  post: true
  activity: (     var k : int ; k := sum / n ;
         var i : int ; i := 0 ;
    var j : int ; j := sum - k * n ; while i < n do (     OclFile["System.out"].print(k + (if j > 0 then 1 else 0 endif) + " ") ;  ;     i := i + 1 ;     j := j - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static BufferedReader bf ;
  static PrintWriter pw ;
  static int n ;
  static int a[];
  static void solve(int te)throws Exception {
    int l=0,r=n-1 ;
    int cnt=1 ;
    while(l<=r){
      a[l]=Math.min(a[l],cnt);
      a[r]=Math.min(a[r],cnt);
      l++;
      r--;
      cnt++;
    }
    for(int i=1 ; i<n ; i++){
      a[i]=Math.min(a[i-1]+1,a[i]);
    }
    for(int i=n-2 ; i>=0 ; i--){
      a[i]=Math.min(a[i+1]+1,a[i]);
    }
    int ans=0 ;
    for(int i=0 ; i<n ; i++)ans=Math.max(a[i],ans);
    str.append(ans).append("\n");
  }
  public static void main(String[] args)throws java.lang.Exception {
    boolean lenv=false ;
    int te=1 ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    String s[]=bf.readLine().trim().split("\\s+");
    n=Integer.parseInt(s[0]);
    a=new int[n];
    s=bf.readLine().trim().split("\\s+");
    for(int i=0 ; i<n ; i++)a[i]=Integer.parseInt(s[i]);
    solve(te);
    pw.print(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute bf : OclFile;
  static   attribute pw : OclFile;
  static   attribute n : int;
  static   attribute a : Sequence(int);
  static   operation solve( te : int) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
    var r : int ; r := n - 1 ;
     var cnt : int ; cnt := 1 ;
    while (l <= r) do (     a[l+1] := Set{a[l+1], cnt}->min() ; 
     a[r+1] := Set{a[r+1], cnt}->min() ; 
    l := l + 1 ; 
    r := r - 1 ; 
    cnt := cnt + 1 ; 
 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     a[i+1] := Set{a[i - 1+1] + 1, a[i+1]}->min() )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     a[i+1] := Set{a[i + 1+1] + 1, a[i+1]}->min() )  ;     i := i - 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do (     ans := Set{a[i+1], ans}->max() ;  ;     i := i + 1 ) ; 
    str := str + StringLib.newString(ans) + StringLib.newString("\n") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var lenv : boolean ; lenv := false ;
     var te : int ; te := 1 ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var s : Sequence(String) ; s := bf.readLine()->trim()->split("\\s+") ;
    n := (s[0+1])->toInteger() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
    s := bf.readLine()->trim()->split("\\s+") ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (s[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    execute solve(te) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int remainderWith7(String num){
    int series[]={
      1,3,2,-1,-3,-2 };
      int series_index=0 ;
      int result=0 ;
      for(int i=num.length()-1 ; i>=0 ; i--){
        int digit=num.charAt(i)-'0' ;
        result+=digit*series[series_index];
        series_index=(series_index+1)% 6 ;
        result %=7 ;
      }
      if(result<0)result=(result+7)% 7 ;
      return result ;
    }
    public static void main(String[] args){
      String str="12345" ;
      System.out.print("Remainder with 7 is "+remainderWith7(str));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation remainderWith7( num : String) : int
  pre: true
  post: true
  activity: (     var series : Sequence(int) ; series := Sequence{1,3,2,-1,-3,-2} ;
     var series_index : int ; series_index := 0 ;
    var result : int ; result := 0 ;
        var i : int ; i := num->size() - 1 ; while i >= 0 do ( (     var digit : int ; digit := num->at(i+1) - ('0')->char2byte() ;
     result := result+(digit * series[series_index+1]) ; 
     series_index := (series_index + 1) mod 6 ; 
     result := result mod 7 )  ;     i := i - 1 ) ; 
    if (result < 0) then     result := (result + 7) mod 7 ; else skip ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "12345" ;
     OclFile["System.out"].print("Remainder with 7 is " + remainderWith7(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Solution {
  static void niceIndices(int A[],int n){
    int sum=0 ;
    Map<Integer,Integer>m=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; ++i){
      m.put(A[i],(m.get(A[i])==null)? 0 : m.get(A[i])+1);
      sum+=A[i];
    }
    for(int i=0 ; i<n ; ++i){
      int k=sum-A[i];
      if(k % 2==0){
        k=k>>1 ;
        if(m.containsKey(k)){
          if((A[i]==k && m.get(k)>1)||(A[i]!=k))System.out.print((i+1)+" ");
        }
      }
    }
  }
  public static void main(String args[]){
    int A[]={
      8,3,5,2 };
      int n=A.length ;
      niceIndices(A,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation niceIndices( A : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var m : Map(int,int) ; m := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     m := m->union(Map{A[i+1] |-> if (m->at(A[i+1]) = null) then 0 else m->at(A[i+1]) + 1 endif}) ; 
     sum := sum+(A[i+1]) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     var k : int ; k := sum - A[i+1] ;
     if (k mod 2 = 0) then (     k := (k/(2->pow(1)))->oclAsType(long) ; 
     if (m->keys()->includes(k)) then (     if ((A[i+1] = k & m->at(k) > 1) or (A[i+1] /= k)) then     OclFile["System.out"].print((i + 1) + " ") ; else skip ) else skip ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{8,3,5,2} ;
     var n : int ; n := A->size() ;
     execute niceIndices(A, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String partOdd(String s){
    String st="" ;
    for(int i=0 ; i<s.length(); i++){
      if(i % 2!=0)st+=s.charAt(i);
    }
    return st ;
  }
  static String partEven(String str){
    String s="" ;
    for(int i=0 ; i<str.length(); i++){
      if(i % 2==0)s+=str.charAt(i);
    }
    return s ;
  }
  static boolean canBeMadeEqual(String s1,String s2){
    char[] even1=partEven(s1).toCharArray();
    char[] even2=partEven(s2).toCharArray();
    char[] odd1=partOdd(s1).toCharArray();
    char[] odd2=partOdd(s2).toCharArray();
    Arrays.sort(even1);
    Arrays.sort(even2);
    Arrays.sort(odd1);
    Arrays.sort(odd2);
    String even_s1=new String(even1);
    String even_s2=new String(even2);
    String odd_s1=new String(odd1);
    String odd_s2=new String(odd2);
    if(even_s1.equals(even_s2)&& odd_s1.equals(odd_s2))return true ;
    return false ;
  }
  public static void main(String[] args){
    String s1="cdab" ;
    String s2="abcd" ;
    if(canBeMadeEqual(s1,s2))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation partOdd( s : String) : String
  pre: true
  post: true
  activity: (     var st : String ; st := "" ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (i mod 2 /= 0) then     st := st+(s->at(i+1)) ; else skip )  ;     i := i + 1 ) ; 
     return st );
  static   operation partEven( str : String) : String
  pre: true
  post: true
  activity: (     var s : String ; s := "" ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (i mod 2 = 0) then     s := s+(str->at(i+1)) ; else skip )  ;     i := i + 1 ) ; 
     return s );
  static   operation canBeMadeEqual( s1 : String, s2 : String) : boolean
  pre: true
  post: true
  activity: (     var even1 : Sequence(String) ; even1 := partEven(s1)->characters() ;
     var even2 : Sequence(String) ; even2 := partEven(s2)->characters() ;
    var odd1 : Sequence(String) ; odd1 := partOdd(s1)->characters() ;
    var odd2 : Sequence(String) ; odd2 := partOdd(s2)->characters() ;
    even1 := even1->sort() ; 
    even2 := even2->sort() ; 
    odd1 := odd1->sort() ; 
    odd2 := odd2->sort() ; 
    var even_s1 : String ; even_s1 := StringLib.newString(even1) ;
    var even_s2 : String ; even_s2 := StringLib.newString(even2) ;
    var odd_s1 : String ; odd_s1 := StringLib.newString(odd1) ;
    var odd_s2 : String ; odd_s2 := StringLib.newString(odd2) ;
    if (even_s1 = even_s2 & odd_s1 = odd_s2) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "cdab" ;
     var s2 : String ; s2 := "abcd" ;
     if (canBeMadeEqual(s1, s2)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int minJumps(int a,int b,int d){
    int temp=a ;
    a=Math.min(a,b);
    b=Math.max(temp,b);
    if(d>=b)return(d+b-1)/b ;
    if(d==0)return 0 ;
    if(d==a)return 1 ;
    return 2 ;
  }
  public static void main(String[] args){
    int a=3,b=4,d=11 ;
    System.out.println(minJumps(a,b,d));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minJumps( a : int, b : int, d : int) : int
  pre: true
  post: true
  activity: (     var temp : int ; temp := a ;
     a := Set{a, b}->min() ; 
    b := Set{temp, b}->max() ; 
    if (d >= b) then     return (d + b - 1) / b else skip ; 
    if (d = 0) then     return 0 else skip ; 
    if (d = a) then     return 1 else skip ; 
    return 2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var b : int ; b := 4 ;
    var d : int ; d := 11 ;
     OclFile["System.out"].println(minJumps(a, b, d)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    boolean iseven=n % 2==0 ;
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    int[] odd,even ;
    if(n % 2==0){
      odd=new int[n/2];
      even=new int[n/2];
    }
    else {
      odd=new int[(n+1)/2];
      even=new int[n/2];
    }
    if(iseven)for(int i=0 ;
    i<(n/2);
    i++){
      odd[i]=a[2*i];
      even[i]=a[2*i+1];
    }
    else {
      for(int i=0 ; i<(n-1)/2 ; i++){
        odd[i]=a[2*i];
        even[i]=a[2*i+1];
      }
      odd[odd.length-1]=a[a.length-1];
    }
    if(iseven){
      System.out.print(even[even.length-1]);
      for(int i=even.length-2 ; i>=0 ; i--)System.out.print(" "+even[i]);
      for(int i=0 ; i<odd.length ; i++)System.out.print(" "+odd[i]);
    }
    else {
      System.out.print(odd[odd.length-1]);
      for(int i=odd.length-2 ; i>=0 ; i--)System.out.print(" "+odd[i]);
      for(int i=0 ; i<even.length ; i++)System.out.print(" "+even[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var iseven : boolean ; iseven := n mod 2 = 0 ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var odd : Sequence(int) ;
    var even : Sequence(int) ;
    if (n mod 2 = 0) then (     odd := Integer.subrange(1,n / 2)->collect(0) ; 
     even := Integer.subrange(1,n / 2)->collect(0) ) else (     odd := Integer.subrange(1,(n + 1) / 2)->collect(0) ; 
     even := Integer.subrange(1,n / 2)->collect(0) ) ;  
    if (iseven) then         var i : int ; i := 0 ; while i < (n / 2) do ( (     odd[i+1] := a[2 * i+1] ; 
     even[i+1] := a[2 * i + 1+1] )  ;     i := i + 1 ) else (         var i : int ; i := 0 ; while i < (n - 1) / 2 do ( (     odd[i+1] := a[2 * i+1] ; 
     even[i+1] := a[2 * i + 1+1] )  ;     i := i + 1 ) ; 
     odd[odd->size() - 1+1] := a[a->size() - 1+1] ) ;  
    if (iseven) then (     OclFile["System.out"].print(even[even->size() - 1+1]) ; 
         var i : int ; i := even->size() - 2 ; while i >= 0 do (     OclFile["System.out"].print(" " + even[i+1]) ;  ;     i := i - 1 ) ; 
         var i : int ; i := 0 ; while i < odd->size() do (     OclFile["System.out"].print(" " + odd[i+1]) ;  ;     i := i + 1 ) ) else (     OclFile["System.out"].print(odd[odd->size() - 1+1]) ; 
         var i : int ; i := odd->size() - 2 ; while i >= 0 do (     OclFile["System.out"].print(" " + odd[i+1]) ;  ;     i := i - 1 ) ; 
         var i : int ; i := 0 ; while i < even->size() do (     OclFile["System.out"].print(" " + even[i+1]) ;  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static char[] a={
    'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z' };
    static char[] b={
      'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z' };
      static char[] c={
        '0','1','2','3','4','5','6','7','8','9' };
        public static void main(String[] args){
          Scanner stdIn=new Scanner(System.in);
          int counter=0 ;
          String W=stdIn.next();
          W=W.toLowerCase();
          while(stdIn.hasNext()){
            String tmp=stdIn.next();
            tmp=tmp.toLowerCase();
            if(W.equals(tmp)){
              counter++;
            }
          }
          System.out.println(counter);
        }
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a : Sequence(String) := Sequence{'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
  static   attribute b : Sequence(String) := Sequence{'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
  static   attribute c : Sequence(String) := Sequence{'0','1','2','3','4','5','6','7','8','9'};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var counter : int ; counter := 0 ;
    var W : String ; W := stdIn.getCurrent() ;
    W := W->toLowerCase() ; 
    while (stdIn.hasNext()) do (     var tmp : String ; tmp := stdIn.getCurrent() ;
     tmp := tmp->toLowerCase() ; 
     if (W = tmp) then (     counter := counter + 1 ) else skip ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.*;
import java.io.InputStreamReader ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
import java.util.*;
import java.math.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader sc=new FastReader();
    PrintWriter pw=new PrintWriter(System.out);
    int t=1 ;
    while(t-->0){
      int n=sc.nextInt(),f=0,a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      int ans[]=new int[n],p=0,q=n-1 ;
      for(int i=n-1 ; i>=0 ; i-=2){
        ans[p++]=a[i];
        if(i-1>=0)ans[q--]=a[i-1];
      }
      for(int w : ans)pw.print(w+" ");
      pw.println();
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := 1 ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.nextInt() ;
    var f : int ; f := 0 ;
    var a : Sequence(void) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    var ans : Sequence(void) ; ans := Integer.subrange(1,n)->collect(0) ;
    var p : int ; p := 0 ;
    var q : int ; q := n - 1 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (      ans[p+1] := a[i+1]  ; p := p + 1 ; 
     if (i - 1 >= 0) then      ans[q+1] := a[i - 1+1]  ; q := q - 1 ; else skip )  ;     i := i-(2) ) ; 
    for (w : ans) do (     skip ;  ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.util.Collection ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.util.Deque ;
import java.util.LinkedList ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskC solver=new TaskC();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskC {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      boolean end=true ;
      Deque<Integer>dq=new LinkedList<>();
      for(int i=0 ; i<n ; i++){
        if(end){
          dq.addLast(in.nextInt());
        }
        else dq.addFirst(in.nextInt());
        end=! end ;
      }
      if(end)while(! dq.isEmpty())out.print(dq.pollFirst()+" ");
      else while(! dq.isEmpty())out.print(dq.pollLast()+" ");
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream));
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskC ; solver := TaskC.newTaskC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskC {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var end : boolean ; end := true ;
    var dq : Sequence(int) ; dq := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (end) then (     dq := dq->append(in.nextInt()) ) else     dq := dq->prepend(in.nextInt()) ; ;  
     end := not(end) )  ;     i := i + 1 ) ; 
    if (end) then     while (not(dq->isEmpty())) do     skip ; else     while (not(dq->isEmpty())) do     skip ; ; ;  
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static int N ;
  private static ArrayList<Integer>arrayList=new ArrayList<>();
  public static void input(){
    Scanner scan=new Scanner(System.in);
    N=scan.nextInt();
    for(int i=0 ; i<N ; i++){
      arrayList.add(scan.nextInt());
    }
  }
  public static void main(String args[]){
    input();
    ArrayList<Integer>b=new ArrayList<>();
    if(N % 2==0){
      for(int i=N-1 ; i>=0 ; i-=2)b.add(arrayList.get(i));
      for(int i=0 ; i<N ; i+=2)b.add(arrayList.get(i));
    }
    else {
      for(int i=N-1 ; i>=0 ; i-=2)b.add(arrayList.get(i));
      for(int i=1 ; i<N ; i+=2)b.add(arrayList.get(i));
    }
    for(int i=0 ; i<N ; i++){
      System.out.print(b.get(i)+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute arrayList : Sequence(int) := Sequence{};
  static   operation input() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := scan.getCurrent()->toInteger() ; 
         var i : int ; i := 0 ; while i < N do ( (     arrayList := arrayList->including(scan.getCurrent()->toInteger()) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute input() ; 
     var b : Sequence(int) ; b := Sequence{} ;
     if (N mod 2 = 0) then (         var i : int ; i := N - 1 ; while i >= 0 do (     b := b->including(arrayList->at(i+1)) ;  ;     i := i-(2) ) ; 
         var i : int ; i := 0 ; while i < N do (     b := b->including(arrayList->at(i+1)) ;  ;     i := i+(2) ) ) else (         var i : int ; i := N - 1 ; while i >= 0 do (     b := b->including(arrayList->at(i+1)) ;  ;     i := i-(2) ) ; 
         var i : int ; i := 1 ; while i < N do (     b := b->including(arrayList->at(i+1)) ;  ;     i := i+(2) ) ) ;  
         var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].print(b->at(i+1) + " ") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void alter(long x,long y){
    while(true){
      if(x==0 || y==0)break ;
      if(x>=2*y)x=x %(2*y);
      else if(y>=2*x)y=y %(2*x);
      else break ;
    }
    System.out.println("X="+x+","+"Y="+y);
  }
  public static void main(String[] args){
    long x=12,y=5 ;
    alter(x,y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation alter( x : long, y : long) : void
  pre: true
  post: true
  activity: (     while (true) do (     if (x = 0 or y = 0) then     break else skip ; 
     if (x >= 2 * y) then     x := x mod (2 * y) ; else     if (y >= 2 * x) then     y := y mod (2 * x) else     break ;  ) ; 
     OclFile["System.out"].println("X=" + x + "," + "Y=" + y) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : long ; x := 12 ;
    var y : long ; y := 5 ;
     execute alter(x, y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.Iterator ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int N=gi();
    int[] A=new int[N];
    LinkedList<Integer>l=new LinkedList<Integer>();
    for(int i=0 ; i<N ; i++){
      A[i]=gi();
      if(i % 2==0){
        l.addFirst(A[i]);
      }
      else {
        l.addLast(A[i]);
      }
    }
    if(N % 2==0)Collections.reverse(l);
    Iterator it=l.listIterator();
    boolean f=false ;
    while(it.hasNext()){
      if(f){
        System.out.print(" ");
      }
      else {
        f=true ;
      }
      System.out.print(it.next());
    }
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : int ; N := gi() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var l : Sequence(int) ; l := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := gi() ; 
     if (i mod 2 = 0) then (     l := l->prepend(A[i+1]) ) else (     l := l->append(A[i+1]) ) )  ;     i := i + 1 ) ; 
    if (N mod 2 = 0) then     l := l->reverse() ; else skip ; 
    var it : OclIterator ; it := l->iterator() ;
    var f : boolean ; f := false ;
    while (it.hasNext()) do (     if (f) then (     OclFile["System.out"].print(" ") ) else (     f := true ) ;  
     OclFile["System.out"].print(it.next()) ) ; 
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    StringTokenizer st ;
    int T=Integer.parseInt(br.readLine());
    for(int test=0 ; test<T ; test++){
      int n=Integer.parseInt(br.readLine());
      String line=br.readLine();
      int answer=0 ;
      for(int i=0 ; i<line.length()-1 ; i++){
        if(line.charAt(i)==line.charAt(i+1)&& line.charAt(i)=='0'){
          answer+=2 ;
        }
      }
      for(int i=0 ; i<line.length()-2 ; i++){
        if(line.charAt(i)=='0' && line.charAt(i+1)=='1' && line.charAt(i+2)=='0'){
          answer+=1 ;
        }
      }
      bw.write(answer+"\n");
    }
    bw.flush();
    bw.close();
    br.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var st : OclIterator ;
    var T : int ; T := (br.readLine())->toInteger() ;
        var test : int ; test := 0 ; while test < T do ( (     var n : int ; n := (br.readLine())->toInteger() ;
     var line : String ; line := br.readLine() ;
    var answer : int ; answer := 0 ;
        var i : int ; i := 0 ; while i < line->size() - 1 do ( (     if (line->at(i+1) = line->at(i + 1+1) & line->at(i+1) = '0') then (     answer := answer+(2) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < line->size() - 2 do ( (     if (line->at(i+1) = '0' & line->at(i + 1+1) = '1' & line->at(i + 2+1) = '0') then (     answer := answer+(1) ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     test := test + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MarinProblem {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testCase=sc.nextInt();
    for(int i=0 ; i<testCase ; i++){
      int n=sc.nextInt();
      int count=0 ;
      char[] ch=sc.next().toCharArray();
      for(int j=0 ; j<n-1 ; j++){
        try {
          if(ch[j]=='0' && ch[j+1]=='0')count+=2 ;
          else if(ch[j]=='0' && ch[j+1]=='1' && ch[j+2]=='0')count+=1 ;
        }
        catch(Exception e){
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MarinProblem {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCase : int ; testCase := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < testCase do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var count : int ; count := 0 ;
    var ch : Sequence(String) ; ch := sc.getCurrent()->characters() ;
        var j : int ; j := 0 ; while j < n - 1 do ( (     try (     if (ch[j+1] = '0' & ch[j + 1+1] = '0') then     count := count+(2) ; else     if (ch[j+1] = '0' & ch[j + 1+1] = '1' & ch[j + 2+1] = '0') then     count := count+(1) ; else skip ; )   catch (e : ProgramException) do skip
 )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    while(T>0){
      int n=in.nextInt();
      String s=in.next();
      char arr[]=s.toCharArray();
      int res=0 ;
      for(int i=0 ; i<arr.length ; i++){
        if(arr[i]=='0'){
          int len=i+2 ;
          if(len>arr.length-1)len=arr.length-1 ;
          int j=i+1 ;
          int t=2 ;
          while(j<=len){
            if(arr[j]=='0'){
              res+=t ;
              break ;
            }
            j++;
            t--;
          }
        }
      }
      System.out.println(res);
      T--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
     while (T > 0) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var s : String ; s := in.getCurrent() ;
    var arr : Sequence(String) ; arr := s->characters() ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = '0') then (     var len : int ; len := i + 2 ;
     if (len > arr->size() - 1) then     len := arr->size() - 1 ; else skip ; 
    var j : int ; j := i + 1 ;
    var t : int ; t := 2 ;
    while (j <= len) do (     if (arr[j+1] = '0') then (     res := res+(t) ; 
     break ) else skip ; 
     j := j + 1 ; 
     t := t - 1 ) ; 
 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
    T := T - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static int sumcommDiv(int a,int b){
    int n=gcd(a,b);
    int sum=0 ;
    for(int i=1 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        if(n/i==i)sum+=i ;
        else sum+=(n/i)+i ;
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int a=10,b=15 ;
    System.out.println("Sum="+sumcommDiv(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation sumcommDiv( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := gcd(a, b) ;
     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     if (n / i = i) then     sum := sum+(i) ; else     sum := sum+((n / i) + i) ; ) else skip )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 10 ;
    var b : int ; b := 15 ;
     OclFile["System.out"].println("Sum=" + sumcommDiv(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int MinimumMoves(int a[],int n,int x){
    int ans=0 ;
    for(int i=1 ; i<n ; i++){
      if(a[i]<=a[i-1]){
        int p=(a[i-1]-a[i])/x+1 ;
        ans+=p ;
        a[i]+=p*x ;
      }
    }
    return ans ;
  }
  public static void main(String args[]){
    int arr[]={
      1,3,3,2 };
      int x=2 ;
      int n=arr.length ;
      System.out.println(MinimumMoves(arr,n,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MinimumMoves( a : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] <= a[i - 1+1]) then (     var p : int ; p := (a[i - 1+1] - a[i+1]) / x + 1 ;
     ans := ans+(p) ; 
     a[i+1] := a[i+1]+(p * x) ) else skip )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,3,2} ;
     var x : int ; x := 2 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(MinimumMoves(arr, n, x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int x=sc.nextInt();
      String s=sc.next();
      boolean ok=true ;
      Set<Character>set=new HashSet<>();
      for(char ch='A' ; ch<'A'+x ; ch++){
        if(s.indexOf(ch)==-1){
          ok=false ;
          break ;
        }
      }
      if(! ok)System.out.println(0);
      else {
        int[] freq=new int[x];
        Arrays.fill(freq,0);
        for(int i=0 ; i<n ; i++)freq[s.charAt(i)-'A']++;
        Arrays.sort(freq);
        System.out.println(freq[0]*x);
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var ok : boolean ; ok := true ;
    var set : Set(String) ; set := Set{} ;
        var ch : String ; ch := 'A' ; while ch < 'A' + x do ( (     if (s->indexOf(ch)-1 = -1) then (     ok := false ; 
     break ) else skip )  ;     ch := ch + 1 ) ; 
    if (not(ok)) then     OclFile["System.out"].println(0) else (     var freq : Sequence(int) ; freq := Integer.subrange(1,x)->collect(0) ;
     freq := freq->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     freq[s->at(i+1) - ('A')->char2byte()+1] := freq[s->at(i+1) - ('A')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    freq := freq->sort() ; 
    OclFile["System.out"].println(freq[0+1] * x) ; 
 ) ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Demo {
  public static void main(String[] args){
    int n,k ;
    Scanner in=new Scanner(System.in);
    n=in.nextInt();
    k=in.nextInt();
    String str=in.next();
    char[] ch=str.toCharArray();
    int[] a=new int[k];
    char[] b=new char[k];
    char al='A' ;
    for(int i=0 ; i<k ; i++){
      a[i]=0 ;
      b[i]=al ;
      al++;
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<k ; j++){
        if(ch[i]==b[j]){
          a[j]++;
          break ;
        }
      }
    }
    int min=a[0];
    for(int i=0 ; i<k ; i++){
      if(a[i]<=min)min=a[i];
    }
    System.out.println(min*k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Demo {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var k : int ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := in.getCurrent()->toInteger() ; 
    k := in.getCurrent()->toInteger() ; 
    var str : String ; str := in.getCurrent() ;
    var ch : Sequence(String) ; ch := str->characters() ;
    var a : Sequence(int) ; a := Integer.subrange(1,k)->collect(0) ;
    var b : Sequence(String) ; b := Integer.subrange(1,k)->collect(0) ;
    var al : String ; al := 'A' ;
        var i : int ; i := 0 ; while i < k do ( (     a[i+1] := 0 ; 
     b[i+1] := al ; 
     al := al + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < k do ( (     if (ch[i+1] = b[j+1]) then (     a[j+1] := a[j+1] + 1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var min : int ; min := a[0+1] ;
        var i : int ; i := 0 ; while i < k do ( (     if (a[i+1] <= min) then     min := a[i+1] ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min * k) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    try(Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out)){
      int n=in.nextInt();
      int[] v=new int[n];
      Set<Integer>set=new HashSet<>();
      for(int i=0 ; i<n ; i++){
        v[i]=in.nextInt();
        set.add(v[i]);
      }
      for(int i=1 ; i<n ; i++)swap(v,(int)(Math.random()*(i-1)),i);
      Arrays.sort(v);
      int ans=2 ;
      for(int i=0 ; i<n ; i++){
        for(int j=i+1 ; j<n ; j++){
          int d=v[j]-v[i];
          if(set.contains(v[i]-d))continue ;
          int cnt=2,cur=v[j];
          while(set.contains(cur+d)){
            cur+=d ;
            cnt++;
          }
          ans=Math.max(ans,cnt);
        }
      }
      out.println(ans);
    }
  }
  private static void swap(int[] a,int x,int y){
    int t=a[x];
    a[x]=a[y];
    a[y]=t ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]) ;
 (     var n : int ; n := in.getCurrent()->toInteger() ;
     var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     v[i+1] := in.getCurrent()->toInteger() ; 
     set := set->including(v[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do (     execute swap(v, (MathLib.random() * (i - 1))->oclAsType(int), i) ;  ;     i := i + 1 ) ; 
    v := v->sort() ; 
    var ans : int ; ans := 2 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var d : int ; d := v[j+1] - v[i+1] ;
     if (set->includes(v[i+1] - d)) then     continue else skip ; 
    var cnt : int ; cnt := 2 ;
    var cur : int ; cur := v[j+1] ;
    while (set->includes(cur + d)) do (     cur := cur+(d) ; 
     cnt := cnt + 1 ) ; 
    ans := Set{ans, cnt}->max() ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 ))  );
  static   operation swap( a : Sequence(int), x : int, y : int) : void
  pre: true
  post: true
  activity: (     var t : int ; t := a[x+1] ;
     a[x+1] := a[y+1] ; 
     a[y+1] := t );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int a=scanner.nextInt();
    int b=scanner.nextInt();
    int c=scanner.nextInt();
    int size=a*c ;
    int timestart ;
    if(size % b==0){
      timestart=(size-b*c)/b ;
    }
    else {
      timestart=(size-b*c)/b+1 ;
    }
    System.out.print(timestart);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    var size : int ; size := a * c ;
    var timestart : int ;
    if (size mod b = 0) then (     timestart := (size - b * c) / b ) else (     timestart := (size - b * c) / b + 1 ) ;  
    OclFile["System.out"].print(timestart) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Problem {
  public static void main(String[] args){
    java.util.Scanner input=new java.util.Scanner(System.in);
    int a,b,c ;
    a=input.nextInt();
    b=input.nextInt();
    c=input.nextInt();
    int time=(int)Math.ceil((a*c)/(double)b);
    System.out.println(time-c);
  }
}
------------------------------------------------------------
OCL File:
---------
class Problem {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : Scanner ; input := Scanner.newScanner(OclFile["System.in"]) ;
     var a : int ;
    var b : int ;
    var c : int ;
    a := input.nextInt() ; 
    b := input.nextInt() ; 
    c := input.nextInt() ; 
    var time : int ; time := ((a * c) / b->oclAsType(double))->ceil()->oclAsType(int) ;
    OclFile["System.out"].println(time - c) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class _195 {
  public static void main(String[] args){
    final Scanner scn=new Scanner(System.in);
    final int a=scn.nextInt();
    final int b=scn.nextInt();
    final int c=scn.nextInt();
    System.out.println(((a-b)*c+b-1)/b);
    scn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class _195 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scn.getCurrent()->toInteger() ;
    var b : int ; b := scn.getCurrent()->toInteger() ;
    var c : int ; c := scn.getCurrent()->toInteger() ;
    OclFile["System.out"].println(((a - b) * c + b - 1) / b) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static int solve(int a,int b,int c){
    int t=(a-b)*c ;
    if(t % b==0)return t/b ;
    else return t/b+1 ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    System.out.println(solve(a,b,c));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation solve( a : int, b : int, c : int) : int
  pre: true
  post: true
  activity: (     var t : int ; t := (a - b) * c ;
     if (t mod b = 0) then     return t / b else     return t / b + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(solve(a, b, c)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int mod=1000000007 ;
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int K=scan.nextInt();
    scan.close();
    long[] count=new long[K+1];
    for(int j=K ; j>=1 ; j--){
      count[j]=power((long)K/j,(long)N);
      int multi=2 ;
      while(j*multi<=K){
        count[j]-=count[j*multi];
        multi++;
      }
    }
    long sum=0 ;
    for(int j=1 ; j<=K ; j++){
      sum+=j*count[j] % mod ;
      sum=sum % mod ;
    }
    System.out.println(sum);
  }
  public static long power(long x,long n){
    long result=1 ;
    while(n>0){
      if(n % 2==1){
        result*=x ;
        result %=mod ;
      }
      x=x*x ;
      x %=mod ;
      n>>=1 ;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var K : int ; K := scan.getCurrent()->toInteger() ;
    skip ; 
    var count : Sequence(long) ; count := Integer.subrange(1,K + 1)->collect(0) ;
        var j : int ; j := K ; while j >= 1 do ( (     count[j+1] := power(K->oclAsType(long) / j, N->oclAsType(long)) ; 
     var multi : int ; multi := 2 ;
     while (j * multi <= K) do (     count[j+1] := count[j+1]-(count[j * multi+1]) ; 
     multi := multi + 1 ) )  ;     j := j - 1 ) ; 
    var sum : long ; sum := 0 ;
        var j : int ; j := 1 ; while j <= K do ( (     sum := sum+(j * count[j+1] mod mod) ; 
     sum := sum mod mod )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
  static   operation power( x : long, n : long) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 1 ;
     while (n > 0) do (     if (n mod 2 = 1) then (     result := result*(x) ; 
     result := result mod mod ) else skip ; 
     x := x * x ; 
     x := x mod mod ; 
     n := n/(2->pow(1)) ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int N=input.nextInt();
    int K=input.nextInt();
    long mod=(long)(1e9+7);
    long[] gcdPerNum=new long[K+1];
    long answer=0 ;
    for(int curGCD=K ; curGCD>=1 ; curGCD--){
      long base=K/curGCD ;
      gcdPerNum[curGCD]=FastExp(base,N,mod);
      for(int OVERCNT=2*curGCD ; OVERCNT<=K ; OVERCNT+=curGCD){
        gcdPerNum[curGCD]-=gcdPerNum[OVERCNT];
        gcdPerNum[curGCD] %=mod ;
        if(gcdPerNum[curGCD]<0)gcdPerNum[curGCD]+=mod ;
      }
      answer+=gcdPerNum[curGCD]*curGCD ;
      answer %=mod ;
    }
    System.out.println(answer);
  }
  public static long FastExp(long base,long exp,long mod){
    String Binary=Binary(exp);
    long[] mods=new long[Binary.length()];
    mods[0]=base % mod ;
    long FinalProduct=1 ;
    for(int i=1 ; i<mods.length ; i++){
      mods[i]=((mods[i-1] % mod)*(mods[i-1] % mod))% mod ;
    }
    for(int i=0 ; i<Binary.length(); i++){
      if(Binary.charAt(i)=='1'){
        FinalProduct*=mods[Binary.length()-i-1];
        FinalProduct %=mod ;
      }
    }
    return FinalProduct ;
  }
  public static String Binary(long exp){
    String answer="" ;
    int length=0 ;
    for(int i=0 ; ; i++){
      if(Math.pow(2,i)>exp){
        length=i ;
        break ;
      }
    }
    for(int i=length-1 ; i>=0 ; i--){
      if(Math.pow(2,i)<=exp){
        answer+="1" ;
        exp-=Math.pow(2,i);
      }
      else {
        answer+="0" ;
      }
    }
    return answer ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := input.getCurrent()->toInteger() ;
    var K : int ; K := input.getCurrent()->toInteger() ;
    var mod : long ; mod := (1e9 + 7)->oclAsType(long) ;
    var gcdPerNum : Sequence(long) ; gcdPerNum := Integer.subrange(1,K + 1)->collect(0) ;
    var answer : long ; answer := 0 ;
        var curGCD : int ; curGCD := K ; while curGCD >= 1 do ( (     var base : long ; base := K / curGCD ;
     gcdPerNum[curGCD+1] := FastExp(base, N, mod) ; 
        var OVERCNT : int ; OVERCNT := 2 * curGCD ; while OVERCNT <= K do ( (     gcdPerNum[curGCD+1] := gcdPerNum[curGCD+1]-(gcdPerNum[OVERCNT+1]) ; 
     gcdPerNum[curGCD+1] := gcdPerNum[curGCD+1] mod mod ; 
     if (gcdPerNum[curGCD+1] < 0) then     gcdPerNum[curGCD+1] := gcdPerNum[curGCD+1]+(mod) ; else skip )  ;     OVERCNT := OVERCNT+(curGCD) ) ; 
    answer := answer+(gcdPerNum[curGCD+1] * curGCD) ; 
    answer := answer mod mod ; 
 )  ;     curGCD := curGCD - 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
  static   operation FastExp( base : long, exp : long, mod : long) : long
  pre: true
  post: true
  activity: (     var Binary : String ; Binary := Binary(exp) ;
     var mods : Sequence(long) ; mods := Integer.subrange(1,Binary->size())->collect(0) ;
    mods[0+1] := base mod mod ; 
    var FinalProduct : long ; FinalProduct := 1 ;
        var i : int ; i := 1 ; while i < mods->size() do ( (     mods[i+1] := ((mods[i - 1+1] mod mod) * (mods[i - 1+1] mod mod)) mod mod )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Binary->size() do ( (     if (Binary->at(i+1) = '1') then (     FinalProduct := FinalProduct*(mods[Binary->size() - i - 1+1]) ; 
     FinalProduct := FinalProduct mod mod ) else skip )  ;     i := i + 1 ) ; 
    return FinalProduct 
 );
  static   operation Binary( exp : long) : String
  pre: true
  post: true
  activity: (     var answer : String ; answer := "" ;
     var length : int ; length := 0 ;
        var i : int ; i := 0 ; while true do ( (     if (2->pow(i) > exp) then (     length := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := (length)->char2byte() - 1 ; while i >= 0 do ( (     if (2->pow(i) <= exp) then (     answer := answer+("1") ; 
     exp := exp-(2->pow(i)) ) else (     answer := answer+("0") ) )  ;     i := i - 1 ) ; 
    return answer 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=Integer.parseInt(scan.next());
    int k=Integer.parseInt(scan.next());
    scan.close();
    int mod=1000000000+7 ;
    long[] d=new long[k+1];
    for(int i=1 ; i<=k ; i++){
      int count=k/i ;
      d[i]=modPow(count,n,mod);
    }
    for(int i=k ; i>0 ; i--){
      int a=2 ;
      while(i*a<=k){
        if(d[i]>=d[i*a]){
          d[i]-=d[i*a];
        }
        else {
          d[i]=d[i]+mod-d[i*a];
        }
        a++;
      }
    }
    long ans=0 ;
    for(int i=1 ; i<=k ; i++){
      ans+=i*d[i];
      ans %=mod ;
    }
    System.out.println(ans);
  }
  private static long modPow(long a,long b,long mod){
    if(b==0){
      return 1 ;
    }
    if(b % 2==0){
      return modPow((a*a)% mod,b/2,mod);
    }
    else {
      return modPow((a*a)% mod,b/2,mod)*a % mod ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (scan.getCurrent())->toInteger() ;
    var k : int ; k := (scan.getCurrent())->toInteger() ;
    skip ; 
    var mod : int ; mod := 1000000000 + 7 ;
    var d : Sequence(long) ; d := Integer.subrange(1,k + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= k do ( (     var count : int ; count := k / i ;
     d[i+1] := modPow(count, n, mod) )  ;     i := i + 1 ) ; 
        var i : int ; i := k ; while i > 0 do ( (     var a : int ; a := 2 ;
     while (i * a <= k) do (     if (d[i+1] >= d[i * a+1]) then (     d[i+1] := d[i+1]-(d[i * a+1]) ) else (     d[i+1] := d[i+1] + mod - d[i * a+1] ) ;  
     a := a + 1 ) )  ;     i := i - 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= k do ( (     ans := ans+(i * d[i+1]) ; 
     ans := ans mod mod )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation modPow( a : long, b : long, mod : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return 1 ) else skip ; 
     if (b mod 2 = 0) then (     return modPow((a * a) mod mod, b / 2, mod) ) else (     return modPow((a * a) mod mod, b / 2, mod) * a mod mod ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(isr);
    int c=0 ;
    String sw="" ;
    for(int ii=0 ; ; ii++){
      String line=br.readLine();
      if(ii==0){
        sw=line.toLowerCase();
        continue ;
      }
      if(line.equals("END_OF_TEXT")|| line==null || line.length()==0){
        break ;
      }
      String[] ss=line.split(" ");
      for(int jj=0 ; jj<ss.length ; jj++){
        if(sw.equals(ss[jj] .toLowerCase())){
          c++;
        }
      }
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
    var c : int ; c := 0 ;
    var sw : String ; sw := "" ;
        var ii : int ; ii := 0 ; while true do ( (     var line : String ; line := br.readLine() ;
     if (ii = 0) then (     sw := line->toLowerCase() ; 
     continue ) else skip ; 
    if (line = "END_OF_TEXT" or line = null or line->size() = 0) then (     break ) else skip ; 
    var ss : Sequence(String) ; ss := line->split(" ") ;
        var jj : int ; jj := 0 ; while jj < ss->size() do ( (     if (sw = ss[jj+1]->toLowerCase()) then (     c := c + 1 ) else skip )  ;     jj := jj + 1 ) ; 
 )  ;     ii := ii + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Map.Entry ;
class Main {
  static int mod=(int)(Math.pow(10,9)+7);
  static List<ArrayList<Integer>>list=new ArrayList<ArrayList<Integer>>();
  static int a_dist[];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    long[] mp=new long[K+5];
    long ans=0 ;
    mp[0]=1 ;
    for(int i=2 ; i<=K ; i++){
      mp[i-1]=i ;
      for(int j=1 ; (double)j<=Math.pow(i,0.5); j++){
        if(i % j==0){
          mp[i-1]=mp[i-1]-mp[j-1];
          if(i/j>j && i/j<i){
            mp[i-1]=mp[i-1]-mp[i/j-1];
          }
        }
      }
    }
    for(int i=1 ; i<=K ; i++){
      long tmp=K/i ;
      ans=(ans+(mp[i-1]*pow(tmp,N)% mod)% mod)% mod ;
    }
    System.out.println(ans);
  }
  public static long pow(long a,long n){
    long res=1 ;
    while(n>0){
      if((n-n/2*2)==1){
        res=(res*a)% mod ;
      }
      a=(a*a)% mod ;
      n>>=1 ;
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := (10->pow(9) + 7)->oclAsType(int);
  static   attribute list : Sequence(Sequence(int)) := Sequence{};
  static   attribute a_dist : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var mp : Sequence(long) ; mp := Integer.subrange(1,K + 5)->collect(0) ;
    var ans : long ; ans := 0 ;
    mp[0+1] := 1 ; 
        var i : int ; i := 2 ; while i <= K do ( (     mp[i - 1+1] := i ; 
         var j : int ; j := 1 ; while j->oclAsType(double) <= i->pow(0.5) do ( (     if (i mod j = 0) then (     mp[i - 1+1] := mp[i - 1+1] - mp[j - 1+1] ; 
     if (i / j > j & i / j < i) then (     mp[i - 1+1] := mp[i - 1+1] - mp[i / j - 1+1] ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= K do ( (     var tmp : long ; tmp := K / i ;
     ans := (ans + (mp[i - 1+1] * pow(tmp, N) mod mod) mod mod) mod mod )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation pow( a : long, n : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     while (n > 0) do (     if ((n - n / 2 * 2) = 1) then (     res := (res * a) mod mod ) else skip ; 
     a := (a * a) mod mod ; 
     n := n/(2->pow(1)) ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1569 {
  static boolean flag ;
  static int finals ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int cases=sc.nextInt();
    while(cases-->0){
      flag=false ;
      int letters=sc.nextInt();
      String ab=sc.next();
      for(int i=1 ; i<letters ; i++){
        if(ab.charAt(i-1)!=ab.charAt(i)){
          flag=true ;
          System.out.println((i)+" "+(i+1));
          break ;
        }
      }
      if(flag==false){
        System.out.println("-1 "+"-1");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1569 {
  static   attribute flag : boolean;
  static   attribute finals : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cases : int ; cases := sc.getCurrent()->toInteger() ;
         while (cases > 0) do (        cases := cases - 1 ;     skip ; (     flag := false ; 
     var letters : int ; letters := sc.getCurrent()->toInteger() ;
    var ab : String ; ab := sc.getCurrent() ;
        var i : int ; i := 1 ; while i < letters do ( (     if (ab->at((i)->char2byte() - 1+1) /= ab->at(i+1)) then (     flag := true ; 
     OclFile["System.out"].println((i) + " " + (i + 1)) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = false) then (     OclFile["System.out"].println("-1 " + "-1") ) else skip ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class contest2 {
  static long fib(long a,long b,long c){
    if(c==0)return a ;
    else if(c==1)return b ;
    else if(c % 3==0)return a ;
    else if(c % 3==1)return b ;
    else return fib(a,b,c-1)^ fib(a,b,c-2);
  }
  public static void main(String[] args){
    Scanner obj=new Scanner(System.in);
    int tc=obj.nextInt();
    while(tc--!=0){
      long a=obj.nextLong();
      long b=obj.nextLong();
      long c=obj.nextLong();
      System.out.println(fib(a,b,c));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class contest2 {
  static   operation fib( a : long, b : long, c : long) : long
  pre: true
  post: true
  activity: (     if (c = 0) then     return a else     if (c = 1) then     return b else     if (c mod 3 = 0) then     return a else     if (c mod 3 = 1) then     return b else     return fib(a, b, c - 1) xor fib(a, b, c - 2) ;  ;  ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : OclFile ; obj := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := obj.getCurrent()->toInteger() ;
         while (tc /= 0) do (    skip ; (     var a : long ; a := obj.getCurrent()->toLong() ;
     var b : long ; b := obj.getCurrent()->toLong() ;
     var c : long ; c := obj.getCurrent()->toLong() ;
     OclFile["System.out"].println(fib(a, b, c)) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int divisorSum(int n){
    int sum=0 ;
    for(int i=1 ; i<=n ; ++i)sum+=(n/i)*i ;
    return sum ;
  }
  public static void main(String args[]){
    int n=4 ;
    System.out.println(divisorSum(n));
    n=5 ;
    System.out.println(divisorSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation divisorSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do (     sum := sum+((n / i) * i) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(divisorSum(n)) ; 
     n := 5 ; 
     OclFile["System.out"].println(divisorSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    int[] count=new int[N];
    for(int i=0 ; i<N ; i++){
      count[sc.nextInt()-1]++;
    }
    int[] hist=new int[N+1];
    for(int i=0 ; i<N ; i++){
      hist[count[i] ]++;
    }
    long[] used=new long[N+1];
    int lack=0 ;
    for(int i=1 ; i<=N ; i++){
      lack+=hist[i-1];
      used[i]=used[i-1]+lack ;
    }
    int[] ans=new int[N+1];
    for(int i=1 ; i<=N ; i++){
      ans[i]=N-(int)((used[i]+i-1)/i);
    }
    int[] out=new int[N+1];
    for(int i=1 ; i<N ; i++){
      for(int j=ans[i]; j>ans[i+1]; j--){
        out[j]=i ;
      }
    }
    out[1]=N ;
    PrintWriter writer=new PrintWriter(System.out);
    for(int i=0 ; i<N ; i++){
      writer.println(out[i+1]);
    }
    writer.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var count : Sequence(int) ; count := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     count[sc.getCurrent()->toInteger() - 1+1] := count[sc.getCurrent()->toInteger() - 1+1] + 1 )  ;     i := i + 1 ) ; 
    var hist : Sequence(int) ; hist := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     hist[count[i+1]+1] := hist[count[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var used : Sequence(long) ; used := Integer.subrange(1,N + 1)->collect(0) ;
    var lack : int ; lack := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     lack := lack+(hist[i - 1+1]) ; 
     used[i+1] := used[i - 1+1] + lack )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do ( (     ans[i+1] := N - ((used[i+1] + i - 1) / i)->oclAsType(int) )  ;     i := i + 1 ) ; 
    var out : Sequence(int) ; out := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i < N do ( (         var j : int ; j := ans[i+1] ; while j > ans[i + 1+1] do ( (     out[j+1] := i )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    out[1+1] := N ; 
    var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile["System.out"]) ;
        var i : int ; i := 0 ; while i < N do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    Map<Integer,Integer>freq=new HashMap<>();
    int[] amts=new int[n+1];
    for(int j=0 ; j<n ; j++){
      int k=in.nextInt();
      if(! freq.containsKey(k)){
        freq.put(k,1);
      }
      else {
        freq.put(k,freq.get(k)+1);
      }
      amts[freq.get(k)]++;
    }
    StringBuilder builder=new StringBuilder();
    int k=1 ;
    int nTemp=n ;
    for(int m=n ; m>0 ; m--){
      while(k<=nTemp/m){
        builder.append(m);
        builder.append('\n');
        k++;
      }
      nTemp-=amts[m];
    }
    while(k<=n){
      builder.append("0\n");
      k++;
    }
    System.out.print(builder);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var freq : Map(int,int) ; freq := Map{} ;
    var amts : Sequence(int) ; amts := Integer.subrange(1,n + 1)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     var k : int ; k := in.getCurrent()->toInteger() ;
     if (not(freq->keys()->includes(k))) then (     freq := freq->union(Map{k |-> 1}) ) else (     freq := freq->union(Map{k |-> freq->at(k) + 1}) ) ;  
     amts[freq->at(k)+1] := amts[freq->at(k)+1] + 1 )  ;     j := j + 1 ) ; 
    var builder : String ; builder := StringLib.newString() ;
    var k : int ; k := 1 ;
    var nTemp : int ; nTemp := n ;
        var m : int ; m := n ; while m > 0 do ( (     while (k <= nTemp / m) do (     builder := builder + StringLib.newString(m) ; 
     builder := builder + StringLib.newString('
') ; 
     k := k + 1 ) ; 
     nTemp := nTemp-(amts[m+1]) )  ;     m := m - 1 ) ; 
    while (k <= n) do (     builder := builder + StringLib.newString("0\n") ; 
     k := k + 1 ) ; 
    OclFile["System.out"].print(builder) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main implements Runnable {
  private static int MOD=1_000_000_007 ;
  public static void main(String[] args){
    Thread thread=new Thread(null,new Main(),"",32*1024*1024);
    thread.start();
  }
  @ Override public void run(){
    final Scanner scanner=new Scanner(System.in);
    solve(scanner);
  }
  static void solve(Scanner scanner){
    int N=Integer.parseInt(scanner.next());
    int A[]=new int[N];
    for(int i=0 ; i<N ; i++){
      A[Integer.parseInt(scanner.next())-1]++;
    }
    Arrays.sort(A);
    int S[]=new int[N+1];
    for(int i=0 ; i<N ; i++){
      S[i+1]=S[i]+A[i];
    }
    for(int k=1 ; k<=N ; k++){
      int l=0 ;
      int r=N/k+1 ;
      while(r-l>1){
        int mid=(l+r)>>>1 ;
        int index=lowerBound(A,0,A.length,mid);
        int sum=mid*(N-index)+S[index];
        if(sum>=mid*k){
          l=mid ;
        }
        else {
          r=mid ;
        }
      }
      System.out.println(l);
    }
  }
  static int lowerBound(int[] A,int fromInc,int toExc,int val){
    int left=fromInc,right=toExc ;
    while(right-left>1){
      int mid=(left+right)>>>1 ;
      if(A[mid]<val){
        left=mid ;
      }
      else {
        right=mid ;
      }
    }
    if(A[left]<val){
      return left+1 ;
    }
    return left ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
  static   attribute MOD : int := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var thread : OclProcess ; thread := OclProcess.newOclProcess(null, Main.newMain(), "", 32 * 1024 * 1024) ;
     thread.start() );
      operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute solve(scanner) );
  static   operation solve( scanner : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := (scanner.getCurrent())->toInteger() ;
     var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[(scanner.getCurrent())->toInteger() - 1+1] := A[(scanner.getCurrent())->toInteger() - 1+1] + 1 )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    var S : Sequence(int) ; S := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     S[i + 1+1] := S[i+1] + A[i+1] )  ;     i := i + 1 ) ; 
        var k : int ; k := 1 ; while k <= N do ( (     var l : int ; l := 0 ;
     var r : int ; r := N / k + 1 ;
     while (r - l > 1) do (     var mid : int ; mid := ((l + r)/(2->pow(1)))->oclAsType(long) ;
     var index : int ; index := lowerBound(A, 0, A->size(), mid) ;
     var sum : int ; sum := mid * (N - index) + S[index+1] ;
     if (sum >= mid * k) then (     l := mid ) else (     r := mid ) ) ; 
     OclFile["System.out"].println(l) )  ;     k := k + 1 ) ; 
 );
  static   operation lowerBound( A : Sequence(int), fromInc : int, toExc : int, val : int) : int
  pre: true
  post: true
  activity: (     var left : int ; left := fromInc ;
    var right : int ; right := toExc ;
     while (right - left > 1) do (     var mid : int ; mid := ((left + right)/(2->pow(1)))->oclAsType(long) ;
     if (A[mid+1] < val) then (     left := mid ) else (     right := mid ) ) ; 
     if (A[left+1] < val) then (     return left + 1 ) else skip ; 
     return left );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int A[]=new int[300001];
    for(int i=0 ; i<N ; ++i){
      int ai=sc.nextInt();
      A[ai]++;
    }
    int freq[]=new int[300001];
    for(int a : A){
      if(a==0){
        continue ;
      }
      freq[a]++;
    }
    long C[]=new long[N+1];
    long D[]=new long[N+1];
    for(int f=1 ; f<=N ; ++f){
      C[f]=C[f-1]+f*freq[f];
      D[f]=D[f-1]+freq[f];
    }
    int X[]=new int[N+1];
    for(int x=1 ; x<=N ; ++x){
      long f=C[x]+x*(D[N]-D[x]);
      f=f/x ;
      X[x]=(int)f ;
    }
    int res[]=new int[N+1];
    res[1]=N ;
    for(int i=N-1 ; i>=1 ; --i){
      if(X[i+1]!=X[i]){
        for(int j=X[i+1]+1 ; j<=X[i]; ++j){
          res[j]=i ;
        }
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int k=1 ; k<=N ; ++k){
      sb.append(res[k]);
      sb.append('\n');
    }
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,300001)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     var ai : int ; ai := sc.getCurrent()->toInteger() ;
     A[ai+1] := A[ai+1] + 1 )  ;     i := i + 1 ) ; 
    var freq : Sequence(int) ; freq := Integer.subrange(1,300001)->collect(0) ;
    for (a : A) do ( (     if (a = 0) then (     continue ) else skip ; 
     freq[a+1] := freq[a+1] + 1 )  ) ; 
    var C : Sequence(long) ; C := Integer.subrange(1,N + 1)->collect(0) ;
    var D : Sequence(long) ; D := Integer.subrange(1,N + 1)->collect(0) ;
        var f : int ; f := 1 ; while f <= N do ( (     C[f+1] := C[f - 1+1] + f * freq[f+1] ; 
     D[f+1] := D[f - 1+1] + freq[f+1] )  ;     f := f + 1 ) ; 
    var X : Sequence(int) ; X := Integer.subrange(1,N + 1)->collect(0) ;
        var x : int ; x := 1 ; while x <= N do ( (     var f : long ; f := C[x+1] + x * (D[N+1] - D[x+1]) ;
     f := f / x ; 
     X[x+1] := f->oclAsType(int) )  ;     x := x + 1 ) ; 
    var res : Sequence(int) ; res := Integer.subrange(1,N + 1)->collect(0) ;
    res[1+1] := N ; 
        var i : int ; i := N - 1 ; while i >= 1 do ( (     if (X[i + 1+1] /= X[i+1]) then (         var j : int ; j := X[i + 1+1] + 1 ; while j <= X[i+1] do ( (     res[j+1] := i )  ;     j := j + 1 ) ) else skip )  ;     i := i - 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var k : int ; k := 1 ; while k <= N do ( (     sb := sb + StringLib.newString(res[k+1]) ; 
     sb := sb + StringLib.newString('
') )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    boolean[] timeTable=new boolean[24*60];
    int h,m ;
    boolean isFirst ;
    for(int i=0 ; i<2 ; ++i){
      int j ;
      j=sc.nextInt();
      for(; j>0 ; --j){
        h=sc.nextInt();
        m=sc.nextInt();
        timeTable[h*60+m]=true ;
      }
    }
    isFirst=true ;
    for(h=0 ; h<24 ; ++h){
      for(m=0 ; m<60 ; ++m){
        if(timeTable[h*60+m]){
          if(! isFirst)System.out.print(" ");
          else isFirst=false ;
          System.out.format("%d:%02d",h,m);
        }
      }
    }
    System.out.println();
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var timeTable : Sequence(boolean) ; timeTable := Integer.subrange(1,24 * 60)->collect(false) ;
    var h : int ;
    var m : int ;
    var isFirst : boolean ;
        var i : int ; i := 0 ; while i < 2 do ( (     var j : int ;
     j := sc.getCurrent()->toInteger() ; 
       while j > 0 do ( (     h := sc.getCurrent()->toInteger() ; 
     m := sc.getCurrent()->toInteger() ; 
     timeTable[h * 60 + m+1] := true )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    isFirst := true ; 
        h := 0 ; while h < 24 do ( (         m := 0 ; while m < 60 do ( (     if (timeTable[h * 60 + m+1]) then (     if (not(isFirst)) then     OclFile["System.out"].print(" ") else     isFirst := false ; ;  
     OclFile["System.out"].format("%d:%02d", h, m) ) else skip )  ;     m := m + 1 ) )  ;     h := h + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    TreeSet<Time>set=new TreeSet<Time>();
    while(n-->0)set.add(new Time(scanner.nextInt(),scanner.nextInt()));
    int m=scanner.nextInt();
    while(m-->0)set.add(new Time(scanner.nextInt(),scanner.nextInt()));
    System.out.print(set.pollFirst());
    for(Time time : set)System.out.print(" "+time);
    System.out.println();
  }
  class Time implements Comparable<Time>{
    int h,m ;
    public Time(int h,int m){
      super();
      this.h=h ;
      this.m=m ;
    }
    @ Override public String toString(){
      return String.format("%d:%02d",h,m);
    }
    @ Override public int hashCode(){
      final int prime=31 ;
      int result=1 ;
      result=prime*result+getOuterType().hashCode();
      result=prime*result+h ;
      result=prime*result+m ;
      return result ;
    }
    @ Override public boolean equals(Object obj){
      if(this==obj)return true ;
      if(obj==null)return false ;
      if(getClass()!=obj.getClass())return false ;
      Time other=(Time)obj ;
      if(! getOuterType().equals(other.getOuterType()))return false ;
      if(h!=other.h)return false ;
      if(m!=other.m)return false ;
      return true ;
    }
    @ Override public int compareTo(Time o){
      if(this.h==o.h)return this.m-o.m ;
      return this.h-o.h ;
    }
    private Main getOuterType(){
      return Main.this ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var set : Set(Time) ; set := Set{} ;
        while (n > 0) do (        n := n - 1 ;     skip ;     set := set->including(Time.newTime(scanner.getCurrent()->toInteger(), scanner.getCurrent()->toInteger())) ; ;  ) ;  
    var m : int ; m := scanner.getCurrent()->toInteger() ;
        while (m > 0) do (        m := m - 1 ;     skip ;     set := set->including(Time.newTime(scanner.getCurrent()->toInteger(), scanner.getCurrent()->toInteger())) ; ;  ) ;  
    OclFile["System.out"].print(set->first()) ; 
    for (time : set) do (     OclFile["System.out"].print(" " + time) ;  ) ; 
    OclFile["System.out"].println() ; 
 );
 class Time implements Comparable<Time> {
   attribute h : int;
   static operation newTime( h : int, m : int) : Time
  pre: true
  post: true
  activity:
  ( var self : Time ;
    self := createTime();
    self.initialise(h, m);
    return self );
  operation initialise( h : int, m : int) : void
  pre: true  post: true
  activity: (     execute super() ; 
     self.h := h ; 
     self.m := m );
      operation toString() : String
  pre: true
  post: true
  activity: (     return StringLib.format("%d:%02d",Sequence{h,m}) );
      operation hashCode() : int
  pre: true
  post: true
  activity: (     var prime : int ; prime := 31 ;
     var result : int ; result := 1 ;
    result := prime * result + getOuterType().hashCode() ; 
    result := prime * result + h ; 
    result := prime * result + m ; 
    return result 
 );
      operation equals( obj : OclAny) : boolean
  pre: true
  post: true
  activity: (     if (self = obj) then     return true else skip ; 
     if (obj = null) then     return false else skip ; 
    if (getClass() /= obj->oclType()) then     return false else skip ; 
    var other : Time ; other := obj->oclAsType(Time) ;
    if (not(getOuterType() = other.getOuterType())) then     return false else skip ; 
    if (h /= other.h) then     return false else skip ; 
    if (m /= other.m) then     return false else skip ; 
    return true 
 );
      operation compareTo( o : Time) : int
  pre: true
  post: true
  activity: (     if (self.h = o.h) then     return self.m - o.m else skip ; 
     return self.h - o.h );
   operation getOuterType() : Main
  pre: true
  post: true
  activity: (     return _container->oclAsType(Main) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int n=input.nextInt();
    int k=input.nextInt();
    TreeSet<Integer>set=new TreeSet<>();
    ArrayList<Integer>ans=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      int value=input.nextInt();
      if(! set.contains(value)){
        set.add(value);
        ans.add(i+1);
      }
    }
    if(ans.size()<k){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
      for(int i=0 ; i<k ; i++){
        System.out.print(ans.get(i)+" ");
      }
      System.out.println("");
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var n : int ; n := input.nextInt() ;
    var k : int ; k := input.nextInt() ;
    var set : Set(int) ; set := Set{} ;
    var ans : Sequence(int) ; ans := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var value : int ; value := input.nextInt() ;
     if (not(set->includes(value))) then (     set := set->including(value) ; 
     ans := ans->including(i + 1) ) else skip )  ;     i := i + 1 ) ; 
    if (ans->size() < k) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ; 
         var i : int ; i := 0 ; while i < k do ( (     OclFile["System.out"].print(ans->at(i+1) + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("") ) ;  
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskB solver=new TaskB();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskB {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      HashSet<Integer>a=new HashSet<Integer>();
      for(int i=0 ; i<n ; i++){
        a.add(in.nextInt());
      }
      out.print(a.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskB ; solver := TaskB.newTaskB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskB {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Set(int) ; a := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     a := a->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  final static int NO_OF_CHARS=256 ;
  static int max_distinct_char(String str,int n){
    int count[]=new int[NO_OF_CHARS];
    for(int i=0 ; i<n ; i++){
      count[str.charAt(i)]++;
    }
    int max_distinct=0 ;
    for(int i=0 ; i<NO_OF_CHARS ; i++){
      if(count[i]!=0){
        max_distinct++;
      }
    }
    return max_distinct ;
  }
  static int smallesteSubstr_maxDistictChar(String str){
    int n=str.length();
    int max_distinct=max_distinct_char(str,n);
    int minl=n ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        String subs=null ;
        if(i<j)subs=str.substring(i,j);
        else subs=str.substring(j,i);
        int subs_lenght=subs.length();
        int sub_distinct_char=max_distinct_char(subs,subs_lenght);
        if(subs_lenght<minl && max_distinct==sub_distinct_char){
          minl=subs_lenght ;
        }
      }
    }
    return minl ;
  }
  static public void main(String[] args){
    String str="AABBBCBB" ;
    int len=smallesteSubstr_maxDistictChar(str);
    System.out.println(" The length of the smallest substring"+" consisting of maximum distinct "+"characters : "+len);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute NO_OF_CHARS : int := 256;
  static   operation max_distinct_char( str : String, n : int) : int
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,NO_OF_CHARS)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     count[str->at(i+1)+1] := count[str->at(i+1)+1] + 1 )  ;     i := i + 1 ) ; 
    var max_distinct : int ; max_distinct := 0 ;
        var i : int ; i := 0 ; while i < NO_OF_CHARS do ( (     if (count[i+1] /= 0) then (     max_distinct := max_distinct + 1 ) else skip )  ;     i := i + 1 ) ; 
    return max_distinct 
 );
  static   operation smallesteSubstr_maxDistictChar( str : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var max_distinct : int ; max_distinct := max_distinct_char(str, n) ;
    var minl : int ; minl := n ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     var subs : String ; subs := null ;
     if (i < j) then     subs := str.subrange(i+1,j) else     subs := str.subrange(j+1,i) ; ;  
    var subs_lenght : int ; subs_lenght := subs->size() ;
    var sub_distinct_char : int ; sub_distinct_char := max_distinct_char(subs, subs_lenght) ;
    if (subs_lenght < minl & max_distinct = sub_distinct_char) then (     minl := subs_lenght ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return minl 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "AABBBCBB" ;
     var len : int ; len := smallesteSubstr_maxDistictChar(str) ;
     OclFile["System.out"].println(" The length of the smallest substring" + " consisting of maximum distinct " + "characters : " + len) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import javax.xml.crypto.Data ;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] listA=new int[n];
    for(int i=0 ; i<n ; i++){
      listA[i]=sc.nextInt()*3600+sc.nextInt()*60 ;
    }
    int m=sc.nextInt();
    int[] listB=new int[m];
    for(int i=0 ; i<m ; i++){
      listB[i]=sc.nextInt()*3600+sc.nextInt()*60 ;
    }
    int[] list=new int[n+m];
    for(int i=0 ; i<n ; i++){
      list[i]=listA[i];
    }
    for(int i=0 ; i<m ; i++){
      list[i+n]=listB[i];
    }
    Arrays.sort(list);
    int pre=list[0];
    show(pre);
    for(int i=1 ; i<n+m ; i++){
      if(list[i]==pre)continue ;
      System.out.print(" ");
      show(list[i]);
      pre=list[i];
    }
    System.out.println();
  }
  static void show(int a){
    int h=a/3600 ;
    System.out.print(h+":");
    a-=h*3600 ;
    a/=60 ;
    if(a<10){
      System.out.print("0");
    }
    System.out.print(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var listA : Sequence(int) ; listA := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     listA[i+1] := sc.getCurrent()->toInteger() * 3600 + sc.getCurrent()->toInteger() * 60 )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var listB : Sequence(int) ; listB := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     listB[i+1] := sc.getCurrent()->toInteger() * 3600 + sc.getCurrent()->toInteger() * 60 )  ;     i := i + 1 ) ; 
    var list : Sequence(int) ; list := Integer.subrange(1,n + m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     list[i+1] := listA[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     list[i + n+1] := listB[i+1] )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var pre : int ; pre := list[0+1] ;
    execute show(pre) ; 
        var i : int ; i := 1 ; while i < n + m do ( (     if (list[i+1] = pre) then     continue else skip ; 
     OclFile["System.out"].print(" ") ; 
     execute show(list[i+1]) ; 
     pre := list[i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation show( a : int) : void
  pre: true
  post: true
  activity: (     var h : int ; h := a / 3600 ;
     OclFile["System.out"].print(h + ":") ; 
    a := a-(h * 3600) ; 
    a := a/(60) ; 
    if (a < 10) then (     OclFile["System.out"].print("0") ) else skip ; 
    OclFile["System.out"].print(a) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    Queue<Integer>N=new ArrayDeque<>(),M=new ArrayDeque<>();
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++)N.add(in.nextInt()*100+in.nextInt());
    int m=in.nextInt();
    for(int i=0 ; i<m ; i++)M.add(in.nextInt()*100+in.nextInt());
    Queue<Integer>res=merge(N,M);
    while(! res.isEmpty()){
      int v=res.remove();
      int j=v/100,k=v-(j*100);
      if(res.isEmpty())System.out.printf("%d:%02d\n",j,k);
      else System.out.printf("%d:%02d ",j,k);
    }
  }
  static Queue<Integer>merge(Queue<Integer>n,Queue<Integer>m){
    Queue<Integer>mg=new ArrayDeque<>();
    while(! n.isEmpty()&& ! m.isEmpty()){
      int a=n.peek(),b=m.peek();
      if(a<b)mg.add(n.remove());
      else if(a>b)mg.add(m.remove());
      else {
        mg.add(n.remove());
        m.remove();
      }
    }
    while(! n.isEmpty())mg.add(n.remove());
    while(! m.isEmpty())mg.add(m.remove());
    return mg ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : Sequence(int) ; N := ArrayDeque<OclAny>.newArrayDeque() ;
    var M : Sequence(int) ; M := ArrayDeque<OclAny>.newArrayDeque() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do (     N := N->including(in.getCurrent()->toInteger() * 100 + in.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    var m : int ; m := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do (     M->excludes(in.getCurrent()->toInteger() * 100 + in.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    var res : Sequence(int) ; res := merge(N, M) ;
    while (not(res->isEmpty())) do (     var v : int ; v := res.remove() ;
     var j : int ; j := v / 100 ;
    var k : int ; k := v - (j * 100) ;
     if (res->isEmpty()) then     OclFile["System.out"].printf("%d:%02d\n", j, k) ; else     OclFile["System.out"].printf("%d:%02d ", j, k) ; ) ; 
 );
  static   operation merge( n : Sequence(int), m : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var mg : Sequence(int) ; mg := ArrayDeque<OclAny>.newArrayDeque() ;
     while (not(n->isEmpty()) & not(m->isEmpty())) do (     var a : int ; a := n->min() ;
    var b : int ; b := m->min() ;
     if (a < b) then     mg := mg->including(n.remove()) ; else     if (a > b) then     mg := mg->including(m.remove()) else (     mg := mg->including(n.remove()) ; 
     m := m.remove() ) ;  ) ; 
    while (not(n->isEmpty())) do     mg := mg->including(n.remove()) ; ; 
    while (not(m->isEmpty())) do     mg := mg->including(m.remove()) ; ; 
    return mg 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextInt()){
      int N=sc.nextInt();
      int[] n=new int[N];
      for(int i=0 ; i<N ; i++)n[i]=sc.nextInt()*60+sc.nextInt();
      int M=sc.nextInt();
      int[] m=new int[M];
      for(int i=0 ; i<M ; i++)m[i]=sc.nextInt()*60+sc.nextInt();
      int[] nm=new int[N+M];
      for(int i=0 ; i<N ; i++)nm[i]=n[i];
      for(int i=0 ; i<M ; i++)nm[N+i]=m[i];
      Arrays.sort(nm);
      int count=0 ;
      for(int i=1 ; i<nm.length ; i++){
        if((nm[i]==nm[i-1])){
          nm[i-1]=0 ;
          count++;
        }
      }
      Arrays.sort(nm);
      for(; count<N+M ; count++){
        System.out.printf("%d:%02d",nm[count]/60,nm[count] % 60);
        if(!(count==N+M-1))System.out.print(" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextInt()) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var n : Sequence(int) ; n := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     n[i+1] := sc.getCurrent()->toInteger() * 60 + sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var m : Sequence(int) ; m := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do (     m[i+1] := sc.getCurrent()->toInteger() * 60 + sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var nm : Sequence(int) ; nm := Integer.subrange(1,N + M)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     nm[i+1] := n[i+1] ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do (     nm[N + i+1] := m[i+1] ;  ;     i := i + 1 ) ; 
    nm := nm->sort() ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < nm->size() do ( (     if ((nm[i+1] = nm[i - 1+1])) then (     nm[i - 1+1] := 0 ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    nm := nm->sort() ; 
      while count < N + M do ( (     OclFile["System.out"].printf("%d:%02d", nm[count+1] / 60, nm[count+1] mod 60) ; 
     if (not((count = N + M - 1))) then     OclFile["System.out"].print(" ") ; else skip )  ;     count := count + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public void main(Scanner sc){
    int n=sc.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    sc.close();
    if(a[0]!=0){
      System.out.println(-1);
      return ;
    }
    long cnt=0 ;
    for(int i=1 ; i<n ; i++){
      if(a[i-1]<a[i]){
        if(a[i]-a[i-1]!=1){
          System.out.println(-1);
          return ;
        }
        cnt++;
      }
      else {
        cnt+=a[i];
      }
    }
    System.out.println(cnt);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    new Main().main(sc);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    sc.close() ; 
    if (a[0+1] /= 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var cnt : long ; cnt := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i - 1+1] < a[i+1]) then (     if (a[i+1] - a[i - 1+1] /= 1) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
     cnt := cnt + 1 ) else (     cnt := cnt+(a[i+1]) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Main.newMain().main(sc) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(final String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int n=scanner.nextInt();
    final List<Integer>list=IntStream.range(0,n).mapToObj(i->scanner.nextInt()).collect(Collectors.toList());
    if(list.get(0)!=0){
      System.out.println(-1);
      return ;
    }
    long sum=list.get(list.size()-1);
    long tmp=list.get(list.size()-1);
    for(int i=list.size()-2 ; i>=0 ; i--){
      final int value=list.get(i);
      if(value<tmp-1){
        System.out.println(-1);
        return ;
      }
      if(value>i){
        System.out.println(-1);
        return ;
      }
      if(value==tmp-1){
        tmp=Math.max(tmp-1,0);
        continue ;
      }
      tmp=value ;
      sum+=value ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Integer.subrange(0, n-1).mapToObj(lambda i : OclAny in scanner.getCurrent()->toInteger()).collect(Collectors.toList()) ;
    if (list->at(0+1) /= 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var sum : long ; sum := list->at(list->size() - 1+1) ;
    var tmp : long ; tmp := list->at(list->size() - 1+1) ;
        var i : int ; i := list->size() - 2 ; while i >= 0 do ( (     var value : int ; value := list->at(i+1) ;
     if (value < tmp - 1) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    if (value > i) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    if (value = tmp - 1) then (     tmp := Set{tmp - 1, 0}->max() ; 
     continue ) else skip ; 
    tmp := value ; 
    sum := sum+(value) ; 
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  int n ;
  int[] as ;
  public static void main(String args[]){
    new Main().run();
  }
  void run(){
    FastReader sc=new FastReader();
    n=sc.nextInt();
    as=new int[n];
    for(int i=0 ; i<n ; i++){
      as[i]=sc.nextInt();
    }
    solve();
  }
  void solve(){
    if(as[0]>0){
      System.out.println(-1);
      return ;
    }
    long[] dp=new long[n];
    dp[n-1]=as[n-1];
    for(int i=n-2 ; i>=0 ; i--){
      if(as[i]>=as[i+1]){
        dp[i]=dp[i+1]+as[i];
      }
      else if(as[i]==as[i+1]-1){
        dp[i]=dp[i+1];
      }
      else {
        System.out.println(-1);
        return ;
      }
    }
    System.out.println(dp[0]);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute as : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     n := sc.nextInt() ; 
    as := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     as[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    execute solve() ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     if (as[0+1] > 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
     var dp : Sequence(long) ; dp := Integer.subrange(1,n)->collect(0) ;
    dp[n - 1+1] := as[n - 1+1] ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (as[i+1] >= as[i + 1+1]) then (     dp[i+1] := dp[i + 1+1] + as[i+1] ) else     if (as[i+1] = as[i + 1+1] - 1) then (     dp[i+1] := dp[i + 1+1] ) else (     OclFile["System.out"].println(-1) ; 
     return ) ;  )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(dp[0+1]) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static long ans(long[] A){
    int N=A.length ;
    long ans=0 ;
    if(A[N-1]>=N)return-1 ;
    ans+=A[N-1];
    long next=A[N-1]-1 ;
    for(int n=N-2 ; n>=0 ; n--){
      if(A[n]>n || A[n]<next)return-1 ;
      if(A[n]>next)ans+=A[n];
      next=A[n]-1 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[] A=new long[N];
    for(int n=0 ; n<N ; n++)A[n]=sc.nextLong();
    System.out.println(ans(A));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation ans( A : Sequence(long)) : long
  pre: true
  post: true
  activity: (     var N : int ; N := A->size() ;
     var ans : long ; ans := 0 ;
    if (A[N - 1+1] >= N) then     return -1 else skip ; 
    ans := ans+(A[N - 1+1]) ; 
    var next : long ; next := A[N - 1+1] - 1 ;
        var n : int ; n := N - 2 ; while n >= 0 do ( (     if (A[n+1] > n or A[n+1] < next) then     return -1 else skip ; 
     if (A[n+1] > next) then     ans := ans+(A[n+1]) ; else skip ; 
     next := A[n+1] - 1 )  ;     n := n - 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do (     A[n+1] := sc.getCurrent()->toLong() ;  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(ans(A)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=Integer.parseInt(scanner.nextLine());
    int[] array=new int[N];
    for(int i=0 ; i<N ; ++i){
      array[i]=Integer.parseInt(scanner.nextLine());
    }
    long count=0 ;
    int prep=0 ;
    for(int i=N-1 ; i>=0 ; --i){
      int current=array[i];
      if(current>=prep){
        count+=current ;
      }
      else if(current<prep-1){
        break ;
      }
      prep=current ;
    }
    if(prep>0){
      count=-1 ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (scanner.nextLine())->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     array[i+1] := (scanner.nextLine())->toInteger() )  ;     i := i + 1 ) ; 
    var count : long ; count := 0 ;
    var prep : int ; prep := 0 ;
        var i : int ; i := N - 1 ; while i >= 0 do ( (     var current : int ; current := array[i+1] ;
     if (current >= prep) then (     count := count+(current) ) else     if (current < prep - 1) then (     break ) else skip ; ;  
     prep := current )  ;     i := i - 1 ) ; 
    if (prep > 0) then (     count := -1 ) else skip ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main254B {
  static int cal(int month,int day){
    int[] months={
      0,31,28,31,30,31,30,31,31,30,31,30,31 };
      int res=0 ;
      for(int i=1 ; i<=month-1 ; i++)res+=months[i];
      return res+day ;
    }
    public static void main(String[] args)throws IOException {
      File in=new File("input.txt");
      Writer wr=new FileWriter("output.txt");
      Scanner sc=new Scanner(in);
      int n=sc.nextInt();
      int[] marked=new int[2*365+1];
      for(int i=0 ; i<n ; i++){
        int m=sc.nextInt();
        int d=sc.nextInt();
        int p=sc.nextInt();
        int t=sc.nextInt();
        int x=cal(m,d);
        for(int j=1 ; j<=t ; j++){
          marked[x-j+365]+=p ;
        }
      }
      int ans=0 ;
      for(int i=0 ; i<marked.length ; i++){
        ans=Math.max(marked[i],ans);
      }
      wr.write(ans+" ");
      wr.flush();
      wr.close();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main254B {
  static   operation cal( month : int, day : int) : int
  pre: true
  post: true
  activity: (     var months : Sequence(int) ; months := Sequence{0,31,28,31,30,31,30,31,31,30,31,30,31} ;
     var res : int ; res := 0 ;
         var i : int ; i := 1 ; while i <= month - 1 do (     res := res+(months[i+1]) ;  ;     i := i + 1 ) ; 
     return res + day );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile("input.txt") ;
     var wr : OclFile ; wr := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var marked : Sequence(int) ; marked := Integer.subrange(1,2 * 365 + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var m : int ; m := sc.getCurrent()->toInteger() ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var x : int ; x := cal(m, d) ;
        var j : int ; j := 1 ; while j <= t do ( (     marked[x - j + 365+1] := marked[x - j + 365+1]+(p) )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < marked->size() do ( (     ans := Set{marked[i+1], ans}->max() )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
import java.util.concurrent.ConcurrentMap ;
public class Watermelon {
  static int[] month={
    0,31,28,31,30,31,30,31,31,30,31,30,31 };
    public static void main(String[] args)throws java.lang.Exception {
      Scanner sc=new Scanner(new File("input.txt"));
      PrintWriter pw=new PrintWriter("output.txt");
      for(int i=1 ; i<=12 ; i++)month[i]+=month[i-1];
      int[] year=new int[466];
      int n=sc.nextInt();
      int m=-1,d=-1,p=-1,t=-1,temp=-1,day=-1,yeart=-1 ;
      for(int i=0 ; i<n ; i++){
        m=sc.nextInt();
        d=sc.nextInt();
        p=sc.nextInt();
        t=sc.nextInt();
        day=month[m-1]+d+100 ;
        while(t-->0)year[day-t]+=p ;
      }
      int ans=-1 ;
      for(int i=0 ; i<466 ; i++)ans=Math.max(ans,year[i]);
      pw.print(ans);
      pw.close();
      sc.close();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Watermelon {
  static   attribute month : Sequence(int) := Sequence{0,31,28,31,30,31,30,31,31,30,31,30,31};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile("input.txt")) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
        var i : int ; i := 1 ; while i <= 12 do (     month[i+1] := month[i+1]+(month[i - 1+1]) ;  ;     i := i + 1 ) ; 
    var year : Sequence(int) ; year := Integer.subrange(1,466)->collect(0) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := -1 ;
    var d : int ; d := -1 ;
    var p : int ; p := -1 ;
    var t : int ; t := -1 ;
    var temp : int ; temp := -1 ;
    var day : int ; day := -1 ;
    var yeart : int ; yeart := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     m := sc.getCurrent()->toInteger() ; 
     d := sc.getCurrent()->toInteger() ; 
    p := sc.getCurrent()->toInteger() ; 
    t := sc.getCurrent()->toInteger() ; 
    day := month[m - 1+1] + d + 100 ; 
        while (t > 0) do (        t := t - 1 ;     skip ;     year[day - t+1] := year[day - t+1]+(p) ; ;  ) ;  
 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -1 ;
        var i : int ; i := 0 ; while i < 466 do (     ans := Set{ans, year[i+1]}->max() ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1569 {
  static boolean flag ;
  static int finals ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int cases=sc.nextInt();
    while(cases-->0){
      flag=false ;
      int letters=sc.nextInt();
      String ab=sc.next();
      for(int i=1 ; i<letters ; i++){
        if(ab.charAt(i-1)!=ab.charAt(i)){
          flag=true ;
          System.out.println((i)+" "+(i+1));
          break ;
        }
      }
      if(flag==false){
        System.out.println("-1 "+"-1");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1569 {
  static   attribute flag : boolean;
  static   attribute finals : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cases : int ; cases := sc.getCurrent()->toInteger() ;
         while (cases > 0) do (        cases := cases - 1 ;     skip ; (     flag := false ; 
     var letters : int ; letters := sc.getCurrent()->toInteger() ;
    var ab : String ; ab := sc.getCurrent() ;
        var i : int ; i := 1 ; while i < letters do ( (     if (ab->at((i)->char2byte() - 1+1) /= ab->at(i+1)) then (     flag := true ; 
     OclFile["System.out"].println((i) + " " + (i + 1)) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = false) then (     OclFile["System.out"].println("-1 " + "-1") ) else skip ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static void findFibSubset(Integer[] x){
    Integer max=Collections.max(Arrays.asList(x));
    List<Integer>fib=new ArrayList<Integer>();
    List<Integer>result=new ArrayList<Integer>();
    Integer a=0 ;
    Integer b=1 ;
    while(b<max){
      Integer c=a+b ;
      a=b ;
      b=c ;
      fib.add(c);
    }
    for(Integer i=0 ; i<x.length ; i++){
      if(fib.contains(x[i])){
        result.add(x[i]);
      }
    }
    System.out.println(result);
  }
  public static void main(String args[]){
    Integer[] a={
      4,2,8,5,20,1,40,13,23 };
      findFibSubset(a);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findFibSubset( x : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var max : int ; max := .max(x) ;
     var fib : Sequence(int) ; fib := Sequence{} ;
    var result : Sequence(int) ; result := Sequence{} ;
    var a : int ; a := 0 ;
    var b : int ; b := 1 ;
    while (b < max) do (     var c : int ; c := a + b ;
     a := b ; 
     b := c ; 
     fib := fib->including(c) ) ; 
        var i : int ; i := 0 ; while i < x->size() do ( (     if (fib->includes(x[i+1])) then (     result := result->including(x[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{4,2,8,5,20,1,40,13,23} ;
     execute findFibSubset(a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _988A_DiverseTeam {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int k=input.nextInt();
    List<Integer>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      list.add(input.nextInt());
    }
    List<Integer>distinct=new ArrayList<>(new LinkedHashSet<>(list));
    if(distinct.size()<k){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
      List<Integer>result=new ArrayList<>();
      for(int i=0 ; i<k ; i++){
        int index=list.indexOf(distinct.get(i))+1 ;
        result.add(index);
      }
      System.out.println(result.toString().replaceAll("[\\[\\],] ",""));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _988A_DiverseTeam {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var k : int ; k := input.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var distinct : Sequence(int) ; distinct := Sequence{}->union(Set{}->union(list)) ;
    if (distinct->size() < k) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ; 
     var result : Sequence(int) ; result := Sequence{} ;
         var i : int ; i := 0 ; while i < k do ( (     var index : int ; index := list->indexOf(distinct->at(i+1))-1 + 1 ;
     result := result->including(index) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(result+"".replaceAllMatches("[\\[\\],] ", "" )) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileInputStream ;
import java.io.FileOutputStream ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class JurySize {
  static int[] DAYS_PER_MONTH={
    0,31,28,31,30,31,30,31,31,30,31,30,31 };
    static int[] accumDays(){
      int[] acc=new int[DAYS_PER_MONTH.length+1];
      for(int i=1 ; i<DAYS_PER_MONTH.length ; i++){
        acc[i]=DAYS_PER_MONTH[i]+acc[i-1];
      }
      return acc ;
    }
    public static void main(String[] args)throws IOException {
      int[] accumDays=accumDays();
      Scanner in=new Scanner(new FileInputStream("input.txt"));
      PrintWriter out=new PrintWriter(new FileOutputStream("output.txt"));
      int n=in.nextInt();
      int[] peoplePerDay=new int[600];
      for(int i=0 ; i<n ; i++){
        int m=in.nextInt();
        int d=in.nextInt();
        int p=in.nextInt();
        int t=in.nextInt();
        int date=accumDays[m-1]+d ;
        for(int j=date-t ; j<=date-1 ; j++){
          peoplePerDay[j+200]+=p ;
        }
      }
      int max=0 ;
      for(int i=0 ; i<peoplePerDay.length ; i++){
        max=Math.max(max,peoplePerDay[i]);
      }
      out.println(max);
      in.close();
      out.close();
      System.exit(0);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class JurySize {
  static   attribute DAYS_PER_MONTH : Sequence(int) := Sequence{0,31,28,31,30,31,30,31,31,30,31,30,31};
  static   operation accumDays() : Sequence(int)
  pre: true
  post: true
  activity: (     var acc : Sequence(int) ; acc := Integer.subrange(1,DAYS_PER_MONTH->size() + 1)->collect(0) ;
         var i : int ; i := 1 ; while i < DAYS_PER_MONTH->size() do ( (     acc[i+1] := DAYS_PER_MONTH[i+1] + acc[i - 1+1] )  ;     i := i + 1 ) ; 
     return acc );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var accumDays : Sequence(int) ; accumDays := accumDays() ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt"))) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var peoplePerDay : Sequence(int) ; peoplePerDay := Integer.subrange(1,600)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var m : int ; m := in.getCurrent()->toInteger() ;
     var d : int ; d := in.getCurrent()->toInteger() ;
    var p : int ; p := in.getCurrent()->toInteger() ;
    var t : int ; t := in.getCurrent()->toInteger() ;
    var date : int ; date := accumDays[m - 1+1] + d ;
        var j : int ; j := date - t ; while j <= date - 1 do ( (     peoplePerDay[j + 200+1] := peoplePerDay[j + 200+1]+(p) )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < peoplePerDay->size() do ( (     max := Set{max, peoplePerDay[i+1]}->max() )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
OclProcess.exit(0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isOsiris(int n){
    int a=n % 10 ;
    int b=(n/10)% 10 ;
    int c=n/100 ;
    int digit_sum=a+b+c ;
    if(n==(2*(digit_sum)*11)){
      return true ;
    }
    return false ;
  }
  public static void main(String args[]){
    int n=132 ;
    if(isOsiris(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isOsiris( n : int) : boolean
  pre: true
  post: true
  activity: (     var a : int ; a := n mod 10 ;
     var b : int ; b := (n / 10) mod 10 ;
    var c : int ; c := n / 100 ;
    var digit_sum : int ; digit_sum := a + b + c ;
    if (n = (2 * (digit_sum) * 11)) then (     return true ) else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 132 ;
     if (isOsiris(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int ar[]=new int[n];
    for(int i=0 ; i<n ; i++){
      ar[i]=scan.nextInt();
    }
    Arrays.parallelSort(ar);
    float ans=0 ;
    float lol[]=new float[n];
    lol[0]=ar[0];
    for(int i=1 ; i<n ; i++){
      lol[i]=(float)((ar[i]+lol[i-1])/2);
    }
    System.out.printf("%.04f",lol[n-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    ar := ar->sort() ; 
    var ans : double ; ans := 0 ;
    var lol : Sequence(double) ; lol := Integer.subrange(1,n)->collect(0.0) ;
    lol[0+1] := ar[0+1] ; 
        var i : int ; i := 1 ; while i < n do ( (     lol[i+1] := ((ar[i+1] + lol[i - 1+1]) / 2)->oclAsType(double) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.04f", lol[n - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int N=in.nextInt();
      PriorityQueue<Double>pq=new PriorityQueue();
      for(int i=0 ; i<N ; ++i){
        pq.add(in.nextDouble());
      }
      while(pq.size()>1){
        double ingredient1=pq.poll();
        double ingredient2=pq.poll();
        double newIngredient=(ingredient1+ingredient2)/2 ;
        pq.add(newIngredient);
      }
      System.out.println(pq.peek());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var N : int ; N := in.getCurrent()->toInteger() ;
     var pq : Sequence(double) ; pq := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     pq := pq->including(in.getCurrent()->toReal()) )  ;     i := i + 1 ) ; 
    while (pq->size() > 1) do (     var ingredient1 : double ; ingredient1 := pq->min() ;
     var ingredient2 : double ; ingredient2 := pq->min() ;
     var newIngredient : double ; newIngredient := (ingredient1 + ingredient2) / 2 ;
     pq := pq->including(newIngredient) ) ; 
    OclFile["System.out"].println(pq->min()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    List<Integer>list=new ArrayList<>();
    IntStream.range(0,N).forEachOrdered(n->list.add(sc.nextInt()));
    list.sort(Comparator.naturalOrder());
    double value=list.get(0);
    for(int i=0 ; i<N-1 ; i++){
      value=(value+list.get(i+1))/2.0 ;
    }
    System.out.println(value);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
    Integer.subrange(0, N-1).forEachOrdered(lambda n : OclAny in list->excludes(sc.getCurrent()->toInteger())) ; 
    list := list.sort(Comparator.naturalOrder()) ; 
    var value : double ; value := list->at(0+1) ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     value := (value + list->at(i + 1+1)) / 2.0 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(value) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=getInt(sc);
    int[] v=getIntArray(sc);
    Arrays.sort(v);
    double sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(i==0){
        sum=v[i];
      }
      else {
        sum=(sum+v[i])/2 ;
      }
    }
    System.out.println(sum);
  }
  public static long getLong(Scanner sc){
    return Long.parseLong(sc.next());
  }
  public static int getInt(Scanner sc){
    return Integer.parseInt(sc.next());
  }
  public static String getString(Scanner sc){
    return sc.next();
  }
  public static int[] getIntArray(Scanner sc){
    String line="" ;
    while(line.equals("")){
      line=sc.nextLine();
    }
    String[] strArray=line.split(" ");
    int[] intArray=new int[strArray.length];
    for(int i=0 ; i<strArray.length ; i++){
      intArray[i]=Integer.parseInt(strArray[i]);
    }
    return intArray ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := getInt(sc) ;
    var v : Sequence(int) ; v := getIntArray(sc) ;
    v := v->sort() ; 
    var sum : double ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i = 0) then (     sum := v[i+1] ) else (     sum := (sum + v[i+1]) / 2 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
  static   operation getLong( sc : OclFile) : long
  pre: true
  post: true
  activity: (     return (sc.getCurrent())->toLong() );
  static   operation getInt( sc : OclFile) : int
  pre: true
  post: true
  activity: (     return (sc.getCurrent())->toInteger() );
  static   operation getString( sc : OclFile) : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
  static   operation getIntArray( sc : OclFile) : Sequence(int)
  pre: true
  post: true
  activity: (     var line : String ; line := "" ;
     while (line = "") do (     line := sc.nextLine() ) ; 
    var strArray : Sequence(String) ; strArray := line->split(" ") ;
    var intArray : Sequence(int) ; intArray := Integer.subrange(1,strArray->size())->collect(0) ;
        var i : int ; i := 0 ; while i < strArray->size() do ( (     intArray[i+1] := (strArray[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    return intArray 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Main main=new Main();
    main.solve();
  }
  public void solve()throws Exception {
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=scan.nextInt();
    long[] a=new long[N];
    for(int i=0 ; i<N ; i++){
      a[i]=scan.nextLong();
    }
    Arrays.sort(a);
    double answer=a[0];
    for(int i=0 ; i<N ; i++){
      answer=(answer+(double)a[i])/2 ;
    }
    System.out.println(String.format("%.9f",answer));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := scan.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var answer : double ; answer := a[0+1] ;
        var i : int ; i := 0 ; while i < N do ( (     answer := (answer + a[i+1]->oclAsType(double)) / 2 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(StringLib.format("%.9f",Sequence{answer})) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int nCr(int n,int r){
    int ans=1 ;
    for(int i=1 ; i<=r ; i+=1){
      ans*=(n-r+i);
      ans/=i ;
    }
    return ans ;
  }
  static int total_ways(int N,int X){
    return(nCr(N-1,X-1)+nCr(N-1,X));
  }
  public static void main(String[] args){
    int N=5,X=3 ;
    System.out.println(total_ways(N,X));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nCr( n : int, r : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
         var i : int ; i := 1 ; while i <= r do ( (     ans := ans*((n - r + i)) ; 
     ans := ans/(i) )  ;     i := i+(1) ) ; 
     return ans );
  static   operation total_ways( N : int, X : int) : int
  pre: true
  post: true
  activity: (     return (nCr(N - 1, X - 1) + nCr(N - 1, X)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
    var X : int ; X := 3 ;
     OclFile["System.out"].println(total_ways(N, X)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static int[] arr=new int[100001];
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    BufferedWriter output=new BufferedWriter(new OutputStreamWriter(System.out));
    sc.nextLine();
    while(t>0){
      int n=sc.nextInt();
      sc.nextLine();
      String s=sc.nextLine();
      if(s.length()<2){
        System.out.println("-1-1");
      }
      else {
        char pre=s.charAt(0);
        int in=0 ;
        for(int i=1 ; i<n ; i++){
          if(pre!=s.charAt(i)){
            in=i ;
            break ;
          }
        }
        if(in>0){
          System.out.println(in+" "+(in+1));
        }
        else {
          System.out.println("-1-1");
        }
      }
      t--;
    }
    output.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute arr : Sequence(int) := Integer.subrange(1,100001)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var output : OclFile ; output := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    skip ; 
    while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     skip ; 
    var s : String ; s := sc.nextLine() ;
    if (s->size() < 2) then (     OclFile["System.out"].println("-1-1") ) else (     var pre : String ; pre := s->at(0+1) ;
     var in : int ; in := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     if (pre /= s->at(i+1)) then (     in := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (in > 0) then (     OclFile["System.out"].println(in + " " + (in + 1)) ) else (     OclFile["System.out"].println("-1-1") ) ) ;  
    t := t - 1 ; 
 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int submatrixXor(int[][] arr){
    int n=3 ;
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        int top_left=(i+1)*(j+1);
        int bottom_right=(n-i)*(n-j);
        if((top_left % 2==1)&&(bottom_right % 2==1))ans=(ans ^ arr[i][j]);
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int[][] arr={
      {
        6,7,13 },{
          8,3,4 },{
            9,7,6 }
          };
          System.out.println(submatrixXor(arr));
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation submatrixXor( arr : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     var top_left : int ; top_left := (i + 1) * (j + 1) ;
     var bottom_right : int ; bottom_right := (n - i) * (n - j) ;
     if ((top_left mod 2 = 1) & (bottom_right mod 2 = 1)) then     ans := (MathLib.bitwiseXor(ans,arr[i+1][j+1])) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{6,7,13},Sequence{8,3,4},Sequence{9,7,6}} ;
     OclFile["System.out"].println(submatrixXor(arr)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void minimumColors(int N,int E,int U[],int V[]){
    Vector<Integer>[] adj=new Vector[N];
    int[] count=new int[N];
    int[] colors=new int[N];
    for(int i=0 ; i<N ; i++){
      adj[i]=new Vector<Integer>();
      colors[i]=1 ;
    }
    for(int i=0 ; i<N ; i++){
      adj[V[i]-1] .add(U[i]-1);
      count[U[i]-1]++;
    }
    Queue<Integer>Q=new LinkedList<>();
    for(int i=0 ; i<N ; i++){
      if(count[i]==0){
        Q.add(i);
      }
    }
    while(! Q.isEmpty()){
      int u=Q.peek();
      Q.remove();
      for(int x : adj[u]){
        count[x]--;
        if(count[x]==0){
          Q.add(x);
        }
        if(colors[x]<=colors[u]){
          colors[x]=1+colors[u];
        }
      }
    }
    int minColor=-1 ;
    for(int i=0 ; i<N ; i++){
      minColor=Math.max(minColor,colors[i]);
    }
    System.out.print(minColor+"\n");
  }
  public static void main(String[] args){
    int N=5,E=6 ;
    int U[]={
      1,2,3,1,2,3 };
      int V[]={
        3,3,4,4,5,5 };
        minimumColors(N,E,U,V);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumColors( N : int, E : int, U : Sequence(int), V : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var adj : Sequence(Sequence(int)) ; adj := Integer.subrange(1,N)->collect(null) ;
     var count : Sequence(int) ; count := Integer.subrange(1,N)->collect(0) ;
    var colors : Sequence(int) ; colors := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     adj[i+1] := Sequence{} ; 
     colors[i+1] := 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     adj[V[i+1] - 1+1]->excludes(U[i+1] - 1) ; 
     count[U[i+1] - 1+1] := count[U[i+1] - 1+1] + 1 )  ;     i := i + 1 ) ; 
    var Q : Sequence(int) ; Q := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     if (count[i+1] = 0) then (     Q := Q->including(i) ) else skip )  ;     i := i + 1 ) ; 
    while (not(Q->isEmpty())) do (     var u : int ; u := Q->min() ;
     Q := Q.remove() ; 
     for (x : adj[u+1]) do ( (     count[x+1] := count[x+1] - 1 ; 
     if (count[x+1] = 0) then (     Q := Q->including(x) ) else skip ; 
     if (colors[x+1] <= colors[u+1]) then (     colors[x+1] := 1 + colors[u+1] ) else skip )  ) ) ; 
    var minColor : int ; minColor := -1 ;
        var i : int ; i := 0 ; while i < N do ( (     minColor := Set{minColor, colors[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(minColor + "\n") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
    var E : int ; E := 6 ;
     var U : Sequence(int) ; U := Sequence{1,2,3,1,2,3} ;
     var V : Sequence(int) ; V := Sequence{3,3,4,4,5,5} ;
     execute minimumColors(N, E, U, V) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),k=sc.nextInt();
    int a[]=new int[1000];
    int b[]=new int[1000];
    ArrayList<Integer>list=new ArrayList<>();
    for(int i=1 ; i<=n ; i++){
      int x=sc.nextInt();
      a[i]=x ;
    }
    int sum=0 ;
    for(int i=1 ; i<=n ; i++){
      if(b[a[i] ]==0){
        b[a[i] ]=1 ;
        list.add(i);
      }
    }
    if(list.size()>=k){
      System.out.println("YES");
      for(int i=0 ; i<k ; i++){
        System.out.print(list.get(i)+" ");
      }
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,1000)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,1000)->collect(0) ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 1 ; while i <= n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     a[i+1] := x )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (b[a[i+1]+1] = 0) then (     b[a[i+1]+1] := 1 ; 
     list := list->including(i) ) else skip )  ;     i := i + 1 ) ; 
    if (list->size() >= k) then (     OclFile["System.out"].println("YES") ; 
         var i : int ; i := 0 ; while i < k do ( (     OclFile["System.out"].print(list->at(i+1) + " ") )  ;     i := i + 1 ) ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextLong();
    int l=0,r=0 ;
    long ans=0,sum=0 ;
    while(l<n){
      while(r<n && sum+a[r]==(sum ^ a[r])){
        sum+=a[r];
        r++;
      }
      ans+=r-l ;
      sum-=a[l];
      l++;
      if(l>r)r=l ;
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    var ans : long ; ans := 0 ;
    var sum : long ; sum := 0 ;
    while (l < n) do (     while (r < n & sum + a[r+1] = (MathLib.bitwiseXor(sum,a[r+1]))) do (     sum := sum+(a[r+1]) ; 
     r := r + 1 ) ; 
     ans := ans+(r - l) ; 
    sum := sum-(a[l+1]) ; 
    l := l + 1 ; 
    if (l > r) then     r := l ; else skip ; 
 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    XorSum2 solver=new XorSum2();
    solver.solve(1,in,out);
    out.close();
  }
  static class XorSum2 {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      long[] a=new long[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextLong();
      }
      long result=0 ;
      long sum=0 ;
      int right=0 ;
      for(int left=0 ; left<n ; left++){
        while(right<n &&((sum+a[right])==(sum ^ a[right]))){
          sum=sum+a[right];
          right++;
        }
        result+=right-left ;
        if(left==right){
          right++;
        }
        else {
          sum-=a[left];
        }
      }
      out.print(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : XorSum2 ; solver := XorSum2.newXorSum2() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class XorSum2 {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var result : long ; result := 0 ;
    var sum : long ; sum := 0 ;
    var right : int ; right := 0 ;
        var left : int ; left := 0 ; while left < n do ( (     while (right < n & ((sum + a[right+1]) = (MathLib.bitwiseXor(sum,a[right+1])))) do (     sum := sum + a[right+1] ; 
     right := right + 1 ) ; 
     result := result+(right - left) ; 
     if (left = right) then (     right := right + 1 ) else (     sum := sum-(a[left+1]) ) )  ;     left := left + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    try(Scanner in=new Scanner(System.in)){
      int N=in.nextInt();
      int[] A=new int[N];
      for(int i=0 ; i<N ; i++){
        A[i]=in.nextInt();
      }
      long count=0 ;
      {
        int xor=0 ;
        int plus=0 ;
        int length=0 ;
        for(int l=0,r=0 ; ; l++){
          for(; ; r++){
            if(r<N){
              xor ^=A[r];
              plus+=A[r];
            }
            else {
              count+=length ;
              break ;
            }
            if(xor==plus){
              length++;
            }
            else {
              count+=length ;
              xor ^=A[r];
              plus-=A[r];
              break ;
            }
          }
          if(l>=N){
            break ;
          }
          xor ^=A[l];
          plus-=A[l];
          length--;
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := in.getCurrent()->toInteger() ;
     var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : long ; count := 0 ;
(     var xor : int ; xor := 0 ;
     var plus : int ; plus := 0 ;
     var length : int ; length := 0 ;
         var l : int ; l := 0 ;
    var r : int ; r := 0 ; while true do ( (       while true do ( (     if (r < N) then (     xor := MathLib.bitwiseXor(xor,A[r+1]) ; 
     plus := plus+(A[r+1]) ) else (     count := count+(length) ; 
     break ) ;  
     if (xor = plus) then (     length := length + 1 ) else (     count := count+(length) ; 
     xor := MathLib.bitwiseXor(xor,A[r+1]) ; 
     plus := plus-(A[r+1]) ; 
     break ) )  ;     r := r + 1 ) ; 
     if (l >= N) then (     break ) else skip ; 
    xor := MathLib.bitwiseXor(xor,A[l+1]) ; 
    plus := plus-(A[l+1]) ; 
    length := length - 1 ; 
 )  ;     l := l + 1 ) ) 
    OclFile["System.out"].println(count) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      long[] a=IntStream.range(0,n).mapToLong(i->scanner.nextLong()).toArray();
      long answer=0L,sum=0L ;
      int right=0 ;
      for(int left=0 ; left<n ; left++){
        while((right<n)&&(sum+a[right]==(sum ^ a[right]))){
          sum+=a[right];
          right++;
        }
        answer+=right-left ;
        sum-=a[left];
      }
      System.out.println(answer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(0, n-1)->collect( _x1 | (lambda i : OclAny in scanner.getCurrent()->toLong())->apply(_x1) )->asSequence() ;
    var answer : long ; answer := 0L ;
    var sum : long ; sum := 0L ;
    var right : int ; right := 0 ;
        var left : int ; left := 0 ; while left < n do ( (     while ((right < n) & (sum + a[right+1] = (MathLib.bitwiseXor(sum,a[right+1])))) do (     sum := sum+(a[right+1]) ; 
     right := right + 1 ) ; 
     answer := answer+(right - left) ; 
     sum := sum-(a[left+1]) )  ;     left := left + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int i ;
    for(i=0 ; Math.pow(2,i+1)<=a ; i++){
    }
    System.out.println((int)Math.pow(2,i));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var i : int ;
        i := 0 ; while 2->pow(i + 1) <= a do ( skip  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(2->pow(i)->oclAsType(int)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.InputMismatchException ;
import java.io.IOException ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskB solver=new TaskB();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskB {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      out.println((int)Math.pow(2,(int)(Math.log(n)/Math.log(2))));
    }
  }
  static class InputReader {
    private final InputStream stream ;
    private final byte[] buf=new byte[8192];
    private int curChar ;
    private int snumChars ;
    public InputReader(InputStream st){
      this.stream=st ;
    }
    public int read(){
      if(snumChars==-1)throw new InputMismatchException();
      if(curChar>=snumChars){
        curChar=0 ;
        try {
          snumChars=stream.read(buf);
        }
        catch(IOException e){
          throw new InputMismatchException();
        }
        if(snumChars<=0)return-1 ;
      }
      return buf[curChar++];
    }
    public int nextInt(){
      int c=read();
      while(isSpaceChar(c)){
        c=read();
      }
      int sgn=1 ;
      if(c=='-'){
        sgn=-1 ;
        c=read();
      }
      int res=0 ;
      do {
        res*=10 ;
        res+=c-'0' ;
        c=read();
      }
      while(! isSpaceChar(c));
      return res*sgn ;
    }
    public boolean isSpaceChar(int c){
      return c==' ' || c=='\n' || c=='\r' || c=='\t' || c==-1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskB ; solver := TaskB.newTaskB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskB {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     skip );
}
  static class InputReader {
   attribute stream : OclFile;
   attribute buf : Sequence(int) := Integer.subrange(1,8192)->collect(0);
   attribute curChar : int;
   attribute snumChars : int;
   static operation newInputReader( st : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(st);
    return self );
  operation initialise( st : OclFile) : void
  pre: true  post: true
  activity: (     self.stream := st );
   operation read() : int
  pre: true
  post: true
  activity: (     if (snumChars = -1) then     error IncorrectElementException() ; else skip ; 
     if (curChar >= snumChars) then (     curChar := 0 ; 
     try (     snumChars := stream.read(buf) )   catch (e : IOException) do (     error IncorrectElementException() )
     if (snumChars <= 0) then     return -1 else skip ) else skip ; 
     return buf[curChar+1] );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     var c : int ; c := read() ;
     while (isSpaceChar(c)) do (     c := read() ) ; 
    var sgn : int ; sgn := 1 ;
    if (c = '-') then (     sgn := -1 ; 
     c := read() ) else skip ; 
    var res : int ; res := 0 ;
  while true do ((     res := res*(10) ; 
     res := res+(c - ('0')->char2byte()) ; 
     c := read() ) ;
    if (not(isSpaceChar(c))) then skip else break) ; 
    return res * sgn 
 );
   operation isSpaceChar( c : int) : boolean
  pre: true
  post: true
  activity: (     return c = ' ' or c = '
' or c = '\r' or c = '\t' or c = -1 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
import java.util.*;
import java.lang.Math ;
import java.util.StringTokenizer ;
public class twelve {
  public static void main(String[] args){
    int a,b,t ;
    String str ;
    FastReader in=new FastReader();
    t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      str=in.nextLine();
      int pos1=0 ;
      int pos2=0 ;
      char[] arr=str.toCharArray();
      if(arr.length>1){
        for(int i=0 ; i<n-1 ; i++){
          if(arr[i]!=arr[i+1]){
            pos1=i+1 ;
            pos2=i+2 ;
            break ;
          }
        }
        if(pos1!=0 && pos2!=0){
          System.out.println(pos1+" "+pos2);
        }
        else {
          System.out.println(-1+" "+-1);
        }
      }
      else {
        System.out.println(-1+" "+-1);
      }
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class twelve {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ;
    var b : int ;
    var t : int ;
     var str : String ;
    var in : FastReader ; in := FastReader.newFastReader() ;
    t := in.nextInt() ; 
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.nextInt() ;
     str := in.nextLine() ; 
    var pos1 : int ; pos1 := 0 ;
    var pos2 : int ; pos2 := 0 ;
    var arr : Sequence(String) ; arr := str->characters() ;
    if (arr->size() > 1) then (         var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] /= arr[i + 1+1]) then (     pos1 := i + 1 ; 
     pos2 := i + 2 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (pos1 /= 0 & pos2 /= 0) then (     OclFile["System.out"].println(pos1 + " " + pos2) ) else (     OclFile["System.out"].println(-1 + " " + -1) ) ) else (     OclFile["System.out"].println(-1 + " " + -1) ) ;  
 ) ;  ) ;  
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static Scanner sc ;
  private static Printer pr ;
  private static void solve(){
    int n=sc.nextInt();
    if(n==1){
      pr.println(1);
    }
    else {
      int p2=2 ;
      while(p2*2<=n){
        p2*=2 ;
      }
      pr.println(p2);
    }
  }
  public static void main(String[] args){
    sc=new Scanner(System.in);
    pr=new Printer(System.out);
    solve();
    pr.close();
    sc.close();
  }
  private static class Printer extends PrintWriter {
    Printer(PrintStream out){
      super(out);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile;
  static   attribute pr : Printer;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 1) then (     pr.println(1) ) else (     var p2 : int ; p2 := 2 ;
     while (p2 * 2 <= n) do (     p2 := p2*(2) ) ; 
     pr.println(p2) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     pr := Printer.newPrinter(OclFile["System.out"]) ; 
    execute solve() ; 
    pr.close() ; 
    skip ; 
 );
  static class Printer extends OclFile {
   static operation newPrinter( out : OclFile) : Printer
  pre: true
  post: true
  activity:
  ( var self : Printer ;
    self := createPrinter();
    self.initialise(out);
    return self );
  operation initialise( out : OclFile) : void
  pre: true  post: true
  activity: (     execute super(out) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args)throws IOException {
    Scanner Input=new Scanner(System.in);
    int N=Input.nextInt();
    if(N==1){
      System.out.println("1");
    }
    else {
      int X=1 ;
      while(X<=N){
        X*=2 ;
      }
      System.out.println(X/2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Input : OclFile ; Input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := Input.getCurrent()->toInteger() ;
     if (N = 1) then (     OclFile["System.out"].println("1") ) else (     var X : int ; X := 1 ;
     while (X <= N) do (     X := X*(2) ) ; 
     OclFile["System.out"].println(X / 2) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    sc.close();
    int[] a=new int[7];
    a[0]=1 ;
    for(int i=1 ; i<7 ; i++){
      a[i]=a[i-1]*2 ;
    }
    for(int i=0 ; i<7 ; i++){
      if(N==a[i]){
        System.out.println(N);
        System.exit(0);
      }
      else if(N<a[i]){
        System.out.println(a[i-1]);
        System.exit(0);
      }
    }
    System.out.println(a[6]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,7)->collect(0) ;
    a[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < 7 do ( (     a[i+1] := a[i - 1+1] * 2 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 7 do ( (     if (N = a[i+1]) then (     OclFile["System.out"].println(N) ; 
 OclProcess.exit(0) ) else     if (N < a[i+1]) then (     OclFile["System.out"].println(a[i - 1+1]) ; 
 OclProcess.exit(0) ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a[6+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),k=sc.nextInt();
    int a[]=new int[1000];
    int b[]=new int[1000];
    ArrayList<Integer>list=new ArrayList<>();
    for(int i=1 ; i<=n ; i++){
      int x=sc.nextInt();
      a[i]=x ;
    }
    int sum=0 ;
    for(int i=1 ; i<=n ; i++){
      if(b[a[i] ]==0){
        b[a[i] ]=1 ;
        list.add(i);
      }
    }
    if(list.size()>=k){
      System.out.println("YES");
      for(int i=0 ; i<k ; i++){
        System.out.print(list.get(i)+" ");
      }
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,1000)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,1000)->collect(0) ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 1 ; while i <= n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     a[i+1] := x )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (b[a[i+1]+1] = 0) then (     b[a[i+1]+1] := 1 ; 
     list := list->including(i) ) else skip )  ;     i := i + 1 ) ; 
    if (list->size() >= k) then (     OclFile["System.out"].println("YES") ; 
         var i : int ; i := 0 ; while i < k do ( (     OclFile["System.out"].print(list->at(i+1) + " ") )  ;     i := i + 1 ) ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void SieveOfEratosthenes(boolean prime[],int p_size){
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=p_size ; p++){
      if(prime[p]){
        for(int i=p*2 ; i<=p_size ; i+=p)prime[i]=false ;
      }
    }
  }
  static int maxPrimeSubarray(int arr[],int n){
    int max_ele=Arrays.stream(arr).max().getAsInt();
    boolean prime[]=new boolean[max_ele+1];
    Arrays.fill(prime,true);
    SieveOfEratosthenes(prime,max_ele);
    int current_max=0,max_so_far=0 ;
    for(int i=0 ; i<n ; i++){
      if(prime[arr[i] ]==false)current_max=0 ;
      else {
        current_max++;
        max_so_far=Math.max(current_max,max_so_far);
      }
    }
    return max_so_far ;
  }
  public static void main(String[] args){
    int arr[]={
      1,0,2,4,3,29,11,7,8,9 };
      int n=arr.length ;
      System.out.print(maxPrimeSubarray(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation SieveOfEratosthenes( prime : Sequence(boolean), p_size : int) : void
  pre: true
  post: true
  activity: (     prime[0+1] := false ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p <= p_size do ( (     if (prime[p+1]) then (         var i : int ; i := p * 2 ; while i <= p_size do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation maxPrimeSubarray( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max_ele : int ; max_ele := stream(arr).max().getAsInt() ;
     var prime : Sequence(boolean) ; prime := Integer.subrange(1,max_ele + 1)->collect(false) ;
    prime := prime->collect(true) ; 
    execute SieveOfEratosthenes(prime, max_ele) ; 
    var current_max : int ; current_max := 0 ;
    var max_so_far : int ; max_so_far := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (prime[arr[i+1]+1] = false) then     current_max := 0 ; else (     current_max := current_max + 1 ; 
     max_so_far := Set{current_max, max_so_far}->max() ) )  ;     i := i + 1 ) ; 
    return max_so_far 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,0,2,4,3,29,11,7,8,9} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(maxPrimeSubarray(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int solve(int[][] dp,int wt,int K,int M,int used){
    if(wt<0){
      return 0 ;
    }
    if(wt==0){
      if(used==1){
        return 1 ;
      }
      return 0 ;
    }
    if(dp[wt][used]!=-1){
      return dp[wt][used];
    }
    int ans=0 ;
    for(int i=1 ; i<=K ; i++){
      if(i>=M){
        ans+=solve(dp,wt-i,K,M,used | 1);
      }
      else {
        ans+=solve(dp,wt-i,K,M,used);
      }
    }
    return dp[wt][used]=ans ;
  }
  public static void main(String[] args){
    int W=3,K=3,M=2 ;
    int[][] dp=new int[W+1][2];
    for(int i=0 ; i<W+1 ; i++){
      for(int j=0 ; j<2 ; j++){
        dp[i][j]=-1 ;
      }
    }
    System.out.print(solve(dp,W,K,M,0)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( dp : Sequence(Sequence(int)), wt : int, K : int, M : int, used : int) : int
  pre: true
  post: true
  activity: (     if (wt < 0) then (     return 0 ) else skip ; 
     if (wt = 0) then (     if (used = 1) then (     return 1 ) else skip ; 
     return 0 ) else skip ; 
    if (dp[wt+1][used+1] /= -1) then (     return dp[wt+1][used+1] ) else skip ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= K do ( (     if (i >= M) then (     ans := ans+(solve(dp, wt - i, K, M, used or 1)) ) else (     ans := ans+(solve(dp, wt - i, K, M, used)) ) )  ;     i := i + 1 ) ; 
    return dp[wt+1][used+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var W : int ; W := 3 ;
    var K : int ; K := 3 ;
    var M : int ; M := 2 ;
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,W + 1)->collect(Integer.subrange(1,2)->collect(0)) ;
         var i : int ; i := 0 ; while i < W + 1 do ( (         var j : int ; j := 0 ; while j < 2 do ( (     dp[i+1][j+1] := -1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(solve(dp, W, K, M, 0) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  private void solve()throws IOException {
    int n=nextInt();
    long e=nextInt();
    long t=nextInt();
    long[] x=new long[n+1];
    for(int i=0 ; i<n ; i++){
      x[i]=nextInt();
    }
    x[n]=e ;
    long[] d=new long[n+1];
    long min=Long.MAX_VALUE ;
    int j=n-1 ;
    for(int i=n-1 ; i>=0 ; i--){
      while((x[j]-x[i])*2>t){
        min=Math.min(min,d[j+1]+(x[j+1]-x[j])+3*x[j]);
        j--;
      }
      d[i]=d[j+1]+t+(x[j+1]-x[i]);
      if(min<Long.MAX_VALUE){
        d[i]=Math.min(d[i],min-3*x[i]);
      }
    }
    out.println(x[0]+d[0]);
  }
  private BufferedReader br ;
  private PrintWriter out ;
  private StringTokenizer st ;
  String next()throws IOException {
    while(st==null || ! st.hasMoreTokens()){
      st=new StringTokenizer(br.readLine());
    }
    return st.nextToken();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(System.out);
    solve();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var e : long ; e := nextInt() ;
    var t : long ; t := nextInt() ;
    var x : Sequence(long) ; x := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := nextInt() )  ;     i := i + 1 ) ; 
    x[n+1] := e ; 
    var d : Sequence(long) ; d := Integer.subrange(1,n + 1)->collect(0) ;
    var min : long ; min := "9223372036854775807"->toLong() ;
    var j : int ; j := n - 1 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     while ((x[j+1] - x[i+1]) * 2 > t) do (     min := Set{min, d[j + 1+1] + (x[j + 1+1] - x[j+1]) + 3 * x[j+1]}->min() ; 
     j := j - 1 ) ; 
     d[i+1] := d[j + 1+1] + t + (x[j + 1+1] - x[i+1]) ; 
     if (min < "9223372036854775807"->toLong()) then (     d[i+1] := Set{d[i+1], min - 3 * x[i+1]}->min() ) else skip )  ;     i := i - 1 ) ; 
    out.println(x[0+1] + d[0+1]) ; 
 );
   attribute br : OclFile;
   attribute out : OclFile;
   attribute st : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     execute solve() ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner scanner=new Scanner(System.in).useDelimiter(",");
    String ln1=scanner.nextLine();
    int w=Integer.parseInt(ln1);
    String ln2=scanner.nextLine();
    int n=Integer.parseInt(ln2);
    int a,b,c ;
    int x[]=new int[30];
    for(int i=0 ; i<w ; i++){
      x[i]=i+1 ;
    }
    for(int i=0 ; i<n ; i++){
      String ln3=scanner.nextLine();
      String ln4[]=ln3.split(",",0);
      a=Integer.parseInt(ln4[0]);
      b=Integer.parseInt(ln4[1]);
      c=x[a-1];
      x[a-1]=x[b-1];
      x[b-1]=c ;
    }
    for(int i=0 ; i<w ; i++){
      System.out.println(x[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]).useDelimiter(",") ;
     var ln1 : String ; ln1 := scanner.nextLine() ;
    var w : int ; w := (ln1)->toInteger() ;
    var ln2 : String ; ln2 := scanner.nextLine() ;
    var n : int ; n := (ln2)->toInteger() ;
    var a : int ;
    var b : int ;
    var c : int ;
    var x : Sequence(int) ; x := Integer.subrange(1,30)->collect(0) ;
        var i : int ; i := 0 ; while i < w do ( (     x[i+1] := i + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var ln3 : String ; ln3 := scanner.nextLine() ;
     var ln4 : Sequence(String) ; ln4 := ln3->split(",") ;
    a := (ln4[0+1])->toInteger() ; 
    b := (ln4[1+1])->toInteger() ; 
    c := x[a - 1+1] ; 
    x[a - 1+1] := x[b - 1+1] ; 
    x[b - 1+1] := c ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < w do ( (     OclFile["System.out"].println(x[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class Main {
  public static final int FIRST_NUMBER=0 ;
  public static final int SECOND_NUMBER=1 ;
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int vertical=Integer.parseInt(br.readLine());
    int horizontal=Integer.parseInt(br.readLine());
    List<int[]>changeRequests=new ArrayList<>();
    for(int i=0 ; i<horizontal ; i++){
      String[] changeRequestStr=br.readLine().split(",");
      int[] changeRequest=new int[2];
      changeRequest[FIRST_NUMBER]=Integer.parseInt(changeRequestStr[FIRST_NUMBER]);
      changeRequest[SECOND_NUMBER]=Integer.parseInt(changeRequestStr[SECOND_NUMBER]);
      changeRequests.add(changeRequest);
    }
    int[] outputArray=getDrawedArray(changeRequests,vertical,horizontal);
    for(int i=1 ; i<outputArray.length ; i++){
      System.out.println(outputArray[i]);
    }
  }
  private static int[] getDrawedArray(List<int[]>changeRequests,int vertical,int horizontal){
    int[] outputArray=new int[vertical+1];
    for(int i=1 ; i<outputArray.length ; i++){
      outputArray[i]=i ;
    }
    for(int[] changeRequest : changeRequests){
      int mediator=0 ;
      mediator=outputArray[changeRequest[FIRST_NUMBER] ];
      outputArray[changeRequest[FIRST_NUMBER] ]=outputArray[changeRequest[SECOND_NUMBER] ];
      outputArray[changeRequest[SECOND_NUMBER] ]=mediator ;
    }
    return outputArray ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute FIRST_NUMBER : int := 0;
  static    attribute SECOND_NUMBER : int := 1;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var vertical : int ; vertical := (br.readLine())->toInteger() ;
    var horizontal : int ; horizontal := (br.readLine())->toInteger() ;
    var changeRequests : Sequence(Sequence(int)) ; changeRequests := Sequence{} ;
        var i : int ; i := 0 ; while i < horizontal do ( (     var changeRequestStr : Sequence(String) ; changeRequestStr := br.readLine()->split(",") ;
     var changeRequest : Sequence(int) ; changeRequest := Integer.subrange(1,2)->collect(0) ;
    changeRequest[FIRST_NUMBER+1] := (changeRequestStr[FIRST_NUMBER+1])->toInteger() ; 
    changeRequest[SECOND_NUMBER+1] := (changeRequestStr[SECOND_NUMBER+1])->toInteger() ; 
    changeRequests := changeRequests->including(changeRequest) ; 
 )  ;     i := i + 1 ) ; 
    var outputArray : Sequence(int) ; outputArray := getDrawedArray(changeRequests, vertical, horizontal) ;
        var i : int ; i := 1 ; while i < outputArray->size() do ( (     OclFile["System.out"].println(outputArray[i+1]) )  ;     i := i + 1 ) ; 
 );
  static   operation getDrawedArray( changeRequests : Sequence(Sequence(int)), vertical : int, horizontal : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var outputArray : Sequence(int) ; outputArray := Integer.subrange(1,vertical + 1)->collect(0) ;
         var i : int ; i := 1 ; while i < outputArray->size() do ( (     outputArray[i+1] := i )  ;     i := i + 1 ) ; 
     for (changeRequest : changeRequests) do ( (     var mediator : int ; mediator := 0 ;
     mediator := outputArray[changeRequest[FIRST_NUMBER+1]+1] ; 
     outputArray[changeRequest[FIRST_NUMBER+1]+1] := outputArray[changeRequest[SECOND_NUMBER+1]+1] ; 
     outputArray[changeRequest[SECOND_NUMBER+1]+1] := mediator )  ) ; 
     return outputArray );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.lang.Math ;
class Main {
  public static void main(String[] args){
    InputStreamReader inputStreamReader=new InputStreamReader(System.in);
    BufferedReader reader=new BufferedReader(inputStreamReader);
    String str ;
    int[] num ;
    boolean flag=false ;
    boolean first=true ;
    boolean second=true ;
    int[] lots=null ;
    int w=0 ;
    int n=0 ;
    try {
      while(flag || reader.ready()){
        str=reader.readLine();
        num=getNum(str);
        if(first){
          w=num[0];
          lots=new int[w];
          for(int i=0 ; i<w ; i++)lots[i]=i+1 ;
          first=false ;
          continue ;
        }
        else if(second){
          n=num[0];
          second=false ;
          continue ;
        }
        swap(lots,num[0]-1,num[1]-1);
        if(--n==0)break ;
      }
      for(int i=0 ; i<w ; i++)System.out.println(lots[i]);
      reader.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  private static int[] getNum(String str){
    String[] data=str.split(",");
    int[] num=new int[data.length];
    for(int i=0 ; i<data.length ; i++){
      num[i]=Integer.parseInt(data[i]);
    }
    return num ;
  }
  private static void swap(int[] box,int a,int b){
    int[] temp=new int[box.length];
    temp[a]=box[a];
    box[a]=box[b];
    box[b]=temp[a];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStreamReader : OclFile ; inputStreamReader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(inputStreamReader) ;
    var str : String ;
    var num : Sequence(int) ;
    var flag : boolean ; flag := false ;
    var first : boolean ; first := true ;
    var second : boolean ; second := true ;
    var lots : Sequence(int) ; lots := null ;
    var w : int ; w := 0 ;
    var n : int ; n := 0 ;
    try (     while (flag or reader.canRead()) do (     str := reader.readLine() ; 
     num := getNum(str) ; 
    if (first) then (     w := num[0+1] ; 
     lots := Integer.subrange(1,w)->collect(0) ; 
        var i : int ; i := 0 ; while i < w do (     lots[i+1] := i + 1 ;  ;     i := i + 1 ) ; 
    first := false ; 
    continue 
 ) else     if (second) then (     n := num[0+1] ; 
     second := false ; 
     continue ) else skip ; ;  
    execute swap(lots, num[0+1] - 1, num[1+1] - 1) ; 
    if ((n - 1) = 0) then     break else skip ; 
 ) ; 
         var i : int ; i := 0 ; while i < w do (     OclFile["System.out"].println(lots[i+1]) ;  ;     i := i + 1 ) ; 
     skip )   catch (e : IOException) do (     e.printStackTrace() )
 );
  static   operation getNum( str : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var data : Sequence(String) ; data := str->split(",") ;
     var num : Sequence(int) ; num := Integer.subrange(1,data->size())->collect(0) ;
         var i : int ; i := 0 ; while i < data->size() do ( (     num[i+1] := (data[i+1])->toInteger() )  ;     i := i + 1 ) ; 
     return num );
  static   operation swap( box : Sequence(int), a : int, b : int) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(int) ; temp := Integer.subrange(1,box->size())->collect(0) ;
     temp[a+1] := box[a+1] ; 
     box[a+1] := box[b+1] ; 
     box[b+1] := temp[a+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test277 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      char[] a=in.next().toCharArray();
      boolean x=true ;
      for(int i=1 ; i<a.length ; i++){
        if(a[i]!=a[i-1]){
          x=false ;
          System.out.println((i)+" "+(i+1));
          break ;
        }
      }
      if(x){
        System.out.println("-1-1");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test277 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(String) ; a := in.getCurrent()->characters() ;
    var x : boolean ; x := true ;
        var i : int ; i := 1 ; while i < a->size() do ( (     if (a[i+1] /= a[i - 1+1]) then (     x := false ; 
     OclFile["System.out"].println((i) + " " + (i + 1)) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (x) then (     OclFile["System.out"].println("-1-1") ) else skip ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    int w=Integer.parseInt(input());
    int[] amida=new int[w];
    for(int i=0 ; i<w ; i++){
      amida[i]=i+1 ;
    }
    int n=Integer.parseInt(input());
    for(int j=0 ; j<n ; j++){
      String[] change=input().split(",");
      int temp=amida[Integer.parseInt(change[0])-1];
      amida[Integer.parseInt(change[0])-1]=amida[Integer.parseInt(change[1])-1];
      amida[Integer.parseInt(change[1])-1]=temp ;
    }
    for(int k : amida){
      System.out.println(k);
    }
    close();
  }
  public static String input(){
    return scanner.nextLine();
  }
  public static void close(){
    if(scanner!=null){
      scanner.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var w : int ; w := (input())->toInteger() ;
     var amida : Sequence(int) ; amida := Integer.subrange(1,w)->collect(0) ;
        var i : int ; i := 0 ; while i < w do ( (     amida[i+1] := i + 1 )  ;     i := i + 1 ) ; 
    var n : int ; n := (input())->toInteger() ;
        var j : int ; j := 0 ; while j < n do ( (     var change : Sequence(String) ; change := input()->split(",") ;
     var temp : int ; temp := amida[(change[0+1])->toInteger() - 1+1] ;
     amida[(change[0+1])->toInteger() - 1+1] := amida[(change[1+1])->toInteger() - 1+1] ; 
     amida[(change[1+1])->toInteger() - 1+1] := temp )  ;     j := j + 1 ) ; 
    for (k : amida) do ( (     OclFile["System.out"].println(k) )  ) ; 
    execute close() ; 
 );
  static   operation input() : String
  pre: true
  post: true
  activity: (     return scanner.nextLine() );
  static   operation close() : void
  pre: true
  post: true
  activity: (     if (scanner /= null) then (     skip ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.print.Printable ;
import java.util.Scanner ;
import javax.sound.midi.SysexMessage ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int w=sc.nextInt();
    int amidaArray[]=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      amidaArray[i]=i ;
    }
    for(int i=0 ; i<w ; i++){
      String str=sc.next();
      String[] strs=str.split(",");
      int a=Integer.parseInt(strs[0]);
      int b=Integer.parseInt(strs[1]);
      int temp=amidaArray[a];
      amidaArray[a]=amidaArray[b];
      amidaArray[b]=temp ;
    }
    for(int i=1 ; i<=n ; i++){
      System.out.println(amidaArray[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var amidaArray : Sequence(int) ; amidaArray := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     amidaArray[i+1] := i )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < w do ( (     var str : String ; str := sc.getCurrent() ;
     var strs : Sequence(String) ; strs := str->split(",") ;
    var a : int ; a := (strs[0+1])->toInteger() ;
    var b : int ; b := (strs[1+1])->toInteger() ;
    var temp : int ; temp := amidaArray[a+1] ;
    amidaArray[a+1] := amidaArray[b+1] ; 
    amidaArray[b+1] := temp ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].println(amidaArray[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static Boolean isPentagonal(int N){
    int i=1,M ;
    do {
      M=(3*i*i-i)/2 ;
      i+=1 ;
    }
    while(M<N);
    return(M==N);
  }
  public static void main(String[] args){
    int N=12 ;
    if(isPentagonal(N))System.out.println(N+" is pentagonal ");
    else System.out.println(N+" is not pentagonal");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPentagonal( N : int) : Boolean
  pre: true
  post: true
  activity: (     var i : int ; i := 1 ;
    var M : int ;
   while true do ((     M := (3 * i * i - i) / 2 ; 
     i := i+(1) ) ;
    if (M < N) then skip else break) ; 
     return (M = N) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 12 ;
     if (isPentagonal(N)) then     OclFile["System.out"].println(N + " is pentagonal ") ; else     OclFile["System.out"].println(N + " is not pentagonal") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class trigo {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int a=in.nextInt();
      int b=in.nextInt();
      int c=in.nextInt();
      int d=in.nextInt();
      System.out.println(b+" "+c+" "+c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class trigo {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    OclFile["System.out"].println(b + " " + c + " " + c) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.Scanner ;
public class _988A_DiverseTeam {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    ArrayList<Integer>arr=new ArrayList<>();
    HashSet<Integer>set=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      int input=in.nextInt();
      arr.add(input);
      set.add(input);
    }
    int[] indeces=new int[k];
    int index=0 ;
    if(set.size()>=k){
      for(int i : set){
        if(index==k)break ;
        indeces[index]=arr.indexOf(i)+1 ;
        index++;
      }
      System.out.println("YES");
      for(int i : indeces){
        System.out.print(i+" ");
      }
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _988A_DiverseTeam {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Sequence{} ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     var input : int ; input := in.getCurrent()->toInteger() ;
     arr := arr->including(input) ; 
     set := set->including(input) )  ;     i := i + 1 ) ; 
    var indeces : Sequence(int) ; indeces := Integer.subrange(1,k)->collect(0) ;
    var index : int ; index := 0 ;
    if (set->size() >= k) then (     for (i : set) do ( (     if (index = k) then     break else skip ; 
     indeces[index+1] := arr->indexOf(i)-1 + 1 ; 
     index := index + 1 )  ) ; 
     OclFile["System.out"].println("YES") ; 
     for (i : indeces) do ( (     OclFile["System.out"].print(i + " ") )  ) ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class hvg {
  public static void main(String[] args){
    Scanner h=new Scanner(System.in);
    int t=h.nextInt();
    while(t-->0){
      long a=h.nextLong();
      long b=h.nextLong();
      long c=h.nextLong();
      long d=h.nextLong();
      System.out.println((b)+" "+(c)+" "+(c));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class hvg {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var h : OclFile ; h := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := h.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : long ; a := h.getCurrent()->toLong() ;
     var b : long ; b := h.getCurrent()->toLong() ;
    var c : long ; c := h.getCurrent()->toLong() ;
    var d : long ; d := h.getCurrent()->toLong() ;
    OclFile["System.out"].println((b) + " " + (c) + " " + (c)) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Triangle {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    for(int i=0 ; i<t ; i++){
      int a=s.nextInt(),b=s.nextInt(),c=s.nextInt(),d=s.nextInt();
      System.out.println(b+" "+c+" "+c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Triangle {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : int ; a := s.getCurrent()->toInteger() ;
    var b : int ; b := s.getCurrent()->toInteger() ;
    var c : int ; c := s.getCurrent()->toInteger() ;
    var d : int ; d := s.getCurrent()->toInteger() ;
     OclFile["System.out"].println(b + " " + c + " " + c) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int d=sc.nextInt();
      System.out.println(b+" "+c+" "+c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(b + " " + c + " " + c) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1337 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int a=in.nextInt();
      int b=in.nextInt();
      int c=in.nextInt();
      int d=in.nextInt();
      System.out.println(a+" "+c+" "+c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1337 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    OclFile["System.out"].println(a + " " + c + " " + c) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int N=10000 ;
  static int n,m ;
  static int[] dp=new int[N];
  static int minOperations(int k){
    if(k<=0 || k>=10000)return 1000000000 ;
    if(k==m)return 0 ;
    dp[k]=dp[k];
    if(dp[k]!=-1)return dp[k];
    dp[k]=1000000000 ;
    dp[k]=1+Math.min(minOperations(2*k),minOperations(k-1));
    return dp[k];
  }
  public static void main(String[] args){
    n=4 ;
    m=6 ;
    Arrays.fill(dp,-1);
    System.out.println(minOperations(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute N : int := 10000;
  static   attribute n : int;
  static   attribute dp : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static   operation minOperations( k : int) : int
  pre: true
  post: true
  activity: (     if (k <= 0 or k >= 10000) then     return 1000000000 else skip ; 
     if (k = m) then     return 0 else skip ; 
    dp[k+1] := dp[k+1] ; 
    if (dp[k+1] /= -1) then     return dp[k+1] else skip ; 
    dp[k+1] := 1000000000 ; 
    dp[k+1] := 1 + Set{minOperations(2 * k), minOperations(k - 1)}->min() ; 
    return dp[k+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := 4 ; 
     m := 6 ; 
     dp := dp->collect(-1) ; 
     OclFile["System.out"].println(minOperations(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round2 ;
import java.util.Scanner ;
public class A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int cases=sc.nextInt();
    for(int caze=1 ; caze<=cases ; caze++){
      int N=sc.nextInt();
      int P=sc.nextInt();
      int[] cant=new int[P];
      for(int i=0 ; i<N ; i++){
        cant[sc.nextInt()% P]++;
      }
      int ans=cant[0];
      if(P==2){
        ans+=(cant[1]+1)/2 ;
      }
      else if(P==3){
        ans+=Math.min(cant[1],cant[2]);
        int left=Math.max(cant[1],cant[2])-Math.min(cant[1],cant[2]);
        ans+=(left+2)/3 ;
      }
      else {
        ans+=Math.min(cant[1],cant[3]);
        int left=Math.max(cant[1],cant[3])-Math.min(cant[1],cant[3]);
        ans+=cant[2]/2 ;
        boolean extra2=cant[2] % 2==1 ;
        if(left>=2 && extra2){
          ans++;
          left-=2 ;
          extra2=false ;
        }
        if(extra2)left++;
        ans+=(left+3)/4 ;
      }
      System.out.println("Case #"+caze+": "+ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cases : int ; cases := sc.getCurrent()->toInteger() ;
         var caze : int ; caze := 1 ; while caze <= cases do ( (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var P : int ; P := sc.getCurrent()->toInteger() ;
    var cant : Sequence(int) ; cant := Integer.subrange(1,P)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     cant[sc.getCurrent()->toInteger() mod P+1] := cant[sc.getCurrent()->toInteger() mod P+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := cant[0+1] ;
    if (P = 2) then (     ans := ans+((cant[1+1] + 1) / 2) ) else     if (P = 3) then (     ans := ans+(Set{cant[1+1], cant[2+1]}->min()) ; 
     var left : int ; left := Set{cant[1+1], cant[2+1]}->max() - Set{cant[1+1], cant[2+1]}->min() ;
     ans := ans+((left + 2) / 3) ) else (     ans := ans+(Set{cant[1+1], cant[3+1]}->min()) ; 
     var left : int ; left := Set{cant[1+1], cant[3+1]}->max() - Set{cant[1+1], cant[3+1]}->min() ;
    ans := ans+(cant[2+1] / 2) ; 
    var extra2 : boolean ; extra2 := cant[2+1] mod 2 = 1 ;
    if (left >= 2 & extra2) then (     ans := ans + 1 ; 
     left := left-(2) ; 
     extra2 := false ) else skip ; 
    if (extra2) then     left := left + 1 ; else skip ; 
    ans := ans+((left + 3) / 4) ; 
 ) ;  ;  
    OclFile["System.out"].println("Case #" + caze + ": " + ans) ; 
 )  ;     caze := caze + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeforces {
  public static void main(String[] args)throws IOException {
    try {
      Scanner sc=new Scanner(System.in);
      long n=sc.nextLong();
      long d=sc.nextLong();
      long sum=(n==d)? n : 2 ;
      System.out.println(sum);
    }
    catch(Exception e){
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var d : long ; d := sc.getCurrent()->toLong() ;
    var sum : long ; sum := if (n = d) then n else 2 endif ;
    OclFile["System.out"].println(sum) ; 
 )   catch (e : ProgramException) do (     OclFile["System.out"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication68 {
  public static void main(String[] args){
    Scanner read=new Scanner(System.in);
    long n1=read.nextLong(),n2=read.nextLong();
    if(n1==n2)System.out.println(n1);
    else System.out.println("2");
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication68 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : OclFile ; read := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n1 : long ; n1 := read.getCurrent()->toLong() ;
    var n2 : long ; n2 := read.getCurrent()->toLong() ;
     if (n1 = n2) then     OclFile["System.out"].println(n1) ; else     OclFile["System.out"].println("2") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Template {
  private static StringTokenizer st ;
  private static BufferedReader br ;
  private static PrintWriter pw ;
  public static void main(String[] args)throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    int l=nextInt();
    int r=nextInt();
    if(l==r){
      System.out.println(l);
    }
    else {
      System.out.println(2);
    }
  }
  private static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  private static long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  private static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  private static String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Template {
  static   attribute st : OclIterator;
  static   attribute br : OclFile;
  static   attribute pw : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ; 
    var l : int ; l := nextInt() ;
    var r : int ; r := nextInt() ;
    if (l = r) then (     OclFile["System.out"].println(l) ) else (     OclFile["System.out"].println(2) ) ;  
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class AFakeNP {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int l=sc.nextInt();
    int r=sc.nextInt();
    if(l<r)System.out.println(2);
    else System.out.println(l);
  }
}
------------------------------------------------------------
OCL File:
---------
 class AFakeNP {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
     if (l < r) then     OclFile["System.out"].println(2) ; else     OclFile["System.out"].println(l) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countLattice(int r){
    if(r<=0)return 0 ;
    int result=4 ;
    for(int x=1 ; x<r ; x++){
      int ySquare=r*r-x*x ;
      int y=(int)Math.sqrt(ySquare);
      if(y*y==ySquare)result+=4 ;
    }
    return result ;
  }
  public static void main(String arg[]){
    int r=5 ;
    System.out.println(countLattice(r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countLattice( r : int) : int
  pre: true
  post: true
  activity: (     if (r <= 0) then     return 0 else skip ; 
     var result : int ; result := 4 ;
         var x : int ; x := 1 ; while x < r do ( (     var ySquare : int ; ySquare := r * r - x * x ;
     var y : int ; y := (ySquare)->sqrt()->oclAsType(int) ;
     if (y * y = ySquare) then     result := result+(4) ; else skip )  ;     x := x + 1 ) ; 
     return result );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : int ; r := 5 ;
     OclFile["System.out"].println(countLattice(r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  final int MAX=(1<<15);
  private void doit(){
    Scanner sc=new Scanner(System.in);
    boolean[] isprime=new boolean[MAX+1];
    Arrays.fill(isprime,true);
    isprime[0]=false ;
    isprime[1]=false ;
    for(int i=0 ; i*i<=MAX ; i++){
      if(isprime[i]){
        for(int j=i*2 ; j<=MAX ; j+=i){
          isprime[j]=false ;
        }
      }
    }
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int count=0 ;
      for(int i=2 ; i<=n/2 ; i++){
        if(isprime[i] && isprime[n-i]){
          count++;
        }
      }
      System.out.println(count);
    }
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute MAX : int := ((1*(2->pow(15)))->oclAsType(long));
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var isprime : Sequence(boolean) ; isprime := Integer.subrange(1,MAX + 1)->collect(false) ;
    isprime := isprime->collect(true) ; 
    isprime[0+1] := false ; 
    isprime[1+1] := false ; 
        var i : int ; i := 0 ; while i * i <= MAX do ( (     if (isprime[i+1]) then (         var j : int ; j := i * 2 ; while j <= MAX do ( (     isprime[j+1] := false )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var count : int ; count := 0 ;
        var i : int ; i := 2 ; while i <= n / 2 do ( (     if (isprime[i+1] & isprime[n - i+1]) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n ;
    double[] x,y ;
    int i,j,s ;
    double ax,ay,bx,by ;
    n=sc.nextInt();
    x=new double[n];
    y=new double[n];
    for(i=0 ; i<n ; i++){
      x[i]=sc.nextDouble();
      y[i]=sc.nextDouble();
    }
    sc.close();
    s=1 ;
    for(i=0 ; i<n-2 ; i++){
      ax=x[i+1]-x[i];
      ay=y[i+1]-y[i];
      bx=x[i+2]-x[i];
      by=y[i+2]-y[i];
      if(ax*by-ay*bx<0){
        s=0 ;
        break ;
      }
    }
    ax=x[i+1]-x[i];
    ay=y[i+1]-y[i];
    bx=x[0]-x[i];
    by=y[0]-y[i];
    if(ax*by-ay*bx<0)s=0 ;
    if(s==0){
      System.out.println("0");
    }
    else {
      System.out.println("1");
    }
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var x : Sequence(double) ;
    var y : Sequence(double) ;
    var i : int ;
    var j : int ;
    var s : int ;
    var ax : double ;
    var ay : double ;
    var bx : double ;
    var by : double ;
    n := sc.nextInt() ; 
    x := Integer.subrange(1,n)->collect(0.0) ; 
    y := Integer.subrange(1,n)->collect(0.0) ; 
        i := 0 ; while i < n do ( (     x[i+1] := sc.nextDouble() ; 
     y[i+1] := sc.nextDouble() )  ;     i := i + 1 ) ; 
    sc.close() ; 
    s := 1 ; 
        i := 0 ; while i < n - 2 do ( (     ax := x[i + 1+1] - x[i+1] ; 
     ay := y[i + 1+1] - y[i+1] ; 
    bx := x[i + 2+1] - x[i+1] ; 
    by := y[i + 2+1] - y[i+1] ; 
    if (ax * by - ay * bx < 0) then (     s := 0 ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    ax := x[i + 1+1] - x[i+1] ; 
    ay := y[i + 1+1] - y[i+1] ; 
    bx := x[0+1] - x[i+1] ; 
    by := y[0+1] - y[i+1] ; 
    if (ax * by - ay * bx < 0) then     s := 0 ; else skip ; 
    if (s = 0) then (     OclFile["System.out"].println("0") ) else (     OclFile["System.out"].println("1") ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Vector2d>p=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      double x=sc.nextDouble();
      double y=sc.nextDouble();
      p.add(new Vector2d(x,y));
    }
    sc.close();
    System.out.println(solve(p));
  }
  static class Vector2d {
    Vector2d(Double x,Double y){
      this.x=x ;
      this.y=y ;
    }
    Double x ;
    Double y ;
    public String toString(){
      return String.format("%1$.10f %2$.10f",x,y);
    }
  }
  public static Vector2d sub(Vector2d v1,Vector2d v2){
    return new Vector2d(v2.x-v1.x,v2.y-v1.y);
  }
  public static int solve(List<Vector2d>p){
    boolean ans=true ;
    int s=p.size();
    for(int i=0 ; i<s ; i++){
      Vector2d a=sub(p.get(i),p.get((i+1)% s));
      Vector2d b=sub(p.get((i+1)% s),p.get((i+2)% s));
      ans=ans &&((a.x*b.y-a.y*b.x)>=0);
    }
    return ans ? 1 : 0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var p : Sequence(Vector2d) ; p := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : double ; x := sc.getCurrent()->toReal() ;
     var y : double ; y := sc.getCurrent()->toReal() ;
     p := p->including(Vector2d.newVector2d(x, y)) )  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(solve(p)) ; 
 );
  static class Vector2d {
   static operation newVector2d( x : double, y : double) : Vector2d
  pre: true
  post: true
  activity:
  ( var self : Vector2d ;
    self := createVector2d();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   attribute x : double;
   attribute y : double;
   operation toString() : String
  pre: true
  post: true
  activity: (     return StringLib.format("%1$.10f %2$.10f",Sequence{x,y}) );
}
  static   operation sub( v1 : Vector2d, v2 : Vector2d) : Vector2d
  pre: true
  post: true
  activity: (     return Vector2d.newVector2d(v2.x - v1.x, v2.y - v1.y) );
  static   operation solve( p : Sequence(Vector2d)) : int
  pre: true
  post: true
  activity: (     var ans : boolean ; ans := true ;
     var s : int ; s := p->size() ;
         var i : int ; i := 0 ; while i < s do ( (     var a : Vector2d ; a := sub(p->at(i+1), p->at((i + 1) mod s+1)) ;
     var b : Vector2d ; b := sub(p->at((i + 1) mod s+1), p->at((i + 2) mod s+1)) ;
     ans := ans & ((a.x * b.y - a.y * b.x) >= 0) )  ;     i := i + 1 ) ; 
     return if ans then 1 else 0 endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.*;
public class Main {
  static int INF=1000000000 ;
  static int MAXN=31 ;
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[][] point=new int[n][2];
    for(int i=0 ; i<n ; ++i){
      point[i][0]=input.nextInt();
      point[i][1]=input.nextInt();
    }
    boolean ok=true ;
    for(int i=1 ; i<n-2 ; ++i){
      int ccw1=ccw(point[i-1],point[i],point[i+1]);
      int ccw2=ccw(point[i],point[i+1],point[i+2]);
      if(ccw1*ccw2<0){
        ok=false ;
        break ;
      }
    }
    int ccw1=ccw(point[n-2],point[n-1],point[0]);
    int ccw2=ccw(point[n-1],point[0],point[1]);
    if(ccw1*ccw2<0){
      ok=false ;
    }
    if(ok)System.out.println(1);
    else System.out.println(0);
  }
  static int ccw(int[] p1,int[] p2,int[] p3){
    int a1,b1 ;
    int a2,b2 ;
    a1=p2[0]-p1[0];
    b1=p2[1]-p1[1];
    a2=p3[0]-p2[0];
    b2=p3[1]-p2[1];
    return a1*b2-a2*b1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute INF : int := 1000000000;
  static   attribute MAXN : int := 31;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var point : Sequence(Sequence(int)) ; point := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     point[i+1][0+1] := input.getCurrent()->toInteger() ; 
     point[i+1][1+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ok : boolean ; ok := true ;
        var i : int ; i := 1 ; while i < n - 2 do ( (     var ccw1 : int ; ccw1 := ccw(point[i - 1+1], point[i+1], point[i + 1+1]) ;
     var ccw2 : int ; ccw2 := ccw(point[i+1], point[i + 1+1], point[i + 2+1]) ;
     if (ccw1 * ccw2 < 0) then (     ok := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var ccw1 : int ; ccw1 := ccw(point[n - 2+1], point[n - 1+1], point[0+1]) ;
    var ccw2 : int ; ccw2 := ccw(point[n - 1+1], point[0+1], point[1+1]) ;
    if (ccw1 * ccw2 < 0) then (     ok := false ) else skip ; 
    if (ok) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println(0) ; ;  
 );
  static   operation ccw( p1 : Sequence(int), p2 : Sequence(int), p3 : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var a1 : int ;
    var b1 : int ;
     var a2 : int ;
    var b2 : int ;
    a1 := p2[0+1] - p1[0+1] ; 
    b1 := p2[1+1] - p1[1+1] ; 
    a2 := p3[0+1] - p2[0+1] ; 
    b2 := p3[1+1] - p2[1+1] ; 
    return a1 * b2 - a2 * b1 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static double area(Point p1,Point p2){
    return(p1.x*p2.y-p1.y*p2.x)/2.0 ;
  }
  public static double solve(Point[] p){
    double ans=0 ;
    for(int i=0 ; i<p.length-1 ; i++)ans+=area(p[i],p[i+1]);
    return ans+area(p[p.length-1],p[0]);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Point[] p=new Point[n];
    Point[] work=new Point[n-1];
    for(int i=0 ; i<n ; i++)p[i]=new Point(sc.nextDouble(),sc.nextDouble());
    double ans=solve(p);
    for(int i=0 ; i<n ; i++){
      int cnt=0 ;
      for(int j=0 ; j<n ; j++){
        if(j==i)continue ;
        else work[cnt++]=p[j];
      }
      if(solve(work)>ans){
        System.out.println(0);
        break ;
      }
      else if(i==n-1)System.out.println(1);
    }
  }
}
class Point {
  double x ;
  double y ;
  Point(double x,double y){
    this.x=x ;
    this.y=y ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation area( p1 : Point, p2 : Point) : double
  pre: true
  post: true
  activity: (     return (p1.x * p2.y - p1.y * p2.x) / 2.0 );
  static   operation solve( p : Sequence(Point)) : double
  pre: true
  post: true
  activity: (     var ans : double ; ans := 0 ;
         var i : int ; i := 0 ; while i < p->size() - 1 do (     ans := ans+(area(p[i+1], p[i + 1+1])) ;  ;     i := i + 1 ) ; 
     return ans + area(p[p->size() - 1+1], p[0+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var p : Sequence(Point) ; p := Integer.subrange(1,n)->collect(null) ;
    var work : Sequence(Point) ; work := Integer.subrange(1,n - 1)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     p[i+1] := Point.newPoint(sc.getCurrent()->toReal(), sc.getCurrent()->toReal()) ;  ;     i := i + 1 ) ; 
    var ans : double ; ans := solve(p) ;
        var i : int ; i := 0 ; while i < n do ( (     var cnt : int ; cnt := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (j = i) then     continue else      work[cnt+1] := p[j+1]  ; cnt := cnt + 1 ; )  ;     j := j + 1 ) ; 
     if (solve(work) > ans) then (     OclFile["System.out"].println(0) ; 
     break ) else     if (i = n - 1) then     OclFile["System.out"].println(1) ; else skip ; )  ;     i := i + 1 ) ; 
 );
}
class Point {
   attribute x : double;
   attribute y : double;
   static operation newPoint( x : double, y : double) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class A {
  public static void main(String[] arg){
    Scanner sc=new Scanner(System.in);
    int TT=sc.nextInt();
    for(int ii=1 ; ii<=TT ; ++ii){
      int N=sc.nextInt();
      int P=sc.nextInt();
      int[] M=new int[5];
      for(int i=0 ; i<N ; ++i){
        int G=sc.nextInt();
        M[G % P]++;
      }
      int ans=1+M[0];
      if(P==2){
        ans+=M[1]/2 ;
        if(M[1] % 2==0)ans--;
      }
      else if(P==3){
        int min=Math.min(M[1],M[2]);
        int left=Math.max(M[1],M[2])-min ;
        if(left % 3==0)ans--;
        left/=3 ;
        ans+=min+left ;
      }
      else if(P==4){
        while(M[2]>=2){
          ans++;
          M[2]-=2 ;
        }
        while(M[1]>0 && M[3]>0){
          ans++;
          M[1]--;
          M[3]--;
        }
        if(M[2]==1){
          if(M[1] % 4>=2){
            ans++;
            M[1]-=2 ;
            M[2]--;
          }
          else if(M[3] % 4>=2){
            ans++;
            M[3]-=2 ;
            M[2]--;
          }
        }
        int threes=M[3]/4 ;
        int ones=M[1]/4 ;
        ans+=threes+ones ;
        if(M[1] % 4==0 && M[3] % 4==0 && M[2] % 2==0){
          ans--;
        }
      }
      System.out.printf("Case #%d: %d\n",ii,ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var TT : int ; TT := sc.getCurrent()->toInteger() ;
         var ii : int ; ii := 1 ; while ii <= TT do ( (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var P : int ; P := sc.getCurrent()->toInteger() ;
    var M : Sequence(int) ; M := Integer.subrange(1,5)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     var G : int ; G := sc.getCurrent()->toInteger() ;
     M[G mod P+1] := M[G mod P+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 1 + M[0+1] ;
    if (P = 2) then (     ans := ans+(M[1+1] / 2) ; 
     if (M[1+1] mod 2 = 0) then     ans := ans - 1 ; else skip ) else     if (P = 3) then (     var min : int ; min := Set{M[1+1], M[2+1]}->min() ;
     var left : int ; left := Set{M[1+1], M[2+1]}->max() - min ;
    if (left mod 3 = 0) then     ans := ans - 1 ; else skip ; 
    left := left/(3) ; 
    ans := ans+(min + left) ; 
 ) else     if (P = 4) then (     while (M[2+1] >= 2) do (     ans := ans + 1 ; 
     M[2+1] := M[2+1]-(2) ) ; 
     while (M[1+1] > 0 & M[3+1] > 0) do (     ans := ans + 1 ; 
     M[1+1] := M[1+1] - 1 ; 
     M[3+1] := M[3+1] - 1 ) ; 
    if (M[2+1] = 1) then (     if (M[1+1] mod 4 >= 2) then (     ans := ans + 1 ; 
     M[1+1] := M[1+1]-(2) ; 
     M[2+1] := M[2+1] - 1 ) else     if (M[3+1] mod 4 >= 2) then (     ans := ans + 1 ; 
     M[3+1] := M[3+1]-(2) ; 
     M[2+1] := M[2+1] - 1 ) else skip ; ) else skip ; 
    var threes : int ; threes := M[3+1] / 4 ;
    var ones : int ; ones := M[1+1] / 4 ;
    ans := ans+(threes + ones) ; 
    if (M[1+1] mod 4 = 0 & M[3+1] mod 4 = 0 & M[2+1] mod 2 = 0) then (     ans := ans - 1 ) else skip ; 
 ) else skip ; ;  ;  
    OclFile["System.out"].printf("Case #%d: %d\n", ii, ans) ; 
 )  ;     ii := ii + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    long[][] p=new long[n+1][2];
    for(int i=0 ; i<n ; i++){
      long x=scan.nextLong();
      long y=scan.nextLong();
      long[] t={
        x,y };
        p[i]=t ;
      }
      p[n]=p[0];
      scan.close();
      for(int i=0 ; i<n ; i++){
        long s=area(p[(i-1+n)% n],p[i],p[i+1]);
        long t=area(p[i],p[i+1],p[(i+2)% n]);
        if(s*t<0){
          System.out.println(0);
          System.exit(0);
        }
      }
      System.out.println(1);
    }
    static long area(long[] x,long[] y,long[] z){
      return(cross(vec(z,x),vec(z,y)));
    }
    static long cross(long[] u,long[] v){
      return u[0]*v[1]-u[1]*v[0];
    }
    static long[] vec(long[] p1,long[] p2){
      long[] u={
        p2[0]-p1[0],p2[1]-p1[1] };
        return u ;
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var p : Sequence(Sequence(long)) ; p := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : long ; x := scan.getCurrent()->toLong() ;
     var y : long ; y := scan.getCurrent()->toLong() ;
     var t : Sequence(long) ; t := Sequence{x,y} ;
     p[i+1] := t )  ;     i := i + 1 ) ; 
    p[n+1] := p[0+1] ; 
    skip ; 
        var i : int ; i := 0 ; while i < n do ( (     var s : long ; s := area(p[(i - 1 + n) mod n+1], p[i+1], p[i + 1+1]) ;
     var t : long ; t := area(p[i+1], p[i + 1+1], p[(i + 2) mod n+1]) ;
     if (s * t < 0) then (     OclFile["System.out"].println(0) ; 
 OclProcess.exit(0) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(1) ; 
 );
  static   operation area( x : Sequence(long), y : Sequence(long), z : Sequence(long)) : long
  pre: true
  post: true
  activity: (     return (cross(vec(z, x), vec(z, y))) );
  static   operation cross( u : Sequence(long), v : Sequence(long)) : long
  pre: true
  post: true
  activity: (     return u[0+1] * v[1+1] - u[1+1] * v[0+1] );
  static   operation vec( p1 : Sequence(long), p2 : Sequence(long)) : Sequence(long)
  pre: true
  post: true
  activity: (     var u : Sequence(long) ; u := Sequence{p2[0+1] - p1[0+1],p2[1+1] - p1[1+1]} ;
     return u );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Rearrange {
  void rearrange(int arr[],int n){
    for(int i=0 ; i<n ; i++)arr[i]+=(arr[arr[i] ] % n)*n ;
    for(int i=0 ; i<n ; i++)arr[i]/=n ;
  }
  void printArr(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    System.out.println("");
  }
  public static void main(String[] args){
    Rearrange rearrange=new Rearrange();
    int arr[]={
      3,2,0,1 };
      int n=arr.length ;
      System.out.println("Given Array is :");
      rearrange.printArr(arr,n);
      rearrange.rearrange(arr,n);
      System.out.println("Modified Array is :");
      rearrange.printArr(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class Rearrange {
   operation rearrange( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     arr[i+1] := arr[i+1]+((arr[arr[i+1]+1] mod n) * n) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do (     arr[i+1] := arr[i+1]/(n) ;  ;     i := i + 1 ) );
   operation printArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var rearrange : Rearrange ; rearrange := Rearrange.newRearrange() ;
     var arr : Sequence(int) ; arr := Sequence{3,2,0,1} ;
    var n : int ; n := arr->size() ;
    OclFile["System.out"].println("Given Array is :") ; 
    rearrange.printArr(arr, n) ; 
    rearrange.rearrange(arr, n) ; 
    OclFile["System.out"].println("Modified Array is :") ; 
    rearrange.printArr(arr, n) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
import java.util.ArrayList ;
class Point {
  double x,y ;
  Point(double x,double y){
    this.x=x ;
    this.y=y ;
  }
}
class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String buf ;
    try {
      ArrayList<Point>array=new ArrayList<Point>();
      while((buf=br.readLine())!=null){
        StringTokenizer st=new StringTokenizer(buf,",");
        array.add(new Point(Double.parseDouble(st.nextToken()),Double.parseDouble(st.nextToken())));
      }
      double S=0 ;
      for(int i=1 ; i<array.size()-1 ; i++){
        double a=dist(array.get(0),array.get(i));
        double b=dist(array.get(i),array.get(i+1));
        double c=dist(array.get(0),array.get(i+1));
        double z=(a+b+c)/2 ;
        S+=Math.sqrt(z*(z-a)*(z-b)*(z-c));
      }
      System.out.println(S);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  public static double dist(Point p1,Point p2){
    return Math.sqrt(Math.pow(p2.x-p1.x,2)+Math.pow(p2.y-p1.y,2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Point {
   attribute x : double;
   static operation newPoint( x : double, y : double) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var buf : String ;
     try (     var array : Sequence(Point) ; array := Sequence{} ;
         buf := br.readLine() ;
    while ((buf) /= null) do (    skip ; (     var st : OclIterator ; st := OclIterator.newOclIterator_String_String(buf, ",") ;
     array := array->including(Point.newPoint((st.next())->toReal(), (st.next())->toReal())) ) ;     buf := br.readLine() ;
 ) ;  
    var S : double ; S := 0 ;
        var i : int ; i := 1 ; while i < array->size() - 1 do ( (     var a : double ; a := dist(array->at(0+1), array->at(i+1)) ;
     var b : double ; b := dist(array->at(i+1), array->at(i + 1+1)) ;
    var c : double ; c := dist(array->at(0+1), array->at(i + 1+1)) ;
    var z : double ; z := (a + b + c) / 2 ;
    S := S+((z * (z - a) * (z - b) * (z - c))->sqrt()) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(S) ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
  static   operation dist( p1 : Point, p2 : Point) : double
  pre: true
  post: true
  activity: (     return (p2.x - p1.x->pow(2) + p2.y - p1.y->pow(2))->sqrt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Point2D ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws java.io.IOException {
    Scanner sc=new Scanner(System.in);
    int c=0 ;
    Point2D.Double[] v=new Point2D.Double[20];
    sc.useDelimiter(",| ?\n");
    while(sc.hasNext()){
      v[c]=new Point2D.Double(sc.nextDouble(),sc.nextDouble());
      c++;
    }
    int n=c ;
    double sum=0 ;
    for(int i=0 ; i<n-1 ; i++){
      sum+=ep(v[i],v[i+1]);
    }
    sum+=ep(v[n-1],v[0]);
    double ans=Math.abs(1.0*sum/2.0);
    System.out.printf("%.6f\n",ans);
  }
  public static double ep(Point2D.Double a,Point2D.Double b){
    return a.x*b.y-a.y*b.x ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : int ; c := 0 ;
    var v : Sequence(Double) ; v := Integer.subrange(1,20)->collect(null) ;
    skip ; 
    while (sc.hasNext()) do (     v[c+1] := Double.newDouble(sc.getCurrent()->toReal(), sc.getCurrent()->toReal()) ; 
     c := c + 1 ) ; 
    var n : int ; n := c ;
    var sum : double ; sum := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     sum := sum+(ep(v[i+1], v[i + 1+1])) )  ;     i := i + 1 ) ; 
    sum := sum+(ep(v[n - 1+1], v[0+1])) ; 
    var ans : double ; ans := if 1.0 * sum / 2.0 < 0 then -(1.0 * sum / 2.0) else 1.0 * sum / 2.0 endif ;
    OclFile["System.out"].printf("%.6f\n", ans) ; 
 );
  static   operation ep( a : Double, b : Double) : double
  pre: true
  post: true
  activity: (     return a.x * b.y - a.y * b.x );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.text.DecimalFormat ;
import java.util.*;
import static java.lang.Math.*;
public class Main {
  static PrintWriter out=new PrintWriter(System.out);
  static double[][] ple=new double[20][2];
  static int count=0 ;
  public static void main(String[] args){
    input();
    output();
    out.flush();
  }
  static void input(){
    Scanner sc=new Scanner(System.in);
    for(int i=0 ; sc.hasNext(); i++){
      String s[]=sc.next().split(",");
      ple[i][0]=Double.parseDouble(s[0]);
      ple[i][1]=Double.parseDouble(s[1]);
      count=i+1 ;
    }
  }
  static void output(){
    double a=0 ;
    for(int i=0 ; i<count ; i++){
      double x1=ple[i][0];
      double y1=ple[i][1];
      double x2=ple[(i+1)% count][0];
      double y2=ple[(i+1)% count][1];
      a+=x1*y2 ;
      a-=x2*y1 ;
    }
    double temp=abs(abs(a/2));
    out.println(new DecimalFormat("#0.000000").format(temp));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute ple : Sequence(Sequence(double)) := Integer.subrange(1,20)->collect(Integer.subrange(1,2)->collect(0.0));
  static   attribute count : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute input() ; 
     execute output() ; 
     skip );
  static   operation input() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var i : int ; i := 0 ; while sc.hasNext() do ( (     var s : Sequence(String) ; s := sc.getCurrent()->split(",") ;
     ple[i+1][0+1] := (s[0+1])->toReal() ; 
     ple[i+1][1+1] := (s[1+1])->toReal() ; 
     count := i + 1 )  ;     i := i + 1 ) );
  static   operation output() : void
  pre: true
  post: true
  activity: (     var a : double ; a := 0 ;
         var i : int ; i := 0 ; while i < count do ( (     var x1 : double ; x1 := ple[i+1][0+1] ;
     var y1 : double ; y1 := ple[i+1][1+1] ;
    var x2 : double ; x2 := ple[(i + 1) mod count+1][0+1] ;
    var y2 : double ; y2 := ple[(i + 1) mod count+1][1+1] ;
    a := a+(x1 * y2) ; 
    a := a-(x2 * y1) ; 
 )  ;     i := i + 1 ) ; 
     var temp : double ; temp := abs(abs(a / 2)) ;
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader reader=new BufferedReader(isr);
    double[] x=new double[20];
    double[] y=new double[20];
    int i=0 ;
    String string ;
    while((string=reader.readLine())!=null){
      x[i]=Double.valueOf(string.split(",")[0]);
      y[i]=Double.valueOf(string.split(",")[1]);
      i++;
    }
    double a=Math.hypot(x[1]-x[0],y[1]-y[0]);
    double b=Math.hypot(x[2]-x[0],y[2]-y[0]);
    double c=Math.hypot(x[2]-x[1],y[2]-y[1]);
    double z=(a+b+c)/2 ;
    double S=Math.sqrt(z*(z-a)*(z-b)*(z-c));
    for(int j=2 ; j<i-1 ; j++){
      a=Math.hypot(x[j]-x[0],y[j]-y[0]);
      b=Math.hypot(x[j+1]-x[0],y[j+1]-y[0]);
      c=Math.hypot(x[j+1]-x[j],y[j+1]-y[j]);
      z=(a+b+c)/2 ;
      S+=Math.sqrt(z*(z-a)*(z-b)*(z-c));
    }
    System.out.println(S);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(isr) ;
    var x : Sequence(double) ; x := Integer.subrange(1,20)->collect(0.0) ;
    var y : Sequence(double) ; y := Integer.subrange(1,20)->collect(0.0) ;
    var i : int ; i := 0 ;
    var string : String ;
        string := reader.readLine() ;
    while ((string) /= null) do (    skip ; (     x[i+1] := (string->split(",")[0+1])->toReal() ; 
     y[i+1] := (string->split(",")[1+1])->toReal() ; 
     i := i + 1 ) ;     string := reader.readLine() ;
 ) ;  
    var a : double ; a := hypot(x[1+1] - x[0+1], y[1+1] - y[0+1]) ;
    var b : double ; b := hypot(x[2+1] - x[0+1], y[2+1] - y[0+1]) ;
    var c : double ; c := hypot(x[2+1] - x[1+1], y[2+1] - y[1+1]) ;
    var z : double ; z := (a + b + c) / 2 ;
    var S : double ; S := (z * (z - (a)->char2byte()) * (z - b) * (z - c))->sqrt() ;
        var j : int ; j := 2 ; while j < i - 1 do ( (     a := hypot(x[j+1] - x[0+1], y[j+1] - y[0+1]) ; 
     b := hypot(x[j + 1+1] - x[0+1], y[j + 1+1] - y[0+1]) ; 
    c := hypot(x[j + 1+1] - x[j+1], y[j + 1+1] - y[j+1]) ; 
    z := (a + b + c) / 2 ; 
    S := S+((z * (z - (a)->char2byte()) * (z - b) * (z - c))->sqrt()) ; 
 )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(S) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  static int N=1024*1024 ;
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int[] p ;
    int pn,i,j,n,count,l,m,r ;
    p=new int[N/6];
    pn=getprime(p);
    for(; ; ){
      n=sc.nextInt();
      if(n==0)break ;
      count=0 ;
      for(i=0 ; i<pn && p[i]<=n/2 ; i++){
        l=0 ;
        r=pn-1 ;
        for(; l<=r ; ){
          m=(l+r)/2 ;
          if(p[i]+p[m]<n)l=m+1 ;
          else if(p[i]+p[m]>n)r=m-1 ;
          else {
            count++;
            break ;
          }
        }
      }
      out.println(count);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
  private static int getprime(int[] p){
    int i,j,count=0 ;
    boolean[] e ;
    e=new boolean[N];
    e[0]=true ;
    e[1]=true ;
    for(i=2 ; i<N ; i++)if(! e[i]){
      p[count++]=i ;
      for(j=i*2 ; j<N ; j+=i)e[j]=true ;
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   attribute N : int := 1024 * 1024;
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var p : Sequence(int) ;
    var pn : int ;
    var i : int ;
    var j : int ;
    var n : int ;
    var count : int ;
    var l : int ;
    var m : int ;
    var r : int ;
    p := Integer.subrange(1,N / 6)->collect(0) ; 
    pn := getprime(p) ; 
      while true do ( (     n := sc.nextInt() ; 
     if (n = 0) then     break else skip ; 
    count := 0 ; 
        i := 0 ; while i < pn & p[i+1] <= n / 2 do ( (     l := 0 ; 
     r := pn - 1 ; 
       while l <= r do ( (     m := (l + r) / 2 ; 
     if (p[i+1] + p[m+1] < n) then     l := m + 1 ; else     if (p[i+1] + p[m+1] > n) then     r := m - 1 else (     count := count + 1 ; 
     break ) ;  )  ) )  ;     i := i + 1 ) ; 
    out.println(count) ; 
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
  static   operation getprime( p : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var count : int ; count := 0 ;
     var e : Sequence(boolean) ;
    e := Integer.subrange(1,N)->collect(false) ; 
    e[0+1] := true ; 
    e[1+1] := true ; 
        i := 2 ; while i < N do (     if (not(e[i+1])) then (      p[count+1] := i  ; count := count + 1 ; 
         j := i * 2 ; while j < N do (     e[j+1] := true ;  ;     j := j+(i) ) ) else skip ;  ;     i := i + 1 ) ; 
    return count 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  class P {
    double x,y ;
    P(double x,double y){
      this.x=x ;
      this.y=y ;
    }
    double length(P p){
      return sqrt((p.x-x)*(p.x-x)+(p.y-y)*(p.y-y));
    }
  }
  void run(){
    sc=new Scanner(System.in);
    LinkedList<P>list=new LinkedList<P>();
    for(; sc.hasNext(); ){
      String[] s=sc.next().split(",");
      double x=Double.parseDouble(s[0]);
      double y=Double.parseDouble(s[1]);
      list.add(new P(x,y));
    }
    int n=list.size();
    P p0=list.getFirst();
    double sum=0 ;
    for(int i=0 ; i<n-2 ; i++){
      P p1=list.get(i+1);
      P p2=list.get(i+2);
      double a=p0.length(p1);
      double b=p1.length(p2);
      double c=p2.length(p0);
      double z=(a+b+c)/2 ;
      double s=sqrt(z*(z-a)*(z-b)*(z-c));
      sum+=s ;
    }
    println(sum+"");
    sc.close();
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
 class P {
   attribute x : double;
   static operation newP( x : double, y : double) : P
  pre: true
  post: true
  activity:
  ( var self : P ;
    self := createP();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation length( p : P) : double
  pre: true
  post: true
  activity: (     return sqrt((p.x - x) * (p.x - x) + (p.y - y) * (p.y - y)) );
}
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var list : Sequence(P) ; list := Sequence{} ;
      while sc.hasNext() do ( (     var s : Sequence(String) ; s := sc.getCurrent()->split(",") ;
     var x : double ; x := (s[0+1])->toReal() ;
     var y : double ; y := (s[1+1])->toReal() ;
     list := list->including(P.newP(x, y)) )  ) ; 
    var n : int ; n := list->size() ;
    var p0 : P ; p0 := list->first() ;
    var sum : double ; sum := 0 ;
        var i : int ; i := 0 ; while i < n - 2 do ( (     var p1 : P ; p1 := list->at(i + 1+1) ;
     var p2 : P ; p2 := list->at(i + 2+1) ;
    var a : double ; a := p0.length(p1) ;
    var b : double ; b := p1.length(p2) ;
    var c : double ; c := p2.length(p0) ;
    var z : double ; z := (a + b + c) / 2 ;
    var s : double ; s := sqrt(z * (z - a) * (z - b) * (z - c)) ;
    sum := sum+(s) ; 
 )  ;     i := i + 1 ) ; 
    execute println(sum + "") ; 
    skip ; 
 );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int cntWays(String str,int n){
    int x=n+1 ;
    int ways=x*x*(x*x-1)/12 ;
    return ways ;
  }
  public static void main(String[] args){
    String str="ab" ;
    int n=str.length();
    System.out.println(cntWays(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation cntWays( str : String, n : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := n + 1 ;
     var ways : int ; ways := x * x * (x * x - 1) / 12 ;
     return ways );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "ab" ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].println(cntWays(str, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int round(int n){
    int a=(n/10)*10 ;
    int b=a+10 ;
    return(n-a>b-n)? b : a ;
  }
  public static void main(String[] args){
    int n=4722 ;
    System.out.println(round(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation round( n : int) : int
  pre: true
  post: true
  activity: (     var a : int ; a := (n / 10) * 10 ;
     var b : int ; b := a + 10 ;
     return if (n - a > b - n) then b else a endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4722 ;
     OclFile["System.out"].println(round(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
(new Main()).solve();
  }
  void solve(){
    Scanner cin=new Scanner(System.in);
    int T=cin.nextInt();
    for(int C=1 ; C<=T ; ++C){
      int N=cin.nextInt();
      int P=cin.nextInt();
      int count[]=new int[P];
      for(int i=0 ; i<N ; ++i){
++count[cin.nextInt()% P];
      }
      int ret=count[0];
      count[0]=0 ;
      if(P==2){
        ret+=(count[1]+1)/2 ;
      }
      else if(P==3){
        int min=Math.min(count[1],count[2]);
        ret+=min ;
        count[1]-=min ;
        count[2]-=min ;
        ret+=(count[1]+2)/3 ;
        ret+=(count[2]+2)/3 ;
      }
      else if(P==4){
        {
          int two=Math.min(count[1],count[3]);
          ret+=two ;
          count[1]-=two ;
          count[3]-=two ;
        }
        {
          int two=count[2]/2 ;
          ret+=two ;
          count[2]-=two*2 ;
        }
        {
          int three=Math.min(count[2],Math.max(count[1]/2,count[3]/2));
          ret+=three ;
          count[2]-=three ;
          if(count[1]>0){
            count[1]-=three*2 ;
          }
          if(count[3]>0){
            count[3]-=three*2 ;
          }
        }
        {
          if(count[1]>0 || count[2]>0 || count[3]>0){
++ret ;
          }
        }
      }
      System.out.println("Case #"+C+": "+ret);
    }
    cin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := cin.getCurrent()->toInteger() ;
         var C : int ; C := 1 ; while C <= T do ( (     var N : int ; N := cin.getCurrent()->toInteger() ;
     var P : int ; P := cin.getCurrent()->toInteger() ;
    var count : Sequence(int) ; count := Integer.subrange(1,P)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     count[cin.getCurrent()->toInteger() mod P+1] := count[cin.getCurrent()->toInteger() mod P+1] + 1 )  ;     i := i + 1 ) ; 
    var ret : int ; ret := count[0+1] ;
    count[0+1] := 0 ; 
    if (P = 2) then (     ret := ret+((count[1+1] + 1) / 2) ) else     if (P = 3) then (     var min : int ; min := Set{count[1+1], count[2+1]}->min() ;
     ret := ret+(min) ; 
    count[1+1] := count[1+1]-(min) ; 
    count[2+1] := count[2+1]-(min) ; 
    ret := ret+((count[1+1] + 2) / 3) ; 
    ret := ret+((count[2+1] + 2) / 3) ; 
 ) else     if (P = 4) then ( (     var two : int ; two := Set{count[1+1], count[3+1]}->min() ;
     ret := ret+(two) ; 
     count[1+1] := count[1+1]-(two) ; 
     count[3+1] := count[3+1]-(two) ) 
 (     var two : int ; two := count[2+1] / 2 ;
     ret := ret+(two) ; 
     count[2+1] := count[2+1]-(two * 2) ) 
 (     var three : int ; three := Set{count[2+1], Set{count[1+1] / 2, count[3+1] / 2}->max()}->min() ;
     ret := ret+(three) ; 
    count[2+1] := count[2+1]-(three) ; 
    if (count[1+1] > 0) then (     count[1+1] := count[1+1]-(three * 2) ) else skip ; 
    if (count[3+1] > 0) then (     count[3+1] := count[3+1]-(three * 2) ) else skip ; 
 ) 
 (     if (count[1+1] > 0 or count[2+1] > 0 or count[3+1] > 0) then (     ret := ret + 1 ) else skip ) ) else skip ; ;  ;  
    OclFile["System.out"].println("Case #" + C + ": " + ret) ; 
 )  ;     C := C + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class MikeAndFeet_305B {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    StringTokenizer st=new StringTokenizer(br.readLine());
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++)nums[i]=Integer.parseInt(st.nextToken());
    helper(nums);
  }
  private static void helper(int[] nums){
    int n=nums.length ;
    int[] arr=new int[n+1];
    Stack<Integer>stack=new Stack<>();
    stack.push(-1);
    for(int i=0 ; i<n ; i++){
      while(stack.peek()!=-1 && nums[stack.peek()]>=nums[i]){
        int j=stack.pop();
        int len=i-stack.peek()-1 ;
        if(arr[len]<nums[j])arr[len]=nums[j];
      }
      stack.push(i);
    }
    while(stack.peek()!=-1){
      int j=stack.pop();
      int len=n-stack.peek()-1 ;
      if(arr[len]<nums[j])arr[len]=nums[j];
    }
    for(int i=n-1 ; i>0 ; i--){
      if(arr[i]<arr[i+1])arr[i]=arr[i+1];
    }
    StringBuilder sb=new StringBuilder();
    for(int i=1 ; i<=n ; i++){
      sb.append(arr[i]);
      sb.append(' ');
    }
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class MikeAndFeet_305B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     nums[i+1] := (st.next())->toInteger() ;  ;     i := i + 1 ) ; 
    execute helper(nums) ; 
 );
  static   operation helper( nums : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := nums->size() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
    var stack : Sequence(int) ; stack := Sequence{} ;
    stack := stack->append(-1) ; 
        var i : int ; i := 0 ; while i < n do ( (     while (stack->min() /= -1 & nums[stack->min()+1] >= nums[i+1]) do (     var j : int ; j := stack->last() ;
     var len : int ; len := i - stack->min() - 1 ;
     if (arr[len+1] < nums[j+1]) then     arr[len+1] := nums[j+1] ; else skip ) ; 
     stack := stack->append(i) )  ;     i := i + 1 ) ; 
    while (stack->min() /= -1) do (     var j : int ; j := stack->last() ;
     var len : int ; len := n - stack->min() - 1 ;
     if (arr[len+1] < nums[j+1]) then     arr[len+1] := nums[j+1] ; else skip ) ; 
        var i : int ; i := n - 1 ; while i > 0 do ( (     if (arr[i+1] < arr[i + 1+1]) then     arr[i+1] := arr[i + 1+1] ; else skip )  ;     i := i - 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 1 ; while i <= n do ( (     sb := sb + StringLib.newString(arr[i+1]) ; 
     sb := sb + StringLib.newString(' ') )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void LeadingZeros(int x,int y){
    if((x ^ y)<=(x & y))System.out.print("\nEqual");
    else if((x &(~ y))>y)System.out.print(y);
    else System.out.print(x);
  }
  public static void main(String[] args){
    int x=10,y=16 ;
    LeadingZeros(x,y);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation LeadingZeros( x : int, y : int) : void
  pre: true
  post: true
  activity: (     if ((x xor y) <= (x & y)) then     OclFile["System.out"].print("\nEqual") ; else     if ((x & (-(y + 1))) > y) then     OclFile["System.out"].print(y) else     OclFile["System.out"].print(x) ; ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 10 ;
    var y : int ; y := 16 ;
     execute LeadingZeros(x, y) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int makeOdd(int n){
    if(n % 2!=0)return 1 ;
    int i ;
    for(i=2 ; i<=n ; i++)if((n % i==0)&&((n/i)% 2==1))break ;
    return i ;
  }
  public static void main(String[] args){
    int n=36 ;
    int res=makeOdd(n);
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation makeOdd( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 /= 0) then     return 1 else skip ; 
     var i : int ;
         i := 2 ; while i <= n do (     if ((n mod i = 0) & ((n / i) mod 2 = 1)) then     break else skip ;  ;     i := i + 1 ) ; 
     return i );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 36 ;
     var res : int ; res := makeOdd(n) ;
     OclFile["System.out"].println(res) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    int[] H=new int[N];
    for(int i=0 ; i<N ; i++){
      H[i]=sc.nextInt();
    }
    long ans=0 ;
    Arrays.sort(H);
    if(H.length<=K){
      System.out.println(0);
    }
    else {
      for(int i=0 ; i<N-K ; i++){
        ans+=H[i];
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var H : Sequence(int) ; H := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     H[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    H := H->sort() ; 
    if (H->size() <= K) then (     OclFile["System.out"].println(0) ) else (         var i : int ; i := 0 ; while i < N - K do ( (     ans := ans+(H[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
import java.util.Collections ;
public class Main {
  Scanner scan=new Scanner(System.in);
  int N ;
  ArrayList<Integer>H=new ArrayList<>();
  int K ;
  int min ;
  Main(){
    N=scan.nextInt();
    K=scan.nextInt();
    for(int i=0 ; i<N ; i++){
      H.add(scan.nextInt());
    }
    System.out.println(minmize(N,K,H));
  }
  public long minmize(int N,int K,ArrayList<Integer>H){
    long sumhp=0 ;
    Collections.sort(H);
    for(int i=0 ; i<H.size()-K ; i++){
      sumhp+=H.get(i);
    }
    return sumhp ;
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute N : int;
   attribute H : Sequence(int) := Sequence{};
   attribute K : int;
   attribute min : int;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     N := scan.getCurrent()->toInteger() ; 
     K := scan.getCurrent()->toInteger() ; 
         var i : int ; i := 0 ; while i < N do ( (     H := H->including(scan.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(minmize(N, K, H)) );
   operation minmize( N : int, K : int, H : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var sumhp : long ; sumhp := 0 ;
     H := H->sort() ; 
         var i : int ; i := 0 ; while i < H->size() - K do ( (     sumhp := sumhp+(H->at(i+1)) )  ;     i := i + 1 ) ; 
     return sumhp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n,k,i=0 ;
    BigInteger s ;
    s=BigInteger.ZERO ;
    String[] strs=br.readLine().trim().split("\\s+");
    n=Integer.parseInt(strs[0]);
    k=Integer.parseInt(strs[1]);
    int a[]=new int[n];
    String[] strsa=br.readLine().trim().split("\\s+");
    for(i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(strsa[i]);
    }
    if((k-n)>=0)System.out.println("0");
    else if((k-n)<0){
      Arrays.sort(a);
      for(i=0 ; i<n-k ; i++)s=s.add(BigInteger.valueOf(a[i]));
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ;
    var k : int ;
    var i : int ; i := 0 ;
    var s : long ;
    s := 0 ; 
    var strs : Sequence(String) ; strs := br.readLine()->trim()->split("\\s+") ;
    n := (strs[0+1])->toInteger() ; 
    k := (strs[1+1])->toInteger() ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var strsa : Sequence(String) ; strsa := br.readLine()->trim()->split("\\s+") ;
        i := 0 ; while i < n do ( (     a[i+1] := (strsa[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    if ((k - n) >= 0) then     OclFile["System.out"].println("0") else     if ((k - n) < 0) then (     a := a->sort() ; 
         i := 0 ; while i < n - k do (     s := s->excludes((a[i+1] + "")->toLong()) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(s) ) else skip ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long monster_kensu=sc.nextLong();
    long kill_kaisu=sc.nextLong();
    if(monster_kensu<=kill_kaisu){
      System.out.println("0");
    }
    else {
      List<Long>monster_list=new ArrayList<>();
      for(int i=0 ; i<monster_kensu ; i++){
        monster_list.add(sc.nextLong());
      }
      Collections.sort(monster_list,Collections.reverseOrder());
      long attack_sum=0 ;
      attack_sum=monster_list.stream().mapToLong(Long :: longValue).skip(kill_kaisu).sum();
      System.out.println(attack_sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var monster_kensu : long ; monster_kensu := sc.getCurrent()->toLong() ;
     var kill_kaisu : long ; kill_kaisu := sc.getCurrent()->toLong() ;
     if (monster_kensu <= kill_kaisu) then (     OclFile["System.out"].println("0") ) else (     var monster_list : Sequence(long) ; monster_list := Sequence{} ;
         var i : int ; i := 0 ; while i < monster_kensu do ( (     monster_list := monster_list->including(sc.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    monster_list, reverseOrder() := monster_list, reverseOrder()->sort() ; 
    var attack_sum : long ; attack_sum := 0 ;
    attack_sum := monster_list->collect( _x1 | (lambda _pars : OclAny in Long.newLong().longValue(_pars))->apply(_x1) ).subrange(kill_kaisu+1)->sum() ; 
    OclFile["System.out"].println(attack_sum) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  private static boolean[] calcPrimeTable(int n){
    boolean[] table=new boolean[n+1];
    for(int i=2 ; i<=Math.sqrt(n); i++){
      if(! table[i]){
        for(int j=i+i ; j<=n ; j+=i){
          table[j]=true ;
        }
      }
    }
    return table ;
  }
  private static void solve(){
    boolean[] table=calcPrimeTable(1<<15);
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      int counter=0 ;
      if(n==0){
        break ;
      }
      for(int i=2 ; i<=n/2 ; i++){
        if(! table[i] && ! table[n-i]){
          counter++;
        }
      }
      System.out.println(counter);
    }
  }
  public static void main(String...args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation calcPrimeTable( n : int) : Sequence(boolean)
  pre: true
  post: true
  activity: (     var table : Sequence(boolean) ; table := Integer.subrange(1,n + 1)->collect(false) ;
         var i : int ; i := 2 ; while i <= (n)->sqrt() do ( (     if (not(table[i+1])) then (         var j : int ; j := i + i ; while j <= n do ( (     table[j+1] := true )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
     return table );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var table : Sequence(boolean) ; table := calcPrimeTable((1*(2->pow(15)))->oclAsType(long)) ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var counter : int ; counter := 0 ;
    if (n = 0) then (     break ) else skip ; 
        var i : int ; i := 2 ; while i <= n / 2 do ( (     if (not(table[i+1]) & not(table[n - i+1])) then (     counter := counter + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  final static long MOD=1000000007 ;
  public static void main(String[] args)throws Exception {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String W=in.readLine();
    String[] Ws=W.split(" ");
    int N=Integer.parseInt(Ws[0]);
    int K=Integer.parseInt(Ws[1]);
    W=in.readLine();
    Ws=W.split(" ");
    long[] H=new long[Ws.length];
    for(int i=0 ; i<Ws.length ; i++){
      H[i]=Long.parseLong(Ws[i]);
    }
    Arrays.sort(H);
    long sum=0 ;
    for(int i=N-1-K ; i>=0 ; i--){
      sum+=H[i];
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : long := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var W : String ; W := in.readLine() ;
    var Ws : Sequence(String) ; Ws := W->split(" ") ;
    var N : int ; N := (Ws[0+1])->toInteger() ;
    var K : int ; K := (Ws[1+1])->toInteger() ;
    W := in.readLine() ; 
    Ws := W->split(" ") ; 
    var H : Sequence(long) ; H := Integer.subrange(1,Ws->size())->collect(0) ;
        var i : int ; i := 0 ; while i < Ws->size() do ( (     H[i+1] := (Ws[i+1])->toLong() )  ;     i := i + 1 ) ; 
    H := H->sort() ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := N - 1 - K ; while i >= 0 do ( (     sum := sum+(H[i+1]) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int minMoves(int n,int a[],int k){
    int ct1[]=new int[k];
    int ct0[]=new int[k];
    int moves=0 ;
    for(int i=0 ; i<n ; i++)if(a[i]==1)ct1[i % k]++;
    else ct0[i % k]++;
    for(int i=0 ; i<k ; i++)moves+=Math.min(ct1[i],ct0[i]);
    return moves ;
  }
  public static void main(String[] args){
    int k=2 ;
    int a[]={
      1,0,0,0,1,0 };
      int n=a.length ;
      System.out.println(minMoves(n,a,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minMoves( n : int, a : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     var ct1 : Sequence(int) ; ct1 := Integer.subrange(1,k)->collect(0) ;
     var ct0 : Sequence(int) ; ct0 := Integer.subrange(1,k)->collect(0) ;
    var moves : int ; moves := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (a[i+1] = 1) then     ct1[i mod k+1] := ct1[i mod k+1] + 1 else     ct0[i mod k+1] := ct0[i mod k+1] + 1 ; ;   ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do (     moves := moves+(Set{ct1[i+1], ct0[i+1]}->min()) ;  ;     i := i + 1 ) ; 
    return moves 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 2 ;
     var a : Sequence(int) ; a := Sequence{1,0,0,0,1,0} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(minMoves(n, a, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static long mod=1000000007 ;
  static long inv2=500000004 ;
  static long modulo(String num){
    long res=0 ;
    for(int i=0 ; i<num.length(); i++)res=(res*10+(long)num.charAt(i)-'0')% mod ;
    return res ;
  }
  static long findSum(String L,String R){
    long a,b,l,r,ret ;
    a=modulo(L);
    b=modulo(R);
    l=((a*(a-1))% mod*inv2)% mod ;
    r=((b*(b+1))% mod*inv2)% mod ;
    ret=(r % mod-l % mod);
    if(ret<0)ret=ret+mod ;
    else ret=ret % mod ;
    return ret ;
  }
  public static void main(String[] args){
    String L="88949273204" ;
    String R="98429729474298592" ;
    System.out.println(findSum(L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute mod : long := 1000000007;
  static   attribute inv2 : long := 500000004;
  static   operation modulo( num : String) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 0 ;
         var i : int ; i := 0 ; while i < num->size() do (     res := (res * 10 + num->at(i+1)->oclAsType(long) - ('0')->char2byte()) mod mod ;  ;     i := i + 1 ) ; 
     return res );
  static   operation findSum( L : String, R : String) : long
  pre: true
  post: true
  activity: (     var a : long ;
    var b : long ;
    var l : long ;
    var r : long ;
    var ret : long ;
     a := modulo(L) ; 
    b := modulo(R) ; 
    l := ((a * (a - 1)) mod mod * inv2) mod mod ; 
    r := ((b * (b + 1)) mod mod * inv2) mod mod ; 
    ret := (r mod mod - l mod mod) ; 
    if (ret < 0) then     ret := ret + mod else     ret := ret mod mod ; ;  
    return ret 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : String ; L := "88949273204" ;
     var R : String ; R := "98429729474298592" ;
     OclFile["System.out"].println(findSum(L, R)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    int n=nextInt();
    int m=nextInt();
    Treasure[] treasure=new Treasure[n];
    for(int i=0 ; i<n ; i++){
      treasure[i]=new Treasure(nextInt(),nextInt());
    }
    Arrays.sort(treasure);
    for(int q=0 ; q<m ; q++){
      int cnt=0 ;
      int x1=nextInt();
      int y1=nextInt();
      int x2=nextInt();
      int y2=nextInt();
      for(int i=0 ; i<n ; i++){
        if(treasure[i] .x>=x1){
          for(int k=i ; k<n ; k++){
            if(treasure[k] .x>x2){
              i=n ;
              k=n ;
            }
            else if(y1<=treasure[k] .y && treasure[k] .y<=y2){
              cnt++;
            }
          }
          break ;
        }
      }
      System.out.println(cnt);
    }
  }
  static int nextInt(){
    int c ;
    try {
      c=System.in.read();
      while(c!='-' &&(c<'0' || c>'9'))c=System.in.read();
      if(c=='-')return-nextInt();
      int res=0 ;
      while(c>='0' && c<='9'){
        res=res*10+c-'0' ;
        c=System.in.read();
      }
      return res ;
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return-1 ;
  }
}
class Treasure implements Comparable<Treasure>{
  int x=0 ;
  int y=0 ;
  public Treasure(int x,int y){
    this.x=x ;
    this.y=y ;
  }
  public int compareTo(Treasure t1){
    return this.x-t1.x ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var m : int ; m := nextInt() ;
    var treasure : Sequence(Treasure) ; treasure := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     treasure[i+1] := Treasure.newTreasure(nextInt(), nextInt()) )  ;     i := i + 1 ) ; 
    treasure := treasure->sort() ; 
        var q : int ; q := 0 ; while q < m do ( (     var cnt : int ; cnt := 0 ;
     var x1 : int ; x1 := nextInt() ;
    var y1 : int ; y1 := nextInt() ;
    var x2 : int ; x2 := nextInt() ;
    var y2 : int ; y2 := nextInt() ;
        var i : int ; i := 0 ; while i < n do ( (     if (treasure[i+1].x >= x1) then (         var k : int ; k := i ; while k < n do ( (     if (treasure[k+1].x > x2) then (     i := n ; 
     k := n ) else     if (y1 <= treasure[k+1].y & treasure[k+1].y <= y2) then (     cnt := cnt + 1 ) else skip ; )  ;     k := k + 1 ) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 )  ;     q := q + 1 ) ; 
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     var c : int ;
     try (     c := OclFile["System.in"].read() ; 
     while (c /= '-' & (c < '0' or c > '9')) do     c := OclFile["System.in"].read() ; ; 
    if (c = '-') then     return -nextInt() else skip ; 
    var res : int ; res := 0 ;
    while (c >= '0' & c <= '9') do (     res := res * 10 + c - ('0')->char2byte() ; 
     c := OclFile["System.in"].read() ) ; 
    return res 
 )   catch (e : IOException) do (     e.printStackTrace() )
     return -1 );
}
class Treasure implements Comparable<Treasure> {
   attribute x : int := 0;
   attribute y : int := 0;
   static operation newTreasure( x : int, y : int) : Treasure
  pre: true
  post: true
  activity:
  ( var self : Treasure ;
    self := createTreasure();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation compareTo( t1 : Treasure) : int
  pre: true
  post: true
  activity: (     return self.x - t1.x );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int[][] map=new int[n][2];
      for(int i=0 ; i<n ; i++){
        map[i][0]=sc.nextInt();
        map[i][1]=sc.nextInt();
      }
      Arrays.sort(map,new Comparator<int[]>(){
        public int compare(int[] o1,int[] o2){
          return o1[0]-o2[0];
        }
      }
);
      int cnt,a,b,c,d ;
      for(int i=0 ; i<m ; i++){
        cnt=0 ;
        a=sc.nextInt();
        b=sc.nextInt();
        c=sc.nextInt();
        d=sc.nextInt();
        for(int j=0 ; j<n ; j++){
          if(map[j][0]>=a){
            for(int k=j ; k<n ; k++){
              if(map[k][0]>c){
                j=n ;
                k=n ;
              }
              else if(b<=map[k][1] && map[k][1]<=d){
                cnt++;
              }
            }
            break ;
          }
        }
        System.out.println(cnt);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     map[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     map[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    map := OclComparator.sortWith(map, OclComparator<Sequence(int)>.newOclComparator()) ; 
    var cnt : int ;
    var a : int ;
    var b : int ;
    var c : int ;
    var d : int ;
        var i : int ; i := 0 ; while i < m do ( (     cnt := 0 ; 
     a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    c := sc.getCurrent()->toInteger() ; 
    d := sc.getCurrent()->toInteger() ; 
        var j : int ; j := 0 ; while j < n do ( (     if (map[j+1][0+1] >= a) then (         var k : int ; k := j ; while k < n do ( (     if (map[k+1][0+1] > c) then (     j := n ; 
     k := n ) else     if (b <= map[k+1][1+1] & map[k+1][1+1] <= d) then (     cnt := cnt + 1 ) else skip ; )  ;     k := k + 1 ) ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    int n=nextInt();
    int m=nextInt();
    Treasure[] treasure=new Treasure[n];
    for(int i=0 ; i<n ; i++){
      treasure[i]=new Treasure(nextInt(),nextInt());
    }
    Arrays.sort(treasure);
    for(int q=0 ; q<m ; q++){
      int count=0 ;
      int x1=nextInt();
      int y1=nextInt();
      int x2=nextInt();
      int y2=nextInt();
      for(int i=0 ; i<treasure.length ; i++){
        if(treasure[i] .x<x1){
          continue ;
        }
        for(int k=i ; k<treasure.length ; k++){
          if(treasure[k] .x>x2){
            break ;
          }
          if(treasure[k] .y>=y1 && treasure[k] .y<=y2){
            count++;
          }
        }
        break ;
      }
      System.out.println(count);
    }
  }
  static int nextInt(){
    int c ;
    try {
      c=System.in.read();
      while(c!='-' &&(c<'0' || c>'9'))c=System.in.read();
      if(c=='-')return-nextInt();
      int res=0 ;
      while(c>='0' && c<='9'){
        res=res*10+c-'0' ;
        c=System.in.read();
      }
      return res ;
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return-1 ;
  }
}
class Treasure implements Comparable<Treasure>{
  int x=0 ;
  int y=0 ;
  public Treasure(int x,int y){
    this.x=x ;
    this.y=y ;
  }
  public int compareTo(Treasure t1){
    return this.x-t1.x ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var m : int ; m := nextInt() ;
    var treasure : Sequence(Treasure) ; treasure := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     treasure[i+1] := Treasure.newTreasure(nextInt(), nextInt()) )  ;     i := i + 1 ) ; 
    treasure := treasure->sort() ; 
        var q : int ; q := 0 ; while q < m do ( (     var count : int ; count := 0 ;
     var x1 : int ; x1 := nextInt() ;
    var y1 : int ; y1 := nextInt() ;
    var x2 : int ; x2 := nextInt() ;
    var y2 : int ; y2 := nextInt() ;
        var i : int ; i := 0 ; while i < treasure->size() do ( (     if (treasure[i+1].x < x1) then (     continue ) else skip ; 
         var k : int ; k := i ; while k < treasure->size() do ( (     if (treasure[k+1].x > x2) then (     break ) else skip ; 
     if (treasure[k+1].y >= y1 & treasure[k+1].y <= y2) then (     count := count + 1 ) else skip )  ;     k := k + 1 ) ; 
     break )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )  ;     q := q + 1 ) ; 
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     var c : int ;
     try (     c := OclFile["System.in"].read() ; 
     while (c /= '-' & (c < '0' or c > '9')) do     c := OclFile["System.in"].read() ; ; 
    if (c = '-') then     return -nextInt() else skip ; 
    var res : int ; res := 0 ;
    while (c >= '0' & c <= '9') do (     res := res * 10 + c - ('0')->char2byte() ; 
     c := OclFile["System.in"].read() ) ; 
    return res 
 )   catch (e : IOException) do (     e.printStackTrace() )
     return -1 );
}
class Treasure implements Comparable<Treasure> {
   attribute x : int := 0;
   attribute y : int := 0;
   static operation newTreasure( x : int, y : int) : Treasure
  pre: true
  post: true
  activity:
  ( var self : Treasure ;
    self := createTreasure();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation compareTo( t1 : Treasure) : int
  pre: true
  post: true
  activity: (     return self.x - t1.x );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  public void bfs(int x,int num){
    Queue<Integer>q=new LinkedList<Integer>();
    q.add(num);
    while(! q.isEmpty()){
      num=q.peek();
      q.poll();
      if(num<=x){
        System.out.print(num+" ");
        int last_digit=num % 10 ;
        if(last_digit==0){
          q.add((num*10)+(last_digit+1));
        }
        else if(last_digit==9){
          q.add((num*10)+(last_digit-1));
        }
        else {
          q.add((num*10)+(last_digit-1));
          q.add((num*10)+(last_digit+1));
        }
      }
    }
  }
  public void printJumping(int x){
    System.out.print("0 ");
    for(int i=1 ; i<=9 && i<=x ; i++){
      this.bfs(x,i);
    }
  }
  public static void main(String[] args)throws IOException {
    int x=40 ;
    GFG obj=new GFG();
    obj.printJumping(x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
   operation bfs( x : int, num : int) : void
  pre: true
  post: true
  activity: (     var q : Sequence(int) ; q := Sequence{} ;
     q := q->including(num) ; 
     while (not(q->isEmpty())) do (     num := q->min() ; 
     q := q->sort()->tail() ; 
     if (num <= x) then (     OclFile["System.out"].print(num + " ") ; 
     var last_digit : int ; last_digit := num mod 10 ;
     if (last_digit = 0) then (     q := q->including((num * 10) + (last_digit + 1)) ) else     if (last_digit = 9) then (     q := q->including((num * 10) + (last_digit - 1)) ) else (     q := q->including((num * 10) + (last_digit - 1)) ; 
     q := q->including((num * 10) + (last_digit + 1)) ) ;  ) else skip ) );
   operation printJumping( x : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("0 ") ; 
         var i : int ; i := 1 ; while i <= 9 & i <= x do ( (     self.bfs(x, i) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 40 ;
     var obj : GFG ; obj := GFG.newGFG() ;
     obj.printJumping(x) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int[] arr=new int[n];
      boolean ok=true ;
      Set<Integer>set=new HashSet<>();
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
        set.add(arr[i]);
      }
      int[] chk=new int[set.size()];
      int i=0 ;
      for(Integer x : set)chk[i++]=x ;
      Arrays.sort(chk);
      int len=chk.length ;
      if(len==1)System.out.println(0);
      else if(len==2){
        if((chk[1]-chk[0])% 2==0)System.out.println((chk[1]-chk[0])/2);
        else System.out.println(chk[1]-chk[0]);
      }
      else if(len==3){
        if((chk[2]-chk[1])==(chk[1]-chk[0]))System.out.println(chk[2]-chk[1]);
        else System.out.println(-1);
      }
      else System.out.println(-1);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var ok : boolean ; ok := true ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     set := set->including(arr[i+1]) )  ;     i := i + 1 ) ; 
    var chk : Sequence(int) ; chk := Integer.subrange(1,set->size())->collect(0) ;
    var i : int ; i := 0 ;
    for (x : set) do (      chk[i+1] := x  ; i := i + 1 ;  ) ; 
    chk := chk->sort() ; 
    var len : int ; len := chk->size() ;
    if (len = 1) then     OclFile["System.out"].println(0) else     if (len = 2) then (     if ((chk[1+1] - chk[0+1]) mod 2 = 0) then     OclFile["System.out"].println((chk[1+1] - chk[0+1]) / 2) ; else     OclFile["System.out"].println(chk[1+1] - chk[0+1]) ; ) else     if (len = 3) then (     if ((chk[2+1] - chk[1+1]) = (chk[1+1] - chk[0+1])) then     OclFile["System.out"].println(chk[2+1] - chk[1+1]) ; else     OclFile["System.out"].println(-1) ; ) else     OclFile["System.out"].println(-1) ; ;  ;  ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class dp1 {
  static int n,dp[];
  static int a[];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int i ;
    n=sc.nextInt();
    a=new int[n];
    for(i=0 ; i<n ; i++)a[i]=sc.nextInt();
    Set<Integer>set=new HashSet<>();
    for(i=0 ; i<n ; i++)set.add(a[i]);
    if(set.size()>3){
      System.out.println(-1);
      System.exit(0);
    }
    if(set.size()==1){
      System.out.println(0);
      System.exit(0);
    }
    PriorityQueue<Integer>pq=new PriorityQueue<>();
    for(Integer p : set)pq.add(p);
    int p,q,r ;
    p=pq.poll();
    q=pq.poll();
    if(set.size()==2){
      if((q-p)% 2==0)System.out.println((q-p)/2);
      else System.out.println(q-p);
    }
    else {
      r=pq.poll();
      if((r+p)% 2==0 &&(r+p)/2==q)System.out.println(r-q);
      else System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class dp1 {
  static   attribute n : int;
  static   attribute a : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ;
    n := sc.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
        i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
        i := 0 ; while i < n do (     set := set->including(a[i+1]) ;  ;     i := i + 1 ) ; 
    if (set->size() > 3) then (     OclFile["System.out"].println(-1) ; 
 OclProcess.exit(0) ) else skip ; 
    if (set->size() = 1) then (     OclFile["System.out"].println(0) ; 
 OclProcess.exit(0) ) else skip ; 
    var pq : Sequence(int) ; pq := Sequence{} ;
    for (p : set) do (     pq := pq->including(p) ;  ) ; 
    var p : int ;
    var q : int ;
    var r : int ;
    p := pq->min() ;     pq := pq->sort()->tail() ; 
    q := pq->min() ;     pq := pq->sort()->tail() ; 
    if (set->size() = 2) then (     if ((q - p) mod 2 = 0) then     OclFile["System.out"].println((q - p) / 2) ; else     OclFile["System.out"].println(q - p) ; ) else (     r := pq->min() ;     pq := pq->sort()->tail() ; 
     if ((r + p) mod 2 = 0 & (r + p) / 2 = q) then     OclFile["System.out"].println(r - q) ; else     OclFile["System.out"].println(-1) ; ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Run {
  public static void main(String[] Z)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder op=new StringBuilder();
    StringTokenizer stz ;
    int n=Integer.parseInt(br.readLine());
    stz=new StringTokenizer(br.readLine());
    ArrayList<Integer>arr=new ArrayList<>(n);
    for(int i=0 ; i<n ; i++){
      int num=Integer.parseInt(stz.nextToken());
      arr.add(num);
    }
    Collections.sort(arr);
    int first=arr.get(0);
    int last=arr.get(n-1);
    int ans=-1 ;
    for(int val=first ; val<=last ; ++val){
      int d=Math.abs(arr.get(0)-val);
      boolean can=true ;
      for(int curr : arr){
        if(curr==val || curr+d==val || curr-d==val){
        }
        else {
          can=false ;
          break ;
        }
      }
      if(can){
        ans=d ;
        break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Run {
  static   operation main( Z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var op : String ; op := StringLib.newString() ;
    var stz : OclIterator ;
    var n : int ; n := (br.readLine())->toInteger() ;
    stz := OclIterator.newOclIterator_String(br.readLine()) ; 
    var arr : Sequence(int) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := (stz.next())->toInteger() ;
     arr := arr->including(num) )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var first : int ; first := arr->at(0+1) ;
    var last : int ; last := arr->at(n - 1+1) ;
    var ans : int ; ans := -1 ;
        var val : int ; val := first ; while val <= last do ( (     var d : int ; d := if arr->at(0+1) - val < 0 then -(arr->at(0+1) - val) else arr->at(0+1) - val endif ;
     var can : boolean ; can := true ;
     for (curr : arr) do ( (     if (curr = val or curr + d = val or curr - d = val) then skip else (     can := false ; 
     break ) )  ) ; 
     if (can) then (     ans := d ; 
     break ) else skip )  ;     val := val + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MakeThemEqual1154B {
  private static Scanner s=new Scanner(System.in);
  public static void main(String[] args){
    int n=s.nextInt();
    Set<Integer>set=new TreeSet<>();
    for(int i=0 ; i<n ; i++){
      set.add(s.nextInt());
    }
    if(set.size()<=3){
      List<Integer>values=new ArrayList<>(set);
      if(values.size()==3 && Math.abs(values.get(0)-values.get(1))==Math.abs(values.get(2)-values.get(1))){
        System.out.println(Math.abs(values.get(0)-values.get(1)));
      }
      else if(values.size()==2){
        int diff=Math.abs(values.get(0)-values.get(1));
        System.out.println(diff % 2==0 ? diff/2 : diff);
      }
      else if(values.size()==1){
        System.out.println(0);
      }
      else {
        System.out.println(-1);
      }
      return ;
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MakeThemEqual1154B {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s.getCurrent()->toInteger() ;
     var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     set := set->including(s.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    if (set->size() <= 3) then (     var values : Sequence(int) ; values := Sequence{}->union(set) ;
     if (values->size() = 3 & if values->at(0+1) - values->at(1+1) < 0 then -(values->at(0+1) - values->at(1+1)) else values->at(0+1) - values->at(1+1) endif = if values->at(2+1) - values->at(1+1) < 0 then -(values->at(2+1) - values->at(1+1)) else values->at(2+1) - values->at(1+1) endif) then (     OclFile["System.out"].println(if values->at(0+1) - values->at(1+1) < 0 then -(values->at(0+1) - values->at(1+1)) else values->at(0+1) - values->at(1+1) endif) ) else     if (values->size() = 2) then (     var diff : int ; diff := if values->at(0+1) - values->at(1+1) < 0 then -(values->at(0+1) - values->at(1+1)) else values->at(0+1) - values->at(1+1) endif ;
     OclFile["System.out"].println(if diff mod 2 = 0 then diff / 2 else diff endif) ) else     if (values->size() = 1) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(-1) ) ;  ;  ;  
     return ) else skip ; 
    OclFile["System.out"].println(-1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemB {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    String line[]=br.readLine().split(" ");
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=Integer.parseInt(line[i]);
    int ans=99999 ;
    for(int d=1 ; d<=1000 ; d++){
      TreeSet<Integer>set=new TreeSet<>();
      for(int i=0 ; i<n ; i++){
        if(arr[i]==d)continue ;
        set.add(Math.abs(d-arr[i]));
      }
      if(set.size()==0)ans=0 ;
      if(set.size()==1)ans=Math.min(ans,set.first());
    }
    System.out.println(ans==99999 ?-1 : ans);
  }
  public static void sort(int arr[]){
    ArrayList<Integer>list=new ArrayList<>();
    for(int it : arr)list.add(it);
    Collections.sort(list);
    for(int i=0 ; i<arr.length ; i++)arr[i]=list.get(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := (line[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 99999 ;
        var d : int ; d := 1 ; while d <= 1000 do ( (     var set : Set(int) ; set := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = d) then     continue else skip ; 
     set := set->including(if d - arr[i+1] < 0 then -(d - arr[i+1]) else d - arr[i+1] endif) )  ;     i := i + 1 ) ; 
     if (set->size() = 0) then     ans := 0 ; else skip ; 
     if (set->size() = 1) then     ans := Set{ans, set->first()}->min() ; else skip )  ;     d := d + 1 ) ; 
    OclFile["System.out"].println(if ans = 99999 then -1 else ans endif) ; 
 );
  static   operation sort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     for (it : arr) do (     list := list->including(it) ;  ) ; 
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < arr->size() do (     arr[i+1] := list->at(i+1) ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void unsort(int l,int r,int a[],int k){
    if(k<1 || l+1==r)return ;
    k-=2 ;
    int mid=(l+r)/2 ;
    int temp=a[mid-1];
    a[mid-1]=a[mid];
    a[mid]=temp ;
    unsort(l,mid,a,k);
    unsort(mid,r,a,k);
  }
  static void arrayWithKCalls(int n,int k){
    if(k % 2==0){
      System.out.print("NO SOLUTION");
      return ;
    }
    int a[]=new int[n+1];
    a[0]=1 ;
    for(int i=1 ; i<n ; i++)a[i]=i+1 ;
    k--;
    unsort(0,n,a,k);
    for(int i=0 ; i<n ; ++i)System.out.print(a[i]+" ");
  }
  public static void main(String[] args){
    int n=10,k=17 ;
    arrayWithKCalls(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation unsort( l : int, r : int, a : Sequence(int), k : int) : void
  pre: true
  post: true
  activity: (     if (k < 1 or l + 1 = r) then     return else skip ; 
     k := k-(2) ; 
    var mid : int ; mid := (l + r) / 2 ;
    var temp : int ; temp := a[mid - 1+1] ;
    a[mid - 1+1] := a[mid+1] ; 
    a[mid+1] := temp ; 
    execute unsort(l, mid, a, k) ; 
    execute unsort(mid, r, a, k) ; 
 );
  static   operation arrayWithKCalls( n : int, k : int) : void
  pre: true
  post: true
  activity: (     if (k mod 2 = 0) then (     OclFile["System.out"].print("NO SOLUTION") ; 
     return ) else skip ; 
     var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    a[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < n do (     a[i+1] := i + 1 ;  ;     i := i + 1 ) ; 
    k := k - 1 ; 
    execute unsort(0, n, a, k) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
    var k : int ; k := 17 ;
     execute arrayWithKCalls(n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int a=s.nextInt(),b=s.nextInt(),c=s.nextInt();
    for(int i=1 ; i<=b ; i++){
      if(a*10/b==c){
        System.out.println(i);
        return ;
      }
      a=a*10 % b ;
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := s.getCurrent()->toInteger() ;
    var b : int ; b := s.getCurrent()->toInteger() ;
    var c : int ; c := s.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= b do ( (     if (a * 10 / b = c) then (     OclFile["System.out"].println(i) ; 
     return ) else skip ; 
     a := a * 10 mod b )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(-1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigDecimal ;
import java.math.RoundingMode ;
public class Main {
  public static void main(String[] args)throws IOException {
    StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    in.nextToken();
    BigDecimal a=new BigDecimal(in.nval);
    in.nextToken();
    BigDecimal b=new BigDecimal(in.nval);
    in.nextToken();
    int c=(int)in.nval ;
    BigDecimal bigNum=a.divide(b,100005,RoundingMode.HALF_UP);
    String ans=bigNum.toString();
    int index=ans.indexOf('.');
    int flag=1 ;
    for(int i=index ; i<ans.length()-1 ; i++){
      char t=ans.charAt(i);
      if(t==c+'0'){
        out.println(i-1);
        out.flush();
        flag=0 ;
        break ;
      }
    }
    if(flag==1)out.println(-1);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : StreamTokenizer ; in := StreamTokenizer.newStreamTokenizer(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    in.next() ; 
    var a : double ; a := double(in.nval) ;
    in.next() ; 
    var b : double ; b := double(in.nval) ;
    in.next() ; 
    var c : int ; c := in.nval->oclAsType(int) ;
    var bigNum : double ; bigNum := a.divide(b, 100005, RoundingMode.HALF_UP) ;
    var ans : String ; ans := bigNum+"" ;
    var index : int ; index := ans->indexOf('.')-1 ;
    var flag : int ; flag := 1 ;
        var i : int ; i := index ; while i < ans->size() - 1 do ( (     var t : String ; t := ans->at(i+1) ;
     if (t = c + '0') then (     skip ; 
     skip ; 
     flag := 0 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 1) then     skip ; else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sca=new Scanner(System.in);
    BigDecimal res=BigDecimal.valueOf(1);
    BigDecimal a,b ;
    a=sca.nextBigDecimal();
    b=sca.nextBigDecimal();
    int n ;
    n=sca.nextInt();
    res=a.divide(b,100005,RoundingMode.HALF_UP);
    String str ;
    str=res.toString();
    int index=str.indexOf('.');
    int flag=1 ;
    for(int i=index ; i<str.length()-1 ; i++){
      char tmp ;
      tmp=str.charAt(i);
      if(tmp==(n+'0')){
        System.out.println(i-1);
        flag=0 ;
        break ;
      }
    }
    if(flag==1)System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sca : OclFile ; sca := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var res : double ; res := (1 + "")->toReal() ;
    var a : double ;
    var b : double ;
    a := sca.nextBigDecimal() ; 
    b := sca.nextBigDecimal() ; 
    var n : int ;
    n := sca.getCurrent()->toInteger() ; 
    res := a.divide(b, 100005, RoundingMode.HALF_UP) ; 
    var str : String ;
    str := res+"" ; 
    var index : int ; index := str->indexOf('.')-1 ;
    var flag : int ; flag := 1 ;
        var i : int ; i := index ; while i < str->size() - 1 do ( (     var tmp : String ;
     tmp := str->at(i+1) ; 
     if (tmp = (n + '0')) then (     OclFile["System.out"].println(i - 1) ; 
     flag := 0 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 1) then     OclFile["System.out"].println(-1) ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int a=s.nextInt(),b=s.nextInt(),c=s.nextInt();
    for(int i=1 ; i<=b ; i++){
      if(a*10/b==c){
        System.out.println(i);
        return ;
      }
      a=a*10 % b ;
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := s.getCurrent()->toInteger() ;
    var b : int ; b := s.getCurrent()->toInteger() ;
    var c : int ; c := s.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= b do ( (     if (a * 10 / b = c) then (     OclFile["System.out"].println(i) ; 
     return ) else skip ; 
     a := a * 10 mod b )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(-1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    int tmp=num ;
    while(tmp % 2==0){
      tmp/=2 ;
    }
    if(tmp==1){
      System.out.println("No");
      return ;
    }
    System.out.println("Yes");
    int line=(int)(Math.floor((num+1)/4.0)*4)-1 ;
    StringBuilder ans=new StringBuilder();
    for(int i=1 ; i<line ; i++){
      ans.append(i+" "+(i+1)+"\n");
      ans.append((num+i)+" "+(num+i+1)+"\n");
    }
    ans.append(line+" "+(num+1)+"\n");
    int rest=num-line ;
    switch(rest){
      case 0 : break ;
      case 1 : ans.append((num/tmp+1)+" "+(line+1)+"\n");
      ans.append((num-num/tmp)+" "+(num+line+1)+"\n");
      break ;
      case 2 : case 3 : ans.append((1)+" "+(line+1)+"\n");
      ans.append((line+1)+" "+(line+2)+"\n");
      ans.append((num+1)+" "+(num+line+2)+"\n");
      ans.append((num+line+2)+" "+(num+line+1)+"\n");
      if(rest==3){
        ans.append((num+line+2)+" "+(line+3)+"\n");
        ans.append((num+2)+" "+(num+line+3)+"\n");
      }
      break ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
    var tmp : int ; tmp := num ;
    while (tmp mod 2 = 0) do (     tmp := tmp/(2) ) ; 
    if (tmp = 1) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
    OclFile["System.out"].println("Yes") ; 
    var line : int ; line := (((num + 1) / 4.0)->floor() * 4)->oclAsType(int) - 1 ;
    var ans : String ; ans := StringLib.newString() ;
        var i : int ; i := 1 ; while i < line do ( (     ans := ans + StringLib.newString(i + " " + (i + 1) + "\n") ; 
     ans := ans + StringLib.newString((num + i) + " " + (num + i + 1) + "\n") )  ;     i := i + 1 ) ; 
    ans := ans + StringLib.newString(line + " " + (num + 1) + "\n") ; 
    var rest : int ; rest := num - line ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (rest) ; 
       if _switchval = 0 then
     break 
   else skip ;
       if _switchval = 1 then
     ans := ans + StringLib.newString((num / tmp + 1) + " " + (line + 1) + "\n") ; 
    ans := ans + StringLib.newString((num - num / tmp) + " " + (num + line + 1) + "\n") ; 
    break 
   else skip ;
    if _switchval = 2 or _switchval = 3 then
    ans := ans + StringLib.newString((1) + " " + (line + 1) + "\n") ; 
    ans := ans + StringLib.newString((line + 1) + " " + (line + 2) + "\n") ; 
    ans := ans + StringLib.newString((num + 1) + " " + (num + line + 2) + "\n") ; 
    ans := ans + StringLib.newString((num + line + 2) + " " + (num + line + 1) + "\n") ; 
    if (rest = 3) then (     ans := ans + StringLib.newString((num + line + 2) + " " + (line + 3) + "\n") ; 
     ans := ans + StringLib.newString((num + 2) + " " + (num + line + 3) + "\n") ) else skip ; 
    break 
   else skip ;
 )
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    {
      for(long i=1 ; i<1L<<30 ; i*=2){
        if(i==N){
          System.out.println("No");
          return ;
        }
      }
    }
    System.out.println("Yes");
    int M=(N % 2==0 ? N-1 : N);
    for(int i=2 ; i<=M ; ++i){
      System.out.println(1+" "+i);
    }
    for(int i=2 ; i<=M ; i+=2){
      System.out.println((i+1)+" "+(i+N));
    }
    for(int i=3 ; i<=M ; i+=2){
      System.out.println((i-1)+" "+(i+N));
    }
    System.out.println((2+N)+" "+(1+N));
    if(M!=N){
      for(int i=2 ; i<=M ; ++i){
        if(2<=(1 ^ i ^ N)&&(1 ^ i ^ N)<=M &&(1 ^ i ^ N)!=i){
          System.out.println(i+" "+N);
          System.out.println((1 ^ i ^ N)+" "+(N+N));
          return ;
        }
      }
    }
  }
  void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
(         var i : long ; i := 1 ; while i < (1L*(2->pow(30)))->oclAsType(long) do ( (     if (i = N) then (     OclFile["System.out"].println("No") ; 
     return ) else skip )  ;     i := i*(2) ) ) 
    OclFile["System.out"].println("Yes") ; 
    var M : int ; M := (if N mod 2 = 0 then N - 1 else N endif) ;
        var i : int ; i := 2 ; while i <= M do ( (     OclFile["System.out"].println(1 + " " + i) )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= M do ( (     OclFile["System.out"].println((i + 1) + " " + (i + N)) )  ;     i := i+(2) ) ; 
        var i : int ; i := 3 ; while i <= M do ( (     OclFile["System.out"].println((i - 1) + " " + (i + N)) )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println((2 + N) + " " + (1 + N)) ; 
    if (M /= N) then (         var i : int ; i := 2 ; while i <= M do ( (     if (2 <= (MathLib.bitwiseXor(MathLib.bitwiseXor(1,i),N)) & (MathLib.bitwiseXor(MathLib.bitwiseXor(1,i),N)) <= M & (MathLib.bitwiseXor(MathLib.bitwiseXor(1,i),N)) /= i) then (     OclFile["System.out"].println(i + " " + N) ; 
     OclFile["System.out"].println((MathLib.bitwiseXor(MathLib.bitwiseXor(1,i),N)) + " " + (N + N)) ; 
     return ) else skip )  ;     i := i + 1 ) ) else skip ; 
 );
   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    br.close();
    int a=0 ;
    for(int i=0 ; i<19 ; i++){
      a=1<<i ;
      if(n==a){
        System.out.println("No");
        return ;
      }
      if(n<a){
        a/=2 ;
        break ;
      }
    }
    System.out.println("Yes");
    System.out.println("1 2");
    System.out.println("2 3");
    System.out.println("3 "+(n+1));
    System.out.println((n+1)+" "+(n+2));
    System.out.println((n+2)+" "+(n+3));
    int m=n ;
    if(m % 2==0){
      m--;
    }
    for(int i=4 ; i<m ; i+=2){
      System.out.println((n+1)+" "+i);
      System.out.println(i+" "+(i+1));
      System.out.println((n+1)+" "+(n+i+1));
      System.out.println((n+i+1)+" "+(n+i));
    }
    if(m!=n){
      System.out.println(n+" "+a);
      int b=n-a+1 ;
      if(b>3 && b % 2==1){
        b+=n ;
      }
      System.out.println(n*2+" "+b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    skip ; 
    var a : int ; a := 0 ;
        var i : int ; i := 0 ; while i < 19 do ( (     a := (1*(2->pow(i)))->oclAsType(long) ; 
     if (n = a) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
     if (n < a) then (     a := a/(2) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Yes") ; 
    OclFile["System.out"].println("1 2") ; 
    OclFile["System.out"].println("2 3") ; 
    OclFile["System.out"].println("3 " + (n + 1)) ; 
    OclFile["System.out"].println((n + 1) + " " + (n + 2)) ; 
    OclFile["System.out"].println((n + 2) + " " + (n + 3)) ; 
    var m : int ; m := n ;
    if (m mod 2 = 0) then (     m := m - 1 ) else skip ; 
        var i : int ; i := 4 ; while i < m do ( (     OclFile["System.out"].println((n + 1) + " " + i) ; 
     OclFile["System.out"].println(i + " " + (i + 1)) ; 
     OclFile["System.out"].println((n + 1) + " " + (n + i + 1)) ; 
     OclFile["System.out"].println((n + i + 1) + " " + (n + i)) )  ;     i := i+(2) ) ; 
    if (m /= n) then (     OclFile["System.out"].println(n + " " + a) ; 
     var b : int ; b := n - a + 1 ;
     if (b > 3 & b mod 2 = 1) then (     b := b+(n) ) else skip ; 
     OclFile["System.out"].println(n * 2 + " " + b) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
import static java.lang.System.exit ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  static void solve()throws Exception {
    int n=scanInt();
    if((n &-n)==n){
      out.print("No");
      return ;
    }
    out.println("Yes");
    int m=n+(n & 1)-1 ;
    for(int i=2 ; i<=m ; i++){
      out.println("1 "+i);
      out.println(i+" "+(n+(i ^ 1)));
    }
    out.println((n+1)+" "+(n+3));
    if(n!=m){
      int x=Integer.lowestOneBit(n)+1,y=n-x+1 ;
      out.println(n+" "+x);
      out.println((2*n)+" "+y);
    }
  }
  static int scanInt()throws IOException {
    return parseInt(scanString());
  }
  static long scanLong()throws IOException {
    return parseLong(scanString());
  }
  static String scanString()throws IOException {
    while(tok==null || ! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  public static void main(String[] args){
    try {
      in=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(System.out);
      solve();
      in.close();
      out.close();
    }
    catch(Throwable e){
      e.printStackTrace();
      exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanInt() ;
     if ((MathLib.bitwiseAnd(n,-n)) = n) then (     out.print("No") ; 
     return ) else skip ; 
    out.println("Yes") ; 
    var m : int ; m := n + (MathLib.bitwiseAnd(n,1)) - 1 ;
        var i : int ; i := 2 ; while i <= m do ( (     out.println("1 " + i) ; 
     out.println(i + " " + (n + (MathLib.bitwiseXor(i,1)))) )  ;     i := i + 1 ) ; 
    out.println((n + 1) + " " + (n + 3)) ; 
    if (n /= m) then (     var x : int ; x := lowestOneBit(n) + 1 ;
    var y : int ; y := n - x + 1 ;
     out.println(n + " " + x) ; 
     out.println((2 * n) + " " + y) ) else skip ; 
 );
  static   operation scanInt() : int
  pre: true
  post: true
  activity: (     return (scanString() + "")->toInteger() );
  static   operation scanLong() : long
  pre: true
  post: true
  activity: (     return parseLong(scanString()) );
  static   operation scanString() : String
  pre: true
  post: true
  activity: (     while (tok = null or not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return tok.next() );
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
     execute exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isNonHypotenuse(int n){
    while(n % 2==0){
      n=n/2 ;
    }
    for(int i=3 ; i<=Math.sqrt(n); i=i+2){
      if(n % i==0){
        if((i-1)% 4==0)return false ;
        while(n % i==0){
          n=n/i ;
        }
      }
    }
    if(n>2 &&(n-1)% 4==0)return false ;
    else return true ;
  }
  public static void test(int n){
    System.out.println("Testing for "+n+" : ");
    if(isNonHypotenuse(n))System.out.println("YES");
    else System.out.println("NO");
  }
  public static void main(String args[]){
    int n=11 ;
    test(n);
    n=10 ;
    test(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isNonHypotenuse( n : int) : boolean
  pre: true
  post: true
  activity: (     while (n mod 2 = 0) do (     n := n / 2 ) ; 
         var i : int ; i := 3 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     if ((i - 1) mod 4 = 0) then     return false else skip ; 
     while (n mod i = 0) do (     n := n / i ) ) else skip )  ;     i := i + 2 ) ; 
     if (n > 2 & (n - 1) mod 4 = 0) then     return false else     return true );
  static   operation test( n : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Testing for " + n + " : ") ; 
     if (isNonHypotenuse(n)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 11 ;
     execute test(n) ; 
     n := 10 ; 
     execute test(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static List<Integer>p=Prime(32768);
  public static int s=p.size();
  public static List<Integer>Prime(int n){
    List<Integer>primes=new ArrayList<Integer>();
    primes.add(2);
    for(int i=3 ; i<=n ; i++){
      int tmp=(int)(Math.sqrt(i))+1 ;
      for(int j=2 ; j<=tmp ; j++){
        if(i % j==0){
          break ;
        }
        if(j==tmp){
          primes.add(i);
        }
      }
    }
    return primes ;
  }
  public static int check(int n){
    int count=0 ;
    for(int i=0 ; i<s ; i++){
      for(int j=s-1 ; j>=i ; j--){
        if((p.get(i)+p.get(j))==n){
          count++;
        }
      }
    }
    return count ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num ;
    while(true){
      num=sc.nextInt();
      if(num!=0){
        System.out.println(check(num));
      }
      else {
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute p : Sequence(int) := Prime(32768);
  static   attribute s : int := p->size();
  static   operation Prime( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var primes : Sequence(int) ; primes := Sequence{} ;
     primes := primes->including(2) ; 
         var i : int ; i := 3 ; while i <= n do ( (     var tmp : int ; tmp := ((i)->sqrt())->oclAsType(int) + 1 ;
         var j : int ; j := 2 ; while j <= tmp do ( (     if (i mod j = 0) then (     break ) else skip ; 
     if (j = tmp) then (     primes := primes->including(i) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return primes );
  static   operation check( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < s do ( (         var j : int ; j := s - 1 ; while j >= i do ( (     if ((p->at(i+1) + p->at(j+1)) = n) then (     count := count + 1 ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ;
     while (true) do (     num := sc.getCurrent()->toInteger() ; 
     if (num /= 0) then (     OclFile["System.out"].println(check(num)) ) else (     break ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    Integer[] d=new Integer[n];
    for(int i=0 ; i<n ; i++){
      d[i]=Integer.parseInt(sc.next());
    }
    Arrays.sort(d,Collections.reverseOrder());
    int prev=d[0];
    int cnt=1 ;
    for(int i=1 ; i<n ; i++){
      if(prev!=d[i]){
        cnt++;
        prev=d[i];
      }
      else {
        continue ;
      }
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     d[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    d := OclComparator.sortWith(d, reverseOrder()) ; 
    var prev : int ; prev := d[0+1] ;
    var cnt : int ; cnt := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     if (prev /= d[i+1]) then (     cnt := cnt + 1 ; 
     prev := d[i+1] ) else (     continue ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static long[] buildValues(int d){
    long[] res=new long[d/2];
    long high=(long)Math.pow(10,d-1);
    long low=1L ;
    for(int i=0 ; i<d/2 ; i++){
      res[i]=high-low ;
      high/=10 ;
      low*=10 ;
    }
    return res ;
  }
  public static long calc(long[] vs,long D){
    long res=1 ;
    long ten=10 ;
    for(int i=0 ; i<vs.length ; i++){
      long now=0 ;
      while(D % ten!=0 && now<9){
        D-=vs[i];
        now++;
      }
      D=Math.abs(D);
      ten*=10 ;
      res*=(i==0)?(9-now):(10-now);
    }
    return D==0 ? res : 0 ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int D=in.nextInt();
    long res=0 ;
    for(int d=1 ; d<=20 ; d++){
      long[] vs=buildValues(d);
      long next=calc(vs,D);
      if(d % 2==1)next*=10 ;
      res+=next ;
    }
    System.out.println(res);
  }
  static int rev(int x){
    String s="0" ;
    while(x>0){
      s+=x % 10+"" ;
      x/=10 ;
    }
    return Integer.valueOf(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation buildValues( d : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var res : Sequence(long) ; res := Integer.subrange(1,d / 2)->collect(0) ;
     var high : long ; high := 10->pow(d - 1)->oclAsType(long) ;
    var low : long ; low := 1L ;
        var i : int ; i := 0 ; while i < d / 2 do ( (     res[i+1] := high - low ; 
     high := high/(10) ; 
     low := low*(10) )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation calc( vs : Sequence(long), D : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     var ten : long ; ten := 10 ;
         var i : int ; i := 0 ; while i < vs->size() do ( (     var now : long ; now := 0 ;
     while (D mod ten /= 0 & now < 9) do (     D := D-(vs[i+1]) ; 
     now := now + 1 ) ; 
    D := if D < 0 then -(D) else D endif ; 
    ten := ten*(10) ; 
    res := res*(if (i = 0) then (9 - now) else (10 - now) endif) ; 
 )  ;     i := i + 1 ) ; 
     return if D = 0 then res else 0 endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var D : int ; D := in.getCurrent()->toInteger() ;
    var res : long ; res := 0 ;
        var d : int ; d := 1 ; while d <= 20 do ( (     var vs : Sequence(long) ; vs := buildValues(d) ;
     var next : long ; next := calc(vs, D) ;
     if (d mod 2 = 1) then     next := next*(10) ; else skip ; 
     res := res+(next) )  ;     d := d + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static   operation rev( x : int) : int
  pre: true
  post: true
  activity: (     var s : String ; s := "0" ;
     while (x > 0) do (     s := s+(x mod 10 + "") ; 
     x := x/(10) ) ; 
     return (s)->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int a=stdIn.nextInt(),b=stdIn.nextInt();
    System.out.print((a+b+1)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := stdIn.getCurrent()->toInteger() ;
    var b : int ; b := stdIn.getCurrent()->toInteger() ;
     OclFile["System.out"].print((a + b + 1) / 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    double x=((double)a+(double)b)/2 ;
    int ans=(int)Math.ceil(x);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := (sc.getCurrent())->toInteger() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    var x : double ; x := (a->oclAsType(double) + b->oclAsType(double)) / 2 ;
    var ans : int ; ans := (x)->ceil()->oclAsType(int) ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    int i,j ;
    Scanner sc=new Scanner(in);
    int a=parseInt(sc.next());
    int b=parseInt(sc.next());
    sc.close();
    out.println((int)ceil((double)(a+b)/2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
    var a : int ; a := parseInt(sc.getCurrent()) ;
    var b : int ; b := parseInt(sc.getCurrent()) ;
    skip ; 
    out.println(ceil((a + b)->oclAsType(double) / 2)->oclAsType(int)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double a,b ;
    a=Double.parseDouble(sc.next());
    b=Double.parseDouble(sc.next());
    int ans=(int)Math.ceil((a+b)/2);
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : double ;
    var b : double ;
    a := (sc.getCurrent())->toReal() ; 
    b := (sc.getCurrent())->toReal() ; 
    var ans : int ; ans := ((a + b) / 2)->ceil()->oclAsType(int) ;
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    start();
  }
  public static void start(){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt(),b=sc.nextInt();
    System.out.println((int)Math.ceil((a+b)/2.0));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute start() );
  static   operation start() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(((a + b) / 2.0)->ceil()->oclAsType(int)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeHundredSixtyTwo {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] arrayOne=new int[n];
    int egg=0 ;
    for(int i=0 ; i<n ; i++){
      arrayOne[i]=input.nextInt();
      egg+=arrayOne[i];
    }
    Arrays.sort(arrayOne);
    int k=arrayOne[n-1];
    System.out.println(Typo(k,egg,n,arrayOne));
  }
  public static Integer Typo(int k,int egg,int n,int[] arrayOne){
    int sum1=0 ;
    for(int i=0 ; i<n ; i++){
      sum1+=k-arrayOne[i];
    }
    if(sum1>egg){
      return k ;
    }
    else {
      return Typo(k+1,egg,n,arrayOne);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixtyTwo {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var arrayOne : Sequence(int) ; arrayOne := Integer.subrange(1,n)->collect(0) ;
    var egg : int ; egg := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arrayOne[i+1] := input.getCurrent()->toInteger() ; 
     egg := egg+(arrayOne[i+1]) )  ;     i := i + 1 ) ; 
    arrayOne := arrayOne->sort() ; 
    var k : int ; k := arrayOne[n - 1+1] ;
    OclFile["System.out"].println(Typo(k, egg, n, arrayOne)) ; 
 );
  static   operation Typo( k : int, egg : int, n : int, arrayOne : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var sum1 : int ; sum1 := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum1 := sum1+(k - arrayOne[i+1]) )  ;     i := i + 1 ) ; 
     if (sum1 > egg) then (     return k ) else (     return Typo(k + 1, egg, n, arrayOne) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static Scanner input=new Scanner(System.in);
  public static void main(String[] args){
    int n=input.nextInt();
    int a[]=new int[n];
    array(a);
    Arrays.sort(a);
    int sum=arraySum(a);
    int test ;
    if(sum % n==0)test=sum/n ;
    else test=(sum+n-1)/n ;
    int result=test+a[0];
    if(result>a[a.length-1]){
      while(true){
        int sum1=0 ;
        for(int i=0 ; i<a.length ; i++){
          sum1=sum1+(result-a[i]);
        }
        if(sum1>=sum)break ;
        else result++;
      }
    }
    else {
      result=a[a.length-1];
      while(true){
        int sum1=0 ;
        for(int i=0 ; i<a.length ; i++){
          sum1=sum1+(result-a[i]);
        }
        if(sum1>=sum)break ;
        else result++;
      }
    }
    System.out.println(result);
  }
  public static void array(int a[]){
    for(int i=0 ; i<a.length ; i++){
      a[i]=input.nextInt();
    }
  }
  public static int arraySum(int a[]){
    int sum=0 ;
    for(int i=0 ; i<a.length ; i++){
      sum=sum+a[i];
    }
    return sum+1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute input : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := input.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    execute array(a) ; 
    a := a->sort() ; 
    var sum : int ; sum := arraySum(a) ;
    var test : int ;
    if (sum mod n = 0) then     test := sum / n else     test := (sum + n - 1) / n ; ;  
    var result : int ; result := test + a[0+1] ;
    if (result > a[a->size() - 1+1]) then (     while (true) do (     var sum1 : int ; sum1 := 0 ;
         var i : int ; i := 0 ; while i < a->size() do ( (     sum1 := sum1 + (result - a[i+1]) )  ;     i := i + 1 ) ; 
     if (sum1 >= sum) then     break else     result := result + 1 ; ) ) else (     result := a[a->size() - 1+1] ; 
     while (true) do (     var sum1 : int ; sum1 := 0 ;
         var i : int ; i := 0 ; while i < a->size() do ( (     sum1 := sum1 + (result - a[i+1]) )  ;     i := i + 1 ) ; 
     if (sum1 >= sum) then     break else     result := result + 1 ; ) ) ;  
    OclFile["System.out"].println(result) ; 
 );
  static   operation array( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) );
  static   operation arraySum( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < a->size() do ( (     sum := sum + a[i+1] )  ;     i := i + 1 ) ; 
     return sum + 1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  static final int MAX_N=100100 ;
  static final int mod=1000000007 ;
  static final int INF=0x3f3f3f3f ;
  public static void main(String[] args)throws Exception {
    initReader(System.in);
    solve();
    printWriter.flush();
  }
  public static void solve()throws IOException {
    int a=nextInt()/1 ;
    int b=nextInt()/2 ;
    int c=nextInt()/4 ;
    printWriter.println(7*Math.min(a,Math.min(b,c)));
  }
  static BufferedReader reader ;
  static StringTokenizer tokenizer ;
  static PrintWriter printWriter ;
  static void initReader(InputStream input){
    reader=new BufferedReader(new InputStreamReader(input));
    tokenizer=new StringTokenizer("");
    printWriter=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  }
  static boolean hasNext(){
    try {
      while(! tokenizer.hasMoreTokens()){
        tokenizer=new StringTokenizer(reader.readLine());
      }
    }
    catch(Exception e){
      return false ;
    }
    return true ;
  }
  static String next()throws IOException {
    while(! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  static String nextLine(){
    try {
      return reader.readLine();
    }
    catch(Exception e){
      return null ;
    }
  }
  static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  static long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  static char nextChar()throws IOException {
    return next().charAt(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX_N : int := 100100;
  static    attribute mod : int := 1000000007;
  static    attribute INF : int := 0x3f3f3f3f;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute initReader(OclFile["System.in"]) ; 
     execute solve() ; 
     printWriter.flush() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ; a := nextInt() / 1 ;
     var b : int ; b := nextInt() / 2 ;
     var c : int ; c := nextInt() / 4 ;
     printWriter.println(7 * Set{a, Set{b, c}->min()}->min()) );
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   attribute printWriter : OclFile;
  static   operation initReader( input : OclFile) : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(input)) ; 
     tokenizer := OclIterator.newOclIterator_String("") ; 
     printWriter := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) );
  static   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     try (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (e : ProgramException) do (     return false )
     return true );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : ProgramException) do (     return null )
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  static final int MAX_N=100100 ;
  static final int mod=1000000007 ;
  static final int INF=0x3f3f3f3f ;
  public static void main(String[] args)throws Exception {
    initReader(System.in);
    solve();
    printWriter.flush();
  }
  public static void solve()throws IOException {
    int a=nextInt();
    int b=nextInt();
    int c=nextInt();
    a/=1 ;
    b/=2 ;
    c/=4 ;
    printWriter.println(Math.min(a,Math.min(b,c))*7);
  }
  static BufferedReader reader ;
  static StringTokenizer tokenizer ;
  static PrintWriter printWriter ;
  static void initReader(InputStream input){
    reader=new BufferedReader(new InputStreamReader(input));
    tokenizer=new StringTokenizer("");
    printWriter=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  }
  static boolean hasNext(){
    try {
      while(! tokenizer.hasMoreTokens()){
        tokenizer=new StringTokenizer(reader.readLine());
      }
    }
    catch(Exception e){
      return false ;
    }
    return true ;
  }
  static String next()throws IOException {
    while(! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  static String nextLine(){
    try {
      return reader.readLine();
    }
    catch(Exception e){
      return null ;
    }
  }
  static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  static long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  static char nextChar()throws IOException {
    return next().charAt(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX_N : int := 100100;
  static    attribute mod : int := 1000000007;
  static    attribute INF : int := 0x3f3f3f3f;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute initReader(OclFile["System.in"]) ; 
     execute solve() ; 
     printWriter.flush() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ; a := nextInt() ;
     var b : int ; b := nextInt() ;
    var c : int ; c := nextInt() ;
    a := a/(1) ; 
    b := b/(2) ; 
    c := c/(4) ; 
    printWriter.println(Set{a, Set{b, c}->min()}->min() * 7) ; 
 );
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   attribute printWriter : OclFile;
  static   operation initReader( input : OclFile) : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(input)) ; 
     tokenizer := OclIterator.newOclIterator_String("") ; 
     printWriter := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) );
  static   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     try (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (e : ProgramException) do (     return false )
     return true );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : ProgramException) do (     return null )
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _746A_Compote {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int lemon=input.nextInt();
    int apple=input.nextInt()/2 ;
    int pears=input.nextInt()/4 ;
    int result=Math.min(Math.min(lemon,apple),pears);
    result*=7 ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _746A_Compote {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var lemon : int ; lemon := input.getCurrent()->toInteger() ;
    var apple : int ; apple := input.getCurrent()->toInteger() / 2 ;
    var pears : int ; pears := input.getCurrent()->toInteger() / 4 ;
    var result : int ; result := Set{Set{lemon, apple}->min(), pears}->min() ;
    result := result*(7) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static double aver(int[] arr){
    int sum=0 ;
    for(int i=0 ; i<arr.length ; i++){
      sum=sum+arr[i];
    }
    return sum/arr.length ;
  }
  public static int fac(int x){
    int sum=1 ;
    while(x>0){
      sum=sum*x ;
      x=x-1 ;
    }
    return sum ;
  }
  public static int comb(int x,int y){
    int sum=0 ;
    sum=fac(x);
    int temp=(fac(y)*fac(x-y));
    return sum/temp ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n>0){
      sc.nextInt();
      sc.nextLine();
      String[] f=sc.nextLine().split("");
      String[] s=sc.nextLine().split("");
      boolean flag=true ;
      for(int i=0 ; i<f.length ; i++){
        if(f[i] .equals("R")){
          if(s[i] .equals("B")|| s[i] .equals("G"))flag=false ;
        }
        if(s[i] .equals("R")){
          if(f[i] .equals("B")|| f[i] .equals("G"))flag=false ;
        }
      }
      if(flag)System.out.println("YES");
      else System.out.println("NO");
      n=n-1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation aver( arr : Sequence(int)) : double
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     sum := sum + arr[i+1] )  ;     i := i + 1 ) ; 
     return sum / arr->size() );
  static   operation fac( x : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 1 ;
     while (x > 0) do (     sum := sum * x ; 
     x := x - 1 ) ; 
     return sum );
  static   operation comb( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     sum := fac(x) ; 
     var temp : int ; temp := (fac(y) * fac(x - y)) ;
     return sum / temp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     while (n > 0) do (     skip ; 
     skip ; 
    var f : Sequence(String) ; f := sc.nextLine()->split("") ;
    var s : Sequence(String) ; s := sc.nextLine()->split("") ;
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < f->size() do ( (     if (f[i+1] = "R") then (     if (s[i+1] = "B" or s[i+1] = "G") then     flag := false ; else skip ) else skip ; 
     if (s[i+1] = "R") then (     if (f[i+1] = "B" or f[i+1] = "G") then     flag := false ; else skip ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
    n := n - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int total ;
    int sen=-1,gosen=-1,man=-1 ;
    boolean judge=false ;
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int Y=sc.nextInt();
    for(int i=0 ; i<=N ; i++){
      for(int j=0 ; i+j<=N ; j++){
        total=i*1000+j*5000+(N-i-j)*10000 ;
        if(total==Y){
          judge=true ;
          sen=i ;
          gosen=j ;
          man=N-i-j ;
        }
        if(judge)break ;
      }
      if(judge)break ;
    }
    System.out.println(man+" "+gosen+" "+sen);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var total : int ;
     var sen : int ; sen := -1 ;
    var gosen : int ; gosen := -1 ;
    var man : int ; man := -1 ;
    var judge : boolean ; judge := false ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var Y : int ; Y := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i <= N do ( (         var j : int ; j := 0 ; while i + j <= N do ( (     total := i * 1000 + j * 5000 + (N - i - j) * 10000 ; 
     if (total = Y) then (     judge := true ; 
     sen := i ; 
     gosen := j ; 
     man := N - i - j ) else skip ; 
     if (judge) then     break else skip )  ;     j := j + 1 ) ; 
     if (judge) then     break else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(man + " " + gosen + " " + sen) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    Stack<String>stack=new Stack<>();
    for(int i=0 ; i<n ; i++){
      String s=in.next();
      stack.push(s);
    }
    HashSet<String>set=new HashSet<>();
    while(! stack.isEmpty()){
      String ans=stack.pop();
      if(set.contains(ans))continue ;
      else {
        pw.println(ans);
      }
      set.add(ans);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var stack : Sequence(String) ; stack := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := in.getCurrent() ;
     stack := stack->append(s) )  ;     i := i + 1 ) ; 
    var set : Set(String) ; set := Set{} ;
    while (not(stack->isEmpty())) do (     var ans : String ; ans := stack->last() ;
     if (set->includes(ans)) then     continue else (     skip ) ;  
     set := set->including(ans) ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ChatOrder {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    Stack<String>stack=new Stack<>();
    for(int i=0 ; i<n ; i++){
      String s=in.next();
      stack.push(s);
    }
    HashSet<String>set=new HashSet<>();
    while(! stack.isEmpty()){
      String ans=stack.pop();
      if(set.contains(ans))continue ;
      pw.println(ans);
      set.add(ans);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class ChatOrder {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var stack : Sequence(String) ; stack := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := in.getCurrent() ;
     stack := stack->append(s) )  ;     i := i + 1 ) ; 
    var set : Set(String) ; set := Set{} ;
    while (not(stack->isEmpty())) do (     var ans : String ; ans := stack->last() ;
     if (set->includes(ans)) then     continue else skip ; 
     skip ; 
     set := set->including(ans) ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class SolutionD {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String[] a=new String[n];
    for(int i=0 ; i<n ; ++i){
      a[i]=in.next();
    }
    Set<String>set=new HashSet<>();
    for(int i=n-1 ; i>=0 ; --i){
      if(set.add(a[i])){
        System.out.println(a[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SolutionD {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(String) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent() )  ;     i := i + 1 ) ; 
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (set->excludes(a[i+1])) then (     OclFile["System.out"].println(a[i+1]) ) else skip )  ;     i := i - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.System.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    int n=sc.nextInt();
    String[] arr=new String[n];
    Map<String,Integer>map_arr=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.next();
    }
    for(int j=0 ; j<n ; j++){
      map_arr.put(arr[j],j);
    }
    LinkedHashMap<String,Integer>reverseSortedMap=new LinkedHashMap<>();
    map_arr.entrySet().stream().sorted(Map.Entry.comparingByValue(Comparator.reverseOrder())).forEachOrdered(x->reverseSortedMap.put(x.getKey(),x.getValue()));
    for(Map.Entry<String,Integer>entry : reverseSortedMap.entrySet()){
      out.println(entry.getKey());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := Integer.subrange(1,n)->collect(null) ;
    var map_arr : Map(String,int) ; map_arr := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     map_arr := map_arr->union(Map{arr[j+1] |-> j}) )  ;     j := j + 1 ) ; 
    var reverseSortedMap : Map(String,int) ; reverseSortedMap := Map{} ;
    map_arr->asSet()->sort().forEachOrdered(lambda x : OclAny in reverseSortedMap->at(x.getKey())) ; 
    for (entry : reverseSortedMap->asSet()) do ( (     out.println(entry.getKey()) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int a=in.nextInt();
      int b=in.nextInt();
      int c=in.nextInt();
      int res=0 ;
      while(a % 2==0 && b % 2==0 && c % 2==0){
        int a1=(b+c)/2 ;
        int b1=(a+c)/2 ;
        int c1=(a+b)/2 ;
        a=a1 ;
        b=b1 ;
        c=c1 ;
++res ;
        if(res>1000){
          out.println(-1);
          return ;
        }
      }
      out.println(res);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.nextInt() ;
     var b : int ; b := in.nextInt() ;
    var c : int ; c := in.nextInt() ;
    var res : int ; res := 0 ;
    while (a mod 2 = 0 & b mod 2 = 0 & c mod 2 = 0) do (     var a1 : int ; a1 := (b + c) / 2 ;
     var b1 : int ; b1 := (a + c) / 2 ;
    var c1 : int ; c1 := (a + b) / 2 ;
    a := a1 ; 
    b := b1 ; 
    c := c1 ; 
    res := res + 1 ; 
    if (res > 1000) then (     skip ; 
     return ) else skip ; 
 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    try(Scanner in=new Scanner(System.in)){
      int A=in.nextInt();
      int B=in.nextInt();
      int C=in.nextInt();
      HashSet<State>used=new HashSet<>();
      used.add(new State(A,B,C));
      int count=0 ;
      for(; ; count++){
        if(A % 2==1 || B % 2==1 || C % 2==1){
          System.out.println(count);
          break ;
        }
        int nextA=B/2+C/2 ;
        int nextB=A/2+C/2 ;
        int nextC=A/2+B/2 ;
        A=nextA ;
        B=nextB ;
        C=nextC ;
        boolean add=used.add(new State(A,B,C));
        if(add==false){
          System.out.println(-1);
          break ;
        }
      }
    }
  }
}
class State {
  int a ;
  int b ;
  int c ;
  public State(int a,int b,int c){
    super();
    this.a=a ;
    this.b=b ;
    this.c=c ;
  }
  @ Override public int hashCode(){
    final int prime=31 ;
    int result=1 ;
    result=prime*result+a ;
    result=prime*result+b ;
    result=prime*result+c ;
    return result ;
  }
  @ Override public boolean equals(Object obj){
    if(this==obj)return true ;
    if(obj==null)return false ;
    if(getClass()!=obj.getClass())return false ;
    State other=(State)obj ;
    if(a!=other.a)return false ;
    if(b!=other.b)return false ;
    if(c!=other.c)return false ;
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var A : int ; A := in.getCurrent()->toInteger() ;
     var B : int ; B := in.getCurrent()->toInteger() ;
    var C : int ; C := in.getCurrent()->toInteger() ;
    var used : Set(State) ; used := Set{} ;
    used := used->including(State.newState(A, B, C)) ; 
    var count : int ; count := 0 ;
      while true do ( (     if (A mod 2 = 1 or B mod 2 = 1 or C mod 2 = 1) then (     OclFile["System.out"].println(count) ; 
     break ) else skip ; 
     var nextA : int ; nextA := B / 2 + C / 2 ;
    var nextB : int ; nextB := A / 2 + C / 2 ;
    var nextC : int ; nextC := A / 2 + B / 2 ;
    A := nextA ; 
    B := nextB ; 
    C := nextC ; 
    var add : boolean ; add := used->excludes(State.newState(A, B, C)) ;
    if (add = false) then (     OclFile["System.out"].println(-1) ; 
     break ) else skip ; 
 )  ;     count := count + 1 ) ; 
 ))  );
}
class State {
   attribute a : int;
   attribute b : int;
   attribute c : int;
   static operation newState( a : int, b : int, c : int) : State
  pre: true
  post: true
  activity:
  ( var self : State ;
    self := createState();
    self.initialise(a, b,c);
    return self );
  operation initialise( a : int, b : int, c : int) : void
  pre: true  post: true
  activity: (     execute super() ; 
     self.a := a ; 
     self.b := b ; 
     self.c := c );
      operation hashCode() : int
  pre: true
  post: true
  activity: (     var prime : int ; prime := 31 ;
     var result : int ; result := 1 ;
    result := prime * result + a ; 
    result := prime * result + b ; 
    result := prime * result + c ; 
    return result 
 );
      operation equals( obj : OclAny) : boolean
  pre: true
  post: true
  activity: (     if (self = obj) then     return true else skip ; 
     if (obj = null) then     return false else skip ; 
    if (getClass() /= obj->oclType()) then     return false else skip ; 
    var other : State ; other := obj->oclAsType(State) ;
    if (a /= other.a) then     return false else skip ; 
    if (b /= other.b) then     return false else skip ; 
    if (c /= other.c) then     return false else skip ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.List ;
import java.util.ArrayList ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] ss0=br.readLine().trim().split(" ",0);
    long a=Long.parseLong(ss0[0]);
    long b=Long.parseLong(ss0[1]);
    long c=Long.parseLong(ss0[2]);
    if(isEnd(a,b,c)){
      System.out.println(0);
      return ;
    }
    if((a==b)&&(b==c)){
      System.out.println(-1);
      return ;
    }
    long x ;
    long y ;
    long z ;
    long count=0L ;
    do {
      x=(b+c)/2 ;
      y=(c+a)/2 ;
      z=(a+b)/2 ;
      count+=1 ;
      a=x ;
      b=y ;
      c=z ;
    }
    while(isEnd(x,y,z)==false);
    System.out.println(count);
    return ;
  }
  static void dp(String s){
    System.out.println(s);
  }
  static void dp(StringBuilder s){
    dp(s.toString());
  }
  static void dp(int i){
    dp(String.valueOf(i));
  }
  static void dp(long i){
    dp(String.valueOf(i));
  }
  static boolean isEnd(long a,long b,long c){
    if(a % 2==1){
      return true ;
    }
    if(b % 2==1){
      return true ;
    }
    if(c % 2==1){
      return true ;
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var ss0 : Sequence(String) ; ss0 := br.readLine()->trim()->split(" ") ;
    var a : long ; a := (ss0[0+1])->toLong() ;
    var b : long ; b := (ss0[1+1])->toLong() ;
    var c : long ; c := (ss0[2+1])->toLong() ;
    if (isEnd(a, b, c)) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    if ((a = b) & (b = c)) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var x : long ;
    var y : long ;
    var z : long ;
    var count : long ; count := 0L ;
  while true do ((     x := (b + c) / 2 ; 
     y := (c + a) / 2 ; 
    z := (a + b) / 2 ; 
    count := count+(1) ; 
    a := x ; 
    b := y ; 
    c := z ; 
 ) ;
    if (isEnd(x, y, z) = false) then skip else break) ; 
    OclFile["System.out"].println(count) ; 
    return 
 );
  static   operation dp( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation dp( s : String) : void
  pre: true
  post: true
  activity: (     execute dp(s+"") );
  static   operation dp( i : int) : void
  pre: true
  post: true
  activity: (     execute dp(((i) + "")) );
  static   operation dp( i : long) : void
  pre: true
  post: true
  activity: (     execute dp(((i) + "")) );
  static   operation isEnd( a : long, b : long, c : long) : boolean
  pre: true
  post: true
  activity: (     if (a mod 2 = 1) then (     return true ) else skip ; 
     if (b mod 2 = 1) then (     return true ) else skip ; 
     if (c mod 2 = 1) then (     return true ) else skip ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=false ;
  private static PrintWriter _out=new PrintWriter(System.out);
  private static PrintWriter _err=new PrintWriter(System.err);
  private void solve(Scanner sc){
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    if(A % 2==1 || B % 2==1 || C % 2==1){
      _out.println(0);
      return ;
    }
    if(A==B && B==C){
      _out.println(-1);
      return ;
    }
    long cnt=0 ;
    while(A % 2==0 && B % 2==0 && C % 2==0){
      int ta=B/2+C/2 ;
      int tb=A/2+C/2 ;
      int tc=A/2+B/2 ;
      A=ta ;
      B=tb ;
      C=tc ;
++cnt ;
    }
    _out.println(cnt);
  }
  private static BigInteger C(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    for(long i=r ; i>1 ; --i){
      res=res.divide(BigInteger.valueOf(i));
    }
    return res ;
  }
  private static BigInteger P(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    return res ;
  }
  public static void main(String[] args){
    long S=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    new Main().solve(sc);
    _out.flush();
    long G=System.currentTimeMillis();
    if(elapsed){
      _err.println((G-S)+"ms");
    }
    _err.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := false;
  static   attribute _out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute _err : OclFile := OclFile.newOclFile_Write(OclFile["System.err"]);
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var A : int ; A := sc.nextInt() ;
     var B : int ; B := sc.nextInt() ;
    var C : int ; C := sc.nextInt() ;
    if (A mod 2 = 1 or B mod 2 = 1 or C mod 2 = 1) then (     skip ; 
     return ) else skip ; 
    if (A = B & B = C) then (     skip ; 
     return ) else skip ; 
    var cnt : long ; cnt := 0 ;
    while (A mod 2 = 0 & B mod 2 = 0 & C mod 2 = 0) do (     var ta : int ; ta := B / 2 + C / 2 ;
     var tb : int ; tb := A / 2 + C / 2 ;
    var tc : int ; tc := A / 2 + B / 2 ;
    A := ta ; 
    B := tb ; 
    C := tc ; 
    cnt := cnt + 1 ; 
 ) ; 
    skip ; 
 );
  static   operation C( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
         var i : long ; i := r ; while i > 1 do ( (     res := res.divide((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation P( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    Main.newMain().solve(sc) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String[] str=in.readLine().split(" ");
    int a=Integer.parseInt(str[0]);
    int b=Integer.parseInt(str[1]);
    int c=Integer.parseInt(str[2]);
    int count=0 ;
    boolean flg=false ;
    for(int i=0 ; i<100000 ; i++){
      if(a % 2==0 && b % 2==0 && c % 2==0){
        int a_tmp=a ;
        int b_tmp=b ;
        int c_tmp=c ;
        a_tmp=b/2+c/2 ;
        b_tmp=a/2+c/2 ;
        c_tmp=a/2+b/2 ;
        a=a_tmp ;
        b=b_tmp ;
        c=c_tmp ;
        count+=1 ;
      }
      else {
        flg=true ;
        break ;
      }
    }
    System.out.println(flg==false ?-1 : count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := in.readLine()->split(" ") ;
    var a : int ; a := (str[0+1])->toInteger() ;
    var b : int ; b := (str[1+1])->toInteger() ;
    var c : int ; c := (str[2+1])->toInteger() ;
    var count : int ; count := 0 ;
    var flg : boolean ; flg := false ;
        var i : int ; i := 0 ; while i < 100000 do ( (     if (a mod 2 = 0 & b mod 2 = 0 & c mod 2 = 0) then (     var a_tmp : int ; a_tmp := a ;
     var b_tmp : int ; b_tmp := b ;
    var c_tmp : int ; c_tmp := c ;
    a_tmp := b / 2 + c / 2 ; 
    b_tmp := a / 2 + c / 2 ; 
    c_tmp := a / 2 + b / 2 ; 
    a := a_tmp ; 
    b := b_tmp ; 
    c := c_tmp ; 
    count := count+(1) ; 
 ) else (     flg := true ; 
     break ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if flg = false then -1 else count endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int D=sc.nextInt();
    System.out.println(solve(D));
    sc.close();
  }
  static final int MAXL=17 ;
  static int N ;
  static long[] v ;
  static long solve(int D){
    if(D % 9!=0)return 0 ;
    D/=9 ;
    long[] B=new long[MAXL];
    B[0]=1 ;
    for(int i=1 ; i<MAXL ; i++)B[i]=B[i-1]*10 ;
    long ans=0 ;
    for(int i=1 ; i<=MAXL ; i++){
      N=(i+1)/2 ;
      v=new long[N];
      for(int j=0 ; j<N ; j++)for(int k=j ; k<i-j ; k++)v[j]+=B[k];
      ans+=count(D,i,0,new int[N]);
    }
    return ans ;
  }
  static long count(long D,int l,int t,int[] x){
    if(t==N){
      if(D!=0)return 0 ;
      long ans=1 ;
      for(int i=0 ; i<N ; i++){
        ans*=(i==0 ? 9 : 10)-Math.abs(x[i]);
      }
      if(l % 2==0)ans*=10 ;
      return ans ;
    }
    long ans=0 ;
    for(int m=-9 ; m<=9 ; m++){
      if(-v[t]<D+v[t]*m && D+v[t]*m<v[t]){
        x[t]=m ;
        ans+=count(D+v[t]*m,l,t+1,x);
      }
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var D : int ; D := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(D)) ; 
     skip );
  static    attribute MAXL : int := 17;
  static   attribute N : int;
  static   attribute v : Sequence(long);
  static   operation solve( D : int) : long
  pre: true
  post: true
  activity: (     if (D mod 9 /= 0) then     return 0 else skip ; 
     D := D/(9) ; 
    var B : Sequence(long) ; B := Integer.subrange(1,MAXL)->collect(0) ;
    B[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < MAXL do (     B[i+1] := B[i - 1+1] * 10 ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= MAXL do ( (     N := (i + 1) / 2 ; 
     v := Integer.subrange(1,N)->collect(0) ; 
         var j : int ; j := 0 ; while j < N do (         var k : int ; k := j ; while k < i - j do (     v[j+1] := v[j+1]+(B[k+1]) ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ; 
     ans := ans+(count(D, i, 0, Integer.subrange(1,N)->collect(0))) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation count( D : long, l : int, t : int, x : Sequence(int)) : long
  pre: true
  post: true
  activity: (     if (t = N) then (     if (D /= 0) then     return 0 else skip ; 
     var ans : long ; ans := 1 ;
        var i : int ; i := 0 ; while i < N do ( (     ans := ans*((if i = 0 then 9 else 10 endif) - if x[i+1] < 0 then -(x[i+1]) else x[i+1] endif) )  ;     i := i + 1 ) ; 
    if (l mod 2 = 0) then     ans := ans*(10) ; else skip ; 
    return ans 
 ) else skip ; 
     var ans : long ; ans := 0 ;
         var m : int ; m := -9 ; while m <= 9 do ( (     if (-v[t+1] < D + v[t+1] * m & D + v[t+1] * m < v[t+1]) then (     x[t+1] := m ; 
     ans := ans+(count(D + v[t+1] * m, l, t + 1, x)) ) else skip )  ;     m := m + 1 ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class SortExample {
  static void printOrder(Integer[] arr,int k){
    int n=arr.length ;
    Arrays.sort(arr,0,k);
    Arrays.sort(arr,k,n,Collections.reverseOrder());
  }
  public static void main(String[] args){
    Integer[] arr={
      5,4,6,2,1,3,8,9,-1 };
      int k=4 ;
      printOrder(arr,k);
      System.out.printf("%s",Arrays.toString(arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class SortExample {
  static   operation printOrder( arr : Sequence(int), k : int) : void
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
     arr := arr.subrange(1,0)^(arr.subrange(0+1,k)->sort())^arr.subrange(k+1,arr.size) ; 
     arr, k, n, reverseOrder() := arr, k, n, reverseOrder()->sort() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,4,6,2,1,3,8,9,-1} ;
     var k : int ; k := 4 ;
     execute printOrder(arr, k) ; 
     OclFile["System.out"].printf("%s", (arr + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_Vanya_and_Cubes {
  public static void main(String[] args){
    Scanner sn=new Scanner(System.in);
    int n=sn.nextInt();
    int i=0 ;
    int sum=0 ;
    while(sum<=n){
      for(int j=1 ; j<=i ; j++){
        sum+=j ;
        if(sum>n)break ;
      }
      i++;
    }
    System.out.println(i-2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Vanya_and_Cubes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sn : OclFile ; sn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sn.getCurrent()->toInteger() ;
    var i : int ; i := 0 ;
    var sum : int ; sum := 0 ;
    while (sum <= n) do (         var j : int ; j := 1 ; while j <= i do ( (     sum := sum+(j) ; 
     if (sum > n) then     break else skip )  ;     j := j + 1 ) ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println(i - 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] tmp=br.readLine().split(" ");
    int N=Integer.parseInt(tmp[0]);
    int Y=Integer.parseInt(tmp[1]);
    int x=-1 ;
    int y=-1 ;
    int z=-1 ;
    if(Y>=100000){
      for(int i=0 ; i<=N ; i++){
        for(int j=0 ; j<=N-i ; j++){
          if(Y==10000*i+5000*j+1000*(N-i-j)){
            x=i ;
            y=j ;
            z=N-i-j ;
          }
        }
      }
    }
    else {
      for(int i=0 ; i<=N ; i++){
        for(int j=0 ; j<=N-i ; j++){
          if(Y==1000*i+5000*j+10000*(N-i-j)){
            z=i ;
            y=j ;
            x=N-i-j ;
          }
        }
      }
    }
    System.out.println(x+" "+y+" "+z);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmp : Sequence(String) ; tmp := br.readLine()->split(" ") ;
    var N : int ; N := (tmp[0+1])->toInteger() ;
    var Y : int ; Y := (tmp[1+1])->toInteger() ;
    var x : int ; x := -1 ;
    var y : int ; y := -1 ;
    var z : int ; z := -1 ;
    if (Y >= 100000) then (         var i : int ; i := 0 ; while i <= N do ( (         var j : int ; j := 0 ; while j <= N - i do ( (     if (Y = 10000 * i + 5000 * j + 1000 * (N - i - j)) then (     x := i ; 
     y := j ; 
     z := N - i - j ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i <= N do ( (         var j : int ; j := 0 ; while j <= N - i do ( (     if (Y = 1000 * i + 5000 * j + 10000 * (N - i - j)) then (     z := i ; 
     y := j ; 
     x := N - i - j ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(x + " " + y + " " + z) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void main(String[] args){
    int i,j,r,N,N1 ;
    N1=3 ;
    N=0 ;
    r=5 ;
    for(i=0 ; i<r ; i++){
      if(i<=r/2){
        N=N1 ;
        for(j=0 ; j<=i ; j++){
          N++;
        }
        N1=N ;
        for(j=0 ; j<=i ; j++){
          N--;
          System.out.print(N+" ");
        }
        System.out.println();
      }
      else {
        for(j=i ; j<r ; j++){
          N--;
          System.out.print(N+" ");
        }
        System.out.println();
      }
    }
  }
};
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var r : int ;
    var N : int ;
    var N1 : int ;
     N1 := 3 ; 
    N := 0 ; 
    r := 5 ; 
        i := 0 ; while i < r do ( (     if (i <= r / 2) then (     N := N1 ; 
         j := 0 ; while j <= i do ( (     N := N + 1 )  ;     j := j + 1 ) ; 
    N1 := N ; 
        j := 0 ; while j <= i do ( (     N := N - 1 ; 
     OclFile["System.out"].print(N + " ") )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) else (         j := i ; while j < r do ( (     N := N - 1 ; 
     OclFile["System.out"].print(N + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() ) )  ;     i := i + 1 ) ; 
 );
}
 ;

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int N=4 ;
  static boolean isScalarMatrix(int mat[][]){
    for(int i=0 ; i<N ; i++)for(int j=0 ; j<N ; j++)if((i!=j)&&(mat[i][j]!=0))return false ;
    for(int i=0 ; i<N-1 ; i++)if(mat[i][i]!=mat[i+1][i+1])return false ;
    return true ;
  }
  public static void main(String args[]){
    int mat[][]={
      {
        2,0,0,0 },{
          0,2,0,0 },{
            0,0,2,0 },{
              0,0,0,2 }
            };
            if(isScalarMatrix(mat))System.out.println("Yes");
            else System.out.println("No");
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 4;
  static   operation isScalarMatrix( mat : Sequence(Sequence(int))) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do (         var j : int ; j := 0 ; while j < N do (     if ((i /= j) & (mat[i+1][j+1] /= 0)) then     return false else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < N - 1 do (     if (mat[i+1][i+1] /= mat[i + 1+1][i + 1+1]) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{2,0,0,0},Sequence{0,2,0,0},Sequence{0,0,2,0},Sequence{0,0,0,2}} ;
     if (isScalarMatrix(mat)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int N=2 ;
  static int M=3 ;
  static boolean check(int mat[][]){
    int xorr=0 ;
    for(int i=0 ; i<N ; i++){
      xorr ^=mat[i][0];
    }
    if(xorr!=0)return true ;
    for(int i=0 ; i<N ; i++){
      for(int j=1 ; j<M ; j++){
        if(mat[i][j]!=mat[i][0])return true ;
      }
    }
    return false ;
  }
  public static void main(String[] args){
    int mat[][]={
      {
        7,7,7 },{
          10,10,7 }
        };
        if(check(mat))System.out.println("Yes");
        else System.out.println("No");
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 2;
  static   attribute M : int := 3;
  static   operation check( mat : Sequence(Sequence(int))) : boolean
  pre: true
  post: true
  activity: (     var xorr : int ; xorr := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     xorr := MathLib.bitwiseXor(xorr,mat[i+1][0+1]) )  ;     i := i + 1 ) ; 
    if (xorr /= 0) then     return true else skip ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 1 ; while j < M do ( (     if (mat[i+1][j+1] /= mat[i+1][0+1]) then     return true else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{7,7,7},Sequence{10,10,7}} ;
     if (check(mat)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minItems(int k,int r){
    for(int i=1 ; i<10 ; i++)if((i*k-r)% 10==0 ||(i*k)% 10==0)return i ;
    return 10 ;
  }
  public static void main(String args[]){
    int k=15 ;
    int r=2 ;
    System.out.println(minItems(k,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minItems( k : int, r : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < 10 do (     if ((i * k - r) mod 10 = 0 or (i * k) mod 10 = 0) then     return i else skip ;  ;     i := i + 1 ) ; 
     return 10 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 15 ;
     var r : int ; r := 2 ;
     OclFile["System.out"].println(minItems(k, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.security.cert.CollectionCertStoreParameters ;
import java.util.*;
import javax.xml.transform.SourceLocator ;
public class A_Appleman_and_Toastman {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int arr[]=new int[n];
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=s.nextInt();
      sum+=arr[i];
    }
    long score=0 ;
    Arrays.sort(arr);
    score=sum ;
    for(int i=0 ; i<n-1 ; i++){
      score+=arr[i];
      sum=sum-arr[i];
      score+=sum ;
    }
    System.out.println(score);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Appleman_and_Toastman {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    var score : long ; score := 0 ;
    arr := arr->sort() ; 
    score := sum ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     score := score+(arr[i+1]) ; 
     sum := sum - arr[i+1] ; 
     score := score+(sum) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(score) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class AppleToast {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scan.nextInt();
    }
    Arrays.sort(a);
    long sum=a[n-1]*n ;
    for(int i=n-2 ; i>=0 ; i--){
      sum+=a[i]*(i+2);
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class AppleToast {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var sum : long ; sum := a[n - 1+1] * n ;
        var i : int ; i := n - 2 ; while i >= 0 do ( (     sum := sum+(a[i+1] * (i + 2)) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float mean(float mid[],int freq[],int n){
    float sum=0,freqSum=0 ;
    for(int i=0 ; i<n ; i++){
      sum=sum+mid[i]*freq[i];
      freqSum=freqSum+freq[i];
    }
    return sum/freqSum ;
  }
  static float groupedSD(float lower_limit[],float upper_limit[],int freq[],int n){
    float mid[]=new float[n];
    float sum=0,freqSum=0,sd ;
    for(int i=0 ; i<n ; i++){
      mid[i]=(lower_limit[i]+upper_limit[i])/2 ;
      sum=sum+freq[i]*mid[i]*mid[i];
      freqSum=freqSum+freq[i];
    }
    sd=(float)Math.sqrt((sum-freqSum*mean(mid,freq,n)*mean(mid,freq,n))/(freqSum-1));
    return sd ;
  }
  public static void main(String[] args){
    float lower_limit[]={
      50,61,71,86,96 };
      float upper_limit[]={
        60,70,85,95,100 };
        int freq[]={
          9,7,9,12,8 };
          int n=lower_limit.length ;
          System.out.println(groupedSD(lower_limit,upper_limit,freq,n));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation mean( mid : Sequence(double), freq : Sequence(int), n : int) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
    var freqSum : double ; freqSum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum + mid[i+1] * freq[i+1] ; 
     freqSum := freqSum + freq[i+1] )  ;     i := i + 1 ) ; 
     return sum / freqSum );
  static   operation groupedSD( lower_limit : Sequence(double), upper_limit : Sequence(double), freq : Sequence(int), n : int) : double
  pre: true
  post: true
  activity: (     var mid : Sequence(double) ; mid := Integer.subrange(1,n)->collect(0.0) ;
     var sum : double ; sum := 0 ;
    var freqSum : double ; freqSum := 0 ;
    var sd : double ;
        var i : int ; i := 0 ; while i < n do ( (     mid[i+1] := (lower_limit[i+1] + upper_limit[i+1]) / 2 ; 
     sum := sum + freq[i+1] * mid[i+1] * mid[i+1] ; 
     freqSum := freqSum + freq[i+1] )  ;     i := i + 1 ) ; 
    sd := ((sum - freqSum * mean(mid, freq, n) * mean(mid, freq, n)) / (freqSum - 1))->sqrt()->oclAsType(double) ; 
    return sd 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var lower_limit : Sequence(double) ; lower_limit := Sequence{50,61,71,86,96} ;
     var upper_limit : Sequence(double) ; upper_limit := Sequence{60,70,85,95,100} ;
    var freq : Sequence(int) ; freq := Sequence{9,7,9,12,8} ;
    var n : int ; n := lower_limit->size() ;
    OclFile["System.out"].println(groupedSD(lower_limit, upper_limit, freq, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Codeforces {
  public static void main(String args[]){
    Scanner k=new Scanner(System.in);
    long n=k.nextLong();
    ArrayList<Long>arr=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      long a=k.nextLong();
      arr.add(a);
    }
    Collections.sort(arr);
    long ans=0 ;
    long sum=0 ;
    for(long a : arr)sum+=a ;
    for(int i=0 ; i<n-1 ; i++){
      ans+=sum ;
      ans+=arr.get(i);
      sum-=arr.get(i);
    }
    System.out.println(ans+arr.get((int)(n-1)));
    k.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : OclFile ; k := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := k.getCurrent()->toLong() ;
    var arr : Sequence(long) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : long ; a := k.getCurrent()->toLong() ;
     arr := arr->including(a) )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var ans : long ; ans := 0 ;
    var sum : long ; sum := 0 ;
    for (a : arr) do (     sum := sum+(a) ;  ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     ans := ans+(sum) ; 
     ans := ans+(arr->at(i+1)) ; 
     sum := sum-(arr->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans + arr->at((n - 1)->oclAsType(int)+1)) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
class GFG {
  static boolean func(int a[],int k){
    for(int i=0 ; i<a.length ; i++)if(a[i] % k==0)return true ;
    return false ;
  }
  public static void main(String args[]){
    int[] a={
      14,27,38,76,84 };
      int k=19 ;
      boolean res=func(a,k);
      System.out.println(res);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation func( a : Sequence(int), k : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < a->size() do (     if (a[i+1] mod k = 0) then     return true else skip ;  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{14,27,38,76,84} ;
     var k : int ; k := 19 ;
     var res : boolean ; res := func(a, k) ;
     OclFile["System.out"].println(res) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int[] Findpermutation(int n){
    int[] a=new int[n+1];
    a[1]=n ;
    for(int i=2 ; i<=n ; i++)a[i]=i-1 ;
    return a ;
  }
  public static void main(String[] args){
    int n=8 ;
    int[] v=Findpermutation(n);
    for(int i=1 ; i<=n ; i++)System.out.print(v[i]+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Findpermutation( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
     a[1+1] := n ; 
         var i : int ; i := 2 ; while i <= n do (     a[i+1] := i - 1 ;  ;     i := i + 1 ) ; 
     return a );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     var v : Sequence(int) ; v := Findpermutation(n) ;
         var i : int ; i := 1 ; while i <= n do (     OclFile["System.out"].print(v[i+1] + " ") ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    Main instance=new Main();
    instance.solve();
  }
  private void solve(){
    try {
      int n=sc.nextInt();
      int y=sc.nextInt();
      for(int i=0 ; i<=n ; i++){
        for(int j=0 ; j<=n ; j++){
          int k=n-i-j ;
          if(k<0){
            continue ;
          }
          if(i*10000+j*5000+1000*k==y){
            System.out.println(i+" "+j+" "+k);
            return ;
          }
        }
      }
      System.out.println("-1-1-1");
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var instance : Main ; instance := Main.newMain() ;
     instance.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     try (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= n do ( (     var k : int ; k := n - i - j ;
     if (k < 0) then (     continue ) else skip ; 
     if (i * 10000 + j * 5000 + 1000 * k = y) then (     OclFile["System.out"].println(i + " " + j + " " + k) ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("-1-1-1") )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int __gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static void countCoprimePairs(int n){
    int count=0 ;
    System.out.println("The co-prime pairs are: ");
    for(int i=2 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        if(__gcd(i,(n/i))==1){
          System.out.print("("+i+","+(n/i)+")\n");
          count++;
        }
      }
    }
    System.out.println("\nNumber of coprime pairs : "+count);
  }
  public static void main(String[] args){
    int N=120 ;
    countCoprimePairs(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
    if (a = b) then     return a else skip ; 
    if (a > b) then     return __gcd(a - b, b) else skip ; 
    return __gcd(a, b - a) 
 );
  static   operation countCoprimePairs( n : int) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     OclFile["System.out"].println("The co-prime pairs are: ") ; 
         var i : int ; i := 2 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     if (__gcd(i, (n / i)) = 1) then (     OclFile["System.out"].print("(" + i + "," + (n / i) + ")\n") ; 
     count := count + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("\nNumber of coprime pairs : " + count) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 120 ;
     execute countCoprimePairs(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class tennis {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder();
    int tt=fs.nextInt();
    Long[] a=fs.readArray(tt);
    sb.append(a[0]).append(" ");
    long max=Math.max(0L,a[0]);
    for(int i=1 ; i<tt ; i++){
      sb.append(max+a[i]+" ");
      max=Math.max(max,a[i]+max);
    }
    out.print(sb);
    out.close();
  }
  static int isPerfectSquare(int x){
    if(x>=0){
      int sr=(int)Math.sqrt(x);
      if((sr*sr)==x)return sr ;
      else return 0 ;
    }
    return 0 ;
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    Long[] readArray(int n){
      Long[] a=new Long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class tennis {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    var tt : int ; tt := fs.nextInt() ;
    var a : Sequence(long) ; a := fs.readArray(tt) ;
    sb := sb + StringLib.newString(a[0+1]) + StringLib.newString(" ") ; 
    var max : long ; max := Set{0L, a[0+1]}->max() ;
        var i : int ; i := 1 ; while i < tt do ( (     sb := sb + StringLib.newString(max + a[i+1] + " ") ; 
     max := Set{max, a[i+1] + max}->max() )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation isPerfectSquare( x : int) : int
  pre: true
  post: true
  activity: (     if (x >= 0) then (     var sr : int ; sr := (x)->sqrt()->oclAsType(int) ;
     if ((sr * sr) = x) then     return sr else     return 0 ) else skip ; 
     return 0 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    StringTokenizer inputString=new StringTokenizer(reader.readLine());
    int n=Integer.parseInt(inputString.nextToken());
    long[] arr=new long[n];
    long[] arr2=new long[n];
    long temp=0 ;
    long[] arrfin=new long[n];
    StringTokenizer inputString2=new StringTokenizer(reader.readLine());
    for(int i=0 ; i<n ; i++){
      int sum=0 ;
      arr[i]=Long.parseLong(inputString2.nextToken());
      if(i==0){
        arr2[i]=0 ;
      }
      else {
        if(arr[i-1]<0){
          arr2[i]=arr2[i-1];
          sum++;
        }
        else {
          arr2[i]=arr2[i-1]+arr[i-1];
        }
      }
      if(sum>1){
        arrfin[i]=arr2[i];
      }
      else {
        arrfin[i]=arr2[i]+arr[i];
      }
      out.print(arrfin[i]+" ");
    }
    reader.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var inputString : OclIterator ; inputString := OclIterator.newOclIterator_String(reader.readLine()) ;
    var n : int ; n := (inputString.next())->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
    var arr2 : Sequence(long) ; arr2 := Integer.subrange(1,n)->collect(0) ;
    var temp : long ; temp := 0 ;
    var arrfin : Sequence(long) ; arrfin := Integer.subrange(1,n)->collect(0) ;
    var inputString2 : OclIterator ; inputString2 := OclIterator.newOclIterator_String(reader.readLine()) ;
        var i : int ; i := 0 ; while i < n do ( (     var sum : int ; sum := 0 ;
     arr[i+1] := (inputString2.next())->toLong() ; 
    if (i = 0) then (     arr2[i+1] := 0 ) else (     if (arr[i - 1+1] < 0) then (     arr2[i+1] := arr2[i - 1+1] ; 
     sum := sum + 1 ) else (     arr2[i+1] := arr2[i - 1+1] + arr[i - 1+1] ) ) ;  
    if (sum > 1) then (     arrfin[i+1] := arr2[i+1] ) else (     arrfin[i+1] := arr2[i+1] + arr[i+1] ) ;  
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    long[] arr=new long[n];
    long[] prArr=new long[n];
    for(int i=0 ; i<n ; i++)arr[i]=scan.nextLong();
    long x=0 ;
    for(int i=0 ; i<n ; i++){
      prArr[i]=arr[i]+x ;
      x=Math.max(x,prArr[i]);
      System.out.print(prArr[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
    var prArr : Sequence(long) ; prArr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := scan.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var x : long ; x := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     prArr[i+1] := arr[i+1] + x ; 
     x := Set{x, prArr[i+1]}->max() ; 
     OclFile["System.out"].print(prArr[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class sol {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),max=0 ;
    StringBuilder s=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt()+max ;
      max=Math.max(max,a);
      s.append(a+" ");
    }
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class sol {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var max : int ; max := 0 ;
    var s : String ; s := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() + max ;
     max := Set{max, a}->max() ; 
     s := s + StringLib.newString(a + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void Count(int[] temp){
    int[] query={
      9,3,2 };
      int Q=query.length ;
      for(int i=0 ; i<Q ; i++){
        int pos=query[i];
        System.out.println(temp[pos-1]);
      }
    }
    static int[] processing(String s,int len){
      int[] temp=new int[len];
      HashMap<Character,Integer>d=new HashMap<Character,Integer>();
      for(int i=0 ; i<len ; i++){
        if(! d.containsKey(s.charAt(i))){
          d.put(s.charAt(i),i);
        }
        else {
          temp[i]=temp[d.get(s.charAt(i))]+1 ;
          d.put(s.charAt(i),i);
        }
      }
      return temp ;
    }
    public static void main(String[] args){
      String s="abacsddaa" ;
      int n=s.length();
      int[] temp=processing(s,n);
      Count(temp);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Count( temp : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var query : Sequence(int) ; query := Sequence{9,3,2} ;
     var Q : int ; Q := query->size() ;
         var i : int ; i := 0 ; while i < Q do ( (     var pos : int ; pos := query[i+1] ;
     OclFile["System.out"].println(temp[pos - 1+1]) )  ;     i := i + 1 ) );
  static   operation processing( s : String, len : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var temp : Sequence(int) ; temp := Integer.subrange(1,len)->collect(0) ;
     var d : Map(String,int) ; d := Map{} ;
         var i : int ; i := 0 ; while i < len do ( (     if (not(d->keys()->includes(s->at(i+1)))) then (     d := d->union(Map{s->at(i+1) |-> i}) ) else (     temp[i+1] := temp[d->at(s->at(i+1))+1] + 1 ; 
     d := d->union(Map{s->at(i+1) |-> i}) ) )  ;     i := i + 1 ) ; 
     return temp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abacsddaa" ;
     var n : int ; n := s->size() ;
     var temp : Sequence(int) ; temp := processing(s, n) ;
     execute Count(temp) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  public static void main(String[] args){
    int a=2 ;
    int b=4 ;
    System.out.println(gcd(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2 ;
     var b : int ; b := 4 ;
     OclFile["System.out"].println(gcd(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Xor {
  static int maxXORInRange(int L,int R){
    int LXR=L ^ R ;
    int msbPos=0 ;
    while(LXR>0){
      msbPos++;
      LXR>>=1 ;
    }
    int maxXOR=0 ;
    int two=1 ;
    while(msbPos-->0){
      maxXOR+=two ;
      two<<=1 ;
    }
    return maxXOR ;
  }
  public static void main(String[] args){
    int L=8 ;
    int R=20 ;
    System.out.println(maxXORInRange(L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
class Xor {
  static   operation maxXORInRange( L : int, R : int) : int
  pre: true
  post: true
  activity: (     var LXR : int ; LXR := MathLib.bitwiseXor(L,R) ;
     var msbPos : int ; msbPos := 0 ;
    while (LXR > 0) do (     msbPos := msbPos + 1 ; 
     LXR := LXR/(2->pow(1)) ) ; 
    var maxXOR : int ; maxXOR := 0 ;
    var two : int ; two := 1 ;
        while (msbPos > 0) do (        msbPos := msbPos - 1 ;     skip ; (     maxXOR := maxXOR+(two) ; 
     two := two*(2->pow(1)) ) ;  ) ;  
    return maxXOR 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 8 ;
     var R : int ; R := 20 ;
     OclFile["System.out"].println(maxXORInRange(L, R)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void fib(int n){
    int a=0,b=1 ;
    if(n>=0)System.out.print(a+" ");
    if(n>=1)System.out.print(b+" ");
    for(int i=2 ; i<=n ; i++){
      System.out.print(a+b+" ");
      b=a+b ;
      a=b-a ;
    }
  }
  public static void main(String[] args){
    fib(9);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fib( n : int) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 0 ;
    var b : int ; b := 1 ;
     if (n >= 0) then     OclFile["System.out"].print(a + " ") ; else skip ; 
     if (n >= 1) then     OclFile["System.out"].print(b + " ") ; else skip ; 
         var i : int ; i := 2 ; while i <= n do ( (     OclFile["System.out"].print(a + b + " ") ; 
     b := a + b ; 
     a := b - a )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute fib(9) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void fib(int n){
    int a=0,b=1,c ;
    if(n>=0)System.out.print(a+" ");
    if(n>=1)System.out.print(b+" ");
    for(int i=2 ; i<=n ; i++){
      c=a+b ;
      System.out.print(c+" ");
      a=b ;
      b=c ;
    }
  }
  public static void main(String[] args){
    fib(9);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fib( n : int) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 0 ;
    var b : int ; b := 1 ;
    var c : int ;
     if (n >= 0) then     OclFile["System.out"].print(a + " ") ; else skip ; 
     if (n >= 1) then     OclFile["System.out"].print(b + " ") ; else skip ; 
         var i : int ; i := 2 ; while i <= n do ( (     c := a + b ; 
     OclFile["System.out"].print(c + " ") ; 
     a := b ; 
     b := c )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute fib(9) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=256 ;
  static boolean canMakeStr2(String str1,String str2){
    int[] count=new int[MAX];
    char[] str3=str1.toCharArray();
    for(int i=0 ; i<str3.length ; i++)count[str3[i] ]++;
    char[] str4=str2.toCharArray();
    for(int i=0 ; i<str4.length ; i++){
      if(count[str4[i] ]==0)return false ;
      count[str4[i] ]--;
    }
    return true ;
  }
  static public void main(String[] args){
    String str1="geekforgeeks" ;
    String str2="for" ;
    if(canMakeStr2(str1,str2))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 256;
  static   operation canMakeStr2( str1 : String, str2 : String) : boolean
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,MAX)->collect(0) ;
     var str3 : Sequence(String) ; str3 := str1->characters() ;
        var i : int ; i := 0 ; while i < str3->size() do (     count[str3[i+1]+1] := count[str3[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
    var str4 : Sequence(String) ; str4 := str2->characters() ;
        var i : int ; i := 0 ; while i < str4->size() do ( (     if (count[str4[i+1]+1] = 0) then     return false else skip ; 
     count[str4[i+1]+1] := count[str4[i+1]+1] - 1 )  ;     i := i + 1 ) ; 
    return true 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "geekforgeeks" ;
     var str2 : String ; str2 := "for" ;
     if (canMakeStr2(str1, str2)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      int y=scanner.nextInt();
      System.out.println(Arrays.stream(getResult(n,y)).mapToObj(i->String.valueOf(i)).collect(Collectors.joining(" ")));
    }
  }
  private static int[] getResult(final int n,final int y){
    for(int i=0 ; i<=Math.min(y/5000,n); i++){
      int count=n-i ;
      int sum=y-i*5000 ;
      int diff=sum-count*1000 ;
      if((diff>=0)&&(0==diff % 9000)&&(diff/9000<=count)){
        return new int[] {
          diff/9000,i,count-diff/9000 };
        }
      }
      return new int[] {
-1,-1,-1 };
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var y : int ; y := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(stream(getResult(n, y)).mapToObj(lambda i : OclAny in ((i) + "")).collect(Collectors.joining(" "))) ))  );
  static   operation getResult( n : int, y : int) : Sequence(int)
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= Set{y / 5000, n}->min() do ( (     var count : int ; count := n - i ;
     var sum : int ; sum := y - i * 5000 ;
     var diff : int ; diff := sum - count * 1000 ;
     if ((diff >= 0) & (0 = diff mod 9000) & (diff / 9000 <= count)) then (     return Sequence{diff / 9000,i,count - diff / 9000} ) else skip )  ;     i := i + 1 ) ; 
     return Sequence{-1,-1,-1} );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean check(long a,long b){
    long c=0 ;
    while(a!=0){
      c=c+a % 10 ;
      a=a/10 ;
    }
    return(c==b);
  }
  static long root(long n){
    boolean found=false ;
    long mx=(long)1E18 ;
    for(long i=0 ; i<=90 ; i++){
      long s=i*i+4*n ;
      long sq=(long)Math.sqrt(s);
      if(sq*sq==s && check((sq-i)/2,i)){
        found=true ;
        mx=Math.min(mx,(sq-i)/2);
      }
    }
    if(found)return mx ;
    else return-1 ;
  }
  public static void main(String[] args){
    long n=110 ;
    System.out.println(root(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation check( a : long, b : long) : boolean
  pre: true
  post: true
  activity: (     var c : long ; c := 0 ;
     while (a /= 0) do (     c := c + a mod 10 ; 
     a := a / 10 ) ; 
     return (c = b) );
  static   operation root( n : long) : long
  pre: true
  post: true
  activity: (     var found : boolean ; found := false ;
     var mx : long ; mx := 1E18->oclAsType(long) ;
         var i : long ; i := 0 ; while i <= 90 do ( (     var s : long ; s := i * i + 4 * n ;
     var sq : long ; sq := (s)->sqrt()->oclAsType(long) ;
     if (sq * sq = s & check((sq - i) / 2, i)) then (     found := true ; 
     mx := Set{mx, (sq - i) / 2}->min() ) else skip )  ;     i := i + 1 ) ; 
     if (found) then     return mx else     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 110 ;
     OclFile["System.out"].println(root(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class Main {
  static int n ;
  static List<List<Integer>>list ;
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    n=Integer.parseInt(sa[0]);
    list=new ArrayList<>(n);
    for(int i=0 ; i<n ; i++){
      list.add(new ArrayList<>());
    }
    for(int i=0 ; i<n-1 ; i++){
      sa=br.readLine().split(" ");
      int x=Integer.parseInt(sa[0])-1 ;
      int y=Integer.parseInt(sa[1])-1 ;
      list.get(x).add(y);
      list.get(y).add(x);
    }
    br.close();
    if(dfs(0,-1)==1){
      System.out.println("Bob");
    }
    else {
      System.out.println("Alice");
    }
  }
  static int dfs(int x,int p){
    int ret=0 ;
    for(int next : list.get(x)){
      if(next!=p){
        int c=dfs(next,x);
        ret ^=c ;
      }
    }
    return ret+1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute list : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    n := (sa[0+1])->toInteger() ; 
    list := Sequence{} ; 
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     sa := br.readLine()->split(" ") ; 
     var x : int ; x := (sa[0+1])->toInteger() - 1 ;
    var y : int ; y := (sa[1+1])->toInteger() - 1 ;
    list->at(x+1)->excludes(y) ; 
    list->at(y+1)->excludes(x) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    if (dfs(0, -1) = 1) then (     OclFile["System.out"].println("Bob") ) else (     OclFile["System.out"].println("Alice") ) ;  
 );
  static   operation dfs( x : int, p : int) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
     for (next : list->at(x+1)) do ( (     if (next /= p) then (     var c : int ; c := dfs(next, x) ;
     ret := MathLib.bitwiseXor(ret,c) ) else skip )  ) ; 
     return ret + 1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  int n ;
  ArrayList<Integer>list[];
  private void solve()throws IOException {
    n=nextInt();
    list=new ArrayList[n+1];
    for(int i=1 ; i<=n ; i++)list[i]=new ArrayList<>();
    for(int i=1 ; i<n ; i++){
      int u=nextInt();
      int v=nextInt();
      list[u] .add(v);
      list[v] .add(u);
    }
    out.println(dfs(1,-1)==0 ? "Bob" : "Alice");
  }
  int dfs(int v,int p){
    int ret=0 ;
    for(int vv : list[v])if(vv!=p)ret ^=dfs(vv,v)+1 ;
    return ret ;
  }
  public void run()throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    st=null ;
    out=new PrintWriter(System.out);
    solve();
    br.close();
    out.close();
  }
  public static void main(String args[])throws IOException {
    new Main().run();
  }
  BufferedReader br ;
  StringTokenizer st ;
  PrintWriter out ;
  String nextToken()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  String nextLine()throws IOException {
    return br.readLine();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute list : Sequence(Sequence(int));
   operation solve() : void
  pre: true
  post: true
  activity: (     n := nextInt() ; 
     list := Integer.subrange(1,n + 1)->collect(null) ; 
        var i : int ; i := 1 ; while i <= n do (     list[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     var u : int ; u := nextInt() ;
     var v : int ; v := nextInt() ;
     list[u+1]->excludes(v) ; 
     list[v+1]->excludes(u) )  ;     i := i + 1 ) ; 
    out.println(if dfs(1, -1) = 0 then "Bob" else "Alice" endif) ; 
 );
   operation dfs( v : int, p : int) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
     for (vv : list[v+1]) do (     if (vv /= p) then     ret := MathLib.bitwiseXor(ret,dfs(vv, v) + 1) ; else skip ;  ) ; 
     return ret );
   operation run() : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := null ; 
    out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    br.close() ; 
    out.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute br : OclFile;
   attribute st : OclIterator;
   attribute out : OclFile;
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
class Main {
  static int grundy(int v,int pare){
    int res=0 ;
    for(int u : Edge[v])if(u!=pare)res ^=(1+grundy(u,v));
    return res ;
  }
  static List<Integer>Edge[];
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    Edge=new ArrayList[N];
    for(int i=0 ; i<N ; ++i)Edge[i]=new ArrayList<>();
    for(int i=0 ; i<N-1 ; ++i){
      int x=scan.nextInt()-1 ;
      int y=scan.nextInt()-1 ;
      Edge[x] .add(y);
      Edge[y] .add(x);
    }
    if(grundy(0,-1)==0){
      System.out.println("Bob");
    }
    else {
      System.out.println("Alice");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation grundy( v : int, pare : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     for (u : Edge[v+1]) do (     if (u /= pare) then     res := MathLib.bitwiseXor(res,(1 + grundy(u, v))) ; else skip ;  ) ; 
     return res );
  static   attribute Edge : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    Edge := Integer.subrange(1,N)->collect(null) ; 
        var i : int ; i := 0 ; while i < N do (     Edge[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     var x : int ; x := scan.getCurrent()->toInteger() - 1 ;
     var y : int ; y := scan.getCurrent()->toInteger() - 1 ;
     Edge[x+1]->excludes(y) ; 
     Edge[y+1]->excludes(x) )  ;     i := i + 1 ) ; 
    if (grundy(0, -1) = 0) then (     OclFile["System.out"].println("Bob") ) else (     OclFile["System.out"].println("Alice") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static ArrayList[] edge ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    edge=new ArrayList[N+1];
    for(int i=1 ; i<N+1 ; i++){
      edge[i]=new ArrayList<Integer>();
    }
    for(int i=0 ; i<N-1 ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      edge[x] .add(y);
      edge[y] .add(x);
    }
    String ans="Alice" ;
    if(dfs(1,0)==0)ans="Bob" ;
    System.out.println(ans);
  }
  public static int dfs(int v,int p){
    ArrayList<Integer>list=edge[v];
    int ret=0 ;
    for(int i=0 ; i<list.size(); i++){
      int u=list.get(i);
      if(u!=p){
        ret=(ret ^(dfs(u,v)+1));
      }
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute edge : Sequence(Sequence);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    edge := Integer.subrange(1,N + 1)->collect(null) ; 
        var i : int ; i := 1 ; while i < N + 1 do ( (     edge[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     edge[x+1]->excludes(y) ; 
     edge[y+1]->excludes(x) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "Alice" ;
    if (dfs(1, 0) = 0) then     ans := "Bob" ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation dfs( v : int, p : int) : int
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := edge[v+1] ;
     var ret : int ; ret := 0 ;
         var i : int ; i := 0 ; while i < list->size() do ( (     var u : int ; u := list->at(i+1) ;
     if (u /= p) then (     ret := (MathLib.bitwiseXor(ret,(dfs(u, v) + 1))) ) else skip )  ;     i := i + 1 ) ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static float rectanglearea(float a,float b){
    if(a<0 || b<0)return-1 ;
    return 2*a*b ;
  }
  public static void main(String args[]){
    float a=10,b=8 ;
    System.out.println(rectanglearea(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation rectanglearea( a : double, b : double) : double
  pre: true
  post: true
  activity: (     if (a < 0 or b < 0) then     return -1 else skip ; 
     return 2 * a * b );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 10 ;
    var b : double ; b := 8 ;
     OclFile["System.out"].println(rectanglearea(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    Node[] nodes=new Node[n];
    for(int i=0 ; i<n ; i++){
      nodes[i]=new Node(i);
    }
    for(int i=0 ; i<n-1 ; i++){
      String[] s=br.readLine().split(" ");
      int a=Integer.parseInt(s[0])-1 ;
      int b=Integer.parseInt(s[1])-1 ;
      nodes[a] .adj.add(nodes[b]);
      nodes[b] .adj.add(nodes[a]);
    }
    if(solve(nodes[0],-1)!=0){
      System.out.println("Alice");
    }
    else {
      System.out.println("Bob");
    }
  }
  static int solve(Node a,int from){
    if(a.adj.size()==1 && a.i!=0){
      return 0 ;
    }
    int ans=0 ;
    for(Node n : a.adj){
      if(n.i!=from){
        ans ^=1+solve(n,a.i);
      }
    }
    return ans ;
  }
}
class Node {
  int i ;
  ArrayList<Node>adj ;
  public Node(int ii){
    i=ii ;
    adj=new ArrayList<Node>();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var nodes : Sequence(Node) ; nodes := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     nodes[i+1] := Node.newNode(i) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < (n)->char2byte() - 1 do ( (     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
     var a : int ; a := (s[0+1])->toInteger() - 1 ;
    var b : int ; b := (s[1+1])->toInteger() - 1 ;
    nodes[a+1].adj->excludes(nodes[b+1]) ; 
    nodes[b+1].adj->excludes(nodes[a+1]) ; 
 )  ;     i := i + 1 ) ; 
    if (solve(nodes[0+1], -1) /= 0) then (     OclFile["System.out"].println("Alice") ) else (     OclFile["System.out"].println("Bob") ) ;  
 );
  static   operation solve( a : Node, from : int) : int
  pre: true
  post: true
  activity: (     if (a.adj->size() = 1 & a.i /= 0) then (     return 0 ) else skip ; 
     var ans : int ; ans := 0 ;
     for (n : a.adj) do ( (     if (n.i /= from) then (     ans := MathLib.bitwiseXor(ans,1 + solve(n, a.i)) ) else skip )  ) ; 
     return ans );
}
class Node {
   attribute i : int;
   attribute adj : Sequence(Node);
   static operation newNode( ii : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(ii);
    return self );
  operation initialise( ii : int) : void
  pre: true  post: true
  activity: (     i := ii ; 
     adj := Sequence{} );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
class GFG {
  public static void maxOverlap(int[] start,int[] end,int n){
    int maxa=Arrays.stream(start).max().getAsInt();
    int maxb=Arrays.stream(end).max().getAsInt();
    int maxc=Math.max(maxa,maxb);
    int[] x=new int[maxc+2];
    Arrays.fill(x,0);
    int cur=0,idx=0 ;
    for(int i=0 ; i<n ; i++){
++x[start[i] ];
--x[end[i]+1];
    }
    int maxy=Integer.MIN_VALUE ;
    for(int i=0 ; i<=maxc ; i++){
      cur+=x[i];
      if(maxy<cur){
        maxy=cur ;
        idx=i ;
      }
    }
    System.out.println("Maximum value is:"+maxy+" at position: "+idx+"");
  }
  public static void main(String[] args){
    int[] start=new int[] {
      13,28,29,14,40,17,3 };
      int[] end=new int[] {
        107,95,111,105,70,127,74 };
        int n=start.length ;
        maxOverlap(start,end,n);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxOverlap( start : Sequence(int), end : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var maxa : int ; maxa := stream(start).max().getAsInt() ;
     var maxb : int ; maxb := stream(end).max().getAsInt() ;
    var maxc : int ; maxc := Set{maxa, maxb}->max() ;
    var x : Sequence(int) ; x := Integer.subrange(1,maxc + 2)->collect(0) ;
    x := x->collect(0) ; 
    var cur : int ; cur := 0 ;
    var idx : int ; idx := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x[start[i+1]+1] := x[start[i+1]+1] + 1 ; 
     x[end[i+1] + 1+1] := x[end[i+1] + 1+1] - 1 )  ;     i := i + 1 ) ; 
    var maxy : int ; maxy := -2147483648 ;
        var i : int ; i := 0 ; while i <= maxc do ( (     cur := cur+(x[i+1]) ; 
     if (maxy < cur) then (     maxy := cur ; 
     idx := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Maximum value is:" + maxy + " at position: " + idx + "") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : Sequence(int) ; start := Sequence{13,28,29,14,40,17,3} ;
     var end : Sequence(int) ; end := Sequence{107,95,111,105,70,127,74} ;
     var n : int ; n := start->size() ;
     execute maxOverlap(start, end, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int ans=1900*M+100*(N-M);
    for(int i=0 ; i<M ; i++){
      ans*=2 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 1900 * M + 100 * (N - M) ;
        var i : int ; i := 0 ; while i < M do ( (     ans := ans*(2) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CHSI solver=new CHSI();
    solver.solve(1,in,out);
    out.close();
  }
  static class CHSI {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=Integer.parseInt(in.next());
      int m=Integer.parseInt(in.next());
      int ans=(int)((1900*m+100*(n-m))*Math.pow(2,m));
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CHSI ; solver := CHSI.newCHSI() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CHSI {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (in.getCurrent())->toInteger() ;
     var m : int ; m := (in.getCurrent())->toInteger() ;
     var ans : int ; ans := ((1900 * m + 100 * (n - m)) * 2->pow(m))->oclAsType(int) ;
     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.Math.*;
import static java.lang.System.*;
public class Main {
  public static long LMS=1900 ;
  public static long SMS=100 ;
  public static void main(String[] args){
    int i=0 ;
    int j=0 ;
    int k=0 ;
    Scanner sc=new Scanner(in);
    long n=parseLong(sc.next());
    long m=parseLong(sc.next());
    sc.close();
    long t=m*LMS+(n-m)*SMS ;
    out.println(t*(long)pow(2,m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute LMS : long := 1900;
  static   attribute SMS : long := 100;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var j : int ; j := 0 ;
    var k : int ; k := 0 ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
    var n : long ; n := parseLong(sc.getCurrent()) ;
    var m : long ; m := parseLong(sc.getCurrent()) ;
    skip ; 
    var t : long ; t := m * LMS + (n - m) * SMS ;
    out.println(t * pow(2, m)->oclAsType(long)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String input=br.readLine();
    int notes=Integer.parseInt(input.substring(0,input.indexOf(" ")));
    input=input.substring(input.indexOf(" ")+1);
    int money_l=Integer.parseInt(input);
    int money=money_l/1000 ;
    String result="-1-1-1" ;
    if(notes<=money && money<=notes*10){
      OUTSIDE : for(int x=0 ;
      x<=notes ;
      x++){
        if(x*10>money){
          break ;
        }
        if(money<=x*10+(notes-x)*5){
          for(int y=0 ; y<=notes-x ; y++){
            if(x*10+y*5>money){
              break ;
            }
            if(x*10+y*5+(notes-x-y)==money){
              result=String.valueOf(x)+" "+String.valueOf(y)+" "+String.valueOf(notes-x-y);
              break OUTSIDE ;
            }
          }
        }
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : String ; input := br.readLine() ;
    var notes : int ; notes := (input.subrange(0+1,input->indexOf(" ")-1))->toInteger() ;
    input := input.subrange(input->indexOf(" ")-1 + 1+1,input->indexOf(" ")-1 + 1) ; 
    var money_l : int ; money_l := (input)->toInteger() ;
    var money : int ; money := money_l / 1000 ;
    var result : String ; result := "-1-1-1" ;
    if (notes <= money & money <= notes * 10) then (         var x : int ; x := 0 ; while x <= notes do ( (     if (x * 10 > money) then (     break ) else skip ; 
     if (money <= x * 10 + ((notes)->char2byte() - (x)->char2byte()) * 5) then (         var y : int ; y := 0 ; while y <= (notes)->char2byte() - (x)->char2byte() do ( (     if (x * 10 + y * 5 > money) then (     break ) else skip ; 
     if (x * 10 + y * 5 + ((notes)->char2byte() - (x)->char2byte() - y) = money) then (     result := ((x) + "") + " " + ((y) + "") + " " + (((notes)->char2byte() - (x)->char2byte() - y) + "") ; 
     break ) else skip )  ;     y := y + 1 ) ) else skip )  ;     x := x + 1 ) ; ) else skip ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static int mod=(int)1e9+7 ;
  static int DX[]={
-1,0,1,0 },DY[]={
      0,-1,0,1 };
      public static void main(String[] args){
        FastScanner fs=new FastScanner(System.in);
        int n=fs.nextInt(),m=fs.nextInt();
        long ans=(long)Math.pow(2,m)*(1900*m+100*(n-m));
        System.out.println(ans);
      }
    }
    class FastScanner {
      private BufferedReader reader=null ;
      private StringTokenizer tokenizer=null ;
      public FastScanner(InputStream in){
        reader=new BufferedReader(new InputStreamReader(in));
        tokenizer=null ;
      }
      public String next(){
        if(tokenizer==null || ! tokenizer.hasMoreTokens()){
          try {
            tokenizer=new StringTokenizer(reader.readLine());
          }
          catch(IOException e){
            throw new RuntimeException(e);
          }
        }
        return tokenizer.nextToken();
      }
      public String nextLine(){
        if(tokenizer==null || ! tokenizer.hasMoreTokens()){
          try {
            return reader.readLine();
          }
          catch(IOException e){
            throw new RuntimeException(e);
          }
        }
        return tokenizer.nextToken("\n");
      }
      public long nextLong(){
        return Long.parseLong(next());
      }
      public int nextInt(){
        return Integer.parseInt(next());
      }
      public double nextDouble(){
        return Double.parseDouble(next());
      }
      public int[] nextIntArray(int n){
        int[] a=new int[n];
        for(int i=0 ; i<n ; i++)a[i]=nextInt();
        return a ;
      }
      public long[] nextLongArray(int n){
        long[] a=new long[n];
        for(int i=0 ; i<n ; i++)a[i]=nextLong();
        return a ;
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := 1e9->oclAsType(int) + 7;
  static   attribute DX : int := Sequence{-1,0,1,0};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var n : int ; n := fs.nextInt() ;
    var m : int ; m := fs.nextInt() ;
     var ans : long ; ans := 2->pow(m)->oclAsType(long) * (1900 * m + 100 * (n - m)) ;
     OclFile["System.out"].println(ans) );
}
class FastScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.nextToken("\n") );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.nio.charset.StandardCharsets ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader reader=new InputStreamReader(System.in,StandardCharsets.UTF_8);
    BufferedReader in=new BufferedReader(reader);
    String[] tokens=in.readLine().split(" ");
    int N=Integer.parseInt(tokens[0]);
    int M=Integer.parseInt(tokens[1]);
    long result=1900*M+100*(N-M);
    long ratio=2 ;
    for(int i=2 ; i<=M ; ++i){
      ratio*=2 ;
    }
    result*=ratio ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"], StandardCharsets.UTF_8) ;
     var in : OclFile ; in := OclFile.newOclFile_Read(reader) ;
    var tokens : Sequence(String) ; tokens := in.readLine()->split(" ") ;
    var N : int ; N := (tokens[0+1])->toInteger() ;
    var M : int ; M := (tokens[1+1])->toInteger() ;
    var result : long ; result := 1900 * M + 100 * (N - M) ;
    var ratio : long ; ratio := 2 ;
        var i : int ; i := 2 ; while i <= M do ( (     ratio := ratio*(2) )  ;     i := i + 1 ) ; 
    result := result*(ratio) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean CheckArray(int arr[],int n){
    int prod=1 ;
    for(int i=0 ; i<n ; ++i)prod*=arr[i];
    for(int i=0 ; i<n ; ++i)if(arr[i]==prod/arr[i])return true ;
    return false ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,12,3,2 };
      int n=arr.length ;
      if(CheckArray(arr,n))System.out.println("YES");
      else System.out.println("NO");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation CheckArray( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var prod : int ; prod := 1 ;
         var i : int ; i := 0 ; while i < n do (     prod := prod*(arr[i+1]) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do (     if (arr[i+1] = prod / arr[i+1]) then     return true else skip ;  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,12,3,2} ;
     var n : int ; n := arr->size() ;
     if (CheckArray(arr, n)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static final int MAX=100000 ;
  private static int[][] map ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String string=sc.next();
    sc.close();
    String mew=string ;
    while(mew.indexOf("mew")!=-1 && ! mew.equals("mew")){
      mew=mew.replaceAll("mew","");
    }
    if(! mew.equals("mew")){
      System.out.println("Rabbit");
      return ;
    }
    System.out.println("Cat");
    return ;
  }
  static void WarshallFloyd(){
    int n=map.length ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(map[i][j]==0){
          map[i][j]=MAX ;
        }
      }
    }
    for(int k=0 ; k<n ; k++){
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          if(i!=j){
            map[i][j]=Math.min(map[i][j],map[i][k]+map[k][j]);
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 100000;
  static   attribute map : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var string : String ; string := sc.getCurrent() ;
    skip ; 
    var mew : String ; mew := string ;
    while (mew->indexOf("mew")-1 /= -1 & not(mew = "mew")) do (     mew := mew.replaceAllMatches("mew", "" ) ) ; 
    if (not(mew = "mew")) then (     OclFile["System.out"].println("Rabbit") ; 
     return ) else skip ; 
    OclFile["System.out"].println("Cat") ; 
    return 
 );
  static   operation WarshallFloyd() : void
  pre: true
  post: true
  activity: (     var n : int ; n := map->size() ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (map[i+1][j+1] = 0) then (     map[i+1][j+1] := MAX ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
         var k : int ; k := 0 ; while k < n do ( (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (i /= j) then (     map[i+1][j+1] := Set{map[i+1][j+1], map[i+1][k+1] + map[k+1][j+1]}->min() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collection ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.InputMismatchException ;
import java.util.PriorityQueue ;
import java.util.Random ;
import java.util.Scanner ;
import java.util.Stack ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class CF427_1 {
  static int N ;
  static int MOD=(int)(1e9+7);
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=in.nextInt();
    while(t-->0){
      long n=in.nextInt();
      long a=in.nextInt();
      long b=in.nextInt();
      if(n<a){
        out.println("No");
        continue ;
      }
      if(a==b){
        if(n % a==0){
          out.println("Yes");
        }
        else {
          out.println("No");
        }
        continue ;
      }
      long x=b/(b-a);
      if(n>x*a){
        out.println("Yes");
        continue ;
      }
      long low=1 ;
      long high=x+1 ;
      long ans=1 ;
      while(low<=high){
        long mid=(low+high)/2 ;
        if(mid*a<n){
          low=mid+1 ;
        }
        else {
          ans=mid ;
          high=mid-1 ;
        }
      }
      if(n>(ans-1)*b && n<ans*a){
        out.println("No");
      }
      else {
        out.println("Yes");
      }
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF427_1 {
  static   attribute N : int;
  static   attribute MOD : int := (1e9 + 7)->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := in.getCurrent()->toInteger() ;
     var a : long ; a := in.getCurrent()->toInteger() ;
    var b : long ; b := in.getCurrent()->toInteger() ;
    if (n < a) then (     skip ; 
     continue ) else skip ; 
    if (a = b) then (     if (n mod a = 0) then (     skip ) else (     skip ) ;  
     continue ) else skip ; 
    var x : long ; x := b / (b - a) ;
    if (n > x * a) then (     skip ; 
     continue ) else skip ; 
    var low : long ; low := 1 ;
    var high : long ; high := x + 1 ;
    var ans : long ; ans := 1 ;
    while (low <= high) do (     var mid : long ; mid := (low + high) / 2 ;
     if (mid * a < n) then (     low := mid + 1 ) else (     ans := mid ; 
     high := mid - 1 ) ) ; 
    if (n > (ans - 1) * b & n < ans * a) then (     skip ) else (     skip ) ;  
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  boolean flag ;
  char[] a ;
  int pos ;
  void cat(){
    if(pos<a.length && a[pos]=='m')pos++;
    else flag=false ;
    if(flag==false)return ;
    if(pos<a.length && a[pos]=='m')cat();
    if(pos<a.length && a[pos]=='e')pos++;
    else flag=false ;
    if(flag==false)return ;
    if(pos<a.length && a[pos]=='m')cat();
    if(pos<a.length && a[pos]=='w')pos++;
    else flag=false ;
    if(flag==false)return ;
  }
  void solve(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      a=sc.next().toCharArray();
      if(a.length % 3!=0){
        System.out.println("Rabbit");
      }
      else {
        flag=true ;
        pos=0 ;
        cat();
        if(flag==true && pos==a.length)System.out.println("Cat");
        else System.out.println("Rabbit");
      }
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute flag : boolean;
   attribute a : Sequence(String);
   attribute pos : int;
   operation cat() : void
  pre: true
  post: true
  activity: (     if (pos < a->size() & a[pos+1] = 'm') then     pos := pos + 1 else     flag := false ; ;  
     if (flag = false) then     return else skip ; 
    if (pos < a->size() & a[pos+1] = 'm') then     execute cat() ; else skip ; 
    if (pos < a->size() & a[pos+1] = 'e') then     pos := pos + 1 else     flag := false ; ;  
    if (flag = false) then     return else skip ; 
    if (pos < a->size() & a[pos+1] = 'm') then     execute cat() ; else skip ; 
    if (pos < a->size() & a[pos+1] = 'w') then     pos := pos + 1 else     flag := false ; ;  
    if (flag = false) then     return else skip ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     a := sc.getCurrent()->characters() ; 
     if (a->size() mod 3 /= 0) then (     OclFile["System.out"].println("Rabbit") ) else (     flag := true ; 
     pos := 0 ; 
     execute cat() ; 
     if (flag = true & pos = a->size()) then     OclFile["System.out"].println("Cat") ; else     OclFile["System.out"].println("Rabbit") ; ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
import java.util.Set ;
import static java.lang.Integer.parseInt ;
public class Main {
  static Set<String>cat=new HashSet<>();
  static Set<String>rabbit=new HashSet<>();
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    cat.add("");
    cat.add("mew");
    while((line=br.readLine())!=null && ! line.isEmpty()){
      System.out.println(isCat(line)? "Cat" : "Rabbit");
    }
  }
  static boolean isCat(String S){
    if(cat.contains(S))return true ;
    if(rabbit.contains(S))return false ;
    if(S.charAt(0)=='m' && S.charAt(S.length()-1)=='w' && S.indexOf('e')>0){
      boolean ret=false ;
      String _S=S.substring(1,S.length()-1);
      for(int i=0 ; i<_S.length(); i++){
        if(_S.charAt(i)=='e'){
          ret=isCat(_S.substring(0,i))& isCat(_S.substring(i+1));
          if(ret){
            cat.add(S);
            break ;
          }
          else {
            rabbit.add(S);
          }
        }
      }
      return ret ;
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute cat : Set(String) := Set{};
  static   attribute rabbit : Set(String) := Set{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    cat := cat->including("") ; 
    cat := cat->including("mew") ; 
        line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     OclFile["System.out"].println(if isCat(line) then "Cat" else "Rabbit" endif) ) ;     line := br.readLine() ;
 ) ;  
 );
  static   operation isCat( S : String) : boolean
  pre: true
  post: true
  activity: (     if (cat->includes(S)) then     return true else skip ; 
     if (rabbit->includes(S)) then     return false else skip ; 
     if (S->at(0+1) = 'm' & S->at(S->size() - 1+1) = 'w' & S->indexOf('e')-1 > 0) then (     var ret : boolean ; ret := false ;
     var _S : String ; _S := S.subrange(1+1,S->size() - 1) ;
         var i : int ; i := 0 ; while i < _S->size() do ( (     if (_S->at(i+1) = 'e') then (     ret := isCat(_S.subrange(0+1,i)) & isCat(_S.subrange(i + 1+1,i + 1)) ; 
     if (ret) then (     cat := cat->including(S) ; 
     break ) else (     rabbit := rabbit->including(S) ) ) else skip )  ;     i := i + 1 ) ; 
     return ret ) else skip ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  Scanner sc=new Scanner(in);
  int n,len ;
  String s ;
  boolean wa(){
    if(s.charAt(n)!='m' || n+2>=len)return false ;
    n++;
    if(s.charAt(n)=='m'){
      if(! wa())return false ;
    }
    if(n>=len || s.charAt(n)!='e')return false ;
    n++;
    if(n>=len)return false ;
    if(s.charAt(n)=='m'){
      if(! wa())return false ;
    }
    if(n>=len || s.charAt(n)!='w')return false ;
    n++;
    return true ;
  }
  void run(){
    s=sc.next();
    len=s.length();
    if(len==0){
      out.println("Cat");
      return ;
    }
    n=0 ;
    if(wa()&& n==len)out.println("Cat");
    else out.println("Rabbit");
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   attribute n : int;
   attribute s : String;
   operation wa() : boolean
  pre: true
  post: true
  activity: (     if (s->at(n+1) /= 'm' or n + 2 >= len) then     return false else skip ; 
     n := n + 1 ; 
    if (s->at(n+1) = 'm') then (     if (not(wa())) then     return false else skip ) else skip ; 
    if (n >= len or s->at(n+1) /= 'e') then     return false else skip ; 
    n := n + 1 ; 
    if (n >= len) then     return false else skip ; 
    if (s->at(n+1) = 'm') then (     if (not(wa())) then     return false else skip ) else skip ; 
    if (n >= len or s->at(n+1) /= 'w') then     return false else skip ; 
    n := n + 1 ; 
    return true 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     s := sc.getCurrent() ; 
     len := s->size() ; 
    if (len = 0) then (     out.println("Cat") ; 
     return ) else skip ; 
    n := 0 ; 
    if (wa() & n = len) then     out.println("Cat") else     out.println("Rabbit") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int N ;
  static String str ;
  static int[][] memo ;
  public static void main(String[] a){
    str=sc.next();
    N=str.length();
    memo=new int[N+1][N+1];
    System.out.println(rec(0,N)? "Cat" : "Rabbit");
  }
  static boolean rec(int s,int e){
    if(s==e)return true ;
    if(memo[s][e]!=0)return memo[s][e]==1 ? true : false ;
    if(str.charAt(s)!='m')return false ;
    if(str.charAt(e-1)!='w')return false ;
    boolean ret=false ;
    for(int i=s+1 ; i<e-1 ; ++i){
      if(str.charAt(i)!='e')continue ;
      if(rec(s+1,i)&& rec(i+1,e-1)){
        ret=true ;
        break ;
      }
    }
    memo[s][e]=ret ? 1 :-1 ;
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int;
  static   attribute str : String;
  static   attribute memo : Sequence(Sequence(int));
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     str := sc.getCurrent() ; 
     N := str->size() ; 
     memo := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ; 
     OclFile["System.out"].println(if rec(0, N) then "Cat" else "Rabbit" endif) );
  static   operation rec( s : int, e : int) : boolean
  pre: true
  post: true
  activity: (     if (s = e) then     return true else skip ; 
     if (memo[s+1][e+1] /= 0) then     return if memo[s+1][e+1] = 1 then true else false endif else skip ; 
    if (str->at(s+1) /= 'm') then     return false else skip ; 
    if (str->at(e - 1+1) /= 'w') then     return false else skip ; 
    var ret : boolean ; ret := false ;
        var i : int ; i := s + 1 ; while i < e - 1 do ( (     if (str->at(i+1) /= 'e') then     continue else skip ; 
     if (rec(s + 1, i) & rec(i + 1, e - 1)) then (     ret := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    memo[s+1][e+1] := if ret then 1 else -1 endif ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int xor_all_elements(int n){
    switch(n & 3){
      case 0 : return n ;
      case 1 : return 1 ;
      case 2 : return n+1 ;
    }
    return 0 ;
  }
  static Vector<Integer>findArray(int xorr[],int n){
    Vector<Integer>arr=new Vector<Integer>();
    int xor_all=xor_all_elements(n);
    int xor_adjacent=0 ;
    for(int i=0 ; i<n-1 ; i+=2){
      xor_adjacent=xor_adjacent ^ xorr[i];
    }
    int last_element=xor_all ^ xor_adjacent ;
    arr.add(last_element);
    for(int i=n-2 ; i>=0 ; i--){
      last_element=xorr[i] ^ last_element ;
      arr.add(last_element);
    }
    return arr ;
  }
  public static void main(String[] args){
    Vector<Integer>arr=new Vector<Integer>();
    int xorr[]={
      7,5,3,7 };
      int n=5 ;
      arr=findArray(xorr,n);
      for(int i=n-1 ; i>=0 ; i--){
        System.out.print(arr.get(i)+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation xor_all_elements( n : int) : int
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (n & 3) ; 
       if _switchval = 0 then
     return n 
   else skip ;
       if _switchval = 1 then
     return 1 
   else skip ;
       if _switchval = 2 then
     return n + 1 
   else skip ;
 )
     return 0 );
  static   operation findArray( xorr : Sequence(int), n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{} ;
     var xor_all : int ; xor_all := xor_all_elements(n) ;
    var xor_adjacent : int ; xor_adjacent := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     xor_adjacent := MathLib.bitwiseXor(xor_adjacent,xorr[i+1]) )  ;     i := i+(2) ) ; 
    var last_element : int ; last_element := MathLib.bitwiseXor(xor_all,xor_adjacent) ;
    arr := arr->including(last_element) ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     last_element := xorr[i+1] xor last_element ; 
     arr := arr->including(last_element) )  ;     i := i - 1 ) ; 
    return arr 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{} ;
     var xorr : Sequence(int) ; xorr := Sequence{7,5,3,7} ;
    var n : int ; n := 5 ;
    arr := findArray(xorr, n) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     OclFile["System.out"].print(arr->at(i+1) + " ") )  ;     i := i - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int mod=(int)(1e9+7);
  static long power(int p){
    long res=1 ;
    for(int i=1 ; i<=p ; ++i){
      res*=2 ;
      res %=mod ;
    }
    return res % mod ;
  }
  static long subset_square_sum(int A[]){
    int n=A.length ;
    long ans=0 ;
    for(int i : A){
      ans+=(1*i*i)% mod ;
      ans %=mod ;
    }
    return(1*ans*power(n-1))% mod ;
  }
  public static void main(String[] args){
    int A[]={
      3,7 };
      System.out.println(subset_square_sum(A));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute mod : int := (1e9 + 7)->oclAsType(int);
  static   operation power( p : int) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : int ; i := 1 ; while i <= p do ( (     res := res*(2) ; 
     res := res mod mod )  ;     i := i + 1 ) ; 
     return res mod mod );
  static   operation subset_square_sum( A : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var n : int ; n := A->size() ;
     var ans : long ; ans := 0 ;
     for (i : A) do ( (     ans := ans+((1 * i * i) mod mod) ; 
     ans := ans mod mod )  ) ; 
     return (1 * ans * power(n - 1)) mod mod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{3,7} ;
     OclFile["System.out"].println(subset_square_sum(A)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    UnionFindTree uft=new UnionFindTree(n);
    for(int i=0 ; i<m ; i++){
      uft.unite(sc.nextInt()-1,sc.nextInt()-1);
    }
    HashSet<Integer>cities=new HashSet<>();
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int x=uft.find(i);
      if(i!=x){
        cities.add(x);
      }
      else {
        count++;
      }
    }
    int cityCount=cities.size();
    int vilCount=count-cityCount ;
    System.out.println(Math.abs(cityCount-vilCount));
  }
  static class UnionFindTree {
    int[] parents ;
    public UnionFindTree(int size){
      parents=new int[size];
      for(int i=0 ; i<size ; i++){
        parents[i]=i ;
      }
    }
    public int find(int x){
      if(parents[x]==x){
        return x ;
      }
      else {
        return parents[x]=find(parents[x]);
      }
    }
    public void unite(int x,int y){
      int xx=find(x);
      int yy=find(y);
      if(xx==yy){
        return ;
      }
      parents[xx]=yy ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var uft : UnionFindTree ; uft := UnionFindTree.newUnionFindTree(n) ;
        var i : int ; i := 0 ; while i < m do ( (     uft.unite(sc.getCurrent()->toInteger() - 1, sc.getCurrent()->toInteger() - 1) )  ;     i := i + 1 ) ; 
    var cities : Set(int) ; cities := Set{} ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := uft.find(i) ;
     if (i /= x) then (     cities := cities->including(x) ) else (     count := count + 1 ) )  ;     i := i + 1 ) ; 
    var cityCount : int ; cityCount := cities->size() ;
    var vilCount : int ; vilCount := count - cityCount ;
    OclFile["System.out"].println(if cityCount - vilCount < 0 then -(cityCount - vilCount) else cityCount - vilCount endif) ; 
 );
  static class UnionFindTree {
   attribute parents : Sequence(int);
   static operation newUnionFindTree( size : int) : UnionFindTree
  pre: true
  post: true
  activity:
  ( var self : UnionFindTree ;
    self := createUnionFindTree();
    self.initialise(size);
    return self );
  operation initialise( size : int) : void
  pre: true  post: true
  activity: (     parents := Integer.subrange(1,size)->collect(0) ; 
         var i : int ; i := 0 ; while i < size do ( (     parents[i+1] := i )  ;     i := i + 1 ) );
   operation find( x : int) : int
  pre: true
  post: true
  activity: (     if (parents[x+1] = x) then (     return x ) else (     return parents[x+1] ) );
   operation unite( x : int, y : int) : void
  pre: true
  post: true
  activity: (     var xx : int ; xx := find(x) ;
     var yy : int ; yy := find(y) ;
     if (xx = yy) then (     return ) else skip ; 
     parents[xx+1] := yy );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countDivisibles(int arr[],int n){
    int res=0 ;
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++)if(arr[i] % arr[j]==0 || arr[j] % arr[i]==0)res++;
    return res ;
  }
  public static void main(String[] args){
    int a[]=new int[] {
      1,2,3,9 };
      int n=a.length ;
      System.out.print(countDivisibles(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countDivisibles( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do (     if (arr[i+1] mod arr[j+1] = 0 or arr[j+1] mod arr[i+1] = 0) then     res := res + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,9} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(countDivisibles(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static final MyScanner in=new MyScanner();
  public static void main(String[] args){
    long N=in.nextLong();
    long M=in.nextLong();
    long amari=N % M ;
    long ura=Math.abs(M-amari);
    System.out.println(Math.min(amari,ura));
  }
  public static class MyScanner {
    Scanner sc=new Scanner(System.in);
    String next(){
      return sc.next();
    }
    int nextInt(){
      return Integer.valueOf(sc.next());
    }
    long nextLong(){
      return Long.valueOf(sc.next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : MyScanner := MyScanner.newMyScanner();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := in.nextLong() ;
     var M : long ; M := in.nextLong() ;
    var amari : long ; amari := N mod M ;
    var ura : long ; ura := if M - amari < 0 then -(M - amari) else M - amari endif ;
    OclFile["System.out"].println(Set{amari, ura}->min()) ; 
 );
  static class MyScanner {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation next() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (sc.getCurrent())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (sc.getCurrent())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getsum(int x){
    return(x*(x+1))/2 ;
  }
  static int countJumps(int n){
    n=Math.abs(n);
    int ans=0 ;
    while(getsum(ans)<n ||((getsum(ans)-n)& 1)>0)ans++;
    return ans ;
  }
  public static void main(String args[]){
    int n=9 ;
    System.out.println(countJumps(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getsum( x : int) : int
  pre: true
  post: true
  activity: (     return (x * (x + 1)) / 2 );
  static   operation countJumps( n : int) : int
  pre: true
  post: true
  activity: (     n := if n < 0 then -(n) else n endif ; 
     var ans : int ; ans := 0 ;
     while (getsum(ans) < n or ((getsum(ans) - n) & 1) > 0) do     ans := ans + 1 ; ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     OclFile["System.out"].println(countJumps(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    resolve(System.in,System.out);
  }
  static void resolve(InputStream is,PrintStream pw){
    Scanner sc=new Scanner(is);
    BigInteger n=new BigInteger(sc.next());
    BigInteger k=new BigInteger(sc.next());
    BigInteger mod=n.mod(k);
    pw.println(mod.min(mod.add(k.negate()).abs()));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute resolve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation resolve( is : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(is) ;
     var n : long ; n := long(sc.getCurrent()) ;
    var k : long ; k := long(sc.getCurrent()) ;
    var mod : long ; mod := n.mod(k) ;
    pw.println(mod->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static void main(String[] args)throws IOException {
    FastReader io=new FastReader();
    long n=io.nextLong(),k=io.nextLong();
    System.out.println(Math.min(n,Math.min(Math.abs(n-(n/k)*k),Math.abs(n-(n/k+1)*k))));
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : FastReader ; io := FastReader.newFastReader() ;
     var n : long ; n := io.nextLong() ;
    var k : long ; k := io.nextLong() ;
     OclFile["System.out"].println(Set{n, Set{if n - (n / k) * k < 0 then -(n - (n / k) * k) else n - (n / k) * k endif, if n - (n / k + 1) * k < 0 then -(n - (n / k + 1) * k) else n - (n / k + 1) * k endif}->min()}->min()) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.Stack ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(new BufferedInputStream(System.in));
    long n=sc.nextLong();
    long k=sc.nextLong();
    n=n % k ;
    n=Math.min(n,Math.abs(n-k));
    System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    n := n mod k ; 
    n := Set{n, if n - k < 0 then -(n - k) else n - k endif}->min() ; 
    OclFile["System.out"].println(n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import static java.lang.Math.min ;
public class Main {
  public static void main(String[] args){
    Scanner get=new Scanner(System.in);
    long n=get.nextLong(),k=get.nextLong();
    System.out.println(Math.min((n % k),k-(n % k)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var get : OclFile ; get := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := get.getCurrent()->toLong() ;
    var k : long ; k := get.getCurrent()->toLong() ;
     OclFile["System.out"].println(Set{(n mod k), k - (n mod k)}->min()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
class Item {
  int value,weight ;
  public Item(int value,int weight){
    this.value=value ;
    this.weight=weight ;
  }
  public int getValue(){
    return this.value ;
  }
  public int getWeight(){
    return this.weight ;
  }
}
public class Main {
  static int N,W ;
  static int Nmax=105 ;
  static int Wmax=10005 ;
  static ArrayList<Item>items=new ArrayList<>();
  static int[][] C=new int[Nmax+1][Wmax+1];
  public static int knapsack(){
    int result=0 ;
    int maxVal=0 ;
    for(int i=1 ; i<=N ; i++){
      for(int w=1 ; w<=W ; w++){
        if(items.get(i).getWeight()<=w){
          if(items.get(i).getValue()+C[i-1][w-items.get(i).getWeight()]>C[i-1][w]){
            C[i][w]=items.get(i).getValue()+C[i-1][w-items.get(i).getWeight()];
          }
          else {
            C[i][w]=C[i-1][w];
          }
        }
        else {
          C[i][w]=C[i-1][w];
        }
      }
      maxVal=C[N][W];
    }
    return result=maxVal ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    W=sc.nextInt();
    Item padding=new Item(0,0);
    items.add(padding);
    for(int i=0 ; i<N ; i++){
      Item item=new Item(sc.nextInt(),sc.nextInt());
      items.add(item);
    }
    System.out.println(knapsack());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Item {
   attribute value : int;
   static operation newItem( value : int, weight : int) : Item
  pre: true
  post: true
  activity:
  ( var self : Item ;
    self := createItem();
    self.initialise(value, weight);
    return self );
  operation initialise( value : int, weight : int) : void
  pre: true  post: true
  activity: (     self.value := value ; 
     self.weight := weight );
   operation getValue() : int
  pre: true
  post: true
  activity: (     return self.value );
   operation getWeight() : int
  pre: true
  post: true
  activity: (     return self.weight );
}
class Main {
  static   attribute N : int;
  static   attribute Nmax : int := 105;
  static   attribute Wmax : int := 10005;
  static   attribute items : Sequence(Item) := Sequence{};
  static   attribute C : Sequence(Sequence(int)) := Integer.subrange(1,Nmax + 1)->collect(Integer.subrange(1,Wmax + 1)->collect(0));
  static   operation knapsack() : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var maxVal : int ; maxVal := 0 ;
         var i : int ; i := 1 ; while i <= N do ( (         var w : int ; w := 1 ; while w <= W do ( (     if (items->at(i+1).getWeight() <= w) then (     if (items->at(i+1).getValue() + C[i - 1+1][w - items->at(i+1).getWeight()+1] > C[i - 1+1][w+1]) then (     C[i+1][w+1] := items->at(i+1).getValue() + C[i - 1+1][w - items->at(i+1).getWeight()+1] ) else (     C[i+1][w+1] := C[i - 1+1][w+1] ) ) else (     C[i+1][w+1] := C[i - 1+1][w+1] ) )  ;     w := w + 1 ) ; 
     maxVal := C[N+1][W+1] )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
    W := sc.getCurrent()->toInteger() ; 
    var padding : Item ; padding := Item.newItem(0, 0) ;
    items := items->including(padding) ; 
        var i : int ; i := 0 ; while i < N do ( (     var item : Item ; item := Item.newItem(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) ;
     items := items->including(item) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(knapsack()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    AizuKnapsackNoRepetitions solver=new AizuKnapsackNoRepetitions();
    solver.solve(1,in,out);
    out.close();
  }
  static class AizuKnapsackNoRepetitions {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int w=in.nextInt();
      int[] vs=new int[n];
      int[] ws=new int[n];
      for(int i=0 ; i<n ; i++){
        vs[i]=in.nextInt();
        ws[i]=in.nextInt();
      }
      out.printf("%d\n",knapsack(w,vs,ws,n));
    }
    private int knapsack(int w,int[] vs,int[] ws,int n){
      int[][] dp=new int[w+1][n+1];
      for(int i=1 ; i<w+1 ; i++){
        for(int j=1 ; j<n+1 ; j++){
          dp[i][j]=dp[i][j-1];
          if(i>=ws[j-1]){
            dp[i][j]=Math.max(dp[i][j],vs[j-1]+dp[i-ws[j-1] ][j-1]);
          }
        }
      }
      return dp[w][n];
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : AizuKnapsackNoRepetitions ; solver := AizuKnapsackNoRepetitions.newAizuKnapsackNoRepetitions() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class AizuKnapsackNoRepetitions {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var w : int ; w := in.getCurrent()->toInteger() ;
    var vs : Sequence(int) ; vs := Integer.subrange(1,n)->collect(0) ;
    var ws : Sequence(int) ; ws := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     vs[i+1] := in.getCurrent()->toInteger() ; 
     ws[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation knapsack( w : int, vs : Sequence(int), ws : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,w + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
         var i : int ; i := 1 ; while i < w + 1 do ( (         var j : int ; j := 1 ; while j < n + 1 do ( (     dp[i+1][j+1] := dp[i+1][j - 1+1] ; 
     if (i >= ws[j - 1+1]) then (     dp[i+1][j+1] := Set{dp[i+1][j+1], vs[j - 1+1] + dp[i - ws[j - 1+1]+1][j - 1+1]}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return dp[w+1][n+1] );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new DPB().doIt();
  }
  class DPB {
    int DP(int v[],int w[],int N,int W,int all[]){
      int result=0 ;
      all[0]=1 ;
      for(int i=0 ; i<N ; i++){
        for(int j=W-1 ; j>=0 ; j--){
          if(j+w[i]<=W){
            if(all[j]>0){
              if(all[0]==1)all[0]=0 ;
              all[j+w[i] ]=Math.max(all[j+w[i] ],all[j]+v[i]);
              all[0]=1 ;
            }
            if(result<all[j+w[i] ])result=all[j+w[i] ];
          }
        }
      }
      return result ;
    }
    void doIt(){
      int N=sc.nextInt();
      int W=sc.nextInt();
      int v[]=new int[N];
      int w[]=new int[N];
      int all[]=new int[W+1];
      for(int i=0 ; i<N ; i++){
        v[i]=sc.nextInt();
        w[i]=sc.nextInt();
      }
      System.out.println(DP(v,w,N,W,all));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     DPB.newDPB().doIt() );
 class DPB {
   operation DP( v : Sequence(int), w : Sequence(int), N : int, W : int, all : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     all[0+1] := 1 ; 
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := W - 1 ; while j >= 0 do ( (     if (j + w[i+1] <= W) then (     if (all[j+1] > 0) then (     if (all[0+1] = 1) then     all[0+1] := 0 ; else skip ; 
     all[j + w[i+1]+1] := Set{all[j + w[i+1]+1], all[j+1] + v[i+1]}->max() ; 
     all[0+1] := 1 ) else skip ; 
     if (result < all[j + w[i+1]+1]) then     result := all[j + w[i+1]+1] ; else skip ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
     return result );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var W : int ; W := sc.getCurrent()->toInteger() ;
    var v : Sequence(int) ; v := Integer.subrange(1,N)->collect(0) ;
    var w : Sequence(int) ; w := Integer.subrange(1,N)->collect(0) ;
    var all : Sequence(int) ; all := Integer.subrange(1,W + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     v[i+1] := sc.getCurrent()->toInteger() ; 
     w[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(DP(v, w, N, W, all)) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long modPower(long x,long y,long p){
    long res=1 ;
    x=x % p ;
    while(y>0){
      if((y & 1)>0)res=(res*x)% p ;
      y=y>>1 ;
      x=(x*x)% p ;
    }
    return res ;
  }
  static long gcd(long a,long b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  static long gcdPow(long a,long n,long c){
    if(a % c==0)return c ;
    long modexpo=modPower(a,n,c);
    return gcd(modexpo,c);
  }
  public static void main(String[] args){
    long a=10248585,n=1000000,c=12564 ;
    System.out.println(gcdPow(a,n,c));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation modPower( x : long, y : long, p : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     if ((y & 1) > 0) then     res := (res * x) mod p ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation gcdPow( a : long, n : long, c : long) : long
  pre: true
  post: true
  activity: (     if (a mod c = 0) then     return c else skip ; 
     var modexpo : long ; modexpo := modPower(a, n, c) ;
     return gcd(modexpo, c) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ; a := 10248585 ;
    var n : long ; n := 1000000 ;
    var c : long ; c := 12564 ;
     OclFile["System.out"].println(gcdPow(a, n, c)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader BR=new BufferedReader(new InputStreamReader(System.in));
    String str=BR.readLine();
    String[] arr=str.split("\\s+");
    int an=Integer.parseInt(arr[0]);
    int mw=Integer.parseInt(arr[1]);
    int[] values=new int[an];
    int[] weights=new int[an];
    for(int i=0 ; i<an ; i++){
      String temp=BR.readLine();
      String[] temparr=temp.split("\\s+");
      int tv=Integer.parseInt(temparr[0]);
      int tw=Integer.parseInt(temparr[1]);
      values[i]=tv ;
      weights[i]=tw ;
    }
    int[][] Vtable=new int[an+1][mw+1];
    for(int i=1 ; i<an+1 ; i++){
      for(int j=1 ; j<mw+1 ; j++){
        if(j<weights[i-1]){
          Vtable[i][j]=Vtable[i-1][j];
        }
        else {
          Vtable[i][j]=Math.max(Vtable[i-1][j-weights[i-1] ]+values[i-1],Vtable[i-1][j]);
        }
      }
    }
    System.out.println(Vtable[an][mw]);
    BR.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var BR : OclFile ; BR := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := BR.readLine() ;
    var arr : Sequence(String) ; arr := str->split("\\s+") ;
    var an : int ; an := (arr[0+1])->toInteger() ;
    var mw : int ; mw := (arr[1+1])->toInteger() ;
    var values : Sequence(int) ; values := Integer.subrange(1,an)->collect(0) ;
    var weights : Sequence(int) ; weights := Integer.subrange(1,an)->collect(0) ;
        var i : int ; i := 0 ; while i < an do ( (     var temp : String ; temp := BR.readLine() ;
     var temparr : Sequence(String) ; temparr := temp->split("\\s+") ;
    var tv : int ; tv := (temparr[0+1])->toInteger() ;
    var tw : int ; tw := (temparr[1+1])->toInteger() ;
    values[i+1] := tv ; 
    weights[i+1] := tw ; 
 )  ;     i := i + 1 ) ; 
    var Vtable : Sequence(Sequence(int)) ; Vtable := Integer.subrange(1,an + 1)->collect(Integer.subrange(1,mw + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i < an + 1 do ( (         var j : int ; j := 1 ; while j < mw + 1 do ( (     if (j < weights[i - 1+1]) then (     Vtable[i+1][j+1] := Vtable[i - 1+1][j+1] ) else (     Vtable[i+1][j+1] := Set{Vtable[i - 1+1][j - weights[i - 1+1]+1] + values[i - 1+1], Vtable[i - 1+1][j+1]}->max() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Vtable[an+1][mw+1]) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int i,j,n,w ;
    int[] v,vv ;
    int[][] dp ;
    n=sc.nextInt();
    w=sc.nextInt();
    v=new int[n];
    vv=new int[n];
    dp=new int[n+1][w+1];
    for(i=0 ; i<n ; i++){
      v[i]=sc.nextInt();
      vv[i]=sc.nextInt();
    }
    for(i=0 ; i<n ; i++)for(j=0 ; j<=w ; j++){
      if(dp[i+1][j]<dp[i][j])dp[i+1][j]=dp[i][j];
      if(j+vv[i]<=w && dp[i][j]+v[i]>dp[i+1][j+vv[i] ])dp[i+1][j+vv[i] ]=dp[i][j]+v[i];
    }
    out.println(dp[n][w]);
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var i : int ;
    var j : int ;
    var n : int ;
    var w : int ;
    var v : Sequence(int) ;
    var vv : Sequence(int) ;
    var dp : Sequence(Sequence(int)) ;
    n := sc.nextInt() ; 
    w := sc.nextInt() ; 
    v := Integer.subrange(1,n)->collect(0) ; 
    vv := Integer.subrange(1,n)->collect(0) ; 
    dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,w + 1)->collect(0)) ; 
        i := 0 ; while i < n do ( (     v[i+1] := sc.nextInt() ; 
     vv[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do (         j := 0 ; while j <= w do ( (     if (dp[i + 1+1][j+1] < dp[i+1][j+1]) then     dp[i + 1+1][j+1] := dp[i+1][j+1] ; else skip ; 
     if (j + vv[i+1] <= w & dp[i+1][j+1] + v[i+1] > dp[i + 1+1][j + vv[i+1]+1]) then     dp[i + 1+1][j + vv[i+1]+1] := dp[i+1][j+1] + v[i+1] ; else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    out.println(dp[n+1][w+1]) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=10 ;
  static int lcs(int[][][] dp,int[] arr1,int n,int[] arr2,int m,int k){
    if(k<0)return-10000000 ;
    if(n<0 || m<0)return 0 ;
    int ans=dp[n][m][k];
    if(ans!=-1)return ans ;
    try {
      ans=Math.max(lcs(dp,arr1,n-1,arr2,m,k),lcs(dp,arr1,n,arr2,m-1,k));
      if(arr1[n-1]==arr2[m-1])ans=Math.max(ans,1+lcs(dp,arr1,n-1,arr2,m-1,k));
      ans=Math.max(ans,1+lcs(dp,arr1,n-1,arr2,m-1,k-1));
    }
    catch(Exception e){
    }
    return ans ;
  }
  public static void main(String[] args){
    int k=1 ;
    int[] arr1={
      1,2,3,4,5 };
      int[] arr2={
        5,3,1,4,2 };
        int n=arr1.length ;
        int m=arr2.length ;
        int[][][] dp=new int[MAX][MAX][MAX];
        for(int i=0 ; i<MAX ; i++)for(int j=0 ; j<MAX ; j++)for(int l=0 ; l<MAX ; l++)dp[i][j][l]=-1 ;
        System.out.println(lcs(dp,arr1,n,arr2,m,k));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 10;
  static   operation lcs( dp : Sequence(Sequence(Sequence(int))), arr1 : Sequence(int), n : int, arr2 : Sequence(int), m : int, k : int) : int
  pre: true
  post: true
  activity: (     if (k < 0) then     return -10000000 else skip ; 
     if (n < 0 or m < 0) then     return 0 else skip ; 
    var ans : int ; ans := dp[n+1][m+1][k+1] ;
    if (ans /= -1) then     return ans else skip ; 
    try (     ans := Set{lcs(dp, arr1, n - 1, arr2, m, k), lcs(dp, arr1, n, arr2, m - 1, k)}->max() ; 
     if (arr1[n - 1+1] = arr2[m - 1+1]) then     ans := Set{ans, 1 + lcs(dp, arr1, n - 1, arr2, m - 1, k)}->max() ; else skip ; 
     ans := Set{ans, 1 + lcs(dp, arr1, n - 1, arr2, m - 1, k - 1)}->max() )   catch (e : ProgramException) do skip
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 1 ;
     var arr1 : Sequence(int) ; arr1 := Sequence{1,2,3,4,5} ;
    var arr2 : Sequence(int) ; arr2 := Sequence{5,3,1,4,2} ;
    var n : int ; n := arr1->size() ;
    var m : int ; m := arr2->size() ;
    var dp : Sequence(Sequence(Sequence(int))) ; dp := Integer.subrange(1,MAX)->collect(Integer.subrange(1,MAX)->collect(Integer.subrange(1,MAX)->collect(0))) ;
        var i : int ; i := 0 ; while i < MAX do (         var j : int ; j := 0 ; while j < MAX do (         var l : int ; l := 0 ; while l < MAX do (     dp[i+1][j+1][l+1] := -1 ;  ;     l := l + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(lcs(dp, arr1, n, arr2, m, k)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int reverse(int n){
    int d=0,s=0 ;
    while(n>0){
      d=n % 10 ;
      s=s*10+d ;
      n=n/10 ;
    }
    return s ;
  }
  static boolean isPalin(int n){
    return n==reverse(n);
  }
  static int sumOfArray(int[] arr,int n){
    int s=0 ;
    for(int i=0 ; i<n ; i++){
      if((arr[i]>10)&& isPalin(arr[i])){
        s+=arr[i];
      }
    }
    return s ;
  }
  public static void main(String[] args){
    int n=6 ;
    int[] arr={
      12,313,11,44,9,1 };
      System.out.println(sumOfArray(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation reverse( n : int) : int
  pre: true
  post: true
  activity: (     var d : int ; d := 0 ;
    var s : int ; s := 0 ;
     while (n > 0) do (     d := n mod 10 ; 
     s := s * 10 + d ; 
     n := n / 10 ) ; 
     return s );
  static   operation isPalin( n : int) : boolean
  pre: true
  post: true
  activity: (     return n = reverse(n) );
  static   operation sumOfArray( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var s : int ; s := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if ((arr[i+1] > 10) & isPalin(arr[i+1])) then (     s := s+(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
     return s );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     var arr : Sequence(int) ; arr := Sequence{12,313,11,44,9,1} ;
     OclFile["System.out"].println(sumOfArray(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int assignValue(int a,int b,int x){
    int arr[]={
      a,b };
      return(arr[x]);
    }
    public static void main(String[] args){
      int y=assignValue(3,7,0);
      System.out.println(y);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation assignValue( a : int, b : int, x : int) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{a,b} ;
     return (arr[x+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var y : int ; y := assignValue(3, 7, 0) ;
     OclFile["System.out"].println(y) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector ;
class Test {
  static void printDivisors(int n){
    Vector<Integer>v=new Vector<>();
    for(int i=1 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        if(n/i==i)System.out.printf("%d ",i);
        else {
          System.out.printf("%d ",i);
          v.add(n/i);
        }
      }
    }
    for(int i=v.size()-1 ; i>=0 ; i--)System.out.printf("%d ",v.get(i));
  }
  public static void main(String args[]){
    System.out.println("The divisors of 100 are: ");
    printDivisors(100);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation printDivisors( n : int) : void
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Sequence{} ;
         var i : int ; i := 1 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     if (n / i = i) then     OclFile["System.out"].printf("%d ", i) ; else (     OclFile["System.out"].printf("%d ", i) ; 
     v := v->including(n / i) ) ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := v->size() - 1 ; while i >= 0 do (     OclFile["System.out"].printf("%d ", v->at(i+1)) ;  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("The divisors of 100 are: ") ; 
     execute printDivisors(100) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long n,d ;
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int t=1 ; t<=test ; t++){
      n=in.nextInt();
      d=in.nextInt();
      long min=bs(0,n);
      pw.println(min<=n ? "YES" : "NO");
    }
    pw.close();
  }
  static long bs(long l,long r){
    long mid,res=cal(l);
    while(l<=r){
      mid=(l+r)/2 ;
      if(cal(mid)<res){
        res=cal(mid);
        l=mid+1 ;
      }
      else {
        r=mid-1 ;
      }
    }
    return res ;
  }
  static long cal(long x){
    return x+(d/(x+1))+(d %(x+1)!=0 ? 1 : 0);
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= test do ( (     n := in.getCurrent()->toInteger() ; 
     d := in.getCurrent()->toInteger() ; 
     var min : long ; min := bs(0, n) ;
     skip )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation bs( l : long, r : long) : long
  pre: true
  post: true
  activity: (     var mid : long ;
    var res : long ; res := cal(l) ;
     while (l <= r) do (     mid := (l + r) / 2 ; 
     if (cal(mid) < res) then (     res := cal(mid) ; 
     l := mid + 1 ) else (     r := mid - 1 ) ) ; 
     return res );
  static   operation cal( x : long) : long
  pre: true
  post: true
  activity: (     return x + (d / (x + 1)) + (if d mod (x + 1) /= 0 then 1 else 0 endif) );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean divisibleBy3(String number){
    int sumOfDigit=0 ;
    for(int i=0 ; i<number.length(); i++)sumOfDigit+=number.charAt(i)-'0' ;
    if(sumOfDigit % 3==0)return true ;
    return false ;
  }
  static boolean divisibleBy25(String number){
    if(number.length()<2)return false ;
    int length=number.length();
    int lastTwo=(number.charAt(length-2)-'0')*10+(number.charAt(length-1)-'0');
    if(lastTwo % 25==0)return true ;
    return false ;
  }
  static boolean divisibleBy75(String number){
    if(divisibleBy3(number)&& divisibleBy25(number))return true ;
    return false ;
  }
  public static void main(String[] args){
    String number="754586672150" ;
    boolean divisible=divisibleBy75(number);
    if(divisible)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation divisibleBy3( number : String) : boolean
  pre: true
  post: true
  activity: (     var sumOfDigit : int ; sumOfDigit := 0 ;
         var i : int ; i := 0 ; while i < number->size() do (     sumOfDigit := sumOfDigit+(number->at(i+1) - ('0')->char2byte()) ;  ;     i := i + 1 ) ; 
     if (sumOfDigit mod 3 = 0) then     return true else skip ; 
     return false );
  static   operation divisibleBy25( number : String) : boolean
  pre: true
  post: true
  activity: (     if (number->size() < 2) then     return false else skip ; 
     var length : int ; length := number->size() ;
    var lastTwo : int ; lastTwo := (number->at(length - 2+1) - ('0')->char2byte()) * 10 + (number->at(length - 1+1) - ('0')->char2byte()) ;
    if (lastTwo mod 25 = 0) then     return true else skip ; 
    return false 
 );
  static   operation divisibleBy75( number : String) : boolean
  pre: true
  post: true
  activity: (     if (divisibleBy3(number) & divisibleBy25(number)) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var number : String ; number := "754586672150" ;
     var divisible : boolean ; divisible := divisibleBy75(number) ;
     if (divisible) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] num ;
    int sum ;
    do {
      sum=0 ;
      num=br.readLine().split("");
      for(String str : num)sum+=Integer.valueOf(str);
      if(sum==0)break ;
      System.out.println(sum);
    }
    while(true);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var num : Sequence(String) ;
     var sum : int ;
   while true do ((     sum := 0 ; 
     num := br.readLine()->split("") ; 
    for (str : num) do (     sum := sum+((str)->toInteger()) ;  ) ; 
    if (sum = 0) then     break else skip ; 
    OclFile["System.out"].println(sum) ; 
 ) ;
    if (true) then skip else break) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastReader f=new FastReader();
    while(true){
      String line=f.nextLine();
      int lineTemp=0 ;
      if(line.equals("0"))break ;
      for(char ch : line.toCharArray()){
        lineTemp+=Integer.parseInt(String.valueOf(ch));
      }
      System.out.println(lineTemp);
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : FastReader ; f := FastReader.newFastReader() ;
     while (true) do (     var line : String ; line := f.nextLine() ;
     var lineTemp : int ; lineTemp := 0 ;
    if (line = "0") then     break else skip ; 
    for (ch : line->characters()) do ( (     lineTemp := lineTemp+((((ch) + ""))->toInteger()) )  ) ; 
    OclFile["System.out"].println(lineTemp) ; 
 ) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static boolean EqualNumber(int A,int B){
    if((A ^ B)!=0)return true ;
    else return false ;
  }
  public static void main(String args[]){
    int A=5,B=6 ;
    if(EqualNumber(A,B)==false)System.out.println(1);
    else System.out.println(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation EqualNumber( A : int, B : int) : boolean
  pre: true
  post: true
  activity: (     if ((A xor B) /= 0) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 5 ;
    var B : int ; B := 6 ;
     if (EqualNumber(A, B) = false) then     OclFile["System.out"].println(1) ; else     OclFile["System.out"].println(0) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner scan=new Scanner(System.in);
  public static void main(String[] args){
    for(; scan.hasNext(); ){
      int sum=0 ;
      char[] swap=scan.nextLine().toCharArray();
      for(int i=0 ; i<swap.length ; i++){
        sum=sum+Character.getNumericValue(swap[i]);
      }
      if(sum!=0){
        System.out.println(sum);
      }
      else {
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (       while scan.hasNext() do ( (     var sum : int ; sum := 0 ;
     var swap : Sequence(String) ; swap := scan.nextLine()->characters() ;
         var i : int ; i := 0 ; while i < swap->size() do ( (     sum := sum + ("" + swap[i+1])->toInteger() )  ;     i := i + 1 ) ; 
     if (sum /= 0) then (     OclFile["System.out"].println(sum) ) else (     break ) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.text.DecimalFormat ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    double N=scan.nextDouble();
    double d=scan.nextDouble();
    double x=scan.nextDouble();
    BigDecimal ans=new BigDecimal("0.0");
    while(N>0.5){
      BigDecimal adnum=BigDecimal.valueOf(d+x*(N-0.5));
      ans=ans.add(adnum);
      d=(N+1.0)*d/N+(5.0*x)/(2.0*N);
      x=(1.0+(2.0/N))*x ;
--N ;
    }
    DecimalFormat format=new DecimalFormat("#.#");
    format.setMinimumFractionDigits(20);
    System.out.println(format.format(ans));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : double ; N := scan.getCurrent()->toReal() ;
    var d : double ; d := scan.getCurrent()->toReal() ;
    var x : double ; x := scan.getCurrent()->toReal() ;
    var ans : double ; ans := double("0.0") ;
    while (N > 0.5) do (     var adnum : double ; adnum := (d + x * (N - 0.5) + "")->toReal() ;
     ans := ans->excludes(adnum) ; 
    d := (N + 1.0) * d / N + (5.0 * x) / (2.0 * N) ; 
    x := (1.0 + (2.0 / N)) * x ; 
    N := N - 1 ; 
 ) ; 
    var format : DecimalFormat ; format := DecimalFormat.newDecimalFormat("#.#") ;
    format.setMinimumFractionDigits(20) ; 
    OclFile["System.out"].println(format.format(ans)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class Main {
  public static final String EOL=System.getProperty("line.separator");
  public void exec()throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    while(true){
      String l=br.readLine();
      if(l.equals("0"))break ;
      int sum=0 ;
      for(char c : l.toCharArray()){
        sum+=c ;
      }
      out.println(sum-('0'*l.length()));
    }
    out.flush();
  }
  public static void main(String[] args)throws IOException {
    new Main().exec();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute EOL : String := OclProcess.getEnvironmentProperty("line.separator");
   operation exec() : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     while (true) do (     var l : String ; l := br.readLine() ;
     if (l = "0") then     break else skip ; 
    var sum : int ; sum := 0 ;
    for (c : l->characters()) do ( (     sum := sum+(c) )  ) ; 
    skip ; 
 ) ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().exec() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayList<String>lines=new ArrayList<String>();
    int c=0 ;
    while(true){
      String next=sc.nextLine();
      if(next.equals("0")){
        break ;
      }
      lines.add(next);
      c++;
    }
    for(int i=0 ; i<c ; i++){
      String s=lines.get(i);
      int sum=0 ;
      for(int j=0 ; j<s.length(); j++){
        int in=Integer.parseInt(s.substring(j,j+1));
        sum+=in ;
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var lines : Sequence(String) ; lines := Sequence{} ;
    var c : int ; c := 0 ;
    while (true) do (     var next : String ; next := sc.nextLine() ;
     if (next = "0") then (     break ) else skip ; 
     lines := lines->including(next) ; 
     c := c + 1 ) ; 
        var i : int ; i := 0 ; while i < c do ( (     var s : String ; s := lines->at(i+1) ;
     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < s->size() do ( (     var in : int ; in := (s.subrange(j+1,j + 1))->toInteger() ;
     sum := sum+(in) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(sum) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static int Modulo(int a,char b[]){
    int mod=0 ;
    for(int i=0 ; i<b.length ; i++)mod=(mod*10+b[i]-'0')% a ;
    return mod ;
  }
  static int LastDigit(char a[],char b[]){
    int len_a=a.length,len_b=b.length ;
    if(len_a==1 && len_b==1 && b[0]=='0' && a[0]=='0')return 1 ;
    if(len_b==1 && b[0]=='0')return 1 ;
    if(len_a==1 && a[0]=='0')return 0 ;
    int exp=(Modulo(4,b)==0)? 4 : Modulo(4,b);
    int res=(int)(Math.pow(a[len_a-1]-'0',exp));
    return res % 10 ;
  }
  public static void main(String args[])throws IOException {
    char a[]="117".toCharArray(),b[]={
      '3' };
      System.out.println(LastDigit(a,b));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Modulo( a : int, b : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var mod : int ; mod := 0 ;
         var i : int ; i := 0 ; while i < b->size() do (     mod := (mod * 10 + b[i+1] - ('0')->char2byte()) mod a ;  ;     i := i + 1 ) ; 
     return mod );
  static   operation LastDigit( a : Sequence(String), b : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var len_a : int ; len_a := a->size() ;
    var len_b : int ; len_b := b->size() ;
     if (len_a = 1 & len_b = 1 & b[0+1] = '0' & a[0+1] = '0') then     return 1 else skip ; 
    if (len_b = 1 & b[0+1] = '0') then     return 1 else skip ; 
    if (len_a = 1 & a[0+1] = '0') then     return 0 else skip ; 
    var exp : int ; exp := if (Modulo(4, b) = 0) then 4 else Modulo(4, b) endif ;
    var res : int ; res := (a[len_a - 1+1] - ('0')->char2byte()->pow(exp))->oclAsType(int) ;
    return res mod 10 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := "117"->characters() ;
    var b : Sequence(void) ; b := Sequence{'3'} ;
     OclFile["System.out"].println(LastDigit(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  public static void main(String args[]){
    double r=3 ;
    double R=7 ;
    float pi=(float)3.14159 ;
    double Volume=0 ;
    Volume=2*pi*pi*R*r*r ;
    System.out.printf("Volume: %f",Volume);
    double Surface=4*pi*pi*R*r ;
    System.out.printf("\nSurface: %f",Surface);
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : double ; r := 3 ;
     var R : double ; R := 7 ;
    var pi : double ; pi := 3.14159->oclAsType(double) ;
    var Volume : double ; Volume := 0 ;
    Volume := 2 * pi * pi * R * r * r ; 
    OclFile["System.out"].printf("Volume: %f", Volume) ; 
    var Surface : double ; Surface := 4 * pi * pi * R * r ;
    OclFile["System.out"].printf("\nSurface: %f", Surface) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int p=sc.nextInt();
    int q=sc.nextInt();
    double r=sc.nextInt();
    int dis=b*p-(b-a)*q ;
    System.out.println(dis/(q+r)+b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var r : double ; r := sc.getCurrent()->toInteger() ;
    var dis : int ; dis := b * p - (b - a) * q ;
    OclFile["System.out"].println(dis / (q + r) + b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double a=sc.nextInt();
    double b=sc.nextInt();
    double p=sc.nextInt();
    double q=sc.nextInt();
    double r=sc.nextInt();
    if(a>b){
      System.out.println((b*p+q*(a-b))/(q+r)+b);
    }
    else {
      System.out.println((b*p-q*(b-a))/(q+r)+b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : double ; a := sc.getCurrent()->toInteger() ;
    var b : double ; b := sc.getCurrent()->toInteger() ;
    var p : double ; p := sc.getCurrent()->toInteger() ;
    var q : double ; q := sc.getCurrent()->toInteger() ;
    var r : double ; r := sc.getCurrent()->toInteger() ;
    if (a > b) then (     OclFile["System.out"].println((b * p + q * (a - b)) / (q + r) + b) ) else (     OclFile["System.out"].println((b * p - q * (b - a)) / (q + r) + b) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    long[] sum=new long[N];
    long[] a=new long[N];
    long[] abssum=new long[N+1];
    List<Integer>minusIndex=new ArrayList<>();
    for(int i=0 ; i<N ; ++i){
      if(i==0){
        a[i]=scan.nextLong();
        sum[i]=a[i];
      }
      else {
        boolean minus=(scan.next().equals("-"));
        a[i]=scan.nextLong();
        sum[i]=sum[i-1]+a[i]*(minus ?-1 : 1);
        if(minus)minusIndex.add(i-1);
      }
    }
    for(int i=N-1 ; i>=0 ; --i)abssum[i]=abssum[i+1]+a[i];
    long ans=sum[N-1];
    for(int i=0 ; i<minusIndex.size()-1 ; ++i){
      ans=Math.max(ans,sum[minusIndex.get(i)]-abssum[minusIndex.get(i)+1]+2*abssum[minusIndex.get(i+1)+1]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var sum : Sequence(long) ; sum := Integer.subrange(1,N)->collect(0) ;
    var a : Sequence(long) ; a := Integer.subrange(1,N)->collect(0) ;
    var abssum : Sequence(long) ; abssum := Integer.subrange(1,N + 1)->collect(0) ;
    var minusIndex : Sequence(int) ; minusIndex := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     if (i = 0) then (     a[i+1] := scan.getCurrent()->toLong() ; 
     sum[i+1] := a[i+1] ) else (     var minus : boolean ; minus := (scan.getCurrent() = "-") ;
     a[i+1] := scan.getCurrent()->toLong() ; 
     sum[i+1] := sum[i - 1+1] + a[i+1] * (if minus then -1 else 1 endif) ; 
     if (minus) then     minusIndex := minusIndex->including(i - 1) ; else skip ) )  ;     i := i + 1 ) ; 
        var i : int ; i := N - 1 ; while i >= 0 do (     abssum[i+1] := abssum[i + 1+1] + a[i+1] ;  ;     i := i - 1 ) ; 
    var ans : long ; ans := sum[N - 1+1] ;
        var i : int ; i := 0 ; while i < minusIndex->size() - 1 do ( (     ans := Set{ans, sum[minusIndex->at(i+1)+1] - abssum[minusIndex->at(i+1) + 1+1] + 2 * abssum[minusIndex->at(i + 1+1) + 1+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  private void solve()throws IOException {
    int n=nextInt();
    long[] a=new long[n];
    char[] c=new char[n];
    c[0]='+' ;
    for(int i=0 ; i<n ; i++){
      if(i>0){
        c[i]=next().charAt(0);
      }
      a[i]=nextInt();
    }
    long s=0 ;
    long ss=0 ;
    long ans=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(c[i]=='+'){
        s+=a[i];
      }
      else {
        ans=Math.max(-a[i]+s+ans,-a[i]-s+ss);
        ss+=s+a[i];
        s=0 ;
      }
    }
    ans+=s ;
    out.println(ans);
  }
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer st ;
  PrintWriter out=new PrintWriter(System.out);
  String next()throws IOException {
    while(st==null || ! st.hasMoreTokens()){
      st=new StringTokenizer(br.readLine());
    }
    return st.nextToken();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    solve();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(String) ; c := Integer.subrange(1,n)->collect(0) ;
    c[0+1] := '+' ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i > 0) then (     c[i+1] := next()->at(0+1) ) else skip ; 
     a[i+1] := nextInt() )  ;     i := i + 1 ) ; 
    var s : long ; s := 0 ;
    var ss : long ; ss := 0 ;
    var ans : long ; ans := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (c[i+1] = '+') then (     s := s+(a[i+1]) ) else (     ans := Set{-a[i+1] + s + ans, -a[i+1] - s + ss}->max() ; 
     ss := ss+(s + a[i+1]) ; 
     s := 0 ) )  ;     i := i - 1 ) ; 
    ans := ans+(s) ; 
    out.println(ans) ; 
 );
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator;
   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     execute solve() ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CF_Round_264B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int s=sc.nextInt();
    int[] arr=new int[s];
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=sc.nextInt();
    }
    solve(arr);
  }
  public static void solve(int[] arr){
    int peak=0 ;
    int currentEnergy=0 ;
    for(int i=1 ; i<arr.length ; i++){
      currentEnergy+=arr[i-1]-arr[i];
      if(currentEnergy<0){
        peak=Math.min(currentEnergy,peak);
      }
    }
    int res=arr[0]-peak ;
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF_Round{
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : int ; s := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,s)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute solve(arr) ; 
 );
  static   operation solve( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var peak : int ; peak := 0 ;
     var currentEnergy : int ; currentEnergy := 0 ;
        var i : int ; i := 1 ; while i < arr->size() do ( (     currentEnergy := currentEnergy+(arr[i - 1+1] - arr[i+1]) ; 
     if (currentEnergy < 0) then (     peak := Set{currentEnergy, peak}->min() ) else skip )  ;     i := i + 1 ) ; 
    var res : int ; res := arr[0+1] - peak ;
    OclFile["System.out"].println(res) ; 
 );
}
64B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : int ; s := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,s)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute solve(arr) ; 
 );
  static   operation solve( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var peak : int ; peak := 0 ;
     var currentEnergy : int ; currentEnergy := 0 ;
        var i : int ; i := 1 ; while i < arr->size() do ( (     currentEnergy := currentEnergy+(arr[i - 1+1] - arr[i+1]) ; 
     if (currentEnergy < 0) then (     peak := Set{currentEnergy, peak}->min() ) else skip )  ;     i := i + 1 ) ; 
    var res : int ; res := arr[0+1] - peak ;
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    while(true){
      String in=s.next();
      if(in.equals("#"))System.exit(0);
      String[] str=in.split("\\|");
      boolean ok=false ;
      for(int i=0 ; i<str.length ; i++){
        String now=str[i] .substring(1,str[i] .length()-1);
        String tmp[]=now.split("\\&");
        boolean OK=true ;
        for(int j=0 ; j<tmp.length ; j++)for(int k=0 ; k<tmp.length ; k++){
          if(tmp[k] .equals("~"+tmp[j]))OK=false ;
        }
        if(OK)ok=true ;
      }
      if(ok)System.out.println("yes");
      else System.out.println("no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var in : String ; in := s.getCurrent() ;
     if (in = "#") then OclProcess.exit(0) ; else skip ; 
    var str : Sequence(String) ; str := in->split("\\|") ;
    var ok : boolean ; ok := false ;
        var i : int ; i := 0 ; while i < str->size() do ( (     var now : String ; now := str[i+1].subrange(1+1,str[i+1]->size() - 1) ;
     var tmp : Sequence(String) ; tmp := now->split("\\&") ;
    var OK : boolean ; OK := true ;
        var j : int ; j := 0 ; while j < tmp->size() do (         var k : int ; k := 0 ; while k < tmp->size() do ( (     if (tmp[k+1] = "~" + tmp[j+1]) then     OK := false ; else skip )  ;     k := k + 1 ) ;  ;     j := j + 1 ) ; 
    if (OK) then     ok := true ; else skip ; 
 )  ;     i := i + 1 ) ; 
    if (ok) then     OclFile["System.out"].println("yes") else     OclFile["System.out"].println("no") ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int N=3 ;
  static int MaxTraceSub(int mat[][]){
    int max_trace=0 ;
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        int r=i,s=j,trace=0 ;
        while(r<N && s<N){
          trace+=mat[r][s];
          r++;
          s++;
          max_trace=Math.max(trace,max_trace);
        }
      }
    }
    return max_trace ;
  }
  public static void main(String[] args){
    int mat[][]={
      {
        10,2,5 },{
          6,10,4 },{
            2,7,-10 }
          };
          System.out.println(MaxTraceSub(mat));
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 3;
  static   operation MaxTraceSub( mat : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var max_trace : int ; max_trace := 0 ;
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     var r : int ; r := i ;
    var s : int ; s := j ;
    var trace : int ; trace := 0 ;
     while (r < N & s < N) do (     trace := trace+(mat[r+1][s+1]) ; 
     r := r + 1 ; 
     s := s + 1 ; 
     max_trace := Set{trace, max_trace}->max() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return max_trace );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{10,2,5},Sequence{6,10,4},Sequence{2,7,-10}} ;
     OclFile["System.out"].println(MaxTraceSub(mat)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.BigInteger ;
public class Main {
  static long[] list=new long[87];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String nyuA=sc.nextLine();
    int N=Integer.parseInt(nyuA);
    TreeSet<Integer>list=new TreeSet<>();
    for(int i=0 ; i<N ; i++){
      list.add(Integer.parseInt(sc.nextLine()));
    }
    ArrayList<Integer>set=new ArrayList<>(list);
    System.out.println(set.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute list : Sequence(long) := Integer.subrange(1,87)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var nyuA : String ; nyuA := sc.nextLine() ;
    var N : int ; N := (nyuA)->toInteger() ;
    var list : Set(int) ; list := Set{} ;
        var i : int ; i := 0 ; while i < N do ( (     list := list->including((sc.nextLine())->toInteger()) )  ;     i := i + 1 ) ; 
    var set : Sequence(int) ; set := Sequence{}->union(list) ;
    OclFile["System.out"].println(set->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Scanner ;
import java.util.concurrent.SynchronousQueue ;
public class Main {
  public static void main(String[] args){
    new Main().solve();
  }
  void solve(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int d=sc.nextInt();
    int x=sc.nextInt();
    double[] F=new double[200001];
    double[] G=new double[200001];
    {
      Arrays.fill(F,-1);
      Arrays.fill(G,-1);
    }
    F[1]=0.5 ;
    G[1]=1 ;
    for(int i=2 ; i<=200000 ; ++i){
      F[i]=(1+2./i)*F[i-1]+5./(2*i)*G[i-1]+1./(2*i)*i*(2*i-1);
      G[i]=(1+1./i)*G[i-1]+1 ;
    }
    System.out.println(String.format("%.20f",F[n]*x+d*G[n]));
  }
  public static void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var F : Sequence(double) ; F := Integer.subrange(1,200001)->collect(0.0) ;
    var G : Sequence(double) ; G := Integer.subrange(1,200001)->collect(0.0) ;
(     F := F->collect(-1) ; 
     G := G->collect(-1) ) 
    F[1+1] := 0.5 ; 
    G[1+1] := 1 ; 
        var i : int ; i := 2 ; while i <= 200000 do ( (     F[i+1] := (1 + 2. / i) * F[i - 1+1] + 5. / (2 * i) * G[i - 1+1] + 1. / (2 * i) * i * (2 * i - 1) ; 
     G[i+1] := (1 + 1. / i) * G[i - 1+1] + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(StringLib.format("%.20f",Sequence{F[n+1] * x + d * G[n+1]})) ; 
 );
  static   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] h=new int[n];
    int temp=0 ;
    for(int i=0 ; i<n ; i++){
      h[i]=in.nextInt();
      if(h[i]>temp){
        temp=h[i];
      }
    }
    System.out.println(temp);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var h : Sequence(int) ; h := Integer.subrange(1,n)->collect(0) ;
    var temp : int ; temp := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     h[i+1] := in.getCurrent()->toInteger() ; 
     if (h[i+1] > temp) then (     temp := h[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(temp) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    int ans=arr[0];
    int curr=0 ;
    for(int i=0 ; i<n-1 ; i++){
      curr+=arr[i]-arr[i+1];
      if(curr<0){
        ans+=Math.abs(curr);
        curr=0 ;
      }
    }
    System.out.println(ans);
  }
}
class Sort implements Comparator<Pair>{
  public int compare(Pair a,Pair b){
    return b.b-a.b ;
  }
}
class Pair {
  int a ;
  int b ;
  public Pair(int a,int b){
    this.a=a ;
    this.b=b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := arr[0+1] ;
    var curr : int ; curr := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     curr := curr+(arr[i+1] - arr[i + 1+1]) ; 
     if (curr < 0) then (     ans := ans+(if curr < 0 then -(curr) else curr endif) ; 
     curr := 0 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}
class Sort implements Function(<Map>,(<Map>,boolean)) {
   operation compare( a : Map, b : Map) : int
  pre: true
  post: true
  activity: (     return b.b - a.b );
}
class Pair {
   attribute a : int;
   attribute b : int;
   static operation newPair( a : int, b : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
import java.util.Vector ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=input.nextInt();
    int count=arr[0];
    for(int i=1 ; i<n ; i++){
      if(arr[i-1]<arr[i])count+=arr[i]-arr[i-1];
      else if(arr[i-1]>arr[i])arr[i]+=arr[i-1]-arr[i];
      else continue ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := input.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var count : int ; count := arr[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     if (arr[i - 1+1] < arr[i+1]) then     count := count+(arr[i+1] - arr[i - 1+1]) ; else     if (arr[i - 1+1] > arr[i+1]) then     arr[i+1] := arr[i+1]+(arr[i - 1+1] - arr[i+1]) else     continue ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n+1];
    arr[0]=0 ;
    int ans=0 ;
    int energy=0 ;
    for(int i=1 ; i<=n ; i++){
      arr[i]=sc.nextInt();
      energy+=arr[i-1]-arr[i];
      if(energy<0){
        ans-=energy ;
        energy=0 ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
    arr[0+1] := 0 ; 
    var ans : int ; ans := 0 ;
    var energy : int ; energy := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     energy := energy+(arr[i - 1+1] - arr[i+1]) ; 
     if (energy < 0) then (     ans := ans-(energy) ; 
     energy := 0 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1047A_LittelCLoves3 {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    final int num=input.nextInt();
    int a=1 ;
    int b=1 ;
    int c=num-2 ;
    if(c % 3==0){
      c--;
      a++;
    }
    System.out.println(String.format("%d %d %d",a,b,c));
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1047A_LittelCLoves3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := input.getCurrent()->toInteger() ;
    var a : int ; a := 1 ;
    var b : int ; b := 1 ;
    var c : int ; c := num - 2 ;
    if (c mod 3 = 0) then (     c := c - 1 ; 
     a := a + 1 ) else skip ; 
    OclFile["System.out"].println(StringLib.format("%d %d %d",Sequence{a,b,c})) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class HelloWorld {
  public static void solve(int n,int m,int k){
    System.out.println((n<=m && n<=k ? "Yes" : "No"));
  }
  public static void sol(int n){
    int ans=0 ;
    for(int i=1 ; i<n ; ++i){
      if(n % i==0){
        ans++;
      }
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if((n-2)% 3==0){
      System.out.println("1 2 "+(n-3));
    }
    else {
      System.out.println("1 1 "+(n-2));
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation solve( n : int, m : int, k : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((if n <= m & n <= k then "Yes" else "No" endif)) );
  static   operation sol( n : int) : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     if (n mod i = 0) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if ((n - 2) mod 3 = 0) then (     OclFile["System.out"].println("1 2 " + (n - 3)) ) else (     OclFile["System.out"].println("1 1 " + (n - 2)) ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B_Average_Sleep_Time {
  static Scanner in=new Scanner(System.in);
  static int n ;
  static double k ;
  static double a[];
  public static void main(String[] amit){
    n=in.nextInt();
    k=in.nextDouble();
    a=new double[n+1];
    for(int i=1 ; i<=n ; i++){
      a[i]=in.nextDouble();
    }
    if(n==1){
      System.out.printf("%.6f",a[1]);
      return ;
    }
    double prefix[]=new double[n+1];
    for(int i=1 ; i<=n ; i++){
      prefix[i]=prefix[i-1]+a[i];
    }
    double sum=0.0 ;
    double pair=0.0 ;
    for(int i=(int)k ; i<=n ; i++,pair++){
      sum+=(prefix[i]-prefix[i-(int)k]);
    }
    System.out.printf("%.6f",sum/pair);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Average_Sleep_Time {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   attribute k : double;
  static   attribute a : Sequence(double);
  static   operation main( amit : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := in.getCurrent()->toInteger() ; 
     k := in.getCurrent()->toReal() ; 
    a := Integer.subrange(1,n + 1)->collect(0.0) ; 
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := in.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
    if (n = 1) then (     OclFile["System.out"].printf("%.6f", a[1+1]) ; 
     return ) else skip ; 
    var prefix : Sequence(double) ; prefix := Integer.subrange(1,n + 1)->collect(0.0) ;
        var i : int ; i := 1 ; while i <= n do ( (     prefix[i+1] := prefix[i - 1+1] + a[i+1] )  ;     i := i + 1 ) ; 
    var sum : double ; sum := 0.0 ;
    var pair : double ; pair := 0.0 ;
        var i : int ; i := k->oclAsType(int) ; while i <= n do ( (     sum := sum+((prefix[i+1] - prefix[i - k->oclAsType(int)+1])) )  ;     i := i + 1 ;     pair := pair + 1 ) ; 
    OclFile["System.out"].printf("%.6f", sum / pair) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Locale ;
import java.util.Scanner ;
public class B808 {
  public static void main(String[] args){
    Locale.setDefault(Locale.US);
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int K=in.nextInt();
    double sum=0 ;
    for(int n=1 ; n<=N ; n++){
      int a=in.nextInt();
      double count=Math.min(Math.min(n,N+1-n),Math.min(K,N-K+1));
      sum+=a*count ;
    }
    sum/=N-K+1 ;
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B808 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.US) ; 
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    var sum : double ; sum := 0 ;
        var n : int ; n := 1 ; while n <= N do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var count : double ; count := Set{Set{n, N + 1 - n}->min(), Set{K, N - K + 1}->min()}->min() ;
     sum := sum+(a * count) )  ;     n := n + 1 ) ; 
    sum := sum/(N - K + 1) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean oppositeSigns(int x,int y){
    return((x ^ y)<0);
  }
  static void partitionNegPos(int arr[],int n){
    Vector<Integer>a=new Vector<Integer>();
    Vector<Integer>b=new Vector<Integer>();
    a.add(arr[0]);
    for(int i=1 ; i<n ; i++){
      if(oppositeSigns(a.get(0),arr[i]))b.add(arr[i]);
      else a.add(arr[i]);
    }
    for(int i=0 ; i<a.size(); i++)System.out.print(a.get(i)+" ");
    System.out.println("");
    for(int i=0 ; i<b.size(); i++)System.out.print(b.get(i)+" ");
  }
  public static void main(String[] args){
    int arr[]={
      1,-2,6,-7,8 };
      int n=arr.length ;
      partitionNegPos(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation oppositeSigns( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return ((x xor y) < 0) );
  static   operation partitionNegPos( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{} ;
     var b : Sequence(int) ; b := Sequence{} ;
    a := a->including(arr[0+1]) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (oppositeSigns(a->at(0+1), arr[i+1])) then     b := b->including(arr[i+1]) ; else     a := a->including(arr[i+1]) ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a->size() do (     OclFile["System.out"].print(a->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
        var i : int ; i := 0 ; while i < b->size() do (     OclFile["System.out"].print(b->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,-2,6,-7,8} ;
     var n : int ; n := arr->size() ;
     execute partitionNegPos(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Scanner ;
import java.util.concurrent.SynchronousQueue ;
public class Main {
  public static void main(String[] args){
    new Main().solve();
  }
  void solve(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int d=sc.nextInt();
    int x=sc.nextInt();
    double[] F=new double[200001];
    double[] G=new double[200001];
    {
      Arrays.fill(F,-1);
      Arrays.fill(G,-1);
    }
    F[1]=0.5 ;
    G[1]=1 ;
    for(int i=2 ; i<=200000 ; ++i){
      F[i]=(1+2./i)*F[i-1]+5./(2*i)*G[i-1]+1./(2*i)*i*(2*i-1);
      G[i]=(1+1d/i)*G[i-1]+1 ;
    }
    System.out.println(String.format("%.20f",F[n]*x+d*G[n]));
  }
  public static void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var F : Sequence(double) ; F := Integer.subrange(1,200001)->collect(0.0) ;
    var G : Sequence(double) ; G := Integer.subrange(1,200001)->collect(0.0) ;
(     F := F->collect(-1) ; 
     G := G->collect(-1) ) 
    F[1+1] := 0.5 ; 
    G[1+1] := 1 ; 
        var i : int ; i := 2 ; while i <= 200000 do ( (     F[i+1] := (1 + 2. / i) * F[i - 1+1] + 5. / (2 * i) * G[i - 1+1] + 1. / (2 * i) * i * (2 * i - 1) ; 
     G[i+1] := (1 + 1d / i) * G[i - 1+1] + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(StringLib.format("%.20f",Sequence{F[n+1] * x + d * G[n+1]})) ; 
 );
  static   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  private static char[] expr ;
  private static int ptr ;
  private static void consume(char c){
    assert expr[ptr]==c : "expected "+c+",but got "+expr[ptr];
    ptr++;
  }
  private static boolean expression(){
    do {
      consume('(');
      if(clause()){
        consume(')');
        return true ;
      }
      else {
        consume(')');
      }
    }
    while(ptr<expr.length && expr[ptr++]=='|');
    assert ptr==expr.length ;
    return false ;
  }
  private static boolean clause(){
    int[] assigments=new int['z'+1];
    boolean result=true ;
    do {
      if(! literal(assigments)){
        result=false ;
      }
    }
    while(expr[ptr++]=='&');
    ptr--;
    return result ;
  }
  private static boolean literal(int[] assigments){
    int x ;
    if(expr[ptr]=='~'){
      ptr++;
      x=1 ;
    }
    else {
      x=-1 ;
    }
    if(assigments[expr[ptr] ]==x){
      ptr++;
      return false ;
    }
    else {
      assigments[expr[ptr] ]=-1*x ;
      ptr++;
      return true ;
    }
  }
  private static void solve(){
    final Scanner scanner=new Scanner(System.in);
    while(true){
      String input=scanner.next();
      if(input.equals("#")){
        break ;
      }
      Main.ptr=0 ;
      Main.expr=input.toCharArray();
      System.out.println(expression()? "yes" : "no");
    }
  }
  public static void main(String...args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute expr : Sequence(String);
  static   attribute ptr : int;
  static   operation consume( c : String) : void
  pre: true
  post: true
  activity: (     assert expr[ptr+1] = c do "expected " + c + ",but got " + expr[ptr+1] ; 
     ptr := ptr + 1 );
  static   operation expression() : boolean
  pre: true
  post: true
  activity: (   while true do ((     execute consume('(') ; 
     if (clause()) then (     execute consume(')') ; 
     return true ) else (     execute consume(')') ) ) ;
    if (ptr < expr->size() & expr[ptr+1] = '|') then
      skip else break) ;  
     assert ptr = expr->size() ; 
     return false );
  static   operation clause() : boolean
  pre: true
  post: true
  activity: (     var assigments : Sequence(int) ; assigments := Integer.subrange(1,'z' + 1)->collect(0) ;
     var result : boolean ; result := true ;
  while true do ((     if (not(literal(assigments))) then (     result := false ) else skip ) ;
    if (expr[ptr+1] = '&') then
          skip ;     skip else break) ;  
    ptr := ptr - 1 ; 
    return result 
 );
  static   operation literal( assigments : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var x : int ;
     if (expr[ptr+1] = '~') then (     ptr := ptr + 1 ; 
     x := 1 ) else (     x := -1 ) ;  
     if (assigments[expr[ptr+1]+1] = x) then (     ptr := ptr + 1 ; 
     return false ) else (     assigments[expr[ptr+1]+1] := -1 * x ; 
     ptr := ptr + 1 ; 
     return true ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var input : String ; input := scanner.getCurrent() ;
     if (input = "#") then (     break ) else skip ; 
    Main.ptr := 0 ; 
    Main.expr := input->characters() ; 
    OclFile["System.out"].println(if expression() then "yes" else "no" endif) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Solve s=new Solve();
    s.solve();
  }
}
class Solve {
  Scanner in=new Scanner(System.in);
  void solve(){
    while(in.hasNext()){
      int n=in.nextInt();
      int ans=0,t=1 ;
      for(int i=0 ; i<n/2 ; i++){
        ans+=t ;
        t*=3 ;
      }
      ans*=2 ;
      if(n % 2==1)ans+=t ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Solve ; s := Solve.newSolve() ;
     s.solve() );
}
class Solve {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation solve() : void
  pre: true
  post: true
  activity: (     while (in.hasNext()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var ans : int ; ans := 0 ;
    var t : int ; t := 1 ;
        var i : int ; i := 0 ; while i < n / 2 do ( (     ans := ans+(t) ; 
     t := t*(3) )  ;     i := i + 1 ) ; 
    ans := ans*(2) ; 
    if (n mod 2 = 1) then     ans := ans+(t) ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args){
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
    try {
      String line ;
      while((line=r.readLine())!=null){
        int n=Integer.parseInt(line);
        if(n==1 || n==2){
          System.out.println(n);
          continue ;
        }
        int size=0,weight=4 ;
        if(n % 2==1){
          size=1 ;
          for(int i=3 ; i<=n ; i+=2){
            size+=weight ;
            weight*=3 ;
          }
        }
        else {
          size=2 ;
          weight=6 ;
          for(int i=4 ; i<=n ; i+=2){
            size+=weight ;
            weight*=3 ;
          }
        }
        System.out.println(size);
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var line : String ;
         line := r.readLine() ;
    while ((line) /= null) do (    skip ; (     var n : int ; n := (line)->toInteger() ;
     if (n = 1 or n = 2) then (     OclFile["System.out"].println(n) ; 
     continue ) else skip ; 
    var size : int ; size := 0 ;
    var weight : int ; weight := 4 ;
    if (n mod 2 = 1) then (     size := 1 ; 
         var i : int ; i := 3 ; while i <= n do ( (     size := size+(weight) ; 
     weight := weight*(3) )  ;     i := i+(2) ) ) else (     size := 2 ; 
     weight := 6 ; 
         var i : int ; i := 4 ; while i <= n do ( (     size := size+(weight) ; 
     weight := weight*(3) )  ;     i := i+(2) ) ) ;  
    OclFile["System.out"].println(size) ; 
 ) ;     line := r.readLine() ;
 ) )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int[] dp=new int[31];
    dp[1]=1 ;
    dp[2]=2 ;
    int sum=0 ;
    for(int i=3 ; i<=30 ; i+=2){
      sum+=Math.pow(3,(i-3)/2);
      dp[i]=1+4*sum ;
    }
    sum=0 ;
    for(int i=4 ; i<=30 ; i+=2){
      sum+=Math.pow(3,(i-4)/2);
      dp[i]=2+6*sum ;
    }
    while(sc.hasNext())System.out.println(dp[sc.nextInt()]);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dp : Sequence(int) ; dp := Integer.subrange(1,31)->collect(0) ;
    dp[1+1] := 1 ; 
    dp[2+1] := 2 ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 3 ; while i <= 30 do ( (     sum := sum+(3->pow((i - 3) / 2)) ; 
     dp[i+1] := 1 + 4 * sum )  ;     i := i+(2) ) ; 
    sum := 0 ; 
        var i : int ; i := 4 ; while i <= 30 do ( (     sum := sum+(3->pow((i - 4) / 2)) ; 
     dp[i+1] := 2 + 6 * sum )  ;     i := i+(2) ) ; 
    while (sc.hasNext()) do     OclFile["System.out"].println(dp[sc.getCurrent()->toInteger()+1]) ; ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String str ;
      while((str=br.readLine())!=null){
        int n=Integer.parseInt(str);
        calc(n);
      }
    }
    catch(Exception e){
    }
  }
  static void calc(int n){
    switch(n){
      case 0 : {
        System.out.println(0);
      }
      case 1 : {
        System.out.println(1);
        break ;
      }
      case 2 : {
        System.out.println(2);
        break ;
      }
      case 3 : {
        System.out.println(5);
        break ;
      }
      default : {
        if(n % 2==0){
          int m=n/2-1 ;
          int result=1 ;
          int edge=3 ;
          for(int i=0 ; i<m ; i++){
            result+=edge ;
            edge*=3 ;
          }
          System.out.println(result*2);
        }
        else {
          int m=(n-1)/2 ;
          int result=1 ;
          int edge=4 ;
          for(int i=0 ; i<m ; i++){
            result+=edge ;
            edge*=3 ;
          }
          System.out.println(result);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var str : String ;
         str := br.readLine() ;
    while ((str) /= null) do (    skip ; (     var n : int ; n := (str)->toInteger() ;
     execute calc(n) ) ;     str := br.readLine() ;
 ) )   catch (e : ProgramException) do skip
 );
  static   operation calc( n : int) : void
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (n) ; 
       if _switchval = 0 then
 (     OclFile["System.out"].println(0) ) 
   else skip ;
       if _switchval = 1 then
 (     OclFile["System.out"].println(1) ; 
     break ) 
   else skip ;
       if _switchval = 2 then
 (     OclFile["System.out"].println(2) ; 
     break ) 
   else skip ;
       if _switchval = 3 then
 (     OclFile["System.out"].println(5) ; 
     break ) 
   else skip ;
       if true then
 (     if (n mod 2 = 0) then (     var m : int ; m := n / 2 - 1 ;
     var result : int ; result := 1 ;
    var edge : int ; edge := 3 ;
        var i : int ; i := 0 ; while i < m do ( (     result := result+(edge) ; 
     edge := edge*(3) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result * 2) ; 
 ) else (     var m : int ; m := ((n)->char2byte() - 1) / 2 ;
     var result : int ; result := 1 ;
    var edge : int ; edge := 4 ;
        var i : int ; i := 0 ; while i < m do ( (     result := result+(edge) ; 
     edge := edge*(3) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ) ) 
   else skip ;
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String is ;
    while((is=in.readLine())!=null){
      int n=Integer.parseInt(is);
      if(n==0){
        System.out.println(0);
        continue ;
      }
      else if(n==1){
        System.out.println(1);
        continue ;
      }
      else if(n==2){
        System.out.println(2);
        continue ;
      }
      int c=2 ;
      int d=0 ;
      for(int i=2 ; i<n ; ++i){
        if(i % 2==0){
          d=d*3+1 ;
        }
        c+=d*2+1 ;
      }
      System.out.println(c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var is : String ;
         is := in.readLine() ;
    while ((is) /= null) do (    skip ; (     var n : int ; n := (is)->toInteger() ;
     if (n = 0) then (     OclFile["System.out"].println(0) ; 
     continue ) else     if (n = 1) then (     OclFile["System.out"].println(1) ; 
     continue ) else     if (n = 2) then (     OclFile["System.out"].println(2) ; 
     continue ) else skip ; ;  ;  
    var c : int ; c := 2 ;
    var d : int ; d := 0 ;
        var i : int ; i := 2 ; while i < n do ( (     if (i mod 2 = 0) then (     d := d * 3 + 1 ) else skip ; 
     c := c+(d * 2 + 1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 ) ;     is := in.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPrime(int n){
    if(n==0 || n==1){
      return false ;
    }
    for(int i=2 ; i*i<=n ; i++){
      if(n % i==0){
        return false ;
      }
    }
    return true ;
  }
  static int sumAscii(String str,int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(isPrime(i+1)){
        sum+=(int)(str.charAt(i));
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    int n=str.length();
    System.out.println(sumAscii(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 0 or n = 1) then (     return false ) else skip ; 
         var i : int ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation sumAscii( str : String, n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (isPrime(i + 1)) then (     sum := sum+((str->at(i+1))->oclAsType(int)) ) else skip )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].println(sumAscii(str, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cupboard {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int arr[][]=new int[n][2];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<2 ; j++){
        arr[i][j]=in.nextInt();
      }
    }
    int count1=0 ;
    int count0=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i][0]==1){
        count0++;
      }
    }
    int left=0 ;
    int right=0 ;
    if(count0>n/2){
      left=n-count0 ;
    }
    else {
      left=count0 ;
    }
    for(int i=0 ; i<n ; i++){
      if(arr[i][1]==1){
        count1++;
      }
    }
    if(count1>n/2){
      right=n-count1 ;
    }
    else {
      right=count1 ;
    }
    int sum=left+right ;
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cupboard {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 2 do ( (     arr[i+1][j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count1 : int ; count1 := 0 ;
    var count0 : int ; count0 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1][0+1] = 1) then (     count0 := count0 + 1 ) else skip )  ;     i := i + 1 ) ; 
    var left : int ; left := 0 ;
    var right : int ; right := 0 ;
    if (count0 > n / 2) then (     left := n - count0 ) else (     left := count0 ) ;  
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1][1+1] = 1) then (     count1 := count1 + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (count1 > n / 2) then (     right := n - count1 ) else (     right := count1 ) ;  
    var sum : int ; sum := left + right ;
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Ideone {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[][] a=new int[n][2];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<2 ; j++){
        a[i][j]=in.nextInt();
      }
    }
    int count1R=0 ;
    int count1L=0 ;
    int time=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i][0]==1){
        count1L++;
      }
      if(a[i][1]==1){
        count1R++;
      }
    }
    if(count1R<=n/2){
      for(int i=0 ; i<n ; i++){
        if(a[i][1]==1){
          a[i][1]=0 ;
          time++;
        }
      }
    }
    else {
      for(int i=0 ; i<n ; i++){
        if(a[i][1]==0){
          a[i][1]=1 ;
          time++;
        }
      }
    }
    if(count1L<=n/2){
      for(int i=0 ; i<n ; i++){
        if(a[i][0]==1){
          a[i][0]=0 ;
          time++;
        }
      }
    }
    else {
      for(int i=0 ; i<n ; i++){
        if(a[i][0]==0){
          a[i][0]=1 ;
          time++;
        }
      }
    }
    System.out.println(time);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ideone {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 2 do ( (     a[i+1][j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count1R : int ; count1R := 0 ;
    var count1L : int ; count1L := 0 ;
    var time : int ; time := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1][0+1] = 1) then (     count1L := count1L + 1 ) else skip ; 
     if (a[i+1][1+1] = 1) then (     count1R := count1R + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (count1R <= n / 2) then (         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1][1+1] = 1) then (     a[i+1][1+1] := 0 ; 
     time := time + 1 ) else skip )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1][1+1] = 0) then (     a[i+1][1+1] := 1 ; 
     time := time + 1 ) else skip )  ;     i := i + 1 ) ) ;  
    if (count1L <= n / 2) then (         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1][0+1] = 1) then (     a[i+1][0+1] := 0 ; 
     time := time + 1 ) else skip )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1][0+1] = 0) then (     a[i+1][0+1] := 1 ; 
     time := time + 1 ) else skip )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(time) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _248A_Cupboards {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    int one1=0 ;
    int zero1=0 ;
    int one2=0 ;
    int zero2=0 ;
    for(int i=0 ; i<test ; i++){
      int num1=input.nextInt();
      if(num1==0){
        zero1++;
      }
      else {
        one1++;
      }
      int num2=input.nextInt();
      if(num2==0){
        zero2++;
      }
      else {
        one2++;
      }
      input.nextLine();
    }
    System.out.println(Math.min(one1,zero1)+Math.min(one2,zero2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
    var one1 : int ; one1 := 0 ;
    var zero1 : int ; zero1 := 0 ;
    var one2 : int ; one2 := 0 ;
    var zero2 : int ; zero2 := 0 ;
        var i : int ; i := 0 ; while i < test do ( (     var num1 : int ; num1 := input.getCurrent()->toInteger() ;
     if (num1 = 0) then (     zero1 := zero1 + 1 ) else (     one1 := one1 + 1 ) ;  
    var num2 : int ; num2 := input.getCurrent()->toInteger() ;
    if (num2 = 0) then (     zero2 := zero2 + 1 ) else (     one2 := one2 + 1 ) ;  
    skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{one1, zero1}->min() + Set{one2, zero2}->min()) ; 
 );
}
48A_Cupboards {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
    var one1 : int ; one1 := 0 ;
    var zero1 : int ; zero1 := 0 ;
    var one2 : int ; one2 := 0 ;
    var zero2 : int ; zero2 := 0 ;
        var i : int ; i := 0 ; while i < test do ( (     var num1 : int ; num1 := input.getCurrent()->toInteger() ;
     if (num1 = 0) then (     zero1 := zero1 + 1 ) else (     one1 := one1 + 1 ) ;  
    var num2 : int ; num2 := input.getCurrent()->toInteger() ;
    if (num2 = 0) then (     zero2 := zero2 + 1 ) else (     one2 := one2 + 1 ) ;  
    skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{one1, zero1}->min() + Set{one2, zero2}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CodeforcesColourblind {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int col=sc.nextInt();
      String first=sc.next();
      String second=sc.next();
      int flag=0 ;
      for(int j=0 ; j<col ; j++){
        char ch1=first.charAt(j);
        char ch2=second.charAt(j);
        if(ch1=='R'){
          if(!(ch2=='R')){
            flag++;
            System.out.println("NO");
            break ;
          }
        }
        else {
          if(ch2=='R'){
            flag++;
            System.out.println("NO");
            break ;
          }
        }
      }
      if(flag==0){
        System.out.println("yes");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeforcesColourblind {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var col : int ; col := sc.getCurrent()->toInteger() ;
     var first : String ; first := sc.getCurrent() ;
    var second : String ; second := sc.getCurrent() ;
    var flag : int ; flag := 0 ;
        var j : int ; j := 0 ; while j < col do ( (     var ch1 : String ; ch1 := first->at(j+1) ;
     var ch2 : String ; ch2 := second->at(j+1) ;
     if (ch1 = 'R') then (     if (not((ch2 = 'R'))) then (     flag := flag + 1 ; 
     OclFile["System.out"].println("NO") ; 
     break ) else skip ) else (     if (ch2 = 'R') then (     flag := flag + 1 ; 
     OclFile["System.out"].println("NO") ; 
     break ) else skip ) )  ;     j := j + 1 ) ; 
    if (flag = 0) then (     OclFile["System.out"].println("yes") ) else skip ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static String strBitwiseAND(String[] arr,int n){
    String res="" ;
    int smallest_size=Integer.MAX_VALUE ;
    int largest_size=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      StringBuilder temp=new StringBuilder();
      temp.append(arr[i]);
      arr[i]=temp.reverse().toString();
      smallest_size=Math.min(smallest_size,arr[i] .length());
      largest_size=Math.max(largest_size,arr[i] .length());
    }
    for(int i=0 ; i<smallest_size ; i++){
      boolean all_ones=true ;
      for(int j=0 ; j<n ; j++){
        if(arr[j] .charAt(i)=='0'){
          all_ones=false ;
          break ;
        }
      }
      res+=(all_ones ? '1' : '0');
    }
    for(int i=0 ; i<largest_size-smallest_size ; i++)res+='0' ;
    StringBuilder temp=new StringBuilder();
    temp.append(res);
    res=temp.reverse().toString();
    return res ;
  }
  public static void main(String[] args){
    String arr[]={
      "101","110110","111" };
      int n=arr.length ;
      System.out.println(strBitwiseAND(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation strBitwiseAND( arr : Sequence(String), n : int) : String
  pre: true
  post: true
  activity: (     var res : String ; res := "" ;
     var smallest_size : int ; smallest_size := 2147483647 ;
    var largest_size : int ; largest_size := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : String ; temp := StringLib.newString() ;
     temp := temp + StringLib.newString(arr[i+1]) ; 
    arr[i+1] := temp->reverse()+"" ; 
    smallest_size := Set{smallest_size, arr[i+1]->size()}->min() ; 
    largest_size := Set{largest_size, arr[i+1]->size()}->max() ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < smallest_size do ( (     var all_ones : boolean ; all_ones := true ;
         var j : int ; j := 0 ; while j < n do ( (     if (arr[j+1]->at(i+1) = '0') then (     all_ones := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     res := res+((if all_ones then '1' else '0' endif)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < largest_size - (smallest_size)->char2byte() do (     res := res+('0') ;  ;     i := i + 1 ) ; 
    var temp : String ; temp := StringLib.newString() ;
    temp := temp + StringLib.newString(res) ; 
    res := temp->reverse()+"" ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"101","110110","111"} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(strBitwiseAND(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  char[] s ;
  int id ;
  boolean assign ;
  char get(){
    return s[id++];
  }
  void exp(){
    boolean[][] r=clause();
    check(r);
    while(true){
      char ch=get();
      if(ch!='|')break ;
      r=clause();
      check(r);
    }
  }
  void check(boolean[][] r){
    for(int i=0 ; i<26*2 ; i++){
      if(r[0][i] && r[1][i])return ;
    }
    assign=true ;
  }
  boolean[][] clause(){
    get();
    boolean[][] r=new boolean[2][26*2];
    for(int k=0 ; k<3 ; k++){
      int a=0 ;
      int x=0 ;
      char ch=get();
      if(ch=='~'){
        a=1 ;
        ch=get();
      }
      if(Character.isLowerCase(ch)){
        ch=Character.toUpperCase(ch);
        x=26 ;
      }
      r[a][x+ch-'A']=true ;
      get();
    }
    return r ;
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      s=(sc.next()+"$").toCharArray();
      if(s[0]=='#')break ;
      id=0 ;
      assign=false ;
      exp();
      System.out.println(assign ? "yes" : "no");
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute s : Sequence(String);
   attribute id : int;
   attribute assign : boolean;
   operation get() : String
  pre: true
  post: true
  activity: (     return s[id+1] );
   operation exp() : void
  pre: true
  post: true
  activity: (     var r : Sequence(Sequence(boolean)) ; r := clause() ;
     execute check(r) ; 
     while (true) do (     var ch : String ; ch := get() ;
     if (ch /= '|') then     break else skip ; 
     r := clause() ; 
     execute check(r) ) );
   operation check( r : Sequence(Sequence(boolean))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 26 * 2 do ( (     if (r[0+1][i+1] & r[1+1][i+1]) then     return else skip )  ;     i := i + 1 ) ; 
     assign := true );
   operation clause() : Sequence(Sequence(boolean))
  pre: true
  post: true
  activity: (     execute get() ; 
     var r : Sequence(Sequence(boolean)) ; r := Integer.subrange(1,2)->collect(Integer.subrange(1,26 * 2)->collect(false)) ;
         var k : int ; k := 0 ; while k < 3 do ( (     var a : int ; a := 0 ;
     var x : int ; x := 0 ;
    var ch : String ; ch := get() ;
    if (ch = '~') then (     a := 1 ; 
     ch := get() ) else skip ; 
    if ((ch->toLowerCase() = ch)) then (     ch := (ch + "")->toUpperCase() ; 
     x := 26 ) else skip ; 
    r[a+1][x + ch - ('A')->char2byte()+1] := true ; 
    execute get() ; 
 )  ;     k := k + 1 ) ; 
     return r );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     s := (sc.getCurrent() + "$")->characters() ; 
     if (s[0+1] = '#') then     break else skip ; 
    id := 0 ; 
    assign := false ; 
    execute exp() ; 
    OclFile["System.out"].println(if assign then "yes" else "no" endif) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Problem1 {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int t=Integer.parseInt(f.readLine());
    while(t-->0){
      StringTokenizer st=new StringTokenizer(f.readLine());
      int n=Integer.parseInt(st.nextToken());
      int u=Integer.parseInt(st.nextToken());
      int v=Integer.parseInt(st.nextToken());
      int[] obstacles=new int[n];
      st=new StringTokenizer(f.readLine());
      for(int i=0 ; i<n ; i++){
        obstacles[i]=Integer.parseInt(st.nextToken());
      }
      boolean free=false ;
      for(int i=0 ; i<n-1 ; i++){
        if(Math.abs(obstacles[i]-obstacles[i+1])>=2){
          free=true ;
          break ;
        }
      }
      if(free){
        out.println(0);
        continue ;
      }
      int cost=-1 ;
      for(int i=0 ; i<n-1 ; i++){
        if(Math.abs(obstacles[i]-obstacles[i+1])==1){
          cost=Math.min(u,v);
        }
      }
      if(cost>0){
        out.println(cost);
        continue ;
      }
      out.println(Math.min(u+v,2*v));
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var t : int ; t := (f.readLine())->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
     var n : int ; n := (st.next())->toInteger() ;
    var u : int ; u := (st.next())->toInteger() ;
    var v : int ; v := (st.next())->toInteger() ;
    var obstacles : Sequence(int) ; obstacles := Integer.subrange(1,n)->collect(0) ;
    st := OclIterator.newOclIterator_String(f.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     obstacles[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    var free : boolean ; free := false ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (if obstacles[i+1] - obstacles[i + 1+1] < 0 then -(obstacles[i+1] - obstacles[i + 1+1]) else obstacles[i+1] - obstacles[i + 1+1] endif >= 2) then (     free := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (free) then (     skip ; 
     continue ) else skip ; 
    var cost : int ; cost := -1 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (if obstacles[i+1] - obstacles[i + 1+1] < 0 then -(obstacles[i+1] - obstacles[i + 1+1]) else obstacles[i+1] - obstacles[i + 1+1] endif = 1) then (     cost := Set{u, v}->min() ) else skip )  ;     i := i + 1 ) ; 
    if (cost > 0) then (     skip ; 
     continue ) else skip ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math.*;
public class Inheritance {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int u=s.nextInt();
      int v=s.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=s.nextInt();
      }
      int ans=0 ;
      int flag=0 ;
      for(int i=0 ; i<n-1 ; i++){
        if((arr[i]>arr[i+1] || arr[i]<arr[i+1])&& Math.abs(arr[i]-arr[i+1])==1){
          ans=Math.min(u,v);
          flag=1 ;
        }
        else if((arr[i]>arr[i+1] || arr[i]<arr[i+1])&& Math.abs(arr[i]-arr[i+1])>1){
          ans=0 ;
          System.out.println(ans);
          flag=2 ;
          break ;
        }
      }
      if(flag==0)System.out.println(v+Math.min(u,v));
      else if(flag==1)System.out.println(Math.min(u,v));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Inheritance {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var u : int ; u := s.getCurrent()->toInteger() ;
    var v : int ; v := s.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if ((arr[i+1] > arr[i + 1+1] or arr[i+1] < arr[i + 1+1]) & if arr[i+1] - arr[i + 1+1] < 0 then -(arr[i+1] - arr[i + 1+1]) else arr[i+1] - arr[i + 1+1] endif = 1) then (     ans := Set{u, v}->min() ; 
     flag := 1 ) else     if ((arr[i+1] > arr[i + 1+1] or arr[i+1] < arr[i + 1+1]) & if arr[i+1] - arr[i + 1+1] < 0 then -(arr[i+1] - arr[i + 1+1]) else arr[i+1] - arr[i + 1+1] endif > 1) then (     ans := 0 ; 
     OclFile["System.out"].println(ans) ; 
     flag := 2 ; 
     break ) else skip ; )  ;     i := i + 1 ) ; 
    if (flag = 0) then     OclFile["System.out"].println(v + Set{u, v}->min()) else     if (flag = 1) then     OclFile["System.out"].println(Set{u, v}->min()) ; else skip ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getPeriod(int n){
    int rem=1 ;
    for(int i=1 ; i<=n+1 ; i++)rem=(10*rem)% n ;
    int d=rem ;
    int count=0 ;
    do {
      rem=(10*rem)% n ;
      count++;
    }
    while(rem!=d);
    return count ;
  }
  public static void main(String[] args){
    System.out.println(getPeriod(3));
    System.out.println(getPeriod(7));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getPeriod( n : int) : int
  pre: true
  post: true
  activity: (     var rem : int ; rem := 1 ;
         var i : int ; i := 1 ; while i <= n + 1 do (     rem := (10 * rem) mod n ;  ;     i := i + 1 ) ; 
    var d : int ; d := rem ;
    var count : int ; count := 0 ;
  while true do ((     rem := (10 * rem) mod n ; 
     count := count + 1 ) ;
    if (rem /= d) then skip else break) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(getPeriod(3)) ; 
     OclFile["System.out"].println(getPeriod(7)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int countDivisors(int n){
    int x=0,ans=1 ;
    while(n % 2==0){
      x++;
      n=n/2 ;
    }
    ans=ans*(x+1);
    for(int i=3 ; i<=Math.sqrt(n); i=i+2){
      x=0 ;
      while(n % i==0){
        x++;
        n=n/i ;
      }
      ans=ans*(x+1);
    }
    if(n>2)ans=ans*2 ;
    return ans ;
  }
  static int getTotalCount(int n,int k){
    int k_count=countDivisors(k);
    int count=0 ;
    for(int i=1 ; i<n ; i++)if(k_count==countDivisors(i))count++;
    if(k<n)count=count-1 ;
    return count ;
  }
  public static void main(String[] args){
    int n=500,k=6 ;
    System.out.println(getTotalCount(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countDivisors( n : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := 0 ;
    var ans : int ; ans := 1 ;
     while (n mod 2 = 0) do (     x := x + 1 ; 
     n := n / 2 ) ; 
    ans := ans * (x + 1) ; 
        var i : int ; i := 3 ; while i <= (n)->sqrt() do ( (     x := 0 ; 
     while (n mod i = 0) do (     x := x + 1 ; 
     n := n / i ) ; 
     ans := ans * (x + 1) )  ;     i := i + 2 ) ; 
    if (n > 2) then     ans := ans * 2 ; else skip ; 
    return ans 
 );
  static   operation getTotalCount( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var k_count : int ; k_count := countDivisors(k) ;
     var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < n do (     if (k_count = countDivisors(i)) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
    if (k < n) then     count := count - 1 ; else skip ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 500 ;
    var k : int ; k := 6 ;
     OclFile["System.out"].println(getTotalCount(n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  static int maxDiff(int[] arr,int n){
    int result=0 ;
    Arrays.sort(arr);
    for(int i=0 ; i<n-1 ; i++){
      if(arr[i]!=arr[i+1])result+=Math.abs(arr[i]);
      else i++;
    }
    if(arr[n-2]!=arr[n-1])result+=Math.abs(arr[n-1]);
    return result ;
  }
  static public void main(String[] args){
    int[] arr={
      4,2,-3,3,-2,-2,8 };
      int n=arr.length ;
      System.out.println("Maximum Difference="+maxDiff(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxDiff( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] /= arr[i + 1+1]) then     result := result+(if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif) ; else     i := i + 1 ; )  ;     i := i + 1 ) ; 
    if (arr[n - 2+1] /= arr[n - 1+1]) then     result := result+(if arr[n - 1+1] < 0 then -(arr[n - 1+1]) else arr[n - 1+1] endif) ; else skip ; 
    return result 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,2,-3,3,-2,-2,8} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Maximum Difference=" + maxDiff(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class NthNodePostOrder {
  static int flag=0 ;
  public static void NthPostordernode(Node root,int N){
    if(root==null)return ;
    if(flag<=N){
      NthPostordernode(root.left,N);
      NthPostordernode(root.right,N);
      flag++;
      if(flag==N)System.out.print(root.data);
    }
  }
  public static void main(String args[]){
    Node root=new Node(25);
    root.left=new Node(20);
    root.right=new Node(30);
    root.left.left=new Node(18);
    root.left.right=new Node(22);
    root.right.left=new Node(24);
    root.right.right=new Node(32);
    int N=6 ;
    NthPostordernode(root,N);
  }
}
class Node {
  int data ;
  Node left,right ;
  Node(int data){
    this.data=data ;
  }
};
------------------------------------------------------------
OCL File:
---------
class NthNodePostOrder {
  static   attribute flag : int := 0;
  static   operation NthPostordernode( root : Node, N : int) : void
  pre: true
  post: true
  activity: (     if (root = null) then     return else skip ; 
     if (flag <= N) then (     execute NthPostordernode(root.left, N) ; 
     execute NthPostordernode(root.right, N) ; 
     flag := flag + 1 ; 
     if (flag = N) then     OclFile["System.out"].print(root.data) ; else skip ) else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var root : Node ; root := Node.newNode(25) ;
     root.left := Node.newNode(20) ; 
    root.right := Node.newNode(30) ; 
    root.left.left := Node.newNode(18) ; 
    root.left.right := Node.newNode(22) ; 
    root.right.left := Node.newNode(24) ; 
    root.right.right := Node.newNode(32) ; 
    var N : int ; N := 6 ;
    execute NthPostordernode(root, N) ; 
 );
}
 class Node {
   attribute data : int;
   attribute left : Node;
   static operation newNode( data : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(data);
    return self );
  operation initialise( data : int) : void
  pre: true  post: true
  activity: (     self.data := data );
}
;

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isValid(long i,long m){
    long sq_i=(long)Math.sqrt(i);
    long sq=Math.min(m,sq_i);
    for(long j=2 ; j<=sq ; j++)if(i % j==0)return false ;
    return true ;
  }
  static void findLargestNum(long n,long m){
    for(long i=n ; i>m ; i--){
      if(isValid(i,m)){
        System.out.println(i);
        return ;
      }
    }
    System.out.println("Number Doesn't Exists");
  }
  public static void main(String[] args){
    long n=16,m=3 ;
    findLargestNum(n,m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isValid( i : long, m : long) : boolean
  pre: true
  post: true
  activity: (     var sq_i : long ; sq_i := (i)->sqrt()->oclAsType(long) ;
     var sq : long ; sq := Set{m, sq_i}->min() ;
         var j : long ; j := 2 ; while j <= sq do (     if (i mod j = 0) then     return false else skip ;  ;     j := j + 1 ) ; 
     return true );
  static   operation findLargestNum( n : long, m : long) : void
  pre: true
  post: true
  activity: (         var i : long ; i := n ; while i > m do ( (     if (isValid(i, m)) then (     OclFile["System.out"].println(i) ; 
     return ) else skip )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println("Number Doesn't Exists") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 16 ;
    var m : long ; m := 3 ;
     execute findLargestNum(n, m) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int uniqueNumbers(int arr[],int n){
    Arrays.sort(arr);
    int freq[]=new int[n+2];
    for(int i=0 ; i<n+2 ; i++)freq[i]=0 ;
    for(int x=0 ; x<n ; x++){
      if(freq[arr[x]-1]==0){
        freq[arr[x]-1]++;
      }
      else if(freq[arr[x] ]==0){
        freq[arr[x] ]++;
      }
      else {
        freq[arr[x]+1]++;
      }
    }
    int unique=0 ;
    for(int x=0 ; x<=n+1 ; x++){
      if(freq[x]!=0){
        unique++;
      }
    }
    return unique ;
  }
  public static void main(String[] args){
    int[] arr={
      3,3,3,3 };
      int n=4 ;
      int ans=uniqueNumbers(arr,n);
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation uniqueNumbers( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var freq : Sequence(int) ; freq := Integer.subrange(1,n + 2)->collect(0) ;
        var i : int ; i := 0 ; while i < n + 2 do (     freq[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var x : int ; x := 0 ; while x < n do ( (     if (freq[arr[x+1] - 1+1] = 0) then (     freq[arr[x+1] - 1+1] := freq[arr[x+1] - 1+1] + 1 ) else     if (freq[arr[x+1]+1] = 0) then (     freq[arr[x+1]+1] := freq[arr[x+1]+1] + 1 ) else (     freq[arr[x+1] + 1+1] := freq[arr[x+1] + 1+1] + 1 ) ;  )  ;     x := x + 1 ) ; 
    var unique : int ; unique := 0 ;
        var x : int ; x := 0 ; while x <= n + 1 do ( (     if (freq[x+1] /= 0) then (     unique := unique + 1 ) else skip )  ;     x := x + 1 ) ; 
    return unique 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,3,3,3} ;
     var n : int ; n := 4 ;
     var ans : int ; ans := uniqueNumbers(arr, n) ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    double d1=sc.nextInt();
    double x=sc.nextInt();
    double ans=0 ;
    for(; N>0 ; N--){
      ans+=d1+(N-0.5)*x ;
      d1=((2*N+2)*d1+5*x)/(2*N);
      x=((double)N+2)/N*x ;
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var d1 : double ; d1 := sc.getCurrent()->toInteger() ;
    var x : double ; x := sc.getCurrent()->toInteger() ;
    var ans : double ; ans := 0 ;
      while N > 0 do ( (     ans := ans+(d1 + (N - 0.5) * x) ; 
     d1 := ((2 * N + 2) * d1 + 5 * x) / (2 * N) ; 
     x := (N->oclAsType(double) + 2) / N * x )  ;     N := N - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean prime(int n){
    if(n==1)return false ;
    for(int i=2 ; i*i<=n ; ++i)if(n % i==0)return false ;
    return true ;
  }
  static int Min_Sum(int n){
    if(prime(n))return 1 ;
    if(n % 2==0)return 2 ;
    else {
      if(prime(n-2))return 2 ;
      else return 3 ;
    }
  }
  public static void main(String[] args){
    int n=27 ;
    System.out.println(Min_Sum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation prime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 1) then     return false else skip ; 
         var i : int ; i := 2 ; while i * i <= n do (     if (n mod i = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation Min_Sum( n : int) : int
  pre: true
  post: true
  activity: (     if (prime(n)) then     return 1 else skip ; 
     if (n mod 2 = 0) then     return 2 else (     if (prime(n - 2)) then     return 2 else     return 3 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 27 ;
     OclFile["System.out"].println(Min_Sum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p047 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p047().run());
  }
  public String run(){
    for(int i=2 ; ; i++){
      if(has4PrimeFactors(i+0)&& has4PrimeFactors(i+1)&& has4PrimeFactors(i+2)&& has4PrimeFactors(i+3))return Integer.toString(i);
    }
  }
  private static boolean has4PrimeFactors(int n){
    return countDistinctPrimeFactors(n)==4 ;
  }
  private static int countDistinctPrimeFactors(int n){
    int count=0 ;
    for(int i=2,end=Library.sqrt(n); i<=end ; i++){
      if(n % i==0){
        do n/=i ;
        while(n % i==0);
        count++;
        end=Library.sqrt(n);
      }
    }
    if(n>1)count++;
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p047 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p047.newp047().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while true do ( (     if (has4PrimeFactors(i + 0) & has4PrimeFactors(i + 1) & has4PrimeFactors(i + 2) & has4PrimeFactors(i + 3)) then     return ((i) + "") else skip )  ;     i := i + 1 ) );
  static   operation has4PrimeFactors( n : int) : boolean
  pre: true
  post: true
  activity: (     return countDistinctPrimeFactors(n) = 4 );
  static   operation countDistinctPrimeFactors( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 2 ;
    var end : int ; end := Library.sqrt(n) ; while i <= end do ( (     if (n mod i = 0) then (   while true do (    n := n/(i) ; ;
    if (n mod i = 0) then skip else break) ; 
     count := count + 1 ; 
     end := Library.sqrt(n) ) else skip )  ;     i := i + 1 ) ; 
     if (n > 1) then     count := count + 1 ; else skip ; 
     return count );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Constructive23 {
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(System.in);
    int availableCubes=sc.nextInt();
    Object result=getNumberOfPyramids(availableCubes);
    System.out.println(result);
  }
  public static Object getNumberOfPyramids(int availableCubes){
    int n=0 ;
    int level=0 ;
    while(n<availableCubes){
      level++;
      n+=(level*(level+1))/2 ;
    }
    return n>availableCubes ? level-1 : level ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Constructive23 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var availableCubes : int ; availableCubes := sc.getCurrent()->toInteger() ;
     var result : OclAny ; result := getNumberOfPyramids(availableCubes) ;
     OclFile["System.out"].println(result) );
  static   operation getNumberOfPyramids( availableCubes : int) : OclAny
  pre: true
  post: true
  activity: (     var n : int ; n := 0 ;
     var level : int ; level := 0 ;
     while (n < availableCubes) do (     level := level + 1 ; 
     n := n+((level * (level + 1)) / 2) ) ; 
     return if n > availableCubes then level - 1 else level endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static String line ;
  static int index(char c){
    if('a'<=c && c<='z')return c-'a' ;
    return 26+c-'A' ;
  }
  static boolean satisfy(String clause){
    String[] vars=clause.split("&");
    boolean[][] used=new boolean[2][52];
    for(String var : vars){
      int pos=var.length()-1 ;
      int i=index(var.charAt(pos));
      if(used[1-pos][i])return false ;
      used[pos][i]=true ;
    }
    return true ;
  }
  static boolean solve(){
    String[] clause=line.split("\\|");
    for(String c : clause){
      if(satisfy(c.substring(1,c.length()-1)))return true ;
    }
    return false ;
  }
  public static void main(String[] args)throws Exception {
    while(true){
      line=sc.next();
      if(line.equals("#"))break ;
      System.out.println(solve()? "yes" : "no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute line : String;
  static   operation index( c : String) : int
  pre: true
  post: true
  activity: (     if ('a' <= c & c <= 'z') then     return c - ('a')->char2byte() else skip ; 
     return 26 + c - ('A')->char2byte() );
  static   operation satisfy( clause : String) : boolean
  pre: true
  post: true
  activity: (     var vars : Sequence(String) ; vars := clause->split("&") ;
     var used : Sequence(Sequence(boolean)) ; used := Integer.subrange(1,2)->collect(Integer.subrange(1,52)->collect(false)) ;
     for (var : vars) do ( (     var pos : int ; pos := var->size() - 1 ;
     var i : int ; i := index(var->at(pos+1)) ;
     if (used[1 - pos+1][i+1]) then     return false else skip ; 
     used[pos+1][i+1] := true )  ) ; 
     return true );
  static   operation solve() : boolean
  pre: true
  post: true
  activity: (     var clause : Sequence(String) ; clause := line->split("\\|") ;
     for (c : clause) do ( (     if (satisfy(c.subrange(1+1,c->size() - 1))) then     return true else skip )  ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     line := sc.getCurrent() ; 
     if (line = "#") then     break else skip ; 
     OclFile["System.out"].println(if solve() then "yes" else "no" endif) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int length=s.length();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<s.length(); i++){
      sb.append("x");
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var length : int ; length := s->size() ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     sb := sb + StringLib.newString("x") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  private static void solve(){
    String S=next();
    int n=S.length();
    for(int i=0 ; i<n ; i++){
      System.out.print("x");
    }
    System.out.println();
  }
  private static BufferedReader br ;
  public static void main(String[] args){
    br=new BufferedReader(new InputStreamReader(System.in));
    String debugDataPath=System.getenv("DD_PATH");
    if(debugDataPath!=null){
      try {
        br=new BufferedReader(new InputStreamReader(new FileInputStream(new File(debugDataPath))));
      }
      catch(Exception e){
        throw new RuntimeException(e);
      }
    }
    solve();
  }
  private static StringTokenizer tokenizer=null ;
  public static String next(){
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        tokenizer=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }
  private static int ni(){
    return Integer.parseInt(next());
  }
  private static long nl(){
    return Long.parseLong(next());
  }
  private static double nd(){
    return Double.parseDouble(next());
  }
  private static int[] na(int n){
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=ni();
    return a ;
  }
  private static char[] ns(){
    return next().toCharArray();
  }
  private static long[] nal(int n){
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=nl();
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var S : String ; S := next() ;
     var n : int ; n := S->size() ;
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print("x") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   attribute br : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     var debugDataPath : String ; debugDataPath := OclProcess.getEnvironmentProperty("DD_PATH") ;
     if (debugDataPath /= null) then (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(debugDataPath)))) )   catch (e : ProgramException) do (     error ProgramException(e) )
 ) else skip ; 
     execute solve() );
  static   attribute tokenizer : OclIterator := null;
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
  static   operation ni() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nl() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nd() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation na( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := ni() ;  ;     i := i + 1 ) ; 
     return a );
  static   operation ns() : Sequence(String)
  pre: true
  post: true
  activity: (     return next()->characters() );
  static   operation nal( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nl() ;  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.System.out ;
public class Main {
  static MyReader in=new MyReader();
  public static void main(String[] args){
    String s=in.s();
    char[] t=new char[s.length()];
    Arrays.fill(t,'x');
    out.println(t);
  }
  static class MyReader extends BufferedReader {
    MyReader(){
      super(new InputStreamReader(System.in));
    }
    String s(){
      try {
        return readLine();
      }
      catch(IOException e){
        return "" ;
      }
    }
    String[] ss(){
      return s().split(" ");
    }
    int i(){
      return Integer.parseInt(s());
    }
    int[] ii(){
      String[] ss=ss();
      int[] ii=new int[ss.length];
      for(int j=0 ; j<ss.length ; j++)ii[j]=Integer.parseInt(ss[j]);
      return ii ;
    }
    ArrayList<Integer>li(){
      String[] ss=ss();
      ArrayList<Integer>li=new ArrayList<>();
      for(int j=0 ; j<ss.length ; j++)li.add(Integer.parseInt(ss[j]));
      return li ;
    }
    long l(){
      return Long.parseLong(s());
    }
    long[] ll(){
      String[] ss=ss();
      long[] ll=new long[ss.length];
      for(int j=0 ; j<ss.length ; j++)ll[j]=Long.parseLong(ss[j]);
      return ll ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : MyReader := MyReader.newMyReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.s() ;
     var t : Sequence(String) ; t := Integer.subrange(1,s->size())->collect(0) ;
     t := t->collect('x') ; 
     out.println(t) );
  static class MyReader extends OclFile {
   static operation newMyReader() : MyReader
  pre: true
  post: true
  activity:
  ( var self : MyReader ;
    self := createMyReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation s() : String
  pre: true
  post: true
  activity: (     try (     return readLine() )   catch (e : IOException) do (     return "" )
 );
   operation ss() : Sequence(String)
  pre: true
  post: true
  activity: (     return s()->split(" ") );
   operation i() : int
  pre: true
  post: true
  activity: (     return (s())->toInteger() );
   operation ii() : Sequence(int)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var ii : Sequence(int) ; ii := Integer.subrange(1,ss->size())->collect(0) ;
         var j : int ; j := 0 ; while j < ss->size() do (     ii[j+1] := (ss[j+1])->toInteger() ;  ;     j := j + 1 ) ; 
     return ii );
   operation li() : Sequence(int)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var li : Sequence(int) ; li := Sequence{} ;
         var j : int ; j := 0 ; while j < ss->size() do (     li := li->including((ss[j+1])->toInteger()) ;  ;     j := j + 1 ) ; 
     return li );
   operation l() : long
  pre: true
  post: true
  activity: (     return (s())->toLong() );
   operation ll() : Sequence(long)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var ll : Sequence(long) ; ll := Integer.subrange(1,ss->size())->collect(0) ;
         var j : int ; j := 0 ; while j < ss->size() do (     ll[j+1] := (ss[j+1])->toLong() ;  ;     j := j + 1 ) ; 
     return ll );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args){
    try {
      BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
      String b=reader.readLine();
      int n=b.length();
      String ans="" ;
      String x="x" ;
      for(int i=0 ; i<n ; i++){
        ans=ans.concat(x);
      }
      System.out.println(ans);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var b : String ; b := reader.readLine() ;
    var n : int ; n := b->size() ;
    var ans : String ; ans := "" ;
    var x : String ; x := "x" ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans+x )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String line=sc.nextLine();
    int n=line.length();
    for(int i=0 ; i<n ; i++){
      System.out.print("x");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : String ; line := sc.nextLine() ;
     var n : int ; n := line->size() ;
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print("x") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long mod=(long)(1e9+7);
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int a1=in.nextInt();
    int a2=in.nextInt();
    int k1=in.nextInt();
    int k2=in.nextInt();
    int total=in.nextInt();
    int c1=a1*(k1-1)+(a2*(k2-1));
    int min=0 ;
    if(c1>=total){
      min=0 ;
    }
    else {
      min=total-c1 ;
    }
    int val_min=Math.min(k1,k2);
    int max=0 ;
    if(k1==val_min){
      int value=(a1*k1);
      if(value>=total){
        max=total/k1 ;
        total=0 ;
      }
      else {
        max=a1 ;
        total-=(a1*k1);
      }
      max+=(total/k2);
    }
    else {
      int value=(a2*k2);
      if(value>=total){
        max=total/k2 ;
        total=0 ;
      }
      else {
        max=a2 ;
        total-=(a2*k2);
      }
      max+=(total/k1);
    }
    pw.println(min+" "+max);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := (1e9 + 7)->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a1 : int ; a1 := in.getCurrent()->toInteger() ;
    var a2 : int ; a2 := in.getCurrent()->toInteger() ;
    var k1 : int ; k1 := in.getCurrent()->toInteger() ;
    var k2 : int ; k2 := in.getCurrent()->toInteger() ;
    var total : int ; total := in.getCurrent()->toInteger() ;
    var c1 : int ; c1 := a1 * (k1 - 1) + (a2 * (k2 - 1)) ;
    var min : int ; min := 0 ;
    if (c1 >= total) then (     min := 0 ) else (     min := total - c1 ) ;  
    var val_min : int ; val_min := Set{k1, k2}->min() ;
    var max : int ; max := 0 ;
    if (k1 = val_min) then (     var value : int ; value := (a1 * k1) ;
     if (value >= total) then (     max := total / k1 ; 
     total := 0 ) else (     max := a1 ; 
     total := total-((a1 * k1)) ) ;  
     max := max+((total / k2)) ) else (     var value : int ; value := (a2 * k2) ;
     if (value >= total) then (     max := total / k2 ; 
     total := 0 ) else (     max := a2 ; 
     total := total-((a2 * k2)) ) ;  
     max := max+((total / k1)) ) ;  
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    MathContext mc=new MathContext(25,RoundingMode.HALF_DOWN);
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int a=in.nextInt();
    int x=in.nextInt();
    BigDecimal L=new BigDecimal(1);
    BigDecimal ans=new BigDecimal(2*x);
    for(int i=2 ; i<=n ; ++i){
      BigDecimal t=new BigDecimal(i);
      L=L.add(BigDecimal.ONE.divide(BigDecimal.valueOf(i),mc));
      t=L.add(BigDecimal.valueOf(i));
      t=t.multiply(BigDecimal.valueOf(x));
      BigDecimal t2=ans.multiply(BigDecimal.valueOf(2)).divide(BigDecimal.valueOf(i),mc);
      ans=ans.add(t).add(t2);
    }
    L=L.add(BigDecimal.ONE.divide(BigDecimal.valueOf(n+1),mc));
    L=L.subtract(BigDecimal.ONE);
    L=L.multiply(BigDecimal.valueOf(n+1)).multiply(BigDecimal.valueOf(2*a-3*x));
    L=L.divide(BigDecimal.valueOf(2),mc);
    ans=ans.add(L);
    System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mc : MathContext ; mc := MathContext.newMathContext(25, RoundingMode.HALF_DOWN) ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
    var L : double ; L := double(1) ;
    var ans : double ; ans := double(2 * x) ;
        var i : int ; i := 2 ; while i <= n do ( (     var t : double ; t := double(i) ;
     L := L->excludes(1.0.divide((i + "")->toReal(), mc)) ; 
    t := L->excludes((i + "")->toReal()) ; 
    t := t.multiply((x + "")->toReal()) ; 
    var t2 : double ; t2 := ans.multiply((2 + "")->toReal()).divide((i + "")->toReal(), mc) ;
    ans := ans->excludes(t)->excludes(t2) ; 
 )  ;     i := i + 1 ) ; 
    L := L->excludes(1.0.divide((n + 1 + "")->toReal(), mc)) ; 
    L := L.subtract(1.0) ; 
    L := L.multiply((n + 1 + "")->toReal()).multiply((2 * a - 3 * x + "")->toReal()) ; 
    L := L.divide((2 + "")->toReal(), mc) ; 
    ans := ans->excludes(L) ; 
    OclFile["System.out"].print(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Problem {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int n=Integer.parseInt(f.readLine());
    int m=Integer.parseInt(f.readLine());
    int k1=Integer.parseInt(f.readLine());
    int k2=Integer.parseInt(f.readLine());
    int nn=Integer.parseInt(f.readLine());
    if(k1<=k2){
      int temp=k1 ;
      k1=k2 ;
      k2=temp ;
      temp=n ;
      n=m ;
      m=temp ;
    }
    if(k1>=k2){
      int min=0 ;
      int nnn=nn ;
      if(nnn<=(n)*(k1-1)+(m)*(k2-1)){
        min=0 ;
      }
      else {
        nnn-=(n)*(k1-1)+(m)*(k2-1);
        min=nnn ;
      }
      int max=Math.min(m,nn/k2);
      if(max==m){
        nn-=(k2*m);
        max+=(nn/k1);
      }
      out.println(min+" "+max);
      out.close();
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := (f.readLine())->toInteger() ;
    var m : int ; m := (f.readLine())->toInteger() ;
    var k1 : int ; k1 := (f.readLine())->toInteger() ;
    var k2 : int ; k2 := (f.readLine())->toInteger() ;
    var nn : int ; nn := (f.readLine())->toInteger() ;
    if (k1 <= k2) then (     var temp : int ; temp := k1 ;
     k1 := k2 ; 
    k2 := temp ; 
    temp := n ; 
    n := m ; 
    m := temp ; 
 ) else skip ; 
    if (k1 >= k2) then (     var min : int ; min := 0 ;
     var nnn : int ; nnn := nn ;
    if (nnn <= (n) * (k1 - 1) + (m) * (k2 - 1)) then (     min := 0 ) else (     nnn := nnn-((n) * (k1 - 1) + (m) * (k2 - 1)) ; 
     min := nnn ) ;  
    var max : int ; max := Set{m, nn / k2}->min() ;
    if (max = m) then (     nn := nn-((k2 * m)) ; 
     max := max+((nn / k1)) ) else skip ; 
    skip ; 
    skip ; 
 ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Code {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    boolean t=true ;
    for(int i=0 ; i<s.length()&& t ; i++){
      if(s.charAt(i)=='*'){
        for(int j=1 ; i+4*j<s.length(); j++){
          if(s.charAt(i+j)=='*' && s.charAt(i+2*j)=='*' && s.charAt(i+3*j)=='*' && s.charAt(i+4*j)=='*'){
            System.out.println("yes");
            t=false ;
            break ;
          }
        }
      }
    }
    if(t){
      System.out.println("no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var t : boolean ; t := true ;
        var i : int ; i := 0 ; while i < s->size() & t do ( (     if (s->at(i+1) = '*') then (         var j : int ; j := 1 ; while i + 4 * j < s->size() do ( (     if (s->at(i + j+1) = '*' & s->at(i + 2 * j+1) = '*' & s->at(i + 3 * j+1) = '*' & s->at(i + 4 * j+1) = '*') then (     OclFile["System.out"].println("yes") ; 
     t := false ; 
     break ) else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    if (t) then (     OclFile["System.out"].println("no") ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    char[] c=sc.next().toCharArray();
    for(int i=1 ; i<c.length ; i++){
      for(int j=0 ; j<c.length ; j++){
        int j2=0 ;
        for(int k=j ; j2<5 && k<c.length ; j2++,k+=i){
          if(c[k]=='.')break ;
        }
        if(j2==5){
          System.out.println("yes");
          return ;
        }
      }
    }
    out.println("no");
    out.flush();
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(FileReader fileReader){
      br=new BufferedReader(fileReader);
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : Sequence(String) ; c := sc.getCurrent()->characters() ;
        var i : int ; i := 1 ; while i < c->size() do ( (         var j : int ; j := 0 ; while j < c->size() do ( (     var j2 : int ; j2 := 0 ;
         var k : int ; k := j ; while j2 < 5 & k < c->size() do ( (     if (c[k+1] = '.') then     break else skip )  ;     j2 := j2 + 1 ;     k := k+(i) ) ; 
     if (j2 = 5) then (     OclFile["System.out"].println("yes") ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( fileReader : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(fileReader);
    return self );
  operation initialise( fileReader : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(fileReader) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class zizo {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] s=sc.next().toCharArray();
    for(int a=0 ; a<n ; a++){
      LOOP : for(int b=1 ;
      b<n ;
      b++){
        for(int i=0 ; i<=4 ; i++){
          int x=a+b*i ;
          if(x>=n){
            continue LOOP ;
          }
          if(s[x]=='.'){
            continue LOOP ;
          }
        }
        System.out.println("yes");
        return ;
      }
    }
    System.out.println("no");
  }
}
------------------------------------------------------------
OCL File:
---------
 class zizo {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
        var a : int ; a := 0 ; while a < n do ( (         var b : int ; b := 1 ; while b < n do ( (         var i : int ; i := 0 ; while i <= 4 do ( (     var x : int ; x := a + b * i ;
     if (x >= n) then (     continue ) else skip ; 
     if (s[x+1] = '.') then (     continue ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("yes") ; 
     return )  ;     b := b + 1 ) ; )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println("no") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  String line ;
  void run(){
    for(; ; ){
      line=sc.nextLine();
      if(line.equals("#")){
        break ;
      }
      boolean satensan=false ;
      for(String s : line.split("[|] ")){
        s=s.substring(1,s.length()-1);
        String[] ss=s.split("&");
        boolean fail=false ;
        for(int j=0 ; j<3 ; j++){
          for(int i=0 ; i<3 ; i++){
            fail |=ss[i] .length()==1 && ss[j] .length()==2 && ss[i] .charAt(0)==ss[j] .charAt(1);
          }
        }
        satensan |=! fail ;
      }
      println(satensan ? "yes" : "no");
    }
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute line : String;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     line := sc.nextLine() ; 
     if (line = "#") then (     break ) else skip ; 
    var satensan : boolean ; satensan := false ;
    for (s : line->split("[|] ")) do ( (     s := s.subrange(1+1,s->size() - 1) ; 
     var ss : Sequence(String) ; ss := s->split("&") ;
    var fail : boolean ; fail := false ;
        var j : int ; j := 0 ; while j < 3 do ( (         var i : int ; i := 0 ; while i < 3 do ( (     fail := MathLib.bitwiseOr(fail, ss[i+1]->size() = 1 & ss[j+1]->size() = 2 & ss[i+1]->at(0+1) = ss[j+1]->at(1+1)) )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    satensan := MathLib.bitwiseOr(satensan, not(fail)) ; 
 )  ) ; 
    execute println(if satensan then "yes" else "no" endif) ; 
 )  ) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Problem_526A {
  public static boolean sol(int i,int sum,int diff){
    if(sum==4)return true ;
    if(i==n || i==-1)return false ;
    for(int j=i+1 ; j<n ; j++){
      if(s.charAt(j)=='*'){
        if(j-i==diff){
          if(sol(j,sum+1,diff))return true ;
        }
        else {
          if(sol(j,1,j-i))return true ;
        }
      }
    }
    return false ;
  }
  static int n ;
  static String s ;
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner();
    PrintWriter pw=new PrintWriter(System.out);
    n=sc.nextInt();
    s=sc.nextLine();
    int i=s.indexOf("*");
    if(sol(i,0,-1))System.out.println("yes");
    else System.out.println("no");
    pw.close();
  }
  static class Scanner {
    BufferedReader br ;
    StringTokenizer st ;
    Scanner(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next()throws IOException {
      while(st==null || ! st.hasMoreTokens()){
        st=new StringTokenizer(br.readLine());
      }
      return st.nextToken();
    }
    int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    String nextLine()throws IOException {
      return br.readLine();
    }
    boolean hasnext()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem_526A {
  static   operation sol( i : int, sum : int, diff : int) : boolean
  pre: true
  post: true
  activity: (     if (sum = 4) then     return true else skip ; 
     if (i = n or i = -1) then     return false else skip ; 
         var j : int ; j := i + 1 ; while j < n do ( (     if (s->at(j+1) = '*') then (     if (j - i = diff) then (     if (sol(j, sum + 1, diff)) then     return true else skip ) else (     if (sol(j, 1, j - i)) then     return true else skip ) ) else skip )  ;     j := j + 1 ) ; 
     return false );
  static   attribute n : int;
  static   attribute s : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := (arguments ( )) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    n := sc.getCurrent()->toInteger() ; 
    s := sc.nextLine() ; 
    var i : int ; i := s->indexOf("*")-1 ;
    if (sol(i, 0, -1)) then     OclFile["System.out"].println("yes") else     OclFile["System.out"].println("no") ; ;  
    skip ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newScanner() : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation hasnext() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
public class KingOfThieves {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String map=br.readLine();
    int maxGap=(int)Math.floor((n-5)/4);
    for(int i=0 ; i<=maxGap ; i++){
      int maxRunSpace=i*4+5 ;
      for(int j=0 ; j<=n-maxRunSpace ; j++){
        if(map.charAt(j)=='.'){
          continue ;
        }
        else {
          boolean possible=true ;
          for(int k=j+i+1 ; k<j+maxRunSpace ; k+=i+1){
            if(map.charAt(k)=='.'){
              possible=false ;
              break ;
            }
          }
          if(possible){
            System.out.println("yes");
            System.exit(0);
          }
        }
      }
    }
    System.out.println("no");
  }
}
------------------------------------------------------------
OCL File:
---------
 class KingOfThieves {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var map : String ; map := br.readLine() ;
    var maxGap : int ; maxGap := ((n - 5) / 4)->floor()->oclAsType(int) ;
        var i : int ; i := 0 ; while i <= maxGap do ( (     var maxRunSpace : int ; maxRunSpace := i * 4 + 5 ;
         var j : int ; j := 0 ; while j <= n - maxRunSpace do ( (     if (map->at(j+1) = '.') then (     continue ) else (     var possible : boolean ; possible := true ;
         var k : int ; k := j + i + 1 ; while k < j + maxRunSpace do ( (     if (map->at(k+1) = '.') then (     possible := false ; 
     break ) else skip )  ;     k := k+(i + 1) ) ; 
     if (possible) then (     OclFile["System.out"].println("yes") ; 
 OclProcess.exit(0) ) else skip ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("no") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int seriesSum(int n){
    return(n*(n+1)*(n+2))/6 ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(seriesSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation seriesSum( n : int) : int
  pre: true
  post: true
  activity: (     return (n * (n + 1) * (n + 2)) / 6 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(seriesSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void checksum(int n){
    if(n % 3==0)System.out.println(n/3-1+" "+n/3+" "+(n/3+1));
    else System.out.println("-1");
  }
  public static void main(String[] args){
    int n=6 ;
    checksum(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checksum( n : int) : void
  pre: true
  post: true
  activity: (     if (n mod 3 = 0) then     OclFile["System.out"].println(n / 3 - 1 + " " + n / 3 + " " + (n / 3 + 1)) ; else     OclFile["System.out"].println("-1") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     execute checksum(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int angle(int n){
    return 2*n ;
  }
  public static void main(String[] args){
    int n=30 ;
    System.out.println(angle(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation angle( n : int) : int
  pre: true
  post: true
  activity: (     return 2 * n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 30 ;
     OclFile["System.out"].println(angle(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void reverseorder(int n){
    boolean prime[]=new boolean[n+1];
    for(int i=0 ; i<n ; i++)prime[i]=true ;
    for(int p=2 ; p*p<=n ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=n ; i+=p)prime[i]=false ;
      }
    }
    for(int i=n ; i>=2 ; i--)if(prime[i]==true)System.out.print(i+" ");
  }
  public static void main(String args[]){
    int N=25 ;
    System.out.println("Prime number in reverse order");
    if(N==1)System.out.println("No prime no exist in this range");
    else reverseorder(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation reverseorder( n : int) : void
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,n + 1)->collect(false) ;
         var i : int ; i := 0 ; while i < n do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
         var p : int ; p := 2 ; while p * p <= n do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= n do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
         var i : int ; i := n ; while i >= 2 do (     if (prime[i+1] = true) then     OclFile["System.out"].print(i + " ") ; else skip ;  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 25 ;
     OclFile["System.out"].println("Prime number in reverse order") ; 
     if (N = 1) then     OclFile["System.out"].println("No prime no exist in this range") ; else     execute reverseorder(N) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int centeredTetrahedralNumber(int n){
    return(2*n+1)*(n*n+n+3)/3 ;
  }
  public static void main(String[] args){
    int n=6 ;
    System.out.println(centeredTetrahedralNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation centeredTetrahedralNumber( n : int) : int
  pre: true
  post: true
  activity: (     return (2 * n + 1) * (n * n + n + 3) / 3 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(centeredTetrahedralNumber(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float avgOfFirstN(int n){
    return(float)(1+n)/2 ;
  }
  public static void main(String args[]){
    int n=20 ;
    System.out.println(avgOfFirstN(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation avgOfFirstN( n : int) : double
  pre: true
  post: true
  activity: (     return (1 + n)->oclAsType(double) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 20 ;
     OclFile["System.out"].println(avgOfFirstN(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long evenPowerSum(int n){
    return(8*n*(n+1)*(2*n+1)*(3*n*n+3*n-1))/15 ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(evenPowerSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation evenPowerSum( n : int) : long
  pre: true
  post: true
  activity: (     return (8 * n * (n + 1) * (2 * n + 1) * (3 * n * n + 3 * n - 1)) / 15 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(evenPowerSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countStr(int n){
    return 1+(n*2)+(n*((n*n)-1)/2);
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(countStr(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countStr( n : int) : int
  pre: true
  post: true
  activity: (     return 1 + (n * 2) + (n * ((n * n) - 1) / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(countStr(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int seriesSum(int n){
    return(n*(n+1)*(n+2))/6 ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(seriesSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation seriesSum( n : int) : int
  pre: true
  post: true
  activity: (     return (n * (n + 1) * (n + 2)) / 6 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(seriesSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.BufferedWriter ;
import java.io.OutputStreamWriter ;
import java.io.IOException ;
import java.util.StringTokenizer ;
public class Solve {
  static FastScan jin=new FastScan();
  static BufferedWriter jout=new BufferedWriter(new OutputStreamWriter(System.out));
  static int T ;
  public static void main(String[] args)throws Exception {
    long res=1 ;
    long cur1=0,cur2=0 ;
    long score1,score2 ;
    int N=jin.nextInt();
    for(int i=0 ; i<N ; ++i){
      score1=jin.nextLong();
      score2=jin.nextLong();
      long score_min=Math.min(score1,score2);
      long cur_max=Math.max(cur1,cur2);
      if(cur1<score_min && cur2<score_min){
        res+=score_min-cur_max ;
        if(cur1!=cur2){
          res+=1 ;
        }
      }
      else if((cur1<score_min && cur2==score_min)||(cur1==score_min && cur2<score_min)){
        res+=1 ;
      }
      cur1=score1 ;
      cur2=score2 ;
    }
    jout.write(res+"");
    jout.close();
  }
}
class FastScan {
  BufferedReader br ;
  StringTokenizer stok ;
  public FastScan(){
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  String next(){
    while(stok==null || ! stok.hasMoreElements()){
      try {
        stok=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
    }
    return stok.nextToken();
  }
  String nextLine(){
    String str="" ;
    try {
      str=br.readLine();
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return str ;
  }
  int nextInt(){
    return Integer.parseInt(this.next());
  }
  long nextLong(){
    return Long.parseLong(this.next());
  }
  double nextDouble(){
    return Double.parseDouble(this.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solve {
  static   attribute jin : FastScan := FastScan.newFastScan();
  static   attribute jout : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute T : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     var cur1 : long ; cur1 := 0 ;
    var cur2 : long ; cur2 := 0 ;
    var score1 : long ;
    var score2 : long ;
    var N : int ; N := jin.nextInt() ;
        var i : int ; i := 0 ; while i < N do ( (     score1 := jin.nextLong() ; 
     score2 := jin.nextLong() ; 
    var score_min : long ; score_min := Set{score1, score2}->min() ;
    var cur_max : long ; cur_max := Set{cur1, cur2}->max() ;
    if (cur1 < score_min & cur2 < score_min) then (     res := res+(score_min - cur_max) ; 
     if (cur1 /= cur2) then (     res := res+(1) ) else skip ) else     if ((cur1 < score_min & cur2 = score_min) or (cur1 = score_min & cur2 < score_min)) then (     res := res+(1) ) else skip ; ;  
    cur1 := score1 ; 
    cur2 := score2 ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}
class FastScan {
   attribute br : OclFile;
   attribute stok : OclIterator;
   static operation newFastScan() : FastScan
  pre: true
  post: true
  activity:
  ( var self : FastScan ;
    self := createFastScan();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (stok = null or not(stok.hasNext())) do (     try (     stok := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return stok.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (self.next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (self.next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (self.next())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int per(int n){
    if(n==0)return 3 ;
    if(n==1)return 0 ;
    if(n==2)return 2 ;
    return per(n-2)+per(n-3);
  }
  public static void main(String[] args){
    int n=9 ;
    System.out.println(per(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation per( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 3 else skip ; 
     if (n = 1) then     return 0 else skip ; 
     if (n = 2) then     return 2 else skip ; 
     return per(n - 2) + per(n - 3) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     OclFile["System.out"].println(per(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static int countSetBits(int n){
    if(n==0)return 0 ;
    else return(n & 1)+countSetBits(n>>1);
  }
  public static void main(String[] args){
    int n=9 ;
    System.out.println(countSetBits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else     return (n & 1) + countSetBits((n/(2->pow(1)))->oclAsType(long)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     OclFile["System.out"].println(countSetBits(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int leonardo(int n){
    if(n==0 || n==1)return 1 ;
    return(leonardo(n-1)+leonardo(n-2)+1);
  }
  public static void main(String args[]){
    System.out.println(leonardo(3));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation leonardo( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0 or n = 1) then     return 1 else skip ; 
     return (leonardo(n - 1) + leonardo(n - 2) + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(leonardo(3)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int weightedMean(int n){
    return(2*n+1)/3 ;
  }
  static public void main(String[] args){
    int n=10 ;
    System.out.println(weightedMean(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation weightedMean( n : int) : int
  pre: true
  post: true
  activity: (     return (2 * n + 1) / 3 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(weightedMean(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void pattern(int min_stars,int p_height){
    int p_space ;
    p_space=p_height-1 ;
    int i,j,k,n,x ;
    x=1 ;
    for(i=0 ; i<p_height ; i++){
      for(j=p_space ; j>i ; j--){
        System.out.print(" ");
      }
      for(k=0 ; k<min_stars ; k++)System.out.print("*");
      for(n=(p_height+p_height-2); n>=x ; n--)System.out.print(" ");
      for(k=0 ; k<min_stars ; k++)System.out.print("*");
      min_stars=min_stars+2 ;
      x=x+2 ;
      System.out.println();
    }
  }
  public static void main(String[] args){
    int min_stars=1 ;
    int p_height=5 ;
    pattern(min_stars,p_height);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pattern( min_stars : int, p_height : int) : void
  pre: true
  post: true
  activity: (     var p_space : int ;
     p_space := p_height - 1 ; 
    var i : int ;
    var j : int ;
    var k : int ;
    var n : int ;
    var x : int ;
    x := 1 ; 
        i := 0 ; while i < p_height do ( (         j := p_space ; while j > i do ( (     OclFile["System.out"].print(" ") )  ;     j := j - 1 ) ; 
         k := 0 ; while k < min_stars do (     OclFile["System.out"].print("*") ;  ;     k := k + 1 ) ; 
        n := (p_height + p_height - 2) ; while n >= x do (     OclFile["System.out"].print(" ") ;  ;     n := n - 1 ) ; 
        k := 0 ; while k < min_stars do (     OclFile["System.out"].print("*") ;  ;     k := k + 1 ) ; 
    min_stars := min_stars + 2 ; 
    x := x + 2 ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var min_stars : int ; min_stars := 1 ;
     var p_height : int ; p_height := 5 ;
     execute pattern(min_stars, p_height) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int binomialCoeffSum(int n){
    return(1<<n);
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(binomialCoeffSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation binomialCoeffSum( n : int) : int
  pre: true
  post: true
  activity: (     return ((1*(2->pow(n)))->oclAsType(long)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(binomialCoeffSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countNumberOfTriangles(int n){
    return n*(n-1)*(n-2)/6 ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(countNumberOfTriangles(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countNumberOfTriangles( n : int) : int
  pre: true
  post: true
  activity: (     return n * (n - 1) * (n - 2) / 6 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(countNumberOfTriangles(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findStarNum(int n){
    return(6*n*(n-1)+1);
  }
  public static void main(String args[]){
    int n=3 ;
    System.out.println(findStarNum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findStarNum( n : int) : int
  pre: true
  post: true
  activity: (     return (6 * n * (n - 1) + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(findStarNum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int Centered_Trigunal_num(int n){
    return(3*n*n+3*n+2)/2 ;
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(Centered_Trigunal_num(n));
    n=12 ;
    System.out.println(Centered_Trigunal_num(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Centered_Trigunal_num( n : int) : int
  pre: true
  post: true
  activity: (     return (3 * n * n + 3 * n + 2) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(Centered_Trigunal_num(n)) ; 
     n := 12 ; 
     OclFile["System.out"].println(Centered_Trigunal_num(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findValueAtX(int n){
    return(n*n*n)+n ;
  }
  public static void main(String[] args){
    System.out.println(findValueAtX(10));
    System.out.println(findValueAtX(2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findValueAtX( n : int) : int
  pre: true
  post: true
  activity: (     return (n * n * n) + n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(findValueAtX(10)) ; 
     OclFile["System.out"].println(findValueAtX(2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void checksum(int n){
    if(n % 5==0)System.out.println((n/5-2)+" "+(n/5-1)+" "+(n/5)+" "+(n/5+1)+" "+(n/5+2));
    else System.out.println("-1");
  }
  public static void main(String[] args){
    int n=15 ;
    checksum(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checksum( n : int) : void
  pre: true
  post: true
  activity: (     if (n mod 5 = 0) then     OclFile["System.out"].println((n / 5 - 2) + " " + (n / 5 - 1) + " " + (n / 5) + " " + (n / 5 + 1) + " " + (n / 5 + 2)) ; else     OclFile["System.out"].println("-1") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     execute checksum(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class trailzero {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int ans=1 ;
    int a=0,b=0 ;
    for(int i=0 ; i<n ; i++){
      int c=sc.nextInt();
      int d=sc.nextInt();
      ans+=Math.max(0,Math.min(c,d)-Math.max(a,b)+((a!=b)? 1 : 0));
      a=c ;
      b=d ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class trailzero {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 1 ;
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var c : int ; c := sc.getCurrent()->toInteger() ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
    ans := ans+(Set{0, Set{c, d}->min() - Set{a, b}->max() + (if (a /= b) then 1 else 0 endif)}->max()) ; 
    a := c ; 
    b := d ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int avg_of_even_num(int n){
    return n+1 ;
  }
  public static void main(String[] args){
    int n=8 ;
    System.out.println(avg_of_even_num(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation avg_of_even_num( n : int) : int
  pre: true
  post: true
  activity: (     return n + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     OclFile["System.out"].println(avg_of_even_num(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int heptagonalNumber(int n){
    return((5*n*n)-(3*n))/2 ;
  }
  public static void main(String[] args){
    int n=2 ;
    System.out.println(heptagonalNumber(n));
    n=15 ;
    System.out.println(heptagonalNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation heptagonalNumber( n : int) : int
  pre: true
  post: true
  activity: (     return ((5 * n * n) - (3 * n)) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(heptagonalNumber(n)) ; 
     n := 15 ; 
     OclFile["System.out"].println(heptagonalNumber(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static float AvgofSquareN(int n){
    return(float)((n+1)*(2*n+1))/6 ;
  }
  static public void main(String[] args){
    int n=2 ;
    System.out.println(AvgofSquareN(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation AvgofSquareN( n : int) : double
  pre: true
  post: true
  activity: (     return ((n + 1) * (2 * n + 1))->oclAsType(double) / 6 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(AvgofSquareN(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B629 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] FfriendPerDay=new int[367];
    int[] MfriendPerDay=new int[367];
    int answer=0 ;
    for(int i=0 ; i<n ; i++){
      char c=sc.next().charAt(0);
      int a=sc.nextInt();
      int b=sc.nextInt();
      for(int j=a ; j<=b ; j++){
        if(c=='M')MfriendPerDay[j]++;
        else FfriendPerDay[j]++;
        if(MfriendPerDay[j]<FfriendPerDay[j]){
          if(MfriendPerDay[j]>answer)answer=MfriendPerDay[j];
        }
        else {
          if(FfriendPerDay[j]>answer)answer=FfriendPerDay[j];
        }
      }
    }
    System.out.println(answer*2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B629 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var FfriendPerDay : Sequence(int) ; FfriendPerDay := Integer.subrange(1,367)->collect(0) ;
    var MfriendPerDay : Sequence(int) ; MfriendPerDay := Integer.subrange(1,367)->collect(0) ;
    var answer : int ; answer := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var c : String ; c := sc.getCurrent()->at(0+1) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
         var j : int ; j := a ; while j <= b do ( (     if (c = 'M') then     MfriendPerDay[j+1] := MfriendPerDay[j+1] + 1 else     FfriendPerDay[j+1] := FfriendPerDay[j+1] + 1 ; ;  
     if (MfriendPerDay[j+1] < FfriendPerDay[j+1]) then (     if (MfriendPerDay[j+1] > answer) then     answer := MfriendPerDay[j+1] ; else skip ) else (     if (FfriendPerDay[j+1] > answer) then     answer := FfriendPerDay[j+1] ; else skip ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer * 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int fnMod(int n){
    if(n % 5==1)return 4 ;
    else return 0 ;
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(fnMod(n));
    n=11 ;
    System.out.println(fnMod(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fnMod( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 5 = 1) then     return 4 else     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(fnMod(n)) ; 
     n := 11 ; 
     OclFile["System.out"].println(fnMod(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int getResult(int n){
    if((n & 1)>0)return 1 ;
    return-1 ;
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(getResult(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getResult( n : int) : int
  pre: true
  post: true
  activity: (     if ((n & 1) > 0) then     return 1 else skip ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(getResult(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int fib(int n){
    if(n<=1)return n ;
    return fib(n-1)+fib(n-2);
  }
  public static void main(String[] args){
    int n=6 ;
    System.out.println(fib(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fib( n : int) : int
  pre: true
  post: true
  activity: (     if (n <= 1) then     return n else skip ; 
     return fib(n - 1) + fib(n - 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(fib(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int pentagon_pyramidal(int n){
    return n*n*(n+1)/2 ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(pentagon_pyramidal(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pentagon_pyramidal( n : int) : int
  pre: true
  post: true
  activity: (     return n * n * (n + 1) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(pentagon_pyramidal(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findCullen(int n){
    return(1<<n)*n+1 ;
  }
  public static void main(String[] args){
    int n=2 ;
    System.out.println(findCullen(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findCullen( n : int) : int
  pre: true
  post: true
  activity: (     return ((1*(2->pow(n)))->oclAsType(long)) * n + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(findCullen(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static int countSetBits(int n){
    if(n==0)return 0 ;
    else return 1+countSetBits(n &(n-1));
  }
  public static void main(String[] args){
    int n=9 ;
    System.out.println(countSetBits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else     return 1 + countSetBits(n & (n - 1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     OclFile["System.out"].println(countSetBits(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countIntegralSolutions(int n){
    return((n+1)*(n+2))/2 ;
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(countIntegralSolutions(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countIntegralSolutions( n : int) : int
  pre: true
  post: true
  activity: (     return ((n + 1) * (n + 2)) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(countIntegralSolutions(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class div541B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int previousx=0,previousy=0 ;
    int ans=1 ;
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      if(previousx==x && previousy==y)continue ;
      int max=Math.max(previousx,previousy);
      int min=Math.min(x,y);
      if(previousx==previousy){
++max ;
      }
      if(max<=min){
        ans+=min-max+1 ;
      }
      previousx=x ;
      previousy=y ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class div541B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var previousx : int ; previousx := 0 ;
    var previousy : int ; previousy := 0 ;
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    if (previousx = x & previousy = y) then     continue else skip ; 
    var max : int ; max := Set{previousx, previousy}->max() ;
    var min : int ; min := Set{x, y}->min() ;
    if (previousx = previousy) then (     max := max + 1 ) else skip ; 
    if (max <= min) then (     ans := ans+(min - max + 1) ) else skip ; 
    previousx := x ; 
    previousy := y ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long centeredTridecagonalNum(long n){
    return(13*n*(n-1)+2)/2 ;
  }
  public static void main(String[] args){
    long n=3 ;
    System.out.println(centeredTridecagonalNum(n));
    n=10 ;
    System.out.println(centeredTridecagonalNum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation centeredTridecagonalNum( n : long) : long
  pre: true
  post: true
  activity: (     return (13 * n * (n - 1) + 2) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 3 ;
     OclFile["System.out"].println(centeredTridecagonalNum(n)) ; 
     n := 10 ; 
     OclFile["System.out"].println(centeredTridecagonalNum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int series(int n){
    return(8*n*n)+1 ;
  }
  public static void main(String args[]){
    int n=5 ;
    System.out.println(series(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation series( n : int) : int
  pre: true
  post: true
  activity: (     return (8 * n * n) + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(series(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.*;
import static java.util.Arrays.sort ;
import javafx.util.Pair ;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int n=input.nextInt();
    int male[]=new int[367];
    int female[]=new int[367];
    for(int i=0 ; i<n ; i++){
      char ch=input.next().charAt(0);
      int a=input.nextInt();
      int b=input.nextInt();
      if(ch=='M'){
        for(int j=a ; j<=b ; j++){
          male[j]++;
        }
      }
      else {
        for(int j=a ; j<=b ; j++){
          female[j]++;
        }
      }
    }
    int ans=Integer.MIN_VALUE ;
    for(int i=1 ; i<367 ; i++){
      ans=Math.max(ans,Math.min(male[i],female[i]));
    }
    System.out.println(ans*2);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var n : int ; n := input.nextInt() ;
    var male : Sequence(int) ; male := Integer.subrange(1,367)->collect(0) ;
    var female : Sequence(int) ; female := Integer.subrange(1,367)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var ch : String ; ch := input.next()->at(0+1) ;
     var a : int ; a := input.nextInt() ;
     var b : int ; b := input.nextInt() ;
     if (ch = 'M') then (         var j : int ; j := a ; while j <= b do ( (     male[j+1] := male[j+1] + 1 )  ;     j := j + 1 ) ) else (         var j : int ; j := a ; while j <= b do ( (     female[j+1] := female[j+1] + 1 )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -2147483648 ;
        var i : int ; i := 1 ; while i < 367 do ( (     ans := Set{ans, Set{male[i+1], female[i+1]}->min()}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans * 2) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int MAX=200006 ;
  static final int CONS=32766 ;
  static void calc(int a[],int b[],int lr[],int q,int n){
    int M,m,i,j,k,l,r,suma,sumb,cc ;
    cc=0 ;
    for(i=0 ; i<n-1 ; ++i){
      a[i+1]+=a[i];
      b[i+1]+=b[i];
    }
    while(q!=0){
      l=lr[cc++];
      r=lr[cc++];
      l-=2 ;
      r-=1 ;
      suma=a[r];
      sumb=b[r];
      if(l>=0){
        suma-=a[l];
        sumb-=b[l];
      }
      M=Math.max(CONS*suma+CONS*sumb,-CONS*suma-CONS*sumb);
      M=Math.max(M,Math.max(CONS*suma-CONS*sumb,-CONS*suma+CONS*sumb));
      m=Math.min(CONS*suma+CONS*sumb,-CONS*suma-CONS*sumb);
      m=Math.min(m,Math.min(CONS*suma-CONS*sumb,-CONS*suma+CONS*sumb));
      System.out.println((M-m));
      q--;
    }
  }
  public static void main(String[] args){
    int n=5,q=2 ;
    int[] a={
      0,7,3,4,5 };
      int[] b={
        0,3,1,2,3 };
        int[] lr=new int[q*2];
        lr[0]=1 ;
        lr[1]=1 ;
        lr[2]=1 ;
        lr[3]=3 ;
        calc(a,b,lr,q,n);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX : int := 200006;
  static    attribute CONS : int := 32766;
  static   operation calc( a : Sequence(int), b : Sequence(int), lr : Sequence(int), q : int, n : int) : void
  pre: true
  post: true
  activity: (     var M : int ;
    var m : int ;
    var i : int ;
    var j : int ;
    var k : int ;
    var l : int ;
    var r : int ;
    var suma : int ;
    var sumb : int ;
    var cc : int ;
     cc := 0 ; 
         i := 0 ; while i < n - 1 do ( (     a[i + 1+1] := a[i + 1+1]+(a[i+1]) ; 
     b[i + 1+1] := b[i + 1+1]+(b[i+1]) )  ;     i := i + 1 ) ; 
     while (q /= 0) do (      l := lr[cc+1]  ; cc := cc + 1 ; 
      r := lr[cc+1]  ; cc := cc + 1 ; 
    l := l-(2) ; 
    r := r-(1) ; 
    suma := a[r+1] ; 
    sumb := b[r+1] ; 
    if (l >= 0) then (     suma := suma-(a[l+1]) ; 
     sumb := sumb-(b[l+1]) ) else skip ; 
    M := Set{CONS * suma + CONS * sumb, -CONS * suma - CONS * sumb}->max() ; 
    M := Set{M, Set{CONS * suma - CONS * sumb, -CONS * suma + CONS * sumb}->max()}->max() ; 
    m := Set{CONS * suma + CONS * sumb, -CONS * suma - CONS * sumb}->min() ; 
    m := Set{m, Set{CONS * suma - CONS * sumb, -CONS * suma + CONS * sumb}->min()}->min() ; 
    OclFile["System.out"].println((M - m)) ; 
    q := q - 1 ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var q : int ; q := 2 ;
     var a : Sequence(int) ; a := Sequence{0,7,3,4,5} ;
    var b : Sequence(int) ; b := Sequence{0,3,1,2,3} ;
    var lr : Sequence(int) ; lr := Integer.subrange(1,q * 2)->collect(0) ;
    lr[0+1] := 1 ; 
    lr[1+1] := 1 ; 
    lr[2+1] := 1 ; 
    lr[3+1] := 3 ; 
    execute calc(a, b, lr, q, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    int[][] ans=getMatrix(n,k);
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<ans.length ; i++){
      for(int j=0 ; j<ans[0] .length ; j++){
        sb.append(ans[i][j]).append(" ");
      }
      sb.append("\n");
    }
    System.out.println(sb);
  }
  public static int[][] getMatrix(int n,int k){
    if(k>n*n){
      return new int[][] {
        {
-1 }
        };
      }
      int[][] ans=new int[n][n];
      for(int i=0 ; i<n && k>0 ; i++){
        ans[i][i]=1 ;
        k--;
        for(int j=i+1 ; j<n && k>1 ; j++){
          ans[i][j]=1 ;
          ans[j][i]=1 ;
          k-=2 ;
        }
      }
      return ans ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var ans : Sequence(Sequence(int)) ; ans := getMatrix(n, k) ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < ans->size() do ( (         var j : int ; j := 0 ; while j < ans[0+1]->size() do ( (     sb := sb + StringLib.newString(ans[i+1][j+1]) + StringLib.newString(" ") )  ;     j := j + 1 ) ; 
     sb := sb + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
  static   operation getMatrix( n : int, k : int) : Sequence(Sequence(int))
  pre: true
  post: true
  activity: (     if (k > n * n) then (     return Sequence{Sequence{-1}} ) else skip ; 
     var ans : Sequence(Sequence(int)) ; ans := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
         var i : int ; i := 0 ; while i < n & k > 0 do ( (     ans[i+1][i+1] := 1 ; 
     k := k - 1 ; 
         var j : int ; j := i + 1 ; while j < n & k > 1 do ( (     ans[i+1][j+1] := 1 ; 
     ans[j+1][i+1] := 1 ; 
     k := k-(2) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A803 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int K=in.nextInt();
    if(N*N<K){
      System.out.println("-1");
    }
    else {
      int[][] A=new int[N][N];
      for(int r=0 ; r<N ; r++){
        for(int c=0 ; c<N ; c++){
          if(K>0 && A[r][c]==0){
            if(r==c){
              A[r][c]=1 ;
              K--;
            }
            else if(K>1){
              A[r][c]=1 ;
              A[c][r]=1 ;
              K-=2 ;
            }
          }
        }
      }
      StringBuilder output=new StringBuilder();
      for(int r=0 ; r<N ; r++){
        for(int c=0 ; c<N ; c++){
          output.append(A[r][c]).append(' ');
        }
        output.append('\n');
      }
      System.out.print(output);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A803 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
     var K : int ; K := in.getCurrent()->toInteger() ;
     if (N * N < K) then (     OclFile["System.out"].println("-1") ) else (     var A : Sequence(Sequence(int)) ; A := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
         var r : int ; r := 0 ; while r < N do ( (         var c : int ; c := 0 ; while c < N do ( (     if (K > 0 & A[r+1][c+1] = 0) then (     if (r = c) then (     A[r+1][c+1] := 1 ; 
     K := K - 1 ) else     if (K > 1) then (     A[r+1][c+1] := 1 ; 
     A[c+1][r+1] := 1 ; 
     K := K-(2) ) else skip ; ) else skip )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    var output : String ; output := StringLib.newString() ;
        var r : int ; r := 0 ; while r < N do ( (         var c : int ; c := 0 ; while c < N do ( (     output := output + StringLib.newString(A[r+1][c+1]) + StringLib.newString(' ') )  ;     c := c + 1 ) ; 
     output := output + StringLib.newString('
') )  ;     r := r + 1 ) ; 
    OclFile["System.out"].print(output) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class MaximalBinaryMatrix {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    String[] temp=br.readLine().split(" ");
    int n=Integer.parseInt(temp[0]);
    int k=Integer.parseInt(temp[1]);
    if(k>n*n){
      pr.println(-1);
      return ;
    }
    int[][] res=new int[n][n];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(k<=1){
          break ;
        }
        if(res[i][j]==1){
          continue ;
        }
        res[i][j]=1 ;
        res[j][i]=1 ;
        k-=i==j ? 1 : 2 ;
      }
    }
    if(k==1){
      for(int i=0 ; i<n ; i++){
        if(res[i][i]==0){
          res[i][i]=1 ;
          break ;
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        pr.print(res[i][j]+" ");
      }
      pr.print('\n');
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MaximalBinaryMatrix {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
     var n : int ; n := (temp[0+1])->toInteger() ;
    var k : int ; k := (temp[1+1])->toInteger() ;
    if (k > n * n) then (     skip ; 
     return ) else skip ; 
    var res : Sequence(Sequence(int)) ; res := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (k <= 1) then (     break ) else skip ; 
     if (res[i+1][j+1] = 1) then (     continue ) else skip ; 
    res[i+1][j+1] := 1 ; 
    res[j+1][i+1] := 1 ; 
    k := k-(if i = j then 1 else 2 endif) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (k = 1) then (         var i : int ; i := 0 ; while i < n do ( (     if (res[i+1][i+1] = 0) then (     res[i+1][i+1] := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     skip )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findTrailingZeros(int n){
    if((n & 1)==1)return 0 ;
    else {
      int ans=0 ;
      n/=2 ;
      while(n!=0){
        ans+=n/5 ;
        n/=5 ;
      }
      return ans ;
    }
  }
  public static void main(String[] args){
    int n=12 ;
    System.out.println(findTrailingZeros(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findTrailingZeros( n : int) : int
  pre: true
  post: true
  activity: (     if ((n & 1) = 1) then     return 0 else (     var ans : int ; ans := 0 ;
     n := n/(2) ; 
     while (n /= 0) do (     ans := ans+(n / 5) ; 
     n := n/(5) ) ; 
     return ans ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     OclFile["System.out"].println(findTrailingZeros(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class trailzero {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    TreeSet<Character>t=new TreeSet();
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      char c=s.charAt(i);
      if(c>='a' && c<='z'){
        t.add(c);
      }
      else {
        ans=Math.max(ans,t.size());
        t=new TreeSet<>();
      }
    }
    ans=Math.max(ans,t.size());
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class trailzero {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var t : Set(String) ; t := Set{} ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var c : String ; c := s->at(i+1) ;
     if (c >= 'a' & c <= 'z') then (     t := t->including(c) ) else (     ans := Set{ans, t->size()}->max() ; 
     t := Set{} ) )  ;     i := i + 1 ) ; 
    ans := Set{ans, t->size()}->max() ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _864B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    HashSet<Character>set=new HashSet<>();
    int count=0,max=-1 ;
    for(char ch : s.toCharArray()){
      if(ch>='a' && ch<='z')set.add(ch);
      else set.clear();
      max=Math.max(set.size(),max);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _864B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var set : Set(String) ; set := Set{} ;
    var count : int ; count := 0 ;
    var max : int ; max := -1 ;
    for (ch : s->characters()) do ( (     if (ch >= 'a' & ch <= 'z') then     set := set->including(ch) else     set := set->intersection(Set{}) ; ;  
     max := Set{set->size(), max}->max() )  ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    sc.nextLine();
    String str=sc.nextLine();
    int j=1 ;
    int max=0 ;
    int count=0 ;
    Set<Character>set=new HashSet<>();
    for(int i=0 ; i<str.length(); i++){
      if(Character.isUpperCase(str.charAt(i))){
        count=0 ;
        set.clear();
      }
      else if(set.add(str.charAt(i))){
        set.add(str.charAt(i));
        count++;
      }
      if(count>max)max=count ;
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
    var str : String ; str := sc.nextLine() ;
    var j : int ; j := 1 ;
    var max : int ; max := 0 ;
    var count : int ; count := 0 ;
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if ((str->at(i+1)->toUpperCase() = str->at(i+1))) then (     count := 0 ; 
     set := set->intersection(Set{}) ) else     if (set->excludes(str->at(i+1))) then (     set := set->including(str->at(i+1)) ; 
     count := count + 1 ) else skip ; ;  
     if (count > max) then     max := count ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javafx.util.Pair ;
import java.io.*;
import java.util.*;
public class Draw {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    ArrayList<Pair>p=new ArrayList<>();
    p.add(new Pair(0,0));
    HashSet<Long>set=new HashSet<>();
    for(int i=0 ; i<n ; i++)p.add(new Pair(in.nextLong(),in.nextLong()));
    long ans=0 ;
    for(int i=1 ; i<=n ; i++){
      long max=Math.max(p.get(i-1).x,p.get(i-1).y);
      long min=Math.min(p.get(i).x,p.get(i).y);
      if(max>min)continue ;
      ans+=(min-max);
      if(! set.contains(max))ans++;
      set.add(max);
      set.add(min);
    }
    pw.println(ans);
    pw.close();
  }
  static class Pair {
    long x,y ;
    Pair(long x,long y){
      this.x=x ;
      this.y=y ;
    }
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Draw {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var p : Sequence(Map) ; p := Sequence{} ;
    p := p->including(Map(0, 0)) ; 
    var set : Set(long) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do (     p := p->including(Map(in.getCurrent()->toLong(), in.getCurrent()->toLong())) ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var max : long ; max := Set{p->at(i - 1+1).x, p->at(i - 1+1).y}->max() ;
     var min : long ; min := Set{p->at(i+1).x, p->at(i+1).y}->min() ;
    if (max > min) then     continue else skip ; 
    ans := ans+((min - max)) ; 
    if (not(set->includes(max))) then     ans := ans + 1 ; else skip ; 
    set := set->including(max) ; 
    set := set->including(min) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class Pair {
   attribute x : long;
   static operation newPair( x : long, y : long) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : long, y : long) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int distancesum(int x[],int y[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++)sum+=(Math.abs(x[i]-x[j])+Math.abs(y[i]-y[j]));
    return sum ;
  }
  public static void main(String[] args){
    int x[]={
-1,1,3,2 };
      int y[]={
        5,6,5,3 };
        int n=x.length ;
        System.out.println(distancesum(x,y,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation distancesum( x : Sequence(int), y : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do (     sum := sum+((if x[i+1] - x[j+1] < 0 then -(x[i+1] - x[j+1]) else x[i+1] - x[j+1] endif + if y[i+1] - y[j+1] < 0 then -(y[i+1] - y[j+1]) else y[i+1] - y[j+1] endif)) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : Sequence(int) ; x := Sequence{-1,1,3,2} ;
     var y : Sequence(int) ; y := Sequence{5,6,5,3} ;
     var n : int ; n := x->size() ;
     OclFile["System.out"].println(distancesum(x, y, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int T=sc.nextInt();
    for(int i=1 ; i<=T ; ++i){
      long N=sc.nextLong();
      System.out.printf("Case #%d: %d\n",i,solve(N));
    }
  }
  static long solve(long v){
    if(v<=10)return v ;
    int len=(""+v).length();
    long mod=1 ;
    for(int i=0 ; i<len/2 ; ++i){
      mod*=10 ;
    }
    if(v % mod==0)return solve(v-1)+1 ;
    long add=v % mod-1 ;
    v-=add ;
    long rev=0 ;
    long tmp=v ;
    while(tmp>0){
      rev*=10 ;
      rev+=tmp % 10 ;
      tmp/=10 ;
    }
    if(rev!=v)return solve(rev)+add+1 ;
    return solve(v-1)+add+1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= T do ( (     var N : long ; N := sc.getCurrent()->toLong() ;
     OclFile["System.out"].printf("Case #%d: %d\n", i, solve(N)) )  ;     i := i + 1 ) );
  static   operation solve( v : long) : long
  pre: true
  post: true
  activity: (     if (v <= 10) then     return v else skip ; 
     var len : int ; len := ("" + v)->size() ;
    var mod : long ; mod := 1 ;
        var i : int ; i := 0 ; while i < len / 2 do ( (     mod := mod*(10) )  ;     i := i + 1 ) ; 
    if (v mod mod = 0) then     return solve(v - 1) + 1 else skip ; 
    var add : long ; add := v mod mod - 1 ;
    v := v-(add) ; 
    var rev : long ; rev := 0 ;
    var tmp : long ; tmp := v ;
    while (tmp > 0) do (     rev := rev*(10) ; 
     rev := rev+(tmp mod 10) ; 
     tmp := tmp/(10) ) ; 
    if (rev /= v) then     return solve(rev) + add + 1 else skip ; 
    return solve(v - 1) + add + 1 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A {
  static long[] POW10=new long[20];
  static {
    POW10[0]=1 ;
    for(int i=1 ; i<POW10.length ; i++)POW10[i]=POW10[i-1]*10 ;
  }
  public static void main(String...orange)throws Exception {
    Scanner input=new Scanner(System.in);
    int numCases=input.nextInt();
    for(int n=0 ; n<numCases ; n++){
      String s=input.next();
      long l=Long.parseLong(s);
      boolean zero=l % POW10[s.length()/2]==0 ;
      if(zero){
        l--;
        s=l+"" ;
      }
      long ans=0 ;
      for(int d=1 ; d<s.length(); d++)ans+=POW10[d/2]+POW10[(d+1)/2]-1 ;
      String sb="0"+s.substring(0,s.length()/2);
      if(s.length()>1 && Long.parseLong(sb)!=POW10[s.length()/2-1]){
        ans+=Long.parseLong("0"+new StringBuilder(s.substring(0,s.length()/2)).reverse().toString());
      }
      ans+=Long.parseLong("0"+s.substring(s.length()/2));
      if(zero)ans++;
      System.out.printf("Case #%d: ",n+1);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute POW10 : Sequence(long) := Integer.subrange(1,20)->collect(0);
  static operation initialiseClass()
  pre: true post: true
  activity:     POW10[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < POW10->size() do (     POW10[i+1] := POW10[i - 1+1] * 10 ;  ;     i := i + 1 ) ; 
;
  static   operation main( orange : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numCases : int ; numCases := input.getCurrent()->toInteger() ;
         var n : int ; n := 0 ; while n < numCases do ( (     var s : String ; s := input.getCurrent() ;
     var l : long ; l := (s)->toLong() ;
    var zero : boolean ; zero := l mod POW10[s->size() / 2+1] = 0 ;
    if (zero) then (     l := l - 1 ; 
     s := l + "" ) else skip ; 
    var ans : long ; ans := 0 ;
        var d : int ; d := 1 ; while d < s->size() do (     ans := ans+(POW10[d / 2+1] + POW10[(d + 1) / 2+1] - 1) ;  ;     d := d + 1 ) ; 
    var sb : String ; sb := "0" + s.subrange(0+1,s->size() / 2) ;
    if (s->size() > 1 & (sb)->toLong() /= POW10[s->size() / 2 - 1+1]) then (     ans := ans+(("0" + StringLib.newString(s.subrange(0+1,s->size() / 2))->reverse()+"")->toLong()) ) else skip ; 
    ans := ans+(("0" + s.subrange(s->size() / 2+1,s->size() / 2))->toLong()) ; 
    if (zero) then     ans := ans + 1 ; else skip ; 
    OclFile["System.out"].printf("Case #%d: ", n + 1) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     n := n + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Slam {
  static int[] basic=new int[15];
  {
    basic[1]=10 ;
    for(int i=2 ; i<15 ; i++){
      if(i % 2==0){
        basic[i]=basic[i-1]+2*(int)(Math.pow(10,i/2))-1 ;
      }
      else {
        basic[i]=basic[i-1]+(int)((Math.pow(10,i/2))+(Math.pow(10,(i+1)/2))-1);
      }
    }
  }
  static boolean allzero(String t){
    for(char ch : t.toCharArray())if(ch!='0')return false ;
    return true ;
  }
  static long f(long v){
    if(v<10)return v ;
    int L=(""+v).length();
    String right=(""+v).substring(L/2,L);
    String left=(""+v).substring(0,L/2);
    if(allzero(right))return 1+f(v-1);
    long result=basic[L-1]+Integer.parseInt(right)+Integer.parseInt(new StringBuilder(left).reverse().toString());
    result=Math.min(result,basic[L-1]+(v-(long)Math.pow(10,L-1)));
    return result ;
  }
  public static void main(String[] args){
    new Slam();
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    for(int kk=1 ; kk<=k ; kk++)System.out.println("Case #"+kk+": "+f(sc.nextLong()));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Slam {
  static   attribute basic : Sequence(int) := Integer.subrange(1,15)->collect(0);
  operation initialiseInstance()
  pre: true post: true
  activity:     basic[1+1] := 10 ; 
        var i : int ; i := 2 ; while i < 15 do ( (     if (i mod 2 = 0) then (     basic[i+1] := basic[i - 1+1] + 2 * (10->pow(i / 2))->oclAsType(int) - 1 ) else (     basic[i+1] := basic[i - 1+1] + ((10->pow(i / 2)) + (10->pow((i + 1) / 2)) - 1)->oclAsType(int) ) )  ;     i := i + 1 ) ; 
;
  static   operation allzero( t : String) : boolean
  pre: true
  post: true
  activity: (     for (ch : t->characters()) do (     if (ch /= '0') then     return false else skip ;  ) ; 
     return true );
  static   operation f( v : long) : long
  pre: true
  post: true
  activity: (     if (v < 10) then     return v else skip ; 
     var L : int ; L := ("" + v)->size() ;
    var right : String ; right := ("" + v).subrange(L / 2+1,L) ;
    var left : String ; left := ("" + v).subrange(0+1,L / 2) ;
    if (allzero(right)) then     return 1 + f(v - 1) else skip ; 
    var result : long ; result := basic[L - 1+1] + (right)->toInteger() + (StringLib.newString(left)->reverse()+"")->toInteger() ;
    result := Set{result, basic[L - 1+1] + (v - 10->pow(L - 1)->oclAsType(long))}->min() ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Slam.newSlam() ; 
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
         var kk : int ; kk := 1 ; while kk <= k do (     OclFile["System.out"].println("Case #" + kk + ": " + f(sc.getCurrent()->toLong())) ;  ;     kk := kk + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
(new Main()).solve();
  }
  void solve(){
    Scanner cin=new Scanner(System.in);
    int T=cin.nextInt();
    for(int C=1 ; C<=T ; ++C){
      String s=cin.next();
      System.out.println("Case #"+C+": "+solve(s));
    }
  }
  long solve(String s){
    if(Long.parseLong(s)==0){
      return 0 ;
    }
    int N=s.length();
    String head=s.substring(0,N/2);
    String tail=s.substring(N/2);
    long tmp=Long.parseLong(tail);
    if(tmp==0){
      return 1+solve(""+(Long.parseLong(s)-1));
    }
    String next=""+(Long.parseLong(s)-(tmp-1));
    String rev=rev(next);
    if(Long.parseLong(next)==Long.parseLong(rev)){
      return tmp+solve(""+(Long.parseLong(s)-tmp));
    }
    return tmp+solve(rev);
  }
  String rev(String s){
    return(new StringBuilder(s)).reverse().toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := cin.getCurrent()->toInteger() ;
         var C : int ; C := 1 ; while C <= T do ( (     var s : String ; s := cin.getCurrent() ;
     OclFile["System.out"].println("Case #" + C + ": " + solve(s)) )  ;     C := C + 1 ) );
   operation solve( s : String) : long
  pre: true
  post: true
  activity: (     if ((s)->toLong() = 0) then (     return 0 ) else skip ; 
     var N : int ; N := s->size() ;
    var head : String ; head := s.subrange(0+1,N / 2) ;
    var tail : String ; tail := s.subrange(N / 2+1,N / 2) ;
    var tmp : long ; tmp := (tail)->toLong() ;
    if (tmp = 0) then (     return 1 + solve("" + ((s)->toLong() - 1)) ) else skip ; 
    var next : String ; next := "" + ((s)->toLong() - ((tmp)->char2byte() - 1)) ;
    var rev : String ; rev := rev(next) ;
    if ((next)->toLong() = (rev)->toLong()) then (     return tmp + solve("" + ((s)->toLong() - (tmp)->char2byte())) ) else skip ; 
    return tmp + solve(rev) 
 );
   operation rev( s : String) : String
  pre: true
  post: true
  activity: (     return (StringLib.newString(s))->reverse()+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A {
  String solve(Scanner sc){
    int N=sc.nextInt();
    int[] dp=new int[N+1];
    dp[1]=1 ;
    for(int i=2 ; i<=N ; i++){
      dp[i]=Integer.MAX_VALUE ;
    }
    for(int i=1 ; i<N ; i++){
      dp[i+1]=Math.min(dp[i+1],dp[i]+1);
      int r=reverse(i);
      if(r<=N){
        dp[r]=Math.min(dp[r],dp[i]+1);
      }
    }
    return ""+dp[N];
  }
  int reverse(int N){
    int r=0 ;
    while(N>0){
      r*=10 ;
      r+=N % 10 ;
      N/=10 ;
    }
    return r ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    for(int cs=1 ; cs<=T ; cs++){
      String res=new A().solve(sc);
      System.out.println("Case #"+cs+": "+res);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   operation solve( sc : OclFile) : String
  pre: true
  post: true
  activity: (     var N : int ; N := sc.nextInt() ;
     var dp : Sequence(int) ; dp := Integer.subrange(1,N + 1)->collect(0) ;
    dp[1+1] := 1 ; 
        var i : int ; i := 2 ; while i <= N do ( (     dp[i+1] := 2147483647 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < N do ( (     dp[i + 1+1] := Set{dp[i + 1+1], dp[i+1] + 1}->min() ; 
     var r : int ; r := reverse(i) ;
     if (r <= N) then (     dp[r+1] := Set{dp[r+1], dp[i+1] + 1}->min() ) else skip )  ;     i := i + 1 ) ; 
    return "" + dp[N+1] 
 );
   operation reverse( N : int) : int
  pre: true
  post: true
  activity: (     var r : int ; r := 0 ;
     while (N > 0) do (     r := r*(10) ; 
     r := r+(N mod 10) ; 
     N := N/(10) ) ; 
     return r );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var cs : int ; cs := 1 ; while cs <= T do ( (     var res : String ; res := A.newA().solve(sc) ;
     OclFile["System.out"].println("Case #" + cs + ": " + res) )  ;     cs := cs + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    for(int i=0 ; i<n ; i++){
      int len=input.nextInt();
      int[] nums=new int[len];
      for(int j=0 ; j<len ; j++){
        nums[j]=input.nextInt();
      }
      func(nums);
    }
  }
  public static boolean func(int[] nums){
    for(int i=0 ; i<nums.length ; i++){
      if(nums[i] % 2==0){
        System.out.println(1);
        System.out.println(i+1);
        return true ;
      }
    }
    int[] res=new int[2];
    int index=0 ;
    for(int i=0 ; i<nums.length ; i++){
      if(nums[i] % 2!=0){
        res[index]=i+1 ;
        index++;
        if(index>1){
          break ;
        }
      }
    }
    if(index<2){
      System.out.println(-1);
      return false ;
    }
    else {
      System.out.println(2);
      System.out.println(res[0]+" "+res[1]);
      return true ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var len : int ; len := input.getCurrent()->toInteger() ;
     var nums : Sequence(int) ; nums := Integer.subrange(1,len)->collect(0) ;
         var j : int ; j := 0 ; while j < len do ( (     nums[j+1] := input.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
     execute func(nums) )  ;     i := i + 1 ) );
  static   operation func( nums : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < nums->size() do ( (     if (nums[i+1] mod 2 = 0) then (     OclFile["System.out"].println(1) ; 
     OclFile["System.out"].println(i + 1) ; 
     return true ) else skip )  ;     i := i + 1 ) ; 
     var res : Sequence(int) ; res := Integer.subrange(1,2)->collect(0) ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < nums->size() do ( (     if (nums[i+1] mod 2 /= 0) then (     res[index+1] := i + 1 ; 
     index := index + 1 ; 
     if (index > 1) then (     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (index < 2) then (     OclFile["System.out"].println(-1) ; 
     return false ) else (     OclFile["System.out"].println(2) ; 
     OclFile["System.out"].println(res[0+1] + " " + res[1+1]) ; 
     return true ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    new Main().solve();
  }
  private void solve(){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      int even=-1 ;
      int odd1=-1 ;
      int odd2=-1 ;
      for(int i=0 ; i<n ; i++){
        if(a[i] % 2!=0){
          if(odd1==-1){
            odd1=i ;
          }
          else if(odd2==-1){
            odd2=i ;
          }
        }
        else if(even==-1){
          even=i ;
        }
      }
      if(even!=-1){
        System.out.println(1);
        System.out.println(++even);
      }
      else if(odd1!=-1 && odd2!=-1){
        System.out.println(2);
        System.out.println(++odd1+" "+++odd2);
      }
      else {
        System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var even : int ; even := -1 ;
    var odd1 : int ; odd1 := -1 ;
    var odd2 : int ; odd2 := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] mod 2 /= 0) then (     if (odd1 = -1) then (     odd1 := i ) else     if (odd2 = -1) then (     odd2 := i ) else skip ; ) else     if (even = -1) then (     even := i ) else skip ; )  ;     i := i + 1 ) ; 
    if (even /= -1) then (     OclFile["System.out"].println(1) ; 
     OclFile["System.out"].println((even + 1)) ) else     if (odd1 /= -1 & odd2 /= -1) then (     OclFile["System.out"].println(2) ; 
     OclFile["System.out"].println((odd1 + 1) + " " + odd2) ) else (     OclFile["System.out"].println(-1) ) ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNextInt()){
      int m=in.nextInt();
      while(m-->0){
        int n=in.nextInt();
        int[] num=new int[n];
        for(int i=0 ; i<n ; i++){
          num[i]=in.nextInt();
        }
        solution(num);
      }
    }
  }
  public static void solution(int[] num){
    List<Integer>index=new LinkedList<>();
    int sum=Arrays.stream(num).sum();
    if(sum % 2==1){
      if(num.length==1){
        System.out.println(-1);
        return ;
      }
      System.out.println(num.length-1);
      boolean f=true ;
      for(int i=0 ; i<num.length ; i++){
        if(f && num[i] % 2==1){
          f=false ;
          continue ;
        }
        System.out.print(i+1);
        System.out.print(" ");
      }
      System.out.println();
    }
    else {
      System.out.println(num.length);
      for(int i=0 ; i<num.length ; i++){
        System.out.print(i+1);
        System.out.print(" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNextInt()) do (     var m : int ; m := in.getCurrent()->toInteger() ;
         while (m > 0) do (        m := m - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var num : Sequence(int) ; num := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     num[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     execute solution(num) ) ;  ) ) );
  static   operation solution( num : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var index : Sequence(int) ; index := Sequence{} ;
     var sum : int ; sum := stream(num)->sum() ;
     if (sum mod 2 = 1) then (     if (num->size() = 1) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
     OclFile["System.out"].println(num->size() - 1) ; 
    var f : boolean ; f := true ;
        var i : int ; i := 0 ; while i < num->size() do ( (     if (f & num[i+1] mod 2 = 1) then (     f := false ; 
     continue ) else skip ; 
     OclFile["System.out"].print(i + 1) ; 
     OclFile["System.out"].print(" ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) else (     OclFile["System.out"].println(num->size()) ; 
         var i : int ; i := 0 ; while i < num->size() do ( (     OclFile["System.out"].print(i + 1) ; 
     OclFile["System.out"].print(" ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class EvenSubsetSumProblem {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    int n,a,x,j ;
    boolean found ;
    while(t-->0){
      n=s.nextInt();
      a=s.nextInt();
      j=0 ;
      found=false ;
      if(a % 2==0){
        System.out.println("1");
        System.out.println(j+1);
        found=true ;
      }
      x=a ;
      for(int i=1 ; i<n ; i++){
        a=s.nextInt();
        if(! found && a % 2==0){
          System.out.println("1");
          System.out.println((i+1));
          found=true ;
        }
        else if(! found && x % 2!=0){
          System.out.println("2");
          System.out.println((j+1)+" "+(i+1));
          found=true ;
        }
        x=a ;
        j=i ;
      }
      if(! found)System.out.println("-1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class EvenSubsetSumProblem {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
    var n : int ;
    var a : int ;
    var x : int ;
    var j : int ;
    var found : boolean ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     n := s.getCurrent()->toInteger() ; 
     a := s.getCurrent()->toInteger() ; 
    j := 0 ; 
    found := false ; 
    if (a mod 2 = 0) then (     OclFile["System.out"].println("1") ; 
     OclFile["System.out"].println(j + 1) ; 
     found := true ) else skip ; 
    x := a ; 
        var i : int ; i := 1 ; while i < n do ( (     a := s.getCurrent()->toInteger() ; 
     if (not(found) & a mod 2 = 0) then (     OclFile["System.out"].println("1") ; 
     OclFile["System.out"].println((i + 1)) ; 
     found := true ) else     if (not(found) & x mod 2 /= 0) then (     OclFile["System.out"].println("2") ; 
     OclFile["System.out"].println((j + 1) + " " + (i + 1)) ; 
     found := true ) else skip ; ;  
     x := a ; 
     j := i )  ;     i := i + 1 ) ; 
    if (not(found)) then     OclFile["System.out"].println("-1") ; else skip ; 
 ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int minimumSets(int arr[],int n,int key){
    int i,j ;
    Arrays.sort(arr);
    for(i=0,j=n-1 ; i<=j ; ++i)if(arr[i]+arr[j]<=key)j--;
    return i ;
  }
  public static void main(String[] args){
    int[] arr={
      3,5,3,4 };
      int n=arr.length ;
      int key=5 ;
      System.out.println(minimumSets(arr,n,key));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumSets( arr : Sequence(int), n : int, key : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     arr := arr->sort() ; 
         i := 0 ;     j := n - 1 ; while i <= j do (     if (arr[i+1] + arr[j+1] <= key) then     j := j - 1 ; else skip ;  ;     i := i + 1 ) ; 
     return i );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,5,3,4} ;
     var n : int ; n := arr->size() ;
     var key : int ; key := 5 ;
     OclFile["System.out"].println(minimumSets(arr, n, key)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args){
    int n=0 ;
    int[] d=null ;
    int[] b=new int[101];
    try {
      BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
      String s=reader.readLine();
      n=Integer.parseInt(s);
      d=new int[n];
      for(int i=0 ; i<n ; i++){
        d[i]=Integer.parseInt(reader.readLine());
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
    int c=0 ;
    for(int i=0 ; i<n ; i++){
      b[d[i] ]++;
      if(b[d[i] ]==1){
        c++;
      }
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 0 ;
     var d : Sequence(int) ; d := null ;
    var b : Sequence(int) ; b := Integer.subrange(1,101)->collect(0) ;
    try (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := reader.readLine() ;
    n := (s)->toInteger() ; 
    d := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     d[i+1] := (reader.readLine())->toInteger() )  ;     i := i + 1 ) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     b[d[i+1]+1] := b[d[i+1]+1] + 1 ; 
     if (b[d[i+1]+1] = 1) then (     c := c + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
class GFG {
  static int fib(int n){
    double phi=(1+Math.sqrt(5))/2 ;
    return(int)Math.round(Math.pow(phi,n)/Math.sqrt(5));
  }
  static int calculateSum(int l,int r){
    int sum=0 ;
    for(int i=l ; i<=r ; i++)sum+=fib(i);
    return sum ;
  }
  public static void main(String[] args){
    int l=4,r=8 ;
    System.out.println(calculateSum(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fib( n : int) : int
  pre: true
  post: true
  activity: (     var phi : double ; phi := (1 + (5)->sqrt()) / 2 ;
     return (phi->pow(n) / (5)->sqrt())->round()->oclAsType(int) );
  static   operation calculateSum( l : int, r : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := l ; while i <= r do (     sum := sum+(fib(i)) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 4 ;
    var r : int ; r := 8 ;
     OclFile["System.out"].println(calculateSum(l, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class GFG {
  static int commonWords(String[] s){
    int m,i,j ;
    String str ;
    HashMap<String,Boolean>has=new HashMap<>();
    String[] ans1=new String[100];
    boolean[] ans2=new boolean[100];
    int track=0 ;
    m=s.length ;
    i=0 ;
    while(i<s[0] .length()){
      str="" ;
      while(i<s[0] .length()&& s[0] .charAt(i)!=' '){
        str+=s[0] .charAt(i);
        i++;
      }
      i++;
      if(str.compareTo("")!=0){
        ans1[track]=str ;
        ans2[track]=true ;
        track++;
      }
    }
    for(j=1 ; j<m ; j++){
      has.clear();
      i=0 ;
      while(i<s[j] .length()){
        str="" ;
        while(i<s[j] .length()&& s[j] .charAt(i)!=' '){
          str+=s[j] .charAt(i);
          i++;
        }
        i++;
        if(str.compareTo("")!=0)has.put(str,true);
      }
      for(int k=0 ; k<track ; k++){
        if(ans2[k]!=false && ! has.containsKey(ans1[k]))ans2[k]=false ;
        else if(ans2[k]!=false && has.containsKey(ans1[k])&& has.get(ans1[k])==true)has.put(ans1[k],false);
      }
    }
    int cnt=0 ;
    for(int k=0 ; k<track ; k++)if(ans2[k]==true)cnt++;
    return cnt ;
  }
  public static void main(String[] args){
    String[] s={
      "there is a cow","cow is our mother","cow gives us milk and milk is sweet","there is a boy who loves cow" };
      System.out.println(commonWords(s));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation commonWords( s : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var m : int ;
    var i : int ;
    var j : int ;
     var str : String ;
    var has : Map(String,Boolean) ; has := Map{} ;
    var ans1 : Sequence(String) ; ans1 := Integer.subrange(1,100)->collect(null) ;
    var ans2 : Sequence(boolean) ; ans2 := Integer.subrange(1,100)->collect(false) ;
    var track : int ; track := 0 ;
    m := s->size() ; 
    i := 0 ; 
    while (i < s[0+1]->size()) do (     str := "" ; 
     while (i < s[0+1]->size() & s[0+1]->at(i+1) /= ' ') do (     str := str+(s[0+1]->at(i+1)) ; 
     i := i + 1 ) ; 
     i := i + 1 ; 
     if (str->compareTo("") /= 0) then (     ans1[track+1] := str ; 
     ans2[track+1] := true ; 
     track := track + 1 ) else skip ) ; 
        j := 1 ; while j < m do ( (     has := has->intersection(Map{}) ; 
     i := 0 ; 
     while (i < s[j+1]->size()) do (     str := "" ; 
     while (i < s[j+1]->size() & s[j+1]->at(i+1) /= ' ') do (     str := str+(s[j+1]->at(i+1)) ; 
     i := i + 1 ) ; 
     i := i + 1 ; 
     if (str->compareTo("") /= 0) then     has := has->union(Map{str |-> true}) ; else skip ) ; 
         var k : int ; k := 0 ; while k < track do ( (     if (ans2[k+1] /= false & not(has->keys()->includes(ans1[k+1]))) then     ans2[k+1] := false ; else     if (ans2[k+1] /= false & has->keys()->includes(ans1[k+1]) & has->at(ans1[k+1]) = true) then     has := has->union(Map{ans1[k+1] |-> false}) ; else skip ; )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var k : int ; k := 0 ; while k < track do (     if (ans2[k+1] = true) then     cnt := cnt + 1 ; else skip ;  ;     k := k + 1 ) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := Sequence{"there is a cow","cow is our mother","cow gives us milk and milk is sweet","there is a boy who loves cow"} ;
     OclFile["System.out"].println(commonWords(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int dayNum=scan.nextInt();
    int chcolotaNum=scan.nextInt();
    int[] arr=new int[dayNum];
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=scan.nextInt();
    }
    int res=0 ;
    int sum=0 ;
    for(int i=0 ; i<arr.length ; i++){
      if(i!=arr.length-1){
        if(arr[i]>=8){
          arr[i+1]+=(arr[i]-8);
          sum+=8 ;
          res++;
          if(sum>=chcolotaNum){
            System.out.println(res);
            break ;
          }
        }
        else {
          sum+=arr[i];
          res++;
          if(sum>=chcolotaNum){
            System.out.println(res);
            break ;
          }
        }
      }
      else {
        if(arr[i]>=8){
          sum+=8 ;
          res++;
          if(sum>=chcolotaNum){
            System.out.println(res);
          }
          else {
            System.out.println(-1);
          }
        }
        else {
          sum+=arr[i];
          res++;
          if(sum>=chcolotaNum){
            System.out.println(res);
          }
          else {
            System.out.println(-1);
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dayNum : int ; dayNum := scan.getCurrent()->toInteger() ;
    var chcolotaNum : int ; chcolotaNum := scan.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,dayNum)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (i /= arr->size() - 1) then (     if (arr[i+1] >= 8) then (     arr[i + 1+1] := arr[i + 1+1]+((arr[i+1] - 8)) ; 
     sum := sum+(8) ; 
     res := res + 1 ; 
     if (sum >= chcolotaNum) then (     OclFile["System.out"].println(res) ; 
     break ) else skip ) else (     sum := sum+(arr[i+1]) ; 
     res := res + 1 ; 
     if (sum >= chcolotaNum) then (     OclFile["System.out"].println(res) ; 
     break ) else skip ) ) else (     if (arr[i+1] >= 8) then (     sum := sum+(8) ; 
     res := res + 1 ; 
     if (sum >= chcolotaNum) then (     OclFile["System.out"].println(res) ) else (     OclFile["System.out"].println(-1) ) ) else (     sum := sum+(arr[i+1]) ; 
     res := res + 1 ; 
     if (sum >= chcolotaNum) then (     OclFile["System.out"].println(res) ) else (     OclFile["System.out"].println(-1) ) ) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CandieCheck {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String inputLine1=in.nextLine();
    String[] in1=inputLine1.split(" ");
    String inputLine2=in.nextLine();
    String[] in2=inputLine2.split(" ");
    int days=0,i=0 ;
    int[] totalCandies=new int[in2.length];
    in.close();
    int numOfDays=Integer.parseInt(in1[0]);
    int numOfCandies=Integer.parseInt(in1[1]);
    for(int j=0 ; j<in2.length ; j++){
      totalCandies[j]=Integer.parseInt(in2[j]);
    }
    while(days<numOfDays && numOfCandies>0 && i<totalCandies.length){
      if(totalCandies[i]>8){
        totalCandies[i]-=8 ;
        numOfCandies-=8 ;
        if(i<totalCandies.length-1){
          totalCandies[i+1]+=totalCandies[i];
        }
      }
      else {
        numOfCandies-=totalCandies[i];
      }
      i++;
      days++;
    }
    if(numOfCandies<=0){
      System.out.println(days);
    }
    else {
      System.out.println("-1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CandieCheck {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inputLine1 : String ; inputLine1 := in.nextLine() ;
    var in1 : Sequence(String) ; in1 := inputLine1->split(" ") ;
    var inputLine2 : String ; inputLine2 := in.nextLine() ;
    var in2 : Sequence(String) ; in2 := inputLine2->split(" ") ;
    var days : int ; days := 0 ;
    var i : int ; i := 0 ;
    var totalCandies : Sequence(int) ; totalCandies := Integer.subrange(1,in2->size())->collect(0) ;
    skip ; 
    var numOfDays : int ; numOfDays := (in1[0+1])->toInteger() ;
    var numOfCandies : int ; numOfCandies := (in1[1+1])->toInteger() ;
        var j : int ; j := 0 ; while j < in2->size() do ( (     totalCandies[j+1] := (in2[j+1])->toInteger() )  ;     j := j + 1 ) ; 
    while (days < numOfDays & numOfCandies > 0 & i < totalCandies->size()) do (     if (totalCandies[i+1] > 8) then (     totalCandies[i+1] := totalCandies[i+1]-(8) ; 
     numOfCandies := numOfCandies-(8) ; 
     if (i < totalCandies->size() - 1) then (     totalCandies[i + 1+1] := totalCandies[i + 1+1]+(totalCandies[i+1]) ) else skip ) else (     numOfCandies := numOfCandies-(totalCandies[i+1]) ) ;  
     i := i + 1 ; 
     days := days + 1 ) ; 
    if (numOfCandies <= 0) then (     OclFile["System.out"].println(days) ) else (     OclFile["System.out"].println("-1") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class AryaAndBran {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int sum=0 ;
    int temp=0 ;
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      x+=temp ;
      int y=Math.min(8,x);
      sum+=y ;
      temp=x-y ;
      if(sum>=k){
        count=i+1 ;
        break ;
      }
    }
    if(count==0){
      System.out.println(-1);
    }
    else {
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AryaAndBran {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var temp : int ; temp := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     x := x+(temp) ; 
    var y : int ; y := Set{8, x}->min() ;
    sum := sum+(y) ; 
    temp := x - y ; 
    if (sum >= k) then (     count := i + 1 ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (count = 0) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(count) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int sumOfTheSeries(int n){
    int sum=0 ;
    for(int i=1 ; i<=n ; i++){
      int k=1 ;
      for(int j=1 ; j<=i ; j++){
        sum+=k ;
        k+=2 ;
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println("Sum="+sumOfTheSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfTheSeries( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     var k : int ; k := 1 ;
         var j : int ; j := 1 ; while j <= i do ( (     sum := sum+(k) ; 
     k := k+(2) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println("Sum=" + sumOfTheSeries(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPowerOfTwo(int n){
    return n!=0 &&((n &(n-1))==0);
  }
  static int previousPowerOfTwo(int n){
    while((n & n-1)>1){
      n=n & n-1 ;
    }
    return n ;
  }
  static boolean checkSum(int n){
    if(n==0 || n==1)return false ;
    else if(isPowerOfTwo(n)){
      System.out.println(n/2+" "+n/2);
    }
    else {
      int x=previousPowerOfTwo(n);
      int y=n-x ;
      if(isPowerOfTwo(y)){
        System.out.println(x+" "+y);
        return true ;
      }
    }
    return false ;
  }
  public static void main(String[] argc){
    int n1=20 ;
    if(checkSum(n1)==false)System.out.println("No");
    System.out.println();
    int n2=11 ;
    if(checkSum(n2)==false)System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPowerOfTwo( n : int) : boolean
  pre: true
  post: true
  activity: (     return n /= 0 & ((n & (n - 1)) = 0) );
  static   operation previousPowerOfTwo( n : int) : int
  pre: true
  post: true
  activity: (     while ((n & n - 1) > 1) do (     n := n & n - 1 ) ; 
     return n );
  static   operation checkSum( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 0 or n = 1) then     return false else     if (isPowerOfTwo(n)) then (     OclFile["System.out"].println(n / 2 + " " + n / 2) ) else (     var x : int ; x := previousPowerOfTwo(n) ;
     var y : int ; y := n - x ;
     if (isPowerOfTwo(y)) then (     OclFile["System.out"].println(x + " " + y) ; 
     return true ) else skip ) ;  ;  
     return false );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n1 : int ; n1 := 20 ;
     if (checkSum(n1) = false) then     OclFile["System.out"].println("No") ; else skip ; 
    OclFile["System.out"].println() ; 
    var n2 : int ; n2 := 11 ;
    if (checkSum(n2) = false) then     OclFile["System.out"].println("No") ; else skip ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countSubarray(int arr[],int n,int k){
    int start=0,end=0 ;
    int count=0,sum=arr[0];
    while(start<n && end<n){
      if(sum<k){
        end++;
        if(end>=start)count+=end-start ;
        if(end<n)sum+=arr[end];
      }
      else {
        sum-=arr[start];
        start++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int array[]={
      1,11,2,3,15 };
      int k=10 ;
      int size=array.length ;
      int count=countSubarray(array,size,k);
      System.out.println(count);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSubarray( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var start : int ; start := 0 ;
    var end : int ; end := 0 ;
     var count : int ; count := 0 ;
    var sum : int ; sum := arr[0+1] ;
     while (start < n & end < n) do (     if (sum < k) then (     end := end + 1 ; 
     if (end >= start) then     count := count+(end - start) ; else skip ; 
     if (end < n) then     sum := sum+(arr[end+1]) ; else skip ) else (     sum := sum-(arr[start+1]) ; 
     start := start + 1 ) ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Sequence{1,11,2,3,15} ;
     var k : int ; k := 10 ;
    var size : int ; size := array->size() ;
    var count : int ; count := countSubarray(array, size, k) ;
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.util.*;
public class TpoDoList {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int k=s.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=s.nextInt();
    ArrayList<ArrayList<Integer>>list=new ArrayList<>();
    int size=n/k ;
    for(int i=0 ; i<k ; i++){
      int m=i ;
      ArrayList<Integer>temp=new ArrayList<>();
      for(int j=0 ; j<size ; j++){
        temp.add(m);
        m=(m+k)% n ;
      }
      list.add(temp);
    }
    int max=Integer.MAX_VALUE ;
    int ans=0 ;
    for(ArrayList<Integer>i : list){
      int sum=0 ;
      int val=0 ;
      for(int j=0 ; j<i.size(); j++){
        if(j==0)val=i.get(j);
        sum+=a[i.get(j)];
      }
      if(sum<max){
        max=sum ;
        ans=val ;
      }
    }
    System.out.println(ans+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class TpoDoList {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var k : int ; k := s.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var list : Sequence(Sequence(int)) ; list := Sequence{} ;
    var size : int ; size := n / k ;
        var i : int ; i := 0 ; while i < k do ( (     var m : int ; m := i ;
     var temp : Sequence(int) ; temp := Sequence{} ;
         var j : int ; j := 0 ; while j < size do ( (     temp := temp->including(m) ; 
     m := (m + k) mod n )  ;     j := j + 1 ) ; 
     list := list->including(temp) )  ;     i := i + 1 ) ; 
    var max : int ; max := 2147483647 ;
    var ans : int ; ans := 0 ;
    for (i : list) do ( (     var sum : int ; sum := 0 ;
     var val : int ; val := 0 ;
         var j : int ; j := 0 ; while j < i->size() do ( (     if (j = 0) then     val := i->at(j+1) ; else skip ; 
     sum := sum+(a[i->at(j+1)+1]) )  ;     j := j + 1 ) ; 
     if (sum < max) then (     max := sum ; 
     ans := val ) else skip )  ) ; 
    OclFile["System.out"].println(ans + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class b366 {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int d=scan.nextInt();
    int a[]=new int[n];
    long b[]=new long[d];
    for(int i=0 ; i<n ; i++){
      a[i]=scan.nextInt();
      b[i % d]+=a[i];
    }
    int in=-1 ;
    long min=(long)Math.pow(10,9);
    for(int j=0 ; j<d ; j++){
      if(b[j]<min){
        min=b[j];
        in=j ;
      }
    }
    System.out.println(in+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class b366 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var d : int ; d := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,d)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() ; 
     b[i mod d+1] := b[i mod d+1]+(a[i+1]) )  ;     i := i + 1 ) ; 
    var in : int ; in := -1 ;
    var min : long ; min := 10->pow(9)->oclAsType(long) ;
        var j : int ; j := 0 ; while j < d do ( (     if (b[j+1] < min) then (     min := b[j+1] ; 
     in := j ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(in + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int fib(int n){
    double phi=(1+Math.sqrt(5))/2 ;
    return(int)Math.round(Math.pow(phi,n)/Math.sqrt(5));
  }
  static int calculateSum(int l,int r){
    int sum=fib(r+2)-fib(l+1);
    return sum ;
  }
  static int sumFibonacci(int k){
    int l=(k*(k-1))/2 ;
    int r=l+k ;
    int sum=calculateSum(l,r-1);
    return sum ;
  }
  public static void main(String args[]){
    int k=3 ;
    System.out.println(sumFibonacci(k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fib( n : int) : int
  pre: true
  post: true
  activity: (     var phi : double ; phi := (1 + (5)->sqrt()) / 2 ;
     return (phi->pow(n) / (5)->sqrt())->round()->oclAsType(int) );
  static   operation calculateSum( l : int, r : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := fib(r + 2) - fib(l + 1) ;
     return sum );
  static   operation sumFibonacci( k : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := (k * (k - 1)) / 2 ;
     var r : int ; r := l + k ;
     var sum : int ; sum := calculateSum(l, r - 1) ;
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 3 ;
     OclFile["System.out"].println(sumFibonacci(k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int R=4 ;
  static int C=3 ;
  static boolean isSafe(int x,int y){
    return(x<R && y<C);
  }
  static int[][] dp=new int[R][C];
  static int minJump(int height[][],int x,int y){
    if(dp[x][y]!=-1){
      return dp[x][y];
    }
    if(x==R-1 && y==C-1){
      return(dp[x][y]=0);
    }
    int diag=Integer.MAX_VALUE ;
    if(isSafe(x+1,y+1)){
      diag=minJump(height,x+1,y+1)+Math.abs(height[x][y]-height[x+1][y+1]);
    }
    int down=Integer.MAX_VALUE ;
    if(isSafe(x+1,y)){
      down=minJump(height,x+1,y)+Math.abs(height[x][y]-height[x+1][y]);
    }
    int right=Integer.MAX_VALUE ;
    if(isSafe(x,y+1)){
      right=minJump(height,x,y+1)+Math.abs(height[x][y]-height[x][y+1]);
    }
    dp[x][y]=Math.min(Math.min(down,right),diag);
    return dp[x][y];
  }
  public static void main(String[] args){
    int height[][]={
      {
        5,4,2 },{
          9,2,1 },{
            2,5,9 },{
              1,3,11 }
            };
            for(int i=0 ; i<R ; i++){
              for(int j=0 ; j<C ; j++){
                dp[i][j]=-1 ;
              }
            }
            System.out.println(minJump(height,0,0));
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute R : int := 4;
  static   attribute C : int := 3;
  static   operation isSafe( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return (x < R & y < C) );
  static   attribute dp : Sequence(Sequence(int)) := Integer.subrange(1,R)->collect(Integer.subrange(1,C)->collect(0));
  static   operation minJump( height : Sequence(Sequence(int)), x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (dp[x+1][y+1] /= -1) then (     return dp[x+1][y+1] ) else skip ; 
     if (x = R - 1 & y = C - 1) then (     return (dp[x+1][y+1]) ) else skip ; 
    var diag : int ; diag := 2147483647 ;
    if (isSafe(x + 1, y + 1)) then (     diag := minJump(height, x + 1, y + 1) + if height[x+1][y+1] - height[x + 1+1][y + 1+1] < 0 then -(height[x+1][y+1] - height[x + 1+1][y + 1+1]) else height[x+1][y+1] - height[x + 1+1][y + 1+1] endif ) else skip ; 
    var down : int ; down := 2147483647 ;
    if (isSafe(x + 1, y)) then (     down := minJump(height, x + 1, y) + if height[x+1][y+1] - height[x + 1+1][y+1] < 0 then -(height[x+1][y+1] - height[x + 1+1][y+1]) else height[x+1][y+1] - height[x + 1+1][y+1] endif ) else skip ; 
    var right : int ; right := 2147483647 ;
    if (isSafe(x, y + 1)) then (     right := minJump(height, x, y + 1) + if height[x+1][y+1] - height[x+1][y + 1+1] < 0 then -(height[x+1][y+1] - height[x+1][y + 1+1]) else height[x+1][y+1] - height[x+1][y + 1+1] endif ) else skip ; 
    dp[x+1][y+1] := Set{Set{down, right}->min(), diag}->min() ; 
    return dp[x+1][y+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var height : Sequence(Sequence(int)) ; height := Sequence{Sequence{5,4,2},Sequence{9,2,1},Sequence{2,5,9},Sequence{1,3,11}} ;
         var i : int ; i := 0 ; while i < R do ( (         var j : int ; j := 0 ; while j < C do ( (     dp[i+1][j+1] := -1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(minJump(height, 0, 0)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DimaAndToDoList {
  public static void main(String args[]){
    int n,k,i,j ;
    Scanner scan=new Scanner(System.in);
    n=scan.nextInt();
    k=scan.nextInt();
    int[] a=new int[n+1];
    for(i=1 ; i<=n ; i++)a[i]=scan.nextInt();
    int sum,mm=Integer.MAX_VALUE,p=-1 ;
    for(i=1 ; i<=k ; i++){
      sum=0 ;
      for(j=i ; j<=n ; j+=k){
        sum+=a[j];
      }
      if(sum<mm){
        mm=sum ;
        p=i ;
      }
    }
    System.out.println(p);
  }
}
------------------------------------------------------------
OCL File:
---------
 class DimaAndToDoList {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var k : int ;
    var i : int ;
    var j : int ;
     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := scan.getCurrent()->toInteger() ; 
    k := scan.getCurrent()->toInteger() ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        i := 1 ; while i <= n do (     a[i+1] := scan.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var sum : int ;
    var mm : int ; mm := 2147483647 ;
    var p : int ; p := -1 ;
        i := 1 ; while i <= k do ( (     sum := 0 ; 
         j := i ; while j <= n do ( (     sum := sum+(a[j+1]) )  ;     j := j+(k) ) ; 
     if (sum < mm) then (     mm := sum ; 
     p := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(p) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class temp {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    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 moves=k ;
    int min=Integer.MAX_VALUE ;
    int start=-1 ;
    for(int i=0 ; i<moves ; i++){
      int tmp=0 ;
      for(int j=i ; j<(i+n); j+=k){
        tmp+=arr[j];
      }
      if(tmp<min){
        min=tmp ;
        start=i ;
      }
    }
    System.out.println(start+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class temp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var moves : int ; moves := k ;
    var min : int ; min := 2147483647 ;
    var start : int ; start := -1 ;
        var i : int ; i := 0 ; while i < moves do ( (     var tmp : int ; tmp := 0 ;
         var j : int ; j := i ; while j < (i + n) do ( (     tmp := tmp+(arr[j+1]) )  ;     j := j+(k) ) ; 
     if (tmp < min) then (     min := tmp ; 
     start := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(start + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int KnapSack(int val[],int wt[],int n,int W){
    int mat[][]=new int[2][W+1];
    int i=0 ;
    while(i<n){
      int j=0 ;
      if(i % 2!=0){
        while(++j<=W){
          if(wt[i]<=j){
            mat[1][j]=Math.max(val[i]+mat[0][j-wt[i] ],mat[0][j]);
          }
          else {
            mat[1][j]=mat[0][j];
          }
        }
      }
      else {
        while(++j<=W){
          if(wt[i]<=j){
            mat[0][j]=Math.max(val[i]+mat[1][j-wt[i] ],mat[1][j]);
          }
          else {
            mat[0][j]=mat[1][j];
          }
        }
      }
      i++;
    }
    return(n % 2!=0)? mat[0][W] : mat[1][W];
  }
  public static void main(String[] args){
    int val[]={
      7,8,4 },wt[]={
        3,8,6 },W=10,n=3 ;
        System.out.println(KnapSack(val,wt,n,W));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation KnapSack( val : Sequence(int), wt : Sequence(int), n : int, W : int) : int
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Integer.subrange(1,2)->collect(Integer.subrange(1,W + 1)->collect(0)) ;
     var i : int ; i := 0 ;
     while (i < n) do (     var j : int ; j := 0 ;
     if (i mod 2 /= 0) then (         j := j + 1 ;
    while ((j + 1) <= W) do (        j := j + 1 ;     skip ; (     if (wt[i+1] <= j) then (     mat[1+1][j+1] := Set{val[i+1] + mat[0+1][j - wt[i+1]+1], mat[0+1][j+1]}->max() ) else (     mat[1+1][j+1] := mat[0+1][j+1] ) ) ;     j := j + 1 ;
 ) ) else (         j := j + 1 ;
    while ((j + 1) <= W) do (        j := j + 1 ;     skip ; (     if (wt[i+1] <= j) then (     mat[0+1][j+1] := Set{val[i+1] + mat[1+1][j - wt[i+1]+1], mat[1+1][j+1]}->max() ) else (     mat[0+1][j+1] := mat[1+1][j+1] ) ) ;     j := j + 1 ;
 ) ) ;  
     i := i + 1 ) ; 
     return if (n mod 2 /= 0) then mat[0+1][W+1] else mat[1+1][W+1] endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var val : Sequence(void) ; val := Sequence{7,8,4} ;
    var wt : Sequence(void) ; wt := Sequence{3,8,6} ;
    var W : int ; W := 10 ;
    var n : int ; n := 3 ;
     OclFile["System.out"].println(KnapSack(val, wt, n, W)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextInt()){
      int h1=sc.nextInt();
      int h2=sc.nextInt();
      int k1=sc.nextInt();
      int k2=sc.nextInt();
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int d=sc.nextInt();
      int hiroshi=h1*a+(h1/10)*c+h2*b+(h2/20)*d ;
      int kenjiro=k1*a+(k1/10)*c+k2*b+(k2/20)*d ;
      if(hiroshi>kenjiro){
        System.out.println("hiroshi");
      }
      else if(hiroshi<kenjiro){
        System.out.println("kenjiro");
      }
      else {
        System.out.println("even");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextInt()) do (     var h1 : int ; h1 := sc.getCurrent()->toInteger() ;
     var h2 : int ; h2 := sc.getCurrent()->toInteger() ;
    var k1 : int ; k1 := sc.getCurrent()->toInteger() ;
    var k2 : int ; k2 := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var hiroshi : int ; hiroshi := h1 * a + (h1 / 10) * c + h2 * b + (h2 / 20) * d ;
    var kenjiro : int ; kenjiro := k1 * a + (k1 / 10) * c + k2 * b + (k2 / 20) * d ;
    if (hiroshi > kenjiro) then (     OclFile["System.out"].println("hiroshi") ) else     if (hiroshi < kenjiro) then (     OclFile["System.out"].println("kenjiro") ) else (     OclFile["System.out"].println("even") ) ;  ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args){
    BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    String str="" ;
    StringTokenizer stk ;
    int hirosi_i,hirosi_y ;
    int kenjir_i,kenjir_y ;
    int iwana_P,yamame_P,iwana10_B,yamame20_B ;
    int sc_h,sc_k ;
    try {
      str=bfr.readLine();
      if(str==""){
        System.exit(0);
      }
      stk=new StringTokenizer(str," ");
      hirosi_i=Integer.parseInt(stk.nextToken());
      hirosi_y=Integer.parseInt(stk.nextToken());
      str=bfr.readLine();
      if(str==""){
        System.exit(0);
      }
      stk=new StringTokenizer(str," ");
      kenjir_i=Integer.parseInt(stk.nextToken());
      kenjir_y=Integer.parseInt(stk.nextToken());
      str=bfr.readLine();
      if(str==""){
        System.exit(0);
      }
      stk=new StringTokenizer(str," ");
      iwana_P=Integer.parseInt(stk.nextToken());
      yamame_P=Integer.parseInt(stk.nextToken());
      iwana10_B=Integer.parseInt(stk.nextToken());
      yamame20_B=Integer.parseInt(stk.nextToken());
      sc_h=iwana_P*hirosi_i+(hirosi_i/10)*iwana10_B+yamame_P*hirosi_y+(hirosi_y/20)*yamame20_B ;
      sc_k=iwana_P*kenjir_i+(kenjir_i/10)*iwana10_B+yamame_P*kenjir_y+(kenjir_y/20)*yamame20_B ;
      if(sc_k>sc_h){
        System.out.println("kenjiro");
      }
      else if(sc_k<sc_h){
        System.out.println("hiroshi");
      }
      else if(sc_k==sc_h){
        System.out.println("even");
      }
    }
    catch(IOException e){
      System.exit(0);
    }
    catch(NumberFormatException e){
      System.exit(0);
    }
    catch(NullPointerException e){
      System.exit(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bfr : OclFile ; bfr := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := "" ;
    var stk : OclIterator ;
    var hirosi_i : int ;
    var hirosi_y : int ;
    var kenjir_i : int ;
    var kenjir_y : int ;
    var iwana_P : int ;
    var yamame_P : int ;
    var iwana10_B : int ;
    var yamame20_B : int ;
    var sc_h : int ;
    var sc_k : int ;
    try (     str := bfr.readLine() ; 
     if (str = "") then ( OclProcess.exit(0) ) else skip ; 
    stk := OclIterator.newOclIterator_String_String(str, " ") ; 
    hirosi_i := (stk.next())->toInteger() ; 
    hirosi_y := (stk.next())->toInteger() ; 
    str := bfr.readLine() ; 
    if (str = "") then ( OclProcess.exit(0) ) else skip ; 
    stk := OclIterator.newOclIterator_String_String(str, " ") ; 
    kenjir_i := (stk.next())->toInteger() ; 
    kenjir_y := (stk.next())->toInteger() ; 
    str := bfr.readLine() ; 
    if (str = "") then ( OclProcess.exit(0) ) else skip ; 
    stk := OclIterator.newOclIterator_String_String(str, " ") ; 
    iwana_P := (stk.next())->toInteger() ; 
    yamame_P := (stk.next())->toInteger() ; 
    iwana10_B := (stk.next())->toInteger() ; 
    yamame20_B := (stk.next())->toInteger() ; 
    sc_h := iwana_P * hirosi_i + (hirosi_i / 10) * iwana10_B + yamame_P * hirosi_y + (hirosi_y / 20) * yamame20_B ; 
    sc_k := iwana_P * kenjir_i + (kenjir_i / 10) * iwana10_B + yamame_P * kenjir_y + (kenjir_y / 20) * yamame20_B ; 
    if (sc_k > sc_h) then (     OclFile["System.out"].println("kenjiro") ) else     if (sc_k < sc_h) then (     OclFile["System.out"].println("hiroshi") ) else     if (sc_k = sc_h) then (     OclFile["System.out"].println("even") ) else skip ; ;  ;  
 )   catch (e : IOException) do ( OclProcess.exit(0) )
   catch (e : IncorrectElementException) do ( OclProcess.exit(0) )
  catch (e : NullAccessException) do ( OclProcess.exit(0) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int h1=sc.nextInt();
    int h2=sc.nextInt();
    int k1=sc.nextInt();
    int k2=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    int hiroshi=h1*a+h2*b+(h1/10)*c+(h2/20)*d ;
    int kenjiro=k1*a+k2*b+(k1/10)*c+(k2/20)*d ;
    if(hiroshi>kenjiro)System.out.println("hiroshi");
    else if(hiroshi<kenjiro)System.out.println("kenjiro");
    else System.out.println("even");
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h1 : int ; h1 := sc.getCurrent()->toInteger() ;
    var h2 : int ; h2 := sc.getCurrent()->toInteger() ;
    var k1 : int ; k1 := sc.getCurrent()->toInteger() ;
    var k2 : int ; k2 := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var hiroshi : int ; hiroshi := h1 * a + h2 * b + (h1 / 10) * c + (h2 / 20) * d ;
    var kenjiro : int ; kenjiro := k1 * a + k2 * b + (k1 / 10) * c + (k2 / 20) * d ;
    if (hiroshi > kenjiro) then     OclFile["System.out"].println("hiroshi") else     if (hiroshi < kenjiro) then     OclFile["System.out"].println("kenjiro") else     OclFile["System.out"].println("even") ; ;  ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int F[][]=new int[2][2];
    for(int i=0 ; i<2 ; i++){
      for(int j=0 ; j<2 ; j++)F[i][j]=in.nextInt();
    }
    int a=in.nextInt(),b=in.nextInt(),c=in.nextInt(),d=in.nextInt();
    int hiro=(a*F[0][0])+(b*F[0][1])+(F[0][0]/10*c)+(F[0][1]/20*d);
    int ken=(a*F[1][0])+(b*F[1][1])+(F[1][0]/10*c)+(F[1][1]/20*d);
    String res ;
    if(hiro>ken)res="hiroshi" ;
    else if(ken>hiro)res="kenjiro" ;
    else res="even" ;
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var F : Sequence(Sequence(int)) ; F := Integer.subrange(1,2)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < 2 do ( (         var j : int ; j := 0 ; while j < 2 do (     F[i+1][j+1] := in.getCurrent()->toInteger() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var hiro : int ; hiro := (a * F[0+1][0+1]) + (b * F[0+1][1+1]) + (F[0+1][0+1] / 10 * c) + (F[0+1][1+1] / 20 * d) ;
    var ken : int ; ken := (a * F[1+1][0+1]) + (b * F[1+1][1+1]) + (F[1+1][0+1] / 10 * c) + (F[1+1][1+1] / 20 * d) ;
    var res : String ;
    if (hiro > ken) then     res := "hiroshi" else     if (ken > hiro) then     res := "kenjiro" else     res := "even" ; ;  ;  
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int h1,h2,k1,k2,a,b,c,d ;
    line=br.readLine();
    h1=parseInt(line.substring(0,line.indexOf(' ')));
    h2=parseInt(line.substring(line.indexOf(' ')+1));
    line=br.readLine();
    k1=parseInt(line.substring(0,line.indexOf(' ')));
    k2=parseInt(line.substring(line.indexOf(' ')+1));
    StringTokenizer st=new StringTokenizer(br.readLine());
    a=parseInt(st.nextToken());
    b=parseInt(st.nextToken());
    c=parseInt(st.nextToken());
    d=parseInt(st.nextToken());
    int h,k ;
    h=h1*a+h2*b+(h1/10)*c+(h2/20)*d ;
    k=k1*a+k2*b+(k1/10)*c+(k2/20)*d ;
    System.out.println(h==k ? "even" :(h>k ? "hiroshi" : "kenjiro"));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var h1 : int ;
    var h2 : int ;
    var k1 : int ;
    var k2 : int ;
    var a : int ;
    var b : int ;
    var c : int ;
    var d : int ;
    line := br.readLine() ; 
    h1 := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    h2 := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    line := br.readLine() ; 
    k1 := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    k2 := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    a := (st.next() + "")->toInteger() ; 
    b := (st.next() + "")->toInteger() ; 
    c := (st.next() + "")->toInteger() ; 
    d := (st.next() + "")->toInteger() ; 
    var h : int ;
    var k : int ;
    h := h1 * a + h2 * b + (h1 / 10) * c + (h2 / 20) * d ; 
    k := k1 * a + k2 * b + (k1 / 10) * c + (k2 / 20) * d ; 
    OclFile["System.out"].println(if h = k then "even" else (if h > k then "hiroshi" else "kenjiro" endif) endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long max=n-1L ;
    long result=0 ;
    for(long i=1L ; i<n ; i++){
      long tempMax=max/i ;
      result=result+tempMax ;
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var max : long ; max := n - 1L ;
    var result : long ; result := 0 ;
        var i : long ; i := 1L ; while i < n do ( (     var tempMax : long ; tempMax := max / i ;
     result := result + tempMax )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int fib(int n){
    double phi=(1+Math.sqrt(5))/2 ;
    return(int)Math.round(Math.pow(phi,n)/Math.sqrt(5));
  }
  static int calculateSum(int l,int r){
    int sum=fib(r+2)-fib(l+1);
    return sum ;
  }
  public static void main(String[] args){
    int l=4,r=8 ;
    System.out.println(calculateSum(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation fib( n : int) : int
  pre: true
  post: true
  activity: (     var phi : double ; phi := (1 + (5)->sqrt()) / 2 ;
     return (phi->pow(n) / (5)->sqrt())->round()->oclAsType(int) );
  static   operation calculateSum( l : int, r : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := fib(r + 2) - fib(l + 1) ;
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 4 ;
    var r : int ; r := 8 ;
     OclFile["System.out"].println(calculateSum(l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    int n=sc.nextInt();
    long res=0 ;
    for(int i=1 ; i<n ; i++){
      res+=(n/i);
      if(n % i==0)res--;
    }
    out.println(res);
    out.close();
  }
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := sc.nextInt() ;
    var res : long ; res := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     res := res+((n / i)) ; 
     if (n mod i = 0) then     res := res - 1 ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int zz=1 ; zz<=T ; zz++){
      int N=in.nextInt();
      int K=in.nextInt();
      long[] sum=new long[N-K+1];
      for(int i=0 ; i<sum.length ; i++)sum[i]=in.nextInt();
      long[] diff=new long[N];
      long[] A=new long[K];
      long[] B=new long[K];
      for(int i=0 ; i+1<sum.length ; i++){
        long d=sum[i+1]-sum[i];
        diff[i+K]=diff[i]+d ;
        A[i % K]=min(A[i % K],diff[i+K]);
        B[i % K]=max(B[i % K],diff[i+K]);
      }
      long total=0 ;
      for(int i=0 ; i<K ; i++){
        total-=A[i];
        B[i]-=A[i];
        A[i]=0 ;
      }
      Arrays.sort(B);
      long d=sum[0]-total ;
      d=((d % K)+K)% K ;
      if(d<0 || d>=K)throw new RuntimeException();
      for(long ans=B[K-1]; ; ans++){
        long less=0 ;
        for(long b : B)less+=ans-b ;
        if(less>=d){
          System.out.format("Case #%d: %d\n",zz,ans);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var zz : int ; zz := 1 ; while zz <= T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var K : int ; K := in.getCurrent()->toInteger() ;
    var sum : Sequence(long) ; sum := Integer.subrange(1,N - K + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < sum->size() do (     sum[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var diff : Sequence(long) ; diff := Integer.subrange(1,N)->collect(0) ;
    var A : Sequence(long) ; A := Integer.subrange(1,K)->collect(0) ;
    var B : Sequence(long) ; B := Integer.subrange(1,K)->collect(0) ;
        var i : int ; i := 0 ; while i + 1 < sum->size() do ( (     var d : long ; d := sum[i + 1+1] - sum[i+1] ;
     diff[i + K+1] := diff[i+1] + d ; 
     A[i mod K+1] := Set{A[i mod K+1], diff[i + K+1]}->min() ; 
     B[i mod K+1] := Set{B[i mod K+1], diff[i + K+1]}->max() )  ;     i := i + 1 ) ; 
    var total : long ; total := 0 ;
        var i : int ; i := 0 ; while i < K do ( (     total := total-(A[i+1]) ; 
     B[i+1] := B[i+1]-(A[i+1]) ; 
     A[i+1] := 0 )  ;     i := i + 1 ) ; 
    B := B->sort() ; 
    var d : long ; d := sum[0+1] - total ;
    d := ((d mod K) + K) mod K ; 
    if (d < 0 or d >= K) then     error ProgramException() ; else skip ; 
        var ans : long ; ans := B[K - 1+1] ; while true do ( (     var less : long ; less := 0 ;
     for (b : B) do (     less := less+(ans - b) ;  ) ; 
     if (less >= d) then (     OclFile["System.out"].format("Case #%d: %d\n", zz, ans) ; 
     break ) else skip )  ;     ans := ans + 1 ) ; 
 )  ;     zz := zz + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  void solve(Scanner in,PrintWriter out){
    int n=in.nextInt();
    int cpt=0 ;
    for(int c=1 ; c<n ; ++c){
      cpt+=nbFactors(n-c);
    }
    out.println(cpt);
  }
  public static int nbFactors(int n){
    int cpt=0 ;
    for(int i=1 ; i<=(int)Math.sqrt(n); i++){
      if(n % i==0 && i*i!=n){
        cpt+=2 ;
      }
      else if(i*i==n){
        cpt++;
      }
    }
    return cpt ;
  }
  public static void main(String[] args){
    try(Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out)){
      new Main().solve(in,out);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve( in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var cpt : int ; cpt := 0 ;
         var c : int ; c := 1 ; while c < n do ( (     cpt := cpt+(nbFactors(n - c)) )  ;     c := c + 1 ) ; 
     out.println(cpt) );
  static   operation nbFactors( n : int) : int
  pre: true
  post: true
  activity: (     var cpt : int ; cpt := 0 ;
         var i : int ; i := 1 ; while i <= (n)->sqrt()->oclAsType(int) do ( (     if (n mod i = 0 & i * i /= n) then (     cpt := cpt+(2) ) else     if (i * i = n) then (     cpt := cpt + 1 ) else skip ; )  ;     i := i + 1 ) ; 
     return cpt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]) ;
 (     Main.newMain().solve(in, out) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc ;
  int[] memo ;
  public static void main(String[] args){
    new Main().execute();
  }
  public void execute(){
    this.sc=new Scanner(System.in);
    int n=sc.nextInt();
    int cnt=0 ;
    this.memo=new int[n+1];
    for(int i=1 ; i<n ; i++){
      cnt+=countPair(n-i);
    }
    System.out.println(cnt);
  }
  public int countPair(int n){
    if(this.memo[n]!=0){
      return this.memo[n];
    }
    int cnt=0 ;
    int max=(int)(Math.sqrt(n));
    for(int i=1 ; i<=max ; i++){
      if(n % i==0){
        cnt+=(i==n/i ? 1 : 2);
      }
    }
    this.memo[n]=cnt ;
    return cnt ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute memo : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().execute() );
   operation execute() : void
  pre: true
  post: true
  activity: (     self.sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var cnt : int ; cnt := 0 ;
    self.memo := Integer.subrange(1,n + 1)->collect(0) ; 
        var i : int ; i := 1 ; while i < n do ( (     cnt := cnt+(countPair(n - i)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
   operation countPair( n : int) : int
  pre: true
  post: true
  activity: (     if (self.memo[n+1] /= 0) then (     return self.memo[n+1] ) else skip ; 
     var cnt : int ; cnt := 0 ;
    var max : int ; max := ((n)->sqrt())->oclAsType(int) ;
        var i : int ; i := 1 ; while i <= max do ( (     if (n mod i = 0) then (     cnt := cnt+((if i = n / i then 1 else 2 endif)) ) else skip )  ;     i := i + 1 ) ; 
    self.memo[n+1] := cnt ; 
    return cnt 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    double n=sc.nextInt();
    long sum=0 ;
    for(int i=1 ; i<n ; i++){
      int one=0 ;
      if(n % i==0)one=1 ;
      int tmp=(int)n/i-one ;
      sum+=tmp ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : double ; n := sc.getCurrent()->toInteger() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     var one : int ; one := 0 ;
     if (n mod i = 0) then     one := 1 ; else skip ; 
     var tmp : int ; tmp := n->oclAsType(int) / i - one ;
     sum := sum+(tmp) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int min1=Integer.MAX_VALUE ;
  static int count=0 ;
  public int permutation(String str1,int i,int n,int p){
    if(i==n){
      int q=Integer.parseInt(str1);
      if(q-p>0 && q<min1){
        min1=q ;
        count=1 ;
      }
    }
    else {
      for(int j=i ; j<=n ; j++){
        str1=swap(str1,i,j);
        permutation(str1,i+1,n,p);
        str1=swap(str1,i,j);
      }
    }
    return min1 ;
  }
  public String swap(String str,int i,int j){
    char ch[]=str.toCharArray();
    char temp=ch[i];
    ch[i]=ch[j];
    ch[j]=temp ;
    return String.valueOf(ch);
  }
  public static void main(String[] args){
    int A=213 ;
    int B=111 ;
    GFG gfg=new GFG();
    String str1=Integer.toString(A);
    int len=str1.length();
    int h=gfg.permutation(str1,0,len-1,B);
    if(count==1)System.out.println(h);
    else System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute min1 : int := 2147483647;
  static   attribute count : int := 0;
   operation permutation( str1 : String, i : int, n : int, p : int) : int
  pre: true
  post: true
  activity: (     if (i = n) then (     var q : int ; q := (str1)->toInteger() ;
     if (q - p > 0 & q < min1) then (     min1 := q ; 
     count := 1 ) else skip ) else (         var j : int ; j := i ; while j <= n do ( (     str1 := swap(str1, i, j) ; 
     execute permutation(str1, i + 1, n, p) ; 
     str1 := swap(str1, i, j) )  ;     j := j + 1 ) ) ;  
     return min1 );
   operation swap( str : String, i : int, j : int) : String
  pre: true
  post: true
  activity: (     var ch : Sequence(String) ; ch := str->characters() ;
     var temp : String ; temp := ch[i+1] ;
    ch[i+1] := ch[j+1] ; 
    ch[j+1] := temp ; 
    return ((ch) + "") 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 213 ;
     var B : int ; B := 111 ;
    var gfg : GFG ; gfg := GFG.newGFG() ;
    var str1 : String ; str1 := ((A) + "") ;
    var len : int ; len := str1->size() ;
    var h : int ; h := gfg.permutation(str1, 0, (len)->char2byte() - 1, B) ;
    if (count = 1) then     OclFile["System.out"].println(h) else     OclFile["System.out"].println(-1) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class LC {
  static class pair {
    int l,r ;
    public pair(int l,int r){
      this.l=l ;
      this.r=r ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int p=sc.nextInt(),q=sc.nextInt(),s=sc.nextInt(),e=sc.nextInt();
    ArrayList<pair>l1=new ArrayList<>();
    ArrayList<pair>l2=new ArrayList<>();
    for(int i=0 ; i<p ; i++){
      l1.add(new pair(sc.nextInt(),sc.nextInt()));
    }
    for(int i=0 ; i<q ; i++){
      l2.add(new pair(sc.nextInt(),sc.nextInt()));
    }
    int ans=0 ;
    for(int i=s ; i<=e ; i++){
      boolean flag=false ;
      for(int j=0 ; j<l1.size(); j++){
        for(int k=0 ; k<l2.size(); k++){
          if(l1.get(j).l>=l2.get(k).l+i && l1.get(j).l<=l2.get(k).r+i)flag=true ;
          if(l1.get(j).l<=l2.get(k).l+i && l1.get(j).r>=l2.get(k).l+i)flag=true ;
        }
      }
      if(flag)ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class LC {
  static class pair {
   attribute l : int;
   static operation newpair( l : int, r : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(l, r);
    return self );
  operation initialise( l : int, r : int) : void
  pre: true  post: true
  activity: (     self.l := l ; 
     self.r := r );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : int ; p := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var e : int ; e := sc.getCurrent()->toInteger() ;
    var l1 : Sequence(pair) ; l1 := Sequence{} ;
    var l2 : Sequence(pair) ; l2 := Sequence{} ;
        var i : int ; i := 0 ; while i < p do ( (     l1 := l1->including(pair.newpair(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     l2 := l2->including(pair.newpair(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := s ; while i <= e do ( (     var flag : boolean ; flag := false ;
         var j : int ; j := 0 ; while j < l1->size() do ( (         var k : int ; k := 0 ; while k < l2->size() do ( (     if (l1->at(j+1).l >= l2->at(k+1).l + i & l1->at(j+1).l <= l2->at(k+1).r + i) then     flag := true ; else skip ; 
     if (l1->at(j+1).l <= l2->at(k+1).l + i & l1->at(j+1).r >= l2->at(k+1).l + i) then     flag := true ; else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
     if (flag) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int longestSubsequenceCommonSegment(int k,String s1,String s2){
    int n=s1.length();
    int m=s2.length();
    int lcs[][]=new int[n+1][m+1];
    int cnt[][]=new int[n+1][m+1];
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=m ; j++){
        lcs[i][j]=Math.max(lcs[i-1][j],lcs[i][j-1]);
        if(s1.charAt(i-1)==s2.charAt(j-1))cnt[i][j]=cnt[i-1][j-1]+1 ;
        if(cnt[i][j]>=k){
          for(int a=k ; a<=cnt[i][j]; a++)lcs[i][j]=Math.max(lcs[i][j],lcs[i-a][j-a]+a);
        }
      }
    }
    return lcs[n][m];
  }
  public static void main(String[] args){
    int k=4 ;
    String s1="aggasdfa" ;
    String s2="aggajasdfa" ;
    System.out.println(longestSubsequenceCommonSegment(k,s1,s2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation longestSubsequenceCommonSegment( k : int, s1 : String, s2 : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s1->size() ;
     var m : int ; m := s2->size() ;
    var lcs : Sequence(Sequence(int)) ; lcs := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
    var cnt : Sequence(Sequence(int)) ; cnt := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= m do ( (     lcs[i+1][j+1] := Set{lcs[i - 1+1][j+1], lcs[i+1][j - 1+1]}->max() ; 
     if (s1->at(i - 1+1) = s2->at(j - 1+1)) then     cnt[i+1][j+1] := cnt[i - 1+1][j - 1+1] + 1 ; else skip ; 
     if (cnt[i+1][j+1] >= k) then (         var a : int ; a := k ; while a <= cnt[i+1][j+1] do (     lcs[i+1][j+1] := Set{lcs[i+1][j+1], lcs[i - a+1][j - a+1] + a}->max() ;  ;     a := a + 1 ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return lcs[n+1][m+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 4 ;
     var s1 : String ; s1 := "aggasdfa" ;
     var s2 : String ; s2 := "aggajasdfa" ;
     OclFile["System.out"].println(longestSubsequenceCommonSegment(k, s1, s2)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Arrays ;
class GFG {
  static int numberOfBST(int n){
    int dp[]=new int[n+1];
    Arrays.fill(dp,0);
    dp[0]=1 ;
    dp[1]=1 ;
    for(int i=2 ; i<=n ; i++){
      for(int j=1 ; j<=i ; j++){
        dp[i]=dp[i]+(dp[i-j]*dp[j-1]);
      }
    }
    return dp[n];
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println("Number of structurally "+"Unique BST with "+n+" keys are : "+numberOfBST(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation numberOfBST( n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
     dp := dp->collect(0) ; 
    dp[0+1] := 1 ; 
    dp[1+1] := 1 ; 
        var i : int ; i := 2 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= i do ( (     dp[i+1] := dp[i+1] + (dp[i - j+1] * dp[j - 1+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return dp[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println("Number of structurally " + "Unique BST with " + n + " keys are : " + numberOfBST(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Faltu1 {
  public static List<Long>primeFactors(long n){
    long cnt=0 ;
    List<Long>list=new ArrayList<>();
    while(n % 2==0){
      list.add(2l);
      n/=2 ;
    }
    for(long i=3 ; i<=Math.sqrt(n); i+=2){
      while(n % i==0){
        list.add(i);
        n/=i ;
      }
    }
    if(n>2)list.add(n);
    return list ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    List<Long>list=primeFactors(n);
    if(list.size()==2){
      System.out.println(2);
      return ;
    }
    if(list.size()==1 || n==1l){
      System.out.println(1);
      System.out.println(0);
      return ;
    }
    System.out.println(1);
    System.out.println(list.get(0)*list.get(1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Faltu1 {
  static   operation primeFactors( n : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var cnt : long ; cnt := 0 ;
     var list : Sequence(long) ; list := Sequence{} ;
    while (n mod 2 = 0) do (     list := list->including(2l) ; 
     n := n/(2) ) ; 
        var i : long ; i := 3 ; while i <= (n)->sqrt() do ( (     while (n mod i = 0) do (     list := list->including(i) ; 
     n := n/(i) ) )  ;     i := i+(2) ) ; 
    if (n > 2) then     list := list->including(n) ; else skip ; 
    return list 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var list : Sequence(long) ; list := primeFactors(n) ;
    if (list->size() = 2) then (     OclFile["System.out"].println(2) ; 
     return ) else skip ; 
    if (list->size() = 1 or n = 1l) then (     OclFile["System.out"].println(1) ; 
     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    OclFile["System.out"].println(1) ; 
    OclFile["System.out"].println(list->at(0+1) * list->at(1+1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public Main(){
    int t=sc.nextInt();
    sc.nextLine();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      sc.nextLine();
      String s1=sc.nextLine();
      String s2=sc.nextLine();
      boolean isSame=true ;
      for(int j=0 ; j<s1.length(); j++){
        if((s1.charAt(j)=='R' || s2.charAt(j)=='R')&& s1.charAt(j)!=s2.charAt(j)){
          isSame=false ;
          break ;
        }
      }
      if(isSame)System.out.println("YES");
      else System.out.println("NO");
    }
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
     skip ; 
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     skip ; 
    var s1 : String ; s1 := sc.nextLine() ;
    var s2 : String ; s2 := sc.nextLine() ;
    var isSame : boolean ; isSame := true ;
        var j : int ; j := 0 ; while j < s1->size() do ( (     if ((s1->at(j+1) = 'R' or s2->at(j+1) = 'R') & s1->at(j+1) /= s2->at(j+1)) then (     isSame := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (isSame) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Solution {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s[]=br.readLine().split(" ");
    String s1[]=br.readLine().split(" ");
    int b=Integer.parseInt(s[0]);
    int numOdd=0 ;
    int numeven=0 ;
    for(int i=0 ; i<s1.length ; i++){
      if(Integer.parseInt(s1[i])% 2!=0 && Integer.parseInt(s1[i])!=0){
        numOdd++;
      }
      else {
        numeven++;
      }
    }
    if(b % 2==0){
      if(Integer.parseInt(s1[s1.length-1])% 2==0){
        System.out.println("even");
      }
      else {
        System.out.println("odd");
      }
    }
    else {
      if(numOdd % 2!=0){
        System.out.println("odd");
      }
      else {
        System.out.println("even");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
    var s1 : Sequence(String) ; s1 := br.readLine()->split(" ") ;
    var b : int ; b := (s[0+1])->toInteger() ;
    var numOdd : int ; numOdd := 0 ;
    var numeven : int ; numeven := 0 ;
        var i : int ; i := 0 ; while i < s1->size() do ( (     if ((s1[i+1])->toInteger() mod 2 /= 0 & (s1[i+1])->toInteger() /= 0) then (     numOdd := numOdd + 1 ) else (     numeven := numeven + 1 ) )  ;     i := i + 1 ) ; 
    if (b mod 2 = 0) then (     if ((s1[s1->size() - 1+1])->toInteger() mod 2 = 0) then (     OclFile["System.out"].println("even") ) else (     OclFile["System.out"].println("odd") ) ) else (     if (numOdd mod 2 /= 0) then (     OclFile["System.out"].println("odd") ) else (     OclFile["System.out"].println("even") ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    boolean even=true ;
    int base=fs.nextInt(),k=fs.nextInt();
    for(int i=0 ; i+1<k ; i++){
      int nn=fs.nextInt();
      if(base % 2==1 && nn % 2==1)even ^=true ;
    }
    if(fs.nextInt()% 2==1)even ^=true ;
    System.out.println(even ? "even" : "odd");
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public long[] readLongArray(int n){
      long[] a=new long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var even : boolean ; even := true ;
    var base : int ; base := fs.nextInt() ;
    var k : int ; k := fs.nextInt() ;
        var i : int ; i := 0 ; while i + 1 < k do ( (     var nn : int ; nn := fs.nextInt() ;
     if (base mod 2 = 1 & nn mod 2 = 1) then     even := MathLib.bitwiseXor(even,true) ; else skip )  ;     i := i + 1 ) ; 
    if (fs.nextInt() mod 2 = 1) then     even := MathLib.bitwiseXor(even,true) ; else skip ; 
    OclFile["System.out"].println(if even then "even" else "odd" endif) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round3 ;
import java.util.Scanner ;
public class B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int cases=sc.nextInt();
    for(int caze=1 ; caze<=cases ; caze++){
      int N=sc.nextInt();
      int K=sc.nextInt();
      int[] sums=new int[N-K+1];
      for(int i=0 ; i<sums.length ; i++){
        sums[i]=sc.nextInt();
      }
      int[] min=new int[K],max=new int[K];
      for(int i=0 ; i<K ; i++){
        int val=0 ;
        for(int j=i ; j+1<sums.length ; j+=K){
          val+=sums[j+1]-sums[j];
          min[i]=Math.min(min[i],val);
          max[i]=Math.max(max[i],val);
        }
      }
      int sumModulo=0,maxInterval=0,canUse=0 ;
      for(int i=0 ; i<K ; i++){
        sumModulo-=min[i];
        maxInterval=Math.max(maxInterval,max[i]-min[i]);
      }
      for(int i=0 ; i<K ; i++){
        canUse+=maxInterval-(max[i]-min[i]);
      }
      boolean can=false ;
      for(int i=0 ; i<=canUse ; i++){
        if((sumModulo+i-sums[0])% K==0){
          can=true ;
          break ;
        }
      }
      if(! can)maxInterval++;
      System.out.println("Case #"+caze+": "+maxInterval);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cases : int ; cases := sc.getCurrent()->toInteger() ;
         var caze : int ; caze := 1 ; while caze <= cases do ( (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    var sums : Sequence(int) ; sums := Integer.subrange(1,N - K + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < sums->size() do ( (     sums[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var min : Sequence(int) ; min := Integer.subrange(1,K)->collect(0) ;
    var max : Sequence(int) ; max := Integer.subrange(1,K)->collect(0) ;
        var i : int ; i := 0 ; while i < K do ( (     var val : int ; val := 0 ;
         var j : int ; j := i ; while j + 1 < sums->size() do ( (     val := val+(sums[j + 1+1] - sums[j+1]) ; 
     min[i+1] := Set{min[i+1], val}->min() ; 
     max[i+1] := Set{max[i+1], val}->max() )  ;     j := j+(K) ) )  ;     i := i + 1 ) ; 
    var sumModulo : int ; sumModulo := 0 ;
    var maxInterval : int ; maxInterval := 0 ;
    var canUse : int ; canUse := 0 ;
        var i : int ; i := 0 ; while i < K do ( (     sumModulo := sumModulo-(min[i+1]) ; 
     maxInterval := Set{maxInterval, max[i+1] - min[i+1]}->max() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < K do ( (     canUse := canUse+(maxInterval - (max[i+1] - min[i+1])) )  ;     i := i + 1 ) ; 
    var can : boolean ; can := false ;
        var i : int ; i := 0 ; while i <= canUse do ( (     if ((sumModulo + i - sums[0+1]) mod K = 0) then (     can := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (not(can)) then     maxInterval := maxInterval + 1 ; else skip ; 
    OclFile["System.out"].println("Case #" + caze + ": " + maxInterval) ; 
 )  ;     caze := caze + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MainClass {
  public static void main(String[] agrs){
    Scanner sc=new Scanner(System.in);
    int b=sc.nextInt();
    int k=sc.nextInt();
    int[] lst=new int[k];
    for(int i=0 ; i<k ; i++){
      lst[i]=sc.nextInt();
    }
    int od=0 ;
    if(b % 2==0){
      if(lst[k-1] % 2!=0)System.out.println("odd");
      else System.out.println("even");
    }
    else {
      for(int i=0 ; i<k ; i++){
        if(lst[i] % 2==1)od++;
      }
      if(od % 2==1)System.out.println("odd");
      else System.out.println("even");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var lst : Sequence(int) ; lst := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     lst[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var od : int ; od := 0 ;
    if (b mod 2 = 0) then (     if (lst[k - 1+1] mod 2 /= 0) then     OclFile["System.out"].println("odd") ; else     OclFile["System.out"].println("even") ; ) else (         var i : int ; i := 0 ; while i < k do ( (     if (lst[i+1] mod 2 = 1) then     od := od + 1 ; else skip )  ;     i := i + 1 ) ; 
     if (od mod 2 = 1) then     OclFile["System.out"].println("odd") ; else     OclFile["System.out"].println("even") ; ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.Vector ;
class GFG {
  static void sortMultiples(int arr[],int n,int x){
    Vector<Integer>v=new Vector<Integer>();
    for(int i=0 ; i<n ; i++){
      if(arr[i] % x==0){
        v.add(arr[i]);
      }
    }
    Collections.sort(v);
    int j=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] % x==0){
        arr[i]=v.get(j++);
      }
    }
  }
  public static void main(String[] args){
    int arr[]={
      125,3,15,6,100,5 };
      int x=5 ;
      int n=arr.length ;
      sortMultiples(arr,n,x);
      for(int i=0 ; i<n ; i++){
        System.out.print(arr[i]+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sortMultiples( arr : Sequence(int), n : int, x : int) : void
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod x = 0) then (     v := v->including(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    v := v->sort() ; 
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod x = 0) then (     arr[i+1] := v->at(j+1) ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{125,3,15,6,100,5} ;
     var x : int ; x := 5 ;
    var n : int ; n := arr->size() ;
    execute sortMultiples(arr, n, x) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void sortMultiples(int arr[],int n,int x){
    Vector<Integer>v=new Vector<Integer>();
    for(int i=0 ; i<n ; i++){
      if(arr[i] % x==0){
        v.add(arr[i]);
      }
    }
    Collections.sort(v,Collections.reverseOrder());
    int j=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] % x==0){
        arr[i]=v.get(j++);
      }
    }
  }
  static void printArray(int arr[],int N){
    for(int i=0 ; i<N ; i++){
      System.out.print(arr[i]+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      125,3,15,6,100,5 };
      int x=5 ;
      int n=arr.length ;
      sortMultiples(arr,n,x);
      printArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sortMultiples( arr : Sequence(int), n : int, x : int) : void
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod x = 0) then (     v := v->including(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    v, reverseOrder() := v, reverseOrder()->sort() ; 
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod x = 0) then (     arr[i+1] := v->at(j+1) ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation printArray( arr : Sequence(int), N : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{125,3,15,6,100,5} ;
     var x : int ; x := 5 ;
    var n : int ; n := arr->size() ;
    execute sortMultiples(arr, n, x) ; 
    execute printArray(arr, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  public void run(){
    Scanner sc=new Scanner(System.in);
    boolean[] p=new boolean[300000];
    boolean[] ms=new boolean[300000];
    for(int i=0 ; i<ms.length ; i++){
      ms[i]=((i % 7==1)||(i % 7==6));
      p[i]=ms[i];
    }
    for(int i=2 ; i<ms.length ; i++){
      if(p[i]){
        for(int j=i+i ; j<ms.length ; j+=i){
          p[j]=false ;
        }
      }
    }
    for(; ; ){
      int n=sc.nextInt();
      if(n==1){
        break ;
      }
      System.out.print(n+":");
      for(int i=2 ; i<=n ; i++){
        if(! p[i])continue ;
        if(n % i==0){
          System.out.print(" "+i);
        }
      }
      System.out.println();
    }
  }
  public static void main(String[] Aregs){
    Main a=new Main();
    a.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : Sequence(boolean) ; p := Integer.subrange(1,300000)->collect(false) ;
    var ms : Sequence(boolean) ; ms := Integer.subrange(1,300000)->collect(false) ;
        var i : int ; i := 0 ; while i < ms->size() do ( (     ms[i+1] := ((i mod 7 = 1) or (i mod 7 = 6)) ; 
     p[i+1] := ms[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i < ms->size() do ( (     if (p[i+1]) then (         var j : int ; j := i + i ; while j < ms->size() do ( (     p[j+1] := false )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
      while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 1) then (     break ) else skip ; 
    OclFile["System.out"].print(n + ":") ; 
        var i : int ; i := 2 ; while i <= n do ( (     if (not(p[i+1])) then     continue else skip ; 
     if (n mod i = 0) then (     OclFile["System.out"].print(" " + i) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ) ; 
 );
  static   operation main( Aregs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Main ; a := Main.newMain() ;
     a.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,i ;
    for(; ; ){
      n=sc.nextInt();
      if(n==1)break ;
      out.print(n+":");
      for(i=6 ; i<=n ; i++){
        if(n % i==0 && ismsprime(i))out.print(" "+i);
      }
      out.println();
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
  private static boolean ismsprime(int p){
    int i ;
    if((p % 7!=1 && p % 7!=6)|| p==1)return false ;
    for(i=6 ; i*i<=p ; i+=5){
      if(p % i==0)return false ;
      i+=2 ;
      if(p % i==0)return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var i : int ;
       while true do ( (     n := sc.nextInt() ; 
     if (n = 1) then     break else skip ; 
    out.print(n + ":") ; 
        i := 6 ; while i <= n do ( (     if (n mod i = 0 & ismsprime(i)) then     out.print(" " + i) ; else skip )  ;     i := i + 1 ) ; 
    out.println() ; 
 )  ) ; 
     sc.close() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
  static   operation ismsprime( p : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ;
     if ((p mod 7 /= 1 & p mod 7 /= 6) or p = 1) then     return false else skip ; 
         i := 6 ; while i * i <= p do ( (     if (p mod i = 0) then     return false else skip ; 
     i := i+(2) ; 
     if (p mod i = 0) then     return false else skip )  ;     i := i+(5) ) ; 
     return true );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  Scanner sc=new Scanner(in);
  int[] eratosthenes(int n){
    boolean[] dp=new boolean[n+1];
    List<Integer>prime=new LinkedList<Integer>();
    for(int i=2 ; i<=n ; i++){
      if(i % 7==1 || i % 7==6){
        if(dp[i])continue ;
        prime.add(i);
        for(int j=i+i ; j<=n ; j+=i)dp[j]=true ;
      }
    }
    int[] ret=new int[prime.size()];
    int count=0 ;
    for(int num : prime)ret[count++]=num ;
    return ret ;
  }
  void run(){
    int n ;
    int[] prime=eratosthenes(400000);
    while(true){
      n=sc.nextInt();
      if(n==1)break ;
      out.printf("%d:",n);
      int index=0 ;
      while(prime[index]<=n){
        if(n % prime[index]==0 &&((n/prime[index])% 7==1 ||(n/prime[index])% 7==6)){
          out.printf(" %d",prime[index]);
        }
        index++;
      }
      out.println();
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   operation eratosthenes( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var dp : Sequence(boolean) ; dp := Integer.subrange(1,n + 1)->collect(false) ;
     var prime : Sequence(int) ; prime := Sequence{} ;
        var i : int ; i := 2 ; while i <= n do ( (     if (i mod 7 = 1 or i mod 7 = 6) then (     if (dp[i+1]) then     continue else skip ; 
     prime := prime->including(i) ; 
         var j : int ; j := i + i ; while j <= n do (     dp[j+1] := true ;  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    var ret : Sequence(int) ; ret := Integer.subrange(1,prime->size())->collect(0) ;
    var count : int ; count := 0 ;
    for (num : prime) do (      ret[count+1] := num  ; count := count + 1 ;  ) ; 
    return ret 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ;
     var prime : Sequence(int) ; prime := eratosthenes(400000) ;
     while (true) do (     n := sc.getCurrent()->toInteger() ; 
     if (n = 1) then     break else skip ; 
    out.printf("%d:", n) ; 
    var index : int ; index := 0 ;
    while (prime[index+1] <= n) do (     if (n mod prime[index+1] = 0 & ((n / prime[index+1]) mod 7 = 1 or (n / prime[index+1]) mod 7 = 6)) then (     out.printf(" %d", prime[index+1]) ) else skip ; 
     index := index + 1 ) ; 
    out.println() ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    MSPrimeGenerator msp=new MSPrimeGenerator();
    while(true){
      int n=Integer.parseInt(br.readLine());
      if(n==1){
        break ;
      }
      System.out.println(solve(n,msp));
    }
  }
  static String solve(int n,MSPrimeGenerator msp){
    StringBuffer sb=new StringBuffer();
    sb.append(n+":");
    for(int i=6 ; i<=n ; i++){
      if(n % i==0 && msp.isPrime(i)){
        sb.append(" "+i);
      }
    }
    return sb.toString();
  }
}
class MSPrimeGenerator {
  private final int N=300000 ;
  private boolean[] isPrime=new boolean[N+1];
  public MSPrimeGenerator(){
    Arrays.fill(isPrime,true);
    isPrime[0]=false ;
    isPrime[1]=false ;
    for(int i=6 ; i<=N ; i++){
      if(isPrime[i]==false){
        continue ;
      }
      if(!(i % 7==1 || i % 7==6)){
        isPrime[i]=false ;
        continue ;
      }
      for(int j=i*2 ; j<=N ; j+=i){
        isPrime[j]=false ;
      }
    }
  }
  public boolean isPrime(int index){
    return isPrime[index];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var msp : MSPrimeGenerator ; msp := MSPrimeGenerator.newMSPrimeGenerator() ;
     while (true) do (     var n : int ; n := (br.readLine())->toInteger() ;
     if (n = 1) then (     break ) else skip ; 
     OclFile["System.out"].println(solve(n, msp)) ) );
  static   operation solve( n : int, msp : MSPrimeGenerator) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     sb := sb + StringLib.newString(n + ":") ; 
         var i : int ; i := 6 ; while i <= n do ( (     if (n mod i = 0 & msp.isPrime(i)) then (     sb := sb + StringLib.newString(" " + i) ) else skip )  ;     i := i + 1 ) ; 
     return sb+"" );
}
class MSPrimeGenerator {
   attribute N : int := 300000;
   attribute isPrime : Sequence(boolean) := Integer.subrange(1,N + 1)->collect(false);
   static operation newMSPrimeGenerator() : MSPrimeGenerator
  pre: true
  post: true
  activity:
  ( var self : MSPrimeGenerator ;
    self := createMSPrimeGenerator();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     isPrime := isPrime->collect(true) ; 
     isPrime[0+1] := false ; 
     isPrime[1+1] := false ; 
         var i : int ; i := 6 ; while i <= N do ( (     if (isPrime[i+1] = false) then (     continue ) else skip ; 
     if (not((i mod 7 = 1 or i mod 7 = 6))) then (     isPrime[i+1] := false ; 
     continue ) else skip ; 
         var j : int ; j := i * 2 ; while j <= N do ( (     isPrime[j+1] := false )  ;     j := j+(i) ) )  ;     i := i + 1 ) );
   operation isPrime( index : int) : boolean
  pre: true
  post: true
  activity: (     return isPrime[index+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int q=input.nextInt();
    String s=input.next();
    char str[]=s.toCharArray();
    for(int i=0 ; i<q ; i++){
      int l=input.nextInt()-1 ;
      int r=input.nextInt()-1 ;
      char c1=input.next().charAt(0);
      char c2=input.next().charAt(0);
      int start=l ;
      int end=r ;
      while(start<=end){
        if(str[start]==c1){
          str[start]=c2 ;
        }
        start++;
      }
    }
    for(char c : str){
      System.out.print(c);
    }
    System.out.println("");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var q : int ; q := input.getCurrent()->toInteger() ;
    var s : String ; s := input.getCurrent() ;
    var str : Sequence(String) ; str := s->characters() ;
        var i : int ; i := 0 ; while i < q do ( (     var l : int ; l := input.getCurrent()->toInteger() - 1 ;
     var r : int ; r := input.getCurrent()->toInteger() - 1 ;
    var c1 : String ; c1 := input.getCurrent()->at(0+1) ;
    var c2 : String ; c2 := input.getCurrent()->at(0+1) ;
    var start : int ; start := l ;
    var end : int ; end := r ;
    while (start <= end) do (     if (str[start+1] = c1) then (     str[start+1] := c2 ) else skip ; 
     start := start + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    for (c : str) do ( (     OclFile["System.out"].print(c) )  ) ; 
    OclFile["System.out"].println("") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int max=3000001 ;
  static boolean[] gdosu=new boolean[max];
  static boolean[] gdsosu=new boolean[max];
  public static void main(String[] args){
    for(int i=0 ; i<max ; i++){
      gdosu[i]=false ;
      if(i<=1)continue ;
      if(i % 7==1 || i % 7==6){
        gdosu[i]=true ;
      }
    }
    for(int i=0 ; i<max ; i++)gdsosu[i]=true ;
    for(int i=0 ; i<max ; i++){
      if(! gdosu[i]){
        gdsosu[i]=false ;
        continue ;
      }
      for(int s=i+i ; s<max ; s+=i){
        gdsosu[s]=false ;
      }
    }
    Scanner in=new Scanner(System.in);
    while(true){
      int input=in.nextInt();
      if(input==1)break ;
      System.out.print(input+":");
      for(int i=0 ; i<=input ; i++){
        if(! gdsosu[i])continue ;
        if(input % i==0){
          System.out.print(" "+i);
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute max : int := 3000001;
  static   attribute gdosu : Sequence(boolean) := Integer.subrange(1,max)->collect(false);
  static   attribute gdsosu : Sequence(boolean) := Integer.subrange(1,max)->collect(false);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < max do ( (     gdosu[i+1] := false ; 
     if (i <= 1) then     continue else skip ; 
     if (i mod 7 = 1 or i mod 7 = 6) then (     gdosu[i+1] := true ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < max do (     gdsosu[i+1] := true ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < max do ( (     if (not(gdosu[i+1])) then (     gdsosu[i+1] := false ; 
     continue ) else skip ; 
         var s : int ; s := i + i ; while s < max do ( (     gdsosu[s+1] := false )  ;     s := s+(i) ) )  ;     i := i + 1 ) ; 
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (true) do (     var input : int ; input := in.getCurrent()->toInteger() ;
     if (input = 1) then     break else skip ; 
    OclFile["System.out"].print(input + ":") ; 
        var i : int ; i := 0 ; while i <= input do ( (     if (not(gdsosu[i+1])) then     continue else skip ; 
     if (input mod i = 0) then (     OclFile["System.out"].print(" " + i) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
class GFG {
  static int divCount(int n){
    boolean hash[]=new boolean[n+1];
    Arrays.fill(hash,true);
    for(int p=2 ; p*p<n ; p++)if(hash[p]==true)for(int i=p*2 ; i<n ; i+=p)hash[i]=false ;
    int total=1 ;
    for(int p=2 ; p<=n ; p++){
      if(hash[p]){
        int count=0 ;
        if(n % p==0){
          while(n % p==0){
            n=n/p ;
            count++;
          }
          total=total*(count+1);
        }
      }
    }
    return total ;
  }
  public static void main(String[] args){
    int n=24 ;
    System.out.print(divCount(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation divCount( n : int) : int
  pre: true
  post: true
  activity: (     var hash : Sequence(boolean) ; hash := Integer.subrange(1,n + 1)->collect(false) ;
     hash := hash->collect(true) ; 
        var p : int ; p := 2 ; while p * p < n do (     if (hash[p+1] = true) then         var i : int ; i := p * 2 ; while i < n do (     hash[i+1] := false ;  ;     i := i+(p) ) ; else skip ;  ;     p := p + 1 ) ; 
    var total : int ; total := 1 ;
        var p : int ; p := 2 ; while p <= n do ( (     if (hash[p+1]) then (     var count : int ; count := 0 ;
     if (n mod p = 0) then (     while (n mod p = 0) do (     n := n / p ; 
     count := count + 1 ) ; 
     total := total * (count + 1) ) else skip ) else skip )  ;     p := p + 1 ) ; 
    return total 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 24 ;
     OclFile["System.out"].print(divCount(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      p=scanner.nextInt();
      if(p==0)break ;
      n=new int[6];
      for(int i=0 ; i<6 ; i++)n[i]=scanner.nextInt();
      u=new int[6];
      System.out.println(slove(p,5));
    }
  }
  private int slove(int r,int c){
    if(c>=0){
      int ans=1<<30 ;
      for(int i=0 ; i<2 ; i++){
        u[c]=Math.min(n[c],r/coin[c]+i);
        ans=Math.min(ans,slove(Math.max(0,r-u[c]*coin[c]),c-1)+u[c]);
      }
      return ans ;
    }
    else {
      int ch=-p ;
      for(int i=0 ; i<6 ; i++)ch+=coin[i]*u[i];
      int ans=0 ;
      for(int i=5 ; i>=0 ; i--){
        ans+=ch/coin[i];
        ch %=coin[i];
      }
      return ans ;
    }
  }
  int p ;
  int[] n,u ;
  int[] coin={
    1,5,10,50,100,500 };
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     p := scanner.getCurrent()->toInteger() ; 
     if (p = 0) then     break else skip ; 
    n := Integer.subrange(1,6)->collect(0) ; 
        var i : int ; i := 0 ; while i < 6 do (     n[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    u := Integer.subrange(1,6)->collect(0) ; 
    OclFile["System.out"].println(slove(p, 5)) ; 
 ) );
   operation slove( r : int, c : int) : int
  pre: true
  post: true
  activity: (     if (c >= 0) then (     var ans : int ; ans := (1*(2->pow(30)))->oclAsType(long) ;
         var i : int ; i := 0 ; while i < 2 do ( (     u[c+1] := Set{n[c+1], r / coin[c+1] + i}->min() ; 
     ans := Set{ans, slove(Set{0, r - u[c+1] * coin[c+1]}->max(), c - 1) + u[c+1]}->min() )  ;     i := i + 1 ) ; 
     return ans ) else (     var ch : int ; ch := -p ;
         var i : int ; i := 0 ; while i < 6 do (     ch := ch+(coin[i+1] * u[i+1]) ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 5 ; while i >= 0 do ( (     ans := ans+(ch / coin[i+1]) ; 
     ch := ch mod coin[i+1] )  ;     i := i - 1 ) ; 
    return ans 
 ) );
   attribute p : int;
   attribute n : Sequence(int);
   attribute coin : Sequence(int) := Sequence{1,5,10,50,100,500};
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Solution {
  public static void main(String[] args){
    FastReader sc=new FastReader();
    StringBuilder sb=new StringBuilder();
    int testcases=1 ;
    while(testcases-->0){
      int n=sc.nextInt();
      int need=1 ;
      int curr=2 ;
      int total=0 ;
      while(n>=need){
        total++;
        n-=need ;
        need+=curr ;
        curr++;
      }
      sb.append(total);
    }
    System.out.println(sb);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var sb : String ; sb := StringLib.newString() ;
    var testcases : int ; testcases := 1 ;
        while (testcases > 0) do (        testcases := testcases - 1 ;     skip ; (     var n : int ; n := sc.nextInt() ;
     var need : int ; need := 1 ;
    var curr : int ; curr := 2 ;
    var total : int ; total := 0 ;
    while (n >= need) do (     total := total + 1 ; 
     n := n-(need) ; 
     need := need+(curr) ; 
     curr := curr + 1 ) ; 
    sb := sb + StringLib.newString(total) ; 
 ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int numCases=sc.nextInt();
    for(int caseNum=1 ; caseNum<=numCases ; caseNum++){
      int N=sc.nextInt();
      int K=sc.nextInt();
      int[] sums=new int[N-K+1];
      for(int i=0 ; i<N-K+1 ; i++){
        sums[i]=sc.nextInt();
      }
      int[] maxDiff=new int[K];
      int[] minDiff=new int[K];
      for(int i=0 ; i<K ; i++){
        int totalDiff=0 ;
        for(int j=i ; j<N-K ; j+=K){
          totalDiff+=sums[j+1]-sums[j];
          maxDiff[i]=Math.max(maxDiff[i],totalDiff);
          minDiff[i]=Math.min(minDiff[i],totalDiff);
        }
      }
      long min=0 ;
      long max=Integer.MAX_VALUE ;
      while(min<max){
        long mid=(min+max)/2 ;
        boolean possible=true ;
        long minSum=0,maxSum=0 ;
        for(int i=0 ; i<K ; i++){
          if(maxDiff[i]-minDiff[i]>mid){
            possible=false ;
            break ;
          }
          long minValue=-minDiff[i],maxValue=mid-maxDiff[i];
          minSum+=minValue ;
          maxSum+=maxValue ;
        }
        long target=((sums[0]-minSum)% K+K)% K+minSum ;
        if(possible && target<=maxSum){
          max=mid ;
        }
        else {
          min=mid+1 ;
        }
      }
      System.out.println("Case #"+caseNum+": "+min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numCases : int ; numCases := sc.getCurrent()->toInteger() ;
         var caseNum : int ; caseNum := 1 ; while caseNum <= numCases do ( (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    var sums : Sequence(int) ; sums := Integer.subrange(1,N - K + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N - K + 1 do ( (     sums[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var maxDiff : Sequence(int) ; maxDiff := Integer.subrange(1,K)->collect(0) ;
    var minDiff : Sequence(int) ; minDiff := Integer.subrange(1,K)->collect(0) ;
        var i : int ; i := 0 ; while i < K do ( (     var totalDiff : int ; totalDiff := 0 ;
         var j : int ; j := i ; while j < N - K do ( (     totalDiff := totalDiff+(sums[j + 1+1] - sums[j+1]) ; 
     maxDiff[i+1] := Set{maxDiff[i+1], totalDiff}->max() ; 
     minDiff[i+1] := Set{minDiff[i+1], totalDiff}->min() )  ;     j := j+(K) ) )  ;     i := i + 1 ) ; 
    var min : long ; min := 0 ;
    var max : long ; max := 2147483647 ;
    while (min < max) do (     var mid : long ; mid := (min + max) / 2 ;
     var possible : boolean ; possible := true ;
    var minSum : long ; minSum := 0 ;
    var maxSum : long ; maxSum := 0 ;
        var i : int ; i := 0 ; while i < K do ( (     if (maxDiff[i+1] - minDiff[i+1] > mid) then (     possible := false ; 
     break ) else skip ; 
     var minValue : long ; minValue := -minDiff[i+1] ;
    var maxValue : long ; maxValue := mid - maxDiff[i+1] ;
     minSum := minSum+(minValue) ; 
     maxSum := maxSum+(maxValue) )  ;     i := i + 1 ) ; 
    var target : long ; target := ((sums[0+1] - minSum) mod K + K) mod K + minSum ;
    if (possible & target <= maxSum) then (     max := mid ) else (     min := mid + 1 ) ;  
 ) ; 
    OclFile["System.out"].println("Case #" + caseNum + ": " + min) ; 
 )  ;     caseNum := caseNum + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  int[] ret ;
  int[] val={
    500,100,50,10,5,1 };
    int plus=500 ;
    void run(){
      Scanner sc=new Scanner(System.in);
      ret=new int[plus];
      fill(ret,INF);
      ret[0]=0 ;
      for(int i=0 ; i<plus ; i++)for(int j=0 ; j<val.length ; j++){
        if(i+val[j]<plus)ret[i+val[j] ]=min(ret[i+val[j] ],ret[i]+1);
      }
      for(; ; ){
        int P=sc.nextInt();
        if(P==0)break ;
        int[] coins=new int[val.length];
        for(int i=val.length-1 ; i>=0 ; i--)coins[i]=sc.nextInt();
        int min=INF ;
        for(int i=P ; i<P+plus ; i++){
          int pay=i ;
          int coin=0 ;
          for(int j=0 ; j<val.length ; j++){
            int c=min(pay/val[j],coins[j]);
            pay-=c*val[j];
            coin+=c ;
          }
          if(pay==0)min=min(min,coin+ret[i-P]);
        }
        System.out.println(min);
      }
    }
    public static void main(String[] args){
      new Main().run();
    }
    void debug(Object...os){
      System.err.println(Arrays.deepToString(os));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute ret : Sequence(int);
   attribute val : Sequence(int) := Sequence{500,100,50,10,5,1};
   attribute plus : int := 500;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     ret := Integer.subrange(1,plus)->collect(0) ; 
    execute fill(ret, INF) ; 
    ret[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < plus do (         var j : int ; j := 0 ; while j < val->size() do ( (     if (i + val[j+1] < plus) then     ret[i + val[j+1]+1] := Set{ret[i + val[j+1]+1], ret[i+1] + 1}->min() ; else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
      while true do ( (     var P : int ; P := sc.getCurrent()->toInteger() ;
     if (P = 0) then     break else skip ; 
    var coins : Sequence(int) ; coins := Integer.subrange(1,val->size())->collect(0) ;
        var i : int ; i := val->size() - 1 ; while i >= 0 do (     coins[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i - 1 ) ; 
    var min : int ; min := INF ;
        var i : int ; i := P ; while i < P + plus do ( (     var pay : int ; pay := i ;
     var coin : int ; coin := 0 ;
         var j : int ; j := 0 ; while j < val->size() do ( (     var c : int ; c := min(pay / val[j+1], coins[j+1]) ;
     pay := pay-(c * val[j+1]) ; 
     coin := coin+(c) )  ;     j := j + 1 ) ; 
     if (pay = 0) then     min := Set{min, coin + ret[i - P+1]}->min() ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 )  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int[] p={
    1,5,10,50,100,500 };
    int[] c ;
    int pay(int x){
      int r=0 ;
      for(int k=5 ; k>=0 ; k--){
        int a=Math.min(x/p[k],c[k]);
        r+=a ;
        x-=p[k]*a ;
      }
      return r ;
    }
    int get(int x){
      int r=0 ;
      for(int k=5 ; k>=0 ; k--){
        int c=x/p[k];
        r+=c ;
        x-=p[k]*c ;
      }
      return r ;
    }
    void run(){
      int[] r=new int[666001];
      for(int i=0 ; i<666001 ; i++)r[i]=get(i);
      Scanner sc=new Scanner(System.in);
      while(true){
        int P=sc.nextInt();
        if(P==0)break ;
        c=new int[6];
        int sum=0 ;
        for(int i=0 ; i<6 ; i++){
          c[i]=sc.nextInt();
          sum+=p[i]*c[i];
        }
        int min=1<<28 ;
        for(int i=P ; i<=sum ; i++){
          min=Math.min(min,pay(i)+r[i-P]);
        }
        System.out.println(min);
      }
    }
    public static void main(String[] args){
      new Main().run();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute p : Sequence(int) := Sequence{1,5,10,50,100,500};
   attribute c : Sequence(int);
   operation pay( x : int) : int
  pre: true
  post: true
  activity: (     var r : int ; r := 0 ;
         var k : int ; k := 5 ; while k >= 0 do ( (     var a : int ; a := Set{x / p[k+1], c[k+1]}->min() ;
     r := r+(a) ; 
     x := x-(p[k+1] * a) )  ;     k := k - 1 ) ; 
     return r );
   operation get( x : int) : int
  pre: true
  post: true
  activity: (     var r : int ; r := 0 ;
         var k : int ; k := 5 ; while k >= 0 do ( (     var c : int ; c := x / p[k+1] ;
     r := r+(c) ; 
     x := x-(p[k+1] * c) )  ;     k := k - 1 ) ; 
     return r );
   operation run() : void
  pre: true
  post: true
  activity: (     var r : Sequence(int) ; r := Integer.subrange(1,666001)->collect(0) ;
         var i : int ; i := 0 ; while i < 666001 do (     r[i+1] := at(i+1) ;  ;     i := i + 1 ) ; 
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var P : int ; P := sc.getCurrent()->toInteger() ;
     if (P = 0) then     break else skip ; 
    c := Integer.subrange(1,6)->collect(0) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 6 do ( (     c[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(p[i+1] * c[i+1]) )  ;     i := i + 1 ) ; 
    var min : int ; min := (1*(2->pow(28)))->oclAsType(long) ;
        var i : int ; i := P ; while i <= sum do ( (     min := Set{min, pay(i) + r[i - P+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static final int MAX=1000 ;
  public static final int[] coins=new int[] {
    500,100,50,10,5,1 };
    public static final int[] maxs=new int[] {
      Integer.MAX_VALUE,Integer.MAX_VALUE,Integer.MAX_VALUE,Integer.MAX_VALUE,Integer.MAX_VALUE,Integer.MAX_VALUE };
      public static final int ret_coin(int P,int[] coin_nums){
        int ret=0 ;
        for(int i=0 ; i<coins.length ; i++){
          final int p_use=P/coins[i];
          final int can_use=Math.min(p_use,coin_nums[i]);
          ret+=can_use ;
          P-=coins[i]*can_use ;
        }
        return ret ;
      }
      public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        while(true){
          final int P=sc.nextInt();
          if(P==0){
            break ;
          }
          int[] coin_nums=new int[6];
          int sum=0 ;
          for(int i=0 ; i<6 ; i++){
            coin_nums[5-i]=sc.nextInt();
            sum+=coin_nums[5-i]*coins[5-i];
          }
          final int max=Math.min(sum,P+500);
          int min=Integer.MAX_VALUE ;
          for(int i=P ; i<=max ; i++){
            min=Math.min(min,ret_coin(i,coin_nums)+ret_coin(i-P,maxs));
          }
          System.out.println(min);
        }
        sc.close();
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 1000;
  static    attribute coins : Sequence(int) := Sequence{500,100,50,10,5,1};
  static    attribute maxs : Sequence(int) := Sequence{2147483647,2147483647,2147483647,2147483647,2147483647,2147483647};
  static    operation ret_coin( P : int, coin_nums : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
         var i : int ; i := 0 ; while i < coins->size() do ( (     var p_use : int ; p_use := P / coins[i+1] ;
     var can_use : int ; can_use := Set{p_use, coin_nums[i+1]}->min() ;
     ret := ret+(can_use) ; 
     P := P-(coins[i+1] * can_use) )  ;     i := i + 1 ) ; 
     return ret );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var P : int ; P := sc.getCurrent()->toInteger() ;
     if (P = 0) then (     break ) else skip ; 
    var coin_nums : Sequence(int) ; coin_nums := Integer.subrange(1,6)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 6 do ( (     coin_nums[5 - i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(coin_nums[5 - i+1] * coins[5 - i+1]) )  ;     i := i + 1 ) ; 
    var max : int ; max := Set{sum, P + 500}->min() ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := P ; while i <= max do ( (     min := Set{min, ret_coin(i, coin_nums) + ret_coin(i - P, maxs)}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static int[] coin={
    500,100,50,10,5,1 };
    public static int[] n=new int[6];
    public static void main(String[] args)throws java.io.IOException {
      Scanner scan=new Scanner(System.in);
      while(true){
        int p=scan.nextInt();
        if(p==0)break ;
        for(int i=5 ; i>=0 ; i--)n[i]=scan.nextInt();
        int ans=1000000 ;
        for(int i=p ; i<p+1000 ; i++)ans=Math.min(ans,buy(i)+change(i-p));
        System.out.println(ans);
      }
    }
    public static int change(int n){
      int sum=0 ;
      for(int i=0 ; i<6 ; i++){
        if(n>=coin[i]){
          sum+=n/coin[i];
          n %=coin[i];
        }
      }
      return sum ;
    }
    public static int buy(int c){
      int sum=0 ;
      for(int i=0 ; i<6 ; i++){
        if(c>=coin[i]){
          int tmp=Math.min(c/coin[i],n[i]);
          sum+=tmp ;
          c-=coin[i]*tmp ;
        }
      }
      if(c!=0)sum=1000000 ;
      return sum ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute coin : Sequence(int) := Sequence{500,100,50,10,5,1};
  static   attribute n : Sequence(int) := Integer.subrange(1,6)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var p : int ; p := scan.getCurrent()->toInteger() ;
     if (p = 0) then     break else skip ; 
        var i : int ; i := 5 ; while i >= 0 do (     n[i+1] := scan.getCurrent()->toInteger() ;  ;     i := i - 1 ) ; 
    var ans : int ; ans := 1000000 ;
        var i : int ; i := p ; while i < p + 1000 do (     ans := Set{ans, buy(i) + change(i - p)}->min() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation change( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < 6 do ( (     if (n >= coin[i+1]) then (     sum := sum+(n / coin[i+1]) ; 
     n := n mod coin[i+1] ) else skip )  ;     i := i + 1 ) ; 
     return sum );
  static   operation buy( c : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < 6 do ( (     if (c >= coin[i+1]) then (     var tmp : int ; tmp := Set{c / coin[i+1], n[i+1]}->min() ;
     sum := sum+(tmp) ; 
     c := c-(coin[i+1] * tmp) ) else skip )  ;     i := i + 1 ) ; 
     if (c /= 0) then     sum := 1000000 ; else skip ; 
     return sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int findMinimumAdjacentSwaps(int arr[],int N){
    boolean[] visited=new boolean[N+1];
    int minimumSwaps=0 ;
    Arrays.fill(visited,false);
    for(int i=0 ; i<2*N ; i++){
      if(visited[arr[i] ]==false){
        visited[arr[i] ]=true ;
        int count=0 ;
        for(int j=i+1 ; j<2*N ; j++){
          if(visited[arr[j] ]==false)count++;
          else if(arr[i]==arr[j])minimumSwaps+=count ;
        }
      }
    }
    return minimumSwaps ;
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3,3,1,2 };
      int N=arr.length ;
      N/=2 ;
      System.out.println(findMinimumAdjacentSwaps(arr,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation findMinimumAdjacentSwaps( arr : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var visited : Sequence(boolean) ; visited := Integer.subrange(1,N + 1)->collect(false) ;
     var minimumSwaps : int ; minimumSwaps := 0 ;
    visited := visited->collect(false) ; 
        var i : int ; i := 0 ; while i < 2 * N do ( (     if (visited[arr[i+1]+1] = false) then (     visited[arr[i+1]+1] := true ; 
     var count : int ; count := 0 ;
         var j : int ; j := i + 1 ; while j < 2 * N do ( (     if (visited[arr[j+1]+1] = false) then     count := count + 1 ; else     if (arr[i+1] = arr[j+1]) then     minimumSwaps := minimumSwaps+(count) ; else skip ; )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    return minimumSwaps 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,3,1,2} ;
     var N : int ; N := arr->size() ;
     N := N/(2) ; 
     OclFile["System.out"].println(findMinimumAdjacentSwaps(arr, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    String s=sc.next();
    while(t-->0){
      int l=sc.nextInt();
      int r=sc.nextInt();
      String c1=sc.next();
      String c2=sc.next();
      char ch1=c1.charAt(0);
      char ch2=c2.charAt(0);
      String s1=s.substring(l-1,r);
      s1=s1.replace(ch1,ch2);
      s=s.substring(0,l-1)+s1+s.substring(r);
    }
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var c1 : String ; c1 := sc.getCurrent() ;
    var c2 : String ; c2 := sc.getCurrent() ;
    var ch1 : String ; ch1 := c1->at(0+1) ;
    var ch2 : String ; ch2 := c2->at(0+1) ;
    var s1 : String ; s1 := s.subrange((l)->char2byte() - 1+1,r) ;
    s1 := s1.replace(ch1, ch2) ; 
    s := s.subrange(0+1,(l)->char2byte() - 1) + s1 + s.subrange(r+1,r) ; 
 ) ;  ) ;  
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int X=sc.nextInt();
    sc.close();
    int total=0 ;
    int cnt=1 ;
    while(true){
      total+=cnt ;
      cnt++;
      if(X<=total){
        break ;
      }
    }
    System.out.print(cnt-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : int ; X := sc.getCurrent()->toInteger() ;
    skip ; 
    var total : int ; total := 0 ;
    var cnt : int ; cnt := 1 ;
    while (true) do (     total := total+(cnt) ; 
     cnt := cnt + 1 ; 
     if (X <= total) then (     break ) else skip ) ; 
    OclFile["System.out"].print(cnt - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.Closeable ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args)throws IOException {
    final Scanner sc=new Scanner(System.in);
    final long X=sc.nextLong();
    long pow=0 ;
    for(int time=0 ; pow<X ; time++){
      pow+=time ;
      if(X<=pow){
        System.out.println(time);
        return ;
      }
    }
  }
  public static class Scanner implements Closeable {
    private BufferedReader br ;
    private StringTokenizer tok ;
    public Scanner(InputStream is)throws IOException {
      br=new BufferedReader(new InputStreamReader(is));
    }
    private void getLine()throws IOException {
      while(! hasNext()){
        tok=new StringTokenizer(br.readLine());
      }
    }
    private boolean hasNext(){
      return tok!=null && tok.hasMoreTokens();
    }
    public String next()throws IOException {
      getLine();
      return tok.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public int[] nextIntArray(int n)throws IOException {
      final int[] ret=new int[n];
      for(int i=0 ; i<n ; i++){
        ret[i]=this.nextInt();
      }
      return ret ;
    }
    public long[] nextLongArray(int n)throws IOException {
      final long[] ret=new long[n];
      for(int i=0 ; i<n ; i++){
        ret[i]=this.nextLong();
      }
      return ret ;
    }
    public void close()throws IOException {
      br.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : long ; X := sc.getCurrent()->toLong() ;
     var pow : long ; pow := 0 ;
         var time : int ; time := 0 ; while pow < X do ( (     pow := pow+(time) ; 
     if (X <= pow) then (     OclFile["System.out"].println(time) ; 
     return ) else skip )  ;     time := time + 1 ) );
  static class Scanner implements Closeable {
   attribute br : OclFile;
   attribute tok : OclIterator;
   static operation newScanner( is : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
   operation getLine() : void
  pre: true
  post: true
  activity: (     while (not(hasNext())) do (     tok := OclIterator.newOclIterator_String(br.readLine()) ) );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return tok /= null & tok.hasNext() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute getLine() ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ret : Sequence(int) ; ret := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     ret[i+1] := self.nextInt() )  ;     i := i + 1 ) ; 
     return ret );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var ret : Sequence(long) ; ret := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     ret[i+1] := self.nextLong() )  ;     i := i + 1 ) ; 
     return ret );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.NoSuchElementException ;
public class Main {
  int X ;
  public void solve(){
    X=nextInt();
    int sum=0 ;
    int i=0 ;
    for(; sum<X ; i++){
      sum+=i ;
    }
    out.println(i-1);
  }
  public static void main(String[] args){
    out.flush();
    new Main().solve();
    out.close();
  }
  private static final InputStream in=System.in ;
  private static final PrintWriter out=new PrintWriter(System.out);
  private final byte[] buffer=new byte[2048];
  private int p=0 ;
  private int buflen=0 ;
  private boolean hasNextByte(){
    if(p<buflen)return true ;
    p=0 ;
    try {
      buflen=in.read(buffer);
    }
    catch(IOException e){
      e.printStackTrace();
    }
    if(buflen<=0)return false ;
    return true ;
  }
  public boolean hasNext(){
    while(hasNextByte()&& ! isPrint(buffer[p])){
      p++;
    }
    return hasNextByte();
  }
  private boolean isPrint(int ch){
    if(ch>='!' && ch<='~')return true ;
    return false ;
  }
  private int nextByte(){
    if(! hasNextByte())return-1 ;
    return buffer[p++];
  }
  public String next(){
    if(! hasNext())throw new NoSuchElementException();
    StringBuilder sb=new StringBuilder();
    int b=-1 ;
    while(isPrint((b=nextByte()))){
      sb.appendCodePoint(b);
    }
    return sb.toString();
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
  public double nextDouble(){
    return Double.parseDouble(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute X : int;
   operation solve() : void
  pre: true
  post: true
  activity: (     X := nextInt() ; 
     var sum : int ; sum := 0 ;
    var i : int ; i := 0 ;
      while sum < X do ( (     sum := sum+(i) )  ;     i := i + 1 ) ; 
    out.println(i - 1) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     out.flush() ; 
     Main.newMain().solve() ; 
     out.close() );
  static    attribute in : OclFile := OclFile["System.in"];
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   attribute buffer : Sequence(int) := Integer.subrange(1,2048)->collect(0);
   attribute p : int := 0;
   attribute buflen : int := 0;
   operation hasNextByte() : boolean
  pre: true
  post: true
  activity: (     if (p < buflen) then     return true else skip ; 
     p := 0 ; 
    try (     buflen := in.read(buffer) )   catch (e : IOException) do (     e.printStackTrace() )
    if (buflen <= 0) then     return false else skip ; 
    return true 
 );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (hasNextByte() & not(isPrint(buffer[p+1]))) do (     p := p + 1 ) ; 
     return hasNextByte() );
   operation isPrint( ch : int) : boolean
  pre: true
  post: true
  activity: (     if (ch >= '!' & ch <= '~') then     return true else skip ; 
     return false );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     if (not(hasNextByte())) then     return -1 else skip ; 
     return buffer[p+1] );
   operation next() : String
  pre: true
  post: true
  activity: (     if (not(hasNext())) then     error IncorrectElementException() ; else skip ; 
     var sb : String ; sb := StringLib.newString() ;
    var b : int ; b := -1 ;
    while (isPrint((b))) do (     sb.appendCodePoint(b) ) ; 
    return sb+"" 
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      Main main=new Main();
      main.solveA(sc);
    }
  }
  private void solveD(Scanner sc){
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out)){
    }
    catch(IOException e){
    }
  }
  private void solveE(Scanner sc){
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out)){
    }
    catch(IOException e){
    }
  }
  private void solveC(Scanner sc){
  }
  void solveB(Scanner sc){
  }
  void solveA(Scanner sc){
    runA(sc.nextLong());
  }
  private void runA(long num){
    if(num==1){
      System.out.println("1");
      return ;
    }
    long min=1 ;
    long max=num ;
    while(min+1<max){
      long now=(min+max)/2 ;
      long x=now*(now+1)/2 ;
      if(x>num){
        max=now ;
      }
      else if(x==num){
        System.out.println(now);
        return ;
      }
      else {
        min=now ;
      }
    }
    System.out.println(min+1);
  }
  private static int binarySearch(int[] list,int num){
    int max=list.length ;
    int min=0 ;
    while(min+1<max){
      int now=(max+min)/2 ;
      if(list[now]>num){
        max=now ;
      }
      else {
        min=now ;
      }
    }
    return min ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var main : Main ; main := Main.newMain() ;
     main.solveA(sc) ))  );
   operation solveD( sc : OclFile) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]) ;
 skip)   catch (e : IOException) do skip
  );
   operation solveE( sc : OclFile) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]) ;
 skip)   catch (e : IOException) do skip
  );
   operation solveC( sc : OclFile) : void
  pre: true
  post: true
  activity: skip;
   operation solveB( sc : OclFile) : void
  pre: true
  post: true
  activity: skip;
   operation solveA( sc : OclFile) : void
  pre: true
  post: true
  activity: (     execute runA(sc.getCurrent()->toLong()) );
   operation runA( num : long) : void
  pre: true
  post: true
  activity: (     if (num = 1) then (     OclFile["System.out"].println("1") ; 
     return ) else skip ; 
     var min : long ; min := 1 ;
    var max : long ; max := num ;
    while (min + 1 < max) do (     var now : long ; now := (min + max) / 2 ;
     var x : long ; x := now * (now + 1) / 2 ;
     if (x > num) then (     max := now ) else     if (x = num) then (     OclFile["System.out"].println(now) ; 
     return ) else (     min := now ) ;  ) ; 
    OclFile["System.out"].println(min + 1) ; 
 );
  static   operation binarySearch( list : Sequence(int), num : int) : int
  pre: true
  post: true
  activity: (     var max : int ; max := list->size() ;
     var min : int ; min := 0 ;
     while (min + 1 < max) do (     var now : int ; now := (max + min) / 2 ;
     if (list[now+1] > num) then (     max := now ) else (     min := now ) ) ; 
     return min );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int ni(){
    return cin.nextInt();
  }
  long nl(){
    return cin.nextLong();
  }
  String line(){
    return cin.nextLine();
  }
  void println(String str){
    System.out.println(str);
  }
  void print(String str){
    System.out.print(str);
  }
  static final int MOD=1000000007 ;
  Scanner cin=new Scanner(System.in);
  String output ;
  public static void main(String[] args){
    new Main().run();
  }
  public void run(){
    input();
    int res=solve();
    output=res+"" ;
    println(output);
  }
  int X ;
  void input(){
    X=ni();
  }
  int solve(){
    int i=1 ;
    int cnt=0 ;
    for(; ; i++){
      int j=i ;
      while(j>0){
        cnt++;
        if(cnt==X){
          return i ;
        }
        j--;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation ni() : int
  pre: true
  post: true
  activity: (     return cin.nextInt() );
   operation nl() : long
  pre: true
  post: true
  activity: (     return cin.nextLong() );
   operation line() : String
  pre: true
  post: true
  activity: (     return cin.nextLine() );
   operation println( str : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(str) );
   operation print( str : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(str) );
  static    attribute MOD : int := 1000000007;
   attribute cin : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute output : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     execute input() ; 
     var res : int ; res := solve() ;
     output := res + "" ; 
     execute println(output) );
   attribute X : int;
   operation input() : void
  pre: true
  post: true
  activity: (     X := ni() );
   operation solve() : int
  pre: true
  post: true
  activity: (     var i : int ; i := 1 ;
     var cnt : int ; cnt := 0 ;
       while true do ( (     var j : int ; j := i ;
     while (j > 0) do (     cnt := cnt + 1 ; 
     if (cnt = X) then (     return i ) else skip ; 
     j := j - 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  public static void main(String...orange)throws Exception {
    Scanner input=new Scanner(System.in);
    int numCases=input.nextInt();
    for(int n=0 ; n<numCases ; n++){
      int N=input.nextInt();
      int K=input.nextInt();
      int[] sums=new int[N-K+1];
      for(int i=0 ; i<N-K+1 ; i++)sums[i]=input.nextInt();
      int[] maxdiffs=new int[K];
      int[] mindiffs=new int[K];
      int[] currdiff=new int[K];
      for(int i=K ; i<N ; i++){
        currdiff[i % K]+=sums[i-K+1]-sums[i-K];
        if(currdiff[i % K]>maxdiffs[i % K])maxdiffs[i % K]=currdiff[i % K];
        if(currdiff[i % K]<mindiffs[i % K])mindiffs[i % K]=currdiff[i % K];
      }
      int[] diffdiffs=new int[K];
      for(int i=0 ; i<K ; i++)diffdiffs[i]=maxdiffs[i]-mindiffs[i];
      int maxdiffdiff=0 ;
      for(int i=0 ; i<K ; i++)if(diffdiffs[i]>maxdiffdiff)maxdiffdiff=diffdiffs[i];
      int highBound=0 ;
      for(int i=0 ; i<K ; i++)highBound+=maxdiffdiff-diffdiffs[i];
      int target=sums[0];
      for(int i=0 ; i<K ; i++)target+=mindiffs[i];
      target=(target % K+K)% K ;
      int ans=maxdiffdiff+(target<=highBound ? 0 : 1);
      System.out.printf("Case #%d: ",n+1);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( orange : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numCases : int ; numCases := input.getCurrent()->toInteger() ;
         var n : int ; n := 0 ; while n < numCases do ( (     var N : int ; N := input.getCurrent()->toInteger() ;
     var K : int ; K := input.getCurrent()->toInteger() ;
    var sums : Sequence(int) ; sums := Integer.subrange(1,N - K + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N - K + 1 do (     sums[i+1] := input.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var maxdiffs : Sequence(int) ; maxdiffs := Integer.subrange(1,K)->collect(0) ;
    var mindiffs : Sequence(int) ; mindiffs := Integer.subrange(1,K)->collect(0) ;
    var currdiff : Sequence(int) ; currdiff := Integer.subrange(1,K)->collect(0) ;
        var i : int ; i := K ; while i < N do ( (     currdiff[i mod K+1] := currdiff[i mod K+1]+(sums[i - K + 1+1] - sums[i - K+1]) ; 
     if (currdiff[i mod K+1] > maxdiffs[i mod K+1]) then     maxdiffs[i mod K+1] := currdiff[i mod K+1] ; else skip ; 
     if (currdiff[i mod K+1] < mindiffs[i mod K+1]) then     mindiffs[i mod K+1] := currdiff[i mod K+1] ; else skip )  ;     i := i + 1 ) ; 
    var diffdiffs : Sequence(int) ; diffdiffs := Integer.subrange(1,K)->collect(0) ;
        var i : int ; i := 0 ; while i < K do (     diffdiffs[i+1] := maxdiffs[i+1] - mindiffs[i+1] ;  ;     i := i + 1 ) ; 
    var maxdiffdiff : int ; maxdiffdiff := 0 ;
        var i : int ; i := 0 ; while i < K do (     if (diffdiffs[i+1] > maxdiffdiff) then     maxdiffdiff := diffdiffs[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    var highBound : int ; highBound := 0 ;
        var i : int ; i := 0 ; while i < K do (     highBound := highBound+(maxdiffdiff - diffdiffs[i+1]) ;  ;     i := i + 1 ) ; 
    var target : int ; target := sums[0+1] ;
        var i : int ; i := 0 ; while i < K do (     target := target+(mindiffs[i+1]) ;  ;     i := i + 1 ) ; 
    target := (target mod K + K) mod K ; 
    var ans : int ; ans := maxdiffdiff + (if target <= highBound then 0 else 1 endif) ;
    OclFile["System.out"].printf("Case #%d: ", n + 1) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     n := n + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int minParentheses(String p){
    int bal=0 ;
    int ans=0 ;
    for(int i=0 ; i<p.length(); ++i){
      bal+=p.charAt(i)=='(' ? 1 :-1 ;
      if(bal==-1){
        ans+=1 ;
        bal+=1 ;
      }
    }
    return bal+ans ;
  }
  public static void main(String args[]){
    String p="())" ;
    System.out.println(minParentheses(p));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minParentheses( p : String) : int
  pre: true
  post: true
  activity: (     var bal : int ; bal := 0 ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < p->size() do ( (     bal := bal+(if p->at(i+1) = '(' then 1 else -1 endif) ; 
     if (bal = -1) then (     ans := ans+(1) ; 
     bal := bal+(1) ) else skip )  ;     i := i + 1 ) ; 
     return bal + ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : String ; p := "())" ;
     OclFile["System.out"].println(minParentheses(p)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int a[]=new int[m];
    int total=0 ;
    for(int i=0 ; i<m ; i++){
      a[i]=sc.nextInt();
      total+=a[i];
    }
    int ans=n-total ;
    if(ans>=0){
      System.out.println(ans);
    }
    else {
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     total := total+(a[i+1]) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := n - total ;
    if (ans >= 0) then (     OclFile["System.out"].println(ans) ) else (     OclFile["System.out"].println(-1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BHomework solver=new BHomework();
    solver.solve(1,in,out);
    out.close();
  }
  static class BHomework {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int days=in.nextInt();
      int m=in.nextInt();
      while(m-->0){
        int x=in.nextInt();
        days-=x ;
      }
      out.println(days<0 ? "-1" : days);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BHomework ; solver := BHomework.newBHomework() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BHomework {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var days : int ; days := in.nextInt() ;
     var m : int ; m := in.nextInt() ;
         while (m > 0) do (        m := m - 1 ;     skip ; (     var x : int ; x := in.nextInt() ;
     days := days-(x) ) ;  ) ;  
     skip );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int i ;
    int k=360 ;
    int j=1 ;
    Scanner sc=new Scanner(System.in);
    if(! sc.hasNextInt()){
      System.err.println("aa aa");
    }
    i=Integer.parseInt(sc.nextLine());
    if(1<=i && i<=179){
      while(!((i*j)% k==0)){
++j ;
      }
      System.out.println(j);
    }
    else {
      System.out.println("aa aa");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
     var k : int ; k := 360 ;
    var j : int ; j := 1 ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    if (not(sc.hasNextInt())) then (     OclFile["System.err"].println("aa aa") ) else skip ; 
    i := (sc.nextLine())->toInteger() ; 
    if (1 <= i & i <= 179) then (     while (not(((i * j) mod k = 0))) do (     j := j + 1 ) ; 
     OclFile["System.out"].println(j) ) else (     OclFile["System.out"].println("aa aa") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    long sum=0 ;
    for(int i=0 ; i<m ; i++){
      sum+=sc.nextInt();
    }
    long result=-1 ;
    result=max(n-sum,-1);
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     sum := sum+(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var result : long ; result := -1 ;
    result := Set{n - sum, -1}->max() ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static void solve(InputReader in,PrintWriter out){
    Integer m=in.nextInt(),n=in.nextInt();
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=in.nextInt();
    }
    System.out.print((m-sum>=0)? m-sum :-1);
  }
  public static void main(String args[]){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    solve(in,out);
    out.close();
  }
  private static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public Double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var m : int ; m := in.nextInt() ;
    var n : int ; n := in.nextInt() ;
     var sum : long ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(in.nextInt()) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(if (m - sum >= 0) then m - sum else -1 endif) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    execute solve(in, out) ; 
    skip ; 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void swap(int a,int b){
    int temp=a ;
    a=b ;
    b=temp ;
  }
  static int minimumSquare(int a,int b){
    int result=0,rem=0 ;
    if(a<b)swap(a,b);
    while(b>0){
      result+=a/b ;
      rem=a % b ;
      a=b ;
      b=rem ;
    }
    return result ;
  }
  public static void main(String[] args){
    int n=13,m=29 ;
    System.out.println(minimumSquare(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation swap( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := a ;
     a := b ; 
     b := temp );
  static   operation minimumSquare( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
    var rem : int ; rem := 0 ;
     if (a < b) then     execute swap(a, b) ; else skip ; 
     while (b > 0) do (     result := result+(a / b) ; 
     rem := a mod b ; 
     a := b ; 
     b := rem ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 13 ;
    var m : int ; m := 29 ;
     OclFile["System.out"].println(minimumSquare(n, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import static java.lang.Math.max ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    while(t!=0){
      int a=input.nextInt();
      int b=input.nextInt();
      int c=input.nextInt();
      int d=input.nextInt();
      int sum=a+b+c+d ;
      if(sum % 3==0 && sum/3>=max(max(a,b),c))System.out.println("YES");
      else System.out.println("NO");
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
     while (t /= 0) do (     var a : int ; a := input.getCurrent()->toInteger() ;
     var b : int ; b := input.getCurrent()->toInteger() ;
    var c : int ; c := input.getCurrent()->toInteger() ;
    var d : int ; d := input.getCurrent()->toInteger() ;
    var sum : int ; sum := a + b + c + d ;
    if (sum mod 3 = 0 & sum / 3 >= Set{Set{a, b}->max(), c}->max()) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class coinn {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    int p=0 ;
    while(t-->0){
      int n=in.nextInt();
      int n2=in.nextInt();
      int n3=in.nextInt();
      int n4=in.nextInt();
      int max=Math.max(n,Math.max(n2,n3));
      int s=n+n2+n3+n4 ;
      if(s % 3==0 && s/3>=max){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class coinn {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
     var p : int ; p := 0 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var n2 : int ; n2 := in.getCurrent()->toInteger() ;
    var n3 : int ; n3 := in.getCurrent()->toInteger() ;
    var n4 : int ; n4 := in.getCurrent()->toInteger() ;
    var max : int ; max := Set{n, Set{n2, n3}->max()}->max() ;
    var s : int ; s := n + n2 + n3 + n4 ;
    if (s mod 3 = 0 & s / 3 >= max) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test148 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      int a[]=new int[3];
      int max=0 ;
      for(int j=0 ; j<3 ; j++){
        a[j]=in.nextInt();
        if(a[j]>max){
          max=a[j];
        }
      }
      int n=in.nextInt();
      for(int j=0 ; j<3 ; j++){
        n-=max-a[j];
      }
      if(n>=0 && n % 3==0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test148 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
     var max : int ; max := 0 ;
        var j : int ; j := 0 ; while j < 3 do ( (     a[j+1] := in.getCurrent()->toInteger() ; 
     if (a[j+1] > max) then (     max := a[j+1] ) else skip )  ;     j := j + 1 ) ; 
    var n : int ; n := in.getCurrent()->toInteger() ;
        var j : int ; j := 0 ; while j < 3 do ( (     n := n-(max - a[j+1]) )  ;     j := j + 1 ) ; 
    if (n >= 0 & n mod 3 = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int zz=1 ; zz<=T ; zz++){
      int N=in.nextInt();
      int[] MC=new int[10000];
      for(int i=0 ; i<N ; i++){
        MC[in.nextInt()-1]++;
      }
      int ans=0 ;
      int[] C=new int[10000];
      int[] E=new int[10000];
      for(int i=1 ; i<=N ; i++){
        boolean good=true ;
        for(int j=0 ; j<10000 ; j++)C[j]=MC[j];
        Arrays.fill(E,0);
        for(int j=0 ; j<10000 ; j++){
          while(C[j]>0){
            boolean legal=true ;
            if(j+i>10000){
              legal=false ;
            }
            else {
              for(int k=0 ; k<i ; k++)if(C[j+k]==0)legal=false ;
            }
            if(legal){
              for(int k=0 ; k<i ; k++)C[j+k]--;
              if(j+i<10000)E[j+i]++;
            }
            else {
              if(E[j]>0){
                E[j]--;
                C[j]--;
                if(j+1<10000)E[j+1]++;
              }
              else {
                good=false ;
                break ;
              }
            }
          }
        }
        if(good){
          ans=i ;
        }
      }
      System.out.format("Case #%d: %d\n",zz,ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var zz : int ; zz := 1 ; while zz <= T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var MC : Sequence(int) ; MC := Integer.subrange(1,10000)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     MC[in.getCurrent()->toInteger() - 1+1] := MC[in.getCurrent()->toInteger() - 1+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var C : Sequence(int) ; C := Integer.subrange(1,10000)->collect(0) ;
    var E : Sequence(int) ; E := Integer.subrange(1,10000)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do ( (     var good : boolean ; good := true ;
         var j : int ; j := 0 ; while j < 10000 do (     C[j+1] := MC[j+1] ;  ;     j := j + 1 ) ; 
    E := E->collect(0) ; 
        var j : int ; j := 0 ; while j < 10000 do ( (     while (C[j+1] > 0) do (     var legal : boolean ; legal := true ;
     if (j + i > 10000) then (     legal := false ) else (         var k : int ; k := 0 ; while k < i do (     if (C[j + k+1] = 0) then     legal := false ; else skip ;  ;     k := k + 1 ) ) ;  
     if (legal) then (         var k : int ; k := 0 ; while k < i do (     C[j + k+1] := C[j + k+1] - 1 ;  ;     k := k + 1 ) ; 
     if (j + i < 10000) then     E[j + i+1] := E[j + i+1] + 1 ; else skip ) else (     if (E[j+1] > 0) then (     E[j+1] := E[j+1] - 1 ; 
     C[j+1] := C[j+1] - 1 ; 
     if (j + 1 < 10000) then     E[j + 1+1] := E[j + 1+1] + 1 ; else skip ) else (     good := false ; 
     break ) ) ) )  ;     j := j + 1 ) ; 
    if (good) then (     ans := i ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].format("Case #%d: %d\n", zz, ans) ; 
 )  ;     zz := zz + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Exersise {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[][] array=new int[n][4];
    for(int i=0 ; i<array.length ; i++){
      for(int j=0 ; j<array[i] .length ; j++){
        array[i][j]=input.nextInt();
      }
    }
    for(int i=0 ; i<array.length ; i++){
      boolean is=isTrue(array[i]);
      if(is==true){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
  public static boolean isTrue(int[] array){
    int sum=0 ;
    int max=array[0];
    for(int i=1 ; i<array.length-1 ; i++){
      if(array[i]>max){
        max=array[i];
      }
    }
    for(int i=0 ; i<array.length-1 ; i++){
      sum=sum+max-array[i];
    }
    int y=array[3]-sum ;
    if(y<0){
      return false ;
    }
    if(y % 3==0){
      return true ;
    }
    else {
      return false ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Exersise {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var array : Sequence(Sequence(int)) ; array := Integer.subrange(1,n)->collect(Integer.subrange(1,4)->collect(0)) ;
        var i : int ; i := 0 ; while i < array->size() do ( (         var j : int ; j := 0 ; while j < array[i+1]->size() do ( (     array[i+1][j+1] := input.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < array->size() do ( (     var is : boolean ; is := isTrue(array[i+1]) ;
     if (is = true) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) )  ;     i := i + 1 ) ; 
 );
  static   operation isTrue( array : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var max : int ; max := array[0+1] ;
        var i : int ; i := 1 ; while i < array->size() - 1 do ( (     if (array[i+1] > max) then (     max := array[i+1] ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < array->size() - 1 do ( (     sum := sum + max - array[i+1] )  ;     i := i + 1 ) ; 
    var y : int ; y := array[3+1] - sum ;
    if (y < 0) then (     return false ) else skip ; 
    if (y mod 3 = 0) then (     return true ) else (     return false ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Collecting {
  public static void main(String[] args){
    Scanner o=new Scanner(System.in);
    int t=o.nextInt();
    while(t-->0){
      long a=o.nextInt(),b=o.nextInt(),c=o.nextInt(),n=o.nextInt();
      long max=Math.max(a,Math.max(b,c)),minus=3*max-a-b-c ;
      if(n-minus<0 ||(n-minus)% 3!=0)System.out.println("NO");
      else System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Collecting {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : OclFile ; o := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := o.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : long ; a := o.getCurrent()->toInteger() ;
    var b : long ; b := o.getCurrent()->toInteger() ;
    var c : long ; c := o.getCurrent()->toInteger() ;
    var n : long ; n := o.getCurrent()->toInteger() ;
     var max : long ; max := Set{a, Set{b, c}->max()}->max() ;
    var minus : long ; minus := 3 * max - a - b - c ;
     if (n - minus < 0 or (n - minus) mod 3 /= 0) then     OclFile["System.out"].println("NO") ; else     OclFile["System.out"].println("YES") ; ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void findMax(int[] arr,int n){
    int maxFirst=Integer.MIN_VALUE ;
    int mid=n/2 ;
    for(int i=0 ; i<mid ; i++){
      maxFirst=Math.max(maxFirst,arr[i]);
    }
    if(n % 2==1){
      maxFirst=Math.max(maxFirst,arr[mid]);
    }
    int maxSecond=Integer.MIN_VALUE ;
    for(int i=mid ; i<n ; i++){
      maxSecond=Math.max(maxSecond,arr[i]);
    }
    System.out.print(maxFirst+","+maxSecond);
  }
  public static void main(String[] args){
    int[] arr={
      1,12,14,5 };
      int n=arr.length ;
      findMax(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMax( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var maxFirst : int ; maxFirst := -2147483648 ;
     var mid : int ; mid := n / 2 ;
        var i : int ; i := 0 ; while i < mid do ( (     maxFirst := Set{maxFirst, arr[i+1]}->max() )  ;     i := i + 1 ) ; 
    if (n mod 2 = 1) then (     maxFirst := Set{maxFirst, arr[mid+1]}->max() ) else skip ; 
    var maxSecond : int ; maxSecond := -2147483648 ;
        var i : int ; i := mid ; while i < n do ( (     maxSecond := Set{maxSecond, arr[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(maxFirst + "," + maxSecond) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,12,14,5} ;
     var n : int ; n := arr->size() ;
     execute findMax(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(in,out);
    out.close();
  }
  static class Task {
    public void solve(InputReader in,PrintWriter out){
      int x=in.nextInt();
      int lcm=(x*360)/gcd(x,360);
      out.println(lcm/x);
    }
    int gcd(int a,int b){
      if(a==0){
        return b ;
      }
      else {
        return gcd(b % a,a);
      }
    }
  }
  static class InputReader {
    BufferedReader br ;
    StringTokenizer st ;
    public InputReader(InputStream stream){
      br=new BufferedReader(new InputStreamReader(stream));
    }
    public String nextToken(){
      while(st==null || ! st.hasMoreTokens()){
        String line=null ;
        try {
          line=br.readLine();
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
        if(line==null){
          return null ;
        }
        st=new StringTokenizer(line);
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(nextToken());
    }
    public long nextLong(){
      return Long.parseLong(nextToken());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var x : int ; x := in.nextInt() ;
     var lcm : int ; lcm := (x * 360) / gcd(x, 360) ;
     skip );
   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then (     return b ) else (     return gcd(b mod a, a) ) );
}
  static class InputReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     var line : String ; line := null ;
     try (     line := br.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
     if (line = null) then (     return null ) else skip ; 
     st := OclIterator.newOclIterator_String(line) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int sumPairs(int arr[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum=sum+(arr[i]*(2*n));
    }
    return sum ;
  }
  static public void main(String[] arg){
    int arr[]={
      1,2,3 };
      int n=arr.length ;
      System.out.println(sumPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum + (arr[i+1] * (2 * n)) )  ;     i := i + 1 ) ; 
     return sum );
  static    operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(sumPairs(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int sumPairs(int arr[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        sum+=(arr[i]+arr[j]);
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3 };
      int n=arr.length ;
      System.out.println(sumPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     sum := sum+((arr[i+1] + arr[j+1])) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(sumPairs(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int A=in.nextInt();
    int B=in.nextInt();
    long[] nums=new long[N];
    for(int i=0 ; i<N ; i++){
      nums[i]=in.nextLong();
    }
    Arrays.sort(nums);
    long sum=0 ;
    boolean isAllSame=true ;
    for(int i=N-1 ; i>=N-A ; i--){
      sum+=nums[i];
      if(i!=N-1 && nums[i]!=nums[i+1]){
        isAllSame=false ;
      }
    }
    double avg=((double)sum)/A ;
    long lowest=nums[N-A];
    int numLowestInNums=0 ;
    int numLowestInAvg=0 ;
    for(int i=0 ; i<N ; i++){
      if(nums[i]==lowest){
        numLowestInNums++;
        if(i>=N-A){
          numLowestInAvg++;
        }
      }
    }
    long count=comb(numLowestInNums,numLowestInAvg);
    if(isAllSame){
      for(int i=N-A-1 ; i>=N-B ; i--){
        if(nums[i]==lowest){
          numLowestInAvg+=1 ;
          count+=comb(numLowestInNums,numLowestInAvg);
        }
        else {
          break ;
        }
      }
    }
    System.out.printf("%.6f\n",avg);
    System.out.println(count);
  }
  public static long comb(int n,int r){
    long v=1 ;
    for(int i=0 ; i<r ; i++){
      v*=n-i ;
      v/=(i+1);
    }
    return v ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var A : int ; A := in.getCurrent()->toInteger() ;
    var B : int ; B := in.getCurrent()->toInteger() ;
    var nums : Sequence(long) ; nums := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     nums[i+1] := in.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    nums := nums->sort() ; 
    var sum : long ; sum := 0 ;
    var isAllSame : boolean ; isAllSame := true ;
        var i : int ; i := N - 1 ; while i >= N - A do ( (     sum := sum+(nums[i+1]) ; 
     if (i /= N - 1 & nums[i+1] /= nums[i + 1+1]) then (     isAllSame := false ) else skip )  ;     i := i - 1 ) ; 
    var avg : double ; avg := (sum->oclAsType(double)) / A ;
    var lowest : long ; lowest := nums[N - A+1] ;
    var numLowestInNums : int ; numLowestInNums := 0 ;
    var numLowestInAvg : int ; numLowestInAvg := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (nums[i+1] = lowest) then (     numLowestInNums := numLowestInNums + 1 ; 
     if (i >= N - A) then (     numLowestInAvg := numLowestInAvg + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    var count : long ; count := comb(numLowestInNums, numLowestInAvg) ;
    if (isAllSame) then (         var i : int ; i := N - A - 1 ; while i >= N - B do ( (     if (nums[i+1] = lowest) then (     numLowestInAvg := numLowestInAvg+(1) ; 
     count := count+(comb(numLowestInNums, numLowestInAvg)) ) else (     break ) )  ;     i := i - 1 ) ) else skip ; 
    OclFile["System.out"].printf("%.6f\n", avg) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation comb( n : int, r : int) : long
  pre: true
  post: true
  activity: (     var v : long ; v := 1 ;
         var i : int ; i := 0 ; while i < r do ( (     v := v*(n - i) ; 
     v := v/((i + 1)) )  ;     i := i + 1 ) ; 
     return v );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  static long[][] comb=new long[51][51];
  public static void combTable(){
    for(int i=0 ; i<=50 ; ++i){
      for(int j=0 ; j<=i ; ++j){
        if(j==0 || j==i){
          comb[i][j]=1 ;
        }
        else {
          comb[i][j]=comb[i-1][j-1]+comb[i-1][j];
        }
      }
    }
  }
  public static void main(String[] args){
    combTable();
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt(),A=sc.nextInt(),B=sc.nextInt();
    Long[] V=new Long[N];
    for(int i=0 ; i<N ; ++i){
      V[i]=sc.nextLong();
    }
    Arrays.sort(V,Collections.reverseOrder());
    int maxvLastIdx=0 ;
    int aValNum=0,aValPos=0 ;
    for(int i=0 ; i<N ; ++i){
      if(V[i] .equals(V[A-1])){
++aValNum ;
        if(i<A){
++aValPos ;
        }
      }
    }
    double avg=0.0 ;
    for(int i=0 ; i<A ; ++i){
      avg+=V[i];
    }
    avg/=A ;
    long cnt=0 ;
    if(aValPos==A){
      for(aValPos=A ; aValPos<=B ; ++aValPos){
        cnt+=comb[aValNum][aValPos];
      }
    }
    else {
      cnt+=comb[aValNum][aValPos];
    }
    System.out.printf("%.6f\n",avg);
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute comb : Sequence(Sequence(long)) := Integer.subrange(1,51)->collect(Integer.subrange(1,51)->collect(0));
  static   operation combTable() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= 50 do ( (         var j : int ; j := 0 ; while j <= i do ( (     if (j = 0 or j = i) then (     comb[i+1][j+1] := 1 ) else (     comb[i+1][j+1] := comb[i - 1+1][j - 1+1] + comb[i - 1+1][j+1] ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute combTable() ; 
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var V : Sequence(long) ; V := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     V[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    V := OclComparator.sortWith(V, reverseOrder()) ; 
    var maxvLastIdx : int ; maxvLastIdx := 0 ;
    var aValNum : int ; aValNum := 0 ;
    var aValPos : int ; aValPos := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (V[i+1] = V[A - 1+1]) then (     aValNum := aValNum + 1 ; 
     if (i < A) then (     aValPos := aValPos + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    var avg : double ; avg := 0.0 ;
        var i : int ; i := 0 ; while i < A do ( (     avg := avg+(V[i+1]) )  ;     i := i + 1 ) ; 
    avg := avg/(A) ; 
    var cnt : long ; cnt := 0 ;
    if (aValPos = A) then (         aValPos := A ; while aValPos <= B do ( (     cnt := cnt+(comb[aValNum+1][aValPos+1]) )  ;     aValPos := aValPos + 1 ) ) else (     cnt := cnt+(comb[aValNum+1][aValPos+1]) ) ;  
    OclFile["System.out"].printf("%.6f\n", avg) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    long[] v=new long[n];
    for(int i=0 ; i<n ; i++){
      v[i]=sc.nextLong();
    }
    sc.close();
    Arrays.sort(v);
    reverse(v);
    long va=v[a-1];
    int big=0 ;
    int eq=0 ;
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(v[i]>va){
        big++;
      }
      else if(v[i]==va){
        eq++;
      }
      if(i<a){
        sum+=v[i];
      }
    }
    BigDecimal bs=BigDecimal.valueOf(sum);
    BigDecimal ba=BigDecimal.valueOf(a);
    System.out.println(bs.divide(ba,25,BigDecimal.ROUND_HALF_UP).toPlainString());
    if(big>0){
      System.out.println(nCr(eq,a-big));
    }
    else {
      long ans=0 ;
      int end=Math.min(eq,b);
      for(int i=a ; i<=end ; i++){
        ans+=nCr(eq,i);
      }
      System.out.println(ans);
    }
  }
  static long nCr(int n,int r){
    long val=1 ;
    for(int i=1 ; i<=r ; i++){
      val=val*(n-i+1)/i ;
    }
    return val ;
  }
  static void reverse(long[] a){
    for(int i=0 ; i<a.length/2 ; i++){
      long tmp=a[i];
      a[i]=a[a.length-1-i];
      a[a.length-1-i]=tmp ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var v : Sequence(long) ; v := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     v[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    skip ; 
    v := v->sort() ; 
    execute reverse(v) ; 
    var va : long ; va := v[a - 1+1] ;
    var big : int ; big := 0 ;
    var eq : int ; eq := 0 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (v[i+1] > va) then (     big := big + 1 ) else     if (v[i+1] = va) then (     eq := eq + 1 ) else skip ; ;  
     if (i < a) then (     sum := sum+(v[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    var bs : double ; bs := (sum + "")->toReal() ;
    var ba : double ; ba := (a + "")->toReal() ;
    OclFile["System.out"].println(bs.divide(ba, 25, ROUND_HALF_UP).toPlainString()) ; 
    if (big > 0) then (     OclFile["System.out"].println(nCr(eq, a - big)) ) else (     var ans : long ; ans := 0 ;
     var end : int ; end := Set{eq, b}->min() ;
         var i : int ; i := a ; while i <= end do ( (     ans := ans+(nCr(eq, i)) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) ) ;  
 );
  static   operation nCr( n : int, r : int) : long
  pre: true
  post: true
  activity: (     var val : long ; val := 1 ;
         var i : int ; i := 1 ; while i <= r do ( (     val := val * (n - i + 1) / i )  ;     i := i + 1 ) ; 
     return val );
  static   operation reverse( a : Sequence(long)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < a->size() / 2 do ( (     var tmp : long ; tmp := a[i+1] ;
     a[i+1] := a[a->size() - 1 - i+1] ; 
     a[a->size() - 1 - i+1] := tmp )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int A=sc.nextInt();
    int B=sc.nextInt();
    long[] v=new long[N];
    for(int i=0 ; i<v.length ; ++i){
      v[i]=sc.nextLong();
    }
    System.out.println(solve(v,A,B));
    sc.close();
  }
  static String solve(long[] v,int A,int B){
    v=Arrays.stream(v).boxed().sorted(Collections.reverseOrder()).mapToLong(x->x).toArray();
    long[] v_=v ;
    double avg=IntStream.range(0,A).mapToLong(i->v_[i]).average().getAsDouble();
    long last=v[A-1];
    int lastCount=(int)Arrays.stream(v).filter(x->x==last).count();
    int lastChosen=(int)IntStream.range(0,A).filter(i->v_[i]==last).count();
    long wayNum=C(lastCount,lastChosen);
    if(v[0]==last){
      for(int i=A+1 ; i<=B && v[i-1]==last ; ++i){
++lastChosen ;
        wayNum+=C(lastCount,lastChosen);
      }
    }
    return String.format("%f\n%d",avg,wayNum);
  }
  static long C(int n,int r){
    long result=1 ;
    for(int i=0 ; i<r ; ++i){
      result=result*(n-i)/(i+1);
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var v : Sequence(long) ; v := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < v->size() do ( (     v[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(v, A, B)) ; 
    skip ; 
 );
  static   operation solve( v : Sequence(long), A : int, B : int) : String
  pre: true
  post: true
  activity: (     v := stream(v)->sort()->collect( _x1 | (lambda x : OclAny in x)->apply(_x1) )->asSequence() ; 
     var v_ : Sequence(long) ; v_ := v ;
    var avg : double ; avg := Integer.subrange(0, A-1)->collect( _x1 | (lambda i : OclAny in v_[i+1])->apply(_x1) ).average().getAsDouble() ;
    var last : long ; last := v[A - 1+1] ;
    var lastCount : int ; lastCount := stream(v)->select( _x1 | (lambda x : OclAny in x = last)->apply(_x1) )->size()->oclAsType(int) ;
    var lastChosen : int ; lastChosen := Integer.subrange(0, A-1)->select( _x1 | (lambda i : OclAny in v_[i+1] = last)->apply(_x1) )->size()->oclAsType(int) ;
    var wayNum : long ; wayNum := C(lastCount, lastChosen) ;
    if (v[0+1] = last) then (         var i : int ; i := A + 1 ; while i <= B & v[i - 1+1] = last do ( (     lastChosen := lastChosen + 1 ; 
     wayNum := wayNum+(C(lastCount, lastChosen)) )  ;     i := i + 1 ) ) else skip ; 
    return StringLib.format("%f\n%d",Sequence{avg,wayNum}) 
 );
  static   operation C( n : int, r : int) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 1 ;
         var i : int ; i := 0 ; while i < r do ( (     result := result * (n - i) / (i + 1) )  ;     i := i + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.run();
  }
  long C[][];
  public void init(int n){
    C=new long[n+1][n+1];
    C[0][0]=1 ;
    for(int i=1 ; i<=n ; i++){
      C[i][0]=1 ;
      for(int j=1 ; j<=n ; j++){
        C[i][j]=C[i-1][j-1]+C[i-1][j];
      }
    }
  }
  private long com(int n,int k){
    if(n<k)return 0 ;
    return C[n][k];
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    ArrayList<Long>v=new ArrayList<Long>();
    for(int i=0 ; i<n ; i++){
      v.add(sc.nextLong());
    }
    init(n);
    Collections.sort(v,Collections.reverseOrder());
    int acnt=0 ;
    int apos=0 ;
    for(int i=0 ; i<n ; i++){
      if(v.get(i).equals(v.get(a))){
        acnt++;
        if(i<a){
          apos++;
        }
      }
    }
    double total=0.0 ;
    for(int i=0 ; i<a ; i++){
      total+=v.get(i);
    }
    double ave=total/(double)a ;
    System.out.println(ave);
    long ans=0 ;
    if(apos==a){
      for(int i=a ; i<=b ; i++){
        ans+=com(acnt,i);
      }
    }
    else {
      ans=com(acnt,apos);
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.run() );
   attribute C : Sequence(Sequence(long));
   operation init( n : int) : void
  pre: true
  post: true
  activity: (     C := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ; 
     C[0+1][0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= n do ( (     C[i+1][0+1] := 1 ; 
         var j : int ; j := 1 ; while j <= n do ( (     C[i+1][j+1] := C[i - 1+1][j - 1+1] + C[i - 1+1][j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
   operation com( n : int, k : int) : long
  pre: true
  post: true
  activity: (     if (n < k) then     return 0 else skip ; 
     return C[n+1][k+1] );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var v : Sequence(long) ; v := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     v := v->including(sc.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    execute init(n) ; 
    v, reverseOrder() := v, reverseOrder()->sort() ; 
    var acnt : int ; acnt := 0 ;
    var apos : int ; apos := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (v->at(i+1) = v->at(a+1)) then (     acnt := acnt + 1 ; 
     if (i < a) then (     apos := apos + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    var total : double ; total := 0.0 ;
        var i : int ; i := 0 ; while i < a do ( (     total := total+(v->at(i+1)) )  ;     i := i + 1 ) ; 
    var ave : double ; ave := total / a->oclAsType(double) ;
    OclFile["System.out"].println(ave) ; 
    var ans : long ; ans := 0 ;
    if (apos = a) then (         var i : int ; i := a ; while i <= b do ( (     ans := ans+(com(acnt, i)) )  ;     i := i + 1 ) ) else (     ans := com(acnt, apos) ) ;  
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class B_as {
  Scanner in ;
  PrintWriter out ;
  public void solve()throws IOException {
    int testNo=in.nextInt();
    for(int test=1 ; test<=testNo ; test++){
      int n=in.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      Arrays.sort(a);
      int m=0 ;
      int[] last=new int[n];
      int[] len=new int[n];
      for(int i=0 ; i<n ; i++){
        int blen=Integer.MAX_VALUE ;
        int best=-1 ;
        for(int j=0 ; j<m ; j++){
          if(last[j]==a[i]-1 && len[j]<blen){
            best=j ;
            blen=len[j];
          }
        }
        if(best==-1){
          last[m]=a[i];
          len[m]=1 ;
          m++;
        }
        else {
          last[best]=a[i];
          len[best]=len[best]+1 ;
        }
      }
      int blen=Integer.MAX_VALUE ;
      for(int i=0 ; i<m ; i++){
        if(len[i]<blen){
          blen=len[i];
        }
      }
      if(blen==Integer.MAX_VALUE){
        blen=0 ;
      }
      out.println("Case #"+test+": "+blen);
    }
  }
  public void run(){
    try {
      in=new Scanner(new File("B-large.in"));
      out=new PrintWriter(new File("B-large.out"));
      solve();
      in.close();
      out.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  public static void main(String[] arg){
    Locale.setDefault(Locale.US);
    new B_as().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_as {
   attribute in : OclFile;
   attribute out : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     var testNo : int ; testNo := in.getCurrent()->toInteger() ;
         var test : int ; test := 1 ; while test <= testNo do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var m : int ; m := 0 ;
    var last : Sequence(int) ; last := Integer.subrange(1,n)->collect(0) ;
    var len : Sequence(int) ; len := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var blen : int ; blen := 2147483647 ;
     var best : int ; best := -1 ;
         var j : int ; j := 0 ; while j < m do ( (     if (last[j+1] = a[i+1] - 1 & len[j+1] < blen) then (     best := j ; 
     blen := len[j+1] ) else skip )  ;     j := j + 1 ) ; 
     if (best = -1) then (     last[m+1] := a[i+1] ; 
     len[m+1] := 1 ; 
     m := m + 1 ) else (     last[best+1] := a[i+1] ; 
     len[best+1] := len[best+1] + 1 ) )  ;     i := i + 1 ) ; 
    var blen : int ; blen := 2147483647 ;
        var i : int ; i := 0 ; while i < m do ( (     if (len[i+1] < blen) then (     blen := len[i+1] ) else skip )  ;     i := i + 1 ) ; 
    if (blen = 2147483647) then (     blen := 0 ) else skip ; 
    skip ; 
 )  ;     test := test + 1 ) );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile("B-large.in")) ; 
     out := OclFile.newOclFile_Write(OclFile("B-large.out")) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.US) ; 
     B_as.newB_as().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static boolean isEmpty(long[] b){
    for(int i=0 ; i<b.length ; i++){
      if(b[i]!=0)return false ;
    }
    return true ;
  }
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      long t=sc.nextLong();
      while(t-->0){
        long A=sc.nextLong();
        long B=sc.nextLong();
        int n=sc.nextInt();
        long[] a=new long[n];
        long[] b=new long[n];
        boolean ok=true ;
        long damage=0 ;
        for(int i=0 ; i<n ; i++){
          a[i]=sc.nextLong();
        }
        for(int i=0 ; i<n ; i++)b[i]=sc.nextLong();
        for(int i=0 ; i<n ; ++i)damage+=(b[i]+A-1)/A*a[i];
        for(int i=0 ; i<n ; ++i){
          if(B-(damage-a[i])>0){
            ok=false ;
            break ;
          }
        }
        if(! ok)System.out.println("YES");
        else System.out.println("NO");
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation isEmpty( b : Sequence(long)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < b->size() do ( (     if (b[i+1] /= 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : long ; t := sc.getCurrent()->toLong() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var A : long ; A := sc.getCurrent()->toLong() ;
     var B : long ; B := sc.getCurrent()->toLong() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
    var ok : boolean ; ok := true ;
    var damage : long ; damage := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     b[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     damage := damage+((b[i+1] + A - 1) / A * a[i+1]) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (B - (damage - a[i+1]) > 0) then (     ok := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (not(ok)) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class G1 {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    long n=sc.nextLong();
    while(n--!=0){
      Slove();
    }
  }
  private static void Slove(){
    long x=sc.nextLong();
    long y=sc.nextLong();
    int n=sc.nextInt();
    long a[]=new long[n];
    long b[]=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
    }
    for(int i=0 ; i<n ; i++){
      b[i]=sc.nextLong();
    }
    long max=0 ;
    for(int i=0 ; i<n ; i++){
      long times=(b[i]+x-1)/x ;
      y-=times*a[i];
      max=Math.max(max,a[i]);
    }
    System.out.println(max+y>=1 ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class G1 {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.getCurrent()->toLong() ;
         while (n /= 0) do (    skip ; (     execute Slove() ) ;  ) );
  static   operation Slove() : void
  pre: true
  post: true
  activity: (     var x : long ; x := sc.getCurrent()->toLong() ;
     var y : long ; y := sc.getCurrent()->toLong() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var max : long ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var times : long ; times := (b[i+1] + x - 1) / x ;
     y := y-(times * a[i+1]) ; 
     max := Set{max, a[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if max + y >= 1 then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    FastReader sc=new FastReader();
    PrintWriter pw=new PrintWriter(System.out);
    int x=sc.nextInt();
    int count=0 ;
    int tmp=x ;
    x=0 ;
    while(x!=360){
      x=x+tmp ;
      if(x>360){
        x=x-360 ;
      }
      count++;
    }
    System.out.println(count);
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    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 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var x : int ; x := sc.nextInt() ;
    var count : int ; count := 0 ;
    var tmp : int ; tmp := x ;
    x := 0 ; 
    while (x /= 360) do (     x := x + tmp ; 
     if (x > 360) then (     x := x - 360 ) else skip ; 
     count := count + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF294A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n+2];
    for(int i=1 ; i<=n ; i++){
      arr[i]=sc.nextInt();
    }
    int m=sc.nextInt();
    int x,y ;
    while(m-->0){
      x=sc.nextInt();
      y=sc.nextInt();
      arr[x+1]+=(arr[x]-y);
      arr[x-1]+=y-1 ;
      arr[x]=0 ;
    }
    for(int i=1 ; i<=n ; i++){
      System.out.println(arr[i]);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF294A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 2)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : int ;
    var y : int ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     x := sc.getCurrent()->toInteger() ; 
     y := sc.getCurrent()->toInteger() ; 
    arr[x + 1+1] := arr[x + 1+1]+((arr[x+1] - y)) ; 
    arr[x - 1+1] := arr[x - 1+1]+(y - 1) ; 
    arr[x+1] := 0 ; 
 ) ;  ) ;  
        var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].println(arr[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF294A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n+2];
    for(int i=1 ; i<=n ; i++){
      arr[i]=sc.nextInt();
    }
    int m=sc.nextInt();
    while(m-->0){
      int x=sc.nextInt();
      int y=sc.nextInt();
      arr[x+1]+=(arr[x]-y);
      arr[x-1]+=y-1 ;
      arr[x]=0 ;
    }
    for(int i=1 ; i<=n ; i++){
      System.out.println(arr[i]);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF294A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 2)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    arr[x + 1+1] := arr[x + 1+1]+((arr[x+1] - y)) ; 
    arr[x - 1+1] := arr[x - 1+1]+(y - 1) ; 
    arr[x+1] := 0 ; 
 ) ;  ) ;  
        var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].println(arr[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF294A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n+2];
    for(int i=1 ; i<=n ; i++){
      arr[i]=sc.nextInt();
    }
    int m=sc.nextInt();
    int x,y ;
    while(m-->0){
      x=sc.nextInt();
      y=sc.nextInt();
      arr[x+1]+=(arr[x]-y);
      arr[x-1]+=y-1 ;
      arr[x]=0 ;
    }
    for(int i=1 ; i<=n ; i++){
      System.out.println(arr[i]);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF294A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 2)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : int ;
    var y : int ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     x := sc.getCurrent()->toInteger() ; 
     y := sc.getCurrent()->toInteger() ; 
    arr[x + 1+1] := arr[x + 1+1]+((arr[x+1] - y)) ; 
    arr[x - 1+1] := arr[x - 1+1]+(y - 1) ; 
    arr[x+1] := 0 ; 
 ) ;  ) ;  
        var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].println(arr[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _294A_ShaassandOskols {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=parseInt(input.nextLine());
    int[] lines=new int[n+2];
    for(int i=1 ; i<=n ; i++){
      lines[i]=input.nextInt();
      ;
    }
    input.nextLine();
    int m=parseInt(input.nextLine());
    for(int i=0 ; i<m ; i++){
      int wire=input.nextInt();
      int xith=input.nextInt();
      input.nextLine();
      int left=xith-1 ;
      int right=lines[wire]-xith ;
      lines[wire+1]+=right ;
      lines[wire-1]+=left ;
      lines[wire]=0 ;
    }
    for(int i=1 ; i<=n ; i++){
      System.out.println(lines[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := parseInt(input.nextLine()) ;
    var lines : Sequence(int) ; lines := Integer.subrange(1,n + 2)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     lines[i+1] := input.getCurrent()->toInteger() ; 
  )  ;     i := i + 1 ) ; 
    skip ; 
    var m : int ; m := parseInt(input.nextLine()) ;
        var i : int ; i := 0 ; while i < m do ( (     var wire : int ; wire := input.getCurrent()->toInteger() ;
     var xith : int ; xith := input.getCurrent()->toInteger() ;
    skip ; 
    var left : int ; left := xith - 1 ;
    var right : int ; right := lines[wire+1] - xith ;
    lines[wire + 1+1] := lines[wire + 1+1]+(right) ; 
    lines[wire - 1+1] := lines[wire - 1+1]+(left) ; 
    lines[wire+1] := 0 ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].println(lines[i+1]) )  ;     i := i + 1 ) ; 
 );
}
94A_ShaassandOskols {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := parseInt(input.nextLine()) ;
    var lines : Sequence(int) ; lines := Integer.subrange(1,n + 2)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     lines[i+1] := input.getCurrent()->toInteger() ; 
  )  ;     i := i + 1 ) ; 
    skip ; 
    var m : int ; m := parseInt(input.nextLine()) ;
        var i : int ; i := 0 ; while i < m do ( (     var wire : int ; wire := input.getCurrent()->toInteger() ;
     var xith : int ; xith := input.getCurrent()->toInteger() ;
    skip ; 
    var left : int ; left := xith - 1 ;
    var right : int ; right := lines[wire+1] - xith ;
    lines[wire + 1+1] := lines[wire + 1+1]+(right) ; 
    lines[wire - 1+1] := lines[wire - 1+1]+(left) ; 
    lines[wire+1] := 0 ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].println(lines[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BuyAShovel {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n ;
    n=scan.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=scan.nextInt();
    }
    int m,x,y ;
    m=scan.nextInt();
    for(int i=0 ; i<m ; i++){
      x=scan.nextInt();
      y=scan.nextInt();
      if(x==n && x==1){
        arr[x-1]=0 ;
      }
      else if(x==n){
        arr[x-1]=(arr[x-1]-(arr[x-1]-y))-1 ;
        arr[x-2]+=arr[x-1];
        arr[x-1]=0 ;
      }
      else if(x==1){
        arr[x]+=arr[x-1]-y ;
        arr[x-1]=(arr[x-1]-(arr[x-1]-y))-1 ;
        arr[x-1]=0 ;
      }
      else {
        arr[x]+=arr[x-1]-y ;
        arr[x-1]=(arr[x-1]-(arr[x-1]-y))-1 ;
        arr[x-2]+=arr[x-1];
        arr[x-1]=0 ;
      }
    }
    for(int i=0 ; i<n ; i++){
      System.out.println(arr[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BuyAShovel {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    n := scan.getCurrent()->toInteger() ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ;
    var x : int ;
    var y : int ;
    m := scan.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < m do ( (     x := scan.getCurrent()->toInteger() ; 
     y := scan.getCurrent()->toInteger() ; 
     if (x = n & x = 1) then (     arr[x - 1+1] := 0 ) else     if (x = n) then (     arr[x - 1+1] := (arr[x - 1+1] - (arr[x - 1+1] - y)) - 1 ; 
     arr[x - 2+1] := arr[x - 2+1]+(arr[x - 1+1]) ; 
     arr[x - 1+1] := 0 ) else     if (x = 1) then (     arr[x+1] := arr[x+1]+(arr[x - 1+1] - y) ; 
     arr[x - 1+1] := (arr[x - 1+1] - (arr[x - 1+1] - y)) - 1 ; 
     arr[x - 1+1] := 0 ) else (     arr[x+1] := arr[x+1]+(arr[x - 1+1] - y) ; 
     arr[x - 1+1] := (arr[x - 1+1] - (arr[x - 1+1] - y)) - 1 ; 
     arr[x - 2+1] := arr[x - 2+1]+(arr[x - 1+1]) ; 
     arr[x - 1+1] := 0 ) ;  ;  )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(arr[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Pattern {
  void display(){
    int n=5 ;
    int space=n/2,num=1 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=space ; j++)System.out.print(" ");
      int count=num/2+1 ;
      for(int k=1 ; k<=num ; k++){
        System.out.print(count);
        if(k<=num/2)count--;
        else count++;
      }
      System.out.println();
      if(i<=n/2){
        space=space-1 ;
        num=num+2 ;
      }
      else {
        space=space+1 ;
        num=num-2 ;
      }
    }
  }
  public static void main(String[] args){
    Pattern p=new Pattern();
    p.display();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Pattern {
   operation display() : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var space : int ; space := n / 2 ;
    var num : int ; num := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= space do (     OclFile["System.out"].print(" ") ;  ;     j := j + 1 ) ; 
     var count : int ; count := num / 2 + 1 ;
        var k : int ; k := 1 ; while k <= num do ( (     OclFile["System.out"].print(count) ; 
     if (k <= num / 2) then     count := count - 1 ; else     count := count + 1 ; )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println() ; 
    if (i <= n / 2) then (     space := space - 1 ; 
     num := num + 2 ) else (     space := space + 1 ; 
     num := num - 2 ) ;  
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : OclRegex ; p := OclRegex() ;
     p.display() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int N=3 ;
  static int countPairs(int a[][]){
    int sumr[]=new int[N];
    int sumc[]=new int[N];
    for(int i=0 ; i<N ; i++)for(int j=0 ; j<N ; j++){
      sumr[i]+=a[i][j];
      sumc[j]+=a[i][j];
    }
    int count=0 ;
    for(int i=0 ; i<N ; i++)for(int j=0 ; j<N ; j++)if(sumc[i]>sumr[j])count++;
    return count ;
  }
  public static void main(String[] args){
    int a[][]={
      {
        1,2,3 },{
          4,5,6 },{
            7,8,9 }
          };
          System.out.println(countPairs(a));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 3;
  static   operation countPairs( a : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var sumr : Sequence(int) ; sumr := Integer.subrange(1,N)->collect(0) ;
     var sumc : Sequence(int) ; sumc := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (         var j : int ; j := 0 ; while j < N do ( (     sumr[i+1] := sumr[i+1]+(a[i+1][j+1]) ; 
     sumc[j+1] := sumc[j+1]+(a[i+1][j+1]) )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N do (         var j : int ; j := 0 ; while j < N do (     if (sumc[i+1] > sumr[j+1]) then     count := count + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(Sequence(int)) ; a := Sequence{Sequence{1,2,3},Sequence{4,5,6},Sequence{7,8,9}} ;
     OclFile["System.out"].println(countPairs(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
class GFG {
  public static int nobleInteger(int arr[]){
    int size=arr.length ;
    for(int i=0 ; i<size ; i++){
      int count=0 ;
      for(int j=0 ; j<size ; j++)if(arr[i]<arr[j])count++;
      if(count==arr[i])return arr[i];
    }
    return-1 ;
  }
  public static void main(String args[]){
    int[] arr={
      10,3,20,40,2 };
      int res=nobleInteger(arr);
      if(res!=-1)System.out.println("The noble "+"integer is "+res);
      else System.out.println("No Noble "+"Integer Found");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nobleInteger( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var size : int ; size := arr->size() ;
         var i : int ; i := 0 ; while i < size do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < size do (     if (arr[i+1] < arr[j+1]) then     count := count + 1 ; else skip ;  ;     j := j + 1 ) ; 
     if (count = arr[i+1]) then     return arr[i+1] else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,3,20,40,2} ;
     var res : int ; res := nobleInteger(arr) ;
     if (res /= -1) then     OclFile["System.out"].println("The noble " + "integer is " + res) ; else     OclFile["System.out"].println("No Noble " + "Integer Found") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round3 ;
import java.io.File ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class B {
  static class Niz {
    int zadnji,duzina ;
    Niz(int element){
      duzina=1 ;
      zadnji=element ;
    }
  }
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(new File("B.in"));
    PrintWriter out=new PrintWriter(new File("B.out"));
    int tt=in.nextInt();
    for(int ttt=1 ; ttt<=tt ; ttt++){
      int n=in.nextInt();
      int[] t=new int[n];
      for(int i=0 ; i<n ; i++)t[i]=in.nextInt();
      int res=0 ;
      if(n>0){
        Arrays.sort(t);
        ArrayList<Niz>nizovi=new ArrayList<B.Niz>();
        for(int i=0 ; i<n ; i++){
          Niz a=null ;
          for(Niz niz : nizovi)if(niz.zadnji==t[i]-1 &&(a==null || a.duzina>niz.duzina))a=niz ;
          if(a==null)nizovi.add(new Niz(t[i]));
          else {
            a.duzina++;
            a.zadnji=t[i];
          }
        }
        res=n ;
        for(Niz niz : nizovi)if(niz.duzina<res)res=niz.duzina ;
      }
      out.printf("Case #%d: %d",ttt,res);
      out.println();
    }
    out.flush();
    out.close();
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static class Niz {
   attribute zadnji : int;
   static operation newNiz( element : int) : Niz
  pre: true
  post: true
  activity:
  ( var self : Niz ;
    self := createNiz();
    self.initialise(element);
    return self );
  operation initialise( element : int) : void
  pre: true  post: true
  activity: (     duzina := 1 ; 
     zadnji := element );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("B.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("B.out")) ;
    var tt : int ; tt := in.getCurrent()->toInteger() ;
        var ttt : int ; ttt := 1 ; while ttt <= tt do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     t[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    if (n > 0) then (     t := t->sort() ; 
     var nizovi : Sequence(Niz) ; nizovi := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : Niz ; a := null ;
     for (niz : nizovi) do (     if (niz.zadnji = t[i+1] - 1 & (a = null or a.duzina > niz.duzina)) then     a := niz ; else skip ;  ) ; 
     if (a = null) then     nizovi := nizovi->including(Niz.newNiz(t[i+1])) ; else (     a.duzina := a.duzina + 1 ; 
     a.zadnji := t[i+1] ) )  ;     i := i + 1 ) ; 
    res := n ; 
    for (niz : nizovi) do (     if (niz.duzina < res) then     res := niz.duzina ; else skip ;  ) ; 
 ) else skip ; 
    skip ; 
    skip ; 
 )  ;     ttt := ttt + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<Integer>a=new ArrayList<>();
    ArrayList<Integer>b=new ArrayList<>();
    ArrayList<Integer>c=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      if(x==1)a.add(i+1);
      if(x==2)b.add(i+1);
      if(x==3)c.add(i+1);
    }
    int count=Math.min(a.size(),Math.min(b.size(),c.size()));
    System.out.println(count);
    for(int i=0 ; i<count ; i++){
      System.out.println(a.get(i)+" "+b.get(i)+" "+c.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
    var b : Sequence(int) ; b := Sequence{} ;
    var c : Sequence(int) ; c := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x = 1) then     a := a->including(i + 1) ; else skip ; 
     if (x = 2) then     b := b->including(i + 1) ; else skip ; 
     if (x = 3) then     c := c->including(i + 1) ; else skip )  ;     i := i + 1 ) ; 
    var count : int ; count := Set{a->size(), Set{b->size(), c->size()}->min()}->min() ;
    OclFile["System.out"].println(count) ; 
        var i : int ; i := 0 ; while i < count do ( (     OclFile["System.out"].println(a->at(i+1) + " " + b->at(i+1) + " " + c->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  BufferedReader br ;
  StringTokenizer st ;
  int max=-1 ;
  void solve()throws IOException {
    long x=ni();
    long temp=360 ;
    long i=2 ;
    while(temp % x!=0){
      temp=360*i ;
      i++;
    }
    pl(temp/x);
  }
  int hcf(int a,int b){
    if(a==0)return b ;
    return hcf(b % a,a);
  }
  Main(){
    try {
      br=new BufferedReader(new InputStreamReader(System.in));
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
        System.out.println(e);
      }
    }
    catch(Exception e){
      System.out.println(e);
    }
  }
  Main(String s){
    try {
      br=new BufferedReader(new FileReader(s));
      st=new StringTokenizer(br.readLine());
    }
    catch(Exception e){
      System.out.println(e);
    }
  }
  public static void main(String[] args)throws IOException {
    new Main().solve();
  }
  String ns(){
    if(! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
        System.out.println(e);
      }
    }
    return st.nextToken();
  }
  int ni(){
    return Integer.parseInt(ns());
  }
  long nl(){
    return Long.parseLong(ns());
  }
  double nd(){
    return Double.parseDouble(ns());
  }
  void pl(String s){
    System.out.println(s);
  }
  void pl(long s){
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute br : OclFile;
   attribute st : OclIterator;
   attribute max : int := -1;
   operation solve() : void
  pre: true
  post: true
  activity: (     var x : long ; x := ni() ;
     var temp : long ; temp := 360 ;
    var i : long ; i := 2 ;
    while (temp mod x /= 0) do (     temp := 360 * i ; 
     i := i + 1 ) ; 
    execute pl(temp / x) ; 
 );
   operation hcf( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return hcf(b mod a, a) );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     OclFile["System.out"].println(e) )
 )   catch (e : ProgramException) do (     OclFile["System.out"].println(e) )
 );
   static operation newMain( s : String) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) ; 
     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     OclFile["System.out"].println(e) )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation ns() : String
  pre: true
  post: true
  activity: (     if (not(st.hasNext())) then (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     OclFile["System.out"].println(e) )
 ) else skip ; 
     return st.next() );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (ns())->toInteger() );
   operation nl() : long
  pre: true
  post: true
  activity: (     return (ns())->toLong() );
   operation nd() : double
  pre: true
  post: true
  activity: (     return (ns())->toReal() );
   operation pl( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
   operation pl( s : long) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] ones=new int[n];
    int[] twos=new int[n];
    int[] thirds=new int[n];
    int c_one=0,c_sec=0,c_third=0 ;
    for(int i=0 ; i<n ; i++){
      int num=sc.nextInt();
      if(num==1){
        ones[c_one]=i+1 ;
        c_one++;
      }
      else if(num==2){
        twos[c_sec]=i+1 ;
        c_sec++;
      }
      else if(num==3){
        thirds[c_third]=i+1 ;
        c_third++;
      }
      else {
      }
    }
    int min=Math.min(c_one,Math.min(c_third,c_sec));
    System.out.println(min);
    for(int i=0 ; i<min ; i++){
      if(min==0){
        System.out.println(0);
      }
      else {
        System.out.println(ones[i]+" "+twos[i]+" "+thirds[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ones : Sequence(int) ; ones := Integer.subrange(1,n)->collect(0) ;
    var twos : Sequence(int) ; twos := Integer.subrange(1,n)->collect(0) ;
    var thirds : Sequence(int) ; thirds := Integer.subrange(1,n)->collect(0) ;
    var c_one : int ; c_one := 0 ;
    var c_sec : int ; c_sec := 0 ;
    var c_third : int ; c_third := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := sc.getCurrent()->toInteger() ;
     if (num = 1) then (     ones[c_one+1] := i + 1 ; 
     c_one := c_one + 1 ) else     if (num = 2) then (     twos[c_sec+1] := i + 1 ; 
     c_sec := c_sec + 1 ) else     if (num = 3) then (     thirds[c_third+1] := i + 1 ; 
     c_third := c_third + 1 ) else skip ;  ;  )  ;     i := i + 1 ) ; 
    var min : int ; min := Set{c_one, Set{c_third, c_sec}->min()}->min() ;
    OclFile["System.out"].println(min) ; 
        var i : int ; i := 0 ; while i < min do ( (     if (min = 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(ones[i+1] + " " + twos[i+1] + " " + thirds[i+1]) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class NewClass33 {
  @ SuppressWarnings("empty-statement")public static void main(String[] args){
    java.util.Scanner in=new java.util.Scanner(System.in);
    int n=in.nextInt();
    int arr[][]=new int[4][5001];
    int count[]=new int[4];
    for(int i=1 ; i<=n ; i++){
      int g=in.nextInt();
      count[g]++;
      arr[g][count[g] ]=i ;
    }
    int s=Math.min(Math.min(count[1],count[2]),count[3]);
    System.out.println(s);
    for(int i=1 ; i<=s ; i++){
      System.out.print(arr[1][i]+" "+arr[2][i]+" "+arr[3][i]);
      System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class NewClass33 {
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : Scanner ; in := Scanner.newScanner(OclFile["System.in"]) ;
     var n : int ; n := in.nextInt() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,4)->collect(Integer.subrange(1,5001)->collect(0)) ;
    var count : Sequence(int) ; count := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     var g : int ; g := in.nextInt() ;
     count[g+1] := count[g+1] + 1 ; 
     arr[g+1][count[g+1]+1] := i )  ;     i := i + 1 ) ; 
    var s : int ; s := Set{Set{count[1+1], count[2+1]}->min(), count[3+1]}->min() ;
    OclFile["System.out"].println(s) ; 
        var i : int ; i := 1 ; while i <= s do ( (     OclFile["System.out"].print(arr[1+1][i+1] + " " + arr[2+1][i+1] + " " + arr[3+1][i+1]) ; 
     OclFile["System.out"].println("") )  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TeamOlympiad {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int number=in.nextInt();
    int[][] arr=new int[4][number+1];
    for(int i=1 ; i<=number ; i++){
      int a=in.nextInt();
      arr[a][++arr[a][0] ]=i ;
    }
    int w=Math.min(Math.min(arr[1][0],arr[2][0]),arr[3][0]);
    System.out.println(w);
    for(int i=1 ; i<=w ; i++){
      System.out.println(arr[1][i]+" "+arr[2][i]+" "+arr[3][i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TeamOlympiad {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := in.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,4)->collect(Integer.subrange(1,number + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= number do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
         arr[a+1][0+1] := arr[a+1][0+1] + 1 ;
 arr[a+1][arr[a+1][0+1]+1] := i  )  ;     i := i + 1 ) ; 
    var w : int ; w := Set{Set{arr[1+1][0+1], arr[2+1][0+1]}->min(), arr[3+1][0+1]}->min() ;
    OclFile["System.out"].println(w) ; 
        var i : int ; i := 1 ; while i <= w do ( (     OclFile["System.out"].println(arr[1+1][i+1] + " " + arr[2+1][i+1] + " " + arr[3+1][i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GFG {
  public static int findRepeatFirst(String s){
    int p=-1,i,k ;
    int MAX_CHAR=256 ;
    int hash[]=new int[MAX_CHAR];
    int pos[]=new int[MAX_CHAR];
    for(i=0 ; i<s.length(); i++){
      k=(int)s.charAt(i);
      if(hash[k]==0){
        hash[k]++;
        pos[k]=i ;
      }
      else if(hash[k]==1)hash[k]++;
    }
    for(i=0 ; i<MAX_CHAR ; i++){
      if(hash[i]==2){
        if(p==-1)p=pos[i];
        else if(p>pos[i])p=pos[i];
      }
    }
    return p ;
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    int pos=findRepeatFirst(str);
    if(pos==-1)System.out.println("Not found");
    else System.out.println(str.charAt(pos));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findRepeatFirst( s : String) : int
  pre: true
  post: true
  activity: (     var p : int ; p := -1 ;
    var i : int ;
    var k : int ;
     var MAX_CHAR : int ; MAX_CHAR := 256 ;
    var hash : Sequence(int) ; hash := Integer.subrange(1,MAX_CHAR)->collect(0) ;
    var pos : Sequence(int) ; pos := Integer.subrange(1,MAX_CHAR)->collect(0) ;
        i := 0 ; while i < s->size() do ( (     k := s->at(i+1)->oclAsType(int) ; 
     if (hash[k+1] = 0) then (     hash[k+1] := hash[k+1] + 1 ; 
     pos[k+1] := i ) else     if (hash[k+1] = 1) then     hash[k+1] := hash[k+1] + 1 ; else skip ; )  ;     i := i + 1 ) ; 
        i := 0 ; while i < MAX_CHAR do ( (     if (hash[i+1] = 2) then (     if (p = -1) then     p := pos[i+1] ; else     if (p > pos[i+1]) then     p := pos[i+1] ; else skip ; ) else skip )  ;     i := i + 1 ) ; 
    return p 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var pos : int ; pos := findRepeatFirst(str) ;
     if (pos = -1) then     OclFile["System.out"].println("Not found") ; else     OclFile["System.out"].println(str->at(pos+1)) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    long f=(long)Math.ceil(Math.sqrt(N));
    long min=N-1 ;
    for(long i=1 ; i<=f ; i++){
      if(N % i!=0){
        continue ;
      }
      if(N/i+i-2<=min){
        min=N/i+i-2 ;
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    var f : long ; f := ((N)->sqrt())->ceil()->oclAsType(long) ;
    var min : long ; min := N - 1 ;
        var i : long ; i := 1 ; while i <= f do ( (     if (N mod i /= 0) then (     continue ) else skip ; 
     if (N / i + i - 2 <= min) then (     min := N / i + i - 2 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.math.*;
import java.util.ArrayList ;
import java.util.*;
import java.io.*;
public class Main {
  static Scanner scn=new Scanner(System.in);
  public static void main(String[] args){
    long n=scn.nextLong();
    int s=(int)Math.sqrt(n);
    boolean flag=true ;
    long n1=-1 ;
    long n2=-1 ;
    while(flag){
      if(n % s==0){
        flag=false ;
        n1=s ;
        n2=n/s ;
      }
      else {
        s--;
      }
    }
    long ans=n1+n2-2 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := scn.getCurrent()->toLong() ;
     var s : int ; s := (n)->sqrt()->oclAsType(int) ;
    var flag : boolean ; flag := true ;
    var n1 : long ; n1 := -1 ;
    var n2 : long ; n2 := -1 ;
    while (flag) do (     if (n mod s = 0) then (     flag := false ; 
     n1 := s ; 
     n2 := n / s ) else (     s := s - 1 ) ) ; 
    var ans : long ; ans := n1 + n2 - 2 ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CWalkOnMultiplicationTable solver=new CWalkOnMultiplicationTable();
    solver.solve(1,in,out);
    out.close();
  }
  static class CWalkOnMultiplicationTable {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      long n=in.nextLong();
      long answer=Long.MAX_VALUE ;
      for(long i=1 ; i*i<=n ; i++){
        if(n % i==0){
          long j=n/i ;
          answer=Math.min(answer,i+j-2);
        }
      }
      out.println(answer);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CWalkOnMultiplicationTable ; solver := CWalkOnMultiplicationTable.newCWalkOnMultiplicationTable() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CWalkOnMultiplicationTable {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : long ; n := in.nextLong() ;
     var answer : long ; answer := "9223372036854775807"->toLong() ;
         var i : long ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     var j : long ; j := n / i ;
     answer := Set{answer, i + j - 2}->min() ) else skip )  ;     i := i + 1 ) ; 
     skip );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scan=new Scanner(System.in)){
      long N=scan.nextLong();
      ArrayList<Long>zenyaku_a=enum_div(N);
      ArrayList<Long>zenyaku_b=enum_div2(zenyaku_a,N);
      long min=zenyaku_a.get(0)+zenyaku_b.get(0);
      for(int i=1 ; i<zenyaku_a.size(); i++){
        if(min>zenyaku_a.get(i)+zenyaku_b.get(i)){
          min=zenyaku_a.get(i)+zenyaku_b.get(i);
        }
      }
      System.out.println(min-2);
      ;
    }
  }
  private static ArrayList<Long>enum_div(long n){
    ArrayList<Long>ret=new ArrayList<Long>();
    for(long i=1 ; i*i<=n ; i++){
      if(n % i==0){
        ret.add(i);
        if(i!=1 && i*i!=n){
          ret.add(n/i);
        }
      }
    }
    ret.add(n);
    Collections.sort(ret);
    return ret ;
  }
  private static ArrayList<Long>enum_div2(ArrayList<Long>a,long n){
    ArrayList<Long>ret=new ArrayList<Long>();
    for(int i=0 ; i<a.size(); i++){
      ret.add(n/a.get(i));
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : long ; N := scan.getCurrent()->toLong() ;
     var zenyaku_a : Sequence(long) ; zenyaku_a := enum_div(N) ;
    var zenyaku_b : Sequence(long) ; zenyaku_b := enum_div2(zenyaku_a, N) ;
    var min : long ; min := zenyaku_a->at(0+1) + zenyaku_b->at(0+1) ;
        var i : int ; i := 1 ; while i < zenyaku_a->size() do ( (     if (min > zenyaku_a->at(i+1) + zenyaku_b->at(i+1)) then (     min := zenyaku_a->at(i+1) + zenyaku_b->at(i+1) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min - 2) ; 
 ))  );
  static   operation enum_div( n : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var ret : Sequence(long) ; ret := Sequence{} ;
         var i : long ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     ret := ret->including(i) ; 
     if (i /= 1 & i * i /= n) then (     ret := ret->including(n / i) ) else skip ) else skip )  ;     i := i + 1 ) ; 
    ret := ret->including(n) ; 
    ret := ret->sort() ; 
    return ret 
 );
  static   operation enum_div2( a : Sequence(long), n : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var ret : Sequence(long) ; ret := Sequence{} ;
         var i : int ; i := 0 ; while i < a->size() do ( (     ret := ret->including(n / a->at(i+1)) )  ;     i := i + 1 ) ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.lang.reflect.Array ;
import java.math.BigDecimal ;
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Iterator ;
import java.util.List ;
import java.util.Map ;
import java.util.Map.Entry ;
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.Stack ;
import java.util.TreeMap ;
import java.util.TreeSet ;
import static java.util.Comparator.*;
public class Main {
  public static void main(String[] args){
    PrintWriter out=new PrintWriter(System.out);
    Solver solver=new Solver(System.in,out);
    solver.solve();
    out.close();
  }
}
class Solver {
  Scanner sc ;
  PrintWriter out ;
  public Solver(InputStream in,PrintWriter out){
    sc=new Scanner(in);
    this.out=out ;
  }
  long INF=999999999999L ;
  public void solve(){
    long N=Long.parseLong(sc.next());
    long ans=INF ;
    for(long i=2 ; i*i<=N ; i++){
      if(N % i==0){
        ans=Math.min(ans,(i-1)+(N/i-1));
      }
    }
    if(ans==INF)ans=N-1 ;
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var solver : Solver ; solver := Solver.newSolver(OclFile["System.in"], out) ;
     solver.solve() ; 
     skip );
}
class Solver {
   attribute sc : OclFile;
   attribute out : OclFile;
   static operation newSolver( in : OclFile, out : OclFile) : Solver
  pre: true
  post: true
  activity:
  ( var self : Solver ;
    self := createSolver();
    self.initialise(in, out);
    return self );
  operation initialise( in : OclFile, out : OclFile) : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(in) ; 
     self.out := out );
   attribute INF : long := 999999999999L;
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : long ; N := (sc.getCurrent())->toLong() ;
     var ans : long ; ans := INF ;
        var i : long ; i := 2 ; while i * i <= N do ( (     if (N mod i = 0) then (     ans := Set{ans, (i - 1) + (N / i - 1)}->min() ) else skip )  ;     i := i + 1 ) ; 
    if (ans = INF) then     ans := N - 1 ; else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  static StreamTokenizer in ;
  static int next()throws Exception {
    in.nextToken();
    return(int)in.nval ;
  };
  static PrintWriter out ;
  static String NAME="b" ;
  public static void main(String[] args)throws Exception {
    in=new StreamTokenizer(new BufferedReader(new FileReader(new File(NAME+".in"))));
    out=new PrintWriter(new File(NAME+".out"));
    int tests=next();
    for(int test=1 ; test<=tests ; test++){
      int n=next();
      if(n==0){
        out.println("Case #"+test+": 0");
        continue ;
      }
      int m=10005 ;
      int[] k=new int[m];
      for(int i=0 ; i<n ; i++)k[next()]++;
      int answ=100000 ;
      int start=0 ;
      int end=0 ;
      while(true){
        while(start<m && k[start]==0)start++;
        if(start==m)break ;
        end=start ;
        while(k[end]!=0)end++;
        ArrayList<Integer>s=new ArrayList<Integer>();
        ArrayList<Integer>e=new ArrayList<Integer>();
        for(int i=start ; i<=end ; i++){
          if(k[i]>k[i-1])for(int j=0 ;
          j<k[i]-k[i-1];
          j++)s.add(i);
          if(k[i]<k[i-1])for(int j=0 ;
          j<k[i-1]-k[i];
          j++)e.add(i);
        }
        for(int i=0 ; i<s.size(); i++)answ=Math.min(answ,e.get(i)-s.get(i));
        start=end ;
      }
      out.println("Case #"+test+": "+answ);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : StreamTokenizer;
  static   operation next() : int
  pre: true
  post: true
  activity: (     in.next() ; 
     return in.nval->oclAsType(int) );
  static   attribute out : OclFile;
  static   attribute NAME : String := "b";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := StreamTokenizer.newStreamTokenizer(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(NAME + ".in")))) ; 
     out := OclFile.newOclFile_Write(OclFile(NAME + ".out")) ; 
    var tests : int ; tests := next() ;
        var test : int ; test := 1 ; while test <= tests do ( (     var n : int ; n := next() ;
     if (n = 0) then (     skip ; 
     continue ) else skip ; 
    var m : int ; m := 10005 ;
    var k : Sequence(int) ; k := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     k[next()+1] := k[next()+1] + 1 ;  ;     i := i + 1 ) ; 
    var answ : int ; answ := 100000 ;
    var start : int ; start := 0 ;
    var end : int ; end := 0 ;
    while (true) do (     while (start < m & k[start+1] = 0) do     start := start + 1 ; ; 
     if (start = m) then     break else skip ; 
    end := start ; 
    while (k[end+1] /= 0) do     end := end + 1 ; ; 
    var s : Sequence(int) ; s := Sequence{} ;
    var e : Sequence(int) ; e := Sequence{} ;
        var i : int ; i := start ; while i <= end do ( (     if (k[i+1] > k[i - 1+1]) then         var j : int ; j := 0 ; while j < k[i+1] - k[i - 1+1] do (     s := s->including(i) ;  ;     j := j + 1 ) ; else skip ; 
     if (k[i+1] < k[i - 1+1]) then         var j : int ; j := 0 ; while j < k[i - 1+1] - k[i+1] do (     e := e->including(i) ;  ;     j := j + 1 ) ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < s->size() do (     answ := Set{answ, e->at(i+1) - s->at(i+1)}->min() ;  ;     i := i + 1 ) ; 
    start := end ; 
 ) ; 
    skip ; 
 )  ;     test := test + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ShortestKingPath {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    String s1=in.next();
    char c[]=s.toCharArray();
    char c1[]=s1.toCharArray();
    int diff=c1[0]-c[0];
    int dif=c1[1]-c[1];
    int n=Math.abs(diff);
    int m=Math.abs(dif);
    String ans="" ;
    while(diff!=0 || dif!=0){
      if(diff>0){
        ans+="R" ;
        diff--;
      }
      if(diff<0){
        ans+="L" ;
        diff++;
      }
      if(dif>0){
        ans+="U" ;
        dif--;
      }
      if(dif<0){
        ans+="D" ;
        dif++;
      }
      ans+="\n" ;
    }
    System.out.println(Math.max(n,m));
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ShortestKingPath {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
    var s1 : String ; s1 := in.getCurrent() ;
    var c : Sequence(String) ; c := s->characters() ;
    var c1 : Sequence(String) ; c1 := s1->characters() ;
    var diff : int ; diff := c1[0+1] - c[0+1] ;
    var dif : int ; dif := c1[1+1] - c[1+1] ;
    var n : int ; n := if diff < 0 then -(diff) else diff endif ;
    var m : int ; m := if dif < 0 then -(dif) else dif endif ;
    var ans : String ; ans := "" ;
    while (diff /= 0 or dif /= 0) do (     if (diff > 0) then (     ans := ans+("R") ; 
     diff := diff - 1 ) else skip ; 
     if (diff < 0) then (     ans := ans+("L") ; 
     diff := diff + 1 ) else skip ; 
    if (dif > 0) then (     ans := ans+("U") ; 
     dif := dif - 1 ) else skip ; 
    if (dif < 0) then (     ans := ans+("D") ; 
     dif := dif + 1 ) else skip ; 
    ans := ans+("\n") ; 
 ) ; 
    OclFile["System.out"].println(Set{n, m}->max()) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    BigInteger x=new BigInteger(sc.next());
    BigInteger n=new BigInteger("360");
    BigInteger gcd=x.gcd(n);
    System.out.println(n.divide(gcd));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := long(sc.getCurrent()) ;
    var n : long ; n := long("360") ;
    var gcd : long ; gcd := x.gcd(n) ;
    OclFile["System.out"].println(n.divide(gcd)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int[] seg={
    6,2,5,5,4,5,6,3,7,6 };
    static int computeSegment(int x){
      if(x==0)return seg[0];
      int count=0 ;
      while(x>0){
        count+=seg[x % 10];
        x/=10 ;
      }
      return count ;
    }
    static int elementMinSegment(int[] arr,int n){
      int minseg=computeSegment(arr[0]);
      int minindex=0 ;
      for(int i=1 ; i<n ; i++){
        int temp=computeSegment(arr[i]);
        if(temp<minseg){
          minseg=temp ;
          minindex=i ;
        }
      }
      return arr[minindex];
    }
    static public void main(String[] args){
      int[] arr={
        489,206,745,123,756 };
        int n=arr.length ;
        System.out.println(elementMinSegment(arr,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute seg : Sequence(int) := Sequence{6,2,5,5,4,5,6,3,7,6};
  static   operation computeSegment( x : int) : int
  pre: true
  post: true
  activity: (     if (x = 0) then     return seg[0+1] else skip ; 
     var count : int ; count := 0 ;
     while (x > 0) do (     count := count+(seg[x mod 10+1]) ; 
     x := x/(10) ) ; 
     return count );
  static   operation elementMinSegment( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var minseg : int ; minseg := computeSegment(arr[0+1]) ;
     var minindex : int ; minindex := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     var temp : int ; temp := computeSegment(arr[i+1]) ;
     if (temp < minseg) then (     minseg := temp ; 
     minindex := i ) else skip )  ;     i := i + 1 ) ; 
     return arr[minindex+1] );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{489,206,745,123,756} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(elementMinSegment(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
class GFG {
  static int factorial(int n){
    int fact=1,i ;
    if(n==0)return 1 ;
    for(i=1 ; i<=n ; i++)fact*=i ;
    return fact ;
  }
  static void findmiddle(int A,int X,int n){
    int i,j,aPow,xPow ;
    float middleTerm1,middleTerm2 ;
    if(n % 2==0){
      i=n/2 ;
      aPow=(int)Math.pow(A,n-i);
      xPow=(int)Math.pow(X,i);
      middleTerm1=((float)factorial(n)/(factorial(n-i)*factorial(i)))*aPow*xPow ;
      System.out.println("MiddleTerm="+middleTerm1);
    }
    else {
      i=(n-1)/2 ;
      j=(n+1)/2 ;
      aPow=(int)Math.pow(A,n-i);
      xPow=(int)Math.pow(X,i);
      middleTerm1=((float)factorial(n)/(factorial(n-i)*factorial(i)))*aPow*xPow ;
      aPow=(int)Math.pow(A,n-j);
      xPow=(int)Math.pow(X,j);
      middleTerm2=((float)factorial(n)/(factorial(n-j)*factorial(j)))*aPow*xPow ;
      System.out.println("MiddleTerm1="+middleTerm1);
      System.out.println("MiddleTerm2="+middleTerm2);
    }
  }
  public static void main(String[] args){
    int n=6,A=2,X=4 ;
    findmiddle(A,X,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation factorial( n : int) : int
  pre: true
  post: true
  activity: (     var fact : int ; fact := 1 ;
    var i : int ;
     if (n = 0) then     return 1 else skip ; 
         i := 1 ; while i <= n do (     fact := fact*(i) ;  ;     i := i + 1 ) ; 
     return fact );
  static   operation findmiddle( A : int, X : int, n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var aPow : int ;
    var xPow : int ;
     var middleTerm1 : double ;
    var middleTerm2 : double ;
     if (n mod 2 = 0) then (     i := n / 2 ; 
     aPow := A->pow(n - i)->oclAsType(int) ; 
    xPow := X->pow(i)->oclAsType(int) ; 
    middleTerm1 := (factorial(n)->oclAsType(double) / (factorial(n - i) * factorial(i))) * aPow * xPow ; 
    OclFile["System.out"].println("MiddleTerm=" + middleTerm1) ; 
 ) else (     i := (n - 1) / 2 ; 
     j := (n + 1) / 2 ; 
    aPow := A->pow(n - i)->oclAsType(int) ; 
    xPow := X->pow(i)->oclAsType(int) ; 
    middleTerm1 := (factorial(n)->oclAsType(double) / (factorial(n - i) * factorial(i))) * aPow * xPow ; 
    aPow := A->pow(n - j)->oclAsType(int) ; 
    xPow := X->pow(j)->oclAsType(int) ; 
    middleTerm2 := (factorial(n)->oclAsType(double) / (factorial(n - j) * factorial(j))) * aPow * xPow ; 
    OclFile["System.out"].println("MiddleTerm1=" + middleTerm1) ; 
    OclFile["System.out"].println("MiddleTerm2=" + middleTerm2) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
    var A : int ; A := 2 ;
    var X : int ; X := 4 ;
     execute findmiddle(A, X, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class a {
  public static long time ;
  public static void main(String[] args)throws Exception {
    time=System.currentTimeMillis();
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    go(br);
    br.close();
    System.exit(0);
  }
  public static void go(BufferedReader br)throws Exception {
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    System.out.println(a*(b-1)+b*(c-1)+c*(a-1)+1);
    sc.close();
  }
  public static void checkTime(){
    System.out.println(System.currentTimeMillis()-time);
    time=System.currentTimeMillis();
  }
}
------------------------------------------------------------
OCL File:
---------
 class a {
  static   attribute time : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     time := OclDate.getSystemTime() ; 
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    execute go(br) ; 
    skip ; 
OclProcess.exit(0) ; 
 );
  static   operation go( br : OclFile) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(a * (b - 1) + b * (c - 1) + c * (a - 1) + 1) ; 
    skip ; 
 );
  static   operation checkTime() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(OclDate.getSystemTime() - time) ; 
     time := OclDate.getSystemTime() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    FastScanner input=new FastScanner();
    long a=input.nextLong();
    long b=input.nextLong();
    long c=input.nextLong();
    long ans=0 ;
    ans=(a*b*c)-((a-1)*(b-1)*(c-1));
    System.out.println(ans);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var a : long ; a := input.nextLong() ;
    var b : long ; b := input.nextLong() ;
    var c : long ; c := input.nextLong() ;
    var ans : long ; ans := 0 ;
    ans := (a * b * c) - ((a - 1) * (b - 1) * (c - 1)) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.PrintWriter ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    double[] a=new double[n];
    double[] tmp=new double[n];
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt()-k ;
      if(i!=0){
        a[i]+=a[i-1];
      }
      tmp[i]=a[i];
      if(tmp[i]>=0){
        ans++;
      }
    }
    Arrays.sort(tmp);
    for(int i=0 ; i<n ; i++){
      a[i]=-Arrays.binarySearch(tmp,a[i]+0.1);
    }
    BIT b=new BIT(n+1);
    for(int i=0 ; i<n ; i++){
      ans+=b.get((int)a[i]);
      b.add((int)a[i]);
    }
    System.out.println(ans);
  }
  static class BIT {
    int n ;
    int[] data ;
    BIT(int n){
      this.n=n ;
      data=new int[n+1];
    }
    void add(int i){
      for(; i<=n ; i+=i &(-i))data[i]++;
    }
    int get(int i){
      int res=0 ;
      for(; i>0 ; i-=i &(-i))res+=data[i];
      return res ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(double) ; a := Integer.subrange(1,n)->collect(0.0) ;
    var tmp : Sequence(double) ; tmp := Integer.subrange(1,n)->collect(0.0) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() - k ; 
     if (i /= 0) then (     a[i+1] := a[i+1]+(a[i - 1+1]) ) else skip ; 
     tmp[i+1] := a[i+1] ; 
     if (tmp[i+1] >= 0) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    tmp := tmp->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := -(tmp->indexOf(a[i+1] + 0.1) - 1) )  ;     i := i + 1 ) ; 
    var b : BIT ; b := BIT.newBIT(n + 1) ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans+(b->at(a[i+1]->oclAsType(int)+1)) ; 
     b->excludes(a[i+1]->oclAsType(int)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class BIT {
   attribute n : int;
   attribute data : Sequence(int);
   static operation newBIT( n : int) : BIT
  pre: true
  post: true
  activity:
  ( var self : BIT ;
    self := createBIT();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     self.n := n ; 
     data := Integer.subrange(1,n + 1)->collect(0) );
   operation add( i : int) : void
  pre: true
  post: true
  activity: (       while i <= n do (     data[i+1] := data[i+1] + 1 ;  ;     i := i+(MathLib.bitwiseAnd(i,(-i))) ) );
   operation get( i : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
       while i > 0 do (     res := res+(data[i+1]) ;  ;     i := i-(MathLib.bitwiseAnd(i,(-i))) ) ; 
     return res );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static long[] bit ;
  static int len ;
  static void add(int x,long y){
    while(x<=len){
      bit[x]+=y ;
      x+=x &(-x);
    }
  }
  static long sum(int x){
    long tmp=0L ;
    while(x>0){
      tmp+=bit[x];
      x-=x &(-x);
    }
    return tmp ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextInt();
      a[i]-=K ;
    }
    long[] ruiseki=new long[N+1];
    TreeSet<Long>set=new TreeSet<Long>();
    set.add(0L);
    for(int i=0 ; i<N ; i++){
      ruiseki[i+1]=ruiseki[i]+a[i];
      set.add(ruiseki[i+1]);
    }
    ArrayList<Long>list=new ArrayList<Long>(set);
    int[] ruiseki_new=new int[N+1];
    for(int i=0 ; i<N+1 ; i++){
      ruiseki_new[i]=Collections.binarySearch(list,ruiseki[i])+1 ;
    }
    len=list.size();
    bit=new long[len+1];
    for(int i=0 ; i<N+1 ; i++){
      add(ruiseki_new[i],1);
    }
    long ans=0L ;
    for(int i=0 ; i<N+1 ; i++){
      add(ruiseki_new[i],-1);
      ans+=(N-i-sum(ruiseki_new[i]-1));
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute bit : Sequence(long);
  static   attribute len : int;
  static   operation add( x : int, y : long) : void
  pre: true
  post: true
  activity: (     while (x <= len) do (     bit[x+1] := bit[x+1]+(y) ; 
     x := x+(x & (-x)) ) );
  static   operation sum( x : int) : long
  pre: true
  post: true
  activity: (     var tmp : long ; tmp := 0L ;
     while (x > 0) do (     tmp := tmp+(bit[x+1]) ; 
     x := x-(x & (-x)) ) ; 
     return tmp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     a[i+1] := a[i+1]-(K) )  ;     i := i + 1 ) ; 
    var ruiseki : Sequence(long) ; ruiseki := Integer.subrange(1,N + 1)->collect(0) ;
    var set : Set(long) ; set := Set{} ;
    set := set->including(0L) ; 
        var i : int ; i := 0 ; while i < N do ( (     ruiseki[i + 1+1] := ruiseki[i+1] + a[i+1] ; 
     set := set->including(ruiseki[i + 1+1]) )  ;     i := i + 1 ) ; 
    var list : Sequence(long) ; list := Sequence{}->union(set) ;
    var ruiseki_new : Sequence(int) ; ruiseki_new := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N + 1 do ( (     ruiseki_new[i+1] := (list->indexOf(ruiseki[i+1]) - 1) + 1 )  ;     i := i + 1 ) ; 
    len := list->size() ; 
    bit := Integer.subrange(1,len + 1)->collect(0) ; 
        var i : int ; i := 0 ; while i < N + 1 do ( (     execute add(ruiseki_new[i+1], 1) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0L ;
        var i : int ; i := 0 ; while i < N + 1 do ( (     execute add(ruiseki_new[i+1], -1) ; 
     ans := ans+((N - i - sum(ruiseki_new[i+1] - 1))) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static long[] sum ;
  static int n ;
  static long tot=0 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    int K=sc.nextInt();
    sum=new long[n+1];
    for(int i=1 ; i<=n ; i++){
      sum[i]=sum[i-1]+sc.nextInt()-K ;
    }
    merge(0,n);
    System.out.println(tot);
  }
  static void merge(int left,int right){
    if(left>=right)return ;
    int mid=(left+right)/2 ;
    merge(left,mid);
    merge(mid+1,right);
    int i=left,j=mid+1,k=0 ;
    long[] temp=new long[right-left+1];
    while(i<=mid && j<=right){
      if(sum[i]<=sum[j]){
        tot+=mid-i+1 ;
        temp[k++]=sum[j++];
      }
      else temp[k++]=sum[i++];
    }
    while(i<=mid)temp[k++]=sum[i++];
    while(j<=right)temp[k++]=sum[j++];
    for(int m=0 ; m<temp.length ; m++)sum[left+m]=temp[m];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sum : Sequence(long);
  static   attribute n : int;
  static   attribute tot : long := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    var K : int ; K := sc.getCurrent()->toInteger() ;
    sum := Integer.subrange(1,n + 1)->collect(0) ; 
        var i : int ; i := 1 ; while i <= n do ( (     sum[i+1] := sum[i - 1+1] + sc.getCurrent()->toInteger() - K )  ;     i := i + 1 ) ; 
    execute merge(0, n) ; 
    OclFile["System.out"].println(tot) ; 
 );
  static   operation merge( left : int, right : int) : void
  pre: true
  post: true
  activity: (     if (left >= right) then     return else skip ; 
     var mid : int ; mid := (left + right) / 2 ;
    execute merge(left, mid) ; 
    execute merge(mid + 1, right) ; 
    var i : int ; i := left ;
    var j : int ; j := mid + 1 ;
    var k : int ; k := 0 ;
    var temp : Sequence(long) ; temp := Integer.subrange(1,right - left + 1)->collect(0) ;
    while (i <= mid & j <= right) do (     if (sum[i+1] <= sum[j+1]) then (     tot := tot+(mid - i + 1) ; 
       temp[k+1] := sum[j+1]  ; k := k + 1  ; j := j + 1 ) else       temp[k+1] := sum[i+1]  ; k := k + 1  ; i := i + 1 ; ) ; 
    while (i <= mid) do       temp[k+1] := sum[i+1]  ; k := k + 1  ; i := i + 1 ; ; 
    while (j <= right) do       temp[k+1] := sum[j+1]  ; k := k + 1  ; j := j + 1 ; ; 
        var m : int ; m := 0 ; while m < temp->size() do (     sum[left + m+1] := temp[m+1] ;  ;     m := m + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class kString1000 {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    String str=sc.next();
    HashMap<Character,Integer>hmap=new HashMap<>();
    for(int i=0 ; i<str.length(); i++){
      char ch=str.charAt(i);
      hmap.put(ch,hmap.getOrDefault(ch,0)+1);
    }
    StringBuilder sb=new StringBuilder();
    boolean isPossible=true ;
    for(Character ch : hmap.keySet()){
      int freq=hmap.get(ch);
      if(freq % k!=0){
        isPossible=false ;
        break ;
      }
      else {
        int numberOfTimes=freq/k ;
        while(numberOfTimes>0){
          sb.append(ch);
          numberOfTimes--;
        }
      }
    }
    if(isPossible==false)System.out.println("-1");
    else {
      String res=sb.toString();
      while(k>1){
        sb.append(res);
        k--;
      }
      System.out.println(sb.toString());
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class kString1000 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var str : String ; str := sc.getCurrent() ;
    var hmap : Map(String,int) ; hmap := Map{} ;
        var i : int ; i := 0 ; while i < str->size() do ( (     var ch : String ; ch := str->at(i+1) ;
     hmap := hmap->union(Map{ch |-> (if hmap->keys()->contains(ch) then hmap->at(ch) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    var isPossible : boolean ; isPossible := true ;
    for (ch : hmap->keys()) do ( (     var freq : int ; freq := hmap->at(ch) ;
     if (freq mod k /= 0) then (     isPossible := false ; 
     break ) else (     var numberOfTimes : int ; numberOfTimes := freq / k ;
     while (numberOfTimes > 0) do (     sb := sb + StringLib.newString(ch) ; 
     numberOfTimes := numberOfTimes - 1 ) ) )  ) ; 
    if (isPossible = false) then     OclFile["System.out"].println("-1") else (     var res : String ; res := sb+"" ;
     while (k > 1) do (     sb := sb + StringLib.newString(res) ; 
     k := k - 1 ) ; 
     OclFile["System.out"].println(sb+"") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class qus {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int k=in.nextInt();
    String str=in.next();
    HashMap<Character,Integer>map=new HashMap();
    for(int i=0 ; i<str.length(); i++){
      map.put(str.charAt(i),map.getOrDefault(str.charAt(i),0)+1);
    }
    String ans="" ;
    int count=0 ;
    for(Character c : map.keySet()){
      if(map.get(c)% k!=0){
        System.out.println("-1");
        return ;
      }
      else {
        count=map.get(c)/k ;
        while(count>0){
          ans+=c ;
          count--;
        }
      }
    }
    String s=ans ;
    k=k-1 ;
    while(k>0){
      ans+=s ;
      k--;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class qus {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var str : String ; str := in.getCurrent() ;
    var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < str->size() do ( (     map := map->union(Map{str->at(i+1) |-> (if map->keys()->contains(str->at(i+1)) then map->at(str->at(i+1)) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "" ;
    var count : int ; count := 0 ;
    for (c : map->keys()) do ( (     if (map->at(c) mod k /= 0) then (     OclFile["System.out"].println("-1") ; 
     return ) else (     count := map->at(c) / k ; 
     while (count > 0) do (     ans := ans+(c) ; 
     count := count - 1 ) ) )  ) ; 
    var s : String ; s := ans ;
    k := k - 1 ; 
    while (k > 0) do (     ans := ans+(s) ; 
     k := k - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Code {
  public static void main(String args[]){
    Scanner r=new Scanner(System.in);
    String ans="" ;
    int n=r.nextInt();
    String s=r.next();
    int a[]=new int[26];
    for(int i=0 ; i<s.length(); i++){
      a[s.charAt(i)-'a']++;
    }
    for(int i=0 ; i<26 ; i++){
      if(a[i] % n!=0){
        System.out.println("-1");
        return ;
      }
    }
    for(int i=0 ; i<26 ; i++){
      for(int j=0 ; j<a[i]/n ; j++)ans=ans+(char)(i+97);
    }
    for(int i=0 ; i<n ; i++)System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ans : String ; ans := "" ;
    var n : int ; n := r.getCurrent()->toInteger() ;
    var s : String ; s := r.getCurrent() ;
    var a : Sequence(int) ; a := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     a[s->at(i+1) - ('a')->char2byte()+1] := a[s->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 26 do ( (     if (a[i+1] mod n /= 0) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 26 do ( (         var j : int ; j := 0 ; while j < a[i+1] / n do (     ans := ans + (i + 97)->oclAsType(String) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(ans) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int compareStrings(String str1,String str2){
    int i=0 ;
    while(i<str1.length()-1 && str1.charAt(i)==str2.charAt(i))i++;
    if(str1.charAt(i)>str2.charAt(i))return-1 ;
    if(str1.charAt(i)<str2.charAt(i))return 1 ;
    else return 0 ;
  }
  static int searchStr(String[] arr,String str,int first,int last){
    if(first>last)return-1 ;
    int mid=(last+first)/2 ;
    if(arr[mid] .isEmpty()){
      int left=mid-1 ;
      int right=mid+1 ;
      while(true){
        if(left<right && right>last)return-1 ;
        if(right<=last && ! arr[right] .isEmpty()){
          mid=right ;
          break ;
        }
        if(left>=right && ! arr[left] .isEmpty()){
          mid=left ;
          break ;
        }
        right++;
        left--;
      }
    }
    if(compareStrings(str,arr[mid])==0)return mid ;
    if(compareStrings(str,arr[mid])<0)return searchStr(arr,str,mid+1,last);
    return searchStr(arr,str,first,mid-1);
  }
  public static void main(String[] args){
    String[] arr={
      "for","","","","geeks","ide","","practice","","","quiz","","" };
      String str="quiz" ;
      int n=arr.length ;
      System.out.println(searchStr(arr,str,0,n-1));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation compareStrings( str1 : String, str2 : String) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     while (i < str1->size() - 1 & str1->at(i+1) = str2->at(i+1)) do     i := i + 1 ; ; 
     if (str1->at(i+1) > str2->at(i+1)) then     return -1 else skip ; 
     if (str1->at(i+1) < str2->at(i+1)) then     return 1 else     return 0 );
  static   operation searchStr( arr : Sequence(String), str : String, first : int, last : int) : int
  pre: true
  post: true
  activity: (     if (first > last) then     return -1 else skip ; 
     var mid : int ; mid := (last + first) / 2 ;
    if (arr[mid+1]->isEmpty()) then (     var left : int ; left := mid - 1 ;
     var right : int ; right := mid + 1 ;
     while (true) do (     if (left < right & right > last) then     return -1 else skip ; 
     if (right <= last & not(arr[right+1]->isEmpty())) then (     mid := right ; 
     break ) else skip ; 
    if (left >= right & not(arr[left+1]->isEmpty())) then (     mid := left ; 
     break ) else skip ; 
    right := right + 1 ; 
    left := left - 1 ; 
 ) ) else skip ; 
    if (compareStrings(str, arr[mid+1]) = 0) then     return mid else skip ; 
    if (compareStrings(str, arr[mid+1]) < 0) then     return searchStr(arr, str, mid + 1, last) else skip ; 
    return searchStr(arr, str, first, mid - 1) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"for","","","","geeks","ide","","practice","","","quiz","",""} ;
     var str : String ; str := "quiz" ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(searchStr(arr, str, 0, (n)->char2byte() - 1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import sun.java2d.pipe.OutlineTextRenderer ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class B {
  private static final int MAX=20000 ;
  private String solve(Scanner in){
    int n=in.nextInt();
    if(n==0){
      return "0" ;
    }
    int[] a=new int[MAX];
    for(int i=0 ; i<n ; i++){
      a[in.nextInt()-1]++;
    }
    int l=1 ;
    int r=n+1 ;
    main : while(r>l+1){
      int m=(l+r)/2 ;
      int[] aa=a.clone();
      int[] b=new int[MAX+1];
      for(int i=0 ; i<MAX ; i++){
        while(aa[i]>0){
          if(i>0 && b[i-1]>0){
            b[i-1]--;
            b[i]++;
            aa[i]--;
          }
          else {
            boolean ok=true ;
            for(int j=i ; j<i+m ; j++){
              if(aa[j]==0)ok=false ;
              aa[j]--;
            }
            if(! ok){
              r=m ;
              continue main ;
            }
            b[i+m-1]++;
          }
        }
      }
      l=m ;
    }
    return ""+l ;
  }
  public static void main(String[] args)throws FileNotFoundException {
    Scanner in=new Scanner(new File("input.txt"));
    PrintWriter out=new PrintWriter("output.txt");
    int T=in.nextInt();
    for(int i=0 ; i<T ; i++){
      String s="Case #"+(i+1)+": "+new B().solve(in);
      out.println(s);
      System.out.println(s);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static    attribute MAX : int := 20000;
   operation solve( in : OclFile) : String
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     if (n = 0) then (     return "0" ) else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,MAX)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[in.nextInt() - 1+1] := a[in.nextInt() - 1+1] + 1 )  ;     i := i + 1 ) ; 
    var l : int ; l := 1 ;
    var r : int ; r := n + 1 ;
    while (r > l + 1) do (     var m : int ; m := (l + r) / 2 ;
     var aa : Sequence(int) ; aa := a->copy() ;
    var b : Sequence(int) ; b := Integer.subrange(1,MAX + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < MAX do ( (     while (aa[i+1] > 0) do (     if (i > 0 & b[i - 1+1] > 0) then (     b[i - 1+1] := b[i - 1+1] - 1 ; 
     b[i+1] := b[i+1] + 1 ; 
     aa[i+1] := aa[i+1] - 1 ) else (     var ok : boolean ; ok := true ;
         var j : int ; j := i ; while j < i + m do ( (     if (aa[j+1] = 0) then     ok := false ; else skip ; 
     aa[j+1] := aa[j+1] - 1 )  ;     j := j + 1 ) ; 
     if (not(ok)) then (     r := m ; 
     continue ) else skip ; 
     b[i + m - 1+1] := b[i + m - 1+1] + 1 ) ) )  ;     i := i + 1 ) ; 
    l := m ; 
 ) ; 
    return "" + l 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("input.txt")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < T do ( (     var s : String ; s := "Case #" + (i + 1) + ": " + B.newB().solve(in) ;
     skip ; 
     OclFile["System.out"].println(s) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printPattern(int radius){
    double dist ;
    for(int i=0 ; i<=2*radius ; i++){
      for(int j=0 ; j<=2*radius ; j++){
        dist=Math.sqrt((i-radius)*(i-radius)+(j-radius)*(j-radius));
        if(dist>radius-0.5 && dist<radius+0.5)System.out.print("*");
        else System.out.print(" ");
      }
      System.out.print("\n");
    }
  }
  public static void main(String[] args){
    int radius=6 ;
    printPattern(radius);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printPattern( radius : int) : void
  pre: true
  post: true
  activity: (     var dist : double ;
         var i : int ; i := 0 ; while i <= 2 * radius do ( (         var j : int ; j := 0 ; while j <= 2 * radius do ( (     dist := ((i - radius) * (i - radius) + (j - radius) * (j - radius))->sqrt() ; 
     if (dist > radius - 0.5 & dist < radius + 0.5) then     OclFile["System.out"].print("*") ; else     OclFile["System.out"].print(" ") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var radius : int ; radius := 6 ;
     execute printPattern(radius) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int N=sc.nextInt();
    int[] p=new int[N];
    for(int i=0 ; i<N ; i++)p[i]=sc.nextInt();
    int ans=0 ;
    for(int i=0 ; i<N-2 ; i++){
      if(p[i]<p[i+1] && p[i+1]<p[i+2] || p[i+2]<p[i+1] && p[i+1]<p[i])ans++;
    }
    out.println(ans);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     p[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < N - 2 do ( (     if (p[i+1] < p[i + 1+1] & p[i + 1+1] < p[i + 2+1] or p[i + 2+1] < p[i + 1+1] & p[i + 1+1] < p[i+1]) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int N=sc.nextInt();
    int[] arr=new int[N];
    for(int i=0 ; i<N ; i++){
      arr[i]=sc.nextInt();
    }
    int counter=0 ;
    for(int i=1 ; i<N-1 ; i++){
      if(check(arr[i-1],arr[i],arr[i+1]))counter++;
    }
    System.out.println(counter);
  }
  static boolean check(int a,int b,int c){
    if(a>b && b>c)return true ;
    if(c>b && b>a)return true ;
    return false ;
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var N : int ; N := sc.nextInt() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    var counter : int ; counter := 0 ;
        var i : int ; i := 1 ; while i < N - 1 do ( (     if (check(arr[i - 1+1], arr[i+1], arr[i + 1+1])) then     counter := counter + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
  static   operation check( a : int, b : int, c : int) : boolean
  pre: true
  post: true
  activity: (     if (a > b & b > c) then     return true else skip ; 
     if (c > b & b > a) then     return true else skip ; 
     return false );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public Main(){
  }
  public static void main(String[] args){
    Map<Integer,Integer>mapP=new HashMap<Integer,Integer>();
    Scanner sc=new Scanner(System.in);
    int n,p,p1,p0,p2,result ;
    int index ;
    n=sc.nextInt();
    for(index=0 ; index<n ; index++){
      p=sc.nextInt();
      mapP.put(index,p);
    }
    sc.close();
    result=0 ;
    for(index=1 ; index<n-1 ; index++){
      p0=mapP.get(index-1);
      p1=mapP.get(index);
      p2=mapP.get(index+1);
      if((p0-p1)*(p2-p1)<0){
        result=result+1 ;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mapP : Map(int,int) ; mapP := Map{} ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ;
    var p : int ;
    var p1 : int ;
    var p0 : int ;
    var p2 : int ;
    var result : int ;
    var index : int ;
    n := sc.getCurrent()->toInteger() ; 
        index := 0 ; while index < n do ( (     p := sc.getCurrent()->toInteger() ; 
     mapP := mapP->union(Map{index |-> p}) )  ;     index := index + 1 ) ; 
    skip ; 
    result := 0 ; 
        index := 1 ; while index < n - 1 do ( (     p0 := mapP->at(index - 1) ; 
     p1 := mapP->at(index) ; 
     p2 := mapP->at(index + 1) ; 
     if ((p0 - p1) * (p2 - p1) < 0) then (     result := result + 1 ) else skip )  ;     index := index + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int total=Integer.parseInt(sc.next());
    List<Integer>list=new ArrayList<>();
    for(int x=1 ; x<=total ; x++){
      list.add(Integer.parseInt(sc.next()));
    }
    int res=0 ;
    for(int x=1 ; x<=total-2 ; x++){
      int first=list.get(x-1);
      int second=list.get(x);
      int third=list.get(x+1);
      if(first<second && second<third){
        res++;
      }
      if(second<first && third<second){
        res++;
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var total : int ; total := (sc.getCurrent())->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var x : int ; x := 1 ; while x <= total do ( (     list := list->including((sc.getCurrent())->toInteger()) )  ;     x := x + 1 ) ; 
    var res : int ; res := 0 ;
        var x : int ; x := 1 ; while x <= total - 2 do ( (     var first : int ; first := list->at(x - 1+1) ;
     var second : int ; second := list->at(x+1) ;
    var third : int ; third := list->at(x + 1+1) ;
    if (first < second & second < third) then (     res := res + 1 ) else skip ; 
    if (second < first & third < second) then (     res := res + 1 ) else skip ; 
 )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Objects ;
import java.util.Scanner ;
import java.util.StringJoiner ;
import java.util.stream.Stream ;
public class Main {
  public static void main(final String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    long u=sc.nextLong();
    long[] p=new long[(int)u];
    for(int i=0 ; i<p.length ; i++){
      p[i]=sc.nextLong();
    }
    int cnt=0 ;
    for(int i=1 ; i<p.length-1 ; i++){
      long[] tmp=Arrays.copyOfRange(p,i-1,i+2);
      Arrays.sort(tmp);
      if(tmp[1]==p[i])cnt++;
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var u : long ; u := sc.getCurrent()->toLong() ;
    var p : Sequence(long) ; p := Integer.subrange(1,u->oclAsType(int))->collect(0) ;
        var i : int ; i := 0 ; while i < p->size() do ( (     p[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 1 ; while i < p->size() - 1 do ( (     var tmp : Sequence(long) ; tmp := p.subrange(i - 1+1,i + 2) ;
     tmp := tmp->sort() ; 
     if (tmp[1+1] = p[i+1]) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Ehabandsubtraction {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int length=sc.nextInt();
    int op=sc.nextInt();
    int arr[]=new int[length+1];
    arr[0]=sc.nextInt();
    for(int i=1 ; i<length ; i++){
      arr[i]=sc.nextInt();
    }
    arr[length]=0 ;
    Arrays.sort(arr);
    for(int i=1 ; i<=length ; i++){
      if(op==0){
        break ;
      }
      if(arr[i]-arr[i-1]!=0){
        op--;
        System.out.println(arr[i]-arr[i-1]);
      }
    }
    while(op>0){
      System.out.println("0");
      op--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ehabandsubtraction {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var length : int ; length := sc.getCurrent()->toInteger() ;
    var op : int ; op := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,length + 1)->collect(0) ;
    arr[0+1] := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i < length do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr[length+1] := 0 ; 
    arr := arr->sort() ; 
        var i : int ; i := 1 ; while i <= length do ( (     if (op = 0) then (     break ) else skip ; 
     if (arr[i+1] - arr[i - 1+1] /= 0) then (     op := op - 1 ; 
     OclFile["System.out"].println(arr[i+1] - arr[i - 1+1]) ) else skip )  ;     i := i + 1 ) ; 
    while (op > 0) do (     OclFile["System.out"].println("0") ; 
     op := op - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
public class GFG {
  static List<Integer>factors=new ArrayList<>(10);
  static void findFactors(int n){
    for(int i=1 ; i*i<=n ; i++){
      if(n % i==0){
        if((n/i)==i){
          factors.add(factors.size(),i);
        }
        else {
          factors.add(factors.size(),n/i);
          factors.add(factors.size(),i);
        }
      }
    }
  }
  static int findProduct(int n){
    int product=-1 ;
    int si=factors.size();
    for(int i=0 ; i<si ; i++){
      for(int j=0 ; j<si ; j++){
        for(int k=0 ; k<si ; k++){
          for(int l=0 ; l<si ; l++){
            int s=factors.get(i)+factors.get(j)+factors.get(k)+factors.get(l);
            if(s==n){
              int p=factors.get(i)*factors.get(j)*factors.get(k)*factors.get(l);
              if(p>product){
                product=p ;
              }
            }
          }
        }
      }
    }
    return product ;
  }
  public static void main(String[] args){
    int n=10 ;
    findFactors(n);
    System.out.println(findProduct(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute factors : Sequence(int) := Sequence{};
  static   operation findFactors( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     if ((n / i) = i) then (     factors := factors.insertAt(factors->size()+1,i) ) else (     factors := factors.insertAt(factors->size()+1,n / i) ; 
     factors := factors.insertAt(factors->size()+1,i) ) ) else skip )  ;     i := i + 1 ) );
  static   operation findProduct( n : int) : int
  pre: true
  post: true
  activity: (     var product : int ; product := -1 ;
     var si : int ; si := factors->size() ;
         var i : int ; i := 0 ; while i < si do ( (         var j : int ; j := 0 ; while j < si do ( (         var k : int ; k := 0 ; while k < si do ( (         var l : int ; l := 0 ; while l < si do ( (     var s : int ; s := factors->at(i+1) + factors->at(j+1) + factors->at(k+1) + factors->at(l+1) ;
     if (s = n) then (     var p : int ; p := factors->at(i+1) * factors->at(j+1) * factors->at(k+1) * factors->at(l+1) ;
     if (p > product) then (     product := p ) else skip ) else skip )  ;     l := l + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return product );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     execute findFactors(n) ; 
     OclFile["System.out"].println(findProduct(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int sum=0 ;
    for(int i=0 ; i<5 ; i++)sum+=sc.nextInt();
    if(sum % 5==0 && sum!=0)sum/=5 ;
    else sum=-1 ;
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 5 do (     sum := sum+(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    if (sum mod 5 = 0 & sum /= 0) then     sum := sum/(5) else     sum := -1 ; ;  
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int a=scan.nextInt();
    int b=scan.nextInt();
    int ans=getNum(a,b);
    System.out.println(ans);
  }
  public static int getNum(int a,int b){
    int reverseB=0 ;
    while(b>0){
      reverseB=reverseB*10+b % 10 ;
      b/=10 ;
    }
    return a+reverseB ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    var ans : int ; ans := getNum(a, b) ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation getNum( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var reverseB : int ; reverseB := 0 ;
     while (b > 0) do (     reverseB := reverseB * 10 + b mod 10 ; 
     b := b/(10) ) ; 
     return a + reverseB );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Initialbet {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int sum=0 ;
    for(int i=0 ; i<5 ; i++)sum+=sc.nextInt();
    System.out.println(sum % 5==0 && sum!=0 ? sum/5 :-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Initialbet {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < 5 do (     sum := sum+(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if sum mod 5 = 0 & sum /= 0 then sum / 5 else -1 endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class GreatSequence {
  private static Scanner s=new Scanner(System.in);
  private static void solve(){
    int n=s.nextInt();
    long x=s.nextLong();
    Map<Long,Integer>countMap=new HashMap<>();
    long[] arr=new long[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=s.nextLong();
      if(countMap.containsKey(arr[i])){
        countMap.put(arr[i],countMap.get(arr[i])+1);
      }
      else {
        countMap.put(arr[i],1);
      }
    }
    Arrays.sort(arr);
    for(int i=0 ; i<n ; i++){
      if(countMap.containsKey(arr[i])&& countMap.get(arr[i])>0){
        long temp=arr[i]*x ;
        if(countMap.containsKey(temp)&& countMap.get(temp)>0){
          countMap.put(arr[i],countMap.get(arr[i])-1);
          countMap.put(temp,countMap.get(temp)-1);
        }
      }
    }
    int ans=0 ;
    for(Long key : countMap.keySet()){
      ans+=countMap.get(key);
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    int t=s.nextInt();
    while(t-->0){
      solve();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GreatSequence {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := s.getCurrent()->toInteger() ;
     var x : long ; x := s.getCurrent()->toLong() ;
    var countMap : Map(long,int) ; countMap := Map{} ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toLong() ; 
     if (countMap->keys()->includes(arr[i+1])) then (     countMap := countMap->union(Map{arr[i+1] |-> countMap->at(arr[i+1]) + 1}) ) else (     countMap := countMap->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (countMap->keys()->includes(arr[i+1]) & countMap->at(arr[i+1]) > 0) then (     var temp : long ; temp := arr[i+1] * x ;
     if (countMap->keys()->includes(temp) & countMap->at(temp) > 0) then (     countMap := countMap->union(Map{arr[i+1] |-> countMap->at(arr[i+1]) - 1}) ; 
     countMap := countMap->union(Map{temp |-> countMap->at(temp) - 1}) ) else skip ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (key : countMap->keys()) do ( (     ans := ans+(countMap->at(key)) )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class InitialBet {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    byte c1=s.nextByte();
    byte c2=s.nextByte();
    byte c3=s.nextByte();
    byte c4=s.nextByte();
    byte c5=s.nextByte();
    int total=c1+c2+c3+c4+c5 ;
    if(total==0)System.out.println("-1");
    else {
      double b1=total/5.0 ;
      int b2=total/5 ;
      if(b1==b2)System.out.println(b2);
      else System.out.println("-1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class InitialBet {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c1 : int ; c1 := s.nextByte() ;
    var c2 : int ; c2 := s.nextByte() ;
    var c3 : int ; c3 := s.nextByte() ;
    var c4 : int ; c4 := s.nextByte() ;
    var c5 : int ; c5 := s.nextByte() ;
    var total : int ; total := c1 + c2 + c3 + c4 + c5 ;
    if (total = 0) then     OclFile["System.out"].println("-1") else (     var b1 : double ; b1 := total / 5.0 ;
     var b2 : int ; b2 := total / 5 ;
     if (b1 = b2) then     OclFile["System.out"].println(b2) ; else     OclFile["System.out"].println("-1") ; ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication83 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int counter=0 ;
    for(int i=0 ; i<5 ; i++){
      counter+=sc.nextInt();
    }
    if(counter % 5==0 && counter>=5){
      System.out.println(counter/5);
    }
    else {
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication83 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var counter : int ; counter := 0 ;
         var i : int ; i := 0 ; while i < 5 do ( (     counter := counter+(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
     if (counter mod 5 = 0 & counter >= 5) then (     OclFile["System.out"].println(counter / 5) ) else (     OclFile["System.out"].println(-1) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float Area(float a){
    if(a<0)return-1 ;
    float x=0.464f*a ;
    float A=0.70477f*(float)Math.pow(x,2);
    return A ;
  }
  public static void main(String[] args){
    float a=5 ;
    System.out.println(String.format("%.5f",Area(a)));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Area( a : double) : double
  pre: true
  post: true
  activity: (     if (a < 0) then     return -1 else skip ; 
     var x : double ; x := 0.464f * a ;
     var A : double ; A := 0.70477f * x->pow(2)->oclAsType(double) ;
     return A );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 5 ;
     OclFile["System.out"].println(StringLib.format("%.5f",Sequence{Area(a)})) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.LinkedList ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.Vector ;
public class Domnio {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    if(isPalindrome(s)&& isReflectable(s)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
  public static boolean isPalindrome(String s){
    for(int i=0 ; i<s.length()/2 ; i++){
      if(s.charAt(i)!=s.charAt(s.length()-1-i)){
        return false ;
      }
    }
    return true ;
  }
  public static boolean isReflectable(String s){
    for(int i=0 ; i<s.length(); i++){
      if("AHIMOTUVWXY".indexOf(s.charAt(i))==-1){
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Domnio {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
     if (isPalindrome(s) & isReflectable(s)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
  static   operation isPalindrome( s : String) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() / 2 do ( (     if (s->at(i+1) /= s->at(s->size() - 1 - (i)->char2byte()+1)) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation isReflectable( s : String) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() do ( (     if ("AHIMOTUVWXY"->indexOf(s->at(i+1))-1 = -1) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class StartUp {
  public static void main(String[] args){
    Scanner x=new Scanner(System.in);
    String a=x.nextLine();
    int m=0 ;
    int n=a.length()-1 ;
    int y=0 ;
    int r=0 ;
    int u=0 ;
    int j=0 ;
    for(int i=1 ; i<=a.length(); i++){
      if(a.charAt(r)=='A' || a.charAt(r)=='H' || a.charAt(r)=='I' || a.charAt(r)=='M' || a.charAt(r)=='O' || a.charAt(r)=='T' || a.charAt(r)=='U' || a.charAt(r)=='V' || a.charAt(r)=='W' || a.charAt(r)=='X' || a.charAt(r)=='Y'){
        m++;
      }
      else {
        break ;
      }
      r++;
    }
    if(m==a.length()){
      while(y<=n){
        if(a.charAt(y)==a.charAt(n))u=1 ;
        else {
          u=0 ;
          break ;
        }
        y++;
        n--;
      }
    }
    if(u==1)System.out.println("YES");
    else if(u==0)System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class StartUp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : OclFile ; x := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := x.nextLine() ;
    var m : int ; m := 0 ;
    var n : int ; n := a->size() - 1 ;
    var y : int ; y := 0 ;
    var r : int ; r := 0 ;
    var u : int ; u := 0 ;
    var j : int ; j := 0 ;
        var i : int ; i := 1 ; while i <= a->size() do ( (     if (a->at(r+1) = 'A' or a->at(r+1) = 'H' or a->at(r+1) = 'I' or a->at(r+1) = 'M' or a->at(r+1) = 'O' or a->at(r+1) = 'T' or a->at(r+1) = 'U' or a->at(r+1) = 'V' or a->at(r+1) = 'W' or a->at(r+1) = 'X' or a->at(r+1) = 'Y') then (     m := m + 1 ) else (     break ) ;  
     r := r + 1 )  ;     i := i + 1 ) ; 
    if (m = a->size()) then (     while (y <= n) do (     if (a->at(y+1) = a->at(n+1)) then     u := 1 else (     u := 0 ; 
     break ) ;  
     y := y + 1 ; 
     n := n - 1 ) ) else skip ; 
    if (u = 1) then     OclFile["System.out"].println("YES") else     if (u = 0) then     OclFile["System.out"].println("NO") ; else skip ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TaskA {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String name=sc.nextLine();
    int toCheck=name.length()% 2==0 ? name.length()/2 : name.length()/2+1 ;
    for(int i=0 ; i<toCheck ; i++){
      char c=name.charAt(i);
      char m=name.charAt(name.length()-1-i);
      if(c!=m || ! sym(c)|| ! sym(m)){
        System.out.println("NO");
        return ;
      }
    }
    System.out.println("YES");
    return ;
  }
  public static boolean sym(char c){
    switch(c){
      case 'A' : return true ;
      case 'H' : return true ;
      case 'I' : return true ;
      case 'M' : return true ;
      case 'O' : return true ;
      case 'T' : return true ;
      case 'U' : return true ;
      case 'V' : return true ;
      case 'W' : return true ;
      case 'X' : return true ;
      case 'Y' : return true ;
      default : return false ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TaskA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var name : String ; name := sc.nextLine() ;
    var toCheck : int ; toCheck := if name->size() mod 2 = 0 then name->size() / 2 else name->size() / 2 + 1 endif ;
        var i : int ; i := 0 ; while i < toCheck do ( (     var c : String ; c := name->at(i+1) ;
     var m : String ; m := name->at(name->size() - 1 - i+1) ;
     if (c /= m or not(sym(c)) or not(sym(m))) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
    return 
 );
  static   operation sym( c : String) : boolean
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
       if _switchval = 'A' then
     return true 
   else skip ;
       if _switchval = 'H' then
     return true 
   else skip ;
       if _switchval = 'I' then
     return true 
   else skip ;
       if _switchval = 'M' then
     return true 
   else skip ;
       if _switchval = 'O' then
     return true 
   else skip ;
       if _switchval = 'T' then
     return true 
   else skip ;
       if _switchval = 'U' then
     return true 
   else skip ;
       if _switchval = 'V' then
     return true 
   else skip ;
       if _switchval = 'W' then
     return true 
   else skip ;
       if _switchval = 'X' then
     return true 
   else skip ;
       if _switchval = 'Y' then
     return true 
   else skip ;
       if true then
     return false 
   else skip ;
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int M=scanner.nextInt();
    Bottle[] bottles=new Bottle[N];
    for(int i=0 ; i<N ; i++)bottles[i]=new Bottle(scanner.nextInt(),scanner.nextInt());
    Arrays.sort(bottles,Comparator.comparingInt(bottle->bottle.price));
    long left=-1 ;
    long right=100_000_000_000_000L ;
    while(right-left>1){
      long mid=(left+right)/2 ;
      long k=mid ;
      int n=0 ;
      for(int i=0 ; i<N ; i++){
        if((long)bottles[i] .price*bottles[i] .cap<k){
          n+=bottles[i] .cap ;
          k-=(long)bottles[i] .price*bottles[i] .cap ;
        }
        else {
          n+=k/bottles[i] .price ;
          break ;
        }
      }
      if(n>=M){
        right=mid ;
      }
      else {
        left=mid ;
      }
    }
    System.out.println(right);
  }
  private static class Bottle {
    private final int price ;
    private final int cap ;
    private Bottle(int price,int cap){
      this.price=price ;
      this.cap=cap ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var M : int ; M := scanner.getCurrent()->toInteger() ;
    var bottles : Sequence(Bottle) ; bottles := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do (     bottles[i+1] := Bottle.newBottle(scanner.getCurrent()->toInteger(), scanner.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    bottles := OclComparator.sortWith(bottles, Comparator.comparingInt(lambda bottle : OclAny in bottle.price)) ; 
    var left : long ; left := -1 ;
    var right : long ; right := 100_000_000_000_000L ;
    while (right - left > 1) do (     var mid : long ; mid := (left + right) / 2 ;
     var k : long ; k := mid ;
    var n : int ; n := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (bottles[i+1].price->oclAsType(long) * bottles[i+1].cap < k) then (     n := n+(bottles[i+1].cap) ; 
     k := k-(bottles[i+1].price->oclAsType(long) * bottles[i+1].cap) ) else (     n := n+(k / bottles[i+1].price) ; 
     break ) )  ;     i := i + 1 ) ; 
    if (n >= M) then (     right := mid ) else (     left := mid ) ;  
 ) ; 
    OclFile["System.out"].println(right) ; 
 );
  static class Bottle {
   attribute price : int;
   attribute cap : int;
   static operation newBottle( price : int, cap : int) : Bottle
  pre: true
  post: true
  activity:
  ( var self : Bottle ;
    self := createBottle();
    self.initialise(price, cap);
    return self );
  operation initialise( price : int, cap : int) : void
  pre: true  post: true
  activity: (     self.price := price ; 
     self.cap := cap );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Map.Entry ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long m=sc.nextInt();
    TreeMap<Long,Integer>map=new TreeMap<>();
    for(int i=0 ; i<n ; i++){
      long key=sc.nextLong();
      int val=sc.nextInt();
      if(map.containsKey(key)){
        map.put(key,map.get(key)+val);
      }
      else {
        map.put(key,val);
      }
    }
    long ans=0l ;
    for(Entry<Long,Integer>entry : map.entrySet()){
      long key=entry.getKey();
      int val=entry.getValue();
      if(m>=val){
        ans+=key*val ;
        m=m-val ;
      }
      else if(m<val){
        ans+=m*key ;
        break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : long ; m := sc.getCurrent()->toInteger() ;
    var map : Map(long,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var key : long ; key := sc.getCurrent()->toLong() ;
     var val : int ; val := sc.getCurrent()->toInteger() ;
     if (map->keys()->includes(key)) then (     map := map->union(Map{key |-> map->at(key) + val}) ) else (     map := map->union(Map{key |-> val}) ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0l ;
    for (entry : map->asSet()) do ( (     var key : long ; key := entry.getKey() ;
     var val : int ; val := entry.getValue() ;
     if (m >= val) then (     ans := ans+(key * val) ; 
     m := m - val ) else     if (m < val) then (     ans := ans+(m * key) ; 
     break ) else skip ; )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Solution171A {
  public static void main(String[] args){
    InputReader in=new InputReader(System.in);
    PrintWriter out=new PrintWriter(System.out);
    Solver171A solver=new Solver171A();
    solver.solve(0,in,out);
    out.close();
  }
  static class Solver171A {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      long a1=in.nextInt(),a2=in.nextInt();
      long res=0 ;
      while(a2>0){
        res*=10 ;
        res+=(a2 % 10);
        a2/=10 ;
      }
      res+=a1 ;
      out.println(res);
    }
    public boolean check(int r,int g,int b,int w){
      int odd=0 ;
      if(r % 2==1){
        odd++;
      }
      if(g % 2==1){
        odd++;
      }
      if(b % 2==1){
        odd++;
      }
      if(w % 2==1){
        odd++;
      }
      if(odd<=1){
        return true ;
      }
      return false ;
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution171A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : InputReader ; in := InputReader.newInputReader(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var solver : Solver171A ; solver := Solver171A.newSolver171A() ;
    solver.solve(0, in, out) ; 
    skip ; 
 );
  static class Solver171A {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a1 : long ; a1 := in.nextInt() ;
    var a2 : long ; a2 := in.nextInt() ;
     var res : long ; res := 0 ;
    while (a2 > 0) do (     res := res*(10) ; 
     res := res+((a2 mod 10)) ; 
     a2 := a2/(10) ) ; 
    res := res+(a1) ; 
    skip ; 
 );
   operation check( r : int, g : int, b : int, w : int) : boolean
  pre: true
  post: true
  activity: (     var odd : int ; odd := 0 ;
     if (r mod 2 = 1) then (     odd := odd + 1 ) else skip ; 
    if (g mod 2 = 1) then (     odd := odd + 1 ) else skip ; 
    if (b mod 2 = 1) then (     odd := odd + 1 ) else skip ; 
    if (w mod 2 = 1) then (     odd := odd + 1 ) else skip ; 
    if (odd <= 1) then (     return true ) else skip ; 
    return false 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long m=sc.nextLong();
    long ans=0 ;
    long[][] ab=new long[n][2];
    for(int c=0 ; c<n ; c++){
      ab[c][0]=sc.nextLong();
      ab[c][1]=sc.nextLong();
    }
    Arrays.sort(ab,(a,b)->Long.compare(a[0],b[0]));
    long count=0 ;
    int c=0 ;
    while(count<m){
      if(ab[c][1]>0){
        ans+=ab[c][0];
        ab[c][1]--;
      }
      else {
        ans+=ab[c+1][0];
        ab[c+1][1]--;
        c++;
      }
      count++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : long ; m := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
    var ab : Sequence(Sequence(long)) ; ab := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var c : int ; c := 0 ; while c < n do ( (     ab[c+1][0+1] := sc.getCurrent()->toLong() ; 
     ab[c+1][1+1] := sc.getCurrent()->toLong() )  ;     c := c + 1 ) ; 
    ab := OclComparator.sortWith(ab, lambda (a , b) : OclAny in compare(a[0+1], b[0+1])) ; 
    var count : long ; count := 0 ;
    var c : int ; c := 0 ;
    while (count < m) do (     if (ab[c+1][1+1] > 0) then (     ans := ans+(ab[c+1][0+1]) ; 
     ab[c+1][1+1] := ab[c+1][1+1] - 1 ) else (     ans := ans+(ab[c + 1+1][0+1]) ; 
     ab[c + 1+1][1+1] := ab[c + 1+1][1+1] - 1 ; 
     c := c + 1 ) ;  
     count := count + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    ArrayList<KeySort>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      long a=sc.nextLong();
      int b=sc.nextInt();
      list.add(new KeySort(b,a));
    }
    Collections.sort(list,new KeySortComparator());
    long money=0 ;
    for(int i=0 ; i<n ; i++){
      if(list.get(i).key<=m){
        money+=list.get(i).key*list.get(i).sort ;
        m-=list.get(i).key ;
      }
      else {
        money+=m*list.get(i).sort ;
        break ;
      }
    }
    System.out.println(money);
  }
}
class KeySort {
  public int key ;
  public long sort ;
  public KeySort(int key,long sort){
    this.key=key ;
    this.sort=sort ;
  }
}
class KeySortComparator implements Comparator<KeySort>{
  @ Override public int compare(KeySort sort1,KeySort sort2){
    if(sort1.sort==sort2.sort){
      return 0 ;
    }
    else if(sort1.sort>sort2.sort){
      return 1 ;
    }
    else {
      return-1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var list : Sequence(KeySort) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     list := list->including(KeySort.newKeySort(b, a)) )  ;     i := i + 1 ) ; 
    list, KeySortComparator.newKeySortComparator() := list, KeySortComparator.newKeySortComparator()->sort() ; 
    var money : long ; money := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (list->at(i+1).key <= m) then (     money := money+(list->at(i+1).key * list->at(i+1).sort) ; 
     m := m-(list->at(i+1).key) ) else (     money := money+(m * list->at(i+1).sort) ; 
     break ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(money) ; 
 );
}
class KeySort {
   attribute key : int;
   attribute sort : long;
   static operation newKeySort( key : int, sort : long) : KeySort
  pre: true
  post: true
  activity:
  ( var self : KeySort ;
    self := createKeySort();
    self.initialise(key, sort);
    return self );
  operation initialise( key : int, sort : long) : void
  pre: true  post: true
  activity: (     self.key := key ; 
     self.sort := sort );
}
class KeySortComparator implements Function(<KeySort>,(<KeySort>,boolean)) {
      operation compare( sort1 : KeySort, sort2 : KeySort) : int
  pre: true
  post: true
  activity: (     if (sort1.sort = sort2.sort) then (     return 0 ) else     if (sort1.sort > sort2.sort) then (     return 1 ) else (     return -1 ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner m=new Scanner(System.in);
    int t ;
    t=m.nextInt();
    while(t-->0){
      int n ;
      int x ;
      n=m.nextInt();
      x=m.nextInt();
      long[] arr=new long[n];
      for(int i=0 ; i<n ; ++i)arr[i]=m.nextLong();
      Arrays.sort(arr);
      HashMap<Long,Integer>hm=new HashMap<>();
      int cnt=0 ;
      for(int i=n-1 ; i>-1 ; i--){
        if(hm.containsKey(x*arr[i]*1l)==true){
          if(hm.get(arr[i]*x*1l)==1)hm.remove(x*arr[i]*1l);
          else hm.put(arr[i]*x*1l,hm.get(arr[i]*x*1l)-1);
          cnt+=2 ;
        }
        else {
          if(hm.containsKey(arr[i]*1l))hm.put(arr[i]*1l,hm.get(arr[i]*1l)+1);
          else hm.put(arr[i]*1l,1);
        }
      }
      System.out.println(n-cnt);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : OclFile ; m := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ;
     t := m.getCurrent()->toInteger() ; 
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ;
     var x : int ;
    n := m.getCurrent()->toInteger() ; 
    x := m.getCurrent()->toInteger() ; 
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := m.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var hm : Map(long,int) ; hm := Map{} ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := n - 1 ; while i > -1 do ( (     if (hm->keys()->includes(x * arr[i+1] * 1l) = true) then (     if (hm->at(arr[i+1] * x * 1l) = 1) then     hm := hm->antirestrict(Set{x * arr[i+1] * 1l}) else     hm := hm->union(Map{arr[i+1] * x * 1l |-> hm->at(arr[i+1] * x * 1l) - 1}) ; ;  
     cnt := cnt+(2) ) else (     if (hm->keys()->includes(arr[i+1] * 1l)) then     hm := hm->union(Map{arr[i+1] * 1l |-> hm->at(arr[i+1] * 1l) + 1}) ; else     hm := hm->union(Map{arr[i+1] * 1l |-> 1}) ; ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(n - cnt) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int m=Integer.parseInt(sc.next());
    int[][] ab=new int[n][2];
    for(int i=0 ; i<n ; i++){
      ab[i][0]=Integer.parseInt(sc.next());
      ab[i][1]=Integer.parseInt(sc.next());
    }
    Arrays.sort(ab,new Comparator<int[]>(){
      @ Override public int compare(int[] o1,int[] o2){
        return o1[0]-o2[0];
      }
    }
);
    int remain=m ;
    long res=0 ;
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(remain==0)break ;
      count=Math.min(remain,ab[i][1]);
      res+=(long)count*ab[i][0];
      remain-=count ;
    }
    System.out.println(res);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var m : int ; m := (sc.getCurrent())->toInteger() ;
    var ab : Sequence(Sequence(int)) ; ab := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     ab[i+1][0+1] := (sc.getCurrent())->toInteger() ; 
     ab[i+1][1+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    ab := OclComparator.sortWith(ab, OclComparator<Sequence(int)>.newOclComparator()) ; 
    var remain : int ; remain := m ;
    var res : long ; res := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (remain = 0) then     break else skip ; 
     count := Set{remain, ab[i+1][1+1]}->min() ; 
     res := res+(count->oclAsType(long) * ab[i+1][0+1]) ; 
     remain := remain-(count) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class BinaryTree {
  Node root ;
  static class Node {
    int val ;
    Node left,right ;
    Node(int v){
      val=v ;
      left=null ;
      right=null ;
    }
  }
  BinaryTree(Node r){
    root=r ;
  }
  BinaryTree(){
  }
  public boolean isSymmetric(Node root){
    Queue<Node>q=new LinkedList<Node>();
    q.add(root.left);
    q.add(root.right);
    while(! q.isEmpty()){
      Node tempLeft=q.remove();
      Node tempRight=q.remove();
      if(tempLeft==null && tempRight==null)continue ;
      if((tempLeft==null && tempRight!=null)||(tempLeft!=null && tempRight==null))return false ;
      if(tempLeft.val!=tempRight.val)return 0 ;
      q.add(tempLeft.left);
      q.add(tempRight.right);
      q.add(tempLeft.right);
      q.add(tempRight.left);
    }
    return true ;
  }
  public static void main(String[] args){
    Node n=new Node(1);
    BinaryTree bt=new BinaryTree(n);
    bt.root.left=new Node(2);
    bt.root.right=new Node(2);
    bt.root.left.left=new Node(3);
    bt.root.left.right=new Node(4);
    bt.root.right.left=new Node(4);
    bt.root.right.right=new Node(3);
    if(bt.isSymmetric(bt.root))System.out.println("The given tree is Symmetric");
    else System.out.println("The given tree is not Symmetric");
  }
}
------------------------------------------------------------
OCL File:
---------
 class BinaryTree {
   attribute root : Node;
  static class Node {
   attribute val : int;
   attribute left : Node;
   static operation newNode( v : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(v);
    return self );
  operation initialise( v : int) : void
  pre: true  post: true
  activity: (     val := v ; 
     left := null ; 
     right := null );
}
   static operation newBinaryTree( r : Node) : BinaryTree
  pre: true
  post: true
  activity:
  ( var self : BinaryTree ;
    self := createBinaryTree();
    self.initialise(r);
    return self );
  operation initialise( r : Node) : void
  pre: true  post: true
  activity: (     root := r );
   static operation newBinaryTree() : BinaryTree
  pre: true
  post: true
  activity:
  ( var self : BinaryTree ;
    self := createBinaryTree();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   operation isSymmetric( root : Node) : boolean
  pre: true
  post: true
  activity: (     var q : Sequence(Node) ; q := Sequence{} ;
     q := q->including(root.left) ; 
    q := q->including(root.right) ; 
    while (not(q->isEmpty())) do (     var tempLeft : Node ; tempLeft := q.remove() ;
     var tempRight : Node ; tempRight := q.remove() ;
    if (tempLeft = null & tempRight = null) then     continue else skip ; 
    if ((tempLeft = null & tempRight /= null) or (tempLeft /= null & tempRight = null)) then     return false else skip ; 
    if (tempLeft.val /= tempRight.val) then     return 0 else skip ; 
    q := q->including(tempLeft.left) ; 
    q := q->including(tempRight.right) ; 
    q := q->including(tempLeft.right) ; 
    q := q->including(tempRight.left) ; 
 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : Node ; n := Node.newNode(1) ;
     var bt : BinaryTree ; bt := BinaryTree.newBinaryTree(n) ;
    bt.root.left := Node.newNode(2) ; 
    bt.root.right := Node.newNode(2) ; 
    bt.root.left.left := Node.newNode(3) ; 
    bt.root.left.right := Node.newNode(4) ; 
    bt.root.right.left := Node.newNode(4) ; 
    bt.root.right.right := Node.newNode(3) ; 
    if (bt.isSymmetric(bt.root)) then     OclFile["System.out"].println("The given tree is Symmetric") else     OclFile["System.out"].println("The given tree is not Symmetric") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Similar_strings {
  static int countManipulations(String s1,String s2){
    int count=0 ;
    int char_count[]=new int[26];
    for(int i=0 ; i<s1.length(); i++)char_count[s1.charAt(i)-'a']++;
    for(int i=0 ; i<s2.length(); i++)if(char_count[s2.charAt(i)-'a']--<=0)count++;
    return count ;
  }
  public static void main(String[] args){
    String s1="ddcf" ;
    String s2="cedk" ;
    System.out.println(countManipulations(s1,s2));
  }
}
------------------------------------------------------------
OCL File:
---------
class Similar_strings {
  static   operation countManipulations( s1 : String, s2 : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var char_count : Sequence(int) ; char_count := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < s1->size() do (     char_count[s1->at(i+1) - ('a')->char2byte()+1] := char_count[s1->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < s2->size() do (     if (char_count[s2->at(i+1) - ('a')->char2byte()+1] <= 0) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "ddcf" ;
     var s2 : String ; s2 := "cedk" ;
     OclFile["System.out"].println(countManipulations(s1, s2)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    for(int i=0 ; i<t ; i++){
      int x=scanner.nextInt();
      int y=scanner.nextInt();
      if(x==0 && y==0){
        System.out.println(0);
      }
      else if(x==0 || y==0){
        System.out.println(1);
      }
      else {
        int temp=(int)Math.sqrt(x*x+y*y);
        if(temp*temp==x*x+y*y){
          System.out.println(1);
        }
        else {
          System.out.println(2);
        }
      }
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var x : int ; x := scanner.getCurrent()->toInteger() ;
     var y : int ; y := scanner.getCurrent()->toInteger() ;
     if (x = 0 & y = 0) then (     OclFile["System.out"].println(0) ) else     if (x = 0 or y = 0) then (     OclFile["System.out"].println(1) ) else (     var temp : int ; temp := (x * x + y * y)->sqrt()->oclAsType(int) ;
     if (temp * temp = x * x + y * y) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(2) ) ) ;  )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      double x=sc.nextDouble();
      double y=sc.nextDouble();
      if((int)x==0 &&(int)y==0){
        System.out.println(0);
        continue ;
      }
      double sqrt=Math.sqrt(Math.pow(x,2)+Math.pow(y,2));
      if(sqrt==(int)sqrt)System.out.println(1);
      else System.out.println(2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x : double ; x := sc.getCurrent()->toReal() ;
     var y : double ; y := sc.getCurrent()->toReal() ;
    if (x->oclAsType(int) = 0 & y->oclAsType(int) = 0) then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
    var sqrt : double ; sqrt := (x->pow(2) + y->pow(2))->sqrt() ;
    if (sqrt = sqrt->oclAsType(int)) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println(2) ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      double x=sc.nextDouble();
      double y=sc.nextDouble();
      if((int)x==0 &&(int)y==0){
        System.out.println(0);
        continue ;
      }
      double sqrt=Math.sqrt(Math.pow(x,2)+Math.pow(y,2));
      if(sqrt==(int)sqrt)System.out.println(1);
      else System.out.println(2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x : double ; x := sc.getCurrent()->toReal() ;
     var y : double ; y := sc.getCurrent()->toReal() ;
    if (x->oclAsType(int) = 0 & y->oclAsType(int) = 0) then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
    var sqrt : double ; sqrt := (x->pow(2) + y->pow(2))->sqrt() ;
    if (sqrt = sqrt->oclAsType(int)) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println(2) ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
import static java.lang.Double.parseDouble ;
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
public class Main {
  static BufferedWriter of=null ;
  static {
    try {
      of=new BufferedWriter(new FileWriter(new File("filee.txt")));
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  private static BufferedWriter ifile=null ;
  static {
    try {
      ifile=new BufferedWriter(new FileWriter(String.valueOf(System.in)));
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  private static final BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
  private static final Fast in=new Fast();
  public static void main(String[] args)throws IOException {
    int n=in.nextInt();
    while(n>0){
      int m1=in.nextInt();
      int m2=in.nextInt();
      if(m1==0 && m2==0)System.out.println("0");
      else if(Math.sqrt((m1*m1)+(m2*m2))-(int)Math.sqrt((m1*m1)+(m2*m2))==0)System.out.println("1");
      else System.out.println("2");
      n--;
    }
  }
  public static class Fast {
    BufferedReader br ;
    StringTokenizer st ;
    public Fast(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public Fast(FileReader f){
      br=new BufferedReader(f);
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return parseInt(next());
    }
    public long nextLong()throws IOException {
      return parseLong(next());
    }
    public double nextDouble()throws IOException {
      return parseDouble(next());
    }
    public float nextFloat()throws IOException {
      return Float.parseFloat(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute of : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     try (     of := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile("filee.txt"))) )   catch (e : IOException) do (     e.printStackTrace() )
;
  static   attribute ifile : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     try (     ifile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(((OclFile["System.in"]) + ""))) )   catch (e : IOException) do (     e.printStackTrace() )
;
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static    attribute in : Fast := Fast.newFast();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     while (n > 0) do (     var m1 : int ; m1 := in.nextInt() ;
     var m2 : int ; m2 := in.nextInt() ;
     if (m1 = 0 & m2 = 0) then     OclFile["System.out"].println("0") else     if (((m1 * m1) + (m2 * m2))->sqrt() - ((m1 * m1) + (m2 * m2))->sqrt()->oclAsType(int) = 0) then     OclFile["System.out"].println("1") else     OclFile["System.out"].println("2") ; ;  ;  
     n := n - 1 ) );
  static class Fast {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFast() : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   static operation newFast( f : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(f) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next() + "")->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return parseDouble(next()) );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findNumberOfEvenCells(int n,int q[][],int size){
    int row[]=new int[n];
    int col[]=new int[n];
    for(int i=0 ; i<size ; i++){
      int x=q[i][0];
      int y=q[i][1];
      row[x-1]++;
      col[y-1]++;
    }
    int r1=0,r2=0 ;
    int c1=0,c2=0 ;
    for(int i=0 ; i<n ; i++){
      if(row[i] % 2==0){
        r1++;
      }
      if(row[i] % 2==1){
        r2++;
      }
      if(col[i] % 2==0){
        c1++;
      }
      if(col[i] % 2==1){
        c2++;
      }
    }
    int count=r1*c1+r2*c2 ;
    return count ;
  }
  public static void main(String[] args){
    int n=2 ;
    int q[][]={
      {
        1,1 },{
          1,2 },{
            2,1 }
          };
          int size=q.length ;
          System.out.println(findNumberOfEvenCells(n,q,size));
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNumberOfEvenCells( n : int, q : Sequence(Sequence(int)), size : int) : int
  pre: true
  post: true
  activity: (     var row : Sequence(int) ; row := Integer.subrange(1,n)->collect(0) ;
     var col : Sequence(int) ; col := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < size do ( (     var x : int ; x := q[i+1][0+1] ;
     var y : int ; y := q[i+1][1+1] ;
     row[x - 1+1] := row[x - 1+1] + 1 ; 
     col[y - 1+1] := col[y - 1+1] + 1 )  ;     i := i + 1 ) ; 
    var r1 : int ; r1 := 0 ;
    var r2 : int ; r2 := 0 ;
    var c1 : int ; c1 := 0 ;
    var c2 : int ; c2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (row[i+1] mod 2 = 0) then (     r1 := r1 + 1 ) else skip ; 
     if (row[i+1] mod 2 = 1) then (     r2 := r2 + 1 ) else skip ; 
     if (col[i+1] mod 2 = 0) then (     c1 := c1 + 1 ) else skip ; 
     if (col[i+1] mod 2 = 1) then (     c2 := c2 + 1 ) else skip )  ;     i := i + 1 ) ; 
    var count : int ; count := r1 * c1 + r2 * c2 ;
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     var q : Sequence(Sequence(int)) ; q := Sequence{Sequence{1,1},Sequence{1,2},Sequence{2,1}} ;
     var size : int ; size := q->size() ;
     OclFile["System.out"].println(findNumberOfEvenCells(n, q, size)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findLength(int[] arr,int n){
    int x=0 ;
    for(int i=0 ; i<n ; i++)x=Math.max(x,arr[i]);
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]!=x)continue ;
      int j=i ;
      while(arr[j]==x){
        j++;
        if(j>=n)break ;
      }
      ans=Math.max(ans,j-i);
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,2 };
      int n=arr.length ;
      System.out.println(findLength(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findLength( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := 0 ;
         var i : int ; i := 0 ; while i < n do (     x := Set{x, arr[i+1]}->max() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] /= x) then     continue else skip ; 
     var j : int ; j := i ;
     while (arr[j+1] = x) do (     j := j + 1 ; 
     if (j >= n) then     break else skip ) ; 
     ans := Set{ans, j - i}->max() )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findLength(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int arr[]=new int[] {
    1,2,2,4 };
    static int countIncreasing(int n){
      int cnt=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=i+1 ; j<n ; j++){
          if(arr[j]>arr[j-1])cnt++;
          else break ;
        }
      }
      return cnt ;
    }
    public static void main(String[] args){
      System.out.println("Count of strictly increasing subarrays is "+countIncreasing(arr.length));
    }
  }

------------------------------------------------------------
OCL File:
---------
class Test {
  static   attribute arr : int := Sequence{1,2,2,4};
  static   operation countIncreasing( n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (arr[j+1] > arr[j - 1+1]) then     cnt := cnt + 1 ; else     break )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Count of strictly increasing subarrays is " + countIncreasing(arr->size())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class Node {
    int data ;
    Node next ;
  };
  static Node head ;
  static void push(Node head_ref,int new_data){
    Node new_node=new Node();
    new_node.data=new_data ;
    new_node.next=head_ref ;
    head_ref=new_node ;
    head=head_ref ;
  }
  static void uniqueElements(Node head){
    HashMap<Integer,Integer>hash=new HashMap<Integer,Integer>();
    for(Node temp=head ; temp!=null ; temp=temp.next){
      if(hash.containsKey(temp.data)){
        hash.put(temp.data,hash.get(temp.data)+1);
      }
      else {
        hash.put(temp.data,1);
      }
    }
    int count=0 ;
    for(Node temp=head ; temp!=null ; temp=temp.next){
      if(hash.get(temp.data)==1){
        System.out.print(temp.data+" ");
        count++;
      }
    }
    if(count==0)System.out.print(" No Unique Elements ");
  }
  public static void main(String[] args){
    head=null ;
    push(head,5);
    push(head,4);
    push(head,3);
    push(head,5);
    push(head,3);
    push(head,2);
    push(head,4);
    push(head,4);
    push(head,1);
    uniqueElements(head);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   attribute head : Node;
  static   operation push( head_ref : Node, new_data : int) : void
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode() ;
     new_node.data := new_data ; 
    new_node.next := head_ref ; 
    head_ref := new_node ; 
    head := head_ref ; 
 );
  static   operation uniqueElements( head : Node) : void
  pre: true
  post: true
  activity: (     var hash : Map(int,int) ; hash := Map{} ;
         var temp : Node ; temp := head ; while temp /= null do ( (     if (hash->keys()->includes(temp.data)) then (     hash := hash->union(Map{temp.data |-> hash->at(temp.data) + 1}) ) else (     hash := hash->union(Map{temp.data |-> 1}) ) )  ;     temp := temp.next ) ; 
    var count : int ; count := 0 ;
        var temp : Node ; temp := head ; while temp /= null do ( (     if (hash->at(temp.data) = 1) then (     OclFile["System.out"].print(temp.data + " ") ; 
     count := count + 1 ) else skip )  ;     temp := temp.next ) ; 
    if (count = 0) then     OclFile["System.out"].print(" No Unique Elements ") ; else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     head := null ; 
     execute push(head, 5) ; 
    execute push(head, 4) ; 
    execute push(head, 3) ; 
    execute push(head, 5) ; 
    execute push(head, 3) ; 
    execute push(head, 2) ; 
    execute push(head, 4) ; 
    execute push(head, 4) ; 
    execute push(head, 1) ; 
    execute uniqueElements(head) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static int min=0 ;
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      long n=sc.nextLong();
      long x=sc.nextLong();
      ArrayList<Long>arr=new ArrayList<Long>();
      HashMap<Long,Long>freq=new HashMap<Long,Long>();
      for(int j=0 ; j<n ; j++){
        long s=sc.nextLong();
        arr.add(s);
        if(freq.containsKey(s)){
          freq.put(s,freq.get(s)+1);
        }
        else {
          freq.put(s,1L);
        }
      }
      Collections.sort(arr);
      for(int k=0 ; k<arr.size(); k++){
        if(freq.get(arr.get(k))==0){
          continue ;
        }
        long multi=arr.get(k)*x ;
        if(freq.containsKey(multi)){
          if(freq.get(multi)==0){
            freq.put(arr.get(k),freq.get(arr.get(k))-1);
            min++;
            continue ;
          }
          else {
            freq.put(arr.get(k),freq.get(arr.get(k))-1);
            freq.put(multi,freq.get(multi)-1);
          }
        }
        else {
          freq.put(arr.get(k),freq.get(arr.get(k))-1);
          min++;
          continue ;
        }
      }
      System.out.println(min);
      min=0 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute min : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : long ; n := sc.getCurrent()->toLong() ;
     var x : long ; x := sc.getCurrent()->toLong() ;
    var arr : Sequence(long) ; arr := Sequence{} ;
    var freq : Map(long,long) ; freq := Map{} ;
        var j : int ; j := 0 ; while j < n do ( (     var s : long ; s := sc.getCurrent()->toLong() ;
     arr := arr->including(s) ; 
     if (freq->keys()->includes(s)) then (     freq := freq->union(Map{s |-> freq->at(s) + 1}) ) else (     freq := freq->union(Map{s |-> 1L}) ) )  ;     j := j + 1 ) ; 
    arr := arr->sort() ; 
        var k : int ; k := 0 ; while k < arr->size() do ( (     if (freq->at(arr->at(k+1)) = 0) then (     continue ) else skip ; 
     var multi : long ; multi := arr->at(k+1) * x ;
     if (freq->keys()->includes(multi)) then (     if (freq->at(multi) = 0) then (     freq := freq->union(Map{arr->at(k+1) |-> freq->at(arr->at(k+1)) - 1}) ; 
     min := min + 1 ; 
     continue ) else (     freq := freq->union(Map{arr->at(k+1) |-> freq->at(arr->at(k+1)) - 1}) ; 
     freq := freq->union(Map{multi |-> freq->at(multi) - 1}) ) ) else (     freq := freq->union(Map{arr->at(k+1) |-> freq->at(arr->at(k+1)) - 1}) ; 
     min := min + 1 ; 
     continue ) )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(min) ; 
    min := 0 ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String n=sc.next();
    if(n.contains("9")){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : String ; n := sc.getCurrent() ;
     if (n->includes("9")) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.InputMismatchException ;
import java.io.IOException ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    FastScanner in=new FastScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,FastScanner in,PrintWriter out){
      int n=in.nextInt();
      out.println(n>=90 || n % 10==9 ? "Yes" : "No");
    }
  }
  static class FastScanner {
    private InputStream in ;
    private byte[] buffer=new byte[1024];
    private int bufPointer ;
    private int bufLength ;
    public FastScanner(InputStream in){
      this.in=in ;
    }
    private int readByte(){
      if(bufPointer>=bufLength){
        if(bufLength==-1)throw new InputMismatchException();
        bufPointer=0 ;
        try {
          bufLength=in.read(buffer);
        }
        catch(IOException e){
          throw new InputMismatchException();
        }
        if(bufLength<=0)return-1 ;
      }
      return buffer[bufPointer++];
    }
    private static boolean isSpaceChar(int c){
      return c==' ' || c=='\n' || c=='\r' || c=='\t' || c==-1 ;
    }
    public long nextLong(){
      long n=0 ;
      int b=readByte();
      while(isSpaceChar(b))b=readByte();
      boolean minus=(b=='-');
      if(minus)b=readByte();
      while(b>='0' && b<='9'){
        n*=10 ;
        n+=b-'0' ;
        b=readByte();
      }
      if(! isSpaceChar(b))throw new NumberFormatException();
      return minus ?-n : n ;
    }
    public int nextInt(){
      long n=nextLong();
      if(n<Integer.MIN_VALUE || n>Integer.MAX_VALUE)throw new NumberFormatException();
      return(int)n ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : FastScanner ; in := FastScanner.newFastScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : FastScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     skip );
}
  static class FastScanner {
   attribute in : OclFile;
   attribute buffer : Sequence(int) := Integer.subrange(1,1024)->collect(0);
   attribute bufPointer : int;
   attribute bufLength : int;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     self.in := in );
   operation readByte() : int
  pre: true
  post: true
  activity: (     if (bufPointer >= bufLength) then (     if (bufLength = -1) then     error IncorrectElementException() ; else skip ; 
     bufPointer := 0 ; 
     try (     bufLength := in.read(buffer) )   catch (e : IOException) do (     error IncorrectElementException() )
     if (bufLength <= 0) then     return -1 else skip ) else skip ; 
     return buffer[bufPointer+1] );
  static   operation isSpaceChar( c : int) : boolean
  pre: true
  post: true
  activity: (     return c = ' ' or c = '
' or c = '\r' or c = '\t' or c = -1 );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     var n : long ; n := 0 ;
     var b : int ; b := readByte() ;
    while (isSpaceChar(b)) do     b := readByte() ; ; 
    var minus : boolean ; minus := (b = '-') ;
    if (minus) then     b := readByte() ; else skip ; 
    while (b >= '0' & b <= '9') do (     n := n*(10) ; 
     n := n+(b - ('0')->char2byte()) ; 
     b := readByte() ) ; 
    if (not(isSpaceChar(b))) then     error IncorrectElementException() ; else skip ; 
    return if minus then -n else n endif 
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     var n : long ; n := nextLong() ;
     if (n < -2147483648 or n > 2147483647) then     error IncorrectElementException() ; else skip ; 
     return n->oclAsType(int) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.IOException ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println((N % 10==9 || N/10==9)? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if (N mod 10 = 9 or N / 10 = 9) then "Yes" else "No" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    InputReader in=new InputReader();
    PrintWriter out=new PrintWriter(System.out);
    int test_cases=1 ;
    Solver s=new Solver();
    for(int i=1 ; i<=test_cases ; i++){
      s.solve(i,in,out);
    }
    out.close();
  }
}
class Solver {
  void solve(int test_number,InputReader in,PrintWriter out)throws IOException {
    int n=in.nextInt();
    out.println((n/10==9 || n % 10==9)? "Yes" : "No");
  }
}
class InputReader {
  BufferedReader br ;
  StringTokenizer st ;
  public InputReader(){
    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 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : InputReader ; in := InputReader.newInputReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test_cases : int ; test_cases := 1 ;
    var s : Solver ; s := Solver.newSolver() ;
        var i : int ; i := 1 ; while i <= test_cases do ( (     s.solve(i, in, out) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
class Solver {
   operation solve( test_number : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     skip );
}
class InputReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newInputReader() : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String in=br.readLine();
      String chr[]=in.split("");
      System.out.println(chr[0] .equals("9")|| chr[1] .equals("9")? "Yes" : "No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var in : String ; in := br.readLine() ;
     var chr : Sequence(String) ; chr := in->split("") ;
     OclFile["System.out"].println(if chr[0+1] = "9" or chr[1+1] = "9" then "Yes" else "No" endif) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String longDivision(String number,int divisor){
    String ans="" ;
    int idx=0 ;
    char[] num=number.toCharArray();
    int temp=num[idx]-'0' ;
    while(temp<divisor)temp=temp*10+(num[++idx]-'0');
    idx+=1 ;
    while(num.length>idx){
      ans+=(temp/divisor);
      temp=(temp % divisor)*10+num[idx++]-'0' ;
    }
    if(ans.length()==0)return "0" ;
    return ans ;
  }
  public static void main(String[] args){
    String number="1248163264128256512" ;
    int divisor=125 ;
    System.out.println(longDivision(number,divisor));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation longDivision( number : String, divisor : int) : String
  pre: true
  post: true
  activity: (     var ans : String ; ans := "" ;
     var idx : int ; idx := 0 ;
    var num : Sequence(String) ; num := number->characters() ;
    var temp : int ; temp := num[idx+1] - ('0')->char2byte() ;
    while (temp < divisor) do         idx := idx + 1 ;
 temp := temp * 10 + (num[idx+1] - ('0')->char2byte())  ; ; 
    idx := idx+(1) ; 
    while (num->size() > idx) do (     ans := ans+((temp / divisor)) ; 
      temp := (temp mod divisor) * 10 + num[idx+1] - ('0')->char2byte()  ; idx := idx + 1 ) ; 
    if (ans->size() = 0) then     return "0" else skip ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var number : String ; number := "1248163264128256512" ;
     var divisor : int ; divisor := 125 ;
     OclFile["System.out"].println(longDivision(number, divisor)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    int m=sc.nextInt();
    int t=reverse(m);
    System.out.println(t+n);
  }
  public static int reverse(int n){
    if(n<10)return n*10 ;
    int t=n,r=0 ;
    while(t>0){
      r=(r*10)+t % 10 ;
      t=t/10 ;
    }
    return r ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : int ; n := sc.nextInt() ;
    var m : int ; m := sc.nextInt() ;
    var t : int ; t := reverse(m) ;
    OclFile["System.out"].println(t + n) ; 
 );
  static   operation reverse( n : int) : int
  pre: true
  post: true
  activity: (     if (n < 10) then     return n * 10 else skip ; 
     var t : int ; t := n ;
    var r : int ; r := 0 ;
     while (t > 0) do (     r := (r * 10) + t mod 10 ; 
     t := t / 10 ) ; 
     return r );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float rhombusarea(float l,float b){
    if(l<0 || b<0)return-1 ;
    return(l*b)/2 ;
  }
  public static void main(String[] args){
    float l=16,b=6 ;
    System.out.println(rhombusarea(l,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation rhombusarea( l : double, b : double) : double
  pre: true
  post: true
  activity: (     if (l < 0 or b < 0) then     return -1 else skip ; 
     return (l * b) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : double ; l := 16 ;
    var b : double ; b := 6 ;
     OclFile["System.out"].println(rhombusarea(l, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Array_Stabilization {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Integer>l=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      l.add(sc.nextInt());
    }
    Collections.sort(l);
    int min=Collections.min(l);
    System.out.println(Math.min(l.get(n-2)-min,l.get(n-1)-l.get(1)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Array_Stabilization {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     l := l->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    l := l->sort() ; 
    var min : int ; min := .min(l) ;
    OclFile["System.out"].println(Set{l->at(n - 2+1) - min, l->at(n - 1+1) - l->at(1+1)}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B1095 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long n=scanner.nextLong();
    Set<Long>set=new HashSet<>();
    ArrayList<Long>list=new ArrayList<>();
    while(n-->0){
      long a=scanner.nextLong();
      list.add(a);
    }
    Collections.sort(list);
    System.out.println(Math.min((list.get(list.size()-1)-list.get(1)),(list.get(list.size()-2)-list.get(0))));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1095 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := scanner.getCurrent()->toLong() ;
    var set : Set(long) ; set := Set{} ;
    var list : Sequence(long) ; list := Sequence{} ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var a : long ; a := scanner.getCurrent()->toLong() ;
     list := list->including(a) ) ;  ) ;  
    list := list->sort() ; 
    OclFile["System.out"].println(Set{(list->at(list->size() - 1+1) - list->at(1+1)), (list->at(list->size() - 2+1) - list->at(0+1))}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public final class Solution {
  public static void main(String[] args)throws IOException {
    BufferedReader bi=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(bi.readLine());
    String s[]=bi.readLine().split(" ");
    Integer a[]=new Integer[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(s[i]);
    }
    Arrays.sort(a);
    System.out.println(Math.min(a[n-1]-a[1],a[n-2]-a[0]));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bi : OclFile ; bi := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (bi.readLine())->toInteger() ;
    var s : Sequence(String) ; s := bi.readLine()->split(" ") ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (s[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    OclFile["System.out"].println(Set{a[n - 1+1] - a[1+1], a[n - 2+1] - a[0+1]}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countZeros(int x){
    int y ;
    int n=32 ;
    y=x>>16 ;
    if(y!=0){
      n=n-16 ;
      x=y ;
    }
    y=x>>8 ;
    if(y!=0){
      n=n-8 ;
      x=y ;
    }
    y=x>>4 ;
    if(y!=0){
      n=n-4 ;
      x=y ;
    }
    y=x>>2 ;
    if(y!=0){
      n=n-2 ;
      x=y ;
    }
    y=x>>1 ;
    if(y!=0)return n-2 ;
    return n-x ;
  }
  public static void main(String[] args){
    int x=101 ;
    System.out.println(countZeros(x));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countZeros( x : int) : int
  pre: true
  post: true
  activity: (     var y : int ;
     var n : int ; n := 32 ;
    y := (x/(2->pow(16)))->oclAsType(long) ; 
    if (y /= 0) then (     n := n - 16 ; 
     x := y ) else skip ; 
    y := (x/(2->pow(8)))->oclAsType(long) ; 
    if (y /= 0) then (     n := n - 8 ; 
     x := y ) else skip ; 
    y := (x/(2->pow(4)))->oclAsType(long) ; 
    if (y /= 0) then (     n := n - 4 ; 
     x := y ) else skip ; 
    y := (x/(2->pow(2)))->oclAsType(long) ; 
    if (y /= 0) then (     n := n - 2 ; 
     x := y ) else skip ; 
    y := (x/(2->pow(1)))->oclAsType(long) ; 
    if (y /= 0) then     return n - 2 else skip ; 
    return n - x 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 101 ;
     OclFile["System.out"].println(countZeros(x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class vanyaAdCubes23 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int sum=0 ;
    int ht=0 ;
    int i=1 ;
    while(n!=0){
      sum+=i ;
      n-=sum ;
      if(n<0){
        break ;
      }
      i++;
      ht++;
    }
    System.out.println(ht);
  }
}
------------------------------------------------------------
OCL File:
---------
 class vanyaAdCubes23 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var ht : int ; ht := 0 ;
    var i : int ; i := 1 ;
    while (n /= 0) do (     sum := sum+(i) ; 
     n := n-(sum) ; 
    if (n < 0) then (     break ) else skip ; 
    i := i + 1 ; 
    ht := ht + 1 ; 
 ) ; 
    OclFile["System.out"].println(ht) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
class GFG {
  public static boolean possible(int n){
    if(n>3){
      int sum=(n*(n+1))/2 ;
      if(sum % 3==0){
        return true ;
      }
    }
    return false ;
  }
  public static void main(String[] args){
    int n=5 ;
    if(possible(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation possible( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n > 3) then (     var sum : int ; sum := (n * (n + 1)) / 2 ;
     if (sum mod 3 = 0) then (     return true ) else skip ) else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     if (possible(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class lll {
  public static void main(String[] args){
    FastScanner fastScanner=new FastScanner();
    int n=fastScanner.nextInt();
    ArrayList<Integer>ar=new ArrayList<>();
    while(n-->0){
      ar.add(fastScanner.nextInt());
    }
    if(n==2)System.out.println(0);
    else {
      ar.sort(Collections.reverseOrder());
      if(ar.get(1)-ar.get(ar.size()-1)>ar.get(0)-ar.get(ar.size()-2))System.out.println(ar.get(0)-ar.get(ar.size()-2));
      else System.out.println(ar.get(1)-ar.get(ar.size()-1));
    }
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(String s){
    try {
      br=new BufferedReader(new FileReader(s));
    }
    catch(FileNotFoundException e){
      e.printStackTrace();
    }
  }
  public FastScanner(){
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  String nextToken(){
    while(st==null || ! st.hasMoreElements()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
    }
    return st.nextToken();
  }
  String nextLine(){
    String str="" ;
    try {
      if(st.hasMoreTokens()){
        str=st.nextToken("\n");
      }
      else {
        str=br.readLine();
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return str ;
  }
  int nextInt(){
    return Integer.parseInt(nextToken());
  }
  long nextLong(){
    return Long.parseLong(nextToken());
  }
  double nextDouble(){
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class lll {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fastScanner : FastScanner ; fastScanner := FastScanner.newFastScanner() ;
     var n : int ; n := fastScanner.nextInt() ;
    var ar : Sequence(int) ; ar := Sequence{} ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     ar := ar->including(fastScanner.nextInt()) ) ;  ) ;  
    if (n = 2) then     OclFile["System.out"].println(0) else (     ar := ar.sort(reverseOrder()) ; 
     if (ar->at(1+1) - ar->at(ar->size() - 1+1) > ar->at(0+1) - ar->at(ar->size() - 2+1)) then     OclFile["System.out"].println(ar->at(0+1) - ar->at(ar->size() - 2+1)) ; else     OclFile["System.out"].println(ar->at(1+1) - ar->at(ar->size() - 1+1)) ; ) ;  
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
 );
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int C=sc.nextInt();
    int[] B=new int[M];
    int[][] A=new int[N][M];
    for(int i=0 ; i<M ; i++){
      B[i]=sc.nextInt();
    }
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<M ; j++){
        A[i][j]=sc.nextInt();
      }
    }
    int count=0 ;
    for(int i=0 ; i<N ; i++){
      int wa=C ;
      for(int j=0 ; j<M ; j++){
        wa+=B[j]*A[i][j];
      }
      if(wa>0){
        count++;
      }
    }
    System.out.print(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var B : Sequence(int) ; B := Integer.subrange(1,M)->collect(0) ;
    var A : Sequence(Sequence(int)) ; A := Integer.subrange(1,N)->collect(Integer.subrange(1,M)->collect(0)) ;
        var i : int ; i := 0 ; while i < M do ( (     B[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < M do ( (     A[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var wa : int ; wa := C ;
         var j : int ; j := 0 ; while j < M do ( (     wa := wa+(B[j+1] * A[i+1][j+1]) )  ;     j := j + 1 ) ; 
     if (wa > 0) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  private static void solve(){
    int n=ni();
    int m=ni();
    int c=ni();
    int b[]=na(m);
    int result=0 ;
    for(int i=0 ; i<n ; i++){
      int tmp=0 ;
      for(int j=0 ; j<m ; j++){
        tmp+=ni()*b[j];
      }
      result+=tmp+c>0 ? 1 : 0 ;
    }
    System.out.println(result);
  }
  private static Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    String debugDataPath=System.getenv("DD_PATH");
    if(debugDataPath!=null){
      try {
        scanner=new Scanner(new BufferedReader(new InputStreamReader(new FileInputStream(new File(debugDataPath)))));
      }
      catch(Exception e){
        throw new RuntimeException(e);
      }
    }
    solve();
  }
  private static StringTokenizer tokenizer=null ;
  public static String next(){
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        tokenizer=new StringTokenizer(scanner.nextLine());
      }
      catch(Exception e){
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }
  private static int ni(){
    return Integer.parseInt(next());
  }
  private static long nl(){
    return Long.parseLong(next());
  }
  private static double nd(){
    return Double.parseDouble(next());
  }
  private static int[] na(int n){
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=ni();
    return a ;
  }
  private static char[] ns(){
    return next().toCharArray();
  }
  private static long[] nal(int n){
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=nl();
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := ni() ;
     var m : int ; m := ni() ;
    var c : int ; c := ni() ;
    var b : Sequence(int) ; b := na(m) ;
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var tmp : int ; tmp := 0 ;
         var j : int ; j := 0 ; while j < m do ( (     tmp := tmp+(ni() * b[j+1]) )  ;     j := j + 1 ) ; 
     result := result+(if tmp + c > 0 then 1 else 0 endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var debugDataPath : String ; debugDataPath := OclProcess.getEnvironmentProperty("DD_PATH") ;
     if (debugDataPath /= null) then (     try (     scanner := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(debugDataPath))))) )   catch (e : ProgramException) do (     error ProgramException(e) )
 ) else skip ; 
     execute solve() );
  static   attribute tokenizer : OclIterator := null;
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(scanner.nextLine()) )   catch (e : ProgramException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
  static   operation ni() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nl() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nd() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation na( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := ni() ;  ;     i := i + 1 ) ; 
     return a );
  static   operation ns() : Sequence(String)
  pre: true
  post: true
  activity: (     return next()->characters() );
  static   operation nal( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nl() ;  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Double.parseDouble ;
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
import static java.lang.System.exit ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class A {
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  static void solve()throws Exception {
    long a=nextLong();
    long b=parseLong(new StringBuilder(next()).reverse().toString());
    out.println(a+b);
  }
  static int nextInt()throws IOException {
    return parseInt(next());
  }
  static long nextLong()throws IOException {
    return parseLong(next());
  }
  static double nextDouble()throws IOException {
    return parseDouble(next());
  }
  static String next()throws IOException {
    while(tok==null || ! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  public static void main(String[] args){
    try {
      in=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(new OutputStreamWriter(System.out));
      solve();
      in.close();
      out.close();
    }
    catch(Throwable e){
      e.printStackTrace();
      exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var a : long ; a := nextLong() ;
     var b : long ; b := parseLong(StringLib.newString(next())->reverse()+"") ;
     skip );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next() + "")->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return parseLong(next()) );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return parseDouble(next()) );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (tok = null or not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return tok.next() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
     execute exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  void solve(){
    int N=in.nextInt(),M=in.nextInt(),C=in.nextInt();
    int[] B=new int[M];
    for(int i=0 ; i<M ; i++)B[i]=in.nextInt();
    int[][] A=new int[N][M];
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<M ; j++){
        A[i][j]=in.nextInt();
      }
    }
    int ans=0 ;
    for(int i=0 ; i<N ; i++){
      int sum=C ;
      for(int j=0 ; j<M ; j++){
        sum+=A[i][j]*B[j];
      }
      if(sum>0)ans++;
    }
    out.println(ans);
  }
  public static void main(String[] args){
    in=new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
    out=new PrintWriter(System.out);
    new Main().solve();
    out.close();
  }
  static FastScanner in ;
  static PrintWriter out ;
  static class FastScanner {
    BufferedReader in ;
    StringTokenizer st ;
    public FastScanner(BufferedReader in){
      this.in=in ;
    }
    public String nextToken(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(in.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(nextToken());
    }
    public long nextLong(){
      return Long.parseLong(nextToken());
    }
    public double nextDouble(){
      return Double.parseDouble(nextToken());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.nextInt() ;
    var M : int ; M := in.nextInt() ;
    var C : int ; C := in.nextInt() ;
     var B : Sequence(int) ; B := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do (     B[i+1] := in.nextInt() ;  ;     i := i + 1 ) ; 
    var A : Sequence(Sequence(int)) ; A := Integer.subrange(1,N)->collect(Integer.subrange(1,M)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < M do ( (     A[i+1][j+1] := in.nextInt() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var sum : int ; sum := C ;
         var j : int ; j := 0 ; while j < M do ( (     sum := sum+(A[i+1][j+1] * B[j+1]) )  ;     j := j + 1 ) ; 
     if (sum > 0) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := FastScanner.newFastScanner(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     Main.newMain().solve() ; 
     out.close() );
  static   attribute in : FastScanner;
  static   attribute out : OclFile;
  static class FastScanner {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     self.in := in );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(in.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedOutputStream ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static PrintWriter out ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    out=new PrintWriter(new BufferedOutputStream(System.out));
    int n=Integer.parseInt(sc.next());
    int m=Integer.parseInt(sc.next());
    int c=Integer.parseInt(sc.next());
    ArrayList<Integer>b_list=new ArrayList<>();
    for(int i=0 ; i<m ; i++){
      b_list.add(Integer.parseInt(sc.next()));
    }
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      int sum=0 ;
      for(int j=0,a=0 ; j<m ; j++){
        a=Integer.parseInt(sc.next());
        sum+=a*b_list.get(j);
      }
      sum+=c ;
      if(sum>0){
        ans++;
      }
    }
    out.println(ans);
    sc.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var n : int ; n := (sc.getCurrent())->toInteger() ;
    var m : int ; m := (sc.getCurrent())->toInteger() ;
    var c : int ; c := (sc.getCurrent())->toInteger() ;
    var b_list : Sequence(int) ; b_list := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     b_list := b_list->including((sc.getCurrent())->toInteger()) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ;
    var a : int ; a := 0 ; while j < m do ( (     a := (sc.getCurrent())->toInteger() ; 
     sum := sum+(a * b_list->at(j+1)) )  ;     j := j + 1 ) ; 
     sum := sum+(c) ; 
     if (sum > 0) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.PriorityQueue ;
import java.util.Queue ;
public class Main {
  private static int LINE_NUMBER=0 ;
  private static int CODE_NUMBER=0 ;
  private static int BIAS=0 ;
  private static int solver(int[] coe,int[] src){
    int sum=BIAS ;
    for(int i=0 ; i<CODE_NUMBER ; i++){
      sum+=(coe[i]*src[i]);
    }
    if(sum>0){
      return 1 ;
    }
    else {
      return 0 ;
    }
  }
  public static void main(String[] args){
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(is);
    try {
      String[] inputArray=br.readLine().split(" ");
      LINE_NUMBER=Integer.parseInt(inputArray[0]);
      CODE_NUMBER=Integer.parseInt(inputArray[1]);
      BIAS=Integer.parseInt(inputArray[2]);
    }
    catch(Exception e){
      e.printStackTrace();
    }
    int[] coe=new int[CODE_NUMBER];
    int[] src=new int[CODE_NUMBER];
    int answer=0 ;
    try {
      String[] inputArray=br.readLine().split(" ");
      for(int j=0 ; j<CODE_NUMBER ; j++){
        coe[j]=Integer.parseInt(inputArray[j]);
      }
      for(int line=0 ; line<LINE_NUMBER ; line++){
        String[] srcArray=br.readLine().split(" ");
        for(int idx=0 ; idx<CODE_NUMBER ; idx++){
          src[idx]=Integer.parseInt(srcArray[idx]);
        }
        answer+=solver(coe,src);
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute LINE_NUMBER : int := 0;
  static   attribute CODE_NUMBER : int := 0;
  static   attribute BIAS : int := 0;
  static   operation solver( coe : Sequence(int), src : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := BIAS ;
         var i : int ; i := 0 ; while i < CODE_NUMBER do ( (     sum := sum+((coe[i+1] * src[i+1])) )  ;     i := i + 1 ) ; 
     if (sum > 0) then (     return 1 ) else (     return 0 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(is) ;
    try (     var inputArray : Sequence(String) ; inputArray := br.readLine()->split(" ") ;
     LINE_NUMBER := (inputArray[0+1])->toInteger() ; 
     CODE_NUMBER := (inputArray[1+1])->toInteger() ; 
     BIAS := (inputArray[2+1])->toInteger() )   catch (e : ProgramException) do (     e.printStackTrace() )
    var coe : Sequence(int) ; coe := Integer.subrange(1,CODE_NUMBER)->collect(0) ;
    var src : Sequence(int) ; src := Integer.subrange(1,CODE_NUMBER)->collect(0) ;
    var answer : int ; answer := 0 ;
    try (     var inputArray : Sequence(String) ; inputArray := br.readLine()->split(" ") ;
         var j : int ; j := 0 ; while j < CODE_NUMBER do ( (     coe[j+1] := (inputArray[j+1])->toInteger() )  ;     j := j + 1 ) ; 
         var line : int ; line := 0 ; while line < LINE_NUMBER do ( (     var srcArray : Sequence(String) ; srcArray := br.readLine()->split(" ") ;
         var idx : int ; idx := 0 ; while idx < CODE_NUMBER do ( (     src[idx+1] := (srcArray[idx+1])->toInteger() )  ;     idx := idx + 1 ) ; 
     answer := answer+(solver(coe, src)) )  ;     line := line + 1 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isVowel(char ch){
    ch=Character.toUpperCase(ch);
    return(ch=='A' || ch=='E' || ch=='I' || ch=='O' || ch=='U');
  }
  static String duplicateVowels(String str){
    int t=str.length();
    String res="" ;
    for(int i=0 ; i<t ; i++){
      if(isVowel(str.charAt(i)))res+=str.charAt(i);
      res+=str.charAt(i);
    }
    return res ;
  }
  public static void main(String[] args){
    String str="helloworld" ;
    System.out.println("Original String: "+str);
    String res=duplicateVowels(str);
    System.out.println("String with Vowels duplicated: "+res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isVowel( ch : String) : boolean
  pre: true
  post: true
  activity: (     ch := (ch + "")->toUpperCase() ; 
     return (ch = 'A' or ch = 'E' or ch = 'I' or ch = 'O' or ch = 'U') );
  static   operation duplicateVowels( str : String) : String
  pre: true
  post: true
  activity: (     var t : int ; t := str->size() ;
     var res : String ; res := "" ;
         var i : int ; i := 0 ; while i < t do ( (     if (isVowel(str->at(i+1))) then     res := res+(str->at(i+1)) ; else skip ; 
     res := res+(str->at(i+1)) )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "helloworld" ;
     OclFile["System.out"].println("Original String: " + str) ; 
     var res : String ; res := duplicateVowels(str) ;
     OclFile["System.out"].println("String with Vowels duplicated: " + res) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int mod=1000000007 ;
  static int[][] dp=new int[55][55];
  static int NoofWays(int face,int throwsVal,int sum){
    if(sum==0 && throwsVal==0){
      return 1 ;
    }
    if(sum<0 || throwsVal==0){
      return 0 ;
    }
    if(dp[throwsVal][sum]!=-1){
      return dp[throwsVal][sum];
    }
    int ans=0 ;
    for(int i=1 ; i<=face ; i++){
      ans+=NoofWays(face,throwsVal-1,sum-i);
    }
    return dp[throwsVal][sum]=ans ;
  }
  public static void main(String[] args){
    int faces=6,throwsVal=3,sum=12 ;
    for(int i=0 ; i<55 ; i++){
      for(int j=0 ; j<55 ; j++){
        dp[i][j]=-1 ;
      }
    }
    System.out.println(NoofWays(faces,throwsVal,sum));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute mod : int := 1000000007;
  static   attribute dp : Sequence(Sequence(int)) := Integer.subrange(1,55)->collect(Integer.subrange(1,55)->collect(0));
  static   operation NoofWays( face : int, throwsVal : int, sum : int) : int
  pre: true
  post: true
  activity: (     if (sum = 0 & throwsVal = 0) then (     return 1 ) else skip ; 
     if (sum < 0 or throwsVal = 0) then (     return 0 ) else skip ; 
    if (dp[throwsVal+1][sum+1] /= -1) then (     return dp[throwsVal+1][sum+1] ) else skip ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= face do ( (     ans := ans+(NoofWays(face, throwsVal - 1, sum - i)) )  ;     i := i + 1 ) ; 
    return dp[throwsVal+1][sum+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var faces : int ; faces := 6 ;
    var throwsVal : int ; throwsVal := 3 ;
    var sum : int ; sum := 12 ;
         var i : int ; i := 0 ; while i < 55 do ( (         var j : int ; j := 0 ; while j < 55 do ( (     dp[i+1][j+1] := -1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(NoofWays(faces, throwsVal, sum)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countPairsWithProdK(int arr[],int n,int k){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++)if(arr[i]*arr[j]==k)count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      1,5,3,4,2 };
      int N=arr.length ;
      int K=3 ;
      System.out.println(countPairsWithProdK(arr,N,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countPairsWithProdK( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do (     if (arr[i+1] * arr[j+1] = k) then     count := count + 1 ; else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,3,4,2} ;
     var N : int ; N := arr->size() ;
     var K : int ; K := 3 ;
     OclFile["System.out"].println(countPairsWithProdK(arr, N, K)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int CountZeroBit(int n){
    int count=0 ;
    while(n>0){
      if((n & 1)!=0)count++;
      n>>=1 ;
    }
    return count ;
  }
  static int CountORandSumEqual(int N){
    int count=CountZeroBit(N);
    return(1<<count);
  }
  public static void main(String[] args){
    int N=10 ;
    System.out.print(CountORandSumEqual(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation CountZeroBit( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     if ((n & 1) /= 0) then     count := count + 1 ; else skip ; 
     n := n/(2->pow(1)) ) ; 
     return count );
  static   operation CountORandSumEqual( N : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := CountZeroBit(N) ;
     return ((1*(2->pow(count)))->oclAsType(long)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 10 ;
     OclFile["System.out"].print(CountORandSumEqual(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void profitLoss(int N,int M){
    if(N==M)System.out.print("No Profit nor Loss");
    else {
      float result=0 ;
      result=(float)(Math.abs(N-M))/M ;
      if(N-M<0)System.out.print("Loss=-"+result*100+"%");
      else System.out.print("Profit="+result*100+"%");
    }
  }
  public static void main(String[] args){
    int N=8,M=9 ;
    profitLoss(N,M);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation profitLoss( N : int, M : int) : void
  pre: true
  post: true
  activity: (     if (N = M) then     OclFile["System.out"].print("No Profit nor Loss") ; else (     var result : double ; result := 0 ;
     result := (if N - M < 0 then -(N - M) else N - M endif)->oclAsType(double) / M ; 
     if (N - M < 0) then     OclFile["System.out"].print("Loss=-" + result * 100 + "%") ; else     OclFile["System.out"].print("Profit=" + result * 100 + "%") ; ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 8 ;
    var M : int ; M := 9 ;
     execute profitLoss(N, M) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static int cubesum(int n){
    return(n)*(n)*(2*n*n-1);
  }
  public static void main(String args[]){
    int a=4 ;
    System.out.println(cubesum(a));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation cubesum( n : int) : int
  pre: true
  post: true
  activity: (     return (n) * (n) * (2 * n * n - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 4 ;
     OclFile["System.out"].println(cubesum(a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static int cubesum(int n){
    return 2*n*n*(n+1)*(n+1);
  }
  public static void main(String args[]){
    int a=8 ;
    System.out.println(cubesum(a));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation cubesum( n : int) : int
  pre: true
  post: true
  activity: (     return 2 * n * n * (n + 1) * (n + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 8 ;
     OclFile["System.out"].println(cubesum(a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class A1133 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int x1=sc.nextInt();
    int y1=sc.nextInt();
    int x2=sc.nextInt();
    int y2=sc.nextInt();
    int x3=sc.nextInt();
    int y3=sc.nextInt();
    System.out.println("3");
    System.out.println((x1+x2-x3)+" "+(y1+y2-y3));
    System.out.println((x3+x2-x1)+" "+(y3+y2-y1));
    System.out.println((x1+x3-x2)+" "+(y1+y3-y2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1133 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : int ; x1 := sc.getCurrent()->toInteger() ;
    var y1 : int ; y1 := sc.getCurrent()->toInteger() ;
    var x2 : int ; x2 := sc.getCurrent()->toInteger() ;
    var y2 : int ; y2 := sc.getCurrent()->toInteger() ;
    var x3 : int ; x3 := sc.getCurrent()->toInteger() ;
    var y3 : int ; y3 := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println("3") ; 
    OclFile["System.out"].println((x1 + x2 - x3) + " " + (y1 + y2 - y3)) ; 
    OclFile["System.out"].println((x3 + x2 - x1) + " " + (y3 + y2 - y1)) ; 
    OclFile["System.out"].println((x1 + x3 - x2) + " " + (y1 + y3 - y2)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] arg){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int M=scanner.nextInt();
    int L=scanner.nextInt();
    int[][] E=new int[N][N];
    for(int u=0 ; u<N ; u++){
      for(int v=0 ; v<N ; v++){
        E[u][v]=(u==v ? 0 : L+1);
      }
    }
    for(int i=0 ; i<M ; i++){
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      int c=scanner.nextInt();
      E[a-1][b-1]=c ;
      E[b-1][a-1]=c ;
    }
    allpairsShortestPaths(E);
    for(int u=0 ; u<N ; u++){
      for(int v=0 ; v<N ; v++){
        E[u][v]=(E[u][v]<=L ? 1 : N+1);
      }
    }
    allpairsShortestPaths(E);
    int Q=scanner.nextInt();
    for(int i=0 ; i<Q ; i++){
      int s=scanner.nextInt();
      int t=scanner.nextInt();
      int d=E[s-1][t-1];
      System.out.println(d<N ? d-1 :-1);
    }
  }
  static void allpairsShortestPaths(int[][] D){
    int N=D.length ;
    for(int v=0 ; v<N ; v++){
      for(int a=0 ; a<N ; a++){
        for(int b=0 ; b<N ; b++){
          D[a][b]=Math.min(D[a][b],D[a][v]+D[v][b]);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var M : int ; M := scanner.getCurrent()->toInteger() ;
    var L : int ; L := scanner.getCurrent()->toInteger() ;
    var E : Sequence(Sequence(int)) ; E := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
        var u : int ; u := 0 ; while u < N do ( (         var v : int ; v := 0 ; while v < N do ( (     E[u+1][v+1] := (if u = v then 0 else L + 1 endif) )  ;     v := v + 1 ) )  ;     u := u + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    E[a - 1+1][b - 1+1] := c ; 
    E[b - 1+1][a - 1+1] := c ; 
 )  ;     i := i + 1 ) ; 
    execute allpairsShortestPaths(E) ; 
        var u : int ; u := 0 ; while u < N do ( (         var v : int ; v := 0 ; while v < N do ( (     E[u+1][v+1] := (if E[u+1][v+1] <= L then 1 else N + 1 endif) )  ;     v := v + 1 ) )  ;     u := u + 1 ) ; 
    execute allpairsShortestPaths(E) ; 
    var Q : int ; Q := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < Q do ( (     var s : int ; s := scanner.getCurrent()->toInteger() ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
     var d : int ; d := E[s - 1+1][t - 1+1] ;
     OclFile["System.out"].println(if d < N then d - 1 else -1 endif) )  ;     i := i + 1 ) ; 
 );
  static   operation allpairsShortestPaths( D : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var N : int ; N := D->size() ;
         var v : int ; v := 0 ; while v < N do ( (         var a : int ; a := 0 ; while a < N do ( (         var b : int ; b := 0 ; while b < N do ( (     D[a+1][b+1] := Set{D[a+1][b+1], D[a+1][v+1] + D[v+1][b+1]}->min() )  ;     b := b + 1 ) )  ;     a := a + 1 ) )  ;     v := v + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxPartition(String s){
    int n=s.length(),P=0 ;
    String current="",previous="" ;
    for(int i=0 ; i<n ; i++){
      current+=s.charAt(i);
      if(! current.equals(previous)){
        previous=current ;
        current="" ;
        P++;
      }
    }
    return P ;
  }
  public static void main(String[] args){
    String s="geeksforgeeks" ;
    int ans=maxPartition(s);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxPartition( s : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
    var P : int ; P := 0 ;
     var current : String ; current := "" ;
    var previous : String ; previous := "" ;
         var i : int ; i := 0 ; while i < n do ( (     current := current+(s->at(i+1)) ; 
     if (not(current = previous)) then (     previous := current ; 
     current := "" ; 
     P := P + 1 ) else skip )  ;     i := i + 1 ) ; 
     return P );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     var ans : int ; ans := maxPartition(s) ;
     OclFile["System.out"].println(ans) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TripForMeal {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int min=Math.min(a,Math.min(b,c));
    if(min==a || min==b || n==1)System.out.println(min*(n-1));
    else System.out.println(Math.min(a,b)+c*(n-2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class TripForMeal {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var min : int ; min := Set{a, Set{b, c}->min()}->min() ;
    if (min = a or min = b or n = 1) then     OclFile["System.out"].println(min * (n - 1)) else     OclFile["System.out"].println(Set{a, b}->min() + c * (n - 2)) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem876A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int cost=0 ;
    int[] a=new int[3];
    for(int i=0 ; i<3 ; ++i){
      a[i]=sc.nextInt();
    }
    if(n>1){
      cost=Math.min(a[0],a[1]);
    }
    if(n>2){
      cost+=Math.min(cost,a[2])*(n-2);
    }
    System.out.println(cost);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem876A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var cost : int ; cost := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (n > 1) then (     cost := Set{a[0+1], a[1+1]}->min() ) else skip ; 
    if (n > 2) then (     cost := cost+(Set{cost, a[2+1]}->min() * (n - 2)) ) else skip ; 
    OclFile["System.out"].println(cost) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sumOfFactors(int n){
    int sum=0 ;
    for(int f=1 ; f<=n/2 ; f++){
      if(n % f==0){
        sum+=f ;
      }
    }
    return sum ;
  }
  static int getSum(int[] arr,int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]>0 && arr[i]==sumOfFactors(arr[i])){
        sum+=arr[i];
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int[] arr={
      17,6,10,6,4 };
      int n=arr.length ;
      System.out.print(getSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumOfFactors( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var f : int ; f := 1 ; while f <= n / 2 do ( (     if (n mod f = 0) then (     sum := sum+(f) ) else skip )  ;     f := f + 1 ) ; 
     return sum );
  static   operation getSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] > 0 & arr[i+1] = sumOfFactors(arr[i+1])) then (     sum := sum+(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{17,6,10,6,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(getSum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class fibonacci {
  static int fib(int n){
    int a=0,b=1,c ;
    if(n==0)return a ;
    for(int i=2 ; i<=n ; i++){
      c=a+b ;
      a=b ;
      b=c ;
    }
    return b ;
  }
  public static void main(String args[]){
    int n=9 ;
    System.out.println(fib(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class fibonacci {
  static   operation fib( n : int) : int
  pre: true
  post: true
  activity: (     var a : int ; a := 0 ;
    var b : int ; b := 1 ;
    var c : int ;
     if (n = 0) then     return a else skip ; 
         var i : int ; i := 2 ; while i <= n do ( (     c := a + b ; 
     a := b ; 
     b := c )  ;     i := i + 1 ) ; 
     return b );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     OclFile["System.out"].println(fib(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Codesolver {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<Integer>ar=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      ar.add(sc.nextInt());
    }
    for(int j=1 ; j<=n ; j++){
      System.out.print(ar.indexOf(j)+1+" ");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codesolver {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ar : Sequence(int) ; ar := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     ar := ar->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var j : int ; j := 1 ; while j <= n do ( (     OclFile["System.out"].print(ar->indexOf(j)-1 + 1 + " ") )  ;     j := j + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Dastan {
  static FastReader scan=new FastReader();
  static PrintWriter sout=new PrintWriter(System.out);
  public static void main(String[] something){
    Codeforces();
    sout.close();
  }
  static void Codeforces(){
    int x=scan.nextInt();
    Integer[] arr=new Integer[x];
    int[] arr1=new int[x];
    for(int i=0 ; i<x ; i++){
      int p=scan.nextInt();
      arr[i]=p ;
    }
    for(int i=0 ; i<x ; i++){
      int c=Arrays.asList(arr).indexOf(i+1)+1 ;
      arr1[i]=c ;
    }
    for(int i=0 ; i<arr1.length ; i++)System.out.print(arr1[i]+" ");
  }
  static boolean isPalindrome(String str){
    StringBuilder sb=new StringBuilder(str);
    return str.equals(sb.reverse().toString());
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Dastan {
  static   attribute scan : FastReader := FastReader.newFastReader();
  static   attribute sout : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( something : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute Codeforces() ; 
     skip );
  static   operation Codeforces() : void
  pre: true
  post: true
  activity: (     var x : int ; x := scan.nextInt() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,x)->collect(null) ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,x)->collect(0) ;
        var i : int ; i := 0 ; while i < x do ( (     var p : int ; p := scan.nextInt() ;
     arr[i+1] := p )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < x do ( (     var c : int ; c := arr->indexOf(i + 1)-1 + 1 ;
     arr1[i+1] := c )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < arr1->size() do (     OclFile["System.out"].print(arr1[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation isPalindrome( str : String) : boolean
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString(str) ;
     return str = sb->reverse()+"" );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float area(float r){
    if(r<0)return-1 ;
    float area=(float)(3.14*Math.pow(r/(2*Math.sqrt(2)),2));
    return area ;
  }
  public static void main(String[] args){
    float a=5 ;
    System.out.println(area(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation area( r : double) : double
  pre: true
  post: true
  activity: (     if (r < 0) then     return -1 else skip ; 
     var area : double ; area := (3.14 * r / (2 * (2)->sqrt())->pow(2))->oclAsType(double) ;
     return area );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 5 ;
     OclFile["System.out"].println(area(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int num=in.nextInt();
    int[] friends=new int[num];
    for(int i=1 ; i<num+1 ; i++){
      friends[in.nextInt()-1]=i ;
    }
    for(Integer friend : friends){
      out.print(friend+" ");
    }
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new FileReader("sub.in"));
      }
      catch(FileNotFoundException ex){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException ex){
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException ex){
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var num : int ; num := in.nextInt() ;
    var friends : Sequence(int) ; friends := Integer.subrange(1,num)->collect(0) ;
        var i : int ; i := 1 ; while i < num + 1 do ( (     friends[in.nextInt() - 1+1] := i )  ;     i := i + 1 ) ; 
    for (friend : friends) do ( (     skip )  ) ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("sub.in"))) )   catch (ex : FileNotFoundException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (ex : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (ex : IOException) do skip
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _749B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x1=sc.nextInt();
    int y1=sc.nextInt();
    int x2=sc.nextInt();
    int y2=sc.nextInt();
    int x3=sc.nextInt();
    int y3=sc.nextInt();
    System.out.println(3);
    System.out.println(x1+x2-x3+" "+(y1+y2-y3));
    System.out.println(x2+x3-x1+" "+(y2+y3-y1));
    System.out.println(x1+x3-x2+" "+(y1+y3-y2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class _749B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : int ; x1 := sc.getCurrent()->toInteger() ;
    var y1 : int ; y1 := sc.getCurrent()->toInteger() ;
    var x2 : int ; x2 := sc.getCurrent()->toInteger() ;
    var y2 : int ; y2 := sc.getCurrent()->toInteger() ;
    var x3 : int ; x3 := sc.getCurrent()->toInteger() ;
    var y3 : int ; y3 := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(3) ; 
    OclFile["System.out"].println(x1 + x2 - x3 + " " + (y1 + y2 - y3)) ; 
    OclFile["System.out"].println(x2 + x3 - x1 + " " + (y2 + y3 - y1)) ; 
    OclFile["System.out"].println(x1 + x3 - x2 + " " + (y1 + y3 - y2)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n+1];
    int[] ans=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      arr[i]=sc.nextInt();
      ans[arr[i] ]=i ;
    }
    for(int i=1 ; i<=n ; i++){
      System.out.print(ans[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     ans[arr[i+1]+1] := i )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].print(ans[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner Data=new Scanner(System.in);
    String str_Number=Data.nextLine();
    int NUMBER=Integer.parseInt(str_Number);
    String str_Frinds_Get=Data.nextLine();
    String Friends_Get_List[]=str_Frinds_Get.split(" ");
    int Friends_Get[]=new int[NUMBER];
    int Frinds_Gift[]=new int[NUMBER];
    for(int i=0 ; i<Friends_Get_List.length ; i++){
      Friends_Get[i]=Integer.parseInt(Friends_Get_List[i]);
    }
    for(int i=0 ; i<Friends_Get.length ; i++){
      Frinds_Gift[Friends_Get[i]-1]=i+1 ;
    }
    for(int i=0 ; i<Frinds_Gift.length ; i++){
      if(i==Frinds_Gift.length-1){
        System.out.print(Frinds_Gift[i]);
      }
      else {
        System.out.print(Frinds_Gift[i]+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Data : OclFile ; Data := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str_Number : String ; str_Number := Data.nextLine() ;
    var NUMBER : int ; NUMBER := (str_Number)->toInteger() ;
    var str_Frinds_Get : String ; str_Frinds_Get := Data.nextLine() ;
    var Friends_Get_List : Sequence(String) ; Friends_Get_List := str_Frinds_Get->split(" ") ;
    var Friends_Get : Sequence(int) ; Friends_Get := Integer.subrange(1,NUMBER)->collect(0) ;
    var Frinds_Gift : Sequence(int) ; Frinds_Gift := Integer.subrange(1,NUMBER)->collect(0) ;
        var i : int ; i := 0 ; while i < Friends_Get_List->size() do ( (     Friends_Get[i+1] := (Friends_Get_List[i+1])->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Friends_Get->size() do ( (     Frinds_Gift[Friends_Get[i+1] - 1+1] := i + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Frinds_Gift->size() do ( (     if (i = Frinds_Gift->size() - 1) then (     OclFile["System.out"].print(Frinds_Gift[i+1]) ) else (     OclFile["System.out"].print(Frinds_Gift[i+1] + " ") ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int distinctCount(int arr[],int n){
    Set<Integer>s=new HashSet<Integer>();
    for(int i=0 ; i<n ; i++)s.add(Math.abs(arr[i]));
    return s.size();
  }
  public static void main(String[] args){
    int arr[]={
-2,-1,0,1,1 };
      int n=arr.length ;
      System.out.println("Count of absolute distinct values : "+distinctCount(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation distinctCount( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
         var i : int ; i := 0 ; while i < n do (     s := s->including(if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif) ;  ;     i := i + 1 ) ; 
     return s->size() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-2,-1,0,1,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Count of absolute distinct values : " + distinctCount(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    HashMap<String,Long>h=new HashMap<>();
    for(int i=0 ; i<1<<n ; i++){
      String red="" ;
      String blue="" ;
      for(int j=0 ; j<n ; j++){
        if((i &(1<<j))>0){
          red+=s.charAt(j);
        }
        else {
          blue+=s.charAt(j);
        }
      }
      String key=red+":"+blue ;
      long tmp=h.getOrDefault(key,0L);
      h.put(key,tmp+1);
    }
    long ans=0 ;
    for(int i=0 ; i<1<<n ; i++){
      String red="" ;
      String blue="" ;
      for(int j=0 ; j<n ; j++){
        if((i &(1<<j))>0){
          red+=s.charAt(2*n-1-j);
        }
        else {
          blue+=s.charAt(2*n-1-j);
        }
      }
      String key=red+":"+blue ;
      long tmp=h.getOrDefault(key,0L);
      ans+=tmp ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var h : Map(String,long) ; h := Map{} ;
        var i : int ; i := 0 ; while i < (1*(2->pow(n)))->oclAsType(long) do ( (     var red : String ; red := "" ;
     var blue : String ; blue := "" ;
        var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd(i,((1*(2->pow(j)))->oclAsType(long)))) > 0) then (     red := red+(s->at(j+1)) ) else (     blue := blue+(s->at(j+1)) ) )  ;     j := j + 1 ) ; 
    var key : String ; key := red + ":" + blue ;
    var tmp : long ; tmp := (if h->keys()->contains(key) then h->at(key) else 0L endif) ;
    h := h->union(Map{key |-> tmp + 1}) ; 
 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < (1*(2->pow(n)))->oclAsType(long) do ( (     var red : String ; red := "" ;
     var blue : String ; blue := "" ;
        var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd(i,((1*(2->pow(j)))->oclAsType(long)))) > 0) then (     red := red+(s->at(2 * n - 1 - (j)->char2byte()+1)) ) else (     blue := blue+(s->at(2 * n - 1 - (j)->char2byte()+1)) ) )  ;     j := j + 1 ) ; 
    var key : String ; key := red + ":" + blue ;
    var tmp : long ; tmp := (if h->keys()->contains(key) then h->at(key) else 0L endif) ;
    ans := ans+(tmp) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String s=in.next();
    char[] l=new char[n];
    char[] r=new char[n];
    for(int i=0 ; i<n ; i++){
      l[i]=s.charAt(i);
      r[i]=s.charAt(2*n-1-i);
    }
    char[][] buf=new char[2][n];
    long count=0 ;
    for(int i=0 ; i<(1<<n); i++){
      int[] p=new int[2];
      for(int j=0 ; j<n ; j++){
        int k=(i>>j)& 1 ;
        buf[k][p[k]++]=l[j];
      }
      long[][] dp=new long[p[0]+1][p[1]+1];
      dp[0][0]=1 ;
      for(int x=0 ; x<=p[0]; x++){
        for(int y=0 ; y<=p[1]; y++){
          if(x<p[0] && r[x+y]==buf[0][x]){
            dp[x+1][y]+=dp[x][y];
          }
          if(y<p[1] && r[x+y]==buf[1][y]){
            dp[x][y+1]+=dp[x][y];
          }
        }
      }
      count+=dp[p[0] ][p[1] ];
    }
    System.out.println(count);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var l : Sequence(String) ; l := Integer.subrange(1,n)->collect(0) ;
    var r : Sequence(String) ; r := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     l[i+1] := s->at(i+1) ; 
     r[i+1] := s->at(2 * n - 1 - i+1) )  ;     i := i + 1 ) ; 
    var buf : Sequence(Sequence(String)) ; buf := Integer.subrange(1,2)->collect(Integer.subrange(1,n)->collect(0)) ;
    var count : long ; count := 0 ;
        var i : int ; i := 0 ; while i < ((1*(2->pow(n)))->oclAsType(long)) do ( (     var p : Sequence(int) ; p := Integer.subrange(1,2)->collect(0) ;
         var j : int ; j := 0 ; while j < n do ( (     var k : int ; k := MathLib.bitwiseAnd(((i/(2->pow(j)))->oclAsType(long)),1) ;
      buf[k+1][p[k+1]+1] := l[j+1]  ; p[k+1] := p[k+1] + 1 )  ;     j := j + 1 ) ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,p[0+1] + 1)->collect(Integer.subrange(1,p[1+1] + 1)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var x : int ; x := 0 ; while x <= p[0+1] do ( (         var y : int ; y := 0 ; while y <= p[1+1] do ( (     if (x < p[0+1] & r[x + y+1] = buf[0+1][x+1]) then (     dp[x + 1+1][y+1] := dp[x + 1+1][y+1]+(dp[x+1][y+1]) ) else skip ; 
     if (y < p[1+1] & r[x + y+1] = buf[1+1][y+1]) then (     dp[x+1][y + 1+1] := dp[x+1][y + 1+1]+(dp[x+1][y+1]) ) else skip )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
    count := count+(dp[p[0+1]+1][p[1+1]+1]) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    String S=sc.next();
    HashMap<String,Integer>map=new HashMap<String,Integer>();
    for(int i=0 ; i<(1<<N); i++){
      int[] arr=new int[N];
      int tmp=i ;
      String red="" ;
      String blue="" ;
      for(int j=0 ; j<N ; j++){
        arr[j]=tmp % 2 ;
        tmp/=2 ;
        if(arr[j]==1)red+=S.charAt(j);
        else blue+=S.charAt(j);
      }
      String key=red+" "+blue ;
      if(map.containsKey(key)){
        map.put(key,map.get(key)+1);
      }
      else {
        map.put(key,1);
      }
    }
    long ans=0L ;
    for(int i=0 ; i<(1<<N); i++){
      int[] arr=new int[N];
      int tmp=i ;
      String red="" ;
      String blue="" ;
      for(int j=N-1 ; j>=0 ; j--){
        arr[j]=tmp % 2 ;
        tmp/=2 ;
        if(arr[j]==1)red+=S.charAt(N+j);
        else blue+=S.charAt(N+j);
      }
      String key=red+" "+blue ;
      if(map.containsKey(key)){
        ans+=map.get(key);
      }
      else {
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var S : String ; S := sc.getCurrent() ;
    var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < ((1*(2->pow(N)))->oclAsType(long)) do ( (     var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
     var tmp : int ; tmp := i ;
    var red : String ; red := "" ;
    var blue : String ; blue := "" ;
        var j : int ; j := 0 ; while j < N do ( (     arr[j+1] := tmp mod 2 ; 
     tmp := tmp/(2) ; 
     if (arr[j+1] = 1) then     red := red+(S->at(j+1)) ; else     blue := blue+(S->at(j+1)) ; )  ;     j := j + 1 ) ; 
    var key : String ; key := red + " " + blue ;
    if (map->keys()->includes(key)) then (     map := map->union(Map{key |-> map->at(key) + 1}) ) else (     map := map->union(Map{key |-> 1}) ) ;  
 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0L ;
        var i : int ; i := 0 ; while i < ((1*(2->pow(N)))->oclAsType(long)) do ( (     var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
     var tmp : int ; tmp := i ;
    var red : String ; red := "" ;
    var blue : String ; blue := "" ;
        var j : int ; j := N - 1 ; while j >= 0 do ( (     arr[j+1] := tmp mod 2 ; 
     tmp := tmp/(2) ; 
     if (arr[j+1] = 1) then     red := red+(S->at(N + j+1)) ; else     blue := blue+(S->at(N + j+1)) ; )  ;     j := j - 1 ) ; 
    var key : String ; key := red + " " + blue ;
    if (map->keys()->includes(key)) then (     ans := ans+(map->at(key)) ) else skip ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long x=sc.nextLong();
    long year=0 ;
    double kingaku=100 ;
    do {
      kingaku=kingaku*1.01 ;
      kingaku=Math.floor(kingaku);
      year++;
    }
    while(kingaku<x);
    System.out.println(year);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := sc.getCurrent()->toLong() ;
    var year : long ; year := 0 ;
    var kingaku : double ; kingaku := 100 ;
  while true do ((     kingaku := kingaku * 1.01 ; 
     kingaku := (kingaku)->floor() ; 
     year := year + 1 ) ;
    if (kingaku < x) then skip else break) ; 
    OclFile["System.out"].println(year) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Main {
  private static PrintWriter out ;
  public static void main(String[] args){
    Main main=new Main();
    Runtime.getRuntime().addShutdownHook(new Thread(()->out.close()));
    try {
      main.run(args);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  private void run(String[] arguments)throws Exception {
    MyScanner sc=new MyScanner();
    out=new PrintWriter(new BufferedOutputStream(System.out));
    long target=sc.nextLong();
    long originalValue=100 ;
    int ans=0 ;
    while(true){
      ans++;
      originalValue=(long)Math.floor(originalValue*1.01);
      if(originalValue>=target){
        break ;
      }
    }
    out.println(ans);
    out.close();
  }
  private class MyScanner {
    BufferedReader br ;
    StringTokenizer st ;
    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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     Runtime.getRuntime().addShutdownHook(OclProcess.newOclProcess((lambdaParameters ( )) out.closeFile())) ; 
     try (     main.run(args) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
   operation run( arguments : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var target : long ; target := sc.nextLong() ;
    var originalValue : long ; originalValue := 100 ;
    var ans : int ; ans := 0 ;
    while (true) do (     ans := ans + 1 ; 
     originalValue := (originalValue * 1.01)->floor()->oclAsType(long) ; 
     if (originalValue >= target) then (     break ) else skip ) ; 
    skip ; 
    skip ; 
 );
 class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    long X=sc.nextLong();
    long money=100 ;
    long ans=0 ;
    for(int i=1 ; ; i++){
      money*=1.01 ;
      if(money>=X){
        ans=i ;
        break ;
      }
    }
    System.out.println(ans);
  }
  static private int binarySearch(long num,long[] orderedArray){
    int lowerBorder=-1 ;
    int upperBorder=orderedArray.length ;
    int mid ;
    while(upperBorder-lowerBorder>1){
      mid=(upperBorder+lowerBorder)/2 ;
      if(orderedArray[mid]<=num){
        lowerBorder=mid ;
      }
      else {
        upperBorder=mid ;
      }
    }
    return lowerBorder ;
  }
  static private int binarySearch(long num,ArrayList<Long>orderedList){
    int lowerBorder=-1 ;
    int upperBorder=orderedList.size();
    int mid ;
    while(upperBorder-lowerBorder>1){
      mid=(upperBorder+lowerBorder)/2 ;
      if(orderedList.get(mid)<=num){
        lowerBorder=mid ;
      }
      else {
        upperBorder=mid ;
      }
    }
    return lowerBorder ;
  }
  public static int gcd(int a,int b){
    return b==0 ? a : gcd(b,a % b);
  }
  public static long gcd(long a,long b){
    return b==0 ? a : gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : long ; X := sc.getCurrent()->toLong() ;
    var money : long ; money := 100 ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while true do ( (     money := money*(1.01) ; 
     if (money >= X) then (     ans := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static    operation binarySearch( num : long, orderedArray : Sequence(long)) : int
  pre: true
  post: true
  activity: (     var lowerBorder : int ; lowerBorder := -1 ;
     var upperBorder : int ; upperBorder := orderedArray->size() ;
    var mid : int ;
    while (upperBorder - lowerBorder > 1) do (     mid := (upperBorder + lowerBorder) / 2 ; 
     if (orderedArray[mid+1] <= num) then (     lowerBorder := mid ) else (     upperBorder := mid ) ) ; 
    return lowerBorder 
 );
  static    operation binarySearch( num : long, orderedList : Sequence(long)) : int
  pre: true
  post: true
  activity: (     var lowerBorder : int ; lowerBorder := -1 ;
     var upperBorder : int ; upperBorder := orderedList->size() ;
    var mid : int ;
    while (upperBorder - lowerBorder > 1) do (     mid := (upperBorder + lowerBorder) / 2 ; 
     if (orderedList->at(mid+1) <= num) then (     lowerBorder := mid ) else (     upperBorder := mid ) ) ; 
    return lowerBorder 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float area(float a){
    if(a<0)return-1 ;
    float area=(float)Math.sqrt(a)/6 ;
    return area ;
  }
  public static void main(String[] args){
    float a=10 ;
    System.out.println(area(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation area( a : double) : double
  pre: true
  post: true
  activity: (     if (a < 0) then     return -1 else skip ; 
     var area : double ; area := (a)->sqrt()->oclAsType(double) / 6 ;
     return area );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 10 ;
     OclFile["System.out"].println(area(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Parallelogram_is_Back {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int x=scanner.nextInt();
    int y=scanner.nextInt();
    int a=scanner.nextInt();
    int b=scanner.nextInt();
    int c=scanner.nextInt();
    int d=scanner.nextInt();
    System.out.println("3");
    System.out.println((x+a-c)+" "+(y+b-d));
    System.out.println((x+c-a)+" "+(y+d-b));
    System.out.println((c+a-x)+" "+(d+b-y));
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Parallelogram_is_Back {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := scanner.getCurrent()->toInteger() ;
    var y : int ; y := scanner.getCurrent()->toInteger() ;
    var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    var d : int ; d := scanner.getCurrent()->toInteger() ;
    OclFile["System.out"].println("3") ; 
    OclFile["System.out"].println((x + a - c) + " " + (y + b - d)) ; 
    OclFile["System.out"].println((x + c - a) + " " + (y + d - b)) ; 
    OclFile["System.out"].println((c + a - x) + " " + (d + b - y)) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.math.RoundingMode ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long X=Long.parseLong(sc.next());
    sc.close();
    BigDecimal bd1=new BigDecimal("100");
    BigDecimal bd2=new BigDecimal("1.01");
    BigDecimal bd3=new BigDecimal(String.valueOf(X));
    int year=0 ;
    while(bd1.compareTo(bd3)==-1){
      bd1=bd1.multiply(bd2);
      bd1=bd1.setScale(0,RoundingMode.DOWN);
      year++;
    }
    System.out.println(year);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : long ; X := (sc.getCurrent())->toLong() ;
    skip ; 
    var bd1 : double ; bd1 := double("100") ;
    var bd2 : double ; bd2 := double("1.01") ;
    var bd3 : double ; bd3 := double(((X) + "")) ;
    var year : int ; year := 0 ;
    while (bd1->compareTo(bd3) = -1) do (     bd1 := bd1.multiply(bd2) ; 
     bd1 := bd1.setScale(0, RoundingMode.DOWN) ; 
     year := year + 1 ) ; 
    OclFile["System.out"].println(year) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static class pair implements Comparable<pair>{
    int id ;
    int ans ;
    pair(int x,int y){
      id=x ;
      ans=y ;
    }
    public pair(){
    }
    public int compareTo(pair o){
      return this.id-o.id ;
    }
  }
  static ArrayList<Integer>gr[];
  static int[] ar ;
  static Scanner sc=new Scanner(System.in);
  static int pri[]=new int[(int)1e6+5];
  static StringBuilder out=new StringBuilder();
  public static void main(String[] args)throws IOException {
    int t=1 ;
    while(t-->0){
      long ru=sc.nextLong();
      long val=100 ;
      long n=0 ;
      while(val<ru){
        val+=val/100 ;
        n++;
      }
      System.out.println(n);
    }
    System.out.println(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class pair implements Comparable<pair> {
   attribute id : int;
   attribute ans : int;
   static operation newpair( x : int, y : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     id := x ; 
     ans := y );
   static operation newpair() : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   operation compareTo( o : pair) : int
  pre: true
  post: true
  activity: (     return self.id - o.id );
}
  static   attribute gr : Sequence(Sequence(int));
  static   attribute ar : Sequence(int);
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute pri : int := Integer.subrange(1,1e6->oclAsType(int) + 5)->collect(0);
  static   attribute out : String := StringLib.newString();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var ru : long ; ru := sc.getCurrent()->toLong() ;
     var val : long ; val := 100 ;
    var n : long ; n := 0 ;
    while (val < ru) do (     val := val+(val / 100) ; 
     n := n + 1 ) ; 
    OclFile["System.out"].println(n) ; 
 ) ;  ) ;  
     OclFile["System.out"].println(out) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean digitDividesK(int num,int k){
    while(num!=0){
      int d=num % 10 ;
      if(d!=0 && k % d==0)return true ;
      num=num/10 ;
    }
    return false ;
  }
  static int findCount(int l,int r,int k){
    int count=0 ;
    for(int i=l ; i<=r ; i++){
      if(digitDividesK(i,k))count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int l=20,r=35 ;
    int k=45 ;
    System.out.println(findCount(l,r,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation digitDividesK( num : int, k : int) : boolean
  pre: true
  post: true
  activity: (     while (num /= 0) do (     var d : int ; d := num mod 10 ;
     if (d /= 0 & k mod d = 0) then     return true else skip ; 
     num := num / 10 ) ; 
     return false );
  static   operation findCount( l : int, r : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := l ; while i <= r do ( (     if (digitDividesK(i, k)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 20 ;
    var r : int ; r := 35 ;
     var k : int ; k := 45 ;
     OclFile["System.out"].println(findCount(l, r, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class cp {
  public static void findAllFactor(int[][] div,int n){
    int divCnt[]=new int[n+1];
    int ptr[]=new int[n+1];
    for(int i=n ; i>=1 ; --i){
      for(int j=i ; j<=n ; j+=i)divCnt[j]++;
    }
    for(int i=1 ; i<=n ; ++i)div[i]=new int[divCnt[i] ];
    for(int i=n ; i>=1 ; --i){
      for(int j=i ; j<=n ; j+=i)div[j][ptr[j]++]=i ;
    }
  }
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int[] l=new int[4];
    for(int i=0 ; i<4 ; i++){
      String str=br.readLine();
      String ss=str.substring(2);
      l[i]=ss.length();
    }
    int cnt=0 ;
    ArrayList<Integer>list=new ArrayList<>();
    for(int i=0 ; i<4 ; i++){
      int id=0,id1=0 ;
      for(int j=0 ; j<4 ; j++){
        if(j!=i){
          if(l[i]<=l[j]/2)id++;
        }
        if(j!=i){
          if(l[i]>=2*l[j])id1++;
        }
      }
      if(id==3 || id1==3){
        list.add(i);
      }
    }
    if(list.size()==1){
      System.out.println((char)('A'+list.get(0)));
    }
    else {
      System.out.println("C");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp {
  static   operation findAllFactor( div : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (     var divCnt : Sequence(int) ; divCnt := Integer.subrange(1,n + 1)->collect(0) ;
     var ptr : Sequence(int) ; ptr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := n ; while i >= 1 do ( (         var j : int ; j := i ; while j <= n do (     divCnt[j+1] := divCnt[j+1] + 1 ;  ;     j := j+(i) ) )  ;     i := i - 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (     div[i+1] := Integer.subrange(1,divCnt[i+1])->collect(0) ;  ;     i := i + 1 ) ; 
        var i : int ; i := n ; while i >= 1 do ( (         var j : int ; j := i ; while j <= n do (      div[j+1][ptr[j+1]+1] := i  ; ptr[j+1] := ptr[j+1] + 1 ;  ;     j := j+(i) ) )  ;     i := i - 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var l : Sequence(int) ; l := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     var str : String ; str := br.readLine() ;
     var ss : String ; ss := str.subrange(2+1,2) ;
     l[i+1] := ss->size() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < 4 do ( (     var id : int ; id := 0 ;
    var id1 : int ; id1 := 0 ;
         var j : int ; j := 0 ; while j < 4 do ( (     if (j /= i) then (     if (l[i+1] <= l[j+1] / 2) then     id := id + 1 ; else skip ) else skip ; 
     if (j /= i) then (     if (l[i+1] >= 2 * l[j+1]) then     id1 := id1 + 1 ; else skip ) else skip )  ;     j := j + 1 ) ; 
     if (id = 3 or id1 = 3) then (     list := list->including(i) ) else skip )  ;     i := i + 1 ) ; 
    if (list->size() = 1) then (     OclFile["System.out"].println(('A' + list->at(0+1))->oclAsType(String)) ) else (     OclFile["System.out"].println("C") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class question {
  public static void main(String[] args)throws NumberFormatException,IOException {
    Scanner sc=new Scanner(System.in);
    int arr[]=new int[4];
    for(int i=0 ; i<4 ; i++)arr[i]=sc.next().length()-2 ;
    char alpha[]={
      '#','A','B','C','D' };
      char ans=alpha[0];
      int shorter=0,longer=0,flag=0 ;
      for(int i=0 ; i<4 ; i++){
        shorter=0 ;
        longer=0 ;
        for(int j=0 ; j<4 ; j++){
          if(i!=j){
            if(2*arr[i]<=arr[j])shorter++;
            else if(arr[i]>=2*arr[j])longer++;
          }
        }
        if((shorter==3 && longer==0)||(shorter==0 && longer==3)){
          ans=alpha[i+1];
          flag++;
        }
      }
      if(flag==1){
        System.out.println(ans);
      }
      else System.out.println("C");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class question {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do (     arr[i+1] := sc.getCurrent()->size() - 2 ;  ;     i := i + 1 ) ; 
    var alpha : Sequence(String) ; alpha := Sequence{'#','A','B','C','D'} ;
    var ans : String ; ans := alpha[0+1] ;
    var shorter : int ; shorter := 0 ;
    var longer : int ; longer := 0 ;
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     shorter := 0 ; 
     longer := 0 ; 
         var j : int ; j := 0 ; while j < 4 do ( (     if (i /= j) then (     if (2 * arr[i+1] <= arr[j+1]) then     shorter := shorter + 1 ; else     if (arr[i+1] >= 2 * arr[j+1]) then     longer := longer + 1 ; else skip ; ) else skip )  ;     j := j + 1 ) ; 
     if ((shorter = 3 & longer = 0) or (shorter = 0 & longer = 3)) then (     ans := alpha[i + 1+1] ; 
     flag := flag + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 1) then (     OclFile["System.out"].println(ans) ) else     OclFile["System.out"].println("C") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CodeForces {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a[]=new int[5];
    for(int i=1 ; i<=4 ; i++){
      a[i]=sc.nextInt();
    }
    String s=sc.next();
    int wastedCalories=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='1')wastedCalories+=a[1];
      if(s.charAt(i)=='2')wastedCalories+=a[2];
      if(s.charAt(i)=='3')wastedCalories+=a[3];
      if(s.charAt(i)=='4')wastedCalories+=a[4];
    }
    System.out.println(wastedCalories);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,5)->collect(0) ;
        var i : int ; i := 1 ; while i <= 4 do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var s : String ; s := sc.getCurrent() ;
    var wastedCalories : int ; wastedCalories := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '1') then     wastedCalories := wastedCalories+(a[1+1]) ; else skip ; 
     if (s->at(i+1) = '2') then     wastedCalories := wastedCalories+(a[2+1]) ; else skip ; 
     if (s->at(i+1) = '3') then     wastedCalories := wastedCalories+(a[3+1]) ; else skip ; 
     if (s->at(i+1) = '4') then     wastedCalories := wastedCalories+(a[4+1]) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(wastedCalories) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CodeForces {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a[]=new int[5];
    for(int i=1 ; i<=4 ; i++){
      a[i]=sc.nextInt();
    }
    String s=sc.next();
    int wastedCalories=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='1')wastedCalories+=a[1];
      if(s.charAt(i)=='2')wastedCalories+=a[2];
      if(s.charAt(i)=='3')wastedCalories+=a[3];
      if(s.charAt(i)=='4')wastedCalories+=a[4];
    }
    System.out.println(wastedCalories);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,5)->collect(0) ;
        var i : int ; i := 1 ; while i <= 4 do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var s : String ; s := sc.getCurrent() ;
    var wastedCalories : int ; wastedCalories := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '1') then     wastedCalories := wastedCalories+(a[1+1]) ; else skip ; 
     if (s->at(i+1) = '2') then     wastedCalories := wastedCalories+(a[2+1]) ; else skip ; 
     if (s->at(i+1) = '3') then     wastedCalories := wastedCalories+(a[3+1]) ; else skip ; 
     if (s->at(i+1) = '4') then     wastedCalories := wastedCalories+(a[4+1]) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(wastedCalories) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    int ans=0 ;
    String str=sc.next();
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)=='1'){
        ans+=a ;
      }
      else if(str.charAt(i)=='2'){
        ans+=b ;
      }
      else if(str.charAt(i)=='3'){
        ans+=c ;
      }
      else {
        ans+=d ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    var str : String ; str := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '1') then (     ans := ans+(a) ) else     if (str->at(i+1) = '2') then (     ans := ans+(b) ) else     if (str->at(i+1) = '3') then (     ans := ans+(c) ) else (     ans := ans+(d) ) ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A431 {
  static Scanner sc=new Scanner();
  public static void main(String[] args){
    solve();
  }
  public static void solve(){
    int[] a=sc.readArray(4);
    String str=sc.next();
    int sum=0 ;
    for(int i=0 ; i<str.length(); i++){
      sum+=a[Character.getNumericValue(str.charAt(i))-1];
    }
    System.out.print(sum);
  }
  static class Scanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A431 {
  static   attribute sc : OclFile := (arguments ( ));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := sc.readArray(4) ;
     var str : String ; str := sc.getCurrent() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     sum := sum+(a[("" + str->at(i+1))->toInteger() - 1+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sum) ; 
 );
  static class Scanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int cntSubSeq(int arr[],int n){
    int pos_count=0 ;
    int neg_count=0 ;
    int result ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]>0)pos_count++;
      if(arr[i]<0)neg_count++;
    }
    result=(int)Math.pow(2,pos_count);
    if(neg_count>0)result*=Math.pow(2,neg_count-1);
    else result=0 ;
    return result ;
  }
  public static void main(String[] args){
    int arr[]={
      3,-4,-1,6 };
      int n=arr.length ;
      System.out.print(cntSubSeq(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation cntSubSeq( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var pos_count : int ; pos_count := 0 ;
     var neg_count : int ; neg_count := 0 ;
    var result : int ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] > 0) then     pos_count := pos_count + 1 ; else skip ; 
     if (arr[i+1] < 0) then     neg_count := neg_count + 1 ; else skip )  ;     i := i + 1 ) ; 
    result := 2->pow(pos_count)->oclAsType(int) ; 
    if (neg_count > 0) then     result := result*(2->pow(neg_count - 1)) else     result := 0 ; ;  
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,-4,-1,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(cntSubSeq(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void union(int a,int b,int[] par,int[] size){
    a=getPar(a,par);
    b=getPar(b,par);
    par[a]=b ;
    size[b]+=size[a];
  }
  int getPar(int a,int[] par){
    if(par[a]==a)return a ;
    return par[a]=getPar(par[a],par);
  }
  void solution(){
    String s1=sc.next();
    String s2=sc.next();
    int x=s1.charAt(0)-s2.charAt(0);
    int y=s1.charAt(1)-s2.charAt(1);
    int ans=Math.max(Math.abs(x),Math.abs(y));
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<ans ; ++i){
      if(x<0){
        sb.append("R");
        x++;
      }
      else if(x>0){
        sb.append("L");
        x--;
      }
      if(y<0){
        sb.append("U");
        y++;
      }
      else if(y>0){
        sb.append("D");
        y--;
      }
      sb.append("\n");
    }
    System.out.println(ans+"\n"+sb);
  }
  public static void main(String[] args){
    new Main().solution();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation union( a : int, b : int, par : Sequence(int), size : Sequence(int)) : void
  pre: true
  post: true
  activity: (     a := getPar(a, par) ; 
     b := getPar(b, par) ; 
     par[a+1] := b ; 
     size[b+1] := size[b+1]+(size[a+1]) );
   operation getPar( a : int, par : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (par[a+1] = a) then     return a else skip ; 
     return par[a+1] );
   operation solution() : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := sc.getCurrent() ;
     var s2 : String ; s2 := sc.getCurrent() ;
    var x : int ; x := s1->at(0+1) - s2->at(0+1) ;
    var y : int ; y := s1->at(1+1) - s2->at(1+1) ;
    var ans : int ; ans := Set{if x < 0 then -(x) else x endif, if y < 0 then -(y) else y endif}->max() ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < ans do ( (     if (x < 0) then (     sb := sb + StringLib.newString("R") ; 
     x := x + 1 ) else     if (x > 0) then (     sb := sb + StringLib.newString("L") ; 
     x := x - 1 ) else skip ; ;  
     if (y < 0) then (     sb := sb + StringLib.newString("U") ; 
     y := y + 1 ) else     if (y > 0) then (     sb := sb + StringLib.newString("D") ; 
     y := y - 1 ) else skip ; ;  
     sb := sb + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans + "\n" + sb) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solution() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B_388 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int x1=in.nextInt();
    int y1=in.nextInt();
    int x2=in.nextInt();
    int y2=in.nextInt();
    int x3=in.nextInt();
    int y3=in.nextInt();
    System.out.println(3);
    System.out.println((x1+x2-x3)+" "+(y1+y2-y3));
    System.out.println((x2+x3-x1)+" "+(y2+y3-y1));
    System.out.println((x3+x1-x2)+" "+(y3+y1-y2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_388 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : int ; x1 := in.getCurrent()->toInteger() ;
    var y1 : int ; y1 := in.getCurrent()->toInteger() ;
    var x2 : int ; x2 := in.getCurrent()->toInteger() ;
    var y2 : int ; y2 := in.getCurrent()->toInteger() ;
    var x3 : int ; x3 := in.getCurrent()->toInteger() ;
    var y3 : int ; y3 := in.getCurrent()->toInteger() ;
    OclFile["System.out"].println(3) ; 
    OclFile["System.out"].println((x1 + x2 - x3) + " " + (y1 + y2 - y3)) ; 
    OclFile["System.out"].println((x2 + x3 - x1) + " " + (y2 + y3 - y1)) ; 
    OclFile["System.out"].println((x3 + x1 - x2) + " " + (y3 + y1 - y2)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static float trianglearea(float a,float b){
    if(a<0 || b<0)return-1 ;
    float area=(float)(3*Math.sqrt(3)*Math.pow(a,2))/(4*b);
    return area ;
  }
  public static void main(String[] args){
    float a=4,b=2 ;
    System.out.println(trianglearea(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation trianglearea( a : double, b : double) : double
  pre: true
  post: true
  activity: (     if (a < 0 or b < 0) then     return -1 else skip ; 
     var area : double ; area := (3 * (3)->sqrt() * a->pow(2))->oclAsType(double) / (4 * b) ;
     return area );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 4 ;
    var b : double ; b := 2 ;
     OclFile["System.out"].println(trianglearea(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int cntSubSeq(int arr[],int n){
    int pos_count=0 ;
    int neg_count=0 ;
    int result ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]>0)pos_count++;
      if(arr[i]<0)neg_count++;
    }
    result=(int)Math.pow(2,pos_count);
    if(neg_count>0)result*=Math.pow(2,neg_count-1);
    result-=1 ;
    return result ;
  }
  public static void main(String[] args){
    int arr[]={
      2,-3,-1,4 };
      int n=arr.length ;
      System.out.print(cntSubSeq(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation cntSubSeq( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var pos_count : int ; pos_count := 0 ;
     var neg_count : int ; neg_count := 0 ;
    var result : int ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] > 0) then     pos_count := pos_count + 1 ; else skip ; 
     if (arr[i+1] < 0) then     neg_count := neg_count + 1 ; else skip )  ;     i := i + 1 ) ; 
    result := 2->pow(pos_count)->oclAsType(int) ; 
    if (neg_count > 0) then     result := result*(2->pow(neg_count - 1)) ; else skip ; 
    result := result-(1) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,-3,-1,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(cntSubSeq(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
class GFG {
  static int sum(int ar[],int n){
    HashMap<Integer,Integer>mp=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      mp.put(ar[i],0);
    }
    for(int i=0 ; i<n ; i++){
      mp.put(ar[i],mp.get(ar[i])+1);
    }
    int sum=0 ;
    for(Map.Entry p : mp.entrySet()){
      n-=(int)p.getValue();
      sum+=n ;
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=6 ;
    int ar[]={
      5,4,4,2,2,8 };
      int ans=sum(ar,n);
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sum( ar : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     mp := mp->union(Map{ar[i+1] |-> 0}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     mp := mp->union(Map{ar[i+1] |-> mp->at(ar[i+1]) + 1}) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    for (p : mp->asSet()) do ( (     n := n-(p.getValue()->oclAsType(int)) ; 
     sum := sum+(n) )  ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     var ar : Sequence(int) ; ar := Sequence{5,4,4,2,2,8} ;
     var ans : int ; ans := sum(ar, n) ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean permutation(int[] arr,int n){
    Set<Integer>hash=new HashSet<Integer>();
    int maxEle=0 ;
    for(int i=0 ; i<n ; i++){
      hash.add(arr[i]);
      maxEle=Math.max(maxEle,arr[i]);
    }
    if(maxEle!=n)return false ;
    if(hash.size()==n)return true ;
    return false ;
  }
  public static void main(String args[]){
    int arr[]={
      1,2,5,3,2 };
      int n=arr.length ;
      if(permutation(arr,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation permutation( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var hash : Set(int) ; hash := Set{} ;
     var maxEle : int ; maxEle := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     hash := hash->including(arr[i+1]) ; 
     maxEle := Set{maxEle, arr[i+1]}->max() )  ;     i := i + 1 ) ; 
    if (maxEle /= n) then     return false else skip ; 
    if (hash->size() = n) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,5,3,2} ;
     var n : int ; n := arr->size() ;
     if (permutation(arr, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getPassingCars(int[] A,int n){
    int result=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if(A[i]==0){
        for(int j=i+1 ; j<n ; j++)if(A[j]==1)result++;
      }
    }
    return result ;
  }
  public static void main(String[] args){
    int[] A={
      0,1,0,1,1 };
      int n=A.length ;
      System.out.println(getPassingCars(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getPassingCars( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     if (A[i+1] = 0) then (         var j : int ; j := i + 1 ; while j < n do (     if (A[j+1] = 1) then     result := result + 1 ; else skip ;  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{0,1,0,1,1} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].println(getPassingCars(A, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int w=sc.nextInt();
      int h=sc.nextInt();
      if(w==0 && h==0)break ;
      BigInteger[][] bi=new BigInteger[h+1][w+1];
      for(int i=0 ; i<=h ; i++){
        for(int j=0 ; j<=w ; j++){
          bi[i][j]=BigInteger.ZERO ;
        }
      }
      BigInteger zero=BigInteger.ZERO ;
      BigInteger max=BigInteger.ZERO ;
      String s,t ;
      for(int i=1 ; i<=h ; i++){
        s=sc.next();
        for(int j=1 ; j<=w ; j++){
          t=s.substring(j-1,j);
          if(t.codePointAt(0)<58){
            if(bi[i][j-1] .compareTo(zero)==0 && bi[i-1][j] .compareTo(zero)==0 && t.compareTo("0")==0)continue ;
            BigInteger x=bi[i][j-1] .multiply(BigInteger.TEN).add(new BigInteger(t));
            BigInteger y=bi[i-1][j] .multiply(BigInteger.TEN).add(new BigInteger(t));
            if(x.compareTo(y)>0)bi[i][j]=x ;
            else bi[i][j]=y ;
            if(max.compareTo(bi[i][j])<0)max=bi[i][j];
          }
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var w : int ; w := sc.getCurrent()->toInteger() ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    if (w = 0 & h = 0) then     break else skip ; 
    var bi : Sequence(Sequence(long)) ; bi := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(null)) ;
        var i : int ; i := 0 ; while i <= h do ( (         var j : int ; j := 0 ; while j <= w do ( (     bi[i+1][j+1] := 0 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var zero : long ; zero := 0 ;
    var max : long ; max := 0 ;
    var s : String ;
    var t : String ;
        var i : int ; i := 1 ; while i <= h do ( (     s := sc.getCurrent() ; 
         var j : int ; j := 1 ; while j <= w do ( (     t := s.subrange(j - 1+1,j) ; 
     if (t.codePointAt(0) < 58) then (     if (bi[i+1][j - 1+1]->compareTo(zero) = 0 & bi[(i)->char2byte() - 1+1][j+1]->compareTo(zero) = 0 & t->compareTo("0") = 0) then     continue else skip ; 
     var x : long ; x := bi[i+1][j - 1+1].multiply(10)->excludes(long(t)) ;
    var y : long ; y := bi[(i)->char2byte() - 1+1][j+1].multiply(10)->excludes(long(t)) ;
    if (x->compareTo(y) > 0) then     bi[i+1][j+1] := x else     bi[i+1][j+1] := y ; ;  
    if (max->compareTo(bi[i+1][j+1]) < 0) then     max := bi[i+1][j+1] ; else skip ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int w=sc.nextInt();
      int h=sc.nextInt();
      if((w | h)==0)break ;
      char[][] m=new char[h][w];
      for(int i=0 ; i<h ; i++)m[i]=sc.next().toCharArray();
      String[][] dp=new String[h][w];
      String res="0" ;
      for(int i=h-1 ; i>=0 ; i--)for(int j=w-1 ; j>=0 ; j--){
        if(Character.isUpperCase(m[i][j]))continue ;
        String l=m[i][j]+"" ;
        String d=m[i][j]+"" ;
        if(i+1<h && ! Character.isUpperCase(m[i+1][j]))d+=dp[i+1][j];
        if(j+1<w && ! Character.isUpperCase(m[i][j+1]))l+=dp[i][j+1];
        if(l.length()!=d.length()){
          dp[i][j]=l.length()>d.length()? l : d ;
        }
        else {
          BigInteger bl=new BigInteger(l);
          BigInteger bd=new BigInteger(d);
          if(bl.compareTo(bd)>0)dp[i][j]=l ;
          else dp[i][j]=d ;
        }
        BigInteger b=new BigInteger(dp[i][j]);
        if(b.compareTo(new BigInteger(res))>0){
          res=dp[i][j];
        }
      }
      System.out.println(new BigInteger(res).toString());
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var w : int ; w := sc.getCurrent()->toInteger() ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(w,h)) = 0) then     break else skip ; 
    var m : Sequence(Sequence(String)) ; m := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do (     m[i+1] := sc.getCurrent()->characters() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(String)) ; dp := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(null)) ;
    var res : String ; res := "0" ;
        var i : int ; i := h - 1 ; while i >= 0 do (         var j : int ; j := w - 1 ; while j >= 0 do ( (     if ((m[i+1][j+1]->toUpperCase() = m[i+1][j+1])) then     continue else skip ; 
     var l : String ; l := m[i+1][j+1] + "" ;
    var d : String ; d := m[i+1][j+1] + "" ;
    if (i + 1 < h & not((m[i + 1+1][j+1]->toUpperCase() = m[i + 1+1][j+1]))) then     d := d+(dp[i + 1+1][j+1]) ; else skip ; 
    if (j + 1 < w & not((m[i+1][j + 1+1]->toUpperCase() = m[i+1][j + 1+1]))) then     l := l+(dp[i+1][j + 1+1]) ; else skip ; 
    if (l->size() /= d->size()) then (     dp[i+1][j+1] := if l->size() > d->size() then l else d endif ) else (     var bl : long ; bl := long(l) ;
     var bd : long ; bd := long(d) ;
     if (bl->compareTo(bd) > 0) then     dp[i+1][j+1] := l ; else     dp[i+1][j+1] := d ; ) ;  
    var b : long ; b := long(dp[i+1][j+1]) ;
    if (b->compareTo(long(res)) > 0) then (     res := dp[i+1][j+1] ) else skip ; 
 )  ;     j := j - 1 ) ;  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(long(res)+"") ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import static java.lang.System.*;
public class Main {
  Scanner sc=new Scanner(in);
  void run(){
    while(true){
      int w=sc.nextInt(),h=sc.nextInt();
      if(w==0 && h==0)break ;
      String[] rows=new String[h];
      for(int i=0 ; i<h ; i++)rows[i]=sc.next();
      BigInteger[][] dp=new BigInteger[h+1][w+1];
      for(int i=0 ; i<=h ; i++)for(int j=0 ; j<=w ; j++)dp[i][j]=BigInteger.ZERO ;
      BigInteger res=BigInteger.ZERO ;
      for(int i=1 ; i<=h ; i++){
        for(int j=1 ; j<=w ; j++){
          if(Character.isDigit(rows[i-1] .charAt(j-1))){
            dp[i][j]=(((dp[i-1][j] .compareTo(dp[i][j-1])>0)? dp[i-1][j] : dp[i][j-1]).multiply(BigInteger.TEN)).add(new BigInteger(""+rows[i-1] .charAt(j-1)));
            res=(dp[i][j] .compareTo(res)>0)? dp[i][j] : res ;
          }
        }
      }
      out.println(res);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   operation run() : void
  pre: true
  post: true
  activity: (     while (true) do (     var w : int ; w := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
     if (w = 0 & h = 0) then     break else skip ; 
    var rows : Sequence(String) ; rows := Integer.subrange(1,h)->collect(null) ;
        var i : int ; i := 0 ; while i < h do (     rows[i+1] := sc.getCurrent() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(null)) ;
        var i : int ; i := 0 ; while i <= h do (         var j : int ; j := 0 ; while j <= w do (     dp[i+1][j+1] := 0 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
        var i : int ; i := 1 ; while i <= h do ( (         var j : int ; j := 1 ; while j <= w do ( (     if ((rows[i - 1+1]->at(j - 1+1) + "")->isMatch("[0-9]")) then (     dp[i+1][j+1] := ((if (dp[i - 1+1][j+1]->compareTo(dp[i+1][j - 1+1]) > 0) then dp[i - 1+1][j+1] else dp[i+1][j - 1+1] endif).multiply(10))->excludes(long("" + rows[i - 1+1]->at(j - 1+1))) ; 
     res := if (dp[i+1][j+1]->compareTo(res) > 0) then dp[i+1][j+1] else res endif ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    out.println(res) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int w=sc.nextInt();
      int h=sc.nextInt();
      if(w==0 && h==0){
        break ;
      }
      char[][] m=new char[h][];
      for(int i=0 ; i<h ; i++){
        m[i]=sc.next().toCharArray();
      }
      BigInteger ans=BigInteger.ZERO ;
      BigInteger[][] dp=new BigInteger[h][w];
      for(int i=0 ; i<h ; i++){
        for(int j=0 ; j<w ; j++){
          dp[i][j]=BigInteger.ZERO ;
          if(! Character.isDigit(m[i][j])){
            continue ;
          }
          BigInteger d=BigInteger.valueOf(m[i][j]-'0');
          dp[i][j]=d ;
          if(i>0){
            dp[i][j]=dp[i][j] .max(dp[i-1][j] .multiply(BigInteger.TEN).add(d));
          }
          if(j>0){
            dp[i][j]=dp[i][j] .max(dp[i][j-1] .multiply(BigInteger.TEN).add(d));
          }
          ans=ans.max(dp[i][j]);
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var w : int ; w := sc.getCurrent()->toInteger() ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    if (w = 0 & h = 0) then (     break ) else skip ; 
    var m : Sequence(Sequence(String)) ; m := Integer.subrange(1,h)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < h do ( (     m[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(null)) ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     dp[i+1][j+1] := 0 ; 
     if (not((m[i+1][j+1] + "")->isMatch("[0-9]"))) then (     continue ) else skip ; 
    var d : long ; d := (m[i+1][j+1] - ('0')->char2byte() + "")->toLong() ;
    dp[i+1][j+1] := d ; 
    if (i > 0) then (     dp[i+1][j+1] := dp[i+1][j+1]->max() ) else skip ; 
    if (j > 0) then (     dp[i+1][j+1] := dp[i+1][j+1]->max() ) else skip ; 
    ans := ans->max() ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class A {
  public static void main(String args[]){
    FS in=new FS();
    PrintWriter out=new PrintWriter(System.out);
    int N=in.nextInt();
    int ar[]=new int[N];
    int cols=0 ;
    for(int i=0 ; i<N ; i++)ar[i]=in.nextInt();
    boolean[] done=new boolean[N];
    Arrays.sort(ar);
    for(int i=0 ; i<N ; i++){
      if(done[i])continue ;
      cols++;
      for(int j=i ; j<N ; j++)if(ar[j] % ar[i]==0)done[j]=true ;
    }
    out.println(cols);
    out.close();
  }
  static class FS {
    BufferedReader br ;
    StringTokenizer st ;
    public FS(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(st==null || ! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(Exception e){
        }
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FS ; in := FS.newFS() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := in.nextInt() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,N)->collect(0) ;
    var cols : int ; cols := 0 ;
        var i : int ; i := 0 ; while i < N do (     ar[i+1] := in.nextInt() ;  ;     i := i + 1 ) ; 
    var done : Sequence(boolean) ; done := Integer.subrange(1,N)->collect(false) ;
    ar := ar->sort() ; 
        var i : int ; i := 0 ; while i < N do ( (     if (done[i+1]) then     continue else skip ; 
     cols := cols + 1 ; 
         var j : int ; j := i ; while j < N do (     if (ar[j+1] mod ar[i+1] = 0) then     done[j+1] := true ; else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FS {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFS() : FS
  pre: true
  post: true
  activity:
  ( var self : FS ;
    self := createFS();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      String s=sc.next();
      StringBuilder tmp=new StringBuilder();
      int[] freq=new int[26];
      Arrays.fill(freq,0);
      for(int i=0 ; i<n ; i++){
        freq[s.charAt(i)-'a']++;
      }
      for(int i=0 ; i<26 ; i++){
        for(int j=0 ; j<freq[i]; j++){
          tmp.append((char)('a'+i)+"");
        }
      }
      int count=0 ;
      for(int i=0 ; i<n ; i++){
        if(s.charAt(i)!=tmp.charAt(i)){
          count++;
        }
      }
      pw.println(count);
    }
    sc.close();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
    var tmp : String ; tmp := StringLib.newString() ;
    var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
    freq := freq->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     freq[s->at(i+1) - ('a')->char2byte()+1] := freq[s->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 26 do ( (         var j : int ; j := 0 ; while j < freq[i+1] do ( (     tmp := tmp + StringLib.newString(('a' + i)->oclAsType(String) + "") )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) /= tmp->at(i+1)) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    sc.close();
    Arrays.sort(a);
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]<0)continue ;
++cnt ;
      for(int j=i+1 ; j<n ; j++){
        if(a[j] % a[i]==0)a[j]=-1 ;
      }
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    a := a->sort() ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] < 0) then     continue else skip ; 
     cnt := cnt + 1 ; 
         var j : int ; j := i + 1 ; while j < n do ( (     if (a[j+1] mod a[i+1] = 0) then     a[j+1] := -1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float area(float a){
    if(a<0)return-1 ;
    float area=(float)Math.pow((a*Math.sqrt(3))/(Math.sqrt(2)),2);
    return area ;
  }
  public static void main(String[] args){
    float a=5 ;
    System.out.println(area(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation area( a : double) : double
  pre: true
  post: true
  activity: (     if (a < 0) then     return -1 else skip ; 
     var area : double ; area := (a * (3)->sqrt()) / ((2)->sqrt())->pow(2)->oclAsType(double) ;
     return area );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 5 ;
     OclFile["System.out"].println(area(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class A_Paint_the_Numbers {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] A=new int[n];
    for(int i=0 ; i<n ; i++){
      A[i]=sc.nextInt();
    }
    Arrays.sort(A);
    boolean[] B=new boolean[n];
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        if(A[j] % A[i]==0){
          B[j]=true ;
        }
      }
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(B[i]==false){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Paint_the_Numbers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    var B : Sequence(boolean) ; B := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (A[j+1] mod A[i+1] = 0) then (     B[j+1] := true ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (B[i+1] = false) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class A1209 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int a[]=new int[n];
    Set<Integer>set=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      a[i]=scanner.nextInt();
    }
    Arrays.sort(a);
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        if(a[j] % a[i]==0){
          a[j]=a[i];
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      set.add(a[i]);
    }
    System.out.println(set.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1209 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (a[j+1] mod a[i+1] = 0) then (     a[j+1] := a[i+1] ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     set := set->including(a[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(set->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.rmi.server.RemoteServer ;
import java.security.cert.CollectionCertStoreParameters ;
import java.util.*;
public class A_Paint_the_Numbers {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    long arr[]=new long[n];
    int count[]=new int[101];
    HashSet<Integer>set=new HashSet<>();
    int i=0 ;
    Vector<Long>v=new Vector<>();
    for(i=0 ; i<n ; i++){
      v.add(s.nextLong());
      if(arr[i]==1){
        break ;
      }
    }
    Collections.sort(v);
    int c=0 ;
    int max=0 ;
    if(i!=n){
      System.out.println(1);
    }
    else {
      int k=1 ;
      int num=2 ;
      while(! v.isEmpty()){
        long a=v.get(0);
        int j=1 ;
        if(v.contains(a)){
          while(! v.isEmpty()&& a*j<=v.get(v.size()-1)){
            while(! v.isEmpty()&& v.contains(a*j))v.remove(a*j);
            j++;
          }
          c++;
        }
      }
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Paint_the_Numbers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
    var count : Sequence(int) ; count := Integer.subrange(1,101)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
    var i : int ; i := 0 ;
    var v : Sequence(long) ; v := Sequence{} ;
        i := 0 ; while i < n do ( (     v := v->including(s.getCurrent()->toLong()) ; 
     if (arr[i+1] = 1) then (     break ) else skip )  ;     i := i + 1 ) ; 
    v := v->sort() ; 
    var c : int ; c := 0 ;
    var max : int ; max := 0 ;
    if (i /= n) then (     OclFile["System.out"].println(1) ) else (     var k : int ; k := 1 ;
     var num : int ; num := 2 ;
     while (not(v->isEmpty())) do (     var a : long ; a := v->at(0+1) ;
     var j : int ; j := 1 ;
     if (v->includes(a)) then (     while (not(v->isEmpty()) & a * j <= v->at(v->size() - 1+1)) do (     while (not(v->isEmpty()) & v->includes(a * j)) do     v := v->excludingFirst(a * j) ; ; 
     j := j + 1 ) ; 
     c := c + 1 ) else skip ) ) ;  
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class template {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    String s=sc.next();
    boolean letter[]=new boolean[26];
    String ans="" ;
    int count=0 ;
    for(char ch : s.toCharArray()){
      if(! letter[ch-'a']){
        count++;
        letter[ch-'a']=true ;
        if(count<=k){
          ans+="\n" ;
        }
      }
      ans+=ch ;
    }
    if(count<k){
      System.out.println("NO");
    }
    else {
      System.out.println("YES"+ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class template {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var letter : Sequence(boolean) ; letter := Integer.subrange(1,26)->collect(false) ;
    var ans : String ; ans := "" ;
    var count : int ; count := 0 ;
    for (ch : s->characters()) do ( (     if (not(letter[ch - ('a')->char2byte()+1])) then (     count := count + 1 ; 
     letter[ch - ('a')->char2byte()+1] := true ; 
     if (count <= k) then (     ans := ans+("\n") ) else skip ) else skip ; 
     ans := ans+(ch) )  ) ; 
    if (count < k) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES" + ans) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxSum(int[] a,int n){
    int ans=0 ;
    int[] arr=new int[n+1];
    for(int i=1 ; i<=n ; i++)arr[i]=a[i-1];
    int[][] dp=new int[n+1][3];
    for(int i=1 ; i<=n ; ++i){
      dp[i][0]=Math.max(arr[i],dp[i-1][0]+arr[i]);
      dp[i][1]=Math.max(0,dp[i-1][0])-arr[i];
      if(i>=2)dp[i][1]=Math.max(dp[i][1],dp[i-1][1]+arr[i]);
      if(i>=2)dp[i][2]=dp[i-1][1]-arr[i];
      if(i>=3)dp[i][2]=Math.max(dp[i][2],dp[i-1][2]+arr[i]);
      ans=Math.max(ans,dp[i][0]);
      ans=Math.max(ans,dp[i][1]);
      ans=Math.max(ans,dp[i][2]);
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
-5,3,2,7,-8,3,7,-9,10,12,-6 };
      int n=arr.length ;
      System.out.println(maxSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxSum( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     arr[i+1] := a[i - 1+1] ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (     dp[i+1][0+1] := Set{arr[i+1], dp[i - 1+1][0+1] + arr[i+1]}->max() ; 
     dp[i+1][1+1] := Set{0, dp[i - 1+1][0+1]}->max() - arr[i+1] ; 
    if (i >= 2) then     dp[i+1][1+1] := Set{dp[i+1][1+1], dp[i - 1+1][1+1] + arr[i+1]}->max() ; else skip ; 
    if (i >= 2) then     dp[i+1][2+1] := dp[i - 1+1][1+1] - arr[i+1] ; else skip ; 
    if (i >= 3) then     dp[i+1][2+1] := Set{dp[i+1][2+1], dp[i - 1+1][2+1] + arr[i+1]}->max() ; else skip ; 
    ans := Set{ans, dp[i+1][0+1]}->max() ; 
    ans := Set{ans, dp[i+1][1+1]}->max() ; 
    ans := Set{ans, dp[i+1][2+1]}->max() ; 
 )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-5,3,2,7,-8,3,7,-9,10,12,-6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxSum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static int lcm(int n,int m){
    return(n*m)/gcd(n,m);
  }
  public static void main(String[] args){
    int n=2,m=3,k=5 ;
    System.out.print(k/lcm(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation lcm( n : int, m : int) : int
  pre: true
  post: true
  activity: (     return (n * m) / gcd(n, m) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
    var m : int ; m := 3 ;
    var k : int ; k := 5 ;
     OclFile["System.out"].print(k / lcm(n, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.dnd.Autoscroll ;
import java.io.BufferedReader ;
import java.io.DataInputStream ;
import java.io.FileInputStream ;
import java.io.IOException ;
import java.util.*;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class cp {
  public static void main(String[] args)throws IOException,NullPointerException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextLong();
    boolean[] p=new boolean[1000001];
    p[0]=false ;
    p[1]=false ;
    p[2]=true ;
    for(int i=3 ; i<p.length ; i+=2)p[i]=true ;
    for(int i=3 ; i<p.length ; i+=2){
      if(p[i]){
        for(int j=3*i ; j<p.length ; j+=2*i)p[j]=false ;
      }
    }
    Set<Long>hs=new HashSet<>();
    hs.add(4L);
    for(int i=3 ; i<p.length ; i+=2){
      if(p[i])hs.add((long)i*i);
    }
    for(int i=0 ; i<n ; i++){
      if(hs.contains(a[i]))System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var p : Sequence(boolean) ; p := Integer.subrange(1,1000001)->collect(false) ;
    p[0+1] := false ; 
    p[1+1] := false ; 
    p[2+1] := true ; 
        var i : int ; i := 3 ; while i < p->size() do (     p[i+1] := true ;  ;     i := i+(2) ) ; 
        var i : int ; i := 3 ; while i < p->size() do ( (     if (p[i+1]) then (         var j : int ; j := 3 * i ; while j < p->size() do (     p[j+1] := false ;  ;     j := j+(2 * i) ) ) else skip )  ;     i := i+(2) ) ; 
    var hs : Set(long) ; hs := Set{} ;
    hs := hs->including(4L) ; 
        var i : int ; i := 3 ; while i < p->size() do ( (     if (p[i+1]) then     hs := hs->including(i->oclAsType(long) * i) ; else skip )  ;     i := i+(2) ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (hs->includes(a[i+1])) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class Main {
  static class Reader {
    static BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer=new StringTokenizer("");
    static String next()throws IOException {
      while(! tokenizer.hasMoreTokens()){
        tokenizer=new StringTokenizer(reader.readLine());
      }
      return tokenizer.nextToken();
    }
    static int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    static double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    static long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
  static boolean[] isPrime=new boolean[1000005];
  static int[] prime=new int[1000005];
  public static void aiPrime(int n){
    Arrays.fill(isPrime,true);
    isPrime[1]=false ;
    int cnt=0 ;
    for(int i=2 ; i<=n ; i++){
      if(isPrime[i])prime[++cnt]=i ;
      for(int j=1 ; j<=cnt && i*prime[j]<=n ; j++){
        isPrime[i*prime[j] ]=false ;
        if(i % prime[j]==0)break ;
      }
    }
  }
  static Reader scanner=new Reader();
  static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws IOException {
    aiPrime(1000000);
    int n ;
    n=scanner.nextInt();
    for(int i=1 ; i<=n ; i++){
      long x=scanner.nextLong();
      int sq=(int)Math.sqrt((double)x);
      if((x % sq==0)&&(x/sq==sq)&&(isPrime[sq])){
        out.println("YES");
        out.flush();
      }
      else {
        out.println("NO");
        out.flush();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Reader {
  static   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute tokenizer : OclIterator := OclIterator.newOclIterator_String("");
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   attribute isPrime : Sequence(boolean) := Integer.subrange(1,1000005)->collect(false);
  static   attribute prime : Sequence(int) := Integer.subrange(1,1000005)->collect(0);
  static   operation aiPrime( n : int) : void
  pre: true
  post: true
  activity: (     isPrime := isPrime->collect(true) ; 
     isPrime[1+1] := false ; 
     var cnt : int ; cnt := 0 ;
         var i : int ; i := 2 ; while i <= n do ( (     if (isPrime[i+1]) then         cnt := cnt + 1 ;
 prime[cnt+1] := i  ; else skip ; 
         var j : int ; j := 1 ; while j <= cnt & i * prime[j+1] <= n do ( (     isPrime[i * prime[j+1]+1] := false ; 
     if (i mod prime[j+1] = 0) then     break else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   attribute scanner : OclFile := OclFile();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute aiPrime(1000000) ; 
     var n : int ;
     n := scanner.getCurrent()->toInteger() ; 
         var i : int ; i := 1 ; while i <= n do ( (     var x : long ; x := scanner.getCurrent()->toLong() ;
     var sq : int ; sq := (x->oclAsType(double))->sqrt()->oclAsType(int) ;
     if ((x mod sq = 0) & (x / sq = sq) & (isPrime[sq+1])) then (     skip ; 
     skip ) else (     skip ; 
     skip ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class SubsequencePermutation {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int testCase=scanner.nextInt()*2 ;
    String[] temp=new String[testCase];
    for(int i=0 ; i<testCase ; i++){
      temp[i]=scanner.next();
    }
    for(int i=1 ; i<temp.length ; i=i+2){
      System.out.println(solve(temp[i]));
    }
  }
  private static int solve(String val){
    char[] tempChar=val.toCharArray();
    Arrays.sort(tempChar);
    int count=0 ;
    for(int i=0 ; i<val.length(); i++){
      if(val.charAt(i)!=tempChar[i]){
        count++;
      }
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class SubsequencePermutation {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCase : int ; testCase := scanner.getCurrent()->toInteger() * 2 ;
    var temp : Sequence(String) ; temp := Integer.subrange(1,testCase)->collect(null) ;
        var i : int ; i := 0 ; while i < testCase do ( (     temp[i+1] := scanner.getCurrent() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < temp->size() do ( (     OclFile["System.out"].println(solve(temp[i+1])) )  ;     i := i + 2 ) ; 
 );
  static   operation solve( val : String) : int
  pre: true
  post: true
  activity: (     var tempChar : Sequence(String) ; tempChar := val->characters() ;
     tempChar := tempChar->sort() ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < val->size() do ( (     if (val->at(i+1) /= tempChar[i+1]) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    return count 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class Main {
  static class Reader {
    static BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer=new StringTokenizer("");
    static String next()throws IOException {
      while(! tokenizer.hasMoreTokens()){
        tokenizer=new StringTokenizer(reader.readLine());
      }
      return tokenizer.nextToken();
    }
    static int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    static double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    static long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
  static boolean[] isPrime=new boolean[1000005];
  public static void aiPrime(int n){
    Arrays.fill(isPrime,true);
    isPrime[1]=false ;
    for(int i=2 ; i<=n ; i++){
      if(isPrime[i]){
        for(int j=2 ; j*i<=n ; j++){
          isPrime[i*j]=false ;
        }
      }
    }
  }
  static Reader scanner=new Reader();
  static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws IOException {
    aiPrime(1000000);
    int n ;
    n=scanner.nextInt();
    for(int i=1 ; i<=n ; i++){
      long x=scanner.nextLong();
      int sq=(int)Math.sqrt((double)x);
      if((x % sq==0)&&(x/sq==sq)&&(isPrime[sq])){
        out.println("YES");
        out.flush();
      }
      else {
        out.println("NO");
        out.flush();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Reader {
  static   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute tokenizer : OclIterator := OclIterator.newOclIterator_String("");
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   attribute isPrime : Sequence(boolean) := Integer.subrange(1,1000005)->collect(false);
  static   operation aiPrime( n : int) : void
  pre: true
  post: true
  activity: (     isPrime := isPrime->collect(true) ; 
     isPrime[1+1] := false ; 
         var i : int ; i := 2 ; while i <= n do ( (     if (isPrime[i+1]) then (         var j : int ; j := 2 ; while j * i <= n do ( (     isPrime[i * j+1] := false )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) );
  static   attribute scanner : OclFile := OclFile();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute aiPrime(1000000) ; 
     var n : int ;
     n := scanner.getCurrent()->toInteger() ; 
         var i : int ; i := 1 ; while i <= n do ( (     var x : long ; x := scanner.getCurrent()->toLong() ;
     var sq : int ; sq := (x->oclAsType(double))->sqrt()->oclAsType(int) ;
     if ((x mod sq = 0) & (x / sq = sq) & (isPrime[sq+1])) then (     skip ; 
     skip ) else (     skip ; 
     skip ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    boolean[] ara=new boolean[1000001];
    for(int i=2 ; i<=1000 ; i++){
      if(! ara[i]){
        for(int j=2*i ; j<ara.length ; j+=i){
          ara[j]=true ;
        }
      }
    }
    ara[1]=true ;
    for(int i=0 ; i<n ; i++){
      long num=in.nextLong();
      if(Math.sqrt(num)% 1==0 && ! ara[(int)Math.sqrt(num)]){
        pw.println("YES");
      }
      else {
        pw.println("NO");
      }
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var ara : Sequence(boolean) ; ara := Integer.subrange(1,1000001)->collect(false) ;
        var i : int ; i := 2 ; while i <= 1000 do ( (     if (not(ara[i+1])) then (         var j : int ; j := 2 * i ; while j < ara->size() do ( (     ara[j+1] := true )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    ara[1+1] := true ; 
        var i : int ; i := 0 ; while i < n do ( (     var num : long ; num := in.getCurrent()->toLong() ;
     if ((num)->sqrt() mod 1 = 0 & not(ara[(num)->sqrt()->oclAsType(int)+1])) then (     skip ) else (     skip ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double trianglearea(double a){
    if(a<0)return-1 ;
    double area=(3*Math.sqrt(3)*Math.pow(a,2))/4 ;
    return area ;
  }
  public static void main(String[] args){
    double a=6 ;
    System.out.println(trianglearea(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation trianglearea( a : double) : double
  pre: true
  post: true
  activity: (     if (a < 0) then     return -1 else skip ; 
     var area : double ; area := (3 * (3)->sqrt() * a->pow(2)) / 4 ;
     return area );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 6 ;
     OclFile["System.out"].println(trianglearea(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class GFG {
  public static int segments(int n,int[] p,int m){
    HashMap<Integer,Integer>c=new HashMap<>();
    c.put(0,1);
    boolean has=false ;
    int sum=0 ;
    int ans=0 ;
    for(int r=0 ; r<n ; r++){
      if(p[r]<m)sum--;
      else if(p[r]>m)sum++;
      if(p[r]==m)has=true ;
      if(has)ans+=(c.get(sum)==null ? 0 : c.get(sum))+(c.get(sum-1)==null ? 0 : c.get(sum-1));
      else c.put(sum,c.get(sum)==null ? 1 : c.get(sum)+1);
    }
    return ans ;
  }
  public static void main(String[] args){
    int[] a={
      2,4,5,3,1 };
      int n=a.length ;
      int m=4 ;
      System.out.println(segments(n,a,m));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation segments( n : int, p : Sequence(int), m : int) : int
  pre: true
  post: true
  activity: (     var c : Map(int,int) ; c := Map{} ;
     c := c->union(Map{0 |-> 1}) ; 
    var has : boolean ; has := false ;
    var sum : int ; sum := 0 ;
    var ans : int ; ans := 0 ;
        var r : int ; r := 0 ; while r < n do ( (     if (p[r+1] < m) then     sum := sum - 1 else     if (p[r+1] > m) then     sum := sum + 1 ; else skip ; ;  
     if (p[r+1] = m) then     has := true ; else skip ; 
     if (has) then     ans := ans+((if c->at(sum) = null then 0 else c->at(sum) endif) + (if c->at(sum - 1) = null then 0 else c->at(sum - 1) endif)) ; else     c := c->union(Map{sum |-> if c->at(sum) = null then 1 else c->at(sum) + 1 endif}) ; )  ;     r := r + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,4,5,3,1} ;
     var n : int ; n := a->size() ;
     var m : int ; m := 4 ;
     OclFile["System.out"].println(segments(n, a, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemD {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    String line[]=br.readLine().split(" ");
    int n=Integer.parseInt(line[0]);
    int k=Integer.parseInt(line[1]);
    line=br.readLine().split(" ");
    int arr[]=new int[n];
    HashMap<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(line[i]);
      map.put(arr[i] % k,map.getOrDefault(arr[i] % k,0)+1);
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int parity=arr[i] % k ;
      if((parity==0 || parity==k-parity)&& map.containsKey(parity)){
        if(map.get(parity)>1){
          count+=2 ;
          map.put(parity,map.get(parity)-2);
        }
      }
      else if(map.containsKey(k-parity)){
        if(parity!=k-parity){
          if(map.get(parity)>0 && map.get(k-parity)>0){
            count+=2 ;
            map.put(parity,map.get(parity)-1);
            map.put(k-parity,map.get(k-parity)-1);
          }
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemD {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var n : int ; n := (line[0+1])->toInteger() ;
    var k : int ; k := (line[1+1])->toInteger() ;
    line := br.readLine()->split(" ") ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (line[i+1])->toInteger() ; 
     map := map->union(Map{arr[i+1] mod k |-> (if map->keys()->contains(arr[i+1] mod k) then map->at(arr[i+1] mod k) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var parity : int ; parity := arr[i+1] mod k ;
     if ((parity = 0 or parity = k - parity) & map->keys()->includes(parity)) then (     if (map->at(parity) > 1) then (     count := count+(2) ; 
     map := map->union(Map{parity |-> map->at(parity) - 2}) ) else skip ) else     if (map->keys()->includes(k - parity)) then (     if (parity /= k - parity) then (     if (map->at(parity) > 0 & map->at(k - parity) > 0) then (     count := count+(2) ; 
     map := map->union(Map{parity |-> map->at(parity) - 1}) ; 
     map := map->union(Map{k - parity |-> map->at(k - parity) - 1}) ) else skip ) else skip ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class practice {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int k=s.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=s.nextInt();
    }
    int res[]=new int[k];
    for(int i=0 ; i<arr.length ; i++){
      int a=arr[i] % k ;
      res[a]++;
    }
    int ans=res[0] % 2==0 ? res[0] : res[0]-1 ;
    int l=1 ;
    int h=k-1 ;
    while(l<h){
      ans+=2*(Math.min(res[l],res[h]));
      l++;
      h--;
    }
    if(k % 2==0){
      int p=k/2 ;
      ans+=res[p] % 2==0 ? res[p] : res[p]-1 ;
    }
    System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var k : int ; k := s.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var res : Sequence(int) ; res := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     var a : int ; a := arr[i+1] mod k ;
     res[a+1] := res[a+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := if res[0+1] mod 2 = 0 then res[0+1] else res[0+1] - 1 endif ;
    var l : int ; l := 1 ;
    var h : int ; h := k - 1 ;
    while (l < h) do (     ans := ans+(2 * (Set{res[l+1], res[h+1]}->min())) ; 
     l := l + 1 ; 
     h := h - 1 ) ; 
    if (k mod 2 = 0) then (     var p : int ; p := k / 2 ;
     ans := ans+(if res[p+1] mod 2 = 0 then res[p+1] else res[p+1] - 1 endif) ) else skip ; 
    OclFile["System.out"].print(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String check(int[] arr,int n){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if((arr[i] & 1)!=0)count++;
    }
    if((count & 1)!=0)return "Odd" ;
    else return "Even" ;
  }
  public static void main(String args[]){
    int[] arr={
      3,9,12,13,15 };
      int n=arr.length ;
      System.out.println(check(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( arr : Sequence(int), n : int) : String
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if ((arr[i+1] & 1) /= 0) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     if ((MathLib.bitwiseAnd(count,1)) /= 0) then     return "Odd" else     return "Even" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,9,12,13,15} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(check(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int s=sc.nextInt();
    int n=sc.nextInt();
    int[] arr1=new int[n];
    int[] arr2=new int[n];
    for(int i=0 ; i<n ; i++){
      arr1[i]=sc.nextInt();
      arr2[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      if(s>arr1[i]){
        s+=arr2[i];
        arr1[i]=arr1[n-1];
        arr2[i]=arr2[n-1];
        n--;
        i=-1 ;
      }
    }
    System.out.print(n==0 ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : int ; s := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr1[i+1] := sc.getCurrent()->toInteger() ; 
     arr2[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (s > arr1[i+1]) then (     s := s+(arr2[i+1]) ; 
     arr1[i+1] := arr1[n - 1+1] ; 
    arr2[i+1] := arr2[n - 1+1] ; 
    n := n - 1 ; 
    i := -1 ; 
 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(if n = 0 then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Code {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int s=sc.nextInt();
    int n=sc.nextInt();
    int[][] dragons=new int[n][2];
    for(int i=0 ; i<n ; i+=1){
      dragons[i][0]=sc.nextInt();
      dragons[i][1]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i+=1){
      if(s>dragons[i][0]){
        s+=dragons[i][1];
        dragons[i]=dragons[n-1];
        n-=1 ;
        i=-1 ;
      }
    }
    if(n==0){
      System.out.print("YES");
    }
    else {
      System.out.print("NO");
    };
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : int ; s := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var dragons : Sequence(Sequence(int)) ; dragons := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     dragons[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     dragons[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i+(1) ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (s > dragons[i+1][0+1]) then (     s := s+(dragons[i+1][1+1]) ; 
     dragons[i+1] := dragons[n - 1+1] ; 
     n := n-(1) ; 
     i := -1 ) else skip )  ;     i := i+(1) ) ; 
    if (n = 0) then (     OclFile["System.out"].print("YES") ) else (     OclFile["System.out"].print("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    System.out.println(askAndCheck(new Scanner(System.in))? "YES" : "NO");
  }
  public static boolean askAndCheck(Scanner scanner){
    String[] firstLine=scanner.nextLine().split(" ");
    int s=Integer.parseInt(firstLine[0]);
    int n=Integer.parseInt(firstLine[1]);
    int[][] numbers=stringToIntMatrix(scanner,n);
    return isPossibleWin(s,numbers);
  }
  private static boolean isPossibleWin(int s,int[][] numbers){
    Arrays.sort(numbers,Comparator.comparingInt(o->o[0]));
    for(int[] xY : numbers){
      if(xY[0]>=s){
        return false ;
      }
      s+=xY[1];
    }
    return true ;
  }
  public static int[][] stringToIntMatrix(Scanner scanner,int n){
    int[][] array=new int[n][];
    for(int i=0 ; i<n ; i++){
      String[] numbers=scanner.nextLine().split(" ");
      array[i]=new int[] {
        Integer.parseInt(numbers[0]),Integer.parseInt(numbers[1])};
      }
      return array ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if askAndCheck(OclFile.newOclFile_Read(OclFile["System.in"])) then "YES" else "NO" endif) );
  static   operation askAndCheck( scanner : OclFile) : boolean
  pre: true
  post: true
  activity: (     var firstLine : Sequence(String) ; firstLine := scanner.nextLine()->split(" ") ;
     var s : int ; s := (firstLine[0+1])->toInteger() ;
    var n : int ; n := (firstLine[1+1])->toInteger() ;
    var numbers : Sequence(Sequence(int)) ; numbers := stringToIntMatrix(scanner, n) ;
    return isPossibleWin(s, numbers) 
 );
  static   operation isPossibleWin( s : int, numbers : Sequence(Sequence(int))) : boolean
  pre: true
  post: true
  activity: (     numbers := OclComparator.sortWith(numbers, Comparator.comparingInt(lambda o : OclAny in o[0+1])) ; 
     for (xY : numbers) do ( (     if (xY[0+1] >= s) then (     return false ) else skip ; 
     s := s+(xY[1+1]) )  ) ; 
     return true );
  static   operation stringToIntMatrix( scanner : OclFile, n : int) : Sequence(Sequence(int))
  pre: true
  post: true
  activity: (     var array : Sequence(Sequence(int)) ; array := Integer.subrange(1,n)->collect(Sequence{}) ;
         var i : int ; i := 0 ; while i < n do ( (     var numbers : Sequence(String) ; numbers := scanner.nextLine()->split(" ") ;
     array[i+1] := Sequence{(numbers[0+1])->toInteger(),(numbers[1+1])->toInteger()} )  ;     i := i + 1 ) ; 
     return array );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long sumAP(long n,long d){
    n/=d ;
    return(n)*(1+n)*d/2 ;
  }
  static long sumMultiples(long n){
    n--;
    return sumAP(n,2)+sumAP(n,5)-sumAP(n,10);
  }
  public static void main(String[] args){
    long n=20 ;
    System.out.println(sumMultiples(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumAP( n : long, d : long) : long
  pre: true
  post: true
  activity: (     n := n/(d) ; 
     return (n) * (1 + n) * d / 2 );
  static   operation sumMultiples( n : long) : long
  pre: true
  post: true
  activity: (     n := n - 1 ; 
     return sumAP(n, 2) + sumAP(n, 5) - sumAP(n, 10) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 20 ;
     OclFile["System.out"].println(sumMultiples(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class S {
  public static void main(String[] args){
    java.util.Scanner scanner=new java.util.Scanner(System.in);
    int s=scanner.nextInt();
    int n=scanner.nextInt();
    Dragon[] dragons=new Dragon[n];
    for(int i=0 ; i<dragons.length ; i++){
      int x=scanner.nextInt();
      int y=scanner.nextInt();
      dragons[i]=new Dragon(x,y);
    }
    sort(dragons);
    for(Dragon dragon : dragons){
      if(s<=dragon.force){
        System.out.println("NO");
        return ;
      }
      s+=dragon.prize ;
    }
    System.out.println("YES");
  }
  private static void sort(Dragon[] dragons){
    for(int i=0 ; i<dragons.length-1 ; i++){
      for(int j=0 ; j<dragons.length-1 ; j++){
        if(dragons[j] .force>dragons[j+1] .force){
          Dragon tmp=dragons[j];
          dragons[j]=dragons[j+1];
          dragons[j+1]=tmp ;
        }
      }
    }
  }
  static class Dragon {
    public int force ;
    public int prize ;
    public Dragon(int force,int prize){
      this.force=force ;
      this.prize=prize ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class S {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : Scanner ; scanner := Scanner.newScanner(OclFile["System.in"]) ;
     var s : int ; s := scanner.nextInt() ;
    var n : int ; n := scanner.nextInt() ;
    var dragons : Sequence(Dragon) ; dragons := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < dragons->size() do ( (     var x : int ; x := scanner.nextInt() ;
     var y : int ; y := scanner.nextInt() ;
     dragons[i+1] := Dragon.newDragon(x, y) )  ;     i := i + 1 ) ; 
    execute sort(dragons) ; 
    for (dragon : dragons) do ( (     if (s <= dragon.force) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
     s := s+(dragon.prize) )  ) ; 
    OclFile["System.out"].println("YES") ; 
 );
  static   operation sort( dragons : Sequence(Dragon)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < dragons->size() - 1 do ( (         var j : int ; j := 0 ; while j < dragons->size() - 1 do ( (     if (dragons[j+1].force > dragons[j + 1+1].force) then (     var tmp : Dragon ; tmp := dragons[j+1] ;
     dragons[j+1] := dragons[j + 1+1] ; 
     dragons[j + 1+1] := tmp ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static class Dragon {
   attribute force : int;
   attribute prize : int;
   static operation newDragon( force : int, prize : int) : Dragon
  pre: true
  post: true
  activity:
  ( var self : Dragon ;
    self := createDragon();
    self.initialise(force, prize);
    return self );
  operation initialise( force : int, prize : int) : void
  pre: true  post: true
  activity: (     self.force := force ; 
     self.prize := prize );
}
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
class GFG {
  public static int countOrderedPairs(int[] A,int n){
    int orderedPairs=0 ;
    HashMap<Integer,Integer>m=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(m.get(A[i])==null)m.put(A[i],1);
      else {
        int a=m.get(A[i]);
        m.put(A[i],++a);
      }
    }
    for(int entry : m.keySet()){
      int X=entry ;
      int Y=m.get(entry);
      for(int j=1 ; j<=Y ; j++){
        if(m.get(j)>=X)orderedPairs++;
      }
    }
    return orderedPairs ;
  }
  public static void main(String[] args){
    int[] A={
      1,1,2,2,3 };
      int n=A.length ;
      System.out.print(countOrderedPairs(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countOrderedPairs( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var orderedPairs : int ; orderedPairs := 0 ;
     var m : Map(int,int) ; m := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (m->at(A[i+1]) = null) then     m := m->union(Map{A[i+1] |-> 1}) ; else (     var a : int ; a := m->at(A[i+1]) ;
     m := m->union(Map{A[i+1] |-> (a + 1)}) ) )  ;     i := i + 1 ) ; 
    for (entry : m->keys()) do ( (     var X : int ; X := entry ;
     var Y : int ; Y := m->at(entry) ;
         var j : int ; j := 1 ; while j <= Y do ( (     if (m->at(j) >= X) then     orderedPairs := orderedPairs + 1 ; else skip )  ;     j := j + 1 ) )  ) ; 
    return orderedPairs 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{1,1,2,2,3} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].print(countOrderedPairs(A, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minimumflip(int mat[][],int n){
    int flip=0 ;
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<i ; j++)if(mat[i][j]!=mat[j][i])flip++;
    return flip ;
  }
  public static void main(String[] args){
    int n=3 ;
    int mat[][]={
      {
        0,0,1 },{
          1,1,1 },{
            1,0,0 }
          };
          System.out.println(minimumflip(mat,n));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumflip( mat : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     var flip : int ; flip := 0 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < i do (     if (mat[i+1][j+1] /= mat[j+1][i+1]) then     flip := flip + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return flip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{0,0,1},Sequence{1,1,1},Sequence{1,0,0}} ;
     OclFile["System.out"].println(minimumflip(mat, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static final int NO_OF_CHARS=256 ;
  static void printDistinct(String str){
    int[] count=new int[NO_OF_CHARS];
    int i ;
    for(i=0 ; i<str.length(); i++)if(str.charAt(i)!=' ')count[(int)str.charAt(i)]++;
    int n=i ;
    for(i=0 ; i<n ; i++)if(count[(int)str.charAt(i)]==1)System.out.print(str.charAt(i));
  }
  public static void main(String args[]){
    String str="GeeksforGeeks" ;
    printDistinct(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute NO_OF_CHARS : int := 256;
  static   operation printDistinct( str : String) : void
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,NO_OF_CHARS)->collect(0) ;
     var i : int ;
        i := 0 ; while i < str->size() do (     if (str->at(i+1) /= ' ') then     count[str->at(i+1)->oclAsType(int)+1] := count[str->at(i+1)->oclAsType(int)+1] + 1 ; else skip ;  ;     i := i + 1 ) ; 
    var n : int ; n := i ;
        i := 0 ; while i < n do (     if (count[str->at(i+1)->oclAsType(int)+1] = 1) then     OclFile["System.out"].print(str->at(i+1)) ; else skip ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GeeksforGeeks" ;
     execute printDistinct(str) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  static final int MAX_X=2000 ;
  static final int MAX_Y=2000 ;
  int[][] s=new int[MAX_X][MAX_Y];
  void solve(){
    for(int i=0 ; i<MAX_X ; ++i)for(int j=0 ; j<MAX_Y ; ++j)s[i][j]=0 ;
    Scanner sc=new Scanner(System.in);
    for(int k=0 ; k<2 ; ++k){
      int x=sc.nextInt();
      int y=sc.nextInt();
      int w=sc.nextInt();
      int h=sc.nextInt();
      for(int i=x ; i<x+w ; ++i)for(int j=y ; j<y+h ; ++j)++s[i][j];
    }
    int c=0 ;
    for(int i=0 ; i<MAX_X ; ++i)for(int j=0 ; j<MAX_Y ; ++j)if(s[i][j]==1)++c ;
    System.out.println(c);
  }
  public static void main(String[] a){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX_X : int := 2000;
  static    attribute MAX_Y : int := 2000;
   attribute s : Sequence(Sequence(int)) := Integer.subrange(1,MAX_X)->collect(Integer.subrange(1,MAX_Y)->collect(0));
   operation solve() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < MAX_X do (         var j : int ; j := 0 ; while j < MAX_Y do (     s[i+1][j+1] := 0 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
        var k : int ; k := 0 ; while k < 2 do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
        var i : int ; i := x ; while i < x + w do (         var j : int ; j := y ; while j < y + h do (     s[i+1][j+1] := s[i+1][j+1] + 1 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
 )  ;     k := k + 1 ) ; 
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < MAX_X do (         var j : int ; j := 0 ; while j < MAX_Y do (     if (s[i+1][j+1] = 1) then     c := c + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
public class Main {
  static Scanner scan=new Scanner(System.in);
  public static void main(String[] args){
    List<Integer>MN=numbers();
    List<Integer>mn=numbers();
    print((MN.get(0)-mn.get(0))*(MN.get(1)-mn.get(1)));
  }
  public static List<Integer>numbers(){
    List<Integer>integers=new ArrayList<>();
    for(String item : getLine().split(" ")){
      integers.add(toInt(item));
    }
    return integers ;
  }
  public static void add(int[][] a,int[] n,int[] m){
    for(int i=0 ; i<n.length ; i++){
    }
  }
  public static int sum(int[][] a,int[] n,int[] m){
    int sum=0 ;
    for(int i=0 ; i<n.length ; i++){
      for(int j=0 ; j<m.length ; j++){
        if(n[i]==1 && m[j]==1){
          sum+=a[i][j];
        }
      }
    }
    return sum ;
  }
  public static int getInt(){
    return scan.nextInt();
  }
  public static String getLine(){
    return scan.nextLine();
  }
  public static int toInt(String str){
    return Integer.parseInt(str);
  }
  public static long toLong(String str){
    return Long.parseLong(str);
  }
  public static void print(String str){
    System.out.println(str);
  }
  public static void print(int num){
    print(""+num);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var MN : Sequence(int) ; MN := numbers() ;
     var mn : Sequence(int) ; mn := numbers() ;
     execute print((MN->at(0+1) - mn->at(0+1)) * (MN->at(1+1) - mn->at(1+1))) );
  static   operation numbers() : Sequence(int)
  pre: true
  post: true
  activity: (     var integers : Sequence(int) ; integers := Sequence{} ;
     for (item : getLine()->split(" ")) do ( (     integers := integers->including(toInt(item)) )  ) ; 
     return integers );
  static   operation add( a : Sequence(Sequence(int)), n : Sequence(int), m : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n->size() do ( skip  ;     i := i + 1 ) );
  static   operation sum( a : Sequence(Sequence(int)), n : Sequence(int), m : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n->size() do ( (         var j : int ; j := 0 ; while j < m->size() do ( (     if (n[i+1] = 1 & m[j+1] = 1) then (     sum := sum+(a[i+1][j+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return scan.getCurrent()->toInteger() );
  static   operation getLine() : String
  pre: true
  post: true
  activity: (     return scan.nextLine() );
  static   operation toInt( str : String) : int
  pre: true
  post: true
  activity: (     return (str)->toInteger() );
  static   operation toLong( str : String) : long
  pre: true
  post: true
  activity: (     return (str)->toLong() );
  static   operation print( str : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(str) );
  static   operation print( num : int) : void
  pre: true
  post: true
  activity: (     execute print("" + num) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    AWhiteCells solver=new AWhiteCells();
    solver.solve(1,in,out);
    out.close();
  }
  static class AWhiteCells {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int W=in.nextInt();
      int H=in.nextInt();
      int w=in.nextInt();
      int h=in.nextInt();
      out.print((W-w)*(H-h));
    }
  }
  static class InputReader implements AutoCloseable {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public void close(){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : AWhiteCells ; solver := AWhiteCells.newAWhiteCells() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class AWhiteCells {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var W : int ; W := in.nextInt() ;
     var H : int ; H := in.nextInt() ;
    var w : int ; w := in.nextInt() ;
    var h : int ; h := in.nextInt() ;
    skip ; 
 );
}
  static class InputReader implements AutoCloseable {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation close() : void
  pre: true
  post: true
  activity: skip;
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int height,width,black_height,black_width,area ;
    height=Integer.parseInt(sc.next());
    width=Integer.parseInt(sc.next());
    black_height=Integer.parseInt(sc.next());
    black_width=Integer.parseInt(sc.next());
    area=(height-black_height)*(width-black_width);
    System.out.println(area);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var height : int ;
    var width : int ;
    var black_height : int ;
    var black_width : int ;
    var area : int ;
    height := (sc.getCurrent())->toInteger() ; 
    width := (sc.getCurrent())->toInteger() ; 
    black_height := (sc.getCurrent())->toInteger() ; 
    black_width := (sc.getCurrent())->toInteger() ; 
    area := (height - black_height) * (width - black_width) ; 
    OclFile["System.out"].println(area) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int h=sc.nextInt();
    int w=sc.nextInt();
    out.println(n*m-h*m-w*n+h*w);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    out.println(n * m - h * m - w * n + h * w) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int row=sc.nextInt();
    int column=sc.nextInt();
    int blackRow=sc.nextInt();
    int blackColumn=sc.nextInt();
    int blackCount=(row*blackColumn+column*blackRow)-(blackRow*blackColumn);
    int allWhite=row*column ;
    System.out.println(allWhite-blackCount);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var row : int ; row := sc.getCurrent()->toInteger() ;
    var column : int ; column := sc.getCurrent()->toInteger() ;
    var blackRow : int ; blackRow := sc.getCurrent()->toInteger() ;
    var blackColumn : int ; blackColumn := sc.getCurrent()->toInteger() ;
    var blackCount : int ; blackCount := (row * blackColumn + column * blackRow) - (blackRow * blackColumn) ;
    var allWhite : int ; allWhite := row * column ;
    OclFile["System.out"].println(allWhite - blackCount) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    while(t>0){
      int n=scan.nextInt();
      int s ;
      int f ;
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        s=scan.nextInt();
        f=scan.nextInt();
        sum+=f-s ;
      }
      if(t<=sum){
        System.out.println("OK");
      }
      else {
        System.out.println(t-sum);
      }
      t=scan.nextInt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var s : int ;
    var f : int ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     s := scan.getCurrent()->toInteger() ; 
     f := scan.getCurrent()->toInteger() ; 
     sum := sum+(f - s) )  ;     i := i + 1 ) ; 
    if (t <= sum) then (     OclFile["System.out"].println("OK") ) else (     OclFile["System.out"].println(t - sum) ) ;  
    t := scan.getCurrent()->toInteger() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static void divide(int n,int m){
    System.out.println("Remainder="+((n)&(m-1)));
    System.out.println("Quotient="+(n>>(int)(Math.log(m)/Math.log(2))));
  }
  static public void main(String[] args){
    int n=43,m=8 ;
    divide(n,m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation divide( n : int, m : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Remainder=" + ((n) & (m - 1))) ; 
     OclFile["System.out"].println("Quotient=" + ((n/(2->pow(((m)->log() / (2)->log())->oclAsType(int))))->oclAsType(long))) );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 43 ;
    var m : int ; m := 8 ;
     execute divide(n, m) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Comparator ;
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    double threshold=1e-6 ;
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[][] f=new int[n][2];
    for(int i=0 ; i<n ; i++){
      f[i][0]=scan.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      f[i][1]=scan.nextInt();
    }
    Comparator<int[]>comparator=Comparator.comparingInt(o->o[0]);
    double lo=0 ;
    double hi=1e9 ;
    double prev=-1 ;
    while(lo<=hi){
      double mid=lo+(hi-lo)/2 ;
      boolean can=true ;
      double min=1e-9 ;
      double max=1e9 ;
      for(int i=0 ; i<f.length ; i++){
        int c=f[i][0];
        int s=f[i][1];
        double localMin=c-s*mid ;
        double localMax=c+s*mid ;
        if(localMin<=max && localMin>=min || localMax>=min && localMax<=max || localMax>=max && localMin<=min){
          max=Math.min(max,localMax);
          min=Math.max(min,localMin);
        }
        else {
          can=false ;
          break ;
        }
      }
      if(can){
        hi=mid ;
        if(Math.abs(mid-prev)<=threshold){
          break ;
        }
        else {
          prev=mid ;
        }
      }
      else {
        lo=mid ;
      }
    }
    System.out.println(lo);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var threshold : double ; threshold := 1e-6 ;
     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := scan.getCurrent()->toInteger() ;
    var f : Sequence(Sequence(int)) ; f := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     f[i+1][0+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     f[i+1][1+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var comparator : Function(<Sequence(int)>,(<Sequence(int)>,boolean)) ; comparator := Comparator.comparingInt(lambda o : OclAny in o[0+1]) ;
    var lo : double ; lo := 0 ;
    var hi : double ; hi := 1e9 ;
    var prev : double ; prev := -1 ;
    while (lo <= hi) do (     var mid : double ; mid := lo + (hi - lo) / 2 ;
     var can : boolean ; can := true ;
    var min : double ; min := 1e-9 ;
    var max : double ; max := 1e9 ;
        var i : int ; i := 0 ; while i < f->size() do ( (     var c : int ; c := f[i+1][0+1] ;
     var s : int ; s := f[i+1][1+1] ;
    var localMin : double ; localMin := c - s * mid ;
    var localMax : double ; localMax := c + s * mid ;
    if (localMin <= max & localMin >= min or localMax >= min & localMax <= max or localMax >= max & localMin <= min) then (     max := Set{max, localMax}->min() ; 
     min := Set{min, localMin}->max() ) else (     can := false ; 
     break ) ;  
 )  ;     i := i + 1 ) ; 
    if (can) then (     hi := mid ; 
     if (if mid - prev < 0 then -(mid - prev) else mid - prev endif <= threshold) then (     break ) else (     prev := mid ) ) else (     lo := mid ) ;  
 ) ; 
    OclFile["System.out"].println(lo) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MeetingPlace {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int[] xs=new int[n];
    int[] vs=new int[n];
    int minx=Integer.MAX_VALUE ;
    int maxx=0 ;
    StringTokenizer st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<n ; i++){
      xs[i]=Integer.parseInt(st.nextToken());
      if(xs[i]>maxx)maxx=xs[i];
      if(xs[i]<minx)minx=xs[i];
    }
    st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<n ; i++)vs[i]=Integer.parseInt(st.nextToken());
    double left=minx ;
    double right=maxx ;
    double mid=(left+right)/2 ;
    double lt,rt,mt ;
    while(true){
      mt=calcTime(xs,vs,mid);
      lt=calcTime(xs,vs,(left+mid)/2);
      rt=calcTime(xs,vs,(right+mid)/2);
      if((mid-left)/2<1.0e-6){
        System.out.println(mt);
        break ;
      }
      if(calcTime(xs,vs,mid-1e-6)<calcTime(xs,vs,mid+1e-6)){
        right=mid ;
        mid=(left+right)/2 ;
      }
      else {
        left=mid ;
        mid=(left+right)/2 ;
      }
    }
  }
  public static double calcTime(int[] xs,int[] vs,double pos){
    double maxt=0 ;
    for(int i=0 ; i<xs.length ; i++)if(Math.abs(xs[i]-pos)/vs[i]>maxt)maxt=Math.abs(xs[i]-pos)/vs[i];
    return maxt ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class MeetingPlace {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var xs : Sequence(int) ; xs := Integer.subrange(1,n)->collect(0) ;
    var vs : Sequence(int) ; vs := Integer.subrange(1,n)->collect(0) ;
    var minx : int ; minx := 2147483647 ;
    var maxx : int ; maxx := 0 ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < n do ( (     xs[i+1] := (st.next())->toInteger() ; 
     if (xs[i+1] > maxx) then     maxx := xs[i+1] ; else skip ; 
     if (xs[i+1] < minx) then     minx := xs[i+1] ; else skip )  ;     i := i + 1 ) ; 
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < n do (     vs[i+1] := (st.next())->toInteger() ;  ;     i := i + 1 ) ; 
    var left : double ; left := minx ;
    var right : double ; right := maxx ;
    var mid : double ; mid := (left + right) / 2 ;
    var lt : double ;
    var rt : double ;
    var mt : double ;
    while (true) do (     mt := calcTime(xs, vs, mid) ; 
     lt := calcTime(xs, vs, (left + mid) / 2) ; 
    rt := calcTime(xs, vs, (right + mid) / 2) ; 
    if ((mid - left) / 2 < 1.0e-6) then (     OclFile["System.out"].println(mt) ; 
     break ) else skip ; 
    if (calcTime(xs, vs, mid - 1e-6) < calcTime(xs, vs, mid + 1e-6)) then (     right := mid ; 
     mid := (left + right) / 2 ) else (     left := mid ; 
     mid := (left + right) / 2 ) ;  
 ) ; 
 );
  static   operation calcTime( xs : Sequence(int), vs : Sequence(int), pos : double) : double
  pre: true
  post: true
  activity: (     var maxt : double ; maxt := 0 ;
         var i : int ; i := 0 ; while i < xs->size() do (     if (if xs[i+1] - pos < 0 then -(xs[i+1] - pos) else xs[i+1] - pos endif / vs[i+1] > maxt) then     maxt := if xs[i+1] - pos < 0 then -(xs[i+1] - pos) else xs[i+1] - pos endif / vs[i+1] ; else skip ;  ;     i := i + 1 ) ; 
     return maxt );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int distinct(int[] arr,int n){
    int count=0 ;
    if(n==1)return 1 ;
    for(int i=0 ; i<n-1 ; i++){
      if(i==0){
        if(arr[i]!=arr[i+1])count+=1 ;
      }
      else {
        if(arr[i]!=arr[i+1] || arr[i]!=arr[i-1])count+=1 ;
      }
    }
    if(arr[n-1]!=arr[n-2])count+=1 ;
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      0,0,0,0,0,1,0 };
      int n=arr.length ;
      System.out.println(distinct(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation distinct( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     if (n = 1) then     return 1 else skip ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (i = 0) then (     if (arr[i+1] /= arr[i + 1+1]) then     count := count+(1) ; else skip ) else (     if (arr[i+1] /= arr[i + 1+1] or arr[i+1] /= arr[i - 1+1]) then     count := count+(1) ; else skip ) )  ;     i := i + 1 ) ; 
    if (arr[n - 1+1] /= arr[n - 2+1]) then     count := count+(1) ; else skip ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,0,0,0,0,1,0} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(distinct(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maxSubArraySumRepeated(int a[],int n,int k){
    int max_so_far=0 ;
    int INT_MIN,max_ending_here=0 ;
    for(int i=0 ; i<n*k ; i++){
      max_ending_here=max_ending_here+a[i % n];
      if(max_so_far<max_ending_here)max_so_far=max_ending_here ;
      if(max_ending_here<0)max_ending_here=0 ;
    }
    return max_so_far ;
  }
  public static void main(String[] args){
    int a[]={
      10,20,-30,-1 };
      int n=a.length ;
      int k=3 ;
      System.out.println("Maximum contiguous sum is "+maxSubArraySumRepeated(a,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSubArraySumRepeated( a : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var max_so_far : int ; max_so_far := 0 ;
     var INT_MIN : int ;
    var max_ending_here : int ; max_ending_here := 0 ;
         var i : int ; i := 0 ; while i < n * k do ( (     max_ending_here := max_ending_here + a[i mod n+1] ; 
     if (max_so_far < max_ending_here) then     max_so_far := max_ending_here ; else skip ; 
     if (max_ending_here < 0) then     max_ending_here := 0 ; else skip )  ;     i := i + 1 ) ; 
     return max_so_far );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{10,20,-30,-1} ;
     var n : int ; n := a->size() ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println("Maximum contiguous sum is " + maxSubArraySumRepeated(a, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  long gcd(long a,long b){
    return b==0 ? a : gcd(b,a % b);
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      if((a | b | c)==0)break ;
      double D=b*b-4*a*c ;
      if(D<0)System.out.println("Impossible");
      else if(D==0){
        int A=2*a ;
        int B=-b ;
        long g=gcd(Math.abs(A),Math.abs(B));
        A/=g ;
        B/=g ;
        System.out.println(A+" "+(-B)+" "+A+" "+(-B));
      }
      else {
        int k=1 ;
        while(k*k<=D){
          if(k*k==D)break ;
          k++;
        }
        if(k*k>D){
          System.out.println("Impossible");
          continue ;
        }
        int P=2*a ;
        int Q=-b+k ;
        int R=2*a ;
        int S=-b-k ;
        long g=gcd(Math.abs(P),Math.abs(Q));
        P/=g ;
        Q/=g ;
        g=gcd(Math.abs(R),Math.abs(S));
        R/=g ;
        S/=g ;
        Q=-Q ;
        S=-S ;
        if(P>R ||(P==R && Q>S))System.out.println(P+" "+Q+" "+R+" "+S);
        else System.out.println(R+" "+S+" "+P+" "+Q);
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(a,b),c)) = 0) then     break else skip ; 
    var D : double ; D := b * b - 4 * a * c ;
    if (D < 0) then     OclFile["System.out"].println("Impossible") else     if (D = 0) then (     var A : int ; A := 2 * a ;
     var B : int ; B := -b ;
    var g : long ; g := gcd(if A < 0 then -(A) else A endif, if B < 0 then -(B) else B endif) ;
    A := A/(g) ; 
    B := B/(g) ; 
    OclFile["System.out"].println(A + " " + (-B) + " " + A + " " + (-B)) ; 
 ) else (     var k : int ; k := 1 ;
     while (k * k <= D) do (     if (k * k = D) then     break else skip ; 
     k := k + 1 ) ; 
    if (k * k > D) then (     OclFile["System.out"].println("Impossible") ; 
     continue ) else skip ; 
    var P : int ; P := 2 * a ;
    var Q : int ; Q := -b + k ;
    var R : int ; R := 2 * a ;
    var S : int ; S := -b - k ;
    var g : long ; g := gcd(if P < 0 then -(P) else P endif, if Q < 0 then -(Q) else Q endif) ;
    P := P/(g) ; 
    Q := Q/(g) ; 
    g := gcd(if R < 0 then -(R) else R endif, if S < 0 then -(S) else S endif) ; 
    R := R/(g) ; 
    S := S/(g) ; 
    Q := -Q ; 
    S := -S ; 
    if (P > R or (P = R & Q > S)) then     OclFile["System.out"].println(P + " " + Q + " " + R + " " + S) else     OclFile["System.out"].println(R + " " + S + " " + P + " " + Q) ; ;  
 ) ;  ;  
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.*;
import java.io.*;
import java.util.*;
public class Main {
  double EPS=1.0e-08 ;
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      if((a | b | c)==0)break ;
      int d=b*b-4*a*c ;
      int e=(int)Math.sqrt(d+EPS);
      if(e*e!=d){
        System.out.println("Impossible");
        continue ;
      }
      int res1=-b+e ;
      int res2=-b-e ;
      int aa=2*a ;
      int div=gcd(res1,aa);
      int p=aa/div ;
      int q=res1/div ;
      if(p*q<0){
        p=Math.abs(p);
        q=Math.abs(q);
      }
      else {
        p=Math.abs(p);
        q=Math.abs(q)*-1 ;
      }
      int div2=gcd(res2,aa);
      int r=aa/div2 ;
      int s=res2/div2 ;
      if(r*s<0){
        r=Math.abs(r);
        s=Math.abs(s);
      }
      else {
        r=Math.abs(r);
        s=Math.abs(s)*-1 ;
      }
      if(p>r ||(p==r && q>=s)){
        System.out.printf("%d %d %d %d\n",p,q,r,s);
      }
      else {
        System.out.printf("%d %d %d %d\n",r,s,p,q);
      }
    }
  }
  private int gcd(int a,int b){
    if(b==0)return a ;
    else return gcd(b,a % b);
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute EPS : double := 1.0e-08;
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(a,b),c)) = 0) then     break else skip ; 
    var d : int ; d := b * b - 4 * a * c ;
    var e : int ; e := (d + EPS)->sqrt()->oclAsType(int) ;
    if (e * e /= d) then (     OclFile["System.out"].println("Impossible") ; 
     continue ) else skip ; 
    var res1 : int ; res1 := -b + e ;
    var res2 : int ; res2 := -b - e ;
    var aa : int ; aa := 2 * a ;
    var div : int ; div := gcd(res1, aa) ;
    var p : int ; p := aa / div ;
    var q : int ; q := res1 / div ;
    if (p * q < 0) then (     p := if p < 0 then -(p) else p endif ; 
     q := if q < 0 then -(q) else q endif ) else (     p := if p < 0 then -(p) else p endif ; 
     q := if q < 0 then -(q) else q endif * -1 ) ;  
    var div2 : int ; div2 := gcd(res2, aa) ;
    var r : int ; r := aa / div2 ;
    var s : int ; s := res2 / div2 ;
    if (r * s < 0) then (     r := if r < 0 then -(r) else r endif ; 
     s := if s < 0 then -(s) else s endif ) else (     r := if r < 0 then -(r) else r endif ; 
     s := if s < 0 then -(s) else s endif * -1 ) ;  
    if (p > r or (p = r & q >= s)) then (     OclFile["System.out"].printf("%d %d %d %d\n", p, q, r, s) ) else (     OclFile["System.out"].printf("%d %d %d %d\n", r, s, p, q) ) ;  
 ) );
   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else     return gcd(b, a mod b) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static long SubArraySum(int arr[],int n){
    long result=0 ;
    for(int i=0 ; i<n ; i++)result+=(arr[i]*(i+1)*(n-i));
    return result ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3 };
      int n=arr.length ;
      System.out.println("Sum of SubArray "+SubArraySum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation SubArraySum( arr : Sequence(int), n : int) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 0 ;
         var i : int ; i := 0 ; while i < n do (     result := result+((arr[i+1] * (i + 1) * (n - i))) ;  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Sum of SubArray " + SubArraySum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static long SubArraySum(int arr[],int n){
    long result=0,temp=0 ;
    for(int i=0 ; i<n ; i++){
      temp=0 ;
      for(int j=i ; j<n ; j++){
        temp+=arr[j];
        result+=temp ;
      }
    }
    return result ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3 };
      int n=arr.length ;
      System.out.println("Sum of SubArray : "+SubArraySum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation SubArraySum( arr : Sequence(int), n : int) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 0 ;
    var temp : long ; temp := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     temp := 0 ; 
         var j : int ; j := i ; while j < n do ( (     temp := temp+(arr[j+1]) ; 
     result := result+(temp) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Sum of SubArray : " + SubArraySum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
class GFG {
  public static void checkType(int arr[],int n){
    if(arr[0]<=arr[1] && arr[n-2]<=arr[n-1])System.out.println("Increasing");
    else if(arr[0]>=arr[1] && arr[n-2]>=arr[n-1])System.out.println("Decreasing");
    else if(arr[0]<=arr[1] && arr[n-2]>=arr[n-1])System.out.println("Increasing then decreasing");
    else System.out.println("Decreasing then increasing");
  }
  public static void main(String[] args){
    int[] arr=new int[] {
      1,2,3,4 };
      int n=arr.length ;
      checkType(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkType( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     if (arr[0+1] <= arr[1+1] & arr[n - 2+1] <= arr[n - 1+1]) then     OclFile["System.out"].println("Increasing") ; else     if (arr[0+1] >= arr[1+1] & arr[n - 2+1] >= arr[n - 1+1]) then     OclFile["System.out"].println("Decreasing") else     if (arr[0+1] <= arr[1+1] & arr[n - 2+1] >= arr[n - 1+1]) then     OclFile["System.out"].println("Increasing then decreasing") else     OclFile["System.out"].println("Decreasing then increasing") ; ;  ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4} ;
     var n : int ; n := arr->size() ;
     execute checkType(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int maxOnesIndex(boolean arr[],int n){
    int start=0 ;
    int end=0 ;
    int maxIndex=-1 ;
    int lastInd=-1 ;
    int maxCnt=0 ;
    while(end<n){
      while(end<n && arr[end]){
        end++;
      }
      if(maxCnt<end-start && lastInd!=-1){
        maxCnt=end-start ;
        maxIndex=lastInd ;
      }
      start=lastInd+1 ;
      lastInd=end ;
      end++;
    }
    if(maxCnt<end-start && lastInd!=-1){
      maxCnt=end-start ;
      maxIndex=lastInd ;
    }
    return maxIndex ;
  }
  static public void main(String[] args){
    boolean arr[]={
      true,true,false,false,true,false,true,true,true,false,true,true,true,};
      int n=arr.length ;
      System.out.println("Index of 0 to be replaced is "+maxOnesIndex(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxOnesIndex( arr : Sequence(boolean), n : int) : int
  pre: true
  post: true
  activity: (     var start : int ; start := 0 ;
     var end : int ; end := 0 ;
    var maxIndex : int ; maxIndex := -1 ;
    var lastInd : int ; lastInd := -1 ;
    var maxCnt : int ; maxCnt := 0 ;
    while (end < n) do (     while (end < n & arr[end+1]) do (     end := end + 1 ) ; 
     if (maxCnt < end - start & lastInd /= -1) then (     maxCnt := end - start ; 
     maxIndex := lastInd ) else skip ; 
    start := lastInd + 1 ; 
    lastInd := end ; 
    end := end + 1 ; 
 ) ; 
    if (maxCnt < end - start & lastInd /= -1) then (     maxCnt := end - start ; 
     maxIndex := lastInd ) else skip ; 
    return maxIndex 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(boolean) ; arr := Sequence{true,true,false,false,true,false,true,true,true,false,true,true,true,} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Index of 0 to be replaced is " + maxOnesIndex(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.Map ;
public class TokitsukazeAndAllZeroSequence {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    while(t>0){
      int n=Integer.parseInt(br.readLine());
      int[] a=new int[n];
      String[] str=br.readLine().split(" ");
      for(int i=0 ; i<n ; i++)a[i]=Integer.parseInt(str[i]);
      Map<Integer,Integer>mp=new HashMap<>();
      for(int i=0 ; i<n ; i++){
        if(mp.containsKey(a[i]))mp.put(a[i],mp.get(a[i])+1);
        else mp.put(a[i],1);
      }
      int operations=0 ;
      int nonZeroUnique=0 ;
      for(Integer key : mp.keySet()){
        if(key!=0){
          int cnt=mp.get(key);
          if(cnt==1){
            nonZeroUnique+=1 ;
          }
          else {
            operations+=cnt ;
          }
        }
      }
      int zeroCount=mp.getOrDefault(0,0);
      if(zeroCount>0 || nonZeroUnique+zeroCount<n){
        operations+=nonZeroUnique ;
      }
      else {
        operations+=nonZeroUnique+1 ;
      }
      System.out.println(operations);
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TokitsukazeAndAllZeroSequence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
     while (t > 0) do (     var n : int ; n := (br.readLine())->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (str[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var mp : Map(int,int) ; mp := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (mp->keys()->includes(a[i+1])) then     mp := mp->union(Map{a[i+1] |-> mp->at(a[i+1]) + 1}) ; else     mp := mp->union(Map{a[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
    var operations : int ; operations := 0 ;
    var nonZeroUnique : int ; nonZeroUnique := 0 ;
    for (key : mp->keys()) do ( (     if (key /= 0) then (     var cnt : int ; cnt := mp->at(key) ;
     if (cnt = 1) then (     nonZeroUnique := nonZeroUnique+(1) ) else (     operations := operations+(cnt) ) ) else skip )  ) ; 
    var zeroCount : int ; zeroCount := (if mp->keys()->contains(0) then mp->at(0) else 0 endif) ;
    if (zeroCount > 0 or nonZeroUnique + zeroCount < n) then (     operations := operations+(nonZeroUnique) ) else (     operations := operations+(nonZeroUnique + 1) ) ;  
    OclFile["System.out"].println(operations) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.Map ;
public class TokitsukazeAndAllZeroSequence {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    while(t>0){
      int n=Integer.parseInt(br.readLine());
      int[] a=new int[n];
      String[] str=br.readLine().split(" ");
      for(int i=0 ; i<n ; i++)a[i]=Integer.parseInt(str[i]);
      Map<Integer,Integer>mp=new HashMap<>();
      for(int i=0 ; i<n ; i++){
        if(mp.containsKey(a[i]))mp.put(a[i],mp.get(a[i])+1);
        else mp.put(a[i],1);
      }
      int operations=0 ;
      int nonZeroUnique=0 ;
      for(Integer key : mp.keySet()){
        if(key!=0){
          int cnt=mp.get(key);
          if(cnt==1){
            nonZeroUnique+=1 ;
          }
          else {
            operations+=cnt ;
          }
        }
      }
      int zeroCount=mp.containsKey(0)? mp.get(0): 0 ;
      if(zeroCount>0 || nonZeroUnique+zeroCount<n){
        operations+=nonZeroUnique ;
      }
      else {
        operations+=nonZeroUnique+1 ;
      }
      System.out.println(operations);
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TokitsukazeAndAllZeroSequence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
     while (t > 0) do (     var n : int ; n := (br.readLine())->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (str[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var mp : Map(int,int) ; mp := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (mp->keys()->includes(a[i+1])) then     mp := mp->union(Map{a[i+1] |-> mp->at(a[i+1]) + 1}) ; else     mp := mp->union(Map{a[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
    var operations : int ; operations := 0 ;
    var nonZeroUnique : int ; nonZeroUnique := 0 ;
    for (key : mp->keys()) do ( (     if (key /= 0) then (     var cnt : int ; cnt := mp->at(key) ;
     if (cnt = 1) then (     nonZeroUnique := nonZeroUnique+(1) ) else (     operations := operations+(cnt) ) ) else skip )  ) ; 
    var zeroCount : int ; zeroCount := if mp->keys()->includes(0) then mp->at(0) else 0 endif ;
    if (zeroCount > 0 or nonZeroUnique + zeroCount < n) then (     operations := operations+(nonZeroUnique) ) else (     operations := operations+(nonZeroUnique + 1) ) ;  
    OclFile["System.out"].println(operations) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class ProblemA {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      HashMap<Integer,Integer>mp=new HashMap<>();
      boolean flag=false ;
      for(Integer val : a){
        if(mp.containsKey(val)){
          mp.put(val,mp.get(val)+1);
          flag=true ;
        }
        else {
          mp.put(val,1);
        }
      }
      Integer ans=n+1 ;
      if(mp.containsKey(0)){
        ans=ans-mp.get(0)-1 ;
      }
      else if(flag){
        ans=n ;
      }
      System.out.println(ans);
      t--;
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var mp : Map(int,int) ; mp := Map{} ;
    var flag : boolean ; flag := false ;
    for (val : a) do ( (     if (mp->keys()->includes(val)) then (     mp := mp->union(Map{val |-> mp->at(val) + 1}) ; 
     flag := true ) else (     mp := mp->union(Map{val |-> 1}) ) )  ) ; 
    var ans : int ; ans := n + 1 ;
    if (mp->keys()->includes(0)) then (     ans := ans - mp->at(0) - 1 ) else     if (flag) then (     ans := n ) else skip ; ;  
    OclFile["System.out"].println(ans) ; 
    t := t - 1 ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Test {
  static int x=32 ;
  static String toggleCase(char[] a){
    for(int i=0 ; i<a.length ; i++){
      a[i] ^=32 ;
    }
    return new String(a);
  }
  public static void main(String[] args){
    String str="CheRrY" ;
    System.out.print("Toggle case: ");
    str=toggleCase(str.toCharArray());
    System.out.println(str);
    System.out.print("Original string: ");
    str=toggleCase(str.toCharArray());
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   attribute x : int := 32;
  static   operation toggleCase( a : Sequence(String)) : String
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := MathLib.bitwiseXor(a[i+1],32) )  ;     i := i + 1 ) ; 
     return StringLib.newString(a) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "CheRrY" ;
     OclFile["System.out"].print("Toggle case: ") ; 
    str := toggleCase(str->characters()) ; 
    OclFile["System.out"].println(str) ; 
    OclFile["System.out"].print("Original string: ") ; 
    str := toggleCase(str->characters()) ; 
    OclFile["System.out"].println(str) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static boolean[][] domino=new boolean[7][7];
  static int[] count=new int[7];
  static int N ;
  public static void main(String[] args)throws Exception {
    while(sc.hasNext()){
      N=sc.nextInt();
      for(boolean[] a : domino){
        Arrays.fill(a,false);
      }
      Arrays.fill(count,0);
      for(int i=0 ; i<N ; ++i){
        String v=sc.next();
        int f=v.charAt(0)-'0' ;
        int s=v.charAt(1)-'0' ;
        domino[f][s]=true ;
++count[f];
++count[s];
      }
      System.out.println(solve()? "Yes" : "No");
    }
  }
  static boolean solve(){
    for(int i=0 ; i<7 ; ++i){
      if(solve(i,0)){
        return true ;
      }
    }
    return false ;
  }
  static boolean solve(int first,int depth){
    if(depth==N)return true ;
    if(count[first]==0)return false ;
    int odd=0 ;
    for(int i=0 ; i<7 ; ++i){
      if(count[i] % 2!=0)++odd ;
    }
    if(!(odd==0 ||(odd==2 && count[first] % 2!=0)))return false ;
    for(int i=0 ; i<7 ; ++i){
      int r=Math.min(i,first);
      int c=Math.max(i,first);
      if(domino[r][c]){
        domino[r][c]=false ;
--count[r];
--count[c];
        if(solve(i,depth+1))return true ;
++count[c];
++count[r];
        domino[r][c]=true ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute domino : Sequence(Sequence(boolean)) := Integer.subrange(1,7)->collect(Integer.subrange(1,7)->collect(false));
  static   attribute count : Sequence(int) := Integer.subrange(1,7)->collect(0);
  static   attribute N : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     N := sc.getCurrent()->toInteger() ; 
     for (a : domino) do ( (     a := a->collect(false) )  ) ; 
    count := count->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     var v : String ; v := sc.getCurrent() ;
     var f : int ; f := v->at(0+1) - ('0')->char2byte() ;
    var s : int ; s := v->at(1+1) - ('0')->char2byte() ;
    domino[f+1][s+1] := true ; 
    count[f+1] := count[f+1] + 1 ; 
    count[s+1] := count[s+1] + 1 ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if solve() then "Yes" else "No" endif) ; 
 ) );
  static   operation solve() : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 7 do ( (     if (solve(i, 0)) then (     return true ) else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation solve( first : int, depth : int) : boolean
  pre: true
  post: true
  activity: (     if (depth = N) then     return true else skip ; 
     if (count[first+1] = 0) then     return false else skip ; 
    var odd : int ; odd := 0 ;
        var i : int ; i := 0 ; while i < 7 do ( (     if (count[i+1] mod 2 /= 0) then     odd := odd + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (not((odd = 0 or (odd = 2 & count[first+1] mod 2 /= 0)))) then     return false else skip ; 
        var i : int ; i := 0 ; while i < 7 do ( (     var r : int ; r := Set{i, first}->min() ;
     var c : int ; c := Set{i, first}->max() ;
     if (domino[r+1][c+1]) then (     domino[r+1][c+1] := false ; 
     count[r+1] := count[r+1] - 1 ; 
    count[c+1] := count[c+1] - 1 ; 
    if (solve(i, depth + 1)) then     return true else skip ; 
    count[c+1] := count[c+1] + 1 ; 
    count[r+1] := count[r+1] + 1 ; 
    domino[r+1][c+1] := true ; 
 ) else skip )  ;     i := i + 1 ) ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printArray(int arr[],int n){
    for(int i=0 ; i<n ; i++){
      System.out.print(arr[i]+" ");
    }
  }
  static void generateArr(int arr[],int n){
    if(n==0)return ;
    if(n==1){
      System.out.print(arr[0]);
      return ;
    }
    int[] suffixMax=new int[n];
    suffixMax[n-1]=arr[n-1];
    for(int i=n-2 ; i>=0 ; i--)suffixMax[i]=Math.max(arr[i],suffixMax[i+1]);
    int minSoFar=arr[0];
    arr[0]=suffixMax[1];
    for(int i=1 ; i<n-1 ; i++){
      int temp=arr[i];
      arr[i]=Math.abs(suffixMax[i+1]-minSoFar);
      minSoFar=Math.min(minSoFar,temp);
    }
    arr[n-1]=minSoFar ;
    printArray(arr,n);
  }
  public static void main(String[] args){
    int arr[]={
      1,5,2,4,3 };
      int n=arr.length ;
      generateArr(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
  static   operation generateArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     if (n = 0) then     return else skip ; 
     if (n = 1) then (     OclFile["System.out"].print(arr[0+1]) ; 
     return ) else skip ; 
    var suffixMax : Sequence(int) ; suffixMax := Integer.subrange(1,n)->collect(0) ;
    suffixMax[n - 1+1] := arr[n - 1+1] ; 
        var i : int ; i := n - 2 ; while i >= 0 do (     suffixMax[i+1] := Set{arr[i+1], suffixMax[i + 1+1]}->max() ;  ;     i := i - 1 ) ; 
    var minSoFar : int ; minSoFar := arr[0+1] ;
    arr[0+1] := suffixMax[1+1] ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := if suffixMax[i + 1+1] - minSoFar < 0 then -(suffixMax[i + 1+1] - minSoFar) else suffixMax[i + 1+1] - minSoFar endif ; 
     minSoFar := Set{minSoFar, temp}->min() )  ;     i := i + 1 ) ; 
    arr[n - 1+1] := minSoFar ; 
    execute printArray(arr, n) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,2,4,3} ;
     var n : int ; n := arr->size() ;
     execute generateArr(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Char_frequency {
  static final int SIZE=26 ;
  static void printCharWithFreq(String str){
    int n=str.length();
    int[] freq=new int[SIZE];
    for(int i=0 ; i<n ; i++)freq[str.charAt(i)-'a']++;
    for(int i=0 ; i<n ; i++){
      if(freq[str.charAt(i)-'a']!=0){
        System.out.print(str.charAt(i));
        System.out.print(freq[str.charAt(i)-'a']+" ");
        freq[str.charAt(i)-'a']=0 ;
      }
    }
  }
  public static void main(String args[]){
    String str="geeksforgeeks" ;
    printCharWithFreq(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class Char_frequency {
  static    attribute SIZE : int := 26;
  static   operation printCharWithFreq( str : String) : void
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var freq : Sequence(int) ; freq := Integer.subrange(1,SIZE)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     freq[str->at(i+1) - ('a')->char2byte()+1] := freq[str->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (freq[str->at(i+1) - ('a')->char2byte()+1] /= 0) then (     OclFile["System.out"].print(str->at(i+1)) ; 
     OclFile["System.out"].print(freq[str->at(i+1) - ('a')->char2byte()+1] + " ") ; 
     freq[str->at(i+1) - ('a')->char2byte()+1] := 0 ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     execute printCharWithFreq(str) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.nio.Buffer ;
import java.util.*;
public class Main2 {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int testCases=sc.nextInt();
    while(testCases-->0){
      int length=sc.nextInt();
      int[] array=new int[length];
      for(int i=0 ; i<length ; i++){
        array[i]=sc.nextInt();
      }
      boolean found=false ;
      for(int i=0 ; i<length-1 ; i++){
        int diff=Math.abs(array[i]-array[i+1]);
        if(diff>1){
          found=true ;
          System.out.println("yes");
          System.out.println((i+1)+" "+(i+2));
          break ;
        }
      }
      if(! found){
        System.out.println("no");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := sc.getCurrent()->toInteger() ;
         while (testCases > 0) do (        testCases := testCases - 1 ;     skip ; (     var length : int ; length := sc.getCurrent()->toInteger() ;
     var array : Sequence(int) ; array := Integer.subrange(1,length)->collect(0) ;
        var i : int ; i := 0 ; while i < length do ( (     array[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var found : boolean ; found := false ;
        var i : int ; i := 0 ; while i < length - 1 do ( (     var diff : int ; diff := if array[i+1] - array[i + 1+1] < 0 then -(array[i+1] - array[i + 1+1]) else array[i+1] - array[i + 1+1] endif ;
     if (diff > 1) then (     found := true ; 
     OclFile["System.out"].println("yes") ; 
     OclFile["System.out"].println((i + 1) + " " + (i + 2)) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (not(found)) then (     OclFile["System.out"].println("no") ) else skip ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Interesting {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int a[]=new int[n];
      boolean flag=false ;
      int l=0 ;
      a[0]=sc.nextInt();
      for(int j=1 ; j<n ; j++){
        a[j]=sc.nextInt();
        if(Math.abs(a[j]-a[j-1])>1){
          flag=true ;
          l=j ;
        }
      }
      if(l==0){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
        System.out.println(l+" "+(l+1));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Interesting {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var flag : boolean ; flag := false ;
    var l : int ; l := 0 ;
    a[0+1] := sc.getCurrent()->toInteger() ; 
        var j : int ; j := 1 ; while j < n do ( (     a[j+1] := sc.getCurrent()->toInteger() ; 
     if (if a[j+1] - a[j - 1+1] < 0 then -(a[j+1] - a[j - 1+1]) else a[j+1] - a[j - 1+1] endif > 1) then (     flag := true ; 
     l := j ) else skip )  ;     j := j + 1 ) ; 
    if (l = 0) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(l + " " + (l + 1)) ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while(!(line=br.readLine().trim()).equals("0")&& ! line.isEmpty()){
      int goal=Integer.parseInt(line);
      int times=Integer.parseInt(br.readLine().trim());
      int sum=0 ;
      for(int i=0 ; i<times ; i++){
        line=br.readLine().trim();
        int s=Integer.parseInt(line.substring(0,line.indexOf(' ')));
        int f=Integer.parseInt(line.substring(line.indexOf(' ')+1));
        sum+=f-s ;
      }
      System.out.println(sum>=goal ? "OK" : goal-sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
     while (not((line) = "0") & not(line->isEmpty())) do (     var goal : int ; goal := (line)->toInteger() ;
     var times : int ; times := (br.readLine()->trim())->toInteger() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < times do ( (     line := br.readLine()->trim() ; 
     var s : int ; s := (line.subrange(0+1,line->indexOf(' ')-1))->toInteger() ;
     var f : int ; f := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1))->toInteger() ;
     sum := sum+(f - s) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if sum >= goal then "OK" else (goal)->char2byte() - sum endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0){
      int n=sc.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      boolean flag=false ;
      for(int i=1 ; i<n ; i++){
        if(Math.abs(arr[i]-arr[i-1])>=2){
          System.out.println("YES");
          System.out.println(i+" "+(i+1));
          flag=true ;
          break ;
        }
      }
      if(! flag){
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := false ;
        var i : int ; i := 1 ; while i < n do ( (     if (if arr[i+1] - arr[i - 1+1] < 0 then -(arr[i+1] - arr[i - 1+1]) else arr[i+1] - arr[i - 1+1] endif >= 2) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(i + " " + (i + 1)) ; 
     flag := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (not(flag)) then (     OclFile["System.out"].println("NO") ) else skip ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p160 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p160().run());
  }
  public String run(){
    return Long.toString(factorialSuffix(1000000000000L));
  }
  private static long factorialSuffix(long n){
    long twos=countFactors(n,2)-countFactors(n,5);
    if(twos>=2505)twos=(twos-5)% 2500+5 ;
    return factorialish(n)*Library.powMod(2,(int)twos,100000)% 100000 ;
  }
  private static long factorialish(long n){
    return evenFactorialish(n)*oddFactorialish(n)% 100000 ;
  }
  private static long evenFactorialish(long n){
    if(n==0)return 1 ;
    else return factorialish(n/2);
  }
  private static long oddFactorialish(long n){
    if(n==0)return 1 ;
    else return oddFactorialish(n/5)*factorialCoprime(n)% 100000 ;
  }
  private static long factorialCoprime(long n){
    n %=100000 ;
    long product=1 ;
    for(int i=1 ; i<=n ; i++){
      if(i % 2!=0 && i % 5!=0)product=i*product % 100000 ;
    }
    return product ;
  }
  private static long countFactors(long end,long n){
    if(end==0)return 0 ;
    else return end/n+countFactors(end/n,n);
  }
}
------------------------------------------------------------
OCL File:
---------
class p160 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p160.newp160().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     return ((factorialSuffix(1000000000000L)) + "") );
  static   operation factorialSuffix( n : long) : long
  pre: true
  post: true
  activity: (     var twos : long ; twos := countFactors(n, 2) - countFactors(n, 5) ;
     if (twos >= 2505) then     twos := (twos - 5) mod 2500 + 5 ; else skip ; 
     return factorialish(n) * Library.powMod(2, twos->oclAsType(int), 100000) mod 100000 );
  static   operation factorialish( n : long) : long
  pre: true
  post: true
  activity: (     return evenFactorialish(n) * oddFactorialish(n) mod 100000 );
  static   operation evenFactorialish( n : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else     return factorialish(n / 2) );
  static   operation oddFactorialish( n : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else     return oddFactorialish(n / 5) * factorialCoprime(n) mod 100000 );
  static   operation factorialCoprime( n : long) : long
  pre: true
  post: true
  activity: (     n := n mod 100000 ; 
     var product : long ; product := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (     if (i mod 2 /= 0 & i mod 5 /= 0) then     product := i * product mod 100000 ; else skip )  ;     i := i + 1 ) ; 
     return product );
  static   operation countFactors( end : long, n : long) : long
  pre: true
  post: true
  activity: (     if (end = 0) then     return 0 else     return end / n + countFactors(end / n, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
public class Word_Correction {
  public static void main(String[] args)throws Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    int n=Integer.parseInt(reader.readLine());
    String v="aeiouy" ;
    char[] str=(reader.readLine()).toCharArray();
    String res="" ;
    boolean lastChResIsV=false ;
    for(int i=0 ; i<n ; i++){
      res+=(! v.contains(str[i]+"")|| ! lastChResIsV)? str[i] : "" ;
      lastChResIsV=v.contains(str[i]+"")? true : false ;
    }
    writer.write(res);
    writer.newLine();
    writer.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Word_Correction {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := (reader.readLine())->toInteger() ;
    var v : String ; v := "aeiouy" ;
    var str : Sequence(String) ; str := (reader.readLine())->characters() ;
    var res : String ; res := "" ;
    var lastChResIsV : boolean ; lastChResIsV := false ;
        var i : int ; i := 0 ; while i < n do ( (     res := res+(if (not(v->includes(str[i+1] + "")) or not(lastChResIsV)) then str[i+1] else "" endif) ; 
     lastChResIsV := if v->includes(str[i+1] + "") then true else false endif )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class WordCorrection {
  public static void main(String[] args){
    try {
      BufferedReader pf=new BufferedReader(new InputStreamReader(System.in));
      int n=Integer.parseInt(pf.readLine());
      String y=pf.readLine();
      char v ;
      int count=0 ;
      int count2=0 ;
      String word="" ;
      for(int i=0 ; i<n ; i++){
        v=y.charAt(i);
        if(v=='a' || v=='e' || v=='y' || v=='i' || v=='o' || v=='u'){
          count++;
          count2++;
          if(count==2){
            count=0 ;
          }
          else if(count2>=2){
            count2=0 ;
          }
          else {
            word=word+y.charAt(i);
          }
        }
        else {
          word=word+y.charAt(i);
          count=0 ;
          count2=0 ;
        }
      }
      System.out.println(word);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class WordCorrection {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var pf : OclFile ; pf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (pf.readLine())->toInteger() ;
    var y : String ; y := pf.readLine() ;
    var v : String ;
    var count : int ; count := 0 ;
    var count2 : int ; count2 := 0 ;
    var word : String ; word := "" ;
        var i : int ; i := 0 ; while i < n do ( (     v := y->at(i+1) ; 
     if (v = 'a' or v = 'e' or v = 'y' or v = 'i' or v = 'o' or v = 'u') then (     count := count + 1 ; 
     count2 := count2 + 1 ; 
     if (count = 2) then (     count := 0 ) else     if (count2 >= 2) then (     count2 := 0 ) else (     word := word + y->at(i+1) ) ;  ) else (     word := word + y->at(i+1) ; 
     count := 0 ; 
     count2 := 0 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(word) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
public class P3_word_correction {
  public static boolean vowels(char c){
    return((c=='a')||(c=='e')||(c=='u')||(c=='i')||(c=='y')||(c=='o'));
  }
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    int n=Integer.parseInt(reader.readLine());
    String word=reader.readLine();
    int count=0 ;
    for(int i=0 ; i<word.length(); i++){
      if(vowels(word.charAt(i))){
        count++;
        if(count<=1){
          writer.write(""+word.charAt(i));
        }
      }
      else {
        count=0 ;
        writer.write(""+word.charAt(i));
      }
    }
    writer.newLine();
    writer.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class P3_word_correction {
  static   operation vowels( c : String) : boolean
  pre: true
  post: true
  activity: (     return ((c = 'a') or (c = 'e') or (c = 'u') or (c = 'i') or (c = 'y') or (c = 'o')) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := (reader.readLine())->toInteger() ;
    var word : String ; word := reader.readLine() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < word->size() do ( (     if (vowels(word->at(i+1))) then (     count := count + 1 ; 
     if (count <= 1) then (     skip ) else skip ) else (     count := 0 ; 
     skip ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
public class P3_word_correction {
  public static boolean vowels(char c){
    return((c=='a')||(c=='e')||(c=='u')||(c=='i')||(c=='y')||(c=='o'));
  }
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    int n=Integer.parseInt(reader.readLine());
    String word=reader.readLine();
    int count=0 ;
    for(int i=0 ; i<word.length(); i++){
      if(vowels(word.charAt(i))){
        count++;
        if(count<=1){
          writer.write(""+word.charAt(i));
        }
      }
      else {
        count=0 ;
        writer.write(""+word.charAt(i));
      }
    }
    writer.newLine();
    writer.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class P3_word_correction {
  static   operation vowels( c : String) : boolean
  pre: true
  post: true
  activity: (     return ((c = 'a') or (c = 'e') or (c = 'u') or (c = 'i') or (c = 'y') or (c = 'o')) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := (reader.readLine())->toInteger() ;
    var word : String ; word := reader.readLine() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < word->size() do ( (     if (vowels(word->at(i+1))) then (     count := count + 1 ; 
     if (count <= 1) then (     skip ) else skip ) else (     count := 0 ; 
     skip ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class CP23 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n1=sc.nextInt();
    int k=0,i=1 ;
    while(n1>k){
      k=k+i ;
      n1=n1-k ;
      if(n1>=0)i++;
    }
    System.out.println(i-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CP23 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n1 : int ; n1 := sc.getCurrent()->toInteger() ;
    var k : int ; k := 0 ;
    var i : int ; i := 1 ;
    while (n1 > k) do (     k := k + i ; 
     n1 := n1 - k ; 
     if (n1 >= 0) then     i := i + 1 ; else skip ) ; 
    OclFile["System.out"].println(i - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static int N ;
  public static int[] arr ;
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    while(in.hasNextInt()){
      N=in.nextInt();
      arr=new int[N];
      boolean[] visited=new boolean[N];
      for(int i=0 ; i<N ; i++){
        arr[i]=in.nextInt();
      }
      boolean found=false ;
      for(int i=0 ; i<N && ! found ; i++){
        visited[i]=true ;
        found=found || recursive(0,arr[i] % 10,visited,1)|| recursive(0,arr[i]/10,visited,1);
        visited[i]=false ;
      }
      if(found){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
  }
  public static boolean recursive(int pos,int n,boolean[] visited,int len){
    if(len==N)return true ;
    if(pos==N)return false ;
    boolean ret=false ;
    int a=arr[pos] % 10 ;
    int b=arr[pos]/10 ;
    int newNum=a==n ? b : a ;
    if(visited[pos])return recursive(pos+1,n,visited,len);
    if(a!=n && b!=n)return recursive(pos+1,n,visited,len);
    visited[pos]=true ;
    ret=ret || recursive(0,newNum,visited,len+1);
    visited[pos]=false ;
    ret=ret || recursive(pos+1,n,visited,len);
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute arr : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNextInt()) do (     N := in.getCurrent()->toInteger() ; 
     arr := Integer.subrange(1,N)->collect(0) ; 
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,N)->collect(false) ;
        var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var found : boolean ; found := false ;
        var i : int ; i := 0 ; while i < N & not(found) do ( (     visited[i+1] := true ; 
     found := found or recursive(0, arr[i+1] mod 10, visited, 1) or recursive(0, arr[i+1] / 10, visited, 1) ; 
     visited[i+1] := false )  ;     i := i + 1 ) ; 
    if (found) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 ) );
  static   operation recursive( pos : int, n : int, visited : Sequence(boolean), len : int) : boolean
  pre: true
  post: true
  activity: (     if (len = N) then     return true else skip ; 
     if (pos = N) then     return false else skip ; 
    var ret : boolean ; ret := false ;
    var a : int ; a := arr[pos+1] mod 10 ;
    var b : int ; b := arr[pos+1] / 10 ;
    var newNum : int ; newNum := if a = n then b else a endif ;
    if (visited[pos+1]) then     return recursive(pos + 1, n, visited, len) else skip ; 
    if (a /= n & b /= n) then     return recursive(pos + 1, n, visited, len) else skip ; 
    visited[pos+1] := true ; 
    ret := ret or recursive(0, newNum, visited, len + 1) ; 
    visited[pos+1] := false ; 
    ret := ret or recursive(pos + 1, n, visited, len) ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
public class AWordCorrection {
  @ SuppressWarnings("empty-statement")public static void main(String[] args)throws Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    String vowels="aeiouy" ;
    int n=Integer.parseInt(reader.readLine());
    String word=reader.readLine();
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(vowels.contains(""+word.charAt(i))){
        count++;
        if(count<=1)writer.write(word.charAt(i));
      }
      else {
        count=0 ;
        writer.write(word.charAt(i));
      }
    }
    writer.newLine();
    writer.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class AWordCorrection {
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var vowels : String ; vowels := "aeiouy" ;
    var n : int ; n := (reader.readLine())->toInteger() ;
    var word : String ; word := reader.readLine() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (vowels->includes("" + word->at(i+1))) then (     count := count + 1 ; 
     if (count <= 1) then     skip ; else skip ) else (     count := 0 ; 
     skip ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args)throws Exception {
    nint();
    int q=nint();
    TreeMap<Integer,Integer>map=new TreeMap<>();
    map.put(-1,Integer.MAX_VALUE);
    while(q-->0){
      int command=nint();
      if(command==0){
        int s=nint();
        int t=nint();
        int x=nint();
        int rightValue=map.floorEntry(t+1).getValue();
        map.subMap(s,t+1).clear();
        map.put(s,x);
        map.put(t+1,rightValue);
      }
      else {
        int i=nint();
        System.out.println(map.floorEntry(i).getValue());
      }
    }
  }
  static int nint(){
    return Integer.parseInt(sc.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute nint() ; 
     var q : int ; q := nint() ;
    var map : Map(int,int) ; map := Map{} ;
    map := map->union(Map{-1 |-> 2147483647}) ; 
        while (q > 0) do (        q := q - 1 ;     skip ; (     var command : int ; command := nint() ;
     if (command = 0) then (     var s : int ; s := nint() ;
     var t : int ; t := nint() ;
    var x : int ; x := nint() ;
    var rightValue : int ; rightValue := map.floorEntry(t + 1).getValue() ;
    map := map->restrict( _key | _key < t + 1 & _key >= s )->intersection(Set{}) ; 
    map := map->union(Map{s |-> x}) ; 
    map := map->union(Map{t + 1 |-> rightValue}) ; 
 ) else (     var i : int ; i := nint() ;
     OclFile["System.out"].println(map.floorEntry(i).getValue()) ) ) ;  ) ;  
 );
  static   operation nint() : int
  pre: true
  post: true
  activity: (     return (sc.getCurrent())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner kbd=new Scanner(System.in);
  public static void main(String[] args){
    while(kbd.hasNext()){
      int t=kbd.nextInt();
      if(t!=0){
        solve(t);
      }
    }
  }
  static void solve(int t){
    int dotime=0 ;
    int n=kbd.nextInt();
    while(n>0){
      int a=kbd.nextInt();
      int b=kbd.nextInt();
      dotime+=(b-a);
      n--;
    }
    if(dotime>=t)System.out.println("OK");
    else System.out.println(t-dotime);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute kbd : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (kbd.hasNext()) do (     var t : int ; t := kbd.getCurrent()->toInteger() ;
     if (t /= 0) then (     execute solve(t) ) else skip ) );
  static   operation solve( t : int) : void
  pre: true
  post: true
  activity: (     var dotime : int ; dotime := 0 ;
     var n : int ; n := kbd.getCurrent()->toInteger() ;
     while (n > 0) do (     var a : int ; a := kbd.getCurrent()->toInteger() ;
     var b : int ; b := kbd.getCurrent()->toInteger() ;
     dotime := dotime+((b - a)) ; 
     n := n - 1 ) ; 
     if (dotime >= t) then     OclFile["System.out"].println("OK") ; else     OclFile["System.out"].println(t - dotime) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args)throws Exception {
    new Main().run();
  }
  void run(){
    nint();
    int q=nint();
    TreeMap<Integer,Integer>map=new TreeMap<>();
    map.put(-1,Integer.MAX_VALUE);
    while(q-->0){
      int cmd=nint();
      if(cmd==0){
        int s=nint();
        int t=nint();
        int x=nint();
        Integer rightValue=map.floorEntry(t+1).getValue();
        map.subMap(s,t+1).clear();
        map.put(s,x);
        map.put(t+1,rightValue);
      }
      else {
        int i=nint();
        System.out.println(map.floorEntry(i).getValue());
      }
    }
  }
  int nint(){
    return Integer.parseInt(sc.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     execute nint() ; 
     var q : int ; q := nint() ;
    var map : Map(int,int) ; map := Map{} ;
    map := map->union(Map{-1 |-> 2147483647}) ; 
        while (q > 0) do (        q := q - 1 ;     skip ; (     var cmd : int ; cmd := nint() ;
     if (cmd = 0) then (     var s : int ; s := nint() ;
     var t : int ; t := nint() ;
    var x : int ; x := nint() ;
    var rightValue : int ; rightValue := map.floorEntry(t + 1).getValue() ;
    map := map->restrict( _key | _key < t + 1 & _key >= s )->intersection(Set{}) ; 
    map := map->union(Map{s |-> x}) ; 
    map := map->union(Map{t + 1 |-> rightValue}) ; 
 ) else (     var i : int ; i := nint() ;
     OclFile["System.out"].println(map.floorEntry(i).getValue()) ) ) ;  ) ;  
 );
   operation nint() : int
  pre: true
  post: true
  activity: (     return (sc.getCurrent())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean checkSame(int n){
    int set=0 ;
    int unset=0 ;
    while(n>0){
      if((n & 1)==1)set++;
      else unset++;
      n=n>>1 ;
    }
    if(set==unset)return true ;
    else return false ;
  }
  public static void main(String[] args){
    int n=12 ;
    if(checkSame(n))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkSame( n : int) : boolean
  pre: true
  post: true
  activity: (     var set : int ; set := 0 ;
     var unset : int ; unset := 0 ;
     while (n > 0) do (     if ((n & 1) = 1) then     set := set + 1 else     unset := unset + 1 ; ;  
     n := (n/(2->pow(1)))->oclAsType(long) ) ; 
     if (set = unset) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     if (checkSame(n)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static void CountPair(int L,int R){
    int x=(R-L+1);
    System.out.println(x/2+"\n");
  }
  public static void main(String args[]){
    int L,R ;
    L=1 ;
    R=8 ;
    CountPair(L,R);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation CountPair( L : int, R : int) : void
  pre: true
  post: true
  activity: (     var x : int ; x := (R - L + 1) ;
     OclFile["System.out"].println(x / 2 + "\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ;
    var R : int ;
     L := 1 ; 
     R := 8 ; 
     execute CountPair(L, R) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MOD=1000000007 ;
  static int number_of_ways(int arr[],int n,int k){
    if(k==1)return 1 ;
    int dp[]=new int[k+1];
    int i ;
    for(i=0 ; i<k+1 ; i++)dp[i]=-1 ;
    for(i=0 ; i<n ; i++)dp[arr[i] ]=0 ;
    dp[0]=1 ;
    dp[1]=(dp[1]==-1)? 1 : dp[1];
    for(i=2 ; i<=k ; ++i){
      if(dp[i]==0)continue ;
      dp[i]=dp[i-1]+dp[i-2];
      dp[i] %=MOD ;
    }
    return dp[k];
  }
  public static void main(String[] args){
    int arr[]={
      3 };
      int n=arr.length ;
      int k=6 ;
      System.out.println(number_of_ways(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MOD : int := 1000000007;
  static   operation number_of_ways( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     if (k = 1) then     return 1 else skip ; 
     var dp : Sequence(int) ; dp := Integer.subrange(1,k + 1)->collect(0) ;
    var i : int ;
        i := 0 ; while i < k + 1 do (     dp[i+1] := -1 ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do (     dp[arr[i+1]+1] := 0 ;  ;     i := i + 1 ) ; 
    dp[0+1] := 1 ; 
    dp[1+1] := if (dp[1+1] = -1) then 1 else dp[1+1] endif ; 
        i := 2 ; while i <= k do ( (     if (dp[i+1] = 0) then     continue else skip ; 
     dp[i+1] := dp[i - 1+1] + dp[i - 2+1] ; 
     dp[i+1] := dp[i+1] mod MOD )  ;     i := i + 1 ) ; 
    return dp[k+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 6 ;
     OclFile["System.out"].println(number_of_ways(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    for(int x=0 ; x<n ; x++){
      String query=scanner.next();
      ArrayList<String>list=new ArrayList<String>();
      for(int i=0 ; i<query.length()-1 ; i++){
        StringBuffer top=new StringBuffer(query.substring(0,i+1));
        StringBuffer bottom=new StringBuffer(query.substring(i+1,query.length()));
        String[] tops=new String[2];
        tops[0]=top.toString();
        tops[1]=top.reverse().toString();
        String[] bottoms=new String[2];
        bottoms[0]=bottom.toString();
        bottoms[1]=bottom.reverse().toString();
        for(int j=0 ; j<tops.length ; j++){
          for(int j2=0 ; j2<bottoms.length ; j2++){
            String sequence0=tops[j]+bottoms[j2];
            String sequence1=bottoms[j2]+tops[j];
            if(! list.contains(sequence0)){
              list.add(sequence0);
            }
            if(! list.contains(sequence1)){
              list.add(sequence1);
            }
          }
        }
      }
      System.out.println(list.size());
    }
  }
  static int nextInt(){
    int c ;
    try {
      c=System.in.read();
      while(c!='-' &&(c<'0' || c>'9'))c=System.in.read();
      if(c=='-')return-nextInt();
      int res=0 ;
      while(c>='0' && c<='9'){
        res=res*10+c-'0' ;
        c=System.in.read();
      }
      return res ;
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
         var x : int ; x := 0 ; while x < n do ( (     var query : String ; query := scanner.getCurrent() ;
     var list : Sequence(String) ; list := Sequence{} ;
         var i : int ; i := 0 ; while i < query->size() - 1 do ( (     var top : String ; top := StringLib.newString(query.subrange(0+1,i + 1)) ;
     var bottom : String ; bottom := StringLib.newString(query.subrange(i + 1+1,query->size())) ;
    var tops : Sequence(String) ; tops := Integer.subrange(1,2)->collect(null) ;
    tops[0+1] := top+"" ; 
    tops[1+1] := top->reverse()+"" ; 
    var bottoms : Sequence(String) ; bottoms := Integer.subrange(1,2)->collect(null) ;
    bottoms[0+1] := bottom+"" ; 
    bottoms[1+1] := bottom->reverse()+"" ; 
        var j : int ; j := 0 ; while j < tops->size() do ( (         var j2 : int ; j2 := 0 ; while j2 < bottoms->size() do ( (     var sequence0 : String ; sequence0 := tops[j+1] + bottoms[j2+1] ;
     var sequence1 : String ; sequence1 := bottoms[j2+1] + tops[j+1] ;
     if (not(list->includes(sequence0))) then (     list := list->including(sequence0) ) else skip ; 
     if (not(list->includes(sequence1))) then (     list := list->including(sequence1) ) else skip )  ;     j2 := j2 + 1 ) )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(list->size()) )  ;     x := x + 1 ) );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     var c : int ;
     try (     c := OclFile["System.in"].read() ; 
     while (c /= '-' & (c < '0' or c > '9')) do     c := OclFile["System.in"].read() ; ; 
    if (c = '-') then     return -nextInt() else skip ; 
    var res : int ; res := 0 ;
    while (c >= '0' & c <= '9') do (     res := res * 10 + c - ('0')->char2byte() ; 
     c := OclFile["System.in"].read() ) ; 
    return res 
 )   catch (e : IOException) do (     e.printStackTrace() )
     return -1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int a=Integer.parseInt(br.readLine());
    String[] b=new String[1000];
    for(int i=0 ; i<a ; i++){
      String str=br.readLine();
      int j=0 ;
      for(int Len=1 ; Len<str.length(); Len++){
        String str2=str.substring(0,Len);
        String str3=str.substring(Len,str.length());
        StringBuilder str4=new StringBuilder(str2);
        str4.reverse();
        String rev=new String(str4);
        StringBuilder str5=new StringBuilder(str3);
        str5.reverse();
        String rev2=new String(str5);
        b[j]=str2+str3 ;
        b[j+1]=str2+rev2 ;
        b[j+2]=rev+str3 ;
        b[j+3]=rev+rev2 ;
        StringBuilder rev3=new StringBuilder(b[j]);
        rev3.reverse();
        b[j+4]=new String(rev3);
        StringBuilder rev4=new StringBuilder(b[j+1]);
        rev4.reverse();
        b[j+5]=new String(rev4);
        StringBuilder rev5=new StringBuilder(b[j+2]);
        rev5.reverse();
        b[j+6]=new String(rev5);
        StringBuilder rev6=new StringBuilder(b[j+3]);
        rev6.reverse();
        b[j+7]=new String(rev6);
        j=j+8 ;
      }
      HashSet<String>set=new HashSet<String>();
      for(int k=0 ; k<(str.length()-1)*8 ; k++){
        set.add(b[k]);
      }
      Iterator it=set.iterator();
      System.out.println(set.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var a : int ; a := (br.readLine())->toInteger() ;
     var b : Sequence(String) ; b := Integer.subrange(1,1000)->collect(null) ;
         var i : int ; i := 0 ; while i < a do ( (     var str : String ; str := br.readLine() ;
     var j : int ; j := 0 ;
        var Len : int ; Len := 1 ; while Len < str->size() do ( (     var str2 : String ; str2 := str.subrange(0+1,Len) ;
     var str3 : String ; str3 := str.subrange(Len+1,str->size()) ;
    var str4 : String ; str4 := StringLib.newString(str2) ;
    str4 := str4->reverse() ; 
    var rev : String ; rev := StringLib.newString(str4) ;
    var str5 : String ; str5 := StringLib.newString(str3) ;
    str5 := str5->reverse() ; 
    var rev2 : String ; rev2 := StringLib.newString(str5) ;
    b[j+1] := str2 + str3 ; 
    b[j + 1+1] := str2 + rev2 ; 
    b[j + 2+1] := rev + str3 ; 
    b[j + 3+1] := rev + rev2 ; 
    var rev3 : String ; rev3 := StringLib.newString(b[j+1]) ;
    rev3 := rev3->reverse() ; 
    b[j + 4+1] := StringLib.newString(rev3) ; 
    var rev4 : String ; rev4 := StringLib.newString(b[j + 1+1]) ;
    rev4 := rev4->reverse() ; 
    b[j + 5+1] := StringLib.newString(rev4) ; 
    var rev5 : String ; rev5 := StringLib.newString(b[j + 2+1]) ;
    rev5 := rev5->reverse() ; 
    b[j + 6+1] := StringLib.newString(rev5) ; 
    var rev6 : String ; rev6 := StringLib.newString(b[j + 3+1]) ;
    rev6 := rev6->reverse() ; 
    b[j + 7+1] := StringLib.newString(rev6) ; 
    j := j + 8 ; 
 )  ;     Len := Len + 1 ) ; 
    var set : Set(String) ; set := Set{} ;
        var k : int ; k := 0 ; while k < (str->size() - 1) * 8 do ( (     set := set->including(b[k+1]) )  ;     k := k + 1 ) ; 
    var it : OclIterator ; it := set->iterator() ;
    OclFile["System.out"].println(set->size()) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter pr=new PrintWriter(System.out);
    int m=sc.nextInt();
    while(m-->0){
      String t=sc.next();
      if(t.length()==1)pr.println(1);
      Set<String>train=new HashSet<String>();
      train.add(t);
      for(int k=0 ; k<t.length(); k++){
        String d1=t.substring(0,k);
        String d2=t.substring(k,t.length());
        StringBuilder sb1=new StringBuilder(d1);
        StringBuilder sb2=new StringBuilder(d2);
        String rd1=sb1.reverse().toString();
        String rd2=sb2.reverse().toString();
        train.add(d2+d1);
        train.add(d1+rd2);
        train.add(rd2+d1);
        train.add(rd1+d2);
        train.add(d2+rd1);
        train.add(rd1+rd2);
        train.add(rd2+rd1);
      }
      pr.println(train.size());
    }
    pr.flush();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     var t : String ; t := sc.getCurrent() ;
     if (t->size() = 1) then     skip ; else skip ; 
    var train : Set(String) ; train := Set{} ;
    train := train->including(t) ; 
        var k : int ; k := 0 ; while k < t->size() do ( (     var d1 : String ; d1 := t.subrange(0+1,k) ;
     var d2 : String ; d2 := t.subrange(k+1,t->size()) ;
    var sb1 : String ; sb1 := StringLib.newString(d1) ;
    var sb2 : String ; sb2 := StringLib.newString(d2) ;
    var rd1 : String ; rd1 := sb1->reverse()+"" ;
    var rd2 : String ; rd2 := sb2->reverse()+"" ;
    train := train->including(d2 + d1) ; 
    train := train->including(d1 + rd2) ; 
    train := train->including(rd2 + d1) ; 
    train := train->including(rd1 + d2) ; 
    train := train->including(d2 + rd1) ; 
    train := train->including(rd1 + rd2) ; 
    train := train->including(rd2 + rd1) ; 
 )  ;     k := k + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.List ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=Integer.parseInt(line);
      for(int i=0 ; i<n ; i++){
        HashSet<String>trains=new HashSet<String>();
        line=br.readLine();
        for(String train : organize(line)){
          if(! trains.contains(train))trains.add(train);
        }
        System.out.println(trains.size());
      }
    }
  }
  static List<String>organize(String line){
    List<String>os=new ArrayList<String>();
    for(int j=1 ; j<line.length(); j++){
      String t1=line.substring(0,j);
      String t2=line.substring(j);
      os.add(t1+t2);
      os.add(t1+new StringBuilder(t2).reverse().toString());
      os.add(new StringBuilder(t1).reverse().toString()+t2);
      os.add(new StringBuilder(t1).reverse().toString()+new StringBuilder(t2).reverse().toString());
      os.add(t2+t1);
      os.add(t2+new StringBuilder(t1).reverse().toString());
      os.add(new StringBuilder(t2).reverse().toString()+t1);
      os.add(new StringBuilder(t2).reverse().toString()+new StringBuilder(t1).reverse().toString());
    }
    return os ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := (line)->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var trains : Set(String) ; trains := Set{} ;
     line := br.readLine() ; 
     for (train : organize(line)) do ( (     if (not(trains->includes(train))) then     trains := trains->including(train) ; else skip )  ) ; 
     OclFile["System.out"].println(trains->size()) )  ;     i := i + 1 ) ) ;     line := br.readLine() ;
 ) );
  static   operation organize( line : String) : Sequence(String)
  pre: true
  post: true
  activity: (     var os : Sequence(String) ; os := Sequence{} ;
         var j : int ; j := 1 ; while j < line->size() do ( (     var t1 : String ; t1 := line.subrange(0+1,j) ;
     var t2 : String ; t2 := line.subrange(j+1,j) ;
    os := os->including(t1 + t2) ; 
    os := os->including(t1 + StringLib.newString(t2)->reverse()+"") ; 
    os := os->including(StringLib.newString(t1)->reverse()+"" + t2) ; 
    os := os->including(StringLib.newString(t1)->reverse()+"" + StringLib.newString(t2)->reverse()+"") ; 
    os := os->including(t2 + t1) ; 
    os := os->including(t2 + StringLib.newString(t1)->reverse()+"") ; 
    os := os->including(StringLib.newString(t2)->reverse()+"" + t1) ; 
    os := os->including(StringLib.newString(t2)->reverse()+"" + StringLib.newString(t1)->reverse()+"") ; 
 )  ;     j := j + 1 ) ; 
     return os );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.PrintWriter ;
public class A_1391 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      for(int i=1 ; i<=n ; i++)out.print(i+" ");
      out.println();
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_1391 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= n do (     skip ;  ;     i := i + 1 ) ; 
     skip ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
class Main {
  public static Scanner sc=new Scanner(in);
  public static Random rand=new Random();
  public void run(){
    int n=sc.nextInt();
    while(n--!=0){
      int c=1 ;
      String str=sc.next();
      Set<String>st=new HashSet<String>();
      for(int i=1 ; i<=str.length(); i++){
        String s1=str.substring(0,i);
        String s2=str.substring(i,str.length());
        String r1=(new StringBuffer(s1)).reverse().toString();
        String r2=(new StringBuffer(s2)).reverse().toString();
        st.add(s1+s2);
        st.add(s2+s1);
        st.add(s1+r2);
        st.add(r2+s1);
        st.add(s2+r1);
        st.add(r1+s2);
        st.add(r1+r2);
        st.add(r2+r1);
      }
      ln(st.size());
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  public int[] nextIntArray(int n){
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=sc.nextInt();
    }
    return res ;
  }
  public static void pr(Object o){
    out.print(o);
  }
  public static void ln(Object o){
    out.println(o);
  }
  public static void ln(){
    out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(in);
  static   attribute rand : OclRandom := OclRandom.newOclRandom();
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
         while (n /= 0) do (    skip ; (     var c : int ; c := 1 ;
     var str : String ; str := sc.getCurrent() ;
    var st : Set(String) ; st := Set{} ;
        var i : int ; i := 1 ; while i <= str->size() do ( (     var s1 : String ; s1 := str.subrange(0+1,i) ;
     var s2 : String ; s2 := str.subrange(i+1,str->size()) ;
    var r1 : String ; r1 := (StringLib.newString(s1))->reverse()+"" ;
    var r2 : String ; r2 := (StringLib.newString(s2))->reverse()+"" ;
    st := st->including(s1 + s2) ; 
    st := st->including(s2 + s1) ; 
    st := st->including(s1 + r2) ; 
    st := st->including(r2 + s1) ; 
    st := st->including(s2 + r1) ; 
    st := st->including(r1 + s2) ; 
    st := st->including(r1 + r2) ; 
    st := st->including(r2 + r1) ; 
 )  ;     i := i + 1 ) ; 
    execute ln(st->size()) ; 
 ) ;  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return res );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     out.println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int target,times,start,end ;
    String ret ;
    Scanner sc=new Scanner(System.in);
    while(true){
      ret="" ;
      target=sc.nextInt();
      if(target==0){
        break ;
      }
      times=sc.nextInt();
      while(times-->0){
        start=sc.nextInt();
        end=sc.nextInt();
        target-=(end-start);
      }
      if(target<=0){
        ret="OK" ;
      }
      else {
        ret=String.valueOf(target);
      }
      System.out.println(ret);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var target : int ;
    var times : int ;
    var start : int ;
    var end : int ;
     var ret : String ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     ret := "" ; 
     target := sc.getCurrent()->toInteger() ; 
    if (target = 0) then (     break ) else skip ; 
    times := sc.getCurrent()->toInteger() ; 
        while (times > 0) do (        times := times - 1 ;     skip ; (     start := sc.getCurrent()->toInteger() ; 
     end := sc.getCurrent()->toInteger() ; 
     target := target-((end - start)) ) ;  ) ;  
    if (target <= 0) then (     ret := "OK" ) else (     ret := ((target) + "") ) ;  
    OclFile["System.out"].println(ret) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Sequences {
  static int getTotalNumberOfSequences(int m,int n){
    if(m<n)return 0 ;
    if(n==0)return 1 ;
    return getTotalNumberOfSequences(m-1,n)+getTotalNumberOfSequences(m/2,n-1);
  }
  public static void main(String[] args){
    int m=10 ;
    int n=4 ;
    System.out.println("Total number of possible sequences "+getTotalNumberOfSequences(m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class Sequences {
  static   operation getTotalNumberOfSequences( m : int, n : int) : int
  pre: true
  post: true
  activity: (     if (m < n) then     return 0 else skip ; 
     if (n = 0) then     return 1 else skip ; 
     return getTotalNumberOfSequences(m - 1, n) + getTotalNumberOfSequences(m / 2, n - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 10 ;
     var n : int ; n := 4 ;
     OclFile["System.out"].println("Total number of possible sequences " + getTotalNumberOfSequences(m, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printKMax(int a[],int n,int k){
    if(k==1){
      for(int i=0 ; i<n ; i+=1)System.out.print(a[i]+" ");
      return ;
    }
    int p=0,q=k-1,t=p,max=a[k-1];
    while(q<=n-1){
      if(a[p]>max)max=a[p];
      p+=1 ;
      if(q==p && p!=n){
        System.out.print(max+" ");
        q++;
        p=++t ;
        if(q<n)max=a[q];
      }
    }
  }
  public static void main(String[] args){
    int a[]={
      1,2,3,4,5,6,7,8,9,10 };
      int n=a.length ;
      int K=3 ;
      printKMax(a,n,K);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printKMax( a : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     if (k = 1) then (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i+(1) ) ; 
     return ) else skip ; 
     var p : int ; p := 0 ;
    var q : int ; q := k - 1 ;
    var t : int ; t := p ;
    var max : int ; max := a[k - 1+1] ;
     while (q <= n - 1) do (     if (a[p+1] > max) then     max := a[p+1] ; else skip ; 
     p := p+(1) ; 
     if (q = p & p /= n) then (     OclFile["System.out"].print(max + " ") ; 
     q := q + 1 ; 
         t := t + 1 ;
 p := t  ; 
     if (q < n) then     max := a[q+1] ; else skip ) else skip ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,4,5,6,7,8,9,10} ;
     var n : int ; n := a->size() ;
     var K : int ; K := 3 ;
     execute printKMax(a, n, K) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner scn=new Scanner(System.in);
    int t=scn.nextInt();
    while(t>0){
      int a=scn.nextInt();
      int b=scn.nextInt();
      int c=scn.nextInt();
      if((b-a)==(c-b)){
        System.out.println("YES");
      }
      else if((a+c)%(2*b)==0){
        System.out.println("YES");
      }
      else if((2*b-c)>0 &&((2*b-c)% a==0)){
        System.out.println("YES");
      }
      else if((2*b-a)>0 &&((2*b-a)% c==0)){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scn.getCurrent()->toInteger() ;
     while (t > 0) do (     var a : int ; a := scn.getCurrent()->toInteger() ;
     var b : int ; b := scn.getCurrent()->toInteger() ;
    var c : int ; c := scn.getCurrent()->toInteger() ;
    if ((b - a) = (c - b)) then (     OclFile["System.out"].println("YES") ) else     if ((a + c) mod (2 * b) = 0) then (     OclFile["System.out"].println("YES") ) else     if ((2 * b - c) > 0 & ((2 * b - c) mod a = 0)) then (     OclFile["System.out"].println("YES") ) else     if ((2 * b - a) > 0 & ((2 * b - a) mod c = 0)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  ;  ;  ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MakeUp {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      double a=sc.nextInt();
      double b=sc.nextInt();
      double c=sc.nextInt();
      if(2*b-c>0 &&(2*b-c)% a==0){
        System.out.println("YES");
      }
      else if(a+c>0 &&(a+c)%(2*b)==0){
        System.out.println("YES");
      }
      else if(2*b-a>0 &&(2*b-a)% c==0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MakeUp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : double ; a := sc.getCurrent()->toInteger() ;
     var b : double ; b := sc.getCurrent()->toInteger() ;
     var c : double ; c := sc.getCurrent()->toInteger() ;
     if (2 * b - c > 0 & (2 * b - c) mod a = 0) then (     OclFile["System.out"].println("YES") ) else     if (a + c > 0 & (a + c) mod (2 * b) = 0) then (     OclFile["System.out"].println("YES") ) else     if (2 * b - a > 0 & (2 * b - a) mod c = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  ;  ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class B1624 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int new_a=b-(c-b);
      int new_b=a+(c-a)/2 ;
      int new_c=a+2*(b-a);
      solve(a,b,c,new_a,new_b,new_c);
    }
  }
  public static void solve(int a,int b,int c,int new_a,int new_b,int new_c){
    if(new_a>=a && new_a!=0 && new_a % a==0){
      System.out.println("YES");
      return ;
    }
    if(new_b>=b && new_b!=0 && new_b % b==0 &&(c-a)% 2==0){
      System.out.println("YES");
      return ;
    }
    if(new_c>=c && new_c!=0 && new_c % c==0){
      System.out.println("YES");
      return ;
    }
    System.out.println("NO");
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1624 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var new_a : int ; new_a := b - (c - b) ;
    var new_b : int ; new_b := a + (c - a) / 2 ;
    var new_c : int ; new_c := a + 2 * (b - a) ;
    execute solve(a, b, c, new_a, new_b, new_c) ; 
 ) ;  ) );
  static   operation solve( a : int, b : int, c : int, new_a : int, new_b : int, new_c : int) : void
  pre: true
  post: true
  activity: (     if (new_a >= a & new_a /= 0 & new_a mod a = 0) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
     if (new_b >= b & new_b /= 0 & new_b mod b = 0 & (c - a) mod 2 = 0) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
    if (new_c >= c & new_c /= 0 & new_c mod c = 0) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
    OclFile["System.out"].println("NO") ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String findLongestPalindrome(String str){
    int count[]=new int[256];
    for(int i=0 ; i<str.length(); i++){
      count[str.charAt(i)]++;
    }
    String beg="",mid="",end="" ;
    for(char ch='a' ; ch<='z' ; ch++){
      if(count[ch] % 2==1){
        mid=String.valueOf(ch);
        count[ch--]--;
      }
      else {
        for(int i=0 ; i<count[ch]/2 ; i++){
          beg+=ch ;
        }
      }
    }
    end=beg ;
    end=reverse(end);
    return beg+mid+end ;
  }
  static String reverse(String str){
    String ans="" ;
    char[] try1=str.toCharArray();
    for(int i=try1.length-1 ; i>=0 ; i--){
      ans+=try1[i];
    }
    return ans ;
  }
  public static void main(String[] args){
    String str="abbaccd" ;
    System.out.println(findLongestPalindrome(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findLongestPalindrome( str : String) : String
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,256)->collect(0) ;
         var i : int ; i := 0 ; while i < str->size() do ( (     count[str->at(i+1)+1] := count[str->at(i+1)+1] + 1 )  ;     i := i + 1 ) ; 
    var beg : String ; beg := "" ;
    var mid : String ; mid := "" ;
    var end : String ; end := "" ;
        var ch : String ; ch := 'a' ; while ch <= 'z' do ( (     if (count[ch+1] mod 2 = 1) then (     mid := ((ch) + "") ; 
     count[ch+1] := count[ch+1] - 1 ) else (         var i : int ; i := 0 ; while i < count[ch+1] / 2 do ( (     beg := beg+(ch) )  ;     i := i + 1 ) ) )  ;     ch := ch + 1 ) ; 
    end := beg ; 
    end := reverse(end) ; 
    return beg + mid + end 
 );
  static   operation reverse( str : String) : String
  pre: true
  post: true
  activity: (     var ans : String ; ans := "" ;
     var try1 : Sequence(String) ; try1 := str->characters() ;
         var i : int ; i := try1->size() - 1 ; while i >= 0 do ( (     ans := ans+(try1[i+1]) )  ;     i := i - 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abbaccd" ;
     OclFile["System.out"].println(findLongestPalindrome(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void reverse(long a[],int b,int e){
    long A[]=new long[e-b];
    for(int i=0 ; i<e-b ; i++)A[i]=a[e-1-i];
    for(int i=0 ; i<e-b ; i++)a[b+i]=A[i];
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long a[]=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextLong();
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      int b=sc.nextInt();
      int e=sc.nextInt();
      reverse(a,b,e);
    }
    for(int i=0 ; i<n-1 ; i++)System.out.print(a[i]+" ");
    System.out.println(a[n-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation reverse( a : Sequence(long), b : int, e : int) : void
  pre: true
  post: true
  activity: (     var A : Sequence(long) ; A := Integer.subrange(1,e - b)->collect(0) ;
         var i : int ; i := 0 ; while i < e - b do (     A[i+1] := a[e - 1 - i+1] ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < e - b do (     a[b + i+1] := A[i+1] ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var b : int ; b := sc.getCurrent()->toInteger() ;
     var e : int ; e := sc.getCurrent()->toInteger() ;
     execute reverse(a, b, e) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a[n - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int[] a=new int[n];
    str=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++)a[i]=Integer.parseInt(str[i]);
    str=br.readLine().split(" ");
    int q=Integer.parseInt(str[0]);
    for(int i=0 ; i<q ; i++){
      str=br.readLine().split(" ");
      int b=Integer.parseInt(str[0]);
      int e=Integer.parseInt(str[1]);
      e-=1 ;
      for(int j=b ; j<b+(e-b+1)/2 ; j++){
        int k=e-(j-b);
        int bf=a[j];
        a[j]=a[k];
        a[k]=bf ;
      }
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(a[i]);
      if(i!=n-1)System.out.print(" ");
    }
    System.out.print("\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    str := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (str[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    str := br.readLine()->split(" ") ; 
    var q : int ; q := (str[0+1])->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     str := br.readLine()->split(" ") ; 
     var b : int ; b := (str[0+1])->toInteger() ;
    var e : int ; e := (str[1+1])->toInteger() ;
    e := e-(1) ; 
        var j : int ; j := b ; while j < b + (e - b + 1) / 2 do ( (     var k : int ; k := e - (j - b) ;
     var bf : int ; bf := a[j+1] ;
     a[j+1] := a[k+1] ; 
     a[k+1] := bf )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(a[i+1]) ; 
     if (i /= n - 1) then     OclFile["System.out"].print(" ") ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("\n") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static Scanner scInputData=new Scanner(System.in);
  static ArrayList<Integer>arrA=new ArrayList<Integer>();
  public static void main(String[] args){
    getArr(arrA);
    reverseArr();
    putResult();
  }
  private static void putResult(){
    for(int arrNum=0 ; arrNum<arrA.size()-1 ; arrNum++){
      System.out.print(arrA.get(arrNum)+" ");
    }
    System.out.println(arrA.get(arrA.size()-1));
  }
  private static void reverseArr(){
    int revNum=scInputData.nextInt();
    int start=0,end=0 ;
    for(int indexToRev=0 ; indexToRev<revNum ; indexToRev++){
      start=scInputData.nextInt();
      end=scInputData.nextInt();
      reverseNum(start,end);
    }
  }
  private static void reverseNum(int start,int end){
    int changeNum=(int)(end-start)/2 ;
    int val_small=0 ;
    for(int indexToChange=0 ; indexToChange<changeNum ; indexToChange++){
      val_small=arrA.get(start+indexToChange);
      arrA.set(start+indexToChange,arrA.get(end-indexToChange-1));
      arrA.set(end-indexToChange-1,val_small);
    }
  }
  private static void getArr(ArrayList<Integer>arr){
    int iArrNum=0 ;
    iArrNum=scInputData.nextInt();
    while(arr.size()<iArrNum){
      arr.add(scInputData.nextInt());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scInputData : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute arrA : Sequence(int) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute getArr(arrA) ; 
     execute reverseArr() ; 
     execute putResult() );
  static   operation putResult() : void
  pre: true
  post: true
  activity: (         var arrNum : int ; arrNum := 0 ; while arrNum < arrA->size() - 1 do ( (     OclFile["System.out"].print(arrA->at(arrNum+1) + " ") )  ;     arrNum := arrNum + 1 ) ; 
     OclFile["System.out"].println(arrA->at(arrA->size() - 1+1)) );
  static   operation reverseArr() : void
  pre: true
  post: true
  activity: (     var revNum : int ; revNum := scInputData.getCurrent()->toInteger() ;
     var start : int ; start := 0 ;
    var end : int ; end := 0 ;
         var indexToRev : int ; indexToRev := 0 ; while indexToRev < revNum do ( (     start := scInputData.getCurrent()->toInteger() ; 
     end := scInputData.getCurrent()->toInteger() ; 
     execute reverseNum(start, end) )  ;     indexToRev := indexToRev + 1 ) );
  static   operation reverseNum( start : int, end : int) : void
  pre: true
  post: true
  activity: (     var changeNum : int ; changeNum := (end - start)->oclAsType(int) / 2 ;
     var val_small : int ; val_small := 0 ;
         var indexToChange : int ; indexToChange := 0 ; while indexToChange < changeNum do ( (     val_small := arrA->at(start + indexToChange+1) ; 
     arrA := arrA.setAt(start + indexToChange+1,arrA->at(end - indexToChange - 1+1)) ; 
     arrA := arrA.setAt(end - indexToChange - 1+1,val_small) )  ;     indexToChange := indexToChange + 1 ) );
  static   operation getArr( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var iArrNum : int ; iArrNum := 0 ;
     iArrNum := scInputData.getCurrent()->toInteger() ; 
     while (arr->size() < iArrNum) do (     arr->excludes(scInputData.getCurrent()->toInteger()) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Round663A {
  public static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    long t=Integer.parseInt(br.readLine());
    while(t-->0){
      int n=Integer.parseInt(br.readLine());
      for(int i=n ; i>0 ; i--){
        pw.print(i+" ");
      }
      pw.println();
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Round663A {
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : long ; t := (br.readLine())->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
         var i : int ; i := n ; while i > 0 do ( (     skip )  ;     i := i - 1 ) ; 
     skip ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int t=sc.nextInt();
      if(t==0)break ;
      int n=sc.nextInt(),sum=0 ;
      for(int i=0 ; i<n ; i++){
        int s=sc.nextInt(),f=sc.nextInt();
        sum+=f-s ;
      }
      System.out.println(t<=sum ? "OK" : t-sum);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var t : int ; t := sc.getCurrent()->toInteger() ;
     if (t = 0) then     break else skip ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
    var f : int ; f := sc.getCurrent()->toInteger() ;
     sum := sum+(f - s) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if t <= sum then "OK" else t - sum endif) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int size=in.nextInt(),arr[]=new int[size];
    for(int i=0 ; i<size ; i++){
      arr[i]=Integer.parseInt(in.next());
    }
    int loop=in.nextInt();
    for(int i=0 ; i<loop ; i++){
      int begin=Integer.parseInt(in.next()),end=Integer.parseInt(in.next());
      for(int j=0 ; j<(end-begin)/2 ; j++){
        int temp=arr[begin+j];
        arr[begin+j]=arr[end-1-j];
        arr[end-1-j]=temp ;
      }
    }
    for(int i=0 ; i<size ; i++){
      out.printf("%d%s",arr[i],(i<size-1)? " " : "\n");
    }
    out.flush();
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var size : int ; size := in.getCurrent()->toInteger() ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < size do ( (     arr[i+1] := (in.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var loop : int ; loop := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < loop do ( (     var begin : int ; begin := (in.getCurrent())->toInteger() ;
    var end : int ; end := (in.getCurrent())->toInteger() ;
         var j : int ; j := 0 ; while j < (end - begin) / 2 do ( (     var temp : int ; temp := arr[begin + j+1] ;
     arr[begin + j+1] := arr[end - 1 - j+1] ; 
     arr[end - 1 - j+1] := temp )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < size do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    int num=sc.nextInt();
    ArrayList<Integer>array=new ArrayList<>();
    for(int i=0 ; i<num ; i++){
      int tmp=sc.nextInt();
      array.add(tmp);
    }
    int num_query=sc.nextInt();
    for(int i=0 ; i<num_query ; i++){
      int l=sc.nextInt();
      int r=sc.nextInt();
      List<Integer>sub=array.subList(l,r);
      Collections.reverse(sub);
      for(int j=l ; j<r ; j++){
        array.set(j,sub.get(j-l));
      }
    }
    for(int i=0 ; i<array.size(); i++){
      sb.append(array.get(i));
      if(i!=array.size()-1)sb.append(' ');
    }
    System.out.println(sb);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
    var num : int ; num := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Sequence{} ;
        var i : int ; i := 0 ; while i < num do ( (     var tmp : int ; tmp := sc.getCurrent()->toInteger() ;
     array := array->including(tmp) )  ;     i := i + 1 ) ; 
    var num_query : int ; num_query := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < num_query do ( (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var sub : Sequence(int) ; sub := array.subrange(l+1,r) ;
    sub := sub->reverse() ; 
        var j : int ; j := l ; while j < r do ( (     array := array.setAt(j+1,sub->at(j - l+1)) )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < array->size() do ( (     sb := sb + StringLib.newString(array->at(i+1)) ; 
     if (i /= array->size() - 1) then     sb := sb + StringLib.newString(' ') ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Tttest {
  public static int fun(String s1,String s2){
    Set<Character>s=new HashSet<>();
    for(int i=0 ; i<s1.length(); i++){
      s.add(s1.charAt(i));
    }
    for(int i=0 ; i<s2.length(); i++){
      s.add(s2.charAt(i));
    }
    return s.size()-1 ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      String s1=sc.next();
      String s2=sc.next();
      System.out.println(fun(s1,s2));
      t--;
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Tttest {
  static   operation fun( s1 : String, s2 : String) : int
  pre: true
  post: true
  activity: (     var s : Set(String) ; s := Set{} ;
         var i : int ; i := 0 ; while i < s1->size() do ( (     s := s->including(s1->at(i+1)) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < s2->size() do ( (     s := s->including(s2->at(i+1)) )  ;     i := i + 1 ) ; 
     return s->size() - 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var s1 : String ; s1 := sc.getCurrent() ;
     var s2 : String ; s2 := sc.getCurrent() ;
     OclFile["System.out"].println(fun(s1, s2)) ; 
     t := t - 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Fast f=new Fast(System.in);
    int t=f.nextInt();
    while(t--!=0){
      String s1=f.next();
      String s2=f.next();
      String s=s1+s2 ;
      int[] freq=new int[26];
      int ans=0 ;
      for(int i=0 ; i<s.length(); i++)freq[s.charAt(i)-'a']++;
      for(int i : freq)ans+=i!=0 ? 1 : 0 ;
      System.out.println(ans-1);
    }
    System.out.flush();
    System.out.close();
  }
}
class Fast {
  StringTokenizer st ;
  BufferedReader br ;
  public Fast(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public Fast(String file)throws IOException {
    br=new BufferedReader(new FileReader(file));
  }
  public Fast(FileReader r){
    br=new BufferedReader(r);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String readAllLines(BufferedReader reader)throws IOException {
    StringBuilder content=new StringBuilder();
    String line ;
    while((line=reader.readLine())!=null){
      content.append(line);
      content.append(System.lineSeparator());
    }
    return content.toString();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public int[] nextIntArray(int n)throws IOException {
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : Fast ; f := Fast.newFast(OclFile["System.in"]) ;
     var t : int ; t := f.nextInt() ;
        while (t /= 0) do (    skip ; (     var s1 : String ; s1 := f.next() ;
     var s2 : String ; s2 := f.next() ;
    var s : String ; s := s1 + s2 ;
    var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < s->size() do (     freq[s->at(i+1) - ('a')->char2byte()+1] := freq[s->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    for (i : freq) do (     ans := ans+(if i /= 0 then 1 else 0 endif) ;  ) ; 
    OclFile["System.out"].println(ans - 1) ; 
 ) ;  ) ;  
    OclFile["System.out"].flush() ; 
    OclFile["System.out"].close() ; 
 );
}
class Fast {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newFast( s : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(s))) );
   static operation newFast( file : String) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   static operation newFast( r : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(r);
    return self );
  operation initialise( r : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(r) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation readAllLines( reader : OclFile) : String
  pre: true
  post: true
  activity: (     var content : String ; content := StringLib.newString() ;
     var line : String ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     content := content + StringLib.newString(line) ; 
     content := content + StringLib.newString(lineSeparator()) ) ;     line := reader.readLine() ;
 ) ;  
     return content+"" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class A1721 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      char[] data=(in.next()+in.next()).toCharArray();
      int[] stat=new int[26];
      for(char c : data){
        stat[c-'a']++;
      }
      Arrays.sort(stat);
      int answer ;
      if(stat[25]==4){
        answer=0 ;
      }
      else if(stat[25]==3){
        answer=1 ;
      }
      else if(stat[25]==2){
        answer=(stat[24]==2)? 1 : 2 ;
      }
      else {
        answer=3 ;
      }
      System.out.println(answer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1721 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var data : Sequence(String) ; data := (in.getCurrent() + in.getCurrent())->characters() ;
     var stat : Sequence(int) ; stat := Integer.subrange(1,26)->collect(0) ;
    for (c : data) do ( (     stat[c - ('a')->char2byte()+1] := stat[c - ('a')->char2byte()+1] + 1 )  ) ; 
    stat := stat->sort() ; 
    var answer : int ;
    if (stat[25+1] = 4) then (     answer := 0 ) else     if (stat[25+1] = 3) then (     answer := 1 ) else     if (stat[25+1] = 2) then (     answer := if (stat[24+1] = 2) then 1 else 2 endif ) else (     answer := 3 ) ;  ;  ;  
    OclFile["System.out"].println(answer) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    while(n-->0){
      String s1=scanner.next();
      String s2=scanner.next();
      int[] arr=new int[26];
      int count=0 ;
      for(int i=0 ; i<s1.length(); ++i){
        arr[(s1.charAt(i)-'a')]++;
        arr[(s2.charAt(i)-'a')]++;
      }
      for(int i=0 ; i<26 ; ++i){
        if(arr[i]!=0){
          count++;
        }
      }
      System.out.println(count-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var s1 : String ; s1 := scanner.getCurrent() ;
     var s2 : String ; s2 := scanner.getCurrent() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,26)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < s1->size() do ( (     arr[(s1->at(i+1) - ('a')->char2byte())+1] := arr[(s1->at(i+1) - ('a')->char2byte())+1] + 1 ; 
     arr[(s2->at(i+1) - ('a')->char2byte())+1] := arr[(s2->at(i+1) - ('a')->char2byte())+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 26 do ( (     if (arr[i+1] /= 0) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count - 1) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.StringTokenizer ;
import java.util.TreeMap ;
public class A {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      HashSet<Character>hs=new HashSet<Character>();
      for(int i=0 ; i<2 ; i++){
        String x=sc.next();
        for(int j=0 ; j<2 ; j++)hs.add(x.charAt(j));
      }
      out.println(hs.size()==1 ? 0 : hs.size()==2 ? 1 : hs.size()==3 ? 2 : 3);
    }
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public boolean hasNext(){
      return st.hasMoreTokens();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var hs : Set(String) ; hs := Set{} ;
         var i : int ; i := 0 ; while i < 2 do ( (     var x : String ; x := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < 2 do (     hs := hs->including(x->at(j+1)) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     skip ) ;  ) ;  
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return st.hasNext() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findMissingPositive(int arr[],int n){
    int m=1 ;
    HashSet<Integer>x=new HashSet<Integer>();
    for(int i=0 ; i<n ; i++){
      if(m<arr[i]){
        x.add(arr[i]);
      }
      else if(m==arr[i]){
        m=m+1 ;
        while(x.contains(m)){
          x.remove(m);
          m=m+1 ;
        }
      }
    }
    return m ;
  }
  public static void main(String[] args){
    int arr[]={
      2,3,-7,6,8,1,-10,15 };
      int n=arr.length ;
      System.out.println(findMissingPositive(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMissingPositive( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var m : int ; m := 1 ;
     var x : Set(int) ; x := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (m < arr[i+1]) then (     x := x->including(arr[i+1]) ) else     if (m = arr[i+1]) then (     m := m + 1 ; 
     while (x->includes(m)) do (     x := x->excludingAt(m+1) ; 
     m := m + 1 ) ) else skip ; )  ;     i := i + 1 ) ; 
     return m );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,-7,6,8,1,-10,15} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMissingPositive(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final int max=100000+5 ;
    PriorityQueue<Integer>pq=new PriorityQueue<>(10,Collections.reverseOrder());
    int N=sc.nextInt();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++)A[i]=sc.nextInt();
    int[] rec=new int[max+1];
    for(int i=0 ; i<N ; i++)rec[A[i] ]++;
    for(int i=1 ; i<=max ; i++){
      if(rec[i]>0)pq.add(rec[i]);
    }
    if(pq.size()==1){
      System.out.println(1);
      System.exit(0);
    }
    while(pq.size()>1 && pq.peek()>1){
      int cur=pq.poll();
      if(cur>=3 && cur % 2==1){
        pq.add(1);
        continue ;
      }
      if(cur % 2==0){
        int next=pq.poll();
        if(next==1)pq.add(1);
        else {
          pq.add(1);
          pq.add(next-1);
        }
      }
    }
    System.out.println(pq.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var max : int ; max := 100000 + 5 ;
    var pq : Sequence(int) ; pq := Sequence{} ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     A[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var rec : Sequence(int) ; rec := Integer.subrange(1,max + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     rec[A[i+1]+1] := rec[A[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= max do ( (     if (rec[i+1] > 0) then     pq := pq->including(rec[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    if (pq->size() = 1) then (     OclFile["System.out"].println(1) ; 
 OclProcess.exit(0) ) else skip ; 
    while (pq->size() > 1 & pq->min() > 1) do (     var cur : int ; cur := pq->min() ;
     if (cur >= 3 & cur mod 2 = 1) then (     pq := pq->including(1) ; 
     continue ) else skip ; 
     if (cur mod 2 = 0) then (     var next : int ; next := pq->min() ;
     if (next = 1) then     pq := pq->including(1) ; else (     pq := pq->including(1) ; 
     pq := pq->including(next - 1) ) ) else skip ) ; 
    OclFile["System.out"].println(pq->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
    }
    Arrays.sort(A);
    int ba=-1 ;
    int cnt=0 ;
    for(int a : A){
      if(ba==a){
        cnt++;
      }
      else {
        ba=a ;
      }
    }
    cnt=(int)Math.ceil(cnt/2.0)*2 ;
    out.println(N-cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    var ba : int ; ba := -1 ;
    var cnt : int ; cnt := 0 ;
    for (a : A) do ( (     if (ba = a) then (     cnt := cnt + 1 ) else (     ba := a ) )  ) ; 
    cnt := (cnt / 2.0)->ceil()->oclAsType(int) * 2 ; 
    out.println(N - cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    long total=0 ;
    for(long i=0 ; i<h ; i++){
      for(long j=0 ; j<w ; j++){
        long x=sc.nextInt();
        total+=x*(i+1)*(h-i)*(j+1)*(w-j);
      }
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var total : long ; total := 0 ;
        var i : long ; i := 0 ; while i < h do ( (         var j : long ; j := 0 ; while j < w do ( (     var x : long ; x := sc.getCurrent()->toInteger() ;
     total := total+(x * (i + 1) * (h - i) * (j + 1) * (w - j)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int fact(int num){
    int fact=1 ;
    while(num>1){
      fact*=num ;
      num-=1 ;
    }
    return fact ;
  }
  static int catalan(int n){
    return fact(2*n)/(fact(n)*fact(n+1));
  }
  public static void main(String[] args){
    int n=5 ;
    int arr[]={
      1,2,3,4,5 };
      int i,k ;
      for(k=0 ; k<n ; k++){
        int s=0 ;
        for(i=0 ; i<n ; i++){
          if(arr[i]<arr[k])s+=1 ;
        }
        int catalan_leftBST=catalan(s);
        int catalan_rightBST=catalan(n-s-1);
        int totalBST=catalan_rightBST*catalan_leftBST ;
        System.out.print(totalBST+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation fact( num : int) : int
  pre: true
  post: true
  activity: (     var fact : int ; fact := 1 ;
     while (num > 1) do (     fact := fact*(num) ; 
     num := num-(1) ) ; 
     return fact );
  static   operation catalan( n : int) : int
  pre: true
  post: true
  activity: (     return fact(2 * n) / (fact(n) * fact(n + 1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var i : int ;
    var k : int ;
         k := 0 ; while k < n do ( (     var s : int ; s := 0 ;
         i := 0 ; while i < n do ( (     if (arr[i+1] < arr[k+1]) then     s := s+(1) ; else skip )  ;     i := i + 1 ) ; 
    var catalan_leftBST : int ; catalan_leftBST := catalan(s) ;
    var catalan_rightBST : int ; catalan_rightBST := catalan(n - s - 1) ;
    var totalBST : int ; totalBST := catalan_rightBST * catalan_leftBST ;
    OclFile["System.out"].print(totalBST + " ") ; 
 )  ;     k := k + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test283 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int x=in.nextInt();
      for(int i=x ; i>0 ; i--){
        System.out.print(i+" ");
      }
      System.out.println();
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test283 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
         var i : int ; i := x ; while i > 0 do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println() )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static PrintWriter out ;
  public static FastScanner in ;
  private void solve(){
    int[] cnt=new int[100002];
    Arrays.fill(cnt,0);
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      cnt[in.nextInt()]++;
    }
    int ans=n ;
    for(int i=0 ; i<100001 ; i++){
      if(cnt[i]>1){
        ans-=(cnt[i]-1);
      }
    }
    if(ans % 2==0)ans--;
    out.print(ans);
  }
  private void runIO(){
    in=new FastScanner();
    out=new PrintWriter(new BufferedOutputStream(System.out));
    solve();
    out.close();
  }
  private static class FastScanner {
    BufferedReader bufferedReader ;
    StringTokenizer stringTokenizer ;
    private FastScanner(){
      bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    }
    private String next(){
      if(stringTokenizer==null || ! stringTokenizer.hasMoreElements()){
        try {
          stringTokenizer=new StringTokenizer(bufferedReader.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return stringTokenizer.nextToken();
    }
    private int nextInt(){
      return Integer.parseInt(next());
    }
    private long nextLong(){
      return Long.parseLong(next());
    }
    private String nextLine(){
      String ret="" ;
      try {
        ret=bufferedReader.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return ret ;
    }
  }
  public static void main(String[] args){
    new Main().runIO();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile;
  static   attribute in : FastScanner;
   operation solve() : void
  pre: true
  post: true
  activity: (     var cnt : Sequence(int) ; cnt := Integer.subrange(1,100002)->collect(0) ;
     cnt := cnt->collect(0) ; 
    var n : int ; n := in.nextInt() ;
        var i : int ; i := 0 ; while i < n do ( (     cnt[in.nextInt()+1] := cnt[in.nextInt()+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := n ;
        var i : int ; i := 0 ; while i < 100001 do ( (     if (cnt[i+1] > 1) then (     ans := ans-((cnt[i+1] - 1)) ) else skip )  ;     i := i + 1 ) ; 
    if (ans mod 2 = 0) then     ans := ans - 1 ; else skip ; 
    skip ; 
 );
   operation runIO() : void
  pre: true
  post: true
  activity: (     in := FastScanner.newFastScanner() ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
     execute solve() ; 
     skip );
  static class FastScanner {
   attribute bufferedReader : OclFile;
   attribute stringTokenizer : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (stringTokenizer = null or not(stringTokenizer.hasNext())) then (     try (     stringTokenizer := OclIterator.newOclIterator_String(bufferedReader.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) else skip ; 
     return stringTokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var ret : String ; ret := "" ;
     try (     ret := bufferedReader.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return ret );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().runIO() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      int[] a=new int[n];
      Map<Integer,Integer>map=new HashMap<>();
      IntStream.range(0,n).forEach(i->{
        a[i]=scanner.nextInt();
        map.put(a[i],map.getOrDefault(a[i],0)+1);
      }
);
      int sum=map.entrySet().stream().mapToInt(entry->entry.getValue()-1).sum();
      System.out.println(n-sum-(sum & 1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var map : Map(int,int) ; map := Map{} ;
    for i : Integer.subrange(0, n-1) do
    (    skip) ; 
    var sum : int ; sum := map->asSet()->collect( _x1 | (lambda entry : OclAny in entry.getValue() - 1)->apply(_x1) )->sum() ;
    OclFile["System.out"].println(n - sum - (MathLib.bitwiseAnd(sum,1))) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int numOfCards=s.nextInt();
    int numOverlap=0 ;
    Set<Integer>cards=new HashSet<Integer>();
    for(int i=0 ; i<numOfCards ; i++){
      int tmp=s.nextInt();
      if(! cards.contains(tmp)){
        cards.add(tmp);
      }
      else {
        numOverlap++;
      }
    }
    if(numOverlap % 2==0){
      System.out.println(numOfCards-numOverlap);
    }
    else {
      System.out.println(numOfCards-numOverlap-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numOfCards : int ; numOfCards := s.getCurrent()->toInteger() ;
    var numOverlap : int ; numOverlap := 0 ;
    var cards : Set(int) ; cards := Set{} ;
        var i : int ; i := 0 ; while i < numOfCards do ( (     var tmp : int ; tmp := s.getCurrent()->toInteger() ;
     if (not(cards->includes(tmp))) then (     cards := cards->including(tmp) ) else (     numOverlap := numOverlap + 1 ) )  ;     i := i + 1 ) ; 
    if (numOverlap mod 2 = 0) then (     OclFile["System.out"].println(numOfCards - numOverlap) ) else (     OclFile["System.out"].println(numOfCards - numOverlap - 1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int k=in.nextInt();
    int n=-1,m=-1 ;
    for(int i=5 ; i*i<=k ; i++){
      if(k % i==0){
        n=i ;
        m=k/n ;
      }
    }
    if(n==-1){
      System.out.println(-1);
      return ;
    }
    char[] c={
      'a','e','i','o','u' };
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<m ; j++){
        pw.print(c[(i+j)% 5]);
      }
      pw.close();
    }
    static void debug(Object...obj){
      System.err.println(Arrays.deepToString(obj));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var n : int ; n := -1 ;
    var m : int ; m := -1 ;
        var i : int ; i := 5 ; while i * i <= k do ( (     if (k mod i = 0) then (     n := i ; 
     m := k / n ) else skip )  ;     i := i + 1 ) ; 
    if (n = -1) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var c : Sequence(String) ; c := Sequence{'a','e','i','o','u'} ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < m do ( (     skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.System.out ;
public class pre127 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 int isPrime(int n){
    if(n==2)return-1 ;
    int ans=-1 ;
    for(int i=2 ; i*i<=n ; i++)if(n % i==0)ans=i ;
    return ans ;
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int k=obj.nextInt(),p=isPrime(k);
    if(p<5 || k<25){
      out.println(-1);
      return ;
    }
    char v[]={
      'a','e','i','o','u' };
      int t,n=p,m=k/n ;
      for(int i=0 ; i<n ; i++){
        t=i % 5 ;
        for(int j=0 ; j<m ; j++){
          out.print(v[t % 5]);
          t++;
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class pre127 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation isPrime( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 2) then     return -1 else skip ; 
     var ans : int ; ans := -1 ;
         var i : int ; i := 2 ; while i * i <= n do (     if (n mod i = 0) then     ans := i ; else skip ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var k : int ; k := obj.nextInt() ;
    var p : int ; p := isPrime(k) ;
    if (p < 5 or k < 25) then (     out.println(-1) ; 
     return ) else skip ; 
    var v : Sequence(String) ; v := Sequence{'a','e','i','o','u'} ;
    var t : int ;
    var n : int ; n := p ;
    var m : int ; m := k / n ;
        var i : int ; i := 0 ; while i < n do ( (     t := i mod 5 ; 
         var j : int ; j := 0 ; while j < m do ( (     out.print(v[t mod 5+1]) ; 
     t := t + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  static final char[] VOWELS={
    'a','e','i','o','u' };
    public static void main(String[] args){
      Scanner sc=new Scanner(System.in);
      int k=sc.nextInt();
      System.out.println(solve(k));
      sc.close();
    }
    static String solve(int k){
      for(int row=VOWELS.length ; row*row<=k ; row++){
        if(k % row==0){
          int col=k/row ;
          char[][] grid=new char[row][col];
          for(int r=0 ; r<row ; r++){
            for(int c=0 ; c<col ; c++){
              grid[r][c]=VOWELS[(r+c)% VOWELS.length];
            }
          }
          return Arrays.stream(grid).map(String :: new).collect(Collectors.joining());
        }
      }
      return "-1" ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute VOWELS : Sequence(String) := Sequence{'a','e','i','o','u'};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(k)) ; 
     skip );
  static   operation solve( k : int) : String
  pre: true
  post: true
  activity: (         var row : int ; row := VOWELS->size() ; while row * row <= k do ( (     if (k mod row = 0) then (     var col : int ; col := k / row ;
     var grid : Sequence(Sequence(String)) ; grid := Integer.subrange(1,row)->collect(Integer.subrange(1,col)->collect(0)) ;
         var r : int ; r := 0 ; while r < row do ( (         var c : int ; c := 0 ; while c < col do ( (     grid[r+1][c+1] := VOWELS[(r + c) mod VOWELS->size()+1] )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
     return stream(grid)->collect( _x1 | (lambda _pars : OclAny in String.newString().new(_pars))->apply(_x1) ).collect(Collectors.joining()) ) else skip )  ;     row := row + 1 ) ; 
     return "-1" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class codeforces {
  public static void main(String args[])throws IOException {
    File file=new File("input.txt");
    Scanner sc=new Scanner(file);
    FileWriter fw=new FileWriter("output.txt");
    int n=sc.nextInt();
    int k=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    HashMap<Integer,List<Integer>>hm=new HashMap<>();
    for(int i=0 ; i<=100 ; i++){
      ArrayList<Integer>a=new ArrayList<>();
      for(int j=0 ; j<n ; j++){
        if(arr[j]==i){
          a.add(j+1);
        }
      }
      if(a.size()!=0)hm.put(i,a);
    }
    int f=0,t=0 ;
    ArrayList<Integer>x=new ArrayList<>();
    for(int i=100 ; i>=0 ; i--){
      if(hm.containsKey(i)){
        for(int j : hm.get(i)){
          if(k>0){
            x.add(j);
            t=i ;
            k--;
          }
          else {
            f=1 ;
            break ;
          }
        }
        if(f==1)break ;
      }
    }
    fw.write(String.valueOf(t));
    fw.write("\n");
    for(int i : x){
      String s=String.valueOf(i);
      s=s+" " ;
      fw.write(s);
    }
    fw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var file : OclFile ; file := OclFile("input.txt") ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(file) ;
    var fw : OclFile ; fw := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var hm : Map(int,Sequence(int)) ; hm := Map{} ;
        var i : int ; i := 0 ; while i <= 100 do ( (     var a : Sequence(int) ; a := Sequence{} ;
         var j : int ; j := 0 ; while j < n do ( (     if (arr[j+1] = i) then (     a := a->including(j + 1) ) else skip )  ;     j := j + 1 ) ; 
     if (a->size() /= 0) then     hm := hm->union(Map{i |-> a}) ; else skip )  ;     i := i + 1 ) ; 
    var f : int ; f := 0 ;
    var t : int ; t := 0 ;
    var x : Sequence(int) ; x := Sequence{} ;
        var i : int ; i := 100 ; while i >= 0 do ( (     if (hm->keys()->includes(i)) then (     for (j : hm->at(i)) do ( (     if (k > 0) then (     x := x->including(j) ; 
     t := i ; 
     k := k - 1 ) else (     f := 1 ; 
     break ) )  ) ; 
     if (f = 1) then     break else skip ) else skip )  ;     i := i - 1 ) ; 
    skip ; 
    skip ; 
    for (i : x) do ( (     var s : String ; s := ((i) + "") ;
     s := s + " " ; 
     skip )  ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Reading {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner((new FileReader("input.txt")));
    FileWriter out=new FileWriter("output.txt");
    int n=sc.nextInt(),k=sc.nextInt();
    List<Integer>a=new ArrayList<>();
    for(int i=0 ; i<n ; i++)a.add(sc.nextInt());
    List<Integer>b=new ArrayList<>(a);
    Collections.sort(b);
    out.write(b.get(n-k)+"\n");
    int h=b.get(n-k);
    for(int i=0 ; i<n ; i++){
      if(a.get(i)>=h && k>0){
        out.write(i+1+" ");
--k ;
      }
    }
    sc.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Reading {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read((OclFile.newOclFile_Read(OclFile.newOclFile("input.txt")))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     a := a->including(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := Sequence{}->union(a) ;
    b := b->sort() ; 
    skip ; 
    var h : int ; h := b->at(n - k+1) ;
        var i : int ; i := 0 ; while i < n do ( (     if (a->at(i+1) >= h & k > 0) then (     skip ; 
     k := k - 1 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class reading {
  public static void main(String[] args)throws IOException {
    Scanner bf=new Scanner(new File("Input.txt"));
    PrintWriter pw=new PrintWriter("output.txt");
    String[] ars=bf.nextLine().split(" ");
    int n=Integer.parseInt(ars[0]);
    int k=Integer.parseInt(ars[1]);
    int[] arr=new int[n];
    ars=bf.nextLine().split(" ");
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(ars[i]);
    }
    int[] copy=arr.clone();
    Arrays.sort(arr);
    pw.println(arr[n-k]);
    StringBuilder sb=new StringBuilder();
    for(int i=n-k ; i<n ; i++){
      sb.append(get(copy,arr[i])+" ");
    }
    pw.println(sb.toString());
    pw.close();
  }
  private static int get(int[] arr,int x){
    int y=0 ;
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]==x){
        y=i ;
        arr[i]=-1 ;
        break ;
      }
    }
    return y+1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class reading {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile("Input.txt")) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
    var ars : Sequence(String) ; ars := bf.nextLine()->split(" ") ;
    var n : int ; n := (ars[0+1])->toInteger() ;
    var k : int ; k := (ars[1+1])->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    ars := bf.nextLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (ars[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var copy : Sequence(int) ; copy := arr->copy() ;
    arr := arr->sort() ; 
    skip ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := n - k ; while i < n do ( (     sb := sb + StringLib.newString(at(copy, arr[i+1]+1) + " ") )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation get( arr : Sequence(int), x : int) : int
  pre: true
  post: true
  activity: (     var y : int ; y := 0 ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = x) then (     y := i ; 
     arr[i+1] := -1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     return y + 1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javax.naming.NamingEnumeration ;
import javax.swing.plaf.IconUIResource ;
import javax.swing.plaf.synth.SynthOptionPaneUI ;
import java.awt.font.FontRenderContext ;
import java.awt.image.ImageProducer ;
import java.beans.beancontext.BeanContextServiceRevokedEvent ;
import java.lang.reflect.Array ;
import java.util.*;
import java.math.BigInteger ;
import java.util.spi.LocaleNameProvider ;
public class ques {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int j=0 ; j<n ; j++){
      long a=sc.nextLong();
      long b=sc.nextLong();
      if(Math.abs(a-b)==1)System.out.println("NO");
      else System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ques {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < n do ( (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
     if (if a - b < 0 then -(a - b) else a - b endif = 1) then     OclFile["System.out"].println("NO") ; else     OclFile["System.out"].println("YES") ; )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[])throws Exception {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    if(n % 2==0){
      System.out.println(-1);
    }
    else {
      for(int i=0 ; i<n ; ++i){
        System.out.print(i+" ");
      }
      System.out.println();
      for(int i=0 ; i<n ; ++i){
        System.out.print(i+" ");
      }
      System.out.println();
      for(int i=0 ; i<n ; ++i){
        System.out.print(((2*i)% n)+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (     OclFile["System.out"].println(-1) ) else (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(((2 * i) mod n) + " ") )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findevenPair(int[] A,int N){
    int i,j ;
    int evenPair=0 ;
    for(i=0 ; i<N ; i++){
      for(j=i+1 ; j<N ; j++){
        if((A[i] & A[j])% 2==0)evenPair++;
      }
    }
    return evenPair ;
  }
  public static void main(String[] args){
    int[] a={
      5,1,3,2 };
      int n=a.length ;
      System.out.println(findevenPair(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findevenPair( A : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var evenPair : int ; evenPair := 0 ;
         i := 0 ; while i < N do ( (         j := i + 1 ; while j < N do ( (     if ((A[i+1] & A[j+1]) mod 2 = 0) then     evenPair := evenPair + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return evenPair );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{5,1,3,2} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(findevenPair(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[])throws Exception {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    if(n % 2==0){
      System.out.println(-1);
    }
    else {
      for(int i=0 ; i<n ; ++i){
        System.out.print(i+" ");
      }
      System.out.println();
      for(int i=0 ; i<n ; ++i){
        System.out.print(i+" ");
      }
      System.out.println();
      for(int i=0 ; i<n ; ++i){
        System.out.print(((2*i)% n)+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (     OclFile["System.out"].println(-1) ) else (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(((2 * i) mod n) + " ") )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int n=Integer.parseInt(in.readLine());
    if(n % 2==0){
      System.out.println(-1);
      return ;
    }
    int[] a=new int[n],b=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=i ;
    int p=n-1 ;
    for(int i=0 ; i<n ; i+=2)b[i]=p--;
    for(int i=1 ; i<n ; i+=2)b[i]=p--;
    for(int i=0 ; i<n ; i++)pw.print(a[i]+" ");
    pw.print("\n");
    for(int i=0 ; i<n ; i++)pw.print(b[i]+" ");
    pw.print("\n");
    for(int i=0 ; i<n ; i++)pw.print(((a[i]+b[i])% n)+" ");
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (in.readLine())->toInteger() ;
    if (n mod 2 = 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := i ;  ;     i := i + 1 ) ; 
    var p : int ; p := n - 1 ;
        var i : int ; i := 0 ; while i < n do (      b[i+1] := p  ; p := p - 1 ;  ;     i := i+(2) ) ; 
        var i : int ; i := 1 ; while i < n do (      b[i+1] := p  ; p := p - 1 ;  ;     i := i+(2) ) ; 
        var i : int ; i := 0 ; while i < n do (     skip ;  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < n do (     skip ;  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < n do (     skip ;  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int n=Integer.parseInt(in.readLine());
    if(n % 2==0){
      System.out.println(-1);
      return ;
    }
    int[] a=new int[n],b=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=i ;
    int p=n-1 ;
    for(int i=0 ; i<n ; i+=2)b[i]=p--;
    for(int i=1 ; i<n ; i+=2)b[i]=p--;
    String[] arrStr=new String[n];
    for(int i=0 ; i<n ; i++)arrStr[i]=String.valueOf(a[i]);
    pw.print(String.join(" ",arrStr)+"\n");
    for(int i=0 ; i<n ; i++)arrStr[i]=String.valueOf(b[i]);
    pw.print(String.join(" ",arrStr)+"\n");
    for(int i=0 ; i<n ; i++)arrStr[i]=String.valueOf((a[i]+b[i])% n);
    pw.print(String.join(" ",arrStr)+"\n");
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (in.readLine())->toInteger() ;
    if (n mod 2 = 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := i ;  ;     i := i + 1 ) ; 
    var p : int ; p := n - 1 ;
        var i : int ; i := 0 ; while i < n do (      b[i+1] := p  ; p := p - 1 ;  ;     i := i+(2) ) ; 
        var i : int ; i := 1 ; while i < n do (      b[i+1] := p  ; p := p - 1 ;  ;     i := i+(2) ) ; 
    var arrStr : Sequence(String) ; arrStr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     arrStr[i+1] := ((a[i+1]) + "") ;  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < n do (     arrStr[i+1] := ((b[i+1]) + "") ;  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < n do (     arrStr[i+1] := (((a[i+1] + b[i+1]) mod n) + "") ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class LuckyPermutationTriple {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));
    int n=in.nextInt();
    ArrayList<Integer>f=new ArrayList<>(),sec=new ArrayList<>(),th=new ArrayList<>();
    if(n==1){
      pw.println(0);
      pw.println(0);
      pw.println(0);
      pw.close();
      return ;
    }
    if(n % 2==0){
      pw.println("-1");
    }
    else {
      int j=1 ;
      for(int i=n-1 ; i>=0 ; i--){
        f.add(i);
        sec.add(j);
        int z=(i+j)% n ;
        j+=2 ;
        if(j>=n)j=0 ;
        th.add(z);
      }
    }
    for(int i : f)pw.print(i+" ");
    pw.println();
    for(int i : sec)pw.print(i+" ");
    pw.println();
    for(int i : th)pw.print(i+" ");
    pw.println();
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class LuckyPermutationTriple {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var f : Sequence(int) ; f := Sequence{} ;
    var sec : Sequence(int) ; sec := Sequence{} ;
    var th : Sequence(int) ; th := Sequence{} ;
    if (n = 1) then (     skip ; 
     skip ; 
    skip ; 
    skip ; 
    return 
 ) else skip ; 
    if (n mod 2 = 0) then (     skip ) else (     var j : int ; j := 1 ;
         var i : int ; i := n - 1 ; while i >= 0 do ( (     f->excludes(i) ; 
     sec->excludes(j) ; 
    var z : int ; z := (i + j) mod n ;
    j := j+(2) ; 
    if (j >= n) then     j := 0 ; else skip ; 
    th->excludes(z) ; 
 )  ;     i := i - 1 ) ) ;  
    for (i : f) do (     skip ;  ) ; 
    skip ; 
    for (i : sec) do (     skip ;  ) ; 
    skip ; 
    for (i : th) do (     skip ;  ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countWays(int arr[],int n){
    int pos[]=new int[n];
    int p=0,i ;
    for(i=0 ; i<n ; i++){
      if(arr[i]==1){
        pos[p]=i+1 ;
        p++;
      }
    }
    if(p==0)return 0 ;
    int ways=1 ;
    for(i=0 ; i<p-1 ; i++){
      ways*=pos[i+1]-pos[i];
    }
    return ways ;
  }
  public static void main(String args[]){
    int[] arr={
      1,0,1,0,1 };
      int n=arr.length ;
      System.out.println(countWays(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countWays( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var pos : Sequence(int) ; pos := Integer.subrange(1,n)->collect(0) ;
     var p : int ; p := 0 ;
    var i : int ;
        i := 0 ; while i < n do ( (     if (arr[i+1] = 1) then (     pos[p+1] := i + 1 ; 
     p := p + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (p = 0) then     return 0 else skip ; 
    var ways : int ; ways := 1 ;
        i := 0 ; while i < p - 1 do ( (     ways := ways*(pos[i + 1+1] - pos[i+1]) )  ;     i := i + 1 ) ; 
    return ways 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,0,1,0,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countWays(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static boolean solve(String n,int l){
    if(l<3){
      if(Integer.parseInt(n)% 8==0)return true ;
      n=new String((new StringBuilder()).append(n).reverse());
      if(Integer.parseInt(n)% 8==0)return true ;
      return false ;
    }
    int[] hash=new int[10];
    for(int i=0 ; i<l ; i++)hash[n.charAt(i)-'0']++;
    for(int i=104 ; i<1000 ; i+=8){
      int dup=i ;
      int[] freq=new int[10];
      freq[dup % 10]++;
      dup=dup/10 ;
      freq[dup % 10]++;
      dup=dup/10 ;
      freq[dup % 10]++;
      dup=i ;
      if(freq[dup % 10]>hash[dup % 10])continue ;
      dup=dup/10 ;
      if(freq[dup % 10]>hash[dup % 10])continue ;
      dup=dup/10 ;
      if(freq[dup % 10]>hash[dup % 10])continue ;
      return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    String number="31462708" ;
    int l=number.length();
    if(solve(number,l))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( n : String, l : int) : boolean
  pre: true
  post: true
  activity: (     if (l < 3) then (     if ((n)->toInteger() mod 8 = 0) then     return true else skip ; 
     n := StringLib.newString((StringLib.newString()) + StringLib.newString(n)->reverse()) ; 
     if ((n)->toInteger() mod 8 = 0) then     return true else skip ; 
     return false ) else skip ; 
     var hash : Sequence(int) ; hash := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < l do (     hash[n->at(i+1) - ('0')->char2byte()+1] := hash[n->at(i+1) - ('0')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 104 ; while i < 1000 do ( (     var dup : int ; dup := i ;
     var freq : Sequence(int) ; freq := Integer.subrange(1,10)->collect(0) ;
    freq[dup mod 10+1] := freq[dup mod 10+1] + 1 ; 
    dup := dup / 10 ; 
    freq[dup mod 10+1] := freq[dup mod 10+1] + 1 ; 
    dup := dup / 10 ; 
    freq[dup mod 10+1] := freq[dup mod 10+1] + 1 ; 
    dup := i ; 
    if (freq[dup mod 10+1] > hash[dup mod 10+1]) then     continue else skip ; 
    dup := dup / 10 ; 
    if (freq[dup mod 10+1] > hash[dup mod 10+1]) then     continue else skip ; 
    dup := dup / 10 ; 
    if (freq[dup mod 10+1] > hash[dup mod 10+1]) then     continue else skip ; 
    return true 
 )  ;     i := i+(8) ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var number : String ; number := "31462708" ;
     var l : int ; l := number->size() ;
     if (solve(number, l)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static int MOD=998244353 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int A=sc.nextInt();
    int B=sc.nextInt();
    long K=sc.nextLong();
    long ans=0 ;
    long[] comb=new long[n+1];
    comb[0]=1 ;
    for(int i=1 ; i<n+1 ; i++){
      comb[i]=comb[i-1]*(n-i+1)% MOD*pow(i,MOD-2)% MOD ;
    }
    long q=K+A ;
    for(int x=0 ; x<=n ; x++){
      q-=A ;
      if(q % B==0){
        long y=q/B ;
        if(y>n)continue ;
        if(y<0)break ;
        ans=(ans+comb[x]*comb[(int)y] % MOD)% MOD ;
      }
    }
    System.out.println(ans);
  }
  static long calc(int n,long a){
    long MulSumN=1 ;
    long MulSumA=1 ;
    for(int i=1 ; i<=a ; i++){
      MulSumN*=n-i+1 ;
      MulSumN %=MOD ;
      MulSumA*=i ;
      MulSumA %=MOD ;
    }
    return MulSumN*pow(MulSumA,MOD-2)% MOD ;
  }
  public static long pow(long a,int b){
    if(b==1)return a ;
    if(b % 2==0){
      long d=pow(a,b/2);
      return d*d % MOD ;
    }
    return a*pow(a,b-1)% MOD ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : int := 998244353;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var K : long ; K := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
    var comb : Sequence(long) ; comb := Integer.subrange(1,n + 1)->collect(0) ;
    comb[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < n + 1 do ( (     comb[i+1] := comb[i - 1+1] * (n - i + 1) mod MOD * pow(i, MOD - 2) mod MOD )  ;     i := i + 1 ) ; 
    var q : long ; q := K + A ;
        var x : int ; x := 0 ; while x <= n do ( (     q := q-(A) ; 
     if (q mod B = 0) then (     var y : long ; y := q / B ;
     if (y > n) then     continue else skip ; 
     if (y < 0) then     break else skip ; 
     ans := (ans + comb[x+1] * comb[y->oclAsType(int)+1] mod MOD) mod MOD ) else skip )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation calc( n : int, a : long) : long
  pre: true
  post: true
  activity: (     var MulSumN : long ; MulSumN := 1 ;
     var MulSumA : long ; MulSumA := 1 ;
         var i : int ; i := 1 ; while i <= a do ( (     MulSumN := MulSumN*(n - i + 1) ; 
     MulSumN := MulSumN mod MOD ; 
     MulSumA := MulSumA*(i) ; 
     MulSumA := MulSumA mod MOD )  ;     i := i + 1 ) ; 
     return MulSumN * pow(MulSumA, MOD - 2) mod MOD );
  static   operation pow( a : long, b : int) : long
  pre: true
  post: true
  activity: (     if (b = 1) then     return a else skip ; 
     if (b mod 2 = 0) then (     var d : long ; d := pow(a, b / 2) ;
     return d * d mod MOD ) else skip ; 
     return a * pow(a, b - 1) mod MOD );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static long MOD=998244353 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long a=sc.nextLong();
    long b=sc.nextLong();
    long k=sc.nextLong();
    long[] comb=new long[n+1];
    comb[0]=1 ;
    for(int i=1 ; i<=n ; i++){
      comb[i]=div(((comb[i-1]*(n-i+1))% MOD),i,MOD);
    }
    long ans=0 ;
    for(int i=0 ; i<=n ; i++){
      if((k-a*i)% b==0 && 0<=(k-a*i)/b &&(k-a*i)/b<=n){
        ans+=comb[i]*comb[(int)((k-a*i)/b)];
        ans %=MOD ;
      }
    }
    System.out.println(ans);
  }
  public static long pow(long a,long b,long mod){
    if(b==0){
      return 1 ;
    }
    else {
      long c=pow(a,b/2,mod);
      return((c*c % mod)*(b % 2==1 ? a : 1))% mod ;
    }
  }
  public static long div(long a,long b,long mod){
    return(a*pow(b,mod-2,mod)% mod);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : long := 998244353;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var comb : Sequence(long) ; comb := Integer.subrange(1,n + 1)->collect(0) ;
    comb[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do ( (     comb[i+1] := div(((comb[i - 1+1] * (n - i + 1)) mod MOD), i, MOD) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i <= n do ( (     if ((k - a * i) mod b = 0 & 0 <= (k - a * i) / b & (k - a * i) / b <= n) then (     ans := ans+(comb[i+1] * comb[((k - a * i) / b)->oclAsType(int)+1]) ; 
     ans := ans mod MOD ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation pow( a : long, b : long, mod : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return 1 ) else (     var c : long ; c := pow(a, b / 2, mod) ;
     return ((c * c mod mod) * (if b mod 2 = 1 then a else 1 endif)) mod mod ) );
  static   operation div( a : long, b : long, mod : long) : long
  pre: true
  post: true
  activity: (     return (a * pow(b, mod - 2, mod) mod mod) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        long a=sc.nextLong();
        long b=sc.nextLong();
        long d=a-b ;
        boolean ok=false ;
        if(d==1)System.out.println("NO");
        else System.out.println("YES");
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
    var d : long ; d := a - b ;
    var ok : boolean ; ok := false ;
    if (d = 1) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  
 ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    long a=Integer.parseInt(sc.next());
    long b=Integer.parseInt(sc.next());
    long k=Long.parseLong(sc.next());
    int mod=998244353 ;
    int max=300_003 ;
    Mod_nCr mn=new Mod_nCr(mod,max);
    long ans=0 ;
    for(int red=0 ; red<=n ; red++){
      int blue=(int)((k-red*a)/b);
      if(red*a+blue*b==k && 0<=blue){
        ans+=mn.nCr(n,red)*mn.nCr(n,blue);
        ans %=mod ;
      }
    }
    System.out.println(ans);
  }
}
class Mod_nCr {
  int mod ;
  long[] fact ;
  long[] rfact ;
  public Mod_nCr(int mod,int max){
    this.mod=mod ;
    fact=new long[max];
    rfact=new long[max];
    fact[0]=1 ;
    rfact[0]=1 ;
    for(int i=1 ; i<max ; i++){
      fact[i]=(fact[i-1]*i)% mod ;
      rfact[i]=mod_inverse(fact[i],mod);
    }
  }
  private long mod_pow(long x,long p,long m){
    long a=1 ;
    while(p>0){
      if(p % 2==1){
        a=a*x % m ;
      }
      x=x*x % m ;
      p/=2 ;
    }
    return a ;
  }
  private long mod_inverse(long a,long m){
    return mod_pow(a,m-2,m);
  }
  public long nCr(int n,int r){
    if(n<r)return 0 ;
    return fact[n]*rfact[r] % mod*rfact[n-r] % mod ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var a : long ; a := (sc.getCurrent())->toInteger() ;
    var b : long ; b := (sc.getCurrent())->toInteger() ;
    var k : long ; k := (sc.getCurrent())->toLong() ;
    var mod : int ; mod := 998244353 ;
    var max : int ; max := 300_003 ;
    var mn : Mod_nCr ; mn := Mod_nCr.newMod_nCr(mod, max) ;
    var ans : long ; ans := 0 ;
        var red : int ; red := 0 ; while red <= n do ( (     var blue : int ; blue := ((k - red * a) / b)->oclAsType(int) ;
     if (red * a + blue * b = k & 0 <= blue) then (     ans := ans+(mn.nCr(n, red) * mn.nCr(n, blue)) ; 
     ans := ans mod mod ) else skip )  ;     red := red + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}
class Mod_nCr {
   attribute mod : int;
   attribute fact : Sequence(long);
   attribute rfact : Sequence(long);
   static operation newMod_nCr( mod : int, max : int) : Mod_nCr
  pre: true
  post: true
  activity:
  ( var self : Mod_nCr ;
    self := createMod_nCr();
    self.initialise(mod, max);
    return self );
  operation initialise( mod : int, max : int) : void
  pre: true  post: true
  activity: (     self.mod := mod ; 
     fact := Integer.subrange(1,max)->collect(0) ; 
    rfact := Integer.subrange(1,max)->collect(0) ; 
    fact[0+1] := 1 ; 
    rfact[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < max do ( (     fact[i+1] := (fact[i - 1+1] * i) mod mod ; 
     rfact[i+1] := mod_inverse(fact[i+1], mod) )  ;     i := i + 1 ) ; 
 );
   operation mod_pow( x : long, p : long, m : long) : long
  pre: true
  post: true
  activity: (     var a : long ; a := 1 ;
     while (p > 0) do (     if (p mod 2 = 1) then (     a := a * x mod m ) else skip ; 
     x := x * x mod m ; 
     p := p/(2) ) ; 
     return a );
   operation mod_inverse( a : long, m : long) : long
  pre: true
  post: true
  activity: (     return mod_pow(a, m - 2, m) );
   operation nCr( n : int, r : int) : long
  pre: true
  post: true
  activity: (     if (n < r) then     return 0 else skip ; 
     return fact[n+1] * rfact[r+1] mod mod * rfact[n - r+1] mod mod );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.BigInteger ;
class Main {
  public static long comb(long a,long b,long mod,long[] pw,long[] ipw){
    return(((pw[(int)a]*ipw[(int)a-(int)b])% mod)*ipw[(int)b])% mod ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int max=400000 ;
    int mod=998244353 ;
    long[] pw=new long[max];
    pw[0]=1 ;
    long[] ipw=new long[max];
    BigInteger modb=new BigInteger(String.valueOf(mod));
    for(int i=1 ; i<max ; i++){
      pw[i]=(i*pw[i-1])% mod ;
    }
    for(int i=0 ; i<max ; i++){
      ipw[i]=new BigInteger(String.valueOf(pw[i])).modInverse(modb).longValue();
    }
    long n=sc.nextLong();
    long a=sc.nextLong();
    long b=sc.nextLong();
    long k=sc.nextLong();
    long ans=0 ;
    for(int A=0 ; A<=n ; A++){
      if((k-A*a)% b!=0)continue ;
      long B=(k-A*a)/b ;
      if(B>n || B<0)continue ;
      ans+=(comb(n,A,mod,pw,ipw)*comb(n,B,mod,pw,ipw))% mod ;
      ans %=mod ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation comb( a : long, b : long, mod : long, pw : Sequence(long), ipw : Sequence(long)) : long
  pre: true
  post: true
  activity: (     return (((pw[a->oclAsType(int)+1] * ipw[a->oclAsType(int) - b->oclAsType(int)+1]) mod mod) * ipw[b->oclAsType(int)+1]) mod mod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var max : int ; max := 400000 ;
    var mod : int ; mod := 998244353 ;
    var pw : Sequence(long) ; pw := Integer.subrange(1,max)->collect(0) ;
    pw[0+1] := 1 ; 
    var ipw : Sequence(long) ; ipw := Integer.subrange(1,max)->collect(0) ;
    var modb : long ; modb := long(((mod) + "")) ;
        var i : int ; i := 1 ; while i < max do ( (     pw[i+1] := (i * pw[i - 1+1]) mod mod )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < max do ( (     ipw[i+1] := long(((pw[i+1]) + "")).modInverse(modb)->oclAsType(long) )  ;     i := i + 1 ) ; 
    var n : long ; n := sc.getCurrent()->toLong() ;
    var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
        var A : int ; A := 0 ; while A <= n do ( (     if ((k - A * a) mod b /= 0) then     continue else skip ; 
     var B : long ; B := (k - A * a) / b ;
    if (B > n or B < 0) then     continue else skip ; 
    ans := ans+((comb(n, A, mod, pw, ipw) * comb(n, B, mod, pw, ipw)) mod mod) ; 
    ans := ans mod mod ; 
 )  ;     A := A + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findEvenPair(int A[],int N){
    int evenPair=0 ;
    for(int i=0 ; i<N ; i++){
      for(int j=i+1 ; j<N ; j++){
        if((A[i] | A[j])% 2==0)evenPair++;
      }
    }
    return evenPair ;
  }
  public static void main(String[] args){
    int A[]={
      5,6,2,8 };
      int N=A.length ;
      System.out.println(findEvenPair(A,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findEvenPair( A : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var evenPair : int ; evenPair := 0 ;
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := i + 1 ; while j < N do ( (     if ((A[i+1] or A[j+1]) mod 2 = 0) then     evenPair := evenPair + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return evenPair );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{5,6,2,8} ;
     var N : int ; N := A->size() ;
     OclFile["System.out"].println(findEvenPair(A, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static final long MOD=998244353 ;
  private static long FACT[];
  private static long IFACT[];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long A=sc.nextInt();
    long B=sc.nextInt();
    long K=sc.nextLong();
    solve(N,A,B,K);
  }
  private static void solve(int N,long A,long B,long K){
    FACT=new long[N+1];
    IFACT=new long[N+1];
    FACT[0]=1 ;
    IFACT[0]=1 ;
    for(int i=1 ; i<=N ; i++){
      FACT[i]=FACT[i-1]*i % MOD ;
      IFACT[i]=inv(FACT[i]);
    }
    long ans=0 ;
    for(int numA=0 ; numA<=N ; numA++){
      long rem=K-A*numA ;
      if(rem<0){
        break ;
      }
      int numB=(int)(rem/B);
      if(A*numA+B*numB==K && numB<=N){
        ans=(ans+comb(N,numA)*comb(N,numB))% MOD ;
      }
    }
    System.out.println(ans);
  }
  private static long comb(int n,int r){
    if(n<0 || r<0 || n<r){
      return 0 ;
    }
    if(r>n/2){
      r=n-r ;
    }
    return FACT[n]*IFACT[n-r] % MOD*IFACT[r] % MOD ;
  }
  private static long inv(long a){
    long b=MOD ;
    long p=1,q=0 ;
    while(b>0){
      long c=a/b ;
      long d ;
      d=a ;
      a=b ;
      b=d % b ;
      d=p ;
      p=q ;
      q=d-c*q ;
    }
    return p<0 ? p+MOD : p ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 998244353;
  static   attribute FACT : Sequence(long);
  static   attribute IFACT : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : long ; A := sc.getCurrent()->toInteger() ;
    var B : long ; B := sc.getCurrent()->toInteger() ;
    var K : long ; K := sc.getCurrent()->toLong() ;
    execute solve(N, A, B, K) ; 
 );
  static   operation solve( N : int, A : long, B : long, K : long) : void
  pre: true
  post: true
  activity: (     FACT := Integer.subrange(1,N + 1)->collect(0) ; 
     IFACT := Integer.subrange(1,N + 1)->collect(0) ; 
    FACT[0+1] := 1 ; 
    IFACT[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= N do ( (     FACT[i+1] := FACT[i - 1+1] * i mod MOD ; 
     IFACT[i+1] := inv(FACT[i+1]) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var numA : int ; numA := 0 ; while numA <= N do ( (     var rem : long ; rem := K - A * numA ;
     if (rem < 0) then (     break ) else skip ; 
     var numB : int ; numB := (rem / B)->oclAsType(int) ;
     if (A * numA + B * numB = K & numB <= N) then (     ans := (ans + comb(N, numA) * comb(N, numB)) mod MOD ) else skip )  ;     numA := numA + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation comb( n : int, r : int) : long
  pre: true
  post: true
  activity: (     if (n < 0 or r < 0 or n < r) then (     return 0 ) else skip ; 
     if (r > n / 2) then (     r := n - r ) else skip ; 
     return FACT[n+1] * IFACT[n - r+1] mod MOD * IFACT[r+1] mod MOD );
  static   operation inv( a : long) : long
  pre: true
  post: true
  activity: (     var b : long ; b := MOD ;
     var p : long ; p := 1 ;
    var q : long ; q := 0 ;
     while (b > 0) do (     var c : long ; c := a / b ;
     var d : long ;
    d := a ; 
    a := b ; 
    b := d mod b ; 
    d := p ; 
    p := q ; 
    q := d - c * q ; 
 ) ; 
     return if p < 0 then p + MOD else p endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int min_elimination(int n,int arr[]){
    int countOdd=0 ;
    for(int i=0 ; i<n ; i++)if(arr[i] % 2==1)countOdd++;
    return Math.min(countOdd,n-countOdd);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,7,9 };
      int n=arr.length ;
      System.out.println(min_elimination(n,arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation min_elimination( n : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var countOdd : int ; countOdd := 0 ;
         var i : int ; i := 0 ; while i < n do (     if (arr[i+1] mod 2 = 1) then     countOdd := countOdd + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return Set{countOdd, n - countOdd}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,7,9} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(min_elimination(n, arr)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedWriter ;
import java.io.File ;
import java.io.FileWriter ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class b {
  public static void main(String[] Args)throws Exception {
    Scanner sc=new Scanner(new File("B-large.in"));
    PrintWriter out=new PrintWriter(new BufferedWriter(new FileWriter(new File("b.out"))));
    int cc=0 ;
    int t=sc.nextInt();
    while(t-->0){
      String x=sc.next();
      for(int i=0 ; i<x.length(); i++)for(int j=0 ; j+1<x.length(); j++)if(x.charAt(j)>x.charAt(j+1)){
        String nx=x.substring(0,j);
        nx=nx+(char)(x.charAt(j)-1);
        while(nx.length()<x.length())nx=nx+"9" ;
        x=nx ;
      }
      while(x.length()>1 && x.charAt(0)=='0')x=x.substring(1);
      out.printf("Case #%d: %s%n",++cc,x);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class b {
  static   operation main( Args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile("B-large.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile("b.out")))) ;
    var cc : int ; cc := 0 ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var x : String ; x := sc.getCurrent() ;
         var i : int ; i := 0 ; while i < x->size() do (         var j : int ; j := 0 ; while j + 1 < x->size() do (     if (x->at(j+1) > x->at(j + 1+1)) then (     var nx : String ; nx := x.subrange(0+1,j) ;
     nx := nx + (x->at(j+1) - 1)->oclAsType(String) ; 
     while (nx->size() < x->size()) do     nx := nx + "9" ; ; 
     x := nx ) else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     while (x->size() > 1 & x->at(0+1) = '0') do     x := x.subrange(1+1,1) ; ; 
     skip ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class B {
  private String solveTest()throws IOException {
    String s=next();
    int i=0 ;
    while(i<s.length()-1 && s.charAt(i+1)>=s.charAt(i)){
      i++;
    }
    if(i==s.length()-1)return s ;
    while(i>0 && s.charAt(i-1)==s.charAt(i))i--;
    String res="" ;
    for(int j=0 ; j<s.length(); j++){
      res+=j<i ? s.charAt(j): j==i ?(char)(s.charAt(j)-1): '9' ;
    }
    if(res.charAt(0)=='0')res=res.substring(1);
    return res ;
  }
  private void solve()throws IOException {
    int n=nextInt();
    for(int i=0 ; i<n ; i++){
      String res=solveTest();
      System.out.println("Case #"+(i+1)+": "+res);
      out.println("Case #"+(i+1)+": "+res);
    }
  }
  BufferedReader br ;
  StringTokenizer st ;
  PrintWriter out ;
  String next()throws IOException {
    while(st==null || ! st.hasMoreTokens()){
      st=new StringTokenizer(br.readLine());
    }
    return st.nextToken();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public static void main(String[] args)throws FileNotFoundException {
    new B().run();
  }
  private void run()throws FileNotFoundException {
    br=new BufferedReader(new FileReader(this.getClass().getSimpleName().substring(0,1)+".in"));
    out=new PrintWriter(this.getClass().getSimpleName().substring(0,1)+".out");
    try {
      solve();
    }
    catch(IOException e){
      e.printStackTrace();
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
   operation solveTest() : String
  pre: true
  post: true
  activity: (     var s : String ; s := next() ;
     var i : int ; i := 0 ;
    while (i < s->size() - 1 & s->at(i + 1+1) >= s->at(i+1)) do (     i := i + 1 ) ; 
    if (i = s->size() - 1) then     return s else skip ; 
    while (i > 0 & s->at((i)->char2byte() - 1+1) = s->at(i+1)) do     i := i - 1 ; ; 
    var res : String ; res := "" ;
        var j : int ; j := 0 ; while j < s->size() do ( (     res := res+(if j < i then s->at(j+1) else if j = i then (s->at(j+1) - 1)->oclAsType(String) else '9' endif endif) )  ;     j := j + 1 ) ; 
    if (res->at(0+1) = '0') then     res := res.subrange(1+1,1) ; else skip ; 
    return res 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
         var i : int ; i := 0 ; while i < n do ( (     var res : String ; res := solveTest() ;
     OclFile["System.out"].println("Case #" + (i + 1) + ": " + res) ; 
     out.println("Case #" + (i + 1) + ": " + res) )  ;     i := i + 1 ) );
   attribute br : OclFile;
   attribute st : OclIterator;
   attribute out : OclFile;
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     B.newB().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(self->oclType().getSimpleName().subrange(0+1,1) + ".in")) ; 
     out := OclFile.newOclFile_Write(self->oclType().getSimpleName().subrange(0+1,1) + ".out") ; 
     try (     execute solve() )   catch (e : IOException) do (     e.printStackTrace() )
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package qualification ;
import java.io.*;
import java.util.*;
public class B_TidyNumbers {
  private static final String FILENAME="B-large" ;
  private static final boolean STANDARD_OUTPUT=false ;
  public static void main(String[] args)throws Throwable {
    try(BufferedReader in=new BufferedReader(new FileReader(FILENAME+".in"))){
      try(PrintStream out=! STANDARD_OUTPUT ? new PrintStream(FILENAME+".out"): System.out){
        for(int t=1,T=Integer.parseInt(in.readLine()); t<=T ; t++){
          char[] N=in.readLine().toCharArray();
          int i=1,k=0 ;
          for(i=1 ; i<N.length && N[i]>=N[i-1]; i++){
          }
          if(i<N.length){
            for(k=i-1 ; k>=0 && N[k]==N[i-1]; k--){
            }
            N[++k]--;
            Arrays.fill(N,k+1,N.length,'9');
            k=k==0 && N[0]=='0' ? 1 : 0 ;
          }
          out.println("Case #"+t+": "+new String(N,k,N.length-k));
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_TidyNumbers {
  static    attribute FILENAME : String := "B-large";
  static    attribute STANDARD_OUTPUT : boolean := false;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(FILENAME + ".in")) ;
 (     try (    var out : OclFile := if not(STANDARD_OUTPUT) then OclFile.newOclFile_Write(FILENAME + ".out") else OclFile["System.out"] endif ;
 (         var t : int ; t := 1 ;
    var T : int ; T := (in.readLine())->toInteger() ; while t <= T do ( (     var N : Sequence(String) ; N := in.readLine()->characters() ;
     var i : int ; i := 1 ;
    var k : int ; k := 0 ;
        i := 1 ; while i < N->size() & N[i+1] >= N[i - 1+1] do ( skip  ;     i := i + 1 ) ; 
    if (i < N->size()) then (         k := i - 1 ; while k >= 0 & N[k+1] = N[i - 1+1] do ( skip  ;     k := k - 1 ) ; 
     N[k+1] := N[k+1] - 1 ; 
     N := N->collect('9') ; 
     k := if k = 0 & N[0+1] = '0' then 1 else 0 endif ) else skip ; 
    skip ; 
 )  ;     t := t + 1 ) ))  ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package com.company ;
import java.io.FileInputStream ;
import java.io.FileNotFoundException ;
import java.io.FileOutputStream ;
import java.io.PrintStream ;
import java.util.Arrays ;
import java.util.Scanner ;
public class ProbB {
  private Scanner scanner=new Scanner(System.in);
  public void main(){
    reDirect();
    int T=scanner.nextInt();
    for(int cas=1 ; cas<=T ; cas++){
      long ans=run();
      System.out.println("Case #"+cas+": "+ans);
    }
  }
  private long run(){
    long input=scanner.nextLong();
    char[] arr=Long.valueOf(input).toString().toCharArray();
    int x=arr.length ;
    for(int i=0 ; i<arr.length-1 ; i++){
      if(arr[i]>arr[i+1]){
        x=i+1 ;
        break ;
      }
    }
    if(x==arr.length){
      return input ;
    }
    int y=x-1 ;
    while(y>0 && arr[y]==arr[y-1])y--;
    arr[y]--;
    for(int i=y+1 ; i<arr.length ; i++){
      arr[i]='9' ;
    }
    return Long.valueOf(new String(arr));
  }
  private void reDirect(){
    try {
      FileInputStream fileInputStream=new FileInputStream("B-large.in");
      scanner=new Scanner(fileInputStream);
      PrintStream ps=new PrintStream(new FileOutputStream("bout-large.txt"));
      System.setOut(ps);
    }
    catch(FileNotFoundException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProbB {
   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation main() : void
  pre: true
  post: true
  activity: (     execute reDirect() ; 
     var T : int ; T := scanner.getCurrent()->toInteger() ;
         var cas : int ; cas := 1 ; while cas <= T do ( (     var ans : long ; ans := run() ;
     OclFile["System.out"].println("Case #" + cas + ": " + ans) )  ;     cas := cas + 1 ) );
   operation run() : long
  pre: true
  post: true
  activity: (     var input : long ; input := scanner.getCurrent()->toLong() ;
     var arr : Sequence(String) ; arr := (input)->toLong()+""->characters() ;
    var x : int ; x := arr->size() ;
        var i : int ; i := 0 ; while i < arr->size() - 1 do ( (     if (arr[i+1] > arr[i + 1+1]) then (     x := i + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (x = arr->size()) then (     return input ) else skip ; 
    var y : int ; y := x - 1 ;
    while (y > 0 & arr[y+1] = arr[y - 1+1]) do     y := y - 1 ; ; 
    arr[y+1] := arr[y+1] - 1 ; 
        var i : int ; i := y + 1 ; while i < arr->size() do ( (     arr[i+1] := '9' )  ;     i := i + 1 ) ; 
    return (StringLib.newString(arr))->toLong() 
 );
   operation reDirect() : void
  pre: true
  post: true
  activity: (     try (     var fileInputStream : OclFile ; fileInputStream := OclFile.newOclFile_Read(OclFile.newOclFile("B-large.in")) ;
     scanner := OclFile.newOclFile_Read(fileInputStream) ; 
     var ps : OclFile ; ps := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("bout-large.txt"))) ;
 setOut(ps) )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package qualifier ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class BTidyNumbers {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in)))){
      int tests=sc.nextInt();
      for(int t=1 ; t<=tests ; t++){
        int[] digits=sc.next().chars().map(i->i-'0').toArray();
        for(int x=0 ; x<digits.length-1 ; x++){
          if(digits[x]>digits[x+1]){
            digits[x]--;
            for(int y=x+1 ; y<digits.length ; y++)digits[y]=9 ;
            while(digits[x]<0 ||(x>0 && digits[x]<digits[x-1])){
              digits[x]=9 ;
              digits[x-1]--;
              x--;
            }
            break ;
          }
        }
        int start=0 ;
        while(digits[start]==0)start++;
        StringBuilder sb=new StringBuilder();
        for(int x=start ; x<digits.length ; x++)sb.append((char)(digits[x]+'0'));
        System.out.printf("Case #%d: %s%n",t,sb.toString());
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BTidyNumbers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
 (     var tests : int ; tests := sc.getCurrent()->toInteger() ;
         var t : int ; t := 1 ; while t <= tests do ( (     var digits : Sequence(int) ; digits := sc.getCurrent().chars()->collect( _x1 | (lambda i : OclAny in i - ('0')->char2byte())->apply(_x1) )->asSequence() ;
         var x : int ; x := 0 ; while x < digits->size() - 1 do ( (     if (digits[x+1] > digits[x + 1+1]) then (     digits[x+1] := digits[x+1] - 1 ; 
         var y : int ; y := x + 1 ; while y < digits->size() do (     digits[y+1] := 9 ;  ;     y := y + 1 ) ; 
     while (digits[x+1] < 0 or (x > 0 & digits[x+1] < digits[x - 1+1])) do (     digits[x+1] := 9 ; 
     digits[x - 1+1] := digits[x - 1+1] - 1 ; 
     x := x - 1 ) ; 
     break ) else skip )  ;     x := x + 1 ) ; 
    var start : int ; start := 0 ;
    while (digits[start+1] = 0) do     start := start + 1 ; ; 
    var sb : String ; sb := StringLib.newString() ;
        var x : int ; x := start ; while x < digits->size() do (     sb := sb + StringLib.newString((digits[x+1] + '0')->oclAsType(String)) ;  ;     x := x + 1 ) ; 
    OclFile["System.out"].printf("Case #%d: %s%n", t, sb+"") ; 
 )  ;     t := t + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PrimeSubtraction {
  public static void main(String[] args){
    Scanner iScanner=new Scanner(System.in);
    int test=iScanner.nextInt();
    while(test>0){
      test--;
      long a=iScanner.nextLong();
      long b=iScanner.nextLong();
      if(a-b!=1){
        System.out.println("YES");
      }
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PrimeSubtraction {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var iScanner : OclFile ; iScanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := iScanner.getCurrent()->toInteger() ;
     while (test > 0) do (     test := test - 1 ; 
     var a : long ; a := iScanner.getCurrent()->toLong() ;
     var b : long ; b := iScanner.getCurrent()->toLong() ;
     if (a - b /= 1) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Node {
    int data ;
    Node next ;
  }
  static Node first,last ;
  static int length=0 ;
  static void printList(Node node){
    while(node!=null){
      System.out.printf("%d ",node.data);
      node=node.next ;
    }
  }
  static void moveToFront(Node head,Node p,int m){
    if(head==null)return ;
    p=head ;
    head=head.next ;
    m++;
    if(length==m){
      p.next=null ;
      last.next=first ;
      first=head ;
    }
    else moveToFront(head,p,m);
  }
  static Node push(Node head_ref,int new_data){
    Node new_node=new Node();
    new_node.data=new_data ;
    new_node.next=head_ref ;
    head_ref=new_node ;
    if(length==0)last=head_ref ;
    else first=head_ref ;
    length++;
    return head_ref ;
  }
  public static void main(String[] args){
    Node start=null ;
    start=push(start,5);
    start=push(start,4);
    start=push(start,3);
    start=push(start,2);
    start=push(start,1);
    start=push(start,0);
    System.out.printf("\n Initial Linked list\n");
    printList(start);
    int m=4 ;
    Node temp=new Node();
    moveToFront(start,temp,m);
    System.out.printf("\n Final Linked list\n");
    start=first ;
    printList(start);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   attribute first : Node;
  static   attribute length : int := 0;
  static   operation printList( node : Node) : void
  pre: true
  post: true
  activity: (     while (node /= null) do (     OclFile["System.out"].printf("%d ", node.data) ; 
     node := node.next ) );
  static   operation moveToFront( head : Node, p : Node, m : int) : void
  pre: true
  post: true
  activity: (     if (head = null) then     return else skip ; 
     p := head ; 
    head := head.next ; 
    m := m + 1 ; 
    if (length = m) then (     p.next := null ; 
     last.next := first ; 
     first := head ) else     execute moveToFront(head, p, m) ; ;  
 );
  static   operation push( head_ref : Node, new_data : int) : Node
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode() ;
     new_node.data := new_data ; 
    new_node.next := head_ref ; 
    head_ref := new_node ; 
    if (length = 0) then     last := head_ref else     first := head_ref ; ;  
    length := length + 1 ; 
    return head_ref 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : Node ; start := null ;
     start := push(start, 5) ; 
    start := push(start, 4) ; 
    start := push(start, 3) ; 
    start := push(start, 2) ; 
    start := push(start, 1) ; 
    start := push(start, 0) ; 
    OclFile["System.out"].printf("\n Initial Linked list\n") ; 
    execute printList(start) ; 
    var m : int ; m := 4 ;
    var temp : Node ; temp := Node.newNode() ;
    execute moveToFront(start, temp, m) ; 
    OclFile["System.out"].printf("\n Final Linked list\n") ; 
    start := first ; 
    execute printList(start) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int count9s(String number){
    int count=0 ;
    int n=number.length();
    for(int i=0 ; i<n ; i++){
      int sum=number.charAt(i)-'0' ;
      if(number.charAt(i)=='9')count++;
      for(int j=i+1 ; j<n ; j++){
        sum=(sum+number.charAt(j)-'0')% 9 ;
        if(sum==0)count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    System.out.println(count9s("4189"));
    System.out.println(count9s("1809"));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count9s( number : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var n : int ; n := number->size() ;
         var i : int ; i := 0 ; while i < n do ( (     var sum : int ; sum := number->at(i+1) - ('0')->char2byte() ;
     if (number->at(i+1) = '9') then     count := count + 1 ; else skip ; 
         var j : int ; j := i + 1 ; while j < n do ( (     sum := (sum + number->at(j+1) - ('0')->char2byte()) mod 9 ; 
     if (sum = 0) then     count := count + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(count9s("4189")) ; 
     OclFile["System.out"].println(count9s("1809")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findExtra(int arr1[],int arr2[],int n){
    int index=n ;
    int left=0,right=n-1 ;
    while(left<=right){
      int mid=(left+right)/2 ;
      if(arr2[mid]==arr1[mid])left=mid+1 ;
      else {
        index=mid ;
        right=mid-1 ;
      }
    }
    return index ;
  }
  public static void main(String[] args){
    int arr1[]={
      2,4,6,8,10,12,13 };
      int arr2[]={
        2,4,6,8,10,12 };
        int n=arr2.length ;
        System.out.println(findExtra(arr1,arr2,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findExtra( arr1 : Sequence(int), arr2 : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var index : int ; index := n ;
     var left : int ; left := 0 ;
    var right : int ; right := n - 1 ;
     while (left <= right) do (     var mid : int ; mid := (left + right) / 2 ;
     if (arr2[mid+1] = arr1[mid+1]) then     left := mid + 1 ; else (     index := mid ; 
     right := mid - 1 ) ) ; 
     return index );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{2,4,6,8,10,12,13} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{2,4,6,8,10,12} ;
     var n : int ; n := arr2->size() ;
     OclFile["System.out"].println(findExtra(arr1, arr2, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findevenPair(int[] A,int N){
    int i,j ;
    int evenPair=0 ;
    for(i=0 ; i<N ; i++){
      for(j=i+1 ; j<N ; j++){
        if((A[i] ^ A[j])% 2==0)evenPair++;
      }
    }
    return evenPair ;
  }
  public static void main(String[] args){
    int A[]={
      5,4,7,2,1 };
      int N=A.length ;
      System.out.println(findevenPair(A,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findevenPair( A : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var evenPair : int ; evenPair := 0 ;
         i := 0 ; while i < N do ( (         j := i + 1 ; while j < N do ( (     if ((A[i+1] xor A[j+1]) mod 2 = 0) then     evenPair := evenPair + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return evenPair );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{5,4,7,2,1} ;
     var N : int ; N := A->size() ;
     OclFile["System.out"].println(findevenPair(A, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void parallel(int a[][]){
    boolean x=true,y=true ;
    for(int i=0 ; i<a.length-1 ; i++){
      for(int j=0 ; j<2 ; j++){
        if(a[i][0]!=a[i+1][0])x=false ;
        if(a[i][1]!=a[i+1][1])y=false ;
      }
    }
    if(x)System.out.println("Parallel to X Axis");
    else if(y)System.out.println("Parallel to Y Axis");
    else System.out.println("Not parallel to X"+" and Y axis");
  }
  public static void main(String[] args){
    int a[][]={
      {
        1,2 },{
          1,4 },{
            1,6 },{
              1,0 }
            };
            parallel(a);
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation parallel( a : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var x : boolean ; x := true ;
    var y : boolean ; y := true ;
         var i : int ; i := 0 ; while i < a->size() - 1 do ( (         var j : int ; j := 0 ; while j < 2 do ( (     if (a[i+1][0+1] /= a[i + 1+1][0+1]) then     x := false ; else skip ; 
     if (a[i+1][1+1] /= a[i + 1+1][1+1]) then     y := false ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (x) then     OclFile["System.out"].println("Parallel to X Axis") ; else     if (y) then     OclFile["System.out"].println("Parallel to Y Axis") else     OclFile["System.out"].println("Not parallel to X" + " and Y axis") ; ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(Sequence(int)) ; a := Sequence{Sequence{1,2},Sequence{1,4},Sequence{1,6},Sequence{1,0}} ;
     execute parallel(a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.util.*;
public class b {
  static BufferedReader f ;
  static StringTokenizer st ;
  static StringBuilder ans=new StringBuilder();
  public static void tc()throws IOException {
    st=new StringTokenizer(f.readLine());
    int n=Integer.parseInt(st.nextToken());
    int m=Integer.parseInt(st.nextToken());
    int[] arr=new int[n*m];
    int[][] grid=new int[n][m];
    for(int i=0 ; i<n ; i++){
      st=new StringTokenizer(f.readLine());
      for(int x=0 ; x<m ; x++){
        int curr=Integer.parseInt(st.nextToken())-1 ;
        arr[curr]=i ;
        grid[i][x]=curr ;
      }
    }
    int[] op=new int[n];
    st=new StringTokenizer(f.readLine());
    for(int i=0 ; i<n ; i++){
      int curr=Integer.parseInt(st.nextToken())-1 ;
      op[i]=arr[curr];
    }
    for(int i=0 ; i<m-1 ; i++){
      st=new StringTokenizer(f.readLine());
    }
    for(int i=0 ; i<n ; i++){
      for(int x=0 ; x<m ; x++){
        ans.append(grid[op[i] ][x]+1+" ");
      }
      ans.append("\n");
    }
  }
  public static void main(String[] args)throws IOException {
    f=new BufferedReader(new InputStreamReader(System.in));
    st=new StringTokenizer(f.readLine());
    int t=Integer.parseInt(st.nextToken());
    for(int i=0 ; i<t ; i++){
      tc();
    }
    System.out.println(ans);
    f.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class b {
  static   attribute f : OclFile;
  static   attribute st : OclIterator;
  static   attribute ans : String := StringLib.newString();
  static   operation tc() : void
  pre: true
  post: true
  activity: (     st := OclIterator.newOclIterator_String(f.readLine()) ; 
     var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n * m)->collect(0) ;
    var grid : Sequence(Sequence(int)) ; grid := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     st := OclIterator.newOclIterator_String(f.readLine()) ; 
         var x : int ; x := 0 ; while x < m do ( (     var curr : int ; curr := (st.next())->toInteger() - 1 ;
     arr[curr+1] := i ; 
     grid[i+1][x+1] := curr )  ;     x := x + 1 ) )  ;     i := i + 1 ) ; 
    var op : Sequence(int) ; op := Integer.subrange(1,n)->collect(0) ;
    st := OclIterator.newOclIterator_String(f.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     var curr : int ; curr := (st.next())->toInteger() - 1 ;
     op[i+1] := arr[curr+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m - 1 do ( (     st := OclIterator.newOclIterator_String(f.readLine()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var x : int ; x := 0 ; while x < m do ( (     ans := ans + StringLib.newString(grid[op[i+1]+1][x+1] + 1 + " ") )  ;     x := x + 1 ) ; 
     ans := ans + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := OclIterator.newOclIterator_String(f.readLine()) ; 
    var t : int ; t := (st.next())->toInteger() ;
        var i : int ; i := 0 ; while i < t do ( (     execute tc() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1413 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    StringBuilder output=new StringBuilder();
    for(int t=0 ; t<T ; t++){
      int R=in.nextInt();
      int C=in.nextInt();
      int[][] rows=new int[R][];
      int[] rowIndex=new int[R*C+1];
      for(int r=0 ; r<R ; r++){
        int[] row=new int[C];
        for(int c=0 ; c<C ; c++){
          int a=in.nextInt();
          row[c]=a ;
          rowIndex[a]=r ;
        }
        rows[r]=row ;
      }
      for(int c=0 ; c<C ; c++){
        for(int r=0 ; r<R ; r++){
          int a=in.nextInt();
          if(c==0){
            for(int elem : rows[rowIndex[a] ]){
              output.append(elem).append(' ');
            }
            output.append('\n');
          }
        }
      }
    }
    System.out.print(output);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1413 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
    var output : String ; output := StringLib.newString() ;
        var t : int ; t := 0 ; while t < T do ( (     var R : int ; R := in.getCurrent()->toInteger() ;
     var C : int ; C := in.getCurrent()->toInteger() ;
    var rows : Sequence(Sequence(int)) ; rows := Integer.subrange(1,R)->collect(Sequence{}) ;
    var rowIndex : Sequence(int) ; rowIndex := Integer.subrange(1,R * C + 1)->collect(0) ;
        var r : int ; r := 0 ; while r < R do ( (     var row : Sequence(int) ; row := Integer.subrange(1,C)->collect(0) ;
         var c : int ; c := 0 ; while c < C do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     row[c+1] := a ; 
     rowIndex[a+1] := r )  ;     c := c + 1 ) ; 
     rows[r+1] := row )  ;     r := r + 1 ) ; 
        var c : int ; c := 0 ; while c < C do ( (         var r : int ; r := 0 ; while r < R do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     if (c = 0) then (     for (elem : rows[rowIndex[a+1]+1]) do ( (     output := output + StringLib.newString(elem) + StringLib.newString(' ') )  ) ; 
     output := output + StringLib.newString('
') ) else skip )  ;     r := r + 1 ) )  ;     c := c + 1 ) ; 
 )  ;     t := t + 1 ) ; 
    OclFile["System.out"].print(output) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countTriangles(int a[],int n){
    int cnt=0 ;
    int pairs=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      pairs+=a[i]/2 ;
      if(a[i] % 2==1 && pairs>0){
        cnt+=1 ;
        pairs-=1 ;
      }
    }
    cnt+=(2*pairs)/3 ;
    return cnt ;
  }
  public static void main(String[] args){
    int a[]={
      1,2,2,2,2 };
      int n=a.length ;
      System.out.println(countTriangles(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countTriangles( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var pairs : int ; pairs := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     pairs := pairs+(a[i+1] / 2) ; 
     if (a[i+1] mod 2 = 1 & pairs > 0) then (     cnt := cnt+(1) ; 
     pairs := pairs-(1) ) else skip )  ;     i := i - 1 ) ; 
    cnt := cnt+((2 * pairs) / 3) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,2,2,2} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(countTriangles(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findMaxXOR(Vector<Integer>arr,int n){
    Vector<Integer>stack=new Vector<Integer>();
    int res=0,l=0,i ;
    for(i=0 ; i<n ; i++){
      while(! stack.isEmpty()&& stack.get(stack.size()-1)<arr.get(i)){
        stack.remove(stack.size()-1);
        l--;
      }
      stack.add(arr.get(i));
      l++;
      if(l>1){
        res=Math.max(res,stack.get(l-1)^ stack.get(l-2));
      }
    }
    return res ;
  }
  public static void main(String[] args){
    Integer[] temp={
      9,8,3,5,7 };
      Vector<Integer>arr=new Vector<>(Arrays.asList(temp));
      int result1=findMaxXOR(arr,5);
      Collections.reverse(arr);
      int result2=findMaxXOR(arr,5);
      System.out.print(Math.max(result1,result2));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMaxXOR( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var stack : Sequence(int) ; stack := Sequence{} ;
     var res : int ; res := 0 ;
    var l : int ; l := 0 ;
    var i : int ;
         i := 0 ; while i < n do ( (     while (not(stack->isEmpty()) & stack->at(stack->size() - 1+1) < arr->at(i+1)) do (     stack := stack->excludingFirst(stack->size() - 1) ; 
     l := l - 1 ) ; 
     stack := stack->including(arr->at(i+1)) ; 
     l := l + 1 ; 
     if (l > 1) then (     res := Set{res, stack->at(l - 1+1) xor stack->at(l - 2+1)}->max() ) else skip )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(int) ; temp := Sequence{9,8,3,5,7} ;
     var arr : Sequence(int) ; arr := Sequence{}->union(temp) ;
    var result1 : int ; result1 := findMaxXOR(arr, 5) ;
    arr := arr->reverse() ; 
    var result2 : int ; result2 := findMaxXOR(arr, 5) ;
    OclFile["System.out"].print(Set{result1, result2}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean asPowerSum(int w,int m){
    while(m>0){
      if((m-1)% w==0)m=(m-1)/w ;
      else if((m+1)% w==0)m=(m+1)/w ;
      else if(m % w==0)m=m/w ;
      else break ;
    }
    return(m==0);
  }
  public static void main(String[] args){
    int w=3,m=7 ;
    if(asPowerSum(w,m))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation asPowerSum( w : int, m : int) : boolean
  pre: true
  post: true
  activity: (     while (m > 0) do (     if ((m - 1) mod w = 0) then     m := (m - 1) / w ; else     if ((m + 1) mod w = 0) then     m := (m + 1) / w else     if (m mod w = 0) then     m := m / w else     break ;  ;  ) ; 
     return (m = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var w : int ; w := 3 ;
    var m : int ; m := 7 ;
     if (asPowerSum(w, m)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class A_Prime_Subtraction {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int T=reader.nextInt();
    while(T!=0){
      T--;
      long x=reader.nextLong();
      long y=reader.nextLong();
      if(x-y==1L){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Prime_Subtraction {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var T : int ; T := reader.nextInt() ;
     while (T /= 0) do (     T := T - 1 ; 
     var x : long ; x := reader.nextLong() ;
     var y : long ; y := reader.nextLong() ;
     if (x - y = 1L) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Graph {
  int V ;
  Vector<Integer>[] adj ;
  Graph(int V){
    this.V=V ;
    this.adj=new Vector[V];
    for(int i=0 ; i<V ; i++)adj[i]=new Vector<Integer>();
  }
  void addEdge(int u,int v){
    adj[u] .add(v);
    adj[v] .add(u);
  }
  int countEdges(){
    int sum=0 ;
    for(int i=0 ; i<V ; i++)sum+=adj[i] .size();
    return sum/2 ;
  }
}
class GFG {
  public static void main(String[] args)throws IOException {
    int V=9 ;
    Graph g=new Graph(V);
    g.addEdge(0,1);
    g.addEdge(0,7);
    g.addEdge(1,2);
    g.addEdge(1,7);
    g.addEdge(2,3);
    g.addEdge(2,8);
    g.addEdge(2,5);
    g.addEdge(3,4);
    g.addEdge(3,5);
    g.addEdge(4,5);
    g.addEdge(5,6);
    g.addEdge(6,7);
    g.addEdge(6,8);
    g.addEdge(7,8);
    System.out.println(g.countEdges());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Graph {
   attribute V : int;
   attribute adj : Sequence(Sequence(int));
   static operation newGraph( V : int) : Graph
  pre: true
  post: true
  activity:
  ( var self : Graph ;
    self := createGraph();
    self.initialise(V);
    return self );
  operation initialise( V : int) : void
  pre: true  post: true
  activity: (     self.V := V ; 
     self.adj := Integer.subrange(1,V)->collect(null) ; 
         var i : int ; i := 0 ; while i < V do (     adj[i+1] := Sequence{} ;  ;     i := i + 1 ) );
   operation addEdge( u : int, v : int) : void
  pre: true
  post: true
  activity: (     adj[u+1]->excludes(v) ; 
     adj[v+1]->excludes(u) );
   operation countEdges() : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < V do (     sum := sum+(adj[i+1]->size()) ;  ;     i := i + 1 ) ; 
     return sum / 2 );
}
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var V : int ; V := 9 ;
     var g : Graph ; g := Graph.newGraph(V) ;
    g.addEdge(0, 1) ; 
    g.addEdge(0, 7) ; 
    g.addEdge(1, 2) ; 
    g.addEdge(1, 7) ; 
    g.addEdge(2, 3) ; 
    g.addEdge(2, 8) ; 
    g.addEdge(2, 5) ; 
    g.addEdge(3, 4) ; 
    g.addEdge(3, 5) ; 
    g.addEdge(4, 5) ; 
    g.addEdge(5, 6) ; 
    g.addEdge(6, 7) ; 
    g.addEdge(6, 8) ; 
    g.addEdge(7, 8) ; 
    OclFile["System.out"].println(g.countEdges()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static int findremainder(int arr[],int len,int n){
    int mul=1 ;
    for(int i=0 ; i<len ; i++)mul=(mul*(arr[i] % n))% n ;
    return mul % n ;
  }
  public static void main(String argc[]){
    int[] arr=new int[] {
      100,10,5,25,35,14 };
      int len=6 ;
      int n=11 ;
      System.out.println(findremainder(arr,len,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation findremainder( arr : Sequence(int), len : int, n : int) : int
  pre: true
  post: true
  activity: (     var mul : int ; mul := 1 ;
         var i : int ; i := 0 ; while i < len do (     mul := (mul * (arr[i+1] mod n)) mod n ;  ;     i := i + 1 ) ; 
     return mul mod n );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{100,10,5,25,35,14} ;
     var len : int ; len := 6 ;
     var n : int ; n := 11 ;
     OclFile["System.out"].println(findremainder(arr, len, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int xorEqualsOrCount(int N){
    int count=0 ;
    int bit ;
    while(N>0){
      bit=N % 2 ;
      if(bit==0)count++;
      N=N/2 ;
    }
    return(int)Math.pow(2,count);
  }
  public static void main(String args[]){
    int N=7 ;
    System.out.println(xorEqualsOrCount(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation xorEqualsOrCount( N : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var bit : int ;
     while (N > 0) do (     bit := N mod 2 ; 
     if (bit = 0) then     count := count + 1 ; else skip ; 
     N := N / 2 ) ; 
     return 2->pow(count)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 7 ;
     OclFile["System.out"].println(xorEqualsOrCount(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.regex.Matcher ;
import java.util.regex.Pattern ;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    String ptn=sc.nextLine();
    ptn=ptn.replaceAll("_",".");
    Matcher m=Pattern.compile(ptn).matcher(s);
    if(m.find()){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var ptn : String ; ptn := sc.nextLine() ;
    ptn := ptn.replaceAllMatches("_", "." ) ; 
    var m : OclRegex ; m := OclRegex.compile(ptn).matcher(s) ;
    if (m.nextMatch()) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int rangeGCD(int n,int m){
    return(n==m)? n : 1 ;
  }
  public static void main(String[] args){
    int n=475 ;
    int m=475 ;
    System.out.println(rangeGCD(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation rangeGCD( n : int, m : int) : int
  pre: true
  post: true
  activity: (     return if (n = m) then n else 1 endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 475 ;
     var m : int ; m := 475 ;
     OclFile["System.out"].println(rangeGCD(n, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.regex.*;
class Main {
  public static void main(String[] z){
    Scanner cin=new Scanner(System.in);
    String s=cin.next();
    String t=cin.next().replaceAll("_",".");
    Matcher m=Pattern.compile(t).matcher(s);
    System.out.println(m.find()? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := cin.getCurrent() ;
    var t : String ; t := cin.getCurrent().replaceAllMatches("_", "." ) ;
    var m : OclRegex ; m := OclRegex.compile(t).matcher(s) ;
    OclFile["System.out"].println(if m.nextMatch() then "Yes" else "No" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.lang.Math ;
import java.io.*;
class GFG {
  static double getValue(double n){
    double result=(Math.floor(Math.log(n+1)/Math.log(2)));
    return Math.pow(2,result);
  }
  public static void main(String[] args){
    double n=9 ;
    System.out.println(getValue(n));
    n=1025 ;
    System.out.println(getValue(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getValue( n : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := (((n + 1)->log() / (2)->log())->floor()) ;
     return 2->pow(result) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 9 ;
     OclFile["System.out"].println(getValue(n)) ; 
     n := 1025 ; 
     OclFile["System.out"].println(getValue(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int[][] q=new int[8][8];
  static int[][] ok=new int[8][8];
  static int cnt=0 ;
  static void mark(int a,int b,int x){
    for(int i=0 ; i<8 ; i++){
      for(int j=0 ; j<8 ; j++){
        if(i==a || j==b || Math.abs(i-a)==Math.abs(j-b)){
          ok[i][j]+=x ;
        }
      }
    }
  }
  static void dfs(int a){
    if(cnt==8)return ;
    if(a==64)return ;
    int i=a/8 ;
    int j=a % 8 ;
    if(ok[i][j]==0){
      mark(i,j,1);
      q[i][j]=1 ;
      cnt++;
      dfs(a+1);
      if(cnt==8)return ;
      mark(i,j,-1);
      q[i][j]=0 ;
      cnt--;
      dfs(a+1);
      if(cnt==8)return ;
    }
    else {
      dfs(a+1);
      if(cnt==8)return ;
    }
  }
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    for(int i=0 ; i<k ; i++){
      int r=sc.nextInt();
      int c=sc.nextInt();
      mark(r,c,1);
      q[r][c]=1 ;
    }
    cnt=k ;
    dfs(0);
    for(int i=0 ; i<8 ; i++){
      for(int j=0 ; j<8 ; j++){
        if(q[i][j]==1){
          System.out.print("Q");
        }
        else {
          System.out.print(".");
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute q : Sequence(Sequence(int)) := Integer.subrange(1,8)->collect(Integer.subrange(1,8)->collect(0));
  static   attribute ok : Sequence(Sequence(int)) := Integer.subrange(1,8)->collect(Integer.subrange(1,8)->collect(0));
  static   attribute cnt : int := 0;
  static   operation mark( a : int, b : int, x : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 8 do ( (         var j : int ; j := 0 ; while j < 8 do ( (     if (i = a or j = b or if i - a < 0 then -(i - a) else i - a endif = if j - b < 0 then -(j - b) else j - b endif) then (     ok[i+1][j+1] := ok[i+1][j+1]+(x) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation dfs( a : int) : void
  pre: true
  post: true
  activity: (     if (cnt = 8) then     return else skip ; 
     if (a = 64) then     return else skip ; 
    var i : int ; i := a / 8 ;
    var j : int ; j := a mod 8 ;
    if (ok[i+1][j+1] = 0) then (     execute mark(i, j, 1) ; 
     q[i+1][j+1] := 1 ; 
    cnt := cnt + 1 ; 
    execute dfs(a + 1) ; 
    if (cnt = 8) then     return else skip ; 
    execute mark(i, j, -1) ; 
    q[i+1][j+1] := 0 ; 
    cnt := cnt - 1 ; 
    execute dfs(a + 1) ; 
    if (cnt = 8) then     return else skip ; 
 ) else (     execute dfs(a + 1) ; 
     if (cnt = 8) then     return else skip ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < k do ( (     var r : int ; r := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
     execute mark(r, c, 1) ; 
     q[r+1][c+1] := 1 )  ;     i := i + 1 ) ; 
    cnt := k ; 
    execute dfs(0) ; 
        var i : int ; i := 0 ; while i < 8 do ( (         var j : int ; j := 0 ; while j < 8 do ( (     if (q[i+1][j+1] = 1) then (     OclFile["System.out"].print("Q") ) else (     OclFile["System.out"].print(".") ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Board {
  int[] Q ;
  boolean[] filled ;
  Board(){
    Q=new int[8];
    filled=new boolean[8];
    Arrays.fill(Q,-1);
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    for(int i=0 ; i<k ; ++i){
      int r=sc.nextInt();
      filled[r]=true ;
      int c=sc.nextInt();
      Q[r]=c ;
    }
  }
  boolean solve(int row){
    if(row>=8){
      return true ;
    }
    if(filled[row]){
      return solve(row+1);
    }
    for(int c=0 ; c<8 ; ++c){
      if(can_place(row,c)){
        Q[row]=c ;
        if(solve(row+1)){
          return true ;
        }
        Q[row]=-1 ;
      }
    }
    return false ;
  }
  boolean can_place(int row,int col){
    for(int r=0 ; r<8 ; ++r){
      if(Q[r]==col)return false ;
      int row_difference=Math.abs(r-row);
      if(Q[r]>=0 &&(Q[r]==col+row_difference || Q[r]==col-row_difference))return false ;
    }
    return true ;
  }
  void print(){
    for(int r=0 ; r<8 ; ++r){
      for(int c=0 ; c<Q[r]; ++c){
        System.out.print(".");
      }
      System.out.print("Q");
      for(int c=Q[r]+1 ; c<8 ; ++c){
        System.out.print(".");
      }
      System.out.println();
    }
  }
}
public class Main {
  public static void main(String[] args){
    Board b=new Board();
    b.solve(0);
    b.print();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Board {
   attribute Q : Sequence(int);
   attribute filled : Sequence(boolean);
   static operation newBoard() : Board
  pre: true
  post: true
  activity:
  ( var self : Board ;
    self := createBoard();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     Q := Integer.subrange(1,8)->collect(0) ; 
     filled := Integer.subrange(1,8)->collect(false) ; 
    Q := Q->collect(-1) ; 
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < k do ( (     var r : int ; r := sc.getCurrent()->toInteger() ;
     filled[r+1] := true ; 
     var c : int ; c := sc.getCurrent()->toInteger() ;
     Q[r+1] := c )  ;     i := i + 1 ) ; 
 );
   operation solve( row : int) : boolean
  pre: true
  post: true
  activity: (     if (row >= 8) then (     return true ) else skip ; 
     if (filled[row+1]) then (     return solve(row + 1) ) else skip ; 
         var c : int ; c := 0 ; while c < 8 do ( (     if (can_place(row, c)) then (     Q[row+1] := c ; 
     if (solve(row + 1)) then (     return true ) else skip ; 
     Q[row+1] := -1 ) else skip )  ;     c := c + 1 ) ; 
     return false );
   operation can_place( row : int, col : int) : boolean
  pre: true
  post: true
  activity: (         var r : int ; r := 0 ; while r < 8 do ( (     if (Q[r+1] = col) then     return false else skip ; 
     var row_difference : int ; row_difference := if r - row < 0 then -(r - row) else r - row endif ;
     if (Q[r+1] >= 0 & (Q[r+1] = col + row_difference or Q[r+1] = col - row_difference)) then     return false else skip )  ;     r := r + 1 ) ; 
     return true );
   operation print() : void
  pre: true
  post: true
  activity: (         var r : int ; r := 0 ; while r < 8 do ( (         var c : int ; c := 0 ; while c < Q[r+1] do ( (     OclFile["System.out"].print(".") )  ;     c := c + 1 ) ; 
     OclFile["System.out"].print("Q") ; 
         var c : int ; c := Q[r+1] + 1 ; while c < 8 do ( (     OclFile["System.out"].print(".") )  ;     c := c + 1 ) ; 
     OclFile["System.out"].println() )  ;     r := r + 1 ) );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var b : Board ; b := Board.newBoard() ;
     b.solve(0) ; 
     b.print() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    r=new int[8];
    Arrays.fill(r,-1);
    int k=sc.nextInt();
    for(int i=0 ; i<k ; i++){
      r[sc.nextInt()]=sc.nextInt();
    }
    used=new boolean[8];
    perm=new int[8];
    permutation(0,8);
    String[] q={
      "Q.......",".Q......","..Q.....","...Q....","....Q...",".....Q..","......Q.",".......Q" };
      for(int i=0 ; i<8 ; i++){
        System.out.println(q[res[i] ]);
      }
      sc.close();
    }
    static int[] r ;
    static int[] res ;
    static boolean[] used ;
    static int[] perm ;
    static void permutation(int pos,int n){
      if(pos==n){
        for(int i=0 ; i<n ; i++){
          if(r[i]!=-1 && r[i]!=perm[i]){
            return ;
          }
        }
        if(res==null){
          boolean flag=true ;
          for(int i=0 ; i<n ; i++){
            for(int j=i+1 ; j<n ; j++){
              if(perm[i]<n-(j-i)&& perm[j]==perm[i]+j-i){
                flag=false ;
                break ;
              }
              if(perm[i]>=j-i && perm[j]==perm[i]-(j-i)){
                flag=false ;
                break ;
              }
            }
          }
          if(flag){
            res=perm.clone();
          }
        }
        return ;
      }
      for(int i=0 ; i<n ; i++){
        if(! used[i]){
          perm[pos]=i ;
          used[i]=true ;
          permutation(pos+1,n);
          used[i]=false ;
        }
      }
      return ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     r := Integer.subrange(1,8)->collect(0) ; 
    r := r->collect(-1) ; 
    var k : int ; k := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < k do ( (     r[sc.getCurrent()->toInteger()+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    used := Integer.subrange(1,8)->collect(false) ; 
    perm := Integer.subrange(1,8)->collect(0) ; 
    execute permutation(0, 8) ; 
    var q : Sequence(String) ; q := Sequence{"Q.......",".Q......","..Q.....","...Q....","....Q...",".....Q..","......Q.",".......Q"} ;
        var i : int ; i := 0 ; while i < 8 do ( (     OclFile["System.out"].println(q[res[i+1]+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   attribute r : Sequence(int);
  static   attribute res : Sequence(int);
  static   attribute used : Sequence(boolean);
  static   attribute perm : Sequence(int);
  static   operation permutation( pos : int, n : int) : void
  pre: true
  post: true
  activity: (     if (pos = n) then (         var i : int ; i := 0 ; while i < n do ( (     if (r[i+1] /= -1 & r[i+1] /= perm[i+1]) then (     return ) else skip )  ;     i := i + 1 ) ; 
     if (res = null) then (     var flag : boolean ; flag := true ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (perm[i+1] < n - (j - i) & perm[j+1] = perm[i+1] + j - i) then (     flag := false ; 
     break ) else skip ; 
     if (perm[i+1] >= j - i & perm[j+1] = perm[i+1] - (j - i)) then (     flag := false ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (flag) then (     res := perm->copy() ) else skip ) else skip ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     if (not(used[i+1])) then (     perm[pos+1] := i ; 
     used[i+1] := true ; 
     execute permutation(pos + 1, n) ; 
     used[i+1] := false ) else skip )  ;     i := i + 1 ) ; 
     return );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        long a=sc.nextLong();
        long b=sc.nextLong();
        if(a<b)System.out.println(b-a);
        else {
          if(a % 2!=b % 2)System.out.println(1);
          else System.out.println(0);
        }
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
     if (a < b) then     OclFile["System.out"].println(b - a) ; else (     if (a mod 2 /= b mod 2) then     OclFile["System.out"].println(1) ; else     OclFile["System.out"].println(0) ; ) ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static final int[] queens=new int[8];
  static final boolean[] threatend=new boolean[8];
  public static void main(String[] Args)throws IOException {
    final BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    final int n=Integer.parseInt(br.readLine());
    for(int i=0 ; i<n ; i++){
      StringTokenizer st=new StringTokenizer(br.readLine()," ");
      int r=Integer.parseInt(st.nextToken());
      int c=Integer.parseInt(st.nextToken());
      queens[r]=c ;
      threatend[r]=true ;
    }
    check(0);
    final char[] output=new char[72];
    Arrays.fill(output,'.');
    for(int i=8 ; i<72 ; i+=9){
      output[i]='\n' ;
    }
    for(int i=0 ; i<8 ; i++){
      output[i*9+queens[i] ]='Q' ;
    }
    System.out.print(output);
  }
  private static boolean check(int r){
    if(r>=8)return true ;
    if(threatend[r])return available(r,queens[r])&& check(r+1);
    for(int i=0 ; i<8 ; i++){
      queens[r]=i ;
      if(available(r,i)&& check(r+1))return true ;
    }
    return false ;
  }
  private static boolean available(int r,int c){
    for(int i=0 ; i<8 ; i++){
      if(i<r ||(i>r && threatend[i])){
        if(c==queens[i])return false ;
        if(Math.abs(c-queens[i])==Math.abs(r-i))return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute queens : Sequence(int) := Integer.subrange(1,8)->collect(0);
  static    attribute threatend : Sequence(boolean) := Integer.subrange(1,8)->collect(false);
  static   operation main( Args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String_String(br.readLine(), " ") ;
     var r : int ; r := (st.next())->toInteger() ;
    var c : int ; c := (st.next())->toInteger() ;
    queens[r+1] := c ; 
    threatend[r+1] := true ; 
 )  ;     i := i + 1 ) ; 
    execute check(0) ; 
    var output : Sequence(String) ; output := Integer.subrange(1,72)->collect(0) ;
    output := output->collect('.') ; 
        var i : int ; i := 8 ; while i < 72 do ( (     output[i+1] := '
' )  ;     i := i+(9) ) ; 
        var i : int ; i := 0 ; while i < 8 do ( (     output[i * 9 + queens[i+1]+1] := 'Q' )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(output) ; 
 );
  static   operation check( r : int) : boolean
  pre: true
  post: true
  activity: (     if (r >= 8) then     return true else skip ; 
     if (threatend[r+1]) then     return available(r, queens[r+1]) & check(r + 1) else skip ; 
         var i : int ; i := 0 ; while i < 8 do ( (     queens[r+1] := i ; 
     if (available(r, i) & check(r + 1)) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation available( r : int, c : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 8 do ( (     if (i < r or (i > r & threatend[i+1])) then (     if (c = queens[i+1]) then     return false else skip ; 
     if (if c - queens[i+1] < 0 then -(c - queens[i+1]) else c - queens[i+1] endif = if r - i < 0 then -(r - i) else r - i endif) then     return false else skip ) else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isCyclic(long N){
    long num=N ;
    int count=0 ;
    int digit=(int)(num % 10);
    boolean allSame=true ;
    while(num>0){
      count++;
      if(num % 10!=digit)allSame=false ;
      num=num/10 ;
    }
    if(allSame==true)return false ;
    if(count % 2==0){
      long halfPower=(long)Math.pow(10,count/2);
      long firstHalf=N % halfPower ;
      long secondHalf=N/halfPower ;
      if(firstHalf==firstHalf && isCyclic(firstHalf))return false ;
    }
    num=N ;
    while(true){
      long rem=num % 10 ;
      long div=num/10 ;
      num=(long)(Math.pow(10,count-1))*rem+div ;
      if(num==N)break ;
      if(num % N!=0)return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    long N=142857 ;
    if(isCyclic(N))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isCyclic( N : long) : boolean
  pre: true
  post: true
  activity: (     var num : long ; num := N ;
     var count : int ; count := 0 ;
    var digit : int ; digit := (num mod 10)->oclAsType(int) ;
    var allSame : boolean ; allSame := true ;
    while (num > 0) do (     count := count + 1 ; 
     if (num mod 10 /= digit) then     allSame := false ; else skip ; 
     num := num / 10 ) ; 
    if (allSame = true) then     return false else skip ; 
    if (count mod 2 = 0) then (     var halfPower : long ; halfPower := 10->pow(count / 2)->oclAsType(long) ;
     var firstHalf : long ; firstHalf := N mod halfPower ;
     var secondHalf : long ; secondHalf := N / halfPower ;
     if (firstHalf = firstHalf & isCyclic(firstHalf)) then     return false else skip ) else skip ; 
    num := N ; 
    while (true) do (     var rem : long ; rem := num mod 10 ;
     var div : long ; div := num / 10 ;
    num := (10->pow(count - 1))->oclAsType(long) * rem + div ; 
    if (num = N) then     break else skip ; 
    if (num mod N /= 0) then     return false else skip ; 
 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := 142857 ;
     if (isCyclic(N)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean subarrayPossible(int arr[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=arr[i];
      if(sum<=0)return true ;
    }
    sum=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      sum+=arr[i];
      if(sum<=0)return true ;
    }
    return false ;
  }
  public static void main(String args[]){
    int arr[]={
      10,5,-12,7,-10,20,30,-10,50,60 };
      int size=arr.length ;
      if(subarrayPossible(arr,size))System.out.print("Yes"+"\n");
      else System.out.print("No"+"\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation subarrayPossible( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(arr[i+1]) ; 
     if (sum <= 0) then     return true else skip )  ;     i := i + 1 ) ; 
    sum := 0 ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     sum := sum+(arr[i+1]) ; 
     if (sum <= 0) then     return true else skip )  ;     i := i - 1 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,5,-12,7,-10,20,30,-10,50,60} ;
     var size : int ; size := arr->size() ;
     if (subarrayPossible(arr, size)) then     OclFile["System.out"].print("Yes" + "\n") ; else     OclFile["System.out"].print("No" + "\n") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String largestSubStr(String s){
    while(s.length()!=0 && s.charAt(s.length()-1)=='1')s=s.substring(0,s.length()-1);
    if(s.length()==0)return "-1" ;
    else return s ;
  }
  public static void main(String[] args){
    String s="11001" ;
    System.out.println(largestSubStr(s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation largestSubStr( s : String) : String
  pre: true
  post: true
  activity: (     while (s->size() /= 0 & s->at(s->size() - 1+1) = '1') do     s := s.subrange(0+1,s->size() - 1) ; ; 
     if (s->size() = 0) then     return "-1" else     return s );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "11001" ;
     OclFile["System.out"].println(largestSubStr(s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  static int[][] multi ;
  static int[] line ;
  static int[] col ;
  static int rec(int m,int n){
    if(m==n)return 0 ;
    if(multi[m][n]==0){
      int min=Integer.MAX_VALUE ;
      for(int i=m ; i<n ; i++){
        int r=rec(m,i)+rec(i+1,n)+(line[m]*col[i]*col[n]);
        if(r<min)min=r ;
      }
      multi[m][n]=min ;
    }
    return multi[m][n];
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    multi=new int[n][n];
    line=new int[n];
    col=new int[n];
    for(int i=0 ; i<n ; i++){
      line[i]=scan.nextInt();
      col[i]=scan.nextInt();
    }
    scan.close();
    System.out.println(rec(0,n-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute multi : Sequence(Sequence(int));
  static   attribute line : Sequence(int);
  static   attribute col : Sequence(int);
  static   operation rec( m : int, n : int) : int
  pre: true
  post: true
  activity: (     if (m = n) then     return 0 else skip ; 
     if (multi[m+1][n+1] = 0) then (     var min : int ; min := 2147483647 ;
         var i : int ; i := m ; while i < n do ( (     var r : int ; r := rec(m, i) + rec(i + 1, n) + (line[m+1] * col[i+1] * col[n+1]) ;
     if (r < min) then     min := r ; else skip )  ;     i := i + 1 ) ; 
     multi[m+1][n+1] := min ) else skip ; 
     return multi[m+1][n+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    multi := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
    line := Integer.subrange(1,n)->collect(0) ; 
    col := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     line[i+1] := scan.getCurrent()->toInteger() ; 
     col[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(rec(0, n - 1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static final int MAX=100 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] in ;
    int[] a=new int[MAX+1];
    for(int i=0 ; i<n ; ++i){
      in=br.readLine().split(" ");
      a[i]=Integer.parseInt(in[0]);
      if(i==n-1){
        a[i+1]=Integer.parseInt(in[1]);
      }
    }
    long[][] cost=new long[MAX][MAX];
    calcCost(a,cost);
    System.out.println(cost[0][n-1]);
  }
  public static void calcCost(int[] a,long[][] cost){
    int n=cost.length ;
    for(int k=0 ; k<n ; k++){
      for(int i=0 ; i+k<n ; i++){
        if(k==0){
          cost[i][k]=0 ;
          continue ;
        }
        cost[i][k]=Long.MAX_VALUE ;
        for(int j=0 ; j<k ; j++){
          long c=cost[i][j]+cost[i+j+1][k-j-1]+a[i]*a[i+j+1]*a[i+k+1];
          if(c<cost[i][k]){
            cost[i][k]=c ;
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 100;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var in : Sequence(String) ;
    var a : Sequence(int) ; a := Integer.subrange(1,MAX + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     in := br.readLine()->split(" ") ; 
     a[i+1] := (in[0+1])->toInteger() ; 
     if (i = n - 1) then (     a[i + 1+1] := (in[1+1])->toInteger() ) else skip )  ;     i := i + 1 ) ; 
    var cost : Sequence(Sequence(long)) ; cost := Integer.subrange(1,MAX)->collect(Integer.subrange(1,MAX)->collect(0)) ;
    execute calcCost(a, cost) ; 
    OclFile["System.out"].println(cost[0+1][n - 1+1]) ; 
 );
  static   operation calcCost( a : Sequence(int), cost : Sequence(Sequence(long))) : void
  pre: true
  post: true
  activity: (     var n : int ; n := cost->size() ;
         var k : int ; k := 0 ; while k < n do ( (         var i : int ; i := 0 ; while i + k < n do ( (     if (k = 0) then (     cost[i+1][k+1] := 0 ; 
     continue ) else skip ; 
     cost[i+1][k+1] := "9223372036854775807"->toLong() ; 
         var j : int ; j := 0 ; while j < k do ( (     var c : long ; c := cost[i+1][j+1] + cost[i + j + 1+1][k - j - 1+1] + a[i+1] * a[i + j + 1+1] * a[i + k + 1+1] ;
     if (c < cost[i+1][k+1]) then (     cost[i+1][k+1] := c ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  static int[][] dp ;
  static int[] p ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.nextLine());
    dp=new int[n+1][n+1];
    p=new int[n+1];
    for(int i=0 ; i<n ; i++){
      int[] input=Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
      p[i]=input[0];
      p[i+1]=input[1];
    }
    out.println(count(1,n));
  }
  static int count(int i,int j){
    if(dp[i][j]!=0 || i==j)return dp[i][j];
    if(i-j==1)return dp[i][j]=p[i-1]*p[i]*p[j];
    int min=Integer.MAX_VALUE ;
    for(int k=i ; k<j ; k++){
      min=min(min,count(i,k)+count(k+1,j)+p[i-1]*p[k]*p[j]);
    }
    return dp[i][j]=min ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dp : Sequence(Sequence(int));
  static   attribute p : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.nextLine())->toInteger() ;
    dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ; 
    p := Integer.subrange(1,n + 1)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     var input : Sequence(int) ; input := stream(sc.nextLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
     p[i+1] := input[0+1] ; 
     p[i + 1+1] := input[1+1] )  ;     i := i + 1 ) ; 
    out.println(count(1, n)) ; 
 );
  static   operation count( i : int, j : int) : int
  pre: true
  post: true
  activity: (     if (dp[i+1][j+1] /= 0 or i = j) then     return dp[i+1][j+1] else skip ; 
     if (i - j = 1) then     return dp[i+1][j+1] else skip ; 
    var min : int ; min := 2147483647 ;
        var k : int ; k := i ; while k < j do ( (     min := Set{min, count(i, k) + count(k + 1, j) + p[i - 1+1] * p[k+1] * p[j+1]}->min() )  ;     k := k + 1 ) ; 
    return dp[i+1][j+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class IS {
  public static void main(String[] args){
    new IS().runapp();
  }
  void runapp(){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int d=scan.nextInt();
    int[] sequence=new int[n];
    int step=0 ;
    int store ;
    for(int x=0 ; x<n ; x++){
      sequence[x]=scan.nextInt();
    }
    for(int y=0 ; y<n-1 ; y++){
      while(sequence[y+1]<=sequence[y]){
        int diff=sequence[y+1]-sequence[y];
        if(sequence[y+1]==sequence[y]){
          sequence[y+1]=sequence[y+1]+d ;
          step=step+1 ;
        }
        else {
          diff=-diff ;
          store=(diff/d)+1 ;
          step=step+store ;
          sequence[y+1]=sequence[y+1]+(d*store);
        }
      }
    }
    System.out.printf("%d",step);
  }
}
------------------------------------------------------------
OCL File:
---------
 class IS {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     IS.newIS().runapp() );
   operation runapp() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var d : int ; d := scan.getCurrent()->toInteger() ;
    var sequence : Sequence(int) ; sequence := Integer.subrange(1,n)->collect(0) ;
    var step : int ; step := 0 ;
    var store : int ;
        var x : int ; x := 0 ; while x < n do ( (     sequence[x+1] := scan.getCurrent()->toInteger() )  ;     x := x + 1 ) ; 
        var y : int ; y := 0 ; while y < n - 1 do ( (     while (sequence[y + 1+1] <= sequence[y+1]) do (     var diff : int ; diff := sequence[y + 1+1] - sequence[y+1] ;
     if (sequence[y + 1+1] = sequence[y+1]) then (     sequence[y + 1+1] := sequence[y + 1+1] + d ; 
     step := step + 1 ) else (     diff := -diff ; 
     store := (diff / d) + 1 ; 
     step := step + store ; 
     sequence[y + 1+1] := sequence[y + 1+1] + (d * store) ) ) )  ;     y := y + 1 ) ; 
    OclFile["System.out"].printf("%d", step) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public int findCost(int arr[]){
    int temp[][]=new int[arr.length][arr.length];
    int q=0 ;
    for(int l=2 ; l<arr.length ; l++){
      for(int i=0 ; i<arr.length-l ; i++){
        int j=i+l ;
        temp[i][j]=1000000 ;
        for(int k=i+1 ; k<j ; k++){
          q=temp[i][k]+temp[k][j]+arr[i]*arr[k]*arr[j];
          if(q<temp[i][j]){
            temp[i][j]=q ;
          }
        }
      }
    }
    return temp[0][arr.length-1];
  }
  public static void main(String[] args){
    Main mmc=new Main();
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] arr=new int[N+1];
    for(int i=1 ; i<N+1 ; i++){
      arr[i-1]=sc.nextInt();
      arr[i]=sc.nextInt();
    }
    int cost=mmc.findCost(arr);
    System.out.println(cost);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation findCost( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var temp : Sequence(Sequence(int)) ; temp := Integer.subrange(1,arr->size())->collect(Integer.subrange(1,arr->size())->collect(0)) ;
     var q : int ; q := 0 ;
         var l : int ; l := 2 ; while l < arr->size() do ( (         var i : int ; i := 0 ; while i < arr->size() - l do ( (     var j : int ; j := i + l ;
     temp[i+1][j+1] := 1000000 ; 
         var k : int ; k := i + 1 ; while k < j do ( (     q := temp[i+1][k+1] + temp[k+1][j+1] + arr[i+1] * arr[k+1] * arr[j+1] ; 
     if (q < temp[i+1][j+1]) then (     temp[i+1][j+1] := q ) else skip )  ;     k := k + 1 ) )  ;     i := i + 1 ) )  ;     l := l + 1 ) ; 
     return temp[0+1][arr->size() - 1+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mmc : Main ; mmc := Main.newMain() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i < N + 1 do ( (     arr[i - 1+1] := sc.getCurrent()->toInteger() ; 
     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cost : int ; cost := mmc.findCost(arr) ;
    OclFile["System.out"].println(cost) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class P1301A {
  public static void main(String[] args)throws IOException {
    BufferedReader io=new BufferedReader(new InputStreamReader(System.in));
    Integer cnt=Integer.valueOf(io.readLine());
    List<String>rs=new ArrayList<String>();
    while(cnt>0){
      cnt--;
      String a=io.readLine();
      String b=io.readLine();
      String c=io.readLine();
      Boolean flag=true ;
      for(int i=0 ; i<c.length(); i++){
        if(c.charAt(i)!=a.charAt(i)&& c.charAt(i)!=b.charAt(i)){
          flag=false ;
          break ;
        }
      }
      if(flag){
        rs.add("YES");
      }
      else {
        rs.add("NO");
      }
    }
    for(String string : rs){
      System.out.println(string);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P1301A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var cnt : int ; cnt := (io.readLine())->toInteger() ;
    var rs : Sequence(String) ; rs := Sequence{} ;
    while (cnt > 0) do (     cnt := cnt - 1 ; 
     var a : String ; a := io.readLine() ;
    var b : String ; b := io.readLine() ;
    var c : String ; c := io.readLine() ;
    var flag : Boolean ; flag := true ;
        var i : int ; i := 0 ; while i < c->size() do ( (     if (c->at(i+1) /= a->at(i+1) & c->at(i+1) /= b->at(i+1)) then (     flag := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then (     rs := rs->including("YES") ) else (     rs := rs->including("NO") ) ;  
 ) ; 
    for (string : rs) do ( (     OclFile["System.out"].println(string) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String a ;
    String b ;
    String c ;
    boolean flag=true ;
    int n=scan.nextInt();
    for(int i=1 ; i<=n ; i++){
      flag=true ;
      a=scan.next();
      b=scan.next();
      c=scan.next();
      for(int j=0 ; j<a.length(); j++){
        if(a.charAt(j)==b.charAt(j)){
          if(c.charAt(j)!=a.charAt(j)){
            flag=false ;
          }
        }
        else if(a.charAt(j)!=b.charAt(j)){
          if(c.charAt(j)==a.charAt(j)|| c.charAt(j)==b.charAt(j))continue ;
          else {
            flag=false ;
          }
        }
      }
      if(flag)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ;
    var b : String ;
    var c : String ;
    var flag : boolean ; flag := true ;
    var n : int ; n := scan.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= n do ( (     flag := true ; 
     a := scan.getCurrent() ; 
    b := scan.getCurrent() ; 
    c := scan.getCurrent() ; 
        var j : int ; j := 0 ; while j < a->size() do ( (     if (a->at(j+1) = b->at(j+1)) then (     if (c->at(j+1) /= a->at(j+1)) then (     flag := false ) else skip ) else     if (a->at(j+1) /= b->at(j+1)) then (     if (c->at(j+1) = a->at(j+1) or c->at(j+1) = b->at(j+1)) then     continue else (     flag := false ) ) else skip ; )  ;     j := j + 1 ) ; 
    if (flag) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    String a=null,b=null,c=null ;
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),length,i,flag ;
    sc.nextLine();
    while(n--!=0){
      flag=1 ;
      a=sc.nextLine();
      b=sc.nextLine();
      c=sc.nextLine();
      length=a.length();
      for(i=0 ; i<length ; i++){
        if(! c.substring(i,i+1).equals(a.substring(i,i+1))&& ! c.substring(i,i+1).equals(b.substring(i,i+1))){
          flag=0 ;
          break ;
        }
      }
      System.out.println(flag==1 ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ; a := null ;
    var b : String ; b := null ;
    var c : String ; c := null ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var length : int ;
    var i : int ;
    var flag : int ;
    skip ; 
        while (n /= 0) do (    skip ; (     flag := 1 ; 
     a := sc.nextLine() ; 
    b := sc.nextLine() ; 
    c := sc.nextLine() ; 
    length := a->size() ; 
        i := 0 ; while i < length do ( (     if (not(c.subrange(i+1,i + 1) = a.subrange(i+1,i + 1)) & not(c.subrange(i+1,i + 1) = b.subrange(i+1,i + 1))) then (     flag := 0 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if flag = 1 then "YES" else "NO" endif) ; 
 ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class A_Three_Strings {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      String a=sc.next();
      String b=sc.next();
      String c=sc.next();
      System.out.println(solve(a,b,c)? "YES" : "NO");
    }
    sc.close();
  }
  static boolean solve(String a,String b,String c){
    return IntStream.range(0,c.length()).allMatch(i->c.charAt(i)==a.charAt(i)|| c.charAt(i)==b.charAt(i));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Three_Strings {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var a : String ; a := sc.getCurrent() ;
     var b : String ; b := sc.getCurrent() ;
     var c : String ; c := sc.getCurrent() ;
     OclFile["System.out"].println(if solve(a, b, c) then "YES" else "NO" endif) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : String, b : String, c : String) : boolean
  pre: true
  post: true
  activity: (     return Integer.subrange(0, c->size()-1)->forAll( _x2 | (lambda i : OclAny in c->at(i+1) = a->at(i+1) or c->at(i+1) = b->at(i+1))->apply(_x2) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner in=new Scanner(System.in);
  static int n,m ;
  static long a[],b[];
  static void solve(){
    int even1=0,odd1=0 ;
    for(int i=0 ; i<n ; ++i){
      if(a[i] % 2==1){
++odd1 ;
      }
      else {
++even1 ;
      }
    }
    int even2=0,odd2=0 ;
    for(int i=0 ; i<m ; ++i){
      if(b[i] % 2==1){
++odd2 ;
      }
      else {
++even2 ;
      }
    }
    int odd=Math.min(even1,odd2)+Math.min(even2,odd1);
    System.out.println(odd);
  }
  public static void main(String[] args){
    n=in.nextInt();
    m=in.nextInt();
    a=new long[n];
    b=new long[m];
    for(int i=0 ; i<n ; ++i){
      a[i]=in.nextLong();
    }
    for(int i=0 ; i<m ; ++i){
      b[i]=in.nextLong();
    }
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   attribute a : long;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var even1 : int ; even1 := 0 ;
    var odd1 : int ; odd1 := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] mod 2 = 1) then (     odd1 := odd1 + 1 ) else (     even1 := even1 + 1 ) )  ;     i := i + 1 ) ; 
    var even2 : int ; even2 := 0 ;
    var odd2 : int ; odd2 := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     if (b[i+1] mod 2 = 1) then (     odd2 := odd2 + 1 ) else (     even2 := even2 + 1 ) )  ;     i := i + 1 ) ; 
    var odd : int ; odd := Set{even1, odd2}->min() + Set{even2, odd1}->min() ;
    OclFile["System.out"].println(odd) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := in.getCurrent()->toInteger() ; 
     m := in.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
    b := Integer.subrange(1,m)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := in.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    execute solve() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int N=1000005 ;
  static void sumOddDigit(int digitSum[]){
    for(int i=1 ; i<N ; i++){
      digitSum[i]=digitSum[i/10]+(i & 1)*(i % 10);
    }
  }
  static void sumFactor(int digitSum[],int factorDigitSum[]){
    for(int i=1 ; i<N ; i++){
      for(int j=i ; j<N ; j+=i){
        factorDigitSum[j]+=digitSum[i];
      }
    }
  }
  static void wrapper(int q,int n[]){
    int digitSum[]=new int[N];
    int factorDigitSum[]=new int[N];
    sumOddDigit(digitSum);
    sumFactor(digitSum,factorDigitSum);
    for(int i=0 ; i<q ; i++)System.out.print(factorDigitSum[n[i] ]+" ");
  }
  public static void main(String args[]){
    int q=2 ;
    int n[]=new int[] {
      10,36 };
      wrapper(q,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 1000005;
  static   operation sumOddDigit( digitSum : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < N do ( (     digitSum[i+1] := digitSum[i / 10+1] + (MathLib.bitwiseAnd(i,1)) * (i mod 10) )  ;     i := i + 1 ) );
  static   operation sumFactor( digitSum : Sequence(int), factorDigitSum : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < N do ( (         var j : int ; j := i ; while j < N do ( (     factorDigitSum[j+1] := factorDigitSum[j+1]+(digitSum[i+1]) )  ;     j := j+(i) ) )  ;     i := i + 1 ) );
  static   operation wrapper( q : int, n : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var digitSum : Sequence(int) ; digitSum := Integer.subrange(1,N)->collect(0) ;
     var factorDigitSum : Sequence(int) ; factorDigitSum := Integer.subrange(1,N)->collect(0) ;
    execute sumOddDigit(digitSum) ; 
    execute sumFactor(digitSum, factorDigitSum) ; 
        var i : int ; i := 0 ; while i < q do (     OclFile["System.out"].print(factorDigitSum[n[i+1]+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var q : int ; q := 2 ;
     var n : Sequence(int) ; n := Sequence{10,36} ;
     execute wrapper(q, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double squareRoot(double n){
    return Math.pow(2,0.5*(Math.log(n)/Math.log(2)));
  }
  public static void main(String[] args){
    double n=12 ;
    System.out.println(squareRoot(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation squareRoot( n : double) : double
  pre: true
  post: true
  activity: (     return 2->pow(0.5 * ((n)->log() / (2)->log())) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 12 ;
     OclFile["System.out"].println(squareRoot(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int a=scan.nextInt();
    String op=scan.next();
    int b=scan.nextInt();
    while(true){
      if(op.equals("+")){
        System.out.println(a+b);
        a=scan.nextInt();
        op=scan.next();
        b=scan.nextInt();
      }
      else if(op.equals("-")){
        System.out.println(a-b);
        a=scan.nextInt();
        op=scan.next();
        b=scan.nextInt();
      }
      else if(op.equals("*")){
        System.out.println(a*b);
        a=scan.nextInt();
        op=scan.next();
        b=scan.nextInt();
      }
      else if(op.equals("/")){
        System.out.println(a/b);
        a=scan.nextInt();
        op=scan.next();
        b=scan.nextInt();
      }
      else if(op.equals("?")){
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
    var op : String ; op := scan.getCurrent() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    while (true) do (     if (op = "+") then (     OclFile["System.out"].println(a + b) ; 
     a := scan.getCurrent()->toInteger() ; 
     op := scan.getCurrent() ; 
     b := scan.getCurrent()->toInteger() ) else     if (op = "-") then (     OclFile["System.out"].println(a - (b)->char2byte()) ; 
     a := scan.getCurrent()->toInteger() ; 
     op := scan.getCurrent() ; 
     b := scan.getCurrent()->toInteger() ) else     if (op = "*") then (     OclFile["System.out"].println(a * b) ; 
     a := scan.getCurrent()->toInteger() ; 
     op := scan.getCurrent() ; 
     b := scan.getCurrent()->toInteger() ) else     if (op = "/") then (     OclFile["System.out"].println(a / b) ; 
     a := scan.getCurrent()->toInteger() ; 
     op := scan.getCurrent() ; 
     b := scan.getCurrent()->toInteger() ) else     if (op = "?") then (     break ) else skip ; ;  ;  ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int highestPowerof2(int n){
    int p=(int)(Math.log(n)/Math.log(2));
    return(int)Math.pow(2,p);
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(highestPowerof2(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation highestPowerof2( n : int) : int
  pre: true
  post: true
  activity: (     var p : int ; p := ((n)->log() / (2)->log())->oclAsType(int) ;
     return 2->pow(p)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(highestPowerof2(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countPaths(int m,int n){
    int[][] dp=new int[m+1][n+1];
    for(int i=1 ; i<=m ; i++){
      for(int j=1 ; j<=n ; j++){
        if(i==1 || j==1)dp[i][j]=1 ;
        else dp[i][j]=dp[i-1][j]+dp[i][j-1];
      }
    }
    return dp[m][n];
  }
  public static void main(String[] args){
    int n=5 ;
    int m=5 ;
    System.out.println(countPaths(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countPaths( m : int, n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
         var i : int ; i := 1 ; while i <= m do ( (         var j : int ; j := 1 ; while j <= n do ( (     if (i = 1 or j = 1) then     dp[i+1][j+1] := 1 ; else     dp[i+1][j+1] := dp[i - 1+1][j+1] + dp[i+1][j - 1+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return dp[m+1][n+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var m : int ; m := 5 ;
     OclFile["System.out"].println(countPaths(n, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int arrSize=51 ;
  static int maxSum=201 ;
  static int MAX=100 ;
  static int inf=999999 ;
  static int dp[][]=new int[arrSize][maxSum];
  static int visit[][]=new int[arrSize][maxSum];
  static int RetClose(int a,int b,int s){
    if(Math.abs(a-s)<Math.abs(b-s))return a ;
    else return b ;
  }
  static int MinDiff(int i,int sum,int arr[],int n){
    if(i==n)return 0 ;
    if(visit[i][sum+MAX]>0)return dp[i][sum+MAX];
    visit[i][sum+MAX]=1 ;
    dp[i][sum+MAX]=RetClose(arr[i]+MinDiff(i+1,sum+arr[i],arr,n),MinDiff(i+1,sum,arr,n),-1*sum);
    return dp[i][sum+MAX];
  }
  static void FindClose(int arr[],int n){
    int ans=inf ;
    for(int i=1 ; i<=n ; i++)ans=RetClose(arr[i-1]+MinDiff(i,arr[i-1],arr,n),ans,0);
    System.out.println(ans);
  }
  public static void main(String[] args){
    int arr[]={
      25,-9,-10,-4,-7,-33 };
      int n=arr.length ;
      FindClose(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute arrSize : int := 51;
  static   attribute maxSum : int := 201;
  static   attribute MAX : int := 100;
  static   attribute inf : int := 999999;
  static   attribute dp : int := Integer.subrange(1,arrSize)->collect(Integer.subrange(1,maxSum)->collect(0));
  static   attribute visit : int := Integer.subrange(1,arrSize)->collect(Integer.subrange(1,maxSum)->collect(0));
  static   operation RetClose( a : int, b : int, s : int) : int
  pre: true
  post: true
  activity: (     if (if a - s < 0 then -(a - s) else a - s endif < if b - s < 0 then -(b - s) else b - s endif) then     return a else     return b );
  static   operation MinDiff( i : int, sum : int, arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (i = n) then     return 0 else skip ; 
     if (visit[i+1][sum + MAX+1] > 0) then     return dp[i+1][sum + MAX+1] else skip ; 
    visit[i+1][sum + MAX+1] := 1 ; 
    dp[i+1][sum + MAX+1] := RetClose(arr[i+1] + MinDiff(i + 1, sum + arr[i+1], arr, n), MinDiff(i + 1, sum, arr, n), -1 * sum) ; 
    return dp[i+1][sum + MAX+1] 
 );
  static   operation FindClose( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := inf ;
         var i : int ; i := 1 ; while i <= n do (     ans := RetClose(arr[i - 1+1] + MinDiff(i, arr[i - 1+1], arr, n), ans, 0) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{25,-9,-10,-4,-7,-33} ;
     var n : int ; n := arr->size() ;
     execute FindClose(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean hasCrest(int arr[],int n,int L,int R){
    int[] present=new int[n];
    for(int i=0 ; i<n ; i++){
      present[i]=0 ;
    }
    for(int i=1 ; i<=n-2 ; i++){
      if((arr[i]<=arr[i+1])&&(arr[i]<=arr[i-1])){
        present[i]=1 ;
      }
    }
    for(int i=1 ; i<n ; i++){
      present[i]+=present[i-1];
    }
    if(present[L]==present[R-1])return true ;
    return false ;
  }
  public static void main(String args[]){
    int arr[]={
      2,1,3,5,12,11,7,9 };
      int N=arr.length ;
      int L=2 ;
      int R=6 ;
      if(hasCrest(arr,N,L,R))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation hasCrest( arr : Sequence(int), n : int, L : int, R : int) : boolean
  pre: true
  post: true
  activity: (     var present : Sequence(int) ; present := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     present[i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n - 2 do ( (     if ((arr[i+1] <= arr[i + 1+1]) & (arr[i+1] <= arr[i - 1+1])) then (     present[i+1] := 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     present[i+1] := present[i+1]+(present[i - 1+1]) )  ;     i := i + 1 ) ; 
    if (present[L+1] = present[R - 1+1]) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,1,3,5,12,11,7,9} ;
     var N : int ; N := arr->size() ;
    var L : int ; L := 2 ;
    var R : int ; R := 6 ;
    if (hasCrest(arr, N, L, R)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countSquares(int m,int n){
    if(n<m){
      int temp=m ;
      m=n ;
      n=temp ;
    }
    return n*(n+1)*(3*m-n+1)/6 ;
  }
  public static void main(String[] args){
    int m=4 ;
    int n=3 ;
    System.out.print("Count of squares is "+countSquares(m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSquares( m : int, n : int) : int
  pre: true
  post: true
  activity: (     if (n < m) then (     var temp : int ; temp := m ;
     m := n ; 
     n := temp ) else skip ; 
     return n * (n + 1) * (3 * m - n + 1) / 6 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 4 ;
     var n : int ; n := 3 ;
     OclFile["System.out"].print("Count of squares is " + countSquares(m, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    int[] l=new int[q];
    int[] r=new int[q];
    for(int i=0 ; i<q ; i++){
      l[i]=sc.nextInt();
      r[i]=sc.nextInt();
    }
    System.out.print(solve(l,r));
    sc.close();
  }
  static String solve(int[] l,int[] r){
    return IntStream.range(0,l.length).mapToObj(i->String.valueOf(computeSum(r[i])-computeSum(l[i]-1))).collect(Collectors.joining("\n"));
  }
  static int computeSum(int limit){
    return((limit % 2==0)? 1 :-1)*(limit+1)/2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Integer.subrange(1,q)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,q)->collect(0) ;
        var i : int ; i := 0 ; while i < q do ( (     l[i+1] := sc.getCurrent()->toInteger() ; 
     r[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(solve(l, r)) ; 
    skip ; 
 );
  static   operation solve( l : Sequence(int), r : Sequence(int)) : String
  pre: true
  post: true
  activity: (     return Integer.subrange(0, l->size()-1).mapToObj(lambda i : OclAny in ((computeSum(r[i+1]) - computeSum(l[i+1] - 1)) + "")).collect(Collectors.joining("\n")) );
  static   operation computeSum( limit : int) : int
  pre: true
  post: true
  activity: (     return (if (limit mod 2 = 0) then 1 else -1 endif) * (limit + 1) / 2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B1080 {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    for(int i=0 ; i<t ; i++){
      int sum=0 ;
      StringTokenizer st=new StringTokenizer(br.readLine());
      int l=Integer.parseInt(st.nextToken()),r=Integer.parseInt(st.nextToken()),length=r-l+1 ;
      if(length % 2==0){
        if(r % 2==0){
          sum=length/2 ;
        }
        else if(r % 2==1){
          sum=-length/2 ;
        }
      }
      else if(length % 2==1){
        if(r % 2==0 && l % 2==0){
          sum=r-(length/2);
        }
        else if(r % 2==1 && l % 2==1){
          sum=-r+(length/2);
        }
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1080 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var sum : int ; sum := 0 ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var l : int ; l := (st.next())->toInteger() ;
    var r : int ; r := (st.next())->toInteger() ;
    var length : int ; length := r - l + 1 ;
    if (length mod 2 = 0) then (     if (r mod 2 = 0) then (     sum := length / 2 ) else     if (r mod 2 = 1) then (     sum := -length / 2 ) else skip ; ) else     if (length mod 2 = 1) then (     if (r mod 2 = 0 & l mod 2 = 0) then (     sum := r - (length / 2) ) else     if (r mod 2 = 1 & l mod 2 = 1) then (     sum := -r + (length / 2) ) else skip ; ) else skip ; ;  
    OclFile["System.out"].println(sum) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  static FastScanner in=new FastScanner();
  static PrintWriter out=new PrintWriter(System.out);
  public static void s(int t){
    t=2 ;
  }
  public static void main(String[] args){
    int n=in.nextInt();
    int[] arr={
      0,6,5,4,3,2,1 };
      int x=in.nextInt();
      HashSet<Integer>set=new HashSet<>(6);
      String res="YES" ;
      while(n--!=0){
        set.clear();
        int s1=in.nextInt(),s2=in.nextInt();
        set.add(s1);
        set.add(s2);
        set.add(x);
        set.add(arr[s1]);
        set.add(arr[s2]);
        set.add(arr[x]);
        if(set.size()!=6)res="NO" ;
      }
      out.println(res);
      out.close();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   attribute in : FastScanner := FastScanner.newFastScanner();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation s( t : int) : void
  pre: true
  post: true
  activity: (     t := 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var arr : Sequence(int) ; arr := Sequence{0,6,5,4,3,2,1} ;
    var x : int ; x := in.nextInt() ;
    var set : Set(int) ; set := Set{} ;
    var res : String ; res := "YES" ;
        while (n /= 0) do (    skip ; (     set := set->intersection(Set{}) ; 
     var s1 : int ; s1 := in.nextInt() ;
    var s2 : int ; s2 := in.nextInt() ;
    set := set->including(s1) ; 
    set := set->including(s2) ; 
    set := set->including(x) ; 
    set := set->including(arr[s1+1]) ; 
    set := set->including(arr[s2+1]) ; 
    set := set->including(arr[x+1]) ; 
    if (set->size() /= 6) then     res := "NO" ; else skip ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),m=in.nextInt();
    ArrayList<Integer>nodd=new ArrayList<>();
    ArrayList<Integer>neven=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      int v=in.nextInt();
      if(v % 2==0){
        neven.add(v);
      }
      else {
        nodd.add(v);
      }
    }
    ArrayList<Integer>modd=new ArrayList<>();
    ArrayList<Integer>meven=new ArrayList<>();
    for(int i=0 ; i<m ; i++){
      int v=in.nextInt();
      if(v % 2==0){
        meven.add(v);
      }
      else {
        modd.add(v);
      }
    }
    int ans=Math.min(neven.size(),modd.size())+Math.min(nodd.size(),meven.size());
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var nodd : Sequence(int) ; nodd := Sequence{} ;
    var neven : Sequence(int) ; neven := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := in.getCurrent()->toInteger() ;
     if (v mod 2 = 0) then (     neven := neven->including(v) ) else (     nodd := nodd->including(v) ) )  ;     i := i + 1 ) ; 
    var modd : Sequence(int) ; modd := Sequence{} ;
    var meven : Sequence(int) ; meven := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     var v : int ; v := in.getCurrent()->toInteger() ;
     if (v mod 2 = 0) then (     meven := meven->including(v) ) else (     modd := modd->including(v) ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := Set{neven->size(), modd->size()}->min() + Set{nodd->size(), meven->size()}->min() ;
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  static int ans(int x){
    if(x % 2==0)return x/2 ;
    else return-x+ans(x-1);
  }
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        int l=sc.nextInt();
        int r=sc.nextInt();
        int sum=ans(r)-ans(l-1);
        System.out.println(sum);
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation ans( x : int) : int
  pre: true
  post: true
  activity: (     if (x mod 2 = 0) then     return x / 2 else     return -x + ans(x - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
     var sum : int ; sum := ans(r) - ans(l - 1) ;
     OclFile["System.out"].println(sum) ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class p1401A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt(),k=sc.nextInt();
      System.out.println(k>n ? k-n :(n-k)% 2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class p1401A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if k > n then k - n else (n - k) mod 2 endif) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javax.swing.*;
import java.io.IOException ;
import java.io.OutputStream ;
import java.math.BigInteger ;
import java.nio.CharBuffer ;
import java.util.*;
public class Main {
  static Scanner scan=new Scanner(System.in);
  public static void main(String[] args){
    int t=1 ;
    while(t-->0){
      System.out.println(solve());
    }
  }
  public static String solve(){
    int n=scan.nextInt();
    String answer=(n-1)% 9+1+"" ;
    return answer ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     OclFile["System.out"].println(solve()) ) ;  ) );
  static   operation solve() : String
  pre: true
  post: true
  activity: (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var answer : String ; answer := (n - 1) mod 9 + 1 + "" ;
     return answer );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static int next ;
  static void solve(){
    while(next>=10){
      int sum=0 ;
      for(char c :(next+"").toCharArray()){
        sum+=c-'0' ;
      }
      next=sum ;
    }
    str.append(next).append("\n");
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    String s[]=bf.readLine().trim().split("\\s+");
    next=Integer.parseInt(s[0]);
    solve();
    pw.println(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute next : int;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     while (next >= 10) do (     var sum : int ; sum := 0 ;
     for (c : (next + "")->characters()) do ( (     sum := sum+(c - ('0')->char2byte()) )  ) ; 
     next := sum ) ; 
     str := str + StringLib.newString(next) + StringLib.newString("\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var s : Sequence(String) ; s := bf.readLine()->trim()->split("\\s+") ;
    next := (s[0+1])->toInteger() ; 
    execute solve() ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class root {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    System.out.println((n-1)% 9+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class root {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println((n - 1) mod 9 + 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      long a=in.nextLong();
      if(a==0)System.out.println(0);
      else if(a % 2==1)System.out.println((a+1)/2);
      else if(a % 2==0)System.out.println(a+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var a : long ; a := in.getCurrent()->toLong() ;
     if (a = 0) then     OclFile["System.out"].println(0) ; else     if (a mod 2 = 1) then     OclFile["System.out"].println((a + 1) / 2) else     if (a mod 2 = 0) then     OclFile["System.out"].println(a + 1) ; else skip ; ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import org.w3c.dom.ls.LSInput ;
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.*;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
import java.util.jar.Attributes ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      long n=in.nextLong();
      long c=n+1 ;
      if(n==0){
        out.println("0");
      }
      else if(c % 2==0){
        out.println(c/2);
      }
      else {
        out.println(c);
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : long ; n := in.nextLong() ;
     var c : long ; c := n + 1 ;
     if (n = 0) then (     skip ) else     if (c mod 2 = 0) then (     skip ) else (     skip ) ;  );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import org.w3c.dom.ls.LSInput ;
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.*;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
import java.util.jar.Attributes ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      long n=in.nextLong();
      long sum=n+1 ;
      if(n==0){
        out.println(0);
      }
      else if(sum % 2==0){
        out.println(sum/2);
      }
      else {
        out.println(sum);
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : long ; n := in.nextLong() ;
     var sum : long ; sum := n + 1 ;
     if (n = 0) then (     skip ) else     if (sum mod 2 = 0) then (     skip ) else (     skip ) ;  );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      long a=in.nextLong();
      if(a % 2==1)System.out.println((a+1)/2);
      else if(a % 2==0 && a>0)System.out.println((a+1));
      else if(a==0)System.out.println("0");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var a : long ; a := in.getCurrent()->toLong() ;
     if (a mod 2 = 1) then     OclFile["System.out"].println((a + 1) / 2) ; else     if (a mod 2 = 0 & a > 0) then     OclFile["System.out"].println((a + 1)) else     if (a = 0) then     OclFile["System.out"].println("0") ; else skip ; ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem979A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong()+1 ;
    System.out.println((n & 1)==0 ? n/2 : n==1 ? 0 : n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem979A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() + 1 ;
     OclFile["System.out"].println(if (MathLib.bitwiseAnd(n,1)) = 0 then n / 2 else if n = 1 then 0 else n endif endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),m=in.nextInt();
    ArrayList<Integer>nodd=new ArrayList<>();
    ArrayList<Integer>neven=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      int v=in.nextInt();
      if(v % 2==0){
        neven.add(v);
      }
      else {
        nodd.add(v);
      }
    }
    ArrayList<Integer>modd=new ArrayList<>();
    ArrayList<Integer>meven=new ArrayList<>();
    for(int i=0 ; i<m ; i++){
      int v=in.nextInt();
      if(v % 2==0){
        meven.add(v);
      }
      else {
        modd.add(v);
      }
    }
    int ans=Math.min(neven.size(),modd.size())+Math.min(nodd.size(),meven.size());
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var nodd : Sequence(int) ; nodd := Sequence{} ;
    var neven : Sequence(int) ; neven := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := in.getCurrent()->toInteger() ;
     if (v mod 2 = 0) then (     neven := neven->including(v) ) else (     nodd := nodd->including(v) ) )  ;     i := i + 1 ) ; 
    var modd : Sequence(int) ; modd := Sequence{} ;
    var meven : Sequence(int) ; meven := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     var v : int ; v := in.getCurrent()->toInteger() ;
     if (v mod 2 = 0) then (     meven := meven->including(v) ) else (     modd := modd->including(v) ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := Set{neven->size(), modd->size()}->min() + Set{nodd->size(), meven->size()}->min() ;
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countWays(int n,int arr[],int len){
    int count[]=new int[n+1];
    count[0]=1 ;
    if(n==0)return 1 ;
    for(int i=1 ; i<=n ; i++){
      int no_ways=0 ;
      for(int j=0 ; j<len ; j++){
        if(i-arr[j]>=0){
          no_ways+=count[i-arr[j] ];
        }
        count[i]=no_ways ;
      }
    }
    return count[n];
  }
  public static void main(String args[]){
    int arr[]={
      1,3,5 };
      int len=arr.length ;
      int n=5 ;
      System.out.print(countWays(n,arr,len));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countWays( n : int, arr : Sequence(int), len : int) : int
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,n + 1)->collect(0) ;
     count[0+1] := 1 ; 
    if (n = 0) then     return 1 else skip ; 
        var i : int ; i := 1 ; while i <= n do ( (     var no_ways : int ; no_ways := 0 ;
         var j : int ; j := 0 ; while j < len do ( (     if (i - arr[j+1] >= 0) then (     no_ways := no_ways+(count[i - arr[j+1]+1]) ) else skip ; 
     count[i+1] := no_ways )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return count[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,5} ;
     var len : int ; len := arr->size() ;
     var n : int ; n := 5 ;
     OclFile["System.out"].print(countWays(n, arr, len)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int N=4 ;
  static int maxDecimalValue(int mat[][],int i,int j,int p){
    if(i>=N || j>=N){
      return 0 ;
    }
    int result=Math.max(maxDecimalValue(mat,i,j+1,p+1),maxDecimalValue(mat,i+1,j,p+1));
    if(mat[i][j]==1){
      return(int)(Math.pow(2,p)+result);
    }
    else {
      return result ;
    }
  }
  public static void main(String[] args){
    int mat[][]={
      {
        1,1,0,1 },{
          0,1,1,0 },{
            1,0,0,1 },{
              1,0,1,1 },};
              System.out.println(maxDecimalValue(mat,0,0,0));
            }
          }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute N : int := 4;
  static   operation maxDecimalValue( mat : Sequence(Sequence(int)), i : int, j : int, p : int) : int
  pre: true
  post: true
  activity: (     if (i >= N or j >= N) then (     return 0 ) else skip ; 
     var result : int ; result := Set{maxDecimalValue(mat, i, j + 1, p + 1), maxDecimalValue(mat, i + 1, j, p + 1)}->max() ;
     if (mat[i+1][j+1] = 1) then (     return (2->pow(p) + result)->oclAsType(int) ) else (     return result ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,1,0,1},Sequence{0,1,1,0},Sequence{1,0,0,1},Sequence{1,0,1,1},} ;
     OclFile["System.out"].println(maxDecimalValue(mat, 0, 0, 0)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double dist(double m,double b1,double b2){
    double d=Math.abs(b2-b1)/((m*m)-1);
    return d ;
  }
  public static void main(String[] args){
    double m=2,b1=4,b2=3 ;
    System.out.println(dist(m,b1,b2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation dist( m : double, b1 : double, b2 : double) : double
  pre: true
  post: true
  activity: (     var d : double ; d := if b2 - b1 < 0 then -(b2 - b1) else b2 - b1 endif / ((m * m) - 1) ;
     return d );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : double ; m := 2 ;
    var b1 : double ; b1 := 4 ;
    var b2 : double ; b2 := 3 ;
     OclFile["System.out"].println(dist(m, b1, b2)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int ps=0 ;
    int ns=0 ;
    for(int i=0 ; i<n ; i++){
      int no=s.nextInt();
      if(no<0)ns=ns-(no);
      else ps=ps+no ;
    }
    System.out.println(ps+ns);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var ps : int ; ps := 0 ;
    var ns : int ; ns := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var no : int ; no := s.getCurrent()->toInteger() ;
     if (no < 0) then     ns := ns - (no) ; else     ps := ps + no ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ps + ns) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF946A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[] arr1=new int[n];
    int b=0 ;
    int c=0 ;
    for(int i=0 ; i<n ; i++){
      arr1[i]=scan.nextInt();
      if(arr1[i]>0){
        b=arr1[i]+b ;
      }
      else if(arr1[i]<0){
        c=arr1[i]+c ;
      }
    }
    System.out.println(b-c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF946A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n)->collect(0) ;
    var b : int ; b := 0 ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr1[i+1] := scan.getCurrent()->toInteger() ; 
     if (arr1[i+1] > 0) then (     b := arr1[i+1] + b ) else     if (arr1[i+1] < 0) then (     c := arr1[i+1] + c ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(b - c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf946A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      ans+=Math.abs(scan.nextInt());
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf946A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans+(if scan.getCurrent()->toInteger() < 0 then -(scan.getCurrent()->toInteger()) else scan.getCurrent()->toInteger() endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class cf946A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[] num=new int[n];
    int seqPos=0 ;
    int seqNeg=0 ;
    for(int i=0 ; i<n ; i++){
      num[i]=scan.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      if(num[i]>=0){
        seqPos+=num[i];
      }
      else if(num[i]<0){
        seqNeg+=num[i];
      }
    }
    System.out.println(seqPos-seqNeg);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf946A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var num : Sequence(int) ; num := Integer.subrange(1,n)->collect(0) ;
    var seqPos : int ; seqPos := 0 ;
    var seqNeg : int ; seqNeg := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     num[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (num[i+1] >= 0) then (     seqPos := seqPos+(num[i+1]) ) else     if (num[i+1] < 0) then (     seqNeg := seqNeg+(num[i+1]) ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(seqPos - seqNeg) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int array[]=new int[105];
    int n,sum=0 ;
    n=scan.nextInt();
    for(int i=0 ; i<n ; i++){
      array[i]=scan.nextInt();
      if(array[i]<0)array[i]=Math.abs(array[i]);
      sum+=array[i];
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var array : Sequence(int) ; array := Integer.subrange(1,105)->collect(0) ;
    var n : int ;
    var sum : int ; sum := 0 ;
    n := scan.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := scan.getCurrent()->toInteger() ; 
     if (array[i+1] < 0) then     array[i+1] := if array[i+1] < 0 then -(array[i+1]) else array[i+1] endif ; else skip ; 
     sum := sum+(array[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countSubstrs(String s1,String s2){
    int ans=0 ;
    for(int i=0 ; i<s1.length(); i++){
      String s3="" ;
      char[] s4=s1.toCharArray();
      for(int j=i ; j<s1.length(); j++){
        s3+=s4[j];
        if(s2.indexOf(s3)!=-1)ans++;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    String s1="aab",s2="aaaab" ;
    System.out.println(countSubstrs(s1,s2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSubstrs( s1 : String, s2 : String) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < s1->size() do ( (     var s3 : String ; s3 := "" ;
     var s4 : Sequence(String) ; s4 := s1->characters() ;
         var j : int ; j := i ; while j < s1->size() do ( (     s3 := s3+(s4[j+1]) ; 
     if (s2->indexOf(s3)-1 /= -1) then     ans := ans + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "aab" ;
    var s2 : String ; s2 := "aaaab" ;
     OclFile["System.out"].println(countSubstrs(s1, s2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=100005 ;
  static boolean[] prime=new boolean[MAX];
  static void SieveOfEratosthenes(){
    for(int i=0 ; i<MAX ; i++)prime[i]=true ;
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<MAX ; p++){
      if(prime[p]){
        for(int i=p*2 ; i<MAX ; i+=p)prime[i]=false ;
      }
    }
  }
  static int countPrimes(int n){
    SieveOfEratosthenes();
    int cnt=0 ;
    for(int i=2 ; i<n ; i++){
      if(prime[i] && prime[i-2])cnt++;
    }
    return cnt ;
  }
  public static void main(String[] args){
    int n=11 ;
    System.out.print(countPrimes(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100005;
  static   attribute prime : Sequence(boolean) := Integer.subrange(1,MAX)->collect(false);
  static   operation SieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < MAX do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
     prime[0+1] := false ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p < MAX do ( (     if (prime[p+1]) then (         var i : int ; i := p * 2 ; while i < MAX do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation countPrimes( n : int) : int
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes() ; 
     var cnt : int ; cnt := 0 ;
         var i : int ; i := 2 ; while i < n do ( (     if (prime[i+1] & prime[i - 2+1]) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 11 ;
     OclFile["System.out"].print(countPrimes(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public final class Template {
  private static int hashofIds[]=new int[100001];
  public static void main(String[] args){
    FastScanner sc=new FastScanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      int id=sc.nextInt();
      if(hashofIds[id]<x){
        System.out.println("NO");
        return ;
      }
      else if(hashofIds[id]==x)hashofIds[id]++;
    }
    System.out.println("YES");
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(InputStream stream){
    br=new BufferedReader(new InputStreamReader(stream));
  }
  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 long nextLong(){
    return Long.parseLong(next());
  }
  public double nextDouble(){
    return Double.parseDouble(next());
  }
  public String nextLine(){
    String str="" ;
    try {
      str=br.readLine();
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return str ;
  }
  public int[] readArray(int n){
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Template {
  static   attribute hashofIds : int := Integer.subrange(1,100001)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var n : int ; n := sc.nextInt() ;
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.nextInt() ;
     var id : int ; id := sc.nextInt() ;
     if (hashofIds[id+1] < x) then (     OclFile["System.out"].println("NO") ; 
     return ) else     if (hashofIds[id+1] = x) then     hashofIds[id+1] := hashofIds[id+1] + 1 ; else skip ; )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("YES") );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( stream : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class okabeandfuturegadgetlaboratory {
  public static void main(String[] args)throws IOException {
    BufferedReader fin=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(fin.readLine());
    int[][] lab=new int[n][n];
    for(int i=0 ; i<n ; i++){
      StringTokenizer st=new StringTokenizer(fin.readLine());
      for(int j=0 ; j<n ; j++){
        lab[i][j]=Integer.parseInt(st.nextToken());
      }
    }
    boolean ans=true ;
    for(int x=0 ; x<n ; x++){
      for(int y=0 ; y<n ; y++){
        if(lab[x][y]!=1){
          int cur=lab[x][y];
          boolean isValid=false ;
          for(int i=0 ; i<n ; i++){
            for(int j=0 ; j<n ; j++){
              if(lab[x][i]+lab[j][y]==cur){
                isValid=true ;
                break ;
              }
            }
            if(isValid){
              break ;
            }
          }
          if(! isValid){
            ans=false ;
            break ;
          }
        }
      }
      if(! ans){
        break ;
      }
    }
    System.out.println(ans ? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class okabeandfuturegadgetlaboratory {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fin : OclFile ; fin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (fin.readLine())->toInteger() ;
    var lab : Sequence(Sequence(int)) ; lab := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(fin.readLine()) ;
         var j : int ; j := 0 ; while j < n do ( (     lab[i+1][j+1] := (st.next())->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : boolean ; ans := true ;
        var x : int ; x := 0 ; while x < n do ( (         var y : int ; y := 0 ; while y < n do ( (     if (lab[x+1][y+1] /= 1) then (     var cur : int ; cur := lab[x+1][y+1] ;
     var isValid : boolean ; isValid := false ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (lab[x+1][i+1] + lab[j+1][y+1] = cur) then (     isValid := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (isValid) then (     break ) else skip )  ;     i := i + 1 ) ; 
     if (not(isValid)) then (     ans := false ; 
     break ) else skip ) else skip )  ;     y := y + 1 ) ; 
     if (not(ans)) then (     break ) else skip )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println(if ans then "Yes" else "No" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.awt.geom.Point2D ;
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  private void doit(){
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] data=new int[12];
      for(int i=0 ; i<12 ; i++){
        data[i]=sc.nextInt()-sc.nextInt();
      }
      int sum=0 ;
      boolean flg=false ;
      int ans=-1 ;
      for(int i=0 ; i<12 ; i++){
        sum+=data[i];
        if(sum>=n){
          ans=i+1 ;
          flg=true ;
          break ;
        }
      }
      if(flg){
        System.out.println(ans);
      }
      else {
        System.out.println("NA");
      }
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation doit() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var data : Sequence(int) ; data := Integer.subrange(1,12)->collect(0) ;
        var i : int ; i := 0 ; while i < 12 do ( (     data[i+1] := sc.getCurrent()->toInteger() - sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var flg : boolean ; flg := false ;
    var ans : int ; ans := -1 ;
        var i : int ; i := 0 ; while i < 12 do ( (     sum := sum+(data[i+1]) ; 
     if (sum >= n) then (     ans := i + 1 ; 
     flg := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flg) then (     OclFile["System.out"].println(ans) ) else (     OclFile["System.out"].println("NA") ) ;  
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testcases=1 ;
    for(int t=0 ; t<testcases ; ++t){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int a[]=new int[n];
      int b[]=new int[m];
      int be=0 ;
      int bo=0 ;
      int ae=0 ;
      int ao=0 ;
      for(int i=1 ; i<n+1 ; ++i){
        a[i-1]=sc.nextInt();
      }
      for(int i=1 ; i<m+1 ; ++i){
        b[i-1]=sc.nextInt();
      }
      for(int i=0 ; i<n ; ++i){
        if(a[i] % 2==0){
          ae++;
        }
        else {
          ao++;
        }
      }
      for(int i=0 ; i<m ; ++i){
        if(b[i] % 2==0){
          be++;
        }
        else {
          bo++;
        }
      }
      System.out.println(Math.min(ae,bo)+Math.min(ao,be));
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testcases : int ; testcases := 1 ;
         var t : int ; t := 0 ; while t < testcases do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
    var be : int ; be := 0 ;
    var bo : int ; bo := 0 ;
    var ae : int ; ae := 0 ;
    var ao : int ; ao := 0 ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     a[i - 1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < m + 1 do ( (     b[i - 1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] mod 2 = 0) then (     ae := ae + 1 ) else (     ao := ao + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     if (b[i+1] mod 2 = 0) then (     be := be + 1 ) else (     bo := bo + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{ae, bo}->min() + Set{ao, be}->min()) ; 
 )  ;     t := t + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class CF417B {
  public static void main(String[] args){
    int n=fs.nextInt();
    int[] participantToSubmissionId=new int[(int)(10e5+1)];
    for(int i=0 ; i<n ; i++){
      int x=fs.nextInt();
      int participantId=fs.nextInt();
      if(participantToSubmissionId[participantId]==x)participantToSubmissionId[participantId]++;
      else if(participantToSubmissionId[participantId]==x+1)continue ;
      else if(x>participantToSubmissionId[participantId]){
        System.out.println("NO");
        return ;
      }
    }
    System.out.println("YES");
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  static FastScanner fs=new FastScanner();
}
------------------------------------------------------------
OCL File:
---------
 class CF417B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := fs.nextInt() ;
     var participantToSubmissionId : Sequence(int) ; participantToSubmissionId := Integer.subrange(1,(10e5 + 1)->oclAsType(int))->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := fs.nextInt() ;
     var participantId : int ; participantId := fs.nextInt() ;
     if (participantToSubmissionId[participantId+1] = x) then     participantToSubmissionId[participantId+1] := participantToSubmissionId[participantId+1] + 1 ; else     if (participantToSubmissionId[participantId+1] = x + 1) then     continue else     if (x > participantToSubmissionId[participantId+1]) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; ;  )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("YES") );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   attribute fs : FastScanner := FastScanner.newFastScanner();
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Program {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),m[]=new int[100001];
    for(int i=0 ; i<n ; i++){
      int x=in.nextInt(),k=in.nextInt();
      if(m[k]<x){
        System.out.println("NO");
        return ;
      }
      else if(m[k]==x)m[k]++;
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Program {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : Sequence(void) ; m := Integer.subrange(1,100001)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
     if (m[k+1] < x) then (     OclFile["System.out"].println("NO") ; 
     return ) else     if (m[k+1] = x) then     m[k+1] := m[k+1] + 1 ; else skip ; )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("YES") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B417 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int[] stat=new int[100001];
    boolean ok=true ;
    for(int n=0 ; n<N ; n++){
      int x=in.nextInt();
      int k=in.nextInt();
      int seen=stat[k];
      if(seen<x){
        ok=false ;
      }
      else if(seen==x){
        stat[k]++;
      }
    }
    System.out.println(ok ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class B417 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var stat : Sequence(int) ; stat := Integer.subrange(1,100001)->collect(0) ;
    var ok : boolean ; ok := true ;
        var n : int ; n := 0 ; while n < N do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
     var seen : int ; seen := stat[k+1] ;
     if (seen < x) then (     ok := false ) else     if (seen = x) then (     stat[k+1] := stat[k+1] + 1 ) else skip ; )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(if ok then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long powermod(long x,long y,long p){
    long res=1 ;
    x=x % p ;
    while(y>0){
      if((y & 1L)>0)res=(res*x)% p ;
      y=y>>1L ;
      x=(x*x)% p ;
    }
    return res ;
  }
  static long modInverse(long a,long m){
    long m0=m,t,q ;
    long x0=0,x1=1 ;
    if(m==1)return 0 ;
    while(a>1){
      q=a/m ;
      t=m ;
      m=a % m ;
      a=t ;
      t=x0 ;
      x0=x1-q*x0 ;
      x1=t ;
    }
    if(x1<0)x1+=m0 ;
    return x1 ;
  }
  static long evaluteExpression(long n){
    long firstsum=0,mod=10 ;
    for(long i=2,j=0 ; (1L<<j)<=n ; i*=i,++j)firstsum=(firstsum+i)% mod ;
    long secondsum=(powermod(4L,n+1,mod)-1)*modInverse(3L,mod);
    return(firstsum*secondsum)% mod ;
  }
  public static void main(String[] args){
    long n=3 ;
    System.out.println(evaluteExpression(n));
    n=10 ;
    System.out.println(evaluteExpression(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation powermod( x : long, y : long, p : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     if ((y & 1L) > 0) then     res := (res * x) mod p ; else skip ; 
     y := (y/(2->pow(1L)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res );
  static   operation modInverse( a : long, m : long) : long
  pre: true
  post: true
  activity: (     var m0 : long ; m0 := m ;
    var t : long ;
    var q : long ;
     var x0 : long ; x0 := 0 ;
    var x1 : long ; x1 := 1 ;
    if (m = 1) then     return 0 else skip ; 
    while (a > 1) do (     q := a / m ; 
     t := m ; 
    m := a mod m ; 
    a := t ; 
    t := x0 ; 
    x0 := x1 - q * x0 ; 
    x1 := t ; 
 ) ; 
    if (x1 < 0) then     x1 := x1+(m0) ; else skip ; 
    return x1 
 );
  static   operation evaluteExpression( n : long) : long
  pre: true
  post: true
  activity: (     var firstsum : long ; firstsum := 0 ;
    var mod : long ; mod := 10 ;
         var i : long ; i := 2 ;
    var j : long ; j := 0 ; while ((1L*(2->pow(j)))->oclAsType(long)) <= n do (     firstsum := (firstsum + i) mod mod ;  ;     i := i*(i) ;     j := j + 1 ) ; 
     var secondsum : long ; secondsum := (powermod(4L, n + 1, mod) - 1) * modInverse(3L, mod) ;
     return (firstsum * secondsum) mod mod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 3 ;
     OclFile["System.out"].println(evaluteExpression(n)) ; 
     n := 10 ; 
     OclFile["System.out"].println(evaluteExpression(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static HashMap<Integer,Integer>hm=new HashMap<Integer,Integer>();
  static void countFreq(int a[],int n){
    for(int i=0 ; i<n ; i++)if(hm.containsKey(a[i]))hm.put(a[i],hm.get(a[i])+1);
    else hm.put(a[i],1);
  }
  static int query(int x){
    if(hm.containsKey(x))return hm.get(x);
    return 0 ;
  }
  public static void main(String[] args){
    int a[]={
      1,3,2,4,2,1 };
      int n=a.length ;
      countFreq(a,n);
      System.out.println(query(2));
      System.out.println(query(3));
      System.out.println(query(5));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute hm : Map(int,int) := Map{};
  static   operation countFreq( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     if (hm->keys()->includes(a[i+1])) then     hm := hm->union(Map{a[i+1] |-> hm->at(a[i+1]) + 1}) else     hm := hm->union(Map{a[i+1] |-> 1}) ; ;   ;     i := i + 1 ) );
  static   operation query( x : int) : int
  pre: true
  post: true
  activity: (     if (hm->keys()->includes(x)) then     return hm->at(x) else skip ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,3,2,4,2,1} ;
     var n : int ; n := a->size() ;
    execute countFreq(a, n) ; 
    OclFile["System.out"].println(query(2)) ; 
    OclFile["System.out"].println(query(3)) ; 
    OclFile["System.out"].println(query(5)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxN=10 ;
  static int[] fact=new int[maxN];
  static int ncr(int n,int r){
    return(fact[n]/fact[r])/fact[n-r];
  }
  static int findSum(int[] arr,int n){
    fact[0]=1 ;
    for(int i=1 ; i<n ; i++)fact[i]=i*fact[i-1];
    int mul=0 ;
    for(int i=0 ; i<=n-1 ; i++)mul+=(int)Math.pow(2,i)*ncr(n-1,i);
    int ans=0 ;
    for(int i=0 ; i<n ; i++)ans+=mul*arr[i];
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      1,1 };
      int n=arr.length ;
      System.out.println(findSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute maxN : int := 10;
  static   attribute fact : Sequence(int) := Integer.subrange(1,maxN)->collect(0);
  static   operation ncr( n : int, r : int) : int
  pre: true
  post: true
  activity: (     return (fact[n+1] / fact[r+1]) / fact[n - r+1] );
  static   operation findSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     fact[0+1] := 1 ; 
         var i : int ; i := 1 ; while i < n do (     fact[i+1] := i * fact[i - 1+1] ;  ;     i := i + 1 ) ; 
    var mul : int ; mul := 0 ;
        var i : int ; i := 0 ; while i <= n - 1 do (     mul := mul+(2->pow(i)->oclAsType(int) * ncr(n - 1, i)) ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do (     ans := ans+(mul * arr[i+1]) ;  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findSum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sumDigits(int n){
    int sum=0 ;
    while(n>0){
      int digit=n % 10 ;
      sum+=digit ;
      n/=10 ;
    }
    return sum ;
  }
  static boolean isDivBySix(String str,int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=(int)(str.charAt(i)-'a'+1);
    }
    if(sum % 3!=0)return false ;
    int lastDigit=((int)(str.charAt(n-1)-'a'+1))% 10 ;
    if(lastDigit % 2!=0)return false ;
    return true ;
  }
  public static void main(String[] args){
    String str="ab" ;
    int n=str.length();
    if(isDivBySix(str,n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumDigits( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n > 0) do (     var digit : int ; digit := n mod 10 ;
     sum := sum+(digit) ; 
     n := n/(10) ) ; 
     return sum );
  static   operation isDivBySix( str : String, n : int) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+((str->at(i+1) - ('a')->char2byte() + 1)->oclAsType(int)) )  ;     i := i + 1 ) ; 
    if (sum mod 3 /= 0) then     return false else skip ; 
    var lastDigit : int ; lastDigit := ((str->at(n - 1+1) - ('a')->char2byte() + 1)->oclAsType(int)) mod 10 ;
    if (lastDigit mod 2 /= 0) then     return false else skip ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "ab" ;
     var n : int ; n := str->size() ;
     if (isDivBySix(str, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long product(int[][] mat,int n){
    long d1=0,d2=0 ;
    for(int i=0 ; i<n ; i++){
      d1+=mat[i][i];
      d2+=mat[i][n-i-1];
    }
    return 1L*d1*d2 ;
  }
  public static void main(String[] args){
    int[][] mat={
      {
        5,8,1 },{
          5,10,3 },{
-6,17,-9 }
          };
          int n=mat.length ;
          System.out.print(product(mat,n));
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation product( mat : Sequence(Sequence(int)), n : int) : long
  pre: true
  post: true
  activity: (     var d1 : long ; d1 := 0 ;
    var d2 : long ; d2 := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     d1 := d1+(mat[i+1][i+1]) ; 
     d2 := d2+(mat[i+1][n - i - 1+1]) )  ;     i := i + 1 ) ; 
     return 1L * d1 * d2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{5,8,1},Sequence{5,10,3},Sequence{-6,17,-9}} ;
     var n : int ; n := mat->size() ;
     OclFile["System.out"].print(product(mat, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class gfg {
  int find(String s){
    int max=0,i,j=0,countk=0,countr=0 ;
    int table[][]=new int[s.length()][2];
    for(i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='R')countr++;
      else table[j++][0]=countr ;
    }
    j--;
    for(i=s.length()-1 ; i>=0 ; i--){
      if(s.charAt(i)=='K'){
        countk++;
        table[j--][1]=countk ;
      }
      if(Math.min(table[j+1][0],table[j+1][1])>max)max=Math.min(table[j+1][0],table[j+1][1]);
    }
    return max ;
  }
  public static void main(String srgs[]){
    String s="RKRRRKKRRKKKKRR" ;
    gfg ob=new gfg();
    int n=ob.find(s);
    System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class gfg {
   operation find( s : String) : int
  pre: true
  post: true
  activity: (     var max : int ; max := 0 ;
    var i : int ;
    var j : int ; j := 0 ;
    var countk : int ; countk := 0 ;
    var countr : int ; countr := 0 ;
     var table : Sequence(Sequence(int)) ; table := Integer.subrange(1,s->size())->collect(Integer.subrange(1,2)->collect(0)) ;
        i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'R') then     countr := countr + 1 ; else      table[j+1][0+1] := countr  ; j := j + 1 ; )  ;     i := i + 1 ) ; 
    j := j - 1 ; 
        i := s->size() - 1 ; while i >= 0 do ( (     if (s->at(i+1) = 'K') then (     countk := countk + 1 ; 
      table[j+1][1+1] := countk  ; j := j - 1 ) else skip ; 
     if (Set{table[j + 1+1][0+1], table[j + 1+1][1+1]}->min() > max) then     max := Set{table[j + 1+1][0+1], table[j + 1+1][1+1]}->min() ; else skip )  ;     i := i - 1 ) ; 
    return max 
 );
  static   operation main( srgs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "RKRRRKKRRKKKKRR" ;
     var ob : gfg ; ob := gfg.newgfg() ;
     var n : int ; n := ob.find(s) ;
     OclFile["System.out"].println(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.System.*;
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      boolean F=false ;
      int saving=0 ;
      int[] a=new int[12],b=new int[12];
      for(int i=0 ; i<12 ; i++){
        a[i]=sc.nextInt();
        b[i]=sc.nextInt();
      }
      for(int i=0 ; i<12 ; i++){
        saving+=a[i]-b[i];
        if(saving>=n){
          out.println(i+1);
          F=true ;
          break ;
        }
      }
      if(! F)out.println("NA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var F : boolean ; F := false ;
    var saving : int ; saving := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,12)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,12)->collect(0) ;
        var i : int ; i := 0 ; while i < 12 do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 12 do ( (     saving := saving+(a[i+1] - b[i+1]) ; 
     if (saving >= n) then (     out.println(i + 1) ; 
     F := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (not(F)) then     out.println("NA") ; else skip ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
public class GFG {
  static int cost(int[] a,int n){
    int min=a[0];
    for(int i=1 ; i<a.length ; i++){
      if(a[i]<min)min=a[i];
    }
    return(n-1)*min ;
  }
  static public void main(String[] args){
    int[] a={
      4,3,2 };
      int n=a.length ;
      System.out.println(cost(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation cost( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var min : int ; min := a[0+1] ;
         var i : int ; i := 1 ; while i < a->size() do ( (     if (a[i+1] < min) then     min := a[i+1] ; else skip )  ;     i := i + 1 ) ; 
     return (n - 1) * min );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{4,3,2} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(cost(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[][] red=new int[n][2];
    int[][] blue=new int[n][2];
    for(int i=0 ; i<n ; i++){
      red[i][0]=sc.nextInt();
      red[i][1]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      blue[i][0]=sc.nextInt();
      blue[i][1]=sc.nextInt();
    }
    Arrays.sort(red,(a,b)->Integer.compare(a[0],b[0]));
    Arrays.sort(blue,(a,b)->Integer.compare(a[0],b[0]));
    NavigableSet<int[]>set=new TreeSet<>((a,b)->Integer.compare(a[1],b[1]));
    int ri=0 ;
    int answer=0 ;
    for(int bi=0 ; bi<n ; bi++){
      while(ri<n && red[ri][0]<blue[bi][0]){
        set.add(red[ri++]);
      }
      if(set.isEmpty())continue ;
      int[] x=set.lower(blue[bi]);
      if(x==null)continue ;
      set.remove(x);
      answer++;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var red : Sequence(Sequence(int)) ; red := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
    var blue : Sequence(Sequence(int)) ; blue := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     red[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     red[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     blue[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     blue[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    red := OclComparator.sortWith(red, lambda (a , b) : OclAny in compare(a[0+1], b[0+1])) ; 
    blue := OclComparator.sortWith(blue, lambda (a , b) : OclAny in compare(a[0+1], b[0+1])) ; 
    var set : NavigableSet<Sequence(int)> ; set := Set{}->union(lambda (a , b) : OclAny in compare(a[1+1], b[1+1])) ;
    var ri : int ; ri := 0 ;
    var answer : int ; answer := 0 ;
        var bi : int ; bi := 0 ; while bi < n do ( (     while (ri < n & red[ri+1][0+1] < blue[bi+1][0+1]) do (     set->excludes(red[ri+1]) ) ; 
     if (set->isEmpty()) then     continue else skip ; 
    var x : Sequence(int) ; x := set.lower(blue[bi+1]) ;
    if (x = null) then     continue else skip ; 
    set := set->excludingFirst(x) ; 
    answer := answer + 1 ; 
 )  ;     bi := bi + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int N=4 ;
  static int areSame(int A[][],int B[][]){
    int i,j ;
    for(i=0 ; i<N ; i++)for(j=0 ; j<N ; j++)if(A[i][j]!=B[i][j])return 0 ;
    return 1 ;
  }
  public static void main(String[] args){
    int A[][]={
      {
        1,1,1,1 },{
          2,2,2,2 },{
            3,3,3,3 },{
              4,4,4,4 }
            };
            int B[][]={
              {
                1,1,1,1 },{
                  2,2,2,2 },{
                    3,3,3,3 },{
                      4,4,4,4 }
                    };
                    if(areSame(A,B)==1)System.out.print("Matrices are identical");
                    else System.out.print("Matrices are not identical");
                  }
                }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute N : int := 4;
  static   operation areSame( A : Sequence(Sequence(int)), B : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := 0 ; while i < N do (         j := 0 ; while j < N do (     if (A[i+1][j+1] /= B[i+1][j+1]) then     return 0 else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(Sequence(int)) ; A := Sequence{Sequence{1,1,1,1},Sequence{2,2,2,2},Sequence{3,3,3,3},Sequence{4,4,4,4}} ;
     var B : Sequence(Sequence(int)) ; B := Sequence{Sequence{1,1,1,1},Sequence{2,2,2,2},Sequence{3,3,3,3},Sequence{4,4,4,4}} ;
     if (areSame(A, B) = 1) then     OclFile["System.out"].print("Matrices are identical") ; else     OclFile["System.out"].print("Matrices are not identical") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void ReplaceElements(int arr[],int n){
    int X=0 ;
    for(int i=0 ; i<n ; ++i){
      X ^=arr[i];
    }
    for(int i=0 ; i<n ; ++i){
      arr[i]=X ^ arr[i];
    }
  }
  public static void main(String[] args){
    int arr[]={
      2,3,3,5,5 };
      int n=arr.length ;
      ReplaceElements(arr,n);
      for(int i=0 ; i<n ; ++i){
        System.out.print(arr[i]+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation ReplaceElements( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     X := MathLib.bitwiseXor(X,arr[i+1]) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := MathLib.bitwiseXor(X,arr[i+1]) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,3,5,5} ;
     var n : int ; n := arr->size() ;
     execute ReplaceElements(arr, n) ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class pair {
    int first,second ;
    public pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static pair getMaxandMinProduct(int arr[],int n){
    int curMaxProduct=arr[0];
    int curMinProduct=arr[0];
    int prevMaxProduct=arr[0];
    int prevMinProduct=arr[0];
    int maxProduct=arr[0];
    int minProduct=arr[0];
    for(int i=1 ; i<n ; ++i){
      curMaxProduct=Math.max(prevMaxProduct*arr[i],Math.max(prevMinProduct*arr[i],arr[i]));
      curMaxProduct=Math.max(curMaxProduct,prevMaxProduct);
      curMinProduct=Math.min(prevMaxProduct*arr[i],Math.min(prevMinProduct*arr[i],arr[i]));
      curMinProduct=Math.min(curMinProduct,prevMinProduct);
      maxProduct=Math.max(maxProduct,curMaxProduct);
      minProduct=Math.min(minProduct,curMinProduct);
      prevMaxProduct=curMaxProduct ;
      prevMinProduct=curMinProduct ;
    }
    return new pair(minProduct,maxProduct);
  }
  public static void main(String[] args){
    int arr[]={
-4,-2,3,7,5,0,1 };
      int n=arr.length ;
      pair product=getMaxandMinProduct(arr,n);
      System.out.printf("Minimum product is %d and "+"Maximum product is %d",product.first,product.second);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static class pair {
   attribute first : int;
   static operation newpair( first : int, second : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation getMaxandMinProduct( arr : Sequence(int), n : int) : pair
  pre: true
  post: true
  activity: (     var curMaxProduct : int ; curMaxProduct := arr[0+1] ;
     var curMinProduct : int ; curMinProduct := arr[0+1] ;
    var prevMaxProduct : int ; prevMaxProduct := arr[0+1] ;
    var prevMinProduct : int ; prevMinProduct := arr[0+1] ;
    var maxProduct : int ; maxProduct := arr[0+1] ;
    var minProduct : int ; minProduct := arr[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     curMaxProduct := Set{prevMaxProduct * arr[i+1], Set{prevMinProduct * arr[i+1], arr[i+1]}->max()}->max() ; 
     curMaxProduct := Set{curMaxProduct, prevMaxProduct}->max() ; 
    curMinProduct := Set{prevMaxProduct * arr[i+1], Set{prevMinProduct * arr[i+1], arr[i+1]}->min()}->min() ; 
    curMinProduct := Set{curMinProduct, prevMinProduct}->min() ; 
    maxProduct := Set{maxProduct, curMaxProduct}->max() ; 
    minProduct := Set{minProduct, curMinProduct}->min() ; 
    prevMaxProduct := curMaxProduct ; 
    prevMinProduct := curMinProduct ; 
 )  ;     i := i + 1 ) ; 
    return pair.newpair(minProduct, maxProduct) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-4,-2,3,7,5,0,1} ;
     var n : int ; n := arr->size() ;
     var product : pair ; product := getMaxandMinProduct(arr, n) ;
     OclFile["System.out"].printf("Minimum product is %d and " + "Maximum product is %d", product->at("first"), product->at("second")) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
class GFG {
  public static boolean isPrime(int n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  public static int primorial(int n){
    int p=2 ;
    n--;
    for(int i=3 ; n!=0 ; i++){
      if(isPrime(i)==true){
        p=p*i ;
        n--;
      }
      i++;
    }
    return p ;
  }
  public static int findNextPrime(int n){
    int nextPrime=n+2 ;
    while(true){
      if(isPrime(nextPrime)==true)break ;
      nextPrime++;
    }
    return nextPrime ;
  }
  public static int fortunateNumber(int n){
    int p=primorial(n);
    return findNextPrime(p)-p ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(fortunateNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation primorial( n : int) : int
  pre: true
  post: true
  activity: (     var p : int ; p := 2 ;
     n := n - 1 ; 
         var i : int ; i := 3 ; while n /= 0 do ( (     if (isPrime(i) = true) then (     p := p * i ; 
     n := n - 1 ) else skip ; 
     i := i + 1 )  ;     i := i + 1 ) ; 
     return p );
  static   operation findNextPrime( n : int) : int
  pre: true
  post: true
  activity: (     var nextPrime : int ; nextPrime := n + 2 ;
     while (true) do (     if (isPrime(nextPrime) = true) then     break else skip ; 
     nextPrime := nextPrime + 1 ) ; 
     return nextPrime );
  static   operation fortunateNumber( n : int) : int
  pre: true
  post: true
  activity: (     var p : int ; p := primorial(n) ;
     return findNextPrime(p) - p );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(fortunateNumber(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Code {
  static long idx ;
  static long cnt ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long l=sc.nextLong();
    long r=sc.nextLong();
    System.out.println(util(n,r)-util(n,l-1));
  }
  public static long util(long n,long x){
    if(x==0 || n==0){
      return 0 ;
    }
    if(n==1){
      return 1 ;
    }
    if(x<=(long)Math.pow(2,len(n/2))-1){
      return util(n/2,x);
    }
    if(x==(long)Math.pow(2,len(n/2))-1+1){
      return(n/2)+(n % 2);
    }
    return(n/2)+(n % 2)+util(n/2,x-((long)Math.pow(2,len(n/2))-1)-1);
  }
  public static int len(long n){
    int l=0 ;
    while(n>0){
      n/=2 ;
      l++;
    }
    return l ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code {
  static   attribute idx : long;
  static   attribute cnt : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var l : long ; l := sc.getCurrent()->toLong() ;
    var r : long ; r := sc.getCurrent()->toLong() ;
    OclFile["System.out"].println(util(n, r) - util(n, l - 1)) ; 
 );
  static   operation util( n : long, x : long) : long
  pre: true
  post: true
  activity: (     if (x = 0 or n = 0) then (     return 0 ) else skip ; 
     if (n = 1) then (     return 1 ) else skip ; 
    if (x <= 2->pow(len(n / 2))->oclAsType(long) - 1) then (     return util(n / 2, x) ) else skip ; 
    if (x = 2->pow(len(n / 2))->oclAsType(long) - 1 + 1) then (     return (n / 2) + (n mod 2) ) else skip ; 
    return (n / 2) + (n mod 2) + util(n / 2, x - (2->pow(len(n / 2))->oclAsType(long) - 1) - 1) 
 );
  static   operation len( n : long) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
     while (n > 0) do (     n := n/(2) ; 
     l := l + 1 ) ; 
     return l );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.io.BufferedOutputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Sample {
  private static final Scanner sc=new Scanner(new BufferedInputStream(System.in));
  private static final PrintWriter pw=new PrintWriter(new BufferedOutputStream(System.out),true);
  private static StringBuffer ans=new StringBuffer();
  public static void main(String[] args)throws Exception {
    long n=sc.nextLong(),cnt=0L,l=sc.nextLong(),r=sc.nextLong();
    char[] a=Long.toBinaryString(n).toCharArray();
    for(long i=l ; i<=r ; i++){
      for(int j=0 ; j<32 ; j++){
        if((i &(1<<j))!=0){
          if(a[j]=='1')cnt++;
          break ;
        }
      }
    }
    ans.append(cnt);
    pw.print(ans);
    sc.close();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sample {
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static    attribute pw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]), true);
  static   attribute ans : String := StringLib.newString();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.getCurrent()->toLong() ;
    var cnt : long ; cnt := 0L ;
    var l : long ; l := sc.getCurrent()->toLong() ;
    var r : long ; r := sc.getCurrent()->toLong() ;
     var a : Sequence(String) ; a := (MathLib.decimal2binary(n) + "")->characters() ;
        var i : long ; i := l ; while i <= r do ( (         var j : int ; j := 0 ; while j < 32 do ( (     if ((MathLib.bitwiseAnd(i,((1*(2->pow(j)))->oclAsType(long)))) /= 0) then (     if (a[j+1] = '1') then     cnt := cnt + 1 ; else skip ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    ans := ans + StringLib.newString(cnt) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Ideone {
  private static long getTotalLength(long n){
    if(n==1)return 1 ;
    return getTotalLength(n/2)*2+1 ;
  }
  private static long getTotalOnes(long n){
    if(n==1)return 1 ;
    return getTotalOnes(n/2)*2+n % 2 ;
  }
  private static long getOnes(long n,long l,long r){
    if(r<l)return 0 ;
    if(n==1)return 1 ;
    long left=getTotalLength(n/2);
    if(l==1 &&(r==left || r==left+1)){
      long ans=getTotalOnes(n/2)+(r==left+1 ? n % 2 : 0);
      return ans ;
    }
    long ans=0 ;
    if(Math.min(left,r)>=l)ans+=getOnes(n/2,l,Math.min(left,r));
    ans+=(r>=left+1 && l<=left+1 ? n % 2 : 0);
    if(r-left-1>=Math.max(1,l-left-1))ans+=getOnes(n/2,Math.max(1,l-left-1),r-left-1);
    return ans ;
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    String arr[]=reader.readLine().split(" ");
    long n=Long.parseLong(arr[0]);
    long l=Long.parseLong(arr[1]);
    long r=Long.parseLong(arr[2]);
    if(n<2){
      System.out.println(n);
    }
    else {
      System.out.println(getOnes(n,l,r));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ideone {
  static   operation getTotalLength( n : long) : long
  pre: true
  post: true
  activity: (     if (n = 1) then     return 1 else skip ; 
     return getTotalLength(n / 2) * 2 + 1 );
  static   operation getTotalOnes( n : long) : long
  pre: true
  post: true
  activity: (     if (n = 1) then     return 1 else skip ; 
     return getTotalOnes(n / 2) * 2 + n mod 2 );
  static   operation getOnes( n : long, l : long, r : long) : long
  pre: true
  post: true
  activity: (     if (r < l) then     return 0 else skip ; 
     if (n = 1) then     return 1 else skip ; 
    var left : long ; left := getTotalLength(n / 2) ;
    if (l = 1 & (r = left or r = left + 1)) then (     var ans : long ; ans := getTotalOnes(n / 2) + (if r = left + 1 then n mod 2 else 0 endif) ;
     return ans ) else skip ; 
    var ans : long ; ans := 0 ;
    if (Set{left, r}->min() >= l) then     ans := ans+(getOnes(n / 2, l, Set{left, r}->min())) ; else skip ; 
    ans := ans+((if r >= left + 1 & l <= left + 1 then n mod 2 else 0 endif)) ; 
    if (r - left - 1 >= Set{1, l - left - 1}->max()) then     ans := ans+(getOnes(n / 2, Set{1, l - left - 1}->max(), r - left - 1)) ; else skip ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var arr : Sequence(String) ; arr := reader.readLine()->split(" ") ;
    var n : long ; n := (arr[0+1])->toLong() ;
    var l : long ; l := (arr[1+1])->toLong() ;
    var r : long ; r := (arr[2+1])->toLong() ;
    if (n < 2) then (     OclFile["System.out"].println(n) ) else (     OclFile["System.out"].println(getOnes(n, l, r)) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CodeForOne {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long l=sc.nextLong();
    long r=sc.nextLong();
    System.out.println(util(n,r)-util(n,l-1));
  }
  public static long util(long n,long x){
    if(x==0 || n==0){
      return 0 ;
    }
    if(n==1){
      return 1 ;
    }
    if(x<=len(n/2)){
      return util(n/2,x);
    }
    if(x==len(n/2)+1){
      return(n/2)+(n % 2);
    }
    return(n/2)+(n % 2)+util(n/2,x-len(n/2)-1);
  }
  public static long len(long n){
    long bits=numberOfBits(n);
    return(long)Math.pow(2,bits)-(long)1 ;
  }
  public static long numberOfBits(long n){
    long l=0 ;
    while(n>0){
      n/=2 ;
      l++;
    }
    return l ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForOne {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var l : long ; l := sc.getCurrent()->toLong() ;
    var r : long ; r := sc.getCurrent()->toLong() ;
    OclFile["System.out"].println(util(n, r) - util(n, l - 1)) ; 
 );
  static   operation util( n : long, x : long) : long
  pre: true
  post: true
  activity: (     if (x = 0 or n = 0) then (     return 0 ) else skip ; 
     if (n = 1) then (     return 1 ) else skip ; 
    if (x <= len(n / 2)) then (     return util(n / 2, x) ) else skip ; 
    if (x = len(n / 2) + 1) then (     return (n / 2) + (n mod 2) ) else skip ; 
    return (n / 2) + (n mod 2) + util(n / 2, x - len(n / 2) - 1) 
 );
  static   operation len( n : long) : long
  pre: true
  post: true
  activity: (     var bits : long ; bits := numberOfBits(n) ;
     return 2->pow(bits)->oclAsType(long) - 1->oclAsType(long) );
  static   operation numberOfBits( n : long) : long
  pre: true
  post: true
  activity: (     var l : long ; l := 0 ;
     while (n > 0) do (     n := n/(2) ; 
     l := l + 1 ) ; 
     return l );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      StringBuilder stringBuilder=new StringBuilder();
      final int term=12 ;
      String line ;
      while((line=br.readLine())!=null){
        if(line.equals("0")){
          break ;
        }
        int goal=Integer.parseInt(line);
        int totalAmount=0 ;
        String progressMonth="" ;
        for(int i=0 ; i<term ; i++){
          String[] dataSet=br.readLine().split(" ");
          if(goal>totalAmount){
            totalAmount=calculate(dataSet,totalAmount);
            progressMonth=check(i,goal,totalAmount);
          }
        }
        stringBuilder.append(progressMonth+"\n");
      }
      System.out.print(stringBuilder);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  private static int calculate(String[] dataSet,int totalAmount){
    int income=Integer.parseInt(dataSet[0]);
    int outcome=Integer.parseInt(dataSet[1]);
    totalAmount+=(income-outcome);
    return totalAmount ;
  }
  private static String check(int progressMonth,int goal,int totalAmount){
    if(goal<=totalAmount){
      return String.valueOf(progressMonth+1);
    }
    return "NA" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var stringBuilder : String ; stringBuilder := StringLib.newString() ;
    var term : int ; term := 12 ;
    var line : String ;
        line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line = "0") then (     break ) else skip ; 
     var goal : int ; goal := (line)->toInteger() ;
    var totalAmount : int ; totalAmount := 0 ;
    var progressMonth : String ; progressMonth := "" ;
        var i : int ; i := 0 ; while i < term do ( (     var dataSet : Sequence(String) ; dataSet := br.readLine()->split(" ") ;
     if (goal > totalAmount) then (     totalAmount := calculate(dataSet, totalAmount) ; 
     progressMonth := check(i, goal, totalAmount) ) else skip )  ;     i := i + 1 ) ; 
    stringBuilder := stringBuilder + StringLib.newString(progressMonth + "\n") ; 
 ) ;     line := br.readLine() ;
 ) ;  
    OclFile["System.out"].print(stringBuilder) ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
  static   operation calculate( dataSet : Sequence(String), totalAmount : int) : int
  pre: true
  post: true
  activity: (     var income : int ; income := (dataSet[0+1])->toInteger() ;
     var outcome : int ; outcome := (dataSet[1+1])->toInteger() ;
     totalAmount := totalAmount+((income - outcome)) ; 
     return totalAmount );
  static   operation check( progressMonth : int, goal : int, totalAmount : int) : String
  pre: true
  post: true
  activity: (     if (goal <= totalAmount) then (     return ((progressMonth + 1) + "") ) else skip ; 
     return "NA" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findMaxFrequency(String s){
    int arr[]=new int[26];
    for(int i=0 ; i<s.length(); i++)arr[s.charAt(i)-'a']++;
    HashMap<Integer,Integer>hash=new HashMap<Integer,Integer>();
    for(int i=0 ; i<26 ; i++)if(arr[i]!=0){
      if(hash.containsKey(arr[i])){
        hash.put(arr[i],hash.get(arr[i])+1);
      }
      else {
        hash.put(arr[i],1);
      }
    }
    int max_count=0,res=-1 ;
    for(Map.Entry<Integer,Integer>i : hash.entrySet()){
      if(max_count<i.getValue()){
        res=i.getKey();
        max_count=i.getValue();
      }
    }
    System.out.println("Frequency "+res+" is repeated "+max_count+" times");
  }
  public static void main(String[] args){
    String s="geeksgeeks" ;
    findMaxFrequency(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMaxFrequency( s : String) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,26)->collect(0) ;
         var i : int ; i := 0 ; while i < s->size() do (     arr[s->at(i+1) - ('a')->char2byte()+1] := arr[s->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    var hash : Map(int,int) ; hash := Map{} ;
        var i : int ; i := 0 ; while i < 26 do (     if (arr[i+1] /= 0) then (     if (hash->keys()->includes(arr[i+1])) then (     hash := hash->union(Map{arr[i+1] |-> hash->at(arr[i+1]) + 1}) ) else (     hash := hash->union(Map{arr[i+1] |-> 1}) ) ) else skip ;  ;     i := i + 1 ) ; 
    var max_count : int ; max_count := 0 ;
    var res : int ; res := -1 ;
    for (i : hash->asSet()) do ( (     if (max_count < i.getValue()) then (     res := i.getKey() ; 
     max_count := i.getValue() ) else skip )  ) ; 
    OclFile["System.out"].println("Frequency " + res + " is repeated " + max_count + " times") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksgeeks" ;
     execute findMaxFrequency(s) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countSub(int arr[],int n){
    int count[]=new int[10];
    for(int i=0 ; i<n ; i++){
      for(int j=arr[i]-1 ; j>=0 ; j--)count[arr[i] ]+=count[j];
      count[arr[i] ]++;
    }
    int result=0 ;
    for(int i=0 ; i<10 ; i++)result+=count[i];
    return result ;
  }
  public static void main(String[] args){
    int arr[]={
      3,2,4,5,4 };
      int n=arr.length ;
      System.out.println(countSub(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSub( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,10)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := arr[i+1] - 1 ; while j >= 0 do (     count[arr[i+1]+1] := count[arr[i+1]+1]+(count[j+1]) ;  ;     j := j - 1 ) ; 
     count[arr[i+1]+1] := count[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < 10 do (     result := result+(count[i+1]) ;  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,2,4,5,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countSub(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Point>red=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      Point p=new Point(a,b);
      red.add(p);
    }
    List<Point>blue=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      Point p=new Point(a,b);
      blue.add(p);
    }
    red.sort((a,b)->a.a-b.a);
    blue.sort((a,b)->a.a-b.a);
    for(Point bp : blue){
      List<Point>possible=new ArrayList<>();
      for(Point rp : red){
        if(bp.a<rp.a)break ;
        if(bp.b>rp.b){
          possible.add(rp);
        }
      }
      possible.sort((a,b)->b.b-a.b);
      for(Point point : possible){
        if(point.paired){
          continue ;
        }
        else {
          point.paired=true ;
          break ;
        }
      }
    }
    long count=red.stream().filter(p->p.paired).count();
    System.out.println(count);
    sc.close();
  }
}
class Point {
  @ Override public String toString(){
    return "Point[a="+a+",b="+b+",paired="+paired+"] " ;
  }
  int a ;
  int b ;
  Boolean paired=false ;
  public Point(int a,int b){
    this.a=a ;
    this.b=b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var red : Sequence(Point) ; red := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     var p : Point ; p := Point.newPoint(a, b) ;
     red := red->including(p) )  ;     i := i + 1 ) ; 
    var blue : Sequence(Point) ; blue := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     var p : Point ; p := Point.newPoint(a, b) ;
     blue := blue->including(p) )  ;     i := i + 1 ) ; 
    red := red.sort(lambda (a , b) : OclAny in a.a - b.a) ; 
    blue := blue.sort(lambda (a , b) : OclAny in a.a - b.a) ; 
    for (bp : blue) do ( (     var possible : Sequence(Point) ; possible := Sequence{} ;
     for (rp : red) do ( (     if (bp.a < rp.a) then     break else skip ; 
     if (bp.b > rp.b) then (     possible := possible->including(rp) ) else skip )  ) ; 
     possible := possible.sort(lambda (a , b) : OclAny in b.b - a.b) ; 
     for (point : possible) do ( (     if (point.paired) then (     continue ) else (     point.paired := true ; 
     break ) )  ) )  ) ; 
    var count : long ; count := red->select( _x1 | (lambda p : OclAny in p.paired)->apply(_x1) )->size() ;
    OclFile["System.out"].println(count) ; 
    skip ; 
 );
}
class Point {
      operation toString() : String
  pre: true
  post: true
  activity: (     return "Point[a=" + a + ",b=" + b + ",paired=" + paired + "] " );
   attribute a : int;
   attribute b : int;
   attribute paired : Boolean := false;
   static operation newPoint( a : int, b : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static ArrayList<Integer>findingValues(int m,int n,int mth,int nth){
    int d=(Math.abs(mth-nth))/Math.abs((m-1)-(n-1));
    int a=mth-((m-1)*d);
    ArrayList<Integer>res=new ArrayList<Integer>();
    res.add(a);
    res.add(d);
    return res ;
  }
  static int findSum(int m,int n,int mth,int nth,int p){
    ArrayList<Integer>ad=findingValues(m,n,mth,nth);
    int a=ad.get(0);
    int d=ad.get(1);
    int sum=(p*(2*a+(p-1)*d))/2 ;
    return sum ;
  }
  public static void main(String[] args){
    int m=6,n=10,mTerm=12,nTerm=20,p=5 ;
    System.out.println(findSum(m,n,mTerm,nTerm,p));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findingValues( m : int, n : int, mth : int, nth : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var d : int ; d := (if mth - nth < 0 then -(mth - nth) else mth - nth endif) / if (m - 1) - (n - 1) < 0 then -((m - 1) - (n - 1)) else (m - 1) - (n - 1) endif ;
     var a : int ; a := mth - ((m - 1) * d) ;
    var res : Sequence(int) ; res := Sequence{} ;
    res := res->including(a) ; 
    res := res->including(d) ; 
    return res 
 );
  static   operation findSum( m : int, n : int, mth : int, nth : int, p : int) : int
  pre: true
  post: true
  activity: (     var ad : Sequence(int) ; ad := findingValues(m, n, mth, nth) ;
     var a : int ; a := ad->at(0+1) ;
    var d : int ; d := ad->at(1+1) ;
    var sum : int ; sum := (p * (2 * a + (p - 1) * d)) / 2 ;
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 6 ;
    var n : int ; n := 10 ;
    var mTerm : int ; mTerm := 12 ;
    var nTerm : int ; nTerm := 20 ;
    var p : int ; p := 5 ;
     OclFile["System.out"].println(findSum(m, n, mTerm, nTerm, p)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void count_unique(HashSet<Integer>s,int n){
    if(s.contains(n))return ;
    s.add(n);
    n+=1 ;
    while(n % 10==0){
      n=n/10 ;
    }
    count_unique(s,n);
  }
  public static void main(String[] args){
    int n=10 ;
    HashSet<Integer>s=new HashSet<>();
    count_unique(s,n);
    System.out.println(s.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count_unique( s : Set(int), n : int) : void
  pre: true
  post: true
  activity: (     if (s->includes(n)) then     return else skip ; 
     s->excludes(n) ; 
    n := n+(1) ; 
    while (n mod 10 = 0) do (     n := n / 10 ) ; 
    execute count_unique(s, n) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     var s : Set(int) ; s := Set{} ;
     execute count_unique(s, n) ; 
     OclFile["System.out"].println(s->size()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int mod=1000000007 ;
  static int noOfBinaryStrings(int N,int k){
    int dp[]=new int[100002];
    for(int i=1 ; i<=k-1 ; i++){
      dp[i]=1 ;
    }
    dp[k]=2 ;
    for(int i=k+1 ; i<=N ; i++){
      dp[i]=(dp[i-1]+dp[i-k])% mod ;
    }
    return dp[N];
  }
  public static void main(String[] args){
    int N=4 ;
    int K=2 ;
    System.out.println(noOfBinaryStrings(N,K));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute mod : int := 1000000007;
  static   operation noOfBinaryStrings( N : int, k : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,100002)->collect(0) ;
         var i : int ; i := 1 ; while i <= k - 1 do ( (     dp[i+1] := 1 )  ;     i := i + 1 ) ; 
    dp[k+1] := 2 ; 
        var i : int ; i := k + 1 ; while i <= N do ( (     dp[i+1] := (dp[i - 1+1] + dp[i - k+1]) mod mod )  ;     i := i + 1 ) ; 
    return dp[N+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     var K : int ; K := 2 ;
     OclFile["System.out"].println(noOfBinaryStrings(N, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B918 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),m=in.nextInt();
    Map<String,String>H=new HashMap<>();
    while(n-->0){
      String s=in.next(),ip=in.next();
      H.put(ip,s);
    }
    while(m-->0){
      String c=in.next(),ip=in.next().replace(";","");
      System.out.println(c+" "+ip+"; #"+H.get(ip));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B918 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var H : Map(String,String) ; H := Map{} ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var s : String ; s := in.getCurrent() ;
    var ip : String ; ip := in.getCurrent() ;
     H := H->union(Map{ip |-> s}) ) ;  ) ;  
        while (m > 0) do (        m := m - 1 ;     skip ; (     var c : String ; c := in.getCurrent() ;
    var ip : String ; ip := in.getCurrent().replace(";", "") ;
     OclFile["System.out"].println(c + " " + ip + "; #" + H->at(ip)) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class IpAddress {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    StringTokenizer st=new StringTokenizer(s.nextLine());
    int N=Integer.parseInt(st.nextToken());
    int M=Integer.parseInt(st.nextToken());
    HashMap<String,String>map=new HashMap<>();
    for(int i=0 ; i<N ; i++){
      st=new StringTokenizer(s.nextLine());
      String name=st.nextToken();
      String ip=st.nextToken();
      map.put(ip,name);
    }
    for(int i=0 ; i<M ; i++){
      String line=s.nextLine();
      st=new StringTokenizer(line);
      String command=st.nextToken();
      String ip=st.nextToken();
      ip=ip.substring(0,ip.length()-1);
      String name=map.get(ip);
      System.out.println(line+" #"+name);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class IpAddress {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(s.nextLine()) ;
    var N : int ; N := (st.next())->toInteger() ;
    var M : int ; M := (st.next())->toInteger() ;
    var map : Map(String,String) ; map := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     st := OclIterator.newOclIterator_String(s.nextLine()) ; 
     var name : String ; name := st.next() ;
     var ip : String ; ip := st.next() ;
     map := map->union(Map{ip |-> name}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var line : String ; line := s.nextLine() ;
     st := OclIterator.newOclIterator_String(line) ; 
    var command : String ; command := st.next() ;
    var ip : String ; ip := st.next() ;
    ip := ip.subrange(0+1,ip->size() - 1) ; 
    var name : String ; name := map->at(ip) ;
    OclFile["System.out"].println(line + " #" + name) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class completeSearch {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    String[][] a=new String[n][2];
    for(int j=0 ; j<a.length ; j++){
      a[j][0]=sc.next();
      a[j][1]=sc.next()+';' ;
    }
    String[][] b=new String[m][2];
    for(int j=0 ; j<b.length ; j++){
      b[j][0]=sc.next();
      b[j][1]=sc.next();
    }
    for(int j=0 ; j<b.length ; j++){
      for(int k=0 ; k<a.length ; k++){
        if(b[j][1] .equals(a[k][1])){
          System.out.println(b[j][0]+" "+b[j][1]+"  #"+a[k][0]);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class completeSearch {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(null)) ;
        var j : int ; j := 0 ; while j < a->size() do ( (     a[j+1][0+1] := sc.getCurrent() ; 
     a[j+1][1+1] := sc.getCurrent() + ';' )  ;     j := j + 1 ) ; 
    var b : Sequence(Sequence(String)) ; b := Integer.subrange(1,m)->collect(Integer.subrange(1,2)->collect(null)) ;
        var j : int ; j := 0 ; while j < b->size() do ( (     b[j+1][0+1] := sc.getCurrent() ; 
     b[j+1][1+1] := sc.getCurrent() )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < b->size() do ( (         var k : int ; k := 0 ; while k < a->size() do ( (     if (b[j+1][1+1] = a[k+1][1+1]) then (     OclFile["System.out"].println(b[j+1][0+1] + " " + b[j+1][1+1] + "  #" + a[k+1][0+1]) ; 
     break ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    FastReader fr=new FastReader();
    HashMap<String,String>mp=new HashMap<>();
    int n=fr.nextInt();
    int m=fr.nextInt();
    String s,s2 ;
    while(n-->0){
      s=fr.next();
      s2=fr.next();
      mp.put(s2,s);
    }
    while(m-->0){
      s=fr.next();
      s2=fr.next();
      System.out.println(s+" "+s2+" #"+mp.get(s2.substring(0,s2.length()-1)));
    }
  }
}
class FastReader {
  BufferedReader bf ;
  StringTokenizer st ;
  public FastReader(){
    bf=new BufferedReader(new InputStreamReader(System.in));
  }
  public String nextLine(){
    String st="" ;
    try {
      st=bf.readLine();
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return st ;
  }
  public String next(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(bf.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
    }
    return st.nextToken();
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fr : FastReader ; fr := FastReader.newFastReader() ;
     var mp : Map(String,String) ; mp := Map{} ;
    var n : int ; n := fr.nextInt() ;
    var m : int ; m := fr.nextInt() ;
    var s : String ;
    var s2 : String ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     s := fr.next() ; 
     s2 := fr.next() ; 
     mp := mp->union(Map{s2 |-> s}) ) ;  ) ;  
        while (m > 0) do (        m := m - 1 ;     skip ; (     s := fr.next() ; 
     s2 := fr.next() ; 
     OclFile["System.out"].println(s + " " + s2 + " #" + mp->at(s2.subrange(0+1,s2->size() - 1))) ) ;  ) ;  
 );
}
class FastReader {
   attribute bf : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var st : String ; st := "" ;
     try (     st := bf.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return st );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(bf.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int val ;
    while((val=getInt(br))!=0){
      int month=0 ;
      for(int i=1 ; i<=12 ; i++){
        String s=br.readLine();
        if(month==0){
          val-=Integer.parseInt(s.substring(0,s.indexOf(" ")));
          val+=Integer.parseInt(s.substring(s.indexOf(" ")+1));
          if(val<=0){
            month=i ;
          }
        }
      }
      System.out.println(month>0 ?(month): "NA");
    }
  }
  private static int getInt(BufferedReader br)throws IOException {
    return Integer.parseInt(br.readLine());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var val : int ;
         val := getInt(br) ;
    while ((val) /= 0) do (    skip ; (     var month : int ; month := 0 ;
         var i : int ; i := 1 ; while i <= 12 do ( (     var s : String ; s := br.readLine() ;
     if (month = 0) then (     val := val-((s.subrange(0+1,s->indexOf(" ")-1))->toInteger()) ; 
     val := val+((s.subrange(s->indexOf(" ")-1 + 1+1,s->indexOf(" ")-1 + 1))->toInteger()) ; 
     if (val <= 0) then (     month := i ) else skip ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if month > 0 then (month) else "NA" endif) ) ;     val := getInt(br) ;
 ) );
  static   operation getInt( br : OclFile) : int
  pre: true
  post: true
  activity: (     return (br.readLine())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  private static BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  public static void main(String[] args)throws IOException {
    String s=in.readLine();
    String[] split=s.split(" ");
    int n=Integer.parseInt(split[0]);
    int l=Integer.parseInt(split[1]);
    String s2=in.readLine();
    String[] split2=s2.split(" ");
    int[] arr=new int[n];
    for(int i=0 ; i<split2.length ; i++){
      arr[i]=Integer.parseInt(split2[i]);
    }
    Arrays.sort(arr);
    int max=Math.max(arr[0]*2,(l-arr[n-1])*2);
    for(int i=1 ; i<arr.length ; i++){
      int d=arr[i]-arr[i-1];
      max=Math.max(d,max);
    }
    System.out.println((double)max/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.readLine() ;
     var split : Sequence(String) ; split := s->split(" ") ;
    var n : int ; n := (split[0+1])->toInteger() ;
    var l : int ; l := (split[1+1])->toInteger() ;
    var s2 : String ; s2 := in.readLine() ;
    var split2 : Sequence(String) ; split2 := s2->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < split2->size() do ( (     arr[i+1] := (split2[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var max : int ; max := Set{arr[0+1] * 2, (l - arr[n - 1+1]) * 2}->max() ;
        var i : int ; i := 1 ; while i < arr->size() do ( (     var d : int ; d := arr[i+1] - arr[i - 1+1] ;
     max := Set{d, max}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max->oclAsType(double) / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Lanterns {
  public static void main(String[] args){
    Scanner o=new Scanner(System.in);
    int n=o.nextInt(),l=o.nextInt();
    long[] arr=new long[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=o.nextLong();
    }
    Arrays.sort(arr);
    double max=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if(arr[i+1]-arr[i]>max)max=arr[i+1]-arr[i];
    }
    max/=2 ;
    if(arr[0]!=0 && max<arr[0])max=arr[0];
    if(arr[n-1]!=l && max<l-arr[n-1])max=l-arr[n-1];
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Lanterns {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : OclFile ; o := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := o.getCurrent()->toInteger() ;
    var l : int ; l := o.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := o.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var max : double ; max := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i + 1+1] - arr[i+1] > max) then     max := arr[i + 1+1] - arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
    max := max/(2) ; 
    if (arr[0+1] /= 0 & max < arr[0+1]) then     max := arr[0+1] ; else skip ; 
    if (arr[n - 1+1] /= l & max < l - arr[n - 1+1]) then     max := l - arr[n - 1+1] ; else skip ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt(),l=s.nextInt();
    double arr[]=new double[n];
    for(int i=0 ; i<n ; i++)arr[i]=s.nextInt();
    Arrays.sort(arr);
    double ans=Math.max(arr[0],l-arr[n-1]);
    for(int i=1 ; i<n ; i++){
      ans=Math.max(ans,(arr[i]-arr[i-1])/2);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var l : int ; l := s.getCurrent()->toInteger() ;
    var arr : Sequence(double) ; arr := Integer.subrange(1,n)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var ans : double ; ans := Set{arr[0+1], l - arr[n - 1+1]}->max() ;
        var i : int ; i := 1 ; while i < n do ( (     ans := Set{ans, (arr[i+1] - arr[i - 1+1]) / 2}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.PriorityQueue ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    Comparator<Point>comp=(p1,p2)->p1.x-p2.x ;
    List<Point>red=new LinkedList<>();
    for(int i=0 ; i<n ; i++){
      String[] in=br.readLine().split(" ");
      red.add(new Point(Integer.parseInt(in[0]),Integer.parseInt(in[1])));
    }
    Collections.sort(red,comp);
    PriorityQueue<Point>blue=new PriorityQueue<>(comp);
    for(int i=0 ; i<n ; i++){
      String[] in=br.readLine().split(" ");
      blue.add(new Point(Integer.parseInt(in[0]),Integer.parseInt(in[1])));
    }
    int ans=0 ;
    while(! blue.isEmpty()){
      Point b=blue.poll();
      int index=-1 ;
      int maxy=-1 ;
      int i=0 ;
      Point tmp ;
      while(i<red.size()&&(tmp=red.get(i)).x<b.x){
        if(tmp.y<b.y && maxy<tmp.y){
          index=i ;
          maxy=tmp.y ;
        }
        i++;
      }
      if(index!=-1){
        red.remove(index);
        ans++;
      }
    }
    System.out.println(ans);
    br.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var comp : Function(<Point>,(<Point>,boolean)) ; comp := lambda (p1 , p2) : OclAny in p1.x - p2.x ;
    var red : Sequence(Point) ; red := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var in : Sequence(String) ; in := br.readLine()->split(" ") ;
     red := red->including(Point.newPoint((in[0+1])->toInteger(), (in[1+1])->toInteger())) )  ;     i := i + 1 ) ; 
    red, comp := red, comp->sort() ; 
    var blue : Sequence(Point) ; blue := Sequence{}->union(comp) ;
        var i : int ; i := 0 ; while i < n do ( (     var in : Sequence(String) ; in := br.readLine()->split(" ") ;
     blue := blue->including(Point.newPoint((in[0+1])->toInteger(), (in[1+1])->toInteger())) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    while (not(blue->isEmpty())) do (     var b : Point ; b := blue->min() ;
     var index : int ; index := -1 ;
    var maxy : int ; maxy := -1 ;
    var i : int ; i := 0 ;
    var tmp : Point ;
        tmp := red->at(i+1) ;
    while (i < red->size() & (tmp).x < b.x) do (    skip ; (     if (tmp.y < b.y & maxy < tmp.y) then (     index := i ; 
     maxy := tmp.y ) else skip ; 
     i := i + 1 ) ;     tmp := red->at(i+1) ;
 ) ;  
    if (index /= -1) then (     red := red->excludingAt(index+1) ; 
     ans := ans + 1 ) else skip ; 
 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int l=in.nextInt();
    ArrayList<Integer>arr=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      arr.add(in.nextInt());
    }
    Collections.sort(arr);
    double d=0 ;
    double temp ;
    for(int i=0 ; i<n-1 ; i++){
      temp=(arr.get(i+1)-arr.get(i))/2.0 ;
      if(temp>d)d=temp ;
    }
    int first=arr.get(0);
    int last=l-arr.get(n-1);
    if(last>d)d=last ;
    if(first>d)d=first ;
    System.out.println(d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var l : int ; l := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr := arr->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var d : double ; d := 0 ;
    var temp : double ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     temp := (arr->at(i + 1+1) - arr->at(i+1)) / 2.0 ; 
     if (temp > d) then     d := temp ; else skip )  ;     i := i + 1 ) ; 
    var first : int ; first := arr->at(0+1) ;
    var last : int ; last := l - arr->at(n - 1+1) ;
    if (last > d) then     d := last ; else skip ; 
    if (first > d) then     d := first ; else skip ; 
    OclFile["System.out"].println(d) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void minAdjDifference(int arr[],int n){
    if(n<2)return ;
    int res=Math.abs(arr[1]-arr[0]);
    for(int i=2 ; i<n ; i++)res=Math.min(res,Math.abs(arr[i]-arr[i-1]));
    res=Math.min(res,Math.abs(arr[n-1]-arr[0]));
    System.out.print("Min Difference="+res);
  }
  public static void main(String arg[]){
    int a[]={
      10,12,13,15,10 };
      int n=a.length ;
      minAdjDifference(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minAdjDifference( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     if (n < 2) then     return else skip ; 
     var res : int ; res := if arr[1+1] - arr[0+1] < 0 then -(arr[1+1] - arr[0+1]) else arr[1+1] - arr[0+1] endif ;
        var i : int ; i := 2 ; while i < n do (     res := Set{res, if arr[i+1] - arr[i - 1+1] < 0 then -(arr[i+1] - arr[i - 1+1]) else arr[i+1] - arr[i - 1+1] endif}->min() ;  ;     i := i + 1 ) ; 
    res := Set{res, if arr[n - 1+1] - arr[0+1] < 0 then -(arr[n - 1+1] - arr[0+1]) else arr[n - 1+1] - arr[0+1] endif}->min() ; 
    OclFile["System.out"].print("Min Difference=" + res) ; 
 );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{10,12,13,15,10} ;
     var n : int ; n := a->size() ;
     execute minAdjDifference(a, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void KPrimeDivisors(int N,int K){
    int maximum_split=0 ;
    while(N % 2==0){
      maximum_split++;
      N/=2 ;
    }
    for(int i=3 ; i*i<=N ; i=i+2){
      while(N % i==0){
        N=N/i ;
        maximum_split++;
      }
    }
    if(N>2)maximum_split++;
    if(maximum_split<K){
      System.out.println("No");
      return ;
    }
    System.out.println("Yes");
  }
  public static void main(String[] args){
    int N=12 ;
    int K=3 ;
    KPrimeDivisors(N,K);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation KPrimeDivisors( N : int, K : int) : void
  pre: true
  post: true
  activity: (     var maximum_split : int ; maximum_split := 0 ;
     while (N mod 2 = 0) do (     maximum_split := maximum_split + 1 ; 
     N := N/(2) ) ; 
        var i : int ; i := 3 ; while i * i <= N do ( (     while (N mod i = 0) do (     N := N / i ; 
     maximum_split := maximum_split + 1 ) )  ;     i := i + 2 ) ; 
    if (N > 2) then     maximum_split := maximum_split + 1 ; else skip ; 
    if (maximum_split < K) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
    OclFile["System.out"].println("Yes") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 12 ;
     var K : int ; K := 3 ;
     execute KPrimeDivisors(N, K) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p077 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p077().run());
  }
  private static final int TARGET=5000 ;
  public String run(){
    for(int limit=1 ; ; limit*=2){
      int result=search(limit,TARGET);
      if(result!=-1)return Integer.toString(result);
    }
  }
  private static int search(int limit,int target){
    int[] partitions=new int[limit];
    partitions[0]=1 ;
    for(int i=0 ; i<partitions.length ; i++){
      if(! Library.isPrime(i))continue ;
      for(int j=i ; j<partitions.length ; j++)partitions[j]+=partitions[j-i];
    }
    for(int i=0 ; i<limit ; i++){
      if(partitions[i]>target)return i ;
    }
    return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p077 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p077.newp077().run()) );
  static    attribute TARGET : int := 5000;
   operation run() : String
  pre: true
  post: true
  activity: (         var limit : int ; limit := 1 ; while true do ( (     var result : int ; result := search(limit, TARGET) ;
     if (result /= -1) then     return ((result) + "") else skip )  ;     limit := limit*(2) ) );
  static   operation search( limit : int, target : int) : int
  pre: true
  post: true
  activity: (     var partitions : Sequence(int) ; partitions := Integer.subrange(1,limit)->collect(0) ;
     partitions[0+1] := 1 ; 
        var i : int ; i := 0 ; while i < partitions->size() do ( (     if (not(Library.isPrime(i))) then     continue else skip ; 
         var j : int ; j := i ; while j < partitions->size() do (     partitions[j+1] := partitions[j+1]+(partitions[j - i+1]) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < limit do ( (     if (partitions[i+1] > target) then     return i else skip )  ;     i := i + 1 ) ; 
    return -1 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Queue ;
class GFG {
  static int minimumMulitplications(int start,int end,int a[],int n){
    int ans[]=new int[100001];
    Arrays.fill(ans,-1);
    int mod=100000 ;
    Queue<Integer>q=new LinkedList<>();
    q.add(start % mod);
    ans[start]=0 ;
    while(! q.isEmpty()){
      int top=q.peek();
      q.remove();
      if(top==end){
        return ans[end];
      }
      for(int i=0 ; i<n ; i++){
        int pushed=top*a[i];
        pushed=pushed % mod ;
        if(ans[pushed]==-1){
          ans[pushed]=ans[top]+1 ;
          q.add(pushed);
        }
      }
    }
    return-1 ;
  }
  public static void main(String args[]){
    int start=7,end=66175 ;
    int a[]={
      3,4,65 };
      int n=a.length ;
      System.out.println(minimumMulitplications(start,end,a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumMulitplications( start : int, end : int, a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Integer.subrange(1,100001)->collect(0) ;
     ans := ans->collect(-1) ; 
    var mod : int ; mod := 100000 ;
    var q : Sequence(int) ; q := Sequence{} ;
    q := q->including(start mod mod) ; 
    ans[start+1] := 0 ; 
    while (not(q->isEmpty())) do (     var top : int ; top := q->min() ;
     q := q.remove() ; 
     if (top = end) then (     return ans[end+1] ) else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     var pushed : int ; pushed := top * a[i+1] ;
     pushed := pushed mod mod ; 
     if (ans[pushed+1] = -1) then (     ans[pushed+1] := ans[top+1] + 1 ; 
     q := q->including(pushed) ) else skip )  ;     i := i + 1 ) ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : int ; start := 7 ;
    var end : int ; end := 66175 ;
     var a : Sequence(int) ; a := Sequence{3,4,65} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(minimumMulitplications(start, end, a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Seasons {
  public static void findSeason(int M){
    switch(M){
      case 12 : case 1 : case 2 : System.out.println("WINTER");
      break ;
      case 3 : case 4 : case 5 : System.out.println("SPRING");
      break ;
      case 6 : case 7 : case 8 : System.out.println("SUMMER");
      break ;
      case 9 : case 10 : case 11 : System.out.println("AUTUMN");
      break ;
      default : System.out.println("Invalid Month number");
      break ;
    }
  }
  public static void main(String abc[]){
    int M=5 ;
    System.out.println("For Month number: "+M);
    findSeason(M);
    M=10 ;
    System.out.println("For Month number: "+M);
    findSeason(M);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Seasons {
  static   operation findSeason( M : int) : void
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (M) ; 
    if _switchval = 12 or _switchval = 1 or _switchval = 2 then
    OclFile["System.out"].println("WINTER") ; 
    break 
   else skip ;
    if _switchval = 3 or _switchval = 4 or _switchval = 5 then
    OclFile["System.out"].println("SPRING") ; 
    break 
   else skip ;
    if _switchval = 6 or _switchval = 7 or _switchval = 8 then
    OclFile["System.out"].println("SUMMER") ; 
    break 
   else skip ;
    if _switchval = 9 or _switchval = 10 or _switchval = 11 then
    OclFile["System.out"].println("AUTUMN") ; 
    break 
   else skip ;
       if true then
     OclFile["System.out"].println("Invalid Month number") ; 
    break 
   else skip ;
 )
 );
  static   operation main( abc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var M : int ; M := 5 ;
     OclFile["System.out"].println("For Month number: " + M) ; 
    execute findSeason(M) ; 
    M := 10 ; 
    OclFile["System.out"].println("For Month number: " + M) ; 
    execute findSeason(M) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    ArrayList<String>arr=new ArrayList<>();
    while(true){
      boolean flag=false ;
      int border=Integer.parseInt(scan.next());
      if(border==0){
        break ;
      }
      String ret="NA" ;
      int sum=0 ;
      for(int i=0 ; i<12 ; i++){
        int m=Integer.parseInt(scan.next());
        int n=Integer.parseInt(scan.next());
        int sub=m-n ;
        sum+=sub ;
        if(sum>=border && flag==false){
          ret=String.valueOf(i+1);
          flag=true ;
        }
      }
      arr.add(ret);
    }
    arr.stream().forEach(System.out :: println);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(String) ; arr := Sequence{} ;
     while (true) do (     var flag : boolean ; flag := false ;
     var border : int ; border := (scan.getCurrent())->toInteger() ;
    if (border = 0) then (     break ) else skip ; 
    var ret : String ; ret := "NA" ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 12 do ( (     var m : int ; m := (scan.getCurrent())->toInteger() ;
     var n : int ; n := (scan.getCurrent())->toInteger() ;
    var sub : int ; sub := m - n ;
    sum := sum+(sub) ; 
    if (sum >= border & flag = false) then (     ret := ((i + 1) + "") ; 
     flag := true ) else skip ; 
 )  ;     i := i + 1 ) ; 
    arr := arr->including(ret) ; 
 ) ; 
     for _forEach : arr do
    (    skip ;) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.Scanner ;
public class DreamoonLikesPermutations {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t>0){
      int n=s.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=s.nextInt();
      }
      int dis[]=new int[n];
      int max=Integer.MIN_VALUE ;
      int maxi[]=new int[n];
      HashMap<Integer,Boolean>map=new HashMap<>();
      for(int i=n-1 ; i>=0 ; i--){
        map.put(arr[i],true);
        dis[i]=map.size();
        max=Math.max(max,arr[i]);
        maxi[i]=max ;
      }
      ArrayList<Integer>ans=new ArrayList<Integer>();
      HashMap<Integer,Boolean>str=new HashMap<>();
      max=Integer.MIN_VALUE ;
      for(int i=0 ; i<n-1 ; i++){
        str.put(arr[i],true);
        max=Math.max(max,arr[i]);
        if(i+1==max && str.size()==i+1 && dis[i+1]==n-i-1 && maxi[i+1]==n-i-1){
          ans.add(i+1);
          ans.add(n-i-1);
        }
      }
      System.out.println(ans.size()/2);
      for(int i=0 ; i<ans.size(); i=i+2){
        System.out.println(ans.get(i)+" "+ans.get(i+1));
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DreamoonLikesPermutations {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := s.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dis : Sequence(int) ; dis := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := -2147483648 ;
    var maxi : Sequence(int) ; maxi := Integer.subrange(1,n)->collect(0) ;
    var map : Map(int,Boolean) ; map := Map{} ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     map := map->union(Map{arr[i+1] |-> true}) ; 
     dis[i+1] := map.size() ; 
     max := Set{max, arr[i+1]}->max() ; 
     maxi[i+1] := max )  ;     i := i - 1 ) ; 
    var ans : Sequence(int) ; ans := Sequence{} ;
    var str : Map(int,Boolean) ; str := Map{} ;
    max := -2147483648 ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     str := str->union(Map{arr[i+1] |-> true}) ; 
     max := Set{max, arr[i+1]}->max() ; 
     if (i + 1 = max & str.size() = i + 1 & dis[i + 1+1] = n - i - 1 & maxi[i + 1+1] = n - i - 1) then (     ans := ans->including(i + 1) ; 
     ans := ans->including(n - i - 1) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans->size() / 2) ; 
        var i : int ; i := 0 ; while i < ans->size() do ( (     OclFile["System.out"].println(ans->at(i+1) + " " + ans->at(i + 1+1)) )  ;     i := i + 2 ) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class DreamoonLikesPermutations {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t!=0){
      solve(br,pr);
      t--;
    }
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    String[] temp=br.readLine().split(" ");
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=Integer.parseInt(temp[i]);
    }
    TreeSet<Integer>set=new TreeSet<>();
    Set<Integer>res=new HashSet<>();
    for(int i=1 ; i<=n ; i++){
      set.add(i);
    }
    for(int i=0 ; i<n ; i++){
      set.remove(nums[i]);
      if(set.first()==i+2){
        res.add(i+1);
      }
    }
    set=new TreeSet<>();
    for(int i=1 ; i<=n ; i++){
      set.add(i);
    }
    for(int i=n-1 ; i>=0 ; i--){
      set.remove(nums[i]);
      if(set.first()!=n-i+1){
        res.remove(i);
      }
    }
    pr.println(res.size());
    for(int i : res){
      pr.println(i+" "+(n-i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DreamoonLikesPermutations {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
    while (t /= 0) do (     execute solve(br, pr) ; 
     t := t - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := (temp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
    var res : Set(int) ; res := Set{} ;
        var i : int ; i := 1 ; while i <= n do ( (     set := set->including(i) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     set := set->excludingFirst(nums[i+1]) ; 
     if (set->first() = i + 2) then (     res := res->including(i + 1) ) else skip )  ;     i := i + 1 ) ; 
    set := Set{} ; 
        var i : int ; i := 1 ; while i <= n do ( (     set := set->including(i) )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     set := set->excludingFirst(nums[i+1]) ; 
     if (set->first() /= n - i + 1) then (     res := res->excludingAt(i+1) ) else skip )  ;     i := i - 1 ) ; 
    skip ; 
    for (i : res) do ( (     skip )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int p=s.nextInt();
    int q=s.nextInt();
    String str=s.next();
    for(int i=0 ; i<=n/p ; i++){
      int find=n-p*i ;
      if(find % q==0){
        int start=0 ;
        System.out.println(i+find/q);
        while(i>0){
          System.out.println(str.substring(start,start+p));
          start+=p ;
          i--;
        }
        int j=find/q ;
        while(j>0){
          System.out.println(str.substring(start,start+q));
          start+=q ;
          j--;
        }
        return ;
      }
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var p : int ; p := s.getCurrent()->toInteger() ;
    var q : int ; q := s.getCurrent()->toInteger() ;
    var str : String ; str := s.getCurrent() ;
        var i : int ; i := 0 ; while i <= n / p do ( (     var find : int ; find := n - p * i ;
     if (find mod q = 0) then (     var start : int ; start := 0 ;
     OclFile["System.out"].println(i + find / q) ; 
    while (i > 0) do (     OclFile["System.out"].println(str.subrange(start+1,start + p)) ; 
     start := start+(p) ; 
     i := i - 1 ) ; 
    var j : int ; j := find / q ;
    while (j > 0) do (     OclFile["System.out"].println(str.subrange(start+1,start + q)) ; 
     start := start+(q) ; 
     j := j - 1 ) ; 
    return 
 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int p=scan.nextInt();
    int q=scan.nextInt();
    String str=scan.next();
    int x=0,y=0 ;
    for(int i=0 ; i<n ; i++){
      if((n-q*i)% p==0){
        y=i ;
        break ;
      }
    }
    if((n-q*y)% p==0){
      x=(n-q*y)/p ;
      if(x<0){
        x=x*(-1);
      }
    }
    if((x==0 && y==0)||(x*p+y*q>n)){
      System.out.println("-1");
    }
    else {
      System.out.println(x+y);
      for(int i=0 ; i<x ; i++){
        System.out.println(str.substring(i*p,i*p+p));
      }
      for(int i=0 ; i<y ; i++){
        System.out.println(str.substring(i*q+p*x,i*q+p*x+q));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var p : int ; p := scan.getCurrent()->toInteger() ;
    var q : int ; q := scan.getCurrent()->toInteger() ;
    var str : String ; str := scan.getCurrent() ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if ((n - q * i) mod p = 0) then (     y := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if ((n - q * y) mod p = 0) then (     x := (n - q * y) / p ; 
     if (x < 0) then (     x := x * (-1) ) else skip ) else skip ; 
    if ((x = 0 & y = 0) or (x * p + y * q > n)) then (     OclFile["System.out"].println("-1") ) else (     OclFile["System.out"].println(x + y) ; 
         var i : int ; i := 0 ; while i < x do ( (     OclFile["System.out"].println(str.subrange(i * p+1,i * p + p)) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < y do ( (     OclFile["System.out"].println(str.subrange(i * q + p * x+1,i * q + p * x + q)) )  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[][] red=new int[n][2];
    int[][] blue=new int[n][2];
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<2 ; j++)red[i][j]=sc.nextInt();
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<2 ; j++)blue[i][j]=sc.nextInt();
    Arrays.sort(red,(array1,array2)->array1[1]-array2[1]);
    Arrays.sort(blue,(array1,array2)->array1[0]-array2[0]);
    Set<Integer>usedSet=new HashSet<>();
    for(int[] b : blue){
      int max=-1 ;
      for(int i=0 ; i<red.length ; i++){
        if(usedSet.contains(i)|| red[i][0]>=b[0])continue ;
        if(red[i][1]>=b[1])break ;
        if(max==-1 || red[max][1]<red[i][1])max=i ;
      }
      if(max!=-1)usedSet.add(max);
    }
    System.out.println(usedSet.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var red : Sequence(Sequence(int)) ; red := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
    var blue : Sequence(Sequence(int)) ; blue := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < 2 do (     red[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < 2 do (     blue[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    red := OclComparator.sortWith(red, lambda (array1 , array2) : OclAny in array1[1+1] - array2[1+1]) ; 
    blue := OclComparator.sortWith(blue, lambda (array1 , array2) : OclAny in array1[0+1] - array2[0+1]) ; 
    var usedSet : Set(int) ; usedSet := Set{} ;
    for (b : blue) do ( (     var max : int ; max := -1 ;
         var i : int ; i := 0 ; while i < red->size() do ( (     if (usedSet->includes(i) or red[i+1][0+1] >= b[0+1]) then     continue else skip ; 
     if (red[i+1][1+1] >= b[1+1]) then     break else skip ; 
     if (max = -1 or red[max+1][1+1] < red[i+1][1+1]) then     max := i ; else skip )  ;     i := i + 1 ) ; 
     if (max /= -1) then     usedSet := usedSet->including(max) ; else skip )  ) ; 
    OclFile["System.out"].println(usedSet->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int countp=0 ;
  static int countq=0 ;
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int a[]=new int[2];
    a[0]=input.nextInt();
    a[1]=input.nextInt();
    String s=input.next();
    if(s.length()% a[0]==0){
      countp=s.length()/a[0];
    }
    else if(s.length()% a[1]==0){
      countq=s.length()/a[1];
    }
    else {
      for(int i=0 ; i<=100 ; i++){
        if((s.length()-(a[0]*i))% a[1]==0 &&((s.length()-(a[0]*i))/a[1])>=0){
          countp=i ;
          countq=(s.length()-(a[0]*i))/a[1];
          break ;
        }
      }
    }
    int start=0 ;
    if(countp==0 && countq==0){
      System.out.println("-1");
    }
    else {
      System.out.println(countp+countq);
      while(countp-->0){
        System.out.println(s.substring(start,start+a[0]));
        start=start+a[0];
      }
      while(countq-->0){
        System.out.println(s.substring(start,start+a[1]));
        start+=a[1];
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute countp : int := 0;
  static   attribute countq : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,2)->collect(0) ;
    a[0+1] := input.getCurrent()->toInteger() ; 
    a[1+1] := input.getCurrent()->toInteger() ; 
    var s : String ; s := input.getCurrent() ;
    if (s->size() mod a[0+1] = 0) then (     countp := s->size() / a[0+1] ) else     if (s->size() mod a[1+1] = 0) then (     countq := s->size() / a[1+1] ) else (         var i : int ; i := 0 ; while i <= 100 do ( (     if ((s->size() - (a[0+1] * i)) mod a[1+1] = 0 & ((s->size() - (a[0+1] * i)) / a[1+1]) >= 0) then (     countp := i ; 
     countq := (s->size() - (a[0+1] * i)) / a[1+1] ; 
     break ) else skip )  ;     i := i + 1 ) ) ;  ;  
    var start : int ; start := 0 ;
    if (countp = 0 & countq = 0) then (     OclFile["System.out"].println("-1") ) else (     OclFile["System.out"].println(countp + countq) ; 
         while (countp > 0) do (        countp := countp - 1 ;     skip ; (     OclFile["System.out"].println(s.subrange(start+1,start + a[0+1])) ; 
     start := start + a[0+1] ) ;  ) ;  
         while (countq > 0) do (        countq := countq - 1 ;     skip ; (     OclFile["System.out"].println(s.subrange(start+1,start + a[1+1])) ; 
     start := start+(a[1+1]) ) ;  ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class TheTextSplitting {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int p=Integer.parseInt(str[1]);
    int q=Integer.parseInt(str[2]);
    String string=br.readLine();
    int pa=-1 ;
    int qb=-1 ;
    for(int i=0 ; (p*i<=n); i++){
      if((n-i*p)% q==0){
        pa=i ;
        qb=(n-pa*p)/q ;
      }
      if(pa!=-1){
        break ;
      }
    }
    if(pa==-1){
      System.out.print("-1");
      return ;
    }
    StringBuilder sb=new StringBuilder();
    int start=0 ;
    for(int i=0 ; i<pa ; i++){
      for(int j=0 ; j<p ; j++){
        sb.append(string.charAt(start++));
        if(j==p-1){
          sb.append("\n");
        }
      }
    }
    for(int i=0 ; i<qb ; i++){
      for(int j=0 ; j<q ; j++){
        sb.append(string.charAt(start++));
        if(j==q-1){
          sb.append("\n");
        }
      }
    }
    System.out.println(pa+qb);
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class TheTextSplitting {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var p : int ; p := (str[1+1])->toInteger() ;
    var q : int ; q := (str[2+1])->toInteger() ;
    var string : String ; string := br.readLine() ;
    var pa : int ; pa := -1 ;
    var qb : int ; qb := -1 ;
        var i : int ; i := 0 ; while (p * i <= n) do ( (     if ((n - i * p) mod q = 0) then (     pa := i ; 
     qb := (n - pa * p) / q ) else skip ; 
     if (pa /= -1) then (     break ) else skip )  ;     i := i + 1 ) ; 
    if (pa = -1) then (     OclFile["System.out"].print("-1") ; 
     return ) else skip ; 
    var sb : String ; sb := StringLib.newString() ;
    var start : int ; start := 0 ;
        var i : int ; i := 0 ; while i < pa do ( (         var j : int ; j := 0 ; while j < p do ( (     sb := sb + StringLib.newString(string->at(start+1)) ; 
     if (j = p - 1) then (     sb := sb + StringLib.newString("\n") ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < qb do ( (         var j : int ; j := 0 ; while j < q do ( (     sb := sb + StringLib.newString(string->at(start+1)) ; 
     if (j = q - 1) then (     sb := sb + StringLib.newString("\n") ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(pa + qb) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isDigit(char ch){
    if(ch>='0' && ch<='9')return true ;
    return false ;
  }
  static int nextNonDigit(String str,int i){
    while(i<str.length()&& isDigit(str.charAt(i))){
      i++;
    }
    if(i>=str.length())return-1 ;
    return i ;
  }
  static void appendRepeated(StringBuilder sb,String str,int times){
    for(int i=0 ; i<times ; i++)sb.append(str);
  }
  static String findString(String str,int n){
    StringBuilder sb=new StringBuilder("");
    int startStr=nextNonDigit(str,0);
    while(startStr!=-1){
      int endStr=startStr ;
      while((endStr+1)<n && ! isDigit(str.charAt(endStr+1))){
        endStr++;
      }
      int startNum=endStr+1 ;
      if(startNum==-1)break ;
      int endNum=startNum ;
      while((endNum+1)<n && isDigit(str.charAt(endNum+1))){
        endNum++;
      }
      int num=Integer.parseInt(str.substring(startNum,endNum+1));
      appendRepeated(sb,str.substring(startStr,endStr+1),num);
      startStr=nextNonDigit(str,endStr+1);
    }
    return sb.toString();
  }
  public static void main(String[] args){
    String str="g1ee1ks1for1g1e2ks1" ;
    int n=str.length();
    System.out.println(findString(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isDigit( ch : String) : boolean
  pre: true
  post: true
  activity: (     if (ch >= '0' & ch <= '9') then     return true else skip ; 
     return false );
  static   operation nextNonDigit( str : String, i : int) : int
  pre: true
  post: true
  activity: (     while (i < str->size() & isDigit(str->at(i+1))) do (     i := i + 1 ) ; 
     if (i >= str->size()) then     return -1 else skip ; 
     return i );
  static   operation appendRepeated( sb : String, str : String, times : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < times do (     sb := sb + StringLib.newString(str) ;  ;     i := i + 1 ) );
  static   operation findString( str : String, n : int) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString("") ;
     var startStr : int ; startStr := nextNonDigit(str, 0) ;
     while (startStr /= -1) do (     var endStr : int ; endStr := startStr ;
     while ((endStr + 1) < n & not(isDigit(str->at(endStr + 1+1)))) do (     endStr := endStr + 1 ) ; 
    var startNum : int ; startNum := endStr + 1 ;
    if (startNum = -1) then     break else skip ; 
    var endNum : int ; endNum := startNum ;
    while ((endNum + 1) < n & isDigit(str->at(endNum + 1+1))) do (     endNum := endNum + 1 ) ; 
    var num : int ; num := (str.subrange(startNum+1,endNum + 1))->toInteger() ;
    execute appendRepeated(sb, str.subrange(startStr+1,endStr + 1), num) ; 
    startStr := nextNonDigit(str, endStr + 1) ; 
 ) ; 
     return sb+"" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "g1ee1ks1for1g1e2ks1" ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].println(findString(str, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.Set ;
public class Main {
  private static final String VOWEL="aeiou" ;
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      int n=Integer.parseInt(br.readLine());
      if(n==0)break ;
      int max=0 ;
      ArrayList<String>list=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        String str=br.readLine();
        max=Math.max(str.length(),max);
        list.add(str);
      }
      int ans=0 ;
      Set<String>set ;
      while(++ans<=max){
        set=new HashSet<>();
        for(String str : list){
          set.add(trim(str,ans));
        }
        if(set.size()==n){
          break ;
        }
      }
      System.out.println(ans>max ?-1 : ans);
    }
  }
  static String trim(String str,int len){
    StringBuilder sb=new StringBuilder();
    boolean flg=true ;
    for(char elm : str.toCharArray()){
      if(flg){
        sb.append(elm);
        flg=false ;
      }
      if(VOWEL.indexOf(elm)>=0){
        flg=true ;
      }
    }
    return sb.toString().substring(0,Math.min(len,sb.length()));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute VOWEL : String := "aeiou";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var n : int ; n := (br.readLine())->toInteger() ;
     if (n = 0) then     break else skip ; 
    var max : int ; max := 0 ;
    var list : Sequence(String) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := br.readLine() ;
     max := Set{str->size(), max}->max() ; 
     list := list->including(str) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var set : Set(String) ;
        ans := ans + 1 ;
    while ((ans + 1) <= max) do (        ans := ans + 1 ;     skip ; (     set := Set{} ; 
     for (str : list) do ( (     set := set->including(trim(str, ans)) )  ) ; 
     if (set->size() = n) then (     break ) else skip ) ;     ans := ans + 1 ;
 ) ;  
    OclFile["System.out"].println(if ans > max then -1 else ans endif) ; 
 ) );
  static   operation trim( str : String, len : int) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     var flg : boolean ; flg := true ;
     for (elm : str->characters()) do ( (     if (flg) then (     sb := sb + StringLib.newString(elm) ; 
     flg := false ) else skip ; 
     if (VOWEL->indexOf(elm)-1 >= 0) then (     flg := true ) else skip )  ) ; 
     return sb+"".subrange(0+1,Set{len, sb->size()}->min()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static Set<Character>list ;
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    list=new HashSet<>();
    list.add('a');
    list.add('i');
    list.add('u');
    list.add('e');
    list.add('o');
    int n ;
    loop : while(scan.hasNext()){
      n=scan.nextInt();
      if(n==0)return ;
      String[] arr=new String[n];
      for(int i=0 ; i<n ; i++)arr[i]=getShortName(scan.next().toCharArray());
      Arrays.sort(arr);
      int result=0 ;
      for(int i=0 ; i<n-1 ; i++){
        if(arr[i] .equals(arr[i+1])){
          System.out.println(-1);
          continue loop ;
        }
        else {
          int same=0 ;
          for(int j=0 ; j<Math.min(arr[i] .length(),arr[i+1] .length()); j++){
            if(arr[i] .charAt(j)==arr[i+1] .charAt(j)){
              same++;
            }
          }
          result=Math.max(same,result);
        }
      }
      System.out.println(result+1);
    }
  }
  public static String getShortName(char[] input){
    String result=""+input[0];
    for(int i=1 ; i<input.length ; i++){
      if(list.contains(input[i-1])){
        result+=input[i];
      }
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute list : Set(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     list := Set{} ; 
    list := list->including('a') ; 
    list := list->including('i') ; 
    list := list->including('u') ; 
    list := list->including('e') ; 
    list := list->including('o') ; 
    var n : int ;
    while (scan.hasNext()) do (     n := scan.getCurrent()->toInteger() ; 
     if (n = 0) then     return else skip ; 
    var arr : Sequence(String) ; arr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := getShortName(scan.getCurrent()->characters()) ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] = arr[i + 1+1]) then (     OclFile["System.out"].println(-1) ; 
     continue ) else (     var same : int ; same := 0 ;
         var j : int ; j := 0 ; while j < Set{arr[i+1]->size(), arr[i + 1+1]->size()}->min() do ( (     if (arr[i+1]->at(j+1) = arr[i + 1+1]->at(j+1)) then (     same := same + 1 ) else skip )  ;     j := j + 1 ) ; 
     result := Set{same, result}->max() ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result + 1) ; 
 ) ; 
 );
  static   operation getShortName( input : Sequence(String)) : String
  pre: true
  post: true
  activity: (     var result : String ; result := "" + input[0+1] ;
         var i : int ; i := 1 ; while i < input->size() do ( (     if (list->includes(input[(i)->char2byte() - 1+1])) then (     result := result+(input[i+1]) ) else skip )  ;     i := i + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      if(a==b && c==b){
        System.out.println(0);
      }
      else {
        int sum=Math.abs(a-b)+Math.abs(b-c)+Math.abs(c-a);
        sum-=4 ;
        System.out.println(Math.max(sum,0));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
     if (a = b & c = b) then (     OclFile["System.out"].println(0) ) else (     var sum : int ; sum := if a - b < 0 then -(a - b) else a - b endif + if b - c < 0 then -(b - c) else b - c endif + if c - a < 0 then -(c - a) else c - a endif ;
     sum := sum-(4) ; 
     OclFile["System.out"].println(Set{sum, 0}->max()) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  private static final String covconv(String s){
    final char[] a=s.toCharArray();
    int sp=0 ;
    for(int p=0 ; p<a.length ; ++p){
      a[sp++]=a[p];
      while(p<a.length && "aiueo".indexOf(a[p])==-1)++p ;
    }
    return new String(a,0,sp);
  }
  private static final int kenkov(String[] s){
    int rvalue=0 ;
    for(int i=0 ; i<s.length ; ++i)rvalue=Math.max(rvalue,s[i] .length());
    return rvalue ;
  }
  private static final boolean check_disjoint(String[] s,int k){
    for(int i=0 ; i<s.length ; ++i){
      final String s1=s[i] .substring(0,Math.min(s[i] .length(),k));
      for(int j=i+1 ; j<s.length ; ++j){
        final String s2=s[j] .substring(0,Math.min(s[j] .length(),k));
        if(s1.equals(s2))return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    try(java.util.Scanner sc=new java.util.Scanner(System.in)){
      MAINLOOP : for(;
      ;
){
        final int n=sc.nextInt();
        if(n==0)break ;
        final String[] s=new String[n];
        for(int i=0 ; i<n ; ++i){
          s[i]=covconv(sc.next());
        }
        final int max_length=kenkov(s);
        int k ;
        for(k=1 ; k<=max_length ; ++k){
          if(check_disjoint(s,k)){
            System.out.println(k);
            continue MAINLOOP ;
          }
        }
        System.out.println("-1");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static    operation covconv( s : String) : String
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := s->characters() ;
     var sp : int ; sp := 0 ;
         var p : int ; p := 0 ; while p < a->size() do ( (      a[sp+1] := a[p+1]  ; sp := sp + 1 ; 
     while (p < a->size() & "aiueo"->indexOf(a[p+1])-1 = -1) do     p := p + 1 ; )  ;     p := p + 1 ) ; 
     return StringLib.newString(a, 0, sp) );
  static    operation kenkov( s : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var rvalue : int ; rvalue := 0 ;
         var i : int ; i := 0 ; while i < s->size() do (     rvalue := Set{rvalue, s[i+1]->size()}->max() ;  ;     i := i + 1 ) ; 
     return rvalue );
  static    operation check_disjoint( s : Sequence(String), k : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() do ( (     var s1 : String ; s1 := s[i+1].subrange(0+1,Set{s[i+1]->size(), k}->min()) ;
         var j : int ; j := i + 1 ; while j < s->size() do ( (     var s2 : String ; s2 := s[j+1].subrange(0+1,Set{s[j+1]->size(), k}->min()) ;
     if (s1 = s2) then     return false else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : Scanner := Scanner.newScanner(OclFile["System.in"]) ;
 (       while true do ( (     var n : int ; n := sc.nextInt() ;
     if (n = 0) then     break else skip ; 
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := covconv(sc.next()) )  ;     i := i + 1 ) ; 
    var max_length : int ; max_length := kenkov(s) ;
    var k : int ;
        k := 1 ; while k <= max_length do ( (     if (check_disjoint(s, k)) then (     OclFile["System.out"].println(k) ; 
     continue ) else skip )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println("-1") ; 
 )  ) ; ))  );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static String getAbbrName(String name,int k){
    StringBuilder sb=new StringBuilder();
    sb.append(name.charAt(0));
    String vowels="aiueo" ;
    for(int i=0 ; i<name.length()-1 ; i++){
      char c=name.charAt(i);
      if(sb.length()==k)break ;
      if(vowels.indexOf(c)!=-1){
        char nc=name.charAt(i+1);
        sb.append(nc);
      }
    }
    return sb.toString();
  }
  public static boolean canGiveUniqueName(List<String>names,int k){
    Set<String>abbrSet=new HashSet<>();
    for(String name : names){
      String abbr=getAbbrName(name,k);
      if(abbrSet.contains(abbr))return false ;
      abbrSet.add(abbr);
    }
    return true ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      sc.nextLine();
      if(n==0)break ;
      List<String>names=new ArrayList<>();
      while(n>0){
        String name=sc.nextLine();
        names.add(name);
        n--;
      }
      int minK=-1 ;
      for(int k=1 ; k<=50 ; k++){
        if(canGiveUniqueName(names,k)){
          minK=k ;
          break ;
        }
      }
      System.out.println(minK);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation getAbbrName( name : String, k : int) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     sb := sb + StringLib.newString(name->at(0+1)) ; 
    var vowels : String ; vowels := "aiueo" ;
        var i : int ; i := 0 ; while i < name->size() - 1 do ( (     var c : String ; c := name->at(i+1) ;
     if (sb->size() = k) then     break else skip ; 
     if (vowels->indexOf(c)-1 /= -1) then (     var nc : String ; nc := name->at(i + 1+1) ;
     sb := sb + StringLib.newString(nc) ) else skip )  ;     i := i + 1 ) ; 
    return sb+"" 
 );
  static   operation canGiveUniqueName( names : Sequence(String), k : int) : boolean
  pre: true
  post: true
  activity: (     var abbrSet : Set(String) ; abbrSet := Set{} ;
     for (name : names) do ( (     var abbr : String ; abbr := getAbbrName(name, k) ;
     if (abbrSet->includes(abbr)) then     return false else skip ; 
     abbrSet := abbrSet->including(abbr) )  ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     skip ; 
    if (n = 0) then     break else skip ; 
    var names : Sequence(String) ; names := Sequence{} ;
    while (n > 0) do (     var name : String ; name := sc.nextLine() ;
     names := names->including(name) ; 
     n := n - 1 ) ; 
    var minK : int ; minK := -1 ;
        var k : int ; k := 1 ; while k <= 50 do ( (     if (canGiveUniqueName(names, k)) then (     minK := k ; 
     break ) else skip )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(minK) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      while(sc.hasNext()){
        int n=sc.nextInt();
        if(n==0)break ;
        String[] code=new String[n+1];
        for(int i=0 ; i<n ; i++){
          String str=sc.next();
          String s="" ;
          s+=String.valueOf(str.charAt(0));
          for(int j=0 ; j<str.length()-1 ; j++){
            if(str.charAt(j)=='a' || str.charAt(j)=='i' || str.charAt(j)=='u' || str.charAt(j)=='e' || str.charAt(j)=='o'){
              s+=String.valueOf(str.charAt(j+1));
            }
          }
          code[i]=s ;
        }
        int c=0 ;
        int ans=0 ;
        for(int k=0 ; k<50 ; k++){
          c=0 ;
          for(int i=0 ; i<n ; i++){
            for(int j=i+1 ; j<n ; j++){
              String str1=code[i] .substring(0,Math.min(k+1,code[i] .length()));
              String str2=code[j] .substring(0,Math.min(k+1,code[j] .length()));
              if(str1.equals(str2)){
                c=1 ;
              }
            }
          }
          if(c==0){
            ans=k+1 ;
            break ;
          }
        }
        if(c>0){
          System.out.println(-1);
        }
        else {
          System.out.println(ans);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var code : Sequence(String) ; code := Integer.subrange(1,n + 1)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := sc.getCurrent() ;
     var s : String ; s := "" ;
    s := s+(((str->at(0+1)) + "")) ; 
        var j : int ; j := 0 ; while j < str->size() - 1 do ( (     if (str->at(j+1) = 'a' or str->at(j+1) = 'i' or str->at(j+1) = 'u' or str->at(j+1) = 'e' or str->at(j+1) = 'o') then (     s := s+(((str->at(j + 1+1)) + "")) ) else skip )  ;     j := j + 1 ) ; 
    code[i+1] := s ; 
 )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
    var ans : int ; ans := 0 ;
        var k : int ; k := 0 ; while k < 50 do ( (     c := 0 ; 
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var str1 : String ; str1 := code[i+1].subrange(0+1,Set{k + 1, code[i+1]->size()}->min()) ;
     var str2 : String ; str2 := code[j+1].subrange(0+1,Set{k + 1, code[j+1]->size()}->min()) ;
     if (str1 = str2) then (     c := 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (c = 0) then (     ans := k + 1 ; 
     break ) else skip )  ;     k := k + 1 ) ; 
    if (c > 0) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(ans) ) ;  
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.math.BigInteger.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import java.math.*;
import java.util.*;
public class D {
  char[] cs ;
  int n ;
  public static void main(String[] args){
    new D().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int on=sc.nextInt();
    for(int o=1 ; o<=on ; o++){
      System.out.printf("Case #%d: ",o);
      n=sc.nextInt();
      cs=sc.next().toCharArray();
      System.out.println(permRec(new int[n],new boolean[n],0));
    }
  }
  int permRec(int[] a,boolean[] used,int p){
    if(p==a.length){
      char last=0 ;
      int res=0 ;
      for(int i=0 ; i<cs.length ; i+=n){
        for(int j=0 ; j<n ; j++){
          char c=cs[i+a[j] ];
          if(c!=last){
            res++;
            last=c ;
          }
        }
      }
      return res ;
    }
    else {
      int res=Integer.MAX_VALUE ;
      for(a[p]=0 ; a[p]<used.length ; a[p]++)if(! used[a[p] ]){
        used[a[p] ]=true ;
        res=min(res,permRec(a,used,p+1));
        used[a[p] ]=false ;
      }
      return res ;
    }
  }
  void debug(Object...os){
    System.err.println(deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
   attribute cs : Sequence(String);
   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     D.newD().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var on : int ; on := sc.getCurrent()->toInteger() ;
         var o : int ; o := 1 ; while o <= on do ( (     OclFile["System.out"].printf("Case #%d: ", o) ; 
     n := sc.getCurrent()->toInteger() ; 
     cs := sc.getCurrent()->characters() ; 
     OclFile["System.out"].println(permRec(Integer.subrange(1,n)->collect(0), Integer.subrange(1,n)->collect(false), 0)) )  ;     o := o + 1 ) );
   operation permRec( a : Sequence(int), used : Sequence(boolean), p : int) : int
  pre: true
  post: true
  activity: (     if (p = a->size()) then (     var last : String ; last := 0 ;
     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < cs->size() do ( (         var j : int ; j := 0 ; while j < n do ( (     var c : String ; c := cs[i + a[j+1]+1] ;
     if (c /= last) then (     res := res + 1 ; 
     last := c ) else skip )  ;     j := j + 1 ) )  ;     i := i+(n) ) ; 
     return res ) else (     var res : int ; res := 2147483647 ;
         a[p+1] := 0 ; while a[p+1] < used->size() do (     if (not(used[a[p+1]+1])) then (     used[a[p+1]+1] := true ; 
     res := Set{res, permRec(a, used, p + 1)}->min() ; 
     used[a[p+1]+1] := false ) else skip ;  ;     a[p+1] := a[p+1] + 1 ) ; 
     return res ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.util.Scanner ;
public class D {
  static Scanner in ;
  static PrintWriter out ;
  public static void main(String[] args)throws FileNotFoundException {
    in=new Scanner(new File("input.txt"));
    out=new PrintWriter("output.txt");
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      out.println("Case #"+(i+1)+": "+new D().solve());
    }
    out.close();
  }
  int k ;
  String s ;
  int[] p ;
  boolean[] z ;
  int res ;
  private Object solve(){
    k=in.nextInt();
    s=in.next();
    p=new int[k];
    z=new boolean[k];
    res=s.length()+1 ;
    bt(0);
    return ""+res ;
  }
  private void bt(int i){
    if(i==k){
      char pc='.' ;
      int r=0 ;
      for(int j=0 ; j<s.length()/k ; j++){
        for(int t=0 ; t<k ; t++){
          char c=s.charAt(j*k+p[t]);
          if(c!=pc){
            pc=c ;
            r++;
          }
        }
      }
      res=Math.min(res,r);
    }
    else {
      for(p[i]=0 ; p[i]<k ; p[i]++)if(! z[p[i] ]){
        z[p[i] ]=true ;
        bt(i+1);
        z[p[i] ]=false ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile("input.txt")) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ; 
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
   attribute k : int;
   attribute s : String;
   attribute p : Sequence(int);
   attribute z : Sequence(boolean);
   attribute res : int;
   operation solve() : OclAny
  pre: true
  post: true
  activity: (     k := in.getCurrent()->toInteger() ; 
     s := in.getCurrent() ; 
    p := Integer.subrange(1,k)->collect(0) ; 
    z := Integer.subrange(1,k)->collect(false) ; 
    res := s->size() + 1 ; 
    execute bt(0) ; 
    return "" + res 
 );
   operation bt( i : int) : void
  pre: true
  post: true
  activity: (     if (i = k) then (     var pc : String ; pc := '.' ;
     var r : int ; r := 0 ;
         var j : int ; j := 0 ; while j < s->size() / k do ( (         var t : int ; t := 0 ; while t < k do ( (     var c : String ; c := s->at(j * k + p[t+1]+1) ;
     if (c /= pc) then (     pc := c ; 
     r := r + 1 ) else skip )  ;     t := t + 1 ) )  ;     j := j + 1 ) ; 
     res := Set{res, r}->min() ) else (         p[i+1] := 0 ; while p[i+1] < k do (     if (not(z[p[i+1]+1])) then (     z[p[i+1]+1] := true ; 
     execute bt(i + 1) ; 
     z[p[i+1]+1] := false ) else skip ;  ;     p[i+1] := p[i+1] + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static final int INF=Integer.MAX_VALUE/4 ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int[] red=new int[2*N];
    int[] blue=new int[2*N];
    Arrays.fill(red,INF);
    Arrays.fill(blue,INF);
    for(int i=0 ; i<N ; i++){
      red[scanner.nextInt()]=scanner.nextInt();
    }
    for(int i=0 ; i<N ; i++){
      blue[scanner.nextInt()]=scanner.nextInt();
    }
    int ans=0 ;
    for(int i=0 ; i<2*N ; i++){
      if(blue[i]!=INF){
        int maxY=-1 ;
        int maxIdx=-1 ;
        for(int j=0 ; j<i ; j++){
          if(red[j]!=INF && red[j]<blue[i] && maxY<red[j]){
            maxY=red[j];
            maxIdx=j ;
          }
        }
        if(maxIdx>=0){
          ans++;
          red[maxIdx]=INF ;
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := 2147483647 / 4;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var red : Sequence(int) ; red := Integer.subrange(1,2 * N)->collect(0) ;
    var blue : Sequence(int) ; blue := Integer.subrange(1,2 * N)->collect(0) ;
    red := red->collect(INF) ; 
    blue := blue->collect(INF) ; 
        var i : int ; i := 0 ; while i < N do ( (     red[scanner.getCurrent()->toInteger()+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     blue[scanner.getCurrent()->toInteger()+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 2 * N do ( (     if (blue[i+1] /= INF) then (     var maxY : int ; maxY := -1 ;
     var maxIdx : int ; maxIdx := -1 ;
         var j : int ; j := 0 ; while j < i do ( (     if (red[j+1] /= INF & red[j+1] < blue[i+1] & maxY < red[j+1]) then (     maxY := red[j+1] ; 
     maxIdx := j ) else skip )  ;     j := j + 1 ) ; 
     if (maxIdx >= 0) then (     ans := ans + 1 ; 
     red[maxIdx+1] := INF ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Stack ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    while(true){
      int n=Integer.parseInt(scan.next());
      int m=Integer.parseInt(scan.next());
      if(n==0)break ;
      V[] ver=new V[n];
      for(int i=0 ; i<n ; i++)ver[i]=new V();
      boolean[] used=new boolean[n];
      for(int i=0 ; i<m ; i++){
        int a=Integer.parseInt(scan.next())-1 ;
        int b=Integer.parseInt(scan.next())-1 ;
        ver[a] .to.add(b);
        ver[b] .to.add(a);
      }
      Stack<int[]>stk=new Stack<int[]>();
      stk.push(new int[] {
        0,0 }
);
        used[0]=true ;
        int ans=0 ;
        while(! stk.isEmpty()){
          int[] p=stk.pop();
          int num=p[0],deep=p[1];
          ans++;
          if(deep!=2)for(Integer i : ver[num] .to){
            if(! used[i]){
              used[i]=true ;
              stk.push(new int[] {
                i,deep+1 }
);
              }
            }
          }
          out.println(ans-1);
        }
        out.flush();
      }
    }
    class V {
      HashSet<Integer>to=new HashSet<Integer>();
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     while (true) do (     var n : int ; n := (scan.getCurrent())->toInteger() ;
     var m : int ; m := (scan.getCurrent())->toInteger() ;
    if (n = 0) then     break else skip ; 
    var ver : Sequence(V) ; ver := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     ver[i+1] := V.newV() ;  ;     i := i + 1 ) ; 
    var used : Sequence(boolean) ; used := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := (scan.getCurrent())->toInteger() - 1 ;
     var b : int ; b := (scan.getCurrent())->toInteger() - 1 ;
     ver[a+1].to->excludes(b) ; 
     ver[b+1].to->excludes(a) )  ;     i := i + 1 ) ; 
    var stk : Sequence(Sequence(int)) ; stk := Sequence{} ;
    stk := stk->append(Sequence{0,0}) ; 
    used[0+1] := true ; 
    var ans : int ; ans := 0 ;
    while (not(stk->isEmpty())) do (     var p : Sequence(int) ; p := stk->last() ;
     var num : int ; num := p[0+1] ;
    var deep : int ; deep := p[1+1] ;
     ans := ans + 1 ; 
     if (deep /= 2) then     for (i : ver[num+1].to) do ( (     if (not(used[i+1])) then (     used[i+1] := true ; 
     stk := stk->append(Sequence{i,deep + 1}) ) else skip )  ) ; else skip ) ; 
    skip ; 
 ) ; 
     skip );
}
class V {
   attribute to : Set(int) := Set{};
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n,m ;
    int a[];
    int friendA[];
    int friendB[];
    int count ;
    n=sc.nextInt();
    m=sc.nextInt();
    while(n+m!=0){
      a=new int[n];
      a[0]=1 ;
      for(int i=1 ; i<n ; i++){
        a[i]=0 ;
      }
      friendA=new int[m];
      friendB=new int[m];
      for(int i=0 ; i<m ; i++){
        friendA[i]=sc.nextInt();
        friendB[i]=sc.nextInt();
        if(friendA[i]==1){
          a[friendB[i]-1]=2 ;
        }
      }
      for(int i=0 ; i<m ; i++){
        if(a[friendA[i]-1]==2 && a[friendB[i]-1]==0){
          a[friendB[i]-1]=3 ;
        }
        else if(a[friendB[i]-1]==2 && a[friendA[i]-1]==0){
          a[friendA[i]-1]=3 ;
        }
      }
      count=-1 ;
      for(int i=0 ; i<n ; i++){
        if(a[i]!=0){
          count++;
        }
      }
      System.out.println(count);
      n=sc.nextInt();
      m=sc.nextInt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var m : int ;
    var a : Sequence(int) ;
    var friendA : Sequence(int) ;
    var friendB : Sequence(int) ;
    var count : int ;
    n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
    while (n + m /= 0) do (     a := Integer.subrange(1,n)->collect(0) ; 
     a[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < n do ( (     a[i+1] := 0 )  ;     i := i + 1 ) ; 
    friendA := Integer.subrange(1,m)->collect(0) ; 
    friendB := Integer.subrange(1,m)->collect(0) ; 
        var i : int ; i := 0 ; while i < m do ( (     friendA[i+1] := sc.getCurrent()->toInteger() ; 
     friendB[i+1] := sc.getCurrent()->toInteger() ; 
     if (friendA[i+1] = 1) then (     a[friendB[i+1] - 1+1] := 2 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     if (a[friendA[i+1] - 1+1] = 2 & a[friendB[i+1] - 1+1] = 0) then (     a[friendB[i+1] - 1+1] := 3 ) else     if (a[friendB[i+1] - 1+1] = 2 & a[friendA[i+1] - 1+1] = 0) then (     a[friendA[i+1] - 1+1] := 3 ) else skip ; )  ;     i := i + 1 ) ; 
    count := -1 ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] /= 0) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ThreeFriends {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    while(test-->0){
      long a=sc.nextLong();
      long b=sc.nextLong();
      long c=sc.nextLong();
      long absValue=Math.abs(a-b)+Math.abs(a-c)+Math.abs(b-c);
      long result=Math.max(absValue-4,0);
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ThreeFriends {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
    var c : long ; c := sc.getCurrent()->toLong() ;
    var absValue : long ; absValue := if a - b < 0 then -(a - b) else a - b endif + if a - c < 0 then -(a - c) else a - c endif + if b - c < 0 then -(b - c) else b - c endif ;
    var result : long ; result := Set{absValue - 4, 0}->max() ;
    OclFile["System.out"].println(result) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    int n,m,count=0,i ;
    int a[]=new int[10000];
    int b[]=new int[10000];
    Set<Integer>s=new TreeSet<Integer>();
    Set<Integer>test=new TreeSet<Integer>();
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    m=sc.nextInt();
    while(true){
      if(n==0 && m==0)break ;
      for(i=0 ; i<m ; i++){
        a[i]=sc.nextInt();
        b[i]=sc.nextInt();
        if(a[i]==1){
          count++;
          s.add(b[i]);
          test.add(b[i]);
        }
      }
      for(i=0 ; i<m ; i++){
        if(s.contains(a[i])&& ! test.contains(b[i])&& a[i]!=1 && b[i]!=1){
          count++;
          test.add(b[i]);
        }
        else if(! test.contains(a[i])&& s.contains(b[i])&& a[i]!=1 && b[i]!=1){
          count++;
          test.add(a[i]);
        }
      }
      System.out.println(count);
      n=sc.nextInt();
      m=sc.nextInt();
      s.clear();
      test.clear();
      count=0 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var m : int ;
    var count : int ; count := 0 ;
    var i : int ;
     var a : Sequence(int) ; a := Integer.subrange(1,10000)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,10000)->collect(0) ;
    var s : Set(int) ; s := Set{} ;
    var test : Set(int) ; test := Set{} ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
    while (true) do (     if (n = 0 & m = 0) then     break else skip ; 
         i := 0 ; while i < m do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() ; 
     if (a[i+1] = 1) then (     count := count + 1 ; 
     s := s->including(b[i+1]) ; 
     test := test->including(b[i+1]) ) else skip )  ;     i := i + 1 ) ; 
        i := 0 ; while i < m do ( (     if (s->includes(a[i+1]) & not(test->includes(b[i+1])) & a[i+1] /= 1 & b[i+1] /= 1) then (     count := count + 1 ; 
     test := test->including(b[i+1]) ) else     if (not(test->includes(a[i+1])) & s->includes(b[i+1]) & a[i+1] /= 1 & b[i+1] /= 1) then (     count := count + 1 ; 
     test := test->including(a[i+1]) ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
    s := s->intersection(Set{}) ; 
    test := test->intersection(Set{}) ; 
    count := 0 ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  int n,m ;
  LinkedList<Integer>[] friends ;
  @ SuppressWarnings("unchecked")void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      n=sc.nextInt();
      m=sc.nextInt();
      if((n | m)==0)break ;
      friends=new LinkedList[n];
      for(int i=0 ; i<n ; i++)friends[i]=new LinkedList<Integer>();
      for(int i=0 ; i<m ; i++){
        int a=sc.nextInt()-1 ;
        int b=sc.nextInt()-1 ;
        friends[a] .add(b);
        friends[b] .add(a);
      }
      HashSet<Integer>set=new HashSet<Integer>();
      for(int a : friends[0]){
        set.add(a);
        for(int b : friends[a])set.add(b);
      }
      System.out.println((set.size()==0 ? 0 : set.size()-1));
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute n : int;
   attribute friends : Sequence(Sequence(int));
     operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     n := sc.getCurrent()->toInteger() ; 
     m := sc.getCurrent()->toInteger() ; 
    if ((MathLib.bitwiseOr(n,m)) = 0) then     break else skip ; 
    friends := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do (     friends[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
     var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
     friends[a+1]->excludes(b) ; 
     friends[b+1]->excludes(a) )  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
    for (a : friends[0+1]) do ( (     set := set->including(a) ; 
     for (b : friends[a+1]) do (     set := set->including(b) ;  ) )  ) ; 
    OclFile["System.out"].println((if set->size() = 0 then 0 else set->size() - 1 endif)) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.nio.charset.MalformedInputException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      String s=sc.next();
      out.println(s.length());
    }
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var s : String ; s := sc.getCurrent() ;
     skip ) ;  ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication49 {
  public static void main(String[] args){
    Scanner read=new Scanner(System.in);
    long n=read.nextLong();
    while(n--!=0){
      String s=read.next();
      System.out.println(s.length());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication49 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : OclFile ; read := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := read.getCurrent()->toLong() ;
         while (n /= 0) do (    skip ; (     var s : String ; s := read.getCurrent() ;
     OclFile["System.out"].println(s->size()) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test267 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      char[] a=in.next().toCharArray();
      System.out.println(a.length);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test267 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : Sequence(String) ; a := in.getCurrent()->characters() ;
     OclFile["System.out"].println(a->size()) )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public List<Integer>topKFrequent(int[] nums,int k){
    HashMap<Integer,Integer>count=new HashMap();
    for(int n : nums){
      count.put(n,count.getOrDefault(n,0)+1);
    }
    PriorityQueue<Integer>heap=new PriorityQueue<Integer>((n1,n2)->count.get(n1)-count.get(n2));
    for(int n : count.keySet()){
      heap.add(n);
      if(heap.size()>k)heap.poll();
    }
    List<Integer>top_k=new LinkedList();
    while(! heap.isEmpty())top_k.add(heap.poll());
    Collections.reverse(top_k);
    return top_k ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation topKFrequent( nums : Sequence(int), k : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var count : Map(int,int) ; count := Map{} ;
     for (n : nums) do ( (     count := count->union(Map{n |-> (if count->keys()->contains(n) then count->at(n) else 0 endif) + 1}) )  ) ; 
    var heap : Sequence(int) ; heap := Sequence{}->union(lambda (n1 , n2) : OclAny in count->at(n1) - count->at(n2)) ;
    for (n : count->keys()) do ( (     heap := heap->including(n) ; 
     if (heap->size() > k) then     heap := heap->sort()->tail() ; else skip )  ) ; 
    var top_k : Sequence(int) ; top_k := Sequence{} ;
    while (not(heap->isEmpty())) do     top_k := top_k->including(heap->min()) ; ; 
    top_k := top_k->reverse() ; 
    return top_k 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class test222 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int a[]=new int[n];
      int b[]=new int[n];
      int max=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        int x=in.nextInt();
        if(x>a[i]){
          b[i]=a[i];
          a[i]=x ;
        }
        else {
          b[i]=x ;
        }
        if(b[i]>max){
          max=b[i];
        }
      }
      Arrays.sort(a);
      System.out.println(max*a[n-1]);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test222 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     if (x > a[i+1]) then (     b[i+1] := a[i+1] ; 
     a[i+1] := x ) else (     b[i+1] := x ) ;  
     if (b[i+1] > max) then (     max := b[i+1] ) else skip )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    OclFile["System.out"].println(max * a[n - 1+1]) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.HashMap ;
import java.util.Map ;
class GFG {
  static String Hex(int num){
    HashMap<Integer,Character>m=new HashMap<Integer,Character>();
    char digit='0' ;
    char c='a' ;
    for(int i=0 ; i<=15 ; i++){
      if(i<10){
        m.put(i,digit);
        digit++;
      }
      else {
        m.put(i,c);
        c++;
      }
    }
    String res="" ;
    if(num==0){
      return "0" ;
    }
    if(num>0){
      while(num!=0){
        res=m.get(num % 16)+res ;
        num/=16 ;
      }
    }
    else {
      int n=num ;
      while(n!=0){
        res=m.get(n % 16)+res ;
        n/=16 ;
      }
    }
    return res ;
  }
  public static void main(String[] args){
    int x=134,y=-1,z=-234 ;
    System.out.println("Hexa representation for");
    System.out.println(x+" is "+Hex(x));
    System.out.println(y+" is "+Hex(y));
    System.out.println(z+" is "+Hex(z));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Hex( num : int) : String
  pre: true
  post: true
  activity: (     var m : Map(int,String) ; m := Map{} ;
     var digit : String ; digit := '0' ;
    var c : String ; c := 'a' ;
        var i : int ; i := 0 ; while i <= 15 do ( (     if (i < 10) then (     m := m->union(Map{i |-> digit}) ; 
     digit := digit + 1 ) else (     m := m->union(Map{i |-> c}) ; 
     c := c + 1 ) )  ;     i := i + 1 ) ; 
    var res : String ; res := "" ;
    if (num = 0) then (     return "0" ) else skip ; 
    if (num > 0) then (     while (num /= 0) do (     res := m->at(num mod 16) + res ; 
     num := num/(16) ) ) else (     var n : int ; n := num ;
     while (n /= 0) do (     res := m->at(n mod 16) + res ; 
     n := n/(16) ) ) ;  
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 134 ;
    var y : int ; y := -1 ;
    var z : int ; z := -234 ;
     OclFile["System.out"].println("Hexa representation for") ; 
    OclFile["System.out"].println(x + " is " + Hex(x)) ; 
    OclFile["System.out"].println(y + " is " + Hex(y)) ; 
    OclFile["System.out"].println(z + " is " + Hex(z)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if((n | m)==0)break ;
      boolean infect[]=new boolean[n+1];
      infect[1]=true ;
      Queue<Data>q=new PriorityQueue<Data>();
      for(int i=0 ; i<m ; i++){
        int t=sc.nextInt();
        int s=sc.nextInt();
        int d=sc.nextInt();
        q.add(new Data(t,s,d));
      }
      while(! q.isEmpty()){
        Data data=q.poll();
        int s=data.s ;
        int d=data.d ;
        if(infect[s]){
          infect[d]=true ;
        }
      }
      int ans=0 ;
      for(int i=1 ; i<=n ; i++){
        if(infect[i])ans++;
      }
      System.out.println(ans);
    }
  }
}
class Data implements Comparable<Data>{
  public int s ;
  public int d ;
  public int t ;
  Data(int t,int s,int d){
    this.t=t ;
    this.s=s ;
    this.d=d ;
  }
  public int compareTo(Data a){
    return t-a.t ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,m)) = 0) then     break else skip ; 
    var infect : Sequence(boolean) ; infect := Integer.subrange(1,n + 1)->collect(false) ;
    infect[1+1] := true ; 
    var q : Sequence(Data) ; q := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var s : int ; s := sc.getCurrent()->toInteger() ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
     q := q->including(Data.newData(t, s, d)) )  ;     i := i + 1 ) ; 
    while (not(q->isEmpty())) do (     var data : Data ; data := q->min() ;
     var s : int ; s := data.s ;
     var d : int ; d := data.d ;
     if (infect[s+1]) then (     infect[d+1] := true ) else skip ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (infect[i+1]) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}
class Data implements Comparable<Data> {
   attribute s : int;
   attribute d : int;
   attribute t : int;
   static operation newData( t : int, s : int, d : int) : Data
  pre: true
  post: true
  activity:
  ( var self : Data ;
    self := createData();
    self.initialise(t, s,d);
    return self );
  operation initialise( t : int, s : int, d : int) : void
  pre: true  post: true
  activity: (     self.t := t ; 
     self.s := s ; 
     self.d := d );
   operation compareTo( a : Data) : int
  pre: true
  post: true
  activity: (     return t - a.t );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Comparator ;
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=parseInt(line.substring(0,line.indexOf(' ')));
      int m=parseInt(line.substring(line.indexOf(' ')+1));
      if((n | m)==0)break ;
      boolean[] ps=new boolean[n+1];
      Queue<int[]>ts=new PriorityQueue<int[]>(11,new Comparator<int[]>(){
        @ Override public int compare(int[] o1,int[] o2){
          return o1[0]-o2[0];
        }
      }
);
      StringTokenizer st ;
      for(int i=0 ; i<m ; i++){
        st=new StringTokenizer(br.readLine());
        int t,s,d ;
        t=parseInt(st.nextToken());
        s=parseInt(st.nextToken());
        d=parseInt(st.nextToken());
        ts.offer(new int[] {
          t,s,d }
);
        }
        ps[1]=true ;
        int count=1 ;
        while(! ts.isEmpty()){
          int[] t=ts.poll();
          if(ps[t[1] ] && ! ps[t[2] ]){
            ps[t[2] ]=true ;
            count++;
          }
        }
        System.out.println(count);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := parseInt(line.subrange(0+1,line->indexOf(' ')-1)) ;
     var m : int ; m := parseInt(line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1)) ;
    if ((MathLib.bitwiseOr(n,m)) = 0) then     break else skip ; 
    var ps : Sequence(boolean) ; ps := Integer.subrange(1,n + 1)->collect(false) ;
    var ts : Sequence(Sequence(int)) ; ts := Sequence{} ;
    var st : OclIterator ;
        var i : int ; i := 0 ; while i < m do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var t : int ;
    var s : int ;
    var d : int ;
    t := (st.next() + "")->toInteger() ; 
    s := (st.next() + "")->toInteger() ; 
    d := (st.next() + "")->toInteger() ; 
    ts := ts->including(Sequence{t,s,d}) ; 
 )  ;     i := i + 1 ) ; 
    ps[1+1] := true ; 
    var count : int ; count := 1 ;
    while (not(ts->isEmpty())) do (     var t : Sequence(int) ; t := ts->min() ;
     if (ps[t[1+1]+1] & not(ps[t[2+1]+1])) then (     ps[t[2+1]+1] := true ; 
     count := count + 1 ) else skip ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF709A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int b=sc.nextInt();
    int d=sc.nextInt();
    int a,sum=0,count=0 ;
    while(n-->0){
      a=sc.nextInt();
      if(a<=b){
        sum+=a ;
      }
      if(sum>d){
        sum=0 ;
        count++;
      }
    }
    System.out.println(count);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF709A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var a : int ;
    var sum : int ; sum := 0 ;
    var count : int ; count := 0 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     a := sc.getCurrent()->toInteger() ; 
     if (a <= b) then (     sum := sum+(a) ) else skip ; 
     if (sum > d) then (     sum := 0 ; 
     count := count + 1 ) else skip ) ;  ) ;  
    OclFile["System.out"].println(count) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
class Main {
  public static Scanner sc=new Scanner(in);
  public static Random rand=new Random();
  class Packet {
    int t ;
    int from ;
    int to ;
    Packet(int t,int from,int to){
      this.t=t ;
      this.from=from ;
      this.to=to ;
    }
  }
  public void run(){
    while(true){
      int N=sc.nextInt(),M=sc.nextInt();
      if(N==0)return ;
      Packet[] ps=new Packet[M];
      for(int i=0 ; i<M ; i++){
        ps[i]=new Packet(sc.nextInt(),sc.nextInt()-1,sc.nextInt()-1);
      }
      Arrays.sort(ps,new Comparator<Packet>(){
        @ Override public int compare(Packet o1,Packet o2){
          return o1.t-o2.t ;
        }
      }
);
      boolean[] infected=new boolean[N];
      infected[0]=true ;
      for(int i=0 ; i<M ; i++){
        if(infected[ps[i] .from])infected[ps[i] .to]=true ;
      }
      int res=0 ;
      for(int i=0 ; i<N ; i++){
        if(infected[i])res++;
      }
      ln(res);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  public int[] nextIntArray(int n){
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=sc.nextInt();
    }
    return res ;
  }
  public static void pr(Object o){
    out.print(o);
  }
  public static void ln(Object o){
    out.println(o);
  }
  public static void ln(){
    out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(in);
  static   attribute rand : OclRandom := OclRandom.newOclRandom();
 class Packet {
   attribute t : int;
   attribute from : int;
   attribute to : int;
   static operation newPacket( t : int, from : int, to : int) : Packet
  pre: true
  post: true
  activity:
  ( var self : Packet ;
    self := createPacket();
    self.initialise(t, from,to);
    return self );
  operation initialise( t : int, from : int, to : int) : void
  pre: true  post: true
  activity: (     self.t := t ; 
     self.from := from ; 
     self.to := to );
}
   operation run() : void
  pre: true
  post: true
  activity: (     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
     if (N = 0) then     return else skip ; 
    var ps : Sequence(Packet) ; ps := Integer.subrange(1,M)->collect(null) ;
        var i : int ; i := 0 ; while i < M do ( (     ps[i+1] := Packet.newPacket(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger() - 1, sc.getCurrent()->toInteger() - 1) )  ;     i := i + 1 ) ; 
    ps := OclComparator.sortWith(ps, OclComparator<Packet>.newOclComparator()) ; 
    var infected : Sequence(boolean) ; infected := Integer.subrange(1,N)->collect(false) ;
    infected[0+1] := true ; 
        var i : int ; i := 0 ; while i < M do ( (     if (infected[ps[i+1].from+1]) then     infected[ps[i+1].to+1] := true ; else skip )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (infected[i+1]) then     res := res + 1 ; else skip )  ;     i := i + 1 ) ; 
    execute ln(res) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return res );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     out.println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  Scanner sc ;
  Main(){
    sc=new Scanner(System.in);
  }
  class com implements Comparable<com>{
    int t ;
    int s ;
    int d ;
    public int compareTo(com tar){
      return t-tar.t ;
    }
    com(int t,int s,int d){
      this.t=t ;
      this.s=s ;
      this.d=d ;
    }
  }
  public void run(){
    for(; ; ){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if(n==0){
        break ;
      }
      TreeSet<Integer>hl=new TreeSet<Integer>();
      com[] arr=new com[m];
      for(int i=0 ; i<m ; i++){
        com a=new com(sc.nextInt(),sc.nextInt(),sc.nextInt());
        arr[i]=a ;
      }
      Arrays.sort(arr);
      hl.add(1);
      for(com c : arr){
        int s=c.s ;
        int d=c.d ;
        if(hl.contains(s)){
          hl.add(d);
        }
      }
      System.out.println(hl.size());
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
 class com implements Comparable<com> {
   attribute t : int;
   attribute s : int;
   attribute d : int;
   operation compareTo( tar : com) : int
  pre: true
  post: true
  activity: (     return t - tar.t );
   static operation newcom( t : int, s : int, d : int) : com
  pre: true
  post: true
  activity:
  ( var self : com ;
    self := createcom();
    self.initialise(t, s,d);
    return self );
  operation initialise( t : int, s : int, d : int) : void
  pre: true  post: true
  activity: (     self.t := t ; 
     self.s := s ; 
     self.d := d );
}
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if (n = 0) then (     break ) else skip ; 
    var hl : Set(int) ; hl := Set{} ;
    var arr : Sequence(com) ; arr := Integer.subrange(1,m)->collect(null) ;
        var i : int ; i := 0 ; while i < m do ( (     var a : com ; a := com.newcom(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) ;
     arr[i+1] := a )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    hl := hl->including(1) ; 
    for (c : arr) do ( (     var s : int ; s := c.s ;
     var d : int ; d := c.d ;
     if (hl->includes(s)) then (     hl := hl->including(d) ) else skip )  ) ; 
    OclFile["System.out"].println(hl->size()) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void sort(String a[],int n){
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        if((a[i]+a[j]).compareTo(a[j]+a[i])>0){
          String s=a[i];
          a[i]=a[j];
          a[j]=s ;
        }
      }
    }
  }
  static String lexsmallest(String a[],int n){
    sort(a,n);
    String answer="" ;
    for(int i=0 ; i<n ; i++)answer+=a[i];
    return answer ;
  }
  public static void main(String args[]){
    String a[]={
      "c","cb","cba" };
      int n=3 ;
      System.out.println("lexiographically smallest string="+lexsmallest(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sort( a : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if ((a[i+1] + a[j+1])->compareTo(a[j+1] + a[i+1]) > 0) then (     var s : String ; s := a[i+1] ;
     a[i+1] := a[j+1] ; 
     a[j+1] := s ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation lexsmallest( a : Sequence(String), n : int) : String
  pre: true
  post: true
  activity: (     execute sort(a, n) ; 
     var answer : String ; answer := "" ;
         var i : int ; i := 0 ; while i < n do (     answer := answer+(a[i+1]) ;  ;     i := i + 1 ) ; 
     return answer );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := Sequence{"c","cb","cba"} ;
     var n : int ; n := 3 ;
     OclFile["System.out"].println("lexiographically smallest string=" + lexsmallest(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CF907B {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    String S[]=new String[28];
    for(int i=1 ; i<28 ; i++)S[i]=sc.next();
    int m=sc.nextInt()% 3,n=sc.nextInt()% 3 ;
    m=m==0 ? 3 : m ;
    n=n==0 ? 3 : n ;
    m=(m-1)*9+n ;
    if(S[m] .contains(".")|| S[m+3] .contains(".")|| S[m+6] .contains(".")){
      S[m]=S[m] .replace(".","!");
      S[m+3]=S[m+3] .replace(".","!");
      S[m+6]=S[m+6] .replace(".","!");
    }
    else {
      for(int i=1 ; i<28 ; i++)S[i]=S[i] .replace(".","!");
    }
    out(S);
  }
  static void out(String[] S){
    for(int i=1 ; i<28 ; i++){
      System.out.print(S[i]+" ");
      if((i+1)% 3==1)System.out.println("");
      if((i+1)% 9==1)System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF907B {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : Sequence(String) ; S := Integer.subrange(1,28)->collect(null) ;
         var i : int ; i := 1 ; while i < 28 do (     S[i+1] := sc.getCurrent() ;  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() mod 3 ;
    var n : int ; n := sc.getCurrent()->toInteger() mod 3 ;
    m := if m = 0 then 3 else m endif ; 
    n := if n = 0 then 3 else n endif ; 
    m := (m - 1) * 9 + n ; 
    if (S[m+1]->includes(".") or S[m + 3+1]->includes(".") or S[m + 6+1]->includes(".")) then (     S[m+1] := S[m+1].replace(".", "!") ; 
     S[m + 3+1] := S[m + 3+1].replace(".", "!") ; 
     S[m + 6+1] := S[m + 6+1].replace(".", "!") ) else (         var i : int ; i := 1 ; while i < 28 do (     S[i+1] := S[i+1].replace(".", "!") ;  ;     i := i + 1 ) ) ;  
    execute out(S) ; 
 );
  static   operation out( S : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < 28 do ( (     OclFile["System.out"].print(S[i+1] + " ") ; 
     if ((i + 1) mod 3 = 1) then     OclFile["System.out"].println("") ; else skip ; 
     if ((i + 1) mod 9 = 1) then     OclFile["System.out"].println("") ; else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class first {
  public static void main(String Args[]){
    Scanner sc=new Scanner(System.in);
    int n ;
    n=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    if(arr[n-1]==1){
      for(int j=n-2 ; j>=0 ; j--){
        if(arr[j]==0){
          System.out.print(j+1);
          System.exit(0);
        }
      }
    }
    else {
      for(int j=n-2 ; j>=0 ; j--){
        if(arr[j]==1){
          System.out.print(j+1);
          System.exit(0);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class first {
  static   operation main( Args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    n := sc.getCurrent()->toInteger() ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (arr[n - 1+1] = 1) then (         var j : int ; j := n - 2 ; while j >= 0 do ( (     if (arr[j+1] = 0) then (     OclFile["System.out"].print(j + 1) ; 
 OclProcess.exit(0) ) else skip )  ;     j := j - 1 ) ) else (         var j : int ; j := n - 2 ; while j >= 0 do ( (     if (arr[j+1] = 1) then (     OclFile["System.out"].print(j + 1) ; 
 OclProcess.exit(0) ) else skip )  ;     j := j - 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1631A_MinMaxSwap {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int len=parseInt(input.nextLine());
      List<Integer>firstArray=new ArrayList<>();
      List<Integer>secondArray=new ArrayList<>();
      for(int i=0 ; i<len ; i++){
        firstArray.add(input.nextInt());
      }
      for(int i=0 ; i<len ; i++){
        secondArray.add(input.nextInt());
      }
      input.nextLine();
      List<Integer>biggerArray=getMaxArray(firstArray,secondArray);
      List<Integer>smallerArray=firstArray==biggerArray ? secondArray : firstArray ;
      int maxValue=Collections.max(biggerArray);
      int maxIndex=biggerArray.indexOf(maxValue);
      for(int i=0 ; i<len ; i++){
        int firstElement=biggerArray.get(i);
        int secondElement=smallerArray.get(i);
        if(i!=maxIndex && secondElement>firstElement){
          smallerArray.set(i,firstElement);
        }
      }
      int result=maxValue*Collections.max(smallerArray);
      System.out.println(result);
    }
  }
  private static List<Integer>getMaxArray(List<Integer>firstArray,List<Integer>secondArray){
    int first=Collections.max(firstArray);
    int second=Collections.max(secondArray);
    if(first>second){
      return firstArray ;
    }
    return secondArray ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1631A_MinMaxSwap {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var len : int ; len := parseInt(input.nextLine()) ;
     var firstArray : Sequence(int) ; firstArray := Sequence{} ;
    var secondArray : Sequence(int) ; secondArray := Sequence{} ;
        var i : int ; i := 0 ; while i < len do ( (     firstArray := firstArray->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < len do ( (     secondArray := secondArray->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    skip ; 
    var biggerArray : Sequence(int) ; biggerArray := getMaxArray(firstArray, secondArray) ;
    var smallerArray : Sequence(int) ; smallerArray := if firstArray = biggerArray then secondArray else firstArray endif ;
    var maxValue : int ; maxValue := .max(biggerArray) ;
    var maxIndex : int ; maxIndex := biggerArray->indexOf(maxValue)-1 ;
        var i : int ; i := 0 ; while i < len do ( (     var firstElement : int ; firstElement := biggerArray->at(i+1) ;
     var secondElement : int ; secondElement := smallerArray->at(i+1) ;
     if (i /= maxIndex & secondElement > firstElement) then (     smallerArray := smallerArray.setAt(i+1,firstElement) ) else skip )  ;     i := i + 1 ) ; 
    var result : int ; result := maxValue * .max(smallerArray) ;
    OclFile["System.out"].println(result) ; 
 ) ;  ) );
  static   operation getMaxArray( firstArray : Sequence(int), secondArray : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var first : int ; first := .max(firstArray) ;
     var second : int ; second := .max(secondArray) ;
     if (first > second) then (     return firstArray ) else skip ; 
     return secondArray );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import java.util.*;
public class Main {
  public static int ans(int arr[],int z,int o,int n){
    for(int i=0 ; i<n ; i++){
      if(arr[i]==1)o--;
      else z--;
      if(o==0 || z==0)return i+1 ;
    }
    return-1 ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    int arr[]=new int[t];
    int z=0,o=0 ;
    StringTokenizer st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<t ; i++){
      arr[i]=Integer.parseInt(st.nextToken());
      if(arr[i]==1)o++;
      else z++;
    }
    System.out.println(ans(arr,z,o,t));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation ans( arr : Sequence(int), z : int, o : int, n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 1) then     o := o - 1 else     z := z - 1 ; ;  
     if (o = 0 or z = 0) then     return i + 1 else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,t)->collect(0) ;
    var z : int ; z := 0 ;
    var o : int ; o := 0 ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < t do ( (     arr[i+1] := (st.next())->toInteger() ; 
     if (arr[i+1] = 1) then     o := o + 1 ; else     z := z + 1 ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans(arr, z, o, t)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Integer.min ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int n,a[]=new int[200000],s=0,m=0 ;
    Scanner in=new Scanner(System.in);
    n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    for(int i=n-1 ; i>=0 ; i--){
      if(a[i]==0){
        s=i+1 ;
        break ;
      }
    }
    for(int i=n-1 ; i>=0 ; i--){
      if(a[i]==1){
        m=i+1 ;
        break ;
      }
    }
    System.out.println(min(s,m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var a : Sequence(void) ; a := Integer.subrange(1,200000)->collect(0) ;
    var s : int ; s := 0 ;
    var m : int ; m := 0 ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := in.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (a[i+1] = 0) then (     s := i + 1 ; 
     break ) else skip )  ;     i := i - 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (a[i+1] = 1) then (     m := i + 1 ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(Set{s, m}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    for(int i=0 ; ; i++){
      String[] s=br.readLine().split(" ");
      int a=Integer.parseInt(s[0]);
      char[] op=s[1] .toCharArray();
      int b=Integer.parseInt(s[2]);
      if(op[0]=='?'){
        break ;
      }
      else if(op[0]=='+'){
        System.out.println(a+b);
      }
      else if(op[0]=='-'){
        System.out.println(a-b);
      }
      else if(op[0]=='*'){
        System.out.println(a*b);
      }
      else if(op[0]=='/'){
        System.out.println(a/b);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
         var i : int ; i := 0 ; while true do ( (     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
     var a : int ; a := (s[0+1])->toInteger() ;
    var op : Sequence(String) ; op := s[1+1]->characters() ;
    var b : int ; b := (s[2+1])->toInteger() ;
    if (op[0+1] = '?') then (     break ) else     if (op[0+1] = '+') then (     OclFile["System.out"].println(a + b) ) else     if (op[0+1] = '-') then (     OclFile["System.out"].println(a - b) ) else     if (op[0+1] = '*') then (     OclFile["System.out"].println(a * b) ) else     if (op[0+1] = '/') then (     OclFile["System.out"].println(a / b) ) else skip ; ;  ;  ;  ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Doors {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int amount=in.nextInt();
    int last1=1 ;
    int last0=1 ;
    for(int i=0 ; i<amount ; i++){
      int num=in.nextInt();
      if(num==0){
        last0=i+1 ;
      }
      else {
        last1=i+1 ;
      }
    }
    System.out.println(Math.min(last0,last1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Doors {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var amount : int ; amount := in.getCurrent()->toInteger() ;
    var last1 : int ; last1 := 1 ;
    var last0 : int ; last0 := 1 ;
        var i : int ; i := 0 ; while i < amount do ( (     var num : int ; num := in.getCurrent()->toInteger() ;
     if (num = 0) then (     last0 := i + 1 ) else (     last1 := i + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{last0, last1}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Sleep {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int H=sc.nextInt();
      int M=sc.nextInt();
      int min=H*60+M ;
      int ans=Integer.MAX_VALUE ;
      int ans1=Integer.MAX_VALUE ;
      int ans2=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; i++){
        int h=sc.nextInt();
        int m=sc.nextInt();
        int temp=h*60+m ;
        ans=temp-min ;
        if(ans>=0){
          ans1=Integer.min(temp-min,ans1);
        }
        else {
          ans2=Integer.min(temp-min,ans2);
        }
      }
      if(ans1!=Integer.MAX_VALUE){
        System.out.println(ans1/60+" "+ans1 % 60);
      }
      else {
        ans2=1440+ans2 ;
        System.out.println(ans2/60+" "+ans2 % 60);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sleep {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var min : int ; min := H * 60 + M ;
    var ans : int ; ans := 2147483647 ;
    var ans1 : int ; ans1 := 2147483647 ;
    var ans2 : int ; ans2 := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     var h : int ; h := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var temp : int ; temp := h * 60 + m ;
    ans := temp - min ; 
    if (ans >= 0) then (     ans1 := Set{temp - min, ans1}->min() ) else (     ans2 := Set{temp - min, ans2}->min() ) ;  
 )  ;     i := i + 1 ) ; 
    if (ans1 /= 2147483647) then (     OclFile["System.out"].println(ans1 / 60 + " " + ans1 mod 60) ) else (     ans2 := 1440 + ans2 ; 
     OclFile["System.out"].println(ans2 / 60 + " " + ans2 mod 60) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class11 {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int h=sc.nextInt();
      int m=sc.nextInt();
      int i,min=1000000,tot=h*60+m ;
      for(i=0 ; i<n ; i++){
        int x=sc.nextInt();
        int y=sc.nextInt();
        int t2=x*60+y ;
        int diff=t2-tot ;
        if(diff<0)diff+=1440 ;
        min=Math.min(diff,min);
      }
      int ans1=min/60 ;
      int ans2=min-ans1*60 ;
      System.out.println(ans1+" "+ans2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class11 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var i : int ;
    var min : int ; min := 1000000 ;
    var tot : int ; tot := h * 60 + m ;
        i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var t2 : int ; t2 := x * 60 + y ;
    var diff : int ; diff := t2 - tot ;
    if (diff < 0) then     diff := diff+(1440) ; else skip ; 
    min := Set{diff, min}->min() ; 
 )  ;     i := i + 1 ) ; 
    var ans1 : int ; ans1 := min / 60 ;
    var ans2 : int ; ans2 := min - ans1 * 60 ;
    OclFile["System.out"].println(ans1 + " " + ans2) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class EveryoneLikeSleeping {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int numberOfSets=scan.nextInt();
    for(int i=0 ; i<numberOfSets ; i++){
      int sleepingHours=1000 ;
      int sleepingMinutes=1000 ;
      int numberOfAlarms=scan.nextInt();
      int sleepHours=scan.nextInt();
      int sleepMinutes=scan.nextInt();
      sleepMinutes+=sleepHours*60 ;
      List<Integer>sleepingArrayMinutes=new LinkedList<>();
      for(int x=0 ; x<numberOfAlarms ; x++){
        int h=scan.nextInt();
        int m=scan.nextInt();
        m+=h*60 ;
        if(sleepMinutes<=m){
          sleepingMinutes=m-sleepMinutes ;
        }
        else {
          sleepingMinutes=1440-sleepMinutes+m ;
        }
        sleepingArrayMinutes.add(sleepingMinutes);
      }
      int min=Collections.min(sleepingArrayMinutes);
      System.out.println(min/60+" "+min % 60);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class EveryoneLikeSleeping {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numberOfSets : int ; numberOfSets := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < numberOfSets do ( (     var sleepingHours : int ; sleepingHours := 1000 ;
     var sleepingMinutes : int ; sleepingMinutes := 1000 ;
    var numberOfAlarms : int ; numberOfAlarms := scan.getCurrent()->toInteger() ;
    var sleepHours : int ; sleepHours := scan.getCurrent()->toInteger() ;
    var sleepMinutes : int ; sleepMinutes := scan.getCurrent()->toInteger() ;
    sleepMinutes := sleepMinutes+(sleepHours * 60) ; 
    var sleepingArrayMinutes : Sequence(int) ; sleepingArrayMinutes := Sequence{} ;
        var x : int ; x := 0 ; while x < numberOfAlarms do ( (     var h : int ; h := scan.getCurrent()->toInteger() ;
     var m : int ; m := scan.getCurrent()->toInteger() ;
    m := m+(h * 60) ; 
    if (sleepMinutes <= m) then (     sleepingMinutes := m - sleepMinutes ) else (     sleepingMinutes := 1440 - sleepMinutes + m ) ;  
    sleepingArrayMinutes := sleepingArrayMinutes->including(sleepingMinutes) ; 
 )  ;     x := x + 1 ) ; 
    var min : int ; min := .min(sleepingArrayMinutes) ;
    OclFile["System.out"].println(min / 60 + " " + min mod 60) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class EveryoneLikeSleeping {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int numberOfSets=scan.nextInt();
    for(int i=0 ; i<numberOfSets ; i++){
      int sleepingHours=1000 ;
      int sleepingMinutes=1000 ;
      int numberOfAlarms=scan.nextInt();
      int sleepHours=scan.nextInt();
      int sleepMinutes=scan.nextInt();
      sleepMinutes+=sleepHours*60 ;
      List<Integer>sleepingArrayMinutes=new ArrayList<>();
      for(int x=0 ; x<numberOfAlarms ; x++){
        int h=scan.nextInt();
        int m=scan.nextInt();
        m+=h*60 ;
        if(sleepMinutes<=m){
          sleepingMinutes=m-sleepMinutes ;
        }
        else {
          sleepingMinutes=1440-sleepMinutes+m ;
        }
        sleepingArrayMinutes.add(sleepingMinutes);
      }
      int min=Collections.min(sleepingArrayMinutes);
      System.out.println(min/60+" "+min % 60);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class EveryoneLikeSleeping {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numberOfSets : int ; numberOfSets := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < numberOfSets do ( (     var sleepingHours : int ; sleepingHours := 1000 ;
     var sleepingMinutes : int ; sleepingMinutes := 1000 ;
    var numberOfAlarms : int ; numberOfAlarms := scan.getCurrent()->toInteger() ;
    var sleepHours : int ; sleepHours := scan.getCurrent()->toInteger() ;
    var sleepMinutes : int ; sleepMinutes := scan.getCurrent()->toInteger() ;
    sleepMinutes := sleepMinutes+(sleepHours * 60) ; 
    var sleepingArrayMinutes : Sequence(int) ; sleepingArrayMinutes := Sequence{} ;
        var x : int ; x := 0 ; while x < numberOfAlarms do ( (     var h : int ; h := scan.getCurrent()->toInteger() ;
     var m : int ; m := scan.getCurrent()->toInteger() ;
    m := m+(h * 60) ; 
    if (sleepMinutes <= m) then (     sleepingMinutes := m - sleepMinutes ) else (     sleepingMinutes := 1440 - sleepMinutes + m ) ;  
    sleepingArrayMinutes := sleepingArrayMinutes->including(sleepingMinutes) ; 
 )  ;     x := x + 1 ) ; 
    var min : int ; min := .min(sleepingArrayMinutes) ;
    OclFile["System.out"].println(min / 60 + " " + min mod 60) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Map ;
import java.util.Scanner ;
import java.util.Vector ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    Integer numberOfTests=scanner.nextInt();
    while(numberOfTests-->0){
      Integer numberOfAlarms=scanner.nextInt();
      Integer vladHourSleep=scanner.nextInt();
      Integer vladMinSleep=scanner.nextInt();
      Integer totalVladMinutes=vladHourSleep*60+vladMinSleep ;
      Integer minDifference=Integer.MAX_VALUE ;
      while(numberOfAlarms-->0){
        Integer alarmHour=scanner.nextInt();
        Integer alarmMin=scanner.nextInt();
        Integer totalAlarmMinutes=alarmHour*60+alarmMin ;
        Integer difference=totalAlarmMinutes-totalVladMinutes ;
        if(difference<0)difference+=1440 ;
        minDifference=Math.min(minDifference,difference);
      }
      Integer ans1=minDifference/60 ;
      int ans2=minDifference-ans1*60 ;
      System.out.println(ans1+" "+ans2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numberOfTests : int ; numberOfTests := scanner.getCurrent()->toInteger() ;
         while (numberOfTests > 0) do (        numberOfTests := numberOfTests - 1 ;     skip ; (     var numberOfAlarms : int ; numberOfAlarms := scanner.getCurrent()->toInteger() ;
     var vladHourSleep : int ; vladHourSleep := scanner.getCurrent()->toInteger() ;
    var vladMinSleep : int ; vladMinSleep := scanner.getCurrent()->toInteger() ;
    var totalVladMinutes : int ; totalVladMinutes := vladHourSleep * 60 + vladMinSleep ;
    var minDifference : int ; minDifference := 2147483647 ;
        while (numberOfAlarms > 0) do (        numberOfAlarms := numberOfAlarms - 1 ;     skip ; (     var alarmHour : int ; alarmHour := scanner.getCurrent()->toInteger() ;
     var alarmMin : int ; alarmMin := scanner.getCurrent()->toInteger() ;
    var totalAlarmMinutes : int ; totalAlarmMinutes := alarmHour * 60 + alarmMin ;
    var difference : int ; difference := totalAlarmMinutes - totalVladMinutes ;
    if (difference < 0) then     difference := difference+(1440) ; else skip ; 
    minDifference := Set{minDifference, difference}->min() ; 
 ) ;  ) ;  
    var ans1 : int ; ans1 := minDifference / 60 ;
    var ans2 : int ; ans2 := minDifference - ans1 * 60 ;
    OclFile["System.out"].println(ans1 + " " + ans2) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      while(sc.hasNext()){
        int e=sc.nextInt();
        if(e==0)break ;
        int min=Integer.MAX_VALUE ;
        for(int z=0 ; z<1000000 ; z++){
          if(z>e)break ;
          for(int y=0 ; y<=1000000 ; y++){
            if(z*z*z+y*y>e || min<=z+y)break ;
            int x=e-y*y-z*z*z ;
            min=Math.min(x+y+z,min);
          }
        }
        System.out.println(min);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (sc.hasNext()) do (     var e : int ; e := sc.getCurrent()->toInteger() ;
     if (e = 0) then     break else skip ; 
    var min : int ; min := 2147483647 ;
        var z : int ; z := 0 ; while z < 1000000 do ( (     if (z > e) then     break else skip ; 
         var y : int ; y := 0 ; while y <= 1000000 do ( (     if (z * z * z + y * y > e or min <= z + y) then     break else skip ; 
     var x : int ; x := e - y * y - z * z * z ;
     min := Set{x + y + z, min}->min() )  ;     y := y + 1 ) )  ;     z := z + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int x,e,i,j,m ;
    for(; ; ){
      e=sc.nextInt();
      if(e==0)break ;
      m=e ;
      for(i=0 ; i*i*i<=e ; i++)for(j=0 ; j*j<=e ; j++)if(i*i*i+j*j<=e){
        x=e-(i*i*i+j*j);
        if(m>x+j+i)m=x+j+i ;
      }
      out.println(m);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var x : int ;
    var e : int ;
    var i : int ;
    var j : int ;
    var m : int ;
       while true do ( (     e := sc.nextInt() ; 
     if (e = 0) then     break else skip ; 
    m := e ; 
        i := 0 ; while i * i * i <= e do (         j := 0 ; while j * j <= e do (     if (i * i * i + j * j <= e) then (     x := e - (i * i * i + j * j) ; 
     if (m > x + j + i) then     m := x + j + i ; else skip ) else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    out.println(m) ; 
 )  ) ; 
     sc.close() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Tower {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int top=sc.nextInt();
    int k=7-top ;
    boolean check=true ;
    for(int i=1 ; i<=n ; i++){
      int l=sc.nextInt();
      int r=sc.nextInt();
      if(l==k || l==top || r==k || r==top){
        check=false ;
        break ;
      }
    }
    System.out.println(check ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Tower {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var top : int ; top := sc.getCurrent()->toInteger() ;
    var k : int ; k := 7 - top ;
    var check : boolean ; check := true ;
        var i : int ; i := 1 ; while i <= n do ( (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
     if (l = k or l = top or r = k or r = top) then (     check := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if check then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class codeforce {
  public static void main(String[] args){
    Scanner css=new Scanner(System.in);
    int t=css.nextInt();
    while(t-->0){
      int n=css.nextInt();
      int[] arr1=new int[n];
      int[] arr2=new int[n];
      for(int i=0 ; i<n ; ++i){
        arr1[i]=css.nextInt();
      }
      for(int i=0 ; i<n ; ++i){
        arr2[i]=css.nextInt();
      }
      for(int i=0 ; i<n ; ++i){
        if(arr1[i]>arr2[i]){
          int temp=arr1[i];
          arr1[i]=arr2[i];
          arr2[i]=temp ;
        }
      }
      int max1=arr1[0];
      int max2=arr2[0];
      for(int i=1 ; i<n ; ++i){
        if(arr1[i]>max1){
          max1=arr1[i];
        }
        if(arr2[i]>max2){
          max2=arr2[i];
        }
      }
      System.out.println(max1*max2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforce {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var css : OclFile ; css := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := css.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := css.getCurrent()->toInteger() ;
     var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr1[i+1] := css.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr2[i+1] := css.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr1[i+1] > arr2[i+1]) then (     var temp : int ; temp := arr1[i+1] ;
     arr1[i+1] := arr2[i+1] ; 
     arr2[i+1] := temp ) else skip )  ;     i := i + 1 ) ; 
    var max1 : int ; max1 := arr1[0+1] ;
    var max2 : int ; max2 := arr2[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     if (arr1[i+1] > max1) then (     max1 := arr1[i+1] ) else skip ; 
     if (arr2[i+1] > max2) then (     max2 := arr2[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max1 * max2) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Juicer {
  static Scanner sc=new Scanner(System.in);
  public static void main(String args[])throws IOException {
    int n=sc.nextInt();
    int b=sc.nextInt();
    int d=sc.nextInt();
    int sum=0 ;
    int counter=0 ;
    while(n-->0){
      int orange=sc.nextInt();
      if(orange>b)continue ;
      sum+=orange ;
      if(sum>d){
        counter++;
        sum=0 ;
      }
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Juicer {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var counter : int ; counter := 0 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var orange : int ; orange := sc.getCurrent()->toInteger() ;
     if (orange > b) then     continue else skip ; 
     sum := sum+(orange) ; 
     if (sum > d) then (     counter := counter + 1 ; 
     sum := 0 ) else skip ) ;  ) ;  
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    int x=0 ;
    int y=0 ;
    int z=0 ;
    int[] m=new int[10000];
    int temp_m ;
    int count ;
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    for(count=0 ; count>=0 ; count++){
      String str=br.readLine();
      int e=Integer.parseInt(str);
      if(e==0){
        break ;
      }
      m[count]=e ;
      for(int tempz=0 ; tempz*tempz*tempz<=e ; tempz++){
        z=tempz ;
      }
      for(int i=0 ; z>=0 ; i++){
        for(int tempy=0 ; tempy*tempy<=e-z*z*z ; tempy++){
          y=tempy ;
        }
        x=e-z*z*z-y*y ;
        temp_m=x+y+z ;
        if(temp_m<m[count]){
          m[count]=temp_m ;
        }
        z--;
      }
    }
    for(int i=0 ; i<count ; i++){
      System.out.println(m[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 0 ;
     var y : int ; y := 0 ;
    var z : int ; z := 0 ;
    var m : Sequence(int) ; m := Integer.subrange(1,10000)->collect(0) ;
    var temp_m : int ;
    var count : int ;
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
        count := 0 ; while count >= 0 do ( (     var str : String ; str := br.readLine() ;
     var e : int ; e := (str)->toInteger() ;
    if (e = 0) then (     break ) else skip ; 
    m[count+1] := e ; 
        var tempz : int ; tempz := 0 ; while tempz * tempz * tempz <= e do ( (     z := tempz )  ;     tempz := tempz + 1 ) ; 
        var i : int ; i := 0 ; while z >= 0 do ( (         var tempy : int ; tempy := 0 ; while tempy * tempy <= (e)->char2byte() - z * z * z do ( (     y := tempy )  ;     tempy := tempy + 1 ) ; 
     x := (e)->char2byte() - z * z * z - y * y ; 
    temp_m := x + y + z ; 
    if (temp_m < m[count+1]) then (     m[count+1] := temp_m ) else skip ; 
    z := z - 1 ; 
 )  ;     i := i + 1 ) ; 
 )  ;     count := count + 1 ) ; 
        var i : int ; i := 0 ; while i < count do ( (     OclFile["System.out"].println(m[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    boolean[] Z=new boolean[1000001];
    int[] z=new int[1000001];
    for(int i=0 ; i<=100 ; i++){
      Z[i*i*i]=true ;
      z[i*i*i]=i ;
    }
    for(; ; ){
      int e=sc.nextInt();
      if(e==0)break ;
      int res=1<<29 ;
      for(int x=0 ; x<=1000000 ; x++){
        if(res<=x)break ;
        for(int y=0 ; y<=1000000 ; y++){
          if(res<=x+y || e<x+y*y)break ;
          if(! Z[e-x-y*y])continue ;
          res=Math.min(res,x+y+z[e-x-y*y]);
        }
      }
      System.out.println(res);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var Z : Sequence(boolean) ; Z := Integer.subrange(1,1000001)->collect(false) ;
    var z : Sequence(int) ; z := Integer.subrange(1,1000001)->collect(0) ;
        var i : int ; i := 0 ; while i <= 100 do ( (     Z[i * i * i+1] := true ; 
     z[i * i * i+1] := i )  ;     i := i + 1 ) ; 
      while true do ( (     var e : int ; e := sc.getCurrent()->toInteger() ;
     if (e = 0) then     break else skip ; 
    var res : int ; res := (1*(2->pow(29)))->oclAsType(long) ;
        var x : int ; x := 0 ; while x <= 1000000 do ( (     if (res <= x) then     break else skip ; 
         var y : int ; y := 0 ; while y <= 1000000 do ( (     if (res <= x + y or e < x + y * y) then     break else skip ; 
     if (not(Z[e - x - y * y+1])) then     continue else skip ; 
     res := Set{res, x + y + z[e - x - y * y+1]}->min() )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 )  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int e=sc.nextInt();
      if(e==0)break ;
      int c=(int)cbrt(e),min=e ;
      for(int z=0 ; z<=c ; z++){
        int s=(int)sqrt(e-z*z*z);
        for(int y=0 ; y<=s ; y++){
          int x=e-y*y-z*z*z ;
          min=min(min,x+y+z);
        }
      }
      System.out.println(min);
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var e : int ; e := sc.getCurrent()->toInteger() ;
     if (e = 0) then     break else skip ; 
    var c : int ; c := cbrt(e)->oclAsType(int) ;
    var min : int ; min := e ;
        var z : int ; z := 0 ; while z <= c do ( (     var s : int ; s := sqrt(e - z * z * z)->oclAsType(int) ;
         var y : int ; y := 0 ; while y <= s do ( (     var x : int ; x := e - y * y - z * z * z ;
     min := Set{min, x + y + z}->min() )  ;     y := y + 1 ) )  ;     z := z + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
class Main {
  Scanner sc ;
  int N,M ;
  String S ;
  Deque<Integer>d ;
  private void calc(){
    sc=new Scanner(System.in);
    N=sc.nextInt();
    M=sc.nextInt();
    S=sc.next();
    d=new ArrayDeque<>();
    int p=N ;
    while(p>0){
      int dice=Math.min(M,p);
      while(true){
        if(dice==0 || p-dice<0){
          dice=-1 ;
          break ;
        }
        if(S.charAt(p-dice)=='0')break ;
        dice--;
      }
      if(dice==-1)break ;
      p-=dice ;
      d.addFirst(dice);
    }
    if(p>0)System.out.println(-1);
    else {
      System.out.println(d.stream().map(n->String.valueOf(n)).collect(Collectors.joining(" ")));
    }
  }
  public static void main(String[] args){
    new Main().calc();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute N : int;
   attribute S : String;
   attribute d : Sequence(int);
   operation calc() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     N := sc.getCurrent()->toInteger() ; 
    M := sc.getCurrent()->toInteger() ; 
    S := sc.getCurrent() ; 
    d := ArrayDeque<OclAny>.newArrayDeque() ; 
    var p : int ; p := N ;
    while (p > 0) do (     var dice : int ; dice := Set{M, p}->min() ;
     while (true) do (     if (dice = 0 or p - dice < 0) then (     dice := -1 ; 
     break ) else skip ; 
     if (S->at(p - dice+1) = '0') then     break else skip ; 
     dice := dice - 1 ) ; 
    if (dice = -1) then     break else skip ; 
    p := p-(dice) ; 
    d := d->prepend(dice) ; 
 ) ; 
    if (p > 0) then     OclFile["System.out"].println(-1) else (     OclFile["System.out"].println(d->collect( _x1 | (lambda n : OclAny in ((n) + ""))->apply(_x1) ).collect(Collectors.joining(" "))) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().calc() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    char[] arr=sc.next().toCharArray();
    int max=0 ;
    int count=0 ;
    for(char c : arr){
      if(c=='1'){
        count++;
        max=Math.max(max,count);
      }
      else {
        count=0 ;
      }
    }
    if(max>=m){
      System.out.println(-1);
      return ;
    }
    ArrayDeque<Integer>stack=new ArrayDeque<>();
    int idx=n ;
    while(idx>0){
      int next=Math.max(idx-m,0);
      while(arr[next]=='1'){
        next++;
      }
      stack.push(idx-next);
      idx=next ;
    }
    boolean isFirst=true ;
    StringBuilder sb=new StringBuilder();
    while(stack.size()>0){
      if(! isFirst){
        sb.append(" ");
      }
      sb.append(stack.pop());
      isFirst=false ;
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
    var max : int ; max := 0 ;
    var count : int ; count := 0 ;
    for (c : arr) do ( (     if (c = '1') then (     count := count + 1 ; 
     max := Set{max, count}->max() ) else (     count := 0 ) )  ) ; 
    if (max >= m) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var stack : Sequence(int) ; stack := ArrayDeque<OclAny>.newArrayDeque() ;
    var idx : int ; idx := n ;
    while (idx > 0) do (     var next : int ; next := Set{idx - m, 0}->max() ;
     while (arr[next+1] = '1') do (     next := next + 1 ) ; 
     stack := stack->append(idx - next) ; 
     idx := next ) ; 
    var isFirst : boolean ; isFirst := true ;
    var sb : String ; sb := StringLib.newString() ;
    while (stack->size() > 0) do (     if (not(isFirst)) then (     sb := sb + StringLib.newString(" ") ) else skip ; 
     sb := sb + StringLib.newString(stack->last()) ; 
     isFirst := false ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  PrintWriter out=new PrintWriter(System.out);
  BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer tok=new StringTokenizer("");
  String next()throws IOException {
    if(! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  int ni()throws IOException {
    return Integer.parseInt(next());
  }
  long nl()throws IOException {
    return Long.parseLong(next());
  }
  void solve()throws IOException {
    int n=ni(),m=ni();
    String s=next();
    int[] A=new int[n+1];
    for(int x=0 ; x<=n ; x++){
      if(s.charAt(x)=='1')A[x]=1 ;
    }
    int c=0 ;
    int[] B=new int[n+10];
    int p=n ;
    boolean f=false ;
    outer : while(true){
      int newp=p-m ;
      if(newp<=0){
        B[c]=p ;
        break ;
      }
      while(A[newp]==1){
        newp++;
        if(newp==p){
          f=true ;
          break outer ;
        }
      }
      B[c]=p-newp ;
      c++;
      p=newp ;
    }
    if(f)out.println("-1");
    else {
      for(int x=c ; x>=0 ; x--)out.print(B[x]+" ");
      out.println();
    }
    out.flush();
  }
  public static void main(String[] args)throws IOException {
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute tok : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     if (not(tok.hasNext())) then (     tok := OclIterator.newOclIterator_String(in.readLine()) ) else skip ; 
     return tok.next() );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nl() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := ni() ;
    var m : int ; m := ni() ;
     var s : String ; s := next() ;
    var A : Sequence(int) ; A := Integer.subrange(1,n + 1)->collect(0) ;
        var x : int ; x := 0 ; while x <= n do ( (     if (s->at(x+1) = '1') then     A[x+1] := 1 ; else skip )  ;     x := x + 1 ) ; 
    var c : int ; c := 0 ;
    var B : Sequence(int) ; B := Integer.subrange(1,n + 10)->collect(0) ;
    var p : int ; p := n ;
    var f : boolean ; f := false ;
    while (true) do (     var newp : int ; newp := p - m ;
     if (newp <= 0) then (     B[c+1] := p ; 
     break ) else skip ; 
    while (A[newp+1] = 1) do (     newp := newp + 1 ; 
     if (newp = p) then (     f := true ; 
     break ) else skip ) ; 
    B[c+1] := p - newp ; 
    c := c + 1 ; 
    p := newp ; 
 ) ; 
    if (f) then     skip else (         var x : int ; x := c ; while x >= 0 do (     skip ;  ;     x := x - 1 ) ; 
     skip ) ;  
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    sc.nextLine();
    String s=sc.nextLine();
    int[] dp=new int[n+1];
    Arrays.fill(dp,Integer.MAX_VALUE);
    dp[n]=0 ;
    Queue<Integer>q=new LinkedList<>();
    q.offer(0);
    for(int i=n-1 ; i>=0 ; i--){
      while(true){
        if(q.size()==0){
          System.out.println(-1);
          return ;
        }
        if(q.peek()!=Integer.MAX_VALUE && q.size()<=m)break ;
        q.poll();
      }
      if(s.charAt(i)=='0')dp[i]=q.peek()+1 ;
      q.offer(dp[i]);
    }
    List<Integer>answeer=new ArrayList<>();
    int x=0 ;
    int rest=dp[0];
    while(x<n){
--rest ;
      int i=1 ;
      while(dp[x+i]!=rest)++i ;
      answeer.add(i);
      x+=i ;
    }
    for(int i=0 ; i<answeer.size(); i++){
      System.out.print(answeer.get(i));
      System.out.print(" ");
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    skip ; 
    var s : String ; s := sc.nextLine() ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
    dp := dp->collect(2147483647) ; 
    dp[n+1] := 0 ; 
    var q : Sequence(int) ; q := Sequence{} ;
    q := q->including(0) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     while (true) do (     if (q->size() = 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
     if (q->min() /= 2147483647 & q->size() <= m) then     break else skip ; 
     q := q->sort()->tail() ) ; 
     if (s->at(i+1) = '0') then     dp[i+1] := q->min() + 1 ; else skip ; 
     q := q->including(dp[i+1]) )  ;     i := i - 1 ) ; 
    var answeer : Sequence(int) ; answeer := Sequence{} ;
    var x : int ; x := 0 ;
    var rest : int ; rest := dp[0+1] ;
    while (x < n) do (     rest := rest - 1 ; 
     var i : int ; i := 1 ;
    while (dp[x + i+1] /= rest) do     i := i + 1 ; ; 
    answeer := answeer->including(i) ; 
    x := x+(i) ; 
 ) ; 
        var i : int ; i := 0 ; while i < answeer->size() do ( (     OclFile["System.out"].print(answeer->at(i+1)) ; 
     OclFile["System.out"].print(" ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    int M=Integer.parseInt(sc.next());
    String S=sc.next();
    char[] c=S.toCharArray();
    ArrayList<Integer>ans=new ArrayList<Integer>();
    int i=N ;
    int flag=0 ;
    loop : while(i>=0){
      for(int j=M ; j>=1 ; j--){
        if(i-j<0)continue ;
        if(c[i-j]=='0'){
          i-=j ;
          ans.add(j);
          break ;
        }
        if(j==1){
          flag=1 ;
          break loop ;
        }
      }
      if(i==0)break ;
    }
    if(flag==1){
      System.out.println(-1);
    }
    else {
      for(int j=ans.size()-1 ; j>=0 ; j--){
        System.out.println(ans.get(j));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var M : int ; M := (sc.getCurrent())->toInteger() ;
    var S : String ; S := sc.getCurrent() ;
    var c : Sequence(String) ; c := S->characters() ;
    var ans : Sequence(int) ; ans := Sequence{} ;
    var i : int ; i := N ;
    var flag : int ; flag := 0 ;
    while (i >= 0) do (         var j : int ; j := M ; while j >= 1 do ( (     if (i - j < 0) then     continue else skip ; 
     if (c[i - j+1] = '0') then (     i := i-(j) ; 
     ans := ans->including(j) ; 
     break ) else skip ; 
     if (j = 1) then (     flag := 1 ; 
     break ) else skip )  ;     j := j - 1 ) ; 
     if (i = 0) then     break else skip ) ; 
    if (flag = 1) then (     OclFile["System.out"].println(-1) ) else (         var j : int ; j := ans->size() - 1 ; while j >= 0 do ( (     OclFile["System.out"].println(ans->at(j+1)) )  ;     j := j - 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static long p=1_000_000_007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    if((2*y-x)% 3!=0 ||(2*x-y)% 3!=0 || Math.max(x,y)>Math.min(x,y)*2){
      System.out.println(0);
      return ;
    }
    int s=(2*y-x)/3 ;
    int t=(2*x-y)/3 ;
    long z=(long)s+t ;
    long A=1 ;
    long B=1 ;
    for(int i=0 ; i<s ; i++){
      A*=(z-i);
      A=A % p ;
      B*=(s-i);
      B=B % p ;
    }
    System.out.println(A*inv(B,p-2)% p);
  }
  public static long inv(long n,long k){
    if(k==0){
      return 1 ;
    }
    if(k % 2==0){
      long l=inv(n,k/2);
      return l*l % p ;
    }
    else {
      return n*inv(n,k-1)% p ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute p : long := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    if ((2 * y - x) mod 3 /= 0 or (2 * x - y) mod 3 /= 0 or Set{x, y}->max() > Set{x, y}->min() * 2) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var s : int ; s := (2 * y - x) / 3 ;
    var t : int ; t := (2 * x - y) / 3 ;
    var z : long ; z := s->oclAsType(long) + t ;
    var A : long ; A := 1 ;
    var B : long ; B := 1 ;
        var i : int ; i := 0 ; while i < s do ( (     A := A*((z - i)) ; 
     A := A mod p ; 
     B := B*((s - i)) ; 
     B := B mod p )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(A * inv(B, p - 2) mod p) ; 
 );
  static   operation inv( n : long, k : long) : long
  pre: true
  post: true
  activity: (     if (k = 0) then (     return 1 ) else skip ; 
     if (k mod 2 = 0) then (     var l : long ; l := inv(n, k / 2) ;
     return l * l mod p ) else (     return n * inv(n, k - 1) mod p ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static final int MOD=1000000007 ;
  public static void main(String[] args){
    var sc=new Scanner(System.in);
    var x=sc.nextInt();
    var y=sc.nextInt();
    sc.close();
    var a=(x+y)/3 ;
    var b=Math.min(x,y)-a ;
    if((x+y)% 3==0 && b>=0){
      var modCalc=new Main().new ModCalc(MOD);
      var result=modCalc.combine(a,b);
      System.out.println(result);
    }
    else {
      System.out.println(0);
    }
  }
  public class ModCalc {
    int mod ;
    public ModCalc(int mod){
      this.mod=mod ;
    }
    public int add(int a,int b){
      return(int)(((long)a+b)% mod);
    }
    public int subtract(int a,int b){
      return(int)(((long)a-b+mod)% mod);
    }
    public int multiply(int a,int b){
      return(int)(((long)a*b)% mod);
    }
    public int divide(int a,int b){
      return multiply(a,pow(b,mod-2));
    }
    public int pow(int n,int k){
      if(k==0){
        return 1 ;
      }
      else if(k % 2==0){
        int p=pow(n,k/2);
        return multiply(p,p);
      }
      else {
        int p=pow(n,(k-1)/2);
        return multiply(multiply(p,p),n);
      }
    }
    public int combine(int n,int k){
      int sum1=1 ;
      int sum2=1 ;
      for(int i=0 ; i<k ; i++){
        sum1=multiply(sum1,n-i);
        sum2=multiply(sum2,i+1);
      }
      return divide(sum1,sum2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : var ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : var ; x := sc.nextInt() ;
    var y : var ; y := sc.nextInt() ;
    sc.close() ; 
    var a : var ; a := (x + y) / 3 ;
    var b : var ; b := Set{x, y}->min() - a ;
    if ((x + y) mod 3 = 0 & b >= 0) then (     var modCalc : var ; modCalc := (Main.newMain()).newModCalc(MOD) ;
     var result : var ; result := modCalc.combine(a, b) ;
     OclFile["System.out"].println(result) ) else (     OclFile["System.out"].println(0) ) ;  
 );
 class ModCalc {
   attribute mod : int;
   static operation newModCalc( mod : int) : ModCalc
  pre: true
  post: true
  activity:
  ( var self : ModCalc ;
    self := createModCalc();
    self.initialise(mod);
    return self );
  operation initialise( mod : int) : void
  pre: true  post: true
  activity: (     self.mod := mod );
   operation add( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return ((a->oclAsType(long) + b) mod mod)->oclAsType(int) );
   operation subtract( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return ((a->oclAsType(long) - b + mod) mod mod)->oclAsType(int) );
   operation multiply( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return ((a->oclAsType(long) * b) mod mod)->oclAsType(int) );
   operation divide( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return multiply(a, pow(b, mod - 2)) );
   operation pow( n : int, k : int) : int
  pre: true
  post: true
  activity: (     if (k = 0) then (     return 1 ) else     if (k mod 2 = 0) then (     var p : int ; p := pow(n, k / 2) ;
     return multiply(p, p) ) else (     var p : int ; p := pow(n, (k - 1) / 2) ;
     return multiply(multiply(p, p), n) ) ;  );
   operation combine( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var sum1 : int ; sum1 := 1 ;
     var sum2 : int ; sum2 := 1 ;
         var i : int ; i := 0 ; while i < k do ( (     sum1 := multiply(sum1, n - i) ; 
     sum2 := multiply(sum2, i + 1) )  ;     i := i + 1 ) ; 
     return divide(sum1, sum2) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class P3 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[][]=new int[n][n];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        a[i][j]=sc.nextInt();
      }
    }
    if(n==1){
      if(a[0][0]==1){
        System.out.println("YES");
        return ;
      }
      else {
        System.out.println("NO");
        return ;
      }
    }
    boolean mast=false ;
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(a[i][j]!=1){
          cnt=0 ;
          for(int k=0 ; k<n ; k++){
            for(int l=0 ; l<n ; l++){
              if(a[i][j]==a[i][k]+a[l][j]){
                cnt=1 ;
                break ;
              }
            }
            if(cnt==1)break ;
          }
          if(cnt==0){
            System.out.println("NO");
            return ;
          }
        }
      }
    }
    if(cnt==1)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class P3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     a[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (n = 1) then (     if (a[0+1][0+1] = 1) then (     OclFile["System.out"].println("YES") ; 
     return ) else (     OclFile["System.out"].println("NO") ; 
     return ) ) else skip ; 
    var mast : boolean ; mast := false ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (a[i+1][j+1] /= 1) then (     cnt := 0 ; 
         var k : int ; k := 0 ; while k < n do ( (         var l : int ; l := 0 ; while l < n do ( (     if (a[i+1][j+1] = a[i+1][k+1] + a[l+1][j+1]) then (     cnt := 1 ; 
     break ) else skip )  ;     l := l + 1 ) ; 
     if (cnt = 1) then     break else skip )  ;     k := k + 1 ) ; 
     if (cnt = 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (cnt = 1) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BuyAShovel {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n,b,d ;
    n=scan.nextInt();
    b=scan.nextInt();
    d=scan.nextInt();
    int a ;
    int sum=0 ;
    int counter=0 ;
    for(int i=0 ; i<n ; i++){
      a=scan.nextInt();
      if(a<=b){
        sum+=a ;
      }
      else {
      }
      if(sum>d){
        counter++;
        sum=0 ;
      }
    }
    System.out.print(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class BuyAShovel {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var b : int ;
    var d : int ;
    n := scan.getCurrent()->toInteger() ; 
    b := scan.getCurrent()->toInteger() ; 
    d := scan.getCurrent()->toInteger() ; 
    var a : int ;
    var sum : int ; sum := 0 ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a := scan.getCurrent()->toInteger() ; 
     if (a <= b) then (     sum := sum+(a) ) else skip ;  
     if (sum > d) then (     counter := counter + 1 ; 
     sum := 0 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CodeForces1461B {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int q=0 ; q<t ; q++){
      int n=input.nextInt();
      int k=input.nextInt();
      int[][] a=new int[n+2][k+2];
      int count=0 ;
      for(int i=1 ; i<=n ; i++){
        String s=input.next();
        for(int j=1 ; j<=s.length(); j++){
          if(s.charAt(j-1)=='*'){
            a[i][j]=1 ;
          }
        }
      }
      for(int i=n ; i>0 ; i--){
        for(int j=1 ; j<=k ; j++){
          if(a[i][j]==0){
            continue ;
          }
          else {
            a[i][j]=Math.min(Math.min(a[i+1][j-1],a[i+1][j]),a[i+1][j+1])+1 ;
            count+=a[i][j];
          }
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces1461B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var q : int ; q := 0 ; while q < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var k : int ; k := input.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n + 2)->collect(Integer.subrange(1,k + 2)->collect(0)) ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var s : String ; s := input.getCurrent() ;
         var j : int ; j := 1 ; while j <= s->size() do ( (     if (s->at((j)->char2byte() - 1+1) = '*') then (     a[i+1][j+1] := 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := n ; while i > 0 do ( (         var j : int ; j := 1 ; while j <= k do ( (     if (a[i+1][j+1] = 0) then (     continue ) else (     a[i+1][j+1] := Set{Set{a[i + 1+1][(j)->char2byte() - 1+1], a[i + 1+1][j+1]}->min(), a[i + 1+1][j + 1+1]}->min() + 1 ; 
     count := count+(a[i+1][j+1]) ) )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )  ;     q := q + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int mod=1000000007 ;
  public static long frac(int n){
    long ans=1 ;
    for(int i=2 ; i<=n ; i++){
      ans*=i ;
      ans %=mod ;
    }
    return ans ;
  }
  public static long modpow(long a,long n,long mod){
    long res=1 ;
    while(n>0){
      if(n % 2==1){
        res=res*a % mod ;
      }
      a=a*a % mod ;
      n>>=1 ;
    }
    return res ;
  }
  static long modinv(long a,long mod){
    return modpow(a,mod-2,mod);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    double a=(2*(double)x-(double)y)/3 ;
    double b=(2*(double)y-(double)x)/3 ;
    if(((2*x-y)% 3==0 &&(2*y-x)% 3==0)&&(2*x-y>=0 && 2*y-x>=0)){
      int aa=(int)a ;
      int bb=(int)b ;
      int cc=aa+bb ;
      long ans1=frac(aa+bb);
      long ans2=modinv(frac(aa),mod);
      long ans3=modinv(frac(bb),mod);
      long ans4=((ans1*ans2)% mod*ans3)% mod ;
      System.out.println(ans4);
    }
    else {
      System.out.println("0");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := 1000000007;
  static   operation frac( n : int) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
         var i : int ; i := 2 ; while i <= n do ( (     ans := ans*(i) ; 
     ans := ans mod mod )  ;     i := i + 1 ) ; 
     return ans );
  static   operation modpow( a : long, n : long, mod : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     while (n > 0) do (     if (n mod 2 = 1) then (     res := res * a mod mod ) else skip ; 
     a := a * a mod mod ; 
     n := n/(2->pow(1)) ) ; 
     return res );
  static   operation modinv( a : long, mod : long) : long
  pre: true
  post: true
  activity: (     return modpow(a, mod - 2, mod) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var a : double ; a := (2 * x->oclAsType(double) - y->oclAsType(double)) / 3 ;
    var b : double ; b := (2 * y->oclAsType(double) - x->oclAsType(double)) / 3 ;
    if (((2 * x - y) mod 3 = 0 & (2 * y - x) mod 3 = 0) & (2 * x - y >= 0 & 2 * y - x >= 0)) then (     var aa : int ; aa := a->oclAsType(int) ;
     var bb : int ; bb := b->oclAsType(int) ;
    var cc : int ; cc := aa + bb ;
    var ans1 : long ; ans1 := frac(aa + bb) ;
    var ans2 : long ; ans2 := modinv(frac(aa), mod) ;
    var ans3 : long ; ans3 := modinv(frac(bb), mod) ;
    var ans4 : long ; ans4 := ((ans1 * ans2) mod mod * ans3) mod mod ;
    OclFile["System.out"].println(ans4) ; 
 ) else (     OclFile["System.out"].println("0") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  static int MOD=1000000007 ;
  static long[] fac=new long[1000000];
  static long[] finv=new long[1000000];
  static long[] inv=new long[1000000];
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str[]=br.readLine().split(" ");
    int x=Integer.parseInt(str[0]);
    int y=Integer.parseInt(str[1]);
    int a=(2*x-y)/3 ;
    int b=(2*y-x)/3 ;
    if(((-x+2*y)% 3!=0)||((2*x-y)% 3!=0)){
      System.out.println(0);
    }
    else {
      COMinit();
      System.out.println(COM(a+b,a));
    }
  }
  public static void COMinit(){
    fac[0]=1L ;
    fac[1]=1L ;
    finv[0]=1L ;
    finv[1]=1L ;
    inv[1]=1L ;
    for(int i=2 ; i<1000000 ; i++){
      fac[i]=fac[i-1]*i % MOD ;
      inv[i]=MOD-inv[MOD % i]*(MOD/i)% MOD ;
      finv[i]=finv[i-1]*inv[i] % MOD ;
    }
  }
  public static long COM(int n,int k){
    if(n<k){
      return 0L ;
    }
    if(n<0 || k<0){
      return 0L ;
    }
    return fac[n]*(finv[k]*finv[n-k] % MOD)% MOD ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : int := 1000000007;
  static   attribute fac : Sequence(long) := Integer.subrange(1,1000000)->collect(0);
  static   attribute finv : Sequence(long) := Integer.subrange(1,1000000)->collect(0);
  static   attribute inv : Sequence(long) := Integer.subrange(1,1000000)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var x : int ; x := (str[0+1])->toInteger() ;
    var y : int ; y := (str[1+1])->toInteger() ;
    var a : int ; a := (2 * x - y) / 3 ;
    var b : int ; b := (2 * y - (x)->char2byte()) / 3 ;
    if (((-x + 2 * y) mod 3 /= 0) or ((2 * x - y) mod 3 /= 0)) then (     OclFile["System.out"].println(0) ) else (     execute COMinit() ; 
     OclFile["System.out"].println(COM(a + b, a)) ) ;  
 );
  static   operation COMinit() : void
  pre: true
  post: true
  activity: (     fac[0+1] := 1L ; 
     fac[1+1] := 1L ; 
    finv[0+1] := 1L ; 
    finv[1+1] := 1L ; 
    inv[1+1] := 1L ; 
        var i : int ; i := 2 ; while i < 1000000 do ( (     fac[i+1] := fac[i - 1+1] * i mod MOD ; 
     inv[i+1] := MOD - inv[MOD mod i+1] * (MOD / i) mod MOD ; 
     finv[i+1] := finv[i - 1+1] * inv[i+1] mod MOD )  ;     i := i + 1 ) ; 
 );
  static   operation COM( n : int, k : int) : long
  pre: true
  post: true
  activity: (     if (n < k) then (     return 0L ) else skip ; 
     if (n < 0 or k < 0) then (     return 0L ) else skip ; 
     return fac[n+1] * (finv[k+1] * finv[n - k+1] mod MOD) mod MOD );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static final int MOD=1_000_000_007 ;
  private static final int MAX=1000000 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int X=sc.nextInt();
    int Y=sc.nextInt();
    int A=-1,B=-1 ;
    for(int a=0 ; a<=X ; a++){
      int b=X-2*a ;
      if(b>=0 && a+2*b==Y){
        A=a ;
        B=b ;
        break ;
      }
    }
    if(A==-1){
      System.out.println(0);
    }
    else {
      System.out.println(combMod(A+B,A));
    }
  }
  private static long combMod(int n,int k){
    long[] fac=new long[n+1];
    fac[0]=1 ;
    for(int i=1 ; i<=n ; i++){
      fac[i]=fac[i-1]*i % MOD ;
    }
    return((fac[n]*power(fac[k],MOD-2))% MOD)*power(fac[n-k],MOD-2)% MOD ;
  }
  private static long power(long a,int n){
    if(n==0){
      return 1 ;
    }
    if(n % 2==1){
      return power(a,n-1)*a % MOD ;
    }
    long half=power(a,n/2);
    return half*half % MOD ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1_000_000_007;
  static    attribute MAX : int := 1000000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : int ; X := sc.getCurrent()->toInteger() ;
    var Y : int ; Y := sc.getCurrent()->toInteger() ;
    var A : int ; A := -1 ;
    var B : int ; B := -1 ;
        var a : int ; a := 0 ; while a <= X do ( (     var b : int ; b := X - 2 * a ;
     if (b >= 0 & a + 2 * b = Y) then (     A := a ; 
     B := b ; 
     break ) else skip )  ;     a := a + 1 ) ; 
    if (A = -1) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(combMod(A + B, A)) ) ;  
 );
  static   operation combMod( n : int, k : int) : long
  pre: true
  post: true
  activity: (     var fac : Sequence(long) ; fac := Integer.subrange(1,n + 1)->collect(0) ;
     fac[0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= n do ( (     fac[i+1] := fac[i - 1+1] * i mod MOD )  ;     i := i + 1 ) ; 
     return ((fac[n+1] * power(fac[k+1], MOD - 2)) mod MOD) * power(fac[n - k+1], MOD - 2) mod MOD );
  static   operation power( a : long, n : int) : long
  pre: true
  post: true
  activity: (     if (n = 0) then (     return 1 ) else skip ; 
     if (n mod 2 = 1) then (     return power(a, n - 1) * a mod MOD ) else skip ; 
     var half : long ; half := power(a, n / 2) ;
     return half * half mod MOD );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int setBit(int xorValue){
    int count=0 ;
    while(xorValue>=1){
      if(xorValue % 2==1)count++;
      xorValue/=2 ;
    }
    return count ;
  }
  static int minFlip(int n,int k){
    int size=(int)(Math.log(n)/Math.log(2))+1 ;
    int max=(int)Math.pow(2,k)-1 ;
    max=max<<(size-k);
    int xorValue=(n ^ max);
    return(setBit(xorValue));
  }
  public static void main(String[] args){
    int n=27,k=3 ;
    System.out.println("Min Flips="+minFlip(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation setBit( xorValue : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (xorValue >= 1) do (     if (xorValue mod 2 = 1) then     count := count + 1 ; else skip ; 
     xorValue := xorValue/(2) ) ; 
     return count );
  static   operation minFlip( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var size : int ; size := ((n)->log() / (2)->log())->oclAsType(int) + 1 ;
     var max : int ; max := 2->pow(k)->oclAsType(int) - 1 ;
    max := (max*(2->pow((size - k))))->oclAsType(long) ; 
    var xorValue : int ; xorValue := (MathLib.bitwiseXor(n,max)) ;
    return (setBit(xorValue)) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 27 ;
    var k : int ; k := 3 ;
     OclFile["System.out"].println("Min Flips=" + minFlip(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] a=new long[n];
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
      sum+=(a[i]/(long)n);
    }
    long ans=0 ;
    while(sum>0){
      long t=sum ;
      ans+=sum ;
      sum=0 ;
      for(int i=0 ; i<n ; i++){
        long s=a[i]/(long)n ;
        a[i]-=(s*(long)n);
        a[i]+=(t-s);
        sum+=(a[i]/(long)n);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() ; 
     sum := sum+((a[i+1] / n->oclAsType(long))) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    while (sum > 0) do (     var t : long ; t := sum ;
     ans := ans+(sum) ; 
     sum := 0 ; 
         var i : int ; i := 0 ; while i < n do ( (     var s : long ; s := a[i+1] / n->oclAsType(long) ;
     a[i+1] := a[i+1]-((s * n->oclAsType(long))) ; 
     a[i+1] := a[i+1]+((t - s)) ; 
     sum := sum+((a[i+1] / n->oclAsType(long))) )  ;     i := i + 1 ) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String args[]){
    ConsoleScanner cin=new ConsoleScanner();
    PrintWriter cout=new PrintWriter(System.out);
    solve(cin,cout);
    cout.flush();
  }
  private static void solve(ConsoleScanner cin,PrintWriter cout){
    int n=cin.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<a.length ; i++)a[i]=cin.nextLong();
    long millis=System.currentTimeMillis();
    long ans=solve(n,a);
    cout.println(ans);
    assert null!=cout.format("%d elapsed",System.currentTimeMillis()-millis);
  }
  private static long solve(int n,long[] a){
    long ans=0 ;
    long[] opes=new long[n];
    while(true){
      boolean any=false ;
      long sum=0 ;
      for(int i=0 ; i<n ; i++){
        opes[i]=a[i]/n ;
        sum+=opes[i];
        any |=opes[i]!=0 ;
        a[i] %=n ;
      }
      for(int i=0 ; i<n ; i++)a[i]+=sum-opes[i];
      ans+=sum ;
      if(! any)break ;
    }
    return ans ;
  }
  static class ConsoleScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      try {
        while(! st.hasMoreElements())st=new StringTokenizer(br.readLine());
        return st.nextToken();
      }
      catch(IOException e){
        throw new AssertionError(e);
      }
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : ConsoleScanner ; cin := ConsoleScanner.newConsoleScanner() ;
     var cout : OclFile ; cout := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     execute solve(cin, cout) ; 
     skip );
  static   operation solve( cin : ConsoleScanner, cout : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := cin.nextInt() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := cin.nextLong() ;  ;     i := i + 1 ) ; 
    var millis : long ; millis := OclDate.getSystemTime() ;
    var ans : long ; ans := solve(n, a) ;
    skip ; 
    assert null /= cout.format("%d elapsed", OclDate.getSystemTime() - millis) ; 
 );
  static   operation solve( n : int, a : Sequence(long)) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
     var opes : Sequence(long) ; opes := Integer.subrange(1,n)->collect(0) ;
     while (true) do (     var any : boolean ; any := false ;
     var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     opes[i+1] := a[i+1] / n ; 
     sum := sum+(opes[i+1]) ; 
     any := MathLib.bitwiseOr(any, opes[i+1] /= 0) ; 
     a[i+1] := a[i+1] mod n )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := a[i+1]+(sum - opes[i+1]) ;  ;     i := i + 1 ) ; 
    ans := ans+(sum) ; 
    if (not(any)) then     break else skip ; 
 ) ; 
     return ans );
  static class ConsoleScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() )   catch (e : IOException) do (     error AssertionException(e) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main extends PrintWriter {
  Main(){
    super(System.out,true);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    Main o=new Main();
    o.main();
    o.flush();
  }
  void main(){
    int n=sc.nextInt();
    long[] aa=new long[n];
    for(int i=0 ; i<n ; i++)aa[i]=sc.nextLong();
    long ans=0 ;
    while(true){
      long sum=0 ;
      for(int i=0 ; i<n ; i++){
        long cnt=aa[i]/n ;
        sum+=cnt ;
      }
      if(sum==0)break ;
      ans+=sum ;
      for(int i=0 ; i<n ; i++){
        long cnt=aa[i]/n ;
        aa[i]=aa[i] % n+sum-cnt ;
      }
    }
    println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends OclFile {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"], true) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : Main ; o := Main.newMain() ;
     o.main() ; 
     o.flush() );
   operation main() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var aa : Sequence(long) ; aa := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     aa[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    while (true) do (     var sum : long ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var cnt : long ; cnt := aa[i+1] / n ;
     sum := sum+(cnt) )  ;     i := i + 1 ) ; 
    if (sum = 0) then     break else skip ; 
    ans := ans+(sum) ; 
        var i : int ; i := 0 ; while i < n do ( (     var cnt : long ; cnt := aa[i+1] / n ;
     aa[i+1] := aa[i+1] mod n + sum - cnt )  ;     i := i + 1 ) ; 
 ) ; 
    execute println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  final long MODULO=1_000_000_000+7 ;
  public void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; ++i){
      a[i]=sc.nextLong();
    }
    Arrays.sort(a);
    long l=0 ;
    long u=Long.MAX_VALUE/10 ;
    while(u-l>1){
      long m=(l+u)/2 ;
      if(f(a,m)<0){
        l=m ;
      }
      else {
        u=m ;
      }
    }
    for(long i=Math.max(0,u-1000); i<=u+1000 ; ++i){
      if(f(a,i)==0){
        System.out.println(i);
        return ;
      }
    }
  }
  long f(long[] a,long k){
    int n=a.length ;
    long s=0 ;
    for(int i=0 ; i<n ; ++i){
      if(a[i]+k<=n-1){
        continue ;
      }
      else {
        long res=a[i]+k-(n-1);
        s+=(res+n)/(n+1);
      }
    }
    return k-s ;
  }
  static void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute MODULO : long := 1_000_000_000 + 7;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var l : long ; l := 0 ;
    var u : long ; u := "9223372036854775807"->toLong() / 10 ;
    while (u - l > 1) do (     var m : long ; m := (l + u) / 2 ;
     if (f(a, m) < 0) then (     l := m ) else (     u := m ) ) ; 
        var i : long ; i := Set{0, u - 1000}->max() ; while i <= u + 1000 do ( (     if (f(a, i) = 0) then (     OclFile["System.out"].println(i) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
 );
   operation f( a : Sequence(long), k : long) : long
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() ;
     var s : long ; s := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] + k <= n - 1) then (     continue ) else (     var res : long ; res := a[i+1] + k - (n - 1) ;
     s := s+((res + n) / (n + 1)) ) )  ;     i := i + 1 ) ; 
     return k - s );
  static   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static final long INF=1000000000000000000L ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    final int N=in.nextInt();
    long[] as=new long[N];
    for(int i=0 ; i<N ; i++){
      as[i]=in.nextLong();
    }
    long K=0 ;
    while(true){
      boolean isFinished=true ;
      for(int i=0 ; i<N ; i++){
        final long k=as[i]/N ;
        if(k>0){
          isFinished=false ;
          K+=k ;
          for(int j=0 ; j<N ; j++){
            if(j==i){
              as[j]=as[j] % N ;
            }
            else {
              as[j]+=k ;
            }
          }
        }
      }
      if(isFinished){
        break ;
      }
    }
    System.out.printf("%d\n",K);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : long := 1000000000000000000L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var as : Sequence(long) ; as := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     as[i+1] := in.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var K : long ; K := 0 ;
    while (true) do (     var isFinished : boolean ; isFinished := true ;
         var i : int ; i := 0 ; while i < N do ( (     var k : long ; k := as[i+1] / N ;
     if (k > 0) then (     isFinished := false ; 
     K := K+(k) ; 
         var j : int ; j := 0 ; while j < N do ( (     if (j = i) then (     as[j+1] := as[j+1] mod N ) else (     as[j+1] := as[j+1]+(k) ) )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
     if (isFinished) then (     break ) else skip ) ; 
    OclFile["System.out"].printf("%d\n", K) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=scan.nextInt();
      int[] arr=new int[n];
      for(int j=0 ; j<n ; j++){
        arr[j]=scan.nextInt();
      }
      printArrayB(n,arr);
    }
  }
  public static void printArrayB(int n,int[] arr){
    if(n==1){
      System.out.println("YES");
      System.out.println(1);
      return ;
    }
    StringBuilder sb=new StringBuilder();
    sb.append("YES\n");
    Set<Integer>set=new HashSet<>();
    int count=0 ;
    Random random=new Random();
    while(count<n){
      int cur=random.nextInt(1000*1000)+1 ;
      boolean valid=true ;
      for(int num : arr){
        if(set.contains(num+cur)){
          valid=false ;
          break ;
        }
      }
      if(valid){
        sb.append(cur).append(" ");
        count++;
        for(int num : arr){
          set.add(num+cur);
        }
      }
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var j : int ; j := 0 ; while j < n do ( (     arr[j+1] := scan.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
     execute printArrayB(n, arr) )  ;     i := i + 1 ) );
  static   operation printArrayB( n : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (n = 1) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
     var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString("YES\n") ; 
    var set : Set(int) ; set := Set{} ;
    var count : int ; count := 0 ;
    var random : OclRandom ; random := OclRandom.newOclRandom() ;
    while (count < n) do (     var cur : int ; cur := random.nextInt(1000 * 1000) + 1 ;
     var valid : boolean ; valid := true ;
     for (num : arr) do ( (     if (set->includes(num + cur)) then (     valid := false ; 
     break ) else skip )  ) ; 
     if (valid) then (     sb := sb + StringLib.newString(cur) + StringLib.newString(" ") ; 
     count := count + 1 ; 
     for (num : arr) do ( (     set := set->including(num + cur) )  ) ) else skip ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class A1239 {
  private static final int LIMIT=100_000 ;
  private static final long MOD=1_000_000_007 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int m=Integer.parseInt(st.nextToken());
    int n=Integer.parseInt(st.nextToken());
    long[] fibonacci=new long[LIMIT+1];
    fibonacci[0]=1 ;
    fibonacci[1]=1 ;
    for(int i=2 ; i<=LIMIT ; i++){
      fibonacci[i]=(fibonacci[i-1]+fibonacci[i-2])% MOD ;
    }
    System.out.println(((fibonacci[m]+fibonacci[n]-1)*2)% MOD);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1239 {
  static    attribute LIMIT : int := 100_000;
  static    attribute MOD : long := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var m : int ; m := (st.next())->toInteger() ;
    var n : int ; n := (st.next())->toInteger() ;
    var fibonacci : Sequence(long) ; fibonacci := Integer.subrange(1,LIMIT + 1)->collect(0) ;
    fibonacci[0+1] := 1 ; 
    fibonacci[1+1] := 1 ; 
        var i : int ; i := 2 ; while i <= LIMIT do ( (     fibonacci[i+1] := (fibonacci[i - 1+1] + fibonacci[i - 2+1]) mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(((fibonacci[m+1] + fibonacci[n+1] - 1) * 2) mod MOD) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findSubSeq(int arr[],int n,int sum){
    for(int i=n-1 ; i>=0 ; i--){
      if(sum<arr[i])arr[i]=-1 ;
      else sum-=arr[i];
    }
    for(int i=0 ; i<n ; i++){
      if(arr[i]!=-1)System.out.print(arr[i]+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      17,25,46,94,201,400 };
      int n=arr.length ;
      int sum=272 ;
      findSubSeq(arr,n,sum);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findSubSeq( arr : Sequence(int), n : int, sum : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := n - 1 ; while i >= 0 do ( (     if (sum < arr[i+1]) then     arr[i+1] := -1 ; else     sum := sum-(arr[i+1]) ; )  ;     i := i - 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] /= -1) then     OclFile["System.out"].print(arr[i+1] + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{17,25,46,94,201,400} ;
     var n : int ; n := arr->size() ;
     var sum : int ; sum := 272 ;
     execute findSubSeq(arr, n, sum) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int countWays(int num){
    int[] dp=new int[num+1];
    int MOD=(int)1E9+7 ;
    dp[1]=2 ;
    for(int i=2 ; i<=num ; ++i){
      dp[i]=0 ;
      for(int j=1 ; j<=3 ; ++j){
        if(i-j==0)dp[i]+=1 ;
        else if(j==1)dp[i]+=dp[i-j]*2 ;
        else if(i-j>0)dp[i]+=dp[i-j];
        if(dp[i]>=MOD)dp[i] %=MOD ;
      }
    }
    return dp[num];
  }
  static public void main(String[] args){
    int n=3 ;
    System.out.println(countWays(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countWays( num : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,num + 1)->collect(0) ;
     var MOD : int ; MOD := 1E9->oclAsType(int) + 7 ;
    dp[1+1] := 2 ; 
        var i : int ; i := 2 ; while i <= num do ( (     dp[i+1] := 0 ; 
         var j : int ; j := 1 ; while j <= 3 do ( (     if (i - j = 0) then     dp[i+1] := dp[i+1]+(1) else     if (j = 1) then     dp[i+1] := dp[i+1]+(dp[i - j+1] * 2) else     if (i - j > 0) then     dp[i+1] := dp[i+1]+(dp[i - j+1]) ; else skip ; ;  ;  
     if (dp[i+1] >= MOD) then     dp[i+1] := dp[i+1] mod MOD ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return dp[num+1] 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(countWays(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      double p=Math.sqrt(sc.nextDouble());
      int n=sc.nextInt();
      if(p==0 && n==0)break ;
      double max=1/(double)n ;
      double min=(double)n ;
      int max_p=1 ;
      int max_q=n ;
      int min_p=n ;
      int min_q=1 ;
      for(int i=1 ; i<=n ; i++){
        int j1=(int)Math.floor(i*p);
        int j2=(int)Math.ceil(i*p);
        if(j1<=n &&(double)j1/i>max){
          max=(double)j1/i ;
          max_p=j1 ;
          max_q=i ;
        }
        if(j2<=n &&(double)j2/i<min){
          min=(double)j2/i ;
          min_p=j2 ;
          min_q=i ;
        }
      }
      System.out.printf("%d/%d %d/%d\n",min_p,min_q,max_p,max_q);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var p : double ; p := (sc.getCurrent()->toReal())->sqrt() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    if (p = 0 & n = 0) then     break else skip ; 
    var max : double ; max := 1 / n->oclAsType(double) ;
    var min : double ; min := n->oclAsType(double) ;
    var max_p : int ; max_p := 1 ;
    var max_q : int ; max_q := n ;
    var min_p : int ; min_p := n ;
    var min_q : int ; min_q := 1 ;
        var i : int ; i := 1 ; while i <= n do ( (     var j1 : int ; j1 := (i * p)->floor()->oclAsType(int) ;
     var j2 : int ; j2 := (i * p)->ceil()->oclAsType(int) ;
     if (j1 <= n & j1->oclAsType(double) / i > max) then (     max := j1->oclAsType(double) / i ; 
     max_p := j1 ; 
     max_q := i ) else skip ; 
     if (j2 <= n & j2->oclAsType(double) / i < min) then (     min := j2->oclAsType(double) / i ; 
     min_p := j2 ; 
     min_q := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%d/%d %d/%d\n", min_p, min_q, max_p, max_q) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  final int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int p=sc.nextInt();
      int n=sc.nextInt();
      if((p | n)==0)break ;
      double max=0 ;
      double min=Double.POSITIVE_INFINITY ;
      double rp=Math.sqrt(p);
      int a=1 ;
      int b=1 ;
      int u=0 ;
      int v=0 ;
      int x=0 ;
      int y=0 ;
      while(true){
        if(1.0*a/b>rp){
          if(min>1.0*a/b){
            min=1.0*a/b ;
            x=a ;
            y=b ;
          }
          b++;
          if(b>n)break ;
        }
        else {
          if(max<1.0*a/b){
            max=1.0*a/b ;
            u=a ;
            v=b ;
          }
          a++;
          if(a>n)break ;
        }
      }
      int g1=gcd(x,y);
      int g2=gcd(u,v);
      x/=g1 ;
      y/=g1 ;
      u/=g2 ;
      v/=g2 ;
      System.out.println(x+"/"+y+" "+u+"/"+v);
    }
  }
  int gcd(int a,int b){
    if(a<b){
      a=a ^ b ;
      b=a ^ b ;
      a=a ^ b ;
    }
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  public static void main(String[] args)throws Exception {
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var p : int ; p := sc.getCurrent()->toInteger() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(p,n)) = 0) then     break else skip ; 
    var max : double ; max := 0 ;
    var min : double ; min := Math_PINFINITY ;
    var rp : double ; rp := (p)->sqrt() ;
    var a : int ; a := 1 ;
    var b : int ; b := 1 ;
    var u : int ; u := 0 ;
    var v : int ; v := 0 ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    while (true) do (     if (1.0 * a / b > rp) then (     if (min > 1.0 * a / b) then (     min := 1.0 * a / b ; 
     x := a ; 
     y := b ) else skip ; 
     b := b + 1 ; 
     if (b > n) then     break else skip ) else (     if (max < 1.0 * a / b) then (     max := 1.0 * a / b ; 
     u := a ; 
     v := b ) else skip ; 
     a := a + 1 ; 
     if (a > n) then     break else skip ) ) ; 
    var g1 : int ; g1 := gcd(x, y) ;
    var g2 : int ; g2 := gcd(u, v) ;
    x := x/(g1) ; 
    y := y/(g1) ; 
    u := u/(g2) ; 
    v := v/(g2) ; 
    OclFile["System.out"].println(x + "/" + y + " " + u + "/" + v) ; 
 ) );
   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a < b) then (     a := MathLib.bitwiseXor(a,b) ; 
     b := MathLib.bitwiseXor(a,b) ; 
     a := MathLib.bitwiseXor(a,b) ) else skip ; 
     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      long n=s.nextInt();
      int nums=0 ;
      long temp=n ;
      while(temp>0){
        nums++;
        temp/=10 ;
      }
      int min=Integer.MAX_VALUE ;
      int[] arr=new int[nums];
      int i=nums-1 ;
      temp=n ;
      while(temp>0){
        arr[i--]=(int)temp % 10 ;
        min=Math.min(min,(int)temp % 10);
        temp/=10 ;
      }
      if(nums==2)System.out.println(arr[1]);
      else System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := s.getCurrent()->toInteger() ;
     var nums : int ; nums := 0 ;
    var temp : long ; temp := n ;
    while (temp > 0) do (     nums := nums + 1 ; 
     temp := temp/(10) ) ; 
    var min : int ; min := 2147483647 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,nums)->collect(0) ;
    var i : int ; i := nums - 1 ;
    temp := n ; 
    while (temp > 0) do (      arr[i+1] := temp->oclAsType(int) mod 10  ; i := i - 1 ; 
     min := Set{min, temp->oclAsType(int) mod 10}->min() ; 
     temp := temp/(10) ) ; 
    if (nums = 2) then     OclFile["System.out"].println(arr[1+1]) else     OclFile["System.out"].println(min) ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=scan.nextInt();
      int[] arr=new int[n];
      for(int j=0 ; j<n ; j++){
        arr[j]=scan.nextInt();
      }
      printArrayB(n,arr);
    }
  }
  public static void printArrayB(int n,int[] arr){
    if(n==1){
      System.out.println("YES");
      System.out.println(1);
      return ;
    }
    StringBuilder sb=new StringBuilder();
    sb.append("YES\n");
    Set<Integer>set=new HashSet<>();
    ArrayList<Integer>ans=new ArrayList<>();
    Random random=new Random();
    while(true){
      int cur=random.nextInt(1000*1000)+1 ;
      boolean used=true ;
      for(int num : arr){
        if(set.contains(num+cur)){
          used=false ;
          break ;
        }
      }
      if(used){
        sb.append(cur).append(" ");
        ans.add(cur);
        if(ans.size()==n){
          break ;
        }
        for(int num : arr){
          set.add(num+cur);
        }
      }
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var j : int ; j := 0 ; while j < n do ( (     arr[j+1] := scan.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
     execute printArrayB(n, arr) )  ;     i := i + 1 ) );
  static   operation printArrayB( n : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (n = 1) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
     var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString("YES\n") ; 
    var set : Set(int) ; set := Set{} ;
    var ans : Sequence(int) ; ans := Sequence{} ;
    var random : OclRandom ; random := OclRandom.newOclRandom() ;
    while (true) do (     var cur : int ; cur := random.nextInt(1000 * 1000) + 1 ;
     var used : boolean ; used := true ;
     for (num : arr) do ( (     if (set->includes(num + cur)) then (     used := false ; 
     break ) else skip )  ) ; 
     if (used) then (     sb := sb + StringLib.newString(cur) + StringLib.newString(" ") ; 
     ans := ans->including(cur) ; 
     if (ans->size() = n) then (     break ) else skip ; 
     for (num : arr) do ( (     set := set->including(num + cur) )  ) ) else skip ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
public class A1684 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      String n=scanner.next();
      List<Character>list=new LinkedList<>();
      for(int i=0 ; i<n.length(); i++){
        list.add(n.charAt(i));
      }
      Collections.sort(list);
      if(list.size()==2){
        System.out.println((n.charAt(0)==list.get(0))? list.get(1): list.get(0));
      }
      else {
        System.out.println(list.get(0));
      }
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1684 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : String ; n := scanner.getCurrent() ;
     var list : Sequence(String) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n->size() do ( (     list := list->including(n->at(i+1)) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    if (list->size() = 2) then (     OclFile["System.out"].println(if (n->at(0+1) = list->at(0+1)) then list->at(1+1) else list->at(0+1) endif) ) else (     OclFile["System.out"].println(list->at(0+1)) ) ;  
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t--!=0){
      int n=scanner.nextInt();
      System.out.println(testcase(n));
    }
  }
  public static int testcase(int n){
    if(n<100){
      return n % 10 ;
    }
    int ans=Integer.MAX_VALUE ;
    while(n!=0){
      ans=Math.min(ans,n % 10);
      n/=10 ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(testcase(n)) ) ;  ) );
  static   operation testcase( n : int) : int
  pre: true
  post: true
  activity: (     if (n < 100) then (     return n mod 10 ) else skip ; 
     var ans : int ; ans := 2147483647 ;
     while (n /= 0) do (     ans := Set{ans, n mod 10}->min() ; 
     n := n/(10) ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class B {
  public static void main(String[] args)throws IOException {
    int n=readInt(),k=readInt();
    List<Integer>a=new ArrayList<Integer>();
    int sol=n+1 ;
    for(int start=0 ; start<n ; start++){
      List<Integer>temp=new ArrayList<Integer>();
      boolean[] fill=new boolean[n];
      for(int j=start ; j<n ; j+=2*k+1){
        temp.add(j);
        for(int tj=max(0,j-k); tj<=min(n-1,j+k); tj++)fill[tj]=true ;
      }
      boolean work=true ;
      for(boolean b : fill)work &=b ;
      if(work && temp.size()<sol){
        sol=temp.size();
        a=temp ;
      }
    }
    out.println(a.size());
    for(int x : a)out.print(x+1+" ");
    out.println();
    out.close();
  }
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
  static StringTokenizer st=new StringTokenizer("");
  static String read()throws IOException {
    return st.hasMoreTokens()? st.nextToken():(st=new StringTokenizer(br.readLine())).nextToken();
  }
  static int readInt()throws IOException {
    return Integer.parseInt(read());
  }
  static long readLong()throws IOException {
    return Long.parseLong(read());
  }
  static double readDouble()throws IOException {
    return Double.parseDouble(read());
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := readInt() ;
    var k : int ; k := readInt() ;
     var a : Sequence(int) ; a := Sequence{} ;
    var sol : int ; sol := n + 1 ;
        var start : int ; start := 0 ; while start < n do ( (     var temp : Sequence(int) ; temp := Sequence{} ;
     var fill : Sequence(boolean) ; fill := Integer.subrange(1,n)->collect(false) ;
        var j : int ; j := start ; while j < n do ( (     temp := temp->including(j) ; 
         var tj : int ; tj := max(0, j - k) ; while tj <= Set{n - 1, j + k}->min() do (     fill[tj+1] := true ;  ;     tj := tj + 1 ) )  ;     j := j+(2 * k + 1) ) ; 
    var work : boolean ; work := true ;
    for (b : fill) do (     work := MathLib.bitwiseAnd(work, b) ;  ) ; 
    if (work & temp->size() < sol) then (     sol := temp->size() ; 
     a := temp ) else skip ; 
 )  ;     start := start + 1 ) ; 
    out.println(a->size()) ; 
    for (x : a) do (     out.print(x + 1 + " ") ;  ) ; 
    out.println() ; 
    out.close() ; 
 );
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute st : OclIterator := OclIterator.newOclIterator_String("");
  static   operation read() : String
  pre: true
  post: true
  activity: (     return if st.hasNext() then st.next() else (st).next() endif );
  static   operation readInt() : int
  pre: true
  post: true
  activity: (     return (read())->toInteger() );
  static   operation readLong() : long
  pre: true
  post: true
  activity: (     return (read())->toLong() );
  static   operation readDouble() : double
  pre: true
  post: true
  activity: (     return (read())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int count(int num){
    int c=0 ;
    while(num!=0){
      c++;
      num=num/10 ;
    }
    return c ;
  }
  public static void main(String args[]){
    Scanner Sc=new Scanner(System.in);
    int a=Sc.nextInt();
    int i ;
    Main obj=new Main();
    int num[]=new int[a];
    for(i=0 ; i<a ; i++){
      num[i]=Sc.nextInt();
    }
    for(i=0 ; i<a ; i++){
      int n=num[i];
      int c=obj.count(n);
      int d ;
      if(c==2)System.out.println(n % 10);
      else if(c>2){
        int min=9 ;
        while(n!=0){
          d=n % 10 ;
          if(min>d)min=d ;
          n=n/10 ;
        }
        System.out.println(min);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation count( num : int) : int
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
     while (num /= 0) do (     c := c + 1 ; 
     num := num / 10 ) ; 
     return c );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Sc : OclFile ; Sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := Sc.getCurrent()->toInteger() ;
    var i : int ;
    var obj : Main ; obj := Main.newMain() ;
    var num : Sequence(int) ; num := Integer.subrange(1,a)->collect(0) ;
        i := 0 ; while i < a do ( (     num[i+1] := Sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        i := 0 ; while i < a do ( (     var n : int ; n := num[i+1] ;
     var c : int ; c := obj.count(n) ;
     var d : int ;
     if (c = 2) then     OclFile["System.out"].println(n mod 10) ; else     if (c > 2) then (     var min : int ; min := 9 ;
     while (n /= 0) do (     d := n mod 10 ; 
     if (min > d) then     min := d ; else skip ; 
     n := n / 10 ) ; 
     OclFile["System.out"].println(min) ) else skip ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static int sumofoddFactors(int n){
    int res=1 ;
    while(n % 2==0)n=n/2 ;
    for(int i=3 ; i<=Math.sqrt(n); i++){
      int count=0,curr_sum=1 ;
      int curr_term=1 ;
      while(n % i==0){
        count++;
        n=n/i ;
        curr_term*=i ;
        curr_sum+=curr_term ;
      }
      res*=curr_sum ;
    }
    if(n>=2)res*=(1+n);
    return res ;
  }
  public static void main(String args[])throws IOException {
    int n=30 ;
    System.out.println(sumofoddFactors(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumofoddFactors( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     while (n mod 2 = 0) do     n := n / 2 ; ; 
        var i : int ; i := 3 ; while i <= (n)->sqrt() do ( (     var count : int ; count := 0 ;
    var curr_sum : int ; curr_sum := 1 ;
     var curr_term : int ; curr_term := 1 ;
     while (n mod i = 0) do (     count := count + 1 ; 
     n := n / i ; 
     curr_term := curr_term*(i) ; 
     curr_sum := curr_sum+(curr_term) ) ; 
     res := res*(curr_sum) )  ;     i := i + 1 ) ; 
    if (n >= 2) then     res := res*((1 + n)) ; else skip ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 30 ;
     OclFile["System.out"].println(sumofoddFactors(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
public class GFG {
  static int sumofFactors(int n){
    int res=1 ;
    for(int i=2 ; i<=Math.sqrt(n); i++){
      int curr_sum=1 ;
      int curr_term=1 ;
      while(n % i==0){
        n=n/i ;
        curr_term*=i ;
        curr_sum+=curr_term ;
      }
      res*=curr_sum ;
    }
    if(n>2)res*=(1+n);
    return res ;
  }
  public static void main(String args[]){
    int n=30 ;
    System.out.println(sumofFactors(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumofFactors( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
         var i : int ; i := 2 ; while i <= (n)->sqrt() do ( (     var curr_sum : int ; curr_sum := 1 ;
     var curr_term : int ; curr_term := 1 ;
     while (n mod i = 0) do (     n := n / i ; 
     curr_term := curr_term*(i) ; 
     curr_sum := curr_sum+(curr_term) ) ; 
     res := res*(curr_sum) )  ;     i := i + 1 ) ; 
     if (n > 2) then     res := res*((1 + n)) ; else skip ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 30 ;
     OclFile["System.out"].println(sumofFactors(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.geom.Point2D ;
public class Main {
  static int n ;
  static Point2D d ;
  static HashMap<Point2D,Boolean>c ;
  static boolean dfs(Point2D p,double sum,int time){
    if(time==n)return true ;
    for(Point2D pp : c.keySet()){
      if(c.get(pp))continue ;
      if(sum+p.distance(pp)>=d.distance(pp))return false ;
    }
    c.put(p,true);
    for(Point2D pp : c.keySet()){
      if(c.get(pp))continue ;
      if(dfs(pp,sum+p.distance(pp),time+1))return true ;
    }
    c.put(p,false);
    return false ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      n=sc.nextInt();
      Point2D h=new Point2D.Double(sc.nextDouble(),sc.nextDouble());
      d=new Point2D.Double(sc.nextDouble(),sc.nextDouble());
      if(n==0)break ;
      c=new HashMap<Point2D,Boolean>();
      c.put(h,false);
      for(int i=0 ; i<n ; i++){
        c.put(new Point2D.Double(sc.nextDouble(),sc.nextDouble()),false);
      }
      System.out.println(dfs(h,0,0)? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute d : Point2D;
  static   attribute c : Map(Point2D,Boolean);
  static   operation dfs( p : Point2D, sum : double, time : int) : boolean
  pre: true
  post: true
  activity: (     if (time = n) then     return true else skip ; 
     for (pp : c->keys()) do ( (     if (c->at(pp)) then     continue else skip ; 
     if (sum + p.distance(pp) >= d.distance(pp)) then     return false else skip )  ) ; 
    c := c->union(Map{p |-> true}) ; 
    for (pp : c->keys()) do ( (     if (c->at(pp)) then     continue else skip ; 
     if (dfs(pp, sum + p.distance(pp), time + 1)) then     return true else skip )  ) ; 
    c := c->union(Map{p |-> false}) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     n := sc.getCurrent()->toInteger() ; 
     var h : Point2D ; h := Double.newDouble(sc.getCurrent()->toReal(), sc.getCurrent()->toReal()) ;
    d := Double.newDouble(sc.getCurrent()->toReal(), sc.getCurrent()->toReal()) ; 
    if (n = 0) then     break else skip ; 
    c := Map{} ; 
    c := c->union(Map{h |-> false}) ; 
        var i : int ; i := 0 ; while i < n do ( (     c := c->union(Map{Double.newDouble(sc.getCurrent()->toReal(), sc.getCurrent()->toReal()) |-> false}) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if dfs(h, 0, 0) then "YES" else "NO" endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class CF38B {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    char[] rr=br.readLine().toCharArray();
    char[] kk=br.readLine().toCharArray();
    int xr=rr[0]-'a' ;
    int yr=rr[1]-'1' ;
    int xk=kk[0]-'a' ;
    int yk=kk[1]-'1' ;
    int cnt=0 ;
    for(int x=0 ; x<8 ; x++){
      for(int y=0 ; y<8 ; y++){
        if(x==xr || y==yr)continue ;
        if(x==xk && y==yk)continue ;
        int dx,dy ;
        dx=Math.abs(x-xr);
        dy=Math.abs(y-yr);
        if((dx==1 && dy==2)||(dx==2 && dy==1))continue ;
        dx=Math.abs(x-xk);
        dy=Math.abs(y-yk);
        if((dx==1 && dy==2)||(dx==2 && dy==1))continue ;
        cnt++;
      }
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF38B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var rr : Sequence(String) ; rr := br.readLine()->characters() ;
    var kk : Sequence(String) ; kk := br.readLine()->characters() ;
    var xr : int ; xr := rr[0+1] - ('a')->char2byte() ;
    var yr : int ; yr := rr[1+1] - ('1')->char2byte() ;
    var xk : int ; xk := kk[0+1] - ('a')->char2byte() ;
    var yk : int ; yk := kk[1+1] - ('1')->char2byte() ;
    var cnt : int ; cnt := 0 ;
        var x : int ; x := 0 ; while x < 8 do ( (         var y : int ; y := 0 ; while y < 8 do ( (     if (x = xr or y = yr) then     continue else skip ; 
     if (x = xk & y = yk) then     continue else skip ; 
    var dx : int ;
    var dy : int ;
    dx := if x - xr < 0 then -(x - xr) else x - xr endif ; 
    dy := if y - yr < 0 then -(y - yr) else y - yr endif ; 
    if ((dx = 1 & dy = 2) or (dx = 2 & dy = 1)) then     continue else skip ; 
    dx := if x - xk < 0 then -(x - xk) else x - xk endif ; 
    dy := if y - yk < 0 then -(y - yk) else y - yk endif ; 
    if ((dx = 1 & dy = 2) or (dx = 2 & dy = 1)) then     continue else skip ; 
    cnt := cnt + 1 ; 
 )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=scan.nextInt();
      int[] arr=new int[n];
      for(int j=0 ; j<n ; j++){
        arr[j]=scan.nextInt();
      }
      printArrayB(n,arr);
    }
  }
  public static void printArrayB(int n,int[] arr){
    if(n==1){
      System.out.println("YES");
      System.out.println(1);
      return ;
    }
    StringBuilder sb=new StringBuilder();
    Set<Integer>set=new HashSet<>();
    Arrays.sort(arr);
    int[] diffs=new int[n*(n-1)/2];
    int idx=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        diffs[idx++]=arr[j]-arr[i];
      }
    }
    sb.append("YES\n");
    int count=0 ;
    boolean[] used=new boolean[1000001];
    int cur=1 ;
    while(count<n){
      while(used[cur]){
        cur++;
      }
      count++;
      sb.append(cur).append(" ");
      for(int diff : diffs){
        int next=cur+diff ;
        if(next<=1000000 && next>=1)used[next]=true ;
      }
      cur++;
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var j : int ; j := 0 ; while j < n do ( (     arr[j+1] := scan.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
     execute printArrayB(n, arr) )  ;     i := i + 1 ) );
  static   operation printArrayB( n : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (n = 1) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
     var sb : String ; sb := StringLib.newString() ;
    var set : Set(int) ; set := Set{} ;
    arr := arr->sort() ; 
    var diffs : Sequence(int) ; diffs := Integer.subrange(1,n * (n - 1) / 2)->collect(0) ;
    var idx : int ; idx := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (      diffs[idx+1] := arr[j+1] - arr[i+1]  ; idx := idx + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString("YES\n") ; 
    var count : int ; count := 0 ;
    var used : Sequence(boolean) ; used := Integer.subrange(1,1000001)->collect(false) ;
    var cur : int ; cur := 1 ;
    while (count < n) do (     while (used[cur+1]) do (     cur := cur + 1 ) ; 
     count := count + 1 ; 
    sb := sb + StringLib.newString(cur) + StringLib.newString(" ") ; 
    for (diff : diffs) do ( (     var next : int ; next := cur + diff ;
     if (next <= 1000000 & next >= 1) then     used[next+1] := true ; else skip )  ) ; 
    cur := cur + 1 ; 
 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPrime(int n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    if(n % 2==0 || n % 3==0)return false ;
    for(int i=5 ; i*i<=n ; i+=6){
      if(n % i==0 || n %(i+2)==0){
        return false ;
      }
    }
    return true ;
  }
  static boolean twinPrime(int n1,int n2){
    return(isPrime(n1)&& isPrime(n2)&& Math.abs(n1-n2)==2);
  }
  static int countTwinPairs(int arr[],int n){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        if(twinPrime(arr[i],arr[j])){
          count++;
        }
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      2,3,5,11 };
      int n=arr.length ;
      System.out.print(countTwinPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do ( (     if (n mod i = 0 or n mod (i + 2) = 0) then (     return false ) else skip )  ;     i := i+(6) ) ; 
    return true 
 );
  static   operation twinPrime( n1 : int, n2 : int) : boolean
  pre: true
  post: true
  activity: (     return (isPrime(n1) & isPrime(n2) & if n1 - n2 < 0 then -(n1 - n2) else n1 - n2 endif = 2) );
  static   operation countTwinPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (twinPrime(arr[i+1], arr[j+1])) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,5,11} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(countTwinPairs(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),m=in.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<m ; i++){
      Map<Integer,Integer>map=new HashMap<>();
      ArrayList<Integer>list=new ArrayList<>();
      for(int j=0 ; j<n ; j++){
        list.add(in.nextInt());
      }
      int max=Collections.max(list);
      int ind=list.indexOf(max);
      a[ind]=a[ind]+1 ;
    }
    ArrayList<Integer>l=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      l.add(a[i]);
    }
    int max_ans=Collections.max(l);
    int ans=l.indexOf(max_ans);
    pw.print(ans+1);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     var map : Map(int,int) ; map := Map{} ;
     var list : Sequence(int) ; list := Sequence{} ;
        var j : int ; j := 0 ; while j < n do ( (     list := list->including(in.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
    var max : int ; max := .max(list) ;
    var ind : int ; ind := list->indexOf(max)-1 ;
    a[ind+1] := a[ind+1] + 1 ; 
 )  ;     i := i + 1 ) ; 
    var l : Sequence(int) ; l := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     l := l->including(a[i+1]) )  ;     i := i + 1 ) ; 
    var max_ans : int ; max_ans := .max(l) ;
    var ans : int ; ans := l->indexOf(max_ans)-1 ;
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  static TreeSet<Long>set ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),m=in.nextInt();
    int[][] votes=new int[m][n];
    for(int i=0 ; i<m ; i++){
      for(int j=0 ; j<n ; j++){
        votes[i][j]=in.nextInt();
      }
    }
    HashMap<Integer,Integer>map=new HashMap();
    for(int i=0 ; i<m ; i++){
      int max=votes[i][0];
      int winner=1 ;
      for(int j=0 ; j<n ; j++){
        if(max<votes[i][j]){
          max=votes[i][j];
          winner=j+1 ;
        }
      }
      map.put(winner,map.getOrDefault(winner,0)+1);
    }
    int ans=1 ;
    int max=0 ;
    for(int i=1 ; i<=n ; i++){
      if(max<map.getOrDefault(i,0)){
        ans=i ;
        max=map.get(i);
      }
    }
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute set : Set(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var votes : Sequence(Sequence(int)) ; votes := Integer.subrange(1,m)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j < n do ( (     votes[i+1][j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < m do ( (     var max : int ; max := votes[i+1][0+1] ;
     var winner : int ; winner := 1 ;
         var j : int ; j := 0 ; while j < n do ( (     if (max < votes[i+1][j+1]) then (     max := votes[i+1][j+1] ; 
     winner := j + 1 ) else skip )  ;     j := j + 1 ) ; 
     map := map->union(Map{winner |-> (if map->keys()->contains(winner) then map->at(winner) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 1 ;
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (max < (if map->keys()->contains(i) then map->at(i) else 0 endif)) then (     ans := i ; 
     max := map->at(i) ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(sc.next());
    }
    long ans=0 ;
    int[] idx=new int[n];
    for(int i=0 ; i<n ; i++){
      idx[a[i]-1]=i ;
    }
    TreeSet<Integer>s=new TreeSet<Integer>();
    for(int i=n-1 ; i>=0 ; i--){
      int x=idx[i];
      s.add(x);
      int l1=-1,l2=-1 ;
      int r1=n,r2=n ;
      Integer tmp ;
      if((tmp=s.lower(x))!=null){
        l2=tmp ;
        if((tmp=s.lower(tmp))!=null){
          l1=tmp ;
        }
      }
      if((tmp=s.higher(x))!=null){
        r1=tmp ;
        if((tmp=s.higher(tmp))!=null){
          r2=tmp ;
        }
      }
      long w1=(l2-l1)*(r1-x);
      long w2=(x-l2)*(r2-r1);
      ans+=(w1+w2)*(i+1);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var idx : Sequence(int) ; idx := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     idx[a[i+1] - 1+1] := i )  ;     i := i + 1 ) ; 
    var s : Set(int) ; s := Set{} ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     var x : int ; x := idx[i+1] ;
     s := s->including(x) ; 
    var l1 : int ; l1 := -1 ;
    var l2 : int ; l2 := -1 ;
    var r1 : int ; r1 := n ;
    var r2 : int ; r2 := n ;
    var tmp : int ;
    if ((tmp) /= null) then (     l2 := tmp ; 
     if ((tmp) /= null) then (     l1 := tmp ) else skip ) else skip ; 
    if ((tmp) /= null) then (     r1 := tmp ; 
     if ((tmp) /= null) then (     r2 := tmp ) else skip ) else skip ; 
    var w1 : long ; w1 := (l2 - l1) * (r1 - x) ;
    var w2 : long ; w2 := (x - l2) * (r2 - r1) ;
    ans := ans+((w1 + w2) * (i + 1)) ; 
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class A_570 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] res=new int[n];
    Arrays.fill(res,0);
    for(int i=0 ; i<m ; i++){
      int max=0 ;
      int ind=0 ;
      for(int j=0 ; j<n ; j++){
        int in=sc.nextInt();
        if(max<in){
          max=in ;
          ind=j ;
        }
      }
      res[ind]+=1 ;
    }
    int ind=0 ;
    int max=0 ;
    for(int i=0 ; i<n ; i++){
      if(max<res[i]){
        max=res[i];
        ind=i ;
      }
    }
    System.out.println(ind+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_570 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
    res := res->collect(0) ; 
        var i : int ; i := 0 ; while i < m do ( (     var max : int ; max := 0 ;
     var ind : int ; ind := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     var in : int ; in := sc.getCurrent()->toInteger() ;
     if (max < in) then (     max := in ; 
     ind := j ) else skip )  ;     j := j + 1 ) ; 
     res[ind+1] := res[ind+1]+(1) )  ;     i := i + 1 ) ; 
    var ind : int ; ind := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (max < res[i+1]) then (     max := res[i+1] ; 
     ind := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ind + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int m=input.nextInt();
    HashMap<Integer,Integer>vote=new HashMap<>();
    int resultIndex=-1 ;
    int resultValue=-1 ;
    for(int i=0 ; i<m ; i++){
      int tempMaxIndex=-1 ;
      int tempMaxValue=-1 ;
      for(int j=1 ; j<=n ; j++){
        int temp=input.nextInt();
        if(temp>tempMaxValue){
          tempMaxIndex=j ;
          tempMaxValue=temp ;
        }
      }
      if(vote.containsKey(tempMaxIndex))vote.put(tempMaxIndex,vote.get(tempMaxIndex)+1);
      else vote.put(tempMaxIndex,1);
      tempMaxValue=vote.get(tempMaxIndex);
      if(tempMaxValue>resultValue ||(resultValue==tempMaxValue && tempMaxIndex<resultIndex)){
        resultIndex=tempMaxIndex ;
        resultValue=tempMaxValue ;
      }
    }
    System.out.println(resultIndex);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var m : int ; m := input.getCurrent()->toInteger() ;
    var vote : Map(int,int) ; vote := Map{} ;
    var resultIndex : int ; resultIndex := -1 ;
    var resultValue : int ; resultValue := -1 ;
        var i : int ; i := 0 ; while i < m do ( (     var tempMaxIndex : int ; tempMaxIndex := -1 ;
     var tempMaxValue : int ; tempMaxValue := -1 ;
        var j : int ; j := 1 ; while j <= n do ( (     var temp : int ; temp := input.getCurrent()->toInteger() ;
     if (temp > tempMaxValue) then (     tempMaxIndex := j ; 
     tempMaxValue := temp ) else skip )  ;     j := j + 1 ) ; 
    if (vote->keys()->includes(tempMaxIndex)) then     vote := vote->union(Map{tempMaxIndex |-> vote->at(tempMaxIndex) + 1}) else     vote := vote->union(Map{tempMaxIndex |-> 1}) ; ;  
    tempMaxValue := vote->at(tempMaxIndex) ; 
    if (tempMaxValue > resultValue or (resultValue = tempMaxValue & tempMaxIndex < resultIndex)) then (     resultIndex := tempMaxIndex ; 
     resultValue := tempMaxValue ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(resultIndex) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int EqualNumbers(int a[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=a[i];
    if(sum % n!=0)return n-1 ;
    return n ;
  }
  public static void main(String args[]){
    int a[]={
      1,4,1 };
      int n=a.length ;
      System.out.println(EqualNumbers(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation EqualNumbers( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+(a[i+1]) ;  ;     i := i + 1 ) ; 
     if (sum mod n /= 0) then     return n - 1 else skip ; 
     return n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,4,1} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(EqualNumbers(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static int find(int n,int k){
    if(n+1>=k)return(k-1);
    else return(2*n+1-k);
  }
  public static void main(String argc[]){
    int n=4,k=7 ;
    int freq=find(n,k);
    if(freq<0)System.out.print(" element"+" not exist \n ");
    else System.out.print(" Frequency"+" of "+k+" is "+freq+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation find( n : int, k : int) : int
  pre: true
  post: true
  activity: (     if (n + 1 >= k) then     return (k - 1) else     return (2 * n + 1 - k) );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
    var k : int ; k := 7 ;
     var freq : int ; freq := find(n, k) ;
     if (freq < 0) then     OclFile["System.out"].print(" element" + " not exist \n ") ; else     OclFile["System.out"].print(" Frequency" + " of " + k + " is " + freq + "\n") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CaseOfFakeNos {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    if(scanner.hasNext()){
      int n=scanner.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=scanner.nextInt();
      while(arr[0]!=0){
        arr[0]=(arr[0]+1)% n ;
        for(int i=1 ; i<n ; i++){
          if(i % 2==1){
            arr[i]=(arr[i]+n-1)% n ;
          }
          else {
            arr[i]=(arr[i]+1)% n ;
          }
        }
      }
      if(check(arr))System.out.println("Yes");
      else System.out.println("No");
    }
  }
  private static boolean check(int[] arr){
    int count=0 ;
    for(int i : arr)if(i!=count++)return false ;
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class CaseOfFakeNos {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     if (scanner.hasNext()) then (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    while (arr[0+1] /= 0) do (     arr[0+1] := (arr[0+1] + 1) mod n ; 
         var i : int ; i := 1 ; while i < n do ( (     if (i mod 2 = 1) then (     arr[i+1] := (arr[i+1] + n - 1) mod n ) else (     arr[i+1] := (arr[i+1] + 1) mod n ) )  ;     i := i + 1 ) ) ; 
    if (check(arr)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 ) else skip );
  static   operation check( arr : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     for (i : arr) do (     if (i /= count) then     return false else skip ;  ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Solution {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(reader.readLine());
    int[] arr=new int[1000001];
    StringTokenizer sToken=new StringTokenizer(reader.readLine());
    for(int i=0 ; i<n ; i++){
      arr[Integer.parseInt(sToken.nextToken())]++;
    }
    int rest=0 ;
    int res=0 ;
    for(int i=0 ; i<=1000000 ; i++){
      res+=((rest+arr[i])% 2);
      rest=(rest+arr[i])/2 ;
    }
    for(int i=0 ; i<40 ; i++){
      res+=(rest % 2);
      rest=rest/2 ;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (reader.readLine())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,1000001)->collect(0) ;
    var sToken : OclIterator ; sToken := OclIterator.newOclIterator_String(reader.readLine()) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[(sToken.next())->toInteger()+1] := arr[(sToken.next())->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
    var rest : int ; rest := 0 ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i <= 1000000 do ( (     res := res+(((rest + arr[i+1]) mod 2)) ; 
     rest := (rest + arr[i+1]) / 2 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 40 do ( (     res := res+((rest mod 2)) ; 
     rest := rest / 2 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CodeForces_C3 {
  static int m=1000001 ;
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      int n=input.nextInt();
      int[] a=new int[n];
      int[] b=new int[n];
      for(int j=0 ; j<n ; j++){
        a[j]=input.nextInt();
      }
      boolean[] bool=new boolean[m];
      int idx=0 ;
      for(int i=1 ; i<m && idx<n ; i++){
        if(! bool[i]){
          b[idx++]=i ;
          for(int x : a){
            for(int y : a){
              int bi=i+x-y ;
              if(bi>=1 && bi<m){
                bool[bi]=true ;
              }
            }
          }
        }
      }
      System.out.println("YES");
      for(int i=0 ; i<n ; i++){
        System.out.print(b[i]+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces_C3 {
  static   attribute m : int := 1000001;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var tt : int ; tt := 0 ; while tt < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     a[j+1] := input.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    var bool : Sequence(boolean) ; bool := Integer.subrange(1,m)->collect(false) ;
    var idx : int ; idx := 0 ;
        var i : int ; i := 1 ; while i < m & idx < n do ( (     if (not(bool[i+1])) then (      b[idx+1] := i  ; idx := idx + 1 ; 
     for (x : a) do ( (     for (y : a) do ( (     var bi : int ; bi := i + x - y ;
     if (bi >= 1 & bi < m) then (     bool[bi+1] := true ) else skip )  ) )  ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(b[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     tt := tt + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int count=0 ;
    String S=sc.next();
    for(int i=0 ; i<S.length(); i++){
      if('+'==S.charAt(i)){
        count++;
      }
      else count--;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := 0 ;
    var S : String ; S := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < S->size() do ( (     if ('+' = S->at(i+1)) then (     count := count + 1 ) else     count := count - 1 ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String[] str=in.readLine().split("");
    int ans=0 ;
    for(int i=0 ; i<4 ; i++){
      if(str[i] .equals("+"))ans++;
      else ans--;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := in.readLine()->split("") ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     if (str[i+1] = "+") then     ans := ans + 1 ; else     ans := ans - 1 ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] $){
    String s=scanner.next();
    System.out.println(s.replace("-","").length()-s.replace("+","").length());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := scanner.getCurrent() ;
     OclFile["System.out"].println(s.replace("-", "")->size() - s.replace("+", "")->size()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    String S1=S.substring(0,1);
    String S2=S.substring(1,2);
    String S3=S.substring(2,3);
    String S4=S.substring(3,4);
    int count=0 ;
    if(S1.equals("+")){
      count++;
    }
    else {
      count--;
    }
    if(S2.equals("+")){
      count++;
    }
    else {
      count--;
    }
    if(S3.equals("+")){
      count++;
    }
    else {
      count--;
    }
    if(S4.equals("+")){
      count++;
    }
    else {
      count--;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    var S1 : String ; S1 := S.subrange(0+1,1) ;
    var S2 : String ; S2 := S.subrange(1+1,2) ;
    var S3 : String ; S3 := S.subrange(2+1,3) ;
    var S4 : String ; S4 := S.subrange(3+1,4) ;
    var count : int ; count := 0 ;
    if (S1 = "+") then (     count := count + 1 ) else (     count := count - 1 ) ;  
    if (S2 = "+") then (     count := count + 1 ) else (     count := count - 1 ) ;  
    if (S3 = "+") then (     count := count + 1 ) else (     count := count - 1 ) ;  
    if (S4 = "+") then (     count := count + 1 ) else (     count := count - 1 ) ;  
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc ;
  int N ;
  int[][] P ;
  public Main(){
    sc=new Scanner(System.in);
  }
  private void calc(){
    N=sc.nextInt();
    P=new int[N][2];
    for(int i=0 ; i<N ; i++){
      P[i][0]=i ;
      P[i][1]=sc.nextInt();
    }
    Arrays.sort(P,(a,b)->-Integer.compare(a[1],b[1]));
    TreeSet<Integer>t=new TreeSet<>();
    long s=0 ;
    for(int i=0 ; i<N ; i++){
      int ind=P[i][0];
      t.add(ind);
      Iterator<Integer>tail=t.tailSet(ind,false).iterator();
      int c=tail.hasNext()? tail.next(): N ;
      int d=tail.hasNext()? tail.next(): N ;
      Iterator<Integer>head=t.headSet(ind,false).descendingIterator();
      int b=head.hasNext()? head.next():-1 ;
      int a=head.hasNext()? head.next():-1 ;
      s+=((long)P[i][1])*((c-ind)*(b-a)+(d-c)*(ind-b));
    }
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().calc();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute N : int;
   attribute P : Sequence(Sequence(int));
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation calc() : void
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     P := Integer.subrange(1,N)->collect(Integer.subrange(1,2)->collect(0)) ; 
        var i : int ; i := 0 ; while i < N do ( (     P[i+1][0+1] := i ; 
     P[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    P := OclComparator.sortWith(P, lambda (a , b) : OclAny in -compare(a[1+1], b[1+1])) ; 
    var t : Set(int) ; t := Set{} ;
    var s : long ; s := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var ind : int ; ind := P[i+1][0+1] ;
     t := t->including(ind) ; 
    var tail : OclIterator ; tail := t->select( _x0 | _x0 >= ind, false )->iterator() ;
    var c : int ; c := if tail.hasNext() then tail.next() else N endif ;
    var d : int ; d := if tail.hasNext() then tail.next() else N endif ;
    var head : OclIterator ; head := t->select( _x0 | _x0 < ind, false ).descendingIterator() ;
    var b : int ; b := if head.hasNext() then head.next() else -1 endif ;
    var a : int ; a := if head.hasNext() then head.next() else -1 endif ;
    s := s+((P[i+1][1+1]->oclAsType(long)) * ((c - ind) * (b - a) + (d - c) * (ind - b))) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().calc() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    partA101();
  }
  public static void partA101(){
    Scanner scA=new Scanner(System.in);
    String S=scA.next();
    int count=0 ;
    for(int i=0 ; i<4 ; i++){
      if(S.charAt(i)=='+'){
        count++;
      }
      else if(S.charAt(i)=='-'){
        count--;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute partA101() );
  static   operation partA101() : void
  pre: true
  post: true
  activity: (     var scA : OclFile ; scA := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := scA.getCurrent() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     if (S->at(i+1) = '+') then (     count := count + 1 ) else     if (S->at(i+1) = '-') then (     count := count - 1 ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class SlimeCombining {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    ArrayList<Integer>A=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      A.add(1);
    }
    for(int x=0 ; x<100000 ; x++){
      int i=0 ;
      while(i<A.size()-1){
        if(A.get(i)==A.get(i+1)){
          A.set(i,A.get(i)+1);
          A.set(i+1,0);
        }
        i++;
      }
      Iterator itr=A.iterator();
      while(itr.hasNext()){
        if((Integer)itr.next()==0){
          itr.remove();
        }
      }
    }
    for(int i=0 ; i<A.size(); i++){
      System.out.print(A.get(i)+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SlimeCombining {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     A := A->including(1) )  ;     i := i + 1 ) ; 
        var x : int ; x := 0 ; while x < 100000 do ( (     var i : int ; i := 0 ;
     while (i < A->size() - 1) do (     if (A->at(i+1) = A->at(i + 1+1)) then (     A := A.setAt(i+1,A->at(i+1) + 1) ; 
     A := A.setAt(i + 1+1,0) ) else skip ; 
     i := i + 1 ) ; 
     var itr : OclIterator ; itr := A->iterator() ;
     while (itr.hasNext()) do (     if (itr.next()->oclAsType(int) = 0) then (     itr := itr.remove() ) else skip ) )  ;     x := x + 1 ) ; 
        var i : int ; i := 0 ; while i < A->size() do ( (     OclFile["System.out"].print(A->at(i+1) + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class questionCF {
  static ArrayList<Integer>game(ArrayList<Integer>list,int n){
    if(n==1){
      list.add(1);
      return list ;
    }
    if(n==2){
      list.add(2);
      return list ;
    }
    int count=0 ;
    for(int i=1 ; true ; i=i*2){
      count++;
      if(i==n){
        list.add(count);
        return list ;
      }
      else if(i>n){
        list.add(count-1);
        game(list,n-(i/2));
        return list ;
      }
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<Integer>l=new ArrayList<>();
    ArrayList<Integer>list=game(l,n);
    for(int i=0 ; i<list.size(); i++)System.out.print(list.get(i)+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class questionCF {
  static   operation game( list : Sequence(int), n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     if (n = 1) then (     list->excludes(1) ; 
     return list ) else skip ; 
     if (n = 2) then (     list->excludes(2) ; 
     return list ) else skip ; 
     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while true do ( (     count := count + 1 ; 
     if (i = n) then (     list->excludes(count) ; 
     return list ) else     if (i > n) then (     list->excludes(count - 1) ; 
     execute game(list, n - (i / 2)) ; 
     return list ) else skip ; )  ;     i := i * 2 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Sequence{} ;
    var list : Sequence(int) ; list := game(l, n) ;
        var i : int ; i := 0 ; while i < list->size() do (     OclFile["System.out"].print(list->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class questionCF {
  static ArrayList<Integer>game(ArrayList<Integer>list,int n){
    if(n==1){
      list.add(1);
      return list ;
    }
    if(n==2){
      list.add(2);
      return list ;
    }
    int count=0 ;
    for(int i=1 ; true ; i=i*2){
      count++;
      if(i==n){
        list.add(count);
        return list ;
      }
      else if(i>n){
        list.add(count-1);
        game(list,n-(i/2));
        return list ;
      }
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<Integer>l=new ArrayList<>();
    ArrayList<Integer>list=game(l,n);
    for(int i=0 ; i<list.size(); i++)System.out.print(list.get(i)+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class questionCF {
  static   operation game( list : Sequence(int), n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     if (n = 1) then (     list->excludes(1) ; 
     return list ) else skip ; 
     if (n = 2) then (     list->excludes(2) ; 
     return list ) else skip ; 
     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while true do ( (     count := count + 1 ; 
     if (i = n) then (     list->excludes(count) ; 
     return list ) else     if (i > n) then (     list->excludes(count - 1) ; 
     execute game(list, n - (i / 2)) ; 
     return list ) else skip ; )  ;     i := i * 2 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Sequence{} ;
    var list : Sequence(int) ; list := game(l, n) ;
        var i : int ; i := 0 ; while i < list->size() do (     OclFile["System.out"].print(list->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class SlimeCombining {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    ArrayList<Integer>A=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      A.add(1);
    }
    for(int x=0 ; x<n ; x++){
      int i=0 ;
      while(i<A.size()-1){
        if(A.get(i)==A.get(i+1)){
          A.set(i,A.get(i)+1);
          A.set(i+1,0);
        }
        i++;
      }
      Iterator itr=A.iterator();
      while(itr.hasNext()){
        if((Integer)itr.next()==0){
          itr.remove();
        }
      }
    }
    for(int i=0 ; i<A.size(); i++){
      System.out.print(A.get(i)+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SlimeCombining {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     A := A->including(1) )  ;     i := i + 1 ) ; 
        var x : int ; x := 0 ; while x < n do ( (     var i : int ; i := 0 ;
     while (i < A->size() - 1) do (     if (A->at(i+1) = A->at(i + 1+1)) then (     A := A.setAt(i+1,A->at(i+1) + 1) ; 
     A := A.setAt(i + 1+1,0) ) else skip ; 
     i := i + 1 ) ; 
     var itr : OclIterator ; itr := A->iterator() ;
     while (itr.hasNext()) do (     if (itr.next()->oclAsType(int) = 0) then (     itr := itr.remove() ) else skip ) )  ;     x := x + 1 ) ; 
        var i : int ; i := 0 ; while i < A->size() do ( (     OclFile["System.out"].print(A->at(i+1) + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=scan.nextInt();
      int[] arr=new int[n];
      for(int j=0 ; j<n ; j++){
        arr[j]=scan.nextInt();
      }
      printArrayB(n,arr);
    }
  }
  public static void printArrayB(int n,int[] arr){
    if(n==1){
      System.out.println("YES");
      System.out.println(1);
      return ;
    }
    StringBuilder sb=new StringBuilder();
    Set<Integer>set=new HashSet<>();
    Arrays.sort(arr);
    int[] diffs=new int[n*(n-1)/2];
    int idx=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        diffs[idx++]=arr[j]-arr[i];
      }
    }
    sb.append("YES\n");
    int count=0 ;
    int cur=1 ;
    Random random=new Random();
    while(count<n){
      cur=random.nextInt(1000*1000)+1 ;
      boolean valid=true ;
      for(int num : arr){
        if(set.contains(num+cur)){
          valid=false ;
          break ;
        }
      }
      if(valid){
        count++;
        sb.append(cur).append(" ");
        if(valid){
          for(int hum : arr){
            set.add(hum+cur);
          }
        }
      }
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var j : int ; j := 0 ; while j < n do ( (     arr[j+1] := scan.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
     execute printArrayB(n, arr) )  ;     i := i + 1 ) );
  static   operation printArrayB( n : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (n = 1) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
     var sb : String ; sb := StringLib.newString() ;
    var set : Set(int) ; set := Set{} ;
    arr := arr->sort() ; 
    var diffs : Sequence(int) ; diffs := Integer.subrange(1,n * (n - 1) / 2)->collect(0) ;
    var idx : int ; idx := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (      diffs[idx+1] := arr[j+1] - arr[i+1]  ; idx := idx + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString("YES\n") ; 
    var count : int ; count := 0 ;
    var cur : int ; cur := 1 ;
    var random : OclRandom ; random := OclRandom.newOclRandom() ;
    while (count < n) do (     cur := random.nextInt(1000 * 1000) + 1 ; 
     var valid : boolean ; valid := true ;
     for (num : arr) do ( (     if (set->includes(num + cur)) then (     valid := false ; 
     break ) else skip )  ) ; 
     if (valid) then (     count := count + 1 ; 
     sb := sb + StringLib.newString(cur) + StringLib.newString(" ") ; 
     if (valid) then (     for (hum : arr) do ( (     set := set->including(hum + cur) )  ) ) else skip ) else skip ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math ;
import java.io.*;
class GFG {
  static int nextPowerOfFour(int n){
    int x=(int)Math.floor(Math.sqrt(Math.sqrt(n)));
    if(Math.pow(x,4)==n)return n ;
    else {
      x=x+1 ;
      return(int)Math.pow(x,4);
    }
  }
  public static void main(String[] args)throws java.lang.Exception {
    int n=122 ;
    System.out.println(nextPowerOfFour(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nextPowerOfFour( n : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := (((n)->sqrt())->sqrt())->floor()->oclAsType(int) ;
     if (x->pow(4) = n) then     return n else (     x := x + 1 ; 
     return x->pow(4)->oclAsType(int) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 122 ;
     OclFile["System.out"].println(nextPowerOfFour(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int division(int num1,int num2){
    if(num1==0)return 0 ;
    if(num2==0)return Integer.MAX_VALUE ;
    boolean negResult=false ;
    if(num1<0){
      num1=-num1 ;
      if(num2<0)num2=-num2 ;
      else negResult=true ;
    }
    else if(num2<0){
      num2=-num2 ;
      negResult=true ;
    }
    int quotient=0 ;
    while(num1>=num2){
      num1=num1-num2 ;
      quotient++;
    }
    if(negResult)quotient=-quotient ;
    return quotient ;
  }
  public static void main(String[] args){
    int num1=13,num2=2 ;
    System.out.println(division(num1,num2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation division( num1 : int, num2 : int) : int
  pre: true
  post: true
  activity: (     if (num1 = 0) then     return 0 else skip ; 
     if (num2 = 0) then     return 2147483647 else skip ; 
    var negResult : boolean ; negResult := false ;
    if (num1 < 0) then (     num1 := -num1 ; 
     if (num2 < 0) then     num2 := -num2 ; else     negResult := true ; ) else     if (num2 < 0) then (     num2 := -num2 ; 
     negResult := true ) else skip ; ;  
    var quotient : int ; quotient := 0 ;
    while (num1 >= num2) do (     num1 := num1 - num2 ; 
     quotient := quotient + 1 ) ; 
    if (negResult) then     quotient := -quotient ; else skip ; 
    return quotient 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num1 : int ; num1 := 13 ;
    var num2 : int ; num2 := 2 ;
     OclFile["System.out"].println(division(num1, num2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] a=new long[n];
    long max=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
      max=Math.max(max,a[i]);
    }
    long half=0 ;
    for(int i=0 ; i<n ; i++){
      if(Math.abs(max/2-a[i])<Math.abs(max/2-half)){
        half=a[i];
      }
    }
    System.out.println(max+" "+half);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var max : long ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() ; 
     max := Set{max, a[i+1]}->max() )  ;     i := i + 1 ) ; 
    var half : long ; half := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (if max / 2 - a[i+1] < 0 then -(max / 2 - a[i+1]) else max / 2 - a[i+1] endif < if max / 2 - half < 0 then -(max / 2 - half) else max / 2 - half endif) then (     half := a[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max + " " + half) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    DBinomialCoefficients solver=new DBinomialCoefficients();
    solver.solve(1,in,out);
    out.close();
  }
  static class DBinomialCoefficients {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      Arrays.sort(a);
      int col=a[n-1];
      int min=col/2 ;
      int max=min+(col % 2==0 ? 0 : 1);
      out.print(col);
      out.print(' ');
      int d=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; i++){
        int cd=Math.min(Math.abs(max-a[i]),Math.abs(min-a[i]));
        if(cd<d){
          d=cd ;
        }
        else {
          out.println(a[i-1]);
          return ;
        }
      }
      out.println(a[n-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : DBinomialCoefficients ; solver := DBinomialCoefficients.newDBinomialCoefficients() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class DBinomialCoefficients {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var col : int ; col := a[n - 1+1] ;
    var min : int ; min := col / 2 ;
    var max : int ; max := min + (if col mod 2 = 0 then 0 else 1 endif) ;
    skip ; 
    skip ; 
    var d : int ; d := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     var cd : int ; cd := Set{if max - a[i+1] < 0 then -(max - a[i+1]) else max - a[i+1] endif, if min - a[i+1] < 0 then -(min - a[i+1]) else min - a[i+1] endif}->min() ;
     if (cd < d) then (     d := cd ) else (     skip ; 
     return ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    TreeSet<Integer>set=new TreeSet<>();
    for(int i=0 ; i<n ; i++){
      set.add(sc.nextInt());
    }
    int ans1=set.last(),ans2=0,diff=Integer.MAX_VALUE ;
    Integer h=set.ceiling(ans1/2);
    Integer l=set.lower(ans1/2);
    if(h==ans1){
      h=l ;
    }
    if(ans1 % 2==0){
      int base=ans1/2 ;
      if(h!=null){
        int d=Math.abs(base-h);
        if(d<diff){
          diff=d ;
          ans2=h ;
        }
      }
      if(l!=null){
        int d=Math.abs(base-l);
        if(d<diff){
          diff=d ;
          ans2=l ;
        }
      }
    }
    else {
      int base=ans1/2 ;
      int base2=ans1/2+1 ;
      if(h!=null){
        int d=Math.abs(base2-h);
        if(d<diff){
          diff=d ;
          ans2=h ;
        }
      }
      if(l!=null){
        int d=Math.abs(base-l);
        if(d<diff){
          diff=d ;
          ans2=l ;
        }
      }
    }
    System.out.println(ans1+" "+ans2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     set := set->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var ans1 : int ; ans1 := set->last() ;
    var ans2 : int ; ans2 := 0 ;
    var diff : int ; diff := 2147483647 ;
    var h : int ; h := set.ceiling(ans1 / 2) ;
    var l : int ; l := set.lower(ans1 / 2) ;
    if (h = ans1) then (     h := l ) else skip ; 
    if (ans1 mod 2 = 0) then (     var base : int ; base := ans1 / 2 ;
     if (h /= null) then (     var d : int ; d := if base - h < 0 then -(base - h) else base - h endif ;
     if (d < diff) then (     diff := d ; 
     ans2 := h ) else skip ) else skip ; 
     if (l /= null) then (     var d : int ; d := if base - l < 0 then -(base - l) else base - l endif ;
     if (d < diff) then (     diff := d ; 
     ans2 := l ) else skip ) else skip ) else (     var base : int ; base := ans1 / 2 ;
     var base2 : int ; base2 := ans1 / 2 + 1 ;
     if (h /= null) then (     var d : int ; d := if base2 - h < 0 then -(base2 - h) else base2 - h endif ;
     if (d < diff) then (     diff := d ; 
     ans2 := h ) else skip ) else skip ; 
     if (l /= null) then (     var d : int ; d := if base - l < 0 then -(base - l) else base - l endif ;
     if (d < diff) then (     diff := d ; 
     ans2 := l ) else skip ) else skip ) ;  
    OclFile["System.out"].println(ans1 + " " + ans2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    int[] pos=new int[n+1];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      pos[arr[i] ]=i ;
    }
    int[] L=new int[n+1];
    int[] R=new int[n+1];
    TreeSet<Integer>set=new TreeSet<>();
    L[n]=pos[n]+1 ;
    R[n]=n-pos[n];
    set.add(pos[n]);
    long res=0 ;
    for(int k=n-1 ; k>=1 ; k--){
      Integer left=set.lower(pos[k]);
      Integer right=set.higher(pos[k]);
      if(left==null){
        L[k]=pos[k]+1 ;
      }
      else {
        L[k]=pos[k]-left ;
        R[arr[left] ]=L[k];
      }
      if(right==null){
        R[k]=n-pos[k];
      }
      else {
        R[k]=right-pos[k];
        L[arr[right] ]=R[k];
      }
      if(left!=null){
        res+=((long)k)*((long)L[arr[left] ])*((long)R[k]);
      }
      if(right!=null){
        res+=((long)k)*((long)L[k])*((long)R[arr[right] ]);
      }
      set.add(pos[k]);
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var pos : Sequence(int) ; pos := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     pos[arr[i+1]+1] := i )  ;     i := i + 1 ) ; 
    var L : Sequence(int) ; L := Integer.subrange(1,n + 1)->collect(0) ;
    var R : Sequence(int) ; R := Integer.subrange(1,n + 1)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
    L[n+1] := pos[n+1] + 1 ; 
    R[n+1] := n - pos[n+1] ; 
    set := set->including(pos[n+1]) ; 
    var res : long ; res := 0 ;
        var k : int ; k := n - 1 ; while k >= 1 do ( (     var left : int ; left := set.lower(pos[k+1]) ;
     var right : int ; right := set.higher(pos[k+1]) ;
    if (left = null) then (     L[k+1] := pos[k+1] + 1 ) else (     L[k+1] := pos[k+1] - left ; 
     R[arr[left+1]+1] := L[k+1] ) ;  
    if (right = null) then (     R[k+1] := n - pos[k+1] ) else (     R[k+1] := right - pos[k+1] ; 
     L[arr[right+1]+1] := R[k+1] ) ;  
    if (left /= null) then (     res := res+((k->oclAsType(long)) * (L[arr[left+1]+1]->oclAsType(long)) * (R[k+1]->oclAsType(long))) ) else skip ; 
    if (right /= null) then (     res := res+((k->oclAsType(long)) * (L[k+1]->oclAsType(long)) * (R[arr[right+1]+1]->oclAsType(long))) ) else skip ; 
    set := set->including(pos[k+1]) ; 
 )  ;     k := k - 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.PriorityQueue ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int[] input=new int[n];
    String[] tmpArray=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      input[i]=Integer.parseInt(tmpArray[i]);
    }
    Arrays.sort(input);
    int a=0 ;
    int b=n-1 ;
    int med=input[n-1]/2 ;
    for(int i=1 ; i<n-2 ; i++){
      if(Math.abs(input[a]-med)>=Math.abs(input[i]-med)){
        a=i ;
      }
    }
    System.out.println(input[b]+" "+input[a]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var input : Sequence(int) ; input := Integer.subrange(1,n)->collect(0) ;
    var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < n do ( (     input[i+1] := (tmpArray[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    input := input->sort() ; 
    var a : int ; a := 0 ;
    var b : int ; b := n - 1 ;
    var med : int ; med := input[n - 1+1] / 2 ;
        var i : int ; i := 1 ; while i < n - 2 do ( (     if (if input[a+1] - med < 0 then -(input[a+1] - med) else input[a+1] - med endif >= if input[i+1] - med < 0 then -(input[i+1] - med) else input[i+1] - med endif) then (     a := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(input[b+1] + " " + input[a+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    Arrays.sort(a);
    System.out.print(Integer.toString(a[n-1])+" ");
    int ans=a[n-2];
    if(a[n-1] % 2==0){
      int target=a[n-1]/2 ;
      for(int i=n-3 ; i>=0 ; i--){
        if(Math.abs(target-a[i])<Math.abs(target-ans))ans=a[i];
      }
    }
    else {
      int t1=a[n-1]/2 ;
      int t2=a[n-1]/2+1 ;
      for(int i=n-3 ; i>=0 ; i--){
        int old=Math.min(Math.abs(ans-t1),Math.abs(ans-t2));
        int cur=Math.min(Math.abs(a[i]-t1),Math.abs(a[i]-t2));
        if(cur<old)ans=a[i];
      }
    }
    System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    OclFile["System.out"].print(((a[n - 1+1]) + "") + " ") ; 
    var ans : int ; ans := a[n - 2+1] ;
    if (a[n - 1+1] mod 2 = 0) then (     var target : int ; target := a[n - 1+1] / 2 ;
         var i : int ; i := n - 3 ; while i >= 0 do ( (     if (if target - a[i+1] < 0 then -(target - a[i+1]) else target - a[i+1] endif < if target - ans < 0 then -(target - ans) else target - ans endif) then     ans := a[i+1] ; else skip )  ;     i := i - 1 ) ) else (     var t1 : int ; t1 := a[n - 1+1] / 2 ;
     var t2 : int ; t2 := a[n - 1+1] / 2 + 1 ;
         var i : int ; i := n - 3 ; while i >= 0 do ( (     var old : int ; old := Set{if ans - t1 < 0 then -(ans - t1) else ans - t1 endif, if ans - t2 < 0 then -(ans - t2) else ans - t2 endif}->min() ;
     var cur : int ; cur := Set{if a[i+1] - t1 < 0 then -(a[i+1] - t1) else a[i+1] - t1 endif, if a[i+1] - t2 < 0 then -(a[i+1] - t2) else a[i+1] - t2 endif}->min() ;
     if (cur < old) then     ans := a[i+1] ; else skip )  ;     i := i - 1 ) ) ;  
    OclFile["System.out"].print(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p020 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p020().run());
  }
  public String run(){
    String temp=Library.factorial(100).toString();
    int sum=0 ;
    for(int i=0 ; i<temp.length(); i++)sum+=temp.charAt(i)-'0' ;
    return Integer.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
class p020 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p020.newp020().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var temp : String ; temp := Library.factorial(100)+"" ;
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < temp->size() do (     sum := sum+(temp->at(i+1) - ('0')->char2byte()) ;  ;     i := i + 1 ) ; 
     return ((sum) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
class GFG {
  static int NthArmstrong(int n){
    int count=0 ;
    for(int i=1 ; i<=Integer.MAX_VALUE ; i++){
      int num=i,rem,digit=0,sum=0 ;
      num=i ;
      digit=(int)Math.log10(num)+1 ;
      while(num>0){
        rem=num % 10 ;
        sum=sum+(int)Math.pow(rem,digit);
        num=num/10 ;
      }
      if(i==sum)count++;
      if(count==n)return i ;
    }
    return n ;
  }
  public static void main(String[] args){
    int n=12 ;
    System.out.println(NthArmstrong(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation NthArmstrong( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i <= 2147483647 do ( (     var num : int ; num := i ;
    var rem : int ;
    var digit : int ; digit := 0 ;
    var sum : int ; sum := 0 ;
     num := i ; 
    digit := (num)->log10()->oclAsType(int) + 1 ; 
    while (num > 0) do (     rem := num mod 10 ; 
     sum := sum + rem->pow(digit)->oclAsType(int) ; 
     num := num / 10 ) ; 
    if (i = sum) then     count := count + 1 ; else skip ; 
    if (count = n) then     return i else skip ; 
 )  ;     i := i + 1 ) ; 
     return n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     OclFile["System.out"].println(NthArmstrong(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  static int binarySearch(int arr[],int low,int high,int key){
    if(high<low)return-1 ;
    int mid=(low+high)/2 ;
    if(key==arr[mid])return mid ;
    if(key>arr[mid])return binarySearch(arr,(mid+1),high,key);
    return binarySearch(arr,low,(mid-1),key);
  }
  public static void main(String[] args){
    int arr[]={
      5,6,7,8,9,10 };
      int n,key ;
      n=arr.length ;
      key=10 ;
      System.out.println("Index: "+binarySearch(arr,0,n,key));
    }
  }

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation binarySearch( arr : Sequence(int), low : int, high : int, key : int) : int
  pre: true
  post: true
  activity: (     if (high < low) then     return -1 else skip ; 
     var mid : int ; mid := (low + high) / 2 ;
    if (key = arr[mid+1]) then     return mid else skip ; 
    if (key > arr[mid+1]) then     return binarySearch(arr, (mid + 1), high, key) else skip ; 
    return binarySearch(arr, low, (mid - 1), key) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,6,7,8,9,10} ;
     var n : int ;
    var key : int ;
    n := arr->size() ; 
    key := 10 ; 
    OclFile["System.out"].println("Index: " + binarySearch(arr, 0, n, key)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces3 {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      System.out.println((n-3)+" "+1+" "+1+" "+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     OclFile["System.out"].println((n - 3) + " " + 1 + " " + 1 + " " + 1) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t--!=0){
      int n=scanner.nextInt();
      System.out.println(n-3+" "+1+" "+1+" "+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(n - 3 + " " + 1 + " " + 1 + " " + 1) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
import static java.lang.Double.parseDouble ;
import static java.lang.Integer.bitCount ;
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
public class Test3 {
  private static final BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
  private static final Fast in=new Fast();
  public static void main(String[] args)throws IOException {
    int num=in.nextInt();
    for(int i=0 ; i<num ; i++){
      int n=in.nextInt();
      out.write((n-3)+" 1 1 1\n");
    }
    out.flush();
  }
  public static class Fast {
    BufferedReader br ;
    StringTokenizer st ;
    public Fast(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public Fast(FileReader f){
      br=new BufferedReader(f);
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return parseInt(next());
    }
    public long nextLong()throws IOException {
      return parseLong(next());
    }
    public double nextDouble()throws IOException {
      return parseDouble(next());
    }
    public float nextFloat()throws IOException {
      return Float.parseFloat(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test3 {
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static    attribute in : Fast := Fast.newFast();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := in.nextInt() ;
         var i : int ; i := 0 ; while i < num do ( (     var n : int ; n := in.nextInt() ;
     skip )  ;     i := i + 1 ) ; 
     skip );
  static class Fast {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFast() : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   static operation newFast( f : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(f) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next() + "")->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return parseDouble(next()) );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class TaskC {
  static final int SIZE=(int)2e5+5 ;
  static ArrayList<Long>li=new ArrayList<>();
  public static void solve(InputReader in,PrintWriter out){
    int n=in.nextInt();
    int t=n-2 ;
    out.println(1+" "+(t-1)+" 1 "+"1");
  }
  public static void init(){
  }
  public static void clear(int n){
  }
  public static void main(String[] args){
    init();
    InputReader in=new InputReader(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int T=1 ;
    T=in.nextInt();
    for(int i=1 ; i<=T ; ++i){
      solve(in,out);
    }
    out.close();
  }
  private static class InputReader {
    private BufferedReader reader ;
    private StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=reader.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TaskC {
  static    attribute SIZE : int := 2e5->oclAsType(int) + 5;
  static   attribute li : Sequence(long) := Sequence{};
  static   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var t : int ; t := n - 2 ;
     out.println(1 + " " + (t - 1) + " 1 " + "1") );
  static   operation init() : void
  pre: true
  post: true
  activity: skip;
  static   operation clear( n : int) : void
  pre: true
  post: true
  activity: skip;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute init() ; 
     var in : InputReader ; in := InputReader.newInputReader(OclFile["System.in"]) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := 1 ;
    T := in.nextInt() ; 
        var i : int ; i := 1 ; while i <= T do ( (     execute solve(in, out) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := reader.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sin=new Scanner(System.in);
    int n=sin.nextInt();
    BigInteger plus ;
    System.out.println(2);
    for(int i=2 ; i<n+1 ; i++){
      plus=BigInteger.valueOf(i+1);
      plus=plus.multiply(plus);
      plus=plus.multiply(BigInteger.valueOf(i));
      plus=plus.subtract(BigInteger.valueOf(i-1));
      System.out.println(plus);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sin : OclFile ; sin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sin.getCurrent()->toInteger() ;
    var plus : long ;
    OclFile["System.out"].println(2) ; 
        var i : int ; i := 2 ; while i < n + 1 do ( (     plus := (i + 1 + "")->toLong() ; 
     plus := plus.multiply(plus) ; 
    plus := plus.multiply((i + "")->toLong()) ; 
    plus := plus.subtract((i - 1 + "")->toLong()) ; 
    OclFile["System.out"].println(plus) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf3 {
  private static Scanner is=new Scanner(System.in);
  public static long isSquare(long n){
    double sq=Math.sqrt(n);
    if((long)sq*(long)sq==n)return(long)sq ;
    else return-1 ;
  }
  public static void main(String[] args){
    int n=is.nextInt();
    long[] pluses=new long[n];
    long onScreen=2 ;
    int k=2 ;
    pluses[0]=2 ;
    long nextsq=6 ;
    while(k<n+1){
      pluses[k-1]=nextsq*((long)(k+1))-(long)(k-1);
      k++;
      onScreen=nextsq ;
      long sq=isSquare(k);
      nextsq=k*(k+1);
    }
    System.out.println(2);
    for(long i=2 ; i<=n ; i++){
      System.out.println(i*(i+1)*(i+1)-(i-1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf3 {
  static   attribute is : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation isSquare( n : long) : long
  pre: true
  post: true
  activity: (     var sq : double ; sq := (n)->sqrt() ;
     if (sq->oclAsType(long) * sq->oclAsType(long) = n) then     return sq->oclAsType(long) else     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := is.getCurrent()->toInteger() ;
     var pluses : Sequence(long) ; pluses := Integer.subrange(1,n)->collect(0) ;
    var onScreen : long ; onScreen := 2 ;
    var k : int ; k := 2 ;
    pluses[0+1] := 2 ; 
    var nextsq : long ; nextsq := 6 ;
    while (k < n + 1) do (     pluses[k - 1+1] := nextsq * ((k + 1)->oclAsType(long)) - (k - 1)->oclAsType(long) ; 
     k := k + 1 ; 
    onScreen := nextsq ; 
    var sq : long ; sq := isSquare(k) ;
    nextsq := k * (k + 1) ; 
 ) ; 
    OclFile["System.out"].println(2) ; 
        var i : long ; i := 2 ; while i <= n do ( (     OclFile["System.out"].println(i * (i + 1) * (i + 1) - (i - 1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    int[] P=new int[N];
    int[] A=new int[N+1];
    for(int i=0 ; i<N ; ++i){
      P[i]=Integer.parseInt(sc.next());
      A[P[i] ]=i+1 ;
    }
    sc.close();
    TreeSet<Integer>set=new TreeSet<>();
    set.add(0);
    set.add(N+1);
    set.add(A[N]);
    long sum=0 ;
    for(int i=N-1 ; i>=1 ; --i){
      int Xi=A[i];
      long y=set.higher(Xi);
      long z=y<N+1 ? set.higher((int)y): N+1 ;
      long x=set.lower(Xi);
      long w=x!=0 ? set.lower((int)x): 0 ;
      long C=(x-w)*(y-Xi)+(Xi-x)*(z-y);
      sum+=C*i ;
      set.add(Xi);
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var P : Sequence(int) ; P := Integer.subrange(1,N)->collect(0) ;
    var A : Sequence(int) ; A := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     P[i+1] := (sc.getCurrent())->toInteger() ; 
     A[P[i+1]+1] := i + 1 )  ;     i := i + 1 ) ; 
    skip ; 
    var set : Set(int) ; set := Set{} ;
    set := set->including(0) ; 
    set := set->including(N + 1) ; 
    set := set->including(A[N+1]) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := N - 1 ; while i >= 1 do ( (     var Xi : int ; Xi := A[i+1] ;
     var y : long ; y := set.higher(Xi) ;
    var z : long ; z := if y < N + 1 then set.higher(y->oclAsType(int)) else N + 1 endif ;
    var x : long ; x := set.lower(Xi) ;
    var w : long ; w := if x /= 0 then set.lower(x->oclAsType(int)) else 0 endif ;
    var C : long ; C := (x - w) * (y - Xi) + (Xi - x) * (z - y) ;
    sum := sum+(C * i) ; 
    set := set->including(Xi) ; 
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf3 {
  private static Scanner is=new Scanner(System.in);
  public static long isSquare(long n){
    double sq=Math.sqrt(n);
    if((long)sq*(long)sq==n)return(long)sq ;
    else return-1 ;
  }
  public static void main(String[] args){
    int n=is.nextInt();
    long[] pluses=new long[n];
    long onScreen=2 ;
    int k=2 ;
    pluses[0]=2 ;
    long nextsq=2 ;
    while(k<n+1){
      pluses[k-1]=((long)(k+1))*(k+1)*k-(k-1);
      k++;
      onScreen=nextsq ;
      long sq=isSquare(k);
      nextsq=k*(k+1);
    }
    for(int i=0 ; i<n ; i++){
      System.out.println(Math.abs(pluses[i]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf3 {
  static   attribute is : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation isSquare( n : long) : long
  pre: true
  post: true
  activity: (     var sq : double ; sq := (n)->sqrt() ;
     if (sq->oclAsType(long) * sq->oclAsType(long) = n) then     return sq->oclAsType(long) else     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := is.getCurrent()->toInteger() ;
     var pluses : Sequence(long) ; pluses := Integer.subrange(1,n)->collect(0) ;
    var onScreen : long ; onScreen := 2 ;
    var k : int ; k := 2 ;
    pluses[0+1] := 2 ; 
    var nextsq : long ; nextsq := 2 ;
    while (k < n + 1) do (     pluses[k - 1+1] := ((k + 1)->oclAsType(long)) * (k + 1) * k - (k - 1) ; 
     k := k + 1 ; 
    onScreen := nextsq ; 
    var sq : long ; sq := isSquare(k) ;
    nextsq := k * (k + 1) ; 
 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(if pluses[i+1] < 0 then -(pluses[i+1]) else pluses[i+1] endif) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean digitWell(int n,int m,int k){
    int cnt=0 ;
    while(n>0){
      if(n % 10==m)++cnt ;
      n/=10 ;
    }
    return cnt==k ;
  }
  static int findInt(int n,int m,int k){
    int i=n+1 ;
    while(true){
      if(digitWell(i,m,k))return i ;
      i++;
    }
  }
  public static void main(String[] args){
    int n=111,m=2,k=2 ;
    System.out.println(findInt(n,m,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation digitWell( n : int, m : int, k : int) : boolean
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     while (n > 0) do (     if (n mod 10 = m) then     cnt := cnt + 1 ; else skip ; 
     n := n/(10) ) ; 
     return cnt = k );
  static   operation findInt( n : int, m : int, k : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := n + 1 ;
     while (true) do (     if (digitWell(i, m, k)) then     return i else skip ; 
     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 111 ;
    var m : int ; m := 2 ;
    var k : int ; k := 2 ;
     OclFile["System.out"].println(findInt(n, m, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static int findCount(int d){
    return 9*(int)((Math.pow(10,d-1)-Math.pow(9,d-1)));
  }
  static int findCountUpto(int d){
    int totalCount=0 ;
    for(int i=1 ; i<=d ; i++)totalCount+=findCount(i);
    return totalCount ;
  }
  public static void main(String args[]){
    int d=1 ;
    System.out.println(findCountUpto(d));
    d=2 ;
    System.out.println(findCountUpto(d));
    d=4 ;
    System.out.println(findCountUpto(d));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findCount( d : int) : int
  pre: true
  post: true
  activity: (     return 9 * ((10->pow(d - 1) - 9->pow(d - 1)))->oclAsType(int) );
  static   operation findCountUpto( d : int) : int
  pre: true
  post: true
  activity: (     var totalCount : int ; totalCount := 0 ;
         var i : int ; i := 1 ; while i <= d do (     totalCount := totalCount+(findCount(i)) ;  ;     i := i + 1 ) ; 
     return totalCount );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : int ; d := 1 ;
     OclFile["System.out"].println(findCountUpto(d)) ; 
    d := 2 ; 
    OclFile["System.out"].println(findCountUpto(d)) ; 
    d := 4 ; 
    OclFile["System.out"].println(findCountUpto(d)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void equal_xor_sum(int arr[],int n){
    int Sum=0 ;
    int Xor=0 ;
    for(int i=0 ; i<n ; i++){
      Sum=Sum+arr[i];
      Xor=Xor ^ arr[i];
    }
    if(Sum==Xor)System.out.println("YES");
    else System.out.println("NO");
  }
  public static void main(String[] args){
    int arr[]={
      6,3,7,10 };
      int n=arr.length ;
      equal_xor_sum(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation equal_xor_sum( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var Sum : int ; Sum := 0 ;
     var Xor : int ; Xor := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     Sum := Sum + arr[i+1] ; 
     Xor := MathLib.bitwiseXor(Xor,arr[i+1]) )  ;     i := i + 1 ) ; 
     if (Sum = Xor) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,3,7,10} ;
     var n : int ; n := arr->size() ;
     execute equal_xor_sum(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt(),a=sc.nextInt(),b=sc.nextInt();
      int[] arr=new int[n+1];
      for(int i=1 ; i<=n ; i++){
        arr[n-i+1]=i ;
      }
      if(a<b){
        arr[n-a+1]=b ;
        arr[n-b+1]=a ;
      }
      if(a<=n/2 && b>n/2 || a==n/2+1 && b==n/2){
        for(int i=1 ; i<=n ; i++)System.out.print(arr[i]+" ");
        System.out.println();
      }
      else System.out.println("-1");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[n - i + 1+1] := i )  ;     i := i + 1 ) ; 
    if (a < b) then (     arr[n - a + 1+1] := b ; 
     arr[n - b + 1+1] := a ) else skip ; 
    if (a <= n / 2 & b > n / 2 or a = n / 2 + 1 & b = n / 2) then (         var i : int ; i := 1 ; while i <= n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) else     OclFile["System.out"].println("-1") ; ;  
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  static int getMissingNo(int a[],int n){
    int i,total ;
    total=(n+1)*(n+2)/2 ;
    for(i=0 ; i<n ; i++)total-=a[i];
    return total ;
  }
  public static void main(String args[]){
    int a[]={
      1,2,4,5,6 };
      int miss=getMissingNo(a,5);
      System.out.println(miss);
    }
  }

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation getMissingNo( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var total : int ;
     total := (n + 1) * (n + 2) / 2 ; 
         i := 0 ; while i < n do (     total := total-(a[i+1]) ;  ;     i := i + 1 ) ; 
     return total );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,4,5,6} ;
     var miss : int ; miss := getMissingNo(a, 5) ;
     OclFile["System.out"].println(miss) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    Integer[] A=new Integer[N];
    int all=0 ;
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
      all+=A[i];
    }
    sc.close();
    Arrays.sort(A,Collections.reverseOrder());
    if(A[M-1]<Math.ceil(all/(4.0*M))){
      System.out.println("No");
      return ;
    }
    System.out.println("Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(null) ;
    var all : int ; all := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() ; 
     all := all+(A[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
    A := OclComparator.sortWith(A, reverseOrder()) ; 
    if (A[M - 1+1] < (all / (4.0 * M))->ceil()) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
    OclFile["System.out"].println("Yes") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException {
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] a=new int[n];
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      sum+=a[i];
    }
    Arrays.sort(a);
    int val=(sum+(4*m-1))/(4*m);
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]>=val){
        count++;
      }
    }
    if(count>=m)out.println("Yes");
    else out.println("No");
    out.flush();
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(FileReader fileReader){
      br=new BufferedReader(fileReader);
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var val : int ; val := (sum + (4 * m - 1)) / (4 * m) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] >= val) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (count >= m) then     skip else     skip ; ;  
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( fileReader : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(fileReader);
    return self );
  operation initialise( fileReader : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(fileReader) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    ArrayList<Integer>numeros=new ArrayList<Integer>();
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    double M=scan.nextFloat();
    int contador=0 ;
    int sumaTotal=0 ;
    double valor=0 ;
    double porcentaje=(1/(4*M));
    while(contador<N){
      int numerito=scan.nextInt();
      numeros.add(numerito);
      sumaTotal+=numerito ;
      contador++;
    }
    valor=sumaTotal*porcentaje ;
    contador=0 ;
    for(Integer a : numeros){
      if(a>=valor){
        contador++;
      }
    }
    if(contador>=M){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var numeros : Sequence(int) ; numeros := Sequence{} ;
     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var N : int ; N := scan.getCurrent()->toInteger() ;
    var M : double ; M := scan.nextFloat() ;
    var contador : int ; contador := 0 ;
    var sumaTotal : int ; sumaTotal := 0 ;
    var valor : double ; valor := 0 ;
    var porcentaje : double ; porcentaje := (1 / (4 * M)) ;
    while (contador < N) do (     var numerito : int ; numerito := scan.getCurrent()->toInteger() ;
     numeros := numeros->including(numerito) ; 
     sumaTotal := sumaTotal+(numerito) ; 
     contador := contador + 1 ) ; 
    valor := sumaTotal * porcentaje ; 
    contador := 0 ; 
    for (a : numeros) do ( (     if (a >= valor) then (     contador := contador + 1 ) else skip )  ) ; 
    if (contador >= M) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int total=scanner.nextInt();
    long popular=scanner.nextInt();
    int[] target=new int[total];
    int tokuhyo ;
    String result="Yes" ;
    for(int i=0 ; i<total ; i++){
      target[i]=scanner.nextInt();
    }
    scanner.close();
    tokuhyo=java.util.Arrays.stream(target).sum();
    target=Arrays.stream(target).boxed().sorted(Comparator.reverseOrder()).mapToInt(Integer :: intValue).toArray();
    long t=4*popular ;
    double l=(double)1/t ;
    double s=tokuhyo*l ;
    for(int i=0 ; i<popular ; i++){
      if(target[i]<s){
        result="No" ;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var total : int ; total := scanner.getCurrent()->toInteger() ;
    var popular : long ; popular := scanner.getCurrent()->toInteger() ;
    var target : Sequence(int) ; target := Integer.subrange(1,total)->collect(0) ;
    var tokuhyo : int ;
    var result : String ; result := "Yes" ;
        var i : int ; i := 0 ; while i < total do ( (     target[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    tokuhyo := java.util.Arrays.stream(target)->sum() ; 
    target := stream(target)->sort()->collect( _x1 | (lambda _pars : OclAny in Integer.newInteger().intValue(_pars))->apply(_x1) )->asSequence() ; 
    var t : long ; t := 4 * popular ;
    var l : double ; l := 1->oclAsType(double) / t ;
    var s : double ; s := tokuhyo * l ;
        var i : int ; i := 0 ; while i < popular do ( (     if (target[i+1] < s) then (     result := "No" ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int N ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    int P[]=new int[N];
    for(int i=0 ; i<N ; i++)P[i]=sc.nextInt()-1 ;
    sc.close();
    int idx[]=new int[N];
    for(int i=0 ; i<N ; i++)idx[P[i] ]=i ;
    TreeSet<Integer>ts=new TreeSet<>();
    long ans=0 ;
    for(int i=N-1 ; i>=0 ; i--){
      int now=idx[i];
      int hi1=myHigher(ts,now);
      int hi2=myHigher(ts,hi1);
      int low1=myLower(ts,now);
      int low2=myLower(ts,low1);
      long cnt=(long)(hi2-hi1)*(now-low1)+(long)(hi1-now)*(low1-low2);
      ans+=cnt*(i+1);
      ts.add(now);
    }
    System.out.println(ans);
  }
  static int myHigher(TreeSet<Integer>ts,int now){
    if(ts.higher(now)!=null)return ts.higher(now);
    else return N ;
  }
  static int myLower(TreeSet<Integer>ts,int now){
    if(ts.lower(now)!=null)return ts.lower(now);
    else return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
    var P : Sequence(int) ; P := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     P[i+1] := sc.getCurrent()->toInteger() - 1 ;  ;     i := i + 1 ) ; 
    skip ; 
    var idx : Sequence(int) ; idx := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     idx[P[i+1]+1] := i ;  ;     i := i + 1 ) ; 
    var ts : Set(int) ; ts := Set{} ;
    var ans : long ; ans := 0 ;
        var i : int ; i := N - 1 ; while i >= 0 do ( (     var now : int ; now := idx[i+1] ;
     var hi1 : int ; hi1 := myHigher(ts, now) ;
    var hi2 : int ; hi2 := myHigher(ts, hi1) ;
    var low1 : int ; low1 := myLower(ts, now) ;
    var low2 : int ; low2 := myLower(ts, low1) ;
    var cnt : long ; cnt := (hi2 - hi1)->oclAsType(long) * (now - low1) + (hi1 - now)->oclAsType(long) * (low1 - low2) ;
    ans := ans+(cnt * (i + 1)) ; 
    ts := ts->including(now) ; 
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation myHigher( ts : Set(int), now : int) : int
  pre: true
  post: true
  activity: (     if (ts.higher(now) /= null) then     return ts.higher(now) else     return N );
  static   operation myLower( ts : Set(int), now : int) : int
  pre: true
  post: true
  activity: (     if (ts.lower(now) /= null) then     return ts.lower(now) else     return -1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int[] fact=new int[14];
  static int size=1 ;
  static void preCompute(int N){
    fact[0]=1 ;
    for(int i=1 ; fact[i-1]<=N ; i++){
      fact[i]=(fact[i-1]*i);
      size++;
    }
  }
  static void findMin(int N){
    preCompute(N);
    int originalN=N ;
    Vector<Integer>ans=new Vector<Integer>();
    for(int i=size-1 ; i>=0 ; i--){
      while(N>=fact[i]){
        N-=fact[i];
        ans.add(fact[i]);
      }
    }
    System.out.print(ans.size()+"\n");
    for(int i=0 ; i<ans.size(); i++)System.out.print(ans.get(i)+" ");
  }
  public static void main(String[] args){
    int n=27 ;
    findMin(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute fact : Sequence(int) := Integer.subrange(1,14)->collect(0);
  static   attribute size : int := 1;
  static   operation preCompute( N : int) : void
  pre: true
  post: true
  activity: (     fact[0+1] := 1 ; 
         var i : int ; i := 1 ; while fact[i - 1+1] <= N do ( (     fact[i+1] := (fact[i - 1+1] * i) ; 
     size := size + 1 )  ;     i := i + 1 ) );
  static   operation findMin( N : int) : void
  pre: true
  post: true
  activity: (     execute preCompute(N) ; 
     var originalN : int ; originalN := N ;
    var ans : Sequence(int) ; ans := Sequence{} ;
        var i : int ; i := size - 1 ; while i >= 0 do ( (     while (N >= fact[i+1]) do (     N := N-(fact[i+1]) ; 
     ans := ans->including(fact[i+1]) ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].print(ans->size() + "\n") ; 
        var i : int ; i := 0 ; while i < ans->size() do (     OclFile["System.out"].print(ans->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 27 ;
     execute findMin(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  static boolean[] x=new boolean[10000001];
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder out=new StringBuilder();
    StringTokenizer tk=new StringTokenizer(in.readLine());
    int n=Int(tk.nextToken()),m=Int(tk.nextToken()),k=Int(tk.nextToken());
    tk=new StringTokenizer(in.readLine());
    for(int i=0 ; i<m ; i++){
      x[Int(tk.nextToken())]=true ;
    }
    int pos=1 ;
    while(k-->0){
      if(x[pos]){
        System.out.println(pos);
        return ;
      }
      tk=new StringTokenizer(in.readLine());
      int a=Int(tk.nextToken()),b=Int(tk.nextToken());
      pos=(pos==a)? b : pos==b ? a : pos ;
    }
    System.out.println(pos);
  }
  static int Int(String s){
    return Integer.parseInt(s);
  }
  static long Lon(String s){
    return Long.parseLong(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute x : Sequence(boolean) := Integer.subrange(1,10000001)->collect(false);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : String ; out := StringLib.newString() ;
    var tk : OclIterator ; tk := OclIterator.newOclIterator_String(in.readLine()) ;
    var n : int ; n := Int(tk.next()) ;
    var m : int ; m := Int(tk.next()) ;
    var k : int ; k := Int(tk.next()) ;
    tk := OclIterator.newOclIterator_String(in.readLine()) ; 
        var i : int ; i := 0 ; while i < m do ( (     x[Int(tk.next())+1] := true )  ;     i := i + 1 ) ; 
    var pos : int ; pos := 1 ;
        while (k > 0) do (        k := k - 1 ;     skip ; (     if (x[pos+1]) then (     OclFile["System.out"].println(pos) ; 
     return ) else skip ; 
     tk := OclIterator.newOclIterator_String(in.readLine()) ; 
     var a : int ; a := Int(tk.next()) ;
    var b : int ; b := Int(tk.next()) ;
     pos := if (pos = a) then b else if pos = b then a else pos endif endif ) ;  ) ;  
    OclFile["System.out"].println(pos) ; 
 );
  static   operation Int( s : String) : int
  pre: true
  post: true
  activity: (     return (s)->toInteger() );
  static   operation Lon( s : String) : long
  pre: true
  post: true
  activity: (     return (s)->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Odd {
  public static int oddSum(int n){
    int sum=0,curr=1 ;
    for(int i=0 ; i<n ; i++){
      sum+=curr ;
      curr+=2 ;
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=20 ;
    System.out.println(" Sum of first "+n+" Odd Numbers is: "+oddSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Odd {
  static   operation oddSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
    var curr : int ; curr := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(curr) ; 
     curr := curr+(2) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 20 ;
     OclFile["System.out"].println(" Sum of first " + n + " Odd Numbers is: " + oddSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean checkValidPair(int num1,int num2){
    String s1=Integer.toString(num1);
    String s2=Integer.toString(num2);
    for(int i=0 ; i<s1.length(); i++)for(int j=0 ; j<s2.length(); j++)if(s1.charAt(i)==s2.charAt(j))return true ;
    return false ;
  }
  static int countPairs(int[] arr,int n){
    int numberOfPairs=0 ;
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++)if(checkValidPair(arr[i],arr[j]))numberOfPairs++;
    return numberOfPairs ;
  }
  public static void main(String args[]){
    int[] arr=new int[] {
      10,12,24 };
      int n=arr.length ;
      System.out.print(countPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkValidPair( num1 : int, num2 : int) : boolean
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := ((num1) + "") ;
     var s2 : String ; s2 := ((num2) + "") ;
         var i : int ; i := 0 ; while i < s1->size() do (         var j : int ; j := 0 ; while j < s2->size() do (     if (s1->at(i+1) = s2->at(j+1)) then     return true else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return false );
  static   operation countPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var numberOfPairs : int ; numberOfPairs := 0 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do (     if (checkValidPair(arr[i+1], arr[j+1])) then     numberOfPairs := numberOfPairs + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return numberOfPairs );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,12,24} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(countPairs(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
class GFG {
  static ArrayList values_of_r_and_a(double m,double n,double mth,double nth){
    if(m<n){
      double t=m ;
      n=m ;
      m=t ;
      t=mth ;
      mth=nth ;
      nth=t ;
    }
    double r=Math.pow(mth/nth,1.0/(m-n));
    double a=mth/Math.pow(r,(m-1));
    ArrayList arr=new ArrayList();
    arr.add(a);
    arr.add(r);
    return arr ;
  }
  static double FindSum(double m,double n,double mth,double nth,double p){
    ArrayList ar=values_of_r_and_a(m,n,mth,nth);
    double a=(double)ar.get(0);
    double r=(double)ar.get(1);
    double pth=a*Math.pow(r,(p-1.0));
    return pth ;
  }
  public static void main(String[] args){
    double m=10 ;
    double n=5 ;
    double p=15 ;
    double mth=2560 ;
    double nth=80 ;
    System.out.println((int)FindSum(m,n,mth,nth,p));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation values_of_r_and_a( m : double, n : double, mth : double, nth : double) : Sequence
  pre: true
  post: true
  activity: (     if (m < n) then (     var t : double ; t := m ;
     n := m ; 
    m := t ; 
    t := mth ; 
    mth := nth ; 
    nth := t ; 
 ) else skip ; 
     var r : double ; r := mth / nth->pow(1.0 / (m - n)) ;
    var a : double ; a := mth / r->pow((m - 1)) ;
    var arr : Sequence ; arr := Sequence{} ;
    arr := arr->including(a) ; 
    arr := arr->including(r) ; 
    return arr 
 );
  static   operation FindSum( m : double, n : double, mth : double, nth : double, p : double) : double
  pre: true
  post: true
  activity: (     var ar : Sequence ; ar := values_of_r_and_a(m, n, mth, nth) ;
     var a : double ; a := ar->at(0+1)->oclAsType(double) ;
    var r : double ; r := ar->at(1+1)->oclAsType(double) ;
    var pth : double ; pth := a * r->pow((p - 1.0)) ;
    return pth 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : double ; m := 10 ;
     var n : double ; n := 5 ;
    var p : double ; p := 15 ;
    var mth : double ; mth := 2560 ;
    var nth : double ; nth := 80 ;
    OclFile["System.out"].println(FindSum(m, n, mth, nth, p)->oclAsType(int)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class CoinChange {
  static long countWays(int S[],int m,int n){
    long[] table=new long[n+1];
    Arrays.fill(table,0);
    table[0]=1 ;
    for(int i=0 ; i<m ; i++)for(int j=S[i]; j<=n ; j++)table[j]+=table[j-S[i] ];
    return table[n];
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3 };
      int m=arr.length ;
      int n=4 ;
      System.out.println(countWays(arr,m,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class CoinChange {
  static   operation countWays( S : Sequence(int), m : int, n : int) : long
  pre: true
  post: true
  activity: (     var table : Sequence(long) ; table := Integer.subrange(1,n + 1)->collect(0) ;
     table := table->collect(0) ; 
    table[0+1] := 1 ; 
        var i : int ; i := 0 ; while i < m do (         var j : int ; j := S[i+1] ; while j <= n do (     table[j+1] := table[j+1]+(table[j - S[i+1]+1]) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return table[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3} ;
     var m : int ; m := arr->size() ;
     var n : int ; n := 4 ;
     OclFile["System.out"].println(countWays(arr, m, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class CoinChange {
  static long countWays(int S[],int m,int n){
    long[] table=new long[n+1];
    Arrays.fill(table,0);
    table[0]=1 ;
    for(int i=0 ; i<m ; i++)for(int j=S[i]; j<=n ; j++)table[j]+=table[j-S[i] ];
    return table[n];
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3 };
      int m=arr.length ;
      int n=4 ;
      System.out.println(countWays(arr,m,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class CoinChange {
  static   operation countWays( S : Sequence(int), m : int, n : int) : long
  pre: true
  post: true
  activity: (     var table : Sequence(long) ; table := Integer.subrange(1,n + 1)->collect(0) ;
     table := table->collect(0) ; 
    table[0+1] := 1 ; 
        var i : int ; i := 0 ; while i < m do (         var j : int ; j := S[i+1] ; while j <= n do (     table[j+1] := table[j+1]+(table[j - S[i+1]+1]) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return table[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3} ;
     var m : int ; m := arr->size() ;
     var n : int ; n := 4 ;
     OclFile["System.out"].println(countWays(arr, m, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void incrementVector(Vector<Integer>a){
    int n=a.size();
    a.set(n-1,a.get(n-1)+1);
    int carry=a.get(n-1)/10 ;
    a.set(n-1,a.get(n-1)% 10);
    for(int i=n-2 ; i>=0 ; i--){
      if(carry==1){
        a.set(i,a.get(i)+1);
        carry=a.get(i)/10 ;
        a.set(i,a.get(i)% 10);
      }
    }
    if(carry==1)a.add(0,1);
  }
  public static void main(String[] args){
    Vector<Integer>vect=new Vector<Integer>();
    vect.add(1);
    vect.add(7);
    vect.add(8);
    vect.add(9);
    incrementVector(vect);
    for(int i=0 ; i<vect.size(); i++)System.out.print(vect.get(i)+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation incrementVector( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() ;
     a := a.setAt(n - 1+1, a->at(n - 1+1) + 1) ; 
    var carry : int ; carry := a->at(n - 1+1) / 10 ;
    a := a.setAt(n - 1+1, a->at(n - 1+1) mod 10) ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (carry = 1) then (     a := a.setAt(i+1, a->at(i+1) + 1) ; 
     carry := a->at(i+1) / 10 ; 
     a := a.setAt(i+1, a->at(i+1) mod 10) ) else skip )  ;     i := i - 1 ) ; 
    if (carry = 1) then     a->excludes(0, 1) ; else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var vect : Sequence(int) ; vect := Sequence{} ;
     vect := vect->including(1) ; 
    vect := vect->including(7) ; 
    vect := vect->including(8) ; 
    vect := vect->including(9) ; 
    execute incrementVector(vect) ; 
        var i : int ; i := 0 ; while i < vect->size() do (     OclFile["System.out"].print(vect->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
class GFG {
  static boolean pronic_check(int n){
    int x=(int)(Math.sqrt(n));
    if(x*(x+1)==n)return true ;
    else return false ;
  }
  public static void main(String[] args){
    int n=56 ;
    if(pronic_check(n)==true)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pronic_check( n : int) : boolean
  pre: true
  post: true
  activity: (     var x : int ; x := ((n)->sqrt())->oclAsType(int) ;
     if (x * (x + 1) = n) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 56 ;
     if (pronic_check(n) = true) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int d=sc.nextInt();
    int ta=sc.nextInt();
    int tb=sc.nextInt();
    double da=sc.nextInt();
    double db=sc.nextInt();
    double min=Double.MAX_VALUE ;
    for(int i=0 ; i*da<=d ; i++){
      for(int j=0 ; i*da+j*db<=d ; j++){
        if(i==0 && j==0){
          continue ;
        }
        min=Math.min(min,Math.abs((ta*i*da+tb*j*db)/(i*da+j*db)-t));
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var ta : int ; ta := sc.getCurrent()->toInteger() ;
    var tb : int ; tb := sc.getCurrent()->toInteger() ;
    var da : double ; da := sc.getCurrent()->toInteger() ;
    var db : double ; db := sc.getCurrent()->toInteger() ;
    var min : double ; min := (2 - 2->pow(-52))*(2->pow(1023)) ;
        var i : int ; i := 0 ; while i * da <= d do ( (         var j : int ; j := 0 ; while i * da + j * db <= d do ( (     if (i = 0 & j = 0) then (     continue ) else skip ; 
     min := Set{min, if (ta * i * da + tb * j * db) / (i * da + j * db) - t < 0 then -((ta * i * da + tb * j * db) / (i * da + j * db) - t) else (ta * i * da + tb * j * db) / (i * da + j * db) - t endif}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxXOR(int arr[],int n){
    int xorArr=0 ;
    for(int i=0 ; i<n ; i++)xorArr ^=arr[i];
    int ans=0 ;
    for(int i=0 ; i<n ; i++)ans=Math.max(ans,(xorArr ^ arr[i]));
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      1,1,3 };
      int n=arr.length ;
      System.out.println(maxXOR(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxXOR( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var xorArr : int ; xorArr := 0 ;
         var i : int ; i := 0 ; while i < n do (     xorArr := MathLib.bitwiseXor(xorArr,arr[i+1]) ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do (     ans := Set{ans, (MathLib.bitwiseXor(xorArr,arr[i+1]))}->max() ;  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxXOR(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean CheckIfstartsWithOne(int n,int b){
    int m=(int)(Math.log10(n)/Math.log10(2));
    for(int i=1 ; i<=m ; i++){
      if(n>=(int)Math.pow(b,i)&& n<=2*(int)Math.pow(b,i)-1)return true ;
    }
    return false ;
  }
  public static void main(String args[]){
    System.out.println(CheckIfstartsWithOne(6,4)? "Yes" : "No");
    System.out.println(CheckIfstartsWithOne(24,2)? "Yes" : "No");
    System.out.println(CheckIfstartsWithOne(24,7)? "Yes" : "No");
    System.out.println(CheckIfstartsWithOne(24,15)? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation CheckIfstartsWithOne( n : int, b : int) : boolean
  pre: true
  post: true
  activity: (     var m : int ; m := ((n)->log10() / (2)->log10())->oclAsType(int) ;
         var i : int ; i := 1 ; while i <= m do ( (     if (n >= b->pow(i)->oclAsType(int) & n <= 2 * b->pow(i)->oclAsType(int) - 1) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if CheckIfstartsWithOne(6, 4) then "Yes" else "No" endif) ; 
     OclFile["System.out"].println(if CheckIfstartsWithOne(24, 2) then "Yes" else "No" endif) ; 
     OclFile["System.out"].println(if CheckIfstartsWithOne(24, 7) then "Yes" else "No" endif) ; 
     OclFile["System.out"].println(if CheckIfstartsWithOne(24, 15) then "Yes" else "No" endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    try {
      ArrayList<String>list=new ArrayList<String>();
      BufferedReader ds=new BufferedReader(new InputStreamReader(System.in));
      while(true){
        String s=ds.readLine();
        if(s!=null && s!=""){
          StringTokenizer sz=new StringTokenizer(s);
          sz.nextToken();
          String perser=sz.nextToken();
          if(perser.equals("?")){
            break ;
          }
          list.add(s);
        }
        else {
          break ;
        }
      }
      for(int i=0 ; i<list.size(); i++){
        String s=list.get(i);
        StringTokenizer sz=new StringTokenizer(s);
        int a=Integer.valueOf(sz.nextToken());
        String per=sz.nextToken();
        int b=Integer.valueOf(sz.nextToken());
        printline(a,b,per);
      }
    }
    catch(Throwable e){
      e.printStackTrace();
      System.out.println("Input Error");
    }
  }
  private static void printline(int a,int b,String per){
    int res=0 ;
    if(per.equals("+"))res=a+b ;
    else if(per.equals("-"))res=a-b ;
    else if(per.equals("*"))res=a*b ;
    else if(per.equals("/"))res=a/b ;
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var list : Sequence(String) ; list := Sequence{} ;
     var ds : OclFile ; ds := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var s : String ; s := ds.readLine() ;
     if (s /= null & s /= "") then (     var sz : OclIterator ; sz := OclIterator.newOclIterator_String(s) ;
     sz.next() ; 
    var perser : String ; perser := sz.next() ;
    if (perser = "?") then (     break ) else skip ; 
    list := list->including(s) ; 
 ) else (     break ) ) ; 
         var i : int ; i := 0 ; while i < list->size() do ( (     var s : String ; s := list->at(i+1) ;
     var sz : OclIterator ; sz := OclIterator.newOclIterator_String(s) ;
    var a : int ; a := (sz.next())->toInteger() ;
    var per : String ; per := sz.next() ;
    var b : int ; b := (sz.next())->toInteger() ;
    execute printline(a, b, per) ; 
 )  ;     i := i + 1 ) )   catch (e : OclException) do (     e.printStackTrace() ; 
     OclFile["System.out"].println("Input Error") )
 );
  static   operation printline( a : int, b : int, per : String) : void
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     if (per = "+") then     res := a + b else     if (per = "-") then     res := a - (b)->char2byte() else     if (per = "*") then     res := a * b else     if (per = "/") then     res := a / b ; else skip ; ;  ;  ;  
     OclFile["System.out"].println(res) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    double a=scanner.nextInt();
    double b=scanner.nextInt();
    for(int x=1 ; x<a ; x++){
      for(int y=1 ; y<b ; y++){
        double d=(x/a)*(x/a)+(y/b)*(y/b);
        if(Math.abs(d-1)<0.00000001){
          int xxx=x,yyy=((int)(Math.sqrt(a*a-x*x)+0.5));
          int xx=y,yy=(int)(Math.sqrt(b*b-y*y)+0.5);
          System.out.println("YES");
          System.out.println("0 0");
          if(yy==yyy)System.out.println(xxx+" "+(-yyy));
          else System.out.println(-xxx+" "+yyy);
          System.out.println(xx+" "+yy);
          return ;
        }
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := scanner.getCurrent()->toInteger() ;
     var b : double ; b := scanner.getCurrent()->toInteger() ;
         var x : int ; x := 1 ; while x < a do ( (         var y : int ; y := 1 ; while y < b do ( (     var d : double ; d := (x / a) * (x / a) + (y / b) * (y / b) ;
     if (if d - 1 < 0 then -(d - 1) else d - 1 endif < 0.00000001) then (     var xxx : int ; xxx := x ;
    var yyy : int ; yyy := (((a * a - x * x)->sqrt() + 0.5)->oclAsType(int)) ;
     var xx : int ; xx := y ;
    var yy : int ; yy := ((b * b - y * y)->sqrt() + 0.5)->oclAsType(int) ;
    OclFile["System.out"].println("YES") ; 
    OclFile["System.out"].println("0 0") ; 
    if (yy = yyy) then     OclFile["System.out"].println(xxx + " " + (-yyy)) else     OclFile["System.out"].println(-xxx + " " + yyy) ; ;  
    OclFile["System.out"].println(xx + " " + yy) ; 
    return 
 ) else skip )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
     OclFile["System.out"].println("NO") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static Scanner sc ;
  public static void main(String[] args){
    sc=new Scanner(System.in);
    final int INF=1_000_000_000 ;
    int n=sc.nextInt();
    long c=sc.nextLong();
    long[] x=new long[n];
    long[] v=new long[n];
    for(int i=0 ; i<n ; i++){
      x[i]=sc.nextLong();
      v[i]=sc.nextLong();
    }
    long sum1=0 ;
    long sum2=0 ;
    long[] dp1=new long[n+1];
    long[] dp2=new long[n+1];
    for(int i=0 ; i<n ; i++){
      sum1+=v[i];
      dp1[i+1]=sum1-x[i];
      dp1[i+1]=Math.max(dp1[i],dp1[i+1]);
      sum2+=v[n-i-1];
      dp2[i+1]=sum2-(c-x[n-i-1]);
      dp2[i+1]=Math.max(dp2[i],dp2[i+1]);
    }
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      long a1=Math.max(dp1[i+1],dp1[i+1]-x[i]+dp2[n-i-1]);
      long a2=Math.max(dp2[i+1],dp2[i+1]-(c-x[n-i-1])+dp1[n-i-1]);
      long aa=Math.max(a1,a2);
      ans=Math.max(ans,aa);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var INF : int ; INF := 1_000_000_000 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : long ; c := sc.getCurrent()->toLong() ;
    var x : Sequence(long) ; x := Integer.subrange(1,n)->collect(0) ;
    var v : Sequence(long) ; v := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toLong() ; 
     v[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var sum1 : long ; sum1 := 0 ;
    var sum2 : long ; sum2 := 0 ;
    var dp1 : Sequence(long) ; dp1 := Integer.subrange(1,n + 1)->collect(0) ;
    var dp2 : Sequence(long) ; dp2 := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     sum1 := sum1+(v[i+1]) ; 
     dp1[i + 1+1] := sum1 - x[i+1] ; 
    dp1[i + 1+1] := Set{dp1[i+1], dp1[i + 1+1]}->max() ; 
    sum2 := sum2+(v[n - i - 1+1]) ; 
    dp2[i + 1+1] := sum2 - (c - x[n - i - 1+1]) ; 
    dp2[i + 1+1] := Set{dp2[i+1], dp2[i + 1+1]}->max() ; 
 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a1 : long ; a1 := Set{dp1[i + 1+1], dp1[i + 1+1] - x[i+1] + dp2[n - i - 1+1]}->max() ;
     var a2 : long ; a2 := Set{dp2[i + 1+1], dp2[i + 1+1] - (c - x[n - i - 1+1]) + dp1[n - i - 1+1]}->max() ;
     var aa : long ; aa := Set{a1, a2}->max() ;
     ans := Set{ans, aa}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static class Sushi {
    long x ;
    long v ;
    public Sushi(long x,long v){
      this.x=x ;
      this.v=v ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long C=sc.nextLong();
    Sushi[] s=new Sushi[N];
    for(int i=0 ; i<N ; i++)s[i]=new Sushi(sc.nextLong(),sc.nextLong());
    long ans=solve(s,C);
    Arrays.sort(s,new Comparator<Sushi>(){
      public int compare(Sushi s1,Sushi s2){
        return-Long.compare(s1.x,s2.x);
      }
    }
);
    for(int i=0 ; i<N ; i++)s[i] .x=C-s[i] .x ;
    ans=Math.max(ans,solve(s,C));
    System.out.println(ans);
    sc.close();
  }
  static long solve(Sushi[] s,long C){
    int N=s.length ;
    long[] cwmax=new long[N+1];
    long sum=0 ;
    for(int i=0 ; i<N ; i++){
      sum+=s[i] .v ;
      cwmax[i+1]=Math.max(cwmax[i],sum-s[i] .x);
    }
    long max=cwmax[N];
    sum=0 ;
    for(int i=N-1 ; i>=0 ; i--){
      sum+=s[i] .v ;
      max=Math.max(max,sum-(C-s[i] .x)*2+cwmax[i]);
    }
    return max ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Sushi {
   attribute x : long;
   attribute v : long;
   static operation newSushi( x : long, v : long) : Sushi
  pre: true
  post: true
  activity:
  ( var self : Sushi ;
    self := createSushi();
    self.initialise(x, v);
    return self );
  operation initialise( x : long, v : long) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.v := v );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var C : long ; C := sc.getCurrent()->toLong() ;
    var s : Sequence(Sushi) ; s := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do (     s[i+1] := Sushi.newSushi(sc.getCurrent()->toLong(), sc.getCurrent()->toLong()) ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := solve(s, C) ;
    s := OclComparator.sortWith(s, OclComparator<Sushi>.newOclComparator()) ; 
        var i : int ; i := 0 ; while i < N do (     s[i+1].x := C - s[i+1].x ;  ;     i := i + 1 ) ; 
    ans := Set{ans, solve(s, C)}->max() ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
  static   operation solve( s : Sequence(Sushi), C : long) : long
  pre: true
  post: true
  activity: (     var N : int ; N := s->size() ;
     var cwmax : Sequence(long) ; cwmax := Integer.subrange(1,N + 1)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     sum := sum+(s[i+1].v) ; 
     cwmax[i + 1+1] := Set{cwmax[i+1], sum - s[i+1].x}->max() )  ;     i := i + 1 ) ; 
    var max : long ; max := cwmax[N+1] ;
    sum := 0 ; 
        var i : int ; i := N - 1 ; while i >= 0 do ( (     sum := sum+(s[i+1].v) ; 
     max := Set{max, sum - (C - s[i+1].x) * 2 + cwmax[i+1]}->max() )  ;     i := i - 1 ) ; 
    return max 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  static Scanner sc=new Scanner(System.in);
  static long[] x=new long[100005];
  static long[] v=new long[100005];
  static long[] s=new long[100005];
  static long n,c ;
  static long ans=0 ;
  static long sum ;
  public static void main(String[] args){
    Arrays.fill(x,0);
    Arrays.fill(v,0);
    Arrays.fill(s,0);
    n=sc.nextLong();
    c=sc.nextLong();
    for(int i=1 ; i<=n ; i++){
      x[i]=sc.nextLong();
      v[i]=sc.nextLong();
    }
    x[(int)n+1]=c ;
    Arrays.fill(s,Long.MIN_VALUE);
    sum=0 ;
    s[0]=0 ;
    for(int i=1 ; i<=n ; i++){
      sum+=v[i];
      s[i]=Math.max(sum-x[i]*2,s[i-1]);
    }
    sum=0 ;
    for(int i=(int)n+1 ; i>0 ; i--){
      sum+=v[i];
      ans=Math.max(ans,s[i-1]+sum-(c-x[i]));
    }
    Arrays.fill(s,Long.MIN_VALUE);
    sum=0 ;
    s[0]=0 ;
    for(int i=1 ; i<=n ; i++){
      sum+=v[i];
      s[i]=Math.max(sum-x[i],s[i-1]);
    }
    sum=0 ;
    for(int i=(int)n+1 ; i>0 ; i--){
      sum+=v[i];
      ans=Math.max(ans,s[i-1]+sum-(2*c-2*x[i]));
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute x : Sequence(long) := Integer.subrange(1,100005)->collect(0);
  static   attribute v : Sequence(long) := Integer.subrange(1,100005)->collect(0);
  static   attribute s : Sequence(long) := Integer.subrange(1,100005)->collect(0);
  static   attribute n : long;
  static   attribute ans : long := 0;
  static   attribute sum : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     x := x->collect(0) ; 
     v := v->collect(0) ; 
    s := s->collect(0) ; 
    n := sc.getCurrent()->toLong() ; 
    c := sc.getCurrent()->toLong() ; 
        var i : int ; i := 1 ; while i <= n do ( (     x[i+1] := sc.getCurrent()->toLong() ; 
     v[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    x[n->oclAsType(int) + 1+1] := c ; 
    s := s->collect("-9223372036854775808"->toLong()) ; 
    sum := 0 ; 
    s[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (     sum := sum+(v[i+1]) ; 
     s[i+1] := Set{sum - x[i+1] * 2, s[i - 1+1]}->max() )  ;     i := i + 1 ) ; 
    sum := 0 ; 
        var i : int ; i := n->oclAsType(int) + 1 ; while i > 0 do ( (     sum := sum+(v[i+1]) ; 
     ans := Set{ans, s[i - 1+1] + sum - (c - x[i+1])}->max() )  ;     i := i - 1 ) ; 
    s := s->collect("-9223372036854775808"->toLong()) ; 
    sum := 0 ; 
    s[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (     sum := sum+(v[i+1]) ; 
     s[i+1] := Set{sum - x[i+1], s[i - 1+1]}->max() )  ;     i := i + 1 ) ; 
    sum := 0 ; 
        var i : int ; i := n->oclAsType(int) + 1 ; while i > 0 do ( (     sum := sum+(v[i+1]) ; 
     ans := Set{ans, s[i - 1+1] + sum - (2 * c - 2 * x[i+1])}->max() )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long C=sc.nextLong();
    long[] x=new long[N];
    long[] v=new long[N];
    long ans=0 ;
    for(int i=0 ; i<N ; i++){
      x[i]=sc.nextLong();
      v[i]=sc.nextLong();
    }
    long sum1=0 ;
    long sum2=0 ;
    long[] a=new long[N+1];
    long[] b=new long[N+1];
    for(int i=0 ; i<N ; i++){
      sum1+=v[i];
      a[i+1]=sum1-x[i];
      a[i+1]=Math.max(a[i],a[i+1]);
      sum2+=v[N-i-1];
      b[i+1]=sum2-(C-x[N-i-1]);
      b[i+1]=Math.max(b[i],b[i+1]);
    }
    for(int i=0 ; i<N ; i++){
      long t1=Math.max(a[i+1],a[i+1]-x[i]+b[N-i-1]);
      long t2=Math.max(b[i+1],b[i+1]-(C-x[N-i-1])+a[N-i-1]);
      long t3=Math.max(t1,t2);
      ans=Math.max(ans,t3);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var C : long ; C := sc.getCurrent()->toLong() ;
    var x : Sequence(long) ; x := Integer.subrange(1,N)->collect(0) ;
    var v : Sequence(long) ; v := Integer.subrange(1,N)->collect(0) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     x[i+1] := sc.getCurrent()->toLong() ; 
     v[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var sum1 : long ; sum1 := 0 ;
    var sum2 : long ; sum2 := 0 ;
    var a : Sequence(long) ; a := Integer.subrange(1,N + 1)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     sum1 := sum1+(v[i+1]) ; 
     a[i + 1+1] := sum1 - x[i+1] ; 
    a[i + 1+1] := Set{a[i+1], a[i + 1+1]}->max() ; 
    sum2 := sum2+(v[N - i - 1+1]) ; 
    b[i + 1+1] := sum2 - (C - x[N - i - 1+1]) ; 
    b[i + 1+1] := Set{b[i+1], b[i + 1+1]}->max() ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var t1 : long ; t1 := Set{a[i + 1+1], a[i + 1+1] - x[i+1] + b[N - i - 1+1]}->max() ;
     var t2 : long ; t2 := Set{b[i + 1+1], b[i + 1+1] - (C - x[N - i - 1+1]) + a[N - i - 1+1]}->max() ;
     var t3 : long ; t3 := Set{t1, t2}->max() ;
     ans := Set{ans, t3}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean IsLarger(int[] X,int[] Y,int n){
    for(int i=0 ; i<n ; i++){
      if(X[i]<Y[i]){
        return false ;
      }
    }
    return true ;
  }
  static int solve(int X[],int Y[],int n){
    int ans=0 ;
    if(IsLarger(X,Y,n))ans=0 ;
    else {
      int d=Y[0]-X[0];
      for(int i=0 ; i<n ; i++)X[i]+=d ;
      if(IsLarger(X,Y,n))ans=d ;
      else {
        ans=d+1 ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int X[]={
      2,3,6,9 };
      int Y[]={
        3,4,8,1 };
        int n=X.length ;
        System.out.println(solve(X,Y,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation IsLarger( X : Sequence(int), Y : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (X[i+1] < Y[i+1]) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation solve( X : Sequence(int), Y : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     if (IsLarger(X, Y, n)) then     ans := 0 else (     var d : int ; d := Y[0+1] - X[0+1] ;
         var i : int ; i := 0 ; while i < n do (     X[i+1] := X[i+1]+(d) ;  ;     i := i + 1 ) ; 
     if (IsLarger(X, Y, n)) then     ans := d ; else (     ans := d + 1 ) ) ;  
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : Sequence(int) ; X := Sequence{2,3,6,9} ;
     var Y : Sequence(int) ; Y := Sequence{3,4,8,1} ;
     var n : int ; n := X->size() ;
     OclFile["System.out"].println(solve(X, Y, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static double average(int arr[],int n,int k){
    double total=0 ;
    if(2*k>=n)return 0 ;
    Arrays.sort(arr);
    int start=k,end=n-k-1 ;
    for(int i=start ; i<=end ; i++)total+=arr[i];
    return(total/(n-2*k));
  }
  public static void main(String[] args){
    int arr[]={
      1,2,4,4,5,6 };
      int n=arr.length ;
      int k=2 ;
      System.out.println(average(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation average( arr : Sequence(int), n : int, k : int) : double
  pre: true
  post: true
  activity: (     var total : double ; total := 0 ;
     if (2 * k >= n) then     return 0 else skip ; 
    arr := arr->sort() ; 
    var start : int ; start := k ;
    var end : int ; end := n - k - 1 ;
        var i : int ; i := start ; while i <= end do (     total := total+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    return (total / (n - 2 * k)) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,4,4,5,6} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(average(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static void commDiv(int a,int b){
    int n=gcd(a,b);
    a=a/n ;
    b=b/n ;
    System.out.println("A="+a+",B="+b);
  }
  public static void main(String[] args){
    int a=10,b=15 ;
    commDiv(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation commDiv( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var n : int ; n := gcd(a, b) ;
     a := a / n ; 
     b := b / n ; 
     OclFile["System.out"].println("A=" + a + ",B=" + b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 10 ;
    var b : int ; b := 15 ;
     execute commDiv(a, b) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printValueOfPi(int N){
    double pi=2*Math.acos(0.0);
    System.out.println(pi);
  }
  public static void main(String[] args){
    int N=4 ;
    printValueOfPi(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printValueOfPi( N : int) : void
  pre: true
  post: true
  activity: (     var pi : double ; pi := 2 * (0.0)->acos() ;
     OclFile["System.out"].println(pi) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     execute printValueOfPi(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication439 {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int x=input.nextInt();
    boolean chesck=true ;
    int y=7-x ;
    for(int i=0 ; i<n ; i++){
      int q=input.nextInt();
      int w=input.nextInt();
      if(q==x || q==y || w==x || w==y){
        chesck=false ;
        break ;
      }
    }
    if(chesck)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication439 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var x : int ; x := input.getCurrent()->toInteger() ;
    var chesck : boolean ; chesck := true ;
    var y : int ; y := 7 - x ;
        var i : int ; i := 0 ; while i < n do ( (     var q : int ; q := input.getCurrent()->toInteger() ;
     var w : int ; w := input.getCurrent()->toInteger() ;
     if (q = x or q = y or w = x or w = y) then (     chesck := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (chesck) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import javax.lang.model.util.ElementScanner6 ;
public class ques1 {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int m=scn.nextInt();
    double max1=-0.0 ;
    double max2=-0.0 ;
    HashMap<Integer,Integer>map=new HashMap<>();
    int idx1=n ;
    int idx2=-1 ;
    for(int i=0 ; i<n ; i++){
      int a=scn.nextInt();
      if(Math.ceil((double)a/m)>=max1){
        max1=Math.ceil((double)a/m);
        idx1=i+1 ;
      }
    }
    System.out.println(idx1);
  }
  public static boolean isPrime(int n){
    boolean ans=true ;
    for(int i=2 ; i*i<=n ; i++){
      if(n % i==0){
        ans=false ;
        break ;
      }
    }
    if(ans==true)return true ;
    else return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ques1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var m : int ; m := scn.getCurrent()->toInteger() ;
    var max1 : double ; max1 := -0.0 ;
    var max2 : double ; max2 := -0.0 ;
    var map : Map(int,int) ; map := Map{} ;
    var idx1 : int ; idx1 := n ;
    var idx2 : int ; idx2 := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scn.getCurrent()->toInteger() ;
     if ((a->oclAsType(double) / m)->ceil() >= max1) then (     max1 := (a->oclAsType(double) / m)->ceil() ; 
     idx1 := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(idx1) ; 
 );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     var ans : boolean ; ans := true ;
         var i : int ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     ans := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (ans = true) then     return true else     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.HashSet ;
import java.util.Set ;
import java.util.StringTokenizer ;
public class Main {
  public static PrintWriter out ;
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    out=new PrintWriter(new BufferedOutputStream(System.out));
    int n=sc.nextInt();
    int m=sc.nextInt();
    int k=sc.nextInt();
    Set<Integer>holes=new HashSet<>();
    for(int i=0 ; i<m ; i++){
      holes.add(sc.nextInt());
    }
    int cup=1 ;
    if(! holes.contains(cup)){
      for(int i=0 ; i<k ; i++){
        cup=swap(sc.nextInt(),sc.nextInt(),cup);
        if(holes.contains(cup)){
          break ;
        }
      }
    }
    out.println(cup);
    out.close();
  }
  private static int swap(int pos1,int pos2,int cup){
    if(cup==pos1)return pos2 ;
    else if(cup==pos2)return pos1 ;
    else return cup ;
  }
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var n : int ; n := sc.nextInt() ;
    var m : int ; m := sc.nextInt() ;
    var k : int ; k := sc.nextInt() ;
    var holes : Set(int) ; holes := Set{} ;
        var i : int ; i := 0 ; while i < m do ( (     holes := holes->including(sc.nextInt()) )  ;     i := i + 1 ) ; 
    var cup : int ; cup := 1 ;
    if (not(holes->includes(cup))) then (         var i : int ; i := 0 ; while i < k do ( (     cup := swap(sc.nextInt(), sc.nextInt(), cup) ; 
     if (holes->includes(cup)) then (     break ) else skip )  ;     i := i + 1 ) ) else skip ; 
    skip ; 
    skip ; 
 );
  static   operation swap( pos1 : int, pos2 : int, cup : int) : int
  pre: true
  post: true
  activity: (     if (cup = pos1) then     return pos2 else     if (cup = pos2) then     return pos1 else     return cup ;  );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class geeks {
  public static int minimumOperations(int[] a,int n){
    HashMap<Integer,Integer>mp=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(mp.get(a[i])!=null){
        int x=mp.get(a[i]);
        mp.put(a[i],++x);
      }
      else mp.put(a[i],1);
    }
    int count=0 ;
    for(HashMap.Entry<Integer,Integer>entry : mp.entrySet()){
      if(entry.getValue()>1){
        count+=(entry.getValue()-1);
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int[] a={
      2,1,2,3,3,4,3 };
      int n=a.length ;
      System.out.println(minimumOperations(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class geeks {
  static   operation minimumOperations( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (mp->at(a[i+1]) /= null) then (     var x : int ; x := mp->at(a[i+1]) ;
     mp := mp->union(Map{a[i+1] |-> (x + 1)}) ) else     mp := mp->union(Map{a[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    for (entry : mp->asSet()) do ( (     if (entry.getValue() > 1) then (     count := count+((entry.getValue() - 1)) ) else skip )  ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,1,2,3,3,4,3} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(minimumOperations(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static boolean isA(char[] s){
    if(s.length<6)return false ;
    if(!(s[0]=='>' && s[1]=='\''))return false ;
    int con=0 ;
    while(2+con<s.length && s[2+con]=='=')con++;
    if(con==0)return false ;
    if(2+con==s.length || s[2+con]!='#')return false ;
    int b=3+con ;
    int sec=0 ;
    while(b+sec<s.length && s[b+sec]=='=')sec++;
    if(sec!=con || b+sec==s.length)return false ;
    return s[b+sec]=='~' && b+sec==s.length-1 ;
  }
  static boolean isB(char[] s){
    if(s.length<6)return false ;
    if(!(s[0]=='>' && s[1]=='^'))return false ;
    int i=2 ;
    int c=0 ;
    while(i+1<s.length && s[i]=='Q' && s[i+1]=='='){
      i+=2 ;
      c++;
    }
    if(i+1>=s.length || c==0)return false ;
    return i+1==s.length-1 && s[i]=='~' && s[i+1]=='~' ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      char[] s=sc.next().toCharArray();
      System.out.println(isA(s)? "A" : isB(s)? "B" : "NA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation isA( s : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     if (s->size() < 6) then     return false else skip ; 
     if (not((s[0+1] = '>' & s[1+1] = '\''))) then     return false else skip ; 
    var con : int ; con := 0 ;
    while (2 + con < s->size() & s[2 + con+1] = '=') do     con := con + 1 ; ; 
    if (con = 0) then     return false else skip ; 
    if (2 + con = s->size() or s[2 + con+1] /= '#') then     return false else skip ; 
    var b : int ; b := 3 + con ;
    var sec : int ; sec := 0 ;
    while (b + sec < s->size() & s[b + sec+1] = '=') do     sec := sec + 1 ; ; 
    if (sec /= con or b + sec = s->size()) then     return false else skip ; 
    return s[b + sec+1] = '~' & b + sec = s->size() - 1 
 );
  static   operation isB( s : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     if (s->size() < 6) then     return false else skip ; 
     if (not((s[0+1] = '>' & s[1+1] = '^'))) then     return false else skip ; 
    var i : int ; i := 2 ;
    var c : int ; c := 0 ;
    while (i + 1 < s->size() & s[i+1] = 'Q' & s[i + 1+1] = '=') do (     i := i+(2) ; 
     c := c + 1 ) ; 
    if (i + 1 >= s->size() or c = 0) then     return false else skip ; 
    return i + 1 = s->size() - 1 & s[i+1] = '~' & s[i + 1+1] = '~' 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
     OclFile["System.out"].println(if isA(s) then "A" else if isB(s) then "B" else "NA" endif endif) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    String s=reader.readLine();
    String type="NA" ;
    String regA=">'(=+)#(=+)\\~" ;
    if(s.matches(regA)){
      if(s.replaceAll(regA,"$1").equals(s.replaceAll(regA,"$2")))type="A" ;
    }
    else if(s.matches(">\\^(Q=)+\\~\\~")){
      type="B" ;
    }
    System.out.printf("%s\n",type);
    return true ;
  }
  private final static boolean DEBUG=false ;
  public static void main(String[] args)throws IOException {
    if(DEBUG){
      log=System.out ;
      String inputStr="1:>'======#======~:" ;
      inputStr=inputStr.replace(":","\n");
      reader=new BufferedReader(new StringReader(inputStr));
    }
    else {
      log=new PrintStream(new OutputStream(){
        public void write(int b){
        }
      }
);
      reader=new BufferedReader(new InputStreamReader(System.in));
    }
    int N=readIntArray()[0];
    for(int i=0 ; i<N ; i++){
      boolean b=new Main().main();
      if(! b)break ;
    }
    reader.close();
  }
  static PrintStream log ;
  static BufferedReader reader ;
  private static int[] readIntArray()throws IOException {
    String s=null ;
    for(; ; ){
      s=reader.readLine();
      if(s==null)return null ;
      s=s.trim();
      if(s.length()!=0)break ;
    }
    String[] sp=s.split("[,] ");
    int[] a=new int[sp.length];
    for(int i=0 ; i<sp.length ; i++){
      a[i]=Integer.parseInt(sp[i]);
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var s : String ; s := reader.readLine() ;
     var type : String ; type := "NA" ;
    var regA : String ; regA := ">'(=+)#(=+)\\~" ;
    if (s->isMatch(regA)) then (     if (s.replaceAllMatches(regA, "$1" ) = s.replaceAllMatches(regA, "$2" )) then     type := "A" ; else skip ) else     if (s->isMatch(">\\^(Q=)+\\~\\~")) then (     type := "B" ) else skip ; ;  
    OclFile["System.out"].printf("%s\n", type) ; 
    return true 
 );
  static   attribute DEBUG : boolean := false;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (DEBUG) then (     log := OclFile["System.out"] ; 
     var inputStr : String ; inputStr := "1:>'======#======~:" ;
     inputStr := inputStr.replace(":", "\n") ; 
     reader := OclFile.newOclFile_Read(StringReader.newStringReader(inputStr)) ) else (     log := OclFile.newOclFile_Write(OclFile()) ; 
     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ) ;  
     var N : int ; N := readIntArray()[0+1] ;
         var i : int ; i := 0 ; while i < N do ( (     var b : boolean ; b := Main.newMain().main() ;
     if (not(b)) then     break else skip )  ;     i := i + 1 ) ; 
     reader.close() );
  static   attribute log : OclFile;
  static   attribute reader : OclFile;
  static   operation readIntArray() : Sequence(int)
  pre: true
  post: true
  activity: (     var s : String ; s := null ;
       while true do ( (     s := reader.readLine() ; 
     if (s = null) then     return null else skip ; 
     s := s->trim() ; 
     if (s->size() /= 0) then     break else skip )  ) ; 
    var sp : Sequence(String) ; sp := s->split("[,] ") ;
    var a : Sequence(int) ; a := Integer.subrange(1,sp->size())->collect(0) ;
        var i : int ; i := 0 ; while i < sp->size() do ( (     a[i+1] := (sp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    return a 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.regex.Matcher ;
import java.util.regex.Pattern ;
public class Main {
  public static final int BIG_NUM=2000000000 ;
  public static final int MOD=1000000007 ;
  public static final long HUGE_NUM=99999999999999999L ;
  public static final double EPS=0.000000001 ;
  @ SuppressWarnings("unchecked")public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    StringBuilder ans=new StringBuilder();
    for(int loop=0 ; loop<N ; loop++){
      String input_str=scanner.next();
      if(input_str.matches("\\A>'(=+)#\\1~\\z")){
        ans.append("A\n");
      }
      else if(input_str.matches("\\A>\\^(Q=)+~~\\z")){
        ans.append("B\n");
      }
      else {
        ans.append("NA\n");
      }
    }
    System.out.printf(ans.toString());
  }
}
class UTIL {
  public static long gcd(long x,long y){
    x=Math.abs(x);
    y=Math.abs(y);
    if(x<y){
      long tmp=y ;
      y=x ;
      x=tmp ;
    }
    if(y==0){
      return x ;
    }
    else {
      return gcd(y,x % y);
    }
  }
  public static long lcm(long x,long y){
    return(x*y)/gcd(x,y);
  }
  public static int getNUM(String tmp_str){
    return Integer.parseInt(tmp_str);
  }
  public static boolean isNumber(String tmp_str){
    if(tmp_str==null || tmp_str.length()==0){
      return false ;
    }
    Pattern pattern=Pattern.compile("\\A[0-9]+\\z");
    Matcher matcher=pattern.matcher(tmp_str);
    return matcher.matches();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BIG_NUM : int := 2000000000;
  static    attribute MOD : int := 1000000007;
  static    attribute HUGE_NUM : long := 99999999999999999L;
  static    attribute EPS : double := 0.000000001;
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var ans : String ; ans := StringLib.newString() ;
        var loop : int ; loop := 0 ; while loop < N do ( (     var input_str : String ; input_str := scanner.getCurrent() ;
     if (input_str->isMatch("\\A>'(=+)#\\1~\\z")) then (     ans := ans + StringLib.newString("A\n") ) else     if (input_str->isMatch("\\A>\\^(Q=)+~~\\z")) then (     ans := ans + StringLib.newString("B\n") ) else (     ans := ans + StringLib.newString("NA\n") ) ;  )  ;     loop := loop + 1 ) ; 
    OclFile["System.out"].printf(ans+"") ; 
 );
}
class UTIL {
  static   operation gcd( x : long, y : long) : long
  pre: true
  post: true
  activity: (     x := if x < 0 then -(x) else x endif ; 
     y := if y < 0 then -(y) else y endif ; 
     if (x < y) then (     var tmp : long ; tmp := y ;
     y := x ; 
     x := tmp ) else skip ; 
     if (y = 0) then (     return x ) else (     return gcd(y, x mod y) ) );
  static   operation lcm( x : long, y : long) : long
  pre: true
  post: true
  activity: (     return (x * y) / gcd(x, y) );
  static   operation getNUM( tmp_str : String) : int
  pre: true
  post: true
  activity: (     return (tmp_str)->toInteger() );
  static   operation isNumber( tmp_str : String) : boolean
  pre: true
  post: true
  activity: (     if (tmp_str = null or tmp_str->size() = 0) then (     return false ) else skip ; 
     var pattern : OclRegex ; pattern := OclRegex.compile("\\A[0-9]+\\z") ;
     var matcher : OclRegex ; matcher := pattern.matcher(tmp_str) ;
     return matcher.isMatch() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.lang.Integer ;
import java.lang.System ;
import java.lang.Exception ;
import java.util.regex.Matcher ;
import java.util.regex.Pattern ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
    Pattern a=Pattern.compile(">'(=+)#\\1~");
    Pattern b=Pattern.compile(">\\^(Q=)+~~");
    int n=Integer.parseInt(r.readLine());
    for(int i=0 ; i<n ; i++){
      String s=r.readLine();
      Matcher ma=a.matcher(s);
      Matcher mb=b.matcher(s);
      if(ma.matches()){
        System.out.println("A");
      }
      else if(mb.matches()){
        System.out.println("B");
      }
      else {
        System.out.println("NA");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var a : OclRegex ; a := OclRegex.compile(">'(=+)#\\1~") ;
    var b : OclRegex ; b := OclRegex.compile(">\\^(Q=)+~~") ;
    var n : int ; n := (r.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := r.readLine() ;
     var ma : OclRegex ; ma := a.matcher(s) ;
     var mb : OclRegex ; mb := b.matcher(s) ;
     if (ma.isMatch()) then (     OclFile["System.out"].println("A") ) else     if (mb.isMatch()) then (     OclFile["System.out"].println("B") ) else (     OclFile["System.out"].println("NA") ) ;  )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void specialNumber(int n){
    if(n<10 || n>99)System.out.println("Invalid Input! "+"Number should have "+"2 digits only");
    else {
      int first=n/10 ;
      int last=n % 10 ;
      int sum=first+last ;
      int pro=first*last ;
      if((sum+pro)==n){
        System.out.println(n+" is a Special"+" Two-Digit Number");
      }
      else {
        System.out.println(n+" is Not a Special"+" Two-Digit Number");
      }
    }
  }
  public static void main(String args[]){
    int n=59 ;
    specialNumber(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation specialNumber( n : int) : void
  pre: true
  post: true
  activity: (     if (n < 10 or n > 99) then     OclFile["System.out"].println("Invalid Input! " + "Number should have " + "2 digits only") ; else (     var first : int ; first := n / 10 ;
     var last : int ; last := n mod 10 ;
    var sum : int ; sum := first + last ;
    var pro : int ; pro := first * last ;
    if ((sum + pro) = n) then (     OclFile["System.out"].println(n + " is a Special" + " Two-Digit Number") ) else (     OclFile["System.out"].println(n + " is Not a Special" + " Two-Digit Number") ) ;  
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 59 ;
     execute specialNumber(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxProdSum(int arr[],int n){
    int leftArraySum=0,maxProduct=0 ;
    for(int i=0 ; i<n ; i++){
      leftArraySum+=arr[i];
      int rightArraySum=0 ;
      for(int j=i+1 ; j<n ; j++){
        rightArraySum+=arr[j];
      }
      int k=leftArraySum*rightArraySum ;
      if(k>maxProduct){
        maxProduct=k ;
      }
    }
    return maxProduct ;
  }
  public static void main(String[] args){
    int arr[]={
      4,10,1,7,2,9 };
      int n=arr.length ;
      System.out.print(maxProdSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxProdSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var leftArraySum : int ; leftArraySum := 0 ;
    var maxProduct : int ; maxProduct := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     leftArraySum := leftArraySum+(arr[i+1]) ; 
     var rightArraySum : int ; rightArraySum := 0 ;
        var j : int ; j := i + 1 ; while j < n do ( (     rightArraySum := rightArraySum+(arr[j+1]) )  ;     j := j + 1 ) ; 
    var k : int ; k := leftArraySum * rightArraySum ;
    if (k > maxProduct) then (     maxProduct := k ) else skip ; 
 )  ;     i := i + 1 ) ; 
     return maxProduct );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,10,1,7,2,9} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(maxProdSum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long oddNumSum(int n){
    return(n*(2*n+1)*(24*n*n*n-12*n*n-14*n+7))/15 ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(oddNumSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation oddNumSum( n : int) : long
  pre: true
  post: true
  activity: (     return (n * (2 * n + 1) * (24 * n * n * n - 12 * n * n - 14 * n + 7)) / 15 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(oddNumSum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int odd_digits(int n){
    if(n<10)return n ;
    else if(n/10<10)return 9 ;
    else if(n/100<10)return 9+n-99 ;
    else if(n/1000<10)return 9+900 ;
    else if(n/10000<10)return 909+n-9999 ;
    else return 90909 ;
  }
  public static void main(String[] args){
    int n=893 ;
    System.out.println(odd_digits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation odd_digits( n : int) : int
  pre: true
  post: true
  activity: (     if (n < 10) then     return n else     if (n / 10 < 10) then     return 9 else     if (n / 100 < 10) then     return 9 + n - 99 else     if (n / 1000 < 10) then     return 9 + 900 else     if (n / 10000 < 10) then     return 909 + n - 9999 else     return 90909 ;  ;  ;  ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 893 ;
     OclFile["System.out"].println(odd_digits(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findPairs(int arr[],int n){
    int cntEven=0,cntOdd=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] % 2==0)cntEven++;
      else cntOdd++;
    }
    int evenPairs=0 ;
    evenPairs+=((cntEven*(cntEven-1))/2);
    evenPairs+=((cntOdd*(cntOdd-1))/2);
    int oddPairs=0 ;
    oddPairs+=(cntEven*cntOdd);
    System.out.println("Odd pairs="+oddPairs);
    System.out.println("Even pairs="+evenPairs);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5 };
      int n=arr.length ;
      findPairs(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findPairs( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var cntEven : int ; cntEven := 0 ;
    var cntOdd : int ; cntOdd := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 = 0) then     cntEven := cntEven + 1 ; else     cntOdd := cntOdd + 1 ; )  ;     i := i + 1 ) ; 
    var evenPairs : int ; evenPairs := 0 ;
    evenPairs := evenPairs+(((cntEven * (cntEven - 1)) / 2)) ; 
    evenPairs := evenPairs+(((cntOdd * (cntOdd - 1)) / 2)) ; 
    var oddPairs : int ; oddPairs := 0 ;
    oddPairs := oddPairs+((cntEven * cntOdd)) ; 
    OclFile["System.out"].println("Odd pairs=" + oddPairs) ; 
    OclFile["System.out"].println("Even pairs=" + evenPairs) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var n : int ; n := arr->size() ;
     execute findPairs(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
class GFG {
  static boolean is_vow(char c){
    return(c=='a')||(c=='e')||(c=='i')||(c=='o')||(c=='u');
  }
  static void removeVowels(String str){
    System.out.print(str.charAt(0));
    for(int i=1 ; i<str.length(); i++)if((! is_vow(str.charAt(i-1)))||(! is_vow(str.charAt(i))))System.out.print(str.charAt(i));
  }
  public static void main(String[] args){
    String str="geeks for geeks" ;
    removeVowels(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation is_vow( c : String) : boolean
  pre: true
  post: true
  activity: (     return (c = 'a') or (c = 'e') or (c = 'i') or (c = 'o') or (c = 'u') );
  static   operation removeVowels( str : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(str->at(0+1)) ; 
         var i : int ; i := 1 ; while i < str->size() do (     if ((not(is_vow(str->at(i - 1+1)))) or (not(is_vow(str->at(i+1))))) then     OclFile["System.out"].print(str->at(i+1)) ; else skip ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeks for geeks" ;
     execute removeVowels(str) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] a)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine()," ");
    int nums[]=new int[3];
    for(int i=0 ; i<nums.length ; i++)nums[i]=Integer.parseInt(st.nextToken());
    Arrays.sort(nums);
    System.out.println(nums[0]+" "+nums[1]+" "+nums[2]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String_String(br.readLine(), " ") ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < nums->size() do (     nums[i+1] := (st.next())->toInteger() ;  ;     i := i + 1 ) ; 
    nums := nums->sort() ; 
    OclFile["System.out"].println(nums[0+1] + " " + nums[1+1] + " " + nums[2+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int atMostSum(int arr[],int n,int k){
    int sum=0 ;
    int cnt=0,maxcnt=0 ;
    for(int i=0 ; i<n ; i++){
      if((sum+arr[i])<=k){
        sum+=arr[i];
        cnt++;
      }
      else if(sum!=0){
        sum=sum-arr[i-cnt]+arr[i];
      }
      maxcnt=Math.max(cnt,maxcnt);
    }
    return maxcnt ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,1,0,1,1,0 };
      int n=arr.length ;
      int k=4 ;
      System.out.print(atMostSum(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation atMostSum( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var cnt : int ; cnt := 0 ;
    var maxcnt : int ; maxcnt := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if ((sum + arr[i+1]) <= k) then (     sum := sum+(arr[i+1]) ; 
     cnt := cnt + 1 ) else     if (sum /= 0) then (     sum := sum - arr[i - cnt+1] + arr[i+1] ) else skip ; ;  
     maxcnt := Set{cnt, maxcnt}->max() )  ;     i := i + 1 ) ; 
     return maxcnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,1,0,1,1,0} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 4 ;
     OclFile["System.out"].print(atMostSum(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPower(int n){
    for(int x=2 ; x<=(int)Math.sqrt(n); x++){
      float f=(float)Math.log(n)/(float)Math.log(x);
      if((f-(int)f)==0.0)return true ;
    }
    return false ;
  }
  public static void main(String args[]){
    for(int i=2 ; i<100 ; i++)if(isPower(i))System.out.print(i+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPower( n : int) : boolean
  pre: true
  post: true
  activity: (         var x : int ; x := 2 ; while x <= (n)->sqrt()->oclAsType(int) do ( (     var f : double ; f := (n)->log()->oclAsType(double) / (x)->log()->oclAsType(double) ;
     if ((f - f->oclAsType(int)) = 0.0) then     return true else skip )  ;     x := x + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i < 100 do (     if (isPower(i)) then     OclFile["System.out"].print(i + " ") ; else skip ;  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int countDistinct(int arr[],int n){
    HashSet<Integer>hs=new HashSet<Integer>();
    for(int i=0 ; i<n ; i++){
      hs.add(arr[i]);
    }
    return hs.size();
  }
  public static void main(String[] args){
    int arr[]=new int[] {
      6,10,5,4,9,120,4,6,10 };
      System.out.println(countDistinct(arr,arr.length));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDistinct( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var hs : Set(int) ; hs := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     hs := hs->including(arr[i+1]) )  ;     i := i + 1 ) ; 
     return hs->size() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,10,5,4,9,120,4,6,10} ;
     OclFile["System.out"].println(countDistinct(arr, arr->size())) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B_Array_Sharpening {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; ++i){
        a[i]=sc.nextInt();
      }
      System.out.println(solve(a)? "Yes" : "No");
    }
    sc.close();
  }
  static boolean solve(int[] a){
    int index=0 ;
    while(index<a.length && a[index]>=index){
++index ;
    }
    if(index==a.length){
      return true ;
    }
    if(a.length-index-1>=a[index-1]){
      return false ;
    }
    while(index<a.length && a[index]>=a.length-index-1){
++index ;
    }
    return index==a.length ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Array_Sharpening {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if solve(a) then "Yes" else "No" endif) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var index : int ; index := 0 ;
     while (index < a->size() & a[index+1] >= index) do (     index := index + 1 ) ; 
    if (index = a->size()) then (     return true ) else skip ; 
    if (a->size() - index - 1 >= a[index - 1+1]) then (     return false ) else skip ; 
    while (index < a->size() & a[index+1] >= a->size() - index - 1) do (     index := index + 1 ) ; 
    return index = a->size() 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    Scanner scanner=new Scanner(System.in);
    while(true){
      int q1=scanner.nextInt();
      if(q1==0)break ;
      int b=scanner.nextInt();
      int c1=scanner.nextInt();
      int c2=scanner.nextInt();
      int q2=scanner.nextInt();
      int count=-1 ;
      for(int i=q2 ; i>=1 ; i--){
        int aa=i*c1 ;
        int bb=Math.max((q1-i),0)*c2 ;
        if(aa+bb<=b){
          count=i ;
          break ;
        }
      }
      if(count==-1){
        System.out.println("NA");
      }
      else {
        int ans=(b-count*c1)/c2 ;
        System.out.println(count+" "+ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var q1 : int ; q1 := scanner.getCurrent()->toInteger() ;
     if (q1 = 0) then     break else skip ; 
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var c1 : int ; c1 := scanner.getCurrent()->toInteger() ;
    var c2 : int ; c2 := scanner.getCurrent()->toInteger() ;
    var q2 : int ; q2 := scanner.getCurrent()->toInteger() ;
    var count : int ; count := -1 ;
        var i : int ; i := q2 ; while i >= 1 do ( (     var aa : int ; aa := i * c1 ;
     var bb : int ; bb := Set{(q1 - i), 0}->max() * c2 ;
     if (aa + bb <= b) then (     count := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    if (count = -1) then (     OclFile["System.out"].println("NA") ) else (     var ans : int ; ans := (b - count * c1) / c2 ;
     OclFile["System.out"].println(count + " " + ans) ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      int q1=sc.nextInt();
      if(q1==0)break ;
      int b=sc.nextInt();
      int c1=sc.nextInt();
      int c2=sc.nextInt();
      int q2=sc.nextInt();
      int BUY1U=Math.min(b/c1,q2);
      int ansBuy1=-1 ;
      for(int buy1=1 ; buy1<=BUY1U ; buy1++){
        int buy2=(b-c1*buy1)/c2 ;
        if(buy1>0 && buy1+buy2>=q1){
          ansBuy1=buy1 ;
        }
      }
      if(ansBuy1==-1)System.out.println("NA");
      else {
        int buy2=(b-c1*ansBuy1)/c2 ;
        System.out.println(ansBuy1+" "+buy2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var q1 : int ; q1 := sc.getCurrent()->toInteger() ;
     if (q1 = 0) then     break else skip ; 
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c1 : int ; c1 := sc.getCurrent()->toInteger() ;
    var c2 : int ; c2 := sc.getCurrent()->toInteger() ;
    var q2 : int ; q2 := sc.getCurrent()->toInteger() ;
    var BUY1U : int ; BUY1U := Set{b / c1, q2}->min() ;
    var ansBuy1 : int ; ansBuy1 := -1 ;
        var buy1 : int ; buy1 := 1 ; while buy1 <= BUY1U do ( (     var buy2 : int ; buy2 := (b - c1 * buy1) / c2 ;
     if (buy1 > 0 & buy1 + buy2 >= q1) then (     ansBuy1 := buy1 ) else skip )  ;     buy1 := buy1 + 1 ) ; 
    if (ansBuy1 = -1) then     OclFile["System.out"].println("NA") else (     var buy2 : int ; buy2 := (b - c1 * ansBuy1) / c2 ;
     OclFile["System.out"].println(ansBuy1 + " " + buy2) ) ;  
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      if(line.equals("0"))break ;
      words=line.split(" ");
      int q1,b,c1,c2,q2 ;
      q1=parseInt(words[0]);
      b=parseInt(words[1]);
      c1=parseInt(words[2]);
      c2=parseInt(words[3]);
      q2=parseInt(words[4]);
      int a1=0,a2=0 ;
      if(b/c1>=q2){
        a1=q2 ;
        a2=(b-c1*q2)/c2 ;
      }
      else {
        a1=b/c1 ;
        a2=(b-c1*a1)/c2 ;
      }
      if(a1+a2<q1){
        if(c1>c2){
          while(a1+a2<q1){
            a1--;
            a2=(b-c1*a1)/c2 ;
          }
        }
        else if(c1<c2){
          while(a1+a2<q1){
            a2--;
            a1=(b-c2*a2)/c1 ;
          }
        }
      }
      if(a1>0 && a2>=0 && a1+a2>=q1 && a1<=q2){
        System.out.println(a1+" "+a2);
      }
      else {
        System.out.println("NA");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     if (line = "0") then     break else skip ; 
     words := line->split(" ") ; 
    var q1 : int ;
    var b : int ;
    var c1 : int ;
    var c2 : int ;
    var q2 : int ;
    q1 := (words[0+1] + "")->toInteger() ; 
    b := (words[1+1] + "")->toInteger() ; 
    c1 := (words[2+1] + "")->toInteger() ; 
    c2 := (words[3+1] + "")->toInteger() ; 
    q2 := (words[4+1] + "")->toInteger() ; 
    var a1 : int ; a1 := 0 ;
    var a2 : int ; a2 := 0 ;
    if (b / c1 >= q2) then (     a1 := q2 ; 
     a2 := (b - c1 * q2) / c2 ) else (     a1 := b / c1 ; 
     a2 := (b - c1 * a1) / c2 ) ;  
    if (a1 + a2 < q1) then (     if (c1 > c2) then (     while (a1 + a2 < q1) do (     a1 := a1 - 1 ; 
     a2 := (b - c1 * a1) / c2 ) ) else     if (c1 < c2) then (     while (a1 + a2 < q1) do (     a2 := a2 - 1 ; 
     a1 := (b - c2 * a2) / c1 ) ) else skip ; ) else skip ; 
    if (a1 > 0 & a2 >= 0 & a1 + a2 >= q1 & a1 <= q2) then (     OclFile["System.out"].println(a1 + " " + a2) ) else (     OclFile["System.out"].println("NA") ) ;  
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  private static int minBroadcastRange(int[] houses,int[] towers){
    int n=houses.length ;
    int m=towers.length ;
    int leftTower=Integer.MIN_VALUE ;
    int rightTower=towers[0];
    int j=0,k=0 ;
    int min_range=0 ;
    while(j<n){
      if(houses[j]<rightTower){
        int left=houses[j]-leftTower ;
        int right=rightTower-houses[j];
        int local_max=left<right ? left : right ;
        if(local_max>min_range)min_range=local_max ;
        j++;
      }
      else {
        leftTower=towers[k];
        if(k<m-1){
          k++;
          rightTower=towers[k];
        }
        else rightTower=Integer.MAX_VALUE ;
      }
    }
    return min_range ;
  }
  public static void main(String[] args){
    int[] a={
      12,13,11,80 };
      int[] b={
        4,6,15,60 };
        int max=minBroadcastRange(a,b);
        System.out.println(max);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minBroadcastRange( houses : Sequence(int), towers : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := houses->size() ;
     var m : int ; m := towers->size() ;
    var leftTower : int ; leftTower := -2147483648 ;
    var rightTower : int ; rightTower := towers[0+1] ;
    var j : int ; j := 0 ;
    var k : int ; k := 0 ;
    var min_range : int ; min_range := 0 ;
    while (j < n) do (     if (houses[j+1] < rightTower) then (     var left : int ; left := houses[j+1] - leftTower ;
     var right : int ; right := rightTower - houses[j+1] ;
    var local_max : int ; local_max := if left < right then left else right endif ;
    if (local_max > min_range) then     min_range := local_max ; else skip ; 
    j := j + 1 ; 
 ) else (     leftTower := towers[k+1] ; 
     if (k < m - 1) then (     k := k + 1 ; 
     rightTower := towers[k+1] ) else     rightTower := 2147483647 ; ) ) ; 
    return min_range 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{12,13,11,80} ;
     var b : Sequence(int) ; b := Sequence{4,6,15,60} ;
     var max : int ; max := minBroadcastRange(a, b) ;
     OclFile["System.out"].println(max) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      int q1=sc.nextInt();
      if(q1==0)return ;
      int b=sc.nextInt();
      int c1=sc.nextInt();
      int c2=sc.nextInt();
      int q2=sc.nextInt();
      int aizCnt=0 ;
      int norCnt=0 ;
      aizCnt=Math.min(b/c1,q2);
      b-=aizCnt*c1 ;
      norCnt+=b/c2 ;
      b-=norCnt*c2 ;
      while(aizCnt+norCnt<q1 && 1<aizCnt--){
        b+=c1 ;
        norCnt+=b/c2 ;
        b-=(b/c2)*c2 ;
      }
      System.out.println((aizCnt==0 || aizCnt+norCnt<q1)? "NA" :(aizCnt+" "+norCnt));
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var q1 : int ; q1 := sc.getCurrent()->toInteger() ;
     if (q1 = 0) then     return else skip ; 
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c1 : int ; c1 := sc.getCurrent()->toInteger() ;
    var c2 : int ; c2 := sc.getCurrent()->toInteger() ;
    var q2 : int ; q2 := sc.getCurrent()->toInteger() ;
    var aizCnt : int ; aizCnt := 0 ;
    var norCnt : int ; norCnt := 0 ;
    aizCnt := Set{b / c1, q2}->min() ; 
    b := b-(aizCnt * c1) ; 
    norCnt := norCnt+(b / c2) ; 
    b := b-(norCnt * c2) ; 
        while (aizCnt + norCnt < q1 & 1 < aizCnt) do (    skip ; (     b := b+(c1) ; 
     norCnt := norCnt+(b / c2) ; 
     b := b-((b / c2) * c2) ) ;  ) ;  
    OclFile["System.out"].println(if (aizCnt = 0 or aizCnt + norCnt < q1) then "NA" else (aizCnt + " " + norCnt) endif) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int maxval(int a[],int n){
    if(n<2){
      return-99999 ;
    }
    int max=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        int x=(a[i]+i)*(a[j]+j);
        if(max<x){
          max=x ;
        }
      }
    }
    return max ;
  }
  public static void main(String args[]){
    int arr[]={
      4,5,3,1,10 };
      int len=arr.length ;
      System.out.println(maxval(arr,len));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxval( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n < 2) then (     return -99999 ) else skip ; 
     var max : int ; max := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var x : int ; x := (a[i+1] + i) * (a[j+1] + j) ;
     if (max < x) then (     max := x ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return max );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,5,3,1,10} ;
     var len : int ; len := arr->size() ;
     OclFile["System.out"].println(maxval(arr, len)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    if((a<=b)&&(a<=c)&&(b<=c)){
      System.out.printf("%d %d %d\n",a,b,c);
    }
    else if((a<=b)&&(a<=c)&&(c<=b)){
      System.out.printf("%d %d %d\n",a,c,b);
    }
    else if((b<=a)&&(b<=c)&&(a<=c)){
      System.out.printf("%d %d %d\n",b,a,c);
    }
    else if((b<=a)&&(b<=c)&&(c<=a)){
      System.out.printf("%d %d %d\n",b,c,a);
    }
    else if((c<=a)&&(c<=b)&&(a<=b)){
      System.out.printf("%d %d %d\n",c,a,b);
    }
    else if((c<=a)&&(c<=b)&&(b<=a)){
      System.out.printf("%d %d %d\n",c,b,a);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    if ((a <= b) & (a <= c) & (b <= c)) then (     OclFile["System.out"].printf("%d %d %d\n", a, b, c) ) else     if ((a <= b) & (a <= c) & (c <= b)) then (     OclFile["System.out"].printf("%d %d %d\n", a, c, b) ) else     if ((b <= a) & (b <= c) & (a <= c)) then (     OclFile["System.out"].printf("%d %d %d\n", b, a, c) ) else     if ((b <= a) & (b <= c) & (c <= a)) then (     OclFile["System.out"].printf("%d %d %d\n", b, c, a) ) else     if ((c <= a) & (c <= b) & (a <= b)) then (     OclFile["System.out"].printf("%d %d %d\n", c, a, b) ) else     if ((c <= a) & (c <= b) & (b <= a)) then (     OclFile["System.out"].printf("%d %d %d\n", c, b, a) ) else skip ; ;  ;  ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findDigitalRoot(int num){
    int sum=Integer.MAX_VALUE,tempNum=num ;
    while(sum>=10){
      sum=0 ;
      while(tempNum>0){
        sum+=tempNum % 10 ;
        tempNum/=10 ;
      }
      tempNum=sum ;
    }
    return sum ;
  }
  static void findAnswer(int X,int N){
    int counter=0 ;
    for(int i=1 ; counter<N ; ++i){
      int digitalRoot=findDigitalRoot(i);
      if(digitalRoot==X){
++counter ;
      }
      if(counter==N){
        System.out.print(i);
        break ;
      }
    }
  }
  public static void main(String args[]){
    int X=1,N=3 ;
    findAnswer(X,N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findDigitalRoot( num : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 2147483647 ;
    var tempNum : int ; tempNum := num ;
     while (sum >= 10) do (     sum := 0 ; 
     while (tempNum > 0) do (     sum := sum+(tempNum mod 10) ; 
     tempNum := tempNum/(10) ) ; 
     tempNum := sum ) ; 
     return sum );
  static   operation findAnswer( X : int, N : int) : void
  pre: true
  post: true
  activity: (     var counter : int ; counter := 0 ;
         var i : int ; i := 1 ; while counter < N do ( (     var digitalRoot : int ; digitalRoot := findDigitalRoot(i) ;
     if (digitalRoot = X) then (     counter := counter + 1 ) else skip ; 
     if (counter = N) then (     OclFile["System.out"].print(i) ; 
     break ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 1 ;
    var N : int ; N := 3 ;
     execute findAnswer(X, N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int reversDigits(int num){
    int rev_num=0 ;
    while(num>0){
      rev_num=rev_num*10+num % 10 ;
      num=num/10 ;
    }
    return rev_num ;
  }
  public static void main(String[] args){
    int num=4562 ;
    System.out.println("Reverse of no.is "+reversDigits(num));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation reversDigits( num : int) : int
  pre: true
  post: true
  activity: (     var rev_num : int ; rev_num := 0 ;
     while (num > 0) do (     rev_num := rev_num * 10 + num mod 10 ; 
     num := num / 10 ) ; 
     return rev_num );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 4562 ;
     OclFile["System.out"].println("Reverse of no.is " + reversDigits(num)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int reversDigits(int num){
    int rev_num=0 ;
    while(num>0){
      rev_num=rev_num*10+num % 10 ;
      num=num/10 ;
    }
    return rev_num ;
  }
  public static void main(String[] args){
    int num=4562 ;
    System.out.println("Reverse of no.is "+reversDigits(num));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation reversDigits( num : int) : int
  pre: true
  post: true
  activity: (     var rev_num : int ; rev_num := 0 ;
     while (num > 0) do (     rev_num := rev_num * 10 + num mod 10 ; 
     num := num / 10 ) ; 
     return rev_num );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 4562 ;
     OclFile["System.out"].println("Reverse of no.is " + reversDigits(num)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int reversDigits(int num){
    int rev_num=0 ;
    while(num>0){
      rev_num=rev_num*10+num % 10 ;
      num=num/10 ;
    }
    return rev_num ;
  }
  public static void main(String[] args){
    int num=4562 ;
    System.out.println("Reverse of no.is "+reversDigits(num));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation reversDigits( num : int) : int
  pre: true
  post: true
  activity: (     var rev_num : int ; rev_num := 0 ;
     while (num > 0) do (     rev_num := rev_num * 10 + num mod 10 ; 
     num := num / 10 ) ; 
     return rev_num );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 4562 ;
     OclFile["System.out"].println("Reverse of no.is " + reversDigits(num)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int rev_num=0 ;
  static int base_pos=1 ;
  static int reversDigits(int num){
    if(num>0){
      reversDigits(num/10);
      rev_num+=(num % 10)*base_pos ;
      base_pos*=10 ;
    }
    return rev_num ;
  }
  public static void main(String[] args){
    int num=4562 ;
    System.out.println(reversDigits(num));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute rev_num : int := 0;
  static   attribute base_pos : int := 1;
  static   operation reversDigits( num : int) : int
  pre: true
  post: true
  activity: (     if (num > 0) then (     execute reversDigits(num / 10) ; 
     rev_num := rev_num+((num mod 10) * base_pos) ; 
     base_pos := base_pos*(10) ) else skip ; 
     return rev_num );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 4562 ;
     OclFile["System.out"].println(reversDigits(num)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int rev_num=0 ;
  static int base_pos=1 ;
  static int reversDigits(int num){
    if(num>0){
      reversDigits(num/10);
      rev_num+=(num % 10)*base_pos ;
      base_pos*=10 ;
    }
    return rev_num ;
  }
  public static void main(String[] args){
    int num=4562 ;
    System.out.println(reversDigits(num));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute rev_num : int := 0;
  static   attribute base_pos : int := 1;
  static   operation reversDigits( num : int) : int
  pre: true
  post: true
  activity: (     if (num > 0) then (     execute reversDigits(num / 10) ; 
     rev_num := rev_num+((num mod 10) * base_pos) ; 
     base_pos := base_pos*(10) ) else skip ; 
     return rev_num );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 4562 ;
     OclFile["System.out"].println(reversDigits(num)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class PrimeNumber {
  static void primeOccurences(int[] arr,int k){
    Map<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<arr.length ; i++){
      int val=arr[i];
      int freq ;
      if(map.containsKey(val)){
        freq=map.get(val);
        freq++;
      }
      else freq=1 ;
      map.put(val,freq);
    }
    for(Map.Entry<Integer,Integer>entry : map.entrySet()){
      int value=entry.getValue();
      if(isPrime(value)&& value>=k)System.out.println(entry.getKey());
    }
  }
  private static boolean isPrime(int n){
    if((n>2 && n % 2==0)|| n==1)return false ;
    for(int i=3 ; i<=(int)Math.sqrt(n); i+=2){
      if(n % i==0)return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    int[] arr={
      11,11,11,23,11,37,37,51,51,51,51,51 };
      int k=2 ;
      primeOccurences(arr,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class PrimeNumber {
  static   operation primeOccurences( arr : Sequence(int), k : int) : void
  pre: true
  post: true
  activity: (     var map : Map(int,int) ; map := Map{} ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     var val : int ; val := arr[i+1] ;
     var freq : int ;
     if (map->keys()->includes(val)) then (     freq := map->at(val) ; 
     freq := freq + 1 ) else     freq := 1 ; ;  
     map := map->union(Map{val |-> freq}) )  ;     i := i + 1 ) ; 
     for (entry : map->asSet()) do ( (     var value : int ; value := entry.getValue() ;
     if (isPrime(value) & value >= k) then     OclFile["System.out"].println(entry.getKey()) ; else skip )  ) );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if ((n > 2 & n mod 2 = 0) or n = 1) then     return false else skip ; 
         var i : int ; i := 3 ; while i <= (n)->sqrt()->oclAsType(int) do ( (     if (n mod i = 0) then     return false else skip )  ;     i := i+(2) ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{11,11,11,23,11,37,37,51,51,51,51,51} ;
     var k : int ; k := 2 ;
     execute primeOccurences(arr, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class SillyMistake {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    String[] temp=br.readLine().split(" ");
    int[] events=new int[n];
    for(int i=0 ; i<n ; i++){
      events[i]=Integer.parseInt(temp[i]);
    }
    List<Integer>res=new ArrayList<>();
    Set<Integer>entered=new HashSet<>();
    Map<Integer,Integer>countEnter=new HashMap();
    int left=0 ;
    for(int right=0 ; right<n ; right++){
      int event=events[right];
      if(event<0){
        if(entered.contains(-event)==false){
          pr.println(-1);
          return ;
        }
        entered.remove(-event);
        if(entered.size()==0){
          res.add(right-left+1);
          left=right+1 ;
          countEnter=new HashMap<>();
        }
      }
      else if(event>0){
        if(countEnter.containsKey(event)){
          pr.println(-1);
          return ;
        }
        countEnter.put(event,1);
        entered.add(event);
      }
    }
    if(entered.size()!=0){
      pr.println(-1);
      return ;
    }
    pr.println(res.size());
    for(int i : res){
      pr.print(i+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SillyMistake {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
    var events : Sequence(int) ; events := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     events[i+1] := (temp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var res : Sequence(int) ; res := Sequence{} ;
    var entered : Set(int) ; entered := Set{} ;
    var countEnter : Map(int,int) ; countEnter := Map{} ;
    var left : int ; left := 0 ;
        var right : int ; right := 0 ; while right < n do ( (     var event : int ; event := events[right+1] ;
     if (event < 0) then (     if (entered->includes(-event) = false) then (     skip ; 
     return ) else skip ; 
     entered := entered->excludingFirst(-event) ; 
     if (entered->size() = 0) then (     res := res->including(right - left + 1) ; 
     left := right + 1 ; 
     countEnter := Map{} ) else skip ) else     if (event > 0) then (     if (countEnter->keys()->includes(event)) then (     skip ; 
     return ) else skip ; 
     countEnter := countEnter->union(Map{event |-> 1}) ; 
     entered := entered->including(event) ) else skip ; )  ;     right := right + 1 ) ; 
    if (entered->size() /= 0) then (     skip ; 
     return ) else skip ; 
    skip ; 
    for (i : res) do ( (     skip )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static float trianglearea(float l,float b){
    if(l<0 || b<0)return-1 ;
    float area=(l*b)/2 ;
    return area ;
  }
  public static void main(String args[]){
    float l=5,b=4 ;
    System.out.println(trianglearea(l,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation trianglearea( l : double, b : double) : double
  pre: true
  post: true
  activity: (     if (l < 0 or b < 0) then     return -1 else skip ; 
     var area : double ; area := (l * b) / 2 ;
     return area );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : double ; l := 5 ;
    var b : double ; b := 4 ;
     OclFile["System.out"].println(trianglearea(l, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxSubArraySum(int a[],int size){
    int max_so_far=Integer.MIN_VALUE,max_ending_here=0,start=0,end=0,s=0 ;
    for(int i=0 ; i<size ; i++){
      max_ending_here+=a[i];
      if(max_so_far<max_ending_here){
        max_so_far=max_ending_here ;
        start=s ;
        end=i ;
      }
      if(max_ending_here<0){
        max_ending_here=0 ;
        s=i+1 ;
      }
    }
    return(end-start+1);
  }
  public static void main(String[] args){
    int a[]={
-2,-3,4,-1,-2,1,5,-3 };
      int n=a.length ;
      System.out.println(maxSubArraySum(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxSubArraySum( a : Sequence(int), size : int) : int
  pre: true
  post: true
  activity: (     var max_so_far : int ; max_so_far := -2147483648 ;
    var max_ending_here : int ; max_ending_here := 0 ;
    var start : int ; start := 0 ;
    var end : int ; end := 0 ;
    var s : int ; s := 0 ;
         var i : int ; i := 0 ; while i < size do ( (     max_ending_here := max_ending_here+(a[i+1]) ; 
     if (max_so_far < max_ending_here) then (     max_so_far := max_ending_here ; 
     start := s ; 
     end := i ) else skip ; 
     if (max_ending_here < 0) then (     max_ending_here := 0 ; 
     s := i + 1 ) else skip )  ;     i := i + 1 ) ; 
     return (end - start + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{-2,-3,4,-1,-2,1,5,-3} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(maxSubArraySum(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test300 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int a[]=new int[100];
    int min=1 ;
    for(int i=0 ; i<n ; i++){
      int x=in.nextInt();
      a[x-1]++;
      if(a[x-1]>min){
        min=a[x-1];
      }
    }
    System.out.println(min);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test300 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,100)->collect(0) ;
    var min : int ; min := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     a[x - 1+1] := a[x - 1+1] + 1 ; 
     if (a[x - 1+1] > min) then (     min := a[x - 1+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    ArrayList<Short>list=new ArrayList<Short>();
    list.add(in.nextShort());
    list.add(in.nextShort());
    list.add(in.nextShort());
    Collections.sort(list);
    byte c=0 ;
    String s ;
    for(Short i : list){
      if(c<list.size()-1)s=" " ;
      else s="" ;
      System.out.printf("%d%s",i,s);
      c+=1 ;
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(int) ; list := Sequence{} ;
    list := list->including(in.nextShort()) ; 
    list := list->including(in.nextShort()) ; 
    list := list->including(in.nextShort()) ; 
    list := list->sort() ; 
    var c : int ; c := 0 ;
    var s : String ;
    for (i : list) do ( (     if (c < list->size() - 1) then     s := " " else     s := "" ; ;  
     OclFile["System.out"].printf("%d%s", i, s) ; 
     c := c+(1) )  ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class PolycarpsPockets {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[] A=new int[101];
    scan.nextLine();
    for(int i=0 ; i<n ; i++){
      A[scan.nextInt()]++;
    }
    int res=0 ;
    for(int i=0 ; i<101 ; i++){
      if(A[i]>res){
        res=A[i];
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class PolycarpsPockets {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,101)->collect(0) ;
    skip ; 
        var i : int ; i := 0 ; while i < n do ( (     A[scan.getCurrent()->toInteger()+1] := A[scan.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < 101 do ( (     if (A[i+1] > res) then (     res := A[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[101];
    int MAX=0 ;
    for(int i=0 ; i<n ; ++i){
      int b=sc.nextInt();
      a[b]++;
      MAX=Math.max(a[b],MAX);
    }
    System.out.println(MAX);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,101)->collect(0) ;
    var MAX : int ; MAX := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var b : int ; b := sc.getCurrent()->toInteger() ;
     a[b+1] := a[b+1] + 1 ; 
     MAX := Set{a[b+1], MAX}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(MAX) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    int n=Integer.parseInt(br.readLine().trim());
    int arr[]=new int[n];
    String a[]=br.readLine().trim().split(" ");
    for(int i=0 ; i<n ; i++)arr[i]=Integer.parseInt(a[i]);
    int max=Integer.MIN_VALUE ;
    HashMap<Integer,Integer>l=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      l.put(arr[i],1+l.getOrDefault(arr[i],0));
    }
    for(Map.Entry<Integer,Integer>x : l.entrySet()){
      max=Math.max(max,x.getValue());
    }
    bw.write(max+"\n");
    br.close();
    bw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := (br.readLine()->trim())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var a : Sequence(String) ; a := br.readLine()->trim()->split(" ") ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := (a[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
    var l : Map(int,int) ; l := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     l := l->union(Map{arr[i+1] |-> 1 + (if l->keys()->contains(arr[i+1]) then l->at(arr[i+1]) else 0 endif)}) )  ;     i := i + 1 ) ; 
    for (x : l->asSet()) do ( (     max := Set{max, x.getValue()}->max() )  ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int n=input.nextInt();
    int count[]=new int[1000];
    int max=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      int value=input.nextInt();
      count[value]++;
      max=Math.max(max,count[value]);
    }
    System.out.println(max);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var n : int ; n := input.nextInt() ;
    var count : Sequence(int) ; count := Integer.subrange(1,1000)->collect(0) ;
    var max : int ; max := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     var value : int ; value := input.nextInt() ;
     count[value+1] := count[value+1] + 1 ; 
     max := Set{max, count[value+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    ArrayList<Integer>ans=new ArrayList<>();
    int cnt=0 ;
    for(int i=0 ; i<20 ; i++){
      int pow=-1 ;
      for(int j=0 ; (1<<j)<=n ; j++){
        if(((1<<j)& n)==0){
          pow=j ;
        }
      }
      if(pow==-1)break ;
      pow++;
      cnt++;
      n ^=((1<<pow)-1);
      boolean allok=true ;
      for(int k=0 ; (1<<k)<=n ; k++){
        if(((1<<k)& n)==0){
          allok=false ;
          break ;
        }
      }
      if(allok){
        ans.add(pow);
        break ;
      }
      cnt++;
      n+=1 ;
      ans.add(pow);
    }
    if(cnt==0)pw.println(0);
    else {
      pw.println(cnt);
      for(int a : ans)pw.print(a+" ");
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var ans : Sequence(int) ; ans := Sequence{} ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < 20 do ( (     var pow : int ; pow := -1 ;
         var j : int ; j := 0 ; while ((1*(2->pow(j)))->oclAsType(long)) <= n do ( (     if ((((1*(2->pow(j)))->oclAsType(long)) & n) = 0) then (     pow := j ) else skip )  ;     j := j + 1 ) ; 
    if (pow = -1) then     break else skip ; 
    pow := pow + 1 ; 
    cnt := cnt + 1 ; 
    n := MathLib.bitwiseXor(n,(((1*(2->pow(pow)))->oclAsType(long)) - 1)) ; 
    var allok : boolean ; allok := true ;
        var k : int ; k := 0 ; while ((1*(2->pow(k)))->oclAsType(long)) <= n do ( (     if ((((1*(2->pow(k)))->oclAsType(long)) & n) = 0) then (     allok := false ; 
     break ) else skip )  ;     k := k + 1 ) ; 
    if (allok) then (     ans := ans->including(pow) ; 
     break ) else skip ; 
    cnt := cnt + 1 ; 
    n := n+(1) ; 
    ans := ans->including(pow) ; 
 )  ;     i := i + 1 ) ; 
    if (cnt = 0) then     skip else (     skip ; 
     for (a : ans) do (     skip ;  ) ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static long N ;
  public static HashSet<Long>set ;
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    N=s.nextLong();
    set=new HashSet<Long>();
    long curr=1 ;
    for(int i=0 ; i<60 ; i++){
      curr*=2 ;
      set.add(curr-1);
    }
    int count=0 ;
    ArrayList<Integer>list=new ArrayList<Integer>();
    while(! set.contains(N)){
      int k=highest(N);
      long xor=(1L<<(k+1))-1 ;
      list.add(k+1);
      N ^=xor ;
      count++;
      if(set.contains(N)){
        break ;
      }
      N++;
      count++;
    }
    System.out.println(count);
    for(long i : list){
      System.out.print(i+" ");
    }
  }
  public static int highest(long i){
    for(int k=40 ; k>=0 ; k--){
      if(((i>>k)& 1)==1){
        return k ;
      }
    }
    return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : long;
  static   attribute set : Set(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := s.getCurrent()->toLong() ; 
    set := Set{} ; 
    var curr : long ; curr := 1 ;
        var i : int ; i := 0 ; while i < 60 do ( (     curr := curr*(2) ; 
     set := set->including(curr - 1) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var list : Sequence(int) ; list := Sequence{} ;
    while (not(set->includes(N))) do (     var k : int ; k := highest(N) ;
     var xor : long ; xor := ((1L*(2->pow((k + 1))))->oclAsType(long)) - 1 ;
    list := list->including(k + 1) ; 
    N := MathLib.bitwiseXor(N,xor) ; 
    count := count + 1 ; 
    if (set->includes(N)) then (     break ) else skip ; 
    N := N + 1 ; 
    count := count + 1 ; 
 ) ; 
    OclFile["System.out"].println(count) ; 
    for (i : list) do ( (     OclFile["System.out"].print(i + " ") )  ) ; 
 );
  static   operation highest( i : long) : int
  pre: true
  post: true
  activity: (         var k : int ; k := 40 ; while k >= 0 do ( (     if ((((i/(2->pow(k)))->oclAsType(long)) & 1) = 1) then (     return k ) else skip )  ;     k := k - 1 ) ; 
     return -1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=s.nextInt();
    }
    fun(arr,n);
  }
  static void fun(int[] arr,int n){
    int iszero=0 ;
    int count=0 ;
    int ans1=0 ;
    HashSet<Integer>hs=new HashSet<>();
    ArrayList<Integer>lengths=new ArrayList<>();
    HashMap<Integer,Integer>h=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(arr[i]>0){
        if(hs.contains(arr[i])){
          System.out.println(-1);
          return ;
        }
        else {
          hs.add(arr[i]);
          h.put(arr[i],1);
          iszero++;
          if(hs.size()==1){
            count=i ;
          }
        }
      }
      else {
        if(hs.contains(arr[i])){
          System.out.println(-1);
          return ;
        }
        else {
          int x=Math.abs(arr[i]);
          if(! hs.contains(x)){
            System.out.println(-1);
            return ;
          }
          else {
            hs.add(arr[i]);
            h.put(x,0);
            iszero--;
            if(iszero==0){
              lengths.add(i-count+1);
              hs.clear();
              h.clear();
            }
          }
        }
      }
      if(i==n-1 && hs.size()>0){
        System.out.println(-1);
        return ;
      }
    }
    System.out.println(lengths.size());
    for(int e : lengths)System.out.print(e+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute fun(arr, n) ; 
 );
  static   operation fun( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var iszero : int ; iszero := 0 ;
     var count : int ; count := 0 ;
    var ans1 : int ; ans1 := 0 ;
    var hs : Set(int) ; hs := Set{} ;
    var lengths : Sequence(int) ; lengths := Sequence{} ;
    var h : Map(int,int) ; h := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] > 0) then (     if (hs->includes(arr[i+1])) then (     OclFile["System.out"].println(-1) ; 
     return ) else (     hs := hs->including(arr[i+1]) ; 
     h := h->union(Map{arr[i+1] |-> 1}) ; 
     iszero := iszero + 1 ; 
     if (hs->size() = 1) then (     count := i ) else skip ) ) else (     if (hs->includes(arr[i+1])) then (     OclFile["System.out"].println(-1) ; 
     return ) else (     var x : int ; x := if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif ;
     if (not(hs->includes(x))) then (     OclFile["System.out"].println(-1) ; 
     return ) else (     hs := hs->including(arr[i+1]) ; 
     h := h->union(Map{x |-> 0}) ; 
     iszero := iszero - 1 ; 
     if (iszero = 0) then (     lengths := lengths->including(i - count + 1) ; 
     hs := hs->intersection(Set{}) ; 
     h := h->intersection(Map{}) ) else skip ) ) ) ;  
     if (i = n - 1 & hs->size() > 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(lengths->size()) ; 
    for (e : lengths) do (     OclFile["System.out"].print(e + " ") ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class Main {
  public static int inf=(int)1e9+7 ;
  public static void main(String[] args)throws IOException,InterruptedException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int len=0 ;
    for(int i=31 ; i>=0 ; i--){
      if(((x>>i)& 1)==1){
        len=i+1 ;
        break ;
      }
    }
    int opt=1 ;
    if(x==(1<<(len+1))-1){
      System.out.println(0);
    }
    else {
      List<Integer>list=new ArrayList<>();
      while(x!=(1<<(len))-1){
        if(opt % 2==0){
          opt++;
          x++;
        }
        else {
          for(int i=len-1 ; i>=0 ; i--){
            if(((x>>i)& 1)==0){
              x ^=(1<<(i+1))-1 ;
              list.add(i+1);
              opt++;
              break ;
            }
          }
        }
      }
      System.out.println(opt-1);
      for(int y : list){
        System.out.print(y+" ");
      }
    }
    sc.close();
    writer.flush();
    writer.close();
    reader.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute inf : int := 1e9->oclAsType(int) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var len : int ; len := 0 ;
        var i : int ; i := 31 ; while i >= 0 do ( (     if ((((x/(2->pow(i)))->oclAsType(long)) & 1) = 1) then (     len := i + 1 ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    var opt : int ; opt := 1 ;
    if (x = ((1*(2->pow((len + 1))))->oclAsType(long)) - 1) then (     OclFile["System.out"].println(0) ) else (     var list : Sequence(int) ; list := Sequence{} ;
     while (x /= ((1*(2->pow((len))))->oclAsType(long)) - 1) do (     if (opt mod 2 = 0) then (     opt := opt + 1 ; 
     x := x + 1 ) else (         var i : int ; i := len - 1 ; while i >= 0 do ( (     if ((((x/(2->pow(i)))->oclAsType(long)) & 1) = 0) then (     x := MathLib.bitwiseXor(x,((1*(2->pow((i + 1))))->oclAsType(long)) - 1) ; 
     list := list->including(i + 1) ; 
     opt := opt + 1 ; 
     break ) else skip )  ;     i := i - 1 ) ) ) ; 
     OclFile["System.out"].println(opt - 1) ; 
     for (y : list) do ( (     OclFile["System.out"].print(y + " ") )  ) ) ;  
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
class GfG {
  static int sumKRepeating(int arr[],int n,int k){
    int sum=0 ;
    HashMap<Integer,Integer>mp=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(! mp.containsKey(arr[i]))mp.put(arr[i],0);
      mp.put(arr[i],mp.get(arr[i])+1);
    }
    for(Integer x : mp.keySet())if(mp.get(x)==k)sum+=x ;
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      9,9,10,11,8,8,9,8 };
      int n=arr.length ;
      int k=3 ;
      System.out.println(sumKRepeating(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation sumKRepeating( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var mp : Map(int,int) ; mp := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (not(mp->keys()->includes(arr[i+1]))) then     mp := mp->union(Map{arr[i+1] |-> 0}) ; else skip ; 
     mp := mp->union(Map{arr[i+1] |-> mp->at(arr[i+1]) + 1}) )  ;     i := i + 1 ) ; 
    for (x : mp->keys()) do (     if (mp->at(x) = k) then     sum := sum+(x) ; else skip ;  ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{9,9,10,11,8,8,9,8} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println(sumKRepeating(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.stream.Collectors ;
import java.util.stream.Stream ;
public class Temp {
  static BufferedReader br=null ;
  static Scanner sc=null ;
  public static void main(String[] args){
    br=new BufferedReader(new InputStreamReader(System.in));
    sc=new Scanner(System.in);
    try {
      int n=sc.nextInt();
      int m=sc.nextInt();
      int[][] marks=new int[n][m];
      int[] subjects=new int[m];
      for(int i=0 ; i<n ; i++){
        char[] line=sc.next().toCharArray();
        for(int j=0 ; j<m ; j++){
          marks[i][j]=line[j]-'0' ;
          subjects[j]=Math.max(subjects[j],marks[i][j]);
        }
      }
      int sucessfull=0 ;
      for(int[] student : marks){
        for(int i=0 ; i<m ; i++){
          if(student[i]==subjects[i]){
            sucessfull++;
            break ;
          }
        }
      }
      System.out.println(sucessfull);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Temp {
  static   attribute br : OclFile := null;
  static   attribute sc : OclFile := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     try (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var marks : Sequence(Sequence(int)) ; marks := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var subjects : Sequence(int) ; subjects := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var line : Sequence(String) ; line := sc.getCurrent()->characters() ;
         var j : int ; j := 0 ; while j < m do ( (     marks[i+1][j+1] := line[j+1] - ('0')->char2byte() ; 
     subjects[j+1] := Set{subjects[j+1], marks[i+1][j+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sucessfull : int ; sucessfull := 0 ;
    for (student : marks) do ( (         var i : int ; i := 0 ; while i < m do ( (     if (student[i+1] = subjects[i+1]) then (     sucessfull := sucessfull + 1 ; 
     break ) else skip )  ;     i := i + 1 ) )  ) ; 
    OclFile["System.out"].println(sucessfull) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.OutputStream ;
import java.io.PrintStream ;
import java.util.*;
public class P152A {
  public static void main(String[] args)throws Exception {
    new P152A().run();
  }
  void run()throws Exception {
    Scanner scanner=new Scanner(getInputStream());
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    String[] grades=new String[n];
    for(int i=0 ; i<n ; i++){
      grades[i]=scanner.next();
    }
    boolean[] best=new boolean[n];
    for(int s=0 ; s<m ; s++){
      char max='0' ;
      for(int i=0 ; i<n ; i++){
        if(grades[i] .charAt(s)>max){
          max=grades[i] .charAt(s);
        }
      }
      for(int i=0 ; i<n ; i++){
        if(grades[i] .charAt(s)==max){
          best[i]=true ;
        }
      }
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(best[i]){
        count++;
      }
    }
    getOutputStream().println(count);
  }
  InputStream getInputStream(){
    return System.in ;
  }
  PrintStream getOutputStream(){
    return System.out ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class P152A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     P152A.newP152A().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(getInputStream()) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var grades : Sequence(String) ; grades := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     grades[i+1] := scanner.getCurrent() )  ;     i := i + 1 ) ; 
    var best : Sequence(boolean) ; best := Integer.subrange(1,n)->collect(false) ;
        var s : int ; s := 0 ; while s < m do ( (     var max : String ; max := '0' ;
         var i : int ; i := 0 ; while i < n do ( (     if (grades[i+1]->at(s+1) > max) then (     max := grades[i+1]->at(s+1) ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (grades[i+1]->at(s+1) = max) then (     best[i+1] := true ) else skip )  ;     i := i + 1 ) )  ;     s := s + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (best[i+1]) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    getOutputStream().println(count) ; 
 );
   operation getInputStream() : OclFile
  pre: true
  post: true
  activity: (     return OclFile["System.in"] );
   operation getOutputStream() : OclFile
  pre: true
  post: true
  activity: (     return OclFile["System.out"] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner imput=new Scanner(System.in);
    int a=imput.nextInt();
    int b=imput.nextInt();
    int c=imput.nextInt();
    int max,mid,min ;
    if(a>b){
      if(a>c){
        max=a ;
        if(b>c){
          mid=b ;
          min=c ;
        }
        else {
          mid=c ;
          min=b ;
        }
      }
      else {
        max=c ;
        mid=a ;
        min=b ;
      }
    }
    else if(a>c){
      max=b ;
      mid=a ;
      min=c ;
    }
    else {
      min=a ;
      if(b>c){
        max=b ;
        mid=c ;
      }
      else {
        max=c ;
        mid=b ;
      }
    }
    System.out.println(min+" "+mid+" "+max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var imput : OclFile ; imput := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := imput.getCurrent()->toInteger() ;
    var b : int ; b := imput.getCurrent()->toInteger() ;
    var c : int ; c := imput.getCurrent()->toInteger() ;
    var max : int ;
    var mid : int ;
    var min : int ;
    if (a > b) then (     if (a > c) then (     max := a ; 
     if (b > c) then (     mid := b ; 
     min := c ) else (     mid := c ; 
     min := b ) ) else (     max := c ; 
     mid := a ; 
     min := b ) ) else     if (a > c) then (     max := b ; 
     mid := a ; 
     min := c ) else (     min := a ; 
     if (b > c) then (     max := b ; 
     mid := c ) else (     max := c ; 
     mid := b ) ) ;  ;  
    OclFile["System.out"].println(min + " " + mid + " " + max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    long matrix[][]=new long[n][m];
    boolean arr[]=new boolean[n];
    for(int i=0 ; i<n ; i++){
      String num=sc.next();
      int len=num.length();
      for(int j=m-1 ; j>=0 ; j--){
        long r=Long.parseLong(Character.toString(num.charAt(len-1)));
        matrix[i][j]=r ;
        len--;
      }
    }
    long max=0 ;
    for(int j=0 ; j<m ; j++){
      max=matrix[0][j];
      ArrayList<Integer>list=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        if(matrix[i][j]==max){
          list.add(i);
        }
        else if(matrix[i][j]>max){
          list.clear();
          list.add(i);
          max=matrix[i][j];
        }
      }
      for(int i=0 ; i<list.size(); i++){
        arr[list.get(i)]=true ;
      }
      list.clear();
    }
    long count=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==true){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var matrix : Sequence(Sequence(long)) ; matrix := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var arr : Sequence(boolean) ; arr := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     var num : String ; num := sc.getCurrent() ;
     var len : int ; len := num->size() ;
         var j : int ; j := m - 1 ; while j >= 0 do ( (     var r : long ; r := ((num->at((len)->char2byte() - 1+1) + ""))->toLong() ;
     matrix[i+1][j+1] := r ; 
     len := len - 1 )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    var max : long ; max := 0 ;
        var j : int ; j := 0 ; while j < m do ( (     max := matrix[0+1][j+1] ; 
     var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (matrix[i+1][j+1] = max) then (     list := list->including(i) ) else     if (matrix[i+1][j+1] > max) then (     list := list->intersection(Set{}) ; 
     list := list->including(i) ; 
     max := matrix[i+1][j+1] ) else skip ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < list->size() do ( (     arr[list->at(i+1)+1] := true )  ;     i := i + 1 ) ; 
    list := list->intersection(Set{}) ; 
 )  ;     j := j + 1 ) ; 
    var count : long ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = true) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int noofstudent=sc.nextInt();
    int noofsubjects=sc.nextInt();
    int arr[][]=new int[noofstudent][noofsubjects];
    for(int i=0 ; i<noofstudent ; i++){
      String s=sc.next();
      for(int j=0 ; j<noofsubjects ; j++){
        arr[i][j]=s.charAt(j);
      }
    }
    HashSet<Integer>set=new HashSet<>();
    for(int i=0 ; i<noofsubjects ; i++){
      int minmarks=Integer.MIN_VALUE ;
      for(int j=0 ; j<noofstudent ; j++){
        if(arr[j][i]>minmarks){
          minmarks=arr[j][i];
        }
      }
      for(int j=0 ; j<noofstudent ; j++){
        if(arr[j][i]==minmarks){
          set.add(j);
        }
      }
    }
    System.out.println(set.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var noofstudent : int ; noofstudent := sc.getCurrent()->toInteger() ;
    var noofsubjects : int ; noofsubjects := sc.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,noofstudent)->collect(Integer.subrange(1,noofsubjects)->collect(0)) ;
        var i : int ; i := 0 ; while i < noofstudent do ( (     var s : String ; s := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < noofsubjects do ( (     arr[i+1][j+1] := s->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < noofsubjects do ( (     var minmarks : int ; minmarks := -2147483648 ;
         var j : int ; j := 0 ; while j < noofstudent do ( (     if (arr[j+1][i+1] > minmarks) then (     minmarks := arr[j+1][i+1] ) else skip )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < noofstudent do ( (     if (arr[j+1][i+1] = minmarks) then (     set := set->including(j) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(set->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findLength(String str,int n){
    int sum[]=new int[n+1];
    sum[0]=0 ;
    for(int i=1 ; i<=n ; i++)sum[i]=(sum[i-1]+str.charAt(i-1)-'0');
    int ans=0 ;
    for(int len=2 ; len<=n ; len+=2){
      for(int i=0 ; i<=n-len ; i++){
        int j=i+len-1 ;
        if(sum[i+len/2]-sum[i]==sum[i+len]-sum[i+len/2])ans=Math.max(ans,len);
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    String str="123123" ;
    System.out.println("Length of the substring is "+findLength(str,str.length()));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findLength( str : String, n : int) : int
  pre: true
  post: true
  activity: (     var sum : Sequence(int) ; sum := Integer.subrange(1,n + 1)->collect(0) ;
     sum[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do (     sum[i+1] := (sum[i - 1+1] + str->at(i - 1+1) - ('0')->char2byte()) ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var len : int ; len := 2 ; while len <= n do ( (         var i : int ; i := 0 ; while i <= n - len do ( (     var j : int ; j := i + len - 1 ;
     if (sum[i + len / 2+1] - sum[i+1] = sum[i + len+1] - sum[i + len / 2+1]) then     ans := Set{ans, len}->max() ; else skip )  ;     i := i + 1 ) )  ;     len := len+(2) ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "123123" ;
     OclFile["System.out"].println("Length of the substring is " + findLength(str, str->size())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      double x=sc.nextDouble();
      System.out.println(x<=48.00 ? "light fly" : x<=51.00 ? "fly" : x<=54.00 ? "bantam" : x<=57.00 ? "feather" : x<=60.00 ? "light" : x<=64.00 ? "light welter" : x<=69.00 ? "welter" : x<=75.00 ? "light middle" : x<=81.00 ? "middle" : x<=91.00 ? "light heavy" : "heavy");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var x : double ; x := sc.getCurrent()->toReal() ;
     OclFile["System.out"].println(if x <= 48.00 then "light fly" else if x <= 51.00 then "fly" else if x <= 54.00 then "bantam" else if x <= 57.00 then "feather" else if x <= 60.00 then "light" else if x <= 64.00 then "light welter" else if x <= 69.00 then "welter" else if x <= 75.00 then "light middle" else if x <= 81.00 then "middle" else if x <= 91.00 then "light heavy" else "heavy" endif endif endif endif endif endif endif endif endif endif) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static String judge(double w){
    if(w<=48.0){
      return "light fly" ;
    }
    else if(w>=48.0 && w<=51.0){
      return "fly" ;
    }
    else if(w>=51.0 && w<=54.0){
      return "bantam" ;
    }
    else if(w>=54.0 && w<=57.0){
      return "feather" ;
    }
    else if(w>=57.0 && w<=60.0){
      return "light" ;
    }
    else if(w>=60.0 && w<=64.0){
      return "light welter" ;
    }
    else if(w>=64.0 && w<=69.0){
      return "welter" ;
    }
    else if(w>=69.0 && w<=75.0){
      return "light middle" ;
    }
    else if(w>=75.0 && w<=81.0){
      return "middle" ;
    }
    else if(w>=81.0 && w<=91.0){
      return "light heavy" ;
    }
    else {
      return "heavy" ;
    }
  }
  public static void main(String[] args)throws IOException {
    Scanner stdIn=null ;
    List<String>result=new ArrayList<String>();
    try {
      stdIn=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
      while(stdIn.hasNext()){
        double w=stdIn.nextDouble();
        result.add(judge(w));
      }
      for(String str : result){
        System.out.println(str);
      }
    }
    finally {
      if(stdIn!=null){
        stdIn.close();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation judge( w : double) : String
  pre: true
  post: true
  activity: (     if (w <= 48.0) then (     return "light fly" ) else     if (w >= 48.0 & w <= 51.0) then (     return "fly" ) else     if (w >= 51.0 & w <= 54.0) then (     return "bantam" ) else     if (w >= 54.0 & w <= 57.0) then (     return "feather" ) else     if (w >= 57.0 & w <= 60.0) then (     return "light" ) else     if (w >= 60.0 & w <= 64.0) then (     return "light welter" ) else     if (w >= 64.0 & w <= 69.0) then (     return "welter" ) else     if (w >= 69.0 & w <= 75.0) then (     return "light middle" ) else     if (w >= 75.0 & w <= 81.0) then (     return "middle" ) else     if (w >= 81.0 & w <= 91.0) then (     return "light heavy" ) else (     return "heavy" ) ;  ;  ;  ;  ;  ;  ;  ;  ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := null ;
     var result : Sequence(String) ; result := Sequence{} ;
     try (     stdIn := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
     while (stdIn.hasNext()) do (     var w : double ; w := stdIn.getCurrent()->toReal() ;
     result := result->including(judge(w)) ) ; 
     for (str : result) do ( (     OclFile["System.out"].println(str) )  ) )   finally (     if (stdIn /= null) then (     skip ) else skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int getRemainder(int num,int divisor){
    return(num-divisor*(num/divisor));
  }
  public static void main(String[] args){
    System.out.println(getRemainder(100,7));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getRemainder( num : int, divisor : int) : int
  pre: true
  post: true
  activity: (     return (num - divisor * (num / divisor)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(getRemainder(100, 7)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static void solve(double w){
    String res="" ;
    if(w<=48.0)res="light fly" ;
    else if(w<=51.0)res="fly" ;
    else if(w<=54.0)res="bantam" ;
    else if(w<=57.0)res="feather" ;
    else if(w<=60.0)res="light" ;
    else if(w<=64.0)res="light welter" ;
    else if(w<=69.0)res="welter" ;
    else if(w<=75.0)res="light middle" ;
    else if(w<=81.0)res="middle" ;
    else if(w<=91.0)res="light heavy" ;
    else res="heavy" ;
    System.out.println(res);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      double weight=sc.nextDouble();
      solve(weight);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( w : double) : void
  pre: true
  post: true
  activity: (     var res : String ; res := "" ;
     if (w <= 48.0) then     res := "light fly" else     if (w <= 51.0) then     res := "fly" else     if (w <= 54.0) then     res := "bantam" else     if (w <= 57.0) then     res := "feather" else     if (w <= 60.0) then     res := "light" else     if (w <= 64.0) then     res := "light welter" else     if (w <= 69.0) then     res := "welter" else     if (w <= 75.0) then     res := "light middle" else     if (w <= 81.0) then     res := "middle" else     if (w <= 91.0) then     res := "light heavy" else     res := "heavy" ; ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  
     OclFile["System.out"].println(res) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var weight : double ; weight := sc.getCurrent()->toReal() ;
     execute solve(weight) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder builder=new StringBuilder();
    String line ;
    String now="A" ;
    while((line=reader.readLine())!=null){
      if(line.isEmpty())break ;
      double a=Double.parseDouble(line);
      if(a>91.00)builder.append("heavy").append('\n');
      else if(a>81.00)builder.append("light heavy").append('\n');
      else if(a>75.00)builder.append("middle").append('\n');
      else if(a>69.00)builder.append("light middle").append('\n');
      else if(a>64.00)builder.append("welter").append('\n');
      else if(a>60.00)builder.append("light welter").append('\n');
      else if(a>57.00)builder.append("light").append('\n');
      else if(a>54.00)builder.append("feather").append('\n');
      else if(a>51.00)builder.append("bantam").append('\n');
      else if(a>48.00)builder.append("fly").append('\n');
      else builder.append("light fly").append('\n');
    }
    System.out.print(builder);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var builder : String ; builder := StringLib.newString() ;
    var line : String ;
    var now : String ; now := "A" ;
        line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->isEmpty()) then     break else skip ; 
     var a : double ; a := (line)->toReal() ;
     if (a > 91.00) then     builder := builder + StringLib.newString("heavy") + StringLib.newString('
') ; else     if (a > 81.00) then     builder := builder + StringLib.newString("light heavy") + StringLib.newString('
') else     if (a > 75.00) then     builder := builder + StringLib.newString("middle") + StringLib.newString('
') else     if (a > 69.00) then     builder := builder + StringLib.newString("light middle") + StringLib.newString('
') else     if (a > 64.00) then     builder := builder + StringLib.newString("welter") + StringLib.newString('
') else     if (a > 60.00) then     builder := builder + StringLib.newString("light welter") + StringLib.newString('
') else     if (a > 57.00) then     builder := builder + StringLib.newString("light") + StringLib.newString('
') else     if (a > 54.00) then     builder := builder + StringLib.newString("feather") + StringLib.newString('
') else     if (a > 51.00) then     builder := builder + StringLib.newString("bantam") + StringLib.newString('
') else     if (a > 48.00) then     builder := builder + StringLib.newString("fly") + StringLib.newString('
') else     builder := builder + StringLib.newString("light fly") + StringLib.newString('
') ; ;  ;  ;  ;  ;  ;  ;  ;  ;  ) ;     line := reader.readLine() ;
 ) ;  
    OclFile["System.out"].print(builder) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static final String LIGHT="light" ;
  public static final String FLY="fly" ;
  public static final String BANTAM="bantam" ;
  public static final String FETHER="feather" ;
  public static final String WELTER="welter" ;
  public static final String MIDDLE="middle" ;
  public static final String HEAVY="heavy" ;
  public static void main(String[] args){
    Scanner scanner=null ;
    try {
      scanner=new Scanner(System.in);
      while(scanner.hasNextDouble()){
        double weight=scanner.nextDouble();
        System.out.println(getClassName(weight));
      }
    }
    finally {
      scanner.close();
    }
  }
  public static String getClassName(double num){
    StringBuilder sb=new StringBuilder();
    if(num<=48.00 ||(57.00<num && num<=64.00)||(69.00<num && num<=75.00)||(81.00<num && num<=91.00)){
      sb.append(LIGHT);
      sb.append(" ");
    }
    if(num<=51.00){
      sb.append(FLY);
    }
    else if(num<=54.00){
      sb.append(BANTAM);
    }
    else if(num<=57.00){
      sb.append(FETHER);
    }
    else if(num<=60.00){
    }
    else if(num<=69.00){
      sb.append(WELTER);
    }
    else if(num<=81.00){
      sb.append(MIDDLE);
    }
    else {
      sb.append(HEAVY);
    }
    return sb.toString().trim();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute LIGHT : String := "light";
  static    attribute FLY : String := "fly";
  static    attribute BANTAM : String := "bantam";
  static    attribute FETHER : String := "feather";
  static    attribute WELTER : String := "welter";
  static    attribute MIDDLE : String := "middle";
  static    attribute HEAVY : String := "heavy";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     while (scanner.hasNextDouble()) do (     var weight : double ; weight := scanner.getCurrent()->toReal() ;
     OclFile["System.out"].println(getClassName(weight)) ) )   finally (     skip )
 );
  static   operation getClassName( num : double) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     if (num <= 48.00 or (57.00 < num & num <= 64.00) or (69.00 < num & num <= 75.00) or (81.00 < num & num <= 91.00)) then (     sb := sb + StringLib.newString(LIGHT) ; 
     sb := sb + StringLib.newString(" ") ) else skip ; 
     if (num <= 51.00) then (     sb := sb + StringLib.newString(FLY) ) else     if (num <= 54.00) then (     sb := sb + StringLib.newString(BANTAM) ) else     if (num <= 57.00) then (     sb := sb + StringLib.newString(FETHER) ) else     if (num <= 60.00) then skip else     if (num <= 69.00) then (     sb := sb + StringLib.newString(WELTER) ) else     if (num <= 81.00) then (     sb := sb + StringLib.newString(MIDDLE) ) else (     sb := sb + StringLib.newString(HEAVY) ) ;  ;  ;  ;  ;  ;  
     return sb+""->trim() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class A_545 {
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    ArrayList<Integer>lt=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      boolean b=true ;
      for(int j=0 ; j<n ; j++){
        int in=sc.nextInt();
        if(in==3 || in==1)b=false ;
      }
      if(b)lt.add(i+1);
    }
    System.out.println(lt.size());
    for(int i=0 ; i<lt.size(); i++)System.out.print(lt.get(i)+" ");
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_545 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : int ; n := sc.nextInt() ;
    var lt : Sequence(int) ; lt := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var b : boolean ; b := true ;
         var j : int ; j := 0 ; while j < n do ( (     var in : int ; in := sc.nextInt() ;
     if (in = 3 or in = 1) then     b := false ; else skip )  ;     j := j + 1 ) ; 
     if (b) then     lt := lt->including(i + 1) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(lt->size()) ; 
        var i : int ; i := 0 ; while i < lt->size() do (     OclFile["System.out"].print(lt->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return (str) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class a {
  private static Scanner sc=new Scanner(System.in);
  private static int n ;
  private static Vector<Integer>mVector=new Vector<>();
  private static void solve()throws Exception {
    Vector<Integer>ansVector=new Vector<>();
    int index=0 ;
    for(int i=0 ; i<n ; i++){
      boolean flag=true ;
      index=i*n ;
      for(int j=0 ; j<n ; j++,index++){
        if(mVector.get(index)==3 || mVector.get(index)==1){
          flag=false ;
          break ;
        }
      }
      if(flag){
        ansVector.add(i+1);
      }
    }
    System.out.println(ansVector.size());
    if(ansVector.size()!=0){
      for(Integer integer : ansVector){
        System.out.print(integer+" ");
      }
    }
  }
  public static void main(String[] args)throws Exception {
    n=sc.nextInt();
    for(int i=0 ; i<n*n ; i++){
      mVector.add(sc.nextInt());
    }
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class a {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   attribute mVector : Sequence(int) := Sequence{};
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var ansVector : Sequence(int) ; ansVector := Sequence{} ;
     var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var flag : boolean ; flag := true ;
     index := i * n ; 
         var j : int ; j := 0 ; while j < n do ( (     if (mVector->at(index+1) = 3 or mVector->at(index+1) = 1) then (     flag := false ; 
     break ) else skip )  ;     j := j + 1 ;     index := index + 1 ) ; 
     if (flag) then (     ansVector := ansVector->including(i + 1) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ansVector->size()) ; 
    if (ansVector->size() /= 0) then (     for (integer : ansVector) do ( (     OclFile["System.out"].print(integer + " ") )  ) ) else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
         var i : int ; i := 0 ; while i < n * n do ( (     mVector := mVector->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int[] num={
      0,0,0 };
      for(int i=0 ; i<num.length ; i++){
        num[i]=scan.nextInt();
      }
      bubbleSort.sort(num);
      System.out.print(num[0]);
      for(int i=1 ; i<num.length ; i++){
        System.out.print(" "+num[i]);
      }
      System.out.println("");
      scan.close();
    }
  }
  class bubbleSort {
    public static void sort(int a[]){
      for(int i=0 ; i<a.length-1 ; i++){
        for(int j=a.length-1 ; j>i ; j--){
          if(a[j]<a[j-1]){
            int t=a[j];
            a[j]=a[j-1];
            a[j-1]=t ;
          }
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : Sequence(int) ; num := Sequence{0,0,0} ;
        var i : int ; i := 0 ; while i < num->size() do ( (     num[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    bubbleSort.sort(num) ; 
    OclFile["System.out"].print(num[0+1]) ; 
        var i : int ; i := 1 ; while i < num->size() do ( (     OclFile["System.out"].print(" " + num[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
    skip ; 
 );
}
class bubbleSort {
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < a->size() - 1 do ( (         var j : int ; j := a->size() - 1 ; while j > i do ( (     if (a[j+1] < a[j - 1+1]) then (     var t : int ; t := a[j+1] ;
     a[j+1] := a[j - 1+1] ; 
     a[j - 1+1] := t ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class J_545 {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int n,ans=0 ;
    n=cin.nextInt();
    int[][] arr=new int[102][102];
    int[] collision=new int[102];
    for(int i=1 ; i<=n ; i++){
      for(int k=1 ; k<=n ; k++){
        arr[i][k]=cin.nextInt();
        if(arr[i][k]==1)collision[i]=1 ;
        else if(arr[i][k]==2)collision[k]=1 ;
        else if(arr[i][k]==3){
          collision[i]=1 ;
          collision[k]=1 ;
        }
      }
    }
    boolean isStart=true ;
    for(int i=1 ; i<=n ; i++){
      if(collision[i]==0)ans++;
    }
    System.out.println(ans);
    if(ans>0){
      for(int i=1 ; i<=n ; i++){
        if(collision[i]==0){
          ans++;
          if(isStart==false)System.out.print(" ");
          isStart=false ;
          System.out.print(i);
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class J_545 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var ans : int ; ans := 0 ;
    n := cin.getCurrent()->toInteger() ; 
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,102)->collect(Integer.subrange(1,102)->collect(0)) ;
    var collision : Sequence(int) ; collision := Integer.subrange(1,102)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (         var k : int ; k := 1 ; while k <= n do ( (     arr[i+1][k+1] := cin.getCurrent()->toInteger() ; 
     if (arr[i+1][k+1] = 1) then     collision[i+1] := 1 ; else     if (arr[i+1][k+1] = 2) then     collision[k+1] := 1 else     if (arr[i+1][k+1] = 3) then (     collision[i+1] := 1 ; 
     collision[k+1] := 1 ) else skip ; ;  )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    var isStart : boolean ; isStart := true ;
        var i : int ; i := 1 ; while i <= n do ( (     if (collision[i+1] = 0) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    if (ans > 0) then (         var i : int ; i := 1 ; while i <= n do ( (     if (collision[i+1] = 0) then (     ans := ans + 1 ; 
     if (isStart = false) then     OclFile["System.out"].print(" ") ; else skip ; 
     isStart := false ; 
     OclFile["System.out"].print(i) ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void rearrange(int a[],int size){
    int positive=0,negative=1,temp ;
    while(true){
      while(positive<size && a[positive]>=0)positive+=2 ;
      while(negative<size && a[negative]<=0)negative+=2 ;
      if(positive<size && negative<size){
        temp=a[positive];
        a[positive]=a[negative];
        a[negative]=temp ;
      }
      else break ;
    }
  }
  public static void main(String args[]){
    int arr[]={
      1,-3,5,6,-3,6,7,-4,9,10 };
      int n=arr.length ;
      rearrange(arr,n);
      for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation rearrange( a : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (     var positive : int ; positive := 0 ;
    var negative : int ; negative := 1 ;
    var temp : int ;
     while (true) do (     while (positive < size & a[positive+1] >= 0) do     positive := positive+(2) ; ; 
     while (negative < size & a[negative+1] <= 0) do     negative := negative+(2) ; ; 
     if (positive < size & negative < size) then (     temp := a[positive+1] ; 
     a[positive+1] := a[negative+1] ; 
     a[negative+1] := temp ) else     break ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,-3,5,6,-3,6,7,-4,9,10} ;
     var n : int ; n := arr->size() ;
     execute rearrange(arr, n) ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int K=scan.nextInt();
    int[] dp=new int[K];
    Arrays.fill(dp,Integer.MAX_VALUE);
    class Node {
      int to,cost ;
      Node(int to,int cost){
        this.to=to ;
        this.cost=cost ;
      }
    }
    PriorityQueue<Node>que=new PriorityQueue<>((a,b)->a.cost-b.cost);
    for(int i=1 ; i<Math.min(10,K); ++i){
      dp[i]=i ;
      que.add(new Node(i,i));
    }
    while(! que.isEmpty()){
      Node node=que.poll();
      int v=node.to ;
      int c=node.cost ;
      if(c>dp[v])continue ;
      for(int i=0 ; i<10 ; ++i){
        int nextv=(v*10+i)% K ;
        int nextc=c+i ;
        if(dp[nextv]>nextc){
          dp[nextv]=nextc ;
          que.add(new Node(nextv,nextc));
        }
      }
    }
    System.out.println(dp[0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var K : int ; K := scan.getCurrent()->toInteger() ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,K)->collect(0) ;
    dp := dp->collect(2147483647) ; 
class Node {
   attribute to : int;
   static operation newNode( to : int, cost : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(to, cost);
    return self );
  operation initialise( to : int, cost : int) : void
  pre: true  post: true
  activity: (     self.to := to ; 
     self.cost := cost );
}
    var que : Sequence(Node) ; que := Sequence{}->union(lambda (a , b) : OclAny in a.cost - b.cost) ;
        var i : int ; i := 1 ; while i < Set{10, K}->min() do ( (     dp[i+1] := i ; 
     que := que->including(Node.newNode(i, i)) )  ;     i := i + 1 ) ; 
    while (not(que->isEmpty())) do (     var node : Node ; node := que->min() ;
     var v : int ; v := node.to ;
    var c : int ; c := node.cost ;
    if (c > dp[v+1]) then     continue else skip ; 
        var i : int ; i := 0 ; while i < 10 do ( (     var nextv : int ; nextv := (v * 10 + i) mod K ;
     var nextc : int ; nextc := c + i ;
     if (dp[nextv+1] > nextc) then (     dp[nextv+1] := nextc ; 
     que := que->including(Node.newNode(nextv, nextc)) ) else skip )  ;     i := i + 1 ) ; 
 ) ; 
    OclFile["System.out"].println(dp[0+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    int[] dist=new int[k];
    for(int i=0 ; i<k ; i++){
      dist[i]=Integer.MAX_VALUE ;
    }
    dist[1]=0 ;
    Deque<Integer>deque=new ArrayDeque<>();
    deque.addFirst(1);
    int[] visit=new int[k];
    visit[1]=1 ;
    while(deque.size()>0){
      int u=deque.pollFirst();
      int v1=(10*u)% k ;
      int v2=(u+1)% k ;
      if(visit[v1]==0){
        dist[v1]=Math.min(dist[v1],dist[u]);
        deque.addFirst(v1);
        visit[v1]=1 ;
      }
      else {
        if(dist[v1]>dist[u]){
          dist[v1]=dist[u];
          deque.remove(v1);
          deque.addFirst(v1);
        }
      }
      if(visit[v2]==0){
        dist[v2]=Math.min(dist[v2],dist[u]+1);
        deque.addLast(v2);
        visit[v2]=1 ;
      }
    }
    System.out.println(dist[0]+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var dist : Sequence(int) ; dist := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     dist[i+1] := 2147483647 )  ;     i := i + 1 ) ; 
    dist[1+1] := 0 ; 
    var deque : Sequence(int) ; deque := ArrayDeque<OclAny>.newArrayDeque() ;
    deque := deque->prepend(1) ; 
    var visit : Sequence(int) ; visit := Integer.subrange(1,k)->collect(0) ;
    visit[1+1] := 1 ; 
    while (deque->size() > 0) do (     var u : int ; u := deque->first() ;
     var v1 : int ; v1 := (10 * u) mod k ;
    var v2 : int ; v2 := (u + 1) mod k ;
    if (visit[v1+1] = 0) then (     dist[v1+1] := Set{dist[v1+1], dist[u+1]}->min() ; 
     deque := deque->prepend(v1) ; 
     visit[v1+1] := 1 ) else (     if (dist[v1+1] > dist[u+1]) then (     dist[v1+1] := dist[u+1] ; 
     deque := deque->excludingAt(v1+1) ; 
     deque := deque->prepend(v1) ) else skip ) ;  
    if (visit[v2+1] = 0) then (     dist[v2+1] := Set{dist[v2+1], dist[u+1] + 1}->min() ; 
     deque := deque->append(v2) ; 
     visit[v2+1] := 1 ) else skip ; 
 ) ; 
    OclFile["System.out"].println(dist[0+1] + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class tennis {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    int res=0,cnt1=0,cnt2=0 ;
    int n=in.nextInt(),m=in.nextInt(),z=in.nextInt();
    for(int i=m ; i<=z ; i+=m){
      for(int j=n ; j<=z ; j+=n){
        if(i==j)res++;
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class tennis {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
    var res : int ; res := 0 ;
    var cnt1 : int ; cnt1 := 0 ;
    var cnt2 : int ; cnt2 := 0 ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var z : int ; z := in.getCurrent()->toInteger() ;
        var i : int ; i := m ; while i <= z do ( (         var j : int ; j := n ; while j <= z do ( (     if (i = j) then     res := res + 1 ; else skip )  ;     j := j+(n) ) )  ;     i := i+(m) ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    solve();
  }
  public static void solve(){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    Deque<Point>dq=new ArrayDeque<Point>();
    boolean[] judge=new boolean[k];
    Arrays.fill(judge,true);
    Point now=new Point(1,1);
    dq.add(now);
    while(! dq.isEmpty()){
      Point z=dq.removeFirst();
      if(! judge[(z.x)]){
        continue ;
      }
      judge[(z.x)]=false ;
      if(z.x==0){
        System.out.println(z.y);
        break ;
      }
      if(judge[(z.x*10)% k]){
        dq.addFirst(new Point((z.x*10)% k,z.y));
      }
      if(judge[(z.x+1)% k]){
        dq.addLast(new Point((z.x+1)% k,z.y+1));
      }
    }
  }
}
class Point {
  int x ;
  int y ;
  Point(int x,int y){
    this.x=x ;
    this.y=y ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var dq : Sequence(Point) ; dq := ArrayDeque<Point>.newArrayDeque() ;
    var judge : Sequence(boolean) ; judge := Integer.subrange(1,k)->collect(false) ;
    judge := judge->collect(true) ; 
    var now : Point ; now := Point.newPoint(1, 1) ;
    dq := dq->including(now) ; 
    while (not(dq->isEmpty())) do (     var z : Point ; z := dq->first() ;
     if (not(judge[(z.x)+1])) then (     continue ) else skip ; 
    judge[(z.x)+1] := false ; 
    if (z.x = 0) then (     OclFile["System.out"].println(z.y) ; 
     break ) else skip ; 
    if (judge[(z.x * 10) mod k+1]) then (     dq := dq->prepend(Point.newPoint((z.x * 10) mod k, z.y)) ) else skip ; 
    if (judge[(z.x + 1) mod k+1]) then (     dq := dq->append(Point.newPoint((z.x + 1) mod k, z.y + 1)) ) else skip ; 
 ) ; 
 );
}
class Point {
   attribute x : int;
   attribute y : int;
   static operation newPoint( x : int, y : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Deque ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().compute();
  }
  void compute(){
    Scanner sc=new Scanner(System.in);
    int K=sc.nextInt();
    int[] one=new int[K];
    int[] zero=new int[K];
    for(int i=1 ; i<K ; i++){
      one[i]=(i+1)% K ;
      zero[i]=(i*10)% K ;
    }
    Deque<Integer>que=new ArrayDeque<>();
    int[] min=new int[K];
    for(int i=0 ; i<K ; i++){
      min[i]=Integer.MAX_VALUE ;
    }
    que.addLast(1);
    min[1]=1 ;
    while(! que.isEmpty()){
      int cur=que.pollFirst();
      if(min[cur]+1<min[one[cur] ]){
        que.addLast(one[cur]);
        min[one[cur] ]=min[cur]+1 ;
      }
      if(min[cur]<min[zero[cur] ]){
        que.addFirst(zero[cur]);
        min[zero[cur] ]=min[cur];
      }
    }
    System.out.println(min[0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().compute() );
   operation compute() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    var one : Sequence(int) ; one := Integer.subrange(1,K)->collect(0) ;
    var zero : Sequence(int) ; zero := Integer.subrange(1,K)->collect(0) ;
        var i : int ; i := 1 ; while i < K do ( (     one[i+1] := (i + 1) mod K ; 
     zero[i+1] := (i * 10) mod K )  ;     i := i + 1 ) ; 
    var que : Sequence(int) ; que := ArrayDeque<OclAny>.newArrayDeque() ;
    var min : Sequence(int) ; min := Integer.subrange(1,K)->collect(0) ;
        var i : int ; i := 0 ; while i < K do ( (     min[i+1] := 2147483647 )  ;     i := i + 1 ) ; 
    que := que->append(1) ; 
    min[1+1] := 1 ; 
    while (not(que->isEmpty())) do (     var cur : int ; cur := que->first() ;
     if (min[cur+1] + 1 < min[one[cur+1]+1]) then (     que := que->append(one[cur+1]) ; 
     min[one[cur+1]+1] := min[cur+1] + 1 ) else skip ; 
     if (min[cur+1] < min[zero[cur+1]+1]) then (     que := que->prepend(zero[cur+1]) ; 
     min[zero[cur+1]+1] := min[cur+1] ) else skip ) ; 
    OclFile["System.out"].println(min[0+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static void main(String[] args){
    final Scanner stdin=new Scanner(System.in);
    while(stdin.hasNextDouble()){
      final double minV=stdin.nextDouble();
      final double t=minV/9.8 ;
      final double y=4.9*t*t ;
      for(int i=0 ; i<100000 ; i++){
        if(y<=5*i-5){
          System.out.println(i);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (stdin.hasNextDouble()) do (     var minV : double ; minV := stdin.getCurrent()->toReal() ;
     var t : double ; t := minV / 9.8 ;
     var y : double ; y := 4.9 * t * t ;
         var i : int ; i := 0 ; while i < 100000 do ( (     if (y <= 5 * i - 5) then (     OclFile["System.out"].println(i) ; 
     break ) else skip )  ;     i := i + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    double y,t,v ;
    for(; sc.hasNext(); ){
      v=sc.nextDouble();
      t=v/9.8 ;
      y=4.9*t*t ;
      out.println((int)y/5+2);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var y : double ;
    var t : double ;
    var v : double ;
       while sc.hasNext() do ( (     v := sc.nextDouble() ; 
     t := v / 9.8 ; 
     y := 4.9 * t * t ; 
     out.println(y->oclAsType(int) / 5 + 2) )  ) ; 
     sc.close() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.BufferedReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine())!=null){
      double v=Double.parseDouble(line);
      int f=0 ;
      while(true){
        f++;
        double height=5*f-5 ;
        double t=Math.sqrt(height/4.9);
        double vReal=9.8*t ;
        if(vReal>=v)break ;
      }
      System.out.println(f);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     var v : double ; v := (line)->toReal() ;
     var f : int ; f := 0 ;
     while (true) do (     f := f + 1 ; 
     var height : double ; height := 5 * f - 5 ;
    var t : double ; t := (height / 4.9)->sqrt() ;
    var vReal : double ; vReal := 9.8 * t ;
    if (vReal >= v) then     break else skip ; 
 ) ; 
     OclFile["System.out"].println(f) ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static void solve(){
    double v=in.nextDouble();
    double t=v/9.8 ;
    double y=4.9*t*t ;
    for(int i=1 ; ; i++){
      if(y<=5*i-5){
        out.println(i);
        return ;
      }
    }
  }
  public static void main(String[] args){
    long start=System.currentTimeMillis();
    while(in.hasNext())solve();
    out.flush();
    long end=System.currentTimeMillis();
    in.close();
    out.close();
  }
  static void trace(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var v : double ; v := in.getCurrent()->toReal() ;
     var t : double ; t := v / 9.8 ;
     var y : double ; y := 4.9 * t * t ;
         var i : int ; i := 1 ; while true do ( (     if (y <= 5 * i - 5) then (     skip ; 
     return ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : long ; start := OclDate.getSystemTime() ;
     while (in.hasNext()) do     execute solve() ; ; 
    skip ; 
    var end : long ; end := OclDate.getSystemTime() ;
    skip ; 
    skip ; 
 );
  static   operation trace( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class anotherforA18 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int arr[]=new int[6];
    for(int i=0 ; i<6 ; i++)arr[i]=in.nextInt();
    if(isRight(arr)){
      System.out.println("RIGHT");
      return ;
    }
    for(int i=0 ; i<6 ; i++){
      arr[i]++;
      if(isRight(arr)){
        System.out.println("ALMOST");
        return ;
      }
      arr[i]-=2 ;
      if(isRight(arr)){
        System.out.println("ALMOST");
        return ;
      }
      arr[i]++;
    }
    System.out.println("NEITHER");
  }
  public static boolean isRight(int[] arr){
    if(cal(arr))return false ;
    int v[]=new int[6];
    for(int i=0 ; i<6 ; i++)v[i]=arr[(i+2)% 6]-arr[i];
    if(v[0]*v[2]+v[1]*v[3]==0)return true ;
    if(v[2]*v[4]+v[3]*v[5]==0)return true ;
    if(v[0]*v[4]+v[1]*v[5]==0)return true ;
    return false ;
  }
  public static boolean cal(int[] arr){
    int a=arr[2]-arr[0];
    int b=arr[3]-arr[1];
    int c=arr[4]-arr[0];
    int d=arr[5]-arr[1];
    if(b*c-a*d==0)return true ;
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class anotherforA18 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,6)->collect(0) ;
        var i : int ; i := 0 ; while i < 6 do (     arr[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    if (isRight(arr)) then (     OclFile["System.out"].println("RIGHT") ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < 6 do ( (     arr[i+1] := arr[i+1] + 1 ; 
     if (isRight(arr)) then (     OclFile["System.out"].println("ALMOST") ; 
     return ) else skip ; 
    arr[i+1] := arr[i+1]-(2) ; 
    if (isRight(arr)) then (     OclFile["System.out"].println("ALMOST") ; 
     return ) else skip ; 
    arr[i+1] := arr[i+1] + 1 ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NEITHER") ; 
 );
  static   operation isRight( arr : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     if (cal(arr)) then     return false else skip ; 
     var v : Sequence(int) ; v := Integer.subrange(1,6)->collect(0) ;
        var i : int ; i := 0 ; while i < 6 do (     v[i+1] := arr[(i + 2) mod 6+1] - arr[i+1] ;  ;     i := i + 1 ) ; 
    if (v[0+1] * v[2+1] + v[1+1] * v[3+1] = 0) then     return true else skip ; 
    if (v[2+1] * v[4+1] + v[3+1] * v[5+1] = 0) then     return true else skip ; 
    if (v[0+1] * v[4+1] + v[1+1] * v[5+1] = 0) then     return true else skip ; 
    return false 
 );
  static   operation cal( arr : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var a : int ; a := arr[2+1] - arr[0+1] ;
     var b : int ; b := arr[3+1] - arr[1+1] ;
    var c : int ; c := arr[4+1] - arr[0+1] ;
    var d : int ; d := arr[5+1] - arr[1+1] ;
    if (b * c - a * d = 0) then     return true else skip ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
class Main {
  private static final double G=9.8 ;
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String buf ;
    try {
      while((buf=br.readLine())!=null){
        double v=Double.parseDouble(buf);
        double t=v/G ;
        double y=(G/2)*t*t ;
        double N=(y+5)/5 ;
        System.out.println((int)Math.ceil(N));
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute G : double := 9.8;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var buf : String ;
     try (         buf := br.readLine() ;
    while ((buf) /= null) do (    skip ; (     var v : double ; v := (buf)->toReal() ;
     var t : double ; t := v / G ;
    var y : double ; y := (G / 2) * t * t ;
    var N : double ; N := (y + 5) / 5 ;
    OclFile["System.out"].println((N)->ceil()->oclAsType(int)) ; 
 ) ;     buf := br.readLine() ;
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder builder=new StringBuilder();
    String line ;
    while((line=reader.readLine())!=null){
      if(line.isEmpty())break ;
      double a=Double.parseDouble(line);
      double sum=a ;
      for(int i=0 ; i<9 ; i++){
        if(i % 2==0){
          a=a*2 ;
        }
        else {
          a=a/3 ;
        }
        sum+=a ;
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var builder : String ; builder := StringLib.newString() ;
     var line : String ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->isEmpty()) then     break else skip ; 
     var a : double ; a := (line)->toReal() ;
    var sum : double ; sum := a ;
        var i : int ; i := 0 ; while i < 9 do ( (     if (i mod 2 = 0) then (     a := a * 2 ) else (     a := a / 3 ) ;  
     sum := sum+(a) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;     line := reader.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] a){
    Scanner sc=new Scanner(System.in);
    for(; sc.hasNextDouble(); )System.out.println(7.8148148*sc.nextDouble());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while sc.hasNextDouble() do (     OclFile["System.out"].println(7.8148148 * sc.getCurrent()->toReal()) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practise {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int same=0 ;
    Set<Integer>set=new HashSet<>();
    int min=Math.min(a,b);
    for(int i=1 ; i<=c/min ; i++){
      if(a<=b){
        set.add(i*b);
        if(set.contains(i*a))same++;
      }
      else {
        set.add(i*a);
        if(set.contains(i*b))same++;
      }
    }
    System.out.println(same);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practise {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var same : int ; same := 0 ;
    var set : Set(int) ; set := Set{} ;
    var min : int ; min := Set{a, b}->min() ;
        var i : int ; i := 1 ; while i <= c / min do ( (     if (a <= b) then (     set := set->including(i * b) ; 
     if (set->includes(i * a)) then     same := same + 1 ; else skip ) else (     set := set->including(i * a) ; 
     if (set->includes(i * b)) then     same := same + 1 ; else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(same) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
import java.math.BigDecimal ;
class Main {
  public static void main(String args[]){
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(isr);
    String buf ;
    try {
      while((buf=br.readLine())!=null){
        BigDecimal a=new BigDecimal(buf);
        BigDecimal two=new BigDecimal("2.0");
        BigDecimal three=new BigDecimal("3.0");
        BigDecimal sum=new BigDecimal(buf);
        for(int i=2 ; i<=10 ; i++){
          if(i % 2==0)a=two.multiply(a);
          else a=a.divide(three,10,BigDecimal.ROUND_FLOOR);
          sum=sum.add(a);
        }
        System.out.println(sum.toString());
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
     var buf : String ;
     try (         buf := br.readLine() ;
    while ((buf) /= null) do (    skip ; (     var a : double ; a := double(buf) ;
     var two : double ; two := double("2.0") ;
    var three : double ; three := double("3.0") ;
    var sum : double ; sum := double(buf) ;
        var i : int ; i := 2 ; while i <= 10 do ( (     if (i mod 2 = 0) then     a := two.multiply(a) else     a := a.divide(three, 10, ROUND_FLOOR) ; ;  
     sum := sum->excludes(a) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum+"") ; 
 ) ;     buf := br.readLine() ;
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static void solve(){
    double a=in.nextDouble();
    double ans=0 ;
    for(int i=0 ; i<10 ; i++){
      ans+=a ;
      if(i % 2==0)a*=2 ;
      else a/=3 ;
    }
    out.printf("%.8f\n",ans);
  }
  public static void main(String[] args){
    long start=System.currentTimeMillis();
    while(in.hasNext())solve();
    out.flush();
    long end=System.currentTimeMillis();
    in.close();
    out.close();
  }
  static void trace(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var a : double ; a := in.getCurrent()->toReal() ;
     var ans : double ; ans := 0 ;
         var i : int ; i := 0 ; while i < 10 do ( (     ans := ans+(a) ; 
     if (i mod 2 = 0) then     a := a*(2) ; else     a := a/(3) ; )  ;     i := i + 1 ) ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : long ; start := OclDate.getSystemTime() ;
     while (in.hasNext()) do     execute solve() ; ; 
    skip ; 
    var end : long ; end := OclDate.getSystemTime() ;
    skip ; 
    skip ; 
 );
  static   operation trace( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.text.NumberFormat ;
import java.util.Scanner ;
public class Main {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      double n=sc.nextDouble();
      double ans=0 ;
      double a[]=new double[11];
      a[1]=n ;
      for(int i=2 ; i<=10 ; i++){
        if(i % 2==0)a[i]=a[i-1]*2 ;
        else a[i]=a[i-1]/3 ;
      }
      for(int i=1 ; i<=10 ; i++)ans+=a[i];
      NumberFormat d=NumberFormat.getInstance();
      d.setMaximumFractionDigits(8);
      System.out.println(d.format(ans));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : double ; n := sc.getCurrent()->toReal() ;
     var ans : double ; ans := 0 ;
    var a : Sequence(double) ; a := Integer.subrange(1,11)->collect(0.0) ;
    a[1+1] := n ; 
        var i : int ; i := 2 ; while i <= 10 do ( (     if (i mod 2 = 0) then     a[i+1] := a[i - 1+1] * 2 ; else     a[i+1] := a[i - 1+1] / 3 ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 10 do (     ans := ans+(a[i+1]) ;  ;     i := i + 1 ) ; 
    var d : NumberFormat ; d := NumberFormat.getInstance() ;
    d.setMaximumFractionDigits(8) ; 
    OclFile["System.out"].println(d.format(ans)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void IfExists(int arr[],int n){
    int sum[]=new int[n];
    Arrays.sort(arr);
    sum[0]=arr[0];
    for(int i=1 ; i<n ; i++)sum[i]=sum[i-1]+arr[i];
    int max=arr[n-1];
    boolean flag=false ;
    for(int i=1 ; i<=max ; i++){
      int findex=0 ;
      int lindex=0 ;
      int l=0 ;
      int r=n-1 ;
      while(l<=r){
        int m=(l+r)/2 ;
        if(arr[m]<i){
          findex=m ;
          l=m+1 ;
        }
        else r=m-1 ;
      }
      l=1 ;
      r=n ;
      flag=false ;
      while(l<=r){
        int m=(r+l)/2 ;
        if(arr[m]>i){
          lindex=m ;
          r=m-1 ;
        }
        else l=m+1 ;
      }
      if(sum[findex]==sum[n-1]-sum[lindex-1]){
        flag=true ;
        break ;
      }
    }
    if(flag)System.out.println("Yes");
    else System.out.println("No");
  }
  public static void main(String args[]){
    int arr[]={
      1,2,2,5 };
      int n=arr.length ;
      IfExists(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation IfExists( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var sum : Sequence(int) ; sum := Integer.subrange(1,n)->collect(0) ;
     arr := arr->sort() ; 
    sum[0+1] := arr[0+1] ; 
        var i : int ; i := 1 ; while i < n do (     sum[i+1] := sum[i - 1+1] + arr[i+1] ;  ;     i := i + 1 ) ; 
    var max : int ; max := arr[n - 1+1] ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 1 ; while i <= max do ( (     var findex : int ; findex := 0 ;
     var lindex : int ; lindex := 0 ;
    var l : int ; l := 0 ;
    var r : int ; r := n - 1 ;
    while (l <= r) do (     var m : int ; m := (l + r) / 2 ;
     if (arr[m+1] < i) then (     findex := m ; 
     l := m + 1 ) else     r := m - 1 ; ) ; 
    l := 1 ; 
    r := n ; 
    flag := false ; 
    while (l <= r) do (     var m : int ; m := (r + l) / 2 ;
     if (arr[m+1] > i) then (     lindex := m ; 
     r := m - 1 ) else     l := m + 1 ; ) ; 
    if (sum[findex+1] = sum[n - 1+1] - sum[lindex - 1+1]) then (     flag := true ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (flag) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,2,5} ;
     var n : int ; n := arr->size() ;
     execute IfExists(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.*;
import java.io.*;
public class a171 {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s=br.readLine();
    int x=Integer.parseInt(s.split(" ")[0]);
    int y=Integer.parseInt(s.split(" ")[1]);
    int curx=0 ;
    int cury=0 ;
    int ctr=0 ;
    int turns=0 ;
    int valx=1 ;
    int valy=1 ;
    int tc=0 ;
    while(true){
      if(curx==x && cury==y){
        break ;
      }
      tc++;
      if(tc % 2==0){
        tc=1 ;
        turns++;
      }
      if(ctr % 2==0){
        int prevx=curx ;
        if((ctr/2)% 2==0){
          curx+=valx ;
          if(cury==y && x>prevx && x<curx){
            break ;
          }
        }
        else {
          curx-=valx ;
          if(cury==y && x>curx && x<prevx){
            break ;
          }
        }
        valx+=1 ;
      }
      else {
        int prevy=cury ;
        if((ctr/2)% 2==0){
          cury+=valy ;
          if(curx==x && y>prevy && y<cury){
            break ;
          }
        }
        else {
          cury-=valy ;
          if(curx==x && y>cury && y<prevy){
            break ;
          }
        }
        valy+=1 ;
      }
      ctr++;
    }
    System.out.println(turns);
  }
}
------------------------------------------------------------
OCL File:
---------
 class a171 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := br.readLine() ;
    var x : int ; x := (s->split(" ")[0+1])->toInteger() ;
    var y : int ; y := (s->split(" ")[1+1])->toInteger() ;
    var curx : int ; curx := 0 ;
    var cury : int ; cury := 0 ;
    var ctr : int ; ctr := 0 ;
    var turns : int ; turns := 0 ;
    var valx : int ; valx := 1 ;
    var valy : int ; valy := 1 ;
    var tc : int ; tc := 0 ;
    while (true) do (     if (curx = x & cury = y) then (     break ) else skip ; 
     tc := tc + 1 ; 
    if (tc mod 2 = 0) then (     tc := 1 ; 
     turns := turns + 1 ) else skip ; 
    if (ctr mod 2 = 0) then (     var prevx : int ; prevx := curx ;
     if ((ctr / 2) mod 2 = 0) then (     curx := curx+(valx) ; 
     if (cury = y & x > prevx & x < curx) then (     break ) else skip ) else (     curx := curx-(valx) ; 
     if (cury = y & x > curx & x < prevx) then (     break ) else skip ) ;  
     valx := valx+(1) ) else (     var prevy : int ; prevy := cury ;
     if ((ctr / 2) mod 2 = 0) then (     cury := cury+(valy) ; 
     if (curx = x & y > prevy & y < cury) then (     break ) else skip ) else (     cury := cury-(valy) ; 
     if (curx = x & y > cury & y < prevy) then (     break ) else skip ) ;  
     valy := valy+(1) ) ;  
    ctr := ctr + 1 ; 
 ) ; 
    OclFile["System.out"].println(turns) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Map ;
import java.util.HashMap ;
public class A_Point_on_Spiral {
  static Scanner in=new Scanner(System.in);
  static int x,y ;
  static Map<Integer,Integer>map=new HashMap<>();
  public static void main(String[] amit){
    x=in.nextInt();
    y=in.nextInt();
    if(x==0 && y==0){
      System.out.println(0);
    }
    else if(-x+1<y && x>=y){
      System.out.println((1+(x-1)*4));
    }
    else if(-y<=x && x<y){
      System.out.println((2+(y-1)*4));
    }
    else if(x<=y && y<-x){
      System.out.println((3+(-x-1)*4));
    }
    else {
      System.out.println((4+(-y-1)*4));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Point_on_Spiral {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute x : int;
  static   attribute map : Map(int,int) := Map{};
  static   operation main( amit : Sequence(String)) : void
  pre: true
  post: true
  activity: (     x := in.getCurrent()->toInteger() ; 
     y := in.getCurrent()->toInteger() ; 
     if (x = 0 & y = 0) then (     OclFile["System.out"].println(0) ) else     if (-x + 1 < y & x >= y) then (     OclFile["System.out"].println((1 + (x - 1) * 4)) ) else     if (-y <= x & x < y) then (     OclFile["System.out"].println((2 + (y - 1) * 4)) ) else     if (x <= y & y < -x) then (     OclFile["System.out"].println((3 + (-x - 1) * 4)) ) else (     OclFile["System.out"].println((4 + (-y - 1) * 4)) ) ;  ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A279 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int X=in.nextInt();
    int Y=in.nextInt();
    int[][] diff=new int[][] {
      {
        1,0 },{
          0,1 },{
-1,0 },{
              0,-1 }
            };
            int x=0 ;
            int y=0 ;
            int length=1 ;
            int turns=0 ;
            while(true){
              int direction=turns % 4 ;
              int nextx=x+length*diff[direction][0];
              int nexty=y+length*diff[direction][1];
              if(Math.min(x,nextx)<=X && X<=Math.max(x,nextx)&& Math.min(y,nexty)<=Y && Y<=Math.max(y,nexty)){
                break ;
              }
              turns++;
              if(turns % 2==0){
                length++;
              }
              x=nextx ;
              y=nexty ;
            }
            System.out.println(turns);
          }
        }

------------------------------------------------------------
OCL File:
---------
 class A279 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : int ; X := in.getCurrent()->toInteger() ;
    var Y : int ; Y := in.getCurrent()->toInteger() ;
    var diff : Sequence(Sequence(int)) ; diff := Sequence{Sequence{1,0},Sequence{0,1},Sequence{-1,0},Sequence{0,-1}} ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var length : int ; length := 1 ;
    var turns : int ; turns := 0 ;
    while (true) do (     var direction : int ; direction := turns mod 4 ;
     var nextx : int ; nextx := x + length * diff[direction+1][0+1] ;
    var nexty : int ; nexty := y + length * diff[direction+1][1+1] ;
    if (Set{x, nextx}->min() <= X & X <= Set{x, nextx}->max() & Set{y, nexty}->min() <= Y & Y <= Set{y, nexty}->max()) then (     break ) else skip ; 
    turns := turns + 1 ; 
    if (turns mod 2 = 0) then (     length := length + 1 ) else skip ; 
    x := nextx ; 
    y := nexty ; 
 ) ; 
    OclFile["System.out"].println(turns) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A18 {
  static boolean right(int arr[]){
    double x[]=new double[3];
    x[0]=Math.pow(arr[0]-arr[2],2)+Math.pow(arr[1]-arr[3],2);
    x[1]=Math.pow(arr[0]-arr[4],2)+Math.pow(arr[1]-arr[5],2);
    x[2]=Math.pow(arr[4]-arr[2],2)+Math.pow(arr[5]-arr[3],2);
    Arrays.sort(x);
    if(x[0]+x[1]==x[2] && x[1]!=0 && x[0]!=0 && x[2]!=0)return true ;
    return false ;
  }
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    PrintWriter pw=new PrintWriter(System.out);
    int arr[]=new int[6];
    for(int i=0 ; i<6 ; i++){
      arr[i]=sc.nextInt();
    }
    if(right(arr))pw.println("RIGHT");
    else {
      for(int i=0 ; i<6 ; i++){
        arr[i]++;
        if(right(arr)){
          pw.println("ALMOST");
          break ;
        }
        arr[i]-=2 ;
        if(right(arr)){
          pw.println("ALMOST");
          break ;
        }
        arr[i]++;
        if(i==5)pw.println("NEITHER");
      }
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A18 {
  static   operation right( arr : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var x : Sequence(double) ; x := Integer.subrange(1,3)->collect(0.0) ;
     x[0+1] := arr[0+1] - arr[2+1]->pow(2) + arr[1+1] - arr[3+1]->pow(2) ; 
    x[1+1] := arr[0+1] - arr[4+1]->pow(2) + arr[1+1] - arr[5+1]->pow(2) ; 
    x[2+1] := arr[4+1] - arr[2+1]->pow(2) + arr[5+1] - arr[3+1]->pow(2) ; 
    x := x->sort() ; 
    if (x[0+1] + x[1+1] = x[2+1] & x[1+1] /= 0 & x[0+1] /= 0 & x[2+1] /= 0) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,6)->collect(0) ;
        var i : int ; i := 0 ; while i < 6 do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (right(arr)) then     skip else (         var i : int ; i := 0 ; while i < 6 do ( (     arr[i+1] := arr[i+1] + 1 ; 
     if (right(arr)) then (     skip ; 
     break ) else skip ; 
    arr[i+1] := arr[i+1]-(2) ; 
    if (right(arr)) then (     skip ; 
     break ) else skip ; 
    arr[i+1] := arr[i+1] + 1 ; 
    if (i = 5) then     skip ; else skip ; 
 )  ;     i := i + 1 ) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    if(x>0 && y>=0){
      if(y==0 && x==1)System.out.println((x-1)*4);
      else if(x>=y)System.out.println((x-1)*4+1);
      else {
        System.out.println((y-1)*4+2);
      }
    }
    else if(x>0 && y<0){
      if(x>y*-1){
        if(y*-1==x-1)System.out.println((x-1)*4);
        else System.out.println((x-1)*4+1);
      }
      else {
        System.out.println((y*-1)*4);
        ;
      }
    }
    else if(x<=0 && y>0){
      if(x==0 || x*-1<y)System.out.println((y-1)*4+2);
      else {
        if(y<x*-1)System.out.println((x*-1-1)*4+3);
        else System.out.println((x*-1-1)*4+2);
      }
    }
    else if(x<=0 && y<0){
      if(x==0)System.out.println((y*-1)*4);
      else {
        if(y*-1>x*-1){
          System.out.println((y*-1)*4);
        }
        else System.out.println((x*-1-1)*4+3);
      }
    }
    else if(x<0 && y==0){
      System.out.println((x*-1)*4-1);
    }
    else {
      System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     if (x > 0 & y >= 0) then (     if (y = 0 & x = 1) then     OclFile["System.out"].println((x - 1) * 4) ; else     if (x >= y) then     OclFile["System.out"].println((x - 1) * 4 + 1) else (     OclFile["System.out"].println((y - 1) * 4 + 2) ) ;  ) else     if (x > 0 & y < 0) then (     if (x > y * -1) then (     if (y * -1 = x - 1) then     OclFile["System.out"].println((x - 1) * 4) ; else     OclFile["System.out"].println((x - 1) * 4 + 1) ; ) else (     OclFile["System.out"].println((y * -1) * 4) ; 
  ) ) else     if (x <= 0 & y > 0) then (     if (x = 0 or x * -1 < y) then     OclFile["System.out"].println((y - 1) * 4 + 2) ; else (     if (y < x * -1) then     OclFile["System.out"].println((x * -1 - 1) * 4 + 3) ; else     OclFile["System.out"].println((x * -1 - 1) * 4 + 2) ; ) ) else     if (x <= 0 & y < 0) then (     if (x = 0) then     OclFile["System.out"].println((y * -1) * 4) ; else (     if (y * -1 > x * -1) then (     OclFile["System.out"].println((y * -1) * 4) ) else     OclFile["System.out"].println((x * -1 - 1) * 4 + 3) ; ) ) else     if (x < 0 & y = 0) then (     OclFile["System.out"].println((x * -1) * 4 - 1) ) else (     OclFile["System.out"].println(0) ) ;  ;  ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class CalcAvg {
  static double avgRec(int a[],int i,int n){
    if(i==n-1)return a[i];
    if(i==0)return((a[i]+avgRec(a,i+1,n))/n);
    return(a[i]+avgRec(a,i+1,n));
  }
  static double average(int a[],int n){
    return avgRec(a,0,n);
  }
  public static void main(String[] args){
    int arr[]={
      10,2,3,4,5,6,7,8,9 };
      int n=arr.length ;
      System.out.println(average(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class CalcAvg {
  static   operation avgRec( a : Sequence(int), i : int, n : int) : double
  pre: true
  post: true
  activity: (     if (i = n - 1) then     return a[i+1] else skip ; 
     if (i = 0) then     return ((a[i+1] + avgRec(a, i + 1, n)) / n) else skip ; 
     return (a[i+1] + avgRec(a, i + 1, n)) );
  static   operation average( a : Sequence(int), n : int) : double
  pre: true
  post: true
  activity: (     return avgRec(a, 0, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,2,3,4,5,6,7,8,9} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(average(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class TaymyrIsCallingYou {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    int m=Integer.parseInt(st.nextToken());
    int z=Integer.parseInt(st.nextToken());
    boolean busy[]=new boolean[z+1];
    for(int i=n ; i<=z ; i+=n){
      busy[i]=true ;
    }
    int count=0 ;
    for(int i=m ; i<=z ; i+=m){
      if(busy[i])count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class TaymyrIsCallingYou {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var z : int ; z := (st.next())->toInteger() ;
    var busy : Sequence(boolean) ; busy := Integer.subrange(1,z + 1)->collect(false) ;
        var i : int ; i := n ; while i <= z do ( (     busy[i+1] := true )  ;     i := i+(n) ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := m ; while i <= z do ( (     if (busy[i+1]) then     count := count + 1 ; else skip )  ;     i := i+(m) ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxN=20 ;
  static int maxM=64 ;
  static int cntSplits(String s){
    if(s.charAt(s.length()-1)=='1')return 0 ;
    int c_zero=0 ;
    for(int i=0 ; i<s.length(); i++)c_zero+=(s.charAt(i)=='0')? 1 : 0 ;
    return(int)Math.pow(2,c_zero-1);
  }
  public static void main(String[] args){
    String s="10010" ;
    System.out.println(cntSplits(s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute maxN : int := 20;
  static   attribute maxM : int := 64;
  static   operation cntSplits( s : String) : int
  pre: true
  post: true
  activity: (     if (s->at(s->size() - 1+1) = '1') then     return 0 else skip ; 
     var c_zero : int ; c_zero := 0 ;
         var i : int ; i := 0 ; while i < s->size() do (     c_zero := c_zero+(if (s->at(i+1) = '0') then 1 else 0 endif) ;  ;     i := i + 1 ) ; 
     return 2->pow(c_zero - 1)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "10010" ;
     OclFile["System.out"].println(cntSplits(s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int a=sc.nextInt();
    if(x<a)System.out.println("0");
    else System.out.println("10");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (x < a) then     OclFile["System.out"].println("0") ; else     OclFile["System.out"].println("10") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.nio.CharBuffer ;
import java.util.NoSuchElementException ;
public class Main {
  public static void main(String[] args){
    SimpleScanner scanner=new SimpleScanner(System.in);
    PrintWriter writer=new PrintWriter(System.out);
    int x=scanner.nextInt();
    int a=scanner.nextInt();
    writer.println(x<a ? 0 : 10);
    writer.close();
  }
  private static class SimpleScanner {
    private static final int BUFFER_SIZE=10240 ;
    private Readable in ;
    private CharBuffer buffer ;
    private boolean eof ;
    SimpleScanner(InputStream in){
      this.in=new BufferedReader(new InputStreamReader(in));
      buffer=CharBuffer.allocate(BUFFER_SIZE);
      buffer.limit(0);
      eof=false ;
    }
    private char read(){
      if(! buffer.hasRemaining()){
        buffer.clear();
        int n ;
        try {
          n=in.read(buffer);
        }
        catch(IOException e){
          n=-1 ;
        }
        if(n<=0){
          eof=true ;
          return '\0' ;
        }
        buffer.flip();
      }
      return buffer.get();
    }
    void checkEof(){
      if(eof)throw new NoSuchElementException();
    }
    char nextChar(){
      checkEof();
      char b=read();
      checkEof();
      return b ;
    }
    String next(){
      char b ;
      do {
        b=read();
        checkEof();
      }
      while(Character.isWhitespace(b));
      StringBuilder sb=new StringBuilder();
      do {
        sb.append(b);
        b=read();
      }
      while(! eof && ! Character.isWhitespace(b));
      return sb.toString();
    }
    int nextInt(){
      return Integer.valueOf(next());
    }
    long nextLong(){
      return Long.valueOf(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : SimpleScanner ; scanner := SimpleScanner.newSimpleScanner(OclFile["System.in"]) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var x : int ; x := scanner.nextInt() ;
    var a : int ; a := scanner.nextInt() ;
    skip ; 
    skip ; 
 );
  static class SimpleScanner {
  static    attribute BUFFER_SIZE : int := 10240;
   attribute in : Readable;
   attribute buffer : Sequence(int);
   attribute eof : boolean;
   static operation newSimpleScanner( in : OclFile) : SimpleScanner
  pre: true
  post: true
  activity:
  ( var self : SimpleScanner ;
    self := createSimpleScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     self.in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     buffer := CharBuffer.allocate(BUFFER_SIZE) ; 
     buffer := buffer.limit(0) ; 
     eof := false );
   operation read() : String
  pre: true
  post: true
  activity: (     if (not(buffer.hasRemaining())) then (     buffer := buffer->intersection(Set{}) ; 
     var n : int ;
    try (     n := in.read(buffer) )   catch (e : IOException) do (     n := -1 )
    if (n <= 0) then (     eof := true ; 
     return '\0' ) else skip ; 
    buffer := buffer.flip() ; 
 ) else skip ; 
     return buffer.get() );
   operation checkEof() : void
  pre: true
  post: true
  activity: (     if (eof) then     error IncorrectElementException() ; else skip );
   operation nextChar() : String
  pre: true
  post: true
  activity: (     execute checkEof() ; 
     var b : String ; b := read() ;
     execute checkEof() ; 
     return b );
   operation next() : String
  pre: true
  post: true
  activity: (     var b : String ;
   while true do ((     b := read() ; 
     execute checkEof() ) ;
    if ((b->isMatch("[\\t\\n ]")) then skip else break) ; 
    var sb : String ; sb := StringLib.newString() ;
  while true do ((     sb := sb + StringLib.newString(b) ; 
     b := read() ) ;
    if (not(eof) & not((b->isMatch("[\\t\\n ]"))) then skip else break) ; 
    return sb+"" 
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ARounding solver=new ARounding();
    solver.solve(1,in,out);
    out.close();
  }
  static class ARounding {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int x=in.nextInt(),a=in.nextInt();
      out.println(x<a ? 0 : 10);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ARounding ; solver := ARounding.newARounding() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ARounding {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var x : int ; x := in.nextInt() ;
    var a : int ; a := in.nextInt() ;
     skip );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String in=br.readLine();
      String chr[]=in.split(" ");
      int x=Integer.parseInt(chr[0]);
      int a=Integer.parseInt(chr[1]);
      System.out.println(x<a ? 0 : 10);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var in : String ; in := br.readLine() ;
     var chr : Sequence(String) ; chr := in->split(" ") ;
    var x : int ; x := (chr[0+1])->toInteger() ;
    var a : int ; a := (chr[1+1])->toInteger() ;
    OclFile["System.out"].println(if x < a then 0 else 10 endif) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static List<List<Integer>>switchList ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int X=sc.nextInt();
    int A=sc.nextInt();
    sc.close();
    if(X>=A){
      System.out.println(10);
    }
    else {
      System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute switchList : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : int ; X := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    skip ; 
    if (X >= A) then (     OclFile["System.out"].println(10) ) else (     OclFile["System.out"].println(0) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    System.out.println((n % 500<=k)? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if (n mod 500 <= k) then "Yes" else "No" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  private static final int MOD=(int)Math.pow(10,9);
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    int coin=sc.nextInt();
    int m=(n % 500);
    if(coin>=m){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 10->pow(9)->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : int ; n := sc.nextInt() ;
    var coin : int ; coin := sc.nextInt() ;
    var m : int ; m := (n mod 500) ;
    if (coin >= m) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countDigits(int n){
    double ans=0 ;
    for(int i=1 ; i<=n ; i++)ans+=Math.log10(i);
    ans=ans*n ;
    return 1+(int)Math.floor(ans);
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(countDigits(n)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDigits( n : int) : int
  pre: true
  post: true
  activity: (     var ans : double ; ans := 0 ;
         var i : int ; i := 1 ; while i <= n do (     ans := ans+((i)->log10()) ;  ;     i := i + 1 ) ; 
     ans := ans * n ; 
     return 1 + (ans)->floor()->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(countDigits(n) + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    AInfiniteCoins solver=new AInfiniteCoins();
    solver.solve(1,in,out);
    out.close();
  }
  static class AInfiniteCoins {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int a=in.nextInt();
      int b=n/500 ;
      out.print(a>=n-b*500 ? "Yes" : "No");
    }
  }
  static class InputReader implements AutoCloseable {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public void close(){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : AInfiniteCoins ; solver := AInfiniteCoins.newAInfiniteCoins() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class AInfiniteCoins {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var a : int ; a := in.nextInt() ;
     var b : int ; b := n / 500 ;
     skip );
}
  static class InputReader implements AutoCloseable {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation close() : void
  pre: true
  post: true
  activity: skip;
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class TaymyrIsCallingYou {
  public static void main(String[] args)throws IOException {
    Reader in=new Reader();
    PrintWriter out=new PrintWriter(System.out);
    int A=in.nextInt(),B=in.nextInt(),K=in.nextInt();
    out.println(K/(lcm(A,B)));
    out.close();
  }
  public static int lcm(int a,int b){
    return a/gcd(a,b)*b ;
  }
  public static int gcd(int a,int b){
    return a==0 ? b : gcd(b % a,a);
  }
  static class Reader {
    BufferedReader in ;
    StringTokenizer st ;
    public Reader(){
      in=new BufferedReader(new InputStreamReader(System.in));
      st=new StringTokenizer("");
    }
    public String nextLine()throws IOException {
      st=new StringTokenizer("");
      return in.readLine();
    }
    public String next()throws IOException {
      while(! st.hasMoreTokens()){
        st=new StringTokenizer(in.readLine());
      }
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
  public static void sort(int[] arr){
    List<Integer>list=new ArrayList<>();
    for(int i : arr){
      list.add(i);
    }
    Collections.sort(list);
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=list.get(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TaymyrIsCallingYou {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var A : int ; A := in.getCurrent()->toInteger() ;
    var B : int ; B := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    skip ; 
    skip ; 
 );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return a / gcd(a, b) * b );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if a = 0 then b else gcd(b mod a, a) endif );
  static class Reader {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newReader() : Reader
  pre: true
  post: true
  activity:
  ( var self : Reader ;
    self := createReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := OclIterator.newOclIterator_String("") );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     st := OclIterator.newOclIterator_String("") ; 
     return in.readLine() );
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   operation sort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     for (i : arr) do ( (     list := list->including(i) )  ) ; 
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := list->at(i+1) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    Solver solver=new Solver();
    solver.init();
    solver.readHead(in.readLine());
    for(; solver.hasNext(); ){
      solver.readBody(in.readLine());
    }
    solver.solve();
  }
}
class Solver {
  int N ;
  int cnt ;
  public void init(){
    N=0 ;
    cnt=0 ;
  }
  public void readHead(String str){
    String[] strArr=str.split(" ");
    N=Integer.parseInt(strArr[0]);
  }
  public boolean hasNext(){
    return cnt<1 ;
  }
  int A ;
  public void readBody(String str){
    A=Integer.parseInt(str);
    cnt++;
  }
  public void solve(){
    if((N % 500)<=A)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var solver : Solver ; solver := Solver.newSolver() ;
    solver.init() ; 
    solver.readHead(in.readLine()) ; 
      while solver.hasNext() do ( (     solver.readBody(in.readLine()) )  ) ; 
    solver.solve() ; 
 );
}
class Solver {
   attribute N : int;
   attribute cnt : int;
   operation init() : void
  pre: true
  post: true
  activity: (     N := 0 ; 
     cnt := 0 );
   operation readHead( str : String) : void
  pre: true
  post: true
  activity: (     var strArr : Sequence(String) ; strArr := str->split(" ") ;
     N := (strArr[0+1])->toInteger() );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return cnt < 1 );
   attribute A : int;
   operation readBody( str : String) : void
  pre: true
  post: true
  activity: (     A := (str)->toInteger() ; 
     cnt := cnt + 1 );
   operation solve() : void
  pre: true
  post: true
  activity: (     if ((N mod 500) <= A) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int n=gi();
    int a=gi();
    if((n % 500)<=a){
      System.out.print("Yes");
    }
    else {
      System.out.print("No");
    }
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := gi() ;
     var a : int ; a := gi() ;
     if ((n mod 500) <= a) then (     OclFile["System.out"].print("Yes") ) else (     OclFile["System.out"].print("No") ) );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] a=sc.next().toCharArray();
    char[] b=sc.next().toCharArray();
    String ans="" ;
    for(int i=0 ; i<n ; i++){
      ans+=a[i];
      ans+=b[i];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(String) ; a := sc.getCurrent()->characters() ;
    var b : Sequence(String) ; b := sc.getCurrent()->characters() ;
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans+(a[i+1]) ; 
     ans := ans+(b[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BStringsWithTheSameLength solver=new BStringsWithTheSameLength();
    solver.solve(1,in,out);
    out.close();
  }
  static class BStringsWithTheSameLength {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      char[] s=in.next().toCharArray();
      char[] t=in.next().toCharArray();
      StringBuilder sb=new StringBuilder();
      for(int i=0 ; i<n ; i++){
        sb.append(s[i]).append(t[i]);
      }
      out.println(sb);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BStringsWithTheSameLength ; solver := BStringsWithTheSameLength.newBStringsWithTheSameLength() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BStringsWithTheSameLength {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var s : Sequence(String) ; s := in.next()->characters() ;
    var t : Sequence(String) ; t := in.next()->characters() ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     sb := sb + StringLib.newString(s[i+1]) + StringLib.newString(t[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.Collection ;
import java.util.Collections ;
import java.util.List ;
public class Main {
  public static Scanner scan=new Scanner(System.in);
  public static void main(String[] args){
    int n ;
    String s,t ;
    n=nextInt();
    s=next();
    t=next();
    char[] arr=new char[2*n];
    for(int i=0 ; i<n ; i++){
      arr[2*i]=s.charAt(i);
      arr[2*i+1]=t.charAt(i);
    }
    for(char a : arr){
      System.out.printf("%c",a);
    }
  }
  public static int nextInt(){
    return Integer.parseInt(scan.next());
  }
  public static long nextLong(){
    return Long.parseLong(scan.next());
  }
  public static String next(){
    return scan.next();
  }
  public static double nextDouble(){
    return Double.parseDouble(scan.next());
  }
  public static float nextFloat(){
    return Float.parseFloat(scan.next());
  }
  public static void yesNo(boolean flag){
    if(flag)System.out.println("Yes");
    else System.out.println("No");
  }
  public static void print(Object a){
    System.out.println(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     var s : String ;
    var t : String ;
    n := nextInt() ; 
    s := next() ; 
    t := next() ; 
    var arr : Sequence(String) ; arr := Integer.subrange(1,2 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[2 * i+1] := s->at(i+1) ; 
     arr[2 * i + 1+1] := t->at(i+1) )  ;     i := i + 1 ) ; 
    for (a : arr) do ( (     OclFile["System.out"].printf("%c", a) )  ) ; 
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (scan.getCurrent())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (scan.getCurrent())->toLong() );
  static   operation next() : String
  pre: true
  post: true
  activity: (     return scan.getCurrent() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (scan.getCurrent())->toReal() );
  static   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(scan.getCurrent()) );
  static   operation yesNo( flag : boolean) : void
  pre: true
  post: true
  activity: (     if (flag) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
  static   operation print( a : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public static void main(String args[]){
    java.util.Scanner sc=new java.util.Scanner(System.in);
    int N=sc.nextInt();
    String S[]=sc.next().split("");
    String T[]=sc.next().split("");
    for(int i=0 ; i<N ; i++){
      System.out.print(S[i]+T[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(OclFile["System.in"]) ;
     var N : int ; N := sc.nextInt() ;
    var S : Sequence(String) ; S := sc.next()->split("") ;
    var T : Sequence(String) ; T := sc.next()->split("") ;
        var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].print(S[i+1] + T[i+1]) )  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  InputStream in=System.in ;
  PrintStream out=System.out ;
  public void _main(String[] args){
    Scanner sc=new Scanner(in);
    int N=sc.nextInt();
    String S=sc.next();
    String T=sc.next();
    sc.close();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<N ; i++){
      sb.append(S.charAt(i));
      sb.append(T.charAt(i));
    }
    out.println(sb.toString());
  }
  public static void main(String[] args){
    new Main()._main(args);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile["System.in"];
   attribute out : OclFile := OclFile["System.out"];
   operation _main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var S : String ; S := sc.getCurrent() ;
    var T : String ; T := sc.getCurrent() ;
    skip ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < N do ( (     sb := sb + StringLib.newString(S->at(i+1)) ; 
     sb := sb + StringLib.newString(T->at(i+1)) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain()._main(args) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  static Scanner scanner=new Scanner();
  public static void main(String[] $){
    int n=scanner.nextInt();
    long ans=0 ;
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scanner.nextInt()-1 ;
    }
    for(int i=0 ; i<n ; i++){
      ans+=scanner.nextInt();
    }
    int[] c=new int[n];
    for(int i=1 ; i<n ; i++){
      c[i-1]=scanner.nextInt();
    }
    for(int i=1 ; i<n ; i++){
      if(a[i-1]+1==a[i]){
        ans+=c[a[i-1] ];
      }
    }
    System.out.println(ans);
  }
  static class Scanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),1<<15);
    StringTokenizer tokenizer ;
    String next(){
      try {
        while(tokenizer==null || ! tokenizer.hasMoreTokens()){
          tokenizer=new StringTokenizer(reader.readLine());
        }
      }
      catch(IOException ignored){
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := (arguments ( ));
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var ans : long ; ans := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() - 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     ans := ans+(scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 1 ; while i < n do ( (     c[i - 1+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (a[i - 1+1] + 1 = a[i+1]) then (     ans := ans+(c[a[i - 1+1]+1]) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class Scanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (1*(2->pow(15)))->oclAsType(long));
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (ignored : IOException) do skip
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BBuffet solver=new BBuffet();
    solver.solve(1,in,out);
    out.close();
  }
  static class BBuffet {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int[] a=in.readIntArray(n);
      int[] b=in.readIntArray(n);
      int[] c=in.readIntArray(n-1);
      for(int i=0 ; i<n ; i++){
        a[i]--;
      }
      int answer=0 ;
      for(int i=0 ; i<n ; i++){
        answer+=b[a[i] ];
        if(i-1>=0 && a[i-1]==a[i]-1){
          answer+=c[a[i-1] ];
        }
      }
      out.println(answer);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public int[] readIntArray(int n){
      int[] x=new int[n];
      for(int i=0 ; i<n ; i++){
        x[i]=nextInt();
      }
      return x ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BBuffet ; solver := BBuffet.newBBuffet() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BBuffet {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var a : Sequence(int) ; a := in.readIntArray(n) ;
    var b : Sequence(int) ; b := in.readIntArray(n) ;
    var c : Sequence(int) ; c := in.readIntArray(n - 1) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := a[i+1] - 1 )  ;     i := i + 1 ) ; 
    var answer : int ; answer := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     answer := answer+(b[a[i+1]+1]) ; 
     if (i - 1 >= 0 & a[i - 1+1] = a[i+1] - 1) then (     answer := answer+(c[a[i - 1+1]+1]) ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     x[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return x );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class mpal {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t,j,i ;
    long n,k,p,d ;
    t=sc.nextInt();
    for(j=1 ; j<=t ; j++){
      n=sc.nextLong();
      k=sc.nextLong();
      if(n % 2==0)System.out.println((k % n)!=0 ?(k % n): n);
      else {
        d=n/2 ;
        p=(k-1)/d ;
        k+=p ;
        System.out.println((k % n)!=0 ?(k % n): n);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class mpal {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ;
    var j : int ;
    var i : int ;
    var n : long ;
    var k : long ;
    var p : long ;
    var d : long ;
    t := sc.getCurrent()->toInteger() ; 
        j := 1 ; while j <= t do ( (     n := sc.getCurrent()->toLong() ; 
     k := sc.getCurrent()->toLong() ; 
     if (n mod 2 = 0) then     OclFile["System.out"].println(if (k mod n) /= 0 then (k mod n) else n endif) ; else (     d := n / 2 ; 
     p := (k - 1) / d ; 
     k := k+(p) ; 
     OclFile["System.out"].println(if (k mod n) /= 0 then (k mod n) else n endif) ) )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long x=in.nextLong(),y=in.nextLong();
    printBin(fillZero(Long.toBinaryString(x & y)));
    printBin(fillZero(Long.toBinaryString(x | y)));
    printBin(fillZero(Long.toBinaryString(x ^ y)));
  }
  static void printBin(String str){
    for(int i=str.length()-32 ; i<str.length(); i++)System.out.print(str.charAt(i));
    System.out.println();
  }
  static String fillZero(String str){
    String zero="" ;
    if(str.length()<32){
      for(int i=0 ; i<32-str.length(); i++)zero+="0" ;
    }
    return zero.concat(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := in.getCurrent()->toLong() ;
    var y : long ; y := in.getCurrent()->toLong() ;
    execute printBin(fillZero((MathLib.decimal2binary(MathLib.bitwiseAnd(x,y)) + ""))) ; 
    execute printBin(fillZero((MathLib.decimal2binary(MathLib.bitwiseOr(x,y)) + ""))) ; 
    execute printBin(fillZero((MathLib.decimal2binary(MathLib.bitwiseXor(x,y)) + ""))) ; 
 );
  static   operation printBin( str : String) : void
  pre: true
  post: true
  activity: (         var i : int ; i := str->size() - 32 ; while i < str->size() do (     OclFile["System.out"].print(str->at(i+1)) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation fillZero( str : String) : String
  pre: true
  post: true
  activity: (     var zero : String ; zero := "" ;
     if (str->size() < 32) then (         var i : int ; i := 0 ; while i < 32 - str->size() do (     zero := zero+("0") ;  ;     i := i + 1 ) ) else skip ; 
     return zero+str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  private static class Line {
    public long a ;
    public long b ;
    public char op ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    List<Line>list=new LinkedList<Line>();
    while(sc.hasNext()){
      Line line=new Line();
      line.a=sc.nextLong();
      line.op=sc.next().charAt(0);
      line.b=sc.nextLong();
      list.add(line);
    }
    for(Line line : list){
      switch(line.op){
        case '+' : System.out.println(line.a+line.b);
        break ;
        case '-' : System.out.println(line.a-line.b);
        break ;
        case '*' : System.out.println(line.a*line.b);
        break ;
        case '/' : System.out.println(line.a/line.b);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Line {
   attribute a : long;
   attribute b : long;
   attribute op : String;
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(Line) ; list := Sequence{} ;
     while (sc.hasNext()) do (     var line : Line ; line := Line.newLine() ;
     line.a := sc.getCurrent()->toLong() ; 
    line.op := sc.getCurrent()->at(0+1) ; 
    line.b := sc.getCurrent()->toLong() ; 
    list := list->including(line) ; 
 ) ; 
     for (line : list) do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (line.op) ; 
       if _switchval = '+' then
     OclFile["System.out"].println(line.a + line.b) ; 
    break 
   else skip ;
       if _switchval = '-' then
     OclFile["System.out"].println(line.a - line.b) ; 
    break 
   else skip ;
       if _switchval = '*' then
     OclFile["System.out"].println(line.a * line.b) ; 
    break 
   else skip ;
       if _switchval = '/' then
     OclFile["System.out"].println(line.a / line.b) ; 
    break 
   else skip ;
 )
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    List<Integer>A=new ArrayList<>();
    List<Integer>B=new ArrayList<>();
    List<Integer>C=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      A.add(scanner.nextInt());
    }
    for(int i=0 ; i<N ; i++){
      B.add(scanner.nextInt());
    }
    for(int i=0 ; i<N-1 ; i++){
      C.add(scanner.nextInt());
    }
    scanner.close();
    int score=0 ;
    int tmp=0 ;
    for(int i=0 ; i<N ; i++){
      int num=A.get(i);
      int current_score=B.get(num-1);
      score+=current_score ;
      if(i!=0 && tmp+1==num){
        score+=C.get(tmp-1);
      }
      tmp=num ;
    }
    System.out.println(score);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Sequence{} ;
    var B : Sequence(int) ; B := Sequence{} ;
    var C : Sequence(int) ; C := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     A := A->including(scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     B := B->including(scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     C := C->including(scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    skip ; 
    var score : int ; score := 0 ;
    var tmp : int ; tmp := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var num : int ; num := A->at(i+1) ;
     var current_score : int ; current_score := B->at(num - 1+1) ;
    score := score+(current_score) ; 
    if (i /= 0 & tmp + 1 = num) then (     score := score+(C->at(tmp - 1+1)) ) else skip ; 
    tmp := num ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(score) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    ArrayList<Integer>listA=new ArrayList<>();
    ArrayList<Integer>listB=new ArrayList<>();
    ArrayList<Integer>listC=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      listA.add(Integer.parseInt(sc.next()));
    }
    for(int i=0 ; i<N ; i++){
      listB.add(Integer.parseInt(sc.next()));
    }
    for(int i=0 ; i<N-1 ; i++){
      listC.add(Integer.parseInt(sc.next()));
    }
    sc.close();
    int satisfaction=0 ;
    for(int i=0 ; i<listA.size(); i++){
      int tmp=listA.get(i)-1 ;
      satisfaction+=listB.get(tmp);
      if(i>0){
        if(listA.get(i)==listA.get(i-1)+1){
          satisfaction+=listC.get(listA.get(i-1)-1);
        }
        else {
          continue ;
        }
      }
    }
    System.out.println(satisfaction);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var listA : Sequence(int) ; listA := Sequence{} ;
    var listB : Sequence(int) ; listB := Sequence{} ;
    var listC : Sequence(int) ; listC := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     listA := listA->including((sc.getCurrent())->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     listB := listB->including((sc.getCurrent())->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     listC := listC->including((sc.getCurrent())->toInteger()) )  ;     i := i + 1 ) ; 
    skip ; 
    var satisfaction : int ; satisfaction := 0 ;
        var i : int ; i := 0 ; while i < listA->size() do ( (     var tmp : int ; tmp := listA->at(i+1) - 1 ;
     satisfaction := satisfaction+(listB->at(tmp+1)) ; 
     if (i > 0) then (     if (listA->at(i+1) = listA->at(i - 1+1) + 1) then (     satisfaction := satisfaction+(listC->at(listA->at(i - 1+1) - 1+1)) ) else (     continue ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(satisfaction) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static Scanner mScanner ;
  public static void main(String[] args){
    mScanner=new Scanner(System.in);
    int intDishTotal=mScanner.nextInt();
    int[] intArrEatOrder=CreateArrayFromInput(intDishTotal);
    int[] intArrSatisfactionB=CreateArrayFromInput(intDishTotal);
    int[] intArrSatisfactionC=CreateArrayFromInput(intDishTotal-1);
    int intSatisFactionSum=0 ;
    int intDishNoHistory=0 ;
    for(int i=0 ; i<intArrEatOrder.length ; i++){
      int intDishNo=intArrEatOrder[i];
      intSatisFactionSum+=intArrSatisfactionB[intDishNo-1];
      if(intDishNoHistory!=0 && intDishNoHistory==(intDishNo-1)){
        intSatisFactionSum+=intArrSatisfactionC[intDishNoHistory-1];
      }
      intDishNoHistory=intDishNo ;
    }
    System.out.println(intSatisFactionSum);
  }
  private static int[] CreateArrayFromInput(int intInCount){
    int[] intArrRet=new int[intInCount];
    for(int i=0 ; i<intInCount ; i++){
      intArrRet[i]=mScanner.nextInt();
    }
    return intArrRet ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mScanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     mScanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var intDishTotal : int ; intDishTotal := mScanner.getCurrent()->toInteger() ;
    var intArrEatOrder : Sequence(int) ; intArrEatOrder := CreateArrayFromInput(intDishTotal) ;
    var intArrSatisfactionB : Sequence(int) ; intArrSatisfactionB := CreateArrayFromInput(intDishTotal) ;
    var intArrSatisfactionC : Sequence(int) ; intArrSatisfactionC := CreateArrayFromInput(intDishTotal - 1) ;
    var intSatisFactionSum : int ; intSatisFactionSum := 0 ;
    var intDishNoHistory : int ; intDishNoHistory := 0 ;
        var i : int ; i := 0 ; while i < intArrEatOrder->size() do ( (     var intDishNo : int ; intDishNo := intArrEatOrder[i+1] ;
     intSatisFactionSum := intSatisFactionSum+(intArrSatisfactionB[intDishNo - 1+1]) ; 
     if (intDishNoHistory /= 0 & intDishNoHistory = (intDishNo - 1)) then (     intSatisFactionSum := intSatisFactionSum+(intArrSatisfactionC[intDishNoHistory - 1+1]) ) else skip ; 
     intDishNoHistory := intDishNo )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(intSatisFactionSum) ; 
 );
  static   operation CreateArrayFromInput( intInCount : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var intArrRet : Sequence(int) ; intArrRet := Integer.subrange(1,intInCount)->collect(0) ;
         var i : int ; i := 0 ; while i < intInCount do ( (     intArrRet[i+1] := mScanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return intArrRet );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] $){
    Scanner sc=new Scanner(in);
    long a=sc.nextLong();
    long b=sc.nextLong();
    long c=sc.nextLong();
    long ans=2*b ;
    if(c-b>a){
      ans+=a+1 ;
    }
    else if(c-b==a){
      ans+=a ;
    }
    else {
      ans+=c-b ;
    }
    out.println(ans);
  }
  static long power(long x,int n){
    long mod=1000000007 ;
    long ans=1 ;
    while(n>0){
      if((n & 1)==1){
        ans=(ans*x)% mod ;
      }
      x=(x*x)% mod ;
      n>>=1 ;
    }
    return ans ;
  }
  static int gcd(int a,int b){
    int temp ;
    while((temp=a % b)!=0){
      a=b ;
      b=temp ;
    }
    return b ;
  }
  static class UF {
    static int size=51 ;
    static int[] par=new int[size];
    static void init(){
      for(int i=1 ; i<size ; i++){
        par[i]=i ;
      }
    }
    static int root(int x){
      if(par[x]==x){
        return x ;
      }
      else {
        return par[x]=root(par[x]);
      }
    }
    static boolean same(int x,int y){
      return root(x)==root(y);
    }
    static void unite(int x,int y){
      x=root(x);
      y=root(y);
      if(x==y)return ;
      par[x]=y ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var c : long ; c := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 2 * b ;
    if (c - b > a) then (     ans := ans+(a + 1) ) else     if (c - b = a) then (     ans := ans+(a) ) else (     ans := ans+(c - b) ) ;  ;  
    out.println(ans) ; 
 );
  static   operation power( x : long, n : int) : long
  pre: true
  post: true
  activity: (     var mod : long ; mod := 1000000007 ;
     var ans : long ; ans := 1 ;
     while (n > 0) do (     if ((n & 1) = 1) then (     ans := (ans * x) mod mod ) else skip ; 
     x := (x * x) mod mod ; 
     n := n/(2->pow(1)) ) ; 
     return ans );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var temp : int ;
         temp := a mod b ;
    while ((temp) /= 0) do (    skip ; (     a := b ; 
     b := temp ) ;     temp := a mod b ;
 ) ;  
     return b );
  static class UF {
  static   attribute size : int := 51;
  static   attribute par : Sequence(int) := Integer.subrange(1,size)->collect(0);
  static   operation init() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < size do ( (     par[i+1] := i )  ;     i := i + 1 ) );
  static   operation root( x : int) : int
  pre: true
  post: true
  activity: (     if (par[x+1] = x) then (     return x ) else (     return par[x+1] ) );
  static   operation same( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return root(x) = root(y) );
  static   operation unite( x : int, y : int) : void
  pre: true
  post: true
  activity: (     x := root(x) ; 
     y := root(y) ; 
     if (x = y) then     return else skip ; 
     par[x+1] := y );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    APoisonousCookies solver=new APoisonousCookies();
    solver.solve(1,in,out);
    out.close();
  }
  static class APoisonousCookies {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int a=in.nextInt();
      int b=in.nextInt();
      int c=in.nextInt();
      long d=c-a>0 ? c-a : 0 ;
      long f=d-b>0 ? d-b : 0 ;
      long res=Math.min(a,c)+Math.min(d,b)+Math.min(f,1)+b ;
      out.println(res);
    }
  }
  static class InputReader implements AutoCloseable {
    private BufferedReader reader ;
    private StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public void close(){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : APoisonousCookies ; solver := APoisonousCookies.newAPoisonousCookies() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class APoisonousCookies {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.nextInt() ;
     var b : int ; b := in.nextInt() ;
    var c : int ; c := in.nextInt() ;
    var d : long ; d := if c - a > 0 then c - a else 0 endif ;
    var f : long ; f := if d - b > 0 then d - b else 0 endif ;
    var res : long ; res := Set{a, c}->min() + Set{d, b}->min() + Set{f, 1}->min() + b ;
    skip ; 
 );
}
  static class InputReader implements AutoCloseable {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation close() : void
  pre: true
  post: true
  activity: skip;
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static int matchsticks[]={
    0,2,5,5,4,5,6,3,7,6 };
    public static void main(String[] args){
      Scanner sc=new Scanner(System.in);
      int untastyAntidote=sc.nextInt();
      int tastyAntidote=sc.nextInt();
      int tastyPoison=sc.nextInt();
      int ans=0 ;
      int min=Math.min(untastyAntidote,tastyPoison);
      ans+=min ;
      tastyPoison-=min ;
      min=Math.min(tastyAntidote,tastyPoison);
      ans+=2*min ;
      tastyAntidote-=min ;
      tastyPoison-=min ;
      if(tastyPoison>0){
        ans++;
      }
      ans+=tastyAntidote ;
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute matchsticks : int := Sequence{0,2,5,5,4,5,6,3,7,6};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var untastyAntidote : int ; untastyAntidote := sc.getCurrent()->toInteger() ;
    var tastyAntidote : int ; tastyAntidote := sc.getCurrent()->toInteger() ;
    var tastyPoison : int ; tastyPoison := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    var min : int ; min := Set{untastyAntidote, tastyPoison}->min() ;
    ans := ans+(min) ; 
    tastyPoison := tastyPoison-(min) ; 
    min := Set{tastyAntidote, tastyPoison}->min() ; 
    ans := ans+(2 * min) ; 
    tastyAntidote := tastyAntidote-(min) ; 
    tastyPoison := tastyPoison-(min) ; 
    if (tastyPoison > 0) then (     ans := ans + 1 ) else skip ; 
    ans := ans+(tastyAntidote) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class Main {
  public static void main(String[] args)throws Exception {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader reader=new BufferedReader(is);
    List<String>mylist=new ArrayList<>();
    String strinput=reader.readLine();
    while(strinput!=null){
      mylist.add(strinput);
      strinput=reader.readLine();
    }
    String arr01[]=mylist.get(0).split(" ");
    int a=Integer.valueOf(arr01[0]);
    int b=Integer.valueOf(arr01[1]);
    int c=Integer.valueOf(arr01[2]);
    int cnt=0 ;
    if(c>=a){
      cnt+=a ;
      c-=a ;
      a=0 ;
    }
    else {
      cnt+=c ;
      a-=c ;
      c=0 ;
    }
    if(c>=b){
      cnt+=b*2 ;
      c-=b ;
      b=0 ;
      if(c>0){
        cnt+=1 ;
      }
    }
    else {
      cnt+=b ;
      cnt+=c ;
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(is) ;
    var mylist : Sequence(String) ; mylist := Sequence{} ;
    var strinput : String ; strinput := reader.readLine() ;
    while (strinput /= null) do (     mylist := mylist->including(strinput) ; 
     strinput := reader.readLine() ) ; 
    var arr01 : Sequence(String) ; arr01 := mylist->at(0+1)->split(" ") ;
    var a : int ; a := (arr01[0+1])->toInteger() ;
    var b : int ; b := (arr01[1+1])->toInteger() ;
    var c : int ; c := (arr01[2+1])->toInteger() ;
    var cnt : int ; cnt := 0 ;
    if (c >= a) then (     cnt := cnt+(a) ; 
     c := c-(a) ; 
     a := 0 ) else (     cnt := cnt+(c) ; 
     a := a-(c) ; 
     c := 0 ) ;  
    if (c >= b) then (     cnt := cnt+(b * 2) ; 
     c := c-(b) ; 
     b := 0 ; 
     if (c > 0) then (     cnt := cnt+(1) ) else skip ) else (     cnt := cnt+(b) ; 
     cnt := cnt+(c) ) ;  
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    InputReader reader=new InputReader(System.in);
    int A,B,C ;
    A=reader.nextInt();
    B=reader.nextInt();
    C=reader.nextInt();
    int ans=B+Math.min(A+B+1,C);
    System.out.println(ans);
  }
  public static class InputReader {
    private StringTokenizer tokenizer ;
    private BufferedReader reader ;
    public InputReader(InputStream in){
      assert in!=null ;
      reader=new BufferedReader(new InputStreamReader(in),Short.MAX_VALUE);
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        tokenizer=null ;
        try {
          return reader.readLine();
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      else {
        StringBuilder builder=new StringBuilder();
        while(tokenizer.hasMoreTokens()){
          builder.append(tokenizer.nextToken());
          builder.append(' ');
        }
        return builder.toString();
      }
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public void close(){
      try {
        reader.close();
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : InputReader ; reader := InputReader.newInputReader(OclFile["System.in"]) ;
     var A : int ;
    var B : int ;
    var C : int ;
    A := reader.nextInt() ; 
    B := reader.nextInt() ; 
    C := reader.nextInt() ; 
    var ans : int ; ans := B + Set{A + B + 1, C}->min() ;
    OclFile["System.out"].println(ans) ; 
 );
  static class InputReader {
   attribute tokenizer : OclIterator;
   attribute reader : OclFile;
   static operation newInputReader( in : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     assert in /= null ; 
     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in), 32767) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     tokenizer := null ; 
     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 ) else (     var builder : String ; builder := StringLib.newString() ;
     while (tokenizer.hasNext()) do (     builder := builder + StringLib.newString(tokenizer.next()) ; 
     builder := builder + StringLib.newString(' ') ) ; 
     return builder+"" ) );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation close() : void
  pre: true
  post: true
  activity: (     try (     skip )   catch (e : IOException) do (     error ProgramException(e) )
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long ans=(long)N*(N-1)/2 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     var ans : long ; ans := N->oclAsType(long) * (N - 1) / 2 ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    DModSum solver=new DModSum();
    solver.solve(1,in,out);
    out.close();
  }
  static class DModSum {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      long n=in.nextInt();
      out.println(n*(n-1)/2);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : DModSum ; solver := DModSum.newDModSum() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class DModSum {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : long ; n := in.nextInt() ;
     skip );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new AOJ0181().doIt();
  }
  class AOJ0181 {
    int m,n ;
    int[] books ;
    boolean isPossible(int width){
      int w=0,cnt=1 ;
      for(int i=0 ; i<n ; i++){
        w+=books[i];
        if(books[i]>width)return false ;
        if(w>width){
          cnt++;
          w=books[i];
        }
      }
      return cnt>m ? false : true ;
    }
    void doIt(){
      while(true){
        m=in.nextInt();
        n=in.nextInt();
        if(n+m==0)return ;
        books=new int[n];
        for(int i=0 ; i<n ; i++)books[i]=in.nextInt();
        int left=1 ;
        int right=1500000 ;
        while(right-left!=1){
          int next=(left+right)/2 ;
          if(isPossible(next))right=next ;
          else left=next ;
        }
        System.out.println(right);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     AOJ0181.newAOJ0181().doIt() );
 class AOJ0181 {
   attribute m : int;
   attribute books : Sequence(int);
   operation isPossible( width : int) : boolean
  pre: true
  post: true
  activity: (     var w : int ; w := 0 ;
    var cnt : int ; cnt := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     w := w+(books[i+1]) ; 
     if (books[i+1] > width) then     return false else skip ; 
     if (w > width) then (     cnt := cnt + 1 ; 
     w := books[i+1] ) else skip )  ;     i := i + 1 ) ; 
     return if cnt > m then false else true endif );
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (true) do (     m := in.getCurrent()->toInteger() ; 
     n := in.getCurrent()->toInteger() ; 
    if (n + m = 0) then     return else skip ; 
    books := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     books[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var left : int ; left := 1 ;
    var right : int ; right := 1500000 ;
    while (right - left /= 1) do (     var next : int ; next := (left + right) / 2 ;
     if (isPossible(next)) then     right := next ; else     left := next ; ) ; 
    OclFile["System.out"].println(right) ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
import java.util.*;
public class test {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    FastReader scan=new FastReader();
    int n=scan.nextInt();
    int top=scan.nextInt();
    boolean done=false ;
    int bottom=7-top ;
    for(int i=0 ; i<n ; i++){
      int a=scan.nextInt();
      int b=scan.nextInt();
      if(a!=top && a!=bottom && 7-a!=top && 7-a!=bottom && b!=top && b!=bottom && 7-b!=top && 7-b!=bottom){
        continue ;
      }
      else {
        System.out.println("NO");
        done=true ;
        break ;
      }
    }
    if(done==false)System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : FastReader ; scan := FastReader.newFastReader() ;
     var n : int ; n := scan.nextInt() ;
    var top : int ; top := scan.nextInt() ;
    var done : boolean ; done := false ;
    var bottom : int ; bottom := 7 - top ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scan.nextInt() ;
     var b : int ; b := scan.nextInt() ;
     if (a /= top & a /= bottom & 7 - a /= top & 7 - a /= bottom & b /= top & b /= bottom & 7 - b /= top & 7 - b /= bottom) then (     continue ) else (     OclFile["System.out"].println("NO") ; 
     done := true ; 
     break ) )  ;     i := i + 1 ) ; 
    if (done = false) then     OclFile["System.out"].println("YES") ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class T1487B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=in.nextInt();
      int k=in.nextInt();
      if(n % 2==0){
      }
      else {
        int lengthSerialSegment=n/2 ;
        int sizeSerialSegment=k/lengthSerialSegment ;
        int sizeNewSegment=k % lengthSerialSegment ;
        int sizeMissed ;
        if(sizeNewSegment>0){
          sizeMissed=sizeSerialSegment ;
        }
        else {
          sizeMissed=sizeSerialSegment-1 ;
          if(sizeMissed==-1){
            sizeMissed=0 ;
          }
        }
        k+=sizeMissed ;
      }
      int position=k % n ;
      if(position==0){
        position=n ;
      }
      System.out.println(position);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class T1487B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    if (n mod 2 = 0) then skip else (     var lengthSerialSegment : int ; lengthSerialSegment := n / 2 ;
     var sizeSerialSegment : int ; sizeSerialSegment := k / lengthSerialSegment ;
    var sizeNewSegment : int ; sizeNewSegment := k mod lengthSerialSegment ;
    var sizeMissed : int ;
    if (sizeNewSegment > 0) then (     sizeMissed := sizeSerialSegment ) else (     sizeMissed := sizeSerialSegment - 1 ; 
     if (sizeMissed = -1) then (     sizeMissed := 0 ) else skip ) ;  
    k := k+(sizeMissed) ; 
 ) ;  
    var position : int ; position := k mod n ;
    if (position = 0) then (     position := n ) else skip ; 
    OclFile["System.out"].println(position) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    final long N=scan.nextLong();
    scan.close();
    System.out.println(BigInteger.valueOf(N-1).multiply(BigInteger.valueOf(N)).divide(BigInteger.valueOf(2)).toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := scan.getCurrent()->toLong() ;
     skip ; 
     OclFile["System.out"].println((N - 1 + "")->toLong().multiply((N + "")->toLong()).divide((2 + "")->toLong())+"") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    System.out.println(n*(n-1)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println(n * (n - 1) / 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    int num=in.nextInt();
    long n=num-1 ;
    long res=(n*(n+1))/2 ;
    out.println(res);
    out.close();
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var num : int ; num := in.nextInt() ;
    var n : long ; n := num - 1 ;
    var res : long ; res := (n * (n + 1)) / 2 ;
    skip ; 
    skip ; 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    try {
      Scanner sc=new Scanner(System.in);
      int n,ans=0 ;
      n=Integer.parseInt(sc.next());
      int[] h=new int[n];
      for(int i=0 ; i<n ; i++){
        h[i]=Integer.parseInt(sc.next());
      }
      for(int i=0 ; i<n-1 ; i++){
        if(h[i]>h[i+1]){
          ans=ans+h[i]-h[i+1];
        }
      }
      System.out.println(ans+h[n-1]);
    }
    catch(Exception e){
      System.out.println("out");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var ans : int ; ans := 0 ;
    n := (sc.getCurrent())->toInteger() ; 
    var h : Sequence(int) ; h := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     h[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (h[i+1] > h[i + 1+1]) then (     ans := ans + h[i+1] - h[i + 1+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans + h[n - 1+1]) ; 
 )   catch (e : ProgramException) do (     OclFile["System.out"].println("out") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CGrandGarden solver=new CGrandGarden();
    solver.solve(1,in,out);
    out.close();
  }
  static class CGrandGarden {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt(),a[]=new int[n];
      for(int i=0 ; i<n ; ++i)a[i]=in.nextInt();
      int ans=0 ;
      for(int i=1 ; i<=100 ; ++i){
        int pos=0 ;
        while(pos<n){
          while(pos<n && a[pos]<i)++pos ;
          if(pos==n)break ;
          while(pos<n && a[pos]>=i)++pos ;
++ans ;
        }
      }
      out.println(ans);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CGrandGarden ; solver := CGrandGarden.newCGrandGarden() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CGrandGarden {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
    var a : Sequence(void) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := in.nextInt() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= 100 do ( (     var pos : int ; pos := 0 ;
     while (pos < n) do (     while (pos < n & a[pos+1] < i) do     pos := pos + 1 ; ; 
     if (pos = n) then     break else skip ; 
     while (pos < n & a[pos+1] >= i) do     pos := pos + 1 ; ; 
     ans := ans + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int N=scanner.nextInt();
    final int[] h=new int[N];
    final int maxHeight ;
    {
      int maxHeightCandidate=0 ;
      for(int k=1 ; k<=N ; k++){
        h[k-1]=scanner.nextInt();
        if(maxHeightCandidate<h[k-1]){
          maxHeightCandidate=h[k-1];
        }
      }
      maxHeight=maxHeightCandidate ;
    }
    int totalCount=0 ;
    for(int height=1 ; height<=maxHeight ; height++){
      int countPerHeight=0 ;
      boolean exists=false ;
      for(int k=1 ; k<=N ; k++){
        if(exists){
          if(h[k-1]<height){
            exists=false ;
          }
        }
        else {
          if(h[k-1]>=height){
            exists=true ;
            countPerHeight++;
          }
        }
      }
      totalCount+=countPerHeight ;
    }
    System.out.println(totalCount);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var h : Sequence(int) ; h := Integer.subrange(1,N)->collect(0) ;
    var maxHeight : int ;
(     var maxHeightCandidate : int ; maxHeightCandidate := 0 ;
         var k : int ; k := 1 ; while k <= N do ( (     h[k - 1+1] := scanner.getCurrent()->toInteger() ; 
     if (maxHeightCandidate < h[k - 1+1]) then (     maxHeightCandidate := h[k - 1+1] ) else skip )  ;     k := k + 1 ) ; 
     maxHeight := maxHeightCandidate ) 
    var totalCount : int ; totalCount := 0 ;
        var height : int ; height := 1 ; while height <= maxHeight do ( (     var countPerHeight : int ; countPerHeight := 0 ;
     var exists : boolean ; exists := false ;
         var k : int ; k := 1 ; while k <= N do ( (     if (exists) then (     if (h[k - 1+1] < height) then (     exists := false ) else skip ) else (     if (h[k - 1+1] >= height) then (     exists := true ; 
     countPerHeight := countPerHeight + 1 ) else skip ) )  ;     k := k + 1 ) ; 
     totalCount := totalCount+(countPerHeight) )  ;     height := height + 1 ) ; 
    OclFile["System.out"].println(totalCount) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    C solver=new C();
    solver.solve(1,in,out);
    out.close();
  }
  static class C {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int N=in.nextInt();
      int[] h=new int[N+1];
      Arrays.fill(h,0);
      for(int i=0 ; i<N ; i++){
        h[i]=in.nextInt();
      }
      int count=0 ;
      for(int i=0 ; i<N ; i++){
        if(h[i]>h[i+1]){
          count+=h[i]-h[i+1];
        }
      }
      out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : C ; solver := C.newC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class C {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
     var h : Sequence(int) ; h := Integer.subrange(1,N + 1)->collect(0) ;
    h := h->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     h[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (h[i+1] > h[i + 1+1]) then (     count := count+(h[i+1] - h[i + 1+1]) ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int N ;
  static int[] flowers ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    flowers=new int[N];
    for(int i=0 ; i<N ; i++){
      flowers[i]=sc.nextInt();
    }
    sc.close();
    int ans=0 ;
    int cur=0 ;
    for(int k=0 ; k<N ; k++){
      if(flowers[k]>cur){
        ans+=flowers[k]-cur ;
      }
      cur=flowers[k];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute flowers : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
    flowers := Integer.subrange(1,N)->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     flowers[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : int ; ans := 0 ;
    var cur : int ; cur := 0 ;
        var k : int ; k := 0 ; while k < N do ( (     if (flowers[k+1] > cur) then (     ans := ans+(flowers[k+1] - cur) ) else skip ; 
     cur := flowers[k+1] )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      int m=sc.nextInt();
      int n=sc.nextInt();
      if(n==0 && m==0)break ;
      int[] w=new int[n];
      for(int i=0 ; i<n ; i++)w[i]=sc.nextInt();
      int hi=10000000 ;
      int lo=1 ;
      while(hi-lo>1){
        int mid=(hi+lo)/2 ;
        if(possible(mid,m,w))hi=mid ;
        else lo=mid ;
      }
      System.out.println(hi);
    }
  }
  boolean possible(int W,int m,int[] w){
    int need=0 ;
    need++;
    int pos=0 ;
    for(int i=0 ; i<w.length ; i++){
      if(pos+w[i]>W){
        need++;
        pos=w[i];
        if(w[i]>W)return false ;
      }
      else {
        pos+=w[i];
      }
    }
    return need<=m ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var m : int ; m := sc.getCurrent()->toInteger() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    if (n = 0 & m = 0) then     break else skip ; 
    var w : Sequence(int) ; w := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     w[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var hi : int ; hi := 10000000 ;
    var lo : int ; lo := 1 ;
    while (hi - lo > 1) do (     var mid : int ; mid := (hi + lo) / 2 ;
     if (possible(mid, m, w)) then     hi := mid ; else     lo := mid ; ) ; 
    OclFile["System.out"].println(hi) ; 
 )  ) );
   operation possible( W : int, m : int, w : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var need : int ; need := 0 ;
     need := need + 1 ; 
    var pos : int ; pos := 0 ;
        var i : int ; i := 0 ; while i < w->size() do ( (     if (pos + w[i+1] > W) then (     need := need + 1 ; 
     pos := w[i+1] ; 
     if (w[i+1] > W) then     return false else skip ) else (     pos := pos+(w[i+1]) ) )  ;     i := i + 1 ) ; 
    return need <= m 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int a=in.nextInt();
      long[] ans=new long[] {
        1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8092,16184,32368,64736,129472,258944,517888,1035776,2071552,4143104,8286208,16572416,33144832,66289664,132579328,265158656,530317312,1060634624,2121269248,4242538496L,8485076992L,16970153984L,33940307968L };
        out.println(ans[a]);
      }
    }
    static class InputReader {
      private BufferedReader reader ;
      private StringTokenizer stt ;
      public InputReader(InputStream stream){
        reader=new BufferedReader(new InputStreamReader(stream));
      }
      public String nextLine(){
        try {
          return reader.readLine();
        }
        catch(IOException e){
          return null ;
        }
      }
      public String next(){
        while(stt==null || ! stt.hasMoreTokens()){
          stt=new StringTokenizer(nextLine());
        }
        return stt.nextToken();
      }
      public int nextInt(){
        return Integer.parseInt(next());
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.nextInt() ;
     var ans : Sequence(long) ; ans := Sequence{1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8092,16184,32368,64736,129472,258944,517888,1035776,2071552,4143104,8286208,16572416,33144832,66289664,132579328,265158656,530317312,1060634624,2121269248,4242538496L,8485076992L,16970153984L,33940307968L} ;
     skip );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute stt : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     return null )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (stt = null or not(stt.hasNext())) do (     stt := OclIterator.newOclIterator_String(nextLine()) ) ; 
     return stt.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    try {
      int pot=Integer.parseInt(bf.readLine());
      if(pot<13){
        System.out.println((long)(Math.pow(2,pot)));
      }
      else {
        System.out.println((long)(8092*Math.pow(2,pot-13)));
      }
    }
    catch(NumberFormatException e){
      e.printStackTrace();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var pot : int ; pot := (bf.readLine())->toInteger() ;
     if (pot < 13) then (     OclFile["System.out"].println((2->pow(pot))->oclAsType(long)) ) else (     OclFile["System.out"].println((8092 * 2->pow(pot - 13))->oclAsType(long)) ) )   catch (e : IncorrectElementException) do (     e.printStackTrace() )
   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static long n,k ;
  static void solve(){
    long val=0 ;
    if(n % 2==0)val=k % n ;
    else val=(k+(k-1)/(n/2))% n ;
    if(val==0)val=n ;
    str.append(val).append("\n");
  }
  public static void main(String[] args)throws java.lang.Exception {
    boolean lenv=false ;
    BufferedReader bf ;
    PrintWriter pw ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    int q1=Integer.parseInt(bf.readLine().trim());
    while(q1-->0){
      String s[]=bf.readLine().trim().split("\\s+");
      n=Long.parseLong(s[0]);
      k=Long.parseLong(s[1]);
      solve();
    }
    pw.print(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute n : long;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var val : long ; val := 0 ;
     if (n mod 2 = 0) then     val := k mod n else     val := (k + (k - 1) / (n / 2)) mod n ; ;  
     if (val = 0) then     val := n ; else skip ; 
     str := str + StringLib.newString(val) + StringLib.newString("\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var lenv : boolean ; lenv := false ;
     var bf : OclFile ;
    var pw : OclFile ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var q1 : int ; q1 := (bf.readLine()->trim())->toInteger() ;
        while (q1 > 0) do (        q1 := q1 - 1 ;     skip ; (     var s : Sequence(String) ; s := bf.readLine()->trim()->split("\\s+") ;
     n := (s[0+1])->toLong() ; 
     k := (s[1+1])->toLong() ; 
     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class I {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int a=Integer.parseInt(br.readLine());
    long ans=0 ;
    if(a<13){
      ans=1<<a ;
    }
    else {
      ans=8092L ;
      for(int i=13 ; i<a ; i++)ans*=2 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class I {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var a : int ; a := (br.readLine())->toInteger() ;
    var ans : long ; ans := 0 ;
    if (a < 13) then (     ans := (1*(2->pow(a)))->oclAsType(long) ) else (     ans := 8092L ; 
         var i : int ; i := 13 ; while i < a do (     ans := ans*(2) ;  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    double x=1 ;
    int z=new Scanner(System.in).nextInt();
    Formatter formatter=new Formatter(System.out);
    for(int i=0 ; i<z ; i++){
      x*=2 ;
      if(i==12){
        x-=100 ;
      }
    }
    formatter.format("%d\n",(long)x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : double ; x := 1 ;
     var z : int ; z := OclFile.newOclFile_Read(OclFile["System.in"]).nextInt() ;
    var formatter : OclFile ; formatter := OclFile.newOclFile_Write(OclFile["System.out"]) ;
        var i : int ; i := 0 ; while i < z do ( (     x := x*(2) ; 
     if (i = 12) then (     x := x-(100) ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int ans ;
    if(a-b>=c){
      ans=0 ;
    }
    else {
      ans=c-a+b ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var ans : int ;
    if (a - b >= c) then (     ans := 0 ) else (     ans := c - a + b ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ATransfer solver=new ATransfer();
    solver.solve(1,in,out);
    out.close();
  }
  static class ATransfer {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int a=in.nextInt();
      int b=in.nextInt();
      int c=in.nextInt();
      int ans=c-(a-b);
      if(ans>0){
        out.println(ans);
      }
      else {
        out.println(0);
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ATransfer ; solver := ATransfer.newATransfer() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ATransfer {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.nextInt() ;
     var b : int ; b := in.nextInt() ;
    var c : int ; c := in.nextInt() ;
    var ans : int ; ans := c - (a - b) ;
    if (ans > 0) then (     skip ) else (     skip ) ;  
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    int rest=A-B ;
    int answer=C-rest ;
    if(answer<0){
      System.out.println(0);
    }
    else {
      System.out.println(answer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var rest : int ; rest := A - B ;
    var answer : int ; answer := C - rest ;
    if (answer < 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(answer) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    A solver=new A();
    solver.solve(1,in,out);
    out.close();
  }
  static class A {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int a=Integer.parseInt(in.next());
      int b=Integer.parseInt(in.next());
      int c=Integer.parseInt(in.next());
      int ans=c-(a-b);
      if(ans<0)ans=0 ;
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : A ; solver := A.newA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class A {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := (in.getCurrent())->toInteger() ;
     var b : int ; b := (in.getCurrent())->toInteger() ;
    var c : int ; c := (in.getCurrent())->toInteger() ;
    var ans : int ; ans := c - (a - b) ;
    if (ans < 0) then     ans := 0 ; else skip ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Main main=new Main();
    main.solve();
  }
  public void solve()throws Exception {
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int A=scan.nextInt();
    int B=scan.nextInt();
    int C=scan.nextInt();
    int ans=Math.max(0,C-(A-B));
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var A : int ; A := scan.getCurrent()->toInteger() ;
    var B : int ; B := scan.getCurrent()->toInteger() ;
    var C : int ; C := scan.getCurrent()->toInteger() ;
    var ans : int ; ans := Set{0, C - (A - B)}->max() ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      int m=sc.nextInt();
      int n=sc.nextInt();
      if((m | n)==0){
        return ;
      }
      int book[]=new int[n];
      int right=1500000 ;
      int left=1 ;
      int min=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; i++){
        book[i]=sc.nextInt();
        left=Math.max(left,book[i]);
      }
      int width=0 ;
      int step=1 ;
      while(right-left>1){
        int mid=(right+left)/2 ;
        width=0 ;
        step=1 ;
        for(int i=0 ; i<n ; i++){
          if(width+book[i]<=mid){
            width+=book[i];
          }
          else {
            width=book[i];
            step++;
          }
        }
        if(step<=m){
          min=Math.min(min,mid);
          right=mid ;
        }
        else {
          left=mid ;
        }
      }
      width=0 ;
      step=1 ;
      for(int i=0 ; i<n ; i++){
        if(width+book[i]<=left){
          width+=book[i];
        }
        else {
          width=book[i];
          step++;
        }
      }
      if(step<=m){
        min=Math.min(min,left);
      }
      System.out.println(min);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var m : int ; m := sc.getCurrent()->toInteger() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(m,n)) = 0) then (     return ) else skip ; 
    var book : Sequence(int) ; book := Integer.subrange(1,n)->collect(0) ;
    var right : int ; right := 1500000 ;
    var left : int ; left := 1 ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     book[i+1] := sc.getCurrent()->toInteger() ; 
     left := Set{left, book[i+1]}->max() )  ;     i := i + 1 ) ; 
    var width : int ; width := 0 ;
    var step : int ; step := 1 ;
    while (right - left > 1) do (     var mid : int ; mid := (right + left) / 2 ;
     width := 0 ; 
    step := 1 ; 
        var i : int ; i := 0 ; while i < n do ( (     if (width + book[i+1] <= mid) then (     width := width+(book[i+1]) ) else (     width := book[i+1] ; 
     step := step + 1 ) )  ;     i := i + 1 ) ; 
    if (step <= m) then (     min := Set{min, mid}->min() ; 
     right := mid ) else (     left := mid ) ;  
 ) ; 
    width := 0 ; 
    step := 1 ; 
        var i : int ; i := 0 ; while i < n do ( (     if (width + book[i+1] <= left) then (     width := width+(book[i+1]) ) else (     width := book[i+1] ; 
     step := step + 1 ) )  ;     i := i + 1 ) ; 
    if (step <= m) then (     min := Set{min, left}->min() ) else skip ; 
    OclFile["System.out"].println(min) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
class Main {
  public static void main(String[] args){
    Solve s=new Solve();
    s.solve();
  }
}
class Solve {
  Solve(){
  }
  Scanner in=new Scanner(System.in);
  void solve(){
    int n=in.nextInt(),t=in.nextInt();
    String str=in.next();
    String[] s=str.split("\\+",0);
    String ns=Integer.toString(n);
    String ts=Integer.toString(t);
    BigInteger bi=new BigInteger("0");
    for(int i=0 ; i<s.length ; i++){
      String tmp=s[i] .substring(2);
      BigInteger b=new BigInteger(ns);
      bi=bi.add(b.pow(Integer.valueOf(tmp)));
    }
    bi=bi.multiply(new BigInteger(ts));
    BigInteger tle=new BigInteger("1000000000");
    if(bi.compareTo(tle)==1){
      System.out.println("TLE");
    }
    else {
      System.out.println(bi.toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Solve ; s := Solve.newSolve() ;
     s.solve() );
}
class Solve {
   static operation newSolve() : Solve
  pre: true
  post: true
  activity:
  ( var self : Solve ;
    self := createSolve();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
    var t : int ; t := in.getCurrent()->toInteger() ;
     var str : String ; str := in.getCurrent() ;
    var s : Sequence(String) ; s := str->split("\\+") ;
    var ns : String ; ns := ((n) + "") ;
    var ts : String ; ts := ((t) + "") ;
    var bi : long ; bi := long("0") ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var tmp : String ; tmp := s[i+1].subrange(2+1,2) ;
     var b : long ; b := long(ns) ;
     bi := bi->excludes(b.pow((tmp)->toInteger())) )  ;     i := i + 1 ) ; 
    bi := bi.multiply(long(ts)) ; 
    var tle : long ; tle := long("1000000000") ;
    if (bi->compareTo(tle) = 1) then (     OclFile["System.out"].println("TLE") ) else (     OclFile["System.out"].println(bi+"") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  final static int sec=1000_000_000 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int n,T ;
    line=br.readLine();
    n=parseInt(line.substring(0,line.indexOf(' ')));
    T=parseInt(line.substring(line.indexOf(' ')+1));
    boolean tle=false ;
    long sum=0 ;
    line=br.readLine();
    outer : for(char c : line.toCharArray()){
      if('0'<=c && c<='9'){
        int k=c-'0' ;
        long _sum ;
        if(k==0){
          _sum=1 ;
        }
        else {
          _sum=n ;
          for(int i=0 ; i<k-1 ; i++){
            _sum*=n ;
            if(_sum>sec){
              tle=true ;
              break outer ;
            }
          }
        }
        sum+=_sum ;
        if(sum>sec){
          tle=true ;
          break outer ;
        }
      }
    }
    sum*=T ;
    if(sum>sec){
      tle=true ;
    }
    System.out.println(tle ? "TLE" : sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sec : int := 1000_000_000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var n : int ;
    var T : int ;
    line := br.readLine() ; 
    n := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    T := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var tle : boolean ; tle := false ;
    var sum : long ; sum := 0 ;
    line := br.readLine() ; 
    for (c : line->characters()) do ( (     if ('0' <= c & c <= '9') then (     var k : int ; k := c - ('0')->char2byte() ;
     var _sum : long ;
    if (k = 0) then (     _sum := 1 ) else (     _sum := n ; 
         var i : int ; i := 0 ; while i < k - 1 do ( (     _sum := _sum*(n) ; 
     if (_sum > sec) then (     tle := true ; 
     break ) else skip )  ;     i := i + 1 ) ) ;  
    sum := sum+(_sum) ; 
    if (sum > sec) then (     tle := true ; 
     break ) else skip ; 
 ) else skip )  ) ; 
    sum := sum*(T) ; 
    if (sum > sec) then (     tle := true ) else skip ; 
    OclFile["System.out"].println(if tle then "TLE" else sum endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.LinkedList ;
import java.util.ListIterator ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String[] fst=sc.nextLine().split(" ");
    BigInteger n=new BigInteger(fst[0]+"");
    BigInteger T=new BigInteger(fst[1]+"");
    BigInteger MAX=new BigInteger("1000000000");
    String input=sc.nextLine();
    BigInteger sum=new BigInteger("0");
    for(String in : input.split("\\+")){
      int num=Integer.parseInt(in.split("\\^")[1]);
      sum=sum.add(n.pow(num).multiply(T));
    }
    System.out.println(sum.compareTo(MAX)<=0 ?(sum+""): "TLE");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var fst : Sequence(String) ; fst := sc.nextLine()->split(" ") ;
    var n : long ; n := long(fst[0+1] + "") ;
    var T : long ; T := long(fst[1+1] + "") ;
    var MAX : long ; MAX := long("1000000000") ;
    var input : String ; input := sc.nextLine() ;
    var sum : long ; sum := long("0") ;
    for (in : input->split("\\+")) do ( (     var num : int ; num := (in->split("\\^")[1+1])->toInteger() ;
     sum := sum->excludes(n.pow(num).multiply(T)) )  ) ; 
    OclFile["System.out"].println(if sum->compareTo(MAX) <= 0 then (sum + "") else "TLE" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printQueries(int n,int a[],int q,int qry[]){
    HashSet<Integer>occ=new HashSet<>();
    int[] suffixCount=new int[n+1];
    for(int i=n-1 ; i>=0 ; i--){
      occ.add(a[i]);
      suffixCount[i+1]=occ.size();
    }
    for(int i=0 ; i<q ; i++)System.out.println(suffixCount[qry[i] ]);
  }
  public static void main(String args[]){
    int n=5,q=3 ;
    int a[]={
      2,4,6,10,2 };
      int qry[]={
        1,3,2 };
        printQueries(n,a,q,qry);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printQueries( n : int, a : Sequence(int), q : int, qry : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var occ : Set(int) ; occ := Set{} ;
     var suffixCount : Sequence(int) ; suffixCount := Integer.subrange(1,n + 1)->collect(0) ;
         var i : int ; i := n - 1 ; while i >= 0 do ( (     occ := occ->including(a[i+1]) ; 
     suffixCount[i + 1+1] := occ->size() )  ;     i := i - 1 ) ; 
         var i : int ; i := 0 ; while i < q do (     OclFile["System.out"].println(suffixCount[qry[i+1]+1]) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var q : int ; q := 3 ;
     var a : Sequence(int) ; a := Sequence{2,4,6,10,2} ;
     var qry : Sequence(int) ; qry := Sequence{1,3,2} ;
     execute printQueries(n, a, q, qry) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static final int Big_Num=1000000000 ;
  static long mul(int n,int h){
    int ans=n ;
    if(h==0)return 1 ;
    if(h==1)return ans ;
    for(int i=0 ; i<h-1 ; i++){
      ans*=n ;
    }
    return ans ;
  }
  static long f(String str,int n){
    int[] an=new int[str.length()];
    int k=0 ;
    for(int i=0 ; i<str.length(); i++){
      char s=str.charAt(i);
      if(Character.isDigit(s)){
        an[k]=Integer.parseInt(String.valueOf(s));
        k++;
      }
    }
    long ans=0 ;
    int kk=0 ;
    for(int aa : an){
      ans+=mul(n,aa);
      kk++;
      if(kk==k)break ;
    }
    return ans ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    String str=sc.next();
    long ans=f(str,n);
    if(ans*t<=Big_Num && ans>0)System.out.println(ans*t);
    else System.out.println("TLE");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute Big_Num : int := 1000000000;
  static   operation mul( n : int, h : int) : long
  pre: true
  post: true
  activity: (     var ans : int ; ans := n ;
     if (h = 0) then     return 1 else skip ; 
    if (h = 1) then     return ans else skip ; 
        var i : int ; i := 0 ; while i < h - 1 do ( (     ans := ans*(n) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation f( str : String, n : int) : long
  pre: true
  post: true
  activity: (     var an : Sequence(int) ; an := Integer.subrange(1,str->size())->collect(0) ;
     var k : int ; k := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     var s : String ; s := str->at(i+1) ;
     if ((s + "")->isMatch("[0-9]")) then (     an[k+1] := (((s) + ""))->toInteger() ; 
     k := k + 1 ) else skip )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var kk : int ; kk := 0 ;
    for (aa : an) do ( (     ans := ans+(mul(n, aa)) ; 
     kk := kk + 1 ; 
     if (kk = k) then     break else skip )  ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var str : String ; str := sc.getCurrent() ;
    var ans : long ; ans := f(str, n) ;
    if (ans * t <= Big_Num & ans > 0) then     OclFile["System.out"].println(ans * t) else     OclFile["System.out"].println("TLE") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static long MAX=1000000000 ;
  static char[] f ;
  static int pos ;
  static int T ;
  public static void main(String[] args){
    int N=sc.nextInt();
    T=sc.nextInt();
    f=sc.next().toCharArray();
    ArrayList<Term>poly=new ArrayList<Term>();
    while(pos<f.length){
      poly.add(parse());
++pos ;
    }
    long ans=0 ;
    for(Term t : poly){
      ans+=t.eval(N);
    }
    if(ans>MAX){
      System.out.println("TLE");
    }
    else {
      System.out.println(ans);
    }
  }
  static Term parse(){
    pos+=2 ;
    int p=f[pos++]-'0' ;
    return new Term(p);
  }
  static class Term {
    int p ;
    Term(int p){
      this.p=p ;
    }
    long eval(int n){
      long ret=T ;
      for(int i=0 ; i<p ; ++i){
        ret*=n ;
        if(ret>MAX)return MAX+1 ;
      }
      return ret ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute MAX : long := 1000000000;
  static   attribute f : Sequence(String);
  static   attribute pos : int;
  static   attribute T : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     T := sc.getCurrent()->toInteger() ; 
    f := sc.getCurrent()->characters() ; 
    var poly : Sequence(Term) ; poly := Sequence{} ;
    while (pos < f->size()) do (     poly := poly->including(parse()) ; 
     pos := pos + 1 ) ; 
    var ans : long ; ans := 0 ;
    for (t : poly) do ( (     ans := ans+(t.eval(N)) )  ) ; 
    if (ans > MAX) then (     OclFile["System.out"].println("TLE") ) else (     OclFile["System.out"].println(ans) ) ;  
 );
  static   operation parse() : Term
  pre: true
  post: true
  activity: (     pos := pos+(2) ; 
     var p : int ; p := f[pos+1] - ('0')->char2byte() ;
     return Term.newTerm(p) );
  static class Term {
   attribute p : int;
   static operation newTerm( p : int) : Term
  pre: true
  post: true
  activity:
  ( var self : Term ;
    self := createTerm();
    self.initialise(p);
    return self );
  operation initialise( p : int) : void
  pre: true  post: true
  activity: (     self.p := p );
   operation eval( n : int) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := T ;
         var i : int ; i := 0 ; while i < p do ( (     ret := ret*(n) ; 
     if (ret > MAX) then     return MAX + 1 else skip )  ;     i := i + 1 ) ; 
     return ret );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class obstacle {
  static int avoidObstacles(int[] obs){
    HashSet<Integer>hs=new HashSet<Integer>();
    int max=obs[0];
    for(int i=0 ; i<obs.length ; i++){
      hs.add(obs[i]);
      max=Math.max(max,obs[i]);
    }
    for(int i=1 ; i<=max ; i++){
      int j ;
      for(j=i ; j<=max ; j=j+i){
        if(hs.contains(j))break ;
      }
      if(j>max)return i ;
    }
    return max+1 ;
  }
  public static void main(String[] args){
    int a[]=new int[] {
      5,3,6,7,9 };
      int b=avoidObstacles(a);
      System.out.println(b);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class obstacle {
  static   operation avoidObstacles( obs : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var hs : Set(int) ; hs := Set{} ;
     var max : int ; max := obs[0+1] ;
        var i : int ; i := 0 ; while i < obs->size() do ( (     hs := hs->including(obs[i+1]) ; 
     max := Set{max, obs[i+1]}->max() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= max do ( (     var j : int ;
         j := i ; while j <= max do ( (     if (hs->includes(j)) then     break else skip )  ;     j := j + i ) ; 
     if (j > max) then     return i else skip )  ;     i := i + 1 ) ; 
    return max + 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{5,3,6,7,9} ;
     var b : int ; b := avoidObstacles(a) ;
     OclFile["System.out"].println(b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    line=br.readLine();
    int N,M ;
    N=parseInt(line.substring(0,line.indexOf(' ')));
    M=parseInt(line.substring(line.indexOf(' ')+1));
    int[] zs=new int[N];
    for(int i=0 ; i<N ; i++){
      zs[i]=parseInt(br.readLine());
    }
    for(int k=1 ; k<=M ; k++){
      for(int i=0 ; i<N-1 ; i++){
        if(zs[i] % k>zs[i+1] % k){
          int tmp=zs[i];
          zs[i]=zs[i+1];
          zs[i+1]=tmp ;
        }
      }
    }
    for(int i=0 ; i<N ; i++){
      System.out.println(zs[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    line := br.readLine() ; 
    var N : int ;
    var M : int ;
    N := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    M := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var zs : Sequence(int) ; zs := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     zs[i+1] := (br.readLine() + "")->toInteger() )  ;     i := i + 1 ) ; 
        var k : int ; k := 1 ; while k <= M do ( (         var i : int ; i := 0 ; while i < N - 1 do ( (     if (zs[i+1] mod k > zs[i + 1+1] mod k) then (     var tmp : int ; tmp := zs[i+1] ;
     zs[i+1] := zs[i + 1+1] ; 
     zs[i + 1+1] := tmp ) else skip )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].println(zs[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  static final Scanner s=new Scanner(System.in);
  static IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static IntStream INS(int n){
    return REPS(n).map(i->getInt());
  }
  static int getInt(){
    return Integer.parseInt(s.next());
  }
  public static void main(String[] $){
    int n=getInt(),m=getInt();
    List<Integer>st=INS(n).boxed().collect(Collectors.toList());
    for(int k=1 ; k<=m ; ++k){
      for(int i=0 ; i<n-1 ; ++i){
        if(st.get(i)% k>st.get(i+1)% k)Collections.swap(st,i,i+1);
      }
    }
    st.forEach(System.out :: println);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static   operation INS( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return REPS(n)->collect( _x1 | (lambda i : OclAny in getInt())->apply(_x1) ) );
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := getInt() ;
    var m : int ; m := getInt() ;
     var st : Sequence(int) ; st := INS(n).collect(Collectors.toList()) ;
         var k : int ; k := 1 ; while k <= m do ( (         var i : int ; i := 0 ; while i < n - 1 do ( (     if (st->at(i+1) mod k > st->at(i + 1+1) mod k) then     st := Integer.subrange(1,st.size)->collect( _x | if _x = i+1 then st->at(i + 1+1) else if _x = i + 1+1 then st->at(i+1) else st->at(_x) endif endif ) ; else skip )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
     for _forEach : st do
    (    skip ;) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    int[] arg=new int[100];
    int i=0,sum=0,n=0,m=0 ;
    int[] bibs=null ;
    int[][] result=null ;
    boolean first=true ;
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String line ;
      while((line=br.readLine())!=null){
        if(first){
          String[] str=line.split(" ");
          n=Integer.parseInt(str[0]);
          m=Integer.parseInt(str[1]);
          bibs=new int[n+1];
          i=0 ;
          first=false ;
        }
        else {
          i++;
          bibs[i]=Integer.parseInt(line);
          if(i==n){
            for(int k=1 ; k<=m ; k++){
              for(int j=1 ; j<n ; j++){
                if(bibs[j] % k>bibs[j+1] % k){
                  int w=bibs[j];
                  bibs[j]=bibs[j+1];
                  bibs[j+1]=w ;
                }
              }
            }
            for(int j=1 ; j<n+1 ; j++){
              System.out.println(bibs[j]);
            }
            break ;
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arg : Sequence(int) ; arg := Integer.subrange(1,100)->collect(0) ;
     var i : int ; i := 0 ;
    var sum : int ; sum := 0 ;
    var n : int ; n := 0 ;
    var m : int ; m := 0 ;
    var bibs : Sequence(int) ; bibs := null ;
    var result : Sequence(Sequence(int)) ; result := null ;
    var first : boolean ; first := true ;
    try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     if (first) then (     var str : Sequence(String) ; str := line->split(" ") ;
     n := (str[0+1])->toInteger() ; 
    m := (str[1+1])->toInteger() ; 
    bibs := Integer.subrange(1,n + 1)->collect(0) ; 
    i := 0 ; 
    first := false ; 
 ) else (     i := i + 1 ; 
     bibs[i+1] := (line)->toInteger() ; 
     if (i = n) then (         var k : int ; k := 1 ; while k <= m do ( (         var j : int ; j := 1 ; while j < n do ( (     if (bibs[j+1] mod k > bibs[j + 1+1] mod k) then (     var w : int ; w := bibs[j+1] ;
     bibs[j+1] := bibs[j + 1+1] ; 
     bibs[j + 1+1] := w ) else skip )  ;     j := j + 1 ) )  ;     k := k + 1 ) ; 
         var j : int ; j := 1 ; while j < n + 1 do ( (     OclFile["System.out"].println(bibs[j+1]) )  ;     j := j + 1 ) ; 
     break ) else skip ) ) ;     line := br.readLine() ;
 ) ))  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      final int m=sc.nextInt();
      final int n=sc.nextInt();
      if(m==0 && n==0){
        break ;
      }
      int[] books=new int[n];
      for(int i=0 ; i<n ; i++){
        books[i]=sc.nextInt();
      }
      int upper=1000000*n ;
      int lower=1 ;
      while((upper-lower)!=1){
        int med=(upper+lower)/2 ;
        int col=0 ;
        int wid=0 ;
        boolean flag=true ;
        for(int i=0 ; i<n ; i++){
          if(col>=m){
            flag=false ;
            break ;
          }
          if(wid+books[i]>med){
            col++;
            i--;
            wid=0 ;
          }
          else {
            wid+=books[i];
          }
        }
        if(! flag){
          lower=med ;
        }
        else {
          upper=med ;
        }
      }
      System.out.println(upper);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var m : int ; m := sc.getCurrent()->toInteger() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    if (m = 0 & n = 0) then (     break ) else skip ; 
    var books : Sequence(int) ; books := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     books[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var upper : int ; upper := 1000000 * n ;
    var lower : int ; lower := 1 ;
    while ((upper - lower) /= 1) do (     var med : int ; med := (upper + lower) / 2 ;
     var col : int ; col := 0 ;
    var wid : int ; wid := 0 ;
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (col >= m) then (     flag := false ; 
     break ) else skip ; 
     if (wid + books[i+1] > med) then (     col := col + 1 ; 
     i := i - 1 ; 
     wid := 0 ) else (     wid := wid+(books[i+1]) ) )  ;     i := i + 1 ) ; 
    if (not(flag)) then (     lower := med ) else (     upper := med ) ;  
 ) ; 
    OclFile["System.out"].println(upper) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int N=sc.nextInt();
  static int[] A_i=new int[N];
  static int M=sc.nextInt();
  public static void main(String[] args){
    inputBibs();
    swappingBibs();
    for(int i=0 ; i<N ; i++){
      System.out.println(A_i[i]);
    }
  }
  private static void inputBibs(){
    for(int i=0 ; i<N ; i++){
      A_i[i]=sc.nextInt();
    }
  }
  private static void swappingBibs(){
    for(int k=2 ; k<=M ; k++){
      for(int i=0 ; i<N-1 ; i++){
        if(A_i[i] % k>A_i[i+1] % k){
          int tmp ;
          tmp=A_i[i];
          A_i[i]=A_i[i+1];
          A_i[i+1]=tmp ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int := sc.getCurrent()->toInteger();
  static   attribute A_i : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static   attribute M : int := sc.getCurrent()->toInteger();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute inputBibs() ; 
     execute swappingBibs() ; 
         var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].println(A_i[i+1]) )  ;     i := i + 1 ) );
  static   operation inputBibs() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do ( (     A_i[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) );
  static   operation swappingBibs() : void
  pre: true
  post: true
  activity: (         var k : int ; k := 2 ; while k <= M do ( (         var i : int ; i := 0 ; while i < N - 1 do ( (     if (A_i[i+1] mod k > A_i[i + 1+1] mod k) then (     var tmp : int ;
     tmp := A_i[i+1] ; 
     A_i[i+1] := A_i[i + 1+1] ; 
     A_i[i + 1+1] := tmp ) else skip )  ;     i := i + 1 ) )  ;     k := k + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    for(int i=2 ; i<=m ; i++){
      for(int j=0 ; j<n-1 ; j++){
        if(arr[j] % i>arr[j+1] % i){
          int tmp=arr[j];
          arr[j]=arr[j+1];
          arr[j+1]=tmp ;
        }
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int x : arr){
      sb.append(x).append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= m do ( (         var j : int ; j := 0 ; while j < n - 1 do ( (     if (arr[j+1] mod i > arr[j + 1+1] mod i) then (     var tmp : int ; tmp := arr[j+1] ;
     arr[j+1] := arr[j + 1+1] ; 
     arr[j + 1+1] := tmp ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    for (x : arr) do ( (     sb := sb + StringLib.newString(x) + StringLib.newString("\n") )  ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    int max=-1 ;
    for(int i=1 ; i<=s.length()-1 ; i++){
      String x=s.substring(0,i);
      String y=s.substring(i,s.length());
      int xs[]=new int[26];
      int ys[]=new int[26];
      Arrays.fill(xs,0);
      Arrays.fill(ys,0);
      for(int j=0 ; j<x.length(); j++){
        xs[x.charAt(j)-'a']=1 ;
      }
      for(int j=0 ; j<y.length(); j++){
        ys[y.charAt(j)-'a']=1 ;
      }
      int total=0 ;
      for(int j=0 ; j<26 ; j++){
        if(xs[j]==1 & ys[j]==1){
          total++;
        }
      }
      max=Math.max(total,max);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var max : int ; max := -1 ;
        var i : int ; i := 1 ; while i <= s->size() - 1 do ( (     var x : String ; x := s.subrange(0+1,i) ;
     var y : String ; y := s.subrange(i+1,s->size()) ;
    var xs : Sequence(int) ; xs := Integer.subrange(1,26)->collect(0) ;
    var ys : Sequence(int) ; ys := Integer.subrange(1,26)->collect(0) ;
    xs := xs->collect(0) ; 
    ys := ys->collect(0) ; 
        var j : int ; j := 0 ; while j < x->size() do ( (     xs[x->at(j+1) - ('a')->char2byte()+1] := 1 )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < y->size() do ( (     ys[y->at(j+1) - ('a')->char2byte()+1] := 1 )  ;     j := j + 1 ) ; 
    var total : int ; total := 0 ;
        var j : int ; j := 0 ; while j < 26 do ( (     if (xs[j+1] = 1 & ys[j+1] = 1) then (     total := total + 1 ) else skip )  ;     j := j + 1 ) ; 
    max := Set{total, max}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Set ;
import java.util.HashSet ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String s=br.readLine();
    int count=0 ;
    int max=-1 ;
    Set<Character>set=new HashSet<>();
    char[] exist=new char[100];
    for(int i=1 ; i<n ; i++){
      String sub1=s.substring(0,i);
      String sub2=s.substring(i);
      for(int j=0 ; j<sub1.length(); j++){
        if(sub2.contains(String.valueOf(sub1.charAt(j)))&& ! set.contains(sub1.charAt(j)))count++;
        set.add(sub1.charAt(j));
      }
      max=Math.max(max,count);
      count=0 ;
      set.clear();
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var s : String ; s := br.readLine() ;
    var count : int ; count := 0 ;
    var max : int ; max := -1 ;
    var set : Set(String) ; set := Set{} ;
    var exist : Sequence(String) ; exist := Integer.subrange(1,100)->collect(0) ;
        var i : int ; i := 1 ; while i < n do ( (     var sub1 : String ; sub1 := s.subrange(0+1,i) ;
     var sub2 : String ; sub2 := s.subrange(i+1,i) ;
        var j : int ; j := 0 ; while j < sub1->size() do ( (     if (sub2->includes(((sub1->at(j+1)) + "")) & not(set->includes(sub1->at(j+1)))) then     count := count + 1 ; else skip ; 
     set := set->including(sub1->at(j+1)) )  ;     j := j + 1 ) ; 
    max := Set{max, count}->max() ; 
    count := 0 ; 
    set := set->intersection(Set{}) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int CountPS(char str[],int n){
    int dp[][]=new int[n][n];
    boolean P[][]=new boolean[n][n];
    for(int i=0 ; i<n ; i++)P[i][i]=true ;
    for(int i=0 ; i<n-1 ; i++){
      if(str[i]==str[i+1]){
        P[i][i+1]=true ;
        dp[i][i+1]=1 ;
      }
    }
    for(int gap=2 ; gap<n ; gap++){
      for(int i=0 ; i<n-gap ; i++){
        int j=gap+i ;
        if(str[i]==str[j] && P[i+1][j-1])P[i][j]=true ;
        if(P[i][j]==true)dp[i][j]=dp[i][j-1]+dp[i+1][j]+1-dp[i+1][j-1];
        else dp[i][j]=dp[i][j-1]+dp[i+1][j]-dp[i+1][j-1];
      }
    }
    return dp[0][n-1];
  }
  public static void main(String[] args){
    String str="abaab" ;
    System.out.println(CountPS(str.toCharArray(),str.length()));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation CountPS( str : Sequence(String), n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
     var P : Sequence(Sequence(boolean)) ; P := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ;
        var i : int ; i := 0 ; while i < n do (     P[i+1][i+1] := true ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (str[i+1] = str[i + 1+1]) then (     P[i+1][i + 1+1] := true ; 
     dp[i+1][i + 1+1] := 1 ) else skip )  ;     i := i + 1 ) ; 
        var gap : int ; gap := 2 ; while gap < n do ( (         var i : int ; i := 0 ; while i < n - gap do ( (     var j : int ; j := gap + i ;
     if (str[i+1] = str[j+1] & P[i + 1+1][j - 1+1]) then     P[i+1][j+1] := true ; else skip ; 
     if (P[i+1][j+1] = true) then     dp[i+1][j+1] := dp[i+1][j - 1+1] + dp[i + 1+1][j+1] + 1 - dp[i + 1+1][j - 1+1] ; else     dp[i+1][j+1] := dp[i+1][j - 1+1] + dp[i + 1+1][j+1] - dp[i + 1+1][j - 1+1] ; )  ;     i := i + 1 ) )  ;     gap := gap + 1 ) ; 
    return dp[0+1][n - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abaab" ;
     OclFile["System.out"].println(CountPS(str->characters(), str->size())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      new Main().solve(sc);
    }
  }
  void solve(Scanner sc){
    int n=sc.nextInt();
    char[] s=sc.next().toCharArray();
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      Set<Character>startSet=new HashSet<>(i);
      for(int j=0 ; j<i ; j++){
        startSet.add(s[j]);
      }
      Set<Character>endSet=new HashSet<>(n-i);
      for(int j=i ; j<n ; j++){
        endSet.add(s[j]);
      }
      startSet.retainAll(endSet);
      ans=Math.max(ans,startSet.size());
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     Main.newMain().solve(sc) ))  );
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var startSet : Set(String) ; startSet := Set{} ;
         var j : int ; j := 0 ; while j < i do ( (     startSet := startSet->including(s[j+1]) )  ;     j := j + 1 ) ; 
    var endSet : Set(String) ; endSet := Set{}->union(n - i) ;
        var j : int ; j := i ; while j < n do ( (     endSet := endSet->including(s[j+1]) )  ;     j := j + 1 ) ; 
    startSet := startSet->intersection(endSet) ; 
    ans := Set{ans, startSet->size()}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BCutAndCount solver=new BCutAndCount();
    solver.solve(1,in,out);
    out.close();
  }
  static class BCutAndCount {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      String s=in.next();
      int max=0 ;
      for(int i=0 ; i<s.length(); i++){
        String a=s.substring(0,i);
        String b=s.substring(i,s.length());
        int count=0 ;
        boolean[] used=new boolean[26];
        outer : for(char c : a.toCharArray()){
          if(used[c-97]){
            continue outer ;
          }
          for(char d : b.toCharArray()){
            if(c==d){
              count++;
              used[c-97]=true ;
              continue outer ;
            }
          }
        }
        if(count>max){
          max=count ;
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BCutAndCount ; solver := BCutAndCount.newBCutAndCount() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BCutAndCount {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var s : String ; s := in.getCurrent() ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var a : String ; a := s.subrange(0+1,i) ;
     var b : String ; b := s.subrange(i+1,s->size()) ;
    var count : int ; count := 0 ;
    var used : Sequence(boolean) ; used := Integer.subrange(1,26)->collect(false) ;
    for (c : a->characters()) do ( (     if (used[c - 97+1]) then (     continue ) else skip ; 
     for (d : b->characters()) do ( (     if (c = d) then (     count := count + 1 ; 
     used[c - 97+1] := true ; 
     continue ) else skip )  ) )  ) ; 
    if (count > max) then (     max := count ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int N=gi();
    String S=gs();
    int max=0 ;
    for(int i=1 ; i<N-1 ; i++){
      String S1=S.substring(0,i);
      String S2=S.substring(i);
      String S3="" ;
      int c=0 ;
      for(int j=0 ; j<S1.length(); j++){
        String m=S1.substring(j,j+1);
        if(S2.contains(m)&& ! S3.contains(m)){
          S3+=m ;
          c++;
        }
      }
      if(c>max){
        max=c ;
      }
    }
    System.out.println(max);
  }
  public static long d(long n){
    String a=String.valueOf(n);
    return(long)a.length();
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : int ; N := gi() ;
    var S : String ; S := gs() ;
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i < N - 1 do ( (     var S1 : String ; S1 := S.subrange(0+1,i) ;
     var S2 : String ; S2 := S.subrange(i+1,i) ;
    var S3 : String ; S3 := "" ;
    var c : int ; c := 0 ;
        var j : int ; j := 0 ; while j < S1->size() do ( (     var m : String ; m := S1.subrange(j+1,j + 1) ;
     if (S2->includes(m) & not(S3->includes(m))) then (     S3 := S3+(m) ; 
     c := c + 1 ) else skip )  ;     j := j + 1 ) ; 
    if (c > max) then (     max := c ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static   operation d( n : long) : long
  pre: true
  post: true
  activity: (     var a : String ; a := ((n) + "") ;
     return a->size()->oclAsType(long) );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    StringTokenizer st=new StringTokenizer(br.readLine());
    int N,M,T ;
    N=parseInt(st.nextToken());
    M=parseInt(st.nextToken());
    T=parseInt(st.nextToken());
    int a[]=new int[N+2];
    a[0]=-M ;
    a[N+1]=T+M ;
    st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<N ; i++){
      a[i+1]=parseInt(st.nextToken());
    }
    int t=0 ;
    for(int i=1 ; i<N+2 ; i++){
      t+=a[i]-a[i-1]>2*M ? a[i]-a[i-1]-2*M : 0 ;
    }
    System.out.println(t);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var N : int ;
    var M : int ;
    var T : int ;
    N := (st.next() + "")->toInteger() ; 
    M := (st.next() + "")->toInteger() ; 
    T := (st.next() + "")->toInteger() ; 
    var a : Sequence(int) ; a := Integer.subrange(1,N + 2)->collect(0) ;
    a[0+1] := -M ; 
    a[N + 1+1] := T + M ; 
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < N do ( (     a[i + 1+1] := (st.next() + "")->toInteger() )  ;     i := i + 1 ) ; 
    var t : int ; t := 0 ;
        var i : int ; i := 1 ; while i < N + 2 do ( (     t := t+(if a[i+1] - a[i - 1+1] > 2 * M then a[i+1] - a[i - 1+1] - 2 * M else 0 endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(t) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static void solve(){
    int n=in.nextInt();
    int m=in.nextInt();
    int t=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    boolean[] f=new boolean[t*2];
    for(int i=0 ; i<n ; i++){
      for(int j=a[i]-m ; j<a[i]+m ; j++){
        f[j]=true ;
      }
    }
    int ans=0 ;
    for(int i=0 ; i<t ; i++){
      if(! f[i])ans++;
    }
    dump(f);
    out.println(ans);
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    solve();
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var t : int ; t := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var f : Sequence(boolean) ; f := Integer.subrange(1,t * 2)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := a[i+1] - m ; while j < a[i+1] + m do ( (     f[j+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < t do ( (     if (not(f[i+1])) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    execute dump(f) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    execute solve() ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  int m=0,n=0 ;
  int[] w=null ;
  boolean IsStorable(int width){
    int row=0,c=0,i=0 ;
    while(i<n){
      if(c+w[i]<=width){
        c+=w[i];
++i ;
      }
      else if(++row<m)c=0 ;
      else return false ;
    }
    return true ;
  }
  void solve(){
    Scanner sc=new Scanner(System.in);
    while(true){
      m=sc.nextInt();
      n=sc.nextInt();
      if(m==0 && n==0)break ;
      w=new int[n];
      for(int i=0 ; i<n ; ++i)w[i]=sc.nextInt();
      int minw=1,maxw=1500000 ;
      if(! IsStorable(maxw))System.out.println("NA");
      while(maxw>minw){
        int mid=(maxw+minw)/2 ;
        if(IsStorable(mid))maxw=mid ;
        else minw=mid+1 ;
      }
      System.out.println(minw);
    }
  }
  public static void main(String[] a){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute m : int := 0;
   attribute w : Sequence(int) := null;
   operation IsStorable( width : int) : boolean
  pre: true
  post: true
  activity: (     var row : int ; row := 0 ;
    var c : int ; c := 0 ;
    var i : int ; i := 0 ;
     while (i < n) do (     if (c + w[i+1] <= width) then (     c := c+(w[i+1]) ; 
     i := i + 1 ) else     if ((row + 1) < m) then     c := 0 else     return false ;  ) ; 
     return true );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     m := sc.getCurrent()->toInteger() ; 
     n := sc.getCurrent()->toInteger() ; 
    if (m = 0 & n = 0) then     break else skip ; 
    w := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     w[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var minw : int ; minw := 1 ;
    var maxw : int ; maxw := 1500000 ;
    if (not(IsStorable(maxw))) then     OclFile["System.out"].println("NA") ; else skip ; 
    while (maxw > minw) do (     var mid : int ; mid := (maxw + minw) / 2 ;
     if (IsStorable(mid)) then     maxw := mid ; else     minw := mid + 1 ; ) ; 
    OclFile["System.out"].println(minw) ; 
 ) );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public void run(){
    int n=sc.nextInt();
    int m=sc.nextInt();
    int t=sc.nextInt();
    calc(n,m,t);
  }
  public void calc(int n,int m,int t){
    int[] memo=new int[10000];
    int before=0 ;
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      int start=a-m ;
      int end=a+m ;
      if(start<before)start=before ;
      for(int j=start ; j<end ; j++){
        if(j<t)memo[j]=-1 ;
      }
    }
    int sum=t ;
    for(int i=0 ; i<t ; i++){
      sum+=memo[i];
    }
    System.out.println(sum);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     execute calc(n, m, t) );
   operation calc( n : int, m : int, t : int) : void
  pre: true
  post: true
  activity: (     var memo : Sequence(int) ; memo := Integer.subrange(1,10000)->collect(0) ;
     var before : int ; before := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var start : int ; start := a - m ;
    var end : int ; end := a + m ;
    if (start < before) then     start := before ; else skip ; 
        var j : int ; j := start ; while j < end do ( (     if (j < t) then     memo[j+1] := -1 ; else skip )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    var sum : int ; sum := t ;
        var i : int ; i := 0 ; while i < t do ( (     sum := sum+(memo[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner scn=new Scanner(System.in);
    int N,M,T ;
    int a1,a2,delta=0 ;
    N=scn.nextInt();
    M=scn.nextInt();
    T=scn.nextInt();
    a1=scn.nextInt();
    for(int i=1 ; i<N ; i++){
      a2=scn.nextInt();
      delta+=2*M>a2-a1 ? 2*M+a1-a2 : 0 ;
      a1=a2 ;
    }
    a2=T+M ;
    delta+=2*M>a2-a1 ? 2*M+a1-a2 : 0 ;
    scn.close();
    System.out.println(T+delta-2*M*N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ;
    var M : int ;
    var T : int ;
    var a1 : int ;
    var a2 : int ;
    var delta : int ; delta := 0 ;
    N := scn.getCurrent()->toInteger() ; 
    M := scn.getCurrent()->toInteger() ; 
    T := scn.getCurrent()->toInteger() ; 
    a1 := scn.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i < N do ( (     a2 := scn.getCurrent()->toInteger() ; 
     delta := delta+(if 2 * M > a2 - a1 then 2 * M + a1 - a2 else 0 endif) ; 
     a1 := a2 )  ;     i := i + 1 ) ; 
    a2 := T + M ; 
    delta := delta+(if 2 * M > a2 - a1 then 2 * M + a1 - a2 else 0 endif) ; 
    skip ; 
    OclFile["System.out"].println(T + delta - 2 * M * N) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] tmpArray=br.readLine().split(" ");
    int n=Integer.parseInt(tmpArray[0]);
    int m=Integer.parseInt(tmpArray[1]);
    int t=Integer.parseInt(tmpArray[2]);
    String delivery=br.readLine();
    System.out.println(solve(delivery,n,m,t));
  }
  static int solve(String delivery,int n,int m,int t){
    String[] tmpArray=delivery.split(" ");
    int delTime[]=new int[n];
    int outsideTime=0 ;
    for(int i=0 ; i<n ; i++){
      delTime[i]=Integer.parseInt(tmpArray[i]);
    }
    for(int i=0 ; i<n ; i++){
      if(i==0){
        outsideTime+=m ;
      }
      else if(delTime[i]-delTime[i-1]>m*2){
        outsideTime+=m*2 ;
      }
      else {
        outsideTime+=delTime[i]-delTime[i-1];
      }
    }
    outsideTime+=Math.min(m,t-delTime[n-1]);
    return t-outsideTime ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
    var n : int ; n := (tmpArray[0+1])->toInteger() ;
    var m : int ; m := (tmpArray[1+1])->toInteger() ;
    var t : int ; t := (tmpArray[2+1])->toInteger() ;
    var delivery : String ; delivery := br.readLine() ;
    OclFile["System.out"].println(solve(delivery, n, m, t)) ; 
 );
  static   operation solve( delivery : String, n : int, m : int, t : int) : int
  pre: true
  post: true
  activity: (     var tmpArray : Sequence(String) ; tmpArray := delivery->split(" ") ;
     var delTime : Sequence(int) ; delTime := Integer.subrange(1,n)->collect(0) ;
    var outsideTime : int ; outsideTime := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     delTime[i+1] := (tmpArray[i+1])->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i = 0) then (     outsideTime := outsideTime+(m) ) else     if (delTime[i+1] - delTime[i - 1+1] > m * 2) then (     outsideTime := outsideTime+(m * 2) ) else (     outsideTime := outsideTime+(delTime[i+1] - delTime[i - 1+1]) ) ;  )  ;     i := i + 1 ) ; 
    outsideTime := outsideTime+(Set{m, t - delTime[n - 1+1]}->min()) ; 
    return t - outsideTime 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int coin(int totalRupees,int X,int Y,int Z){
    float one=0,fifty=0,twentyfive=0,result=0,total=0 ;
    one=X*1 ;
    fifty=((Y*1)/2);
    twentyfive=((Z*1)/4);
    total=one+fifty+twentyfive ;
    result=((totalRupees)/total);
    return(int)result ;
  }
  public static void main(String[] args){
    int totalRupees=1800 ;
    int X=1,Y=2,Z=4 ;
    int Rupees=coin(totalRupees,X,Y,Z);
    System.out.println("1 rupess coins="+Rupees*1);
    System.out.println("50 paisa coins="+Rupees*2);
    System.out.println("25 paisa coins="+Rupees*4);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation coin( totalRupees : int, X : int, Y : int, Z : int) : int
  pre: true
  post: true
  activity: (     var one : double ; one := 0 ;
    var fifty : double ; fifty := 0 ;
    var twentyfive : double ; twentyfive := 0 ;
    var result : double ; result := 0 ;
    var total : double ; total := 0 ;
     one := X * 1 ; 
    fifty := ((Y * 1) / 2) ; 
    twentyfive := ((Z * 1) / 4) ; 
    total := one + fifty + twentyfive ; 
    result := ((totalRupees) / total) ; 
    return result->oclAsType(int) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var totalRupees : int ; totalRupees := 1800 ;
     var X : int ; X := 1 ;
    var Y : int ; Y := 2 ;
    var Z : int ; Z := 4 ;
    var Rupees : int ; Rupees := coin(totalRupees, X, Y, Z) ;
    OclFile["System.out"].println("1 rupess coins=" + Rupees * 1) ; 
    OclFile["System.out"].println("50 paisa coins=" + Rupees * 2) ; 
    OclFile["System.out"].println("25 paisa coins=" + Rupees * 4) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int numberOfPaths(int m,int n){
    int[] dp=new int[n];
    dp[0]=1 ;
    for(int i=0 ; i<m ; i++){
      for(int j=1 ; j<n ; j++){
        dp[j]+=dp[j-1];
      }
    }
    return dp[n-1];
  }
  public static void main(String args[]){
    System.out.println(numberOfPaths(3,3));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation numberOfPaths( m : int, n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
     dp[0+1] := 1 ; 
         var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 1 ; while j < n do ( (     dp[j+1] := dp[j+1]+(dp[j - 1+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return dp[n - 1+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(numberOfPaths(3, 3)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sum(int h){
    return(int)Math.pow(2,h-1);
  }
  public static void main(String[] args){
    int L=3 ;
    System.out.println(sum(L));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sum( h : int) : int
  pre: true
  post: true
  activity: (     return 2->pow(h - 1)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 3 ;
     OclFile["System.out"].println(sum(L)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Odd_Selection {
  static InputStreamReader r=new InputStreamReader(System.in);
  static BufferedReader br=new BufferedReader(r);
  static PrintWriter p=new PrintWriter(System.out);
  public static void main(String[] args)throws Exception {
    int test=1 ;
    me146 : while(test-->0){
      String str[]=splitString();
      int n=Integer.parseInt(str[0]);
      long capacity=Long.parseLong(str[1]);
      long process=Long.parseLong(str[2]);
      str=splitString();
      long a[]=new long[n];
      for(int i=0 ; i<n ; i++)a[i]=Long.parseLong(str[i]);
      int index=0 ;
      long filled=0 ;
      long answer=0 ;
      while(index<n){
        long remaining=capacity-filled ;
        if(remaining>=a[index]){
          filled+=a[index];
          index++;
        }
        else {
          long x=(long)Math.ceil((a[index]-remaining)*1.0/process);
          answer+=x ;
          filled=Math.max(0,filled-x*process);
        }
      }
      long x=(long)Math.ceil(filled*1.0/process);
      answer+=x ;
      p.println(answer);
    }
    p.flush();
  }
  static String formatString(String s){
    int len=s.length();
    for(int i=0 ; i<19-len ; i++){
      s="0"+s ;
    }
    return s ;
  }
  static String[] splitString()throws IOException {
    return br.readLine().trim().split(" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Odd_Selection {
  static   attribute r : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute br : OclFile := OclFile.newOclFile_Read(r);
  static   attribute p : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var test : int ; test := 1 ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var str : Sequence(String) ; str := splitString() ;
     var n : int ; n := (str[0+1])->toInteger() ;
    var capacity : long ; capacity := (str[1+1])->toLong() ;
    var process : long ; process := (str[2+1])->toLong() ;
    str := splitString() ; 
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (str[i+1])->toLong() ;  ;     i := i + 1 ) ; 
    var index : int ; index := 0 ;
    var filled : long ; filled := 0 ;
    var answer : long ; answer := 0 ;
    while (index < n) do (     var remaining : long ; remaining := capacity - filled ;
     if (remaining >= a[index+1]) then (     filled := filled+(a[index+1]) ; 
     index := index + 1 ) else (     var x : long ; x := ((a[index+1] - remaining) * 1.0 / process)->ceil()->oclAsType(long) ;
     answer := answer+(x) ; 
     filled := Set{0, filled - x * process}->max() ) ) ; 
    var x : long ; x := (filled * 1.0 / process)->ceil()->oclAsType(long) ;
    answer := answer+(x) ; 
    skip ; 
 ) ;  ) ;  
     skip );
  static   operation formatString( s : String) : String
  pre: true
  post: true
  activity: (     var len : int ; len := s->size() ;
         var i : int ; i := 0 ; while i < 19 - len do ( (     s := "0" + s )  ;     i := i + 1 ) ; 
     return s );
  static   operation splitString() : Sequence(String)
  pre: true
  post: true
  activity: (     return br.readLine()->trim()->split(" ") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
public class B_Vanya_and_Food_Processor {
  static BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException {
    int[] l1=readArray();
    int n=l1[0];
    int h=l1[1];
    int k=l1[2];
    int[] pieces=readArray();
    long seconds=0 ;
    int content=0 ;
    int i=0 ;
    while(true){
      while(i<n && content+pieces[i]<=h){
        content+=pieces[i++];
      }
      if(i==n){
        seconds+=Math.ceil((double)content/(double)k);
        break ;
      }
      else if(content<k){
        seconds++;
        content=0 ;
      }
      else {
        seconds+=(long)(content/k);
        content %=k ;
      }
    }
    out.println(seconds);
    out.close();
  }
  private static String read()throws IOException {
    return in.readLine();
  }
  private static int readInt()throws IOException {
    return Integer.parseInt(in.readLine());
  }
  private static int[] readArray()throws IOException {
    String[] line=in.readLine().split("\\s");
    int[] a=Arrays.stream(line).mapToInt(Integer :: parseInt).toArray();
    return a ;
  }
  private static int[] readSortedArray()throws IOException {
    String[] line=in.readLine().split("\\s");
    int[] a=Arrays.stream(line).mapToInt(Integer :: parseInt).sorted().toArray();
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Vanya_and_Food_Processor {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l1 : Sequence(int) ; l1 := readArray() ;
     var n : int ; n := l1[0+1] ;
    var h : int ; h := l1[1+1] ;
    var k : int ; k := l1[2+1] ;
    var pieces : Sequence(int) ; pieces := readArray() ;
    var seconds : long ; seconds := 0 ;
    var content : int ; content := 0 ;
    var i : int ; i := 0 ;
    while (true) do (     while (i < n & content + pieces[i+1] <= h) do (      content := content + pieces[i+1]  ; i := i + 1 ) ; 
     if (i = n) then (     seconds := seconds+((content->oclAsType(double) / k->oclAsType(double))->ceil()) ; 
     break ) else     if (content < k) then (     seconds := seconds + 1 ; 
     content := 0 ) else (     seconds := seconds+((content / k)->oclAsType(long)) ; 
     content := content mod k ) ;  ) ; 
    skip ; 
    skip ; 
 );
  static   operation read() : String
  pre: true
  post: true
  activity: (     return in.readLine() );
  static   operation readInt() : int
  pre: true
  post: true
  activity: (     return (in.readLine())->toInteger() );
  static   operation readArray() : Sequence(int)
  pre: true
  post: true
  activity: (     var line : Sequence(String) ; line := in.readLine()->split("\\s") ;
     var a : Sequence(int) ; a := stream(line)->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
     return a );
  static   operation readSortedArray() : Sequence(int)
  pre: true
  post: true
  activity: (     var line : Sequence(String) ; line := in.readLine()->split("\\s") ;
     var a : Sequence(int) ; a := stream(line)->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->sort()->asSequence() ;
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isVowel(char ch){
    if(ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u')return true ;
    return false ;
  }
  static String createAltStr(String str1,String str2,int start,int l){
    String finalStr="" ;
    for(int i=0,j=start ; j<l ; i++,j++)finalStr=(finalStr+str1.charAt(i))+str2.charAt(j);
    return finalStr ;
  }
  static String findAltStr(String str){
    int nv=0,nc=0 ;
    String vstr="",cstr="" ;
    int l=str.length();
    for(int i=0 ; i<l ; i++){
      char ch=str.charAt(i);
      if(isVowel(ch)){
        nv++;
        vstr=vstr+ch ;
      }
      else {
        nc++;
        cstr=cstr+ch ;
      }
    }
    if(Math.abs(nv-nc)>=2)return "no such string" ;
    if(nv>nc)return(vstr.charAt(0)+createAltStr(cstr,vstr,1,nv));
    if(nc>nv)return(cstr.charAt(0)+createAltStr(vstr,cstr,1,nc));
    if(cstr.charAt(0)<vstr.charAt(0))return createAltStr(cstr,vstr,0,nv);
    return createAltStr(vstr,cstr,0,nc);
  }
  public static void main(String args[]){
    String str="geeks" ;
    System.out.println(findAltStr(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isVowel( ch : String) : boolean
  pre: true
  post: true
  activity: (     if (ch = 'a' or ch = 'e' or ch = 'i' or ch = 'o' or ch = 'u') then     return true else skip ; 
     return false );
  static   operation createAltStr( str1 : String, str2 : String, start : int, l : int) : String
  pre: true
  post: true
  activity: (     var finalStr : String ; finalStr := "" ;
         var i : int ; i := 0 ;
    var j : int ; j := start ; while j < l do (     finalStr := (finalStr + str1->at(i+1)) + str2->at(j+1) ;  ;     i := i + 1 ;     j := j + 1 ) ; 
     return finalStr );
  static   operation findAltStr( str : String) : String
  pre: true
  post: true
  activity: (     var nv : int ; nv := 0 ;
    var nc : int ; nc := 0 ;
     var vstr : String ; vstr := "" ;
    var cstr : String ; cstr := "" ;
    var l : int ; l := str->size() ;
        var i : int ; i := 0 ; while i < l do ( (     var ch : String ; ch := str->at(i+1) ;
     if (isVowel(ch)) then (     nv := nv + 1 ; 
     vstr := vstr + ch ) else (     nc := nc + 1 ; 
     cstr := cstr + ch ) )  ;     i := i + 1 ) ; 
    if (if nv - nc < 0 then -(nv - nc) else nv - nc endif >= 2) then     return "no such string" else skip ; 
    if (nv > nc) then     return (vstr->at(0+1) + createAltStr(cstr, vstr, 1, nv)) else skip ; 
    if (nc > nv) then     return (cstr->at(0+1) + createAltStr(vstr, cstr, 1, nc)) else skip ; 
    if (cstr->at(0+1) < vstr->at(0+1)) then     return createAltStr(cstr, vstr, 0, nv) else skip ; 
    return createAltStr(vstr, cstr, 0, nc) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeks" ;
     OclFile["System.out"].println(findAltStr(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static final int SIZE=26 ;
  static boolean isVowel(char ch){
    if(ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u'){
      return true ;
    }
    return false ;
  }
  static String createAltStr(String str1,String str2,int start,int l){
    String finalStr="" ;
    for(int i=0,j=start ; j<l ; i++,j++){
      finalStr=(finalStr+str1.charAt(i))+str2.charAt(j);
    }
    return finalStr ;
  }
  static String findAltStr(String str){
    int char_freq[]=new int[SIZE];
    Arrays.fill(char_freq,0);
    int nv=0,nc=0 ;
    String vstr="",cstr="" ;
    int l=str.length();
    for(int i=0 ; i<l ; i++){
      char ch=str.charAt(i);
      if(isVowel(ch)){
        nv++;
      }
      else {
        nc++;
      }
      char_freq[ch-97]++;
    }
    if(Math.abs(nv-nc)>=2){
      return "no such String" ;
    }
    for(int i=0 ; i<SIZE ; i++){
      char ch=(char)(i+97);
      for(int j=1 ; j<=char_freq[i]; j++){
        if(isVowel(ch)){
          vstr+=ch ;
        }
        else {
          cstr+=ch ;
        }
      }
    }
    if(nv>nc){
      return(vstr.charAt(0)+createAltStr(cstr,vstr,1,nv));
    }
    if(nc>nv){
      return(cstr.charAt(0)+createAltStr(vstr,cstr,1,nc));
    }
    if(cstr.charAt(0)<vstr.charAt(0)){
      return createAltStr(cstr,vstr,0,nv);
    }
    return createAltStr(vstr,cstr,0,nc);
  }
  public static void main(String[] args){
    String str="aeroplane" ;
    System.out.println(findAltStr(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute SIZE : int := 26;
  static   operation isVowel( ch : String) : boolean
  pre: true
  post: true
  activity: (     if (ch = 'a' or ch = 'e' or ch = 'i' or ch = 'o' or ch = 'u') then (     return true ) else skip ; 
     return false );
  static   operation createAltStr( str1 : String, str2 : String, start : int, l : int) : String
  pre: true
  post: true
  activity: (     var finalStr : String ; finalStr := "" ;
         var i : int ; i := 0 ;
    var j : int ; j := start ; while j < l do ( (     finalStr := (finalStr + str1->at(i+1)) + str2->at(j+1) )  ;     i := i + 1 ;     j := j + 1 ) ; 
     return finalStr );
  static   operation findAltStr( str : String) : String
  pre: true
  post: true
  activity: (     var char_freq : Sequence(int) ; char_freq := Integer.subrange(1,SIZE)->collect(0) ;
     char_freq := char_freq->collect(0) ; 
    var nv : int ; nv := 0 ;
    var nc : int ; nc := 0 ;
    var vstr : String ; vstr := "" ;
    var cstr : String ; cstr := "" ;
    var l : int ; l := str->size() ;
        var i : int ; i := 0 ; while i < l do ( (     var ch : String ; ch := str->at(i+1) ;
     if (isVowel(ch)) then (     nv := nv + 1 ) else (     nc := nc + 1 ) ;  
     char_freq[(ch)->char2byte() - 97+1] := char_freq[(ch)->char2byte() - 97+1] + 1 )  ;     i := i + 1 ) ; 
    if (if nv - nc < 0 then -(nv - nc) else nv - nc endif >= 2) then (     return "no such String" ) else skip ; 
        var i : int ; i := 0 ; while i < SIZE do ( (     var ch : String ; ch := (i + 97)->oclAsType(String) ;
         var j : int ; j := 1 ; while j <= char_freq[i+1] do ( (     if (isVowel(ch)) then (     vstr := vstr+(ch) ) else (     cstr := cstr+(ch) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (nv > nc) then (     return (vstr->at(0+1) + createAltStr(cstr, vstr, 1, nv)) ) else skip ; 
    if (nc > nv) then (     return (cstr->at(0+1) + createAltStr(vstr, cstr, 1, nc)) ) else skip ; 
    if (cstr->at(0+1) < vstr->at(0+1)) then (     return createAltStr(cstr, vstr, 0, nv) ) else skip ; 
    return createAltStr(vstr, cstr, 0, nc) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "aeroplane" ;
     OclFile["System.out"].println(findAltStr(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
class Stuff implements Comparable<Stuff>{
  int v ;
  int w ;
  double performance ;
  Stuff(int v,int w){
    this.v=v ;
    this.w=w ;
    performance=1.0*v/w ;
  }
  public int compareTo(Stuff s){
    if(performance<s.performance)return 1 ;
    if(performance>s.performance)return-1 ;
    return 0 ;
  }
}
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int w=sc.nextInt();
    PriorityQueue<Stuff>que=new PriorityQueue<>();
    for(int i=0 ; i<n ; i++){
      int vi=sc.nextInt();
      int wi=sc.nextInt();
      que.add(new Stuff(vi,wi));
    }
    double res=0 ;
    while(w>0 && ! que.isEmpty()){
      Stuff s=que.poll();
      if(w>=s.w){
        res+=s.v ;
        w-=s.w ;
      }
      else {
        res+=s.performance*w ;
        w=0 ;
      }
    }
    System.out.println(BigDecimal.valueOf(res).toPlainString());
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Stuff implements Comparable<Stuff> {
   attribute v : int;
   attribute w : int;
   attribute performance : double;
   static operation newStuff( v : int, w : int) : Stuff
  pre: true
  post: true
  activity:
  ( var self : Stuff ;
    self := createStuff();
    self.initialise(v, w);
    return self );
  operation initialise( v : int, w : int) : void
  pre: true  post: true
  activity: (     self.v := v ; 
     self.w := w ; 
     performance := 1.0 * v / w );
   operation compareTo( s : Stuff) : int
  pre: true
  post: true
  activity: (     if (performance < s.performance) then     return 1 else skip ; 
     if (performance > s.performance) then     return -1 else skip ; 
     return 0 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var que : Sequence(Stuff) ; que := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var vi : int ; vi := sc.getCurrent()->toInteger() ;
     var wi : int ; wi := sc.getCurrent()->toInteger() ;
     que := que->including(Stuff.newStuff(vi, wi)) )  ;     i := i + 1 ) ; 
    var res : double ; res := 0 ;
    while (w > 0 & not(que->isEmpty())) do (     var s : Stuff ; s := que->min() ;
     if (w >= s.w) then (     res := res+(s.v) ; 
     w := w-(s.w) ) else (     res := res+(s.performance * w) ; 
     w := 0 ) ) ; 
    OclFile["System.out"].println((res + "")->toReal().toPlainString()) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  static class Tree {
    final String name ;
    final ArrayList<Tree>a=new ArrayList<Tree>();
    Tree(String name){
      this.name=name ;
    }
    int size(){
      if(a.size()==0)return 1 ;
      int ans=1 ;
      for(Tree t : a)ans+=t.size();
      return ans ;
    }
    void out(String s){
      System.out.println(s+name);
      for(Tree t : a)t.out(s+"  ");
    }
    void out(){
      out("");
    }
  }
  static void add(Tree t,String d){
    String[] ss=d.substring(1).split("/");
    for(String s : ss){
      Tree w=null ;
      for(Tree r : t.a)if(r.name.equals(s)){
        w=r ;
        break ;
      }
      if(w==null){
        w=new Tree(s);
        t.a.add(w);
      }
      t=w ;
    }
  }
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(new File("Main.in"));
    PrintWriter out=new PrintWriter(new File("Main.out"));
    int tests=in.nextInt();
    for(int test=1 ; test<=tests ; test++){
      out.print("Case #"+test+": ");
      int n=in.nextInt();
      int m=in.nextInt();
      in.nextLine();
      Tree t=new Tree("");
      for(int i=0 ; i<n ; i++){
        String d=in.nextLine();
        add(t,d);
      }
      int was=t.size();
      for(int i=0 ; i<m ; i++){
        String d=in.nextLine();
        add(t,d);
      }
      out.println(t.size()-was);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Tree {
   attribute name : String;
   attribute a : Sequence(Tree) := Sequence{};
   static operation newTree( name : String) : Tree
  pre: true
  post: true
  activity:
  ( var self : Tree ;
    self := createTree();
    self.initialise(name);
    return self );
  operation initialise( name : String) : void
  pre: true  post: true
  activity: (     self.name := name );
   operation size() : int
  pre: true
  post: true
  activity: (     if (a->size() = 0) then     return 1 else skip ; 
     var ans : int ; ans := 1 ;
     for (t : a) do (     ans := ans+(t->size()) ;  ) ; 
     return ans );
   operation out( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s + name) ; 
     for (t : a) do (     t.out(s + "  ") ;  ) );
   operation out() : void
  pre: true
  post: true
  activity: (     execute out("") );
}
  static   operation add( t : Tree, d : String) : void
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := d.subrange(1+1,1)->split("/") ;
     for (s : ss) do ( (     var w : Tree ; w := null ;
     for (r : t.a) do (     if (r.name = s) then (     w := r ; 
     break ) else skip ;  ) ; 
     if (w = null) then (     w := Tree.newTree(s) ; 
     t.a->excludes(w) ) else skip ; 
     t := w )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("Main.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("Main.out")) ;
    var tests : int ; tests := in.getCurrent()->toInteger() ;
        var test : int ; test := 1 ; while test <= tests do ( (     skip ; 
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    skip ; 
    var t : Tree ; t := Tree.newTree("") ;
        var i : int ; i := 0 ; while i < n do ( (     var d : String ; d := in.nextLine() ;
     execute add(t, d) )  ;     i := i + 1 ) ; 
    var was : int ; was := t->size() ;
        var i : int ; i := 0 ; while i < m do ( (     var d : String ; d := in.nextLine() ;
     execute add(t, d) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     test := test + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Solution {
  class Tree {
    Map<String,Tree>mp=new HashMap<String,Tree>();
    public Tree(){
    }
  }
  Tree root ;
  int res ;
  void process(String s,boolean add){
    s=s.substring(1);
    String[] items=s.split("/");
    Tree cur=root ;
    for(int i=0 ; i<items.length ; i++){
      if(! cur.mp.containsKey(items[i])){
        cur.mp.put(items[i],new Tree());
        if(add)res++;
      }
      cur=cur.mp.get(items[i]);
    }
  }
  public void doMain()throws Exception {
    Scanner sc=new Scanner(new FileReader("input.txt"));
    PrintWriter pw=new PrintWriter(new FileWriter("output.txt"));
    int caseCnt=sc.nextInt();
    long time=System.currentTimeMillis();
    for(int caseNum=1 ; caseNum<=caseCnt ; caseNum++){
      int have=sc.nextInt(),next=sc.nextInt();
      root=new Tree();
      res=0 ;
      for(int i=0 ; i<have ; i++){
        process(sc.next(),false);
      }
      for(int i=0 ; i<next ; i++)process(sc.next(),true);
      pw.println("Case #"+caseNum+": "+res);
      System.out.println("Finished testcase "+caseNum+",time="+(System.currentTimeMillis()-time));
    }
    pw.flush();
    pw.close();
    sc.close();
  }
  public static void main(String[] args)throws Exception {
(new Solution()).doMain();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
 class Tree {
   attribute mp : Map(String,Tree) := Map{};
   static operation newTree() : Tree
  pre: true
  post: true
  activity:
  ( var self : Tree ;
    self := createTree();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
}
   attribute root : Tree;
   attribute res : int;
   operation process( s : String, add : boolean) : void
  pre: true
  post: true
  activity: (     s := s.subrange(1+1,1) ; 
     var items : Sequence(String) ; items := s->split("/") ;
     var cur : Tree ; cur := root ;
         var i : int ; i := 0 ; while i < items->size() do ( (     if (not(cur.mp.containsKey(items[i+1]))) then (     cur := cur.mp->union(Map{items[i+1] |-> Tree.newTree()}) ; 
     if (add) then     res := res + 1 ; else skip ) else skip ; 
     cur := cur.mp->at(items[i+1]+1) )  ;     i := i + 1 ) );
   operation doMain() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt"))) ;
    var caseCnt : int ; caseCnt := sc.getCurrent()->toInteger() ;
    var time : long ; time := OclDate.getSystemTime() ;
        var caseNum : int ; caseNum := 1 ; while caseNum <= caseCnt do ( (     var have : int ; have := sc.getCurrent()->toInteger() ;
    var next : int ; next := sc.getCurrent()->toInteger() ;
     root := Tree.newTree() ; 
    res := 0 ; 
        var i : int ; i := 0 ; while i < have do ( (     execute process(sc.getCurrent(), false) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < next do (     execute process(sc.getCurrent(), true) ;  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.out"].println("Finished testcase " + caseNum + ",time=" + (OclDate.getSystemTime() - time)) ; 
 )  ;     caseNum := caseNum + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Solution.newSolution()).doMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.*;
public class A {
  public void solve()throws FileNotFoundException {
    Scanner in=new Scanner(new File("A-large.in"));
    PrintWriter out=new PrintWriter("A-large.out");
    int testN=in.nextInt();
    for(int test=1 ; test<=testN ; test++){
      out.print("Case #"+test+": ");
      int n=in.nextInt();
      int m=in.nextInt();
      String[] exists=new String[n];
      String[] create=new String[m];
      Set<String>ex=new HashSet<String>();
      for(int i=0 ; i<n ; i++){
        exists[i]=in.next();
        String[] t=exists[i] .split("/");
        String r="" ;
        for(int j=1 ; j<t.length ; j++){
          r=r+"/"+t[j];
          ex.add(r);
        }
      }
      Set<String>need=new TreeSet<String>();
      for(int i=0 ; i<m ; i++){
        create[i]=in.next();
        String[] t=create[i] .split("/");
        String r="" ;
        for(int j=1 ; j<t.length ; j++){
          r=r+"/"+t[j];
          need.add(r);
        }
      }
      int res=0 ;
      for(String s : need){
        if(! ex.contains(s)){
          res++;
          ex.add(s);
        }
      }
      out.println(res);
    }
    in.close();
    out.close();
  }
  public static void main(String[] args)throws FileNotFoundException {
    new A().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   operation solve() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("A-large.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("A-large.out")) ;
    var testN : int ; testN := in.getCurrent()->toInteger() ;
        var test : int ; test := 1 ; while test <= testN do ( (     skip ; 
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var exists : Sequence(String) ; exists := Integer.subrange(1,n)->collect(null) ;
    var create : Sequence(String) ; create := Integer.subrange(1,m)->collect(null) ;
    var ex : Set(String) ; ex := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     exists[i+1] := in.getCurrent() ; 
     var t : Sequence(String) ; t := exists[i+1]->split("/") ;
     var r : String ; r := "" ;
         var j : int ; j := 1 ; while j < t->size() do ( (     r := r + "/" + t[j+1] ; 
     ex := ex->including(r) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var need : Set(String) ; need := Set{} ;
        var i : int ; i := 0 ; while i < m do ( (     create[i+1] := in.getCurrent() ; 
     var t : Sequence(String) ; t := create[i+1]->split("/") ;
     var r : String ; r := "" ;
         var j : int ; j := 1 ; while j < t->size() do ( (     r := r + "/" + t[j+1] ; 
     need := need->including(r) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    for (s : need) do ( (     if (not(ex->includes(s))) then (     res := res + 1 ; 
     ex := ex->including(s) ) else skip )  ) ; 
    skip ; 
 )  ;     test := test + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     A.newA().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main implements Runnable {
  public Scanner in ;
  public PrintWriter out ;
  Main()throws IOException {
    in=new Scanner(new File("in"));
    out=new PrintWriter(new File("out"));
  }
  void close()throws IOException {
    out.close();
  }
  void check(boolean f,String msg){
    if(! f){
      out.close();
      throw new RuntimeException(msg);
    }
  }
  public void run(){
    int tn=in.nextInt();
    for(int test=1 ; test<=tn ; test++){
      int old=in.nextInt();
      int create=in.nextInt();
      in.nextLine();
      Node root=new Node();
      for(int i=0 ; i<old ; i++){
        add(root,in.nextLine().split("/"),1);
      }
      int r=0 ;
      for(int i=0 ; i<create ; i++){
        r+=add(root,in.nextLine().split("/"),1);
      }
      out.println("Case #"+test+": "+r);
    }
    try {
      close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  int add(Node node,String[] tokens,int p){
    if(p>=tokens.length){
      return 0 ;
    }
    int r=0 ;
    if(node.children.get(tokens[p])==null){
      node.children.put(tokens[p],new Node());
      r=1 ;
    }
    return r+add(node.children.get(tokens[p]),tokens,p+1);
  }
  public class Node {
    Map<String,Node>children ;
    Node(){
      children=new TreeMap<String,Node>();
    }
  }
  public static void main(String[] args)throws IOException {
    new Thread(new Main()).start();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
   attribute in : OclFile;
   attribute out : OclFile;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile("in")) ; 
     out := OclFile.newOclFile_Write(OclFile("out")) );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
   operation check( f : boolean, msg : String) : void
  pre: true
  post: true
  activity: (     if (not(f)) then (     skip ; 
     error ProgramException(msg) ) else skip );
   operation run() : void
  pre: true
  post: true
  activity: (     var tn : int ; tn := in.getCurrent()->toInteger() ;
         var test : int ; test := 1 ; while test <= tn do ( (     var old : int ; old := in.getCurrent()->toInteger() ;
     var create : int ; create := in.getCurrent()->toInteger() ;
    skip ; 
    var root : Node ; root := Node.newNode() ;
        var i : int ; i := 0 ; while i < old do ( (     execute add(root, in.nextLine()->split("/"), 1) )  ;     i := i + 1 ) ; 
    var r : int ; r := 0 ;
        var i : int ; i := 0 ; while i < create do ( (     r := r+(add(root, in.nextLine()->split("/"), 1)) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     test := test + 1 ) ; 
     try (     execute close() )   catch (e : IOException) do (     e.printStackTrace() )
 );
   operation add( node : Node, tokens : Sequence(String), p : int) : int
  pre: true
  post: true
  activity: (     if (p >= tokens->size()) then (     return 0 ) else skip ; 
     var r : int ; r := 0 ;
     if (node.children->at(tokens[p+1]+1) = null) then (     node := node.children->union(Map{tokens[p+1] |-> Node.newNode()}) ; 
     r := 1 ) else skip ; 
     return r + add(node.children->at(tokens[p+1]+1), tokens, p + 1) );
 class Node {
   attribute children : Map(String,Node);
   static operation newNode() : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     children := Map{} );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(Main.newMain()).start() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class x {
  static class Directory {
    int st ;
    HashMap<String,Directory>h ;
    Directory(int cst){
      h=new HashMap<String,Directory>();
      st=cst ;
    }
    Directory create(String name,int sst){
      Directory c=h.get(name);
      if(c!=null)return c ;
      c=new Directory(sst);
      h.put(name,c);
      return c ;
    }
    int count(int lst){
      int cur=0 ;
      if(st>lst)++cur ;
      for(Directory z : h.values())cur+=z.count(lst);
      return cur ;
    }
  }
  public static void main(String args[])throws Exception {
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int tt=1 ; tt<=t ; tt++){
      Directory r=new Directory(0);
      int n=in.nextInt(),m=in.nextInt();
      for(int i=1 ; i<=n+m ; i++){
        String[] a=in.next().split("/");
        Directory c=r ;
        for(int j=1 ; j<a.length ; j++){
          c=c.create(a[j],i);
        }
      }
      System.out.println("Case #"+tt+": "+r.count(n));
    };
  };
};
------------------------------------------------------------
OCL File:
---------
 class x {
  static class Directory {
   attribute st : int;
   attribute h : Map(String,Directory);
   static operation newDirectory( cst : int) : Directory
  pre: true
  post: true
  activity:
  ( var self : Directory ;
    self := createDirectory();
    self.initialise(cst);
    return self );
  operation initialise( cst : int) : void
  pre: true  post: true
  activity: (     h := Map{} ; 
     st := cst );
   operation create( name : String, sst : int) : Directory
  pre: true
  post: true
  activity: (     var c : Directory ; c := h->at(name) ;
     if (c /= null) then     return c else skip ; 
    c := Directory.newDirectory(sst) ; 
    h := h->union(Map{name |-> c}) ; 
    return c 
 );
   operation count( lst : int) : int
  pre: true
  post: true
  activity: (     var cur : int ; cur := 0 ;
     if (st > lst) then     cur := cur + 1 ; else skip ; 
     for (z : h->values()) do (     cur := cur+(z.count(lst)) ;  ) ; 
     return cur );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var tt : int ; tt := 1 ; while tt <= t do ( (     var r : Directory ; r := Directory.newDirectory(0) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= n + m do ( (     var a : Sequence(String) ; a := in.getCurrent()->split("/") ;
     var c : Directory ; c := r ;
         var j : int ; j := 1 ; while j < a->size() do ( (     c := c.create(a[j+1], i) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Case #" + tt + ": " + r.count(n)) )  ;     tt := tt + 1 ) ; 
  );
}
;

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int tc=0 ; tc<n ; tc++){
      String s=sc.next();
      String t=sc.next();
      System.out.println(solve(s,t)? "YES" : "NO");
    }
    sc.close();
  }
  static boolean solve(String s,String t){
    int sIndex=0 ;
    for(char tCh : t.toCharArray()){
      if(sIndex<s.length()&& tCh==s.charAt(sIndex)){
        sIndex++;
      }
      else if(sIndex==0 || tCh!=s.charAt(sIndex-1)){
        return false ;
      }
    }
    return sIndex==s.length();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < n do ( (     var s : String ; s := sc.getCurrent() ;
     var t : String ; t := sc.getCurrent() ;
     OclFile["System.out"].println(if solve(s, t) then "YES" else "NO" endif) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( s : String, t : String) : boolean
  pre: true
  post: true
  activity: (     var sIndex : int ; sIndex := 0 ;
     for (tCh : t->characters()) do ( (     if (sIndex < s->size() & tCh = s->at(sIndex+1)) then (     sIndex := sIndex + 1 ) else     if (sIndex = 0 or tCh /= s->at((sIndex)->char2byte() - 1+1)) then (     return false ) else skip ; )  ) ; 
     return sIndex = s->size() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int N=s.nextInt();
    int M=s.nextInt();
    long a[]=new long[N];
    long b[]=new long[N];
    long c[]=new long[M];
    long d[]=new long[M];
    long min=0 ;
    int l=0 ;
    int i=0,j=0 ;
    for(i=0 ; i<N ; i++){
      a[i]=s.nextInt();
      b[i]=s.nextInt();
    }
    for(i=0 ; i<M ; i++){
      c[i]=s.nextInt();
      d[i]=s.nextInt();
    }
    for(i=0 ; i<N ; i++){
      min=Math.abs(a[i]-c[0])+Math.abs(b[i]-d[0]);
      l=0 ;
      for(j=0 ; j<M ; j++){
        if(min>Math.abs(a[i]-c[j])+Math.abs(b[i]-d[j])){
          min=Math.abs(a[i]-c[j])+Math.abs(b[i]-d[j]);
          l=j ;
        }
      }
      System.out.println(l+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := s.getCurrent()->toInteger() ;
    var M : int ; M := s.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,N)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,N)->collect(0) ;
    var c : Sequence(long) ; c := Integer.subrange(1,M)->collect(0) ;
    var d : Sequence(long) ; d := Integer.subrange(1,M)->collect(0) ;
    var min : long ; min := 0 ;
    var l : int ; l := 0 ;
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
        i := 0 ; while i < N do ( (     a[i+1] := s.getCurrent()->toInteger() ; 
     b[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        i := 0 ; while i < M do ( (     c[i+1] := s.getCurrent()->toInteger() ; 
     d[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        i := 0 ; while i < N do ( (     min := if a[i+1] - c[0+1] < 0 then -(a[i+1] - c[0+1]) else a[i+1] - c[0+1] endif + if b[i+1] - d[0+1] < 0 then -(b[i+1] - d[0+1]) else b[i+1] - d[0+1] endif ; 
     l := 0 ; 
         j := 0 ; while j < M do ( (     if (min > if a[i+1] - c[j+1] < 0 then -(a[i+1] - c[j+1]) else a[i+1] - c[j+1] endif + if b[i+1] - d[j+1] < 0 then -(b[i+1] - d[j+1]) else b[i+1] - d[j+1] endif) then (     min := if a[i+1] - c[j+1] < 0 then -(a[i+1] - c[j+1]) else a[i+1] - c[j+1] endif + if b[i+1] - d[j+1] < 0 then -(b[i+1] - d[j+1]) else b[i+1] - d[j+1] endif ; 
     l := j ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(l + 1) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=br.readLine();
    String[] t=str.split("\\ ");
    int a=Integer.parseInt(t[0]);
    int b=Integer.parseInt(t[1]);
    System.out.println(Math.max(a*b,Math.max(a-b,a+b)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := br.readLine() ;
    var t : Sequence(String) ; t := str->split("\\ ") ;
    var a : int ; a := (t[0+1])->toInteger() ;
    var b : int ; b := (t[1+1])->toInteger() ;
    OclFile["System.out"].println(Set{a * b, Set{a - b, a + b}->max()}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sn=new Scanner(System.in);
    int A=0 ;
    int B=0 ;
    int x=0 ;
    int y=0 ;
    int z=0 ;
    int max=0 ;
    try {
      String str=sn.nextLine();
      String[] strlist=str.split(" ",0);
      A=Integer.parseInt(strlist[0]);
      B=Integer.parseInt(strlist[1]);
      sn.close();
      if(A<-100 || 100<B){
        return ;
      }
      x=A+B ;
      y=A-B ;
      z=A*B ;
      max=Math.max(x,y);
      max=Math.max(max,z);
      System.out.println(max);
    }
    catch(Exception e){
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sn : OclFile ; sn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := 0 ;
    var B : int ; B := 0 ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var z : int ; z := 0 ;
    var max : int ; max := 0 ;
    try (     var str : String ; str := sn.nextLine() ;
     var strlist : Sequence(String) ; strlist := str->split(" ") ;
    A := (strlist[0+1])->toInteger() ; 
    B := (strlist[1+1])->toInteger() ; 
    skip ; 
    if (A < -100 or 100 < B) then (     return ) else skip ; 
    x := A + B ; 
    y := A - B ; 
    z := A * B ; 
    max := Set{x, y}->max() ; 
    max := Set{max, z}->max() ; 
    OclFile["System.out"].println(max) ; 
 )   catch (e : ProgramException) do (     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int ans=Math.max(a*b,a+b);
    ans=Math.max(ans,a-b);
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := Set{a * b, a + b}->max() ;
    ans := Set{ans, a - b}->max() ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
class Stuff implements Comparable<Stuff>{
  int v ;
  int w ;
  double performance ;
  Stuff(int v,int w){
    this.v=v ;
    this.w=w ;
    performance=1.0*v/w ;
  }
  public int compareTo(Stuff s){
    if(performance<s.performance)return 1 ;
    if(performance>s.performance)return-1 ;
    return 0 ;
  }
}
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int w=sc.nextInt();
    PriorityQueue<Stuff>que=new PriorityQueue<>();
    for(int i=0 ; i<n ; i++){
      int vi=sc.nextInt();
      int wi=sc.nextInt();
      que.add(new Stuff(vi,wi));
    }
    double res=0 ;
    while(w>0 && ! que.isEmpty()){
      Stuff s=que.poll();
      if(w>=s.w){
        res+=s.v ;
        w-=s.w ;
      }
      else {
        res+=s.performance*w ;
        w=0 ;
      }
    }
    System.out.println(BigDecimal.valueOf(res).toPlainString());
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Stuff implements Comparable<Stuff> {
   attribute v : int;
   attribute w : int;
   attribute performance : double;
   static operation newStuff( v : int, w : int) : Stuff
  pre: true
  post: true
  activity:
  ( var self : Stuff ;
    self := createStuff();
    self.initialise(v, w);
    return self );
  operation initialise( v : int, w : int) : void
  pre: true  post: true
  activity: (     self.v := v ; 
     self.w := w ; 
     performance := 1.0 * v / w );
   operation compareTo( s : Stuff) : int
  pre: true
  post: true
  activity: (     if (performance < s.performance) then     return 1 else skip ; 
     if (performance > s.performance) then     return -1 else skip ; 
     return 0 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var que : Sequence(Stuff) ; que := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var vi : int ; vi := sc.getCurrent()->toInteger() ;
     var wi : int ; wi := sc.getCurrent()->toInteger() ;
     que := que->including(Stuff.newStuff(vi, wi)) )  ;     i := i + 1 ) ; 
    var res : double ; res := 0 ;
    while (w > 0 & not(que->isEmpty())) do (     var s : Stuff ; s := que->min() ;
     if (w >= s.w) then (     res := res+(s.v) ; 
     w := w-(s.w) ) else (     res := res+(s.performance * w) ; 
     w := 0 ) ) ; 
    OclFile["System.out"].println((res + "")->toReal().toPlainString()) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt(),b=sc.nextInt();
    sc.close();
    int ans=a+b ;
    int tmp=a-b ;
    ans=Math.max(ans,tmp);
    tmp=a*b ;
    ans=Math.max(ans,tmp);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    skip ; 
    var ans : int ; ans := a + b ;
    var tmp : int ; tmp := a - b ;
    ans := Set{ans, tmp}->max() ; 
    tmp := a * b ; 
    ans := Set{ans, tmp}->max() ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int[] ans=new int[3];
    ans[0]=a+b ;
    ans[1]=a-b ;
    ans[2]=a*b ;
    Arrays.sort(ans);
    System.out.println(ans[2]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,3)->collect(0) ;
    ans[0+1] := a + b ; 
    ans[1+1] := a - b ; 
    ans[2+1] := a * b ; 
    ans := ans->sort() ; 
    OclFile["System.out"].println(ans[2+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void reverse(int arr[],int n,int k){
    for(int i=0 ; i<n ; i+=k){
      int left=i ;
      int right=Math.min(i+k-1,n-1);
      int temp ;
      while(left<right){
        temp=arr[left];
        arr[left]=arr[right];
        arr[right]=temp ;
        left+=1 ;
        right-=1 ;
      }
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,6,7,8 };
      int k=3 ;
      int n=arr.length ;
      reverse(arr,n,k);
      for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation reverse( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var left : int ; left := i ;
     var right : int ; right := Set{i + k - 1, n - 1}->min() ;
     var temp : int ;
     while (left < right) do (     temp := arr[left+1] ; 
     arr[left+1] := arr[right+1] ; 
    arr[right+1] := temp ; 
    left := left+(1) ; 
    right := right-(1) ; 
 ) )  ;     i := i+(k) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6,7,8} ;
     var k : int ; k := 3 ;
    var n : int ; n := arr->size() ;
    execute reverse(arr, n, k) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void reverse(int arr[],int n,int k){
    for(int i=0 ; i<n ; i+=2*k){
      int left=i ;
      int right=Math.min(i+k-1,n-1);
      while(left<right){
        swap(arr,left++,right--);
      }
    }
  }
  static int[] swap(int[] array,int i,int j){
    int temp=array[i];
    array[i]=array[j];
    array[j]=temp ;
    return array ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,6,7,8,9,10,11,12,13,14 };
      int k=3 ;
      int n=arr.length ;
      reverse(arr,n,k);
      for(int i=0 ; i<n ; i++){
        System.out.print(arr[i]+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation reverse( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var left : int ; left := i ;
     var right : int ; right := Set{i + k - 1, n - 1}->min() ;
     while (left < right) do (     execute swap(arr, left, right) ) )  ;     i := i+(2 * k) ) );
  static   operation swap( array : Sequence(int), i : int, j : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var temp : int ; temp := array[i+1] ;
     array[i+1] := array[j+1] ; 
     array[j+1] := temp ; 
     return array );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6,7,8,9,10,11,12,13,14} ;
     var k : int ; k := 3 ;
    var n : int ; n := arr->size() ;
    execute reverse(arr, n, k) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void reverse(int[] arr,int n,int k,int m){
    for(int i=0 ; i<n ; i+=k+m){
      int left=i ;
      int right=Math.min(i+k-1,n-1);
      while(left<right)swap(arr,left++,right--);
    }
  }
  static int[] swap(int[] arr,int i,int j){
    int temp=arr[i];
    arr[i]=arr[j];
    arr[j]=temp ;
    return arr ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,6,7,8,9,10,11,12,13,14 };
      int k=3 ;
      int m=2 ;
      int n=arr.length ;
      reverse(arr,n,k,m);
      for(int i=0 ; i<n ; i++){
        System.out.print(arr[i]+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation reverse( arr : Sequence(int), n : int, k : int, m : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var left : int ; left := i ;
     var right : int ; right := Set{i + k - 1, n - 1}->min() ;
     while (left < right) do     execute swap(arr, left, right) ; )  ;     i := i+(k + m) ) );
  static   operation swap( arr : Sequence(int), i : int, j : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := arr[j+1] ; 
     arr[j+1] := temp ; 
     return arr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6,7,8,9,10,11,12,13,14} ;
     var k : int ; k := 3 ;
    var m : int ; m := 2 ;
    var n : int ; n := arr->size() ;
    execute reverse(arr, n, k, m) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int arr[]={
    10,20,30,50,10,70,30 };
    static void printMaxOfMin(int n){
      for(int k=1 ; k<=n ; k++){
        int maxOfMin=Integer.MIN_VALUE ;
        for(int i=0 ; i<=n-k ; i++){
          int min=arr[i];
          for(int j=1 ; j<k ; j++){
            if(arr[i+j]<min)min=arr[i+j];
          }
          if(min>maxOfMin)maxOfMin=min ;
        }
        System.out.print(maxOfMin+" ");
      }
    }
    public static void main(String[] args){
      printMaxOfMin(arr.length);
    }
  }

------------------------------------------------------------
OCL File:
---------
class Test {
  static   attribute arr : int := Sequence{10,20,30,50,10,70,30};
  static   operation printMaxOfMin( n : int) : void
  pre: true
  post: true
  activity: (         var k : int ; k := 1 ; while k <= n do ( (     var maxOfMin : int ; maxOfMin := -2147483648 ;
         var i : int ; i := 0 ; while i <= n - k do ( (     var min : int ; min := arr[i+1] ;
         var j : int ; j := 1 ; while j < k do ( (     if (arr[i + j+1] < min) then     min := arr[i + j+1] ; else skip )  ;     j := j + 1 ) ; 
     if (min > maxOfMin) then     maxOfMin := min ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(maxOfMin + " ") )  ;     k := k + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute printMaxOfMin(arr->size()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class TechnohobletOfFire {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int k=sc.nextInt();
    int[] p=new int[n+1];
    int[] s=new int[n+1];
    int[] mp=new int[m+1];
    for(int i=1 ; i<=n ; i++){
      p[i]=sc.nextInt();
    }
    for(int i=1 ; i<=n ; i++){
      s[i]=sc.nextInt();
    }
    for(int i=1 ; i<=n ; i++){
      mp[s[i] ]=Math.max(mp[s[i] ],p[i]);
    }
    int c=0 ;
    for(int i=1 ; i<=k ; i++){
      int x=sc.nextInt();
      if(p[x]!=mp[s[x] ])c++;
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class TechnohobletOfFire {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n + 1)->collect(0) ;
    var s : Sequence(int) ; s := Integer.subrange(1,n + 1)->collect(0) ;
    var mp : Sequence(int) ; mp := Integer.subrange(1,m + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     p[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     s[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     mp[s[i+1]+1] := Set{mp[s[i+1]+1], p[i+1]}->max() )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
        var i : int ; i := 1 ; while i <= k do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (p[x+1] /= mp[s[x+1]+1]) then     c := c + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str[]=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int m=Integer.parseInt(str[1]);
    Pair p[]=new Pair[n];
    Pair check[]=new Pair[m];
    for(int i=0 ; i<n ; i++){
      str=br.readLine().split(" ");
      int a=Integer.parseInt(str[0]);
      int b=Integer.parseInt(str[1]);
      p[i]=new Pair(a,b);
    }
    for(int i=0 ; i<m ; i++){
      str=br.readLine().split(" ");
      int c=Integer.parseInt(str[0]);
      int d=Integer.parseInt(str[1]);
      check[i]=new Pair(c,d);
    }
    for(int i=0 ; i<n ; i++){
      int min=Integer.MAX_VALUE ;
      int minI=-1 ;
      for(int j=0 ; j<m ; j++){
        if(p[i] .getDist(check[j] .x,check[j] .y)<min){
          min=p[i] .getDist(check[j] .x,check[j] .y);
          minI=j ;
        }
      }
      System.out.println(minI+1);
    }
  }
}
class Pair {
  int x ;
  int y ;
  public Pair(int x,int y){
    this.x=x ;
    this.y=y ;
  }
  public int getDist(int x,int y){
    return Math.abs(x-this.x)+Math.abs(y-this.y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var m : int ; m := (str[1+1])->toInteger() ;
    var p : Sequence(Map) ; p := Integer.subrange(1,n)->collect(null) ;
    var check : Sequence(Map) ; check := Integer.subrange(1,m)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     str := br.readLine()->split(" ") ; 
     var a : int ; a := (str[0+1])->toInteger() ;
     var b : int ; b := (str[1+1])->toInteger() ;
     p[i+1] := Map(a, b) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     str := br.readLine()->split(" ") ; 
     var c : int ; c := (str[0+1])->toInteger() ;
     var d : int ; d := (str[1+1])->toInteger() ;
     check[i+1] := Map(c, d) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var min : int ; min := 2147483647 ;
     var minI : int ; minI := -1 ;
         var j : int ; j := 0 ; while j < m do ( (     if (p[i+1].getDist(check[j+1].x, check[j+1].y) < min) then (     min := p[i+1].getDist(check[j+1].x, check[j+1].y) ; 
     minI := j ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(minI + 1) )  ;     i := i + 1 ) ; 
 );
}
class Pair {
   attribute x : int;
   attribute y : int;
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation getDist( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return if x - self.x < 0 then -(x - self.x) else x - self.x endif + if y - self.y < 0 then -(y - self.y) else y - self.y endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Test {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int k=sc.nextInt();
    int[] powers=new int[n];
    int[] school=new int[n];
    int[] select=new int[k];
    for(int i=0 ; i<n ; i++){
      powers[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      school[i]=sc.nextInt();
    }
    for(int i=0 ; i<k ; i++){
      select[i]=sc.nextInt();
    }
    HashMap<Integer,Integer>set=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int selectedSchool=school[i];
      if(set.containsKey(selectedSchool)){
        int value=set.get(selectedSchool);
        set.put(selectedSchool,Math.max(powers[i],value));
      }
      else {
        set.put(selectedSchool,powers[i]);
      }
    }
    int ans=0 ;
    for(int i=0 ; i<k ; i++){
      int schoolValue=set.get(school[select[i]-1]);
      if(powers[select[i]-1]<schoolValue){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var powers : Sequence(int) ; powers := Integer.subrange(1,n)->collect(0) ;
    var school : Sequence(int) ; school := Integer.subrange(1,n)->collect(0) ;
    var select : Sequence(int) ; select := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     powers[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     school[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do ( (     select[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var set : Map(int,int) ; set := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var selectedSchool : int ; selectedSchool := school[i+1] ;
     if (set->keys()->includes(selectedSchool)) then (     var value : int ; value := set->at(selectedSchool) ;
     set := set->union(Map{selectedSchool |-> Set{powers[i+1], value}->max()}) ) else (     set := set->union(Map{selectedSchool |-> powers[i+1]}) ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     var schoolValue : int ; schoolValue := set->at(school[select[i+1] - 1+1]) ;
     if (powers[select[i+1] - 1+1] < schoolValue) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAXN=10000000 ;
  static int minimumSteps(int n,int m,int a,int b){
    if(n>m)return MAXN ;
    if(n==m)return 0 ;
    return Math.min(1+minimumSteps(n*a,m,a,b),1+minimumSteps(n*b,m,a,b));
  }
  public static void main(String[] args){
    int n=120,m=51840 ;
    int a=2,b=3 ;
    System.out.println(minimumSteps(n,m,a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAXN : int := 10000000;
  static   operation minimumSteps( n : int, m : int, a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (n > m) then     return MAXN else skip ; 
     if (n = m) then     return 0 else skip ; 
     return Set{1 + minimumSteps(n * a, m, a, b), 1 + minimumSteps(n * b, m, a, b)}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 120 ;
    var m : int ; m := 51840 ;
     var a : int ; a := 2 ;
    var b : int ; b := 3 ;
     OclFile["System.out"].println(minimumSteps(n, m, a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
class Stuff implements Comparable<Stuff>{
  int v ;
  int w ;
  double performance ;
  Stuff(int v,int w){
    this.v=v ;
    this.w=w ;
    performance=1.0*v/w ;
  }
  public int compareTo(Stuff s){
    if(performance<s.performance)return 1 ;
    if(performance>s.performance)return-1 ;
    return 0 ;
  }
}
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int w=sc.nextInt();
    PriorityQueue<Stuff>que=new PriorityQueue<>();
    for(int i=0 ; i<n ; i++){
      int vi=sc.nextInt();
      int wi=sc.nextInt();
      que.add(new Stuff(vi,wi));
    }
    double res=0 ;
    while(w>0 && ! que.isEmpty()){
      Stuff s=que.poll();
      if(w>=s.w){
        res+=s.v ;
        w-=s.w ;
      }
      else {
        res+=s.performance*w ;
        w=0 ;
      }
    }
    System.out.println(BigDecimal.valueOf(res).toPlainString());
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Stuff implements Comparable<Stuff> {
   attribute v : int;
   attribute w : int;
   attribute performance : double;
   static operation newStuff( v : int, w : int) : Stuff
  pre: true
  post: true
  activity:
  ( var self : Stuff ;
    self := createStuff();
    self.initialise(v, w);
    return self );
  operation initialise( v : int, w : int) : void
  pre: true  post: true
  activity: (     self.v := v ; 
     self.w := w ; 
     performance := 1.0 * v / w );
   operation compareTo( s : Stuff) : int
  pre: true
  post: true
  activity: (     if (performance < s.performance) then     return 1 else skip ; 
     if (performance > s.performance) then     return -1 else skip ; 
     return 0 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var que : Sequence(Stuff) ; que := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var vi : int ; vi := sc.getCurrent()->toInteger() ;
     var wi : int ; wi := sc.getCurrent()->toInteger() ;
     que := que->including(Stuff.newStuff(vi, wi)) )  ;     i := i + 1 ) ; 
    var res : double ; res := 0 ;
    while (w > 0 & not(que->isEmpty())) do (     var s : Stuff ; s := que->min() ;
     if (w >= s.w) then (     res := res+(s.v) ; 
     w := w-(s.w) ) else (     res := res+(s.performance * w) ; 
     w := 0 ) ) ; 
    OclFile["System.out"].println((res + "")->toReal().toPlainString()) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static boolean strcheck(String s1,String s2){
    if(s1.compareTo(s2)!=0)return false ;
    return true ;
  }
  public static boolean check(String s){
    if(s.length()>=10)return true ;
    for(int i=1 ; i<s.length(); i++){
      for(int j=i+1 ; j<s.length(); j++){
        for(int k=j+1 ; k<s.length(); k++){
          String s1="",s2="",s3="",s4="" ;
          try {
            s1=s.substring(0,i);
            s2=s.substring(i,j-i);
            s3=s.substring(j,k-j);
            s4=s.substring(k,s.length()-k);
          }
          catch(StringIndexOutOfBoundsException e){
          }
          if(strcheck(s1,s2)&& strcheck(s1,s3)&& strcheck(s1,s4)&& strcheck(s2,s3)&& strcheck(s2,s4)&& strcheck(s3,s4))return true ;
        }
      }
    }
    return false ;
  }
  public static void main(String[] args){
    String str="aaabb" ;
    if(check(str))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation strcheck( s1 : String, s2 : String) : boolean
  pre: true
  post: true
  activity: (     if (s1->compareTo(s2) /= 0) then     return false else skip ; 
     return true );
  static   operation check( s : String) : boolean
  pre: true
  post: true
  activity: (     if (s->size() >= 10) then     return true else skip ; 
         var i : int ; i := 1 ; while i < s->size() do ( (         var j : int ; j := i + 1 ; while j < s->size() do ( (         var k : int ; k := j + 1 ; while k < s->size() do ( (     var s1 : String ; s1 := "" ;
    var s2 : String ; s2 := "" ;
    var s3 : String ; s3 := "" ;
    var s4 : String ; s4 := "" ;
     try (     s1 := s.subrange(0+1,i) ; 
     s2 := s.subrange(i+1,j - i) ; 
     s3 := s.subrange(j+1,k - j) ; 
     s4 := s.subrange(k+1,s->size() - k) )   catch (e : IndexingException) do skip
     if (strcheck(s1, s2) & strcheck(s1, s3) & strcheck(s1, s4) & strcheck(s2, s3) & strcheck(s2, s4) & strcheck(s3, s4)) then     return true else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "aaabb" ;
     if (check(str)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Stack ;
class Test {
  static Stack<Character>st=new Stack<>();
  static void insert_at_bottom(char x){
    if(st.isEmpty())st.push(x);
    else {
      char a=st.peek();
      st.pop();
      insert_at_bottom(x);
      st.push(a);
    }
  }
  static void reverse(){
    if(st.size()>0){
      char x=st.peek();
      st.pop();
      reverse();
      insert_at_bottom(x);
    }
  }
  public static void main(String[] args){
    st.push('1');
    st.push('2');
    st.push('3');
    st.push('4');
    System.out.println("Original Stack");
    System.out.println(st);
    reverse();
    System.out.println("Reversed Stack");
    System.out.println(st);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   attribute st : Sequence(String) := Sequence{};
  static   operation insert_at_bottom( x : String) : void
  pre: true
  post: true
  activity: (     if (st->isEmpty()) then     st := st->append(x) ; else (     var a : String ; a := st->min() ;
     st := st->front() ; 
     execute insert_at_bottom(x) ; 
     st := st->append(a) ) );
  static   operation reverse() : void
  pre: true
  post: true
  activity: (     if (st->size() > 0) then (     var x : String ; x := st->min() ;
     st := st->front() ; 
     execute reverse() ; 
     execute insert_at_bottom(x) ) else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     st := st->append('1') ; 
     st := st->append('2') ; 
    st := st->append('3') ; 
    st := st->append('4') ; 
    OclFile["System.out"].println("Original Stack") ; 
    OclFile["System.out"].println(st) ; 
    execute reverse() ; 
    OclFile["System.out"].println("Reversed Stack") ; 
    OclFile["System.out"].println(st) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  public static int MAX_CHAR=256 ;
  static int kthNonRepeating(String str,int k){
    int n=str.length();
    int[] count=new int[MAX_CHAR];
    int[] index=new int[MAX_CHAR];
    for(int i=0 ; i<MAX_CHAR ; i++){
      count[i]=0 ;
      index[i]=n ;
    }
    for(int i=0 ; i<n ; i++){
      char x=str.charAt(i);
++count[x];
      if(count[x]==1)index[x]=i ;
      if(count[x]==2)index[x]=n ;
    }
    Arrays.sort(index);
    return(index[k-1]!=n)? index[k-1] :-1 ;
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    int k=3 ;
    int res=kthNonRepeating(str,k);
    System.out.println(res==-1 ? "There are less than k non-repeating characters" : "k'th non-repeating character is  "+str.charAt(res));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX_CHAR : int := 256;
  static   operation kthNonRepeating( str : String, k : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var count : Sequence(int) ; count := Integer.subrange(1,MAX_CHAR)->collect(0) ;
    var index : Sequence(int) ; index := Integer.subrange(1,MAX_CHAR)->collect(0) ;
        var i : int ; i := 0 ; while i < MAX_CHAR do ( (     count[i+1] := 0 ; 
     index[i+1] := n )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : String ; x := str->at(i+1) ;
     count[x+1] := count[x+1] + 1 ; 
     if (count[x+1] = 1) then     index[x+1] := i ; else skip ; 
     if (count[x+1] = 2) then     index[x+1] := n ; else skip )  ;     i := i + 1 ) ; 
    index := index->sort() ; 
    return if (index[k - 1+1] /= n) then index[k - 1+1] else -1 endif 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var k : int ; k := 3 ;
     var res : int ; res := kthNonRepeating(str, k) ;
     OclFile["System.out"].println(if res = -1 then "There are less than k non-repeating characters" else "k'th non-repeating character is  " + str->at(res+1) endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class GFG {
  static void findElements(int arr[],int n){
    int first=Integer.MIN_VALUE ;
    int second=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]>first){
        second=first ;
        first=arr[i];
      }
      else if(arr[i]>second)second=arr[i];
    }
    for(int i=0 ; i<n ; i++)if(arr[i]<second)System.out.print(arr[i]+" ");
  }
  public static void main(String args[]){
    int arr[]={
      2,-6,3,5,1 };
      int n=arr.length ;
      findElements(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findElements( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var first : int ; first := -2147483648 ;
     var second : int ; second := 2147483647 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] > first) then (     second := first ; 
     first := arr[i+1] ) else     if (arr[i+1] > second) then     second := arr[i+1] ; else skip ; )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do (     if (arr[i+1] < second) then     OclFile["System.out"].print(arr[i+1] + " ") ; else skip ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,-6,3,5,1} ;
     var n : int ; n := arr->size() ;
     execute findElements(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class gfg {
  static int sub_arrays(int[] a,int n,int k){
    int sum[]=new int[n+2];
    for(int i=0 ; i<n+2 ; i++){
      sum[i]=0 ;
    }
    for(int i=0 ; i<n ; i++){
      a[i]--;
      a[i] %=k ;
      sum[i+1]+=sum[i]+a[i];
      sum[i+1] %=k ;
    }
    int ans=0,l=0,r=0 ;
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n+1 ; i++){
      mp.put(sum[i],0);
    }
    int temp ;
    for(int i=0 ; i<n+1 ; i++){
      ans+=(int)mp.get(sum[i]);
      temp=(int)mp.get(sum[i])+1 ;
      mp.put(sum[i],temp);
      r++;
      if(r-l>=k){
        temp=(int)mp.get(sum[l])-1 ;
        mp.put(sum[l],temp);
        l++;
      }
    }
    return ans ;
  }
  public static void main(String args[]){
    int[] a={
      1,4,2,3,5 };
      int n=a.length ;
      int k=4 ;
      System.out.print(sub_arrays(a,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class gfg {
  static   operation sub_arrays( a : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var sum : Sequence(int) ; sum := Integer.subrange(1,n + 2)->collect(0) ;
         var i : int ; i := 0 ; while i < n + 2 do ( (     sum[i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := a[i+1] - 1 ; 
     a[i+1] := a[i+1] mod k ; 
     sum[i + 1+1] := sum[i + 1+1]+(sum[i+1] + a[i+1]) ; 
     sum[i + 1+1] := sum[i + 1+1] mod k )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    var mp : Map(int,int) ; mp := Map{} ;
        var i : int ; i := 0 ; while i < n + 1 do ( (     mp := mp->union(Map{sum[i+1] |-> 0}) )  ;     i := i + 1 ) ; 
    var temp : int ;
        var i : int ; i := 0 ; while i < n + 1 do ( (     ans := ans+(mp->at(sum[i+1])->oclAsType(int)) ; 
     temp := mp->at(sum[i+1])->oclAsType(int) + 1 ; 
    mp := mp->union(Map{sum[i+1] |-> temp}) ; 
    r := r + 1 ; 
    if (r - l >= k) then (     temp := mp->at(sum[l+1])->oclAsType(int) - 1 ; 
     mp := mp->union(Map{sum[l+1] |-> temp}) ; 
     l := l + 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,4,2,3,5} ;
     var n : int ; n := a->size() ;
     var k : int ; k := 4 ;
     OclFile["System.out"].print(sub_arrays(a, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int lenDoubleString(String s){
    int l=s.length();
    String first_half=s.substring(0,l/2);
    String second_half="" ;
    if(l % 2==0)second_half=s.substring(l/2);
    else second_half=s.substring(l/2+1);
    second_half=reverse(second_half);
    System.out.println(first_half+second_half);
    if(l % 2==0)System.out.println(l);
    else System.out.println(l-1);
    return Integer.MIN_VALUE ;
  }
  static String reverse(String input){
    char[] temparray=input.toCharArray();
    int left,right=0 ;
    right=temparray.length-1 ;
    for(left=0 ; left<right ; left++,right--){
      char temp=temparray[left];
      temparray[left]=temparray[right];
      temparray[right]=temp ;
    }
    return String.valueOf(temparray);
  }
  public static void main(String[] args){
    String n="abba" ;
    lenDoubleString(n);
    n="abcdedcba" ;
    lenDoubleString(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation lenDoubleString( s : String) : int
  pre: true
  post: true
  activity: (     var l : int ; l := s->size() ;
     var first_half : String ; first_half := s.subrange(0+1,l / 2) ;
    var second_half : String ; second_half := "" ;
    if (l mod 2 = 0) then     second_half := s.subrange(l / 2+1,l / 2) else     second_half := s.subrange(l / 2 + 1+1,l / 2 + 1) ; ;  
    second_half := reverse(second_half) ; 
    OclFile["System.out"].println(first_half + second_half) ; 
    if (l mod 2 = 0) then     OclFile["System.out"].println(l) else     OclFile["System.out"].println(l - 1) ; ;  
    return -2147483648 
 );
  static   operation reverse( input : String) : String
  pre: true
  post: true
  activity: (     var temparray : Sequence(String) ; temparray := input->characters() ;
     var left : int ;
    var right : int ; right := 0 ;
    right := temparray->size() - 1 ; 
        left := 0 ; while left < right do ( (     var temp : String ; temp := temparray[left+1] ;
     temparray[left+1] := temparray[right+1] ; 
     temparray[right+1] := temp )  ;     left := left + 1 ;     right := right - 1 ) ; 
    return (temparray)->sum()  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : String ; n := "abba" ;
     execute lenDoubleString(n) ; 
     n := "abcdedcba" ; 
     execute lenDoubleString(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int t=sc.nextInt();
      int n=sc.nextInt();
      if(t==0 && n==0)break ;
      boolean[][] map=new boolean[150][150];
      boolean[][] visit=new boolean[150][150];
      int p,q,r ;
      for(int i=0 ; i<n ; i++){
        p=sc.nextInt()+75 ;
        q=sc.nextInt()+75 ;
        map[q][p]=true ;
      }
      p=sc.nextInt()+75 ;
      q=sc.nextInt()+75 ;
      int cnt=1 ;
      LinkedList<Integer>x=new LinkedList<Integer>();
      LinkedList<Integer>y=new LinkedList<Integer>();
      int[] a=new int[] {
        1,1,0,-1,-1,0 };
        int[] b=new int[] {
          1,0,1,-1,0,-1 };
          x.offer(p);
          y.offer(q);
          visit[q][p]=true ;
          for(int i=0 ; i<t ; i++){
            r=x.size();
            for(int j=0 ; j<r ; j++){
              p=x.poll();
              q=y.poll();
              for(int k=0 ; k<6 ; k++){
                if(visit[q+b[k] ][p+a[k] ]==false && map[q+b[k] ][p+a[k] ]==false){
                  visit[q+b[k] ][p+a[k] ]=true ;
                  x.offer(p+a[k]);
                  y.offer(q+b[k]);
                  cnt++;
                }
              }
            }
          }
          System.out.println(cnt);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    if (t = 0 & n = 0) then     break else skip ; 
    var map : Sequence(Sequence(boolean)) ; map := Integer.subrange(1,150)->collect(Integer.subrange(1,150)->collect(false)) ;
    var visit : Sequence(Sequence(boolean)) ; visit := Integer.subrange(1,150)->collect(Integer.subrange(1,150)->collect(false)) ;
    var p : int ;
    var q : int ;
    var r : int ;
        var i : int ; i := 0 ; while i < n do ( (     p := sc.getCurrent()->toInteger() + 75 ; 
     q := sc.getCurrent()->toInteger() + 75 ; 
     map[q+1][p+1] := true )  ;     i := i + 1 ) ; 
    p := sc.getCurrent()->toInteger() + 75 ; 
    q := sc.getCurrent()->toInteger() + 75 ; 
    var cnt : int ; cnt := 1 ;
    var x : Sequence(int) ; x := Sequence{} ;
    var y : Sequence(int) ; y := Sequence{} ;
    var a : Sequence(int) ; a := Sequence{1,1,0,-1,-1,0} ;
    var b : Sequence(int) ; b := Sequence{1,0,1,-1,0,-1} ;
    x := x->including(p) ; 
    y := y->including(q) ; 
    visit[q+1][p+1] := true ; 
        var i : int ; i := 0 ; while i < t do ( (     r := x->size() ; 
         var j : int ; j := 0 ; while j < r do ( (     p := x->min() ;     x := x->sort()->tail() ; 
     q := y->min() ;     y := y->sort()->tail() ; 
         var k : int ; k := 0 ; while k < 6 do ( (     if (visit[q + b[k+1]+1][p + a[k+1]+1] = false & map[q + b[k+1]+1][p + a[k+1]+1] = false) then (     visit[q + b[k+1]+1][p + a[k+1]+1] := true ; 
     x := x->including(p + a[k+1]) ; 
     y := y->including(q + b[k+1]) ; 
     cnt := cnt + 1 ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int[] DX={
    1,1,0,-1,-1,0 };
    static int[] DY={
      1,0,-1,-1,0,1 };
      public static void main(String[] arg){
        while(true){
          int T=sc.nextInt();
          if(T==0)break ;
          int N=sc.nextInt();
          boolean[][] visited=new boolean[201][201];
          for(int i=0 ; i<N ; ++i){
            int x=sc.nextInt()+100 ;
            int y=sc.nextInt()+100 ;
            visited[x][y]=true ;
          }
          ArrayList<Point>ps=new ArrayList<Point>();
          int sx=sc.nextInt()+100 ;
          int sy=sc.nextInt()+100 ;
          visited[sx][sy]=true ;
          ps.add(new Point(sx,sy));
          int ans=1 ;
          for(int i=0 ; i<T ; ++i){
            ArrayList<Point>next=new ArrayList<Point>();
            for(Point p : ps){
              for(int j=0 ; j<6 ; ++j){
                int nx=p.x+DX[j];
                int ny=p.y+DY[j];
                if(! visited[nx][ny]){
                  visited[nx][ny]=true ;
                  next.add(new Point(nx,ny));
                }
              }
            }
            ans+=next.size();
            ps=next ;
          }
          System.out.println(ans);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute DX : Sequence(int) := Sequence{1,1,0,-1,-1,0};
  static   attribute DY : Sequence(int) := Sequence{1,0,-1,-1,0,1};
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var T : int ; T := sc.getCurrent()->toInteger() ;
     if (T = 0) then     break else skip ; 
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var visited : Sequence(Sequence(boolean)) ; visited := Integer.subrange(1,201)->collect(Integer.subrange(1,201)->collect(false)) ;
        var i : int ; i := 0 ; while i < N do ( (     var x : int ; x := sc.getCurrent()->toInteger() + 100 ;
     var y : int ; y := sc.getCurrent()->toInteger() + 100 ;
     visited[x+1][y+1] := true )  ;     i := i + 1 ) ; 
    var ps : Sequence(Point) ; ps := Sequence{} ;
    var sx : int ; sx := sc.getCurrent()->toInteger() + 100 ;
    var sy : int ; sy := sc.getCurrent()->toInteger() + 100 ;
    visited[sx+1][sy+1] := true ; 
    ps := ps->including(Point.newPoint(sx, sy)) ; 
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < T do ( (     var next : Sequence(Point) ; next := Sequence{} ;
     for (p : ps) do ( (         var j : int ; j := 0 ; while j < 6 do ( (     var nx : int ; nx := p.x + DX[j+1] ;
     var ny : int ; ny := p.y + DY[j+1] ;
     if (not(visited[nx+1][ny+1])) then (     visited[nx+1][ny+1] := true ; 
     next := next->including(Point.newPoint(nx, ny)) ) else skip )  ;     j := j + 1 ) )  ) ; 
     ans := ans+(next->size()) ; 
     ps := next )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner in ;
  static PrintWriter out ;
  static String INPUT="" ;
  public static void main(String[] args)throws Exception {
    in=INPUT.isEmpty()? new Scanner(System.in): new Scanner(INPUT);
    out=new PrintWriter(System.out);
    int N=ni();
    int M=ni();
    int ab[][]=new int[N][3];
    int cd[][]=new int[M][2];
    int i,j ;
    for(i=0 ; i<N ; i++){
      ab[i][0]=ni();
      ab[i][1]=ni();
      ab[i][2]=-1 ;
    }
    for(i=0 ; i<M ; i++){
      cd[i][0]=ni();
      cd[i][1]=ni();
    }
    for(i=0 ; i<N ; i++){
      int min=400000000 ;
      for(j=M-1 ; j>=0 ; j--){
        int distance=Math.abs(ab[i][0]-cd[j][0])+Math.abs(ab[i][1]-cd[j][1]);
        if(min>=distance){
          min=distance ;
          ab[i][2]=j+1 ;
        }
      }
    }
    for(i=0 ; i<N ; i++)out.println(ab[i][2]);
    out.flush();
  }
  static int ni(){
    return Integer.parseInt(in.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute INPUT : String := "";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := if INPUT->isEmpty() then OclFile.newOclFile_Read(OclFile["System.in"]) else OclFile.newOclFile_Read(OclFile.newOclFile(INPUT)) endif ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    var N : int ; N := ni() ;
    var M : int ; M := ni() ;
    var ab : Sequence(Sequence(int)) ; ab := Integer.subrange(1,N)->collect(Integer.subrange(1,3)->collect(0)) ;
    var cd : Sequence(Sequence(int)) ; cd := Integer.subrange(1,M)->collect(Integer.subrange(1,2)->collect(0)) ;
    var i : int ;
    var j : int ;
        i := 0 ; while i < N do ( (     ab[i+1][0+1] := ni() ; 
     ab[i+1][1+1] := ni() ; 
     ab[i+1][2+1] := -1 )  ;     i := i + 1 ) ; 
        i := 0 ; while i < M do ( (     cd[i+1][0+1] := ni() ; 
     cd[i+1][1+1] := ni() )  ;     i := i + 1 ) ; 
        i := 0 ; while i < N do ( (     var min : int ; min := 400000000 ;
         j := M - 1 ; while j >= 0 do ( (     var distance : int ; distance := if ab[i+1][0+1] - cd[j+1][0+1] < 0 then -(ab[i+1][0+1] - cd[j+1][0+1]) else ab[i+1][0+1] - cd[j+1][0+1] endif + if ab[i+1][1+1] - cd[j+1][1+1] < 0 then -(ab[i+1][1+1] - cd[j+1][1+1]) else ab[i+1][1+1] - cd[j+1][1+1] endif ;
     if (min >= distance) then (     min := distance ; 
     ab[i+1][2+1] := j + 1 ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
        i := 0 ; while i < N do (     skip ;  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation ni() : int
  pre: true
  post: true
  activity: (     return (in.getCurrent())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[][] move={
      {
        0,1 },{
          1,1 },{
-1,0 },{
              1,0 },{
-1,-1 },{
                  0,-1 }
                };
                while(true){
                  int t=sc.nextInt();
                  int n=sc.nextInt();
                  if(t==0 && n==0)break ;
                  boolean[][] map=new boolean[200][200];
                  while(n--!=0){
                    int x=sc.nextInt()+100 ;
                    int y=sc.nextInt()+100 ;
                    map[x][y]=true ;
                  }
                  int x=sc.nextInt()+100 ;
                  int y=sc.nextInt()+100 ;
                  map[x][y]=true ;
                  int c=1 ;
                  List<int[]>list=new ArrayList<int[]>();
                  list.add(new int[] {
                    x,y }
);
                    while(t--!=0){
                      List<int[]>next=new ArrayList<int[]>();
                      for(int[] a : list){
                        for(int k=0 ; k<6 ; k++){
                          int nx=a[0]+move[k][0];
                          int ny=a[1]+move[k][1];
                          if(! map[nx][ny]){
                            map[nx][ny]=true ;
                            c++;
                            next.add(new int[] {
                              nx,ny }
);
                            }
                          }
                        }
                        list=next ;
                      }
                      System.out.println(c);
                    }
                  }
                }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var move : Sequence(Sequence(int)) ; move := Sequence{Sequence{0,1},Sequence{1,1},Sequence{-1,0},Sequence{1,0},Sequence{-1,-1},Sequence{0,-1}} ;
     while (true) do (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    if (t = 0 & n = 0) then     break else skip ; 
    var map : Sequence(Sequence(boolean)) ; map := Integer.subrange(1,200)->collect(Integer.subrange(1,200)->collect(false)) ;
        while (n /= 0) do (    skip ; (     var x : int ; x := sc.getCurrent()->toInteger() + 100 ;
     var y : int ; y := sc.getCurrent()->toInteger() + 100 ;
     map[x+1][y+1] := true ) ;  ) ;  
    var x : int ; x := sc.getCurrent()->toInteger() + 100 ;
    var y : int ; y := sc.getCurrent()->toInteger() + 100 ;
    map[x+1][y+1] := true ; 
    var c : int ; c := 1 ;
    var list : Sequence(Sequence(int)) ; list := Sequence{} ;
    list := list->including(Sequence{x,y}) ; 
        while (t /= 0) do (    skip ; (     var next : Sequence(Sequence(int)) ; next := Sequence{} ;
     for (a : list) do ( (         var k : int ; k := 0 ; while k < 6 do ( (     var nx : int ; nx := a[0+1] + move[k+1][0+1] ;
     var ny : int ; ny := a[1+1] + move[k+1][1+1] ;
     if (not(map[nx+1][ny+1])) then (     map[nx+1][ny+1] := true ; 
     c := c + 1 ; 
     next := next->including(Sequence{nx,ny}) ) else skip )  ;     k := k + 1 ) )  ) ; 
     list := next ) ;  ) ;  
    OclFile["System.out"].println(c) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] tmpArray=br.readLine().split(" ");
    int n=Integer.parseInt(tmpArray[0]);
    double totalW=Integer.parseInt(tmpArray[1]);
    Item[] items=new Item[n];
    for(int i=0 ; i<n ; i++){
      tmpArray=br.readLine().split(" ");
      int value=Integer.parseInt(tmpArray[0]);
      int weight=Integer.parseInt(tmpArray[1]);
      items[i]=new Item(value,weight);
    }
    Arrays.sort(items);
    double result=0 ;
    for(int i=0 ; i<n && totalW>0 ; i++){
      double w1=Math.min(items[i] .weight,totalW);
      result+=w1*items[i] .valuePerWeight ;
      totalW-=w1 ;
    }
    System.out.printf("%.8f\n",result);
  }
}
class Item implements Comparable<Item>{
  int value ;
  int weight ;
  double valuePerWeight ;
  Item(int v,int w){
    value=v ;
    weight=w ;
    valuePerWeight=(double)value/weight ;
  }
  @ Override public int compareTo(Item item1){
    if(this.valuePerWeight<item1.valuePerWeight){
      return 1 ;
    }
    else if(this.valuePerWeight>item1.valuePerWeight){
      return-1 ;
    }
    else {
      return 0 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
    var n : int ; n := (tmpArray[0+1])->toInteger() ;
    var totalW : double ; totalW := (tmpArray[1+1])->toInteger() ;
    var items : Sequence(Item) ; items := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     tmpArray := br.readLine()->split(" ") ; 
     var value : int ; value := (tmpArray[0+1])->toInteger() ;
     var weight : int ; weight := (tmpArray[1+1])->toInteger() ;
     items[i+1] := Item.newItem(value, weight) )  ;     i := i + 1 ) ; 
    items := items->sort() ; 
    var result : double ; result := 0 ;
        var i : int ; i := 0 ; while i < n & totalW > 0 do ( (     var w1 : double ; w1 := Set{items[i+1].weight, totalW}->min() ;
     result := result+(w1 * items[i+1].valuePerWeight) ; 
     totalW := totalW-(w1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.8f\n", result) ; 
 );
}
class Item implements Comparable<Item> {
   attribute value : int;
   attribute weight : int;
   attribute valuePerWeight : double;
   static operation newItem( v : int, w : int) : Item
  pre: true
  post: true
  activity:
  ( var self : Item ;
    self := createItem();
    self.initialise(v, w);
    return self );
  operation initialise( v : int, w : int) : void
  pre: true  post: true
  activity: (     value := v ; 
     weight := w ; 
     valuePerWeight := value->oclAsType(double) / weight );
      operation compareTo( item1 : Item) : int
  pre: true
  post: true
  activity: (     if (self.valuePerWeight < item1.valuePerWeight) then (     return 1 ) else     if (self.valuePerWeight > item1.valuePerWeight) then (     return -1 ) else (     return 0 ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  public static final int[] dx={
    0,1,1,0,-1,-1 };
    public static final int[] dy={
      1,1,0,-1,-1,0 };
      public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(true){
          int t=in.nextInt();
          int n=in.nextInt();
          if(t==0 && n==0)break ;
          boolean[][] block=new boolean[200][200];
          for(int i=0 ; i<n ; i++){
            int x=in.nextInt()+100 ;
            int y=in.nextInt()+100 ;
            block[y][x]=true ;
          }
          int sx=in.nextInt()+100 ;
          int sy=in.nextInt()+100 ;
          boolean[][] used=new boolean[200][200];
          Queue<Pos>qu=new LinkedList<Pos>();
          qu.add(new Pos(sy,sx,0));
          int count=0 ;
          while(! qu.isEmpty()){
            Pos p=qu.poll();
            if(used[p.y][p.x])continue ;
            if(p.turn>t)continue ;
            used[p.y][p.x]=true ;
            count++;
            for(int i=0 ; i<6 ; i++){
              int ny=p.y+dy[i];
              int nx=p.x+dx[i];
              if(block[ny][nx])continue ;
              qu.add(new Pos(ny,nx,p.turn+1));
            }
          }
          System.out.println(count);
        }
      }
    }
    class Pos {
      int x,y ;
      int turn ;
      public Pos(int y,int x,int turn){
        this.y=y ;
        this.x=x ;
        this.turn=turn ;
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute dx : Sequence(int) := Sequence{0,1,1,0,-1,-1};
  static    attribute dy : Sequence(int) := Sequence{1,1,0,-1,-1,0};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var t : int ; t := in.getCurrent()->toInteger() ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    if (t = 0 & n = 0) then     break else skip ; 
    var block : Sequence(Sequence(boolean)) ; block := Integer.subrange(1,200)->collect(Integer.subrange(1,200)->collect(false)) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() + 100 ;
     var y : int ; y := in.getCurrent()->toInteger() + 100 ;
     block[y+1][x+1] := true )  ;     i := i + 1 ) ; 
    var sx : int ; sx := in.getCurrent()->toInteger() + 100 ;
    var sy : int ; sy := in.getCurrent()->toInteger() + 100 ;
    var used : Sequence(Sequence(boolean)) ; used := Integer.subrange(1,200)->collect(Integer.subrange(1,200)->collect(false)) ;
    var qu : Sequence(Pos) ; qu := Sequence{} ;
    qu := qu->including(Pos.newPos(sy, sx, 0)) ; 
    var count : int ; count := 0 ;
    while (not(qu->isEmpty())) do (     var p : Pos ; p := qu->min() ;
     if (used[p.y+1][p.x+1]) then     continue else skip ; 
    if (p.turn > t) then     continue else skip ; 
    used[p.y+1][p.x+1] := true ; 
    count := count + 1 ; 
        var i : int ; i := 0 ; while i < 6 do ( (     var ny : int ; ny := p.y + dy[i+1] ;
     var nx : int ; nx := p.x + dx[i+1] ;
     if (block[ny+1][nx+1]) then     continue else skip ; 
     qu := qu->including(Pos.newPos(ny, nx, p.turn + 1)) )  ;     i := i + 1 ) ; 
 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
}
class Pos {
   attribute x : int;
   attribute turn : int;
   static operation newPos( y : int, x : int, turn : int) : Pos
  pre: true
  post: true
  activity:
  ( var self : Pos ;
    self := createPos();
    self.initialise(y, x,turn);
    return self );
  operation initialise( y : int, x : int, turn : int) : void
  pre: true  post: true
  activity: (     self.y := y ; 
     self.x := x ; 
     self.turn := turn );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int gcd(int a,int b){
    if(a==0 || b==0)return 0 ;
    if(a==b)return a ;
    if(a>b)return gcd(a-b,b);
    return gcd(a,b-a);
  }
  static void printResult(int arr[],int n){
    int count=0 ;
    for(int i=1 ; i<n ; i++)if(gcd(arr[i],arr[i-1])!=1)count++;
    System.out.println(count);
    System.out.print(arr[0]+" ");
    for(int i=1 ; i<n ; i++){
      if(gcd(arr[i],arr[i-1])!=1)System.out.print(1+" ");
      System.out.print(arr[i]+" ");
    }
  }
  public static void main(String args[]){
    int A[]={
      5,10,20 };
      int n=A.length ;
      printResult(A,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0 or b = 0) then     return 0 else skip ; 
     if (a = b) then     return a else skip ; 
     if (a > b) then     return gcd(a - b, b) else skip ; 
     return gcd(a, b - a) );
  static   operation printResult( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i < n do (     if (gcd(arr[i+1], arr[i - 1+1]) /= 1) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    OclFile["System.out"].print(arr[0+1] + " ") ; 
        var i : int ; i := 1 ; while i < n do ( (     if (gcd(arr[i+1], arr[i - 1+1]) /= 1) then     OclFile["System.out"].print(1 + " ") ; else skip ; 
     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{5,10,20} ;
     var n : int ; n := A->size() ;
     execute printResult(A, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int findOnBulbs(int numberOfBulbs){
    int onBulbs=0 ;
    int bulb=1 ;
    int person=1 ;
    for(bulb=1 ; bulb<=numberOfBulbs ; bulb++){
      int factors=0 ;
      for(person=1 ; person*person<=numberOfBulbs ; person++){
        if(bulb % person==0){
          factors++;
          if(bulb/person!=person){
            factors++;
          }
        }
      }
      if(factors % 2==1){
        System.out.println("Light bulb "+bulb+" will be on");
        onBulbs++;
      }
    }
    return onBulbs ;
  }
  public static void main(String[] args){
    int numberOfBulbs=1000 ;
    int onBulbs=findOnBulbs(numberOfBulbs);
    System.out.println("Total "+onBulbs+" light bulbs will be on in the end out of "+numberOfBulbs+" light bulbs");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findOnBulbs( numberOfBulbs : int) : int
  pre: true
  post: true
  activity: (     var onBulbs : int ; onBulbs := 0 ;
     var bulb : int ; bulb := 1 ;
    var person : int ; person := 1 ;
        bulb := 1 ; while bulb <= numberOfBulbs do ( (     var factors : int ; factors := 0 ;
         person := 1 ; while person * person <= numberOfBulbs do ( (     if (bulb mod person = 0) then (     factors := factors + 1 ; 
     if (bulb / person /= person) then (     factors := factors + 1 ) else skip ) else skip )  ;     person := person + 1 ) ; 
     if (factors mod 2 = 1) then (     OclFile["System.out"].println("Light bulb " + bulb + " will be on") ; 
     onBulbs := onBulbs + 1 ) else skip )  ;     bulb := bulb + 1 ) ; 
    return onBulbs 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var numberOfBulbs : int ; numberOfBulbs := 1000 ;
     var onBulbs : int ; onBulbs := findOnBulbs(numberOfBulbs) ;
     OclFile["System.out"].println("Total " + onBulbs + " light bulbs will be on in the end out of " + numberOfBulbs + " light bulbs") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countOdd(int L,int R){
    int N=(R-L)/2 ;
    if(R % 2!=0 || L % 2!=0)N++;
    return N ;
  }
  public static void main(String[] args){
    int L=3,R=7 ;
    int odds=countOdd(L,R);
    int evens=(R-L+1)-odds ;
    System.out.println("Count of odd numbers is "+odds);
    System.out.println("Count of even numbers is "+evens);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countOdd( L : int, R : int) : int
  pre: true
  post: true
  activity: (     var N : int ; N := (R - L) / 2 ;
     if (R mod 2 /= 0 or L mod 2 /= 0) then     N := N + 1 ; else skip ; 
     return N );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 3 ;
    var R : int ; R := 7 ;
     var odds : int ; odds := countOdd(L, R) ;
    var evens : int ; evens := (R - L + 1) - odds ;
    OclFile["System.out"].println("Count of odd numbers is " + odds) ; 
    OclFile["System.out"].println("Count of even numbers is " + evens) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int maxAND(int L,int R){
    if(L==R)return L ;
    else if((R-L)==1)return(R & L);
    else {
      if(((R-1)& R)>((R-2)&(R-1)))return((R-1)& R);
      else return((R-2)&(R-1));
    }
  }
  public static void main(String[] args){
    int L=1,R=632 ;
    System.out.println(maxAND(L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation maxAND( L : int, R : int) : int
  pre: true
  post: true
  activity: (     if (L = R) then     return L else     if ((R - L) = 1) then     return (R & L) else (     if (((R - 1) & R) > ((R - 2) & (R - 1))) then     return ((R - 1) & R) else     return ((R - 2) & (R - 1)) ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 1 ;
    var R : int ; R := 632 ;
     OclFile["System.out"].println(maxAND(L, R)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int h=5*n+10 ;
      int[][] map=new int[h][5];
      int d,p,q,max,cnt ;
      for(int i=0 ; i<n ; i++){
        d=sc.nextInt();
        p=sc.nextInt();
        q=sc.nextInt()-1 ;
        if(d==1){
          max=-1 ;
          for(int j=q ; j<q+p ; j++){
            cnt=h-1 ;
            while(map[cnt][j]==0){
              cnt--;
              if(cnt==-1)break ;
            }
            max=Math.max(max,cnt);
          }
          for(int j=q ; j<q+p ; j++)map[max+1][j]=1 ;
        }
        else {
          cnt=h-1 ;
          while(map[cnt][q]==0){
            cnt--;
            if(cnt==-1)break ;
          }
          for(int j=cnt+1 ; j<cnt+1+p ; j++)map[j][q]=1 ;
        }
        cnt=0 ;
        for(int j=0 ; j<h ; j++){
          if(map[j][0]==1 && map[j][1]==1 && map[j][2]==1 && map[j][3]==1 && map[j][4]==1)continue ;
          map[cnt]=map[j];
          cnt++;
        }
      }
      int sum=0 ;
      for(int i=0 ; i<h ; i++){
        for(int j=0 ; j<5 ; j++){
          sum+=map[i][j];
        }
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var h : int ; h := 5 * n + 10 ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,h)->collect(Integer.subrange(1,5)->collect(0)) ;
    var d : int ;
    var p : int ;
    var q : int ;
    var max : int ;
    var cnt : int ;
        var i : int ; i := 0 ; while i < n do ( (     d := sc.getCurrent()->toInteger() ; 
     p := sc.getCurrent()->toInteger() ; 
    q := sc.getCurrent()->toInteger() - 1 ; 
    if (d = 1) then (     max := -1 ; 
         var j : int ; j := q ; while j < q + p do ( (     cnt := h - 1 ; 
     while (map[cnt+1][j+1] = 0) do (     cnt := cnt - 1 ; 
     if (cnt = -1) then     break else skip ) ; 
     max := Set{max, cnt}->max() )  ;     j := j + 1 ) ; 
         var j : int ; j := q ; while j < q + p do (     map[max + 1+1][j+1] := 1 ;  ;     j := j + 1 ) ) else (     cnt := h - 1 ; 
     while (map[cnt+1][q+1] = 0) do (     cnt := cnt - 1 ; 
     if (cnt = -1) then     break else skip ) ; 
         var j : int ; j := cnt + 1 ; while j < cnt + 1 + p do (     map[j+1][q+1] := 1 ;  ;     j := j + 1 ) ) ;  
    cnt := 0 ; 
        var j : int ; j := 0 ; while j < h do ( (     if (map[j+1][0+1] = 1 & map[j+1][1+1] = 1 & map[j+1][2+1] = 1 & map[j+1][3+1] = 1 & map[j+1][4+1] = 1) then     continue else skip ; 
     map[cnt+1] := map[j+1] ; 
     cnt := cnt + 1 )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < 5 do ( (     sum := sum+(map[i+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static boolean prime[]=new boolean[1000000+5];
  static void findPrime(){
    Arrays.fill(prime,true);
    prime[1]=false ;
    for(int p=2 ; p*p<=1000000 ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=1000000 ; i+=p)prime[i]=false ;
      }
    }
  }
  static int lenOfLongSubarr(int arr[],int n){
    Map<Integer,Integer>um=new HashMap<Integer,Integer>();
    int sum=0,maxLen=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=prime[arr[i] ]==false ?-1 : 1 ;
      if(sum==1)maxLen=i+1 ;
      else if(! um.containsKey(sum))um.put(sum,i);
      if(um.containsKey(sum-1)){
        if(maxLen<(i-um.get(sum-1)))maxLen=i-um.get(sum-1);
      }
    }
    return maxLen ;
  }
  public static void main(String[] args){
    findPrime();
    int arr[]={
      1,9,3,4,5,6,7,8 };
      int n=arr.length ;
      System.out.println(lenOfLongSubarr(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   attribute prime : boolean := Integer.subrange(1,1000000 + 5)->collect(false);
  static   operation findPrime() : void
  pre: true
  post: true
  activity: (     prime := prime->collect(true) ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p <= 1000000 do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= 1000000 do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation lenOfLongSubarr( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var um : Map(int,int) ; um := Map{} ;
     var sum : int ; sum := 0 ;
    var maxLen : int ; maxLen := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(if prime[arr[i+1]+1] = false then -1 else 1 endif) ; 
     if (sum = 1) then     maxLen := i + 1 else     if (not(um->keys()->includes(sum))) then     um := um->union(Map{sum |-> i}) ; else skip ; ;  
     if (um->keys()->includes(sum - 1)) then (     if (maxLen < (i - um->at(sum - 1))) then     maxLen := i - um->at(sum - 1) ; else skip ) else skip )  ;     i := i + 1 ) ; 
     return maxLen );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute findPrime() ; 
     var arr : Sequence(int) ; arr := Sequence{1,9,3,4,5,6,7,8} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(lenOfLongSubarr(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Division {
  public static void main(String[] argf){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int x=sc.nextInt();
      if(x<=1399){
        System.out.println("Division 4");
      }
      if(x>=1400 && x<=1599){
        System.out.println("Division 3");
      }
      if(x>=1600 && x<=1899){
        System.out.println("Division 2");
      }
      if(x>=1900){
        System.out.println("Division 1");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Division {
  static   operation main( argf : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x <= 1399) then (     OclFile["System.out"].println("Division 4") ) else skip ; 
    if (x >= 1400 & x <= 1599) then (     OclFile["System.out"].println("Division 3") ) else skip ; 
    if (x >= 1600 & x <= 1899) then (     OclFile["System.out"].println("Division 2") ) else skip ; 
    if (x >= 1900) then (     OclFile["System.out"].println("Division 1") ) else skip ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  static final Scanner s=new Scanner(System.in);
  public static void main(String[] __){
    int n=s.nextInt(),m=s.nextInt();
    Point[] students=new Point[n];
    CheckPoint[] cps=new CheckPoint[m];
    for(int i=0 ; i<n ; i++)students[i]=new Point(s.nextInt(),s.nextInt());
    for(int i=0 ; i<m ; i++)cps[i]=new CheckPoint(i+1,s.nextInt(),s.nextInt());
    for(Point st : students)System.out.println(Arrays.stream(cps).min(Comparator.comparingInt(o->Math.abs(o.x-st.x)+Math.abs(o.y-st.y))).get().id);
  }
}
class CheckPoint extends Point {
  int id ;
  CheckPoint(int id,int x,int y){
    super(x,y);
    this.id=id ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( __ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s.getCurrent()->toInteger() ;
    var m : int ; m := s.getCurrent()->toInteger() ;
     var students : Sequence(Point) ; students := Integer.subrange(1,n)->collect(null) ;
    var cps : Sequence(CheckPoint) ; cps := Integer.subrange(1,m)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     students[i+1] := Point.newPoint(s.getCurrent()->toInteger(), s.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     cps[i+1] := CheckPoint.newCheckPoint(i + 1, s.getCurrent()->toInteger(), s.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    for (st : students) do (     OclFile["System.out"].println(stream(cps)->min().get().id) ;  ) ; 
 );
}
class CheckPoint extends Point {
   attribute id : int;
   static operation newCheckPoint( id : int, x : int, y : int) : CheckPoint
  pre: true
  post: true
  activity:
  ( var self : CheckPoint ;
    self := createCheckPoint();
    self.initialise(id, x,y);
    return self );
  operation initialise( id : int, x : int, y : int) : void
  pre: true  post: true
  activity: (     execute super(x, y) ; 
     self.id := id );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static final int nbits=32 ;
  static BitSet bs ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a=sc.nextLong();
    long b=sc.nextLong();
    BitSet bsa=new BitSet(nbits);
    BitSet bsb=new BitSet(nbits);
    for(int i=0 ; i<nbits ; i++){
      if((a &(1<<i))!=0)bsa.set(i);
    }
    for(int i=0 ; i<nbits ; i++){
      if((b &(1<<i))!=0)bsb.set(i);
    }
    makeBitSet(bsa);
    bs.and(bsb);
    printBitSet(bs);
    System.out.print("\n");
    makeBitSet(bsa);
    bs.or(bsb);
    printBitSet(bs);
    System.out.print("\n");
    makeBitSet(bsa);
    bs.xor(bsb);
    printBitSet(bs);
    System.out.print("\n");
  }
  static void makeBitSet(BitSet b){
    bs=new BitSet(nbits);
    for(int i=0 ; i<nbits ; i++){
      if(b.get(i))bs.set(i);
    }
  }
  static void printBitSet(BitSet b){
    for(int i=nbits-1 ; i>=0 ; i--){
      if(b.get(i))System.out.print(1);
      else System.out.print(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute nbits : int := 32;
  static   attribute bs : Sequence(boolean);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var bsa : Sequence(boolean) ; bsa := MathLib.toBitSequence(nbits) ;
    var bsb : Sequence(boolean) ; bsb := MathLib.toBitSequence(nbits) ;
        var i : int ; i := 0 ; while i < nbits do ( (     if ((MathLib.bitwiseAnd(a,((1*(2->pow(i)))->oclAsType(long)))) /= 0) then     bsa := bsa.setAt(i+1, true) ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < nbits do ( (     if ((MathLib.bitwiseAnd(b,((1*(2->pow(i)))->oclAsType(long)))) /= 0) then     bsb := bsb.setAt(i+1, true) ; else skip )  ;     i := i + 1 ) ; 
    execute makeBitSet(bsa) ; 
    bs := bs.and(bsb) ; 
    execute printBitSet(bs) ; 
    OclFile["System.out"].print("\n") ; 
    execute makeBitSet(bsa) ; 
    bs := bs.or(bsb) ; 
    execute printBitSet(bs) ; 
    OclFile["System.out"].print("\n") ; 
    execute makeBitSet(bsa) ; 
    bs := bs.xor(bsb) ; 
    execute printBitSet(bs) ; 
    OclFile["System.out"].print("\n") ; 
 );
  static   operation makeBitSet( b : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (     bs := MathLib.toBitSequence(nbits) ; 
         var i : int ; i := 0 ; while i < nbits do ( (     if (b->at(i+1)) then     bs := bs.setAt(i+1, true) ; else skip )  ;     i := i + 1 ) );
  static   operation printBitSet( b : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := nbits - 1 ; while i >= 0 do ( (     if (b->at(i+1)) then     OclFile["System.out"].print(1) ; else     OclFile["System.out"].print(0) ; )  ;     i := i - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getSingle(int arr[],int n){
    int ones=0,twos=0 ;
    int common_bit_mask ;
    for(int i=0 ; i<n ; i++){
      twos=twos |(ones & arr[i]);
      ones=ones ^ arr[i];
      common_bit_mask=~(ones & twos);
      ones &=common_bit_mask ;
      twos &=common_bit_mask ;
    }
    return ones ;
  }
  public static void main(String args[]){
    int arr[]={
      3,3,2,3 };
      int n=arr.length ;
      System.out.println("The element with single occurrence is "+getSingle(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getSingle( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ones : int ; ones := 0 ;
    var twos : int ; twos := 0 ;
     var common_bit_mask : int ;
         var i : int ; i := 0 ; while i < n do ( (     twos := MathLib.bitwiseOr(twos,(MathLib.bitwiseAnd(ones,arr[i+1]))) ; 
     ones := MathLib.bitwiseXor(ones,arr[i+1]) ; 
    common_bit_mask := -((MathLib.bitwiseAnd(ones,twos)) + 1) ; 
    ones := MathLib.bitwiseAnd(ones, common_bit_mask) ; 
    twos := MathLib.bitwiseAnd(twos, common_bit_mask) ; 
 )  ;     i := i + 1 ) ; 
     return ones );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,3,2,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("The element with single occurrence is " + getSingle(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.max ;
import static java.lang.Math.min ;
import static java.lang.Math.abs ;
import static java.lang.System.out ;
import java.util.*;
import java.io.*;
import java.math.*;
public class Demo4 {
  public static void main(String[] args){
    try {
      FastReader in=new FastReader();
      int testCases=in.nextInt();
      while(testCases-->0){
        int n=in.nextInt();
        if(n<=1399){
          System.out.println("Division 4");
        }
        else if(n<=1599){
          System.out.println("Division 3");
        }
        else if(n<=1899){
          System.out.println("Division 2");
        }
        else if(n>=1900){
          System.out.println("Division 1");
        }
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
      ;
    }
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        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().trim();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Demo4 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var in : FastReader ; in := FastReader.newFastReader() ;
     var testCases : int ; testCases := in.nextInt() ;
         while (testCases > 0) do (        testCases := testCases - 1 ;     skip ; (     var n : int ; n := in.nextInt() ;
     if (n <= 1399) then (     OclFile["System.out"].println("Division 4") ) else     if (n <= 1599) then (     OclFile["System.out"].println("Division 3") ) else     if (n <= 1899) then (     OclFile["System.out"].println("Division 2") ) else     if (n >= 1900) then (     OclFile["System.out"].println("Division 1") ) else skip ; ;  ;  ) ;  ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
  );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine()->trim() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int n,m ;
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<=(n-1); i++){
      m=sc.nextInt();
      arr[i]=m ;
    }
    for(int j=0 ; j<=(n-1); j++){
      if(arr[j]<=1399)System.out.println("Division 4");
      else if(arr[j]>=1400 && arr[j]<=1599)System.out.println("Division 3");
      else if(arr[j]>=1600 && arr[j]<=1899)System.out.println("Division 2");
      else System.out.println("Division 1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var m : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := sc.getCurrent()->toInteger() ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i <= (n - 1) do ( (     m := sc.getCurrent()->toInteger() ; 
     arr[i+1] := m )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j <= (n - 1) do ( (     if (arr[j+1] <= 1399) then     OclFile["System.out"].println("Division 4") ; else     if (arr[j+1] >= 1400 & arr[j+1] <= 1599) then     OclFile["System.out"].println("Division 3") else     if (arr[j+1] >= 1600 & arr[j+1] <= 1899) then     OclFile["System.out"].println("Division 2") else     OclFile["System.out"].println("Division 1") ; ;  ;  )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Arrays ;
import java.util.Vector ;
import java.lang.Math ;
public class virtual {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      if(n>=1900){
        System.out.println("Division 1");
      }
      else if(n>=1600){
        System.out.println("Division 2");
      }
      else if(n>=1400){
        System.out.println("Division 3");
      }
      else {
        System.out.println("Division 4");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class virtual {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n >= 1900) then (     OclFile["System.out"].println("Division 1") ) else     if (n >= 1600) then (     OclFile["System.out"].println("Division 2") ) else     if (n >= 1400) then (     OclFile["System.out"].println("Division 3") ) else (     OclFile["System.out"].println("Division 4") ) ;  ;  ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class C {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int times=input.nextInt();
    boolean m=true ;
    while(m){
      int test=input.nextInt();
      if(test>=1900)System.out.println("Division 1");
      else if(test<=1899 && test>=1600)System.out.println("Division 2");
      else if(test<=1599 && test>=1400)System.out.println("Division 3");
      else System.out.println("Division 4");
      times--;
      if(times==0)m=false ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var times : int ; times := input.getCurrent()->toInteger() ;
     var m : boolean ; m := true ;
     while (m) do (     var test : int ; test := input.getCurrent()->toInteger() ;
     if (test >= 1900) then     OclFile["System.out"].println("Division 1") else     if (test <= 1899 & test >= 1600) then     OclFile["System.out"].println("Division 2") else     if (test <= 1599 & test >= 1400) then     OclFile["System.out"].println("Division 3") else     OclFile["System.out"].println("Division 4") ; ;  ;  ;  
     times := times - 1 ; 
     if (times = 0) then     m := false ; else skip ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    long a[]=new long[n];
    long b[]=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextLong();
      b[i]=in.nextLong();
    }
    long ans=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      a[i]+=ans ;
      long c=((a[i]+b[i]-1)/b[i])*b[i]-a[i];
      ans+=c ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toLong() ; 
     b[i+1] := in.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     a[i+1] := a[i+1]+(ans) ; 
     var c : long ; c := ((a[i+1] + b[i+1] - 1) / b[i+1]) * b[i+1] - a[i+1] ;
     ans := ans+(c) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static final int MOD=(int)Math.pow(10,9)+7 ;
  static final boolean TEST=false ;
  static void debug(Object...os){
    if(TEST){
      StringBuilder sb=new StringBuilder(os.length);
      for(Object o : os)sb.append(o);
      System.out.println(sb);
    }
  }
  public static void main(String[] args){
    try(Scanner in=new Scanner(System.in)){
      do {
        solve(in);
      }
      while(TEST);
    }
  }
  private static void solve(Scanner in){
    int N=in.nextInt();
    long[] A=new long[N],B=new long[N];
    for(int i=0 ; i<N ; i++){
      A[i]=in.nextInt();
      B[i]=in.nextInt();
    }
    long ans=0 ;
    long accum=0 ;
    for(int i=N-1 ; i>-1 ; i--){
      A[i]+=accum ;
      long delta=0 ;
      if(A[i]==0){
        delta=0 ;
      }
      else if(A[i]<B[i]){
        delta=B[i]-A[i];
      }
      else if(A[i] % B[i]!=0){
        delta=B[i]-(A[i] % B[i]);
      }
      A[i]+=delta ;
      accum+=delta ;
      ans+=delta ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 10->pow(9)->oclAsType(int) + 7;
  static    attribute TEST : boolean := false;
  static   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (TEST) then (     var sb : String ; sb := StringLib.newString(os->size()) ;
     for (o : os) do (     sb := sb + StringLib.newString(o) ;  ) ; 
     OclFile["System.out"].println(sb) ) else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (   while true do ((     execute solve(in) ) ;
    if (TEST) then skip else break) ))  );
  static   operation solve( in : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
     var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
    var B : Sequence(long) ; B := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := in.getCurrent()->toInteger() ; 
     B[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var accum : long ; accum := 0 ;
        var i : int ; i := (N)->char2byte() - 1 ; while i > -1 do ( (     A[i+1] := A[i+1]+(accum) ; 
     var delta : long ; delta := 0 ;
    if (A[i+1] = 0) then (     delta := 0 ) else     if (A[i+1] < B[i+1]) then (     delta := B[i+1] - A[i+1] ) else     if (A[i+1] mod B[i+1] /= 0) then (     delta := B[i+1] - (A[i+1] mod B[i+1]) ) else skip ; ;  ;  
    A[i+1] := A[i+1]+(delta) ; 
    accum := accum+(delta) ; 
    ans := ans+(delta) ; 
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    try {
      InputStreamReader isr=new InputStreamReader(System.in);
      BufferedReader br=new BufferedReader(isr);
      long n=Integer.parseInt(br.readLine());
      ArrayList<Long>a=new ArrayList<Long>();
      ArrayList<Long>b=new ArrayList<Long>();
      for(int i=0 ; i<n ; i++){
        String tmp[]=br.readLine().split(" ");
        a.add(Long.parseLong(tmp[0]));
        b.add(Long.parseLong(tmp[1]));
      }
      long count=0 ;
      for(long i=n ; i>0 ; i--){
        Long atmp=a.get((int)(i-1));
        atmp=atmp+count ;
        Long btmp=b.get((int)(i-1));
        long tmp=(atmp)% btmp ;
        if(tmp!=0){
          count=count+(btmp-tmp);
        }
      }
      System.out.println(count);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
    var n : long ; n := (br.readLine())->toInteger() ;
    var a : Sequence(long) ; a := Sequence{} ;
    var b : Sequence(long) ; b := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var tmp : Sequence(String) ; tmp := br.readLine()->split(" ") ;
     a := a->including((tmp[0+1])->toLong()) ; 
     b := b->including((tmp[1+1])->toLong()) )  ;     i := i + 1 ) ; 
    var count : long ; count := 0 ;
        var i : long ; i := n ; while i > 0 do ( (     var atmp : long ; atmp := a->at((i - 1)->oclAsType(int)+1) ;
     atmp := atmp + count ; 
    var btmp : long ; btmp := b->at((i - 1)->oclAsType(int)+1) ;
    var tmp : long ; tmp := (atmp) mod btmp ;
    if (tmp /= 0) then (     count := count + (btmp - (tmp)->char2byte()) ) else skip ; 
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args){
    SC sc=new SC(System.in);
    int N=sc.nextInt();
    int[][] sw=new int[N][2];
    long cnt=0 ;
    for(int i=0 ; i<N ; i++){
      sw[i][0]=sc.nextInt();
      sw[i][1]=sc.nextInt();
    }
    for(int i=N-1 ; i>=0 ; i--){
      if((cnt+sw[i][0])% sw[i][1]==0){
      }
      else {
        cnt+=sw[i][1]-(cnt+sw[i][0])% sw[i][1];
      }
    }
    System.out.println(cnt);
  }
  static class SC {
    InputStream inp=System.in ;
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public SC(InputStream inp){
      reader=new BufferedReader(new InputStreamReader(inp));
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : SC ; sc := SC.newSC(OclFile["System.in"]) ;
     var N : int ; N := sc.nextInt() ;
    var sw : Sequence(Sequence(int)) ; sw := Integer.subrange(1,N)->collect(Integer.subrange(1,2)->collect(0)) ;
    var cnt : long ; cnt := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     sw[i+1][0+1] := sc.nextInt() ; 
     sw[i+1][1+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
        var i : int ; i := N - 1 ; while i >= 0 do ( (     if ((cnt + sw[i+1][0+1]) mod sw[i+1][1+1] = 0) then skip else (     cnt := cnt+(sw[i+1][1+1] - (cnt + sw[i+1][0+1]) mod sw[i+1][1+1]) ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
  static class SC {
   attribute inp : OclFile := OclFile["System.in"];
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newSC( inp : OclFile) : SC
  pre: true
  post: true
  activity:
  ( var self : SC ;
    self := createSC();
    self.initialise(inp);
    return self );
  operation initialise( inp : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inp)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    int n=Integer.parseInt(sa[0]);
    int[] a=new int[n];
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++){
      sa=br.readLine().split(" ");
      a[i]=Integer.parseInt(sa[0]);
      b[i]=Integer.parseInt(sa[1]);
    }
    br.close();
    long ans=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      long c=(a[i]+ans)% b[i];
      if(c>0){
        ans+=b[i]-c ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var n : int ; n := (sa[0+1])->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     sa := br.readLine()->split(" ") ; 
     a[i+1] := (sa[0+1])->toInteger() ; 
     b[i+1] := (sa[1+1])->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     var c : long ; c := (a[i+1] + ans) mod b[i+1] ;
     if (c > 0) then (     ans := ans+(b[i+1] - c) ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX_CHAR=26 ;
  static String removeChars(char arr[],int k){
    int[] hash=new int[MAX_CHAR];
    int n=arr.length ;
    for(int i=0 ; i<n ; ++i)hash[arr[i]-'a']++;
    String ans="" ;
    for(int i=0 ; i<n ; ++i){
      if(hash[arr[i]-'a']!=k){
        ans+=arr[i];
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    char str[]="geeksforgeeks".toCharArray();
    int k=2 ;
    System.out.print(removeChars(str,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX_CHAR : int := 26;
  static   operation removeChars( arr : Sequence(String), k : int) : String
  pre: true
  post: true
  activity: (     var hash : Sequence(int) ; hash := Integer.subrange(1,MAX_CHAR)->collect(0) ;
     var n : int ; n := arr->size() ;
        var i : int ; i := 0 ; while i < n do (     hash[arr[i+1] - ('a')->char2byte()+1] := hash[arr[i+1] - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < n do ( (     if (hash[arr[i+1] - ('a')->char2byte()+1] /= k) then (     ans := ans+(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := "geeksforgeeks"->characters() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].print(removeChars(str, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int m=Integer.parseInt(sc.next());
    Integer[] a=new Integer[n];
    Integer[] b=new Integer[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(sc.next());
      b[i]=Integer.parseInt(sc.next());
    }
    Integer[] c=new Integer[m];
    Integer[] d=new Integer[m];
    for(int i=0 ; i<m ; i++){
      c[i]=Integer.parseInt(sc.next());
      d[i]=Integer.parseInt(sc.next());
    }
    sc.close();
    String[] index=new String[n];
    for(int i=0 ; i<n ; i++){
      List<Integer>list=new ArrayList<>();
      for(int j=0 ; j<m ; j++){
        int dist=Math.abs(a[i]-c[j])+Math.abs(b[i]-d[j]);
        list.add(dist);
      }
      int min=list.stream().mapToInt(k->k).min().getAsInt();
      index[i]=Integer.toString(list.indexOf(min)+1);
    }
    String result=String.join("\n",index);
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var m : int ; m := (sc.getCurrent())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(null) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sc.getCurrent())->toInteger() ; 
     b[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var c : Sequence(int) ; c := Integer.subrange(1,m)->collect(null) ;
    var d : Sequence(int) ; d := Integer.subrange(1,m)->collect(null) ;
        var i : int ; i := 0 ; while i < m do ( (     c[i+1] := (sc.getCurrent())->toInteger() ; 
     d[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var index : Sequence(String) ; index := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var list : Sequence(int) ; list := Sequence{} ;
         var j : int ; j := 0 ; while j < m do ( (     var dist : int ; dist := if a[i+1] - c[j+1] < 0 then -(a[i+1] - c[j+1]) else a[i+1] - c[j+1] endif + if b[i+1] - d[j+1] < 0 then -(b[i+1] - d[j+1]) else b[i+1] - d[j+1] endif ;
     list := list->including(dist) )  ;     j := j + 1 ) ; 
     var min : int ; min := list->collect( _x1 | (lambda k : OclAny in k)->apply(_x1) ).min().getAsInt() ;
     index[i+1] := ((list->indexOf(min)-1 + 1) + "") )  ;     i := i + 1 ) ; 
    var result : String ; result := join("\n", index) ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int decimalToBinary(int N){
    int B_Number=0 ;
    int cnt=0 ;
    while(N!=0){
      int rem=N % 2 ;
      double c=Math.pow(10,cnt);
      B_Number+=rem*c ;
      N/=2 ;
      cnt++;
    }
    return B_Number ;
  }
  public static void main(String[] args){
    int N=17 ;
    System.out.println(decimalToBinary(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation decimalToBinary( N : int) : int
  pre: true
  post: true
  activity: (     var B_Number : int ; B_Number := 0 ;
     var cnt : int ; cnt := 0 ;
     while (N /= 0) do (     var rem : int ; rem := N mod 2 ;
     var c : double ; c := 10->pow(cnt) ;
    B_Number := B_Number+(rem * c) ; 
    N := N/(2) ; 
    cnt := cnt + 1 ; 
 ) ; 
     return B_Number );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 17 ;
     OclFile["System.out"].println(decimalToBinary(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int N=1000000 ;
  static long phi[]=new long[N+5];
  static void computeTotient(){
    for(int i=1 ; i<=N ; i++)phi[i]=i ;
    for(int p=2 ; p<=N ; p++){
      if(phi[p]==p){
        phi[p]=p-1 ;
        for(int i=2*p ; i<=N ; i+=p){
          phi[i]=(phi[i]/p)*(p-1);
        }
      }
    }
  }
  static long power(long x,long y,long p){
    long res=1 ;
    x=x % p ;
    while(y>0){
      if((y & 1)>0)res=(res*x)% p ;
      y=y>>1 ;
      x=(x*x)% p ;
    }
    return res ;
  }
  static long calculate(long x,long k,long mod){
    long arr[]=new long[N];
    long count=0 ;
    while(mod>1){
      arr[(int)count++]=mod ;
      mod=phi[(int)mod];
    }
    long result=1 ;
    long loop=count+1 ;
    arr[(int)count]=1 ;
    for(int i=(int)Math.min(k,loop)-1 ; i>=0 ; i--)result=power(x,result,arr[i]);
    return result ;
  }
  public static void main(String args[]){
    computeTotient();
    long x=3,k=2,m=3 ;
    System.out.println(calculate(x,k,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 1000000;
  static   attribute phi : long := Integer.subrange(1,N + 5)->collect(0);
  static   operation computeTotient() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= N do (     phi[i+1] := i ;  ;     i := i + 1 ) ; 
         var p : int ; p := 2 ; while p <= N do ( (     if (phi[p+1] = p) then (     phi[p+1] := p - 1 ; 
         var i : int ; i := 2 * p ; while i <= N do ( (     phi[i+1] := (phi[i+1] / p) * (p - 1) )  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation power( x : long, y : long, p : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     if ((y & 1) > 0) then     res := (res * x) mod p ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res );
  static   operation calculate( x : long, k : long, mod : long) : long
  pre: true
  post: true
  activity: (     var arr : Sequence(long) ; arr := Integer.subrange(1,N)->collect(0) ;
     var count : long ; count := 0 ;
    while (mod > 1) do (      arr[count->oclAsType(int)+1] := mod  ; count->oclAsType(int) := count->oclAsType(int) + 1 ; 
     mod := phi[mod->oclAsType(int)+1] ) ; 
    var result : long ; result := 1 ;
    var loop : long ; loop := count + 1 ;
    arr[count->oclAsType(int)+1] := 1 ; 
        var i : int ; i := Set{k, loop}->min()->oclAsType(int) - 1 ; while i >= 0 do (     result := power(x, result, arr[i+1]) ;  ;     i := i - 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute computeTotient() ; 
     var x : long ; x := 3 ;
    var k : long ; k := 2 ;
    var m : long ; m := 3 ;
     OclFile["System.out"].println(calculate(x, k, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.util.Arrays.*;
import static java.lang.Math.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int N,M ;
  static int[][][] flr=new int[100][100][2];
  static boolean read(){
    N=sc.nextInt();
    if(N==0)return false ;
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        flr[i][j][0]=sc.nextInt();
        flr[i][j][1]=sc.nextInt();
      }
    }
    return true ;
  }
  static int[][] step=new int[100][100];
  static int sol ;
  static void solve(){
    sol=0 ;
    for(int i=0 ; i<N ; i++)fill(step[i],-1);
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        rec(j,i,i*N+j);
      }
    }
    System.out.println(sol);
  }
  static void rec(int x,int y,int s){
    if(step[y][x]==s){
      sol++;
    }
    else if(step[y][x]==-1){
      step[y][x]=s ;
      rec(flr[y][x][0],flr[y][x][1],s);
    }
  }
  public static void main(String[] args){
    while(read())solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int;
  static   attribute flr : Sequence(Sequence(Sequence(int))) := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(Integer.subrange(1,2)->collect(0)));
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     if (N = 0) then     return false else skip ; 
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     flr[i+1][j+1][0+1] := sc.getCurrent()->toInteger() ; 
     flr[i+1][j+1][1+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return true );
  static   attribute step : Sequence(Sequence(int)) := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(0));
  static   attribute sol : int;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     sol := 0 ; 
         var i : int ; i := 0 ; while i < N do (     execute fill(step[i+1], -1) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     execute rec(j, i, i * N + j) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sol) );
  static   operation rec( x : int, y : int, s : int) : void
  pre: true
  post: true
  activity: (     if (step[y+1][x+1] = s) then (     sol := sol + 1 ) else     if (step[y+1][x+1] = -1) then (     step[y+1][x+1] := s ; 
     execute rec(flr[y+1][x+1][0+1], flr[y+1][x+1][1+1], s) ) else skip ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (read()) do     execute solve() ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      int N=in.nextInt();
      if(N==0)return ;
      jump a[][]=new jump[N][N];
      ArrayList<jump>AL=new ArrayList<jump>();
      int field[][]=new int[N][N];
      boolean judge[][]=new boolean[N][N];
      int cnt=0 ;
      for(int i=0 ; i<N ; i++)for(int j=0 ; j<N ; j++){
        jump b=new jump(in.nextInt(),in.nextInt());
        a[j][i]=b ;
      }
      for(int i=0 ; i<N ; i++)for(int j=0 ; j<N ; j++){
        int xx=j ;
        int yy=i ;
        if(field[j][i]==0)for(;
        ;
){
          if(field[xx][yy]==2){
            if(judge[xx][yy]==false){
              cnt++;
              judge[xx][yy]=true ;
            }
            break ;
          }
          field[xx][yy]=2 ;
          jump b=new jump(xx,yy);
          AL.add(b);
          int tx=a[xx][yy] .x ;
          int ty=a[xx][yy] .y ;
          xx=tx ;
          yy=ty ;
        }
        for(int k=0 ; k<AL.size(); k++){
          int rex=AL.get(k).x ;
          int rey=AL.get(k).y ;
          judge[rex][rey]=true ;
        }
      }
      System.out.println(cnt);
    }
  }
}
class jump {
  int x ;
  int y ;
  public jump(int a,int b){
    x=a ;
    y=b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     if (N = 0) then     return else skip ; 
    var a : Sequence(Sequence(jump)) ; a := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(null)) ;
    var AL : Sequence(jump) ; AL := Sequence{} ;
    var field : Sequence(Sequence(int)) ; field := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
    var judge : Sequence(Sequence(boolean)) ; judge := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(false)) ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < N do (         var j : int ; j := 0 ; while j < N do ( (     var b : jump ; b := jump.newjump(in.getCurrent()->toInteger(), in.getCurrent()->toInteger()) ;
     a[j+1][i+1] := b )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do (         var j : int ; j := 0 ; while j < N do ( (     var xx : int ; xx := j ;
     var yy : int ; yy := i ;
     if (field[j+1][i+1] = 0) then       while true do ( (     if (field[xx+1][yy+1] = 2) then (     if (judge[xx+1][yy+1] = false) then (     cnt := cnt + 1 ; 
     judge[xx+1][yy+1] := true ) else skip ; 
     break ) else skip ; 
     field[xx+1][yy+1] := 2 ; 
    var b : jump ; b := jump.newjump(xx, yy) ;
    AL := AL->including(b) ; 
    var tx : int ; tx := a[xx+1][yy+1].x ;
    var ty : int ; ty := a[xx+1][yy+1].y ;
    xx := tx ; 
    yy := ty ; 
 )  ) ; else skip ; 
         var k : int ; k := 0 ; while k < AL->size() do ( (     var rex : int ; rex := AL->at(k+1).x ;
     var rey : int ; rey := AL->at(k+1).y ;
     judge[rex+1][rey+1] := true )  ;     k := k + 1 ) )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 )  ) );
}
class jump {
   attribute x : int;
   attribute y : int;
   static operation newjump( a : int, b : int) : jump
  pre: true
  post: true
  activity:
  ( var self : jump ;
    self := createjump();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     x := a ; 
     y := b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int N ;
  static int[][][] field ;
  static int[][] already ;
  static boolean[][] isLoop ;
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    for(; ; ){
      N=cin.nextInt();
      if(N==0)break ;
      field=new int[N][N][2];
      already=new int[N][N];
      isLoop=new boolean[N][N];
      for(int i=0 ; i<N ; i++){
        for(int j=0 ; j<N ; j++){
          field[j][i][0]=cin.nextInt();
          field[j][i][1]=cin.nextInt();
        }
      }
      int ans=0,cnt=1 ;
      ;
      for(int i=0 ; i<N ; i++){
        for(int j=0 ; j<N ; j++){
          int[] a=a(j,i,cnt++);
          if(a[0]==j && a[1]==i && ! isLoop[j][i]){
            ans++;
            b(j,i);
          }
        }
      }
      System.out.println(ans);
    }
  }
  static void b(int y,int x){
    if(isLoop[y][x])return ;
    isLoop[y][x]=true ;
    int a=field[y][x][0];
    int b=field[y][x][1];
    b(a,b);
  }
  static int[] a(int y,int x,int cnt){
    int a=field[y][x][0];
    int b=field[y][x][1];
    if(already[y][x]==cnt)return new int[] {
      y,x };
      already[y][x]=cnt ;
      return a(a,b,cnt);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute field : Sequence(Sequence(Sequence(int)));
  static   attribute already : Sequence(Sequence(int));
  static   attribute isLoop : Sequence(Sequence(boolean));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     N := cin.getCurrent()->toInteger() ; 
     if (N = 0) then     break else skip ; 
    field := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(Integer.subrange(1,2)->collect(0))) ; 
    already := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ; 
    isLoop := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(false)) ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     field[j+1][i+1][0+1] := cin.getCurrent()->toInteger() ; 
     field[j+1][i+1][1+1] := cin.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var cnt : int ; cnt := 1 ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     var a : Sequence(int) ; a := a(j, i, cnt) ;
     if (a[0+1] = j & a[1+1] = i & not(isLoop[j+1][i+1])) then (     ans := ans + 1 ; 
     execute b(j, i) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ) );
  static   operation b( y : int, x : int) : void
  pre: true
  post: true
  activity: (     if (isLoop[y+1][x+1]) then     return else skip ; 
     isLoop[y+1][x+1] := true ; 
    var a : int ; a := field[y+1][x+1][0+1] ;
    var b : int ; b := field[y+1][x+1][1+1] ;
    execute b(a, b) ; 
 );
  static   operation a( y : int, x : int, cnt : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : int ; a := field[y+1][x+1][0+1] ;
     var b : int ; b := field[y+1][x+1][1+1] ;
    if (already[y+1][x+1] = cnt) then     return Sequence{y,x} else skip ; 
    already[y+1][x+1] := cnt ; 
    return a(a, b, cnt) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int[][][] m=new int[n][n][2];
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)for(int k=0 ; k<2 ; k++)m[i][j][k]=sc.nextInt();
      boolean[][] u=new boolean[n][n];
      int c=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          if(u[i][j])continue ;
          u[i][j]=true ;
          Set<Integer>set=new HashSet<Integer>();
          set.add(i*n+j);
          int nj=m[i][j][0];
          int ni=m[i][j][1];
          while(true){
            if(u[ni][nj]){
              if(set.contains(ni*n+nj))c++;
              break ;
            }
            u[ni][nj]=true ;
            set.add(ni*n+nj);
            int ti=ni ;
            int tj=nj ;
            nj=m[ti][tj][0];
            ni=m[ti][tj][1];
          }
        }
      }
      System.out.println(c);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var m : Sequence(Sequence(Sequence(int))) ; m := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0))) ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (         var k : int ; k := 0 ; while k < 2 do (     m[i+1][j+1][k+1] := sc.getCurrent()->toInteger() ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var u : Sequence(Sequence(boolean)) ; u := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (u[i+1][j+1]) then     continue else skip ; 
     u[i+1][j+1] := true ; 
    var set : Set(int) ; set := Set{} ;
    set := set->including(i * n + j) ; 
    var nj : int ; nj := m[i+1][j+1][0+1] ;
    var ni : int ; ni := m[i+1][j+1][1+1] ;
    while (true) do (     if (u[ni+1][nj+1]) then (     if (set->includes(ni * n + nj)) then     c := c + 1 ; else skip ; 
     break ) else skip ; 
     u[ni+1][nj+1] := true ; 
    set := set->including(ni * n + nj) ; 
    var ti : int ; ti := ni ;
    var tj : int ; tj := nj ;
    nj := m[ti+1][tj+1][0+1] ; 
    ni := m[ti+1][tj+1][1+1] ; 
 ) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int INT_MAX=2147483647 ;
  static int isKthBitSet(int x,int k){
    return((x &(1<<(k-1)))>0)? 1 : 0 ;
  }
  static int leftmostSetBit(int x){
    int count=0 ;
    while(x>0){
      count++;
      x=x>>1 ;
    }
    return count ;
  }
  static int isBinPalindrome(int x){
    int l=leftmostSetBit(x);
    int r=1 ;
    while(l>r){
      if(isKthBitSet(x,l)!=isKthBitSet(x,r))return 0 ;
      l--;
      r++;
    }
    return 1 ;
  }
  static int findNthPalindrome(int n){
    int pal_count=0 ;
    int i=0 ;
    for(i=1 ; i<=INT_MAX ; i++){
      if(isBinPalindrome(i)>0){
        pal_count++;
      }
      if(pal_count==n)break ;
    }
    return i ;
  }
  public static void main(String[] args){
    int n=9 ;
    System.out.println(findNthPalindrome(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute INT_MAX : int := 2147483647;
  static   operation isKthBitSet( x : int, k : int) : int
  pre: true
  post: true
  activity: (     return if ((x & ((1*(2->pow((k - 1))))->oclAsType(long))) > 0) then 1 else 0 endif );
  static   operation leftmostSetBit( x : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (x > 0) do (     count := count + 1 ; 
     x := (x/(2->pow(1)))->oclAsType(long) ) ; 
     return count );
  static   operation isBinPalindrome( x : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := leftmostSetBit(x) ;
     var r : int ; r := 1 ;
     while (l > r) do (     if (isKthBitSet(x, l) /= isKthBitSet(x, r)) then     return 0 else skip ; 
     l := l - 1 ; 
     r := r + 1 ) ; 
     return 1 );
  static   operation findNthPalindrome( n : int) : int
  pre: true
  post: true
  activity: (     var pal_count : int ; pal_count := 0 ;
     var i : int ; i := 0 ;
         i := 1 ; while i <= INT_MAX do ( (     if (isBinPalindrome(i) > 0) then (     pal_count := pal_count + 1 ) else skip ; 
     if (pal_count = n) then     break else skip )  ;     i := i + 1 ) ; 
     return i );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     OclFile["System.out"].println(findNthPalindrome(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=Integer.parseInt(sc.next());
    int ans=0 ;
    if(x<=111){
      ans=111 ;
    }
    else if(x<=222){
      ans=222 ;
    }
    else if(x<=333){
      ans=333 ;
    }
    else if(x<=444){
      ans=444 ;
    }
    else if(x<=555){
      ans=555 ;
    }
    else if(x<=666){
      ans=666 ;
    }
    else if(x<=777){
      ans=777 ;
    }
    else if(x<=888){
      ans=888 ;
    }
    else if(x<=999){
      ans=999 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := (sc.getCurrent())->toInteger() ;
    var ans : int ; ans := 0 ;
    if (x <= 111) then (     ans := 111 ) else     if (x <= 222) then (     ans := 222 ) else     if (x <= 333) then (     ans := 333 ) else     if (x <= 444) then (     ans := 444 ) else     if (x <= 555) then (     ans := 555 ) else     if (x <= 666) then (     ans := 666 ) else     if (x <= 777) then (     ans := 777 ) else     if (x <= 888) then (     ans := 888 ) else     if (x <= 999) then (     ans := 999 ) else skip ; ;  ;  ;  ;  ;  ;  ;  ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maxdiff(int arr[],int n){
    Map<Integer,Integer>freq=new HashMap<>();
    for(int i=0 ; i<n ; i++)freq.put(arr[i],freq.get(arr[i])==null ? 1 : freq.get(arr[i])+1);
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(freq.get(arr[i])>freq.get(arr[j])&& arr[i]>arr[j])ans=Math.max(ans,freq.get(arr[i])-freq.get(arr[j]));
        else if(freq.get(arr[i])<freq.get(arr[j])&& arr[i]<arr[j])ans=Math.max(ans,freq.get(arr[j])-freq.get(arr[i]));
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      3,1,3,2,3,2 };
      int n=arr.length ;
      System.out.println(maxdiff(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxdiff( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var freq : Map(int,int) ; freq := Map{} ;
         var i : int ; i := 0 ; while i < n do (     freq := freq->union(Map{arr[i+1] |-> if freq->at(arr[i+1]) = null then 1 else freq->at(arr[i+1]) + 1 endif}) ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (freq->at(arr[i+1]) > freq->at(arr[j+1]) & arr[i+1] > arr[j+1]) then     ans := Set{ans, freq->at(arr[i+1]) - freq->at(arr[j+1])}->max() ; else     if (freq->at(arr[i+1]) < freq->at(arr[j+1]) & arr[i+1] < arr[j+1]) then     ans := Set{ans, freq->at(arr[j+1]) - freq->at(arr[i+1])}->max() ; else skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,1,3,2,3,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxdiff(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.IOException ;
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Deque ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    String N=sc.next();
    char c=N.charAt(0);
    boolean allsmall=true ;
    for(int i=1 ; i<N.length(); i++){
      if(N.charAt(i)>c)allsmall=false ;
    }
    for(int i=0 ; i<N.length(); i++)System.out.print(allsmall ? ""+c : ""+(char)(c+('2'-'1')));
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : String ; N := sc.getCurrent() ;
    var c : String ; c := N->at(0+1) ;
    var allsmall : boolean ; allsmall := true ;
        var i : int ; i := 1 ; while i < N->size() do ( (     if (N->at(i+1) > c) then     allsmall := false ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N->size() do (     OclFile["System.out"].print(if allsmall then "" + c else "" + (c + (('2')->char2byte() - ('1')->char2byte()))->oclAsType(String) endif) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Set ;
import java.util.HashSet ;
public class CF225_D2_A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    int up=scanner.nextInt();
    while(t--!=0){
      Set<Integer>set=new HashSet<>();
      int n1=scanner.nextInt();
      int n2=scanner.nextInt();
      set.add(n1);
      set.add(n2);
      set.add(up);
      set.add(7-n1);
      set.add(7-n2);
      up=7-up ;
      set.add(up);
      if(set.size()!=6){
        System.out.println("NO");
        System.exit(0);
      }
    }
    System.out.println("YES");
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF225_D2_A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
    var up : int ; up := scanner.getCurrent()->toInteger() ;
        while (t /= 0) do (    skip ; (     var set : Set(int) ; set := Set{} ;
     var n1 : int ; n1 := scanner.getCurrent()->toInteger() ;
    var n2 : int ; n2 := scanner.getCurrent()->toInteger() ;
    set := set->including(n1) ; 
    set := set->including(n2) ; 
    set := set->including(up) ; 
    set := set->including(7 - n1) ; 
    set := set->including(7 - n2) ; 
    up := 7 - up ; 
    set := set->including(up) ; 
    if (set->size() /= 6) then (     OclFile["System.out"].println("NO") ; 
 OclProcess.exit(0) ) else skip ; 
 ) ;  ) ;  
    OclFile["System.out"].println("YES") ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int calculateSum(int n){
    if(n % 2==1)return(n+1)/2 ;
    return-n/2 ;
  }
  public static void main(String ar[]){
    int n=8 ;
    System.out.println(calculateSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculateSum( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 = 1) then     return (n + 1) / 2 else skip ; 
     return -n / 2 );
  static   operation main( ar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     OclFile["System.out"].println(calculateSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.math.RoundingMode ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    if(N % 111==0){
      System.out.println(N);
      return ;
    }
    int DN=N/111 ;
    System.out.println(111*(DN+1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    if (N mod 111 = 0) then (     OclFile["System.out"].println(N) ; 
     return ) else skip ; 
    var DN : int ; DN := N / 111 ;
    OclFile["System.out"].println(111 * (DN + 1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    solve();
  }
  public static void solve(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int i=0 ;
    while(true){
      if((n+i)% 111==0){
        System.out.println(n+i);
        break ;
      }
      i++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var i : int ; i := 0 ;
     while (true) do (     if ((n + i) mod 111 = 0) then (     OclFile["System.out"].println(n + i) ; 
     break ) else skip ; 
     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Integer list[]={
      111,222,333,444,555,666,777,888,999 };
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int ret=0 ;
      for(int i=n ; true ; i++){
        if(Arrays.asList(list).contains(i)){
          ret=i ;
          break ;
        }
      }
      System.out.println(ret);
      sc.close();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{111,222,333,444,555,666,777,888,999} ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var ret : int ; ret := 0 ;
        var i : int ; i := n ; while true do ( (     if (list->includes(i)) then (     ret := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ret) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int[][] field=new int[h+2][w+2];
    int[] arr=new int[h*w];
    for(int i=0 ; i<h*w ; i++){
      int x=sc.nextInt();
      arr[x-1]=i ;
    }
    int count=0 ;
    for(int i=0 ; i<h*w ; i++){
      int hh=arr[i]/w+1 ;
      int ww=arr[i] % w+1 ;
      int[] besides=new int[] {
        field[hh-1][ww],field[hh][ww-1],field[hh+1][ww],field[hh][ww+1] };
        Arrays.sort(besides);
        if(besides[0]==-1){
          field[hh][ww]=-1 ;
          count++;
        }
        else {
          int x=besides[0];
          for(int j=1 ; j<4 ; j++){
            if(x==0){
              x=besides[j];
            }
            else {
              if(x!=besides[j]){
                field[hh][ww]=-1 ;
                count++;
                break ;
              }
            }
          }
          if(field[hh][ww]==-1){
            continue ;
          }
          if(x==0){
            field[hh][ww]=i+1 ;
          }
          else {
            field[hh][ww]=x ;
          }
        }
      }
      System.out.println(count);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var field : Sequence(Sequence(int)) ; field := Integer.subrange(1,h + 2)->collect(Integer.subrange(1,w + 2)->collect(0)) ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,h * w)->collect(0) ;
        var i : int ; i := 0 ; while i < h * w do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     arr[x - 1+1] := i )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < h * w do ( (     var hh : int ; hh := arr[i+1] / w + 1 ;
     var ww : int ; ww := arr[i+1] mod w + 1 ;
    var besides : Sequence(int) ; besides := Sequence{field[hh - 1+1][ww+1],field[hh+1][ww - 1+1],field[hh + 1+1][ww+1],field[hh+1][ww + 1+1]} ;
    besides := besides->sort() ; 
    if (besides[0+1] = -1) then (     field[hh+1][ww+1] := -1 ; 
     count := count + 1 ) else (     var x : int ; x := besides[0+1] ;
         var j : int ; j := 1 ; while j < 4 do ( (     if (x = 0) then (     x := besides[j+1] ) else (     if (x /= besides[j+1]) then (     field[hh+1][ww+1] := -1 ; 
     count := count + 1 ; 
     break ) else skip ) )  ;     j := j + 1 ) ; 
     if (field[hh+1][ww+1] = -1) then (     continue ) else skip ; 
     if (x = 0) then (     field[hh+1][ww+1] := i + 1 ) else (     field[hh+1][ww+1] := x ) ) ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double Perimeter(double s,int n){
    double perimeter=1 ;
    perimeter=n*s ;
    return perimeter ;
  }
  public static void main(String[] args){
    int n=5 ;
    double s=2.5,peri ;
    peri=Perimeter(s,n);
    System.out.println("Perimeter of Regular Polygon"+" with "+n+" sides of length "+s+"="+peri);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Perimeter( s : double, n : int) : double
  pre: true
  post: true
  activity: (     var perimeter : double ; perimeter := 1 ;
     perimeter := n * s ; 
     return perimeter );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var s : double ; s := 2.5 ;
    var peri : double ;
     peri := Perimeter(s, n) ; 
     OclFile["System.out"].println("Perimeter of Regular Polygon" + " with " + n + " sides of length " + s + "=" + peri) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  static List<long[]>list=new ArrayList<>();
  public static void main(String[] args){
    InputReader s=new InputReader();
    int n=s.nextInt();
    if(n<0)n=-n ;
    int sum=0 ;
    for(int i=0 ; ; i++){
      sum+=i ;
      if(n==sum || sum>n &&(sum-n)% 2==0){
        System.out.println(i);
        return ;
      }
    }
  }
}
class InputReader {
  public BufferedReader reader ;
  public StringTokenizer tokenizer ;
  public InputReader(){
    reader=new BufferedReader(new InputStreamReader(System.in),32768);
    tokenizer=null ;
  }
  public String next(){
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        tokenizer=new StringTokenizer(reader.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public double nextDouble(){
    return Double.parseDouble(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute list : Sequence(Sequence(long)) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : InputReader ; s := InputReader.newInputReader() ;
     var n : int ; n := s.nextInt() ;
    if (n < 0) then     n := -n ; else skip ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while true do ( (     sum := sum+(i) ; 
     if (n = sum or sum > n & (sum - n) mod 2 = 0) then (     OclFile["System.out"].println(i) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
 );
}
class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader() : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int x=Math.abs(sc.nextInt());
      System.out.println(minTimes(x));
    }
    sc.close();
  }
  public static long minTimes(long x){
    if(x==0){
      return 0 ;
    }
    long l=0 ;
    long r=x ;
    long m=0 ;
    long near=0 ;
    while(l<=r){
      m=(l+r)/2 ;
      if(sum(m)>=x){
        near=m ;
        r=m-1 ;
      }
      else {
        l=m+1 ;
      }
    }
    if(sum(near)==x){
      return near ;
    }
    if(((sum(near)-x)& 1)==1){
      near++;
    }
    if(((sum(near)-x)& 1)==1){
      near++;
    }
    return near ;
  }
  public static long sum(long n){
    return(n*(n+1))/2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var x : int ; x := if sc.getCurrent()->toInteger() < 0 then -(sc.getCurrent()->toInteger()) else sc.getCurrent()->toInteger() endif ;
     OclFile["System.out"].println(minTimes(x)) ) ; 
     skip );
  static   operation minTimes( x : long) : long
  pre: true
  post: true
  activity: (     if (x = 0) then (     return 0 ) else skip ; 
     var l : long ; l := 0 ;
    var r : long ; r := x ;
    var m : long ; m := 0 ;
    var near : long ; near := 0 ;
    while (l <= r) do (     m := (l + r) / 2 ; 
     if (sum(m) >= x) then (     near := m ; 
     r := m - 1 ) else (     l := m + 1 ) ) ; 
    if (sum(near) = x) then (     return near ) else skip ; 
    if (((sum(near) - x) & 1) = 1) then (     near := near + 1 ) else skip ; 
    if (((sum(near) - x) & 1) = 1) then (     near := near + 1 ) else skip ; 
    return near 
 );
  static   operation sum( n : long) : long
  pre: true
  post: true
  activity: (     return (n * (n + 1)) / 2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF_1447B_NumbersBox {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int count=scanner.nextInt();
    for(int i=0 ; i<count ; i++){
      int n=scanner.nextInt();
      int m=scanner.nextInt();
      int[] arr=new int[n*m];
      int nagiviteTimes=0 ;
      int minNum=Integer.MAX_VALUE ;
      int sumNum=0 ;
      for(int j=0 ; j<arr.length ; j++){
        arr[j]=scanner.nextInt();
        if(arr[j]<0){
          arr[j]=0-arr[j];
          nagiviteTimes++;
          sumNum+=arr[j];
          if(minNum>arr[j]){
            minNum=arr[j];
          }
        }
        else {
          sumNum+=arr[j];
          if(minNum>arr[j]){
            minNum=arr[j];
          }
        }
      }
      if(nagiviteTimes % 2==0){
        System.out.println(sumNum);
      }
      else {
        System.out.println(sumNum-minNum*2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF_1447B_NumbersBox {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < count do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n * m)->collect(0) ;
    var nagiviteTimes : int ; nagiviteTimes := 0 ;
    var minNum : int ; minNum := 2147483647 ;
    var sumNum : int ; sumNum := 0 ;
        var j : int ; j := 0 ; while j < arr->size() do ( (     arr[j+1] := scanner.getCurrent()->toInteger() ; 
     if (arr[j+1] < 0) then (     arr[j+1] := 0 - arr[j+1] ; 
     nagiviteTimes := nagiviteTimes + 1 ; 
     sumNum := sumNum+(arr[j+1]) ; 
     if (minNum > arr[j+1]) then (     minNum := arr[j+1] ) else skip ) else (     sumNum := sumNum+(arr[j+1]) ; 
     if (minNum > arr[j+1]) then (     minNum := arr[j+1] ) else skip ) )  ;     j := j + 1 ) ; 
    if (nagiviteTimes mod 2 = 0) then (     OclFile["System.out"].println(sumNum) ) else (     OclFile["System.out"].println(sumNum - minNum * 2) ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    new Main().solve();
  }
  Scanner in ;
  PrintWriter out ;
  int a[]=new int[5];
  public void solve(){
    in=new Scanner(System.in);
    out=new PrintWriter(System.out);
    int t=1 ;
    while(t-->0){
      long n=in.nextLong(),ans=0 ;
      n=Math.abs(n);
      long now=0 ;
      while(true){
        Long mid=(now)*(now+1)/2 ;
        if(mid==n){
          ans=now ;
          break ;
        }
        else if(mid>n){
          if((mid-n)% 2==0){
            ans=now ;
            break ;
          }
        }
        now++;
      }
      out.println(ans);
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   attribute in : OclFile;
   attribute out : OclFile;
   attribute a : int := Integer.subrange(1,5)->collect(0);
   operation solve() : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    var t : int ; t := 1 ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := in.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
     n := if n < 0 then -(n) else n endif ; 
    var now : long ; now := 0 ;
    while (true) do (     var mid : long ; mid := (now) * (now + 1) / 2 ;
     if (mid = n) then (     ans := now ; 
     break ) else     if (mid > n) then (     if ((mid - n) mod 2 = 0) then (     ans := now ; 
     break ) else skip ) else skip ; ;  
     now := now + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    x=Math.abs(x);
    if(x==0){
      System.out.println("0");
      return ;
    }
    int ans=0,sum=0,num=1 ;
    while(sum!=x){
      sum+=num ;
      if(sum>x &&((sum-x)% 2)==0){
        ans++;
        break ;
      }
      ans++;
      num++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    x := if x < 0 then -(x) else x endif ; 
    if (x = 0) then (     OclFile["System.out"].println("0") ; 
     return ) else skip ; 
    var ans : int ; ans := 0 ;
    var sum : int ; sum := 0 ;
    var num : int ; num := 1 ;
    while (sum /= x) do (     sum := sum+(num) ; 
     if (sum > x & ((sum - x) mod 2) = 0) then (     ans := ans + 1 ; 
     break ) else skip ; 
     ans := ans + 1 ; 
     num := num + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void max_element(int a[],int n){
    int[] pre=new int[n];
    pre[0]=a[0];
    for(int i=1 ; i<n ; i++)pre[i]=Math.max(pre[i-1],a[i]);
    int[] suf=new int[n];
    suf[n-1]=a[n-1];
    for(int i=n-2 ; i>=0 ; i--)suf[i]=Math.max(suf[i+1],a[i]);
    for(int i=0 ; i<n ; i++){
      if(i==0)System.out.print(suf[i+1]+" ");
      else if(i==n-1)System.out.print(pre[i-1]+" ");
      else System.out.print(Math.max(pre[i-1],suf[i+1])+" ");
    }
  }
  public static void main(String[] args){
    int a[]={
      2,5,6,1,3 };
      int n=a.length ;
      max_element(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation max_element( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var pre : Sequence(int) ; pre := Integer.subrange(1,n)->collect(0) ;
     pre[0+1] := a[0+1] ; 
        var i : int ; i := 1 ; while i < n do (     pre[i+1] := Set{pre[i - 1+1], a[i+1]}->max() ;  ;     i := i + 1 ) ; 
    var suf : Sequence(int) ; suf := Integer.subrange(1,n)->collect(0) ;
    suf[n - 1+1] := a[n - 1+1] ; 
        var i : int ; i := n - 2 ; while i >= 0 do (     suf[i+1] := Set{suf[i + 1+1], a[i+1]}->max() ;  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i = 0) then     OclFile["System.out"].print(suf[i + 1+1] + " ") ; else     if (i = n - 1) then     OclFile["System.out"].print(pre[i - 1+1] + " ") else     OclFile["System.out"].print(Set{pre[i - 1+1], suf[i + 1+1]}->max() + " ") ; ;  )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,5,6,1,3} ;
     var n : int ; n := a->size() ;
     execute max_element(a, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findLastIndex(String str,Character x){
    for(int i=str.length()-1 ; i>=0 ; i--)if(str.charAt(i)==x)return i ;
    return-1 ;
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    Character x='e' ;
    int index=findLastIndex(str,x);
    if(index==-1)System.out.println("Character not found");
    else System.out.println("Last index is "+index);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findLastIndex( str : String, x : String) : int
  pre: true
  post: true
  activity: (         var i : int ; i := str->size() - 1 ; while i >= 0 do (     if (str->at(i+1) = x) then     return i else skip ;  ;     i := i - 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var x : String ; x := 'e' ;
     var index : int ; index := findLastIndex(str, x) ;
     if (index = -1) then     OclFile["System.out"].println("Character not found") ; else     OclFile["System.out"].println("Last index is " + index) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileNotFoundException ;
import java.util.Scanner ;
public class Main {
  int n ;
  String[] s ;
  int[] d ;
  public static void main(String[] args)throws FileNotFoundException {
    new Main().run();
  }
  private void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      s=new String[1000];
      d=new int[1000];
      n=sc.nextInt();
      if(n==0)return ;
      sc.nextLine();
      for(int i=0 ; i<n ; i++){
        s[i]=sc.nextLine();
        for(int j=0 ; j<s[i] .length(); j++){
          if(s[i] .charAt(j)!='.'){
            d[i]=j ;
            break ;
          }
        }
        s[i]=s[i] .replace(".","");
      }
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<d[i]; j++){
          if(j==d[i]-1){
            System.out.print("+");
          }
          else {
            int x=-1,y=-1 ;
            for(int p=i-1 ; p>=0 ; p--){
              if(j==d[p]-1){
                x=p ;
                break ;
              }
              else if(j>d[p]-1){
                break ;
              }
            }
            for(int q=i+1 ; q<n ; q++){
              if(j==d[q]-1){
                y=q ;
                break ;
              }
              else if(j>d[q]-1){
                break ;
              }
            }
            if(x==-1 || y==-1){
              System.out.print(" ");
            }
            else if(y-x>=2){
              System.out.print("|");
            }
            else {
              System.out.print(" ");
            }
          }
        }
        System.out.println(s[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute s : Sequence(String);
   attribute d : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     s := Integer.subrange(1,1000)->collect(null) ; 
     d := Integer.subrange(1,1000)->collect(0) ; 
    n := sc.getCurrent()->toInteger() ; 
    if (n = 0) then     return else skip ; 
    skip ; 
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := sc.nextLine() ; 
         var j : int ; j := 0 ; while j < s[i+1]->size() do ( (     if (s[i+1]->at(j+1) /= '.') then (     d[i+1] := j ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     s[i+1] := s[i+1].replace(".", "") )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < d[i+1] do ( (     if (j = d[i+1] - 1) then (     OclFile["System.out"].print("+") ) else (     var x : int ; x := -1 ;
    var y : int ; y := -1 ;
         var p : int ; p := i - 1 ; while p >= 0 do ( (     if (j = d[p+1] - 1) then (     x := p ; 
     break ) else     if (j > d[p+1] - 1) then (     break ) else skip ; )  ;     p := p - 1 ) ; 
         var q : int ; q := i + 1 ; while q < n do ( (     if (j = d[q+1] - 1) then (     y := q ; 
     break ) else     if (j > d[q+1] - 1) then (     break ) else skip ; )  ;     q := q + 1 ) ; 
     if (x = -1 or y = -1) then (     OclFile["System.out"].print(" ") ) else     if (y - x >= 2) then (     OclFile["System.out"].print("|") ) else (     OclFile["System.out"].print(" ") ) ;  ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(s[i+1]) )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    while(true){
      final int n=Integer.parseInt(sc.nextLine());
      if(n==0){
        break ;
      }
      char[][] map=new char[n][];
      for(int i=0 ; i<n ; i++){
        map[i]=sc.nextLine().toCharArray();
      }
      LinkedList<Integer>stack=new LinkedList<Integer>();
      for(int i=n-1 ; i>=0 ; i--){
        int pos=0 ;
        if(map[i][pos]!='.'){
          continue ;
        }
        while(pos<map[i] .length && map[i][pos]=='.'){
          pos++;
        }
        final int height=pos-1 ;
        while(! stack.isEmpty()){
          if(stack.getLast()>=height){
            stack.removeLast();
          }
          else {
            break ;
          }
        }
        for(int high : stack){
          map[i][high]='|' ;
        }
        map[i][height]='+' ;
        for(int j=0 ; j<height ; j++){
          if(map[i][j]=='.'){
            map[i][j]=' ' ;
          }
        }
        stack.addLast(height);
      }
      for(int i=0 ; i<n ; i++){
        System.out.println(map[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := (sc.nextLine())->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var map : Sequence(Sequence(String)) ; map := Integer.subrange(1,n)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < n do ( (     map[i+1] := sc.nextLine()->characters() )  ;     i := i + 1 ) ; 
    var stack : Sequence(int) ; stack := Sequence{} ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     var pos : int ; pos := 0 ;
     if (map[i+1][pos+1] /= '.') then (     continue ) else skip ; 
    while (pos < map[i+1]->size() & map[i+1][pos+1] = '.') do (     pos := pos + 1 ) ; 
    var height : int ; height := pos - 1 ;
    while (not(stack->isEmpty())) do (     if (stack->last() >= height) then (     stack := stack->front() ) else (     break ) ) ; 
    for (high : stack) do ( (     map[i+1][high+1] := '|' )  ) ; 
    map[i+1][height+1] := '+' ; 
        var j : int ; j := 0 ; while j < height do ( (     if (map[i+1][j+1] = '.') then (     map[i+1][j+1] := ' ' ) else skip )  ;     j := j + 1 ) ; 
    stack := stack->append(height) ; 
 )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(map[i+1]) )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  static int MAX=999+51 ;
  static char TERM='Z' ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=parseInt(line);
      if(n==0)break ;
      char[][] board=new char[n][MAX];
      int check=0 ;
      for(int i=0 ; i<n ; i++){
        line=br.readLine();
        for(int j=0 ; j<line.length(); j++){
          char c=line.charAt(j);
          board[i][j]=c ;
          if(c=='.'){
            check++;
            if(line.charAt(j+1)>='a'){
              board[i][j]='+' ;
              check--;
            }
          }
        }
        board[i][line.length()]=TERM ;
      }
      for(int j=0 ; j<MAX ; j++){
        for(int i=n-1 ; i>0 ; i--){
          char c=board[i][j];
          if(c=='+'){
            for(int k=i-1 ; k>0 ; k--){
              if(board[k][j]=='.'){
                board[k][j]='|' ;
                check--;
              }
              else break ;
            }
          }
          else if(c=='.'){
            board[i][j]=' ' ;
            check--;
          }
        }
        if(check==0)break ;
      }
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<MAX ; j++){
          char c=board[i][j];
          if(c==TERM)break ;
          System.out.print(board[i][j]);
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MAX : int := 999 + 51;
  static   attribute TERM : String := 'Z';
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := parseInt(line) ;
     if (n = 0) then     break else skip ; 
    var board : Sequence(Sequence(String)) ; board := Integer.subrange(1,n)->collect(Integer.subrange(1,MAX)->collect(0)) ;
    var check : int ; check := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     line := br.readLine() ; 
         var j : int ; j := 0 ; while j < line->size() do ( (     var c : String ; c := line->at(j+1) ;
     board[i+1][j+1] := c ; 
     if (c = '.') then (     check := check + 1 ; 
     if (line->at(j + 1+1) >= 'a') then (     board[i+1][j+1] := '+' ; 
     check := check - 1 ) else skip ) else skip )  ;     j := j + 1 ) ; 
     board[i+1][line->size()+1] := TERM )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < MAX do ( (         var i : int ; i := (n)->char2byte() - 1 ; while i > 0 do ( (     var c : String ; c := board[i+1][j+1] ;
     if (c = '+') then (         var k : int ; k := i - 1 ; while k > 0 do ( (     if (board[k+1][j+1] = '.') then (     board[k+1][j+1] := '|' ; 
     check := check - 1 ) else     break )  ;     k := k - 1 ) ) else     if (c = '.') then (     board[i+1][j+1] := ' ' ; 
     check := check - 1 ) else skip ; )  ;     i := i - 1 ) ; 
     if (check = 0) then     break else skip )  ;     j := j + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < MAX do ( (     var c : String ; c := board[i+1][j+1] ;
     if (c = TERM) then     break else skip ; 
     OclFile["System.out"].print(board[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public void run(){
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      calc(n);
    }
  }
  public void calc(int n){
    char[][] words=new char[n][];
    words[0]=sc.next().toCharArray();
    for(int i=1 ; i<n ; i++){
      words[i]=sc.next().toCharArray();
      int before=-1 ;
      int mmax=0 ;
      for(int k=0 ; k<words[i] .length ; k++){
        if(words[i][k+1]!='.'){
          words[i][k]='+' ;
          for(int j=i-1 ; j>=0 ; j--){
            if(words[j][k]==' '){
              words[j][k]='|' ;
            }
            else break ;
          }
          break ;
        }
        else {
          words[i][k]=' ' ;
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      System.out.println(words[i]);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
     execute calc(n) ) );
   operation calc( n : int) : void
  pre: true
  post: true
  activity: (     var words : Sequence(Sequence(String)) ; words := Integer.subrange(1,n)->collect(Sequence{}) ;
     words[0+1] := sc.getCurrent()->characters() ; 
         var i : int ; i := 1 ; while i < n do ( (     words[i+1] := sc.getCurrent()->characters() ; 
     var before : int ; before := -1 ;
     var mmax : int ; mmax := 0 ;
         var k : int ; k := 0 ; while k < words[i+1]->size() do ( (     if (words[i+1][k + 1+1] /= '.') then (     words[i+1][k+1] := '+' ; 
         var j : int ; j := i - 1 ; while j >= 0 do ( (     if (words[j+1][k+1] = ' ') then (     words[j+1][k+1] := '|' ) else     break )  ;     j := j - 1 ) ; 
     break ) else (     words[i+1][k+1] := ' ' ) )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(words[i+1]) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(true){
      int n=in.nextInt();
      if(n==0)break ;
      ArrayList<ArrayList<Character>>head=new ArrayList<>();
      String[] body=new String[n];
      for(int i=0 ; i<n ; i++){
        head.add(new ArrayList<Character>());
        String txt=in.next();
        int j=0 ;
        while(txt.charAt(j)=='.'){
          head.get(i).add(' ');
          j++;
        }
        body[i]=txt.substring(j);
      }
      for(int i=0 ; i<n ; i++){
        ArrayList<Character>line=head.get(i);
        int col=line.size()-1 ;
        if(line.size()==0)continue ;
        line.set(col,'+');
        int j=i-1 ;
        while(head.get(j).size()-1>col){
          head.get(j).set(col,'|');
          j--;
        }
      }
      for(int i=0 ; i<n ; i++){
        ArrayList<Character>line=head.get(i);
        for(int j=0 ; j<line.size(); j++){
          System.out.print(line.get(j));
        }
        System.out.println(body[i]);
      }
      System.gc();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var head : Sequence(Sequence(String)) ; head := Sequence{} ;
    var body : Sequence(String) ; body := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     head := head->including(Sequence{}) ; 
     var txt : String ; txt := in.getCurrent() ;
    var j : int ; j := 0 ;
    while (txt->at(j+1) = '.') do (     head->at(i+1)->excludes(' ') ; 
     j := j + 1 ) ; 
    body[i+1] := txt.subrange(j+1,j) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var line : Sequence(String) ; line := head->at(i+1) ;
     var col : int ; col := line->size() - 1 ;
    if (line->size() = 0) then     continue else skip ; 
    line := line.setAt(col+1,'+') ; 
    var j : int ; j := i - 1 ;
    while (head->at(j+1)->size() - 1 > col) do (     head := head->at(j+1).setAt(col+1, '|') ; 
     j := j - 1 ) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var line : Sequence(String) ; line := head->at(i+1) ;
         var j : int ; j := 0 ; while j < line->size() do ( (     OclFile["System.out"].print(line->at(j+1)) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(body[i+1]) )  ;     i := i + 1 ) ; 
gc() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MinimumCost(int a[],int n,int x){
    for(int i=1 ; i<n ; i++){
      a[i]=Math.min(a[i],2*a[i-1]);
    }
    int ind=0 ;
    int sum=0 ;
    while(x>0){
      if(x!=0)sum+=a[ind];
      ind++;
      x=x>>1 ;
    }
    return sum ;
  }
  public static void main(String[] args){
    int a[]={
      20,50,60,90 };
      int x=7 ;
      int n=a.length ;
      System.out.println(MinimumCost(a,n,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MinimumCost( a : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < n do ( (     a[i+1] := Set{a[i+1], 2 * a[i - 1+1]}->min() )  ;     i := i + 1 ) ; 
     var ind : int ; ind := 0 ;
    var sum : int ; sum := 0 ;
    while (x > 0) do (     if (x /= 0) then     sum := sum+(a[ind+1]) ; else skip ; 
     ind := ind + 1 ; 
     x := (x/(2->pow(1)))->oclAsType(long) ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{20,50,60,90} ;
     var x : int ; x := 7 ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(MinimumCost(a, n, x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class AP {
  static void makeAP(int arr[],int n){
    int initial_term,common_difference ;
    if(n==3){
      common_difference=arr[2]-arr[1];
      initial_term=arr[1]-common_difference ;
    }
    else if((arr[1]-arr[0])==arr[2]-arr[1]){
      initial_term=arr[0];
      common_difference=arr[1]-arr[0];
    }
    else if((arr[2]-arr[1])==(arr[3]-arr[2])){
      common_difference=arr[2]-arr[1];
      initial_term=arr[1]-common_difference ;
    }
    else {
      common_difference=(arr[3]-arr[0])/3 ;
      initial_term=arr[0];
    }
    for(int i=0 ; i<n ; i++)System.out.print(initial_term+(i*common_difference)+" ");
    System.out.println();
  }
  public static void main(String[] args){
    int arr[]={
      1,3,7 };
      int n=arr.length ;
      makeAP(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class AP {
  static   operation makeAP( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var initial_term : int ;
    var common_difference : int ;
     if (n = 3) then (     common_difference := arr[2+1] - arr[1+1] ; 
     initial_term := arr[1+1] - common_difference ) else     if ((arr[1+1] - arr[0+1]) = arr[2+1] - arr[1+1]) then (     initial_term := arr[0+1] ; 
     common_difference := arr[1+1] - arr[0+1] ) else     if ((arr[2+1] - arr[1+1]) = (arr[3+1] - arr[2+1])) then (     common_difference := arr[2+1] - arr[1+1] ; 
     initial_term := arr[1+1] - common_difference ) else (     common_difference := (arr[3+1] - arr[0+1]) / 3 ; 
     initial_term := arr[0+1] ) ;  ;  ;  
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(initial_term + (i * common_difference) + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,7} ;
     var n : int ; n := arr->size() ;
     execute makeAP(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAX=1005 ;
  static int shortestSeq(char[] S,char[] T){
    int m=S.length,n=T.length ;
    int dp[][]=new int[m+1][n+1];
    for(int i=0 ; i<=m ; i++){
      dp[i][0]=1 ;
    }
    for(int i=0 ; i<=n ; i++){
      dp[0][i]=MAX ;
    }
    for(int i=1 ; i<=m ; i++){
      for(int j=1 ; j<=n ; j++){
        char ch=S[i-1];
        int k ;
        for(k=j-1 ; k>=0 ; k--){
          if(T[k]==ch){
            break ;
          }
        }
        if(k==-1){
          dp[i][j]=1 ;
        }
        else {
          dp[i][j]=Math.min(dp[i-1][j],dp[i-1][k]+1);
        }
      }
    }
    int ans=dp[m][n];
    if(ans>=MAX){
      ans=-1 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    char S[]="babab".toCharArray();
    char T[]="babba".toCharArray();
    int m=S.length,n=T.length ;
    System.out.println("Length of shortest"+"subsequence is : "+shortestSeq(S,T));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 1005;
  static   operation shortestSeq( S : Sequence(String), T : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var m : int ; m := S->size() ;
    var n : int ; n := T->size() ;
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i <= m do ( (     dp[i+1][0+1] := 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= n do ( (     dp[0+1][i+1] := MAX )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= m do ( (         var j : int ; j := 1 ; while j <= n do ( (     var ch : String ; ch := S[i - 1+1] ;
     var k : int ;
         k := j - 1 ; while k >= 0 do ( (     if (T[k+1] = ch) then (     break ) else skip )  ;     k := k - 1 ) ; 
     if (k = -1) then (     dp[i+1][j+1] := 1 ) else (     dp[i+1][j+1] := Set{dp[i - 1+1][j+1], dp[i - 1+1][k+1] + 1}->min() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := dp[m+1][n+1] ;
    if (ans >= MAX) then (     ans := -1 ) else skip ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : Sequence(String) ; S := "babab"->characters() ;
     var T : Sequence(String) ; T := "babba"->characters() ;
     var m : int ; m := S->size() ;
    var n : int ; n := T->size() ;
     OclFile["System.out"].println("Length of shortest" + "subsequence is : " + shortestSeq(S, T)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int sumOfPairs(int n){
    ArrayList<Integer>v=new ArrayList<Integer>();
    int sum=0 ;
    while(n>0){
      v.add(n % 2);
      n=n/2 ;
    }
    Collections.reverse(v);
    for(int i=0 ; i<v.size()-1 ; i++){
      for(int j=i+1 ; j<v.size(); j++){
        if(v.get(i)==0 && v.get(j)==1)sum+=1 ;
        if(v.get(i)==1 && v.get(j)==1)sum+=3 ;
        if(v.get(i)==1 && v.get(j)==0)sum+=2 ;
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int N=5 ;
    System.out.print(sumOfPairs(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfPairs( n : int) : int
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Sequence{} ;
     var sum : int ; sum := 0 ;
    while (n > 0) do (     v := v->including(n mod 2) ; 
     n := n / 2 ) ; 
    v := v->reverse() ; 
        var i : int ; i := 0 ; while i < v->size() - 1 do ( (         var j : int ; j := i + 1 ; while j < v->size() do ( (     if (v->at(i+1) = 0 & v->at(j+1) = 1) then     sum := sum+(1) ; else skip ; 
     if (v->at(i+1) = 1 & v->at(j+1) = 1) then     sum := sum+(3) ; else skip ; 
     if (v->at(i+1) = 1 & v->at(j+1) = 0) then     sum := sum+(2) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     OclFile["System.out"].print(sumOfPairs(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int largestSubset(int[] a,int n){
    Arrays.sort(a);
    int[] dp=new int[n];
    dp[n-1]=1 ;
    for(int i=n-2 ; i>=0 ; i--){
      int mxm=0 ;
      for(int j=i+1 ; j<n ; j++){
        if(a[j] % a[i]==0){
          mxm=Math.max(mxm,dp[j]);
        }
      }
      dp[i]=1+mxm ;
    }
    return Arrays.stream(dp).max().getAsInt();
  }
  public static void main(String[] args){
    int[] a={
      1,3,6,13,17,18 };
      int n=a.length ;
      System.out.println(largestSubset(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation largestSubset( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
    dp[n - 1+1] := 1 ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     var mxm : int ; mxm := 0 ;
         var j : int ; j := i + 1 ; while j < n do ( (     if (a[j+1] mod a[i+1] = 0) then (     mxm := Set{mxm, dp[j+1]}->max() ) else skip )  ;     j := j + 1 ) ; 
     dp[i+1] := 1 + mxm )  ;     i := i - 1 ) ; 
    return stream(dp).max().getAsInt() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,3,6,13,17,18} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(largestSubset(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class AlternateSetBits {
  static boolean allBitsAreSet(int n){
    if(((n+1)& n)==0)return true ;
    return false ;
  }
  static boolean bitsAreInAltOrder(int n){
    int num=n ^(n>>>1);
    return allBitsAreSet(num);
  }
  public static void main(String args[]){
    int n=10 ;
    if(bitsAreInAltOrder(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class AlternateSetBits {
  static   operation allBitsAreSet( n : int) : boolean
  pre: true
  post: true
  activity: (     if (((n + 1) & n) = 0) then     return true else skip ; 
     return false );
  static   operation bitsAreInAltOrder( n : int) : boolean
  pre: true
  post: true
  activity: (     var num : int ; num := MathLib.bitwiseXor(n,((n/(2->pow(1)))->oclAsType(long))) ;
     return allBitsAreSet(num) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     if (bitsAreInAltOrder(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findLastIndex(String str,Character x){
    int index=-1 ;
    for(int i=0 ; i<str.length(); i++)if(str.charAt(i)==x)index=i ;
    return index ;
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    Character x='e' ;
    int index=findLastIndex(str,x);
    if(index==-1)System.out.println("Character not found");
    else System.out.println("Last index is "+index);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findLastIndex( str : String, x : String) : int
  pre: true
  post: true
  activity: (     var index : int ; index := -1 ;
         var i : int ; i := 0 ; while i < str->size() do (     if (str->at(i+1) = x) then     index := i ; else skip ;  ;     i := i + 1 ) ; 
     return index );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var x : String ; x := 'e' ;
     var index : int ; index := findLastIndex(str, x) ;
     if (index = -1) then     OclFile["System.out"].println("Character not found") ; else     OclFile["System.out"].println("Last index is " + index) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void findTriangles(int n){
    int num=n ;
    System.out.print(num+" ");
    System.out.print(num*(num-4)*(num-5)/6);
  }
  public static void main(String[] args){
    int n ;
    n=6 ;
    findTriangles(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findTriangles( n : int) : void
  pre: true
  post: true
  activity: (     var num : int ; num := n ;
     OclFile["System.out"].print(num + " ") ; 
     OclFile["System.out"].print(num * (num - 4) * (num - 5) / 6) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     n := 6 ; 
     execute findTriangles(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Deque ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int q=sc.nextInt();
    List<Deque<Integer>>list=new ArrayList<Deque<Integer>>();
    for(int i=0 ; i<n ; i++){
      list.add(new ArrayDeque<Integer>());
    }
    for(int i=0 ; i<q ; i++){
      int query=sc.nextInt();
      int t=sc.nextInt();
      switch(query){
        case 0 : int x=sc.nextInt();
        list.get(t).add(x);
        break ;
        case 1 : if(!(list.get(t).isEmpty())){
          System.out.println(list.get(t).peekFirst());
        }
        break ;
        case 2 : list.get(t).pollFirst();
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var list : Sequence(Sequence(int)) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(ArrayDeque<int>.newArrayDeque()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var query : int ; query := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (query) ; 
       if _switchval = 0 then
     var x : int ; x := sc.getCurrent()->toInteger() ;
    list->at(t+1)->excludes(x) ; 
    break 
   else skip ;
       if _switchval = 1 then
     if (not((list->at(t+1)->isEmpty()))) then (     OclFile["System.out"].println(list->at(t+1).peekFirst()) ) else skip ; 
    break 
   else skip ;
       if _switchval = 2 then
     list := list->at(t+1)->tail() ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  static final int INIT=8 ;
  static int[] grow(int[] s){
    int[] d=new int[s.length*2];
    System.arraycopy(s,0,d,0,s.length);
    return d ;
  }
  static class Queue {
    private int[] data ;
    private int r,w ;
    public Queue(){
      data=new int[INIT];
    }
    public boolean isEmpty(){
      return r==w ;
    }
    public void enqueue(int x){
      if(w>=data.length){
        data=grow(data);
      }
      data[w++]=x ;
    }
    public int getFront(){
      return data[r];
    }
    public void dequeue(){
      if(! isEmpty()){
        r++;
      }
    }
  }
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      Queue[] qq=new Queue[n];
      for(int i=0 ; i<n ; i++){
        qq[i]=new Queue();
      }
      int q=sc.nextInt();
      for(int i=0 ; i<q ; i++){
        int c=sc.nextInt();
        int t=sc.nextInt();
        switch(c){
          case 0 : int x=sc.nextInt();
          qq[t] .enqueue(x);
          break ;
          case 1 : if(! qq[t] .isEmpty()){
            System.out.println(Integer.toString(qq[t] .getFront()));
          }
          break ;
          case 2 : qq[t] .dequeue();
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INIT : int := 8;
  static   operation grow( s : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var d : Sequence(int) ; d := Integer.subrange(1,s->size() * 2)->collect(0) ;
     for _x : Integer.subrange(1,s->size()) do d[0 + _x] := s[0 + _x] ; 
     return d );
  static class Queue {
   attribute data : Sequence(int);
   attribute r : int;
   static operation newQueue() : Queue
  pre: true
  post: true
  activity:
  ( var self : Queue ;
    self := createQueue();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     data := Integer.subrange(1,INIT)->collect(0) );
   operation isEmpty() : boolean
  pre: true
  post: true
  activity: (     return r = w );
   operation enqueue( x : int) : void
  pre: true
  post: true
  activity: (     if (w >= data->size()) then (     data := grow(data) ) else skip ; 
      data[w+1] := x  ; w := w + 1 );
   operation getFront() : int
  pre: true
  post: true
  activity: (     return data[r+1] );
   operation dequeue() : void
  pre: true
  post: true
  activity: (     if (not(isEmpty())) then (     r := r + 1 ) else skip );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var qq : Sequence(Sequence) ; qq := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     qq[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var c : int ; c := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
       if _switchval = 0 then
     var x : int ; x := sc.getCurrent()->toInteger() ;
    qq[t+1].enqueue(x) ; 
    break 
   else skip ;
       if _switchval = 1 then
     if (not(qq[t+1]->isEmpty())) then (     OclFile["System.out"].println(((qq[t+1].getFront()) + "")) ) else skip ; 
    break 
   else skip ;
       if _switchval = 2 then
     qq[t+1].dequeue() ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.lang.*;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] s=br.readLine().split(" ",0);
    int n=Integer.parseInt(s[0]);
    int q=Integer.parseInt(s[1]);
    Queue[] queues=new Queue[n];
    for(int i=0 ; i<n ; i++){
      queues[i]=new Queue();
    }
    String[] l ;
    String command ;
    int t,x ;
    for(int i=0 ; i<q ; i++){
      l=br.readLine().split(" ",0);
      command=l[0];
      t=Integer.parseInt(l[1]);
      switch(command){
        case "0" : x=Integer.parseInt(l[2]);
        queues[t] .enqueue(x);
        break ;
        case "1" : queues[t] .front();
        break ;
        case "2" : queues[t] .dequeue();
        break ;
      }
    }
  }
}
class Queue {
  ArrayList<Integer>a ;
  Queue(){
    a=new ArrayList<Integer>();
  }
  void enqueue(int x){
    a.add(x);
  }
  void front(){
    int size=a.size();
    if(size!=0){
      System.out.println(a.get(0));
    }
  }
  void dequeue(){
    int size=a.size();
    if(size!=0){
      a.remove(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
    var n : int ; n := (s[0+1])->toInteger() ;
    var q : int ; q := (s[1+1])->toInteger() ;
    var queues : Sequence(Sequence) ; queues := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     queues[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
    var l : Sequence(String) ;
    var command : String ;
    var t : int ;
    var x : int ;
        var i : int ; i := 0 ; while i < q do ( (     l := br.readLine()->split(" ") ; 
     command := l[0+1] ; 
     t := (l[1+1])->toInteger() ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (command) ; 
       if _switchval = "0" then
     x := (l[2+1])->toInteger() ; 
    queues[t+1].enqueue(x) ; 
    break 
   else skip ;
       if _switchval = "1" then
     queues[t+1].front() ; 
    break 
   else skip ;
       if _switchval = "2" then
     queues[t+1].dequeue() ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
 );
}
class Queue {
   attribute a : Sequence(int);
   static operation newQueue() : Queue
  pre: true
  post: true
  activity:
  ( var self : Queue ;
    self := createQueue();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     a := Sequence{} );
   operation enqueue( x : int) : void
  pre: true
  post: true
  activity: (     a := a->including(x) );
   operation front() : void
  pre: true
  post: true
  activity: (     var size : int ; size := a->size() ;
     if (size /= 0) then (     OclFile["System.out"].println(a->at(0+1)) ) else skip );
   operation dequeue() : void
  pre: true
  post: true
  activity: (     var size : int ; size := a->size() ;
     if (size /= 0) then (     a := a->excludingAt(0+1) ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    ArrayList<ArrayDeque<Integer>>que=new ArrayList<ArrayDeque<Integer>>();
    int n=in.nextInt(),loop=in.nextInt();
    for(int i=0 ; i<n ; i++){
      ArrayDeque<Integer>q=new ArrayDeque<>();
      que.add(q);
    }
    for(int i=0 ; i<loop ; i++){
      int odr=Integer.parseInt(in.next()),index=Integer.parseInt(in.next());
      switch(odr){
        case 0 : que.get(index).add(Integer.parseInt(in.next()));
        break ;
        case 1 : if(! que.get(index).isEmpty()){
          out.println(que.get(index).peek());
        }
        break ;
        case 2 : if(! que.get(index).isEmpty()){
          que.get(index).remove();
        }
        break ;
      }
    }
    out.flush();
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var que : Sequence(Sequence(int)) ; que := Sequence{} ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var loop : int ; loop := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var q : Sequence(int) ; q := ArrayDeque<OclAny>.newArrayDeque() ;
     que := que->including(q) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < loop do ( (     var odr : int ; odr := (in.getCurrent())->toInteger() ;
    var index : int ; index := (in.getCurrent())->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (odr) ; 
       if _switchval = 0 then
     que->at(index+1)->excludes((in.getCurrent())->toInteger()) ; 
    break 
   else skip ;
       if _switchval = 1 then
     if (not(que->at(index+1)->isEmpty())) then (     skip ) else skip ; 
    break 
   else skip ;
       if _switchval = 2 then
     if (not(que->at(index+1)->isEmpty())) then (     que := que->at(index+1).remove() ) else skip ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countPairs(int n){
    int count=0 ;
    for(int x=1 ; x<n ; x++){
      for(int y=x+1 ; y<=n ; y++){
        if((y+x)%(y ^ x)==0)count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int n=6 ;
    System.out.println(countPairs(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countPairs( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var x : int ; x := 1 ; while x < n do ( (         var y : int ; y := x + 1 ; while y <= n do ( (     if ((y + x) mod (MathLib.bitwiseXor(y,x)) = 0) then     count := count + 1 ; else skip )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(countPairs(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    ArrayList<ArrayDeque<Integer>>ar=new ArrayList<>();
    for(int i=0 ; i<n ; i++)ar.add(new ArrayDeque<>());
    int m=sc.nextInt();
    for(int i=0 ; i<m ; i++){
      int mode=sc.nextInt();
      if(mode==0){
        ar.get(sc.nextInt()).addLast(sc.nextInt());
      }
      else if(mode==1){
        int temp=sc.nextInt();
        if(ar.get(temp).peekFirst()!=null)System.out.println(ar.get(temp).getFirst());
      }
      else if(mode==2){
        int temp=sc.nextInt();
        if(ar.get(temp).peekFirst()!=null)ar.get(temp).removeFirst();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ar : Sequence(Sequence(int)) ; ar := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     ar := ar->including(ArrayDeque<OclAny>.newArrayDeque()) ;  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     var mode : int ; mode := sc.getCurrent()->toInteger() ;
     if (mode = 0) then (     ar := ar->at(sc.getCurrent()->toInteger()+1)->append(sc.getCurrent()->toInteger()) ) else     if (mode = 1) then (     var temp : int ; temp := sc.getCurrent()->toInteger() ;
     if (ar->at(temp+1).peekFirst() /= null) then     OclFile["System.out"].println(ar->at(temp+1)->first()) ; else skip ) else     if (mode = 2) then (     var temp : int ; temp := sc.getCurrent()->toInteger() ;
     if (ar->at(temp+1).peekFirst() /= null) then     ar := ar->at(temp+1)->tail() ; else skip ) else skip ; ;  )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedHashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Festive834B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int guest=in.nextInt();
    int guard=in.nextInt();
    String s=in.next();
    Set set=new LinkedHashSet();
    int[] arr=new int[26];
    String ans="NO" ;
    for(int i=0 ; i<guest ; i++){
      arr[s.charAt(i)-'A']=i ;
    }
    for(int i=0 ; i<guest ; i++){
      set.add(s.charAt(i));
      if(set.size()>guard){
        ans="YES" ;
        break ;
      }
      if(arr[s.charAt(i)-'A']==i)set.remove(s.charAt(i));
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Festive834B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var guest : int ; guest := in.getCurrent()->toInteger() ;
    var guard : int ; guard := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var set : Set ; set := Set{} ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,26)->collect(0) ;
    var ans : String ; ans := "NO" ;
        var i : int ; i := 0 ; while i < guest do ( (     arr[s->at(i+1) - ('A')->char2byte()+1] := i )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < guest do ( (     set := set->including(s->at(i+1)) ; 
     if (set->size() > guard) then (     ans := "YES" ; 
     break ) else skip ; 
     if (arr[s->at(i+1) - ('A')->char2byte()+1] = i) then     set := set->excludingFirst(s->at(i+1)) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int numberOfGuests=sc.nextInt();
    int numberOfGuards=sc.nextInt();
    char[] letters=sc.next().toCharArray();
    if(numberOfGuests==0){
      System.out.println("NO");
      return ;
    }
    boolean[] isDoorGuarded=new boolean[26];
    int usedGuards=0 ;
    boolean isAtLeastOneDoorUnguarded=false ;
    for(int i=0 ; i<letters.length ; i++){
      char currentDoorLetter=letters[i];
      if(! isDoorGuarded[currentDoorLetter-'A']){
        isDoorGuarded[currentDoorLetter-'A']=true ;
        usedGuards++;
      }
      if(usedGuards>numberOfGuards){
        isAtLeastOneDoorUnguarded=true ;
        break ;
      }
      boolean isCurrentGuestTheLast=true ;
      for(int j=i+1 ; j<letters.length ; j++){
        if(letters[j]==currentDoorLetter){
          isCurrentGuestTheLast=false ;
          break ;
        }
      }
      if(isCurrentGuestTheLast){
        usedGuards--;
        isDoorGuarded[currentDoorLetter-'A']=false ;
      }
    }
    if(isAtLeastOneDoorUnguarded){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numberOfGuests : int ; numberOfGuests := sc.getCurrent()->toInteger() ;
    var numberOfGuards : int ; numberOfGuards := sc.getCurrent()->toInteger() ;
    var letters : Sequence(String) ; letters := sc.getCurrent()->characters() ;
    if (numberOfGuests = 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    var isDoorGuarded : Sequence(boolean) ; isDoorGuarded := Integer.subrange(1,26)->collect(false) ;
    var usedGuards : int ; usedGuards := 0 ;
    var isAtLeastOneDoorUnguarded : boolean ; isAtLeastOneDoorUnguarded := false ;
        var i : int ; i := 0 ; while i < letters->size() do ( (     var currentDoorLetter : String ; currentDoorLetter := letters[i+1] ;
     if (not(isDoorGuarded[(currentDoorLetter)->char2byte() - ('A')->char2byte()+1])) then (     isDoorGuarded[(currentDoorLetter)->char2byte() - ('A')->char2byte()+1] := true ; 
     usedGuards := usedGuards + 1 ) else skip ; 
    if (usedGuards > numberOfGuards) then (     isAtLeastOneDoorUnguarded := true ; 
     break ) else skip ; 
    var isCurrentGuestTheLast : boolean ; isCurrentGuestTheLast := true ;
        var j : int ; j := i + 1 ; while j < letters->size() do ( (     if (letters[j+1] = currentDoorLetter) then (     isCurrentGuestTheLast := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (isCurrentGuestTheLast) then (     usedGuards := usedGuards - 1 ; 
     isDoorGuarded[(currentDoorLetter)->char2byte() - ('A')->char2byte()+1] := false ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (isAtLeastOneDoorUnguarded) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class WriteNow {
  public static HashSet<Integer>set=new HashSet<>();
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    if(k==26){
      System.out.println("NO");
      return ;
    }
    char[] str=scan.next().toCharArray();
    int[] arr=new int[26];
    HashSet<Character>set=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      arr[(str[i]-'A')]++;
    }
    for(int i=0 ; i<n ; i++){
      if(! set.contains(str[i])){
        k--;
        if(k<0){
          System.out.println("YES");
          return ;
        }
        set.add(str[i]);
      }
      if(--arr[str[i]-'A']==0){
        k++;
      }
    }
    System.out.println("NO");
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class WriteNow {
  static   attribute set : Set(int) := Set{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    if (k = 26) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    var str : Sequence(String) ; str := scan.getCurrent()->characters() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,26)->collect(0) ;
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr[(str[i+1] - ('A')->char2byte())+1] := arr[(str[i+1] - ('A')->char2byte())+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (not(set->includes(str[i+1]))) then (     k := k - 1 ; 
     if (k < 0) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
     set := set->including(str[i+1]) ) else skip ; 
     if ((arr[str[i+1] - ('A')->char2byte()+1] - 1) = 0) then (     k := k + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static void main(String[] args){
    int i,j,k,sp,space=4 ;
    char prt='$' ;
    for(i=1 ; i<=5 ; i++){
      for(sp=space ; sp>=1 ; sp--){
        System.out.print(" ");
      }
      for(j=1 ; j<=i ; j++){
        System.out.print(prt);
      }
      for(k=1 ; k<=(i-1); k++){
        if(i==1){
          continue ;
        }
        System.out.print(prt);
      }
      System.out.println();
      space--;
    }
    space=1 ;
    for(i=4 ; i>=1 ; i--){
      for(sp=space ; sp>=1 ; sp--){
        System.out.print(" ");
      }
      for(j=1 ; j<=i ; j++){
        System.out.print(prt);
      }
      for(k=1 ; k<=(i-1); k++){
        System.out.print(prt);
      }
      space++;
      System.out.println();
    }
    space=3 ;
    for(i=2 ; i<=5 ; i++){
      if((i % 2)!=0){
        for(sp=space ; sp>=1 ; sp--){
          System.out.print(" ");
        }
        for(j=1 ; j<=i ; j++){
          System.out.print(prt);
        }
      }
      if((i % 2)!=0){
        System.out.println();
        space--;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var k : int ;
    var sp : int ;
    var space : int ; space := 4 ;
     var prt : String ; prt := '$' ;
        i := 1 ; while i <= 5 do ( (         sp := space ; while sp >= 1 do ( (     OclFile["System.out"].print(" ") )  ;     sp := sp - 1 ) ; 
         j := 1 ; while j <= i do ( (     OclFile["System.out"].print(prt) )  ;     j := j + 1 ) ; 
        k := 1 ; while k <= (i - 1) do ( (     if (i = 1) then (     continue ) else skip ; 
     OclFile["System.out"].print(prt) )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println() ; 
    space := space - 1 ; 
 )  ;     i := i + 1 ) ; 
    space := 1 ; 
        i := 4 ; while i >= 1 do ( (         sp := space ; while sp >= 1 do ( (     OclFile["System.out"].print(" ") )  ;     sp := sp - 1 ) ; 
         j := 1 ; while j <= i do ( (     OclFile["System.out"].print(prt) )  ;     j := j + 1 ) ; 
        k := 1 ; while k <= (i - 1) do ( (     OclFile["System.out"].print(prt) )  ;     k := k + 1 ) ; 
    space := space + 1 ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i - 1 ) ; 
    space := 3 ; 
        i := 2 ; while i <= 5 do ( (     if ((i mod 2) /= 0) then (         sp := space ; while sp >= 1 do ( (     OclFile["System.out"].print(" ") )  ;     sp := sp - 1 ) ; 
         j := 1 ; while j <= i do ( (     OclFile["System.out"].print(prt) )  ;     j := j + 1 ) ) else skip ; 
     if ((i mod 2) /= 0) then (     OclFile["System.out"].println() ; 
     space := space - 1 ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int MOD=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr);
    for(int i=0 ; i<n ; i++){
      if(arr[i]!=(i+n % 2)/2*2+(n+1)% 2){
        System.out.println(0);
        return ;
      }
    }
    int ans=1 ;
    for(int i=0 ; i<n/2 ; i++){
      ans*=2 ;
      ans %=MOD ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] /= (i + n mod 2) / 2 * 2 + (n + 1) mod 2) then (     OclFile["System.out"].println(0) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < n / 2 do ( (     ans := ans*(2) ; 
     ans := ans mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static long[] count_color=new long[2];
  static void dfs(Vector<Integer>adj[],int node,int parent,boolean color){
    count_color[color==false ? 0 : 1]++;
    for(int i=0 ; i<adj[node] .size(); i++){
      if(adj[node] .get(i)!=parent)dfs(adj,adj[node] .get(i),node,! color);
    }
  }
  static int findMaxEdges(Vector<Integer>adj[],int n){
    dfs(adj,1,0,false);
    return(int)(count_color[0]*count_color[1]-(n-1));
  }
  public static void main(String[] args){
    int n=5 ;
    Vector<Integer>[] adj=new Vector[n+1];
    for(int i=0 ; i<n+1 ; i++)adj[i]=new Vector<Integer>();
    adj[1] .add(2);
    adj[1] .add(3);
    adj[2] .add(4);
    adj[3] .add(5);
    System.out.println(findMaxEdges(adj,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute count_color : Sequence(long) := Integer.subrange(1,2)->collect(0);
  static   operation dfs( adj : Sequence(Sequence(int)), node : int, parent : int, color : boolean) : void
  pre: true
  post: true
  activity: (     count_color[if color = false then 0 else 1 endif+1] := count_color[if color = false then 0 else 1 endif+1] + 1 ; 
         var i : int ; i := 0 ; while i < adj[node+1]->size() do ( (     if (adj[node+1]->at(i+1) /= parent) then     execute dfs(adj, adj[node+1]->at(i+1), node, not(color)) ; else skip )  ;     i := i + 1 ) );
  static   operation findMaxEdges( adj : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     execute dfs(adj, 1, 0, false) ; 
     return (count_color[0+1] * count_color[1+1] - (n - 1))->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var adj : Sequence(Sequence(int)) ; adj := Integer.subrange(1,n + 1)->collect(null) ;
        var i : int ; i := 0 ; while i < n + 1 do (     adj[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
    adj[1+1]->excludes(2) ; 
    adj[1+1]->excludes(3) ; 
    adj[2+1]->excludes(4) ; 
    adj[3+1]->excludes(5) ; 
    OclFile["System.out"].println(findMaxEdges(adj, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int digSum(int n){
    if(n==0)return 0 ;
    return(n % 9==0)? 9 :(n % 9);
  }
  static int powerDigitSum(int a,int n){
    int res=1 ;
    while(n>0){
      if(n % 2==1){
        res=res*digSum(a);
        res=digSum(res);
      }
      a=digSum(digSum(a)*digSum(a));
      n/=2 ;
    }
    return res ;
  }
  public static void main(String args[]){
    int a=9,n=4 ;
    System.out.print(powerDigitSum(a,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation digSum( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else skip ; 
     return if (n mod 9 = 0) then 9 else (n mod 9) endif );
  static   operation powerDigitSum( a : int, n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     while (n > 0) do (     if (n mod 2 = 1) then (     res := res * digSum(a) ; 
     res := digSum(res) ) else skip ; 
     a := digSum(digSum(a) * digSum(a)) ; 
     n := n/(2) ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 9 ;
    var n : int ; n := 4 ;
     OclFile["System.out"].print(powerDigitSum(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GFG {
  static int maxLength(int arr[],int N){
    int product=1,len=0 ;
    for(int i=0 ; i<N ; i++){
      product*=arr[i];
    }
    if(product>=0){
      return N ;
    }
    for(int i=0 ; i<N ; i++){
      if(arr[i]<0){
        len=Math.max(len,Math.max(N-i-1,i));
      }
    }
    return len ;
  }
  public static void main(String args[]){
    int arr[]={
-1,1,1,-2,3,2,-1 };
      int N=arr.length ;
      System.out.println(maxLength(arr,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxLength( arr : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var product : int ; product := 1 ;
    var len : int ; len := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     product := product*(arr[i+1]) )  ;     i := i + 1 ) ; 
    if (product >= 0) then (     return N ) else skip ; 
        var i : int ; i := 0 ; while i < N do ( (     if (arr[i+1] < 0) then (     len := Set{len, Set{N - i - 1, i}->max()}->max() ) else skip )  ;     i := i + 1 ) ; 
    return len 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-1,1,1,-2,3,2,-1} ;
     var N : int ; N := arr->size() ;
     OclFile["System.out"].println(maxLength(arr, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Vector<Long>getArray(int n){
    Vector<Long>ans=new Vector<Long>();
    long p2=1 ;
    while(n>0){
      if(n % 2==1)ans.add(p2);
      n>>=1 ;
      p2*=2 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int n=15 ;
    Vector<Long>ans=getArray(n);
    for(Long i : ans)System.out.print(i+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var ans : Sequence(long) ; ans := Sequence{} ;
     var p2 : long ; p2 := 1 ;
     while (n > 0) do (     if (n mod 2 = 1) then     ans := ans->including(p2) ; else skip ; 
     n := n/(2->pow(1)) ; 
     p2 := p2*(2) ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     var ans : Sequence(long) ; ans := getArray(n) ;
     for (i : ans) do (     OclFile["System.out"].print(i + " ") ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countPairs(int n){
    int count=0 ;
    for(int x=1 ; x<n ; x++){
      for(int y=x+1 ; y<=n ; y++){
        if((y*x)%(y+x)==0)count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int n=15 ;
    System.out.println(countPairs(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPairs( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var x : int ; x := 1 ; while x < n do ( (         var y : int ; y := x + 1 ; while y <= n do ( (     if ((y * x) mod (y + x) = 0) then     count := count + 1 ; else skip )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     OclFile["System.out"].println(countPairs(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static int findPossibleDerivables(int arr[],int n,int D,int A,int B){
    int gcdAB=gcd(A,B);
    int counter=0 ;
    for(int i=0 ; i<n ; i++){
      if((Math.abs(arr[i]-D)% gcdAB)==0){
        counter++;
      }
    }
    return counter ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,7,13 };
      int n=arr.length ;
      int D=5,A=4,B=2 ;
      System.out.println(findPossibleDerivables(arr,n,D,A,B));
      int a[]={
        1,2,3 };
        n=a.length ;
        D=6 ;
        A=3 ;
        B=2 ;
        System.out.println(findPossibleDerivables(a,n,D,A,B));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation findPossibleDerivables( arr : Sequence(int), n : int, D : int, A : int, B : int) : int
  pre: true
  post: true
  activity: (     var gcdAB : int ; gcdAB := gcd(A, B) ;
     var counter : int ; counter := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if ((if arr[i+1] - D < 0 then -(arr[i+1] - D) else arr[i+1] - D endif mod gcdAB) = 0) then (     counter := counter + 1 ) else skip )  ;     i := i + 1 ) ; 
     return counter );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,7,13} ;
     var n : int ; n := arr->size() ;
    var D : int ; D := 5 ;
    var A : int ; A := 4 ;
    var B : int ; B := 2 ;
    OclFile["System.out"].println(findPossibleDerivables(arr, n, D, A, B)) ; 
    var a : Sequence(int) ; a := Sequence{1,2,3} ;
    n := a->size() ; 
    D := 6 ; 
    A := 3 ; 
    B := 2 ; 
    OclFile["System.out"].println(findPossibleDerivables(a, n, D, A, B)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.io.*;
class GFG {
  static int closetAND(int arr[],int n,int k){
    int ans=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      int X=arr[i];
      for(int j=i ; j<n ; j++){
        X &=arr[j];
        ans=Math.min(ans,Math.abs(k-X));
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      4,7,10 };
      int n=arr.length ;
      int k=2 ;
      System.out.println(closetAND(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation closetAND( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 2147483647 ;
         var i : int ; i := 0 ; while i < n do ( (     var X : int ; X := arr[i+1] ;
         var j : int ; j := i ; while j < n do ( (     X := MathLib.bitwiseAnd(X, arr[j+1]) ; 
     ans := Set{ans, if k - X < 0 then -(k - X) else k - X endif}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,7,10} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(closetAND(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
public class Main {
  public static final int BIG_NUM=2000000000 ;
  public static final int MOD=1000000007 ;
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String input[]=br.readLine().split("\\s+");
      BigInteger A=new BigInteger(input[0]);
      BigInteger B=new BigInteger(input[1]);
      BigInteger ans ;
      ans=A.divide(B);
      System.out.println(ans);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BIG_NUM : int := 2000000000;
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var input : Sequence(String) ; input := br.readLine()->split("\\s+") ;
     var A : long ; A := long(input[0+1]) ;
    var B : long ; B := long(input[1+1]) ;
    var ans : long ;
    ans := A.divide(B) ; 
    OclFile["System.out"].println(ans) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    BigInteger a=scan.nextBigInteger();
    BigInteger b=scan.nextBigInteger();
    System.out.println(a.divide(b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := scan.nextBigInteger() ;
     var b : long ; b := scan.nextBigInteger() ;
     OclFile["System.out"].println(a.divide(b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(new BufferedInputStream(System.in));
    while(in.hasNext()){
      BigInteger a=in.nextBigInteger(),b=in.nextBigInteger();
      System.out.println(a.divide(b));
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (in.hasNext()) do (     var a : long ; a := in.nextBigInteger() ;
    var b : long ; b := in.nextBigInteger() ;
     OclFile["System.out"].println(a.divide(b)) ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    String s ;
    Scanner reader=new Scanner(System.in);
    s=reader.nextLine();
    String[] str ;
    str=s.split(" ");
    BigInteger a=new BigInteger(str[0]);
    BigInteger b=new BigInteger(str[1]);
    BigInteger c=a.divide(b);
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    s := reader.nextLine() ; 
    var str : Sequence(String) ;
    str := s->split(" ") ; 
    var a : long ; a := long(str[0+1]) ;
    var b : long ; b := long(str[1+1]) ;
    var c : long ; c := a.divide(b) ;
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
class Solver {
  private final int[] A ;
  private final int N ;
  Solver(Scanner in){
    N=in.nextInt();
    A=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=in.nextInt();
    }
  }
  void solve(){
    int[] count=new int[N];
    count[0]++;
    for(int a : A){
      count[a]++;
      if(count[a]>=3){
        System.out.println(0);
        return ;
      }
    }
    System.out.println(BigInteger.valueOf(2).modPow(BigInteger.valueOf(N/2),BigInteger.valueOf(1000000007)).intValue());
  }
}
class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    new Solver(in).solve();
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solver {
   attribute A : Sequence(int);
   attribute N : int;
   static operation newSolver( in : OclFile) : Solver
  pre: true
  post: true
  activity:
  ( var self : Solver ;
    self := createSolver();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     N := in.nextInt() ; 
     A := Integer.subrange(1,N)->collect(0) ; 
         var i : int ; i := 0 ; while i < N do ( (     A[i+1] := in.nextInt() )  ;     i := i + 1 ) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,N)->collect(0) ;
     count[0+1] := count[0+1] + 1 ; 
     for (a : A) do ( (     count[a+1] := count[a+1] + 1 ; 
     if (count[a+1] >= 3) then (     OclFile["System.out"].println(0) ; 
     return ) else skip )  ) ; 
     OclFile["System.out"].println((2 + "")->toLong().modPow((N / 2 + "")->toLong(), (1000000007 + "")->toLong())->oclAsType(int)) );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Solver.newSolver(in).solve() ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    BigInteger a,b ;
    Scanner cin=new Scanner(System.in);
    a=cin.nextBigInteger();
    b=cin.nextBigInteger();
    System.out.println(a.divide(b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ;
    var b : long ;
     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    a := cin.nextBigInteger() ; 
    b := cin.nextBigInteger() ; 
    OclFile["System.out"].println(a.divide(b)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
public class Main {
  public static final int BIG_NUM=2000000000 ;
  public static final int MOD=1000000007 ;
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String input[]=br.readLine().split("\\s+");
      BigInteger A=new BigInteger(input[0]);
      BigInteger B=new BigInteger(input[1]);
      BigInteger ans ;
      ans=A.multiply(B);
      System.out.println(ans);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BIG_NUM : int := 2000000000;
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var input : Sequence(String) ; input := br.readLine()->split("\\s+") ;
     var A : long ; A := long(input[0+1]) ;
    var B : long ; B := long(input[1+1]) ;
    var ans : long ;
    ans := A.multiply(B) ; 
    OclFile["System.out"].println(ans) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    BigInteger a,b ;
    Scanner cin=new Scanner(System.in);
    a=cin.nextBigInteger();
    b=cin.nextBigInteger();
    System.out.println(a.multiply(b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ;
    var b : long ;
     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    a := cin.nextBigInteger() ; 
    b := cin.nextBigInteger() ; 
    OclFile["System.out"].println(a.multiply(b)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int longestPalindrome(String s){
    int[] count=new int[128];
    for(char c : s.toCharArray())count[c]++;
    int ans=0 ;
    for(int v : count){
      ans+=v/2*2 ;
      if(ans % 2==0 && v % 2==1)ans++;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation longestPalindrome( s : String) : int
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,128)->collect(0) ;
     for (c : s->characters()) do (     count[c+1] := count[c+1] + 1 ;  ) ; 
    var ans : int ; ans := 0 ;
    for (v : count) do ( (     ans := ans+(v / 2 * 2) ; 
     if (ans mod 2 = 0 & v mod 2 = 1) then     ans := ans + 1 ; else skip )  ) ; 
    return ans 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(new BufferedInputStream(System.in));
    while(in.hasNext()){
      BigInteger a=in.nextBigInteger(),b=in.nextBigInteger();
      System.out.println(a.multiply(b));
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (in.hasNext()) do (     var a : long ; a := in.nextBigInteger() ;
    var b : long ; b := in.nextBigInteger() ;
     OclFile["System.out"].println(a.multiply(b)) ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    BigInteger a=new BigInteger(str);
    str=sc.next();
    BigInteger b=new BigInteger(str);
    System.out.println(a.multiply(b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var a : long ; a := long(str) ;
    str := sc.getCurrent() ; 
    var b : long ; b := long(str) ;
    OclFile["System.out"].println(a.multiply(b)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    String s ;
    Scanner reader=new Scanner(System.in);
    s=reader.nextLine();
    String[] str ;
    str=s.split(" ");
    BigInteger a=new BigInteger(str[0]);
    BigInteger b=new BigInteger(str[1]);
    BigInteger c=a.multiply(b);
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    s := reader.nextLine() ; 
    var str : Sequence(String) ;
    str := s->split(" ") ; 
    var a : long ; a := long(str[0+1]) ;
    var b : long ; b := long(str[1+1]) ;
    var c : long ; c := a.multiply(b) ;
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws java.io.IOException {
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    while(n!=0){
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=scan.nextInt();
      }
      int b[]={
        0,0,0,0,0,0,0 };
        for(int i=0 ; i<n ; i++){
          if(a[i]<10){
            b[0]++;
          }
          else if(a[i]<20){
            b[1]++;
          }
          else if(a[i]<30){
            b[2]++;
          }
          else if(a[i]<40){
            b[3]++;
          }
          else if(a[i]<50){
            b[4]++;
          }
          else if(a[i]<60){
            b[5]++;
          }
          else {
            b[6]++;
          }
        }
        for(int i=0 ; i<7 ; i++){
          System.out.println(b[i]);
        }
        n=scan.nextInt();
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
     while (n /= 0) do (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := Sequence{0,0,0,0,0,0,0} ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] < 10) then (     b[0+1] := b[0+1] + 1 ) else     if (a[i+1] < 20) then (     b[1+1] := b[1+1] + 1 ) else     if (a[i+1] < 30) then (     b[2+1] := b[2+1] + 1 ) else     if (a[i+1] < 40) then (     b[3+1] := b[3+1] + 1 ) else     if (a[i+1] < 50) then (     b[4+1] := b[4+1] + 1 ) else     if (a[i+1] < 60) then (     b[5+1] := b[5+1] + 1 ) else (     b[6+1] := b[6+1] + 1 ) ;  ;  ;  ;  ;  )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 7 do ( (     OclFile["System.out"].println(b[i+1]) )  ;     i := i + 1 ) ; 
    n := scan.getCurrent()->toInteger() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int[] a,count ;
    int i,j,n ;
    count=new int[7];
    for(; ; ){
      n=sc.nextInt();
      if(n==0)break ;
      a=new int[n];
      for(i=0 ; i<n ; i++)a[i]=sc.nextInt();
      for(i=0 ; i<7 ; i++)count[i]=0 ;
      for(i=0 ; i<n ; i++){
        for(j=10 ; j<70 ; j+=10)if(a[i]<j){
          count[j/10-1]++;
          break ;
        }
        if(j==70)count[j/10-1]++;
      }
      for(i=0 ; i<7 ; i++)out.println(count[i]);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var a : Sequence(int) ;
    var count : Sequence(int) ;
    var i : int ;
    var j : int ;
    var n : int ;
    count := Integer.subrange(1,7)->collect(0) ; 
      while true do ( (     n := sc.nextInt() ; 
     if (n = 0) then     break else skip ; 
    a := Integer.subrange(1,n)->collect(0) ; 
        i := 0 ; while i < n do (     a[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < 7 do (     count[i+1] := 0 ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (         j := 10 ; while j < 70 do (     if (a[i+1] < j) then (     count[j / 10 - 1+1] := count[j / 10 - 1+1] + 1 ; 
     break ) else skip ;  ;     j := j+(10) ) ; 
     if (j = 70) then     count[j / 10 - 1+1] := count[j / 10 - 1+1] + 1 ; else skip )  ;     i := i + 1 ) ; 
        i := 0 ; while i < 7 do (     out.println(count[i+1]) ;  ;     i := i + 1 ) ; 
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new A().doIt();
  }
  class A {
    void cnt(int num,int a[]){
      if(num<10)a[0]++;
      else if(num<20)a[1]++;
      else if(num<30)a[2]++;
      else if(num<40)a[3]++;
      else if(num<50)a[4]++;
      else if(num<60)a[5]++;
      else a[6]++;
    }
    void doIt(){
      while(true){
        int n=Integer.parseInt(sc.next());
        if(n==0)break ;
        int a[]=new int[7];
        for(int i=0 ; i<n ; i++){
          int num=Integer.parseInt(sc.next());
          cnt(num,a);
        }
        for(int i=0 ; i<7 ; i++)System.out.println(a[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     A.newA().doIt() );
 class A {
   operation cnt( num : int, a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (num < 10) then     a[0+1] := a[0+1] + 1 ; else     if (num < 20) then     a[1+1] := a[1+1] + 1 else     if (num < 30) then     a[2+1] := a[2+1] + 1 else     if (num < 40) then     a[3+1] := a[3+1] + 1 else     if (num < 50) then     a[4+1] := a[4+1] + 1 else     if (num < 60) then     a[5+1] := a[5+1] + 1 else     a[6+1] := a[6+1] + 1 ; ;  ;  ;  ;  ;  );
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := (sc.getCurrent())->toInteger() ;
     if (n = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,7)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := (sc.getCurrent())->toInteger() ;
     execute cnt(num, a) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 7 do (     OclFile["System.out"].println(a[i+1]) ;  ;     i := i + 1 ) ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static boolean isPossible(int n,int[] counter){
    if(n % 2==0){
      for(int i=1 ; i<n ; i+=2){
        if(counter[i]!=2){
          return false ;
        }
      }
      for(int i=0 ; i<n ; i+=2){
        if(counter[i]!=0){
          return false ;
        }
      }
      return true ;
    }
    else {
      if(counter[0]!=1){
        return false ;
      }
      for(int i=1 ; i<n ; i+=2){
        if(counter[i]!=0){
          return false ;
        }
      }
      for(int i=2 ; i<n ; i+=2){
        if(counter[i]!=2){
          return false ;
        }
      }
      return true ;
    }
  }
  private static long solve(int n,int[] counter){
    if(! isPossible(n,counter)){
      return 0 ;
    }
    long output=1 ;
    for(int i=0 ; i<n/2 ; i++){
      output*=2 ;
      output %=1000000007 ;
    }
    return output ;
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=Integer.parseInt(s.next());
    int[] counter=new int[n];
    for(int i=0 ; i<n ; i++){
      counter[Integer.parseInt(s.next())]++;
    }
    System.out.println(solve(n,counter));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation isPossible( n : int, counter : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     if (n mod 2 = 0) then (         var i : int ; i := 1 ; while i < n do ( (     if (counter[i+1] /= 2) then (     return false ) else skip )  ;     i := i+(2) ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (counter[i+1] /= 0) then (     return false ) else skip )  ;     i := i+(2) ) ; 
     return true ) else (     if (counter[0+1] /= 1) then (     return false ) else skip ; 
         var i : int ; i := 1 ; while i < n do ( (     if (counter[i+1] /= 0) then (     return false ) else skip )  ;     i := i+(2) ) ; 
         var i : int ; i := 2 ; while i < n do ( (     if (counter[i+1] /= 2) then (     return false ) else skip )  ;     i := i+(2) ) ; 
     return true ) );
  static   operation solve( n : int, counter : Sequence(int)) : long
  pre: true
  post: true
  activity: (     if (not(isPossible(n, counter))) then (     return 0 ) else skip ; 
     var output : long ; output := 1 ;
         var i : int ; i := 0 ; while i < n / 2 do ( (     output := output*(2) ; 
     output := output mod 1000000007 )  ;     i := i + 1 ) ; 
     return output );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (s.getCurrent())->toInteger() ;
    var counter : Sequence(int) ; counter := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     counter[(s.getCurrent())->toInteger()+1] := counter[(s.getCurrent())->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(n, counter)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] count=new int[7];
      while(n-->0){
        int x=sc.nextInt();
        if(x>=60)x=60 ;
        count[x/10]++;
      }
      for(int x : count)System.out.println(x);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var count : Sequence(int) ; count := Integer.subrange(1,7)->collect(0) ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x >= 60) then     x := 60 ; else skip ; 
     count[x / 10+1] := count[x / 10+1] + 1 ) ;  ) ;  
    for (x : count) do (     OclFile["System.out"].println(x) ;  ) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int TrialDivision(int N){
    int i=2 ;
    int k=(int)Math.ceil(Math.sqrt(N));
    while(i<=k){
      if(N % i==0)return 0 ;
      i+=1 ;
    }
    return 1 ;
  }
  public static void main(String[] args){
    int N=49 ;
    int p=TrialDivision(N);
    if(p!=0)System.out.print("Prime");
    else System.out.print("Composite");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation TrialDivision( N : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 2 ;
     var k : int ; k := ((N)->sqrt())->ceil()->oclAsType(int) ;
     while (i <= k) do (     if (N mod i = 0) then     return 0 else skip ; 
     i := i+(1) ) ; 
     return 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 49 ;
     var p : int ; p := TrialDivision(N) ;
     if (p /= 0) then     OclFile["System.out"].print("Prime") ; else     OclFile["System.out"].print("Composite") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long binomialCoeff(int n,int k){
    long res=1 ;
    if(k>n-k)k=n-k ;
    for(int i=0 ; i<k ; ++i){
      res*=(n-i);
      res/=(i+1);
    }
    return res ;
  }
  static long catalan(int n){
    long c=binomialCoeff(2*n,n);
    return c/(n+1);
  }
  static long findWays(int n){
    if((n & 1)!=0)return 0 ;
    return catalan(n/2);
  }
  public static void main(String[] args){
    int n=6 ;
    System.out.println("Total possible expressions of length "+n+" is "+findWays(6));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation binomialCoeff( n : int, k : int) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     if (k > n - k) then     k := n - k ; else skip ; 
         var i : int ; i := 0 ; while i < k do ( (     res := res*((n - i)) ; 
     res := res/((i + 1)) )  ;     i := i + 1 ) ; 
     return res );
  static   operation catalan( n : int) : long
  pre: true
  post: true
  activity: (     var c : long ; c := binomialCoeff(2 * n, n) ;
     return c / (n + 1) );
  static   operation findWays( n : int) : long
  pre: true
  post: true
  activity: (     if ((n & 1) /= 0) then     return 0 else skip ; 
     return catalan(n / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println("Total possible expressions of length " + n + " is " + findWays(6)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxSum(int arr[],int n,int k){
    if(n<k){
      System.out.println("Invalid");
      return-1 ;
    }
    int max_sum=0 ;
    for(int i=0 ; i<k ; i++)max_sum+=arr[i];
    int window_sum=max_sum ;
    for(int i=k ; i<n ; i++){
      window_sum+=arr[i]-arr[i-k];
      max_sum=Math.max(max_sum,window_sum);
    }
    return max_sum ;
  }
  public static void main(String[] args){
    int arr[]={
      1,4,2,10,2,3,1,0,20 };
      int k=4 ;
      int n=arr.length ;
      System.out.println(maxSum(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxSum( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     if (n < k) then (     OclFile["System.out"].println("Invalid") ; 
     return -1 ) else skip ; 
     var max_sum : int ; max_sum := 0 ;
        var i : int ; i := 0 ; while i < k do (     max_sum := max_sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    var window_sum : int ; window_sum := max_sum ;
        var i : int ; i := k ; while i < n do ( (     window_sum := window_sum+(arr[i+1] - arr[i - k+1]) ; 
     max_sum := Set{max_sum, window_sum}->max() )  ;     i := i + 1 ) ; 
    return max_sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,4,2,10,2,3,1,0,20} ;
     var k : int ; k := 4 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxSum(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Space {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    for(int i=1 ; i<=T ; i++){
      int L=sc.nextInt();
      long t=sc.nextLong();
      int N=sc.nextInt();
      int C=sc.nextInt();
      long time=t ;
      int[] a=new int[1000001];
      for(int j=0 ; j<C ; j++){
        a[j]=sc.nextInt();
      }
      for(int j=C ; j<N ; j++){
        a[j]=a[j-C];
      }
      int index=0 ;
      while(t>0 && index<N){
        if(a[index]>(t/2)){
          a[index]-=t/2 ;
          t=-1 ;
        }
        else {
          t-=a[index]*2 ;
          index++;
        }
      }
      if(t>0){
        time-=t ;
      }
      if(index<N){
        Arrays.sort(a,index,(int)N);
        for(int j=(int)(N-1); j>=index ; j--){
          if(L>0){
            time+=a[j];
            L--;
          }
          else {
            time+=a[j]*2 ;
          }
        }
      }
      System.out.println("Case #"+i+": "+time);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Space {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= T do ( (     var L : int ; L := sc.getCurrent()->toInteger() ;
     var t : long ; t := sc.getCurrent()->toLong() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var time : long ; time := t ;
    var a : Sequence(int) ; a := Integer.subrange(1,1000001)->collect(0) ;
        var j : int ; j := 0 ; while j < C do ( (     a[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
        var j : int ; j := C ; while j < N do ( (     a[j+1] := a[j - C+1] )  ;     j := j + 1 ) ; 
    var index : int ; index := 0 ;
    while (t > 0 & index < N) do (     if (a[index+1] > (t / 2)) then (     a[index+1] := a[index+1]-(t / 2) ; 
     t := -1 ) else (     t := t-(a[index+1] * 2) ; 
     index := index + 1 ) ) ; 
    if (t > 0) then (     time := time-(t) ) else skip ; 
    if (index < N) then (     a := a.subrange(1,index)^(a.subrange(index+1,N->oclAsType(int))->sort())^a.subrange(N->oclAsType(int)+1,a.size) ; 
         var j : int ; j := (N - 1)->oclAsType(int) ; while j >= index do ( (     if (L > 0) then (     time := time+(a[j+1]) ; 
     L := L - 1 ) else (     time := time+(a[j+1] * 2) ) )  ;     j := j - 1 ) ) else skip ; 
    OclFile["System.out"].println("Case #" + i + ": " + time) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class BL {
  private static final String FILE_NAME="B-large" ;
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new FileReader(FILE_NAME+".in"));
    Scanner scanner=new Scanner(in);
    BufferedWriter out=new BufferedWriter(new FileWriter(FILE_NAME+"L.out"));
    int t=scanner.nextInt();
    for(int c=1 ; c<=t ; ++c){
      int speedN=scanner.nextInt();
      long speedT=scanner.nextLong();
      int n=scanner.nextInt();
      int cc=scanner.nextInt();
      long totalTime=0 ;
      List<Long>savedTimes=new ArrayList<Long>();
      int[] d=new int[cc];
      for(int i=0 ; i<n ; ++i){
        int time ;
        if(i<cc){
          d[i]=2*scanner.nextInt();
          time=d[i];
        }
        else {
          time=d[i % cc];
        }
        if(totalTime>=speedT){
          savedTimes.add((long)time/2);
        }
        else if(totalTime+time>speedT){
          savedTimes.add(((totalTime+time)-speedT)/2);
        }
        totalTime+=time ;
      }
      Collections.sort(savedTimes);
      int len=savedTimes.size();
      for(int i=0 ; i<speedN && i<len ; ++i){
        totalTime-=savedTimes.get(len-i-1);
      }
      StringBuilder ans=new StringBuilder();
      ans.append("Case #");
      ans.append(c);
      ans.append(": ");
      ans.append(totalTime);
      out.write(ans.toString()+"\n");
      System.out.println(ans.toString());
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class BL {
  static    attribute FILE_NAME : String := "B-large";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(FILE_NAME + ".in")) ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(in) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(FILE_NAME + "L.out")) ;
    var t : int ; t := scanner.getCurrent()->toInteger() ;
        var c : int ; c := 1 ; while c <= t do ( (     var speedN : int ; speedN := scanner.getCurrent()->toInteger() ;
     var speedT : long ; speedT := scanner.getCurrent()->toLong() ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var cc : int ; cc := scanner.getCurrent()->toInteger() ;
    var totalTime : long ; totalTime := 0 ;
    var savedTimes : Sequence(long) ; savedTimes := Sequence{} ;
    var d : Sequence(int) ; d := Integer.subrange(1,cc)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var time : int ;
     if (i < cc) then (     d[i+1] := 2 * scanner.getCurrent()->toInteger() ; 
     time := d[i+1] ) else (     time := d[i mod cc+1] ) ;  
     if (totalTime >= speedT) then (     savedTimes := savedTimes->including(time->oclAsType(long) / 2) ) else     if (totalTime + time > speedT) then (     savedTimes := savedTimes->including(((totalTime + time) - speedT) / 2) ) else skip ; ;  
     totalTime := totalTime+(time) )  ;     i := i + 1 ) ; 
    savedTimes := savedTimes->sort() ; 
    var len : int ; len := savedTimes->size() ;
        var i : int ; i := 0 ; while i < speedN & i < len do ( (     totalTime := totalTime-(savedTimes->at(len - i - 1+1)) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := StringLib.newString() ;
    ans := ans + StringLib.newString("Case #") ; 
    ans := ans + StringLib.newString(c) ; 
    ans := ans + StringLib.newString(": ") ; 
    ans := ans + StringLib.newString(totalTime) ; 
    skip ; 
    OclFile["System.out"].println(ans+"") ; 
 )  ;     c := c + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public void doMain()throws Exception {
    Scanner sc=new Scanner(new FileReader("input.txt"));
    PrintWriter pw=new PrintWriter(new FileWriter("output.txt"));
    int T=sc.nextInt();
    for(int caseNum=1 ; caseNum<=T ; caseNum++){
      System.out.println("case "+caseNum);
      int L=sc.nextInt();
      long t=sc.nextLong();
      int N=sc.nextInt();
      int C=sc.nextInt();
      long[] a=new long[N];
      for(int i=0 ; i<C ; i++)a[i]=sc.nextLong();
      for(int i=C ; i<N ; i++)a[i]=a[i-C];
      long res=0 ;
      for(int i=0 ; i<N ; i++)res+=4*a[i];
      int pos=0 ;
      while(pos<N && 2*a[pos]<=t){
        t-=2*a[pos];
        pos++;
      }
      if(pos<N){
        List<Long>ll=new ArrayList<Long>();
        ll.add(2*a[pos]-t);
        for(int i=pos+1 ; i<N ; i++)ll.add(2*a[i]);
        Collections.sort(ll);
        for(int i=ll.size()-1 ; i>=0 && i>=ll.size()-L ; i--){
          res-=ll.get(i);
        }
      }
      if(res % 2==1){
        System.out.println("failure");
        System.exit(0);
      }
      else pw.println("Case #"+caseNum+": "+res/2);
    }
    sc.close();
    pw.flush();
    pw.close();
  }
  public static void main(String[] args)throws Exception {
(new Solution()).doMain();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
   operation doMain() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt"))) ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
        var caseNum : int ; caseNum := 1 ; while caseNum <= T do ( (     OclFile["System.out"].println("case " + caseNum) ; 
     var L : int ; L := sc.getCurrent()->toInteger() ;
    var t : long ; t := sc.getCurrent()->toLong() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < C do (     a[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
        var i : int ; i := C ; while i < N do (     a[i+1] := a[i - C+1] ;  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < N do (     res := res+(4 * a[i+1]) ;  ;     i := i + 1 ) ; 
    var pos : int ; pos := 0 ;
    while (pos < N & 2 * a[pos+1] <= t) do (     t := t-(2 * a[pos+1]) ; 
     pos := pos + 1 ) ; 
    if (pos < N) then (     var ll : Sequence(long) ; ll := Sequence{} ;
     ll := ll->including(2 * a[pos+1] - t) ; 
        var i : int ; i := pos + 1 ; while i < N do (     ll := ll->including(2 * a[i+1]) ;  ;     i := i + 1 ) ; 
    ll := ll->sort() ; 
        var i : int ; i := ll->size() - 1 ; while i >= 0 & i >= ll->size() - L do ( (     res := res-(ll->at(i+1)) )  ;     i := i - 1 ) ; 
 ) else skip ; 
    if (res mod 2 = 1) then (     OclFile["System.out"].println("failure") ; 
 OclProcess.exit(0) ) else     skip ; ;  
 )  ;     caseNum := caseNum + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Solution.newSolution()).doMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package CodeJam ;
import java.util.*;
import java.io.*;
public class B {
  private static String inFilename="B-large.in" ;
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(new FileReader("src/CodeJam/"+inFilename));
    PrintWriter out=new PrintWriter(new FileWriter("src/CodeJam/output.txt"));
    int T=in.nextInt();
    for(int tt=0 ; tt<T ; tt++){
      long result=0 ;
      int L=in.nextInt();
      long t=in.nextLong();
      int N=in.nextInt();
      int C=in.nextInt();
      int[] a=new int[C];
      for(int i=0 ; i<C ; i++){
        a[i]=in.nextInt();
      }
      int[] d=new int[N];
      for(int i=0 ; i<N ; i++){
        d[i]=a[i % C];
      }
      for(int i=0 ; i<N ; i++){
        if(result+d[i]*2<=t){
          result+=d[i]*2 ;
        }
        else {
          int left0=(int)(d[i]-(t-result)/2);
          result=t ;
          int[] left=new int[N-i];
          left[0]=left0 ;
          for(int j=1 ; j<N-i ; j++){
            left[j]=d[i+j];
          }
          Arrays.sort(left);
          int j=left.length-1 ;
          for(int l=0 ; l<L && j>=0 ; l++){
            result+=left[j--];
          }
          for(int k=j ; k>=0 ; k--){
            result+=left[k]*2 ;
          }
          break ;
        }
      }
      out.print("Case #"+(tt+1)+": "+result+"\n");
    }
    in.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute inFilename : String := "B-large.in";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read("src/CodeJam/" + inFilename)) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("src/CodeJam/output.txt"))) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var tt : int ; tt := 0 ; while tt < T do ( (     var result : long ; result := 0 ;
     var L : int ; L := in.getCurrent()->toInteger() ;
    var t : long ; t := in.getCurrent()->toLong() ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var C : int ; C := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,C)->collect(0) ;
        var i : int ; i := 0 ; while i < C do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var d : Sequence(int) ; d := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     d[i+1] := a[i mod C+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (result + d[i+1] * 2 <= t) then (     result := result+(d[i+1] * 2) ) else (     var left0 : int ; left0 := (d[i+1] - (t - result) / 2)->oclAsType(int) ;
     result := t ; 
    var left : Sequence(int) ; left := Integer.subrange(1,N - i)->collect(0) ;
    left[0+1] := left0 ; 
        var j : int ; j := 1 ; while j < N - i do ( (     left[j+1] := d[i + j+1] )  ;     j := j + 1 ) ; 
    left := left->sort() ; 
    var j : int ; j := left->size() - 1 ;
        var l : int ; l := 0 ; while l < L & j >= 0 do ( (      result := result + left[j+1]  ; j := j - 1 )  ;     l := l + 1 ) ; 
        var k : int ; k := j ; while k >= 0 do ( (     result := result+(left[k+1] * 2) )  ;     k := k - 1 ) ; 
    break 
 ) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     tt := tt + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void maxProduct(int arr[],int n){
    if(n<2){
      System.out.println("No pairs exists");
      return ;
    }
    if(n==2){
      System.out.println(arr[0]+" "+arr[1]);
      return ;
    }
    int posa=Integer.MIN_VALUE,posb=Integer.MIN_VALUE ;
    int nega=Integer.MIN_VALUE,negb=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]>posa){
        posb=posa ;
        posa=arr[i];
      }
      else if(arr[i]>posb)posb=arr[i];
      if(arr[i]<0 && Math.abs(arr[i])>Math.abs(nega)){
        negb=nega ;
        nega=arr[i];
      }
      else if(arr[i]<0 && Math.abs(arr[i])>Math.abs(negb))negb=arr[i];
    }
    if(nega*negb>posa*posb)System.out.println("Max product pair is {"+nega+","+negb+"}");
    else System.out.println("Max product pair is {"+posa+","+posb+"}");
  }
  public static void main(String[] args){
    int arr[]={
      1,4,3,6,7,0 };
      int n=arr.length ;
      maxProduct(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxProduct( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     if (n < 2) then (     OclFile["System.out"].println("No pairs exists") ; 
     return ) else skip ; 
     if (n = 2) then (     OclFile["System.out"].println(arr[0+1] + " " + arr[1+1]) ; 
     return ) else skip ; 
    var posa : int ; posa := -2147483648 ;
    var posb : int ; posb := -2147483648 ;
    var nega : int ; nega := -2147483648 ;
    var negb : int ; negb := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] > posa) then (     posb := posa ; 
     posa := arr[i+1] ) else     if (arr[i+1] > posb) then     posb := arr[i+1] ; else skip ; ;  
     if (arr[i+1] < 0 & if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif > if nega < 0 then -(nega) else nega endif) then (     negb := nega ; 
     nega := arr[i+1] ) else     if (arr[i+1] < 0 & if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif > if negb < 0 then -(negb) else negb endif) then     negb := arr[i+1] ; else skip ; )  ;     i := i + 1 ) ; 
    if (nega * negb > posa * posb) then     OclFile["System.out"].println("Max product pair is {" + nega + "," + negb + "}") else     OclFile["System.out"].println("Max product pair is {" + posa + "," + posb + "}") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,4,3,6,7,0} ;
     var n : int ; n := arr->size() ;
     execute maxProduct(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int calculateLeaps(int n){
    if(n==0 || n==1){
      return 1 ;
    }
    else {
      int leaps=0 ;
      for(int i=0 ; i<n ; i++)leaps+=calculateLeaps(i);
      return leaps ;
    }
  }
  public static void main(String[] args){
    System.out.println(calculateLeaps(4));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation calculateLeaps( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0 or n = 1) then (     return 1 ) else (     var leaps : int ; leaps := 0 ;
         var i : int ; i := 0 ; while i < n do (     leaps := leaps+(calculateLeaps(i)) ;  ;     i := i + 1 ) ; 
     return leaps ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(calculateLeaps(4)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int N=gi();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=gi();
    }
    Arrays.parallelSort(A);
    if(N % 2==0){
      for(int i=0 ; i<N ; i++){
        if(A[i]!=Math.floorDiv(i+2,2)*2-1){
          System.out.println(0);
          return ;
        }
      }
    }
    else {
      for(int i=0 ; i<N ; i++){
        if(A[i]!=Math.floorDiv(i+1,2)*2){
          System.out.println(0);
          return ;
        }
      }
    }
    long a=1 ;
    long nn=Math.floorDiv(N,2);
    while(nn>0){
      a*=2 ;
      a=a % 1000000007 ;
      nn--;
    }
    System.out.println(a);
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : int ; N := gi() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := gi() )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    if (N mod 2 = 0) then (         var i : int ; i := 0 ; while i < N do ( (     if (A[i+1] /= floorDiv(i + 2, 2) * 2 - 1) then (     OclFile["System.out"].println(0) ; 
     return ) else skip )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < N do ( (     if (A[i+1] /= floorDiv(i + 1, 2) * 2) then (     OclFile["System.out"].println(0) ; 
     return ) else skip )  ;     i := i + 1 ) ) ;  
    var a : long ; a := 1 ;
    var nn : long ; nn := floorDiv(N, 2) ;
    while (nn > 0) do (     a := a*(2) ; 
     a := a mod 1000000007 ; 
     nn := nn - 1 ) ; 
    OclFile["System.out"].println(a) ; 
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class ex8 {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    sc.nextLine();
    int count=0 ;
    int flag=0 ;
    String s[]=new String[n];
    for(int i=0 ; i<n ; i++){
      s[i]=" "+sc.nextLine();
    }
    for(int i=0 ; i<n ; i++){
      String res="" ;
      count=0 ;
      for(int q=1 ; q<=12 ; q++){
        if(s[i] .charAt(q)=='X'){
          res=" 1x12" ;
          count++;
          break ;
        }
      }
      for(int j=2 ; j<=6 ; j++){
        flag=0 ;
        if(12 % j==0){
          for(int k=1 ; k<=12/j ; k++){
            flag=0 ;
            for(int p=k ; p<=12 ; p+=12/j){
              if(s[i] .charAt(p)=='O'){
                flag=1 ;
                break ;
              }
            }
            if(flag==0){
              count++;
              res+=" "+j+"x"+12/j ;
              break ;
            }
          }
        }
      }
      flag=0 ;
      for(int l=1 ; l<=12 ; l++){
        if(s[i] .charAt(l)=='O'){
          flag=1 ;
          break ;
        }
      }
      if(flag==0){
        res+=" 12x1" ;
        count++;
      }
      System.out.printf("%d%s",count,res);
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ex8 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
    var count : int ; count := 0 ;
    var flag : int ; flag := 0 ;
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := " " + sc.nextLine() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var res : String ; res := "" ;
     count := 0 ; 
        var q : int ; q := 1 ; while q <= 12 do ( (     if (s[i+1]->at(q+1) = 'X') then (     res := " 1x12" ; 
     count := count + 1 ; 
     break ) else skip )  ;     q := q + 1 ) ; 
        var j : int ; j := 2 ; while j <= 6 do ( (     flag := 0 ; 
     if (12 mod j = 0) then (         var k : int ; k := 1 ; while k <= 12 / j do ( (     flag := 0 ; 
         var p : int ; p := k ; while p <= 12 do ( (     if (s[i+1]->at(p+1) = 'O') then (     flag := 1 ; 
     break ) else skip )  ;     p := p+(12 / j) ) ; 
     if (flag = 0) then (     count := count + 1 ; 
     res := res+(" " + j + "x" + 12 / j) ; 
     break ) else skip )  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) ; 
    flag := 0 ; 
        var l : int ; l := 1 ; while l <= 12 do ( (     if (s[i+1]->at(l+1) = 'O') then (     flag := 1 ; 
     break ) else skip )  ;     l := l + 1 ) ; 
    if (flag = 0) then (     res := res+(" 12x1") ; 
     count := count + 1 ) else skip ; 
    OclFile["System.out"].printf("%d%s", count, res) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Geeks {
  static void ReplaceElements(int arr[],int n){
    int max_ele=arr[0];
    arr[0]=-1 ;
    for(int i=1 ; i<n ; ++i){
      if(max_ele>arr[i])arr[i]=max_ele ;
      else if(max_ele<=arr[i]){
        int temp=arr[i];
        arr[i]=max_ele ;
        max_ele=temp ;
      }
    }
  }
  public static void main(String args[]){
    int arr[]={
      4,5,2,1,7,6 };
      int n=arr.length ;
      ReplaceElements(arr,n);
      for(int i=0 ; i<n ; ++i)System.out.println(arr[i]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Geeks {
  static   operation ReplaceElements( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var max_ele : int ; max_ele := arr[0+1] ;
     arr[0+1] := -1 ; 
         var i : int ; i := 1 ; while i < n do ( (     if (max_ele > arr[i+1]) then     arr[i+1] := max_ele ; else     if (max_ele <= arr[i+1]) then (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := max_ele ; 
     max_ele := temp ) else skip ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,5,2,1,7,6} ;
     var n : int ; n := arr->size() ;
     execute ReplaceElements(arr, n) ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].println(arr[i+1]) ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printString(char[] str,int n){
    int ones=0 ;
    for(int i=0 ; i<n ; i++)if(str[i]=='1')ones++;
    boolean used=false ;
    for(int i=0 ; i<n ; i++){
      if(str[i]=='2' && ! used){
        used=true ;
        for(int j=0 ; j<ones ; j++)System.out.print("1");
      }
      if(str[i]!='1')System.out.print(str[i]);
    }
    if(! used)for(int j=0 ;
    j<ones ;
    j++)System.out.print("1");
  }
  public static void main(String[] args){
    String str="100210" ;
    int n=str.length();
    printString(str.toCharArray(),n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printString( str : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (     var ones : int ; ones := 0 ;
         var i : int ; i := 0 ; while i < n do (     if (str[i+1] = '1') then     ones := ones + 1 ; else skip ;  ;     i := i + 1 ) ; 
    var used : boolean ; used := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (str[i+1] = '2' & not(used)) then (     used := true ; 
         var j : int ; j := 0 ; while j < ones do (     OclFile["System.out"].print("1") ;  ;     j := j + 1 ) ) else skip ; 
     if (str[i+1] /= '1') then     OclFile["System.out"].print(str[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    if (not(used)) then         var j : int ; j := 0 ; while j < ones do (     OclFile["System.out"].print("1") ;  ;     j := j + 1 ) ; else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "100210" ;
     var n : int ; n := str->size() ;
     execute printString(str->characters(), n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findSmallNum(int N,int K){
    int rem=N % K ;
    if(rem==0)return N ;
    else return N-rem ;
  }
  static int findLargeNum(int N,int K){
    int rem=(N+K)% K ;
    if(rem==0)return N ;
    else return N+K-rem ;
  }
  static int sumDivisibles(int A,int B,int M){
    int first=findSmallNum(A,M);
    int last=findLargeNum(B,M);
    if(first<A)first+=M ;
    if(last>B)first-=M ;
    int n=(B/M)-(A-1)/M ;
    return n*(first+last)/2 ;
  }
  public static void main(String[] args){
    int A=6,B=15,M=3 ;
    System.out.print(sumDivisibles(A,B,M));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findSmallNum( N : int, K : int) : int
  pre: true
  post: true
  activity: (     var rem : int ; rem := N mod K ;
     if (rem = 0) then     return N else     return N - rem );
  static   operation findLargeNum( N : int, K : int) : int
  pre: true
  post: true
  activity: (     var rem : int ; rem := (N + K) mod K ;
     if (rem = 0) then     return N else     return N + K - rem );
  static   operation sumDivisibles( A : int, B : int, M : int) : int
  pre: true
  post: true
  activity: (     var first : int ; first := findSmallNum(A, M) ;
     var last : int ; last := findLargeNum(B, M) ;
    if (first < A) then     first := first+(M) ; else skip ; 
    if (last > B) then     first := first-(M) ; else skip ; 
    var n : int ; n := (B / M) - (A - 1) / M ;
    return n * (first + last) / 2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 6 ;
    var B : int ; B := 15 ;
    var M : int ; M := 3 ;
     OclFile["System.out"].print(sumDivisibles(A, B, M)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GFG {
  public static int getSum(int arr[],int n){
    int i,sum=0 ;
    Set<Integer>hashSet=new HashSet<>();
    for(i=0 ; i<n ; i++)hashSet.add(arr[i]);
    for(i=0 ; i<n ; i++){
      double sqrtCurrent=Math.sqrt(arr[i]);
      if(Math.floor(sqrtCurrent)!=Math.ceil(sqrtCurrent))continue ;
      if(hashSet.contains((int)sqrtCurrent)){
        sum+=(sqrtCurrent*sqrtCurrent);
      }
    }
    return sum ;
  }
  public static void main(String args[]){
    int arr[]={
      2,4,5,6,7,8,9,3 };
      int n=arr.length ;
      System.out.println(getSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var sum : int ; sum := 0 ;
     var hashSet : Set(int) ; hashSet := Set{} ;
        i := 0 ; while i < n do (     hashSet := hashSet->including(arr[i+1]) ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     var sqrtCurrent : double ; sqrtCurrent := (arr[i+1])->sqrt() ;
     if ((sqrtCurrent)->floor() /= (sqrtCurrent)->ceil()) then     continue else skip ; 
     if (hashSet->includes(sqrtCurrent->oclAsType(int))) then (     sum := sum+((sqrtCurrent * sqrtCurrent)) ) else skip )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,5,6,7,8,9,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(getSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    int h=Integer.parseInt(sa[0]);
    int n=Integer.parseInt(sa[2]);
    TreeMap<Integer,TreeSet<Integer>>map=new TreeMap<>();
    for(int i=0 ; i<n ; i++){
      sa=br.readLine().split(" ");
      int x=Integer.parseInt(sa[0]);
      int y=Integer.parseInt(sa[1]);
      TreeSet<Integer>set=map.get(x);
      if(set==null){
        set=new TreeSet<>();
        map.put(x,set);
      }
      set.add(y);
    }
    br.close();
    int x=1 ;
    int y=1 ;
    for(int k : map.keySet()){
      TreeSet<Integer>set=map.get(k);
      y+=k-x-1 ;
      if(set.floor(y)!=null){
        System.out.println(k-1);
        return ;
      }
      if(! set.contains(y+1)){
        y++;
      }
      x=k ;
    }
    System.out.println(h);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var h : int ; h := (sa[0+1])->toInteger() ;
    var n : int ; n := (sa[2+1])->toInteger() ;
    var map : Map(int,Set(int)) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     sa := br.readLine()->split(" ") ; 
     var x : int ; x := (sa[0+1])->toInteger() ;
    var y : int ; y := (sa[1+1])->toInteger() ;
    var set : Set(int) ; set := map->at(x) ;
    if (set = null) then (     set := Set{} ; 
     map := map->union(Map{x |-> set}) ) else skip ; 
    set := set->including(y) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    var x : int ; x := 1 ;
    var y : int ; y := 1 ;
    for (k : map->keys()) do ( (     var set : Set(int) ; set := map->at(k) ;
     y := y+(k - x - 1) ; 
    if (set.floor(y) /= null) then (     OclFile["System.out"].println(k - 1) ; 
     return ) else skip ; 
    if (not(set->includes(y + 1))) then (     y := y + 1 ) else skip ; 
    x := k ; 
 )  ) ; 
    OclFile["System.out"].println(h) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int H=200000+11 ;
  static int W=200000+11 ;
  static List<TreeSet<Integer>>heights=new ArrayList<>(H);
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int n=sc.nextInt();
    for(int i=0 ; i<w ; i++){
      if(i>=heights.size()){
        heights.add(new TreeSet<Integer>());
      }
      else {
        heights.get(i).clear();
      }
      heights.get(i).add(h);
    }
    for(int i=0 ; i<n ; i++){
      int h_i=sc.nextInt();
      int w_i=sc.nextInt();
      h_i-=1 ;
      w_i-=1 ;
      heights.get(w_i).add(h_i);
    }
    int current_h=0,current_w=0 ;
    int ans=h ;
    while(current_h<h && current_w<w){
      int hh=heights.get(current_w).higher(current_h);
      ans=Math.min(ans,hh);
      current_h+=1 ;
      if(heights.get(current_w).contains(current_h)){
        break ;
      }
      if(current_w+1>=w){
        break ;
      }
      if(! heights.get(current_w+1).contains(current_h)){
        current_w+=1 ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute H : int := 200000 + 11;
  static   attribute W : int := 200000 + 11;
  static   attribute heights : Sequence(Set(int)) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < w do ( (     if (i >= heights->size()) then (     heights := heights->including(Set{}) ) else (     heights := heights->at(i+1)->intersection(Set{}) ) ;  
     heights->at(i+1)->excludes(h) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var h_i : int ; h_i := sc.getCurrent()->toInteger() ;
     var w_i : int ; w_i := sc.getCurrent()->toInteger() ;
    h_i := h_i-(1) ; 
    w_i := w_i-(1) ; 
    heights->at(w_i+1)->excludes(h_i) ; 
 )  ;     i := i + 1 ) ; 
    var current_h : int ; current_h := 0 ;
    var current_w : int ; current_w := 0 ;
    var ans : int ; ans := h ;
    while (current_h < h & current_w < w) do (     var hh : int ; hh := heights->at(current_w+1).higher(current_h) ;
     ans := Set{ans, hh}->min() ; 
    current_h := current_h+(1) ; 
    if (heights->at(current_w+1)->includes(current_h)) then (     break ) else skip ; 
    if (current_w + 1 >= w) then (     break ) else skip ; 
    if (not(heights->at(current_w + 1+1)->includes(current_h))) then (     current_w := current_w+(1) ) else skip ; 
 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int n=sc.nextInt();
    HashMap<Integer,TreeSet<Integer>>map=new HashMap<>();
    for(int i=1 ; i<=h ; i++){
      map.put(i,new TreeSet<>());
    }
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      map.get(x).add(y);
    }
    int yMax=1 ;
    for(int i=2 ; i<=h ; i++){
      if(map.get(i).isEmpty()){
        yMax++;
      }
      else if(map.get(i).first()<=yMax){
        System.out.println(i-1);
        return ;
      }
      else if(map.get(i).first()>yMax+1){
        yMax++;
      }
    }
    System.out.println(h);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var map : Map(int,Set(int)) ; map := Map{} ;
        var i : int ; i := 1 ; while i <= h do ( (     map := map->union(Map{i |-> Set{}}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     map->at(x)->excludes(y) )  ;     i := i + 1 ) ; 
    var yMax : int ; yMax := 1 ;
        var i : int ; i := 2 ; while i <= h do ( (     if (map->at(i)->isEmpty()) then (     yMax := yMax + 1 ) else     if (map->at(i)->first() <= yMax) then (     OclFile["System.out"].println(i - 1) ; 
     return ) else     if (map->at(i)->first() > yMax + 1) then (     yMax := yMax + 1 ) else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(h) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int A[]=new int[N];
    for(int i=0 ; i<N ; i++){
      int temp=sc.nextInt();
      A[temp]++;
    }
    for(int i=0 ; i<N ; i++){
      if(N % 2==0){
        if(i % 2==1 && A[i]!=2){
          System.out.println(0);
          return ;
        }
        if(i % 2==0 && A[i]!=0){
          System.out.println(0);
          return ;
        }
      }
      else {
        if(i==0 && A[i]!=1){
          System.out.println(0);
          return ;
        }
        if(i % 2==1 && A[i]!=0){
          System.out.println(0);
          return ;
        }
        if(i>0 && i % 2==0 && A[i]!=2){
          System.out.println(0);
          return ;
        }
      }
    }
    long count=1 ;
    for(int i=0 ; i<N/2 ; i++){
      count=(count*2)% 1000000007 ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     var temp : int ; temp := sc.getCurrent()->toInteger() ;
     A[temp+1] := A[temp+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (N mod 2 = 0) then (     if (i mod 2 = 1 & A[i+1] /= 2) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
     if (i mod 2 = 0 & A[i+1] /= 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ) else (     if (i = 0 & A[i+1] /= 1) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
     if (i mod 2 = 1 & A[i+1] /= 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
     if (i > 0 & i mod 2 = 0 & A[i+1] /= 2) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ) )  ;     i := i + 1 ) ; 
    var count : long ; count := 1 ;
        var i : int ; i := 0 ; while i < N / 2 do ( (     count := (count * 2) mod 1000000007 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static PrintWriter out=new PrintWriter(System.out);
  static Scanner in=new Scanner(System.in);
  static BufferedReader re=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter wr=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws IOException {
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int T=in.nextInt();
    while(T>0){
      int n=in.nextInt();
      int arr[][]=new int[n][2];
      for(int i=0 ; i<n ; i++){
        arr[i][0]=in.nextInt();
        arr[i][1]=i+1 ;
      }
      Arrays.sort(arr,(o1,o2)->o1[0]-o2[0]);
      if(n>=2)System.out.println(arr[0][1]+" "+arr[n-1][1]);
      else System.out.println(1+" "+1);
      T--;
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute re : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute wr : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
     while (T > 0) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1][0+1] := in.getCurrent()->toInteger() ; 
     arr[i+1][1+1] := i + 1 )  ;     i := i + 1 ) ; 
    arr := OclComparator.sortWith(arr, lambda (o1 , o2) : OclAny in o1[0+1] - o2[0+1]) ; 
    if (n >= 2) then     OclFile["System.out"].println(arr[0+1][1+1] + " " + arr[n - 1+1][1+1]) else     OclFile["System.out"].println(1 + " " + 1) ; ;  
    T := T - 1 ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    String a,b ;
    long n ;
    try(Scanner sc=new Scanner(System.in)){
      a=sc.next();
      b=sc.next();
      n=Long.parseLong(a)& Long.parseLong(b);
      System.out.println(String.format("%32s",Long.toBinaryString(n)).replace(' ','0'));
      n=Long.parseLong(a)| Long.parseLong(b);
      System.out.println(String.format("%32s",Long.toBinaryString(n)).replace(' ','0'));
      n=Long.parseLong(a)^ Long.parseLong(b);
      System.out.println(String.format("%32s",Long.toBinaryString(n)).replace(' ','0'));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ;
    var b : String ;
     var n : long ;
     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     a := sc.getCurrent() ; 
     b := sc.getCurrent() ; 
    n := MathLib.bitwiseAnd((a)->toLong(),(b)->toLong()) ; 
    OclFile["System.out"].println(StringLib.format("%32s",Sequence{(MathLib.decimal2binary(n) + "")}).replace(' ', '0')) ; 
    n := MathLib.bitwiseOr((a)->toLong(),(b)->toLong()) ; 
    OclFile["System.out"].println(StringLib.format("%32s",Sequence{(MathLib.decimal2binary(n) + "")}).replace(' ', '0')) ; 
    n := MathLib.bitwiseXor((a)->toLong(),(b)->toLong()) ; 
    OclFile["System.out"].println(StringLib.format("%32s",Sequence{(MathLib.decimal2binary(n) + "")}).replace(' ', '0')) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
public class InnaAndChooseOptions {
  public static boolean isSolution(int columnsCount,String x){
    boolean allXs[]=new boolean[columnsCount];
    Arrays.fill(allXs,true);
    for(int i=0 ; i<12 ; i++){
      if(x.charAt(i)!='X')allXs[i % columnsCount]=false ;
    }
    for(int i=0 ; i<columnsCount ; i++)if(allXs[i])return true ;
    return false ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    for(int i=0 ; i<t ; i++){
      int possibleSolutions=0 ;
      StringBuilder solutions=new StringBuilder();
      String s=br.readLine();
      if(isSolution(12,s)){
        solutions.append(" 1x12");
        possibleSolutions++;
      }
      if(isSolution(6,s)){
        solutions.append(" 2x6");
        possibleSolutions++;
      }
      if(isSolution(4,s)){
        solutions.append(" 3x4");
        possibleSolutions++;
      }
      if(isSolution(3,s)){
        solutions.append(" 4x3");
        possibleSolutions++;
      }
      if(isSolution(2,s)){
        solutions.append(" 6x2");
        possibleSolutions++;
      }
      if(isSolution(1,s)){
        solutions.append(" 12x1");
        possibleSolutions++;
      }
      pw.print(possibleSolutions++);
      pw.println(solutions);
    }
    pw.flush();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class InnaAndChooseOptions {
  static   operation isSolution( columnsCount : int, x : String) : boolean
  pre: true
  post: true
  activity: (     var allXs : Sequence(boolean) ; allXs := Integer.subrange(1,columnsCount)->collect(false) ;
     allXs := allXs->collect(true) ; 
        var i : int ; i := 0 ; while i < 12 do ( (     if (x->at(i+1) /= 'X') then     allXs[i mod columnsCount+1] := false ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < columnsCount do (     if (allXs[i+1]) then     return true else skip ;  ;     i := i + 1 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < t do ( (     var possibleSolutions : int ; possibleSolutions := 0 ;
     var solutions : String ; solutions := StringLib.newString() ;
    var s : String ; s := br.readLine() ;
    if (isSolution(12, s)) then (     solutions := solutions + StringLib.newString(" 1x12") ; 
     possibleSolutions := possibleSolutions + 1 ) else skip ; 
    if (isSolution(6, s)) then (     solutions := solutions + StringLib.newString(" 2x6") ; 
     possibleSolutions := possibleSolutions + 1 ) else skip ; 
    if (isSolution(4, s)) then (     solutions := solutions + StringLib.newString(" 3x4") ; 
     possibleSolutions := possibleSolutions + 1 ) else skip ; 
    if (isSolution(3, s)) then (     solutions := solutions + StringLib.newString(" 4x3") ; 
     possibleSolutions := possibleSolutions + 1 ) else skip ; 
    if (isSolution(2, s)) then (     solutions := solutions + StringLib.newString(" 6x2") ; 
     possibleSolutions := possibleSolutions + 1 ) else skip ; 
    if (isSolution(1, s)) then (     solutions := solutions + StringLib.newString(" 12x1") ; 
     possibleSolutions := possibleSolutions + 1 ) else skip ; 
    skip ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class lunarnewyearandcrosscounting {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter((System.out));
    int n=Integer.parseInt(in.readLine());
    String[] M=new String[n];
    for(int i=0 ; i<n ; i++){
      M[i]=in.readLine();
    }
    int a=0 ;
    for(int i=1 ; i<n-1 ; i++){
      for(int j=1 ; j<n-1 ; j++){
        if(M[i] .charAt(j)=='X'){
          if((M[i] .charAt(j)==M[i-1] .charAt(j-1))&&(M[i] .charAt(j)==M[i-1] .charAt(j+1))&&(M[i] .charAt(j)==M[i+1] .charAt(j-1))&&(M[i] .charAt(j)==M[i+1] .charAt(j+1))){
            a++;
          }
        }
      }
    }
    out.println(a);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class lunarnewyearandcrosscounting {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write((OclFile["System.out"])) ;
    var n : int ; n := (in.readLine())->toInteger() ;
    var M : Sequence(String) ; M := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     M[i+1] := in.readLine() )  ;     i := i + 1 ) ; 
    var a : int ; a := 0 ;
        var i : int ; i := 1 ; while i < n - 1 do ( (         var j : int ; j := 1 ; while j < n - 1 do ( (     if (M[i+1]->at(j+1) = 'X') then (     if ((M[i+1]->at(j+1) = M[i - 1+1]->at(j - 1+1)) & (M[i+1]->at(j+1) = M[i - 1+1]->at(j + 1+1)) & (M[i+1]->at(j+1) = M[i + 1+1]->at(j - 1+1)) & (M[i+1]->at(j+1) = M[i + 1+1]->at(j + 1+1))) then (     a := a + 1 ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileNotFoundException ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import static java.lang.System.in ;
import java.util.ArrayList ;
public class lunarnewyearandcrosscounting {
  static PrintWriter go=new PrintWriter(System.out);
  public static void main(String args[])throws IOException,FileNotFoundException {
    BufferedReader gi=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(gi.readLine());
    int nb=0 ;
    String[] M=new String[n];
    for(int i=0 ; i<n ; i++){
      M[i]=gi.readLine();
    }
    for(int i=1 ; i<n-1 ; i++){
      for(int j=1 ; j<n-1 ; j++){
        if('X'==M[i] .charAt(j)&& 'X'==M[i-1] .charAt(j-1)&& 'X'==M[i-1] .charAt(j+1)&& 'X'==M[i+1] .charAt(j-1)&& 'X'==M[i+1] .charAt(j+1)){
          nb++;
        }
      }
    }
    go.println(nb);
    go.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class lunarnewyearandcrosscounting {
  static   attribute go : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var gi : OclFile ; gi := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (gi.readLine())->toInteger() ;
    var nb : int ; nb := 0 ;
    var M : Sequence(String) ; M := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     M[i+1] := gi.readLine() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (         var j : int ; j := 1 ; while j < n - 1 do ( (     if ('X' = M[i+1]->at(j+1) & 'X' = M[i - 1+1]->at(j - 1+1) & 'X' = M[i - 1+1]->at(j + 1+1) & 'X' = M[i + 1+1]->at(j - 1+1) & 'X' = M[i + 1+1]->at(j + 1+1)) then (     nb := nb + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class LunarNewYear {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    char[][] s=new char[n][n];
    for(int i=0 ; i<n ; i++){
      s[i]=input.next().toCharArray();
    }
    int counter=0 ;
    for(int i=1 ; i<n-1 ; i++){
      for(int j=1 ; j<n-1 ; j++){
        if(s[i][j]=='X' && s[i-1][j+1]=='X' && s[i+1][j+1]=='X' && s[i-1][j-1]=='X' && s[i+1][j-1]=='X'){
          counter++;
        }
      }
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class LunarNewYear {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var s : Sequence(Sequence(String)) ; s := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := input.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    var counter : int ; counter := 0 ;
        var i : int ; i := 1 ; while i < n - 1 do ( (         var j : int ; j := 1 ; while j < n - 1 do ( (     if (s[i+1][j+1] = 'X' & s[i - 1+1][j + 1+1] = 'X' & s[i + 1+1][j + 1+1] = 'X' & s[i - 1+1][j - 1+1] = 'X' & s[i + 1+1][j - 1+1] = 'X') then (     counter := counter + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void findTriplets(int[] arr,int n,int sum){
    Arrays.sort(arr);
    for(int i=0 ; i<n-1 ; i++){
      int l=i+1 ;
      int r=n-1 ;
      int x=arr[i];
      while(l<r){
        if(x+arr[l]+arr[r]==sum){
          System.out.println(x+" "+arr[l]+" "+arr[r]);
          l++;
          r--;
        }
        else if(x+arr[l]+arr[r]<sum)l++;
        else r--;
      }
    }
  }
  public static void main(String args[]){
    int[] arr=new int[] {
      0,-1,2,-3,1 };
      int sum=-2 ;
      int n=arr.length ;
      findTriplets(arr,n,sum);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findTriplets( arr : Sequence(int), n : int, sum : int) : void
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
         var i : int ; i := 0 ; while i < n - 1 do ( (     var l : int ; l := i + 1 ;
     var r : int ; r := n - 1 ;
     var x : int ; x := arr[i+1] ;
     while (l < r) do (     if (x + arr[l+1] + arr[r+1] = sum) then (     OclFile["System.out"].println(x + " " + arr[l+1] + " " + arr[r+1]) ; 
     l := l + 1 ; 
     r := r - 1 ) else     if (x + arr[l+1] + arr[r+1] < sum) then     l := l + 1 else     r := r - 1 ; ;  ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,-1,2,-3,1} ;
     var sum : int ; sum := -2 ;
     var n : int ; n := arr->size() ;
     execute findTriplets(arr, n, sum) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      int x=in.nextInt();
      int tak=0 ;
      int jup=0 ;
      for(int i=0 ; i<n ; i++){
        if(in.nextInt()% 2==0){
          jup++;
        }
        else {
          tak++;
        }
      }
      if(tak==0 || x % 2==0 && jup==0 || n==x && tak % 2==0){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var x : int ; x := in.getCurrent()->toInteger() ;
    var tak : int ; tak := 0 ;
    var jup : int ; jup := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (in.getCurrent()->toInteger() mod 2 = 0) then (     jup := jup + 1 ) else (     tak := tak + 1 ) )  ;     i := i + 1 ) ; 
    if (tak = 0 or x mod 2 = 0 & jup = 0 or n = x & tak mod 2 = 0) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class OddSelection {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=scanner.nextInt(),k=scanner.nextInt();
      int oc=0,ec=0 ;
      for(int j=0 ; j<n ; j++){
        int num=scanner.nextInt();
        if(num % 2==0)ec++;
        else oc++;
      }
      if(oc==0)System.out.println("NO");
      else {
        if(oc % 2==0)oc--;
        if(k>oc){
          System.out.println(ec>=k-oc ? "YES" : "NO");
        }
        else {
          if(k % 2==0){
            System.out.println(ec>=1 ? "YES" : "NO");
          }
          else System.out.println("YES");
        }
      }
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class OddSelection {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
     var oc : int ; oc := 0 ;
    var ec : int ; ec := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     var num : int ; num := scanner.getCurrent()->toInteger() ;
     if (num mod 2 = 0) then     ec := ec + 1 ; else     oc := oc + 1 ; )  ;     j := j + 1 ) ; 
     if (oc = 0) then     OclFile["System.out"].println("NO") ; else (     if (oc mod 2 = 0) then     oc := oc - 1 ; else skip ; 
     if (k > oc) then (     OclFile["System.out"].println(if ec >= k - oc then "YES" else "NO" endif) ) else (     if (k mod 2 = 0) then (     OclFile["System.out"].println(if ec >= 1 then "YES" else "NO" endif) ) else     OclFile["System.out"].println("YES") ; ) ) )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double cal_speed(double dist,double time){
    System.out.print("\n Distance(km): "+dist);
    System.out.print("\n Time(hr): "+time);
    return dist/time ;
  }
  static double cal_dis(double speed,double time){
    System.out.print("\n Time(hr): "+time);
    System.out.print("\n Speed(km/hr): "+speed);
    return speed*time ;
  }
  static double cal_time(double dist,double speed){
    System.out.print("\n Distance(km): "+dist);
    System.out.print("\n Speed(km/hr): "+speed);
    return speed*dist ;
  }
  public static void main(String[] args){
    System.out.println("\n The calculated Speed(km/hr)is : "+cal_speed(45.9,2.0));
    System.out.println("\n The calculated Distance(km): "+cal_dis(62.9,2.5));
    System.out.println("\n The calculated Time(hr): "+cal_time(48.0,4.5));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation cal_speed( dist : double, time : double) : double
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("\n Distance(km): " + dist) ; 
     OclFile["System.out"].print("\n Time(hr): " + time) ; 
     return dist / time );
  static   operation cal_dis( speed : double, time : double) : double
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("\n Time(hr): " + time) ; 
     OclFile["System.out"].print("\n Speed(km/hr): " + speed) ; 
     return speed * time );
  static   operation cal_time( dist : double, speed : double) : double
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("\n Distance(km): " + dist) ; 
     OclFile["System.out"].print("\n Speed(km/hr): " + speed) ; 
     return speed * dist );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("\n The calculated Speed(km/hr)is : " + cal_speed(45.9, 2.0)) ; 
     OclFile["System.out"].println("\n The calculated Distance(km): " + cal_dis(62.9, 2.5)) ; 
     OclFile["System.out"].println("\n The calculated Time(hr): " + cal_time(48.0, 4.5)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static float trapezoidarea(float r){
    if(r<0)return-1 ;
    float a=(3*(float)Math.sqrt(3)*(float)Math.pow(r,2))/4 ;
    return a ;
  }
  public static void main(String args[]){
    float r=5 ;
    System.out.printf("%.3f",trapezoidarea(r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation trapezoidarea( r : double) : double
  pre: true
  post: true
  activity: (     if (r < 0) then     return -1 else skip ; 
     var a : double ; a := (3 * (3)->sqrt()->oclAsType(double) * r->pow(2)->oclAsType(double)) / 4 ;
     return a );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : double ; r := 5 ;
     OclFile["System.out"].printf("%.3f", trapezoidarea(r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int count=0 ; count<t ; count++){
      int n=sc.nextInt();
      int[] x=new int[n];
      int[] t0=new int[n];
      int xmin=Integer.MAX_VALUE ;
      int xmax=Integer.MIN_VALUE ;
      int tmax=Integer.MIN_VALUE ;
      for(int i=0 ; i<n ; i++){
        x[i]=sc.nextInt();
        xmin=Math.min(xmin,x[i]);
        xmax=Math.max(xmax,x[i]);
      }
      for(int i=0 ; i<n ; i++){
        t0[i]=sc.nextInt();
        tmax=Math.max(tmax,t0[i]);
      }
      int l=tmax ;
      int r=tmax+xmax-xmin ;
      while(l<r-1){
        int mid=l+(r-l)/2 ;
        int rMin=Integer.MAX_VALUE ;
        int lMax=Integer.MIN_VALUE ;
        for(int i=0 ; i<n ; i++){
          rMin=Math.min(rMin,x[i]+mid-t0[i]);
          lMax=Math.max(lMax,x[i]-mid+t0[i]);
        }
        if(rMin>=lMax){
          r=mid ;
        }
        else {
          l=mid ;
        }
      }
      int lMax=Integer.MIN_VALUE ;
      int rMin=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; i++){
        lMax=Math.max(lMax,x[i]-r+t0[i]);
        rMin=Math.min(rMin,x[i]+r-t0[i]);
      }
      double ans=(rMin+lMax)*1.0/2 ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var count : int ; count := 0 ; while count < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var t0 : Sequence(int) ; t0 := Integer.subrange(1,n)->collect(0) ;
    var xmin : int ; xmin := 2147483647 ;
    var xmax : int ; xmax := -2147483648 ;
    var tmax : int ; tmax := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     xmin := Set{xmin, x[i+1]}->min() ; 
     xmax := Set{xmax, x[i+1]}->max() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     t0[i+1] := sc.getCurrent()->toInteger() ; 
     tmax := Set{tmax, t0[i+1]}->max() )  ;     i := i + 1 ) ; 
    var l : int ; l := tmax ;
    var r : int ; r := tmax + xmax - xmin ;
    while (l < r - 1) do (     var mid : int ; mid := l + (r - l) / 2 ;
     var rMin : int ; rMin := 2147483647 ;
    var lMax : int ; lMax := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     rMin := Set{rMin, x[i+1] + mid - t0[i+1]}->min() ; 
     lMax := Set{lMax, x[i+1] - mid + t0[i+1]}->max() )  ;     i := i + 1 ) ; 
    if (rMin >= lMax) then (     r := mid ) else (     l := mid ) ;  
 ) ; 
    var lMax : int ; lMax := -2147483648 ;
    var rMin : int ; rMin := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     lMax := Set{lMax, x[i+1] - r + t0[i+1]}->max() ; 
     rMin := Set{rMin, x[i+1] + r - t0[i+1]}->min() )  ;     i := i + 1 ) ; 
    var ans : double ; ans := (rMin + lMax) * 1.0 / 2 ;
    OclFile["System.out"].println(ans) ; 
 )  ;     count := count + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class OnTheLine {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      t--;
      int n=sc.nextInt();
      int[] x=new int[n];
      for(int i=0 ; i<n ; i++){
        x[i]=sc.nextInt();
      }
      int minDist=Integer.MAX_VALUE ;
      int maxDist=Integer.MIN_VALUE ;
      for(int i=0 ; i<n ; i++){
        int time=sc.nextInt();
        minDist=Math.min(x[i]-time,minDist);
        maxDist=Math.max(x[i]+time,maxDist);
      }
      System.out.println((minDist+maxDist)*0.5);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class OnTheLine {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     t := t - 1 ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var minDist : int ; minDist := 2147483647 ;
    var maxDist : int ; maxDist := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     var time : int ; time := sc.getCurrent()->toInteger() ;
     minDist := Set{x[i+1] - time, minDist}->min() ; 
     maxDist := Set{x[i+1] + time, maxDist}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((minDist + maxDist) * 0.5) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long M=1_000_000_007 ;
    char[] s=scanner.next().toCharArray();
    long[][] dp=new long[s.length+1][13];
    int[] map={
      0,4,8,12,3,7,11,2,6,10,1,5,9 };
      dp[0][0]=1 ;
      for(int i=1 ; i<=s.length ; i++){
        char ch=s[i-1];
        for(int j=0 ; j<13 ; j++){
          if(ch=='?'){
            for(int k=0 ; k<10 ; k++){
              int l=j-k ;
              if(l<0)l+=13 ;
              dp[i][j]+=dp[i-1][map[l] ];
              if(dp[i][j]>=M)dp[i][j]-=M ;
            }
          }
          else {
            int l=j-(ch-'0');
            if(l<0)l+=13 ;
            dp[i][j]=dp[i-1][map[l] ];
          }
        }
      }
      System.out.println(dp[s.length][5]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var M : long ; M := 1_000_000_007 ;
    var s : Sequence(String) ; s := scanner.getCurrent()->characters() ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,s->size() + 1)->collect(Integer.subrange(1,13)->collect(0)) ;
    var map : Sequence(int) ; map := Sequence{0,4,8,12,3,7,11,2,6,10,1,5,9} ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= s->size() do ( (     var ch : String ; ch := s[i - 1+1] ;
         var j : int ; j := 0 ; while j < 13 do ( (     if (ch = '?') then (         var k : int ; k := 0 ; while k < 10 do ( (     var l : int ; l := (j)->char2byte() - k ;
     if (l < 0) then     l := l+(13) ; else skip ; 
     dp[i+1][j+1] := dp[i+1][j+1]+(dp[i - 1+1][map[l+1]+1]) ; 
     if (dp[i+1][j+1] >= M) then     dp[i+1][j+1] := dp[i+1][j+1]-(M) ; else skip )  ;     k := k + 1 ) ) else (     var l : int ; l := (j)->char2byte() - ((ch)->char2byte() - ('0')->char2byte()) ;
     if (l < 0) then     l := l+(13) ; else skip ; 
     dp[i+1][j+1] := dp[i - 1+1][map[l+1]+1] ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[s->size()+1][5+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B278 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    String[] S=new String[N];
    for(int n=0 ; n<N ; n++){
      S[n]=in.next();
    }
    for(char c='a' ; c<='z' ; c++){
      boolean found=false ;
      for(String s : S){
        if(s.indexOf(c)!=-1){
          found=true ;
          break ;
        }
      }
      if(! found){
        System.out.println(c);
        return ;
      }
    }
    for(char c1='a' ; c1<='z' ; c1++){
      for(char c2='a' ; c2<='z' ; c2++){
        String cand=c1+""+c2 ;
        boolean found=false ;
        for(String s : S){
          if(s.contains(cand)){
            found=true ;
            break ;
          }
        }
        if(! found){
          System.out.println(cand);
          return ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B278 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var S : Sequence(String) ; S := Integer.subrange(1,N)->collect(null) ;
        var n : int ; n := 0 ; while n < N do ( (     S[n+1] := in.getCurrent() )  ;     n := n + 1 ) ; 
        var c : String ; c := 'a' ; while c <= 'z' do ( (     var found : boolean ; found := false ;
     for (s : S) do ( (     if (s->indexOf(c)-1 /= -1) then (     found := true ; 
     break ) else skip )  ) ; 
     if (not(found)) then (     OclFile["System.out"].println(c) ; 
     return ) else skip )  ;     c := c + 1 ) ; 
        var c1 : String ; c1 := 'a' ; while c1 <= 'z' do ( (         var c2 : String ; c2 := 'a' ; while c2 <= 'z' do ( (     var cand : String ; cand := c1 + "" + c2 ;
     var found : boolean ; found := false ;
     for (s : S) do ( (     if (s->includes(cand)) then (     found := true ; 
     break ) else skip )  ) ; 
     if (not(found)) then (     OclFile["System.out"].println(cand) ; 
     return ) else skip )  ;     c2 := c2 + 1 ) )  ;     c1 := c1 + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int binomialCoeff(int n,int k){
    int res=1 ;
    if(k>n-k)k=n-k ;
    for(int i=0 ; i<k ; ++i){
      res*=(n-i);
      res/=(i+1);
    }
    return res ;
  }
  static int power(int x,int y){
    int res=1 ;
    while(y>0){
      if((y & 1)==1)res=res*x ;
      y=y>>1 ;
      x=x*x ;
    }
    return res ;
  }
  static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  static void FindProbability(int n){
    int up=binomialCoeff(2*n,n);
    int down=power(2,2*n);
    int g=gcd(up,down);
    up/=g ;
    down/=g ;
    System.out.println(up+"/"+down);
  }
  public static void main(String[] args){
    int N=8 ;
    FindProbability(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation binomialCoeff( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     if (k > n - k) then     k := n - k ; else skip ; 
         var i : int ; i := 0 ; while i < k do ( (     res := res*((n - i)) ; 
     res := res/((i + 1)) )  ;     i := i + 1 ) ; 
     return res );
  static   operation power( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     while (y > 0) do (     if ((y & 1) = 1) then     res := res * x ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := x * x ) ; 
     return res );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation FindProbability( n : int) : void
  pre: true
  post: true
  activity: (     var up : int ; up := binomialCoeff(2 * n, n) ;
     var down : int ; down := power(2, 2 * n) ;
    var g : int ; g := gcd(up, down) ;
    up := up/(g) ; 
    down := down/(g) ; 
    OclFile["System.out"].println(up + "/" + down) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 8 ;
     execute FindProbability(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      String s=sc.next();
      if(s.equals("0")){
        break ;
      }
      int n=s.length();
      int step=-1 ;
      boolean flag=false ;
      LinkedList<String>list=new LinkedList<String>();
      LinkedList<String>next=new LinkedList<String>();
      HashSet<String>set=new HashSet<String>();
      list.add(s);
      while(! list.isEmpty()&& ! flag){
        step++;
        for(String t : list){
          if(! set.contains(t)){
            set.add(t);
            char bug[]=t.toCharArray();
            boolean b=true ;
            for(int i=0 ; i<n-1 ; i++){
              if(bug[i]!=bug[i+1]){
                b=false ;
                char le=bug[i];
                char ri=bug[i+1];
                char an=le!='r' && ri!='r' ? 'r' : le!='g' && ri!='g' ? 'g' : 'b' ;
                bug[i]=an ;
                bug[i+1]=an ;
                next.add(new String(bug));
                bug[i]=le ;
                bug[i+1]=ri ;
              }
            }
            if(b){
              flag=true ;
              break ;
            }
          }
        }
        list=next ;
        next=new LinkedList<String>();
      }
      System.out.println(flag ? step : "NA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var s : String ; s := sc.getCurrent() ;
     if (s = "0") then (     break ) else skip ; 
    var n : int ; n := s->size() ;
    var step : int ; step := -1 ;
    var flag : boolean ; flag := false ;
    var list : Sequence(String) ; list := Sequence{} ;
    var next : Sequence(String) ; next := Sequence{} ;
    var set : Set(String) ; set := Set{} ;
    list := list->including(s) ; 
    while (not(list->isEmpty()) & not(flag)) do (     step := step + 1 ; 
     for (t : list) do ( (     if (not(set->includes(t))) then (     set := set->including(t) ; 
     var bug : Sequence(String) ; bug := t->characters() ;
    var b : boolean ; b := true ;
        var i : int ; i := 0 ; while i < (n)->char2byte() - 1 do ( (     if (bug[i+1] /= bug[i + 1+1]) then (     b := false ; 
     var le : String ; le := bug[i+1] ;
    var ri : String ; ri := bug[i + 1+1] ;
    var an : String ; an := if le /= 'r' & ri /= 'r' then 'r' else if le /= 'g' & ri /= 'g' then 'g' else 'b' endif endif ;
    bug[i+1] := an ; 
    bug[i + 1+1] := an ; 
    next := next->including(StringLib.newString(bug)) ; 
    bug[i+1] := le ; 
    bug[i + 1+1] := ri ; 
 ) else skip )  ;     i := i + 1 ) ; 
    if (b) then (     flag := true ; 
     break ) else skip ; 
 ) else skip )  ) ; 
     list := next ; 
     next := Sequence{} ) ; 
    OclFile["System.out"].println(if flag then step else "NA" endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemB {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int test=Integer.parseInt(br.readLine());
    while(test-->0){
      int n=Integer.parseInt(br.readLine());
      String line[]=br.readLine().split(" ");
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=Integer.parseInt(line[i]);
      Arrays.sort(arr);
      boolean ok=true ;
      int ans=1 ;
      for(int i=0 ; i<n-1 ; i++){
        if(arr[i+1]-arr[i]==1)ok=false ;
      }
      if(! ok)ans=2 ;
      sb.append(ans);
      sb.append("\n");
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var test : int ; test := (br.readLine())->toInteger() ;
        while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := (line[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var ok : boolean ; ok := true ;
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i + 1+1] - arr[i+1] = 1) then     ok := false ; else skip )  ;     i := i + 1 ) ; 
    if (not(ok)) then     ans := 2 ; else skip ; 
    sb := sb + StringLib.newString(ans) ; 
    sb := sb + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Queue ;
import java.util.Scanner ;
public class A1249 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int q=scanner.nextInt();
    while(q-->0){
      int n=scanner.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=scanner.nextInt();
      }
      Arrays.sort(a);
      Queue<Integer>queue=new LinkedList<>();
      for(int i=0 ; i<n ; i++){
        queue.add(a[i]);
      }
      List<Integer>tempList=new LinkedList<>();
      int ans=0 ;
      while(! queue.isEmpty()){
        int size=queue.size();
        for(int i=1 ; i<=size ; i++){
          int x=queue.poll();
          if(tempList.contains(x+1)|| tempList.contains(x-1)){
            queue.add(x);
          }
          else {
            tempList.add(x);
          }
        }
        tempList.clear();
        ans++;
      }
      System.out.println(ans);
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1249 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := scanner.getCurrent()->toInteger() ;
         while (q > 0) do (        q := q - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var queue : Sequence(int) ; queue := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     queue := queue->including(a[i+1]) )  ;     i := i + 1 ) ; 
    var tempList : Sequence(int) ; tempList := Sequence{} ;
    var ans : int ; ans := 0 ;
    while (not(queue->isEmpty())) do (     var size : int ; size := queue->size() ;
         var i : int ; i := 1 ; while i <= size do ( (     var x : int ; x := queue->min() ;
     if (tempList->includes(x + 1) or tempList->includes(x - 1)) then (     queue := queue->including(x) ) else (     tempList := tempList->including(x) ) )  ;     i := i + 1 ) ; 
     tempList := tempList->intersection(Set{}) ; 
     ans := ans + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A1249 {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int p=s.nextInt();
    while(p-->0){
      int n=s.nextInt();
      int[] x=new int[n];
      for(int i=0 ; i<n ; i++)x[i]=s.nextInt();
      Arrays.sort(x);
      int g=1 ;
      for(int i=n-1 ; i>=1 ; i--){
        if(x[i]-x[i-1]==1)g=2 ;
      }
      System.out.println(g);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1249 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : int ; p := s.getCurrent()->toInteger() ;
         while (p > 0) do (        p := p - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     x[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    x := x->sort() ; 
    var g : int ; g := 1 ;
        var i : int ; i := n - 1 ; while i >= 1 do ( (     if (x[i+1] - x[i - 1+1] = 1) then     g := 2 ; else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(g) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class BinaryStr {
  public static void main(String[] args)throws IOException {
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.valueOf(bf.readLine());
    for(int i=0 ; i<t ; i++){
      int n=Integer.valueOf(bf.readLine());
      char[] arr=bf.readLine().toCharArray();
      char[] arr2=new char[n];
      for(int j=0 ; j<=n-1 ; j++){
        arr2[j]=arr[j];
      }
      for(int j=0 ; j<=n-1 ; j++){
        if(j % 2==0){
          arr2[j]='0' ;
        }
        else {
          arr2[j]='1' ;
        }
      }
      int cur=0 ;
      int k ;
      for(int j=0 ; j<=n-1 ; j++){
        if(arr[j]==arr2[j])continue ;
        for(k=j ; k<=n-1 ; k++){
          if(arr[k]==arr2[k])break ;
        }
        cur++;
        j=k-1 ;
      }
      int ans=Integer.MAX_VALUE ;
      ans=Math.min(ans,cur);
      for(int j=0 ; j<=n-1 ; j++){
        if(j % 2==1){
          arr2[j]='0' ;
        }
        else {
          arr2[j]='1' ;
        }
      }
      cur=0 ;
      for(int j=0 ; j<=n-1 ; j++){
        if(arr[j]==arr2[j])continue ;
        for(k=j ; k<=n-1 ; k++){
          if(arr[k]==arr2[k])break ;
        }
        cur++;
        j=k-1 ;
      }
      ans=Math.min(ans,cur);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BinaryStr {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (bf.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := (bf.readLine())->toInteger() ;
     var arr : Sequence(String) ; arr := bf.readLine()->characters() ;
    var arr2 : Sequence(String) ; arr2 := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j <= n - 1 do ( (     arr2[j+1] := arr[j+1] )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j <= n - 1 do ( (     if (j mod 2 = 0) then (     arr2[j+1] := '0' ) else (     arr2[j+1] := '1' ) )  ;     j := j + 1 ) ; 
    var cur : int ; cur := 0 ;
    var k : int ;
        var j : int ; j := 0 ; while j <= n - 1 do ( (     if (arr[j+1] = arr2[j+1]) then     continue else skip ; 
         k := j ; while k <= n - 1 do ( (     if (arr[k+1] = arr2[k+1]) then     break else skip )  ;     k := k + 1 ) ; 
     cur := cur + 1 ; 
     j := k - 1 )  ;     j := j + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
    ans := Set{ans, cur}->min() ; 
        var j : int ; j := 0 ; while j <= n - 1 do ( (     if (j mod 2 = 1) then (     arr2[j+1] := '0' ) else (     arr2[j+1] := '1' ) )  ;     j := j + 1 ) ; 
    cur := 0 ; 
        var j : int ; j := 0 ; while j <= n - 1 do ( (     if (arr[j+1] = arr2[j+1]) then     continue else skip ; 
         k := j ; while k <= n - 1 do ( (     if (arr[k+1] = arr2[k+1]) then     break else skip )  ;     k := k + 1 ) ; 
     cur := cur + 1 ; 
     j := k - 1 )  ;     j := j + 1 ) ; 
    ans := Set{ans, cur}->min() ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class A_Yet_Another_Dividing_into_Teams {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    for(int tc=0 ; tc<q ; tc++){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; i++){
        a[i]=sc.nextInt();
      }
      System.out.println(solve(a));
    }
    sc.close();
  }
  static int solve(int[] a){
    Arrays.sort(a);
    return IntStream.range(0,a.length-1).anyMatch(i->a[i]+1==a[i+1])? 2 : 1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Yet_Another_Dividing_into_Teams {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < q do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(solve(a)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     return if Integer.subrange(0, a->size() - 1-1)->exists( _x2 | (lambda i : OclAny in a[i+1] + 1 = a[i + 1+1])->apply(_x2) ) then 2 else 1 endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findSubsequence(int arr[],int n){
    int len=1 ;
    int tmp ;
    int i,j,d ;
    int[][] dp=new int[n][10];
    int[] cnt=new int[10];
    int locMax ;
    tmp=arr[0];
    while(tmp>0){
      dp[0][tmp % 10]=1 ;
      tmp/=10 ;
    }
    for(i=1 ; i<n ; i++){
      tmp=arr[i];
      locMax=1 ;
      for(int x=0 ; x<10 ; x++)cnt[x]=0 ;
      while(tmp>0){
        cnt[tmp % 10]=1 ;
        tmp/=10 ;
      }
      for(d=0 ; d<=9 ; d++){
        if(cnt[d]>0){
          dp[i][d]=1 ;
          for(j=0 ; j<i ; j++){
            dp[i][d]=Math.max(dp[i][d],dp[j][d]+1);
            locMax=Math.max(dp[i][d],locMax);
          }
        }
      }
      for(d=0 ; d<=9 ; d++){
        if(cnt[d]>0){
          dp[i][d]=locMax ;
        }
      }
      len=Math.max(len,locMax);
    }
    return len ;
  }
  public static void main(String[] args){
    int arr[]={
      1,12,44,29,33,96,89 };
      int n=arr.length ;
      System.out.println(findSubsequence(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findSubsequence( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var len : int ; len := 1 ;
     var tmp : int ;
    var i : int ;
    var j : int ;
    var d : int ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,10)->collect(0)) ;
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,10)->collect(0) ;
    var locMax : int ;
    tmp := arr[0+1] ; 
    while (tmp > 0) do (     dp[0+1][tmp mod 10+1] := 1 ; 
     tmp := tmp/(10) ) ; 
        i := 1 ; while i < n do ( (     tmp := arr[i+1] ; 
     locMax := 1 ; 
        var x : int ; x := 0 ; while x < 10 do (     cnt[x+1] := 0 ;  ;     x := x + 1 ) ; 
    while (tmp > 0) do (     cnt[tmp mod 10+1] := 1 ; 
     tmp := tmp/(10) ) ; 
        d := 0 ; while d <= 9 do ( (     if (cnt[d+1] > 0) then (     dp[i+1][d+1] := 1 ; 
         j := 0 ; while j < i do ( (     dp[i+1][d+1] := Set{dp[i+1][d+1], dp[j+1][d+1] + 1}->max() ; 
     locMax := Set{dp[i+1][d+1], locMax}->max() )  ;     j := j + 1 ) ) else skip )  ;     d := d + 1 ) ; 
        d := 0 ; while d <= 9 do ( (     if (cnt[d+1] > 0) then (     dp[i+1][d+1] := locMax ) else skip )  ;     d := d + 1 ) ; 
    len := Set{len, locMax}->max() ; 
 )  ;     i := i + 1 ) ; 
    return len 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,12,44,29,33,96,89} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findSubsequence(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=1 ;
    while(t--!=0){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int[][] a=new int[n][m];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<m ; j++)a[i][j]=sc.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        if(a[i][0]==1 || a[i][m-1]==1){
          System.out.println("2");
          return ;
        }
      }
      for(int i=0 ; i<m ; i++){
        if(a[0][i]==1 || a[n-1][i]==1){
          System.out.println("2");
          return ;
        }
      }
      System.out.println(4);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do (     a[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1][0+1] = 1 or a[i+1][m - 1+1] = 1) then (     OclFile["System.out"].println("2") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     if (a[0+1][i+1] = 1 or a[n - 1+1][i+1] = 1) then (     OclFile["System.out"].println("2") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(4) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A9 {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int arr[][]=new int[n+2][m+2];
    int ans=4 ;
    for(int i=1 ; i<n+1 ; i++){
      for(int j=1 ; j<m+1 ; j++){
        arr[i][j]=in.nextInt();
        if((i==1 || i==n || j==1 || j==m)&& arr[i][j]==1)ans=2 ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A9 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n + 2)->collect(Integer.subrange(1,m + 2)->collect(0)) ;
    var ans : int ; ans := 4 ;
        var i : int ; i := 1 ; while i < n + 1 do ( (         var j : int ; j := 1 ; while j < m + 1 do ( (     arr[i+1][j+1] := in.getCurrent()->toInteger() ; 
     if ((i = 1 or i = n or j = 1 or j = m) & arr[i+1][j+1] = 1) then     ans := 2 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int n,m ;
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    m=sc.nextInt();
    int a ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        a=sc.nextInt();
        if(a==1){
          if(i==0 || i==(n-1)){
            System.out.println(2);
            System.exit(0);
          }
          else if(j==0 || j==(m-1)){
            System.out.println(2);
            System.exit(0);
          }
        }
      }
    }
    System.out.println(4);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var m : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
    var a : int ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     a := sc.getCurrent()->toInteger() ; 
     if (a = 1) then (     if (i = 0 or i = (n - 1)) then (     OclFile["System.out"].println(2) ; 
 OclProcess.exit(0) ) else     if (j = 0 or j = (m - 1)) then (     OclFile["System.out"].println(2) ; 
 OclProcess.exit(0) ) else skip ; ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(4) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TableColoring {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(scan.nextInt()==1 &&(i==0 || i==n-1 || j==0 || j==m-1)){
          System.out.println(2);
          return ;
        }
      }
    }
    System.out.println(4);
  }
}
------------------------------------------------------------
OCL File:
---------
 class TableColoring {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (scan.getCurrent()->toInteger() = 1 & (i = 0 or i = n - 1 or j = 0 or j = m - 1)) then (     OclFile["System.out"].println(2) ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(4) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Ideone {
  public static void main(String[] args)throws java.lang.Exception {
    long M=1000000007 ;
    long res=1 ;
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    for(int i=0 ; i<k-1 ; i++)res=(res*k)% M ;
    for(int i=0 ; i<n-k ; i++)res=(res*(n-k))% M ;
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ideone {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var M : long ; M := 1000000007 ;
     var res : long ; res := 1 ;
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < k - 1 do (     res := (res * k) mod M ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - k do (     res := (res * (n - k)) mod M ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countNums(int l,int r){
    int cnt=0 ;
    for(int i=l ; i<=r ; i++){
      int lastDigit=(i % 10);
      if((lastDigit % 10)==2 ||(lastDigit % 10)==3 ||(lastDigit % 10)==9){
        cnt++;
      }
    }
    return cnt ;
  }
  public static void main(String[] args){
    int l=11,r=33 ;
    System.out.print(countNums(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countNums( l : int, r : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := l ; while i <= r do ( (     var lastDigit : int ; lastDigit := (i mod 10) ;
     if ((lastDigit mod 10) = 2 or (lastDigit mod 10) = 3 or (lastDigit mod 10) = 9) then (     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 11 ;
    var r : int ; r := 33 ;
     OclFile["System.out"].print(countNums(l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printNumbers(int a[],int n,int x){
    boolean flag=false ;
    for(int i=0 ; i<n ; i++){
      int num=a[i];
      int g=__gcd(num,x);
      while(g!=1){
        num/=g ;
        g=__gcd(num,x);
      }
      if(num==1){
        flag=true ;
        System.out.print(a[i]+" ");
      }
    }
    if(! flag)System.out.println("There are no such numbers");
  }
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  public static void main(String[] args){
    int x=60 ;
    int a[]={
      2,5,10,7,17 };
      int n=a.length ;
      printNumbers(a,n,x);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printNumbers( a : Sequence(int), n : int, x : int) : void
  pre: true
  post: true
  activity: (     var flag : boolean ; flag := false ;
         var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := a[i+1] ;
     var g : int ; g := __gcd(num, x) ;
     while (g /= 1) do (     num := num/(g) ; 
     g := __gcd(num, x) ) ; 
     if (num = 1) then (     flag := true ; 
     OclFile["System.out"].print(a[i+1] + " ") ) else skip )  ;     i := i + 1 ) ; 
     if (not(flag)) then     OclFile["System.out"].println("There are no such numbers") ; else skip );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 60 ;
     var a : Sequence(int) ; a := Sequence{2,5,10,7,17} ;
     var n : int ; n := a->size() ;
     execute printNumbers(a, n, x) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static final int MOD=1_000_000_007 ;
  private static final String YES="YES" ;
  private static final String NO="NO" ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    System.out.println(solve(S));
  }
  private static long solve(String S){
    int[][] dp=new int[S.length()+1][13];
    dp[S.length()][0]=1 ;
    int mul=1 ;
    for(int i=S.length()-1 ; i>=0 ; i--){
      if(S.charAt(i)=='?'){
        for(int k=0 ; k<10 ; k++){
          for(int j=0 ; j<13 ; j++){
            int p=(mul*k+j)% 13 ;
            dp[i][p]+=dp[i+1][j];
            dp[i][p] %=MOD ;
          }
        }
      }
      else {
        int k=S.charAt(i)-'0' ;
        for(int j=0 ; j<13 ; j++){
          int p=(mul*k+j)% 13 ;
          dp[i][p]+=dp[i+1][j];
          dp[i][p] %=MOD ;
        }
      }
      mul*=10 ;
      mul %=13 ;
    }
    return dp[0][5] % MOD ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1_000_000_007;
  static    attribute YES : String := "YES";
  static    attribute NO : String := "NO";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
     OclFile["System.out"].println(solve(S)) );
  static   operation solve( S : String) : long
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,S->size() + 1)->collect(Integer.subrange(1,13)->collect(0)) ;
     dp[S->size()+1][0+1] := 1 ; 
    var mul : int ; mul := 1 ;
        var i : int ; i := S->size() - 1 ; while i >= 0 do ( (     if (S->at(i+1) = '?') then (         var k : int ; k := 0 ; while k < 10 do ( (         var j : int ; j := 0 ; while j < 13 do ( (     var p : int ; p := (mul * k + j) mod 13 ;
     dp[i+1][p+1] := dp[i+1][p+1]+(dp[i + 1+1][j+1]) ; 
     dp[i+1][p+1] := dp[i+1][p+1] mod MOD )  ;     j := j + 1 ) )  ;     k := k + 1 ) ) else (     var k : int ; k := S->at(i+1) - ('0')->char2byte() ;
         var j : int ; j := 0 ; while j < 13 do ( (     var p : int ; p := (mul * k + j) mod 13 ;
     dp[i+1][p+1] := dp[i+1][p+1]+(dp[i + 1+1][j+1]) ; 
     dp[i+1][p+1] := dp[i+1][p+1] mod MOD )  ;     j := j + 1 ) ) ;  
     mul := mul*(10) ; 
     mul := mul mod 13 )  ;     i := i - 1 ) ; 
    return dp[0+1][5+1] mod MOD 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMissing(int arr[],int n,int k,int avg){
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=arr[i];
    }
    int num=(avg*(n+k))-sum ;
    int den=k ;
    if(num % den!=0)return-1 ;
    return(int)(num/den);
  }
  public static void main(String[] args){
    int k=3,avg=4 ;
    int arr[]={
      2,7,3 };
      int n=arr.length ;
      System.out.println(findMissing(arr,n,k,avg));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMissing( arr : Sequence(int), n : int, k : int, avg : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    var num : int ; num := (avg * (n + k)) - sum ;
    var den : int ; den := k ;
    if (num mod den /= 0) then     return -1 else skip ; 
    return (num / den)->oclAsType(int) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 3 ;
    var avg : int ; avg := 4 ;
     var arr : Sequence(int) ; arr := Sequence{2,7,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMissing(arr, n, k, avg)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p008 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p008().run());
  }
  public String run(){
    long maxProd=-1 ;
    for(int i=0 ; i+ADJACENT<=NUMBER.length(); i++){
      long prod=1 ;
      for(int j=0 ; j<ADJACENT ; j++)prod*=NUMBER.charAt(i+j)-'0' ;
      maxProd=Math.max(prod,maxProd);
    }
    return Long.toString(maxProd);
  }
  private static final int ADJACENT=13 ;
  private static final String NUMBER="7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450" ;
}
------------------------------------------------------------
OCL File:
---------
class p008 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p008.newp008().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var maxProd : long ; maxProd := -1 ;
         var i : int ; i := 0 ; while i + ADJACENT <= NUMBER->size() do ( (     var prod : long ; prod := 1 ;
         var j : int ; j := 0 ; while j < ADJACENT do (     prod := prod*(NUMBER->at(i + j+1) - ('0')->char2byte()) ;  ;     j := j + 1 ) ; 
     maxProd := Set{prod, maxProd}->max() )  ;     i := i + 1 ) ; 
     return ((maxProd) + "") );
  static    attribute ADJACENT : int := 13;
  static    attribute NUMBER : String := "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450";
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner in=new Scanner(System.in)){
      int N=in.nextInt();
      int A=in.nextInt();
      int[] x=new int[N];
      for(int i=0 ; i<N ; i++){
        x[i]=in.nextInt();
      }
      long[][][] dp=new long[N+1][51][2501];
      dp[0][0][0]++;
      for(int i=0 ; i<N ; i++){
        for(int n=0 ; n<51 ; n++){
          for(int sum=0 ; sum<2501 ; sum++){
            if(dp[i][n][sum]<=0){
              continue ;
            }
            dp[i+1][n+0][sum+0]+=dp[i][n][sum];
            dp[i+1][n+1][sum+x[i] ]+=dp[i][n][sum];
          }
        }
      }
      long count=0 ;
      for(int n=0 ; n<51 ; n++){
        for(int sum=0 ; sum<2501 ; sum++){
          if(dp[N][n][sum]>0 && sum>0 && sum==A*n){
            count+=dp[N][n][sum];
          }
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := in.getCurrent()->toInteger() ;
     var A : int ; A := in.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     x[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(Sequence(long))) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,51)->collect(Integer.subrange(1,2501)->collect(0))) ;
    dp[0+1][0+1][0+1] := dp[0+1][0+1][0+1] + 1 ; 
        var i : int ; i := 0 ; while i < N do ( (         var n : int ; n := 0 ; while n < 51 do ( (         var sum : int ; sum := 0 ; while sum < 2501 do ( (     if (dp[i+1][n+1][sum+1] <= 0) then (     continue ) else skip ; 
     dp[i + 1+1][n + 0+1][sum + 0+1] := dp[i + 1+1][n + 0+1][sum + 0+1]+(dp[i+1][n+1][sum+1]) ; 
     dp[i + 1+1][n + 1+1][sum + x[i+1]+1] := dp[i + 1+1][n + 1+1][sum + x[i+1]+1]+(dp[i+1][n+1][sum+1]) )  ;     sum := sum + 1 ) )  ;     n := n + 1 ) )  ;     i := i + 1 ) ; 
    var count : long ; count := 0 ;
        var n : int ; n := 0 ; while n < 51 do ( (         var sum : int ; sum := 0 ; while sum < 2501 do ( (     if (dp[N+1][n+1][sum+1] > 0 & sum > 0 & sum = A * n) then (     count := count+(dp[N+1][n+1][sum+1]) ) else skip )  ;     sum := sum + 1 ) )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.PrintWriter ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] s=sc.next().toCharArray();
    BIT[] count=new BIT[26];
    for(int j=0 ; j<26 ; j++){
      count[j]=new BIT(1+s.length);
      for(int i=1 ; i<=s.length ; i++){
        if((s[i-1]-'a')==j){
          count[j] .add(i,1);
        }
      }
    }
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      if(a==1){
        char c=sc.next().charAt(0);
        count[c-'a'] .add(b,1);
        count[s[b-1]-'a'] .add(b,-1);
        s[b-1]=c ;
      }
      else {
        int c=sc.nextInt();
        int ans=0 ;
        for(int j=0 ; j<26 ; j++){
          if(count[j] .get(c)-count[j] .get(b-1)>0){
            ans++;
          }
        }
        System.out.println(ans);
      }
    }
  }
  static class BIT {
    int n ;
    int[] data ;
    BIT(int n){
      this.n=n ;
      data=new int[n+1];
    }
    void add(int i,int v){
      for(; i<=n ; i+=i &(-i))data[i]+=v ;
    }
    int get(int i){
      int res=0 ;
      for(; i>0 ; i-=i &(-i))res+=data[i];
      return res ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var count : Sequence(BIT) ; count := Integer.subrange(1,26)->collect(null) ;
        var j : int ; j := 0 ; while j < 26 do ( (     count[j+1] := BIT.newBIT(1 + s->size()) ; 
         var i : int ; i := 1 ; while i <= s->size() do ( (     if ((s[i - 1+1] - ('a')->char2byte()) = j) then (     count[j+1]->excludes(i, 1) ) else skip )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (a = 1) then (     var c : String ; c := sc.getCurrent()->at(0+1) ;
     count[(c)->char2byte() - ('a')->char2byte()+1]->excludes(b, 1) ; 
     count[s[b - 1+1] - ('a')->char2byte()+1]->excludes(b, -1) ; 
     s[b - 1+1] := c ) else (     var c : int ; c := sc.getCurrent()->toInteger() ;
     var ans : int ; ans := 0 ;
         var j : int ; j := 0 ; while j < 26 do ( (     if (count[j+1]->at(c+1) - count[j+1]->at(b - 1+1) > 0) then (     ans := ans + 1 ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(ans) ) )  ;     i := i + 1 ) ; 
 );
  static class BIT {
   attribute n : int;
   attribute data : Sequence(int);
   static operation newBIT( n : int) : BIT
  pre: true
  post: true
  activity:
  ( var self : BIT ;
    self := createBIT();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     self.n := n ; 
     data := Integer.subrange(1,n + 1)->collect(0) );
   operation add( i : int, v : int) : void
  pre: true
  post: true
  activity: (       while i <= n do (     data[i+1] := data[i+1]+(v) ;  ;     i := i+(MathLib.bitwiseAnd(i,(-i))) ) );
   operation get( i : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
       while i > 0 do (     res := res+(data[i+1]) ;  ;     i := i-(MathLib.bitwiseAnd(i,(-i))) ) ; 
     return res );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    int M=1<<N ;
    char[] cs=sc.next().toCharArray();
    boolean[] winBig=new boolean[M-1];
    for(int i=0 ; i<M-1 ; i++){
      winBig[i]=cs[i]=='1' ;
    }
    int[][] winner=new int[N+1][M];
    int[] P=new int[M];
    for(int i=0 ; i<M ; i++){
      P[i]=Integer.parseInt(sc.next());
      winner[0][i]=P[i];
    }
    int len=1 ;
    for(int i=0 ; i<N ; i++,len*=2){
      for(int j=0 ; j<M ; j++){
        int p1=winner[i][j];
        int p2=winner[i][(j+len)% M];
        int hi=Math.max(p1,p2);
        int lo=Math.min(p1,p2);
        winner[i+1][j]=winBig[hi-lo-1] ? hi : lo ;
      }
    }
    PrintWriter writer=new PrintWriter(System.out);
    for(int i=0 ; i<M ; i++){
      writer.println(winner[N][i]);
    }
    writer.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var M : int ; M := (1*(2->pow(N)))->oclAsType(long) ;
    var cs : Sequence(String) ; cs := sc.getCurrent()->characters() ;
    var winBig : Sequence(boolean) ; winBig := Integer.subrange(1,M - 1)->collect(false) ;
        var i : int ; i := 0 ; while i < M - 1 do ( (     winBig[i+1] := cs[i+1] = '1' )  ;     i := i + 1 ) ; 
    var winner : Sequence(Sequence(int)) ; winner := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,M)->collect(0)) ;
    var P : Sequence(int) ; P := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     P[i+1] := (sc.getCurrent())->toInteger() ; 
     winner[0+1][i+1] := P[i+1] )  ;     i := i + 1 ) ; 
    var len : int ; len := 1 ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < M do ( (     var p1 : int ; p1 := winner[i+1][j+1] ;
     var p2 : int ; p2 := winner[i+1][(j + len) mod M+1] ;
    var hi : int ; hi := Set{p1, p2}->max() ;
    var lo : int ; lo := Set{p1, p2}->min() ;
    winner[i + 1+1][j+1] := if winBig[hi - lo - 1+1] then hi else lo endif ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ;     len := len*(2) ) ; 
    var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile["System.out"]) ;
        var i : int ; i := 0 ; while i < M do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double sumOfSeries(int n){
    double res=0.0 ;
    int sum=0,prod=1 ;
    for(int i=1 ; i<=n ; i++){
      sum+=i ;
      prod*=i ;
      res+=((double)sum/prod);
    }
    return res ;
  }
  public static void main(String arg[]){
    int n=4 ;
    System.out.println(sumOfSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumOfSeries( n : int) : double
  pre: true
  post: true
  activity: (     var res : double ; res := 0.0 ;
     var sum : int ; sum := 0 ;
    var prod : int ; prod := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (     sum := sum+(i) ; 
     prod := prod*(i) ; 
     res := res+((sum->oclAsType(double) / prod)) )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(sumOfSeries(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void main(String[] args){
    String str="Mr John Smith   " ;
    str=str.trim();
    str=str.replaceAll("\\s","%20");
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "Mr John Smith   " ;
     str := str->trim() ; 
     str := str.replaceAllMatches("\\s", "%20" ) ; 
     OclFile["System.out"].println(str) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  private static int evaluate(final int[] a,final int k){
    int res=0 ;
    int t ;
    int i ;
    t=1 ;
    for(i=0 ; i<a.length ; ++i){
      if(i>=k)t/=a[i-k];
      t*=a[i];
      res=Math.max(res,t);
    }
    return(res);
  }
  public void run(final java.util.Scanner sc,final java.io.PrintStream out){
    int i,j ;
    for(; ; ){
      int[] a ;
      int n,k ;
      int r1,r2=0 ;
      n=sc.nextInt();
      k=sc.nextInt();
      if(n==0 || k==0)break ;
      a=new int[n];
      for(i=0 ; i<a.length ; ++i)a[i]=sc.nextInt();
      r1=evaluate(a,k);
      for(i=0 ; i<a.length ; ++i)for(j=i+1 ; j<a.length ; ++j){
        int t ;
        t=a[i];
        a[i]=a[j];
        a[j]=t ;
        r2=Math.max(r2,evaluate(a,k));
        t=a[i];
        a[i]=a[j];
        a[j]=t ;
      }
      out.println(r2<r1 ? "NO GAME" : r2-r1);
    }
  }
  public static void main(final String[] args){
(new Main()).run(new java.util.Scanner(System.in),System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation evaluate( a : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     var t : int ;
    var i : int ;
    t := 1 ; 
        i := 0 ; while i < a->size() do ( (     if (i >= k) then     t := t/(a[i - k+1]) ; else skip ; 
     t := t*(a[i+1]) ; 
     res := Set{res, t}->max() )  ;     i := i + 1 ) ; 
    return (res) 
 );
   operation run( sc : Scanner, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
       while true do ( (     var a : Sequence(int) ;
     var n : int ;
    var k : int ;
    var r1 : int ;
    var r2 : int ; r2 := 0 ;
    n := sc.nextInt() ; 
    k := sc.nextInt() ; 
    if (n = 0 or k = 0) then     break else skip ; 
    a := Integer.subrange(1,n)->collect(0) ; 
        i := 0 ; while i < a->size() do (     a[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
    r1 := evaluate(a, k) ; 
        i := 0 ; while i < a->size() do (         j := i + 1 ; while j < a->size() do ( (     var t : int ;
     t := a[i+1] ; 
    a[i+1] := a[j+1] ; 
    a[j+1] := t ; 
    r2 := Set{r2, evaluate(a, k)}->max() ; 
    t := a[i+1] ; 
    a[i+1] := a[j+1] ; 
    a[j+1] := t ; 
 )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    out.println(if r2 < r1 then "NO GAME" else r2 - r1 endif) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(Scanner.newScanner(OclFile["System.in"]), OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.ListIterator ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static long get_max(final int n,int[] array,final int k){
    long cur=1 ;
    for(int i=0 ; i<k ; i++){
      cur*=array[i];
    }
    long max=cur ;
    for(int i=k ; i<n ; i++){
      cur/=array[i-k];
      cur*=array[i];
      max=Math.max(max,cur);
    }
    return max ;
  }
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    while(true){
      final int n=sc.nextInt();
      final int k=sc.nextInt();
      if(n==0 && k==0){
        break ;
      }
      int[] array=new int[n];
      for(int i=0 ; i<n ; i++){
        array[i]=sc.nextInt();
      }
      long def_max=get_max(n,array,k);
      long new_max=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=i+1 ; j<n ; j++){
          int tmp=array[i];
          array[i]=array[j];
          array[j]=tmp ;
          new_max=Math.max(new_max,get_max(n,array,k));
          tmp=array[i];
          array[i]=array[j];
          array[j]=tmp ;
        }
      }
      if(def_max>new_max){
        System.out.println("NO GAME");
      }
      else {
        System.out.println(new_max-def_max);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation get_max( n : int, array : Sequence(int), k : int) : long
  pre: true
  post: true
  activity: (     var cur : long ; cur := 1 ;
         var i : int ; i := 0 ; while i < k do ( (     cur := cur*(array[i+1]) )  ;     i := i + 1 ) ; 
    var max : long ; max := cur ;
        var i : int ; i := k ; while i < n do ( (     cur := cur/(array[i - k+1]) ; 
     cur := cur*(array[i+1]) ; 
     max := Set{max, cur}->max() )  ;     i := i + 1 ) ; 
    return max 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    if (n = 0 & k = 0) then (     break ) else skip ; 
    var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var def_max : long ; def_max := get_max(n, array, k) ;
    var new_max : long ; new_max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var tmp : int ; tmp := array[i+1] ;
     array[i+1] := array[j+1] ; 
    array[j+1] := tmp ; 
    new_max := Set{new_max, get_max(n, array, k)}->max() ; 
    tmp := array[i+1] ; 
    array[i+1] := array[j+1] ; 
    array[j+1] := tmp ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (def_max > new_max) then (     OclFile["System.out"].println("NO GAME") ) else (     OclFile["System.out"].println(new_max - def_max) ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      int n=in.nextInt();
      int k=in.nextInt();
      if((n | k)==0)return ;
      int a[]=new int[n];
      int max=0 ;
      int cmax=0 ;
      for(int i=0 ; i<n ; i++)a[i]=in.nextInt();
      for(int i=0 ; i<n-k+1 ; i++){
        int mul=1 ;
        for(int j=i ; j<i+k ; j++)mul*=a[j];
        max=Math.max(max,mul);
      }
      int ans=-1 ;
      for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++){
        int b[]=a.clone();
        int tmp=b[i];
        b[i]=b[j];
        b[j]=tmp ;
        for(int s=0 ; s<n-k+1 ; s++){
          int mul=1 ;
          for(int t=s ; t<s+k ; t++)mul*=b[t];
          cmax=Math.max(cmax,mul);
        }
        ans=Math.max(ans,cmax-max);
      }
      System.out.println(ans>=0 ? ans : "NO GAME");
    }
  }
  static public void debug(Object...o){
    System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,k)) = 0) then     return else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := 0 ;
    var cmax : int ; cmax := 0 ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - k + 1 do ( (     var mul : int ; mul := 1 ;
         var j : int ; j := i ; while j < i + k do (     mul := mul*(a[j+1]) ;  ;     j := j + 1 ) ; 
     max := Set{max, mul}->max() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -1 ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do ( (     var b : Sequence(int) ; b := a->copy() ;
     var tmp : int ; tmp := b[i+1] ;
    b[i+1] := b[j+1] ; 
    b[j+1] := tmp ; 
        var s : int ; s := 0 ; while s < n - k + 1 do ( (     var mul : int ; mul := 1 ;
         var t : int ; t := s ; while t < s + k do (     mul := mul*(b[t+1]) ;  ;     t := t + 1 ) ; 
     cmax := Set{cmax, mul}->max() )  ;     s := s + 1 ) ; 
    ans := Set{ans, cmax - max}->max() ; 
 )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if ans >= 0 then ans else "NO GAME" endif) ; 
 )  ) );
  static    operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    int mod=(int)1E9+7 ;
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    char[] s=br.readLine().toCharArray();
    long dp[]=new long[13];
    if(s[0]=='?'){
      for(int n=0 ; n<10 ; n++){
        dp[n]=1 ;
      }
    }
    else {
      dp[s[0]-'0']=1 ;
    }
    for(int i=1 ; i<s.length ; i++){
      long[] temp=new long[13];
      for(int r=0 ; r<13 ; r++){
        if(s[i]!='?'){
          int now=s[i]-'0' ;
          temp[(r*10+now)% 13]+=dp[r];
        }
        else {
          for(int now=0 ; now<10 ; now++){
            temp[(r*10+now)% 13]+=dp[r];
          }
        }
      }
      for(int r=0 ; r<13 ; r++){
        dp[r]=temp[r] % mod ;
      }
    }
    System.out.println(dp[5]);
    br.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mod : int ; mod := 1E9->oclAsType(int) + 7 ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var s : Sequence(String) ; s := br.readLine()->characters() ;
    var dp : Sequence(long) ; dp := Integer.subrange(1,13)->collect(0) ;
    if (s[0+1] = '?') then (         var n : int ; n := 0 ; while n < 10 do ( (     dp[n+1] := 1 )  ;     n := n + 1 ) ) else (     dp[s[0+1] - ('0')->char2byte()+1] := 1 ) ;  
        var i : int ; i := 1 ; while i < s->size() do ( (     var temp : Sequence(long) ; temp := Integer.subrange(1,13)->collect(0) ;
         var r : int ; r := 0 ; while r < 13 do ( (     if (s[i+1] /= '?') then (     var now : int ; now := s[i+1] - ('0')->char2byte() ;
     temp[(r * 10 + now) mod 13+1] := temp[(r * 10 + now) mod 13+1]+(dp[r+1]) ) else (         var now : int ; now := 0 ; while now < 10 do ( (     temp[(r * 10 + now) mod 13+1] := temp[(r * 10 + now) mod 13+1]+(dp[r+1]) )  ;     now := now + 1 ) ) )  ;     r := r + 1 ) ; 
         var r : int ; r := 0 ; while r < 13 do ( (     dp[r+1] := temp[r+1] mod mod )  ;     r := r + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[5+1]) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      int k=sc.nextInt();
      if(n==0 && k==0)break ;
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      int max=0 ;
      int temp=1 ;
      for(int p=0 ; p<=n-k ; p++){
        temp=1 ;
        for(int q=0 ; q<k ; q++)temp*=a[p+q];
        max=Math.max(max,temp);
      }
      int maxorigin=max ;
      int maxmax=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=i+1 ; j<n ; j++){
          temp=a[i];
          a[i]=a[j];
          a[j]=temp ;
          max=0 ;
          for(int p=0 ; p<=n-k ; p++){
            temp=1 ;
            for(int q=0 ; q<k ; q++)temp*=a[p+q];
            max=Math.max(max,temp);
          }
          maxmax=Math.max(maxmax,max);
          temp=a[i];
          a[i]=a[j];
          a[j]=temp ;
        }
      }
      System.out.println(maxmax-maxorigin);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    if (n = 0 & k = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var temp : int ; temp := 1 ;
        var p : int ; p := 0 ; while p <= n - k do ( (     temp := 1 ; 
         var q : int ; q := 0 ; while q < k do (     temp := temp*(a[p + q+1]) ;  ;     q := q + 1 ) ; 
     max := Set{max, temp}->max() )  ;     p := p + 1 ) ; 
    var maxorigin : int ; maxorigin := max ;
    var maxmax : int ; maxmax := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     temp := a[i+1] ; 
     a[i+1] := a[j+1] ; 
    a[j+1] := temp ; 
    max := 0 ; 
        var p : int ; p := 0 ; while p <= n - k do ( (     temp := 1 ; 
         var q : int ; q := 0 ; while q < k do (     temp := temp*(a[p + q+1]) ;  ;     q := q + 1 ) ; 
     max := Set{max, temp}->max() )  ;     p := p + 1 ) ; 
    maxmax := Set{maxmax, max}->max() ; 
    temp := a[i+1] ; 
    a[i+1] := a[j+1] ; 
    a[j+1] := temp ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(maxmax - maxorigin) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
import java.awt.geom.*;
import java.io.*;
public class Main {
  static int INF=2<<27 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      int K=sc.nextInt();
      if(n==0 && K==0)break ;
      int[] c=new int[n];
      for(int i=0 ; i<n ; i++){
        c[i]=sc.nextInt();
      }
      int CMax=0 ;
      for(int i=0 ; i<n ; i++){
        if(i+(K-1)>=n)break ;
        int sum=1 ;
        for(int j=0 ; j<K ; j++){
          sum*=c[i+j];
        }
        CMax=Math.max(sum,CMax);
      }
      int AMax=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=i+1 ; j<n ; j++){
          int tmp=c[i];
          c[i]=c[j];
          c[j]=tmp ;
          for(int k=0 ; k<n ; k++){
            if(k+(K-1)>=n)break ;
            int sum=1 ;
            for(int l=0 ; l<K ; l++){
              sum*=c[k+l];
            }
            AMax=Math.max(sum,AMax);
          }
          tmp=c[i];
          c[i]=c[j];
          c[j]=tmp ;
        }
      }
      System.out.println(AMax<CMax ? "NO GAME" : AMax-CMax);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute INF : int := (2*(2->pow(27)))->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    if (n = 0 & K = 0) then     break else skip ; 
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var CMax : int ; CMax := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i + (K - 1) >= n) then     break else skip ; 
     var sum : int ; sum := 1 ;
         var j : int ; j := 0 ; while j < K do ( (     sum := sum*(c[i + j+1]) )  ;     j := j + 1 ) ; 
     CMax := Set{sum, CMax}->max() )  ;     i := i + 1 ) ; 
    var AMax : int ; AMax := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var tmp : int ; tmp := c[i+1] ;
     c[i+1] := c[j+1] ; 
    c[j+1] := tmp ; 
        var k : int ; k := 0 ; while k < n do ( (     if (k + (K - 1) >= n) then     break else skip ; 
     var sum : int ; sum := 1 ;
         var l : int ; l := 0 ; while l < K do ( (     sum := sum*(c[k + l+1]) )  ;     l := l + 1 ) ; 
     AMax := Set{sum, AMax}->max() )  ;     k := k + 1 ) ; 
    tmp := c[i+1] ; 
    c[i+1] := c[j+1] ; 
    c[j+1] := tmp ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if AMax < CMax then "NO GAME" else AMax - CMax endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static void findNonPalinString(char s[]){
    int freq[]=new int[26];
    int flag=0 ;
    for(int i=0 ; i<s.length ; i++){
      if(s[i]!=s[0])flag=1 ;
      freq[s[i]-'a']++;
    }
    if(flag==0)System.out.println("-1");
    else {
      for(int i=0 ; i<26 ; i++)for(int j=0 ; j<freq[i]; j++)System.out.print((char)('a'+i));
    }
  }
  public static void main(String[] args){
    String s="abba" ;
    findNonPalinString(s.toCharArray());
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation findNonPalinString( s : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
     var flag : int ; flag := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s[i+1] /= s[0+1]) then     flag := 1 ; else skip ; 
     freq[s[i+1] - ('a')->char2byte()+1] := freq[s[i+1] - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
     if (flag = 0) then     OclFile["System.out"].println("-1") ; else (         var i : int ; i := 0 ; while i < 26 do (         var j : int ; j := 0 ; while j < freq[i+1] do (     OclFile["System.out"].print(('a' + i)->oclAsType(String)) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abba" ;
     execute findNonPalinString(s->characters()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int k=scanner.nextInt();
    int MOD=1000000007 ;
    HashMap<Integer,List<Integer>>map=new HashMap<>();
    int[][] dp=new int[k+1][n+1];
    for(int i=1 ; i<=2000 ; i++){
      map.put(i,pre(i));
    }
    dp[0][0]=1 ;
    for(int i=1 ; i<=n ; i++){
      dp[1][i]=1 ;
    }
    for(int i=2 ; i<=k ; i++){
      for(int j=1 ; j<=n ; j++){
        List<Integer>list=map.get(j);
        for(int p=0 ; p<list.size(); p++){
          dp[i][j]=(dp[i][j]+dp[i-1][list.get(p)])% MOD ;
        }
      }
    }
    int ans=0 ;
    for(int i=1 ; i<=n ; i++){
      ans=(ans+dp[k][i])% MOD ;
    }
    System.out.println(ans);
  }
  static List<Integer>pre(int n){
    List<Integer>list=new ArrayList<>();
    for(int i=1 ; i<=n ; i++){
      if(n % i==0){
        list.add(i);
      }
    }
    return list ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
    var MOD : int ; MOD := 1000000007 ;
    var map : Map(int,Sequence(int)) ; map := Map{} ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,k + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= 2000 do ( (     map := map->union(Map{i |-> pre(i)}) )  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do ( (     dp[1+1][i+1] := 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= k do ( (         var j : int ; j := 1 ; while j <= n do ( (     var list : Sequence(int) ; list := map->at(j) ;
         var p : int ; p := 0 ; while p < list->size() do ( (     dp[i+1][j+1] := (dp[i+1][j+1] + dp[i - 1+1][list->at(p+1)+1]) mod MOD )  ;     p := p + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     ans := (ans + dp[k+1][i+1]) mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation pre( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
         var i : int ; i := 1 ; while i <= n do ( (     if (n mod i = 0) then (     list := list->including(i) ) else skip )  ;     i := i + 1 ) ; 
     return list );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class CF414B {
  public static Scanner scanner ;
  public static int MOD=1000000007 ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int k=scanner.nextInt();
    long[] dp=new long[n+1];
    for(int i=1 ; i<dp.length ; i++)dp[i]=1 ;
    for(int i=0 ; i<k-1 ; i++){
      for(int j=1 ; j<=n ; j++){
        long sum=0 ;
        for(int a=j ; a<=n ; a+=j){
          sum=(sum+dp[a])% MOD ;
        }
        dp[j]=sum ;
      }
    }
    long sum=0 ;
    for(int i=0 ; i<dp.length ; i++){
      sum=(sum+dp[i])% MOD ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF414B {
  static   attribute scanner : OclFile;
  static   attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
    var dp : Sequence(long) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i < dp->size() do (     dp[i+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k - 1 do ( (         var j : int ; j := 1 ; while j <= n do ( (     var sum : long ; sum := 0 ;
         var a : int ; a := j ; while a <= n do ( (     sum := (sum + dp[a+1]) mod MOD )  ;     a := a+(j) ) ; 
     dp[j+1] := sum )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < dp->size() do ( (     sum := (sum + dp[i+1]) mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Solution {
  static StringBuffer str=new StringBuffer();
  static BufferedReader bf ;
  static PrintWriter pw ;
  static int n,k ;
  static long mod=(long)1e9+7 ;
  static long dp[][];
  static void solve(int te)throws Exception {
    long dp[][]=new long[2][n+1];
    for(int i=1 ; i<=n ; i++)dp[1][i]=1 ;
    for(int x=2 ; x<=k ; x++){
      for(int i=1 ; i<=n ; i++){
        for(int j=i ; j<=n ; j+=i){
          dp[0][j]=((dp[0][j]+dp[1][i])% mod+mod)% mod ;
        }
      }
      for(int i=0 ; i<=n ; i++){
        dp[1][i]=dp[0][i];
        dp[0][i]=0 ;
      }
    }
    long ans=0 ;
    for(int i=1 ; i<=n ; i++){
      ans=((ans+dp[1][i])% mod+mod)% mod ;
    }
    str.append(ans).append("\n");
  }
  public static void main(String[] args)throws java.lang.Exception {
    boolean lenv=false ;
    int te=1 ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    String s[]=bf.readLine().trim().split("\\s+");
    n=Integer.parseInt(s[0]);
    k=Integer.parseInt(s[1]);
    solve(te);
    pw.print(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute str : String := StringLib.newString();
  static   attribute bf : OclFile;
  static   attribute pw : OclFile;
  static   attribute n : int;
  static   attribute mod : long := 1e9->oclAsType(long) + 7;
  static   attribute dp : Sequence(Sequence(long));
  static   operation solve( te : int) : void
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
         var i : int ; i := 1 ; while i <= n do (     dp[1+1][i+1] := 1 ;  ;     i := i + 1 ) ; 
        var x : int ; x := 2 ; while x <= k do ( (         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i ; while j <= n do ( (     dp[0+1][j+1] := ((dp[0+1][j+1] + dp[1+1][i+1]) mod mod + mod) mod mod )  ;     j := j+(i) ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i <= n do ( (     dp[1+1][i+1] := dp[0+1][i+1] ; 
     dp[0+1][i+1] := 0 )  ;     i := i + 1 ) )  ;     x := x + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     ans := ((ans + dp[1+1][i+1]) mod mod + mod) mod mod )  ;     i := i + 1 ) ; 
    str := str + StringLib.newString(ans) + StringLib.newString("\n") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var lenv : boolean ; lenv := false ;
     var te : int ; te := 1 ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var s : Sequence(String) ; s := bf.readLine()->trim()->split("\\s+") ;
    n := (s[0+1])->toInteger() ; 
    k := (s[1+1])->toInteger() ; 
    execute solve(te) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class nonsub {
  public static int gcd(int a,int b){
    if(b==0)return a ;
    else return gcd(b,a % b);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t,n,j,i,k,m ;
    t=sc.nextInt();
    for(j=1 ; j<=t ; j++){
      n=sc.nextInt();
      List<Integer>ll=new ArrayList<>();
      m=1 ;
      while(ll.size()<n){
        ll.clear();
        m++;
        for(i=m ; i<=4*n ; i++){
          for(k=0 ; k<ll.size(); k++){
            if(i % ll.get(k)==0 || gcd(i,ll.get(k))==1)break ;
          }
          if(k==ll.size())ll.add(i);
          if(ll.size()==n)break ;
        }
      }
      for(i=0 ; i<ll.size(); i++)System.out.print(ll.get(i)+" ");
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class nonsub {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else     return gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ;
    var n : int ;
    var j : int ;
    var i : int ;
    var k : int ;
    var m : int ;
     t := sc.getCurrent()->toInteger() ; 
         j := 1 ; while j <= t do ( (     n := sc.getCurrent()->toInteger() ; 
     var ll : Sequence(int) ; ll := Sequence{} ;
    m := 1 ; 
    while (ll->size() < n) do (     ll := ll->intersection(Set{}) ; 
     m := m + 1 ; 
         i := m ; while i <= 4 * n do ( (         k := 0 ; while k < ll->size() do ( (     if (i mod ll->at(k+1) = 0 or gcd(i, ll->at(k+1)) = 1) then     break else skip )  ;     k := k + 1 ) ; 
     if (k = ll->size()) then     ll := ll->including(i) ; else skip ; 
     if (ll->size() = n) then     break else skip )  ;     i := i + 1 ) ) ; 
        i := 0 ; while i < ll->size() do (     OclFile["System.out"].print(ll->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    sc.nextLine();
    while(t-->0){
      int n=sc.nextInt();
      for(int i=2*n ; i<4*n ; i+=2)System.out.print(i+" ");
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     skip ; 
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 2 * n ; while i < 4 * n do (     OclFile["System.out"].print(i + " ") ;  ;     i := i+(2) ) ; 
     OclFile["System.out"].println() ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Question1 {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int test=s.nextInt();
    for(int i=0 ; i<test ; i++){
      int n=s.nextInt();
      ArrayList<Integer>arr=new ArrayList<>(n);
      for(int j=1 ; j<=(n); j++){
        arr.add(4*n-(2*(j-1)));
      }
      for(int k=0 ; k<arr.size(); k++){
        System.out.print(arr.get(k)+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Question1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := s.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < test do ( (     var n : int ; n := s.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Sequence{} ;
        var j : int ; j := 1 ; while j <= (n) do ( (     arr := arr->including(4 * n - (2 * (j - 1))) )  ;     j := j + 1 ) ; 
        var k : int ; k := 0 ; while k < arr->size() do ( (     OclFile["System.out"].print(arr->at(k+1) + " ") )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    String S=stdIn.next();
    int dp[][]=new int[S.length()+5][13];
    dp[0][0]=1 ;
    int z=0 ;
    while(z<S.length()){
      char a=S.charAt(z);
      int y=0,ki=0 ;
      if(a=='?'){
        while(y<10){
          while(ki<13){
            dp[z+1][(ki*10+y)% 13]+=dp[z][ki];
            dp[z+1][(ki*10+y)% 13] %=1000000007 ;
            ki++;
          }
          ki=0 ;
          y++;
        }
        y=0 ;
      }
      else {
        y=a-'0' ;
        while(ki<13){
          dp[z+1][(ki*10+y)% 13]+=dp[z][ki];
          dp[z+1][(ki*10+y)% 13] %=1000000007 ;
          ki++;
        }
        ki=0 ;
      }
      z++;
    }
    System.out.println(dp[S.length()][5]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := stdIn.getCurrent() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,S->size() + 5)->collect(Integer.subrange(1,13)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
    var z : int ; z := 0 ;
    while (z < S->size()) do (     var a : String ; a := S->at(z+1) ;
     var y : int ; y := 0 ;
    var ki : int ; ki := 0 ;
     if (a = '?') then (     while (y < 10) do (     while (ki < 13) do (     dp[z + 1+1][(ki * 10 + y) mod 13+1] := dp[z + 1+1][(ki * 10 + y) mod 13+1]+(dp[z+1][ki+1]) ; 
     dp[z + 1+1][(ki * 10 + y) mod 13+1] := dp[z + 1+1][(ki * 10 + y) mod 13+1] mod 1000000007 ; 
     ki := ki + 1 ) ; 
     ki := 0 ; 
     y := y + 1 ) ; 
     y := 0 ) else (     y := (a)->char2byte() - ('0')->char2byte() ; 
     while (ki < 13) do (     dp[z + 1+1][(ki * 10 + y) mod 13+1] := dp[z + 1+1][(ki * 10 + y) mod 13+1]+(dp[z+1][ki+1]) ; 
     dp[z + 1+1][(ki * 10 + y) mod 13+1] := dp[z + 1+1][(ki * 10 + y) mod 13+1] mod 1000000007 ; 
     ki := ki + 1 ) ; 
     ki := 0 ) ;  
     z := z + 1 ) ; 
    OclFile["System.out"].println(dp[S->size()+1][5+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication75 {
  public static void main(String[] args){
    Scanner read=new Scanner(System.in);
    int t=read.nextInt();
    while(t-->0){
      int n=read.nextInt();
      for(int i=n*4 ; i>=n*2 && n!=0 ; i-=2){
        System.out.print(i+" ");
        n--;
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication75 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : OclFile ; read := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := read.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := read.getCurrent()->toInteger() ;
         var i : int ; i := n * 4 ; while i >= n * 2 & n /= 0 do ( (     OclFile["System.out"].print(i + " ") ; 
     n := n - 1 )  ;     i := i-(2) ) ; 
     OclFile["System.out"].println() ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean checkOrigin(int x1,int y1,int x2,int y2){
    return(x1*(y2-y1)==y1*(x2-x1));
  }
  public static void main(String[] args){
    if(checkOrigin(1,28,2,56)==true)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkOrigin( x1 : int, y1 : int, x2 : int, y2 : int) : boolean
  pre: true
  post: true
  activity: (     return (x1 * (y2 - y1) = y1 * (x2 - x1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (checkOrigin(1, 28, 2, 56) = true) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static double maxAvgSubArray(int a[],int n,int x,int y){
    int prefix[]=new int[n];
    prefix[0]=a[0];
    for(int i=1 ; i<n ; i++)prefix[i]=prefix[i-1]+a[i];
    double maximum=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+x-1 ; j<i+y && j<n ; j++){
        double sum=prefix[j];
        if(i>0)sum-=prefix[i-1];
        double current=sum/(double)(j-i+1);
        maximum=Math.max(maximum,current);
      }
    }
    return maximum ;
  }
  public static void main(String[] args){
    int a[]={
      6,7,8,3,2,4,2 };
      int X=2,Y=4 ;
      int n=a.length ;
      System.out.println(maxAvgSubArray(a,n,X,Y));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation maxAvgSubArray( a : Sequence(int), n : int, x : int, y : int) : double
  pre: true
  post: true
  activity: (     var prefix : Sequence(int) ; prefix := Integer.subrange(1,n)->collect(0) ;
     prefix[0+1] := a[0+1] ; 
        var i : int ; i := 1 ; while i < n do (     prefix[i+1] := prefix[i - 1+1] + a[i+1] ;  ;     i := i + 1 ) ; 
    var maximum : double ; maximum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + x - 1 ; while j < i + y & j < n do ( (     var sum : double ; sum := prefix[j+1] ;
     if (i > 0) then     sum := sum-(prefix[i - 1+1]) ; else skip ; 
     var current : double ; current := sum / (j - i + 1)->oclAsType(double) ;
     maximum := Set{maximum, current}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return maximum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{6,7,8,3,2,4,2} ;
     var X : int ; X := 2 ;
    var Y : int ; Y := 4 ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(maxAvgSubArray(a, n, X, Y)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.reflect.Array ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    StringTokenizer st=new StringTokenizer(f.readLine());
    int n=Integer.parseInt(st.nextToken());
    int m=Integer.parseInt(st.nextToken());
    int k=Integer.parseInt(st.nextToken());
    out.println(m*(m-1)/2);
    for(int i=1 ; i<=m ; i++){
      for(int j=i+1 ; j<=m ; j++){
        if(k>0){
          out.println(j+" "+i);
        }
        else {
          out.println(i+" "+j);
        }
      }
    }
    f.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var k : int ; k := (st.next())->toInteger() ;
    skip ; 
        var i : int ; i := 1 ; while i <= m do ( (         var j : int ; j := i + 1 ; while j <= m do ( (     if (k > 0) then (     skip ) else (     skip ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class B384 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int M=in.nextInt();
    int K=in.nextInt();
    List<Point>list=new ArrayList<>();
    for(int from=1 ; from<M ; from++){
      for(int to=from+1 ; to<=M ; to++){
        list.add((K==0)? new Point(from,to): new Point(to,from));
      }
    }
    StringBuilder out=new StringBuilder();
    out.append(list.size());
    for(Point p : list){
      out.append('\n').append(p.x).append(' ').append(p.y);
    }
    System.out.println(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B384 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var M : int ; M := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    var list : Sequence(Point) ; list := Sequence{} ;
        var from : int ; from := 1 ; while from < M do ( (         var to : int ; to := from + 1 ; while to <= M do ( (     list := list->including(if (K = 0) then Point.newPoint(from, to) else Point.newPoint(to, from) endif) )  ;     to := to + 1 ) )  ;     from := from + 1 ) ; 
    var out : String ; out := StringLib.newString() ;
    out := out + StringLib.newString(list->size()) ; 
    for (p : list) do ( (     out := out + StringLib.newString('
') + StringLib.newString(p.x) + StringLib.newString(' ') + StringLib.newString(p.y) )  ) ; 
    OclFile["System.out"].println(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    File f1=new File("input.txt");
    File f2=new File("output.txt");
    Scanner input=new Scanner(f1);
    PrintWriter output=new PrintWriter(f2);
    int n=input.nextInt();
    String s=input.next();
    char ch[]=s.toCharArray();
    int L=0 ;
    int R=0 ;
    for(int i=0,j=s.length()/2 ; i<s.length()/2 ; i++,j++){
      if(ch[i]=='L' && ch[j]=='L'){
        output.println((i+1)+" "+(j+1));
      }
      else if(ch[i]=='L' && ch[j]=='R'){
        output.println((i+1)+" "+(j+1));
      }
      else if(ch[i]=='R' && ch[j]=='R'){
        output.println((i+1)+" "+(j+1));
      }
      else {
        output.println((j+1)+" "+(i+1));
      }
    }
    output.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f1 : OclFile ; f1 := OclFile("input.txt") ;
     var f2 : OclFile ; f2 := OclFile("output.txt") ;
    var input : OclFile ; input := OclFile.newOclFile_Read(f1) ;
    var output : OclFile ; output := OclFile.newOclFile_Write(f2) ;
    var n : int ; n := input.getCurrent()->toInteger() ;
    var s : String ; s := input.getCurrent() ;
    var ch : Sequence(String) ; ch := s->characters() ;
    var L : int ; L := 0 ;
    var R : int ; R := 0 ;
        var i : int ; i := 0 ;
    var j : int ; j := s->size() / 2 ; while i < s->size() / 2 do ( (     if (ch[i+1] = 'L' & ch[j+1] = 'L') then (     skip ) else     if (ch[i+1] = 'L' & ch[j+1] = 'R') then (     skip ) else     if (ch[i+1] = 'R' & ch[j+1] = 'R') then (     skip ) else (     skip ) ;  ;  )  ;     i := i + 1 ;     j := j + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1062 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    if(N==1){
      System.out.println("1 0");
      return ;
    }
    int maxPower=0 ;
    int base=1 ;
    int origN=N ;
    int min=1 ;
    for(int d=2 ; d<=1000 ; d++){
      int power=0 ;
      while(N % d==0){
        power++;
        N/=d ;
      }
      if(power>maxPower){
        maxPower=power ;
        base=d ;
      }
      else if(power==maxPower){
        base*=d ;
      }
      if(power!=0){
        min*=d ;
      }
    }
    if(N!=1){
      if(1>maxPower){
        maxPower=1 ;
        base=N ;
      }
      else if(1==maxPower){
        base*=N ;
      }
      min*=N ;
    }
    int sqrts=0 ;
    int p=1 ;
    while(p<maxPower){
      sqrts++;
      p*=2 ;
    }
    boolean sqrtOnly=false ;
    if(Integer.bitCount(maxPower)==1){
      long newN=1 ;
      for(int i=0 ; i<maxPower ; i++){
        newN*=base ;
      }
      sqrtOnly=(newN==origN);
    }
    int ops=sqrts+(sqrtOnly ? 0 : 1);
    System.out.println(min+" "+ops);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1062 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    if (N = 1) then (     OclFile["System.out"].println("1 0") ; 
     return ) else skip ; 
    var maxPower : int ; maxPower := 0 ;
    var base : int ; base := 1 ;
    var origN : int ; origN := N ;
    var min : int ; min := 1 ;
        var d : int ; d := 2 ; while d <= 1000 do ( (     var power : int ; power := 0 ;
     while (N mod d = 0) do (     power := power + 1 ; 
     N := N/(d) ) ; 
     if (power > maxPower) then (     maxPower := power ; 
     base := d ) else     if (power = maxPower) then (     base := base*(d) ) else skip ; ;  
     if (power /= 0) then (     min := min*(d) ) else skip )  ;     d := d + 1 ) ; 
    if (N /= 1) then (     if (1 > maxPower) then (     maxPower := 1 ; 
     base := N ) else     if (1 = maxPower) then (     base := base*(N) ) else skip ; ;  
     min := min*(N) ) else skip ; 
    var sqrts : int ; sqrts := 0 ;
    var p : int ; p := 1 ;
    while (p < maxPower) do (     sqrts := sqrts + 1 ; 
     p := p*(2) ) ; 
    var sqrtOnly : boolean ; sqrtOnly := false ;
    if (bitCount(maxPower) = 1) then (     var newN : long ; newN := 1 ;
         var i : int ; i := 0 ; while i < maxPower do ( (     newN := newN*(base) )  ;     i := i + 1 ) ; 
     sqrtOnly := (newN = origN) ) else skip ; 
    var ops : int ; ops := sqrts + (if sqrtOnly then 0 else 1 endif) ;
    OclFile["System.out"].println(min + " " + ops) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findPair(int arr[],int n){
    if(n<2){
      System.out.print("-1");
      return ;
    }
    int maximum=arr[0];
    for(int i=1 ; i<n ; i++)maximum=Math.max(maximum,arr[i]);
    int temp=10000001,r=0,middle=maximum/2 ;
    for(int i=0 ; i<n ; i++){
      if(Math.abs(middle-arr[i])<temp && n % 2==0){
        temp=Math.abs(middle-arr[i]);
        r=arr[i];
      }
      else if(Math.min(Math.abs(middle-arr[i]),Math.abs(middle+1-arr[i]))<temp && n % 2==1){
        temp=Math.min(Math.abs(middle-arr[i]),Math.abs(middle+1-arr[i]));
        r=arr[i];
      }
    }
    System.out.print("n="+maximum+" and r="+r);
  }
  public static void main(String args[]){
    int arr[]={
      0,2,3,4,1,6,8,9 };
      int n=arr.length ;
      findPair(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findPair( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     if (n < 2) then (     OclFile["System.out"].print("-1") ; 
     return ) else skip ; 
     var maximum : int ; maximum := arr[0+1] ;
        var i : int ; i := 1 ; while i < n do (     maximum := Set{maximum, arr[i+1]}->max() ;  ;     i := i + 1 ) ; 
    var temp : int ; temp := 10000001 ;
    var r : int ; r := 0 ;
    var middle : int ; middle := maximum / 2 ;
        var i : int ; i := 0 ; while i < n do ( (     if (if middle - arr[i+1] < 0 then -(middle - arr[i+1]) else middle - arr[i+1] endif < temp & n mod 2 = 0) then (     temp := if middle - arr[i+1] < 0 then -(middle - arr[i+1]) else middle - arr[i+1] endif ; 
     r := arr[i+1] ) else     if (Set{if middle - arr[i+1] < 0 then -(middle - arr[i+1]) else middle - arr[i+1] endif, if middle + 1 - arr[i+1] < 0 then -(middle + 1 - arr[i+1]) else middle + 1 - arr[i+1] endif}->min() < temp & n mod 2 = 1) then (     temp := Set{if middle - arr[i+1] < 0 then -(middle - arr[i+1]) else middle - arr[i+1] endif, if middle + 1 - arr[i+1] < 0 then -(middle + 1 - arr[i+1]) else middle + 1 - arr[i+1] endif}->min() ; 
     r := arr[i+1] ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("n=" + maximum + " and r=" + r) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,2,3,4,1,6,8,9} ;
     var n : int ; n := arr->size() ;
     execute findPair(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countPairs(int s,int K){
    if(K>s ||(s-K)% 2==1){
      return 0 ;
    }
    if((s-K)/2==1 & K==1){
      return 0 ;
    }
    int setBits=__builtin_popcount(K);
    int pairsCount=(int)Math.pow(2,setBits);
    if(s==K){
      pairsCount-=2 ;
    }
    return pairsCount ;
  }
  static int __builtin_popcount(int n){
    int count=0 ;
    while(n>0){
      count+=n & 1 ;
      n>>=1 ;
    }
    return count ;
  }
  public static void main(String[] args){
    int s=9,K=5 ;
    System.out.println(countPairs(s,K));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countPairs( s : int, K : int) : int
  pre: true
  post: true
  activity: (     if (K > s or (s - K) mod 2 = 1) then (     return 0 ) else skip ; 
     if ((s - K) / 2 = 1 & K = 1) then (     return 0 ) else skip ; 
    var setBits : int ; setBits := __builtin_popcount(K) ;
    var pairsCount : int ; pairsCount := 2->pow(setBits)->oclAsType(int) ;
    if (s = K) then (     pairsCount := pairsCount-(2) ) else skip ; 
    return pairsCount 
 );
  static   operation __builtin_popcount( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     count := count+(n & 1) ; 
     n := n/(2->pow(1)) ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : int ; s := 9 ;
    var K : int ; K := 5 ;
     OclFile["System.out"].println(countPairs(s, K)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static final int N=3 ;
  static void scalarProductMat(int mat[][],int k){
    for(int i=0 ; i<N ; i++)for(int j=0 ; j<N ; j++)mat[i][j]=mat[i][j]*k ;
  }
  public static void main(String[] args){
    int mat[][]={
      {
        1,2,3 },{
          4,5,6 },{
            7,8,9 }
          };
          int k=4 ;
          scalarProductMat(mat,k);
          System.out.println("Scalar Product Matrix is : ");
          for(int i=0 ; i<N ; i++){
            for(int j=0 ; j<N ; j++)System.out.print(mat[i][j]+" ");
            System.out.println();
          }
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute N : int := 3;
  static   operation scalarProductMat( mat : Sequence(Sequence(int)), k : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do (         var j : int ; j := 0 ; while j < N do (     mat[i+1][j+1] := mat[i+1][j+1] * k ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,2,3},Sequence{4,5,6},Sequence{7,8,9}} ;
     var k : int ; k := 4 ;
    execute scalarProductMat(mat, k) ; 
    OclFile["System.out"].println("Scalar Product Matrix is : ") ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do (     OclFile["System.out"].print(mat[i+1][j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    new Main().run();
  }
  final long MOD=(long)1e9+7 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    char[] cs=sc.next().toCharArray();
    long[][] dp=new long[cs.length][13];
    int base=1 ;
    for(int i=0 ; i<cs.length ; ++i){
      if(cs[cs.length-1-i]=='?'){
        for(int pre=0 ; pre<13 ; ++pre){
          for(int next=0 ; next<10 ; ++next){
            dp[i][(base*next+pre)% 13]+=(i>0 ? dp[i-1][pre] :(pre==0 ? 1 : 0));
            dp[i][(base*next+pre)% 13] %=MOD ;
          }
        }
      }
      else {
        int next=cs[cs.length-1-i]-'0' ;
        for(int pre=0 ; pre<13 ; ++pre){
          dp[i][(base*next+pre)% 13]+=(i>0 ? dp[i-1][pre] :(pre==0 ? 1 : 0));
          dp[i][(base*next+pre)% 13] %=MOD ;
        }
      }
      base=base*10 % 13 ;
    }
    System.out.println(dp[dp.length-1][5]);
  }
  void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute MOD : long := 1e9->oclAsType(long) + 7;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cs : Sequence(String) ; cs := sc.getCurrent()->characters() ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,cs->size())->collect(Integer.subrange(1,13)->collect(0)) ;
    var base : int ; base := 1 ;
        var i : int ; i := 0 ; while i < cs->size() do ( (     if (cs[cs->size() - 1 - i+1] = '?') then (         var pre : int ; pre := 0 ; while pre < 13 do ( (         var next : int ; next := 0 ; while next < 10 do ( (     dp[i+1][(base * next + pre) mod 13+1] := dp[i+1][(base * next + pre) mod 13+1]+((if i > 0 then dp[i - 1+1][pre+1] else (if pre = 0 then 1 else 0 endif) endif)) ; 
     dp[i+1][(base * next + pre) mod 13+1] := dp[i+1][(base * next + pre) mod 13+1] mod MOD )  ;     next := next + 1 ) )  ;     pre := pre + 1 ) ) else (     var next : int ; next := cs[cs->size() - 1 - i+1] - ('0')->char2byte() ;
         var pre : int ; pre := 0 ; while pre < 13 do ( (     dp[i+1][(base * next + pre) mod 13+1] := dp[i+1][(base * next + pre) mod 13+1]+((if i > 0 then dp[i - 1+1][pre+1] else (if pre = 0 then 1 else 0 endif) endif)) ; 
     dp[i+1][(base * next + pre) mod 13+1] := dp[i+1][(base * next + pre) mod 13+1] mod MOD )  ;     pre := pre + 1 ) ) ;  
     base := base * 10 mod 13 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[dp->size() - 1+1][5+1]) ; 
 );
   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] prices=new int[4];
    for(int i=0 ; i<4 ; i++){
      prices[i]=sc.nextInt();
    }
    int[] counts=new int[4];
    for(int i=0 ; i<4 ; i++){
      counts[i]=sc.nextInt();
    }
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; ; i++){
      int x=i*counts[0];
      for(int j=0 ; ; j++){
        int y=x+j*counts[1];
        for(int k=0 ; ; k++){
          int z=y+k*counts[2];
          int l=0 ;
          if(z<n){
            l=(n-z+counts[3]-1)/counts[3];
          }
          min=Math.min(min,i*prices[0]+j*prices[1]+k*prices[2]+l*prices[3]);
          if(z>=n){
            break ;
          }
        }
        if(y>=n){
          break ;
        }
      }
      if(x>=n){
        break ;
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var prices : Sequence(int) ; prices := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     prices[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var counts : Sequence(int) ; counts := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     counts[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while true do ( (     var x : int ; x := i * counts[0+1] ;
         var j : int ; j := 0 ; while true do ( (     var y : int ; y := x + j * counts[1+1] ;
         var k : int ; k := 0 ; while true do ( (     var z : int ; z := y + k * counts[2+1] ;
     var l : int ; l := 0 ;
    if (z < n) then (     l := (n - z + counts[3+1] - 1) / counts[3+1] ) else skip ; 
    min := Set{min, i * prices[0+1] + j * prices[1+1] + k * prices[2+1] + l * prices[3+1]}->min() ; 
    if (z >= n) then (     break ) else skip ; 
 )  ;     k := k + 1 ) ; 
     if (y >= n) then (     break ) else skip )  ;     j := j + 1 ) ; 
     if (x >= n) then (     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    int[] P=new int[4];
    int[] T=new int[4];
    for(int i=0 ; i<4 ; i++){
      P[i]=sc.nextInt();
    }
    for(int i=0 ; i<4 ; i++){
      T[i]=sc.nextInt();
    }
    int[] dp=new int[201];
    Arrays.fill(dp,200000);
    dp[0]=0 ;
    for(int i=0 ; i<4 ; i++){
      for(int j=0 ; j+T[i]<dp.length ; j++){
        dp[j+T[i] ]=Math.min(dp[j+T[i] ],dp[j]+P[i]);
      }
    }
    int ans=Integer.MAX_VALUE ;
    for(int i=N ; i<dp.length ; i++){
      ans=Math.min(ans,dp[i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var P : Sequence(int) ; P := Integer.subrange(1,4)->collect(0) ;
    var T : Sequence(int) ; T := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     P[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 4 do ( (     T[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,201)->collect(0) ;
    dp := dp->collect(200000) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j + T[i+1] < dp->size() do ( (     dp[j + T[i+1]+1] := Set{dp[j + T[i+1]+1], dp[j+1] + P[i+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := N ; while i < dp->size() do ( (     ans := Set{ans, dp[i+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s,s2 ;
    int n,de=0 ;
    s=in.next();
    n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      s2=in.next();
      int ln=2*s2.length();
      s2=s2+s2 ;
      while(ln-->0){
        if(s2.contains(s)){
          de++;
          break ;
        }
      }
    }
    System.out.println(de);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ;
    var s2 : String ;
    var n : int ;
    var de : int ; de := 0 ;
    s := in.getCurrent() ; 
    n := in.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     s2 := in.getCurrent() ; 
     var ln : int ; ln := 2 * s2->size() ;
     s2 := s2 + s2 ; 
         while (ln > 0) do (        ln := ln - 1 ;     skip ; (     if (s2->includes(s)) then (     de := de + 1 ; 
     break ) else skip ) ;  ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(de) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.regex.Matcher ;
import java.util.regex.Pattern ;
public class Main {
  public static final int BIG_NUM=2000000000 ;
  public static final int MOD=1000000007 ;
  public static final long HUGE_NUM=99999999999999999L ;
  public static final double EPS=0.000000001 ;
  public static final int SIZE=21 ;
  @ SuppressWarnings("unchecked")public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String pattern=br.readLine();
      int N=Integer.parseInt(br.readLine());
      int ans=0 ;
      boolean FLG ;
      for(int i=0 ; i<N ; i++){
        String T=br.readLine();
        for(int start=0 ; start<T.length(); start++){
          FLG=true ;
          for(int k=0 ; k<pattern.length(); k++){
            if(T.charAt((start+k)% T.length())!=pattern.charAt(k)){
              FLG=false ;
              break ;
            }
          }
          if(FLG){
            ans+=1 ;
            break ;
          }
        }
      }
      System.out.println(ans);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
class UTIL {
  public static int getNUM(String tmp_str){
    return Integer.parseInt(tmp_str);
  }
  public static boolean isNumber(String tmp_str){
    if(tmp_str==null || tmp_str.length()==0){
      return false ;
    }
    Pattern pattern=Pattern.compile("\\A[0-9]+\\z");
    Matcher matcher=pattern.matcher(tmp_str);
    return matcher.matches();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BIG_NUM : int := 2000000000;
  static    attribute MOD : int := 1000000007;
  static    attribute HUGE_NUM : long := 99999999999999999L;
  static    attribute EPS : double := 0.000000001;
  static    attribute SIZE : int := 21;
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var pattern : String ; pattern := br.readLine() ;
     var N : int ; N := (br.readLine())->toInteger() ;
    var ans : int ; ans := 0 ;
    var FLG : boolean ;
        var i : int ; i := 0 ; while i < N do ( (     var T : String ; T := br.readLine() ;
         var start : int ; start := 0 ; while start < T->size() do ( (     FLG := true ; 
         var k : int ; k := 0 ; while k < pattern->size() do ( (     if (T->at((start + k) mod T->size()+1) /= pattern->at(k+1)) then (     FLG := false ; 
     break ) else skip )  ;     k := k + 1 ) ; 
     if (FLG) then (     ans := ans+(1) ; 
     break ) else skip )  ;     start := start + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}
class UTIL {
  static   operation getNUM( tmp_str : String) : int
  pre: true
  post: true
  activity: (     return (tmp_str)->toInteger() );
  static   operation isNumber( tmp_str : String) : boolean
  pre: true
  post: true
  activity: (     if (tmp_str = null or tmp_str->size() = 0) then (     return false ) else skip ; 
     var pattern : OclRegex ; pattern := OclRegex.compile("\\A[0-9]+\\z") ;
     var matcher : OclRegex ; matcher := pattern.matcher(tmp_str) ;
     return matcher.isMatch() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  Scanner sc=new Scanner(System.in);
  int n ;
  String[] ring ;
  String s ;
  int count ;
  int i,point ;
  void run(){
    while(sc.hasNext()){
      s=sc.next();
      n=sc.nextInt();
      ring=new String[n];
      for(i=0 ; i<n ; i++)ring[i]=sc.next();
      count=0 ;
      solve();
    }
  }
  void solve(){
    for(i=0 ; i<n ; i++)if(search(ring[i]))count++;
    System.out.println(count);
  }
  boolean search(String c){
    point=0 ;
    int start=0 ;
    int m=0 ;
    boolean cont=true ;
    boolean[] flag=new boolean[c.length()];
    Arrays.fill(flag,true);
    boolean now=true ;
    boolean find=false ;
    while(cont){
      boolean tf=s.substring(m,m+1).equals(c.substring(point,point+1));
      if(tf){
        point=(point+1)% 10 ;
        m++;
        if(m>=s.length())find=true ;
      }
      else {
        flag[start]=false ;
        start=(start+1)% 10 ;
        point=start ;
        m=0 ;
      }
      cont=! find && flag[start];
    }
    return find ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute n : int;
   attribute ring : Sequence(String);
   attribute s : String;
   attribute count : int;
   attribute i : int;
   operation run() : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     s := sc.getCurrent() ; 
     n := sc.getCurrent()->toInteger() ; 
    ring := Integer.subrange(1,n)->collect(null) ; 
        i := 0 ; while i < n do (     ring[i+1] := sc.getCurrent() ;  ;     i := i + 1 ) ; 
    count := 0 ; 
    execute solve() ; 
 ) );
   operation solve() : void
  pre: true
  post: true
  activity: (         i := 0 ; while i < n do (     if (search(ring[i+1])) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) );
   operation search( c : String) : boolean
  pre: true
  post: true
  activity: (     point := 0 ; 
     var start : int ; start := 0 ;
    var m : int ; m := 0 ;
    var cont : boolean ; cont := true ;
    var flag : Sequence(boolean) ; flag := Integer.subrange(1,c->size())->collect(false) ;
    flag := flag->collect(true) ; 
    var now : boolean ; now := true ;
    var find : boolean ; find := false ;
    while (cont) do (     var tf : boolean ; tf := s.subrange(m+1,m + 1) = c.subrange(point+1,point + 1) ;
     if (tf) then (     point := (point + 1) mod 10 ; 
     m := m + 1 ; 
     if (m >= s->size()) then     find := true ; else skip ) else (     flag[start+1] := false ; 
     start := (start + 1) mod 10 ; 
     point := start ; 
     m := 0 ) ;  
     cont := not(find) & flag[start+1] ) ; 
    return find 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      char[] word=line.toCharArray();
      int N=Integer.parseInt(br.readLine());
      int count=0 ;
      outer1 : for(int i=0 ;
      i<N ;
      i++){
        char[] ring=br.readLine().toCharArray();
        outer2 : for(int j=0 ;
        j<ring.length+word.length ;
        j++){
          if(ring[j % ring.length]==word[0]){
            for(int k=1 ; k<word.length ; k++){
              if(word[k]!=ring[(j+k)% ring.length]){
                j+=k-1 ;
                continue outer2 ;
              }
            }
            count++;
            continue outer1 ;
          }
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var word : Sequence(String) ; word := line->characters() ;
     var N : int ; N := (br.readLine())->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var ring : Sequence(String) ; ring := br.readLine()->characters() ;
         var j : int ; j := 0 ; while j < ring->size() + word->size() do ( (     if (ring[j mod ring->size()+1] = word[0+1]) then (         var k : int ; k := 1 ; while k < word->size() do ( (     if (word[k+1] /= ring[(j + k) mod ring->size()+1]) then (     j := j+(k - 1) ; 
     continue ) else skip )  ;     k := k + 1 ) ; 
     count := count + 1 ; 
     continue ) else skip )  ;     j := j + 1 ) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    File f1=new File("input.txt");
    File f2=new File("output.txt");
    Scanner input=new Scanner(f1);
    FileWriter output=new FileWriter(f2);
    int n=input.nextInt();
    String s=input.next();
    char ch[]=s.toCharArray();
    int L=0 ;
    int R=0 ;
    for(int i=0,j=s.length()/2 ; i<s.length()/2 ; i++,j++){
      if(ch[i]=='L' && ch[j]=='L'){
        output.write((i+1)+" "+(j+1)+"\n");
      }
      else if(ch[i]=='L' && ch[j]=='R'){
        output.write((i+1)+" "+(j+1)+"\n");
      }
      else if(ch[i]=='R' && ch[j]=='R'){
        output.write((i+1)+" "+(j+1)+"\n");
      }
      else {
        output.write((j+1)+" "+(i+1)+"\n");
      }
    }
    output.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f1 : OclFile ; f1 := OclFile("input.txt") ;
     var f2 : OclFile ; f2 := OclFile("output.txt") ;
    var input : OclFile ; input := OclFile.newOclFile_Read(f1) ;
    var output : OclFile ; output := OclFile.newOclFile_Write(f2) ;
    var n : int ; n := input.getCurrent()->toInteger() ;
    var s : String ; s := input.getCurrent() ;
    var ch : Sequence(String) ; ch := s->characters() ;
    var L : int ; L := 0 ;
    var R : int ; R := 0 ;
        var i : int ; i := 0 ;
    var j : int ; j := s->size() / 2 ; while i < s->size() / 2 do ( (     if (ch[i+1] = 'L' & ch[j+1] = 'L') then (     skip ) else     if (ch[i+1] = 'L' & ch[j+1] = 'R') then (     skip ) else     if (ch[i+1] = 'R' & ch[j+1] = 'R') then (     skip ) else (     skip ) ;  ;  )  ;     i := i + 1 ;     j := j + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    String s=sc.next();
    int n=sc.nextInt();
    int a=0 ;
    for(int i=0 ; i<n ; i++){
      String t=sc.next();
      if((t+t).indexOf(s)>=0){
        a++;
      }
    }
    println(""+a);
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     var s : String ; s := sc.getCurrent() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var t : String ; t := sc.getCurrent() ;
     if ((t + t)->indexOf(s)-1 >= 0) then (     a := a + 1 ) else skip )  ;     i := i + 1 ) ; 
    execute println("" + a) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewClass39 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    int p=1 ;
    while(t-->0){
      int n=in.nextInt();
      int m=in.nextInt();
      if((n<m &&((n+m)% 2==1))||(n>m)&&((n+m)% 2==0)){
        System.out.println("1");
      }
      else if((n<m &&((n+m)% 2==0))||(n>m)&&((n+m)% 2==1)){
        System.out.println("2");
      }
      else {
        System.out.println("0");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass39 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
     var p : int ; p := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
     if ((n < m & ((n + m) mod 2 = 1)) or (n > m) & ((n + m) mod 2 = 0)) then (     OclFile["System.out"].println("1") ) else     if ((n < m & ((n + m) mod 2 = 0)) or (n > m) & ((n + m) mod 2 = 1)) then (     OclFile["System.out"].println("2") ) else (     OclFile["System.out"].println("0") ) ;  ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Fast f=new Fast(System.in);
    int t=f.nextInt();
    while(t--!=0){
      int a=f.nextInt(),b=f.nextInt();
      if(a==b)System.out.println(0);
      else if(a>b){
        if((a-b)% 2==0)System.out.println(1);
        else System.out.println(2);
      }
      else {
        if((b-a)% 2!=0)System.out.println(1);
        else System.out.println(2);
      }
    }
    System.out.flush();
    System.out.close();
  }
}
class Fast {
  StringTokenizer st ;
  BufferedReader br ;
  public Fast(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public Fast(String file)throws IOException {
    br=new BufferedReader(new FileReader(file));
  }
  public Fast(FileReader r){
    br=new BufferedReader(r);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String readAllLines(BufferedReader reader)throws IOException {
    StringBuilder content=new StringBuilder();
    String line ;
    while((line=reader.readLine())!=null){
      content.append(line);
      content.append(System.lineSeparator());
    }
    return content.toString();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public int[] nextIntArray(int n)throws IOException {
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : Fast ; f := Fast.newFast(OclFile["System.in"]) ;
     var t : int ; t := f.nextInt() ;
        while (t /= 0) do (    skip ; (     var a : int ; a := f.nextInt() ;
    var b : int ; b := f.nextInt() ;
     if (a = b) then     OclFile["System.out"].println(0) ; else     if (a > b) then (     if ((a - b) mod 2 = 0) then     OclFile["System.out"].println(1) ; else     OclFile["System.out"].println(2) ; ) else (     if ((b - a) mod 2 /= 0) then     OclFile["System.out"].println(1) ; else     OclFile["System.out"].println(2) ; ) ;  ) ;  ) ;  
    OclFile["System.out"].flush() ; 
    OclFile["System.out"].close() ; 
 );
}
class Fast {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newFast( s : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFast( file : String) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   static operation newFast( r : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(r);
    return self );
  operation initialise( r : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(r) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation readAllLines( reader : OclFile) : String
  pre: true
  post: true
  activity: (     var content : String ; content := StringLib.newString() ;
     var line : String ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     content := content + StringLib.newString(line) ; 
     content := content + StringLib.newString(lineSeparator()) ) ;     line := reader.readLine() ;
 ) ;  
     return content+"" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ATwoProblems solver=new ATwoProblems();
    solver.solve(1,in,out);
    out.close();
  }
  static class ATwoProblems {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int points=in.nextInt();
      int t=in.nextInt();
      int a=in.nextInt();
      int b=in.nextInt();
      int ta=in.nextInt();
      int tb=in.nextInt();
      for(int i=0 ; i<t ; i++){
        for(int j=0 ; j<t ; j++){
          if(points==a-i*ta+b-j*tb ||(points==0)|| points==a-ta*i || points==b-tb*j){
            out.println("YES");
            return ;
          }
        }
      }
      out.println("NO");
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ATwoProblems ; solver := ATwoProblems.newATwoProblems() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ATwoProblems {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var points : int ; points := in.nextInt() ;
     var t : int ; t := in.nextInt() ;
    var a : int ; a := in.nextInt() ;
    var b : int ; b := in.nextInt() ;
    var ta : int ; ta := in.nextInt() ;
    var tb : int ; tb := in.nextInt() ;
        var i : int ; i := 0 ; while i < t do ( (         var j : int ; j := 0 ; while j < t do ( (     if (points = a - i * ta + b - j * tb or (points = 0) or points = a - ta * i or points = b - tb * j) then (     skip ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class pre133 {
  public static void main(String args[]){
    Scanner obj=new Scanner(System.in);
    int tc=obj.nextInt();
    while(tc--!=0){
      int a=obj.nextInt(),b=obj.nextInt(),k=Math.abs(a-b);
      if(k==0){
        System.out.println(0);
        continue ;
      }
      if(a>b){
        if(k % 2==0){
          System.out.println(1);
          continue ;
        }
        else {
          System.out.println(2);
          continue ;
        }
      }
      else {
        if(k % 2==0){
          System.out.println(2);
          continue ;
        }
        else {
          System.out.println(1);
          continue ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre133 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : OclFile ; obj := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := obj.getCurrent()->toInteger() ;
         while (tc /= 0) do (    skip ; (     var a : int ; a := obj.getCurrent()->toInteger() ;
    var b : int ; b := obj.getCurrent()->toInteger() ;
    var k : int ; k := if a - b < 0 then -(a - b) else a - b endif ;
     if (k = 0) then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
     if (a > b) then (     if (k mod 2 = 0) then (     OclFile["System.out"].println(1) ; 
     continue ) else (     OclFile["System.out"].println(2) ; 
     continue ) ) else (     if (k mod 2 = 0) then (     OclFile["System.out"].println(2) ; 
     continue ) else (     OclFile["System.out"].println(1) ; 
     continue ) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class AddOddOrSubtractEven {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    int[] out=new int[T];
    for(int i=0 ; i<T ; i++){
      int A,B ;
      A=sc.nextInt();
      B=sc.nextInt();
      int diff=A-B ;
      if(diff<0)out[i]=(Math.abs(diff)% 2==0)? 2 : 1 ;
      else if(diff>0)out[i]=(diff % 2==0)? 1 : 2 ;
      else out[i]=0 ;
    }
    for(int j=0 ; j<T ; j++)System.out.println(out[j]);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class AddOddOrSubtractEven {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
    var out : Sequence(int) ; out := Integer.subrange(1,T)->collect(0) ;
        var i : int ; i := 0 ; while i < T do ( (     var A : int ;
    var B : int ;
     A := sc.getCurrent()->toInteger() ; 
    B := sc.getCurrent()->toInteger() ; 
    var diff : int ; diff := A - B ;
    if (diff < 0) then     out[i+1] := if (if diff < 0 then -(diff) else diff endif mod 2 = 0) then 2 else 1 endif else     if (diff > 0) then     out[i+1] := if (diff mod 2 = 0) then 1 else 2 endif else     out[i+1] := 0 ; ;  ;  
 )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < T do (     OclFile["System.out"].println(out[j+1]) ;  ;     j := j + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Fast f=new Fast(System.in);
    int t=f.nextInt();
    while(t--!=0){
      int n=f.nextInt();
      String s=f.next();
      if(s.contains("T")&& s.contains("i")&& s.contains("m")&& s.contains("u")&& s.contains("r")&& s.length()==5)System.out.println("YES");
      else System.out.println("NO");
    }
    System.out.flush();
    System.out.close();
  }
}
class Fast {
  StringTokenizer st ;
  BufferedReader br ;
  public Fast(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public Fast(String file)throws IOException {
    br=new BufferedReader(new FileReader(file));
  }
  public Fast(FileReader r){
    br=new BufferedReader(r);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String readAllLines(BufferedReader reader)throws IOException {
    StringBuilder content=new StringBuilder();
    String line ;
    while((line=reader.readLine())!=null){
      content.append(line);
      content.append(System.lineSeparator());
    }
    return content.toString();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public int[] nextIntArray(int n)throws IOException {
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : Fast ; f := Fast.newFast(OclFile["System.in"]) ;
     var t : int ; t := f.nextInt() ;
        while (t /= 0) do (    skip ; (     var n : int ; n := f.nextInt() ;
     var s : String ; s := f.next() ;
     if (s->includes("T") & s->includes("i") & s->includes("m") & s->includes("u") & s->includes("r") & s->size() = 5) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) ;  ) ;  
    OclFile["System.out"].flush() ; 
    OclFile["System.out"].close() ; 
 );
}
class Fast {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newFast( s : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(s))) );
   static operation newFast( file : String) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   static operation newFast( r : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(r);
    return self );
  operation initialise( r : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(r) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation readAllLines( reader : OclFile) : String
  pre: true
  post: true
  activity: (     var content : String ; content := StringLib.newString() ;
     var line : String ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     content := content + StringLib.newString(line) ; 
     content := content + StringLib.newString(lineSeparator()) ) ;     line := reader.readLine() ;
 ) ;  
     return content+"" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class QQQ {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long t=in.nextLong();
    for(int i=0 ; i<t ; i++){
      long r=in.nextLong();
      long b=in.nextLong();
      long k=0 ;
      if(r<=2){
        System.out.println(1);
      }
      else System.out.println((int)Math.ceil((r-2)/(float)b)+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class QQQ {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : long ; t := in.getCurrent()->toLong() ;
         var i : int ; i := 0 ; while i < t do ( (     var r : long ; r := in.getCurrent()->toLong() ;
     var b : long ; b := in.getCurrent()->toLong() ;
     var k : long ; k := 0 ;
     if (r <= 2) then (     OclFile["System.out"].println(1) ) else     OclFile["System.out"].println(((r - 2) / b->oclAsType(double))->ceil()->oclAsType(int) + 1) ; )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Application {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    for(int i=0 ; i<n ; i++){
      int a=scan.nextInt();
      int b=scan.nextInt();
      if(a>2)System.out.println((int)Math.ceil(((a-2.0)/b)+1));
      else System.out.println(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Application {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scan.getCurrent()->toInteger() ;
     var b : int ; b := scan.getCurrent()->toInteger() ;
     if (a > 2) then     OclFile["System.out"].println((((a - 2.0) / b) + 1)->ceil()->oclAsType(int)) ; else     OclFile["System.out"].println(1) ; )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Fast f=new Fast(System.in);
    int t=f.nextInt();
    while(t--!=0){
      int n=f.nextInt(),x=f.nextInt();
      if(n<=2)System.out.println(1);
      else System.out.println((int)ceil((n-2.0)/x)+1);
    }
    System.out.flush();
    System.out.close();
  }
}
class Fast {
  StringTokenizer st ;
  BufferedReader br ;
  public Fast(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public Fast(String file)throws IOException {
    br=new BufferedReader(new FileReader(file));
  }
  public Fast(FileReader r){
    br=new BufferedReader(r);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String readAllLines(BufferedReader reader)throws IOException {
    StringBuilder content=new StringBuilder();
    String line ;
    while((line=reader.readLine())!=null){
      content.append(line);
      content.append(System.lineSeparator());
    }
    return content.toString();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public int[] nextIntArray(int n)throws IOException {
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
}
class Pair {
  int d ;
  int k ;
  public Pair(int d,int k){
    this.d=d ;
    this.k=k ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : Fast ; f := Fast.newFast(OclFile["System.in"]) ;
     var t : int ; t := f.nextInt() ;
        while (t /= 0) do (    skip ; (     var n : int ; n := f.nextInt() ;
    var x : int ; x := f.nextInt() ;
     if (n <= 2) then     OclFile["System.out"].println(1) ; else     OclFile["System.out"].println(ceil((n - 2.0) / x)->oclAsType(int) + 1) ; ) ;  ) ;  
    OclFile["System.out"].flush() ; 
    OclFile["System.out"].close() ; 
 );
}
class Fast {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newFast( s : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFast( file : String) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   static operation newFast( r : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(r);
    return self );
  operation initialise( r : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(r) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation readAllLines( reader : OclFile) : String
  pre: true
  post: true
  activity: (     var content : String ; content := StringLib.newString() ;
     var line : String ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     content := content + StringLib.newString(line) ; 
     content := content + StringLib.newString(lineSeparator()) ) ;     line := reader.readLine() ;
 ) ;  
     return content+"" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
class Pair {
   attribute d : int;
   attribute k : int;
   static operation newPair( d : int, k : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(d, k);
    return self );
  operation initialise( d : int, k : int) : void
  pre: true  post: true
  activity: (     self.d := d ; 
     self.k := k );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class floor {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      int x=in.nextInt();
      if(n<=2){
        System.out.println(1);
      }
      else {
        n-=2 ;
        System.out.println((n+x-1)/x+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class floor {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var x : int ; x := in.getCurrent()->toInteger() ;
     if (n <= 2) then (     OclFile["System.out"].println(1) ) else (     n := n-(2) ; 
     OclFile["System.out"].println((n + x - 1) / x + 1) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class A234 {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(new File("input.txt"));
    PrintWriter out=new PrintWriter(new File("output.txt"));
    int N=in.nextInt();
    char[] S=in.next().toCharArray();
    for(int n=0 ; n<N/2 ; n++){
      int left=n+1 ;
      int right=left+N/2 ;
      if(S[n]=='R' && S[n+N/2]=='L'){
        out.println(right+" "+left);
      }
      else {
        out.println(left+" "+right);
      }
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A234 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("input.txt")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("output.txt")) ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var S : Sequence(String) ; S := in.getCurrent()->characters() ;
        var n : int ; n := 0 ; while n < N / 2 do ( (     var left : int ; left := n + 1 ;
     var right : int ; right := left + N / 2 ;
     if (S[n+1] = 'R' & S[n + N / 2+1] = 'L') then (     skip ) else (     skip ) )  ;     n := n + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    InputReader in=new InputReader(inputStream);
    int T=in.nextInt();
    while(T-->0){
      int n=in.nextInt();
      int x=in.nextInt();
      int l=1 ;
      int r=2 ;
      int level=1 ;
      while(l>n || r<n){
        l=r+1 ;
        r=(level*x)+2 ;
        level++;
      }
      System.out.println(level);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
     var T : int ; T := in.nextInt() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := in.nextInt() ;
     var x : int ; x := in.nextInt() ;
    var l : int ; l := 1 ;
    var r : int ; r := 2 ;
    var level : int ; level := 1 ;
    while (l > n or r < n) do (     l := r + 1 ; 
     r := (level * x) + 2 ; 
     level := level + 1 ) ; 
    OclFile["System.out"].println(level) ; 
 ) ;  ) );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p015 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p015().run());
  }
  public String run(){
    return Library.binomial(40,20).toString();
  }
}
------------------------------------------------------------
OCL File:
---------
class p015 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p015.newp015().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     return Library.binomial(40, 20)+"" );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class S {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int x=in.nextInt(),t=in.nextInt(),a=in.nextInt(),b=in.nextInt(),da=in.nextInt(),db=in.nextInt();
    int p=a,q=b,temp=0 ;
    if(x==0)System.out.print("YES");
    else {
      l : for(int i=0 ;
      i<t ;
      i++){
        a=a-(i*da);
        if(a==x){
          temp=1 ;
          break ;
        }
        if(a<0)a=0 ;
        for(int j=0 ; j<t ; j++){
          b=b-(j*db);
          if(b==x){
            temp=1 ;
            break ;
          }
          if(b<0)b=0 ;
          int sum=a+b ;
          if(sum==x){
            temp=1 ;
            break l ;
          }
          b=q ;
        }
        a=p ;
      }
      if(temp==1)System.out.print("YES");
      else System.out.print("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class S {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := in.getCurrent()->toInteger() ;
    var t : int ; t := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var da : int ; da := in.getCurrent()->toInteger() ;
    var db : int ; db := in.getCurrent()->toInteger() ;
     var p : int ; p := a ;
    var q : int ; q := b ;
    var temp : int ; temp := 0 ;
     if (x = 0) then     OclFile["System.out"].print("YES") ; else (         var i : int ; i := 0 ; while i < t do ( (     a := a - (i * da) ; 
     if (a = x) then (     temp := 1 ; 
     break ) else skip ; 
    if (a < 0) then     a := 0 ; else skip ; 
        var j : int ; j := 0 ; while j < t do ( (     b := b - (j * db) ; 
     if (b = x) then (     temp := 1 ; 
     break ) else skip ; 
    if (b < 0) then     b := 0 ; else skip ; 
    var sum : int ; sum := a + b ;
    if (sum = x) then (     temp := 1 ; 
     break ) else skip ; 
    b := q ; 
 )  ;     j := j + 1 ) ; 
    a := p ; 
 )  ;     i := i + 1 ) ; 
     if (temp = 1) then     OclFile["System.out"].print("YES") ; else     OclFile["System.out"].print("NO") ; ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public final class Main {
  Scanner sc ;
  public static void main(String[] args)throws Exception {
    new Main().run();
  }
  {
    sc=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
  }
  void run(){
    TreeSet<Integer>primes=sieve(1000000);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[][] a=new int[n][m];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        int num=sc.nextInt();
        a[i][j]=primes.ceiling(num)-num ;
      }
    }
    int min=Integer.MAX_VALUE ;
    for(int[] row : a){
      min=Math.min(min,Arrays.stream(row).sum());
    }
    for(int i=0 ; i<m ; i++){
      int sum=0 ;
      for(int j=0 ; j<n ; j++){
        sum+=a[j][i];
      }
      min=Math.min(min,sum);
    }
    System.out.println(min);
  }
  TreeSet<Integer>sieve(int n){
    boolean[] non_primes=new boolean[n+1];
    TreeSet<Integer>set=new TreeSet<>();
    for(int i=2 ; i*i<=n ; i++){
      if(! non_primes[i]){
        for(int j=2*i ; j<=n ; j+=i){
          non_primes[j]=true ;
        }
      }
    }
    for(int i=2 ; i<=n ; i++)if(! non_primes[i])set.add(i);
    return set ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
  operation initialiseInstance()
  pre: true post: true
  activity:     sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
;
   operation run() : void
  pre: true
  post: true
  activity: (     var primes : Set(int) ; primes := sieve(1000000) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     var num : int ; num := sc.getCurrent()->toInteger() ;
     a[i+1][j+1] := primes.ceiling(num) - num )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
    for (row : a) do ( (     min := Set{min, stream(row)->sum()}->min() )  ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     sum := sum+(a[j+1][i+1]) )  ;     j := j + 1 ) ; 
     min := Set{min, sum}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
   operation sieve( n : int) : Set(int)
  pre: true
  post: true
  activity: (     var non_primes : Sequence(boolean) ; non_primes := Integer.subrange(1,n + 1)->collect(false) ;
     var set : Set(int) ; set := Set{} ;
        var i : int ; i := 2 ; while i * i <= n do ( (     if (not(non_primes[i+1])) then (         var j : int ; j := 2 * i ; while j <= n do ( (     non_primes[j+1] := true )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= n do (     if (not(non_primes[i+1])) then     set := set->including(i) ; else skip ;  ;     i := i + 1 ) ; 
    return set 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final long MOD=(long)1e9+7 ;
    Scanner sc=new Scanner(System.in);
    int r1=sc.nextInt();
    int c1=sc.nextInt();
    int r2=sc.nextInt();
    int c2=sc.nextInt();
    int sumMax=r2+c2+1 ;
    long[] frac=new long[sumMax+1];
    long[] frac_inv=new long[sumMax+1];
    frac[0]=1 ;
    frac_inv[0]=1 ;
    for(int i=1 ; i<=sumMax ; i++){
      frac[i]=(frac[i-1]*i)% MOD ;
      frac_inv[i]=modinv(frac[i],MOD);
    }
    long ans=0 ;
    for(int i=r1 ; i<=r2 ; i++){
      long tmp1=0 ;
      long tmp2=0 ;
      tmp1=(frac[i+c2+1]*frac_inv[c2])% MOD ;
      tmp2=(frac[i+c1]*frac_inv[c1-1])% MOD ;
      long tmp=(tmp1-tmp2+MOD)% MOD ;
      tmp=(tmp*frac_inv[i+1])% MOD ;
      ans=(ans+tmp)% MOD ;
    }
    System.out.println(ans);
  }
  static long modpow(long a,long n,long mod){
    long res=1 ;
    while(n>0){
      if((n & 1)==1){
        res=(res*a)% mod ;
      }
      a=(a*a)% mod ;
      n>>=1 ;
    }
    return res ;
  }
  static long modinv(long a,long mod){
    return modpow(a,mod-2,mod);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var MOD : long ; MOD := 1e9->oclAsType(long) + 7 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var r1 : int ; r1 := sc.getCurrent()->toInteger() ;
    var c1 : int ; c1 := sc.getCurrent()->toInteger() ;
    var r2 : int ; r2 := sc.getCurrent()->toInteger() ;
    var c2 : int ; c2 := sc.getCurrent()->toInteger() ;
    var sumMax : int ; sumMax := r2 + c2 + 1 ;
    var frac : Sequence(long) ; frac := Integer.subrange(1,sumMax + 1)->collect(0) ;
    var frac_inv : Sequence(long) ; frac_inv := Integer.subrange(1,sumMax + 1)->collect(0) ;
    frac[0+1] := 1 ; 
    frac_inv[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= sumMax do ( (     frac[i+1] := (frac[i - 1+1] * i) mod MOD ; 
     frac_inv[i+1] := modinv(frac[i+1], MOD) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := r1 ; while i <= r2 do ( (     var tmp1 : long ; tmp1 := 0 ;
     var tmp2 : long ; tmp2 := 0 ;
    tmp1 := (frac[i + c2 + 1+1] * frac_inv[c2+1]) mod MOD ; 
    tmp2 := (frac[i + c1+1] * frac_inv[c1 - 1+1]) mod MOD ; 
    var tmp : long ; tmp := (tmp1 - tmp2 + MOD) mod MOD ;
    tmp := (tmp * frac_inv[i + 1+1]) mod MOD ; 
    ans := (ans + tmp) mod MOD ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation modpow( a : long, n : long, mod : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     while (n > 0) do (     if ((n & 1) = 1) then (     res := (res * a) mod mod ) else skip ; 
     a := (a * a) mod mod ; 
     n := n/(2->pow(1)) ) ; 
     return res );
  static   operation modinv( a : long, mod : long) : long
  pre: true
  post: true
  activity: (     return modpow(a, mod - 2, mod) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static long fact[];
  static long inverse[];
  static int mod=1_000_000_007 ;
  static long pow(long a,int n){
    long res=1 ;
    while(n>0){
      if((n-n/2*2)==1){
        res=res*a % mod ;
      }
      a=a*a % mod ;
      n>>=1 ;
    }
    return res ;
  }
  static long modinv(long n){
    return pow(n,mod-2);
  }
  static long comb(int n,int k){
    if(n<0 || k<0 || n<k)return 0 ;
    return fact[n]*(inverse[k]*inverse[n-k] % mod)% mod ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    fact=new long[2400005];
    fact[0]=1 ;
    inverse=new long[2400005];
    inverse[0]=1 ;
    for(int i=1 ; i<2400005 ; i++){
      fact[i]=(fact[i-1]*(long)i)% mod ;
      inverse[i]=modinv(fact[i]);
    }
    int r1=sc.nextInt();
    int c1=sc.nextInt();
    int r2=sc.nextInt();
    int c2=sc.nextInt();
    long ans=0L ;
    for(int i=r1 ; i<r2+1 ; i++){
      ans=(ans+comb(i+c2+1,c2)-comb(i+c1,c1-1))% mod ;
    }
    ans=(ans+mod)% mod ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute fact : Sequence(long);
  static   attribute inverse : Sequence(long);
  static   attribute mod : int := 1_000_000_007;
  static   operation pow( a : long, n : int) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     while (n > 0) do (     if ((n - n / 2 * 2) = 1) then (     res := res * a mod mod ) else skip ; 
     a := a * a mod mod ; 
     n := n/(2->pow(1)) ) ; 
     return res );
  static   operation modinv( n : long) : long
  pre: true
  post: true
  activity: (     return pow(n, mod - 2) );
  static   operation comb( n : int, k : int) : long
  pre: true
  post: true
  activity: (     if (n < 0 or k < 0 or n < k) then     return 0 else skip ; 
     return fact[n+1] * (inverse[k+1] * inverse[n - k+1] mod mod) mod mod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     fact := Integer.subrange(1,2400005)->collect(0) ; 
    fact[0+1] := 1 ; 
    inverse := Integer.subrange(1,2400005)->collect(0) ; 
    inverse[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < 2400005 do ( (     fact[i+1] := (fact[i - 1+1] * i->oclAsType(long)) mod mod ; 
     inverse[i+1] := modinv(fact[i+1]) )  ;     i := i + 1 ) ; 
    var r1 : int ; r1 := sc.getCurrent()->toInteger() ;
    var c1 : int ; c1 := sc.getCurrent()->toInteger() ;
    var r2 : int ; r2 := sc.getCurrent()->toInteger() ;
    var c2 : int ; c2 := sc.getCurrent()->toInteger() ;
    var ans : long ; ans := 0L ;
        var i : int ; i := r1 ; while i < r2 + 1 do ( (     ans := (ans + comb(i + c2 + 1, c2) - comb(i + c1, c1 - 1)) mod mod )  ;     i := i + 1 ) ; 
    ans := (ans + mod) mod mod ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int mod=1_000_000_007 ;
    Combination com=new Combination(n,mod);
    long ans=0L ;
    int m=k<n ? k : n-1 ;
    for(int i=0 ; i<=m ; i++){
      long z=com.comb(n,i);
      long c=com.comb(n-1,i);
      ans=(ans+(z*c % mod))% mod ;
    }
    System.out.println(ans);
    sc.close();
  }
}
class Combination {
  private long fac[];
  private long inv[];
  private int mod ;
  public Combination(int size,int mod){
    this.fac=new long[size+1];
    this.inv=new long[size+1];
    this.mod=mod ;
    this.fac[0]=1 ;
    this.inv[0]=1 ;
    for(int i=1 ; i<=size ; i++){
      fac[i]=(fac[i-1]*i)% mod ;
      inv[i]=modPow(fac[i],(int)mod-2)% mod ;
    }
  }
  public long comb(int n,int r){
    return fac[n]*inv[r] % mod*inv[n-r] % mod ;
  }
  private long modPow(long base,int exp){
    long ret=1 ;
    while(exp>0){
      if((exp & 1)==1){
        ret=ret*base % mod ;
      }
      base=base*base % mod ;
      exp>>=1 ;
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var mod : int ; mod := 1_000_000_007 ;
    var com : Combination ; com := Combination.newCombination(n, mod) ;
    var ans : long ; ans := 0L ;
    var m : int ; m := if k < n then k else n - 1 endif ;
        var i : int ; i := 0 ; while i <= m do ( (     var z : long ; z := com.comb(n, i) ;
     var c : long ; c := com.comb(n - 1, i) ;
     ans := (ans + (z * c mod mod)) mod mod )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}
class Combination {
   attribute fac : Sequence(long);
   attribute inv : Sequence(long);
   attribute mod : int;
   static operation newCombination( size : int, mod : int) : Combination
  pre: true
  post: true
  activity:
  ( var self : Combination ;
    self := createCombination();
    self.initialise(size, mod);
    return self );
  operation initialise( size : int, mod : int) : void
  pre: true  post: true
  activity: (     self.fac := Integer.subrange(1,size + 1)->collect(0) ; 
     self.inv := Integer.subrange(1,size + 1)->collect(0) ; 
    self.mod := mod ; 
    self.fac[0+1] := 1 ; 
    self.inv[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= size do ( (     fac[i+1] := (fac[i - 1+1] * i) mod mod ; 
     inv[i+1] := modPow(fac[i+1], mod->oclAsType(int) - 2) mod mod )  ;     i := i + 1 ) ; 
 );
   operation comb( n : int, r : int) : long
  pre: true
  post: true
  activity: (     return fac[n+1] * inv[r+1] mod mod * inv[n - r+1] mod mod );
   operation modPow( base : long, exp : int) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := 1 ;
     while (exp > 0) do (     if ((exp & 1) = 1) then (     ret := ret * base mod mod ) else skip ; 
     base := base * base mod mod ; 
     exp := exp/(2->pow(1)) ) ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int MAX_FAC=400001 ;
  static long FAC[]=new long[MAX_FAC];
  static long INV_FAC[]=new long[MAX_FAC];
  private static long MOD=1_000_000_007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long k=sc.nextLong();
    long ans=0 ;
    initFAC();
    if(k==1){
      ans=(n*(n-1))% MOD ;
    }
    else {
      for(long i=1 ; i<=Math.min(k,n-1); i++){
        ans+=((bara((int)n,(int)(n-i))*comb((int)n,(int)i))% MOD);
        ans %=MOD ;
      }
      ans++;
      ans %=MOD ;
    }
    System.out.println(ans);
  }
  static long comb(int n,int k){
    return(((FAC[n]*INV_FAC[n-k])% MOD)*INV_FAC[k])% MOD ;
  }
  static void initFAC(){
    FAC[0]=1 ;
    INV_FAC[0]=modinv(FAC[0]);
    for(int i=1 ; i<MAX_FAC ; i++){
      FAC[i]=(i*FAC[i-1])% MOD ;
      INV_FAC[i]=modinv(FAC[i]);
    }
  }
  static long modpow(long a,long b){
    if(b==1){
      return a % MOD ;
    }
    if(b==0){
      return 1 ;
    }
    long res=b/2 ;
    long rem=b % 2 ;
    long p=modpow(a,res)% MOD ;
    if(rem==1){
      return(((p*p)% MOD)*a)% MOD ;
    }
    else {
      return(p*p)% MOD ;
    }
  }
  static long modinv(long a){
    return modpow(a,MOD-2);
  }
  private static long bara(int n,int k){
    return comb(n-1,k-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MAX_FAC : int := 400001;
  static   attribute FAC : long := Integer.subrange(1,MAX_FAC)->collect(0);
  static   attribute INV_FAC : long := Integer.subrange(1,MAX_FAC)->collect(0);
  static   attribute MOD : long := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
    execute initFAC() ; 
    if (k = 1) then (     ans := (n * (n - 1)) mod MOD ) else (         var i : long ; i := 1 ; while i <= Set{k, n - 1}->min() do ( (     ans := ans+(((bara(n->oclAsType(int), (n - i)->oclAsType(int)) * comb(n->oclAsType(int), i->oclAsType(int))) mod MOD)) ; 
     ans := ans mod MOD )  ;     i := i + 1 ) ; 
     ans := ans + 1 ; 
     ans := ans mod MOD ) ;  
    OclFile["System.out"].println(ans) ; 
 );
  static   operation comb( n : int, k : int) : long
  pre: true
  post: true
  activity: (     return (((FAC[n+1] * INV_FAC[n - k+1]) mod MOD) * INV_FAC[k+1]) mod MOD );
  static   operation initFAC() : void
  pre: true
  post: true
  activity: (     FAC[0+1] := 1 ; 
     INV_FAC[0+1] := modinv(FAC[0+1]) ; 
         var i : int ; i := 1 ; while i < MAX_FAC do ( (     FAC[i+1] := (i * FAC[i - 1+1]) mod MOD ; 
     INV_FAC[i+1] := modinv(FAC[i+1]) )  ;     i := i + 1 ) );
  static   operation modpow( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 1) then (     return a mod MOD ) else skip ; 
     if (b = 0) then (     return 1 ) else skip ; 
    var res : long ; res := b / 2 ;
    var rem : long ; rem := b mod 2 ;
    var p : long ; p := modpow(a, res) mod MOD ;
    if (rem = 1) then (     return (((p * p) mod MOD) * a) mod MOD ) else (     return (p * p) mod MOD ) ;  
 );
  static   operation modinv( a : long) : long
  pre: true
  post: true
  activity: (     return modpow(a, MOD - 2) );
  static   operation bara( n : int, k : int) : long
  pre: true
  post: true
  activity: (     return comb(n - 1, k - 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class codeforces {
  public static void main(String args[])throws IOException {
    File file=new File("input.txt");
    Scanner sc=new Scanner(file);
    FileWriter fw=new FileWriter("output.txt");
    int n=sc.nextInt();
    String s=sc.next();
    String st="" ;
    int l=s.length();
    for(int i=0 ; i<l/2 ; i++){
      char ch1=s.charAt(i);
      char ch2=s.charAt(l/2+i);
      if(ch1=='R' && ch2=='L'){
        st=Integer.toString(l/2+i+1)+" "+Integer.toString(i+1);
      }
      else {
        st=Integer.toString(i+1)+" "+Integer.toString(l/2+i+1);
      }
      fw.write(st+"\n");
    }
    fw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var file : OclFile ; file := OclFile("input.txt") ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(file) ;
    var fw : OclFile ; fw := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var st : String ; st := "" ;
    var l : int ; l := s->size() ;
        var i : int ; i := 0 ; while i < l / 2 do ( (     var ch1 : String ; ch1 := s->at(i+1) ;
     var ch2 : String ; ch2 := s->at(l / 2 + i+1) ;
     if (ch1 = 'R' & ch2 = 'L') then (     st := ((l / 2 + i + 1) + "") + " " + ((i + 1) + "") ) else (     st := ((i + 1) + "") + " " + ((l / 2 + i + 1) + "") ) ;  
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static long fact[];
  static long inverse[];
  static int mod=1_000_000_007 ;
  static long pow(long a,int n){
    long res=1 ;
    while(n>0){
      if((n-n/2*2)==1){
        res=res*a % mod ;
      }
      a=a*a % mod ;
      n>>=1 ;
    }
    return res ;
  }
  static long modinv(long n){
    return pow(n,mod-2);
  }
  static long comb(int n,int k){
    if(n<0 || k<0 || n<k)return 0 ;
    return fact[n]*(inverse[k]*inverse[n-k] % mod)% mod ;
  }
  public static void main(String[] args){
    fact=new long[500000];
    fact[0]=1 ;
    inverse=new long[500000];
    inverse[0]=1 ;
    for(int i=1 ; i<500000 ; i++){
      fact[i]=(fact[i-1]*(long)i)% mod ;
      inverse[i]=modinv(fact[i]);
    }
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    if(k>=n-1){
      System.out.println(comb(n+n-1,n-1));
      return ;
    }
    long ans=0L ;
    for(int i=0 ; i<=k ; i++){
      ans=(ans+comb(n,i)*comb(n-(n-i)+(n-i)-1,n-i-1)% mod)% mod ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute fact : Sequence(long);
  static   attribute inverse : Sequence(long);
  static   attribute mod : int := 1_000_000_007;
  static   operation pow( a : long, n : int) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     while (n > 0) do (     if ((n - n / 2 * 2) = 1) then (     res := res * a mod mod ) else skip ; 
     a := a * a mod mod ; 
     n := n/(2->pow(1)) ) ; 
     return res );
  static   operation modinv( n : long) : long
  pre: true
  post: true
  activity: (     return pow(n, mod - 2) );
  static   operation comb( n : int, k : int) : long
  pre: true
  post: true
  activity: (     if (n < 0 or k < 0 or n < k) then     return 0 else skip ; 
     return fact[n+1] * (inverse[k+1] * inverse[n - k+1] mod mod) mod mod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     fact := Integer.subrange(1,500000)->collect(0) ; 
     fact[0+1] := 1 ; 
    inverse := Integer.subrange(1,500000)->collect(0) ; 
    inverse[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < 500000 do ( (     fact[i+1] := (fact[i - 1+1] * i->oclAsType(long)) mod mod ; 
     inverse[i+1] := modinv(fact[i+1]) )  ;     i := i + 1 ) ; 
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    if (k >= n - 1) then (     OclFile["System.out"].println(comb(n + n - 1, n - 1)) ; 
     return ) else skip ; 
    var ans : long ; ans := 0L ;
        var i : int ; i := 0 ; while i <= k do ( (     ans := (ans + comb(n, i) * comb(n - (n - i) + (n - i) - 1, n - i - 1) mod mod) mod mod )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Contest {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int x=in.nextInt();
    int t=in.nextInt();
    int a=in.nextInt();
    int b=in.nextInt();
    int da=in.nextInt();
    int db=in.nextInt();
    Set<Integer>pos=new HashSet<>();
    pos.add(0);
    for(int i=0 ; i<t ; i++){
      pos.add(a-da*i);
      pos.add(b-db*i);
      for(int j=0 ; j<t ; j++){
        pos.add(a-da*i+b-db*j);
      }
    }
    System.out.println(pos.contains(x)? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Contest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := in.getCurrent()->toInteger() ;
    var t : int ; t := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var da : int ; da := in.getCurrent()->toInteger() ;
    var db : int ; db := in.getCurrent()->toInteger() ;
    var pos : Set(int) ; pos := Set{} ;
    pos := pos->including(0) ; 
        var i : int ; i := 0 ; while i < t do ( (     pos := pos->including(a - da * i) ; 
     pos := pos->including(b - db * i) ; 
         var j : int ; j := 0 ; while j < t do ( (     pos := pos->including(a - da * i + b - db * j) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if pos->includes(x) then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static final long MOD=1000000007 ;
  static long modpow(long n,long y){
    if(y==0){
      return 1 ;
    }
    else if(y==1){
      return n % MOD ;
    }
    else {
      if(y % 2==0){
        long r=modpow(n,y/2);
        return(r*r)% MOD ;
      }
      else {
        long r=modpow(n,y/2);
        long r2=(r*r)% MOD ;
        return(r2*n)% MOD ;
      }
    }
  }
  static long modinv(long n){
    return modpow(n,MOD-2);
  }
  static long comb(int N,int R,long fact[]){
    long ret=fact[N];
    ret=(ret*modinv(fact[R]))% MOD ;
    ret=(ret*modinv(fact[N-R]))% MOD ;
    return ret ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    long fact[]=new long[2*n];
    fact[0]=1 ;
    fact[1]=1 ;
    for(int i=2 ; i<fact.length ; ++i){
      fact[i]=((long)(i)*fact[i-1])% MOD ;
    }
    if(k>=n){
      System.out.println(comb(2*n-1,n,fact));
      return ;
    }
    long S=1 ;
    for(int i=1 ; i<=k ; ++i){
      long x=comb(n,i,fact);
      long y=comb(n-1,i,fact);
      S+=(x*y)% MOD ;
      S=S % MOD ;
    }
    System.out.println(S);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 1000000007;
  static   operation modpow( n : long, y : long) : long
  pre: true
  post: true
  activity: (     if (y = 0) then (     return 1 ) else     if (y = 1) then (     return n mod MOD ) else (     if (y mod 2 = 0) then (     var r : long ; r := modpow(n, y / 2) ;
     return (r * r) mod MOD ) else (     var r : long ; r := modpow(n, y / 2) ;
     var r2 : long ; r2 := (r * r) mod MOD ;
     return (r2 * n) mod MOD ) ) ;  );
  static   operation modinv( n : long) : long
  pre: true
  post: true
  activity: (     return modpow(n, MOD - 2) );
  static   operation comb( N : int, R : int, fact : Sequence(long)) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := fact[N+1] ;
     ret := (ret * modinv(fact[R+1])) mod MOD ; 
     ret := (ret * modinv(fact[N - R+1])) mod MOD ; 
     return ret );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var fact : Sequence(long) ; fact := Integer.subrange(1,2 * n)->collect(0) ;
    fact[0+1] := 1 ; 
    fact[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < fact->size() do ( (     fact[i+1] := ((i)->oclAsType(long) * fact[i - 1+1]) mod MOD )  ;     i := i + 1 ) ; 
    if (k >= n) then (     OclFile["System.out"].println(comb(2 * n - 1, n, fact)) ; 
     return ) else skip ; 
    var S : long ; S := 1 ;
        var i : int ; i := 1 ; while i <= k do ( (     var x : long ; x := comb(n, i, fact) ;
     var y : long ; y := comb(n - 1, i, fact) ;
     S := S+((x * y) mod MOD) ; 
     S := S mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(S) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  final static int MAX=100005 ;
  static void precompute(int prefix[],int suffix[]){
    boolean prime[]=new boolean[MAX];
    for(int i=0 ; i<MAX ; i++){
      prime[i]=true ;
    }
    for(int i=2 ; i*i<MAX ; i++){
      if(prime[i]){
        for(int j=i+i ; j<MAX ; j+=i){
          prime[j]=false ;
        }
      }
    }
    prefix[1]=1 ;
    suffix[MAX-1]=(int)1e9+7 ;
    for(int i=2 ; i<MAX ; i++){
      if(prime[i]){
        prefix[i]=i ;
      }
      else {
        prefix[i]=prefix[i-1];
      }
    }
    for(int i=MAX-2 ; i>1 ; i--){
      if(prime[i]){
        suffix[i]=i ;
      }
      else {
        suffix[i]=suffix[i+1];
      }
    }
  }
  static int query(int prefix[],int suffix[],int L,int R){
    if(prefix[R]<L || suffix[L]>R){
      return 0 ;
    }
    else {
      return prefix[R]-suffix[L];
    }
  }
  public static void main(String[] args){
    int q=3 ;
    int L[]={
      2,2,24 };
      int R[]={
        5,2,28 };
        int prefix[]=new int[MAX],suffix[]=new int[MAX];
        precompute(prefix,suffix);
        for(int i=0 ; i<q ; i++){
          System.out.println(query(prefix,suffix,L[i],R[i]));
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100005;
  static   operation precompute( prefix : Sequence(int), suffix : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,MAX)->collect(false) ;
         var i : int ; i := 0 ; while i < MAX do ( (     prime[i+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i * i < MAX do ( (     if (prime[i+1]) then (         var j : int ; j := i + i ; while j < MAX do ( (     prime[j+1] := false )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    prefix[1+1] := 1 ; 
    suffix[MAX - 1+1] := 1e9->oclAsType(int) + 7 ; 
        var i : int ; i := 2 ; while i < MAX do ( (     if (prime[i+1]) then (     prefix[i+1] := i ) else (     prefix[i+1] := prefix[i - 1+1] ) )  ;     i := i + 1 ) ; 
        var i : int ; i := MAX - 2 ; while i > 1 do ( (     if (prime[i+1]) then (     suffix[i+1] := i ) else (     suffix[i+1] := suffix[i + 1+1] ) )  ;     i := i - 1 ) ; 
 );
  static   operation query( prefix : Sequence(int), suffix : Sequence(int), L : int, R : int) : int
  pre: true
  post: true
  activity: (     if (prefix[R+1] < L or suffix[L+1] > R) then (     return 0 ) else (     return prefix[R+1] - suffix[L+1] ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var q : int ; q := 3 ;
     var L : Sequence(int) ; L := Sequence{2,2,24} ;
    var R : Sequence(int) ; R := Sequence{5,2,28} ;
    var prefix : Sequence(int) ; prefix := Integer.subrange(1,MAX)->collect(0) ;
    var suffix : Sequence(void) ; suffix := Integer.subrange(1,MAX)->collect(0) ;
    execute precompute(prefix, suffix) ; 
        var i : int ; i := 0 ; while i < q do ( (     OclFile["System.out"].println(query(prefix, suffix, L[i+1], R[i+1])) )  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int V_SUM_MAX=1000 ;
  static final int N_MAX=100 ;
  static final int W_MAX=10000000 ;
  static int dp[][]=new int[V_SUM_MAX+1][N_MAX];
  static boolean v[][]=new boolean[V_SUM_MAX+1][N_MAX];
  static int solveDp(int r,int i,int w[],int val[],int n){
    if(r<=0)return 0 ;
    if(i==n)return W_MAX ;
    if(v[r][i])return dp[r][i];
    v[r][i]=true ;
    dp[r][i]=Math.min(solveDp(r,i+1,w,val,n),w[i]+solveDp(r-val[i],i+1,w,val,n));
    return dp[r][i];
  }
  static int maxWeight(int w[],int val[],int n,int c){
    for(int i=V_SUM_MAX ; i>=0 ; i--){
      if(solveDp(i,0,w,val,n)<=c){
        return i ;
      }
    }
    return 0 ;
  }
  public static void main(String[] args){
    int w[]={
      3,4,5 };
      int val[]={
        30,50,60 };
        int n=w.length ;
        int C=8 ;
        System.out.println(maxWeight(w,val,n,C));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute V_SUM_MAX : int := 1000;
  static    attribute N_MAX : int := 100;
  static    attribute W_MAX : int := 10000000;
  static   attribute dp : int := Integer.subrange(1,V_SUM_MAX + 1)->collect(Integer.subrange(1,N_MAX)->collect(0));
  static   attribute v : boolean := Integer.subrange(1,V_SUM_MAX + 1)->collect(Integer.subrange(1,N_MAX)->collect(false));
  static   operation solveDp( r : int, i : int, w : Sequence(int), val : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (r <= 0) then     return 0 else skip ; 
     if (i = n) then     return W_MAX else skip ; 
    if (v[r+1][i+1]) then     return dp[r+1][i+1] else skip ; 
    v[r+1][i+1] := true ; 
    dp[r+1][i+1] := Set{solveDp(r, i + 1, w, val, n), w[i+1] + solveDp(r - val[i+1], i + 1, w, val, n)}->min() ; 
    return dp[r+1][i+1] 
 );
  static   operation maxWeight( w : Sequence(int), val : Sequence(int), n : int, c : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := V_SUM_MAX ; while i >= 0 do ( (     if (solveDp(i, 0, w, val, n) <= c) then (     return i ) else skip )  ;     i := i - 1 ) ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var w : Sequence(int) ; w := Sequence{3,4,5} ;
     var val : Sequence(int) ; val := Sequence{30,50,60} ;
    var n : int ; n := w->size() ;
    var C : int ; C := 8 ;
    OclFile["System.out"].println(maxWeight(w, val, n, C)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solve {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t>0){
      int n=scanner.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<arr.length ; i++){
        arr[i]=scanner.nextInt();
      }
      StringBuilder sb=new StringBuilder();
      int remaining=0 ;
      for(int i=arr.length-1 ; i>=0 ; i--){
        if(remaining<arr[i] && arr[i]>0){
          remaining=arr[i];
        }
        sb.append(remaining>0 ? 1+" " : 0+" ");
        remaining--;
      }
      System.out.println(sb.reverse());
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solve {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    var remaining : int ; remaining := 0 ;
        var i : int ; i := arr->size() - 1 ; while i >= 0 do ( (     if (remaining < arr[i+1] & arr[i+1] > 0) then (     remaining := arr[i+1] ) else skip ; 
     sb := sb + StringLib.newString(if remaining > 0 then 1 + " " else 0 + " " endif) ; 
     remaining := remaining - 1 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(sb->reverse()) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.Stack ;
public class _1501B_NapoleanCake {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=Integer.parseInt(input.nextLine());
    while(test-->0){
      int creamUnit=Integer.parseInt(input.nextLine());
      Stack<Integer>creams=new Stack<>();
      int[] result=new int[creamUnit];
      for(int i=0 ; i<creamUnit ; i++){
        creams.add(input.nextInt());
      }
      input.nextLine();
      creamUnit--;
      while(! creams.isEmpty()&& creamUnit>=0){
        int num=creams.peek();
        if(num==0){
          creamUnit--;
          creams.pop();
          continue ;
        }
        while(num>0 && creamUnit>=0){
          result[creamUnit--]=1 ;
          if(creams.peek()>num){
            num=creams.peek();
          }
          creams.pop();
          num-=1 ;
        }
      }
      System.out.println(Arrays.toString(result).replaceAll("[\\[\\],] ",""));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1501B_NapoleanCake {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := (input.nextLine())->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var creamUnit : int ; creamUnit := (input.nextLine())->toInteger() ;
     var creams : Sequence(int) ; creams := Sequence{} ;
    var result : Sequence(int) ; result := Integer.subrange(1,creamUnit)->collect(0) ;
        var i : int ; i := 0 ; while i < creamUnit do ( (     creams := creams->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    skip ; 
    creamUnit := creamUnit - 1 ; 
    while (not(creams->isEmpty()) & creamUnit >= 0) do (     var num : int ; num := creams->min() ;
     if (num = 0) then (     creamUnit := creamUnit - 1 ; 
     creams := creams->front() ; 
     continue ) else skip ; 
     while (num > 0 & creamUnit >= 0) do (      result[creamUnit+1] := 1  ; creamUnit := creamUnit - 1 ; 
     if (creams->min() > num) then (     num := creams->min() ) else skip ; 
     creams := creams->front() ; 
     num := num-(1) ) ) ; 
    OclFile["System.out"].println((result + "").replaceAllMatches("[\\[\\],] ", "" )) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class AA {
  static int[] gem ;
  static int[][] dp ;
  static int d ;
  static int max=-1 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      ArrayDeque<Integer>ad=new ArrayDeque<Integer>();
      for(int j=0 ; j<n ; j++){
        ad.add(j);
        int q=sc.nextInt();
        int lim=j-q ;
        while(ad.size()>0 && ad.peekLast()>lim)ad.pollLast();
      }
      for(int j=0 ; j<n ; j++){
        if(ad.size()>0 && ad.peekFirst()==j){
          System.out.print(0+" ");
          ad.pollFirst();
        }
        else System.out.print(1+" ");
      }
      System.out.println();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class AA {
  static   attribute gem : Sequence(int);
  static   attribute dp : Sequence(Sequence(int));
  static   attribute d : int;
  static   attribute max : int := -1;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ad : Sequence(int) ; ad := ArrayDeque<int>.newArrayDeque() ;
        var j : int ; j := 0 ; while j < n do ( (     ad := ad->including(j) ; 
     var q : int ; q := sc.getCurrent()->toInteger() ;
     var lim : int ; lim := j - q ;
     while (ad->size() > 0 & ad.peekLast() > lim) do     ad := ad->front() ; )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     if (ad->size() > 0 & ad.peekFirst() = j) then (     OclFile["System.out"].print(0 + " ") ; 
     ad := ad->tail() ) else     OclFile["System.out"].print(1 + " ") ; )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void findValues(int a,int b){
    if((a-b)% 2==1){
      System.out.println("-1");
      return ;
    }
    System.out.println(((a-b)/2)+" "+((a+b)/2));
  }
  public static void main(String[] args){
    int a=12,b=8 ;
    findValues(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findValues( a : int, b : int) : void
  pre: true
  post: true
  activity: (     if ((a - b) mod 2 = 1) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
     OclFile["System.out"].println(((a - b) / 2) + " " + ((a + b) / 2)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 12 ;
    var b : int ; b := 8 ;
     execute findValues(a, b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] $){
    int n=scanner.nextInt();
    int[][] dist=new int[n][n];
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        dist[i][j]=scanner.nextInt();
        sum+=dist[i][j];
      }
    }
    sum/=2 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        for(int k=0 ; k<n ; k++){
          if(dist[j][k]>dist[j][i]+dist[i][k]){
            System.out.println(-1);
            return ;
          }
        }
      }
    }
    for(int i=1 ; i<n ; i++){
      for(int j=0 ; j<i ; j++){
        for(int k=0 ; k<n ; k++){
          if(i!=k && j!=k && dist[i][j]==dist[i][k]+dist[k][j]){
            sum-=dist[i][j];
            break ;
          }
        }
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var dist : Sequence(Sequence(int)) ; dist := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     dist[i+1][j+1] := scanner.getCurrent()->toInteger() ; 
     sum := sum+(dist[i+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    sum := sum/(2) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (         var k : int ; k := 0 ; while k < n do ( (     if (dist[j+1][k+1] > dist[j+1][i+1] + dist[i+1][k+1]) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 0 ; while j < i do ( (         var k : int ; k := 0 ; while k < n do ( (     if (i /= k & j /= k & dist[i+1][j+1] = dist[i+1][k+1] + dist[k+1][j+1]) then (     sum := sum-(dist[i+1][j+1]) ; 
     break ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int n ;
  static int[][] dist ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    dist=new int[n][n];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        dist[i][j]=sc.nextInt();
      }
    }
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        sum+=(long)dist[i][j];
      }
    }
    boolean[][] subtracted=new boolean[n][n];
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        for(int k=0 ; k<n ; k++){
          if(k==i || k==j){
            continue ;
          }
          if(dist[i][j]>dist[i][k]+dist[k][j]){
            System.out.println(-1);
            return ;
          }
          if(! subtracted[i][j] && dist[i][j]==dist[i][k]+dist[k][j]){
            sum-=(long)dist[i][j];
            subtracted[i][j]=true ;
          }
        }
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute dist : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    dist := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     dist[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     sum := sum+(dist[i+1][j+1]->oclAsType(long)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var subtracted : Sequence(Sequence(boolean)) ; subtracted := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (         var k : int ; k := 0 ; while k < n do ( (     if (k = i or k = j) then (     continue ) else skip ; 
     if (dist[i+1][j+1] > dist[i+1][k+1] + dist[k+1][j+1]) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
     if (not(subtracted[i+1][j+1]) & dist[i+1][j+1] = dist[i+1][k+1] + dist[k+1][j+1]) then (     sum := sum-(dist[i+1][j+1]->oclAsType(long)) ; 
     subtracted[i+1][j+1] := true ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GfG {
  private static int table[][];
  private static int height ;
  private GfG(int n){
    height=(int)Math.ceil(Math.log10(n)/Math.log10(2));
    table=new int[n+1][height+1];
  }
  private static void preprocessing(){
    for(int i=0 ; i<table.length ; i++){
      Arrays.fill(table[i],-1);
    }
  }
  private static void calculateSparse(int u,int v){
    table[v][0]=u ;
    for(int i=1 ; i<=height ; i++){
      table[v][i]=table[table[v][i-1] ][i-1];
      if(table[v][i]==-1)break ;
    }
  }
  private static int kthancestor(int V,int k){
    for(int i=0 ; i<=height ; i++){
      if((k &(1<<i))!=0){
        V=table[V][i];
        if(V==-1)break ;
      }
    }
    return V ;
  }
  public static void main(String args[]){
    int n=6 ;
    GfG obj=new GfG(n);
    preprocessing();
    calculateSparse(1,2);
    calculateSparse(1,3);
    calculateSparse(2,4);
    calculateSparse(2,5);
    calculateSparse(3,6);
    int K=2,V=5 ;
    System.out.print(kthancestor(V,K));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   attribute table : Sequence(Sequence(int));
  static   attribute height : int;
   static operation newGfG( n : int) : GfG
  pre: true
  post: true
  activity:
  ( var self : GfG ;
    self := createGfG();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     height := ((n)->log10() / (2)->log10())->ceil()->oclAsType(int) ; 
     table := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,height + 1)->collect(0)) );
  static   operation preprocessing() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < table->size() do ( (     table[i+1] := table[i+1]->collect(-1) )  ;     i := i + 1 ) );
  static   operation calculateSparse( u : int, v : int) : void
  pre: true
  post: true
  activity: (     table[v+1][0+1] := u ; 
         var i : int ; i := 1 ; while i <= height do ( (     table[v+1][i+1] := table[table[v+1][i - 1+1]+1][i - 1+1] ; 
     if (table[v+1][i+1] = -1) then     break else skip )  ;     i := i + 1 ) );
  static   operation kthancestor( V : int, k : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= height do ( (     if ((k & ((1*(2->pow(i)))->oclAsType(long))) /= 0) then (     V := table[V+1][i+1] ; 
     if (V = -1) then     break else skip ) else skip )  ;     i := i + 1 ) ; 
     return V );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     var obj : GfG ; obj := GfG.newGfG(n) ;
    execute preprocessing() ; 
    execute calculateSparse(1, 2) ; 
    execute calculateSparse(1, 3) ; 
    execute calculateSparse(2, 4) ; 
    execute calculateSparse(2, 5) ; 
    execute calculateSparse(3, 6) ; 
    var K : int ; K := 2 ;
    var V : int ; V := 5 ;
    OclFile["System.out"].print(kthancestor(V, K)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      long a=sc.nextLong();
      long b=sc.nextLong();
      System.out.println(toPaddedBinaryString(a & b));
      System.out.println(toPaddedBinaryString(a | b));
      System.out.println(toPaddedBinaryString(a ^ b));
    }
  }
  public static String toPaddedBinaryString(long bin){
    String result=String.format("%32s",Long.toBinaryString(bin)).replaceAll(" ","0");
    if(result.length()>32)return result.substring(result.length()-32);
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
    OclFile["System.out"].println(toPaddedBinaryString(MathLib.bitwiseAnd(a,b))) ; 
    OclFile["System.out"].println(toPaddedBinaryString(MathLib.bitwiseOr(a,b))) ; 
    OclFile["System.out"].println(toPaddedBinaryString(MathLib.bitwiseXor(a,b))) ; 
 ))  );
  static   operation toPaddedBinaryString( bin : long) : String
  pre: true
  post: true
  activity: (     var result : String ; result := StringLib.format("%32s",Sequence{(MathLib.decimal2binary(bin) + "")}).replaceAllMatches(" ", "0" ) ;
     if (result->size() > 32) then     return result.subrange(result->size() - 32+1,result->size() - 32) else skip ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private void solve(){
    int x=nextInt();
    int t=nextInt();
    int a=nextInt();
    int b=nextInt();
    int da=nextInt();
    int db=nextInt();
    int first ;
    int second ;
    boolean ok=false ;
    for(int i=0 ; i<t ; i++){
      first=a-(da*i);
      for(int j=0 ; j<t ; j++){
        second=b-(db*j);
        if(second+first==x || second==x || first==x || x==0){
          ok=true ;
          break ;
        }
      }
    }
    if(ok)out.print("YES");
    else out.print("NO");
  }
  public static void main(String[] args){
    new Main().run();
  }
  BufferedReader br ;
  StringTokenizer st ;
  PrintWriter out ;
  private void run(){
    try {
      br=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(System.out);
      solve();
      br.close();
      out.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  private int nextInt(){
    return Integer.parseInt(next());
  }
  private String next(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
        return "END_OF_FILE" ;
      }
    }
    return st.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var x : int ; x := nextInt() ;
     var t : int ; t := nextInt() ;
    var a : int ; a := nextInt() ;
    var b : int ; b := nextInt() ;
    var da : int ; da := nextInt() ;
    var db : int ; db := nextInt() ;
    var first : int ;
    var second : int ;
    var ok : boolean ; ok := false ;
        var i : int ; i := 0 ; while i < t do ( (     first := a - (da * i) ; 
         var j : int ; j := 0 ; while j < t do ( (     second := b - (db * j) ; 
     if (second + first = x or second = x or first = x or x = 0) then (     ok := true ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (ok) then     out.print("YES") else     out.print("NO") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute br : OclFile;
   attribute st : OclIterator;
   attribute out : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() ; 
     return "END_OF_FILE" )
 ) ; 
     return st.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    DRestoringRoadNetwork solver=new DRestoringRoadNetwork();
    solver.solve(1,in,out);
    out.close();
  }
  static class DRestoringRoadNetwork {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int[][] remTable=new int[n][n];
      long ans=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          remTable[i][j]=in.nextInt();
        }
      }
      for(int i=0 ; i<n ; i++){
        for(int j=i+1 ; j<n ; j++){
          boolean need=true ;
          for(int k=0 ; k<n ; k++){
            if(i==k || k==j)continue ;
            if(remTable[i][j]>remTable[i][k]+remTable[k][j]){
              ans=-1 ;
              break ;
            }
            else if(remTable[i][j]==remTable[i][k]+remTable[k][j]){
              need=false ;
            }
          }
          if(ans==-1)continue ;
          if(need){
            ans+=remTable[i][j];
          }
        }
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : DRestoringRoadNetwork ; solver := DRestoringRoadNetwork.newDRestoringRoadNetwork() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class DRestoringRoadNetwork {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var remTable : Sequence(Sequence(int)) ; remTable := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     remTable[i+1][j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var need : boolean ; need := true ;
         var k : int ; k := 0 ; while k < n do ( (     if (i = k or k = j) then     continue else skip ; 
     if (remTable[i+1][j+1] > remTable[i+1][k+1] + remTable[k+1][j+1]) then (     ans := -1 ; 
     break ) else     if (remTable[i+1][j+1] = remTable[i+1][k+1] + remTable[k+1][j+1]) then (     need := false ) else skip ; )  ;     k := k + 1 ) ; 
     if (ans = -1) then     continue else skip ; 
     if (need) then (     ans := ans+(remTable[i+1][j+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public final class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int N=s.nextInt();
    long[][] length=new long[N][N];
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        length[i][j]=s.nextLong();
      }
    }
    long result=0 ;
    for(int i=0 ; i<N ; i++){
      for(int j=i+1 ; j<N ; j++){
        long dist=length[i][j];
        boolean flag=true ;
        for(int k=0 ; k<N ; k++){
          if(k==i || k==j)continue ;
          long sum=length[i][k]+length[k][j];
          if(sum<dist){
            System.out.print(-1);
            return ;
          }
          else if(sum==dist){
            flag=false ;
          }
        }
        if(flag)result+=dist ;
      }
    }
    System.out.print(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := s.getCurrent()->toInteger() ;
    var length : Sequence(Sequence(long)) ; length := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     length[i+1][j+1] := s.getCurrent()->toLong() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var result : long ; result := 0 ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := i + 1 ; while j < N do ( (     var dist : long ; dist := length[i+1][j+1] ;
     var flag : boolean ; flag := true ;
         var k : int ; k := 0 ; while k < N do ( (     if (k = i or k = j) then     continue else skip ; 
     var sum : long ; sum := length[i+1][k+1] + length[k+1][j+1] ;
     if (sum < dist) then (     OclFile["System.out"].print(-1) ; 
     return ) else     if (sum = dist) then (     flag := false ) else skip ; )  ;     k := k + 1 ) ; 
     if (flag) then     result := result+(dist) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args)throws Exception {
    FastReader sc=new FastReader();
    String s=sc.next();
    StringBuffer snew=new StringBuffer();
    char d=s.charAt(0);
    if((int)s.charAt(0)>=97 &&(int)s.charAt(0)<=122)d=(char)(s.charAt(0)-32);
    snew.append(d);
    snew.append(s.substring(1));
    System.out.println(snew.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var s : String ; s := sc.next() ;
    var snew : String ; snew := StringLib.newString() ;
    var d : String ; d := s->at(0+1) ;
    if (s->at(0+1)->oclAsType(int) >= 97 & s->at(0+1)->oclAsType(int) <= 122) then     d := (s->at(0+1) - 32)->oclAsType(String) ; else skip ; 
    snew := snew + StringLib.newString(d) ; 
    snew := snew + StringLib.newString(s.subrange(1+1,1)) ; 
    OclFile["System.out"].println(snew+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Scanner ;
public class Solution {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    char[] ch=s.toCharArray();
    ch[0]=Character.toUpperCase(ch[0]);
    for(int i=0 ; i<ch.length ; i++)System.out.print(ch[i]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var ch : Sequence(String) ; ch := s->characters() ;
    ch[0+1] := (ch[0+1] + "")->toUpperCase() ; 
        var i : int ; i := 0 ; while i < ch->size() do (     OclFile["System.out"].print(ch[i+1]) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.String ;
public class CapialWord {
  public static void main(String[] args){
    String s ;
    Scanner sc=new Scanner(System.in);
    s=sc.next();
    int i,len=s.length();
    char[] ch=new char[len];
    ch=s.toCharArray();
    ch[0]=Character.toUpperCase(ch[0]);
    System.out.println(ch);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CapialWord {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    s := sc.getCurrent() ; 
    var i : int ;
    var len : int ; len := s->size() ;
    var ch : Sequence(String) ; ch := Integer.subrange(1,len)->collect(0) ;
    ch := s->characters() ; 
    ch[0+1] := (ch[0+1] + "")->toUpperCase() ; 
    OclFile["System.out"].println(ch) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    for(int i=0 ; i<s.length(); i++){
      if(i==0){
        System.out.print((""+s.charAt(0)).toUpperCase());
        continue ;
      }
      else {
        System.out.print(s.charAt(i));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (i = 0) then (     OclFile["System.out"].print(("" + s->at(0+1))->toUpperCase()) ; 
     continue ) else (     OclFile["System.out"].print(s->at(i+1)) ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.*;
import java.util.Scanner ;
import java.util.Arrays ;
import java.text.NumberFormat ;
import java.math.*;
public class Main {
  public static void aMethod(){
    Scanner scanner=new Scanner(System.in);
    String word=scanner.nextLine();
    System.out.print(word.substring(0,1).toUpperCase());
    System.out.println(word.substring(1,word.length()));
  }
  public static void main(String[] args){
    aMethod();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation aMethod() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var word : String ; word := scanner.nextLine() ;
     OclFile["System.out"].print(word.subrange(0+1,1)->toUpperCase()) ; 
     OclFile["System.out"].println(word.subrange(1+1,word->size())) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute aMethod() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isSubSeqDivisible(String str){
    int i,j,k,l=str.length();
    int arr[]=new int[l];
    for(i=0 ; i<l ; i++)arr[i]=str.charAt(i)-'0' ;
    for(i=0 ; i<l ; i++){
      for(j=i ; j<l ; j++){
        for(k=j ; k<l ; k++){
          if(arr[i] % 8==0)return true ;
          else if((arr[i]*10+arr[j])% 8==0 && i!=j)return true ;
          else if((arr[i]*100+arr[j]*10+arr[k])% 8==0 && i!=j && j!=k && i!=k)return true ;
        }
      }
    }
    return false ;
  }
  public static void main(String args[]){
    String str="3144" ;
    if(isSubSeqDivisible(str))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isSubSeqDivisible( str : String) : boolean
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var k : int ;
    var l : int ; l := str->size() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,l)->collect(0) ;
        i := 0 ; while i < l do (     arr[i+1] := str->at(i+1) - ('0')->char2byte() ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < l do ( (         j := i ; while j < l do ( (         k := j ; while k < l do ( (     if (arr[i+1] mod 8 = 0) then     return true else     if ((arr[i+1] * 10 + arr[j+1]) mod 8 = 0 & i /= j) then     return true else     if ((arr[i+1] * 100 + arr[j+1] * 10 + arr[k+1]) mod 8 = 0 & i /= j & j /= k & i /= k) then     return true else skip ; ;  )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "3144" ;
     if (isSubSeqDivisible(str)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean sumSquare(int n){
    HashMap<Integer,Integer>s=new HashMap<Integer,Integer>();
    for(int i=0 ; i*i<=n ; ++i){
      s.put(i*i,1);
      if(s.containsKey(n-i*i)){
        System.out.println((int)Math.sqrt(n-i*i)+"^2+"+i+"^2");
        return true ;
      }
    }
    return false ;
  }
  public static void main(String[] args){
    int n=169 ;
    System.out.print(sumSquare(n)? "YES\n" : "NO\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumSquare( n : int) : boolean
  pre: true
  post: true
  activity: (     var s : Map(int,int) ; s := Map{} ;
         var i : int ; i := 0 ; while i * i <= n do ( (     s := s->union(Map{i * i |-> 1}) ; 
     if (s->keys()->includes(n - i * i)) then (     OclFile["System.out"].println((n - i * i)->sqrt()->oclAsType(int) + "^2+" + i + "^2") ; 
     return true ) else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 169 ;
     OclFile["System.out"].print(if sumSquare(n) then "YES\n" else "NO\n" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.Stack ;
public class test {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt(),t=sc.nextInt(),a=sc.nextInt(),b=sc.nextInt(),da=sc.nextInt(),db=sc.nextInt();
    boolean found=x==0 ;
    for(int xa=0 ; xa<t ; xa++){
      if(a-da*xa==x)found=true ;
      for(int xb=0 ; xb<t ; xb++){
        int points=(a-da*xa)+(b-db*xb);
        if(points==x || b-db*xb==x){
          found=true ;
        }
      }
    }
    if(found){
      System.out.println("YES");
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var da : int ; da := sc.getCurrent()->toInteger() ;
    var db : int ; db := sc.getCurrent()->toInteger() ;
    var found : boolean ; found := x = 0 ;
        var xa : int ; xa := 0 ; while xa < t do ( (     if (a - da * xa = x) then     found := true ; else skip ; 
         var xb : int ; xb := 0 ; while xb < t do ( (     var points : int ; points := (a - da * xa) + (b - db * xb) ;
     if (points = x or b - db * xb = x) then (     found := true ) else skip )  ;     xb := xb + 1 ) )  ;     xa := xa + 1 ) ; 
    if (found) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int evenDecimalValue(String str,int n){
    int result=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i ; j<n ; j++){
        int decimalValue=0 ;
        int powerOf2=1 ;
        for(int k=i ; k<=j ; k++){
          decimalValue+=((str.charAt(k)-'0')*powerOf2);
          powerOf2*=2 ;
        }
        if(decimalValue % 2==0)result++;
      }
    }
    return result ;
  }
  public static void main(String[] args){
    String str="10010" ;
    int n=5 ;
    System.out.println(evenDecimalValue(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation evenDecimalValue( str : String, n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i ; while j < n do ( (     var decimalValue : int ; decimalValue := 0 ;
     var powerOf2 : int ; powerOf2 := 1 ;
         var k : int ; k := i ; while k <= j do ( (     decimalValue := decimalValue+(((str->at(k+1) - ('0')->char2byte()) * powerOf2)) ; 
     powerOf2 := powerOf2*(2) )  ;     k := k + 1 ) ; 
     if (decimalValue mod 2 = 0) then     result := result + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "10010" ;
     var n : int ; n := 5 ;
     OclFile["System.out"].println(evenDecimalValue(str, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int count(int n){
    if(n<4)return-1 ;
    int rem=n % 4 ;
    if(rem==0)return n/4 ;
    if(rem==1){
      if(n<9)return-1 ;
      return(n-9)/4+1 ;
    }
    if(rem==2)return(n-6)/4+1 ;
    if(rem==3){
      if(n<15)return-1 ;
      return(n-15)/4+2 ;
    }
    return 0 ;
  }
  public static void main(String[] args){
    int n=90 ;
    System.out.println(count(n));
    n=143 ;
    System.out.println(count(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count( n : int) : int
  pre: true
  post: true
  activity: (     if (n < 4) then     return -1 else skip ; 
     var rem : int ; rem := n mod 4 ;
    if (rem = 0) then     return n / 4 else skip ; 
    if (rem = 1) then (     if (n < 9) then     return -1 else skip ; 
     return (n - 9) / 4 + 1 ) else skip ; 
    if (rem = 2) then     return (n - 6) / 4 + 1 else skip ; 
    if (rem = 3) then (     if (n < 15) then     return -1 else skip ; 
     return (n - 15) / 4 + 2 ) else skip ; 
    return 0 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 90 ;
     OclFile["System.out"].println(count(n)) ; 
     n := 143 ; 
     OclFile["System.out"].println(count(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int factorial(int N){
    if(N==0 || N==1)return 1 ;
    return N*factorial(N-1);
  }
  static int nthTerm(int N){
    return(factorial(N)*(N+2)/2);
  }
  public static void main(String args[]){
    int N=6 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation factorial( N : int) : int
  pre: true
  post: true
  activity: (     if (N = 0 or N = 1) then     return 1 else skip ; 
     return N * factorial(N - 1) );
  static   operation nthTerm( N : int) : int
  pre: true
  post: true
  activity: (     return (factorial(N) * (N + 2) / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 6 ;
     OclFile["System.out"].println(nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Arrays ;
class GFG {
  static int countTripletsLessThanL(int n,int L,int[] arr){
    Arrays.sort(arr);
    int ways=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        for(int k=j+1 ; k<n ; k++){
          int mostDistantDistance=arr[k]-arr[i];
          if(mostDistantDistance<=L){
            ways++;
          }
        }
      }
    }
    return ways ;
  }
  static public void main(String[] args){
    int[] arr={
      1,2,3,4 };
      int n=arr.length ;
      int L=3 ;
      int ans=countTripletsLessThanL(n,L,arr);
      System.out.println("Total Number of ways="+ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countTripletsLessThanL( n : int, L : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var ways : int ; ways := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (         var k : int ; k := j + 1 ; while k < n do ( (     var mostDistantDistance : int ; mostDistantDistance := arr[k+1] - arr[i+1] ;
     if (mostDistantDistance <= L) then (     ways := ways + 1 ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ways );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4} ;
     var n : int ; n := arr->size() ;
    var L : int ; L := 3 ;
    var ans : int ; ans := countTripletsLessThanL(n, L, arr) ;
    OclFile["System.out"].println("Total Number of ways=" + ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class CountSubString {
  int countSubStr(char str[],int n){
    int res=0 ;
    for(int i=0 ; i<n ; i++){
      if(str[i]=='1'){
        for(int j=i+1 ; j<n ; j++){
          if(str[j]=='1')res++;
        }
      }
    }
    return res ;
  }
  public static void main(String[] args){
    CountSubString count=new CountSubString();
    String string="00100101" ;
    char str[]=string.toCharArray();
    int n=str.length ;
    System.out.println(count.countSubStr(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class CountSubString {
   operation countSubStr( str : Sequence(String), n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (str[i+1] = '1') then (         var j : int ; j := i + 1 ; while j < n do ( (     if (str[j+1] = '1') then     res := res + 1 ; else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var count : CountSubString ; count := CountSubString.newCountSubString() ;
     var string : String ; string := "00100101" ;
    var str : Sequence(String) ; str := string->characters() ;
    var n : int ; n := str->size() ;
    OclFile["System.out"].println(count.countSubStr(str, n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0){
      int n=sc.nextInt();
      HashMap<Integer,Integer>map=new HashMap<>();
      for(int i=0 ; i<n ; i++){
        int b=sc.nextInt();
        int d=sc.nextInt();
        map.put(d,Math.max(map.getOrDefault(d,0),b));
      }
      if(map.size()==10){
        int ans=0 ;
        for(int k : map.keySet())ans+=map.get(k);
        System.out.println(ans);
      }
      else System.out.println("MOREPROBLEMS");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var map : Map(int,int) ; map := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     var b : int ; b := sc.getCurrent()->toInteger() ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
     map := map->union(Map{d |-> Set{(if map->keys()->contains(d) then map->at(d) else 0 endif), b}->max()}) )  ;     i := i + 1 ) ; 
     if (map.size() = 10) then (     var ans : int ; ans := 0 ;
     for (k : map->keys()) do (     ans := ans+(map->at(k)) ;  ) ; 
     OclFile["System.out"].println(ans) ) else     OclFile["System.out"].println("MOREPROBLEMS") ; ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().start();
  }
  private void start(){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      int[] a=new int[11];
      Arrays.fill(a,-1);
      for(int i=0 ; i<n ; i++){
        int b=in.nextInt();
        int d=in.nextInt();
        a[d]=Math.max(a[d],b);
      }
      int tot=0 ;
      for(int i=1 ; i<=10 ; i++){
        if(a[i]==-1){
          tot=-1 ;
          break ;
        }
        else {
          tot+=a[i];
        }
      }
      if(tot<0){
        System.out.println("MOREPROBLEMS");
      }
      else {
        System.out.println(tot);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().start() );
   operation start() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,11)->collect(0) ;
    a := a->collect(-1) ; 
        var i : int ; i := 0 ; while i < n do ( (     var b : int ; b := in.getCurrent()->toInteger() ;
     var d : int ; d := in.getCurrent()->toInteger() ;
     a[d+1] := Set{a[d+1], b}->max() )  ;     i := i + 1 ) ; 
    var tot : int ; tot := 0 ;
        var i : int ; i := 1 ; while i <= 10 do ( (     if (a[i+1] = -1) then (     tot := -1 ; 
     break ) else (     tot := tot+(a[i+1]) ) )  ;     i := i + 1 ) ; 
    if (tot < 0) then (     OclFile["System.out"].println("MOREPROBLEMS") ) else (     OclFile["System.out"].println(tot) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class r10_1 {
  public static void main(String[] args){
    ArrayList<Integer>l=new ArrayList<Integer>();
    l.add(1);
    l.add(2);
    l.add(3);
    l.add(4);
    l.add(5);
    l.add(6);
    l.add(7);
    l.add(8);
    l.add(9);
    l.add(10);
    Scanner sc=new Scanner(System.in);
    long t=sc.nextLong();
    for(int i=0 ; i<t ; i++){
      long n=sc.nextLong();
      Map<Integer,Long>hm=new HashMap<>();
      for(int j=0 ; j<n ; j++){
        long bi=sc.nextLong();
        int di=sc.nextInt();
        if(hm.containsKey(di)){
          if(bi>hm.get(di)){
            hm.replace(di,bi);
          }
        }
        else {
          hm.put(di,bi);
        }
      }
      ArrayList<Integer>hm2=new ArrayList<>(hm.keySet());
      boolean ans=false ;
      for(int j=1 ; j<=10 ; j++){
        if(! hm2.contains(j)){
          System.out.println("MOREPROBLEMS");
          ans=true ;
          break ;
        }
      }
      if(! ans){
        long sum=0 ;
        for(Map.Entry<Integer,Long>entry : hm.entrySet()){
          sum+=entry.getValue();
        }
        System.out.println(sum);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class r10_1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     l := l->including(1) ; 
    l := l->including(2) ; 
    l := l->including(3) ; 
    l := l->including(4) ; 
    l := l->including(5) ; 
    l := l->including(6) ; 
    l := l->including(7) ; 
    l := l->including(8) ; 
    l := l->including(9) ; 
    l := l->including(10) ; 
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var t : long ; t := sc.getCurrent()->toLong() ;
        var i : int ; i := 0 ; while i < t do ( (     var n : long ; n := sc.getCurrent()->toLong() ;
     var hm : Map(int,long) ; hm := Map{} ;
        var j : int ; j := 0 ; while j < n do ( (     var bi : long ; bi := sc.getCurrent()->toLong() ;
     var di : int ; di := sc.getCurrent()->toInteger() ;
     if (hm->keys()->includes(di)) then (     if (bi > hm->at(di)) then (     hm := hm.replace(di, bi) ) else skip ) else (     hm := hm->union(Map{di |-> bi}) ) )  ;     j := j + 1 ) ; 
    var hm2 : Sequence(int) ; hm2 := Sequence{}->union(hm->keys()) ;
    var ans : boolean ; ans := false ;
        var j : int ; j := 1 ; while j <= 10 do ( (     if (not(hm2->includes(j))) then (     OclFile["System.out"].println("MOREPROBLEMS") ; 
     ans := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (not(ans)) then (     var sum : long ; sum := 0 ;
     for (entry : hm->asSet()) do ( (     sum := sum+(entry.getValue()) )  ) ; 
     OclFile["System.out"].println(sum) ) else skip ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class gfg {
  static int N=10000 ;
  static long arr[]=new long[N];
  static void seive(){
    for(int i=2 ; i*i<N ; i++){
      if(arr[i]==0){
        for(int j=2 ; i*j<N ; j++){
          arr[i*j]+=i ;
        }
      }
    }
  }
  static long sum(int l,int r){
    seive();
    long[] pref_arr=new long[r+1];
    pref_arr[0]=arr[0];
    for(int i=1 ; i<=r ; i++){
      pref_arr[i]=pref_arr[i-1]+arr[i];
    }
    if(l==1)return(pref_arr[r]);
    else return(pref_arr[r]-pref_arr[l-1]);
  }
  public static void main(String[] args){
    int l=5,r=10 ;
    System.out.println(sum(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class gfg {
  static   attribute N : int := 10000;
  static   attribute arr : long := Integer.subrange(1,N)->collect(0);
  static   operation seive() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i < N do ( (     if (arr[i+1] = 0) then (         var j : int ; j := 2 ; while i * j < N do ( (     arr[i * j+1] := arr[i * j+1]+(i) )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) );
  static   operation sum( l : int, r : int) : long
  pre: true
  post: true
  activity: (     execute seive() ; 
     var pref_arr : Sequence(long) ; pref_arr := Integer.subrange(1,r + 1)->collect(0) ;
    pref_arr[0+1] := arr[0+1] ; 
        var i : int ; i := 1 ; while i <= r do ( (     pref_arr[i+1] := pref_arr[i - 1+1] + arr[i+1] )  ;     i := i + 1 ) ; 
    if (l = 1) then     return (pref_arr[r+1]) else     return (pref_arr[r+1] - pref_arr[l - 1+1]) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 5 ;
    var r : int ; r := 10 ;
     OclFile["System.out"].println(sum(l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      InputStreamReader r=new InputStreamReader(System.in);
      BufferedReader br=new BufferedReader(r);
      String s1=br.readLine();
      String s2=br.readLine();
      int c1=0,c2=0,startS1=-1,startS2=-1 ;
      for(int i=0 ; i<s1.length(); i++){
        if(s1.charAt(i)!='0'){
          startS1=i ;
          break ;
        }
        c1++;
      }
      for(int i=0 ; i<s2.length(); i++){
        if(s2.charAt(i)!='0'){
          startS2=i ;
          break ;
        }
        c2++;
      }
      if(c1==s1.length()&& c2==s2.length())System.out.println("=");
      else if(c1==s1.length())System.out.println("<");
      else if(c2==s2.length())System.out.println(">");
      else {
        String t1=s1.substring(startS1,s1.length());
        String t2=s2.substring(startS2,s2.length());
        if(t1.length()>t2.length())System.out.println(">");
        else if(t2.length()>t1.length())System.out.println("<");
        else {
          int p=-1 ;
          for(int i=0 ; i<t1.length(); i++){
            if(t1.charAt(i)>t2.charAt(i)){
              System.out.println(">");
              p=0 ;
              break ;
            }
            if(t2.charAt(i)>t1.charAt(i)){
              System.out.println("<");
              p=0 ;
              break ;
            }
          }
          if(p==-1)System.out.println("=");
        }
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(r) ;
    var s1 : String ; s1 := br.readLine() ;
    var s2 : String ; s2 := br.readLine() ;
    var c1 : int ; c1 := 0 ;
    var c2 : int ; c2 := 0 ;
    var startS1 : int ; startS1 := -1 ;
    var startS2 : int ; startS2 := -1 ;
        var i : int ; i := 0 ; while i < s1->size() do ( (     if (s1->at(i+1) /= '0') then (     startS1 := i ; 
     break ) else skip ; 
     c1 := c1 + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < s2->size() do ( (     if (s2->at(i+1) /= '0') then (     startS2 := i ; 
     break ) else skip ; 
     c2 := c2 + 1 )  ;     i := i + 1 ) ; 
    if (c1 = s1->size() & c2 = s2->size()) then     OclFile["System.out"].println("=") else     if (c1 = s1->size()) then     OclFile["System.out"].println("<") else     if (c2 = s2->size()) then     OclFile["System.out"].println(">") else (     var t1 : String ; t1 := s1.subrange(startS1+1,s1->size()) ;
     var t2 : String ; t2 := s2.subrange(startS2+1,s2->size()) ;
     if (t1->size() > t2->size()) then     OclFile["System.out"].println(">") ; else     if (t2->size() > t1->size()) then     OclFile["System.out"].println("<") else (     var p : int ; p := -1 ;
         var i : int ; i := 0 ; while i < t1->size() do ( (     if (t1->at(i+1) > t2->at(i+1)) then (     OclFile["System.out"].println(">") ; 
     p := 0 ; 
     break ) else skip ; 
     if (t2->at(i+1) > t1->at(i+1)) then (     OclFile["System.out"].println("<") ; 
     p := 0 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (p = -1) then     OclFile["System.out"].println("=") ; else skip ) ;  ) ;  ;  ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isSumOfPowersOfTwo(int n){
    if(n % 2==1)return false ;
    else return true ;
  }
  public static void main(String args[]){
    int n=10 ;
    if(isSumOfPowersOfTwo(n))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isSumOfPowersOfTwo( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n mod 2 = 1) then     return false else     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     if (isSumOfPowersOfTwo(n)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String a=br.readLine();
    String b=br.readLine();
    char charArray1[]=a.toCharArray();
    char charArray2[]=b.toCharArray();
    int i ;
    for(i=0 ; i<a.length(); i++){
      if(charArray1[i]!='0'){
        break ;
      }
    }
    if(i!=a.length())a=a.substring(i);
    else a="0" ;
    for(i=0 ; i<b.length(); i++){
      if(charArray2[i]!='0'){
        break ;
      }
    }
    if(i!=b.length())b=b.substring(i);
    else b="0" ;
    if(a.length()>b.length())System.out.println(">");
    else if(a.length()<b.length())System.out.println("<");
    else {
      if(a.compareTo(b)<0)System.out.println("<");
      else if(a.compareTo(b)>0)System.out.println(">");
      else System.out.println("=");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var a : String ; a := br.readLine() ;
    var b : String ; b := br.readLine() ;
    var charArray1 : Sequence(String) ; charArray1 := a->characters() ;
    var charArray2 : Sequence(String) ; charArray2 := b->characters() ;
    var i : int ;
        i := 0 ; while i < a->size() do ( (     if (charArray1[i+1] /= '0') then (     break ) else skip )  ;     i := i + 1 ) ; 
    if (i /= a->size()) then     a := a.subrange(i+1,i) else     a := "0" ; ;  
        i := 0 ; while i < b->size() do ( (     if (charArray2[i+1] /= '0') then (     break ) else skip )  ;     i := i + 1 ) ; 
    if (i /= b->size()) then     b := b.subrange(i+1,i) else     b := "0" ; ;  
    if (a->size() > b->size()) then     OclFile["System.out"].println(">") else     if (a->size() < b->size()) then     OclFile["System.out"].println("<") else (     if (a->compareTo(b) < 0) then     OclFile["System.out"].println("<") ; else     if (a->compareTo(b) > 0) then     OclFile["System.out"].println(">") else     OclFile["System.out"].println("=") ; ;  ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] $){
    int n=scanner.nextInt();
    int[] a=new int[n];
    int[] b=new int[n];
    Arrays.setAll(a,i->scanner.nextInt());
    Arrays.setAll(b,i->scanner.nextInt());
    int ans=0 ;
    for(int i=1<<28 ; i>0 ; i>>=1){
      int count=0 ;
      for(int j=0 ; j<n ; j++){
        a[j] &=2*i-1 ;
        b[j] &=2*i-1 ;
      }
      Arrays.sort(a);
      Arrays.sort(b);
      int p1=0,p2=0,p3=0 ;
      for(int j=n-1 ; j>=0 ; j--){
        while(p1<n && a[j]+b[p1]<i)p1++;
        while(p2<n && a[j]+b[p2]<2*i)p2++;
        while(p3<n && a[j]+b[p3]<3*i)p3++;
        count+=n+p2-p1-p3 ;
        count &=1 ;
      }
      if(count % 2==1){
        ans |=i ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
setAll(a, lambda i : OclAny in scanner.getCurrent()->toInteger()) ; 
setAll(b, lambda i : OclAny in scanner.getCurrent()->toInteger()) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := (1*(2->pow(28)))->oclAsType(long) ; while i > 0 do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     a[j+1] := MathLib.bitwiseAnd(a[j+1], 2 * i - 1) ; 
     b[j+1] := MathLib.bitwiseAnd(b[j+1], 2 * i - 1) )  ;     j := j + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    var p1 : int ; p1 := 0 ;
    var p2 : int ; p2 := 0 ;
    var p3 : int ; p3 := 0 ;
        var j : int ; j := n - 1 ; while j >= 0 do ( (     while (p1 < n & a[j+1] + b[p1+1] < i) do     p1 := p1 + 1 ; ; 
     while (p2 < n & a[j+1] + b[p2+1] < 2 * i) do     p2 := p2 + 1 ; ; 
    while (p3 < n & a[j+1] + b[p3+1] < 3 * i) do     p3 := p3 + 1 ; ; 
    count := count+(n + p2 - p1 - p3) ; 
    count := MathLib.bitwiseAnd(count, 1) ; 
 )  ;     j := j - 1 ) ; 
    if (count mod 2 = 1) then (     ans := MathLib.bitwiseOr(ans, i) ) else skip ; 
 )  ;     i := i/(2->pow(1)) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.*;
public class Solution {
  static MyScanner str=new MyScanner();
  public static void main(String[] args)throws IOException {
    long T=1 ;
    while(T-->0){
      solve();
    }
  }
  static void solve()throws IOException {
    int n=i();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=i();
      while(a[i] % 2==0)a[i]/=2 ;
      while(a[i] % 3==0)a[i]/=3 ;
    }
    for(int i=1 ; i<n ; i++){
      if(a[i]!=a[0]){
        System.out.println("NO");
        return ;
      }
    }
    System.out.println("YES");
  }
  public static int i()throws IOException {
    return str.nextInt();
  }
  public static long l()throws IOException {
    return str.nextLong();
  }
  public static double d()throws IOException {
    return str.nextDouble();
  }
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute str : MyScanner := MyScanner.newMyScanner();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : long ; T := 1 ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := i() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := i() ; 
     while (a[i+1] mod 2 = 0) do     a[i+1] := a[i+1]/(2) ; ; 
     while (a[i+1] mod 3 = 0) do     a[i+1] := a[i+1]/(3) ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] /= a[0+1]) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
  static   operation i() : int
  pre: true
  post: true
  activity: (     return str.nextInt() );
  static   operation l() : long
  pre: true
  post: true
  activity: (     return str.nextLong() );
  static   operation d() : double
  pre: true
  post: true
  activity: (     return str.nextDouble() );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    HashSet<Integer>set=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      int val=in.nextInt();
      while(val % 2==0){
        val/=2 ;
      }
      while(val % 3==0){
        val/=3 ;
      }
      set.add(val);
    }
    if(set.size()==1){
      pw.println("Yes");
    }
    else {
      pw.println("No");
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     var val : int ; val := in.getCurrent()->toInteger() ;
     while (val mod 2 = 0) do (     val := val/(2) ) ; 
     while (val mod 3 = 0) do (     val := val/(3) ) ; 
     set := set->including(val) )  ;     i := i + 1 ) ; 
    if (set->size() = 1) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class WriteNow {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[][] arr=new int[n][6];
    int[] count=new int[100];
    for(int i1=0 ; i1<n ; i1++){
      for(int i=0 ; i<6 ; i++){
        arr[i1][i]=scan.nextInt();
      }
    }
    for(int i1=0 ; i1<n ; i1++){
      for(int i2=0 ; i2<6 ; i2++){
        count[arr[i1][i2] ]=1 ;
        for(int i3=i1+1 ; i3<n ; i3++){
          for(int i4=0 ; i4<6 ; i4++){
            count[arr[i3][i4] ]=1 ;
            count[arr[i1][i2]*10+arr[i3][i4] ]=1 ;
            count[arr[i3][i4]*10+arr[i1][i2] ]=1 ;
          }
        }
      }
    }
    for(int i=1 ; i<count.length ; i++){
      if(count[i]==0){
        System.out.println(i-1);
        break ;
      }
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class WriteNow {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,6)->collect(0)) ;
    var count : Sequence(int) ; count := Integer.subrange(1,100)->collect(0) ;
        var i1 : int ; i1 := 0 ; while i1 < n do ( (         var i : int ; i := 0 ; while i < 6 do ( (     arr[i1+1][i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) )  ;     i1 := i1 + 1 ) ; 
        var i1 : int ; i1 := 0 ; while i1 < n do ( (         var i2 : int ; i2 := 0 ; while i2 < 6 do ( (     count[arr[i1+1][i2+1]+1] := 1 ; 
         var i3 : int ; i3 := i1 + 1 ; while i3 < n do ( (         var i4 : int ; i4 := 0 ; while i4 < 6 do ( (     count[arr[i3+1][i4+1]+1] := 1 ; 
     count[arr[i1+1][i2+1] * 10 + arr[i3+1][i4+1]+1] := 1 ; 
     count[arr[i3+1][i4+1] * 10 + arr[i1+1][i2+1]+1] := 1 )  ;     i4 := i4 + 1 ) )  ;     i3 := i3 + 1 ) )  ;     i2 := i2 + 1 ) )  ;     i1 := i1 + 1 ) ; 
        var i : int ; i := 1 ; while i < count->size() do ( (     if (count[i+1] = 0) then (     OclFile["System.out"].println(i - 1) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class trailzero {
  public static void main(String[] args)throws Throwable {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[6*n];
    for(int i=0 ; i<6*n ; i++){
      a[i]=sc.nextInt();
    }
    ArrayList<Integer>p=new ArrayList<>();
    for(int i=0 ; i<6*n ; i++){
      for(int j=0 ; j<6*n ; j++){
        p.add(a[i]);
        if(i/6!=j/6){
          p.add(a[i]+10*a[j]);
        }
      }
    }
    int num=1 ;
    while(p.contains(num)){
      num++;
    }
    System.out.println(num-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class trailzero {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,6 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < 6 * n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var p : Sequence(int) ; p := Sequence{} ;
        var i : int ; i := 0 ; while i < 6 * n do ( (         var j : int ; j := 0 ; while j < 6 * n do ( (     p := p->including(a[i+1]) ; 
     if (i / 6 /= j / 6) then (     p := p->including(a[i+1] + 10 * a[j+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var num : int ; num := 1 ;
    while (p->includes(num)) do (     num := num + 1 ) ; 
    OclFile["System.out"].println(num - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static void splitArr(int arr[],int n,int k){
    for(int i=0 ; i<k ; i++){
      int x=arr[0];
      for(int j=0 ; j<n-1 ; ++j)arr[j]=arr[j+1];
      arr[n-1]=x ;
    }
  }
  public static void main(String[] args){
    int arr[]={
      12,10,5,6,52,36 };
      int n=arr.length ;
      int position=2 ;
      splitArr(arr,6,position);
      for(int i=0 ; i<n ; ++i)System.out.print(arr[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation splitArr( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < k do ( (     var x : int ; x := arr[0+1] ;
         var j : int ; j := 0 ; while j < n - 1 do (     arr[j+1] := arr[j + 1+1] ;  ;     j := j + 1 ) ; 
     arr[n - 1+1] := x )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,10,5,6,52,36} ;
     var n : int ; n := arr->size() ;
    var position : int ; position := 2 ;
    execute splitArr(arr, 6, position) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class node {
    char data ;
    node next ;
  };
  static node add(char data){
    node newnode=new node();
    newnode.data=data ;
    newnode.next=null ;
    return newnode ;
  }
  static void print(node head){
    while(head!=null){
      System.out.print(head.data+"->");
      head=head.next ;
    }
    System.out.print("null");
  }
  static boolean isSpecialChar(char ch){
    if(ch>='a' && ch<='z')return false ;
    if(ch>='A' && ch<='Z')return false ;
    if(ch>='0' && ch<='9')return false ;
    return true ;
  }
  static node removeFromLL(node head){
    node curr=head ;
    node prev=head ;
    while(curr!=null && isSpecialChar(curr.data)){
      node temp=curr ;
      head=curr.next ;
      curr=curr.next ;
      temp=null ;
    }
    prev=head ;
    while(curr!=null){
      while(curr!=null && isSpecialChar(curr.data)){
        node temp=curr ;
        prev.next=curr.next ;
        curr=curr.next ;
        temp=null ;
      }
      if(curr==null)break ;
      prev=curr ;
      curr=curr.next ;
    }
    return head ;
  }
  public static void main(String[] args){
    node head=null ;
    head=add('(');
    head.next=add('G');
    head.next.next=add('E');
    head.next.next.next=add('E');
    head.next.next.next.next=add('*');
    head.next.next.next.next.next=add('K');
    head.next.next.next.next.next.next=add('S');
    head.next.next.next.next.next.next.next=add('*');
    head=removeFromLL(head);
    print(head);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class node {
   attribute data : String;
   attribute next : node;
}
  static   operation add( data : String) : node
  pre: true
  post: true
  activity: (     var newnode : node ; newnode := node.newnode() ;
     newnode.data := data ; 
     newnode.next := null ; 
     return newnode );
  static   operation print( head : node) : void
  pre: true
  post: true
  activity: (     while (head /= null) do (     OclFile["System.out"].print(head.data + "->") ; 
     head := head.next ) ; 
     OclFile["System.out"].print("null") );
  static   operation isSpecialChar( ch : String) : boolean
  pre: true
  post: true
  activity: (     if (ch >= 'a' & ch <= 'z') then     return false else skip ; 
     if (ch >= 'A' & ch <= 'Z') then     return false else skip ; 
     if (ch >= '0' & ch <= '9') then     return false else skip ; 
     return true );
  static   operation removeFromLL( head : node) : node
  pre: true
  post: true
  activity: (     var curr : node ; curr := head ;
     var prev : node ; prev := head ;
    while (curr /= null & isSpecialChar(curr.data)) do (     var temp : node ; temp := curr ;
     head := curr.next ; 
     curr := curr.next ; 
     temp := null ) ; 
    prev := head ; 
    while (curr /= null) do (     while (curr /= null & isSpecialChar(curr.data)) do (     var temp : node ; temp := curr ;
     prev.next := curr.next ; 
     curr := curr.next ; 
     temp := null ) ; 
     if (curr = null) then     break else skip ; 
     prev := curr ; 
     curr := curr.next ) ; 
    return head 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : node ; head := null ;
     head := add('(') ; 
    head.next := add('G') ; 
    head.next.next := add('E') ; 
    head.next.next.next := add('E') ; 
    head.next.next.next.next := add('*') ; 
    head.next.next.next.next.next := add('K') ; 
    head.next.next.next.next.next.next := add('S') ; 
    head.next.next.next.next.next.next.next := add('*') ; 
    head := removeFromLL(head) ; 
    execute print(head) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GFG {
  static long getChicks(int n){
    int size=Math.max(n,7);
    long[] dp=new long[size];
    dp[0]=0 ;
    dp[1]=1 ;
    for(int i=2 ; i<6 ; i++){
      dp[i]=dp[i-1]*3 ;
    }
    dp[6]=726 ;
    for(int i=8 ; i<=n ; i++){
      dp[i]=(dp[i-1]-(2*dp[i-6]/3))*3 ;
    }
    return dp[n];
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(getChicks(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getChicks( n : int) : long
  pre: true
  post: true
  activity: (     var size : int ; size := Set{n, 7}->max() ;
     var dp : Sequence(long) ; dp := Integer.subrange(1,size)->collect(0) ;
    dp[0+1] := 0 ; 
    dp[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < 6 do ( (     dp[i+1] := dp[i - 1+1] * 3 )  ;     i := i + 1 ) ; 
    dp[6+1] := 726 ; 
        var i : int ; i := 8 ; while i <= n do ( (     dp[i+1] := (dp[i - 1+1] - (2 * dp[i - 6+1] / 3)) * 3 )  ;     i := i + 1 ) ; 
    return dp[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(getChicks(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    MyScanner in=new MyScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    D solver=new D();
    solver.solve(1,in,out);
    out.close();
  }
  static class D {
    private static long MOD=(long)(1e9+7);
    public void solve(int testNumber,MyScanner in,PrintWriter out){
      int N=in.Int();
      int K=in.Int();
      long ans=0 ;
      for(long i=K ; i<=N+1 ; i++){
        long a=(i*(i-1))/2 ;
        long b=((N+(N-i+1))*i)/2 ;
        ans+=b-(a-1);
        ans %=MOD ;
      }
      out.println((ans+MOD)% MOD);
    }
  }
  static class MyScanner {
    private BufferedReader in ;
    private StringTokenizer st ;
    public MyScanner(InputStream stream){
      in=new BufferedReader(new InputStreamReader(stream));
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          String rl=in.readLine();
          if(rl==null){
            return null ;
          }
          st=new StringTokenizer(rl);
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    public int Int(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : MyScanner ; in := MyScanner.newMyScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : D ; solver := D.newD() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class D {
  static   attribute MOD : long := (1e9 + 7)->oclAsType(long);
   operation solve( testNumber : int, in : MyScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.Int() ;
     var K : int ; K := in.Int() ;
    var ans : long ; ans := 0 ;
        var i : long ; i := K ; while i <= N + 1 do ( (     var a : long ; a := (i * (i - 1)) / 2 ;
     var b : long ; b := ((N + (N - i + 1)) * i) / 2 ;
     ans := ans+(b - (a - 1)) ; 
     ans := ans mod MOD )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class MyScanner {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner( stream : OclFile) : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     var rl : String ; rl := in.readLine() ;
     if (rl = null) then (     return null ) else skip ; 
     st := OclIterator.newOclIterator_String(rl) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation Int() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class E {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int testCases=in.nextInt();
    for(int testCase=0 ; testCase<testCases ; testCase++){
      int n=in.nextInt();
      char[] s=in.next().toCharArray();
      int ones=0 ;
      int zeros=0 ;
      int sum=0 ;
      for(int i=1 ; i<n ; i++){
        if(s[i]==s[i-1]){
          if(s[i]=='1'){
            ones++;
          }
          else {
            zeros++;
          }
        }
      }
      sum=Math.max(ones,zeros);
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class E {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := in.getCurrent()->toInteger() ;
         var testCase : int ; testCase := 0 ; while testCase < testCases do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var s : Sequence(String) ; s := in.getCurrent()->characters() ;
    var ones : int ; ones := 0 ;
    var zeros : int ; zeros := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (s[i+1] = s[i - 1+1]) then (     if (s[i+1] = '1') then (     ones := ones + 1 ) else (     zeros := zeros + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    sum := Set{ones, zeros}->max() ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     testCase := testCase + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] cmd=br.readLine().split(" ");
    long x=Long.valueOf(cmd[0]);
    long k=Long.valueOf(cmd[1]);
    long[] sum1=new long[(int)x+2];
    for(long i=1 ; i<=x+1 ; i++){
      sum1[(int)i]=sum1[(int)i-1]+i ;
    }
    long[] sum2=new long[(int)x+2];
    for(long i=x+1 ; i>=1 ; i--){
      sum2[(int)(x+2-i)]=sum2[(int)(x+1-i)]+i ;
    }
    long ans=0 ;
    for(long i=k ; i<=x+1 ; i++){
      long diff=sum2[(int)i]-sum1[(int)i]+1 ;
      ans=(ans+diff)% 1000000007 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var cmd : Sequence(String) ; cmd := br.readLine()->split(" ") ;
    var x : long ; x := (cmd[0+1])->toLong() ;
    var k : long ; k := (cmd[1+1])->toLong() ;
    var sum1 : Sequence(long) ; sum1 := Integer.subrange(1,x->oclAsType(int) + 2)->collect(0) ;
        var i : long ; i := 1 ; while i <= x + 1 do ( (     sum1[i->oclAsType(int)+1] := sum1[i->oclAsType(int) - 1+1] + i )  ;     i := i + 1 ) ; 
    var sum2 : Sequence(long) ; sum2 := Integer.subrange(1,x->oclAsType(int) + 2)->collect(0) ;
        var i : long ; i := x + 1 ; while i >= 1 do ( (     sum2[(x + 2 - i)->oclAsType(int)+1] := sum2[(x + 1 - i)->oclAsType(int)+1] + i )  ;     i := i - 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : long ; i := k ; while i <= x + 1 do ( (     var diff : long ; diff := sum2[i->oclAsType(int)+1] - sum1[i->oclAsType(int)+1] + 1 ;
     ans := (ans + diff) mod 1000000007 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      b[i]=sc.nextInt();
    }
    sc.close();
    long[] num=new long[29];
    long ans=0 ;
    for(int i=0 ; i<29 ; i++){
      int[] ta=new int[n];
      int[] tb=new int[n];
      for(int j=0 ; j<n ; j++){
        ta[j]=a[j] %(2<<i);
        tb[j]=b[j] %(2<<i);
      }
      Arrays.sort(tb);
      int pow1=(2<<i)/2 ;
      int pow2=2*pow1,pow3=3*pow1,pow4=4*pow1 ;
      for(int j=0 ; j<n ; j++){
        int tmp1=myBinarySearch(tb,pow1-ta[j]);
        int tmp2=myBinarySearch(tb,pow2-ta[j]);
        int tmp3=myBinarySearch(tb,pow3-ta[j]);
        int tmp4=myBinarySearch(tb,pow4-ta[j]);
        num[i]+=tmp2-tmp1+tmp4-tmp3 ;
      }
      if(num[i] % 2==1)ans+=(2<<i)/2 ;
    }
    System.out.println(ans);
  }
  public static int myBinarySearch(int[] la,int key){
    int l=-1 ;
    int r=la.length ;
    while(r-l>1){
      int m=(l+r)>>1 ;
      if(la[m]>=key){
        r=m ;
      }
      else {
        l=m ;
      }
    }
    return r ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var num : Sequence(long) ; num := Integer.subrange(1,29)->collect(0) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < 29 do ( (     var ta : Sequence(int) ; ta := Integer.subrange(1,n)->collect(0) ;
     var tb : Sequence(int) ; tb := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     ta[j+1] := a[j+1] mod ((2*(2->pow(i)))->oclAsType(long)) ; 
     tb[j+1] := b[j+1] mod ((2*(2->pow(i)))->oclAsType(long)) )  ;     j := j + 1 ) ; 
    tb := tb->sort() ; 
    var pow1 : int ; pow1 := ((2*(2->pow(i)))->oclAsType(long)) / 2 ;
    var pow2 : int ; pow2 := 2 * pow1 ;
    var pow3 : int ; pow3 := 3 * pow1 ;
    var pow4 : int ; pow4 := 4 * pow1 ;
        var j : int ; j := 0 ; while j < n do ( (     var tmp1 : int ; tmp1 := myBinarySearch(tb, pow1 - ta[j+1]) ;
     var tmp2 : int ; tmp2 := myBinarySearch(tb, pow2 - ta[j+1]) ;
    var tmp3 : int ; tmp3 := myBinarySearch(tb, pow3 - ta[j+1]) ;
    var tmp4 : int ; tmp4 := myBinarySearch(tb, pow4 - ta[j+1]) ;
    num[i+1] := num[i+1]+(tmp2 - tmp1 + tmp4 - tmp3) ; 
 )  ;     j := j + 1 ) ; 
    if (num[i+1] mod 2 = 1) then     ans := ans+(((2*(2->pow(i)))->oclAsType(long)) / 2) ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation myBinarySearch( la : Sequence(int), key : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := -1 ;
     var r : int ; r := la->size() ;
     while (r - l > 1) do (     var m : int ; m := ((l + r)/(2->pow(1)))->oclAsType(long) ;
     if (la[m+1] >= key) then (     r := m ) else (     l := m ) ) ; 
     return r );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    long n=sc.nextInt();
    long k=sc.nextInt();
    long mod=(long)Math.pow(10,9)+7 ;
    long count=0 ;
    for(long i=k ; i<=n+1 ; i++){
      long min=sum(0,i-1);
      long max=sum(n-i+1,n);
      count+=(max-min+1);
      count %=mod ;
    }
    System.out.println(count);
  }
  private static long sum(long left,long right){
    return(left+right)*(right-left+1)/2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.getCurrent()->toInteger() ;
     var k : long ; k := sc.getCurrent()->toInteger() ;
    var mod : long ; mod := 10->pow(9)->oclAsType(long) + 7 ;
    var count : long ; count := 0 ;
        var i : long ; i := k ; while i <= n + 1 do ( (     var min : long ; min := sum(0, i - 1) ;
     var max : long ; max := sum(n - i + 1, n) ;
     count := count+((max - min + 1)) ; 
     count := count mod mod )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation sum( left : long, right : long) : long
  pre: true
  post: true
  activity: (     return (left + right) * (right - left + 1) / 2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    long num=1000000007 ;
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    StringTokenizer st=new StringTokenizer(bf.readLine());
    int n=Integer.parseInt(st.nextToken());
    int k=Integer.parseInt(st.nextToken());
    long sum=0 ;
    for(long j=k ; j<=n ; j++){
      sum+=(long)((j*(long)(n)-j*j+j+1));
      sum %=num ;
    }
    out.println(sum+1);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : long ; num := 1000000007 ;
     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(bf.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var k : int ; k := (st.next())->toInteger() ;
    var sum : long ; sum := 0 ;
        var j : long ; j := k ; while j <= n do ( (     sum := sum+(((j * (n)->oclAsType(long) - j * j + j + 1))->oclAsType(long)) ; 
     sum := sum mod num )  ;     j := j + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    FastReader a=new FastReader();
    int n=a.nextInt();
    int m=a.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<arr.length ; i++)arr[i]=a.nextInt();
    int sum=0 ;
    int[] add=new int[n];
    while(m-->0){
      int type=a.nextInt();
      if(type==1){
        int index=a.nextInt()-1 ;
        arr[index]=a.nextInt()-sum ;
      }
      else if(type==3){
        int index=a.nextInt()-1 ;
        System.out.println(arr[index]+sum);
      }
      else {
        sum+=a.nextInt();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : FastReader ; a := FastReader.newFastReader() ;
     var n : int ; n := a.nextInt() ;
    var m : int ; m := a.nextInt() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do (     arr[i+1] := a.nextInt() ;  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var add : Sequence(int) ; add := Integer.subrange(1,n)->collect(0) ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     var type : int ; type := a.nextInt() ;
     if (type = 1) then (     var index : int ; index := a.nextInt() - 1 ;
     arr[index+1] := a.nextInt() - sum ) else     if (type = 3) then (     var index : int ; index := a.nextInt() - 1 ;
     OclFile["System.out"].println(arr[index+1] + sum) ) else (     sum := sum+(a.nextInt()) ) ;  ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    HashMap<String,Integer>map=new HashMap<String,Integer>();
    for(int i=0 ; i<n ; i++){
      String s=sc.next();
      if(map.get(s)==null){
        map.put(s,1);
      }
      else {
        map.put(s,map.get(s)+1);
      }
    }
    int m=Integer.parseInt(sc.next());
    for(int i=0 ; i<m ; i++){
      String s=sc.next();
      if(map.get(s)!=null){
        map.put(s,map.get(s)-1);
      }
    }
    int max=0 ;
    for(int val : map.values()){
      if(val>max){
        max=val ;
      }
    }
    System.out.println(max);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
     if (map->at(s) = null) then (     map := map->union(Map{s |-> 1}) ) else (     map := map->union(Map{s |-> map->at(s) + 1}) ) )  ;     i := i + 1 ) ; 
    var m : int ; m := (sc.getCurrent())->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     var s : String ; s := sc.getCurrent() ;
     if (map->at(s) /= null) then (     map := map->union(Map{s |-> map->at(s) - 1}) ) else skip )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    for (val : map->values()) do ( (     if (val > max) then (     max := val ) else skip )  ) ; 
    OclFile["System.out"].println(max) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Iterator ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    Map<String,Integer>map=new HashMap<String,Integer>();
    for(int i=0 ; i<N ; i++){
      String key=sc.next();
      Integer count=map.get(key);
      if(count==null)count=1 ;
      else count++;
      map.put(key,count);
    }
    int M=sc.nextInt();
    for(int i=0 ; i<M ; i++){
      String key=sc.next();
      Integer count=map.get(key);
      if(count==null)count=-1 ;
      else count--;
      map.put(key,count);
    }
    Iterator<Integer>it=map.values().iterator();
    int res=0 ;
    while(it.hasNext()){
      int t=it.next();
      if(res<t)res=t ;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     var key : String ; key := sc.getCurrent() ;
     var count : int ; count := map->at(key) ;
     if (count = null) then     count := 1 else     count := count + 1 ; ;  
     map := map->union(Map{key |-> count}) )  ;     i := i + 1 ) ; 
    var M : int ; M := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < M do ( (     var key : String ; key := sc.getCurrent() ;
     var count : int ; count := map->at(key) ;
     if (count = null) then     count := -1 else     count := count - 1 ; ;  
     map := map->union(Map{key |-> count}) )  ;     i := i + 1 ) ; 
    var it : OclIterator ; it := map->values()->iterator() ;
    var res : int ; res := 0 ;
    while (it.hasNext()) do (     var t : int ; t := it.next() ;
     if (res < t) then     res := t ; else skip ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner s=new Scanner(System.in);
  public static void main(String[] args){
    int N=s.nextInt();
    String[] bArr=new String[N];
    boolean[] bBoolArr=new boolean[N];
    for(int i=0 ; i<N ; i++){
      bArr[i]=s.next();
      bBoolArr[i]=true ;
    }
    int M=s.nextInt();
    String[] rArr=new String[M];
    for(int i=0 ; i<M ; i++){
      rArr[i]=s.next();
    }
    int count=1 ;
    int ans=0 ;
    if(N==1){
      for(int k=0 ; k<M ; k++){
        if(rArr[k] .equals(bArr[0])){
          System.out.println(0);
          return ;
        }
      }
      System.out.println(1);
      return ;
    }
    for(int i=0 ; i<N ; i++){
      if(bBoolArr[i]==true){
        count=1 ;
        for(int j=i+1 ; j<N ; j++){
          if(bArr[i] .equals(bArr[j])){
            bBoolArr[j]=false ;
            count++;
          }
        }
        for(int k=0 ; k<M ; k++){
          if(bArr[i] .equals(rArr[k])){
            count--;
          }
        }
      }
      if(count<1){
        count=0 ;
      }
      if(ans<count){
        ans=count ;
      }
      bBoolArr[i]=false ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := s.getCurrent()->toInteger() ;
     var bArr : Sequence(String) ; bArr := Integer.subrange(1,N)->collect(null) ;
    var bBoolArr : Sequence(boolean) ; bBoolArr := Integer.subrange(1,N)->collect(false) ;
        var i : int ; i := 0 ; while i < N do ( (     bArr[i+1] := s.getCurrent() ; 
     bBoolArr[i+1] := true )  ;     i := i + 1 ) ; 
    var M : int ; M := s.getCurrent()->toInteger() ;
    var rArr : Sequence(String) ; rArr := Integer.subrange(1,M)->collect(null) ;
        var i : int ; i := 0 ; while i < M do ( (     rArr[i+1] := s.getCurrent() )  ;     i := i + 1 ) ; 
    var count : int ; count := 1 ;
    var ans : int ; ans := 0 ;
    if (N = 1) then (         var k : int ; k := 0 ; while k < M do ( (     if (rArr[k+1] = bArr[0+1]) then (     OclFile["System.out"].println(0) ; 
     return ) else skip )  ;     k := k + 1 ) ; 
     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < N do ( (     if (bBoolArr[i+1] = true) then (     count := 1 ; 
         var j : int ; j := i + 1 ; while j < N do ( (     if (bArr[i+1] = bArr[j+1]) then (     bBoolArr[j+1] := false ; 
     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
         var k : int ; k := 0 ; while k < M do ( (     if (bArr[i+1] = rArr[k+1]) then (     count := count - 1 ) else skip )  ;     k := k + 1 ) ) else skip ; 
     if (count < 1) then (     count := 0 ) else skip ; 
     if (ans < count) then (     ans := count ) else skip ; 
     bBoolArr[i+1] := false )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    HashMap<String,Integer>map=new HashMap<>();
    int n=sc.nextInt();
    String s ;
    for(int i=0 ; i<n ; i++){
      s=sc.next();
      map.put(s,map.getOrDefault(s,0));
      map.put(s,map.get(s)+1);
    }
    int m=sc.nextInt();
    for(int i=0 ; i<m ; i++){
      s=sc.next();
      map.put(s,map.getOrDefault(s,0));
      map.put(s,map.get(s)-1);
    }
    int max=0 ;
    for(Map.Entry<String,Integer>e : map.entrySet()){
      max=Math.max(max,e.getValue());
    }
    out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var map : Map(String,int) ; map := Map{} ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ;
        var i : int ; i := 0 ; while i < n do ( (     s := sc.getCurrent() ; 
     map := map->union(Map{s |-> (if map->keys()->contains(s) then map->at(s) else 0 endif)}) ; 
     map := map->union(Map{s |-> map->at(s) + 1}) )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     s := sc.getCurrent() ; 
     map := map->union(Map{s |-> (if map->keys()->contains(s) then map->at(s) else 0 endif)}) ; 
     map := map->union(Map{s |-> map->at(s) - 1}) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    for (e : map->asSet()) do ( (     max := Set{max, e.getValue()}->max() )  ) ; 
    out.println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int K=sc.nextInt();
    char[][] arr=new char[h][w];
    for(int i=0 ; i<h ; i++){
      String s=sc.next();
      for(int j=0 ; j<s.length(); j++){
        arr[i][j]=s.charAt(j);
      }
    }
    int ans=0 ;
    for(int i=0 ; i<(1<<h); i++){
      for(int j=0 ; j<(1<<w); j++){
        int black=0 ;
        for(int k=0 ; k<h ; k++){
          for(int l=0 ; l<w ; l++){
            if(((i>>k)& 1)==0 &&((j>>l)& 1)==0 && arr[k][l]=='#'){
              black++;
            }
          }
        }
        if(black==K){
          ans++;
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(String)) ; arr := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (     var s : String ; s := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < s->size() do ( (     arr[i+1][j+1] := s->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < ((1*(2->pow(h)))->oclAsType(long)) do ( (         var j : int ; j := 0 ; while j < ((1*(2->pow(w)))->oclAsType(long)) do ( (     var black : int ; black := 0 ;
         var k : int ; k := 0 ; while k < h do ( (         var l : int ; l := 0 ; while l < w do ( (     if ((((i/(2->pow(k)))->oclAsType(long)) & 1) = 0 & (((j/(2->pow(l)))->oclAsType(long)) & 1) = 0 & arr[k+1][l+1] = '#') then (     black := black + 1 ) else skip )  ;     l := l + 1 ) )  ;     k := k + 1 ) ; 
     if (black = K) then (     ans := ans + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    HashMap<String,Integer>smap=new HashMap<String,Integer>();
    for(int i=0 ; i<n ; i++){
      String str=sc.next();
      Integer tmp=smap.get(str);
      if(tmp==null){
        smap.put(str,1);
      }
      else {
        smap.put(str,tmp+1);
      }
    }
    int m=sc.nextInt();
    HashMap<String,Integer>mmap=new HashMap<String,Integer>();
    for(int i=0 ; i<m ; i++){
      String str=sc.next();
      Integer tmp=mmap.get(str);
      if(tmp==null){
        mmap.put(str,1);
      }
      else {
        mmap.put(str,tmp+1);
      }
    }
    int max=0 ;
    for(String key : smap.keySet()){
      int val1=smap.get(key);
      Integer val2=mmap.get(key);
      if(val2==null){
        max=Math.max(max,val1);
      }
      else {
        max=Math.max(max,val1-val2);
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var smap : Map(String,int) ; smap := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := sc.getCurrent() ;
     var tmp : int ; tmp := smap->at(str) ;
     if (tmp = null) then (     smap := smap->union(Map{str |-> 1}) ) else (     smap := smap->union(Map{str |-> tmp + 1}) ) )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var mmap : Map(String,int) ; mmap := Map{} ;
        var i : int ; i := 0 ; while i < m do ( (     var str : String ; str := sc.getCurrent() ;
     var tmp : int ; tmp := mmap->at(str) ;
     if (tmp = null) then (     mmap := mmap->union(Map{str |-> 1}) ) else (     mmap := mmap->union(Map{str |-> tmp + 1}) ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    for (key : smap->keys()) do ( (     var val1 : int ; val1 := smap->at(key) ;
     var val2 : int ; val2 := mmap->at(key) ;
     if (val2 = null) then (     max := Set{max, val1}->max() ) else (     max := Set{max, val1 - val2}->max() ) )  ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int count=0 ;
    for(; scanner.hasNext(); ){
      String input=scanner.next();
      String inverse="" ;
      for(int i=input.length(); i>0 ; i--){
        inverse+=input.substring(i-1,i);
      }
      if(input.equals(inverse)){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := 0 ;
       while scanner.hasNext() do ( (     var input : String ; input := scanner.getCurrent() ;
     var inverse : String ; inverse := "" ;
         var i : int ; i := input->size() ; while i > 0 do ( (     inverse := inverse+(input.subrange((i)->char2byte() - 1+1,i)) )  ;     i := i - 1 ) ; 
     if (input = inverse) then (     count := count + 1 ) else skip )  ) ; 
     OclFile["System.out"].println(count) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    String stdin=null ;
    int cnt=0 ;
    int len=0 ;
    int fin=0 ;
    boolean rev=true ;
    while((stdin=parseStdin())!=null){
      rev=true ;
      len=stdin.length();
      fin=len/2 ;
      for(int n=0 ; n<fin ; n++){
        if(!(rev=(stdin.charAt(n)==stdin.charAt(len-1-n)))){
          break ;
        }
      }
      if(rev){
        cnt++;
      }
    }
    System.out.println(cnt);
  }
  private static String parseStdin(){
    String stdin=null ;
    try {
      String line=br.readLine();
      if(line!=null){
        if(! line.isEmpty()){
          stdin=line ;
        }
      }
    }
    catch(IOException e){
    }
    return stdin ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : String ; stdin := null ;
     var cnt : int ; cnt := 0 ;
    var len : int ; len := 0 ;
    var fin : int ; fin := 0 ;
    var rev : boolean ; rev := true ;
        stdin := parseStdin() ;
    while ((stdin) /= null) do (    skip ; (     rev := true ; 
     len := stdin->size() ; 
    fin := len / 2 ; 
        var n : int ; n := 0 ; while n < fin do ( (     if (not((rev))) then (     break ) else skip )  ;     n := n + 1 ) ; 
    if (rev) then (     cnt := cnt + 1 ) else skip ; 
 ) ;     stdin := parseStdin() ;
 ) ;  
    OclFile["System.out"].println(cnt) ; 
 );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var stdin : String ; stdin := null ;
     try (     var line : String ; line := br.readLine() ;
     if (line /= null) then (     if (not(line->isEmpty())) then (     stdin := line ) else skip ) else skip )   catch (e : IOException) do skip
     return stdin );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int A=sc.nextInt();
    HashMap<Integer,Long>tmpSum=new HashMap<>();
    for(int i=0 ; i<N ; i++){
      int diff=sc.nextInt()-A ;
      HashMap<Integer,Long>prevMap=new HashMap<>(tmpSum);
      for(int key : prevMap.keySet()){
        addCountMap(tmpSum,key+diff,prevMap.get(key));
      }
      addCountMap(tmpSum,diff,1);
    }
    sc.close();
    long result ;
    if(tmpSum.get(0)!=null){
      result=tmpSum.get(0);
    }
    else {
      result=0 ;
    }
    System.out.println(result);
  }
  private static void addCountMap(HashMap<Integer,Long>map,int key,long count){
    if(map.get(key)==null){
      map.put(key,count);
    }
    else {
      map.put(key,map.get(key)+count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var tmpSum : Map(int,long) ; tmpSum := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     var diff : int ; diff := sc.getCurrent()->toInteger() - A ;
     var prevMap : Map(int,long) ; prevMap := Map{}->union(tmpSum) ;
     for (key : prevMap->keys()) do ( (     execute addCountMap(tmpSum, key + diff, prevMap->at(key)) )  ) ; 
     execute addCountMap(tmpSum, diff, 1) )  ;     i := i + 1 ) ; 
    skip ; 
    var result : long ;
    if (tmpSum->at(0) /= null) then (     result := tmpSum->at(0) ) else (     result := 0 ) ;  
    OclFile["System.out"].println(result) ; 
 );
  static   operation addCountMap( map : Map(int,long), key : int, count : long) : void
  pre: true
  post: true
  activity: (     if (map->at(key+1) = null) then (     map := map->union(Map{key |-> count}) ) else (     map := map->union(Map{key |-> map->at(key+1) + count}) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] a=new long[n];
    long[] b=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
    }
    for(int i=0 ; i<n ; i++){
      b[i]=sc.nextLong();
    }
    long[] fig=new long[29];
    long ans=0 ;
    for(int i=0 ; i<30 ; i++){
      long t=1<<i ;
      long count=0 ;
      long[] aa=new long[n];
      long[] bb=new long[n];
      for(int j=0 ; j<n ; j++){
        aa[j]=a[j] %(2*t);
        bb[j]=b[j] %(2*t);
      }
      Arrays.sort(bb);
      for(int k=0 ; k<n ; k++){
        count+=lowerBounds(bb,2*t-aa[k])-lowerBounds(bb,t-aa[k]);
        count+=n-lowerBounds(bb,3*t-aa[k]);
      }
      ans |=(count & 1)<<i ;
    }
    System.out.println(ans);
  }
  public static int lowerBounds(long[] arr,long value){
    int low=0 ;
    int high=arr.length ;
    int mid ;
    while(high>low){
      mid=((high-low)>>>1)+low ;
      if(arr[mid]<value){
        low=mid+1 ;
      }
      else {
        high=mid ;
      }
    }
    return low ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var fig : Sequence(long) ; fig := Integer.subrange(1,29)->collect(0) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < 30 do ( (     var t : long ; t := (1*(2->pow(i)))->oclAsType(long) ;
     var count : long ; count := 0 ;
    var aa : Sequence(long) ; aa := Integer.subrange(1,n)->collect(0) ;
    var bb : Sequence(long) ; bb := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     aa[j+1] := a[j+1] mod (2 * t) ; 
     bb[j+1] := b[j+1] mod (2 * t) )  ;     j := j + 1 ) ; 
    bb := bb->sort() ; 
        var k : int ; k := 0 ; while k < n do ( (     count := count+(lowerBounds(bb, 2 * t - aa[k+1]) - lowerBounds(bb, t - aa[k+1])) ; 
     count := count+(n - lowerBounds(bb, 3 * t - aa[k+1])) )  ;     k := k + 1 ) ; 
    ans := MathLib.bitwiseOr(ans, ((MathLib.bitwiseAnd(count,1))*(2->pow(i)))->oclAsType(long)) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation lowerBounds( arr : Sequence(long), value : long) : int
  pre: true
  post: true
  activity: (     var low : int ; low := 0 ;
     var high : int ; high := arr->size() ;
    var mid : int ;
    while (high > low) do (     mid := (((high - low)/(2->pow(1)))->oclAsType(long)) + low ; 
     if (arr[mid+1] < value) then (     low := mid + 1 ) else (     high := mid ) ) ; 
    return low 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    List<String>wordList=new ArrayList<String>();
    while(stdIn.hasNext()){
      wordList.add(stdIn.next());
    }
    int simmetryCount=0 ;
    for(String i : wordList){
      int iDotLength=i.length();
      for(int j=0 ; j<iDotLength ; j++){
        if(i.charAt(j)!=i.charAt(iDotLength-1-j)){
          break ;
        }
        else if(iDotLength==1 || i.charAt(j)==i.charAt(iDotLength-1-j)&& j>=iDotLength-1-j){
          simmetryCount++;
          break ;
        }
      }
    }
    System.out.println(simmetryCount);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var wordList : Sequence(String) ; wordList := Sequence{} ;
    while (stdIn.hasNext()) do (     wordList := wordList->including(stdIn.getCurrent()) ) ; 
    var simmetryCount : int ; simmetryCount := 0 ;
    for (i : wordList) do ( (     var iDotLength : int ; iDotLength := i->size() ;
         var j : int ; j := 0 ; while j < iDotLength do ( (     if (i->at(j+1) /= i->at(iDotLength - 1 - j+1)) then (     break ) else     if (iDotLength = 1 or i->at(j+1) = i->at(iDotLength - 1 - j+1) & j >= iDotLength - 1 - j) then (     simmetryCount := simmetryCount + 1 ; 
     break ) else skip ; )  ;     j := j + 1 ) )  ) ; 
    OclFile["System.out"].println(simmetryCount) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PalindromeCounter pc=new PalindromeCounter();
    while(true){
      String str=br.readLine();
      if(str==null){
        break ;
      }
      pc.setString(str);
    }
    System.out.println(pc.getCount());
  }
}
class PalindromeCounter {
  int count=0 ;
  public void setString(String str){
    StringBuffer sb=new StringBuffer(str);
    sb.reverse();
    if(str.equals(sb.toString())){
      count++;
    }
  }
  public int getCount(){
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pc : PalindromeCounter ; pc := PalindromeCounter.newPalindromeCounter() ;
     while (true) do (     var str : String ; str := br.readLine() ;
     if (str = null) then (     break ) else skip ; 
     pc.setString(str) ) ; 
     OclFile["System.out"].println(pc.getCount()) );
}
class PalindromeCounter {
   attribute count : int := 0;
   operation setString( str : String) : void
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString(str) ;
     sb := sb->reverse() ; 
     if (str = sb+"") then (     count := count + 1 ) else skip );
   operation getCount() : int
  pre: true
  post: true
  activity: (     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws java.io.IOException {
    Scanner scan=new Scanner(System.in);
    int count=0 ;
    while(scan.hasNext()){
      String text=scan.next();
      int out=0 ;
      char character[]=text.toCharArray();
      if(character.length==1){
++count ;
      }
      else {
        for(int i=0 ; i<(character.length)/2 ; i++){
          for(int j=character.length-1-i ; j>character.length-2-i ; j--){
            if(character[i]==character[j]){
              if(i==(character.length)/2-1){
++count ;
              }
            }
            else {
              out=1 ;
              break ;
            }
          }
          if(out==1){
            break ;
          }
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := 0 ;
     while (scan.hasNext()) do (     var text : String ; text := scan.getCurrent() ;
     var out : int ; out := 0 ;
     var character : Sequence(String) ; character := text->characters() ;
     if (character->size() = 1) then (     count := count + 1 ) else (         var i : int ; i := 0 ; while i < (character->size()) / 2 do ( (         var j : int ; j := character->size() - 1 - (i)->char2byte() ; while j > character->size() - 2 - (i)->char2byte() do ( (     if (character[i+1] = character[j+1]) then (     if (i = (character->size()) / 2 - 1) then (     count := count + 1 ) else skip ) else (     out := 1 ; 
     break ) )  ;     j := j - 1 ) ; 
     if (out = 1) then (     break ) else skip )  ;     i := i + 1 ) ) ) ; 
     OclFile["System.out"].println(count) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static String prefixSuffix(String a,String b,int l){
    String prefix=a.substring(0,l);
    int lb=b.length();
    String suffix=b.substring(lb-l);
    return(prefix+suffix);
  }
  public static void main(String args[])throws IOException {
    String a="remuneration",b="acquiesce" ;
    int l=5 ;
    System.out.println(prefixSuffix(a,b,l));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation prefixSuffix( a : String, b : String, l : int) : String
  pre: true
  post: true
  activity: (     var prefix : String ; prefix := a.subrange(0+1,l) ;
     var lb : int ; lb := b->size() ;
     var suffix : String ; suffix := b.subrange((lb)->char2byte() - l+1,(lb)->char2byte() - l) ;
     return (prefix + suffix) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ; a := "remuneration" ;
    var b : String ; b := "acquiesce" ;
     var l : int ; l := 5 ;
     OclFile["System.out"].println(prefixSuffix(a, b, l)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=2*in.nextInt();
    int[] a=new int[n];
    Arrays.setAll(a,i->in.nextInt());
    Arrays.sort(a);
    pw.println(a[n/2]==a[n/2-1] ? "NO" : "YES");
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := 2 * in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
setAll(a, lambda i : OclAny in in.getCurrent()->toInteger()) ; 
    a := a->sort() ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    C solver=new C();
    solver.solve(1,in,out);
    out.close();
  }
  static class C {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int h=Integer.parseInt(in.next());
      int w=Integer.parseInt(in.next());
      int k=Integer.parseInt(in.next());
      char[][] c=new char[h][w];
      for(int i=0 ; i<h ; i++){
        c[i]=in.next().toCharArray();
      }
      int ans=0 ;
      for(int bith=0 ; bith<(1<<h); ++bith){
        for(int bitw=0 ; bitw<(1<<w); ++bitw){
          int black=0 ;
          for(int i=0 ; i<h ; i++){
            if((bith &(1<<i))==0)continue ;
            for(int j=0 ; j<w ; j++){
              if((bitw &(1<<j))==0)continue ;
              if(c[i][j]=='#')black++;
            }
          }
          if(black==k)ans++;
        }
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : C ; solver := C.newC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class C {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var h : int ; h := (in.getCurrent())->toInteger() ;
     var w : int ; w := (in.getCurrent())->toInteger() ;
    var k : int ; k := (in.getCurrent())->toInteger() ;
    var c : Sequence(Sequence(String)) ; c := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (     c[i+1] := in.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var bith : int ; bith := 0 ; while bith < ((1*(2->pow(h)))->oclAsType(long)) do ( (         var bitw : int ; bitw := 0 ; while bitw < ((1*(2->pow(w)))->oclAsType(long)) do ( (     var black : int ; black := 0 ;
         var i : int ; i := 0 ; while i < h do ( (     if ((MathLib.bitwiseAnd(bith,((1*(2->pow(i)))->oclAsType(long)))) = 0) then     continue else skip ; 
         var j : int ; j := 0 ; while j < w do ( (     if ((MathLib.bitwiseAnd(bitw,((1*(2->pow(j)))->oclAsType(long)))) = 0) then     continue else skip ; 
     if (c[i+1][j+1] = '#') then     black := black + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (black = k) then     ans := ans + 1 ; else skip )  ;     bitw := bitw + 1 ) )  ;     bith := bith + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class ChessTourney {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=2*Integer.parseInt(input.nextLine());
    int[] ranks=new int[n];
    for(int i=0 ; i<n ; i++)ranks[i]=input.nextInt();
    Arrays.sort(ranks);
    for(int i=0,j=n-1 ; i<n/2 ; i++,j--){
      if(ranks[j]<=ranks[i]){
        System.out.println("NO");
        return ;
      }
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class ChessTourney {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := 2 * (input.nextLine())->toInteger() ;
    var ranks : Sequence(int) ; ranks := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     ranks[i+1] := input.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    ranks := ranks->sort() ; 
        var i : int ; i := 0 ;
    var j : int ; j := n - 1 ; while i < n / 2 do ( (     if (ranks[j+1] <= ranks[i+1]) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ;     i := i + 1 ;     j := j - 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[2*n];
    for(int i=0 ; i<a.length ; i++){
      a[i]=sc.nextInt();
    }
    Arrays.sort(a);
    if(a[n-1]<a[n])System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,2 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    if (a[n - 1+1] < a[n+1]) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int solve(int n,int base){
    int result=0 ;
    while(n>0){
      int remainder=n % base ;
      result=result+remainder ;
      n=n/base ;
    }
    return result ;
  }
  static void printSumsOfDigits(int n){
    for(int base=2 ; base<n ; ++base)System.out.print(solve(n,base)+" ");
  }
  public static void main(String[] args){
    int n=8 ;
    printSumsOfDigits(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( n : int, base : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     while (n > 0) do (     var remainder : int ; remainder := n mod base ;
     result := result + remainder ; 
     n := n / base ) ; 
     return result );
  static   operation printSumsOfDigits( n : int) : void
  pre: true
  post: true
  activity: (         var base : int ; base := 2 ; while base < n do (     OclFile["System.out"].print(solve(n, base) + " ") ;  ;     base := base + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     execute printSumsOfDigits(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class Test {
  static int maxModValue(int arr[],int n){
    int ans=0 ;
    Arrays.sort(arr);
    for(int j=n-2 ; j>=0 ; --j){
      if(ans>=arr[j])break ;
      if(arr[j]==arr[j+1])continue ;
      for(int i=2*arr[j]; i<=arr[n-1]+arr[j]; i+=arr[j]){
        int ind=Arrays.binarySearch(arr,i);
        if(ind<0)ind=Math.abs(ind+1);
        else {
          while(arr[ind]==i){
            ind--;
            if(ind==0){
              ind=-1 ;
              break ;
            }
          }
          ind++;
        }
        ans=Math.max(ans,arr[ind-1] % arr[j]);
      }
    }
    return ans ;
  }
  public static void main(String args[]){
    int arr[]={
      3,4,5,9,11 };
      System.out.println(maxModValue(arr,arr.length));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation maxModValue( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     arr := arr->sort() ; 
         var j : int ; j := n - 2 ; while j >= 0 do ( (     if (ans >= arr[j+1]) then     break else skip ; 
     if (arr[j+1] = arr[j + 1+1]) then     continue else skip ; 
         var i : int ; i := 2 * arr[j+1] ; while i <= arr[n - 1+1] + arr[j+1] do ( (     var ind : int ; ind := (arr->indexOf(i) - 1) ;
     if (ind < 0) then     ind := if ind + 1 < 0 then -(ind + 1) else ind + 1 endif else (     while (arr[ind+1] = i) do (     ind := ind - 1 ; 
     if (ind = 0) then (     ind := -1 ; 
     break ) else skip ) ; 
     ind := ind + 1 ) ;  
     ans := Set{ans, arr[ind - 1+1] mod arr[j+1]}->max() )  ;     i := i+(arr[j+1]) ) )  ;     j := j - 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,4,5,9,11} ;
     OclFile["System.out"].println(maxModValue(arr, arr->size())) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    int idx=-1,max=-1 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      if(a[i]>max){
        max=a[i];
        idx=i ;
      }
    }
    boolean flag=true ;
    for(int i=idx+2 ; i<n ; i++){
      if(a[i]>a[i-1])flag=false ;
    }
    if(flag){
      for(int i=idx-2 ; i>=0 ; i--){
        if(a[i]>a[i+1])flag=false ;
      }
    }
    if(flag)System.out.println("YES");
    else System.out.println("NO");
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var idx : int ; idx := -1 ;
    var max : int ; max := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (a[i+1] > max) then (     max := a[i+1] ; 
     idx := i ) else skip )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := true ;
        var i : int ; i := idx + 2 ; while i < n do ( (     if (a[i+1] > a[i - 1+1]) then     flag := false ; else skip )  ;     i := i + 1 ) ; 
    if (flag) then (         var i : int ; i := idx - 2 ; while i >= 0 do ( (     if (a[i+1] > a[i + 1+1]) then     flag := false ; else skip )  ;     i := i - 1 ) ) else skip ; 
    if (flag) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static int a[],b[];
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    a=new int[n];
    b=new int[n];
    st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(st.nextToken());
    }
    st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<n ; i++){
      b[i]=Integer.parseInt(st.nextToken());
    }
    int ans=0 ;
    for(int i=29 ; i>=1 ; i--){
      int cntone=0 ;
      int T=1<<(i-1);
      for(int j=0 ; j<n ; j++){
        b[j]=b[j] &(2*T-1);
      }
      for(int j=0 ; j<n ; j++){
        a[j]=a[j] &(2*T-1);
      }
      Arrays.sort(a);
      Arrays.sort(b);
      int p1=0,p2=0,p3=0 ;
      for(int j=n-1 ; j>=0 ; j--){
        while(p1<n && a[j]+b[p1]<T)p1++;
        while(p2<n && a[j]+b[p2]<2*T)p2++;
        while(p3<n && a[j]+b[p3]<3*T)p3++;
        cntone+=(p2-p1)+(n-p3);
        cntone &=1 ;
      }
      if(cntone % 2==1)ans |=T ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    a := Integer.subrange(1,n)->collect(0) ; 
    b := Integer.subrange(1,n)->collect(0) ; 
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 29 ; while i >= 1 do ( (     var cntone : int ; cntone := 0 ;
     var T : int ; T := (1*(2->pow((i - 1))))->oclAsType(long) ;
        var j : int ; j := 0 ; while j < n do ( (     b[j+1] := b[j+1] & (2 * T - 1) )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     a[j+1] := a[j+1] & (2 * T - 1) )  ;     j := j + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    var p1 : int ; p1 := 0 ;
    var p2 : int ; p2 := 0 ;
    var p3 : int ; p3 := 0 ;
        var j : int ; j := n - 1 ; while j >= 0 do ( (     while (p1 < n & a[j+1] + b[p1+1] < T) do     p1 := p1 + 1 ; ; 
     while (p2 < n & a[j+1] + b[p2+1] < 2 * T) do     p2 := p2 + 1 ; ; 
    while (p3 < n & a[j+1] + b[p3+1] < 3 * T) do     p3 := p3 + 1 ; ; 
    cntone := cntone+((p2 - p1) + (n - p3)) ; 
    cntone := MathLib.bitwiseAnd(cntone, 1) ; 
 )  ;     j := j - 1 ) ; 
    if (cntone mod 2 = 1) then     ans := MathLib.bitwiseOr(ans, T) ; else skip ; 
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class pillars {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,a[],i,max,p ;
    n=sc.nextInt();
    a=new int[n];
    for(i=0 ; i<n ; i++)a[i]=sc.nextInt();
    max=a[0];
    p=0 ;
    for(i=1 ; i<n ; i++){
      if(a[i]>max){
        max=a[i];
        p=i ;
      }
    }
    for(i=p+1 ; i<n-1 ; i++){
      if(a[i]<a[i+1])break ;
    }
    if(i!=n-1 && i!=n){
      System.out.println("NO");
      System.exit(0);
    }
    for(i=p-1 ; i>0 ; i--){
      if(a[i]<a[i-1])break ;
    }
    if(i==0 || i==-1)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class pillars {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var a : Sequence(void) ;
    var i : int ;
    var max : int ;
    var p : int ;
    n := sc.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
        i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    max := a[0+1] ; 
    p := 0 ; 
        i := 1 ; while i < n do ( (     if (a[i+1] > max) then (     max := a[i+1] ; 
     p := i ) else skip )  ;     i := i + 1 ) ; 
        i := p + 1 ; while i < n - 1 do ( (     if (a[i+1] < a[i + 1+1]) then     break else skip )  ;     i := i + 1 ) ; 
    if (i /= n - 1 & i /= n) then (     OclFile["System.out"].println("NO") ; 
 OclProcess.exit(0) ) else skip ; 
        i := p - 1 ; while i > 0 do ( (     if (a[i+1] < a[i - 1+1]) then     break else skip )  ;     i := i - 1 ) ; 
    if (i = 0 or i = -1) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minOperations(String str,int n){
    int count=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if(str.charAt(i)!=str.charAt(i+1))count++;
    }
    return(count+1)/2 ;
  }
  public static void main(String[] args){
    String str="000111" ;
    int n=str.length();
    System.out.println(minOperations(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minOperations( str : String, n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     if (str->at(i+1) /= str->at(i + 1+1)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return (count + 1) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "000111" ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].println(minOperations(str, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str[]=br.readLine().split("");
    int ans=0 ;
    int now=0 ;
    for(int i=0 ; i<str.length ; i++){
      if(str[i] .equals("(")){
        now++;
      }
      else if(str[i] .equals(")")){
        now--;
      }
      else {
        ans=now ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split("") ;
    var ans : int ; ans := 0 ;
    var now : int ; now := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str[i+1] = "(") then (     now := now + 1 ) else     if (str[i+1] = ")") then (     now := now - 1 ) else (     ans := now ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=br.readLine();
    while(str.contains("()")){
      str=str.replaceAll("\\(\\)","");
    }
    char[] input=str.toCharArray();
    int starIndex=0 ;
    for(int i=0 ; i<input.length ; i++){
      if(input[i]=='*'){
        starIndex=i ;
      }
    }
    int left=starIndex-1 ;
    int right=starIndex+1 ;
    int result=0 ;
    while(left>=0){
      if(input[left]=='('){
        while(right<=input.length-1){
          if(input[right]==')'){
            result++;
            break ;
          }
          right++;
        }
      }
      left--;
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := br.readLine() ;
    while (str->includes("()")) do (     str := str.replaceAllMatches("\\(\\)", "" ) ) ; 
    var input : Sequence(String) ; input := str->characters() ;
    var starIndex : int ; starIndex := 0 ;
        var i : int ; i := 0 ; while i < input->size() do ( (     if (input[i+1] = '*') then (     starIndex := i ) else skip )  ;     i := i + 1 ) ; 
    var left : int ; left := starIndex - 1 ;
    var right : int ; right := starIndex + 1 ;
    var result : int ; result := 0 ;
    while (left >= 0) do (     if (input[left+1] = '(') then (     while (right <= input->size() - 1) do (     if (input[right+1] = ')') then (     result := result + 1 ; 
     break ) else skip ; 
     right := right + 1 ) ) else skip ; 
     left := left - 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int k=sc.nextInt();
    ArrayList<String[]>c=new ArrayList<>();
    for(int i=0 ; i<h ; i++){
      c.add(sc.next().split(""));
    }
    int result=0 ;
    int hb=(int)Math.pow(2,h);
    int wb=(int)Math.pow(2,w);
    for(int i=0 ; i<hb ; i++){
      String hTmp="000000"+Integer.toString(i,2);
      String hSt=hTmp.substring(hTmp.length()-h);
      ArrayList<String[]>selectedRows=new ArrayList<>();
      for(int hi=0 ; hi<h ; hi++){
        if(hSt.charAt(hi)=='1'){
          selectedRows.add(c.get(hi));
        }
      }
      for(int j=0 ; j<wb ; j++){
        String wTmp="000000"+Integer.toString(j,2);
        String wSt=wTmp.substring(wTmp.length()-w);
        ArrayList<Integer>selectedIndex=new ArrayList<>();
        for(int wi=0 ; wi<w ; wi++){
          if(wSt.charAt(wi)=='1'){
            selectedIndex.add(wi);
          }
        }
        int count=0 ;
        for(String[] strings : selectedRows){
          for(int wi : selectedIndex){
            if("#".equals(strings[wi])){
              count++;
            }
          }
        }
        if(count==k){
          result++;
        }
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var c : Sequence(Sequence(String)) ; c := Sequence{} ;
        var i : int ; i := 0 ; while i < h do ( (     c := c->including(sc.getCurrent()->split("")) )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
    var hb : int ; hb := 2->pow(h)->oclAsType(int) ;
    var wb : int ; wb := 2->pow(w)->oclAsType(int) ;
        var i : int ; i := 0 ; while i < hb do ( (     var hTmp : String ; hTmp := "000000" + ((i) + "") ;
     var hSt : String ; hSt := hTmp.subrange(hTmp->size() - h+1,hTmp->size() - h) ;
    var selectedRows : Sequence(Sequence(String)) ; selectedRows := Sequence{} ;
        var hi : int ; hi := 0 ; while hi < h do ( (     if (hSt->at(hi+1) = '1') then (     selectedRows := selectedRows->including(c->at(hi+1)) ) else skip )  ;     hi := hi + 1 ) ; 
        var j : int ; j := 0 ; while j < wb do ( (     var wTmp : String ; wTmp := "000000" + ((j) + "") ;
     var wSt : String ; wSt := wTmp.subrange(wTmp->size() - w+1,wTmp->size() - w) ;
    var selectedIndex : Sequence(int) ; selectedIndex := Sequence{} ;
        var wi : int ; wi := 0 ; while wi < w do ( (     if (wSt->at(wi+1) = '1') then (     selectedIndex := selectedIndex->including(wi) ) else skip )  ;     wi := wi + 1 ) ; 
    var count : int ; count := 0 ;
    for (strings : selectedRows) do ( (     for (wi : selectedIndex) do ( (     if ("#" = strings[wi+1]) then (     count := count + 1 ) else skip )  ) )  ) ; 
    if (count = k) then (     result := result + 1 ) else skip ; 
 )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long mulmod(long a,long b,long mod){
    long res=0 ;
    a=a % mod ;
    while(b>0){
      if(b % 2==1){
        res=(res+a)% mod ;
      }
      a=(a*2)% mod ;
      b/=2 ;
    }
    return res % mod ;
  }
  public static void main(String[] args){
    long a=9223372036854775807L,b=9223372036854775807L ;
    System.out.println(mulmod(a,b,100000000000L));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation mulmod( a : long, b : long, mod : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 0 ;
     a := a mod mod ; 
     while (b > 0) do (     if (b mod 2 = 1) then (     res := (res + a) mod mod ) else skip ; 
     a := (a * 2) mod mod ; 
     b := b/(2) ) ; 
     return res mod mod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ; a := 9223372036854775807L ;
    var b : long ; b := 9223372036854775807L ;
     OclFile["System.out"].println(mulmod(a, b, 100000000000L)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int parity(int a){
    return a % 3 ;
  }
  static int solve(int[] array,int size){
    int operations=0 ;
    for(int i=0 ; i<size-1 ; i++){
      if(parity(array[i])==parity(array[i+1])){
        operations++;
        if(i+2<size){
          int pari1=parity(array[i]);
          int pari2=parity(array[i+2]);
          if(pari1==pari2){
            if(pari1==0)array[i+1]=1 ;
            else if(pari1==1)array[i+1]=0 ;
            else array[i+1]=1 ;
          }
          else {
            if((pari1==0 && pari2==1)||(pari1==1 && pari2==0))array[i+1]=2 ;
            if((pari1==1 && pari2==2)||(pari1==2 && pari2==1))array[i+1]=0 ;
            if((pari1==2 && pari2==0)||(pari1==0 && pari2==2))array[i+1]=1 ;
          }
        }
      }
    }
    return operations ;
  }
  public static void main(String arg[]){
    int[] array={
      2,1,3,0 };
      int size=array.length ;
      System.out.println(solve(array,size));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation parity( a : int) : int
  pre: true
  post: true
  activity: (     return a mod 3 );
  static   operation solve( array : Sequence(int), size : int) : int
  pre: true
  post: true
  activity: (     var operations : int ; operations := 0 ;
         var i : int ; i := 0 ; while i < size - 1 do ( (     if (parity(array[i+1]) = parity(array[i + 1+1])) then (     operations := operations + 1 ; 
     if (i + 2 < size) then (     var pari1 : int ; pari1 := parity(array[i+1]) ;
     var pari2 : int ; pari2 := parity(array[i + 2+1]) ;
     if (pari1 = pari2) then (     if (pari1 = 0) then     array[i + 1+1] := 1 ; else     if (pari1 = 1) then     array[i + 1+1] := 0 else     array[i + 1+1] := 1 ; ;  ) else (     if ((pari1 = 0 & pari2 = 1) or (pari1 = 1 & pari2 = 0)) then     array[i + 1+1] := 2 ; else skip ; 
     if ((pari1 = 1 & pari2 = 2) or (pari1 = 2 & pari2 = 1)) then     array[i + 1+1] := 0 ; else skip ; 
     if ((pari1 = 2 & pari2 = 0) or (pari1 = 0 & pari2 = 2)) then     array[i + 1+1] := 1 ; else skip ) ) else skip ) else skip )  ;     i := i + 1 ) ; 
     return operations );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Sequence{2,1,3,0} ;
     var size : int ; size := array->size() ;
     OclFile["System.out"].println(solve(array, size)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findSDSFunc(int n){
    int DP[]=new int[n+1];
    DP[0]=0 ;
    DP[1]=1 ;
    for(int i=2 ; i<=n ; i++){
      if(i % 2==0)DP[i]=DP[i/2];
      else DP[i]=DP[(i-1)/2]+DP[(i+1)/2];
    }
    return DP[n];
  }
  public static void main(String[] args){
    int n=15 ;
    System.out.println(findSDSFunc(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findSDSFunc( n : int) : int
  pre: true
  post: true
  activity: (     var DP : Sequence(int) ; DP := Integer.subrange(1,n + 1)->collect(0) ;
     DP[0+1] := 0 ; 
    DP[1+1] := 1 ; 
        var i : int ; i := 2 ; while i <= n do ( (     if (i mod 2 = 0) then     DP[i+1] := DP[i / 2+1] ; else     DP[i+1] := DP[(i - 1) / 2+1] + DP[(i + 1) / 2+1] ; )  ;     i := i + 1 ) ; 
    return DP[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     OclFile["System.out"].println(findSDSFunc(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class C {
  public static void main(String...orange)throws Exception {
    Scanner input=new Scanner(System.in);
    int numCases=input.nextInt();
    for(int n=0 ; n<numCases ; n++){
      int N=input.nextInt();
      int[] arr=new int[N];
      for(int i=0 ; i<N ; i++)arr[i]=input.nextInt();
      int[] data=new int[2*N];
      for(int i=0 ; i<N ; i++)data[arr[i]-i+N]++;
      double score=0 ;
      for(int i=700 ; i<1000 ; i++)score+=data[i];
      for(int i=1000 ; i<1300 ; i++)score-=data[i];
      boolean good=score>-40 ;
      System.out.printf("Case #%d: ",n+1);
      if(good)System.out.println("GOOD");
      else System.out.println("BAD");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( orange : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numCases : int ; numCases := input.getCurrent()->toInteger() ;
         var n : int ; n := 0 ; while n < numCases do ( (     var N : int ; N := input.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     arr[i+1] := input.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var data : Sequence(int) ; data := Integer.subrange(1,2 * N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     data[arr[i+1] - i + N+1] := data[arr[i+1] - i + N+1] + 1 ;  ;     i := i + 1 ) ; 
    var score : double ; score := 0 ;
        var i : int ; i := 700 ; while i < 1000 do (     score := score+(data[i+1]) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1000 ; while i < 1300 do (     score := score-(data[i+1]) ;  ;     i := i + 1 ) ; 
    var good : boolean ; good := score > -40 ;
    OclFile["System.out"].printf("Case #%d: ", n + 1) ; 
    if (good) then     OclFile["System.out"].println("GOOD") else     OclFile["System.out"].println("BAD") ; ;  
 )  ;     n := n + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class ProperShuffle {
  public final static String INPUT_FILE_NAME="C-small-attempt0(1).in" ;
  public final static String OUTPUT_FILE_NAME="ProperShuffle.out" ;
  public static void main(String[] args){
    try(Scanner in=new Scanner(new FileReader(INPUT_FILE_NAME));
    PrintWriter out=new PrintWriter(new FileWriter(OUTPUT_FILE_NAME))){
      double[][] rv=new double[1000][1000];
      for(int t=0 ; t<1000 ; t++){
        double[] cv=new double[1000];
        for(int i=0 ; i<1000 ; i++){
          if(i==t){
            cv[i]=1 ;
          }
          else {
            cv[i]=0 ;
          }
        }
        for(int i=0 ; i<1000 ; i++){
          double[] nv=new double[1000];
          for(int j=0 ; j<1000 ; j++){
            if(i!=j){
              nv[j]=cv[j]*.999+cv[i]*.001 ;
            }
          }
          nv[i]=.001 ;
          cv=nv ;
        }
        rv[t]=cv ;
      }
      System.out.println("done");
      int numT=in.nextInt();
      int res=0 ;
      for(int t=1 ; t<=numT ; t++){
        in.nextInt();
        double total=0 ;
        for(int i=0 ; i<1000 ; i++){
          int v=in.nextInt();
          total+=rv[v][i];
        }
        if(total<=1.005){
          out.println("Case #"+t+": GOOD");
          res++;
        }
        else {
          out.println("Case #"+t+": BAD");
        }
      }
      System.out.println(res);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProperShuffle {
  static   attribute INPUT_FILE_NAME : String := "C-small-attempt0(1).in";
  static   attribute OUTPUT_FILE_NAME : String := "ProperShuffle.out";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(INPUT_FILE_NAME))) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile(OUTPUT_FILE_NAME))) ;
 (     var rv : Sequence(Sequence(double)) ; rv := Integer.subrange(1,1000)->collect(Integer.subrange(1,1000)->collect(0.0)) ;
         var t : int ; t := 0 ; while t < 1000 do ( (     var cv : Sequence(double) ; cv := Integer.subrange(1,1000)->collect(0.0) ;
         var i : int ; i := 0 ; while i < 1000 do ( (     if (i = t) then (     cv[i+1] := 1 ) else (     cv[i+1] := 0 ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < 1000 do ( (     var nv : Sequence(double) ; nv := Integer.subrange(1,1000)->collect(0.0) ;
         var j : int ; j := 0 ; while j < 1000 do ( (     if (i /= j) then (     nv[j+1] := cv[j+1] * .999 + cv[i+1] * .001 ) else skip )  ;     j := j + 1 ) ; 
     nv[i+1] := .001 ; 
     cv := nv )  ;     i := i + 1 ) ; 
     rv[t+1] := cv )  ;     t := t + 1 ) ; 
    OclFile["System.out"].println("done") ; 
    var numT : int ; numT := in.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
        var t : int ; t := 1 ; while t <= numT do ( (     skip ; 
     var total : double ; total := 0 ;
         var i : int ; i := 0 ; while i < 1000 do ( (     var v : int ; v := in.getCurrent()->toInteger() ;
     total := total+(rv[v+1][i+1]) )  ;     i := i + 1 ) ; 
     if (total <= 1.005) then (     skip ; 
     res := res + 1 ) else (     skip ) )  ;     t := t + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 ))   catch (e : IOException) do (     e.printStackTrace() )
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileInputStream ;
import java.util.Arrays ;
import java.util.Random ;
import java.util.Scanner ;
public class ProperShuffle {
  static Random random=new Random();
  private static String file="data/r1c-C-small-attempt0.in" ;
  private static final int LEN=1000 ;
  private static final int TRY_COUNT=1000*LEN ;
  public static void main(String[] args)throws Exception {
    FileInputStream is=new FileInputStream(new File(file));
    Scanner scanner=new Scanner(is);
    int[][] count=new int[LEN][LEN];
    int[] arr=new int[LEN];
    for(int i=0 ; i<LEN ; i++){
      arr[i]=i ;
    }
    for(int i=0 ; i<TRY_COUNT ; i++){
      int[] copy=arr.clone();
      shuffle(copy);
      for(int j=0 ; j<LEN ; j++){
        count[copy[j] ][j]++;
      }
    }
    int T=scanner.nextInt();
    for(int t=0 ; t<T ; t++){
      int n=scanner.nextInt();
      double prob=1.0 ;
      for(int i=0 ; i<n ; i++){
        int s=scanner.nextInt();
        prob*=(double)count[s][i]/(double)(TRY_COUNT/LEN);
      }
      if(prob>1.0){
        out(t,"BAD");
      }
      else {
        out(t,"GOOD");
      }
    }
  }
  static void shuffle(int arr[]){
    int len=arr.length ;
    for(int k=0 ; k<len ; k++){
      int p=random.nextInt(len);
      int t=arr[p];
      arr[p]=arr[k];
      arr[k]=t ;
    }
  }
  static void out(int t,Object ans){
    System.out.println("Case #"+(t+1)+": "+ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProperShuffle {
  static   attribute random : OclRandom := OclRandom.newOclRandom();
  static   attribute file : String := "data/r1c-C-small-attempt0.in";
  static    attribute LEN : int := 1000;
  static    attribute TRY_COUNT : int := 1000 * LEN;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile(file)) ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(is) ;
    var count : Sequence(Sequence(int)) ; count := Integer.subrange(1,LEN)->collect(Integer.subrange(1,LEN)->collect(0)) ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,LEN)->collect(0) ;
        var i : int ; i := 0 ; while i < LEN do ( (     arr[i+1] := i )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < TRY_COUNT do ( (     var copy : Sequence(int) ; copy := arr->copy() ;
     execute shuffle(copy) ; 
         var j : int ; j := 0 ; while j < LEN do ( (     count[copy[j+1]+1][j+1] := count[copy[j+1]+1][j+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var T : int ; T := scanner.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < T do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var prob : double ; prob := 1.0 ;
         var i : int ; i := 0 ; while i < n do ( (     var s : int ; s := scanner.getCurrent()->toInteger() ;
     prob := prob*(count[s+1][i+1]->oclAsType(double) / (TRY_COUNT / LEN)->oclAsType(double)) )  ;     i := i + 1 ) ; 
     if (prob > 1.0) then (     execute out(t, "BAD") ) else (     execute out(t, "GOOD") ) )  ;     t := t + 1 ) ; 
 );
  static   operation shuffle( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var len : int ; len := arr->size() ;
         var k : int ; k := 0 ; while k < len do ( (     var p : int ; p := random.nextInt(len) ;
     var t : int ; t := arr[p+1] ;
     arr[p+1] := arr[k+1] ; 
     arr[k+1] := t )  ;     k := k + 1 ) );
  static   operation out( t : int, ans : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Case #" + (t + 1) + ": " + ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=100000 ;
  static int findSumofEle(int arr1[],int m,int arr2[],int n){
    int hash[]=new int[MAX];
    for(int i=0 ; i<n ; i++){
      hash[arr2[i] ]++;
    }
    for(int i=1 ; i<MAX ; i++){
      hash[i]=hash[i]+hash[i-1];
    }
    int maximumFreq=0 ;
    for(int i=0 ; i<m ; i++){
      maximumFreq=Math.max(maximumFreq,hash[arr1[i] ]);
    }
    int sumOfElements=0 ;
    for(int i=0 ; i<m ; i++){
      sumOfElements+=(maximumFreq==hash[arr1[i] ])? arr1[i] : 0 ;
    }
    return sumOfElements ;
  }
  public static void main(String[] args){
    int arr1[]={
      2,5,6,8 };
      int arr2[]={
        4,10 };
        int m=arr1.length ;
        int n=arr2.length ;
        System.out.println(findSumofEle(arr1,m,arr2,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100000;
  static   operation findSumofEle( arr1 : Sequence(int), m : int, arr2 : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var hash : Sequence(int) ; hash := Integer.subrange(1,MAX)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     hash[arr2[i+1]+1] := hash[arr2[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < MAX do ( (     hash[i+1] := hash[i+1] + hash[i - 1+1] )  ;     i := i + 1 ) ; 
    var maximumFreq : int ; maximumFreq := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     maximumFreq := Set{maximumFreq, hash[arr1[i+1]+1]}->max() )  ;     i := i + 1 ) ; 
    var sumOfElements : int ; sumOfElements := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     sumOfElements := sumOfElements+(if (maximumFreq = hash[arr1[i+1]+1]) then arr1[i+1] else 0 endif) )  ;     i := i + 1 ) ; 
    return sumOfElements 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{2,5,6,8} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{4,10} ;
    var m : int ; m := arr1->size() ;
    var n : int ; n := arr2->size() ;
    OclFile["System.out"].println(findSumofEle(arr1, m, arr2, n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class Test {
  static int count(int x,int Y[],int n,int NoOfY[]){
    if(x==0)return 0 ;
    if(x==1)return NoOfY[0];
    int idx=Arrays.binarySearch(Y,x);
    int ans ;
    if(idx<0){
      idx=Math.abs(idx+1);
      ans=Y.length-idx ;
    }
    else {
      while(idx<n && Y[idx]==x){
        idx++;
      }
      ans=Y.length-idx ;
    }
    ans+=(NoOfY[0]+NoOfY[1]);
    if(x==2)ans-=(NoOfY[3]+NoOfY[4]);
    if(x==3)ans+=NoOfY[2];
    return ans ;
  }
  static int countPairs(int X[],int Y[],int m,int n){
    int NoOfY[]=new int[5];
    for(int i=0 ; i<n ; i++)if(Y[i]<5)NoOfY[Y[i] ]++;
    Arrays.sort(Y);
    int total_pairs=0 ;
    for(int i=0 ; i<m ; i++)total_pairs+=count(X[i],Y,n,NoOfY);
    return total_pairs ;
  }
  public static void main(String args[]){
    int X[]={
      2,1,6 };
      int Y[]={
        1,5 };
        System.out.println("Total pairs="+countPairs(X,Y,X.length,Y.length));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation count( x : int, Y : Sequence(int), n : int, NoOfY : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (x = 0) then     return 0 else skip ; 
     if (x = 1) then     return NoOfY[0+1] else skip ; 
    var idx : int ; idx := (Y->indexOf(x) - 1) ;
    var ans : int ;
    if (idx < 0) then (     idx := if idx + 1 < 0 then -(idx + 1) else idx + 1 endif ; 
     ans := Y->size() - idx ) else (     while (idx < n & Y[idx+1] = x) do (     idx := idx + 1 ) ; 
     ans := Y->size() - idx ) ;  
    ans := ans+((NoOfY[0+1] + NoOfY[1+1])) ; 
    if (x = 2) then     ans := ans-((NoOfY[3+1] + NoOfY[4+1])) ; else skip ; 
    if (x = 3) then     ans := ans+(NoOfY[2+1]) ; else skip ; 
    return ans 
 );
  static   operation countPairs( X : Sequence(int), Y : Sequence(int), m : int, n : int) : int
  pre: true
  post: true
  activity: (     var NoOfY : Sequence(int) ; NoOfY := Integer.subrange(1,5)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     if (Y[i+1] < 5) then     NoOfY[Y[i+1]+1] := NoOfY[Y[i+1]+1] + 1 ; else skip ;  ;     i := i + 1 ) ; 
    Y := Y->sort() ; 
    var total_pairs : int ; total_pairs := 0 ;
        var i : int ; i := 0 ; while i < m do (     total_pairs := total_pairs+(count(X[i+1], Y, n, NoOfY)) ;  ;     i := i + 1 ) ; 
    return total_pairs 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : Sequence(int) ; X := Sequence{2,1,6} ;
     var Y : Sequence(int) ; Y := Sequence{1,5} ;
     OclFile["System.out"].println("Total pairs=" + countPairs(X, Y, X->size(), Y->size())) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    while(test>0){
      long n=sc.nextLong();
      if((n &(n-1))!=0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
      test--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
     while (test > 0) do (     var n : long ; n := sc.getCurrent()->toLong() ;
     if ((MathLib.bitwiseAnd(n,(n - 1))) /= 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
     test := test - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    int max=-1 ;
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    while(x>0){
      long n=sc.nextLong();
      sc.nextLine();
      if(n % 2==1)System.out.println("YES");
      else {
        boolean non=true ;
        while(n>1){
          if(n % 2==1){
            non=false ;
            break ;
          }
          n=n/2 ;
        }
        if(non)System.out.println("NO");
        else System.out.println("YES");
      }
      x=x-1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var max : int ; max := -1 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     while (x > 0) do (     var n : long ; n := sc.getCurrent()->toLong() ;
     skip ; 
     if (n mod 2 = 1) then     OclFile["System.out"].println("YES") else (     var non : boolean ; non := true ;
     while (n > 1) do (     if (n mod 2 = 1) then (     non := false ; 
     break ) else skip ; 
     n := n / 2 ) ; 
     if (non) then     OclFile["System.out"].println("NO") ; else     OclFile["System.out"].println("YES") ; ) ;  
     x := x - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int h=Integer.parseInt(scan.next());
    int w=Integer.parseInt(scan.next());
    int k=Integer.parseInt(scan.next());
    int[][] c=new int[h][w];
    for(int i=0 ; i<h ; i++){
      String[] s=scan.next().split("");
      for(int j=0 ; j<w ; j++){
        if(s[j] .equals(".")){
          c[i][j]=0 ;
        }
        else {
          c[i][j]=1 ;
        }
      }
    }
    scan.close();
    long ans=0 ;
    for(int i=0 ; i<(1<<h); i++){
      Set<Integer>iSet=new HashSet<Integer>();
      for(int a=0 ; a<h ; a++){
        if((i &(1<<a))!=0){
          iSet.add(a);
        }
      }
      for(int j=0 ; j<(1<<w); j++){
        Set<Integer>jSet=new HashSet<Integer>();
        for(int a=0 ; a<w ; a++){
          if((j &(1<<a))!=0){
            jSet.add(a);
          }
        }
        int black=0 ;
        for(int a=0 ; a<h ; a++){
          if(iSet.contains(a)){
            continue ;
          }
          for(int b=0 ; b<w ; b++){
            if(jSet.contains(b)){
              continue ;
            }
            black+=c[a][b];
          }
        }
        if(black==k){
          ans++;
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := (scan.getCurrent())->toInteger() ;
    var w : int ; w := (scan.getCurrent())->toInteger() ;
    var k : int ; k := (scan.getCurrent())->toInteger() ;
    var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (     var s : Sequence(String) ; s := scan.getCurrent()->split("") ;
         var j : int ; j := 0 ; while j < w do ( (     if (s[j+1] = ".") then (     c[i+1][j+1] := 0 ) else (     c[i+1][j+1] := 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < ((1*(2->pow(h)))->oclAsType(long)) do ( (     var iSet : Set(int) ; iSet := Set{} ;
         var a : int ; a := 0 ; while a < h do ( (     if ((MathLib.bitwiseAnd(i,((1*(2->pow(a)))->oclAsType(long)))) /= 0) then (     iSet := iSet->including(a) ) else skip )  ;     a := a + 1 ) ; 
         var j : int ; j := 0 ; while j < ((1*(2->pow(w)))->oclAsType(long)) do ( (     var jSet : Set(int) ; jSet := Set{} ;
         var a : int ; a := 0 ; while a < w do ( (     if ((MathLib.bitwiseAnd(j,((1*(2->pow(a)))->oclAsType(long)))) /= 0) then (     jSet := jSet->including(a) ) else skip )  ;     a := a + 1 ) ; 
    var black : int ; black := 0 ;
        var a : int ; a := 0 ; while a < h do ( (     if (iSet->includes(a)) then (     continue ) else skip ; 
         var b : int ; b := 0 ; while b < w do ( (     if (jSet->includes(b)) then (     continue ) else skip ; 
     black := black+(c[a+1][b+1]) )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    if (black = k) then (     ans := ans + 1 ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    StringTokenizer inputString=new StringTokenizer(reader.readLine());
    int t=Integer.parseInt(inputString.nextToken());
    while(t>0){
      StringTokenizer inputString2=new StringTokenizer(reader.readLine());
      long n=Long.parseLong(inputString2.nextToken());
      String x="NO" ;
      for(long i=n ; i>1 ; i=i/2){
        if(i % 2!=0){
          x="YES" ;
          i=1 ;
        }
      }
      out.println(x);
      t--;
    }
    reader.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var inputString : OclIterator ; inputString := OclIterator.newOclIterator_String(reader.readLine()) ;
    var t : int ; t := (inputString.next())->toInteger() ;
    while (t > 0) do (     var inputString2 : OclIterator ; inputString2 := OclIterator.newOclIterator_String(reader.readLine()) ;
     var n : long ; n := (inputString2.next())->toLong() ;
    var x : String ; x := "NO" ;
        var i : long ; i := n ; while i > 1 do ( (     if (i mod 2 /= 0) then (     x := "YES" ; 
     i := 1 ) else skip )  ;     i := i / 2 ) ; 
    skip ; 
    t := t - 1 ; 
 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class A_Odd_Divisor {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int T=reader.nextInt();
    while(T!=0){
      T--;
      long N=reader.nextLong();
      if(N % 2==1){
        System.out.println("YES");
      }
      else {
        boolean ans=true ;
        while(N!=1){
          if(N % 2==0){
            N=N/2 ;
          }
          else {
            ans=false ;
            break ;
          }
        }
        if(ans==false){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Odd_Divisor {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var T : int ; T := reader.nextInt() ;
     while (T /= 0) do (     T := T - 1 ; 
     var N : long ; N := reader.nextLong() ;
     if (N mod 2 = 1) then (     OclFile["System.out"].println("YES") ) else (     var ans : boolean ; ans := true ;
     while (N /= 1) do (     if (N mod 2 = 0) then (     N := N / 2 ) else (     ans := false ; 
     break ) ) ; 
     if (ans = false) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class OddDivisor {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      double a=sc.nextDouble();
      if(a % 2==0){
        while(a % 2==0){
          a=a/2 ;
        }
        if(a>1){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
      else {
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class OddDivisor {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : double ; a := sc.getCurrent()->toReal() ;
     if (a mod 2 = 0) then (     while (a mod 2 = 0) do (     a := a / 2 ) ; 
     if (a > 1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else (     OclFile["System.out"].println("YES") ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  public static void main(String[] args){
    new A().solve();
  }
  Scanner in ;
  private void solve(){
    in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      countLikes(n);
    }
  }
  private void countLikes(int n){
    int likes=0 ;
    int dislikes=0 ;
    while(n-->0){
      int user=in.nextInt();
      if(user==1 || user==3){
++likes ;
      }
      else if(user==2){
++dislikes ;
      }
    }
    System.out.println(likes);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     A.newA().solve() );
   attribute in : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     execute countLikes(n) ) ;  ) );
   operation countLikes( n : int) : void
  pre: true
  post: true
  activity: (     var likes : int ; likes := 0 ;
     var dislikes : int ; dislikes := 0 ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var user : int ; user := in.getCurrent()->toInteger() ;
     if (user = 1 or user = 3) then (     likes := likes + 1 ) else     if (user = 2) then (     dislikes := dislikes + 1 ) else skip ; ) ;  ) ;  
     OclFile["System.out"].println(likes) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class exe_A1511 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    int[] ans=new int[t];
    for(int i=0 ; i<t ; i++){
      int n=scanner.nextInt();
      for(int j=0 ; j<n ; j++){
        int x=scanner.nextInt();
        if(x==1 || x==3)ans[i]++;
      }
    }
    scanner.close();
    for(int i : ans)System.out.println(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class exe_A1511 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,t)->collect(0) ;
        var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < n do ( (     var x : int ; x := scanner.getCurrent()->toInteger() ;
     if (x = 1 or x = 3) then     ans[i+1] := ans[i+1] + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    for (i : ans) do (     OclFile["System.out"].println(i) ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  public static void main(String[] args){
    new A().solve();
  }
  Scanner in ;
  private void solve(){
    in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      countLikes(n);
    }
  }
  private void countLikes(int n){
    int likes=0 ;
    while(n-->0){
      int user=in.nextInt();
      if(user==1 || user==3){
++likes ;
      }
    }
    System.out.println(likes);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     A.newA().solve() );
   attribute in : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     execute countLikes(n) ) ;  ) );
   operation countLikes( n : int) : void
  pre: true
  post: true
  activity: (     var likes : int ; likes := 0 ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var user : int ; user := in.getCurrent()->toInteger() ;
     if (user = 1 or user = 3) then (     likes := likes + 1 ) else skip ) ;  ) ;  
     OclFile["System.out"].println(likes) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int yoko=scan.nextInt();
    int tate=scan.nextInt();
    String c=scan.next();
    int i ;
    int y ;
    for(i=1 ; i<=tate ; i++){
      for(y=1 ; y<=yoko ; y++){
        if(i==1 && y==1 || i==tate && y==yoko || i==1 && y==yoko || y==1 && i==tate){
          System.out.print("+");
        }
        else if(y==1 || y==yoko){
          System.out.print("|");
        }
        else if(i==1 || i==tate){
          System.out.print("-");
        }
        else if(i==tate/2+1 && y==yoko/2+1){
          System.out.print(c);
        }
        else {
          System.out.print(".");
        }
      }
      System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var yoko : int ; yoko := scan.getCurrent()->toInteger() ;
    var tate : int ; tate := scan.getCurrent()->toInteger() ;
    var c : String ; c := scan.getCurrent() ;
    var i : int ;
    var y : int ;
        i := 1 ; while i <= tate do ( (         y := 1 ; while y <= yoko do ( (     if (i = 1 & y = 1 or i = tate & y = yoko or i = 1 & y = yoko or y = 1 & i = tate) then (     OclFile["System.out"].print("+") ) else     if (y = 1 or y = yoko) then (     OclFile["System.out"].print("|") ) else     if (i = 1 or i = tate) then (     OclFile["System.out"].print("-") ) else     if (i = tate / 2 + 1 & y = yoko / 2 + 1) then (     OclFile["System.out"].print(c) ) else (     OclFile["System.out"].print(".") ) ;  ;  ;  )  ;     y := y + 1 ) ; 
     OclFile["System.out"].println("") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DeleteFromTheLeft {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String t=sc.next();
    int w=0 ;
    while(true){
      int i=s.length()-w-1 ;
      int j=t.length()-w-1 ;
      if(i>=0 && j>=0 && s.charAt(i)==t.charAt(j)){
        w++;
      }
      else {
        break ;
      }
    }
    System.out.println(s.length()+t.length()-2*w);
  }
}
------------------------------------------------------------
OCL File:
---------
 class DeleteFromTheLeft {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var w : int ; w := 0 ;
    while (true) do (     var i : int ; i := s->size() - (w)->char2byte() - 1 ;
     var j : int ; j := t->size() - (w)->char2byte() - 1 ;
     if (i >= 0 & j >= 0 & s->at(i+1) = t->at(j+1)) then (     w := w + 1 ) else (     break ) ) ; 
    OclFile["System.out"].println(s->size() + t->size() - 2 * w) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int W=sc.nextInt();
    int H=sc.nextInt();
    String c=sc.next();
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        if(i==0 && j==0 || i==0 && j==W-1 || i==H-1 && j==0 || i==H-1 && j==W-1){
          System.out.print("+");
        }
        else if(i==0 || i==H-1){
          System.out.print("-");
        }
        else if(j==0 || j==W-1){
          System.out.print("|");
        }
        else if(i==H/2 && j==W/2){
          System.out.print(c);
        }
        else {
          System.out.print(".");
        }
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var W : int ; W := sc.getCurrent()->toInteger() ;
    var H : int ; H := sc.getCurrent()->toInteger() ;
    var c : String ; c := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (i = 0 & j = 0 or i = 0 & j = W - 1 or i = H - 1 & j = 0 or i = H - 1 & j = W - 1) then (     OclFile["System.out"].print("+") ) else     if (i = 0 or i = H - 1) then (     OclFile["System.out"].print("-") ) else     if (j = 0 or j = W - 1) then (     OclFile["System.out"].print("|") ) else     if (i = H / 2 & j = W / 2) then (     OclFile["System.out"].print(c) ) else (     OclFile["System.out"].print(".") ) ;  ;  ;  )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      String str=reader.readLine();
      String s[]=str.split(" ");
      int w=Integer.parseInt(s[0]);
      int h=Integer.parseInt(s[1]);
      String c=s[2];
      int x=(w/2);
      int y=(h/2);
      StringBuilder sb=new StringBuilder();
      for(int i=0 ; i<h ; i++){
        for(int j=0 ; j<w ; j++){
          if(i==0 || i==h-1){
            if(j==0 || j==w-1){
              sb.append("+");
            }
            else {
              sb.append("-");
            }
          }
          else {
            if(j==0 || j==w-1){
              sb.append("|");
            }
            else if(i==y && j==x){
              sb.append(c);
            }
            else {
              sb.append(".");
            }
          }
          if(j==w-1 && i!=h-1){
            sb.append("\n");
          }
        }
      }
      System.out.println(sb);
      reader.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  static int gcd(int a,int b){
    return b>0 ? gcd(b,a % b): a ;
  }
  static int lcm(int a,int b){
    return a*b/gcd(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var str : String ; str := reader.readLine() ;
     var s : Sequence(String) ; s := str->split(" ") ;
    var w : int ; w := (s[0+1])->toInteger() ;
    var h : int ; h := (s[1+1])->toInteger() ;
    var c : String ; c := s[2+1] ;
    var x : int ; x := (w / 2) ;
    var y : int ; y := (h / 2) ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (i = 0 or i = h - 1) then (     if (j = 0 or j = (w)->char2byte() - 1) then (     sb := sb + StringLib.newString("+") ) else (     sb := sb + StringLib.newString("-") ) ) else (     if (j = 0 or j = (w)->char2byte() - 1) then (     sb := sb + StringLib.newString("|") ) else     if (i = y & j = x) then (     sb := sb + StringLib.newString(c) ) else (     sb := sb + StringLib.newString(".") ) ;  ) ;  
     if (j = (w)->char2byte() - 1 & i /= h - 1) then (     sb := sb + StringLib.newString("\n") ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b > 0 then gcd(b, a mod b) else a endif );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return a * b / gcd(a, b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int H=scan.nextInt();
    int W=scan.nextInt();
    int K=scan.nextInt();
    int[][] blacks=new int[H][W];
    for(int i=0 ; i<H ; i++){
      char[] t=scan.next().toCharArray();
      for(int j=0 ; j<W ; j++){
        if(t[j]=='#')blacks[i][j]=1 ;
      }
    }
    int max_h=pow(2,H);
    int max_w=pow(2,W);
    int ans=0 ;
    for(int i=0 ; i<max_h ; i++){
      for(int j=0 ; j<max_w ; j++){
        int count=0 ;
        for(int row=0 ; row<H ; row++){
          if(((i>>row)& 1)==1)continue ;
          for(int column=0 ; column<W ; column++){
            if(((j>>column)& 1)==1)continue ;
            count+=blacks[row][column];
          }
        }
        if(count==K)ans+=1 ;
      }
    }
    System.out.println(ans);
  }
  private int pow(int base,int count){
    if(count==0)return 1 ;
    if(count % 2==1)return base*pow(base,count-1);
    int t=pow(base,count/2);
    return t*t ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var H : int ; H := scan.getCurrent()->toInteger() ;
    var W : int ; W := scan.getCurrent()->toInteger() ;
    var K : int ; K := scan.getCurrent()->toInteger() ;
    var blacks : Sequence(Sequence(int)) ; blacks := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var i : int ; i := 0 ; while i < H do ( (     var t : Sequence(String) ; t := scan.getCurrent()->characters() ;
         var j : int ; j := 0 ; while j < W do ( (     if (t[j+1] = '#') then     blacks[i+1][j+1] := 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max_h : int ; max_h := pow(2, H) ;
    var max_w : int ; max_w := pow(2, W) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < max_h do ( (         var j : int ; j := 0 ; while j < max_w do ( (     var count : int ; count := 0 ;
         var row : int ; row := 0 ; while row < H do ( (     if ((((i/(2->pow(row)))->oclAsType(long)) & 1) = 1) then     continue else skip ; 
         var column : int ; column := 0 ; while column < W do ( (     if ((((j/(2->pow(column)))->oclAsType(long)) & 1) = 1) then     continue else skip ; 
     count := count+(blacks[row+1][column+1]) )  ;     column := column + 1 ) )  ;     row := row + 1 ) ; 
     if (count = K) then     ans := ans+(1) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation pow( base : int, count : int) : int
  pre: true
  post: true
  activity: (     if (count = 0) then     return 1 else skip ; 
     if (count mod 2 = 1) then     return base * pow(base, count - 1) else skip ; 
     var t : int ; t := pow(base, count / 2) ;
     return t * t );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args){
    BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    String str="" ;
    StringTokenizer stk ;
    String moji="" ;
    int yoko,tate ;
    String[] hata ;
    try {
      str=bfr.readLine();
      if(str==null){
        System.exit(0);
      }
      else {
        stk=new StringTokenizer(str," ");
        yoko=Integer.parseInt(stk.nextToken());
        tate=Integer.parseInt(stk.nextToken());
        moji=stk.nextToken();
        hata=new String[tate];
        for(int i=0 ; i<tate ; i++){
          hata[i]="" ;
        }
        for(int i=0 ; i<yoko ; i++){
          if(i==0 || i==yoko-1){
            hata[0]=hata[0]+"+" ;
            hata[tate-1]=hata[tate-1]+"+" ;
            for(int j=1 ; j<tate-1 ; j++){
              hata[j]=hata[j]+"|" ;
            }
          }
          else {
            hata[0]=hata[0]+"-" ;
            hata[tate-1]=hata[tate-1]+"-" ;
            for(int j=1 ; j<tate-1 ; j++){
              if(j!=(tate-1)/2){
                hata[j]=hata[j]+"." ;
              }
              else {
                if(i==(yoko-1)/2){
                  hata[j]=hata[j]+moji ;
                }
                else {
                  hata[j]=hata[j]+"." ;
                }
              }
            }
          }
        }
        for(int l=0 ; l<tate ; l++){
          System.out.println(hata[l]);
        }
      }
    }
    catch(IOException e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bfr : OclFile ; bfr := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := "" ;
    var stk : OclIterator ;
    var moji : String ; moji := "" ;
    var yoko : int ;
    var tate : int ;
    var hata : Sequence(String) ;
    try (     str := bfr.readLine() ; 
     if (str = null) then ( OclProcess.exit(0) ) else (     stk := OclIterator.newOclIterator_String_String(str, " ") ; 
     yoko := (stk.next())->toInteger() ; 
    tate := (stk.next())->toInteger() ; 
    moji := stk.next() ; 
    hata := Integer.subrange(1,tate)->collect(null) ; 
        var i : int ; i := 0 ; while i < tate do ( (     hata[i+1] := "" )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < yoko do ( (     if (i = 0 or i = (yoko)->char2byte() - 1) then (     hata[0+1] := hata[0+1] + "+" ; 
     hata[(tate)->char2byte() - 1+1] := hata[(tate)->char2byte() - 1+1] + "+" ; 
         var j : int ; j := 1 ; while j < (tate)->char2byte() - 1 do ( (     hata[j+1] := hata[j+1] + "|" )  ;     j := j + 1 ) ) else (     hata[0+1] := hata[0+1] + "-" ; 
     hata[(tate)->char2byte() - 1+1] := hata[(tate)->char2byte() - 1+1] + "-" ; 
         var j : int ; j := 1 ; while j < (tate)->char2byte() - 1 do ( (     if (j /= ((tate)->char2byte() - 1) / 2) then (     hata[j+1] := hata[j+1] + "." ) else (     if (i = ((yoko)->char2byte() - 1) / 2) then (     hata[j+1] := hata[j+1] + moji ) else (     hata[j+1] := hata[j+1] + "." ) ) )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
        var l : int ; l := 0 ; while l < tate do ( (     OclFile["System.out"].println(hata[l+1]) )  ;     l := l + 1 ) ; 
 ) )   catch (e : IOException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int w=sc.nextInt();
    int h=sc.nextInt();
    char c=sc.next().charAt(0);
    StringBuilder sb=new StringBuilder();
    sb.append("+");
    for(int i=0 ; i<w-2 ; i++){
      sb.append("-");
    }
    sb.append("+\n");
    for(int y=1 ; y<h-1 ; y++){
      sb.append("|");
      for(int x=1 ; x<w-1 ; x++){
        if(y==h/2 && x==w/2){
          sb.append(c);
        }
        else {
          sb.append(".");
        }
      }
      sb.append("|\n");
    }
    sb.append("+");
    for(int i=0 ; i<w-2 ; i++){
      sb.append("-");
    }
    sb.append("+");
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var c : String ; c := sc.getCurrent()->at(0+1) ;
    var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString("+") ; 
        var i : int ; i := 0 ; while i < w - 2 do ( (     sb := sb + StringLib.newString("-") )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString("+\n") ; 
        var y : int ; y := 1 ; while y < h - 1 do ( (     sb := sb + StringLib.newString("|") ; 
         var x : int ; x := 1 ; while x < w - 1 do ( (     if (y = h / 2 & x = w / 2) then (     sb := sb + StringLib.newString(c) ) else (     sb := sb + StringLib.newString(".") ) )  ;     x := x + 1 ) ; 
     sb := sb + StringLib.newString("|\n") )  ;     y := y + 1 ) ; 
    sb := sb + StringLib.newString("+") ; 
        var i : int ; i := 0 ; while i < w - 2 do ( (     sb := sb + StringLib.newString("-") )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString("+") ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B928 {
  static Scanner sc=null ;
  public static void main(String args[]){
    sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int a[]=new int[n+1];
    for(int i=1 ; i<=n ; i++)a[i]=sc.nextInt();
    int dp[]=new int[n+1];
    dp[1]=Math.min(k+1,n);
    for(int i=2 ; i<=n ; i++){
      int num=a[i];
      if(num==0){
        if(k==0){
          dp[i]=1 ;
        }
        else {
          int left=Math.min(k,i-1);
          int right=Math.min(k,n-i);
          dp[i]=left+right+1 ;
        }
      }
      else {
        if(k==0){
          dp[i]=1+dp[num];
        }
        else {
          int left=Math.min(k,i-1);
          int right=Math.min(k,n-i);
          int l1=Math.max(i-k,1);
          int r1=Math.min(num+k,n);
          int d=Math.max(0,r1-l1+1);
          dp[i]=dp[num]+1+left+right-d ;
        }
      }
    }
    for(int i=1 ; i<=n ; i++){
      System.out.print(dp[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B928 {
  static   attribute sc : OclFile := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
    dp[1+1] := Set{k + 1, n}->min() ; 
        var i : int ; i := 2 ; while i <= n do ( (     var num : int ; num := a[i+1] ;
     if (num = 0) then (     if (k = 0) then (     dp[i+1] := 1 ) else (     var left : int ; left := Set{k, i - 1}->min() ;
     var right : int ; right := Set{k, n - i}->min() ;
     dp[i+1] := left + right + 1 ) ) else (     if (k = 0) then (     dp[i+1] := 1 + dp[num+1] ) else (     var left : int ; left := Set{k, i - 1}->min() ;
     var right : int ; right := Set{k, n - i}->min() ;
    var l1 : int ; l1 := Set{i - k, 1}->max() ;
    var r1 : int ; r1 := Set{num + k, n}->min() ;
    var d : int ; d := Set{0, r1 - l1 + 1}->max() ;
    dp[i+1] := dp[num+1] + 1 + left + right - d ; 
 ) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].print(dp[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B928 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int K=in.nextInt();
    int[] count=new int[N];
    for(int n=0 ; n<N ; n++){
      int start=Math.max(0,n-K);
      int end=Math.min(N-1,n+K);
      int previous=in.nextInt();
      if(previous==0){
        count[n]=end-start+1 ;
      }
      else {
        previous--;
        int prevEnd=Math.min(N-1,previous+K);
        count[n]=count[previous]+end-Math.max(start-1,prevEnd);
      }
    }
    StringBuilder output=new StringBuilder();
    for(int c : count){
      output.append(c).append(' ');
    }
    System.out.println(output);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B928 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    var count : Sequence(int) ; count := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     var start : int ; start := Set{0, n - K}->max() ;
     var end : int ; end := Set{N - 1, n + K}->min() ;
     var previous : int ; previous := in.getCurrent()->toInteger() ;
     if (previous = 0) then (     count[n+1] := end - start + 1 ) else (     previous := previous - 1 ; 
     var prevEnd : int ; prevEnd := Set{N - 1, previous + K}->min() ;
     count[n+1] := count[previous+1] + end - Set{start - 1, prevEnd}->max() ) )  ;     n := n + 1 ) ; 
    var output : String ; output := StringLib.newString() ;
    for (c : count) do ( (     output := output + StringLib.newString(c) + StringLib.newString(' ') )  ) ; 
    OclFile["System.out"].println(output) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class Chat {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    String[] temp=br.readLine().split(" ");
    int n=Integer.parseInt(temp[0]);
    int k=Integer.parseInt(temp[1]);
    int[] nums=new int[n];
    temp=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      nums[i]=Integer.parseInt(temp[i]);
    }
    int[] dp=new int[n];
    dp[0]=Math.min(n,k+1);
    for(int i=1 ; i<n ; i++){
      int last=nums[i];
      if(last==0){
        int right=Math.min(k,n-i-1);
        int left=Math.min(k,i);
        dp[i]=right+left+1 ;
      }
      else {
        int j=last-1 ;
        dp[i]=dp[j];
        int lastMax=j+k ;
        int currentMax=Math.min(n-1,i+k);
        int currentMin=Math.max(i-k,0);
        int overlap=Math.max(0,Math.min(currentMax,lastMax)-currentMin+1);
        dp[i]-=overlap ;
        int right=Math.min(k,n-i-1);
        int left=Math.min(k,i);
        dp[i]+=right+left+1 ;
      }
    }
    for(int i : dp){
      pr.print(i+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Chat {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
     var n : int ; n := (temp[0+1])->toInteger() ;
    var k : int ; k := (temp[1+1])->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
    temp := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := (temp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
    dp[0+1] := Set{n, k + 1}->min() ; 
        var i : int ; i := 1 ; while i < n do ( (     var last : int ; last := nums[i+1] ;
     if (last = 0) then (     var right : int ; right := Set{k, n - i - 1}->min() ;
     var left : int ; left := Set{k, i}->min() ;
     dp[i+1] := right + left + 1 ) else (     var j : int ; j := last - 1 ;
     dp[i+1] := dp[j+1] ; 
    var lastMax : int ; lastMax := j + k ;
    var currentMax : int ; currentMax := Set{n - 1, i + k}->min() ;
    var currentMin : int ; currentMin := Set{i - k, 0}->max() ;
    var overlap : int ; overlap := Set{0, Set{currentMax, lastMax}->min() - currentMin + 1}->max() ;
    dp[i+1] := dp[i+1]-(overlap) ; 
    var right : int ; right := Set{k, n - i - 1}->min() ;
    var left : int ; left := Set{k, i}->min() ;
    dp[i+1] := dp[i+1]+(right + left + 1) ; 
 ) )  ;     i := i + 1 ) ; 
    for (i : dp) do ( (     skip )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder str=new StringBuilder("");
    int t=Integer.parseInt(br.readLine());
    while(t-->0){
      String h[]=br.readLine().split(" ");
      int n=Integer.parseInt(h[0]);
      int k=Integer.parseInt(h[1]);
      String ans="" ;
      char a='a' ;
      int i ;
      for(i=0 ; i<k ; i++)ans+=a ;
      char b='b' ;
      char c='c' ;
      for(i=0 ; i<n-k ; i++){
        if(i % 3==0)ans+=b ;
        else if(i % 3==1)ans+=c ;
        else ans+=a ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := StringLib.newString("") ;
     var t : int ; t := (br.readLine())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var h : Sequence(String) ; h := br.readLine()->split(" ") ;
     var n : int ; n := (h[0+1])->toInteger() ;
    var k : int ; k := (h[1+1])->toInteger() ;
    var ans : String ; ans := "" ;
    var a : String ; a := 'a' ;
    var i : int ;
        i := 0 ; while i < k do (     ans := ans+(a) ;  ;     i := i + 1 ) ; 
    var b : String ; b := 'b' ;
    var c : String ; c := 'c' ;
        i := 0 ; while i < (n)->char2byte() - k do ( (     if (i mod 3 = 0) then     ans := ans+(b) ; else     if (i mod 3 = 1) then     ans := ans+(c) else     ans := ans+(a) ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int k=sc.nextInt(),n=sc.nextInt();
      StringBuilder sb=new StringBuilder(k);
      for(int i=0 ; i<n ; i++){
        sb.append("a");
      }
      for(int i=0 ; i<k-n ; i++){
        if((i % 3)==0){
          sb.append("c");
        }
        else if((i % 3)==1){
          sb.append("b");
        }
        else if((i % 3)==2){
          sb.append("a");
        }
      }
      System.out.println(sb);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var k : int ; k := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
     var sb : String ; sb := StringLib.newString(k) ;
        var i : int ; i := 0 ; while i < n do ( (     sb := sb + StringLib.newString("a") )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k - n do ( (     if ((i mod 3) = 0) then (     sb := sb + StringLib.newString("c") ) else     if ((i mod 3) = 1) then (     sb := sb + StringLib.newString("b") ) else     if ((i mod 3) = 2) then (     sb := sb + StringLib.newString("a") ) else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.System.*;
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    String word1=sc.nextLine();
    String word2=sc.nextLine();
    int count=0 ;
    for(int i=word1.length()-1,j=word2.length()-1 ; i>=0 ; i--,j--){
      if(j==-1)break ;
      if(word1.charAt(i)==word2.charAt(j)){
        count=count+2 ;
      }
      else {
        break ;
      }
    }
    out.println(word1.length()+word2.length()-count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var word1 : String ; word1 := sc.nextLine() ;
    var word2 : String ; word2 := sc.nextLine() ;
    var count : int ; count := 0 ;
        var i : int ; i := word1->size() - 1 ;
    var j : int ; j := word2->size() - 1 ; while i >= 0 do ( (     if (j = -1) then     break else skip ; 
     if (word1->at(i+1) = word2->at(j+1)) then (     count := count + 2 ) else (     break ) )  ;     i := i - 1 ;     j := j - 1 ) ; 
    out.println(word1->size() + word2->size() - (count)->char2byte()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countPairs(int arr[],int n){
    HashMap<Integer,Integer>frequency=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      if(frequency.containsKey(arr[i])){
        frequency.put(arr[i],frequency.get(arr[i])+1);
      }
      else {
        frequency.put(arr[i],1);
      }
    }
    int count=0 ;
    for(Map.Entry<Integer,Integer>x : frequency.entrySet()){
      int f=x.getValue();
      count+=f*(f-1)/2 ;
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      1,1,1 };
      int n=arr.length ;
      System.out.print(countPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var frequency : Map(int,int) ; frequency := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (frequency->keys()->includes(arr[i+1])) then (     frequency := frequency->union(Map{arr[i+1] |-> frequency->at(arr[i+1]) + 1}) ) else (     frequency := frequency->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    for (x : frequency->asSet()) do ( (     var f : int ; f := x.getValue() ;
     count := count+(f * (f - 1) / 2) )  ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(countPairs(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Stack ;
class GFG {
  static int countNumber(int n){
    int result=0 ;
    for(int i=1 ; i<=9 ; i++){
      Stack<Integer>s=new Stack<>();
      if(i<=n){
        s.push(i);
        result++;
      }
      while(! s.empty()){
        int tp=s.peek();
        s.pop();
        for(int j=tp % 10 ; j<=9 ; j++){
          int x=tp*10+j ;
          if(x<=n){
            s.push(x);
            result++;
          }
        }
      }
    }
    return result ;
  }
  public static void main(String[] args){
    int n=15 ;
    System.out.println(countNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countNumber( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 1 ; while i <= 9 do ( (     var s : Sequence(int) ; s := Sequence{} ;
     if (i <= n) then (     s := s->append(i) ; 
     result := result + 1 ) else skip ; 
     while (not(s->isEmpty())) do (     var tp : int ; tp := s->min() ;
     s := s->front() ; 
         var j : int ; j := tp mod 10 ; while j <= 9 do ( (     var x : int ; x := tp * 10 + j ;
     if (x <= n) then (     s := s->append(x) ; 
     result := result + 1 ) else skip )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     OclFile["System.out"].println(countNumber(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    System.out.println(new SocialGame(scanner.nextInt(),scanner.nextInt(),scanner.nextInt()).calcDays_to_earn_goal_coins());
    scanner.close();
  }
}
class SocialGame {
  private int daily_coin=0 ;
  private int weekly_coin=0 ;
  private int goal_coin=0 ;
  public SocialGame(int daily_coin,int weekly_coin,int goal_coin){
    this.daily_coin=daily_coin ;
    this.weekly_coin=weekly_coin ;
    this.goal_coin=goal_coin ;
  }
  public int calcDays_to_earn_goal_coins(){
    int remain_coin=goal_coin ;
    int passed_days=0 ;
    while(true){
      passed_days+=1 ;
      remain_coin-=daily_coin ;
      if(passed_days % 7==0){
        remain_coin-=weekly_coin ;
      }
      if(remain_coin<=0){
        return passed_days ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println(SocialGame.newSocialGame(scanner.getCurrent()->toInteger(), scanner.getCurrent()->toInteger(), scanner.getCurrent()->toInteger()).calcDays_to_earn_goal_coins()) ; 
     skip );
}
class SocialGame {
   attribute daily_coin : int := 0;
   attribute weekly_coin : int := 0;
   attribute goal_coin : int := 0;
   static operation newSocialGame( daily_coin : int, weekly_coin : int, goal_coin : int) : SocialGame
  pre: true
  post: true
  activity:
  ( var self : SocialGame ;
    self := createSocialGame();
    self.initialise(daily_coin, weekly_coin,goal_coin);
    return self );
  operation initialise( daily_coin : int, weekly_coin : int, goal_coin : int) : void
  pre: true  post: true
  activity: (     self.daily_coin := daily_coin ; 
     self.weekly_coin := weekly_coin ; 
     self.goal_coin := goal_coin );
   operation calcDays_to_earn_goal_coins() : int
  pre: true
  post: true
  activity: (     var remain_coin : int ; remain_coin := goal_coin ;
     var passed_days : int ; passed_days := 0 ;
     while (true) do (     passed_days := passed_days+(1) ; 
     remain_coin := remain_coin-(daily_coin) ; 
     if (passed_days mod 7 = 0) then (     remain_coin := remain_coin-(weekly_coin) ) else skip ; 
     if (remain_coin <= 0) then (     return passed_days ) else skip ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws Exception {
    Integer numWeekday=0 ;
    Integer result=0 ;
    Integer total=0 ;
    try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in))){
      String[] data=reader.readLine().split(" ");
      Integer a=Integer.parseInt(data[0]);
      Integer b=Integer.parseInt(data[1]);
      Integer c=Integer.parseInt(data[2]);
      while(total<c){
        result+=1 ;
        numWeekday=(numWeekday+1)% 7 ;
        total+=a ;
        if(numWeekday==0){
          total+=b ;
        }
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var numWeekday : int ; numWeekday := 0 ;
     var result : int ; result := 0 ;
     var total : int ; total := 0 ;
     try (    var reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var data : Sequence(String) ; data := reader.readLine()->split(" ") ;
     var a : int ; a := (data[0+1])->toInteger() ;
    var b : int ; b := (data[1+1])->toInteger() ;
    var c : int ; c := (data[2+1])->toInteger() ;
    while (total < c) do (     result := result+(1) ; 
     numWeekday := (numWeekday + 1) mod 7 ; 
     total := total+(a) ; 
     if (numWeekday = 0) then (     total := total+(b) ) else skip ) ; 
    OclFile["System.out"].println(result) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int sum,getCoin,getBonus ;
    int getSum=0,count=0 ;
    Scanner scan=new Scanner(System.in);
    getCoin=scan.nextInt();
    getBonus=scan.nextInt();
    sum=scan.nextInt();
    for(int i=0 ; getSum<sum ; i++){
      count++;
      getSum+=getCoin ;
      if((count)% 7==0){
        getSum+=getBonus ;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sum : int ;
    var getCoin : int ;
    var getBonus : int ;
     var getSum : int ; getSum := 0 ;
    var count : int ; count := 0 ;
    var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    getCoin := scan.getCurrent()->toInteger() ; 
    getBonus := scan.getCurrent()->toInteger() ; 
    sum := scan.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while getSum < sum do ( (     count := count + 1 ; 
     getSum := getSum+(getCoin) ; 
     if ((count) mod 7 = 0) then (     getSum := getSum+(getBonus) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int cpw=b+7*a ;
      int ws=c/cpw ;
      int rc=c-cpw*ws ;
      int ds=rc/a ;
      int rm=rc-a*ds ;
      if(rm>0){
        ds++;
      }
      int days=ws*7+ds ;
      if(b>0 && ds>7){
        int wd=(ws+1)*7 ;
        if(days>wd){
          days=wd ;
        }
      }
      System.out.println(String.format("%d",days));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var cpw : int ; cpw := b + 7 * a ;
    var ws : int ; ws := c / cpw ;
    var rc : int ; rc := c - cpw * ws ;
    var ds : int ; ds := rc / a ;
    var rm : int ; rm := rc - a * ds ;
    if (rm > 0) then (     ds := ds + 1 ) else skip ; 
    var days : int ; days := ws * 7 + ds ;
    if (b > 0 & ds > 7) then (     var wd : int ; wd := (ws + 1) * 7 ;
     if (days > wd) then (     days := wd ) else skip ) else skip ; 
    OclFile["System.out"].println(StringLib.format("%d",Sequence{days})) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Integer ;
import java.lang.String ;
import java.io.*;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String s=new String(in.readLine());
    String[] li=s.split("+");
    int A=Integer.parseInt(li[0]);
    int B=Integer.parseInt(li[1]);
    int C=Integer.parseInt(li[2]);
    int i=0,j=7 ;
    while((A*7+B)*(i+1)<C)i++;
    while((A*7+B)*i+A*(j-1)>=C)j--;
    System.out.println(i*7+j);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := StringLib.newString(in.readLine()) ;
    var li : Sequence(String) ; li := s->split("+") ;
    var A : int ; A := (li[0+1])->toInteger() ;
    var B : int ; B := (li[1+1])->toInteger() ;
    var C : int ; C := (li[2+1])->toInteger() ;
    var i : int ; i := 0 ;
    var j : int ; j := 7 ;
    while ((A * 7 + B) * (i + 1) < C) do     i := i + 1 ; ; 
    while ((A * 7 + B) * i + A * (j - 1) >= C) do     j := j - 1 ; ; 
    OclFile["System.out"].println(i * 7 + j) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float trianglearea(float r){
    if(r<0)return-1 ;
    return r*r ;
  }
  public static void main(String[] args){
    float r=5 ;
    System.out.println(trianglearea(r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation trianglearea( r : double) : double
  pre: true
  post: true
  activity: (     if (r < 0) then     return -1 else skip ; 
     return r * r );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : double ; r := 5 ;
     OclFile["System.out"].println(trianglearea(r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void solve(int n){
    double a=n/2 ;
    if(n % 2!=0){
      System.out.println((Math.ceil(a)-1)+" "+(Math.floor(a)+1));
    }
    else {
      if((int)(a)% 2==0){
        System.out.println((Math.ceil(a)-1)+" "+(Math.floor(a)+1));
      }
      else {
        System.out.println((Math.ceil(a)-2)+" "+(Math.floor(a)+2));
      }
    }
  }
  public static void main(String[] args){
    int n=34 ;
    solve(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( n : int) : void
  pre: true
  post: true
  activity: (     var a : double ; a := n / 2 ;
     if (n mod 2 /= 0) then (     OclFile["System.out"].println(((a)->ceil() - 1) + " " + ((a)->floor() + 1)) ) else (     if ((a)->oclAsType(int) mod 2 = 0) then (     OclFile["System.out"].println(((a)->ceil() - 1) + " " + ((a)->floor() + 1)) ) else (     OclFile["System.out"].println(((a)->ceil() - 2) + " " + ((a)->floor() + 2)) ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 34 ;
     execute solve(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1220 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    long arr[][]=new long[n][n];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        arr[i][j]=in.nextLong();
      }
    }
    long zeroIndex=(long)Math.sqrt(((double)(arr[0][1]*arr[0][2])/arr[1][2]));
    System.out.print(zeroIndex+" ");
    for(int i=1 ; i<n ; i++){
      System.out.print(arr[0][i]/zeroIndex+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1220 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(long)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     arr[i+1][j+1] := in.getCurrent()->toLong() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var zeroIndex : long ; zeroIndex := (((arr[0+1][1+1] * arr[0+1][2+1])->oclAsType(double) / arr[1+1][2+1]))->sqrt()->oclAsType(long) ;
    OclFile["System.out"].print(zeroIndex + " ") ; 
        var i : int ; i := 1 ; while i < n do ( (     OclFile["System.out"].print(arr[0+1][i+1] / zeroIndex + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p429 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p429().run());
  }
  private static final int LIMIT=Library.pow(10,8);
  private static final int MODULUS=1000000009 ;
  public String run(){
    int[] primes=Library.listPrimes(LIMIT);
    long sum=1 ;
    for(int p : primes){
      int power=countFactors(LIMIT,p);
      sum*=1+Library.powMod(p,power*2,MODULUS);
      sum %=MODULUS ;
    }
    return Long.toString(sum);
  }
  private static int countFactors(int n,int p){
    if(n==0)return 0 ;
    else return n/p+countFactors(n/p,p);
  }
}
------------------------------------------------------------
OCL File:
---------
class p429 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p429.newp429().run()) );
  static    attribute LIMIT : int := Library.pow(10, 8);
  static    attribute MODULUS : int := 1000000009;
   operation run() : String
  pre: true
  post: true
  activity: (     var primes : Sequence(int) ; primes := Library.listPrimes(LIMIT) ;
     var sum : long ; sum := 1 ;
     for (p : primes) do ( (     var power : int ; power := countFactors(LIMIT, p) ;
     sum := sum*(1 + Library.powMod(p, power * 2, MODULUS)) ; 
     sum := sum mod MODULUS )  ) ; 
     return ((sum) + "") );
  static   operation countFactors( n : int, p : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else     return n / p + countFactors(n / p, p) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf1005B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String str1=scan.next();
    String str2=scan.next();
    int in1=str1.length()-1 ;
    int in2=str2.length()-1 ;
    int cntKeep=0 ;
    while(in1>=0 && in2>=0){
      if(str1.charAt(in1)==str2.charAt(in2)){
        cntKeep+=2 ;
      }
      else {
        break ;
      }
      in1--;
      in2--;
    }
    System.out.println(str1.length()+str2.length()-cntKeep);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1005B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str1 : String ; str1 := scan.getCurrent() ;
    var str2 : String ; str2 := scan.getCurrent() ;
    var in1 : int ; in1 := str1->size() - 1 ;
    var in2 : int ; in2 := str2->size() - 1 ;
    var cntKeep : int ; cntKeep := 0 ;
    while (in1 >= 0 & in2 >= 0) do (     if (str1->at(in1+1) = str2->at(in2+1)) then (     cntKeep := cntKeep+(2) ) else (     break ) ;  
     in1 := in1 - 1 ; 
     in2 := in2 - 1 ) ; 
    OclFile["System.out"].println(str1->size() + str2->size() - cntKeep) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static StringBuilder sb ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sb=new StringBuilder();
    long a=sc.nextLong();
    long b=sc.nextLong();
    sb.append(to32BitBinaryString(a & b)).append("\n");
    sb.append(to32BitBinaryString(a | b)).append("\n");
    sb.append(to32BitBinaryString(a ^ b)).append("\n");
    PrintWriter out=new PrintWriter(System.out);
    out.print(sb);
    out.flush();
    sc.close();
  }
  public static String to32BitBinaryString(long l){
    String s=String.format("%32s",Long.toBinaryString(l)).replace(" ","0");
    return s.substring(s.length()-32,s.length());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sb : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     sb := StringLib.newString() ; 
    var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    sb := sb + StringLib.newString(to32BitBinaryString(MathLib.bitwiseAnd(a,b))) + StringLib.newString("\n") ; 
    sb := sb + StringLib.newString(to32BitBinaryString(MathLib.bitwiseOr(a,b))) + StringLib.newString("\n") ; 
    sb := sb + StringLib.newString(to32BitBinaryString(MathLib.bitwiseXor(a,b))) + StringLib.newString("\n") ; 
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation to32BitBinaryString( l : long) : String
  pre: true
  post: true
  activity: (     var s : String ; s := StringLib.format("%32s",Sequence{(MathLib.decimal2binary(l) + "")}).replace(" ", "0") ;
     return s.subrange(s->size() - 32+1,s->size()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static double maxAverageOfPath(int cost[][],int N){
    int dp[][]=new int[N+1][N+1];
    dp[0][0]=cost[0][0];
    for(int i=1 ; i<N ; i++)dp[i][0]=dp[i-1][0]+cost[i][0];
    for(int j=1 ; j<N ; j++)dp[0][j]=dp[0][j-1]+cost[0][j];
    for(int i=1 ; i<N ; i++)for(int j=1 ; j<N ; j++)dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1])+cost[i][j];
    return(double)dp[N-1][N-1]/(2*N-1);
  }
  public static void main(String[] args){
    int cost[][]={
      {
        1,2,3 },{
          6,5,4 },{
            7,3,9 }
          };
          System.out.println(maxAverageOfPath(cost,3));
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxAverageOfPath( cost : Sequence(Sequence(int)), N : int) : double
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
     dp[0+1][0+1] := cost[0+1][0+1] ; 
        var i : int ; i := 1 ; while i < N do (     dp[i+1][0+1] := dp[i - 1+1][0+1] + cost[i+1][0+1] ;  ;     i := i + 1 ) ; 
        var j : int ; j := 1 ; while j < N do (     dp[0+1][j+1] := dp[0+1][j - 1+1] + cost[0+1][j+1] ;  ;     j := j + 1 ) ; 
        var i : int ; i := 1 ; while i < N do (         var j : int ; j := 1 ; while j < N do (     dp[i+1][j+1] := Set{dp[i - 1+1][j+1], dp[i+1][j - 1+1]}->max() + cost[i+1][j+1] ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return dp[N - 1+1][N - 1+1]->oclAsType(double) / (2 * N - 1) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cost : Sequence(Sequence(int)) ; cost := Sequence{Sequence{1,2,3},Sequence{6,5,4},Sequence{7,3,9}} ;
     OclFile["System.out"].println(maxAverageOfPath(cost, 3)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Train {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int t=1 ;
    while(t-->0){
      String str[]=br.readLine().trim().split(" ");
      int n=Integer.parseInt(str[0]);
      int m=Integer.parseInt(str[1]);
      int k=Integer.parseInt(str[2]);
      boolean tohead=false ;
      str=br.readLine().trim().split(" ");
      if(str[1] .equals("head"))tohead=true ;
      else tohead=false ;
      char a[]=br.readLine().trim().toCharArray();
      int time=a.length ;
      for(int i=0 ; i<time ; i++){
        if(a[i]=='0'){
          if(m!=1 && m!=n){
            int x=Math.abs(k-(m+1));
            int y=Math.abs(k-(m-1));
            if(x>y){
              m++;
            }
            else {
              m--;
            }
          }
          if(tohead)k--;
          else k++;
          if(k==1 || k==n){
            tohead=! tohead ;
          }
        }
        else {
          if(tohead)k--;
          else k++;
          if(k==1 || k==n){
            tohead=! tohead ;
          }
          if(k==1){
            m=n ;
          }
          else if(k==n){
            m=1 ;
          }
          else {
            if(tohead)m=n ;
            else m=1 ;
          }
        }
        if(m==k){
          System.out.println("Controller "+(i+1));
          System.exit(0);
        }
      }
      pw.println("Stowaway");
    }
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Train {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := 1 ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var str : Sequence(String) ; str := br.readLine()->trim()->split(" ") ;
     var n : int ; n := (str[0+1])->toInteger() ;
    var m : int ; m := (str[1+1])->toInteger() ;
    var k : int ; k := (str[2+1])->toInteger() ;
    var tohead : boolean ; tohead := false ;
    str := br.readLine()->trim()->split(" ") ; 
    if (str[1+1] = "head") then     tohead := true else     tohead := false ; ;  
    var a : Sequence(String) ; a := br.readLine()->trim()->characters() ;
    var time : int ; time := a->size() ;
        var i : int ; i := 0 ; while i < time do ( (     if (a[i+1] = '0') then (     if (m /= 1 & m /= n) then (     var x : int ; x := if k - (m + 1) < 0 then -(k - (m + 1)) else k - (m + 1) endif ;
     var y : int ; y := if k - (m - 1) < 0 then -(k - (m - 1)) else k - (m - 1) endif ;
     if (x > y) then (     m := m + 1 ) else (     m := m - 1 ) ) else skip ; 
     if (tohead) then     k := k - 1 else     k := k + 1 ; ;  
     if (k = 1 or k = n) then (     tohead := not(tohead) ) else skip ) else (     if (tohead) then     k := k - 1 else     k := k + 1 ; ;  
     if (k = 1 or k = n) then (     tohead := not(tohead) ) else skip ; 
     if (k = 1) then (     m := n ) else     if (k = n) then (     m := 1 ) else (     if (tohead) then     m := n ; else     m := 1 ; ) ;  ) ;  
     if (m = k) then (     OclFile["System.out"].println("Controller " + (i + 1)) ; 
 OclProcess.exit(0) ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B74 {
  public static void main(String[] args){
    new B74().run();
  }
  public void run(){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    int k=scanner.nextInt();
    scanner.nextLine();
    String di=scanner.nextLine();
    String time=scanner.nextLine();
    char[] ts=time.toCharArray();
    for(int i=0 ; i<ts.length ; ++i){
      if(ts[i]=='0'){
        if(m>k){
          m=m==n ? n : m+1 ;
        }
        else {
          m=m==1 ? 1 : m-1 ;
        }
      }
      else {
        m=k ;
      }
      k+=getControllerStep(di);
      di=changeDirection(di,k,n);
      if(m==k){
        System.out.println("Controller "+String.valueOf(i+1));
        break ;
      }
    }
    if(m!=k){
      System.out.println("Stowaway");
    }
  }
  private int getControllerStep(String di){
    if(di.equals("to head")){
      return-1 ;
    }
    else {
      return 1 ;
    }
  }
  private String changeDirection(String di,int c,int n){
    if(di.equals("to head")&& c==1){
      return "to tail" ;
    }
    if(di.equals("to tail")&& c==n){
      return "to head" ;
    }
    return di ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B74 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     B74.newB74().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
    skip ; 
    var di : String ; di := scanner.nextLine() ;
    var time : String ; time := scanner.nextLine() ;
    var ts : Sequence(String) ; ts := time->characters() ;
        var i : int ; i := 0 ; while i < ts->size() do ( (     if (ts[i+1] = '0') then (     if (m > k) then (     m := if m = n then n else m + 1 endif ) else (     m := if m = 1 then 1 else m - 1 endif ) ) else (     m := k ) ;  
     k := k+(getControllerStep(di)) ; 
     di := changeDirection(di, k, n) ; 
     if (m = k) then (     OclFile["System.out"].println("Controller " + ((i + 1) + "")) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (m /= k) then (     OclFile["System.out"].println("Stowaway") ) else skip ; 
 );
   operation getControllerStep( di : String) : int
  pre: true
  post: true
  activity: (     if (di = "to head") then (     return -1 ) else (     return 1 ) );
   operation changeDirection( di : String, c : int, n : int) : String
  pre: true
  post: true
  activity: (     if (di = "to head" & c = 1) then (     return "to tail" ) else skip ; 
     if (di = "to tail" & c = n) then (     return "to head" ) else skip ; 
     return di );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B74 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int stowaway=in.nextInt();
    int controller=in.nextInt();
    if(stowaway<controller){
      stowaway=1 ;
    }
    else {
      stowaway=N ;
    }
    in.next();
    boolean toHead="head".equals(in.next());
    char[] S=in.next().toCharArray();
    int end=0 ;
    for(int step=0 ; step<S.length ; step++){
      char c=S[step];
      if(c=='1'){
        if(toHead){
          stowaway=N ;
        }
        else {
          stowaway=1 ;
        }
      }
      if(toHead){
        controller--;
        if(controller==1){
          toHead=false ;
        }
      }
      else {
        controller++;
        if(controller==N){
          toHead=true ;
        }
      }
      if(controller==stowaway){
        end=step+1 ;
        break ;
      }
    }
    if(end==0){
      System.out.println("Stowaway");
    }
    else {
      System.out.println("Controller "+end);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B74 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var stowaway : int ; stowaway := in.getCurrent()->toInteger() ;
    var controller : int ; controller := in.getCurrent()->toInteger() ;
    if (stowaway < controller) then (     stowaway := 1 ) else (     stowaway := N ) ;  
    skip ; 
    var toHead : boolean ; toHead := "head" = in.getCurrent() ;
    var S : Sequence(String) ; S := in.getCurrent()->characters() ;
    var end : int ; end := 0 ;
        var step : int ; step := 0 ; while step < S->size() do ( (     var c : String ; c := S[step+1] ;
     if (c = '1') then (     if (toHead) then (     stowaway := N ) else (     stowaway := 1 ) ) else skip ; 
     if (toHead) then (     controller := controller - 1 ; 
     if (controller = 1) then (     toHead := false ) else skip ) else (     controller := controller + 1 ; 
     if (controller = N) then (     toHead := true ) else skip ) ;  
     if (controller = stowaway) then (     end := step + 1 ; 
     break ) else skip )  ;     step := step + 1 ) ; 
    if (end = 0) then (     OclFile["System.out"].println("Stowaway") ) else (     OclFile["System.out"].println("Controller " + end) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Bomb {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String[] s=in.readLine().split(" ");
    int n=Integer.parseInt(s[0]);
    int m=Integer.parseInt(s[1]);
    String[] l=new String[n];
    int[] v=new int[n];
    int[] g=new int[m];
    int all=0 ;
    for(int i=0 ; i<n ; i++){
      l[i]=in.readLine();
      char[] c=l[i] .toCharArray();
      for(int j=0 ; j<m ; j++){
        if(c[j]=='*'){
          g[j]++;
          v[i]++;
          all++;
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      char[] temp=l[i] .toCharArray();
      for(int j=0 ; j<m ; j++){
        int d=v[i]+g[j];
        if(temp[j]=='*')d--;
        if(d==all){
          System.out.println("YES");
          System.out.println((i+1)+" "+(j+1));
          return ;
        }
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Bomb {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : Sequence(String) ; s := in.readLine()->split(" ") ;
    var n : int ; n := (s[0+1])->toInteger() ;
    var m : int ; m := (s[1+1])->toInteger() ;
    var l : Sequence(String) ; l := Integer.subrange(1,n)->collect(null) ;
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
    var g : Sequence(int) ; g := Integer.subrange(1,m)->collect(0) ;
    var all : int ; all := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     l[i+1] := in.readLine() ; 
     var c : Sequence(String) ; c := l[i+1]->characters() ;
         var j : int ; j := 0 ; while j < m do ( (     if (c[j+1] = '*') then (     g[j+1] := g[j+1] + 1 ; 
     v[i+1] := v[i+1] + 1 ; 
     all := all + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var temp : Sequence(String) ; temp := l[i+1]->characters() ;
         var j : int ; j := 0 ; while j < m do ( (     var d : int ; d := v[i+1] + g[j+1] ;
     if (temp[j+1] = '*') then     d := d - 1 ; else skip ; 
     if (d = all) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println((i + 1) + " " + (j + 1)) ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int m=s.nextInt();
    s.nextLine();
    int star=0 ;
    char[][] a=new char[n][m];
    int[] starRow=new int[n];
    int[] starCol=new int[m];
    for(int row=0 ; row<n ; row++){
      String line=s.nextLine();
      for(int col=0 ; col<line.length(); col++){
        a[row][col]=line.charAt(col);
        if(a[row][col]=='*'){
          star++;
          starRow[row]++;
          starCol[col]++;
        }
      }
    }
    if(star==0){
      System.out.println("YES");
      System.out.println("1 1");
      return ;
    }
    for(int row=0 ; row<n ; row++){
      for(int col=0 ; col<m ; col++){
        if(a[row][col]=='*' && starRow[row]+starCol[col]-1==star){
          System.out.println("YES");
          System.out.println((row+1)+" "+(col+1));
          return ;
        }
        else if(a[row][col]=='.' && starRow[row]+starCol[col]==star){
          System.out.println("YES");
          System.out.println((row+1)+" "+(col+1));
          return ;
        }
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var m : int ; m := s.getCurrent()->toInteger() ;
    skip ; 
    var star : int ; star := 0 ;
    var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var starRow : Sequence(int) ; starRow := Integer.subrange(1,n)->collect(0) ;
    var starCol : Sequence(int) ; starCol := Integer.subrange(1,m)->collect(0) ;
        var row : int ; row := 0 ; while row < n do ( (     var line : String ; line := s.nextLine() ;
         var col : int ; col := 0 ; while col < line->size() do ( (     a[row+1][col+1] := line->at(col+1) ; 
     if (a[row+1][col+1] = '*') then (     star := star + 1 ; 
     starRow[row+1] := starRow[row+1] + 1 ; 
     starCol[col+1] := starCol[col+1] + 1 ) else skip )  ;     col := col + 1 ) )  ;     row := row + 1 ) ; 
    if (star = 0) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println("1 1") ; 
     return ) else skip ; 
        var row : int ; row := 0 ; while row < n do ( (         var col : int ; col := 0 ; while col < m do ( (     if (a[row+1][col+1] = '*' & starRow[row+1] + starCol[col+1] - 1 = star) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println((row + 1) + " " + (col + 1)) ; 
     return ) else     if (a[row+1][col+1] = '.' & starRow[row+1] + starCol[col+1] = star) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println((row + 1) + " " + (col + 1)) ; 
     return ) else skip ; )  ;     col := col + 1 ) )  ;     row := row + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int n=gi();
    int[] A=new int[n];
    for(int i=0 ; i<n ; i++){
      A[i]=gi();
    }
    Arrays.parallelSort(A);
    System.out.print(A[A.length-1]-A[0]);
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := gi() ;
    var A : Sequence(int) ; A := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := gi() )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    OclFile["System.out"].print(A[A->size() - 1+1] - A[0+1]) ; 
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.stream.IntStream ;
import java.io.UncheckedIOException ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.util.OptionalInt ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    LightScanner in=new LightScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BTravelingAtCoDeerProblem solver=new BTravelingAtCoDeerProblem();
    solver.solve(1,in,out);
    out.close();
  }
  static class BTravelingAtCoDeerProblem {
    public void solve(int testNumber,LightScanner in,PrintWriter out){
      int n=in.ints();
      int[] a=in.ints(n);
      out.println(Arrays.stream(a).max().getAsInt()-Arrays.stream(a).min().getAsInt());
    }
  }
  static class LightScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public LightScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String string(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int ints(){
      return Integer.parseInt(string());
    }
    public int[] ints(int length){
      return IntStream.range(0,length).map(x->ints()).toArray();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : LightScanner ; in := LightScanner.newLightScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BTravelingAtCoDeerProblem ; solver := BTravelingAtCoDeerProblem.newBTravelingAtCoDeerProblem() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BTravelingAtCoDeerProblem {
   operation solve( testNumber : int, in : LightScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.ints() ;
     var a : Sequence(int) ; a := in.ints(n) ;
     skip );
}
  static class LightScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newLightScanner( in : OclFile) : LightScanner
  pre: true
  post: true
  activity:
  ( var self : LightScanner ;
    self := createLightScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation string() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation ints() : int
  pre: true
  post: true
  activity: (     return (string())->toInteger() );
   operation ints( length : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, length-1)->collect( _x1 | (lambda x : OclAny in ints())->apply(_x1) )->asSequence() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  int n ;
  public static void main(String args[]){
    new Main().run();
  }
  void run(){
    FastReader sc=new FastReader();
    n=sc.nextInt();
    int max=0 ;
    int min=1000 ;
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      if(max<a){
        max=a ;
      }
      if(a<min){
        min=a ;
      }
    }
    System.out.println(max-min);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     n := sc.nextInt() ; 
    var max : int ; max := 0 ;
    var min : int ; min := 1000 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.nextInt() ;
     if (max < a) then (     max := a ) else skip ; 
     if (a < min) then (     min := a ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max - min) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.util.InputMismatchException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskB solver=new TaskB();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskB {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int[] a=in.nextIntArray(n);
      int max=a[0];
      int min=a[0];
      for(int i=0 ; i<n ; i++){
        max=Math.max(max,a[i]);
        min=Math.min(min,a[i]);
      }
      out.println(max-min);
    }
  }
  static class InputReader {
    BufferedReader in ;
    StringTokenizer tok ;
    public String nextString(){
      while(! tok.hasMoreTokens()){
        try {
          tok=new StringTokenizer(in.readLine()," ");
        }
        catch(IOException e){
          throw new InputMismatchException();
        }
      }
      return tok.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(nextString());
    }
    public int[] nextIntArray(int n){
      int[] res=new int[n];
      for(int i=0 ; i<n ; i++){
        res[i]=nextInt();
      }
      return res ;
    }
    public InputReader(InputStream inputStream){
      in=new BufferedReader(new InputStreamReader(inputStream));
      tok=new StringTokenizer("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskB ; solver := TaskB.newTaskB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskB {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var a : Sequence(int) ; a := in.nextIntArray(n) ;
    var max : int ; max := a[0+1] ;
    var min : int ; min := a[0+1] ;
        var i : int ; i := 0 ; while i < n do ( (     max := Set{max, a[i+1]}->max() ; 
     min := Set{min, a[i+1]}->min() )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute in : OclFile;
   attribute tok : OclIterator;
   operation nextString() : String
  pre: true
  post: true
  activity: (     while (not(tok.hasNext())) do (     try (     tok := OclIterator.newOclIterator_String_String(in.readLine(), " ") )   catch (e : IOException) do (     error IncorrectElementException() )
 ) ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextString())->toInteger() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return res );
   static operation newInputReader( inputStream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) ; 
     tok := OclIterator.newOclIterator_String("") );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static void BubbleSort(int d[]){
    for(int i=d.length-1 ; i>0 ; i--){
      for(int j=0 ; j<i ; j++){
        if(d[j]>d[j+1]){
          int work ;
          work=d[j];
          d[j]=d[j+1];
          d[j+1]=work ;
        }
      }
    }
  }
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int h[]=new int[N];
    for(int i=0 ; i<N ; i++){
      h[i]=scan.nextInt();
    }
    BubbleSort(h);
    int ans ;
    ans=h[N-1]-h[0];
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation BubbleSort( d : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := d->size() - 1 ; while i > 0 do ( (         var j : int ; j := 0 ; while j < i do ( (     if (d[j+1] > d[j + 1+1]) then (     var work : int ;
     work := d[j+1] ; 
     d[j+1] := d[j + 1+1] ; 
     d[j + 1+1] := work ) else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var h : Sequence(int) ; h := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     h[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute BubbleSort(h) ; 
    var ans : int ;
    ans := h[N - 1+1] - h[0+1] ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAX=1000000 ;
  static int sieve_Prime[]=new int[MAX+4];
  static int sieve_count[]=new int[MAX+4];
  static void form_sieve(){
    sieve_Prime[1]=1 ;
    for(int i=2 ; i<=MAX ; i++){
      if(sieve_Prime[i]==0){
        for(int j=i*2 ; j<=MAX ; j+=i){
          if(sieve_Prime[j]==0){
            sieve_Prime[j]=1 ;
            sieve_count[i]++;
          }
        }
      }
    }
  }
  public static void main(String[] args){
    form_sieve();
    int n=2 ;
    System.out.println("Count="+(sieve_count[n]+1));
    n=3 ;
    System.out.println("Count="+(sieve_count[n]+1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 1000000;
  static   attribute sieve_Prime : int := Integer.subrange(1,MAX + 4)->collect(0);
  static   attribute sieve_count : int := Integer.subrange(1,MAX + 4)->collect(0);
  static   operation form_sieve() : void
  pre: true
  post: true
  activity: (     sieve_Prime[1+1] := 1 ; 
         var i : int ; i := 2 ; while i <= MAX do ( (     if (sieve_Prime[i+1] = 0) then (         var j : int ; j := i * 2 ; while j <= MAX do ( (     if (sieve_Prime[j+1] = 0) then (     sieve_Prime[j+1] := 1 ; 
     sieve_count[i+1] := sieve_count[i+1] + 1 ) else skip )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute form_sieve() ; 
     var n : int ; n := 2 ;
    OclFile["System.out"].println("Count=" + (sieve_count[n+1] + 1)) ; 
    n := 3 ; 
    OclFile["System.out"].println("Count=" + (sieve_count[n+1] + 1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.nio.Buffer ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String first=br.readLine();
    String second=br.readLine();
    int res=0 ;
    int x=0 ;
    int i=Math.min(first.length(),second.length())-1 ;
    while(i>=0){
      if(first.length()==second.length()){
        if(first.charAt(i)!=second.charAt(i))break ;
        else i--;
      }
      else {
        if(first.length()>second.length()){
          if(first.charAt(first.length()-1-x)!=second.charAt(i))break ;
          else {
            i--;
            x++;
          }
        }
        else {
          if(second.charAt(second.length()-1-x)!=first.charAt(i))break ;
          else {
            i--;
            x++;
          }
        }
      }
    }
    if(i==-1){
      System.out.println(Math.abs(first.length()-second.length()));
      return ;
    }
    else {
      res+=Math.abs(first.length()-second.length());
      res+=(i+1)*2 ;
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var first : String ; first := br.readLine() ;
    var second : String ; second := br.readLine() ;
    var res : int ; res := 0 ;
    var x : int ; x := 0 ;
    var i : int ; i := Set{first->size(), second->size()}->min() - 1 ;
    while (i >= 0) do (     if (first->size() = second->size()) then (     if (first->at(i+1) /= second->at(i+1)) then     break else     i := i - 1 ; ) else (     if (first->size() > second->size()) then (     if (first->at(first->size() - 1 - x+1) /= second->at(i+1)) then     break else (     i := i - 1 ; 
     x := x + 1 ) ) else (     if (second->at(second->size() - 1 - x+1) /= first->at(i+1)) then     break else (     i := i - 1 ; 
     x := x + 1 ) ) ) ) ; 
    if (i = -1) then (     OclFile["System.out"].println(if first->size() - second->size() < 0 then -(first->size() - second->size()) else first->size() - second->size() endif) ; 
     return ) else (     res := res+(if first->size() - second->size() < 0 then -(first->size() - second->size()) else first->size() - second->size() endif) ; 
     res := res+((i + 1) * 2) ; 
     OclFile["System.out"].println(res) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean Check_is_possible(int l,int r,int k){
    int div_count=(r/k)-(l/k);
    if(l % k==0){
      div_count++;
    }
    return(div_count>1);
  }
  public static void main(String[] args){
    int l=30,r=70,k=10 ;
    if(Check_is_possible(l,r,k)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Check_is_possible( l : int, r : int, k : int) : boolean
  pre: true
  post: true
  activity: (     var div_count : int ; div_count := (r / k) - (l / k) ;
     if (l mod k = 0) then (     div_count := div_count + 1 ) else skip ; 
     return (div_count > 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 30 ;
    var r : int ; r := 70 ;
    var k : int ; k := 10 ;
     if (Check_is_possible(l, r, k)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void CalPeri(){
    int S=5,Perimeter ;
    Perimeter=10*S ;
    System.out.println("The Perimeter of Decagon is : "+Perimeter);
  }
  public static void main(String[] args){
    CalPeri();
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation CalPeri() : void
  pre: true
  post: true
  activity: (     var S : int ; S := 5 ;
    var Perimeter : int ;
     Perimeter := 10 * S ; 
     OclFile["System.out"].println("The Perimeter of Decagon is : " + Perimeter) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute CalPeri() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class solve {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    int ans=0 ;
    TreeMap<Double,Double>hm=new TreeMap<>();
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      int a=sc.nextInt();
      hm.put((x-(a*1d/2)),(x+(a*1d/2)));
    }
    double[] start=new double[hm.size()];
    double[] end=new double[hm.size()];
    int idx=0 ;
    for(Map.Entry map : hm.entrySet()){
      start[idx]=(double)map.getKey();
      end[idx]=(double)map.getValue();
      idx++;
    }
    for(int i=1 ; i<hm.size(); i++){
      if(start[i]-end[i-1]>t){
        ans+=2 ;
      }
      else if(start[i]-end[i-1]==t)ans+=1 ;
    }
    System.out.println(ans+2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solve {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    var hm : Map(double,double) ; hm := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     hm := hm->union(Map{(x - (a * 1d / 2)) |-> (x + (a * 1d / 2))}) )  ;     i := i + 1 ) ; 
    var start : Sequence(double) ; start := Integer.subrange(1,hm.size())->collect(0.0) ;
    var end : Sequence(double) ; end := Integer.subrange(1,hm.size())->collect(0.0) ;
    var idx : int ; idx := 0 ;
    for (map : hm->asSet()) do ( (     start[idx+1] := map.getKey()->oclAsType(double) ; 
     end[idx+1] := map.getValue()->oclAsType(double) ; 
     idx := idx + 1 )  ) ; 
        var i : int ; i := 1 ; while i < hm.size() do ( (     if (start[i+1] - end[i - 1+1] > t) then (     ans := ans+(2) ) else     if (start[i+1] - end[i - 1+1] = t) then     ans := ans+(1) ; else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans + 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Scanner ;
public class RENAMETHISBITCH2 {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      int t=sc.nextInt();
      List<float[]>sections=new ArrayList<>();
      int count=2 ;
      for(int i=0 ; i<n ; i++){
        int x=sc.nextInt();
        int a=sc.nextInt();
        sections.add(new float[] {
          x-a/2f,x+a/2f }
);
        }
        Collections.sort(sections,new ArrayComparator());
        for(int i=0 ; i<n-1 ; i++){
          float d=Math.abs(sections.get(i+1)[0]-sections.get(i)[1]);
          if(t==d)count++;
          else if(t<d)count+=2 ;
        }
        System.out.println(count);
      }
      catch(Exception e){
        e.printStackTrace();
      }
    }
  }
  class ArrayComparator implements Comparator<float[]>{
    public int compare(float[] i1,float[] i2){
      return(int)(i1[0]-i2[0]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class RENAMETHISBITCH2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var sections : Sequence(Sequence(double)) ; sections := Sequence{} ;
    var count : int ; count := 2 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     sections := sections->including(Sequence{x - a / 2f,x + a / 2f}) )  ;     i := i + 1 ) ; 
    sections, ArrayComparator.newArrayComparator() := sections, ArrayComparator.newArrayComparator()->sort() ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var d : double ; d := if sections->at(i + 1+1)[0+1] - sections->at(i+1)[1+1] < 0 then -(sections->at(i + 1+1)[0+1] - sections->at(i+1)[1+1]) else sections->at(i + 1+1)[0+1] - sections->at(i+1)[1+1] endif ;
     if (t = d) then     count := count + 1 ; else     if (t < d) then     count := count+(2) ; else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ))   catch (e : ProgramException) do (     e.printStackTrace() )
  );
}
class ArrayComparator implements Function(<Sequence(double)>,(<Sequence(double)>,boolean)) {
   operation compare( i1 : Sequence(double), i2 : Sequence(double)) : int
  pre: true
  post: true
  activity: (     return (i1[0+1] - i2[0+1])->oclAsType(int) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class A15 {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    List<Integer>x=new ArrayList<>();
    List<Integer>x2=new ArrayList<>();
    List<Float>a2=new ArrayList<>();
    List<Float>a=new ArrayList<>();
    float d ;
    int res=0 ;
    int n=scan.nextInt();
    int t=scan.nextInt();
    for(int i=0 ; i<n ; i++){
      x.add(scan.nextInt());
      x2.add(x.get(i));
      a2.add(scan.nextFloat());
    }
    Collections.sort(x);
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(x.get(i)==x2.get(j))a.add(a2.get(j));
      }
    }
    for(int i=0 ; i<n-1 ; i++){
      d=x.get(i+1)-x.get(i)-(a.get(i+1)/2+a.get(i)/2);
      if(d>t)res+=2 ;
      else if(d==t)res+=1 ;
    }
    System.out.print(res+2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A15 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : Sequence(int) ; x := Sequence{} ;
    var x2 : Sequence(int) ; x2 := Sequence{} ;
    var a2 : Sequence(double) ; a2 := Sequence{} ;
    var a : Sequence(double) ; a := Sequence{} ;
    var d : double ;
    var res : int ; res := 0 ;
    var n : int ; n := scan.getCurrent()->toInteger() ;
    var t : int ; t := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     x := x->including(scan.getCurrent()->toInteger()) ; 
     x2 := x2->including(x->at(i+1)) ; 
     a2 := a2->including(scan.nextFloat()) )  ;     i := i + 1 ) ; 
    x := x->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (x->at(i+1) = x2->at(j+1)) then     a := a->including(a2->at(j+1)) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     d := x->at(i + 1+1) - x->at(i+1) - (a->at(i + 1+1) / 2 + a->at(i+1) / 2) ; 
     if (d > t) then     res := res+(2) ; else     if (d = t) then     res := res+(1) ; else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(res + 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner in=new Scanner(System.in);
  public static void main(String[] args)throws Exception {
    int[] counts=new int['z'-'a'+1];
    int c ;
    while((c=System.in.read())!=-1){
      if('A'<=c && c<='Z'){
        c-=('A'-'a');
      }
      if('a'<=c && c<='z'){
        counts[c-'a']++;
      }
    }
    for(int i=0 ; i<counts.length ; i++){
      StringBuilder sb=new StringBuilder();
      sb.append((char)('a'+i)).append(" : ").append(counts[i]);
      System.out.println(sb.toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var counts : Sequence(int) ; counts := Integer.subrange(1,('z')->char2byte() - ('a')->char2byte() + 1)->collect(0) ;
     var c : int ;
         c := OclFile["System.in"].read() ;
    while ((c) /= -1) do (    skip ; (     if ('A' <= c & c <= 'Z') then (     c := c-((('A')->char2byte() - ('a')->char2byte())) ) else skip ; 
     if ('a' <= c & c <= 'z') then (     counts[c - ('a')->char2byte()+1] := counts[c - ('a')->char2byte()+1] + 1 ) else skip ) ;     c := OclFile["System.in"].read() ;
 ) ;  
         var i : int ; i := 0 ; while i < counts->size() do ( (     var sb : String ; sb := StringLib.newString() ;
     sb := sb + StringLib.newString(('a' + i)->oclAsType(String)) + StringLib.newString(" : ") + StringLib.newString(counts[i+1]) ; 
     OclFile["System.out"].println(sb+"") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.HashMap ;
class Main {
  public static void main(String args[]){
    HashMap<Integer,Integer>hm=new HashMap<Integer,Integer>();
    Scanner scan=new Scanner(System.in);
    for(int i=97 ; i<=122 ; i++){
      hm.put(i,0);
    }
    while(scan.hasNext()){
      String str=scan.nextLine();
      for(int i=0 ; i<str.length(); i++){
        if(65<=str.charAt(i)&& str.charAt(i)<=90){
          hm.put(str.charAt(i)+32,hm.get(str.charAt(i)+32)+1);
        }
        else if(97<=str.charAt(i)&& str.charAt(i)<=122){
          hm.put((int)str.charAt(i),hm.get((int)str.charAt(i))+1);
        }
      }
    }
    for(int i=97 ; i<=122 ; i++){
      System.out.println((char)i+" : "+hm.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var hm : Map(int,int) ; hm := Map{} ;
     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
        var i : int ; i := 97 ; while i <= 122 do ( (     hm := hm->union(Map{i |-> 0}) )  ;     i := i + 1 ) ; 
    while (scan.hasNext()) do (     var str : String ; str := scan.nextLine() ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (65 <= str->at(i+1) & str->at(i+1) <= 90) then (     hm := hm->union(Map{str->at(i+1) + 32 |-> hm->at(str->at(i+1) + 32) + 1}) ) else     if (97 <= str->at(i+1) & str->at(i+1) <= 122) then (     hm := hm->union(Map{str->at(i+1)->oclAsType(int) |-> hm->at(str->at(i+1)->oclAsType(int)) + 1}) ) else skip ; )  ;     i := i + 1 ) ) ; 
        var i : int ; i := 97 ; while i <= 122 do ( (     OclFile["System.out"].println(i->oclAsType(String) + " : " + hm->at(i)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int[] count=new int[26];
  static String[] alfa={
    "a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z" };
    public static void main(String[] args){
      @ SuppressWarnings("resource")Scanner sc2=new Scanner(System.in);
      while(sc2.hasNext()){
        String[] s=sc2.nextLine().split("");
        for(String s1 : s){
          if(! s1.equals("")){
            for(int i=0 ; i<Main.alfa.length ; i++){
              if(s1.equalsIgnoreCase(alfa[i])){
                count[i]++;
              }
            }
          }
        }
      }
      Main.end();
    }
    public static void end(){
      for(int i=0 ; i<Main.alfa.length ; i++){
        System.out.println(alfa[i]+" : "+count[i]);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute count : Sequence(int) := Integer.subrange(1,26)->collect(0);
  static   attribute alfa : Sequence(String) := Sequence{"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc2 : OclFile ; sc2 := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc2.hasNext()) do (     var s : Sequence(String) ; s := sc2.nextLine()->split("") ;
     for (s1 : s) do ( (     if (not(s1 = "")) then (         var i : int ; i := 0 ; while i < Main.alfa->size() do ( (     if (s1->equalsIgnoreCase(alfa[i+1])) then (     count[i+1] := count[i+1] + 1 ) else skip )  ;     i := i + 1 ) ) else skip )  ) ) ; 
     Main.end() );
  static   operation end() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < Main.alfa->size() do ( (     OclFile["System.out"].println(alfa[i+1] + " : " + count[i+1]) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Map<Character,Integer>counts=new HashMap<Character,Integer>();
    for(Character ch='a' ; ch<='z' ; ch++)counts.put(ch,0);
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      String line=scan.nextLine();
      for(char rawch : line.toCharArray()){
        Character ch=Character.toLowerCase(rawch);
        int count=0 ;
        if(counts.containsKey(ch))count=counts.get(ch);
        counts.put(ch,count+1);
      }
    }
    for(Character ch='a' ; ch<='z' ; ch++){
      int count=counts.get(ch);
      System.out.printf("%c : %d\n",ch,count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var counts : Map(String,int) ; counts := Map{} ;
         var ch : String ; ch := 'a' ; while ch <= 'z' do (     counts := counts->union(Map{ch |-> 0}) ;  ;     ch := ch + 1 ) ; 
    var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (scan.hasNext()) do (     var line : String ; line := scan.nextLine() ;
     for (rawch : line->characters()) do ( (     var ch : String ; ch := (rawch + "")->toLowerCase() ;
     var count : int ; count := 0 ;
     if (counts->keys()->includes(ch)) then     count := counts->at(ch) ; else skip ; 
     counts := counts->union(Map{ch |-> count + 1}) )  ) ) ; 
        var ch : String ; ch := 'a' ; while ch <= 'z' do ( (     var count : int ; count := counts->at(ch) ;
     OclFile["System.out"].printf("%c : %d\n", ch, count) )  ;     ch := ch + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,k,t,u,v,l ;
    n=sc.nextInt();
    k=sc.nextInt();
    t=sc.nextInt();
    u=sc.nextInt();
    v=sc.nextInt();
    l=sc.nextInt();
    int[] d=new int[n+1];
    for(int i=0 ; i<n ; ++i)d[i]=sc.nextInt();
    d[n]=l ;
    int pos=0,c=0,nk=0 ;
    double tm=0 ;
    while(pos<l){
      if(pos<d[c]){
        if(nk>0){
          nk--;
          int x=Math.min(l,pos+t*v);
          tm+=(x-pos)/(double)v ;
          pos=x ;
        }
        else {
          tm+=(d[c]-pos)/(double)u ;
          pos=d[c];
        }
      }
      else {
        if(d[c]==pos){
          int x=Math.min(l,pos+t*v);
          tm+=(x-pos)/(double)v ;
          pos=x ;
++c ;
        }
        else {
          if(nk<k){
            c++;
            nk++;
          }
          else {
            int x=Math.min(l,d[c++]+t*v);
            tm+=(x-pos)/(double)v ;
            pos=x ;
          }
        }
      }
    }
    System.out.println(tm);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var k : int ;
    var t : int ;
    var u : int ;
    var v : int ;
    var l : int ;
    n := sc.getCurrent()->toInteger() ; 
    k := sc.getCurrent()->toInteger() ; 
    t := sc.getCurrent()->toInteger() ; 
    u := sc.getCurrent()->toInteger() ; 
    v := sc.getCurrent()->toInteger() ; 
    l := sc.getCurrent()->toInteger() ; 
    var d : Sequence(int) ; d := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     d[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    d[n+1] := l ; 
    var pos : int ; pos := 0 ;
    var c : int ; c := 0 ;
    var nk : int ; nk := 0 ;
    var tm : double ; tm := 0 ;
    while (pos < l) do (     if (pos < d[c+1]) then (     if (nk > 0) then (     nk := nk - 1 ; 
     var x : int ; x := Set{l, pos + t * v}->min() ;
     tm := tm+((x - pos) / v->oclAsType(double)) ; 
     pos := x ) else (     tm := tm+((d[c+1] - pos) / u->oclAsType(double)) ; 
     pos := d[c+1] ) ) else (     if (d[c+1] = pos) then (     var x : int ; x := Set{l, pos + t * v}->min() ;
     tm := tm+((x - pos) / v->oclAsType(double)) ; 
     pos := x ; 
     c := c + 1 ) else (     if (nk < k) then (     c := c + 1 ; 
     nk := nk + 1 ) else (     var x : int ; x := Set{l, d[c+1] + t * v}->min() ;
     tm := tm+((x - pos) / v->oclAsType(double)) ; 
     pos := x ) ) ) ) ; 
    OclFile["System.out"].println(tm) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    try {
      int count=0 ;
      int[] num=new int[26];
      BufferedReader stdReader=new BufferedReader(new InputStreamReader(System.in));
      String line ;
      while((line=stdReader.readLine())!=null){
        for(int i=0 ; i<line.length(); ++i){
          if('a'<=line.charAt(i)&& line.charAt(i)<='z'){
++num[line.charAt(i)-'a'];
          }
          else if('A'<=line.charAt(i)&& line.charAt(i)<='Z'){
++num[line.charAt(i)-'A'];
          }
        }
      }
      stdReader.close();
      for(int i=0 ; i<26 ; ++i){
        System.out.println((char)(i+'a')+" : "+num[i]);
      }
    }
    catch(Exception e){
      e.getStackTrace();
      System.exit(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var count : int ; count := 0 ;
     var num : Sequence(int) ; num := Integer.subrange(1,26)->collect(0) ;
    var stdReader : OclFile ; stdReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var line : String ;
        line := stdReader.readLine() ;
    while ((line) /= null) do (    skip ; (         var i : int ; i := 0 ; while i < line->size() do ( (     if ('a' <= line->at(i+1) & line->at(i+1) <= 'z') then (     num[line->at(i+1) - ('a')->char2byte()+1] := num[line->at(i+1) - ('a')->char2byte()+1] + 1 ) else     if ('A' <= line->at(i+1) & line->at(i+1) <= 'Z') then (     num[line->at(i+1) - ('A')->char2byte()+1] := num[line->at(i+1) - ('A')->char2byte()+1] + 1 ) else skip ; )  ;     i := i + 1 ) ) ;     line := stdReader.readLine() ;
 ) ;  
    skip ; 
        var i : int ; i := 0 ; while i < 26 do ( (     OclFile["System.out"].println((i + 'a')->oclAsType(String) + " : " + num[i+1]) )  ;     i := i + 1 ) ; 
 )   catch (e : ProgramException) do (     e.getStackTrace() ; 
 OclProcess.exit(-1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static int find(String s,String t){
    s=s.toLowerCase();
    t=t.toLowerCase();
    int n1=s.length()-1 ;
    int n2=t.length()-1 ;
    while(Math.min(n1,n2)>=0){
      if(s.charAt(n1)!=t.charAt(n2))break ;
      n1--;
      n2--;
    }
    return n1+n2+2 ;
  }
  public static void main(String[] args){
    try {
      System.setIn(new FileInputStream("input.txt"));
      System.setOut(new PrintStream(new FileOutputStream("output.txt")));
    }
    catch(Exception e){
      System.err.println("Error");
    }
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String t=sc.next();
    System.out.println(find(s,t));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation find( s : String, t : String) : int
  pre: true
  post: true
  activity: (     s := s->toLowerCase() ; 
     t := t->toLowerCase() ; 
    var n1 : int ; n1 := s->size() - 1 ;
    var n2 : int ; n2 := t->size() - 1 ;
    while (Set{n1, n2}->min() >= 0) do (     if (s->at(n1+1) /= t->at(n2+1)) then     break else skip ; 
     n1 := n1 - 1 ; 
     n2 := n2 - 1 ) ; 
    return n1 + n2 + 2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) )   catch (e : ProgramException) do (     OclFile["System.err"].println("Error") )
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    OclFile["System.out"].println(find(s, t)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int n ;
  static int[][] dp=new int[1000][1000];
  static String str="abcb" ;
  static int countPS(int i,int j){
    if(i>=n || j<0)return 0 ;
    if(dp[i][j]!=-1)return dp[i][j];
    if((i-j==1)||(i-j==-1)){
      if(str.charAt(i)==str.charAt(j))return dp[i][j]=3 ;
      else return dp[i][j]=2 ;
    }
    if(i==j)return dp[1][j]=1 ;
    else if(str.charAt(i)==str.charAt(j))return dp[i][j]=countPS(i+1,j)+countPS(i,j-1)+1 ;
    else return dp[i][j]=countPS(i+1,j)+countPS(i,j-1)-countPS(i+1,j-1);
  }
  public static void main(String[] args){
    for(int i=0 ; i<1000 ; i++)for(int j=0 ; j<1000 ; j++)dp[i][j]=-1 ;
    n=str.length();
    System.out.println("Total palindromic subsequence"+"are : "+countPS(0,n-1));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute n : int;
  static   attribute dp : Sequence(Sequence(int)) := Integer.subrange(1,1000)->collect(Integer.subrange(1,1000)->collect(0));
  static   attribute str : String := "abcb";
  static   operation countPS( i : int, j : int) : int
  pre: true
  post: true
  activity: (     if (i >= n or j < 0) then     return 0 else skip ; 
     if (dp[i+1][j+1] /= -1) then     return dp[i+1][j+1] else skip ; 
     if ((i - j = 1) or (i - j = -1)) then (     if (str->at(i+1) = str->at(j+1)) then     return dp[i+1][j+1] else     return dp[i+1][j+1] ) else skip ; 
     if (i = j) then     return dp[1+1][j+1] else     if (str->at(i+1) = str->at(j+1)) then     return dp[i+1][j+1] else     return dp[i+1][j+1] ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 1000 do (         var j : int ; j := 0 ; while j < 1000 do (     dp[i+1][j+1] := -1 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     n := str->size() ; 
     OclFile["System.out"].println("Total palindromic subsequence" + "are : " + countPS(0, n - 1)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static Scanner scan=new Scanner(System.in);
  public static void main(String[] args){
    int n=scan.nextInt();
    String str="" ;
    for(int i=0 ; i<n ; i++){
      str+=scan.nextInt();
      if(i!=n-1)str+=" " ;
    }
    String str2="" ;
    List<String>list=new ArrayList<String>();
    for(int i=1 ; i<n+1 ; i++){
      str2+=i ;
    }
    list=permutation(list,str2,"");
    int a=-1 ;
    for(int i=0 ; i<list.size(); i++){
      if(list.get(i).equals(str)){
        a=i ;
        break ;
      }
    }
    if(a!=0){
      System.out.println(list.get(a-1));
    }
    System.out.println(list.get(a));
    if(a!=list.size()-1)System.out.println(list.get(a+1));
  }
  public static List<String>permutation(List<String>list,String q,String ans){
    if(q.length()<=1){
      list.add(ans+q);
    }
    else {
      for(int i=0 ; i<q.length(); i++){
        permutation(list,q.substring(0,i)+q.substring(i+1),ans+q.charAt(i)+" ");
      }
    }
    return list ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var str : String ; str := "" ;
        var i : int ; i := 0 ; while i < n do ( (     str := str+(scan.getCurrent()->toInteger()) ; 
     if (i /= n - 1) then     str := str+(" ") ; else skip )  ;     i := i + 1 ) ; 
    var str2 : String ; str2 := "" ;
    var list : Sequence(String) ; list := Sequence{} ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     str2 := str2+(i) )  ;     i := i + 1 ) ; 
    list := permutation(list, str2, "") ; 
    var a : int ; a := -1 ;
        var i : int ; i := 0 ; while i < list->size() do ( (     if (list->at(i+1) = str) then (     a := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (a /= 0) then (     OclFile["System.out"].println(list->at(a - 1+1)) ) else skip ; 
    OclFile["System.out"].println(list->at(a+1)) ; 
    if (a /= list->size() - 1) then     OclFile["System.out"].println(list->at(a + 1+1)) ; else skip ; 
 );
  static   operation permutation( list : Sequence(String), q : String, ans : String) : Sequence(String)
  pre: true
  post: true
  activity: (     if (q->size() <= 1) then (     list := list->including(ans + q) ) else (         var i : int ; i := 0 ; while i < q->size() do ( (     execute permutation(list, q.subrange(0+1,i) + q.subrange(i + 1+1,i + 1), ans + q->at(i+1) + " ") )  ;     i := i + 1 ) ) ;  
     return list );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static TreeSet<Integer>all=new TreeSet<>();
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextLine().charAt(0)-'0' ;
    int[] base=new int[n];
    for(int i=0 ; i<n ; i++){
      base[i]=i+1 ;
    }
    make(0,0,base,n);
    int x=0 ;
    char[] input=sc.nextLine().toCharArray();
    for(int i=0 ; i<input.length ; i+=2){
      x*=10 ;
      x+=input[i]-'0' ;
    }
    Integer before=all.lower(x);
    if(before!=null){
      System.out.println(toString(before,n));
    }
    System.out.println(input);
    Integer next=all.higher(x);
    if(next!=null){
      System.out.println(toString(next,n));
    }
  }
  static void make(int value,int mask,int[] base,int size){
    if(mask==(1<<size)-1){
      all.add(value);
      return ;
    }
    value*=10 ;
    for(int i=0 ; i<size ; i++){
      if((mask &(1<<i))!=0){
        continue ;
      }
      make(value+base[i],mask |(1<<i),base,size);
    }
  }
  static char[] toString(int x,int size){
    char[] ans=new char[size*2-1];
    Arrays.fill(ans,' ');
    int idx=ans.length-1 ;
    for(int i=0 ; i<size ; i++){
      ans[idx]=(char)(x % 10+'0');
      x/=10 ;
      idx-=2 ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute all : Set(int) := Set{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.nextLine()->at(0+1) - ('0')->char2byte() ;
    var base : Sequence(int) ; base := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     base[i+1] := i + 1 )  ;     i := i + 1 ) ; 
    execute make(0, 0, base, n) ; 
    var x : int ; x := 0 ;
    var input : Sequence(String) ; input := sc.nextLine()->characters() ;
        var i : int ; i := 0 ; while i < input->size() do ( (     x := x*(10) ; 
     x := x+(input[i+1] - ('0')->char2byte()) )  ;     i := i+(2) ) ; 
    var before : int ; before := all.lower(x) ;
    if (before /= null) then (     OclFile["System.out"].println(toString(before, n)) ) else skip ; 
    OclFile["System.out"].println(input) ; 
    var next : int ; next := all.higher(x) ;
    if (next /= null) then (     OclFile["System.out"].println(toString(next, n)) ) else skip ; 
 );
  static   operation make( value : int, mask : int, base : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (     if (mask = ((1*(2->pow(size)))->oclAsType(long)) - 1) then (     all := all->including(value) ; 
     return ) else skip ; 
     value := value*(10) ; 
         var i : int ; i := 0 ; while i < size do ( (     if ((mask & ((1*(2->pow(i)))->oclAsType(long))) /= 0) then (     continue ) else skip ; 
     execute make(value + base[i+1], mask or ((1*(2->pow(i)))->oclAsType(long)), base, size) )  ;     i := i + 1 ) );
  static   operation toString( x : int, size : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var ans : Sequence(String) ; ans := Integer.subrange(1,size * 2 - 1)->collect(0) ;
     ans := ans->collect(' ') ; 
    var idx : int ; idx := ans->size() - 1 ;
        var i : int ; i := 0 ; while i < size do ( (     ans[idx+1] := (x mod 10 + '0')->oclAsType(String) ; 
     x := x/(10) ; 
     idx := idx-(2) )  ;     i := i + 1 ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String numberArray1="" ;
    String numberArray2="" ;
    for(int i=1 ; i<=n ; i++){
      numberArray1+=String.valueOf(i);
      numberArray2+=String.valueOf(sc.nextInt());
    }
    List<String>numberList=new ArrayList<String>();
    permutation(numberArray1,"",numberList);
    for(int i=0 ; i<numberList.size(); i++){
      if(numberList.get(i).equals(numberArray2)){
        if(i!=0)display(numberList.get(i-1));
        display(numberArray2);
        if(i!=numberList.size()-1)display(numberList.get(i+1));
        break ;
      }
    }
  }
  public static List<String>permutation(String s,String ans,List<String>list){
    if(s.length()<=1){
      list.add(ans+s);
    }
    else {
      for(int i=0 ; i<s.length(); i++){
        permutation(s.substring(0,i)+s.substring(i+1),ans+s.charAt(i),list);
      }
    }
    return list ;
  }
  public static void display(String s){
    for(int i=0 ; i<s.length(); i++){
      if(i!=0)System.out.print(" ");
      System.out.print(s.charAt(i));
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var numberArray1 : String ; numberArray1 := "" ;
    var numberArray2 : String ; numberArray2 := "" ;
        var i : int ; i := 1 ; while i <= n do ( (     numberArray1 := numberArray1+(((i) + "")) ; 
     numberArray2 := numberArray2+(((sc.getCurrent()->toInteger()) + "")) )  ;     i := i + 1 ) ; 
    var numberList : Sequence(String) ; numberList := Sequence{} ;
    execute permutation(numberArray1, "", numberList) ; 
        var i : int ; i := 0 ; while i < numberList->size() do ( (     if (numberList->at(i+1) = numberArray2) then (     if (i /= 0) then     execute display(numberList->at((i)->char2byte() - 1+1)) ; else skip ; 
     execute display(numberArray2) ; 
     if (i /= numberList->size() - 1) then     execute display(numberList->at(i + 1+1)) ; else skip ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation permutation( s : String, ans : String, list : Sequence(String)) : Sequence(String)
  pre: true
  post: true
  activity: (     if (s->size() <= 1) then (     list->excludes(ans + s) ) else (         var i : int ; i := 0 ; while i < s->size() do ( (     execute permutation(s.subrange(0+1,i) + s.subrange(i + 1+1,i + 1), ans + s->at(i+1), list) )  ;     i := i + 1 ) ) ;  
     return list );
  static   operation display( s : String) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() do ( (     if (i /= 0) then     OclFile["System.out"].print(" ") ; else skip ; 
     OclFile["System.out"].print(s->at(i+1)) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      String target="" ;
      for(int i=0 ; i<n ; i++){
        target+=sc.nextInt();
        if(i!=n-1)target+=" " ;
      }
      String a="" ;
      for(int i=1 ; i<n+1 ; i++)a+=i ;
      List<String>list=new ArrayList<String>();
      list=permutation(list,a,"");
      int index=-1 ;
      for(int i=0 ; i<list.size(); i++){
        if(list.get(i).equals(target)){
          index=i ;
          break ;
        }
      }
      if(index!=0)System.out.println(list.get(index-1));
      System.out.println(list.get(index));
      if(index!=list.size()-1)System.out.println(list.get(index+1));
    }
  }
  static List<String>permutation(List<String>list,String input,String ans){
    if(input.length()<=1){
      list.add(ans+input);
    }
    else {
      for(int i=0 ; i<input.length(); i++){
        permutation(list,input.substring(0,i)+input.substring(i+1),ans+input.charAt(i)+" ");
      }
    }
    return list ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var target : String ; target := "" ;
        var i : int ; i := 0 ; while i < n do ( (     target := target+(sc.getCurrent()->toInteger()) ; 
     if (i /= n - 1) then     target := target+(" ") ; else skip )  ;     i := i + 1 ) ; 
    var a : String ; a := "" ;
        var i : int ; i := 1 ; while i < n + 1 do (     a := a+(i) ;  ;     i := i + 1 ) ; 
    var list : Sequence(String) ; list := Sequence{} ;
    list := permutation(list, a, "") ; 
    var index : int ; index := -1 ;
        var i : int ; i := 0 ; while i < list->size() do ( (     if (list->at(i+1) = target) then (     index := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (index /= 0) then     OclFile["System.out"].println(list->at(index - 1+1)) ; else skip ; 
    OclFile["System.out"].println(list->at(index+1)) ; 
    if (index /= list->size() - 1) then     OclFile["System.out"].println(list->at(index + 1+1)) ; else skip ; 
 ))  );
  static   operation permutation( list : Sequence(String), input : String, ans : String) : Sequence(String)
  pre: true
  post: true
  activity: (     if (input->size() <= 1) then (     list := list->including(ans + input) ) else (         var i : int ; i := 0 ; while i < input->size() do ( (     execute permutation(list, input.subrange(0+1,i) + input.subrange(i + 1+1,i + 1), ans + input->at(i+1) + " ") )  ;     i := i + 1 ) ) ;  
     return list );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static Scanner scan=new Scanner(System.in);
  public static void main(String[] args){
    int n=scan.nextInt();
    String str="" ;
    for(int i=0 ; i<n ; i++){
      str+=scan.nextInt();
      if(i!=n-1)str+=" " ;
    }
    String str2="" ;
    List<String>list=new ArrayList<String>();
    for(int i=1 ; i<n+1 ; i++){
      str2+=i ;
    }
    list=permutation(list,str2,"");
    int a=-1 ;
    for(int i=0 ; i<list.size(); i++){
      if(list.get(i).equals(str)){
        a=i ;
        break ;
      }
    }
    if(a!=0){
      System.out.println(list.get(a-1));
    }
    System.out.println(list.get(a));
    if(a!=list.size()-1)System.out.println(list.get(a+1));
  }
  public static List<String>permutation(List<String>list,String q,String ans){
    if(q.length()<=1){
      list.add(ans+q);
    }
    else {
      for(int i=0 ; i<q.length(); i++){
        permutation(list,q.substring(0,i)+q.substring(i+1),ans+q.charAt(i)+" ");
      }
    }
    return list ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var str : String ; str := "" ;
        var i : int ; i := 0 ; while i < n do ( (     str := str+(scan.getCurrent()->toInteger()) ; 
     if (i /= n - 1) then     str := str+(" ") ; else skip )  ;     i := i + 1 ) ; 
    var str2 : String ; str2 := "" ;
    var list : Sequence(String) ; list := Sequence{} ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     str2 := str2+(i) )  ;     i := i + 1 ) ; 
    list := permutation(list, str2, "") ; 
    var a : int ; a := -1 ;
        var i : int ; i := 0 ; while i < list->size() do ( (     if (list->at(i+1) = str) then (     a := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (a /= 0) then (     OclFile["System.out"].println(list->at(a - 1+1)) ) else skip ; 
    OclFile["System.out"].println(list->at(a+1)) ; 
    if (a /= list->size() - 1) then     OclFile["System.out"].println(list->at(a + 1+1)) ; else skip ; 
 );
  static   operation permutation( list : Sequence(String), q : String, ans : String) : Sequence(String)
  pre: true
  post: true
  activity: (     if (q->size() <= 1) then (     list := list->including(ans + q) ) else (         var i : int ; i := 0 ; while i < q->size() do ( (     execute permutation(list, q.subrange(0+1,i) + q.subrange(i + 1+1,i + 1), ans + q->at(i+1) + " ") )  ;     i := i + 1 ) ) ;  
     return list );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math ;
public class heaters {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int r=sc.nextInt();
    ArrayList<Integer>arr=new ArrayList<Integer>();
    for(int i=0 ; i<n ; ++i){
      int a=sc.nextInt();
      arr.add(a);
    }
    int ans=0 ;
    int last=-1 ;
    while(last<n-1){
      int pos=-1 ;
      for(int i=n-1 ; i>Math.max(-1,last-r+1); --i){
        if(arr.get(i)==1 && i-r<=last){
          pos=i ;
          break ;
        }
      }
      if(pos==-1){
        System.out.println("-1");
        return ;
      }
++ans ;
      last=pos+r-1 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class heaters {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     arr := arr->including(a) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var last : int ; last := -1 ;
    while (last < n - 1) do (     var pos : int ; pos := -1 ;
         var i : int ; i := n - 1 ; while i > Set{-1, last - r + 1}->max() do ( (     if (arr->at(i+1) = 1 & i - r <= last) then (     pos := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    if (pos = -1) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
    ans := ans + 1 ; 
    last := pos + r - 1 ; 
 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class main {
  static long mod=(long)1e9+7 ;
  static int max=(int)1e5+5 ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),r=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=in.nextInt();
    int c=0 ;
    for(int i=0 ; i<n ; i++){
      int j=i,lo=-1 ;
      for(; j<n ; j++){
        if(a[j]==1){
          if(j-r+1<=i)lo=j ;
          else break ;
        }
      }
      if(lo==-1){
        j=i-1 ;
        for(; j>=0 ; j--){
          if(a[j]==1){
            if(j+r-1>=i)lo=j ;
            break ;
          }
        }
        if(lo==-1){
          c=-1 ;
          break ;
        }
      }
      c++;
      i=lo+r-1 ;
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   attribute mod : long := 1e9->oclAsType(long) + 7;
  static   attribute max : int := 1e5->oclAsType(int) + 5;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var r : int ; r := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var j : int ; j := i ;
    var lo : int ; lo := -1 ;
       while j < n do ( (     if (a[j+1] = 1) then (     if (j - r + 1 <= i) then     lo := j ; else     break ) else skip )  ;     j := j + 1 ) ; 
    if (lo = -1) then (     j := i - 1 ; 
       while j >= 0 do ( (     if (a[j+1] = 1) then (     if (j + r - 1 >= i) then     lo := j ; else skip ; 
     break ) else skip )  ;     j := j - 1 ) ; 
     if (lo = -1) then (     c := -1 ; 
     break ) else skip ) else skip ; 
    c := c + 1 ; 
    i := lo + r - 1 ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static int N,r ;
  public static int[] heaters ;
  public static boolean[] on ;
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(f.readLine());
    N=Integer.parseInt(st.nextToken());
    r=Integer.parseInt(st.nextToken());
    st=new StringTokenizer(f.readLine());
    heaters=new int[N];
    on=new boolean[N];
    for(int i=0 ; i<N ; i++){
      heaters[i]=Integer.parseInt(st.nextToken());
    }
    int res=0 ;
    int last=-1<<29 ;
    for(int i=0 ; i<N ; i++){
      boolean ok=false ;
      if((i-last)<r)continue ;
      for(int k=i ; k<Math.min(N,i+r); k++){
        if(on[k])ok=true ;
      }
      if(ok)continue ;
      ok=false ;
      for(int k=Math.min(N-1,i+r-1); k>=i ; k--){
        if(heaters[k]==1){
          on[k]=true ;
          ok=true ;
          last=k ;
          res++;
          break ;
        }
      }
      if(ok)continue ;
      for(int k=i-1 ; k>=Math.max(0,i-r+1); k--){
        if(heaters[k]==1){
          on[k]=true ;
          ok=true ;
          last=Math.max(last,k);
          res++;
          break ;
        }
      }
      if(! ok){
        System.out.println(-1);
        return ;
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute heaters : Sequence(int);
  static   attribute on : Sequence(boolean);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
    N := (st.next())->toInteger() ; 
    r := (st.next())->toInteger() ; 
    st := OclIterator.newOclIterator_String(f.readLine()) ; 
    heaters := Integer.subrange(1,N)->collect(0) ; 
    on := Integer.subrange(1,N)->collect(false) ; 
        var i : int ; i := 0 ; while i < N do ( (     heaters[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    var last : int ; last := (-1*(2->pow(29)))->oclAsType(long) ;
        var i : int ; i := 0 ; while i < N do ( (     var ok : boolean ; ok := false ;
     if ((i - last) < r) then     continue else skip ; 
        var k : int ; k := i ; while k < Set{N, i + r}->min() do ( (     if (on[k+1]) then     ok := true ; else skip )  ;     k := k + 1 ) ; 
    if (ok) then     continue else skip ; 
    ok := false ; 
        var k : int ; k := Set{N - 1, i + r - 1}->min() ; while k >= i do ( (     if (heaters[k+1] = 1) then (     on[k+1] := true ; 
     ok := true ; 
    last := k ; 
    res := res + 1 ; 
    break 
 ) else skip )  ;     k := k - 1 ) ; 
    if (ok) then     continue else skip ; 
        var k : int ; k := i - 1 ; while k >= Set{0, i - r + 1}->max() do ( (     if (heaters[k+1] = 1) then (     on[k+1] := true ; 
     ok := true ; 
    last := Set{last, k}->max() ; 
    res := res + 1 ; 
    break 
 ) else skip )  ;     k := k - 1 ) ; 
    if (not(ok)) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A {
  static Scanner in ;
  public static void main(String[] args){
    in=new Scanner(System.in);
    int T=in.nextInt();
    for(int C=1 ; C<=T ; C++){
      System.out.println("Case #"+C+":"+solve());
    }
  }
  public static String solve(){
    String out="" ;
    int n=in.nextInt();
    int[] count=new int[n];
    int remaining=0 ;
    for(int i=0 ; i<n ; i++){
      count[i]=in.nextInt();
      remaining+=count[i];
    }
    while(remaining>0){
      out+=" " ;
      int maxIdx=-1 ;
      for(int i=0 ; i<n ; i++){
        if(count[i]>0 &&(maxIdx==-1 || count[i]>count[maxIdx])){
          maxIdx=i ;
        }
      }
      out+=(char)(maxIdx+'A');
      count[maxIdx]--;
      remaining--;
      if(remaining<=0)break ;
      maxIdx=-1 ;
      int gT0=0 ;
      boolean tie=false ;
      for(int i=0 ; i<n ; i++){
        if(count[i]>0){
          gT0++;
        }
        if(count[i]>0 &&(maxIdx==-1 || count[i]>count[maxIdx])){
          maxIdx=i ;
        }
        else if(count[i]>0 && gT0==2 && count[i]==count[maxIdx]){
          tie=true ;
        }
      }
      boolean skip=tie && gT0==2 ;
      if(! skip){
        out+=(char)(maxIdx+'A');
        count[maxIdx]--;
        remaining--;
      }
    }
    return out ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute in : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var T : int ; T := in.getCurrent()->toInteger() ;
         var C : int ; C := 1 ; while C <= T do ( (     OclFile["System.out"].println("Case #" + C + ":" + solve()) )  ;     C := C + 1 ) );
  static   operation solve() : String
  pre: true
  post: true
  activity: (     var out : String ; out := "" ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var count : Sequence(int) ; count := Integer.subrange(1,n)->collect(0) ;
    var remaining : int ; remaining := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     count[i+1] := in.getCurrent()->toInteger() ; 
     remaining := remaining+(count[i+1]) )  ;     i := i + 1 ) ; 
    while (remaining > 0) do (     out := out+(" ") ; 
     var maxIdx : int ; maxIdx := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (count[i+1] > 0 & (maxIdx = -1 or count[i+1] > count[maxIdx+1])) then (     maxIdx := i ) else skip )  ;     i := i + 1 ) ; 
    out := out+((maxIdx + 'A')->oclAsType(String)) ; 
    count[maxIdx+1] := count[maxIdx+1] - 1 ; 
    remaining := remaining - 1 ; 
    if (remaining <= 0) then     break else skip ; 
    maxIdx := -1 ; 
    var gT0 : int ; gT0 := 0 ;
    var tie : boolean ; tie := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (count[i+1] > 0) then (     gT0 := gT0 + 1 ) else skip ; 
     if (count[i+1] > 0 & (maxIdx = -1 or count[i+1] > count[maxIdx+1])) then (     maxIdx := i ) else     if (count[i+1] > 0 & gT0 = 2 & count[i+1] = count[maxIdx+1]) then (     tie := true ) else skip ; )  ;     i := i + 1 ) ; 
    var skip : boolean ; skip := tie & gT0 = 2 ;
    if (not(skip)) then (     out := out+((maxIdx + 'A')->oclAsType(String)) ; 
     count[maxIdx+1] := count[maxIdx+1] - 1 ; 
     remaining := remaining - 1 ) else skip ; 
 ) ; 
    return out 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    Set<Integer>set=new TreeSet<>();
    outerloop : while(n>0){
      int sw=scanner.nextInt();
      for(int i=0 ; i<sw ; i++){
        set.add(scanner.nextInt());
      }
      if(set.size()==m)break outerloop ;
      n--;
    }
    if(set.size()==m)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
    while (n > 0) do (     var sw : int ; sw := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < sw do ( (     set := set->including(scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
     if (set->size() = m) then     break else skip ; 
     n := n - 1 ) ; 
    if (set->size() = m) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main();
  }
  public Main()throws IOException {
    Scanner sc=new Scanner(new File("A-large.in"));
    PrintWriter out=new PrintWriter(new File("A-large.out"));
    int amountOfTasks=sc.nextInt();
    for(int task=1 ; task<=amountOfTasks ; task++){
      int amount=sc.nextInt();
      int[] counts=new int[amount];
      int sum=0 ;
      for(int i=0 ; i<amount ; i++){
        counts[i]=sc.nextInt();
        sum+=counts[i];
      }
      String sol="" ;
      if(sum % 2==1){
        int max1=0 ;
        for(int i=0 ; i<amount ; i++){
          if(counts[i]>counts[max1]){
            max1=i ;
          }
        }
        counts[max1]--;
        char first=(char)(max1+'A');
        sol+=first ;
        sum--;
      }
      while(sum>0){
        int max1=0 ;
        for(int i=0 ; i<amount ; i++){
          if(counts[i]>counts[max1]){
            max1=i ;
          }
        }
        counts[max1]--;
        int max2=0 ;
        for(int i=0 ; i<amount ; i++){
          if(counts[i]>counts[max2]){
            max2=i ;
          }
        }
        counts[max2]--;
        char first=(char)(max1+'A');
        char second=(char)(max2+'A');
        if(sol.length()>0){
          sol+=" " ;
        }
        sol+=first ;
        sol+=second ;
        sum-=2 ;
      }
      String solution="Case #"+task+": "+sol ;
      System.out.println(solution);
      out.println(solution);
    }
    out.close();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile("A-large.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("A-large.out")) ;
    var amountOfTasks : int ; amountOfTasks := sc.getCurrent()->toInteger() ;
        var task : int ; task := 1 ; while task <= amountOfTasks do ( (     var amount : int ; amount := sc.getCurrent()->toInteger() ;
     var counts : Sequence(int) ; counts := Integer.subrange(1,amount)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < amount do ( (     counts[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(counts[i+1]) )  ;     i := i + 1 ) ; 
    var sol : String ; sol := "" ;
    if (sum mod 2 = 1) then (     var max1 : int ; max1 := 0 ;
         var i : int ; i := 0 ; while i < amount do ( (     if (counts[i+1] > counts[max1+1]) then (     max1 := i ) else skip )  ;     i := i + 1 ) ; 
    counts[max1+1] := counts[max1+1] - 1 ; 
    var first : String ; first := (max1 + 'A')->oclAsType(String) ;
    sol := sol+(first) ; 
    sum := sum - 1 ; 
 ) else skip ; 
    while (sum > 0) do (     var max1 : int ; max1 := 0 ;
         var i : int ; i := 0 ; while i < amount do ( (     if (counts[i+1] > counts[max1+1]) then (     max1 := i ) else skip )  ;     i := i + 1 ) ; 
    counts[max1+1] := counts[max1+1] - 1 ; 
    var max2 : int ; max2 := 0 ;
        var i : int ; i := 0 ; while i < amount do ( (     if (counts[i+1] > counts[max2+1]) then (     max2 := i ) else skip )  ;     i := i + 1 ) ; 
    counts[max2+1] := counts[max2+1] - 1 ; 
    var first : String ; first := (max1 + 'A')->oclAsType(String) ;
    var second : String ; second := (max2 + 'A')->oclAsType(String) ;
    if (sol->size() > 0) then (     sol := sol+(" ") ) else skip ; 
    sol := sol+(first) ; 
    sol := sol+(second) ; 
    sum := sum-(2) ; 
 ) ; 
    var solution : String ; solution := "Case #" + task + ": " + sol ;
    OclFile["System.out"].println(solution) ; 
    skip ; 
 )  ;     task := task + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package com.mavtushenko.Gcj1C ;
import java.io.*;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class TaskA {
  public static void main(String[] args){
    String fileName="A-large.in" ;
    try(BufferedReader br=new BufferedReader(new FileReader(fileName))){
      try(BufferedWriter bw=new BufferedWriter(new FileWriter(fileName+".out"))){
        int tests=Integer.valueOf(br.readLine());
        for(int test=1 ; test<=tests ; ++test){
          int n=new Scanner(br.readLine()).nextInt();
          Scanner scanner=new Scanner(br.readLine());
          int s[]=new int[n];
          for(int i=0 ; i<n ; ++i)s[i]=scanner.nextInt();
          bw.write("Case #"+test+": ");
          while(true){
            int max=0 ;
            for(int ss : s)max=Math.max(max,ss);
            if(max==0)break ;
            ArrayList<Integer>pos=new ArrayList<Integer>();
            for(int i=0 ; i<n ; ++i){
              if(s[i]==max)pos.add(i);
            }
            int ps=pos.size();
            if(pos.size()% 2==1){
              ps--;
              int cur=pos.get(pos.size()-1);
              s[cur]--;
              bw.write(""+(char)('A'+cur)+" ");
            }
            for(int i=0 ; i<ps ; i+=2){
              int c1=pos.get(i);
              int c2=pos.get(i+1);
              s[c1]--;
              s[c2]--;
              bw.write(""+(char)('A'+c1)+(char)('A'+c2)+" ");
            }
          }
          bw.write("\n");
        }
        bw.close();
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TaskA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fileName : String ; fileName := "A-large.in" ;
     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(fileName))) ;
 (     try (    var bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(fileName + ".out")) ;
 (     var tests : int ; tests := (br.readLine())->toInteger() ;
         var test : int ; test := 1 ; while test <= tests do ( (     var n : int ; n := OclFile.newOclFile_Read(br.readLine()).nextInt() ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(br.readLine()) ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     s[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    skip ; 
    while (true) do (     var max : int ; max := 0 ;
     for (ss : s) do (     max := Set{max, ss}->max() ;  ) ; 
    if (max = 0) then     break else skip ; 
    var pos : Sequence(int) ; pos := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] = max) then     pos := pos->including(i) ; else skip )  ;     i := i + 1 ) ; 
    var ps : int ; ps := pos->size() ;
    if (pos->size() mod 2 = 1) then (     ps := ps - 1 ; 
     var cur : int ; cur := pos->at(pos->size() - 1+1) ;
     s[cur+1] := s[cur+1] - 1 ; 
     skip ) else skip ; 
        var i : int ; i := 0 ; while i < ps do ( (     var c1 : int ; c1 := pos->at(i+1) ;
     var c2 : int ; c2 := pos->at(i + 1+1) ;
    s[c1+1] := s[c1+1] - 1 ; 
    s[c2+1] := s[c2+1] - 1 ; 
    skip ; 
 )  ;     i := i+(2) ) ; 
 ) ; 
    skip ; 
 )  ;     test := test + 1 ) ; 
     skip ))  ))   catch (e : IOException) do (     e.printStackTrace() )
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package Round1 ;
import java.io.*;
public class A {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new FileReader("/Users/chao/Downloads/A-large.in"));
    FileWriter out=new FileWriter("/Users/chao/Desktop/A-large.txt");
    String s=in.readLine();
    int m=Integer.parseInt(s);
    int[] a=new int[26];
    for(int cases=1 ; cases<=m ; cases++){
      int n=Integer.parseInt(in.readLine());
      int cnt=n ;
      String[] ss=in.readLine().split(" ");
      for(int i=0 ; i<ss.length ; i++){
        a[i]=Integer.parseInt(ss[i]);
      }
      out.write("Case #"+cases+":");
      while(cnt>2){
        int k=findMaxIndex(a,n);
        out.write(" "+(char)('A'+k));
        if(--a[k]==0)cnt--;
      }
      while(cnt>0){
        int k=findMaxIndex(a,n);
        out.write(" "+(char)('A'+k));
        if(--a[k]==0)cnt--;
        k=findMaxIndex(a,n);
        out.write((char)('A'+k));
        if(--a[k]==0)cnt--;
      }
      out.write("\n");
    }
    in.close();
    out.flush();
    out.close();
  }
  private static int findMaxIndex(int[] a,int n){
    int num=-1 ;
    int k=-1 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]>num){
        num=a[i];
        k=i ;
      }
    }
    return k ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("/Users/chao/Downloads/A-large.in"))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("/Users/chao/Desktop/A-large.txt")) ;
    var s : String ; s := in.readLine() ;
    var m : int ; m := (s)->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,26)->collect(0) ;
        var cases : int ; cases := 1 ; while cases <= m do ( (     var n : int ; n := (in.readLine())->toInteger() ;
     var cnt : int ; cnt := n ;
    var ss : Sequence(String) ; ss := in.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < ss->size() do ( (     a[i+1] := (ss[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    while (cnt > 2) do (     var k : int ; k := findMaxIndex(a, n) ;
     skip ; 
     if ((a[k+1] - 1) = 0) then     cnt := cnt - 1 ; else skip ) ; 
    while (cnt > 0) do (     var k : int ; k := findMaxIndex(a, n) ;
     skip ; 
    if ((a[k+1] - 1) = 0) then     cnt := cnt - 1 ; else skip ; 
    k := findMaxIndex(a, n) ; 
    skip ; 
    if ((a[k+1] - 1) = 0) then     cnt := cnt - 1 ; else skip ; 
 ) ; 
    skip ; 
 )  ;     cases := cases + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation findMaxIndex( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := -1 ;
     var k : int ; k := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] > num) then (     num := a[i+1] ; 
     k := i ) else skip )  ;     i := i + 1 ) ; 
     return k );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A {
  static int N ;
  static int ans ;
  public static void main(String...orange)throws Exception {
    Scanner input=new Scanner(System.in);
    int numCases=input.nextInt();
    for(int n=0 ; n<numCases ; n++){
      N=input.nextInt();
      int[] nums=new int[N];
      int sum=0 ;
      for(int i=0 ; i<N ; i++){
        nums[i]=input.nextInt();
        sum+=nums[i];
      }
      List<String>steps=new ArrayList<String>();
      while(sum>0){
        String s="" ;
        s+=add(nums,false);
        s+=add(nums,true);
        steps.add(s);
        sum-=s.length();
      }
      System.out.printf("Case #%d:",n+1);
      for(String s : steps)System.out.print(" "+s);
      System.out.println();
    }
  }
  static String add(int[] nums,boolean check){
    int most=0 ;
    for(int i=0 ; i<nums.length ; i++)if(nums[i]>nums[most])most=i ;
    nums[most]--;
    int sum=0 ;
    for(int num : nums)sum+=num ;
    if(check)for(int num : nums)if(num>sum/2){
      nums[most]++;
      return "" ;
    }
    return(char)('A'+most)+"" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute N : int;
  static   attribute ans : int;
  static   operation main( orange : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numCases : int ; numCases := input.getCurrent()->toInteger() ;
         var n : int ; n := 0 ; while n < numCases do ( (     N := input.getCurrent()->toInteger() ; 
     var nums : Sequence(int) ; nums := Integer.subrange(1,N)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     nums[i+1] := input.getCurrent()->toInteger() ; 
     sum := sum+(nums[i+1]) )  ;     i := i + 1 ) ; 
    var steps : Sequence(String) ; steps := Sequence{} ;
    while (sum > 0) do (     var s : String ; s := "" ;
     s := s+(add(nums, false)) ; 
    s := s+(add(nums, true)) ; 
    steps := steps->including(s) ; 
    sum := sum-(s->size()) ; 
 ) ; 
    OclFile["System.out"].printf("Case #%d:", n + 1) ; 
    for (s : steps) do (     OclFile["System.out"].print(" " + s) ;  ) ; 
    OclFile["System.out"].println() ; 
 )  ;     n := n + 1 ) );
  static   operation add( nums : Sequence(int), check : boolean) : String
  pre: true
  post: true
  activity: (     var most : int ; most := 0 ;
         var i : int ; i := 0 ; while i < nums->size() do (     if (nums[i+1] > nums[most+1]) then     most := i ; else skip ;  ;     i := i + 1 ) ; 
    nums[most+1] := nums[most+1] - 1 ; 
    var sum : int ; sum := 0 ;
    for (num : nums) do (     sum := sum+(num) ;  ) ; 
    if (check) then     for (num : nums) do (     if (num > sum / 2) then (     nums[most+1] := nums[most+1] + 1 ; 
     return "" ) else skip ;  ) ; else skip ; 
    return ('A' + most)->oclAsType(String) + "" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String str=sc.next();
      int a=str.indexOf(":");
      int b=Integer.parseInt(str.substring(0,a));
      int c=Integer.parseInt(str.substring(a+1));
      int h2=c % 10 ;
      int h1=c/10 ;
      int d=(h2*10)+h1 ;
      if(d==b){
        System.out.println(0);
        return ;
      }
      else {
        int count=0 ;
        for(int i=1 ; i<=1440 ; i++){
          c=c+1 ;
          count++;
          if(c==60){
            c=0 ;
            b=b+1 ;
            if(b==24){
              b=0 ;
            }
          }
          if((c % 10)*10+c/10==b){
            System.out.println(count);
            return ;
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var str : String ; str := sc.getCurrent() ;
     var a : int ; a := str->indexOf(":")-1 ;
    var b : int ; b := (str.subrange(0+1,a))->toInteger() ;
    var c : int ; c := (str.subrange(a + 1+1,a + 1))->toInteger() ;
    var h2 : int ; h2 := c mod 10 ;
    var h1 : int ; h1 := c / 10 ;
    var d : int ; d := (h2 * 10) + h1 ;
    if (d = b) then (     OclFile["System.out"].println(0) ; 
     return ) else (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i <= 1440 do ( (     c := c + 1 ; 
     count := count + 1 ; 
     if (c = 60) then (     c := 0 ; 
     b := b + 1 ; 
     if (b = 24) then (     b := 0 ) else skip ) else skip ; 
     if ((c mod 10) * 10 + c / 10 = b) then (     OclFile["System.out"].println(count) ; 
     return ) else skip )  ;     i := i + 1 ) ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    while(sc.hasNext()){
      String s=sc.next();
      char a[]=s.toCharArray();
      int b[]=new int[4];
      b[0]=Character.getNumericValue(a[0]);
      b[1]=Character.getNumericValue(a[1]);
      b[2]=Character.getNumericValue(a[3]);
      b[3]=Character.getNumericValue(a[4]);
      int hour=b[0]*10+b[1];
      int hour1=b[1]*10+b[0];
      int minute=b[2]*10+b[3];
      if(hour==0){
        if(minute==0)System.out.println(0);
        else System.out.println(70-minute);
      }
      if((hour<=4 && hour>=1)||(hour>=10 && hour<=14)||(hour>=20 && hour<=22)){
        if(minute<=hour1)System.out.println(hour1-minute);
        else System.out.println(60-minute+((b[1]+1)*10+b[0]));
      }
      if(hour>5 && hour<=9)System.out.println(601-60*hour-minute);
      if(hour>15 && hour<=19)System.out.println(1202-60*hour-minute);
      if(hour==5 || hour==15){
        if(minute<=hour1)System.out.println(hour1-minute);
        else {
          if(hour==5)System.out.println(601-60*hour-minute);
          if(hour==15)System.out.println(1202-60*hour-minute);
        }
      }
      if(hour==23){
        if(minute<=hour1)System.out.println(hour1-minute);
        else System.out.println(60-minute);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     var s : String ; s := sc.getCurrent() ;
     var a : Sequence(String) ; a := s->characters() ;
    var b : Sequence(int) ; b := Integer.subrange(1,4)->collect(0) ;
    b[0+1] := ("" + a[0+1])->toInteger() ; 
    b[1+1] := ("" + a[1+1])->toInteger() ; 
    b[2+1] := ("" + a[3+1])->toInteger() ; 
    b[3+1] := ("" + a[4+1])->toInteger() ; 
    var hour : int ; hour := b[0+1] * 10 + b[1+1] ;
    var hour1 : int ; hour1 := b[1+1] * 10 + b[0+1] ;
    var minute : int ; minute := b[2+1] * 10 + b[3+1] ;
    if (hour = 0) then (     if (minute = 0) then     OclFile["System.out"].println(0) ; else     OclFile["System.out"].println(70 - minute) ; ) else skip ; 
    if ((hour <= 4 & hour >= 1) or (hour >= 10 & hour <= 14) or (hour >= 20 & hour <= 22)) then (     if (minute <= hour1) then     OclFile["System.out"].println(hour1 - minute) ; else     OclFile["System.out"].println(60 - minute + ((b[1+1] + 1) * 10 + b[0+1])) ; ) else skip ; 
    if (hour > 5 & hour <= 9) then     OclFile["System.out"].println(601 - 60 * hour - minute) ; else skip ; 
    if (hour > 15 & hour <= 19) then     OclFile["System.out"].println(1202 - 60 * hour - minute) ; else skip ; 
    if (hour = 5 or hour = 15) then (     if (minute <= hour1) then     OclFile["System.out"].println(hour1 - minute) ; else (     if (hour = 5) then     OclFile["System.out"].println(601 - 60 * hour - minute) ; else skip ; 
     if (hour = 15) then     OclFile["System.out"].println(1202 - 60 * hour - minute) ; else skip ) ) else skip ; 
    if (hour = 23) then (     if (minute <= hour1) then     OclFile["System.out"].println(hour1 - minute) ; else     OclFile["System.out"].println(60 - minute) ; ) else skip ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Driver {
  public static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    String s=scanner.next();
    if(isPallindrome(s)){
      System.out.println(0);
      return ;
    }
    String[] time=s.split(":");
    int hh=Integer.parseInt(time[0]);
    int mm=Integer.parseInt(time[1]);
    int count=0 ;
    StringBuilder sb=new StringBuilder();
    String temp=String.format("%02d:%02d\n",hh,mm);
    temp=temp.trim();
    sb.append(temp);
    while(! isPallindrome(sb.toString())){
      sb.setLength(0);
      mm++;
      count++;
      if(mm>=60){
        mm=0 ;
        hh++;
      }
      if(hh>=24)hh=0 ;
      temp=String.format("%02d:%02d\n",hh,mm);
      ;
      temp=temp.trim();
      sb.append(temp);
    }
    System.out.println(count);
  }
  private static boolean isPallindrome(String s){
    for(int i=0,j=s.length()-1 ; i<s.length()/2 ; i++,j--){
      if(s.charAt(i)!=s.charAt(j)){
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Driver {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var s : String ; s := scanner.getCurrent() ;
    if (isPallindrome(s)) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var time : Sequence(String) ; time := s->split(":") ;
    var hh : int ; hh := (time[0+1])->toInteger() ;
    var mm : int ; mm := (time[1+1])->toInteger() ;
    var count : int ; count := 0 ;
    var sb : String ; sb := StringLib.newString() ;
    var temp : String ; temp := StringLib.format("%02d:%02d\n",Sequence{hh,mm}) ;
    temp := temp->trim() ; 
    sb := sb + StringLib.newString(temp) ; 
    while (not(isPallindrome(sb+""))) do (     sb := sb.subrange(1,0) ; 
     mm := mm + 1 ; 
    count := count + 1 ; 
    if (mm >= 60) then (     mm := 0 ; 
     hh := hh + 1 ) else skip ; 
    if (hh >= 24) then     hh := 0 ; else skip ; 
    temp := StringLib.format("%02d:%02d\n",Sequence{hh,mm}) ; 
    temp := temp->trim() ; 
    sb := sb + StringLib.newString(temp) ; 
 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation isPallindrome( s : String) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ;
    var j : int ; j := s->size() - 1 ; while i < s->size() / 2 do ( (     if (s->at(i+1) /= s->at(j+1)) then (     return false ) else skip )  ;     i := i + 1 ;     j := j - 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public static void main(String[] args)throws IOException {
    FastReader fr=new FastReader();
    BufferedWriter output=new BufferedWriter(new OutputStreamWriter(System.out));
    StringBuilder sb=new StringBuilder();
    int tests=fr.nextInt();
    for(int t=1 ; t<=tests ; t++){
      int n=fr.nextInt();
      String s=fr.next();
      int ones=0,zeros=0 ;
      for(int i=0 ; i<n-1 ; i++){
        if(s.charAt(i)=='0' && s.charAt(i+1)=='0')zeros++;
        if(s.charAt(i)=='1' && s.charAt(i+1)=='1')ones++;
      }
      sb.append(Math.max(zeros,ones)).append("\n");
    }
    output.write(sb.toString());
    output.flush();
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    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 {
      if(st.hasMoreTokens()){
        str=st.nextToken("\n");
      }
      else {
        str=br.readLine();
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return str ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fr : FastReader ; fr := FastReader.newFastReader() ;
     var output : OclFile ; output := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var sb : String ; sb := StringLib.newString() ;
    var tests : int ; tests := fr.nextInt() ;
        var t : int ; t := 1 ; while t <= tests do ( (     var n : int ; n := fr.nextInt() ;
     var s : String ; s := fr.next() ;
    var ones : int ; ones := 0 ;
    var zeros : int ; zeros := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (s->at(i+1) = '0' & s->at(i + 1+1) = '0') then     zeros := zeros + 1 ; else skip ; 
     if (s->at(i+1) = '1' & s->at(i + 1+1) = '1') then     ones := ones + 1 ; else skip )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(Set{zeros, ones}->max()) + StringLib.newString("\n") ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.io.PrintStream ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      String s=in.next();
      int hour=Integer.parseInt(s.substring(0,2));
      int minute=Integer.parseInt(s.substring(3));
      int count=0 ;
      while(! isPalindrome(hour,minute)){
        count++;
        if(minute<59)minute++;
        else {
          minute=0 ;
          if(hour<23)hour++;
          else hour=0 ;
        }
      }
      out.println(count);
    }
    boolean isPalindrome(int hour,int minute){
      return(hour/10==minute % 10)&&(hour % 10==minute/10);
    }
  }
  static class InputReader {
    private static BufferedReader in ;
    private static StringTokenizer tok ;
    public InputReader(InputStream in){
      this.in=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      try {
        while(tok==null || ! tok.hasMoreTokens()){
          tok=new StringTokenizer(in.readLine());
        }
      }
      catch(IOException ex){
        System.err.println("An IOException was caught :"+ex.getMessage());
      }
      return tok.nextToken();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.next() ;
     var hour : int ; hour := (s.subrange(0+1,2))->toInteger() ;
    var minute : int ; minute := (s.subrange(3+1,3))->toInteger() ;
    var count : int ; count := 0 ;
    while (not(isPalindrome(hour, minute))) do (     count := count + 1 ; 
     if (minute < 59) then     minute := minute + 1 ; else (     minute := 0 ; 
     if (hour < 23) then     hour := hour + 1 ; else     hour := 0 ; ) ) ; 
    skip ; 
 );
   operation isPalindrome( hour : int, minute : int) : boolean
  pre: true
  post: true
  activity: (     return (hour / 10 = minute mod 10) & (hour mod 10 = minute / 10) );
}
  static class InputReader {
  static   attribute in : OclFile;
  static   attribute tok : OclIterator;
   static operation newInputReader( in : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     self.in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (tok = null or not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String(in.readLine()) ) )   catch (ex : IOException) do (     OclFile["System.err"].println("An IOException was caught :" + ex.getMessage()) )
     return tok.next() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public ListNode reverseList(ListNode head){
    ListNode newHead=null ;
    while(head!=null){
      ListNode next=head.next ;
      head.next=newHead ;
      newHead=head ;
      head=next ;
    }
    return newHead ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation reverseList( head : ListNode) : ListNode
  pre: true
  post: true
  activity: (     var newHead : ListNode ; newHead := null ;
     while (head /= null) do (     var next : ListNode ; next := head.next ;
     head.next := newHead ; 
     newHead := head ; 
     head := next ) ; 
     return newHead );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Solve s=new Solve();
    s.solve();
  }
}
class Solve {
  Scanner in=new Scanner(System.in);
  void solve(){
    int[][] s={
      {
        1,2,3,4 },{
          2,-1,4,-3 },{
            3,-4,-1,2 },{
              4,3,-2,-1 }
            };
            while(in.hasNext()){
              int n=in.nextInt();
              if(n==0)return ;
              for(int k=0 ; k<n ; k++){
                int[] a=new int[4];
                int[] b=new int[4];
                long[] ans=new long[4];
                for(int i=0 ; i<4 ; i++)a[i]=in.nextInt();
                for(int i=0 ; i<4 ; i++)b[i]=in.nextInt();
                for(int i=0 ; i<4 ; i++){
                  for(int j=0 ; j<4 ; j++){
                    int t=s[i][j],d=1 ;
                    if(t<0){
                      t=-t ;
                      d=-1 ;
                    }
--t ;
                    ans[t]+=(long)d*a[i]*b[j];
                  }
                }
                for(int i=0 ; i<4 ; i++){
                  if(i!=0)System.out.print(" ");
                  System.out.print(ans[i]);
                }
                System.out.println();
              }
            }
          }
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Solve ; s := Solve.newSolve() ;
     s.solve() );
}
class Solve {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation solve() : void
  pre: true
  post: true
  activity: (     var s : Sequence(Sequence(int)) ; s := Sequence{Sequence{1,2,3,4},Sequence{2,-1,4,-3},Sequence{3,-4,-1,2},Sequence{4,3,-2,-1}} ;
     while (in.hasNext()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
         var k : int ; k := 0 ; while k < n do ( (     var a : Sequence(int) ; a := Integer.subrange(1,4)->collect(0) ;
     var b : Sequence(int) ; b := Integer.subrange(1,4)->collect(0) ;
    var ans : Sequence(long) ; ans := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 4 do (     b[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < 4 do ( (     var t : int ; t := s[i+1][j+1] ;
    var d : int ; d := 1 ;
     if (t < 0) then (     t := -t ; 
     d := -1 ) else skip ; 
     t := t - 1 ; 
     ans[t+1] := ans[t+1]+(d->oclAsType(long) * a[i+1] * b[j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 4 do ( (     if (i /= 0) then     OclFile["System.out"].print(" ") ; else skip ; 
     OclFile["System.out"].print(ans[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     k := k + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int a[]=new int[m+1];
    for(int i=0 ; i<n ; i++){
      int f=in.nextInt();
      for(int j=0 ; j<f ; j++){
        int z=in.nextInt();
        a[z]++;
      }
    }
    boolean ans=true ;
    for(int i=1 ; i<=m ; i++){
      if(a[i]==0)ans=false ;
    }
    if(ans){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var f : int ; f := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < f do ( (     var z : int ; z := in.getCurrent()->toInteger() ;
     a[z+1] := a[z+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : boolean ; ans := true ;
        var i : int ; i := 1 ; while i <= m do ( (     if (a[i+1] = 0) then     ans := false ; else skip )  ;     i := i + 1 ) ; 
    if (ans) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(final java.util.Scanner sc,final java.io.PrintStream out){
    int i ;
    for(; ; ){
      int n ;
      n=sc.nextInt();
      if(n==0)break ;
      for(i=0 ; i<n ; ++i){
        int x1,y1,z1,w1 ;
        int x2,y2,z2,w2 ;
        x1=sc.nextInt();
        y1=sc.nextInt();
        z1=sc.nextInt();
        w1=sc.nextInt();
        x2=sc.nextInt();
        y2=sc.nextInt();
        z2=sc.nextInt();
        w2=sc.nextInt();
        out.printf("%d %d %d %d\n",x1*x2-y1*y2-z1*z2-w1*w2,y1*x2+x1*y2-w1*z2+z1*w2,z1*x2+w1*y2+x1*z2-y1*w2,w1*x2-z1*y2+y1*z2+x1*w2);
      }
    }
  }
  public static void main(final String[] args){
(new Main()).run(new java.util.Scanner(System.in),System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( sc : Scanner, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var i : int ;
       while true do ( (     var n : int ;
     n := sc.nextInt() ; 
     if (n = 0) then     break else skip ; 
         i := 0 ; while i < n do ( (     var x1 : int ;
    var y1 : int ;
    var z1 : int ;
    var w1 : int ;
     var x2 : int ;
    var y2 : int ;
    var z2 : int ;
    var w2 : int ;
    x1 := sc.nextInt() ; 
    y1 := sc.nextInt() ; 
    z1 := sc.nextInt() ; 
    w1 := sc.nextInt() ; 
    x2 := sc.nextInt() ; 
    y2 := sc.nextInt() ; 
    z2 := sc.nextInt() ; 
    w2 := sc.nextInt() ; 
    out.printf("%d %d %d %d\n", x1 * x2 - y1 * y2 - z1 * z2 - w1 * w2, y1 * x2 + x1 * y2 - w1 * z2 + z1 * w2, z1 * x2 + w1 * y2 + x1 * z2 - y1 * w2, w1 * x2 - z1 * y2 + y1 * z2 + x1 * w2) ; 
 )  ;     i := i + 1 ) )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(Scanner.newScanner(OclFile["System.in"]), OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      int n=sc.nextInt();
      if(n==0)break ;
      for(int i=0 ; i<n ; i++){
        solve();
      }
    }
  }
  int[][] pos={
    {
      0,1,2,3 },{
        1,0,3,2 },{
          2,3,0,1 },{
            3,2,1,0 },};
            int[][] sign={
              {
                1,1,1,1 },{
                  1,-1,1,-1 },{
                    1,-1,-1,1 },{
                      1,1,-1,-1 },};
                      void solve(){
                        int[] t=new int[4];
                        for(int i=0 ; i<4 ; i++)t[i]=sc.nextInt();
                        int[] s=new int[4];
                        for(int i=0 ; i<4 ; i++)s[i]=sc.nextInt();
                        int[] m=new int[4];
                        for(int i=0 ; i<4 ; i++){
                          for(int j=0 ; j<4 ; j++){
                            m[pos[i][j] ]+=sign[i][j]*t[i]*s[j];
                          }
                        }
                        System.out.println(m[0]+" "+m[1]+" "+m[2]+" "+m[3]);
                      }
                    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     execute solve() )  ;     i := i + 1 ) )  ) );
   attribute pos : Sequence(Sequence(int)) := Sequence{Sequence{0,1,2,3},Sequence{1,0,3,2},Sequence{2,3,0,1},Sequence{3,2,1,0},};
   attribute sign : Sequence(Sequence(int)) := Sequence{Sequence{1,1,1,1},Sequence{1,-1,1,-1},Sequence{1,-1,-1,1},Sequence{1,1,-1,-1},};
   operation solve() : void
  pre: true
  post: true
  activity: (     var t : Sequence(int) ; t := Integer.subrange(1,4)->collect(0) ;
         var i : int ; i := 0 ; while i < 4 do (     t[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var s : Sequence(int) ; s := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do (     s[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var m : Sequence(int) ; m := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < 4 do ( (     m[pos[i+1][j+1]+1] := m[pos[i+1][j+1]+1]+(sign[i+1][j+1] * t[i+1] * s[j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(m[0+1] + " " + m[1+1] + " " + m[2+1] + " " + m[3+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner kbd=new Scanner(System.in);
  public static void main(String[] args){
    while(true){
      int n=kbd.nextInt();
      if(n==0)break ;
      while(n-->0)solve();
    }
  }
  static void solve(){
    long[] a=new long[4];
    long[] b=new long[4];
    int i ;
    for(i=0 ; i<4 ; i++){
      a[i]=kbd.nextLong();
    }
    for(i=0 ; i<4 ; i++){
      b[i]=kbd.nextLong();
    }
    long[] ans=new long[4];
    ans[0]=a[0]*b[0]-a[1]*b[1]-a[2]*b[2]-a[3]*b[3];
    ans[1]=a[0]*b[1]+a[1]*b[0]+a[2]*b[3]-a[3]*b[2];
    ans[2]=a[0]*b[2]-a[1]*b[3]+a[2]*b[0]+a[3]*b[1];
    ans[3]=a[0]*b[3]+a[1]*b[2]-a[2]*b[1]+a[3]*b[0];
    System.out.println(ans[0]+" "+ans[1]+" "+ans[2]+" "+ans[3]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute kbd : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := kbd.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
         while (n > 0) do (        n := n - 1 ;     skip ;     execute solve() ; ;  ) ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,4)->collect(0) ;
     var b : Sequence(long) ; b := Integer.subrange(1,4)->collect(0) ;
    var i : int ;
        i := 0 ; while i < 4 do ( (     a[i+1] := kbd.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        i := 0 ; while i < 4 do ( (     b[i+1] := kbd.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var ans : Sequence(long) ; ans := Integer.subrange(1,4)->collect(0) ;
    ans[0+1] := a[0+1] * b[0+1] - a[1+1] * b[1+1] - a[2+1] * b[2+1] - a[3+1] * b[3+1] ; 
    ans[1+1] := a[0+1] * b[1+1] + a[1+1] * b[0+1] + a[2+1] * b[3+1] - a[3+1] * b[2+1] ; 
    ans[2+1] := a[0+1] * b[2+1] - a[1+1] * b[3+1] + a[2+1] * b[0+1] + a[3+1] * b[1+1] ; 
    ans[3+1] := a[0+1] * b[3+1] + a[1+1] * b[2+1] - a[2+1] * b[1+1] + a[3+1] * b[0+1] ; 
    OclFile["System.out"].println(ans[0+1] + " " + ans[1+1] + " " + ans[2+1] + " " + ans[3+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class pre5 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int a=obj.nextInt(),b=obj.nextInt();
    int dx=obj.nextInt(),dy=obj.nextInt();
    int x=obj.nextInt(),y=obj.nextInt();
    if(abs(dx-a)% x==0 && abs(dy-b)% y==0){
      if((abs(dx-a)/x)% 2==(abs(dy-b)/y)% 2)out.println("YES");
      else out.println("NO");
    }
    else out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre5 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var a : int ; a := obj.nextInt() ;
    var b : int ; b := obj.nextInt() ;
    var dx : int ; dx := obj.nextInt() ;
    var dy : int ; dy := obj.nextInt() ;
    var x : int ; x := obj.nextInt() ;
    var y : int ; y := obj.nextInt() ;
    if (abs(dx - a) mod x = 0 & abs(dy - b) mod y = 0) then (     if ((abs(dx - a) / x) mod 2 = (abs(dy - b) / y) mod 2) then     out.println("YES") ; else     out.println("NO") ; ) else     out.println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long x1=sc.nextLong();
    long y1=sc.nextLong();
    long x2=sc.nextLong();
    long y2=sc.nextLong();
    long x=sc.nextLong();
    long y=sc.nextLong();
    boolean b=false ;
    if(Math.abs(x2-x1)% x==0 && Math.abs(y2-y1)% y==0){
      long t1=Math.abs(x2-x1)/x ;
      long t2=Math.abs(y2-y1)/y ;
      if(t1 % 2==t2 % 2){
        System.out.println("YES");
      }
      else System.out.println("NO");
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : long ; x1 := sc.getCurrent()->toLong() ;
    var y1 : long ; y1 := sc.getCurrent()->toLong() ;
    var x2 : long ; x2 := sc.getCurrent()->toLong() ;
    var y2 : long ; y2 := sc.getCurrent()->toLong() ;
    var x : long ; x := sc.getCurrent()->toLong() ;
    var y : long ; y := sc.getCurrent()->toLong() ;
    var b : boolean ; b := false ;
    if (if x2 - x1 < 0 then -(x2 - x1) else x2 - x1 endif mod x = 0 & if y2 - y1 < 0 then -(y2 - y1) else y2 - y1 endif mod y = 0) then (     var t1 : long ; t1 := if x2 - x1 < 0 then -(x2 - x1) else x2 - x1 endif / x ;
     var t2 : long ; t2 := if y2 - y1 < 0 then -(y2 - y1) else y2 - y1 endif / y ;
     if (t1 mod 2 = t2 mod 2) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] arg){
    int N=sc.nextInt();
    int K=sc.nextInt();
    int T=sc.nextInt();
    int U=sc.nextInt();
    int V=sc.nextInt();
    int L=sc.nextInt();
    int[] D=new int[N];
    for(int i=0 ; i<N ; ++i){
      D[i]=sc.nextInt();
    }
    int pos=0 ;
    double time=0 ;
    double dist=0 ;
    double bootEnd=-1 ;
    int carrot=0 ;
    while(true){
      if(bootEnd<0){
        if(carrot>0){
--carrot ;
          bootEnd=dist+T*V ;
        }
        else {
          if(pos<N){
            time+=(D[pos]-dist)/U ;
            dist=D[pos];
++pos ;
++carrot ;
          }
          else {
            time+=(L-dist)/U ;
            break ;
          }
        }
      }
      else {
        if(pos<N){
          if(bootEnd<D[pos]){
            time+=(bootEnd-dist)/V ;
            dist=bootEnd ;
            bootEnd=-1 ;
          }
          else {
            time+=(D[pos]-dist)/V ;
            dist=D[pos];
            if(carrot==K){
              bootEnd=D[pos]+T*V ;
            }
            else {
++carrot ;
            }
++pos ;
          }
        }
        else {
          if(bootEnd<L){
            time+=(bootEnd-dist)/V ;
            dist=bootEnd ;
            bootEnd=-1 ;
          }
          else {
            time+=(L-dist)/V ;
            break ;
          }
        }
      }
    }
    System.out.println(time);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
    var U : int ; U := sc.getCurrent()->toInteger() ;
    var V : int ; V := sc.getCurrent()->toInteger() ;
    var L : int ; L := sc.getCurrent()->toInteger() ;
    var D : Sequence(int) ; D := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     D[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var pos : int ; pos := 0 ;
    var time : double ; time := 0 ;
    var dist : double ; dist := 0 ;
    var bootEnd : double ; bootEnd := -1 ;
    var carrot : int ; carrot := 0 ;
    while (true) do (     if (bootEnd < 0) then (     if (carrot > 0) then (     carrot := carrot - 1 ; 
     bootEnd := dist + T * V ) else (     if (pos < N) then (     time := time+((D[pos+1] - dist) / U) ; 
     dist := D[pos+1] ; 
     pos := pos + 1 ; 
     carrot := carrot + 1 ) else (     time := time+((L - dist) / U) ; 
     break ) ) ) else (     if (pos < N) then (     if (bootEnd < D[pos+1]) then (     time := time+((bootEnd - dist) / V) ; 
     dist := bootEnd ; 
     bootEnd := -1 ) else (     time := time+((D[pos+1] - dist) / V) ; 
     dist := D[pos+1] ; 
     if (carrot = K) then (     bootEnd := D[pos+1] + T * V ) else (     carrot := carrot + 1 ) ;  
     pos := pos + 1 ) ) else (     if (bootEnd < L) then (     time := time+((bootEnd - dist) / V) ; 
     dist := bootEnd ; 
     bootEnd := -1 ) else (     time := time+((L - dist) / V) ; 
     break ) ) ) ) ; 
    OclFile["System.out"].println(time) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.run();
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    ArrayList<ArrayList<Integer>>g0=new ArrayList<ArrayList<Integer>>();
    ArrayList<ArrayList<Integer>>g1=new ArrayList<ArrayList<Integer>>();
    for(int i=0 ; i<k ; i++){
      g0.add(new ArrayList<Integer>());
      g1.add(new ArrayList<Integer>());
    }
    for(int i=1 ; i<k ; i++){
      g0.get(i).add((i*10)% k);
      g1.get(i).add((i+1)% k);
    }
    ArrayDeque<Integer>deq=new ArrayDeque<Integer>();
    int dist[]=new int[k];
    int INF=1001001001 ;
    for(int i=0 ; i<k ; i++)dist[i]=INF ;
    dist[1]=1 ;
    deq.push(1);
    while(! deq.isEmpty()){
      int u=deq.poll();
      for(int v : g0.get(u)){
        if(dist[v]>dist[u]){
          dist[v]=dist[u];
          deq.addFirst(v);
        }
      }
      for(int v : g1.get(u)){
        if(dist[v]>dist[u]){
          dist[v]=dist[u]+1 ;
          deq.addLast(v);
        }
      }
    }
    System.out.println(dist[0]);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var g0 : Sequence(Sequence(int)) ; g0 := Sequence{} ;
    var g1 : Sequence(Sequence(int)) ; g1 := Sequence{} ;
        var i : int ; i := 0 ; while i < k do ( (     g0 := g0->including(Sequence{}) ; 
     g1 := g1->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < k do ( (     g0->at(i+1)->excludes((i * 10) mod k) ; 
     g1->at(i+1)->excludes((i + 1) mod k) )  ;     i := i + 1 ) ; 
    var deq : Sequence(int) ; deq := ArrayDeque<int>.newArrayDeque() ;
    var dist : Sequence(int) ; dist := Integer.subrange(1,k)->collect(0) ;
    var INF : int ; INF := 1001001001 ;
        var i : int ; i := 0 ; while i < k do (     dist[i+1] := INF ;  ;     i := i + 1 ) ; 
    dist[1+1] := 1 ; 
    deq := deq->append(1) ; 
    while (not(deq->isEmpty())) do (     var u : int ; u := deq->min() ;
     for (v : g0->at(u+1)) do ( (     if (dist[v+1] > dist[u+1]) then (     dist[v+1] := dist[u+1] ; 
     deq := deq->prepend(v) ) else skip )  ) ; 
     for (v : g1->at(u+1)) do ( (     if (dist[v+1] > dist[u+1]) then (     dist[v+1] := dist[u+1] + 1 ; 
     deq := deq->append(v) ) else skip )  ) ) ; 
    OclFile["System.out"].println(dist[0+1]) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findMaximum(int l,int p,int q,int r){
    int dp[]=new int[l+1];
    for(int i=0 ; i<l+1 ; i++)dp[i]=-1 ;
    dp[0]=0 ;
    for(int i=0 ; i<=l ; i++){
      if(dp[i]==-1)continue ;
      if(i+p<=l)dp[i+p]=Math.max(dp[i+p],dp[i]+1);
      if(i+q<=l)dp[i+q]=Math.max(dp[i+q],dp[i]+1);
      if(i+r<=l)dp[i+r]=Math.max(dp[i+r],dp[i]+1);
    }
    return dp[l];
  }
  public static void main(String[] args){
    int l=11,p=2,q=3,r=5 ;
    int ans=findMaximum(l,p,q,r);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMaximum( l : int, p : int, q : int, r : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,l + 1)->collect(0) ;
         var i : int ; i := 0 ; while i < l + 1 do (     dp[i+1] := -1 ;  ;     i := i + 1 ) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i <= l do ( (     if (dp[i+1] = -1) then     continue else skip ; 
     if (i + p <= l) then     dp[i + p+1] := Set{dp[i + p+1], dp[i+1] + 1}->max() ; else skip ; 
     if (i + q <= l) then     dp[i + q+1] := Set{dp[i + q+1], dp[i+1] + 1}->max() ; else skip ; 
     if (i + r <= l) then     dp[i + r+1] := Set{dp[i + r+1], dp[i+1] + 1}->max() ; else skip )  ;     i := i + 1 ) ; 
    return dp[l+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 11 ;
    var p : int ; p := 2 ;
    var q : int ; q := 3 ;
    var r : int ; r := 5 ;
     var ans : int ; ans := findMaximum(l, p, q, r) ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    BigInteger big_num=BigInteger.valueOf(1);
    for(int i=2 ; i<=num+1 ; i++){
      big_num=big_num.multiply(BigInteger.valueOf(i));
    }
    System.out.println(big_num.add(BigInteger.valueOf(2)));
    for(int i=2 ; i<=num+1 ; i++){
      System.out.println(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
    var big_num : long ; big_num := (1 + "")->toLong() ;
        var i : int ; i := 2 ; while i <= num + 1 do ( (     big_num := big_num.multiply((i + "")->toLong()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(big_num->excludes((2 + "")->toLong())) ; 
        var i : int ; i := 2 ; while i <= num + 1 do ( (     OclFile["System.out"].println(i) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
class Main {
  @ SuppressWarnings("resource")public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int a=scanner.nextInt();
    List<Integer>x=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      x.add(scanner.nextInt());
    }
    long ans=0 ;
    long[][][] dp=new long[n+1][n+1][n*a+1];
    dp[0][0][0]=1 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=0 ; j<=n ; j++){
        for(int k=0 ; k<=n*a ; k++){
          if(j-1>=0 && k-x.get(i-1)>=0){
            dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-x.get(i-1)];
          }
          else {
            dp[i][j][k]=dp[i-1][j][k];
          }
        }
      }
    }
    for(int j=1 ; j<=n ; j++){
      ans+=dp[n][j][a*j];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var a : int ; a := scanner.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     x := x->including(scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var dp : Sequence(Sequence(Sequence(long))) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n * a + 1)->collect(0))) ;
    dp[0+1][0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= n do ( (         var k : int ; k := 0 ; while k <= n * a do ( (     if (j - 1 >= 0 & k - x->at(i - 1+1) >= 0) then (     dp[i+1][j+1][k+1] := dp[i - 1+1][j+1][k+1] + dp[i - 1+1][j - 1+1][k - x->at(i - 1+1)+1] ) else (     dp[i+1][j+1][k+1] := dp[i - 1+1][j+1][k+1] ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var j : int ; j := 1 ; while j <= n do ( (     ans := ans+(dp[n+1][j+1][a * j+1]) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Bulbs {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),m=in.nextInt(),i ;
    boolean[] a=new boolean[m];
    String o="YES" ;
    while(n-->0){
      int x=in.nextInt();
      while(x-->0){
        a[in.nextInt()-1]=true ;
      }
    }
    in.close();
    for(i=0 ; i<m ; i++){
      if(a[i]==false){
        o="NO" ;
      }
    }
    System.out.println(o);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Bulbs {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var i : int ;
    var a : Sequence(boolean) ; a := Integer.subrange(1,m)->collect(false) ;
    var o : String ; o := "YES" ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var x : int ; x := in.getCurrent()->toInteger() ;
         while (x > 0) do (        x := x - 1 ;     skip ; (     a[in.getCurrent()->toInteger() - 1+1] := true ) ;  ) ) ;  ) ;  
    skip ; 
        i := 0 ; while i < m do ( (     if (a[i+1] = false) then (     o := "NO" ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(o) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.BigInteger ;
import static java.lang.Math.*;
class Main {
  static int[] makePrimes(final int lim){
    BitSet isPrime=new BitSet(lim+1);
    isPrime.set(0,lim+1,true);
    isPrime.set(0,2,false);
    final int limIndex=(int)sqrt(lim);
    for(int index=2 ; index<=limIndex ; index++){
      if(isPrime.get(index)){
        for(int i=index*index ; i<=lim ; i+=index){
          isPrime.set(i,false);
        }
      }
    }
    final int count=isPrime.cardinality();
    int[] ans=new int[count];
    int index=0 ;
    for(int i=0 ; i<=lim ; i++){
      if(isPrime.get(i)){
        ans[index++]=i ;
      }
    }
    return ans ;
  }
  public static void main(final String[] args){
    final Scanner stdin=new Scanner(System.in);
    final int n=stdin.nextInt();
    int[] primes=makePrimes(n+1);
    BigInteger b=lcmAll(primes).add(new BigInteger("2"));
    System.out.println(b);
    for(int i=2 ; i<=n+1 ; i++){
      boolean success=false ;
      for(int j=0 ; j<=primes.length && primes[j]<=i ; j++){
        if(i % primes[j]==0){
          System.out.println(primes[j]);
          success=true ;
          break ;
        }
      }
      if(! success){
        System.out.println(i);
      }
    }
  }
  static BigInteger lcmAll(int[] primes){
    BigInteger ans=BigInteger.ONE ;
    for(int i : primes){
      final BigInteger val=new BigInteger(Integer.toString(i));
      ans=ans.multiply(val);
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation makePrimes( lim : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var isPrime : Sequence(boolean) ; isPrime := MathLib.toBitSequence(lim + 1) ;
     isPrime := isPrime.setAt(0+1,true) ; 
    isPrime := isPrime.setAt(0+1,false) ; 
    var limIndex : int ; limIndex := sqrt(lim)->oclAsType(int) ;
        var index : int ; index := 2 ; while index <= limIndex do ( (     if (isPrime->at(index+1)) then (         var i : int ; i := index * index ; while i <= lim do ( (     isPrime := isPrime.setAt(i+1,false) )  ;     i := i+(index) ) ) else skip )  ;     index := index + 1 ) ; 
    var count : int ; count := isPrime.cardinality() ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,count)->collect(0) ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i <= lim do ( (     if (isPrime->at(i+1)) then (      ans[index+1] := i  ; index := index + 1 ) else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdin.getCurrent()->toInteger() ;
    var primes : Sequence(int) ; primes := makePrimes(n + 1) ;
    var b : long ; b := lcmAll(primes)->excludes(long("2")) ;
    OclFile["System.out"].println(b) ; 
        var i : int ; i := 2 ; while i <= n + 1 do ( (     var success : boolean ; success := false ;
         var j : int ; j := 0 ; while j <= primes->size() & primes[j+1] <= i do ( (     if (i mod primes[j+1] = 0) then (     OclFile["System.out"].println(primes[j+1]) ; 
     success := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (not(success)) then (     OclFile["System.out"].println(i) ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation lcmAll( primes : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
     for (i : primes) do ( (     var val : long ; val := long(((i) + "")) ;
     ans := ans.multiply(val) )  ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.math.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    new Solver();
  }
}
class Solver {
  ScanReader reader=new ScanReader(System.in);
  PrintWriter writer=new PrintWriter(System.out);
  Solver(){
    main();
    writer.flush();
  }
  void main(){
    BigInteger m=BigInteger.ONE ;
    for(int i=0 ; i<1500 ; i++)m=m.multiply(BigInteger.valueOf(i+2));
    m=m.add(BigInteger.valueOf(2));
    while(reader.hasNext()){
      int n=Integer.parseInt(reader.next());
      System.out.println(m);
      for(int i=0 ; i<n ; i++)System.out.println(i+2);
    }
  }
}
class ScanReader {
  BufferedReader br ;
  StringTokenizer st ;
  public ScanReader(InputStream in){
    br=new BufferedReader(new InputStreamReader(in));
    st=null ;
  }
  public boolean hasNext(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        if(! br.ready())return false ;
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return true ;
  }
  public String nextLine(){
    hasNext();
    return st.nextToken("");
  }
  public String next(){
    hasNext();
    return st.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Solver.newSolver() );
}
class Solver {
   attribute reader : ScanReader := ScanReader.newScanReader(OclFile["System.in"]);
   attribute writer : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   static operation newSolver() : Solver
  pre: true
  post: true
  activity:
  ( var self : Solver ;
    self := createSolver();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute main() ; 
     skip );
   operation main() : void
  pre: true
  post: true
  activity: (     var m : long ; m := 1 ;
         var i : int ; i := 0 ; while i < 1500 do (     m := m.multiply((i + 2 + "")->toLong()) ;  ;     i := i + 1 ) ; 
     m := m->excludes((2 + "")->toLong()) ; 
     while (reader.hasNext()) do (     var n : int ; n := (reader.next())->toInteger() ;
     OclFile["System.out"].println(m) ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].println(i + 2) ;  ;     i := i + 1 ) ) );
}
class ScanReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newScanReader( in : OclFile) : ScanReader
  pre: true
  post: true
  activity:
  ( var self : ScanReader ;
    self := createScanReader();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     st := null );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     if (not(br.canRead())) then     return false else skip ; 
     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return true );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     execute hasNext() ; 
     return st.nextToken("") );
   operation next() : String
  pre: true
  post: true
  activity: (     execute hasNext() ; 
     return st.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  final static int SIZE=1501 ;
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    BigInteger[] fact=new BigInteger[SIZE+1];
    for(int i=0 ; i<=SIZE ; i++){
      if(i==0){
        fact[i]=new BigInteger(1+"");
      }
      else {
        fact[i]=fact[i-1] .multiply(new BigInteger(i+""));
      }
    }
    final int n=sc.nextInt();
    final BigInteger ans=fact[n+1] .add(new BigInteger("2"));
    System.out.println(ans);
    for(int i=0 ; i<n ; i++){
      System.out.println(i+2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute SIZE : int := 1501;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var fact : Sequence(long) ; fact := Integer.subrange(1,SIZE + 1)->collect(null) ;
        var i : int ; i := 0 ; while i <= SIZE do ( (     if (i = 0) then (     fact[i+1] := long(1 + "") ) else (     fact[i+1] := fact[i - 1+1].multiply(long(i + "")) ) )  ;     i := i + 1 ) ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : long ; ans := fact[n + 1+1]->excludes(long("2")) ;
    OclFile["System.out"].println(ans) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(i + 2) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CD {
  public static void main(String[] args){
    Scanner st=new Scanner(System.in);
    int n=st.nextInt();
    int m=st.nextInt();
    int amt=0 ;
    int q=n ;
    for(int i=1 ; i<=n ; i++){
      if(i*m<=n){
        amt++;
        n++;
      }
      else {
        break ;
      }
    }
    System.out.println(amt+q);
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CD {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var st : OclFile ; st := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := st.getCurrent()->toInteger() ;
    var m : int ; m := st.getCurrent()->toInteger() ;
    var amt : int ; amt := 0 ;
    var q : int ; q := n ;
        var i : int ; i := 1 ; while i <= n do ( (     if (i * m <= n) then (     amt := amt + 1 ; 
     n := n + 1 ) else (     break ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(amt + q) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int k=sc.nextInt();
      int t=sc.nextInt();
      int u=sc.nextInt();
      int v=sc.nextInt();
      int l=sc.nextInt();
      int[] d=new int[n];
      for(int i=0 ; i<n ; i++){
        d[i]=sc.nextInt();
      }
      int stock=0,start=0,end=0,sum=0 ;
      for(int i=0 ; i<n ; i++){
        if(d[i]<=end){
          if(stock==k){
            end=Math.min(l,d[i]+t*v);
          }
          else {
            stock++;
          }
        }
        else {
          while(stock!=0 && d[i]>end){
            stock--;
            end=Math.min(l,end+t*v);
          }
          if(d[i]<=end){
            stock++;
          }
          else {
            sum+=end-start ;
            start=d[i];
            end=Math.min(l,d[i]+t*v);
          }
        }
      }
      sum+=Math.min(l,(long)end+(long)stock*t*v)-start ;
      double res=(double)(l-sum)/u+(double)sum/v ;
      System.out.printf("%.7f\n",res);
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var u : int ; u := sc.getCurrent()->toInteger() ;
    var v : int ; v := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     d[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var stock : int ; stock := 0 ;
    var start : int ; start := 0 ;
    var end : int ; end := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (d[i+1] <= end) then (     if (stock = k) then (     end := Set{l, d[i+1] + t * v}->min() ) else (     stock := stock + 1 ) ) else (     while (stock /= 0 & d[i+1] > end) do (     stock := stock - 1 ; 
     end := Set{l, end + t * v}->min() ) ; 
     if (d[i+1] <= end) then (     stock := stock + 1 ) else (     sum := sum+(end - start) ; 
     start := d[i+1] ; 
     end := Set{l, d[i+1] + t * v}->min() ) ) )  ;     i := i + 1 ) ; 
    sum := sum+(Set{l, end->oclAsType(long) + stock->oclAsType(long) * t * v}->min() - start) ; 
    var res : double ; res := (l - sum)->oclAsType(double) / u + sum->oclAsType(double) / v ;
    OclFile["System.out"].printf("%.7f\n", res) ; 
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    boolean b=false ;
    int n=sc.nextInt();
    int m=sc.nextInt();
    int count=0 ;
    while(n>0){
      n=n-1 ;
      count=count+1 ;
      if(count % m==0 && count!=0){
        n=n+1 ;
        b=true ;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var b : boolean ; b := false ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    while (n > 0) do (     n := n - 1 ; 
     count := count + 1 ; 
     if (count mod m = 0 & count /= 0) then (     n := n + 1 ; 
     b := true ) else skip ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    int t=x ;
    while(x>=y){
      int a=x/y ;
      t=t+a ;
      int r=x % y ;
      x=a+r ;
    }
    System.out.println(t);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var t : int ; t := x ;
    while (x >= y) do (     var a : int ; a := x / y ;
     t := t + a ; 
     var r : int ; r := x mod y ;
     x := a + r ) ; 
    OclFile["System.out"].println(t) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solver {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int cnt=0 ;
    int ans=0 ;
    while(n>0){
      cnt++;
      ans++;
      if(cnt==m){
        n++;
        cnt=0 ;
      }
      n--;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solver {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var cnt : int ; cnt := 0 ;
    var ans : int ; ans := 0 ;
    while (n > 0) do (     cnt := cnt + 1 ; 
     ans := ans + 1 ; 
     if (cnt = m) then (     n := n + 1 ; 
     cnt := 0 ) else skip ; 
     n := n - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static final int NO_OF_CHARS=256 ;
  static boolean areAnagram(String str1,String str2){
    int[] count=new int[NO_OF_CHARS];
    int i ;
    for(i=0 ; i<str1.length()&& i<str2.length(); i++){
      count[str1.charAt(i)]++;
      count[str2.charAt(i)]--;
    }
    if(str1.length()!=str2.length())return false ;
    for(i=0 ; i<NO_OF_CHARS ; i++)if(count[i]!=0)return false ;
    return true ;
  }
  static void findAllAnagrams(String arr[],int n){
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++)if(areAnagram(arr[i],arr[j]))System.out.println(arr[i]+" is anagram of "+arr[j]);
  }
  public static void main(String args[]){
    String arr[]={
      "geeksquiz","geeksforgeeks","abcd","forgeeksgeeks","zuiqkeegs" };
      int n=arr.length ;
      findAllAnagrams(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute NO_OF_CHARS : int := 256;
  static   operation areAnagram( str1 : String, str2 : String) : boolean
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,NO_OF_CHARS)->collect(0) ;
     var i : int ;
        i := 0 ; while i < str1->size() & i < str2->size() do ( (     count[str1->at(i+1)+1] := count[str1->at(i+1)+1] + 1 ; 
     count[str2->at(i+1)+1] := count[str2->at(i+1)+1] - 1 )  ;     i := i + 1 ) ; 
    if (str1->size() /= str2->size()) then     return false else skip ; 
        i := 0 ; while i < NO_OF_CHARS do (     if (count[i+1] /= 0) then     return false else skip ;  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation findAllAnagrams( arr : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do (     if (areAnagram(arr[i+1], arr[j+1])) then     OclFile["System.out"].println(arr[i+1] + " is anagram of " + arr[j+1]) ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"geeksquiz","geeksforgeeks","abcd","forgeeksgeeks","zuiqkeegs"} ;
     var n : int ; n := arr->size() ;
     execute findAllAnagrams(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int max_size=20 ;
  static int max_k=20 ;
  static int[][] dp=new int[max_size][max_k];
  static boolean[][] v=new boolean[max_size][max_k];
  static int sum=0 ;
  static void findSum(int arr[],int n){
    for(int i=0 ; i<n ; i++)sum+=arr[i];
  }
  static int cntWays(int arr[],int i,int ck,int k,int n,int curr_sum){
    if(sum % k!=0)return 0 ;
    if(i!=n && ck==k+1)return 0 ;
    if(i==n){
      if(ck==k+1)return 1 ;
      else return 0 ;
    }
    if(v[i][ck])return dp[i][ck];
    curr_sum+=arr[i];
    v[i][ck]=true ;
    dp[i][ck]=cntWays(arr,i+1,ck,k,n,curr_sum);
    if(curr_sum==(sum/k)*ck)dp[i][ck]+=cntWays(arr,i+1,ck+1,k,n,curr_sum);
    return dp[i][ck];
  }
  public static void main(String[] args){
    int arr[]={
      1,-1,1,-1,1,-1 };
      int n=arr.length ;
      int k=2 ;
      findSum(arr,n);
      System.out.println(cntWays(arr,0,1,k,n,0));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute max_size : int := 20;
  static   attribute max_k : int := 20;
  static   attribute dp : Sequence(Sequence(int)) := Integer.subrange(1,max_size)->collect(Integer.subrange(1,max_k)->collect(0));
  static   attribute v : Sequence(Sequence(boolean)) := Integer.subrange(1,max_size)->collect(Integer.subrange(1,max_k)->collect(false));
  static   attribute sum : int := 0;
  static   operation findSum( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) );
  static   operation cntWays( arr : Sequence(int), i : int, ck : int, k : int, n : int, curr_sum : int) : int
  pre: true
  post: true
  activity: (     if (sum mod k /= 0) then     return 0 else skip ; 
     if (i /= n & ck = k + 1) then     return 0 else skip ; 
    if (i = n) then (     if (ck = k + 1) then     return 1 else     return 0 ) else skip ; 
    if (v[i+1][ck+1]) then     return dp[i+1][ck+1] else skip ; 
    curr_sum := curr_sum+(arr[i+1]) ; 
    v[i+1][ck+1] := true ; 
    dp[i+1][ck+1] := cntWays(arr, i + 1, ck, k, n, curr_sum) ; 
    if (curr_sum = (sum / k) * ck) then     dp[i+1][ck+1] := dp[i+1][ck+1]+(cntWays(arr, i + 1, ck + 1, k, n, curr_sum)) ; else skip ; 
    return dp[i+1][ck+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,-1,1,-1,1,-1} ;
     var n : int ; n := arr->size() ;
    var k : int ; k := 2 ;
    execute findSum(arr, n) ; 
    OclFile["System.out"].println(cntWays(arr, 0, 1, k, n, 0)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int INT_MAX=Integer.MAX_VALUE ;
  static int solve(int arr[],int n,int k){
    int minx=INT_MAX ;
    int i ;
    for(i=0 ; i<n ; i++){
      minx=Math.min(minx,arr[i]);
    }
    int decrements=0 ;
    for(i=0 ; i<n ; i++){
      if((arr[i]-minx)% k!=0){
        return-1 ;
      }
      else {
        decrements+=((arr[i]-minx)/k);
      }
    }
    return decrements ;
  }
  public static void main(String[] args){
    int n,k ;
    n=3 ;
    k=3 ;
    int arr[]={
      12,9,15 };
      System.out.println(solve(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute INT_MAX : int := 2147483647;
  static   operation solve( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var minx : int ; minx := INT_MAX ;
     var i : int ;
        i := 0 ; while i < n do ( (     minx := Set{minx, arr[i+1]}->min() )  ;     i := i + 1 ) ; 
    var decrements : int ; decrements := 0 ;
        i := 0 ; while i < n do ( (     if ((arr[i+1] - minx) mod k /= 0) then (     return -1 ) else (     decrements := decrements+(((arr[i+1] - minx) / k)) ) )  ;     i := i + 1 ) ; 
    return decrements 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var k : int ;
     n := 3 ; 
    k := 3 ; 
    var arr : Sequence(int) ; arr := Sequence{12,9,15} ;
    OclFile["System.out"].println(solve(arr, n, k)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Bulbs {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String[] input=scan.nextLine().split(" ");
    int button=Integer.parseInt(input[0]);
    boolean[] bulb=new boolean[Integer.parseInt(input[1])];
    for(int i=0 ; i<button ; i++){
      input=scan.nextLine().split(" ");
      for(int j=1 ; j<input.length ; j++){
        bulb[Integer.parseInt(input[j])-1]=true ;
      }
    }
    boolean light=true ;
    for(int i=0 ; i<bulb.length ; i++){
      if(! bulb[i])light=false ;
    }
    System.out.println(light ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Bulbs {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : Sequence(String) ; input := scan.nextLine()->split(" ") ;
    var button : int ; button := (input[0+1])->toInteger() ;
    var bulb : Sequence(boolean) ; bulb := Integer.subrange(1,(input[1+1])->toInteger())->collect(false) ;
        var i : int ; i := 0 ; while i < button do ( (     input := scan.nextLine()->split(" ") ; 
         var j : int ; j := 1 ; while j < input->size() do ( (     bulb[(input[j+1])->toInteger() - 1+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var light : boolean ; light := true ;
        var i : int ; i := 0 ; while i < bulb->size() do ( (     if (not(bulb[i+1])) then     light := false ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if light then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isSubsetSum(int set[],int n,int sum){
    boolean subset[][]=new boolean[sum+1][n+1];
    for(int i=0 ; i<=n ; i++)subset[0][i]=true ;
    for(int i=1 ; i<=sum ; i++)subset[i][0]=false ;
    for(int i=1 ; i<=sum ; i++){
      for(int j=1 ; j<=n ; j++){
        subset[i][j]=subset[i][j-1];
        if(i>=set[j-1])subset[i][j]=subset[i][j] || subset[i-set[j-1] ][j-1];
      }
    }
    return subset[sum][n];
  }
  public static void main(String args[]){
    int set[]={
      3,34,4,12,5,2 };
      int sum=9 ;
      int n=set.length ;
      if(isSubsetSum(set,n,sum)==true)System.out.println("Found a subset"+" with given sum");
      else System.out.println("No subset with"+" given sum");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isSubsetSum( set : Sequence(int), n : int, sum : int) : boolean
  pre: true
  post: true
  activity: (     var subset : Sequence(Sequence(boolean)) ; subset := Integer.subrange(1,sum + 1)->collect(Integer.subrange(1,n + 1)->collect(false)) ;
         var i : int ; i := 0 ; while i <= n do (     subset[0+1][i+1] := true ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= sum do (     subset[i+1][0+1] := false ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= sum do ( (         var j : int ; j := 1 ; while j <= n do ( (     subset[i+1][j+1] := subset[i+1][j - 1+1] ; 
     if (i >= set[j - 1+1]) then     subset[i+1][j+1] := subset[i+1][j+1] or subset[i - set[j - 1+1]+1][j - 1+1] ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return subset[sum+1][n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var set : Sequence(int) ; set := Sequence{3,34,4,12,5,2} ;
     var sum : int ; sum := 9 ;
     var n : int ; n := set->size() ;
     if (isSubsetSum(set, n, sum) = true) then     OclFile["System.out"].println("Found a subset" + " with given sum") ; else     OclFile["System.out"].println("No subset with" + " given sum") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean checkPalindrome(String str){
    int n=str.length();
    int count=0 ;
    for(int i=0 ; i<n/2 ; ++i)if(str.charAt(i)!=str.charAt(n-i-1))++count ;
    return(count<=1);
  }
  public static void main(String[] args){
    String str="abccaa" ;
    if(checkPalindrome(str))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkPalindrome( str : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n / 2 do (     if (str->at(i+1) /= str->at(n - i - 1+1)) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return (count <= 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abccaa" ;
     if (checkPalindrome(str)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getHCF(int x,int y){
    int minimum=Math.min(x,y);
    if(x % minimum==0 && y % minimum==0)return minimum ;
    for(int i=minimum/2 ; i>=2 ; i--){
      if(x % i==0 && y % i==0)return i ;
    }
    return 1 ;
  }
  public static void main(String[] args){
    int x=16,y=32 ;
    System.out.println(getHCF(x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getHCF( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var minimum : int ; minimum := Set{x, y}->min() ;
     if (x mod minimum = 0 & y mod minimum = 0) then     return minimum else skip ; 
         var i : int ; i := minimum / 2 ; while i >= 2 do ( (     if (x mod i = 0 & y mod i = 0) then     return i else skip )  ;     i := i - 1 ) ; 
     return 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 16 ;
    var y : int ; y := 32 ;
     OclFile["System.out"].println(getHCF(x, y)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    int n=sc.nextInt();
    int k=sc.nextInt();
    int t=sc.nextInt();
    int u=sc.nextInt();
    int v=sc.nextInt();
    int l=sc.nextInt();
    int d[]=new int[n+1];
    for(int i=0 ; i<n ; i++){
      d[i]=sc.nextInt();
    }
    d[n]=l ;
    int index=0 ;
    int nc=0 ;
    int cn=0 ;
    long boost=t*v ;
    int bl=0 ;
    for(int i=0 ; i<l ; i++){
      if(d[index]<=i){
        if(cn==0){
          nc=i ;
        }
        if(cn==k+1){
          nc=i ;
        }
        else {
          cn++;
        }
        index++;
      }
      if(cn!=0 && i-nc==boost){
        nc=i ;
        cn--;
      }
      if(cn>0){
        bl++;
      }
    }
    int nbl=l-bl ;
    System.out.println((double)bl/v+(double)nbl/u);
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var u : int ; u := sc.getCurrent()->toInteger() ;
    var v : int ; v := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var d : Sequence(int) ; d := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     d[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    d[n+1] := l ; 
    var index : int ; index := 0 ;
    var nc : int ; nc := 0 ;
    var cn : int ; cn := 0 ;
    var boost : long ; boost := t * v ;
    var bl : int ; bl := 0 ;
        var i : int ; i := 0 ; while i < l do ( (     if (d[index+1] <= i) then (     if (cn = 0) then (     nc := i ) else skip ; 
     if (cn = k + 1) then (     nc := i ) else (     cn := cn + 1 ) ;  
     index := index + 1 ) else skip ; 
     if (cn /= 0 & i - nc = boost) then (     nc := i ; 
     cn := cn - 1 ) else skip ; 
     if (cn > 0) then (     bl := bl + 1 ) else skip )  ;     i := i + 1 ) ; 
    var nbl : int ; nbl := l - bl ;
    OclFile["System.out"].println(bl->oclAsType(double) / v + nbl->oclAsType(double) / u) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class CF2 {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));
    Task solver=new Task();
    solver.solve(br,pw);
    pw.close();
  }
  static class Task {
    public void solve(BufferedReader br,PrintWriter pw)throws IOException {
      int n=Integer.parseInt(br.readLine());
      if(n % 2==1){
        pw.println(-1);
        return ;
      }
      int rowLen=2 ;
      StringBuilder layer=new StringBuilder("bb\n"+"bb\n");
      int numRows=2 ;
      boolean black=false ;
      int end=(n-2)/2 ;
      for(int i=0 ; i<end ; i++){
        char c=black ? 'b' : 'w' ;
        int start=0 ;
        for(int j=0 ; j<numRows ; j++){
          layer.insert(start,c);
          start+=rowLen+1 ;
          layer.insert(start,c);
          start+=2 ;
        }
        rowLen+=2 ;
        numRows+=2 ;
        StringBuilder row=new StringBuilder();
        for(int j=0 ; j<rowLen ; j++){
          row.append(c);
        }
        row.append("\n");
        layer.insert(0,row);
        layer.append(row);
        black=! black ;
      }
      StringBuilder layer2=new StringBuilder();
      for(int i=0 ; i<layer.length(); i++){
        if(layer.charAt(i)=='b'){
          layer2.append('w');
        }
        else if(layer.charAt(i)=='w'){
          layer2.append('b');
        }
        else {
          layer2.append(layer.charAt(i));
        }
      }
      for(int i=0 ; i<n ; i++){
        if(i % 2==0){
          pw.println(layer);
        }
        else {
          pw.println(layer2);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(br, pw) ; 
    skip ; 
 );
  static class Task {
   operation solve( br : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     if (n mod 2 = 1) then (     skip ; 
     return ) else skip ; 
    var rowLen : int ; rowLen := 2 ;
    var layer : String ; layer := StringLib.newString("bb\n" + "bb\n") ;
    var numRows : int ; numRows := 2 ;
    var black : boolean ; black := false ;
    var end : int ; end := (n - 2) / 2 ;
        var i : int ; i := 0 ; while i < end do ( (     var c : String ; c := if black then 'b' else 'w' endif ;
     var start : int ; start := 0 ;
        var j : int ; j := 0 ; while j < numRows do ( (     layer := layer.insertAt(start+1, StringLib.newString(c)) ; 
     start := start+(rowLen + 1) ; 
     layer := layer.insertAt(start+1, StringLib.newString(c)) ; 
     start := start+(2) )  ;     j := j + 1 ) ; 
    rowLen := rowLen+(2) ; 
    numRows := numRows+(2) ; 
    var row : String ; row := StringLib.newString() ;
        var j : int ; j := 0 ; while j < rowLen do ( (     row := row + StringLib.newString(c) )  ;     j := j + 1 ) ; 
    row := row + StringLib.newString("\n") ; 
    layer := layer.insertAt(0+1, StringLib.newString(row)) ; 
    layer := layer + StringLib.newString(row) ; 
    black := not(black) ; 
 )  ;     i := i + 1 ) ; 
    var layer2 : String ; layer2 := StringLib.newString() ;
        var i : int ; i := 0 ; while i < layer->size() do ( (     if (layer->at(i+1) = 'b') then (     layer2 := layer2 + StringLib.newString('w') ) else     if (layer->at(i+1) = 'w') then (     layer2 := layer2 + StringLib.newString('b') ) else (     layer2 := layer2 + StringLib.newString(layer->at(i+1)) ) ;  )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then (     skip ) else (     skip ) )  ;     i := i + 1 ) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int n ;
  public static int q ;
  public static int[] p ;
  public static int[] rank ;
  public static boolean same(int x,int y){
    return findSet(x)==findSet(y);
  }
  public static void unite(int x,int y){
    int i=findSet(x);
    int j=findSet(y);
    if(i==j){
      return ;
    }
    if(rank[i]>rank[j]){
      p[j]=p[i];
    }
    else {
      p[i]=p[j];
      if(rank[i]==rank[j]){
        rank[j]++;
      }
    }
  }
  public static int findSet(int i){
    if(p[i]==i){
      return i ;
    }
    else {
      return p[i]=findSet(p[i]);
    }
  }
  public static void DisjointSet(){
    p=new int[n];
    rank=new int[n];
    for(int i=0 ; i<n ; i++){
      p[i]=i ;
      rank[i]=0 ;
    }
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    n=scanner.nextInt();
    q=scanner.nextInt();
    DisjointSet();
    for(int i=0 ; i<q ; i++){
      int com=scanner.nextInt();
      int x=scanner.nextInt();
      int y=scanner.nextInt();
      if(com==0){
        unite(x,y);
      }
      if(com==1){
        if(same(x,y)){
          System.out.println(1);
        }
        else {
          System.out.println(0);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute q : int;
  static   attribute p : Sequence(int);
  static   attribute rank : Sequence(int);
  static   operation same( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return findSet(x) = findSet(y) );
  static   operation unite( x : int, y : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := findSet(x) ;
     var j : int ; j := findSet(y) ;
     if (i = j) then (     return ) else skip ; 
     if (rank[i+1] > rank[j+1]) then (     p[j+1] := p[i+1] ) else (     p[i+1] := p[j+1] ; 
     if (rank[i+1] = rank[j+1]) then (     rank[j+1] := rank[j+1] + 1 ) else skip ) );
  static   operation findSet( i : int) : int
  pre: true
  post: true
  activity: (     if (p[i+1] = i) then (     return i ) else (     return p[i+1] ) );
  static   operation DisjointSet() : void
  pre: true
  post: true
  activity: (     p := Integer.subrange(1,n)->collect(0) ; 
     rank := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do ( (     p[i+1] := i ; 
     rank[i+1] := 0 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := scanner.getCurrent()->toInteger() ; 
    q := scanner.getCurrent()->toInteger() ; 
    execute DisjointSet() ; 
        var i : int ; i := 0 ; while i < q do ( (     var com : int ; com := scanner.getCurrent()->toInteger() ;
     var x : int ; x := scanner.getCurrent()->toInteger() ;
    var y : int ; y := scanner.getCurrent()->toInteger() ;
    if (com = 0) then (     execute unite(x, y) ) else skip ; 
    if (com = 1) then (     if (same(x, y)) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(0) ) ) else skip ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    Integer n=sc.nextInt();
    Integer q=sc.nextInt();
    UnionFind uni=new UnionFind(n);
    while(q-->0){
      Integer com,x,y ;
      com=sc.nextInt();
      x=sc.nextInt();
      y=sc.nextInt();
      if(com==0){
        uni.merge(x,y);
      }
      else {
        if(uni.same(x,y)){
          System.out.println(1);
        }
        else {
          System.out.println(0);
        }
      }
    }
  }
  public class UnionFind {
    int[] unions ;
    UnionFind(Integer size){
      this.unions=new int[size];
      for(Integer i=0 ; i<size ; i++){
        this.unions[i]=i ;
      }
    }
    int find(int v){
      if(unions[v]==v){
        return v ;
      }
      else {
        int ret=find(this.unions[v]);
        this.unions[v]=ret ;
        return ret ;
      }
    }
    void merge(int v1,int v2){
      int v1Root=find(v1);
      int v2Root=find(v2);
      this.unions[v1Root]=v2Root ;
    }
    Boolean same(int v1,int v2){
      return find(v1)==(find(v2));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var uni : UnionFind ; uni := UnionFind.newUnionFind(n) ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     var com : int ;
    var x : int ;
    var y : int ;
     com := sc.getCurrent()->toInteger() ; 
    x := sc.getCurrent()->toInteger() ; 
    y := sc.getCurrent()->toInteger() ; 
    if (com = 0) then (     uni.merge(x, y) ) else (     if (uni.same(x, y)) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(0) ) ) ;  
 ) ;  ) ;  
 );
 class UnionFind {
   attribute unions : Sequence(int);
   static operation newUnionFind( size : int) : UnionFind
  pre: true
  post: true
  activity:
  ( var self : UnionFind ;
    self := createUnionFind();
    self.initialise(size);
    return self );
  operation initialise( size : int) : void
  pre: true  post: true
  activity: (     self.unions := Integer.subrange(1,size)->collect(0) ; 
         var i : int ; i := 0 ; while i < size do ( (     self.unions[i+1] := i )  ;     i := i + 1 ) );
   operation find( v : int) : int
  pre: true
  post: true
  activity: (     if (unions[v+1] = v) then (     return v ) else (     var ret : int ; ret := find(self.unions[v+1]) ;
     self.unions[v+1] := ret ; 
     return ret ) );
   operation merge( v1 : int, v2 : int) : void
  pre: true
  post: true
  activity: (     var v1Root : int ; v1Root := find(v1) ;
     var v2Root : int ; v2Root := find(v2) ;
     self.unions[v1Root+1] := v2Root );
   operation same( v1 : int, v2 : int) : Boolean
  pre: true
  post: true
  activity: (     return find(v1) = (find(v2)) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  int[] a ;
  private void unite(int x,int y){
    if(a[y]!=y)unite(x,a[y]);
    else a[y]=x ;
  }
  private int getRepresentation(int x){
    if(a[x]==x)return(x);
    a[x]=getRepresentation(a[x]);
    return(a[x]);
  }
  private boolean same(int x,int y){
    return(getRepresentation(x)==getRepresentation(y));
  }
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,q ;
    int i ;
    n=sc.nextInt();
    q=sc.nextInt();
    a=new int[n];
    for(i=0 ; i<n ; ++i)a[i]=i ;
    for(i=0 ; i<q ; ++i){
      int c,x,y ;
      c=sc.nextInt();
      x=sc.nextInt();
      y=sc.nextInt();
      if(c==0){
        if(! same(x,y))unite(x,y);
      }
      else System.out.println(same(x,y)? "1" : "0");
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   attribute a : Sequence(int);
   operation unite( x : int, y : int) : void
  pre: true
  post: true
  activity: (     if (a[y+1] /= y) then     execute unite(x, a[y+1]) ; else     a[y+1] := x ; );
   operation getRepresentation( x : int) : int
  pre: true
  post: true
  activity: (     if (a[x+1] = x) then     return (x) else skip ; 
     a[x+1] := getRepresentation(a[x+1]) ; 
     return (a[x+1]) );
   operation same( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return (getRepresentation(x) = getRepresentation(y)) );
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var q : int ;
    var i : int ;
    n := sc.nextInt() ; 
    q := sc.nextInt() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
        i := 0 ; while i < n do (     a[i+1] := i ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < q do ( (     var c : int ;
    var x : int ;
    var y : int ;
     c := sc.nextInt() ; 
    x := sc.nextInt() ; 
    y := sc.nextInt() ; 
    if (c = 0) then (     if (not(same(x, y))) then     execute unite(x, y) ; else skip ) else     OclFile["System.out"].println(if same(x, y) then "1" else "0" endif) ; ;  
 )  ;     i := i + 1 ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static List<Set<Integer>>setList=new ArrayList<Set<Integer>>();
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int num=s.nextInt();
    int query=s.nextInt();
    for(int i=0 ; i<query ; i++){
      boolean result=false ;
      switch(s.nextInt()){
        case 0 : result=unite(s.nextInt(),s.nextInt());
        break ;
        case 1 : result=same(s.nextInt(),s.nextInt());
        System.out.println(result ? 1 : 0);
        break ;
      }
    }
  }
  private static boolean unite(int x,int y){
    Set<Integer>xSet=null ;
    Set<Integer>ySet=null ;
    for(Set<Integer>tmpSet : setList){
      if(tmpSet.contains(x)){
        xSet=tmpSet ;
        if(ySet!=null){
          break ;
        }
      }
      if(tmpSet.contains(y)){
        ySet=tmpSet ;
        if(xSet!=null){
          break ;
        }
      }
    }
    if(xSet==null && ySet==null){
      Set<Integer>tmpHashSet=new HashSet<Integer>();
      tmpHashSet.add(x);
      tmpHashSet.add(y);
      setList.add(tmpHashSet);
      return true ;
    }
    if(xSet==null){
      ySet.add(x);
      return false ;
    }
    if(ySet==null){
      xSet.add(y);
      return false ;
    }
    if(xSet.equals(ySet))return false ;
    xSet.addAll(ySet);
    setList.remove(ySet);
    return true ;
  }
  private static boolean same(int x,int y){
    for(Set<Integer>tmpSet : setList){
      if(tmpSet.contains(x)){
        if(tmpSet.contains(y)){
          return true ;
        }
        else {
          return false ;
        }
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute setList : Sequence(Set(int)) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := s.getCurrent()->toInteger() ;
     var query : int ; query := s.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < query do ( (     var result : boolean ; result := false ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (s.getCurrent()->toInteger()) ; 
       if _switchval = 0 then
     result := unite(s.getCurrent()->toInteger(), s.getCurrent()->toInteger()) ; 
    break 
   else skip ;
       if _switchval = 1 then
     result := same(s.getCurrent()->toInteger(), s.getCurrent()->toInteger()) ; 
    OclFile["System.out"].println(if result then 1 else 0 endif) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) );
  static   operation unite( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     var xSet : Set(int) ; xSet := null ;
     var ySet : Set(int) ; ySet := null ;
    for (tmpSet : setList) do ( (     if (tmpSet->includes(x)) then (     xSet := tmpSet ; 
     if (ySet /= null) then (     break ) else skip ) else skip ; 
     if (tmpSet->includes(y)) then (     ySet := tmpSet ; 
     if (xSet /= null) then (     break ) else skip ) else skip )  ) ; 
    if (xSet = null & ySet = null) then (     var tmpHashSet : Set(int) ; tmpHashSet := Set{} ;
     tmpHashSet := tmpHashSet->including(x) ; 
    tmpHashSet := tmpHashSet->including(y) ; 
    setList := setList->including(tmpHashSet) ; 
    return true 
 ) else skip ; 
    if (xSet = null) then (     ySet := ySet->including(x) ; 
     return false ) else skip ; 
    if (ySet = null) then (     xSet := xSet->including(y) ; 
     return false ) else skip ; 
    if (xSet = ySet) then     return false else skip ; 
    xSet := xSet->union(ySet) ; 
    setList := setList->excludingFirst(ySet) ; 
    return true 
 );
  static   operation same( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     for (tmpSet : setList) do ( (     if (tmpSet->includes(x)) then (     if (tmpSet->includes(y)) then (     return true ) else (     return false ) ) else skip )  ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Stack ;
public class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String line ;
      while((line=br.readLine())!=null){
        if(line.isEmpty())break ;
        String spl[]=line.split(" ");
        int n=Integer.parseInt(spl[0]),q=Integer.parseInt(spl[1]);
        int[] parent=new int[n];
        for(int i=0 ; i<n ; i++)parent[i]=i ;
        for(int i=0 ; i<q ; i++){
          line=br.readLine();
          spl=line.split(" ");
          int[] ns=new int[3];
          for(int j=0 ; j<3 ; j++)ns[j]=Integer.parseInt(spl[j]);
          if(ns[0]==0){
            if(parent[ns[1] ]!=parent[ns[2] ]){
              int tmp=parent[ns[1] ];
              for(int k=0 ; k<n ; k++){
                if(parent[k]==tmp)parent[k]=parent[ns[2] ];
              }
            }
          }
          else {
            if(parent[ns[1] ]==parent[ns[2] ])System.out.println("1");
            else System.out.println("0");
          }
        }
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->isEmpty()) then     break else skip ; 
     var spl : Sequence(String) ; spl := line->split(" ") ;
    var n : int ; n := (spl[0+1])->toInteger() ;
    var q : int ; q := (spl[1+1])->toInteger() ;
    var parent : Sequence(int) ; parent := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     parent[i+1] := i ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     line := br.readLine() ; 
     spl := line->split(" ") ; 
    var ns : Sequence(int) ; ns := Integer.subrange(1,3)->collect(0) ;
        var j : int ; j := 0 ; while j < 3 do (     ns[j+1] := (spl[j+1])->toInteger() ;  ;     j := j + 1 ) ; 
    if (ns[0+1] = 0) then (     if (parent[ns[1+1]+1] /= parent[ns[2+1]+1]) then (     var tmp : int ; tmp := parent[ns[1+1]+1] ;
         var k : int ; k := 0 ; while k < n do ( (     if (parent[k+1] = tmp) then     parent[k+1] := parent[ns[2+1]+1] ; else skip )  ;     k := k + 1 ) ) else skip ) else (     if (parent[ns[1+1]+1] = parent[ns[2+1]+1]) then     OclFile["System.out"].println("1") ; else     OclFile["System.out"].println("0") ; ) ;  
 )  ;     i := i + 1 ) ; 
 ) ;     line := br.readLine() ;
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class pre5 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    char str[]=obj.next().toCharArray();
    int ans=0,n=str.length ;
    for(int i=0 ; i<n ; i++){
      int count=0 ;
      str[i]=(str[i]=='V')? 'K' : 'V' ;
      for(int j=0 ; j<n-1 ; j++){
        if(str[j]=='V' && str[j+1]=='K')count++;
      }
      str[i]=(str[i]=='V')? 'K' : 'V' ;
      ans=max(ans,count);
      count=0 ;
      for(int j=0 ; j<n-1 ; j++)if(str[j]=='V' && str[j+1]=='K')count++;
      ans=max(ans,count);
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre5 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var str : Sequence(String) ; str := obj.next()->characters() ;
    var ans : int ; ans := 0 ;
    var n : int ; n := str->size() ;
        var i : int ; i := 0 ; while i < n do ( (     var count : int ; count := 0 ;
     str[i+1] := if (str[i+1] = 'V') then 'K' else 'V' endif ; 
        var j : int ; j := 0 ; while j < (n)->char2byte() - 1 do ( (     if (str[j+1] = 'V' & str[j + 1+1] = 'K') then     count := count + 1 ; else skip )  ;     j := j + 1 ) ; 
    str[i+1] := if (str[i+1] = 'V') then 'K' else 'V' endif ; 
    ans := Set{ans, count}->max() ; 
    count := 0 ; 
        var j : int ; j := 0 ; while j < (n)->char2byte() - 1 do (     if (str[j+1] = 'V' & str[j + 1+1] = 'K') then     count := count + 1 ; else skip ;  ;     j := j + 1 ) ; 
    ans := Set{ans, count}->max() ; 
 )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class Bulbs {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    boolean[] on=new boolean[m];
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      for(int j=0 ; j<x ; j++){
        int temp=sc.nextInt();
        on[temp-1]=true ;
      }
    }
    int c=0 ;
    for(int i=0 ; i<on.length ; i++){
      if(on[i]==true){
        c++;
      }
    }
    if(c==on.length){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Bulbs {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var on : Sequence(boolean) ; on := Integer.subrange(1,m)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < x do ( (     var temp : int ; temp := sc.getCurrent()->toInteger() ;
     on[temp - 1+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < on->size() do ( (     if (on[i+1] = true) then (     c := c + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (c = on->size()) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class VK {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int n=s.length();
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      StringBuilder sb=new StringBuilder(s);
      if(s.charAt(i)=='V')sb.setCharAt(i,'K');
      else sb.setCharAt(i,'V');
      ans=Math.max(ans,cnt(sb.toString()));
    }
    System.out.println(Math.max(ans,cnt(s)));
  }
  private static int cnt(String s){
    int i=0 ;
    int ans=0 ;
    while(i<s.length()-1){
      if(s.substring(i,i+2).equals("VK")){
        ans++;
        i+=2 ;
      }
      else {
        i++;
      }
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class VK {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var n : int ; n := s->size() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var sb : String ; sb := StringLib.newString(s) ;
     if (s->at(i+1) = 'V') then     sb := sb.setAt(i+1, 'K') else     sb := sb.setAt(i+1, 'V') ; ;  
     ans := Set{ans, cnt(sb+"")}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{ans, cnt(s)}->max()) ; 
 );
  static   operation cnt( s : String) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var ans : int ; ans := 0 ;
     while (i < s->size() - 1) do (     if (s.subrange(i+1,i + 2) = "VK") then (     ans := ans + 1 ; 
     i := i+(2) ) else (     i := i + 1 ) ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter out=new PrintWriter(System.out);
  static StringTokenizer st=new StringTokenizer("");
  public static void main(String[] args)throws IOException {
    solve();
    br.close();
    out.close();
  }
  public static String next()throws IOException {
    while(! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public static int nexti()throws IOException {
    return Integer.parseInt(next());
  }
  public static void solve()throws IOException {
    char[] c=next().toCharArray();
    if(c.length==1){
      out.println(0);
      return ;
    }
    int ans=0 ;
    for(int i=0 ; i<c.length-1 ; i++)if(c[i]=='V' && c[i+1]=='K')++ans ;
    for(int i=0 ; i<c.length ; i++){
      c[i]=c[i]=='V' ? 'K' : 'V' ;
      int res=0 ;
      for(int j=0 ; j<c.length-1 ; j++)if(c[j]=='V' && c[j+1]=='K')++res ;
      if(res>ans)ans=res ;
      c[i]=c[i]=='V' ? 'K' : 'V' ;
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute st : OclIterator := OclIterator.newOclIterator_String("");
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() ; 
     skip ; 
     skip );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
  static   operation nexti() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var c : Sequence(String) ; c := next()->characters() ;
     if (c->size() = 1) then (     skip ; 
     return ) else skip ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < c->size() - 1 do (     if (c[i+1] = 'V' & c[i + 1+1] = 'K') then     ans := ans + 1 ; else skip ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < c->size() do ( (     c[i+1] := if c[i+1] = 'V' then 'K' else 'V' endif ; 
     var res : int ; res := 0 ;
        var j : int ; j := 0 ; while j < c->size() - 1 do (     if (c[j+1] = 'V' & c[j + 1+1] = 'K') then     res := res + 1 ; else skip ;  ;     j := j + 1 ) ; 
    if (res > ans) then     ans := res ; else skip ; 
    c[i+1] := if c[i+1] = 'V' then 'K' else 'V' endif ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int waysToSplit(String s){
    int n=s.length();
    int answer=0 ;
    int prefix[]=new int[n];
    int suffix[]=new int[n];
    int seen[]=new int[26];
    for(int i=0 ; i<n ; i++){
      int prev=(i-1>=0 ? prefix[i-1] : 0);
      if(seen[s.charAt(i)-'a']==0){
        prefix[i]+=(prev+1);
      }
      else prefix[i]=prev ;
      seen[s.charAt(i)-'a']=1 ;
    }
    for(int i=0 ; i<26 ; i++)seen[i]=0 ;
    suffix[n-1]=0 ;
    for(int i=n-1 ; i>=1 ; i--){
      int prev=suffix[i];
      if(seen[s.charAt(i)-'a']==0){
        suffix[i-1]+=(prev+1);
      }
      else suffix[i-1]=prev ;
      seen[s.charAt(i)-'a']=1 ;
    }
    for(int i=0 ; i<n ; i++){
      if(prefix[i]==suffix[i])answer++;
    }
    return answer ;
  }
  public static void main(String[] args){
    String s="ababa" ;
    System.out.println(waysToSplit(s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation waysToSplit( s : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var answer : int ; answer := 0 ;
    var prefix : Sequence(int) ; prefix := Integer.subrange(1,n)->collect(0) ;
    var suffix : Sequence(int) ; suffix := Integer.subrange(1,n)->collect(0) ;
    var seen : Sequence(int) ; seen := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var prev : int ; prev := (if i - 1 >= 0 then prefix[i - 1+1] else 0 endif) ;
     if (seen[s->at(i+1) - ('a')->char2byte()+1] = 0) then (     prefix[i+1] := prefix[i+1]+((prev + 1)) ) else     prefix[i+1] := prev ; ;  
     seen[s->at(i+1) - ('a')->char2byte()+1] := 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 26 do (     seen[i+1] := 0 ;  ;     i := i + 1 ) ; 
    suffix[n - 1+1] := 0 ; 
        var i : int ; i := n - 1 ; while i >= 1 do ( (     var prev : int ; prev := suffix[i+1] ;
     if (seen[s->at(i+1) - ('a')->char2byte()+1] = 0) then (     suffix[i - 1+1] := suffix[i - 1+1]+((prev + 1)) ) else     suffix[i - 1+1] := prev ; ;  
     seen[s->at(i+1) - ('a')->char2byte()+1] := 1 )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (prefix[i+1] = suffix[i+1]) then     answer := answer + 1 ; else skip )  ;     i := i + 1 ) ; 
    return answer 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "ababa" ;
     OclFile["System.out"].println(waysToSplit(s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class FibZero {
  static int findMinZero(int p){
    int first=1,second=1,number=2,next=1 ;
    while(next>0){
      next=(first+second)% p ;
      first=second ;
      second=next ;
      number++;
    }
    return number ;
  }
  public static void main(String[] args){
    int p=7 ;
    System.out.println("Minimal zero is "+findMinZero(p));
  }
}
------------------------------------------------------------
OCL File:
---------
 class FibZero {
  static   operation findMinZero( p : int) : int
  pre: true
  post: true
  activity: (     var first : int ; first := 1 ;
    var second : int ; second := 1 ;
    var number : int ; number := 2 ;
    var next : int ; next := 1 ;
     while (next > 0) do (     next := (first + second) mod p ; 
     first := second ; 
     second := next ; 
     number := number + 1 ) ; 
     return number );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : int ; p := 7 ;
     OclFile["System.out"].println("Minimal zero is " + findMinZero(p)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int INFINITY_=9999999 ;
  static int sqrtByLongDivision(int n){
    int i=0,udigit,j ;
    int cur_divisor=0 ;
    int quotient_units_digit=0 ;
    int cur_quotient=0 ;
    int cur_dividend=0 ;
    int cur_remainder=0 ;
    int a[]=new int[10];
    while(n>0){
      a[i]=n % 100 ;
      n=n/100 ;
      i++;
    }
    i--;
    for(j=i ; j>=0 ; j--){
      cur_remainder=INFINITY_ ;
      cur_dividend=cur_dividend*100+a[j];
      for(udigit=0 ; udigit<=9 ; udigit++){
        if(cur_remainder>=cur_dividend-((cur_divisor*10+udigit)*udigit)&& cur_dividend-((cur_divisor*10+udigit)*udigit)>=0){
          cur_remainder=cur_dividend-((cur_divisor*10+udigit)*udigit);
          quotient_units_digit=udigit ;
        }
      }
      cur_quotient=cur_quotient*10+quotient_units_digit ;
      cur_divisor=cur_quotient*2 ;
      cur_dividend=cur_remainder ;
    }
    return cur_quotient ;
  }
  public static void main(String[] args){
    int x=1225 ;
    System.out.print(sqrtByLongDivision(x)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute INFINITY_ : int := 9999999;
  static   operation sqrtByLongDivision( n : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var udigit : int ;
    var j : int ;
     var cur_divisor : int ; cur_divisor := 0 ;
    var quotient_units_digit : int ; quotient_units_digit := 0 ;
    var cur_quotient : int ; cur_quotient := 0 ;
    var cur_dividend : int ; cur_dividend := 0 ;
    var cur_remainder : int ; cur_remainder := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,10)->collect(0) ;
    while (n > 0) do (     a[i+1] := n mod 100 ; 
     n := n / 100 ; 
     i := i + 1 ) ; 
    i := i - 1 ; 
        j := i ; while j >= 0 do ( (     cur_remainder := INFINITY_ ; 
     cur_dividend := cur_dividend * 100 + a[j+1] ; 
        udigit := 0 ; while udigit <= 9 do ( (     if (cur_remainder >= cur_dividend - ((cur_divisor * 10 + udigit) * udigit) & cur_dividend - ((cur_divisor * 10 + udigit) * udigit) >= 0) then (     cur_remainder := cur_dividend - ((cur_divisor * 10 + udigit) * udigit) ; 
     quotient_units_digit := udigit ) else skip )  ;     udigit := udigit + 1 ) ; 
    cur_quotient := cur_quotient * 10 + quotient_units_digit ; 
    cur_divisor := cur_quotient * 2 ; 
    cur_dividend := cur_remainder ; 
 )  ;     j := j - 1 ) ; 
    return cur_quotient 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 1225 ;
     OclFile["System.out"].print(sqrtByLongDivision(x) + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean check(String s){
    for(int i=0 ; i+1<s.length(); ++i){
      if(Math.abs(s.charAt(i)-s.charAt(i+1))==1){
        return false ;
      }
    }
    return true ;
  }
  static void Rearrange(String str){
    String odd="",even="" ;
    for(int i=0 ; i<str.length(); ++i){
      if(str.charAt(i)% 2==0){
        even+=str.charAt(i);
      }
      else {
        odd+=str.charAt(i);
      }
    }
    odd=sort(odd);
    even=sort(even);
    if(check(odd+even)){
      System.out.print(odd+even);
    }
    else if(check(even+odd)){
      System.out.print(even+odd);
    }
    else {
      System.out.print(-1);
    }
  }
  public static String sort(String inputString){
    char tempArray[]=inputString.toCharArray();
    Arrays.sort(tempArray);
    return new String(tempArray);
  }
  public static void main(String[] args){
    String str="aabcd" ;
    Rearrange(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( s : String) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i + 1 < s->size() do ( (     if (if s->at(i+1) - s->at(i + 1+1) < 0 then -(s->at(i+1) - s->at(i + 1+1)) else s->at(i+1) - s->at(i + 1+1) endif = 1) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation Rearrange( str : String) : void
  pre: true
  post: true
  activity: (     var odd : String ; odd := "" ;
    var even : String ; even := "" ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) mod 2 = 0) then (     even := even+(str->at(i+1)) ) else (     odd := odd+(str->at(i+1)) ) )  ;     i := i + 1 ) ; 
    odd := sort(odd) ; 
    even := sort(even) ; 
    if (check(odd + even)) then (     OclFile["System.out"].print(odd + even) ) else     if (check(even + odd)) then (     OclFile["System.out"].print(even + odd) ) else (     OclFile["System.out"].print(-1) ) ;  ;  
 );
  static   operation sort( inputString : String) : String
  pre: true
  post: true
  activity: (     var tempArray : Sequence(String) ; tempArray := inputString->characters() ;
     tempArray := tempArray->sort() ; 
     return StringLib.newString(tempArray) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "aabcd" ;
     execute Rearrange(str) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    while(k-->0){
      int n=sc.nextInt();
      int[] lst1=new int[n];
      int[] lst2=new int[n];
      for(int i=0 ; i<n ; i++)lst1[i]=sc.nextInt();
      for(int i=0 ; i<n ; i++)lst2[i]=sc.nextInt();
      int value=0 ;
      int time=0 ;
      boolean isAllowToPrintYes=true ;
      for(int i=0 ; i<n ; i++){
        if(lst1[i]-lst2[i]>0){
          System.out.println("NO");
          isAllowToPrintYes=false ;
          break ;
        }
        if(lst1[i]-lst2[i]!=value){
          value=lst1[i]-lst2[i];
          if(value!=0)time++;
        }
      }
      if(isAllowToPrintYes){
        System.out.println(time<2 ? "YES" : "NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
         while (k > 0) do (        k := k - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var lst1 : Sequence(int) ; lst1 := Integer.subrange(1,n)->collect(0) ;
    var lst2 : Sequence(int) ; lst2 := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     lst1[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     lst2[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var value : int ; value := 0 ;
    var time : int ; time := 0 ;
    var isAllowToPrintYes : boolean ; isAllowToPrintYes := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (lst1[i+1] - lst2[i+1] > 0) then (     OclFile["System.out"].println("NO") ; 
     isAllowToPrintYes := false ; 
     break ) else skip ; 
     if (lst1[i+1] - lst2[i+1] /= value) then (     value := lst1[i+1] - lst2[i+1] ; 
     if (value /= 0) then     time := time + 1 ; else skip ) else skip )  ;     i := i + 1 ) ; 
    if (isAllowToPrintYes) then (     OclFile["System.out"].println(if time < 2 then "YES" else "NO" endif) ) else skip ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static void palindrome(int arr[],int n){
    int flag=0 ;
    for(int i=0 ; i<=n/2 && n!=0 ; i++){
      if(arr[i]!=arr[n-i-1]){
        flag=1 ;
        break ;
      }
    }
    if(flag==1)System.out.println("Not Palindrome");
    else System.out.println("Palindrome");
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,2,1 };
      int n=arr.length ;
      palindrome(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation palindrome( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var flag : int ; flag := 0 ;
         var i : int ; i := 0 ; while i <= n / 2 & n /= 0 do ( (     if (arr[i+1] /= arr[n - i - 1+1]) then (     flag := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (flag = 1) then     OclFile["System.out"].println("Not Palindrome") ; else     OclFile["System.out"].println("Palindrome") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,2,1} ;
     var n : int ; n := arr->size() ;
     execute palindrome(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int search(int arr[],int l,int h,int key){
    if(l>h)return-1 ;
    int mid=(l+h)/2 ;
    if(arr[mid]==key)return mid ;
    if((arr[l]==arr[mid])&&(arr[h]==arr[mid])){
++l ;
--h ;
    }
    if(arr[l]<=arr[mid]){
      if(key>=arr[l] && key<=arr[mid])return search(arr,l,mid-1,key);
      return search(arr,mid+1,h,key);
    }
    if(key>=arr[mid] && key<=arr[h])return search(arr,mid+1,h,key);
    return search(arr,l,mid-1,key);
  }
  public static void main(String[] args){
    int arr[]={
      3,3,1,2,3,3 };
      int n=arr.length ;
      int key=3 ;
      System.out.println(search(arr,0,n-1,key));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation search( arr : Sequence(int), l : int, h : int, key : int) : int
  pre: true
  post: true
  activity: (     if (l > h) then     return -1 else skip ; 
     var mid : int ; mid := (l + h) / 2 ;
    if (arr[mid+1] = key) then     return mid else skip ; 
    if ((arr[l+1] = arr[mid+1]) & (arr[h+1] = arr[mid+1])) then (     l := l + 1 ; 
     h := h - 1 ) else skip ; 
    if (arr[l+1] <= arr[mid+1]) then (     if (key >= arr[l+1] & key <= arr[mid+1]) then     return search(arr, l, mid - 1, key) else skip ; 
     return search(arr, mid + 1, h, key) ) else skip ; 
    if (key >= arr[mid+1] & key <= arr[h+1]) then     return search(arr, mid + 1, h, key) else skip ; 
    return search(arr, l, mid - 1, key) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,3,1,2,3,3} ;
     var n : int ; n := arr->size() ;
     var key : int ; key := 3 ;
     OclFile["System.out"].println(search(arr, 0, n - 1, key)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if(n==0 && m==0)break ;
      String[] op=new String[n];
      String[] from=new String[n];
      String[] to=new String[n];
      for(int i=0 ; i<n ; i++){
        op[i]=sc.next();
        from[i]=sc.next().replaceAll("\\?",".");
        to[i]=sc.next().replaceAll("\\?",".");
      }
      ArrayList<String>fromList=new ArrayList<String>();
      ArrayList<String>toList=new ArrayList<String>();
      ArrayList<String>mesList=new ArrayList<String>();
      for(int i=0 ; i<m ; i++){
        String f=sc.next();
        String t=sc.next();
        String mes=sc.next();
        for(int j=n-1 ; j>=0 ; j--){
          if(f.matches(from[j])&& t.matches(to[j])){
            if(op[j] .equals("permit")){
              fromList.add(f);
              toList.add(t);
              mesList.add(mes);
            }
            break ;
          }
        }
      }
      int size=fromList.size();
      System.out.println(size);
      for(int i=0 ; i<size ; i++){
        System.out.println(fromList.get(i)+" "+toList.get(i)+" "+mesList.get(i));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if (n = 0 & m = 0) then     break else skip ; 
    var op : Sequence(String) ; op := Integer.subrange(1,n)->collect(null) ;
    var from : Sequence(String) ; from := Integer.subrange(1,n)->collect(null) ;
    var to : Sequence(String) ; to := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     op[i+1] := sc.getCurrent() ; 
     from[i+1] := sc.getCurrent().replaceAllMatches("\\?", "." ) ; 
     to[i+1] := sc.getCurrent().replaceAllMatches("\\?", "." ) )  ;     i := i + 1 ) ; 
    var fromList : Sequence(String) ; fromList := Sequence{} ;
    var toList : Sequence(String) ; toList := Sequence{} ;
    var mesList : Sequence(String) ; mesList := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     var f : String ; f := sc.getCurrent() ;
     var t : String ; t := sc.getCurrent() ;
     var mes : String ; mes := sc.getCurrent() ;
         var j : int ; j := n - 1 ; while j >= 0 do ( (     if (f->isMatch(from[j+1]) & t->isMatch(to[j+1])) then (     if (op[j+1] = "permit") then (     fromList := fromList->including(f) ; 
     toList := toList->including(t) ; 
     mesList := mesList->including(mes) ) else skip ; 
     break ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    var size : int ; size := fromList->size() ;
    OclFile["System.out"].println(size) ; 
        var i : int ; i := 0 ; while i < size do ( (     OclFile["System.out"].println(fromList->at(i+1) + " " + toList->at(i+1) + " " + mesList->at(i+1)) )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF251A {
  public static Scanner scanner ;
  public static int[] arr ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int d=scanner.nextInt();
    arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(scanner.next());
    }
    long res=0 ;
    for(int i=0 ; i<n ; i++){
      int nextIndex=nextIndex(i,d);
      if(nextIndex==n)nextIndex--;
      long combination=(long)(nextIndex-i)*(nextIndex-i-1)/2 ;
      res+=combination ;
    }
    System.out.println(res);
  }
  public static int nextIndex(int from,int distance){
    int fromElement=arr[from];
    int target=fromElement+distance ;
    int lo=from,hi=arr.length-1 ;
    int lowerKeyIndex=lo ;
    while(lo<=hi){
      int mid=lo+(hi-lo)/2 ;
      if(arr[mid]>target)hi=mid-1 ;
      else if(arr[mid]<target){
        lowerKeyIndex=mid ;
        lo=mid+1 ;
      }
      else return mid ;
    }
    return lo<arr.length && arr[lo]<=target ? lo : lowerKeyIndex ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF251A {
  static   attribute scanner : OclFile;
  static   attribute arr : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var d : int ; d := scanner.getCurrent()->toInteger() ;
    arr := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (scanner.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var nextIndex : int ; nextIndex := nextIndex(i, d) ;
     if (nextIndex = n) then     nextIndex := nextIndex - 1 ; else skip ; 
     var combination : long ; combination := (nextIndex - i)->oclAsType(long) * (nextIndex - i - 1) / 2 ;
     res := res+(combination) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static   operation nextIndex( from : int, distance : int) : int
  pre: true
  post: true
  activity: (     var fromElement : int ; fromElement := arr[from+1] ;
     var target : int ; target := fromElement + distance ;
    var lo : int ; lo := from ;
    var hi : int ; hi := arr->size() - 1 ;
    var lowerKeyIndex : int ; lowerKeyIndex := lo ;
    while (lo <= hi) do (     var mid : int ; mid := lo + (hi - lo) / 2 ;
     if (arr[mid+1] > target) then     hi := mid - 1 ; else     if (arr[mid+1] < target) then (     lowerKeyIndex := mid ; 
     lo := mid + 1 ) else     return mid ;  ) ; 
    return if lo < arr->size() & arr[lo+1] <= target then lo else lowerKeyIndex endif 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      final int n=sc.nextInt();
      final int m=sc.nextInt();
      if(n==0 && m==0){
        break ;
      }
      boolean[] is_legal=new boolean[n];
      String[] source_pattern=new String[n];
      String[] destination_pattern=new String[n];
      for(int i=0 ; i<n ; i++){
        final String act=sc.next();
        final String so=sc.next();
        final String de=sc.next();
        is_legal[i]="permit".equals(act);
        source_pattern[i]=so.replaceAll("\\?",".");
        destination_pattern[i]=de.replaceAll("\\?",".");
      }
      LinkedList<String>list=new LinkedList<String>();
      for(int i=0 ; i<m ; i++){
        boolean ok=false ;
        String from=sc.next();
        String to=sc.next();
        String mes=sc.next();
        for(int j=n-1 ; j>=0 ; j--){
          if(from.matches(source_pattern[j])&& to.matches(destination_pattern[j])){
            if(is_legal[j]){
              ok=true ;
            }
            else {
              ok=false ;
            }
            break ;
          }
        }
        if(! ok){
          continue ;
        }
        list.add(from+" "+to+" "+mes);
      }
      System.out.println(list.size());
      for(String str : list){
        System.out.println(str);
      }
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if (n = 0 & m = 0) then (     break ) else skip ; 
    var is_legal : Sequence(boolean) ; is_legal := Integer.subrange(1,n)->collect(false) ;
    var source_pattern : Sequence(String) ; source_pattern := Integer.subrange(1,n)->collect(null) ;
    var destination_pattern : Sequence(String) ; destination_pattern := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var act : String ; act := sc.getCurrent() ;
     var so : String ; so := sc.getCurrent() ;
    var de : String ; de := sc.getCurrent() ;
    is_legal[i+1] := "permit" = act ; 
    source_pattern[i+1] := so.replaceAllMatches("\\?", "." ) ; 
    destination_pattern[i+1] := de.replaceAllMatches("\\?", "." ) ; 
 )  ;     i := i + 1 ) ; 
    var list : Sequence(String) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     var ok : boolean ; ok := false ;
     var from : String ; from := sc.getCurrent() ;
    var to : String ; to := sc.getCurrent() ;
    var mes : String ; mes := sc.getCurrent() ;
        var j : int ; j := n - 1 ; while j >= 0 do ( (     if (from->isMatch(source_pattern[j+1]) & to->isMatch(destination_pattern[j+1])) then (     if (is_legal[j+1]) then (     ok := true ) else (     ok := false ) ;  
     break ) else skip )  ;     j := j - 1 ) ; 
    if (not(ok)) then (     continue ) else skip ; 
    list := list->including(from + " " + to + " " + mes) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(list->size()) ; 
    for (str : list) do ( (     OclFile["System.out"].println(str) )  ) ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p121 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p121().run());
  }
  private static final int TURNS=15 ;
  public String run(){
    BigInteger[][] ways=new BigInteger[TURNS+1][];
    ways[0]=new BigInteger[] {
      BigInteger.ONE };
      for(int i=1 ; i<=TURNS ; i++){
        ways[i]=new BigInteger[i+1];
        for(int j=0 ; j<=i ; j++){
          BigInteger temp=BigInteger.ZERO ;
          if(j<i)temp=ways[i-1][j] .multiply(BigInteger.valueOf(i));
          if(j>0)temp=temp.add(ways[i-1][j-1]);
          ways[i][j]=temp ;
        }
      }
      BigInteger numer=BigInteger.ZERO ;
      for(int i=TURNS/2+1 ; i<=TURNS ; i++)numer=numer.add(ways[TURNS][i]);
      BigInteger denom=Library.factorial(TURNS+1);
      return denom.divide(numer).toString();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class p121 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p121.newp121().run()) );
  static    attribute TURNS : int := 15;
   operation run() : String
  pre: true
  post: true
  activity: (     var ways : Sequence(Sequence(long)) ; ways := Integer.subrange(1,TURNS + 1)->collect(Sequence{}) ;
     ways[0+1] := Sequence{1} ; 
        var i : int ; i := 1 ; while i <= TURNS do ( (     ways[i+1] := Integer.subrange(1,i + 1)->collect(null) ; 
         var j : int ; j := 0 ; while j <= i do ( (     var temp : long ; temp := 0 ;
     if (j < i) then     temp := ways[i - 1+1][j+1].multiply((i + "")->toLong()) ; else skip ; 
     if (j > 0) then     temp := temp->excludes(ways[i - 1+1][j - 1+1]) ; else skip ; 
     ways[i+1][j+1] := temp )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var numer : long ; numer := 0 ;
        var i : int ; i := TURNS / 2 + 1 ; while i <= TURNS do (     numer := numer->excludes(ways[TURNS+1][i+1]) ;  ;     i := i + 1 ) ; 
    var denom : long ; denom := Library.factorial(TURNS + 1) ;
    return denom.divide(numer)+"" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static boolean SumDivisible(int n,int k){
    int sum=0,position=1 ;
    while(n>0){
      if(position % 2==1)sum+=n % 10 ;
      n=n/10 ;
      position++;
    }
    if(sum % k==0)return true ;
    return false ;
  }
  public static void main(String arr[]){
    int n=592452 ;
    int k=3 ;
    if(SumDivisible(n,k))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation SumDivisible( n : int, k : int) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
    var position : int ; position := 1 ;
     while (n > 0) do (     if (position mod 2 = 1) then     sum := sum+(n mod 10) ; else skip ; 
     n := n / 10 ; 
     position := position + 1 ) ; 
     if (sum mod k = 0) then     return true else skip ; 
     return false );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 592452 ;
     var k : int ; k := 3 ;
     if (SumDivisible(n, k)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int getRemainder(int num,int divisor){
    while(num>=divisor)num-=divisor ;
    return num ;
  }
  public static void main(String[] args){
    int num=100,divisor=7 ;
    System.out.println(getRemainder(num,divisor));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getRemainder( num : int, divisor : int) : int
  pre: true
  post: true
  activity: (     while (num >= divisor) do     num := num-(divisor) ; ; 
     return num );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 100 ;
    var divisor : int ; divisor := 7 ;
     OclFile["System.out"].println(getRemainder(num, divisor)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.HashSet ;
public class FindMarble {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    String ln1[]=reader.readLine().split(" ");
    String ln2[]=reader.readLine().split(" ");
    HashMap<Integer,Integer>shuffleMap=new HashMap<>();
    int n=Integer.parseInt(ln1[0]);
    int i=1 ;
    while(i<=n){
      shuffleMap.put(i,Integer.parseInt(ln2[i-1]));
      i++;
    }
    HashSet<Integer>visited=new HashSet<>();
    int s=Integer.parseInt(ln1[1]);
    int t=Integer.parseInt(ln1[2]);
    visited.add(s);
    int steps=0 ;
    while(steps!=-1){
      if(s==t)break ;
      s=shuffleMap.get(s);
      if(visited.contains(s)){
        steps=-1 ;
      }
      else {
        visited.add(s);
        steps++;
      }
    }
    System.out.println(steps);
  }
}
------------------------------------------------------------
OCL File:
---------
 class FindMarble {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var ln1 : Sequence(String) ; ln1 := reader.readLine()->split(" ") ;
    var ln2 : Sequence(String) ; ln2 := reader.readLine()->split(" ") ;
    var shuffleMap : Map(int,int) ; shuffleMap := Map{} ;
    var n : int ; n := (ln1[0+1])->toInteger() ;
    var i : int ; i := 1 ;
    while (i <= n) do (     shuffleMap := shuffleMap->union(Map{i |-> (ln2[i - 1+1])->toInteger()}) ; 
     i := i + 1 ) ; 
    var visited : Set(int) ; visited := Set{} ;
    var s : int ; s := (ln1[1+1])->toInteger() ;
    var t : int ; t := (ln1[2+1])->toInteger() ;
    visited := visited->including(s) ; 
    var steps : int ; steps := 0 ;
    while (steps /= -1) do (     if (s = t) then     break else skip ; 
     s := shuffleMap->at(s) ; 
     if (visited->includes(s)) then (     steps := -1 ) else (     visited := visited->including(s) ; 
     steps := steps + 1 ) ) ; 
    OclFile["System.out"].println(steps) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class LC {
  static HashMap<Integer,Integer>m=new HashMap<>();
  static HashMap<Integer,Integer>vis=new HashMap<>();
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int s=sc.nextInt();
    int e=sc.nextInt();
    for(int i=1 ; i<=n ; i++){
      m.put(i,sc.nextInt());
      vis.put(i,0);
    }
    System.out.println(dfs(s,e,0));
  }
  private static int dfs(int s,int e,int i){
    if(vis.get(s)==1)return-1 ;
    if(s==e)return i ;
    vis.put(s,1);
    return dfs(m.get(s),e,i+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class LC {
  static   attribute m : Map(int,int) := Map{};
  static   attribute vis : Map(int,int) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var e : int ; e := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= n do ( (     m := m->union(Map{i |-> sc.getCurrent()->toInteger()}) ; 
     vis := vis->union(Map{i |-> 0}) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dfs(s, e, 0)) ; 
 );
  static   operation dfs( s : int, e : int, i : int) : int
  pre: true
  post: true
  activity: (     if (vis->at(s) = 1) then     return -1 else skip ; 
     if (s = e) then     return i else skip ; 
     vis := vis->union(Map{s |-> 1}) ; 
     return dfs(m->at(s), e, i + 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class FindMarble {
  private static Scanner s=new Scanner(System.in);
  private static void solve(){
    int n=s.nextInt(),initial=s.nextInt(),target=s.nextInt();
    int[] arr=new int[n+1];
    for(int i=1 ; i<=n ; i++)arr[i]=s.nextInt();
    boolean[] visited=new boolean[n+1];
    visited[initial]=true ;
    int ans=0 ;
    while(initial!=target){
      initial=arr[initial];
      if(visited[initial]){
        System.out.println(-1);
        return ;
      }
      ans++;
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class FindMarble {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := s.getCurrent()->toInteger() ;
    var initial : int ; initial := s.getCurrent()->toInteger() ;
    var target : int ; target := s.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     arr[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,n + 1)->collect(false) ;
    visited[initial+1] := true ; 
    var ans : int ; ans := 0 ;
    while (initial /= target) do (     initial := arr[initial+1] ; 
     if (visited[initial+1]) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
     ans := ans + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner a=new Scanner(System.in);
    int n=a.nextInt();
    int s=a.nextInt();
    int t=a.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<arr.length ; i++)arr[i]=a.nextInt();
    HashSet<Integer>set=new HashSet<>();
    int ans=0 ;
    boolean flag=true ;
    while(s!=t){
      if(set.contains(s)){
        flag=false ;
        System.out.println(-1);
        break ;
      }
      set.add(s);
      s=arr[s-1];
      ans++;
    }
    if(flag)System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : OclFile ; a := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := a.getCurrent()->toInteger() ;
    var s : int ; s := a.getCurrent()->toInteger() ;
    var t : int ; t := a.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do (     arr[i+1] := a.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
    var ans : int ; ans := 0 ;
    var flag : boolean ; flag := true ;
    while (s /= t) do (     if (set->includes(s)) then (     flag := false ; 
     OclFile["System.out"].println(-1) ; 
     break ) else skip ; 
     set := set->including(s) ; 
     s := arr[s - 1+1] ; 
     ans := ans + 1 ) ; 
    if (flag) then     OclFile["System.out"].println(ans) ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int arraySum(int arr[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum=sum+arr[i];
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      10,11,12,13,12,11,10 };
      int n=arr.length ;
      System.out.print(arraySum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation arraySum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum + arr[i+1] ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,11,12,13,12,11,10} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(arraySum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static Scanner scan=new Scanner(System.in);
  private static final long MOD=1000_000_007L ;
  public static void main(String[] args){
    long N=Long.parseLong(scan.next());
    int digit=(int)(Math.log10(N)/Math.log10(2)+1.0);
    int[] bitN=new int[digit];
    for(int i=0 ; i<digit ; i++){
      bitN[digit-1-i]=(int)(N % 2);
      N=N/2 ;
    }
    long[][] dp=new long[digit+1][3];
    dp[0][0]=1 ;
    for(int i=1 ; i<=digit ; i++){
      if(bitN[i-1]==1){
        dp[i][0]=dp[i-1][0];
        dp[i][1]=(dp[i-1][0]+dp[i-1][1])% MOD ;
        dp[i][2]=(2*dp[i-1][1]+3*dp[i-1][2])% MOD ;
      }
      else {
        dp[i][0]=(dp[i-1][0]+dp[i-1][1])% MOD ;
        dp[i][1]=dp[i-1][1];
        dp[i][2]=(dp[i-1][1]+3*dp[i-1][2])% MOD ;
      }
    }
    long ans=(dp[digit][0]+dp[digit][1]+dp[digit][2])% MOD ;
    System.out.println(ans);
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute MOD : long := 1000_000_007L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := (scan.getCurrent())->toLong() ;
     var digit : int ; digit := ((N)->log10() / (2)->log10() + 1.0)->oclAsType(int) ;
    var bitN : Sequence(int) ; bitN := Integer.subrange(1,digit)->collect(0) ;
        var i : int ; i := 0 ; while i < digit do ( (     bitN[digit - 1 - i+1] := (N mod 2)->oclAsType(int) ; 
     N := N / 2 )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,digit + 1)->collect(Integer.subrange(1,3)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= digit do ( (     if (bitN[i - 1+1] = 1) then (     dp[i+1][0+1] := dp[i - 1+1][0+1] ; 
     dp[i+1][1+1] := (dp[i - 1+1][0+1] + dp[i - 1+1][1+1]) mod MOD ; 
     dp[i+1][2+1] := (2 * dp[i - 1+1][1+1] + 3 * dp[i - 1+1][2+1]) mod MOD ) else (     dp[i+1][0+1] := (dp[i - 1+1][0+1] + dp[i - 1+1][1+1]) mod MOD ; 
     dp[i+1][1+1] := dp[i - 1+1][1+1] ; 
     dp[i+1][2+1] := (dp[i - 1+1][1+1] + 3 * dp[i - 1+1][2+1]) mod MOD ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := (dp[digit+1][0+1] + dp[digit+1][1+1] + dp[digit+1][2+1]) mod MOD ;
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Objects ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long N=scanner.nextLong();
    int M=1_000_000_007 ;
    int n=0 ;
    long t=N ;
    while(t>0){
      n++;
      t>>=1 ;
    }
    System.out.println(rec(n,N,M,new HashMap<>()));
  }
  private static long rec(int i,long j,long mod,HashMap<Pair,Long>memo){
    if(j<0)return 0 ;
    if(i<=0)return 1 ;
    if((1L<<(i+1))-2<j)return rec(i,(1L<<(i+1))-2,mod,memo);
    Pair key=new Pair(i,j);
    if(memo.containsKey(key))return memo.get(key);
    long res=rec(i-1,j,mod,memo);
    res+=rec(i-1,j-(1L<<(i-1)),mod,memo);
    res %=mod ;
    res+=rec(i-1,j-(1L<<i),mod,memo);
    res %=mod ;
    memo.put(key,res);
    return res ;
  }
  private static class Pair {
    public final int i ;
    public final long j ;
    private Pair(int i,long j){
      this.i=i ;
      this.j=j ;
    }
    @ Override public boolean equals(Object o){
      if(this==o)return true ;
      if(o==null || getClass()!=o.getClass())return false ;
      Pair pair=(Pair)o ;
      return i==pair.i && j==pair.j ;
    }
    @ Override public int hashCode(){
      return Objects.hash(i,j);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := scanner.getCurrent()->toLong() ;
    var M : int ; M := 1_000_000_007 ;
    var n : int ; n := 0 ;
    var t : long ; t := N ;
    while (t > 0) do (     n := n + 1 ; 
     t := t/(2->pow(1)) ) ; 
    OclFile["System.out"].println(rec(n, N, M, Map{})) ; 
 );
  static   operation rec( i : int, j : long, mod : long, memo : Map(Map,long)) : long
  pre: true
  post: true
  activity: (     if (j < 0) then     return 0 else skip ; 
     if (i <= 0) then     return 1 else skip ; 
    if (((1L*(2->pow((i + 1))))->oclAsType(long)) - 2 < j) then     return rec(i, ((1L*(2->pow((i + 1))))->oclAsType(long)) - 2, mod, memo) else skip ; 
    var key : Map ; key := Map(i, j) ;
    if (memo.containsKey(key)) then     return memo->at(key+1) else skip ; 
    var res : long ; res := rec(i - 1, j, mod, memo) ;
    res := res+(rec(i - 1, j - ((1L*(2->pow((i - 1))))->oclAsType(long)), mod, memo)) ; 
    res := res mod mod ; 
    res := res+(rec(i - 1, j - ((1L*(2->pow(i)))->oclAsType(long)), mod, memo)) ; 
    res := res mod mod ; 
    memo := memo->union(Map{key |-> res}) ; 
    return res 
 );
  static class Pair {
   attribute i : int;
   attribute j : long;
   static operation newPair( i : int, j : long) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(i, j);
    return self );
  operation initialise( i : int, j : long) : void
  pre: true  post: true
  activity: (     self.i := i ; 
     self.j := j );
      operation equals( o : OclAny) : boolean
  pre: true
  post: true
  activity: (     if (self = o) then     return true else skip ; 
     if (o = null or getClass() /= o->oclType()) then     return false else skip ; 
     var pair : Map ; pair := o->oclAsType(Map) ;
     return i = pair.i & j = pair.j );
      operation hashCode() : int
  pre: true
  post: true
  activity: (     return Objects.hash(i, j) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF251A {
  public static Scanner scanner ;
  public static int[] arr ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int d=scanner.nextInt();
    arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(scanner.next());
    }
    long res=0 ;
    for(int i=0 ; i<n ; i++){
      int nextIndex=nextIndex(i,d);
      if(nextIndex==n)nextIndex--;
      long combination=(long)(nextIndex-i)*(nextIndex-i-1)/2 ;
      res+=combination ;
    }
    System.out.println(res);
  }
  public static int nextIndex(int from,int distance){
    int fromElement=arr[from];
    int target=fromElement+distance ;
    int lo=from,hi=arr.length ;
    int lowerKeyIndex=lo ;
    while(lo<hi){
      int mid=lo+(hi-lo)/2 ;
      if(arr[mid]>target)hi=mid-1 ;
      else if(arr[mid]<target){
        lowerKeyIndex=mid ;
        lo=mid+1 ;
      }
      else return mid ;
    }
    return lo<arr.length && arr[lo]<=target ? lo : lowerKeyIndex ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF251A {
  static   attribute scanner : OclFile;
  static   attribute arr : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var d : int ; d := scanner.getCurrent()->toInteger() ;
    arr := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (scanner.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var nextIndex : int ; nextIndex := nextIndex(i, d) ;
     if (nextIndex = n) then     nextIndex := nextIndex - 1 ; else skip ; 
     var combination : long ; combination := (nextIndex - i)->oclAsType(long) * (nextIndex - i - 1) / 2 ;
     res := res+(combination) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static   operation nextIndex( from : int, distance : int) : int
  pre: true
  post: true
  activity: (     var fromElement : int ; fromElement := arr[from+1] ;
     var target : int ; target := fromElement + distance ;
    var lo : int ; lo := from ;
    var hi : int ; hi := arr->size() ;
    var lowerKeyIndex : int ; lowerKeyIndex := lo ;
    while (lo < hi) do (     var mid : int ; mid := lo + (hi - lo) / 2 ;
     if (arr[mid+1] > target) then     hi := mid - 1 ; else     if (arr[mid+1] < target) then (     lowerKeyIndex := mid ; 
     lo := mid + 1 ) else     return mid ;  ) ; 
    return if lo < arr->size() & arr[lo+1] <= target then lo else lowerKeyIndex endif 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long x=in.nextLong();
    printBin(fillZero(Long.toBinaryString(x)));
    printBin(fillZero(Long.toBinaryString(~ x)));
    printBin(fillZero(Long.toBinaryString(x<<1)));
    printBin(fillZero(Long.toBinaryString(x>>1)));
  }
  static void printBin(String str){
    for(int i=str.length()-32 ; i<str.length(); i++)System.out.print(str.charAt(i));
    System.out.println();
  }
  static String fillZero(String str){
    String zero="" ;
    if(str.length()<32){
      for(int i=0 ; i<32-str.length(); i++)zero+="0" ;
    }
    return zero.concat(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := in.getCurrent()->toLong() ;
    execute printBin(fillZero((MathLib.decimal2binary(x) + ""))) ; 
    execute printBin(fillZero((MathLib.decimal2binary(-(x + 1)) + ""))) ; 
    execute printBin(fillZero((MathLib.decimal2binary((x*(2->pow(1)))->oclAsType(long)) + ""))) ; 
    execute printBin(fillZero((MathLib.decimal2binary((x/(2->pow(1)))->oclAsType(long)) + ""))) ; 
 );
  static   operation printBin( str : String) : void
  pre: true
  post: true
  activity: (         var i : int ; i := str->size() - 32 ; while i < str->size() do (     OclFile["System.out"].print(str->at(i+1)) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation fillZero( str : String) : String
  pre: true
  post: true
  activity: (     var zero : String ; zero := "" ;
     if (str->size() < 32) then (         var i : int ; i := 0 ; while i < 32 - str->size() do (     zero := zero+("0") ;  ;     i := i + 1 ) ) else skip ; 
     return zero+str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.*;
import java.io.*;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    int n=scanner.nextInt();
    int a[]=new int[n+1];
    int b[]=new int[n+1];
    int num[]=new int[n+1];
    for(int i=1 ; i<=n ; i++)a[i]=scanner.nextInt();
    for(int i=1 ; i<=n ; i++)b[i]=scanner.nextInt();
    for(int i=1 ; i<=n ; i++)num[b[i] ]++;
    String ss="" ;
    int ans=0 ;
    boolean st[]=new boolean[n+1];
    for(int i=1 ; i<=n ; i++){
      if(a[i]==1){
        st[i]=true ;
        StringBuilder sb=new StringBuilder();
        int x=b[i];
        StringBuilder sss=new StringBuilder();
        sss.append(i);
        sb.append(" "+sss.reverse());
        int s=1 ;
        while(! st[x] && num[x]==1 && x!=0 && a[x]!=1){
          sss=new StringBuilder();
          sss.append(x);
          sb.append(" "+sss.reverse());
          st[x]=true ;
          x=b[x];
          s++;
        }
        if(s>ans){
          ans=s ;
          ss=sb.reverse().toString();
        }
      }
    }
    System.out.println(ans);
    System.out.println(ss);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n + 1)->collect(0) ;
    var num : Sequence(int) ; num := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (     b[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (     num[b[i+1]+1] := num[b[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
    var ss : String ; ss := "" ;
    var ans : int ; ans := 0 ;
    var st : Sequence(boolean) ; st := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 1 ; while i <= n do ( (     if (a[i+1] = 1) then (     st[i+1] := true ; 
     var sb : String ; sb := StringLib.newString() ;
    var x : int ; x := b[i+1] ;
    var sss : String ; sss := StringLib.newString() ;
    sss := sss + StringLib.newString(i) ; 
    sb := sb + StringLib.newString(" " + sss->reverse()) ; 
    var s : int ; s := 1 ;
    while (not(st[x+1]) & num[x+1] = 1 & x /= 0 & a[x+1] /= 1) do (     sss := StringLib.newString() ; 
     sss := sss + StringLib.newString(x) ; 
    sb := sb + StringLib.newString(" " + sss->reverse()) ; 
    st[x+1] := true ; 
    x := b[x+1] ; 
    s := s + 1 ; 
 ) ; 
    if (s > ans) then (     ans := s ; 
     ss := sb->reverse()+"" ) else skip ; 
 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    OclFile["System.out"].println(ss) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  static final int MODULUS=1_000_000_007 ;
  static Map<Long,Integer>cache=new HashMap<>();
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    System.out.println(solve(N));
    sc.close();
  }
  static int solve(long N){
    if(N<=1){
      return(int)N+1 ;
    }
    if(cache.containsKey(N)){
      return cache.get(N);
    }
    int result ;
    if(N % 2==0){
      result=addMod(multiplyMod(solve(N/2-1),2),solve(N/2));
    }
    else {
      result=addMod(multiplyMod(solve(N/2),2),solve(N/2-1));
    }
    cache.put(N,result);
    return result ;
  }
  static int addMod(int x,int y){
    return(x+y)% MODULUS ;
  }
  static int multiplyMod(int x,int y){
    return(int)((long)x*y % MODULUS);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MODULUS : int := 1_000_000_007;
  static   attribute cache : Map(long,int) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println(solve(N)) ; 
     skip );
  static   operation solve( N : long) : int
  pre: true
  post: true
  activity: (     if (N <= 1) then (     return N->oclAsType(int) + 1 ) else skip ; 
     if (cache->keys()->includes(N)) then (     return cache->at(N) ) else skip ; 
    var result : int ;
    if (N mod 2 = 0) then (     result := addMod(multiplyMod(solve(N / 2 - 1), 2), solve(N / 2)) ) else (     result := addMod(multiplyMod(solve(N / 2), 2), solve(N / 2 - 1)) ) ;  
    cache := cache->union(Map{N |-> result}) ; 
    return result 
 );
  static   operation addMod( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return (x + y) mod MODULUS );
  static   operation multiplyMod( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return (x->oclAsType(long) * y mod MODULUS)->oclAsType(int) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long N=scanner.nextLong();
    int M=1_000_000_007 ;
    int t=0 ;
    long n=N ;
    while(n>0){
      n/=2 ;
      t++;
    }
    long[][] dp=new long[t+1][3];
    dp[0][0]=1 ;
    for(int i=1 ; i<=t ; i++){
      if((N>>(t-i))% 2==0){
        dp[i][0]=dp[i-1][0];
        dp[i][0]=modAdd(dp[i][0],dp[i-1][1],M);
        dp[i][1]=dp[i-1][1];
        dp[i][2]=dp[i-1][1];
        dp[i][2]=modAdd(dp[i][2],3*dp[i-1][2] % M,M);
      }
      else {
        dp[i][0]=dp[i-1][0];
        dp[i][1]=dp[i-1][0];
        dp[i][1]=modAdd(dp[i][1],dp[i-1][1],M);
        dp[i][2]=2*dp[i-1][1] % M ;
        dp[i][2]=modAdd(dp[i][2],3*dp[i-1][2],M);
      }
    }
    long ans=0 ;
    for(int i=0 ; i<3 ; i++){
      ans+=dp[t][i];
      ans %=M ;
    }
    System.out.println(ans);
  }
  private static long modAdd(long a,long b,long M){
    a+=b % M ;
    a %=M ;
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := scanner.getCurrent()->toLong() ;
    var M : int ; M := 1_000_000_007 ;
    var t : int ; t := 0 ;
    var n : long ; n := N ;
    while (n > 0) do (     n := n/(2) ; 
     t := t + 1 ) ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,t + 1)->collect(Integer.subrange(1,3)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= t do ( (     if (((N/(2->pow((t - i))))->oclAsType(long)) mod 2 = 0) then (     dp[i+1][0+1] := dp[i - 1+1][0+1] ; 
     dp[i+1][0+1] := modAdd(dp[i+1][0+1], dp[i - 1+1][1+1], M) ; 
    dp[i+1][1+1] := dp[i - 1+1][1+1] ; 
    dp[i+1][2+1] := dp[i - 1+1][1+1] ; 
    dp[i+1][2+1] := modAdd(dp[i+1][2+1], 3 * dp[i - 1+1][2+1] mod M, M) ; 
 ) else (     dp[i+1][0+1] := dp[i - 1+1][0+1] ; 
     dp[i+1][1+1] := dp[i - 1+1][0+1] ; 
    dp[i+1][1+1] := modAdd(dp[i+1][1+1], dp[i - 1+1][1+1], M) ; 
    dp[i+1][2+1] := 2 * dp[i - 1+1][1+1] mod M ; 
    dp[i+1][2+1] := modAdd(dp[i+1][2+1], 3 * dp[i - 1+1][2+1], M) ; 
 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     ans := ans+(dp[t+1][i+1]) ; 
     ans := ans mod M )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation modAdd( a : long, b : long, M : long) : long
  pre: true
  post: true
  activity: (     a := a+(b mod M) ; 
     a := a mod M ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.run();
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long dp[][]=new long[65][3];
    dp[0][0]=1 ;
    long MOD=1000000007 ;
    for(int i=0 ; i<64 ; i++){
      long d=(n>>(63-i))& 1 ;
      if(d==1){
        dp[i+1][0]+=dp[i][0];
        dp[i+1][1]+=dp[i][0]+dp[i][1];
        dp[i+1][2]+=2*dp[i][1]+3*dp[i][2];
      }
      else {
        dp[i+1][0]+=dp[i][0]+dp[i][1];
        dp[i+1][1]+=dp[i][1];
        dp[i+1][2]+=dp[i][1]+3*dp[i][2];
      }
      dp[i+1][0] %=MOD ;
      dp[i+1][1] %=MOD ;
      dp[i+1][2] %=MOD ;
    }
    long ans=dp[64][0]+dp[64][1]+dp[64][2];
    ans %=MOD ;
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,65)->collect(Integer.subrange(1,3)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
    var MOD : long ; MOD := 1000000007 ;
        var i : int ; i := 0 ; while i < 64 do ( (     var d : long ; d := MathLib.bitwiseAnd(((n/(2->pow((63 - i))))->oclAsType(long)),1) ;
     if (d = 1) then (     dp[i + 1+1][0+1] := dp[i + 1+1][0+1]+(dp[i+1][0+1]) ; 
     dp[i + 1+1][1+1] := dp[i + 1+1][1+1]+(dp[i+1][0+1] + dp[i+1][1+1]) ; 
     dp[i + 1+1][2+1] := dp[i + 1+1][2+1]+(2 * dp[i+1][1+1] + 3 * dp[i+1][2+1]) ) else (     dp[i + 1+1][0+1] := dp[i + 1+1][0+1]+(dp[i+1][0+1] + dp[i+1][1+1]) ; 
     dp[i + 1+1][1+1] := dp[i + 1+1][1+1]+(dp[i+1][1+1]) ; 
     dp[i + 1+1][2+1] := dp[i + 1+1][2+1]+(dp[i+1][1+1] + 3 * dp[i+1][2+1]) ) ;  
    dp[i + 1+1][0+1] := dp[i + 1+1][0+1] mod MOD ; 
    dp[i + 1+1][1+1] := dp[i + 1+1][1+1] mod MOD ; 
    dp[i + 1+1][2+1] := dp[i + 1+1][2+1] mod MOD ; 
 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := dp[64+1][0+1] + dp[64+1][1+1] + dp[64+1][2+1] ;
    ans := ans mod MOD ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maximumOccurrence(String s){
    int n=s.length();
    HashMap<String,Integer>freq=new HashMap<String,Integer>();
    int i,j ;
    for(i=0 ; i<n ; i++){
      String temp="" ;
      temp+=s.charAt(i);
      if(freq.containsKey(temp)){
        freq.put(temp,freq.get(temp)+1);
      }
      else {
        freq.put(temp,1);
      }
    }
    for(i=0 ; i<n ; i++){
      for(j=i+1 ; j<n ; j++){
        String temp="" ;
        temp+=s.charAt(i);
        temp+=s.charAt(j);
        if(freq.containsKey(temp))freq.put(temp,freq.get(temp)+1);
        else freq.put(temp,1);
      }
    }
    int answer=Integer.MIN_VALUE ;
    for(int it : freq.values())answer=Math.max(answer,it);
    return answer ;
  }
  public static void main(String[] args){
    String s="xxxyy" ;
    System.out.print(maximumOccurrence(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maximumOccurrence( s : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var freq : Map(String,int) ; freq := Map{} ;
    var i : int ;
    var j : int ;
        i := 0 ; while i < n do ( (     var temp : String ; temp := "" ;
     temp := temp+(s->at(i+1)) ; 
     if (freq->keys()->includes(temp)) then (     freq := freq->union(Map{temp |-> freq->at(temp) + 1}) ) else (     freq := freq->union(Map{temp |-> 1}) ) )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (         j := i + 1 ; while j < n do ( (     var temp : String ; temp := "" ;
     temp := temp+(s->at(i+1)) ; 
     temp := temp+(s->at(j+1)) ; 
     if (freq->keys()->includes(temp)) then     freq := freq->union(Map{temp |-> freq->at(temp) + 1}) ; else     freq := freq->union(Map{temp |-> 1}) ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var answer : int ; answer := -2147483648 ;
    for (it : freq->values()) do (     answer := Set{answer, it}->max() ;  ) ; 
    return answer 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "xxxyy" ;
     OclFile["System.out"].print(maximumOccurrence(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Myclass {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int m=scn.nextInt();
    int[] a=new int[m];
    for(int i=0 ; i<m ; ++i){
      a[i]=scn.nextInt();
    }
    int[] light=new int[n+1];
    for(int i=0 ; i<n+1 ; ++i){
      light[i]=-1 ;
    }
    for(int i=0 ; i<m ; ++i){
      for(int j=a[i]; j<=n ; ++j){
        if(light[j]==-1){
          light[j]=a[i];
        }
      }
    }
    for(int i=1 ; i<=n ; ++i){
      System.out.print(light[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Myclass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var m : int ; m := scn.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := scn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var light : Sequence(int) ; light := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n + 1 do ( (     light[i+1] := -1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := a[i+1] ; while j <= n do ( (     if (light[j+1] = -1) then (     light[j+1] := a[i+1] ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].print(light[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] arg){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] arr=new int[m];
    for(int i=0 ; i<m ; i++)arr[i]=sc.nextInt();
    int[] ans=new int[n];
    for(int i=m-1 ; i>=0 ; i--){
      int j=arr[i];
      int k=j-1 ;
      while(k<n){
        ans[k]=j ;
        k++;
      }
    }
    for(int i : ans)System.out.print(i+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := m - 1 ; while i >= 0 do ( (     var j : int ; j := arr[i+1] ;
     var k : int ; k := j - 1 ;
     while (k < n) do (     ans[k+1] := j ; 
     k := k + 1 ) )  ;     i := i - 1 ) ; 
    for (i : ans) do (     OclFile["System.out"].print(i + " ") ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
public class file {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),m=in.nextInt();
    int a[]=new int[n];
    int l=n ;
    for(int i=0 ; i<m ; i++){
      int b=in.nextInt();
      for(int j=b-1 ; j<l ; j++)a[j]=b ;
      l=Math.min(l,b-1);
    }
    for(int i=0 ; i<a.length ; i++)System.out.print((i==0 ? "" : " ")+a[i]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class file {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var l : int ; l := n ;
        var i : int ; i := 0 ; while i < m do ( (     var b : int ; b := in.getCurrent()->toInteger() ;
         var j : int ; j := b - 1 ; while j < l do (     a[j+1] := b ;  ;     j := j + 1 ) ; 
     l := Set{l, b - 1}->min() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a->size() do (     OclFile["System.out"].print((if i = 0 then "" else " " endif) + a[i+1]) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MashmokhandLights {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] x=new int[m];
    for(int i=0 ; i<m ; i++){
      x[i]=sc.nextInt();
    }
    int[] res=new int[n];
    for(int i=0 ; i<m ; i++){
      for(int j=x[i]-1 ; j<n ; j++){
        if(res[j]==0)res[j]=x[i];
      }
    }
    for(int i=0 ; i<n-1 ; i++){
      System.out.print(res[i]+" ");
    }
    System.out.print(res[n-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MashmokhandLights {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     x[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := x[i+1] - 1 ; while j < n do ( (     if (res[j+1] = 0) then     res[j+1] := x[i+1] ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     OclFile["System.out"].print(res[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(res[n - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int distancesum(int arr[],int n){
    Arrays.sort(arr);
    int res=0,sum=0 ;
    for(int i=0 ; i<n ; i++){
      res+=(arr[i]*i-sum);
      sum+=arr[i];
    }
    return res ;
  }
  static int totaldistancesum(int x[],int y[],int n){
    return distancesum(x,n)+distancesum(y,n);
  }
  public static void main(String[] args){
    int x[]={
-1,1,3,2 };
      int y[]={
        5,6,5,3 };
        int n=x.length ;
        System.out.println(totaldistancesum(x,y,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation distancesum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var res : int ; res := 0 ;
    var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     res := res+((arr[i+1] * i - sum)) ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
     return res );
  static   operation totaldistancesum( x : Sequence(int), y : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     return distancesum(x, n) + distancesum(y, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : Sequence(int) ; x := Sequence{-1,1,3,2} ;
     var y : Sequence(int) ; y := Sequence{5,6,5,3} ;
     var n : int ; n := x->size() ;
     OclFile["System.out"].println(totaldistancesum(x, y, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class demo1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    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 res=0 ;
    int count=0 ;
    Arrays.sort(arr);
    for(int i=0 ; i<n ; i++){
      if(arr[i]+k<=5){
        count++;
      }
    }
    res=count/3 ;
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class demo1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    var count : int ; count := 0 ;
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] + k <= 5) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    res := count / 3 ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B350 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    Node[] nodes=new Node[N];
    for(int n=0 ; n<N ; n++){
      Node node=new Node();
      node.id=n+1 ;
      int type=in.nextInt();
      node.mountain=(type==0);
      nodes[n]=node ;
    }
    for(int n=0 ; n<N ; n++){
      int from=in.nextInt()-1 ;
      if(from!=-1){
        nodes[from] .outDegree++;
        nodes[from] .next=nodes[n];
      }
    }
    Node best=null ;
    for(Node node : nodes){
      solve(node);
      if(best==null || best.length<node.length){
        best=node ;
      }
    }
    StringBuilder out=new StringBuilder();
    out.append(best.length).append('\n');
    while(true){
      out.append(best.id).append(' ');
      if(best.mountain){
        best=best.next ;
      }
      else {
        break ;
      }
    }
    System.out.println(out);
  }
  static void solve(Node node){
    if(node.length!=-1)return ;
    if(node.mountain){
      if(node.outDegree==1){
        node.length=Integer.MIN_VALUE ;
        solve(node.next);
        if(node.next.length>0){
          node.length=node.next.length+1 ;
        }
        else {
          node.length=0 ;
        }
      }
      else {
        node.length=0 ;
      }
    }
    else {
      node.length=1 ;
    }
  }
  static class Node {
    int id ;
    boolean mountain ;
    int outDegree ;
    Node next ;
    int length=-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B350 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var nodes : Sequence(Node) ; nodes := Integer.subrange(1,N)->collect(null) ;
        var n : int ; n := 0 ; while n < N do ( (     var node : Node ; node := Node.newNode() ;
     node.id := n + 1 ; 
    var type : int ; type := in.getCurrent()->toInteger() ;
    node.mountain := (type = 0) ; 
    nodes[n+1] := node ; 
 )  ;     n := n + 1 ) ; 
        var n : int ; n := 0 ; while n < N do ( (     var from : int ; from := in.getCurrent()->toInteger() - 1 ;
     if (from /= -1) then (     nodes[from+1].outDegree := nodes[from+1].outDegree + 1 ; 
     nodes[from+1].next := nodes[n+1] ) else skip )  ;     n := n + 1 ) ; 
    var best : Node ; best := null ;
    for (node : nodes) do ( (     execute solve(node) ; 
     if (best = null or best->size() < node->size()) then (     best := node ) else skip )  ) ; 
    var out : String ; out := StringLib.newString() ;
    out := out + StringLib.newString(best->size()) + StringLib.newString('
') ; 
    while (true) do (     out := out + StringLib.newString(best.id) + StringLib.newString(' ') ; 
     if (best.mountain) then (     best := best.next ) else (     break ) ) ; 
    OclFile["System.out"].println(out) ; 
 );
  static   operation solve( node : Node) : void
  pre: true
  post: true
  activity: (     if (node->size() /= -1) then     return else skip ; 
     if (node.mountain) then (     if (node.outDegree = 1) then (     node->size() := -2147483648 ; 
     execute solve(node.next) ; 
     if (node.next->size() > 0) then (     node->size() := node.next->size() + 1 ) else (     node->size() := 0 ) ) else (     node->size() := 0 ) ) else (     node->size() := 1 ) );
  static class Node {
   attribute id : int;
   attribute mountain : boolean;
   attribute outDegree : int;
   attribute next : Node;
   attribute length : int := -1;
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static int n ;
  static long d ;
  static long a[];
  static long solve(){
    long ans=0 ;
    int l=0,r=1 ;
    while(l<=r && l<n){
      boolean ins=false ;
      while(r<n && a[r]-a[l]<=d){
        r++;
        ins=true ;
      }
      if(ins)r--;
      ans+=(r-l)*1l*(r-l-1)/2 ;
      l++;
      if(l>r)r=l ;
    }
    return ans ;
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    String s[]=bf.readLine().trim().split("\\s+");
    n=Integer.parseInt(s[0]);
    d=Long.parseLong(s[1]);
    a=new long[n];
    s=bf.readLine().trim().split("\\s+");
    for(int i=0 ; i<n ; i++)a[i]=Long.parseLong(s[i]);
    str.append(solve()).append("\n");
    pw.print(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute n : int;
  static   attribute d : long;
  static   attribute a : Sequence(long);
  static   operation solve() : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
     var l : int ; l := 0 ;
    var r : int ; r := 1 ;
     while (l <= r & l < n) do (     var ins : boolean ; ins := false ;
     while (r < n & a[r+1] - a[l+1] <= d) do (     r := r + 1 ; 
     ins := true ) ; 
    if (ins) then     r := r - 1 ; else skip ; 
    ans := ans+((r - l) * 1l * (r - l - 1) / 2) ; 
    l := l + 1 ; 
    if (l > r) then     r := l ; else skip ; 
 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var s : Sequence(String) ; s := bf.readLine()->trim()->split("\\s+") ;
    n := (s[0+1])->toInteger() ; 
    d := (s[1+1])->toLong() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
    s := bf.readLine()->trim()->split("\\s+") ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (s[i+1])->toLong() ;  ;     i := i + 1 ) ; 
    str := str + StringLib.newString(solve()) + StringLib.newString("\n") ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),k=sc.nextInt();
    int res=0 ;
    int[] arr=new int[7];
    for(int i=0 ; i<n ; i++){
      arr[sc.nextInt()]++;
    }
    for(int i=0 ; i<6 ; i++){
      if(Math.abs(5-i)>=k)res+=arr[i];
    }
    System.out.println(res/3);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,7)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[sc.getCurrent()->toInteger()+1] := arr[sc.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 6 do ( (     if (if 5 - i < 0 then -(5 - i) else 5 - i endif >= k) then     res := res+(arr[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res / 3) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    int counter=0 ;
    for(int i=0 ; i<n ; i++){
      int tmp=scan.nextInt();
      if(tmp+k<=5)counter++;
    }
    System.out.println(counter/3);
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var tmp : int ; tmp := scan.getCurrent()->toInteger() ;
     if (tmp + k <= 5) then     counter := counter + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter / 3) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class codeforces {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    int total_number_of_contestants_eligible=0 ;
    for(int i=1 ; i<=n ; i++){
      int val=scan.nextInt();
      if(val<=(5-k)){
        total_number_of_contestants_eligible++;
      }
    }
    System.out.println(total_number_of_contestants_eligible/3);
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var total_number_of_contestants_eligible : int ; total_number_of_contestants_eligible := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var val : int ; val := scan.getCurrent()->toInteger() ;
     if (val <= (5 - k)) then (     total_number_of_contestants_eligible := total_number_of_contestants_eligible + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total_number_of_contestants_eligible / 3) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ChoosingTeam {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    int counter=0 ;
    for(int i=0 ; i<n ; i++){
      int part=in.nextInt();
      if((5-part)>=k)counter++;
    }
    System.out.println(counter/3);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ChoosingTeam {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var part : int ; part := in.getCurrent()->toInteger() ;
     if ((5 - part) >= k) then     counter := counter + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter / 3) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class test205 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      Arrays.sort(a);
      int sum=0 ;
      for(int i=1 ; i<n ; i++){
        sum++;
        if(a[i]!=a[i-1]){
          break ;
        }
      }
      if(a[n-1]==a[0]){
        sum++;
      }
      System.out.println(n-sum);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test205 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     sum := sum + 1 ; 
     if (a[i+1] /= a[i - 1+1]) then (     break ) else skip )  ;     i := i + 1 ) ; 
    if (a[n - 1+1] = a[0+1]) then (     sum := sum + 1 ) else skip ; 
    OclFile["System.out"].println(n - sum) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Eshag_Loves_Big_Arrays {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testcase=sc.nextInt();
    while(testcase!=0){
      testcase--;
      int len=sc.nextInt(),count=0 ;
      int arr[]=new int[len],min=Integer.MAX_VALUE ;
      for(int i=0 ; i<len ; i++){
        arr[i]=sc.nextInt();
        if(min>arr[i])min=arr[i];
      }
      for(int i=0 ; i<len ; i++){
        if(arr[i]>min)count++;
      }
      System.out.print(count);
      if(testcase>0)System.out.println();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Eshag_Loves_Big_Arrays {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testcase : int ; testcase := sc.getCurrent()->toInteger() ;
     while (testcase /= 0) do (     testcase := testcase - 1 ; 
     var len : int ; len := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,len)->collect(0) ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < len do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (min > arr[i+1]) then     min := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < len do ( (     if (arr[i+1] > min) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(count) ; 
    if (testcase > 0) then     OclFile["System.out"].println() ; else skip ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Eshag_Loves_Big_Arrays {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testcase=sc.nextInt();
    while(testcase!=0){
      testcase--;
      int len=sc.nextInt(),count=0 ;
      int arr[]=new int[len],min=Integer.MAX_VALUE ;
      for(int i=0 ; i<len ; i++){
        arr[i]=sc.nextInt();
        if(min>arr[i])min=arr[i];
      }
      for(int i=0 ; i<len ; i++){
        if(arr[i]>min)count++;
      }
      System.out.print(count);
      if(testcase>0)System.out.println();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Eshag_Loves_Big_Arrays {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testcase : int ; testcase := sc.getCurrent()->toInteger() ;
     while (testcase /= 0) do (     testcase := testcase - 1 ; 
     var len : int ; len := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,len)->collect(0) ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < len do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (min > arr[i+1]) then     min := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < len do ( (     if (arr[i+1] > min) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(count) ; 
    if (testcase > 0) then     OclFile["System.out"].println() ; else skip ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int arr[]=new int[n];
      for(int p=0 ; p<n ; p++){
        int num=sc.nextInt();
        arr[p]=num ;
      }
      Arrays.sort(arr);
      int min=arr[0];
      int count=0 ;
      for(int p=0 ; p<n ; p++){
        if(arr[p]==min){
          count++;
        }
      }
      if(count==n){
        System.out.println("0");
      }
      else {
        System.out.println(n-count);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var p : int ; p := 0 ; while p < n do ( (     var num : int ; num := sc.getCurrent()->toInteger() ;
     arr[p+1] := num )  ;     p := p + 1 ) ; 
    arr := arr->sort() ; 
    var min : int ; min := arr[0+1] ;
    var count : int ; count := 0 ;
        var p : int ; p := 0 ; while p < n do ( (     if (arr[p+1] = min) then (     count := count + 1 ) else skip )  ;     p := p + 1 ) ; 
    if (count = n) then (     OclFile["System.out"].println("0") ) else (     OclFile["System.out"].println(n - count) ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int countSetBits(int n){
    if(n==0)return 0 ;
    else return(n & 1)+countSetBits(n>>1);
  }
  static boolean isPossible(int a,int b){
    int cntA=countSetBits(a);
    int cntB=countSetBits(b);
    if(cntA==cntB)return true ;
    return false ;
  }
  public static void main(String[] args){
    int a=3,b=9 ;
    if(isPossible(a,b))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else     return (n & 1) + countSetBits((n/(2->pow(1)))->oclAsType(long)) );
  static   operation isPossible( a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     var cntA : int ; cntA := countSetBits(a) ;
     var cntB : int ; cntB := countSetBits(b) ;
     if (cntA = cntB) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var b : int ; b := 9 ;
     if (isPossible(a, b)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class Test {
  static int arr1[]=new int[] {
    1,5,9,10,15,20 };
    static int arr2[]=new int[] {
      2,3,8,13 };
      static void merge(int m,int n){
        for(int i=n-1 ; i>=0 ; i--){
          int j,last=arr1[m-1];
          for(j=m-2 ; j>=0 && arr1[j]>arr2[i]; j--)arr1[j+1]=arr1[j];
          if(j!=m-2 || last>arr2[i]){
            arr1[j+1]=arr2[i];
            arr2[i]=last ;
          }
        }
      }
      public static void main(String[] args){
        merge(arr1.length,arr2.length);
        System.out.print("After Merging nFirst Array: ");
        System.out.println(Arrays.toString(arr1));
        System.out.print("Second Array:  ");
        System.out.println(Arrays.toString(arr2));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Test {
  static   attribute arr1 : int := Sequence{1,5,9,10,15,20};
  static   attribute arr2 : int := Sequence{2,3,8,13};
  static   operation merge( m : int, n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := n - 1 ; while i >= 0 do ( (     var j : int ;
    var last : int ; last := arr1[m - 1+1] ;
         j := m - 2 ; while j >= 0 & arr1[j+1] > arr2[i+1] do (     arr1[j + 1+1] := arr1[j+1] ;  ;     j := j - 1 ) ; 
     if (j /= m - 2 or last > arr2[i+1]) then (     arr1[j + 1+1] := arr2[i+1] ; 
     arr2[i+1] := last ) else skip )  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute merge(arr1->size(), arr2->size()) ; 
     OclFile["System.out"].print("After Merging nFirst Array: ") ; 
    OclFile["System.out"].println((arr1 + "")) ; 
    OclFile["System.out"].print("Second Array:  ") ; 
    OclFile["System.out"].println((arr2 + "")) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    long num1=input.nextLong();
    long num2=input.nextLong();
    long num3=input.nextLong();
    long num4=input.nextLong();
    long max1=Math.max(num1,num2);
    long max2=Math.max(num3,num4);
    long max=Math.max(max1,max2);
    if(max!=num1)System.out.print(max-num1+" ");
    if(max!=num2)System.out.print(max-num2+" ");
    if(max!=num3)System.out.print(max-num3+" ");
    if(max!=num4)System.out.print(max-num4);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num1 : long ; num1 := input.getCurrent()->toLong() ;
    var num2 : long ; num2 := input.getCurrent()->toLong() ;
    var num3 : long ; num3 := input.getCurrent()->toLong() ;
    var num4 : long ; num4 := input.getCurrent()->toLong() ;
    var max1 : long ; max1 := Set{num1, num2}->max() ;
    var max2 : long ; max2 := Set{num3, num4}->max() ;
    var max : long ; max := Set{max1, max2}->max() ;
    if (max /= num1) then     OclFile["System.out"].print(max - num1 + " ") ; else skip ; 
    if (max /= num2) then     OclFile["System.out"].print(max - num2 + " ") ; else skip ; 
    if (max /= num3) then     OclFile["System.out"].print(max - num3 + " ") ; else skip ; 
    if (max /= num4) then     OclFile["System.out"].print(max - num4) ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int y=in.nextInt(),k=in.nextInt(),n=in.nextInt();
    int max=n/k ;
    StringBuffer s=new StringBuffer();
    for(int i=1 ; i<=max ; i++){
      if((k*i-y)>0)s.append(k*i-y+" ");
    }
    System.out.println(s.length()==0 ?-1 : s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var y : int ; y := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var max : int ; max := n / k ;
    var s : String ; s := StringLib.newString() ;
        var i : int ; i := 1 ; while i <= max do ( (     if ((k * i - y) > 0) then     s := s + StringLib.newString(k * i - y + " ") ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if s->size() = 0 then -1 else s endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class P_1154A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a[]=new int[4];
    for(int i=0 ; i<4 ; i++){
      a[i]=sc.nextInt();
    }
    Arrays.sort(a);
    System.out.print(a[3]-a[0]+" ");
    System.out.print(a[3]-a[1]+" ");
    System.out.print(a[3]-a[2]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class P_1154A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    OclFile["System.out"].print(a[3+1] - a[0+1] + " ") ; 
    OclFile["System.out"].print(a[3+1] - a[1+1] + " ") ; 
    OclFile["System.out"].print(a[3+1] - a[2+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class restoring_three_numbers {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    ArrayList<Long>al=new ArrayList<>();
    for(int i=0 ; i<4 ; i++){
      al.add(in.nextLong());
    }
    Collections.sort(al);
    for(int i=0 ; i<3 ; i++){
      System.out.print(al.get(3)-al.get(i)+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class restoring_three_numbers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var al : Sequence(long) ; al := Sequence{} ;
        var i : int ; i := 0 ; while i < 4 do ( (     al := al->including(in.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    al := al->sort() ; 
        var i : int ; i := 0 ; while i < 3 do ( (     OclFile["System.out"].print(al->at(3+1) - al->at(i+1) + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MyClass {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s[]=br.readLine().split(" ");
    int a=Integer.parseInt(s[0]);
    int b=Integer.parseInt(s[1]);
    int c=Integer.parseInt(s[2]);
    int d=Integer.parseInt(s[3]);
    if(a>b){
      b=a+b ;
      a=b-a ;
      b=b-a ;
    }
    if(b>c){
      c=b+c ;
      b=c-b ;
      c=c-b ;
    }
    if(c>d){
      d=c+d ;
      c=d-c ;
      d=d-c ;
    }
    System.out.print((d-c)+" ");
    System.out.print((d-b)+" ");
    System.out.println((d-a)+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
    var a : int ; a := (s[0+1])->toInteger() ;
    var b : int ; b := (s[1+1])->toInteger() ;
    var c : int ; c := (s[2+1])->toInteger() ;
    var d : int ; d := (s[3+1])->toInteger() ;
    if (a > b) then (     b := a + b ; 
     a := b - (a)->char2byte() ; 
     b := b - (a)->char2byte() ) else skip ; 
    if (b > c) then (     c := b + c ; 
     b := c - b ; 
     c := c - b ) else skip ; 
    if (c > d) then (     d := c + d ; 
     c := d - c ; 
     d := d - c ) else skip ; 
    OclFile["System.out"].print((d - c) + " ") ; 
    OclFile["System.out"].print((d - b) + " ") ; 
    OclFile["System.out"].println((d - (a)->char2byte()) + " ") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int x=sc.nextInt();
      int y=sc.nextInt();
      int z=sc.nextInt();
      int w=sc.nextInt();
      int[] arr=new int[4];
      arr[0]=x ;
      arr[1]=y ;
      arr[2]=z ;
      arr[3]=w ;
      Arrays.sort(arr);
      for(int i=0 ; i<3 ; i++){
        System.out.print((arr[3]-arr[i])+" ");
      }
      System.out.println();
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var z : int ; z := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,4)->collect(0) ;
    arr[0+1] := x ; 
    arr[1+1] := y ; 
    arr[2+1] := z ; 
    arr[3+1] := w ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < 3 do ( (     OclFile["System.out"].print((arr[3+1] - arr[i+1]) + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public final class p111 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p111().run());
  }
  private static final int DIGITS=10 ;
  private int[] primes ;
  public String run(){
    primes=Library.listPrimes((int)Library.sqrt(pow(10,DIGITS)));
    long total=0 ;
    for(int digit=0 ; digit<10 ; digit++){
      for(int rep=DIGITS ; rep>=0 ; rep--){
        long sum=0 ;
        int[] digits=new int[DIGITS];
        long count=pow(9,DIGITS-rep);
        level2 : for(long i=0 ;
        i<count ;
        i++){
          Arrays.fill(digits,0,rep,digit);
          long temp=i ;
          for(int j=0 ; j<DIGITS-rep ; j++){
            int d=(int)(temp % 9);
            if(d>=digit)d++;
            if(j>0 && d>digits[DIGITS-j])continue level2 ;
            digits[DIGITS-1-j]=d ;
            temp/=9 ;
          }
          Arrays.sort(digits);
          do {
            if(digits[0]>0){
              long num=toInteger(digits);
              if(isPrime(num))sum+=num ;
            }
          }
          while(Library.nextPermutation(digits));
        }
        if(sum>0){
          total+=sum ;
          break ;
        }
      }
    }
    return Long.toString(total);
  }
  private boolean isPrime(long n){
    for(int p : primes){
      if(n % p==0)return false ;
    }
    return true ;
  }
  private static long toInteger(int[] digits){
    long result=0 ;
    for(int x : digits)result=result*10+x ;
    return result ;
  }
  private static long pow(int x,int y){
    long z=1 ;
    for(int i=0 ; i<y ; i++)z*=x ;
    return z ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class p111 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p111.newp111().run()) );
  static    attribute DIGITS : int := 10;
   attribute primes : Sequence(int);
   operation run() : String
  pre: true
  post: true
  activity: (     primes := Library.listPrimes(Library.sqrt(pow(10, DIGITS))->oclAsType(int)) ; 
     var total : long ; total := 0 ;
         var digit : int ; digit := 0 ; while digit < 10 do ( (         var rep : int ; rep := DIGITS ; while rep >= 0 do ( (     var sum : long ; sum := 0 ;
     var digits : Sequence(int) ; digits := Integer.subrange(1,DIGITS)->collect(0) ;
    var count : long ; count := pow(9, DIGITS - rep) ;
        var i : long ; i := 0 ; while i < count do ( (     digits := digits->collect(digit) ; 
     var temp : long ; temp := i ;
        var j : int ; j := 0 ; while j < DIGITS - rep do ( (     var d : int ; d := (temp mod 9)->oclAsType(int) ;
     if (d >= digit) then     d := d + 1 ; else skip ; 
    if (j > 0 & d > digits[DIGITS - j+1]) then     continue else skip ; 
    digits[DIGITS - 1 - j+1] := d ; 
    temp := temp/(9) ; 
 )  ;     j := j + 1 ) ; 
    digits := digits->sort() ; 
  while true do ((     if (digits[0+1] > 0) then (     var num : long ; num := toInteger(digits) ;
     if (isPrime(num)) then     sum := sum+(num) ; else skip ) else skip ) ;
    if (Library.nextPermutation(digits)) then skip else break) ; 
 )  ;     i := i + 1 ) ; 
    if (sum > 0) then (     total := total+(sum) ; 
     break ) else skip ; 
 )  ;     rep := rep - 1 ) )  ;     digit := digit + 1 ) ; 
     return ((total) + "") );
   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (     for (p : primes) do ( (     if (n mod p = 0) then     return false else skip )  ) ; 
     return true );
  static   operation toInteger( digits : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 0 ;
     for (x : digits) do (     result := result * 10 + x ;  ) ; 
     return result );
  static   operation pow( x : int, y : int) : long
  pre: true
  post: true
  activity: (     var z : long ; z := 1 ;
         var i : int ; i := 0 ; while i < y do (     z := z*(x) ;  ;     i := i + 1 ) ; 
     return z );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int aCount=0 ;
    int zCount=0 ;
    int answer=0 ;
    Scanner scan=new Scanner(System.in);
    String str=scan.next();
    String[] splitStr=str.split("",0);
    for(int i=0 ; i<splitStr.length ; i++){
      if(splitStr[i] .equals("A")){
        aCount=i ;
        break ;
      }
    }
    for(int i=0 ; i<splitStr.length ; i++){
      if(splitStr[i] .equals("Z")&& i>aCount){
        zCount=i ;
      }
      answer=zCount-aCount+1 ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var aCount : int ; aCount := 0 ;
     var zCount : int ; zCount := 0 ;
    var answer : int ; answer := 0 ;
    var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var str : String ; str := scan.getCurrent() ;
    var splitStr : Sequence(String) ; splitStr := str->split("") ;
        var i : int ; i := 0 ; while i < splitStr->size() do ( (     if (splitStr[i+1] = "A") then (     aCount := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < splitStr->size() do ( (     if (splitStr[i+1] = "Z" & i > aCount) then (     zCount := i ) else skip ; 
     answer := zCount - aCount + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    String line=str.substring(str.indexOf("A"),str.lastIndexOf("Z"));
    System.out.println(line.length()+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
     var line : String ; line := str.subrange(str->indexOf("A")-1+1,str->lastIndexOf("Z")-1) ;
     OclFile["System.out"].println(line->size() + 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    String s=sc.next();
    int l=s.length();
    int st=l-1 ;
    int en=0 ;
    for(int i=0 ; i<l ; i++){
      if(s.charAt(i)=='A'){
        st=Math.min(i,st);
      }
      if(s.charAt(i)=='Z'){
        en=Math.max(i,en);
      }
    }
    System.out.println(en-st+1);
  }
  static int l_min(int[] a){
    Arrays.sort(a);
    return a[0];
  }
  static int l_max(int[] a){
    int l=a.length ;
    Arrays.sort(a);
    return a[l-1];
  }
  public static PrintWriter out ;
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var s : String ; s := sc.next() ;
    var l : int ; l := s->size() ;
    var st : int ; st := (l)->char2byte() - 1 ;
    var en : int ; en := 0 ;
        var i : int ; i := 0 ; while i < l do ( (     if (s->at(i+1) = 'A') then (     st := Set{i, st}->min() ) else skip ; 
     if (s->at(i+1) = 'Z') then (     en := Set{i, en}->max() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(en - st + 1) ; 
 );
  static   operation l_min( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     return a[0+1] );
  static   operation l_max( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var l : int ; l := a->size() ;
     a := a->sort() ; 
     return a[(l)->char2byte() - 1+1] );
  static   attribute out : OclFile;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static int sameRemainder(int a,int b,int c){
    int a1=(b-a),b1=(c-b),c1=(c-a);
    return gcd(a1,gcd(b1,c1));
  }
  public static void main(String[] args){
    int a=62,b=132,c=237 ;
    System.out.println(sameRemainder(a,b,c));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation sameRemainder( a : int, b : int, c : int) : int
  pre: true
  post: true
  activity: (     var a1 : int ; a1 := (b - a) ;
    var b1 : int ; b1 := (c - b) ;
    var c1 : int ; c1 := (c - a) ;
     return gcd(a1, gcd(b1, c1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 62 ;
    var b : int ; b := 132 ;
    var c : int ; c := 237 ;
     OclFile["System.out"].println(sameRemainder(a, b, c)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    String S=input.readLine();
    int APosition=0 ;
    for(int i=0 ; i<S.length(); i++){
      if(isA(S.charAt(i))){
        APosition=i ;
        break ;
      }
    }
    int ZPosition=S.length()-1 ;
    for(int i=S.length()-1 ; i>=0 ; i--){
      if(isZ(S.charAt(i))){
        ZPosition=i ;
        break ;
      }
    }
    System.out.println(ZPosition-APosition+1);
  }
  private static boolean isA(char c){
    return c=='A' ;
  }
  private static boolean isZ(char c){
    return c=='Z' ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var S : String ; S := input.readLine() ;
    var APosition : int ; APosition := 0 ;
        var i : int ; i := 0 ; while i < S->size() do ( (     if (isA(S->at(i+1))) then (     APosition := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var ZPosition : int ; ZPosition := S->size() - 1 ;
        var i : int ; i := S->size() - 1 ; while i >= 0 do ( (     if (isZ(S->at(i+1))) then (     ZPosition := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ZPosition - (APosition)->char2byte() + 1) ; 
 );
  static   operation isA( c : String) : boolean
  pre: true
  post: true
  activity: (     return c = 'A' );
  static   operation isZ( c : String) : boolean
  pre: true
  post: true
  activity: (     return c = 'Z' );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner s=new Scanner(System.in);
  public static void main(String[] args){
    String in=s.next();
    int s=-1,g=-1 ;
    for(int i=0 ; s==-1 ; i++){
      if(in.charAt(i)=='A')s=i ;
    }
    for(int i=in.length()-1 ; g==-1 ; i--){
      if(in.charAt(i)=='Z')g=i ;
    }
    System.out.println(g-s+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : String ; in := s.getCurrent() ;
     var s : int ; s := -1 ;
    var g : int ; g := -1 ;
        var i : int ; i := 0 ; while s = -1 do ( (     if (in->at(i+1) = 'A') then     s := i ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := in->size() - 1 ; while g = -1 do ( (     if (in->at(i+1) = 'Z') then     g := i ; else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println((g)->char2byte() - (s)->char2byte() + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int y=in.nextInt(),k=in.nextInt(),n=in.nextInt(),c=0 ;
    ArrayList<Integer>ans=new ArrayList<>();
    int max=n/k ;
    for(int i=1 ; i<=max ; i++){
      if((k*i-y)>0)ans.add(k*i-y);
    }
    if(ans.size()==0)System.out.println(-1);
    else {
      for(int e : ans)System.out.print(e+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var y : int ; y := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
    var ans : Sequence(int) ; ans := Sequence{} ;
    var max : int ; max := n / k ;
        var i : int ; i := 1 ; while i <= max do ( (     if ((k * i - y) > 0) then     ans := ans->including(k * i - y) ; else skip )  ;     i := i + 1 ) ; 
    if (ans->size() = 0) then     OclFile["System.out"].println(-1) else (     for (e : ans) do (     OclFile["System.out"].print(e + " ") ;  ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int percent(int a,int b){
    float result=0 ;
    result=((b-a)*100)/a ;
    return(int)result ;
  }
  public static void main(String[] args){
    int a=20,b=25 ;
    System.out.println(percent(a,b)+"%");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation percent( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
     result := ((b - a) * 100) / a ; 
     return result->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 20 ;
    var b : int ; b := 25 ;
     OclFile["System.out"].println(percent(a, b) + "%") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.time.DayOfWeek ;
import java.time.LocalDate ;
import java.time.YearMonth ;
import java.time.temporal.TemporalAdjusters ;
import java.util.Scanner ;
public class SmallBear {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    sc.next();
    String unit=sc.next();
    System.out.println(solve(x,unit));
    sc.close();
  }
  public static int solve(int startDay,String unit){
    int count=0 ;
    if(unit.contains("week")){
      LocalDate start=LocalDate.of(2016,1,1);
      count+=start.getDayOfWeek().getValue()==startDay ? 1 : 0 ;
      while(true){
        start=start.with(TemporalAdjusters.next(DayOfWeek.of(startDay)));
        if(start.getYear()==2017){
          break ;
        }
        count++;
      }
    }
    else {
      YearMonth yearMonth=YearMonth.of(2016,1);
      for(int i=1 ; i<=12 ; i++){
        count+=yearMonth.isValidDay(startDay)? 1 : 0 ;
        yearMonth=yearMonth.plusMonths(1);
      }
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class SmallBear {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    skip ; 
    var unit : String ; unit := sc.getCurrent() ;
    OclFile["System.out"].println(solve(x, unit)) ; 
    skip ; 
 );
  static   operation solve( startDay : int, unit : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     if (unit->includes("week")) then (     var start : LocalDate ; start := LocalDate.of(2016, 1, 1) ;
     count := count+(if start.getDayOfWeek().getValue() = startDay then 1 else 0 endif) ; 
     while (true) do (     start := start.with(TemporalAdjusters.next(DayOfWeek.of(startDay))) ; 
     if (start.getYear() = 2017) then (     break ) else skip ; 
     count := count + 1 ) ) else (     var yearMonth : YearMonth ; yearMonth := YearMonth.of(2016, 1) ;
         var i : int ; i := 1 ; while i <= 12 do ( (     count := count+(if yearMonth.isValidDay(startDay) then 1 else 0 endif) ; 
     yearMonth := yearMonth.plusMonths(1) )  ;     i := i + 1 ) ) ;  
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.time.LocalDate ;
import java.time.YearMonth ;
import java.time.temporal.TemporalAdjusters ;
import java.util.Scanner ;
public class SmallBear {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    sc.next();
    String unit=sc.next();
    System.out.println(solve(x,unit));
    sc.close();
  }
  public static int solve(int startDay,String unit){
    int count=0 ;
    if(unit.contains("week")){
      int firstJan=LocalDate.of(2016,1,1).getDayOfWeek().getValue();
      LocalDate start=LocalDate.of(2016,1,1);
      if(firstJan<startDay){
        start=LocalDate.of(2016,1,startDay-firstJan+1);
      }
      else if(firstJan>startDay){
        start=LocalDate.of(2016,1,3+startDay);
      }
      while(start.getYear()==2016){
        start=start.plusWeeks(1);
        count++;
      }
    }
    else {
      YearMonth yearMonth=YearMonth.of(2016,1);
      for(int i=1 ; i<=12 ; i++){
        count+=yearMonth.isValidDay(startDay)? 1 : 0 ;
        yearMonth=yearMonth.plusMonths(1);
      }
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class SmallBear {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    skip ; 
    var unit : String ; unit := sc.getCurrent() ;
    OclFile["System.out"].println(solve(x, unit)) ; 
    skip ; 
 );
  static   operation solve( startDay : int, unit : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     if (unit->includes("week")) then (     var firstJan : int ; firstJan := LocalDate.of(2016, 1, 1).getDayOfWeek().getValue() ;
     var start : LocalDate ; start := LocalDate.of(2016, 1, 1) ;
     if (firstJan < startDay) then (     start := LocalDate.of(2016, 1, startDay - firstJan + 1) ) else     if (firstJan > startDay) then (     start := LocalDate.of(2016, 1, 3 + startDay) ) else skip ; ;  
     while (start.getYear() = 2016) do (     start := start.plusWeeks(1) ; 
     count := count + 1 ) ) else (     var yearMonth : YearMonth ; yearMonth := YearMonth.of(2016, 1) ;
         var i : int ; i := 1 ; while i <= 12 do ( (     count := count+(if yearMonth.isValidDay(startDay) then 1 else 0 endif) ; 
     yearMonth := yearMonth.plusMonths(1) )  ;     i := i + 1 ) ) ;  
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int d ;
    String word ;
    char[] w ;
    word=in.nextLine();
    w=word.toCharArray();
    if(w[5]=='w'){
      d=(int)(w[0]-'0');
      if(d==5 || d==6)System.out.println(53);
      else System.out.println(52);
    }
    else {
      if(w[1]==' ')d=(int)(w[0]-'0');
      else d=(int)(10*(w[0]-'0')+(w[1]-'0'));
      if(d<=29)System.out.println(12);
      else if(d==30)System.out.println(11);
      else System.out.print(7);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : int ;
    var word : String ;
    var w : Sequence(String) ;
    word := in.nextLine() ; 
    w := word->characters() ; 
    if (w[5+1] = 'w') then (     d := (w[0+1] - ('0')->char2byte())->oclAsType(int) ; 
     if (d = 5 or d = 6) then     OclFile["System.out"].println(53) ; else     OclFile["System.out"].println(52) ; ) else (     if (w[1+1] = ' ') then     d := (w[0+1] - ('0')->char2byte())->oclAsType(int) else     d := (10 * (w[0+1] - ('0')->char2byte()) + (w[1+1] - ('0')->char2byte()))->oclAsType(int) ; ;  
     if (d <= 29) then     OclFile["System.out"].println(12) ; else     if (d = 30) then     OclFile["System.out"].println(11) else     OclFile["System.out"].print(7) ; ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Driver {
  private static Scanner scanner ;
  static boolean check ;
  public static boolean isWeek(String string){
    if(string.equals("week"))return true ;
    else {
      return false ;
    }
  }
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    String s=scanner.nextLine();
    String[] arr=s.split(" ");
    int single_day=Integer.valueOf(arr[0]);
    int count=0 ;
    if(isWeek(arr[arr.length-1])){
      if(single_day==5 || single_day==6){
        System.out.println(53);
      }
      else {
        System.out.println(52);
      }
    }
    else {
      if(single_day==31){
        System.out.println(7);
      }
      else if(single_day==30){
        System.out.println(11);
      }
      else {
        System.out.println(12);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Driver {
  static   attribute scanner : OclFile;
  static   attribute check : boolean;
  static   operation isWeek( string : String) : boolean
  pre: true
  post: true
  activity: (     if (string = "week") then     return true else (     return false ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var s : String ; s := scanner.nextLine() ;
    var arr : Sequence(String) ; arr := s->split(" ") ;
    var single_day : int ; single_day := (arr[0+1])->toInteger() ;
    var count : int ; count := 0 ;
    if (isWeek(arr[arr->size() - 1+1])) then (     if (single_day = 5 or single_day = 6) then (     OclFile["System.out"].println(53) ) else (     OclFile["System.out"].println(52) ) ) else (     if (single_day = 31) then (     OclFile["System.out"].println(7) ) else     if (single_day = 30) then (     OclFile["System.out"].println(11) ) else (     OclFile["System.out"].println(12) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.time.DayOfWeek ;
import java.time.LocalDate ;
import java.time.YearMonth ;
import java.time.temporal.TemporalAdjusters ;
import java.util.Scanner ;
public class SmallBear {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    sc.next();
    String unit=sc.next();
    System.out.println(solve(x,unit));
    sc.close();
  }
  public static int solve(int startDay,String unit){
    int count=0 ;
    if(unit.contains("week")){
      LocalDate start=LocalDate.of(2016,1,1).with(TemporalAdjusters.nextOrSame(DayOfWeek.of(startDay)));
      while(start.getYear()==2016){
        start=start.plusWeeks(1);
        count++;
      }
    }
    else {
      YearMonth yearMonth=YearMonth.of(2016,1);
      for(int i=1 ; i<=12 ; i++){
        count+=yearMonth.isValidDay(startDay)? 1 : 0 ;
        yearMonth=yearMonth.plusMonths(1);
      }
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class SmallBear {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    skip ; 
    var unit : String ; unit := sc.getCurrent() ;
    OclFile["System.out"].println(solve(x, unit)) ; 
    skip ; 
 );
  static   operation solve( startDay : int, unit : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     if (unit->includes("week")) then (     var start : LocalDate ; start := LocalDate.of(2016, 1, 1).with(TemporalAdjusters.nextOrSame(DayOfWeek.of(startDay))) ;
     while (start.getYear() = 2016) do (     start := start.plusWeeks(1) ; 
     count := count + 1 ) ) else (     var yearMonth : YearMonth ; yearMonth := YearMonth.of(2016, 1) ;
         var i : int ; i := 1 ; while i <= 12 do ( (     count := count+(if yearMonth.isValidDay(startDay) then 1 else 0 endif) ; 
     yearMonth := yearMonth.plusMonths(1) )  ;     i := i + 1 ) ) ;  
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minimumChanges(int arr[],int n){
    int i ;
    int changes=0 ;
    for(i=0 ; i<n ; i++){
      if(arr[i]==1){
        int j ;
        for(j=i+1 ; j<n ; j++){
          if(arr[j]==0)break ;
        }
        i=j-1 ;
        changes++;
      }
    }
    return changes ;
  }
  public static void main(String args[]){
    int arr[]={
      1,1,0,0,0,1,0,1,1 };
      int n=arr.length ;
      System.out.println("Minimum operations: "+minimumChanges(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minimumChanges( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
     var changes : int ; changes := 0 ;
         i := 0 ; while i < n do ( (     if (arr[i+1] = 1) then (     var j : int ;
         j := i + 1 ; while j < n do ( (     if (arr[j+1] = 0) then     break else skip )  ;     j := j + 1 ) ; 
     i := j - 1 ; 
     changes := changes + 1 ) else skip )  ;     i := i + 1 ) ; 
     return changes );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,0,0,0,1,0,1,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Minimum operations: " + minimumChanges(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  static final int INF=0x3f3f3f3f ;
  static final long LNF=0x3f3f3f3f3f3f3f3fL ;
  public static void main(String[] args)throws IOException {
    initReader();
    long a=nextLong();
    long b=nextLong();
    long c=nextLong();
    long d=nextLong();
    long[] an={
      a,b,c };
      Arrays.sort(an);
      long ans=0 ;
      if(an[1]-an[0]<d){
        ans+=(d-an[1]+an[0]);
      }
      if(an[2]-an[1]<d){
        ans+=(d-an[2]+an[1]);
      }
      pw.println(ans);
      pw.close();
    }
    static BufferedReader reader ;
    static StringTokenizer tokenizer ;
    static PrintWriter pw ;
    public static void initReader()throws IOException {
      reader=new BufferedReader(new InputStreamReader(System.in));
      tokenizer=new StringTokenizer("");
      pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    }
    public static boolean hasNext(){
      try {
        while(! tokenizer.hasMoreTokens()){
          tokenizer=new StringTokenizer(reader.readLine());
        }
      }
      catch(Exception e){
        return false ;
      }
      return true ;
    }
    public static String next()throws IOException {
      while(! tokenizer.hasMoreTokens()){
        tokenizer=new StringTokenizer(reader.readLine());
      }
      return tokenizer.nextToken();
    }
    public static String nextLine(){
      try {
        return reader.readLine();
      }
      catch(Exception e){
        return null ;
      }
    }
    public static int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public static long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public static double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public static char nextChar()throws IOException {
      return next().charAt(0);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := 0x3f3f3f3f;
  static    attribute LNF : long := 0x3f3f3f3f3f3f3f3fL;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute initReader() ; 
     var a : long ; a := nextLong() ;
    var b : long ; b := nextLong() ;
    var c : long ; c := nextLong() ;
    var d : long ; d := nextLong() ;
    var an : Sequence(long) ; an := Sequence{a,b,c} ;
    an := an->sort() ; 
    var ans : long ; ans := 0 ;
    if (an[1+1] - an[0+1] < d) then (     ans := ans+((d - an[1+1] + an[0+1])) ) else skip ; 
    if (an[2+1] - an[1+1] < d) then (     ans := ans+((d - an[2+1] + an[1+1])) ) else skip ; 
    pw.println(ans) ; 
    pw.close() ; 
 );
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   attribute pw : OclFile;
  static   operation initReader() : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := OclIterator.newOclIterator_String("") ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) );
  static   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     try (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (e : ProgramException) do (     return false )
     return true );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : ProgramException) do (     return null )
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countMultiples(int n){
    int res=0 ;
    for(int i=1 ; i<=n ; i++)if(i % 3==0 || i % 7==0)res++;
    return res ;
  }
  public static void main(String[] args){
    System.out.print("Count=");
    System.out.println(countMultiples(25));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countMultiples( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 1 ; while i <= n do (     if (i mod 3 = 0 or i mod 7 = 0) then     res := res + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("Count=") ; 
     OclFile["System.out"].println(countMultiples(25)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int sim(char[][] s,int n,int d,int start){
    int t=start ;
    for(int i=0 ; i<d ; i++){
      if(t>0 && s[i][t-1]=='1')t--;
      else if(t<n-1 && s[i][t]=='1')t++;
    }
    return t ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int m=sc.nextInt()-1 ;
      int g=sc.nextInt()-1 ;
      int d=sc.nextInt();
      char[][] s=new char[d][n-1];
      for(int i=0 ; i<d ; i++)s[i]=sc.next().toCharArray();
      if(sim(s,n,d,m)==g){
        System.out.println(0);
        continue ;
      }
      boolean ok=false ;
      for(int i=0 ; i<d ; i++){
        for(int j=0 ; j<n-1 ; j++){
          if(ok || s[i][j]=='1')continue ;
          boolean left,right ;
          if(j==0 || s[i][j-1]=='0')left=true ;
          else left=false ;
          if(j==n-2 || s[i][j+1]=='0')right=true ;
          else right=false ;
          if(left && right){
            s[i][j]='1' ;
            if(sim(s,n,d,m)==g){
              System.out.println((i+1)+" "+(j+1));
              ok=true ;
              break ;
            }
            s[i][j]='0' ;
          }
        }
      }
      if(! ok)System.out.println("1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation sim( s : Sequence(Sequence(String)), n : int, d : int, start : int) : int
  pre: true
  post: true
  activity: (     var t : int ; t := start ;
         var i : int ; i := 0 ; while i < d do ( (     if (t > 0 & s[i+1][t - 1+1] = '1') then     t := t - 1 ; else     if (t < n - 1 & s[i+1][t+1] = '1') then     t := t + 1 ; else skip ; )  ;     i := i + 1 ) ; 
     return t );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var m : int ; m := sc.getCurrent()->toInteger() - 1 ;
    var g : int ; g := sc.getCurrent()->toInteger() - 1 ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var s : Sequence(Sequence(String)) ; s := Integer.subrange(1,d)->collect(Integer.subrange(1,n - 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < d do (     s[i+1] := sc.getCurrent()->characters() ;  ;     i := i + 1 ) ; 
    if (sim(s, n, d, m) = g) then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
    var ok : boolean ; ok := false ;
        var i : int ; i := 0 ; while i < d do ( (         var j : int ; j := 0 ; while j < n - 1 do ( (     if (ok or s[i+1][j+1] = '1') then     continue else skip ; 
     var left : boolean ;
    var right : boolean ;
    if (j = 0 or s[i+1][j - 1+1] = '0') then     left := true else     left := false ; ;  
    if (j = n - 2 or s[i+1][j + 1+1] = '0') then     right := true else     right := false ; ;  
    if (left & right) then (     s[i+1][j+1] := '1' ; 
     if (sim(s, n, d, m) = g) then (     OclFile["System.out"].println((i + 1) + " " + (j + 1)) ; 
     ok := true ; 
     break ) else skip ; 
     s[i+1][j+1] := '0' ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (not(ok)) then     OclFile["System.out"].println("1") ; else skip ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int sim(char[][] s,int n,int d,int start){
    int t=start ;
    for(int i=0 ; i<d ; i++){
      if(t>0 && s[i][t-1]=='1')t--;
      else if(t<n-1 && s[i][t]=='1')t++;
    }
    return t ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int m=sc.nextInt()-1 ;
      int g=sc.nextInt()-1 ;
      int d=sc.nextInt();
      char[][] s=new char[d][n-1];
      for(int i=0 ; i<d ; i++)s[i]=sc.next().toCharArray();
      if(sim(s,n,d,m)==g){
        System.out.println(0);
        continue ;
      }
      boolean ok=false ;
      for(int i=0 ; i<d ; i++){
        for(int j=0 ; j<n-1 ; j++){
          if(ok || s[i][j]=='1')continue ;
          boolean left,right ;
          if(j==0 || s[i][j-1]=='0')left=true ;
          else left=false ;
          if(j==n-2 || s[i][j+1]=='0')right=true ;
          else right=false ;
          if(left && right){
            s[i][j]='1' ;
            if(sim(s,n,d,m)==g){
              System.out.println((i+1)+" "+(j+1));
              ok=true ;
              break ;
            }
            s[i][j]='0' ;
          }
        }
      }
      if(! ok)System.out.println("1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation sim( s : Sequence(Sequence(String)), n : int, d : int, start : int) : int
  pre: true
  post: true
  activity: (     var t : int ; t := start ;
         var i : int ; i := 0 ; while i < d do ( (     if (t > 0 & s[i+1][t - 1+1] = '1') then     t := t - 1 ; else     if (t < n - 1 & s[i+1][t+1] = '1') then     t := t + 1 ; else skip ; )  ;     i := i + 1 ) ; 
     return t );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var m : int ; m := sc.getCurrent()->toInteger() - 1 ;
    var g : int ; g := sc.getCurrent()->toInteger() - 1 ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var s : Sequence(Sequence(String)) ; s := Integer.subrange(1,d)->collect(Integer.subrange(1,n - 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < d do (     s[i+1] := sc.getCurrent()->characters() ;  ;     i := i + 1 ) ; 
    if (sim(s, n, d, m) = g) then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
    var ok : boolean ; ok := false ;
        var i : int ; i := 0 ; while i < d do ( (         var j : int ; j := 0 ; while j < n - 1 do ( (     if (ok or s[i+1][j+1] = '1') then     continue else skip ; 
     var left : boolean ;
    var right : boolean ;
    if (j = 0 or s[i+1][j - 1+1] = '0') then     left := true else     left := false ; ;  
    if (j = n - 2 or s[i+1][j + 1+1] = '0') then     right := true else     right := false ; ;  
    if (left & right) then (     s[i+1][j+1] := '1' ; 
     if (sim(s, n, d, m) = g) then (     OclFile["System.out"].println((i + 1) + " " + (j + 1)) ; 
     ok := true ; 
     break ) else skip ; 
     s[i+1][j+1] := '0' ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (not(ok)) then     OclFile["System.out"].println("1") ; else skip ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int y=in.nextInt(),k=in.nextInt(),n=in.nextInt(),c=0 ;
    int max=n/k ;
    for(int i=1 ; i<=max ; i++){
      if((k*i-y)>0){
        System.out.print((k*i-y)+" ");
        c++;
      }
    }
    if(c==0)System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var y : int ; y := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
    var max : int ; max := n / k ;
        var i : int ; i := 1 ; while i <= max do ( (     if ((k * i - y) > 0) then (     OclFile["System.out"].print((k * i - y) + " ") ; 
     c := c + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (c = 0) then     OclFile["System.out"].println(-1) ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int s=sc.nextInt();
      int g=sc.nextInt();
      int m=sc.nextInt();
      int[][] map=new int[m+1][n+1];
      String t ;
      for(int i=1 ; i<=m ; i++){
        t=sc.next();
        for(int j=1 ; j<n ; j++){
          map[i][j]=t.codePointAt(j-1)-48 ;
        }
      }
      int x ;
      boolean flag=false ;
      for(int i=0 ; i<=m ; i++){
        for(int j=1 ; j<n ; j++){
          if(map[i][j-1]==0 && map[i][j]==0 && map[i][j+1]==0){
            map[i][j]=1 ;
            x=s ;
            for(int k=1 ; k<=m ; k++){
              if(map[k][x-1]==1)x--;
              else if(map[k][x]==1)x++;
            }
            if(x==g){
              if(i==0)System.out.println(0);
              else System.out.println(i+" "+j);
              flag=true ;
              i=m+1 ;
              j=n ;
            }
            else {
              map[i][j]=0 ;
            }
          }
        }
      }
      if(flag==false)System.out.println(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var g : int ; g := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
    var t : String ;
        var i : int ; i := 1 ; while i <= m do ( (     t := sc.getCurrent() ; 
         var j : int ; j := 1 ; while j < n do ( (     map[i+1][j+1] := t.codePointAt(j - 1) - 48 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var x : int ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i <= m do ( (         var j : int ; j := 1 ; while j < n do ( (     if (map[i+1][j - 1+1] = 0 & map[i+1][j+1] = 0 & map[i+1][j + 1+1] = 0) then (     map[i+1][j+1] := 1 ; 
     x := s ; 
         var k : int ; k := 1 ; while k <= m do ( (     if (map[k+1][x - 1+1] = 1) then     x := x - 1 ; else     if (map[k+1][x+1] = 1) then     x := x + 1 ; else skip ; )  ;     k := k + 1 ) ; 
     if (x = g) then (     if (i = 0) then     OclFile["System.out"].println(0) else     OclFile["System.out"].println(i + " " + j) ; ;  
     flag := true ; 
     i := m + 1 ; 
     j := n ) else (     map[i+1][j+1] := 0 ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (flag = false) then     OclFile["System.out"].println(1) ; else skip ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int i=0,j=0 ;
      int n=sc.nextInt();
      if(n==0)break ;
      int s=sc.nextInt();
      int g=sc.nextInt();
      int d=sc.nextInt();
      char[][] map=new char[d][n-1];
      for(i=0 ; i<d ; i++){
        map[i]=sc.next().toCharArray();
      }
      if(reachable(map,s,g)){
        System.out.println(0);
        continue ;
      }
      boolean flg=true ;
      for(i=0 ; flg && i<d ; i++){
        for(j=0 ; flg && j<n-1 ; j++){
          if(map[i][j]=='0' &&(j-1<0 || map[i][j-1]=='0')&&(j+1>=n-1 || map[i][j+1]=='0')){
            map[i][j]='1' ;
            if(reachable(map,s,g))flg=false ;
            map[i][j]='0' ;
          }
        }
      }
      if(! flg)System.out.println(i+" "+j);
      else System.out.println(1);
    }
  }
  private static boolean reachable(char[][] map,int s,int g){
    int i=0,j=s-1 ;
    while(i<map.length){
      if(j<map[0] .length && map[i][j]=='1')j++;
      else if(j-1>=0 && map[i][j-1]=='1')j--;
      i++;
    }
    return j==g-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var i : int ; i := 0 ;
    var j : int ; j := 0 ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    if (n = 0) then     break else skip ; 
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var g : int ; g := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(String)) ; map := Integer.subrange(1,d)->collect(Integer.subrange(1,n - 1)->collect(0)) ;
        i := 0 ; while i < d do ( (     map[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    if (reachable(map, s, g)) then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
    var flg : boolean ; flg := true ;
        i := 0 ; while flg & i < d do ( (         j := 0 ; while flg & j < n - 1 do ( (     if (map[i+1][j+1] = '0' & (j - 1 < 0 or map[i+1][j - 1+1] = '0') & (j + 1 >= n - 1 or map[i+1][j + 1+1] = '0')) then (     map[i+1][j+1] := '1' ; 
     if (reachable(map, s, g)) then     flg := false ; else skip ; 
     map[i+1][j+1] := '0' ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (not(flg)) then     OclFile["System.out"].println(i + " " + j) else     OclFile["System.out"].println(1) ; ;  
 ) );
  static   operation reachable( map : Sequence(Sequence(String)), s : int, g : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var j : int ; j := s - 1 ;
     while (i < map->size()) do (     if (j < map[0+1]->size() & map[i+1][j+1] = '1') then     j := j + 1 else     if (j - 1 >= 0 & map[i+1][j - 1+1] = '1') then     j := j - 1 ; else skip ; ;  
     i := i + 1 ) ; 
     return j = g - 1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  static int missingK(int[] a,int k,int n){
    int difference=0,ans=0,count=k ;
    boolean flag=false ;
    for(int i=0 ; i<n-1 ; i++){
      difference=0 ;
      if((a[i]+1)!=a[i+1]){
        difference+=(a[i+1]-a[i])-1 ;
        if(difference>=count){
          ans=a[i]+count ;
          flag=true ;
          break ;
        }
        else count-=difference ;
      }
    }
    if(flag)return ans ;
    else return-1 ;
  }
  public static void main(String args[]){
    int[] a={
      1,5,11,19 };
      int k=11 ;
      int n=a.length ;
      int missing=missingK(a,k,n);
      System.out.print(missing);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation missingK( a : Sequence(int), k : int, n : int) : int
  pre: true
  post: true
  activity: (     var difference : int ; difference := 0 ;
    var ans : int ; ans := 0 ;
    var count : int ; count := k ;
     var flag : boolean ; flag := false ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     difference := 0 ; 
     if ((a[i+1] + 1) /= a[i + 1+1]) then (     difference := difference+((a[i + 1+1] - a[i+1]) - 1) ; 
     if (difference >= count) then (     ans := a[i+1] + count ; 
     flag := true ; 
     break ) else     count := count-(difference) ; ) else skip )  ;     i := i + 1 ) ; 
     if (flag) then     return ans else     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,5,11,19} ;
     var k : int ; k := 11 ;
    var n : int ; n := a->size() ;
    var missing : int ; missing := missingK(a, k, n) ;
    OclFile["System.out"].print(missing) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printEgyptian(int nr,int dr){
    if(dr==0 || nr==0){
      return ;
    }
    if(dr % nr==0){
      System.out.print("1/"+dr/nr);
      return ;
    }
    if(nr % dr==0){
      System.out.print(nr/dr);
      return ;
    }
    if(nr>dr){
      System.out.print(nr/dr+"+");
      printEgyptian(nr % dr,dr);
      return ;
    }
    int n=dr/nr+1 ;
    System.out.print("1/"+n+"+");
    printEgyptian(nr*n-dr,dr*n);
  }
  public static void main(String[] args){
    int nr=6,dr=14 ;
    System.out.print("Egyptian Fraction Representation of "+nr+"/"+dr+" is\n ");
    printEgyptian(nr,dr);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printEgyptian( nr : int, dr : int) : void
  pre: true
  post: true
  activity: (     if (dr = 0 or nr = 0) then (     return ) else skip ; 
     if (dr mod nr = 0) then (     OclFile["System.out"].print("1/" + dr / nr) ; 
     return ) else skip ; 
    if (nr mod dr = 0) then (     OclFile["System.out"].print(nr / dr) ; 
     return ) else skip ; 
    if (nr > dr) then (     OclFile["System.out"].print(nr / dr + "+") ; 
     execute printEgyptian(nr mod dr, dr) ; 
     return ) else skip ; 
    var n : int ; n := dr / nr + 1 ;
    OclFile["System.out"].print("1/" + n + "+") ; 
    execute printEgyptian(nr * n - dr, dr * n) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var nr : int ; nr := 6 ;
    var dr : int ; dr := 14 ;
     OclFile["System.out"].print("Egyptian Fraction Representation of " + nr + "/" + dr + " is\n ") ; 
     execute printEgyptian(nr, dr) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static Scanner s=new Scanner(System.in);
  public static void main(String[] $){
    int n=s.nextInt();
    StringBuilder b=new StringBuilder(n);
    for(int i=0 ; i<n ; ++i)b.append(Integer.parseInt(s.next()));
    String c=b.toString();
    for(int i=0 ; i>=0 ; ++i){
      if(b.indexOf(String.valueOf(i))<0){
        System.out.println(i);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s.getCurrent()->toInteger() ;
     var b : String ; b := StringLib.newString(n) ;
        var i : int ; i := 0 ; while i < n do (     b := b + StringLib.newString((s.getCurrent())->toInteger()) ;  ;     i := i + 1 ) ; 
    var c : String ; c := b+"" ;
        var i : int ; i := 0 ; while i >= 0 do ( (     if (b->indexOf(((i) + ""))-1 < 0) then (     OclFile["System.out"].println(i) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int n=parseInt(br.readLine());
    char[] seq=new char[n];
    int _i=0 ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      for(int i=0 ; i<line.length(); i+=2,_i++){
        seq[_i]=line.charAt(i);
      }
    }
    boolean[] nums=new boolean[1_000_000];
    outer : for(int i=0 ;
    i<n ;
    i++){
      for(int j=i ; j<n ; j++){
        int len=j-i+1 ;
        if((seq[i]=='0' && len>1)|| len>6)continue outer ;
        nums[parseInt(String.valueOf(seq,i,len))]=true ;
      }
    }
    for(int i=0 ; i<nums.length ; i++){
      if(! nums[i]){
        System.out.println(i);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var n : int ; n := parseInt(br.readLine()) ;
    var seq : Sequence(String) ; seq := Integer.subrange(1,n)->collect(0) ;
    var _i : int ; _i := 0 ;
        line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (         var i : int ; i := 0 ; while i < line->size() do ( (     seq[_i+1] := line->at(i+1) )  ;     i := i+(2) ;     _i := _i + 1 ) ) ;     line := br.readLine() ;
 ) ;  
    var nums : Sequence(boolean) ; nums := Integer.subrange(1,1_000_000)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i ; while j < n do ( (     var len : int ; len := j - i + 1 ;
     if ((seq[i+1] = '0' & len > 1) or len > 6) then     continue else skip ; 
     nums[((seq).subrange(i+1,i+len)->sum()  + "")->toInteger()+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < nums->size() do ( (     if (not(nums[i+1])) then (     OclFile["System.out"].println(i) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class CodeForces {
  public static void main(String[] args)throws FileNotFoundException {
    FastScanner fs=new FastScanner();
    int a=fs.nextInt(),b=fs.nextInt(),c=fs.nextInt(),d=fs.nextInt();
    int p,q ;
    if(a*d>=b*c){
      p=a*d-b*c ;
      q=a*d ;
    }
    else {
      p=b*c-a*d ;
      q=b*c ;
    }
    int k=gcd(p,q);
    p/=k ;
    q/=k ;
    System.out.println(p+"/"+q);
  }
  static int gcd(int a,int b){
    return b==0 ? a : gcd(b,a % b);
  }
  static void sort(int[] a){
    ArrayList<Integer>l=new ArrayList<>();
    for(int i : a)l.add(i);
    Collections.sort(l);
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var a : int ; a := fs.nextInt() ;
    var b : int ; b := fs.nextInt() ;
    var c : int ; c := fs.nextInt() ;
    var d : int ; d := fs.nextInt() ;
    var p : int ;
    var q : int ;
    if (a * d >= b * c) then (     p := a * d - b * c ; 
     q := a * d ) else (     p := b * c - a * d ; 
     q := b * c ) ;  
    var k : int ; k := gcd(p, q) ;
    p := p/(k) ; 
    q := q/(k) ; 
    OclFile["System.out"].println(p + "/" + q) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l := l->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.math.BigDecimal ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  private static Scanner scanner ;
  private static PrintWriter writer ;
  private static int nod ;
  private static String numbers=new String();
  private static Set<BigDecimal>allNumbers=new HashSet<>();
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    writer=new PrintWriter(System.out,true);
    writer.flush();
    nod=scanner.nextInt();
    for(int i=0 ; i<nod ; i++){
      int number=scanner.nextInt();
      numbers+=Integer.toString(number);
    }
    String res="0" ;
    for(int i=0 ; ; i++){
      String str=String.valueOf(i);
      int startIndex=0 ;
      String scanStr=numbers ;
      for(int j=0 ; j<str.length(); j++){
        if(! numbers.contains(str)){
          res=String.valueOf(i);
          writer.println(res);
          scanner.close();
          writer.close();
          return ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   attribute writer : OclFile;
  static   attribute nod : int;
  static   attribute numbers : String := StringLib.newString();
  static   attribute allNumbers : Set(double) := Set{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     writer := OclFile.newOclFile_Write(OclFile["System.out"], true) ; 
    skip ; 
    nod := scanner.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < nod do ( (     var number : int ; number := scanner.getCurrent()->toInteger() ;
     numbers := numbers+(((number) + "")) )  ;     i := i + 1 ) ; 
    var res : String ; res := "0" ;
        var i : int ; i := 0 ; while true do ( (     var str : String ; str := ((i) + "") ;
     var startIndex : int ; startIndex := 0 ;
     var scanStr : String ; scanStr := numbers ;
         var j : int ; j := 0 ; while j < str->size() do ( (     if (not(numbers->includes(str))) then (     res := ((i) + "") ; 
     skip ; 
    skip ; 
    skip ; 
    return 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static void solve(){
    int n=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    boolean[] g=new boolean[10000];
    for(int i=0 ; i<10000 ; i++){
      if(g[i])continue ;
      int d=1 ;
      while(i/(int)Math.pow(10,d)!=0)d++;
      boolean f=false ;
      for(int j=0 ; j<n ; j++){
        int p=0,dig=1 ;
        if(j+d-1>=n)break ;
        for(int k=j+d-1 ; k>=j ; k--){
          p+=dig*a[k];
          dig*=10 ;
        }
        g[p]=true ;
        if(p==i){
          f=true ;
          break ;
        }
      }
      if(! f){
        out.println(i);
        return ;
      }
    }
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    solve();
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var g : Sequence(boolean) ; g := Integer.subrange(1,10000)->collect(false) ;
        var i : int ; i := 0 ; while i < 10000 do ( (     if (g[i+1]) then     continue else skip ; 
     var d : int ; d := 1 ;
    while (i / 10->pow(d)->oclAsType(int) /= 0) do     d := d + 1 ; ; 
    var f : boolean ; f := false ;
        var j : int ; j := 0 ; while j < n do ( (     var p : int ; p := 0 ;
    var dig : int ; dig := 1 ;
     if (j + d - 1 >= n) then     break else skip ; 
        var k : int ; k := j + d - 1 ; while k >= j do ( (     p := p+(dig * a[k+1]) ; 
     dig := dig*(10) )  ;     k := k - 1 ) ; 
    g[p+1] := true ; 
    if (p = i) then (     f := true ; 
     break ) else skip ; 
 )  ;     j := j + 1 ) ; 
    if (not(f)) then (     skip ; 
     return ) else skip ; 
 )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    execute solve() ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  Scanner sc=new Scanner(System.in);
  int[] memo=new int[1000];
  public void run(){
    int n=sc.nextInt();
    calc(n);
  }
  public void calc(int n){
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      int sum=0 ;
      for(int j=0 ; j<3 ; j++){
        if(i+j<n){
          sum=sum*10+nums[i+j];
          memo[sum]=1 ;
        }
      }
    }
    for(int i=0 ; i<1000 ; i++){
      if(memo[i]==0){
        System.out.println(i);
        break ;
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute memo : Sequence(int) := Integer.subrange(1,1000)->collect(0);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     execute calc(n) );
   operation calc( n : int) : void
  pre: true
  post: true
  activity: (     var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < 3 do ( (     if (i + j < n) then (     sum := sum * 10 + nums[i + j+1] ; 
     memo[sum+1] := 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < 1000 do ( (     if (memo[i+1] = 0) then (     OclFile["System.out"].println(i) ; 
     break ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean containsElement(int[] arr,int n){
    int xorArr=0 ;
    for(int i=0 ; i<n ; ++i)xorArr ^=arr[i];
    for(int i=0 ; i<n ; ++i){
      int x=xorArr ^ arr[i];
      if(arr[i]==x)return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    int[] arr={
      8,2,4,15,1 };
      int n=arr.length ;
      if(containsElement(arr,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation containsElement( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var xorArr : int ; xorArr := 0 ;
         var i : int ; i := 0 ; while i < n do (     xorArr := MathLib.bitwiseXor(xorArr,arr[i+1]) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := MathLib.bitwiseXor(xorArr,arr[i+1]) ;
     if (arr[i+1] = x) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,2,4,15,1} ;
     var n : int ; n := arr->size() ;
     if (containsElement(arr, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int y=in.nextInt(),k=in.nextInt(),n=in.nextInt(),c=0 ;
    for(int i=1 ; i<=n/k ; i++){
      if((k*i-y)>0){
        System.out.print((k*i-y)+" ");
        c++;
      }
    }
    if(c==0)System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var y : int ; y := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
         var i : int ; i := 1 ; while i <= n / k do ( (     if ((k * i - y) > 0) then (     OclFile["System.out"].print((k * i - y) + " ") ; 
     c := c + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (c = 0) then     OclFile["System.out"].println(-1) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p287 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p287().run());
  }
  private static final int N=24 ;
  private static final long RADIUS_SQUARED=1L<<(2*N-2);
  public String run(){
    int temp=1<<(N-1);
    return compressedLength(N,-temp,temp,-temp,temp).toString();
  }
  private BigInteger compressedLength(int n,int xStart,int xEnd,int yStart,int yEnd){
    assert n>=0 ;
    assert xStart<xEnd && xEnd-xStart==1<<n ;
    assert yStart<yEnd && yEnd-yStart==1<<n ;
    int minAbsX=xStart<=0 && 0<xEnd ? 0 : Math.min(Math.abs(xStart),Math.abs(xEnd-1));
    int minAbsY=yStart<=0 && 0<yEnd ? 0 : Math.min(Math.abs(yStart),Math.abs(yEnd-1));
    int maxAbsX=Math.max(Math.abs(xStart),Math.abs(xEnd-1));
    int maxAbsY=Math.max(Math.abs(yStart),Math.abs(yEnd-1));
    long minRadius=(long)minAbsX*minAbsX+(long)minAbsY*minAbsY ;
    long maxRadius=(long)maxAbsX*maxAbsX+(long)maxAbsY*maxAbsY ;
    if(maxRadius<=RADIUS_SQUARED || minRadius>RADIUS_SQUARED)return BigInteger.valueOf(2);
    else {
      int xMid=(xStart+xEnd)/2 ;
      int yMid=(yStart+yEnd)/2 ;
      return BigInteger.ONE.add(compressedLength(n-1,xStart,xMid,yMid,yEnd)).add(compressedLength(n-1,xMid,xEnd,yMid,yEnd)).add(compressedLength(n-1,xStart,xMid,yStart,yMid)).add(compressedLength(n-1,xMid,xEnd,yStart,yMid));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class p287 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p287.newp287().run()) );
  static    attribute N : int := 24;
  static    attribute RADIUS_SQUARED : long := (1L*(2->pow((2 * N - 2))))->oclAsType(long);
   operation run() : String
  pre: true
  post: true
  activity: (     var temp : int ; temp := (1*(2->pow((N - 1))))->oclAsType(long) ;
     return compressedLength(N, -temp, temp, -temp, temp)+"" );
   operation compressedLength( n : int, xStart : int, xEnd : int, yStart : int, yEnd : int) : long
  pre: true
  post: true
  activity: (     assert n >= 0 ; 
     assert xStart < xEnd & xEnd - xStart = (1*(2->pow(n)))->oclAsType(long) ; 
    assert yStart < yEnd & yEnd - yStart = (1*(2->pow(n)))->oclAsType(long) ; 
    var minAbsX : int ; minAbsX := if xStart <= 0 & 0 < xEnd then 0 else Set{if xStart < 0 then -(xStart) else xStart endif, if xEnd - 1 < 0 then -(xEnd - 1) else xEnd - 1 endif}->min() endif ;
    var minAbsY : int ; minAbsY := if yStart <= 0 & 0 < yEnd then 0 else Set{if yStart < 0 then -(yStart) else yStart endif, if yEnd - 1 < 0 then -(yEnd - 1) else yEnd - 1 endif}->min() endif ;
    var maxAbsX : int ; maxAbsX := Set{if xStart < 0 then -(xStart) else xStart endif, if xEnd - 1 < 0 then -(xEnd - 1) else xEnd - 1 endif}->max() ;
    var maxAbsY : int ; maxAbsY := Set{if yStart < 0 then -(yStart) else yStart endif, if yEnd - 1 < 0 then -(yEnd - 1) else yEnd - 1 endif}->max() ;
    var minRadius : long ; minRadius := minAbsX->oclAsType(long) * minAbsX + minAbsY->oclAsType(long) * minAbsY ;
    var maxRadius : long ; maxRadius := maxAbsX->oclAsType(long) * maxAbsX + maxAbsY->oclAsType(long) * maxAbsY ;
    if (maxRadius <= RADIUS_SQUARED or minRadius > RADIUS_SQUARED) then     return (2 + "")->toLong() else (     var xMid : int ; xMid := (xStart + xEnd) / 2 ;
     var yMid : int ; yMid := (yStart + yEnd) / 2 ;
     return 1->excludes(compressedLength(n - 1, xStart, xMid, yMid, yEnd))->excludes(compressedLength(n - 1, xMid, xEnd, yMid, yEnd))->excludes(compressedLength(n - 1, xStart, xMid, yStart, yMid))->excludes(compressedLength(n - 1, xMid, xEnd, yStart, yMid)) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void greaterK(int n,int k){
    int[] p=new int[String.valueOf(n).length()+2];
    int index=0 ;
    int x=n ;
    while(x>0){
      p[index]=(int)(x % k);
      x/=k ;
      index++;
    }
    int idx=0 ;
    for(int i=0 ; i<p.length-1 ; ++i){
      if(p[i]>=2){
        p[i]=0 ;
        p[i+1]++;
        for(int j=idx ; j<i ; ++j){
          p[j]=0 ;
        }
        idx=i+1 ;
      }
      if(p[i]==k){
        p[i]=0 ;
        p[i+1]++;
      }
    }
    int j=p.length-1 ;
    if(p[j]>=2){
      p[index]=1 ;
      index++;
    }
    int ans=0 ;
    for(int i=p.length-1 ; i>=0 ; --i){
      ans=ans*k+p[i];
    }
    System.out.print(ans+"\n");
  }
  public static void main(String[] args){
    int n=29,k=7 ;
    greaterK(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation greaterK( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var p : Sequence(int) ; p := Integer.subrange(1,((n) + "")->size() + 2)->collect(0) ;
     var index : int ; index := 0 ;
    var x : int ; x := n ;
    while (x > 0) do (     p[index+1] := (x mod k)->oclAsType(int) ; 
     x := x/(k) ; 
     index := index + 1 ) ; 
    var idx : int ; idx := 0 ;
        var i : int ; i := 0 ; while i < p->size() - 1 do ( (     if (p[i+1] >= 2) then (     p[i+1] := 0 ; 
     p[i + 1+1] := p[i + 1+1] + 1 ; 
         var j : int ; j := idx ; while j < i do ( (     p[j+1] := 0 )  ;     j := j + 1 ) ; 
     idx := i + 1 ) else skip ; 
     if (p[i+1] = k) then (     p[i+1] := 0 ; 
     p[i + 1+1] := p[i + 1+1] + 1 ) else skip )  ;     i := i + 1 ) ; 
    var j : int ; j := p->size() - 1 ;
    if (p[j+1] >= 2) then (     p[index+1] := 1 ; 
     index := index + 1 ) else skip ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := p->size() - 1 ; while i >= 0 do ( (     ans := ans * k + p[i+1] )  ;     i := i - 1 ) ; 
    OclFile["System.out"].print(ans + "\n") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 29 ;
    var k : int ; k := 7 ;
     execute greaterK(n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  private static final int N=999983 ;
  public void run(final java.util.Scanner sc,final java.io.PrintStream out){
    final int[] sum=new int[N+1];
    int i,j ;
    java.util.Arrays.fill(sum,2,sum.length,1);
    for(i=2 ; i*i<sum.length ; ++i){
      if(sum[i]==0)continue ;
      for(j=i+i ; j<sum.length ; j+=i)sum[j]=0 ;
    }
    for(i=1 ; i<sum.length ; ++i)sum[i]+=sum[i-1];
    for(; ; ){
      int res ;
      int n ;
      n=sc.nextInt();
      if(n==0)break ;
      res=-n ;
      for(i=0 ; i<n ; ++i){
        int p,m ;
        p=sc.nextInt();
        m=sc.nextInt();
        res+=sum[Math.min(sum.length-1,p+m)]-sum[Math.max(0,p-m-1)];
      }
      out.println(res);
    }
  }
  public static void main(final String[] args){
(new Main()).run(new java.util.Scanner(System.in),System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static    attribute N : int := 999983;
   operation run( sc : Scanner, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sum : Sequence(int) ; sum := Integer.subrange(1,N + 1)->collect(0) ;
     var i : int ;
    var j : int ;
    java.util.Arrays.fill(sum, 2, sum->size(), 1) ; 
        i := 2 ; while i * i < sum->size() do ( (     if (sum[i+1] = 0) then     continue else skip ; 
         j := i + i ; while j < sum->size() do (     sum[j+1] := 0 ;  ;     j := j+(i) ) )  ;     i := i + 1 ) ; 
        i := 1 ; while i < sum->size() do (     sum[i+1] := sum[i+1]+(sum[i - 1+1]) ;  ;     i := i + 1 ) ; 
      while true do ( (     var res : int ;
     var n : int ;
    n := sc.nextInt() ; 
    if (n = 0) then     break else skip ; 
    res := -n ; 
        i := 0 ; while i < n do ( (     var p : int ;
    var m : int ;
     p := sc.nextInt() ; 
     m := sc.nextInt() ; 
     res := res+(sum[Set{sum->size() - 1, p + m}->min()+1] - sum[Set{0, p - m - 1}->max()+1]) )  ;     i := i + 1 ) ; 
    out.println(res) ; 
 )  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(Scanner.newScanner(OclFile["System.in"]), OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import static java.lang.Integer.parseInt ;
public class Main {
  static final int MAX=1_000_000 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    boolean[] ps=primes(MAX);
    int[] count=new int[ps.length];
    for(int i=1 ; i<count.length ; i++){
      count[i]=count[i-1]+(ps[i] ? 1 : 0);
    }
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=parseInt(line);
      if(n==0)break ;
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        line=br.readLine();
        int p,m,s,t ;
        p=parseInt(line.substring(0,line.indexOf(' ')));
        m=parseInt(line.substring(line.indexOf(' ')+1));
        s=p-m-1 ;
        t=p+m ;
        if(p-m-1<0)s=1 ;
        if(p+m>MAX)t=MAX ;
        sum+=count[t]-count[s]-1 ;
      }
      System.out.println(sum);
    }
  }
  static boolean[] primes(int limit){
    boolean[] ps=new boolean[limit+1];
    int _limit=(int)Math.sqrt(ps.length)+1 ;
    Arrays.fill(ps,2,ps.length,true);
    for(int i=2 ; i<=_limit ; i++){
      if(ps[i]){
        for(int j=i*2 ; j<ps.length ; j+=i){
          if(ps[j])ps[j]=false ;
        }
      }
    }
    return ps ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 1_000_000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var ps : Sequence(boolean) ; ps := primes(MAX) ;
    var count : Sequence(int) ; count := Integer.subrange(1,ps->size())->collect(0) ;
        var i : int ; i := 1 ; while i < count->size() do ( (     count[i+1] := count[i - 1+1] + (if ps[i+1] then 1 else 0 endif) )  ;     i := i + 1 ) ; 
        line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := parseInt(line) ;
     if (n = 0) then     break else skip ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     line := br.readLine() ; 
     var p : int ;
    var m : int ;
    var s : int ;
    var t : int ;
    p := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    m := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    s := p - m - 1 ; 
    t := p + m ; 
    if (p - m - 1 < 0) then     s := 1 ; else skip ; 
    if (p + m > MAX) then     t := MAX ; else skip ; 
    sum := sum+(count[t+1] - count[s+1] - 1) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;     line := br.readLine() ;
 ) ;  
 );
  static   operation primes( limit : int) : Sequence(boolean)
  pre: true
  post: true
  activity: (     var ps : Sequence(boolean) ; ps := Integer.subrange(1,limit + 1)->collect(false) ;
     var _limit : int ; _limit := (ps->size())->sqrt()->oclAsType(int) + 1 ;
    ps := ps->collect(true) ; 
        var i : int ; i := 2 ; while i <= _limit do ( (     if (ps[i+1]) then (         var j : int ; j := i * 2 ; while j < ps->size() do ( (     if (ps[j+1]) then     ps[j+1] := false ; else skip )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    return ps 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.lang.*;
import java.util.*;
public class solution1 {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    int[] arr={
      a,b,c };
      Arrays.sort(arr);
      int answer=0 ;
      int diff=Math.abs(arr[0]-arr[1]);
      int diff1=Math.abs((arr[1]-arr[2]));
      if(diff>=d && diff1>=d)System.out.println(0);
      if(diff<d){
        answer+=d-diff ;
      }
      if(diff1<d)answer+=d-diff1 ;
      if(answer!=0)System.out.println(answer);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Sequence{a,b,c} ;
    arr := arr->sort() ; 
    var answer : int ; answer := 0 ;
    var diff : int ; diff := if arr[0+1] - arr[1+1] < 0 then -(arr[0+1] - arr[1+1]) else arr[0+1] - arr[1+1] endif ;
    var diff1 : int ; diff1 := if (arr[1+1] - arr[2+1]) < 0 then -((arr[1+1] - arr[2+1])) else (arr[1+1] - arr[2+1]) endif ;
    if (diff >= d & diff1 >= d) then     OclFile["System.out"].println(0) ; else skip ; 
    if (diff < d) then (     answer := answer+(d - diff) ) else skip ; 
    if (diff1 < d) then     answer := answer+(d - diff1) ; else skip ; 
    if (answer /= 0) then     OclFile["System.out"].println(answer) ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static ArrayList<Integer>list=new ArrayList<Integer>();
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    makePrimeList();
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        int p=sc.nextInt();
        int m=sc.nextInt();
        if(m==0){
          if(Collections.binarySearch(list,p)<0){
            sum-=1 ;
          }
          continue ;
        }
        else {
          int min=Collections.binarySearch(list,p-m);
          if(min<0){
            min*=-1 ;
            min-=1 ;
          }
          int max=Collections.binarySearch(list,p+m);
          if(max<0){
            max*=-1 ;
            max-=2 ;
          }
          sum+=max-min ;
        }
      }
      System.out.println(sum);
    }
  }
  static void makePrimeList(){
    boolean[] isntPrime=new boolean[1000000];
    int i=2 ;
    for(; i*i<isntPrime.length ; i++){
      if(! isntPrime[i]){
        list.add(i);
        for(int j=i+i ; j<isntPrime.length ; j+=i){
          isntPrime[j]=true ;
        }
      }
    }
    for(; i<isntPrime.length ; i++){
      if(! isntPrime[i]){
        list.add(i);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute list : Sequence(int) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute makePrimeList() ; 
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var p : int ; p := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     if (m = 0) then (     if ((list->indexOf(p) - 1) < 0) then (     sum := sum-(1) ) else skip ; 
     continue ) else (     var min : int ; min := .binarySearch(list, p - m) ;
     if (min < 0) then (     min := min*(-1) ; 
     min := min-(1) ) else skip ; 
    var max : int ; max := .binarySearch(list, p + m) ;
    if (max < 0) then (     max := max*(-1) ; 
     max := max-(2) ) else skip ; 
    sum := sum+(max - min) ; 
 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) );
  static   operation makePrimeList() : void
  pre: true
  post: true
  activity: (     var isntPrime : Sequence(boolean) ; isntPrime := Integer.subrange(1,1000000)->collect(false) ;
     var i : int ; i := 2 ;
       while i * i < isntPrime->size() do ( (     if (not(isntPrime[i+1])) then (     list := list->including(i) ; 
         var j : int ; j := i + i ; while j < isntPrime->size() do ( (     isntPrime[j+1] := true )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
       while i < isntPrime->size() do ( (     if (not(isntPrime[i+1])) then (     list := list->including(i) ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int[] p={
      25,18,15,12,10,8,6,4,2,1 };
      Map<String,Driver>map=new HashMap<>();
      int t=s.nextInt();
      for(int i=0 ; i<t ; i++){
        int n=s.nextInt();
        for(int j=0 ; j<n ; j++){
          String name=s.next();
          Driver d=map.computeIfAbsent(name,k->new Driver(name));
          d.places[j]++;
          if(j<10)d.score+=p[j];
        }
      }
      List<Driver>drivers=new ArrayList<>(map.values());
      drivers.sort((s1,s2)->{
        int diffPts=s2.score-s1.score ;
        if(diffPts!=0)return diffPts ;
        for(int i=0 ; i<50 ; i++){
          diffPts=s2.places[i]-s1.places[i];
          if(diffPts!=0)return diffPts ;
        }
        return 0 ;
      }
);
      System.out.println(drivers.get(0).name);
      drivers.sort((s1,s2)->{
        int firstPlaces=s2.places[0]-s1.places[0];
        if(firstPlaces!=0)return firstPlaces ;
        int diffPts=s2.score-s1.score ;
        if(diffPts!=0)return diffPts ;
        for(int i=1 ; i<50 ; i++){
          diffPts=s2.places[i]-s1.places[i];
          if(diffPts!=0)return diffPts ;
        }
        return 0 ;
      }
);
      System.out.println(drivers.get(0).name);
      s.close();
    }
    public static class Driver {
      String name ;
      int score ;
      int[] places ;
      public Driver(String nm){
        name=nm ;
        score=0 ;
        places=new int[50];
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : Sequence(int) ; p := Sequence{25,18,15,12,10,8,6,4,2,1} ;
    var map : Map(String,Driver) ; map := Map{} ;
    var t : int ; t := s.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := s.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < n do ( (     var name : String ; name := s.getCurrent() ;
     var d : Driver ; d := map.computeIfAbsent(name, lambda k : OclAny in Driver.newDriver(name)) ;
     d.places[j+1] := d.places[j+1] + 1 ; 
     if (j < 10) then     d.score := d.score+(p[j+1]) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var drivers : Sequence(Driver) ; drivers := Sequence{}->union(map->values()) ;
    drivers := drivers.sort(lambda (s1 , s2) : OclAny in (     var diffPts : int ; diffPts := s2.score - s1.score ;
     if (diffPts /= 0) then     return diffPts else skip ; 
         var i : int ; i := 0 ; while i < 50 do ( (     diffPts := s2.places[i+1] - s1.places[i+1] ; 
     if (diffPts /= 0) then     return diffPts else skip )  ;     i := i + 1 ) ; 
     return 0 )) ; 
    OclFile["System.out"].println(drivers->at(0+1).name) ; 
    drivers := drivers.sort(lambda (s1 , s2) : OclAny in (     var firstPlaces : int ; firstPlaces := s2.places[0+1] - s1.places[0+1] ;
     if (firstPlaces /= 0) then     return firstPlaces else skip ; 
    var diffPts : int ; diffPts := s2.score - s1.score ;
    if (diffPts /= 0) then     return diffPts else skip ; 
        var i : int ; i := 1 ; while i < 50 do ( (     diffPts := s2.places[i+1] - s1.places[i+1] ; 
     if (diffPts /= 0) then     return diffPts else skip )  ;     i := i + 1 ) ; 
    return 0 
 )) ; 
    OclFile["System.out"].println(drivers->at(0+1).name) ; 
    skip ; 
 );
  static class Driver {
   attribute name : String;
   attribute score : int;
   attribute places : Sequence(int);
   static operation newDriver( nm : String) : Driver
  pre: true
  post: true
  activity:
  ( var self : Driver ;
    self := createDriver();
    self.initialise(nm);
    return self );
  operation initialise( nm : String) : void
  pre: true  post: true
  activity: (     name := nm ; 
     score := 0 ; 
     places := Integer.subrange(1,50)->collect(0) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; ++i){
        a[i]=sc.nextInt();
      }
      System.out.println(solve(a)? "YES" : "NO");
    }
    sc.close();
  }
  static boolean solve(int[] a){
    return ! IntStream.range(0,a.length-1).allMatch(i->a[i]>a[i+1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if solve(a) then "YES" else "NO" endif) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     return not(Integer.subrange(0, a->size() - 1-1)->forAll( _x2 | (lambda i : OclAny in a[i+1] > a[i + 1+1])->apply(_x2) )) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Random ;
import java.util.StringTokenizer ;
import java.util.Collections ;
import java.util.ArrayList ;
import java.util.TreeSet ;
import java.util.Random ;
public class A {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    int T=fs.nextInt();
    outer : for(int tt=0 ;
    tt<T ;
    tt++){
      int n=fs.nextInt();
      int[] a=fs.readArray(n);
      for(int i=0 ; i+1<n ; i++){
        if(a[i]<=a[i+1]){
          System.out.println("YES");
          continue outer ;
        }
      }
      System.out.println("NO");
    }
  }
  static final Random random=new Random();
  static void sort(int[] a){
    ArrayList<Integer>l=new ArrayList<>();
    for(int i : a)l.add(i);
    Collections.sort(l);
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var T : int ; T := fs.nextInt() ;
         var tt : int ; tt := 0 ; while tt < T do ( (     var n : int ; n := fs.nextInt() ;
     var a : Sequence(int) ; a := fs.readArray(n) ;
         var i : int ; i := 0 ; while i + 1 < n do ( (     if (a[i+1] <= a[i + 1+1]) then (     OclFile["System.out"].println("YES") ; 
     continue ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("NO") )  ;     tt := tt + 1 ) ; );
  static    attribute random : OclRandom := OclRandom.newOclRandom();
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l := l->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Calendar ;
import java.util.Locale ;
final class Main {
  private Main(){
  }
  public static void main(final String[] argv)throws IOException {
    final BufferedReader inputReader=new BufferedReader(new InputStreamReader(System.in));
    Calendar calendar=Calendar.getInstance();
    while(true){
      String input=inputReader.readLine();
      if(input==null){
        break ;
      }
      String[] inputs=input.split(" ");
      if(inputs[0] .equals("0")){
        break ;
      }
      calendar.set(2004,Integer.parseInt(inputs[0])-1,Integer.parseInt(inputs[1]));
      final String week=calendar.getDisplayName(Calendar.DAY_OF_WEEK,Calendar.LONG,Locale.ENGLISH);
      System.out.println(week);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
  static   operation main( argv : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputReader : OclFile ; inputReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var calendar : OclDate ; calendar := OclDate.newOclDate() ;
     while (true) do (     var input : String ; input := inputReader.readLine() ;
     if (input = null) then (     break ) else skip ; 
    var inputs : Sequence(String) ; inputs := input->split(" ") ;
    if (inputs[0+1] = "0") then (     break ) else skip ; 
    calendar := calendar.setAt(2004+1, (inputs[1+1])->toInteger()) ; 
    var week : String ; week := calendar.getDisplayName(DAY_OF_WEEK, LONG, Locale.ENGLISH) ;
    OclFile["System.out"].println(week) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import javax.security.auth.kerberos.KerberosKey ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int[] x=new int[n+1];
    x[0]=-1 ;
    for(int i=1 ; i<=n ; i++){
      x[i]=sc.nextInt();
    }
    int max=a ;
    for(int i=0 ; i<n ; i++){
      max=Math.max(max,x[i]);
    }
    int X=max*n ;
    long[][][] dp=new long[n+1][n+1][X+1];
    dp[0][0][0]=1 ;
    for(int j=1 ; j<=n ; j++){
      for(int k=0 ; k<=n ; k++){
        for(int s=0 ; s<=X ; s++){
          if(j==0 && k==0 && s==0){
            continue ;
          }
          long count=0 ;
          if(s>=x[j] && k>=1){
            count+=dp[j-1][k][s];
            count+=dp[j-1][k-1][s-x[j] ];
          }
          else if(s<x[j]){
            count+=dp[j-1][k][s];
          }
          dp[j][k][s]=count ;
        }
      }
    }
    long sum=0 ;
    for(int k=1 ; k<=n ; k++){
      sum+=dp[n][k][k*a];
    }
    System.out.println(sum);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n + 1)->collect(0) ;
    x[0+1] := -1 ; 
        var i : int ; i := 1 ; while i <= n do ( (     x[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var max : int ; max := a ;
        var i : int ; i := 0 ; while i < n do ( (     max := Set{max, x[i+1]}->max() )  ;     i := i + 1 ) ; 
    var X : int ; X := max * n ;
    var dp : Sequence(Sequence(Sequence(long))) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(Integer.subrange(1,X + 1)->collect(0))) ;
    dp[0+1][0+1][0+1] := 1 ; 
        var j : int ; j := 1 ; while j <= n do ( (         var k : int ; k := 0 ; while k <= n do ( (         var s : int ; s := 0 ; while s <= X do ( (     if (j = 0 & k = 0 & s = 0) then (     continue ) else skip ; 
     var count : long ; count := 0 ;
     if (s >= x[j+1] & k >= 1) then (     count := count+(dp[j - 1+1][k+1][s+1]) ; 
     count := count+(dp[j - 1+1][k - 1+1][s - x[j+1]+1]) ) else     if (s < x[j+1]) then (     count := count+(dp[j - 1+1][k+1][s+1]) ) else skip ; ;  
     dp[j+1][k+1][s+1] := count )  ;     s := s + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    var sum : long ; sum := 0 ;
        var k : int ; k := 1 ; while k <= n do ( (     sum := sum+(dp[n+1][k+1][k * a+1]) )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class awe {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    int n,k,max,before,first,now,a,b,c ;
    for(int i=0 ; i<t ; i++){
      n=input.nextInt();
      k=input.nextInt();
      first=input.nextInt();
      max=0 ;
      before=first ;
      for(int j=1 ; j<k ; j++){
        now=input.nextInt();
        a=now-before+1 ;
        if(a>max)max=a ;
        before=now ;
      }
      max=(max+1)/2 ;
      b=n-before+1 ;
      max=b>max ? b : max ;
      max=first>max ? first : max ;
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class awe {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
     var n : int ;
    var k : int ;
    var max : int ;
    var before : int ;
    var first : int ;
    var now : int ;
    var a : int ;
    var b : int ;
    var c : int ;
         var i : int ; i := 0 ; while i < t do ( (     n := input.getCurrent()->toInteger() ; 
     k := input.getCurrent()->toInteger() ; 
    first := input.getCurrent()->toInteger() ; 
    max := 0 ; 
    before := first ; 
        var j : int ; j := 1 ; while j < k do ( (     now := input.getCurrent()->toInteger() ; 
     a := now - before + 1 ; 
     if (a > max) then     max := a ; else skip ; 
     before := now )  ;     j := j + 1 ) ; 
    max := (max + 1) / 2 ; 
    b := n - before + 1 ; 
    max := if b > max then b else max endif ; 
    max := if first > max then first else max endif ; 
    OclFile["System.out"].println(max) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static boolean isSorted(int[] array){
    for(int i=0 ; i<array.length-1 ; i++){
      if(array[i]>array[i+1])return false ;
    }
    return true ;
  }
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        int n=sc.nextInt();
        int[] arr=new int[n];
        for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
        int opr=((n*(n-1))/2)-1 ;
        boolean ok=false ;
        if(isSorted(arr))System.out.println("YES");
        else {
          for(int i=1 ; i<n ; i++){
            if(arr[i]>=arr[i-1]){
              ok=true ;
              break ;
            }
          }
          if(ok)System.out.println("YES");
          else System.out.println("NO");
        }
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation isSorted( array : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < array->size() - 1 do ( (     if (array[i+1] > array[i + 1+1]) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var opr : int ; opr := ((n * (n - 1)) / 2) - 1 ;
    var ok : boolean ; ok := false ;
    if (isSorted(arr)) then     OclFile["System.out"].println("YES") else (         var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] >= arr[i - 1+1]) then (     ok := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (ok) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) ;  
 ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1420 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      int[] A=new int[N];
      for(int n=0 ; n<N ; n++){
        A[n]=in.nextInt();
      }
      boolean ok=false ;
      for(int n=1 ; n<N ; n++){
        if(A[n-1]<=A[n]){
          ok=true ;
          break ;
        }
      }
      System.out.println(ok ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1420 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var ok : boolean ; ok := false ;
        var n : int ; n := 1 ; while n < N do ( (     if (A[n - 1+1] <= A[n+1]) then (     ok := true ; 
     break ) else skip )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(if ok then "YES" else "NO" endif) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  static final int INF=0x3f3f3f3f ;
  static final long LNF=0x3f3f3f3f3f3f3f3fL ;
  public static void main(String[] args)throws IOException {
    initReader();
    int a[]=new int[3];
    for(int i=0 ; i<3 ; i++){
      a[i]=nextInt();
    }
    int d=nextInt();
    Arrays.sort(a);
    int a1=a[1]-a[0],a2=a[2]-a[1];
    if(a1>=d)a1=d ;
    if(a2>=d)a2=d ;
    pw.println(2*d-a1-a2);
    pw.close();
  }
  static BufferedReader reader ;
  static StringTokenizer tokenizer ;
  static PrintWriter pw ;
  public static void initReader()throws IOException {
    reader=new BufferedReader(new InputStreamReader(System.in));
    tokenizer=new StringTokenizer("");
    pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  }
  public static boolean hasNext(){
    try {
      while(! tokenizer.hasMoreTokens()){
        tokenizer=new StringTokenizer(reader.readLine());
      }
    }
    catch(Exception e){
      return false ;
    }
    return true ;
  }
  public static String next()throws IOException {
    while(! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  public static String nextLine(){
    try {
      return reader.readLine();
    }
    catch(Exception e){
      return null ;
    }
  }
  public static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public static long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public static char nextChar()throws IOException {
    return next().charAt(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := 0x3f3f3f3f;
  static    attribute LNF : long := 0x3f3f3f3f3f3f3f3fL;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute initReader() ; 
     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     a[i+1] := nextInt() )  ;     i := i + 1 ) ; 
    var d : int ; d := nextInt() ;
    a := a->sort() ; 
    var a1 : int ; a1 := a[1+1] - a[0+1] ;
    var a2 : int ; a2 := a[2+1] - a[1+1] ;
    if (a1 >= d) then     a1 := d ; else skip ; 
    if (a2 >= d) then     a2 := d ; else skip ; 
    pw.println(2 * d - a1 - a2) ; 
    pw.close() ; 
 );
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   attribute pw : OclFile;
  static   operation initReader() : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := OclIterator.newOclIterator_String("") ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) );
  static   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     try (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (e : ProgramException) do (     return false )
     return true );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : ProgramException) do (     return null )
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  int[][] map ;
  int w,h ;
  int[] ax={
-1,0,1,1,1,0,-1,-1 };
    int[] ay={
-1,-1,-1,0,1,1,1,0 };
      void run(){
        Scanner sc=new Scanner(System.in);
        while(true){
          w=sc.nextInt();
          h=sc.nextInt();
          if((w | h)==0){
            break ;
          }
          map=new int[h][w];
          for(int j=0 ; j<h ; j++){
            for(int i=0 ; i<w ; i++){
              map[j][i]=sc.nextInt();
            }
          }
          int cnt=0 ;
          for(int j=0 ; j<h ; j++){
            for(int i=0 ; i<w ; i++){
              if(map[j][i]==1){
                search(i,j);
                cnt++;
              }
            }
          }
          System.out.println(cnt);
        }
      }
      public static void main(String[] args){
        new Main().run();
      }
      public void search(int x,int y){
        if(x<0 || y<0 || x>=w || y>=h || map[y][x]==0){
          return ;
        }
        map[y][x]=0 ;
        for(int i=0 ; i<8 ; i++){
          int nx=x+ax[i];
          int ny=y+ay[i];
          search(nx,ny);
        }
      }
      public void debug(){
        System.out.println("---------------");
        for(int j=0 ; j<h ; j++){
          for(int i=0 ; i<w ; i++){
            System.out.print(map[j][i]+" ");
          }
          System.out.println();
        }
        System.out.println("---------------");
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute map : Sequence(Sequence(int));
   attribute w : int;
   attribute ax : Sequence(int) := Sequence{-1,0,1,1,1,0,-1,-1};
   attribute ay : Sequence(int) := Sequence{-1,-1,-1,0,1,1,1,0};
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     w := sc.getCurrent()->toInteger() ; 
     h := sc.getCurrent()->toInteger() ; 
    if ((MathLib.bitwiseOr(w,h)) = 0) then (     break ) else skip ; 
    map := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ; 
        var j : int ; j := 0 ; while j < h do ( (         var i : int ; i := 0 ; while i < w do ( (     map[j+1][i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var j : int ; j := 0 ; while j < h do ( (         var i : int ; i := 0 ; while i < w do ( (     if (map[j+1][i+1] = 1) then (     execute search(i, j) ; 
     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation search( x : int, y : int) : void
  pre: true
  post: true
  activity: (     if (x < 0 or y < 0 or x >= w or y >= h or map[y+1][x+1] = 0) then (     return ) else skip ; 
     map[y+1][x+1] := 0 ; 
         var i : int ; i := 0 ; while i < 8 do ( (     var nx : int ; nx := x + ax[i+1] ;
     var ny : int ; ny := y + ay[i+1] ;
     execute search(nx, ny) )  ;     i := i + 1 ) );
   operation debug() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("---------------") ; 
         var j : int ; j := 0 ; while j < h do ( (         var i : int ; i := 0 ; while i < w do ( (     OclFile["System.out"].print(map[j+1][i+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("---------------") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static boolean[][] visited ;
  public static int[][] map ;
  public static void CheckIsland(int a,int b,int w,int h){
    visited[a][b]=true ;
    for(int i=-1 ; i<2 ; i++){
      for(int k=-1 ; k<2 ; k++){
        int a2=a+i ;
        int b2=b+k ;
        if(a2>=0 && b2>=0 && a2<h && b2<w && visited[a2][b2]==false && map[a2][b2]==1){
          visited[a2][b2]=true ;
          CheckIsland(a2,b2,w,h);
        }
      }
    }
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(true){
      int numberOfIslands=0 ;
      int w=in.nextInt();
      int h=in.nextInt();
      if(w==0 || h==0)break ;
      map=new int[h][w];
      visited=new boolean[h][w];
      for(int i=0 ; i<h ; i++){
        for(int k=0 ; k<w ; k++){
          map[i][k]=in.nextInt();
          visited[i][k]=false ;
        }
      }
      for(int i=0 ; i<h ; i++){
        for(int k=0 ; k<w ; k++){
          if(map[i][k]==1 && visited[i][k]==false){
            numberOfIslands++;
            CheckIsland(i,k,w,h);
          }
        }
      }
      System.out.println(numberOfIslands);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute visited : Sequence(Sequence(boolean));
  static   attribute map : Sequence(Sequence(int));
  static   operation CheckIsland( a : int, b : int, w : int, h : int) : void
  pre: true
  post: true
  activity: (     visited[a+1][b+1] := true ; 
         var i : int ; i := -1 ; while i < 2 do ( (         var k : int ; k := -1 ; while k < 2 do ( (     var a2 : int ; a2 := a + i ;
     var b2 : int ; b2 := b + k ;
     if (a2 >= 0 & b2 >= 0 & a2 < h & b2 < w & visited[a2+1][b2+1] = false & map[a2+1][b2+1] = 1) then (     visited[a2+1][b2+1] := true ; 
     execute CheckIsland(a2, b2, w, h) ) else skip )  ;     k := k + 1 ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var numberOfIslands : int ; numberOfIslands := 0 ;
     var w : int ; w := in.getCurrent()->toInteger() ;
    var h : int ; h := in.getCurrent()->toInteger() ;
    if (w = 0 or h = 0) then     break else skip ; 
    map := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ; 
    visited := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(false)) ; 
        var i : int ; i := 0 ; while i < h do ( (         var k : int ; k := 0 ; while k < w do ( (     map[i+1][k+1] := in.getCurrent()->toInteger() ; 
     visited[i+1][k+1] := false )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < h do ( (         var k : int ; k := 0 ; while k < w do ( (     if (map[i+1][k+1] = 1 & visited[i+1][k+1] = false) then (     numberOfIslands := numberOfIslands + 1 ; 
     execute CheckIsland(i, k, w, h) ) else skip )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(numberOfIslands) ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.Math ;
public class Main {
  static int W ;
  static int H ;
  public static int[][] mp=new int[51][51];
  public static int countIsland(int h,int w){
    mp[h][w]=0 ;
    for(int i=-1 ; i<2 ; i++){
      for(int j=-1 ; j<2 ; j++){
        if(h+i>=H || h+i<0 || w+j>=W || w+j<0 ||(i==0 && j==0)){
        }
        else {
          if(mp[h+i][w+j]==1){
            countIsland(h+i,w+j);
          }
        }
      }
    }
    return 1 ;
  }
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    while(true){
      for(int i=0 ; i<51 ; i++){
        for(int j=0 ; j<51 ; j++){
          mp[i][j]=0 ;
        }
      }
      W=sc.nextInt();
      H=sc.nextInt();
      if(W==0 && H==0)break ;
      int cnt=0 ;
      for(int i=0 ; i<H ; i++){
        for(int j=0 ; j<W ; j++){
          mp[i][j]=sc.nextInt();
        }
      }
      for(int i=0 ; i<H ; i++){
        for(int j=0 ; j<W ; j++){
          if(mp[i][j]==1){
            countIsland(i,j);
            cnt++;
          }
        }
      }
      System.out.println(cnt);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute W : int;
  static   attribute H : int;
  static   attribute mp : Sequence(Sequence(int)) := Integer.subrange(1,51)->collect(Integer.subrange(1,51)->collect(0));
  static   operation countIsland( h : int, w : int) : int
  pre: true
  post: true
  activity: (     mp[h+1][w+1] := 0 ; 
         var i : int ; i := -1 ; while i < 2 do ( (         var j : int ; j := -1 ; while j < 2 do ( (     if (h + i >= H or h + i < 0 or w + j >= W or w + j < 0 or (i = 0 & j = 0)) then skip else (     if (mp[h + i+1][w + j+1] = 1) then (     execute countIsland(h + i, w + j) ) else skip ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (         var i : int ; i := 0 ; while i < 51 do ( (         var j : int ; j := 0 ; while j < 51 do ( (     mp[i+1][j+1] := 0 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     W := sc.getCurrent()->toInteger() ; 
    H := sc.getCurrent()->toInteger() ; 
    if (W = 0 & H = 0) then     break else skip ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     mp[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (mp[i+1][j+1] = 1) then (     execute countIsland(i, j) ; 
     cnt := cnt + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Scanner ;
public class Main {
  static final int[] dx={
    0,1,0,-1,1,-1,-1,1 },dy={
      1,0,-1,0,1,1,-1,-1 };
      static int w,h ;
      static int[][] board ;
      static class Pair {
        int x,y ;
        Pair(int x,int y){
          this.x=x ;
          this.y=y ;
        }
      }
      static void walk(int x,int y){
        ArrayDeque<Pair>que=new ArrayDeque<>();
        que.push(new Pair(x,y));
        while(! que.isEmpty()){
          Pair p=que.poll();
          board[p.y][p.x]=0 ;
          for(int i=0 ; i<8 ; ++i){
            int nx=p.x+dx[i],ny=p.y+dy[i];
            if(nx<0 || nx>=w || ny<0 || ny>=h)continue ;
            if(board[ny][nx]==1){
              que.push(new Pair(nx,ny));
            }
          }
        }
      }
      public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        while(true){
          w=scanner.nextInt();
          h=scanner.nextInt();
          if(w==0 && h==0)break ;
          board=new int[h][w];
          int ans=0 ;
          for(int i=0 ; i<h ; ++i){
            for(int j=0 ; j<w ; ++j){
              board[i][j]=scanner.nextInt();
            }
          }
          for(int i=0 ; i<h ; ++i){
            for(int j=0 ; j<w ; ++j){
              if(board[i][j]==1){
++ans ;
                walk(j,i);
              }
            }
          }
          System.out.println(ans);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute dx : Sequence(int) := Sequence{0,1,0,-1,1,-1,-1,1};
  static   attribute w : int;
  static   attribute board : Sequence(Sequence(int));
  static class Pair {
   attribute x : int;
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}
  static   operation walk( x : int, y : int) : void
  pre: true
  post: true
  activity: (     var que : Sequence(Map) ; que := ArrayDeque<OclAny>.newArrayDeque() ;
     que := que->append(Map(x, y)) ; 
     while (not(que->isEmpty())) do (     var p : Map ; p := que->min() ;
     board[p.y+1][p.x+1] := 0 ; 
         var i : int ; i := 0 ; while i < 8 do ( (     var nx : int ; nx := p.x + dx[i+1] ;
    var ny : int ; ny := p.y + dy[i+1] ;
     if (nx < 0 or nx >= w or ny < 0 or ny >= h) then     continue else skip ; 
     if (board[ny+1][nx+1] = 1) then (     que := que->append(Map(nx, ny)) ) else skip )  ;     i := i + 1 ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     w := scanner.getCurrent()->toInteger() ; 
     h := scanner.getCurrent()->toInteger() ; 
    if (w = 0 & h = 0) then     break else skip ; 
    board := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     board[i+1][j+1] := scanner.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (board[i+1][j+1] = 1) then (     ans := ans + 1 ; 
     execute walk(j, i) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Sea {
  private int w ;
  private int h ;
  private int atlas[][];
  public Sea(int w,int h,int[][] atlas){
    this.w=w ;
    this.h=h ;
    this.atlas=atlas ;
  }
  private void dfs(int x,int y){
    atlas[x][y]=0 ;
    for(int dx=-1 ; dx<=1 ; ++dx){
      for(int dy=-1 ; dy<=1 ; ++dy){
        int nx=x+dx ;
        int ny=y+dy ;
        if(out(nx,ny))continue ;
        if(atlas[nx][ny]==1)dfs(nx,ny);
      }
    }
  }
  public boolean in(int x,int y){
    return(0<=x && x<h)&&(0<=y && y<w);
  }
  public boolean out(int x,int y){
    return ! in(x,y);
  }
  public int countIsland(){
    int cnt=0 ;
    for(int x=0 ; x<h ; ++x)for(int y=0 ; y<w ; ++y)if(atlas[x][y]==1){
      dfs(x,y);
++cnt ;
    }
    return cnt ;
  }
}
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder out=new StringBuilder();
    while(true){
      int w=sc.nextInt();
      int h=sc.nextInt();
      if(w==0 && h==0)break ;
      int atlas[][]=new int[h][w];
      for(int i=0 ; i<h ; ++i)for(int j=0 ; j<w ; ++j)atlas[i][j]=sc.nextInt();
      Sea sea=new Sea(w,h,atlas);
      out.append(sea.countIsland()+"\n");
    }
    System.out.print(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sea {
   attribute w : int;
   attribute h : int;
   attribute atlas : Sequence(Sequence(int));
   static operation newSea( w : int, h : int, atlas : Sequence(Sequence(int))) : Sea
  pre: true
  post: true
  activity:
  ( var self : Sea ;
    self := createSea();
    self.initialise(w, h,atlas);
    return self );
  operation initialise( w : int, h : int, atlas : Sequence(Sequence(int))) : void
  pre: true  post: true
  activity: (     self.w := w ; 
     self.h := h ; 
     self.atlas := atlas );
   operation dfs( x : int, y : int) : void
  pre: true
  post: true
  activity: (     atlas[x+1][y+1] := 0 ; 
         var dx : int ; dx := -1 ; while dx <= 1 do ( (         var dy : int ; dy := -1 ; while dy <= 1 do ( (     var nx : int ; nx := x + dx ;
     var ny : int ; ny := y + dy ;
     if (out(nx, ny)) then     continue else skip ; 
     if (atlas[nx+1][ny+1] = 1) then     execute dfs(nx, ny) ; else skip )  ;     dy := dy + 1 ) )  ;     dx := dx + 1 ) );
   operation in( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return (0 <= x & x < h) & (0 <= y & y < w) );
   operation out( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return not(in(x, y)) );
   operation countIsland() : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var x : int ; x := 0 ; while x < h do (         var y : int ; y := 0 ; while y < w do (     if (atlas[x+1][y+1] = 1) then (     execute dfs(x, y) ; 
     cnt := cnt + 1 ) else skip ;  ;     y := y + 1 ) ;  ;     x := x + 1 ) ; 
     return cnt );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : String ; out := StringLib.newString() ;
     while (true) do (     var w : int ; w := sc.getCurrent()->toInteger() ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    if (w = 0 & h = 0) then     break else skip ; 
    var atlas : Sequence(Sequence(int)) ; atlas := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do (         var j : int ; j := 0 ; while j < w do (     atlas[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var sea : Sea ; sea := Sea.newSea(w, h, atlas) ;
    out := out + StringLib.newString(sea.countIsland() + "\n") ; 
 ) ; 
     OclFile["System.out"].print(out) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findCost(String str,int arr[],int n){
    long costofC=0,costofO=0,costofD=0,costofE=0 ;
    for(int i=0 ; i<n ; i++){
      if(str.charAt(i)=='c')costofC+=arr[i];
      else if(str.charAt(i)=='o')costofO=Math.min(costofC,costofO+arr[i]);
      else if(str.charAt(i)=='d')costofD=Math.min(costofO,costofD+arr[i]);
      else if(str.charAt(i)=='e')costofE=Math.min(costofD,costofE+arr[i]);
    }
    return(int)costofE ;
  }
  public static void main(String[] args){
    String str="geekcodergeeks" ;
    int arr[]={
      1,2,1,3,4,2,6,4,6,2,3,3,3,2 };
      int n=arr.length ;
      System.out.print(findCost(str,arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findCost( str : String, arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var costofC : long ; costofC := 0 ;
    var costofO : long ; costofO := 0 ;
    var costofD : long ; costofD := 0 ;
    var costofE : long ; costofE := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (str->at(i+1) = 'c') then     costofC := costofC+(arr[i+1]) ; else     if (str->at(i+1) = 'o') then     costofO := Set{costofC, costofO + arr[i+1]}->min() else     if (str->at(i+1) = 'd') then     costofD := Set{costofO, costofD + arr[i+1]}->min() else     if (str->at(i+1) = 'e') then     costofE := Set{costofD, costofE + arr[i+1]}->min() ; else skip ; ;  ;  )  ;     i := i + 1 ) ; 
     return costofE->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geekcodergeeks" ;
     var arr : Sequence(int) ; arr := Sequence{1,2,1,3,4,2,6,4,6,2,3,3,3,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(findCost(str, arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    gcdLength1511B();
  }
  public static void gcdLength1511B(){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    for(int i=0 ; i<t ; i++){
      int a=scan.nextInt();
      int b=scan.nextInt();
      int c=scan.nextInt();
      System.out.println((int)Math.pow(10,a-1)+(int)Math.pow(10,c-1)+" "+(int)Math.pow(10,b-1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute gcdLength1511B() );
  static   operation gcdLength1511B() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : int ; a := scan.getCurrent()->toInteger() ;
     var b : int ; b := scan.getCurrent()->toInteger() ;
     var c : int ; c := scan.getCurrent()->toInteger() ;
     OclFile["System.out"].println(10->pow(a - 1)->oclAsType(int) + 10->pow(c - 1)->oclAsType(int) + " " + 10->pow(b - 1)->oclAsType(int)) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Test20200824 {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    int n=0 ;
    int k=0 ;
    int step=1 ;
    int count=0 ;
    int[] res=new int[t];
    for(int i=0 ; i<t ; i++){
      n=input.nextInt();
      k=input.nextInt();
      input.nextLine();
      step=1 ;
      count=k ;
      ArrayList<Integer>numbers=new ArrayList<>();
      boolean[] flags=new boolean[n];
      for(int j=0 ; j<k ; j++){
        int m=input.nextInt()-1 ;
        numbers.add(m);
        flags[m]=true ;
      }
      input.nextLine();
      while(count<n){
        step++;
        for(int j=0 ; j<count ; j++){
          if(numbers.get(j)-1>=0 && ! flags[numbers.get(j)-1]){
            numbers.add(numbers.get(j)-1);
            flags[numbers.get(j)-1]=true ;
          }
          if(numbers.get(j)+1<n && ! flags[numbers.get(j)+1]){
            numbers.add(numbers.get(j)+1);
            flags[numbers.get(j)+1]=true ;
          }
        }
        count=numbers.size();
      }
      res[i]=step ;
    }
    for(int i=0 ; i<t ; i++){
      System.out.println(res[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test20200824 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
    var n : int ; n := 0 ;
    var k : int ; k := 0 ;
    var step : int ; step := 1 ;
    var count : int ; count := 0 ;
    var res : Sequence(int) ; res := Integer.subrange(1,t)->collect(0) ;
        var i : int ; i := 0 ; while i < t do ( (     n := input.getCurrent()->toInteger() ; 
     k := input.getCurrent()->toInteger() ; 
    skip ; 
    step := 1 ; 
    count := k ; 
    var numbers : Sequence(int) ; numbers := Sequence{} ;
    var flags : Sequence(boolean) ; flags := Integer.subrange(1,n)->collect(false) ;
        var j : int ; j := 0 ; while j < k do ( (     var m : int ; m := input.getCurrent()->toInteger() - 1 ;
     numbers := numbers->including(m) ; 
     flags[m+1] := true )  ;     j := j + 1 ) ; 
    skip ; 
    while (count < n) do (     step := step + 1 ; 
         var j : int ; j := 0 ; while j < count do ( (     if (numbers->at(j+1) - 1 >= 0 & not(flags[numbers->at(j+1) - 1+1])) then (     numbers := numbers->including(numbers->at(j+1) - 1) ; 
     flags[numbers->at(j+1) - 1+1] := true ) else skip ; 
     if (numbers->at(j+1) + 1 < n & not(flags[numbers->at(j+1) + 1+1])) then (     numbers := numbers->including(numbers->at(j+1) + 1) ; 
     flags[numbers->at(j+1) + 1+1] := true ) else skip )  ;     j := j + 1 ) ; 
     count := numbers->size() ) ; 
    res[i+1] := step ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < t do ( (     OclFile["System.out"].println(res[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static int Gcd(int a,int b){
    if(b==0)return a ;
    return Gcd(b,a % b);
  }
  public static int GcdLen(int n){
    int count=0 ;
    while(n>0){
      n/=10 ;
      count++;
    }
    return count ;
  }
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new BufferedReader(new InputStreamReader(System.in)));
    int t=Integer.parseInt(br.readLine());
    while(t-->0){
      int[] arr={
        1,1,10,100,1000,10000,100000,1000000,10000000,100000000 };
        String[] str=br.readLine().split(" ");
        int a=Integer.parseInt(str[0]);
        int b=Integer.parseInt(str[1]);
        int c=Integer.parseInt(str[2]);
        int x=arr[c];
        int y=arr[c];
        while(x<arr[a]){
          x*=2 ;
        }
        while(y<arr[b]){
          y*=3 ;
        }
        System.out.println(x+" "+y);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation Gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return Gcd(b, a mod b) );
  static   operation GcdLen( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     n := n/(10) ; 
     count := count + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var arr : Sequence(int) ; arr := Sequence{1,1,10,100,1000,10000,100000,1000000,10000000,100000000} ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var a : int ; a := (str[0+1])->toInteger() ;
    var b : int ; b := (str[1+1])->toInteger() ;
    var c : int ; c := (str[2+1])->toInteger() ;
    var x : int ; x := arr[c+1] ;
    var y : int ; y := arr[c+1] ;
    while (x < arr[a+1]) do (     x := x*(2) ) ; 
    while (y < arr[b+1]) do (     y := y*(3) ) ; 
    OclFile["System.out"].println(x + " " + y) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class BB {
  public static void main(String[] args)throws IOException {
    new BB();
  }
  BB()throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    int t_n=Integer.parseInt(in.readLine());
    for(int t_i=0 ; t_i<t_n ; t_i++){
      String[] tmp=in.readLine().split(" ");
      double a=Math.pow(10,Integer.parseInt(tmp[0])-1);
      double b=Math.pow(10,Integer.parseInt(tmp[1])-1);
      double c=Math.pow(10,Integer.parseInt(tmp[2])-1);
      int resC=2 ;
      while(resC<=c){
        resC*=2 ;
      }
      int resA=resC ;
      int resB=resC ;
      while(resB<=b){
        resB*=3 ;
      }
      while(resA<=a){
        resA*=5 ;
      }
      out.print(resA);
      out.print(' ');
      out.println(resB);
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class BB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( BB.newBB() );
   static operation newBB() : BB
  pre: true
  post: true
  activity:
  ( var self : BB ;
    self := createBB();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t_n : int ; t_n := (in.readLine())->toInteger() ;
        var t_i : int ; t_i := 0 ; while t_i < t_n do ( (     var tmp : Sequence(String) ; tmp := in.readLine()->split(" ") ;
     var a : double ; a := 10->pow((tmp[0+1])->toInteger() - 1) ;
    var b : double ; b := 10->pow((tmp[1+1])->toInteger() - 1) ;
    var c : double ; c := 10->pow((tmp[2+1])->toInteger() - 1) ;
    var resC : int ; resC := 2 ;
    while (resC <= c) do (     resC := resC*(2) ) ; 
    var resA : int ; resA := resC ;
    var resB : int ; resB := resC ;
    while (resB <= b) do (     resB := resB*(3) ) ; 
    while (resA <= a) do (     resA := resA*(5) ) ; 
    skip ; 
    skip ; 
    skip ; 
 )  ;     t_i := t_i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public static void main(String[] args){
    System.out.println(25);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(25) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewClass13 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    double t=in.nextDouble();
    int r=1 ;
    System.out.println(25);
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass13 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : double ; t := in.getCurrent()->toReal() ;
     var r : int ; r := 1 ;
     OclFile["System.out"].println(25) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    System.out.println("25");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("25") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    System.out.print("25");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("25") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class A_Again_Twenty_Five {
  public static void main(String[] args){
    System.out.println(25);
  }
}
------------------------------------------------------------
OCL File:
---------
class A_Again_Twenty_Five {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(25) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class TheClosestPair {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long n=in.nextLong(),k=in.nextLong();
    if(getVal(n)>k){
      int cnt=0 ;
      for(int i=0,x=0 ; i<n ; x+=cnt,i++){
        pw.println(0+" "+x);
        cnt++;
      }
    }
    else pw.println("no solution");
    pw.close();
  }
  static long getVal(long n){
    long tot=0 ;
    for(long i=1 ; i<=n ; i++){
      for(long j=i+1 ; j<=n ; j++){
        tot++;
      }
    }
    return tot ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class TheClosestPair {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := in.getCurrent()->toLong() ;
    var k : long ; k := in.getCurrent()->toLong() ;
    if (getVal(n) > k) then (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ;
    var x : int ; x := 0 ; while i < n do ( (     skip ; 
     cnt := cnt + 1 )  ;     x := x+(cnt) ;     i := i + 1 ) ) else     skip ; ;  
    skip ; 
 );
  static   operation getVal( n : long) : long
  pre: true
  post: true
  activity: (     var tot : long ; tot := 0 ;
         var i : long ; i := 1 ; while i <= n do ( (         var j : long ; j := i + 1 ; while j <= n do ( (     tot := tot + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return tot );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A311 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int K=in.nextInt();
    int maxK=N*(N-1)/2 ;
    if(maxK<=K){
      System.out.println("no solution");
    }
    else {
      for(int n=0 ; n<N ; n++){
        System.out.println("0 "+n);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A311 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    var maxK : int ; maxK := N * (N - 1) / 2 ;
    if (maxK <= K) then (     OclFile["System.out"].println("no solution") ) else (         var n : int ; n := 0 ; while n < N do ( (     OclFile["System.out"].println("0 " + n) )  ;     n := n + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class TheClosestPair {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long n=in.nextLong(),k=in.nextLong();
    if(getVal(n)>k){
      int cnt=0 ;
      for(int i=0,x=0 ; i<n ; x+=cnt,i++){
        pw.println(0+" "+x);
        cnt++;
      }
    }
    else pw.println("no solution");
    pw.close();
  }
  static long getVal(long n){
    long tot=0 ;
    for(long i=1 ; i<=n ; i++){
      for(long j=i+1 ; j<=n ; j++){
        tot++;
      }
    }
    return tot ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class TheClosestPair {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := in.getCurrent()->toLong() ;
    var k : long ; k := in.getCurrent()->toLong() ;
    if (getVal(n) > k) then (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ;
    var x : int ; x := 0 ; while i < n do ( (     skip ; 
     cnt := cnt + 1 )  ;     x := x+(cnt) ;     i := i + 1 ) ) else     skip ; ;  
    skip ; 
 );
  static   operation getVal( n : long) : long
  pre: true
  post: true
  activity: (     var tot : long ; tot := 0 ;
         var i : long ; i := 1 ; while i <= n do ( (         var j : long ; j := i + 1 ; while j <= n do ( (     tot := tot + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return tot );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class w20200824 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int times=sc.nextInt();
    int[] result=new int[times];
    for(int i=0 ; i<times ; i++){
      int len=sc.nextInt();
      int[] seats=new int[len];
      int num=sc.nextInt();
      int[] posgun=new int[num];
      for(int j=0 ; j<num ; j++){
        posgun[j]=sc.nextInt();
      }
      for(int j=0 ; j<num ; j++){
        seats[posgun[j]-1]=1 ;
      }
      result[i]=solution(seats);
    }
    for(int i=0 ; i<times ; i++){
      System.out.println(result[i]);
    }
  }
  public static int solution(int[] seats){
    int count1=0 ;
    int count2=0 ;
    int i=0,j=seats.length-1 ;
    while(seats[i]==0){
      count1++;
      i++;
    }
    while(seats[j]==0){
      count2++;
      j--;
    }
    int countmid=0,countmax=0 ;
    for(int k=i+1 ; k<=j ; k++){
      if(seats[k]==0){
        countmid++;
      }
      else {
        countmax=Math.max(countmax,countmid);
        countmid=0 ;
      }
    }
    return Math.max(Math.max(count1,count2),(countmax+1)/2)+1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class w20200824 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var times : int ; times := sc.getCurrent()->toInteger() ;
    var result : Sequence(int) ; result := Integer.subrange(1,times)->collect(0) ;
        var i : int ; i := 0 ; while i < times do ( (     var len : int ; len := sc.getCurrent()->toInteger() ;
     var seats : Sequence(int) ; seats := Integer.subrange(1,len)->collect(0) ;
    var num : int ; num := sc.getCurrent()->toInteger() ;
    var posgun : Sequence(int) ; posgun := Integer.subrange(1,num)->collect(0) ;
        var j : int ; j := 0 ; while j < num do ( (     posgun[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < num do ( (     seats[posgun[j+1] - 1+1] := 1 )  ;     j := j + 1 ) ; 
    result[i+1] := solution(seats) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < times do ( (     OclFile["System.out"].println(result[i+1]) )  ;     i := i + 1 ) ; 
 );
  static   operation solution( seats : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var count1 : int ; count1 := 0 ;
     var count2 : int ; count2 := 0 ;
    var i : int ; i := 0 ;
    var j : int ; j := seats->size() - 1 ;
    while (seats[i+1] = 0) do (     count1 := count1 + 1 ; 
     i := i + 1 ) ; 
    while (seats[j+1] = 0) do (     count2 := count2 + 1 ; 
     j := j - 1 ) ; 
    var countmid : int ; countmid := 0 ;
    var countmax : int ; countmax := 0 ;
        var k : int ; k := i + 1 ; while k <= j do ( (     if (seats[k+1] = 0) then (     countmid := countmid + 1 ) else (     countmax := Set{countmax, countmid}->max() ; 
     countmid := 0 ) )  ;     k := k + 1 ) ; 
    return Set{Set{count1, count2}->max(), (countmax + 1) / 2}->max() + 1 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int find_k(int a,int b){
    if((a+b)% 2==0)return((a+b)/2);
    return-1 ;
  }
  public static void main(String[] args){
    int a=2,b=16 ;
    System.out.println(find_k(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find_k( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if ((a + b) mod 2 = 0) then     return ((a + b) / 2) else skip ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2 ;
    var b : int ; b := 16 ;
     OclFile["System.out"].println(find_k(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class esep {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int k=sc.nextInt();
    System.out.println(m>=n && k>=n ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class esep {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(if m >= n & k >= n then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test184 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    int b=in.nextInt();
    int c=in.nextInt();
    if(a<=b && a<=c){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test184 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    if (a <= b & a <= c) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class VusTheCossackAndAContest {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int k=sc.nextInt();
    if(m<n || k<n){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class VusTheCossackAndAContest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    if (m < n or k < n) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    if(a<=b && a<=c){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    if (a <= b & a <= c) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class pen {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    int b=in.nextInt();
    int c=in.nextInt();
    if(a<=b && a<=c){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pen {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    if (a <= b & a <= c) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class C {
  static Scanner in ;
  public static void main(String[] args){
    in=new Scanner(System.in);
    int T=in.nextInt();
    for(int C=1 ; C<=T ; C++){
      System.out.println("Case #"+C+": "+solve());
    }
  }
  public static String solve(){
    String out="" ;
    int a=in.nextInt(),b=in.nextInt(),c=in.nextInt(),limit=in.nextInt();
    int[] abT=new int[201];
    int[] bcT=new int[201];
    int[] acT=new int[201];
    int count=0 ;
    for(int i=a ; i>=1 ; i--){
      for(int j=b ; j>=1 ; j--){
        for(int kk=c ; kk>=1 ; kk--){
          int k=(kk+(i)+(j))% c ;
          k++;
          int ab=i*15+j ;
          int ac=i*15+k ;
          int bc=j*15+k ;
          if(abT[ab]<limit && bcT[bc]<limit && acT[ac]<limit){
            out+="\n"+i+" "+j+" "+k ;
            count++;
            abT[ab]++;
            bcT[bc]++;
            acT[ac]++;
          }
          else {
          }
        }
      }
    }
    System.err.println(count);
    return count+""+out ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   attribute in : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var T : int ; T := in.getCurrent()->toInteger() ;
         var C : int ; C := 1 ; while C <= T do ( (     OclFile["System.out"].println("Case #" + C + ": " + solve()) )  ;     C := C + 1 ) );
  static   operation solve() : String
  pre: true
  post: true
  activity: (     var out : String ; out := "" ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var limit : int ; limit := in.getCurrent()->toInteger() ;
    var abT : Sequence(int) ; abT := Integer.subrange(1,201)->collect(0) ;
    var bcT : Sequence(int) ; bcT := Integer.subrange(1,201)->collect(0) ;
    var acT : Sequence(int) ; acT := Integer.subrange(1,201)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := a ; while i >= 1 do ( (         var j : int ; j := b ; while j >= 1 do ( (         var kk : int ; kk := c ; while kk >= 1 do ( (     var k : int ; k := (kk + (i) + (j)) mod c ;
     k := k + 1 ; 
    var ab : int ; ab := i * 15 + j ;
    var ac : int ; ac := i * 15 + k ;
    var bc : int ; bc := j * 15 + k ;
    if (abT[ab+1] < limit & bcT[bc+1] < limit & acT[ac+1] < limit) then (     out := out+("\n" + i + " " + j + " " + k) ; 
     count := count + 1 ; 
    abT[ab+1] := abT[ab+1] + 1 ; 
    bcT[bc+1] := bcT[bc+1] + 1 ; 
    acT[ac+1] := acT[ac+1] + 1 ; 
 ) else skip ;  
 )  ;     kk := kk - 1 ) )  ;     j := j - 1 ) )  ;     i := i - 1 ) ; 
    OclFile["System.err"].println(count) ; 
    return count + "" + out 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package gcj2016r1c ;
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
public class ProblemC {
  public static void main(String[] args)throws Exception {
    String fileName=args[0];
    ProblemC obj=new ProblemC();
    obj.solve(fileName);
  }
  public void solve(String fileName)throws Exception {
    BufferedReader br=new BufferedReader(new FileReader(fileName));
    BufferedWriter bw=new BufferedWriter(new FileWriter(fileName+".out"));
    int T=Integer.parseInt(br.readLine());
    for(int i=0 ; i<T ; i++){
      String str=br.readLine();
      StringTokenizer token=new StringTokenizer(str," ");
      int J=Integer.parseInt(token.nextToken());
      int P=Integer.parseInt(token.nextToken());
      int S=Integer.parseInt(token.nextToken());
      int K=Integer.parseInt(token.nextToken());
      ArrayList<int[]>list=new ArrayList<>();
      int[] chk=new int[P];
      int s=0 ;
      for(int j=0 ; j<J ; j++){
        for(int p=0 ; p<P ; p++){
          if(j!=0){
            s=chk[p];
          }
          for(int k=0 ; k<Math.min(K,S); k++){
            list.add(new int[] {
              j+1,p+1,s+1 }
);
              s=(s+1)% S ;
              chk[p]=s ;
            }
          }
        }
        bw.write("Case #"+(i+1)+": "+list.size());
        bw.write("\r\n");
        for(int[] e : list){
          bw.write(e[0]+" "+e[1]+" "+e[2]);
          bw.write("\r\n");
        }
      }
      bw.close();
      br.close();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class ProblemC {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fileName : String ; fileName := args[0+1] ;
     var obj : ProblemC ; obj := ProblemC.newProblemC() ;
     obj.solve(fileName) );
   operation solve( fileName : String) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(fileName))) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(fileName + ".out")) ;
    var T : int ; T := (br.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < T do ( (     var str : String ; str := br.readLine() ;
     var token : OclIterator ; token := OclIterator.newOclIterator_String_String(str, " ") ;
    var J : int ; J := (token.next())->toInteger() ;
    var P : int ; P := (token.next())->toInteger() ;
    var S : int ; S := (token.next())->toInteger() ;
    var K : int ; K := (token.next())->toInteger() ;
    var list : Sequence(Sequence(int)) ; list := Sequence{} ;
    var chk : Sequence(int) ; chk := Integer.subrange(1,P)->collect(0) ;
    var s : int ; s := 0 ;
        var j : int ; j := 0 ; while j < J do ( (         var p : int ; p := 0 ; while p < P do ( (     if (j /= 0) then (     s := chk[p+1] ) else skip ; 
         var k : int ; k := 0 ; while k < Set{K, S}->min() do ( (     list := list->including(Sequence{j + 1,p + 1,s + 1}) ; 
     s := (s + 1) mod S ; 
     chk[p+1] := s )  ;     k := k + 1 ) )  ;     p := p + 1 ) )  ;     j := j + 1 ) ; 
    skip ; 
    skip ; 
    for (e : list) do ( (     skip ; 
     skip )  ) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class R1CQ3 {
  public static void main(String[] args){
    try {
      String fileName="C-large" ;
      Scanner in=new Scanner(new File(fileName+".in"));
      PrintWriter out=new PrintWriter(fileName+".out");
      int numberOfTestCases=in.nextInt();
      for(int caseNum=1 ; caseNum<=numberOfTestCases ; caseNum++){
        int J=in.nextInt();
        int P=in.nextInt();
        int S=in.nextInt();
        int k=in.nextInt();
        int dayCount=0 ;
        String result="" ;
        for(int j=1 ; j<=J ; j++){
          for(int p=1 ; p<=P ; p++){
            for(int i=0 ; i<S && i<k ; i++){
              dayCount++;
              int a=(((i+p+j)% S)+1);
              result+=j+" "+p+" "+a+"\n" ;
            }
          }
        }
        out.println("Case #"+caseNum+": "+dayCount+"\n"+result.substring(0,result.length()-1));
      }
      in.close();
      out.close();
    }
    catch(Exception ex){
      ex.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class R1CQ3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var fileName : String ; fileName := "C-large" ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile(fileName + ".in")) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(fileName + ".out") ;
    var numberOfTestCases : int ; numberOfTestCases := in.getCurrent()->toInteger() ;
        var caseNum : int ; caseNum := 1 ; while caseNum <= numberOfTestCases do ( (     var J : int ; J := in.getCurrent()->toInteger() ;
     var P : int ; P := in.getCurrent()->toInteger() ;
    var S : int ; S := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var dayCount : int ; dayCount := 0 ;
    var result : String ; result := "" ;
        var j : int ; j := 1 ; while j <= J do ( (         var p : int ; p := 1 ; while p <= P do ( (         var i : int ; i := 0 ; while i < S & i < k do ( (     dayCount := dayCount + 1 ; 
     var a : int ; a := (((i + p + j) mod S) + 1) ;
     result := result+(j + " " + p + " " + a + "\n") )  ;     i := i + 1 ) )  ;     p := p + 1 ) )  ;     j := j + 1 ) ; 
    skip ; 
 )  ;     caseNum := caseNum + 1 ) ; 
    skip ; 
    skip ; 
 )   catch (ex : ProgramException) do (     ex.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package codejamquestion ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class CodeJamQuestion {
  public static void main(String[] args){
    try {
      Scanner in=new Scanner(new File("C-large.in"));
      PrintWriter out=new PrintWriter("C-large.out");
      int tests=in.nextInt();
      for(int test=1 ; test<=tests ; test++){
        String answer="Case #"+test+": " ;
        String outfits="" ;
        int days=0 ;
        int J=in.nextInt();
        int P=in.nextInt();
        int S=in.nextInt();
        int k=in.nextInt();
        for(int j=1 ; j<=J ; j++){
          for(int p=1 ; p<=P ; p++){
            for(int i=0 ; i<S && i<k ; i++){
              outfits+=j+" "+p+" "+(((i+p+j)% S)+1)+"\n" ;
              days++;
            }
          }
        }
        answer+=days+"\n"+outfits ;
        out.println(answer);
      }
      in.close();
      out.close();
    }
    catch(FileNotFoundException ex){
      System.out.println("ERROR");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeJamQuestion {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("C-large.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("C-large.out")) ;
    var tests : int ; tests := in.getCurrent()->toInteger() ;
        var test : int ; test := 1 ; while test <= tests do ( (     var answer : String ; answer := "Case #" + test + ": " ;
     var outfits : String ; outfits := "" ;
    var days : int ; days := 0 ;
    var J : int ; J := in.getCurrent()->toInteger() ;
    var P : int ; P := in.getCurrent()->toInteger() ;
    var S : int ; S := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
        var j : int ; j := 1 ; while j <= J do ( (         var p : int ; p := 1 ; while p <= P do ( (         var i : int ; i := 0 ; while i < S & i < k do ( (     outfits := outfits+(j + " " + p + " " + (((i + p + j) mod S) + 1) + "\n") ; 
     days := days + 1 )  ;     i := i + 1 ) )  ;     p := p + 1 ) )  ;     j := j + 1 ) ; 
    answer := answer+(days + "\n" + outfits) ; 
    skip ; 
 )  ;     test := test + 1 ) ; 
    skip ; 
    skip ; 
 )   catch (ex : FileNotFoundException) do (     OclFile["System.out"].println("ERROR") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package Round1 ;
import java.io.*;
public class C {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new FileReader("/Users/chao/Downloads/C-large.in"));
    FileWriter out=new FileWriter("/Users/chao/Desktop/C-large.txt");
    String s=in.readLine();
    int m=Integer.parseInt(s);
    int[] a=new int[3];
    for(int cases=1 ; cases<=m ; cases++){
      String[] ss=in.readLine().split(" ");
      for(int i=0 ; i<3 ; i++){
        a[i]=Integer.parseInt(ss[i]);
      }
      int k=Integer.parseInt(ss[3]);
      k=Math.min(k,a[2]);
      int ans=a[0]*a[1]*k ;
      out.write("Case #"+cases+": "+ans+"\n");
      for(int i=1 ; i<=a[0]; i++){
        for(int j=1 ; j<=a[1]; j++){
          for(int x=0 ; x<k ; x++){
            int val=(i+j+x-2)% a[2]+1 ;
            out.write(i+" "+j+" "+val+"\n");
          }
        }
      }
    }
    in.close();
    out.flush();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("/Users/chao/Downloads/C-large.in"))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("/Users/chao/Desktop/C-large.txt")) ;
    var s : String ; s := in.readLine() ;
    var m : int ; m := (s)->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
        var cases : int ; cases := 1 ; while cases <= m do ( (     var ss : Sequence(String) ; ss := in.readLine()->split(" ") ;
         var i : int ; i := 0 ; while i < 3 do ( (     a[i+1] := (ss[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var k : int ; k := (ss[3+1])->toInteger() ;
    k := Set{k, a[2+1]}->min() ; 
    var ans : int ; ans := a[0+1] * a[1+1] * k ;
    skip ; 
        var i : int ; i := 1 ; while i <= a[0+1] do ( (         var j : int ; j := 1 ; while j <= a[1+1] do ( (         var x : int ; x := 0 ; while x < k do ( (     var val : int ; val := (i + j + x - 2) mod a[2+1] + 1 ;
     skip )  ;     x := x + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 )  ;     cases := cases + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static final int nbits=32 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long x=sc.nextLong();
    BitSet bs=new BitSet(nbits);
    for(int i=0 ; i<nbits ; i++){
      if((x &(1<<i))!=0)bs.set(i);
    }
    printBitSet(bs);
    System.out.print("\n");
    bs.flip(0,nbits);
    printBitSet(bs);
    System.out.print("\n");
    bs.flip(0,nbits);
    BitSet bsa=new BitSet(nbits);
    for(int i=0 ; i<nbits-1 ; i++){
      if(bs.get(i))bsa.set(i+1);
    }
    printBitSet(bsa);
    System.out.print("\n");
    bsa=new BitSet(nbits);
    for(int i=0 ; i<nbits-1 ; i++){
      if(bs.get(i+1))bsa.set(i);
    }
    printBitSet(bsa);
    System.out.print("\n");
  }
  static void printBitSet(BitSet bs){
    for(int i=nbits-1 ; i>=0 ; i--){
      if(bs.get(i))System.out.print(1);
      else System.out.print(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute nbits : int := 32;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := sc.getCurrent()->toLong() ;
    var bs : Sequence(boolean) ; bs := MathLib.toBitSequence(nbits) ;
        var i : int ; i := 0 ; while i < nbits do ( (     if ((MathLib.bitwiseAnd(x,((1*(2->pow(i)))->oclAsType(long)))) /= 0) then     bs := bs.setAt(i+1, true) ; else skip )  ;     i := i + 1 ) ; 
    execute printBitSet(bs) ; 
    OclFile["System.out"].print("\n") ; 
    bs := bs.flip(0, nbits) ; 
    execute printBitSet(bs) ; 
    OclFile["System.out"].print("\n") ; 
    bs := bs.flip(0, nbits) ; 
    var bsa : Sequence(boolean) ; bsa := MathLib.toBitSequence(nbits) ;
        var i : int ; i := 0 ; while i < nbits - 1 do ( (     if (bs->at(i+1)) then     bsa := bsa.setAt(i + 1+1, true) ; else skip )  ;     i := i + 1 ) ; 
    execute printBitSet(bsa) ; 
    OclFile["System.out"].print("\n") ; 
    bsa := MathLib.toBitSequence(nbits) ; 
        var i : int ; i := 0 ; while i < nbits - 1 do ( (     if (bs->at(i + 1+1)) then     bsa := bsa.setAt(i+1, true) ; else skip )  ;     i := i + 1 ) ; 
    execute printBitSet(bsa) ; 
    OclFile["System.out"].print("\n") ; 
 );
  static   operation printBitSet( bs : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := nbits - 1 ; while i >= 0 do ( (     if (bs->at(i+1)) then     OclFile["System.out"].print(1) ; else     OclFile["System.out"].print(0) ; )  ;     i := i - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class awe {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    int n,k,max,before,now,a,b,c ;
    for(int i=0 ; i<t ; i++){
      n=input.nextInt();
      k=input.nextInt();
      max=input.nextInt();
      before=max ;
      for(int j=1 ; j<k ; j++){
        now=input.nextInt();
        a=now-before+1 ;
        b=a/2 ;
        c=a % 2 ;
        if((c==0)&&(b>max))max=b ;
        else if((c==1)&&(b+1>max))max=b+1 ;
        before=now ;
      }
      b=n-before+1 ;
      max=b>max ? b : max ;
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class awe {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
     var n : int ;
    var k : int ;
    var max : int ;
    var before : int ;
    var now : int ;
    var a : int ;
    var b : int ;
    var c : int ;
         var i : int ; i := 0 ; while i < t do ( (     n := input.getCurrent()->toInteger() ; 
     k := input.getCurrent()->toInteger() ; 
    max := input.getCurrent()->toInteger() ; 
    before := max ; 
        var j : int ; j := 1 ; while j < k do ( (     now := input.getCurrent()->toInteger() ; 
     a := now - before + 1 ; 
    b := a / 2 ; 
    c := a mod 2 ; 
    if ((c = 0) & (b > max)) then     max := b else     if ((c = 1) & (b + 1 > max)) then     max := b + 1 ; else skip ; ;  
    before := now ; 
 )  ;     j := j + 1 ) ; 
    b := n - before + 1 ; 
    max := if b > max then b else max endif ; 
    OclFile["System.out"].println(max) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class B_CorrectSolution {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    char[] cs=scan.nextLine().toCharArray();
    Arrays.sort(cs);
    int i ;
    for(i=0 ; i<cs.length && cs[i]==48 ; i++);
    if(i!=0 && i<cs.length){
      cs[0]=cs[i];
      cs[i]=48 ;
    }
    System.out.println(scan.nextLine().equals(new String(cs))? "OK" : "WRONG_ANSWER");
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_CorrectSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cs : Sequence(String) ; cs := scan.nextLine()->characters() ;
    cs := cs->sort() ; 
    var i : int ;
        i := 0 ; while i < cs->size() & cs[i+1] = 48 do (   ;     i := i + 1 ) ; 
    if (i /= 0 & i < cs->size()) then (     cs[0+1] := cs[i+1] ; 
     cs[i+1] := 48 ) else skip ; 
    OclFile["System.out"].println(if scan.nextLine() = StringLib.newString(cs) then "OK" else "WRONG_ANSWER" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String a=in.nextLine();
    String s=in.nextLine();
    char[] adadChars=a.toCharArray();
    Arrays.sort(adadChars);
    String res="" ;
    try {
      int i ;
      for(i=0 ; i<adadChars.length && adadChars[i]=='0' ; i++){
        if(i==adadChars.length-1)throw new BadEx("0");
      }
      res+=adadChars[i];
      for(int j=0 ; j<adadChars.length ; j++){
        if(i==j)continue ;
        res+=adadChars[j];
      }
    }
    catch(BadEx be){
      res=be.getMessage();
    }
    if(s.equals(res))System.out.println("OK");
    else System.out.println("WRONG_ANSWER");
  }
}
class BadEx extends Exception {
  public BadEx(String message){
    super(message);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := in.nextLine() ;
    var s : String ; s := in.nextLine() ;
    var adadChars : Sequence(String) ; adadChars := a->characters() ;
    adadChars := adadChars->sort() ; 
    var res : String ; res := "" ;
    try (     var i : int ;
         i := 0 ; while i < adadChars->size() & adadChars[i+1] = '0' do ( (     if (i = adadChars->size() - 1) then     error BadEx.newBadEx("0") ; else skip )  ;     i := i + 1 ) ; 
     res := res+(adadChars[i+1]) ; 
         var j : int ; j := 0 ; while j < adadChars->size() do ( (     if (i = j) then     continue else skip ; 
     res := res+(adadChars[j+1]) )  ;     j := j + 1 ) )   catch (be : BadEx) do (     res := be.getMessage() )
    if (s = res) then     OclFile["System.out"].println("OK") else     OclFile["System.out"].println("WRONG_ANSWER") ; ;  
 );
}
class BadEx extends ProgramException {
   static operation newBadEx( message : String) : BadEx
  pre: true
  post: true
  activity:
  ( var self : BadEx ;
    self := createBadEx();
    self.initialise(message);
    return self );
  operation initialise( message : String) : void
  pre: true  post: true
  activity: (     execute super(message) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String num=sc.next();
    String sum=sc.next();
    char a[]=num.toCharArray();
    char b[]=sum.toCharArray();
    if(num.length()!=sum.length()){
      System.out.println("WRONG_ANSWER");
      return ;
    }
    Arrays.sort(a);
    for(int i=0 ; i<a.length ; i++){
      if(a[i]!='0'){
        char t ;
        t=a[i];
        a[i]=a[0];
        a[0]=t ;
        break ;
      }
    }
    for(int i=0 ; i<num.length(); i++){
      if(a[i]!=b[i]){
        System.out.println("WRONG_ANSWER");
        return ;
      }
    }
    System.out.println("OK");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : String ; num := sc.getCurrent() ;
    var sum : String ; sum := sc.getCurrent() ;
    var a : Sequence(String) ; a := num->characters() ;
    var b : Sequence(String) ; b := sum->characters() ;
    if (num->size() /= sum->size()) then (     OclFile["System.out"].println("WRONG_ANSWER") ; 
     return ) else skip ; 
    a := a->sort() ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] /= '0') then (     var t : String ;
     t := a[i+1] ; 
    a[i+1] := a[0+1] ; 
    a[0+1] := t ; 
    break 
 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < num->size() do ( (     if (a[i+1] /= b[i+1]) then (     OclFile["System.out"].println("WRONG_ANSWER") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("OK") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import com.sun.jndi.cosnaming.CNCtx ;
import java.io.*;
import java.util.*;
public class CodehorsesTshirts {
  static HashMap<Integer,ArrayList<String>>map ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    HashMap<String,Integer>map=new HashMap<>();
    HashMap<String,Integer>map2=new HashMap<>();
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      String x=in.next();
      map.put(x,map.getOrDefault(x,0)+1);
    }
    for(int i=0 ; i<n ; i++){
      String x=in.next();
      map2.put(x,map2.getOrDefault(x,0)+1);
    }
    int ans=0 ;
    for(String s : map.keySet()){
      if(map2.containsKey(s)&& map2.get(s)!=0){
        int cntM1=map.get(s);
        int cntM2=map2.get(s);
        if(cntM1>cntM2){
          map2.put(s,0);
          int cnt=cntM1-cntM2 ;
          map.put(s,cnt);
        }
        else if(cntM1<cntM2){
          map.put(s,0);
          map2.put(s,cntM2-cntM1);
        }
        else {
          map.put(s,0);
          map2.put(s,0);
        }
      }
    }
    for(int v : map.values())ans+=v ;
    for(int v : map2.values())ans+=v ;
    ans/=2 ;
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodehorsesTshirts {
  static   attribute map : Map(int,Sequence(String));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var map : Map(String,int) ; map := Map{} ;
    var map2 : Map(String,int) ; map2 := Map{} ;
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var x : String ; x := in.getCurrent() ;
     map := map->union(Map{x |-> (if map->keys()->contains(x) then map->at(x) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : String ; x := in.getCurrent() ;
     map2 := map2->union(Map{x |-> (if map2->keys()->contains(x) then map2->at(x) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (s : map->keys()) do ( (     if (map2->keys()->includes(s) & map2->at(s) /= 0) then (     var cntM1 : int ; cntM1 := map->at(s) ;
     var cntM2 : int ; cntM2 := map2->at(s) ;
     if (cntM1 > cntM2) then (     map2 := map2->union(Map{s |-> 0}) ; 
     var cnt : int ; cnt := cntM1 - cntM2 ;
     map := map->union(Map{s |-> cnt}) ) else     if (cntM1 < cntM2) then (     map := map->union(Map{s |-> 0}) ; 
     map2 := map2->union(Map{s |-> cntM2 - cntM1}) ) else (     map := map->union(Map{s |-> 0}) ; 
     map2 := map2->union(Map{s |-> 0}) ) ;  ) else skip )  ) ; 
    for (v : map->values()) do (     ans := ans+(v) ;  ) ; 
    for (v : map2->values()) do (     ans := ans+(v) ;  ) ; 
    ans := ans/(2) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import com.sun.jndi.cosnaming.CNCtx ;
import java.io.*;
import java.util.*;
public class CodehorsesTshirts {
  static HashMap<Integer,ArrayList<String>>map ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    HashMap<String,Integer>map=new HashMap<>();
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      String x=in.next();
      Integer cnt=map.get(x);
      if(cnt==null)cnt=1 ;
      else cnt+=1 ;
      map.put(x,cnt);
    }
    for(int i=0 ; i<n ; i++){
      String x=in.next();
      Integer cnt=map.get(x);
      if(cnt==null)cnt=-1 ;
      else cnt--;
      map.put(x,cnt);
    }
    int[] state=new int[10];
    for(Map.Entry<String,Integer>m : map.entrySet()){
      state[m.getKey().length()]+=Math.abs(m.getValue());
    }
    int ans=0 ;
    for(int i=0 ; i<10 ; i++)ans+=state[i];
    ans/=2 ;
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodehorsesTshirts {
  static   attribute map : Map(int,Sequence(String));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var map : Map(String,int) ; map := Map{} ;
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var x : String ; x := in.getCurrent() ;
     var cnt : int ; cnt := map->at(x) ;
     if (cnt = null) then     cnt := 1 else     cnt := cnt+(1) ; ;  
     map := map->union(Map{x |-> cnt}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : String ; x := in.getCurrent() ;
     var cnt : int ; cnt := map->at(x) ;
     if (cnt = null) then     cnt := -1 else     cnt := cnt - 1 ; ;  
     map := map->union(Map{x |-> cnt}) )  ;     i := i + 1 ) ; 
    var state : Sequence(int) ; state := Integer.subrange(1,10)->collect(0) ;
    for (m : map->asSet()) do ( (     state[m.getKey()->size()+1] := state[m.getKey()->size()+1]+(if m.getValue() < 0 then -(m.getValue()) else m.getValue() endif) )  ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 10 do (     ans := ans+(state[i+1]) ;  ;     i := i + 1 ) ; 
    ans := ans/(2) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class shirtsbeforehoes {
  public static void main(String[] args)throws IOException {
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(r.readLine());
    int n=Integer.parseInt(st.nextToken());
    int[][] oldlist=new int[4][3];
    int[][] newlist=new int[4][3];
    for(int x=0 ; x<n ; x++){
      String thing=r.readLine();
      int index=thing.length()-1 ;
      char compare=thing.charAt(thing.length()-1);
      if(compare=='S')oldlist[index][0]++;
      if(compare=='M')oldlist[index][1]++;
      if(compare=='L')oldlist[index][2]++;
    }
    for(int x=0 ; x<n ; x++){
      String thing=r.readLine();
      int index=thing.length()-1 ;
      char compare=thing.charAt(thing.length()-1);
      if(compare=='S')newlist[index][0]++;
      if(compare=='M')newlist[index][1]++;
      if(compare=='L')newlist[index][2]++;
    }
    int[][] convertList=new int[4][3];
    for(int x=0 ; x<4 ; x++){
      for(int y=0 ; y<3 ; y++){
        convertList[x][y]=Math.abs(newlist[x][y]-oldlist[x][y]);
      }
    }
    int answer=0 ;
    for(int x=0 ; x<4 ; x++){
      for(int y=0 ; y<3 ; y++){
        answer=answer+convertList[x][y];
      }
    }
    System.out.println(answer/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class shirtsbeforehoes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(r.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var oldlist : Sequence(Sequence(int)) ; oldlist := Integer.subrange(1,4)->collect(Integer.subrange(1,3)->collect(0)) ;
    var newlist : Sequence(Sequence(int)) ; newlist := Integer.subrange(1,4)->collect(Integer.subrange(1,3)->collect(0)) ;
        var x : int ; x := 0 ; while x < n do ( (     var thing : String ; thing := r.readLine() ;
     var index : int ; index := thing->size() - 1 ;
    var compare : String ; compare := thing->at(thing->size() - 1+1) ;
    if (compare = 'S') then     oldlist[index+1][0+1] := oldlist[index+1][0+1] + 1 ; else skip ; 
    if (compare = 'M') then     oldlist[index+1][1+1] := oldlist[index+1][1+1] + 1 ; else skip ; 
    if (compare = 'L') then     oldlist[index+1][2+1] := oldlist[index+1][2+1] + 1 ; else skip ; 
 )  ;     x := x + 1 ) ; 
        var x : int ; x := 0 ; while x < n do ( (     var thing : String ; thing := r.readLine() ;
     var index : int ; index := thing->size() - 1 ;
    var compare : String ; compare := thing->at(thing->size() - 1+1) ;
    if (compare = 'S') then     newlist[index+1][0+1] := newlist[index+1][0+1] + 1 ; else skip ; 
    if (compare = 'M') then     newlist[index+1][1+1] := newlist[index+1][1+1] + 1 ; else skip ; 
    if (compare = 'L') then     newlist[index+1][2+1] := newlist[index+1][2+1] + 1 ; else skip ; 
 )  ;     x := x + 1 ) ; 
    var convertList : Sequence(Sequence(int)) ; convertList := Integer.subrange(1,4)->collect(Integer.subrange(1,3)->collect(0)) ;
        var x : int ; x := 0 ; while x < 4 do ( (         var y : int ; y := 0 ; while y < 3 do ( (     convertList[x+1][y+1] := if newlist[x+1][y+1] - oldlist[x+1][y+1] < 0 then -(newlist[x+1][y+1] - oldlist[x+1][y+1]) else newlist[x+1][y+1] - oldlist[x+1][y+1] endif )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
    var answer : int ; answer := 0 ;
        var x : int ; x := 0 ; while x < 4 do ( (         var y : int ; y := 0 ; while y < 3 do ( (     answer := answer + convertList[x+1][y+1] )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println(answer / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    ArrayList<String>word=new ArrayList<>();
    for(; scanner.hasNext(); ){
      word.add(scanner.next());
    }
    int len_max=0 ;
    String str_len="" ;
    int[] word_cnt=new int[word.size()];
    String[] str_words=new String[word.size()];
    for(int i=0 ; i<word.size(); i++){
      word_cnt[i]=0 ;
      str_words[i]="" ;
    }
    for(int i=0 ; i<word.size(); i++){
      String w=word.get(i);
      if(w.length()>len_max){
        len_max=w.length();
        str_len=w ;
      }
      for(int j=0 ; j<=i ; j++){
        if(w.equals(word.get(j))){
          word_cnt[j]++;
          str_words[j]=w ;
        }
      }
    }
    String str_word="" ;
    int word_max=0 ;
    for(int i=0 ; i<word.size(); i++){
      if(word_max<word_cnt[i]){
        word_max=word_cnt[i];
        str_word=str_words[i];
      }
    }
    System.out.println(str_word+" "+str_len);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var word : Sequence(String) ; word := Sequence{} ;
      while scanner.hasNext() do ( (     word := word->including(scanner.getCurrent()) )  ) ; 
    var len_max : int ; len_max := 0 ;
    var str_len : String ; str_len := "" ;
    var word_cnt : Sequence(int) ; word_cnt := Integer.subrange(1,word->size())->collect(0) ;
    var str_words : Sequence(String) ; str_words := Integer.subrange(1,word->size())->collect(null) ;
        var i : int ; i := 0 ; while i < word->size() do ( (     word_cnt[i+1] := 0 ; 
     str_words[i+1] := "" )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < word->size() do ( (     var w : String ; w := word->at(i+1) ;
     if (w->size() > len_max) then (     len_max := w->size() ; 
     str_len := w ) else skip ; 
         var j : int ; j := 0 ; while j <= i do ( (     if (w = word->at(j+1)) then (     word_cnt[j+1] := word_cnt[j+1] + 1 ; 
     str_words[j+1] := w ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var str_word : String ; str_word := "" ;
    var word_max : int ; word_max := 0 ;
        var i : int ; i := 0 ; while i < word->size() do ( (     if (word_max < word_cnt[i+1]) then (     word_max := word_cnt[i+1] ; 
     str_word := str_words[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(str_word + " " + str_len) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Map.Entry ;
class Main {
  Scanner sc=new Scanner(System.in);
  public void run(){
    Hashtable<String,Integer>vals=new Hashtable<String,Integer>();
    while(sc.hasNext()){
      String m=sc.next();
      if(vals.containsKey(m)){
        vals.put(m,vals.get(m)+1);
      }
      else {
        vals.put(m,0);
      }
    }
    ArrayList<Entry<String,Integer>>valList=new ArrayList<Entry<String,Integer>>(vals.entrySet());
    Collections.sort(valList,new Comparator<Entry<String,Integer>>(){
      @ Override public int compare(Entry<String,Integer>o1,Entry<String,Integer>o2){
        return o2.getValue()-o1.getValue();
      }
    }
);
    String mode=valList.get(0).getKey();
    Collections.sort(valList,new Comparator<Entry<String,Integer>>(){
      @ Override public int compare(Entry<String,Integer>o1,Entry<String,Integer>o2){
        return o2.getKey().length()-o1.getKey().length();
      }
    }
);
    String lng=valList.get(0).getKey();
    ln(mode+" "+lng);
  }
  public static void main(String[] args){
    new Main().run();
  }
  public static void pr(Object o){
    System.out.print(o);
  }
  public static void ln(Object o){
    System.out.println(o);
  }
  public static void ln(){
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var vals : Map(String,int) ; vals := Map{} ;
     while (sc.hasNext()) do (     var m : String ; m := sc.getCurrent() ;
     if (vals->keys()->includes(m)) then (     vals := vals->union(Map{m |-> vals->at(m) + 1}) ) else (     vals := vals->union(Map{m |-> 0}) ) ) ; 
    var valList : Sequence(Entry<String,int>) ; valList := Sequence{}->union(vals->asSet()) ;
    valList, OclComparator<Entry<String,int>>.newOclComparator() := valList, OclComparator<Entry<String,int>>.newOclComparator()->sort() ; 
    var mode : String ; mode := valList->at(0+1).getKey() ;
    valList, OclComparator<Entry<String,int>>.newOclComparator() := valList, OclComparator<Entry<String,int>>.newOclComparator()->sort() ; 
    var lng : String ; lng := valList->at(0+1).getKey() ;
    execute ln(mode + " " + lng) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int i,n,max ;
    String[] s ;
    int[] count ;
    String l ;
    n=0 ;
    s=new String[1000];
    count=new int[1000];
    for(; sc.hasNext(); ){
      s[n]=sc.next();
      n++;
      for(i=0 ; i<n-1 ; i++)if(s[n-1] .equals(s[i]))count[i]++;
    }
    max=0 ;
    l=s[0];
    for(i=1 ; i<n ; i++){
      if(count[max]<count[i])max=i ;
      if(l.length()<s[i] .length())l=s[i];
    }
    out.println(s[max]+" "+l);
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var i : int ;
    var n : int ;
    var max : int ;
    var s : Sequence(String) ;
    var count : Sequence(int) ;
    var l : String ;
    n := 0 ; 
    s := Integer.subrange(1,1000)->collect(null) ; 
    count := Integer.subrange(1,1000)->collect(0) ; 
      while sc.hasNext() do ( (     s[n+1] := sc.next() ; 
     n := n + 1 ; 
         i := 0 ; while i < n - 1 do (     if (s[n - 1+1] = s[i+1]) then     count[i+1] := count[i+1] + 1 ; else skip ;  ;     i := i + 1 ) )  ) ; 
    max := 0 ; 
    l := s[0+1] ; 
        i := 1 ; while i < n do ( (     if (count[max+1] < count[i+1]) then     max := i ; else skip ; 
     if (l->size() < s[i+1]->size()) then     l := s[i+1] ; else skip )  ;     i := i + 1 ) ; 
    out.println(s[max+1] + " " + l) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int CHARS=26 ;
  static boolean isValidString(String str){
    int freq[]=new int[CHARS];
    for(int i=0 ; i<str.length(); i++){
      freq[str.charAt(i)-'a']++;
    }
    int i,freq1=0,count_freq1=0 ;
    for(i=0 ; i<CHARS ; i++){
      if(freq[i]!=0){
        freq1=freq[i];
        count_freq1=1 ;
        break ;
      }
    }
    int j,freq2=0,count_freq2=0 ;
    for(j=i+1 ; j<CHARS ; j++){
      if(freq[j]!=0){
        if(freq[j]==freq1){
          count_freq1++;
        }
        else {
          count_freq2=1 ;
          freq2=freq[j];
          break ;
        }
      }
    }
    for(int k=j+1 ; k<CHARS ; k++){
      if(freq[k]!=0){
        if(freq[k]==freq1){
          count_freq1++;
        }
        if(freq[k]==freq2){
          count_freq2++;
        }
        else {
          return false ;
        }
      }
      if(count_freq1>1 && count_freq2>1){
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    String str="abcbc" ;
    if(isValidString(str)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute CHARS : int := 26;
  static   operation isValidString( str : String) : boolean
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,CHARS)->collect(0) ;
         var i : int ; i := 0 ; while i < str->size() do ( (     freq[str->at(i+1) - ('a')->char2byte()+1] := freq[str->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    var i : int ;
    var freq1 : int ; freq1 := 0 ;
    var count_freq1 : int ; count_freq1 := 0 ;
        i := 0 ; while i < CHARS do ( (     if (freq[i+1] /= 0) then (     freq1 := freq[i+1] ; 
     count_freq1 := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var j : int ;
    var freq2 : int ; freq2 := 0 ;
    var count_freq2 : int ; count_freq2 := 0 ;
        j := i + 1 ; while j < CHARS do ( (     if (freq[j+1] /= 0) then (     if (freq[j+1] = freq1) then (     count_freq1 := count_freq1 + 1 ) else (     count_freq2 := 1 ; 
     freq2 := freq[j+1] ; 
     break ) ) else skip )  ;     j := j + 1 ) ; 
        var k : int ; k := j + 1 ; while k < CHARS do ( (     if (freq[k+1] /= 0) then (     if (freq[k+1] = freq1) then (     count_freq1 := count_freq1 + 1 ) else skip ; 
     if (freq[k+1] = freq2) then (     count_freq2 := count_freq2 + 1 ) else (     return false ) ) else skip ; 
     if (count_freq1 > 1 & count_freq2 > 1) then (     return false ) else skip )  ;     k := k + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abcbc" ;
     if (isValidString(str)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    Map<String,Integer>dict=new HashMap<String,Integer>();
    String line=br.readLine();
    String[] words=line.split("\\s");
    for(int i=0 ; i<words.length ; i++){
      if(! dict.containsKey(words[i])){
        dict.put(words[i],1);
      }
      else {
        dict.put(words[i],dict.get(words[i])+1);
      }
    }
    String longest="" ;
    String max_word="" ;
    long max=0 ;
    for(String key : dict.keySet()){
      if(key.length()>longest.length())longest=new String(key);
      if(max<dict.get(key)){
        max=dict.get(key);
        max_word=new String(key);
      }
    }
    System.out.println(max_word+" "+longest);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var dict : Map(String,int) ; dict := Map{} ;
    var line : String ; line := br.readLine() ;
    var words : Sequence(String) ; words := line->split("\\s") ;
        var i : int ; i := 0 ; while i < words->size() do ( (     if (not(dict->keys()->includes(words[i+1]))) then (     dict := dict->union(Map{words[i+1] |-> 1}) ) else (     dict := dict->union(Map{words[i+1] |-> dict->at(words[i+1]) + 1}) ) )  ;     i := i + 1 ) ; 
    var longest : String ; longest := "" ;
    var max_word : String ; max_word := "" ;
    var max : long ; max := 0 ;
    for (key : dict->keys()) do ( (     if (key->size() > longest->size()) then     longest := StringLib.newString(key) ; else skip ; 
     if (max < dict->at(key)) then (     max := dict->at(key) ; 
     max_word := StringLib.newString(key) ) else skip )  ) ; 
    OclFile["System.out"].println(max_word + " " + longest) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class awe {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    int n,k,max,before,first,now,a ;
    for(int i=0 ; i<t ; i++){
      n=input.nextInt();
      k=input.nextInt();
      first=input.nextInt();
      max=0 ;
      before=first ;
      for(int j=1 ; j<k ; j++){
        now=input.nextInt();
        a=now-before+1 ;
        if(a>max)max=a ;
        before=now ;
      }
      max=(max+1)/2 ;
      a=n-before+1 ;
      max=a>max ? a : max ;
      max=first>max ? first : max ;
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class awe {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
     var n : int ;
    var k : int ;
    var max : int ;
    var before : int ;
    var first : int ;
    var now : int ;
    var a : int ;
         var i : int ; i := 0 ; while i < t do ( (     n := input.getCurrent()->toInteger() ; 
     k := input.getCurrent()->toInteger() ; 
    first := input.getCurrent()->toInteger() ; 
    max := 0 ; 
    before := first ; 
        var j : int ; j := 1 ; while j < k do ( (     now := input.getCurrent()->toInteger() ; 
     a := now - before + 1 ; 
     if (a > max) then     max := a ; else skip ; 
     before := now )  ;     j := j + 1 ) ; 
    max := (max + 1) / 2 ; 
    a := n - before + 1 ; 
    max := if a > max then a else max endif ; 
    max := if first > max then first else max endif ; 
    OclFile["System.out"].println(max) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    String s=sc.nextLine();
    String[] strs=s.split(" ");
    Map<String,Integer>map=new HashMap<>();
    int length_max=Integer.MIN_VALUE ;
    int length_max_i=0 ;
    int count_max=Integer.MIN_VALUE ;
    for(int i=0 ; i<strs.length ; i++){
      map.put(strs[i],map.getOrDefault(strs[i],0));
      map.put(strs[i],map.get(strs[i])+1);
      if(length_max<strs[i] .length()){
        length_max_i=i ;
      }
      length_max=Math.max(length_max,strs[i] .length());
      count_max=Math.max(count_max,map.get(strs[i]));
    }
    for(Map.Entry<String,Integer>entry : map.entrySet()){
      int a=entry.getValue();
      if(a==count_max){
        System.out.print(entry.getKey());
      }
    }
    System.out.println(" "+strs[length_max_i]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := sc.nextLine() ;
     var strs : Sequence(String) ; strs := s->split(" ") ;
    var map : Map(String,int) ; map := Map{} ;
    var length_max : int ; length_max := -2147483648 ;
    var length_max_i : int ; length_max_i := 0 ;
    var count_max : int ; count_max := -2147483648 ;
        var i : int ; i := 0 ; while i < strs->size() do ( (     map := map->union(Map{strs[i+1] |-> (if map->keys()->contains(strs[i+1]) then map->at(strs[i+1]) else 0 endif)}) ; 
     map := map->union(Map{strs[i+1] |-> map->at(strs[i+1]) + 1}) ; 
    if (length_max < strs[i+1]->size()) then (     length_max_i := i ) else skip ; 
    length_max := Set{length_max, strs[i+1]->size()}->max() ; 
    count_max := Set{count_max, map->at(strs[i+1])}->max() ; 
 )  ;     i := i + 1 ) ; 
    for (entry : map->asSet()) do ( (     var a : int ; a := entry.getValue() ;
     if (a = count_max) then (     OclFile["System.out"].print(entry.getKey()) ) else skip )  ) ; 
    OclFile["System.out"].println(" " + strs[length_max_i+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG1 {
  static int KthMinValAfterMconcatenate(int[] A,int N,int M,int K){
    Arrays.sort(A);
    return(A[((K-1)/M)]);
  }
  public static void main(String[] args){
    int[] A={
      3,1,2 };
      int M=3,K=4 ;
      int N=A.length ;
      System.out.println(KthMinValAfterMconcatenate(A,N,M,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG1 {
  static   operation KthMinValAfterMconcatenate( A : Sequence(int), N : int, M : int, K : int) : int
  pre: true
  post: true
  activity: (     A := A->sort() ; 
     return (A[((K - 1) / M)+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{3,1,2} ;
     var M : int ; M := 3 ;
    var K : int ; K := 4 ;
     var N : int ; N := A->size() ;
     OclFile["System.out"].println(KthMinValAfterMconcatenate(A, N, M, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Stack ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    Stack<Integer>stack=new Stack<Integer>();
    boolean inOrder=true ;
    for(int i=0 ; i<n ; i++){
      String input=br.readLine();
      if(input.equals("A")){
        stack.push(1);
      }
      else {
        if(stack.isEmpty()){
          inOrder=false ;
          break ;
        }
        stack.pop();
      }
    }
    if(stack.isEmpty()&& inOrder){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var stack : Sequence(int) ; stack := Sequence{} ;
    var inOrder : boolean ; inOrder := true ;
        var i : int ; i := 0 ; while i < n do ( (     var input : String ; input := br.readLine() ;
     if (input = "A") then (     stack := stack->append(1) ) else (     if (stack->isEmpty()) then (     inOrder := false ; 
     break ) else skip ; 
     stack := stack->front() ) )  ;     i := i + 1 ) ; 
    if (stack->isEmpty() & inOrder) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public void run(){
    int n=sc.nextInt();
    calc(n);
  }
  public void calc(int n){
    int counter=0 ;
    String ans="NO" ;
    for(int i=0 ; i<n ; i++){
      String s=sc.next();
      if(s.equals("A"))counter++;
      else if(s.equals("Un"))counter--;
      if(counter<0)break ;
    }
    if(counter==0)ans="YES" ;
    System.out.println(ans);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     execute calc(n) );
   operation calc( n : int) : void
  pre: true
  post: true
  activity: (     var counter : int ; counter := 0 ;
     var ans : String ; ans := "NO" ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
     if (s = "A") then     counter := counter + 1 else     if (s = "Un") then     counter := counter - 1 ; else skip ; ;  
     if (counter < 0) then     break else skip )  ;     i := i + 1 ) ; 
    if (counter = 0) then     ans := "YES" ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Spliterator ;
import java.util.Spliterators ;
import java.util.concurrent.ThreadLocalRandom ;
import java.util.concurrent.atomic.AtomicInteger ;
import java.util.stream.IntStream ;
import java.util.stream.Stream ;
import java.util.stream.StreamSupport ;
public class Main {
  static final Scanner s=new Scanner(System.in);
  static long[] fal_rnd(int size){
    AtomicInteger l=new AtomicInteger(-1),r=new AtomicInteger(size);
    long[] res=new long[size];
    INS(size).unordered().parallel().mapToLong(Long :: parseLong).forEach(v->res[ThreadLocalRandom.current().nextBoolean()? l.incrementAndGet(): r.decrementAndGet()]=v);
    return res ;
  }
  static IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static Stream<String>INS(long size){
    return StreamSupport.stream(Spliterators.spliterator(s,size,Spliterator.NONNULL & Spliterator.IMMUTABLE),false).limit(size);
  }
  public static void main(String[] __){
    int d=0 ;
    for(int i=s.nextInt(); i>0 ; i--){
      switch(s.next()){
        case "A" : d++;
        break ;
        case "Un" : d--;
        if(d<0){
          System.out.println("NO");
          return ;
        }
        break ;
      }
    }
    System.out.println(d==0 ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation fal_rnd( size : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var l : int ; l := (-1) ;
    var r : int ; r := (size) ;
     var res : Sequence(long) ; res := Integer.subrange(1,size)->collect(0) ;
     for v : INS(size)->collect( _x1 | (lambda _s : String in _s->toLong())->apply(_x1) ) do
    (    res[if MathLib.nextBoolean() then l+1 else r-1 endif+1] := v) ; 
     return res );
  static   operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static   operation INS( size : long) : Stream<String>
  pre: true
  post: true
  activity: (     return (OclIterator.newOclIterator_Sequence(s)).elements.subrange(1,size) );
  static   operation main( __ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : int ; d := 0 ;
         var i : int ; i := s.getCurrent()->toInteger() ; while i > 0 do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (s.getCurrent()) ; 
       if _switchval = "A" then
     d := d + 1 ; 
    break 
   else skip ;
       if _switchval = "Un" then
     d := d - 1 ; 
    if (d < 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    break 
   else skip ;
 )
 )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println(if d = 0 then "YES" else "NO" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      int count=Integer.parseInt(br.readLine());
      String aun[]=new String[count];
      for(int i=0 ; i<count ; i++){
        aun[i]=br.readLine();
      }
      if(aun[0] .equals("Un")){
        System.out.println("NO");
      }
      else {
        int aCount=0 ;
        int unCount=0 ;
        boolean aStart=true ;
        boolean no=false ;
        for(int i=0 ; i<count ; i++){
          if(aun[i] .equals("A")&& aStart){
            aCount++;
            if(aCount<unCount || aCount==unCount){
              no=true ;
              break ;
            }
            aStart=false ;
          }
          else if(aun[i] .equals("A")){
            if(aCount<unCount){
              no=true ;
              break ;
            }
            aCount++;
          }
          else if(aun[i] .equals("Un")){
            aStart=true ;
            unCount++;
          }
        }
        if(aCount!=unCount)no=true ;
        if(no){
          System.out.println("NO");
        }
        else {
          System.out.println("YES");
        }
      }
      br.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var count : int ; count := (br.readLine())->toInteger() ;
     var aun : Sequence(String) ; aun := Integer.subrange(1,count)->collect(null) ;
        var i : int ; i := 0 ; while i < count do ( (     aun[i+1] := br.readLine() )  ;     i := i + 1 ) ; 
    if (aun[0+1] = "Un") then (     OclFile["System.out"].println("NO") ) else (     var aCount : int ; aCount := 0 ;
     var unCount : int ; unCount := 0 ;
    var aStart : boolean ; aStart := true ;
    var no : boolean ; no := false ;
        var i : int ; i := 0 ; while i < count do ( (     if (aun[i+1] = "A" & aStart) then (     aCount := aCount + 1 ; 
     if (aCount < unCount or aCount = unCount) then (     no := true ; 
     break ) else skip ; 
     aStart := false ) else     if (aun[i+1] = "A") then (     if (aCount < unCount) then (     no := true ; 
     break ) else skip ; 
     aCount := aCount + 1 ) else     if (aun[i+1] = "Un") then (     aStart := true ; 
     unCount := unCount + 1 ) else skip ; ;  )  ;     i := i + 1 ) ; 
    if (aCount /= unCount) then     no := true ; else skip ; 
    if (no) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 ) ;  
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static void solve(){
    int n=in.nextInt();
    int p=0 ;
    for(int i=0 ; i<n ; i++){
      String s=in.next();
      if("A".equals(s)){
        p++;
      }
      else {
        p--;
      }
      if(p<0){
        out.println("NO");
        return ;
      }
    }
    if(p==0){
      out.println("YES");
    }
    else {
      out.println("NO");
    }
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    solve();
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var p : int ; p := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := in.getCurrent() ;
     if ("A" = s) then (     p := p + 1 ) else (     p := p - 1 ) ;  
     if (p < 0) then (     skip ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     if (p = 0) then (     skip ) else (     skip ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    execute solve() ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - (start)->char2byte()) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    Gates g=new Gates(n);
    for(int i=0 ; i<m ; i++){
      int l=sc.nextInt();
      int r=sc.nextInt();
      g.check(l,r);
    }
    g.printAns();
  }
}
class Gates {
  int l=1 ;
  int r ;
  Gates(int n){
    this.r=n ;
  }
  void check(int l,int r){
    if(this.l<l){
      this.l=l ;
    }
    if(this.r>r){
      this.r=r ;
    }
  }
  void printAns(){
    int ans=0 ;
    if(l<=r){
      ans=r-l+1 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var g : Gates ; g := Gates.newGates(n) ;
        var i : int ; i := 0 ; while i < m do ( (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
     g.check(l, r) )  ;     i := i + 1 ) ; 
    g.printAns() ; 
 );
}
class Gates {
   attribute l : int := 1;
   attribute r : int;
   static operation newGates( n : int) : Gates
  pre: true
  post: true
  activity:
  ( var self : Gates ;
    self := createGates();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     self.r := n );
   operation check( l : int, r : int) : void
  pre: true
  post: true
  activity: (     if (self.l < l) then (     self.l := l ) else skip ; 
     if (self.r > r) then (     self.r := r ) else skip );
   operation printAns() : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     if (l <= r) then (     ans := r - l + 1 ) else skip ; 
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        String s=sc.next();
        char[] ch=s.toCharArray();
        for(int i=0 ; i<ch.length ; i++){
          if((i+1)% 2!=0){
            if(ch[i]!='a')ch[i]='a' ;
            else ch[i]='b' ;
          }
          else if((i+1)% 2==0){
            if(ch[i]!='z')ch[i]='z' ;
            else ch[i]='y' ;
          }
        }
        s=String.valueOf(ch);
        System.out.println(s);
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : String ; s := sc.getCurrent() ;
     var ch : Sequence(String) ; ch := s->characters() ;
        var i : int ; i := 0 ; while i < ch->size() do ( (     if ((i + 1) mod 2 /= 0) then (     if (ch[i+1] /= 'a') then     ch[i+1] := 'a' ; else     ch[i+1] := 'b' ; ) else     if ((i + 1) mod 2 = 0) then (     if (ch[i+1] /= 'z') then     ch[i+1] := 'z' ; else     ch[i+1] := 'y' ; ) else skip ; )  ;     i := i + 1 ) ; 
    s := (ch)->sum()  ; 
    OclFile["System.out"].println(s) ; 
 ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    Solver solver=new Solver();
    solver.init();
    solver.readHead(in.readLine());
    for(; solver.hasNext(); ){
      solver.readBody(in.readLine());
    }
    solver.solve();
  }
}
class Solver {
  int N ;
  int cnt ;
  public void init(){
    N=0 ;
    cnt=0 ;
  }
  public void readHead(String str){
    String[] strArr=str.split(" ");
    N=Integer.parseInt(strArr[0]);
    M=Integer.parseInt(strArr[1]);
    L=1 ;
    R=N ;
  }
  int M ;
  int L ;
  int R ;
  public boolean hasNext(){
    return cnt<M ;
  }
  public void readBody(String str){
    String[] strArr=str.split(" ");
    int l=Integer.parseInt(strArr[0]);
    int r=Integer.parseInt(strArr[1]);
    if(l>L)L=l ;
    if(r<R)R=r ;
    cnt++;
  }
  public void solve(){
    int ans=0 ;
    if(L<=R)ans=R-L+1 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var solver : Solver ; solver := Solver.newSolver() ;
    solver.init() ; 
    solver.readHead(in.readLine()) ; 
      while solver.hasNext() do ( (     solver.readBody(in.readLine()) )  ) ; 
    solver.solve() ; 
 );
}
class Solver {
   attribute N : int;
   attribute cnt : int;
   operation init() : void
  pre: true
  post: true
  activity: (     N := 0 ; 
     cnt := 0 );
   operation readHead( str : String) : void
  pre: true
  post: true
  activity: (     var strArr : Sequence(String) ; strArr := str->split(" ") ;
     N := (strArr[0+1])->toInteger() ; 
    M := (strArr[1+1])->toInteger() ; 
    L := 1 ; 
    R := N ; 
 );
   attribute M : int;
   attribute L : int;
   attribute R : int;
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return cnt < M );
   operation readBody( str : String) : void
  pre: true
  post: true
  activity: (     var strArr : Sequence(String) ; strArr := str->split(" ") ;
     var l : int ; l := (strArr[0+1])->toInteger() ;
    var r : int ; r := (strArr[1+1])->toInteger() ;
    if (l > L) then     L := l ; else skip ; 
    if (r < R) then     R := r ; else skip ; 
    cnt := cnt + 1 ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     if (L <= R) then     ans := R - L + 1 ; else skip ; 
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int m=Integer.parseInt(sc.next());
    int[] a={
      0,100001 };
      boolean flag=true ;
      while(m>0){
        int l=Integer.parseInt(sc.next());
        int r=Integer.parseInt(sc.next());
        if(r<a[0] || a[1]<l){
          System.out.println(0);
          flag=false ;
          break ;
        }
        if(a[0]<l){
          a[0]=l ;
        }
        if(r<a[1]){
          a[1]=r ;
        }
        m--;
      }
      sc.close();
      if(flag){
        System.out.println(a[1]-a[0]+1);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var m : int ; m := (sc.getCurrent())->toInteger() ;
    var a : Sequence(int) ; a := Sequence{0,100001} ;
    var flag : boolean ; flag := true ;
    while (m > 0) do (     var l : int ; l := (sc.getCurrent())->toInteger() ;
     var r : int ; r := (sc.getCurrent())->toInteger() ;
    if (r < a[0+1] or a[1+1] < l) then (     OclFile["System.out"].println(0) ; 
     flag := false ; 
     break ) else skip ; 
    if (a[0+1] < l) then (     a[0+1] := l ) else skip ; 
    if (r < a[1+1]) then (     a[1+1] := r ) else skip ; 
    m := m - 1 ; 
 ) ; 
    skip ; 
    if (flag) then (     OclFile["System.out"].println(a[1+1] - a[0+1] + 1) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void pyramid(int n){
    int i,j,num,gap ;
    for(i=n ; i>=1 ; i--){
      for(gap=n-1 ; gap>=i ; gap--){
        System.out.print(" ");
        System.out.print(" ");
      }
      num='A' ;
      for(j=1 ; j<=i ; j++){
        System.out.print((char)num+++" ");
      }
      for(j=i-1 ; j>=0 ; j--){
        System.out.print((char)--num+" ");
      }
      System.out.println("");
    }
  }
  public static void main(String[] args){
    int n=9 ;
    pyramid(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pyramid( n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var num : int ;
    var gap : int ;
         i := n ; while i >= 1 do ( (         gap := n - 1 ; while gap >= i do ( (     OclFile["System.out"].print(" ") ; 
     OclFile["System.out"].print(" ") )  ;     gap := gap - 1 ) ; 
     num := 'A' ; 
        j := 1 ; while j <= i do ( (     OclFile["System.out"].print(num->oclAsType(String) + " ") )  ;     j := j + 1 ) ; 
        j := i - 1 ; while j >= 0 do ( (     OclFile["System.out"].print((num - 1)->oclAsType(String) + " ") )  ;     j := j - 1 ) ; 
    OclFile["System.out"].println("") ; 
 )  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     execute pyramid(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[][] l=new int[m][2];
    for(int i=0 ; i<m ; i++){
      for(int j=0 ; j<2 ; j++){
        l[i][j]=sc.nextInt();
      }
    }
    int[] nn=new int[n+1];
    for(int i=0 ; i<m ; i++){
      int s=l[i][0];
      int e=l[i][1];
      for(int j=s ; j<e+1 ; j++){
        nn[j]++;
      }
    }
    int ans=0 ;
    for(int i=0 ; i<nn.length ; i++){
      if(nn[i]==m)ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var l : Sequence(Sequence(int)) ; l := Integer.subrange(1,m)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j < 2 do ( (     l[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var nn : Sequence(int) ; nn := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     var s : int ; s := l[i+1][0+1] ;
     var e : int ; e := l[i+1][1+1] ;
         var j : int ; j := s ; while j < e + 1 do ( (     nn[j+1] := nn[j+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < nn->size() do ( (     if (nn[i+1] = m) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int m=Integer.parseInt(sc.next());
    int[] l=new int[m];
    int[] r=new int[m];
    for(int i=0 ; i<m ; i++){
      l[i]=Integer.parseInt(sc.next());
      r[i]=Integer.parseInt(sc.next());
    }
    int left=Arrays.stream(l).max().getAsInt();
    int right=Arrays.stream(r).min().getAsInt();
    int result=Math.max(0,right-left+1);
    System.out.println(result);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var m : int ; m := (sc.getCurrent())->toInteger() ;
    var l : Sequence(int) ; l := Integer.subrange(1,m)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     l[i+1] := (sc.getCurrent())->toInteger() ; 
     r[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var left : int ; left := stream(l).max().getAsInt() ;
    var right : int ; right := stream(r).min().getAsInt() ;
    var result : int ; result := Set{0, right - left + 1}->max() ;
    OclFile["System.out"].println(result) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    String s=sc.next();
    String t=sc.next();
    int i=0 ;
    while(i<n && i<m && s.charAt(i)==t.charAt(i)){
      i++;
    }
    if(n-m>1){
      System.out.println("NO");
    }
    else if(i==n){
      if(i==m){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    else if(s.charAt(i)=='*'){
      i++;
      while(i<n && s.charAt(i)==t.charAt(i+m-n)){
        i++;
      }
      if(i==n){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var i : int ; i := 0 ;
    while (i < n & i < m & s->at(i+1) = t->at(i+1)) do (     i := i + 1 ) ; 
    if (n - m > 1) then (     OclFile["System.out"].println("NO") ) else     if (i = n) then (     if (i = m) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else     if (s->at(i+1) = '*') then (     i := i + 1 ; 
     while (i < n & s->at(i+1) = t->at(i + m - n+1)) do (     i := i + 1 ) ; 
     if (i = n) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else (     OclFile["System.out"].println("NO") ) ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sc.nextInt();
    sc.nextInt();
    String s=sc.next();
    String t=sc.next();
    System.out.println(solve(s,t)? "YES" : "NO");
    sc.close();
  }
  static boolean solve(String s,String t){
    int wildcardIndex=s.indexOf('*');
    if(wildcardIndex==-1){
      return s.equals(t);
    }
    else {
      return s.length()-1<=t.length()&& t.startsWith(s.substring(0,wildcardIndex))&& t.endsWith(s.substring(wildcardIndex+1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    skip ; 
    var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    OclFile["System.out"].println(if solve(s, t) then "YES" else "NO" endif) ; 
    skip ; 
 );
  static   operation solve( s : String, t : String) : boolean
  pre: true
  post: true
  activity: (     var wildcardIndex : int ; wildcardIndex := s->indexOf('*')-1 ;
     if (wildcardIndex = -1) then (     return s = t ) else (     return s->size() - 1 <= t->size() & t->hasPrefix(s.subrange(0+1,wildcardIndex)) & t->hasSuffix(s.subrange(wildcardIndex + 1+1,wildcardIndex + 1)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isPossible(int Sx,int Sy,int Dx,int Dy,int x,int y){
    if(Math.abs(Sx-Dx)% x==0 && Math.abs(Sy-Dy)% y==0 &&(Math.abs(Sx-Dx)/x)% 2==(Math.abs(Sy-Dy)/y)% 2)return true ;
    return false ;
  }
  public static void main(String[] args){
    int Sx=0,Sy=0,Dx=0,Dy=0 ;
    int x=3,y=4 ;
    if(isPossible(Sx,Sy,Dx,Dy,x,y))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPossible( Sx : int, Sy : int, Dx : int, Dy : int, x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     if (if Sx - Dx < 0 then -(Sx - Dx) else Sx - Dx endif mod x = 0 & if Sy - Dy < 0 then -(Sy - Dy) else Sy - Dy endif mod y = 0 & (if Sx - Dx < 0 then -(Sx - Dx) else Sx - Dx endif / x) mod 2 = (if Sy - Dy < 0 then -(Sy - Dy) else Sy - Dy endif / y) mod 2) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Sx : int ; Sx := 0 ;
    var Sy : int ; Sy := 0 ;
    var Dx : int ; Dx := 0 ;
    var Dy : int ; Dy := 0 ;
     var x : int ; x := 3 ;
    var y : int ; y := 4 ;
     if (isPossible(Sx, Sy, Dx, Dy, x, y)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p030 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p030().run());
  }
  public String run(){
    int sum=0 ;
    for(int i=2 ; i<1000000 ; i++){
      if(i==fifthPowerDigitSum(i))sum+=i ;
    }
    return Integer.toString(sum);
  }
  private static int fifthPowerDigitSum(int x){
    int sum=0 ;
    while(x!=0){
      int y=x % 10 ;
      sum+=y*y*y*y*y ;
      x/=10 ;
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p030 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p030.newp030().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 2 ; while i < 1000000 do ( (     if (i = fifthPowerDigitSum(i)) then     sum := sum+(i) ; else skip )  ;     i := i + 1 ) ; 
     return ((sum) + "") );
  static   operation fifthPowerDigitSum( x : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (x /= 0) do (     var y : int ; y := x mod 10 ;
     sum := sum+(y * y * y * y * y) ; 
     x := x/(10) ) ; 
     return sum );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().solver();
  }
  void solver(){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    long P=sc.nextLong();
    long Q=sc.nextLong();
    long[] C=new long[(int)N];
    for(int i=0 ; i<N ; i++){
      C[i]=sc.nextInt();
    }
    Long[] a=new Long[(int)N];
    for(int i=0 ; i<N ; i++){
      a[i]=C[i]+i*P ;
    }
    Arrays.sort(a,new Comparator<Long>(){
      @ Override public int compare(Long o1,Long o2){
        return-Long.compare(o1,o2);
      }
    }
);
    for(int i=1 ; i<N ; i++){
      a[i]+=a[i-1];
    }
    long ans=P*N*(2*Q+N-1)/2 ;
    long diff=N*(N-1)*P/2 ;
    for(int i=0 ; i<N ; i++){
      ans=Math.max(ans,a[i]+P*(N-(i+1))*(2*Q+2*(N-(i+1)-1))/2-diff);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solver() );
   operation solver() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    var P : long ; P := sc.getCurrent()->toLong() ;
    var Q : long ; Q := sc.getCurrent()->toLong() ;
    var C : Sequence(long) ; C := Integer.subrange(1,N->oclAsType(int))->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     C[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var a : Sequence(long) ; a := Integer.subrange(1,N->oclAsType(int))->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := C[i+1] + i * P )  ;     i := i + 1 ) ; 
    a := OclComparator.sortWith(a, OclComparator<long>.newOclComparator()) ; 
        var i : int ; i := 1 ; while i < N do ( (     a[i+1] := a[i+1]+(a[i - 1+1]) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := P * N * (2 * Q + N - 1) / 2 ;
    var diff : long ; diff := N * (N - 1) * P / 2 ;
        var i : int ; i := 0 ; while i < N do ( (     ans := Set{ans, a[i+1] + P * (N - (i + 1)) * (2 * Q + 2 * (N - (i + 1) - 1)) / 2 - diff}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class YetAnotherStringGame {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      StringBuilder sb=new StringBuilder(sc.next());
      for(int i=0 ; i<sb.length(); i++){
        if((i & 1)==0){
          if(sb.charAt(i)=='a'){
            sb.setCharAt(i,'b');
          }
          else {
            sb.setCharAt(i,'a');
          }
        }
        else {
          if(sb.charAt(i)=='z'){
            sb.setCharAt(i,'y');
          }
          else {
            sb.setCharAt(i,'z');
          }
        }
      }
      System.out.println(sb);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class YetAnotherStringGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var sb : String ; sb := StringLib.newString(sc.getCurrent()) ;
         var i : int ; i := 0 ; while i < sb->size() do ( (     if ((MathLib.bitwiseAnd(i,1)) = 0) then (     if (sb->at(i+1) = 'a') then (     sb := sb.setAt(i+1, 'b') ) else (     sb := sb.setAt(i+1, 'a') ) ) else (     if (sb->at(i+1) = 'z') then (     sb := sb.setAt(i+1, 'y') ) else (     sb := sb.setAt(i+1, 'z') ) ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sb) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    long N=scan.nextInt();
    long P=scan.nextInt();
    long Q=scan.nextInt();
    long C[]=new long[(int)N];
    long ans=0 ;
    for(int i=0 ; i<N ; i++){
      long num=scan.nextInt();
      C[i]=(Q-i)*P-num ;
      ans+=num ;
    }
    Arrays.sort(C);
    long S=ans ;
    for(int i=0 ; i<N ; i++){
      S+=C[(int)N-i-1];
      S+=i*P*2 ;
      ans=Math.max(ans,S);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := scan.getCurrent()->toInteger() ;
    var P : long ; P := scan.getCurrent()->toInteger() ;
    var Q : long ; Q := scan.getCurrent()->toInteger() ;
    var C : Sequence(long) ; C := Integer.subrange(1,N->oclAsType(int))->collect(0) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var num : long ; num := scan.getCurrent()->toInteger() ;
     C[i+1] := (Q - i) * P - num ; 
     ans := ans+(num) )  ;     i := i + 1 ) ; 
    C := C->sort() ; 
    var S : long ; S := ans ;
        var i : int ; i := 0 ; while i < N do ( (     S := S+(C[N->oclAsType(int) - i - 1+1]) ; 
     S := S+(i * P * 2) ; 
     ans := Set{ans, S}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countDistinctCode(String str){
    Set<String>codes=new HashSet<>();
    for(int i=0 ; i<str.length()-1 ; i++)codes.add(str.substring(i,i+2));
    return codes.size();
  }
  public static void main(String[] args){
    String str="UPUP" ;
    System.out.println(countDistinctCode(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDistinctCode( str : String) : int
  pre: true
  post: true
  activity: (     var codes : Set(String) ; codes := Set{} ;
         var i : int ; i := 0 ; while i < str->size() - 1 do (     codes := codes->including(str.subrange(i+1,i + 2)) ;  ;     i := i + 1 ) ; 
     return codes->size() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "UPUP" ;
     OclFile["System.out"].println(countDistinctCode(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSubSeq(String str,int len){
    int ans=0 ;
    int mul=1 ;
    for(int i=0 ; i<len ; i++){
      if(str.charAt(i)=='0')ans+=mul ;
      mul*=2 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    String str="10010" ;
    int len=str.length();
    System.out.print(countSubSeq(str,len));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSubSeq( str : String, len : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var mul : int ; mul := 1 ;
         var i : int ; i := 0 ; while i < len do ( (     if (str->at(i+1) = '0') then     ans := ans+(mul) ; else skip ; 
     mul := mul*(2) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "10010" ;
     var len : int ; len := str->size() ;
     OclFile["System.out"].print(countSubSeq(str, len)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      String s=sc.next();
      String n="a" ;
      int p=0 ;
      for(char ch='b' ; ch<='z' && p<s.length()-1 ; ch++){
        if(s.indexOf(ch)==-1){
          break ;
        }
        else if(s.lastIndexOf(ch)!=s.indexOf(ch)){
          break ;
        }
        else {
          int start=s.indexOf(n.charAt(0));
          int end=s.indexOf(n.charAt(n.length()-1));
          int curri=s.indexOf(ch);
          if(curri+1==end || curri-1==end || curri+1==start || curri-1==start){
            if(curri>end){
              n=n+ch ;
            }
            else {
              n=ch+n ;
            }
          }
          else {
            break ;
          }
        }
        p++;
      }
      if(n.equals(s)){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var s : String ; s := sc.getCurrent() ;
     var n : String ; n := "a" ;
    var p : int ; p := 0 ;
        var ch : String ; ch := 'b' ; while ch <= 'z' & p < s->size() - 1 do ( (     if (s->indexOf(ch)-1 = -1) then (     break ) else     if (s->lastIndexOf(ch)-1 /= s->indexOf(ch)-1) then (     break ) else (     var start : int ; start := s->indexOf(n->at(0+1))-1 ;
     var end : int ; end := s->indexOf(n->at(n->size() - 1+1))-1 ;
     var curri : int ; curri := s->indexOf(ch)-1 ;
     if (curri + 1 = end or curri - 1 = end or curri + 1 = start or curri - 1 = start) then (     if (curri > end) then (     n := n + ch ) else (     n := ch + n ) ) else (     break ) ) ;  ;  
     p := p + 1 )  ;     ch := ch + 1 ) ; 
    if (n = s) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static final int INF=2000000000 ;
  int N,diff ;
  int[] A ;
  Scanner sc ;
  void update(int i,int v){
    int d1=0,d2=0 ;
    if(A[i-1]>A[i])d1++;
    if(A[i]>A[i+1])d1++;
    A[i]=v ;
    if(A[i-1]>A[i])d2++;
    if(A[i]>A[i+1])d2++;
    diff+=(d2-d1);
  }
  void activate(){
    sc=new Scanner(System.in);
    N=sc.nextInt();
    A=new int[N+2];
    for(int i=1 ; i<=N ; i++)A[i]=sc.nextInt();
    A[0]=-INF ;
    A[N+1]=INF ;
    System.out.println(solve());
  }
  int solve(){
    int a,b,q,v1,v2 ;
    diff=0 ;
    for(int i=1 ; i<=N ; i++){
      if(A[i-1]>A[i])diff++;
    }
    if(diff==0)return 0 ;
    q=sc.nextInt();
    for(int i=1 ; i<=q ; i++){
      a=sc.nextInt();
      b=sc.nextInt();
      v1=A[a];
      v2=A[b];
      update(a,v2);
      update(b,v1);
      if(diff==0)return i ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    new Main().activate();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := 2000000000;
   attribute N : int;
   attribute A : Sequence(int);
   attribute sc : OclFile;
   operation update( i : int, v : int) : void
  pre: true
  post: true
  activity: (     var d1 : int ; d1 := 0 ;
    var d2 : int ; d2 := 0 ;
     if (A[i - 1+1] > A[i+1]) then     d1 := d1 + 1 ; else skip ; 
    if (A[i+1] > A[i + 1+1]) then     d1 := d1 + 1 ; else skip ; 
    A[i+1] := v ; 
    if (A[i - 1+1] > A[i+1]) then     d2 := d2 + 1 ; else skip ; 
    if (A[i+1] > A[i + 1+1]) then     d2 := d2 + 1 ; else skip ; 
    diff := diff+((d2 - d1)) ; 
 );
   operation activate() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     N := sc.getCurrent()->toInteger() ; 
    A := Integer.subrange(1,N + 2)->collect(0) ; 
        var i : int ; i := 1 ; while i <= N do (     A[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    A[0+1] := -INF ; 
    A[N + 1+1] := INF ; 
    OclFile["System.out"].println(solve()) ; 
 );
   operation solve() : int
  pre: true
  post: true
  activity: (     var a : int ;
    var b : int ;
    var q : int ;
    var v1 : int ;
    var v2 : int ;
     diff := 0 ; 
        var i : int ; i := 1 ; while i <= N do ( (     if (A[i - 1+1] > A[i+1]) then     diff := diff + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (diff = 0) then     return 0 else skip ; 
    q := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i <= q do ( (     a := sc.getCurrent()->toInteger() ; 
     b := sc.getCurrent()->toInteger() ; 
    v1 := A[a+1] ; 
    v2 := A[b+1] ; 
    execute update(a, v2) ; 
    execute update(b, v1) ; 
    if (diff = 0) then     return i else skip ; 
 )  ;     i := i + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().activate() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    Set<Integer>nsorted=new HashSet<Integer>();
    a[0]=sc.nextInt();
    for(int i=1 ; i<n ; i++){
      a[i]=sc.nextInt();
      if(a[i-1]>a[i]){
        nsorted.add(i-1);
      }
    }
    int q=sc.nextInt();
    int ans=-1 ;
    if(nsorted.isEmpty()){
      ans=0 ;
    }
    else {
      for(int i=1 ; i<=q ; i++){
        int x=sc.nextInt()-1 ;
        int y=sc.nextInt()-1 ;
        int tmp=a[x];
        a[x]=a[y];
        a[y]=tmp ;
        if(x-1>=0){
          if(a[x-1]>a[x]){
            nsorted.add(x-1);
          }
          else {
            nsorted.remove(x-1);
          }
        }
        if(x+1<n){
          if(a[x]>a[x+1]){
            nsorted.add(x);
          }
          else {
            nsorted.remove(x);
          }
        }
        if(y-1>=0){
          if(a[y-1]>a[y]){
            nsorted.add(y-1);
          }
          else {
            nsorted.remove(y-1);
          }
        }
        if(y+1<n){
          if(a[y]>a[y+1]){
            nsorted.add(y);
          }
          else {
            nsorted.remove(y);
          }
        }
        if(nsorted.isEmpty()){
          ans=i ;
          break ;
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var nsorted : Set(int) ; nsorted := Set{} ;
    a[0+1] := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (a[i - 1+1] > a[i+1]) then (     nsorted := nsorted->including(i - 1) ) else skip )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := -1 ;
    if (nsorted->isEmpty()) then (     ans := 0 ) else (         var i : int ; i := 1 ; while i <= q do ( (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
     var y : int ; y := sc.getCurrent()->toInteger() - 1 ;
    var tmp : int ; tmp := a[x+1] ;
    a[x+1] := a[y+1] ; 
    a[y+1] := tmp ; 
    if (x - 1 >= 0) then (     if (a[x - 1+1] > a[x+1]) then (     nsorted := nsorted->including(x - 1) ) else (     nsorted := nsorted->excludingFirst(x - 1) ) ) else skip ; 
    if (x + 1 < n) then (     if (a[x+1] > a[x + 1+1]) then (     nsorted := nsorted->including(x) ) else (     nsorted := nsorted->excludingAt(x+1) ) ) else skip ; 
    if (y - 1 >= 0) then (     if (a[y - 1+1] > a[y+1]) then (     nsorted := nsorted->including(y - 1) ) else (     nsorted := nsorted->excludingFirst(y - 1) ) ) else skip ; 
    if (y + 1 < n) then (     if (a[y+1] > a[y + 1+1]) then (     nsorted := nsorted->including(y) ) else (     nsorted := nsorted->excludingAt(y+1) ) ) else skip ; 
    if (nsorted->isEmpty()) then (     ans := i ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  static void FindRatio(int a,int b,int c){
    int up=Math.abs(b-c);
    int down=Math.abs(c-a);
    int g=gcd(up,down);
    up/=g ;
    down/=g ;
    System.out.println(up+":"+down);
  }
  public static void main(String[] args){
    int a=4,b=10,c=6 ;
    FindRatio(a,b,c);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation FindRatio( a : int, b : int, c : int) : void
  pre: true
  post: true
  activity: (     var up : int ; up := if b - c < 0 then -(b - c) else b - c endif ;
     var down : int ; down := if c - a < 0 then -(c - a) else c - a endif ;
    var g : int ; g := gcd(up, down) ;
    up := up/(g) ; 
    down := down/(g) ; 
    OclFile["System.out"].println(up + ":" + down) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 4 ;
    var b : int ; b := 10 ;
    var c : int ; c := 6 ;
     execute FindRatio(a, b, c) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Review3 {
  public static void main(String[] args){
    Scanner UserInput=new Scanner(System.in);
    int num=UserInput.nextInt();
    int hour=UserInput.nextInt();
    ArrayList<Integer>subjects=new ArrayList<>(num);
    for(int i=0 ; i<num ; i++){
      subjects.add(UserInput.nextInt());
    }
    Collections.sort(subjects);
    long sum=0 ;
    for(int i=0 ; i<num ; i++){
      sum+=(long)subjects.get(i)*(long)hour ;
      if(hour>1)hour--;
    }
    System.out.println(sum);
    UserInput.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Review3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var UserInput : OclFile ; UserInput := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := UserInput.getCurrent()->toInteger() ;
    var hour : int ; hour := UserInput.getCurrent()->toInteger() ;
    var subjects : Sequence(int) ; subjects := Sequence{} ;
        var i : int ; i := 0 ; while i < num do ( (     subjects := subjects->including(UserInput.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    subjects := subjects->sort() ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < num do ( (     sum := sum+(subjects->at(i+1)->oclAsType(long) * hour->oclAsType(long)) ; 
     if (hour > 1) then     hour := hour - 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Test2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x=sc.nextInt();
    List<Integer>c=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      c.add(sc.nextInt());
    }
    Collections.sort(c);
    long max=0 ;
    for(int i=0 ; i<n ; i++){
      max+=1L*c.get(i)*x ;
      if(x>1)x--;
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var c : Sequence(int) ; c := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     c := c->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    c := c->sort() ; 
    var max : long ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     max := max+(1L * c->at(i+1) * x) ; 
     if (x > 1) then     x := x - 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedOutputStream ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class devu {
  public static void main(String[] args)throws Exception {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    StringTokenizer st=new StringTokenizer(in.readLine());
    int n=Integer.parseInt(st.nextToken());
    int x=Integer.parseInt(st.nextToken());
    Long[] nums=new Long[n];
    StringTokenizer st1=new StringTokenizer(in.readLine());
    for(int i=0 ; i<n ; i++){
      nums[i]=Long.parseLong(st1.nextToken());
    }
    Arrays.parallelSort(nums);
    long res=0 ;
    long curr=x ;
    for(int i=0 ; i<n ; i++){
      res+=curr*nums[i];
      if(curr>1)curr--;
    }
    out.println(res);
    in.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class devu {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(in.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var x : int ; x := (st.next())->toInteger() ;
    var nums : Sequence(long) ; nums := Integer.subrange(1,n)->collect(null) ;
    var st1 : OclIterator ; st1 := OclIterator.newOclIterator_String(in.readLine()) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := (st1.next())->toLong() )  ;     i := i + 1 ) ; 
    nums := nums->sort() ; 
    var res : long ; res := 0 ;
    var curr : long ; curr := x ;
        var i : int ; i := 0 ; while i < n do ( (     res := res+(curr * nums[i+1]) ; 
     if (curr > 1) then     curr := curr - 1 ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMinimumSubsequences(String A,String B){
    int numberOfSubsequences=1 ;
    int sizeOfB=B.length();
    int sizeOfA=A.length();
    int inf=1000000 ;
    int[][] next=new int[26][sizeOfB];
    for(int i=0 ; i<26 ; i++){
      for(int j=0 ; j<sizeOfB ; j++){
        next[i][j]=inf ;
      }
    }
    for(int i=0 ; i<sizeOfB ; i++){
      next[B.charAt(i)-'a'][i]=i ;
    }
    for(int i=0 ; i<26 ; i++){
      for(int j=sizeOfB-2 ; j>=0 ; j--){
        if(next[i][j]==inf){
          next[i][j]=next[i][j+1];
        }
      }
    }
    int pos=0 ;
    int i=0 ;
    while(i<sizeOfA){
      if(pos==0 && next[A.charAt(i)-'a'][pos]==inf){
        numberOfSubsequences=-1 ;
        break ;
      }
      else if(pos<sizeOfB && next[A.charAt(i)-'a'][pos]<inf){
        int nextIndex=next[A.charAt(i)-'a'][pos]+1 ;
        pos=nextIndex ;
        i++;
      }
      else {
        numberOfSubsequences++;
        pos=0 ;
      }
    }
    return numberOfSubsequences ;
  }
  public static void main(String[] args){
    String A="aacbe" ;
    String B="aceab" ;
    System.out.print(findMinimumSubsequences(A,B));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMinimumSubsequences( A : String, B : String) : int
  pre: true
  post: true
  activity: (     var numberOfSubsequences : int ; numberOfSubsequences := 1 ;
     var sizeOfB : int ; sizeOfB := B->size() ;
    var sizeOfA : int ; sizeOfA := A->size() ;
    var inf : int ; inf := 1000000 ;
    var next : Sequence(Sequence(int)) ; next := Integer.subrange(1,26)->collect(Integer.subrange(1,sizeOfB)->collect(0)) ;
        var i : int ; i := 0 ; while i < 26 do ( (         var j : int ; j := 0 ; while j < sizeOfB do ( (     next[i+1][j+1] := inf )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < sizeOfB do ( (     next[B->at(i+1) - ('a')->char2byte()+1][i+1] := i )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 26 do ( (         var j : int ; j := sizeOfB - 2 ; while j >= 0 do ( (     if (next[i+1][j+1] = inf) then (     next[i+1][j+1] := next[i+1][j + 1+1] ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    var pos : int ; pos := 0 ;
    var i : int ; i := 0 ;
    while (i < sizeOfA) do (     if (pos = 0 & next[A->at(i+1) - ('a')->char2byte()+1][pos+1] = inf) then (     numberOfSubsequences := -1 ; 
     break ) else     if (pos < sizeOfB & next[A->at(i+1) - ('a')->char2byte()+1][pos+1] < inf) then (     var nextIndex : int ; nextIndex := next[A->at(i+1) - ('a')->char2byte()+1][pos+1] + 1 ;
     pos := nextIndex ; 
     i := i + 1 ) else (     numberOfSubsequences := numberOfSubsequences + 1 ; 
     pos := 0 ) ;  ) ; 
    return numberOfSubsequences 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : String ; A := "aacbe" ;
     var B : String ; B := "aceab" ;
     OclFile["System.out"].print(findMinimumSubsequences(A, B)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int countPairs(String str){
    int result=0 ;
    int n=str.length();
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++)if(Math.abs(str.charAt(i)-str.charAt(j))==Math.abs(i-j))result++;
    return result ;
  }
  public static void main(String args[]){
    String str="geeksforgeeks" ;
    System.out.println(countPairs(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation countPairs( str : String) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var n : int ; n := str->size() ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do (     if (if str->at(i+1) - str->at(j+1) < 0 then -(str->at(i+1) - str->at(j+1)) else str->at(i+1) - str->at(j+1) endif = if i - j < 0 then -(i - j) else i - j endif) then     result := result + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     OclFile["System.out"].println(countPairs(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static final int MAX_CHAR=26 ;
  static int countPairs(String str){
    int result=0 ;
    int n=str.length();
    for(int i=0 ; i<n ; i++)for(int j=1 ; (i+j)<n && j<=MAX_CHAR ; j++)if((Math.abs(str.charAt(i+j)-str.charAt(i))==j))result++;
    return result ;
  }
  public static void main(String args[]){
    String str="geeksforgeeks" ;
    System.out.println(countPairs(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static    attribute MAX_CHAR : int := 26;
  static   operation countPairs( str : String) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var n : int ; n := str->size() ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 1 ; while (i + j) < n & j <= MAX_CHAR do (     if ((if str->at(i + j+1) - str->at(i+1) < 0 then -(str->at(i + j+1) - str->at(i+1)) else str->at(i + j+1) - str->at(i+1) endif = j)) then     result := result + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     OclFile["System.out"].println(countPairs(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.*;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      if(n<2)n=2 ;
      Integer a[]=new Integer[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      Arrays.sort(a);
      int s=1 ;
      double b=a[1]-a[0];
      for(int i=1 ; i<n-1 ; i++){
        double c=a[i+1]-a[i];
        if(b>c){
          b=c ;
          s=1 ;
        }
        else if(b==c)s++;
      }
      out.printf("%.0f",b);
      out.println(" "+s);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     if (n < 2) then     n := 2 ; else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var s : int ; s := 1 ;
    var b : double ; b := a[1+1] - a[0+1] ;
        var i : int ; i := 1 ; while i < n - 1 do ( (     var c : double ; c := a[i + 1+1] - a[i+1] ;
     if (b > c) then (     b := c ; 
     s := 1 ) else     if (b = c) then     s := s + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Locale ;
import java.util.StringTokenizer ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      Integer[] a=new Integer[n];
      ;
      int sum=0 ;
      int min=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      Arrays.sort(a);
      min=Math.abs(a[0]-a[1]);
      for(int i=0 ; i<n ; i++){
        for(int j=i+1 ; j<n ; j++){
          int b=Math.abs(a[i]-a[j]);
          if(b==min){
            sum++;
          }
          else if(b<min){
            min=b ;
            sum=1 ;
          }
          else break ;
        }
      }
      out.print(min+" "+sum);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(null) ;
    var sum : int ; sum := 0 ;
    var min : int ; min := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    min := if a[0+1] - a[1+1] < 0 then -(a[0+1] - a[1+1]) else a[0+1] - a[1+1] endif ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var b : int ; b := if a[i+1] - a[j+1] < 0 then -(a[i+1] - a[j+1]) else a[i+1] - a[j+1] endif ;
     if (b = min) then (     sum := sum + 1 ) else     if (b < min) then (     min := b ; 
     sum := 1 ) else     break ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  static final Scanner cin=new Scanner(System.in);
  public static void main(String[] args){
    int t=cin.nextInt();
    while(t>0){
      solve();
      t--;
    }
  }
  public static void solve(){
    String a=cin.next();
    char init='a' ;
    int pos=a.indexOf('a');
    if(pos==-1){
      System.out.println("NO");
      return ;
    }
    int left=pos ;
    int right=pos ;
    for(int i=1 ; i<a.length(); i++){
      init++;
      pos=a.indexOf(init);
      if(pos==-1){
        System.out.println("NO");
        return ;
      }
      if(pos==left-1){
        left--;
      }
      else if(pos==right+1){
        right++;
      }
      else {
        System.out.println("NO");
        return ;
      }
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute cin : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := cin.getCurrent()->toInteger() ;
     while (t > 0) do (     execute solve() ; 
     t := t - 1 ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var a : String ; a := cin.getCurrent() ;
     var init : String ; init := 'a' ;
    var pos : int ; pos := a->indexOf('a')-1 ;
    if (pos = -1) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    var left : int ; left := pos ;
    var right : int ; right := pos ;
        var i : int ; i := 1 ; while i < a->size() do ( (     init := init + 1 ; 
     pos := a->indexOf(init)-1 ; 
     if (pos = -1) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
     if (pos = left - 1) then (     left := left - 1 ) else     if (pos = right + 1) then (     right := right + 1 ) else (     OclFile["System.out"].println("NO") ; 
     return ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    Integer[] a=new Integer[n];
    for(int i=0 ; i<n ; i++)a[i]=in.nextInt();
    Arrays.sort(a);
    int min=a[1]-a[0];
    int num=1 ;
    for(int i=1 ; i<n-1 ; i++){
      if(min>a[i+1]-a[i]){
        min=a[i+1]-a[i];
        num=1 ;
      }
      else if(a[i+1]-a[i]==min)num++;
    }
    System.out.print(min+" ");
    System.out.println(num);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var min : int ; min := a[1+1] - a[0+1] ;
    var num : int ; num := 1 ;
        var i : int ; i := 1 ; while i < n - 1 do ( (     if (min > a[i + 1+1] - a[i+1]) then (     min := a[i + 1+1] - a[i+1] ; 
     num := 1 ) else     if (a[i + 1+1] - a[i+1] = min) then     num := num + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(min + " ") ; 
    OclFile["System.out"].println(num) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    ArrayList<Long>ls=new ArrayList<>();
    for(int i=0 ; i<n ; i++)ls.add(in.nextLong());
    long[] res=solve(ls,n);
    pw.println(res[0]+" "+res[1]);
    pw.close();
  }
  static long[] solve(ArrayList<Long>ls,int n){
    Collections.sort(ls);
    HashMap<Long,ArrayList<Long>>map=new HashMap<>();
    long min=Long.MAX_VALUE ;
    for(int i=1 ; i<n ; i++){
      long dis=Math.abs(ls.get(i)-ls.get(i-1));
      min=Math.min(min,dis);
      if(map.containsKey(dis)){
        ArrayList<Long>temp=map.get(dis);
        temp.add((long)i);
        map.put(dis,temp);
      }
      else {
        ArrayList<Long>temp=new ArrayList<>();
        temp.add((long)i);
        map.put(dis,temp);
      }
    }
    long ans=map.get(min).size();
    long[] res=new long[2];
    res[0]=min ;
    res[1]=ans ;
    return res ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var ls : Sequence(long) ; ls := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     ls := ls->including(in.getCurrent()->toLong()) ;  ;     i := i + 1 ) ; 
    var res : Sequence(long) ; res := solve(ls, n) ;
    skip ; 
    skip ; 
 );
  static   operation solve( ls : Sequence(long), n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     ls := ls->sort() ; 
     var map : Map(long,Sequence(long)) ; map := Map{} ;
    var min : long ; min := "9223372036854775807"->toLong() ;
        var i : int ; i := 1 ; while i < n do ( (     var dis : long ; dis := if ls->at(i+1) - ls->at(i - 1+1) < 0 then -(ls->at(i+1) - ls->at(i - 1+1)) else ls->at(i+1) - ls->at(i - 1+1) endif ;
     min := Set{min, dis}->min() ; 
     if (map->keys()->includes(dis)) then (     var temp : Sequence(long) ; temp := map->at(dis) ;
     temp := temp->including(i->oclAsType(long)) ; 
     map := map->union(Map{dis |-> temp}) ) else (     var temp : Sequence(long) ; temp := Sequence{} ;
     temp := temp->including(i->oclAsType(long)) ; 
     map := map->union(Map{dis |-> temp}) ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := map->at(min)->size() ;
    var res : Sequence(long) ; res := Integer.subrange(1,2)->collect(0) ;
    res[0+1] := min ; 
    res[1+1] := ans ; 
    return res 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B121 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int K=in.nextInt();
    char[] S=in.next().toCharArray();
    int pos=0 ;
    while(pos<N-1 && K>0){
      if(S[pos]=='4' && S[pos+1]=='7'){
        if(pos % 2==0){
          if(pos+2<N && S[pos+2]=='7'){
            if(K % 2==1){
              S[pos+1]='4' ;
            }
            break ;
          }
          else {
            S[pos+1]='4' ;
            K--;
          }
        }
        else {
          if(pos>0 && S[pos-1]=='4'){
            if(K % 2==1){
              S[pos]='7' ;
            }
            break ;
          }
          else {
            S[pos]='7' ;
            K--;
          }
        }
      }
      else {
        pos++;
      }
    }
    System.out.println(new String(S));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B121 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    var S : Sequence(String) ; S := in.getCurrent()->characters() ;
    var pos : int ; pos := 0 ;
    while (pos < N - 1 & K > 0) do (     if (S[pos+1] = '4' & S[pos + 1+1] = '7') then (     if (pos mod 2 = 0) then (     if (pos + 2 < N & S[pos + 2+1] = '7') then (     if (K mod 2 = 1) then (     S[pos + 1+1] := '4' ) else skip ; 
     break ) else (     S[pos + 1+1] := '4' ; 
     K := K - 1 ) ) else (     if (pos > 0 & S[pos - 1+1] = '4') then (     if (K mod 2 = 1) then (     S[pos+1] := '7' ) else skip ; 
     break ) else (     S[pos+1] := '7' ; 
     K := K - 1 ) ) ) else (     pos := pos + 1 ) ) ; 
    OclFile["System.out"].println(StringLib.newString(S)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int count=sc.nextInt();
    int strength=sc.nextInt();
    int total=1 ;
    int size=1 ;
    count--;
    while(true){
      int x=(total+strength-1)/strength ;
      if(count>=x){
        size++;
        total+=x ;
        count-=x ;
      }
      else {
        break ;
      }
    }
    System.out.println(size);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := sc.getCurrent()->toInteger() ;
    var strength : int ; strength := sc.getCurrent()->toInteger() ;
    var total : int ; total := 1 ;
    var size : int ; size := 1 ;
    count := count - 1 ; 
    while (true) do (     var x : int ; x := (total + strength - 1) / strength ;
     if (count >= x) then (     size := size + 1 ; 
     total := total+(x) ; 
     count := count-(x) ) else (     break ) ) ; 
    OclFile["System.out"].println(size) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long base=sc.nextLong(),K=sc.nextLong();
    long next ;
    int ans=1 ;
    while(base>=1){
      long low=0,high=base ;
      while(high-low>1){
        long willNext=(low+high)/2 ;
        if(willNext<=K*(base-willNext)){
          low=willNext ;
        }
        else {
          high=willNext ;
        }
      }
      next=low ;
      if(next>0){
        base=next ;
        ans++;
      }
      else {
        break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var base : long ; base := sc.getCurrent()->toLong() ;
    var K : long ; K := sc.getCurrent()->toLong() ;
    var next : long ;
    var ans : int ; ans := 1 ;
    while (base >= 1) do (     var low : long ; low := 0 ;
    var high : long ; high := base ;
     while (high - low > 1) do (     var willNext : long ; willNext := (low + high) / 2 ;
     if (willNext <= K * (base - willNext)) then (     low := willNext ) else (     high := willNext ) ) ; 
     next := low ; 
     if (next > 0) then (     base := next ; 
     ans := ans + 1 ) else (     break ) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Iterator ;
import java.util.List ;
public class Algorithm {
  static int ans=0 ;
  public static void main(String[] rgs)throws IOException {
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder stringBuilder=new StringBuilder();
    int t=Integer.parseInt(bufferedReader.readLine());
    for(int i=0 ; i<t ; i++){
      String[] a=bufferedReader.readLine().split(" ");
      int row=Integer.parseInt(a[0]);
      int col=Integer.parseInt(a[1]);
      StringBuilder ans=new StringBuilder();
      int[] ansarray=new int[row*col];
      int p=0 ;
      int[] rowarray={
        0,0,row-1,row-1 };
        int[] colarray={
          0,col-1,0,col-1 };
          for(int j=0 ; j<row ; j++){
            for(int k=0 ; k<col ; k++){
              int dis=0 ;
              for(int l=0 ; l<4 ; l++){
                dis=Math.max(dis,Math.abs(rowarray[l]-j)+Math.abs(colarray[l]-k));
              }
              ansarray[p++]=dis ;
            }
          }
          Arrays.sort(ansarray);
          for(int j=0 ; j<ansarray.length ; j++){
            ans.append(ansarray[j]).append(" ");
          }
          stringBuilder.append(ans).append("\n");
        }
        System.out.println(stringBuilder);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Algorithm {
  static   attribute ans : int := 0;
  static   operation main( rgs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var stringBuilder : String ; stringBuilder := StringLib.newString() ;
    var t : int ; t := (bufferedReader.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < t do ( (     var a : Sequence(String) ; a := bufferedReader.readLine()->split(" ") ;
     var row : int ; row := (a[0+1])->toInteger() ;
    var col : int ; col := (a[1+1])->toInteger() ;
    var ans : String ; ans := StringLib.newString() ;
    var ansarray : Sequence(int) ; ansarray := Integer.subrange(1,row * col)->collect(0) ;
    var p : int ; p := 0 ;
    var rowarray : Sequence(int) ; rowarray := Sequence{0,0,row - 1,row - 1} ;
    var colarray : Sequence(int) ; colarray := Sequence{0,col - 1,0,col - 1} ;
        var j : int ; j := 0 ; while j < row do ( (         var k : int ; k := 0 ; while k < col do ( (     var dis : int ; dis := 0 ;
         var l : int ; l := 0 ; while l < 4 do ( (     dis := Set{dis, if rowarray[l+1] - j < 0 then -(rowarray[l+1] - j) else rowarray[l+1] - j endif + if colarray[l+1] - k < 0 then -(colarray[l+1] - k) else colarray[l+1] - k endif}->max() )  ;     l := l + 1 ) ; 
      ansarray[p+1] := dis  ; p := p + 1 )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    ansarray := ansarray->sort() ; 
        var j : int ; j := 0 ; while j < ansarray->size() do ( (     ans := ans + StringLib.newString(ansarray[j+1]) + StringLib.newString(" ") )  ;     j := j + 1 ) ; 
    stringBuilder := stringBuilder + StringLib.newString(ans) + StringLib.newString("\n") ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(stringBuilder) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),k=sc.nextInt();
    int res=0 ;
    int row=1 ;
    int w=0 ;
    while(n>=row){
      if(row*k>=w){
++res ;
        w+=row ;
        n-=row ;
      }
      else if(n>=row+1)++row ;
      else break ;
    }
    System.out.println(res);
  }
  public static void main(String[] a){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
    var row : int ; row := 1 ;
    var w : int ; w := 0 ;
    while (n >= row) do (     if (row * k >= w) then (     res := res + 1 ; 
     w := w+(row) ; 
     n := n-(row) ) else     if (n >= row + 1) then     row := row + 1 else     break ;  ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int q=scan.nextInt();
    long ans=(n-2L)*(n-2L);
    Map<Integer,Integer>rM=new HashMap<>();
    Map<Integer,Integer>cM=new HashMap<>();
    int m=n ;
    for(int i=0 ; i<q ; i++){
      int type=scan.nextInt();
      int pos=scan.nextInt();
      if(type==1){
        if(cM.containsKey(pos)){
          ans-=cM.get(pos);
        }
        else {
          ans-=n-2 ;
          for(int j=pos+1 ; j<m ; j++){
            cM.put(j,n-2);
          }
          m=pos ;
        }
      }
      else {
        if(rM.containsKey(pos)){
          ans-=rM.get(pos);
        }
        else {
          ans-=m-2 ;
          for(int j=pos+1 ; j<n ; j++){
            rM.put(j,m-2);
          }
          n=pos ;
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var q : int ; q := scan.getCurrent()->toInteger() ;
    var ans : long ; ans := (n - 2L) * (n - 2L) ;
    var rM : Map(int,int) ; rM := Map{} ;
    var cM : Map(int,int) ; cM := Map{} ;
    var m : int ; m := n ;
        var i : int ; i := 0 ; while i < q do ( (     var type : int ; type := scan.getCurrent()->toInteger() ;
     var pos : int ; pos := scan.getCurrent()->toInteger() ;
     if (type = 1) then (     if (cM->keys()->includes(pos)) then (     ans := ans-(cM->at(pos)) ) else (     ans := ans-(n - 2) ; 
         var j : int ; j := pos + 1 ; while j < m do ( (     cM := cM->union(Map{j |-> n - 2}) )  ;     j := j + 1 ) ; 
     m := pos ) ) else (     if (rM->keys()->includes(pos)) then (     ans := ans-(rM->at(pos)) ) else (     ans := ans-(m - 2) ; 
         var j : int ; j := pos + 1 ; while j < n do ( (     rM := rM->union(Map{j |-> m - 2}) )  ;     j := j + 1 ) ; 
     n := pos ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final int N=sc.nextInt();
    final int Q=sc.nextInt();
    int[] horizontallyAvailables=new int[N-2];
    int[] verticallyAvailables=new int[N-2];
    for(int i=0 ; i<N-2 ; i++){
      horizontallyAvailables[i]=N-2 ;
      verticallyAvailables[i]=N-2 ;
    }
    long blacks=((long)N-2)*(N-2);
    int minHorizontal=N-2 ;
    int minVertical=N-2 ;
    for(int i=0 ; i<Q ; i++){
      boolean isVertical=sc.nextInt()==1 ;
      int idx=sc.nextInt()-2 ;
      if(isVertical){
        if(idx<minVertical){
          for(int j=idx ; j<minVertical ; j++){
            verticallyAvailables[j]=minHorizontal ;
          }
          minVertical=idx ;
        }
        blacks-=verticallyAvailables[idx];
      }
      else {
        if(idx<minHorizontal){
          for(int j=idx ; j<minHorizontal ; j++){
            horizontallyAvailables[j]=minVertical ;
          }
          minHorizontal=idx ;
        }
        blacks-=horizontallyAvailables[idx];
      }
    }
    System.out.println(blacks);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var Q : int ; Q := sc.getCurrent()->toInteger() ;
    var horizontallyAvailables : Sequence(int) ; horizontallyAvailables := Integer.subrange(1,N - 2)->collect(0) ;
    var verticallyAvailables : Sequence(int) ; verticallyAvailables := Integer.subrange(1,N - 2)->collect(0) ;
        var i : int ; i := 0 ; while i < N - 2 do ( (     horizontallyAvailables[i+1] := N - 2 ; 
     verticallyAvailables[i+1] := N - 2 )  ;     i := i + 1 ) ; 
    var blacks : long ; blacks := (N->oclAsType(long) - 2) * (N - 2) ;
    var minHorizontal : int ; minHorizontal := N - 2 ;
    var minVertical : int ; minVertical := N - 2 ;
        var i : int ; i := 0 ; while i < Q do ( (     var isVertical : boolean ; isVertical := sc.getCurrent()->toInteger() = 1 ;
     var idx : int ; idx := sc.getCurrent()->toInteger() - 2 ;
     if (isVertical) then (     if (idx < minVertical) then (         var j : int ; j := idx ; while j < minVertical do ( (     verticallyAvailables[j+1] := minHorizontal )  ;     j := j + 1 ) ; 
     minVertical := idx ) else skip ; 
     blacks := blacks-(verticallyAvailables[idx+1]) ) else (     if (idx < minHorizontal) then (         var j : int ; j := idx ; while j < minHorizontal do ( (     horizontallyAvailables[j+1] := minVertical )  ;     j := j + 1 ) ; 
     minHorizontal := idx ) else skip ; 
     blacks := blacks-(horizontallyAvailables[idx+1]) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(blacks) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt(),q=scanner.nextInt();
      int[] bottom=new int[n],right=new int[n];
      Arrays.fill(bottom,n);
      Arrays.fill(right,n);
      long result=(n-2)*(long)(n-2);
      int h=n,w=n ;
      for(int i=0 ; i<q ; i++){
        int command=scanner.nextInt(),x=scanner.nextInt();
        if(1==command){
          if(x<w){
            Arrays.fill(bottom,x,w,h);
            w=x ;
          }
          result-=bottom[x]-2 ;
        }
        else {
          if(x<h){
            Arrays.fill(right,x,h,w);
            h=x ;
          }
          result-=right[x]-2 ;
        }
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var q : int ; q := scanner.getCurrent()->toInteger() ;
     var bottom : Sequence(int) ; bottom := Integer.subrange(1,n)->collect(0) ;
    var right : Sequence(int) ; right := Integer.subrange(1,n)->collect(0) ;
    bottom := bottom->collect(n) ; 
    right := right->collect(n) ; 
    var result : long ; result := (n - 2) * (n - 2)->oclAsType(long) ;
    var h : int ; h := n ;
    var w : int ; w := n ;
        var i : int ; i := 0 ; while i < q do ( (     var command : int ; command := scanner.getCurrent()->toInteger() ;
    var x : int ; x := scanner.getCurrent()->toInteger() ;
     if (1 = command) then (     if (x < w) then (     bottom := bottom->collect(h) ; 
     w := x ) else skip ; 
     result := result-(bottom[x+1] - 2) ) else (     if (x < h) then (     right := right->collect(w) ; 
     h := x ) else skip ; 
     result := result-(right[x+1] - 2) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    int n=Integer.parseInt(sa[0]);
    int q=Integer.parseInt(sa[1]);
    long ans=(long)(n-2)*(n-2);
    TreeMap<Integer,Integer>mapx=new TreeMap<>();
    TreeMap<Integer,Integer>mapy=new TreeMap<>();
    mapx.put(n-1,n-1);
    mapy.put(n-1,n-1);
    for(int i=0 ; i<q ; i++){
      sa=br.readLine().split(" ");
      int a=Integer.parseInt(sa[1])-1 ;
      if(sa[0] .equals("1")){
        int b=mapx.get(mapx.ceilingKey(a));
        ans-=b-1 ;
        mapy.put(b,Math.min(a,mapy.getOrDefault(b,n-1)));
      }
      else {
        int b=mapy.get(mapy.ceilingKey(a));
        ans-=b-1 ;
        mapx.put(b,Math.min(a,mapx.getOrDefault(b,n-1)));
      }
    }
    System.out.println(ans);
    br.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var n : int ; n := (sa[0+1])->toInteger() ;
    var q : int ; q := (sa[1+1])->toInteger() ;
    var ans : long ; ans := (n - 2)->oclAsType(long) * (n - 2) ;
    var mapx : Map(int,int) ; mapx := Map{} ;
    var mapy : Map(int,int) ; mapy := Map{} ;
    mapx := mapx->union(Map{n - 1 |-> n - 1}) ; 
    mapy := mapy->union(Map{n - 1 |-> n - 1}) ; 
        var i : int ; i := 0 ; while i < q do ( (     sa := br.readLine()->split(" ") ; 
     var a : int ; a := (sa[1+1])->toInteger() - 1 ;
     if (sa[0+1] = "1") then (     var b : int ; b := mapx->at(mapx.ceilingKey(a)) ;
     ans := ans-(b - 1) ; 
     mapy := mapy->union(Map{b |-> Set{a, (if mapy->keys()->contains(b) then mapy->at(b) else n - 1 endif)}->min()}) ) else (     var b : int ; b := mapy->at(mapy.ceilingKey(a)) ;
     ans := ans-(b - 1) ; 
     mapx := mapx->union(Map{b |-> Set{a, (if mapx->keys()->contains(b) then mapx->at(b) else n - 1 endif)}->min()}) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static int nonsquare(int n){
    return n+(int)(0.5+(Math.sqrt(n)));
  }
  static void printNonSquare(int n){
    for(int i=1 ; i<=n ; i++)System.out.print(nonsquare(i)+" ");
  }
  public static void main(String args[]){
    int n=10 ;
    printNonSquare(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nonsquare( n : int) : int
  pre: true
  post: true
  activity: (     return n + (0.5 + ((n)->sqrt()))->oclAsType(int) );
  static   operation printNonSquare( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= n do (     OclFile["System.out"].print(nonsquare(i) + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     execute printNonSquare(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void generateSequence(int n,int g){
    for(int i=1 ; i<=n ; i++)System.out.print(i*g+" ");
    ;
  }
  public static void main(String[] args){
    int n=6,g=5 ;
    generateSequence(n,g);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation generateSequence( n : int, g : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= n do (     OclFile["System.out"].print(i * g + " ") ;  ;     i := i + 1 ) ; 
  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
    var g : int ; g := 5 ;
     execute generateSequence(n, g) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int geometricMean(int n){
    return(int)Math.sqrt(n);
  }
  public static void main(String[] args){
    int n=16 ;
    System.out.println(geometricMean(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation geometricMean( n : int) : int
  pre: true
  post: true
  activity: (     return (n)->sqrt()->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 16 ;
     OclFile["System.out"].println(geometricMean(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int calculateSum(int n){
    return n*(n+1)/2+(int)Math.pow((n*(n+1)/2),2);
  }
  public static void main(String args[]){
    int n=3 ;
    System.out.println("Sum="+calculateSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation calculateSum( n : int) : int
  pre: true
  post: true
  activity: (     return n * (n + 1) / 2 + (n * (n + 1) / 2)->pow(2)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println("Sum=" + calculateSum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static double sumOfSeries(int n){
    return 0.0246*(Math.pow(10,n)-1-(9*n));
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(sumOfSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfSeries( n : int) : double
  pre: true
  post: true
  activity: (     return 0.0246 * (10->pow(n) - 1 - (9 * n)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(sumOfSeries(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class RoutineProblem {
  static int gcd(int a,int b){
    return b==0 ? a : gcd(b,a % b);
  }
  public static void main(String[] ras){
    Scanner sc=new Scanner(System.in);
    int a,b,c,d ;
    a=sc.nextInt();
    b=sc.nextInt();
    c=sc.nextInt();
    d=sc.nextInt();
    int p,q ;
    if(a*d>b*c){
      p=a*d-b*c ;
      q=a*d ;
    }
    else {
      p=b*c-a*d ;
      q=b*c ;
    }
    int g=gcd(p,q);
    p=p/g ;
    q=q/g ;
    System.out.println(p+"/"+q);
  }
}
------------------------------------------------------------
OCL File:
---------
 class RoutineProblem {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
  static   operation main( ras : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ;
    var b : int ;
    var c : int ;
    var d : int ;
    a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    c := sc.getCurrent()->toInteger() ; 
    d := sc.getCurrent()->toInteger() ; 
    var p : int ;
    var q : int ;
    if (a * d > b * c) then (     p := a * d - b * c ; 
     q := a * d ) else (     p := b * c - a * d ; 
     q := b * c ) ;  
    var g : int ; g := gcd(p, q) ;
    p := p / g ; 
    q := q / g ; 
    OclFile["System.out"].println(p + "/" + q) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sumOfSeries(int n){
    return(int)(0.6172*(Math.pow(10,n)-1)-0.55*n);
  }
  public static void main(String[] args){
    int n=2 ;
    System.out.println(sumOfSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumOfSeries( n : int) : int
  pre: true
  post: true
  activity: (     return (0.6172 * (10->pow(n) - 1) - 0.55 * n)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(sumOfSeries(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int count(int n){
    return(int)Math.pow(2,n-1);
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(count(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation count( n : int) : int
  pre: true
  post: true
  activity: (     return 2->pow(n - 1)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(count(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long numbers(int n){
    return(long)(Math.pow(2,n+1))-2 ;
  }
  public static void main(String args[]){
    int n=2 ;
    System.out.println(numbers(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation numbers( n : int) : long
  pre: true
  post: true
  activity: (     return (2->pow(n + 1))->oclAsType(long) - 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(numbers(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int calculateSum(int n){
    return(int)Math.pow(n*(n+1)/2,2);
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(calculateSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculateSum( n : int) : int
  pre: true
  post: true
  activity: (     return n * (n + 1) / 2->pow(2)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(calculateSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int calculateSum(int n){
    return(int)((2*Math.pow((n*(n+1)/2),2)))+((n*(n+1)*(2*n+1))/6);
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println("Sum="+calculateSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculateSum( n : int) : int
  pre: true
  post: true
  activity: (     return ((2 * (n * (n + 1) / 2)->pow(2)))->oclAsType(int) + ((n * (n + 1) * (2 * n + 1)) / 6) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println("Sum=" + calculateSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int count(int n){
    return(int)(-1+Math.sqrt(1+8*n))/2 ;
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(count(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation count( n : int) : int
  pre: true
  post: true
  activity: (     return (-1 + (1 + 8 * n)->sqrt())->oclAsType(int) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(count(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int m=input.nextInt();
    int[] l=new int[m];
    long sum=0 ;
    for(int i=0 ; i<m ; ++i){
      l[i]=input.nextInt();
      sum+=l[i];
    }
    int[] p=new int[m];
    int coverd=0,start=1 ;
    for(int i=0 ; i<m ; ++i){
      int length=l[i],index=i ;
      if(start-1+length>n){
        System.out.println(-1);
        return ;
      }
      sum-=length ;
      if(sum>=(long)(n-((start+length-1)>coverd ? start+length-1 : coverd))){
        p[index]=start ;
      }
      else {
        p[index]=n-((int)sum+length-1);
        if(p[index]>coverd+1 || p[index]<start){
          System.out.println(-1);
          return ;
        }
      }
      coverd=Math.max(p[index]+length-1,coverd);
      start=p[index]+1 ;
    }
    if(coverd!=n){
      System.out.println();
      return ;
    }
    for(int i=0 ; i<m ; ++i){
      System.out.print(p[i]+" ");
    }
    System.out.println(" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var m : int ; m := input.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Integer.subrange(1,m)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     l[i+1] := input.getCurrent()->toInteger() ; 
     sum := sum+(l[i+1]) )  ;     i := i + 1 ) ; 
    var p : Sequence(int) ; p := Integer.subrange(1,m)->collect(0) ;
    var coverd : int ; coverd := 0 ;
    var start : int ; start := 1 ;
        var i : int ; i := 0 ; while i < m do ( (     var length : int ; length := l[i+1] ;
    var index : int ; index := i ;
     if (start - 1 + length > n) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    sum := sum-(length) ; 
    if (sum >= (n - (if (start + length - 1) > coverd then start + length - 1 else coverd endif))->oclAsType(long)) then (     p[index+1] := start ) else (     p[index+1] := n - (sum->oclAsType(int) + length - 1) ; 
     if (p[index+1] > coverd + 1 or p[index+1] < start) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ) ;  
    coverd := Set{p[index+1] + length - 1, coverd}->max() ; 
    start := p[index+1] + 1 ; 
 )  ;     i := i + 1 ) ; 
    if (coverd /= n) then (     OclFile["System.out"].println() ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < m do ( (     OclFile["System.out"].print(p[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(" ") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int nDigitPalindromes(int n){
    return(9*(int)Math.pow(10,(n-1)/2));
  }
  public static void main(String[] args){
    int n=2 ;
    System.out.println(nDigitPalindromes(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nDigitPalindromes( n : int) : int
  pre: true
  post: true
  activity: (     return (9 * 10->pow((n - 1) / 2)->oclAsType(int)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(nDigitPalindromes(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int count(int n){
    return(int)(15*Math.pow(16,n-1));
  }
  public static void main(String args[]){
    int n=2 ;
    System.out.println(count(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation count( n : int) : int
  pre: true
  post: true
  activity: (     return (15 * 16->pow(n - 1))->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(count(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double sumOfSeries(int n){
    return(0.666)*(1-1/Math.pow(10,n));
  }
  public static void main(String[] args){
    int n=2 ;
    System.out.println(sumOfSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfSeries( n : int) : double
  pre: true
  post: true
  activity: (     return (0.666) * (1 - 1 / 10->pow(n)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(sumOfSeries(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.StringTokenizer ;
public class R766B {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int t=Integer.parseInt(st.nextToken());
    while(t-->0){
      st=new StringTokenizer(br.readLine());
      int n=Integer.parseInt(st.nextToken());
      int m=Integer.parseInt(st.nextToken());
      solve(n,m);
    }
  }
  private static void solve(int n,int m){
    int[][] matrix=new int[n][m];
    calculate(matrix,0,0);
    calculate(matrix,0,m-1);
    calculate(matrix,n-1,0);
    calculate(matrix,n-1,m-1);
    List<Integer>list=new ArrayList<>();
    for(int i=0 ; i<matrix.length ; i++){
      for(int j=0 ; j<matrix[i] .length ; j++){
        list.add(matrix[i][j]);
      }
    }
    StringBuilder builder=new StringBuilder();
    list.stream().sorted().forEach(distance->builder.append(distance).append(" "));
    System.out.println(builder);
  }
  private static void calculate(int[][] matrix,int row,int col){
    for(int i=0 ; i<matrix.length ; i++){
      for(int j=0 ; j<matrix[i] .length ; j++){
        matrix[i][j]=Math.max(matrix[i][j],Math.abs(i-row)+Math.abs(j-col));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class R766B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var t : int ; t := (st.next())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var n : int ; n := (st.next())->toInteger() ;
     var m : int ; m := (st.next())->toInteger() ;
     execute solve(n, m) ) ;  ) );
  static   operation solve( n : int, m : int) : void
  pre: true
  post: true
  activity: (     var matrix : Sequence(Sequence(int)) ; matrix := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
     execute calculate(matrix, 0, 0) ; 
    execute calculate(matrix, 0, m - 1) ; 
    execute calculate(matrix, n - 1, 0) ; 
    execute calculate(matrix, n - 1, m - 1) ; 
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < matrix->size() do ( (         var j : int ; j := 0 ; while j < matrix[i+1]->size() do ( (     list := list->including(matrix[i+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var builder : String ; builder := StringLib.newString() ;
    for distance : list->sort() do
    (    builder := builder + StringLib.newString(distance) + StringLib.newString(" ")) ; 
    OclFile["System.out"].println(builder) ; 
 );
  static   operation calculate( matrix : Sequence(Sequence(int)), row : int, col : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < matrix->size() do ( (         var j : int ; j := 0 ; while j < matrix[i+1]->size() do ( (     matrix[i+1][j+1] := Set{matrix[i+1][j+1], if (i)->char2byte() - row < 0 then -((i)->char2byte() - row) else (i)->char2byte() - row endif + if j - col < 0 then -(j - col) else j - col endif}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int smallestMultiple(int n){
    if(n==1)return 5 ;
    return(int)(Math.pow(10,n-1));
  }
  public static void main(String args[]){
    int n=4 ;
    System.out.println(smallestMultiple(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation smallestMultiple( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 5 else skip ; 
     return (10->pow(n - 1))->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(smallestMultiple(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int totalNumber(int n){
    return 8*(int)Math.pow(9,n-1);
  }
  static public void main(String[] args){
    int n=3 ;
    System.out.println(totalNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation totalNumber( n : int) : int
  pre: true
  post: true
  activity: (     return 8 * 9->pow(n - 1)->oclAsType(int) );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(totalNumber(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int getChicks(int n){
    int chicks=(int)Math.pow(3,n-1);
    return chicks ;
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(getChicks(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getChicks( n : int) : int
  pre: true
  post: true
  activity: (     var chicks : int ; chicks := 3->pow(n - 1)->oclAsType(int) ;
     return chicks );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(getChicks(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.Closeable ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.PriorityQueue ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    final long n=sc.nextLong();
    if(n==0){
      System.out.println(0);
    }
    else {
      System.out.println(Long.numberOfTrailingZeros(Long.highestOneBit(n))+1);
    }
  }
  public static class Scanner implements Closeable {
    private BufferedReader br ;
    private StringTokenizer tok ;
    public Scanner(InputStream is)throws IOException {
      br=new BufferedReader(new InputStreamReader(is));
    }
    private void getLine()throws IOException {
      while(! hasNext()){
        tok=new StringTokenizer(br.readLine());
      }
    }
    private boolean hasNext(){
      return tok!=null && tok.hasMoreTokens();
    }
    public String next()throws IOException {
      getLine();
      return tok.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public void close()throws IOException {
      br.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
     if (n = 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(numberOfTrailingZeros(highestOneBit(n)) + 1) ) );
  static class Scanner implements Closeable {
   attribute br : OclFile;
   attribute tok : OclIterator;
   static operation newScanner( is : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
   operation getLine() : void
  pre: true
  post: true
  activity: (     while (not(hasNext())) do (     tok := OclIterator.newOclIterator_String(br.readLine()) ) );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return tok /= null & tok.hasNext() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute getLine() ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String line ;
    long n=sc.nextLong();
    int count=0 ;
    if(n>0){
      while(n>=2){
        n/=2 ;
        count++;
      }
      count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : String ;
    var n : long ; n := sc.getCurrent()->toLong() ;
    var count : int ; count := 0 ;
    if (n > 0) then (     while (n >= 2) do (     n := n/(2) ; 
     count := count + 1 ) ; 
     count := count + 1 ) else skip ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      long max=0 ;
      long res=1 ;
      long sum=0 ;
      for(int i=0 ; i<n ; i++){
        int x=sc.nextInt();
        while(x % 2==0){
          x>>=1 ;
          res<<=1 ;
        }
        max=Math.max(x,max);
        sum+=x ;
      }
      System.out.println(sum-max+max*res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var max : long ; max := 0 ;
    var res : long ; res := 1 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     while (x mod 2 = 0) do (     x := x/(2->pow(1)) ; 
     res := res*(2->pow(1)) ) ; 
     max := Set{x, max}->max() ; 
     sum := sum+(x) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum - max + max * res) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class divMul {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        int n=sc.nextInt();
        int a[]=new int[n];
        int ct=0 ;
        int sum=0 ;
        int max=0 ;
        for(int i=0 ; i<n ; i++){
          a[i]=sc.nextInt();
          while(a[i] % 2==0){
            ct++;
            a[i]/=2 ;
          }
          if(a[i]>max)max=a[i];
          sum+=a[i];
        }
        long mx=max*(long)(Math.pow(2,ct));
        System.out.println((sum-max)+mx);
      }
    }
    catch(Exception e){
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class divMul {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var ct : int ; ct := 0 ;
    var sum : int ; sum := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     while (a[i+1] mod 2 = 0) do (     ct := ct + 1 ; 
     a[i+1] := a[i+1]/(2) ) ; 
     if (a[i+1] > max) then     max := a[i+1] ; else skip ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    var mx : long ; mx := max * (2->pow(ct))->oclAsType(long) ;
    OclFile["System.out"].println((sum - max) + mx) ; 
 ) ;  ) )   catch (e : ProgramException) do (     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int[] x=new int[n+1];
    int max=0 ;
    for(int i=1 ; i<=n ; i++){
      x[i]=sc.nextInt();
      max=Math.max(max,x[i]);
    }
    long[][][] dp=new long[n+1][n+1][max*n+1];
    dp[0][0][0]=1 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=0 ; j<=i ; j++){
        for(int k=0 ; k<=n*max ; k++){
          if(i==0 && j==0 && k==0)continue ;
          else if(j>=1 && k>=x[i]){
            dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-x[i] ];
          }
          else dp[i][j][k]=dp[i-1][j][k];
        }
      }
    }
    long ans=0 ;
    for(int i=1 ; i<=n ; i++)if(a*i<=max*n+1)ans+=(long)dp[n][i][a*i];
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n + 1)->collect(0) ;
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     max := Set{max, x[i+1]}->max() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(Sequence(long))) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(Integer.subrange(1,max * n + 1)->collect(0))) ;
    dp[0+1][0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= i do ( (         var k : int ; k := 0 ; while k <= n * max do ( (     if (i = 0 & j = 0 & k = 0) then     continue else     if (j >= 1 & k >= x[i+1]) then (     dp[i+1][j+1][k+1] := dp[i - 1+1][j+1][k+1] + dp[i - 1+1][j - 1+1][k - x[i+1]+1] ) else     dp[i+1][j+1][k+1] := dp[i - 1+1][j+1][k+1] ; ;  )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do (     if (a * i <= max * n + 1) then     ans := ans+(dp[n+1][i+1][a * i+1]->oclAsType(long)) ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static final long MOD=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s1=sc.next();
    String s2=sc.next();
    ArrayList<Integer>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      if(s1.charAt(i)==s2.charAt(i)){
        list.add(0);
      }
      else {
        list.add(1);
        i++;
      }
    }
    long val=1 ;
    for(int i=0 ; i<list.size(); i++){
      if(i==0){
        if(list.get(i)==0){
          val*=3 ;
        }
        else {
          val*=6 ;
        }
      }
      else {
        if(list.get(i-1)==0 && list.get(i)==0){
          val*=2 ;
        }
        else if(list.get(i-1)==0 && list.get(i)==1){
          val*=2 ;
        }
        else if(list.get(i-1)==1 && list.get(i)==0){
          val*=1 ;
        }
        else if(list.get(i-1)==1 && list.get(i)==1){
          val*=3 ;
        }
      }
      val %=MOD ;
    }
    System.out.println(val);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s1 : String ; s1 := sc.getCurrent() ;
    var s2 : String ; s2 := sc.getCurrent() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (s1->at(i+1) = s2->at(i+1)) then (     list := list->including(0) ) else (     list := list->including(1) ; 
     i := i + 1 ) )  ;     i := i + 1 ) ; 
    var val : long ; val := 1 ;
        var i : int ; i := 0 ; while i < list->size() do ( (     if (i = 0) then (     if (list->at(i+1) = 0) then (     val := val*(3) ) else (     val := val*(6) ) ) else (     if (list->at(i - 1+1) = 0 & list->at(i+1) = 0) then (     val := val*(2) ) else     if (list->at(i - 1+1) = 0 & list->at(i+1) = 1) then (     val := val*(2) ) else     if (list->at(i - 1+1) = 1 & list->at(i+1) = 0) then (     val := val*(1) ) else     if (list->at(i - 1+1) = 1 & list->at(i+1) = 1) then (     val := val*(3) ) else skip ; ;  ;  ) ;  
     val := val mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(val) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxOnesIndex(boolean arr[],int n){
    int i=0 ;
    int leftCnt=0 ;
    int rightCnt=0 ;
    int maxIndex=-1 ;
    int lastInd=-1 ;
    int maxCnt=0 ;
    while(i<n){
      if(arr[i]){
        rightCnt++;
      }
      else {
        if(lastInd!=-1){
          if(rightCnt+leftCnt+1>maxCnt){
            maxCnt=leftCnt+rightCnt+1 ;
            maxIndex=lastInd ;
          }
        }
        lastInd=i ;
        leftCnt=rightCnt ;
        rightCnt=0 ;
      }
      i++;
    }
    if(lastInd!=-1){
      if(leftCnt+rightCnt+1>maxCnt){
        maxCnt=leftCnt+rightCnt+1 ;
        maxIndex=lastInd ;
      }
    }
    return maxIndex ;
  }
  public static void main(String[] args){
    boolean arr[]={
      true,true,false,false,true,false,true,true,true,false,true,true,true,};
      int n=arr.length ;
      System.out.println("Index of 0 to be replaced is "+maxOnesIndex(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxOnesIndex( arr : Sequence(boolean), n : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var leftCnt : int ; leftCnt := 0 ;
    var rightCnt : int ; rightCnt := 0 ;
    var maxIndex : int ; maxIndex := -1 ;
    var lastInd : int ; lastInd := -1 ;
    var maxCnt : int ; maxCnt := 0 ;
    while (i < n) do (     if (arr[i+1]) then (     rightCnt := rightCnt + 1 ) else (     if (lastInd /= -1) then (     if (rightCnt + leftCnt + 1 > maxCnt) then (     maxCnt := leftCnt + rightCnt + 1 ; 
     maxIndex := lastInd ) else skip ) else skip ; 
     lastInd := i ; 
     leftCnt := rightCnt ; 
     rightCnt := 0 ) ;  
     i := i + 1 ) ; 
    if (lastInd /= -1) then (     if (leftCnt + rightCnt + 1 > maxCnt) then (     maxCnt := leftCnt + rightCnt + 1 ; 
     maxIndex := lastInd ) else skip ) else skip ; 
    return maxIndex 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(boolean) ; arr := Sequence{true,true,false,false,true,false,true,true,true,false,true,true,true,} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Index of 0 to be replaced is " + maxOnesIndex(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void FindRank(int arr[],int length){
    System.out.print("1"+" ");
    for(int i=1 ; i<arr.length ; i++){
      int rank=1 ;
      for(int j=0 ; j<i ; j++){
        if(arr[j]>arr[i])rank++;
      }
      System.out.print(rank+" ");
    }
  }
  public static void main(String args[]){
    int arr[]={
      88,14,69,30,29,89 };
      int len=arr.length ;
      FindRank(arr,len);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation FindRank( arr : Sequence(int), length : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("1" + " ") ; 
         var i : int ; i := 1 ; while i < arr->size() do ( (     var rank : int ; rank := 1 ;
         var j : int ; j := 0 ; while j < i do ( (     if (arr[j+1] > arr[i+1]) then     rank := rank + 1 ; else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print(rank + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{88,14,69,30,29,89} ;
     var len : int ; len := arr->size() ;
     execute FindRank(arr, len) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int printKDistinct(int arr[],int n,int k){
    int dist_count=0 ;
    for(int i=0 ; i<n ; i++){
      int j ;
      for(j=0 ; j<n ; j++)if(i!=j && arr[j]==arr[i])break ;
      if(j==n)dist_count++;
      if(dist_count==k)return arr[i];
    }
    return-1 ;
  }
  public static void main(String[] args){
    int ar[]={
      1,2,1,3,4,2 };
      int n=ar.length ;
      int k=2 ;
      System.out.print(printKDistinct(ar,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printKDistinct( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var dist_count : int ; dist_count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var j : int ;
         j := 0 ; while j < n do (     if (i /= j & arr[j+1] = arr[i+1]) then     break else skip ;  ;     j := j + 1 ) ; 
     if (j = n) then     dist_count := dist_count + 1 ; else skip ; 
     if (dist_count = k) then     return arr[i+1] else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ar : Sequence(int) ; ar := Sequence{1,2,1,3,4,2} ;
     var n : int ; n := ar->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].print(printKDistinct(ar, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void permuteRec(String str,int n,int index,String curr){
    if(index==n){
      return ;
    }
    System.out.println(curr);
    for(int i=index+1 ; i<n ; i++){
      curr+=str.charAt(i);
      permuteRec(str,n,i,curr);
      curr=curr.substring(0,curr.length()-1);
    }
    return ;
  }
  static void powerSet(String str){
    char[] arr=str.toCharArray();
    Arrays.sort(arr);
    permuteRec(new String(arr),str.length(),-1,"");
  }
  public static void main(String[] args){
    String str="cab" ;
    powerSet(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation permuteRec( str : String, n : int, index : int, curr : String) : void
  pre: true
  post: true
  activity: (     if (index = n) then (     return ) else skip ; 
     OclFile["System.out"].println(curr) ; 
         var i : int ; i := index + 1 ; while i < n do ( (     curr := curr+(str->at(i+1)) ; 
     execute permuteRec(str, n, i, curr) ; 
     curr := curr.subrange(0+1,curr->size() - 1) )  ;     i := i + 1 ) ; 
     return );
  static   operation powerSet( str : String) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := str->characters() ;
     arr := arr->sort() ; 
     execute permuteRec(StringLib.newString(arr), str->size(), -1, "") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "cab" ;
     execute powerSet(str) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] xs=new int[n];
    for(int i=0 ; i<n ; i++){
      xs[i]=sc.nextInt();
    }
    int L=sc.nextInt();
    int num=1 ;
    int t=1 ;
    while(num<n){
      num<<=1 ;
      t++;
    }
    int[][] next=new int[t][n];
    for(int i=0 ; i<n ; i++){
      next[0][i]=lowerBound(xs,xs[i]+L);
    }
    for(int k=0 ; k<t-1 ; k++){
      for(int i=0 ; i<n ; i++){
        next[k+1][i]=next[k][next[k][i] ];
      }
    }
    StringBuilder sb=new StringBuilder();
    int q=sc.nextInt();
    while(q-->0){
      int a=sc.nextInt()-1 ;
      int b=sc.nextInt()-1 ;
      if(a>b){
        int c=a ;
        a=b ;
        b=c ;
      }
      int answer=1 ;
      for(int i=t-1 ; i>=0 ; i--){
        if(xs[b]>xs[next[i][a] ]){
          a=next[i][a];
          answer+=Math.pow(2,i);
        }
      }
      sb.append(answer).append("\n");
    }
    System.out.print(sb);
  }
  private static int lowerBound(int[] a,int x){
    int l=0,r=a.length ;
    while(r-l>1){
      int m=(l+r)/2 ;
      if(a[m]<=x)l=m ;
      else r=m ;
    }
    return l ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var xs : Sequence(int) ; xs := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     xs[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var L : int ; L := sc.getCurrent()->toInteger() ;
    var num : int ; num := 1 ;
    var t : int ; t := 1 ;
    while (num < n) do (     num := num*(2->pow(1)) ; 
     t := t + 1 ) ; 
    var next : Sequence(Sequence(int)) ; next := Integer.subrange(1,t)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     next[0+1][i+1] := lowerBound(xs, xs[i+1] + L) )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < t - 1 do ( (         var i : int ; i := 0 ; while i < n do ( (     next[k + 1+1][i+1] := next[k+1][next[k+1][i+1]+1] )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
     var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
    if (a > b) then (     var c : int ; c := a ;
     a := b ; 
     b := c ) else skip ; 
    var answer : int ; answer := 1 ;
        var i : int ; i := t - 1 ; while i >= 0 do ( (     if (xs[b+1] > xs[next[i+1][a+1]+1]) then (     a := next[i+1][a+1] ; 
     answer := answer+(2->pow(i)) ) else skip )  ;     i := i - 1 ) ; 
    sb := sb + StringLib.newString(answer) + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].print(sb) ; 
 );
  static   operation lowerBound( a : Sequence(int), x : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
    var r : int ; r := a->size() ;
     while (r - l > 1) do (     var m : int ; m := (l + r) / 2 ;
     if (a[m+1] <= x) then     l := m ; else     r := m ; ) ; 
     return l );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printArray(int[] arr,int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  static void findArray(int[] q,int n){
    int ans ;
    int[] arr=new int[n];
    for(int k=0,j=0 ; j<n/4 ; j++){
      ans=q[k] ^ q[k+3];
      arr[k+1]=q[k+1] ^ ans ;
      arr[k+2]=q[k+2] ^ ans ;
      arr[k]=q[k] ^((arr[k+1])^(arr[k+2]));
      arr[k+3]=q[k+3] ^(arr[k+1] ^ arr[k+2]);
      k+=4 ;
    }
    printArray(arr,n);
  }
  public static void main(String args[]){
    int[] q={
      4,1,7,0 };
      int n=q.length ;
      findArray(q,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation findArray( q : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var ans : int ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var k : int ; k := 0 ;
    var j : int ; j := 0 ; while j < n / 4 do ( (     ans := q[k+1] xor q[k + 3+1] ; 
     arr[k + 1+1] := q[k + 1+1] xor ans ; 
    arr[k + 2+1] := q[k + 2+1] xor ans ; 
    arr[k+1] := q[k+1] xor ((arr[k + 1+1]) xor (arr[k + 2+1])) ; 
    arr[k + 3+1] := q[k + 3+1] xor (arr[k + 1+1] xor arr[k + 2+1]) ; 
    k := k+(4) ; 
 )  ;     j := j + 1 ) ; 
     execute printArray(arr, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var q : Sequence(int) ; q := Sequence{4,1,7,0} ;
     var n : int ; n := q->size() ;
     execute findArray(q, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DawidCandy {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] c=new int[4];
    for(int i=0 ; i<4 ; i++){
      c[i]=sc.nextInt();
    }
    int total=c[0]+c[1]+c[2]+c[3];
    if(total % 2!=0){
      System.out.println("NO");
      return ;
    }
    int required=total/2 ;
    if(c[0]+c[1]==required || c[0]+c[2]==required || c[0]+c[3]==required || c[0]+c[1]+c[2]==required || c[0]+c[1]+c[3]==required || c[0]+c[2]+c[3]==required || c[1]+c[2]+c[3]==required){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DawidCandy {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : Sequence(int) ; c := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     c[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var total : int ; total := c[0+1] + c[1+1] + c[2+1] + c[3+1] ;
    if (total mod 2 /= 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    var required : int ; required := total / 2 ;
    if (c[0+1] + c[1+1] = required or c[0+1] + c[2+1] = required or c[0+1] + c[3+1] = required or c[0+1] + c[1+1] + c[2+1] = required or c[0+1] + c[1+1] + c[3+1] = required or c[0+1] + c[2+1] + c[3+1] = required or c[1+1] + c[2+1] + c[3+1] = required) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1228A_Distincdigit {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    LinkedList<Integer>list=new LinkedList<>();
    for(int i=0 ; i<4 ; i++){
      list.add(input.nextInt());
    }
    Collections.sort(list);
    int first=list.get(0);
    int second=list.get(1);
    int third=list.get(2);
    int forth=list.get(3);
    if(first+forth==second+third){
      System.out.println("YES");
    }
    else if(first+second+third==forth){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1228A_Distincdigit {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < 4 do ( (     list := list->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var first : int ; first := list->at(0+1) ;
    var second : int ; second := list->at(1+1) ;
    var third : int ; third := list->at(2+1) ;
    var forth : int ; forth := list->at(3+1) ;
    if (first + forth = second + third) then (     OclFile["System.out"].println("YES") ) else     if (first + second + third = forth) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class ques {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int j=0 ; j<t ; j++){
      int q=sc.nextInt();
      int n=sc.nextInt();
      int[] index=new int[n];
      for(int i=0 ; i<n ; i++){
        index[i]=0 ;
      }
      for(int i=0 ; i<q ; i++){
        int ind=sc.nextInt();
        if(ind<n/2+1){
          if(index[ind-1]==1){
            index[n-ind]=1 ;
          }
          else index[ind-1]=1 ;
        }
        else {
          if(index[n-ind]==1){
            index[ind-1]=1 ;
          }
          else index[n-ind]=1 ;
        }
      }
      String ans="" ;
      for(int k=0 ; k<n ; k++){
        if(index[k]==0)ans+='B' ;
        else ans+='A' ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ques {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var q : int ; q := sc.getCurrent()->toInteger() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var index : Sequence(int) ; index := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     index[i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var ind : int ; ind := sc.getCurrent()->toInteger() ;
     if (ind < n / 2 + 1) then (     if (index[ind - 1+1] = 1) then (     index[n - ind+1] := 1 ) else     index[ind - 1+1] := 1 ; ) else (     if (index[n - ind+1] = 1) then (     index[ind - 1+1] := 1 ) else     index[n - ind+1] := 1 ; ) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "" ;
        var k : int ; k := 0 ; while k < n do ( (     if (index[k+1] = 0) then     ans := ans+('B') ; else     ans := ans+('A') ; )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void cout(Object o){
    System.out.print(o);
  }
  public static void coutnl(Object o){
    System.out.println(o);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int tt=sc.nextInt();
    while(tt-->0){
      int n=sc.nextInt(),m=sc.nextInt();
      TreeSet<Integer>s=new TreeSet<Integer>();
      for(int i=0 ; i<n ; i++){
        int x=sc.nextInt();
        int mini=Math.min(x,m+1-x);
        int maxi=Math.max(x,m+1-x);
        if(s.contains(mini)){
          s.add(maxi);
        }
        else {
          s.add(mini);
        }
      }
      for(int i=1 ; i<=m ; i++){
        if(s.contains(i)){
          cout('A');
        }
        else {
          cout('B');
        }
      }
      coutnl(" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation cout( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
  static   operation coutnl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tt : int ; tt := sc.getCurrent()->toInteger() ;
         while (tt > 0) do (        tt := tt - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
     var s : Set(int) ; s := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var mini : int ; mini := Set{x, m + 1 - x}->min() ;
     var maxi : int ; maxi := Set{x, m + 1 - x}->max() ;
     if (s->includes(mini)) then (     s := s->including(maxi) ) else (     s := s->including(mini) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= m do ( (     if (s->includes(i)) then (     execute cout('A') ) else (     execute cout('B') ) )  ;     i := i + 1 ) ; 
    execute coutnl(" ") ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class anotherStringMinimisationProblem {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int m=sc.nextInt();
      StringBuilder sb=new StringBuilder();
      for(int j=0 ; j<m ; j++){
        sb.append("B");
      }
      for(int j=0 ; j<n ; j++){
        int a=sc.nextInt();
        if(a>(int)m/2){
          a=m-a+1 ;
        }
        if(sb.charAt(a-1)=='B'){
          sb.setCharAt(a-1,'A');
        }
        else {
          sb.setCharAt(m-a,'A');
        }
      }
      System.out.println(sb);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class anotherStringMinimisationProblem {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        var j : int ; j := 0 ; while j < m do ( (     sb := sb + StringLib.newString("B") )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (a > m->oclAsType(int) / 2) then (     a := m - a + 1 ) else skip ; 
     if (sb->at(a - 1+1) = 'B') then (     sb := sb.setAt(a - 1+1, 'A') ) else (     sb := sb.setAt(m - a+1, 'A') ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int h=sc.nextInt();
    int[] a=new int[n];
    Integer[] b=new Integer[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
    }
    Arrays.sort(a);
    Arrays.sort(b);
    Arrays.sort(b,Comparator.reverseOrder());
    int ans=Integer.MAX_VALUE ;
    for(int i=0 ; i<=n ; i++){
      if(i!=0)h-=b[i-1];
      int cnt=0 ;
      if(h>0){
        cnt=(h+a[n-1]-1)/a[n-1];
      }
      ans=Math.min(ans,cnt+i);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    b := OclComparator.sortWith(b, Comparator.reverseOrder()) ; 
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i <= n do ( (     if (i /= 0) then     h := h-(b[i - 1+1]) ; else skip ; 
     var cnt : int ; cnt := 0 ;
     if (h > 0) then (     cnt := (h + a[n - 1+1] - 1) / a[n - 1+1] ) else skip ; 
     ans := Set{ans, cnt + i}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      int m=input.nextInt();
      TreeSet<Integer>set=new TreeSet<>();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=input.nextInt();
        int min=Math.min(a[i],m+1-a[i]);
        int max=Math.max(a[i],m+1-a[i]);
        if(set.contains(min)){
          set.add(max);
        }
        else set.add(min);
      }
      char s[]=new char[m];
      Arrays.fill(s,'B');
      while(! set.isEmpty()){
        s[set.pollFirst()-1]='A' ;
      }
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := input.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.getCurrent()->toInteger() ;
     var m : int ; m := input.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.getCurrent()->toInteger() ; 
     var min : int ; min := Set{a[i+1], m + 1 - a[i+1]}->min() ;
     var max : int ; max := Set{a[i+1], m + 1 - a[i+1]}->max() ;
     if (set->includes(min)) then (     set := set->including(max) ) else     set := set->including(min) ; )  ;     i := i + 1 ) ; 
    var s : Sequence(String) ; s := Integer.subrange(1,m)->collect(0) ;
    s := s->collect('B') ; 
    while (not(set->isEmpty())) do (     s[set->first() - 1+1] := 'A' ) ; 
    OclFile["System.out"].println(s) ; 
 ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Node {
    int data ;
    Node next ;
  };
  static Node reverse(Node head,int k){
    Node prev=null ;
    Node curr=head ;
    Node temp=null ;
    Node tail=null ;
    Node newHead=null ;
    Node join=null ;
    int t=0 ;
    while(curr!=null){
      t=k ;
      join=curr ;
      prev=null ;
      while(curr!=null && t--!=0){
        temp=curr.next ;
        curr.next=prev ;
        prev=curr ;
        curr=temp ;
      }
      if((newHead==null))newHead=prev ;
      if(tail!=null)tail.next=prev ;
      tail=join ;
    }
    return newHead ;
  }
  static Node push(Node head_ref,int new_data){
    Node new_node=new Node();
    new_node.data=new_data ;
    new_node.next=(head_ref);
(head_ref)=new_node ;
    return head_ref ;
  }
  static void printList(Node node){
    while(node!=null){
      System.out.print(node.data+" ");
      node=node.next ;
    }
  }
  public static void main(String args[]){
    Node head=null ;
    head=push(head,9);
    head=push(head,8);
    head=push(head,7);
    head=push(head,6);
    head=push(head,5);
    head=push(head,4);
    head=push(head,3);
    head=push(head,2);
    head=push(head,1);
    int k=3 ;
    System.out.print("Given linked list \n");
    printList(head);
    head=reverse(head,k);
    System.out.print("\nReversed Linked list \n");
    printList(head);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   operation reverse( head : Node, k : int) : Node
  pre: true
  post: true
  activity: (     var prev : Node ; prev := null ;
     var curr : Node ; curr := head ;
    var temp : Node ; temp := null ;
    var tail : Node ; tail := null ;
    var newHead : Node ; newHead := null ;
    var join : Node ; join := null ;
    var t : int ; t := 0 ;
    while (curr /= null) do (     t := k ; 
     join := curr ; 
    prev := null ; 
        while (curr /= null & t /= 0) do (    skip ; (     temp := curr.next ; 
     curr.next := prev ; 
     prev := curr ; 
     curr := temp ) ;  ) ;  
    if ((newHead = null)) then     newHead := prev ; else skip ; 
    if (tail /= null) then     tail.next := prev ; else skip ; 
    tail := join ; 
 ) ; 
    return newHead 
 );
  static   operation push( head_ref : Node, new_data : int) : Node
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode() ;
     new_node.data := new_data ; 
    new_node.next := (head_ref) ; 
    (head_ref) := new_node ; 
    return head_ref 
 );
  static   operation printList( node : Node) : void
  pre: true
  post: true
  activity: (     while (node /= null) do (     OclFile["System.out"].print(node.data + " ") ; 
     node := node.next ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := null ;
     head := push(head, 9) ; 
    head := push(head, 8) ; 
    head := push(head, 7) ; 
    head := push(head, 6) ; 
    head := push(head, 5) ; 
    head := push(head, 4) ; 
    head := push(head, 3) ; 
    head := push(head, 2) ; 
    head := push(head, 1) ; 
    var k : int ; k := 3 ;
    OclFile["System.out"].print("Given linked list \n") ; 
    execute printList(head) ; 
    head := reverse(head, k) ; 
    OclFile["System.out"].print("\nReversed Linked list \n") ; 
    execute printList(head) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int l=sc.nextInt();
    int r=sc.nextInt();
    String res="" ;
    while(l<=r && ! distintosDigitos(l)){
      l++;
    }
    if(l==r+1)System.out.println(-1);
    else System.out.println(l);
  }
  private static boolean distintosDigitos(int d){
    boolean[] digito=new boolean[10];
    while(d>0){
      int n=d % 10 ;
      if(digito[n])return false ;
      digito[n]=true ;
      d/=10 ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var res : String ; res := "" ;
    while (l <= r & not(distintosDigitos(l))) do (     l := l + 1 ) ; 
    if (l = r + 1) then     OclFile["System.out"].println(-1) else     OclFile["System.out"].println(l) ; ;  
 );
  static   operation distintosDigitos( d : int) : boolean
  pre: true
  post: true
  activity: (     var digito : Sequence(boolean) ; digito := Integer.subrange(1,10)->collect(false) ;
     while (d > 0) do (     var n : int ; n := d mod 10 ;
     if (digito[n+1]) then     return false else skip ; 
     digito[n+1] := true ; 
     d := d/(10) ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int l=sc.nextInt();
    int r=sc.nextInt();
    for(int i=l ; i<=r ; i++){
      ArrayList<Integer>list=new ArrayList<>();
      int auxiliar=i ;
      while(auxiliar>0){
        list.add(auxiliar % 10);
        auxiliar/=10 ;
      }
      if(! comprobarRepetidos(list)){
        System.out.println(i);
        break ;
      }
      l++;
    }
    if(l==r+1){
      System.out.println("-1");
    }
  }
  public static boolean comprobarRepetidos(ArrayList<Integer>list){
    for(int i=0 ; i<list.size()-1 ; i++){
      for(int j=i+1 ; j<list.size(); j++){
        if(list.get(i)==list.get(j)){
          return true ;
        }
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
        var i : int ; i := l ; while i <= r do ( (     var list : Sequence(int) ; list := Sequence{} ;
     var auxiliar : int ; auxiliar := i ;
    while (auxiliar > 0) do (     list := list->including(auxiliar mod 10) ; 
     auxiliar := auxiliar/(10) ) ; 
    if (not(comprobarRepetidos(list))) then (     OclFile["System.out"].println(i) ; 
     break ) else skip ; 
    l := l + 1 ; 
 )  ;     i := i + 1 ) ; 
    if (l = r + 1) then (     OclFile["System.out"].println("-1") ) else skip ; 
 );
  static   operation comprobarRepetidos( list : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < list->size() - 1 do ( (         var j : int ; j := i + 1 ; while j < list->size() do ( (     if (list->at(i+1) = list->at(j+1)) then (     return true ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws java.io.IOException {
    BufferedReader leer=new BufferedReader(new InputStreamReader(System.in));
    Scanner in=new Scanner(System.in);
    while(leer.ready()){
      int l=in.nextInt();
      int r=in.nextInt();
      int res=0 ;
      boolean bb=true ;
      for(int i=l ; i<=r && bb ; i++){
        if(distintos(i)){
          res=i ;
          bb=false ;
        }
      }
      if(bb){
        System.out.println(-1);
      }
      else {
        System.out.println(res);
      }
    }
  }
  static boolean distintos(int n){
    char[] arr=(n+"").toCharArray();
    HashMap<Character,Integer>map=new HashMap<>();
    for(int i=0 ; i<arr.length ; i++){
      if(map.containsKey(arr[i])){
        map.put(arr[i],map.get(arr[i])+1);
      }
      else {
        map.put(arr[i],1);
      }
    }
    for(Map.Entry entry : map.entrySet()){
      if(Integer.parseInt((entry.getValue()+""))!=1){
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var leer : OclFile ; leer := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (leer.canRead()) do (     var l : int ; l := in.getCurrent()->toInteger() ;
     var r : int ; r := in.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
    var bb : boolean ; bb := true ;
        var i : int ; i := l ; while i <= r & bb do ( (     if (distintos(i)) then (     res := i ; 
     bb := false ) else skip )  ;     i := i + 1 ) ; 
    if (bb) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(res) ) ;  
 ) );
  static   operation distintos( n : int) : boolean
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := (n + "")->characters() ;
     var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (map->keys()->includes(arr[i+1])) then (     map := map->union(Map{arr[i+1] |-> map->at(arr[i+1]) + 1}) ) else (     map := map->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    for (entry : map->asSet()) do ( (     if (((entry.getValue() + ""))->toInteger() /= 1) then (     return false ) else skip )  ) ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DigitosDisitintos {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int aux ;
    int dig=0 ;
    for(int i=a ; i<=b ; i++){
      int[] x=new int[10];
      dig=0 ;
      aux=i ;
      while(aux>0){
        x[aux % 10]++;
        if(x[aux % 10]>1){
          dig=1 ;
          break ;
        }
        aux/=10 ;
      }
      if(dig==0){
        System.out.println(i);
        break ;
      }
    }
    if(dig==1){
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DigitosDisitintos {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var aux : int ;
    var dig : int ; dig := 0 ;
        var i : int ; i := a ; while i <= b do ( (     var x : Sequence(int) ; x := Integer.subrange(1,10)->collect(0) ;
     dig := 0 ; 
    aux := i ; 
    while (aux > 0) do (     x[aux mod 10+1] := x[aux mod 10+1] + 1 ; 
     if (x[aux mod 10+1] > 1) then (     dig := 1 ; 
     break ) else skip ; 
     aux := aux/(10) ) ; 
    if (dig = 0) then (     OclFile["System.out"].println(i) ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (dig = 1) then (     OclFile["System.out"].println(-1) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int l=sc.nextInt();
    int r=sc.nextInt();
    while(l<=r && ! distintosDigitos(l)){
      l++;
    }
    if(l==r+1){
      System.out.println(-1);
    }
    else {
      System.out.println(l);
    }
  }
  private static boolean distintosDigitos(int l){
    boolean[] present=new boolean[10];
    while(l>0){
      int digit=l % 10 ;
      if(present[digit])return false ;
      present[digit]=true ;
      l/=10 ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    while (l <= r & not(distintosDigitos(l))) do (     l := l + 1 ) ; 
    if (l = r + 1) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(l) ) ;  
 );
  static   operation distintosDigitos( l : int) : boolean
  pre: true
  post: true
  activity: (     var present : Sequence(boolean) ; present := Integer.subrange(1,10)->collect(false) ;
     while (l > 0) do (     var digit : int ; digit := l mod 10 ;
     if (present[digit+1]) then     return false else skip ; 
     present[digit+1] := true ; 
     l := l/(10) ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int minPassed=Integer.MAX_VALUE ;
    int maxPassed=Integer.MIN_VALUE ;
    for(int i=0 ; i<a ; i++){
      int v=sc.nextInt();
      minPassed=Math.min(minPassed,v);
      maxPassed=Math.max(maxPassed,v);
    }
    int minReq=Math.max(maxPassed,2*minPassed);
    int minNotPassed=Integer.MAX_VALUE ;
    for(int i=0 ; i<b ; i++){
      int v=sc.nextInt();
      minNotPassed=Math.min(minNotPassed,v);
    }
    if(minNotPassed>minReq){
      System.out.println(minReq);
    }
    else {
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var minPassed : int ; minPassed := 2147483647 ;
    var maxPassed : int ; maxPassed := -2147483648 ;
        var i : int ; i := 0 ; while i < a do ( (     var v : int ; v := sc.getCurrent()->toInteger() ;
     minPassed := Set{minPassed, v}->min() ; 
     maxPassed := Set{maxPassed, v}->max() )  ;     i := i + 1 ) ; 
    var minReq : int ; minReq := Set{maxPassed, 2 * minPassed}->max() ;
    var minNotPassed : int ; minNotPassed := 2147483647 ;
        var i : int ; i := 0 ; while i < b do ( (     var v : int ; v := sc.getCurrent()->toInteger() ;
     minNotPassed := Set{minNotPassed, v}->min() )  ;     i := i + 1 ) ; 
    if (minNotPassed > minReq) then (     OclFile["System.out"].println(minReq) ) else (     OclFile["System.out"].println(-1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    sc.nextLine();
    int ns[]=Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    int ms[]=Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    int v=Math.max(Arrays.stream(ns).max().getAsInt(),2*(Arrays.stream(ns).min().getAsInt()));
    if(Arrays.stream(ms).min().getAsInt()<=v)System.out.println(-1);
    else System.out.println(v);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    skip ; 
    var ns : Sequence(int) ; ns := stream(sc.nextLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var ms : Sequence(int) ; ms := stream(sc.nextLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var v : int ; v := Set{stream(ns).max().getAsInt(), 2 * (stream(ns).min().getAsInt())}->max() ;
    if (stream(ms).min().getAsInt() <= v) then     OclFile["System.out"].println(-1) else     OclFile["System.out"].println(v) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int a[]=new int[n];
    int b[]=new int[m];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    for(int i=0 ; i<m ; i++){
      b[i]=sc.nextInt();
    }
    Arrays.sort(a);
    Arrays.sort(b);
    int tmin=2*a[0];
    tmin=Math.max(tmin,a[n-1]);
    if(b[0]<=tmin)System.out.println("-1");
    else System.out.println(tmin);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    var tmin : int ; tmin := 2 * a[0+1] ;
    tmin := Set{tmin, a[n - 1+1]}->max() ; 
    if (b[0+1] <= tmin) then     OclFile["System.out"].println("-1") else     OclFile["System.out"].println(tmin) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    String n ;
    try(Scanner sc=new Scanner(System.in)){
      n=sc.next();
      System.out.println(String.format("%32s",Long.toBinaryString(Long.parseLong(n))).replace(' ','0'));
      System.out.println(String.format("%32s",Long.toBinaryString(~ Long.parseLong(n))).substring(32));
      System.out.println(String.format("%33s",Long.toBinaryString(Long.parseLong(n)<<1)).replace(' ','0').substring(1));
      System.out.println(String.format("%32s",Long.toBinaryString(Long.parseLong(n)>>>1)).replace(' ','0'));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : String ;
     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     n := sc.getCurrent() ; 
     OclFile["System.out"].println(StringLib.format("%32s",Sequence{(MathLib.decimal2binary((n)->toLong()) + "")}).replace(' ', '0')) ; 
    OclFile["System.out"].println(StringLib.format("%32s",Sequence{(MathLib.decimal2binary(-((n)->toLong() + 1)) + "")}).subrange(32+1,32)) ; 
    OclFile["System.out"].println(StringLib.format("%33s",Sequence{(MathLib.decimal2binary(((n)->toLong()*(2->pow(1)))->oclAsType(long)) + "")}).replace(' ', '0').subrange(1+1,1)) ; 
    OclFile["System.out"].println(StringLib.format("%32s",Sequence{(MathLib.decimal2binary(((n)->toLong()/(2->pow(1)))->oclAsType(long)) + "")}).replace(' ', '0')) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static void solve(int N,int H,int[] attack,int[] throwk){
    int count=0 ;
    int sum=0 ;
    Arrays.sort(attack);
    int maxa=attack[N-1];
    Arrays.sort(throwk);
    for(int i=N-1 ; throwk[i]>maxa && i>0 ; i--){
      sum+=throwk[i];
      count++;
      if(sum>=H){
        System.out.print(count);
        return ;
      }
    }
    if(throwk[0]>maxa){
      sum+=throwk[0];
      count++;
    }
    if(sum>=H){
      System.out.print(count);
      return ;
    }
    count=(int)(count+Math.ceil((double)(H-sum)/maxa));
    System.out.print(count);
    return ;
  }
  public static void main(String args[]){
    Scanner input=new Scanner(System.in);
    int N=input.nextInt();
    int H=input.nextInt();
    int[] attack=new int[N];
    int[] throwk=new int[N];
    for(int i=0 ; i<N ; i++){
      attack[i]=input.nextInt();
      throwk[i]=input.nextInt();
    }
    input.close();
    solve(N,H,attack,throwk);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( N : int, H : int, attack : Sequence(int), throwk : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var sum : int ; sum := 0 ;
    attack := attack->sort() ; 
    var maxa : int ; maxa := attack[N - 1+1] ;
    throwk := throwk->sort() ; 
        var i : int ; i := N - 1 ; while throwk[i+1] > maxa & i > 0 do ( (     sum := sum+(throwk[i+1]) ; 
     count := count + 1 ; 
     if (sum >= H) then (     OclFile["System.out"].print(count) ; 
     return ) else skip )  ;     i := i - 1 ) ; 
    if (throwk[0+1] > maxa) then (     sum := sum+(throwk[0+1]) ; 
     count := count + 1 ) else skip ; 
    if (sum >= H) then (     OclFile["System.out"].print(count) ; 
     return ) else skip ; 
    count := (count + ((H - sum)->oclAsType(double) / maxa)->ceil())->oclAsType(int) ; 
    OclFile["System.out"].print(count) ; 
    return 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := input.getCurrent()->toInteger() ;
    var H : int ; H := input.getCurrent()->toInteger() ;
    var attack : Sequence(int) ; attack := Integer.subrange(1,N)->collect(0) ;
    var throwk : Sequence(int) ; throwk := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     attack[i+1] := input.getCurrent()->toInteger() ; 
     throwk[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    execute solve(N, H, attack, throwk) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static final int MODULUS=1_000_000_007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sc.nextInt();
    String S1=sc.next();
    String S2=sc.next();
    System.out.println(solve(S1,S2));
    sc.close();
  }
  static int solve(String S1,String S2){
    int result=1 ;
    int index=0 ;
    int prevLength=0 ;
    while(index!=S1.length()){
      int factor ;
      if(index+1!=S1.length()&& S1.charAt(index)==S1.charAt(index+1)){
        if(prevLength==0){
          factor=6 ;
        }
        else if(prevLength==1){
          factor=2 ;
        }
        else {
          factor=3 ;
        }
        prevLength=2 ;
      }
      else {
        if(prevLength==0){
          factor=3 ;
        }
        else if(prevLength==1){
          factor=2 ;
        }
        else {
          factor=1 ;
        }
        prevLength=1 ;
      }
      result=multiplyMod(result,factor);
      index+=prevLength ;
    }
    return result ;
  }
  static int multiplyMod(int x,int y){
    return(int)((long)x*y % MODULUS);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MODULUS : int := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var S1 : String ; S1 := sc.getCurrent() ;
    var S2 : String ; S2 := sc.getCurrent() ;
    OclFile["System.out"].println(solve(S1, S2)) ; 
    skip ; 
 );
  static   operation solve( S1 : String, S2 : String) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 1 ;
     var index : int ; index := 0 ;
    var prevLength : int ; prevLength := 0 ;
    while (index /= S1->size()) do (     var factor : int ;
     if (index + 1 /= S1->size() & S1->at(index+1) = S1->at(index + 1+1)) then (     if (prevLength = 0) then (     factor := 6 ) else     if (prevLength = 1) then (     factor := 2 ) else (     factor := 3 ) ;  ;  
     prevLength := 2 ) else (     if (prevLength = 0) then (     factor := 3 ) else     if (prevLength = 1) then (     factor := 2 ) else (     factor := 1 ) ;  ;  
     prevLength := 1 ) ;  
     result := multiplyMod(result, factor) ; 
     index := index+(prevLength) ) ; 
    return result 
 );
  static   operation multiplyMod( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return (x->oclAsType(long) * y mod MODULUS)->oclAsType(int) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int k=Integer.parseInt(sc.next());
    int q=Integer.parseInt(sc.next());
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(sc.next());
    }
    int ans=(int)1e9 ;
    for(int x : a){
      int cnt=0 ;
      PriorityQueue<Integer>que=new PriorityQueue<>();
      PriorityQueue<Integer>ya=new PriorityQueue<>();
      for(int i=0 ; i<n ; i++){
        que.add(a[i]);
        if(a[i]<x){
          que.clear();
        }
        if(k<=que.size()){
          cnt++;
          ya.add(que.poll());
        }
      }
      if(q<=cnt){
        int y=0 ;
        for(int i=0 ; i<q ; i++){
          y=ya.poll();
        }
        ans=Math.min(ans,y-x);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var k : int ; k := (sc.getCurrent())->toInteger() ;
    var q : int ; q := (sc.getCurrent())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 1e9->oclAsType(int) ;
    for (x : a) do ( (     var cnt : int ; cnt := 0 ;
     var que : Sequence(int) ; que := Sequence{} ;
    var ya : Sequence(int) ; ya := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     que := que->including(a[i+1]) ; 
     if (a[i+1] < x) then (     que := que->intersection(Set{}) ) else skip ; 
     if (k <= que->size()) then (     cnt := cnt + 1 ; 
     ya := ya->including(que->min()) ) else skip )  ;     i := i + 1 ) ; 
    if (q <= cnt) then (     var y : int ; y := 0 ;
         var i : int ; i := 0 ; while i < q do ( (     y := ya->min() ;     ya := ya->sort()->tail() )  ;     i := i + 1 ) ; 
     ans := Set{ans, y - x}->min() ) else skip ; 
 )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int K=scan.nextInt();
    int Q=scan.nextInt();
    int[] A=new int[N];
    int[] B=new int[N];
    for(int i=0 ; i<N ; ++i){
      A[i]=scan.nextInt();
      B[i]=A[i];
    }
    Arrays.sort(B);
    int ans=1000000001 ;
    PriorityQueue<Integer>que=new PriorityQueue<>();
    for(int i=0 ; i<N ; ++i){
      if(i+Q-1>=N || B[i+Q-1]-B[i]>=ans)continue ;
      int left=-1,right=ans ;
      while(right-left>1){
        int center=(right+left)/2 ;
        int cnt=0 ;
        que.clear();
        for(int j=0 ; j<N ; ++j){
          if(A[j]<B[i])que.clear();
          else {
            que.add(A[j]);
            if(que.size()>=K){
              if(que.poll()-B[i]<=center)++cnt ;
              if(cnt>=Q){
                break ;
              }
            }
          }
        }
        if(cnt>=Q)right=center ;
        else left=center ;
      }
      ans=Math.min(ans,right);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var K : int ; K := scan.getCurrent()->toInteger() ;
    var Q : int ; Q := scan.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := scan.getCurrent()->toInteger() ; 
     B[i+1] := A[i+1] )  ;     i := i + 1 ) ; 
    B := B->sort() ; 
    var ans : int ; ans := 1000000001 ;
    var que : Sequence(int) ; que := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     if (i + Q - 1 >= N or B[i + Q - 1+1] - B[i+1] >= ans) then     continue else skip ; 
     var left : int ; left := -1 ;
    var right : int ; right := ans ;
     while (right - left > 1) do (     var center : int ; center := (right + left) / 2 ;
     var cnt : int ; cnt := 0 ;
    que := que->intersection(Set{}) ; 
        var j : int ; j := 0 ; while j < N do ( (     if (A[j+1] < B[i+1]) then     que := que->intersection(Set{}) ; else (     que := que->including(A[j+1]) ; 
     if (que->size() >= K) then (     if (que->min() - B[i+1] <= center) then     cnt := cnt + 1 ; else skip ; 
     if (cnt >= Q) then (     break ) else skip ) else skip ) )  ;     j := j + 1 ) ; 
    if (cnt >= Q) then     right := center else     left := center ; ;  
 ) ; 
     ans := Set{ans, right}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int q=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    long ans=1000000000 ;
    PriorityQueue<Integer>small=new PriorityQueue<>(),big=new PriorityQueue<>();
    for(int i=0 ; i<n ; i++){
      int left=0 ;
      big.clear();
      while(left<n){
        while(left<n && a[left]<a[i]){
          left++;
        }
        small.clear();
        while(left<n && a[left]>=a[i]){
          small.add(a[left++]);
        }
        while(small.size()>=k){
          big.add(small.poll());
        }
      }
      if(big.size()<q){
        continue ;
      }
      for(int j=1 ; j<q ; j++){
        big.poll();
      }
      ans=Math.min(ans,big.peek()-a[i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 1000000000 ;
    var small : Sequence(int) ; small := Sequence{} ;
    var big : Sequence(int) ; big := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var left : int ; left := 0 ;
     big := big->intersection(Set{}) ; 
    while (left < n) do (     while (left < n & a[left+1] < a[i+1]) do (     left := left + 1 ) ; 
     small := small->intersection(Set{}) ; 
     while (left < n & a[left+1] >= a[i+1]) do (     small := small->including(a[left+1]) ) ; 
     while (small->size() >= k) do (     big->excludes(small->min()) ) ) ; 
    if (big->size() < q) then (     continue ) else skip ; 
        var j : int ; j := 1 ; while j < q do ( (     big := big->sort()->tail() )  ;     j := j + 1 ) ; 
    ans := Set{ans, big->min() - a[i+1]}->min() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int K=scanner.nextInt();
    int Q=scanner.nextInt();
    long A[]=new long[N];
    for(int i=0 ; i<N ; i++){
      A[i]=scanner.nextInt();
    }
    boolean flag[]=new boolean[N+1];
    long ans=(long)1e18 ;
    flag[N]=true ;
    for(int loop=0 ; loop<N ; loop++){
      ArrayList<Long>v=new ArrayList<>(),v_tmp=new ArrayList<>();
      for(int i=0 ; i<=N ; i++){
        if(flag[i]){
          Collections.sort(v_tmp);
          for(int j=0 ; j<=v_tmp.size()-K ; j++){
            v.add(v_tmp.get(j));
          }
          v_tmp.clear();
        }
        else {
          v_tmp.add(A[i]);
        }
      }
      if(v.size()>=Q){
        Collections.sort(v);
        ans=Math.min(ans,v.get(Q-1)-v.get(0));
      }
      int pos=0 ;
      long num=(long)1e18 ;
      for(int i=0 ; i<N ; i++){
        if(! flag[i] && A[i]<num){
          pos=i ;
          num=A[i];
        }
      }
      flag[pos]=true ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var K : int ; K := scanner.getCurrent()->toInteger() ;
    var Q : int ; Q := scanner.getCurrent()->toInteger() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var flag : Sequence(boolean) ; flag := Integer.subrange(1,N + 1)->collect(false) ;
    var ans : long ; ans := 1e18->oclAsType(long) ;
    flag[N+1] := true ; 
        var loop : int ; loop := 0 ; while loop < N do ( (     var v : Sequence(long) ; v := Sequence{} ;
    var v_tmp : Sequence(long) ; v_tmp := Sequence{} ;
         var i : int ; i := 0 ; while i <= N do ( (     if (flag[i+1]) then (     v_tmp := v_tmp->sort() ; 
         var j : int ; j := 0 ; while j <= v_tmp->size() - K do ( (     v := v->including(v_tmp->at(j+1)) )  ;     j := j + 1 ) ; 
     v_tmp := v_tmp->intersection(Set{}) ) else (     v_tmp->excludes(A[i+1]) ) )  ;     i := i + 1 ) ; 
    if (v->size() >= Q) then (     v := v->sort() ; 
     ans := Set{ans, v->at(Q - 1+1) - v->at(0+1)}->min() ) else skip ; 
    var pos : int ; pos := 0 ;
    var num : long ; num := 1e18->oclAsType(long) ;
        var i : int ; i := 0 ; while i < N do ( (     if (not(flag[i+1]) & A[i+1] < num) then (     pos := i ; 
     num := A[i+1] ) else skip )  ;     i := i + 1 ) ; 
    flag[pos+1] := true ; 
 )  ;     loop := loop + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static int[] arr=new int[10];
  private static int ans=0 ;
  private static void check_common(int i){
    while(i>0){
      if(arr[i % 10]==1){
        ans++;
        break ;
      }
      i=i/10 ;
    }
  }
  public static void main(String[] args){
    int x,n,i ;
    for(i=0 ; i<10 ; i++){
      arr[i]=0 ;
    }
    Scanner sc=new Scanner(System.in);
    x=sc.nextInt();
    n=x ;
    while(n>=1){
      arr[n % 10]=1 ;
      n=n/10 ;
    }
    if(x==1){
      ans=1 ;
    }
    else {
      for(i=1 ; i*i<=x ; i++){
        if(x % i==0){
          check_common(i);
          if(x/i!=i){
            check_common(x/i);
          }
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute arr : Sequence(int) := Integer.subrange(1,10)->collect(0);
  static   attribute ans : int := 0;
  static   operation check_common( i : int) : void
  pre: true
  post: true
  activity: (     while (i > 0) do (     if (arr[i mod 10+1] = 1) then (     ans := ans + 1 ; 
     break ) else skip ; 
     i := i / 10 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ;
    var n : int ;
    var i : int ;
         i := 0 ; while i < 10 do ( (     arr[i+1] := 0 )  ;     i := i + 1 ) ; 
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    x := sc.getCurrent()->toInteger() ; 
    n := x ; 
    while (n >= 1) do (     arr[n mod 10+1] := 1 ; 
     n := n / 10 ) ; 
    if (x = 1) then (     ans := 1 ) else (         i := 1 ; while i * i <= x do ( (     if (x mod i = 0) then (     execute check_common(i) ; 
     if (x / i /= i) then (     execute check_common(x / i) ) else skip ) else skip )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
import static java.lang.Math.sqrt ;
public class BLittleElephantAndNumbers {
  public static void main(String[] args){
    BLittleElephantAndNumbers elephantAndNumbers=new BLittleElephantAndNumbers();
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    int num=elephantAndNumbers.getYueNum(t);
    System.out.println(num);
  }
  private int getYueNum(int n){
    List<Integer>arrayInt=getYueShulist(n);
    int num=0 ;
    for(int i=0 ; i<arrayInt.size(); i++){
      if(judgeNum(n,arrayInt.get(i))){
        num++;
      }
    }
    return num ;
  }
  private List<Integer>getYueShulist(int n){
    List<Integer>arrayInt=new ArrayList<>();
    for(int i=1 ; i<=sqrt(n); i++){
      int b ;
      if(n % i==0){
        b=i ;
        arrayInt.add(b);
        if(n!=b*b){
          arrayInt.add(n/b);
        }
      }
    }
    return arrayInt ;
  }
  private boolean judgeNum(int a,int b){
    char[] arra=getNumList(a);
    char[] arrb=getNumList(b);
    boolean flag=false ;
    for(int i=0 ; i<arra.length ; i++){
      for(int j=0 ; j<arrb.length ; j++){
        if(arra[i]==arrb[j]){
          flag=true ;
          break ;
        }
      }
      if(flag==true){
        break ;
      }
    }
    return flag ;
  }
  private char[] getNumList(int n){
    char[] chars=String.valueOf(n).toCharArray();
    return chars ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class BLittleElephantAndNumbers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var elephantAndNumbers : BLittleElephantAndNumbers ; elephantAndNumbers := BLittleElephantAndNumbers.newBLittleElephantAndNumbers() ;
     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var t : int ; t := input.getCurrent()->toInteger() ;
    var num : int ; num := elephantAndNumbers.getYueNum(t) ;
    OclFile["System.out"].println(num) ; 
 );
   operation getYueNum( n : int) : int
  pre: true
  post: true
  activity: (     var arrayInt : Sequence(int) ; arrayInt := getYueShulist(n) ;
     var num : int ; num := 0 ;
         var i : int ; i := 0 ; while i < arrayInt->size() do ( (     if (judgeNum(n, arrayInt->at(i+1))) then (     num := num + 1 ) else skip )  ;     i := i + 1 ) ; 
     return num );
   operation getYueShulist( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arrayInt : Sequence(int) ; arrayInt := Sequence{} ;
         var i : int ; i := 1 ; while i <= sqrt(n) do ( (     var b : int ;
     if (n mod i = 0) then (     b := i ; 
     arrayInt := arrayInt->including(b) ; 
     if (n /= b * b) then (     arrayInt := arrayInt->including(n / b) ) else skip ) else skip )  ;     i := i + 1 ) ; 
     return arrayInt );
   operation judgeNum( a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     var arra : Sequence(String) ; arra := getNumList(a) ;
     var arrb : Sequence(String) ; arrb := getNumList(b) ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < arra->size() do ( (         var j : int ; j := 0 ; while j < arrb->size() do ( (     if (arra[i+1] = arrb[j+1]) then (     flag := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (flag = true) then (     break ) else skip )  ;     i := i + 1 ) ; 
    return flag 
 );
   operation getNumList( n : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var chars : Sequence(String) ; chars := ((n) + "")->characters() ;
     return chars );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MainB {
  private static int[] arr=new int[10];
  private static int ans=0 ;
  private static void check_common(int i){
    while(i>0){
      if(arr[i % 10]==1){
        ans++;
        break ;
      }
      i=i/10 ;
    }
  }
  public static void main(String[] args){
    int x,n,i ;
    for(i=0 ; i<10 ; i++){
      arr[i]=0 ;
    }
    Scanner scanner=new Scanner(System.in);
    x=scanner.nextInt();
    n=x ;
    while(n>=1){
      arr[n % 10]=1 ;
      n=n/10 ;
    }
    if(x==1){
      ans=1 ;
    }
    else {
      for(i=1 ; i*i<=x ; i++){
        if(x % i==0){
          check_common(i);
          if(x/i!=i){
            check_common(x/i);
          }
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainB {
  static   attribute arr : Sequence(int) := Integer.subrange(1,10)->collect(0);
  static   attribute ans : int := 0;
  static   operation check_common( i : int) : void
  pre: true
  post: true
  activity: (     while (i > 0) do (     if (arr[i mod 10+1] = 1) then (     ans := ans + 1 ; 
     break ) else skip ; 
     i := i / 10 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ;
    var n : int ;
    var i : int ;
         i := 0 ; while i < 10 do ( (     arr[i+1] := 0 )  ;     i := i + 1 ) ; 
    var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    x := scanner.getCurrent()->toInteger() ; 
    n := x ; 
    while (n >= 1) do (     arr[n mod 10+1] := 1 ; 
     n := n / 10 ) ; 
    if (x = 1) then (     ans := 1 ) else (         i := 1 ; while i * i <= x do ( (     if (x mod i = 0) then (     execute check_common(i) ; 
     if (x / i /= i) then (     execute check_common(x / i) ) else skip ) else skip )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    String strN=n+"" ;
    boolean have0=strN.contains("0");
    boolean have1=strN.contains("1");
    boolean have2=strN.contains("2");
    boolean have3=strN.contains("3");
    boolean have4=strN.contains("4");
    boolean have5=strN.contains("5");
    boolean have6=strN.contains("6");
    boolean have7=strN.contains("7");
    boolean have8=strN.contains("8");
    boolean have9=strN.contains("9");
    int cnt=0 ;
    for(int i=1 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        String strI=i+"" ;
        if((have0 && strI.contains("0"))||(have1 && strI.contains("1"))||(have2 && strI.contains("2"))||(have3 && strI.contains("3"))||(have4 && strI.contains("4"))||(have5 && strI.contains("5"))||(have6 && strI.contains("6"))||(have7 && strI.contains("7"))||(have8 && strI.contains("8"))||(have9 && strI.contains("9"))){
          cnt++;
        }
        if(n/i!=i){
          String strI2=n/i+"" ;
          if((have0 && strI2.contains("0"))||(have1 && strI2.contains("1"))||(have2 && strI2.contains("2"))||(have3 && strI2.contains("3"))||(have4 && strI2.contains("4"))||(have5 && strI2.contains("5"))||(have6 && strI2.contains("6"))||(have7 && strI2.contains("7"))||(have8 && strI2.contains("8"))||(have9 && strI2.contains("9"))){
            cnt++;
          }
        }
      }
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var strN : String ; strN := n + "" ;
    var have0 : boolean ; have0 := strN->includes("0") ;
    var have1 : boolean ; have1 := strN->includes("1") ;
    var have2 : boolean ; have2 := strN->includes("2") ;
    var have3 : boolean ; have3 := strN->includes("3") ;
    var have4 : boolean ; have4 := strN->includes("4") ;
    var have5 : boolean ; have5 := strN->includes("5") ;
    var have6 : boolean ; have6 := strN->includes("6") ;
    var have7 : boolean ; have7 := strN->includes("7") ;
    var have8 : boolean ; have8 := strN->includes("8") ;
    var have9 : boolean ; have9 := strN->includes("9") ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 1 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     var strI : String ; strI := i + "" ;
     if ((have0 & strI->includes("0")) or (have1 & strI->includes("1")) or (have2 & strI->includes("2")) or (have3 & strI->includes("3")) or (have4 & strI->includes("4")) or (have5 & strI->includes("5")) or (have6 & strI->includes("6")) or (have7 & strI->includes("7")) or (have8 & strI->includes("8")) or (have9 & strI->includes("9"))) then (     cnt := cnt + 1 ) else skip ; 
     if (n / i /= i) then (     var strI2 : String ; strI2 := n / i + "" ;
     if ((have0 & strI2->includes("0")) or (have1 & strI2->includes("1")) or (have2 & strI2->includes("2")) or (have3 & strI2->includes("3")) or (have4 & strI2->includes("4")) or (have5 & strI2->includes("5")) or (have6 & strI2->includes("6")) or (have7 & strI2->includes("7")) or (have8 & strI2->includes("8")) or (have9 & strI2->includes("9"))) then (     cnt := cnt + 1 ) else skip ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(1,in,out);
    out.close();
  }
  static class Task {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int N=in.nextInt();
      int M=in.nextInt();
      Integer[] a=new Integer[N];
      Integer[] b=new Integer[N];
      for(int i=0 ; i<N ; i++){
        a[i]=in.nextInt();
        b[i]=in.nextInt();
      }
      Arrays.sort(a,Comparator.reverseOrder());
      Arrays.sort(b,Comparator.reverseOrder());
      int count=0 ;
      for(int i=0 ; i<N ; i++){
        if(b[i]<=a[0]){
          break ;
        }
        count++;
        M-=b[i];
        if(M<=0){
          break ;
        }
      }
      while(M>0){
        M-=a[0];
        count++;
      }
      out.println(count);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.nextInt() ;
     var M : int ; M := in.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(null) ;
    var b : Sequence(int) ; b := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := in.nextInt() ; 
     b[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    a := OclComparator.sortWith(a, Comparator.reverseOrder()) ; 
    b := OclComparator.sortWith(b, Comparator.reverseOrder()) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (b[i+1] <= a[0+1]) then (     break ) else skip ; 
     count := count + 1 ; 
     M := M-(b[i+1]) ; 
     if (M <= 0) then (     break ) else skip )  ;     i := i + 1 ) ; 
    while (M > 0) do (     M := M-(a[0+1]) ; 
     count := count + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int fnMod(int n){
    int rem=n % 4 ;
    if(rem==0 || rem==3)return 0 ;
    else if(rem==1 || rem==2)return 1 ;
    return 0 ;
  }
  public static void main(String[] args){
    int n=6 ;
    System.out.print(fnMod(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fnMod( n : int) : int
  pre: true
  post: true
  activity: (     var rem : int ; rem := n mod 4 ;
     if (rem = 0 or rem = 3) then     return 0 else     if (rem = 1 or rem = 2) then     return 1 else skip ; ;  
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].print(fnMod(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int array[][]=new int[3][n+1];
    for(int i=1 ; i<=2 ; i++){
      String str=br.readLine();
      for(int j=1 ; j<=n ; j++)array[i][j]=str.charAt(j-1);
    }
    String str="" ;
    for(int i=1 ; i<n ; i++){
      if(array[1][i]==array[1][i+1]){
        str+='Y' ;
++i ;
        continue ;
      }
      else str+='X' ;
      if(i==n-1)str+='X' ;
    }
    long ans ;
    long mod=(long)1E9+7 ;
    if(str.length()==0 || str.charAt(0)=='X')ans=3 ;
    else ans=6 ;
    for(int i=1 ; i<str.length(); i++){
      if(str.charAt(i-1)=='X' && str.charAt(i)=='Y')ans*=2 ;
      if(str.charAt(i-1)=='X' && str.charAt(i)=='X')ans*=2 ;
      if(str.charAt(i-1)=='Y' && str.charAt(i)=='Y')ans*=3 ;
      while(ans>=mod)ans-=mod ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var array : Sequence(Sequence(int)) ; array := Integer.subrange(1,3)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= 2 do ( (     var str : String ; str := br.readLine() ;
         var j : int ; j := 1 ; while j <= n do (     array[i+1][j+1] := str->at((j)->char2byte() - 1+1) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var str : String ; str := "" ;
        var i : int ; i := 1 ; while i < n do ( (     if (array[1+1][i+1] = array[1+1][i + 1+1]) then (     str := str+('Y') ; 
     i := i + 1 ; 
     continue ) else     str := str+('X') ; ;  
     if (i = n - 1) then     str := str+('X') ; else skip )  ;     i := i + 1 ) ; 
    var ans : long ;
    var mod : long ; mod := 1E9->oclAsType(long) + 7 ;
    if (str->size() = 0 or str->at(0+1) = 'X') then     ans := 3 else     ans := 6 ; ;  
        var i : int ; i := 1 ; while i < str->size() do ( (     if (str->at((i)->char2byte() - 1+1) = 'X' & str->at(i+1) = 'Y') then     ans := ans*(2) ; else skip ; 
     if (str->at((i)->char2byte() - 1+1) = 'X' & str->at(i+1) = 'X') then     ans := ans*(2) ; else skip ; 
     if (str->at((i)->char2byte() - 1+1) = 'Y' & str->at(i+1) = 'Y') then     ans := ans*(3) ; else skip ; 
     while (ans >= mod) do     ans := ans-(mod) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printPair(int g,int l){
    System.out.print(g+" "+l);
  }
  public static void main(String[] args){
    int g=3,l=12 ;
    printPair(g,l);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printPair( g : int, l : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(g + " " + l) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : int ; g := 3 ;
    var l : int ; l := 12 ;
     execute printPair(g, l) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void anglechordtang(int z){
    System.out.print("The angle between tangent"+" and the chord is "+z+" degrees");
  }
  public static void main(String[] args){
    int z=48 ;
    anglechordtang(z);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation anglechordtang( z : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("The angle between tangent" + " and the chord is " + z + " degrees") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var z : int ; z := 48 ;
     execute anglechordtang(z) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s="" ;
    while(true){
      if(n %-2==0){
        s="0"+s ;
      }
      else {
        s="1"+s ;
        n--;
      }
      if(n/-2==0)break ;
      n/=-2 ;
    }
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := "" ;
    while (true) do (     if (n mod -2 = 0) then (     s := "0" + s ) else (     s := "1" + s ; 
     n := n - 1 ) ;  
     if (n / -2 = 0) then     break else skip ; 
     n := n/(-2) ) ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  static void divmod(int[] vi,int a,int b){
    if(b<0){
      b=-b ;
      a=-a ;
    }
    if(a>0){
      int q=0 ;
      int r=a ;
      while(r-b>=0){
        q+=1 ;
        r-=b ;
      }
      vi[0]=q ;
      vi[1]=r ;
    }
    else if(a<0){
      int q=0 ;
      int r=a ;
      do {
        q-=1 ;
        r+=b ;
      }
      while(r<0);
      vi[0]=q ;
      vi[1]=r ;
    }
    else {
      vi[0]=0 ;
      vi[1]=a ;
    }
  }
  public static void main(String[] args)throws IOException {
    final String s ;
    try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in))){
      s=reader.readLine();
    }
    int[] vi=new int[2];
    int N=Integer.parseInt(s);
    StringBuilder sb=new StringBuilder();
    int base=2 ;
    while(0!=N){
      divmod(vi,N,base);
      sb.insert(0,String.valueOf(vi[1]));
      N-=vi[1];
      divmod(vi,N,-base);
      N=vi[0];
    }
    if(sb.length()==0)sb.append("0");
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation divmod( vi : Sequence(int), a : int, b : int) : void
  pre: true
  post: true
  activity: (     if (b < 0) then (     b := -b ; 
     a := -a ) else skip ; 
     if (a > 0) then (     var q : int ; q := 0 ;
     var r : int ; r := a ;
    while (r - b >= 0) do (     q := q+(1) ; 
     r := r-(b) ) ; 
    vi[0+1] := q ; 
    vi[1+1] := r ; 
 ) else     if (a < 0) then (     var q : int ; q := 0 ;
     var r : int ; r := a ;
  while true do ((     q := q-(1) ; 
     r := r+(b) ) ;
    if (r < 0) then skip else break) ; 
    vi[0+1] := q ; 
    vi[1+1] := r ; 
 ) else (     vi[0+1] := 0 ; 
     vi[1+1] := a ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ;
     try (    var reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     s := reader.readLine() ))  
    var vi : Sequence(int) ; vi := Integer.subrange(1,2)->collect(0) ;
    var N : int ; N := (s)->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
    var base : int ; base := 2 ;
    while (0 /= N) do (     execute divmod(vi, N, base) ; 
     sb := sb.insertAt(0+1, StringLib.newString(((vi[1+1]) + ""))) ; 
    N := N-(vi[1+1]) ; 
    execute divmod(vi, N, -base) ; 
    N := vi[0+1] ; 
 ) ; 
    if (sb->size() = 0) then     sb := sb + StringLib.newString("0") ; else skip ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskC solver=new TaskC();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskC {
    StringBuilder ans=new StringBuilder();
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int N=in.nextInt();
      if(N==0)out.println(0);
      else {
        rec(N);
        out.println(ans.reverse());
      }
    }
    void rec(int N){
      if(N==0)return ;
      ans.append(yo(N,-2));
      rec(syo(N,-2));
    }
    int syo(int n1,int n2){
      if(n1>=0)return n1/n2 ;
      else return(n1-Math.abs(n2)+1)/n2 ;
    }
    int yo(int n1,int n2){
      if(n1>=0)return n1 % n2 ;
      else return((Math.abs(n2)+n1 % n2)% n2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskC ; solver := TaskC.newTaskC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskC {
   attribute ans : String := StringLib.newString();
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
     if (N = 0) then     skip ; else (     execute rec(N) ; 
     skip ) );
   operation rec( N : int) : void
  pre: true
  post: true
  activity: (     if (N = 0) then     return else skip ; 
     ans := ans + StringLib.newString(yo(N, -2)) ; 
     execute rec(syo(N, -2)) );
   operation syo( n1 : int, n2 : int) : int
  pre: true
  post: true
  activity: (     if (n1 >= 0) then     return n1 / n2 else     return (n1 - if n2 < 0 then -(n2) else n2 endif + 1) / n2 );
   operation yo( n1 : int, n2 : int) : int
  pre: true
  post: true
  activity: (     if (n1 >= 0) then     return n1 mod n2 else     return ((if n2 < 0 then -(n2) else n2 endif + n1 mod n2) mod n2) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Deque ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    sc.close();
    if(N==0){
      System.out.println(0);
    }
    else {
      Deque<Integer>stack=new ArrayDeque<Integer>();
      double tmp=0 ;
      for(int i=1 ; i<=35 ; i++){
        double bek=Math.pow(-2,i);
        if(N % bek==0){
          stack.push(0);
        }
        else {
          if(tmp==0){
            tmp=N-(bek/(-2));
          }
          else {
            tmp=tmp-(bek/(-2));
          }
          if(tmp % bek==0){
            stack.push(1);
          }
          else {
            stack.push(0);
            tmp=tmp+(bek/(-2));
          }
        }
      }
      int flag=0 ;
      int ff=stack.size();
      for(int i=0 ; i<ff ; i++){
        int a=stack.poll();
        if(flag==0 && a==0){
          continue ;
        }
        else {
          System.out.print(a);
          flag++;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     skip ; 
     if (N = 0) then (     OclFile["System.out"].println(0) ) else (     var stack : Sequence(int) ; stack := ArrayDeque<int>.newArrayDeque() ;
     var tmp : double ; tmp := 0 ;
        var i : int ; i := 1 ; while i <= 35 do ( (     var bek : double ; bek := -2->pow(i) ;
     if (N mod bek = 0) then (     stack := stack->append(0) ) else (     if (tmp = 0) then (     tmp := N - (bek / (-2)) ) else (     tmp := tmp - (bek / (-2)) ) ;  
     if (tmp mod bek = 0) then (     stack := stack->append(1) ) else (     stack := stack->append(0) ; 
     tmp := tmp + (bek / (-2)) ) ) )  ;     i := i + 1 ) ; 
    var flag : int ; flag := 0 ;
    var ff : int ; ff := stack->size() ;
        var i : int ; i := 0 ; while i < ff do ( (     var a : int ; a := stack->min() ;
     if (flag = 0 & a = 0) then (     continue ) else (     OclFile["System.out"].print(a) ; 
     flag := flag + 1 ) )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    FastScanner in=new FastScanner(System.in);
    int n=in.nextInt();
    if(n==0){
      System.out.println(0);
      return ;
    }
    String res="" ;
    while(n!=0){
      int thing=n/-2 ;
      int rem=n %-2 ;
      if(rem<0){
        rem=(rem+2)% 2 ;
        if(thing<0)thing--;
        else thing++;
      }
      res=""+rem+res ;
      n=thing ;
    }
    System.out.println(res);
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(InputStream in){
      br=new BufferedReader(new InputStreamReader(in));
      st=new StringTokenizer("");
    }
    public String next()throws IOException {
      if(! st.hasMoreTokens()){
        st=new StringTokenizer(br.readLine());
        return next();
      }
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public double nextDouble()throws NumberFormatException,IOException {
      return Double.parseDouble(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
  public static int go(String a){
    int res=0 ;
    for(int i=0 ; i<a.length(); i++){
      res+=a.charAt(i)-'0' ;
    }
    return res ;
  }
  public static int len(String a){
    int res=0 ;
    for(int i=a.length()-1 ; i>=0 ; i--){
      if(a.charAt(i)-'0'==0)res++;
      else return res ;
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var n : int ; n := in.nextInt() ;
    if (n = 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var res : String ; res := "" ;
    while (n /= 0) do (     var thing : int ; thing := n / -2 ;
     var rem : int ; rem := n mod -2 ;
    if (rem < 0) then (     rem := (rem + 2) mod 2 ; 
     if (thing < 0) then     thing := thing - 1 ; else     thing := thing + 1 ; ) else skip ; 
    res := "" + rem + res ; 
    n := thing ; 
 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     st := OclIterator.newOclIterator_String("") );
   operation next() : String
  pre: true
  post: true
  activity: (     if (not(st.hasNext())) then (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     return next() ) else skip ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   operation go( a : String) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < a->size() do ( (     res := res+(a->at(i+1) - ('0')->char2byte()) )  ;     i := i + 1 ) ; 
     return res );
  static   operation len( a : String) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := a->size() - 1 ; while i >= 0 do ( (     if (a->at(i+1) - ('0')->char2byte() = 0) then     res := res + 1 ; else     return res )  ;     i := i - 1 ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int fastmod(int base,int exp,int mod){
    if(exp==0)return 1 ;
    else if(exp % 2==0){
      int ans=fastmod(base,exp/2,mod);
      return(ans % mod*ans % mod)% mod ;
    }
    else return(fastmod(base,exp-1,mod)% mod*base % mod)% mod ;
  }
  static int countSetBits(int n){
    int count=0 ;
    while(n>0){
      count+=n & 1 ;
      n>>=1 ;
    }
    return count ;
  }
  static int findPowerSum(int n,int ar[]){
    final int mod=(int)1e9+7 ;
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      int base=countSetBits(ar[i]);
      int exp=ar[i];
      sum+=fastmod(base,exp,mod);
      sum %=mod ;
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=3 ;
    int ar[]={
      1,2,3 };
      System.out.println(findPowerSum(n,ar));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation fastmod( base : int, exp : int, mod : int) : int
  pre: true
  post: true
  activity: (     if (exp = 0) then     return 1 else     if (exp mod 2 = 0) then (     var ans : int ; ans := fastmod(base, exp / 2, mod) ;
     return (ans mod mod * ans mod mod) mod mod ) else     return (fastmod(base, exp - 1, mod) mod mod * base mod mod) mod mod ;  );
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     count := count+(n & 1) ; 
     n := n/(2->pow(1)) ) ; 
     return count );
  static   operation findPowerSum( n : int, ar : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var mod : int ; mod := 1e9->oclAsType(int) + 7 ;
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var base : int ; base := countSetBits(ar[i+1]) ;
     var exp : int ; exp := ar[i+1] ;
     sum := sum+(fastmod(base, exp, mod)) ; 
     sum := sum mod mod )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var ar : Sequence(int) ; ar := Sequence{1,2,3} ;
     OclFile["System.out"].println(findPowerSum(n, ar)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String input=sc.nextLine();
    String[] inputs=input.split(" ");
    int count=Integer.valueOf(inputs[0]);
    int score=Integer.valueOf(inputs[1]);
    int[] a=new int[count];
    int[] b=new int[count];
    for(int i=0 ; i<count ; i++){
      String data=sc.nextLine();
      String[] datas=data.split(" ");
      a[i]=Integer.valueOf(datas[0]);
      b[i]=Integer.valueOf(datas[1]);
    }
    int maxA=Integer.MIN_VALUE ;
    for(int i=0 ; i<count ; i++){
      if(a[i]>maxA){
        maxA=a[i];
      }
      else if(a[i]==maxA){
      }
    }
    int moves=0 ;
    Arrays.sort(b);
    int[] j=new int[count];
    for(int i=0 ; i<count ; i++){
      j[count-i-1]=b[i];
    }
    b=j ;
    for(int i=0 ; i<count ; i++){
      if(b[i]>=maxA){
        moves=moves+1 ;
        score=score-b[i];
        if(score<=0){
          break ;
        }
      }
    }
    if(score>0){
      int extraMoves=score/maxA ;
      if(score-(extraMoves*maxA)>0)moves=moves+extraMoves+1 ;
      else moves=moves+extraMoves ;
    }
    System.out.println(moves);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : String ; input := sc.nextLine() ;
    var inputs : Sequence(String) ; inputs := input->split(" ") ;
    var count : int ; count := (inputs[0+1])->toInteger() ;
    var score : int ; score := (inputs[1+1])->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,count)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,count)->collect(0) ;
        var i : int ; i := 0 ; while i < count do ( (     var data : String ; data := sc.nextLine() ;
     var datas : Sequence(String) ; datas := data->split(" ") ;
     a[i+1] := (datas[0+1])->toInteger() ; 
     b[i+1] := (datas[1+1])->toInteger() )  ;     i := i + 1 ) ; 
    var maxA : int ; maxA := -2147483648 ;
        var i : int ; i := 0 ; while i < count do ( (     if (a[i+1] > maxA) then (     maxA := a[i+1] ) else     if (a[i+1] = maxA) then skip else skip ; )  ;     i := i + 1 ) ; 
    var moves : int ; moves := 0 ;
    b := b->sort() ; 
    var j : Sequence(int) ; j := Integer.subrange(1,count)->collect(0) ;
        var i : int ; i := 0 ; while i < count do ( (     j[count - i - 1+1] := b[i+1] )  ;     i := i + 1 ) ; 
    b := j ; 
        var i : int ; i := 0 ; while i < count do ( (     if (b[i+1] >= maxA) then (     moves := moves + 1 ; 
     score := score - b[i+1] ; 
     if (score <= 0) then (     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (score > 0) then (     var extraMoves : int ; extraMoves := score / maxA ;
     if (score - (extraMoves * maxA) > 0) then     moves := moves + extraMoves + 1 ; else     moves := moves + extraMoves ; ) else skip ; 
    OclFile["System.out"].println(moves) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isPowerOf(long val,int base){
    while(val>1){
      if(val % base!=0)return false ;
      val/=base ;
    }
    return true ;
  }
  static int numberOfPartitions(String binaryNo){
    int i,j,n=binaryNo.length();
    long val ;
    int dp[]=new int[n];
    dp[n-1]=(((binaryNo.charAt(n-1)-'0')==0)?-1 : 1);
    for(i=n-2 ; i>=0 ; i--){
      val=0 ;
      if((binaryNo.charAt(i)-'0')==0){
        dp[i]=-1 ;
        continue ;
      }
      dp[i]=Integer.MAX_VALUE ;
      for(j=i ; j<n ; j++){
        val=(val*2)+(long)(binaryNo.charAt(j)-'0');
        if(isPowerOf(val,4)|| isPowerOf(val,6)){
          if(j==n-1){
            dp[i]=1 ;
          }
          else {
            if(dp[j+1]!=-1)dp[i]=Math.min(dp[i],dp[j+1]+1);
          }
        }
      }
      if(dp[i]==Integer.MAX_VALUE)dp[i]=-1 ;
    }
    return dp[0];
  }
  public static void main(String[] args){
    String binaryNo="100110110" ;
    System.out.println(numberOfPartitions(binaryNo));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPowerOf( val : long, base : int) : boolean
  pre: true
  post: true
  activity: (     while (val > 1) do (     if (val mod base /= 0) then     return false else skip ; 
     val := val/(base) ) ; 
     return true );
  static   operation numberOfPartitions( binaryNo : String) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var n : int ; n := binaryNo->size() ;
     var val : long ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
    dp[n - 1+1] := (if ((binaryNo->at(n - 1+1) - ('0')->char2byte()) = 0) then -1 else 1 endif) ; 
        i := n - 2 ; while i >= 0 do ( (     val := 0 ; 
     if ((binaryNo->at(i+1) - ('0')->char2byte()) = 0) then (     dp[i+1] := -1 ; 
     continue ) else skip ; 
    dp[i+1] := 2147483647 ; 
        j := i ; while j < n do ( (     val := (val * 2) + (binaryNo->at(j+1) - ('0')->char2byte())->oclAsType(long) ; 
     if (isPowerOf(val, 4) or isPowerOf(val, 6)) then (     if (j = n - 1) then (     dp[i+1] := 1 ) else (     if (dp[j + 1+1] /= -1) then     dp[i+1] := Set{dp[i+1], dp[j + 1+1] + 1}->min() ; else skip ) ) else skip )  ;     j := j + 1 ) ; 
    if (dp[i+1] = 2147483647) then     dp[i+1] := -1 ; else skip ; 
 )  ;     i := i - 1 ) ; 
    return dp[0+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var binaryNo : String ; binaryNo := "100110110" ;
     OclFile["System.out"].println(numberOfPartitions(binaryNo)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class FoxAndSnack {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int row=in.nextInt();
    int cal=in.nextInt();
    char[][] snake=new char[row][cal];
    for(int d=0 ; d<row ; d++){
      for(int o=0 ; o<cal ; o++){
        if(d % 2==0){
          snake[d][o]='#' ;
        }
        else if((d/2)% 2==0){
          if(o==cal-1){
            snake[d][o]='#' ;
          }
          else {
            snake[d][o]='.' ;
          }
        }
        else if((d/2)% 2==1){
          if(o==0){
            snake[d][o]='#' ;
          }
          else {
            snake[d][o]='.' ;
          }
        }
      }
    }
    for(int d=0 ; d<row ; d++){
      for(int o=0 ; o<cal ; o++){
        System.out.print(snake[d][o]);
      }
      System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class FoxAndSnack {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var row : int ; row := in.getCurrent()->toInteger() ;
    var cal : int ; cal := in.getCurrent()->toInteger() ;
    var snake : Sequence(Sequence(String)) ; snake := Integer.subrange(1,row)->collect(Integer.subrange(1,cal)->collect(0)) ;
        var d : int ; d := 0 ; while d < row do ( (         var o : int ; o := 0 ; while o < cal do ( (     if (d mod 2 = 0) then (     snake[d+1][o+1] := '#' ) else     if ((d / 2) mod 2 = 0) then (     if (o = cal - 1) then (     snake[d+1][o+1] := '#' ) else (     snake[d+1][o+1] := '.' ) ) else     if ((d / 2) mod 2 = 1) then (     if (o = 0) then (     snake[d+1][o+1] := '#' ) else (     snake[d+1][o+1] := '.' ) ) else skip ; ;  )  ;     o := o + 1 ) )  ;     d := d + 1 ) ; 
        var d : int ; d := 0 ; while d < row do ( (         var o : int ; o := 0 ; while o < cal do ( (     OclFile["System.out"].print(snake[d+1][o+1]) )  ;     o := o + 1 ) ; 
     OclFile["System.out"].println("") )  ;     d := d + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    scan.nextLine();
    String s1=scan.nextLine();
    String s2=scan.nextLine();
    char arr[]=s1.toCharArray();
    if(N==1){
      System.out.println("3");
      return ;
    }
    if(N==2){
      System.out.println("6");
      return ;
    }
    long result=1 ;
    boolean horizon=true ;
    int i=0 ;
    if(arr[0]==arr[1]){
      horizon=true ;
      result=6 ;
      i=2 ;
    }
    else {
      horizon=false ;
      result=3 ;
      i=1 ;
    }
    while(i<N-1){
      if(arr[i]==arr[i+1]){
        if(horizon)result*=3 ;
        else result*=2 ;
        horizon=true ;
        i+=2 ;
      }
      else {
        if(horizon){
        }
        else result*=2 ;
        i++;
        horizon=false ;
        if(i==N-1)result*=2 ;
      }
    }
    long res=result % 1000000007 ;
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    skip ; 
    var s1 : String ; s1 := scan.nextLine() ;
    var s2 : String ; s2 := scan.nextLine() ;
    var arr : Sequence(String) ; arr := s1->characters() ;
    if (N = 1) then (     OclFile["System.out"].println("3") ; 
     return ) else skip ; 
    if (N = 2) then (     OclFile["System.out"].println("6") ; 
     return ) else skip ; 
    var result : long ; result := 1 ;
    var horizon : boolean ; horizon := true ;
    var i : int ; i := 0 ;
    if (arr[0+1] = arr[1+1]) then (     horizon := true ; 
     result := 6 ; 
     i := 2 ) else (     horizon := false ; 
     result := 3 ; 
     i := 1 ) ;  
    while (i < N - 1) do (     if (arr[i+1] = arr[i + 1+1]) then (     if (horizon) then     result := result*(3) else     result := result*(2) ; ;  
     horizon := true ; 
     i := i+(2) ) else (     if (horizon) then skip else     result := result*(2) ; ;  
     i := i + 1 ; 
     horizon := false ; 
     if (i = N - 1) then     result := result*(2) ; else skip ) ) ; 
    var res : long ; res := result mod 1000000007 ;
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class CP9 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n1=sc.nextInt(),n2=sc.nextInt();
    boolean f=true ;
    for(int i=1 ; i<=n1 ; i++){
      for(int j=1 ; j<=n2 ; j++){
        if(i % 2==0){
          if((i % 4!=0)&& j==n2){
            System.out.print("#");
          }
          else if((i % 4==0)&& j==1){
            System.out.print("#");
          }
          else {
            System.out.print(".");
          }
        }
        else {
          System.out.print("#");
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CP9 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n1 : int ; n1 := sc.getCurrent()->toInteger() ;
    var n2 : int ; n2 := sc.getCurrent()->toInteger() ;
     var f : boolean ; f := true ;
         var i : int ; i := 1 ; while i <= n1 do ( (         var j : int ; j := 1 ; while j <= n2 do ( (     if (i mod 2 = 0) then (     if ((i mod 4 /= 0) & j = n2) then (     OclFile["System.out"].print("#") ) else     if ((i mod 4 = 0) & j = 1) then (     OclFile["System.out"].print("#") ) else (     OclFile["System.out"].print(".") ) ;  ) else (     OclFile["System.out"].print("#") ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class demo1 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    char[][] arr=new char[n][m];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        arr[i][j]='.' ;
      }
    }
    int s=1 ;
    int x=3 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(i % 2==0){
          arr[i][j]='#' ;
        }
        else if(i==s){
          arr[i][m-1]='#' ;
          s+=4 ;
        }
        else if(i==x){
          arr[i][0]='#' ;
          x+=4 ;
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        System.out.print(arr[i][j]);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class demo1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(String)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     arr[i+1][j+1] := '.' )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var s : int ; s := 1 ;
    var x : int ; x := 3 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (i mod 2 = 0) then (     arr[i+1][j+1] := '#' ) else     if (i = s) then (     arr[i+1][m - 1+1] := '#' ; 
     s := s+(4) ) else     if (i = x) then (     arr[i+1][0+1] := '#' ; 
     x := x+(4) ) else skip ; ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     OclFile["System.out"].print(arr[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class jjj {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    for(int i=1 ; i<=n ; i++){
      char c=i % 2==0 ? '.' : '#' ;
      for(int j=1 ; j<=m ; j++){
        if(c=='.' && i % 4==0 && j==1){
          System.out.print('#');
          continue ;
        }
        else if(c=='.' && j==m && i % 4!=0){
          System.out.print('#');
          break ;
        }
        System.out.print(c);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class jjj {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= n do ( (     var c : String ; c := if i mod 2 = 0 then '.' else '#' endif ;
         var j : int ; j := 1 ; while j <= m do ( (     if (c = '.' & i mod 4 = 0 & j = 1) then (     OclFile["System.out"].print('#') ; 
     continue ) else     if (c = '.' & j = m & i mod 4 /= 0) then (     OclFile["System.out"].print('#') ; 
     break ) else skip ; ;  
     OclFile["System.out"].print(c) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int second=1 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=m ; j++){
        if(i % 2==1){
          System.out.print("#");
        }
        else {
          if(second==1){
            if(j==m){
              System.out.print("#");
            }
            else {
              System.out.print(".");
            }
          }
          else {
            if(j==1){
              System.out.print("#");
            }
            else {
              System.out.print(".");
            }
          }
        }
      }
      System.out.println();
      if(i % 2==0){
        if(second==0){
          second=1 ;
        }
        else {
          second=0 ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var second : int ; second := 1 ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= m do ( (     if (i mod 2 = 1) then (     OclFile["System.out"].print("#") ) else (     if (second = 1) then (     if (j = m) then (     OclFile["System.out"].print("#") ) else (     OclFile["System.out"].print(".") ) ) else (     if (j = 1) then (     OclFile["System.out"].print("#") ) else (     OclFile["System.out"].print(".") ) ) ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() ; 
     if (i mod 2 = 0) then (     if (second = 0) then (     second := 1 ) else (     second := 0 ) ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class cup {
  public static void main(String[] args){
    int i ;
    Scanner sc=new Scanner(System.in);
    String str,s ;
    str=sc.nextLine();
    float n=(float)str.length()/20 ;
    int r=(int)Math.ceil(n);
    float m=(float)str.length()/r ;
    int c=(int)Math.ceil(m),j=0,k=c ;
    System.out.println(r+" "+c);
    int rem=r-((r*c)-str.length());
    for(i=0 ; i<r ; i++){
      if(i>=rem && i!=r-1)k--;
      if(i>=rem+1)j--;
      s=str.substring(j,k);
      while(s.length()<c)s+="*" ;
      System.out.println(s);
      j+=c ;
      if(k+c>str.length())k=str.length();
      else k+=c ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cup {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var str : String ;
    var s : String ;
    str := sc.nextLine() ; 
    var n : double ; n := str->size()->oclAsType(double) / 20 ;
    var r : int ; r := (n)->ceil()->oclAsType(int) ;
    var m : double ; m := str->size()->oclAsType(double) / r ;
    var c : int ; c := (m)->ceil()->oclAsType(int) ;
    var j : int ; j := 0 ;
    var k : int ; k := c ;
    OclFile["System.out"].println(r + " " + c) ; 
    var rem : int ; rem := r - ((r * c) - str->size()) ;
        i := 0 ; while i < r do ( (     if (i >= rem & i /= r - 1) then     k := k - 1 ; else skip ; 
     if (i >= rem + 1) then     j := j - 1 ; else skip ; 
    s := str.subrange(j+1,k) ; 
    while (s->size() < c) do     s := s+("*") ; ; 
    OclFile["System.out"].println(s) ; 
    j := j+(c) ; 
    if (k + c > str->size()) then     k := str->size() else     k := k+(c) ; ;  
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class H {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    double l=s.length();
    int a=(int)Math.ceil(l/20);
    int b=(int)Math.ceil(l/a);
    int p=a*b-(int)l ;
    int q=0 ;
    System.out.println(a+" "+b);
    for(int i=0 ; i<a ; i++){
      if(p>0){
        System.out.print("*");
        p--;
        for(int j=0 ; j<b-1 ; j++){
          System.out.print(s.charAt(q));
          q++;
        }
      }
      else {
        for(int j=0 ; j<b ; j++){
          System.out.print(s.charAt(q));
          q++;
        }
      }
      System.out.println();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class H {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var l : double ; l := s->size() ;
    var a : int ; a := (l / 20)->ceil()->oclAsType(int) ;
    var b : int ; b := (l / a)->ceil()->oclAsType(int) ;
    var p : int ; p := a * b - (l)->char2byte() ;
    var q : int ; q := 0 ;
    OclFile["System.out"].println(a + " " + b) ; 
        var i : int ; i := 0 ; while i < a do ( (     if (p > 0) then (     OclFile["System.out"].print("*") ; 
     p := p - 1 ; 
         var j : int ; j := 0 ; while j < b - 1 do ( (     OclFile["System.out"].print(s->at(q+1)) ; 
     q := q + 1 )  ;     j := j + 1 ) ) else (         var j : int ; j := 0 ; while j < b do ( (     OclFile["System.out"].print(s->at(q+1)) ; 
     q := q + 1 )  ;     j := j + 1 ) ) ;  
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findCountOfPairs(int a,int b,int n){
    int ans=0 ;
    for(int i=1 ; i<=a ; i++){
      ans+=b/n ;
      ans+=(i % n+b % n)>=n ? 1 : 0 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int a=5,b=13,n=3 ;
    System.out.println(findCountOfPairs(a,b,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findCountOfPairs( a : int, b : int, n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i <= a do ( (     ans := ans+(b / n) ; 
     ans := ans+(if (i mod n + b mod n) >= n then 1 else 0 endif) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 5 ;
    var b : int ; b := 13 ;
    var n : int ; n := 3 ;
     OclFile["System.out"].println(findCountOfPairs(a, b, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskD solver=new TaskD();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskD {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt(),h=in.nextInt();
      TaskD.Weapon[] ws=new TaskD.Weapon[n];
      int maxA=-1 ;
      for(int i=0 ; i<n ; i++){
        TaskD.Weapon w=new TaskD.Weapon(in.nextInt(),in.nextInt());
        ws[i]=w ;
        maxA=Math.max(maxA,w.a);
      }
      Arrays.sort(ws);
      int res=0 ;
      for(int i=0 ; i<n ; i++){
        if(h<=0){
          out.println(res);
          return ;
        }
        if(ws[i] .b<=maxA){
          break ;
        }
        h-=ws[i] .b ;
++res ;
      }
      if(h<=0){
        out.println(res);
        return ;
      }
      res+=(int)Math.ceil((h*1.0)/maxA);
      out.println(res);
    }
    static class Weapon implements Comparable<TaskD.Weapon>{
      int a ;
      int b ;
      public Weapon(int a,int b){
        this.a=a ;
        this.b=b ;
      }
      public int compareTo(TaskD.Weapon o){
        if(b==o.b)return-Integer.compare(a,o.a);
        return-Integer.compare(b,o.b);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskD ; solver := TaskD.newTaskD() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskD {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
    var h : int ; h := in.getCurrent()->toInteger() ;
     var ws : Sequence(Weapon) ; ws := Integer.subrange(1,n)->collect(null) ;
    var maxA : int ; maxA := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var w : Weapon ; w := Weapon.newWeapon(in.getCurrent()->toInteger(), in.getCurrent()->toInteger()) ;
     ws[i+1] := w ; 
     maxA := Set{maxA, w.a}->max() )  ;     i := i + 1 ) ; 
    ws := ws->sort() ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (h <= 0) then (     skip ; 
     return ) else skip ; 
     if (ws[i+1].b <= maxA) then (     break ) else skip ; 
     h := h-(ws[i+1].b) ; 
     res := res + 1 )  ;     i := i + 1 ) ; 
    if (h <= 0) then (     skip ; 
     return ) else skip ; 
    res := res+(((h * 1.0) / maxA)->ceil()->oclAsType(int)) ; 
    skip ; 
 );
  static class Weapon implements Comparable<Weapon> {
   attribute a : int;
   attribute b : int;
   static operation newWeapon( a : int, b : int) : Weapon
  pre: true
  post: true
  activity:
  ( var self : Weapon ;
    self := createWeapon();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
   operation compareTo( o : Weapon) : int
  pre: true
  post: true
  activity: (     if (b = o.b) then     return -compare(a, o.a) else skip ; 
     return -compare(b, o.b) );
}
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int N ;
  public static void main(String[] args){
    N=sc.nextInt();
    long[] A=new long[N];
    long sum=0 ;
    long min=Long.MAX_VALUE ;
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextLong();
      sum+=A[i];
      min=Math.min(min,A[i]);
    }
    if(N % 2==1){
      System.out.println(sum % 2==1 ? "First" : "Second");
    }
    else {
      if(min % 2==1){
        System.out.println("First");
      }
      else {
        System.out.println(sum % 2==1 ? "First" : "Second");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
    var sum : long ; sum := 0 ;
    var min : long ; min := "9223372036854775807"->toLong() ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toLong() ; 
     sum := sum+(A[i+1]) ; 
     min := Set{min, A[i+1]}->min() )  ;     i := i + 1 ) ; 
    if (N mod 2 = 1) then (     OclFile["System.out"].println(if sum mod 2 = 1 then "First" else "Second" endif) ) else (     if (min mod 2 = 1) then (     OclFile["System.out"].println("First") ) else (     OclFile["System.out"].println(if sum mod 2 = 1 then "First" else "Second" endif) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void powerSet(String str,int index,String curr){
    int n=str.length();
    if(index==n){
      return ;
    }
    System.out.println(curr);
    for(int i=index+1 ; i<n ; i++){
      curr+=str.charAt(i);
      powerSet(str,i,curr);
      curr=curr.substring(0,curr.length()-1);
    }
  }
  public static void main(String[] args){
    String str="abc" ;
    int index=-1 ;
    String curr="" ;
    powerSet(str,index,curr);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation powerSet( str : String, index : int, curr : String) : void
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     if (index = n) then (     return ) else skip ; 
     OclFile["System.out"].println(curr) ; 
         var i : int ; i := index + 1 ; while i < n do ( (     curr := curr+(str->at(i+1)) ; 
     execute powerSet(str, i, curr) ; 
     curr := curr.subrange(0+1,curr->size() - 1) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abc" ;
     var index : int ; index := -1 ;
     var curr : String ; curr := "" ;
     execute powerSet(str, index, curr) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.LinkedList ;
import java.util.ListIterator ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      final int a=sc.nextInt();
      final int b=sc.nextInt();
      final int c=sc.nextInt();
      final int d=sc.nextInt();
      final int e=sc.nextInt();
      if(a==0 && b==0 && c==0 && d==0 && e==0){
        break ;
      }
      final int na=sc.nextInt();
      final int nb=sc.nextInt();
      final int nc=sc.nextInt();
      final int sum=na+nb+nc ;
      final int full=na*a+nb*b+nc*c ;
      int min=full ;
      for(int inc=1 ; inc<=sum ; inc++){
        int rest=inc ;
        int cur=full ;
        final int c_c=Math.min(nc,rest);
        cur-=c_c*c ;
        if(inc<d){
          cur+=d*e ;
        }
        else {
          cur+=c_c*e ;
        }
        rest=Math.max(0,rest-c_c);
        final int b_c=Math.min(nb,rest);
        cur-=b_c*b ;
        if(inc>=d){
          cur+=b_c*e ;
        }
        rest=Math.max(0,rest-b_c);
        final int a_c=Math.min(na,rest);
        cur-=a_c*a ;
        if(inc>=d){
          cur+=a_c*e ;
        }
        rest=Math.max(0,rest-a_c);
        min=Math.min(min,cur);
      }
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var e : int ; e := sc.getCurrent()->toInteger() ;
    if (a = 0 & b = 0 & c = 0 & d = 0 & e = 0) then (     break ) else skip ; 
    var na : int ; na := sc.getCurrent()->toInteger() ;
    var nb : int ; nb := sc.getCurrent()->toInteger() ;
    var nc : int ; nc := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := na + nb + nc ;
    var full : int ; full := na * a + nb * b + nc * c ;
    var min : int ; min := full ;
        var inc : int ; inc := 1 ; while inc <= sum do ( (     var rest : int ; rest := inc ;
     var cur : int ; cur := full ;
    var c_c : int ; c_c := Set{nc, rest}->min() ;
    cur := cur-(c_c * c) ; 
    if (inc < d) then (     cur := cur+(d * e) ) else (     cur := cur+(c_c * e) ) ;  
    rest := Set{0, rest - c_c}->max() ; 
    var b_c : int ; b_c := Set{nb, rest}->min() ;
    cur := cur-(b_c * b) ; 
    if (inc >= d) then (     cur := cur+(b_c * e) ) else skip ; 
    rest := Set{0, rest - b_c}->max() ; 
    var a_c : int ; a_c := Set{na, rest}->min() ;
    cur := cur-(a_c * a) ; 
    if (inc >= d) then (     cur := cur+(a_c * e) ) else skip ; 
    rest := Set{0, rest - a_c}->max() ; 
    min := Set{min, cur}->min() ; 
 )  ;     inc := inc + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int area=a*b ;
    int length=2*a+2*b ;
    System.out.println(area+" "+length);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var area : int ; area := a * b ;
    var length : int ; length := 2 * a + 2 * b ;
    OclFile["System.out"].println(area + " " + length) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      String a=in.next();
      int n=a.length();
      char c[]=new char[n];
      for(int i=0 ; i<n ; i++){
        c[i]=a.charAt(i);
      }
      Arrays.sort(c);
      int s=1 ;
      for(int i=0 ; i<n-1 ; i++){
        if(c[i]!=c[i+1])s++;
      }
      int temp=0 ;
      int k=0 ;
      int d[]=new int[s];
      if(s==1 || s>4)temp=0 ;
      else if(s==2){
        for(int i=0 ; i<n-1 ; i++){
          if(c[i]==c[i+1])d[k]++;
          else k++;
        }
        if(d[0]>=1 && d[1]>=1)temp=1 ;
      }
      else if(s==3){
        for(int i=0 ; i<n-1 ; i++){
          if(c[i]==c[i+1])d[k]++;
          else k++;
        }
        for(int i=0 ; i<3 ; i++){
          if(d[i]>=1){
            temp=1 ;
            break ;
          }
        }
      }
      else if(s==4)temp=1 ;
      if(temp==1)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var a : String ; a := in.getCurrent() ;
     var n : int ; n := a->size() ;
    var c : Sequence(String) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := a->at(i+1) )  ;     i := i + 1 ) ; 
    c := c->sort() ; 
    var s : int ; s := 1 ;
        var i : int ; i := 0 ; while i < (n)->char2byte() - 1 do ( (     if (c[i+1] /= c[i + 1+1]) then     s := s + 1 ; else skip )  ;     i := i + 1 ) ; 
    var temp : int ; temp := 0 ;
    var k : int ; k := 0 ;
    var d : Sequence(int) ; d := Integer.subrange(1,s)->collect(0) ;
    if (s = 1 or s > 4) then     temp := 0 else     if (s = 2) then (         var i : int ; i := 0 ; while i < (n)->char2byte() - 1 do ( (     if (c[i+1] = c[i + 1+1]) then     d[k+1] := d[k+1] + 1 ; else     k := k + 1 ; )  ;     i := i + 1 ) ; 
     if (d[0+1] >= 1 & d[1+1] >= 1) then     temp := 1 ; else skip ) else     if (s = 3) then (         var i : int ; i := 0 ; while i < (n)->char2byte() - 1 do ( (     if (c[i+1] = c[i + 1+1]) then     d[k+1] := d[k+1] + 1 ; else     k := k + 1 ; )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < 3 do ( (     if (d[i+1] >= 1) then (     temp := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ) else     if (s = 4) then     temp := 1 ; else skip ; ;  ;  ;  
    if (temp = 1) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.List ;
public class NotSimplyBeatifulStrings {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    String s=br.readLine();
    if(s.length()<4){
      pr.println("No");
      return ;
    }
    int[] count=new int[26];
    for(int i=0 ; i<s.length(); i++){
      char c=s.charAt(i);
      count[c-'a']++;
    }
    List<Integer>list=new ArrayList<>();
    for(int i : count){
      if(i!=0){
        list.add(i);
      }
    }
    if(list.size()>4 || list.size()==1){
      pr.println("No");
      return ;
    }
    if(list.size()==4){
      pr.println("Yes");
      return ;
    }
    if(list.size()==2){
      if(list.get(0)>=2 && list.get(1)>=2){
        pr.println("Yes");
        return ;
      }
      pr.println("No");
      return ;
    }
    if(list.size()==3){
      pr.println("Yes");
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NotSimplyBeatifulStrings {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := br.readLine() ;
     if (s->size() < 4) then (     skip ; 
     return ) else skip ; 
    var count : Sequence(int) ; count := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var c : String ; c := s->at(i+1) ;
     count[(c)->char2byte() - ('a')->char2byte()+1] := count[(c)->char2byte() - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    var list : Sequence(int) ; list := Sequence{} ;
    for (i : count) do ( (     if (i /= 0) then (     list := list->including(i) ) else skip )  ) ; 
    if (list->size() > 4 or list->size() = 1) then (     skip ; 
     return ) else skip ; 
    if (list->size() = 4) then (     skip ; 
     return ) else skip ; 
    if (list->size() = 2) then (     if (list->at(0+1) >= 2 & list->at(1+1) >= 2) then (     skip ; 
     return ) else skip ; 
     skip ; 
     return ) else skip ; 
    if (list->size() = 3) then (     skip ; 
     return ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static class P implements Comparable<P>{
    int x,y ;
    P(int x,int y){
      this.x=x ;
      this.y=y ;
    }
    @ Override public int compareTo(P o2){
      int f=Integer.compare(this.x,o2.x);
      if(f==0){
        return Integer.compare(this.y,o2.y);
      }
      return f ;
    }
    public String toString(){
      return this.x+" "+this.y ;
    }
  }
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      P[] a=new P[n];
      for(int i=0 ; i<n ; i++){
        a[i]=new P(sc.nextInt(),sc.nextInt());
      }
      Arrays.sort(a);
      for(int i=0 ; i<n ; i++){
        System.out.println(a[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class P implements Comparable<P> {
   attribute x : int;
   static operation newP( x : int, y : int) : P
  pre: true
  post: true
  activity:
  ( var self : P ;
    self := createP();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
      operation compareTo( o2 : P) : int
  pre: true
  post: true
  activity: (     var f : int ; f := compare(self.x, o2.x) ;
     if (f = 0) then (     return compare(self.y, o2.y) ) else skip ; 
     return f );
   operation toString() : String
  pre: true
  post: true
  activity: (     return self.x + " " + self.y );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(P) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := P.newP(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(a[i+1]) )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  static Scanner scInputData=new Scanner(System.in);
  static ArrayList<Coordinate>arrCoordinate=new ArrayList<Coordinate>();
  public static void main(String[] args){
    getCoordinate();
    compareCoordinate();
    putResult();
  }
  private static void putResult(){
    for(Coordinate crd : arrCoordinate){
      System.out.println(crd.getX()+" "+crd.getY());
    }
  }
  private static void compareCoordinate(){
    Collections.sort(arrCoordinate,new Comparator<Coordinate>(){
      public int compare(Coordinate crd1,Coordinate crd2){
        return Integer.compare(crd1.getX(),crd2.getX());
      }
    }
.thenComparing(new Comparator<Coordinate>(){
      public int compare(Coordinate crd1,Coordinate crd2){
        return Integer.compare(crd1.getY(),crd2.getY());
      }
    }
));
  }
  private static void getCoordinate(){
    int iCoordinateNum=0 ;
    iCoordinateNum=scInputData.nextInt();
    while(arrCoordinate.size()<iCoordinateNum){
      Coordinate crd=new Coordinate(scInputData.nextInt(),scInputData.nextInt());
      arrCoordinate.add(crd);
    }
  }
  static class Coordinate {
    int x,y ;
    public Coordinate(int x,int y){
      this.x=x ;
      this.y=y ;
    }
    int getX(){
      return x ;
    }
    int getY(){
      return y ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scInputData : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute arrCoordinate : Sequence(Coordinate) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute getCoordinate() ; 
     execute compareCoordinate() ; 
     execute putResult() );
  static   operation putResult() : void
  pre: true
  post: true
  activity: (     for (crd : arrCoordinate) do ( (     OclFile["System.out"].println(crd.getX() + " " + crd.getY()) )  ) );
  static   operation compareCoordinate() : void
  pre: true
  post: true
  activity: (     arrCoordinate, OclComparator<Coordinate>.newOclComparator().thenComparing(OclComparator<Coordinate>.newOclComparator()) := arrCoordinate, OclComparator<Coordinate>.newOclComparator().thenComparing(OclComparator<Coordinate>.newOclComparator())->sort() );
  static   operation getCoordinate() : void
  pre: true
  post: true
  activity: (     var iCoordinateNum : int ; iCoordinateNum := 0 ;
     iCoordinateNum := scInputData.getCurrent()->toInteger() ; 
     while (arrCoordinate->size() < iCoordinateNum) do (     var crd : Coordinate ; crd := Coordinate.newCoordinate(scInputData.getCurrent()->toInteger(), scInputData.getCurrent()->toInteger()) ;
     arrCoordinate := arrCoordinate->including(crd) ) );
  static class Coordinate {
   attribute x : int;
   static operation newCoordinate( x : int, y : int) : Coordinate
  pre: true
  post: true
  activity:
  ( var self : Coordinate ;
    self := createCoordinate();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation getX() : int
  pre: true
  post: true
  activity: (     return x );
   operation getY() : int
  pre: true
  post: true
  activity: (     return y );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    Points[] a=new Points[n];
    for(int i=0 ; i<n ; i++)a[i]=new Points();
    for(int i=0 ; i<n ; i++){
      str=br.readLine().split(" ");
      a[i] .x=Integer.parseInt(str[0]);
      a[i] .y=Integer.parseInt(str[1]);
    }
    Arrays.sort(a);
    for(int i=0 ; i<n ; i++)System.out.println(a[i] .x+" "+a[i] .y);
  }
}
class Points implements Comparable<Points>{
  int x,y ;
  @ Override public int compareTo(Points b){
    return(this.x==b.x ? this.y-b.y : this.x-b.x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var a : Sequence(Points) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := Points.newPoints() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     str := br.readLine()->split(" ") ; 
     a[i+1].x := (str[0+1])->toInteger() ; 
     a[i+1].y := (str[1+1])->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].println(a[i+1].x + " " + a[i+1].y) ;  ;     i := i + 1 ) ; 
 );
}
class Points implements Comparable<Points> {
   attribute x : int;
      operation compareTo( b : Points) : int
  pre: true
  post: true
  activity: (     return (if self.x = b.x then self.y - b.y else self.x - b.x endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Digits {
  static long firstkdigits(int n,int k){
    long product=1 ;
    for(int i=0 ; i<n ; i++)product*=n ;
    while((int)(product/Math.pow(10,k))!=0)product=product/10 ;
    return product ;
  }
  public static void main(String[] args){
    int n=15 ;
    int k=4 ;
    System.out.println(firstkdigits(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class Digits {
  static   operation firstkdigits( n : int, k : int) : long
  pre: true
  post: true
  activity: (     var product : long ; product := 1 ;
         var i : int ; i := 0 ; while i < n do (     product := product*(n) ;  ;     i := i + 1 ) ; 
     while ((product / 10->pow(k))->oclAsType(int) /= 0) do     product := product / 10 ; ; 
     return product );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     var k : int ; k := 4 ;
     OclFile["System.out"].println(firstkdigits(n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    List<Data>d=new ArrayList<Data>();
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      long x=sc.nextLong();
      long y=sc.nextLong();
      d.add(new Data(x,y));
    }
    Collections.sort(d);
    Iterator<Data>it=d.iterator();
    while(it.hasNext()){
      Data a=it.next();
      a.print();
    }
  }
}
class Data implements Comparable<Data>{
  long x ;
  long y ;
  Data(long x,long y){
    this.x=x ;
    this.y=y ;
  }
  public int compareTo(Data d){
    if(x<d.x)return-1 ;
    else if(x==d.x){
      if(y<d.y)return-1 ;
      else return 1 ;
    }
    else return 1 ;
  }
  public void print(){
    System.out.println(x+" "+y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : Sequence(Data) ; d := Sequence{} ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var x : long ; x := sc.getCurrent()->toLong() ;
     var y : long ; y := sc.getCurrent()->toLong() ;
     d := d->including(Data.newData(x, y)) )  ;     i := i + 1 ) ; 
    d := d->sort() ; 
    var it : OclIterator ; it := d->iterator() ;
    while (it.hasNext()) do (     var a : Data ; a := it.next() ;
     a.print() ) ; 
 );
}
class Data implements Comparable<Data> {
   attribute x : long;
   attribute y : long;
   static operation newData( x : long, y : long) : Data
  pre: true
  post: true
  activity:
  ( var self : Data ;
    self := createData();
    self.initialise(x, y);
    return self );
  operation initialise( x : long, y : long) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation compareTo( d : Data) : int
  pre: true
  post: true
  activity: (     if (x < d.x) then     return -1 else     if (x = d.x) then (     if (y < d.y) then     return -1 else     return 1 ) else     return 1 ;  );
   operation print() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(x + " " + y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
class Pairs {
  private int x ;
  private int y ;
  public Pairs(int xx,int yy){
    x=xx ;
    y=yy ;
  }
  public int getX(){
    return x ;
  }
  public int getY(){
    return y ;
  }
}
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      Pairs[] array=new Pairs[n];
      for(int i=0 ; i<n ; i++){
        int xx=sc.nextInt();
        int yy=sc.nextInt();
        array[i]=new Pairs(xx,yy);
      }
      Arrays.sort(array,new Comparator<Pairs>(){
        @ Override public int compare(Pairs p0,Pairs p1){
          if(p0.getX()>p1.getX())return 1 ;
          else if(p0.getX()<p1.getX())return-1 ;
          else {
            if(p0.getY()>p1.getY())return 1 ;
            else return-1 ;
          }
        }
      }
);
      for(int i=0 ; i<n ; i++){
        System.out.println(array[i] .getX()+" "+array[i] .getY());
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Pairs {
   attribute x : int;
   attribute y : int;
   static operation newPairs( xx : int, yy : int) : Pairs
  pre: true
  post: true
  activity:
  ( var self : Pairs ;
    self := createPairs();
    self.initialise(xx, yy);
    return self );
  operation initialise( xx : int, yy : int) : void
  pre: true  post: true
  activity: (     x := xx ; 
     y := yy );
   operation getX() : int
  pre: true
  post: true
  activity: (     return x );
   operation getY() : int
  pre: true
  post: true
  activity: (     return y );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var array : Sequence(Pairs) ; array := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var xx : int ; xx := sc.getCurrent()->toInteger() ;
     var yy : int ; yy := sc.getCurrent()->toInteger() ;
     array[i+1] := Pairs.newPairs(xx, yy) )  ;     i := i + 1 ) ; 
    array := OclComparator.sortWith(array, OclComparator<Pairs>.newOclComparator()) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(array[i+1].getX() + " " + array[i+1].getY()) )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.StringTokenizer ;
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    int T=fs.nextInt();
    for(int i=0 ; i<T ; i++){
      long arr[]=new long[3];
      arr[0]=fs.nextLong();
      arr[1]=fs.nextLong();
      arr[2]=fs.nextLong();
      Arrays.sort(arr);
      long ans=arr[0]+arr[1]+arr[2];
      System.out.println(ans-1);
    }
  }
  static void sort(int[] a){
    ArrayList<Integer>l=new ArrayList<>();
    for(int i : a)l.add(i);
    Collections.sort(l);
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var T : int ; T := fs.nextInt() ;
         var i : int ; i := 0 ; while i < T do ( (     var arr : Sequence(long) ; arr := Integer.subrange(1,3)->collect(0) ;
     arr[0+1] := fs.nextLong() ; 
    arr[1+1] := fs.nextLong() ; 
    arr[2+1] := fs.nextLong() ; 
    arr := arr->sort() ; 
    var ans : long ; ans := arr[0+1] + arr[1+1] + arr[2+1] ;
    OclFile["System.out"].println(ans - 1) ; 
 )  ;     i := i + 1 ) );
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l := l->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class Solution {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static int GCD(int a,int b){
    if(b==0)return a ;
    return GCD(b % a,a);
  }
  public static void main(String[] args){
    FastReader s=new FastReader();
    int t=s.nextInt();
    while(t-->0){
      int a=s.nextInt();
      int b=s.nextInt();
      int c=s.nextInt();
      int t1=Math.max(a,Math.max(b,c));
      int t2=a+b+c-1 ;
      System.out.println(Math.max(t1,t2));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation GCD( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return GCD(b mod a, a) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : FastReader ; s := FastReader.newFastReader() ;
     var t : int ; t := s.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := s.nextInt() ;
     var b : int ; b := s.nextInt() ;
    var c : int ; c := s.nextInt() ;
    var t1 : int ; t1 := Set{a, Set{b, c}->max()}->max() ;
    var t2 : int ; t2 := a + b + c - 1 ;
    OclFile["System.out"].println(Set{t1, t2}->max()) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args){
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(isr);
    int a,b ;
    try {
      String str=br.readLine();
      String[] strAry=str.split(" ");
      a=Integer.parseInt(strAry[0]);
      b=Integer.parseInt(strAry[1]);
    }
    catch(Exception e){
      a=0 ;
      b=0 ;
    }
    System.out.println(a*b+" "+(2*a+2*b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
    var a : int ;
    var b : int ;
    try (     var str : String ; str := br.readLine() ;
     var strAry : Sequence(String) ; strAry := str->split(" ") ;
     a := (strAry[0+1])->toInteger() ; 
     b := (strAry[1+1])->toInteger() )   catch (e : ProgramException) do (     a := 0 ; 
     b := 0 )
    OclFile["System.out"].println(a * b + " " + (2 * a + 2 * b)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    int t=fs.nextInt();
    while(t-->0){
      int n=3 ;
      long ans=0,sum=0 ;
      for(int i=0 ; i<n ; i++){
        long b=fs.nextLong();
        sum+=b ;
      }
      ans=sum-1 ;
      System.out.println(ans);
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var t : int ; t := fs.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := 3 ;
     var ans : long ; ans := 0 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var b : long ; b := fs.nextLong() ;
     sum := sum+(b) )  ;     i := i + 1 ) ; 
    ans := sum - 1 ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      System.out.println(solve(a,b,c));
    }
    sc.close();
  }
  static int solve(int a,int b,int c){
    return Math.max(Math.max(a,b),c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(a, b, c)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : int, b : int, c : int) : int
  pre: true
  post: true
  activity: (     return Set{Set{a, b}->max(), c}->max() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static String allBitsSetInTheGivenRange(int n,int l,int r){
    int num=((1<<r)-1)^((1<<(l-1))-1);
    int new_num=n & num ;
    if(new_num==0)return "Yes" ;
    return "No" ;
  }
  public static void main(String[] args){
    int n=17 ;
    int l=2 ;
    int r=4 ;
    System.out.println(allBitsSetInTheGivenRange(n,l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation allBitsSetInTheGivenRange( n : int, l : int, r : int) : String
  pre: true
  post: true
  activity: (     var num : int ; num := MathLib.bitwiseXor((((1*(2->pow(r)))->oclAsType(long)) - 1),(((1*(2->pow((l - 1))))->oclAsType(long)) - 1)) ;
     var new_num : int ; new_num := MathLib.bitwiseAnd(n,num) ;
     if (new_num = 0) then     return "Yes" else skip ; 
     return "No" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 17 ;
     var l : int ; l := 2 ;
     var r : int ; r := 4 ;
     OclFile["System.out"].println(allBitsSetInTheGivenRange(n, l, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String solve(int n,char x,char y){
    int length=(int)Math.ceil(Math.log(n+2)/Math.log(2))-1 ;
    int rank=n-(1<<length)+1 ;
    String left="",right="" ;
    for(int i=length-1 ; i>=0 ; i--){
      int mask=(1<<i);
      int bit=mask & rank ;
      if(bit>0){
        left+=y ;
        right+=y ;
      }
      else {
        left+=x ;
        right+=x ;
      }
    }
    StringBuilder sb=new StringBuilder(right);
    sb.reverse();
    right=sb.toString();
    String res=left+right ;
    return res ;
  }
  public static void main(String[] args){
    int n=23 ;
    char x='4',y='5' ;
    String ans=solve(n,x,y);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( n : int, x : String, y : String) : String
  pre: true
  post: true
  activity: (     var length : int ; length := ((n + 2)->log() / (2)->log())->ceil()->oclAsType(int) - 1 ;
     var rank : int ; rank := n - ((1*(2->pow(length)))->oclAsType(long)) + 1 ;
    var left : String ; left := "" ;
    var right : String ; right := "" ;
        var i : int ; i := length - 1 ; while i >= 0 do ( (     var mask : int ; mask := ((1*(2->pow(i)))->oclAsType(long)) ;
     var bit : int ; bit := MathLib.bitwiseAnd(mask,rank) ;
     if (bit > 0) then (     left := left+(y) ; 
     right := right+(y) ) else (     left := left+(x) ; 
     right := right+(x) ) )  ;     i := i - 1 ) ; 
    var sb : String ; sb := StringLib.newString(right) ;
    sb := sb->reverse() ; 
    right := sb+"" ; 
    var res : String ; res := left + right ;
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 23 ;
     var x : String ; x := '4' ;
    var y : String ; y := '5' ;
     var ans : String ; ans := solve(n, x, y) ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.Integer.*;
import static java.lang.String.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    int[] nm={
      0,31,28,31,30,31,30,31,31,30,31,30,31 };
      String str=in.readLine(),ans="",date ;
      int i,d,m,y,mx=0,f ;
      Map<String,Integer>freq=new HashMap<String,Integer>();
      for(y=2013 ; y<=2015 ; y++){
        for(m=1 ; m<=12 ; m++){
          for(d=1 ; d<=nm[m]; d++){
            date=format("%02d-%02d-%04d",d,m,y);
            f=(str.length()-str.replace(date,"").length())/10 ;
            freq.put(date,f);
            if(freq.get(date)>mx){
              mx=freq.get(date);
              ans=date ;
            }
          }
        }
      }
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var nm : Sequence(int) ; nm := Sequence{0,31,28,31,30,31,30,31,31,30,31,30,31} ;
    var str : String ; str := in.readLine() ;
    var ans : String ; ans := "" ;
    var date : String ;
    var i : int ;
    var d : int ;
    var m : int ;
    var y : int ;
    var mx : int ; mx := 0 ;
    var f : int ;
    var freq : Map(String,int) ; freq := Map{} ;
        y := 2013 ; while y <= 2015 do ( (         m := 1 ; while m <= 12 do ( (         d := 1 ; while d <= nm[m+1] do ( (     date := format("%02d-%02d-%04d", d, m, y) ; 
     f := (str->size() - str.replace(date, "")->size()) / 10 ; 
     freq := freq->union(Map{date |-> f}) ; 
     if (freq->at(date) > mx) then (     mx := freq->at(date) ; 
     ans := date ) else skip )  ;     d := d + 1 ) )  ;     m := m + 1 ) )  ;     y := y + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args){
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
    try {
      String line ;
      while((line=r.readLine())!=null){
        int m,n ;
        m=Integer.parseInt(line.split(" ")[0]);
        n=Integer.parseInt(line.split(" ")[1]);
        if(m<n){
          int t=m ;
          m=n ;
          n=t ;
        }
        while(n!=0){
          int t=n ;
          n=m % n ;
          m=t ;
        }
        System.out.println(m);
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var line : String ;
         line := r.readLine() ;
    while ((line) /= null) do (    skip ; (     var m : int ;
    var n : int ;
     m := (line->split(" ")[0+1])->toInteger() ; 
    n := (line->split(" ")[1+1])->toInteger() ; 
    if (m < n) then (     var t : int ; t := m ;
     m := n ; 
     n := t ) else skip ; 
    while (n /= 0) do (     var t : int ; t := n ;
     n := m mod n ; 
     m := t ) ; 
    OclFile["System.out"].println(m) ; 
 ) ;     line := r.readLine() ;
 ) )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.time.LocalDate ;
import java.time.format.DateTimeFormatter ;
import java.util.HashMap ;
import java.util.LinkedList ;
import java.util.Map.Entry ;
import java.util.Scanner ;
public class Problem4 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    DateTimeFormatter f=DateTimeFormatter.ofPattern("d/MM/yyyy");
    LinkedList<String>dates=new LinkedList<String>();
    LocalDate x=LocalDate.of(2013,1,1);
    LocalDate y=LocalDate.of(2015,12,31);
    String s=sc.nextLine();
    s=s.replace("-","/");
    for(int i=10 ; i<=s.length(); i++){
      String dateIn=s.substring(i-10,i);
      try {
        LocalDate ld=LocalDate.parse(dateIn,f);
        String dateOut=ld.format(f);
        if(! dateIn.equals(dateOut)&& ! dateIn.equals("0"+dateOut)){
        }
        else if(ld.isBefore(x)|| ld.isAfter(y)){
        }
        else dates.add(dateIn);
      }
      catch(Exception e){
      }
    }
    HashMap<String,Integer>hm=new HashMap<String,Integer>();
    for(String d : dates){
      hm.put(d,hm.getOrDefault(d,0)+1);
    }
    int max=0 ;
    String doom=null ;
    for(Entry<String,Integer>entry : hm.entrySet()){
      if(entry.getValue()>max){
        max=entry.getValue();
        doom=entry.getKey();
      }
    }
    doom=doom.replace("/","-");
    System.out.println(doom);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem4 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var f : DateTimeFormatter ; f := DateTimeFormatter.ofPattern("d/MM/yyyy") ;
    var dates : Sequence(String) ; dates := Sequence{} ;
    var x : LocalDate ; x := LocalDate.of(2013, 1, 1) ;
    var y : LocalDate ; y := LocalDate.of(2015, 12, 31) ;
    var s : String ; s := sc.nextLine() ;
    s := s.replace("-", "/") ; 
        var i : int ; i := 10 ; while i <= s->size() do ( (     var dateIn : String ; dateIn := s.subrange((i)->char2byte() - 10+1,i) ;
     try (     var ld : LocalDate ; ld := LocalDate.parse(dateIn, f) ;
     var dateOut : String ; dateOut := ld.format(f) ;
     if (not(dateIn = dateOut) & not(dateIn = "0" + dateOut)) then skip else     if (ld.isBefore(x) or ld.isAfter(y)) then skip else     dates := dates->including(dateIn) ; ;  )   catch (e : ProgramException) do skip
 )  ;     i := i + 1 ) ; 
    var hm : Map(String,int) ; hm := Map{} ;
    for (d : dates) do ( (     hm := hm->union(Map{d |-> (if hm->keys()->contains(d) then hm->at(d) else 0 endif) + 1}) )  ) ; 
    var max : int ; max := 0 ;
    var doom : String ; doom := null ;
    for (entry : hm->asSet()) do ( (     if (entry.getValue() > max) then (     max := entry.getValue() ; 
     doom := entry.getKey() ) else skip )  ) ; 
    doom := doom.replace("/", "-") ; 
    OclFile["System.out"].println(doom) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] a=new int[m];
    int[] b=new int[m];
    int[] c=new int[m];
    int[] cost=new int[n];
    ArrayDeque<Integer>list=new ArrayDeque<Integer>();
    for(int i=0 ; i<m ; i++){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
      c[i]=sc.nextInt();
    }
    int k=0 ;
    int p=0 ;
    list.push(0);
    while(true){
      k=list.size();
      for(int i=0 ; i<k ; i++){
        p=list.pop();
        for(int j=0 ; j<m ; j++){
          if(p==a[j] && cost[p]+c[j]>cost[b[j] ]){
            cost[b[j] ]=cost[p]+c[j];
            list.push(b[j]);
          }
        }
      }
      if(list.size()==0)break ;
    }
    System.out.println(cost[n-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,m)->collect(0) ;
    var cost : Sequence(int) ; cost := Integer.subrange(1,n)->collect(0) ;
    var list : Sequence(int) ; list := ArrayDeque<int>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() ; 
     c[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var k : int ; k := 0 ;
    var p : int ; p := 0 ;
    list := list->append(0) ; 
    while (true) do (     k := list->size() ; 
         var i : int ; i := 0 ; while i < k do ( (     p := list->last() ;     list := list->front() ; 
         var j : int ; j := 0 ; while j < m do ( (     if (p = a[j+1] & cost[p+1] + c[j+1] > cost[b[j+1]+1]) then (     cost[b[j+1]+1] := cost[p+1] + c[j+1] ; 
     list := list->append(b[j+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (list->size() = 0) then     break else skip ) ; 
    OclFile["System.out"].println(cost[n - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  int[][] cost ;
  public void run(){
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      int n=scan.nextInt();
      int m=scan.nextInt();
      cost=new int[n][n];
      for(int i=0 ; i<n ; i++){
        Arrays.fill(cost[i],-1);
      }
      for(int i=0 ; i<n ; i++){
        cost[i][i]=0 ;
      }
      for(int i=0 ; i<m ; i++){
        cost[scan.nextInt()][scan.nextInt()]=scan.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          for(int k=0 ; k<n ; k++){
            if(!(cost[i][k]<0 || cost[j][i]<0)){
              cost[j][k]=Math.max(cost[j][k],cost[j][i]+cost[i][k]);
            }
          }
        }
      }
      System.out.println(cost[0][n-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute cost : Sequence(Sequence(int));
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var m : int ; m := scan.getCurrent()->toInteger() ;
    cost := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
        var i : int ; i := 0 ; while i < n do ( (     cost[i+1] := cost[i+1]->collect(-1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     cost[i+1][i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     cost[scan.getCurrent()->toInteger()+1][scan.getCurrent()->toInteger()+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (         var k : int ; k := 0 ; while k < n do ( (     if (not((cost[i+1][k+1] < 0 or cost[j+1][i+1] < 0))) then (     cost[j+1][k+1] := Set{cost[j+1][k+1], cost[j+1][i+1] + cost[i+1][k+1]}->max() ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cost[0+1][n - 1+1]) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.geom.*;
public class Main {
  double EPS=1.0e-08 ;
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int[][] pass=new int[n][n];
      int INF=1<<24 ;
      for(int i=0 ; i<n ; i++){
        Arrays.fill(pass[i],INF);
      }
      for(int i=0 ; i<m ; i++){
        int a=sc.nextInt();
        int b=sc.nextInt();
        int cost=sc.nextInt();
        pass[a][b]=-cost ;
      }
      for(int j=0 ; j<n ; j++){
        for(int i=0 ; i<n ; i++){
          for(int k=0 ; k<n ; k++){
            pass[i][k]=Math.min(pass[i][k],pass[i][j]+pass[j][k]);
          }
        }
      }
      System.out.println(pass[0][n-1]*-1);
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute EPS : double := 1.0e-08;
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var pass : Sequence(Sequence(int)) ; pass := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var INF : int ; INF := (1*(2->pow(24)))->oclAsType(long) ;
        var i : int ; i := 0 ; while i < n do ( (     pass[i+1] := pass[i+1]->collect(INF) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     var cost : int ; cost := sc.getCurrent()->toInteger() ;
     pass[a+1][b+1] := -cost )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (         var i : int ; i := 0 ; while i < n do ( (         var k : int ; k := 0 ; while k < n do ( (     pass[i+1][k+1] := Set{pass[i+1][k+1], pass[i+1][j+1] + pass[j+1][k+1]}->min() )  ;     k := k + 1 ) )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(pass[0+1][n - 1+1] * -1) ; 
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    int num1,num2,ans1,ans2 ;
    Scanner scan=new Scanner(System.in);
    num1=scan.nextInt();
    num2=scan.nextInt();
    ans1=num1*num2 ;
    ans2=(num1+num2)*2 ;
    System.out.println(ans1+" "+ans2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num1 : int ;
    var num2 : int ;
    var ans1 : int ;
    var ans2 : int ;
     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    num1 := scan.getCurrent()->toInteger() ; 
    num2 := scan.getCurrent()->toInteger() ; 
    ans1 := num1 * num2 ; 
    ans2 := (num1 + num2) * 2 ; 
    OclFile["System.out"].println(ans1 + " " + ans2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.util.Arrays.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  int n,m ;
  int[] mem ;
  ArrayList<E>[] g ;
  @ SuppressWarnings("unchecked")void run(){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    m=sc.nextInt();
    mem=new int[n];
    fill(mem,-1);
    g=new ArrayList[n];
    for(int i=0 ; i<n ; i++)g[i]=new ArrayList<E>();
    for(int i=0 ; i<m ; i++){
      int a=sc.nextInt(),b=sc.nextInt(),c=sc.nextInt();
      g[a] .add(new E(b,c));
    }
    System.out.println(dfs(0));
  }
  int dfs(int p){
    if(mem[p]>=0)return mem[p];
    if(p==n-1)return mem[p]=0 ;
    int max=0 ;
    for(E e : g[p]){
      max=max(max,dfs(e.to)+e.val);
    }
    return mem[p]=max ;
  }
  class E {
    int to,val ;
    E(int to,int val){
      this.to=to ;
      this.val=val ;
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   attribute n : int;
   attribute mem : Sequence(int);
   attribute g : Sequence(Sequence(E));
     operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
    mem := Integer.subrange(1,n)->collect(0) ; 
    execute fill(mem, -1) ; 
    g := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do (     g[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
     g[a+1]->excludes(E.newE(b, c)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dfs(0)) ; 
 );
   operation dfs( p : int) : int
  pre: true
  post: true
  activity: (     if (mem[p+1] >= 0) then     return mem[p+1] else skip ; 
     if (p = n - 1) then     return mem[p+1] else skip ; 
    var max : int ; max := 0 ;
    for (e : g[p+1]) do ( (     max := Set{max, dfs(e.to) + e.val}->max() )  ) ; 
    return mem[p+1] 
 );
 class E {
   attribute to : int;
   static operation newE( to : int, val : int) : E
  pre: true
  post: true
  activity:
  ( var self : E ;
    self := createE();
    self.initialise(to, val);
    return self );
  operation initialise( to : int, val : int) : void
  pre: true  post: true
  activity: (     self.to := to ; 
     self.val := val );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    final int N=sc.nextInt();
    final int M=sc.nextInt();
    final int size=N+2 ;
    int[] sum=new int[size];
    for(int i=0 ; i<M ; i++){
      final int from=sc.nextInt();
      final int to=sc.nextInt();
      sum[from]+=1 ;
      sum[to]-=1 ;
    }
    for(int i=1 ; i<size ; i++){
      sum[i]+=sum[i-1];
    }
    int ans=N+1 ;
    for(int i=0 ; i<size ; i++){
      if(sum[i]>0){
        ans+=2 ;
      }
    }
    System.out.println(ans);
    sc.close();
  }
  public static class Scanner {
    private BufferedReader br ;
    private StringTokenizer tok ;
    public Scanner(InputStream is)throws IOException {
      br=new BufferedReader(new InputStreamReader(is));
    }
    private void getLine()throws IOException {
      while(! hasNext()){
        tok=new StringTokenizer(br.readLine());
      }
    }
    private boolean hasNext(){
      return tok!=null && tok.hasMoreTokens();
    }
    public String next()throws IOException {
      getLine();
      return tok.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public void close()throws IOException {
      br.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var size : int ; size := N + 2 ;
    var sum : Sequence(int) ; sum := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     var from : int ; from := sc.getCurrent()->toInteger() ;
     var to : int ; to := sc.getCurrent()->toInteger() ;
     sum[from+1] := sum[from+1]+(1) ; 
     sum[to+1] := sum[to+1]-(1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < size do ( (     sum[i+1] := sum[i+1]+(sum[i - 1+1]) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := N + 1 ;
        var i : int ; i := 0 ; while i < size do ( (     if (sum[i+1] > 0) then (     ans := ans+(2) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute tok : OclIterator;
   static operation newScanner( is : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
   operation getLine() : void
  pre: true
  post: true
  activity: (     while (not(hasNext())) do (     tok := OclIterator.newOclIterator_String(br.readLine()) ) );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return tok /= null & tok.hasNext() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute getLine() ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigDecimal ;
import java.util.*;
public class Main {
  static int INF=2<<27 ;
  static int[] vx={
    1,0,-1,0 };
    static int[] vy={
      0,1,0,-1 };
      public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        PrintWriter out=new PrintWriter(System.out);
        int N=sc.nextInt();
        int m=sc.nextInt();
        int[] c=new int[m];
        int[] d=new int[m];
        boolean[] triple=new boolean[N+1];
        for(int i=0 ; i<m ; i++){
          c[i]=sc.nextInt();
          d[i]=sc.nextInt();
          for(int j=c[i]; j<d[i]; j++){
            triple[j]=true ;
          }
        }
        int sum=0 ;
        for(int i=0 ; i<=N ; i++){
          if(triple[i])sum+=3 ;
          else sum+=1 ;
        }
        System.out.println(sum);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute INF : int := (2*(2->pow(27)))->oclAsType(long);
  static   attribute vx : Sequence(int) := Sequence{1,0,-1,0};
  static   attribute vy : Sequence(int) := Sequence{0,1,0,-1};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var c : Sequence(int) ; c := Integer.subrange(1,m)->collect(0) ;
    var d : Sequence(int) ; d := Integer.subrange(1,m)->collect(0) ;
    var triple : Sequence(boolean) ; triple := Integer.subrange(1,N + 1)->collect(false) ;
        var i : int ; i := 0 ; while i < m do ( (     c[i+1] := sc.getCurrent()->toInteger() ; 
     d[i+1] := sc.getCurrent()->toInteger() ; 
         var j : int ; j := c[i+1] ; while j < d[i+1] do ( (     triple[j+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i <= N do ( (     if (triple[i+1]) then     sum := sum+(3) ; else     sum := sum+(1) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new C().doIt();
  }
  class C {
    int n,c ;
    ArrayList<Pair>list ;
    void doIt(){
      n=in.nextInt();
      c=in.nextInt();
      list=new ArrayList<Pair>();
      for(int i=0 ; i<c ; i++)list.add(new Pair(in.nextInt(),in.nextInt()));
      Collections.sort(list);
      int[] hyou=new int[n+1];
      for(int i=1 ; i<=n ; i++){
        hyou[i]=hyou[i-1];
        for(int s=0 ; s<c ; s++){
          if(list.get(s).a==i)hyou[i]+=1 ;
          else if(list.get(s).b==i)hyou[i]-=1 ;
        }
      }
      int memo=-1 ;
      for(int i=1 ; i<=n ; i++){
        if(hyou[i]>0){
          if(memo==-1)memo=i ;
          hyou[i]=-1 ;
        }
        else {
          if(hyou[i-1]==-1){
            hyou[i]=memo ;
            memo=-1 ;
          }
        }
      }
      int cnt=0 ;
      for(int i=0 ; i<=n ; i++){
        if(hyou[i]>0){
          cnt+=(i-hyou[i])*2 ;
        }
        cnt++;
      }
      System.out.println(cnt);
    }
    class Pair implements Comparable<Pair>{
      int a,b ;
      public Pair(int a,int b){
        this.a=a ;
        this.b=b ;
      }
      public int compareTo(Pair o){
        return this.b-o.b ;
      }
      public String toString(){
        return "["+a+","+b+"] " ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     C.newC().doIt() );
 class C {
   attribute n : int;
   attribute list : Sequence(Map);
   operation doIt() : void
  pre: true
  post: true
  activity: (     n := in.getCurrent()->toInteger() ; 
     c := in.getCurrent()->toInteger() ; 
    list := Sequence{} ; 
        var i : int ; i := 0 ; while i < c do (     list := list->including(Map(in.getCurrent()->toInteger(), in.getCurrent()->toInteger())) ;  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var hyou : Sequence(int) ; hyou := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     hyou[i+1] := hyou[i - 1+1] ; 
         var s : int ; s := 0 ; while s < c do ( (     if (list->at(s+1).a = i) then     hyou[i+1] := hyou[i+1]+(1) ; else     if (list->at(s+1).b = i) then     hyou[i+1] := hyou[i+1]-(1) ; else skip ; )  ;     s := s + 1 ) )  ;     i := i + 1 ) ; 
    var memo : int ; memo := -1 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (hyou[i+1] > 0) then (     if (memo = -1) then     memo := i ; else skip ; 
     hyou[i+1] := -1 ) else (     if (hyou[i - 1+1] = -1) then (     hyou[i+1] := memo ; 
     memo := -1 ) else skip ) )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i <= n do ( (     if (hyou[i+1] > 0) then (     cnt := cnt+((i - hyou[i+1]) * 2) ) else skip ; 
     cnt := cnt + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
 class Pair implements Comparable<Map> {
   attribute a : int;
   static operation newPair( a : int, b : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
   operation compareTo( o : Map) : int
  pre: true
  post: true
  activity: (     return self.b - o.b );
   operation toString() : String
  pre: true
  post: true
  activity: (     return "[" + a + "," + b + "] " );
}
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static int gcdHelper(int x,int y){
    if(y==0){
      return x ;
    }
    else {
    }
    return gcdHelper(y,x % y);
  }
  public static void main(String[] args)throws IOException {
    BufferedReader scan=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    String[] numArr ;
    while((line=scan.readLine())!=null){
      numArr=line.split(" ");
      int out=gcdHelper(Integer.parseInt(numArr[0]),Integer.parseInt(numArr[1]));
      System.out.println(out);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcdHelper( x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (y = 0) then (     return x ) else skip ;  
     return gcdHelper(y, x mod y) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
     var numArr : Sequence(String) ;
         line := scan.readLine() ;
    while ((line) /= null) do (    skip ; (     numArr := line->split(" ") ; 
     var out : int ; out := gcdHelper((numArr[0+1])->toInteger(), (numArr[1+1])->toInteger()) ;
     OclFile["System.out"].println(out) ) ;     line := scan.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,m ;
    int[] c,d,count ;
    int i,j,ans ;
    n=sc.nextInt();
    m=sc.nextInt();
    c=new int[m];
    d=new int[m];
    count=new int[n];
    for(i=0 ; i<m ; i++){
      c[i]=sc.nextInt();
      d[i]=sc.nextInt();
      for(j=c[i]; j<d[i]; j++)count[j]++;
    }
    ans=n+1 ;
    for(i=0 ; i<n ; i++)if(count[i]>0)ans+=2 ;
    out.println(ans);
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var m : int ;
    var c : Sequence(int) ;
    var d : Sequence(int) ;
    var count : Sequence(int) ;
    var i : int ;
    var j : int ;
    var ans : int ;
    n := sc.nextInt() ; 
    m := sc.nextInt() ; 
    c := Integer.subrange(1,m)->collect(0) ; 
    d := Integer.subrange(1,m)->collect(0) ; 
    count := Integer.subrange(1,n)->collect(0) ; 
        i := 0 ; while i < m do ( (     c[i+1] := sc.nextInt() ; 
     d[i+1] := sc.nextInt() ; 
         j := c[i+1] ; while j < d[i+1] do (     count[j+1] := count[j+1] + 1 ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    ans := n + 1 ; 
        i := 0 ; while i < n do (     if (count[i+1] > 0) then     ans := ans+(2) ; else skip ;  ;     i := i + 1 ) ; 
    out.println(ans) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    if(m==0){
      System.out.println(n+1);
      return ;
    }
    P[] ps=new P[m];
    for(int i=0 ; i<m ; i++){
      ps[i]=new P(sc.nextInt(),sc.nextInt());
    }
    sort(ps);
    int s=ps[0] .f,e=ps[0] .t ;
    ArrayList<P>l=new ArrayList<P>();
    for(int i=1 ; ; i++){
      while(i<m && e>=ps[i] .f){
        e=max(e,ps[i] .t);
        i++;
      }
      l.add(new P(s,e));
      if(i==m)break ;
      s=ps[i] .f ;
      e=ps[i] .t ;
    }
    int len=0,c=0 ;
    for(P p : l){
      len+=p.f-c ;
      len+=3*(p.t-p.f);
      c=p.t ;
    }
    len+=n+1-c ;
    System.out.println(len);
  }
  class P implements Comparable<P>{
    int f,t ;
    P(int f,int t){
      this.f=f ;
      this.t=t ;
    }
    public int compareTo(P o){
      if(f==o.f){
        return o.t-t ;
      }
      return f-o.f ;
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    if (m = 0) then (     OclFile["System.out"].println(n + 1) ; 
     return ) else skip ; 
    var ps : Sequence(P) ; ps := Integer.subrange(1,m)->collect(null) ;
        var i : int ; i := 0 ; while i < m do ( (     ps[i+1] := P.newP(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    execute sort(ps) ; 
    var s : int ; s := ps[0+1].f ;
    var e : int ; e := ps[0+1].t ;
    var l : Sequence(P) ; l := Sequence{} ;
        var i : int ; i := 1 ; while true do ( (     while (i < m & e >= ps[i+1].f) do (     e := Set{e, ps[i+1].t}->max() ; 
     i := i + 1 ) ; 
     l := l->including(P.newP(s, e)) ; 
    if (i = m) then     break else skip ; 
    s := ps[i+1].f ; 
    e := ps[i+1].t ; 
 )  ;     i := i + 1 ) ; 
    var len : int ; len := 0 ;
    var c : int ; c := 0 ;
    for (p : l) do ( (     len := len+(p.f - c) ; 
     len := len+(3 * (p.t - p.f)) ; 
     c := p.t )  ) ; 
    len := len+(n + 1 - c) ; 
    OclFile["System.out"].println(len) ; 
 );
 class P implements Comparable<P> {
   attribute f : int;
   static operation newP( f : int, t : int) : P
  pre: true
  post: true
  activity:
  ( var self : P ;
    self := createP();
    self.initialise(f, t);
    return self );
  operation initialise( f : int, t : int) : void
  pre: true  post: true
  activity: (     self.f := f ; 
     self.t := t );
   operation compareTo( o : P) : int
  pre: true
  post: true
  activity: (     if (f = o.f) then (     return o.t - t ) else skip ; 
     return f - o.f );
}
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int[] a=new int[101];
      while(true){
        int s=sc.nextInt();
        int t=sc.nextInt();
        if((s | t)==0)break ;
        a[s]++;
        a[t]++;
      }
      int o=0 ;
      for(int s : a)if(s % 2==1)o++;
      System.out.println(o!=2 ? "NG" : a[1] % 2==1 && a[2] % 2==1 ? "OK" : "NG");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var a : Sequence(int) ; a := Integer.subrange(1,101)->collect(0) ;
     while (true) do (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(s,t)) = 0) then     break else skip ; 
    a[s+1] := a[s+1] + 1 ; 
    a[t+1] := a[t+1] + 1 ; 
 ) ; 
    var o : int ; o := 0 ;
    for (s : a) do (     if (s mod 2 = 1) then     o := o + 1 ; else skip ;  ) ; 
    OclFile["System.out"].println(if o /= 2 then "NG" else if a[1+1] mod 2 = 1 & a[2+1] mod 2 = 1 then "OK" else "NG" endif endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int a,b ;
    int[] count ;
    int i,n ;
    count=new int[100];
    for(; sc.hasNext(); ){
      for(i=0 ; i<100 ; i++)count[i]=0 ;
      n=0 ;
      for(; ; ){
        a=sc.nextInt();
        b=sc.nextInt();
        if(a==0 && b==0)break ;
        count[a-1]++;
        count[b-1]++;
      }
      for(i=0 ; i<2 ; i++)if(count[i] % 2==0)n=1 ;
      for(i=2 ; i<100 ; i++)if(count[i] % 2!=0)n=1 ;
      if(n==1)out.println("NG");
      else out.println("OK");
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var a : int ;
    var b : int ;
    var count : Sequence(int) ;
    var i : int ;
    var n : int ;
    count := Integer.subrange(1,100)->collect(0) ; 
      while sc.hasNext() do ( (         i := 0 ; while i < 100 do (     count[i+1] := 0 ;  ;     i := i + 1 ) ; 
     n := 0 ; 
      while true do ( (     a := sc.nextInt() ; 
     b := sc.nextInt() ; 
    if (a = 0 & b = 0) then     break else skip ; 
    count[a - 1+1] := count[a - 1+1] + 1 ; 
    count[b - 1+1] := count[b - 1+1] + 1 ; 
 )  ) ; 
        i := 0 ; while i < 2 do (     if (count[i+1] mod 2 = 0) then     n := 1 ; else skip ;  ;     i := i + 1 ) ; 
        i := 2 ; while i < 100 do (     if (count[i+1] mod 2 /= 0) then     n := 1 ; else skip ;  ;     i := i + 1 ) ; 
    if (n = 1) then     out.println("NG") else     out.println("OK") ; ;  
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    int[] params=null ;
    String out="" ;
    while((params=parseParams())!=null){
      if(params.length!=2){
        continue ;
      }
      HashMap<Integer,Boolean>result=new HashMap<Integer,Boolean>();
      while(params[0]!=0 && params[1]!=0){
        for(int key : params){
          Boolean val=true ;
          switch(key){
            case 1 : case 2 : val=(result.containsKey(key))? ! result.get(key): true ;
            break ;
            default : val=(result.containsKey(key))? ! result.get(key): false ;
            break ;
          }
          result.put(key,val);
        }
        params=parseParams();
      }
      out+=result.containsValue(false)? "NG\n" : "OK\n" ;
    }
    System.out.print(out);
  }
  private static int[] parseParams(){
    int[] params=null ;
    String[] split=null ;
    String strIn=null ;
    if((strIn=parseStdin())!=null){
      split=strIn.split(" ");
      params=new int[split.length];
      for(int n=0 ; n<split.length ; n++){
        params[n]=Integer.parseInt(split[n]);
      }
    }
    return params ;
  }
  private static String parseStdin(){
    String strNum=null ;
    try {
      String line=br.readLine();
      if(line!=null){
        if(! line.isEmpty()){
          strNum=line ;
        }
      }
    }
    catch(IOException e){
    }
    return strNum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var params : Sequence(int) ; params := null ;
     var out : String ; out := "" ;
         params := parseParams() ;
    while ((params) /= null) do (    skip ; (     if (params->size() /= 2) then (     continue ) else skip ; 
     var result : Map(int,Boolean) ; result := Map{} ;
     while (params[0+1] /= 0 & params[1+1] /= 0) do (     for (key : params) do ( (     var val : Boolean ; val := true ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (key) ; 
    if _switchval = 1 or _switchval = 2 then
    val := if (result->keys()->includes(key)) then not(result->at(key)) else true endif ; 
    break 
   else skip ;
       if true then
     val := if (result->keys()->includes(key)) then not(result->at(key)) else false endif ; 
    break 
   else skip ;
 )
     result := result->union(Map{key |-> val}) )  ) ; 
     params := parseParams() ) ; 
     out := out+(if result->values()->includes(false) then "NG\n" else "OK\n" endif) ) ;     params := parseParams() ;
 ) ;  
     OclFile["System.out"].print(out) );
  static   operation parseParams() : Sequence(int)
  pre: true
  post: true
  activity: (     var params : Sequence(int) ; params := null ;
     var split : Sequence(String) ; split := null ;
    var strIn : String ; strIn := null ;
    if ((strIn) /= null) then (     split := strIn->split(" ") ; 
     params := Integer.subrange(1,split->size())->collect(0) ; 
         var n : int ; n := 0 ; while n < split->size() do ( (     params[n+1] := (split[n+1])->toInteger() )  ;     n := n + 1 ) ) else skip ; 
    return params 
 );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var strNum : String ; strNum := null ;
     try (     var line : String ; line := br.readLine() ;
     if (line /= null) then (     if (not(line->isEmpty())) then (     strNum := line ) else skip ) else skip )   catch (e : IOException) do skip
     return strNum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map.Entry ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  boolean solve(HashMap<Integer,Integer>v){
    boolean even=true ;
    for(Entry<Integer,Integer>e : v.entrySet()){
      if(e.getValue()% 2!=0)even=false ;
    }
    return even ;
  }
  int ni(){
    return sc.nextInt();
  }
  void io(){
    HashMap<Integer,Integer>v ;
    sc=new Scanner(System.in);
    while(sc.hasNext()){
      v=new HashMap<Integer,Integer>();
      int a,b ;
      while(true){
        a=ni();
        b=ni();
        if(a==0 && b==0)break ;
        int n=1 ;
        if(v.containsKey(a)){
          n=v.get(a)+1 ;
        }
        v.put(a,n);
        n=1 ;
        if(v.containsKey(b)){
          n=v.get(b)+1 ;
        }
        v.put(b,n);
      }
      v.put(1,v.get(1)+1);
      v.put(2,v.get(2)+1);
      System.out.println(solve(v)? "OK" : "NG");
    }
    sc.close();
  }
  public static void main(String[] args){
    new Main().io();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   operation solve( v : Map(int,int)) : boolean
  pre: true
  post: true
  activity: (     var even : boolean ; even := true ;
     for (e : v->asSet()) do ( (     if (e.getValue() mod 2 /= 0) then     even := false ; else skip )  ) ; 
     return even );
   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
   operation io() : void
  pre: true
  post: true
  activity: (     var v : Map(int,int) ;
     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     while (sc.hasNext()) do (     v := Map{} ; 
     var a : int ;
    var b : int ;
    while (true) do (     a := ni() ; 
     b := ni() ; 
    if (a = 0 & b = 0) then     break else skip ; 
    var n : int ; n := 1 ;
    if (v->keys()->includes(a)) then (     n := v->at(a) + 1 ) else skip ; 
    v := v->union(Map{a |-> n}) ; 
    n := 1 ; 
    if (v->keys()->includes(b)) then (     n := v->at(b) + 1 ) else skip ; 
    v := v->union(Map{b |-> n}) ; 
 ) ; 
    v := v->union(Map{1 |-> v->at(1) + 1}) ; 
    v := v->union(Map{2 |-> v->at(2) + 1}) ; 
    OclFile["System.out"].println(if solve(v) then "OK" else "NG" endif) ; 
 ) ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().io() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String input1=sc.next();
    String input2=sc.next();
    int width ;
    int height ;
    width=Integer.parseInt(input1);
    height=Integer.parseInt(input2);
    int menseki=width*height ;
    int syuu=width*2+height*2 ;
    System.out.println(menseki+" "+syuu);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input1 : String ; input1 := sc.getCurrent() ;
    var input2 : String ; input2 := sc.getCurrent() ;
    var width : int ;
    var height : int ;
    width := (input1)->toInteger() ; 
    height := (input2)->toInteger() ; 
    var menseki : int ; menseki := width * height ;
    var syuu : int ; syuu := width * 2 + height * 2 ;
    OclFile["System.out"].println(menseki + " " + syuu) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    String line=null ;
    while((line=reader.readLine())!=null){
      if(line.isEmpty()){
        continue ;
      }
      int[] counts=new int[101];
      while(true){
        String[] values=line.split(" ");
        int a=Integer.parseInt(values[0]);
        int b=Integer.parseInt(values[1]);
        if(a==0 && b==0){
          break ;
        }
        counts[a]++;
        counts[b]++;
        line=reader.readLine();
      }
      String result="NG" ;
      if(counts[1] % 2==1 && counts[2] % 2==1){
        boolean found=false ;
        for(int i=3 ; i<=100 ; i++){
          if(counts[i] % 2!=0){
            found=true ;
            break ;
          }
        }
        if(! found){
          result="OK" ;
        }
      }
      out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     var line : String ; line := null ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->isEmpty()) then (     continue ) else skip ; 
     var counts : Sequence(int) ; counts := Integer.subrange(1,101)->collect(0) ;
    while (true) do (     var values : Sequence(String) ; values := line->split(" ") ;
     var a : int ; a := (values[0+1])->toInteger() ;
    var b : int ; b := (values[1+1])->toInteger() ;
    if (a = 0 & b = 0) then (     break ) else skip ; 
    counts[a+1] := counts[a+1] + 1 ; 
    counts[b+1] := counts[b+1] + 1 ; 
    line := reader.readLine() ; 
 ) ; 
    var result : String ; result := "NG" ;
    if (counts[1+1] mod 2 = 1 & counts[2+1] mod 2 = 1) then (     var found : boolean ; found := false ;
         var i : int ; i := 3 ; while i <= 100 do ( (     if (counts[i+1] mod 2 /= 0) then (     found := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (not(found)) then (     result := "OK" ) else skip ) else skip ; 
    out.println(result) ; 
 ) ;     line := reader.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Rextester {
  FastScanner in ;
  PrintWriter out ;
  void solve(){
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      for(int i=1 ; i<=n ; i++){
        System.out.print(i+" ");
        for(int j=n ; j>=1 ; j--){
          if(i!=j)System.out.print(j+" ");
        }
        System.out.println();
      }
    }
  }
  void runIO(){
    in=new FastScanner(System.in);
    out=new PrintWriter(System.out);
    solve();
    out.close();
  }
  class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(File f){
      try {
        br=new BufferedReader(new FileReader(f));
      }
      catch(FileNotFoundException e){
        e.printStackTrace();
      }
    }
    public FastScanner(InputStream f){
      br=new BufferedReader(new InputStreamReader(f));
    }
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        String s=null ;
        try {
          s=br.readLine();
        }
        catch(IOException e){
          e.printStackTrace();
        }
        if(s==null)return null ;
        st=new StringTokenizer(s);
      }
      return st.nextToken();
    }
    boolean hasMoreTokens(){
      while(st==null || ! st.hasMoreTokens()){
        String s=null ;
        try {
          s=br.readLine();
        }
        catch(IOException e){
          e.printStackTrace();
        }
        if(s==null)return false ;
        st=new StringTokenizer(s);
      }
      return true ;
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
  public static void main(String[] args){
    new Rextester().runIO();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Rextester {
   attribute in : FastScanner;
   attribute out : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     var t : int ; t := in.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.nextInt() ;
         var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].print(i + " ") ; 
         var j : int ; j := n ; while j >= 1 do ( (     if (i /= j) then     OclFile["System.out"].print(j + " ") ; else skip )  ;     j := j - 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ) ;  ) );
   operation runIO() : void
  pre: true
  post: true
  activity: (     in := FastScanner.newFastScanner(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     execute solve() ; 
     skip );
 class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( f : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(f)) )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
 );
   static operation newFastScanner( f : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(f)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     var s : String ; s := null ;
     try (     s := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     if (s = null) then     return null else skip ; 
     st := OclIterator.newOclIterator_String(s) ) ; 
     return st.next() );
   operation hasMoreTokens() : boolean
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     var s : String ; s := null ;
     try (     s := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     if (s = null) then     return false else skip ; 
     st := OclIterator.newOclIterator_String(s) ) ; 
     return true );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Rextester.newRextester().runIO() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger ;
import java.util.stream.Collectors ;
public class AntiFibonacciPermutation {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      List<Integer>list=new ArrayList<>();
      List<Integer>list2=new ArrayList<>();
      for(int i=1 ; i<=n ; i++){
        list.add(i);
      }
      Collections.reverse(list);
      list2.addAll(list);
      for(int i=n-1 ; i>0 ; i--){
        Collections.swap(list,i,i-1);
        list2.addAll(list);
      }
      for(int i=0 ; i<list2.size(); i++){
        System.out.print(list2.get(i)+" ");
        if(i % n==n-1){
          System.out.println();
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AntiFibonacciPermutation {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var list : Sequence(int) ; list := Sequence{} ;
    var list2 : Sequence(int) ; list2 := Sequence{} ;
        var i : int ; i := 1 ; while i <= n do ( (     list := list->including(i) )  ;     i := i + 1 ) ; 
    list := list->reverse() ; 
    list2 := list2->union(list) ; 
        var i : int ; i := n - 1 ; while i > 0 do ( (     list := Integer.subrange(1,list.size)->collect( _x | if _x = i+1 then list->at(i - 1+1) else if _x = i - 1+1 then list->at(i+1) else list->at(_x) endif endif ) ; 
     list2 := list2->union(list) )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < list2->size() do ( (     OclFile["System.out"].print(list2->at(i+1) + " ") ; 
     if (i mod n = n - 1) then (     OclFile["System.out"].println() ) else skip )  ;     i := i + 1 ) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class IncreasingSequence {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int d=in.nextInt();
    int all[]=new int[n];
    int cnt1=0 ;
    int cnt2=0 ;
    for(int i=0 ; i<n ; i++){
      all[i]=in.nextInt();
    }
    for(int i=0 ; i<n-1 ; i++){
      if(all[i]>=all[i+1]){
        cnt1+=(all[i]-all[i+1])/d+1 ;
        cnt2=(all[i]-all[i+1])/d+1 ;
        all[i+1]+=cnt2*d ;
      }
    }
    System.out.println(cnt1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class IncreasingSequence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var all : Sequence(int) ; all := Integer.subrange(1,n)->collect(0) ;
    var cnt1 : int ; cnt1 := 0 ;
    var cnt2 : int ; cnt2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     all[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (all[i+1] >= all[i + 1+1]) then (     cnt1 := cnt1+((all[i+1] - all[i + 1+1]) / d + 1) ; 
     cnt2 := (all[i+1] - all[i + 1+1]) / d + 1 ; 
     all[i + 1+1] := all[i + 1+1]+(cnt2 * d) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int m=sc.nextInt();
      while(m-->0){
        int n=sc.nextInt();
        for(int i=1 ; i<=n ; i++){
          System.out.print(i);
          for(int k=n ; k>0 ; k--){
            if(i!=k){
              System.out.print(" "+k);
            }
          }
          System.out.println();
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var m : int ; m := sc.getCurrent()->toInteger() ;
         while (m > 0) do (        m := m - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].print(i) ; 
         var k : int ; k := n ; while k > 0 do ( (     if (i /= k) then (     OclFile["System.out"].print(" " + k) ) else skip )  ;     k := k - 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ) ;  ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      solve(sc);
    }
  }
  static void solve(Scanner sc){
    int n=sc.nextInt();
    for(int j=1 ; j<=n ; j++){
      System.out.print(j);
      for(int x=n ; x>0 ; x--){
        if(x!=j){
          System.out.print(" "+x);
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve(sc) ) ;  ) );
  static   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var j : int ; j := 1 ; while j <= n do ( (     OclFile["System.out"].print(j) ; 
         var x : int ; x := n ; while x > 0 do ( (     if (x /= j) then (     OclFile["System.out"].print(" " + x) ) else skip )  ;     x := x - 1 ) ; 
     OclFile["System.out"].println() )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.util.InputMismatchException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskB solver=new TaskB();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskB {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int t=in.nextInt();
      int min=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; i++){
        int c=in.nextInt();
        int time=in.nextInt();
        if(time<=t)min=Math.min(min,c);
      }
      out.println(min==Integer.MAX_VALUE ? "TLE" : min);
    }
  }
  static class InputReader {
    private BufferedReader br ;
    private StringTokenizer st ;
    public InputReader(InputStream inputStream){
      br=new BufferedReader(new InputStreamReader(inputStream));
      st=new StringTokenizer("");
    }
    public String nextString(){
      while(! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine()," ");
        }
        catch(IOException e){
          throw new InputMismatchException();
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(nextString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskB ; solver := TaskB.newTaskB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskB {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var t : int ; t := in.nextInt() ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     var c : int ; c := in.nextInt() ;
     var time : int ; time := in.nextInt() ;
     if (time <= t) then     min := Set{min, c}->min() ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newInputReader( inputStream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) ; 
     st := OclIterator.newOclIterator_String("") );
   operation nextString() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String_String(br.readLine(), " ") )   catch (e : IOException) do (     error IncorrectElementException() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextString())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    int T=Integer.parseInt(sc.next());
    List<Integer>list=new ArrayList();
    for(int i=0 ; i<N ; i++){
      int a=Integer.parseInt(sc.next());
      int b=Integer.parseInt(sc.next());
      if(b<=T){
        list.add(a);
      }
    }
    if(list.size()==0){
      System.out.println("TLE");
    }
    else {
      Collections.sort(list);
      System.out.println(list.get(0));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var T : int ; T := (sc.getCurrent())->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := (sc.getCurrent())->toInteger() ;
     var b : int ; b := (sc.getCurrent())->toInteger() ;
     if (b <= T) then (     list := list->including(a) ) else skip )  ;     i := i + 1 ) ; 
    if (list->size() = 0) then (     OclFile["System.out"].println("TLE") ) else (     list := list->sort() ; 
     OclFile["System.out"].println(list->at(0+1)) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BTimeLimitExceeded solver=new BTimeLimitExceeded();
    solver.solve(1,in,out);
    out.close();
  }
  static class BTimeLimitExceeded {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int tl=in.nextInt();
      int mincost=10000 ;
      for(int i=0 ; i<n ; i++){
        int c=in.nextInt();
        int t=in.nextInt();
        if(tl>=t){
          mincost=Math.min(mincost,c);
        }
      }
      if(mincost>1000){
        out.println("TLE");
      }
      else {
        out.println(mincost);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BTimeLimitExceeded ; solver := BTimeLimitExceeded.newBTimeLimitExceeded() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BTimeLimitExceeded {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var tl : int ; tl := in.getCurrent()->toInteger() ;
    var mincost : int ; mincost := 10000 ;
        var i : int ; i := 0 ; while i < n do ( (     var c : int ; c := in.getCurrent()->toInteger() ;
     var t : int ; t := in.getCurrent()->toInteger() ;
     if (tl >= t) then (     mincost := Set{mincost, c}->min() ) else skip )  ;     i := i + 1 ) ; 
    if (mincost > 1000) then (     skip ) else (     skip ) ;  
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
class Main {
  static Scanner s=new Scanner(System.in);
  public static void main(String[] $){
    int n=s.nextInt(),t=s.nextInt();
    int r=1000000000 ;
    for(int i=0 ; i<n ; ++i){
      int a=s.nextInt(),b=s.nextInt();
      if(b<=t)r=Math.min(r,a);
    }
    System.out.println(r<1000000000 ? r : "TLE");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s.getCurrent()->toInteger() ;
    var t : int ; t := s.getCurrent()->toInteger() ;
     var r : int ; r := 1000000000 ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := s.getCurrent()->toInteger() ;
    var b : int ; b := s.getCurrent()->toInteger() ;
     if (b <= t) then     r := Set{r, a}->min() ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if r < 1000000000 then r else "TLE" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int timeLimit=sc.nextInt();
    int[][] input=new int[N][2];
    List<Integer>list=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<2 ; j++){
        input[i][j]=sc.nextInt();
      }
    }
    for(int i=0 ; i<N ; i++){
      if(input[i][1]<=timeLimit){
        list.add(i);
      }
    }
    if(list.size()==0){
      System.out.println("TLE");
    }
    else {
      int min=input[0][0];
      for(int k : list){
        if(input[k][0]<min){
          min=input[k][0];
        }
      }
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var timeLimit : int ; timeLimit := sc.getCurrent()->toInteger() ;
    var input : Sequence(Sequence(int)) ; input := Integer.subrange(1,N)->collect(Integer.subrange(1,2)->collect(0)) ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < 2 do ( (     input[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (input[i+1][1+1] <= timeLimit) then (     list := list->including(i) ) else skip )  ;     i := i + 1 ) ; 
    if (list->size() = 0) then (     OclFile["System.out"].println("TLE") ) else (     var min : int ; min := input[0+1][0+1] ;
     for (k : list) do ( (     if (input[k+1][0+1] < min) then (     min := input[k+1][0+1] ) else skip )  ) ; 
     OclFile["System.out"].println(min) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public static void main(String[] args){
    java.util.Scanner scanner=new java.util.Scanner(System.in);
    int a=scanner.nextInt();
    int b=scanner.nextInt();
    System.out.print(a*b);
    System.out.print(" ");
    System.out.println(a*2+b*2);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : Scanner ; scanner := Scanner.newScanner(OclFile["System.in"]) ;
     var a : int ; a := scanner.nextInt() ;
    var b : int ; b := scanner.nextInt() ;
    OclFile["System.out"].print(a * b) ; 
    OclFile["System.out"].print(" ") ; 
    OclFile["System.out"].println(a * 2 + b * 2) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
class Solution {
  public List<String>fizzBuzz(int n){
    List<String>res=new ArrayList<>();
    for(int i=1 ; i<=n ; i++){
      String tmp="" ;
      if(i % 3==0)tmp+="Fizz" ;
      if(i % 5==0)tmp+="Buzz" ;
      if(tmp.length()==0)tmp+=String.valueOf(i);
      res.add(tmp);
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
   operation fizzBuzz( n : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var res : Sequence(String) ; res := Sequence{} ;
         var i : int ; i := 1 ; while i <= n do ( (     var tmp : String ; tmp := "" ;
     if (i mod 3 = 0) then     tmp := tmp+("Fizz") ; else skip ; 
    if (i mod 5 = 0) then     tmp := tmp+("Buzz") ; else skip ; 
    if (tmp->size() = 0) then     tmp := tmp+(((i) + "")) ; else skip ; 
    res := res->including(tmp) ; 
 )  ;     i := i + 1 ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Myclass {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int[] sizes=new int[n];
    for(int i=0 ; i<n ; ++i){
      sizes[i]=scn.nextInt();
    }
    int ans=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; ++i){
      int x,sum=0,cnt=0 ;
      for(int j=0 ; j<sizes[i]; ++j){
        x=scn.nextInt();
        sum+=x ;
        cnt++;
      }
      int temp=sum*5+cnt*15 ;
      ans=Math.min(ans,temp);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Myclass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var sizes : Sequence(int) ; sizes := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     sizes[i+1] := scn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ;
    var sum : int ; sum := 0 ;
    var cnt : int ; cnt := 0 ;
         var j : int ; j := 0 ; while j < sizes[i+1] do ( (     x := scn.getCurrent()->toInteger() ; 
     sum := sum+(x) ; 
     cnt := cnt + 1 )  ;     j := j + 1 ) ; 
     var temp : int ; temp := sum * 5 + cnt * 15 ;
     ans := Set{ans, temp}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class App {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    int b=in.nextInt();
    int c=in.nextInt();
    int d=in.nextInt();
    int x1=a*d-c*b ;
    int x2=c*b-a*d ;
    if(x1>0){
      int x=gcd(x1,a*d);
      System.out.println(x1/x+"/"+a*d/x);
    }
    else {
      int x=gcd(x2,c*b);
      System.out.println(x2/x+"/"+c*b/x);
    }
    in.close();
  }
  public static int gcd(int a,int b){
    if(b==0){
      return a ;
    }
    return gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var x1 : int ; x1 := a * d - c * b ;
    var x2 : int ; x2 := c * b - a * d ;
    if (x1 > 0) then (     var x : int ; x := gcd(x1, a * d) ;
     OclFile["System.out"].println(x1 / x + "/" + a * d / x) ) else (     var x : int ; x := gcd(x2, c * b) ;
     OclFile["System.out"].println(x2 / x + "/" + c * b / x) ) ;  
    skip ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else skip ; 
     return gcd(b, a mod b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      int[] k=new int[t];
      int min=Integer.MAX_VALUE ;
      for(int i=0 ; i<t ; i++){
        k[i]=sc.nextInt();
      }
      for(int i=0 ; i<t ; i++){
        int x=k[i];
        int sum=x*15 ;
        while(x-->0){
          int temp=sc.nextInt();
          sum+=temp*5 ;
        }
        min=Math.min(min,sum);
      }
      System.out.println(min);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var k : Sequence(int) ; k := Integer.subrange(1,t)->collect(0) ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < t do ( (     k[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < t do ( (     var x : int ; x := k[i+1] ;
     var sum : int ; sum := x * 15 ;
         while (x > 0) do (        x := x - 1 ;     skip ; (     var temp : int ; temp := sc.getCurrent()->toInteger() ;
     sum := sum+(temp * 5) ) ;  ) ;  
     min := Set{min, sum}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class solution8 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int min=Integer.MAX_VALUE ;
    int temp=0 ;
    int[] counterPop=new int[n];
    for(int i=0 ; i<n ; i++){
      counterPop[i]=sc.nextInt();
    }
    for(int i=0 ; i<counterPop.length ; i++){
      for(int j=0 ; j<counterPop[i]; j++){
        temp+=sc.nextInt()*5 ;
      }
      temp+=counterPop[i]*15 ;
      min=Math.min(temp,min);
      temp=0 ;
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution8 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var min : int ; min := 2147483647 ;
    var temp : int ; temp := 0 ;
    var counterPop : Sequence(int) ; counterPop := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     counterPop[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < counterPop->size() do ( (         var j : int ; j := 0 ; while j < counterPop[i+1] do ( (     temp := temp+(sc.getCurrent()->toInteger() * 5) )  ;     j := j + 1 ) ; 
     temp := temp+(counterPop[i+1] * 15) ; 
     min := Set{temp, min}->min() ; 
     temp := 0 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class IsDivisible {
  static boolean check(String str){
    int n=str.length();
    if(n==0)return false ;
    if(n==1)return((str.charAt(0)-'0')% 8==0);
    if(n==2)return(((str.charAt(n-2)-'0')*10+(str.charAt(n-1)-'0'))% 8==0);
    int last=str.charAt(n-1)-'0' ;
    int second_last=str.charAt(n-2)-'0' ;
    int third_last=str.charAt(n-3)-'0' ;
    return((third_last*100+second_last*10+last)% 8==0);
  }
  public static void main(String[] args){
    String str="76952" ;
    if(check(str))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class IsDivisible {
  static   operation check( str : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     if (n = 0) then     return false else skip ; 
    if (n = 1) then     return ((str->at(0+1) - ('0')->char2byte()) mod 8 = 0) else skip ; 
    if (n = 2) then     return (((str->at(n - 2+1) - ('0')->char2byte()) * 10 + (str->at(n - 1+1) - ('0')->char2byte())) mod 8 = 0) else skip ; 
    var last : int ; last := str->at(n - 1+1) - ('0')->char2byte() ;
    var second_last : int ; second_last := str->at(n - 2+1) - ('0')->char2byte() ;
    var third_last : int ; third_last := str->at(n - 3+1) - ('0')->char2byte() ;
    return ((third_last * 100 + second_last * 10 + last) mod 8 = 0) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "76952" ;
     if (check(str)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class IsDivisible {
  static boolean check(String str){
    int n=str.length();
    if(n==0)return false ;
    if(n==1)return((str.charAt(0)-'0')% 4==0);
    int last=str.charAt(n-1)-'0' ;
    int second_last=str.charAt(n-2)-'0' ;
    return((second_last*10+last)% 4==0);
  }
  public static void main(String[] args){
    String str="76952" ;
    if(check(str))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class IsDivisible {
  static   operation check( str : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     if (n = 0) then     return false else skip ; 
    if (n = 1) then     return ((str->at(0+1) - ('0')->char2byte()) mod 4 = 0) else skip ; 
    var last : int ; last := str->at(n - 1+1) - ('0')->char2byte() ;
    var second_last : int ; second_last := str->at(n - 2+1) - ('0')->char2byte() ;
    return ((second_last * 10 + last) mod 4 = 0) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "76952" ;
     if (check(str)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static void precompute(int arr[],int n,int pre[]){
    Arrays.fill(pre,0);
    pre[n-1]=arr[n-1]*(int)(Math.pow(2,0));
    for(int i=n-2 ; i>=0 ; i--)pre[i]=pre[i+1]+arr[i]*(1<<(n-1-i));
  }
  static int decimalOfSubarr(int arr[],int l,int r,int n,int pre[]){
    if(r!=n-1)return(pre[l]-pre[r+1])/(1<<(n-1-r));
    return pre[l]/(1<<(n-1-r));
  }
  public static void main(String[] args){
    int arr[]={
      1,0,1,0,1,1 };
      int n=arr.length ;
      int pre[]=new int[n];
      precompute(arr,n,pre);
      System.out.println(decimalOfSubarr(arr,2,4,n,pre));
      System.out.println(decimalOfSubarr(arr,4,5,n,pre));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation precompute( arr : Sequence(int), n : int, pre : Sequence(int)) : void
  pre: true
  post: true
  activity: (     pre := pre->collect(0) ; 
     pre[n - 1+1] := arr[n - 1+1] * (2->pow(0))->oclAsType(int) ; 
         var i : int ; i := n - 2 ; while i >= 0 do (     pre[i+1] := pre[i + 1+1] + arr[i+1] * ((1*(2->pow((n - 1 - i))))->oclAsType(long)) ;  ;     i := i - 1 ) );
  static   operation decimalOfSubarr( arr : Sequence(int), l : int, r : int, n : int, pre : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (r /= n - 1) then     return (pre[l+1] - pre[r + 1+1]) / ((1*(2->pow((n - 1 - r))))->oclAsType(long)) else skip ; 
     return pre[l+1] / ((1*(2->pow((n - 1 - r))))->oclAsType(long)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,0,1,0,1,1} ;
     var n : int ; n := arr->size() ;
    var pre : Sequence(int) ; pre := Integer.subrange(1,n)->collect(0) ;
    execute precompute(arr, n, pre) ; 
    OclFile["System.out"].println(decimalOfSubarr(arr, 2, 4, n, pre)) ; 
    OclFile["System.out"].println(decimalOfSubarr(arr, 4, 5, n, pre)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    HashSet<Integer>set=new HashSet<>();
    int max=Integer.MIN_VALUE ;
    for(int i=0 ; i<n*2 ; i++){
      int v=in.nextInt();
      if(! set.contains(v)){
        set.add(v);
        max=Math.max(max,set.size());
      }
      else {
        set.remove(v);
      }
    }
    pw.println(max);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
    var max : int ; max := -2147483648 ;
        var i : int ; i := 0 ; while i < n * 2 do ( (     var v : int ; v := in.getCurrent()->toInteger() ;
     if (not(set->includes(v))) then (     set := set->including(v) ; 
     max := Set{max, set->size()}->max() ) else (     set := set->excludingAt(v+1) ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SockPairs {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),i,m=0,c=0 ;
    boolean[] a=new boolean[n];
    for(i=0 ; i<n*2 ; i++){
      int x=in.nextInt()-1 ;
      c=a[x] ? c-1 : c+1 ;
      m=Math.max(m,c);
      a[x]=! a[x];
    }
    in.close();
    System.out.println(m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class SockPairs {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var i : int ;
    var m : int ; m := 0 ;
    var c : int ; c := 0 ;
    var a : Sequence(boolean) ; a := Integer.subrange(1,n)->collect(false) ;
        i := 0 ; while i < n * 2 do ( (     var x : int ; x := in.getCurrent()->toInteger() - 1 ;
     c := if a[x+1] then c - 1 else c + 1 endif ; 
     m := Set{m, c}->max() ; 
     a[x+1] := not(a[x+1]) )  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class AndryushaAndSocks {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int N=input.nextInt();
    int[] arr=new int[2*N];
    boolean[] vis=new boolean[N+1];
    int cur=0 ;
    int ans=1 ;
    for(int i=0 ; i<2*N ; i++){
      arr[i]=input.nextInt();
    }
    for(int i=0 ; i<2*N ; i++){
      if(! vis[arr[i] ]){
        cur++;
        vis[arr[i] ]=true ;
        ans=Math.max(cur,ans);
      }
      else {
        cur--;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class AndryushaAndSocks {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := input.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,2 * N)->collect(0) ;
    var vis : Sequence(boolean) ; vis := Integer.subrange(1,N + 1)->collect(false) ;
    var cur : int ; cur := 0 ;
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < 2 * N do ( (     arr[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 2 * N do ( (     if (not(vis[arr[i+1]+1])) then (     cur := cur + 1 ; 
     vis[arr[i+1]+1] := true ; 
     ans := Set{cur, ans}->max() ) else (     cur := cur - 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    while(true){
      int N=sc.nextInt();
      if(N==0)break ;
      int M=sc.nextInt();
      int S=sc.nextInt()-1 ;
      int G1=sc.nextInt()-1 ;
      int G2=sc.nextInt()-1 ;
      int[][] dist=new int[N][N];
      for(int i=0 ; i<N ; ++i){
        Arrays.fill(dist[i],1<<25);
        dist[i][i]=0 ;
      }
      for(int i=0 ; i<M ; ++i){
        int A=sc.nextInt()-1 ;
        int B=sc.nextInt()-1 ;
        int C=sc.nextInt();
        dist[A][B]=C ;
      }
      for(int i=0 ; i<N ; ++i){
        for(int j=0 ; j<N ; ++j){
          for(int k=0 ; k<N ; ++k){
            dist[j][k]=Math.min(dist[j][k],dist[j][i]+dist[i][k]);
          }
        }
      }
      int ans=1<<30 ;
      for(int i=0 ; i<N ; ++i){
        ans=Math.min(ans,dist[S][i]+dist[i][G1]+dist[i][G2]);
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then     break else skip ; 
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var S : int ; S := sc.getCurrent()->toInteger() - 1 ;
    var G1 : int ; G1 := sc.getCurrent()->toInteger() - 1 ;
    var G2 : int ; G2 := sc.getCurrent()->toInteger() - 1 ;
    var dist : Sequence(Sequence(int)) ; dist := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     dist[i+1] := dist[i+1]->collect((1*(2->pow(25)))->oclAsType(long)) ; 
     dist[i+1][i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var A : int ; A := sc.getCurrent()->toInteger() - 1 ;
     var B : int ; B := sc.getCurrent()->toInteger() - 1 ;
     var C : int ; C := sc.getCurrent()->toInteger() ;
     dist[A+1][B+1] := C )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (         var k : int ; k := 0 ; while k < N do ( (     dist[j+1][k+1] := Set{dist[j+1][k+1], dist[j+1][i+1] + dist[i+1][k+1]}->min() )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := (1*(2->pow(30)))->oclAsType(long) ;
        var i : int ; i := 0 ; while i < N do ( (     ans := Set{ans, dist[S+1][i+1] + dist[i+1][G1+1] + dist[i+1][G2+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void prefixSum(int[] p_arr,int[] arr,int n){
    p_arr[0]=arr[0];
    for(int i=1 ; i<n ; i++)p_arr[i]=arr[i]+p_arr[i-1];
  }
  static void qPrefixSum(int[] p_arr,int n,HashSet<Integer>q){
    for(int i=0 ; i<n ; i++)q.add(p_arr[i]);
  }
  static void canDivide(int[] p_arr,int n,HashSet<Integer>q,int l,int r){
    int sum ;
    if(l==0)sum=p_arr[r];
    else sum=p_arr[r]-p_arr[l-1];
    if(sum % 2==1){
      System.out.println("No");
      return ;
    }
    int beg=0 ;
    if(l!=0)beg=p_arr[l-1];
    if(q.contains(beg+sum/2)&&(beg+sum/2)!=(int)q.toArray()[q.size()-1])System.out.println("Yes");
    else System.out.println("No");
  }
  public static void main(String[] args){
    int arr[]={
      1,1,2,3 };
      int n=arr.length ;
      int p_arr[]=new int[n];
      prefixSum(p_arr,arr,n);
      HashSet<Integer>q=new HashSet<>();
      qPrefixSum(p_arr,n,q);
      canDivide(p_arr,n,q,0,1);
      canDivide(p_arr,n,q,1,3);
      canDivide(p_arr,n,q,1,2);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation prefixSum( p_arr : Sequence(int), arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     p_arr[0+1] := arr[0+1] ; 
         var i : int ; i := 1 ; while i < n do (     p_arr[i+1] := arr[i+1] + p_arr[i - 1+1] ;  ;     i := i + 1 ) );
  static   operation qPrefixSum( p_arr : Sequence(int), n : int, q : Set(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     q->excludes(p_arr[i+1]) ;  ;     i := i + 1 ) );
  static   operation canDivide( p_arr : Sequence(int), n : int, q : Set(int), l : int, r : int) : void
  pre: true
  post: true
  activity: (     var sum : int ;
     if (l = 0) then     sum := p_arr[r+1] else     sum := p_arr[r+1] - p_arr[l - 1+1] ; ;  
    if (sum mod 2 = 1) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
    var beg : int ; beg := 0 ;
    if (l /= 0) then     beg := p_arr[l - 1+1] ; else skip ; 
    if (q->includes(beg + sum / 2) & (beg + sum / 2) /= q->asSequence()[q->size() - 1+1]->oclAsType(int)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,2,3} ;
     var n : int ; n := arr->size() ;
    var p_arr : Sequence(int) ; p_arr := Integer.subrange(1,n)->collect(0) ;
    execute prefixSum(p_arr, arr, n) ; 
    var q : Set(int) ; q := Set{} ;
    execute qPrefixSum(p_arr, n, q) ; 
    execute canDivide(p_arr, n, q, 0, 1) ; 
    execute canDivide(p_arr, n, q, 1, 3) ; 
    execute canDivide(p_arr, n, q, 1, 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int a,b ;
    for(; sc.hasNext(); ){
      a=sc.nextInt();
      b=sc.nextInt();
      System.out.println(gcd(a,b));
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
  private static int gcd(int a,int b){
    if(a % b==0)return b ;
    else return gcd(b,(a % b));
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var a : int ;
    var b : int ;
       while sc.hasNext() do ( (     a := sc.nextInt() ; 
     b := sc.nextInt() ; 
     OclFile["System.out"].println(gcd(a, b)) )  ) ; 
     sc.close() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a mod b = 0) then     return b else     return gcd(b, (a mod b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    HashSet<Integer>set=new HashSet<>();
    int max=Integer.MIN_VALUE ;
    for(int i=0 ; i<n*2 ; i++){
      int v=in.nextInt();
      if(! set.contains(v)){
        set.add(v);
        max=Math.max(max,set.size());
      }
      else {
        set.remove(v);
      }
    }
    pw.println(max);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
    var max : int ; max := -2147483648 ;
        var i : int ; i := 0 ; while i < n * 2 do ( (     var v : int ; v := in.getCurrent()->toInteger() ;
     if (not(set->includes(v))) then (     set := set->including(v) ; 
     max := Set{max, set->size()}->max() ) else (     set := set->excludingAt(v+1) ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedOutputStream ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Map ;
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
import java.util.TreeMap ;
public class Practice2 {
  public static void main(String[] args){
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    FastReader sc=new FastReader();
    int d=sc.nextInt();
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    long sum=0 ;
    for(int i=0 ; i<n-1 ; i++){
      sum+=d-arr[i];
    }
    out.println(sum);
    out.close();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var sc : FastReader ; sc := FastReader.newFastReader() ;
    var d : int ; d := sc.nextInt() ;
    var n : int ; n := sc.nextInt() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     sum := sum+(d - arr[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Practice {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader sc=new FastReader();
    int d=sc.nextInt();
    int n=sc.nextInt();
    int days[]=new int[n];
    int sum=0 ;
    for(int i=0 ; i<n-1 ; i++){
      days[i]=sc.nextInt();
      sum+=(d-days[i]);
    }
    System.out.print(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var d : int ; d := sc.nextInt() ;
    var n : int ; n := sc.nextInt() ;
    var days : Sequence(int) ; days := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     days[i+1] := sc.nextInt() ; 
     sum := sum+((d - days[i+1])) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int d=in.nextInt();
    int n=in.nextInt();
    int inc=0 ;
    int[] a=new int[n];
    for(int i=0 ; i<n-1 ; i++){
      inc+=d-in.nextInt();
    }
    System.out.println(inc);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : int ; d := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var inc : int ; inc := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     inc := inc+(d - in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(inc) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class pre83 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 int find(int m,int d){
    return d-m+1 ;
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int d=obj.nextInt(),n=obj.nextInt(),arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=obj.nextInt();
    int ans=0 ;
    int day=arr[0];
    for(int i=1 ; i<n ; i++){
      int reset=find(day+1,d);
      ans+=reset ;
      day=arr[i];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre83 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation find( m : int, d : int) : int
  pre: true
  post: true
  activity: (     return d - m + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var d : int ; d := obj.nextInt() ;
    var n : int ; n := obj.nextInt() ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := obj.nextInt() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var day : int ; day := arr[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     var reset : int ; reset := find(day + 1, d) ;
     ans := ans+(reset) ; 
     day := arr[i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CodeForce {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static StringBuilder sb=new StringBuilder();
  public static int checkreverse(int[][] arr,int n){
    if(n % 2==1)return n ;
    for(int i=n/2-1 ; i>=0 ; i--){
      for(int j=0 ; j<arr[0] .length ; j++){
        if(arr[i][j]!=arr[n-i-1][j])return n ;
      }
    }
    return checkreverse(arr,n/2);
  }
  static boolean flag=false ;
  static int next(String[] sr,int ind){
    return Integer.parseInt(sr[ind]);
  }
  public static void main(String[] args)throws IOException {
    String[] sr=br.readLine().split(" ");
    int n=next(sr,0);
    int m=next(sr,1);
    int[][] arr=new int[n][m];
    for(int i=0 ; i<n ; i++){
      sr=br.readLine().split(" ");
      for(int j=0 ; j<m ; j++)arr[i][j]=next(sr,j);
    }
    System.out.println(checkreverse(arr,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForce {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute sb : String := StringLib.newString();
  static   operation checkreverse( arr : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 = 1) then     return n else skip ; 
         var i : int ; i := n / 2 - 1 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < arr[0+1]->size() do ( (     if (arr[i+1][j+1] /= arr[n - i - 1+1][j+1]) then     return n else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
     return checkreverse(arr, n / 2) );
  static   attribute flag : boolean := false;
  static   operation next( sr : Sequence(String), ind : int) : int
  pre: true
  post: true
  activity: (     return (sr[ind+1])->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sr : Sequence(String) ; sr := br.readLine()->split(" ") ;
     var n : int ; n := next(sr, 0) ;
    var m : int ; m := next(sr, 1) ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     sr := br.readLine()->split(" ") ; 
         var j : int ; j := 0 ; while j < m do (     arr[i+1][j+1] := next(sr, j) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(checkreverse(arr, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 boolean compare(int[] a,int[] b){
    for(int i=0 ; i<a.length ; i++){
      if(a[i]!=b[i])return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[][] arr=new int[n+1][m];
    for(int i=1 ; i<=n ; i++)for(int j=0 ; j<m ; j++)arr[i][j]=sc.nextInt();
    while(n % 2==0){
      int x=n/2 ;
      int y=x+1 ;
      boolean fg=false ;
      while(x>0 && y<=n){
        if(! compare(arr[x],arr[y]))fg=true ;
        x--;
        y++;
      }
      if(fg)break ;
      n/=2 ;
    }
    System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation compare( a : Sequence(int), b : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] /= b[i+1]) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : int ; n := sc.nextInt() ;
    var m : int ; m := sc.nextInt() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do (         var j : int ; j := 0 ; while j < m do (     arr[i+1][j+1] := sc.nextInt() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    while (n mod 2 = 0) do (     var x : int ; x := n / 2 ;
     var y : int ; y := x + 1 ;
    var fg : boolean ; fg := false ;
    while (x > 0 & y <= n) do (     if (not(compare(arr[x+1], arr[y+1]))) then     fg := true ; else skip ; 
     x := x - 1 ; 
     y := y + 1 ) ; 
    if (fg) then     break else skip ; 
    n := n/(2) ; 
 ) ; 
    OclFile["System.out"].println(n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    StringTokenizer st=new StringTokenizer(f.readLine());
    int n=Integer.parseInt(st.nextToken());
    int m=Integer.parseInt(st.nextToken());
    int[][] a=new int[n][m];
    for(int i=0 ; i<n ; i++){
      st=new StringTokenizer(f.readLine());
      for(int j=0 ; j<m ; j++){
        a[i][j]=Integer.parseInt(st.nextToken());
      }
    }
    while(n % 2==0){
      boolean flag=false ;
      for(int i=0 ; i<n/2 ; i++){
        if(! Arrays.equals(a[i],a[n-i-1])){
          flag=true ;
          break ;
        }
      }
      if(flag){
        break ;
      }
      n/=2 ;
    }
    out.println(n);
    f.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     st := OclIterator.newOclIterator_String(f.readLine()) ; 
         var j : int ; j := 0 ; while j < m do ( (     a[i+1][j+1] := (st.next())->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    while (n mod 2 = 0) do (     var flag : boolean ; flag := false ;
         var i : int ; i := 0 ; while i < n / 2 do ( (     if (not(a[i+1] = a[n - i - 1+1])) then (     flag := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (flag) then (     break ) else skip ; 
     n := n/(2) ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int n=in.nextInt();
      int s=1 ;
      String[] a=new String[n+1];
      a[0]="-1" ;
      for(int i=1 ; i<=n ; i++){
        a[i]=in.next();
      }
      Arrays.sort(a);
      int max=0 ;
      for(int i=1 ; i<=n ; i++){
        if(a[i] .equals(a[i-1]))s++;
        else {
          max=Math.max(max,s);
          s=1 ;
        }
      }
      max=Math.max(max,s);
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var s : int ; s := 1 ;
    var a : Sequence(String) ; a := Integer.subrange(1,n + 1)->collect(null) ;
    a[0+1] := "-1" ; 
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := in.getCurrent() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (a[i+1] = a[i - 1+1]) then     s := s + 1 ; else (     max := Set{max, s}->max() ; 
     s := 1 ) )  ;     i := i + 1 ) ; 
    max := Set{max, s}->max() ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findRemainders(long n){
    HashSet<Long>vc=new HashSet<Long>();
    for(long i=1 ; i<=Math.ceil(Math.sqrt(n)); i++)vc.add(n/i);
    for(long i=(long)(n/Math.ceil(Math.sqrt(n))-1); i>=0 ; i--)vc.add(i);
    for(long it : vc)System.out.print(it+" ");
  }
  public static void main(String[] args){
    long n=5 ;
    findRemainders(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findRemainders( n : long) : void
  pre: true
  post: true
  activity: (     var vc : Set(long) ; vc := Set{} ;
         var i : long ; i := 1 ; while i <= ((n)->sqrt())->ceil() do (     vc := vc->including(n / i) ;  ;     i := i + 1 ) ; 
         var i : long ; i := (n / ((n)->sqrt())->ceil() - 1)->oclAsType(long) ; while i >= 0 do (     vc := vc->including(i) ;  ;     i := i - 1 ) ; 
     for (it : vc) do (     OclFile["System.out"].print(it + " ") ;  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 5 ;
     execute findRemainders(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    long n=stdIn.nextLong();
    String nishin=Long.toBinaryString(n);
    char c[]=nishin.toCharArray();
    int start=32-nishin.length();
    for(int i=0 ; i<32 ; i++){
      if(i<start){
        System.out.print(0);
      }
      else {
        if(c[i-start]=='1'){
          System.out.print(1);
        }
        else {
          System.out.print(0);
        }
      }
    }
    System.out.println();
    for(int i=0 ; i<32 ; i++){
      if(i<start){
        System.out.print(1);
      }
      else {
        if(c[i-start]=='1'){
          System.out.print(0);
        }
        else {
          System.out.print(1);
        }
      }
    }
    System.out.println();
    for(int i=1 ; i<32 ; i++){
      if(i<start){
        System.out.print(0);
      }
      else {
        if(c[i-start]=='1'){
          System.out.print(1);
        }
        else {
          System.out.print(0);
        }
      }
    }
    System.out.print(0);
    System.out.println();
    System.out.print(0);
    for(int i=0 ; i<31 ; i++){
      if(i<start){
        System.out.print(0);
      }
      else {
        if(c[i-start]=='1'){
          System.out.print(1);
        }
        else {
          System.out.print(0);
        }
      }
    }
    System.out.println();
    stdIn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := stdIn.getCurrent()->toLong() ;
    var nishin : String ; nishin := (MathLib.decimal2binary(n) + "") ;
    var c : Sequence(String) ; c := nishin->characters() ;
    var start : int ; start := 32 - nishin->size() ;
        var i : int ; i := 0 ; while i < 32 do ( (     if (i < start) then (     OclFile["System.out"].print(0) ) else (     if (c[i - (start)->char2byte()+1] = '1') then (     OclFile["System.out"].print(1) ) else (     OclFile["System.out"].print(0) ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
        var i : int ; i := 0 ; while i < 32 do ( (     if (i < start) then (     OclFile["System.out"].print(1) ) else (     if (c[i - (start)->char2byte()+1] = '1') then (     OclFile["System.out"].print(0) ) else (     OclFile["System.out"].print(1) ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
        var i : int ; i := 1 ; while i < 32 do ( (     if (i < start) then (     OclFile["System.out"].print(0) ) else (     if (c[i - (start)->char2byte()+1] = '1') then (     OclFile["System.out"].print(1) ) else (     OclFile["System.out"].print(0) ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(0) ; 
    OclFile["System.out"].println() ; 
    OclFile["System.out"].print(0) ; 
        var i : int ; i := 0 ; while i < 31 do ( (     if (i < start) then (     OclFile["System.out"].print(0) ) else (     if (c[i - (start)->char2byte()+1] = '1') then (     OclFile["System.out"].print(1) ) else (     OclFile["System.out"].print(0) ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static long gcd(long a,long b){
    if(a<b){
      long tmp=a ;
      a=b ;
      b=tmp ;
    }
    while(b!=0){
      long r=a % b ;
      a=b ;
      b=r ;
    }
    return a ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext())System.out.println(gcd(sc.nextLong(),sc.nextLong()));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a < b) then (     var tmp : long ; tmp := a ;
     a := b ; 
     b := tmp ) else skip ; 
     while (b /= 0) do (     var r : long ; r := a mod b ;
     a := b ; 
     b := r ) ; 
     return a );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do     OclFile["System.out"].println(gcd(sc.getCurrent()->toLong(), sc.getCurrent()->toLong())) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int countPS(String str){
    int N=str.length();
    int[][] cps=new int[N+1][N+1];
    for(int i=0 ; i<N ; i++)cps[i][i]=1 ;
    for(int L=2 ; L<=N ; L++){
      for(int i=0 ; i<N ; i++){
        int k=L+i-1 ;
        if(k<N){
          if(str.charAt(i)==str.charAt(k))cps[i][k]=cps[i][k-1]+cps[i+1][k]+1 ;
          else cps[i][k]=cps[i][k-1]+cps[i+1][k]-cps[i+1][k-1];
        }
      }
    }
    return cps[0][N-1];
  }
  public static void main(String args[]){
    String str="abcb" ;
    System.out.println("Total palindromic "+"subsequence are : "+countPS(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countPS( str : String) : int
  pre: true
  post: true
  activity: (     var N : int ; N := str->size() ;
     var cps : Sequence(Sequence(int)) ; cps := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do (     cps[i+1][i+1] := 1 ;  ;     i := i + 1 ) ; 
        var L : int ; L := 2 ; while L <= N do ( (         var i : int ; i := 0 ; while i < N do ( (     var k : int ; k := L + i - 1 ;
     if (k < N) then (     if (str->at(i+1) = str->at(k+1)) then     cps[i+1][k+1] := cps[i+1][k - 1+1] + cps[i + 1+1][k+1] + 1 ; else     cps[i+1][k+1] := cps[i+1][k - 1+1] + cps[i + 1+1][k+1] - cps[i + 1+1][k - 1+1] ; ) else skip )  ;     i := i + 1 ) )  ;     L := L + 1 ) ; 
    return cps[0+1][N - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abcb" ;
     OclFile["System.out"].println("Total palindromic " + "subsequence are : " + countPS(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int cost(String str){
    int len=str.length();
    int res=0 ;
    for(int i=0,j=len-1 ; i<j ; i++,j--)if(str.charAt(i)!=str.charAt(j))res+=Math.min(str.charAt(i),str.charAt(j))-'a'+1 ;
    return res ;
  }
  public static void main(String[] args){
    String str="abcdef" ;
    System.out.println(cost(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation cost( str : String) : int
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     var res : int ; res := 0 ;
         var i : int ; i := 0 ;
    var j : int ; j := len - 1 ; while i < j do (     if (str->at(i+1) /= str->at(j+1)) then     res := res+(Set{str->at(i+1), str->at(j+1)}->min() - ('a')->char2byte() + 1) ; else skip ;  ;     i := i + 1 ;     j := j - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abcdef" ;
     OclFile["System.out"].println(cost(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findX(int a[],int n){
    Arrays.sort(a);
    int x=a[0]*a[n-1];
    Vector<Integer>vec=new Vector<Integer>();
    for(int i=2 ; i*i<=x ; i++){
      if(n % i==0){
        vec.add(i);
        if((n/i)!=i)vec.add(n/i);
      }
    }
    if(vec.size()==n){
      int i=0 ;
      for(int it : vec){
        if(a[i++]!=it)return-1 ;
      }
    }
    return x ;
  }
  public static void main(String[] args){
    int a[]={
      2,5,4,10 };
      int n=a.length ;
      System.out.print(findX(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findX( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var x : int ; x := a[0+1] * a[n - 1+1] ;
    var vec : Sequence(int) ; vec := Sequence{} ;
        var i : int ; i := 2 ; while i * i <= x do ( (     if (n mod i = 0) then (     vec := vec->including(i) ; 
     if ((n / i) /= i) then     vec := vec->including(n / i) ; else skip ) else skip )  ;     i := i + 1 ) ; 
    if (vec->size() = n) then (     var i : int ; i := 0 ;
     for (it : vec) do ( (     if (a[i+1] /= it) then     return -1 else skip )  ) ) else skip ; 
    return x 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,5,4,10} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(findX(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int No_Of_Pairs(int N){
    int i=1 ;
    while((i*i*i)+(2*i*i)+i<=N)i++;
    return(i-1);
  }
  static void print_pairs(int pairs){
    int i=1,mul ;
    for(i=1 ; i<=pairs ; i++){
      mul=i*(i+1);
      System.out.println("Pair no."+i+"-->("+(mul*i)+","+mul*(i+1)+")");
    }
  }
  public static void main(String[] args){
    int N=500,pairs,mul,i=1 ;
    pairs=No_Of_Pairs(N);
    System.out.println("No.of pairs="+pairs);
    print_pairs(pairs);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation No_Of_Pairs( N : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 1 ;
     while ((i * i * i) + (2 * i * i) + i <= N) do     i := i + 1 ; ; 
     return (i - 1) );
  static   operation print_pairs( pairs : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 1 ;
    var mul : int ;
         i := 1 ; while i <= pairs do ( (     mul := i * (i + 1) ; 
     OclFile["System.out"].println("Pair no." + i + "-->(" + (mul * i) + "," + mul * (i + 1) + ")") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 500 ;
    var pairs : int ;
    var mul : int ;
    var i : int ; i := 1 ;
     pairs := No_Of_Pairs(N) ; 
     OclFile["System.out"].println("No.of pairs=" + pairs) ; 
     execute print_pairs(pairs) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static String getNumber(String s){
    int number_of_digits=s.length();
    int freq[]=new int[10];
    for(int i=0 ; i<number_of_digits ; i++){
      if(s.charAt(i)=='1' || s.charAt(i)=='2' || s.charAt(i)=='3' || s.charAt(i)=='5' || s.charAt(i)=='7'){
        freq[s.charAt(i)-48]+=1 ;
      }
      if(s.charAt(i)=='4'){
        freq[2]+=2 ;
        freq[3]++;
      }
      if(s.charAt(i)=='6'){
        freq[5]++;
        freq[3]++;
      }
      if(s.charAt(i)=='8'){
        freq[7]++;
        freq[2]+=3 ;
      }
      if(s.charAt(i)=='9'){
        freq[7]++;
        freq[3]+=2 ;
        freq[2]++;
      }
    }
    String t="" ;
    if(freq[1]==number_of_digits || freq[0]==number_of_digits ||(freq[0]+freq[1])==number_of_digits){
      return s ;
    }
    else {
      for(int i=9 ; i>=2 ; i--){
        int ctr=freq[i];
        while((ctr--)>0){
          t+=(char)(i+48);
        }
      }
      return t ;
    }
  }
  public static void main(String[] args){
    String s="1280" ;
    System.out.println(getNumber(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getNumber( s : String) : String
  pre: true
  post: true
  activity: (     var number_of_digits : int ; number_of_digits := s->size() ;
     var freq : Sequence(int) ; freq := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < number_of_digits do ( (     if (s->at(i+1) = '1' or s->at(i+1) = '2' or s->at(i+1) = '3' or s->at(i+1) = '5' or s->at(i+1) = '7') then (     freq[s->at(i+1) - 48+1] := freq[s->at(i+1) - 48+1]+(1) ) else skip ; 
     if (s->at(i+1) = '4') then (     freq[2+1] := freq[2+1]+(2) ; 
     freq[3+1] := freq[3+1] + 1 ) else skip ; 
    if (s->at(i+1) = '6') then (     freq[5+1] := freq[5+1] + 1 ; 
     freq[3+1] := freq[3+1] + 1 ) else skip ; 
    if (s->at(i+1) = '8') then (     freq[7+1] := freq[7+1] + 1 ; 
     freq[2+1] := freq[2+1]+(3) ) else skip ; 
    if (s->at(i+1) = '9') then (     freq[7+1] := freq[7+1] + 1 ; 
     freq[3+1] := freq[3+1]+(2) ; 
     freq[2+1] := freq[2+1] + 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    var t : String ; t := "" ;
    if (freq[1+1] = number_of_digits or freq[0+1] = number_of_digits or (freq[0+1] + freq[1+1]) = number_of_digits) then (     return s ) else (         var i : int ; i := 9 ; while i >= 2 do ( (     var ctr : int ; ctr := freq[i+1] ;
         while ((ctr) > 0) do (        skip ;     skip ; (     t := t+((i + 48)->oclAsType(String)) ) ;  ) )  ;     i := i - 1 ) ; 
     return t ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "1280" ;
     OclFile["System.out"].println(getNumber(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int makePalindrome(int n,boolean odd){
    int res=n ;
    if(odd){
      n=n/10 ;
    }
    while(n>0){
      res=10*res+n % 10 ;
      n/=10 ;
    }
    return res ;
  }
  static boolean isPalindrome(int n,int base){
    int reversed=0 ;
    int temp=n ;
    while(temp>0){
      reversed=reversed*base+temp % base ;
      temp/=base ;
    }
    return reversed==n ;
  }
  static void sumPalindrome(int n,int k){
    int sum=0,i=1 ;
    int p=makePalindrome(i,true);
    while(p<n){
      if(isPalindrome(p,k)){
        sum+=p ;
      }
      i++;
      p=makePalindrome(i,true);
    }
    i=1 ;
    p=makePalindrome(i,false);
    while(p<n){
      if(isPalindrome(p,k)){
        sum+=p ;
      }
      i++;
      p=makePalindrome(i,false);
    }
    System.out.println("Total sum is "+sum);
  }
  public static void main(String[] args){
    int n=1000000,k=2 ;
    sumPalindrome(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation makePalindrome( n : int, odd : boolean) : int
  pre: true
  post: true
  activity: (     var res : int ; res := n ;
     if (odd) then (     n := n / 10 ) else skip ; 
     while (n > 0) do (     res := 10 * res + n mod 10 ; 
     n := n/(10) ) ; 
     return res );
  static   operation isPalindrome( n : int, base : int) : boolean
  pre: true
  post: true
  activity: (     var reversed : int ; reversed := 0 ;
     var temp : int ; temp := n ;
     while (temp > 0) do (     reversed := reversed * base + temp mod base ; 
     temp := temp/(base) ) ; 
     return reversed = n );
  static   operation sumPalindrome( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
    var i : int ; i := 1 ;
     var p : int ; p := makePalindrome(i, true) ;
    while (p < n) do (     if (isPalindrome(p, k)) then (     sum := sum+(p) ) else skip ; 
     i := i + 1 ; 
     p := makePalindrome(i, true) ) ; 
    i := 1 ; 
    p := makePalindrome(i, false) ; 
    while (p < n) do (     if (isPalindrome(p, k)) then (     sum := sum+(p) ) else skip ; 
     i := i + 1 ; 
     p := makePalindrome(i, false) ) ; 
    OclFile["System.out"].println("Total sum is " + sum) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1000000 ;
    var k : int ; k := 2 ;
     execute sumPalindrome(n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    long x=sc.nextLong();
    long y=sc.nextLong();
    sc.close();
    if(Math.abs(x-y)<=1){
      System.out.println("Brown");
    }
    else {
      System.out.println("Alice");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := sc.getCurrent()->toLong() ;
    var y : long ; y := sc.getCurrent()->toLong() ;
    skip ; 
    if (if x - y < 0 then -(x - y) else x - y endif <= 1) then (     OclFile["System.out"].println("Brown") ) else (     OclFile["System.out"].println("Alice") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(in,out);
    out.close();
  }
  static class Task {
    long X,Y ;
    void solve(InputReader in,PrintWriter out){
      X=in.nextLong();
      Y=in.nextLong();
      if(Math.abs(X-Y)<2)out.println("Brown");
      else out.println("Alice");
    }
  }
  static class InputReader {
    BufferedReader reader ;
    StringTokenizer tokenizer ;
    InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream));
      tokenizer=null ;
    }
    String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] nextIntArray(int size){
      int[] arr=new int[size];
      for(int i=0 ; i<size ; i++){
        arr[i]=nextInt();
      }
      return arr ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    long[] nextLongArray(int size){
      long[] arr=new long[size];
      for(int i=0 ; i<size ; i++){
        arr[i]=nextLong();
      }
      return arr ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(in, out) ; 
    skip ; 
 );
  static class Task {
   attribute X : long;
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     X := in.nextLong() ; 
     Y := in.nextLong() ; 
     if (if X - Y < 0 then -(X - Y) else X - Y endif < 2) then     skip ; else     skip ; );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextIntArray( size : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < size do ( (     arr[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return arr );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLongArray( size : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var arr : Sequence(long) ; arr := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < size do ( (     arr[i+1] := nextLong() )  ;     i := i + 1 ) ; 
     return arr );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main extends PrintWriter {
  Main(){
    super(System.out,true);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    Main o=new Main();
    o.main();
    o.flush();
  }
  void main(){
    long x=sc.nextLong();
    long y=sc.nextLong();
    println(Math.abs(x-y)>1 ? "Alice" : "Brown");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends OclFile {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"], true) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : Main ; o := Main.newMain() ;
     o.main() ; 
     o.flush() );
   operation main() : void
  pre: true
  post: true
  activity: (     var x : long ; x := sc.getCurrent()->toLong() ;
     var y : long ; y := sc.getCurrent()->toLong() ;
     execute println(if if x - y < 0 then -(x - y) else x - y endif > 1 then "Alice" else "Brown" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.io.BufferedWriter ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import java.io.Writer ;
import java.io.OutputStreamWriter ;
import java.io.BufferedReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    OutputWriter out=new OutputWriter(outputStream);
    D_Alice_Brown solver=new D_Alice_Brown();
    solver.solve(1,in,out);
    out.close();
  }
  static class D_Alice_Brown {
    public void solve(int testNumber,InputReader in,OutputWriter out){
      long a=in.nextLong();
      long b=in.nextLong();
      out.printLine(Math.abs(a-b)<=1 ? "Brown" : "Alice");
    }
  }
  static class InputReader {
    BufferedReader reader ;
    StringTokenizer st ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream));
      st=null ;
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          String line=reader.readLine();
          if(line==null){
            return null ;
          }
          st=new StringTokenizer(line);
        }
        catch(Exception e){
          throw new RuntimeException();
        }
      }
      return st.nextToken();
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
  static class OutputWriter {
    private final PrintWriter writer ;
    public OutputWriter(OutputStream outputStream){
      writer=new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }
    public OutputWriter(Writer writer){
      this.writer=new PrintWriter(writer);
    }
    public void printLine(String s){
      writer.println(s);
    }
    public void close(){
      writer.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OutputWriter ; out := OutputWriter.newOutputWriter(outputStream) ;
    var solver : D_Alice_Brown ; solver := D_Alice_Brown.newD_Alice_Brown() ;
    solver.solve(1, in, out) ; 
    out.close() ; 
 );
  static class D_Alice_Brown {
   operation solve( testNumber : int, in : InputReader, out : OutputWriter) : void
  pre: true
  post: true
  activity: (     var a : long ; a := in.nextLong() ;
     var b : long ; b := in.nextLong() ;
     out.printLine(if if a - b < 0 then -(a - b) else a - b endif <= 1 then "Brown" else "Alice" endif) );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute st : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) ; 
     st := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     var line : String ; line := reader.readLine() ;
     if (line = null) then (     return null ) else skip ; 
     st := OclIterator.newOclIterator_String(line) )   catch (e : ProgramException) do (     error ProgramException() )
 ) ; 
     return st.next() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static class OutputWriter {
   attribute writer : OclFile;
   static operation newOutputWriter( outputStream : OclFile) : OutputWriter
  pre: true
  post: true
  activity:
  ( var self : OutputWriter ;
    self := createOutputWriter();
    self.initialise(outputStream);
    return self );
  operation initialise( outputStream : OclFile) : void
  pre: true  post: true
  activity: (     writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputStream))) );
   static operation newOutputWriter( writer : OclFile) : OutputWriter
  pre: true
  post: true
  activity:
  ( var self : OutputWriter ;
    self := createOutputWriter();
    self.initialise(writer);
    return self );
  operation initialise( writer : OclFile) : void
  pre: true  post: true
  activity: (     self.writer := OclFile.newOclFile_Write(OclFile.newOclFile(writer)) );
   operation printLine( s : String) : void
  pre: true
  post: true
  activity: (     skip );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static BigInteger a,b ;
  public static void main(String[] args){
    while(read()){
      solve();
    }
  }
  static boolean read(){
    if(! sc.hasNext())return false ;
    a=sc.nextBigInteger();
    b=sc.nextBigInteger();
    return true ;
  }
  static void solve(){
    System.out.println(a.gcd(b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute a : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (read()) do (     execute solve() ) );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     if (not(sc.hasNext())) then     return false else skip ; 
     a := sc.nextBigInteger() ; 
     b := sc.nextBigInteger() ; 
     return true );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(a.gcd(b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    BigDecimal x=scanner.nextBigDecimal();
    BigDecimal y=scanner.nextBigDecimal();
    if(x.subtract(y).abs().compareTo(BigDecimal.ONE)>0){
      System.out.println("Alice");
    }
    else {
      System.out.println("Brown");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : double ; x := scanner.nextBigDecimal() ;
     var y : double ; y := scanner.nextBigDecimal() ;
     if (x.subtract(y).abs()->compareTo(1.0) > 0) then (     OclFile["System.out"].println("Alice") ) else (     OclFile["System.out"].println("Brown") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[][] list=new int[N][100];
    for(int i=0 ; i<N ; i++){
      int a=sc.nextInt();
      for(int j=1 ; j<=100 ; j++){
        list[i][j-1]=(j-a)*(j-a);
      }
    }
    int ans=listCheck(list);
    System.out.println(ans);
  }
  public static int listCheck(int[][] list){
    int ans=Integer.MAX_VALUE ;
    for(int i=0 ; i<100 ; i++){
      int check=0 ;
      for(int j=0 ; j<list.length ; j++){
        check+=list[j][i];
      }
      if(ans>check){
        ans=check ;
      }
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var list : Sequence(Sequence(int)) ; list := Integer.subrange(1,N)->collect(Integer.subrange(1,100)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
         var j : int ; j := 1 ; while j <= 100 do ( (     list[i+1][j - 1+1] := (j - a) * (j - a) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := listCheck(list) ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation listCheck( list : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 2147483647 ;
         var i : int ; i := 0 ; while i < 100 do ( (     var check : int ; check := 0 ;
         var j : int ; j := 0 ; while j < list->size() do ( (     check := check+(list[j+1][i+1]) )  ;     j := j + 1 ) ; 
     if (ans > check) then (     ans := check ) else skip )  ;     i := i + 1 ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int N=2 ;
  static boolean isVowel(char ch){
    return(ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u');
  }
  static int countVowels(String str,int l,int r){
    int cnt=0 ;
    for(int i=l ; i<=r ; i++){
      if(isVowel(str.charAt(i)))cnt++;
    }
    return cnt ;
  }
  static void performQueries(String str,int queries[][],int q){
    for(int i=0 ; i<q ; i++){
      System.out.println(countVowels(str,queries[i][0],queries[i][1]));
    }
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    int queries[][]={
      {
        1,3 },{
          2,4 },{
            1,9 }
          };
          int q=queries.length ;
          performQueries(str,queries,q);
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 2;
  static   operation isVowel( ch : String) : boolean
  pre: true
  post: true
  activity: (     return (ch = 'a' or ch = 'e' or ch = 'i' or ch = 'o' or ch = 'u') );
  static   operation countVowels( str : String, l : int, r : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := l ; while i <= r do ( (     if (isVowel(str->at(i+1))) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation performQueries( str : String, queries : Sequence(Sequence(int)), q : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < q do ( (     OclFile["System.out"].println(countVowels(str, queries[i+1][0+1], queries[i+1][1+1])) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var queries : Sequence(Sequence(int)) ; queries := Sequence{Sequence{1,3},Sequence{2,4},Sequence{1,9}} ;
     var q : int ; q := queries->size() ;
     execute performQueries(str, queries, q) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int prevPowerof2(int n){
    int p=(int)(Math.log(n)/Math.log(2));
    return(int)Math.pow(2,p);
  }
  static int nextPowerOf2(int n){
    int p=1 ;
    if((n==0)&& !((n &(n-1))==0))return n ;
    while(p<n)p<<=1 ;
    return p ;
  }
  static int minDiff(int n){
    int low=prevPowerof2(n);
    int high=nextPowerOf2(n);
    return Math.min(n-low,high-n);
  }
  public static void main(String[] args){
    int n=6 ;
    System.out.println(minDiff(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation prevPowerof2( n : int) : int
  pre: true
  post: true
  activity: (     var p : int ; p := ((n)->log() / (2)->log())->oclAsType(int) ;
     return 2->pow(p)->oclAsType(int) );
  static   operation nextPowerOf2( n : int) : int
  pre: true
  post: true
  activity: (     var p : int ; p := 1 ;
     if ((n = 0) & not(((n & (n - 1)) = 0))) then     return n else skip ; 
     while (p < n) do     p := p*(2->pow(1)) ; ; 
     return p );
  static   operation minDiff( n : int) : int
  pre: true
  post: true
  activity: (     var low : int ; low := prevPowerof2(n) ;
     var high : int ; high := nextPowerOf2(n) ;
     return Set{n - low, high - n}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(minDiff(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    int n=sc.nextInt();
    boolean flag=false ;
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      int s=sc.nextInt();
      int t=sc.nextInt();
      if(s==t)cnt++;
      else cnt=0 ;
      if(3<=cnt)flag=true ;
    }
    if(flag)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var flag : boolean ; flag := false ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     if (s = t) then     cnt := cnt + 1 else     cnt := 0 ; ;  
     if (3 <= cnt) then     flag := true ; else skip )  ;     i := i + 1 ) ; 
    if (flag) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sc.nextLine();
    int count=0 ;
    String str="" ;
    String[] line ;
    List<String[]>lineArray=new ArrayList();
    while(sc.hasNextLine()){
      str=sc.nextLine();
      line=str.split(" ");
      lineArray.add(line);
    }
    for(String[] comLine : lineArray){
      if(comLine[0] .equals(comLine[1])){
        count++;
        if(count==3){
          break ;
        }
      }
      else {
        count=0 ;
      }
    }
    if(count==3){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var count : int ; count := 0 ;
    var str : String ; str := "" ;
    var line : Sequence(String) ;
    var lineArray : Sequence(Sequence(String)) ; lineArray := Sequence{} ;
    while (sc.hasNextLine()) do (     str := sc.nextLine() ; 
     line := str->split(" ") ; 
     lineArray := lineArray->including(line) ) ; 
    for (comLine : lineArray) do ( (     if (comLine[0+1] = comLine[1+1]) then (     count := count + 1 ; 
     if (count = 3) then (     break ) else skip ) else (     count := 0 ) )  ) ; 
    if (count = 3) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  private static final int mod=(int)1e9+7 ;
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    int count=0 ;
    int max=0 ;
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      if(x==y){
        count++;
      }
      else {
        max=Math.max(count,max);
        count=0 ;
      }
    }
    max=Math.max(count,max);
    System.out.println(max>=3 ? "Yes" : "No");
  }
  static long nCr(int n,int r,int p){
    if(r==0)return 1 ;
    int[] fac=new int[n+1];
    fac[0]=1 ;
    for(int i=1 ; i<=n ; i++)fac[i]=fac[i-1]*i % p ;
    return(fac[n]*modInverse(fac[r],p)% p*modInverse(fac[n-r],p)% p)% p ;
  }
  static long modInverse(int n,int p){
    return pow(n,p-2)% mod ;
  }
  static long pow(long x,long y){
    long res=1l ;
    while(y!=0){
      if(y % 2==1){
        res=x*res % mod ;
      }
      y/=2 ;
      x=x*x % mod ;
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute mod : int := 1e9->oclAsType(int) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     if (x = y) then (     count := count + 1 ) else (     max := Set{count, max}->max() ; 
     count := 0 ) )  ;     i := i + 1 ) ; 
    max := Set{count, max}->max() ; 
    OclFile["System.out"].println(if max >= 3 then "Yes" else "No" endif) ; 
 );
  static   operation nCr( n : int, r : int, p : int) : long
  pre: true
  post: true
  activity: (     if (r = 0) then     return 1 else skip ; 
     var fac : Sequence(int) ; fac := Integer.subrange(1,n + 1)->collect(0) ;
    fac[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do (     fac[i+1] := fac[i - 1+1] * i mod p ;  ;     i := i + 1 ) ; 
    return (fac[n+1] * modInverse(fac[r+1], p) mod p * modInverse(fac[n - r+1], p) mod p) mod p 
 );
  static   operation modInverse( n : int, p : int) : long
  pre: true
  post: true
  activity: (     return pow(n, p - 2) mod mod );
  static   operation pow( x : long, y : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1l ;
     while (y /= 0) do (     if (y mod 2 = 1) then (     res := x * res mod mod ) else skip ; 
     y := y/(2) ; 
     x := x * x mod mod ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    out=new PrintWriter(new BufferedOutputStream(System.out));
    int numberOfRolls=sc.nextInt();
    int[][] array=new int[numberOfRolls][2];
    for(int i=0 ; i<numberOfRolls ; i++){
      array[i][0]=sc.nextInt();
      array[i][1]=sc.nextInt();
    }
    for(int i=0 ; i<=array.length-3 ; i++){
      if(array[i][0]==array[i][1] && array[i+1][0]==array[i+1][1] && array[i+2][0]==array[i+2][1]){
        System.out.println("Yes");
        return ;
      }
    }
    System.out.println("No");
    out.close();
  }
  public static PrintWriter out ;
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var numberOfRolls : int ; numberOfRolls := sc.nextInt() ;
    var array : Sequence(Sequence(int)) ; array := Integer.subrange(1,numberOfRolls)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < numberOfRolls do ( (     array[i+1][0+1] := sc.nextInt() ; 
     array[i+1][1+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= array->size() - 3 do ( (     if (array[i+1][0+1] = array[i+1][1+1] & array[i + 1+1][0+1] = array[i + 1+1][1+1] & array[i + 2+1][0+1] = array[i + 2+1][1+1]) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("No") ; 
    out.close() ; 
 );
  static   attribute out : OclFile;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int[] D=new int[2*N];
    for(int i=0 ; i<2*N ; i+=2){
      D[i]=scan.nextInt();
      D[i+1]=scan.nextInt();
    }
    String ans="No" ;
    for(int i=0 ; i<2*(N-2); i+=2){
      if(D[i]==D[i+1] && D[i+2]==D[i+3] && D[i+4]==D[i+5]){
        ans="Yes" ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var D : Sequence(int) ; D := Integer.subrange(1,2 * N)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 * N do ( (     D[i+1] := scan.getCurrent()->toInteger() ; 
     D[i + 1+1] := scan.getCurrent()->toInteger() )  ;     i := i+(2) ) ; 
    var ans : String ; ans := "No" ;
        var i : int ; i := 0 ; while i < 2 * (N - 2) do ( (     if (D[i+1] = D[i + 1+1] & D[i + 2+1] = D[i + 3+1] & D[i + 4+1] = D[i + 5+1]) then (     ans := "Yes" ) else skip )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  static int H ;
  static int W ;
  static boolean[][] done ;
  static char[][] map ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while(!(line=br.readLine()).equals("0 0")){
      String[] input=line.split(" ");
      H=Integer.parseInt(input[0]);
      W=Integer.parseInt(input[1]);
      done=new boolean[H][W];
      map=new char[H][W];
      int res=0 ;
      for(int i=0 ; i<H ; i++){
        map[i]=br.readLine().toCharArray();
      }
      for(int i=0 ; i<H ; i++){
        for(int j=0 ; j<W ; j++){
          if(done[i][j]){
            continue ;
          }
          else {
            res++;
            dist(i,j,map[i][j]);
          }
        }
      }
      System.out.println(res);
    }
  }
  static void dist(int h,int w,char c){
    try {
      char x=map[h][w];
      if(! done[h][w] && x==c){
        done[h][w]=true ;
        dist(h,w-1,c);
        dist(h,w+1,c);
        dist(h-1,w,c);
        dist(h+1,w,c);
      }
    }
    catch(ArrayIndexOutOfBoundsException e){
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute H : int;
  static   attribute W : int;
  static   attribute done : Sequence(Sequence(boolean));
  static   attribute map : Sequence(Sequence(String));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     while (not((line) = "0 0")) do (     var input : Sequence(String) ; input := line->split(" ") ;
     H := (input[0+1])->toInteger() ; 
    W := (input[1+1])->toInteger() ; 
    done := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(false)) ; 
    map := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < H do ( (     map[i+1] := br.readLine()->characters() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (done[i+1][j+1]) then (     continue ) else (     res := res + 1 ; 
     execute dist(i, j, map[i+1][j+1]) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 ) );
  static   operation dist( h : int, w : int, c : String) : void
  pre: true
  post: true
  activity: (     try (     var x : String ; x := map[h+1][w+1] ;
     if (not(done[h+1][w+1]) & x = c) then (     done[h+1][w+1] := true ; 
     execute dist(h, w - 1, c) ; 
    execute dist(h, w + 1, c) ; 
    execute dist(h - 1, w, c) ; 
    execute dist(h + 1, w, c) ; 
 ) else skip )   catch (e : IndexingException) do (     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int[] a=new int[26];
    int sum=0 ;
    for(int i=0 ; i<s.length(); i++){
      a[s.charAt(i)-'a']++;
    }
    for(int i=0 ; i<26 ; i++){
      sum+=a[i] % 2 ;
    }
    System.out.println(sum/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var a : Sequence(int) ; a := Integer.subrange(1,26)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     a[s->at(i+1) - ('a')->char2byte()+1] := a[s->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 26 do ( (     sum := sum+(a[i+1] mod 2) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int[] dx={
-1,0,1,0 };
    public static int[] dy={
      0,1,0,-1 };
      public static void solve(char[][] maze,int x,int y){
        char temp=maze[x][y];
        maze[x][y]='.' ;
        for(int i=0 ; i<4 ; i++){
          int new_x=x+dx[i];
          int new_y=y+dy[i];
          if(new_x<0 || new_x>=maze.length || new_y<0 || new_y>=maze[0] .length)continue ;
          if(maze[new_x][new_y]==temp){
            solve(maze,new_x,new_y);
          }
        }
      }
      public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int x,y ;
        while(true){
          String l=sc.nextLine();
          String[] nums=l.split("\\s+");
          if(nums.length==2 && nums[0] .equals("0")&& nums[1] .equals("0"))return ;
          int h=Integer.parseInt(nums[0]);
          int w=Integer.parseInt(nums[1]);
          char[][] maze=new char[h][w];
          for(int i=0 ; i<h ; i++){
            String s=sc.nextLine();
            for(int j=0 ; j<w ; j++){
              maze[i][j]=s.charAt(j);
            }
          }
          int res=0 ;
          for(int i=0 ; i<h ; i++){
            for(int j=0 ; j<w ; j++){
              if(maze[i][j]!='.'){
                solve(maze,i,j);
                res++;
              }
            }
          }
          System.out.println(res);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dx : Sequence(int) := Sequence{-1,0,1,0};
  static   attribute dy : Sequence(int) := Sequence{0,1,0,-1};
  static   operation solve( maze : Sequence(Sequence(String)), x : int, y : int) : void
  pre: true
  post: true
  activity: (     var temp : String ; temp := maze[x+1][y+1] ;
     maze[x+1][y+1] := '.' ; 
         var i : int ; i := 0 ; while i < 4 do ( (     var new_x : int ; new_x := x + dx[i+1] ;
     var new_y : int ; new_y := y + dy[i+1] ;
     if (new_x < 0 or new_x >= maze->size() or new_y < 0 or new_y >= maze[0+1]->size()) then     continue else skip ; 
     if (maze[new_x+1][new_y+1] = temp) then (     execute solve(maze, new_x, new_y) ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ;
    var y : int ;
     while (true) do (     var l : String ; l := sc.nextLine() ;
     var nums : Sequence(String) ; nums := l->split("\\s+") ;
    if (nums->size() = 2 & nums[0+1] = "0" & nums[1+1] = "0") then     return else skip ; 
    var h : int ; h := (nums[0+1])->toInteger() ;
    var w : int ; w := (nums[1+1])->toInteger() ;
    var maze : Sequence(Sequence(String)) ; maze := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (     var s : String ; s := sc.nextLine() ;
         var j : int ; j := 0 ; while j < w do ( (     maze[i+1][j+1] := s->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (maze[i+1][j+1] /= '.') then (     execute solve(maze, i, j) ; 
     res := res + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static PrintWriter out ;
  static StringBuilder sb ;
  static long mod=1000000007 ;
  static int inf=(int)1e15 ;
  static ArrayList<Integer>[] adL,adH ;
  static int n,q ;
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    out=new PrintWriter(System.out);
    int n=sc.nextInt();
    long ans=Long.MAX_VALUE ;
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    Arrays.sort(a);
    for(int i=a[0]; i<=a[n-1]; i++){
      long tem=0 ;
      for(int j=0 ; j<n ; j++)tem+=(i-a[j])*(i-a[j]);
      ans=Math.min(ans,tem);
    }
    System.out.println(ans);
    out.flush();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream system){
      br=new BufferedReader(new InputStreamReader(system));
    }
    public Scanner(String file)throws Exception {
      br=new BufferedReader(new FileReader(file));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public char nextChar()throws IOException {
      return next().charAt(0);
    }
    public Long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
    public void waitForInput()throws InterruptedException {
      Thread.sleep(3000);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile;
  static   attribute sb : String;
  static   attribute mod : long := 1000000007;
  static   attribute inf : int := 1e15->oclAsType(int);
  static   attribute adL : Sequence(Sequence(int));
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : long ; ans := "9223372036854775807"->toLong() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
        var i : int ; i := a[0+1] ; while i <= a[n - 1+1] do ( (     var tem : long ; tem := 0 ;
         var j : int ; j := 0 ; while j < n do (     tem := tem+((i - a[j+1]) * (i - a[j+1])) ;  ;     j := j + 1 ) ; 
     ans := Set{ans, tem}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( system : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(system);
    return self );
  operation initialise( system : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(system)) );
   static operation newScanner( file : String) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
   operation waitForInput() : void
  pre: true
  post: true
  activity: (     OclProcess.sleep(3000) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    new Main().calc();
  }
  int[] moveX={
    0,0,-1,1 };
    int[] moveY={
-1,1,0,0 };
      char[][] map ;
      boolean[][] check ;
      int ans=0 ;
      int w,h ;
      void calc(){
        Scanner sc=new Scanner(System.in);
        while(true){
          h=sc.nextInt();
          w=sc.nextInt();
          if(w==0)break ;
          ans=0 ;
          map=new char[h][w];
          check=new boolean[h][w];
          for(int i=0 ; i<h ; i++)map[i]=sc.next().toCharArray();
          bfs();
          System.out.println(ans);
        }
      }
      void bfs(){
        for(int i=0 ; i<h ; i++){
          for(int j=0 ; j<w ; j++){
            if(check[i][j])continue ;
            check[i][j]=true ;
            ans++;
            Queue<Integer>queueX=new LinkedList<Integer>();
            Queue<Integer>queueY=new LinkedList<Integer>();
            queueX.add(j);
            queueY.add(i);
            while(! queueX.isEmpty()){
              int x=queueX.poll();
              int y=queueY.poll();
              for(int k=0 ; k<moveX.length ; k++){
                int nextX=x+moveX[k];
                int nextY=y+moveY[k];
                if(0<=nextX && nextX<w && 0<=nextY && nextY<h && ! check[nextY][nextX] && map[i][j]==map[nextY][nextX]){
                  check[nextY][nextX]=true ;
                  queueX.add(nextX);
                  queueY.add(nextY);
                }
              }
            }
          }
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().calc() );
   attribute moveX : Sequence(int) := Sequence{0,0,-1,1};
   attribute moveY : Sequence(int) := Sequence{-1,1,0,0};
   attribute map : Sequence(Sequence(String));
   attribute check : Sequence(Sequence(boolean));
   attribute ans : int := 0;
   attribute w : int;
   operation calc() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     h := sc.getCurrent()->toInteger() ; 
     w := sc.getCurrent()->toInteger() ; 
    if (w = 0) then     break else skip ; 
    ans := 0 ; 
    map := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ; 
    check := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(false)) ; 
        var i : int ; i := 0 ; while i < h do (     map[i+1] := sc.getCurrent()->characters() ;  ;     i := i + 1 ) ; 
    execute bfs() ; 
    OclFile["System.out"].println(ans) ; 
 ) );
   operation bfs() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (check[i+1][j+1]) then     continue else skip ; 
     check[i+1][j+1] := true ; 
    ans := ans + 1 ; 
    var queueX : Sequence(int) ; queueX := Sequence{} ;
    var queueY : Sequence(int) ; queueY := Sequence{} ;
    queueX := queueX->including(j) ; 
    queueY := queueY->including(i) ; 
    while (not(queueX->isEmpty())) do (     var x : int ; x := queueX->min() ;
     var y : int ; y := queueY->min() ;
         var k : int ; k := 0 ; while k < moveX->size() do ( (     var nextX : int ; nextX := x + moveX[k+1] ;
     var nextY : int ; nextY := y + moveY[k+1] ;
     if (0 <= nextX & nextX < w & 0 <= nextY & nextY < h & not(check[nextY+1][nextX+1]) & map[i+1][j+1] = map[nextY+1][nextX+1]) then (     check[nextY+1][nextX+1] := true ; 
     queueX := queueX->including(nextX) ; 
     queueY := queueY->including(nextY) ) else skip )  ;     k := k + 1 ) ) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static final int DONE_FLAG='.' ;
  public static final int[] dx={
    0,1,0,-1 };
    public static final int[] dy={
-1,0,1,0 };
      public static int h,w ;
      public static char[][] map ;
      public static void depthFirstSearch(int x,int y,char target){
        if(map[y][x]!=target){
          return ;
        }
        map[y][x]=DONE_FLAG ;
        for(int i=0 ; i<4 ; i++){
          int nx=x+dx[i];
          int ny=y+dy[i];
          if(nx<0 || w<=nx || ny<0 || h<=ny){
            continue ;
          }
          depthFirstSearch(nx,ny,target);
        }
      }
      public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        while(true){
          h=sc.nextInt();
          w=sc.nextInt();
          if(h==0 && w==0){
            break ;
          }
          map=new char[h][];
          for(int i=0 ; i<h ; i++){
            map[i]=sc.next().toCharArray();
          }
          int count=0 ;
          for(int i=0 ; i<h ; i++){
            for(int j=0 ; j<w ; j++){
              char current=map[i][j];
              if(current!=DONE_FLAG){
                depthFirstSearch(j,i,current);
                count++;
              }
            }
          }
          System.out.println(count);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute DONE_FLAG : int := '.';
  static    attribute dx : Sequence(int) := Sequence{0,1,0,-1};
  static    attribute dy : Sequence(int) := Sequence{-1,0,1,0};
  static   attribute h : int;
  static   attribute map : Sequence(Sequence(String));
  static   operation depthFirstSearch( x : int, y : int, target : String) : void
  pre: true
  post: true
  activity: (     if (map[y+1][x+1] /= target) then (     return ) else skip ; 
     map[y+1][x+1] := DONE_FLAG ; 
         var i : int ; i := 0 ; while i < 4 do ( (     var nx : int ; nx := x + dx[i+1] ;
     var ny : int ; ny := y + dy[i+1] ;
     if (nx < 0 or w <= nx or ny < 0 or h <= ny) then (     continue ) else skip ; 
     execute depthFirstSearch(nx, ny, target) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     h := sc.getCurrent()->toInteger() ; 
     w := sc.getCurrent()->toInteger() ; 
    if (h = 0 & w = 0) then (     break ) else skip ; 
    map := Integer.subrange(1,h)->collect(Sequence{}) ; 
        var i : int ; i := 0 ; while i < h do ( (     map[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     var current : String ; current := map[i+1][j+1] ;
     if (current /= DONE_FLAG) then (     execute depthFirstSearch(j, i, current) ; 
     count := count + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void decBinary(int arr[],int n){
    int k=(int)(Math.log(n)/Math.log(2));
    while(n>0){
      arr[k--]=n % 2 ;
      n/=2 ;
    }
  }
  static int binaryDec(int arr[],int n){
    int ans=0 ;
    for(int i=0 ; i<n ; i++)ans+=arr[i]<<(n-i-1);
    return ans ;
  }
  static int concat(int m,int n){
    int k=(int)(Math.log(m)/Math.log(2))+1 ;
    int l=(int)(Math.log(n)/Math.log(2))+1 ;
    int a[]=new int[k];
    int b[]=new int[l];
    int c[]=new int[k+l];
    decBinary(a,m);
    decBinary(b,n);
    int in=0 ;
    for(int i=0 ; i<k ; i++)c[in++]=a[i];
    for(int i=0 ; i<l ; i++)c[in++]=b[i];
    return(binaryDec(c,k+l));
  }
  public static void main(String[] args){
    int m=4,n=5 ;
    System.out.println(concat(m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation decBinary( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var k : int ; k := ((n)->log() / (2)->log())->oclAsType(int) ;
     while (n > 0) do (      arr[k+1] := n mod 2  ; k := k - 1 ; 
     n := n/(2) ) );
  static   operation binaryDec( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do (     ans := ans+((arr[i+1]*(2->pow((n - i - 1))))->oclAsType(long)) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation concat( m : int, n : int) : int
  pre: true
  post: true
  activity: (     var k : int ; k := ((m)->log() / (2)->log())->oclAsType(int) + 1 ;
     var l : int ; l := ((n)->log() / (2)->log())->oclAsType(int) + 1 ;
    var a : Sequence(int) ; a := Integer.subrange(1,k)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,l)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,k + l)->collect(0) ;
    execute decBinary(a, m) ; 
    execute decBinary(b, n) ; 
    var in : int ; in := 0 ;
        var i : int ; i := 0 ; while i < k do (      c[in+1] := a[i+1]  ; in := in + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < l do (      c[in+1] := b[i+1]  ; in := in + 1 ;  ;     i := i + 1 ) ; 
    return (binaryDec(c, k + l)) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 4 ;
    var n : int ; n := 5 ;
     OclFile["System.out"].println(concat(m, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _771A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    boolean[] visited=new boolean[n+1];
    ArrayList<Integer>[] edges=new ArrayList[n+1];
    for(int i=1 ; i<n+1 ; i++){
      edges[i]=new ArrayList<Integer>();
    }
    for(int i=0 ; i<m ; i++){
      int c=in.nextInt();
      int d=in.nextInt();
      edges[c] .add(d);
      edges[d] .add(c);
    }
    for(int i=1 ; i<n+1 ; i++){
      if(! visited[i]){
        double nodes=0 ;
        double cons=0 ;
        Queue<Integer>q=new LinkedList<Integer>();
        q.add(i);
        visited[i]=true ;
        while(! q.isEmpty()){
          int curr=q.poll();
          nodes++;
          for(int j=0 ; j<edges[curr] .size(); j++){
            cons++;
            if(! visited[edges[curr] .get(j)]){
              q.add(edges[curr] .get(j));
              visited[edges[curr] .get(j)]=true ;
            }
          }
        }
        if(!(cons/2==nodes*(nodes-1)/2)){
          System.out.println("NO");
          System.exit(0);
        }
      }
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class _771A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,n + 1)->collect(false) ;
    var edges : Sequence(Sequence(int)) ; edges := Integer.subrange(1,n + 1)->collect(null) ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     edges[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var c : int ; c := in.getCurrent()->toInteger() ;
     var d : int ; d := in.getCurrent()->toInteger() ;
     edges[c+1]->excludes(d) ; 
     edges[d+1]->excludes(c) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n + 1 do ( (     if (not(visited[i+1])) then (     var nodes : double ; nodes := 0 ;
     var cons : double ; cons := 0 ;
    var q : Sequence(int) ; q := Sequence{} ;
    q := q->including(i) ; 
    visited[i+1] := true ; 
    while (not(q->isEmpty())) do (     var curr : int ; curr := q->min() ;
     nodes := nodes + 1 ; 
         var j : int ; j := 0 ; while j < edges[curr+1]->size() do ( (     cons := cons + 1 ; 
     if (not(visited[edges[curr+1]->at(j+1)+1])) then (     q := q->including(edges[curr+1]->at(j+1)) ; 
     visited[edges[curr+1]->at(j+1)+1] := true ) else skip )  ;     j := j + 1 ) ) ; 
    if (not((cons / 2 = nodes * (nodes - 1) / 2))) then (     OclFile["System.out"].println("NO") ; 
 OclProcess.exit(0) ) else skip ; 
 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Mavenprojects {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String x=sc.next();
    String y=sc.next();
    System.out.println(x.compareToIgnoreCase(y)>0 ? 1 : x.compareToIgnoreCase(y)<0 ?-1 : 0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mavenprojects {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : String ; x := sc.getCurrent() ;
     var y : String ; y := sc.getCurrent() ;
     OclFile["System.out"].println(if x->toLowerCase()->compareTo(y->toLowerCase()) > 0 then 1 else if x->toLowerCase()->compareTo(y->toLowerCase()) < 0 then -1 else 0 endif endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Aklsdjnsla {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s1=in.next();
    String s2=in.next();
    System.out.println(s1.compareToIgnoreCase(s2)<0 ?-1 : s1.compareToIgnoreCase(s2)>0 ? 1 : 0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Aklsdjnsla {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := in.getCurrent() ;
     var s2 : String ; s2 := in.getCurrent() ;
     OclFile["System.out"].println(if s1->toLowerCase()->compareTo(s2->toLowerCase()) < 0 then -1 else if s1->toLowerCase()->compareTo(s2->toLowerCase()) > 0 then 1 else 0 endif endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String a,b ;
    a=scan.nextLine();
    b=scan.nextLine();
    int c=a.toLowerCase().compareTo(b.toLowerCase());
    if(c>0)System.out.println(1);
    else if(c==0)System.out.println(0);
    else System.out.println(-1);
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ;
    var b : String ;
    a := scan.nextLine() ; 
    b := scan.nextLine() ; 
    var c : int ; c := a->toLowerCase()->compareTo(b->toLowerCase()) ;
    if (c > 0) then     OclFile["System.out"].println(1) else     if (c = 0) then     OclFile["System.out"].println(0) else     OclFile["System.out"].println(-1) ; ;  ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int[] a=new int[26];
    int sum=0 ;
    for(int i=0 ; i<s.length(); i++){
      a[s.charAt(i)-'a']++;
    }
    for(int i=0 ; i<26 ; i++){
      sum+=a[i] % 2 ;
    }
    System.out.println(sum/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var a : Sequence(int) ; a := Integer.subrange(1,26)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     a[s->at(i+1) - ('a')->char2byte()+1] := a[s->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 26 do ( (     sum := sum+(a[i+1] mod 2) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] Z)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer stz ;
    int n=Integer.parseInt(br.readLine());
    ArrayList<ArrayList<Integer>>companies=new ArrayList<>(n);
    int[] max=new int[n];
    for(int i=0 ; i<n ; i++){
      stz=new StringTokenizer(br.readLine());
      int m=Integer.parseInt(stz.nextToken());
      int currMax=Integer.MIN_VALUE ;
      ArrayList<Integer>list=new ArrayList<>(m);
      for(int j=0 ; j<m ; j++){
        list.add(Integer.parseInt(stz.nextToken()));
        currMax=Math.max(currMax,list.get(j));
      }
      companies.add(list);
      max[i]=currMax ;
    }
    long allMax=Integer.MIN_VALUE ;
    long ans=0 ;
    for(int e : max)allMax=Math.max(allMax,e);
    for(int i=0 ; i<n ; i++){
      if(allMax!=max[i]){
        long size=companies.get(i).size();
        long diff=allMax-max[i];
        long toAdd=size*diff ;
        ans+=toAdd ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( Z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var stz : OclIterator ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var companies : Sequence(Sequence(int)) ; companies := Sequence{} ;
    var max : Sequence(int) ; max := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     stz := OclIterator.newOclIterator_String(br.readLine()) ; 
     var m : int ; m := (stz.next())->toInteger() ;
    var currMax : int ; currMax := -2147483648 ;
    var list : Sequence(int) ; list := Sequence{} ;
        var j : int ; j := 0 ; while j < m do ( (     list := list->including((stz.next())->toInteger()) ; 
     currMax := Set{currMax, list->at(j+1)}->max() )  ;     j := j + 1 ) ; 
    companies := companies->including(list) ; 
    max[i+1] := currMax ; 
 )  ;     i := i + 1 ) ; 
    var allMax : long ; allMax := -2147483648 ;
    var ans : long ; ans := 0 ;
    for (e : max) do (     allMax := Set{allMax, e}->max() ;  ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (allMax /= max[i+1]) then (     var size : long ; size := companies->at(i+1)->size() ;
     var diff : long ; diff := allMax - max[i+1] ;
     var toAdd : long ; toAdd := size * diff ;
     ans := ans+(toAdd) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    long dp[][]=new long[n][2];
    long global_max=-1 ;
    for(int i=0 ; i<n ; i++){
      long m=s.nextLong();
      dp[i][0]=m ;
      long curr_max=-1 ;
      for(int j=0 ; j<m ; j++){
        curr_max=Math.max(curr_max,s.nextLong());
        global_max=Math.max(global_max,curr_max);
      }
      dp[i][1]=curr_max ;
    }
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      ans+=(global_max-dp[i][1])*dp[i][0];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
    var global_max : long ; global_max := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var m : long ; m := s.getCurrent()->toLong() ;
     dp[i+1][0+1] := m ; 
    var curr_max : long ; curr_max := -1 ;
        var j : int ; j := 0 ; while j < m do ( (     curr_max := Set{curr_max, s.getCurrent()->toLong()}->max() ; 
     global_max := Set{global_max, curr_max}->max() )  ;     j := j + 1 ) ; 
    dp[i+1][1+1] := curr_max ; 
 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans+((global_max - dp[i+1][1+1]) * dp[i+1][0+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int hammingDistance(int x,int y){
    return Integer.bitCount(x ^ y);
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation hammingDistance( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return bitCount(x xor y) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] as=br.readLine().split(" ");
    int[] ar=new int[n];
    int sum=0 ;
    int max=0,min=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      ar[i]=Integer.parseInt(as[i]);
      sum+=ar[i];
      max=Math.max(max,ar[i]);
      min=Math.min(min,ar[i]);
    }
    int average=sum/n ;
    int res=0 ;
    int res2=0 ;
    int res3=0 ;
    for(int i=0 ; i<n ; i++){
      res+=(ar[i]-average)*(ar[i]-average);
      res2+=(ar[i]-average-1)*(ar[i]-average-1);
      res3+=(ar[i]-average+1)*(ar[i]-average+1);
    }
    int gati_res=Math.min(res,res2);
    gati_res=Math.min(gati_res,res3);
    System.out.println(gati_res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var as : Sequence(String) ; as := br.readLine()->split(" ") ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
    var max : int ; max := 0 ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := (as[i+1])->toInteger() ; 
     sum := sum+(ar[i+1]) ; 
     max := Set{max, ar[i+1]}->max() ; 
     min := Set{min, ar[i+1]}->min() )  ;     i := i + 1 ) ; 
    var average : int ; average := sum / n ;
    var res : int ; res := 0 ;
    var res2 : int ; res2 := 0 ;
    var res3 : int ; res3 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     res := res+((ar[i+1] - average) * (ar[i+1] - average)) ; 
     res2 := res2+((ar[i+1] - average - 1) * (ar[i+1] - average - 1)) ; 
     res3 := res3+((ar[i+1] - average + 1) * (ar[i+1] - average + 1)) )  ;     i := i + 1 ) ; 
    var gati_res : int ; gati_res := Set{res, res2}->min() ;
    gati_res := Set{gati_res, res3}->min() ; 
    OclFile["System.out"].println(gati_res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findRotations(String str){
    String tmp=str+str ;
    int n=str.length();
    for(int i=1 ; i<=n ; i++){
      String substring=tmp.substring(i,str.length());
      if(str==substring)return i ;
    }
    return n ;
  }
  public static void main(String[] args){
    String str="abc" ;
    System.out.println(findRotations(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findRotations( str : String) : int
  pre: true
  post: true
  activity: (     var tmp : String ; tmp := str + str ;
     var n : int ; n := str->size() ;
         var i : int ; i := 1 ; while i <= n do ( (     var substring : String ; substring := tmp.subrange(i+1,str->size()) ;
     if (str = substring) then     return i else skip )  ;     i := i + 1 ) ; 
     return n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abc" ;
     OclFile["System.out"].println(findRotations(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class GFG {
  public static int sumDivisorsOfDivisors(int n){
    HashMap<Integer,Integer>mp=new HashMap<>();
    for(int j=2 ; j<=Math.sqrt(n); j++){
      int count=0 ;
      while(n % j==0){
        n/=j ;
        count++;
      }
      if(count!=0)mp.put(j,count);
    }
    if(n!=1)mp.put(n,1);
    int ans=1 ;
    for(HashMap.Entry<Integer,Integer>entry : mp.entrySet()){
      int pw=1 ;
      int sum=0 ;
      for(int i=entry.getValue()+1 ; i>=1 ; i--){
        sum+=(i*pw);
        pw=entry.getKey();
      }
      ans*=sum ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(sumDivisorsOfDivisors(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumDivisorsOfDivisors( n : int) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var j : int ; j := 2 ; while j <= (n)->sqrt() do ( (     var count : int ; count := 0 ;
     while (n mod j = 0) do (     n := n/(j) ; 
     count := count + 1 ) ; 
     if (count /= 0) then     mp := mp->union(Map{j |-> count}) ; else skip )  ;     j := j + 1 ) ; 
    if (n /= 1) then     mp := mp->union(Map{n |-> 1}) ; else skip ; 
    var ans : int ; ans := 1 ;
    for (entry : mp->asSet()) do ( (     var pw : int ; pw := 1 ;
     var sum : int ; sum := 0 ;
         var i : int ; i := entry.getValue() + 1 ; while i >= 1 do ( (     sum := sum+((i * pw)) ; 
     pw := entry.getKey() )  ;     i := i - 1 ) ; 
     ans := ans*(sum) )  ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(sumDivisorsOfDivisors(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    List<Integer>list=new ArrayList<Integer>();
    int n2=n*2 ;
    for(int i=0 ; i<n2 ; ++i){
      list.add(i+1);
    }
    int m=stdIn.nextInt();
    for(int i=0 ; i<m ; ++i){
      int k=stdIn.nextInt();
      if(k==0){
        List<Integer>listBuf=new ArrayList<Integer>();
        for(int j=0 ; j<list.size(); ++j){
          listBuf.add(list.get(j));
        }
        list.clear();
        for(int j=0 ; j<n ; ++j){
          list.add(listBuf.get(j));
          list.add(listBuf.get(n+j));
        }
      }
      else {
        List<Integer>listBuf=new ArrayList<Integer>();
        for(int j=0 ; j<list.size(); ++j){
          listBuf.add(list.get(j));
        }
        list.clear();
        for(int j=k ; j<n2 ; ++j){
          list.add(listBuf.get(j));
        }
        for(int j=0 ; j<k ; ++j){
          list.add(listBuf.get(j));
        }
      }
    }
    for(int i=0 ; i<n2 ; ++i){
      System.out.println(list.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
    var n2 : int ; n2 := n * 2 ;
        var i : int ; i := 0 ; while i < n2 do ( (     list := list->including(i + 1) )  ;     i := i + 1 ) ; 
    var m : int ; m := stdIn.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     var k : int ; k := stdIn.getCurrent()->toInteger() ;
     if (k = 0) then (     var listBuf : Sequence(int) ; listBuf := Sequence{} ;
         var j : int ; j := 0 ; while j < list->size() do ( (     listBuf := listBuf->including(list->at(j+1)) )  ;     j := j + 1 ) ; 
     list := list->intersection(Set{}) ; 
         var j : int ; j := 0 ; while j < n do ( (     list := list->including(listBuf->at(j+1)) ; 
     list := list->including(listBuf->at(n + j+1)) )  ;     j := j + 1 ) ) else (     var listBuf : Sequence(int) ; listBuf := Sequence{} ;
         var j : int ; j := 0 ; while j < list->size() do ( (     listBuf := listBuf->including(list->at(j+1)) )  ;     j := j + 1 ) ; 
    list := list->intersection(Set{}) ; 
        var j : int ; j := k ; while j < n2 do ( (     list := list->including(listBuf->at(j+1)) )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < k do ( (     list := list->including(listBuf->at(j+1)) )  ;     j := j + 1 ) ; 
 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n2 do ( (     OclFile["System.out"].println(list->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    int n=sc.nextInt();
    int[] a=new int[2*n];
    int[] b=new int[2*n];
    for(int i=0 ; i<2*n ; i++){
      a[i]=i+1 ;
    }
    int m=sc.nextInt();
    for(int j=0 ; j<m ; j++){
      int k=sc.nextInt();
      if(k==0){
        for(int i=0 ; i<n ; i++){
          b[2*i]=a[i];
          b[2*i+1]=a[i+n];
        }
      }
      else {
        for(int i=0 ; i<k ; i++){
          b[2*n-k+i]=a[i];
        }
        for(int i=0 ; i<2*n-k ; i++){
          b[i]=a[k+i];
        }
      }
      System.arraycopy(b,0,a,0,2*n);
    }
    for(int i=0 ; i<2*n ; i++){
      println(a[i]+"");
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,2 * n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,2 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     a[i+1] := i + 1 )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
        var j : int ; j := 0 ; while j < m do ( (     var k : int ; k := sc.getCurrent()->toInteger() ;
     if (k = 0) then (         var i : int ; i := 0 ; while i < n do ( (     b[2 * i+1] := a[i+1] ; 
     b[2 * i + 1+1] := a[i + n+1] )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < k do ( (     b[2 * n - k + i+1] := a[i+1] )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < 2 * n - k do ( (     b[i+1] := a[k + i+1] )  ;     i := i + 1 ) ) ;  
     for _x : Integer.subrange(1,2 * n) do a[0 + _x] := b[0 + _x] )  ;     j := j + 1 ) ; 
        var i : int ; i := 0 ; while i < 2 * n do ( (     execute println(a[i+1] + "") )  ;     i := i + 1 ) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String line ;
      int i=0,length=0 ;
      boolean first=true ;
      int[] card=null ;
      while((line=br.readLine())!=null){
        if(first){
          length=Integer.parseInt(line)*2 ;
          card=new int[length+1];
          for(int k=1 ; k<card.length ; k++){
            card[k]=k ;
          }
          i=Integer.parseInt(br.readLine());
          first=false ;
        }
        else {
          int move=Integer.parseInt(line);
          if(move==0){
            int[] n=new int[length+1];
            for(int k=1 ; k<length+1 ; k++){
              if(k % 2==1){
                n[k]=card[k/2+1];
              }
              else {
                n[k]=card[length/2+k/2];
              }
            }
            card=n.clone();
          }
          else {
            int[] n=new int[length+1];
            for(int k=move+1 ; k<length+1 ; k++){
              n[k-move]=card[k];
            }
            for(int k=1 ; k<move+1 ; k++){
              n[k+length-move]=card[k];
            }
            card=n.clone();
          }
          i--;
          if(i==0){
            for(int k=1 ; k<card.length ; k++){
              System.out.println(card[k]);
            }
            break ;
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var line : String ;
     var i : int ; i := 0 ;
    var length : int ; length := 0 ;
    var first : boolean ; first := true ;
    var card : Sequence(int) ; card := null ;
        line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     if (first) then (     length := (line)->toInteger() * 2 ; 
     card := Integer.subrange(1,length + 1)->collect(0) ; 
        var k : int ; k := 1 ; while k < card->size() do ( (     card[k+1] := k )  ;     k := k + 1 ) ; 
    i := (br.readLine())->toInteger() ; 
    first := false ; 
 ) else (     var move : int ; move := (line)->toInteger() ;
     if (move = 0) then (     var n : Sequence(int) ; n := Integer.subrange(1,length + 1)->collect(0) ;
         var k : int ; k := 1 ; while k < length + 1 do ( (     if (k mod 2 = 1) then (     n[k+1] := card[k / 2 + 1+1] ) else (     n[k+1] := card[length / 2 + k / 2+1] ) )  ;     k := k + 1 ) ; 
     card := n->copy() ) else (     var n : Sequence(int) ; n := Integer.subrange(1,length + 1)->collect(0) ;
         var k : int ; k := move + 1 ; while k < length + 1 do ( (     n[k - move+1] := card[k+1] )  ;     k := k + 1 ) ; 
         var k : int ; k := 1 ; while k < move + 1 do ( (     n[k + length - move+1] := card[k+1] )  ;     k := k + 1 ) ; 
     card := n->copy() ) ;  
     i := i - 1 ; 
     if (i = 0) then (         var k : int ; k := 1 ; while k < card->size() do ( (     OclFile["System.out"].println(card[k+1]) )  ;     k := k + 1 ) ; 
     break ) else skip ) ) ;     line := br.readLine() ;
 ) ;  
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    boolean[] a=new boolean[N+1];
    long odd=0 ;
    long even=0 ;
    long max=Long.MIN_VALUE ;
    int mp=-1 ;
    for(int i=1 ; i<=N ; ++i){
      long temp=sc.nextLong();
      if(temp>max){
        max=temp ;
        mp=i ;
      }
      if(temp>0){
        a[i]=true ;
        if(i % 2==1)odd+=temp ;
        else even+=temp ;
      }
    }
    if(odd==0 && even==0){
      System.out.println(max);
      System.out.println(N-1);
      for(int i=N ; i>mp ; --i){
        System.out.println(i);
      }
      for(int i=1 ; i<mp ; ++i){
        System.out.println(1);
      }
      return ;
    }
    System.out.println(Math.max(odd,even));
    int offset=odd>even ? 1 : 0 ;
    int p=N ;
    ArrayList<Integer>al=new ArrayList<Integer>();
    while(! a[p] ||(p+offset)% 2!=0){
      al.add(p);
      p--;
    }
    int left=0 ;
    while(! a[left] ||(left+offset)% 2!=0)left++;
    for(int i=p-2 ; i>=left ; i-=2){
      if(a[i])al.add(i+1);
      else al.add(i);
    }
    for(int i=1 ; i<left ; ++i)al.add(1);
    System.out.println(al.size());
    for(int i=0 ; i<al.size(); i++){
      System.out.println(al.get(i));
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(boolean) ; a := Integer.subrange(1,N + 1)->collect(false) ;
    var odd : long ; odd := 0 ;
    var even : long ; even := 0 ;
    var max : long ; max := "-9223372036854775808"->toLong() ;
    var mp : int ; mp := -1 ;
        var i : int ; i := 1 ; while i <= N do ( (     var temp : long ; temp := sc.getCurrent()->toLong() ;
     if (temp > max) then (     max := temp ; 
     mp := i ) else skip ; 
     if (temp > 0) then (     a[i+1] := true ; 
     if (i mod 2 = 1) then     odd := odd+(temp) ; else     even := even+(temp) ; ) else skip )  ;     i := i + 1 ) ; 
    if (odd = 0 & even = 0) then (     OclFile["System.out"].println(max) ; 
     OclFile["System.out"].println(N - 1) ; 
        var i : int ; i := N ; while i > mp do ( (     OclFile["System.out"].println(i) )  ;     i := i - 1 ) ; 
        var i : int ; i := 1 ; while i < mp do ( (     OclFile["System.out"].println(1) )  ;     i := i + 1 ) ; 
    return 
 ) else skip ; 
    OclFile["System.out"].println(Set{odd, even}->max()) ; 
    var offset : int ; offset := if odd > even then 1 else 0 endif ;
    var p : int ; p := N ;
    var al : Sequence(int) ; al := Sequence{} ;
    while (not(a[p+1]) or (p + offset) mod 2 /= 0) do (     al := al->including(p) ; 
     p := p - 1 ) ; 
    var left : int ; left := 0 ;
    while (not(a[left+1]) or (left + offset) mod 2 /= 0) do     left := left + 1 ; ; 
        var i : int ; i := p - 2 ; while i >= left do ( (     if (a[i+1]) then     al := al->including(i + 1) ; else     al := al->including(i) ; )  ;     i := i-(2) ) ; 
        var i : int ; i := 1 ; while i < left do (     al := al->including(1) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(al->size()) ; 
        var i : int ; i := 0 ; while i < al->size() do ( (     OclFile["System.out"].println(al->at(i+1)) )  ;     i := i + 1 ) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static Scanner s=new Scanner(System.in);
  public static void main(String[] args){
    int[] in=new int[s.nextInt()*2];
    for(int i=0 ; i<in.length ; i++)in[i]=i+1 ;
    int b ;
    for(int i=s.nextInt(); i>0 ; --i)if((b=Integer.parseInt(s.next()))==0)riffle(in);
    else cut(in,b);
    System.out.println(Arrays.toString(in).replaceAll("[^0-9,] ","").replaceAll(",","\n"));
  }
  static void cut(int[] in,int k){
    int[] b=Arrays.copyOfRange(in,0,k);
    for(int i=0 ; i<in.length-b.length ; i++)in[i]=in[i+b.length];
    for(int i=0 ; i<b.length ; i++)in[in.length-b.length+i]=b[i];
  }
  static void riffle(int[] in){
    int[] b=Arrays.copyOfRange(in,0,in.length/2);
    int[] bb=Arrays.copyOfRange(in,in.length/2,in.length);
    for(int i=0 ; i<b.length ; i++){
      in[i*2]=b[i];
      in[i*2+1]=bb[i];
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : Sequence(int) ; in := Integer.subrange(1,s.getCurrent()->toInteger() * 2)->collect(0) ;
         var i : int ; i := 0 ; while i < in->size() do (     in[i+1] := i + 1 ;  ;     i := i + 1 ) ; 
    var b : int ;
        var i : int ; i := s.getCurrent()->toInteger() ; while i > 0 do (     if ((b) = 0) then     execute riffle(in) else     execute cut(in, b) ; ;   ;     i := i - 1 ) ; 
    OclFile["System.out"].println((in + "").replaceAllMatches("[^0-9,] ", "" ).replaceAllMatches(",", "\n" )) ; 
 );
  static   operation cut( in : Sequence(int), k : int) : void
  pre: true
  post: true
  activity: (     var b : Sequence(int) ; b := in.subrange(0+1,k) ;
         var i : int ; i := 0 ; while i < in->size() - b->size() do (     in[i+1] := in[i + b->size()+1] ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < b->size() do (     in[in->size() - b->size() + i+1] := b[i+1] ;  ;     i := i + 1 ) );
  static   operation riffle( in : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var b : Sequence(int) ; b := in.subrange(0+1,in->size() / 2) ;
     var bb : Sequence(int) ; bb := in.subrange(in->size() / 2+1,in->size()) ;
         var i : int ; i := 0 ; while i < b->size() do ( (     in[i * 2+1] := b[i+1] ; 
     in[i * 2 + 1+1] := bb[i+1] )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String[] a=sc.next().split("");
    for(int i=0 ; i<a.length ; i++){
      if(a[i] .equals("1")){
        a[i]="9" ;
      }
      else {
        a[i]="1" ;
      }
      System.out.print(a[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(String) ; a := sc.getCurrent()->split("") ;
         var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] = "1") then (     a[i+1] := "9" ) else (     a[i+1] := "1" ) ;  
     OclFile["System.out"].print(a[i+1]) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String in=br.readLine();
      String chr[]=in.split("");
      int a=Integer.parseInt(chr[0]);
      int b=Integer.parseInt(chr[1]);
      int c=Integer.parseInt(chr[2]);
      a=(a==1 ? 9 : 1);
      b=(b==1 ? 9 : 1);
      c=(c==1 ? 9 : 1);
      System.out.println(a*100+b*10+c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var in : String ; in := br.readLine() ;
     var chr : Sequence(String) ; chr := in->split("") ;
    var a : int ; a := (chr[0+1])->toInteger() ;
    var b : int ; b := (chr[1+1])->toInteger() ;
    var c : int ; c := (chr[2+1])->toInteger() ;
    a := (if a = 1 then 9 else 1 endif) ; 
    b := (if b = 1 then 9 else 1 endif) ; 
    c := (if c = 1 then 9 else 1 endif) ; 
    OclFile["System.out"].println(a * 100 + b * 10 + c) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.System.out ;
public class Main {
  static MyReader in=new MyReader();
  public static void main(String[] args){
    int N=in.i();
    int[] X=in.ii();
    int sum=0 ;
    int sum2=0 ;
    for(int i=0 ; i<X.length ; i++){
      int xi=X[i];
      sum+=xi ;
      sum2+=xi*xi ;
    }
    int y=sum % N*2<N ? sum/N : sum/N+1 ;
    int ans=y*(N*y-2*sum)+sum2 ;
    out.println(ans);
  }
  static class MyReader extends BufferedReader {
    MyReader(){
      super(new InputStreamReader(System.in));
    }
    String s(){
      try {
        return readLine();
      }
      catch(IOException e){
        return "" ;
      }
    }
    String[] ss(){
      return s().split(" ");
    }
    int i(){
      return Integer.parseInt(s());
    }
    int[] ii(){
      String[] ss=ss();
      int[] ii=new int[ss.length];
      for(int j=0 ; j<ss.length ; j++)ii[j]=Integer.parseInt(ss[j]);
      return ii ;
    }
    ArrayList<Integer>li(){
      String[] ss=ss();
      ArrayList<Integer>li=new ArrayList<>();
      for(int j=0 ; j<ss.length ; j++)li.add(Integer.parseInt(ss[j]));
      return li ;
    }
    long l(){
      return Long.parseLong(s());
    }
    long[] ll(){
      String[] ss=ss();
      long[] ll=new long[ss.length];
      for(int j=0 ; j<ss.length ; j++)ll[j]=Long.parseLong(ss[j]);
      return ll ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : MyReader := MyReader.newMyReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.i() ;
     var X : Sequence(int) ; X := in.ii() ;
    var sum : int ; sum := 0 ;
    var sum2 : int ; sum2 := 0 ;
        var i : int ; i := 0 ; while i < X->size() do ( (     var xi : int ; xi := X[i+1] ;
     sum := sum+(xi) ; 
     sum2 := sum2+(xi * xi) )  ;     i := i + 1 ) ; 
    var y : int ; y := if sum mod N * 2 < N then sum / N else sum / N + 1 endif ;
    var ans : int ; ans := y * (N * y - 2 * sum) + sum2 ;
    out.println(ans) ; 
 );
  static class MyReader extends OclFile {
   static operation newMyReader() : MyReader
  pre: true
  post: true
  activity:
  ( var self : MyReader ;
    self := createMyReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation s() : String
  pre: true
  post: true
  activity: (     try (     return readLine() )   catch (e : IOException) do (     return "" )
 );
   operation ss() : Sequence(String)
  pre: true
  post: true
  activity: (     return s()->split(" ") );
   operation i() : int
  pre: true
  post: true
  activity: (     return (s())->toInteger() );
   operation ii() : Sequence(int)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var ii : Sequence(int) ; ii := Integer.subrange(1,ss->size())->collect(0) ;
         var j : int ; j := 0 ; while j < ss->size() do (     ii[j+1] := (ss[j+1])->toInteger() ;  ;     j := j + 1 ) ; 
     return ii );
   operation li() : Sequence(int)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var li : Sequence(int) ; li := Sequence{} ;
         var j : int ; j := 0 ; while j < ss->size() do (     li := li->including((ss[j+1])->toInteger()) ;  ;     j := j + 1 ) ; 
     return li );
   operation l() : long
  pre: true
  post: true
  activity: (     return (s())->toLong() );
   operation ll() : Sequence(long)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var ll : Sequence(long) ; ll := Integer.subrange(1,ss->size())->collect(0) ;
         var j : int ; j := 0 ; while j < ss->size() do (     ll[j+1] := (ss[j+1])->toLong() ;  ;     j := j + 1 ) ; 
     return ll );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  void solve(){
    char[] a=incharar();
    for(int i=0 ; i<a.length ; i++){
      if(a[i]=='1')a[i]='9' ;
      else if(a[i]=='9')a[i]='1' ;
    }
    out.println(String.valueOf(a));
  }
  public static Scanner in=new Scanner(System.in);
  public static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    new Main().solve();
    out.flush();
  }
  public int inint(){
    return in.nextInt();
  }
  public String instr(){
    return in.next();
  }
  public char[] incharar(){
    return in.next().toCharArray();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := incharar() ;
         var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] = '1') then     a[i+1] := '9' ; else     if (a[i+1] = '9') then     a[i+1] := '1' ; else skip ; )  ;     i := i + 1 ) ; 
     out.println((a)->sum() ) );
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() ; 
     skip );
   operation inint() : int
  pre: true
  post: true
  activity: (     return in.getCurrent()->toInteger() );
   operation instr() : String
  pre: true
  post: true
  activity: (     return in.getCurrent() );
   operation incharar() : Sequence(String)
  pre: true
  post: true
  activity: (     return in.getCurrent()->characters() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javax.print.DocFlavor ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigDecimal ;
import java.math.BigInteger ;
import java.nio.charset.StandardCharsets ;
import java.util.*;
import java.util.function.BiConsumer ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    String n=sc.next();
    for(int i=0 ; i<n.length(); i++){
      if(n.charAt(i)=='1')System.out.print('9');
      if(n.charAt(i)=='9')System.out.print('1');
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : String ; n := sc.getCurrent() ;
         var i : int ; i := 0 ; while i < n->size() do ( (     if (n->at(i+1) = '1') then     OclFile["System.out"].print('9') ; else skip ; 
     if (n->at(i+1) = '9') then     OclFile["System.out"].print('1') ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.TreeMap ;
class Count {
  static int countPairs(int[] a,int n){
    TreeMap<Integer,Integer>map=new TreeMap<>();
    for(int i=0 ; i<n ; i++){
      map.put(a[i],1);
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(map.get(a[i])<1)continue ;
      int cur=1 ;
      while(cur<=a[i])cur<<=1 ;
      if(map.containsKey(cur-a[i])){
        if(cur-a[i]==a[i] && map.get(a[i])==1)continue ;
        count++;
        map.put(cur-a[i],map.get(cur-a[i])-1);
        map.put(a[i],map.get(a[i])-1);
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int[] a={
      3,11,14,5,13 };
      int n=a.length ;
      System.out.println(countPairs(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Count {
  static   operation countPairs( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var map : Map(int,int) ; map := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     map := map->union(Map{a[i+1] |-> 1}) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (map->at(a[i+1]) < 1) then     continue else skip ; 
     var cur : int ; cur := 1 ;
     while (cur <= a[i+1]) do     cur := cur*(2->pow(1)) ; ; 
     if (map->keys()->includes(cur - a[i+1])) then (     if (cur - a[i+1] = a[i+1] & map->at(a[i+1]) = 1) then     continue else skip ; 
     count := count + 1 ; 
     map := map->union(Map{cur - a[i+1] |-> map->at(cur - a[i+1]) - 1}) ; 
     map := map->union(Map{a[i+1] |-> map->at(a[i+1]) - 1}) ) else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{3,11,14,5,13} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(countPairs(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean check(int arr[],int N,int K){
    HashSet<Integer>unique=new HashSet<Integer>();
    for(int i=0 ; i<N ; i++)unique.add(arr[i]);
    if(unique.size()==K)return true ;
    return false ;
  }
  public static void main(String[] args){
    int arr[]={
      1,1,2,3 };
      int N=arr.length ;
      int K=3 ;
      if(check(arr,N,K))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( arr : Sequence(int), N : int, K : int) : boolean
  pre: true
  post: true
  activity: (     var unique : Set(int) ; unique := Set{} ;
         var i : int ; i := 0 ; while i < N do (     unique := unique->including(arr[i+1]) ;  ;     i := i + 1 ) ; 
     if (unique->size() = K) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,2,3} ;
     var N : int ; N := arr->size() ;
     var K : int ; K := 3 ;
     if (check(arr, N, K)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int complement(int num){
    int i,len=0,temp,comp ;
    temp=num ;
    while(true){
      len++;
      num=num/10 ;
      if(Math.abs(num)==0)break ;
    }
    num=temp ;
    comp=(int)Math.pow(10,len)-num ;
    return comp ;
  }
  public static void main(String[] args){
    System.out.println(complement(25));
    System.out.println(complement(456));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation complement( num : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var len : int ; len := 0 ;
    var temp : int ;
    var comp : int ;
     temp := num ; 
    while (true) do (     len := len + 1 ; 
     num := num / 10 ; 
     if (if num < 0 then -(num) else num endif = 0) then     break else skip ) ; 
    num := temp ; 
    comp := 10->pow(len)->oclAsType(int) - num ; 
    return comp 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(complement(25)) ; 
     OclFile["System.out"].println(complement(456)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static int N=1001 ;
  public static int xx[]=new int[] {
    1,-1,0,0 };
    public static int yy[]=new int[] {
      0,0,1,-1 };
      public static int n ;
      public static int n1 ;
      public static int n2 ;
      public static int n3 ;
      public static int n4 ;
      public static int a1 ;
      public static int a2 ;
      public static int rs ;
      public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        n=scanner.nextInt();
        for(int i=0 ; i<n ; i++){
          n1=scanner.nextInt();
          n2=scanner.nextInt();
          n3=scanner.nextInt();
          n4=scanner.nextInt();
          a1=scanner.nextInt();
          a2=scanner.nextInt();
          rs=Math.abs(n1-n3)+Math.abs(n2-n4);
          if((a1<Math.max(n1,n3)&& a1>Math.min(n1,n3)&&(n2==n4)&&(n2==a2))||(a2<Math.max(n2,n4)&& a2>Math.min(n4,n2)&&(n1==n3)&&(n1==a1))){
            rs+=2 ;
          }
          System.out.println(rs);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int := 1001;
  static   attribute xx : int := Sequence{1,-1,0,0};
  static   attribute yy : int := Sequence{0,0,1,-1};
  static   attribute n : int;
  static   attribute n1 : int;
  static   attribute n2 : int;
  static   attribute n3 : int;
  static   attribute n4 : int;
  static   attribute a1 : int;
  static   attribute a2 : int;
  static   attribute rs : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := scanner.getCurrent()->toInteger() ; 
         var i : int ; i := 0 ; while i < n do ( (     n1 := scanner.getCurrent()->toInteger() ; 
     n2 := scanner.getCurrent()->toInteger() ; 
    n3 := scanner.getCurrent()->toInteger() ; 
    n4 := scanner.getCurrent()->toInteger() ; 
    a1 := scanner.getCurrent()->toInteger() ; 
    a2 := scanner.getCurrent()->toInteger() ; 
    rs := if n1 - n3 < 0 then -(n1 - n3) else n1 - n3 endif + if n2 - n4 < 0 then -(n2 - n4) else n2 - n4 endif ; 
    if ((a1 < Set{n1, n3}->max() & a1 > Set{n1, n3}->min() & (n2 = n4) & (n2 = a2)) or (a2 < Set{n2, n4}->max() & a2 > Set{n4, n2}->min() & (n1 = n3) & (n1 = a1))) then (     rs := rs+(2) ) else skip ; 
    OclFile["System.out"].println(rs) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  BufferedReader in ;
  PrintWriter out ;
  Main(){
    in=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(System.out);
  }
  void close()throws IOException {
    in.close();
    out.flush();
    out.close();
  }
  boolean between(int x1,int x2,int x3){
    return(x1<x2 && x2<x3)||(x1>x2 && x2>x3);
  }
  void solve()throws IOException {
    int t=Integer.parseInt(in.readLine());
    while(t>0){
      in.readLine();
      StringTokenizer st=new StringTokenizer(in.readLine());
      int xa=Integer.parseInt(st.nextToken())-1 ;
      int ya=Integer.parseInt(st.nextToken())-1 ;
      st=new StringTokenizer(in.readLine());
      int xb=Integer.parseInt(st.nextToken())-1 ;
      int yb=Integer.parseInt(st.nextToken())-1 ;
      st=new StringTokenizer(in.readLine());
      int xf=Integer.parseInt(st.nextToken())-1 ;
      int yf=Integer.parseInt(st.nextToken())-1 ;
      int da=Math.abs(xa-xb);
      int db=Math.abs(ya-yb);
      int ans ;
      if((between(xa,xf,xb)&&(ya==yb && ya==yf))||(between(ya,yf,yb)&&(xa==xb && xa==xf))){
        ans=da+db+2 ;
      }
      else {
        ans=da+db ;
      }
      out.append(String.format("%d\n",ans));
      t--;
    }
  }
  public static void main(String[] args)throws IOException {
    Main m=new Main();
    m.solve();
    m.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile;
   attribute out : OclFile;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) );
   operation close() : void
  pre: true
  post: true
  activity: (     skip ; 
     skip ; 
     skip );
   operation between( x1 : int, x2 : int, x3 : int) : boolean
  pre: true
  post: true
  activity: (     return (x1 < x2 & x2 < x3) or (x1 > x2 & x2 > x3) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var t : int ; t := (in.readLine())->toInteger() ;
     while (t > 0) do (     skip ; 
     var st : OclIterator ; st := OclIterator.newOclIterator_String(in.readLine()) ;
    var xa : int ; xa := (st.next())->toInteger() - 1 ;
    var ya : int ; ya := (st.next())->toInteger() - 1 ;
    st := OclIterator.newOclIterator_String(in.readLine()) ; 
    var xb : int ; xb := (st.next())->toInteger() - 1 ;
    var yb : int ; yb := (st.next())->toInteger() - 1 ;
    st := OclIterator.newOclIterator_String(in.readLine()) ; 
    var xf : int ; xf := (st.next())->toInteger() - 1 ;
    var yf : int ; yf := (st.next())->toInteger() - 1 ;
    var da : int ; da := if xa - xb < 0 then -(xa - xb) else xa - xb endif ;
    var db : int ; db := if ya - yb < 0 then -(ya - yb) else ya - yb endif ;
    var ans : int ;
    if ((between(xa, xf, xb) & (ya = yb & ya = yf)) or (between(ya, yf, yb) & (xa = xb & xa = xf))) then (     ans := da + db + 2 ) else (     ans := da + db ) ;  
    skip ; 
    t := t - 1 ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.solve() ; 
     m.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class e {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int A_x=sc.nextInt();
      int A_y=sc.nextInt();
      int B_x=sc.nextInt();
      int B_y=sc.nextInt();
      int F_x=sc.nextInt();
      int F_y=sc.nextInt();
      int dx1=F_x-A_x ;
      int dx2=F_x-B_x ;
      int dy1=F_y-A_y ;
      int dy2=F_y-B_y ;
      if(A_x==B_x && B_x==F_x &&(((dy1<0)&(dy2>0))|((dy1>0)&(dy2<0)))){
        System.out.println(Math.abs((A_x-B_x))+Math.abs((A_y-B_y))+2);
      }
      else if(A_y==B_y && B_y==F_y &&(((dx1<0)&(dx2>0))|((dx1>0)&(dx2<0)))){
        System.out.println(Math.abs((A_x-B_x))+Math.abs((A_y-B_y))+2);
      }
      else {
        System.out.println(Math.abs((A_x-B_x))+Math.abs((A_y-B_y)));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class e {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var A_x : int ; A_x := sc.getCurrent()->toInteger() ;
     var A_y : int ; A_y := sc.getCurrent()->toInteger() ;
    var B_x : int ; B_x := sc.getCurrent()->toInteger() ;
    var B_y : int ; B_y := sc.getCurrent()->toInteger() ;
    var F_x : int ; F_x := sc.getCurrent()->toInteger() ;
    var F_y : int ; F_y := sc.getCurrent()->toInteger() ;
    var dx1 : int ; dx1 := F_x - A_x ;
    var dx2 : int ; dx2 := F_x - B_x ;
    var dy1 : int ; dy1 := F_y - A_y ;
    var dy2 : int ; dy2 := F_y - B_y ;
    if (A_x = B_x & B_x = F_x & (((dy1 < 0) & (dy2 > 0)) or ((dy1 > 0) & (dy2 < 0)))) then (     OclFile["System.out"].println(if (A_x - B_x) < 0 then -((A_x - B_x)) else (A_x - B_x) endif + if (A_y - B_y) < 0 then -((A_y - B_y)) else (A_y - B_y) endif + 2) ) else     if (A_y = B_y & B_y = F_y & (((dx1 < 0) & (dx2 > 0)) or ((dx1 > 0) & (dx2 < 0)))) then (     OclFile["System.out"].println(if (A_x - B_x) < 0 then -((A_x - B_x)) else (A_x - B_x) endif + if (A_y - B_y) < 0 then -((A_y - B_y)) else (A_y - B_y) endif + 2) ) else (     OclFile["System.out"].println(if (A_x - B_x) < 0 then -((A_x - B_x)) else (A_x - B_x) endif + if (A_y - B_y) < 0 then -((A_y - B_y)) else (A_y - B_y) endif) ) ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem1547A {
  public static Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    int tc=scanner.nextInt();
    while(tc-->0){
      int xA=scanner.nextInt();
      int yA=scanner.nextInt();
      int xB=scanner.nextInt();
      int yB=scanner.nextInt();
      int xF=scanner.nextInt();
      int yF=scanner.nextInt();
      int ans=0 ;
      if(((xA<xF && xF<xB)||(xB<xF && xF<xA))&&(yA==yF && yB==yF)){
        ans=Math.abs(xB-xA)+2 ;
      }
      else if(((yF>yA && yB>yF)||(yB<yF && yF<yA))&&(xA==xF && xB==xF)){
        ans=Math.abs(yA-yB)+2 ;
      }
      else {
        ans=Math.abs(xB-xA)+Math.abs(yB-yA);
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem1547A {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var tc : int ; tc := scanner.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var xA : int ; xA := scanner.getCurrent()->toInteger() ;
     var yA : int ; yA := scanner.getCurrent()->toInteger() ;
    var xB : int ; xB := scanner.getCurrent()->toInteger() ;
    var yB : int ; yB := scanner.getCurrent()->toInteger() ;
    var xF : int ; xF := scanner.getCurrent()->toInteger() ;
    var yF : int ; yF := scanner.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    if (((xA < xF & xF < xB) or (xB < xF & xF < xA)) & (yA = yF & yB = yF)) then (     ans := if xB - xA < 0 then -(xB - xA) else xB - xA endif + 2 ) else     if (((yF > yA & yB > yF) or (yB < yF & yF < yA)) & (xA = xF & xB = xF)) then (     ans := if yA - yB < 0 then -(yA - yB) else yA - yB endif + 2 ) else (     ans := if xB - xA < 0 then -(xB - xA) else xB - xA endif + if yB - yA < 0 then -(yB - yA) else yB - yA endif ) ;  ;  
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public void run(){
    Scanner sc=new Scanner(System.in);
    int m=sc.nextInt();
    int n=sc.nextInt();
    double[][] p=new double[m][n];
    for(int i=0 ; i<m ; ++i){
      for(int j=0 ; j<n ; ++j){
        p[i][j]=sc.nextDouble();
      }
    }
    double[][] prob=new double[n+1][1<<m];
    Arrays.fill(prob[n],1);
    for(int s=(1<<m)-2 ; s>=0 ; --s){
      for(int i=0 ; i<n ; ++i){
        for(int j=0 ; j<m ; ++j){
          if((s>>j)% 2==1)continue ;
          double tmp=0 ;
          double mul=1 ;
          for(int k=i ; k<=n ; ++k){
            tmp+=prob[k][s | 1<<j]*mul*(1-(k==n ? 0 : p[j][k]));
            if(k<n)mul*=p[j][k];
          }
          prob[i][s]=Math.max(prob[i][s],tmp);
        }
      }
    }
    System.out.println(String.format("%.40f",prob[0][0]));
  }
  void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var p : Sequence(Sequence(double)) ; p := Integer.subrange(1,m)->collect(Integer.subrange(1,n)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j < n do ( (     p[i+1][j+1] := sc.getCurrent()->toReal() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var prob : Sequence(Sequence(double)) ; prob := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,(1*(2->pow(m)))->oclAsType(long))->collect(0.0)) ;
    prob[n+1] := prob[n+1]->collect(1) ; 
        var s : int ; s := ((1*(2->pow(m)))->oclAsType(long)) - 2 ; while s >= 0 do ( (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (((s/(2->pow(j)))->oclAsType(long)) mod 2 = 1) then     continue else skip ; 
     var tmp : double ; tmp := 0 ;
    var mul : double ; mul := 1 ;
        var k : int ; k := i ; while k <= n do ( (     tmp := tmp+(prob[k+1][MathLib.bitwiseOr(s,(1*(2->pow(j)))->oclAsType(long))+1] * mul * (1 - (if k = n then 0 else p[j+1][k+1] endif))) ; 
     if (k < n) then     mul := mul*(p[j+1][k+1]) ; else skip )  ;     k := k + 1 ) ; 
    prob[i+1][s+1] := Set{prob[i+1][s+1], tmp}->max() ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     s := s - 1 ) ; 
    OclFile["System.out"].println(StringLib.format("%.40f",Sequence{prob[0+1][0+1]})) ; 
 );
   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    abc156_c solver=new abc156_c();
    solver.solve(1,in,out);
    out.close();
  }
  static class abc156_c {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int N=in.nextInt();
      int x[]=new int[N];
      for(int i=0 ; i<N ; i++){
        x[i]=in.nextInt();
      }
      int min=Integer.MAX_VALUE ;
      for(int i=1 ; i<=100 ; i++){
        int val=0 ;
        for(int j=0 ; j<N ; j++){
          val+=(x[j]-i)*(x[j]-i);
        }
        min=Math.min(min,val);
      }
      out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : abc156_c ; solver := abc156_c.newabc156_c() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class abc156_c {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
     var x : Sequence(int) ; x := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     x[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
        var i : int ; i := 1 ; while i <= 100 do ( (     var val : int ; val := 0 ;
         var j : int ; j := 0 ; while j < N do ( (     val := val+((x[j+1] - i) * (x[j+1] - i)) )  ;     j := j + 1 ) ; 
     min := Set{min, val}->min() )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int N,M ;
  static double[][] P ;
  static double[][] memo ;
  public static void main(String[] arg){
    M=sc.nextInt();
    N=sc.nextInt();
    P=new double[M][N];
    memo=new double[N+1][1<<M];
    for(double[] a : memo){
      Arrays.fill(a,-1);
    }
    for(int i=0 ; i<M ; ++i){
      for(int j=0 ; j<N ; ++j){
        P[i][j]=sc.nextDouble();
      }
    }
    System.out.printf("%.9f\n",rec(0,0));
  }
  static double rec(int pos,int st){
    if(pos==N)return 1 ;
    if(memo[pos][st]!=-1)return memo[pos][st];
    double ret=0 ;
    for(int i=0 ; i<M ; ++i){
      if((st &(1<<i))!=0)continue ;
      double prob=0 ;
      int nst=st+(1<<i);
      double np=1 ;
      for(int j=pos ; j<N ; ++j){
        prob+=np*(1-P[i][j])*rec(j,nst);
        np*=P[i][j];
      }
      prob+=np*rec(N,nst);
      ret=Math.max(ret,prob);
    }
    memo[pos][st]=ret ;
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int;
  static   attribute P : Sequence(Sequence(double));
  static   attribute memo : Sequence(Sequence(double));
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     M := sc.getCurrent()->toInteger() ; 
     N := sc.getCurrent()->toInteger() ; 
    P := Integer.subrange(1,M)->collect(Integer.subrange(1,N)->collect(0.0)) ; 
    memo := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,(1*(2->pow(M)))->oclAsType(long))->collect(0.0)) ; 
    for (a : memo) do ( (     a := a->collect(-1) )  ) ; 
        var i : int ; i := 0 ; while i < M do ( (         var j : int ; j := 0 ; while j < N do ( (     P[i+1][j+1] := sc.getCurrent()->toReal() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.9f\n", rec(0, 0)) ; 
 );
  static   operation rec( pos : int, st : int) : double
  pre: true
  post: true
  activity: (     if (pos = N) then     return 1 else skip ; 
     if (memo[pos+1][st+1] /= -1) then     return memo[pos+1][st+1] else skip ; 
    var ret : double ; ret := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     if ((st & ((1*(2->pow(i)))->oclAsType(long))) /= 0) then     continue else skip ; 
     var prob : double ; prob := 0 ;
    var nst : int ; nst := st + ((1*(2->pow(i)))->oclAsType(long)) ;
    var np : double ; np := 1 ;
        var j : int ; j := pos ; while j < N do ( (     prob := prob+(np * (1 - P[i+1][j+1]) * rec(j, nst)) ; 
     np := np*(P[i+1][j+1]) )  ;     j := j + 1 ) ; 
    prob := prob+(np * rec(N, nst)) ; 
    ret := Set{ret, prob}->max() ; 
 )  ;     i := i + 1 ) ; 
    memo[pos+1][st+1] := ret ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HitTheLottery {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int bills=0 ;
    while(n/100>0){
      bills++;
      n-=100 ;
    }
    while(n/20>0){
      bills++;
      n-=20 ;
    }
    while(n/10>0){
      bills++;
      n-=10 ;
    }
    while(n/5>0){
      bills++;
      n-=5 ;
    }
    bills+=n ;
    System.out.println(bills);
  }
}
------------------------------------------------------------
OCL File:
---------
 class HitTheLottery {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var bills : int ; bills := 0 ;
    while (n / 100 > 0) do (     bills := bills + 1 ; 
     n := n-(100) ) ; 
    while (n / 20 > 0) do (     bills := bills + 1 ; 
     n := n-(20) ) ; 
    while (n / 10 > 0) do (     bills := bills + 1 ; 
     n := n-(10) ) ; 
    while (n / 5 > 0) do (     bills := bills + 1 ; 
     n := n-(5) ) ; 
    bills := bills+(n) ; 
    OclFile["System.out"].println(bills) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A996 {
  public static void main(String[] args){
    int[] arr=new int[] {
      100,20,10,5,1 };
      Scanner in=new Scanner(System.in);
      int n=in.nextInt();
      int res=0 ;
      for(int i=0 ; i<5 ; i++){
        res+=n/arr[i];
        n %=arr[i];
      }
      System.out.println(res);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class A996 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{100,20,10,5,1} ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < 5 do ( (     res := res+(n / arr[i+1]) ; 
     n := n mod arr[i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class QQQ {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int i=0 ;
    long num=in.nextLong();
    while(num>0){
      if(num>=100){
        num-=100 ;
        i++;
      }
      else if(num>=20){
        num-=20 ;
        i++;
      }
      else if(num>=10){
        num-=10 ;
        i++;
      }
      else if(num>=5){
        num-=5 ;
        i++;
      }
      else if(num>=1){
        num-=1 ;
        i++;
      }
    }
    System.out.println(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class QQQ {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ; i := 0 ;
    var num : long ; num := in.getCurrent()->toLong() ;
    while (num > 0) do (     if (num >= 100) then (     num := num-(100) ; 
     i := i + 1 ) else     if (num >= 20) then (     num := num-(20) ; 
     i := i + 1 ) else     if (num >= 10) then (     num := num-(10) ; 
     i := i + 1 ) else     if (num >= 5) then (     num := num-(5) ; 
     i := i + 1 ) else     if (num >= 1) then (     num := num-(1) ; 
     i := i + 1 ) else skip ; ;  ;  ;  ) ; 
    OclFile["System.out"].println(i) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static boolean slove(char a,char b,char c){
    if(a==b && b==c)return true ;
    else return false ;
  }
  public static void main(String args[]){
    Scanner input=new Scanner(System.in);
    String s=input.next();
    int l=0 ;
    int n=s.length();
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i ; j<n ; j++){
        int flag=0 ;
        for(int k=1 ; j-(2*k)>=i ; k++){
          if(slove(s.charAt(j),s.charAt(j-k),s.charAt(j-2*k))){
            ans+=n-j ;
            flag=1 ;
            break ;
          }
        }
        if(flag==1)break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation slove( a : String, b : String, c : String) : boolean
  pre: true
  post: true
  activity: (     if (a = b & b = c) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := input.getCurrent() ;
    var l : int ; l := 0 ;
    var n : int ; n := s->size() ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i ; while j < n do ( (     var flag : int ; flag := 0 ;
         var k : int ; k := 1 ; while j - (2 * k) >= i do ( (     if (slove(s->at(j+1), s->at(j - k+1), s->at(j - 2 * k+1))) then (     ans := ans+(n - j) ; 
     flag := 1 ; 
     break ) else skip )  ;     k := k + 1 ) ; 
     if (flag = 1) then     break else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Application {
  public static void main(String[] something){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    System.out.println(n/100+n/20 % 5+n/10 % 2+n/5 % 2+n % 5);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Application {
  static   operation main( something : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
     OclFile["System.out"].println(n / 100 + n / 20 mod 5 + n / 10 mod 2 + n / 5 mod 2 + n mod 5) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HitTheLottery {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int bills=0 ;
    bills+=n/100 ;
    n-=n/100*100 ;
    bills+=n/20 ;
    n-=n/20*20 ;
    bills+=n/10 ;
    n-=n/10*10 ;
    bills+=n/5 ;
    n-=n/5*5 ;
    bills+=n ;
    System.out.println(bills);
  }
}
------------------------------------------------------------
OCL File:
---------
 class HitTheLottery {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var bills : int ; bills := 0 ;
    bills := bills+(n / 100) ; 
    n := n-(n / 100 * 100) ; 
    bills := bills+(n / 20) ; 
    n := n-(n / 20 * 20) ; 
    bills := bills+(n / 10) ; 
    n := n-(n / 10 * 10) ; 
    bills := bills+(n / 5) ; 
    n := n-(n / 5 * 5) ; 
    bills := bills+(n) ; 
    OclFile["System.out"].println(bills) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    long k=sc.nextLong();
    long[] sumA=new long[n];
    int idxA=-1 ;
    for(int i=0 ; i<n ; i++){
      if(i==0)sumA[i]=sc.nextLong();
      else sumA[i]=sumA[i-1]+sc.nextLong();
      if(sumA[i]<=k)idxA=i ;
    }
    int idxB=-1 ;
    long[] sumB=new long[m];
    for(int i=0 ; i<m ; i++){
      if(i==0)sumB[i]=sc.nextLong();
      else sumB[i]=sumB[i-1]+sc.nextLong();
      if(sumB[i]<=k)idxB=i ;
    }
    long max=Math.max(idxA,idxB)+1 ;
    int j=0 ;
    for(int i=idxA ; i>=0 ; i--){
      while(j<=idxB && k-sumA[i]>=sumB[j]){
        max=Math.max(max,i+1+j+1);
        j++;
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var sumA : Sequence(long) ; sumA := Integer.subrange(1,n)->collect(0) ;
    var idxA : int ; idxA := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i = 0) then     sumA[i+1] := sc.getCurrent()->toLong() else     sumA[i+1] := sumA[i - 1+1] + sc.getCurrent()->toLong() ; ;  
     if (sumA[i+1] <= k) then     idxA := i ; else skip )  ;     i := i + 1 ) ; 
    var idxB : int ; idxB := -1 ;
    var sumB : Sequence(long) ; sumB := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     if (i = 0) then     sumB[i+1] := sc.getCurrent()->toLong() else     sumB[i+1] := sumB[i - 1+1] + sc.getCurrent()->toLong() ; ;  
     if (sumB[i+1] <= k) then     idxB := i ; else skip )  ;     i := i + 1 ) ; 
    var max : long ; max := Set{idxA, idxB}->max() + 1 ;
    var j : int ; j := 0 ;
        var i : int ; i := idxA ; while i >= 0 do ( (     while (j <= idxB & k - sumA[i+1] >= sumB[j+1]) do (     max := Set{max, i + 1 + j + 1}->max() ; 
     j := j + 1 ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.PrintWriter ;
import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.Math.*;
import static java.lang.System.*;
public class Main {
  public static final int MOD=1000000007 ;
  public static int n ;
  public static int m ;
  public static long k ;
  public static long[] a ;
  public static long[] b ;
  public static void main(String[] args){
    int i,j ;
    Scanner sc=new Scanner(in);
    n=parseInt(sc.next());
    m=parseInt(sc.next());
    k=parseLong(sc.next());
    a=new long[n];
    for(i=0 ; i<n ; i++){
      a[i]=parseLong(sc.next());
    }
    b=new long[m];
    for(i=0 ; i<m ; i++){
      b[i]=parseLong(sc.next());
    }
    sc.close();
    long ans=0 ;
    long cnt=0 ;
    long tot=0 ;
    i=0 ;
    j=0 ;
    while(tot<=k && i<n){
      tot+=a[i];
      i++;
      cnt++;
    }
    if(tot>k){
      cnt--;
      i--;
      tot-=a[i];
    }
    ans=cnt ;
    j=0 ;
    for(i--; ; i--){
      while(tot<=k && j<m){
        tot+=b[j];
        j++;
        cnt++;
      }
      if(tot>k){
        cnt--;
        j--;
        tot-=b[j];
      }
      ans=Math.max(ans,cnt);
      if(i<0)break ;
      cnt--;
      tot-=a[i];
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1000000007;
  static   attribute n : int;
  static   attribute m : int;
  static   attribute k : long;
  static   attribute a : Sequence(long);
  static   attribute b : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
    n := (sc.getCurrent() + "")->toInteger() ; 
    m := (sc.getCurrent() + "")->toInteger() ; 
    k := parseLong(sc.getCurrent()) ; 
    a := Integer.subrange(1,n)->collect(0) ; 
        i := 0 ; while i < n do ( (     a[i+1] := parseLong(sc.getCurrent()) )  ;     i := i + 1 ) ; 
    b := Integer.subrange(1,m)->collect(0) ; 
        i := 0 ; while i < m do ( (     b[i+1] := parseLong(sc.getCurrent()) )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : long ; ans := 0 ;
    var cnt : long ; cnt := 0 ;
    var tot : long ; tot := 0 ;
    i := 0 ; 
    j := 0 ; 
    while (tot <= k & i < n) do (     tot := tot+(a[i+1]) ; 
     i := i + 1 ; 
     cnt := cnt + 1 ) ; 
    if (tot > k) then (     cnt := cnt - 1 ; 
     i := i - 1 ; 
     tot := tot-(a[i+1]) ) else skip ; 
    ans := cnt ; 
    j := 0 ; 
        i := i - 1 ; while true do ( (     while (tot <= k & j < m) do (     tot := tot+(b[j+1]) ; 
     j := j + 1 ; 
     cnt := cnt + 1 ) ; 
     if (tot > k) then (     cnt := cnt - 1 ; 
     j := j - 1 ; 
     tot := tot-(b[j+1]) ) else skip ; 
    ans := Set{ans, cnt}->max() ; 
    if (i < 0) then     break else skip ; 
    cnt := cnt - 1 ; 
    tot := tot-(a[i+1]) ; 
 )  ;     i := i - 1 ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=sc.nextInt(),M=sc.nextInt(),K=sc.nextInt();
    long[] Apref=new long[N+1];
    for(int i=0 ; i<N ; i++){
      Apref[i+1]=Apref[i]+sc.nextInt();
    }
    TreeMap<Long,Long>map=new TreeMap<>();
    map.put(0l,0l);
    long s=0 ;
    for(int i=0 ; i<M ; i++){
      s+=sc.nextInt();
      map.put(s,i+1l);
    }
    long best=0 ;
    for(int i=0 ; i<=N ; i++){
      Long k=map.floorKey(K-Apref[i]);
      if(k!=null){
        best=Math.max(best,i+map.get(map.floorKey(K-Apref[i])));
      }
    }
    System.out.println(best);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var Apref : Sequence(long) ; Apref := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     Apref[i + 1+1] := Apref[i+1] + sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var map : Map(long,long) ; map := Map{} ;
    map := map->union(Map{0l |-> 0l}) ; 
    var s : long ; s := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     s := s+(sc.getCurrent()->toInteger()) ; 
     map := map->union(Map{s |-> i + 1l}) )  ;     i := i + 1 ) ; 
    var best : long ; best := 0 ;
        var i : int ; i := 0 ; while i <= N do ( (     var k : long ; k := map.floorKey(K - Apref[i+1]) ;
     if (k /= null) then (     best := Set{best, i + map->at(map.floorKey(K - Apref[i+1]))}->max() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(best) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastScanner sc=new FastScanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    long K=sc.nextLong();
    long a_books[]=new long[N];
    for(int i=0 ; i<N ; i++){
      a_books[i]=sc.nextLong();
    }
    long b_books[]=new long[M];
    for(int i=0 ; i<M ; i++){
      b_books[i]=sc.nextLong();
    }
    long total=0 ;
    int i=0,j=0 ;
    while(i<N && total+a_books[i]<=K){
      total+=a_books[i];
      i++;
    }
    while(j<M && total+b_books[j]<=K){
      total+=b_books[j];
      j++;
    }
    int ans=i+j ;
    i--;
    for(; i>=0 ; i--){
      total-=a_books[i];
      while(j<M && total+b_books[j]<=K){
        total+=b_books[j];
        j++;
      }
      if(ans<=i+j){
        ans=i+j ;
      }
    }
    System.out.println(ans);
  }
  private static class FastScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public FastScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
      tokenizer=null ;
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var N : int ; N := sc.nextInt() ;
    var M : int ; M := sc.nextInt() ;
    var K : long ; K := sc.nextLong() ;
    var a_books : Sequence(long) ; a_books := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a_books[i+1] := sc.nextLong() )  ;     i := i + 1 ) ; 
    var b_books : Sequence(long) ; b_books := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     b_books[i+1] := sc.nextLong() )  ;     i := i + 1 ) ; 
    var total : long ; total := 0 ;
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    while (i < N & total + a_books[i+1] <= K) do (     total := total+(a_books[i+1]) ; 
     i := i + 1 ) ; 
    while (j < M & total + b_books[j+1] <= K) do (     total := total+(b_books[j+1]) ; 
     j := j + 1 ) ; 
    var ans : int ; ans := i + j ;
    i := i - 1 ; 
      while i >= 0 do ( (     total := total-(a_books[i+1]) ; 
     while (j < M & total + b_books[j+1] <= K) do (     total := total+(b_books[j+1]) ; 
     j := j + 1 ) ; 
     if (ans <= i + j) then (     ans := i + j ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class FastScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long k=sc.nextLong();
    int count=1 ;
    while(k % 2==0){
      k/=2 ;
      count+=1 ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var count : int ; count := 1 ;
    while (k mod 2 = 0) do (     k := k/(2) ; 
     count := count+(1) ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String line=sc.nextLine();
    String[] lines=line.split(" ");
    int N=Integer.parseInt(lines[0]);
    int M=Integer.parseInt(lines[1]);
    long K=Long.parseLong(lines[2]);
    long[] A=new long[N];
    long[] B=new long[M];
    line=sc.nextLine();
    lines=line.split(" ");
    for(int i=0 ; i<N ; i++){
      A[i]=Long.parseLong(lines[i]);
    }
    line=sc.nextLine();
    lines=line.split(" ");
    for(int i=0 ; i<M ; i++){
      B[i]=Long.parseLong(lines[i]);
    }
    long t=0 ;
    for(int i=0 ; i<M ; i++){
      t=t+B[i];
    }
    int count=0 ;
    int j=M ;
    for(int i=0 ; i<A.length+1 ; i++){
      while(j>0 && t>K){
        j--;
        t=t-B[j];
      }
      if(t>K){
        break ;
      }
      count=Math.max(count,i+j);
      if(i==N){
        break ;
      }
      t=t+A[i];
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : String ; line := sc.nextLine() ;
    var lines : Sequence(String) ; lines := line->split(" ") ;
    var N : int ; N := (lines[0+1])->toInteger() ;
    var M : int ; M := (lines[1+1])->toInteger() ;
    var K : long ; K := (lines[2+1])->toLong() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
    var B : Sequence(long) ; B := Integer.subrange(1,M)->collect(0) ;
    line := sc.nextLine() ; 
    lines := line->split(" ") ; 
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := (lines[i+1])->toLong() )  ;     i := i + 1 ) ; 
    line := sc.nextLine() ; 
    lines := line->split(" ") ; 
        var i : int ; i := 0 ; while i < M do ( (     B[i+1] := (lines[i+1])->toLong() )  ;     i := i + 1 ) ; 
    var t : long ; t := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     t := t + B[i+1] )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var j : int ; j := M ;
        var i : int ; i := 0 ; while i < A->size() + 1 do ( (     while (j > 0 & t > K) do (     j := j - 1 ; 
     t := t - B[j+1] ) ; 
     if (t > K) then (     break ) else skip ; 
    count := Set{count, i + j}->max() ; 
    if (i = N) then (     break ) else skip ; 
    t := t + A[i+1] ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.text.DecimalFormat ;
import java.util.Locale ;
public class Checksum {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    String s=reader.readLine();
    double checksum=0 ;
    for(int i=0 ; i<s.length(); i++){
      int z=i ;
      if(Character.isDigit(s.charAt(i))){
        StringBuilder currentPrice=new StringBuilder();
        for(int j=z ; j<s.length(); j++){
          char currentSymbol=s.charAt(j);
          i=j ;
          if(Character.isDigit(currentSymbol)|| Character.toString(currentSymbol).equals(".")){
            currentPrice.append(Character.toString(currentSymbol));
          }
          else break ;
        }
        String[] k=currentPrice.toString().split("\\.");
        currentPrice=new StringBuilder();
        for(int j=0 ; j<k.length ; j++){
          if(k.length>1 && j+1==k.length && k[j] .length()==2){
            currentPrice.append(".").append(k[j]);
          }
          else currentPrice.append(k[j]);
        }
        checksum+=Double.parseDouble(currentPrice.toString());
      }
    }
    s=String.format("%,.2f",checksum);
    s=s.replaceAll(",",".");
    if(s.substring(s.length()-2).equals("00"))s=s.substring(0,s.length()-3);
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Checksum {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := reader.readLine() ;
    var checksum : double ; checksum := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var z : int ; z := i ;
     if ((s->at(i+1) + "")->isMatch("[0-9]")) then (     var currentPrice : String ; currentPrice := StringLib.newString() ;
         var j : int ; j := z ; while j < s->size() do ( (     var currentSymbol : String ; currentSymbol := s->at(j+1) ;
     i := j ; 
     if ((currentSymbol + "")->isMatch("[0-9]") or (currentSymbol + "") = ".") then (     currentPrice := currentPrice + StringLib.newString((currentSymbol + "")) ) else     break )  ;     j := j + 1 ) ; 
    var k : Sequence(String) ; k := currentPrice+""->split("\\.") ;
    currentPrice := StringLib.newString() ; 
        var j : int ; j := 0 ; while j < k->size() do ( (     if (k->size() > 1 & j + 1 = k->size() & k[j+1]->size() = 2) then (     currentPrice := currentPrice + StringLib.newString(".") + StringLib.newString(k[j+1]) ) else     currentPrice := currentPrice + StringLib.newString(k[j+1]) ; )  ;     j := j + 1 ) ; 
    checksum := checksum+((currentPrice+"")->toReal()) ; 
 ) else skip )  ;     i := i + 1 ) ; 
    s := StringLib.format("%,.2f",Sequence{checksum}) ; 
    s := s.replaceAllMatches(",", "." ) ; 
    if (s.subrange(s->size() - 2+1,s->size() - 2) = "00") then     s := s.subrange(0+1,s->size() - 3) ; else skip ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Reader myReader=new Reader();
    char[] arr=myReader.nextToken().toCharArray();
    int n=arr.length ;
    int[] end=new int[n];
    Arrays.fill(end,Integer.MAX_VALUE);
    for(int i=0 ; i<n ; i++){
      for(int k=1 ; k<5 ; k++){
        if(i+k+k<n && arr[i]==arr[i+k] && arr[i+k]==arr[i+k+k]){
          end[i]=i+k+k ;
          break ;
        }
      }
    }
    int i=n-1 ;
    long res=0 ;
    for(int j=n-1 ; j>0 ; j--){
      while(i>-1){
        if(end[i]<=j){
          break ;
        }
        i--;
      }
      res+=(i+1);
      if(i==-1)break ;
    }
    System.out.println(res);
  }
  private static class Reader {
    BufferedReader reader ;
    StringTokenizer st ;
    Reader(){
      reader=new BufferedReader(new InputStreamReader(System.in));
    }
    String nextToken(){
      try {
        if(st==null || ! st.hasMoreTokens())st=new StringTokenizer(reader.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(nextToken());
    }
    long nextLong(){
      return Long.parseLong(nextToken());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var myReader : OclFile ; myReader := OclFile() ;
     var arr : Sequence(String) ; arr := myReader.nextToken()->characters() ;
    var n : int ; n := arr->size() ;
    var end : Sequence(int) ; end := Integer.subrange(1,n)->collect(0) ;
    end := end->collect(2147483647) ; 
        var i : int ; i := 0 ; while i < n do ( (         var k : int ; k := 1 ; while k < 5 do ( (     if (i + k + k < n & arr[i+1] = arr[i + k+1] & arr[i + k+1] = arr[i + k + k+1]) then (     end[i+1] := i + k + k ; 
     break ) else skip )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    var i : int ; i := n - 1 ;
    var res : long ; res := 0 ;
        var j : int ; j := n - 1 ; while j > 0 do ( (     while (i > -1) do (     if (end[i+1] <= j) then (     break ) else skip ; 
     i := i - 1 ) ; 
     res := res+((i + 1)) ; 
     if (i = -1) then     break else skip )  ;     j := j - 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static class Reader {
   attribute reader : OclFile;
   attribute st : OclIterator;
   static operation newReader() : Reader
  pre: true
  post: true
  activity:
  ( var self : Reader ;
    self := createReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     try (     if (st = null or not(st.hasNext())) then     st := OclIterator.newOclIterator_String(reader.readLine()) ; else skip )   catch (e : IOException) do (     e.printStackTrace() )
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.ArrayList ;
import java.util.Scanner ;
public class TaskE {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    char[] c=scan.nextLine().toCharArray();
    int k=0 ;
    BigDecimal d=new BigDecimal(0);
    while(k<c.length){
      if(function(c[k])){
        String s="" ;
        while(function(c[k])){
          s+=c[k];
          if(k+1<c.length)k++;
          else break ;
        }
        boolean t=false ;
        if(s.contains("."))t=s.substring(s.length()-3,s.length()-2).equals(".");
        s=s.replace(".","");
        if(t)s=s.substring(0,s.length()-2)+"."+s.substring(s.length()-2);
        d=d.add(new BigDecimal(s));
      }
      k++;
    }
    String s=d.toString();
    int r=s.length();
    if(s.contains("."))if(s.substring(s.lastIndexOf(".")).length()==3)r=s.lastIndexOf(".");
    while(r-3>0){
      r-=3 ;
      s=s.substring(0,r)+"."+s.substring(r);
    }
    if(s.substring(s.lastIndexOf(".")).length()==3 && s.substring(s.lastIndexOf(".")).equals(".00"))s=s.substring(0,s.lastIndexOf("."));
    System.out.println(s);
  }
  private static boolean function(char c){
    return c=='1' || c=='0' || c=='2' || c=='3' || c=='4' || c=='5' || c=='6' || c=='7' || c=='8' || c=='9' || c=='.' ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class TaskE {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : Sequence(String) ; c := scan.nextLine()->characters() ;
    var k : int ; k := 0 ;
    var d : double ; d := double(0) ;
    while (k < c->size()) do (     if (function(c[k+1])) then (     var s : String ; s := "" ;
     while (function(c[k+1])) do (     s := s+(c[k+1]) ; 
     if (k + 1 < c->size()) then     k := k + 1 ; else     break ) ; 
    var t : boolean ; t := false ;
    if (s->includes(".")) then     t := s.subrange(s->size() - 3+1,s->size() - 2) = "." ; else skip ; 
    s := s.replace(".", "") ; 
    if (t) then     s := s.subrange(0+1,s->size() - 2) + "." + s.subrange(s->size() - 2+1,s->size() - 2) ; else skip ; 
    d := d->excludes(double(s)) ; 
 ) else skip ; 
     k := k + 1 ) ; 
    var s : String ; s := d+"" ;
    var r : int ; r := s->size() ;
    if (s->includes(".")) then     if (s.subrange(s->lastIndexOf(".")-1+1,s->lastIndexOf(".")-1)->size() = 3) then     r := s->lastIndexOf(".")-1 ; else skip ; else skip ; 
    while ((r)->char2byte() - 3 > 0) do (     r := r-(3) ; 
     s := s.subrange(0+1,r) + "." + s.subrange(r+1,r) ) ; 
    if (s.subrange(s->lastIndexOf(".")-1+1,s->lastIndexOf(".")-1)->size() = 3 & s.subrange(s->lastIndexOf(".")-1+1,s->lastIndexOf(".")-1) = ".00") then     s := s.subrange(0+1,s->lastIndexOf(".")-1) ; else skip ; 
    OclFile["System.out"].println(s) ; 
 );
  static   operation function( c : String) : boolean
  pre: true
  post: true
  activity: (     return c = '1' or c = '0' or c = '2' or c = '3' or c = '4' or c = '5' or c = '6' or c = '7' or c = '8' or c = '9' or c = '.' );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static long findNumUtil(long res,int a,int aCount,int b,int bCount,int n){
    if(res>1e11)return(long)1e11 ;
    if(aCount==bCount && res>=n)return res ;
    return Math.min(findNumUtil(res*10+a,a,aCount+1,b,bCount,n),findNumUtil(res*10+b,a,aCount,b,bCount+1,n));
  }
  static int findNum(int n,int a,int b){
    int result=0 ;
    int aCount=0 ;
    int bCount=0 ;
    return(int)findNumUtil(result,a,aCount,b,bCount,n);
  }
  public static void main(String args[]){
    int N=4500 ;
    int A=4 ;
    int B=7 ;
    System.out.println(findNum(N,A,B));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNumUtil( res : long, a : int, aCount : int, b : int, bCount : int, n : int) : long
  pre: true
  post: true
  activity: (     if (res > 1e11) then     return 1e11->oclAsType(long) else skip ; 
     if (aCount = bCount & res >= n) then     return res else skip ; 
     return Set{findNumUtil(res * 10 + a, a, aCount + 1, b, bCount, n), findNumUtil(res * 10 + b, a, aCount, b, bCount + 1, n)}->min() );
  static   operation findNum( n : int, a : int, b : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var aCount : int ; aCount := 0 ;
     var bCount : int ; bCount := 0 ;
     return findNumUtil(result, a, aCount, b, bCount, n)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4500 ;
     var A : int ; A := 4 ;
     var B : int ; B := 7 ;
     OclFile["System.out"].println(findNum(N, A, B)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=Integer.parseInt(scanner.nextLine());
      if(n==0){
        break ;
      }
      int[][] num=new int[n][2];
      for(int i=0 ; i<n ; i++){
        String[] s=scanner.nextLine().split(" ");
        int[] b=new int[s.length-1];
        num[i][0]=Integer.parseInt(s[0]);
        int frame=1 ;
        for(int j=1 ; j<s.length ; j++){
          b[j-1]=Integer.parseInt(s[j]);
        }
        int j=0 ;
        while(j<b.length){
          if(frame>=10){
            num[i][1]+=b[j];
            j++;
          }
          else {
            num[i][1]+=b[j]+b[j+1];
            if(b[j]==10){
              num[i][1]+=b[j+2];
              j++;
            }
            else {
              if(b[j]+b[j+1]==10){
                num[i][1]+=b[j+2];
              }
              j+=2 ;
            }
          }
          frame++;
        }
      }
      Arrays.sort(num,new Comparator<int[]>(){
        @ Override public int compare(int[] a,int[] b){
          if(a[1]==b[1]){
            return a[0]-b[0];
          }
          return b[1]-a[1];
        }
      }
);
      for(int i=0 ; i<n ; i++){
        System.out.println(num[i][0]+" "+num[i][1]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := (scanner.nextLine())->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var num : Sequence(Sequence(int)) ; num := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var s : Sequence(String) ; s := scanner.nextLine()->split(" ") ;
     var b : Sequence(int) ; b := Integer.subrange(1,s->size() - 1)->collect(0) ;
    num[i+1][0+1] := (s[0+1])->toInteger() ; 
    var frame : int ; frame := 1 ;
        var j : int ; j := 1 ; while j < s->size() do ( (     b[j - 1+1] := (s[j+1])->toInteger() )  ;     j := j + 1 ) ; 
    var j : int ; j := 0 ;
    while (j < b->size()) do (     if (frame >= 10) then (     num[i+1][1+1] := num[i+1][1+1]+(b[j+1]) ; 
     j := j + 1 ) else (     num[i+1][1+1] := num[i+1][1+1]+(b[j+1] + b[j + 1+1]) ; 
     if (b[j+1] = 10) then (     num[i+1][1+1] := num[i+1][1+1]+(b[j + 2+1]) ; 
     j := j + 1 ) else (     if (b[j+1] + b[j + 1+1] = 10) then (     num[i+1][1+1] := num[i+1][1+1]+(b[j + 2+1]) ) else skip ; 
     j := j+(2) ) ) ;  
     frame := frame + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    num := OclComparator.sortWith(num, OclComparator<Sequence(int)>.newOclComparator()) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(num[i+1][0+1] + " " + num[i+1][1+1]) )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=Integer.parseInt(scanner.nextLine());
      if(n==0){
        break ;
      }
      int[][] num=new int[n][2];
      for(int l=0 ; l<n ; l++){
        StringTokenizer tokenizer=new StringTokenizer(scanner.nextLine());
        num[l][0]=Integer.parseInt(tokenizer.nextToken());
        int t=tokenizer.countTokens();
        int[] b=new int[t];
        int frame=1 ;
        for(int i=0 ; i<t ; i++){
          b[i]=Integer.parseInt(tokenizer.nextToken());
        }
        int j=0 ;
        int sum=0 ;
        while(j<b.length){
          if(frame>=10){
            sum+=b[j];
            j++;
          }
          else {
            sum+=b[j]+b[j+1];
            if(b[j]==10){
              sum+=b[j+2];
              j++;
            }
            else {
              if(b[j]+b[j+1]==10){
                sum+=b[j+2];
              }
              j+=2 ;
            }
          }
          frame++;
        }
        num[l][1]=sum ;
      }
      Arrays.sort(num,new Comparator<int[]>(){
        @ Override public int compare(int[] a,int[] b){
          if(a[1]==b[1]){
            return a[0]-b[0];
          }
          return b[1]-a[1];
        }
      }
);
      for(int[] a : num){
        System.out.println(a[0]+" "+a[1]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := (scanner.nextLine())->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var num : Sequence(Sequence(int)) ; num := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var l : int ; l := 0 ; while l < n do ( (     var tokenizer : OclIterator ; tokenizer := OclIterator.newOclIterator_String(scanner.nextLine()) ;
     num[l+1][0+1] := (tokenizer.next())->toInteger() ; 
    var t : int ; t := tokenizer.elements->size() ;
    var b : Sequence(int) ; b := Integer.subrange(1,t)->collect(0) ;
    var frame : int ; frame := 1 ;
        var i : int ; i := 0 ; while i < t do ( (     b[i+1] := (tokenizer.next())->toInteger() )  ;     i := i + 1 ) ; 
    var j : int ; j := 0 ;
    var sum : int ; sum := 0 ;
    while (j < b->size()) do (     if (frame >= 10) then (     sum := sum+(b[j+1]) ; 
     j := j + 1 ) else (     sum := sum+(b[j+1] + b[j + 1+1]) ; 
     if (b[j+1] = 10) then (     sum := sum+(b[j + 2+1]) ; 
     j := j + 1 ) else (     if (b[j+1] + b[j + 1+1] = 10) then (     sum := sum+(b[j + 2+1]) ) else skip ; 
     j := j+(2) ) ) ;  
     frame := frame + 1 ) ; 
    num[l+1][1+1] := sum ; 
 )  ;     l := l + 1 ) ; 
    num := OclComparator.sortWith(num, OclComparator<Sequence(int)>.newOclComparator()) ; 
    for (a : num) do ( (     OclFile["System.out"].println(a[0+1] + " " + a[1+1]) )  ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final Scanner stdin=new Scanner(System.in);
  public static void main(String[] args){
    int n ;
    while((n=stdin.nextInt())!=0){
      stdin.nextLine();
      T[] record=new T[n];
      for(int i=0 ; i<n ; ++i)record[i]=new T(stdin.nextLine().split(" "));
      Arrays.sort(record);
      for(T t : record)System.out.println(t.id+" "+t.sum);
    }
  }
  static class T implements Comparable<T>{
    int sum,id ;
    @ Override public int compareTo(T o2){
      return sum!=o2.sum ? o2.sum-sum : id-o2.id ;
    }
    T(String[] in){
      int[] frame=new int[10];
      id=Integer.parseInt(in[0]);
      int[] input=new int[in.length-1];
      for(int i=0 ; i<input.length ; ++i)input[i]=Integer.parseInt(in[i+1]);
      sum=0 ;
      for(int i=0,p=0 ; p<10 ; ++p){
        frame[p]=input[i]+input[i+1];
        if(p==9){
          if(frame[p]>=10)frame[p]+=input[i+2];
        }
        else if(input[i]==10){
          frame[p]+=input[i+2];
++i ;
        }
        else {
          if(frame[p]==10)frame[p]+=input[i+2];
          i+=2 ;
        }
        sum+=frame[p];
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute stdin : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
         n := stdin.getCurrent()->toInteger() ;
    while ((n) /= 0) do (    skip ; (     skip ; 
     var record : Sequence(T) ; record := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     record[i+1] := T.newT(stdin.nextLine()->split(" ")) ;  ;     i := i + 1 ) ; 
    record := record->sort() ; 
    for (t : record) do (     OclFile["System.out"].println(t.id + " " + t.sum) ;  ) ; 
 ) ;     n := stdin.getCurrent()->toInteger() ;
 ) );
  static class T implements Comparable<T> {
   attribute sum : int;
      operation compareTo( o2 : T) : int
  pre: true
  post: true
  activity: (     return if sum /= o2.sum then o2.sum - sum else id - o2.id endif );
   static operation newT( in : Sequence(String)) : T
  pre: true
  post: true
  activity:
  ( var self : T ;
    self := createT();
    self.initialise(in);
    return self );
  operation initialise( in : Sequence(String)) : void
  pre: true  post: true
  activity: (     var frame : Sequence(int) ; frame := Integer.subrange(1,10)->collect(0) ;
     id := (in[0+1])->toInteger() ; 
    var input : Sequence(int) ; input := Integer.subrange(1,in->size() - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < input->size() do (     input[i+1] := (in[i + 1+1])->toInteger() ;  ;     i := i + 1 ) ; 
    sum := 0 ; 
        var i : int ; i := 0 ;
    var p : int ; p := 0 ; while p < 10 do ( (     frame[p+1] := input[i+1] + input[i + 1+1] ; 
     if (p = 9) then (     if (frame[p+1] >= 10) then     frame[p+1] := frame[p+1]+(input[i + 2+1]) ; else skip ) else     if (input[i+1] = 10) then (     frame[p+1] := frame[p+1]+(input[i + 2+1]) ; 
     i := i + 1 ) else (     if (frame[p+1] = 10) then     frame[p+1] := frame[p+1]+(input[i + 2+1]) ; else skip ; 
     i := i+(2) ) ;  ;  
     sum := sum+(frame[p+1]) )  ;     p := p + 1 ) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ChloeAndSequence {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int N=in.nextInt();
    long length=1 ;
    for(int n=2 ; n<=N ; n++){
      length=2*length+1 ;
    }
    long K=in.nextLong();
    pw.println(solve(N,K,length));
    pw.close();
  }
  private static int solve(int N,long K,long length){
    long subLength=(length-1)/2 ;
    if(K==subLength+1){
      return N ;
    }
    else if(K<=subLength){
      return solve(N-1,K,subLength);
    }
    else {
      return solve(N-1,K-subLength-1,subLength);
    }
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class ChloeAndSequence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var length : long ; length := 1 ;
        var n : int ; n := 2 ; while n <= N do ( (     length := 2 * length + 1 )  ;     n := n + 1 ) ; 
    var K : long ; K := in.getCurrent()->toLong() ;
    skip ; 
    skip ; 
 );
  static   operation solve( N : int, K : long, length : long) : int
  pre: true
  post: true
  activity: (     var subLength : long ; subLength := (length - 1) / 2 ;
     if (K = subLength + 1) then (     return N ) else     if (K <= subLength) then (     return solve(N - 1, K, subLength) ) else (     return solve(N - 1, K - subLength - 1, subLength) ) ;  );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.util.*;
public class a {
  public static void main(String[] args)throws IOException {
    StringTokenizer st ;
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    st=new StringTokenizer(f.readLine());
    int all=0 ;
    int n=Integer.parseInt(st.nextToken());
    st=new StringTokenizer(f.readLine());
    for(int i=0 ; i<n ; i++){
      all+=Integer.parseInt(st.nextToken());
    }
    st=new StringTokenizer(f.readLine());
    boolean tru=false ;
    int m=Integer.parseInt(st.nextToken());
    for(int i=0 ; i<m ; i++){
      st=new StringTokenizer(f.readLine());
      int ft=Integer.parseInt(st.nextToken());
      if(Integer.parseInt(st.nextToken())>=all){
        System.out.println(Math.max(all,ft));
        tru=true ;
        break ;
      }
    }
    f.close();
    if(! tru)System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var st : OclIterator ;
     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    st := OclIterator.newOclIterator_String(f.readLine()) ; 
    var all : int ; all := 0 ;
    var n : int ; n := (st.next())->toInteger() ;
    st := OclIterator.newOclIterator_String(f.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     all := all+((st.next())->toInteger()) )  ;     i := i + 1 ) ; 
    st := OclIterator.newOclIterator_String(f.readLine()) ; 
    var tru : boolean ; tru := false ;
    var m : int ; m := (st.next())->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     st := OclIterator.newOclIterator_String(f.readLine()) ; 
     var ft : int ; ft := (st.next())->toInteger() ;
     if ((st.next())->toInteger() >= all) then (     OclFile["System.out"].println(Set{all, ft}->max()) ; 
     tru := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    if (not(tru)) then     OclFile["System.out"].println(-1) ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int a[]=new int[n];
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=input.nextInt();
      sum+=a[i];
    }
    int m=input.nextInt();
    int b[][]=new int[m][2];
    if(m==0){
      System.out.println("-1");
      return ;
    }
    else {
      for(int i=0 ; i<m ; i++){
        b[i][0]=input.nextInt();
        b[i][1]=input.nextInt();
      }
      if(sum>b[m-1][1])System.out.println("-1");
      else {
        for(int i=0 ; i<m ; i++){
          if(sum<=b[i][1]){
            System.out.println(Math.max(sum,b[i][0]));
            return ;
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    var m : int ; m := input.getCurrent()->toInteger() ;
    var b : Sequence(Sequence(int)) ; b := Integer.subrange(1,m)->collect(Integer.subrange(1,2)->collect(0)) ;
    if (m = 0) then (     OclFile["System.out"].println("-1") ; 
     return ) else (         var i : int ; i := 0 ; while i < m do ( (     b[i+1][0+1] := input.getCurrent()->toInteger() ; 
     b[i+1][1+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     if (sum > b[m - 1+1][1+1]) then     OclFile["System.out"].println("-1") ; else (         var i : int ; i := 0 ; while i < m do ( (     if (sum <= b[i+1][1+1]) then (     OclFile["System.out"].println(Set{sum, b[i+1][0+1]}->max()) ; 
     return ) else skip )  ;     i := i + 1 ) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class GoingHome {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
    }
    in.close();
    int[][] freq=new int[5000001][2];
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        int sum=arr[i]+arr[j];
        if(freq[sum][0]==0){
          freq[sum][0]=i+1 ;
          freq[sum][1]=j+1 ;
        }
        else {
          int a=i+1 ;
          int b=j+1 ;
          if(a!=freq[sum][0] && a!=freq[sum][1] && b!=freq[sum][0] && b!=freq[sum][1]){
            System.out.println("YES");
            System.out.println(freq[sum][0]+" "+freq[sum][1]+" "+a+" "+b);
            return ;
          }
        }
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GoingHome {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var freq : Sequence(Sequence(int)) ; freq := Integer.subrange(1,5000001)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var sum : int ; sum := arr[i+1] + arr[j+1] ;
     if (freq[sum+1][0+1] = 0) then (     freq[sum+1][0+1] := i + 1 ; 
     freq[sum+1][1+1] := j + 1 ) else (     var a : int ; a := i + 1 ;
     var b : int ; b := j + 1 ;
     if (a /= freq[sum+1][0+1] & a /= freq[sum+1][1+1] & b /= freq[sum+1][0+1] & b /= freq[sum+1][1+1]) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(freq[sum+1][0+1] + " " + freq[sum+1][1+1] + " " + a + " " + b) ; 
     return ) else skip ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class codeforces813A {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int x=0,n=s.nextInt(),i,m,ans=0 ;
    boolean j=false ;
    for(i=0 ; i<n ; i++)x=x+s.nextInt();
    m=s.nextInt();
    int[] c=new int[m];
    int[] b=new int[m];
    for(i=0 ; i<m ; i++){
      c[i]=s.nextInt();
      b[i]=s.nextInt();
    }
    for(i=0 ; i<m ; i++){
      if(x>=c[i] && x<=b[i]){
        ans=x ;
        j=true ;
        break ;
      }
      else if(x<c[i]){
        ans=c[i];
        j=true ;
        break ;
      }
    }
    if(j==true)System.out.print(ans);
    else System.out.print(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces813A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := 0 ;
    var n : int ; n := s.getCurrent()->toInteger() ;
    var i : int ;
    var m : int ;
    var ans : int ; ans := 0 ;
    var j : boolean ; j := false ;
        i := 0 ; while i < n do (     x := x + s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    m := s.getCurrent()->toInteger() ; 
    var c : Sequence(int) ; c := Integer.subrange(1,m)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
        i := 0 ; while i < m do ( (     c[i+1] := s.getCurrent()->toInteger() ; 
     b[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        i := 0 ; while i < m do ( (     if (x >= c[i+1] & x <= b[i+1]) then (     ans := x ; 
     j := true ; 
     break ) else     if (x < c[i+1]) then (     ans := c[i+1] ; 
     j := true ; 
     break ) else skip ; )  ;     i := i + 1 ) ; 
    if (j = true) then     OclFile["System.out"].print(ans) else     OclFile["System.out"].print(-1) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
public class GFG {
  static void twoWaySort(Integer arr[],int n){
    int l=0,r=n-1 ;
    int k=0 ;
    while(l<r){
      while(arr[l] % 2!=0){
        l++;
        k++;
      }
      while(arr[r] % 2==0 && l<r)r--;
      if(l<r){
        int temp=arr[l];
        arr[l]=arr[r];
        arr[r]=temp ;
      }
    }
    Arrays.sort(arr,0,k,Collections.reverseOrder());
    Arrays.sort(arr,k,n);
  }
  public static void main(String[] args){
    Integer arr[]={
      1,3,2,7,5,4 };
      twoWaySort(arr,arr.length);
      System.out.println(Arrays.toString(arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation twoWaySort( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
    var r : int ; r := n - 1 ;
     var k : int ; k := 0 ;
    while (l < r) do (     while (arr[l+1] mod 2 /= 0) do (     l := l + 1 ; 
     k := k + 1 ) ; 
     while (arr[r+1] mod 2 = 0 & l < r) do     r := r - 1 ; ; 
     if (l < r) then (     var temp : int ; temp := arr[l+1] ;
     arr[l+1] := arr[r+1] ; 
     arr[r+1] := temp ) else skip ) ; 
    arr, 0, k, reverseOrder() := arr, 0, k, reverseOrder()->sort() ; 
    arr := arr.subrange(1,k)^(arr.subrange(k+1,n)->sort())^arr.subrange(n+1,arr.size) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,2,7,5,4} ;
     execute twoWaySort(arr, arr->size()) ; 
     OclFile["System.out"].println((arr + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findOddPair(int A[],int N){
    int oddPair=0 ;
    for(int i=0 ; i<N ; i++){
      for(int j=i+1 ; j<N ; j++){
        if((A[i] | A[j])% 2!=0)oddPair++;
      }
    }
    return oddPair ;
  }
  public static void main(String[] args){
    int A[]={
      5,6,2,8 };
      int N=A.length ;
      System.out.println(findOddPair(A,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findOddPair( A : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var oddPair : int ; oddPair := 0 ;
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := i + 1 ; while j < N do ( (     if ((A[i+1] or A[j+1]) mod 2 /= 0) then     oddPair := oddPair + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return oddPair );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{5,6,2,8} ;
     var N : int ; N := A->size() ;
     OclFile["System.out"].println(findOddPair(A, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findOddPair(int A[],int N){
    int i,j ;
    int oddPair=0 ;
    for(i=0 ; i<N ; i++){
      for(j=i+1 ; j<N ; j++){
        if((A[i] ^ A[j])% 2!=0)oddPair++;
      }
    }
    return oddPair ;
  }
  public static void main(String args[]){
    int A[]={
      5,4,7,2,1 };
      int N=A.length ;
      System.out.println(findOddPair(A,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findOddPair( A : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var oddPair : int ; oddPair := 0 ;
         i := 0 ; while i < N do ( (         j := i + 1 ; while j < N do ( (     if ((A[i+1] xor A[j+1]) mod 2 /= 0) then     oddPair := oddPair + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return oddPair );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{5,4,7,2,1} ;
     var N : int ; N := A->size() ;
     OclFile["System.out"].println(findOddPair(A, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static byte sizeofInt=8 ;
  static int countZeros(int x){
    int total_bits=sizeofInt*8 ;
    int res=0 ;
    while((x &(1<<(total_bits-1)))==0){
      x=(x<<1);
      res++;
    }
    return res ;
  }
  public static void main(String[] args){
    int x=101 ;
    System.out.println(countZeros(x));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute sizeofInt : int := 8;
  static   operation countZeros( x : int) : int
  pre: true
  post: true
  activity: (     var total_bits : int ; total_bits := sizeofInt * 8 ;
     var res : int ; res := 0 ;
     while ((x & ((1*(2->pow((total_bits - 1))))->oclAsType(long))) = 0) do (     x := ((x*(2->pow(1)))->oclAsType(long)) ; 
     res := res + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 101 ;
     OclFile["System.out"].println(countZeros(x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static int findOccurrences(String str1,String substr1){
    int counter=0 ;
    char[] str=str1.toCharArray();
    char[] substr=substr1.toCharArray();
    for(int i=0 ; i<str1.length(); i++){
      if(str[i]==substr[0]){
        for(int j=i+1 ; j<str1.length(); j++){
          if(str[j]==substr[1]){
            for(int k=j+1 ; k<str1.length(); k++){
              if(str[k]==substr[2])counter++;
            }
          }
        }
      }
    }
    return counter ;
  }
  public static void main(String argc[]){
    String str="GFGFGYSYIOIWIN" ;
    String substr="GFG" ;
    System.out.println(findOccurrences(str,substr));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation findOccurrences( str1 : String, substr1 : String) : int
  pre: true
  post: true
  activity: (     var counter : int ; counter := 0 ;
     var str : Sequence(String) ; str := str1->characters() ;
    var substr : Sequence(String) ; substr := substr1->characters() ;
        var i : int ; i := 0 ; while i < str1->size() do ( (     if (str[i+1] = substr[0+1]) then (         var j : int ; j := i + 1 ; while j < str1->size() do ( (     if (str[j+1] = substr[1+1]) then (         var k : int ; k := j + 1 ; while k < str1->size() do ( (     if (str[k+1] = substr[2+1]) then     counter := counter + 1 ; else skip )  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    return counter 
 );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GFGFGYSYIOIWIN" ;
     var substr : String ; substr := "GFG" ;
     OclFile["System.out"].println(findOccurrences(str, substr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int[][] floodFill(int[][] image,int sr,int sc,int newColor){
    Queue<Node>queue=new LinkedList<Node>();
    int color=image[sr][sc];
    if(color==newColor)return image ;
    queue.add(new Node(sr,sc));
    while(! queue.isEmpty()){
      Node curr=queue.remove();
      int r=curr.r,c=curr.c ;
      if(image[r][c]==color){
        image[r][c]=newColor ;
        if(r-1>=0)queue.add(new Node(r-1,c));
        if(r+1<image.length)queue.add(new Node(r+1,c));
        if(c-1>=0)queue.add(new Node(r,c-1));
        if(c+1<image[0] .length)queue.add(new Node(r,c+1));
      }
    }
    return image ;
  }
  class Node {
    int r ;
    int c ;
    public Node(int r,int c){
      this.r=r ;
      this.c=c ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation floodFill( image : Sequence(Sequence(int)), sr : int, sc : int, newColor : int) : Sequence(Sequence(int))
  pre: true
  post: true
  activity: (     var queue : Sequence(Node) ; queue := Sequence{} ;
     var color : int ; color := image[sr+1][sc+1] ;
    if (color = newColor) then     return image else skip ; 
    queue := queue->including(Node.newNode(sr, sc)) ; 
    while (not(queue->isEmpty())) do (     var curr : Node ; curr := queue.remove() ;
     var r : int ; r := curr.r ;
    var c : int ; c := curr.c ;
     if (image[r+1][c+1] = color) then (     image[r+1][c+1] := newColor ; 
     if (r - 1 >= 0) then     queue := queue->including(Node.newNode(r - 1, c)) ; else skip ; 
    if (r + 1 < image->size()) then     queue := queue->including(Node.newNode(r + 1, c)) ; else skip ; 
    if (c - 1 >= 0) then     queue := queue->including(Node.newNode(r, c - 1)) ; else skip ; 
    if (c + 1 < image[0+1]->size()) then     queue := queue->including(Node.newNode(r, c + 1)) ; else skip ; 
 ) else skip ) ; 
    return image 
 );
 class Node {
   attribute r : int;
   attribute c : int;
   static operation newNode( r : int, c : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(r, c);
    return self );
  operation initialise( r : int, c : int) : void
  pre: true  post: true
  activity: (     self.r := r ; 
     self.c := c );
}
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String S=sc.nextLine();
    char c=S.charAt(0);
    int N=S.length();
    List<Integer>bw=new ArrayList<>();
    int temp=0 ;
    for(int i=0 ; i<N ; i++){
      if(c==S.charAt(i)){
        temp++;
      }
      else {
        bw.add(temp);
        temp=1 ;
        c=S.charAt(i);
      }
    }
    bw.add(temp);
    System.out.println(bw.size()-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.nextLine() ;
    var c : String ; c := S->at(0+1) ;
    var N : int ; N := S->size() ;
    var bw : Sequence(int) ; bw := Sequence{} ;
    var temp : int ; temp := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (c = S->at(i+1)) then (     temp := temp + 1 ) else (     bw := bw->including(temp) ; 
     temp := 1 ; 
     c := S->at(i+1) ) )  ;     i := i + 1 ) ; 
    bw := bw->including(temp) ; 
    OclFile["System.out"].println(bw->size() - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long n,k,multiple=1 ;
    n=scanner.nextLong();
    k=scanner.nextLong();
    for(long i=0 ; i<n ; i++){
      multiple=multiple*2 ;
      if(k % multiple!=0){
        System.out.println(i+1);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ;
    var k : long ;
    var multiple : long ; multiple := 1 ;
    n := scanner.getCurrent()->toLong() ; 
    k := scanner.getCurrent()->toLong() ; 
        var i : long ; i := 0 ; while i < n do ( (     multiple := multiple * 2 ; 
     if (k mod multiple /= 0) then (     OclFile["System.out"].println(i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      char[] s=scanner.nextLine().toCharArray();
      char pre=' ' ;
      int count=0 ;
      for(char c : s){
        if(c!=pre){
          count++;
          pre=c ;
        }
      }
      System.out.println(count-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var s : Sequence(String) ; s := scanner.nextLine()->characters() ;
     var pre : String ; pre := ' ' ;
    var count : int ; count := 0 ;
    for (c : s) do ( (     if (c /= pre) then (     count := count + 1 ; 
     pre := c ) else skip )  ) ; 
    OclFile["System.out"].println((count)->char2byte() - 1) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Queue ;
import java.util.Random ;
import java.util.Scanner ;
public class Main {
  private static Scanner sc=new Scanner(System.in);
  static long mod=1000000007 ;
  public static void main(String[] args){
    String S=sc.next();
    int v=0 ;
    for(int i=1 ; i<S.length(); i++){
      if(S.charAt(i)!=S.charAt(i-1))v++;
    }
    p(v);
  }
  public static long modPow(long g,long N){
    long T=1 ;
    for(int i=0 ; i<N ; i++){
      T*=g ;
      T %=mod ;
    }
    return T ;
  }
  public static long lcm(long a,long b){
    return a/gcd(a,b)*b ;
  }
  public static long gcd(long a,long b){
    return b==0 ? a : gcd(b,a % b);
  }
  static void p(String ans){
    System.out.println(ans);
  };
  static void p(int ans){
    System.out.println(ans);
  };
  static void p(){
    System.out.println();
  };
  static void p(long ans){
    System.out.println(ans);
  };
  static void p(double ans){
    System.out.println(ans);
  };
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute mod : long := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := sc.getCurrent() ;
     var v : int ; v := 0 ;
         var i : int ; i := 1 ; while i < S->size() do ( (     if (S->at(i+1) /= S->at(i - 1+1)) then     v := v + 1 ; else skip )  ;     i := i + 1 ) ; 
     execute p(v) );
  static   operation modPow( g : long, N : long) : long
  pre: true
  post: true
  activity: (     var T : long ; T := 1 ;
         var i : int ; i := 0 ; while i < N do ( (     T := T*(g) ; 
     T := T mod mod )  ;     i := i + 1 ) ; 
     return T );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return a / gcd(a, b) * b );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
  static   operation p( ans : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( ans : long) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : double) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=br.readLine();
    int count=0 ;
    char c=str.charAt(0);
    for(int i=1 ; i<str.length(); i++){
      if(str.charAt(i)!=c){
        count++;
        c=str.charAt(i);
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := br.readLine() ;
    var count : int ; count := 0 ;
    var c : String ; c := str->at(0+1) ;
        var i : int ; i := 1 ; while i < str->size() do ( (     if (str->at(i+1) /= c) then (     count := count + 1 ; 
     c := str->at(i+1) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    char c=S.charAt(0);
    int ans=0 ;
    for(int i=1 ; i<S.length(); i++){
      if(c!=S.charAt(i)){
        ans++;
        c=S.charAt(i);
      }
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    var c : String ; c := S->at(0+1) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < S->size() do ( (     if (c /= S->at(i+1)) then (     ans := ans + 1 ; 
     c := S->at(i+1) ) else skip )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static class Pair {
    int min ;
    int max ;
  }
  static Pair getMinMax(int arr[],int low,int high){
    Pair minmax=new Pair();
    Pair mml=new Pair();
    Pair mmr=new Pair();
    int mid ;
    if(low==high){
      minmax.max=arr[low];
      minmax.min=arr[low];
      return minmax ;
    }
    if(high==low+1){
      if(arr[low]>arr[high]){
        minmax.max=arr[low];
        minmax.min=arr[high];
      }
      else {
        minmax.max=arr[high];
        minmax.min=arr[low];
      }
      return minmax ;
    }
    mid=(low+high)/2 ;
    mml=getMinMax(arr,low,mid);
    mmr=getMinMax(arr,mid+1,high);
    if(mml.min<mmr.min){
      minmax.min=mml.min ;
    }
    else {
      minmax.min=mmr.min ;
    }
    if(mml.max>mmr.max){
      minmax.max=mml.max ;
    }
    else {
      minmax.max=mmr.max ;
    }
    return minmax ;
  }
  public static void main(String args[]){
    int arr[]={
      1000,11,445,1,330,3000 };
      int arr_size=6 ;
      Pair minmax=getMinMax(arr,0,arr_size-1);
      System.out.printf("\nMinimum element is %d",minmax.min);
      System.out.printf("\nMaximum element is %d",minmax.max);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Pair {
   attribute min : int;
   attribute max : int;
}
  static   operation getMinMax( arr : Sequence(int), low : int, high : int) : Map
  pre: true
  post: true
  activity: (     var minmax : Map ; minmax := Map() ;
     var mml : Map ; mml := Map() ;
    var mmr : Map ; mmr := Map() ;
    var mid : int ;
    if (low = high) then (     minmax.max := arr[low+1] ; 
     minmax.min := arr[low+1] ; 
     return minmax ) else skip ; 
    if (high = low + 1) then (     if (arr[low+1] > arr[high+1]) then (     minmax.max := arr[low+1] ; 
     minmax.min := arr[high+1] ) else (     minmax.max := arr[high+1] ; 
     minmax.min := arr[low+1] ) ;  
     return minmax ) else skip ; 
    mid := (low + high) / 2 ; 
    mml := getMinMax(arr, low, mid) ; 
    mmr := getMinMax(arr, mid + 1, high) ; 
    if (mml.min < mmr.min) then (     minmax.min := mml.min ) else (     minmax.min := mmr.min ) ;  
    if (mml.max > mmr.max) then (     minmax.max := mml.max ) else (     minmax.max := mmr.max ) ;  
    return minmax 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1000,11,445,1,330,3000} ;
     var arr_size : int ; arr_size := 6 ;
    var minmax : Map ; minmax := getMinMax(arr, 0, arr_size - 1) ;
    OclFile["System.out"].printf("\nMinimum element is %d", minmax.min) ; 
    OclFile["System.out"].printf("\nMaximum element is %d", minmax.max) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  public static long repeatedSum(long n){
    if(n==0)return 0 ;
    return(n % 9==0)? 9 :(n % 9);
  }
  public static long repeatedProduct(long n){
    long prod=1 ;
    while(n>0 || prod>9){
      if(n==0){
        n=prod ;
        prod=1 ;
      }
      prod*=n % 10 ;
      n/=10 ;
    }
    return prod ;
  }
  public static long maxSumProduct(long N){
    if(N<10)return N ;
    return Math.max(repeatedSum(N),repeatedProduct(N));
  }
  public static void main(String[] args){
    long n=631 ;
    System.out.println(maxSumProduct(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation repeatedSum( n : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else skip ; 
     return if (n mod 9 = 0) then 9 else (n mod 9) endif );
  static   operation repeatedProduct( n : long) : long
  pre: true
  post: true
  activity: (     var prod : long ; prod := 1 ;
     while (n > 0 or prod > 9) do (     if (n = 0) then (     n := prod ; 
     prod := 1 ) else skip ; 
     prod := prod*(n mod 10) ; 
     n := n/(10) ) ; 
     return prod );
  static   operation maxSumProduct( N : long) : long
  pre: true
  post: true
  activity: (     if (N < 10) then     return N else skip ; 
     return Set{repeatedSum(N), repeatedProduct(N)}->max() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 631 ;
     OclFile["System.out"].println(maxSumProduct(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static Scanner s=new Scanner(System.in);
  public static void main(String[] args){
    int n=s.nextInt();
    String a,b ;
    for(int i=0 ; i<n ; i++){
      a=s.next();
      b=s.next();
      int[][] c=new int[a.length()+1][b.length()+1];
      for(int j=1 ; j<=a.length(); j++){
        for(int k=1 ; k<=b.length(); k++){
          if(a.charAt(j-1)==b.charAt(k-1)){
            c[j][k]=c[j-1][k-1]+1 ;
          }
          else {
            c[j][k]=Math.max(c[j-1][k],c[j][k-1]);
          }
        }
      }
      System.out.println(c[a.length()][b.length()]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s.getCurrent()->toInteger() ;
     var a : String ;
    var b : String ;
         var i : int ; i := 0 ; while i < n do ( (     a := s.getCurrent() ; 
     b := s.getCurrent() ; 
    var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,a->size() + 1)->collect(Integer.subrange(1,b->size() + 1)->collect(0)) ;
        var j : int ; j := 1 ; while j <= a->size() do ( (         var k : int ; k := 1 ; while k <= b->size() do ( (     if (a->at(j - 1+1) = b->at(k - 1+1)) then (     c[j+1][k+1] := c[j - 1+1][k - 1+1] + 1 ) else (     c[j+1][k+1] := Set{c[j - 1+1][k+1], c[j+1][k - 1+1]}->max() ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(c[a->size()+1][b->size()+1]) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import static java.lang.Math.*;
import static java.lang.Integer.parseInt ;
class Main {
  final static PrintWriter out=new PrintWriter(System.out);
  final static BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  static int lcs(char[] a,char[] b){
    final int alen=a.length ;
    final int blen=b.length ;
    int dp[][]=new int[alen+1][blen+1];
    int maxl=0 ;
    for(int i=0 ; i<alen ; ++i){
      for(int j=0 ; j<blen ; ++j){
        if(a[i]==b[j])dp[i+1][j+1]=dp[i][j]+1 ;
        else dp[i+1][j+1]=max(dp[i][j+1],dp[i+1][j]);
        maxl=max(maxl,dp[i+1][j+1]);
      }
    }
    return(maxl);
  }
  public static void main(String[] args)throws IOException {
    final int N=parseInt(in.readLine());
    for(int i=0 ; i<N ; ++i){
      char[] a=in.readLine().toCharArray();
      char[] b=in.readLine().toCharArray();
      out.println(lcs(a,b));
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   operation lcs( a : Sequence(String), b : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var alen : int ; alen := a->size() ;
     var blen : int ; blen := b->size() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,alen + 1)->collect(Integer.subrange(1,blen + 1)->collect(0)) ;
    var maxl : int ; maxl := 0 ;
        var i : int ; i := 0 ; while i < alen do ( (         var j : int ; j := 0 ; while j < blen do ( (     if (a[i+1] = b[j+1]) then     dp[i + 1+1][j + 1+1] := dp[i+1][j+1] + 1 else     dp[i + 1+1][j + 1+1] := Set{dp[i+1][j + 1+1], dp[i + 1+1][j+1]}->max() ; ;  
     maxl := Set{maxl, dp[i + 1+1][j + 1+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return (maxl) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := parseInt(in.readLine()) ;
         var i : int ; i := 0 ; while i < N do ( (     var a : Sequence(String) ; a := in.readLine()->characters() ;
     var b : Sequence(String) ; b := in.readLine()->characters() ;
     skip )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    AizuLCS solver=new AizuLCS();
    solver.solve(1,in,out);
    out.close();
  }
  static class AizuLCS {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      while(n--!=0){
        String x=in.next();
        String y=in.next();
        out.printf("%d\n",lcs(x,y));
      }
    }
    private int lcs(final String x,final String y){
      int xlen=x.length();
      int ylen=y.length();
      int[][] dp=new int[xlen+1][ylen+1];
      for(int i=1 ; i<=xlen ; i++){
        for(int j=1 ; j<=ylen ; j++){
          int insertion=dp[i][j-1];
          int deletion=dp[i-1][j];
          if(x.charAt(i-1)==y.charAt(j-1)){
            dp[i][j]=Math.max(dp[i-1][j-1]+1,Math.min(insertion,deletion));
          }
          else {
            dp[i][j]=Math.max(insertion,deletion);
          }
        }
      }
      return dp[xlen][ylen];
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : AizuLCS ; solver := AizuLCS.newAizuLCS() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class AizuLCS {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
         while (n /= 0) do (    skip ; (     var x : String ; x := in.getCurrent() ;
     var y : String ; y := in.getCurrent() ;
     skip ) ;  ) );
   operation lcs( x : String, y : String) : int
  pre: true
  post: true
  activity: (     var xlen : int ; xlen := x->size() ;
     var ylen : int ; ylen := y->size() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,xlen + 1)->collect(Integer.subrange(1,ylen + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= xlen do ( (         var j : int ; j := 1 ; while j <= ylen do ( (     var insertion : int ; insertion := dp[i+1][j - 1+1] ;
     var deletion : int ; deletion := dp[i - 1+1][j+1] ;
     if (x->at(i - 1+1) = y->at(j - 1+1)) then (     dp[i+1][j+1] := Set{dp[i - 1+1][j - 1+1] + 1, Set{insertion, deletion}->min()}->max() ) else (     dp[i+1][j+1] := Set{insertion, deletion}->max() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return dp[xlen+1][ylen+1] 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  public void run(){
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      int q=Integer.parseInt(br.readLine());
      StringBuilder buf=new StringBuilder();
      for(int i=0 ; i<q ; i++){
        buf.append(deriveLcs(br.readLine(),br.readLine())).append("\n");
      }
      System.out.print(buf);
    }
    catch(IOException e){
      System.out.println("IOException!");
    }
  }
  private int deriveLcs(String seqX,String seqY){
    int m=seqX.length();
    int n=seqY.length();
    int[][] subSeq=new int[m+1][n+1];
    int maxSubSeq=0 ;
    for(int i=1 ; i<=m ; i++)subSeq[i][0]=0 ;
    for(int j=1 ; j<=n ; j++)subSeq[0][j]=0 ;
    for(int i=1 ; i<=m ; i++){
      for(int j=1 ; j<=n ; j++){
        if(seqX.charAt(i-1)==seqY.charAt(j-1))subSeq[i][j]=subSeq[i-1][j-1]+1 ;
        else subSeq[i][j]=Math.max(subSeq[i-1][j],subSeq[i][j-1]);
        maxSubSeq=Math.max(maxSubSeq,subSeq[i][j]);
      }
    }
    return maxSubSeq ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var q : int ; q := (br.readLine())->toInteger() ;
     var buf : String ; buf := StringLib.newString() ;
         var i : int ; i := 0 ; while i < q do ( (     buf := buf + StringLib.newString(deriveLcs(br.readLine(), br.readLine())) + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(buf) ))   catch (e : IOException) do (     OclFile["System.out"].println("IOException!") )
  );
   operation deriveLcs( seqX : String, seqY : String) : int
  pre: true
  post: true
  activity: (     var m : int ; m := seqX->size() ;
     var n : int ; n := seqY->size() ;
    var subSeq : Sequence(Sequence(int)) ; subSeq := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
    var maxSubSeq : int ; maxSubSeq := 0 ;
        var i : int ; i := 1 ; while i <= m do (     subSeq[i+1][0+1] := 0 ;  ;     i := i + 1 ) ; 
        var j : int ; j := 1 ; while j <= n do (     subSeq[0+1][j+1] := 0 ;  ;     j := j + 1 ) ; 
        var i : int ; i := 1 ; while i <= m do ( (         var j : int ; j := 1 ; while j <= n do ( (     if (seqX->at((i)->char2byte() - 1+1) = seqY->at(j - 1+1)) then     subSeq[i+1][j+1] := subSeq[(i)->char2byte() - 1+1][j - 1+1] + 1 else     subSeq[i+1][j+1] := Set{subSeq[(i)->char2byte() - 1+1][j+1], subSeq[i+1][j - 1+1]}->max() ; ;  
     maxSubSeq := Set{maxSubSeq, subSeq[i+1][j+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return maxSubSeq 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int s=sc.nextInt();
      int g1=sc.nextInt();
      int g2=sc.nextInt();
      if(n==0 && m==0 && s==0 && g1==0 && g2==0)break ;
      int[][] cost=new int[n+1][n+1];
      for(int i=1 ; i<=n ; i++){
        for(int j=1 ; j<=n ; j++){
          cost[i][j]=Integer.MAX_VALUE ;
        }
      }
      for(int i=0 ; i<m ; i++)cost[sc.nextInt()][sc.nextInt()]=sc.nextInt();
      for(int i=1 ; i<=n ; i++)cost[i][i]=0 ;
      for(int i=1 ; i<=n ; i++){
        for(int j=1 ; j<=n ; j++){
          for(int k=1 ; k<=n ; k++){
            if(cost[j][i]!=Integer.MAX_VALUE && cost[i][k]!=Integer.MAX_VALUE){
              cost[j][k]=Math.min(cost[j][k],cost[j][i]+cost[i][k]);
            }
          }
        }
      }
      int min=Integer.MAX_VALUE ;
      for(int i=1 ; i<=n ; i++){
        if(cost[s][i]!=Integer.MAX_VALUE && cost[i][g1]!=Integer.MAX_VALUE && cost[i][g2]!=Integer.MAX_VALUE){
          min=Math.min(min,cost[s][i]+cost[i][g1]+cost[i][g2]);
        }
      }
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var g1 : int ; g1 := sc.getCurrent()->toInteger() ;
    var g2 : int ; g2 := sc.getCurrent()->toInteger() ;
    if (n = 0 & m = 0 & s = 0 & g1 = 0 & g2 = 0) then     break else skip ; 
    var cost : Sequence(Sequence(int)) ; cost := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     cost[i+1][j+1] := 2147483647 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     cost[sc.getCurrent()->toInteger()+1][sc.getCurrent()->toInteger()+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (     cost[i+1][i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (         var k : int ; k := 1 ; while k <= n do ( (     if (cost[j+1][i+1] /= 2147483647 & cost[i+1][k+1] /= 2147483647) then (     cost[j+1][k+1] := Set{cost[j+1][k+1], cost[j+1][i+1] + cost[i+1][k+1]}->min() ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (cost[s+1][i+1] /= 2147483647 & cost[i+1][g1+1] /= 2147483647 & cost[i+1][g2+1] /= 2147483647) then (     min := Set{min, cost[s+1][i+1] + cost[i+1][g1+1] + cost[i+1][g2+1]}->min() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static StringBuilder sb ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sb=new StringBuilder();
    List<Long>ans=new ArrayList<>();
    ans.add(sc.nextLong());
    ans.add(~ ans.get(0));
    ans.add(ans.get(0)<<1);
    ans.add(ans.get(0)>>1);
    for(int i=0 ; i<ans.size(); i++){
      String s=String.format("%32s",Long.toBinaryString(ans.get(i))).replace(" ","0");
      String str=s.substring(s.length()-32,s.length());
      sb.append(str).append("\n");
    }
    PrintWriter out=new PrintWriter(System.out);
    out.print(sb);
    out.flush();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sb : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     sb := StringLib.newString() ; 
    var ans : Sequence(long) ; ans := Sequence{} ;
    ans := ans->including(sc.getCurrent()->toLong()) ; 
    ans := ans->including(-(ans->at(0+1) + 1)) ; 
    ans := ans->including((ans->at(0+1)*(2->pow(1)))->oclAsType(long)) ; 
    ans := ans->including((ans->at(0+1)/(2->pow(1)))->oclAsType(long)) ; 
        var i : int ; i := 0 ; while i < ans->size() do ( (     var s : String ; s := StringLib.format("%32s",Sequence{(MathLib.decimal2binary(ans->at(i+1)) + "")}).replace(" ", "0") ;
     var str : String ; str := s.subrange(s->size() - 32+1,s->size()) ;
     sb := sb + StringLib.newString(str) + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countUnsetBits(int n){
    int x=n ;
    n |=n>>1 ;
    n |=n>>2 ;
    n |=n>>4 ;
    n |=n>>8 ;
    n |=n>>16 ;
    return Integer.bitCount(x ^ n);
  }
  public static void main(String[] args){
    int n=17 ;
    System.out.println(countUnsetBits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countUnsetBits( n : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := n ;
     n := MathLib.bitwiseOr(n, (n/(2->pow(1)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(2)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(4)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(8)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(16)))->oclAsType(long)) ; 
    return bitCount(MathLib.bitwiseXor(x,n)) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 17 ;
     OclFile["System.out"].println(countUnsetBits(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int a=sc.nextInt(),l=sc.nextInt(),x=sc.nextInt();
      double t=(2*l+a)/2.,s=(2*l+x)/2.;
      System.out.printf("%.8f\n",2*Math.sqrt(s*(s-l)*(s-(l+x)/2.)*(s-(l+x)/2.))+Math.sqrt(t*(t-a)*(t-l)*(t-l)));
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
     var t : double ; t := (2 * l + a) / 2. ;
    var s : double ; s := (2 * l + x) / 2. ;
     OclFile["System.out"].printf("%.8f\n", 2 * (s * (s - l) * (s - (l + x) / 2.) * (s - (l + x) / 2.))->sqrt() + (t * (t - a) * (t - l) * (t - l))->sqrt()) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  private static int[][] cache ;
  private static char[] x ;
  private static char[] y ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int set=sc.nextInt();
    for(int k=0 ; k<set ; k++){
      x=sc.next().toCharArray();
      y=sc.next().toCharArray();
      int m=x.length ;
      int n=y.length ;
      cache=new int[m+1][n+1];
      for(int i=1 ; i<=m ; i++){
        Arrays.fill(cache[i],Integer.MIN_VALUE);
        cache[i][0]=0 ;
      }
      Arrays.fill(cache[0],0);
      System.out.println(lcs(m,n));
    }
    sc.close();
  }
  private static int lcs(int m,int n){
    if(cache[m][n]!=Integer.MIN_VALUE){
      return cache[m][n];
    }
    int result ;
    if(x[m-1]==y[n-1]){
      result=lcs(m-1,n-1)+1 ;
    }
    else {
      result=Math.max(lcs(m-1,n),lcs(m,n-1));
    }
    cache[m][n]=result ;
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute cache : Sequence(Sequence(int));
  static   attribute x : Sequence(String);
  static   attribute y : Sequence(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var set : int ; set := sc.getCurrent()->toInteger() ;
         var k : int ; k := 0 ; while k < set do ( (     x := sc.getCurrent()->characters() ; 
     y := sc.getCurrent()->characters() ; 
    var m : int ; m := x->size() ;
    var n : int ; n := y->size() ;
    cache := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ; 
        var i : int ; i := 1 ; while i <= m do ( (     cache[i+1] := cache[i+1]->collect(-2147483648) ; 
     cache[i+1][0+1] := 0 )  ;     i := i + 1 ) ; 
    cache[0+1] := cache[0+1]->collect(0) ; 
    OclFile["System.out"].println(lcs(m, n)) ; 
 )  ;     k := k + 1 ) ; 
     skip );
  static   operation lcs( m : int, n : int) : int
  pre: true
  post: true
  activity: (     if (cache[m+1][n+1] /= -2147483648) then (     return cache[m+1][n+1] ) else skip ; 
     var result : int ;
    if (x[m - 1+1] = y[n - 1+1]) then (     result := lcs(m - 1, n - 1) + 1 ) else (     result := Set{lcs(m - 1, n), lcs(m, n - 1)}->max() ) ;  
    cache[m+1][n+1] := result ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static long getTrailingZeroes(long n){
    long count=0 ;
    long val,powerTwo=2 ;
    do {
      val=n/powerTwo ;
      count+=val ;
      powerTwo*=2 ;
    }
    while(val!=0);
    return(count/4);
  }
  public static void main(String[] args){
    int n=6 ;
    System.out.println(getTrailingZeroes(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation getTrailingZeroes( n : long) : long
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
     var val : long ;
    var powerTwo : long ; powerTwo := 2 ;
   while true do ((     val := n / powerTwo ; 
     count := count+(val) ; 
     powerTwo := powerTwo*(2) ) ;
    if (val /= 0) then skip else break) ; 
     return (count / 4) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(getTrailingZeroes(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  public static int calculateDivisors(int A,int B){
    int N=(A-B);
    int noOfDivisors=0 ;
    for(int i=1 ; i<=Math.sqrt(N); i++){
      if((N % i)==0){
        if(i>B)noOfDivisors++;
        if((N/i)!=i &&(N/i)>B)noOfDivisors++;
      }
    }
    return noOfDivisors ;
  }
  public static int numberOfPossibleWaysUtil(int A,int B){
    if(A==B)return-1 ;
    if(A<B)return 0 ;
    int noOfDivisors=0 ;
    noOfDivisors=calculateDivisors(A,B);
    return noOfDivisors ;
  }
  public static void numberOfPossibleWays(int A,int B){
    int noOfSolutions=numberOfPossibleWaysUtil(A,B);
    if(noOfSolutions==-1){
      System.out.print("For A="+A+" and B="+B+",X can take Infinitely many values"+" greater than "+A+"\n");
    }
    else {
      System.out.print("For A="+A+" and B="+B+",X can take "+noOfSolutions+" values\n");
    }
  }
  public static void main(String[] args){
    int A=26,B=2 ;
    numberOfPossibleWays(A,B);
    A=21 ;
    B=5 ;
    numberOfPossibleWays(A,B);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculateDivisors( A : int, B : int) : int
  pre: true
  post: true
  activity: (     var N : int ; N := (A - B) ;
     var noOfDivisors : int ; noOfDivisors := 0 ;
         var i : int ; i := 1 ; while i <= (N)->sqrt() do ( (     if ((N mod i) = 0) then (     if (i > B) then     noOfDivisors := noOfDivisors + 1 ; else skip ; 
     if ((N / i) /= i & (N / i) > B) then     noOfDivisors := noOfDivisors + 1 ; else skip ) else skip )  ;     i := i + 1 ) ; 
     return noOfDivisors );
  static   operation numberOfPossibleWaysUtil( A : int, B : int) : int
  pre: true
  post: true
  activity: (     if (A = B) then     return -1 else skip ; 
     if (A < B) then     return 0 else skip ; 
    var noOfDivisors : int ; noOfDivisors := 0 ;
    noOfDivisors := calculateDivisors(A, B) ; 
    return noOfDivisors 
 );
  static   operation numberOfPossibleWays( A : int, B : int) : void
  pre: true
  post: true
  activity: (     var noOfSolutions : int ; noOfSolutions := numberOfPossibleWaysUtil(A, B) ;
     if (noOfSolutions = -1) then (     OclFile["System.out"].print("For A=" + A + " and B=" + B + ",X can take Infinitely many values" + " greater than " + A + "\n") ) else (     OclFile["System.out"].print("For A=" + A + " and B=" + B + ",X can take " + noOfSolutions + " values\n") ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 26 ;
    var B : int ; B := 2 ;
     execute numberOfPossibleWays(A, B) ; 
    A := 21 ; 
    B := 5 ; 
    execute numberOfPossibleWays(A, B) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    char[] input ;
    StringBuffer ret=new StringBuffer();
    Scanner scanner=new Scanner(System.in);
    input=scanner.nextLine().toCharArray();
    for(int i=0 ; i<input.length ; i++){
      char c=input[i];
      if(c>='A' && c<='C'){
        c+=26 ;
      }
      c-=3 ;
      ret.append(c);
    }
    System.out.println(ret.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : Sequence(String) ;
     var ret : String ; ret := StringLib.newString() ;
    var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    input := scanner.nextLine()->characters() ; 
        var i : int ; i := 0 ; while i < input->size() do ( (     var c : String ; c := input[i+1] ;
     if (c >= 'A' & c <= 'C') then (     c := c+(26) ) else skip ; 
     c := c-(3) ; 
     ret := ret + StringLib.newString(c) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ret+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.Map ;
public class Main {
  public static void main(String[] args)throws Exception {
    Map<String,String>map=new HashMap<String,String>();
    byte[] asciiCodes1=new byte[26];
    byte[] asciiCodes2=new byte[26];
    int j=0 ;
    for(byte i=0 ; i<26 ; i++){
      asciiCodes1[j]=(byte)((byte)65+i);
      asciiCodes2[j]=(byte)((byte)68+i);
      j++;
    }
    asciiCodes2[23]=(byte)((byte)65);
    asciiCodes2[24]=(byte)((byte)66);
    asciiCodes2[25]=(byte)((byte)67);
    String resultString2=new String(asciiCodes1,"US-ASCII");
    String resultString=new String(asciiCodes2,"US-ASCII");
    for(int i=0 ; i<26 ; i++){
      map.put(resultString.substring(i,i+1),resultString2.substring(i,i+1));
    }
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String line,str="" ;
      while((line=br.readLine())!=null){
        for(int k=0 ; k<line.length(); k++){
          str+=map.get(line.substring(k,k+1));
        }
        System.out.println(str);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var map : Map(String,String) ; map := Map{} ;
     var asciiCodes1 : Sequence(int) ; asciiCodes1 := Integer.subrange(1,26)->collect(0) ;
    var asciiCodes2 : Sequence(int) ; asciiCodes2 := Integer.subrange(1,26)->collect(0) ;
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < 26 do ( (     asciiCodes1[j+1] := (((65 mod 128) + i) mod 128) ; 
     asciiCodes2[j+1] := (((68 mod 128) + i) mod 128) ; 
     j := j + 1 )  ;     i := i + 1 ) ; 
    asciiCodes2[23+1] := (((65 mod 128)) mod 128) ; 
    asciiCodes2[24+1] := (((66 mod 128)) mod 128) ; 
    asciiCodes2[25+1] := (((67 mod 128)) mod 128) ; 
    var resultString2 : String ; resultString2 := StringLib.newString(asciiCodes1, "US-ASCII") ;
    var resultString : String ; resultString := StringLib.newString(asciiCodes2, "US-ASCII") ;
        var i : int ; i := 0 ; while i < 26 do ( (     map := map->union(Map{resultString.subrange(i+1,i + 1) |-> resultString2.subrange(i+1,i + 1)}) )  ;     i := i + 1 ) ; 
    try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var line : String ;
    var str : String ; str := "" ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (         var k : int ; k := 0 ; while k < line->size() do ( (     str := str+(map->at(line.subrange(k+1,k + 1))) )  ;     k := k + 1 ) ; 
     OclFile["System.out"].println(str) ; 
     break ) ;     line := br.readLine() ;
 ) ))  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static final int RECT_COUNT=0 ;
  public static final int Q_NUMBER=1 ;
  public static void main(String[] args)throws IOException {
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    String beforeStr=bufferedReader.readLine();
    String afterAtr="" ;
    for(int i=0 ; i<beforeStr.length(); i++){
      switch(getStringCharAt(beforeStr,i)){
        case "A" : afterAtr+="X" ;
        break ;
        case "B" : afterAtr+="Y" ;
        break ;
        case "C" : afterAtr+="Z" ;
        break ;
        default : afterAtr+=String.valueOf((char)(beforeStr.charAt(i)-3));
      }
    }
    System.out.println(afterAtr);
  }
  public static String getStringCharAt(String str,int position){
    return String.valueOf(str.charAt(position));
  }
  public static String[] getStringCharArr(String str){
    String[] arrResult=new String[str.length()];
    for(int i=0 ; i<str.length(); i++)arrResult[i]=getStringCharAt(str,i);
    return arrResult ;
  }
  public static boolean isInnerPosition(int x1,int x2,int searchPosition){
    return x1<=searchPosition && searchPosition<=x2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute RECT_COUNT : int := 0;
  static    attribute Q_NUMBER : int := 1;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var beforeStr : String ; beforeStr := bufferedReader.readLine() ;
    var afterAtr : String ; afterAtr := "" ;
        var i : int ; i := 0 ; while i < beforeStr->size() do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (getStringCharAt(beforeStr, i)) ; 
       if _switchval = "A" then
     afterAtr := afterAtr+("X") ; 
    break 
   else skip ;
       if _switchval = "B" then
     afterAtr := afterAtr+("Y") ; 
    break 
   else skip ;
       if _switchval = "C" then
     afterAtr := afterAtr+("Z") ; 
    break 
   else skip ;
       if true then
     afterAtr := afterAtr+((((beforeStr->at(i+1) - 3)->oclAsType(String)) + "")) ; 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(afterAtr) ; 
 );
  static   operation getStringCharAt( str : String, position : int) : String
  pre: true
  post: true
  activity: (     return ((str->at(position+1)) + "") );
  static   operation getStringCharArr( str : String) : Sequence(String)
  pre: true
  post: true
  activity: (     var arrResult : Sequence(String) ; arrResult := Integer.subrange(1,str->size())->collect(null) ;
         var i : int ; i := 0 ; while i < str->size() do (     arrResult[i+1] := getStringCharAt(str, i) ;  ;     i := i + 1 ) ; 
     return arrResult );
  static   operation isInnerPosition( x1 : int, x2 : int, searchPosition : int) : boolean
  pre: true
  post: true
  activity: (     return x1 <= searchPosition & searchPosition <= x2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args){
    SC sc=new SC(System.in);
    String s=sc.next();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<s.length(); i++){
      sb.append((char)((s.charAt(i)-68+26)% 26+65));
    }
    pl(sb.toString());
  }
  public static void pl(Object o){
    System.out.println(o);
  }
  public static void pl(){
    System.out.println();
  }
  public static void p(Object o){
    System.out.print(o);
  }
  static class SC {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public SC(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        throw new UncheckedIOException(e);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : SC ; sc := SC.newSC(OclFile["System.in"]) ;
     var s : String ; s := sc.next() ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     sb := sb + StringLib.newString(((s->at(i+1) - 68 + 26) mod 26 + 65)->oclAsType(String)) )  ;     i := i + 1 ) ; 
    execute pl(sb+"") ; 
 );
  static   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation pl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
  static class SC {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newSC( in : OclFile) : SC
  pre: true
  post: true
  activity:
  ( var self : SC ;
    self := createSC();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new aoj510().doIt();
  }
  class aoj510 {
    void alf(char ctr[]){
      for(char c='A' ; c<='Z' ; c++){
        if(c<'D')ctr[c]=(char)(c+23);
        else ctr[c]=(char)(c-3);
      }
    }
    void doIt(){
      char ctr[]=new char[128];
      alf(ctr);
      char str[]=sc.next().toCharArray();
      int length=str.length ;
      StringBuilder sb=new StringBuilder();
      for(int i=0 ; i<length ; i++){
        sb.append(ctr[str[i] ]);
      }
      System.out.println(sb);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     aoj510.newaoj510().doIt() );
 class aoj510 {
   operation alf( ctr : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var c : String ; c := 'A' ; while c <= 'Z' do ( (     if (c < 'D') then     ctr[c+1] := (c + 23)->oclAsType(String) ; else     ctr[c+1] := ((c)->char2byte() - 3)->oclAsType(String) ; )  ;     c := c + 1 ) );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var ctr : Sequence(String) ; ctr := Integer.subrange(1,128)->collect(0) ;
     execute alf(ctr) ; 
    var str : Sequence(String) ; str := sc.getCurrent()->characters() ;
    var length : int ; length := str->size() ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < length do ( (     sb := sb + StringLib.newString(ctr[str[i+1]+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int extraElement(int A[],int B[],int n){
    int ans=0 ;
    for(int i=0 ; i<n ; i++)ans ^=A[i];
    for(int i=0 ; i<n+1 ; i++)ans ^=B[i];
    return ans ;
  }
  public static void main(String[] args){
    int A[]={
      10,15,5 };
      int B[]={
        10,100,15,5 };
        int n=A.length ;
        System.out.println(extraElement(A,B,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation extraElement( A : Sequence(int), B : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do (     ans := MathLib.bitwiseXor(ans,A[i+1]) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n + 1 do (     ans := MathLib.bitwiseXor(ans,B[i+1]) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{10,15,5} ;
     var B : Sequence(int) ; B := Sequence{10,100,15,5} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].println(extraElement(A, B, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int minOperations(int[] arr,int n){
    int maxi,result=0 ;
    int[] freq=new int[1000001];
    for(int i=0 ; i<n ; i++){
      int x=arr[i];
      freq[x]++;
    }
    maxi=Arrays.stream(arr).max().getAsInt();
    for(int i=1 ; i<=maxi ; i++){
      if(freq[i]!=0){
        for(int j=i*2 ; j<=maxi ; j=j+i){
          freq[j]=0 ;
        }
        result++;
      }
    }
    return result ;
  }
  public static void main(String[] args){
    int arr[]={
      2,4,2,4,4,4 };
      int n=arr.length ;
      System.out.println(minOperations(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minOperations( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var maxi : int ;
    var result : int ; result := 0 ;
     var freq : Sequence(int) ; freq := Integer.subrange(1,1000001)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := arr[i+1] ;
     freq[x+1] := freq[x+1] + 1 )  ;     i := i + 1 ) ; 
    maxi := stream(arr).max().getAsInt() ; 
        var i : int ; i := 1 ; while i <= maxi do ( (     if (freq[i+1] /= 0) then (         var j : int ; j := i * 2 ; while j <= maxi do ( (     freq[j+1] := 0 )  ;     j := j + i ) ; 
     result := result + 1 ) else skip )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,2,4,4,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minOperations(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Q1 {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int start=97 ;
    int moves=0 ;
    String s=scan.next();
    for(int i=0 ; i<s.length(); i++){
      int result=Math.abs(s.charAt(i)-start);
      if(result<=13)moves+=result ;
      else moves+=(26-result);
      start=s.charAt(i);
    }
    System.out.print(moves+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Q1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var start : int ; start := 97 ;
    var moves : int ; moves := 0 ;
    var s : String ; s := scan.getCurrent() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var result : int ; result := if s->at(i+1) - start < 0 then -(s->at(i+1) - start) else s->at(i+1) - start endif ;
     if (result <= 13) then     moves := moves+(result) else     moves := moves+((26 - result)) ; ;  
     start := s->at(i+1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(moves + "\n") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.ListIterator ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static final double EPS=1e-10 ;
  public static final double heron(double a,double b,double c){
    double s=(a+b+c)/2 ;
    return Math.sqrt(s*(s-a)*(s-b)*(s-c));
  }
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    while(sc.hasNextInt()){
      final int a=sc.nextInt();
      final int l=sc.nextInt();
      final int x=sc.nextInt();
      final double a_harf=a/2.0 ;
      double area=Math.sin(Math.acos(a_harf/l))*l*a_harf ;
      final double max_len=l+x ;
      double hi=(l+x)/2.0-EPS ;
      double low=EPS ;
      while(hi-low>EPS){
        final double upper=(hi*2+low)/3 ;
        final double lower=(hi+low*2)/3 ;
        final double upper_value=heron(l,upper,max_len-upper);
        final double lower_value=heron(l,lower,max_len-lower);
        if(Double.isNaN(lower_value)|| upper_value>lower_value){
          low=lower ;
        }
        else {
          hi=upper ;
        }
      }
      final double value=(low+hi)/2 ;
      area+=heron(l,value,max_len-value)*2 ;
      System.out.printf("%.10f\n",area);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute EPS : double := 1e-10;
  static    operation heron( a : double, b : double, c : double) : double
  pre: true
  post: true
  activity: (     var s : double ; s := (a + b + c) / 2 ;
     return (s * (s - a) * (s - b) * (s - c))->sqrt() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextInt()) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var a_harf : double ; a_harf := a / 2.0 ;
    var area : double ; area := ((a_harf / l)->acos())->sin() * l * a_harf ;
    var max_len : double ; max_len := l + x ;
    var hi : double ; hi := (l + x) / 2.0 - EPS ;
    var low : double ; low := EPS ;
    while (hi - low > EPS) do (     var upper : double ; upper := (hi * 2 + low) / 3 ;
     var lower : double ; lower := (hi + low * 2) / 3 ;
    var upper_value : double ; upper_value := heron(l, upper, max_len - upper) ;
    var lower_value : double ; lower_value := heron(l, lower, max_len - lower) ;
    if ((lower_value)->oclIsInvalid() or upper_value > lower_value) then (     low := lower ) else (     hi := upper ) ;  
 ) ; 
    var value : double ; value := (low + hi) / 2 ;
    area := area+(heron(l, value, max_len - value) * 2) ; 
    OclFile["System.out"].printf("%.10f\n", area) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Ex3 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=1 ;
    for(int oo=0 ; oo<t ; oo++){
      String str=in.nextLine();
      int len=str.length();
      int x=Math.abs(str.charAt(0)-'a');
      int ans=0 ;
      if(x>13){
        ans+=(26-x);
      }
      else {
        ans+=x ;
      }
      for(int i=1 ; i<len ; i++){
        x=Math.abs(str.charAt(i)-str.charAt(i-1));
        if(x>13){
          ans+=(26-x);
        }
        else {
          ans+=x ;
        }
      }
      System.out.println(ans);
    }
  }
  public class ListNode<E>{
    private E value ;
    private ListNode next ;
    public ListNode(E newVal,ListNode<E>newNext){
      value=newVal ;
      next=newNext ;
    }
    public E getValue(){
      return value ;
    }
    public ListNode<E>getNext(){
      return next ;
    }
    public void setValue(E newValue){
      value=newValue ;
    }
    public void setNext(ListNode<E>newNext){
      next=newNext ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ex3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
         var oo : int ; oo := 0 ; while oo < t do ( (     var str : String ; str := in.nextLine() ;
     var len : int ; len := str->size() ;
    var x : int ; x := if str->at(0+1) - ('a')->char2byte() < 0 then -(str->at(0+1) - ('a')->char2byte()) else str->at(0+1) - ('a')->char2byte() endif ;
    var ans : int ; ans := 0 ;
    if (x > 13) then (     ans := ans+((26 - x)) ) else (     ans := ans+(x) ) ;  
        var i : int ; i := 1 ; while i < len do ( (     x := if str->at(i+1) - str->at(i - 1+1) < 0 then -(str->at(i+1) - str->at(i - 1+1)) else str->at(i+1) - str->at(i - 1+1) endif ; 
     if (x > 13) then (     ans := ans+((26 - x)) ) else (     ans := ans+(x) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     oo := oo + 1 ) );
 class ListNode<E> {
   attribute value : E;
   attribute next : ListNode;
   static operation newListNode( newVal : E, newNext : ListNode<E>) : ListNode
  pre: true
  post: true
  activity:
  ( var self : ListNode ;
    self := createListNode();
    self.initialise(newVal, newNext);
    return self );
  operation initialise( newVal : E, newNext : ListNode<E>) : void
  pre: true  post: true
  activity: (     value := newVal ; 
     next := newNext );
   operation getValue() : E
  pre: true
  post: true
  activity: (     return value );
   operation getNext() : ListNode<E>
  pre: true
  post: true
  activity: (     return next );
   operation setValue( newValue : E) : void
  pre: true
  post: true
  activity: (     value := newValue );
   operation setNext( newNext : ListNode<E>) : void
  pre: true
  post: true
  activity: (     next := newNext );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test163 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char n[]=in.next().toCharArray();
    int a=97 ;
    int sum=0 ;
    for(int i=0 ; i<n.length ; i++){
      int x=0 ;
      if(a>n[i]){
        while(a>n[i]){
          a--;
          x++;
        }
      }
      else {
        while(a<n[i]){
          a++;
          x++;
        }
      }
      if(x>13){
        x=26-x ;
      }
      sum+=x ;
    }
    System.out.println(sum);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test163 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : Sequence(String) ; n := in.getCurrent()->characters() ;
    var a : int ; a := 97 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n->size() do ( (     var x : int ; x := 0 ;
     if (a > n[i+1]) then (     while (a > n[i+1]) do (     a := a - 1 ; 
     x := x + 1 ) ) else (     while (a < n[i+1]) do (     a := a + 1 ; 
     x := x + 1 ) ) ;  
     if (x > 13) then (     x := 26 - x ) else skip ; 
     sum := sum+(x) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int rotations=0 ;
    char ptr='a' ;
    for(int i=0 ; i<s.length(); i++){
      char c=s.charAt(i);
      if(c>ptr)rotations+=Math.min(ptr-'a'+'z'-c+1,c-ptr);
      else if(c<ptr)rotations+=Math.min(ptr-c,'z'-ptr+c-'a'+1);
      ptr=c ;
    }
    System.out.println(rotations);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var rotations : int ; rotations := 0 ;
    var ptr : String ; ptr := 'a' ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var c : String ; c := s->at(i+1) ;
     if (c > ptr) then     rotations := rotations+(Set{(ptr)->char2byte() - ('a')->char2byte() + 'z' - (c)->char2byte() + 1, (c)->char2byte() - (ptr)->char2byte()}->min()) else     if (c < ptr) then     rotations := rotations+(Set{(ptr)->char2byte() - (c)->char2byte(), ('z')->char2byte() - (ptr)->char2byte() + c - ('a')->char2byte() + 1}->min()) ; else skip ; ;  
     ptr := c )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(rotations) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CodeForces {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int start=0,add=0 ;
    for(int i=0 ; i<s.length(); i++){
      int index=s.charAt(i)-97 ;
      int move=Math.abs(start-index);
      if(move<13)add+=move ;
      else add+=26-move ;
      start=index ;
    }
    System.out.println(add);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var start : int ; start := 0 ;
    var add : int ; add := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var index : int ; index := s->at(i+1) - 97 ;
     var move : int ; move := if (start)->char2byte() - index < 0 then -((start)->char2byte() - index) else (start)->char2byte() - index endif ;
     if (move < 13) then     add := add+(move) else     add := add+(26 - move) ; ;  
     start := index )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(add) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector ;
class Test {
  static final int MAX_SIZE=1000001 ;
  static Vector<Boolean>isprime=new Vector<>(MAX_SIZE);
  static Vector<Integer>prime=new Vector<>();
  static Vector<Integer>SPF=new Vector<>(MAX_SIZE);
  static void manipulated_seive(int N){
    isprime.set(0,false);
    isprime.set(1,false);
    for(int i=2 ; i<N ; i++){
      if(isprime.get(i)){
        prime.add(i);
        SPF.set(i,i);
      }
      for(int j=0 ; j<prime.size()&& i*prime.get(j)<N && prime.get(j)<=SPF.get(i); j++){
        isprime.set(i*prime.get(j),false);
        SPF.set(i*prime.get(j),prime.get(j));
      }
    }
  }
  public static void main(String args[]){
    int N=13 ;
    for(int i=0 ; i<MAX_SIZE ; i++){
      isprime.add(true);
      SPF.add(2);
    }
    manipulated_seive(N);
    for(int i=0 ; i<prime.size()&& prime.get(i)<=N ; i++)System.out.print(prime.get(i)+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static    attribute MAX_SIZE : int := 1000001;
  static   attribute isprime : Sequence(Boolean) := Sequence{};
  static   attribute prime : Sequence(int) := Sequence{};
  static   attribute SPF : Sequence(int) := Sequence{};
  static   operation manipulated_seive( N : int) : void
  pre: true
  post: true
  activity: (     isprime := isprime.setAt(0+1,false) ; 
     isprime := isprime.setAt(1+1,false) ; 
         var i : int ; i := 2 ; while i < N do ( (     if (isprime->at(i+1)) then (     prime := prime->including(i) ; 
     SPF := SPF.setAt(i+1,i) ) else skip ; 
         var j : int ; j := 0 ; while j < prime->size() & i * prime->at(j+1) < N & prime->at(j+1) <= SPF->at(i+1) do ( (     isprime := isprime.setAt(i * prime->at(j+1)+1,false) ; 
     SPF := SPF.setAt(i * prime->at(j+1)+1,prime->at(j+1)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 13 ;
         var i : int ; i := 0 ; while i < MAX_SIZE do ( (     isprime := isprime->including(true) ; 
     SPF := SPF->including(2) )  ;     i := i + 1 ) ; 
     execute manipulated_seive(N) ; 
         var i : int ; i := 0 ; while i < prime->size() & prime->at(i+1) <= N do (     OclFile["System.out"].print(prime->at(i+1) + " ") ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
public class ColoringATree {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(reader.readLine());
    Map<Integer,TreeNode>idMap=new HashMap<>();
    Map<Integer,Integer>parentMap=new HashMap<>();
    for(int i=1 ; i<=n ; i++)idMap.put(i,new TreeNode(i));
    String[] temp=reader.readLine().split("\\s+");
    for(int i=0 ; i<temp.length ; i++){
      int id=i+2 ;
      int parentId=Integer.parseInt(temp[i]);
      parentMap.put(id,parentId);
      idMap.get(parentId).children.add(idMap.get(id));
    }
    Map<Integer,Integer>colorMap=new HashMap<>();
    temp=reader.readLine().split("\\s+");
    for(int i=0 ; i<temp.length ; i++){
      colorMap.put(i+1,Integer.parseInt(temp[i]));
    }
    System.out.println(dfs(idMap.get(1),colorMap));
  }
  private static int dfs(TreeNode root,Map<Integer,Integer>colorMap){
    if(root==null)return 0 ;
    int ans=root.color==colorMap.get(root.id)? 0 : 1 ;
    root.color=colorMap.get(root.id);
    for(TreeNode child : root.children){
      child.color=root.color ;
      ans+=dfs(child,colorMap);
    }
    return ans ;
  }
  static class TreeNode {
    int id ;
    int color ;
    List<TreeNode>children ;
    public TreeNode(int id){
      this.id=id ;
      children=new ArrayList<>();
      color=0 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ColoringATree {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (reader.readLine())->toInteger() ;
    var idMap : Map(int,TreeNode) ; idMap := Map{} ;
    var parentMap : Map(int,int) ; parentMap := Map{} ;
        var i : int ; i := 1 ; while i <= n do (     idMap := idMap->union(Map{i |-> TreeNode.newTreeNode(i)}) ;  ;     i := i + 1 ) ; 
    var temp : Sequence(String) ; temp := reader.readLine()->split("\\s+") ;
        var i : int ; i := 0 ; while i < temp->size() do ( (     var id : int ; id := i + 2 ;
     var parentId : int ; parentId := (temp[i+1])->toInteger() ;
     parentMap := parentMap->union(Map{id |-> parentId}) ; 
     idMap->at(parentId).children->excludes(idMap->at(id)) )  ;     i := i + 1 ) ; 
    var colorMap : Map(int,int) ; colorMap := Map{} ;
    temp := reader.readLine()->split("\\s+") ; 
        var i : int ; i := 0 ; while i < temp->size() do ( (     colorMap := colorMap->union(Map{i + 1 |-> (temp[i+1])->toInteger()}) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dfs(idMap->at(1), colorMap)) ; 
 );
  static   operation dfs( root : TreeNode, colorMap : Map(int,int)) : int
  pre: true
  post: true
  activity: (     if (root = null) then     return 0 else skip ; 
     var ans : int ; ans := if root.color = colorMap->at(root.id) then 0 else 1 endif ;
    root.color := colorMap->at(root.id) ; 
    for (child : root.children) do ( (     child.color := root.color ; 
     ans := ans+(dfs(child, colorMap)) )  ) ; 
    return ans 
 );
  static class TreeNode {
   attribute id : int;
   attribute color : int;
   attribute children : Sequence(TreeNode);
   static operation newTreeNode( id : int) : TreeNode
  pre: true
  post: true
  activity:
  ( var self : TreeNode ;
    self := createTreeNode();
    self.initialise(id);
    return self );
  operation initialise( id : int) : void
  pre: true  post: true
  activity: (     self.id := id ; 
     children := Sequence{} ; 
     color := 0 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
import java.util.stream.IntStream ;
import javafx.util.Pair ;
public class Main {
  static void sort(int a[]){
    Random ran=new Random();
    for(int i=0 ; i<a.length ; i++){
      int r=ran.nextInt(a.length);
      int temp=a[r];
      a[r]=a[i];
      a[i]=temp ;
    }
    Arrays.sort(a);
  }
  public static void main(String[] args)throws IOException {
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int k=input.nextInt();
    int count=1 ;
    for(int i=0 ; i<k ; i++){
      int q=input.nextInt();
      for(int j=1 ; j<=q ; j++){
        int value=input.nextInt();
        if(j!=value){
          count+=2 ;
        }
      }
      count--;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var ran : OclRandom ; ran := OclRandom.newOclRandom() ;
         var i : int ; i := 0 ; while i < a->size() do ( (     var r : int ; r := ran.nextInt(a->size()) ;
     var temp : int ; temp := a[r+1] ;
     a[r+1] := a[i+1] ; 
     a[i+1] := temp )  ;     i := i + 1 ) ; 
     a := a->sort() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var k : int ; k := input.getCurrent()->toInteger() ;
    var count : int ; count := 1 ;
        var i : int ; i := 0 ; while i < k do ( (     var q : int ; q := input.getCurrent()->toInteger() ;
         var j : int ; j := 1 ; while j <= q do ( (     var value : int ; value := input.getCurrent()->toInteger() ;
     if (j /= value) then (     count := count+(2) ) else skip )  ;     j := j + 1 ) ; 
     count := count - 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class A {
  public static void main(String hi[])throws Exception {
    BufferedReader infile=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(infile.readLine());
    int N=Integer.parseInt(st.nextToken());
    int K=Integer.parseInt(st.nextToken());
    ArrayList<Integer>[] dolls=new ArrayList[K];
    for(int i=0 ; i<K ; i++){
      dolls[i]=new ArrayList<Integer>();
      st=new StringTokenizer(infile.readLine());
      int cnt=Integer.parseInt(st.nextToken());
      while(cnt-->0)dolls[i] .add(Integer.parseInt(st.nextToken()));
    }
    int prefix=1 ;
    for(int i=0 ; i<K ; i++)if(dolls[i] .get(0)==1){
      for(int a=1 ; a<dolls[i] .size(); a++){
        if(dolls[i] .get(a)!=a+1)break ;
        prefix++;
      }
      break ;
    }
    int res=(N-prefix)*2 ;
    res-=K ;
    System.out.println(res+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( hi : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var infile : OclFile ; infile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(infile.readLine()) ;
    var N : int ; N := (st.next())->toInteger() ;
    var K : int ; K := (st.next())->toInteger() ;
    var dolls : Sequence(Sequence(int)) ; dolls := Integer.subrange(1,K)->collect(null) ;
        var i : int ; i := 0 ; while i < K do ( (     dolls[i+1] := Sequence{} ; 
     st := OclIterator.newOclIterator_String(infile.readLine()) ; 
     var cnt : int ; cnt := (st.next())->toInteger() ;
         while (cnt > 0) do (        cnt := cnt - 1 ;     skip ;     dolls[i+1]->excludes((st.next())->toInteger()) ; ;  ) )  ;     i := i + 1 ) ; 
    var prefix : int ; prefix := 1 ;
        var i : int ; i := 0 ; while i < K do (     if (dolls[i+1]->at(0+1) = 1) then (         var a : int ; a := 1 ; while a < dolls[i+1]->size() do ( (     if (dolls[i+1]->at(a+1) /= a + 1) then     break else skip ; 
     prefix := prefix + 1 )  ;     a := a + 1 ) ; 
     break ) else skip ;  ;     i := i + 1 ) ; 
    var res : int ; res := (N - prefix) * 2 ;
    res := res-(K) ; 
    OclFile["System.out"].println(res + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int totalWays(int N,int M,int X){
    int dp[][]=new int[N+1][2];
    if(X==1){
      dp[0][0]=1 ;
    }
    else {
      dp[0][1]=0 ;
    }
    if(X==1){
      dp[1][0]=0 ;
      dp[1][1]=M-1 ;
    }
    else {
      dp[1][0]=1 ;
      dp[1][1]=(M-2);
    }
    for(int i=2 ; i<N ; i++){
      dp[i][0]=dp[i-1][1];
      dp[i][1]=dp[i-1][0]*(M-1)+dp[i-1][1]*(M-2);
    }
    return dp[N-1][0];
  }
  public static void main(String[] args){
    int N=4,M=3,X=2 ;
    System.out.println(totalWays(N,M,X));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation totalWays( N : int, M : int, X : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,2)->collect(0)) ;
     if (X = 1) then (     dp[0+1][0+1] := 1 ) else (     dp[0+1][1+1] := 0 ) ;  
    if (X = 1) then (     dp[1+1][0+1] := 0 ; 
     dp[1+1][1+1] := M - 1 ) else (     dp[1+1][0+1] := 1 ; 
     dp[1+1][1+1] := (M - 2) ) ;  
        var i : int ; i := 2 ; while i < N do ( (     dp[i+1][0+1] := dp[i - 1+1][1+1] ; 
     dp[i+1][1+1] := dp[i - 1+1][0+1] * (M - 1) + dp[i - 1+1][1+1] * (M - 2) )  ;     i := i + 1 ) ; 
    return dp[N - 1+1][0+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
    var M : int ; M := 3 ;
    var X : int ; X := 2 ;
     OclFile["System.out"].println(totalWays(N, M, X)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float mean(float arr[],int n){
    float sum=0 ;
    for(int i=0 ; i<n ; i++)sum=sum+arr[i];
    return sum/n ;
  }
  static float SSD(float arr[],int n){
    float sum=0 ;
    for(int i=0 ; i<n ; i++)sum=sum+(arr[i]-mean(arr,n))*(arr[i]-mean(arr,n));
    return(float)Math.sqrt(sum/(n-1));
  }
  static float sampleError(float arr[],int n){
    return SSD(arr,n)/(float)Math.sqrt(n);
  }
  public static void main(String[] args){
    float arr[]={
      78.53f,79.62f,80.25f,81.05f,83.21f,83.46f };
      int n=arr.length ;
      System.out.println(sampleError(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation mean( arr : Sequence(double), n : int) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum + arr[i+1] ;  ;     i := i + 1 ) ; 
     return sum / n );
  static   operation SSD( arr : Sequence(double), n : int) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum + (arr[i+1] - mean(arr, n)) * (arr[i+1] - mean(arr, n)) ;  ;     i := i + 1 ) ; 
     return (sum / (n - 1))->sqrt()->oclAsType(double) );
  static   operation sampleError( arr : Sequence(double), n : int) : double
  pre: true
  post: true
  activity: (     return SSD(arr, n) / (n)->sqrt()->oclAsType(double) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(double) ; arr := Sequence{78.53f,79.62f,80.25f,81.05f,83.21f,83.46f} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(sampleError(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static void psuedoBinary(int n){
    while(n!=0){
      int temp=n,m=0,p=1 ;
      while(temp!=0){
        int rem=temp % 10 ;
        temp=temp/10 ;
        if(rem!=0)m+=p ;
        p*=10 ;
      }
      System.out.print(m+" ");
      n=n-m ;
    }
    System.out.println(" ");
  }
  public static void main(String[] args){
    int n=31 ;
    psuedoBinary(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation psuedoBinary( n : int) : void
  pre: true
  post: true
  activity: (     while (n /= 0) do (     var temp : int ; temp := n ;
    var m : int ; m := 0 ;
    var p : int ; p := 1 ;
     while (temp /= 0) do (     var rem : int ; rem := temp mod 10 ;
     temp := temp / 10 ; 
     if (rem /= 0) then     m := m+(p) ; else skip ; 
     p := p*(10) ) ; 
     OclFile["System.out"].print(m + " ") ; 
     n := n - m ) ; 
     OclFile["System.out"].println(" ") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 31 ;
     execute psuedoBinary(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    solve1091();
  }
  public static void solve1091(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int a=sc.nextInt();
      int l=sc.nextInt();
      int x=sc.nextInt();
      double nitouhen=menseki(a,calcHeight(l,a));
      double yoyuu=menseki(l,calcHeight(0.5*(l+x),l));
      System.out.println(nitouhen+2*yoyuu);
    }
  }
  public static double menseki(double teihen,double takasa){
    return 0.5*teihen*takasa ;
  }
  public static double calcHeight(double syahen,double ippen){
    return Math.sqrt(syahen*syahen-0.5*ippen*0.5*ippen);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve1091() );
  static   operation solve1091() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var nitouhen : double ; nitouhen := menseki(a, calcHeight(l, a)) ;
    var yoyuu : double ; yoyuu := menseki(l, calcHeight(0.5 * (l + x), l)) ;
    OclFile["System.out"].println(nitouhen + 2 * yoyuu) ; 
 ) );
  static   operation menseki( teihen : double, takasa : double) : double
  pre: true
  post: true
  activity: (     return 0.5 * teihen * takasa );
  static   operation calcHeight( syahen : double, ippen : double) : double
  pre: true
  post: true
  activity: (     return (syahen * syahen - 0.5 * ippen * 0.5 * ippen)->sqrt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    while(true){
      int H=input.nextInt();
      int W=input.nextInt();
      if(H==0 && W==0)break ;
      for(int i=0 ; i<H ; i++){
        for(int j=0 ; j<W ; j++)System.out.print("#");
        System.out.println();
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var H : int ; H := input.getCurrent()->toInteger() ;
     var W : int ; W := input.getCurrent()->toInteger() ;
    if (H = 0 & W = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do (     OclFile["System.out"].print("#") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    ArrayList<String>list=new ArrayList<String>();
    String str ;
    int a,b ;
    try {
      for(int i=0 ; ; i++){
        str=br.readLine();
        if(str.equals("0 0")){
          break ;
        }
        list.add(str);
      }
      for(int i=0 ; i<list.size(); i++){
        a=Integer.parseInt((String)list.get(i).subSequence(0,list.get(i).indexOf(" ")));
        b=Integer.parseInt((String)list.get(i).substring(list.get(i).indexOf(" ")+1,list.get(i).length()));
        for(int h=0 ; h<a ; h++){
          for(int w=0 ; w<b ; w++){
            System.out.print("#");
          }
          System.out.println();
        }
        System.out.println();
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var list : Sequence(String) ; list := Sequence{} ;
    var str : String ;
    var a : int ;
    var b : int ;
    try (         var i : int ; i := 0 ; while true do ( (     str := br.readLine() ; 
     if (str = "0 0") then (     break ) else skip ; 
     list := list->including(str) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < list->size() do ( (     a := (list->at(i+1).subrange(0+1,list->at(i+1)->indexOf(" ")-1)->oclAsType(String))->toInteger() ; 
     b := (list->at(i+1).subrange(list->at(i+1)->indexOf(" ")-1 + 1+1,list->at(i+1)->size())->oclAsType(String))->toInteger() ; 
         var h : int ; h := 0 ; while h < a do ( (         var w : int ; w := 0 ; while w < b do ( (     OclFile["System.out"].print("#") )  ;     w := w + 1 ) ; 
     OclFile["System.out"].println() )  ;     h := h + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      br.lines().map(line->Arrays.stream(line.split(" ")).mapToInt(Integer :: parseInt).toArray()).forEach(tokens->{
        int height=tokens[0];
        int width=tokens[1];
        if(height==0 && width==0){
          return ;
        }
        for(int h=0 ; h<height ; h++){
          for(int w=0 ; w<width ; w++){
            System.out.print("#");
          }
          System.out.println();
        }
        System.out.println();
      }
);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     for tokens : br.lines()->collect( _x1 | (lambda line : OclAny in stream(line->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence())->apply(_x1) ) do
    (    skip) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st ;
    try {
      while(true){
        String line=br.readLine();
        st=new StringTokenizer(line);
        int h=Integer.parseInt(st.nextToken());
        int w=Integer.parseInt(st.nextToken());
        if(h==0 && w==0){
          break ;
        }
        StringBuilder sb=new StringBuilder();
        for(int i=0 ; i<w ; i++){
          sb.append("#");
        }
        for(int i=0 ; i<h ; i++){
          System.out.println(sb.toString());
        }
        System.out.println();
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ;
     try (     while (true) do (     var line : String ; line := br.readLine() ;
     st := OclIterator.newOclIterator_String(line) ; 
    var h : int ; h := (st.next())->toInteger() ;
    var w : int ; w := (st.next())->toInteger() ;
    if (h = 0 & w = 0) then (     break ) else skip ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < w do ( (     sb := sb + StringLib.newString("#") )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < h do ( (     OclFile["System.out"].println(sb+"") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    while(true){
      String line=input.readLine();
      String[] num=line.split(" ");
      int tate=Integer.parseInt(num[0]);
      int yoko=Integer.parseInt(num[1]);
      if(tate==0 && yoko==0)break ;
      for(int i=0 ; i<tate ; i++){
        for(int j=0 ; j<yoko ; j++){
          sb.append("#");
        }
        sb.append("\n");
      }
      sb.append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
     while (true) do (     var line : String ; line := input.readLine() ;
     var num : Sequence(String) ; num := line->split(" ") ;
    var tate : int ; tate := (num[0+1])->toInteger() ;
    var yoko : int ; yoko := (num[1+1])->toInteger() ;
    if (tate = 0 & yoko = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < tate do ( (         var j : int ; j := 0 ; while j < yoko do ( (     sb := sb + StringLib.newString("#") )  ;     j := j + 1 ) ; 
     sb := sb + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString("\n") ; 
 ) ; 
     OclFile["System.out"].print(sb) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    System.out.println((n+1)*n/2);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println((n + 1) * n / 2) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in);
){
      solve(sc);
    }
  }
  public static void solve(Scanner sc){
    int a=sc.nextInt();
    System.out.println(a*(a+1)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     execute solve(sc) ))  );
  static   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(a * (a + 1) / 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
public class GFG {
  int getMinNum(int a,int b,int c){
    if(c<a || c>b){
      return c ;
    }
    int x=((b/c)*c)+c ;
    return x ;
  }
  public static void main(String args[]){
    int a=2 ;
    int b=4 ;
    int c=4 ;
    GFG g=new GFG();
    System.out.println(g.getMinNum(a,b,c));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
   operation getMinNum( a : int, b : int, c : int) : int
  pre: true
  post: true
  activity: (     if (c < a or c > b) then (     return c ) else skip ; 
     var x : int ; x := ((b / c) * c) + c ;
     return x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2 ;
     var b : int ; b := 4 ;
    var c : int ; c := 4 ;
    var g : GFG ; g := GFG.newGFG() ;
    OclFile["System.out"].println(g.getMinNum(a, b, c)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int Children ;
    int Candies=0 ;
    Scanner scanner=new Scanner(System.in);
    Children=scanner.nextInt();
    if(Children>=1 && Children<=100){
      for(int i=1 ; i<=Children ; i++){
        Candies=Candies+i ;
      }
      System.out.println(Candies);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Children : int ;
     var Candies : int ; Candies := 0 ;
    var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    Children := scanner.getCurrent()->toInteger() ; 
    if (Children >= 1 & Children <= 100) then (         var i : int ; i := 1 ; while i <= Children do ( (     Candies := Candies + i )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(Candies) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    String str=input.readLine();
    int s=Integer.parseInt(str);
    int answer=0 ;
    for(int i=s ; i>0 ; i--){
      answer=answer+i ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := input.readLine() ;
    var s : int ; s := (str)->toInteger() ;
    var answer : int ; answer := 0 ;
        var i : int ; i := s ; while i > 0 do ( (     answer := answer + i )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int n,sum=0 ;
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    for(int i=1 ; i<=n ; i++){
      sum+=i ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var sum : int ; sum := 0 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i <= n do ( (     sum := sum+(i) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  Scanner sc=new Scanner(in);
  double calc(){
    return 0 ;
  }
  void run(){
    while(true){
      if(! sc.hasNext())break ;
      int a=sc.nextInt(),l=sc.nextInt(),x=sc.nextInt();
      double ans=(double)a/2*Math.sqrt(l*l-(double)a*a/4.0);
      double lower=0.0,upper=1000 ;
      double mid ;
      while(upper-lower>1e-10){
        mid=(lower+upper)/2 ;
        double t=Math.sqrt((double)l*l/4+mid*mid);
        if(t+t<l+x){
          lower=mid ;
        }
        else {
          upper=mid ;
        }
      }
      ans+=(double)l*(lower+upper)/2 ;
      out.printf("%.10f\n",ans);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   operation calc() : double
  pre: true
  post: true
  activity: (     return 0 );
   operation run() : void
  pre: true
  post: true
  activity: (     while (true) do (     if (not(sc.hasNext())) then     break else skip ; 
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var ans : double ; ans := a->oclAsType(double) / 2 * (l * l - a->oclAsType(double) * a / 4.0)->sqrt() ;
    var lower : double ; lower := 0.0 ;
    var upper : double ; upper := 1000 ;
    var mid : double ;
    while (upper - lower > 1e-10) do (     mid := (lower + upper) / 2 ; 
     var t : double ; t := (l->oclAsType(double) * l / 4 + mid * mid)->sqrt() ;
     if (t + t < l + x) then (     lower := mid ) else (     upper := mid ) ) ; 
    ans := ans+(l->oclAsType(double) * (lower + upper) / 2) ; 
    out.printf("%.10f\n", ans) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
import static java.lang.Math.*;
import static java.lang.Integer.*;
import static java.lang.System.*;
public class B {
  public static String[] parts(BufferedReader br)throws Exception {
    String line=br.readLine();
    if(line==null)return null ;
    return line.trim().split("\\s+");
  }
  public static void main(String args[])throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(in));
    int cas=parseInt(br.readLine());
    for(int z=1 ; z<=cas ; z++){
      int n=parseInt(br.readLine());
      String[] ss=parts(br);
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=parseInt(ss[i]);
      int[] cl=new int[n];
      int[] cr=new int[n];
      HashMap<Integer,Integer>where=new HashMap<Integer,Integer>();
      for(int i=0 ; i<n ; i++){
        where.put(arr[i],i);
        for(int j=0 ; j<n ; j++){
          if(i==j)continue ;
          if(i<j && arr[j]>arr[i])cl[i]++;
          if(i>j && arr[j]>arr[i])cr[i]++;
        }
      }
      int ans=0 ;
      Arrays.sort(arr);
      for(int i=n-2 ; i>=0 ; i--){
        int x=arr[i];
        int j=where.get(x);
        ans+=min(cl[j],cr[j]);
      }
      out.println("Case #"+z+": "+ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation parts( br : OclFile) : Sequence(String)
  pre: true
  post: true
  activity: (     var line : String ; line := br.readLine() ;
     if (line = null) then     return null else skip ; 
     return line->trim()->split("\\s+") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     var cas : int ; cas := parseInt(br.readLine()) ;
         var z : int ; z := 1 ; while z <= cas do ( (     var n : int ; n := parseInt(br.readLine()) ;
     var ss : Sequence(String) ; ss := parts(br) ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := (ss[i+1] + "")->toInteger() ;  ;     i := i + 1 ) ; 
    var cl : Sequence(int) ; cl := Integer.subrange(1,n)->collect(0) ;
    var cr : Sequence(int) ; cr := Integer.subrange(1,n)->collect(0) ;
    var where : Map(int,int) ; where := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     where := where->union(Map{arr[i+1] |-> i}) ; 
         var j : int ; j := 0 ; while j < n do ( (     if (i = j) then     continue else skip ; 
     if (i < j & arr[j+1] > arr[i+1]) then     cl[i+1] := cl[i+1] + 1 ; else skip ; 
     if (i > j & arr[j+1] > arr[i+1]) then     cr[i+1] := cr[i+1] + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    arr := arr->sort() ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     var x : int ; x := arr[i+1] ;
     var j : int ; j := where->at(x) ;
     ans := ans+(Set{cl[j+1], cr[j+1]}->min()) )  ;     i := i - 1 ) ; 
    out.println("Case #" + z + ": " + ans) ; 
 )  ;     z := z + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class UpAndDown {
  private static Scanner input ;
  private static PrintWriter out ;
  public static void main(String[] args)throws Exception {
    input=new Scanner(new FileReader("B-large.in"));
    out=new PrintWriter(new FileWriter("B-large.out"));
    int testCases=input.nextInt();
    for(int testCase=1 ; testCase<=testCases ; testCase++){
      out.println("Case #"+testCase+": "+solveCase());
    }
    out.close();
  }
  public static int solveCase(){
    int n=input.nextInt();
    int[] values=new int[n];
    for(int i=0 ; i<n ; i++){
      values[i]=input.nextInt();
    }
    boolean[] done=new boolean[n];
    int res=0 ;
    for(int i=0 ; i<n ; i++){
      int index=-1 ;
      for(int j=0 ; j<n ; j++){
        if(! done[j] &&(index==-1 || values[j]<values[index]))index=j ;
      }
      int left=0,right=0 ;
      for(int j=0 ; j<index ; j++)if(! done[j])left++;
      for(int j=index+1 ; j<n ; j++)if(! done[j])right++;
      res+=Math.min(left,right);
      done[index]=true ;
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class UpAndDown {
  static   attribute input : OclFile;
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("B-large.in"))) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("B-large.out"))) ; 
    var testCases : int ; testCases := input.getCurrent()->toInteger() ;
        var testCase : int ; testCase := 1 ; while testCase <= testCases do ( (     skip )  ;     testCase := testCase + 1 ) ; 
    skip ; 
 );
  static   operation solveCase() : int
  pre: true
  post: true
  activity: (     var n : int ; n := input.getCurrent()->toInteger() ;
     var values : Sequence(int) ; values := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     values[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var done : Sequence(boolean) ; done := Integer.subrange(1,n)->collect(false) ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var index : int ; index := -1 ;
         var j : int ; j := 0 ; while j < n do ( (     if (not(done[j+1]) & (index = -1 or values[j+1] < values[index+1])) then     index := j ; else skip )  ;     j := j + 1 ) ; 
    var left : int ; left := 0 ;
    var right : int ; right := 0 ;
        var j : int ; j := 0 ; while j < index do (     if (not(done[j+1])) then     left := left + 1 ; else skip ;  ;     j := j + 1 ) ; 
        var j : int ; j := index + 1 ; while j < n do (     if (not(done[j+1])) then     right := right + 1 ; else skip ;  ;     j := j + 1 ) ; 
    res := res+(Set{left, right}->min()) ; 
    done[index+1] := true ; 
 )  ;     i := i + 1 ) ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.util.*;
public class B {
  Scanner sc=new Scanner(System.in);
  int N ;
  int[] A ;
  void read(){
    N=sc.nextInt();
    A=new int[N];
    for(int i=0 ; i<N ; i++)A[i]=sc.nextInt();
  }
  void solve(){
    int num=0 ;
    for(int i=0 ; i<N ; i++){
      int p=0 ;
      for(int j=0 ; j<N-i ; j++)if(A[p]>A[j]){
        p=j ;
      }
      num+=min(p,N-i-1-p);
      for(int j=p ; j<N-i-1 ; j++)A[j]=A[j+1];
    }
    System.out.println(num);
  }
  void run(){
    int caseN=sc.nextInt();
    for(int caseID=1 ; caseID<=caseN ; caseID++){
      read();
      System.out.printf("Case #%d: ",caseID);
      solve();
      System.out.flush();
    }
  }
  void debug(Object...os){
    System.err.println(deepToString(os));
  }
  public static void main(String[] args){
    try {
      System.setIn(new BufferedInputStream(new FileInputStream(args.length>0 ? args[0] :(B.class.getName()+".in"))));
    }
    catch(Exception e){
    }
    new B().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute N : int;
   attribute A : Sequence(int);
   operation read() : void
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     A := Integer.subrange(1,N)->collect(0) ; 
         var i : int ; i := 0 ; while i < N do (     A[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var num : int ; num := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     var p : int ; p := 0 ;
         var j : int ; j := 0 ; while j < N - i do (     if (A[p+1] > A[j+1]) then (     p := j ) else skip ;  ;     j := j + 1 ) ; 
     num := num+(Set{p, N - i - 1 - p}->min()) ; 
         var j : int ; j := p ; while j < N - i - 1 do (     A[j+1] := A[j + 1+1] ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(num) );
   operation run() : void
  pre: true
  post: true
  activity: (     var caseN : int ; caseN := sc.getCurrent()->toInteger() ;
         var caseID : int ; caseID := 1 ; while caseID <= caseN do ( (     execute read() ; 
     OclFile["System.out"].printf("Case #%d: ", caseID) ; 
     execute solve() ; 
     OclFile["System.out"].flush() )  ;     caseID := caseID + 1 ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile_Read(if args->size() > 0 then args[0+1] else (OclType["B"].getName() + ".in") endif))) )   catch (e : ProgramException) do skip
     B.newB().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class SolB3 {
  public static void main(String[] args){
    try {
      new SolB3().run();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  public void run()throws IOException {
    br=new BufferedReader(new FileReader(FNAME+".in"));
    out=new PrintWriter(FNAME+".out");
    solve();
    out.close();
  }
  BufferedReader br ;
  PrintWriter out ;
  StringTokenizer st ;
  boolean eof ;
  String nextToken(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine()," \n\t/");
      }
      catch(IOException e){
        eof=true ;
        return "0" ;
      }
    }
    return st.nextToken();
  }
  int nextInt(){
    return Integer.parseInt(nextToken());
  }
  long nextLong(){
    return Long.parseLong(nextToken());
  }
  String FNAME="B-large" ;
  void solve(){
    int tests=nextInt();
    for(int test=1 ; test<=tests ; test++){
      out.print("Case #"+test+": ");
      int n=nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=nextInt();
      }
      int ans=0 ;
      for(int i=0 ; i<n ; i++){
        int imin=0 ;
        for(int j=0 ; j<n-i ; j++){
          if(a[j]<a[imin]){
            imin=j ;
          }
        }
        ans+=Math.min(imin,n-1-i-imin);
        for(int j=imin ; j<n-i-1 ; j++){
          a[j]=a[j+1];
        }
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SolB3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     SolB3.newSolB3().run() )   catch (e : IOException) do (     e.printStackTrace() )
 );
   operation run() : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(FNAME + ".in")) ; 
     out := OclFile.newOclFile_Write(FNAME + ".out") ; 
     execute solve() ; 
     out.close() );
   attribute br : OclFile;
   attribute out : OclFile;
   attribute st : OclIterator;
   attribute eof : boolean;
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String_String(br.readLine(), " \n\t/") )   catch (e : IOException) do (     eof := true ; 
     return "0" )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   attribute FNAME : String := "B-large";
   operation solve() : void
  pre: true
  post: true
  activity: (     var tests : int ; tests := nextInt() ;
         var test : int ; test := 1 ; while test <= tests do ( (     skip ; 
     var n : int ; n := nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := nextInt() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var imin : int ; imin := 0 ;
         var j : int ; j := 0 ; while j < n - i do ( (     if (a[j+1] < a[imin+1]) then (     imin := j ) else skip )  ;     j := j + 1 ) ; 
     ans := ans+(Set{imin, n - 1 - i - imin}->min()) ; 
         var j : int ; j := imin ; while j < n - i - 1 do ( (     a[j+1] := a[j + 1+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     test := test + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int[] par=new int[1001];
  static void init(int n){
    for(int i=0 ; i<=n ; i++){
      par[i]=i ;
    }
  }
  static int root(int x){
    if(par[x]==x)return x ;
    return par[x]=root(par[x]);
  }
  static void unite(int x,int y){
    par[root(x)]=root(y);
  }
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int[] F=new int[1001];
      for(int i=2 ; i<=1000 ; i++){
        F[0]=1 ;
        F[1]=2 ;
        F[i]=F[i-2]+F[i-1];
        F[i] %=1001 ;
      }
      while(sc.hasNext()){
        int V=sc.nextInt();
        int d=sc.nextInt();
        init(V);
        for(int i=1 ; i<=V ; i++){
          for(int j=i+1 ; j<=V ; j++){
            if(Math.abs(F[j]-F[i])<d){
              unite(i,j);
            }
          }
        }
        int count=0 ;
        for(int i=1 ; i<=V ; i++){
          if(par[i]==i){
            count++;
          }
        }
        System.out.println(count);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute par : Sequence(int) := Integer.subrange(1,1001)->collect(0);
  static   operation init( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= n do ( (     par[i+1] := i )  ;     i := i + 1 ) );
  static   operation root( x : int) : int
  pre: true
  post: true
  activity: (     if (par[x+1] = x) then     return x else skip ; 
     return par[x+1] );
  static   operation unite( x : int, y : int) : void
  pre: true
  post: true
  activity: (     par[root(x)+1] := root(y) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var F : Sequence(int) ; F := Integer.subrange(1,1001)->collect(0) ;
         var i : int ; i := 2 ; while i <= 1000 do ( (     F[0+1] := 1 ; 
     F[1+1] := 2 ; 
     F[i+1] := F[i - 2+1] + F[i - 1+1] ; 
     F[i+1] := F[i+1] mod 1001 )  ;     i := i + 1 ) ; 
     while (sc.hasNext()) do (     var V : int ; V := sc.getCurrent()->toInteger() ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
    execute init(V) ; 
        var i : int ; i := 1 ; while i <= V do ( (         var j : int ; j := i + 1 ; while j <= V do ( (     if (if F[j+1] - F[i+1] < 0 then -(F[j+1] - F[i+1]) else F[j+1] - F[i+1] endif < d) then (     execute unite(i, j) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= V do ( (     if (par[i+1] = i) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
import java.util.Arrays ;
class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String buf ;
    try {
      while((buf=br.readLine())!=null){
        StringTokenizer st=new StringTokenizer(buf);
        int V=Integer.parseInt(st.nextToken());
        int d=Integer.parseInt(st.nextToken());
        int f[]=new int[V+1];
        int count=1 ;
        f[0]=1 ;
        f[1]=2 ;
        for(int i=2 ; i<=V ; i++){
          f[i]=(f[i-1]+f[i-2])% 1001 ;
        }
        Arrays.sort(f);
        for(int i=2 ; i<=V ; i++){
          if(f[i]-f[i-1]>=d)count++;
        }
        System.out.println(count);
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var buf : String ;
     try (         buf := br.readLine() ;
    while ((buf) /= null) do (    skip ; (     var st : OclIterator ; st := OclIterator.newOclIterator_String(buf) ;
     var V : int ; V := (st.next())->toInteger() ;
    var d : int ; d := (st.next())->toInteger() ;
    var f : Sequence(int) ; f := Integer.subrange(1,V + 1)->collect(0) ;
    var count : int ; count := 1 ;
    f[0+1] := 1 ; 
    f[1+1] := 2 ; 
        var i : int ; i := 2 ; while i <= V do ( (     f[i+1] := (f[i - 1+1] + f[i - 2+1]) mod 1001 )  ;     i := i + 1 ) ; 
    f := f->sort() ; 
        var i : int ; i := 2 ; while i <= V do ( (     if (f[i+1] - f[i - 1+1] >= d) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;     buf := br.readLine() ;
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] s=sc.next().toCharArray();
    int x=0 ;
    int max=0 ;
    for(int i=0 ; i<n ; i++){
      if(s[i]=='I'){
        x++;
      }
      else {
        x--;
      }
      max=Math.max(max,x);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var x : int ; x := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] = 'I') then (     x := x + 1 ) else (     x := x - 1 ) ;  
     max := Set{max, x}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      final int V=sc.nextInt();
      final int D=sc.nextInt();
      if(V==0 && D==0){
        break ;
      }
      int fibs[]=new int[V+1];
      BigInteger[] bfi=new BigInteger[V+1];
      BigInteger mod=new BigInteger("1001");
      bfi[0]=new BigInteger("1");
      bfi[1]=new BigInteger("2");
      for(int i=2 ; i<=V ; i++){
        bfi[i]=bfi[i-1] .add(bfi[i-2]);
      }
      for(int i=1 ; i<=V ; i++){
        fibs[i]=bfi[i] .mod(mod).intValue();
      }
      Arrays.sort(fibs);
      int count=0 ;
      for(int i=1 ; i<=V ; i++){
        if(i!=1 && fibs[i-1]+D<=fibs[i]){
          count++;
        }
      }
      System.out.println(count+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var V : int ; V := sc.getCurrent()->toInteger() ;
     var D : int ; D := sc.getCurrent()->toInteger() ;
    if (V = 0 & D = 0) then (     break ) else skip ; 
    var fibs : Sequence(int) ; fibs := Integer.subrange(1,V + 1)->collect(0) ;
    var bfi : Sequence(long) ; bfi := Integer.subrange(1,V + 1)->collect(null) ;
    var mod : long ; mod := long("1001") ;
    bfi[0+1] := long("1") ; 
    bfi[1+1] := long("2") ; 
        var i : int ; i := 2 ; while i <= V do ( (     bfi[i+1] := bfi[i - 1+1]->excludes(bfi[i - 2+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= V do ( (     fibs[i+1] := bfi[i+1].mod(mod)->oclAsType(int) )  ;     i := i + 1 ) ; 
    fibs := fibs->sort() ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= V do ( (     if (i /= 1 & fibs[i - 1+1] + D <= fibs[i+1]) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count + 1) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
class Main {
  private static void solve(){
    Scanner scanner=new Scanner(System.in);
    final int n=1001 ;
    while(scanner.hasNextInt()){
      int v=scanner.nextInt();
      int d=scanner.nextInt();
      int a=1 ;
      int b=1 ;
      int[] fib=new int[v];
      for(int i=0 ; i<v ; i++){
        fib[i]=(a+b)% n ;
        b=a ;
        a=fib[i];
      }
      Arrays.sort(fib);
      int counter=0 ;
      int previous=fib[0];
      for(int i=0 ; i<v ; i++){
        int current=fib[i];
        if(current-previous>=d){
          counter++;
        }
        previous=current ;
      }
      System.out.println(counter+1);
    }
  }
  public static void main(String...args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := 1001 ;
     while (scanner.hasNextInt()) do (     var v : int ; v := scanner.getCurrent()->toInteger() ;
     var d : int ; d := scanner.getCurrent()->toInteger() ;
    var a : int ; a := 1 ;
    var b : int ; b := 1 ;
    var fib : Sequence(int) ; fib := Integer.subrange(1,v)->collect(0) ;
        var i : int ; i := 0 ; while i < v do ( (     fib[i+1] := (a + b) mod n ; 
     b := a ; 
     a := fib[i+1] )  ;     i := i + 1 ) ; 
    fib := fib->sort() ; 
    var counter : int ; counter := 0 ;
    var previous : int ; previous := fib[0+1] ;
        var i : int ; i := 0 ; while i < v do ( (     var current : int ; current := fib[i+1] ;
     if (current - previous >= d) then (     counter := counter + 1 ) else skip ; 
     previous := current )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter + 1) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] arg)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String is ;
    String[] ia ;
    final BigInteger N=new BigInteger("1001");
    ArrayList<Integer>al ;
    while((is=in.readLine())!=null){
      ia=is.split(" ");
      int V=Integer.parseInt(ia[0]);
      int d=Integer.parseInt(ia[1]);
      if(V==0){
        System.out.println(0);
        continue ;
      }
      BigInteger a=BigInteger.ONE,b=BigInteger.ONE,c ;
      al=new ArrayList<Integer>();
      for(int i=0 ; i<V ; ++i){
        c=a.add(b);
        a=b ;
        b=c ;
        al.add(c.mod(N).intValue());
      }
      Collections.sort(al);
      int x=1 ;
      int s=al.get(0),t ;
      for(int i=1 ; i<al.size(); ++i){
        t=al.get(i);
        if((t-s)>=d){
++x ;
        }
        s=t ;
      }
      System.out.println(x);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var is : String ;
    var ia : Sequence(String) ;
    var N : long ; N := long("1001") ;
    var al : Sequence(int) ;
        is := in.readLine() ;
    while ((is) /= null) do (    skip ; (     ia := is->split(" ") ; 
     var V : int ; V := (ia[0+1])->toInteger() ;
    var d : int ; d := (ia[1+1])->toInteger() ;
    if (V = 0) then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
    var a : long ; a := 1 ;
    var b : long ; b := 1 ;
    var c : long ;
    al := Sequence{} ; 
        var i : int ; i := 0 ; while i < V do ( (     c := a->excludes(b) ; 
     a := b ; 
     b := c ; 
     al := al->including(c.mod(N)->oclAsType(int)) )  ;     i := i + 1 ) ; 
    al := al->sort() ; 
    var x : int ; x := 1 ;
    var s : int ; s := al->at(0+1) ;
    var t : int ;
        var i : int ; i := 1 ; while i < al->size() do ( (     t := al->at(i+1) ; 
     if ((t - s) >= d) then (     x := x + 1 ) else skip ; 
     s := t )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(x) ; 
 ) ;     is := in.readLine() ;
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Sum {
  void sumOfPrevK(int N,int K){
    int arr[]=new int[N];
    arr[0]=1 ;
    for(int i=1 ; i<N ; i++){
      int j=i-1,count=0,sum=0 ;
      while(j>=0 && count<K){
        sum+=arr[j];
        j--;
        count++;
      }
      arr[i]=sum ;
    }
    for(int i=0 ; i<N ; i++){
      System.out.print(arr[i]+" ");
    }
  }
  public static void main(String args[]){
    Sum s=new Sum();
    int N=10,K=4 ;
    s.sumOfPrevK(N,K);
  }
}
------------------------------------------------------------
OCL File:
---------
class Sum {
   operation sumOfPrevK( N : int, K : int) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
     arr[0+1] := 1 ; 
         var i : int ; i := 1 ; while i < N do ( (     var j : int ; j := i - 1 ;
    var count : int ; count := 0 ;
    var sum : int ; sum := 0 ;
     while (j >= 0 & count < K) do (     sum := sum+(arr[j+1]) ; 
     j := j - 1 ; 
     count := count + 1 ) ; 
     arr[i+1] := sum )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Sum ; s := Sum.newSum() ;
     var N : int ; N := 10 ;
    var K : int ; K := 4 ;
     s.sumOfPrevK(N, K) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(stdIn.hasNext()){
      double a=stdIn.nextDouble();
      double l=stdIn.nextDouble();
      double x=stdIn.nextDouble();
      double s1=a/4*Math.sqrt((a+2*l)*(2*l-a));
      double maxS2=0 ;
      for(double i=0.00001 ; i<1.0 ; i+=0.00001){
        double len1=i*(l+x);
        double len2=(1.0-i)*(l+x);
        double s=(l+len1+len2)/2.0 ;
        if(s*(s-l)*(s-len1)*(s-len2)<0){
          continue ;
        }
        else {
          double s2=Math.sqrt(s*(s-l)*(s-len1)*(s-len2));
          if(maxS2<s2){
            maxS2=s2 ;
          }
        }
      }
      System.out.printf("%6f\n",s1+2*maxS2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (stdIn.hasNext()) do (     var a : double ; a := stdIn.getCurrent()->toReal() ;
     var l : double ; l := stdIn.getCurrent()->toReal() ;
    var x : double ; x := stdIn.getCurrent()->toReal() ;
    var s1 : double ; s1 := a / 4 * ((a + 2 * l) * (2 * l - a))->sqrt() ;
    var maxS2 : double ; maxS2 := 0 ;
        var i : double ; i := 0.00001 ; while i < 1.0 do ( (     var len1 : double ; len1 := i * (l + x) ;
     var len2 : double ; len2 := (1.0 - i) * (l + x) ;
     var s : double ; s := (l + len1 + len2) / 2.0 ;
     if (s * (s - l) * (s - len1) * (s - len2) < 0) then (     continue ) else (     var s2 : double ; s2 := (s * (s - l) * (s - len1) * (s - len2))->sqrt() ;
     if (maxS2 < s2) then (     maxS2 := s2 ) else skip ) )  ;     i := i+(0.00001) ) ; 
    OclFile["System.out"].printf("%6f\n", s1 + 2 * maxS2) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
public class main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    StringTokenizer st=new StringTokenizer(br.readLine());
    long min=Long.MAX_VALUE ;
    long[] arr=new long[n];
    ArrayList<Integer>arr0=new ArrayList<>();
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=Integer.parseInt(st.nextToken());
      if(min>arr[i]){
        min=arr[i];
      }
    }
    for(int i=0 ; i<arr.length ; i++){
      arr[i]-=min ;
    }
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]==0){
        arr0.add(i);
      }
    }
    if(arr0.size()==0){
      System.out.println((n*min)+n-1);
    }
    else {
      int first0=arr0.get(0);
      int last0=arr0.get(arr0.size()-1);
      int max=(arr.length-1)-last0+first0 ;
      for(int i=0 ; i<arr0.size()-1 ; i++){
        if(arr0.get(i+1)-arr0.get(i)-1>max){
          max=arr0.get(i+1)-arr0.get(i)-1 ;
        }
      }
      System.out.println(n*min+max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var min : long ; min := "9223372036854775807"->toLong() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
    var arr0 : Sequence(int) ; arr0 := Sequence{} ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := (st.next())->toInteger() ; 
     if (min > arr[i+1]) then (     min := arr[i+1] ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := arr[i+1]-(min) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = 0) then (     arr0 := arr0->including(i) ) else skip )  ;     i := i + 1 ) ; 
    if (arr0->size() = 0) then (     OclFile["System.out"].println((n * min) + n - 1) ) else (     var first0 : int ; first0 := arr0->at(0+1) ;
     var last0 : int ; last0 := arr0->at(arr0->size() - 1+1) ;
    var max : int ; max := (arr->size() - 1) - last0 + first0 ;
        var i : int ; i := 0 ; while i < arr0->size() - 1 do ( (     if (arr0->at(i + 1+1) - arr0->at(i+1) - 1 > max) then (     max := arr0->at(i + 1+1) - arr0->at(i+1) - 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n * min + max) ; 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    System.out.println(sc.nextInt()>999 ? "ABD" : "ABC");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println(if sc.getCurrent()->toInteger() > 999 then "ABD" else "ABC" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  void solve(){
    int n=inint();
    if(n<1000)out.println("ABC");
    else out.println("ABD");
  }
  public static Scanner in=new Scanner(System.in);
  public static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    new Main().solve();
    out.flush();
  }
  public int inint(){
    return in.nextInt();
  }
  public String instr(){
    return in.next();
  }
  public int[] inintar(int num){
    int[] a=new int[num];
    for(int i=0 ; i<num ; i++){
      a[i]=in.nextInt();
    }
    return a ;
  }
  public char[] incharar(){
    return in.next().toCharArray();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := inint() ;
     if (n < 1000) then     out.println("ABC") ; else     out.println("ABD") ; );
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() ; 
     skip );
   operation inint() : int
  pre: true
  post: true
  activity: (     return in.getCurrent()->toInteger() );
   operation instr() : String
  pre: true
  post: true
  activity: (     return in.getCurrent() );
   operation inintar( num : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,num)->collect(0) ;
         var i : int ; i := 0 ; while i < num do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return a );
   operation incharar() : Sequence(String)
  pre: true
  post: true
  activity: (     return in.getCurrent()->characters() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().solveA();
  }
  private void solveA(){
    Scanner scanner=null ;
    int numN=0 ;
    try {
      scanner=new Scanner(System.in);
      numN=scanner.nextInt();
      if(numN>999){
        System.out.println("ABD");
      }
      else {
        System.out.println("ABC");
      }
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
  private void solveB(){
    Scanner scanner=null ;
    int numN=0 ;
    int numK=0 ;
    int numS=0 ;
    try {
      scanner=new Scanner(System.in);
      numN=scanner.nextInt();
      System.out.println("");
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
  private void solveC(){
    Scanner scanner=null ;
    int numN=0 ;
    int numK=0 ;
    int numS=0 ;
    try {
      scanner=new Scanner(System.in);
      numN=scanner.nextInt();
      System.out.println("");
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
  private void solveD(){
    Scanner scanner=null ;
    int numN=0 ;
    int numK=0 ;
    int numS=0 ;
    try {
      scanner=new Scanner(System.in);
      numN=scanner.nextInt();
      System.out.println("");
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solveA() );
   operation solveA() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var numN : int ; numN := 0 ;
     try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     numN := scanner.getCurrent()->toInteger() ; 
     if (numN > 999) then (     OclFile["System.out"].println("ABD") ) else (     OclFile["System.out"].println("ABC") ) )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
   operation solveB() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var numN : int ; numN := 0 ;
    var numK : int ; numK := 0 ;
    var numS : int ; numS := 0 ;
    try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     numN := scanner.getCurrent()->toInteger() ; 
     OclFile["System.out"].println("") )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
   operation solveC() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var numN : int ; numN := 0 ;
    var numK : int ; numK := 0 ;
    var numS : int ; numS := 0 ;
    try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     numN := scanner.getCurrent()->toInteger() ; 
     OclFile["System.out"].println("") )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
   operation solveD() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var numN : int ; numN := 0 ;
    var numK : int ; numK := 0 ;
    var numS : int ; numS := 0 ;
    try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     numN := scanner.getCurrent()->toInteger() ; 
     OclFile["System.out"].println("") )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      System.out.println((n>999)? "ABD" : "ABC");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if (n > 999) then "ABD" else "ABC" endif) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static FastScanner sc=new FastScanner(br);
  static PrintWriter out=new PrintWriter(System.out);
  static Random rnd=new Random();
  public static void main(String args[])throws Exception {
    int n=sc.nextInt();
    char[] a=sc.next().toCharArray();
    int x=0,max=0 ;
    for(int i=0 ; i<n ; i++){
      x+=(a[i]=='I' ? 1 :-1);
      max=Math.max(max,x);
    }
    out.println(max);
    out.close();
  }
}
class FastScanner {
  BufferedReader in ;
  StringTokenizer st ;
  public FastScanner(BufferedReader in){
    this.in=in ;
  }
  public String nextToken()throws Exception {
    while(st==null || ! st.hasMoreTokens()){
      st=new StringTokenizer(in.readLine());
    }
    return st.nextToken();
  }
  public String next()throws Exception {
    return nextToken().toString();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(nextToken());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(nextToken());
  }
  public double nextDouble()throws Exception {
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute sc : FastScanner := FastScanner.newFastScanner(br);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute rnd : OclRandom := OclRandom.newOclRandom();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var a : Sequence(String) ; a := sc.next()->characters() ;
    var x : int ; x := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x := x+((if a[i+1] = 'I' then 1 else -1 endif)) ; 
     max := Set{max, x}->max() )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}
class FastScanner {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     self.in := in );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return st.next() );
   operation next() : String
  pre: true
  post: true
  activity: (     return nextToken()+"" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    sc.close();
    if(N<1000){
      System.out.println("ABC");
    }
    else {
      System.out.println("ABD");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
     skip ; 
     if (N < 1000) then (     OclFile["System.out"].println("ABC") ) else (     OclFile["System.out"].println("ABD") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n,k ;
    int a[];
    int sum,sum2 ;
    int max ;
    int space ;
    n=sc.nextInt();
    k=sc.nextInt();
    while(n+k!=0){
      a=new int[n+1];
      sum=0 ;
      sum2=0 ;
      max=0 ;
      space=0 ;
      for(int i=0 ; i<k ; i++){
        a[sc.nextInt()]=1 ;
      }
      if(a[0]==0){
        for(int i=1 ; i<=n ; i++){
          if(a[i]==1){
            sum++;
          }
          else {
            max=(max<sum)? sum : max ;
            sum=0 ;
          }
        }
        max=(max<sum)? sum : max ;
      }
      else {
        for(int i=1 ; i<=n ; i++){
          if(a[i]==1){
            sum2++;
          }
          else {
            if(space==1){
              max=(max<sum+sum2+1)? sum+sum2+1 : max ;
              sum=sum2 ;
              sum2=0 ;
              space=0 ;
            }
            max=(max<sum2)? sum2 : max ;
            space++;
          }
        }
        if(space==1){
          max=(max<sum+sum2+1)? sum+sum2+1 : max ;
        }
        max=(max<sum2)? sum2 : max ;
      }
      System.out.println(max);
      n=sc.nextInt();
      k=sc.nextInt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var k : int ;
    var a : Sequence(int) ;
    var sum : int ;
    var sum2 : int ;
    var max : int ;
    var space : int ;
    n := sc.getCurrent()->toInteger() ; 
    k := sc.getCurrent()->toInteger() ; 
    while (n + k /= 0) do (     a := Integer.subrange(1,n + 1)->collect(0) ; 
     sum := 0 ; 
    sum2 := 0 ; 
    max := 0 ; 
    space := 0 ; 
        var i : int ; i := 0 ; while i < k do ( (     a[sc.getCurrent()->toInteger()+1] := 1 )  ;     i := i + 1 ) ; 
    if (a[0+1] = 0) then (         var i : int ; i := 1 ; while i <= n do ( (     if (a[i+1] = 1) then (     sum := sum + 1 ) else (     max := if (max < sum) then sum else max endif ; 
     sum := 0 ) )  ;     i := i + 1 ) ; 
     max := if (max < sum) then sum else max endif ) else (         var i : int ; i := 1 ; while i <= n do ( (     if (a[i+1] = 1) then (     sum2 := sum2 + 1 ) else (     if (space = 1) then (     max := if (max < sum + sum2 + 1) then sum + sum2 + 1 else max endif ; 
     sum := sum2 ; 
     sum2 := 0 ; 
     space := 0 ) else skip ; 
     max := if (max < sum2) then sum2 else max endif ; 
     space := space + 1 ) )  ;     i := i + 1 ) ; 
     if (space = 1) then (     max := if (max < sum + sum2 + 1) then sum + sum2 + 1 else max endif ) else skip ; 
     max := if (max < sum2) then sum2 else max endif ) ;  
    OclFile["System.out"].println(max) ; 
    n := sc.getCurrent()->toInteger() ; 
    k := sc.getCurrent()->toInteger() ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(true){
      int n=stdIn.nextInt();
      int k=stdIn.nextInt();
      if(n==0 && k==0)break ;
      boolean[] tmp=new boolean[n+1];
      int sum=0 ;
      for(int i=0 ; i<k ; i++){
        int s=stdIn.nextInt();
        if(s==0){
          sum++;
        }
        tmp[s]=true ;
      }
      int max=0 ;
      int lp=1 ;
      int rp=1 ;
      int prelp=1 ;
      int tmpsum=sum ;
      while(true){
        if(! tmp[rp]){
          rp++;
          lp++;
        }
        else {
          break ;
        }
      }
      while(true){
        rp++;
        while(rp<tmp.length &&(tmp[rp] || tmpsum>0)){
          if(! tmp[rp] || rp>tmp.length){
            prelp=rp ;
            tmpsum--;
          }
          rp++;
        }
        tmpsum=sum ;
        if(rp-lp>max){
          max=rp-lp ;
        }
        if(lp>tmp.length || rp>tmp.length){
          break ;
        }
        lp=prelp+1 ;
        rp=lp+1 ;
        prelp++;
      }
      if(sum==0){
        System.out.println(max-2);
      }
      else System.out.println(max-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     var k : int ; k := stdIn.getCurrent()->toInteger() ;
    if (n = 0 & k = 0) then     break else skip ; 
    var tmp : Sequence(boolean) ; tmp := Integer.subrange(1,n + 1)->collect(false) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     var s : int ; s := stdIn.getCurrent()->toInteger() ;
     if (s = 0) then (     sum := sum + 1 ) else skip ; 
     tmp[s+1] := true )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var lp : int ; lp := 1 ;
    var rp : int ; rp := 1 ;
    var prelp : int ; prelp := 1 ;
    var tmpsum : int ; tmpsum := sum ;
    while (true) do (     if (not(tmp[rp+1])) then (     rp := rp + 1 ; 
     lp := lp + 1 ) else (     break ) ) ; 
    while (true) do (     rp := rp + 1 ; 
     while (rp < tmp->size() & (tmp[rp+1] or tmpsum > 0)) do (     if (not(tmp[rp+1]) or rp > tmp->size()) then (     prelp := rp ; 
     tmpsum := tmpsum - 1 ) else skip ; 
     rp := rp + 1 ) ; 
    tmpsum := sum ; 
    if (rp - lp > max) then (     max := rp - lp ) else skip ; 
    if (lp > tmp->size() or rp > tmp->size()) then (     break ) else skip ; 
    lp := prelp + 1 ; 
    rp := lp + 1 ; 
    prelp := prelp + 1 ; 
 ) ; 
    if (sum = 0) then (     OclFile["System.out"].println(max - 2) ) else     OclFile["System.out"].println(max - 1) ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.BitSet ;
import java.util.List ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line=br.readLine();
    BitSet sb=new BitSet();
    List<Integer>list=new ArrayList<Integer>();
    while(!("0 0".equals(line))){
      int n=Integer.parseInt(line.substring(0,line.indexOf(' ')));
      int k=Integer.parseInt(line.substring(line.indexOf(' ')+1));
      sb.clear();
      list.clear();
      for(int i=0 ; i<k ; i++){
        sb.set(Integer.parseInt(br.readLine()));
      }
      int sizeMax=0 ;
      if(! sb.get(1)){
        list.add(0);
      }
      int start=sb.nextSetBit(1);
      while(start!=-1){
        final int end=sb.nextClearBit(start);
        list.add(Integer.valueOf(end-start));
        start=sb.nextSetBit(end);
        if(start-end!=1){
          list.add(Integer.valueOf(0));
        }
      }
      if(sb.get(0)){
        for(int i=0 ; i<list.size()-1 ; i++){
          sizeMax=Math.max(sizeMax,list.get(i)+list.get(i+1)+1);
        }
      }
      else {
        for(int i=0 ; i<list.size(); i++){
          sizeMax=Math.max(sizeMax,list.get(i));
        }
      }
      System.out.println(sizeMax);
      line=br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := br.readLine() ;
    var sb : Sequence(boolean) ; sb := MathLib.toBitSequence() ;
    var list : Sequence(int) ; list := Sequence{} ;
    while (not(("0 0" = line))) do (     var n : int ; n := (line.subrange(0+1,line->indexOf(' ')-1))->toInteger() ;
     var k : int ; k := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1))->toInteger() ;
    sb := sb->intersection(Set{}) ; 
    list := list->intersection(Set{}) ; 
        var i : int ; i := 0 ; while i < k do ( (     sb := sb.setAt((br.readLine())->toInteger()+1, true) )  ;     i := i + 1 ) ; 
    var sizeMax : int ; sizeMax := 0 ;
    if (not(sb->at(1+1))) then (     list := list->including(0) ) else skip ; 
    var start : int ; start := sb.nextSetBit(1) ;
    while (start /= -1) do (     var end : int ; end := sb.nextClearBit(start) ;
     list := list->including((end - start)->toInteger()) ; 
     start := sb.nextSetBit(end) ; 
     if (start - end /= 1) then (     list := list->including((0)->toInteger()) ) else skip ) ; 
    if (sb->at(0+1)) then (         var i : int ; i := 0 ; while i < list->size() - 1 do ( (     sizeMax := Set{sizeMax, list->at(i+1) + list->at(i + 1+1) + 1}->max() )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < list->size() do ( (     sizeMax := Set{sizeMax, list->at(i+1)}->max() )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(sizeMax) ; 
    line := br.readLine() ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      int k=sc.nextInt();
      if((n | k)==0)break ;
      int[] card=new int[k+1];
      for(int i=0 ; i<k ; i++)card[i]=sc.nextInt();
      sort(card);
      int max=0 ;
      if(card[1]!=0){
        int cnt=0 ;
        for(int i=1 ; i<=k ; i++){
          if(card[i]==card[i-1]+1)cnt++;
          else cnt=1 ;
          max=max(cnt,max);
        }
      }
      else {
        int[] cnt=new int[2];
        for(int i=2 ; i<=k ; i++){
          if(card[i]==card[i-1]+1){
            cnt[0]++;
            if(cnt[1]!=0)cnt[1]++;
          }
          else if(card[i]==card[i-1]+2){
            cnt[1]=cnt[0]+2 ;
            cnt[0]=1 ;
          }
          else {
            cnt[0]=1 ;
            cnt[1]=0 ;
          }
          max=max(max,max(cnt[0],cnt[1]));
        }
      }
      System.out.println(max);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,k)) = 0) then     break else skip ; 
    var card : Sequence(int) ; card := Integer.subrange(1,k + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < k do (     card[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    execute sort(card) ; 
    var max : int ; max := 0 ;
    if (card[1+1] /= 0) then (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 1 ; while i <= k do ( (     if (card[i+1] = card[i - 1+1] + 1) then     cnt := cnt + 1 else     cnt := 1 ; ;  
     max := Set{cnt, max}->max() )  ;     i := i + 1 ) ) else (     var cnt : Sequence(int) ; cnt := Integer.subrange(1,2)->collect(0) ;
         var i : int ; i := 2 ; while i <= k do ( (     if (card[i+1] = card[i - 1+1] + 1) then (     cnt[0+1] := cnt[0+1] + 1 ; 
     if (cnt[1+1] /= 0) then     cnt[1+1] := cnt[1+1] + 1 ; else skip ) else     if (card[i+1] = card[i - 1+1] + 2) then (     cnt[1+1] := cnt[0+1] + 2 ; 
     cnt[0+1] := 1 ) else (     cnt[0+1] := 1 ; 
     cnt[1+1] := 0 ) ;  ;  
     max := Set{max, Set{cnt[0+1], cnt[1+1]}->max()}->max() )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(max) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int multiplyWith4(int n){
    return(n<<2);
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.print(multiplyWith4(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation multiplyWith4( n : int) : int
  pre: true
  post: true
  activity: (     return ((n*(2->pow(2)))->oclAsType(long)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].print(multiplyWith4(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.BitSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    BitSet set=new BitSet();
    boolean hasWild=false ;
    while((n!=k)&&(n!=0)){
      set.clear();
      hasWild=false ;
      for(int i=0 ; i<k ; i++){
        final int nextInt=in.nextInt();
        if(nextInt!=0){
          set.set(nextInt);
        }
        else {
          hasWild=true ;
        }
      }
      int start=set.nextSetBit(0);
      int sizeMax=0 ;
      while(start!=-1){
        int end=start ;
        while(set.get(end+1)){
          end++;
        }
        int nextstart=set.nextSetBit(end+1);
        if(hasWild && set.get(end+2)){
          end+=2 ;
          while(set.get(end+1)){
            end++;
          }
        }
        final int size=(end-start)+1 ;
        sizeMax=Math.max(sizeMax,size);
        start=nextstart ;
      }
      System.out.println(sizeMax);
      n=in.nextInt();
      k=in.nextInt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var set : Sequence(boolean) ; set := MathLib.toBitSequence() ;
    var hasWild : boolean ; hasWild := false ;
    while ((n /= k) & (n /= 0)) do (     set := set->intersection(Set{}) ; 
     hasWild := false ; 
        var i : int ; i := 0 ; while i < k do ( (     var nextInt : int ; nextInt := in.getCurrent()->toInteger() ;
     if (nextInt /= 0) then (     set := set.setAt(nextInt+1, true) ) else (     hasWild := true ) )  ;     i := i + 1 ) ; 
    var start : int ; start := set.nextSetBit(0) ;
    var sizeMax : int ; sizeMax := 0 ;
    while (start /= -1) do (     var end : int ; end := start ;
     while (set->at(end + 1+1)) do (     end := end + 1 ) ; 
    var nextstart : int ; nextstart := set.nextSetBit(end + 1) ;
    if (hasWild & set->at(end + 2+1)) then (     end := end+(2) ; 
     while (set->at(end + 1+1)) do (     end := end + 1 ) ) else skip ; 
    var size : int ; size := (end - start) + 1 ;
    sizeMax := Set{sizeMax, size}->max() ; 
    start := nextstart ; 
 ) ; 
    OclFile["System.out"].println(sizeMax) ; 
    n := in.getCurrent()->toInteger() ; 
    k := in.getCurrent()->toInteger() ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class GFG {
  static int binarySearch(int arr[],int low,int high,int x){
    if(high>=low){
      int mid=low+(high-low)/2 ;
      if(x==arr[mid])return mid ;
      if(x>arr[mid])return binarySearch(arr,(mid+1),high,x);
      else return binarySearch(arr,low,(mid-1),x);
    }
    return-1 ;
  }
  static int countPairsWithDiffK(int arr[],int n,int k){
    int count=0,i ;
    Arrays.sort(arr);
    for(i=0 ; i<n-1 ; i++)if(binarySearch(arr,i+1,n-1,arr[i]+k)!=-1)count++;
    return count ;
  }
  public static void main(String args[]){
    int arr[]={
      1,5,3,4,2 };
      int n=arr.length ;
      int k=3 ;
      System.out.println("Count of pairs with given diff is "+countPairsWithDiffK(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation binarySearch( arr : Sequence(int), low : int, high : int, x : int) : int
  pre: true
  post: true
  activity: (     if (high >= low) then (     var mid : int ; mid := low + (high - low) / 2 ;
     if (x = arr[mid+1]) then     return mid else skip ; 
     if (x > arr[mid+1]) then     return binarySearch(arr, (mid + 1), high, x) else     return binarySearch(arr, low, (mid - 1), x) ) else skip ; 
     return -1 );
  static   operation countPairsWithDiffK( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
    var i : int ;
     arr := arr->sort() ; 
         i := 0 ; while i < n - 1 do (     if (binarySearch(arr, i + 1, n - 1, arr[i+1] + k) /= -1) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,3,4,2} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println("Count of pairs with given diff is " + countPairsWithDiffK(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigDecimal ;
import java.math.MathContext ;
import java.util.*;
public class ProblemD {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    String line[]=br.readLine().split(" ");
    int arr[]=new int[n];
    int count[]=new int[10001];
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(line[i]);
      count[arr[i] ]++;
    }
    Arrays.sort(arr);
    int x=arr[n-1];
    for(int i=1 ; i*i<=x ; i++){
      if(x % i==0){
        count[i]--;
        if(i!=x/i)count[x/i]--;
      }
    }
    for(int i=10000 ; i>=0 ; i--){
      if(count[i]>0){
        System.out.println(x+" "+i);
        break ;
      }
    }
  }
  public static int gcd(int a,int b){
    return b==0 ? a : gcd(b,a % b);
  }
  public static int search(int l,int r,int target,int arr[]){
    int ans=0 ;
    while(l<=r){
      int mid=(l+r)/2 ;
      if(arr[mid]<=target){
        ans=mid ;
        l=mid+1 ;
      }
      else r=mid-1 ;
    }
    return ans ;
  }
  public static void sort(int arr[]){
    ArrayList<Integer>list=new ArrayList<>();
    for(int it : arr)list.add(it);
    Collections.sort(list);
    for(int i=0 ; i<list.size(); i++)arr[i]=list.get(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemD {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var count : Sequence(int) ; count := Integer.subrange(1,10001)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (line[i+1])->toInteger() ; 
     count[arr[i+1]+1] := count[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var x : int ; x := arr[(n)->char2byte() - 1+1] ;
        var i : int ; i := 1 ; while i * i <= x do ( (     if (x mod i = 0) then (     count[i+1] := count[i+1] - 1 ; 
     if (i /= x / i) then     count[x / i+1] := count[x / i+1] - 1 ; else skip ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 10000 ; while i >= 0 do ( (     if (count[i+1] > 0) then (     OclFile["System.out"].println(x + " " + i) ; 
     break ) else skip )  ;     i := i - 1 ) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
  static   operation search( l : int, r : int, target : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     while (l <= r) do (     var mid : int ; mid := (l + r) / 2 ;
     if (arr[mid+1] <= target) then (     ans := mid ; 
     l := mid + 1 ) else     r := mid - 1 ; ) ; 
     return ans );
  static   operation sort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     for (it : arr) do (     list := list->including(it) ;  ) ; 
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < list->size() do (     arr[i+1] := list->at(i+1) ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class practice {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=1 ;
    while(t-->0){
      int n=s.nextInt();
      HashMap<Integer,Integer>hs=new HashMap();
      List<Integer>l=new ArrayList();
      int max=0 ;
      for(int i=0 ; i<n ; i++){
        int a=s.nextInt();
        max=Math.max(max,a);
        l.add(a);
        hs.put(a,hs.getOrDefault(a,0)+1);
      }
      List<Integer>r=new ArrayList();
      for(int i=0 ; i<l.size(); i++){
        int a=l.get(i);
        if(hs.get(a)==1){
          if(max % a!=0){
            r.add(a);
          }
        }
        else {
          r.add(a);
        }
      }
      Collections.sort(r);
      System.out.println(max+" "+(r.get(r.size()-1)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var hs : Map(int,int) ; hs := Map{} ;
    var l : Sequence(int) ; l := Sequence{} ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := s.getCurrent()->toInteger() ;
     max := Set{max, a}->max() ; 
     l := l->including(a) ; 
     hs := hs->union(Map{a |-> (if hs->keys()->contains(a) then hs->at(a) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var r : Sequence(int) ; r := Sequence{} ;
        var i : int ; i := 0 ; while i < l->size() do ( (     var a : int ; a := l->at(i+1) ;
     if (hs->at(a) = 1) then (     if (max mod a /= 0) then (     r := r->including(a) ) else skip ) else (     r := r->including(a) ) )  ;     i := i + 1 ) ; 
    r := r->sort() ; 
    OclFile["System.out"].println(max + " " + (r->at(r->size() - 1+1))) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  int n ;
  char[] cs ;
  public static void main(String args[]){
    new Main().run();
  }
  void run(){
    FastReader sc=new FastReader();
    n=sc.nextInt();
    cs=sc.next().toCharArray();
    solve();
  }
  void solve(){
    int x=0 ;
    int max=0 ;
    for(int i=0 ; i<n ; i++){
      if(cs[i]=='I'){
        x++;
        if(max<x){
          max=x ;
        }
      }
      else {
        x--;
      }
    }
    System.out.println(max);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute cs : Sequence(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     n := sc.nextInt() ; 
     cs := sc.next()->characters() ; 
     execute solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var x : int ; x := 0 ;
     var max : int ; max := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (cs[i+1] = 'I') then (     x := x + 1 ; 
     if (max < x) then (     max := x ) else skip ) else (     x := x - 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(max) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class submitfinal {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    Vector<Integer>v1=new Vector<>();
    Vector<Integer>v2=new Vector<>();
    for(int i=0 ; i<n ; ++i){
      a[i]=sc.nextInt();
    }
    Arrays.sort(a);
    v2.add(a[n-1]);
    for(int i=0 ; i<n-1 ; ++i){
      if(a[i]==a[i+1]){
        v1.add(a[i]);
        v2.add(a[i]);
      }
      else {
        if(a[n-1] % a[i]==0){
          if(v2.contains(a[i])==false)v2.add(a[i]);
        }
        else {
          v1.add(a[i]);
        }
      }
    }
    Collections.sort(v1);
    Collections.sort(v2);
    System.out.println(v1.get(v1.size()-1)+" "+v2.get(v2.size()-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class submitfinal {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var v1 : Sequence(int) ; v1 := Sequence{} ;
    var v2 : Sequence(int) ; v2 := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    v2 := v2->including(a[n - 1+1]) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (a[i+1] = a[i + 1+1]) then (     v1 := v1->including(a[i+1]) ; 
     v2 := v2->including(a[i+1]) ) else (     if (a[n - 1+1] mod a[i+1] = 0) then (     if (v2->includes(a[i+1]) = false) then     v2 := v2->including(a[i+1]) ; else skip ) else (     v1 := v1->including(a[i+1]) ) ) )  ;     i := i + 1 ) ; 
    v1 := v1->sort() ; 
    v2 := v2->sort() ; 
    OclFile["System.out"].println(v1->at(v1->size() - 1+1) + " " + v2->at(v2->size() - 1+1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.SortedMap ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] d=new int[n];
    for(int i=0 ; i<d.length ; i++){
      d[i]=sc.nextInt();
    }
    System.out.println(solve(d));
    sc.close();
  }
  static String solve(int[] d){
    SortedMap<Integer,Integer>divisorToCount=new TreeMap<>();
    for(int divisor : d){
      divisorToCount.put(divisor,divisorToCount.getOrDefault(divisor,0)+1);
    }
    int x=divisorToCount.lastKey();
    for(int i=1 ; i<=x ; i++){
      if(x % i==0){
        divisorToCount.put(i,divisorToCount.get(i)-1);
        if(divisorToCount.get(i)==0){
          divisorToCount.remove(i);
        }
      }
    }
    int y=divisorToCount.lastKey();
    return String.format("%d %d",x,y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < d->size() do ( (     d[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(d)) ; 
    skip ; 
 );
  static   operation solve( d : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var divisorToCount : Map(int,int) ; divisorToCount := Map{} ;
     for (divisor : d) do ( (     divisorToCount := divisorToCount->union(Map{divisor |-> (if divisorToCount->keys()->contains(divisor) then divisorToCount->at(divisor) else 0 endif) + 1}) )  ) ; 
    var x : int ; x := divisorToCount->keys()->max() ;
        var i : int ; i := 1 ; while i <= x do ( (     if (x mod i = 0) then (     divisorToCount := divisorToCount->union(Map{i |-> divisorToCount->at(i) - 1}) ; 
     if (divisorToCount->at(i) = 0) then (     divisorToCount := divisorToCount->antirestrict(Set{i}) ) else skip ) else skip )  ;     i := i + 1 ) ; 
    var y : int ; y := divisorToCount->keys()->max() ;
    return StringLib.format("%d %d",Sequence{x,y}) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      n=scanner.nextInt();
      k=scanner.nextInt();
      if((n | k)==0)break ;
      num=new int[n];
      for(int i=0 ; i<n ; i++)num[i]=scanner.nextInt();
      set=new HashSet<String>();
      dfs(0,"",0);
      System.out.println(set.size());
    }
  }
  private void dfs(int x,String s,int bit){
    if(x==k){
      set.add(s);
      return ;
    }
    for(int i=0 ; i<num.length ; i++){
      if(((bit>>i)& 1)==1)continue ;
      dfs(x+1,s+num[i],bit | 1<<i);
    }
  }
  int n,k ;
  int[] num ;
  Set<String>set ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     n := scanner.getCurrent()->toInteger() ; 
     k := scanner.getCurrent()->toInteger() ; 
    if ((n or k) = 0) then     break else skip ; 
    num := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     num[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    set := Set{} ; 
    execute dfs(0, "", 0) ; 
    OclFile["System.out"].println(set->size()) ; 
 ) );
   operation dfs( x : int, s : String, bit : int) : void
  pre: true
  post: true
  activity: (     if (x = k) then (     set->excludes(s) ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < num->size() do ( (     if ((((bit/(2->pow(i)))->oclAsType(long)) & 1) = 1) then     continue else skip ; 
     execute dfs(x + 1, s + num[i+1], bit or (1*(2->pow(i)))->oclAsType(long)) )  ;     i := i + 1 ) );
   attribute n : int;
   attribute num : Sequence(int);
   attribute set : Set(String);
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static String[] card ;
  static HashSet<String>set ;
  static int N ;
  static void rec(int[] p,int d){
    if(d==p.length){
      String all="" ;
      for(int i=0 ; i<d ; ++i){
        all+=card[p[i] ];
      }
      set.add(all);
      return ;
    }
    OUT : for(int i=0 ;
    i<N ;
++i){
      for(int j=0 ; j<d ; ++j){
        if(p[j]==i)continue OUT ;
      }
      p[d]=i ;
      rec(p,d+1);
    }
  }
  public static void main(String[] args){
    while(true){
      N=sc.nextInt();
      int K=sc.nextInt();
      if(N==0)break ;
      card=new String[N];
      for(int i=0 ; i<N ; ++i){
        card[i]=sc.next();
      }
      set=new HashSet<String>();
      int[] p=new int[K];
      rec(p,0);
      System.out.println(set.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute card : Sequence(String);
  static   attribute set : Set(String);
  static   attribute N : int;
  static   operation rec( p : Sequence(int), d : int) : void
  pre: true
  post: true
  activity: (     if (d = p->size()) then (     var all : String ; all := "" ;
         var i : int ; i := 0 ; while i < d do ( (     all := all+(card[p[i+1]+1]) )  ;     i := i + 1 ) ; 
     set := set->including(all) ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < d do ( (     if (p[j+1] = i) then     continue else skip )  ;     j := j + 1 ) ; 
     p[d+1] := i ; 
     execute rec(p, d + 1) )  ;     i := i + 1 ) ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     N := sc.getCurrent()->toInteger() ; 
     var K : int ; K := sc.getCurrent()->toInteger() ;
    if (N = 0) then     break else skip ; 
    card := Integer.subrange(1,N)->collect(null) ; 
        var i : int ; i := 0 ; while i < N do ( (     card[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    set := Set{} ; 
    var p : Sequence(int) ; p := Integer.subrange(1,K)->collect(0) ;
    execute rec(p, 0) ; 
    OclFile["System.out"].println(set->size()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    while(true){
      int a=s.nextInt();
      int b=s.nextInt();
      if(a+b==0)System.exit(0);
      HashMap<String,Boolean>map=new HashMap<String,Boolean>();
      String[] c=new String[a];
      for(int i=0 ; i<a ; i++){
        c[i]=s.next();
      }
      int count=0 ;
      for(int i=0 ; i<a ; i++){
        for(int j=0 ; j<a ; j++){
          if(b>2){
            for(int k=0 ; k<a ; k++){
              if(b>3){
                for(int l=0 ; l<a ; l++){
                  if(i!=j && i!=k && i!=l && j!=k && j!=l && k!=l && ! map.containsKey(c[i]+c[j]+c[k]+c[l])){
                    count++;
                    map.put(c[i]+c[j]+c[k]+c[l],true);
                  }
                }
              }
              else {
                if(i!=j && i!=k && j!=k && ! map.containsKey(c[i]+c[j]+c[k])){
                  count++;
                  map.put(c[i]+c[j]+c[k],true);
                }
              }
            }
          }
          else {
            if(i!=j && ! map.containsKey(c[i]+c[j])){
              count++;
              map.put(c[i]+c[j],true);
            }
          }
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var a : int ; a := s.getCurrent()->toInteger() ;
     var b : int ; b := s.getCurrent()->toInteger() ;
    if (a + b = 0) then OclProcess.exit(0) ; else skip ; 
    var map : Map(String,Boolean) ; map := Map{} ;
    var c : Sequence(String) ; c := Integer.subrange(1,a)->collect(null) ;
        var i : int ; i := 0 ; while i < a do ( (     c[i+1] := s.getCurrent() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < a do ( (         var j : int ; j := 0 ; while j < a do ( (     if (b > 2) then (         var k : int ; k := 0 ; while k < a do ( (     if (b > 3) then (         var l : int ; l := 0 ; while l < a do ( (     if (i /= j & i /= k & i /= l & j /= k & j /= l & k /= l & not(map->keys()->includes(c[i+1] + c[j+1] + c[k+1] + c[l+1]))) then (     count := count + 1 ; 
     map := map->union(Map{c[i+1] + c[j+1] + c[k+1] + c[l+1] |-> true}) ) else skip )  ;     l := l + 1 ) ) else (     if (i /= j & i /= k & j /= k & not(map->keys()->includes(c[i+1] + c[j+1] + c[k+1]))) then (     count := count + 1 ; 
     map := map->union(Map{c[i+1] + c[j+1] + c[k+1] |-> true}) ) else skip ) )  ;     k := k + 1 ) ) else (     if (i /= j & not(map->keys()->includes(c[i+1] + c[j+1]))) then (     count := count + 1 ; 
     map := map->union(Map{c[i+1] + c[j+1] |-> true}) ) else skip ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void find_idx(int arr[],int n){
    Vector answer=new Vector();
    int sum=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(sum==arr[i]){
        answer.add(i);
      }
      sum+=arr[i];
    }
    if(answer.size()==0){
      System.out.println("-1");
      return ;
    }
    for(int i=answer.size()-1 ; i>=0 ; i--)System.out.print(answer.get(i)+" ");
  }
  public static void main(String[] args){
    int arr[]={
      36,2,17,6,6,5 };
      int n=arr.length ;
      find_idx(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation find_idx( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var answer : Sequence ; answer := Sequence{} ;
     var sum : int ; sum := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (sum = arr[i+1]) then (     answer := answer->including(i) ) else skip ; 
     sum := sum+(arr[i+1]) )  ;     i := i - 1 ) ; 
    if (answer->size() = 0) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
        var i : int ; i := answer->size() - 1 ; while i >= 0 do (     OclFile["System.out"].print(answer->at(i+1) + " ") ;  ;     i := i - 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{36,2,17,6,6,5} ;
     var n : int ; n := arr->size() ;
     execute find_idx(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int k=sc.nextInt();
      int[] m=new int[n];
      for(int i=0 ; i<n ; i++){
        m[i]=sc.nextInt();
      }
      ArrayDeque<String>que=new ArrayDeque<String>();
      StringBuffer sb ;
      String s ;
      for(int a=0 ; a<n ; a++){
        for(int b=0 ; b<n ; b++){
          if(a!=b){
            if(k==2){
              sb=new StringBuffer();
              s=sb.append(m[a]).append(m[b]).toString();
              if(que.contains(s)==false)que.add(s);
            }
            else {
              for(int c=0 ; c<n ; c++){
                if(a!=c && b!=c){
                  if(k==3){
                    sb=new StringBuffer();
                    s=sb.append(m[a]).append(m[b]).append(m[c]).toString();
                    if(que.contains(s)==false)que.add(s);
                  }
                  else {
                    for(int d=0 ; d<n ; d++){
                      if(a!=d && b!=d && c!=d){
                        sb=new StringBuffer();
                        s=sb.append(m[a]).append(m[b]).append(m[c]).append(m[d]).toString();
                        if(que.contains(s)==false)que.add(s);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
      System.out.println(que.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var m : Sequence(int) ; m := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     m[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var que : Sequence(String) ; que := ArrayDeque<String>.newArrayDeque() ;
    var sb : String ;
    var s : String ;
        var a : int ; a := 0 ; while a < n do ( (         var b : int ; b := 0 ; while b < n do ( (     if (a /= b) then (     if (k = 2) then (     sb := StringLib.newString() ; 
     s := sb + StringLib.newString(m[a+1]) + StringLib.newString(m[b+1])+"" ; 
     if (que->includes(s) = false) then     que := que->including(s) ; else skip ) else (         var c : int ; c := 0 ; while c < n do ( (     if (a /= c & b /= c) then (     if (k = 3) then (     sb := StringLib.newString() ; 
     s := sb + StringLib.newString(m[a+1]) + StringLib.newString(m[b+1]) + StringLib.newString(m[c+1])+"" ; 
     if (que->includes(s) = false) then     que := que->including(s) ; else skip ) else (         var d : int ; d := 0 ; while d < n do ( (     if (a /= d & b /= d & c /= d) then (     sb := StringLib.newString() ; 
     s := sb + StringLib.newString(m[a+1]) + StringLib.newString(m[b+1]) + StringLib.newString(m[c+1]) + StringLib.newString(m[d+1])+"" ; 
     if (que->includes(s) = false) then     que := que->including(s) ; else skip ) else skip )  ;     d := d + 1 ) ) ) else skip )  ;     c := c + 1 ) ) ) else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(que->size()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] $){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt(),a=0,i=0 ;
    while(i++<n)if(s.nextInt()==i){
      a++;
      if(i++<n)s.next();
    }
    System.out.println(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var a : int ; a := 0 ;
    var i : int ; i := 0 ;
         while (i < n) do (        i := i + 1 ;     skip ;     if (s.getCurrent()->toInteger() = i) then (     a := a + 1 ; 
     if (i < n) then     skip ; else skip ) else skip ; ;  ) ;  
     OclFile["System.out"].println(a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskD solver=new TaskD();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskD {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int[] a=new int[n+1];
      for(int i=1 ; i<=n ; ++i){
        a[i]=in.nextInt();
      }
      int ans=0 ;
      for(int i=1 ; i+1<=n ; ++i){
        if(a[i]==i){
          int tmp=a[i];
          a[i]=a[i+1];
          a[i+1]=tmp ;
          ans++;
        }
      }
      if(a[n]==n)ans++;
      out.println(ans);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskD ; solver := TaskD.newTaskD() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskD {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i + 1 <= n do ( (     if (a[i+1] = i) then (     var tmp : int ; tmp := a[i+1] ;
     a[i+1] := a[i + 1+1] ; 
     a[i + 1+1] := tmp ; 
     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (a[n+1] = n) then     ans := ans + 1 ; else skip ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    int k=sc.nextInt();
    String s=sc.next();
    int ans=0 ;
    int x=0 ;
    for(int i=0 ; i<k ; i++){
      if(s.charAt(i)=='I'){
        x++;
      }
      else {
        x--;
      }
      ans=Math.max(x,ans);
    }
    System.out.println(ans);
  }
  static int l_min(int[] a){
    Arrays.sort(a);
    return a[0];
  }
  static int l_max(int[] a){
    int l=a.length ;
    Arrays.sort(a);
    return a[l-1];
  }
  public static PrintWriter out ;
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var k : int ; k := sc.nextInt() ;
    var s : String ; s := sc.next() ;
    var ans : int ; ans := 0 ;
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     if (s->at(i+1) = 'I') then (     x := x + 1 ) else (     x := x - 1 ) ;  
     ans := Set{x, ans}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation l_min( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     return a[0+1] );
  static   operation l_max( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var l : int ; l := a->size() ;
     a := a->sort() ; 
     return a[l - 1+1] );
  static   attribute out : OclFile;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
import java.util.function.Consumer ;
import java.util.stream.IntStream ;
import static java.util.stream.Collectors.toList ;
public class Main {
  private static final Scanner scanner=new Scanner(System.in);
  private static final Consumer<List<String>>consumer=solve();
  public static void main(String[] args){
    consumer.accept(readInput());
  }
  private static List<String>readInput(){
    final List<String>lineList=new ArrayList<>();
    while(scanner.hasNextLine()){
      lineList.add(scanner.nextLine());
    }
    return lineList ;
  }
  private static Consumer<List<String>>solve(){
    return args->{
      final List<Integer>numList=Arrays.stream(args.get(1).split(" ")).map(Integer :: valueOf).collect(toList());
      final List<Integer>matchedIndexList=IntStream.range(0,numList.size()).filter(x->numList.get(x).equals(x+1)).boxed().collect(toList());
      Integer curr=-1 ;
      Integer cnt=0 ;
      Integer ans=0 ;
      for(final Integer index : matchedIndexList){
        if(curr==-1 || curr+1==index){
          cnt++;
          curr=index ;
          continue ;
        }
        ans+=Double.valueOf(Math.ceil(cnt.doubleValue()/2)).intValue();
        cnt=1 ;
        curr=index ;
      }
      ans+=Double.valueOf(Math.ceil(cnt.doubleValue()/2)).intValue();
      System.out.println(ans);
    };
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute consumer : Function(<Sequence(String)>, void) := solve();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     consumer->apply(readInput()) );
  static   operation readInput() : Sequence(String)
  pre: true
  post: true
  activity: (     var lineList : Sequence(String) ; lineList := Sequence{} ;
     while (scanner.hasNextLine()) do (     lineList := lineList->including(scanner.nextLine()) ) ; 
     return lineList );
  static   operation solve() : Function(<Sequence(String)>, void)
  pre: true
  post: true
  activity: (     return lambda args : OclAny in (     var numList : Sequence(int) ; numList := stream(args->at(1+1)->split(" "))->collect( _x1 | (lambda _pars : OclAny in Integer.newInteger().valueOf(_pars))->apply(_x1) ).collect(toList()) ;
     var matchedIndexList : Sequence(int) ; matchedIndexList := Integer.subrange(0, numList->size()-1)->select( _x1 | (lambda x : OclAny in numList->at(x+1) = x + 1)->apply(_x1) ).collect(toList()) ;
    var curr : int ; curr := -1 ;
    var cnt : int ; cnt := 0 ;
    var ans : int ; ans := 0 ;
    for (index : matchedIndexList) do ( (     if (curr = -1 or curr + 1 = index) then (     cnt := cnt + 1 ; 
     curr := index ; 
     continue ) else skip ; 
     ans := ans+(((cnt->oclAsType(double) / 2)->ceil())->toReal()->oclAsType(int)) ; 
     cnt := 1 ; 
     curr := index )  ) ; 
    ans := ans+(((cnt->oclAsType(double) / 2)->ceil())->toReal()->oclAsType(int)) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  int n ;
  int[] ps ;
  public static void main(String args[]){
    new Main().run();
  }
  void run(){
    FastReader sc=new FastReader();
    n=sc.nextInt();
    ps=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      ps[i]=sc.nextInt();
    }
    solve();
  }
  void solve(){
    boolean[] bads=new boolean[n+1];
    for(int i=1 ; i<=n ; i++){
      if(ps[i]==i){
        bads[i]=true ;
      }
    }
    int count=0 ;
    for(int i=1 ; i<n ; i++){
      if(ps[i]==i){
        swap(ps,i,i+1);
        count++;
      }
    }
    if(ps[n]==n){
      count++;
    }
    System.out.println(count);
  }
  void swap(int[] ps,int i,int j){
    int temp=ps[i];
    ps[i]=ps[j];
    ps[j]=temp ;
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute ps : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     n := sc.nextInt() ; 
    ps := Integer.subrange(1,n + 1)->collect(0) ; 
        var i : int ; i := 1 ; while i <= n do ( (     ps[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    execute solve() ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var bads : Sequence(boolean) ; bads := Integer.subrange(1,n + 1)->collect(false) ;
         var i : int ; i := 1 ; while i <= n do ( (     if (ps[i+1] = i) then (     bads[i+1] := true ) else skip )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (ps[i+1] = i) then (     execute swap(ps, i, i + 1) ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (ps[n+1] = n) then (     count := count + 1 ) else skip ; 
    OclFile["System.out"].println(count) ; 
 );
   operation swap( ps : Sequence(int), i : int, j : int) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := ps[i+1] ;
     ps[i+1] := ps[j+1] ; 
     ps[j+1] := temp );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int N=gi();
    int[] p=new int[N];
    boolean bf=false ;
    long ans=0 ;
    for(int i=0 ; i<N ; i++){
      p[i]=gi();
      if(p[i]==i+1){
        if(! bf){
          ans++;
          bf=true ;
        }
        else {
          bf=false ;
        }
      }
      else {
        bf=false ;
      }
    }
    System.out.println(ans);
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : int ; N := gi() ;
    var p : Sequence(int) ; p := Integer.subrange(1,N)->collect(0) ;
    var bf : boolean ; bf := false ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     p[i+1] := gi() ; 
     if (p[i+1] = i + 1) then (     if (not(bf)) then (     ans := ans + 1 ; 
     bf := true ) else (     bf := false ) ) else (     bf := false ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    Scanner r=new Scanner(System.in);
    char[] c ;
    String s ;
    int[] huda=new int[10];
    int n ;
    int turn ;
    int field ;
    int i,j ;
    while(r.hasNext()){
      turn=0 ;
      field=0 ;
      s=r.next();
      n=Integer.parseInt(s);
      if(n==0)break ;
      for(i=0 ; i<n ; i++)huda[i]=0 ;
      s=r.next();
      c=s.toCharArray();
      for(i=0 ; i<100 ; i++){
        switch(c[i]){
          case 'M' : huda[turn]++;
          break ;
          case 'S' : field+=huda[turn]+1 ;
          huda[turn]=0 ;
          break ;
          case 'L' : huda[turn]+=field+1 ;
          field=0 ;
          break ;
        }
        if(turn+1==n)turn=0 ;
        else turn++;
      }
      Arrays.sort(huda,0,n);
      for(i=0 ; i<n ; i++)System.out.print(huda[i]+" ");
      System.out.println(field);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : Sequence(String) ;
    var s : String ;
    var huda : Sequence(int) ; huda := Integer.subrange(1,10)->collect(0) ;
    var n : int ;
    var turn : int ;
    var field : int ;
    var i : int ;
    var j : int ;
    while (r.hasNext()) do (     turn := 0 ; 
     field := 0 ; 
    s := r.getCurrent() ; 
    n := (s)->toInteger() ; 
    if (n = 0) then     break else skip ; 
        i := 0 ; while i < n do (     huda[i+1] := 0 ;  ;     i := i + 1 ) ; 
    s := r.getCurrent() ; 
    c := s->characters() ; 
        i := 0 ; while i < 100 do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c[i+1]) ; 
       if _switchval = 'M' then
     huda[turn+1] := huda[turn+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 'S' then
     field := field+(huda[turn+1] + 1) ; 
    huda[turn+1] := 0 ; 
    break 
   else skip ;
       if _switchval = 'L' then
     huda[turn+1] := huda[turn+1]+(field + 1) ; 
    field := 0 ; 
    break 
   else skip ;
 )
     if (turn + 1 = n) then     turn := 0 ; else     turn := turn + 1 ; )  ;     i := i + 1 ) ; 
    huda := huda.subrange(1,0)^(huda.subrange(0+1,n)->sort())^huda.subrange(n+1,huda.size) ; 
        i := 0 ; while i < n do (     OclFile["System.out"].print(huda[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(field) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void play(String line,int N){
    int[] C=new int[N];
    int B=0 ;
    for(int i=0 ; i<N ; i++)C[i]=0 ;
    for(int i=0 ; i<line.length(); i++){
      int p=i % N ;
      if(line.charAt(i)=='M'){
        C[p]++;
      }
      else if(line.charAt(i)=='S'){
        C[p]++;
        B+=C[p];
        C[p]=0 ;
      }
      else if(line.charAt(i)=='L'){
        C[p]+=B+1 ;
        B=0 ;
      }
    }
    Arrays.sort(C);
    for(int i=0 ; i<N ; i++)System.out.print(C[i]+" ");
    System.out.println(B);
  }
  void solve(){
    int N ;
    String line ;
    Scanner sc=new Scanner(System.in);
    while(true){
      N=sc.nextInt();
      if(N==0)break ;
      line=sc.next();
      play(line,N);
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation play( line : String, N : int) : void
  pre: true
  post: true
  activity: (     var C : Sequence(int) ; C := Integer.subrange(1,N)->collect(0) ;
     var B : int ; B := 0 ;
        var i : int ; i := 0 ; while i < N do (     C[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < line->size() do ( (     var p : int ; p := i mod N ;
     if (line->at(i+1) = 'M') then (     C[p+1] := C[p+1] + 1 ) else     if (line->at(i+1) = 'S') then (     C[p+1] := C[p+1] + 1 ; 
     B := B+(C[p+1]) ; 
     C[p+1] := 0 ) else     if (line->at(i+1) = 'L') then (     C[p+1] := C[p+1]+(B + 1) ; 
     B := 0 ) else skip ; ;  )  ;     i := i + 1 ) ; 
    C := C->sort() ; 
        var i : int ; i := 0 ; while i < N do (     OclFile["System.out"].print(C[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(B) ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : int ;
     var line : String ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     N := sc.getCurrent()->toInteger() ; 
     if (N = 0) then     break else skip ; 
     line := sc.getCurrent() ; 
     execute play(line, N) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.math.BigInteger ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    final int decks=100 ;
    int[] deck=new int[decks];
    while(true){
      final int N=sc.nextInt();
      if(N==0){
        break ;
      }
      char[] input=sc.next().toCharArray();
      for(int i=0 ; i<decks ; i++){
        if(input[i]=='M'){
          deck[i]=0 ;
        }
        else if(input[i]=='S'){
          deck[i]=1 ;
        }
        else if(input[i]=='L'){
          deck[i]=2 ;
        }
      }
      int field=0 ;
      int[] player=new int[N];
      for(int i=0 ; i<decks ; i++){
        final int play=i % N ;
        if(deck[i]==0){
          player[play]++;
        }
        else if(deck[i]==1){
          field+=player[play]+1 ;
          player[play]=0 ;
        }
        else if(deck[i]==2){
          player[play]+=field+1 ;
          field=0 ;
        }
      }
      Arrays.sort(player);
      for(int i=0 ; i<N ; i++){
        if(i!=0){
          System.out.print(" ");
        }
        System.out.print(player[i]);
      }
      System.out.println(" "+field);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var decks : int ; decks := 100 ;
     var deck : Sequence(int) ; deck := Integer.subrange(1,decks)->collect(0) ;
     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then (     break ) else skip ; 
    var input : Sequence(String) ; input := sc.getCurrent()->characters() ;
        var i : int ; i := 0 ; while i < decks do ( (     if (input[i+1] = 'M') then (     deck[i+1] := 0 ) else     if (input[i+1] = 'S') then (     deck[i+1] := 1 ) else     if (input[i+1] = 'L') then (     deck[i+1] := 2 ) else skip ; ;  )  ;     i := i + 1 ) ; 
    var field : int ; field := 0 ;
    var player : Sequence(int) ; player := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < decks do ( (     var play : int ; play := i mod N ;
     if (deck[i+1] = 0) then (     player[play+1] := player[play+1] + 1 ) else     if (deck[i+1] = 1) then (     field := field+(player[play+1] + 1) ; 
     player[play+1] := 0 ) else     if (deck[i+1] = 2) then (     player[play+1] := player[play+1]+(field + 1) ; 
     field := 0 ) else skip ; ;  )  ;     i := i + 1 ) ; 
    player := player->sort() ; 
        var i : int ; i := 0 ; while i < N do ( (     if (i /= 0) then (     OclFile["System.out"].print(" ") ) else skip ; 
     OclFile["System.out"].print(player[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(" " + field) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem1481B {
  public static Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    int tc=scanner.nextInt();
    while(tc-->0){
      int size=scanner.nextInt();
      int k=scanner.nextInt();
      int[] array=new int[size];
      for(int i=0 ; i<array.length ; i++){
        array[i]=scanner.nextInt();
      }
      int ans=-1 ;
      while(k-->0){
        ans=-1 ;
        for(int i=0 ; i<array.length-1 ; i++){
          if(array[i]<array[i+1]){
            ans=i ;
            break ;
          }
        }
        if(ans==-1){
          break ;
        }
        array[ans]++;
      }
      if(ans==-1){
        System.out.println(-1);
      }
      else {
        System.out.println(ans+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem1481B {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var tc : int ; tc := scanner.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var size : int ; size := scanner.getCurrent()->toInteger() ;
     var k : int ; k := scanner.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < array->size() do ( (     array[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -1 ;
        while (k > 0) do (        k := k - 1 ;     skip ; (     ans := -1 ; 
         var i : int ; i := 0 ; while i < array->size() - 1 do ( (     if (array[i+1] < array[i + 1+1]) then (     ans := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (ans = -1) then (     break ) else skip ; 
     array[ans+1] := array[ans+1] + 1 ) ;  ) ;  
    if (ans = -1) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(ans + 1) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws java.io.IOException {
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    String t[]=new String[100];
    while(n!=0){
      String M=scan.next();
      for(int i=0 ; i<100 ; i++){
        t[i]=String.valueOf(M.charAt(i));
      }
      int k[]=new int[n];
      int S=0 ;
      int cou=0 ;
      for(int i=0 ; i<100 ; i++){
        for(int j=0 ; j<n ; j++){
          if(cou==j){
            if(t[i] .equals("M")){
++k[j];
            }
            else if(t[i] .equals("S")){
              S=S+k[j]+1 ;
              k[j]=0 ;
            }
            else {
              k[j]=k[j]+1+S ;
              S=0 ;
            }
            if(cou==n-1){
              cou=0 ;
            }
            else {
++cou ;
            }
            break ;
          }
        }
      }
      int T=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=i+1 ; j<n ; j++){
          if(k[i]>k[j]){
            T=k[i];
            k[i]=k[j];
            k[j]=T ;
          }
        }
      }
      for(int i=0 ; i<n ; i++){
        System.out.print(k[i]+" ");
      }
      System.out.println(S);
      n=scan.nextInt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
     var t : Sequence(String) ; t := Integer.subrange(1,100)->collect(null) ;
     while (n /= 0) do (     var M : String ; M := scan.getCurrent() ;
         var i : int ; i := 0 ; while i < 100 do ( (     t[i+1] := ((M->at(i+1)) + "") )  ;     i := i + 1 ) ; 
    var k : Sequence(int) ; k := Integer.subrange(1,n)->collect(0) ;
    var S : int ; S := 0 ;
    var cou : int ; cou := 0 ;
        var i : int ; i := 0 ; while i < 100 do ( (         var j : int ; j := 0 ; while j < n do ( (     if (cou = j) then (     if (t[i+1] = "M") then (     k[j+1] := k[j+1] + 1 ) else     if (t[i+1] = "S") then (     S := S + k[j+1] + 1 ; 
     k[j+1] := 0 ) else (     k[j+1] := k[j+1] + 1 + S ; 
     S := 0 ) ;  ;  
     if (cou = n - 1) then (     cou := 0 ) else (     cou := cou + 1 ) ;  
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var T : int ; T := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (k[i+1] > k[j+1]) then (     T := k[i+1] ; 
     k[i+1] := k[j+1] ; 
     k[j+1] := T ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(k[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(S) ; 
    n := scan.getCurrent()->toInteger() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class CodeForces {
  static long[] a ;
  static int n ;
  static long h ;
  public static void main(String[] args)throws FileNotFoundException {
    FastScanner fs=new FastScanner();
    int a=fs.nextInt(),b=fs.nextInt();
    System.out.println(Math.max(a,b)-1+" "+Math.min(a,b));
  }
  static void sort(int[] a){
    ArrayList<Integer>l=new ArrayList<>();
    for(int i : a)l.add(i);
    Collections.sort(l);
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   attribute a : Sequence(long);
  static   attribute n : int;
  static   attribute h : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var a : int ; a := fs.nextInt() ;
    var b : int ; b := fs.nextInt() ;
     OclFile["System.out"].println(Set{a, b}->max() - 1 + " " + Set{a, b}->min()) );
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l := l->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    B solver=new B();
    solver.solve(1,in,out);
    out.close();
  }
  static class B {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=Integer.parseInt(in.next());
      String S=in.next();
      int x=0 ;
      int ans=0 ;
      for(int i=0 ; i<n ; i++){
        if(S.charAt(i)=='I'){
          x++;
        }
        else {
          x--;
        }
        ans=Math.max(ans,x);
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : B ; solver := B.newB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class B {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (in.getCurrent())->toInteger() ;
     var S : String ; S := in.getCurrent() ;
    var x : int ; x := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (S->at(i+1) = 'I') then (     x := x + 1 ) else (     x := x - 1 ) ;  
     ans := Set{ans, x}->max() )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PlayingCubes {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    if(scanner.hasNext()){
      int x=scanner.nextInt();
      int y=scanner.nextInt();
      System.out.println(((x+y)-Math.min(x,y)-1)+" "+Math.min(x,y));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PlayingCubes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     if (scanner.hasNext()) then (     var x : int ; x := scanner.getCurrent()->toInteger() ;
     var y : int ; y := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(((x + y) - Set{x, y}->min() - 1) + " " + Set{x, y}->min()) ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      while(true){
        int n=Integer.parseInt(sc.nextLine());
        if(n==0)break ;
        int[] kouho=new int[26];
        int[] sokuhou=new int[26];
        String[] vote=new String[n];
        for(int i=0 ; i<26 ; i++){
          kouho[i]=0 ;
        }
        vote=sc.nextLine().split(" ");
        boolean flag=true ;
        loop : for(int i=1 ;
        i<=n ;
        i++){
          int d=vote[i-1] .charAt(0)-'A' ;
          kouho[d]+=1 ;
          for(int j=0 ; j<26 ; j++){
            sokuhou[j]=kouho[j];
          }
          Arrays.sort(sokuhou);
          if(sokuhou[24]+(n-i)<sokuhou[25]){
            int k=0 ;
            for(k=0 ; k<26 ; k++){
              if(kouho[k]==sokuhou[25])break ;
            }
            System.out.printf("%c %d",k+'A',i);
            System.out.println();
            flag=false ;
            break loop ;
          }
        }
        if(flag)System.out.println("TIE");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (true) do (     var n : int ; n := (sc.nextLine())->toInteger() ;
     if (n = 0) then     break else skip ; 
    var kouho : Sequence(int) ; kouho := Integer.subrange(1,26)->collect(0) ;
    var sokuhou : Sequence(int) ; sokuhou := Integer.subrange(1,26)->collect(0) ;
    var vote : Sequence(String) ; vote := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < 26 do ( (     kouho[i+1] := 0 )  ;     i := i + 1 ) ; 
    vote := sc.nextLine()->split(" ") ; 
    var flag : boolean ; flag := true ;
        var i : int ; i := 1 ; while i <= n do ( (     var d : int ; d := vote[i - 1+1]->at(0+1) - ('A')->char2byte() ;
     kouho[d+1] := kouho[d+1]+(1) ; 
        var j : int ; j := 0 ; while j < 26 do ( (     sokuhou[j+1] := kouho[j+1] )  ;     j := j + 1 ) ; 
    sokuhou := sokuhou->sort() ; 
    if (sokuhou[24+1] + (n - i) < sokuhou[25+1]) then (     var k : int ; k := 0 ;
         k := 0 ; while k < 26 do ( (     if (kouho[k+1] = sokuhou[25+1]) then     break else skip )  ;     k := k + 1 ) ; 
    OclFile["System.out"].printf("%c %d", k + 'A', i) ; 
    OclFile["System.out"].println() ; 
    flag := false ; 
    break 
 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (flag) then     OclFile["System.out"].println("TIE") ; else skip ; 
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static boolean solve(){
    int n=in.nextInt();
    if(n==0)return false ;
    int[] cnt=new int[26];
    boolean f=false ;
    for(int i=0 ; i<n ; i++){
      int p=in.next().charAt(0)-'A' ;
      cnt[p]++;
      int[] tmp=Arrays.copyOfRange(cnt,0,26);
      Arrays.sort(tmp);
      if(! f && tmp[24]+n-i-1<tmp[25]){
        int idx=-1 ;
        for(int j=0 ; j<26 ; j++){
          if(tmp[25]==cnt[j])idx=j ;
        }
        out.println((char)(idx+'A')+" "+(i+1));
        f=true ;
      }
    }
    if(! f)out.println("TIE");
    return true ;
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    while(solve());
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return false else skip ; 
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,26)->collect(0) ;
    var f : boolean ; f := false ;
        var i : int ; i := 0 ; while i < n do ( (     var p : int ; p := in.getCurrent()->at(0+1) - ('A')->char2byte() ;
     cnt[p+1] := cnt[p+1] + 1 ; 
    var tmp : Sequence(int) ; tmp := cnt.subrange(0+1,26) ;
    tmp := tmp->sort() ; 
    if (not(f) & tmp[24+1] + n - i - 1 < tmp[25+1]) then (     var idx : int ; idx := -1 ;
         var j : int ; j := 0 ; while j < 26 do ( (     if (tmp[25+1] = cnt[j+1]) then     idx := j ; else skip )  ;     j := j + 1 ) ; 
     skip ; 
     f := true ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (not(f)) then     skip ; else skip ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    while (solve()) do  ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=parseInt(line);
      if(n==0)break ;
      line=br.readLine();
      Candidate[] idx=new Candidate['Z'-'A'+1];
      List<Candidate>list=new ArrayList<>();
      list.add(new Candidate('\0'));
      Candidate c=null ;
      int d=-1 ;
      for(int i=0,j=1 ; i<line.length(); i+=2,j++){
        int _c=line.charAt(i)-'A' ;
        if(idx[_c]==null){
          idx[_c]=new Candidate((char)(_c+'A'));
          list.add(idx[_c]);
        }
        idx[_c] .vote++;
        Collections.sort(list,new Comparator<Candidate>(){
          @ Override public int compare(Candidate o1,Candidate o2){
            return Integer.compare(o2.vote,o1.vote);
          }
        }
);
        if(list.get(0).vote>list.get(1).vote+n-j){
          c=list.get(0);
          d=j ;
          break ;
        }
      }
      if(c!=null){
        System.out.printf("%c %d%n",c.name,d);
      }
      else {
        System.out.println("TIE");
      }
    }
  }
}
class Candidate {
  char name ;
  int vote=0 ;
  Candidate(char name){
    this.name=name ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := parseInt(line) ;
     if (n = 0) then     break else skip ; 
    line := br.readLine() ; 
    var idx : Sequence(Candidate) ; idx := Integer.subrange(1,('Z')->char2byte() - ('A')->char2byte() + 1)->collect(null) ;
    var list : Sequence(Candidate) ; list := Sequence{} ;
    list := list->including(Candidate.newCandidate('\0')) ; 
    var c : Candidate ; c := null ;
    var d : int ; d := -1 ;
        var i : int ; i := 0 ;
    var j : int ; j := 1 ; while i < line->size() do ( (     var _c : int ; _c := line->at(i+1) - ('A')->char2byte() ;
     if (idx[_c+1] = null) then (     idx[_c+1] := Candidate.newCandidate((_c + 'A')->oclAsType(String)) ; 
     list := list->including(idx[_c+1]) ) else skip ; 
    idx[_c+1].vote := idx[_c+1].vote + 1 ; 
    list, OclComparator<Candidate>.newOclComparator() := list, OclComparator<Candidate>.newOclComparator()->sort() ; 
    if (list->at(0+1).vote > list->at(1+1).vote + n - j) then (     c := list->at(0+1) ; 
     d := j ; 
     break ) else skip ; 
 )  ;     i := i+(2) ;     j := j + 1 ) ; 
    if (c /= null) then (     OclFile["System.out"].printf("%c %d%n", c.name, d) ) else (     OclFile["System.out"].println("TIE") ) ;  
 ) ;     line := br.readLine() ;
 ) );
}
class Candidate {
   attribute name : String;
   attribute vote : int := 0;
   static operation newCandidate( name : String) : Candidate
  pre: true
  post: true
  activity:
  ( var self : Candidate ;
    self := createCandidate();
    self.initialise(name);
    return self );
  operation initialise( name : String) : void
  pre: true  post: true
  activity: (     self.name := name );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public void run(){
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      calc(n);
    }
  }
  public void calc(int n){
    String firs="" ;
    String secs="" ;
    int firn=0 ;
    int secn=0 ;
    int d=0 ;
    HashMap<String,Integer>map=new HashMap<String,Integer>();
    for(int i=0 ; i<n ; i++){
      String c=sc.next();
      d+=1 ;
      int cn=1 ;
      if(map.containsKey(c)){
        cn=map.get(c)+1 ;
      }
      map.put(c,cn);
      if(cn>firn){
        if(!(firs.equals(c))){
          secs=firs ;
          secn=firn ;
        }
        firs=c ;
        firn=cn ;
      }
      else if(cn>secn){
        secs=c ;
        secn=cn ;
      }
      if(secn+n-d<firn){
        break ;
      }
    }
    if(firn==secn){
      System.out.println("TIE");
    }
    else {
      System.out.print(firs);
      System.out.print(" ");
      System.out.println(d);
    }
    for(int i=d ; i<n ; i++){
      sc.next();
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
     execute calc(n) ) );
   operation calc( n : int) : void
  pre: true
  post: true
  activity: (     var firs : String ; firs := "" ;
     var secs : String ; secs := "" ;
    var firn : int ; firn := 0 ;
    var secn : int ; secn := 0 ;
    var d : int ; d := 0 ;
    var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var c : String ; c := sc.getCurrent() ;
     d := d+(1) ; 
    var cn : int ; cn := 1 ;
    if (map->keys()->includes(c)) then (     cn := map->at(c) + 1 ) else skip ; 
    map := map->union(Map{c |-> cn}) ; 
    if (cn > firn) then (     if (not((firs = c))) then (     secs := firs ; 
     secn := firn ) else skip ; 
     firs := c ; 
     firn := cn ) else     if (cn > secn) then (     secs := c ; 
     secn := cn ) else skip ; ;  
    if (secn + n - d < firn) then (     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (firn = secn) then (     OclFile["System.out"].println("TIE") ) else (     OclFile["System.out"].print(firs) ; 
     OclFile["System.out"].print(" ") ; 
     OclFile["System.out"].println(d) ) ;  
        var i : int ; i := d ; while i < n do ( (     skip )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map.Entry ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  static final Scanner s=new Scanner(System.in);
  static int getInt(){
    return Integer.parseInt(s.next());
  }
  static IntStream REPS(int l){
    return IntStream.range(0,l);
  }
  public static void main(String[] __){
    HashMap<Character,Integer>hm=new HashMap<>(26);
    while(true){
      hm.clear();
      boolean f=false ;
      int n=getInt();
      if(n==0)return ;
      for(int i=n-1 ; i>=0 ; i--){
        if(! f){
          hm.merge(s.next().charAt(0),1,Integer :: sum);
          List<Entry<Character,Integer>>hoge=hm.entrySet().stream().sorted(Entry.comparingByValue(Comparator.reverseOrder())).limit(2).collect(Collectors.toList());
          Entry<Character,Integer>e=hoge.get(0);
          if((hoge.size()==1 && e.getValue()>i)||(hoge.size()>1 && e.getValue()>hoge.get(1).getValue()+i)){
            System.out.println(e.getKey()+" "+(n-i));
            f=true ;
          }
        }
        else {
          s.next();
        }
      }
      if(! f){
        System.out.println("TIE");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation REPS( l : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, l-1) );
  static   operation main( __ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var hm : Map(String,int) ; hm := Map{} ;
     while (true) do (     hm := hm->intersection(Map{}) ; 
     var f : boolean ; f := false ;
    var n : int ; n := getInt() ;
    if (n = 0) then     return else skip ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (not(f)) then (     hm := hm.merge(s.getCurrent()->at(0+1), 1, lambda _pars : OclAny in Integer.newInteger().sum(_pars)) ; 
     var hoge : Sequence(Entry<String,int>) ; hoge := hm->asSet()->sort().subrange(1,2).collect(Collectors.toList()) ;
     var e : Entry<String,int> ; e := hoge->at(0+1) ;
     if ((hoge->size() = 1 & e.getValue() > i) or (hoge->size() > 1 & e.getValue() > hoge->at(1+1).getValue() + i)) then (     OclFile["System.out"].println(e.getKey() + " " + (n - i)) ; 
     f := true ) else skip ) else (     skip ) )  ;     i := i - 1 ) ; 
    if (not(f)) then (     OclFile["System.out"].println("TIE") ) else skip ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static Reader rd=new Reader();
  public static void main(String[] args){
    int tt=rd.nextInt();
    while(tt-->0){
      new Solution().solve();
    }
  }
  static class Solution {
    void solve(){
      int n=rd.nextInt(),b=rd.nextInt(),x=rd.nextInt(),y=rd.nextInt();
      int[] a=new int[n+1];
      a[0]=0 ;
      long sum=0 ;
      for(int i=1 ; i<=n ; i++){
        if(a[i-1]+x<=b){
          a[i]=a[i-1]+x ;
        }
        else {
          a[i]=a[i-1]-y ;
        }
        sum+=a[i];
      }
      System.out.println(sum);
    }
  }
  static class Reader {
    private BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    private StringTokenizer tokenizer=new StringTokenizer("");
    private String innerNextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException ex){
        throw new RuntimeException(ex);
      }
    }
    public boolean hasNext(){
      while(! tokenizer.hasMoreTokens()){
        String nextLine=innerNextLine();
        if(nextLine==null){
          return false ;
        }
        tokenizer=new StringTokenizer(nextLine);
      }
      return true ;
    }
    public String nextLine(){
      tokenizer=new StringTokenizer("");
      return innerNextLine();
    }
    public String next(){
      hasNext();
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.valueOf(next());
    }
    public long nextLong(){
      return Long.valueOf(next());
    }
    public double nextDouble(){
      return Double.valueOf(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute rd : OclFile := OclFile();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var tt : int ; tt := rd.getCurrent()->toInteger() ;
         while (tt > 0) do (        tt := tt - 1 ;     skip ; (     Solution.newSolution().solve() ) ;  ) );
  static class Solution {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := rd.getCurrent()->toInteger() ;
    var b : int ; b := rd.getCurrent()->toInteger() ;
    var x : int ; x := rd.getCurrent()->toInteger() ;
    var y : int ; y := rd.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    a[0+1] := 0 ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (a[i - 1+1] + x <= b) then (     a[i+1] := a[i - 1+1] + x ) else (     a[i+1] := a[i - 1+1] - y ) ;  
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}
  static class Reader {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute tokenizer : OclIterator := OclIterator.newOclIterator_String("");
   operation innerNextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (ex : IOException) do (     error ProgramException(ex) )
 );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     var nextLine : String ; nextLine := innerNextLine() ;
     if (nextLine = null) then (     return false ) else skip ; 
     tokenizer := OclIterator.newOclIterator_String(nextLine) ) ; 
     return true );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     tokenizer := OclIterator.newOclIterator_String("") ; 
     return innerNextLine() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute hasNext() ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String args[])throws java.lang.Exception {
    FastScanner input=new FastScanner();
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      long b=input.nextLong();
      long x=input.nextLong();
      long y=input.nextLong();
      long a[]=new long[n];
      long ans=0 ;
      long now=0 ;
      for(int i=0 ; i<n ; i++){
        if(now+x<=b){
          now+=x ;
        }
        else {
          now-=y ;
        }
        ans+=now ;
      }
      System.out.println(ans);
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var tc : int ; tc := input.nextInt() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.nextInt() ;
     var b : long ; b := input.nextLong() ;
    var x : long ; x := input.nextLong() ;
    var y : long ; y := input.nextLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var ans : long ; ans := 0 ;
    var now : long ; now := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (now + x <= b) then (     now := now+(x) ) else (     now := now-(y) ) ;  
     ans := ans+(now) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) ;  );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minOperations(int A,int B){
    if(A>B){
      A=A+B ;
      B=A-B ;
      A=A-B ;
    }
    B=B/__gcd(A,B);
    return B-1 ;
  }
  static int __gcd(int a,int b){
    return b==0 ? a : __gcd(b,a % b);
  }
  public static void main(String[] args){
    int A=7,B=15 ;
    System.out.print(minOperations(A,B)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minOperations( A : int, B : int) : int
  pre: true
  post: true
  activity: (     if (A > B) then (     A := A + B ; 
     B := A - B ; 
     A := A - B ) else skip ; 
     B := B / __gcd(A, B) ; 
     return B - 1 );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else __gcd(b, a mod b) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 7 ;
    var B : int ; B := 15 ;
     OclFile["System.out"].print(minOperations(A, B) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  public static void main(String...args){
    Scanner sc=new Scanner(System.in);
    int tt=sc.nextInt();
    int n,B,x,y ;
    while((tt--)>0){
      BigInteger ans=new BigInteger("0");
      long an=0 ;
      n=sc.nextInt();
      B=sc.nextInt();
      x=sc.nextInt();
      y=sc.nextInt();
      int[] a=new int[n+1];
      a[0]=0 ;
      for(int i=1 ; i<n+1 ; i++){
        a[i]+=(((a[i-1]+x)>B)?(a[i-1]-y):(a[i-1]+x));
      }
      for(int i=1 ; i<n+1 ; i++){
        an+=a[i];
      }
      System.out.println(an);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tt : int ; tt := sc.getCurrent()->toInteger() ;
     var n : int ;
    var B : int ;
    var x : int ;
    var y : int ;
         while ((tt) > 0) do (        skip ;     skip ; (     var ans : long ; ans := long("0") ;
     var an : long ; an := 0 ;
    n := sc.getCurrent()->toInteger() ; 
    B := sc.getCurrent()->toInteger() ; 
    x := sc.getCurrent()->toInteger() ; 
    y := sc.getCurrent()->toInteger() ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    a[0+1] := 0 ; 
        var i : int ; i := 1 ; while i < n + 1 do ( (     a[i+1] := a[i+1]+((if ((a[i - 1+1] + x) > B) then (a[i - 1+1] - y) else (a[i - 1+1] + x) endif)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n + 1 do ( (     an := an+(a[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(an) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int ans=0 ;
      int n=sc.nextInt(),m=sc.nextInt();
      ArrayList<State>al=new ArrayList<State>();
      if(n==0 && m==0)break ;
      for(int i=0 ; i<n ; i++)al.add(new State(sc.nextInt(),sc.nextInt()));
      Collections.sort(al);
      while(! al.isEmpty()){
        State st=al.remove(0);
        m-=st.d ;
        if(m<=0){
          ans-=m*st.p ;
          break ;
        }
      }
      while(! al.isEmpty()){
        State st=al.remove(0);
        ans+=st.d*st.p ;
      }
      System.out.println(ans);
    }
  }
}
class State implements Comparable<State>{
  int d,p ;
  public State(int d,int p){
    this.d=d ;
    this.p=p ;
  }
  public int compareTo(State st){
    return st.p-this.p ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var ans : int ; ans := 0 ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var al : Sequence(State) ; al := Sequence{} ;
    if (n = 0 & m = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < n do (     al := al->including(State.newState(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) ;  ;     i := i + 1 ) ; 
    al := al->sort() ; 
    while (not(al->isEmpty())) do (     var st : State ; st := al->at(0+1) ;
     m := m-(st.d) ; 
     if (m <= 0) then (     ans := ans-(m * st.p) ; 
     break ) else skip ) ; 
    while (not(al->isEmpty())) do (     var st : State ; st := al->at(0+1) ;
     ans := ans+(st.d * st.p) ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}
class State implements Comparable<State> {
   attribute d : int;
   static operation newState( d : int, p : int) : State
  pre: true
  post: true
  activity:
  ( var self : State ;
    self := createState();
    self.initialise(d, p);
    return self );
  operation initialise( d : int, p : int) : void
  pre: true  post: true
  activity: (     self.d := d ; 
     self.p := p );
   operation compareTo( st : State) : int
  pre: true
  post: true
  activity: (     return st.p - self.p );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1657 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      int B=in.nextInt();
      int X=in.nextInt();
      int Y=in.nextInt();
      int a=0 ;
      long sum=0 ;
      for(int n=1 ; n<=N ; n++){
        int nextA=a+X ;
        if(nextA>B){
          nextA=a-Y ;
        }
        sum+=nextA ;
        a=nextA ;
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1657 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var B : int ; B := in.getCurrent()->toInteger() ;
    var X : int ; X := in.getCurrent()->toInteger() ;
    var Y : int ; Y := in.getCurrent()->toInteger() ;
    var a : int ; a := 0 ;
    var sum : long ; sum := 0 ;
        var n : int ; n := 1 ; while n <= N do ( (     var nextA : int ; nextA := a + X ;
     if (nextA > B) then (     nextA := a - Y ) else skip ; 
     sum := sum+(nextA) ; 
     a := nextA )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
class GFG {
  static boolean getParity(int n){
    boolean parity=false ;
    while(n!=0){
      parity=! parity ;
      n=n &(n-1);
    }
    return parity ;
  }
  public static void main(String[] args){
    int n=12 ;
    System.out.println("Parity of no "+n+"="+(getParity(n)? "odd" : "even"));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getParity( n : int) : boolean
  pre: true
  post: true
  activity: (     var parity : boolean ; parity := false ;
     while (n /= 0) do (     parity := not(parity) ; 
     n := n & (n - 1) ) ; 
     return parity );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     OclFile["System.out"].println("Parity of no " + n + "=" + (if getParity(n) then "odd" else "even" endif)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean subArray(int[] arr,int n,int m){
    int i ;
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(i=0 ; i<n ; i++){
      mp.put(arr[i],i+1);
    }
    int sumcur=0 ;
    int p=Integer.MAX_VALUE ;
    Vector<Integer>ans=new Vector<Integer>();
    for(i=1 ; i<=m ; i++){
      sumcur+=mp.get(i);
      p=Math.min(p,mp.get(i));
      int val=p*i-i+(i*(i+1))/2 ;
      if(i==m){
        if(val==sumcur){
          return true ;
        }
        else return false ;
      }
    }
    return false ;
  }
  public static void main(String[] args){
    int arr[]={
      4,5,1,3,2,6 };
      int n=arr.length ;
      int m=3 ;
      if(subArray(arr,n,m))System.out.print("Yes");
      else System.out.print("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation subArray( arr : Sequence(int), n : int, m : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ;
     var mp : Map(int,int) ; mp := Map{} ;
        i := 0 ; while i < n do ( (     mp := mp->union(Map{arr[i+1] |-> i + 1}) )  ;     i := i + 1 ) ; 
    var sumcur : int ; sumcur := 0 ;
    var p : int ; p := 2147483647 ;
    var ans : Sequence(int) ; ans := Sequence{} ;
        i := 1 ; while i <= m do ( (     sumcur := sumcur+(mp->at(i)) ; 
     p := Set{p, mp->at(i)}->min() ; 
     var val : int ; val := p * i - i + (i * (i + 1)) / 2 ;
     if (i = m) then (     if (val = sumcur) then (     return true ) else     return false ) else skip )  ;     i := i + 1 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,5,1,3,2,6} ;
     var n : int ; n := arr->size() ;
     var m : int ; m := 3 ;
     if (subArray(arr, n, m)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Solution {
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line=br.readLine();
    int num=Integer.parseInt(line);
    Set<String>set=new HashSet<>();
    for(int i=0 ; i<num ; i++){
      line=br.readLine();
      if(! set.contains(line))set.add(line);
    }
    System.out.print(set.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := br.readLine() ;
    var num : int ; num := (line)->toInteger() ;
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := 0 ; while i < num do ( (     line := br.readLine() ; 
     if (not(set->includes(line))) then     set := set->including(line) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(set->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String k=sc.nextLine();
    HashSet<String>h=new HashSet<String>();
    for(int i=0 ; i<n ; ++i){
      String s=sc.nextLine();
      h.add(s);
    }
    System.out.println(h.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : String ; k := sc.nextLine() ;
    var h : Set(String) ; h := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.nextLine() ;
     h := h->including(s) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(h->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Set<String>set=new HashSet<String>();
    while(n-->=0){
      String s=sc.nextLine();
      set.add(s);
    }
    System.out.println(set.size()-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var set : Set(String) ; set := Set{} ;
        while (n >= 0) do (        n := n - 1 ;     skip ; (     var s : String ; s := sc.nextLine() ;
     set := set->including(s) ) ;  ) ;  
    OclFile["System.out"].println(set->size() - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class JavaApplication51 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Set<String>s=new HashSet<String>();
    for(int i=0 ; i<n+1 ; i++){
      s.add(sc.nextLine());
    }
    System.out.println(s.size()-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication51 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Set(String) ; s := Set{} ;
        var i : int ; i := 0 ; while i < n + 1 do ( (     s := s->including(sc.nextLine()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s->size() - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Solution {
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.valueOf(br.readLine());
    Set<String>uniqueLeaves=new HashSet<String>();
    while(n--!=0){
      uniqueLeaves.add(br.readLine().trim());
    }
    System.out.println(uniqueLeaves.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var uniqueLeaves : Set(String) ; uniqueLeaves := Set{} ;
        while (n /= 0) do (    skip ; (     uniqueLeaves := uniqueLeaves->including(br.readLine()->trim()) ) ;  ) ;  
    OclFile["System.out"].println(uniqueLeaves->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int NUMBER=998244353 ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    List<ABC179DTuple>tuples=new ArrayList<>(k);
    for(int i=0 ; i<k ; i++){
      int l=in.nextInt();
      int r=in.nextInt();
      ABC179DTuple tuple=new ABC179DTuple();
      tuple.l=l ;
      tuple.r=r ;
      tuples.add(tuple);
    }
    long[] table=new long[n+1];
    long[] upDown=new long[n+1];
    long up=0 ;
    table[1]=1 ;
    for(int i=1 ; i<=n ; i++){
      up+=upDown[i];
      table[i]+=up ;
      table[i]=table[i] % NUMBER ;
      for(int j=0 ; j<k ; j++){
        ABC179DTuple tuple=tuples.get(j);
        if(i+tuple.l<=n){
          upDown[i+tuple.l]+=table[i];
        }
        if(i+tuple.r+1<=n){
          upDown[i+tuple.r+1]-=table[i];
        }
      }
    }
    System.out.println(table[n]);
  }
}
class ABC179DTuple {
  int l ;
  int r ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute NUMBER : int := 998244353;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var tuples : Sequence(ABC179DTuple) ; tuples := Sequence{} ;
        var i : int ; i := 0 ; while i < k do ( (     var l : int ; l := in.getCurrent()->toInteger() ;
     var r : int ; r := in.getCurrent()->toInteger() ;
    var tuple : ABC179DTuple ; tuple := ABC179DTuple.newABC179DTuple() ;
    tuple.l := l ; 
    tuple.r := r ; 
    tuples := tuples->including(tuple) ; 
 )  ;     i := i + 1 ) ; 
    var table : Sequence(long) ; table := Integer.subrange(1,n + 1)->collect(0) ;
    var upDown : Sequence(long) ; upDown := Integer.subrange(1,n + 1)->collect(0) ;
    var up : long ; up := 0 ;
    table[1+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do ( (     up := up+(upDown[i+1]) ; 
     table[i+1] := table[i+1]+(up) ; 
     table[i+1] := table[i+1] mod NUMBER ; 
         var j : int ; j := 0 ; while j < k do ( (     var tuple : ABC179DTuple ; tuple := tuples->at(j+1) ;
     if (i + tuple.l <= n) then (     upDown[i + tuple.l+1] := upDown[i + tuple.l+1]+(table[i+1]) ) else skip ; 
     if (i + tuple.r + 1 <= n) then (     upDown[i + tuple.r + 1+1] := upDown[i + tuple.r + 1+1]-(table[i+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(table[n+1]) ; 
 );
}
class ABC179DTuple {
   attribute l : int;
   attribute r : int;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
public final class p026 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p026().run());
  }
  public String run(){
    int bestNumber=0 ;
    int bestLength=0 ;
    for(int i=1 ; i<=1000 ; i++){
      int len=getCycleLength(i);
      if(len>bestLength){
        bestNumber=i ;
        bestLength=len ;
      }
    }
    return Integer.toString(bestNumber);
  }
  private static int getCycleLength(int n){
    Map<Integer,Integer>stateToIter=new HashMap<>();
    int state=1 ;
    for(int iter=0 ; ; iter++){
      if(stateToIter.containsKey(state))return iter-stateToIter.get(state);
      else {
        stateToIter.put(state,iter);
        state=state*10 % n ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class p026 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p026.newp026().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var bestNumber : int ; bestNumber := 0 ;
     var bestLength : int ; bestLength := 0 ;
         var i : int ; i := 1 ; while i <= 1000 do ( (     var len : int ; len := getCycleLength(i) ;
     if (len > bestLength) then (     bestNumber := i ; 
     bestLength := len ) else skip )  ;     i := i + 1 ) ; 
     return ((bestNumber) + "") );
  static   operation getCycleLength( n : int) : int
  pre: true
  post: true
  activity: (     var stateToIter : Map(int,int) ; stateToIter := Map{} ;
     var state : int ; state := 1 ;
         var iter : int ; iter := 0 ; while true do ( (     if (stateToIter->keys()->includes(state)) then     return iter - stateToIter->at(state) else (     stateToIter := stateToIter->union(Map{state |-> iter}) ; 
     state := state * 10 mod n ) )  ;     iter := iter + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
public class Main {
  public static int solution(int n,int m,int[] children){
    ArrayList<Integer>last=new ArrayList<>();
    int count=0 ;
    int pointer=0 ;
    for(int i=0 ; i<n ; i++){
      if(children[i]<=m)count++;
      else {
        children[i]=children[i]-m ;
        last.add(i);
      }
    }
    while(count!=n){
      int size=last.size();
      for(int j=pointer ; j<size ; j++){
        if(children[last.get(j)]<=m)count++;
        else {
          children[last.get(j)]=children[last.get(j)]-m ;
          last.add(last.get(j));
        }
      }
      pointer=size ;
    }
    if(last.size()==0)return n ;
    else return last.get(last.size()-1)+1 ;
  }
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int m=input.nextInt();
    int[] children=new int[n];
    for(int i=0 ; i<n ; i++){
      children[i]=input.nextInt();
    }
    System.out.println(solution(n,m,children));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solution( n : int, m : int, children : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var last : Sequence(int) ; last := Sequence{} ;
     var count : int ; count := 0 ;
    var pointer : int ; pointer := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (children[i+1] <= m) then     count := count + 1 ; else (     children[i+1] := children[i+1] - m ; 
     last := last->including(i) ) )  ;     i := i + 1 ) ; 
    while (count /= n) do (     var size : int ; size := last->size() ;
         var j : int ; j := pointer ; while j < size do ( (     if (children[last->at(j+1)+1] <= m) then     count := count + 1 ; else (     children[last->at(j+1)+1] := children[last->at(j+1)+1] - m ; 
     last := last->including(last->at(j+1)) ) )  ;     j := j + 1 ) ; 
     pointer := size ) ; 
    if (last->size() = 0) then     return n else     return last->at(last->size() - 1+1) + 1 ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var m : int ; m := input.getCurrent()->toInteger() ;
    var children : Sequence(int) ; children := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     children[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solution(n, m, children)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void rearrange(int arr[],int n){
    int j=0,temp ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]<0){
        if(i!=j){
          temp=arr[i];
          arr[i]=arr[j];
          arr[j]=temp ;
        }
        j++;
      }
    }
  }
  static void printArray(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String args[]){
    int arr[]={
-1,2,-3,4,5,6,-7,8,9 };
      int n=arr.length ;
      rearrange(arr,n);
      printArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation rearrange( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var j : int ; j := 0 ;
    var temp : int ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] < 0) then (     if (i /= j) then (     temp := arr[i+1] ; 
     arr[i+1] := arr[j+1] ; 
     arr[j+1] := temp ) else skip ; 
     j := j + 1 ) else skip )  ;     i := i + 1 ) );
  static   operation printArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-1,2,-3,4,5,6,-7,8,9} ;
     var n : int ; n := arr->size() ;
     execute rearrange(arr, n) ; 
     execute printArray(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int MOD=998244353 ;
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] left=new int[k];
    int[] right=new int[k];
    for(int i=0 ; i<k ; i++){
      left[i]=sc.nextInt();
      right[i]=sc.nextInt();
    }
    int[] dp=new int[n+1];
    dp[1]=1 ;
    int[] sdp=new int[n+2];
    sdp[2]=sdp[1]+dp[1];
    for(int i=2 ; i<=n ; i++){
      for(int j=0 ; j<k ; j++){
        int l=left[j];
        int r=right[j];
        int L=i-r ;
        int R=i-l ;
        if(L-1<0)L=1 ;
        if(R<0)R=0 ;
        int sum_LR=sdp[R+1]-sdp[L];
        if(sum_LR<0)sum_LR+=MOD ;
        dp[i]+=sum_LR ;
        dp[i] %=MOD ;
      }
      sdp[i+1]=sdp[i]+dp[i];
      sdp[i+1] %=MOD ;
    }
    System.out.println(dp[n]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : int := 998244353;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var left : Sequence(int) ; left := Integer.subrange(1,k)->collect(0) ;
    var right : Sequence(int) ; right := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     left[i+1] := sc.getCurrent()->toInteger() ; 
     right[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
    dp[1+1] := 1 ; 
    var sdp : Sequence(int) ; sdp := Integer.subrange(1,n + 2)->collect(0) ;
    sdp[2+1] := sdp[1+1] + dp[1+1] ; 
        var i : int ; i := 2 ; while i <= n do ( (         var j : int ; j := 0 ; while j < k do ( (     var l : int ; l := left[j+1] ;
     var r : int ; r := right[j+1] ;
    var L : int ; L := i - r ;
    var R : int ; R := i - l ;
    if (L - 1 < 0) then     L := 1 ; else skip ; 
    if (R < 0) then     R := 0 ; else skip ; 
    var sum_LR : int ; sum_LR := sdp[R + 1+1] - sdp[L+1] ;
    if (sum_LR < 0) then     sum_LR := sum_LR+(MOD) ; else skip ; 
    dp[i+1] := dp[i+1]+(sum_LR) ; 
    dp[i+1] := dp[i+1] mod MOD ; 
 )  ;     j := j + 1 ) ; 
     sdp[i + 1+1] := sdp[i+1] + dp[i+1] ; 
     sdp[i + 1+1] := sdp[i + 1+1] mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[n+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int mod=998244353 ;
    int[] l=new int[k];
    int[] r=new int[k];
    long[] sum=new long[k];
    for(int i=0 ; i<k ; i++){
      l[i]=sc.nextInt();
      r[i]=sc.nextInt();
    }
    long[] dp=new long[n*2];
    dp[1]=1 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=0 ; j<k ; j++){
        int ra=Math.min(n,i-l[j]);
        ra=Math.max(0,ra);
        int la=Math.max(0,i-r[j]);
        la=Math.min(n,la);
        sum[j]+=dp[ra];
        dp[i]+=sum[j];
        sum[j]-=dp[la];
      }
      dp[i] %=mod ;
    }
    System.out.println(dp[n]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var mod : int ; mod := 998244353 ;
    var l : Sequence(int) ; l := Integer.subrange(1,k)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,k)->collect(0) ;
    var sum : Sequence(long) ; sum := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     l[i+1] := sc.getCurrent()->toInteger() ; 
     r[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(long) ; dp := Integer.subrange(1,n * 2)->collect(0) ;
    dp[1+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 0 ; while j < k do ( (     var ra : int ; ra := Set{n, i - l[j+1]}->min() ;
     ra := Set{0, ra}->max() ; 
    var la : int ; la := Set{0, i - r[j+1]}->max() ;
    la := Set{n, la}->min() ; 
    sum[j+1] := sum[j+1]+(dp[ra+1]) ; 
    dp[i+1] := dp[i+1]+(sum[j+1]) ; 
    sum[j+1] := sum[j+1]-(dp[la+1]) ; 
 )  ;     j := j + 1 ) ; 
     dp[i+1] := dp[i+1] mod mod )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[n+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Solution {
  static String OctToBin(String octnum){
    long i=0 ;
    String binary="" ;
    while(i<octnum.length()){
      char c=octnum.charAt((int)i);
      switch(c){
        case '0' : binary+="000" ;
        break ;
        case '1' : binary+="001" ;
        break ;
        case '2' : binary+="010" ;
        break ;
        case '3' : binary+="011" ;
        break ;
        case '4' : binary+="100" ;
        break ;
        case '5' : binary+="101" ;
        break ;
        case '6' : binary+="110" ;
        break ;
        case '7' : binary+="111" ;
        break ;
        default : System.out.println("\nInvalid Octal Digit "+octnum.charAt((int)i));
        break ;
      }
      i++;
    }
    return binary ;
  }
  public static void main(String args[]){
    String octnum="345" ;
    System.out.println("Equivalent Binary Value="+OctToBin(octnum));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation OctToBin( octnum : String) : String
  pre: true
  post: true
  activity: (     var i : long ; i := 0 ;
     var binary : String ; binary := "" ;
     while (i < octnum->size()) do (     var c : String ; c := octnum->at(i->oclAsType(int)+1) ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
       if _switchval = '0' then
     binary := binary+("000") ; 
    break 
   else skip ;
       if _switchval = '1' then
     binary := binary+("001") ; 
    break 
   else skip ;
       if _switchval = '2' then
     binary := binary+("010") ; 
    break 
   else skip ;
       if _switchval = '3' then
     binary := binary+("011") ; 
    break 
   else skip ;
       if _switchval = '4' then
     binary := binary+("100") ; 
    break 
   else skip ;
       if _switchval = '5' then
     binary := binary+("101") ; 
    break 
   else skip ;
       if _switchval = '6' then
     binary := binary+("110") ; 
    break 
   else skip ;
       if _switchval = '7' then
     binary := binary+("111") ; 
    break 
   else skip ;
       if true then
     OclFile["System.out"].println("\nInvalid Octal Digit " + octnum->at(i->oclAsType(int)+1)) ; 
    break 
   else skip ;
 )
     i := i + 1 ) ; 
     return binary );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var octnum : String ; octnum := "345" ;
     OclFile["System.out"].println("Equivalent Binary Value=" + OctToBin(octnum)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int ans ;
    while(true){
      String x=sc.nextLine();
      if(x.charAt(0)=='0')break ;
      ans=0 ;
      for(int i=0 ; i<x.length(); i++)ans+=x.charAt(i)-'0' ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ans : int ;
     while (true) do (     var x : String ; x := sc.nextLine() ;
     if (x->at(0+1) = '0') then     break else skip ; 
    ans := 0 ; 
        var i : int ; i := 0 ; while i < x->size() do (     ans := ans+(x->at(i+1) - ('0')->char2byte()) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String args[])throws IOException {
    int[] sum=new int[1000];
    String[] str=new String[1000];
    int max=0 ;
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    for(int i=0 ; ; i++){
      str[i]=input.readLine();
      if(Long.parseLong(""+str[i] .charAt(0)+"")==0){
        max=i ;
        break ;
      }
    }
    for(int j=0 ; j<max ; j++){
      for(int i=0 ; i<str[j] .length(); i++){
        sum[j]+=Long.parseLong(""+str[j] .charAt(i)+"");
      }
      System.out.print(""+sum[j]+"\n");
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sum : Sequence(int) ; sum := Integer.subrange(1,1000)->collect(0) ;
     var str : Sequence(String) ; str := Integer.subrange(1,1000)->collect(null) ;
    var max : int ; max := 0 ;
    var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
        var i : int ; i := 0 ; while true do ( (     str[i+1] := input.readLine() ; 
     if (("" + str[i+1]->at(0+1) + "")->toLong() = 0) then (     max := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < max do ( (         var i : int ; i := 0 ; while i < str[j+1]->size() do ( (     sum[j+1] := sum[j+1]+(("" + str[j+1]->at(i+1) + "")->toLong()) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("" + sum[j+1] + "\n") )  ;     j := j + 1 ) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args){
    int sum=0 ;
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      while(true){
        String line=reader.readLine();
        char a=line.charAt(0);
        if(a=='0'){
          break ;
        }
        for(int i=0 ; i<line.length(); i++){
          a=line.charAt(i);
          if(a-'0'==0){
          }
          else if(a-'1'==0){
            sum=sum+1 ;
          }
          else if(a-'2'==0){
            sum=sum+2 ;
          }
          else if(a-'3'==0){
            sum=sum+3 ;
          }
          else if(a-'4'==0){
            sum=sum+4 ;
          }
          else if(a-'5'==0){
            sum=sum+5 ;
          }
          else if(a-'6'==0){
            sum=sum+6 ;
          }
          else if(a-'7'==0){
            sum=sum+7 ;
          }
          else if(a-'8'==0){
            sum=sum+8 ;
          }
          else {
            sum=sum+9 ;
          }
        }
        System.out.println(sum);
        sum=0 ;
      }
    }
    catch(IOException e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     while (true) do (     var line : String ; line := reader.readLine() ;
     var a : String ; a := line->at(0+1) ;
    if (a = '0') then (     break ) else skip ; 
        var i : int ; i := 0 ; while i < line->size() do ( (     a := line->at(i+1) ; 
     if ((a)->char2byte() - ('0')->char2byte() = 0) then skip else     if ((a)->char2byte() - ('1')->char2byte() = 0) then (     sum := sum + 1 ) else     if ((a)->char2byte() - ('2')->char2byte() = 0) then (     sum := sum + 2 ) else     if ((a)->char2byte() - ('3')->char2byte() = 0) then (     sum := sum + 3 ) else     if ((a)->char2byte() - ('4')->char2byte() = 0) then (     sum := sum + 4 ) else     if ((a)->char2byte() - ('5')->char2byte() = 0) then (     sum := sum + 5 ) else     if ((a)->char2byte() - ('6')->char2byte() = 0) then (     sum := sum + 6 ) else     if ((a)->char2byte() - ('7')->char2byte() = 0) then (     sum := sum + 7 ) else     if ((a)->char2byte() - ('8')->char2byte() = 0) then (     sum := sum + 8 ) else (     sum := sum + 9 ) ;  ;  ;  ;  ;  ;  ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
    sum := 0 ; 
 ) )   catch (e : IOException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static String str ;
  public static void main(String[] args){
    while(read()){
      solve();
    }
  }
  static boolean read(){
    str=sc.next();
    if(str.equals("0"))return false ;
    return true ;
  }
  static void solve(){
    int sum=0 ;
    char number[]=str.toCharArray();
    int num[]=new int[number.length];
    for(int i=0 ; i<number.length ; i++){
      num[i]=number[i]-'0' ;
    }
    for(int i=0 ; i<num.length ; i++){
      sum+=num[i];
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute str : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (read()) do (     execute solve() ) );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     str := sc.getCurrent() ; 
     if (str = "0") then     return false else skip ; 
     return true );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var number : Sequence(String) ; number := str->characters() ;
    var num : Sequence(int) ; num := Integer.subrange(1,number->size())->collect(0) ;
        var i : int ; i := 0 ; while i < number->size() do ( (     num[i+1] := number[i+1] - ('0')->char2byte() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < num->size() do ( (     sum := sum+(num[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.LinkedList ;
public class Main {
  private static class List extends LinkedList<long[]>{
  }
  public static void main(String[] args)throws Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    LinkedList<Integer>list=new LinkedList<Integer>();
    String input=null ;
    while(!(input=reader.readLine()).equals("0")){
      int sum=0 ;
      for(int i=0 ; i<input.length(); i++){
        sum+=perse(input.charAt(i));
      }
      list.add(sum);
    }
    for(int i : list){
      System.out.println(i);
    }
  }
  private static int perse(char num){
    return num-'0' ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class List extends Sequence(Sequence(long)) { }
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var list : Sequence(int) ; list := Sequence{} ;
    var input : String ; input := null ;
    while (not((input) = "0")) do (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < input->size() do ( (     sum := sum+(perse(input->at(i+1))) )  ;     i := i + 1 ) ; 
     list := list->including(sum) ) ; 
    for (i : list) do ( (     OclFile["System.out"].println(i) )  ) ; 
 );
  static   operation perse( num : String) : int
  pre: true
  post: true
  activity: (     return num - ('0')->char2byte() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static int gcdExtended(int a,int b,int x,int y){
    if(a==0){
      x=0 ;
      y=1 ;
      return b ;
    }
    int x1=1,y1=1 ;
    int gcd=gcdExtended(b % a,a,x1,y1);
    x=y1-(b/a)*x1 ;
    y=x1 ;
    return gcd ;
  }
  public static void main(String[] args){
    int x=1,y=1 ;
    int a=35,b=15 ;
    int g=gcdExtended(a,b,x,y);
    System.out.print("gcd("+a+","+b+")="+g);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcdExtended( a : int, b : int, x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then (     x := 0 ; 
     y := 1 ; 
     return b ) else skip ; 
     var x1 : int ; x1 := 1 ;
    var y1 : int ; y1 := 1 ;
    var gcd : int ; gcd := gcdExtended(b mod a, a, x1, y1) ;
    x := y1 - (b / a) * x1 ; 
    y := x1 ; 
    return gcd 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 1 ;
    var y : int ; y := 1 ;
     var a : int ; a := 35 ;
    var b : int ; b := 15 ;
     var g : int ; g := gcdExtended(a, b, x, y) ;
     OclFile["System.out"].print("gcd(" + a + "," + b + ")=" + g) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static int gcdExtended(int a,int b,int x,int y){
    if(a==0){
      x=0 ;
      y=1 ;
      return b ;
    }
    int x1=1,y1=1 ;
    int gcd=gcdExtended(b % a,a,x1,y1);
    x=y1-(b/a)*x1 ;
    y=x1 ;
    return gcd ;
  }
  public static void main(String[] args){
    int x=1,y=1 ;
    int a=35,b=15 ;
    int g=gcdExtended(a,b,x,y);
    System.out.print("gcd("+a+","+b+")="+g);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcdExtended( a : int, b : int, x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then (     x := 0 ; 
     y := 1 ; 
     return b ) else skip ; 
     var x1 : int ; x1 := 1 ;
    var y1 : int ; y1 := 1 ;
    var gcd : int ; gcd := gcdExtended(b mod a, a, x1, y1) ;
    x := y1 - (b / a) * x1 ; 
    y := x1 ; 
    return gcd 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 1 ;
    var y : int ; y := 1 ;
     var a : int ; a := 35 ;
    var b : int ; b := 15 ;
     var g : int ; g := gcdExtended(a, b, x, y) ;
     OclFile["System.out"].print("gcd(" + a + "," + b + ")=" + g) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Collections ;
public class Main {
  public static void main(String[] args){
    while(true){
      int N=nextInt();
      if(N==0){
        break ;
      }
      int M=nextInt();
      ArrayList<Edge>list=new ArrayList<Edge>();
      for(int i=0 ; i<N ; i++){
        int D=nextInt();
        int P=nextInt();
        list.add(new Edge(D,P));
      }
      Collections.sort(list);
      int deathP=0 ;
      for(Edge e : list){
        if(M>=e.D){
          M-=e.D ;
        }
        else {
          deathP+=(e.D-M)*e.P ;
          M=0 ;
        }
      }
      System.out.println(deathP);
    }
  }
  static int nextInt(){
    int c ;
    try {
      c=System.in.read();
      while(c!='-' &&(c<'0' || c>'9'))c=System.in.read();
      if(c=='-')return-nextInt();
      int res=0 ;
      while(c>='0' && c<='9'){
        res=res*10+c-'0' ;
        c=System.in.read();
      }
      return res ;
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return-1 ;
  }
}
class Edge implements Comparable<Edge>{
  int D,P ;
  Edge(int d,int p){
    this.D=d ;
    this.P=p ;
  }
  @ Override public int compareTo(Edge arg0){
    return arg0.P-this.P ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var N : int ; N := nextInt() ;
     if (N = 0) then (     break ) else skip ; 
    var M : int ; M := nextInt() ;
    var list : Sequence(Edge) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var D : int ; D := nextInt() ;
     var P : int ; P := nextInt() ;
     list := list->including(Edge.newEdge(D, P)) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var deathP : int ; deathP := 0 ;
    for (e : list) do ( (     if (M >= e.D) then (     M := M-(e.D) ) else (     deathP := deathP+((e.D - M) * e.P) ; 
     M := 0 ) )  ) ; 
    OclFile["System.out"].println(deathP) ; 
 ) );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     var c : int ;
     try (     c := OclFile["System.in"].read() ; 
     while (c /= '-' & (c < '0' or c > '9')) do     c := OclFile["System.in"].read() ; ; 
    if (c = '-') then     return -nextInt() else skip ; 
    var res : int ; res := 0 ;
    while (c >= '0' & c <= '9') do (     res := res * 10 + c - ('0')->char2byte() ; 
     c := OclFile["System.in"].read() ) ; 
    return res 
 )   catch (e : IOException) do (     e.printStackTrace() )
     return -1 );
}
class Edge implements Comparable<Edge> {
   attribute D : int;
   static operation newEdge( d : int, p : int) : Edge
  pre: true
  post: true
  activity:
  ( var self : Edge ;
    self := createEdge();
    self.initialise(d, p);
    return self );
  operation initialise( d : int, p : int) : void
  pre: true  post: true
  activity: (     self.D := d ; 
     self.P := p );
      operation compareTo( arg0 : Edge) : int
  pre: true
  post: true
  activity: (     return arg0.P - self.P );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int s=sc.nextInt();
      int g1=sc.nextInt();
      int g2=sc.nextInt();
      if((n | m | s | g1 | g2)==0)break ;
      s--;
      g1--;
      g2--;
      int[][] pass=new int[n][n];
      int INF=1<<24 ;
      for(int i=0 ; i<n ; i++){
        Arrays.fill(pass[i],INF);
        pass[i][i]=0 ;
      }
      for(int i=0 ; i<m ; i++){
        int a=sc.nextInt()-1 ;
        int b=sc.nextInt()-1 ;
        int cost=sc.nextInt();
        pass[a][b]=cost ;
      }
      for(int j=0 ; j<n ; j++){
        for(int i=0 ; i<n ; i++){
          for(int k=0 ; k<n ; k++){
            pass[i][k]=Math.min(pass[i][k],pass[i][j]+pass[j][k]);
          }
        }
      }
      int min=INF ;
      for(int i=0 ; i<n ; i++){
        int value=pass[s][i]+pass[i][g1]+pass[i][g2];
        min=Math.min(min,value);
      }
      System.out.println(min);
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var g1 : int ; g1 := sc.getCurrent()->toInteger() ;
    var g2 : int ; g2 := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(MathLib.bitwiseOr(MathLib.bitwiseOr(n,m),s),g1),g2)) = 0) then     break else skip ; 
    s := s - 1 ; 
    g1 := g1 - 1 ; 
    g2 := g2 - 1 ; 
    var pass : Sequence(Sequence(int)) ; pass := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var INF : int ; INF := (1*(2->pow(24)))->oclAsType(long) ;
        var i : int ; i := 0 ; while i < n do ( (     pass[i+1] := pass[i+1]->collect(INF) ; 
     pass[i+1][i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
     var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
     var cost : int ; cost := sc.getCurrent()->toInteger() ;
     pass[a+1][b+1] := cost )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (         var i : int ; i := 0 ; while i < n do ( (         var k : int ; k := 0 ; while k < n do ( (     pass[i+1][k+1] := Set{pass[i+1][k+1], pass[i+1][j+1] + pass[j+1][k+1]}->min() )  ;     k := k + 1 ) )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    var min : int ; min := INF ;
        var i : int ; i := 0 ; while i < n do ( (     var value : int ; value := pass[s+1][i+1] + pass[i+1][g1+1] + pass[i+1][g2+1] ;
     min := Set{min, value}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int d=sc.nextInt();
    String space[]=new String[n];
    int countSpace ;
    int countD=0 ;
    for(int i=0 ; i<n ; i++){
      countSpace=0 ;
      space[i]=sc.next();
      for(int j=0 ; j<m ; j++){
        if(space[i] .charAt(j)=='#'){
          countD+=Math.max(countSpace-d+1,0);
          countSpace=0 ;
        }
        else {
          countSpace++;
          if(j==m-1)countD+=Math.max(countSpace-d+1,0);
        }
      }
    }
    for(int i=0 ; i<m ; i++){
      countSpace=0 ;
      for(int j=0 ; j<n ; j++){
        if(space[j] .charAt(i)=='#'){
          countD+=Math.max(countSpace-d+1,0);
          countSpace=0 ;
        }
        else {
          countSpace++;
          if(j==n-1)countD+=Math.max(countSpace-d+1,0);
        }
      }
    }
    System.out.println(countD);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var space : Sequence(String) ; space := Integer.subrange(1,n)->collect(null) ;
    var countSpace : int ;
    var countD : int ; countD := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     countSpace := 0 ; 
     space[i+1] := sc.getCurrent() ; 
         var j : int ; j := 0 ; while j < m do ( (     if (space[i+1]->at(j+1) = '#') then (     countD := countD+(Set{(countSpace)->char2byte() - d + 1, 0}->max()) ; 
     countSpace := 0 ) else (     countSpace := countSpace + 1 ; 
     if (j = m - 1) then     countD := countD+(Set{(countSpace)->char2byte() - d + 1, 0}->max()) ; else skip ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     countSpace := 0 ; 
         var j : int ; j := 0 ; while j < n do ( (     if (space[j+1]->at(i+1) = '#') then (     countD := countD+(Set{(countSpace)->char2byte() - d + 1, 0}->max()) ; 
     countSpace := 0 ) else (     countSpace := countSpace + 1 ; 
     if (j = n - 1) then     countD := countD+(Set{(countSpace)->char2byte() - d + 1, 0}->max()) ; else skip ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(countD) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static void precomput(long f[]){
    f[0]=0 ;
    f[1]=1 ;
    for(int i=2 ; i<300 ; i++)f[i]=(f[i-1]+f[i-2])% 100 ;
  }
  static long findLastDigit(long f[],int n){
    return(f[(n % 300)]);
  }
  public static void main(String args[]){
    long f[]=new long[300];
    Arrays.fill(f,0);
    precomput(f);
    int n=1 ;
    System.out.println(findLastDigit(f,n));
    n=61 ;
    System.out.println(findLastDigit(f,n));
    n=7 ;
    System.out.println(findLastDigit(f,n));
    n=67 ;
    System.out.println(findLastDigit(f,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation precomput( f : Sequence(long)) : void
  pre: true
  post: true
  activity: (     f[0+1] := 0 ; 
     f[1+1] := 1 ; 
         var i : int ; i := 2 ; while i < 300 do (     f[i+1] := (f[i - 1+1] + f[i - 2+1]) mod 100 ;  ;     i := i + 1 ) );
  static   operation findLastDigit( f : Sequence(long), n : int) : long
  pre: true
  post: true
  activity: (     return (f[(n mod 300)+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : Sequence(long) ; f := Integer.subrange(1,300)->collect(0) ;
     f := f->collect(0) ; 
    execute precomput(f) ; 
    var n : int ; n := 1 ;
    OclFile["System.out"].println(findLastDigit(f, n)) ; 
    n := 61 ; 
    OclFile["System.out"].println(findLastDigit(f, n)) ; 
    n := 7 ; 
    OclFile["System.out"].println(findLastDigit(f, n)) ; 
    n := 67 ; 
    OclFile["System.out"].println(findLastDigit(f, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  static void flip(int a,int b){
    int lcm=(a*b)/gcd(a,b);
    a=lcm/a ;
    b=lcm/b ;
    System.out.print((a-1)+" "+(b-1));
  }
  public static void main(String[] args){
    int a=10 ;
    int b=5 ;
    flip(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation flip( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var lcm : int ; lcm := (a * b) / gcd(a, b) ;
     a := lcm / a ; 
     b := lcm / b ; 
     OclFile["System.out"].print((a - 1) + " " + (b - 1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 10 ;
     var b : int ; b := 5 ;
     execute flip(a, b) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static int longLenStrictBitonicSub(int arr[],int n){
    HashMap<Integer,Integer>inc=new HashMap<Integer,Integer>();
    HashMap<Integer,Integer>dcr=new HashMap<Integer,Integer>();
    int len_inc[]=new int[n];
    int len_dcr[]=new int[n];
    int longLen=0 ;
    for(int i=0 ; i<n ; i++){
      int len=0 ;
      if(inc.containsKey(arr[i]-1))len=inc.get(arr[i]-1);
      len_inc[i]=len+1 ;
      inc.put(arr[i],len_inc[i]);
    }
    for(int i=n-1 ; i>=0 ; i--){
      int len=0 ;
      if(dcr.containsKey(arr[i]-1))len=dcr.get(arr[i]-1);
      len_dcr[i]=len+1 ;
      dcr.put(arr[i],len_dcr[i]);
    }
    for(int i=0 ; i<n ; i++)if(longLen<(len_inc[i]+len_dcr[i]-1))longLen=len_inc[i]+len_dcr[i]-1 ;
    return longLen ;
  }
  public static void main(String[] args){
    int arr[]={
      1,5,2,3,4,5,3,2 };
      int n=arr.length ;
      System.out.println("Longest length strict "+"bitonic subsequence="+longLenStrictBitonicSub(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation longLenStrictBitonicSub( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var inc : Map(int,int) ; inc := Map{} ;
     var dcr : Map(int,int) ; dcr := Map{} ;
    var len_inc : Sequence(int) ; len_inc := Integer.subrange(1,n)->collect(0) ;
    var len_dcr : Sequence(int) ; len_dcr := Integer.subrange(1,n)->collect(0) ;
    var longLen : int ; longLen := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var len : int ; len := 0 ;
     if (inc->keys()->includes(arr[i+1] - 1)) then     len := inc->at(arr[i+1] - 1) ; else skip ; 
     len_inc[i+1] := len + 1 ; 
     inc := inc->union(Map{arr[i+1] |-> len_inc[i+1]}) )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     var len : int ; len := 0 ;
     if (dcr->keys()->includes(arr[i+1] - 1)) then     len := dcr->at(arr[i+1] - 1) ; else skip ; 
     len_dcr[i+1] := len + 1 ; 
     dcr := dcr->union(Map{arr[i+1] |-> len_dcr[i+1]}) )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     if (longLen < (len_inc[i+1] + len_dcr[i+1] - 1)) then     longLen := len_inc[i+1] + len_dcr[i+1] - 1 ; else skip ;  ;     i := i + 1 ) ; 
    return longLen 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,2,3,4,5,3,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Longest length strict " + "bitonic subsequence=" + longLenStrictBitonicSub(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    boolean[] r=new boolean[50000],c=new boolean[50000];
    int[] a=new int[50000],b=new int[50000],o=new int[50000];
    for(; ; ){
      int R=sc.nextInt(),C=sc.nextInt(),Q=sc.nextInt();
      if((R | C | Q)==0)break ;
      Arrays.fill(r,false);
      Arrays.fill(c,false);
      long res=0 ;
      for(int i=0 ; i<Q ; i++){
        a[i]=sc.nextInt();
        b[i]=sc.nextInt();
        o[i]=sc.nextInt();
      }
      for(int i=Q-1 ; i>=0 ; i--){
        if(o[i]==0){
          if(a[i]==0){
            if(r[b[i] ])continue ;
            r[b[i] ]=true ;
            R--;
          }
          else {
            if(c[b[i] ])continue ;
            c[b[i] ]=true ;
            C--;
          }
        }
        else {
          if(a[i]==0){
            if(r[b[i] ])continue ;
            r[b[i] ]=true ;
            res+=C ;
            R--;
          }
          else {
            if(c[b[i] ])continue ;
            c[b[i] ]=true ;
            res+=R ;
            C--;
          }
        }
      }
      System.out.println(res);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : Sequence(boolean) ; r := Integer.subrange(1,50000)->collect(false) ;
    var c : Sequence(boolean) ; c := Integer.subrange(1,50000)->collect(false) ;
     var a : Sequence(int) ; a := Integer.subrange(1,50000)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,50000)->collect(0) ;
    var o : Sequence(int) ; o := Integer.subrange(1,50000)->collect(0) ;
       while true do ( (     var R : int ; R := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var Q : int ; Q := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseOr(MathLib.bitwiseOr(R,C),Q)) = 0) then     break else skip ; 
    r := r->collect(false) ; 
    c := c->collect(false) ; 
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < Q do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() ; 
     o[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := Q - 1 ; while i >= 0 do ( (     if (o[i+1] = 0) then (     if (a[i+1] = 0) then (     if (r[b[i+1]+1]) then     continue else skip ; 
     r[b[i+1]+1] := true ; 
     R := R - 1 ) else (     if (c[b[i+1]+1]) then     continue else skip ; 
     c[b[i+1]+1] := true ; 
     C := C - 1 ) ) else (     if (a[i+1] = 0) then (     if (r[b[i+1]+1]) then     continue else skip ; 
     r[b[i+1]+1] := true ; 
     res := res+(C) ; 
     R := R - 1 ) else (     if (c[b[i+1]+1]) then     continue else skip ; 
     c[b[i+1]+1] := true ; 
     res := res+(R) ; 
     C := C - 1 ) ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(res) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int r=sc.nextInt();
      int c=sc.nextInt();
      int q=sc.nextInt();
      if((r | c | q)==0)break ;
      Query qs[]=new Query[q];
      for(int i=0 ; i<q ; i++){
        qs[i]=new Query(sc.nextInt(),sc.nextInt(),sc.nextInt());
      }
      Set<String>set=new HashSet<String>();
      long stand_r=0 ;
      long stand_c=0 ;
      long sit_r=0 ;
      long sit_c=0 ;
      long ans=0 ;
      for(int i=q-1 ; i>=0 ; i--){
        if(set.contains(qs[i] .toString()))continue ;
        set.add(qs[i] .toString());
        if(qs[i] .a==1){
          if(qs[i] .o==0){
            sit_r++;
          }
          else {
            stand_r++;
            ans+=r ;
            ans-=sit_c ;
            ans-=stand_c ;
          }
        }
        else {
          if(qs[i] .o==0){
            sit_c++;
          }
          else {
            stand_c++;
            ans+=c ;
            ans-=sit_r ;
            ans-=stand_r ;
          }
        }
      }
      System.out.println(ans);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
class Query {
  int a ;
  int b ;
  int o ;
  Query(int a,int b,int o){
    this.a=a ;
    this.b=b ;
    this.o=o ;
  }
  public String toString(){
    return "a:"+a+","+"b:"+b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var r : int ; r := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(r,c),q)) = 0) then     break else skip ; 
    var qs : Sequence(Query) ; qs := Integer.subrange(1,q)->collect(null) ;
        var i : int ; i := 0 ; while i < q do ( (     qs[i+1] := Query.newQuery(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var set : Set(String) ; set := Set{} ;
    var stand_r : long ; stand_r := 0 ;
    var stand_c : long ; stand_c := 0 ;
    var sit_r : long ; sit_r := 0 ;
    var sit_c : long ; sit_c := 0 ;
    var ans : long ; ans := 0 ;
        var i : int ; i := q - 1 ; while i >= 0 do ( (     if (set->includes(qs[i+1]+"")) then     continue else skip ; 
     set := set->including(qs[i+1]+"") ; 
     if (qs[i+1].a = 1) then (     if (qs[i+1].o = 0) then (     sit_r := sit_r + 1 ) else (     stand_r := stand_r + 1 ; 
     ans := ans+(r) ; 
     ans := ans-(sit_c) ; 
     ans := ans-(stand_c) ) ) else (     if (qs[i+1].o = 0) then (     sit_c := sit_c + 1 ) else (     stand_c := stand_c + 1 ; 
     ans := ans+(c) ; 
     ans := ans-(sit_r) ; 
     ans := ans-(stand_r) ) ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}
class Query {
   attribute a : int;
   attribute b : int;
   attribute o : int;
   static operation newQuery( a : int, b : int, o : int) : Query
  pre: true
  post: true
  activity:
  ( var self : Query ;
    self := createQuery();
    self.initialise(a, b,o);
    return self );
  operation initialise( a : int, b : int, o : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b ; 
     self.o := o );
   operation toString() : String
  pre: true
  post: true
  activity: (     return "a:" + a + "," + "b:" + b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    while(true){
      int r=s.nextInt();
      int c=s.nextInt();
      int q=s.nextInt();
      if(r==0)break ;
      boolean[] r_used=new boolean[r];
      boolean[] c_used=new boolean[c];
      int r_cnt=c ;
      int c_cnt=r ;
      int[] alst=new int[q];
      int[] blst=new int[q];
      int[] olst=new int[q];
      for(int i=0 ; i<q ; i++){
        alst[q-i-1]=s.nextInt();
        blst[q-i-1]=s.nextInt();
        olst[q-i-1]=s.nextInt();
      }
      int ans=0 ;
      for(int i=0 ; i<q ; i++){
        int a=alst[i];
        int b=blst[i];
        int o=olst[i];
        if(a==0){
          if(o==0){
            if(! r_used[b]){
              r_used[b]=true ;
              c_cnt-=1 ;
            }
          }
          else {
            if(! r_used[b]){
              ans+=r_cnt ;
              r_used[b]=true ;
              c_cnt-=1 ;
            }
          }
        }
        else {
          if(o==0){
            if(! c_used[b]){
              c_used[b]=true ;
              r_cnt-=1 ;
            }
          }
          else {
            if(! c_used[b]){
              ans+=c_cnt ;
              c_used[b]=true ;
              r_cnt-=1 ;
            }
          }
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var r : int ; r := s.getCurrent()->toInteger() ;
     var c : int ; c := s.getCurrent()->toInteger() ;
    var q : int ; q := s.getCurrent()->toInteger() ;
    if (r = 0) then     break else skip ; 
    var r_used : Sequence(boolean) ; r_used := Integer.subrange(1,r)->collect(false) ;
    var c_used : Sequence(boolean) ; c_used := Integer.subrange(1,c)->collect(false) ;
    var r_cnt : int ; r_cnt := c ;
    var c_cnt : int ; c_cnt := r ;
    var alst : Sequence(int) ; alst := Integer.subrange(1,q)->collect(0) ;
    var blst : Sequence(int) ; blst := Integer.subrange(1,q)->collect(0) ;
    var olst : Sequence(int) ; olst := Integer.subrange(1,q)->collect(0) ;
        var i : int ; i := 0 ; while i < q do ( (     alst[q - i - 1+1] := s.getCurrent()->toInteger() ; 
     blst[q - i - 1+1] := s.getCurrent()->toInteger() ; 
     olst[q - i - 1+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < q do ( (     var a : int ; a := alst[i+1] ;
     var b : int ; b := blst[i+1] ;
     var o : int ; o := olst[i+1] ;
     if (a = 0) then (     if (o = 0) then (     if (not(r_used[b+1])) then (     r_used[b+1] := true ; 
     c_cnt := c_cnt-(1) ) else skip ) else (     if (not(r_used[b+1])) then (     ans := ans+(r_cnt) ; 
     r_used[b+1] := true ; 
     c_cnt := c_cnt-(1) ) else skip ) ) else (     if (o = 0) then (     if (not(c_used[b+1])) then (     c_used[b+1] := true ; 
     r_cnt := r_cnt-(1) ) else skip ) else (     if (not(c_used[b+1])) then (     ans := ans+(c_cnt) ; 
     c_used[b+1] := true ; 
     r_cnt := r_cnt-(1) ) else skip ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int calcExpectation(int[][] memo,int dis,int money){
    for(int r=0 ; r<memo.length ; r++){
      int max=memo[0][1];
      int minusDis=memo[0][0],idx=0 ;
      for(int c=1 ; c<memo.length ; c++){
        if(memo[c][1]>max){
          max=memo[c][1];
          minusDis=memo[c][0];
          idx=c ;
        }
      }
      if(money>=minusDis){
        money-=minusDis ;
        memo[idx][0]=0 ;
        memo[idx][1]=0 ;
      }
      else {
        memo[idx][0]-=money ;
        money=0 ;
      }
      if(money==0)break ;
    }
    int ret=0 ;
    for(int r=0 ; r<memo.length ; r++){
      int num=memo[r][0]*memo[r][1];
      if(num>0)ret+=num ;
    }
    return(ret);
  }
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(true){
      int n=stdIn.nextInt();
      int m=stdIn.nextInt();
      if(n+m==0)break ;
      int[][] memo=new int[n][2];
      int sumDistance=0 ;
      for(int r=0 ; r<n ; r++){
        memo[r][0]=stdIn.nextInt();
        memo[r][1]=stdIn.nextInt();
        sumDistance+=memo[r][0];
      }
      System.out.println(calcExpectation(memo,sumDistance,m));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation calcExpectation( memo : Sequence(Sequence(int)), dis : int, money : int) : int
  pre: true
  post: true
  activity: (         var r : int ; r := 0 ; while r < memo->size() do ( (     var max : int ; max := memo[0+1][1+1] ;
     var minusDis : int ; minusDis := memo[0+1][0+1] ;
    var idx : int ; idx := 0 ;
        var c : int ; c := 1 ; while c < memo->size() do ( (     if (memo[c+1][1+1] > max) then (     max := memo[c+1][1+1] ; 
     minusDis := memo[c+1][0+1] ; 
     idx := c ) else skip )  ;     c := c + 1 ) ; 
    if (money >= minusDis) then (     money := money-(minusDis) ; 
     memo[idx+1][0+1] := 0 ; 
     memo[idx+1][1+1] := 0 ) else (     memo[idx+1][0+1] := memo[idx+1][0+1]-(money) ; 
     money := 0 ) ;  
    if (money = 0) then     break else skip ; 
 )  ;     r := r + 1 ) ; 
     var ret : int ; ret := 0 ;
         var r : int ; r := 0 ; while r < memo->size() do ( (     var num : int ; num := memo[r+1][0+1] * memo[r+1][1+1] ;
     if (num > 0) then     ret := ret+(num) ; else skip )  ;     r := r + 1 ) ; 
     return (ret) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     var m : int ; m := stdIn.getCurrent()->toInteger() ;
    if (n + m = 0) then     break else skip ; 
    var memo : Sequence(Sequence(int)) ; memo := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
    var sumDistance : int ; sumDistance := 0 ;
        var r : int ; r := 0 ; while r < n do ( (     memo[r+1][0+1] := stdIn.getCurrent()->toInteger() ; 
     memo[r+1][1+1] := stdIn.getCurrent()->toInteger() ; 
     sumDistance := sumDistance+(memo[r+1][0+1]) )  ;     r := r + 1 ) ; 
    OclFile["System.out"].println(calcExpectation(memo, sumDistance, m)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public final class p127 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p127().run());
  }
  private static final int LIMIT=120000 ;
  public String run(){
    int[] rads=new int[LIMIT];
    Arrays.fill(rads,1,rads.length,1);
    for(int i=2 ; i<rads.length ; i++){
      if(rads[i]==1){
        for(int j=i ; j<rads.length ; j+=i)rads[j]*=i ;
      }
    }
    long sum=0 ;
    for(int c=2 ; c<LIMIT ; c++){
      if(rads[c]==c)continue ;
      for(int a=1,end=(c-1)/2 ; a<=end ; a++){
        int b=c-a ;
        assert a<b ;
        if((long)rads[a]*rads[b]*rads[c]<c && Library.gcd(a,b)==1)sum+=c ;
      }
    }
    return Long.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p127 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p127.newp127().run()) );
  static    attribute LIMIT : int := 120000;
   operation run() : String
  pre: true
  post: true
  activity: (     var rads : Sequence(int) ; rads := Integer.subrange(1,LIMIT)->collect(0) ;
     rads := rads->collect(1) ; 
        var i : int ; i := 2 ; while i < rads->size() do ( (     if (rads[i+1] = 1) then (         var j : int ; j := i ; while j < rads->size() do (     rads[j+1] := rads[j+1]*(i) ;  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var c : int ; c := 2 ; while c < LIMIT do ( (     if (rads[c+1] = c) then     continue else skip ; 
         var a : int ; a := 1 ;
    var end : int ; end := (c - 1) / 2 ; while a <= end do ( (     var b : int ; b := c - a ;
     assert a < b ; 
     if (rads[a+1]->oclAsType(long) * rads[b+1] * rads[c+1] < c & Library.gcd(a, b) = 1) then     sum := sum+(c) ; else skip )  ;     a := a + 1 ) )  ;     c := c + 1 ) ; 
    return ((sum) + "") 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static int kthdigit(int a,int b,int k){
    int p=(int)Math.pow(a,b);
    int count=0 ;
    while(p>0 && count<k){
      int rem=p % 10 ;
      count++;
      if(count==k)return rem ;
      p=p/10 ;
    }
    return 0 ;
  }
  public static void main(String argc[]){
    int a=5,b=2 ;
    int k=1 ;
    System.out.println(kthdigit(a,b,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation kthdigit( a : int, b : int, k : int) : int
  pre: true
  post: true
  activity: (     var p : int ; p := a->pow(b)->oclAsType(int) ;
     var count : int ; count := 0 ;
     while (p > 0 & count < k) do (     var rem : int ; rem := p mod 10 ;
     count := count + 1 ; 
     if (count = k) then     return rem else skip ; 
     p := p / 10 ) ; 
     return 0 );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 5 ;
    var b : int ; b := 2 ;
     var k : int ; k := 1 ;
     OclFile["System.out"].println(kthdigit(a, b, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.security.NoSuchAlgorithmException ;
import java.util.ArrayList ;
import java.util.HashMap ;
public class Main {
  public static HashMap<String,String>map=new HashMap<>();
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int D=sc.nextInt();
    boolean[][] map=new boolean[N][M];
    for(int i=0 ; i<N ; i++){
      char[] in=sc.next().toCharArray();
      for(int j=0 ; j<M ; j++){
        if(in[j]!='#')map[i][j]=true ;
      }
    }
    int ans=0 ;
    for(int i=0 ; i<N ; i++){
      int cc=0 ;
      for(int j=0 ; j<M ; j++){
        if(map[i][j])cc++;
        if(! map[i][j] || j==M-1){
          ans+=Math.max(0,cc-D+1);
          cc=0 ;
        }
      }
    }
    for(int i=0 ; i<M ; i++){
      int cc=0 ;
      for(int j=0 ; j<N ; j++){
        if(map[j][i])cc++;
        if(! map[j][i] || j==N-1){
          ans+=Math.max(0,cc-D+1);
          cc=0 ;
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute map : Map(String,String) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var D : int ; D := sc.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(boolean)) ; map := Integer.subrange(1,N)->collect(Integer.subrange(1,M)->collect(false)) ;
        var i : int ; i := 0 ; while i < N do ( (     var in : Sequence(String) ; in := sc.getCurrent()->characters() ;
         var j : int ; j := 0 ; while j < M do ( (     if (in[j+1] /= '#') then     map[i+1][j+1] := true ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var cc : int ; cc := 0 ;
         var j : int ; j := 0 ; while j < M do ( (     if (map[i+1][j+1]) then     cc := cc + 1 ; else skip ; 
     if (not(map[i+1][j+1]) or j = M - 1) then (     ans := ans+(Set{0, cc - D + 1}->max()) ; 
     cc := 0 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var cc : int ; cc := 0 ;
         var j : int ; j := 0 ; while j < N do ( (     if (map[j+1][i+1]) then     cc := cc + 1 ; else skip ; 
     if (not(map[j+1][i+1]) or j = N - 1) then (     ans := ans+(Set{0, cc - D + 1}->max()) ; 
     cc := 0 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void recaman(int n){
    int arr[]=new int[n];
    arr[0]=0 ;
    System.out.print(arr[0]+",");
    for(int i=1 ; i<n ; i++){
      int curr=arr[i-1]-i ;
      int j ;
      for(j=0 ; j<i ; j++){
        if((arr[j]==curr)|| curr<0){
          curr=arr[i-1]+i ;
          break ;
        }
      }
      arr[i]=curr ;
      System.out.print(arr[i]+",");
    }
  }
  public static void main(String[] args){
    int n=17 ;
    recaman(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation recaman( n : int) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
     arr[0+1] := 0 ; 
     OclFile["System.out"].print(arr[0+1] + ",") ; 
         var i : int ; i := 1 ; while i < n do ( (     var curr : int ; curr := arr[i - 1+1] - i ;
     var j : int ;
        j := 0 ; while j < i do ( (     if ((arr[j+1] = curr) or curr < 0) then (     curr := arr[i - 1+1] + i ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    arr[i+1] := curr ; 
    OclFile["System.out"].print(arr[i+1] + ",") ; 
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 17 ;
     execute recaman(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int min=Integer.MIN_VALUE ;
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int one=sc.nextInt();
      count-=one ;
      int two=sc.nextInt();
      count+=two ;
      min=Math.max(min,count);
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var min : int ; min := -2147483648 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var one : int ; one := sc.getCurrent()->toInteger() ;
     count := count-(one) ; 
    var two : int ; two := sc.getCurrent()->toInteger() ;
    count := count+(two) ; 
    min := Set{min, count}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class OneTestCase {
  public static void main(String[] args){
    int n=scan.nextInt();
    int max=0 ;
    int current=0 ;
    for(int i=0 ; i<n ; i++){
      int exit=scan.nextInt();
      int enter=scan.nextInt();
      current+=enter-exit ;
      max=Math.max(max,current);
    }
    System.out.println(max);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  static FastReader scan=new FastReader();
  static int MOD=1000000007 ;
}
------------------------------------------------------------
OCL File:
---------
 class OneTestCase {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scan.nextInt() ;
     var max : int ; max := 0 ;
    var current : int ; current := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var exit : int ; exit := scan.nextInt() ;
     var enter : int ; enter := scan.nextInt() ;
     current := current+(enter - exit) ; 
     max := Set{max, current}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   attribute scan : FastReader := FastReader.newFastReader();
  static   attribute MOD : int := 1000000007;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Ideone {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int max=0 ;
    int total=0 ;
    while(n-->0){
      int a=sc.nextInt();
      int b=sc.nextInt();
      total=total-a+b ;
      if(total>max){
        max=total ;
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ideone {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var max : int ; max := 0 ;
    var total : int ; total := 0 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     total := total - a + b ; 
     if (total > max) then (     max := total ) else skip ) ;  ) ;  
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Madik {
  public static void main(String[] args){
    Scanner mad=new Scanner(System.in);
    int n=mad.nextInt();
    int count=0 ;
    int min=0 ;
    for(int i=0 ; i<n ; i++){
      int exit=mad.nextInt();
      int enter=mad.nextInt();
      count+=enter ;
      count-=exit ;
      if(count>min){
        min=count ;
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Madik {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mad : OclFile ; mad := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := mad.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var min : int ; min := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var exit : int ; exit := mad.getCurrent()->toInteger() ;
     var enter : int ; enter := mad.getCurrent()->toInteger() ;
    count := count+(enter) ; 
    count := count-(exit) ; 
    if (count > min) then (     min := count ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=br.readLine();
    int num=Integer.parseInt(str);
    int i ;
    for(i=0 ; i<100 ; i++){
      if(num>=Math.pow(2,i)-1){
        continue ;
      }
      else {
        break ;
      }
    }
    System.out.println(i-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := br.readLine() ;
    var num : int ; num := (str)->toInteger() ;
    var i : int ;
        i := 0 ; while i < 100 do ( (     if (num >= 2->pow(i) - 1) then (     continue ) else (     break ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(i - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
class Main {
  public static Scanner sc=new Scanner(in);
  public static Random rand=new Random();
  class D {
    int d ;
    int x ;
    D(int d,int x){
      this.d=d ;
      this.x=x ;
    }
  }
  public void run(){
    while(true){
      int n=sc.nextInt(),m=sc.nextInt();
      if(n==0 && m==0)return ;
      D[] dlist=new D[n];
      for(int i=0 ; i<n ; i++){
        dlist[i]=new D(sc.nextInt(),sc.nextInt());
      }
      Arrays.sort(dlist,new Comparator<D>(){
        @ Override public int compare(D o1,D o2){
          return o2.x-o1.x ;
        }
      }
);
      for(int i=0 ; i<n ; i++){
        if(m>=dlist[i] .d){
          m-=dlist[i] .d ;
          dlist[i] .d=0 ;
        }
        else {
          dlist[i] .d-=m ;
          m=0 ;
        }
      }
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        sum+=dlist[i] .d*dlist[i] .x ;
      }
      ln(sum);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  public int[] nextIntArray(int n){
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=sc.nextInt();
    }
    return res ;
  }
  public static void pr(Object o){
    out.print(o);
  }
  public static void ln(Object o){
    out.println(o);
  }
  public static void ln(){
    out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(in);
  static   attribute rand : OclRandom := OclRandom.newOclRandom();
 class D {
   attribute d : int;
   attribute x : int;
   static operation newD( d : int, x : int) : D
  pre: true
  post: true
  activity:
  ( var self : D ;
    self := createD();
    self.initialise(d, x);
    return self );
  operation initialise( d : int, x : int) : void
  pre: true  post: true
  activity: (     self.d := d ; 
     self.x := x );
}
   operation run() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
     if (n = 0 & m = 0) then     return else skip ; 
    var dlist : Sequence(D) ; dlist := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     dlist[i+1] := D.newD(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    dlist := OclComparator.sortWith(dlist, OclComparator<D>.newOclComparator()) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (m >= dlist[i+1].d) then (     m := m-(dlist[i+1].d) ; 
     dlist[i+1].d := 0 ) else (     dlist[i+1].d := dlist[i+1].d-(m) ; 
     m := 0 ) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(dlist[i+1].d * dlist[i+1].x) )  ;     i := i + 1 ) ; 
    execute ln(sum) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return res );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     out.println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    solve3027();
  }
  public static void solve3027(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int binaryNumDigits=Integer.toBinaryString(N).length();
    int ans=N==Math.pow(2,binaryNumDigits)-1 ? binaryNumDigits : binaryNumDigits-1 ;
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve3027() );
  static   operation solve3027() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var binaryNumDigits : int ; binaryNumDigits := (MathLib.decimal2binary(N) + "")->size() ;
    var ans : int ; ans := if N = 2->pow(binaryNumDigits) - 1 then binaryNumDigits else binaryNumDigits - 1 endif ;
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    solve3027();
  }
  public static void solve3027(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    String binary=Integer.toBinaryString(N);
    int binaryNumDigits=binary.length();
    int ans=binary.contains("0")? binaryNumDigits-1 : binaryNumDigits ;
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve3027() );
  static   operation solve3027() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var binary : String ; binary := (MathLib.decimal2binary(N) + "") ;
    var binaryNumDigits : int ; binaryNumDigits := binary->size() ;
    var ans : int ; ans := if binary->includes("0") then (binaryNumDigits)->char2byte() - 1 else binaryNumDigits endif ;
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String args[]){
    BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    String str="" ;
    try {
      while(true){
        str=bfr.readLine();
        if(str==""){
          System.exit(0);
        }
        int input=Integer.parseInt(str);
        int kurai=0 ;
        int ichi_kazu=0 ;
        int tmp=0 ;
        for(int i=0 ; i<31 ; i++){
          tmp=input>>i ;
          if(tmp % 2==1){
            kurai=i+1 ;
            ichi_kazu++;
          }
        }
        System.out.println(Math.max(kurai-1,ichi_kazu));
      }
    }
    catch(IOException e){
      System.exit(0);
    }
    catch(NumberFormatException e){
      System.exit(0);
    }
    catch(NullPointerException e){
      System.exit(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bfr : OclFile ; bfr := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := "" ;
     try (     while (true) do (     str := bfr.readLine() ; 
     if (str = "") then ( OclProcess.exit(0) ) else skip ; 
    var input : int ; input := (str)->toInteger() ;
    var kurai : int ; kurai := 0 ;
    var ichi_kazu : int ; ichi_kazu := 0 ;
    var tmp : int ; tmp := 0 ;
        var i : int ; i := 0 ; while i < 31 do ( (     tmp := (input/(2->pow(i)))->oclAsType(long) ; 
     if (tmp mod 2 = 1) then (     kurai := i + 1 ; 
     ichi_kazu := ichi_kazu + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{kurai - 1, ichi_kazu}->max()) ; 
 ) )   catch (e : IOException) do ( OclProcess.exit(0) )
   catch (e : IncorrectElementException) do ( OclProcess.exit(0) )
  catch (e : NullAccessException) do ( OclProcess.exit(0) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static String[] nums=sc.nextLine().split(" ");
  static int N=Integer.parseInt(nums[0]);
  static int M=Integer.parseInt(nums[1]);
  static char[][] room=new char[N][M];
  static int D=Integer.parseInt(nums[2]);
  static int num=0 ;
  public static void main(String[] args){
    inputRoom();
    if(M>=D){
      setWE();
    }
    if(N>=D){
      setNS();
    }
    System.out.println(num);
    sc.close();
  }
  private static void setWE(){
    boolean canPut=true ;
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<M-D+1 ; j++){
        canPut=true ;
        for(int k=0 ; k<D ; k++){
          if(Main.room[i][j+k]=='#'){
            canPut=false ;
            break ;
          }
        }
        if(canPut==true){
          num++;
        }
      }
    }
  }
  private static void setNS(){
    boolean canPut=true ;
    for(int i=0 ; i<M ; i++){
      for(int j=0 ; j<N-D+1 ; j++){
        canPut=true ;
        for(int k=0 ; k<D ; k++){
          if(Main.room[j+k][i]=='#'){
            canPut=false ;
            break ;
          }
        }
        if(canPut==true){
          num++;
        }
      }
    }
  }
  private static void inputRoom(){
    String str_room="" ;
    for(int i=0 ; i<N ; i++){
      str_room=sc.nextLine();
      Main.room[i]=str_room.toCharArray();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute nums : Sequence(String) := sc.nextLine()->split(" ");
  static   attribute N : int := (nums[0+1])->toInteger();
  static   attribute M : int := (nums[1+1])->toInteger();
  static   attribute room : Sequence(Sequence(String)) := Integer.subrange(1,N)->collect(Integer.subrange(1,M)->collect(0));
  static   attribute D : int := (nums[2+1])->toInteger();
  static   attribute num : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute inputRoom() ; 
     if (M >= D) then (     execute setWE() ) else skip ; 
    if (N >= D) then (     execute setNS() ) else skip ; 
    OclFile["System.out"].println(num) ; 
    skip ; 
 );
  static   operation setWE() : void
  pre: true
  post: true
  activity: (     var canPut : boolean ; canPut := true ;
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < M - D + 1 do ( (     canPut := true ; 
         var k : int ; k := 0 ; while k < D do ( (     if (Main.room[i+1][j + k+1] = '#') then (     canPut := false ; 
     break ) else skip )  ;     k := k + 1 ) ; 
     if (canPut = true) then (     num := num + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation setNS() : void
  pre: true
  post: true
  activity: (     var canPut : boolean ; canPut := true ;
         var i : int ; i := 0 ; while i < M do ( (         var j : int ; j := 0 ; while j < N - D + 1 do ( (     canPut := true ; 
         var k : int ; k := 0 ; while k < D do ( (     if (Main.room[j + k+1][i+1] = '#') then (     canPut := false ; 
     break ) else skip )  ;     k := k + 1 ) ; 
     if (canPut = true) then (     num := num + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation inputRoom() : void
  pre: true
  post: true
  activity: (     var str_room : String ; str_room := "" ;
         var i : int ; i := 0 ; while i < N do ( (     str_room := sc.nextLine() ; 
     Main.room[i+1] := str_room->characters() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int count1=-1 ;
    int count2=0 ;
    while(n>0){
      count2+=n % 2 ;
      n>>=1 ;
      count1++;
    }
    System.out.println(Math.max(count1,count2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var count1 : int ; count1 := -1 ;
    var count2 : int ; count2 := 0 ;
    while (n > 0) do (     count2 := count2+(n mod 2) ; 
     n := n/(2->pow(1)) ; 
     count1 := count1 + 1 ) ; 
    OclFile["System.out"].println(Set{count1, count2}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static int INF=10000 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    char[][] s=new char[H][W];
    for(int i=0 ; i<H ; i++){
      String S=sc.next();
      for(int j=0 ; j<W ; j++){
        s[i][j]=S.charAt(j);
      }
    }
    int[][] dp=new int[H][W];
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        dp[i][j]=INF ;
      }
    }
    dp[0][0]=s[0][0]=='.' ? 0 : 1 ;
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        if(j<W-1){
          int nextVal=dp[i][j];
          if(s[i][j]=='.' && s[i][j+1]=='#'){
            nextVal++;
          }
          dp[i][j+1]=Math.min(dp[i][j+1],nextVal);
        }
        if(i<H-1){
          int nextVal=dp[i][j];
          if(s[i][j]=='.' && s[i+1][j]=='#'){
            nextVal++;
          }
          dp[i+1][j]=Math.min(dp[i+1][j],nextVal);
        }
      }
    }
    System.out.println(dp[H-1][W-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute INF : int := 10000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var s : Sequence(Sequence(String)) ; s := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var i : int ; i := 0 ; while i < H do ( (     var S : String ; S := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < W do ( (     s[i+1][j+1] := S->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     dp[i+1][j+1] := INF )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := if s[0+1][0+1] = '.' then 0 else 1 endif ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (j < W - 1) then (     var nextVal : int ; nextVal := dp[i+1][j+1] ;
     if (s[i+1][j+1] = '.' & s[i+1][j + 1+1] = '#') then (     nextVal := nextVal + 1 ) else skip ; 
     dp[i+1][j + 1+1] := Set{dp[i+1][j + 1+1], nextVal}->min() ) else skip ; 
     if (i < H - 1) then (     var nextVal : int ; nextVal := dp[i+1][j+1] ;
     if (s[i+1][j+1] = '.' & s[i + 1+1][j+1] = '#') then (     nextVal := nextVal + 1 ) else skip ; 
     dp[i + 1+1][j+1] := Set{dp[i + 1+1][j+1], nextVal}->min() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[H - 1+1][W - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] $){
    final Scanner s=new Scanner(System.in);
    int h=s.nextInt();
    int w=s.nextInt();
    int[][] a=new int[h+1][w+1];
    char[][] c=new char[h+1][w+1];
    Arrays.fill(a[0],99999);
    for(int i=2 ; i<=h ; ++i)a[i][0]=99999 ;
    c[1][0]='.' ;
    for(int i=1 ; i<=h ; ++i){
      String t=s.next();
      for(int j=1 ; j<=w ; ++j){
        c[i][j]=t.charAt(j-1);
        int u=(c[i][j]!=c[i-1][j] ? 1 : 0)+a[i-1][j];
        int l=(c[i][j]!=c[i][j-1] ? 1 : 0)+a[i][j-1];
        a[i][j]=Math.min(u,l);
      }
    }
    System.out.println((a[h][w]+1)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := s.getCurrent()->toInteger() ;
    var w : int ; w := s.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(0)) ;
    var c : Sequence(Sequence(String)) ; c := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(0)) ;
    a[0+1] := a[0+1]->collect(99999) ; 
        var i : int ; i := 2 ; while i <= h do (     a[i+1][0+1] := 99999 ;  ;     i := i + 1 ) ; 
    c[1+1][0+1] := '.' ; 
        var i : int ; i := 1 ; while i <= h do ( (     var t : String ; t := s.getCurrent() ;
         var j : int ; j := 1 ; while j <= w do ( (     c[i+1][j+1] := t->at((j)->char2byte() - 1+1) ; 
     var u : int ; u := (if c[i+1][j+1] /= c[i - 1+1][j+1] then 1 else 0 endif) + a[i - 1+1][j+1] ;
     var l : int ; l := (if c[i+1][j+1] /= c[i+1][(j)->char2byte() - 1+1] then 1 else 0 endif) + a[i+1][(j)->char2byte() - 1+1] ;
     a[i+1][j+1] := Set{u, l}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((a[h+1][w+1] + 1) / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int Check(char c){
    if(c=='#'){
      return 1 ;
    }
    else {
      return 0 ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int[][] dp=new int[h][w];
    String[] masu=new String[h];
    for(int i=0 ; i<h ; i++){
      masu[i]=sc.next();
    }
    if(masu[0] .charAt(0)=='#'){
      dp[0][0]=1 ;
    }
    else {
      dp[0][0]=0 ;
    }
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        if(i==0 && j==0)continue ;
        if(i==0){
          dp[i][j]=dp[i][j-1]+(dp[i][j-1] % 2==Check(masu[i] .charAt(j))? 0 : 1);
        }
        else if(j==0){
          dp[i][j]=dp[i-1][j]+(dp[i-1][j] % 2==Check(masu[i] .charAt(j))? 0 : 1);
        }
        else {
          dp[i][j]=Math.min(dp[i][j-1]+(dp[i][j-1] % 2==Check(masu[i] .charAt(j))? 0 : 1),dp[i-1][j]+(dp[i-1][j] % 2==Check(masu[i] .charAt(j))? 0 : 1));
        }
      }
    }
    System.out.println((dp[h-1][w-1]+1)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation Check( c : String) : int
  pre: true
  post: true
  activity: (     if (c = '#') then (     return 1 ) else (     return 0 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    var masu : Sequence(String) ; masu := Integer.subrange(1,h)->collect(null) ;
        var i : int ; i := 0 ; while i < h do ( (     masu[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    if (masu[0+1]->at(0+1) = '#') then (     dp[0+1][0+1] := 1 ) else (     dp[0+1][0+1] := 0 ) ;  
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (i = 0 & j = 0) then     continue else skip ; 
     if (i = 0) then (     dp[i+1][j+1] := dp[i+1][j - 1+1] + (if dp[i+1][j - 1+1] mod 2 = Check(masu[i+1]->at(j+1)) then 0 else 1 endif) ) else     if (j = 0) then (     dp[i+1][j+1] := dp[i - 1+1][j+1] + (if dp[i - 1+1][j+1] mod 2 = Check(masu[i+1]->at(j+1)) then 0 else 1 endif) ) else (     dp[i+1][j+1] := Set{dp[i+1][j - 1+1] + (if dp[i+1][j - 1+1] mod 2 = Check(masu[i+1]->at(j+1)) then 0 else 1 endif), dp[i - 1+1][j+1] + (if dp[i - 1+1][j+1] mod 2 = Check(masu[i+1]->at(j+1)) then 0 else 1 endif)}->min() ) ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((dp[h - 1+1][w - 1+1] + 1) / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    char[][] board=new char[H][W];
    for(int h=0 ; h<H ; h++){
      board[h]=sc.next().toCharArray();
    }
    int[][] shortest=new int[H][W];
    shortest[0][0]=board[0][0]=='.' ? 0 : 1 ;
    for(int h=1 ; h<H ; h++){
      if(board[h-1][0]=='.' && board[h][0]=='#')shortest[h][0]=1+shortest[h-1][0];
      else shortest[h][0]=shortest[h-1][0];
    }
    for(int w=1 ; w<W ; w++){
      if(board[0][w-1]=='.' && board[0][w]=='#')shortest[0][w]=1+shortest[0][w-1];
      else shortest[0][w]=shortest[0][w-1];
    }
    for(int h=1 ; h<H ; h++)for(int w=1 ; w<W ; w++){
      int d=board[h-1][w]=='.' && board[h][w]=='#' ? 1+shortest[h-1][w] : shortest[h-1][w];
      int r=board[h][w-1]=='.' && board[h][w]=='#' ? 1+shortest[h][w-1] : shortest[h][w-1];
      shortest[h][w]=Math.min(d,r);
    }
    System.out.println(shortest[H-1][W-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var board : Sequence(Sequence(String)) ; board := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var h : int ; h := 0 ; while h < H do ( (     board[h+1] := sc.getCurrent()->characters() )  ;     h := h + 1 ) ; 
    var shortest : Sequence(Sequence(int)) ; shortest := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
    shortest[0+1][0+1] := if board[0+1][0+1] = '.' then 0 else 1 endif ; 
        var h : int ; h := 1 ; while h < H do ( (     if (board[h - 1+1][0+1] = '.' & board[h+1][0+1] = '#') then     shortest[h+1][0+1] := 1 + shortest[h - 1+1][0+1] ; else     shortest[h+1][0+1] := shortest[h - 1+1][0+1] ; )  ;     h := h + 1 ) ; 
        var w : int ; w := 1 ; while w < W do ( (     if (board[0+1][w - 1+1] = '.' & board[0+1][w+1] = '#') then     shortest[0+1][w+1] := 1 + shortest[0+1][w - 1+1] ; else     shortest[0+1][w+1] := shortest[0+1][w - 1+1] ; )  ;     w := w + 1 ) ; 
        var h : int ; h := 1 ; while h < H do (         var w : int ; w := 1 ; while w < W do ( (     var d : int ; d := if board[h - 1+1][w+1] = '.' & board[h+1][w+1] = '#' then 1 + shortest[h - 1+1][w+1] else shortest[h - 1+1][w+1] endif ;
     var r : int ; r := if board[h+1][w - 1+1] = '.' & board[h+1][w+1] = '#' then 1 + shortest[h+1][w - 1+1] else shortest[h+1][w - 1+1] endif ;
     shortest[h+1][w+1] := Set{d, r}->min() )  ;     w := w + 1 ) ;  ;     h := h + 1 ) ; 
    OclFile["System.out"].println(shortest[H - 1+1][W - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class AloynaAndFlowers {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int mood[]=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      mood[i]=in.nextInt();
    }
    int cumulativeSum[]=new int[n+1];
    cumulativeSum[0]=mood[0];
    for(int i=1 ; i<=n ; i++){
      cumulativeSum[i]=cumulativeSum[i-1]+mood[i];
    }
    int total=0 ;
    while(m-->0){
      int l=in.nextInt();
      int r=in.nextInt();
      int sum=cumulativeSum[r]-cumulativeSum[l-1];
      if(sum>0)total+=sum ;
    }
    System.out.print(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class AloynaAndFlowers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var mood : Sequence(int) ; mood := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     mood[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cumulativeSum : Sequence(int) ; cumulativeSum := Integer.subrange(1,n + 1)->collect(0) ;
    cumulativeSum[0+1] := mood[0+1] ; 
        var i : int ; i := 1 ; while i <= n do ( (     cumulativeSum[i+1] := cumulativeSum[i - 1+1] + mood[i+1] )  ;     i := i + 1 ) ; 
    var total : int ; total := 0 ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     var l : int ; l := in.getCurrent()->toInteger() ;
     var r : int ; r := in.getCurrent()->toInteger() ;
     var sum : int ; sum := cumulativeSum[r+1] - cumulativeSum[l - 1+1] ;
     if (sum > 0) then     total := total+(sum) ; else skip ) ;  ) ;  
    OclFile["System.out"].print(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  Scanner sc=new Scanner(in);
  class A {
    int d,p ;
    A(int d,int p){
      this.d=d ;
      this.p=p ;
    }
  }
  void sort(A[] a){
    int n=a.length ;
    for(int i=n-1 ; i>0 ; i--){
      for(int j=0 ; j<i ; j++){
        if(a[j] .p<a[j+1] .p){
          A temp=a[j];
          a[j]=a[j+1];
          a[j+1]=temp ;
        }
      }
    }
  }
  void run(){
    int n,m ;
    while(true){
      n=sc.nextInt();
      m=sc.nextInt();
      if(n==0)break ;
      A[] a=new A[n];
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        int d=sc.nextInt(),p=sc.nextInt();
        a[i]=new A(d,p);
        sum+=d*p ;
      }
      sort(a);
      int guard=0 ;
      int index=0 ;
      while(m>=a[index] .d){
        m-=a[index] .d ;
        guard+=a[index] .d*a[index] .p ;
        index++;
        if(index==n){
          break ;
        }
      }
      if(index<n)guard+=m*a[index] .p ;
      out.println(sum-guard);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
 class A {
   attribute d : int;
   static operation newA( d : int, p : int) : A
  pre: true
  post: true
  activity:
  ( var self : A ;
    self := createA();
    self.initialise(d, p);
    return self );
  operation initialise( d : int, p : int) : void
  pre: true  post: true
  activity: (     self.d := d ; 
     self.p := p );
}
   operation sort( a : Sequence(A)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() ;
         var i : int ; i := n - 1 ; while i > 0 do ( (         var j : int ; j := 0 ; while j < i do ( (     if (a[j+1].p < a[j + 1+1].p) then (     var temp : A ; temp := a[j+1] ;
     a[j+1] := a[j + 1+1] ; 
     a[j + 1+1] := temp ) else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ;
    var m : int ;
     while (true) do (     n := sc.getCurrent()->toInteger() ; 
     m := sc.getCurrent()->toInteger() ; 
    if (n = 0) then     break else skip ; 
    var a : Sequence(A) ; a := Integer.subrange(1,n)->collect(null) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var d : int ; d := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
     a[i+1] := A.newA(d, p) ; 
     sum := sum+(d * p) )  ;     i := i + 1 ) ; 
    execute sort(a) ; 
    var guard : int ; guard := 0 ;
    var index : int ; index := 0 ;
    while (m >= a[index+1].d) do (     m := m-(a[index+1].d) ; 
     guard := guard+(a[index+1].d * a[index+1].p) ; 
     index := index + 1 ; 
     if (index = n) then (     break ) else skip ) ; 
    if (index < n) then     guard := guard+(m * a[index+1].p) ; else skip ; 
    out.println(sum - guard) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MaxExpr {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    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 total_happiness=0 ;
    int cummSum[]=new int[n+1];
    cummSum[1]=arr[0];
    for(int i=2 ; i<=n ; i++){
      cummSum[i]=cummSum[i-1]+arr[i-1];
    }
    for(int i=0 ; i<m ; i++){
      int l=sc.nextInt();
      int r=sc.nextInt();
      int sum=0 ;
      sum=cummSum[r]-cummSum[l-1];
      if(sum>0)total_happiness+=sum ;
    }
    System.out.println(total_happiness);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class MaxExpr {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var total_happiness : int ; total_happiness := 0 ;
    var cummSum : Sequence(int) ; cummSum := Integer.subrange(1,n + 1)->collect(0) ;
    cummSum[1+1] := arr[0+1] ; 
        var i : int ; i := 2 ; while i <= n do ( (     cummSum[i+1] := cummSum[i - 1+1] + arr[i - 1+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    sum := cummSum[r+1] - cummSum[l - 1+1] ; 
    if (sum > 0) then     total_happiness := total_happiness+(sum) ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total_happiness) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int[] a=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      a[i]=in.nextInt();
    }
    int[] preSum=new int[n+1];
    preSum[0]=0 ;
    for(int i=1 ; i<=n ; i++){
      preSum[i]=preSum[i-1]+a[i];
    }
    int ans=0 ;
    while(m>0){
      int l=in.nextInt();
      int r=in.nextInt();
      int sum=0 ;
      if(l!=0){
        sum=preSum[r]-preSum[l-1];
      }
      else {
        sum=preSum[r];
      }
      m--;
      if(sum>0){
        ans+=sum ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var preSum : Sequence(int) ; preSum := Integer.subrange(1,n + 1)->collect(0) ;
    preSum[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (     preSum[i+1] := preSum[i - 1+1] + a[i+1] )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    while (m > 0) do (     var l : int ; l := in.getCurrent()->toInteger() ;
     var r : int ; r := in.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    if (l /= 0) then (     sum := preSum[r+1] - preSum[l - 1+1] ) else (     sum := preSum[r+1] ) ;  
    m := m - 1 ; 
    if (sum > 0) then (     ans := ans+(sum) ) else skip ; 
 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MaxExpr {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    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 total_happiness=0 ;
    int cummSum[]=new int[n+1];
    cummSum[0]=0 ;
    for(int i=1,j=0 ; i<=n ; i++,j++){
      cummSum[i]=cummSum[i-1]+arr[j];
    }
    for(int i=0 ; i<m ; i++){
      int l=sc.nextInt();
      int r=sc.nextInt();
      int sum=0 ;
      sum=cummSum[r]-cummSum[l-1];
      if(sum>0)total_happiness+=sum ;
    }
    System.out.println(total_happiness);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class MaxExpr {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var total_happiness : int ; total_happiness := 0 ;
    var cummSum : Sequence(int) ; cummSum := Integer.subrange(1,n + 1)->collect(0) ;
    cummSum[0+1] := 0 ; 
        var i : int ; i := 1 ;
    var j : int ; j := 0 ; while i <= n do ( (     cummSum[i+1] := cummSum[i - 1+1] + arr[j+1] )  ;     i := i + 1 ;     j := j + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    sum := cummSum[r+1] - cummSum[l - 1+1] ; 
    if (sum > 0) then     total_happiness := total_happiness+(sum) ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total_happiness) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static int maxHappiness=0 ;
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int subarr=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    while(subarr-->0){
      int l=sc.nextInt();
      int r=sc.nextInt();
      findHappiness(arr,l-1,r-1,0);
    }
    System.out.println(maxHappiness);
  }
  public static void findHappiness(int[] arr,int left,int right,int sum){
    for(int i=left ; i<=right ; i++){
      sum+=arr[i];
    }
    if(sum>0)maxHappiness+=sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute maxHappiness : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var subarr : int ; subarr := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        while (subarr > 0) do (        subarr := subarr - 1 ;     skip ; (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
     execute findHappiness(arr, l - 1, r - 1, 0) ) ;  ) ;  
    OclFile["System.out"].println(maxHappiness) ; 
 );
  static   operation findHappiness( arr : Sequence(int), left : int, right : int, sum : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := left ; while i <= right do ( (     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
     if (sum > 0) then     maxHappiness := maxHappiness+(sum) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int space=sc.nextInt();
      String[][] room=new String[n][m];
      for(int i=0 ; i<n ; i++){
        String s=sc.next();
        for(int j=0 ; j<m ; j++){
          room[i][j]=s.substring(j,j+1);
        }
      }
      int count=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<m ; j++){
          if(room[i][j] .equals(".")){
            if(j<m-space+1){
              boolean flag=true ;
              for(int k=0 ; k<space ; k++){
                if(! room[i][j] .equals(room[i][j+k]))flag=false ;
              }
              if(flag)count++;
            }
            if(i<n-space+1){
              boolean flag=true ;
              for(int k=0 ; k<space ; k++){
                if(! room[i][j] .equals(room[i+k][j]))flag=false ;
              }
              if(flag)count++;
            }
          }
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var space : int ; space := sc.getCurrent()->toInteger() ;
    var room : Sequence(Sequence(String)) ; room := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(null)) ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < m do ( (     room[i+1][j+1] := s.subrange(j+1,j + 1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (room[i+1][j+1] = ".") then (     if (j < m - space + 1) then (     var flag : boolean ; flag := true ;
         var k : int ; k := 0 ; while k < space do ( (     if (not(room[i+1][j+1] = room[i+1][j + k+1])) then     flag := false ; else skip )  ;     k := k + 1 ) ; 
     if (flag) then     count := count + 1 ; else skip ) else skip ; 
     if (i < n - space + 1) then (     var flag : boolean ; flag := true ;
         var k : int ; k := 0 ; while k < space do ( (     if (not(room[i+1][j+1] = room[i + k+1][j+1])) then     flag := false ; else skip )  ;     k := k + 1 ) ; 
     if (flag) then     count := count + 1 ; else skip ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GfG {
  static int two_factor(int n){
    int twocount=0 ;
    while(n % 2==0){
      twocount++;
      n=n/2 ;
    }
    return twocount ;
  }
  static int five_factor(int n){
    int fivecount=0 ;
    while(n % 5==0){
      fivecount++;
      n=n/5 ;
    }
    return fivecount ;
  }
  static int find_con_zero(int arr[],int n){
    int twocount=0 ;
    int fivecount=0 ;
    for(int i=0 ; i<n ; i++){
      twocount+=two_factor(arr[i]);
      fivecount+=five_factor(arr[i]);
    }
    if(twocount<fivecount)return twocount ;
    else return fivecount ;
  }
  public static void main(String s[]){
    int arr[]={
      100,10,5,25,35,14 };
      int n=6 ;
      System.out.println(find_con_zero(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation two_factor( n : int) : int
  pre: true
  post: true
  activity: (     var twocount : int ; twocount := 0 ;
     while (n mod 2 = 0) do (     twocount := twocount + 1 ; 
     n := n / 2 ) ; 
     return twocount );
  static   operation five_factor( n : int) : int
  pre: true
  post: true
  activity: (     var fivecount : int ; fivecount := 0 ;
     while (n mod 5 = 0) do (     fivecount := fivecount + 1 ; 
     n := n / 5 ) ; 
     return fivecount );
  static   operation find_con_zero( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var twocount : int ; twocount := 0 ;
     var fivecount : int ; fivecount := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     twocount := twocount+(two_factor(arr[i+1])) ; 
     fivecount := fivecount+(five_factor(arr[i+1])) )  ;     i := i + 1 ) ; 
     if (twocount < fivecount) then     return twocount else     return fivecount );
  static   operation main( s : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{100,10,5,25,35,14} ;
     var n : int ; n := 6 ;
     OclFile["System.out"].println(find_con_zero(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int Max_Xor(int arr[],int n,int k){
    int maxXor=Integer.MIN_VALUE ;
    for(int i=0 ; i<(1<<n); i++){
      if(Integer.bitCount(i)==k){
        int cur_xor=0 ;
        for(int j=0 ; j<n ; j++){
          if((i &(1<<j))==0)cur_xor=cur_xor ^ arr[j];
        }
        maxXor=Math.max(maxXor,cur_xor);
      }
    }
    return maxXor ;
  }
  public static void main(String[] args){
    int arr[]={
      2,5,4,1,3,7,6,8 };
      int n=arr.length ;
      int k=3 ;
      System.out.println(Max_Xor(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Max_Xor( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var maxXor : int ; maxXor := -2147483648 ;
         var i : int ; i := 0 ; while i < ((1*(2->pow(n)))->oclAsType(long)) do ( (     if (bitCount(i) = k) then (     var cur_xor : int ; cur_xor := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd(i,((1*(2->pow(j)))->oclAsType(long)))) = 0) then     cur_xor := MathLib.bitwiseXor(cur_xor,arr[j+1]) ; else skip )  ;     j := j + 1 ) ; 
     maxXor := Set{maxXor, cur_xor}->max() ) else skip )  ;     i := i + 1 ) ; 
     return maxXor );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,5,4,1,3,7,6,8} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println(Max_Xor(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int ksmallest(int arr[],int n,int k){
    for(int i=0 ; i<n ; i++){
      if(arr[i]<=k)k++;
      else break ;
    }
    return k ;
  }
  public static void main(String args[]){
    int k=1 ;
    int arr[]={
      1 };
      int n=arr.length ;
      System.out.println(ksmallest(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation ksmallest( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] <= k) then     k := k + 1 ; else     break )  ;     i := i + 1 ) ; 
     return k );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 1 ;
     var arr : Sequence(int) ; arr := Sequence{1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(ksmallest(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sum(int arr[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=arr[i];
    }
    sum=sum*(int)Math.pow(2,n-1);
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      2,1,5,6 };
      int n=arr.length ;
      System.out.println(sum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
     sum := sum * 2->pow(n - 1)->oclAsType(int) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,1,5,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(sum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  final static int INT_MIN=Integer.MIN_VALUE ;
  static int maxSum(int a[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=a[i];
    int limit=2*sum+1 ;
    int dp[][]=new int[n+1][limit];
    for(int i=0 ; i<n+1 ; i++){
      for(int j=0 ; j<limit ; j++)dp[i][j]=INT_MIN ;
    }
    dp[0][sum]=0 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=0 ; j<limit ; j++){
        if((j-a[i-1])>=0 && dp[i-1][j-a[i-1] ]!=INT_MIN)dp[i][j]=Math.max(dp[i][j],dp[i-1][j-a[i-1] ]+a[i-1]);
        if((j+a[i-1])<limit && dp[i-1][j+a[i-1] ]!=INT_MIN)dp[i][j]=Math.max(dp[i][j],dp[i-1][j+a[i-1] ]);
        if(dp[i-1][j]!=INT_MIN)dp[i][j]=Math.max(dp[i][j],dp[i-1][j]);
      }
    }
    return dp[n][sum];
  }
  public static void main(String[] args){
    int n=4 ;
    int[] a={
      1,2,3,6 };
      System.out.println(maxSum(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute INT_MIN : int := -2147483648;
  static   operation maxSum( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+(a[i+1]) ;  ;     i := i + 1 ) ; 
    var limit : int ; limit := 2 * sum + 1 ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,limit)->collect(0)) ;
        var i : int ; i := 0 ; while i < n + 1 do ( (         var j : int ; j := 0 ; while j < limit do (     dp[i+1][j+1] := INT_MIN ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    dp[0+1][sum+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 0 ; while j < limit do ( (     if ((j - a[i - 1+1]) >= 0 & dp[i - 1+1][j - a[i - 1+1]+1] /= INT_MIN) then     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i - 1+1][j - a[i - 1+1]+1] + a[i - 1+1]}->max() ; else skip ; 
     if ((j + a[i - 1+1]) < limit & dp[i - 1+1][j + a[i - 1+1]+1] /= INT_MIN) then     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i - 1+1][j + a[i - 1+1]+1]}->max() ; else skip ; 
     if (dp[i - 1+1][j+1] /= INT_MIN) then     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i - 1+1][j+1]}->max() ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return dp[n+1][sum+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var a : Sequence(int) ; a := Sequence{1,2,3,6} ;
     OclFile["System.out"].println(maxSum(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    PriorityQueue<Integer>front=new PriorityQueue<>();
    PriorityQueue<Integer>back=new PriorityQueue<>();
    int[] arr=new int[n];
    long frontSum=0 ;
    long backSum=0 ;
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      frontSum+=x ;
      front.add(x);
    }
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      backSum+=x ;
      back.add(-x);
    }
    long[] values=new long[n+1];
    values[0]=frontSum ;
    values[n]=-backSum ;
    for(int i=0 ; i<n ; i++){
      frontSum+=arr[i];
      front.add(arr[i]);
      frontSum-=front.poll();
      values[i+1]+=frontSum ;
      backSum+=arr[n-i-1];
      back.add(-arr[n-i-1]);
      backSum+=back.poll();
      values[n-i-1]-=backSum ;
    }
    long max=Long.MIN_VALUE ;
    for(int i=0 ; i<=n ; i++){
      max=Math.max(max,values[i]);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var front : Sequence(int) ; front := Sequence{} ;
    var back : Sequence(int) ; back := Sequence{} ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var frontSum : long ; frontSum := 0 ;
    var backSum : long ; backSum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     frontSum := frontSum+(x) ; 
     front := front->including(x) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     backSum := backSum+(x) ; 
     back := back->including(-x) )  ;     i := i + 1 ) ; 
    var values : Sequence(long) ; values := Integer.subrange(1,n + 1)->collect(0) ;
    values[0+1] := frontSum ; 
    values[n+1] := -backSum ; 
        var i : int ; i := 0 ; while i < n do ( (     frontSum := frontSum+(arr[i+1]) ; 
     front := front->including(arr[i+1]) ; 
    frontSum := frontSum - (front->min()) ;     front := front->sort()->tail() ; 
    values[i + 1+1] := values[i + 1+1]+(frontSum) ; 
    backSum := backSum+(arr[n - i - 1+1]) ; 
    back := back->including(-arr[n - i - 1+1]) ; 
    backSum := backSum + back->min() ;     back := back->sort()->tail() ; 
    values[n - i - 1+1] := values[n - i - 1+1]-(backSum) ; 
 )  ;     i := i + 1 ) ; 
    var max : long ; max := "-9223372036854775808"->toLong() ;
        var i : int ; i := 0 ; while i <= n do ( (     max := Set{max, values[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class symmat {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int count=0 ;
      for(int i=0 ; i<n ; i++){
        int a=sc.nextInt();
        int b=sc.nextInt();
        int c=sc.nextInt();
        int d=sc.nextInt();
        if(b==c){
          count=1 ;
        }
      }
      if(count==1 && m % 2==0)System.out.println("YES");
      else System.out.println("NO");
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class symmat {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    if (b = c) then (     count := 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (count = 1 & m mod 2 = 0) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class USBPS2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int usb=sc.nextInt();
    int ps2=sc.nextInt();
    int both=sc.nextInt();
    int n=sc.nextInt();
    PriorityQueue<Integer>usbPrices=new PriorityQueue<Integer>();
    PriorityQueue<Integer>ps2Prices=new PriorityQueue<Integer>();
    for(int i=0 ; i<n ; i++){
      int price=sc.nextInt();
      String type=sc.next();
      if(type.equals("USB")){
        usbPrices.add(price);
      }
      else {
        ps2Prices.add(price);
      }
    }
    int min=Math.min(usb,usbPrices.size());
    int count=0 ;
    long totalPrice=0 ;
    for(int i=0 ; i<min ; i++){
      int x=usbPrices.poll();
      totalPrice+=x ;
      count++;
    }
    min=Math.min(ps2,ps2Prices.size());
    for(int i=0 ; i<min ; i++){
      int x=ps2Prices.poll();
      totalPrice+=x ;
      count++;
    }
    PriorityQueue<Integer>bothPrices=new PriorityQueue<Integer>();
    for(int i : usbPrices){
      bothPrices.add(i);
    }
    for(int i : ps2Prices){
      bothPrices.add(i);
    }
    min=Math.min(both,bothPrices.size());
    for(int i=0 ; i<min ; i++){
      int x=bothPrices.poll();
      totalPrice+=x ;
      count++;
    }
    System.out.println(count+" "+totalPrice);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class USBPS2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var usb : int ; usb := sc.getCurrent()->toInteger() ;
    var ps2 : int ; ps2 := sc.getCurrent()->toInteger() ;
    var both : int ; both := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var usbPrices : Sequence(int) ; usbPrices := Sequence{} ;
    var ps2Prices : Sequence(int) ; ps2Prices := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var price : int ; price := sc.getCurrent()->toInteger() ;
     var type : String ; type := sc.getCurrent() ;
     if (type = "USB") then (     usbPrices := usbPrices->including(price) ) else (     ps2Prices := ps2Prices->including(price) ) )  ;     i := i + 1 ) ; 
    var min : int ; min := Set{usb, usbPrices->size()}->min() ;
    var count : int ; count := 0 ;
    var totalPrice : long ; totalPrice := 0 ;
        var i : int ; i := 0 ; while i < min do ( (     var x : int ; x := usbPrices->min() ;
     totalPrice := totalPrice+(x) ; 
     count := count + 1 )  ;     i := i + 1 ) ; 
    min := Set{ps2, ps2Prices->size()}->min() ; 
        var i : int ; i := 0 ; while i < min do ( (     var x : int ; x := ps2Prices->min() ;
     totalPrice := totalPrice+(x) ; 
     count := count + 1 )  ;     i := i + 1 ) ; 
    var bothPrices : Sequence(int) ; bothPrices := Sequence{} ;
    for (i : usbPrices) do ( (     bothPrices := bothPrices->including(i) )  ) ; 
    for (i : ps2Prices) do ( (     bothPrices := bothPrices->including(i) )  ) ; 
    min := Set{both, bothPrices->size()}->min() ; 
        var i : int ; i := 0 ; while i < min do ( (     var x : int ; x := bothPrices->min() ;
     totalPrice := totalPrice+(x) ; 
     count := count + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count + " " + totalPrice) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String strBitwiseOR(String[] arr,int n){
    String res="" ;
    int max_size=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      max_size=Math.max(max_size,(int)arr[i] .length());
      arr[i]=reverse(arr[i]);
    }
    for(int i=0 ; i<n ; i++){
      String s="" ;
      for(int j=0 ; j<max_size-arr[i] .length(); j++)s+='0' ;
      arr[i]=arr[i]+s ;
    }
    for(int i=0 ; i<max_size ; i++){
      int curr_bit=0 ;
      for(int j=0 ; j<n ; j++)curr_bit=curr_bit |(arr[j] .charAt(i)-'0');
      res+=(char)(curr_bit+'0');
    }
    res=reverse(res);
    return res ;
  }
  static String reverse(String input){
    char[] temparray=input.toCharArray();
    int left,right=0 ;
    right=temparray.length-1 ;
    for(left=0 ; left<right ; left++,right--){
      char temp=temparray[left];
      temparray[left]=temparray[right];
      temparray[right]=temp ;
    }
    return String.valueOf(temparray);
  }
  public static void main(String[] args){
    String arr[]={
      "10","11","1000001" };
      int n=arr.length ;
      System.out.println(strBitwiseOR(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation strBitwiseOR( arr : Sequence(String), n : int) : String
  pre: true
  post: true
  activity: (     var res : String ; res := "" ;
     var max_size : int ; max_size := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     max_size := Set{max_size, arr[i+1]->size()->oclAsType(int)}->max() ; 
     arr[i+1] := reverse(arr[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := "" ;
         var j : int ; j := 0 ; while j < (max_size)->char2byte() - arr[i+1]->size() do (     s := s+('0') ;  ;     j := j + 1 ) ; 
     arr[i+1] := arr[i+1] + s )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < max_size do ( (     var curr_bit : int ; curr_bit := 0 ;
         var j : int ; j := 0 ; while j < n do (     curr_bit := MathLib.bitwiseOr(curr_bit,(arr[j+1]->at(i+1) - ('0')->char2byte())) ;  ;     j := j + 1 ) ; 
     res := res+((curr_bit + '0')->oclAsType(String)) )  ;     i := i + 1 ) ; 
    res := reverse(res) ; 
    return res 
 );
  static   operation reverse( input : String) : String
  pre: true
  post: true
  activity: (     var temparray : Sequence(String) ; temparray := input->characters() ;
     var left : int ;
    var right : int ; right := 0 ;
    right := temparray->size() - 1 ; 
        left := 0 ; while left < right do ( (     var temp : String ; temp := temparray[left+1] ;
     temparray[left+1] := temparray[right+1] ; 
     temparray[right+1] := temp )  ;     left := left + 1 ;     right := right - 1 ) ; 
    return (temparray)->sum()  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"10","11","1000001"} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(strBitwiseOR(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void check(int arr[],int N){
    int even=0 ;
    int odd=0 ;
    for(int i=0 ; i<N ; i++){
      if(arr[i] % 2==1){
        odd++;
      }
      else {
        even++;
      }
    }
    if(even==N || odd==N)System.out.print("Yes");
    else System.out.print("No");
  }
  public static void main(String[] args){
    int arr[]={
      1,1,3 };
      int N=arr.length ;
      check(arr,N);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( arr : Sequence(int), N : int) : void
  pre: true
  post: true
  activity: (     var even : int ; even := 0 ;
     var odd : int ; odd := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     if (arr[i+1] mod 2 = 1) then (     odd := odd + 1 ) else (     even := even + 1 ) )  ;     i := i + 1 ) ; 
     if (even = N or odd = N) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,3} ;
     var N : int ; N := arr->size() ;
     execute check(arr, N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    int[] leftMost=new int[n],rightMost=new int[n];
    int maxFloor=-1 ;
    Arrays.fill(leftMost,m+1);
    for(int i=n-1 ; i>=0 ; --i){
      String s=sc.next();
      for(int j=0 ; j<m+2 ; ++j)if(s.charAt(j)=='1'){
        rightMost[i]=j ;
        if(maxFloor==-1)maxFloor=i ;
      }
      for(int j=m+1 ; j>=0 ; --j)if(s.charAt(j)=='1')leftMost[i]=j ;
    }
    int ans=10000000 ;
    for(int stairs=0 ; stairs<(1<<n-1); ++stairs){
      int cur=0,room=0,floor=0 ;
      while(floor<=maxFloor){
        if(room==0){
          cur+=rightMost[floor]-room ;
          room=rightMost[floor];
        }
        else {
          cur+=room-leftMost[floor];
          room=leftMost[floor];
        }
        if(floor==maxFloor)break ;
        int nxtStairs=(stairs &(1<<floor))==0 ? 0 : m+1 ;
        cur+=Math.abs(nxtStairs-room)+1 ;
        room=nxtStairs ;
++floor ;
      }
      ans=Math.min(ans,cur);
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var leftMost : Sequence(int) ; leftMost := Integer.subrange(1,n)->collect(0) ;
    var rightMost : Sequence(int) ; rightMost := Integer.subrange(1,n)->collect(0) ;
    var maxFloor : int ; maxFloor := -1 ;
    leftMost := leftMost->collect(m + 1) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     var s : String ; s := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < m + 2 do (     if (s->at(j+1) = '1') then (     rightMost[i+1] := j ; 
     if (maxFloor = -1) then     maxFloor := i ; else skip ) else skip ;  ;     j := j + 1 ) ; 
         var j : int ; j := m + 1 ; while j >= 0 do (     if (s->at(j+1) = '1') then     leftMost[i+1] := j ; else skip ;  ;     j := j - 1 ) )  ;     i := i - 1 ) ; 
    var ans : int ; ans := 10000000 ;
        var stairs : int ; stairs := 0 ; while stairs < ((1*(2->pow(n - 1)))->oclAsType(long)) do ( (     var cur : int ; cur := 0 ;
    var room : int ; room := 0 ;
    var floor : int ; floor := 0 ;
     while (floor <= maxFloor) do (     if (room = 0) then (     cur := cur+(rightMost[floor+1] - room) ; 
     room := rightMost[floor+1] ) else (     cur := cur+(room - leftMost[floor+1]) ; 
     room := leftMost[floor+1] ) ;  
     if (floor = maxFloor) then     break else skip ; 
    var nxtStairs : int ; nxtStairs := if (MathLib.bitwiseAnd(stairs,((1*(2->pow(floor)))->oclAsType(long)))) = 0 then 0 else m + 1 endif ;
    cur := cur+(if nxtStairs - room < 0 then -(nxtStairs - room) else nxtStairs - room endif + 1) ; 
    room := nxtStairs ; 
    floor := floor + 1 ; 
 ) ; 
     ans := Set{ans, cur}->min() )  ;     stairs := stairs + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int H=sc.nextInt();
    int W=sc.nextInt();
    int space=sc.nextInt();
    char[][] map=new char[H][W];
    for(int i=0 ; i<H ; i++){
      map[i]=sc.next().toCharArray();
    }
    int total=0 ;
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        if(map[i][j]=='.'){
          boolean Ver=true ;
          for(int k=1 ; k<space ; k++){
            if(i+k>=H){
              Ver=false ;
              break ;
            }
            if(map[i+k][j]=='#'){
              Ver=false ;
            }
          }
          if(Ver){
            total++;
          }
          boolean Hor=true ;
          for(int k=1 ; k<space ; k++){
            if(j+k>=W){
              Hor=false ;
              break ;
            }
            if(map[i][j+k]=='#'){
              Hor=false ;
            }
          }
          if(Hor){
            total++;
          }
        }
      }
    }
    out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var H : int ; H := sc.getCurrent()->toInteger() ;
     var W : int ; W := sc.getCurrent()->toInteger() ;
    var space : int ; space := sc.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(String)) ; map := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var i : int ; i := 0 ; while i < H do ( (     map[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (map[i+1][j+1] = '.') then (     var Ver : boolean ; Ver := true ;
         var k : int ; k := 1 ; while k < space do ( (     if (i + k >= H) then (     Ver := false ; 
     break ) else skip ; 
     if (map[i + k+1][j+1] = '#') then (     Ver := false ) else skip )  ;     k := k + 1 ) ; 
    if (Ver) then (     total := total + 1 ) else skip ; 
    var Hor : boolean ; Hor := true ;
        var k : int ; k := 1 ; while k < space do ( (     if (j + k >= W) then (     Hor := false ; 
     break ) else skip ; 
     if (map[i+1][j + k+1] = '#') then (     Hor := false ) else skip )  ;     k := k + 1 ) ; 
    if (Hor) then (     total := total + 1 ) else skip ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    out.println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    int[] leftMost=new int[n],rightMost=new int[n];
    int maxFloor=-1 ;
    Arrays.fill(leftMost,m+1);
    for(int i=n-1 ; i>=0 ; --i){
      String s=sc.next();
      for(int j=0 ; j<m+2 ; ++j)if(s.charAt(j)=='1'){
        rightMost[i]=j ;
        if(maxFloor==-1)maxFloor=i ;
      }
      for(int j=m+1 ; j>=0 ; --j)if(s.charAt(j)=='1')leftMost[i]=j ;
    }
    int ans=10000000 ;
    for(int stairs=0 ; stairs<(1<<n-1); ++stairs){
      int cur=0,room=0,floor=0 ;
      while(floor<=maxFloor){
        if(room==0){
          cur+=rightMost[floor]-room ;
          room=rightMost[floor];
        }
        else {
          cur+=room-leftMost[floor];
          room=leftMost[floor];
        }
        if(floor==maxFloor)break ;
        int nxtStairs=(stairs &(1<<floor))==0 ? 0 : m+1 ;
        cur+=Math.abs(nxtStairs-room)+1 ;
        room=nxtStairs ;
++floor ;
      }
      ans=Math.min(ans,cur);
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var leftMost : Sequence(int) ; leftMost := Integer.subrange(1,n)->collect(0) ;
    var rightMost : Sequence(int) ; rightMost := Integer.subrange(1,n)->collect(0) ;
    var maxFloor : int ; maxFloor := -1 ;
    leftMost := leftMost->collect(m + 1) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     var s : String ; s := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < m + 2 do (     if (s->at(j+1) = '1') then (     rightMost[i+1] := j ; 
     if (maxFloor = -1) then     maxFloor := i ; else skip ) else skip ;  ;     j := j + 1 ) ; 
         var j : int ; j := m + 1 ; while j >= 0 do (     if (s->at(j+1) = '1') then     leftMost[i+1] := j ; else skip ;  ;     j := j - 1 ) )  ;     i := i - 1 ) ; 
    var ans : int ; ans := 10000000 ;
        var stairs : int ; stairs := 0 ; while stairs < ((1*(2->pow(n - 1)))->oclAsType(long)) do ( (     var cur : int ; cur := 0 ;
    var room : int ; room := 0 ;
    var floor : int ; floor := 0 ;
     while (floor <= maxFloor) do (     if (room = 0) then (     cur := cur+(rightMost[floor+1] - room) ; 
     room := rightMost[floor+1] ) else (     cur := cur+(room - leftMost[floor+1]) ; 
     room := leftMost[floor+1] ) ;  
     if (floor = maxFloor) then     break else skip ; 
    var nxtStairs : int ; nxtStairs := if (MathLib.bitwiseAnd(stairs,((1*(2->pow(floor)))->oclAsType(long)))) = 0 then 0 else m + 1 endif ;
    cur := cur+(if nxtStairs - room < 0 then -(nxtStairs - room) else nxtStairs - room endif + 1) ; 
    room := nxtStairs ; 
    floor := floor + 1 ; 
 ) ; 
     ans := Set{ans, cur}->min() )  ;     stairs := stairs + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void printNumbers(int n,int d){
    String st=""+d ;
    char ch=st.charAt(0);
    for(int i=0 ; i<=n ; i++){
      st="" ;
      st=st+i ;
      if(i==d || st.indexOf(ch)>=0)System.out.print(i+" ");
    }
  }
  public static void main(String[] args){
    int n=100,d=5 ;
    printNumbers(n,d);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printNumbers( n : int, d : int) : void
  pre: true
  post: true
  activity: (     var st : String ; st := "" + d ;
     var ch : String ; ch := st->at(0+1) ;
         var i : int ; i := 0 ; while i <= n do ( (     st := "" ; 
     st := st + i ; 
     if (i = d or st->indexOf(ch)-1 >= 0) then     OclFile["System.out"].print(i + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 100 ;
    var d : int ; d := 5 ;
     execute printNumbers(n, d) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    int t=0 ;
    int ans=-1 ;
    while(true){
      int nt=t+A ;
      while(C<t)C+=60 ;
      if(t<=C && C<=nt){
        ans=C ;
        break ;
      }
      t=nt+B ;
      if(t % 60==0)break ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var t : int ; t := 0 ;
    var ans : int ; ans := -1 ;
    while (true) do (     var nt : int ; nt := t + A ;
     while (C < t) do     C := C+(60) ; ; 
    if (t <= C & C <= nt) then (     ans := C ; 
     break ) else skip ; 
    t := nt + B ; 
    if (t mod 60 = 0) then     break else skip ; 
 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  private final java.util.Scanner sc ;
  private final java.io.PrintStream out ;
  public Main(java.io.InputStream in,java.io.PrintStream out){
    this.sc=new java.util.Scanner(in);
    this.out=out ;
  }
  public void run(){
    final int a=sc.nextInt();
    final int b=sc.nextInt();
    final int c=sc.nextInt();
    final boolean[] d=new boolean[60];
    int rval=0 ;
    for(int s=0 ; ; ){
      if(d[s]){
        rval=-1 ;
        break ;
      }
      d[s]=true ;
      if(s<=c && c<=s+a){
        rval+=c ;
        break ;
      }
      s+=a ;
      if(60<=s){
        rval+=60 ;
        s-=60 ;
        if(c<=s){
          rval+=c ;
          break ;
        }
      }
      s+=b ;
      if(60<=s){
        s-=60 ;
        rval+=60 ;
      }
    }
    out.println(rval);
  }
  public static void main(String[] args){
(new Main(System.in,System.out)).run();
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   attribute sc : Scanner;
   attribute out : PrintStream;
   static operation newMain( in : InputStream, out : PrintStream) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(in, out);
    return self );
  operation initialise( in : InputStream, out : PrintStream) : void
  pre: true  post: true
  activity: (     self.sc := Scanner.newScanner(in) ; 
     self.out := out );
   operation run() : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.nextInt() ;
     var b : int ; b := sc.nextInt() ;
    var c : int ; c := sc.nextInt() ;
    var d : Sequence(boolean) ; d := Integer.subrange(1,60)->collect(false) ;
    var rval : int ; rval := 0 ;
        var s : int ; s := 0 ; while true do ( (     if (d[s+1]) then (     rval := -1 ; 
     break ) else skip ; 
     d[s+1] := true ; 
    if (s <= c & c <= s + a) then (     rval := rval+(c) ; 
     break ) else skip ; 
    s := s+(a) ; 
    if (60 <= s) then (     rval := rval+(60) ; 
     s := s-(60) ; 
     if (c <= s) then (     rval := rval+(c) ; 
     break ) else skip ) else skip ; 
    s := s+(b) ; 
    if (60 <= s) then (     s := s-(60) ; 
     rval := rval+(60) ) else skip ; 
 )  ) ; 
    out.println(rval) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain(OclFile["System.in"], OclFile["System.out"])).run() );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      int[] a=IntStream.range(0,3*n).map(i->scanner.nextInt()).toArray();
      long[] result1=new long[n+1],result2=new long[n+1];
      Queue<Integer>minQueue=new PriorityQueue<>((x,y)->x.compareTo(y));
      result1[0]=IntStream.range(0,n).mapToLong(i->(long)a[i]).sum();
      Queue<Integer>maxQueue=new PriorityQueue<>((x,y)->y.compareTo(x));
      result2[n]=IntStream.range(2*n,3*n).mapToLong(i->(long)a[i]).sum();
      IntStream.range(0,n).forEach(i->{
        minQueue.add(a[i]);
        maxQueue.add(a[3*n-i-1]);
      }
);
      IntStream.rangeClosed(1,n).forEach(i->{
        minQueue.add(a[n+i-1]);
        result1[i]=result1[i-1]+a[n+i-1]-minQueue.poll();
        maxQueue.add(a[n+n-i]);
        result2[n-i]=result2[n-i+1]+a[n+n-i]-maxQueue.poll();
      }
);
      System.out.println(IntStream.rangeClosed(0,n).mapToLong(i->result1[i]-result2[i]).max().getAsLong());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(0, 3 * n-1)->collect( _x1 | (lambda i : OclAny in scanner.getCurrent()->toInteger())->apply(_x1) )->asSequence() ;
    var result1 : Sequence(long) ; result1 := Integer.subrange(1,n + 1)->collect(0) ;
    var result2 : Sequence(long) ; result2 := Integer.subrange(1,n + 1)->collect(0) ;
    var minQueue : Sequence(int) ; minQueue := Sequence{}->union(lambda (x , y) : OclAny in x->compareTo(y)) ;
    result1[0+1] := Integer.subrange(0, n-1)->collect( _x1 | (lambda i : OclAny in a[i+1]->oclAsType(long))->apply(_x1) )->sum() ; 
    var maxQueue : Sequence(int) ; maxQueue := Sequence{}->union(lambda (x , y) : OclAny in y->compareTo(x)) ;
    result2[n+1] := Integer.subrange(2 * n, 3 * n-1)->collect( _x1 | (lambda i : OclAny in a[i+1]->oclAsType(long))->apply(_x1) )->sum() ; 
    for i : Integer.subrange(0, n-1) do
    (    skip) ; 
    for i : Integer.subrange(1, n) do
    (    skip) ; 
    OclFile["System.out"].println(Integer.subrange(0, n)->collect( _x1 | (lambda i : OclAny in result1[i+1] - result2[i+1])->apply(_x1) ).max().getAsLong()) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.Closeable ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.LinkedHashMap ;
import java.util.LinkedHashSet ;
import java.util.LinkedList ;
import java.util.Map ;
import java.util.Map.Entry ;
import java.util.PriorityQueue ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    final int a=sc.nextInt();
    final int b=sc.nextInt();
    final int c=sc.nextInt();
    final int cycle=(a+b);
    boolean[] visited=new boolean[cycle];
    for(long sum_time=c ; ; sum_time+=60){
      final int mod_time=(int)(sum_time % cycle);
      if(visited[mod_time]){
        System.out.println(-1);
        break ;
      }
      visited[mod_time]=true ;
      if(mod_time<=a){
        System.out.println(sum_time);
        break ;
      }
    }
  }
  public static class Scanner implements Closeable {
    private BufferedReader br ;
    private StringTokenizer tok ;
    public Scanner(InputStream is)throws IOException {
      br=new BufferedReader(new InputStreamReader(is));
    }
    private void getLine()throws IOException {
      while(! hasNext()){
        tok=new StringTokenizer(br.readLine());
      }
    }
    private boolean hasNext(){
      return tok!=null && tok.hasMoreTokens();
    }
    public String next()throws IOException {
      getLine();
      return tok.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public void close()throws IOException {
      br.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var cycle : int ; cycle := (a + b) ;
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,cycle)->collect(false) ;
        var sum_time : long ; sum_time := c ; while true do ( (     var mod_time : int ; mod_time := (sum_time mod cycle)->oclAsType(int) ;
     if (visited[mod_time+1]) then (     OclFile["System.out"].println(-1) ; 
     break ) else skip ; 
     visited[mod_time+1] := true ; 
     if (mod_time <= a) then (     OclFile["System.out"].println(sum_time) ; 
     break ) else skip )  ;     sum_time := sum_time+(60) ) ; 
 );
  static class Scanner implements Closeable {
   attribute br : OclFile;
   attribute tok : OclIterator;
   static operation newScanner( is : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
   operation getLine() : void
  pre: true
  post: true
  activity: (     while (not(hasNext())) do (     tok := OclIterator.newOclIterator_String(br.readLine()) ) );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return tok /= null & tok.hasNext() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute getLine() ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static void solve(){
    int a=in.nextInt();
    int b=in.nextInt();
    int c=in.nextInt();
    int pos=0,ans=0 ;
    for(int i=0 ; i<200 ; i++){
      if(i % 2==0){
        if(pos+a>=60 && pos<=c){
          out.println((ans+(c-pos)));
          return ;
        }
        else if(pos+a>=60 && c<=(pos+a)% 60){
          out.println((ans+(60-pos)+c));
          return ;
        }
        else if(pos<=c && c<=pos+a){
          out.println((ans+(c-pos)));
          return ;
        }
        pos=(pos+a)% 60 ;
        ans+=a ;
      }
      else {
        pos=(pos+b)% 60 ;
        ans+=b ;
      }
    }
    out.println("-1");
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    solve();
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var pos : int ; pos := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 200 do ( (     if (i mod 2 = 0) then (     if (pos + a >= 60 & pos <= c) then (     skip ; 
     return ) else     if (pos + a >= 60 & c <= (pos + a) mod 60) then (     skip ; 
     return ) else     if (pos <= c & c <= pos + a) then (     skip ; 
     return ) else skip ; ;  ;  
     pos := (pos + a) mod 60 ; 
     ans := ans+(a) ) else (     pos := (pos + b) mod 60 ; 
     ans := ans+(b) ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    execute solve() ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  BufferedReader buff=new BufferedReader(new InputStreamReader(System.in));
  String input=null ;
  ArrayList<Integer>sleepedstart=new ArrayList<Integer>(0);
  ArrayList<Integer>sleepedend=new ArrayList<Integer>(0);
  int time=0 ;
  int result=0 ;
  int sleeptimerest=0 ;
  int sleeptime=0 ;
  int awaketimerest=0 ;
  int ctime=0 ;
  public static void main(String[] args){
    Main r=new Main();
    r.Run();
  }
  public void Run(){
    try {
      input=buff.readLine();
      String get[]=input.split(" ");
      int a=Integer.parseInt(get[0]);
      int b=Integer.parseInt(get[1]);
      int c=Integer.parseInt(get[2]);
      awaketimerest=a ;
      ctime=c ;
      while(true){
        time++;
        ctime--;
        if(awaketimerest>0 && ctime==0){
          result=time ;
          break ;
        }
        else if(ctime==0){
          if(sleepedstart.contains((time+sleeptimerest)% 60)&& sleepedend.contains((time-sleeptime)% 60)){
            result=-1 ;
            break ;
          }
          sleepedstart.add((time+sleeptimerest)% 60);
          sleepedend.add((time-sleeptime)% 60);
          ctime=60 ;
        }
        if(awaketimerest!=0){
          awaketimerest--;
          if(awaketimerest==0){
            sleeptimerest=b ;
            sleeptime=0 ;
          }
        }
        else if(sleeptimerest!=0){
          sleeptimerest--;
          sleeptime++;
          if(sleeptimerest==0){
            awaketimerest=a ;
          }
        }
      }
      System.out.println(result);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute buff : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute input : String := null;
   attribute sleepedstart : Sequence(int) := Sequence{};
   attribute sleepedend : Sequence(int) := Sequence{};
   attribute time : int := 0;
   attribute result : int := 0;
   attribute sleeptimerest : int := 0;
   attribute sleeptime : int := 0;
   attribute awaketimerest : int := 0;
   attribute ctime : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : Main ; r := Main.newMain() ;
     r.Run() );
   operation Run() : void
  pre: true
  post: true
  activity: (     try (     input := buff.readLine() ; 
     var get : Sequence(String) ; get := input->split(" ") ;
    var a : int ; a := (get[0+1])->toInteger() ;
    var b : int ; b := (get[1+1])->toInteger() ;
    var c : int ; c := (get[2+1])->toInteger() ;
    awaketimerest := a ; 
    ctime := c ; 
    while (true) do (     time := time + 1 ; 
     ctime := ctime - 1 ; 
     if (awaketimerest > 0 & ctime = 0) then (     result := time ; 
     break ) else     if (ctime = 0) then (     if (sleepedstart->includes((time + sleeptimerest) mod 60) & sleepedend->includes((time - sleeptime) mod 60)) then (     result := -1 ; 
     break ) else skip ; 
     sleepedstart := sleepedstart->including((time + sleeptimerest) mod 60) ; 
     sleepedend := sleepedend->including((time - sleeptime) mod 60) ; 
     ctime := 60 ) else skip ; ;  
     if (awaketimerest /= 0) then (     awaketimerest := awaketimerest - 1 ; 
     if (awaketimerest = 0) then (     sleeptimerest := b ; 
     sleeptime := 0 ) else skip ) else     if (sleeptimerest /= 0) then (     sleeptimerest := sleeptimerest - 1 ; 
     sleeptime := sleeptime + 1 ; 
     if (sleeptimerest = 0) then (     awaketimerest := a ) else skip ) else skip ; ) ; 
    OclFile["System.out"].println(result) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.util.*;
public class main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int k=sc.nextInt();
      if(k>(n+1)/2){
        System.out.println("-1");
      }
      else {
        for(int i=0 ; i<n ; i++){
          for(int j=0 ; j<n ; j++){
            if(i==j && i % 2==0 && k>0){
              System.out.print("R");
              k--;
            }
            else System.out.print(".");
          }
          System.out.println();
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     if (k > (n + 1) / 2) then (     OclFile["System.out"].println("-1") ) else (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (i = j & i mod 2 = 0 & k > 0) then (     OclFile["System.out"].print("R") ; 
     k := k - 1 ) else     OclFile["System.out"].print(".") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.util.*;
public class StableArrangement {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int k=s.nextInt();
      int x=(int)Math.ceil(n/2.0);
      if(k>x)System.out.println(-1);
      else {
        for(int i=0 ; i<n ; i++){
          for(int j=0 ; j<n ; j++){
            if(i==j && i % 2==0 && k-->0)System.out.print("R");
            else System.out.print(".");
          }
          System.out.println();
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class StableArrangement {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var k : int ; k := s.getCurrent()->toInteger() ;
     var x : int ; x := (n / 2.0)->ceil()->oclAsType(int) ;
     if (k > x) then     OclFile["System.out"].println(-1) ; else (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (i = j & i mod 2 = 0 & k > 0) then     OclFile["System.out"].print("R") ; else     OclFile["System.out"].print(".") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void solve(int n,int k){
    if(k>(n+1)/2){
      System.out.println(-1);
    }
    else {
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          if((i-j)==0 &&(i)% 2==0 && k>0){
            System.out.print("R");
            k--;
          }
          else {
            System.out.print(".");
          }
        }
        System.out.println();
      }
    }
  }
  public static void main(String args[]){
    Scanner scn=new Scanner(System.in);
    int t=scn.nextInt();
    while(t-->0){
      int n=scn.nextInt();
      int k=scn.nextInt();
      solve(n,k);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( n : int, k : int) : void
  pre: true
  post: true
  activity: (     if (k > (n + 1) / 2) then (     OclFile["System.out"].println(-1) ) else (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if ((i - j) = 0 & (i) mod 2 = 0 & k > 0) then (     OclFile["System.out"].print("R") ; 
     k := k - 1 ) else (     OclFile["System.out"].print(".") ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scn.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scn.getCurrent()->toInteger() ;
     var k : int ; k := scn.getCurrent()->toInteger() ;
     execute solve(n, k) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.regex.*;
public class vk18 {
  public static void main(String[] stp)throws Exception {
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt(),i,sum=0,count=0 ;
    int a[]=new int[n];
    for(i=0 ; i<n ; i++){
      a[i]=scan.nextInt();
      sum+=a[i];
    }
    for(i=0 ; i<n ; i++){
      count+=a[i];
      if(count>=(sum+(sum % 2))/2){
        break ;
      }
    }
    System.out.println(i+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class vk18 {
  static   operation main( stp : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var i : int ;
    var sum : int ; sum := 0 ;
    var count : int ; count := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     count := count+(a[i+1]) ; 
     if (count >= (sum + (sum mod 2)) / 2) then (     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(i + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt()-1 ;
    int b=sc.nextInt()-1 ;
    int c=sc.nextInt()-1 ;
    int d=sc.nextInt()-1 ;
    char[] s=sc.next().toCharArray();
    boolean ans=true ;
    boolean cross=d<c ;
    int idx=a ;
    boolean tmp1=false ;
    while(true){
      if(c-idx<3){
        tmp1=true ;
        break ;
      }
      if(idx+2<n && s[idx+2]!='#')idx+=2 ;
      else if(idx+1<n && s[idx+1]!='#')idx+=1 ;
      else {
        tmp1=false ;
        break ;
      }
    }
    idx=b ;
    boolean tmp2=false ;
    while(true){
      if(d-idx<3){
        tmp2=true ;
        break ;
      }
      if(idx+2<n && s[idx+2]!='#')idx+=2 ;
      else if(idx+1<n && s[idx+1]!='#')idx+=1 ;
      else {
        tmp2=false ;
        break ;
      }
    }
    if(tmp1 && tmp2){
      if(cross){
        int tmp=0 ;
        int max=0 ;
        for(int i=b-1 ; i<=d+1 ; i++){
          if(s[i]=='.'){
            tmp++;
          }
          else {
            if(max<tmp)max=tmp ;
            tmp=0 ;
          }
        }
        if(2<Math.max(max,tmp))ans=true ;
        else ans=false ;
      }
      else {
        ans=true ;
      }
    }
    else {
      ans=false ;
    }
    System.out.println(ans ? "Yes" : "No");
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
    var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
    var c : int ; c := sc.getCurrent()->toInteger() - 1 ;
    var d : int ; d := sc.getCurrent()->toInteger() - 1 ;
    var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var ans : boolean ; ans := true ;
    var cross : boolean ; cross := d < c ;
    var idx : int ; idx := a ;
    var tmp1 : boolean ; tmp1 := false ;
    while (true) do (     if (c - idx < 3) then (     tmp1 := true ; 
     break ) else skip ; 
     if (idx + 2 < n & s[idx + 2+1] /= '#') then     idx := idx+(2) ; else     if (idx + 1 < n & s[idx + 1+1] /= '#') then     idx := idx+(1) else (     tmp1 := false ; 
     break ) ;  ) ; 
    idx := b ; 
    var tmp2 : boolean ; tmp2 := false ;
    while (true) do (     if (d - idx < 3) then (     tmp2 := true ; 
     break ) else skip ; 
     if (idx + 2 < n & s[idx + 2+1] /= '#') then     idx := idx+(2) ; else     if (idx + 1 < n & s[idx + 1+1] /= '#') then     idx := idx+(1) else (     tmp2 := false ; 
     break ) ;  ) ; 
    if (tmp1 & tmp2) then (     if (cross) then (     var tmp : int ; tmp := 0 ;
     var max : int ; max := 0 ;
         var i : int ; i := b - 1 ; while i <= d + 1 do ( (     if (s[i+1] = '.') then (     tmp := tmp + 1 ) else (     if (max < tmp) then     max := tmp ; else skip ; 
     tmp := 0 ) )  ;     i := i + 1 ) ; 
     if (2 < Set{max, tmp}->max()) then     ans := true ; else     ans := false ; ) else (     ans := true ) ) else (     ans := false ) ;  
    OclFile["System.out"].println(if ans then "Yes" else "No" endif) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    int a=Integer.parseInt(sa[1])-1 ;
    int b=Integer.parseInt(sa[2])-1 ;
    int c=Integer.parseInt(sa[3])-1 ;
    int d=Integer.parseInt(sa[4])-1 ;
    char[] s=br.readLine().toCharArray();
    br.close();
    for(int i=b+1 ; i<d ; i++){
      if(s[i-1]=='#' && s[i]=='#'){
        System.out.println("No");
        return ;
      }
    }
    for(int i=a+1 ; i<c ; i++){
      if(s[i-1]=='#' && s[i]=='#'){
        System.out.println("No");
        return ;
      }
    }
    if(c>d){
      for(int i=b+1 ; i<=d+1 ; i++){
        if(s[i-2]=='.' && s[i-1]=='.' && s[i]=='.'){
          System.out.println("Yes");
          return ;
        }
      }
      System.out.println("No");
      return ;
    }
    System.out.println("Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var a : int ; a := (sa[1+1])->toInteger() - 1 ;
    var b : int ; b := (sa[2+1])->toInteger() - 1 ;
    var c : int ; c := (sa[3+1])->toInteger() - 1 ;
    var d : int ; d := (sa[4+1])->toInteger() - 1 ;
    var s : Sequence(String) ; s := br.readLine()->characters() ;
    skip ; 
        var i : int ; i := b + 1 ; while i < d do ( (     if (s[i - 1+1] = '#' & s[i+1] = '#') then (     OclFile["System.out"].println("No") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := a + 1 ; while i < c do ( (     if (s[i - 1+1] = '#' & s[i+1] = '#') then (     OclFile["System.out"].println("No") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    if (c > d) then (         var i : int ; i := b + 1 ; while i <= d + 1 do ( (     if (s[i - 2+1] = '.' & s[i - 1+1] = '.' & s[i+1] = '.') then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
    OclFile["System.out"].println("Yes") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String line=in.nextLine();
    int n=Integer.parseInt(line.split(" ")[0]);
    int s1=Integer.parseInt(line.split(" ")[1]);
    int f1=Integer.parseInt(line.split(" ")[2]);
    int s2=Integer.parseInt(line.split(" ")[3]);
    int f2=Integer.parseInt(line.split(" ")[4]);
    String fld=in.nextLine();
    in.close();
    String snr=fld.substring(s1-1,s2);
    String fnr=fld.substring(f1-1,f2);
    String o="..." ;
    if(f2<s2)o=fld.substring(f1-2,f2+1);
    if(! snr.contains("##")&& ! fnr.contains("##")&& o.contains("...")){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : String ; line := in.nextLine() ;
    var n : int ; n := (line->split(" ")[0+1])->toInteger() ;
    var s1 : int ; s1 := (line->split(" ")[1+1])->toInteger() ;
    var f1 : int ; f1 := (line->split(" ")[2+1])->toInteger() ;
    var s2 : int ; s2 := (line->split(" ")[3+1])->toInteger() ;
    var f2 : int ; f2 := (line->split(" ")[4+1])->toInteger() ;
    var fld : String ; fld := in.nextLine() ;
    skip ; 
    var snr : String ; snr := fld.subrange(s1 - 1+1,s2) ;
    var fnr : String ; fnr := fld.subrange(f1 - 1+1,f2) ;
    var o : String ; o := "..." ;
    if (f2 < s2) then     o := fld.subrange(f1 - 2+1,f2 + 1) ; else skip ; 
    if (not(snr->includes("##")) & not(fnr->includes("##")) & o->includes("...")) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.*;
import java.awt.geom.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] $){
    Scanner sc=new Scanner(in);
    PriorityQueue<Long>left=new PriorityQueue<>();
    PriorityQueue<Long>right=new PriorityQueue<>(Comparator.reverseOrder());
    int n=sc.nextInt();
    long[] a=new long[1+n*3];
    for(int i=1 ; i<=3*n ; i++){
      a[i]=sc.nextLong();
    }
    long[] tL=new long[3*n+1];
    long[] tR=new long[3*n+2];
    for(int i=1 ; i<=2*n ; i++){
      left.add(a[i]);
      if(i<=n)tL[i]+=a[i]+tL[i-1];
      else {
        long y=left.poll();
        tL[i]+=tL[i-1]+a[i]-y ;
      }
    }
    for(int i=3*n ; i>n ; i--){
      right.add(a[i]);
      if(i>=2*n+1)tR[i]+=a[i]+tR[i+1];
      else {
        long y=right.poll();
        tR[i]+=tR[i+1]+a[i]-y ;
      }
    }
    long ans=Long.MIN_VALUE ;
    for(int i=n ; i<=n*2 ; i++){
      ans=max(tL[i]-tR[i+1],ans);
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var left : Sequence(long) ; left := Sequence{} ;
    var right : Sequence(long) ; right := Sequence{}->union(Comparator.reverseOrder()) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,1 + n * 3)->collect(0) ;
        var i : int ; i := 1 ; while i <= 3 * n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var tL : Sequence(long) ; tL := Integer.subrange(1,3 * n + 1)->collect(0) ;
    var tR : Sequence(long) ; tR := Integer.subrange(1,3 * n + 2)->collect(0) ;
        var i : int ; i := 1 ; while i <= 2 * n do ( (     left := left->including(a[i+1]) ; 
     if (i <= n) then     tL[i+1] := tL[i+1]+(a[i+1] + tL[i - 1+1]) ; else (     var y : long ; y := left->min() ;
     tL[i+1] := tL[i+1]+(tL[i - 1+1] + a[i+1] - y) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 3 * n ; while i > n do ( (     right := right->including(a[i+1]) ; 
     if (i >= 2 * n + 1) then     tR[i+1] := tR[i+1]+(a[i+1] + tR[i + 1+1]) ; else (     var y : long ; y := right->min() ;
     tR[i+1] := tR[i+1]+(tR[i + 1+1] + a[i+1] - y) ) )  ;     i := i - 1 ) ; 
    var ans : long ; ans := "-9223372036854775808"->toLong() ;
        var i : int ; i := n ; while i <= n * 2 do ( (     ans := Set{tL[i+1] - tR[i + 1+1], ans}->max() )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int n=in.nextInt();
    int a=in.nextInt();
    int b=in.nextInt();
    int c=in.nextInt();
    int d=in.nextInt();
    String s=in.next();
    System.out.println(solve(a-1,b-1,c-1,d-1,s));
    in.close();
  }
  private static String solve(int a,int b,int c,int d,String s){
    if(c>=b)if(! canMove(a,Math.max(c,d),s))return "No" ;
    else {
      if(! canMove(a,c,s))return "No" ;
      if(! canMove(b,d,s))return "No" ;
    }
    if(c>d)if(! canPass(b-1,d-1,s))return "No" ;
    return "Yes" ;
  }
  private static boolean canPass(int a,int b,String s){
    for(int i=a ; i<=b ; i++)if(s.charAt(i)=='.' && s.charAt(i+1)=='.' && s.charAt(i+2)=='.')return true ;
    return false ;
  }
  private static boolean canMove(int a,int b,String s){
    for(int i=a ; i<b ; i++)if(s.charAt(i)=='#' && s.charAt(i+1)=='#')return false ;
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    OclFile["System.out"].println(solve(a - 1, b - 1, c - 1, d - 1, s)) ; 
    skip ; 
 );
  static   operation solve( a : int, b : int, c : int, d : int, s : String) : String
  pre: true
  post: true
  activity: (     if (c >= b) then     if (not(canMove(a, Set{c, d}->max(), s))) then     return "No" else (     if (not(canMove(a, c, s))) then     return "No" else skip ; 
     if (not(canMove(b, d, s))) then     return "No" else skip ) ;  else skip ; 
     if (c > d) then     if (not(canPass(b - 1, d - 1, s))) then     return "No" else skip ; else skip ; 
     return "Yes" );
  static   operation canPass( a : int, b : int, s : String) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := a ; while i <= b do (     if (s->at(i+1) = '.' & s->at(i + 1+1) = '.' & s->at(i + 2+1) = '.') then     return true else skip ;  ;     i := i + 1 ) ; 
     return false );
  static   operation canMove( a : int, b : int, s : String) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := a ; while i < b do (     if (s->at(i+1) = '#' & s->at(i + 1+1) = '#') then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int A=sc.nextInt()-1 ;
    int B=sc.nextInt()-1 ;
    int C=sc.nextInt()-1 ;
    int D=sc.nextInt()-1 ;
    String S=sc.next();
    boolean twoRock=false ;
    for(int i=1 ; i<N ; i++){
      if(A<i && i<Math.max(C,D)&& S.charAt(i-1)=='#' && S.charAt(i)=='#'){
        twoRock=true ;
      }
    }
    if(twoRock){
      System.out.println("No");
      return ;
    }
    if(C<D){
      System.out.println("Yes");
      return ;
    }
    boolean overtake=false ;
    for(int i=1 ; i<N-1 ; i++){
      if(B<=i && i<=D && i+1<=C && S.charAt(i-1)=='.' && S.charAt(i)=='.' && S.charAt(i+1)=='.'){
        overtake=true ;
      }
    }
    System.out.println(overtake ? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() - 1 ;
    var B : int ; B := sc.getCurrent()->toInteger() - 1 ;
    var C : int ; C := sc.getCurrent()->toInteger() - 1 ;
    var D : int ; D := sc.getCurrent()->toInteger() - 1 ;
    var S : String ; S := sc.getCurrent() ;
    var twoRock : boolean ; twoRock := false ;
        var i : int ; i := 1 ; while i < N do ( (     if (A < i & i < Set{C, D}->max() & S->at(i - 1+1) = '#' & S->at(i+1) = '#') then (     twoRock := true ) else skip )  ;     i := i + 1 ) ; 
    if (twoRock) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
    if (C < D) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
    var overtake : boolean ; overtake := false ;
        var i : int ; i := 1 ; while i < N - 1 do ( (     if (B <= i & i <= D & i + 1 <= C & S->at(i - 1+1) = '.' & S->at(i+1) = '.' & S->at(i + 1+1) = '.') then (     overtake := true ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if overtake then "Yes" else "No" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int mod=1000000007 ;
  static int[] ans=new int[100002];
  static int[] pref=new int[100002];
  static void preCompute(){
    Arrays.fill(ans,1);
    for(int i=2 ; i<=100000/2 ; i++){
      for(int j=2*i ; j<=100000 ; j+=i){
        ans[j]=(ans[j]*i)% mod ;
      }
    }
    for(int i=1 ; i<100002 ; ++i){
      pref[i]=pref[i-1]+ans[i];
      pref[i] %=mod ;
    }
  }
  static void printSum(int L,int R){
    System.out.print(pref[R]-pref[L-1]+" ");
  }
  static void printSumProper(int[][] arr,int Q){
    preCompute();
    for(int i=0 ; i<Q ; i++){
      printSum(arr[i][0],arr[i][1]);
    }
  }
  public static void main(String args[]){
    int Q=2 ;
    int[][] arr={
      {
        10,20 },{
          12,16 }
        };
        printSumProper(arr,Q);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute mod : int := 1000000007;
  static   attribute ans : Sequence(int) := Integer.subrange(1,100002)->collect(0);
  static   attribute pref : Sequence(int) := Integer.subrange(1,100002)->collect(0);
  static   operation preCompute() : void
  pre: true
  post: true
  activity: (     ans := ans->collect(1) ; 
         var i : int ; i := 2 ; while i <= 100000 / 2 do ( (         var j : int ; j := 2 * i ; while j <= 100000 do ( (     ans[j+1] := (ans[j+1] * i) mod mod )  ;     j := j+(i) ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i < 100002 do ( (     pref[i+1] := pref[i - 1+1] + ans[i+1] ; 
     pref[i+1] := pref[i+1] mod mod )  ;     i := i + 1 ) );
  static   operation printSum( L : int, R : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(pref[R+1] - pref[L - 1+1] + " ") );
  static   operation printSumProper( arr : Sequence(Sequence(int)), Q : int) : void
  pre: true
  post: true
  activity: (     execute preCompute() ; 
         var i : int ; i := 0 ; while i < Q do ( (     execute printSum(arr[i+1][0+1], arr[i+1][1+1]) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Q : int ; Q := 2 ;
     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{10,20},Sequence{12,16}} ;
     execute printSumProper(arr, Q) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      long n=sc.nextLong();
      if(n==0){
        break ;
      }
      char[] ch=("1"+sc.next()).toCharArray();
      long d=decode(ch);
      long e=0 ;
      long bound=(1L<<53);
      long now=d ;
      long nowd=d ;
      long remain=n ;
      for(; ; ){
        if(nowd==0){
          break ;
        }
        long next=(bound-now);
        long times=((next-1)/nowd)+1 ;
        if(remain<times){
          now+=nowd*remain ;
          break ;
        }
        now+=nowd*times ;
        now>>=1 ;
        nowd>>=1 ;
        e++;
        remain-=times ;
      }
      System.out.println(encode(e,now));
    }
  }
  String encode(long e,long now){
    String ee=String.format("%012d",0)+Long.toBinaryString(e);
    String dd=String.format("%052d",0)+Long.toBinaryString(now);
    ee=ee.substring(ee.length()-12);
    dd=dd.substring(dd.length()-52);
    return ee+dd ;
  }
  long decode(char[] ch2){
    long res=0 ;
    for(int i=0 ; i<ch2.length ; i++){
      res*=2 ;
      res+=ch2[i]-'0' ;
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : long ; n := sc.getCurrent()->toLong() ;
     if (n = 0) then (     break ) else skip ; 
    var ch : Sequence(String) ; ch := ("1" + sc.getCurrent())->characters() ;
    var d : long ; d := decode(ch) ;
    var e : long ; e := 0 ;
    var bound : long ; bound := ((1L*(2->pow(53)))->oclAsType(long)) ;
    var now : long ; now := d ;
    var nowd : long ; nowd := d ;
    var remain : long ; remain := n ;
      while true do ( (     if (nowd = 0) then (     break ) else skip ; 
     var next : long ; next := (bound - now) ;
    var times : long ; times := ((next - 1) / nowd) + 1 ;
    if (remain < times) then (     now := now+(nowd * remain) ; 
     break ) else skip ; 
    now := now+(nowd * times) ; 
    now := now/(2->pow(1)) ; 
    nowd := nowd/(2->pow(1)) ; 
    e := e + 1 ; 
    remain := remain-(times) ; 
 )  ) ; 
    OclFile["System.out"].println(encode(e, now)) ; 
 )  ) );
   operation encode( e : long, now : long) : String
  pre: true
  post: true
  activity: (     var ee : String ; ee := StringLib.format("%012d",Sequence{0}) + (MathLib.decimal2binary(e) + "") ;
     var dd : String ; dd := StringLib.format("%052d",Sequence{0}) + (MathLib.decimal2binary(now) + "") ;
    ee := ee.subrange(ee->size() - 12+1,ee->size() - 12) ; 
    dd := dd.subrange(dd->size() - 52+1,dd->size() - 52) ; 
    return ee + dd 
 );
   operation decode( ch2 : Sequence(String)) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 0 ;
         var i : int ; i := 0 ; while i < ch2->size() do ( (     res := res*(2) ; 
     res := res+(ch2[i+1] - ('0')->char2byte()) )  ;     i := i + 1 ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class PairInSortedRotated {
  static boolean pairInSortedRotated(int arr[],int n,int x){
    int i ;
    for(i=0 ; i<n-1 ; i++)if(arr[i]>arr[i+1])break ;
    int l=(i+1)% n ;
    int r=i ;
    while(l!=r){
      if(arr[l]+arr[r]==x)return true ;
      if(arr[l]+arr[r]<x)l=(l+1)% n ;
      else r=(n+r-1)% n ;
    }
    return false ;
  }
  public static void main(String[] args){
    int arr[]={
      11,15,6,8,9,10 };
      int sum=16 ;
      int n=arr.length ;
      if(pairInSortedRotated(arr,n,sum))System.out.print("Array has two elements"+" with sum 16");
      else System.out.print("Array doesn't have two"+" elements with sum 16 ");
    }
  }

------------------------------------------------------------
OCL File:
---------
class PairInSortedRotated {
  static   operation pairInSortedRotated( arr : Sequence(int), n : int, x : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ;
         i := 0 ; while i < n - 1 do (     if (arr[i+1] > arr[i + 1+1]) then     break else skip ;  ;     i := i + 1 ) ; 
    var l : int ; l := (i + 1) mod n ;
    var r : int ; r := i ;
    while (l /= r) do (     if (arr[l+1] + arr[r+1] = x) then     return true else skip ; 
     if (arr[l+1] + arr[r+1] < x) then     l := (l + 1) mod n ; else     r := (n + r - 1) mod n ; ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{11,15,6,8,9,10} ;
     var sum : int ; sum := 16 ;
     var n : int ; n := arr->size() ;
     if (pairInSortedRotated(arr, n, sum)) then     OclFile["System.out"].print("Array has two elements" + " with sum 16") ; else     OclFile["System.out"].print("Array doesn't have two" + " elements with sum 16 ") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static int getMedian(int[] a,int[] b,int startA,int startB,int endA,int endB){
    if(endA-startA==1){
      return(Math.max(a[startA],b[startB])+Math.min(a[endA],b[endB]))/2 ;
    }
    int m1=median(a,startA,endA);
    int m2=median(b,startB,endB);
    if(m1==m2){
      return m1 ;
    }
    else if(m1<m2){
      return getMedian(a,b,(endA+startA+1)/2,startB,endA,(endB+startB+1)/2);
    }
    else {
      return getMedian(a,b,startA,(endB+startB+1)/2,(endA+startA+1)/2,endB);
    }
  }
  static int median(int[] arr,int start,int end){
    int n=end-start+1 ;
    if(n % 2==0){
      return(arr[start+(n/2)]+arr[start+(n/2-1)])/2 ;
    }
    else {
      return arr[start+n/2];
    }
  }
  public static void main(String[] args){
    int ar1[]={
      1,2,3,6 };
      int ar2[]={
        4,6,8,10 };
        int n1=ar1.length ;
        int n2=ar2.length ;
        if(n1!=n2){
          System.out.println("Doesn't work for arrays "+"of unequal size");
        }
        else if(n1==0){
          System.out.println("Arrays are empty.");
        }
        else if(n1==1){
          System.out.println((ar1[0]+ar2[0])/2);
        }
        else {
          System.out.println("Median is "+getMedian(ar1,ar2,0,0,ar1.length-1,ar2.length-1));
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation getMedian( a : Sequence(int), b : Sequence(int), startA : int, startB : int, endA : int, endB : int) : int
  pre: true
  post: true
  activity: (     if (endA - startA = 1) then (     return (Set{a[startA+1], b[startB+1]}->max() + Set{a[endA+1], b[endB+1]}->min()) / 2 ) else skip ; 
     var m1 : int ; m1 := median(a, startA, endA) ;
     var m2 : int ; m2 := median(b, startB, endB) ;
     if (m1 = m2) then (     return m1 ) else     if (m1 < m2) then (     return getMedian(a, b, (endA + startA + 1) / 2, startB, endA, (endB + startB + 1) / 2) ) else (     return getMedian(a, b, startA, (endB + startB + 1) / 2, (endA + startA + 1) / 2, endB) ) ;  );
  static   operation median( arr : Sequence(int), start : int, end : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := end - start + 1 ;
     if (n mod 2 = 0) then (     return (arr[start + (n / 2)+1] + arr[start + (n / 2 - 1)+1]) / 2 ) else (     return arr[start + n / 2+1] ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ar1 : Sequence(int) ; ar1 := Sequence{1,2,3,6} ;
     var ar2 : Sequence(int) ; ar2 := Sequence{4,6,8,10} ;
    var n1 : int ; n1 := ar1->size() ;
    var n2 : int ; n2 := ar2->size() ;
    if (n1 /= n2) then (     OclFile["System.out"].println("Doesn't work for arrays " + "of unequal size") ) else     if (n1 = 0) then (     OclFile["System.out"].println("Arrays are empty.") ) else     if (n1 = 1) then (     OclFile["System.out"].println((ar1[0+1] + ar2[0+1]) / 2) ) else (     OclFile["System.out"].println("Median is " + getMedian(ar1, ar2, 0, 0, ar1->size() - 1, ar2->size() - 1)) ) ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int max_profit(int a[],int b[],int n,int fee){
    int i,j,profit ;
    int l,r,diff_day=1,sum=0 ;
    b[0]=0 ;
    b[1]=diff_day ;
    for(i=1 ; i<n ; i++){
      l=0 ;
      r=diff_day ;
      sum=0 ;
      for(j=n-1 ; j>=i ; j--){
        profit=(a[r]-a[l])-fee ;
        if(profit>0){
          sum=sum+profit ;
        }
        l++;
        r++;
      }
      if(b[0]<sum){
        b[0]=sum ;
        b[1]=diff_day ;
      }
      diff_day++;
    }
    return 0 ;
  }
  public static void main(String args[]){
    int arr[]={
      6,1,7,2,8,4 };
      int n=arr.length ;
      int[] b=new int[2];
      int tranFee=2 ;
      max_profit(arr,b,n,tranFee);
      System.out.println(b[0]+","+b[1]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation max_profit( a : Sequence(int), b : Sequence(int), n : int, fee : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var profit : int ;
     var l : int ;
    var r : int ;
    var diff_day : int ; diff_day := 1 ;
    var sum : int ; sum := 0 ;
    b[0+1] := 0 ; 
    b[1+1] := diff_day ; 
        i := 1 ; while i < n do ( (     l := 0 ; 
     r := diff_day ; 
    sum := 0 ; 
        j := n - 1 ; while j >= i do ( (     profit := (a[r+1] - a[l+1]) - fee ; 
     if (profit > 0) then (     sum := sum + profit ) else skip ; 
     l := l + 1 ; 
     r := r + 1 )  ;     j := j - 1 ) ; 
    if (b[0+1] < sum) then (     b[0+1] := sum ; 
     b[1+1] := diff_day ) else skip ; 
    diff_day := diff_day + 1 ; 
 )  ;     i := i + 1 ) ; 
    return 0 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,1,7,2,8,4} ;
     var n : int ; n := arr->size() ;
    var b : Sequence(int) ; b := Integer.subrange(1,2)->collect(0) ;
    var tranFee : int ; tranFee := 2 ;
    execute max_profit(arr, b, n, tranFee) ; 
    OclFile["System.out"].println(b[0+1] + "," + b[1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.io.IOException ;
public class A {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    int n=Integer.parseInt(br.readLine());
    String s[]=br.readLine().split(" ");
    int v[]=new int[n];
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      v[i]=Integer.parseInt(s[i]);
      sum+=v[i];
    }
    int sum2=0 ;
    for(int i=0 ; i<n ; i++){
      sum2+=v[i];
      if(sum2*2>=sum){
        out.println(i+1);
        break ;
      }
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var s : Sequence(String) ; s := br.readLine()->split(" ") ;
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     v[i+1] := (s[i+1])->toInteger() ; 
     sum := sum+(v[i+1]) )  ;     i := i + 1 ) ; 
    var sum2 : int ; sum2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum2 := sum2+(v[i+1]) ; 
     if (sum2 * 2 >= sum) then (     skip ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
public class Run {
  public static boolean check(int curr,int a,int b,int n){
    for(int i=0 ; i<n ; i++){
      if(a>=curr){
        a-=curr ;
      }
      else if(b>=curr){
        b-=curr ;
      }
      else {
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] Z)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder op=new StringBuilder();
    StringTokenizer stz ;
    stz=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(stz.nextToken());
    int a=Integer.parseInt(stz.nextToken());
    int b=Integer.parseInt(stz.nextToken());
    int total=a+b ;
    int ans=Math.min(a,b);
    for(int i=ans ; i>=0 ; --i){
      boolean poss=check(i,a,b,n);
      if(poss){
        System.out.println(i);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Run {
  static   operation check( curr : int, a : int, b : int, n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (a >= curr) then (     a := a-(curr) ) else     if (b >= curr) then (     b := b-(curr) ) else (     return false ) ;  )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( Z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var op : String ; op := StringLib.newString() ;
    var stz : OclIterator ;
    stz := OclIterator.newOclIterator_String(br.readLine()) ; 
    var n : int ; n := (stz.next())->toInteger() ;
    var a : int ; a := (stz.next())->toInteger() ;
    var b : int ; b := (stz.next())->toInteger() ;
    var total : int ; total := a + b ;
    var ans : int ; ans := Set{a, b}->min() ;
        var i : int ; i := ans ; while i >= 0 do ( (     var poss : boolean ; poss := check(i, a, b, n) ;
     if (poss) then (     OclFile["System.out"].println(i) ; 
     break ) else skip )  ;     i := i - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class WriteNow {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int a=scan.nextInt();
    int b=scan.nextInt();
    if(n*2>(a+b)){
      System.out.println(1);
    }
    else {
      int res=2 ;
      while(true){
        int tempA=a ;
        int tempB=b ;
        int tempN=n ;
        if(tempA/res==0 || tempB/res==0){
          System.out.println(res-1);
          break ;
        }
        if(tempN>tempA/res+tempB/res){
          System.out.println(res-1);
          break ;
        }
        res++;
      }
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class WriteNow {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    if (n * 2 > (a + b)) then (     OclFile["System.out"].println(1) ) else (     var res : int ; res := 2 ;
     while (true) do (     var tempA : int ; tempA := a ;
     var tempB : int ; tempB := b ;
    var tempN : int ; tempN := n ;
    if (tempA / res = 0 or tempB / res = 0) then (     OclFile["System.out"].println(res - 1) ; 
     break ) else skip ; 
    if (tempN > tempA / res + tempB / res) then (     OclFile["System.out"].println(res - 1) ; 
     break ) else skip ; 
    res := res + 1 ; 
 ) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    int[] a=new int[3*N];
    for(int i=0 ; i<N*3 ; i++){
      a[i]=Integer.parseInt(sc.next());
    }
    sc.close();
    long[] dpLeft=new long[N+1];
    long[] dpRight=new long[N+1];
    PriorityQueue<Integer>que=new PriorityQueue<>();
    long sum=0 ;
    for(int i=0 ; i<N ; i++){
      que.add(a[i]);
      sum+=a[i];
    }
    dpLeft[0]=sum ;
    for(int i=1 ; i<=N ; i++){
      que.add(a[i+N-1]);
      sum=sum+a[i+N-1]-que.remove();
      dpLeft[i]=sum ;
    }
    que=new PriorityQueue<>((o1,o2)->o2-o1);
    sum=0 ;
    for(int i=3*N-1 ; i>=N*2 ; i--){
      que.add(a[i]);
      sum+=a[i];
    }
    dpRight[0]=sum ;
    for(int i=1 ; i<=N ; i++){
      que.add(a[2*N-i]);
      sum=sum+a[2*N-i]-que.remove();
      dpRight[i]=sum ;
    }
    long ans=Long.MIN_VALUE ;
    for(int i=0 ; i<=N ; i++){
      ans=Math.max(ans,dpLeft[i]-dpRight[N-i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,3 * N)->collect(0) ;
        var i : int ; i := 0 ; while i < N * 3 do ( (     a[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var dpLeft : Sequence(long) ; dpLeft := Integer.subrange(1,N + 1)->collect(0) ;
    var dpRight : Sequence(long) ; dpRight := Integer.subrange(1,N + 1)->collect(0) ;
    var que : Sequence(int) ; que := Sequence{} ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     que := que->including(a[i+1]) ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    dpLeft[0+1] := sum ; 
        var i : int ; i := 1 ; while i <= N do ( (     que := que->including(a[i + N - 1+1]) ; 
     sum := sum + a[i + N - 1+1] - que.remove() ; 
     dpLeft[i+1] := sum )  ;     i := i + 1 ) ; 
    que := Sequence{}->union(lambda (o1 , o2) : OclAny in o2 - o1) ; 
    sum := 0 ; 
        var i : int ; i := 3 * N - 1 ; while i >= N * 2 do ( (     que := que->including(a[i+1]) ; 
     sum := sum+(a[i+1]) )  ;     i := i - 1 ) ; 
    dpRight[0+1] := sum ; 
        var i : int ; i := 1 ; while i <= N do ( (     que := que->including(a[2 * N - i+1]) ; 
     sum := sum + a[2 * N - i+1] - que.remove() ; 
     dpRight[i+1] := sum )  ;     i := i + 1 ) ; 
    var ans : long ; ans := "-9223372036854775808"->toLong() ;
        var i : int ; i := 0 ; while i <= N do ( (     ans := Set{ans, dpLeft[i+1] - dpRight[N - i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TwoPie {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int a=scanner.nextInt();
    int b=scanner.nextInt();
    int maxOfMin=0 ;
    for(int aPlates=1 ; aPlates<=n-1 ; aPlates++){
      int bPlates=n-aPlates ;
      int minOnPlate=Math.min(a/aPlates,b/bPlates);
      maxOfMin=Math.max(minOnPlate,maxOfMin);
    }
    System.out.println(maxOfMin);
  }
}
------------------------------------------------------------
OCL File:
---------
 class TwoPie {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var maxOfMin : int ; maxOfMin := 0 ;
        var aPlates : int ; aPlates := 1 ; while aPlates <= n - 1 do ( (     var bPlates : int ; bPlates := n - aPlates ;
     var minOnPlate : int ; minOnPlate := Set{a / aPlates, b / bPlates}->min() ;
     maxOfMin := Set{minOnPlate, maxOfMin}->max() )  ;     aPlates := aPlates + 1 ) ; 
    OclFile["System.out"].println(maxOfMin) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class TwoCakes {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),a=in.nextInt(),b=in.nextInt();
    int ans=0 ;
    for(int i=1 ; i<=Math.min(a,b); i++){
      int cnt1=a/i ;
      int cnt2=b/i ;
      if((cnt1+cnt2)>=n){
        ans=Math.max(i,ans);
      }
    }
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class TwoCakes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= Set{a, b}->min() do ( (     var cnt1 : int ; cnt1 := a / i ;
     var cnt2 : int ; cnt2 := b / i ;
     if ((cnt1 + cnt2) >= n) then (     ans := Set{i, ans}->max() ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  static final int INF=0x3f3f3f3f ;
  static final long LNF=0x3f3f3f3f3f3f3f3fL ;
  public static void main(String[] args)throws IOException {
    initReader();
    long a=nextLong(),b=nextLong(),c=nextLong();
    long a1=a % c,b1=b % c ;
    pw.print((long)((a+b)/c)+" ");
    if(a1+b1>=c){
      pw.print(Math.min(c-a1,c-b1));
    }
    else {
      pw.print(0);
    }
    pw.close();
  }
  static BufferedReader reader ;
  static StringTokenizer tokenizer ;
  static PrintWriter pw ;
  public static void initReader()throws IOException {
    reader=new BufferedReader(new InputStreamReader(System.in));
    tokenizer=new StringTokenizer("");
    pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  }
  public static boolean hasNext(){
    try {
      while(! tokenizer.hasMoreTokens()){
        tokenizer=new StringTokenizer(reader.readLine());
      }
    }
    catch(Exception e){
      return false ;
    }
    return true ;
  }
  public static String next()throws IOException {
    while(! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  public static String nextLine(){
    try {
      return reader.readLine();
    }
    catch(Exception e){
      return null ;
    }
  }
  public static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public static long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public static char nextChar()throws IOException {
    return next().charAt(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := 0x3f3f3f3f;
  static    attribute LNF : long := 0x3f3f3f3f3f3f3f3fL;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute initReader() ; 
     var a : long ; a := nextLong() ;
    var b : long ; b := nextLong() ;
    var c : long ; c := nextLong() ;
    var a1 : long ; a1 := a mod c ;
    var b1 : long ; b1 := b mod c ;
    pw.print(((a + b) / c)->oclAsType(long) + " ") ; 
    if (a1 + b1 >= c) then (     pw.print(Set{c - a1, c - b1}->min()) ) else (     pw.print(0) ) ;  
    pw.close() ; 
 );
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   attribute pw : OclFile;
  static   operation initReader() : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := OclIterator.newOclIterator_String("") ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) );
  static   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     try (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (e : ProgramException) do (     return false )
     return true );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : ProgramException) do (     return null )
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  static final int INF=0x3f3f3f3f ;
  static final long LNF=0x3f3f3f3f3f3f3f3fL ;
  public static void main(String[] args)throws IOException {
    initReader();
    long a=nextLong(),b=nextLong(),c=nextLong();
    long a1=a % c,b1=b % c ;
    pw.print((long)((a+b)/c)+" ");
    if(a1+b1>=c){
      pw.print(Math.min(c-a1,c-b1));
    }
    else {
      pw.print(0);
    }
    pw.close();
  }
  static BufferedReader reader ;
  static StringTokenizer tokenizer ;
  static PrintWriter pw ;
  public static void initReader()throws IOException {
    reader=new BufferedReader(new InputStreamReader(System.in));
    tokenizer=new StringTokenizer("");
    pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  }
  public static boolean hasNext(){
    try {
      while(! tokenizer.hasMoreTokens()){
        tokenizer=new StringTokenizer(reader.readLine());
      }
    }
    catch(Exception e){
      return false ;
    }
    return true ;
  }
  public static String next()throws IOException {
    while(! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  public static String nextLine(){
    try {
      return reader.readLine();
    }
    catch(Exception e){
      return null ;
    }
  }
  public static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public static long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public static char nextChar()throws IOException {
    return next().charAt(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := 0x3f3f3f3f;
  static    attribute LNF : long := 0x3f3f3f3f3f3f3f3fL;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute initReader() ; 
     var a : long ; a := nextLong() ;
    var b : long ; b := nextLong() ;
    var c : long ; c := nextLong() ;
    var a1 : long ; a1 := a mod c ;
    var b1 : long ; b1 := b mod c ;
    pw.print(((a + b) / c)->oclAsType(long) + " ") ; 
    if (a1 + b1 >= c) then (     pw.print(Set{c - a1, c - b1}->min()) ) else (     pw.print(0) ) ;  
    pw.close() ; 
 );
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   attribute pw : OclFile;
  static   operation initReader() : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := OclIterator.newOclIterator_String("") ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) );
  static   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     try (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (e : ProgramException) do (     return false )
     return true );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : ProgramException) do (     return null )
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int solve(int[] A,int[] B,int[] C){
    int i,j,k ;
    i=A.length-1 ;
    j=B.length-1 ;
    k=C.length-1 ;
    int min_diff,current_diff,max_term ;
    min_diff=Math.abs(Math.max(A[i],Math.max(B[j],C[k]))-Math.min(A[i],Math.min(B[j],C[k])));
    while(i!=-1 && j!=-1 && k!=-1){
      current_diff=Math.abs(Math.max(A[i],Math.max(B[j],C[k]))-Math.min(A[i],Math.min(B[j],C[k])));
      if(current_diff<min_diff)min_diff=current_diff ;
      max_term=Math.max(A[i],Math.max(B[j],C[k]));
      if(A[i]==max_term)i-=1 ;
      else if(B[j]==max_term)j-=1 ;
      else k-=1 ;
    }
    return min_diff ;
  }
  public static void main(String[] args){
    int[] D={
      5,8,10,15 };
      int[] E={
        6,9,15,78,89 };
        int[] F={
          2,3,6,6,8,8,10 };
          System.out.println(solve(D,E,F));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( A : Sequence(int), B : Sequence(int), C : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var k : int ;
     i := A->size() - 1 ; 
    j := B->size() - 1 ; 
    k := C->size() - 1 ; 
    var min_diff : int ;
    var current_diff : int ;
    var max_term : int ;
    min_diff := if Set{A[i+1], Set{B[j+1], C[k+1]}->max()}->max() - Set{A[i+1], Set{B[j+1], C[k+1]}->min()}->min() < 0 then -(Set{A[i+1], Set{B[j+1], C[k+1]}->max()}->max() - Set{A[i+1], Set{B[j+1], C[k+1]}->min()}->min()) else Set{A[i+1], Set{B[j+1], C[k+1]}->max()}->max() - Set{A[i+1], Set{B[j+1], C[k+1]}->min()}->min() endif ; 
    while (i /= -1 & j /= -1 & k /= -1) do (     current_diff := if Set{A[i+1], Set{B[j+1], C[k+1]}->max()}->max() - Set{A[i+1], Set{B[j+1], C[k+1]}->min()}->min() < 0 then -(Set{A[i+1], Set{B[j+1], C[k+1]}->max()}->max() - Set{A[i+1], Set{B[j+1], C[k+1]}->min()}->min()) else Set{A[i+1], Set{B[j+1], C[k+1]}->max()}->max() - Set{A[i+1], Set{B[j+1], C[k+1]}->min()}->min() endif ; 
     if (current_diff < min_diff) then     min_diff := current_diff ; else skip ; 
     max_term := Set{A[i+1], Set{B[j+1], C[k+1]}->max()}->max() ; 
     if (A[i+1] = max_term) then     i := i-(1) ; else     if (B[j+1] = max_term) then     j := j-(1) else     k := k-(1) ; ;  ) ; 
    return min_diff 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var D : Sequence(int) ; D := Sequence{5,8,10,15} ;
     var E : Sequence(int) ; E := Sequence{6,9,15,78,89} ;
     var F : Sequence(int) ; F := Sequence{2,3,6,6,8,8,10} ;
     OclFile["System.out"].println(solve(D, E, F)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int INT_MAX=Integer.MAX_VALUE ;
  static int findLength(String s,int k){
    int ans=INT_MAX ;
    int l=0 ;
    int r=0 ;
    int cnt_zero=0,cnt_one=0 ;
    while(l<s.length()&& r<=s.length()){
      if(cnt_zero>=k && cnt_one>=1){
        ans=Math.min(ans,r-l);
        l++;
        if(s.charAt(l-1)=='0')cnt_zero--;
        else cnt_one--;
      }
      else {
        if(r==s.length())break ;
        if(s.charAt(r)=='0')cnt_zero++;
        else cnt_one++;
        r++;
      }
    }
    if(ans==INT_MAX)return-1 ;
    return ans ;
  }
  public static void main(String[] args){
    String s="100" ;
    int k=2 ;
    System.out.println(findLength(s,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute INT_MAX : int := 2147483647;
  static   operation findLength( s : String, k : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := INT_MAX ;
     var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    var cnt_zero : int ; cnt_zero := 0 ;
    var cnt_one : int ; cnt_one := 0 ;
    while (l < s->size() & r <= s->size()) do (     if (cnt_zero >= k & cnt_one >= 1) then (     ans := Set{ans, r - l}->min() ; 
     l := l + 1 ; 
     if (s->at(l - 1+1) = '0') then     cnt_zero := cnt_zero - 1 ; else     cnt_one := cnt_one - 1 ; ) else (     if (r = s->size()) then     break else skip ; 
     if (s->at(r+1) = '0') then     cnt_zero := cnt_zero + 1 else     cnt_one := cnt_one + 1 ; ;  
     r := r + 1 ) ) ; 
    if (ans = INT_MAX) then     return -1 else skip ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "100" ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(findLength(s, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class GFG {
  public static int minReplace(int a[],int n){
    int i ;
    HashMap<Integer,Integer>te=new HashMap<>();
    HashMap<Integer,Integer>to=new HashMap<>();
    for(i=0 ; i<n ; i++){
      if(i % 2==0){
        if(te.containsKey(a[i]))te.put(a[i],te.get(a[i])+1);
        else te.put(a[i],1);
      }
      else {
        if(to.containsKey(a[i]))to.put(a[i],to.get(a[i])+1);
        else to.put(a[i],1);
      }
    }
    int me=-1 ;
    int mo=-1 ;
    int ce=-1 ;
    int co=-1 ;
    for(Integer It : te.keySet()){
      if(te.get(It)>ce){
        ce=te.get(It);
        me=It ;
      }
    }
    for(Integer It : to.keySet()){
      if(to.get(It)>co){
        co=to.get(It);
        mo=It ;
      }
    }
    int res=0 ;
    for(i=0 ; i<n ; i++){
      if(i % 2==0){
        if(a[i]!=me)res++;
      }
      else {
        if(a[i]!=mo)res++;
      }
    }
    return res ;
  }
  public static void main(String[] args){
    int n ;
    n=4 ;
    int a[]={
      3,1,3,2 };
      System.out.println(minReplace(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minReplace( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
     var te : Map(int,int) ; te := Map{} ;
    var to : Map(int,int) ; to := Map{} ;
        i := 0 ; while i < n do ( (     if (i mod 2 = 0) then (     if (te->keys()->includes(a[i+1])) then     te := te->union(Map{a[i+1] |-> te->at(a[i+1]) + 1}) ; else     te := te->union(Map{a[i+1] |-> 1}) ; ) else (     if (to->keys()->includes(a[i+1])) then     to := to->union(Map{a[i+1] |-> to->at(a[i+1]) + 1}) ; else     to := to->union(Map{a[i+1] |-> 1}) ; ) )  ;     i := i + 1 ) ; 
    var me : int ; me := -1 ;
    var mo : int ; mo := -1 ;
    var ce : int ; ce := -1 ;
    var co : int ; co := -1 ;
    for (It : te->keys()) do ( (     if (te->at(It) > ce) then (     ce := te->at(It) ; 
     me := It ) else skip )  ) ; 
    for (It : to->keys()) do ( (     if (to->at(It) > co) then (     co := to->at(It) ; 
     mo := It ) else skip )  ) ; 
    var res : int ; res := 0 ;
        i := 0 ; while i < n do ( (     if (i mod 2 = 0) then (     if (a[i+1] /= me) then     res := res + 1 ; else skip ) else (     if (a[i+1] /= mo) then     res := res + 1 ; else skip ) )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     n := 4 ; 
     var a : Sequence(int) ; a := Sequence{3,1,3,2} ;
     OclFile["System.out"].println(minReplace(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countPairs(int A,int B){
    int cnt=0 ;
    for(int i=0 ; i<=A ; ++i){
      for(int j=i ; j<=A ; ++j){
        int AND=i & j ;
        int OR=i | j ;
        if(OR==A && AND==B){
          cnt++;
        }
      }
    }
    return cnt ;
  }
  public static void main(String[] args){
    int A=3,B=0 ;
    System.out.println(countPairs(A,B));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countPairs( A : int, B : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i <= A do ( (         var j : int ; j := i ; while j <= A do ( (     var AND : int ; AND := MathLib.bitwiseAnd(i,j) ;
     var OR : int ; OR := MathLib.bitwiseOr(i,j) ;
     if (OR = A & AND = B) then (     cnt := cnt + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 3 ;
    var B : int ; B := 0 ;
     OclFile["System.out"].println(countPairs(A, B)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class _962A {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt();
    int arr[]=new int[n];
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
      sum+=arr[i];
    }
    int half=sum/2+(sum % 2==0 ? 0 : 1);
    int count=0 ;
    int result=0 ;
    for(int i=0 ; i<n ; i++){
      count+=arr[i];
      if(count>=half){
        result=i+1 ;
        break ;
      }
    }
    out.println(result);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class _962A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    var half : int ; half := sum / 2 + (if sum mod 2 = 0 then 0 else 1 endif) ;
    var count : int ; count := 0 ;
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     count := count+(arr[i+1]) ; 
     if (count >= half) then (     result := i + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class MoamenAndKSubarrays {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    Map<Integer,Integer>map=new HashMap<>();
    while(t-->0){
      int n=in.nextInt();
      int k=in.nextInt();
      int i ;
      int a[]=new int[n];
      int b[]=new int[n];
      for(i=0 ; i<n ; i++){
        a[i]=in.nextInt();
        b[i]=a[i];
      }
      Arrays.sort(b);
      for(i=0 ; i<n ; i++){
        map.put(b[i],i);
      }
      int c=0 ;
      for(i=0 ; i<n ; i++){
        if(map.get(a[i])>0 && i>0 && b[map.get(a[i])-1]==a[i-1]){
        }
        else c++;
      }
      if(c<=k)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MoamenAndKSubarrays {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
     var map : Map(int,int) ; map := Map{} ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var i : int ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     b[i+1] := a[i+1] )  ;     i := i + 1 ) ; 
    b := b->sort() ; 
        i := 0 ; while i < n do ( (     map := map->union(Map{b[i+1] |-> i}) )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
        i := 0 ; while i < n do ( (     if (map->at(a[i+1]) > 0 & i > 0 & b[map->at(a[i+1]) - 1+1] = a[i - 1+1]) then skip else     c := c + 1 ; )  ;     i := i + 1 ) ; 
    if (c <= k) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[] a=new long[3*N];
    for(int i=0 ; i<3*N ; i++){
      a[i]=sc.nextLong();
    }
    long[] sumMax=new long[N+1];
    PriorityQueue<Long>pq1=new PriorityQueue<Long>();
    for(int i=0 ; i<N ; i++){
      sumMax[0]+=a[i];
      pq1.add(a[i]);
    }
    for(int i=1 ; i<N+1 ; i++){
      pq1.add(a[N-1+i]);
      long min=pq1.poll();
      sumMax[i]=sumMax[i-1]+a[N-1+i]-min ;
    }
    long[] sumMin=new long[N+1];
    PriorityQueue<Long>pq2=new PriorityQueue<Long>(N,Collections.reverseOrder());
    for(int i=0 ; i<N ; i++){
      sumMin[0]+=a[3*N-1-i];
      pq2.add(a[3*N-1-i]);
    }
    for(int i=1 ; i<N+1 ; i++){
      pq2.add(a[2*N-i]);
      long max=pq2.poll();
      sumMin[i]=sumMin[i-1]+a[2*N-i]-max ;
    }
    long ans=-(long)Math.pow(10,15);
    for(int i=0 ; i<N+1 ; i++){
      ans=Math.max(ans,sumMax[i]-sumMin[N-i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,3 * N)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 * N do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var sumMax : Sequence(long) ; sumMax := Integer.subrange(1,N + 1)->collect(0) ;
    var pq1 : Sequence(long) ; pq1 := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     sumMax[0+1] := sumMax[0+1]+(a[i+1]) ; 
     pq1 := pq1->including(a[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < N + 1 do ( (     pq1 := pq1->including(a[N - 1 + i+1]) ; 
     var min : long ; min := pq1->min() ;
     sumMax[i+1] := sumMax[i - 1+1] + a[N - 1 + i+1] - min )  ;     i := i + 1 ) ; 
    var sumMin : Sequence(long) ; sumMin := Integer.subrange(1,N + 1)->collect(0) ;
    var pq2 : Sequence(long) ; pq2 := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     sumMin[0+1] := sumMin[0+1]+(a[3 * N - 1 - i+1]) ; 
     pq2 := pq2->including(a[3 * N - 1 - i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < N + 1 do ( (     pq2 := pq2->including(a[2 * N - i+1]) ; 
     var max : long ; max := pq2->min() ;
     sumMin[i+1] := sumMin[i - 1+1] + a[2 * N - i+1] - max )  ;     i := i + 1 ) ; 
    var ans : long ; ans := -10->pow(15)->oclAsType(long) ;
        var i : int ; i := 0 ; while i < N + 1 do ( (     ans := Set{ans, sumMax[i+1] - sumMin[N - i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Solution {
  public static void main(String[] args)throws Exception {
    try {
      System.setIn(new FileInputStream("input.txt"));
      System.setOut(new PrintStream(new FileOutputStream("output.txt")));
    }
    catch(Exception e){
      System.err.println("Error");
    }
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    while(t-->0){
      String[] str=br.readLine().split(" ");
      int n=Integer.parseInt(str[0]);
      int m=Integer.parseInt(str[1]);
      String[] array=br.readLine().split(" ");
      int[] a=new int[n];
      int[] b=new int[n];
      int c=1 ;
      for(int i=0 ; i<n ; i++){
        a[i]=Integer.parseInt(array[i]);
        b[i]=a[i];
      }
      Arrays.sort(b);
      HashMap<Integer,Integer>map=new HashMap<>();
      for(int i=0 ; i<n ; i++){
        map.put(b[i],i);
      }
      for(int i=1 ; i<n ; i++){
        if(map.get(a[i])>0 && i>0 && b[map.get(a[i])-1]==a[i-1])continue ;
        else c++;
      }
      if(c<=m){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) )   catch (e : ProgramException) do (     OclFile["System.err"].println("Error") )
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     var n : int ; n := (str[0+1])->toInteger() ;
    var m : int ; m := (str[1+1])->toInteger() ;
    var array : Sequence(String) ; array := br.readLine()->split(" ") ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var c : int ; c := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (array[i+1])->toInteger() ; 
     b[i+1] := a[i+1] )  ;     i := i + 1 ) ; 
    b := b->sort() ; 
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     map := map->union(Map{b[i+1] |-> i}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (map->at(a[i+1]) > 0 & i > 0 & b[map->at(a[i+1]) - 1+1] = a[i - 1+1]) then     continue else     c := c + 1 ; )  ;     i := i + 1 ) ; 
    if (c <= m) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Subarray_Inversions {
  static int inversion_count(int n,int k,int[] a){
    int count=0 ;
    for(int start=0 ; start<n-k+1 ; start++){
      int end=start+k ;
      count+=bubble_count(a,start,end);
    }
    return count ;
  }
  public static int bubble_count(int[] arr,int start,int end){
    int count=0 ;
    for(int i=start ; i<end ; i++){
      for(int j=i+1 ; j<end ; j++){
        if(arr[i]>arr[j]){
          count++;
        }
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int n=10 ;
    int[] arr={
      15,51,44,44,76,50,29,88,48,50 };
      int k=5 ;
      long result=inversion_count(n,k,arr);
      System.out.println(result);
    }
  }

------------------------------------------------------------
OCL File:
---------
class Subarray_Inversions {
  static   operation inversion_count( n : int, k : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var start : int ; start := 0 ; while start < n - k + 1 do ( (     var end : int ; end := start + k ;
     count := count+(bubble_count(a, start, end)) )  ;     start := start + 1 ) ; 
     return count );
  static   operation bubble_count( arr : Sequence(int), start : int, end : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := start ; while i < end do ( (         var j : int ; j := i + 1 ; while j < end do ( (     if (arr[i+1] > arr[j+1]) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     var arr : Sequence(int) ; arr := Sequence{15,51,44,44,76,50,29,88,48,50} ;
    var k : int ; k := 5 ;
    var result : long ; result := inversion_count(n, k, arr) ;
    OclFile["System.out"].println(result) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int solve(double M,double N,double s){
    int ans=((int)(Math.ceil(M/s))*(int)(Math.ceil(N/s)));
    return ans ;
  }
  public static void main(String[] args){
    double N=12,M=13,s=4 ;
    System.out.println(solve(M,N,s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( M : double, N : double, s : double) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := (((M / s)->ceil())->oclAsType(int) * ((N / s)->ceil())->oclAsType(int)) ;
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : double ; N := 12 ;
    var M : double ; M := 13 ;
    var s : double ; s := 4 ;
     OclFile["System.out"].println(solve(M, N, s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class GFG {
  static int solution(int[] A){
    int n=A.length ;
    boolean[] present=new boolean[n+1];
    for(int i=0 ; i<n ; i++){
      if(A[i]>0 && A[i]<=n)present[A[i] ]=true ;
    }
    for(int i=1 ; i<=n ; i++)if(! present[i])return i ;
    return n+1 ;
  }
  public static void main(String[] args){
    int A[]={
      0,10,2,-10,-20 };
      System.out.println(solution(A));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solution( A : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := A->size() ;
     var present : Sequence(boolean) ; present := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     if (A[i+1] > 0 & A[i+1] <= n) then     present[A[i+1]+1] := true ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (     if (not(present[i+1])) then     return i else skip ;  ;     i := i + 1 ) ; 
    return n + 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{0,10,2,-10,-20} ;
     OclFile["System.out"].println(solution(A)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static ArrayList<Integer>set=new ArrayList<Integer>();
  static ArrayList<Integer>prime=new ArrayList<Integer>();
  static boolean isPrime(int x){
    int sqroot=(int)Math.sqrt(x);
    if(x==1)return false ;
    for(int i=2 ; i<=sqroot ; i++)if(x % i==0)return false ;
    return true ;
  }
  static void display(){
    int length=set.size();
    for(int i=0 ; i<length ; i++)System.out.print(set.get(i)+" ");
    System.out.println();
  }
  static void primeSum(int total,int N,int S,int index){
    if(total==S && set.size()==N){
      display();
      return ;
    }
    if(total>S || index==prime.size()|| set.size()>=N)return ;
    set.add(prime.get(index));
    primeSum(total+prime.get(index),N,S,index+1);
    set.remove(set.size()-1);
    primeSum(total,N,S,index+1);
  }
  static void allPrime(int N,int S,int P){
    for(int i=P+1 ; i<=S ; i++){
      if(isPrime(i))prime.add(i);
    }
    if(prime.size()<N)return ;
    primeSum(0,N,S,0);
  }
  public static void main(String args[]){
    int S=54,N=2,P=3 ;
    allPrime(N,S,P);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute set : Sequence(int) := Sequence{};
  static   attribute prime : Sequence(int) := Sequence{};
  static   operation isPrime( x : int) : boolean
  pre: true
  post: true
  activity: (     var sqroot : int ; sqroot := (x)->sqrt()->oclAsType(int) ;
     if (x = 1) then     return false else skip ; 
         var i : int ; i := 2 ; while i <= sqroot do (     if (x mod i = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation display() : void
  pre: true
  post: true
  activity: (     var length : int ; length := set->size() ;
         var i : int ; i := 0 ; while i < length do (     OclFile["System.out"].print(set->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation primeSum( total : int, N : int, S : int, index : int) : void
  pre: true
  post: true
  activity: (     if (total = S & set->size() = N) then (     execute display() ; 
     return ) else skip ; 
     if (total > S or index = prime->size() or set->size() >= N) then     return else skip ; 
    set := set->including(prime->at(index+1)) ; 
    execute primeSum(total + prime->at(index+1), N, S, index + 1) ; 
    set := set->excludingFirst(set->size() - 1) ; 
    execute primeSum(total, N, S, index + 1) ; 
 );
  static   operation allPrime( N : int, S : int, P : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := P + 1 ; while i <= S do ( (     if (isPrime(i)) then     prime := prime->including(i) ; else skip )  ;     i := i + 1 ) ; 
     if (prime->size() < N) then     return else skip ; 
     execute primeSum(0, N, S, 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : int ; S := 54 ;
    var N : int ; N := 2 ;
    var P : int ; P := 3 ;
     execute allPrime(N, S, P) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int MAX_SIZE=100005 ;
  static int[] fib=new int[MAX_SIZE+1];
  static void fibonacci(){
    int i ;
    fib[0]=0 ;
    fib[1]=1 ;
    for(i=2 ; i<=MAX_SIZE ; i++){
      fib[i]=fib[i-1]+fib[i-2];
    }
  }
  static void printLevel(int level){
    int left_index=(int)Math.pow(2,level-1);
    int right_index=(int)(Math.pow(2,level)-1);
    for(int i=left_index ; i<=right_index ; i++){
      System.out.print(fib[i-1]+" ");
    }
    System.out.println();
  }
  public static void main(String[] args){
    fibonacci();
    int K=4 ;
    printLevel(K);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX_SIZE : int := 100005;
  static   attribute fib : Sequence(int) := Integer.subrange(1,MAX_SIZE + 1)->collect(0);
  static   operation fibonacci() : void
  pre: true
  post: true
  activity: (     var i : int ;
     fib[0+1] := 0 ; 
     fib[1+1] := 1 ; 
         i := 2 ; while i <= MAX_SIZE do ( (     fib[i+1] := fib[i - 1+1] + fib[i - 2+1] )  ;     i := i + 1 ) );
  static   operation printLevel( level : int) : void
  pre: true
  post: true
  activity: (     var left_index : int ; left_index := 2->pow(level - 1)->oclAsType(int) ;
     var right_index : int ; right_index := (2->pow(level) - 1)->oclAsType(int) ;
         var i : int ; i := left_index ; while i <= right_index do ( (     OclFile["System.out"].print(fib[i - 1+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute fibonacci() ; 
     var K : int ; K := 4 ;
     execute printLevel(K) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int decideWinner(int[] a,int n){
    int count0=0 ;
    int count1=0 ;
    int count2=0 ;
    int count3=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i] % 4==0)count0++;
      else if(a[i] % 4==1)count1++;
      else if(a[i] % 4==2)count2++;
      else if(a[i] % 4==3)count3++;
    }
    if(count0 % 2==0 && count1 % 2==0 && count2 % 2==0 && count3==0)return 1 ;
    else return 2 ;
  }
  public static void main(String args[]){
    int[] a={
      4,8,5,9 };
      int n=a.length ;
      if(decideWinner(a,n)==1)System.out.print("X wins");
      else System.out.print("Y wins");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation decideWinner( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count0 : int ; count0 := 0 ;
     var count1 : int ; count1 := 0 ;
    var count2 : int ; count2 := 0 ;
    var count3 : int ; count3 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] mod 4 = 0) then     count0 := count0 + 1 ; else     if (a[i+1] mod 4 = 1) then     count1 := count1 + 1 else     if (a[i+1] mod 4 = 2) then     count2 := count2 + 1 else     if (a[i+1] mod 4 = 3) then     count3 := count3 + 1 ; else skip ; ;  ;  )  ;     i := i + 1 ) ; 
    if (count0 mod 2 = 0 & count1 mod 2 = 0 & count2 mod 2 = 0 & count3 = 0) then     return 1 else     return 2 ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{4,8,5,9} ;
     var n : int ; n := a->size() ;
     if (decideWinner(a, n) = 1) then     OclFile["System.out"].print("X wins") ; else     OclFile["System.out"].print("Y wins") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MinOperation(int a[],int n,int k){
    int result=0 ;
    for(int i=0 ; i<n ; ++i){
      if(a[i]!=1 && a[i]>k){
        result=result+Math.min(a[i] % k,k-a[i] % k);
      }
      else {
        result=result+k-a[i];
      }
    }
    return result ;
  }
  public static void main(String[] args){
    int arr[]={
      4,5,6 };
      int n=arr.length ;
      int k=5 ;
      System.out.println(MinOperation(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MinOperation( a : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] /= 1 & a[i+1] > k) then (     result := result + Set{a[i+1] mod k, k - a[i+1] mod k}->min() ) else (     result := result + k - a[i+1] ) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,5,6} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 5 ;
     OclFile["System.out"].println(MinOperation(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Solution {
  public int subarraySum(int[] nums,int k){
    int count=0,sum=0 ;
    HashMap<Integer,Integer>map=new HashMap<>();
    map.put(0,1);
    for(int i=0 ; i<nums.length ; i++){
      sum+=nums[i];
      if(map.containsKey(sum-k))count+=map.get(sum-k);
      map.put(sum,map.getOrDefault(sum,0)+1);
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation subarraySum( nums : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
    var sum : int ; sum := 0 ;
     var map : Map(int,int) ; map := Map{} ;
    map := map->union(Map{0 |-> 1}) ; 
        var i : int ; i := 0 ; while i < nums->size() do ( (     sum := sum+(nums[i+1]) ; 
     if (map->keys()->includes(sum - k)) then     count := count+(map->at(sum - k)) ; else skip ; 
     map := map->union(Map{sum |-> (if map->keys()->contains(sum) then map->at(sum) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    return count 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class q {
  static Scanner in=new Scanner(System.in);
  int a[];
  void main(){
    int n=in.nextInt();
    a=new int[n];
    a[0]=in.nextInt();
    for(int i=1 ; i<n ; i++)a[i]=a[i-1]+in.nextInt();
    int t=(a[n-1] % 2==0)? a[n-1]/2 : a[n-1]/2+1 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]>=t){
        System.out.println(i+1);
        break ;
      }
    }
  }
  int bs(int x){
    int start=0,end=a.length-1,mid ;
    while(start<=end){
      mid=(start+end)/2 ;
      if(a[mid]==x)return mid ;
      if(a[mid]<x)start=mid ;
      if(mid==start)return(a[mid]>x)? mid : end ;
      else end=mid ;
    }
    return-1 ;
  }
  public static void main(String[] args){
(new q()).main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class q {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute a : Sequence(int);
   operation main() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     a := Integer.subrange(1,n)->collect(0) ; 
    a[0+1] := in.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i < n do (     a[i+1] := a[i - 1+1] + in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var t : int ; t := if (a[n - 1+1] mod 2 = 0) then a[n - 1+1] / 2 else a[n - 1+1] / 2 + 1 endif ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] >= t) then (     OclFile["System.out"].println(i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
   operation bs( x : int) : int
  pre: true
  post: true
  activity: (     var start : int ; start := 0 ;
    var end : int ; end := a->size() - 1 ;
    var mid : int ;
     while (start <= end) do (     mid := (start + end) / 2 ; 
     if (a[mid+1] = x) then     return mid else skip ; 
     if (a[mid+1] < x) then     start := mid ; else skip ; 
     if (mid = start) then     return if (a[mid+1] > x) then mid else end endif else     end := mid ; ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (q.newq()).main() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MonsterHit {
  static int h1 ;
  static int a1 ;
  static int c1 ;
  static int h2 ;
  static int a2 ;
  static int minMove=Integer.MAX_VALUE ;
  static List<String>res ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    h1=scanner.nextInt();
    a1=scanner.nextInt();
    c1=scanner.nextInt();
    h2=scanner.nextInt();
    a2=scanner.nextInt();
    List<String>actionList=new ArrayList<>();
    dfs(actionList,h1,h2);
    System.out.println(minMove);
    for(String s : res){
      System.out.println(s);
    }
  }
  public static void dfs(List<String>moves,int myhealth,int monsterhealth){
    if(monsterhealth<=0 && myhealth>0){
      if(moves.size()<minMove){
        minMove=moves.size();
        res=new ArrayList<>(moves);
      }
      return ;
    }
    if(myhealth>0 && monsterhealth-a1<=0){
      moves.add("STRIKE");
      dfs(moves,myhealth,monsterhealth-a1);
      return ;
    }
    if(myhealth<=a2){
      moves.add("HEAL");
      dfs(moves,myhealth+c1-a2,monsterhealth);
      return ;
    }
    moves.add("STRIKE");
    if(monsterhealth-a1<=0){
      dfs(moves,myhealth,monsterhealth-a1);
    }
    else {
      dfs(moves,myhealth-a2,monsterhealth-a1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MonsterHit {
  static   attribute h1 : int;
  static   attribute a1 : int;
  static   attribute c1 : int;
  static   attribute h2 : int;
  static   attribute a2 : int;
  static   attribute minMove : int := 2147483647;
  static   attribute res : Sequence(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     h1 := scanner.getCurrent()->toInteger() ; 
    a1 := scanner.getCurrent()->toInteger() ; 
    c1 := scanner.getCurrent()->toInteger() ; 
    h2 := scanner.getCurrent()->toInteger() ; 
    a2 := scanner.getCurrent()->toInteger() ; 
    var actionList : Sequence(String) ; actionList := Sequence{} ;
    execute dfs(actionList, h1, h2) ; 
    OclFile["System.out"].println(minMove) ; 
    for (s : res) do ( (     OclFile["System.out"].println(s) )  ) ; 
 );
  static   operation dfs( moves : Sequence(String), myhealth : int, monsterhealth : int) : void
  pre: true
  post: true
  activity: (     if (monsterhealth <= 0 & myhealth > 0) then (     if (moves->size() < minMove) then (     minMove := moves->size() ; 
     res := Sequence{}->union(moves) ) else skip ; 
     return ) else skip ; 
     if (myhealth > 0 & monsterhealth - a1 <= 0) then (     moves->excludes("STRIKE") ; 
     execute dfs(moves, myhealth, monsterhealth - a1) ; 
     return ) else skip ; 
    if (myhealth <= a2) then (     moves->excludes("HEAL") ; 
     execute dfs(moves, myhealth + c1 - a2, monsterhealth) ; 
     return ) else skip ; 
    moves->excludes("STRIKE") ; 
    if (monsterhealth - a1 <= 0) then (     execute dfs(moves, myhealth, monsterhealth - a1) ) else (     execute dfs(moves, myhealth - a2, monsterhealth - a1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Gfg {
  static int arr[]={
    1,5,6 };
    static int countWays(int N){
      int count[]=new int[N+1];
      count[0]=1 ;
      for(int i=1 ; i<=N ; i++)for(int j=0 ; j<arr.length ; j++)if(i>=arr[j])count[i]+=count[i-arr[j] ];
      return count[N];
    }
    public static void main(String[] args){
      int N=7 ;
      System.out.println("Total number of ways="+countWays(N));
    }
  }

------------------------------------------------------------
OCL File:
---------
class Gfg {
  static   attribute arr : int := Sequence{1,5,6};
  static   operation countWays( N : int) : int
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,N + 1)->collect(0) ;
     count[0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= N do (         var j : int ; j := 0 ; while j < arr->size() do (     if (i >= arr[j+1]) then     count[i+1] := count[i+1]+(count[i - arr[j+1]+1]) ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return count[N+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 7 ;
     OclFile["System.out"].println("Total number of ways=" + countWays(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  static long mod=1000003 ;
  static long pow(long a,long b){
    if(b==0)return 1 ;
    long ans=pow(a,b/2);
    if(b % 2==0)return ans*ans % mod ;
    return ans*ans % mod*a % mod ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();
    boolean bl=true ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      if(map.containsKey(arr[i]))map.replace(arr[i],map.get(arr[i])+1);
      else map.put(arr[i],1);
    }
    if(n==1 && arr[0]==0)bl=false ;
    int two=0 ;
    for(Map.Entry entry : map.entrySet()){
      int v=(int)entry.getValue();
      if(v==2)two++;
      if(v>2)bl=false ;
    }
    if(two>1)bl=false ;
    if(map.containsKey(0)&& map.get(0)>1)bl=false ;
    if(two==1){
      for(int i=0 ; i<n ; i++){
        if(map.get(arr[i])==2){
          if(map.containsKey(arr[i]-1))bl=false ;
        }
      }
    }
    if(! bl)System.out.println("cslnb");
    else {
      Arrays.sort(arr);
      int tot=0 ;
      for(int i=0 ; i<n ; i++){
        tot+=arr[i]-i ;
        tot %=2 ;
      }
      if(tot % 2==0)System.out.println("cslnb");
      else System.out.println("sjfnb");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute mod : long := 1000003;
  static   operation pow( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return 1 else skip ; 
     var ans : long ; ans := pow(a, b / 2) ;
     if (b mod 2 = 0) then     return ans * ans mod mod else skip ; 
     return ans * ans mod mod * a mod mod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var map : Map(int,int) ; map := Map{} ;
    var bl : boolean ; bl := true ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (map->keys()->includes(arr[i+1])) then     map := map.replace(arr[i+1], map->at(arr[i+1]) + 1) ; else     map := map->union(Map{arr[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
    if (n = 1 & arr[0+1] = 0) then     bl := false ; else skip ; 
    var two : int ; two := 0 ;
    for (entry : map->asSet()) do ( (     var v : int ; v := entry.getValue()->oclAsType(int) ;
     if (v = 2) then     two := two + 1 ; else skip ; 
     if (v > 2) then     bl := false ; else skip )  ) ; 
    if (two > 1) then     bl := false ; else skip ; 
    if (map->keys()->includes(0) & map->at(0) > 1) then     bl := false ; else skip ; 
    if (two = 1) then (         var i : int ; i := 0 ; while i < n do ( (     if (map->at(arr[i+1]) = 2) then (     if (map->keys()->includes(arr[i+1] - 1)) then     bl := false ; else skip ) else skip )  ;     i := i + 1 ) ) else skip ; 
    if (not(bl)) then     OclFile["System.out"].println("cslnb") else (     arr := arr->sort() ; 
     var tot : int ; tot := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     tot := tot+(arr[i+1] - i) ; 
     tot := tot mod 2 )  ;     i := i + 1 ) ; 
     if (tot mod 2 = 0) then     OclFile["System.out"].println("cslnb") ; else     OclFile["System.out"].println("sjfnb") ; ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.StringTokenizer ;
public class Div1B {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    FastReader fsr=new FastReader();
    String sequence=fsr.nextLine();
    solution(sequence,out);
    out.flush();
    out.close();
  }
  private static void solution(String sequence,PrintWriter out){
    int n=sequence.length();
    BigInteger MOD=BigInteger.valueOf(1000000007L);
    BigInteger minNumMoves=BigInteger.ZERO ;
    BigInteger numB=BigInteger.ZERO ;
    for(int i=n-1 ; i>=0 ; i--){
      char curr=sequence.charAt(i);
      if(curr=='b'){
        numB=numB.add(BigInteger.ONE);
      }
      else {
        minNumMoves=minNumMoves.add(numB);
        minNumMoves=minNumMoves.mod(MOD);
        numB=numB.shiftLeft(1);
        numB=numB.mod(MOD);
      }
    }
    out.println(minNumMoves);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Div1B {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var fsr : FastReader ; fsr := FastReader.newFastReader() ;
    var sequence : String ; sequence := fsr.nextLine() ;
    execute solution(sequence, out) ; 
    skip ; 
    skip ; 
 );
  static   operation solution( sequence : String, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sequence->size() ;
     var MOD : long ; MOD := (1000000007L + "")->toLong() ;
    var minNumMoves : long ; minNumMoves := 0 ;
    var numB : long ; numB := 0 ;
        var i : int ; i := (n)->char2byte() - 1 ; while i >= 0 do ( (     var curr : String ; curr := sequence->at(i+1) ;
     if (curr = 'b') then (     numB := numB->excludes(1) ) else (     minNumMoves := minNumMoves->excludes(numB) ; 
     minNumMoves := minNumMoves.mod(MOD) ; 
     numB := numB.shiftLeft(1) ; 
     numB := numB.mod(MOD) ) )  ;     i := i - 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args)throws java.lang.Exception {
    FastReader sc=new FastReader();
    String s=sc.next();
    int mod=1000000007 ;
    int bnum=0 ;
    int step=0 ;
    for(int i=s.length()-1 ; i>=0 ; i--){
      char ch=s.charAt(i);
      if(ch=='b'){
        bnum++;
      }
      else {
        step+=bnum ;
        bnum*=2 ;
        step=step % mod ;
        bnum=bnum % mod ;
      }
    }
    System.out.println(step);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var s : String ; s := sc.next() ;
    var mod : int ; mod := 1000000007 ;
    var bnum : int ; bnum := 0 ;
    var step : int ; step := 0 ;
        var i : int ; i := s->size() - 1 ; while i >= 0 do ( (     var ch : String ; ch := s->at(i+1) ;
     if (ch = 'b') then (     bnum := bnum + 1 ) else (     step := step+(bnum) ; 
     bnum := bnum*(2) ; 
     step := step mod mod ; 
     bnum := bnum mod mod ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(step) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class MinimumNumberOfSteps {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int mod=(int)1e9+7 ;
    String s=br.readLine();
    long res=0 ;
    long rightB=0 ;
    int n=s.length();
    for(int i=n-1 ; i>=0 ; i--){
      if(s.charAt(i)=='b'){
        rightB++;
      }
      else if(s.charAt(i)=='a'){
        res+=rightB ;
        res %=mod ;
        rightB*=2 ;
        rightB %=mod ;
      }
    }
    pr.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MinimumNumberOfSteps {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var mod : int ; mod := 1e9->oclAsType(int) + 7 ;
     var s : String ; s := br.readLine() ;
    var res : long ; res := 0 ;
    var rightB : long ; rightB := 0 ;
    var n : int ; n := s->size() ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (s->at(i+1) = 'b') then (     rightB := rightB + 1 ) else     if (s->at(i+1) = 'a') then (     res := res+(rightB) ; 
     res := res mod mod ; 
     rightB := rightB*(2) ; 
     rightB := rightB mod mod ) else skip ; )  ;     i := i - 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int swapBits(int x,int p1,int p2,int n){
    int set1=(x>>p1)&((1<<n)-1);
    int set2=(x>>p2)&((1<<n)-1);
    int xor=(set1 ^ set2);
    xor=(xor<<p1)|(xor<<p2);
    int result=x ^ xor ;
    return result ;
  }
  public static void main(String[] args){
    int res=swapBits(28,0,3,2);
    System.out.println("Result="+res);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation swapBits( x : int, p1 : int, p2 : int, n : int) : int
  pre: true
  post: true
  activity: (     var set1 : int ; set1 := MathLib.bitwiseAnd(((x/(2->pow(p1)))->oclAsType(long)),(((1*(2->pow(n)))->oclAsType(long)) - 1)) ;
     var set2 : int ; set2 := MathLib.bitwiseAnd(((x/(2->pow(p2)))->oclAsType(long)),(((1*(2->pow(n)))->oclAsType(long)) - 1)) ;
    var xor : int ; xor := (MathLib.bitwiseXor(set1,set2)) ;
    xor := ((xor*(2->pow(p1)))->oclAsType(long)) or ((xor*(2->pow(p2)))->oclAsType(long)) ; 
    var result : int ; result := MathLib.bitwiseXor(x,xor) ;
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var res : int ; res := swapBits(28, 0, 3, 2) ;
     OclFile["System.out"].println("Result=" + res) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test232 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int a=in.nextInt();
      int b=in.nextInt();
      int c=in.nextInt();
      int x=in.nextInt();
      int y=in.nextInt();
      if(x>a){
        c-=(x-a);
      }
      if(y>b){
        c-=(y-b);
      }
      if(c>=0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test232 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
    var y : int ; y := in.getCurrent()->toInteger() ;
    if (x > a) then (     c := c-((x - a)) ) else skip ; 
    if (y > b) then (     c := c-((y - b)) ) else skip ; 
    if (c >= 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1675A_FoodForAnimal {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int a=input.nextInt();
      int b=input.nextInt();
      int c=input.nextInt();
      int x=input.nextInt();
      int y=input.nextInt();
      input.nextLine();
      int dogNeed=0 ;
      int catNeed=0 ;
      if(x>a){
        dogNeed=x-a ;
        c-=dogNeed ;
      }
      if(y>b){
        catNeed=y-b ;
        c-=catNeed ;
      }
      if(c<0){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1675A_FoodForAnimal {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var a : int ; a := input.getCurrent()->toInteger() ;
     var b : int ; b := input.getCurrent()->toInteger() ;
    var c : int ; c := input.getCurrent()->toInteger() ;
    var x : int ; x := input.getCurrent()->toInteger() ;
    var y : int ; y := input.getCurrent()->toInteger() ;
    skip ; 
    var dogNeed : int ; dogNeed := 0 ;
    var catNeed : int ; catNeed := 0 ;
    if (x > a) then (     dogNeed := x - a ; 
     c := c-(dogNeed) ) else skip ; 
    if (y > b) then (     catNeed := y - b ; 
     c := c-(catNeed) ) else skip ; 
    if (c < 0) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class FoodAnimals {
  int number ;
  public FoodAnimals(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  public void input(int a,int b,int c,int x,int y){
    int dogComplete=x-a ;
    int catComplete=y-b ;
    if(dogComplete<=0 && catComplete<=0){
      System.out.println("YES");
    }
    else {
      if(dogComplete<0 || catComplete<0){
        if(dogComplete<0){
          dogComplete=0 ;
        }
        else {
          catComplete=0 ;
        }
      }
      int animalComplete=(dogComplete+catComplete)-c ;
      if(animalComplete<=0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
  public static void main(String[] a){
    Scanner s=new Scanner(System.in);
    int number=s.nextInt();
    FoodAnimals instance=new FoodAnimals(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      int num1=s.nextInt();
      int num2=s.nextInt();
      int num3=s.nextInt();
      int num4=s.nextInt();
      int num5=s.nextInt();
      instance.input(num1,num2,num3,num4,num5);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class FoodAnimals {
   attribute number : int;
   static operation newFoodAnimals( number : int) : FoodAnimals
  pre: true
  post: true
  activity:
  ( var self : FoodAnimals ;
    self := createFoodAnimals();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
   operation input( a : int, b : int, c : int, x : int, y : int) : void
  pre: true
  post: true
  activity: (     var dogComplete : int ; dogComplete := x - a ;
     var catComplete : int ; catComplete := y - b ;
     if (dogComplete <= 0 & catComplete <= 0) then (     OclFile["System.out"].println("YES") ) else (     if (dogComplete < 0 or catComplete < 0) then (     if (dogComplete < 0) then (     dogComplete := 0 ) else (     catComplete := 0 ) ) else skip ; 
     var animalComplete : int ; animalComplete := (dogComplete + catComplete) - c ;
     if (animalComplete <= 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := s.getCurrent()->toInteger() ;
     var instance : FoodAnimals ; instance := FoodAnimals.newFoodAnimals(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var num1 : int ; num1 := s.getCurrent()->toInteger() ;
     var num2 : int ; num2 := s.getCurrent()->toInteger() ;
    var num3 : int ; num3 := s.getCurrent()->toInteger() ;
    var num4 : int ; num4 := s.getCurrent()->toInteger() ;
    var num5 : int ; num5 := s.getCurrent()->toInteger() ;
    instance.input(num1, num2, num3, num4, num5) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.*;
public class CD {
  public static void main(String[] args){
    Scanner st=new Scanner(System.in);
    int n=st.nextInt();
    while(n-->0){
      int a=st.nextInt();
      int b=st.nextInt();
      int c=st.nextInt();
      int x=st.nextInt();
      int y=st.nextInt();
      int dog=a-x ;
      int cat=b-y ;
      if(dog<0){
        c+=dog ;
      }
      if(cat<0){
        c+=cat ;
      }
      if(c>=0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CD {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var st : OclFile ; st := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := st.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var a : int ; a := st.getCurrent()->toInteger() ;
     var b : int ; b := st.getCurrent()->toInteger() ;
    var c : int ; c := st.getCurrent()->toInteger() ;
    var x : int ; x := st.getCurrent()->toInteger() ;
    var y : int ; y := st.getCurrent()->toInteger() ;
    var dog : int ; dog := a - x ;
    var cat : int ; cat := b - y ;
    if (dog < 0) then (     c := c+(dog) ) else skip ; 
    if (cat < 0) then (     c := c+(cat) ) else skip ; 
    if (c >= 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Tttest {
  public static String fun(long[] arr){
    long rem1=0 ;
    long rem2=0 ;
    long total=0 ;
    if(arr[3]>arr[0]){
      rem1=arr[3]-arr[0];
    }
    if(arr[4]>arr[1]){
      rem2=arr[4]-arr[1];
    }
    total=rem1+rem2 ;
    if(total>arr[2]){
      return "NO" ;
    }
    else {
      return "YES" ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      long[] arr=new long[5];
      for(int i=0 ; i<arr.length ; i++){
        arr[i]=sc.nextLong();
      }
      System.out.println(fun(arr));
      t--;
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Tttest {
  static   operation fun( arr : Sequence(long)) : String
  pre: true
  post: true
  activity: (     var rem1 : long ; rem1 := 0 ;
     var rem2 : long ; rem2 := 0 ;
    var total : long ; total := 0 ;
    if (arr[3+1] > arr[0+1]) then (     rem1 := arr[3+1] - arr[0+1] ) else skip ; 
    if (arr[4+1] > arr[1+1]) then (     rem2 := arr[4+1] - arr[1+1] ) else skip ; 
    total := rem1 + rem2 ; 
    if (total > arr[2+1]) then (     return "NO" ) else (     return "YES" ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var arr : Sequence(long) ; arr := Integer.subrange(1,5)->collect(0) ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(fun(arr)) ; 
     t := t - 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int centered_square_num(int n){
    return n*n+((n-1)*(n-1));
  }
  public static void main(String[] args){
    int n=7 ;
    System.out.print(n+"th Centered"+" square number: "+centered_square_num(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation centered_square_num( n : int) : int
  pre: true
  post: true
  activity: (     return n * n + ((n - 1) * (n - 1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     OclFile["System.out"].print(n + "th Centered" + " square number: " + centered_square_num(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class pre53 {
  public static void main(String args[]){
    Scanner obj=new Scanner(System.in);
    int n=obj.nextInt(),arr[]=new int[n],sum2=0,sum1=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=obj.nextInt();
      sum1+=arr[i];
    }
    int index=-1 ;
    for(int i=0 ; i<n ; i++){
      sum2+=arr[i];
      if(sum2*2>=sum1){
        index=i ;
        break ;
      }
    }
    System.out.println(index+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre53 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : OclFile ; obj := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := obj.getCurrent()->toInteger() ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum2 : int ; sum2 := 0 ;
    var sum1 : int ; sum1 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := obj.getCurrent()->toInteger() ; 
     sum1 := sum1+(arr[i+1]) )  ;     i := i + 1 ) ; 
    var index : int ; index := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     sum2 := sum2+(arr[i+1]) ; 
     if (sum2 * 2 >= sum1) then (     index := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(index + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Stringfun {
  String str="Geeks for Geeks." ;
  void words(){
    int wCount=0,uCount=0,vCount=0 ;
    for(int i=0 ; i<str.length(); i++){
      char c=str.charAt(i);
      switch(c){
        case ' ' : case '.' : wCount++;
      }
      switch(c){
        case 'A' : case 'E' : case 'I' : case 'O' : case 'U' : case 'a' : case 'e' : case 'i' : case 'o' : case 'u' : vCount++;
      }
      if(c>=65 && c<=90){
        uCount++;
      }
    }
    System.out.println("Number of words="+wCount);
    System.out.println("Number of vowels="+vCount);
    System.out.println("Number of upper case characters="+uCount);
  }
  void frequency(){
    TreeMap<Character,Integer>hmap=new TreeMap<Character,Integer>();
    for(int i=0 ; i<str.length(); i++){
      Integer c=hmap.get(str.charAt(i));
      if(hmap.get(str.charAt(i))==null)hmap.put(str.charAt(i),1);
      else hmap.put(str.charAt(i),++c);
    }
    for(Map.Entry m : hmap.entrySet())System.out.println("Character="+m.getKey()+" Frequency="+m.getValue());
  }
  public static void main(String args[])throws IOException {
    Stringfun obj=new Stringfun();
    obj.words();
    obj.frequency();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Stringfun {
   attribute str : String := "Geeks for Geeks.";
   operation words() : void
  pre: true
  post: true
  activity: (     var wCount : int ; wCount := 0 ;
    var uCount : int ; uCount := 0 ;
    var vCount : int ; vCount := 0 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     var c : String ; c := str->at(i+1) ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
    if _switchval = ' ' or _switchval = '.' then
    wCount := wCount + 1 ; 
   else skip ;
      )
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
    if _switchval = 'A' or _switchval = 'E' or _switchval = 'I' or _switchval = 'O' or _switchval = 'U' then
   if _switchval = 'a' then
   if _switchval = 'e' then
   if _switchval = 'i' then
   if _switchval = 'o' then
   if _switchval = 'u' then
    vCount := vCount + 1 ; 
   else skip ;
      )
     if (c >= 65 & c <= 90) then (     uCount := uCount + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Number of words=" + wCount) ; 
    OclFile["System.out"].println("Number of vowels=" + vCount) ; 
    OclFile["System.out"].println("Number of upper case characters=" + uCount) ; 
 );
   operation frequency() : void
  pre: true
  post: true
  activity: (     var hmap : Map(String,int) ; hmap := Map{} ;
         var i : int ; i := 0 ; while i < str->size() do ( (     var c : int ; c := hmap->at(str->at(i+1)) ;
     if (hmap->at(str->at(i+1)) = null) then     hmap := hmap->union(Map{str->at(i+1) |-> 1}) ; else     hmap := hmap->union(Map{str->at(i+1) |-> (c + 1)}) ; )  ;     i := i + 1 ) ; 
     for (m : hmap->asSet()) do (     OclFile["System.out"].println("Character=" + m.getKey() + " Frequency=" + m.getValue()) ;  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Stringfun ; obj := Stringfun.newStringfun() ;
     obj.words() ; 
     obj.frequency() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
class GfG {
  public static int findLCM(int a,int b){
    int lar=Math.max(a,b);
    int small=Math.min(a,b);
    for(int i=lar ; ; i+=lar){
      if(i % small==0)return i ;
    }
  }
  public static void main(String[] argc){
    int a=5,b=7 ;
    System.out.println("LCM of "+a+" and "+b+" is "+findLCM(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation findLCM( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var lar : int ; lar := Set{a, b}->max() ;
     var small : int ; small := Set{a, b}->min() ;
         var i : int ; i := lar ; while true do ( (     if (i mod small = 0) then     return i else skip )  ;     i := i+(lar) ) );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 5 ;
    var b : int ; b := 7 ;
     OclFile["System.out"].println("LCM of " + a + " and " + b + " is " + findLCM(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countways(int a[],int n){
    int cnt[]=new int[n];
    int s=0 ;
    for(int i=0 ; i<n ; i++){
      s+=a[i];
    }
    if(s % 3!=0)return 0 ;
    s/=3 ;
    int ss=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      ss+=a[i];
      if(ss==s)cnt[i]=1 ;
    }
    for(int i=n-2 ; i>=0 ; i--)cnt[i]+=cnt[i+1];
    int ans=0 ;
    ss=0 ;
    for(int i=0 ; i+2<n ; i++){
      ss+=a[i];
      if(ss==s)ans+=cnt[i+2];
    }
    return ans ;
  }
  public static void main(String[] args){
    int n=5 ;
    int a[]={
      1,2,3,0,3 };
      System.out.println(countways(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countways( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var cnt : Sequence(int) ; cnt := Integer.subrange(1,n)->collect(0) ;
     var s : int ; s := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     s := s+(a[i+1]) )  ;     i := i + 1 ) ; 
    if (s mod 3 /= 0) then     return 0 else skip ; 
    s := s/(3) ; 
    var ss : int ; ss := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     ss := ss+(a[i+1]) ; 
     if (ss = s) then     cnt[i+1] := 1 ; else skip )  ;     i := i - 1 ) ; 
        var i : int ; i := n - 2 ; while i >= 0 do (     cnt[i+1] := cnt[i+1]+(cnt[i + 1+1]) ;  ;     i := i - 1 ) ; 
    var ans : int ; ans := 0 ;
    ss := 0 ; 
        var i : int ; i := 0 ; while i + 2 < n do ( (     ss := ss+(a[i+1]) ; 
     if (ss = s) then     ans := ans+(cnt[i + 2+1]) ; else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var a : Sequence(int) ; a := Sequence{1,2,3,0,3} ;
     OclFile["System.out"].println(countways(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int nextPowerOf2(int n){
    int count=0 ;
    if(n>0 &&(n &(n-1))==0)return n ;
    while(n!=0){
      n>>=1 ;
      count+=1 ;
    }
    return 1<<count ;
  }
  public static void main(String args[]){
    int n=0 ;
    System.out.println(nextPowerOf2(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nextPowerOf2( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     if (n > 0 & (n & (n - 1)) = 0) then     return n else skip ; 
     while (n /= 0) do (     n := n/(2->pow(1)) ; 
     count := count+(1) ) ; 
     return (1*(2->pow(count)))->oclAsType(long) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 0 ;
     OclFile["System.out"].println(nextPowerOf2(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int nextPowerOf2(int n){
    int p=1 ;
    if(n>0 &&(n &(n-1))==0)return n ;
    while(p<n)p<<=1 ;
    return p ;
  }
  public static void main(String args[]){
    int n=5 ;
    System.out.println(nextPowerOf2(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nextPowerOf2( n : int) : int
  pre: true
  post: true
  activity: (     var p : int ; p := 1 ;
     if (n > 0 & (n & (n - 1)) = 0) then     return n else skip ; 
     while (p < n) do     p := p*(2->pow(1)) ; ; 
     return p );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(nextPowerOf2(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int countPieces(int N){
    return 2*N ;
  }
  public static void main(String args[]){
    int N=100 ;
    System.out.println(countPieces(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation countPieces( N : int) : int
  pre: true
  post: true
  activity: (     return 2 * N );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 100 ;
     OclFile["System.out"].println(countPieces(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p097 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p097().run());
  }
  public String run(){
    BigInteger modulus=BigInteger.TEN.pow(10);
    BigInteger n=BigInteger.valueOf(2).modPow(BigInteger.valueOf(7830457),modulus);
    n=n.multiply(BigInteger.valueOf(28433)).mod(modulus);
    n=n.add(BigInteger.ONE).mod(modulus);
    return String.format("%010d",n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p097 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p097.newp097().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var modulus : long ; modulus := 10.pow(10) ;
     var n : long ; n := (2 + "")->toLong().modPow((7830457 + "")->toLong(), modulus) ;
    n := n.multiply((28433 + "")->toLong()).mod(modulus) ; 
    n := n->excludes(1).mod(modulus) ; 
    return StringLib.format("%010d",Sequence{n}) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static long MOD=(long)Math.pow(10,9)+7 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    int A=sc.nextInt();
    int B=sc.nextInt();
    long[] f=new long[2*(int)Math.pow(10,5)+1];
    long[] g=new long[2*(int)Math.pow(10,5)+1];
    f[0]=1 ;
    g[0]=1 ;
    for(int i=1 ; i<f.length ; i++){
      f[i]=(f[i-1]*i)% MOD ;
      g[i]=func(f[i],MOD-2);
    }
    long ans=(((f[H+W-2]*g[H-1])% MOD)*g[W-1])% MOD ;
    for(int r=0 ; r<B ; r++){
      long a=(((f[H-A-1+r]*g[r])% MOD)*g[H-A-1])% MOD ;
      long b=(((f[W-r-1+A-1]*g[W-r-1])% MOD)*g[A-1])% MOD ;
      ans-=(a*b)% MOD ;
      if(ans<0)ans+=MOD ;
    }
    System.out.println(ans);
  }
  public static long func(long a,long x){
    if(x==0)return 1 ;
    if(x % 2==0){
      long t=func(a,x/2);
      return(t*t)% MOD ;
    }
    else {
      long t=func(a,x/2);
      long s=(a*t)% MOD ;
      s=(s*t)% MOD ;
      return s ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : long := 10->pow(9)->oclAsType(long) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var f : Sequence(long) ; f := Integer.subrange(1,2 * 10->pow(5)->oclAsType(int) + 1)->collect(0) ;
    var g : Sequence(long) ; g := Integer.subrange(1,2 * 10->pow(5)->oclAsType(int) + 1)->collect(0) ;
    f[0+1] := 1 ; 
    g[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < f->size() do ( (     f[i+1] := (f[i - 1+1] * i) mod MOD ; 
     g[i+1] := func(f[i+1], MOD - 2) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := (((f[H + W - 2+1] * g[H - 1+1]) mod MOD) * g[W - 1+1]) mod MOD ;
        var r : int ; r := 0 ; while r < B do ( (     var a : long ; a := (((f[H - A - 1 + r+1] * g[r+1]) mod MOD) * g[H - A - 1+1]) mod MOD ;
     var b : long ; b := (((f[W - r - 1 + A - 1+1] * g[W - r - 1+1]) mod MOD) * g[A - 1+1]) mod MOD ;
     ans := ans-((a * b) mod MOD) ; 
     if (ans < 0) then     ans := ans+(MOD) ; else skip )  ;     r := r + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation func( a : long, x : long) : long
  pre: true
  post: true
  activity: (     if (x = 0) then     return 1 else skip ; 
     if (x mod 2 = 0) then (     var t : long ; t := func(a, x / 2) ;
     return (t * t) mod MOD ) else (     var t : long ; t := func(a, x / 2) ;
     var s : long ; s := (a * t) mod MOD ;
     s := (s * t) mod MOD ; 
     return s ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  long MOD=1_000_000_000+7 ;
  long[] pow,rev ;
  long pow(long n,int k){
    if(k==0){
      return 1 ;
    }
    if(k % 2==0){
      long t=pow(n,k/2);
      t %=MOD ;
      return t*t % MOD ;
    }
    else {
      long t=pow(n,(k-1)/2);
      t %=MOD ;
      t*=t ;
      t %=MOD ;
      return t*n % MOD ;
    }
  }
  long combi(int n,int k){
    long ret=1 ;
    ret*=pow[n];
    ret*=rev[k];
    ret %=MOD ;
    ret*=rev[n-k];
    return ret % MOD ;
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int hh=sc.nextInt();
    int ww=sc.nextInt();
    pow=new long[h+w+1];
    rev=new long[h+w+1];
    pow[0]=1 ;
    rev[0]=1 ;
    for(int i=1 ; i<h+w+1 ; i++){
      pow[i]=pow[i-1]*i ;
      pow[i] %=MOD ;
      rev[i]=pow(pow[i],(int)MOD-2);
    }
    long ans=0 ;
    for(int i=1 ; i<=w-ww ; i++){
      long tmp1=combi(ww-1+i+h-hh-1,h-hh-1);
      long tmp2=combi(w-ww-i+hh-1,hh-1);
      ans+=tmp1*tmp2 ;
      ans %=MOD ;
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute MOD : long := 1_000_000_000 + 7;
   attribute pow : Sequence(long);
   operation pow( n : long, k : int) : long
  pre: true
  post: true
  activity: (     if (k = 0) then (     return 1 ) else skip ; 
     if (k mod 2 = 0) then (     var t : long ; t := pow(n, k / 2) ;
     t := t mod MOD ; 
     return t * t mod MOD ) else (     var t : long ; t := pow(n, (k - 1) / 2) ;
     t := t mod MOD ; 
    t := t*(t) ; 
    t := t mod MOD ; 
    return t * n mod MOD 
 ) );
   operation combi( n : int, k : int) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := 1 ;
     ret := ret*(pow[n+1]) ; 
    ret := ret*(rev[k+1]) ; 
    ret := ret mod MOD ; 
    ret := ret*(rev[n - k+1]) ; 
    return ret mod MOD 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var hh : int ; hh := sc.getCurrent()->toInteger() ;
    var ww : int ; ww := sc.getCurrent()->toInteger() ;
    pow := Integer.subrange(1,h + w + 1)->collect(0) ; 
    rev := Integer.subrange(1,h + w + 1)->collect(0) ; 
    pow[0+1] := 1 ; 
    rev[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < h + w + 1 do ( (     pow[i+1] := pow[i - 1+1] * i ; 
     pow[i+1] := pow[i+1] mod MOD ; 
     rev[i+1] := pow(pow[i+1], MOD->oclAsType(int) - 2) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= w - ww do ( (     var tmp1 : long ; tmp1 := combi(ww - 1 + i + h - hh - 1, h - hh - 1) ;
     var tmp2 : long ; tmp2 := combi(w - ww - i + hh - 1, hh - 1) ;
     ans := ans+(tmp1 * tmp2) ; 
     ans := ans mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int numberOfWays(int x){
    if(x==0 || x==1)return 1 ;
    else return numberOfWays(x-1)+(x-1)*numberOfWays(x-2);
  }
  public static void main(String[] args){
    int x=3 ;
    System.out.println(numberOfWays(x));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation numberOfWays( x : int) : int
  pre: true
  post: true
  activity: (     if (x = 0 or x = 1) then     return 1 else     return numberOfWays(x - 1) + (x - 1) * numberOfWays(x - 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 3 ;
     OclFile["System.out"].println(numberOfWays(x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      int m=scanner.nextInt();
      int s=scanner.nextInt();
      int g1=scanner.nextInt();
      int g2=scanner.nextInt();
      if((n | m | s | g1 | g2)==0)break ;
      s--;
      g1--;
      g2--;
      int[][] g=new int[n][n];
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)g[i][j]=i==j ? 0 : INF ;
      while(m-->0){
        int b1=scanner.nextInt()-1 ;
        int b2=scanner.nextInt()-1 ;
        int c=scanner.nextInt();
        g[b1][b2]=c ;
      }
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)for(int k=0 ; k<n ; k++)g[j][k]=Math.min(g[j][k],g[j][i]+g[i][k]);
      int ans=INF ;
      for(int i=0 ; i<n ; i++)ans=Math.min(ans,g[s][i]+g[i][g1]+g[i][g2]);
      System.out.println(ans);
    }
  }
  int INF=1<<29 ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
    var s : int ; s := scanner.getCurrent()->toInteger() ;
    var g1 : int ; g1 := scanner.getCurrent()->toInteger() ;
    var g2 : int ; g2 := scanner.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(MathLib.bitwiseOr(MathLib.bitwiseOr(n,m),s),g1),g2)) = 0) then     break else skip ; 
    s := s - 1 ; 
    g1 := g1 - 1 ; 
    g2 := g2 - 1 ; 
    var g : Sequence(Sequence(int)) ; g := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (     g[i+1][j+1] := if i = j then 0 else INF endif ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        while (m > 0) do (        m := m - 1 ;     skip ; (     var b1 : int ; b1 := scanner.getCurrent()->toInteger() - 1 ;
     var b2 : int ; b2 := scanner.getCurrent()->toInteger() - 1 ;
     var c : int ; c := scanner.getCurrent()->toInteger() ;
     g[b1+1][b2+1] := c ) ;  ) ;  
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (         var k : int ; k := 0 ; while k < n do (     g[j+1][k+1] := Set{g[j+1][k+1], g[j+1][i+1] + g[i+1][k+1]}->min() ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := INF ;
        var i : int ; i := 0 ; while i < n do (     ans := Set{ans, g[s+1][i+1] + g[i+1][g1+1] + g[i+1][g2+1]}->min() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
   attribute INF : int := (1*(2->pow(29)))->oclAsType(long);
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  HashMap<List<Long>,Long>f=new HashMap<>();
  int N ;
  long W ;
  long[] w,v ;
  void run(){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    W=sc.nextLong();
    w=new long[N];
    v=new long[N];
    for(int i=0 ; i<N ; ++i){
      w[i]=sc.nextLong();
      v[i]=sc.nextLong();
    }
    System.out.println(func(W,0));
  }
  long func(long ww,int num){
    if(ww<0)return-Long.MAX_VALUE/16 ;
    if(num==N)return 0 ;
    if(f.containsKey(Arrays.asList(ww,(long)num)))return f.get(Arrays.asList(ww,(long)num));
    long ret=Math.max(func(ww-w[num],num+1)+v[num],func(ww,num+1));
    f.put(Arrays.asList(ww,(long)num),ret);
    return ret ;
  }
  void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute f : Map(Sequence(long),long) := Map{};
   attribute N : int;
   attribute W : long;
   attribute w : Sequence(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
    W := sc.getCurrent()->toLong() ; 
    w := Integer.subrange(1,N)->collect(0) ; 
    v := Integer.subrange(1,N)->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     w[i+1] := sc.getCurrent()->toLong() ; 
     v[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(func(W, 0)) ; 
 );
   operation func( ww : long, num : int) : long
  pre: true
  post: true
  activity: (     if (ww < 0) then     return -"9223372036854775807"->toLong() / 16 else skip ; 
     if (num = N) then     return 0 else skip ; 
    if (f->keys()->includes(Sequence{ww,num->oclAsType(long)})) then     return f->at(Sequence{ww,num->oclAsType(long)}) else skip ; 
    var ret : long ; ret := Set{func(ww - w[num+1], num + 1) + v[num+1], func(ww, num + 1)}->max() ;
    f := f->union(Map{Sequence{ww,num->oclAsType(long)} |-> ret}) ; 
    return ret 
 );
   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static long[] fact ;
  static long mod ;
  static long[] inv ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    mod=1000000007 ;
    fact=new long[200001];
    fact[1]=1 ;
    fact[0]=1 ;
    for(int i=2 ; i<200001 ; i++){
      fact[i]=(fact[i-1]*i)% mod ;
    }
    inv=new long[200001];
    inv[200000]=pow(fact[200000],mod-2);
    inv[0]=1 ;
    for(int i=199999 ; i>0 ; i--){
      inv[i]=(inv[i+1]*(i+1))% mod ;
    }
    long ans=0 ;
    for(int i=0 ; i<w-b ; i++){
      ans+=(comb(w+h-a-2-i,w-i-1)*comb(a-1+i,i))% mod ;
      ans %=mod ;
    }
    System.out.println(ans);
  }
  static long comb(int t,int y){
    long re=1 ;
    re*=fact[t];
    re*=inv[y];
    re %=mod ;
    re*=inv[t-y];
    return re % mod ;
  }
  static long pow(long p,long q){
    long res=1 ;
    while(q>0){
      if((q & 1)==1){
        res*=p ;
        res %=mod ;
      }
      q>>=1 ;
      p*=p ;
      p %=mod ;
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute fact : Sequence(long);
  static   attribute mod : long;
  static   attribute inv : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    mod := 1000000007 ; 
    fact := Integer.subrange(1,200001)->collect(0) ; 
    fact[1+1] := 1 ; 
    fact[0+1] := 1 ; 
        var i : int ; i := 2 ; while i < 200001 do ( (     fact[i+1] := (fact[i - 1+1] * i) mod mod )  ;     i := i + 1 ) ; 
    inv := Integer.subrange(1,200001)->collect(0) ; 
    inv[200000+1] := pow(fact[200000+1], mod - 2) ; 
    inv[0+1] := 1 ; 
        var i : int ; i := 199999 ; while i > 0 do ( (     inv[i+1] := (inv[i + 1+1] * (i + 1)) mod mod )  ;     i := i - 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < w - b do ( (     ans := ans+((comb(w + h - a - 2 - i, w - i - 1) * comb(a - 1 + i, i)) mod mod) ; 
     ans := ans mod mod )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation comb( t : int, y : int) : long
  pre: true
  post: true
  activity: (     var re : long ; re := 1 ;
     re := re*(fact[t+1]) ; 
    re := re*(inv[y+1]) ; 
    re := re mod mod ; 
    re := re*(inv[t - y+1]) ; 
    return re mod mod 
 );
  static   operation pow( p : long, q : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     while (q > 0) do (     if ((q & 1) = 1) then (     res := res*(p) ; 
     res := res mod mod ) else skip ; 
     q := q/(2->pow(1)) ; 
     p := p*(p) ; 
     p := p mod mod ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  private static final long MOD=1_000_000_007L ;
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int h=scanner.nextInt(),w=scanner.nextInt(),a=scanner.nextInt(),b=scanner.nextInt();
      long[] frac=new long[h+w-1];
      frac[0]=1 ;
      IntStream.range(1,frac.length).forEach(i->frac[i]=frac[i-1]*i % MOD);
      long[] reverseFrac=new long[h+w-1];
      reverseFrac[h+w-2]=powMod(frac[h+w-2],MOD-2);
      for(int i=reverseFrac.length-2 ; i>=0 ; i--){
        reverseFrac[i]=reverseFrac[i+1]*(i+1)% MOD ;
      }
      long answer=0L ;
      for(int i=b ; i<w ; i++){
        answer+=frac[h-a-1+i]*reverseFrac[h-a-1] % MOD*reverseFrac[i] % MOD*frac[a+w-2-i] % MOD*reverseFrac[a-1] % MOD*reverseFrac[w-1-i] % MOD ;
        answer %=MOD ;
      }
      System.out.println(answer);
    }
  }
  private static long powMod(long n,long m){
    long result=1L ;
    while(m>0){
      if(1==(m & 1)){
        result=result*n % MOD ;
      }
      n=n*n % MOD ;
      m>>=1 ;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 1_000_000_007L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var h : int ; h := scanner.getCurrent()->toInteger() ;
    var w : int ; w := scanner.getCurrent()->toInteger() ;
    var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
     var frac : Sequence(long) ; frac := Integer.subrange(1,h + w - 1)->collect(0) ;
    frac[0+1] := 1 ; 
    for i : Integer.subrange(1, frac->size()-1) do
    (    frac[i+1] := frac[i - 1+1] * i mod MOD) ; 
    var reverseFrac : Sequence(long) ; reverseFrac := Integer.subrange(1,h + w - 1)->collect(0) ;
    reverseFrac[h + w - 2+1] := powMod(frac[h + w - 2+1], MOD - 2) ; 
        var i : int ; i := reverseFrac->size() - 2 ; while i >= 0 do ( (     reverseFrac[i+1] := reverseFrac[i + 1+1] * (i + 1) mod MOD )  ;     i := i - 1 ) ; 
    var answer : long ; answer := 0L ;
        var i : int ; i := b ; while i < w do ( (     answer := answer+(frac[h - a - 1 + i+1] * reverseFrac[h - a - 1+1] mod MOD * reverseFrac[i+1] mod MOD * frac[a + w - 2 - i+1] mod MOD * reverseFrac[a - 1+1] mod MOD * reverseFrac[w - 1 - i+1] mod MOD) ; 
     answer := answer mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 ))  );
  static   operation powMod( n : long, m : long) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 1L ;
     while (m > 0) do (     if (1 = (m & 1)) then (     result := result * n mod MOD ) else skip ; 
     n := n * n mod MOD ; 
     m := m/(2->pow(1)) ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int numberofterm(int n,int number){
    int firstnum=(int)Math.pow(10,n-1);
    int lastnum=(int)Math.pow(10,n);
    int count=0 ;
    for(int i=firstnum ; i<lastnum ; i++)if(i % number==0)count++;
    return count ;
  }
  public static void main(String[] args){
    int n=3,num=7 ;
    System.out.println(numberofterm(n,num));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation numberofterm( n : int, number : int) : int
  pre: true
  post: true
  activity: (     var firstnum : int ; firstnum := 10->pow(n - 1)->oclAsType(int) ;
     var lastnum : int ; lastnum := 10->pow(n)->oclAsType(int) ;
    var count : int ; count := 0 ;
        var i : int ; i := firstnum ; while i < lastnum do (     if (i mod number = 0) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
    var num : int ; num := 7 ;
     OclFile["System.out"].println(numberofterm(n, num)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int totalSumDivisibleByNum(int n,int number){
    int firstnum=(int)Math.pow(10,n-1);
    int lastnum=(int)Math.pow(10,n);
    int sum=0 ;
    for(int i=firstnum ; i<lastnum ; i++)if(i % number==0)sum+=i ;
    return sum ;
  }
  public static void main(String[] args){
    int n=3,num=7 ;
    System.out.println(totalSumDivisibleByNum(n,num));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation totalSumDivisibleByNum( n : int, number : int) : int
  pre: true
  post: true
  activity: (     var firstnum : int ; firstnum := 10->pow(n - 1)->oclAsType(int) ;
     var lastnum : int ; lastnum := 10->pow(n)->oclAsType(int) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := firstnum ; while i < lastnum do (     if (i mod number = 0) then     sum := sum+(i) ; else skip ;  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
    var num : int ; num := 7 ;
     OclFile["System.out"].println(totalSumDivisibleByNum(n, num)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class calc {
  public static void main(String[] ar){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int a[]=new int[9];
    int c=0 ;
    int k=1 ;
    while(n!=0){
      int r=n % 10 ;
      if(r>c)c=r ;
      for(int i=0 ; i<r ; i++)a[i]=a[i]+k ;
      n=n/10 ;
      k=k*10 ;
    }
    System.out.println(c);
    for(int i=0 ; i<c ; i++)System.out.print(a[i]+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class calc {
  static   operation main( ar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,9)->collect(0) ;
    var c : int ; c := 0 ;
    var k : int ; k := 1 ;
    while (n /= 0) do (     var r : int ; r := n mod 10 ;
     if (r > c) then     c := r ; else skip ; 
        var i : int ; i := 0 ; while i < r do (     a[i+1] := a[i+1] + k ;  ;     i := i + 1 ) ; 
    n := n / 10 ; 
    k := k * 10 ; 
 ) ; 
    OclFile["System.out"].println(c) ; 
        var i : int ; i := 0 ; while i < c do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float findRadiusOfcircumcircle(float n,float a){
    if(n<0 || a<0)return-1 ;
    float radius=(float)(a/Math.sqrt(2-(2*Math.cos(360/n))));
    return radius ;
  }
  public static void main(String[] args){
    float n=5,a=6 ;
    System.out.println(findRadiusOfcircumcircle(n,a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findRadiusOfcircumcircle( n : double, a : double) : double
  pre: true
  post: true
  activity: (     if (n < 0 or a < 0) then     return -1 else skip ; 
     var radius : double ; radius := (a / (2 - (2 * (360 / n)->cos()))->sqrt())->oclAsType(double) ;
     return radius );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 5 ;
    var a : double ; a := 6 ;
     OclFile["System.out"].println(findRadiusOfcircumcircle(n, a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    ArrayList<Stack<String>>stack=new ArrayList<Stack<String>>(n);
    for(int i=0 ; i<n ; ++i){
      stack.add(new Stack<String>());
    }
    while(true){
      String str=stdIn.next();
      if(str.equals("quit")){
        break ;
      }
      if(str.equals("push")){
        int a=stdIn.nextInt();
        String c=stdIn.next();
        stack.get(a-1).add(c);
      }
      else if(str.equals("move")){
        int a=stdIn.nextInt();
        int b=stdIn.nextInt();
        stack.get(b-1).add(stack.get(a-1).pop());
      }
      else if(str.equals("pop")){
        int a=stdIn.nextInt();
        System.out.println(stack.get(a-1).pop());
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var stack : Sequence(Sequence(String)) ; stack := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     stack := stack->including(Sequence{}) )  ;     i := i + 1 ) ; 
    while (true) do (     var str : String ; str := stdIn.getCurrent() ;
     if (str = "quit") then (     break ) else skip ; 
     if (str = "push") then (     var a : int ; a := stdIn.getCurrent()->toInteger() ;
     var c : String ; c := stdIn.getCurrent() ;
     stack->at((a)->char2byte() - 1+1)->excludes(c) ) else     if (str = "move") then (     var a : int ; a := stdIn.getCurrent()->toInteger() ;
     var b : int ; b := stdIn.getCurrent()->toInteger() ;
     stack->at(b - 1+1)->excludes(stack->at((a)->char2byte() - 1+1)->last()) ) else     if (str = "pop") then (     var a : int ; a := stdIn.getCurrent()->toInteger() ;
     OclFile["System.out"].println(stack->at((a)->char2byte() - 1+1)->last()) ) else skip ; ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void countFreq(int a[],int n){
    int hm[]=new int[n];
    for(int i=0 ; i<n ; i++)hm[a[i] ]++;
    int cumul=0 ;
    for(int i=0 ; i<n ; i++){
      cumul+=hm[a[i] ];
      if(hm[a[i] ]!=0){
        System.out.println(a[i]+"->"+cumul);
      }
      hm[a[i] ]=0 ;
    }
  }
  public static void main(String[] args){
    int a[]={
      1,3,2,4,2,1 };
      int n=a.length ;
      countFreq(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countFreq( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var hm : Sequence(int) ; hm := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     hm[a[i+1]+1] := hm[a[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
     var cumul : int ; cumul := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     cumul := cumul+(hm[a[i+1]+1]) ; 
     if (hm[a[i+1]+1] /= 0) then (     OclFile["System.out"].println(a[i+1] + "->" + cumul) ) else skip ; 
     hm[a[i+1]+1] := 0 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,3,2,4,2,1} ;
     var n : int ; n := a->size() ;
     execute countFreq(a, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
public class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String order=br.readLine();
      order=br.readLine();
      char[][] dq=new char[101][1000];
      int[] numDq=new int[101];
      ArrayList<Character>al=new ArrayList<Character>();
      while(! order.equals("quit")){
        String[] splited=order.split(" ");
        if(splited[0] .equals("push")){
          int dqN=Integer.parseInt(splited[1]);
          dq[dqN][numDq[dqN] ]=splited[2] .charAt(0);
          numDq[dqN]++;
        }
        else if(splited[0] .equals("pop")){
          int dqN=Integer.parseInt(splited[1]);
          char pulled=dq[dqN][numDq[dqN]-1];
          numDq[dqN]--;
          al.add(pulled);
        }
        else {
          int dqN=Integer.parseInt(splited[1]);
          char pulled=dq[dqN][numDq[dqN]-1];
          numDq[dqN]--;
          int dqN2=Integer.parseInt(splited[2]);
          dq[dqN2][numDq[dqN2] ]=pulled ;
          numDq[dqN2]++;
        }
        order=br.readLine();
      }
      for(char ch : al)System.out.println(ch);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var order : String ; order := br.readLine() ;
     order := br.readLine() ; 
    var dq : Sequence(Sequence(String)) ; dq := Integer.subrange(1,101)->collect(Integer.subrange(1,1000)->collect(0)) ;
    var numDq : Sequence(int) ; numDq := Integer.subrange(1,101)->collect(0) ;
    var al : Sequence(String) ; al := Sequence{} ;
    while (not(order = "quit")) do (     var splited : Sequence(String) ; splited := order->split(" ") ;
     if (splited[0+1] = "push") then (     var dqN : int ; dqN := (splited[1+1])->toInteger() ;
     dq[dqN+1][numDq[dqN+1]+1] := splited[2+1]->at(0+1) ; 
     numDq[dqN+1] := numDq[dqN+1] + 1 ) else     if (splited[0+1] = "pop") then (     var dqN : int ; dqN := (splited[1+1])->toInteger() ;
     var pulled : String ; pulled := dq[dqN+1][numDq[dqN+1] - 1+1] ;
     numDq[dqN+1] := numDq[dqN+1] - 1 ; 
     al := al->including(pulled) ) else (     var dqN : int ; dqN := (splited[1+1])->toInteger() ;
     var pulled : String ; pulled := dq[dqN+1][numDq[dqN+1] - 1+1] ;
    numDq[dqN+1] := numDq[dqN+1] - 1 ; 
    var dqN2 : int ; dqN2 := (splited[2+1])->toInteger() ;
    dq[dqN2+1][numDq[dqN2+1]+1] := pulled ; 
    numDq[dqN2+1] := numDq[dqN2+1] + 1 ; 
 ) ;  ;  
     order := br.readLine() ) ; 
    for (ch : al) do (     OclFile["System.out"].println(ch) ;  ) ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static String a[][]=new String[101][1001];
  static int p[]=new int[101];
  public static void push(int n,String s){
    a[n][p[n] ]=s ;
    p[n]++;
  }
  public static String pop(int n){
    p[n]--;
    return a[n][p[n] ];
  }
  public static void move(int n,int m){
    push(m,pop(n));
  }
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    Arrays.fill(p,0);
    int XX=stdIn.nextInt();
    while(true){
      String s=stdIn.next();
      if(s.equals("quit"))break ;
      else if(s.equals("push")){
        int n=stdIn.nextInt();
        String t=stdIn.next();
        push(n,t);
      }
      else if(s.equals("move")){
        int n=stdIn.nextInt();
        int m=stdIn.nextInt();
        move(n,m);
      }
      else {
        int n=stdIn.nextInt();
        System.out.println(pop(n));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a : String := Integer.subrange(1,101)->collect(Integer.subrange(1,1001)->collect(null));
  static   attribute p : int := Integer.subrange(1,101)->collect(0);
  static   operation push( n : int, s : String) : void
  pre: true
  post: true
  activity: (     a[n+1][p[n+1]+1] := s ; 
     p[n+1] := p[n+1] + 1 );
  static   operation pop( n : int) : String
  pre: true
  post: true
  activity: (     p[n+1] := p[n+1] - 1 ; 
     return a[n+1][p[n+1]+1] );
  static   operation move( n : int, m : int) : void
  pre: true
  post: true
  activity: (     execute push(m, pop(n)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     p := p->collect(0) ; 
     var XX : int ; XX := stdIn.getCurrent()->toInteger() ;
     while (true) do (     var s : String ; s := stdIn.getCurrent() ;
     if (s = "quit") then     break else     if (s = "push") then (     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     var t : String ; t := stdIn.getCurrent() ;
     execute push(n, t) ) else     if (s = "move") then (     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     var m : int ; m := stdIn.getCurrent()->toInteger() ;
     execute move(n, m) ) else (     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     OclFile["System.out"].println(pop(n)) ) ;  ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayDeque ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=br.readLine();
    int n=Integer.parseInt(str);
    int p ;
    ArrayDeque<String>blockStack=new ArrayDeque<String>();
    ArrayList<ArrayDeque<String>>stacksStack=new ArrayList<ArrayDeque<String>>();
    ArrayList<String>popList=new ArrayList<String>();
    for(int i=0 ; i<n ; i++){
      stacksStack.add(new ArrayDeque<String>());
    }
    while(!(str=br.readLine()).equals("quit")){
      String strArray[]=str.split(" ");
      if(strArray[0] .equals("push")){
        p=Integer.parseInt(strArray[1])-1 ;
        stacksStack.get(p).push(strArray[2]);
      }
      else if(strArray[0] .equals("pop")){
        p=Integer.parseInt(strArray[1])-1 ;
        popList.add(stacksStack.get(p).pop());
      }
      else if(strArray[0] .equals("move")){
        int p1=Integer.parseInt(strArray[1])-1 ;
        int p2=Integer.parseInt(strArray[2])-1 ;
        stacksStack.get(p2).push(stacksStack.get(p1).pop());
      }
      else {
      }
    }
    for(int i=0 ; i<popList.size(); i++){
      System.out.println(popList.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := br.readLine() ;
    var n : int ; n := (str)->toInteger() ;
    var p : int ;
    var blockStack : Sequence(String) ; blockStack := ArrayDeque<String>.newArrayDeque() ;
    var stacksStack : Sequence(Sequence(String)) ; stacksStack := Sequence{} ;
    var popList : Sequence(String) ; popList := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     stacksStack := stacksStack->including(ArrayDeque<String>.newArrayDeque()) )  ;     i := i + 1 ) ; 
    while (not((str) = "quit")) do (     var strArray : Sequence(String) ; strArray := str->split(" ") ;
     if (strArray[0+1] = "push") then (     p := (strArray[1+1])->toInteger() - 1 ; 
     stacksStack := stacksStack->at(p+1)->append(strArray[2+1]) ) else     if (strArray[0+1] = "pop") then (     p := (strArray[1+1])->toInteger() - 1 ; 
     popList := popList->including(stacksStack->at(p+1)->last()) ) else     if (strArray[0+1] = "move") then (     var p1 : int ; p1 := (strArray[1+1])->toInteger() - 1 ;
     var p2 : int ; p2 := (strArray[2+1])->toInteger() - 1 ;
     stacksStack := stacksStack->at(p2+1)->append(stacksStack->at(p1+1)->last()) ) else skip ;  ;  ) ; 
        var i : int ; i := 0 ; while i < popList->size() do ( (     OclFile["System.out"].println(popList->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
@ SuppressWarnings("unchecked")public class Main {
  public static String joinInt(int[] a,String separator){
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<a.length ; i++){
      if(i>0){
        sb.append(separator);
      }
      sb.append(a[i]);
    }
    return sb.toString();
  }
  static int[] nextIntArray(Scanner sc,int N){
    int[] arr=new int[N];
    for(int i=0 ; i<N ; i++){
      arr[i]=sc.nextInt();
    }
    return arr ;
  }
  public static void main(String[] args){
    final int COMPRESS=400 ;
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int W=sc.nextInt();
    int[] ws=new int[N];
    int[] vs=new int[N];
    for(int i=0 ; i<N ; i++){
      ws[i]=sc.nextInt();
      vs[i]=sc.nextInt();
    }
    int[] value=new int[(COMPRESS+4)*N];
    int compress=0 ;
    if(ws[0]>COMPRESS){
      compress=ws[0]-COMPRESS ;
    }
    for(int i=0 ; i<N ; i++){
      int w=ws[i]-compress ;
      int v=vs[i];
      for(int j=value.length-1 ; j>=w ; j--){
        value[j]=Math.max(value[j],value[j-w]+v);
      }
    }
    if(compress==0){
      System.out.println(value[W]);
    }
    else {
      int a=W/ws[0];
      int b=W % ws[0];
      int c=ws[0]-compress ;
      int W2=a*c+Math.min(b,c-1);
      System.out.println(value[W2]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation joinInt( a : Sequence(int), separator : String) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < a->size() do ( (     if (i > 0) then (     sb := sb + StringLib.newString(separator) ) else skip ; 
     sb := sb + StringLib.newString(a[i+1]) )  ;     i := i + 1 ) ; 
     return sb+"" );
  static   operation nextIntArray( sc : OclFile, N : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
         var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
     return arr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var COMPRESS : int ; COMPRESS := 400 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var ws : Sequence(int) ; ws := Integer.subrange(1,N)->collect(0) ;
    var vs : Sequence(int) ; vs := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     ws[i+1] := sc.getCurrent()->toInteger() ; 
     vs[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var value : Sequence(int) ; value := Integer.subrange(1,(COMPRESS + 4) * N)->collect(0) ;
    var compress : int ; compress := 0 ;
    if (ws[0+1] > COMPRESS) then (     compress := ws[0+1] - COMPRESS ) else skip ; 
        var i : int ; i := 0 ; while i < N do ( (     var w : int ; w := ws[i+1] - compress ;
     var v : int ; v := vs[i+1] ;
         var j : int ; j := value->size() - 1 ; while j >= w do ( (     value[j+1] := Set{value[j+1], value[j - w+1] + v}->max() )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    if (compress = 0) then (     OclFile["System.out"].println(value[W+1]) ) else (     var a : int ; a := W / ws[0+1] ;
     var b : int ; b := W mod ws[0+1] ;
    var c : int ; c := ws[0+1] - compress ;
    var W2 : int ; W2 := a * c + Set{b, c - 1}->min() ;
    OclFile["System.out"].println(value[W2+1]) ; 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int m_size=Integer.parseInt(scan.nextLine());
    String[][] mount=new String[m_size][100];
    int m_num=0 ;
    String block=null ;
    while(scan.hasNext()){
      String[] cmd=scan.nextLine().split(" ");
      if(cmd[0] .equals("quit")){
        break ;
      }
      else if(cmd[0] .equals("push")){
        m_num=Integer.parseInt(cmd[1])-1 ;
        block=cmd[2];
        mount[m_num][searchindex(mount,m_num)+1]=block ;
      }
      else if(cmd[0] .equals("pop")){
        m_num=Integer.parseInt(cmd[1])-1 ;
        String out=mount[m_num][searchindex(mount,m_num)];
        mount[m_num][searchindex(mount,m_num)]=null ;
        System.out.println(out);
      }
      else if(cmd[0] .equals("move")){
        m_num=Integer.parseInt(cmd[1])-1 ;
        String temp=mount[m_num][searchindex(mount,m_num)];
        mount[m_num][searchindex(mount,m_num)]=null ;
        m_num=Integer.parseInt(cmd[2])-1 ;
        mount[m_num][searchindex(mount,m_num)+1]=temp ;
      }
      else {
        System.out.println("Error");
        break ;
      }
    }
  }
  public static int searchindex(String[][] mount,int m_num){
    int index=0 ;
    for(int i=0 ; i<1000 ; i++){
      if(null==mount[m_num][i]){
        index=i-1 ;
        break ;
      }
    }
    return index ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m_size : int ; m_size := (scan.nextLine())->toInteger() ;
    var mount : Sequence(Sequence(String)) ; mount := Integer.subrange(1,m_size)->collect(Integer.subrange(1,100)->collect(null)) ;
    var m_num : int ; m_num := 0 ;
    var block : String ; block := null ;
    while (scan.hasNext()) do (     var cmd : Sequence(String) ; cmd := scan.nextLine()->split(" ") ;
     if (cmd[0+1] = "quit") then (     break ) else     if (cmd[0+1] = "push") then (     m_num := (cmd[1+1])->toInteger() - 1 ; 
     block := cmd[2+1] ; 
     mount[m_num+1][searchindex(mount, m_num) + 1+1] := block ) else     if (cmd[0+1] = "pop") then (     m_num := (cmd[1+1])->toInteger() - 1 ; 
     var out : String ; out := mount[m_num+1][searchindex(mount, m_num)+1] ;
     mount[m_num+1][searchindex(mount, m_num)+1] := null ; 
     OclFile["System.out"].println(out) ) else     if (cmd[0+1] = "move") then (     m_num := (cmd[1+1])->toInteger() - 1 ; 
     var temp : String ; temp := mount[m_num+1][searchindex(mount, m_num)+1] ;
    mount[m_num+1][searchindex(mount, m_num)+1] := null ; 
    m_num := (cmd[2+1])->toInteger() - 1 ; 
    mount[m_num+1][searchindex(mount, m_num) + 1+1] := temp ; 
 ) else (     OclFile["System.out"].println("Error") ; 
     break ) ;  ;  ;  ) ; 
 );
  static   operation searchindex( mount : Sequence(Sequence(String)), m_num : int) : int
  pre: true
  post: true
  activity: (     var index : int ; index := 0 ;
         var i : int ; i := 0 ; while i < 1000 do ( (     if (null = mount[m_num+1][i+1]) then (     index := i - 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     return index );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minimumIncrease(int a,int b,int c){
    int arr[]={
      a,b,c };
      Arrays.sort(arr);
      if(arr[0]+arr[1]>=arr[2])return 0 ;
      else return arr[2]-(arr[0]+arr[1]);
    }
    public static void main(String[] args){
      int a=3,b=5,c=10 ;
      System.out.println(minimumIncrease(a,b,c));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumIncrease( a : int, b : int, c : int) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{a,b,c} ;
     arr := arr->sort() ; 
     if (arr[0+1] + arr[1+1] >= arr[2+1]) then     return 0 else     return arr[2+1] - (arr[0+1] + arr[1+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var b : int ; b := 5 ;
    var c : int ; c := 10 ;
     OclFile["System.out"].println(minimumIncrease(a, b, c)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minLength(int n){
    int ans=n/26 ;
    if(n % 26!=0)ans++;
    return ans ;
  }
  static String minString(int n){
    int ans=n/26 ;
    String res="" ;
    while(ans--!=0){
      res=res+"z" ;
    }
    if(n % 26!=0){
      res=res+(char)((n % 26)+96);
    }
    return res ;
  }
  public static void main(String[] args){
    int n=50 ;
    System.out.println(minLength(n));
    System.out.println(minString(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minLength( n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := n / 26 ;
     if (n mod 26 /= 0) then     ans := ans + 1 ; else skip ; 
     return ans );
  static   operation minString( n : int) : String
  pre: true
  post: true
  activity: (     var ans : int ; ans := n / 26 ;
     var res : String ; res := "" ;
        while (ans /= 0) do (    skip ; (     res := res + "z" ) ;  ) ;  
    if (n mod 26 /= 0) then (     res := res + ((n mod 26) + 96)->oclAsType(String) ) else skip ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 50 ;
     OclFile["System.out"].println(minLength(n)) ; 
     OclFile["System.out"].println(minString(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int a ;
    int b ;
    while(true){
      a=scan.nextInt();
      b=scan.nextInt();
      if(a==0 && b==0){
        break ;
      }
      else {
      }
      if((a*b)% 2==1){
        System.out.println("no");
      }
      else {
        System.out.println("yes");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ;
     var b : int ;
     while (true) do (     a := scan.getCurrent()->toInteger() ; 
     b := scan.getCurrent()->toInteger() ; 
     if (a = 0 & b = 0) then (     break ) else skip ;  
     if ((a * b) mod 2 = 1) then (     OclFile["System.out"].println("no") ) else (     OclFile["System.out"].println("yes") ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    int kuti=1 ;
    int tap=0 ;
    while(kuti<b){
      kuti=kuti-1+a ;
      tap++;
    }
    System.out.println(tap);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := (sc.getCurrent())->toInteger() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    var kuti : int ; kuti := 1 ;
    var tap : int ; tap := 0 ;
    while (kuti < b) do (     kuti := kuti - 1 + a ; 
     tap := tap + 1 ) ; 
    OclFile["System.out"].println(tap) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    while(true){
      int x=in.nextInt();
      int y=in.nextInt();
      if(x+y==0)break ;
      new AOJ1072().doIt(x,y);
    }
  }
  class AOJ1072 {
    void doIt(int x,int y){
      if((x*y)% 2==0)System.out.println("yes");
      else System.out.println("no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     while (true) do (     var x : int ; x := in.getCurrent()->toInteger() ;
     var y : int ; y := in.getCurrent()->toInteger() ;
     if (x + y = 0) then     break else skip ; 
     AOJ1072.newAOJ1072().doIt(x, y) ) );
 class AOJ1072 {
   operation doIt( x : int, y : int) : void
  pre: true
  post: true
  activity: (     if ((x * y) mod 2 = 0) then     OclFile["System.out"].println("yes") ; else     OclFile["System.out"].println("no") ; );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
    try {
      while(true){
        String[] st=sc.readLine().split(" ");
        int r=Integer.valueOf(st[0]),c=Integer.valueOf(st[1]);
        if((r | c)==0)break ;
        if(r*c % 2==0)System.out.println("yes");
        else System.out.println("no");
      }
    }
    catch(Exception e){
      System.out.println("Error");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     while (true) do (     var st : Sequence(String) ; st := sc.readLine()->split(" ") ;
     var r : int ; r := (st[0+1])->toInteger() ;
    var c : int ; c := (st[1+1])->toInteger() ;
     if ((MathLib.bitwiseOr(r,c)) = 0) then     break else skip ; 
     if (r * c mod 2 = 0) then     OclFile["System.out"].println("yes") ; else     OclFile["System.out"].println("no") ; ) )   catch (e : ProgramException) do (     OclFile["System.out"].println("Error") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  private static void solve(){
    final Scanner scanner=new Scanner(System.in);
    while(true){
      final int r=scanner.nextInt();
      final int c=scanner.nextInt();
      if(r==0 && c==0){
        break ;
      }
      System.out.println((r*c)% 2==0 ? "yes" : "no");
    }
  }
  public static void main(String...args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var r : int ; r := scanner.getCurrent()->toInteger() ;
     var c : int ; c := scanner.getCurrent()->toInteger() ;
     if (r = 0 & c = 0) then (     break ) else skip ; 
     OclFile["System.out"].println(if (r * c) mod 2 = 0 then "yes" else "no" endif) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
import java.awt.geom.*;
import java.io.*;
public class Main {
  static int INF=2<<27 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int r=sc.nextInt();
      int c=sc.nextInt();
      if(r==0 && c==0)break ;
      System.out.println((r*c)% 2==0 ? "yes" : "no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute INF : int := (2*(2->pow(27)))->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var r : int ; r := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
     if (r = 0 & c = 0) then     break else skip ; 
     OclFile["System.out"].println(if (r * c) mod 2 = 0 then "yes" else "no" endif) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int cnt=0 ;
    String w,t ;
    w=scanner.next();
    while(true){
      t=scanner.next();
      if(t.equals("END_OF_TEXT"))break ;
      if(t.toLowerCase().equals(w))++cnt ;
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cnt : int ; cnt := 0 ;
    var w : String ;
    var t : String ;
    w := scanner.getCurrent() ; 
    while (true) do (     t := scanner.getCurrent() ; 
     if (t = "END_OF_TEXT") then     break else skip ; 
     if (t->toLowerCase() = w) then     cnt := cnt + 1 ; else skip ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void find_volume(double area,double h){
    double Volume=(area*h);
    System.out.println("Volume: "+Volume);
  }
  static void find_Surface_area(double area,double a,double h){
    double Surface_area=(2*area)+(8*a*h);
    System.out.println("Surface area: "+Surface_area);
  }
  public static void main(String[] args){
    double h=1 ;
    double a=6 ;
    double d=2 ;
    double area=2*a*d ;
    find_Surface_area(area,a,h);
    find_volume(area,h);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find_volume( area : double, h : double) : void
  pre: true
  post: true
  activity: (     var Volume : double ; Volume := (area * h) ;
     OclFile["System.out"].println("Volume: " + Volume) );
  static   operation find_Surface_area( area : double, a : double, h : double) : void
  pre: true
  post: true
  activity: (     var Surface_area : double ; Surface_area := (2 * area) + (8 * a * h) ;
     OclFile["System.out"].println("Surface area: " + Surface_area) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var h : double ; h := 1 ;
     var a : double ; a := 6 ;
    var d : double ; d := 2 ;
    var area : double ; area := 2 * a * d ;
    execute find_Surface_area(area, a, h) ; 
    execute find_volume(area, h) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    int val=k/5 ;
    if(k % 5>0){
      val++;
    }
    System.out.println(val);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var val : int ; val := k / 5 ;
    if (k mod 5 > 0) then (     val := val + 1 ) else skip ; 
    OclFile["System.out"].println(val) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int dis=sc.nextInt();
    int step=0 ;
    for(int i=1 ; i<=dis ; i+=5){
      step++;
    }
    System.out.println(step);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dis : int ; dis := sc.getCurrent()->toInteger() ;
    var step : int ; step := 0 ;
        var i : int ; i := 1 ; while i <= dis do ( (     step := step + 1 )  ;     i := i+(5) ) ; 
    OclFile["System.out"].println(step) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int count=0 ;
    while(x>5){
      x-=5 ;
      count++;
    }
    System.out.println(x==0 ? count : count+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    while (x > 5) do (     x := x-(5) ; 
     count := count + 1 ) ; 
    OclFile["System.out"].println(if x = 0 then count else count + 1 endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class elephant {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        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().trim();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  static class FastWriter {
    private final BufferedWriter bw ;
    public FastWriter(){
      this.bw=new BufferedWriter(new OutputStreamWriter(System.out));
    }
    public void print(Object object)throws IOException {
      bw.append(""+object);
    }
    public void println(Object object)throws IOException {
      print(object);
      bw.append("\n");
    }
    public void close()throws IOException {
      bw.close();
    }
  }
  public static void main(String[] args){
    try {
      FastReader in=new FastReader();
      FastWriter out=new FastWriter();
      int distance=in.nextInt();
      int elephantSteps=5 ;
      int ans=0 ;
      int count=0 ;
      while(true){
        if(ans>=distance){
          break ;
        }
        ans+=elephantSteps ;
        count++;
      }
      System.out.println(count);
      out.close();
    }
    catch(Exception e){
      System.out.println(e);
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class elephant {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine()->trim() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return str );
}
  static class FastWriter {
   attribute bw : OclFile;
   static operation newFastWriter() : FastWriter
  pre: true
  post: true
  activity:
  ( var self : FastWriter ;
    self := createFastWriter();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) );
   operation print( object : OclAny) : void
  pre: true
  post: true
  activity: (     skip );
   operation println( object : OclAny) : void
  pre: true
  post: true
  activity: (     execute print(object) ; 
     skip );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : FastWriter ; out := FastWriter.newFastWriter() ;
    var distance : int ; distance := in.nextInt() ;
    var elephantSteps : int ; elephantSteps := 5 ;
    var ans : int ; ans := 0 ;
    var count : int ; count := 0 ;
    while (true) do (     if (ans >= distance) then (     break ) else skip ; 
     ans := ans+(elephantSteps) ; 
     count := count + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    out.close() ; 
 )   catch (e : ProgramException) do (     OclFile["System.out"].println(e) ; 
     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static class InputReader {
    BufferedReader reader ;
    StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
  }
  static InputReader r=new InputReader(System.in);
  static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args){
    int a=r.nextInt();
    int b=r.nextInt();
    pw.println((int)Math.ceil((1.0*b-1)/(a-1)));
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
  static   attribute r : InputReader := InputReader.newInputReader(OclFile["System.in"]);
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := r.nextInt() ;
     var b : int ; b := r.nextInt() ;
     skip ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Elephant {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int pos=sc.nextInt();
      System.out.println((pos+4)/5);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Elephant {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var pos : int ; pos := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println((pos + 4) / 5) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    String[] kang={
      "a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","ld","mb","mp","nc","nd","ng","nt","nw","ps","qu","cw","ts" };
      Scanner sc=new Scanner(System.in);
      int N=sc.nextInt();
      sc.nextLine();
      int[][] c=new int[38][38];
      while(N--!=0){
        for(String s : sc.nextLine().split(" ")){
          int p=-1 ;
          while(! "".equals(s)){
            for(int k=37 ; k>=0 ; k--){
              if(s.startsWith(kang[k])){
                if(p!=-1)c[p][k]++;
                p=k ;
                s=s.substring(kang[k] .length(),s.length());
                break ;
              }
            }
          }
        }
      }
      for(int i=0 ; i<38 ; i++){
        int k=0 ;
        for(int j=1 ; j<38 ; j++){
          if(c[i][k]<c[i][j])k=j ;
        }
        System.out.println(kang[i]+" "+kang[k]+" "+c[i][k]);
      }
    }
    public static void main(String[] args){
      new Main().run();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var kang : Sequence(String) ; kang := Sequence{"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","ld","mb","mp","nc","nd","ng","nt","nw","ps","qu","cw","ts"} ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    skip ; 
    var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,38)->collect(Integer.subrange(1,38)->collect(0)) ;
        while (N /= 0) do (    skip ; (     for (s : sc.nextLine()->split(" ")) do ( (     var p : int ; p := -1 ;
     while (not("" = s)) do (         var k : int ; k := 37 ; while k >= 0 do ( (     if (s->hasPrefix(kang[k+1])) then (     if (p /= -1) then     c[p+1][k+1] := c[p+1][k+1] + 1 ; else skip ; 
     p := k ; 
     s := s.subrange(kang[k+1]->size()+1,s->size()) ; 
     break ) else skip )  ;     k := k - 1 ) ) )  ) ) ;  ) ;  
        var i : int ; i := 0 ; while i < 38 do ( (     var k : int ; k := 0 ;
         var j : int ; j := 1 ; while j < 38 do ( (     if (c[i+1][k+1] < c[i+1][j+1]) then     k := j ; else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(kang[i+1] + " " + kang[k+1] + " " + c[i+1][k+1]) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    String[] kang={
      "a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","ld","mb","mp","nc","nd","ng","nt","nw","ps","qu","cw","ts","B" };
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int[][] ans=new int[kang.length][kang.length];
      while(sc.hasNext()){
        String str=(sc.next()+"A");
        String temp ;
        int front=kang.length-1 ;
        for(int i=0 ; i<str.length()-1 ; i++){
          for(int j=kang.length-2 ; j>=0 ; j--){
            temp=str.substring(i,i+kang[j] .length());
            if(kang[j] .equals(temp)){
              ans[front][j]++;
              front=j ;
              i+=kang[j] .length()-1 ;
              break ;
            }
          }
        }
      }
      for(int i=0 ; i<kang.length-1 ; i++){
        int max=0 ;
        for(int j=0 ; j<kang.length-1 ; j++){
          max=ans[i][max]>=ans[i][j] ? max : j ;
        }
        System.out.println(kang[i]+" "+kang[max]+" "+ans[i][max]);
      }
    }
    public static void main(String[] args){
      new Main().run();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var kang : Sequence(String) ; kang := Sequence{"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","ld","mb","mp","nc","nd","ng","nt","nw","ps","qu","cw","ts","B"} ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : Sequence(Sequence(int)) ; ans := Integer.subrange(1,kang->size())->collect(Integer.subrange(1,kang->size())->collect(0)) ;
    while (sc.hasNext()) do (     var str : String ; str := (sc.getCurrent() + "A") ;
     var temp : String ;
     var front : int ; front := kang->size() - 1 ;
         var i : int ; i := 0 ; while i < str->size() - 1 do ( (         var j : int ; j := kang->size() - 2 ; while j >= 0 do ( (     temp := str.subrange(i+1,i + kang[j+1]->size()) ; 
     if (kang[j+1] = temp) then (     ans[front+1][j+1] := ans[front+1][j+1] + 1 ; 
     front := j ; 
     i := i+(kang[j+1]->size() - 1) ; 
     break ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ) ; 
        var i : int ; i := 0 ; while i < kang->size() - 1 do ( (     var max : int ; max := 0 ;
         var j : int ; j := 0 ; while j < kang->size() - 1 do ( (     max := if ans[i+1][max+1] >= ans[i+1][j+1] then max else j endif )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(kang[i+1] + " " + kang[max+1] + " " + ans[i+1][max+1]) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int matrix[][]=new int[100][100];
  static void printRequiredMatrix(int n){
    if(n==1){
      System.out.println("1");
    }
    else if(n % 2!=0){
      System.out.println("-1");
    }
    else {
      for(int i=0 ; i<n ; i++){
        matrix[i][i]=n ;
      }
      int u=n-1 ;
      for(int i=0 ; i<n-1 ; i++){
        matrix[i][u]=i+1 ;
        for(int j=1 ; j<n/2 ; j++){
          int a=(i+j)%(n-1);
          int b=(i-j+n-1)%(n-1);
          if(a<b){
            int temp=a ;
            a=b ;
            b=temp ;
          }
          matrix[b][a]=i+1 ;
        }
      }
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<i ; j++)matrix[i][j]=matrix[j][i]+n ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++)System.out.print(matrix[i][j]+" ");
        System.out.println();
      }
    }
    System.out.println();
  }
  public static void main(String[] args){
    int n=1 ;
    printRequiredMatrix(n);
    n=3 ;
    printRequiredMatrix(n);
    n=6 ;
    printRequiredMatrix(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute matrix : int := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(0));
  static   operation printRequiredMatrix( n : int) : void
  pre: true
  post: true
  activity: (     if (n = 1) then (     OclFile["System.out"].println("1") ) else     if (n mod 2 /= 0) then (     OclFile["System.out"].println("-1") ) else (         var i : int ; i := 0 ; while i < n do ( (     matrix[i+1][i+1] := n )  ;     i := i + 1 ) ; 
     var u : int ; u := n - 1 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     matrix[i+1][u+1] := i + 1 ; 
         var j : int ; j := 1 ; while j < n / 2 do ( (     var a : int ; a := (i + j) mod (n - 1) ;
     var b : int ; b := (i - j + n - 1) mod (n - 1) ;
     if (a < b) then (     var temp : int ; temp := a ;
     a := b ; 
     b := temp ) else skip ; 
     matrix[b+1][a+1] := i + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < i do (     matrix[i+1][j+1] := matrix[j+1][i+1] + n ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do (     OclFile["System.out"].print(matrix[i+1][j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 ) ;  ;  
     OclFile["System.out"].println() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1 ;
     execute printRequiredMatrix(n) ; 
    n := 3 ; 
    execute printRequiredMatrix(n) ; 
    n := 6 ; 
    execute printRequiredMatrix(n) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxLen=30 ;
  static int[] seg=new int[3*maxLen];
  static int build(int l,int r,int in,int[] arr){
    if(l==r)return seg[in]=arr[l];
    int mid=(l+r)/2 ;
    return seg[in]=__gcd(build(l,mid,2*in+1,arr),build(mid+1,r,2*in+2,arr));
  }
  static int query(int l,int r,int l1,int r1,int in){
    if(l1<=l && r<=r1)return seg[in];
    if(l>r1 || r<l1)return 0 ;
    int mid=(l+r)/2 ;
    return __gcd(query(l,mid,l1,r1,2*in+1),query(mid+1,r,l1,r1,2*in+2));
  }
  static int findLen(int[] arr,int n){
    build(0,n-1,0,arr);
    int i=0,j=0 ;
    int ans=Integer.MAX_VALUE ;
    while(i<n){
      while(j<n && query(0,n-1,i,j,0)!=1)j++;
      if(j==n)break ;
      ans=Math.min((j-i+1),ans);
      i++;
      j=Math.max(j,i);
    }
    if(ans==Integer.MAX_VALUE)return-1 ;
    else return ans ;
  }
  static int __gcd(int a,int b){
    return b==0 ? a : __gcd(b,a % b);
  }
  public static void main(String[] args){
    int arr[]={
      2,2,2 };
      int n=arr.length ;
      System.out.println(findLen(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute maxLen : int := 30;
  static   attribute seg : Sequence(int) := Integer.subrange(1,3 * maxLen)->collect(0);
  static   operation build( l : int, r : int, in : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (l = r) then     return seg[in+1] else skip ; 
     var mid : int ; mid := (l + r) / 2 ;
     return seg[in+1] );
  static   operation query( l : int, r : int, l1 : int, r1 : int, in : int) : int
  pre: true
  post: true
  activity: (     if (l1 <= l & r <= r1) then     return seg[in+1] else skip ; 
     if (l > r1 or r < l1) then     return 0 else skip ; 
     var mid : int ; mid := (l + r) / 2 ;
     return __gcd(query(l, mid, l1, r1, 2 * in + 1), query(mid + 1, r, l1, r1, 2 * in + 2)) );
  static   operation findLen( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     execute build(0, n - 1, 0, arr) ; 
     var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    var ans : int ; ans := 2147483647 ;
    while (i < n) do (     while (j < n & query(0, n - 1, i, j, 0) /= 1) do     j := j + 1 ; ; 
     if (j = n) then     break else skip ; 
    ans := Set{(j - i + 1), ans}->min() ; 
    i := i + 1 ; 
    j := Set{j, i}->max() ; 
 ) ; 
    if (ans = 2147483647) then     return -1 else     return ans ;  
 );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else __gcd(b, a mod b) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,2,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findLen(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String W=br.readLine().toLowerCase();
    String END="END_OF_TEXT" ;
    int cnt=0 ;
    for(; ; ){
      String line=br.readLine();
      if(line.equals(END)){
        break ;
      }
      String[] words=line.split(" ");
      for(int i=0 ; i<words.length ; i++){
        if(words[i] .toLowerCase().equals(W)){
          cnt++;
        }
      }
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var W : String ; W := br.readLine()->toLowerCase() ;
    var END : String ; END := "END_OF_TEXT" ;
    var cnt : int ; cnt := 0 ;
      while true do ( (     var line : String ; line := br.readLine() ;
     if (line = END) then (     break ) else skip ; 
     var words : Sequence(String) ; words := line->split(" ") ;
         var i : int ; i := 0 ; while i < words->size() do ( (     if (words[i+1]->toLowerCase() = W) then (     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) )  ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(true){
      int n=in.nextInt();
      int a=in.nextInt();
      int b=in.nextInt();
      int c=in.nextInt();
      int x=in.nextInt();
      if(n==0)break ;
      int count=0 ;
      boolean cont=true ;
      for(int i=0 ; i<n ; i++){
        int y=in.nextInt();
        while(cont && y!=x){
          x=next(x,a,b,c);
          count++;
          if(count>10000){
            cont=false ;
          }
        }
        x=next(x,a,b,c);
        if(i<n-1)count++;
      }
      System.out.println(count>10000 ?-1 : count);
    }
  }
  public static int next(int x,int a,int b,int c){
    return(x*a+b)% c ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
    if (n = 0) then     break else skip ; 
    var count : int ; count := 0 ;
    var cont : boolean ; cont := true ;
        var i : int ; i := 0 ; while i < n do ( (     var y : int ; y := in.getCurrent()->toInteger() ;
     while (cont & y /= x) do (     x := next(x, a, b, c) ; 
     count := count + 1 ; 
     if (count > 10000) then (     cont := false ) else skip ) ; 
     x := next(x, a, b, c) ; 
     if (i < n - 1) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if count > 10000 then -1 else count endif) ; 
 ) );
  static   operation next( x : int, a : int, b : int, c : int) : int
  pre: true
  post: true
  activity: (     return (x * a + b) mod c );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  static int f=10001 ;
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,a,b,c,x,y,t,i ;
    for(; ; ){
      n=sc.nextInt();
      a=sc.nextInt();
      b=sc.nextInt();
      c=sc.nextInt();
      x=sc.nextInt();
      if(n==0 && a==0 && b==0 && c==0 && x==0)break ;
      t=-1 ;
      for(i=0 ; i<n ; i++){
        y=sc.nextInt();
        for(t++; t<f ; t++){
          if(x==y)break ;
          x=(a*x+b)% c ;
        }
        x=(a*x+b)% c ;
      }
      if(t<f)out.println(t);
      else out.println("-1");
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   attribute f : int := 10001;
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var a : int ;
    var b : int ;
    var c : int ;
    var x : int ;
    var y : int ;
    var t : int ;
    var i : int ;
       while true do ( (     n := sc.nextInt() ; 
     a := sc.nextInt() ; 
    b := sc.nextInt() ; 
    c := sc.nextInt() ; 
    x := sc.nextInt() ; 
    if (n = 0 & a = 0 & b = 0 & c = 0 & x = 0) then     break else skip ; 
    t := -1 ; 
        i := 0 ; while i < n do ( (     y := sc.nextInt() ; 
         t := t + 1 ; while t < f do ( (     if (x = y) then     break else skip ; 
     x := (a * x + b) mod c )  ;     t := t + 1 ) ; 
     x := (a * x + b) mod c )  ;     i := i + 1 ) ; 
    if (t < f) then     out.println(t) else     out.println("-1") ; ;  
 )  ) ; 
     sc.close() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void debug(String str){
    System.out.println(str);
  }
  public static void main(String[] args){
    long A ;
    long B ;
    try(Scanner sc=new Scanner(System.in)){
      A=sc.nextLong();
      B=sc.nextLong();
    }
    int cnt=0 ;
    System.out.println((int)Math.ceil((double)(B-1)/(A-1)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation debug( str : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(str) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : long ;
     var B : long ;
    try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     A := sc.getCurrent()->toLong() ; 
     B := sc.getCurrent()->toLong() ))  
    var cnt : int ; cnt := 0 ;
    OclFile["System.out"].println(((B - 1)->oclAsType(double) / (A - 1))->ceil()->oclAsType(int)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findAndPrintOriginalArray(int arr[],int n){
    int arr_sum=0 ;
    for(int i=0 ; i<n ; i++)arr_sum+=arr[i];
    arr_sum=arr_sum/(n-1);
    for(int i=0 ; i<n ; i++)System.out.print(arr_sum-arr[i]+" ");
  }
  public static void main(String[] args){
    int arr[]={
      10,14,12,13,11 };
      int n=arr.length ;
      findAndPrintOriginalArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findAndPrintOriginalArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var arr_sum : int ; arr_sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     arr_sum := arr_sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
     arr_sum := arr_sum / (n - 1) ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr_sum - arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,14,12,13,11} ;
     var n : int ; n := arr->size() ;
     execute findAndPrintOriginalArray(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int sumOfDigits(int a){
    int sum=0 ;
    while(a!=0){
      sum+=a % 10 ;
      a/=10 ;
    }
    return sum ;
  }
  static int findMax(int x){
    int b=1,ans=x ;
    while(x!=0){
      int cur=(x-1)*b+(b-1);
      if(sumOfDigits(cur)>sumOfDigits(ans)||(sumOfDigits(cur)==sumOfDigits(ans)&& cur>ans))ans=cur ;
      x/=10 ;
      b*=10 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int n=521 ;
    System.out.println(findMax(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfDigits( a : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (a /= 0) do (     sum := sum+(a mod 10) ; 
     a := a/(10) ) ; 
     return sum );
  static   operation findMax( x : int) : int
  pre: true
  post: true
  activity: (     var b : int ; b := 1 ;
    var ans : int ; ans := x ;
     while (x /= 0) do (     var cur : int ; cur := (x - 1) * b + (b - 1) ;
     if (sumOfDigits(cur) > sumOfDigits(ans) or (sumOfDigits(cur) = sumOfDigits(ans) & cur > ans)) then     ans := cur ; else skip ; 
     x := x/(10) ; 
     b := b*(10) ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 521 ;
     OclFile["System.out"].println(findMax(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javafx.util.Builder ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Problem_1342B {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    Set<Character>set=new HashSet<>();
    int T=scanner.nextInt();
    String s ;
    char[] t ;
    for(int i=0 ; i<T ; i++){
      s=scanner.next();
      t=s.toCharArray();
      int n=t.length ;
      set.clear();
      for(char c : t){
        set.add(c);
      }
      if(set.size()==1){
        System.out.println(s);
      }
      else {
        StringBuilder builder=new StringBuilder();
        for(int j=0 ; j<n ; j++){
          builder.append("01");
        }
        System.out.println(builder);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem_1342B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var set : Set(String) ; set := Set{} ;
    var T : int ; T := scanner.getCurrent()->toInteger() ;
    var s : String ;
    var t : Sequence(String) ;
        var i : int ; i := 0 ; while i < T do ( (     s := scanner.getCurrent() ; 
     t := s->characters() ; 
    var n : int ; n := t->size() ;
    set := set->intersection(Set{}) ; 
    for (c : t) do ( (     set := set->including(c) )  ) ; 
    if (set->size() = 1) then (     OclFile["System.out"].println(s) ) else (     var builder : String ; builder := StringLib.newString() ;
         var j : int ; j := 0 ; while j < n do ( (     builder := builder + StringLib.newString("01") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(builder) ) ;  
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class prepa {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int total=sc.nextInt();
    int last=0 ;
    int current ;
    for(int i=0 ; i<total ; i++){
      int a=sc.nextInt();
      current=a ;
      if(i==0){
        last=current ;
        continue ;
      }
      System.out.println(last+current);
      if(i==(total-1)){
        System.out.println(current);
      }
      last=current ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class prepa {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var total : int ; total := sc.getCurrent()->toInteger() ;
    var last : int ; last := 0 ;
    var current : int ;
        var i : int ; i := 0 ; while i < total do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     current := a ; 
    if (i = 0) then (     last := current ; 
     continue ) else skip ; 
    OclFile["System.out"].println(last + current) ; 
    if (i = (total - 1)) then (     OclFile["System.out"].println(current) ) else skip ; 
    last := current ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MemoryAndCrow {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    scan.nextLine();
    int[] A=new int[n];
    for(int i=0 ; i<n ; i++){
      A[i]=scan.nextInt();
    }
    int[] B=new int[n];
    for(int i=0 ; i<n-1 ; i++){
      B[i]=A[i]+A[i+1];
    }
    B[n-1]=A[n-1];
    for(int i=0 ; i<n ; i++){
      System.out.print(B[i]+" ");
    }
  }
  static int calculate(int[] A,int[] B,int i,int n){
    int b=A[i];
    boolean plus=true ;
    for(int x=i+1 ; x<n ; x++){
      if(plus){
        b+=B[x];
      }
      else {
        b-=B[x];
      }
      plus=! plus ;
    }
    return b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class MemoryAndCrow {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    skip ; 
    var A : Sequence(int) ; A := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var B : Sequence(int) ; B := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     B[i+1] := A[i+1] + A[i + 1+1] )  ;     i := i + 1 ) ; 
    B[n - 1+1] := A[n - 1+1] ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(B[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation calculate( A : Sequence(int), B : Sequence(int), i : int, n : int) : int
  pre: true
  post: true
  activity: (     var b : int ; b := A[i+1] ;
     var plus : boolean ; plus := true ;
         var x : int ; x := i + 1 ; while x < n do ( (     if (plus) then (     b := b+(B[x+1]) ) else (     b := b-(B[x+1]) ) ;  
     plus := not(plus) )  ;     x := x + 1 ) ; 
     return b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static final int BIG_NUM=2000000000 ;
  public static final int MOD=1000000007 ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String P=scanner.next().toLowerCase();
    char p[]=P.toCharArray();
    String tmp ;
    int ans=0 ;
    boolean FLG ;
    while(!(tmp=scanner.next()).equals("END_OF_TEXT")){
      char line[]=tmp.toLowerCase().toCharArray();
      if(line.length!=p.length)continue ;
      FLG=true ;
      for(int i=0 ; i<P.length(); i++){
        if(p[i]!=line[i]){
          FLG=false ;
          break ;
        }
      }
      if(FLG)ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BIG_NUM : int := 2000000000;
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var P : String ; P := scanner.getCurrent()->toLowerCase() ;
    var p : Sequence(String) ; p := P->characters() ;
    var tmp : String ;
    var ans : int ; ans := 0 ;
    var FLG : boolean ;
    while (not((tmp) = "END_OF_TEXT")) do (     var line : Sequence(String) ; line := tmp->toLowerCase()->characters() ;
     if (line->size() /= p->size()) then     continue else skip ; 
    FLG := true ; 
        var i : int ; i := 0 ; while i < P->size() do ( (     if (p[i+1] /= line[i+1]) then (     FLG := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (FLG) then     ans := ans + 1 ; else skip ; 
 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PROBLEM48 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextInt();
    long a[]=new long[(int)(n+1)];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
    }
    for(int i=0 ; i<n ; i++){
      a[i]=a[i]+a[i+1];
    }
    for(int i=0 ; i<n ; i++)System.out.print(a[i]+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class PROBLEM48 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,(n + 1)->oclAsType(int))->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := a[i+1] + a[i + 1+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
      if(i>0)System.out.print((a[i-1]+a[i])+" ");
    }
    System.out.print(a[n-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     if (i > 0) then     OclFile["System.out"].print((a[i - 1+1] + a[i+1]) + " ") ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(a[n - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    char[] s=(sc.next()+"_").toCharArray();
    int x=0,y=0,len=0 ;
    boolean inside=false ;
    for(char c : s)if(c=='_'){
      if(len!=0 && inside)++y ;
      else x=Math.max(x,len);
      len=0 ;
    }
    else if(c=='('){
      inside=true ;
      x=Math.max(x,len);
      len=0 ;
    }
    else if(c==')'){
      inside=false ;
      if(len!=0)++y ;
      len=0 ;
    }
    else++len ;
    out.println(x+" "+y);
    out.flush();
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := (sc.getCurrent() + "_")->characters() ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var len : int ; len := 0 ;
    var inside : boolean ; inside := false ;
    for (c : s) do (     if (c = '_') then (     if (len /= 0 & inside) then     y := y + 1 else     x := Set{x, len}->max() ; ;  
     len := 0 ) else     if (c = '(') then (     inside := true ; 
     x := Set{x, len}->max() ; 
     len := 0 ) else     if (c = ')') then (     inside := false ; 
     if (len /= 0) then     y := y + 1 ; else skip ; 
     len := 0 ) else     len := len + 1 ; ;  ;  ;   ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=Integer.parseInt(sc.next());
    int B=Integer.parseInt(sc.next());
    int amari=0 ;
    int result=0 ;
    result=(B-1)/(A-1);
    amari=(B-1)%(A-1);
    if(amari!=0){
      result+=1 ;
    }
    PrintWriter out=new PrintWriter(System.out);
    out.println(result);
    sc.close();
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := (sc.getCurrent())->toInteger() ;
    var B : int ; B := (sc.getCurrent())->toInteger() ;
    var amari : int ; amari := 0 ;
    var result : int ; result := 0 ;
    result := (B - 1) / (A - 1) ; 
    amari := (B - 1) mod (A - 1) ; 
    if (amari /= 0) then (     result := result+(1) ) else skip ; 
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder();
    int n=fs.nextInt();
    String s=fs.next();
    int j=0,cnt1=0,cnt2=0 ;
    boolean ch ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='('){
        j=0 ;
        while(s.charAt(i)!=')'){
          ch=false ;
          i++;
          for(; i<s.length(); i++){
            if(s.charAt(i)==')' || s.charAt(i)=='_')break ;
            ch=true ;
          }
          if(ch)cnt2++;
        }
      }
      else if(s.charAt(i)!='_')j++;
      else j=0 ;
      cnt1=Math.max(cnt1,j);
    }
    out.print(cnt1+" "+cnt2);
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long[] readArray(int n){
      long[] a=new long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := fs.nextInt() ;
    var s : String ; s := fs.next() ;
    var j : int ; j := 0 ;
    var cnt1 : int ; cnt1 := 0 ;
    var cnt2 : int ; cnt2 := 0 ;
    var ch : boolean ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '(') then (     j := 0 ; 
     while (s->at(i+1) /= ')') do (     ch := false ; 
     i := i + 1 ; 
       while i < s->size() do ( (     if (s->at(i+1) = ')' or s->at(i+1) = '_') then     break else skip ; 
     ch := true )  ;     i := i + 1 ) ; 
     if (ch) then     cnt2 := cnt2 + 1 ; else skip ) ) else     if (s->at(i+1) /= '_') then     j := j + 1 else     j := 0 ; ;  ;  
     cnt1 := Set{cnt1, j}->max() )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int largestPrimeFactor(int n){
    int max=-1 ;
    while(n % 2==0){
      max=2 ;
      n>>=1 ;
    }
    for(int i=3 ; i<=Math.sqrt(n); i+=2){
      while(n % i==0){
        max=i ;
        n=n/i ;
      }
    }
    if(n>2)max=n ;
    return max ;
  }
  static boolean checkUnusual(int n){
    int factor=largestPrimeFactor(n);
    if(factor>Math.sqrt(n)){
      return true ;
    }
    else {
      return false ;
    }
  }
  public static void main(String[] args){
    int n=14 ;
    if(checkUnusual(n)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation largestPrimeFactor( n : int) : int
  pre: true
  post: true
  activity: (     var max : int ; max := -1 ;
     while (n mod 2 = 0) do (     max := 2 ; 
     n := n/(2->pow(1)) ) ; 
        var i : int ; i := 3 ; while i <= (n)->sqrt() do ( (     while (n mod i = 0) do (     max := i ; 
     n := n / i ) )  ;     i := i+(2) ) ; 
    if (n > 2) then     max := n ; else skip ; 
    return max 
 );
  static   operation checkUnusual( n : int) : boolean
  pre: true
  post: true
  activity: (     var factor : int ; factor := largestPrimeFactor(n) ;
     if (factor > (n)->sqrt()) then (     return true ) else (     return false ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 14 ;
     if (checkUnusual(n)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Comparator ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    line=br.readLine();
    int n,m ;
    n=parseInt(line.substring(0,line.indexOf(' ')));
    m=parseInt(line.substring(line.indexOf(' ')+1));
    int[] seq=new int[n+1];
    int head=1 ;
    seq[0]=Integer.MIN_VALUE ;
    for(int i=1 ; i<=n ; i++)seq[i]=i ;
    for(int i=0 ; i<m ; i++){
      int e=parseInt(br.readLine());
      seq[e]=--head ;
    }
    int[][] res=new int[n+1][2];
    for(int i=0 ; i<=n ; i++){
      res[i][0]=i ;
      res[i][1]=seq[i];
    }
    Arrays.sort(res,new Comparator<int[]>(){
      @ Override public int compare(int[] o1,int[] o2){
        return Integer.compare(o1[1],o2[1]);
      }
    }
);
    StringBuilder sb=new StringBuilder();
    for(int i=1 ; i<=n ; i++){
      sb.append(res[i][0]).append('\n');
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    line := br.readLine() ; 
    var n : int ;
    var m : int ;
    n := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    m := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var seq : Sequence(int) ; seq := Integer.subrange(1,n + 1)->collect(0) ;
    var head : int ; head := 1 ;
    seq[0+1] := -2147483648 ; 
        var i : int ; i := 1 ; while i <= n do (     seq[i+1] := i ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var e : int ; e := parseInt(br.readLine()) ;
         head := head - 1 ;
 seq[e+1] := head  )  ;     i := i + 1 ) ; 
    var res : Sequence(Sequence(int)) ; res := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i <= n do ( (     res[i+1][0+1] := i ; 
     res[i+1][1+1] := seq[i+1] )  ;     i := i + 1 ) ; 
    res := OclComparator.sortWith(res, OclComparator<Sequence(int)>.newOclComparator()) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 1 ; while i <= n do ( (     sb := sb + StringLib.newString(res[i+1][0+1]) + StringLib.newString('
') )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[] E=new int[M];
    for(int i=0 ; i<M ; i++){
      E[i]=sc.nextInt();
    }
    boolean[] used=new boolean[N+1];
    for(int i=M-1 ; i>=0 ; i--){
      if(! used[E[i] ]){
        System.out.println(E[i]);
        used[E[i] ]=true ;
      }
    }
    for(int i=1 ; i<=N ; i++){
      if(! used[i])System.out.println(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var M : int ; M := sc.getCurrent()->toInteger() ;
    var E : Sequence(int) ; E := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     E[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var used : Sequence(boolean) ; used := Integer.subrange(1,N + 1)->collect(false) ;
        var i : int ; i := M - 1 ; while i >= 0 do ( (     if (not(used[E[i+1]+1])) then (     OclFile["System.out"].println(E[i+1]) ; 
     used[E[i+1]+1] := true ) else skip )  ;     i := i - 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (     if (not(used[i+1])) then     OclFile["System.out"].println(i) ; else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    solve();
  }
  public static void solve(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] e=new int[m];
    int[] num=new int[n+1];
    ArrayList<Integer>list=new ArrayList<Integer>();
    for(int i=0 ; i<m ; i++){
      int x=sc.nextInt();
      num[x]=1 ;
      list.add(x);
    }
    for(int i=list.size()-1 ; i>=0 ; i--){
      if(num[list.get(i)]==1){
        System.out.println(list.get(i));
        num[list.get(i)]=2 ;
      }
    }
    for(int i=1 ; i<=n ; i++){
      if(num[i]==0){
        System.out.println(i);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var e : Sequence(int) ; e := Integer.subrange(1,m)->collect(0) ;
    var num : Sequence(int) ; num := Integer.subrange(1,n + 1)->collect(0) ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     num[x+1] := 1 ; 
     list := list->including(x) )  ;     i := i + 1 ) ; 
        var i : int ; i := list->size() - 1 ; while i >= 0 do ( (     if (num[list->at(i+1)+1] = 1) then (     OclFile["System.out"].println(list->at(i+1)) ; 
     num[list->at(i+1)+1] := 2 ) else skip )  ;     i := i - 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (num[i+1] = 0) then (     OclFile["System.out"].println(i) ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] tmpArray=br.readLine().split(" ");
    int n=Integer.parseInt(tmpArray[0]);
    int m=Integer.parseInt(tmpArray[1]);
    Node[] array=new Node[n];
    for(int i=0 ; i<n ; i++){
      array[i]=new Node(i+1);
    }
    for(int i=0 ; i<m ; i++){
      int index=Integer.parseInt(br.readLine())-1 ;
      array[index] .priority=i ;
    }
    Arrays.sort(array);
    for(int i=0 ; i<n ; i++){
      System.out.println(array[i] .key);
    }
  }
}
class Node implements Comparable<Node>{
  int key ;
  int priority=-1 ;
  Node(int key){
    this.key=key ;
  }
  @ Override public int compareTo(Node node){
    return node.priority-this.priority ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
    var n : int ; n := (tmpArray[0+1])->toInteger() ;
    var m : int ; m := (tmpArray[1+1])->toInteger() ;
    var array : Sequence(Node) ; array := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := Node.newNode(i + 1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var index : int ; index := (br.readLine())->toInteger() - 1 ;
     array[index+1].priority := i )  ;     i := i + 1 ) ; 
    array := array->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(array[i+1].key) )  ;     i := i + 1 ) ; 
 );
}
class Node implements Comparable<Node> {
   attribute key : int;
   attribute priority : int := -1;
   static operation newNode( key : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(key);
    return self );
  operation initialise( key : int) : void
  pre: true  post: true
  activity: (     self.key := key );
      operation compareTo( node : Node) : int
  pre: true
  post: true
  activity: (     return node.priority - self.priority );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    line=br.readLine();
    int n,m ;
    n=parseInt(line.substring(0,line.indexOf(' ')));
    m=parseInt(line.substring(line.indexOf(' ')+1));
    List<Integer>list=new ArrayList<>(n+m);
    boolean[] dup=new boolean[n+1];
    for(int i=n ; i>=1 ; i--)list.add(i);
    for(int i=0 ; i<m ; i++)list.add(parseInt(br.readLine()));
    StringBuilder sb=new StringBuilder();
    for(int i=list.size()-1 ; i>=0 ; i--){
      int e=list.get(i);
      if(! dup[e]){
        sb.append(e).append('\n');
        dup[e]=true ;
      }
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    line := br.readLine() ; 
    var n : int ;
    var m : int ;
    n := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    m := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var list : Sequence(int) ; list := Sequence{}->union(n + m) ;
    var dup : Sequence(boolean) ; dup := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := n ; while i >= 1 do (     list := list->including(i) ;  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     list := list->including((br.readLine() + "")->toInteger()) ;  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := list->size() - 1 ; while i >= 0 do ( (     var e : int ; e := list->at(i+1) ;
     if (not(dup[e+1])) then (     sb := sb + StringLib.newString(e) + StringLib.newString('
') ; 
     dup[e+1] := true ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.text.*;
public class Main {
  public static final String EOF="END_OF_TEXT" ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String keyWord=sc.nextLine().toLowerCase();
    int count=0 ;
    String[] strArr ;
    boolean exit=false ;
    while(! exit){
      strArr=sc.nextLine().split(" ");
      for(int i=0 ; i<strArr.length ; i++){
        if(strArr[i] .equals(EOF)){
          exit=true ;
          break ;
        }
        if(strArr[i] .toLowerCase().equals(keyWord)){
          count++;
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute EOF : String := "END_OF_TEXT";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var keyWord : String ; keyWord := sc.nextLine()->toLowerCase() ;
    var count : int ; count := 0 ;
    var strArr : Sequence(String) ;
    var exit : boolean ; exit := false ;
    while (not(exit)) do (     strArr := sc.nextLine()->split(" ") ; 
         var i : int ; i := 0 ; while i < strArr->size() do ( (     if (strArr[i+1] = EOF) then (     exit := true ; 
     break ) else skip ; 
     if (strArr[i+1]->toLowerCase() = keyWord) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1315 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    StringBuilder output=new StringBuilder();
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int a=in.nextInt();
      int b=in.nextInt();
      int p=in.nextInt();
      char[] S=in.next().toCharArray();
      S[S.length-1]='C' ;
      int cost=0 ;
      int answer=S.length ;
      for(int n=S.length-2 ; n>=0 ; n--){
        if(S[n+1]!=S[n]){
          cost+=(S[n]=='A')? a : b ;
        }
        if(cost<=p){
          answer=n+1 ;
        }
        else {
          break ;
        }
      }
      output.append(answer).append('\n');
    }
    System.out.print(output);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1315 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var output : String ; output := StringLib.newString() ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < T do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    var p : int ; p := in.getCurrent()->toInteger() ;
    var S : Sequence(String) ; S := in.getCurrent()->characters() ;
    S[S->size() - 1+1] := 'C' ; 
    var cost : int ; cost := 0 ;
    var answer : int ; answer := S->size() ;
        var n : int ; n := S->size() - 2 ; while n >= 0 do ( (     if (S[n + 1+1] /= S[n+1]) then (     cost := cost+(if (S[n+1] = 'A') then a else b endif) ) else skip ; 
     if (cost <= p) then (     answer := n + 1 ) else (     break ) )  ;     n := n - 1 ) ; 
    output := output + StringLib.newString(answer) + StringLib.newString('
') ; 
 )  ;     t := t + 1 ) ; 
    OclFile["System.out"].print(output) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class test6 {
  public static final int mod=1000000007 ;
  public static void main(String[] args)throws IOException {
    BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    int t=Integer.parseInt(sc.readLine());
    while(t-->0){
      String[] ipp=sc.readLine().split(" ");
      int a=Integer.parseInt(ipp[0]);
      int b=Integer.parseInt(ipp[1]);
      int p=Integer.parseInt(ipp[2]);
      String s=sc.readLine();
      int n=s.length();
      int i=n-2 ;
      long sum=0 ;
      int ans=n ;
      while(i>=0){
        if(s.charAt(i)=='A'){
          sum+=a ;
          if(sum>p){
            ans=i+1 ;
            break ;
          }
          while(i>=0 && s.charAt(i)=='A'){
            i--;
          }
        }
        else if(s.charAt(i)=='B'){
          sum+=b ;
          if(sum>p){
            ans=i+1 ;
            break ;
          }
          while(i>=0 && s.charAt(i)=='B'){
            i--;
          }
        }
      }
      if(sum<=p)ans=0 ;
      out.println(ans+1);
    }
    out.flush();
    out.close();
  }
  public static int gcd(int A,int B){
    if(B==0)return A ;
    else return gcd(B,A % B);
  }
  public static class Pair {
    long x=0 ;
    long y=0 ;
    Pair(long a,long b){
      x=a ;
      y=b ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class test6 {
  static    attribute mod : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (sc.readLine())->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var ipp : Sequence(String) ; ipp := sc.readLine()->split(" ") ;
     var a : int ; a := (ipp[0+1])->toInteger() ;
    var b : int ; b := (ipp[1+1])->toInteger() ;
    var p : int ; p := (ipp[2+1])->toInteger() ;
    var s : String ; s := sc.readLine() ;
    var n : int ; n := s->size() ;
    var i : int ; i := (n)->char2byte() - 2 ;
    var sum : long ; sum := 0 ;
    var ans : int ; ans := n ;
    while (i >= 0) do (     if (s->at(i+1) = 'A') then (     sum := sum+(a) ; 
     if (sum > p) then (     ans := i + 1 ; 
     break ) else skip ; 
     while (i >= 0 & s->at(i+1) = 'A') do (     i := i - 1 ) ) else     if (s->at(i+1) = 'B') then (     sum := sum+(b) ; 
     if (sum > p) then (     ans := i + 1 ; 
     break ) else skip ; 
     while (i >= 0 & s->at(i+1) = 'B') do (     i := i - 1 ) ) else skip ; ) ; 
    if (sum <= p) then     ans := 0 ; else skip ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
 );
  static   operation gcd( A : int, B : int) : int
  pre: true
  post: true
  activity: (     if (B = 0) then     return A else     return gcd(B, A mod B) );
  static class Pair {
   attribute x : long := 0;
   attribute y : long := 0;
   static operation newPair( a : long, b : long) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(a, b);
    return self );
  operation initialise( a : long, b : long) : void
  pre: true  post: true
  activity: (     x := a ; 
     y := b );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int A=sc.nextInt();
    int B=sc.nextInt();
    int ans=(A+B-3)/(A-1);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
     var ans : int ; ans := (A + B - 3) / (A - 1) ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int gcd(int a,int b){
    if(a==b)return a ;
    if(a==0)return b ;
    if(b==0)return a ;
    if((~ a & 1)==1){
      if((b & 1)==1)return gcd(a>>1,b);
      else return gcd(a>>1,b>>1)<<1 ;
    }
    if((~ b & 1)==1)return gcd(a,b>>1);
    if(a>b)return gcd((a-b)>>1,b);
    return gcd((b-a)>>1,a);
  }
  public static void main(String args[]){
    int a=34,b=17 ;
    System.out.println("Gcd of given"+"numbers is "+gcd(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = b) then     return a else skip ; 
     if (a = 0) then     return b else skip ; 
    if (b = 0) then     return a else skip ; 
    if ((-(a + 1) & 1) = 1) then (     if ((b & 1) = 1) then     return gcd((a/(2->pow(1)))->oclAsType(long), b) else     return (gcd((a/(2->pow(1)))->oclAsType(long), (b/(2->pow(1)))->oclAsType(long))*(2->pow(1)))->oclAsType(long) ) else skip ; 
    if ((-(b + 1) & 1) = 1) then     return gcd(a, (b/(2->pow(1)))->oclAsType(long)) else skip ; 
    if (a > b) then     return gcd(((a - b)/(2->pow(1)))->oclAsType(long), b) else skip ; 
    return gcd(((b - a)/(2->pow(1)))->oclAsType(long), a) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 34 ;
    var b : int ; b := 17 ;
     OclFile["System.out"].println("Gcd of given" + "numbers is " + gcd(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    int k ;
    for(k=0 ; ((a | b)& 1)==0 ; ++k){
      a>>=1 ;
      b>>=1 ;
    }
    while((a & 1)==0)a>>=1 ;
    do {
      while((b & 1)==0)b>>=1 ;
      if(a>b){
        int temp=a ;
        a=b ;
        b=temp ;
      }
      b=(b-a);
    }
    while(b!=0);
    return a<<k ;
  }
  public static void main(String args[]){
    int a=34,b=17 ;
    System.out.println("Gcd of given "+"numbers is "+gcd(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
    var k : int ;
        k := 0 ; while ((a or b) & 1) = 0 do ( (     a := a/(2->pow(1)) ; 
     b := b/(2->pow(1)) )  ;     k := k + 1 ) ; 
    while ((a & 1) = 0) do     a := a/(2->pow(1)) ; ; 
  while true do ((     while ((b & 1) = 0) do     b := b/(2->pow(1)) ; ; 
     if (a > b) then (     var temp : int ; temp := a ;
     a := b ; 
     b := temp ) else skip ; 
     b := (b - a) ) ;
    if (b /= 0) then skip else break) ; 
    return (a*(2->pow(k)))->oclAsType(long) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 34 ;
    var b : int ; b := 17 ;
     OclFile["System.out"].println("Gcd of given " + "numbers is " + gcd(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int ans=0 ;
      int pw=1000_000_000 ;
      while(n>0){
        while(n<pw)pw/=10 ;
        ans+=pw ;
        n-=pw-pw/10 ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ans : int ; ans := 0 ;
    var pw : int ; pw := 1000_000_000 ;
    while (n > 0) do (     while (n < pw) do     pw := pw/(10) ; ; 
     ans := ans+(pw) ; 
     n := n-(pw - pw / 10) ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
public class Main {
  static void mySoln(int i,int[] cases){
    int x,y,spent=0 ;
    x=cases[i];
    spent=0 ;
    while(true){
      if(x>=10){
        y=x/10 ;
        x=x % 10+y ;
        y=y*10 ;
        spent=spent+y ;
      }
      else {
        spent=spent+x ;
        System.out.println(spent);
        break ;
      }
    }
  }
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    int cases[]=new int[t];
    for(int i=0 ; i<t ; i++){
      cases[i]=Integer.parseInt(br.readLine());
    }
    for(int i=0 ; i<t ; i++)mySoln(i,cases);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation mySoln( i : int, cases : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var x : int ;
    var y : int ;
    var spent : int ; spent := 0 ;
     x := cases[i+1] ; 
     spent := 0 ; 
     while (true) do (     if (x >= 10) then (     y := x / 10 ; 
     x := x mod 10 + y ; 
     y := y * 10 ; 
     spent := spent + y ) else (     spent := spent + x ; 
     OclFile["System.out"].println(spent) ; 
     break ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
    var cases : Sequence(int) ; cases := Integer.subrange(1,t)->collect(0) ;
        var i : int ; i := 0 ; while i < t do ( (     cases[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < t do (     execute mySoln(i, cases) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
public class Main {
  static void mySoln(int t,int[] cases){
    int x,y,spent=0 ;
    for(int i=0 ; i<t ; i++){
      x=cases[i];
      spent=0 ;
      while(true){
        if(x>=10){
          y=x/10 ;
          x=x % 10+y ;
          y=y*10 ;
          spent=spent+y ;
        }
        else {
          spent=spent+x ;
          System.out.println(spent);
          break ;
        }
      }
    }
  }
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    int cases[]=new int[t];
    for(int i=0 ; i<t ; i++){
      cases[i]=Integer.parseInt(br.readLine());
    }
    mySoln(t,cases);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation mySoln( t : int, cases : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var x : int ;
    var y : int ;
    var spent : int ; spent := 0 ;
         var i : int ; i := 0 ; while i < t do ( (     x := cases[i+1] ; 
     spent := 0 ; 
     while (true) do (     if (x >= 10) then (     y := x / 10 ; 
     x := x mod 10 + y ; 
     y := y * 10 ; 
     spent := spent + y ) else (     spent := spent + x ; 
     OclFile["System.out"].println(spent) ; 
     break ) ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
    var cases : Sequence(int) ; cases := Integer.subrange(1,t)->collect(0) ;
        var i : int ; i := 0 ; while i < t do ( (     cases[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    execute mySoln(t, cases) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class sol {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int test=0 ; test<t ; test++){
      int n=sc.nextInt();
      int num=0,ans=n ;
      while(n>=10){
        num=n/10 ;
        n=num+n % 10 ;
        ans+=num ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class sol {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var test : int ; test := 0 ; while test < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var num : int ; num := 0 ;
    var ans : int ; ans := n ;
     while (n >= 10) do (     num := n / 10 ; 
     n := num + n mod 10 ; 
     ans := ans+(num) ) ; 
     OclFile["System.out"].println(ans) )  ;     test := test + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Mridul5 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int k=0 ;
    while(k!=t){
      k=k+1 ;
      int n=sc.nextInt();
      long sum=0,sum1=n ;
      while(sum1>=10){
        sum=sum+sum1-sum1 % 10 ;
        sum1=sum1 % 10+sum1/10 ;
      }
      sum=sum+sum1 ;
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mridul5 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     var k : int ; k := 0 ;
     while (k /= t) do (     k := k + 1 ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var sum : long ; sum := 0 ;
    var sum1 : long ; sum1 := n ;
    while (sum1 >= 10) do (     sum := sum + sum1 - sum1 mod 10 ; 
     sum1 := sum1 mod 10 + sum1 / 10 ) ; 
    sum := sum + sum1 ; 
    OclFile["System.out"].println(sum) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int toDecimal(String binary,int i){
    int n=binary.length();
    if(i==n-1)return binary.charAt(i)-'0' ;
    return((binary.charAt(i)-'0')<<(n-i-1))+toDecimal(binary,i+1);
  }
  public static void main(String[] args){
    String binary="1010" ;
    int i=0 ;
    System.out.println(toDecimal(binary,i));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation toDecimal( binary : String, i : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := binary->size() ;
     if (i = n - 1) then     return binary->at(i+1) - ('0')->char2byte() else skip ; 
     return (((binary->at(i+1) - ('0')->char2byte())*(2->pow((n - i - 1))))->oclAsType(long)) + toDecimal(binary, i + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var binary : String ; binary := "1010" ;
     var i : int ; i := 0 ;
     OclFile["System.out"].println(toDecimal(binary, i)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String t[];
    int count=0 ;
    boolean flag=true ;
    try {
      String w=br.readLine();
      while(flag){
        t=br.readLine().split(" ");
        for(String string : t){
          if(string.equals("END_OF_TEXT")){
            flag=false ;
            break ;
          }
          if(string.equalsIgnoreCase(w)){
            count++;
          }
        }
      }
      System.out.println(count);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : Sequence(String) ;
    var count : int ; count := 0 ;
    var flag : boolean ; flag := true ;
    try (     var w : String ; w := br.readLine() ;
     while (flag) do (     t := br.readLine()->split(" ") ; 
     for (string : t) do ( (     if (string = "END_OF_TEXT") then (     flag := false ; 
     break ) else skip ; 
     if (string->equalsIgnoreCase(w)) then (     count := count + 1 ) else skip )  ) ) ; 
     OclFile["System.out"].println(count) )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static void preprocess(int p[],int x[],int y[],int n){
    for(int i=0 ; i<n ; i++)p[i]=x[i]*x[i]+y[i]*y[i];
    Arrays.sort(p);
  }
  public static int query(int p[],int n,int rad){
    int start=0,end=n-1 ;
    while((end-start)>1){
      int mid=(start+end)/2 ;
      double tp=Math.sqrt(p[mid]);
      if(tp>(rad*1.0))end=mid-1 ;
      else start=mid ;
    }
    double tp1=Math.sqrt(p[start]);
    double tp2=Math.sqrt(p[end]);
    if(tp1>(rad*1.0))return 0 ;
    else if(tp2<=(rad*1.0))return end+1 ;
    else return start+1 ;
  }
  public static void main(String[] args){
    int x[]={
      1,2,3,-1,4 };
      int y[]={
        1,2,3,-1,4 };
        int n=x.length ;
        int p[]=new int[n];
        preprocess(p,x,y,n);
        System.out.println(query(p,n,3));
        System.out.println(query(p,n,32));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation preprocess( p : Sequence(int), x : Sequence(int), y : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     p[i+1] := x[i+1] * x[i+1] + y[i+1] * y[i+1] ;  ;     i := i + 1 ) ; 
     p := p->sort() );
  static   operation query( p : Sequence(int), n : int, rad : int) : int
  pre: true
  post: true
  activity: (     var start : int ; start := 0 ;
    var end : int ; end := n - 1 ;
     while ((end - start) > 1) do (     var mid : int ; mid := (start + end) / 2 ;
     var tp : double ; tp := (p[mid+1])->sqrt() ;
     if (tp > (rad * 1.0)) then     end := mid - 1 ; else     start := mid ; ) ; 
    var tp1 : double ; tp1 := (p[start+1])->sqrt() ;
    var tp2 : double ; tp2 := (p[end+1])->sqrt() ;
    if (tp1 > (rad * 1.0)) then     return 0 else     if (tp2 <= (rad * 1.0)) then     return end + 1 else     return start + 1 ;  ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : Sequence(int) ; x := Sequence{1,2,3,-1,4} ;
     var y : Sequence(int) ; y := Sequence{1,2,3,-1,4} ;
    var n : int ; n := x->size() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    execute preprocess(p, x, y, n) ; 
    OclFile["System.out"].println(query(p, n, 3)) ; 
    OclFile["System.out"].println(query(p, n, 32)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void possibleTripletInRange(int L,int R){
    boolean flag=false ;
    int possibleA=0,possibleB=0,possibleC=0 ;
    int numbersInRange=(R-L+1);
    if(numbersInRange<3){
      flag=false ;
    }
    else if(numbersInRange>3){
      flag=true ;
      if(L % 2>0){
        L++;
      }
      possibleA=L ;
      possibleB=L+1 ;
      possibleC=L+2 ;
    }
    else {
      if(!(L % 2>0)){
        flag=true ;
        possibleA=L ;
        possibleB=L+1 ;
        possibleC=L+2 ;
      }
      else {
        flag=false ;
      }
    }
    if(flag==true){
      System.out.println("("+possibleA+","+possibleB+","+possibleC+")"+" is one such possible"+" triplet between "+L+" and "+R);
    }
    else {
      System.out.println("No Such Triplet"+" exists between "+L+" and "+R);
    }
  }
  public static void main(String[] args){
    int L,R ;
    L=2 ;
    R=10 ;
    possibleTripletInRange(L,R);
    L=23 ;
    R=46 ;
    possibleTripletInRange(L,R);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation possibleTripletInRange( L : int, R : int) : void
  pre: true
  post: true
  activity: (     var flag : boolean ; flag := false ;
     var possibleA : int ; possibleA := 0 ;
    var possibleB : int ; possibleB := 0 ;
    var possibleC : int ; possibleC := 0 ;
    var numbersInRange : int ; numbersInRange := (R - L + 1) ;
    if (numbersInRange < 3) then (     flag := false ) else     if (numbersInRange > 3) then (     flag := true ; 
     if (L mod 2 > 0) then (     L := L + 1 ) else skip ; 
    possibleA := L ; 
    possibleB := L + 1 ; 
    possibleC := L + 2 ; 
 ) else (     if (not((L mod 2 > 0))) then (     flag := true ; 
     possibleA := L ; 
     possibleB := L + 1 ; 
     possibleC := L + 2 ) else (     flag := false ) ) ;  ;  
    if (flag = true) then (     OclFile["System.out"].println("(" + possibleA + "," + possibleB + "," + possibleC + ")" + " is one such possible" + " triplet between " + L + " and " + R) ) else (     OclFile["System.out"].println("No Such Triplet" + " exists between " + L + " and " + R) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ;
    var R : int ;
     L := 2 ; 
    R := 10 ; 
    execute possibleTripletInRange(L, R) ; 
    L := 23 ; 
    R := 46 ; 
    execute possibleTripletInRange(L, R) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String addZeros(String str,int n){
    for(int i=0 ; i<n ; i++){
      str="0"+str ;
    }
    return str ;
  }
  static String getXOR(String a,String b){
    int aLen=a.length();
    int bLen=b.length();
    if(aLen>bLen){
      a=addZeros(b,aLen-bLen);
    }
    else if(bLen>aLen){
      a=addZeros(a,bLen-aLen);
    }
    int len=Math.max(aLen,bLen);
    String res="" ;
    for(int i=0 ; i<len ; i++){
      if(a.charAt(i)==b.charAt(i))res+="0" ;
      else res+="1" ;
    }
    return res ;
  }
  public static void main(String[] args){
    String a="11001",b="111111" ;
    System.out.println(getXOR(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation addZeros( str : String, n : int) : String
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     str := "0" + str )  ;     i := i + 1 ) ; 
     return str );
  static   operation getXOR( a : String, b : String) : String
  pre: true
  post: true
  activity: (     var aLen : int ; aLen := a->size() ;
     var bLen : int ; bLen := b->size() ;
    if (aLen > bLen) then (     a := addZeros(b, aLen - bLen) ) else     if (bLen > aLen) then (     a := addZeros(a, bLen - aLen) ) else skip ; ;  
    var len : int ; len := Set{aLen, bLen}->max() ;
    var res : String ; res := "" ;
        var i : int ; i := 0 ; while i < len do ( (     if (a->at(i+1) = b->at(i+1)) then     res := res+("0") ; else     res := res+("1") ; )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ; a := "11001" ;
    var b : String ; b := "111111" ;
     OclFile["System.out"].println(getXOR(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countSegments(int a[],int n,int x){
    boolean flag=false ;
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]>x){
        flag=true ;
      }
      else {
        if(flag)count+=1 ;
        flag=false ;
      }
    }
    if(flag)count+=1 ;
    return count ;
  }
  public static void main(String[] args){
    int a[]={
      8,25,10,19,19,18,20,11,18 };
      int n=a.length ;
      int x=13 ;
      System.out.println(countSegments(a,n,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSegments( a : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var flag : boolean ; flag := false ;
     var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] > x) then (     flag := true ) else (     if (flag) then     count := count+(1) ; else skip ; 
     flag := false ) )  ;     i := i + 1 ) ; 
    if (flag) then     count := count+(1) ; else skip ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{8,25,10,19,19,18,20,11,18} ;
     var n : int ; n := a->size() ;
     var x : int ; x := 13 ;
     OclFile["System.out"].println(countSegments(a, n, x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean checkEqualNo(int m,int n,int a,int b){
    if(m<=n){
      if((n-m)%(a+b)==0){
        return true ;
      }
      else {
        return false ;
      }
    }
    else {
      return false ;
    }
  }
  public static void main(String[] args){
    int M=2,N=8 ;
    int A=3,B=3 ;
    if(checkEqualNo(M,N,A,B)==true)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkEqualNo( m : int, n : int, a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     if (m <= n) then (     if ((n - m) mod (a + b) = 0) then (     return true ) else (     return false ) ) else (     return false ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var M : int ; M := 2 ;
    var N : int ; N := 8 ;
     var A : int ; A := 3 ;
    var B : int ; B := 3 ;
     if (checkEqualNo(M, N, A, B) = true) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int r=sc.nextInt();
    System.out.println(r*r*3);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(r * r * 3) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Map ;
import java.util.Map.Entry ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  static long MOD=1_000_000_007 ;
  static int INF=1_000_000_007 ;
  static boolean isPreprocessing=false ;
  static int MAX=260 ;
  static long[] fac ;
  static long[] inv ;
  static long[] finv ;
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    System.out.println(3*N*N);
  }
  static long lcm(long a,long b){
    long temp ;
    long c=a ;
    c*=b ;
    while((temp=a % b)!=0){
      a=b ;
      b=temp ;
    }
    return(c/b);
  }
  static void COMinit(){
    fac=new long[MAX+1];
    fac[0]=1L ;
    fac[1]=1L ;
    inv=new long[MAX+1];
    inv[1]=1L ;
    finv=new long[MAX+1];
    finv[0]=1L ;
    finv[1]=1L ;
    for(int i=2 ; i<MAX ; i++){
      fac[i]=fac[i-1]*i % MOD ;
      inv[i]=MOD-inv[(int)(MOD % i)]*(MOD/i)% MOD ;
      finv[i]=finv[i-1]*inv[i] % MOD ;
    }
    isPreprocessing=true ;
  }
  static long COM(int i,int j){
    if(i<j)return 0 ;
    if(i<0 || j<0)return 0 ;
    if(! isPreprocessing)COMinit();
    return fac[i]*(finv[j]*finv[i-j] % MOD)% MOD ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : long := 1_000_000_007;
  static   attribute INF : int := 1_000_000_007;
  static   attribute isPreprocessing : boolean := false;
  static   attribute MAX : int := 260;
  static   attribute fac : Sequence(long);
  static   attribute inv : Sequence(long);
  static   attribute finv : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
     OclFile["System.out"].println(3 * N * N) );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var temp : long ;
     var c : long ; c := a ;
    c := c*(b) ; 
        temp := a mod b ;
    while ((temp) /= 0) do (    skip ; (     a := b ; 
     b := temp ) ;     temp := a mod b ;
 ) ;  
    return (c / b) 
 );
  static   operation COMinit() : void
  pre: true
  post: true
  activity: (     fac := Integer.subrange(1,MAX + 1)->collect(0) ; 
     fac[0+1] := 1L ; 
    fac[1+1] := 1L ; 
    inv := Integer.subrange(1,MAX + 1)->collect(0) ; 
    inv[1+1] := 1L ; 
    finv := Integer.subrange(1,MAX + 1)->collect(0) ; 
    finv[0+1] := 1L ; 
    finv[1+1] := 1L ; 
        var i : int ; i := 2 ; while i < MAX do ( (     fac[i+1] := fac[i - 1+1] * i mod MOD ; 
     inv[i+1] := MOD - inv[(MOD mod i)->oclAsType(int)+1] * (MOD / i) mod MOD ; 
     finv[i+1] := finv[i - 1+1] * inv[i+1] mod MOD )  ;     i := i + 1 ) ; 
    isPreprocessing := true ; 
 );
  static   operation COM( i : int, j : int) : long
  pre: true
  post: true
  activity: (     if (i < j) then     return 0 else skip ; 
     if (i < 0 or j < 0) then     return 0 else skip ; 
     if (not(isPreprocessing)) then     execute COMinit() ; else skip ; 
     return fac[i+1] * (finv[j+1] * finv[i - j+1] mod MOD) mod MOD );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    A solver=new A();
    solver.solve(1,in,out);
    out.close();
  }
  static class A {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int a=Integer.parseInt(in.next());
      int ans=3*a*a ;
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : A ; solver := A.newA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class A {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := (in.getCurrent())->toInteger() ;
     var ans : int ; ans := 3 * a * a ;
     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    sc.close();
    System.out.println(3*n*n);
  }
  public static int[] arrayInt(Scanner sc,int n){
    int[] array=new int[n];
    for(int i=0 ; i<n ; i++){
      array[i]=sc.nextInt();
    }
    return array ;
  }
  public static long[] arrayLong(Scanner sc,int n){
    long[] array=new long[n];
    for(int i=0 ; i<n ; i++){
      array[i]=sc.nextLong();
    }
    return array ;
  }
  public static double[] arrayDouble(Scanner sc,int n){
    double[] array=new double[n];
    for(int i=0 ; i<n ; i++){
      array[i]=sc.nextDouble();
    }
    return array ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     skip ; 
     OclFile["System.out"].println(3 * n * n) );
  static   operation arrayInt( sc : OclFile, n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     array[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return array );
  static   operation arrayLong( sc : OclFile, n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var array : Sequence(long) ; array := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     array[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
     return array );
  static   operation arrayDouble( sc : OclFile, n : int) : Sequence(double)
  pre: true
  post: true
  activity: (     var array : Sequence(double) ; array := Integer.subrange(1,n)->collect(0.0) ;
         var i : int ; i := 0 ; while i < n do ( (     array[i+1] := sc.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
     return array );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner inp=new Scanner(System.in);
    do_(inp);
    inp.close();
  }
  public static void do_(Scanner inp){
    int a=inp.nextInt();
    System.out.println(a*a*3);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inp : OclFile ; inp := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute do_(inp) ; 
     skip );
  static   operation do_( inp : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := inp.getCurrent()->toInteger() ;
     OclFile["System.out"].println(a * a * 3) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static double ABS(double x){
    return x>0 ? x :-x ;
  }
  public static int One(int x){
    if(x==2)return 2 ;
    return(x-1)/2*3+2 ;
  }
  public static int Two(int x){
    return x/2*3 ;
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int a,x,y ;
    a=s.nextInt();
    x=s.nextInt();
    y=s.nextInt();
    s.close();
    if(y % a==0){
      System.out.println("-1");
    }
    else {
      int n=y/a+1 ;
      if(n==1){
        if(x<ABS(a/2.0)&& x>-ABS(a/2.0))System.out.println(1);
        else System.out.println(-1);
      }
      else {
        if(n % 2==0){
          if(x<ABS(a/2.0)&& x>-ABS(a/2.0))System.out.println(One(n));
          else System.out.println("-1");
        }
        else {
          if(x<0 && x>-a){
            System.out.println(Two(n));
          }
          else if(x>0 && x<a){
            System.out.println(Two(n)+1);
          }
          else System.out.println("-1");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation ABS( x : double) : double
  pre: true
  post: true
  activity: (     return if x > 0 then x else -x endif );
  static   operation One( x : int) : int
  pre: true
  post: true
  activity: (     if (x = 2) then     return 2 else skip ; 
     return (x - 1) / 2 * 3 + 2 );
  static   operation Two( x : int) : int
  pre: true
  post: true
  activity: (     return x / 2 * 3 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ;
    var x : int ;
    var y : int ;
    a := s.getCurrent()->toInteger() ; 
    x := s.getCurrent()->toInteger() ; 
    y := s.getCurrent()->toInteger() ; 
    skip ; 
    if (y mod a = 0) then (     OclFile["System.out"].println("-1") ) else (     var n : int ; n := y / a + 1 ;
     if (n = 1) then (     if (x < ABS(a / 2.0) & x > -ABS(a / 2.0)) then     OclFile["System.out"].println(1) ; else     OclFile["System.out"].println(-1) ; ) else (     if (n mod 2 = 0) then (     if (x < ABS(a / 2.0) & x > -ABS(a / 2.0)) then     OclFile["System.out"].println(One(n)) ; else     OclFile["System.out"].println("-1") ; ) else (     if (x < 0 & x > -a) then (     OclFile["System.out"].println(Two(n)) ) else     if (x > 0 & x < a) then (     OclFile["System.out"].println(Two(n) + 1) ) else     OclFile["System.out"].println("-1") ; ;  ) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class CountSubsequences {
  public static int productSubSeqCount(ArrayList<Integer>arr,int k){
    int n=arr.size();
    int dp[][]=new int[k+1][n+1];
    for(int i=1 ; i<=k ; i++){
      for(int j=1 ; j<=n ; j++){
        dp[i][j]=dp[i][j-1];
        if(arr.get(j-1)<=i && arr.get(j-1)>0)dp[i][j]+=dp[i/arr.get(j-1)][j-1]+1 ;
      }
    }
    return dp[k][n];
  }
  public static void main(String args[]){
    ArrayList<Integer>A=new ArrayList<Integer>();
    A.add(1);
    A.add(2);
    A.add(3);
    A.add(4);
    int k=10 ;
    System.out.println(productSubSeqCount(A,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class CountSubsequences {
  static   operation productSubSeqCount( arr : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,k + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
         var i : int ; i := 1 ; while i <= k do ( (         var j : int ; j := 1 ; while j <= n do ( (     dp[i+1][j+1] := dp[i+1][j - 1+1] ; 
     if (arr->at(j - 1+1) <= i & arr->at(j - 1+1) > 0) then     dp[i+1][j+1] := dp[i+1][j+1]+(dp[i / arr->at(j - 1+1)+1][j - 1+1] + 1) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return dp[k+1][n+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{} ;
     A := A->including(1) ; 
    A := A->including(2) ; 
    A := A->including(3) ; 
    A := A->including(4) ; 
    var k : int ; k := 10 ;
    OclFile["System.out"].println(productSubSeqCount(A, k)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class code1 {
  static class pair {
    long idx,value ;
    public pair(long x,long y){
      this.idx=x ;
      this.value=y ;
    }
  }
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int t=sc.nextInt();
    while(t-->0){
      solve();
    }
  }
  static void solve(){
    long n=sc.nextLong();
    ArrayList<pair>a=new ArrayList<>();
    for(long i=1 ; i<=n ; i++){
      a.add(new pair(i,sc.nextLong()));
    }
    if(n>1){
      Collections.sort(a,(aa,b)->(int)(aa.value-b.value));
      System.out.println(a.get(0).idx+" "+a.get(a.size()-1).idx);
    }
    else System.out.println(1+" "+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class code1 {
  static class pair {
   attribute idx : long;
   static operation newpair( x : long, y : long) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(x, y);
    return self );
  operation initialise( x : long, y : long) : void
  pre: true  post: true
  activity: (     self.idx := x ; 
     self.value := y );
}
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.getCurrent()->toLong() ;
     var a : Sequence(pair) ; a := Sequence{} ;
         var i : long ; i := 1 ; while i <= n do ( (     a := a->including(pair.newpair(i, sc.getCurrent()->toLong())) )  ;     i := i + 1 ) ; 
     if (n > 1) then (     a, lambda (aa , b) : OclAny in (aa.value - b.value)->oclAsType(int) := a, lambda (aa , b) : OclAny in (aa.value - b.value)->oclAsType(int)->sort() ; 
     OclFile["System.out"].println(a->at(0+1).idx + " " + a->at(a->size() - 1+1).idx) ) else     OclFile["System.out"].println(1 + " " + 1) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Security0812C {
  public static void main(String[] args){
    Scanner reader=new Scanner(System.in);
    while(reader.hasNextInt()){
      int[] nums1=new int[3];
      for(int i=0 ; i<3 ; i++){
        nums1[i]=reader.nextInt();
      }
      int[] nums2=new int[2];
      for(int i=0 ; i<2 ; i++){
        nums2[i]=reader.nextInt();
      }
      handle(nums1,nums2);
    }
  }
  private static void handle(int[] nums1,int[] nums2){
    int h1=nums1[0];
    int a1=nums1[1];
    int c1=nums1[2];
    int h2=nums2[0];
    int a2=nums2[1];
    List<String>res=new ArrayList<>();
    while(h2>0){
      if(h2-a1<=0){
        res.add("STRIKE");
        break ;
      }
      if(h1>a2){
        res.add("STRIKE");
        h1=h1-a2 ;
        h2=h2-a1 ;
      }
      else {
        res.add("HEAL");
        h1=h1+c1 ;
        h1=h1-a2 ;
      }
    }
    System.out.println(res.size());
    res.forEach(System.out :: println);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Security0812C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (reader.hasNextInt()) do (     var nums1 : Sequence(int) ; nums1 := Integer.subrange(1,3)->collect(0) ;
         var i : int ; i := 0 ; while i < 3 do ( (     nums1[i+1] := reader.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var nums2 : Sequence(int) ; nums2 := Integer.subrange(1,2)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 do ( (     nums2[i+1] := reader.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute handle(nums1, nums2) ; 
 ) );
  static   operation handle( nums1 : Sequence(int), nums2 : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var h1 : int ; h1 := nums1[0+1] ;
     var a1 : int ; a1 := nums1[1+1] ;
    var c1 : int ; c1 := nums1[2+1] ;
    var h2 : int ; h2 := nums2[0+1] ;
    var a2 : int ; a2 := nums2[1+1] ;
    var res : Sequence(String) ; res := Sequence{} ;
    while (h2 > 0) do (     if (h2 - a1 <= 0) then (     res := res->including("STRIKE") ; 
     break ) else skip ; 
     if (h1 > a2) then (     res := res->including("STRIKE") ; 
     h1 := h1 - a2 ; 
     h2 := h2 - a1 ) else (     res := res->including("HEAL") ; 
     h1 := h1 + c1 ; 
     h1 := h1 - a2 ) ) ; 
    OclFile["System.out"].println(res->size()) ; 
    for _forEach : res do
    (    skip ;) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static char[] alphabets="abcdefghijklmnopqrstuvwxyz".toCharArray();
  static String conversion(String charSet,char[] str1){
    String s2="" ;
    for(char i : str1)s2+=alphabets[charSet.indexOf(i)];
    return s2 ;
  }
  public static void main(String[] args){
    String charSet="qwertyuiopasdfghjklzxcvbnm" ;
    String str1="egrt" ;
    System.out.print(conversion(charSet,str1.toCharArray()));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute alphabets : Sequence(String) := "abcdefghijklmnopqrstuvwxyz"->characters();
  static   operation conversion( charSet : String, str1 : Sequence(String)) : String
  pre: true
  post: true
  activity: (     var s2 : String ; s2 := "" ;
     for (i : str1) do (     s2 := s2+(alphabets[charSet->indexOf(i)-1+1]) ;  ) ; 
     return s2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var charSet : String ; charSet := "qwertyuiopasdfghjklzxcvbnm" ;
     var str1 : String ; str1 := "egrt" ;
     OclFile["System.out"].print(conversion(charSet, str1->characters())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int customers=scanner.nextInt();
    ArrayList<ArrayList<Integer>>clients=new ArrayList<>();
    while(customers>0){
      ArrayList<Integer>tmp=new ArrayList<>();
      tmp.add(scanner.nextInt());
      tmp.add(scanner.nextInt());
      clients.add(tmp);
      customers--;
    }
    int cashes=0 ;
    int tmpCounter=1 ;
    for(int i=0 ; i+1<clients.size(); i++){
      int h=clients.get(i).get(0);
      int min=clients.get(i).get(1);
      int hNext=clients.get(i+1).get(0);
      int minNext=clients.get(i+1).get(1);
      if(h==hNext && min==minNext)tmpCounter++;
      else {
        if(tmpCounter>cashes)cashes=tmpCounter ;
        tmpCounter=1 ;
      }
    }
    if(tmpCounter>cashes)cashes=tmpCounter ;
    System.out.println(cashes);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var customers : int ; customers := scanner.getCurrent()->toInteger() ;
    var clients : Sequence(Sequence(int)) ; clients := Sequence{} ;
    while (customers > 0) do (     var tmp : Sequence(int) ; tmp := Sequence{} ;
     tmp := tmp->including(scanner.getCurrent()->toInteger()) ; 
    tmp := tmp->including(scanner.getCurrent()->toInteger()) ; 
    clients := clients->including(tmp) ; 
    customers := customers - 1 ; 
 ) ; 
    var cashes : int ; cashes := 0 ;
    var tmpCounter : int ; tmpCounter := 1 ;
        var i : int ; i := 0 ; while i + 1 < clients->size() do ( (     var h : int ; h := clients->at(i+1)->at(0+1) ;
     var min : int ; min := clients->at(i+1)->at(1+1) ;
    var hNext : int ; hNext := clients->at(i + 1+1)->at(0+1) ;
    var minNext : int ; minNext := clients->at(i + 1+1)->at(1+1) ;
    if (h = hNext & min = minNext) then     tmpCounter := tmpCounter + 1 else (     if (tmpCounter > cashes) then     cashes := tmpCounter ; else skip ; 
     tmpCounter := 1 ) ;  
 )  ;     i := i + 1 ) ; 
    if (tmpCounter > cashes) then     cashes := tmpCounter ; else skip ; 
    OclFile["System.out"].println(cashes) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Division {
  static int ilshatabuyNeTOP=1000000000 ;
  public static void main(String[] args)throws IOException {
    PrintWriter pw=new PrintWriter(System.out);
    int n=nextInt();
    int[] mas=new int[n];
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      mas[i]=nextInt();
      arr[i]=nextInt();
    }
    int count=1 ;
    int max=count ;
    for(int i=1 ; i<n ; i++){
      if(mas[i]==mas[i-1] && arr[i]==arr[i-1]){
        count++;
      }
      else {
        if(count>max){
          max=count ;
        }
        count=1 ;
      }
    }
    if(count>max){
      max=count ;
    }
    System.out.println(max);
  }
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter out=new PrintWriter(System.out);
  static StringTokenizer in=new StringTokenizer("");
  public static boolean hasNext()throws IOException {
    if(in.hasMoreTokens())return true ;
    String s ;
    while((s=br.readLine())!=null){
      in=new StringTokenizer(s);
      if(in.hasMoreTokens())return true ;
    }
    return false ;
  }
  public static String nextToken()throws IOException {
    while(! in.hasMoreTokens()){
      in=new StringTokenizer(br.readLine());
    }
    return in.nextToken();
  }
  public static int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public static double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  public static long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Division {
  static   attribute ilshatabuyNeTOP : int := 1000000000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var n : int ; n := nextInt() ;
    var mas : Sequence(int) ; mas := Integer.subrange(1,n)->collect(0) ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     mas[i+1] := nextInt() ; 
     arr[i+1] := nextInt() )  ;     i := i + 1 ) ; 
    var count : int ; count := 1 ;
    var max : int ; max := count ;
        var i : int ; i := 1 ; while i < n do ( (     if (mas[i+1] = mas[i - 1+1] & arr[i+1] = arr[i - 1+1]) then (     count := count + 1 ) else (     if (count > max) then (     max := count ) else skip ; 
     count := 1 ) )  ;     i := i + 1 ) ; 
    if (count > max) then (     max := count ) else skip ; 
    OclFile["System.out"].println(max) ; 
 );
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclIterator := OclIterator.newOclIterator_String("");
  static   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     if (in.hasNext()) then     return true else skip ; 
     var s : String ;
         s := br.readLine() ;
    while ((s) /= null) do (    skip ; (     in := OclIterator.newOclIterator_String(s) ; 
     if (in.hasNext()) then     return true else skip ) ;     s := br.readLine() ;
 ) ;  
     return false );
  static   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (not(in.hasNext())) do (     in := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return in.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int k=1 ;
    int n=scanner.nextInt();
    int localMax=0 ;
    int totalMax=0 ;
    int prevHours=scanner.nextInt();
    int prevMins=scanner.nextInt();
    for(int i=1 ; i<n ; i++){
      int currHours=scanner.nextInt();
      int currMins=scanner.nextInt();
      if(currHours==prevHours && currMins==prevMins){
        localMax++;
      }
      else {
        if(totalMax<localMax)totalMax=localMax ;
        localMax=0 ;
      }
      prevHours=currHours ;
      prevMins=currMins ;
    }
    k+=Math.max(totalMax,localMax);
    System.out.println(k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := 1 ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var localMax : int ; localMax := 0 ;
    var totalMax : int ; totalMax := 0 ;
    var prevHours : int ; prevHours := scanner.getCurrent()->toInteger() ;
    var prevMins : int ; prevMins := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i < n do ( (     var currHours : int ; currHours := scanner.getCurrent()->toInteger() ;
     var currMins : int ; currMins := scanner.getCurrent()->toInteger() ;
    if (currHours = prevHours & currMins = prevMins) then (     localMax := localMax + 1 ) else (     if (totalMax < localMax) then     totalMax := localMax ; else skip ; 
     localMax := 0 ) ;  
    prevHours := currHours ; 
    prevMins := currMins ; 
 )  ;     i := i + 1 ) ; 
    k := k+(Set{totalMax, localMax}->max()) ; 
    OclFile["System.out"].println(k) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B {
  static Scanner sc=null ;
  public static void main(String[] args){
    sc=new Scanner(System.in);
    int N=sc.nextInt();
    int mat[][]=new int[24][60];
    for(int i=0 ; i<24 ; i++)Arrays.fill(mat[i],0);
    for(int i=0 ; i<N ; i++){
      int n1=sc.nextInt();
      int n2=sc.nextInt();
      mat[n1][n2]+=1 ;
    }
    int res=0 ;
    for(int i=0 ; i<24 ; i++){
      for(int j=0 ; j<60 ; j++){
        res=Math.max(mat[i][j],res);
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute sc : OclFile := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var mat : Sequence(Sequence(int)) ; mat := Integer.subrange(1,24)->collect(Integer.subrange(1,60)->collect(0)) ;
        var i : int ; i := 0 ; while i < 24 do (     mat[i+1] := mat[i+1]->collect(0) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var n1 : int ; n1 := sc.getCurrent()->toInteger() ;
     var n2 : int ; n2 := sc.getCurrent()->toInteger() ;
     mat[n1+1][n2+1] := mat[n1+1][n2+1]+(1) )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < 24 do ( (         var j : int ; j := 0 ; while j < 60 do ( (     res := Set{mat[i+1][j+1], res}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class A696 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int Q=in.nextInt();
    Map<Long,Long>map=new HashMap<>();
    for(int q=0 ; q<Q ; q++){
      int type=in.nextInt();
      long u=in.nextLong();
      long v=in.nextLong();
      if(type==1){
        long cost=in.nextLong();
        while(u!=v){
          if(u<v){
            long temp=u ;
            u=v ;
            v=temp ;
          }
          long c=map.getOrDefault(u,0L);
          map.put(u,c+cost);
          u/=2 ;
        }
      }
      else {
        long answer=0 ;
        while(u!=v){
          if(u<v){
            long temp=u ;
            u=v ;
            v=temp ;
          }
          long c=map.getOrDefault(u,0L);
          answer+=c ;
          u/=2 ;
        }
        System.out.println(answer);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A696 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var Q : int ; Q := in.getCurrent()->toInteger() ;
     var map : Map(long,long) ; map := Map{} ;
         var q : int ; q := 0 ; while q < Q do ( (     var type : int ; type := in.getCurrent()->toInteger() ;
     var u : long ; u := in.getCurrent()->toLong() ;
     var v : long ; v := in.getCurrent()->toLong() ;
     if (type = 1) then (     var cost : long ; cost := in.getCurrent()->toLong() ;
     while (u /= v) do (     if (u < v) then (     var temp : long ; temp := u ;
     u := v ; 
     v := temp ) else skip ; 
     var c : long ; c := (if map->keys()->contains(u) then map->at(u) else 0L endif) ;
     map := map->union(Map{u |-> c + cost}) ; 
     u := u/(2) ) ) else (     var answer : long ; answer := 0 ;
     while (u /= v) do (     if (u < v) then (     var temp : long ; temp := u ;
     u := v ; 
     v := temp ) else skip ; 
     var c : long ; c := (if map->keys()->contains(u) then map->at(u) else 0L endif) ;
     answer := answer+(c) ; 
     u := u/(2) ) ; 
     OclFile["System.out"].println(answer) ) )  ;     q := q + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    Stack<Integer>a=new Stack<Integer>();
    int L=s.nextInt();
    for(int i=1 ; i<=L ; i++){
      int b=s.nextInt();
      if(b>0){
        if(a.search(b)!=-1){
          System.out.println(i);
          break ;
        }
        else {
          a.push(b);
        }
      }
      else {
        if(a.empty()||-b!=a.peek()){
          System.out.println(i);
          break ;
        }
        else {
          a.pop();
        }
      }
      if(i==L){
        System.out.println("OK");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Sequence{} ;
     var L : int ; L := s.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= L do ( (     var b : int ; b := s.getCurrent()->toInteger() ;
     if (b > 0) then (     if (a->reverse()->indexOf(b)-1 /= -1) then (     OclFile["System.out"].println(i) ; 
     break ) else (     a := a->append(b) ) ) else (     if (a->isEmpty() or -b /= a->min()) then (     OclFile["System.out"].println(i) ; 
     break ) else (     a := a->front() ) ) ;  
     if (i = L) then (     OclFile["System.out"].println("OK") ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    HashSet<Integer>inside=new HashSet<>();
    ArrayDeque<Integer>deq=new ArrayDeque<>();
    for(int i=1 ; i<=n ; i++){
      int x=sc.nextInt();
      if(x>0){
        if(inside.contains(x)){
          System.out.println(i);
          return ;
        }
        inside.add(x);
        deq.push(x);
      }
      else {
        x*=-1 ;
        if(deq.size()==0 || deq.pop()!=x){
          System.out.println(i);
          return ;
        }
        inside.remove(x);
      }
    }
    System.out.println("OK");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var inside : Set(int) ; inside := Set{} ;
    var deq : Sequence(int) ; deq := ArrayDeque<OclAny>.newArrayDeque() ;
        var i : int ; i := 1 ; while i <= n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x > 0) then (     if (inside->includes(x)) then (     OclFile["System.out"].println(i) ; 
     return ) else skip ; 
     inside := inside->including(x) ; 
     deq := deq->append(x) ) else (     x := x*(-1) ; 
     if (deq->size() = 0 or deq->last() /= x) then (     OclFile["System.out"].println(i) ; 
     return ) else skip ; 
     inside := inside->excludingAt(x+1) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("OK") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    Scanner sc=new Scanner(systemin);
    int L=sc.nextInt();
    int[] f=new int[100];
    List<Integer>list=new ArrayList<>();
    for(int i=0 ; ; i++){
      if(i>=L){
        result.printf("OK\n");
        break ;
      }
      int c=sc.nextInt();
      if(c>0){
        if(f[c-1]>0){
          result.printf("%d\n",i+1);
          break ;
        }
        list.add(c);
        f[c-1]=1 ;
      }
      else {
        int r=-1 ;
        if(list.size()>0)r=list.remove(list.size()-1);
        if(-c!=r){
          result.printf("%d\n",i+1);
          break ;
        }
        f[-c-1]=0 ;
      }
    }
    sc.close();
    return false ;
  }
  PrintStream log ;
  PrintStream result=System.out ;
  BufferedReader systemin ;
  static Main instance=new Main();
  Main(){
    systemin=new BufferedReader(new InputStreamReader(System.in));
    log=new PrintStream(new OutputStream(){
      public void write(int b){
      }
    }
);
  }
  public static void main(String[] args)throws IOException {
    instance.main();
    instance.systemin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(systemin) ;
     var L : int ; L := sc.getCurrent()->toInteger() ;
    var f : Sequence(int) ; f := Integer.subrange(1,100)->collect(0) ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while true do ( (     if (i >= L) then (     result.printf("OK\n") ; 
     break ) else skip ; 
     var c : int ; c := sc.getCurrent()->toInteger() ;
     if (c > 0) then (     if (f[c - 1+1] > 0) then (     result.printf("%d\n", i + 1) ; 
     break ) else skip ; 
     list := list->including(c) ; 
     f[c - 1+1] := 1 ) else (     var r : int ; r := -1 ;
     if (list->size() > 0) then     r := list->includes(list->size() - 1) ;     list := list->excludingFirst(list->size() - 1) ; else skip ; 
     if (-c /= r) then (     result.printf("%d\n", i + 1) ; 
     break ) else skip ; 
     f[-c - 1+1] := 0 ) )  ;     i := i + 1 ) ; 
    skip ; 
    return false 
 );
   attribute log : OclFile;
   attribute result : OclFile := OclFile["System.out"];
   attribute systemin : OclFile;
  static   attribute instance : Main := Main.newMain();
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     systemin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     log := OclFile.newOclFile_Write(OclFile()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     instance.main() ; 
     instance.systemin.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Stack<Integer>s=new Stack<Integer>(){
    };
    int L=sc.nextInt();
    for(int i=1 ; i<=L ; i++){
      int c=sc.nextInt();
      if(c>0){
        if(s.search(c)!=-1){
          System.out.println(i);
          break ;
        }
        else s.push(c);
      }
      else {
        if(s.empty()||(-c!=s.peek())){
          System.out.println(i);
          break ;
        }
        else s.pop();
      }
      if(i==L)System.out.println("OK");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(int) ; s := Sequence{}(classCreatorRest (arguments ( )) (classBody { })) ;
     var L : int ; L := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= L do ( (     var c : int ; c := sc.getCurrent()->toInteger() ;
     if (c > 0) then (     if (s->reverse()->indexOf(c)-1 /= -1) then (     OclFile["System.out"].println(i) ; 
     break ) else     s := s->append(c) ; ) else (     if (s->isEmpty() or (-c /= s->min())) then (     OclFile["System.out"].println(i) ; 
     break ) else     s := s->front() ; ) ;  
     if (i = L) then     OclFile["System.out"].println("OK") ; else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  static TreeSet<Integer>set=new TreeSet<Integer>();
  public static void generateNumber(int count,int a[],int n,int num,int k){
    if(count==k){
      set.add(num);
      return ;
    }
    for(int i=0 ; i<n ; i++)generateNumber(count+1,a,n,num+a[i],k);
  }
  public static void printDistinctIntegers(int k,int a[],int n){
    generateNumber(0,a,n,0,k);
    System.out.print("The"+" "+set.size()+" "+"distinct integers are: ");
    System.out.println();
    Iterator<Integer>i=set.iterator();
    while(set.isEmpty()==false){
      while(i.hasNext()){
        System.out.print(i.next()+" ");
      }
    }
  }
  public static void main(String[] args){
    int arr[]={
      3,8,17,5 };
      int n=arr.length ;
      int k=2 ;
      printDistinctIntegers(k,arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute set : Set(int) := Set{};
  static   operation generateNumber( count : int, a : Sequence(int), n : int, num : int, k : int) : void
  pre: true
  post: true
  activity: (     if (count = k) then (     set := set->including(num) ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < n do (     execute generateNumber(count + 1, a, n, num + a[i+1], k) ;  ;     i := i + 1 ) );
  static   operation printDistinctIntegers( k : int, a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     execute generateNumber(0, a, n, 0, k) ; 
     OclFile["System.out"].print("The" + " " + set->size() + " " + "distinct integers are: ") ; 
    OclFile["System.out"].println() ; 
    var i : OclIterator ; i := set->iterator() ;
    while (set->isEmpty() = false) do (     while (i.hasNext()) do (     OclFile["System.out"].print(i.next() + " ") ) ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,8,17,5} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     execute printDistinctIntegers(k, arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class3 {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int pre[]=new int[2005];
      int n=sc.nextInt();
      for(int i=1 ; i<=n ; i++){
        int a=sc.nextInt();
        pre[i]=(pre[i-1] ^ a);
      }
      boolean yes=false ;
      if(pre[n]==0)yes=true ;
      for(int i=1 ; i<=n ; i++){
        for(int j=i+1 ; j<n ; j++)yes |=(pre[i]==(pre[j] ^ pre[i])&& pre[i]==(pre[n] ^ pre[j]));
      }
      if(yes)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class3 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var pre : Sequence(int) ; pre := Integer.subrange(1,2005)->collect(0) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     pre[i+1] := (pre[i - 1+1] xor a) )  ;     i := i + 1 ) ; 
    var yes : boolean ; yes := false ;
    if (pre[n+1] = 0) then     yes := true ; else skip ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i + 1 ; while j < n do (     yes := MathLib.bitwiseOr(yes, (pre[i+1] = (pre[j+1] xor pre[i+1]) & pre[i+1] = (pre[n+1] xor pre[j+1]))) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (yes) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    double a=scanner.nextDouble();
    double b=scanner.nextDouble();
    double n=scanner.nextDouble();
    double x=0.0 ;
    if(b<=n){
      x=b-1.0 ;
    }
    else {
      x=n ;
    }
    System.out.println((int)(Math.floor(a*x/b)-a*Math.floor(x/b)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : double ; a := scanner.getCurrent()->toReal() ;
    var b : double ; b := scanner.getCurrent()->toReal() ;
    var n : double ; n := scanner.getCurrent()->toReal() ;
    var x : double ; x := 0.0 ;
    if (b <= n) then (     x := b - 1.0 ) else (     x := n ) ;  
    OclFile["System.out"].println(((a * x / b)->floor() - a * (x / b)->floor())->oclAsType(int)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static final MyScanner in=new MyScanner();
  public static void main(String[] args){
    double A=in.nextLong();
    double B=in.nextLong();
    double N=in.nextLong();
    double x=-1 ;
    if(N<B){
      x=N ;
    }
    else {
      x=B-1 ;
    }
    System.out.println((long)(Math.floor(A*x/B)-(A*Math.floor(x/B))));
  }
  public static class Obj implements Comparable<Obj>{
    int a ;
    int b ;
    int c ;
    int d ;
    @ Override public int compareTo(Obj o){
      return Integer.compare(this.a,o.a);
    }
  }
  public static class MyScanner {
    Scanner sc=new Scanner(System.in);
    String next(){
      return sc.next();
    }
    int nextInt(){
      return Integer.valueOf(sc.next());
    }
    long nextLong(){
      return Long.valueOf(sc.next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : MyScanner := MyScanner.newMyScanner();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : double ; A := in.nextLong() ;
     var B : double ; B := in.nextLong() ;
    var N : double ; N := in.nextLong() ;
    var x : double ; x := -1 ;
    if (N < B) then (     x := N ) else (     x := B - 1 ) ;  
    OclFile["System.out"].println(((A * x / B)->floor() - (A * (x / B)->floor()))->oclAsType(long)) ; 
 );
  static class Obj implements Comparable<Obj> {
   attribute a : int;
   attribute b : int;
   attribute c : int;
   attribute d : int;
      operation compareTo( o : Obj) : int
  pre: true
  post: true
  activity: (     return compare(self.a, o.a) );
}
  static class MyScanner {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation next() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (sc.getCurrent())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (sc.getCurrent())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str[]=br.readLine().split(" ");
    long a=Long.parseLong(str[0]);
    long b=Long.parseLong(str[1]);
    long n=Long.parseLong(str[2]);
    long x=Math.min(b-1,n);
    System.out.println((a*x)/b-a*(x/b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var a : long ; a := (str[0+1])->toLong() ;
    var b : long ; b := (str[1+1])->toLong() ;
    var n : long ; n := (str[2+1])->toLong() ;
    var x : long ; x := Set{b - 1, n}->min() ;
    OclFile["System.out"].println((a * x) / b - a * (x / b)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    double A=stdIn.nextDouble();
    double B=stdIn.nextDouble();
    long N=stdIn.nextLong();
    long max=0 ;
    for(long i=(long)B-1 ; i<N ; i+=(long)B){
      if(max<sub(A,B,i)){
        max=sub(A,B,i);
      }
      else {
        break ;
      }
    }
    max=Math.max(max,sub(A,B,N));
    System.out.println(max);
  }
  public static long sub(double A,double B,long x){
    long ret=(long)(Math.floor(A*x/B)-A*Math.floor(x/B));
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : double ; A := stdIn.getCurrent()->toReal() ;
    var B : double ; B := stdIn.getCurrent()->toReal() ;
    var N : long ; N := stdIn.getCurrent()->toLong() ;
    var max : long ; max := 0 ;
        var i : long ; i := B->oclAsType(long) - 1 ; while i < N do ( (     if (max < sub(A, B, i)) then (     max := sub(A, B, i) ) else (     break ) )  ;     i := i+(B->oclAsType(long)) ) ; 
    max := Set{max, sub(A, B, N)}->max() ; 
    OclFile["System.out"].println(max) ; 
 );
  static   operation sub( A : double, B : double, x : long) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := ((A * x / B)->floor() - A * (x / B)->floor())->oclAsType(long) ;
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.ArrayList ;
import java.util.Collections ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long A=sc.nextLong();
    long B=sc.nextLong();
    long N=sc.nextLong();
    long x ;
    if(N<B){
      x=N ;
    }
    else {
      x=B-1 ;
    }
    long ans=A*x/B-A*(x/B);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : long ; A := sc.getCurrent()->toLong() ;
    var B : long ; B := sc.getCurrent()->toLong() ;
    var N : long ; N := sc.getCurrent()->toLong() ;
    var x : long ;
    if (N < B) then (     x := N ) else (     x := B - 1 ) ;  
    var ans : long ; ans := A * x / B - A * (x / B) ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    PresentfromLena();
  }
  public static void PresentfromLena(){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    for(int i=0 ; i<=n ; i++){
      for(int j=n,x=-1 ; j>=0 ; j--){
        if(i>=j){
          int t=++x ;
          if(i==0 && t==0){
            System.out.print("0");
          }
          else {
            System.out.print(t+" ");
          }
        }
        else System.out.print("  ");
      }
      for(int j=0,x=i ; j<n ; j++){
        if(i>j){
          int t=--x ;
          if(t==0){
            System.out.print(0);
          }
          else {
            System.out.print(t+" ");
          }
        }
      }
      System.out.println();
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0,x=-1 ; j<=n ; j++){
        if(j>i){
          int t=++x ;
          if(i==n-1 && t==0){
            System.out.print("0");
          }
          else {
            System.out.print(t+" ");
          }
        }
        else System.out.print("  ");
      }
      for(int j=n-1,x=n-i-1 ; j>0 ; j--){
        if(j>i){
          int t=--x ;
          if(t==0){
            System.out.print(0);
          }
          else {
            System.out.print(t+" ");
          }
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute PresentfromLena() );
  static   operation PresentfromLena() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i <= n do ( (         var j : int ; j := n ;
    var x : int ; x := -1 ; while j >= 0 do ( (     if (i >= j) then (     var t : int ;     x := x + 1 ;
t := x ;
     if (i = 0 & t = 0) then (     OclFile["System.out"].print("0") ) else (     OclFile["System.out"].print(t + " ") ) ) else     OclFile["System.out"].print("  ") ; )  ;     j := j - 1 ) ; 
         var j : int ; j := 0 ;
    var x : int ; x := i ; while j < n do ( (     if (i > j) then (     var t : int ;     x := x - 1 ;
t := x ;
     if (t = 0) then (     OclFile["System.out"].print(0) ) else (     OclFile["System.out"].print(t + " ") ) ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ;
    var x : int ; x := -1 ; while j <= n do ( (     if (j > i) then (     var t : int ;     x := x + 1 ;
t := x ;
     if (i = n - 1 & t = 0) then (     OclFile["System.out"].print("0") ) else (     OclFile["System.out"].print(t + " ") ) ) else     OclFile["System.out"].print("  ") ; )  ;     j := j + 1 ) ; 
         var j : int ; j := n - 1 ;
    var x : int ; x := n - i - 1 ; while j > 0 do ( (     if (j > i) then (     var t : int ;     x := x - 1 ;
t := x ;
     if (t = 0) then (     OclFile["System.out"].print(0) ) else (     OclFile["System.out"].print(t + " ") ) ) else skip )  ;     j := j - 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int row=-n ; row<=n ; ++row){
      int top=n-Math.abs(row);
      for(int i=0 ; i<Math.abs(row); ++i){
        System.out.print("  ");
      }
      for(int i=0 ; i<top ; ++i){
        System.out.print(i+" ");
      }
      for(int i=top ; i>0 ; --i){
        System.out.print(i+" ");
      }
      System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var row : int ; row := -n ; while row <= n do ( (     var top : int ; top := n - if row < 0 then -(row) else row endif ;
         var i : int ; i := 0 ; while i < if row < 0 then -(row) else row endif do ( (     OclFile["System.out"].print("  ") )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < top do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i + 1 ) ; 
        var i : int ; i := top ; while i > 0 do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(0) ; 
 )  ;     row := row + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF118B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    String[] s=new String[N+1];
    for(int i=0 ; i<=N ; i++){
      s[i]=""+i ;
      for(int j=i-1 ; j>=0 ; j--){
        s[i]=j+" "+s[i]+" "+j ;
      }
      for(int j=0 ; j<N-i ; j++){
        s[i]="  "+s[i];
      }
      System.out.println(s[i]);
    }
    for(int i=N-1 ; i>=0 ; i--){
      System.out.println(s[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF118B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := Integer.subrange(1,N + 1)->collect(null) ;
        var i : int ; i := 0 ; while i <= N do ( (     s[i+1] := "" + i ; 
         var j : int ; j := i - 1 ; while j >= 0 do ( (     s[i+1] := j + " " + s[i+1] + " " + j )  ;     j := j - 1 ) ; 
         var j : int ; j := 0 ; while j < N - i do ( (     s[i+1] := "  " + s[i+1] )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(s[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := N - 1 ; while i >= 0 do ( (     OclFile["System.out"].println(s[i+1]) )  ;     i := i - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int X=sc.nextInt();
    int a[]=new int[N];
    int b=N ;
    int c=1000 ;
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextInt();
      X=X-a[i];
      if(a[i]<c){
        c=a[i];
      }
    }
    b=b+X/c ;
    System.out.println(b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var X : int ; X := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var b : int ; b := N ;
    var c : int ; c := 1000 ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     X := X - a[i+1] ; 
     if (a[i+1] < c) then (     c := a[i+1] ) else skip )  ;     i := i + 1 ) ; 
    b := b + X / c ; 
    OclFile["System.out"].println(b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.*;
public class teest extends PrintWriter {
  teest(){
    super(System.out);
  }
  public static void main(String[] $)throws IOException {
    teest o=new teest();
    o.main();
    o.flush();
  }
  void main()throws IOException {
    Scanner a=new Scanner(System.in);
    int t=a.nextInt();
    while(t>0){
      int n=a.nextInt(),k=a.nextInt();
      if(n % 2!=k % 2 || n/k<k)System.out.println("NO");
      else System.out.println("YES");
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class teest extends OclFile {
   static operation newteest() : teest
  pre: true
  post: true
  activity:
  ( var self : teest ;
    self := createteest();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"]) );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : teest ; o := teest.newteest() ;
     o.main() ; 
     o.flush() );
   operation main() : void
  pre: true
  post: true
  activity: (     var a : OclFile ; a := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := a.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := a.getCurrent()->toInteger() ;
    var k : int ; k := a.getCurrent()->toInteger() ;
     if (n mod 2 /= k mod 2 or n / k < k) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  
     t := t - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import sun.font.TrueTypeFont ;
import static java.lang.System.out ;
public class Main {
  public static Scanner sc=new Scanner(System.in);
  public static void main(String args[]){
    int N=sc.nextInt();
    int gram=sc.nextInt();
    int[] array=new int[N];
    int count=N ;
    int cost=0 ;
    for(int i=0 ; i<N ; i++){
      array[i]=sc.nextInt();
    }
    Arrays.sort(array);
    for(int make : array){
      cost+=make ;
    }
    int row=array[0];
    while(row+cost<=gram){
      cost+=row ;
      count++;
    }
    out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var gram : int ; gram := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,N)->collect(0) ;
    var count : int ; count := N ;
    var cost : int ; cost := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     array[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    array := array->sort() ; 
    for (make : array) do ( (     cost := cost+(make) )  ) ; 
    var row : int ; row := array[0+1] ;
    while (row + cost <= gram) do (     cost := cost+(row) ; 
     count := count + 1 ) ; 
    out.println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; ++i){
        a[i]=sc.nextInt();
      }
      System.out.println(solve(a)? "YES" : "NO");
    }
    sc.close();
  }
  static boolean solve(int[] a){
    int xor=Arrays.stream(a).reduce((x,y)->x ^ y).getAsInt();
    if(xor==0){
      return true ;
    }
    int part=0 ;
    int count=0 ;
    for(int ai : a){
      part ^=ai ;
      if(part==xor){
        part=0 ;
++count ;
      }
    }
    return count>=2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if solve(a) then "YES" else "NO" endif) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var xor : int ; xor := stream(a)->iterate( _var; _acc : OclAny | lambda (x , y) : OclAny in x xor y->apply((_acc,_var)) ).getAsInt() ;
     if (xor = 0) then (     return true ) else skip ; 
    var part : int ; part := 0 ;
    var count : int ; count := 0 ;
    for (ai : a) do ( (     part := MathLib.bitwiseXor(part,ai) ; 
     if (part = xor) then (     part := 0 ; 
     count := count + 1 ) else skip )  ) ; 
    return count >= 2 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] tmp=br.readLine().split(" ");
    int N=Integer.parseInt(tmp[0]);
    int X=Integer.parseInt(tmp[1]);
    List<Integer>m=new ArrayList<Integer>();
    int oneDo=0 ;
    for(int n=0 ; n<N ; n++){
      m.add(Integer.parseInt(br.readLine()));
      oneDo+=m.get(n);
    }
    X-=oneDo ;
    int count=N ;
    m.sort(null);
    int min=m.get(0);
    while(X>=min){
      X-=min ;
      count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmp : Sequence(String) ; tmp := br.readLine()->split(" ") ;
    var N : int ; N := (tmp[0+1])->toInteger() ;
    var X : int ; X := (tmp[1+1])->toInteger() ;
    var m : Sequence(int) ; m := Sequence{} ;
    var oneDo : int ; oneDo := 0 ;
        var n : int ; n := 0 ; while n < N do ( (     m := m->including((br.readLine())->toInteger()) ; 
     oneDo := oneDo+(m->at(n+1)) )  ;     n := n + 1 ) ; 
    X := X-(oneDo) ; 
    var count : int ; count := N ;
    m := m.sort(null) ; 
    var min : int ; min := m->at(0+1) ;
    while (X >= min) do (     X := X-(min) ; 
     count := count + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int count=0 ;
    int N=scanner.nextInt();
    int X=scanner.nextInt();
    ArrayList<Integer>list=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      int m=scanner.nextInt();
      list.add(m);
      X-=m ;
    }
    Collections.sort(list);
    int min=list.get(0);
    for(int x=0 ; x<=X/min ; x++){
      count=x ;
      if(min*x>X){
        break ;
      }
    }
    count+=N ;
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := 0 ;
    var N : int ; N := scanner.getCurrent()->toInteger() ;
    var X : int ; X := scanner.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var m : int ; m := scanner.getCurrent()->toInteger() ;
     list := list->including(m) ; 
     X := X-(m) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var min : int ; min := list->at(0+1) ;
        var x : int ; x := 0 ; while x <= X / min do ( (     count := x ; 
     if (min * x > X) then (     break ) else skip )  ;     x := x + 1 ) ; 
    count := count+(N) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in),1);
    String s=r.readLine();
    String[] sl=s.split("[\\s]+");
    int n=Integer.parseInt(sl[0]);
    int x=Integer.parseInt(sl[1]);
    int min=999999 ;
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      int z=Integer.parseInt(r.readLine());
      sum+=z ;
      min=Math.min(min,z);
    }
    System.out.println(n+(x-sum)/min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 1) ;
     var s : String ; s := r.readLine() ;
    var sl : Sequence(String) ; sl := s->split("[\\s]+") ;
    var n : int ; n := (sl[0+1])->toInteger() ;
    var x : int ; x := (sl[1+1])->toInteger() ;
    var min : int ; min := 999999 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var z : int ; z := (r.readLine())->toInteger() ;
     sum := sum+(z) ; 
     min := Set{min, z}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n + (x - sum) / min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    char[] s=in.next().toCharArray();
    boolean delete=false ;
    for(int i=0 ; i<n-1 ; i++){
      if(s[i]>s[i+1] && ! delete){
        s[i]='1' ;
        delete=true ;
      }
    }
    if(! delete)s[n-1]='1' ;
    for(char c : s){
      if(c=='1')continue ;
      pw.print(c);
    }
    pw.println();
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := in.getCurrent()->characters() ;
    var delete : boolean ; delete := false ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (s[i+1] > s[i + 1+1] & not(delete)) then (     s[i+1] := '1' ; 
     delete := true ) else skip )  ;     i := i + 1 ) ; 
    if (not(delete)) then     s[n - 1+1] := '1' ; else skip ; 
    for (c : s) do ( (     if (c = '1') then     continue else skip ; 
     skip )  ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int T=sc.nextInt();
    String str=sc.next();
    for(int i=1 ; i<str.length(); i++){
      if(str.charAt(i-1)>str.charAt(i)){
        str=str.substring(0,i-1)+str.substring(i,str.length());
        break ;
      }
    }
    if(T==1){
      System.out.println(str);
    }
    else if(T==str.length()){
      str=str.substring(0,T-1);
      System.out.println(str);
    }
    else {
      System.out.println(str);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var T : int ; T := sc.nextInt() ;
    var str : String ; str := sc.next() ;
        var i : int ; i := 1 ; while i < str->size() do ( (     if (str->at((i)->char2byte() - 1+1) > str->at(i+1)) then (     str := str.subrange(0+1,(i)->char2byte() - 1) + str.subrange(i+1,str->size()) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (T = 1) then (     OclFile["System.out"].println(str) ) else     if (T = str->size()) then (     str := str.subrange(0+1,T - 1) ; 
     OclFile["System.out"].println(str) ) else (     OclFile["System.out"].println(str) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int totalDigits(int n){
    int number_of_digits=0 ;
    for(int i=1 ; i<=n ; i*=10)number_of_digits+=(n-i+1);
    return number_of_digits ;
  }
  public static void main(String[] args){
    int n=13 ;
    System.out.println(totalDigits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation totalDigits( n : int) : int
  pre: true
  post: true
  activity: (     var number_of_digits : int ; number_of_digits := 0 ;
         var i : int ; i := 1 ; while i <= n do (     number_of_digits := number_of_digits+((n - i + 1)) ;  ;     i := i*(10) ) ; 
     return number_of_digits );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 13 ;
     OclFile["System.out"].println(totalDigits(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void descOrder(char[] s){
    Arrays.sort(s);
    reverse(s);
  }
  static void reverse(char[] a){
    int i,n=a.length ;
    char t ;
    for(i=0 ; i<n/2 ; i++){
      t=a[i];
      a[i]=a[n-i-1];
      a[n-i-1]=t ;
    }
  }
  public static void main(String[] args){
    char[] s="geeksforgeeks".toCharArray();
    descOrder(s);
    System.out.println(String.valueOf(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation descOrder( s : Sequence(String)) : void
  pre: true
  post: true
  activity: (     s := s->sort() ; 
     execute reverse(s) );
  static   operation reverse( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var n : int ; n := a->size() ;
     var t : String ;
         i := 0 ; while i < n / 2 do ( (     t := a[i+1] ; 
     a[i+1] := a[n - i - 1+1] ; 
     a[n - i - 1+1] := t )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := "geeksforgeeks"->characters() ;
     execute descOrder(s) ; 
     OclFile["System.out"].println((s)->sum() ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int N=parseInt(br.readLine());
    int[] c=new int[N+1];
    int[] a=new int[N+1];
    StringTokenizer st=new StringTokenizer(br.readLine());
    for(int i=1 ; i<=N ; i++){
      c[i]=parseInt(st.nextToken());
    }
    int Q=parseInt(br.readLine());
    int ans=0 ;
    for(int i=0 ; i<Q ; i++){
      st=new StringTokenizer(br.readLine());
      int t=parseInt(st.nextToken());
      int x=parseInt(st.nextToken());
      int d=parseInt(st.nextToken());
      if(t==1){
        a[x]+=d ;
      }
      else {
        a[x]-=d ;
      }
      if(a[x]<0 || a[x]>c[x]){
        ans=x ;
        break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var N : int ; N := parseInt(br.readLine()) ;
    var c : Sequence(int) ; c := Integer.subrange(1,N + 1)->collect(0) ;
    var a : Sequence(int) ; a := Integer.subrange(1,N + 1)->collect(0) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 1 ; while i <= N do ( (     c[i+1] := (st.next() + "")->toInteger() )  ;     i := i + 1 ) ; 
    var Q : int ; Q := parseInt(br.readLine()) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < Q do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var t : int ; t := parseInt(st.next()) ;
    var x : int ; x := parseInt(st.next()) ;
    var d : int ; d := parseInt(st.next()) ;
    if (t = 1) then (     a[x+1] := a[x+1]+(d) ) else (     a[x+1] := a[x+1]-(d) ) ;  
    if (a[x+1] < 0 or a[x+1] > c[x+1]) then (     ans := x ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int product(int x){
    int prod=1 ;
    while(x>0){
      prod*=(x % 10);
      x/=10 ;
    }
    return prod ;
  }
  static int findNumber(int l,int r){
    String b=Integer.toString(r);
    int ans=r ;
    for(int i=0 ; i<b.length(); i++){
      if(b.charAt(i)=='0')continue ;
      char[] curr=b.toCharArray();
      curr[i]=(char)(((int)(curr[i]-(int)'0')-1)+(int)('0'));
      for(int j=i+1 ; j<curr.length ; j++)curr[j]='9' ;
      int num=0 ;
      for(int j=0 ; j<curr.length ; j++)num=num*10+(curr[j]-'0');
      if(num>=l && product(ans)<product(num))ans=num ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int l=1,r=10 ;
    System.out.println(findNumber(l,r));
    l=51 ;
    r=62 ;
    System.out.println(findNumber(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation product( x : int) : int
  pre: true
  post: true
  activity: (     var prod : int ; prod := 1 ;
     while (x > 0) do (     prod := prod*((x mod 10)) ; 
     x := x/(10) ) ; 
     return prod );
  static   operation findNumber( l : int, r : int) : int
  pre: true
  post: true
  activity: (     var b : String ; b := ((r) + "") ;
     var ans : int ; ans := r ;
         var i : int ; i := 0 ; while i < b->size() do ( (     if (b->at(i+1) = '0') then     continue else skip ; 
     var curr : Sequence(String) ; curr := b->characters() ;
    curr[i+1] := (((curr[i+1] - ('0')->char2byte())->oclAsType(int) - 1) + ('0')->oclAsType(int))->oclAsType(String) ; 
        var j : int ; j := i + 1 ; while j < curr->size() do (     curr[j+1] := '9' ;  ;     j := j + 1 ) ; 
    var num : int ; num := 0 ;
        var j : int ; j := 0 ; while j < curr->size() do (     num := num * 10 + (curr[j+1] - ('0')->char2byte()) ;  ;     j := j + 1 ) ; 
    if (num >= l & product(ans) < product(num)) then     ans := num ; else skip ; 
 )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 1 ;
    var r : int ; r := 10 ;
     OclFile["System.out"].println(findNumber(l, r)) ; 
    l := 51 ; 
    r := 62 ; 
    OclFile["System.out"].println(findNumber(l, r)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int[] capacityBox=new int[n];
    int[] amountEach=new int[n];
    boolean isPossible=true ;
    Arrays.fill(amountEach,0);
    for(int i=0 ; i<n ; i++){
      capacityBox[i]=scanner.nextInt();
    }
    int numberInstructions=scanner.nextInt();
    for(int i=0 ; i<numberInstructions ; i++){
      int t=scanner.nextInt();
      int x=scanner.nextInt();
      int d=scanner.nextInt();
      if(t==1){
        amountEach[x-1]+=d ;
      }
      else {
        amountEach[x-1]-=d ;
      }
      if(amountEach[x-1]>capacityBox[x-1] || amountEach[x-1]<0){
        isPossible=false ;
        System.out.println(x);
        break ;
      }
    }
    if(isPossible){
      System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var capacityBox : Sequence(int) ; capacityBox := Integer.subrange(1,n)->collect(0) ;
    var amountEach : Sequence(int) ; amountEach := Integer.subrange(1,n)->collect(0) ;
    var isPossible : boolean ; isPossible := true ;
    amountEach := amountEach->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     capacityBox[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var numberInstructions : int ; numberInstructions := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < numberInstructions do ( (     var t : int ; t := scanner.getCurrent()->toInteger() ;
     var x : int ; x := scanner.getCurrent()->toInteger() ;
    var d : int ; d := scanner.getCurrent()->toInteger() ;
    if (t = 1) then (     amountEach[x - 1+1] := amountEach[x - 1+1]+(d) ) else (     amountEach[x - 1+1] := amountEach[x - 1+1]-(d) ) ;  
    if (amountEach[x - 1+1] > capacityBox[x - 1+1] or amountEach[x - 1+1] < 0) then (     isPossible := false ; 
     OclFile["System.out"].println(x) ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (isPossible) then (     OclFile["System.out"].println(0) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] boxes=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      boxes[i]=sc.nextInt();
    }
    int q=sc.nextInt();
    int[] contents=new int[n+1];
    for(int i=0 ; i<q ; i++){
      int type=sc.nextInt();
      int apple=sc.nextInt();
      int count=sc.nextInt();
      if(type==1){
        contents[apple]+=count ;
        if(contents[apple]>boxes[apple]){
          System.out.println(apple);
          return ;
        }
      }
      else if(type==2){
        contents[apple]-=count ;
        if(contents[apple]<0){
          System.out.println(apple);
          return ;
        }
      }
    }
    System.out.println(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var boxes : Sequence(int) ; boxes := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     boxes[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var contents : Sequence(int) ; contents := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < q do ( (     var type : int ; type := sc.getCurrent()->toInteger() ;
     var apple : int ; apple := sc.getCurrent()->toInteger() ;
     var count : int ; count := sc.getCurrent()->toInteger() ;
     if (type = 1) then (     contents[apple+1] := contents[apple+1]+(count) ; 
     if (contents[apple+1] > boxes[apple+1]) then (     OclFile["System.out"].println(apple) ; 
     return ) else skip ) else     if (type = 2) then (     contents[apple+1] := contents[apple+1]-(count) ; 
     if (contents[apple+1] < 0) then (     OclFile["System.out"].println(apple) ; 
     return ) else skip ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  Scanner sc=new Scanner(in);
  void run(){
    int[][] cost=new int[100][100];
    int INF=Integer.MAX_VALUE/3 ;
    while(true){
      int n=sc.nextInt(),m=sc.nextInt(),s=sc.nextInt()-1,g1=sc.nextInt()-1,g2=sc.nextInt()-1 ;
      if(n==0)break ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++)cost[i][j]=INF ;
        cost[i][i]=0 ;
      }
      for(int i=0 ; i<m ; i++){
        int b1=sc.nextInt()-1,b2=sc.nextInt()-1,c=sc.nextInt();
        cost[b1][b2]=c ;
      }
      for(int k=0 ; k<n ; k++)for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)cost[i][j]=min(cost[i][j],cost[i][k]+cost[k][j]);
      int res=INF ;
      for(int i=0 ; i<n ; i++){
        res=min(res,cost[s][i]+cost[i][g1]+cost[i][g2]);
      }
      out.println(res);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   operation run() : void
  pre: true
  post: true
  activity: (     var cost : Sequence(Sequence(int)) ; cost := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(0)) ;
     var INF : int ; INF := 2147483647 / 3 ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() - 1 ;
    var g1 : int ; g1 := sc.getCurrent()->toInteger() - 1 ;
    var g2 : int ; g2 := sc.getCurrent()->toInteger() - 1 ;
     if (n = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do (     cost[i+1][j+1] := INF ;  ;     j := j + 1 ) ; 
     cost[i+1][i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var b1 : int ; b1 := sc.getCurrent()->toInteger() - 1 ;
    var b2 : int ; b2 := sc.getCurrent()->toInteger() - 1 ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
     cost[b1+1][b2+1] := c )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < n do (         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (     cost[i+1][j+1] := Set{cost[i+1][j+1], cost[i+1][k+1] + cost[k+1][j+1]}->min() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ;  ;     k := k + 1 ) ; 
    var res : int ; res := INF ;
        var i : int ; i := 0 ; while i < n do ( (     res := Set{res, cost[s+1][i+1] + cost[i+1][g1+1] + cost[i+1][g2+1]}->min() )  ;     i := i + 1 ) ; 
    out.println(res) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class C {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int t=in.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      int n=in.nextInt();
      int[] a=new int[n];
      Arrays.setAll(a,i->in.nextInt());
      if(solve(a,n))pw.println("YES");
      else pw.println("NO");
    }
    pw.close();
  }
  static boolean solve(int[] a,int n){
    if(n==2 && a[0]==a[1])return true ;
    if(n==2)return false ;
    int[] pref=new int[n];
    pref[0]=a[0];
    for(int i=1 ; i<n ; i++){
      pref[i]=pref[i-1] ^ a[i];
    }
    if(twice(pref,n)|| threeSeg(pref,n))return true ;
    return false ;
  }
  static boolean twice(int[] pref,int n){
    for(int i=1 ; i<n ; i++){
      if(pref[i-1]==(pref[n-1] ^ pref[i-1]))return true ;
    }
    return false ;
  }
  static boolean threeSeg(int[] pref,int n){
    for(int i=0 ; i<n ; i++){
      int xor=pref[i];
      for(int j=i+1 ; j<n ; j++){
        int xor2=pref[j] ^ pref[n-1];
        int xor3=pref[i] ^ pref[j];
        if(xor==xor2 && xor==xor3)return true ;
      }
    }
    return false ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        var tt : int ; tt := 0 ; while tt < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
 setAll(a, lambda i : OclAny in in.getCurrent()->toInteger()) ; 
     if (solve(a, n)) then     skip ; else     skip ; )  ;     tt := tt + 1 ) ; 
    skip ; 
 );
  static   operation solve( a : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 2 & a[0+1] = a[1+1]) then     return true else skip ; 
     if (n = 2) then     return false else skip ; 
    var pref : Sequence(int) ; pref := Integer.subrange(1,n)->collect(0) ;
    pref[0+1] := a[0+1] ; 
        var i : int ; i := 1 ; while i < n do ( (     pref[i+1] := pref[i - 1+1] xor a[i+1] )  ;     i := i + 1 ) ; 
    if (twice(pref, n) or threeSeg(pref, n)) then     return true else skip ; 
    return false 
 );
  static   operation twice( pref : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < n do ( (     if (pref[i - 1+1] = (pref[n - 1+1] xor pref[i - 1+1])) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation threeSeg( pref : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var xor : int ; xor := pref[i+1] ;
         var j : int ; j := i + 1 ; while j < n do ( (     var xor2 : int ; xor2 := MathLib.bitwiseXor(pref[j+1],pref[n - 1+1]) ;
     var xor3 : int ; xor3 := MathLib.bitwiseXor(pref[i+1],pref[j+1]) ;
     if (xor = xor2 & xor = xor3) then     return true else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return false );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int countBox=Integer.valueOf(sc.nextLine());
    String[] arrBoxCap=sc.nextLine().split(" ");
    int countInstruction=Integer.valueOf(sc.nextLine());
    int[] boxes=new int[countBox];
    for(int i=0 ; i<countInstruction ; i++){
      String[] instruction=sc.nextLine().split(" ");
      int iBox=Integer.valueOf(instruction[1])-1 ;
      int apple=Integer.valueOf(instruction[2]);
      if(instruction[0] .equals("1")){
        boxes[iBox]+=apple ;
      }
      else {
        boxes[iBox]-=apple ;
      }
      if(boxes[iBox]>Integer.valueOf(arrBoxCap[iBox])|| boxes[iBox]<0){
        System.out.println(iBox+1);
        return ;
      }
    }
    System.out.println("0");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var countBox : int ; countBox := (sc.nextLine())->toInteger() ;
    var arrBoxCap : Sequence(String) ; arrBoxCap := sc.nextLine()->split(" ") ;
    var countInstruction : int ; countInstruction := (sc.nextLine())->toInteger() ;
    var boxes : Sequence(int) ; boxes := Integer.subrange(1,countBox)->collect(0) ;
        var i : int ; i := 0 ; while i < countInstruction do ( (     var instruction : Sequence(String) ; instruction := sc.nextLine()->split(" ") ;
     var iBox : int ; iBox := (instruction[1+1])->toInteger() - 1 ;
    var apple : int ; apple := (instruction[2+1])->toInteger() ;
    if (instruction[0+1] = "1") then (     boxes[iBox+1] := boxes[iBox+1]+(apple) ) else (     boxes[iBox+1] := boxes[iBox+1]-(apple) ) ;  
    if (boxes[iBox+1] > (arrBoxCap[iBox+1])->toInteger() or boxes[iBox+1] < 0) then (     OclFile["System.out"].println(iBox + 1) ; 
     return ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("0") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] limit=new int[n];
    for(int i=0 ; i<n ; i++){
      limit[i]=sc.nextInt();
    }
    int[] apples=new int[n];
    int q=sc.nextInt();
    boolean breakFlag=false ;
    for(int i=0 ; i<q ; i++){
      int t=sc.nextInt();
      int x=sc.nextInt()-1 ;
      int d=sc.nextInt();
      if(t==1){
        apples[x]+=d ;
        if(apples[x]>limit[x]){
          System.out.println(x+1);
          breakFlag=true ;
          break ;
        }
      }
      else {
        apples[x]-=d ;
        if(apples[x]<0){
          System.out.println(x+1);
          breakFlag=true ;
          break ;
        }
      }
    }
    if(! breakFlag)System.out.println(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var limit : Sequence(int) ; limit := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     limit[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var apples : Sequence(int) ; apples := Integer.subrange(1,n)->collect(0) ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var breakFlag : boolean ; breakFlag := false ;
        var i : int ; i := 0 ; while i < q do ( (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
     if (t = 1) then (     apples[x+1] := apples[x+1]+(d) ; 
     if (apples[x+1] > limit[x+1]) then (     OclFile["System.out"].println(x + 1) ; 
     breakFlag := true ; 
     break ) else skip ) else (     apples[x+1] := apples[x+1]-(d) ; 
     if (apples[x+1] < 0) then (     OclFile["System.out"].println(x + 1) ; 
     breakFlag := true ; 
     break ) else skip ) )  ;     i := i + 1 ) ; 
    if (not(breakFlag)) then     OclFile["System.out"].println(0) ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Objects ;
import java.util.Scanner ;
import java.util.HashMap ;
public class Main {
  public static void main(String[] args){
    Main.implementation2();
  }
  public static void implementation2(){
    Scanner scanner=new Scanner(System.in);
    int numOfDigits=Integer.parseInt(scanner.nextLine());
    String[] nums=scanner.nextLine().split(" ");
    int unique=0 ;
    HashMap<String,Boolean>existingNums=new HashMap<>();
    for(String num : nums){
      if((! Objects.equals(num,"0"))&&(existingNums.get(num)==null)){
        unique+=1 ;
        existingNums.put(num,true);
      }
    }
    System.out.println(unique);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.implementation2() );
  static   operation implementation2() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numOfDigits : int ; numOfDigits := (scanner.nextLine())->toInteger() ;
    var nums : Sequence(String) ; nums := scanner.nextLine()->split(" ") ;
    var unique : int ; unique := 0 ;
    var existingNums : Map(String,Boolean) ; existingNums := Map{} ;
    for (num : nums) do ( (     if ((not(Objects = num, "0")) & (existingNums->at(num) = null)) then (     unique := unique+(1) ; 
     existingNums := existingNums->union(Map{num |-> true}) ) else skip )  ) ; 
    OclFile["System.out"].println(unique) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Dcoder {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    Set<Integer>l=new HashSet<>();
    int n=sc.nextInt();
    while(n-->0){
      int a=sc.nextInt();
      if(a!=0 && l.contains(a)==false){
        l.add(a);
      }
    }
    System.out.println(l.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Dcoder {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : Set(int) ; l := Set{} ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (a /= 0 & l->includes(a) = false) then (     l := l->including(a) ) else skip ) ;  ) ;  
    OclFile["System.out"].println(l->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class NastyaArray {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),c=0 ;
    HashSet<Integer>a=new HashSet<Integer>();
    while(n-->0){
      int x=in.nextInt();
      if(x!=0 && a.add(x)){
        c++;
      }
    }
    in.close();
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class NastyaArray {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
    var a : Set(int) ; a := Set{} ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var x : int ; x := in.getCurrent()->toInteger() ;
     if (x /= 0 & a->excludes(x)) then (     c := c + 1 ) else skip ) ;  ) ;  
    skip ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a,k ;
    Set<Long>sett=new HashSet<Long>();
    a=sc.nextLong();
    for(long i=0 ; i<a ; i++){
      long j=sc.nextLong();
      if(j!=0)sett.add(j);
    }
    System.out.println(sett.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ;
    var k : long ;
    var sett : Set(long) ; sett := Set{} ;
    a := sc.getCurrent()->toLong() ; 
        var i : long ; i := 0 ; while i < a do ( (     var j : long ; j := sc.getCurrent()->toLong() ;
     if (j /= 0) then     sett := sett->including(j) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sett->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=100005 ;
  static boolean[] isPrime=new boolean[MAX];
  static void sieveOfEratostheneses(){
    isPrime[1]=true ;
    for(int i=2 ; i*i<MAX ; i++){
      if(! isPrime[i]){
        for(int j=2*i ; j<MAX ; j+=i)isPrime[j]=true ;
      }
    }
  }
  static int findPrime(int n){
    int num=n+1 ;
    while(num>0){
      if(! isPrime[num])return num ;
      num=num+1 ;
    }
    return 0 ;
  }
  static int minNumber(int arr[],int n){
    sieveOfEratostheneses();
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=arr[i];
    if(! isPrime[sum])return 0 ;
    int num=findPrime(sum);
    return num-sum ;
  }
  public static void main(String[] args){
    int arr[]={
      2,4,6,8,12 };
      int n=arr.length ;
      System.out.println(minNumber(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100005;
  static   attribute isPrime : Sequence(boolean) := Integer.subrange(1,MAX)->collect(false);
  static   operation sieveOfEratostheneses() : void
  pre: true
  post: true
  activity: (     isPrime[1+1] := true ; 
         var i : int ; i := 2 ; while i * i < MAX do ( (     if (not(isPrime[i+1])) then (         var j : int ; j := 2 * i ; while j < MAX do (     isPrime[j+1] := true ;  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) );
  static   operation findPrime( n : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := n + 1 ;
     while (num > 0) do (     if (not(isPrime[num+1])) then     return num else skip ; 
     num := num + 1 ) ; 
     return 0 );
  static   operation minNumber( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     execute sieveOfEratostheneses() ; 
     var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    if (not(isPrime[sum+1])) then     return 0 else skip ; 
    var num : int ; num := findPrime(sum) ;
    return num - sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,6,8,12} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minNumber(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int gcd(int a,int b){
    if(b==0)return a ;
    else return gcd(b,a % b);
  }
  static boolean coPrime(int n1,int n2){
    if(gcd(n1,n2)==1)return true ;
    else return false ;
  }
  static int largestCoprime(int N){
    int half=(int)(N/2);
    while(coPrime(N,half)==false)half--;
    return half ;
  }
  public static void main(String args[]){
    int n=50 ;
    System.out.println(largestCoprime(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else     return gcd(b, a mod b) );
  static   operation coPrime( n1 : int, n2 : int) : boolean
  pre: true
  post: true
  activity: (     if (gcd(n1, n2) = 1) then     return true else     return false );
  static   operation largestCoprime( N : int) : int
  pre: true
  post: true
  activity: (     var half : int ; half := (N / 2)->oclAsType(int) ;
     while (coPrime(N, half) = false) do     half := half - 1 ; ; 
     return half );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 50 ;
     OclFile["System.out"].println(largestCoprime(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GfG {
  static int sumOfTheSeries(int n){
    return(n*(n+1)/2)*(2*n+1)/3 ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println("Sum="+sumOfTheSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation sumOfTheSeries( n : int) : int
  pre: true
  post: true
  activity: (     return (n * (n + 1) / 2) * (2 * n + 1) / 3 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println("Sum=" + sumOfTheSeries(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void ans(int n){
    if(n==1)System.out.println("1");
    else System.out.println("0");
  }
  public static void main(String[] args){
    int n=2 ;
    ans(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation ans( n : int) : void
  pre: true
  post: true
  activity: (     if (n = 1) then     OclFile["System.out"].println("1") ; else     OclFile["System.out"].println("0") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     execute ans(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int mod=1000000000 ;
  static int ways(int i,int arr[],int n){
    if(i==n-1)return 1 ;
    int sum=0 ;
    for(int j=1 ; j+i<n && j<=arr[i]; j++){
      sum+=(ways(i+j,arr,n))% mod ;
      sum %=mod ;
    }
    return sum % mod ;
  }
  public static void main(String[] args){
    int arr[]={
      5,3,1,4,3 };
      int n=arr.length ;
      System.out.println(ways(0,arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute mod : int := 1000000000;
  static   operation ways( i : int, arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (i = n - 1) then     return 1 else skip ; 
     var sum : int ; sum := 0 ;
         var j : int ; j := 1 ; while j + i < n & j <= arr[i+1] do ( (     sum := sum+((ways(i + j, arr, n)) mod mod) ; 
     sum := sum mod mod )  ;     j := j + 1 ) ; 
     return sum mod mod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,3,1,4,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(ways(0, arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isEven(int arr[],int n,int r){
    if(r % 2==0){
      if(arr[n-1] % 2==0)return true ;
    }
    else {
      int oddCount=0 ;
      for(int i=0 ; i<n ; ++i){
        if(arr[i] % 2!=0)oddCount++;
      }
      if(oddCount % 2==0)return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    int arr[]={
      1,0 };
      int n=arr.length ;
      int r=2 ;
      if(isEven(arr,n,r))System.out.println("Even");
      else System.out.println("Odd");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isEven( arr : Sequence(int), n : int, r : int) : boolean
  pre: true
  post: true
  activity: (     if (r mod 2 = 0) then (     if (arr[n - 1+1] mod 2 = 0) then     return true else skip ) else (     var oddCount : int ; oddCount := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 /= 0) then     oddCount := oddCount + 1 ; else skip )  ;     i := i + 1 ) ; 
     if (oddCount mod 2 = 0) then     return true else skip ) ;  
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,0} ;
     var n : int ; n := arr->size() ;
     var r : int ; r := 2 ;
     if (isEven(arr, n, r)) then     OclFile["System.out"].println("Even") ; else     OclFile["System.out"].println("Odd") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class App {
  public class ListNode {
    int val ;
    ListNode next ;
    public ListNode(){
    }
    public ListNode(int val){
      this.val=val ;
    }
    ListNode(int val,ListNode next){
      this.val=val ;
      this.next=next ;
    }
  }
  static int n,m ;
  public static boolean valid(long x,long y){
    return x>0 && x<=n && y>0 && y<=m ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    n=in.nextInt();
    m=in.nextInt();
    long x=in.nextLong();
    long y=in.nextLong();
    int k=in.nextInt();
    long ans=0,steps ;
    for(int i=0 ; i<k ; i++){
      long row=in.nextLong();
      long col=in.nextLong();
      steps=0 ;
      long l=0,r=1000000009,mid=0 ;
      while(l<=r){
        mid=l+(r-l)/2 ;
        if(valid(x+(row*mid),y+(col*mid))){
          steps=mid ;
          l=mid+1 ;
        }
        else {
          r=mid-1 ;
        }
      }
      ans+=steps ;
      x=x+(row*steps);
      y=y+(col*steps);
    }
    System.out.println(ans);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
 class ListNode {
   attribute val : int;
   attribute next : ListNode;
   static operation newListNode() : ListNode
  pre: true
  post: true
  activity:
  ( var self : ListNode ;
    self := createListNode();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   static operation newListNode( val : int) : ListNode
  pre: true
  post: true
  activity:
  ( var self : ListNode ;
    self := createListNode();
    self.initialise(val);
    return self );
  operation initialise( val : int) : void
  pre: true  post: true
  activity: (     self.val := val );
   static operation newListNode( val : int, next : ListNode) : ListNode
  pre: true
  post: true
  activity:
  ( var self : ListNode ;
    self := createListNode();
    self.initialise(val, next);
    return self );
  operation initialise( val : int, next : ListNode) : void
  pre: true  post: true
  activity: (     self.val := val ; 
     self.next := next );
}
  static   attribute n : int;
  static   operation valid( x : long, y : long) : boolean
  pre: true
  post: true
  activity: (     return x > 0 & x <= n & y > 0 & y <= m );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := in.getCurrent()->toInteger() ; 
    m := in.getCurrent()->toInteger() ; 
    var x : long ; x := in.getCurrent()->toLong() ;
    var y : long ; y := in.getCurrent()->toLong() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var ans : long ; ans := 0 ;
    var steps : long ;
        var i : int ; i := 0 ; while i < k do ( (     var row : long ; row := in.getCurrent()->toLong() ;
     var col : long ; col := in.getCurrent()->toLong() ;
    steps := 0 ; 
    var l : long ; l := 0 ;
    var r : long ; r := 1000000009 ;
    var mid : long ; mid := 0 ;
    while (l <= r) do (     mid := l + (r - l) / 2 ; 
     if (valid(x + (row * mid), y + (col * mid))) then (     steps := mid ; 
     l := mid + 1 ) else (     r := mid - 1 ) ) ; 
    ans := ans+(steps) ; 
    x := x + (row * steps) ; 
    y := y + (col * steps) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication1 {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    long n=s.nextInt();
    long m=s.nextInt();
    long x1=s.nextInt();
    long y1=s.nextInt();
    long count=0 ;
    long k=s.nextInt();
    for(int i=1 ; i<=k ; i++){
      long x=s.nextInt();
      long y=s.nextInt();
      long l=0 ;
      long r=(long)1e9 ;
      long steps=0 ;
      long mid ;
      while(l<=r){
        mid=(l+r)/2 ;
        if((x*mid)+x1<=n &&(x*mid)+x1>0 &&(y*mid)+y1<=m &&(y*mid)+y1>0){
          l=mid+1 ;
          steps=mid ;
        }
        else r=mid-1 ;
      }
      count+=steps ;
      x1+=steps*x ;
      y1+=steps*y ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := s.getCurrent()->toInteger() ;
    var m : long ; m := s.getCurrent()->toInteger() ;
    var x1 : long ; x1 := s.getCurrent()->toInteger() ;
    var y1 : long ; y1 := s.getCurrent()->toInteger() ;
    var count : long ; count := 0 ;
    var k : long ; k := s.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= k do ( (     var x : long ; x := s.getCurrent()->toInteger() ;
     var y : long ; y := s.getCurrent()->toInteger() ;
    var l : long ; l := 0 ;
    var r : long ; r := 1e9->oclAsType(long) ;
    var steps : long ; steps := 0 ;
    var mid : long ;
    while (l <= r) do (     mid := (l + r) / 2 ; 
     if ((x * mid) + x1 <= n & (x * mid) + x1 > 0 & (y * mid) + y1 <= m & (y * mid) + y1 > 0) then (     l := mid + 1 ; 
     steps := mid ) else     r := mid - 1 ; ) ; 
    count := count+(steps) ; 
    x1 := x1+(steps * x) ; 
    y1 := y1+(steps * y) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void Divide(int a,int b){
    long dividend=(long)a ;
    long divisor=(long)b ;
    long sign=(dividend<0)^(divisor<0)?-1 : 1 ;
    dividend=Math.abs(dividend);
    divisor=Math.abs(divisor);
    if(divisor==0){
      System.out.println("Cannot Divide by 0");
      return ;
    }
    if(dividend==0){
      System.out.println(a+"/"+b+" is equal to : "+0);
      return ;
    }
    if(divisor==1){
      System.out.println(a+"/"+b+" is equal to : "+sign*dividend);
      return ;
    }
    System.out.println(a+"/"+b+" is equal to : "+Math.floor(sign*(Math.exp(Math.log(dividend)-Math.log(divisor)))));
  }
  public static void main(String[] args){
    int a=10,b=5 ;
    Divide(a,b);
    a=49 ;
    b=-7 ;
    Divide(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Divide( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var dividend : long ; dividend := a->oclAsType(long) ;
     var divisor : long ; divisor := b->oclAsType(long) ;
    var sign : long ; sign := if MathLib.bitwiseXor((dividend < 0),(divisor < 0)) then -1 else 1 endif ;
    dividend := if dividend < 0 then -(dividend) else dividend endif ; 
    divisor := if divisor < 0 then -(divisor) else divisor endif ; 
    if (divisor = 0) then (     OclFile["System.out"].println("Cannot Divide by 0") ; 
     return ) else skip ; 
    if (dividend = 0) then (     OclFile["System.out"].println(a + "/" + b + " is equal to : " + 0) ; 
     return ) else skip ; 
    if (divisor = 1) then (     OclFile["System.out"].println(a + "/" + b + " is equal to : " + sign * dividend) ; 
     return ) else skip ; 
    OclFile["System.out"].println(a + "/" + b + " is equal to : " + (sign * (((dividend)->log() - (divisor)->log())->exp()))->floor()) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 10 ;
    var b : int ; b := 5 ;
     execute Divide(a, b) ; 
    a := 49 ; 
    b := -7 ; 
    execute Divide(a, b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    try(Scanner sc=new Scanner(System.in)){
      long t=Long.parseLong(sc.next());
      int n=Integer.parseInt(sc.next());
      long[] a=new long[n];
      long[] b=new long[n];
      for(int i=0 ; i<n ; i++){
        a[i]=Long.parseLong(sc.next());
        b[i]=Long.parseLong(sc.next());
      }
      int st=0 ;
      long sum=0 ;
      long max=0 ;
      for(int i=0 ; i<n ; i++){
        long ed=t+a[i];
        if(i>0){
          sum-=(b[i-1]-a[i-1]);
        }
        boolean f=false ;
        for(int j=st ; j<n ; j++){
          if(ed<b[j]){
            long val=sum+(ed-a[j]);
            max=Math.max(max,val);
            st=j ;
            break ;
          }
          else if(j+1<n && ed<=a[j+1]){
            long val=sum+(b[j]-a[j]);
            max=Math.max(max,val);
            st=j ;
            break ;
          }
          else {
            sum+=(b[j]-a[j]);
            if(j==n-1){
              f=true ;
              max=Math.max(max,sum);
            }
          }
        }
        if(f){
          break ;
        }
      }
      System.out.println(max);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var t : long ; t := (sc.getCurrent())->toLong() ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sc.getCurrent())->toLong() ; 
     b[i+1] := (sc.getCurrent())->toLong() )  ;     i := i + 1 ) ; 
    var st : int ; st := 0 ;
    var sum : long ; sum := 0 ;
    var max : long ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var ed : long ; ed := t + a[i+1] ;
     if (i > 0) then (     sum := sum-((b[i - 1+1] - a[i - 1+1])) ) else skip ; 
    var f : boolean ; f := false ;
        var j : int ; j := st ; while j < n do ( (     if (ed < b[j+1]) then (     var val : long ; val := sum + (ed - a[j+1]) ;
     max := Set{max, val}->max() ; 
     st := j ; 
     break ) else     if (j + 1 < n & ed <= a[j + 1+1]) then (     var val : long ; val := sum + (b[j+1] - a[j+1]) ;
     max := Set{max, val}->max() ; 
     st := j ; 
     break ) else (     sum := sum+((b[j+1] - a[j+1])) ; 
     if (j = n - 1) then (     f := true ; 
     max := Set{max, sum}->max() ) else skip ) ;  )  ;     j := j + 1 ) ; 
    if (f) then (     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ))  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long t=sc.nextLong();
    int n=sc.nextInt();
    long[] starts=new long[n+1];
    long[] ends=new long[n+1];
    long[] times=new long[n+1];
    for(int i=1 ; i<=n ; i++){
      starts[i]=sc.nextLong();
      ends[i]=sc.nextLong();
      times[i]=times[i-1]+ends[i]-starts[i];
    }
    int right=1 ;
    long max=0 ;
    for(int left=1 ; left<=n ; left++){
      while(right<n && starts[left]+t>=ends[right]){
        right++;
      }
      long time=times[right-1]-times[left-1];
      if(starts[left]+t>=ends[right]){
        time+=ends[right]-starts[right];
      }
      else if(starts[left]+t>=starts[right]){
        time+=starts[left]+t-starts[right];
      }
      max=Math.max(max,time);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : long ; t := sc.getCurrent()->toLong() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var starts : Sequence(long) ; starts := Integer.subrange(1,n + 1)->collect(0) ;
    var ends : Sequence(long) ; ends := Integer.subrange(1,n + 1)->collect(0) ;
    var times : Sequence(long) ; times := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     starts[i+1] := sc.getCurrent()->toLong() ; 
     ends[i+1] := sc.getCurrent()->toLong() ; 
     times[i+1] := times[i - 1+1] + ends[i+1] - starts[i+1] )  ;     i := i + 1 ) ; 
    var right : int ; right := 1 ;
    var max : long ; max := 0 ;
        var left : int ; left := 1 ; while left <= n do ( (     while (right < n & starts[left+1] + t >= ends[right+1]) do (     right := right + 1 ) ; 
     var time : long ; time := times[right - 1+1] - times[left - 1+1] ;
     if (starts[left+1] + t >= ends[right+1]) then (     time := time+(ends[right+1] - starts[right+1]) ) else     if (starts[left+1] + t >= starts[right+1]) then (     time := time+(starts[left+1] + t - starts[right+1]) ) else skip ; ;  
     max := Set{max, time}->max() )  ;     left := left + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=25 ;
  static int getMinSum(int arr[],int n){
    int bits_count[]=new int[MAX],max_bit=0,sum=0,ans=0 ;
    for(int d=0 ; d<n ; d++){
      int e=arr[d],f=0 ;
      while(e>0){
        int rem=e % 2 ;
        e=e/2 ;
        if(rem==1){
          bits_count[f]+=rem ;
        }
        f++;
      }
      max_bit=Math.max(max_bit,f);
    }
    for(int d=0 ; d<max_bit ; d++){
      int temp=(int)Math.pow(2,d);
      if(bits_count[d]>n/2)ans=ans+temp ;
    }
    for(int d=0 ; d<n ; d++){
      arr[d]=arr[d] ^ ans ;
      sum=sum+arr[d];
    }
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      3,5,7,11,15 };
      int n=arr.length ;
      System.out.println(getMinSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 25;
  static   operation getMinSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var bits_count : Sequence(void) ; bits_count := Integer.subrange(1,MAX)->collect(0) ;
    var max_bit : int ; max_bit := 0 ;
    var sum : int ; sum := 0 ;
    var ans : int ; ans := 0 ;
         var d : int ; d := 0 ; while d < n do ( (     var e : int ; e := arr[d+1] ;
    var f : int ; f := 0 ;
     while (e > 0) do (     var rem : int ; rem := e mod 2 ;
     e := e / 2 ; 
     if (rem = 1) then (     bits_count[f+1] := bits_count[f+1]+(rem) ) else skip ; 
     f := f + 1 ) ; 
     max_bit := Set{max_bit, f}->max() )  ;     d := d + 1 ) ; 
        var d : int ; d := 0 ; while d < max_bit do ( (     var temp : int ; temp := 2->pow(d)->oclAsType(int) ;
     if (bits_count[d+1] > n / 2) then     ans := ans + temp ; else skip )  ;     d := d + 1 ) ; 
        var d : int ; d := 0 ; while d < n do ( (     arr[d+1] := arr[d+1] xor ans ; 
     sum := sum + arr[d+1] )  ;     d := d + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,5,7,11,15} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(getMinSum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      long a[]=new long[n];
      long mike=0 ;
      long joe=0 ;
      long mk=Long.MAX_VALUE ;
      long je=Long.MAX_VALUE ;
      int smallestmike=0,smallestjoe=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=input.nextLong();
        if(i % 2==0){
          if(mk>a[i]){
            mk=a[i];
            smallestmike=i ;
          }
        }
        else {
          if(je>a[i]){
            je=a[i];
            smallestjoe=i ;
          }
        }
      }
      if(n % 2==1){
        System.out.println("Mike");
      }
      else if(mk<je){
        System.out.println("Joe");
      }
      else if(mk>je){
        System.out.println("Mike");
      }
      else if(mk==je){
        if(smallestjoe<smallestmike)System.out.println("Mike");
        else {
          System.out.println("Joe");
        }
      }
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var tc : int ; tc := input.nextInt() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.nextInt() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var mike : long ; mike := 0 ;
    var joe : long ; joe := 0 ;
    var mk : long ; mk := "9223372036854775807"->toLong() ;
    var je : long ; je := "9223372036854775807"->toLong() ;
    var smallestmike : int ; smallestmike := 0 ;
    var smallestjoe : int ; smallestjoe := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.nextLong() ; 
     if (i mod 2 = 0) then (     if (mk > a[i+1]) then (     mk := a[i+1] ; 
     smallestmike := i ) else skip ) else (     if (je > a[i+1]) then (     je := a[i+1] ; 
     smallestjoe := i ) else skip ) )  ;     i := i + 1 ) ; 
    if (n mod 2 = 1) then (     OclFile["System.out"].println("Mike") ) else     if (mk < je) then (     OclFile["System.out"].println("Joe") ) else     if (mk > je) then (     OclFile["System.out"].println("Mike") ) else     if (mk = je) then (     if (smallestjoe < smallestmike) then     OclFile["System.out"].println("Mike") ; else (     OclFile["System.out"].println("Joe") ) ) else skip ; ;  ;  ;  
 ) ;  ) ;  );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class CircleGame {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        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().trim();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  private static boolean JoeWins(int[] arr){
    if(arr.length % 2!=0)return false ;
    else {
      int minindex=0,min_value=Integer.MAX_VALUE ;
      for(int i=0 ; i<arr.length ; i++){
        if(arr[i]<min_value){
          min_value=arr[i];
          minindex=i ;
        }
      }
      if(minindex % 2==0)return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    try {
      FastReader in=new FastReader();
      PrintWriter out=new PrintWriter(System.out);
      int testcases=in.nextInt();
      while(testcases-->0){
        int n=in.nextInt();
        int[] arr=new int[n];
        for(int i=0 ; i<n ; i++)arr[i]=in.nextInt();
        if(JoeWins(arr))out.println("Joe");
        else out.println("Mike");
      }
      out.close();
    }
    catch(Exception e){
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CircleGame {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine()->trim() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return str );
}
  static   operation JoeWins( arr : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     if (arr->size() mod 2 /= 0) then     return false else (     var minindex : int ; minindex := 0 ;
    var min_value : int ; min_value := 2147483647 ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] < min_value) then (     min_value := arr[i+1] ; 
     minindex := i ) else skip )  ;     i := i + 1 ) ; 
     if (minindex mod 2 = 0) then     return true else skip ) ;  
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var testcases : int ; testcases := in.nextInt() ;
        while (testcases > 0) do (        testcases := testcases - 1 ;     skip ; (     var n : int ; n := in.nextInt() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     arr[i+1] := in.nextInt() ;  ;     i := i + 1 ) ; 
     if (JoeWins(arr)) then     skip ; else     skip ; ) ;  ) ;  
    skip ; 
 )   catch (e : ProgramException) do (     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Solution {
  static PrintWriter pw ;
  static FastScanner s ;
  public static void main(String[] args)throws Exception {
    pw=new PrintWriter(System.out);
    s=new FastScanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=s.nextInt();
      if(n % 2==1)pw.println("Mike");
      else {
        int smallest=0 ;
        for(int i=0 ; i<n ; ++i)if(a[i]<a[smallest])smallest=i ;
        if(smallest % 2==0)pw.println("Joe");
        else pw.println("Mike");
      }
    }
    pw.flush();
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public FastScanner(String s)throws Exception {
    br=new BufferedReader(new FileReader(new File(s)));
  }
  public String next()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(next());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute pw : OclFile;
  static   attribute s : FastScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     pw := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     s := FastScanner.newFastScanner(OclFile["System.in"]) ; 
    var t : int ; t := s.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := s.nextInt() ;  ;     i := i + 1 ) ; 
     if (n mod 2 = 1) then     skip ; else (     var smallest : int ; smallest := 0 ;
         var i : int ; i := 0 ; while i < n do (     if (a[i+1] < a[smallest+1]) then     smallest := i ; else skip ;  ;     i := i + 1 ) ; 
     if (smallest mod 2 = 0) then     skip ; else     skip ; ) ) ;  ) ;  
    skip ; 
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int s=sc.nextInt();
    long div=1_000_000_007 ;
    long[] ans=new long[s+1];
    for(int i=1 ; i<=s ; i++){
      if(i<=2)ans[i]=0 ;
      else if(i==3)ans[i]=1 ;
      else ans[i]=(ans[i-1]+ans[i-3])% div ;
    }
    System.out.println(ans[s]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : int ; s := sc.getCurrent()->toInteger() ;
    var div : long ; div := 1_000_000_007 ;
    var ans : Sequence(long) ; ans := Integer.subrange(1,s + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= s do ( (     if (i <= 2) then     ans[i+1] := 0 ; else     if (i = 3) then     ans[i+1] := 1 else     ans[i+1] := (ans[i - 1+1] + ans[i - 3+1]) mod div ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans[s+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  long MOD=(long)1e9+7 ;
  InputStream in ;
  OutputStream out ;
  public Main(){
    this(System.in,System.out);
  }
  public Main(InputStream in,OutputStream out){
    this.in=in ;
    this.out=out ;
  }
  void run(){
    Scanner sc=new Scanner(this.in);
    PrintWriter out=new PrintWriter(this.out);
    int s=sc.nextInt();
    int l=(s+2)/3 ;
    long[][] dp=new long[l+1][s+1];
    long[][] sum=new long[l+1][s+1];
    dp[0][0]=1 ;
    for(int i=0 ; i<=s ; i++){
      sum[0][i]=1 ;
    }
    long ans=0 ;
    for(int i=1 ; i<=l ; i++){
      for(int j=3*i ; j<=s ; j++){
        dp[i][j]=(sum[i-1][j-3])% MOD ;
        sum[i][j]=(sum[i][j-1]+dp[i][j])% MOD ;
      }
      ans=(ans+dp[i][s])% MOD ;
    }
    out.println(ans);
    out.flush();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute MOD : long := 1e9->oclAsType(long) + 7;
   attribute in : OclFile;
   attribute out : OclFile;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile["System.in"], OclFile["System.out"]) );
   static operation newMain( in : OclFile, out : OclFile) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(in, out);
    return self );
  operation initialise( in : OclFile, out : OclFile) : void
  pre: true  post: true
  activity: (     self.in := in ; 
     self.out := out );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(self.in) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(self.out) ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var l : int ; l := (s + 2) / 3 ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,l + 1)->collect(Integer.subrange(1,s + 1)->collect(0)) ;
    var sum : Sequence(Sequence(long)) ; sum := Integer.subrange(1,l + 1)->collect(Integer.subrange(1,s + 1)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 0 ; while i <= s do ( (     sum[0+1][i+1] := 1 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= l do ( (         var j : int ; j := 3 * i ; while j <= s do ( (     dp[i+1][j+1] := (sum[i - 1+1][j - 3+1]) mod MOD ; 
     sum[i+1][j+1] := (sum[i+1][j - 1+1] + dp[i+1][j+1]) mod MOD )  ;     j := j + 1 ) ; 
     ans := (ans + dp[i+1][s+1]) mod MOD )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p007 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p007().run());
  }
  public String run(){
    for(int i=2,count=0 ; ; i++){
      if(Library.isPrime(i)){
        count++;
        if(count==10001)return Integer.toString(i);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class p007 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p007.newp007().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ;
    var count : int ; count := 0 ; while true do ( (     if (Library.isPrime(i)) then (     count := count + 1 ; 
     if (count = 10001) then     return ((i) + "") else skip ) else skip )  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskD solver=new TaskD();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskD {
    static int MOD=1_000_000_000+7 ;
    int memo[];
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int T=1 ;
      while(T-->0){
        solveOne(in,out);
      }
    }
    private void solveOne(Scanner in,PrintWriter out){
      int N=in.nextInt();
      memo=new int[N+10];
      Arrays.fill(memo,-1);
      out.println(dp(N));
    }
    private int dp(int n){
      if(n==0)return 1 ;
      if(n<0)return 0 ;
      if(memo[n]!=-1)return memo[n];
      int ans=0 ;
      for(int num=3 ; num<=n ; num++){
        ans=(ans+dp(n-num))% MOD ;
      }
      memo[n]=ans ;
      return ans ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskD ; solver := TaskD.newTaskD() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskD {
  static   attribute MOD : int := 1_000_000_000 + 7;
   attribute memo : Sequence(int);
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var T : int ; T := 1 ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     execute solveOne(in, out) ) ;  ) );
   operation solveOne( in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
     memo := Integer.subrange(1,N + 10)->collect(0) ; 
     memo := memo->collect(-1) ; 
     skip );
   operation dp( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     if (n < 0) then     return 0 else skip ; 
    if (memo[n+1] /= -1) then     return memo[n+1] else skip ; 
    var ans : int ; ans := 0 ;
        var num : int ; num := 3 ; while num <= n do ( (     ans := (ans + dp(n - num)) mod MOD )  ;     num := num + 1 ) ; 
    memo[n+1] := ans ; 
    return ans 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class Main {
  static long dp[],mod=(long)1e9+7 ;
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int s=in.nextInt();
    dp=new long[s+1];
    Arrays.fill(dp,-1);
    pw.println(solve(s));
    pw.close();
  }
  static long solve(int s){
    if(s==0)return 1 ;
    if(s<3)return 0 ;
    if(dp[s]!=-1)return dp[s];
    long res=0 ;
    for(int i=3 ; i<=s ; i++){
      res+=solve(s-i);
      if(res>=mod)res-=mod ;
    }
    return dp[s]=res ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dp : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : int ; s := in.getCurrent()->toInteger() ;
    dp := Integer.subrange(1,s + 1)->collect(0) ; 
    dp := dp->collect(-1) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( s : int) : long
  pre: true
  post: true
  activity: (     if (s = 0) then     return 1 else skip ; 
     if (s < 3) then     return 0 else skip ; 
    if (dp[s+1] /= -1) then     return dp[s+1] else skip ; 
    var res : long ; res := 0 ;
        var i : int ; i := 3 ; while i <= s do ( (     res := res+(solve(s - i)) ; 
     if (res >= mod) then     res := res-(mod) ; else skip )  ;     i := i + 1 ) ; 
    return dp[s+1] 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    try(final var stdin=new InputStreamReader(System.in);
    final var br=new BufferedReader(stdin)){
      final var s=Integer.parseInt(br.readLine());
      final var modulo=(long)Math.pow(10,9)+7 ;
      final var cache=new long[Math.max(s+1,6)];
      cache[3]=1 ;
      cache[4]=1 ;
      cache[5]=1 ;
      for(int i=6 ; i<=s ; i++){
        cache[i]=(cache[i-1]+cache[i-3])% modulo ;
      }
      System.out.println(cache[s]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var stdin : var = OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : var = OclFile.newOclFile_Read(stdin) ;
 (     var s : var ; s := (br.readLine())->toInteger() ;
     var modulo : var ; modulo := 10->pow(9)->oclAsType(long) + 7 ;
    var cache : var ; cache := Integer.subrange(1,Set{s + 1, 6}->max())->collect(0) ;
    cache[3+1] := 1 ; 
    cache[4+1] := 1 ; 
    cache[5+1] := 1 ; 
        var i : int ; i := 6 ; while i <= s do ( (     cache[i+1] := (cache[i - 1+1] + cache[i - 3+1]) mod modulo )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cache[s+1]) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int rhombusAreaPeri(int d1,int d2){
    int area,perimeter ;
    area=(d1*d2)/2 ;
    perimeter=(int)(2*Math.sqrt(Math.pow(d1,2)+Math.pow(d2,2)));
    System.out.println("The area of rhombus with diagonals "+d1+" and "+d2+" is "+area+".");
    System.out.println("The perimeter of rhombus with diagonals "+d1+" and "+d2+" is "+perimeter+".");
    return 0 ;
  }
  public static void main(String[] args){
    int d1=2,d2=4 ;
    rhombusAreaPeri(d1,d2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation rhombusAreaPeri( d1 : int, d2 : int) : int
  pre: true
  post: true
  activity: (     var area : int ;
    var perimeter : int ;
     area := (d1 * d2) / 2 ; 
    perimeter := (2 * (d1->pow(2) + d2->pow(2))->sqrt())->oclAsType(int) ; 
    OclFile["System.out"].println("The area of rhombus with diagonals " + d1 + " and " + d2 + " is " + area + ".") ; 
    OclFile["System.out"].println("The perimeter of rhombus with diagonals " + d1 + " and " + d2 + " is " + perimeter + ".") ; 
    return 0 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d1 : int ; d1 := 2 ;
    var d2 : int ; d2 := 4 ;
     execute rhombusAreaPeri(d1, d2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class _70B implements Runnable {
  private BufferedReader in ;
  private Object solve()throws IOException {
    int n=nextInt(),c=0,q=0 ;
    String s=nextToken();
    for(int i=0,l=s.length(),p=0 ; i<l ; i++){
      char h=s.charAt(i);
      p++;
      if(h=='.' || h=='!' || h=='?'){
        if(p>n){
          return "Impossible" ;
        }
        if(q==0){
          q=p ;
        }
        else if(q+1+p<=n){
          q+=1+p ;
        }
        else {
          q=p ;
          c++;
        }
        p=0 ;
        i++;
      }
    }
    if(q>0){
      c++;
    }
    return c ;
  }
  public static void main(String[] args){
    new _70B().run();
  }
  @ Override public void run(){
    try {
      in=new BufferedReader(new InputStreamReader(System.in));
      PrintStream out=System.out ;
      out.print(solve());
      in.close();
    }
    catch(IOException e){
      System.exit(0);
    }
  }
  private String nextToken()throws IOException {
    return in.readLine();
  }
  private int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class _70B implements Runnable {
   attribute in : OclFile;
   operation solve() : OclAny
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
    var c : int ; c := 0 ;
    var q : int ; q := 0 ;
     var s : String ; s := nextToken() ;
        var i : int ; i := 0 ;
    var l : int ; l := s->size() ;
    var p : int ; p := 0 ; while i < l do ( (     var h : String ; h := s->at(i+1) ;
     p := p + 1 ; 
     if (h = '.' or h = '!' or h = '?') then (     if (p > n) then (     return "Impossible" ) else skip ; 
     if (q = 0) then (     q := p ) else     if (q + 1 + p <= n) then (     q := q+(1 + p) ) else (     q := p ; 
     c := c + 1 ) ;  ;  
     p := 0 ; 
     i := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (q > 0) then (     c := c + 1 ) else skip ; 
    return c 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     _70B.new_70B().run() );
      operation run() : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     var out : OclFile ; out := OclFile["System.out"] ;
     skip ; 
     skip )   catch (e : IOException) do ( OclProcess.exit(0) )
 );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     return in.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maxValue(int arr[],int n,int moves){
    for(int i=n-2 ; i>=0 ; i--){
      if(arr[i]>0){
        int distance=n-1-i ;
        if(moves<distance)break ;
        int can_take=moves/distance ;
        int take=Math.min(arr[i],can_take);
        arr[n-1]+=take ;
        moves-=take*distance ;
      }
    }
    return arr[n-1];
  }
  public static void main(String[] args){
    int arr[]={
      2,3,0,1 };
      int M=5 ;
      int N=arr.length ;
      System.out.print(maxValue(arr,N,M));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxValue( arr : Sequence(int), n : int, moves : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := n - 2 ; while i >= 0 do ( (     if (arr[i+1] > 0) then (     var distance : int ; distance := n - 1 - i ;
     if (moves < distance) then     break else skip ; 
    var can_take : int ; can_take := moves / distance ;
    var take : int ; take := Set{arr[i+1], can_take}->min() ;
    arr[n - 1+1] := arr[n - 1+1]+(take) ; 
    moves := moves-(take * distance) ; 
 ) else skip )  ;     i := i - 1 ) ; 
     return arr[n - 1+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,0,1} ;
     var M : int ; M := 5 ;
     var N : int ; N := arr->size() ;
     OclFile["System.out"].print(maxValue(arr, N, M)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int getCount(int l,int r,int p){
    int cnt=0 ;
    int val=p ;
    while(true){
      int a=r/val ;
      int b=(l-1)/val ;
      val*=p ;
      if((a-b)>0){
        cnt+=(a-b);
      }
      else break ;
    }
    return cnt ;
  }
  public static void main(String[] args){
    int l=2,r=8,p=2 ;
    System.out.println(getCount(l,r,p));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getCount( l : int, r : int, p : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var val : int ; val := p ;
     while (true) do (     var a : int ; a := r / val ;
     var b : int ; b := (l - 1) / val ;
     val := val*(p) ; 
     if ((a - b) > 0) then (     cnt := cnt+((a - b)) ) else     break ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 2 ;
    var r : int ; r := 8 ;
    var p : int ; p := 2 ;
     OclFile["System.out"].println(getCount(l, r, p)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static void sortRows(int mat[][],int n){
    for(int i=0 ; i<n ; i++)Arrays.sort(mat[i]);
  }
  public static void findAndPrintCommonElements(int mat[][],int n){
    sortRows(mat,n);
    int curr_index[]=new int[n];
    int f=0 ;
    for(; curr_index[0]<n ; curr_index[0]++){
      int value=mat[0][curr_index[0] ];
      boolean present=true ;
      for(int i=1 ; i<n ; i++){
        while(curr_index[i]<n && mat[i][curr_index[i] ]<=value)curr_index[i]++;
        if(mat[i][curr_index[i]-1]!=value)present=false ;
        if(curr_index[i]==n){
          f=1 ;
          break ;
        }
      }
      if(present)System.out.print(value+" ");
      if(f==1)break ;
    }
  }
  public static void main(String[] args){
    int mat[][]={
      {
        12,1,14,3,16 },{
          14,2,1,3,35 },{
            14,1,14,3,11 },{
              14,25,3,2,1 },{
                1,18,3,21,14 }
              };
              int n=5 ;
              findAndPrintCommonElements(mat,n);
            }
          }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sortRows( mat : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     mat[i+1] := mat[i+1]->sort() ;  ;     i := i + 1 ) );
  static   operation findAndPrintCommonElements( mat : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (     execute sortRows(mat, n) ; 
     var curr_index : Sequence(int) ; curr_index := Integer.subrange(1,n)->collect(0) ;
     var f : int ; f := 0 ;
       while curr_index[0+1] < n do ( (     var value : int ; value := mat[0+1][curr_index[0+1]+1] ;
     var present : boolean ; present := true ;
        var i : int ; i := 1 ; while i < n do ( (     while (curr_index[i+1] < n & mat[i+1][curr_index[i+1]+1] <= value) do     curr_index[i+1] := curr_index[i+1] + 1 ; ; 
     if (mat[i+1][curr_index[i+1] - 1+1] /= value) then     present := false ; else skip ; 
     if (curr_index[i+1] = n) then (     f := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (present) then     OclFile["System.out"].print(value + " ") ; else skip ; 
    if (f = 1) then     break else skip ; 
 )  ;     curr_index[0+1] := curr_index[0+1] + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{12,1,14,3,16},Sequence{14,2,1,3,35},Sequence{14,1,14,3,11},Sequence{14,25,3,2,1},Sequence{1,18,3,21,14}} ;
     var n : int ; n := 5 ;
     execute findAndPrintCommonElements(mat, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void traverseLshape(int a[][],int n,int m){
    for(int j=0 ; j<m ; j++){
      for(int i=0 ; i<=n-j-1 ; i++)System.out.print(a[i][j]+" ");
      for(int k=j+1 ; k<m ; k++)System.out.print(a[n-1-j][k]+" ");
    }
  }
  public static void main(String args[]){
    int n=4 ;
    int m=3 ;
    int a[][]={
      {
        1,2,3 },{
          4,5,6 },{
            7,8,9 },{
              10,11,12 }
            };
            traverseLshape(a,n,m);
          }
        }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation traverseLshape( a : Sequence(Sequence(int)), n : int, m : int) : void
  pre: true
  post: true
  activity: (         var j : int ; j := 0 ; while j < m do ( (         var i : int ; i := 0 ; while i <= n - j - 1 do (     OclFile["System.out"].print(a[i+1][j+1] + " ") ;  ;     i := i + 1 ) ; 
         var k : int ; k := j + 1 ; while k < m do (     OclFile["System.out"].print(a[n - 1 - j+1][k+1] + " ") ;  ;     k := k + 1 ) )  ;     j := j + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var m : int ; m := 3 ;
     var a : Sequence(Sequence(int)) ; a := Sequence{Sequence{1,2,3},Sequence{4,5,6},Sequence{7,8,9},Sequence{10,11,12}} ;
     execute traverseLshape(a, n, m) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int countTripletsLessThan(int[] arr,int n,int val){
    Arrays.sort(arr);
    int ans=0 ;
    int j,k ;
    int sum ;
    for(int i=0 ; i<n-2 ; i++){
      j=i+1 ;
      k=n-1 ;
      while(j!=k){
        sum=arr[i]+arr[j]+arr[k];
        if(sum>val)k--;
        else {
          ans+=(k-j);
          j++;
        }
      }
    }
    return ans ;
  }
  public static int countTriplets(int arr[],int n,int a,int b){
    int res ;
    res=countTripletsLessThan(arr,n,b)-countTripletsLessThan(arr,n,a-1);
    return res ;
  }
  public static void main(String[] args){
    int[] arr={
      2,7,5,3,8,4,1,9 };
      int n=arr.length ;
      int a=8,b=16 ;
      System.out.println(""+countTriplets(arr,n,a,b));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countTripletsLessThan( arr : Sequence(int), n : int, val : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var ans : int ; ans := 0 ;
    var j : int ;
    var k : int ;
    var sum : int ;
        var i : int ; i := 0 ; while i < n - 2 do ( (     j := i + 1 ; 
     k := n - 1 ; 
     while (j /= k) do (     sum := arr[i+1] + arr[j+1] + arr[k+1] ; 
     if (sum > val) then     k := k - 1 ; else (     ans := ans+((k - j)) ; 
     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation countTriplets( arr : Sequence(int), n : int, a : int, b : int) : int
  pre: true
  post: true
  activity: (     var res : int ;
     res := countTripletsLessThan(arr, n, b) - countTripletsLessThan(arr, n, a - 1) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,7,5,3,8,4,1,9} ;
     var n : int ; n := arr->size() ;
     var a : int ; a := 8 ;
    var b : int ; b := 16 ;
     OclFile["System.out"].println("" + countTriplets(arr, n, a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int m=sc.nextInt();
    System.out.println(48-m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(48 - m) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findTriplets(int x){
    Vector<Integer>fact=new Vector<Integer>();
    HashSet<Integer>factors=new HashSet<Integer>();
    for(int i=2 ; i<=Math.sqrt(x); i++){
      if(x % i==0){
        fact.add(i);
        if(x/i!=i)fact.add(x/i);
        factors.add(i);
        factors.add(x/i);
      }
    }
    boolean found=false ;
    int k=fact.size();
    for(int i=0 ; i<k ; i++){
      int a=fact.get(i);
      for(int j=0 ; j<k ; j++){
        int b=fact.get(j);
        if((a!=b)&&(x %(a*b)==0)&&(x/(a*b)!=a)&&(x/(a*b)!=b)&&(x/(a*b)!=1)){
          System.out.print(a+" "+b+" "+(x/(a*b)));
          found=true ;
          break ;
        }
      }
      if(found)break ;
    }
    if(! found)System.out.print("-1");
  }
  public static void main(String[] args){
    int x=105 ;
    findTriplets(x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findTriplets( x : int) : void
  pre: true
  post: true
  activity: (     var fact : Sequence(int) ; fact := Sequence{} ;
     var factors : Set(int) ; factors := Set{} ;
        var i : int ; i := 2 ; while i <= (x)->sqrt() do ( (     if (x mod i = 0) then (     fact := fact->including(i) ; 
     if (x / i /= i) then     fact := fact->including(x / i) ; else skip ; 
     factors := factors->including(i) ; 
     factors := factors->including(x / i) ) else skip )  ;     i := i + 1 ) ; 
    var found : boolean ; found := false ;
    var k : int ; k := fact->size() ;
        var i : int ; i := 0 ; while i < k do ( (     var a : int ; a := fact->at(i+1) ;
         var j : int ; j := 0 ; while j < k do ( (     var b : int ; b := fact->at(j+1) ;
     if ((a /= b) & (x mod (a * b) = 0) & (x / (a * b) /= a) & (x / (a * b) /= b) & (x / (a * b) /= 1)) then (     OclFile["System.out"].print(a + " " + b + " " + (x / (a * b))) ; 
     found := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (found) then     break else skip )  ;     i := i + 1 ) ; 
    if (not(found)) then     OclFile["System.out"].print("-1") ; else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 105 ;
     execute findTriplets(x) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int m=Integer.parseInt(br.readLine());
    PrintWriter pw=new PrintWriter(System.out);
    pw.println(48-m);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var m : int ; m := (br.readLine())->toInteger() ;
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    A(sc);
  }
  public static void A(Scanner sc){
    int m=sc.nextInt();
    out.println(24-m+24);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute A(sc) );
  static   operation A( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var m : int ; m := sc.getCurrent()->toInteger() ;
     out.println(24 - m + 24) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    Scanner sc=new Scanner(System.in);
    int M=sc.nextInt();
    System.out.println(48-M);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var M : int ; M := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(48 - M) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int result=24-n+24 ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var result : int ; result := 24 - n + 24 ;
     OclFile["System.out"].println(result) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void print(int arr[],int n){
    for(int i=0 ; i<n ; i++){
      System.out.print(arr[i]+" ");
    }
    System.out.println();
  }
  static void swapMax(int[] arr,int target_position,int current_position){
    int aux=0 ;
    for(int i=current_position ; i>target_position ; i--){
      aux=arr[i-1];
      arr[i-1]=arr[i];
      arr[i]=aux ;
    }
  }
  static void maximizeArray(int[] arr,int length,int swaps){
    if(swaps==0)return ;
    for(int i=0 ; i<length ; i++){
      int max_index=0,max=Integer.MIN_VALUE ;
      int limit=(swaps+i)>length ? length : swaps+i ;
      for(int j=i ; j<=limit ; j++){
        if(arr[j]>max){
          max=arr[j];
          max_index=j ;
        }
      }
      swaps-=(max_index-i);
      swapMax(arr,i,max_index);
      if(swaps==0)break ;
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,2,9,8,1,4,9,9,9 };
      int length=arr.length ;
      int swaps=4 ;
      maximizeArray(arr,length,swaps);
      print(arr,length);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation print( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation swapMax( arr : Sequence(int), target_position : int, current_position : int) : void
  pre: true
  post: true
  activity: (     var aux : int ; aux := 0 ;
         var i : int ; i := current_position ; while i > target_position do ( (     aux := arr[i - 1+1] ; 
     arr[i - 1+1] := arr[i+1] ; 
     arr[i+1] := aux )  ;     i := i - 1 ) );
  static   operation maximizeArray( arr : Sequence(int), length : int, swaps : int) : void
  pre: true
  post: true
  activity: (     if (swaps = 0) then     return else skip ; 
         var i : int ; i := 0 ; while i < length do ( (     var max_index : int ; max_index := 0 ;
    var max : int ; max := -2147483648 ;
     var limit : int ; limit := if (swaps + i) > length then length else swaps + i endif ;
        var j : int ; j := i ; while j <= limit do ( (     if (arr[j+1] > max) then (     max := arr[j+1] ; 
     max_index := j ) else skip )  ;     j := j + 1 ) ; 
    swaps := swaps-((max_index - i)) ; 
    execute swapMax(arr, i, max_index) ; 
    if (swaps = 0) then     break else skip ; 
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,9,8,1,4,9,9,9} ;
     var length : int ; length := arr->size() ;
    var swaps : int ; swaps := 4 ;
    execute maximizeArray(arr, length, swaps) ; 
    execute print(arr, length) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayDeque ;
import java.util.Deque ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      StringTokenizer st=new StringTokenizer(line);
      int N=Integer.parseInt(st.nextToken());
      Deque<Integer>relays=new ArrayDeque<Integer>();
      Deque<Integer>duties=new ArrayDeque<Integer>();
      for(int i=0 ; i<N ; i++){
        relays.offer(i);
      }
      st=new StringTokenizer(br.readLine());
      while(st.hasMoreTokens()){
        int a=Integer.parseInt(st.nextToken());
        if(a % 2==0){
          for(int i=0 ; i<a ; i++){
            relays.offer(relays.poll());
          }
        }
        else {
          for(int i=0 ; i<a ; i++){
            relays.offerFirst(relays.pollLast());
          }
        }
        duties.offer(relays.pollFirst());
      }
      st=new StringTokenizer(br.readLine());
      while(st.hasMoreTokens()){
        int q=Integer.parseInt(st.nextToken());
        System.out.println(duties.contains(q)? 0 : 1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var st : OclIterator ; st := OclIterator.newOclIterator_String(line) ;
     var N : int ; N := (st.next())->toInteger() ;
    var relays : Sequence(int) ; relays := ArrayDeque<int>.newArrayDeque() ;
    var duties : Sequence(int) ; duties := ArrayDeque<int>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < N do ( (     relays := relays->including(i) )  ;     i := i + 1 ) ; 
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    while (st.hasNext()) do (     var a : int ; a := (st.next())->toInteger() ;
     if (a mod 2 = 0) then (         var i : int ; i := 0 ; while i < a do ( (     relays := relays->including(relays->min()) )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < a do ( (     relays := relays->prepend(relays->last()) )  ;     i := i + 1 ) ) ;  
     duties := duties->including(relays->first()) ) ; 
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    while (st.hasNext()) do (     var q : int ; q := (st.next())->toInteger() ;
     OclFile["System.out"].println(if duties->includes(q) then 0 else 1 endif) ) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayDeque ;
import java.util.Deque ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      StringTokenizer st=new StringTokenizer(line);
      int N=Integer.parseInt(st.nextToken());
      Deque<Integer>relays=new ArrayDeque<Integer>();
      Deque<Integer>duties=new ArrayDeque<Integer>();
      for(int i=0 ; i<N ; i++){
        relays.offer(i);
      }
      st=new StringTokenizer(br.readLine());
      while(st.hasMoreTokens()){
        int a=Integer.parseInt(st.nextToken());
        if(a % 2==0){
          for(int i=0 ; i<a ; i++){
            relays.offer(relays.poll());
          }
        }
        else {
          for(int i=0 ; i<a ; i++){
            relays.offerFirst(relays.pollLast());
          }
        }
        duties.offer(relays.pollFirst());
      }
      StringBuilder sb=new StringBuilder();
      st=new StringTokenizer(br.readLine());
      while(st.hasMoreTokens()){
        int q=Integer.parseInt(st.nextToken());
        sb.append(duties.contains(q)? "0\n" : "1\n");
      }
      System.out.print(sb.toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var st : OclIterator ; st := OclIterator.newOclIterator_String(line) ;
     var N : int ; N := (st.next())->toInteger() ;
    var relays : Sequence(int) ; relays := ArrayDeque<int>.newArrayDeque() ;
    var duties : Sequence(int) ; duties := ArrayDeque<int>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < N do ( (     relays := relays->including(i) )  ;     i := i + 1 ) ; 
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    while (st.hasNext()) do (     var a : int ; a := (st.next())->toInteger() ;
     if (a mod 2 = 0) then (         var i : int ; i := 0 ; while i < a do ( (     relays := relays->including(relays->min()) )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < a do ( (     relays := relays->prepend(relays->last()) )  ;     i := i + 1 ) ) ;  
     duties := duties->including(relays->first()) ) ; 
    var sb : String ; sb := StringLib.newString() ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    while (st.hasNext()) do (     var q : int ; q := (st.next())->toInteger() ;
     sb := sb + StringLib.newString(if duties->includes(q) then "0\n" else "1\n" endif) ) ; 
    OclFile["System.out"].print(sb+"") ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MainClass {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    String position=scn.nextLine();
    if((position.charAt(1)=='1' || position.charAt(1)=='8')&&(position.charAt(0)=='a' || position.charAt(0)=='h')){
      System.out.println(3);
    }
    else if((position.charAt(1)=='1' || position.charAt(1)=='8')& !(position.charAt(0)=='a' || position.charAt(0)=='h')){
      System.out.println(5);
    }
    else if(!(position.charAt(1)=='1' || position.charAt(1)=='8')&(position.charAt(0)=='a' || position.charAt(0)=='h')){
      System.out.println(5);
    }
    else {
      System.out.println(8);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var position : String ; position := scn.nextLine() ;
     if ((position->at(1+1) = '1' or position->at(1+1) = '8') & (position->at(0+1) = 'a' or position->at(0+1) = 'h')) then (     OclFile["System.out"].println(3) ) else     if ((position->at(1+1) = '1' or position->at(1+1) = '8') & not((position->at(0+1) = 'a' or position->at(0+1) = 'h'))) then (     OclFile["System.out"].println(5) ) else     if (not((position->at(1+1) = '1' or position->at(1+1) = '8')) & (position->at(0+1) = 'a' or position->at(0+1) = 'h')) then (     OclFile["System.out"].println(5) ) else (     OclFile["System.out"].println(8) ) ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Dice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String z=sc.next();
    char c=z.charAt(0);
    char r=z.charAt(1);
    int m=0 ;
    if((c=='a' && r=='1')||(c=='h' && r=='1')||(c=='h' && r=='8')||(c=='a' && r=='8'))m=3 ;
    else if((c!='a' && r=='1')||(c!='h' && r=='1')||(c!='h' && r=='8')||(c!='a' && r=='8')||(c=='a' && r!='1')||(c=='h' && r!='1')||(c=='h' && r!='8')||(c=='a' && r!='8'))m=5 ;
    else m=8 ;
    System.out.println(m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Dice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var z : String ; z := sc.getCurrent() ;
    var c : String ; c := z->at(0+1) ;
    var r : String ; r := z->at(1+1) ;
    var m : int ; m := 0 ;
    if ((c = 'a' & r = '1') or (c = 'h' & r = '1') or (c = 'h' & r = '8') or (c = 'a' & r = '8')) then     m := 3 else     if ((c /= 'a' & r = '1') or (c /= 'h' & r = '1') or (c /= 'h' & r = '8') or (c /= 'a' & r = '8') or (c = 'a' & r /= '1') or (c = 'h' & r /= '1') or (c = 'h' & r /= '8') or (c = 'a' & r /= '8')) then     m := 5 else     m := 8 ; ;  ;  
    OclFile["System.out"].println(m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class K {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    String s=in.next();
    int ans=8 ;
    if(s.charAt(0)=='a' || s.charAt(0)=='h'){
      if(s.charAt(1)=='1' || s.charAt(1)=='8')ans-=5 ;
      else ans-=3 ;
    }
    else if(s.charAt(1)=='1' || s.charAt(1)=='8'){
      ans-=3 ;
    }
    out.println(ans);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class K {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : String ; s := in.getCurrent() ;
    var ans : int ; ans := 8 ;
    if (s->at(0+1) = 'a' or s->at(0+1) = 'h') then (     if (s->at(1+1) = '1' or s->at(1+1) = '8') then     ans := ans-(5) ; else     ans := ans-(3) ; ) else     if (s->at(1+1) = '1' or s->at(1+1) = '8') then (     ans := ans-(3) ) else skip ; ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int eggDrop(int n,int k){
    if(k==1 || k==0)return k ;
    if(n==1)return k ;
    int min=Integer.MAX_VALUE ;
    int x,res ;
    for(x=1 ; x<=k ; x++){
      res=Math.max(eggDrop(n-1,x-1),eggDrop(n,k-x));
      if(res<min)min=res ;
    }
    return min+1 ;
  }
  public static void main(String args[]){
    int n=2,k=10 ;
    System.out.print("Minimum number of "+"trials in worst case with "+n+" eggs and "+k+" floors is "+eggDrop(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation eggDrop( n : int, k : int) : int
  pre: true
  post: true
  activity: (     if (k = 1 or k = 0) then     return k else skip ; 
     if (n = 1) then     return k else skip ; 
    var min : int ; min := 2147483647 ;
    var x : int ;
    var res : int ;
        x := 1 ; while x <= k do ( (     res := Set{eggDrop(n - 1, x - 1), eggDrop(n, k - x)}->max() ; 
     if (res < min) then     min := res ; else skip )  ;     x := x + 1 ) ; 
    return min + 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
    var k : int ; k := 10 ;
     OclFile["System.out"].print("Minimum number of " + "trials in worst case with " + n + " eggs and " + k + " floors is " + eggDrop(n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class codeforces {
  public static void main(String[] args){
    Scanner ob=new Scanner(System.in);
    String s=ob.next();
    char d[]=s.toCharArray();
    int a=d[1]-'0' ;
    int b=d[0]-96 ;
    int temp1=a+1 ;
    int temp2=b+1 ;
    int temp3=a-1 ;
    int temp4=b-1 ;
    int c=0 ;
    if(temp1>8)c++;
    if(temp2>8)c++;
    if(temp3<1)c++;
    if(temp4<1)c++;
    if(c==2)System.out.println(3);
    else if(c==1)System.out.println(5);
    else System.out.println(8);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ob : OclFile ; ob := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := ob.getCurrent() ;
    var d : Sequence(String) ; d := s->characters() ;
    var a : int ; a := d[1+1] - ('0')->char2byte() ;
    var b : int ; b := d[0+1] - 96 ;
    var temp1 : int ; temp1 := a + 1 ;
    var temp2 : int ; temp2 := b + 1 ;
    var temp3 : int ; temp3 := (a)->char2byte() - 1 ;
    var temp4 : int ; temp4 := b - 1 ;
    var c : int ; c := 0 ;
    if (temp1 > 8) then     c := c + 1 ; else skip ; 
    if (temp2 > 8) then     c := c + 1 ; else skip ; 
    if (temp3 < 1) then     c := c + 1 ; else skip ; 
    if (temp4 < 1) then     c := c + 1 ; else skip ; 
    if (c = 2) then     OclFile["System.out"].println(3) else     if (c = 1) then     OclFile["System.out"].println(5) else     OclFile["System.out"].println(8) ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF150B extends PrintWriter {
  CF150B(){
    super(System.out,true);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    CF150B o=new CF150B();
    o.main();
    o.flush();
  }
  static final int MD=1000000007 ;
  long power(int a,int k){
    return k==0 ? 1 : power(a,k-1)*a % MD ;
  }
  void main(){
    int n=sc.nextInt();
    int m=sc.nextInt();
    int k=sc.nextInt();
    println(k==1 || k>n ? power(m,n): k==n ? power(m,(n+1)/2): k % 2==0 ? m : m*m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF150B extends OclFile {
   static operation newCF150B() : CF150B
  pre: true
  post: true
  activity:
  ( var self : CF150B ;
    self := createCF150B();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"], true) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : CF150B ; o := CF150B.newCF150B() ;
     o.main() ; 
     o.flush() );
  static    attribute MD : int := 1000000007;
   operation power( a : int, k : int) : long
  pre: true
  post: true
  activity: (     return if k = 0 then 1 else power(a, k - 1) * a mod MD endif );
   operation main() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     execute println(if k = 1 or k > n then power(m, n) else if k = n then power(m, (n + 1) / 2) else if k mod 2 = 0 then m else m * m endif endif endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class F {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    StringTokenizer st=new StringTokenizer(sc.nextLine(),".|!|?");
    boolean good=true ;
    int ans=0,rem=0 ;
    for(int i=0 ; st.hasMoreTokens(); ++i){
      int len=st.nextToken().length()+1 ;
      if(len>rem){
++ans ;
        if(i!=0)--len ;
        rem=n ;
      }
      rem-=len ;
      good &=rem>=0 ;
    }
    out.println(good ? ans : "Impossible");
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class F {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String_String(sc.nextLine(), ".|!|?") ;
    var good : boolean ; good := true ;
    var ans : int ; ans := 0 ;
    var rem : int ; rem := 0 ;
        var i : int ; i := 0 ; while st.hasNext() do ( (     var len : int ; len := st.next()->size() + 1 ;
     if (len > rem) then (     ans := ans + 1 ; 
     if (i /= 0) then     len := len - 1 ; else skip ; 
     rem := n ) else skip ; 
     rem := rem-(len) ; 
     good := MathLib.bitwiseAnd(good, rem >= 0) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int supermarket=in.nextInt();
    int kilo=in.nextInt();
    double result=0 ;
    double Max=Integer.MAX_VALUE ;
    for(int i=0 ; i<supermarket ; i++){
      double a=in.nextInt();
      double b=in.nextInt();
      result=relation(a,b,kilo);
      if(Max>result){
        Max=result ;
      }
    }
    System.out.printf("%.8f",Max);
  }
  public static double relation(double a,double b,double kilo){
    double res=(kilo*a)/b ;
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var supermarket : int ; supermarket := in.getCurrent()->toInteger() ;
    var kilo : int ; kilo := in.getCurrent()->toInteger() ;
    var result : double ; result := 0 ;
    var Max : double ; Max := 2147483647 ;
        var i : int ; i := 0 ; while i < supermarket do ( (     var a : double ; a := in.getCurrent()->toInteger() ;
     var b : double ; b := in.getCurrent()->toInteger() ;
     result := relation(a, b, kilo) ; 
     if (Max > result) then (     Max := result ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.8f", Max) ; 
 );
  static   operation relation( a : double, b : double, kilo : double) : double
  pre: true
  post: true
  activity: (     var res : double ; res := (kilo * a) / b ;
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class P919A {
  public static void main(String[] args)throws IOException {
    BufferedReader io=new BufferedReader(new InputStreamReader(System.in));
    String[] nm=io.readLine().split(" ");
    Integer n=Integer.valueOf(nm[0]);
    Double m=Double.valueOf(nm[1]);
    Double rs=Double.MAX_VALUE ;
    while(n>0){
      n--;
      String[] ab=io.readLine().split(" ");
      Double a=Double.valueOf(ab[0]);
      Double b=Double.valueOf(ab[1]);
      if(rs.compareTo(a/b)>0){
        rs=(double)(a/b);
      }
    }
    System.out.println(m*rs);
  }
}
------------------------------------------------------------
OCL File:
---------
 class P919A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var nm : Sequence(String) ; nm := io.readLine()->split(" ") ;
    var n : int ; n := (nm[0+1])->toInteger() ;
    var m : double ; m := (nm[1+1])->toReal() ;
    var rs : double ; rs := (2 - 2->pow(-52))*(2->pow(1023)) ;
    while (n > 0) do (     n := n - 1 ; 
     var ab : Sequence(String) ; ab := io.readLine()->split(" ") ;
    var a : double ; a := (ab[0+1])->toReal() ;
    var b : double ; b := (ab[1+1])->toReal() ;
    if (rs->compareTo(a / b) > 0) then (     rs := (a / b)->oclAsType(double) ) else skip ; 
 ) ; 
    OclFile["System.out"].println(m * rs) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigDecimal ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    double minnum=0,y=0 ;
    int[][] a=new int[n][2];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<2 ; j++){
        a[i][j]=in.nextInt();
      }
    }
    minnum=1.0*a[0][0]/a[0][1];
    for(int i=1 ; i<n ; i++){
      y=1.0*a[i][0]/a[i][1];
      if(y<minnum){
        minnum=y ;
      }
    }
    System.out.printf("%.8f",minnum*m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var minnum : double ; minnum := 0 ;
    var y : double ; y := 0 ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 2 do ( (     a[i+1][j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    minnum := 1.0 * a[0+1][0+1] / a[0+1][1+1] ; 
        var i : int ; i := 1 ; while i < n do ( (     y := 1.0 * a[i+1][0+1] / a[i+1][1+1] ; 
     if (y < minnum) then (     minnum := y ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.8f", minnum * m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Supermarket_919A {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner scan=new Scanner(System.in);
    int supermaktesNbr=scan.nextInt();
    int KilosNbr=scan.nextInt();
    double lessKilos=10000,tempKilos ;
    for(int i=0 ; i<supermaktesNbr ; i++){
      tempKilos=(scan.nextDouble()/scan.nextDouble());
      if(tempKilos<lessKilos)lessKilos=tempKilos ;
    }
    System.out.println(lessKilos*KilosNbr);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Supermarket_919A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var supermaktesNbr : int ; supermaktesNbr := scan.getCurrent()->toInteger() ;
    var KilosNbr : int ; KilosNbr := scan.getCurrent()->toInteger() ;
    var lessKilos : double ; lessKilos := 10000 ;
    var tempKilos : double ;
        var i : int ; i := 0 ; while i < supermaktesNbr do ( (     tempKilos := (scan.getCurrent()->toReal() / scan.getCurrent()->toReal()) ; 
     if (tempKilos < lessKilos) then     lessKilos := tempKilos ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(lessKilos * KilosNbr) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int maxEvenSubarray(int array[],int N){
    int ans=0 ;
    int count=0 ;
    for(int i=0 ; i<array.length ; i++){
      if(array[i] % 2==0){
        count++;
        ans=Math.max(ans,count);
      }
      else {
        count=0 ;
      }
    }
    ans=Math.max(ans,count);
    return ans ;
  }
  public static void main(String args[]){
    int arr[]={
      9,8,5,4,4,4,2,4,1 };
      int N=arr.length ;
      System.out.println(maxEvenSubarray(arr,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxEvenSubarray( array : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < array->size() do ( (     if (array[i+1] mod 2 = 0) then (     count := count + 1 ; 
     ans := Set{ans, count}->max() ) else (     count := 0 ) )  ;     i := i + 1 ) ; 
    ans := Set{ans, count}->max() ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{9,8,5,4,4,4,2,4,1} ;
     var N : int ; N := arr->size() ;
     OclFile["System.out"].println(maxEvenSubarray(arr, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class www {
  public static void main(String[] args){
    int n=0,k=0,num,LuckyNumber=0,counter=0 ;
    int digits=0 ;
    Scanner input=new Scanner(System.in);
    n=input.nextInt();
    k=input.nextInt();
    for(int i=0 ; i<n ; i++){
      num=input.nextInt();
      while(num!=0){
        digits=num % 10 ;
        num=num/10 ;
        if(digits==7 || digits==4)LuckyNumber++;
      }
      if(LuckyNumber<=k)counter++;
      LuckyNumber=0 ;
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class www {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 0 ;
    var k : int ; k := 0 ;
    var num : int ;
    var LuckyNumber : int ; LuckyNumber := 0 ;
    var counter : int ; counter := 0 ;
     var digits : int ; digits := 0 ;
    var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := input.getCurrent()->toInteger() ; 
    k := input.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     num := input.getCurrent()->toInteger() ; 
     while (num /= 0) do (     digits := num mod 10 ; 
     num := num / 10 ; 
     if (digits = 7 or digits = 4) then     LuckyNumber := LuckyNumber + 1 ; else skip ) ; 
     if (LuckyNumber <= k) then     counter := counter + 1 ; else skip ; 
     LuckyNumber := 0 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      int num=sc.nextInt();
      int count=0 ;
      while(num>0){
        int r=num % 10 ;
        if(r==4 || r==7){
          count++;
        }
        num=num/10 ;
      }
      if(count<=k){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := sc.getCurrent()->toInteger() ;
     var count : int ; count := 0 ;
     while (num > 0) do (     var r : int ; r := num mod 10 ;
     if (r = 4 or r = 7) then (     count := count + 1 ) else skip ; 
     num := num / 10 ) ; 
     if (count <= k) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class RomaAndLuckyNumbers {
  public static boolean check(int n,int k){
    int count=0 ;
    while(n!=0){
      int d=n % 10 ;
      n/=10 ;
      if(d==4 || d==7)count++;
    }
    if(count<=k)return true ;
    return false ;
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      if(check(a,k))count++;
    }
    System.out.print(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class RomaAndLuckyNumbers {
  static   operation check( n : int, k : int) : boolean
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n /= 0) do (     var d : int ; d := n mod 10 ;
     n := n/(10) ; 
     if (d = 4 or d = 7) then     count := count + 1 ; else skip ) ; 
     if (count <= k) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (check(a, k)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),s=0 ;
    int[] p=new int[n];
    for(int i=0 ; i<n ; i++){
      p[i]=in.nextInt();
      s+=p[i];
    }
    Arrays.sort(p);
    for(int i=0 ; i<n ; i++){
      if(s % 2==0 && p[i] % 2==1){
        s-=p[i];
        break ;
      }
    }
    System.out.print(s % 2==0 ? 0 : s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : int ; s := 0 ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := in.getCurrent()->toInteger() ; 
     s := s+(p[i+1]) )  ;     i := i + 1 ) ; 
    p := p->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (s mod 2 = 0 & p[i+1] mod 2 = 1) then (     s := s-(p[i+1]) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(if s mod 2 = 0 then 0 else s endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class RomaAndLuckyNumber {
  public static int getLuckyNumber(int n,int k,String[] a){
    int counter=0 ;
    for(int i=0 ; i<a.length ; i++){
      int fourSevenCounter=0 ;
      for(int j=0 ; j<a[i] .length(); j++){
        if((a[i] .charAt(j))=='4' ||(a[i] .charAt(j))=='7'){
          fourSevenCounter++;
        }
      }
      if(fourSevenCounter<=k){
        counter++;
      }
    }
    return counter ;
  }
  public static void main(String[] args){
    Scanner obj=new Scanner(System.in);
    int n=obj.nextInt();
    int k=obj.nextInt();
    String[] a=new String[n];
    for(int j=0 ; j<n ; j++){
      a[j]=obj.next();
    }
    System.out.println(getLuckyNumber(n,k,a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class RomaAndLuckyNumber {
  static   operation getLuckyNumber( n : int, k : int, a : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var counter : int ; counter := 0 ;
         var i : int ; i := 0 ; while i < a->size() do ( (     var fourSevenCounter : int ; fourSevenCounter := 0 ;
         var j : int ; j := 0 ; while j < a[i+1]->size() do ( (     if ((a[i+1]->at(j+1)) = '4' or (a[i+1]->at(j+1)) = '7') then (     fourSevenCounter := fourSevenCounter + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (fourSevenCounter <= k) then (     counter := counter + 1 ) else skip )  ;     i := i + 1 ) ; 
     return counter );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : OclFile ; obj := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := obj.getCurrent()->toInteger() ;
    var k : int ; k := obj.getCurrent()->toInteger() ;
    var a : Sequence(String) ; a := Integer.subrange(1,n)->collect(null) ;
        var j : int ; j := 0 ; while j < n do ( (     a[j+1] := obj.getCurrent() )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(getLuckyNumber(n, k, a)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class TextMessaging {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String input=br.readLine();
    int max=-1 ;
    int[] msgLength=new int[input.length()/2];
    int count=0 ;
    int idx=0 ;
    for(int i=0 ; i<input.length(); i++){
      char c=input.charAt(i);
      if(c=='.' || c=='?' || c=='!'){
        msgLength[idx++]=++count ;
        if(count>max)max=count ;
        i++;
        count=0 ;
      }
      else count++;
    }
    if(max>n)System.out.println("Impossible");
    else {
      int ans=0 ;
      for(int i=0 ; i<idx ; i++){
        int l=msgLength[i];
        while(i<idx-1 && l+msgLength[i+1]+1<=n){
          l+=msgLength[i+1]+1 ;
          i++;
        }
        ans++;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TextMessaging {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var input : String ; input := br.readLine() ;
    var max : int ; max := -1 ;
    var msgLength : Sequence(int) ; msgLength := Integer.subrange(1,input->size() / 2)->collect(0) ;
    var count : int ; count := 0 ;
    var idx : int ; idx := 0 ;
        var i : int ; i := 0 ; while i < input->size() do ( (     var c : String ; c := input->at(i+1) ;
     if (c = '.' or c = '?' or c = '!') then (          count := count + 1 ;
 msgLength[idx+1] := count  ; idx := idx + 1  ; 
     if (count > max) then     max := count ; else skip ; 
     i := i + 1 ; 
     count := 0 ) else     count := count + 1 ; )  ;     i := i + 1 ) ; 
    if (max > n) then     OclFile["System.out"].println("Impossible") else (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < idx do ( (     var l : int ; l := msgLength[i+1] ;
     while (i < idx - 1 & l + msgLength[i + 1+1] + 1 <= n) do (     l := l+(msgLength[i + 1+1] + 1) ; 
     i := i + 1 ) ; 
     ans := ans + 1 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder();
    int n=fs.nextInt(),k=fs.nextInt();
    int ch=0 ;
    for(int i=0 ; i<n ; i++){
      int a=fs.nextInt();
      int d=0 ;
      while(a>0){
        if(a % 10==7 || a % 10==4)d++;
        a/=10 ;
      }
      if(d<=k)ch++;
    }
    out.println(ch);
    out.close();
  }
  static int isPerfectSquare(int x){
    if(x>=0){
      int sr=(int)Math.sqrt(x);
      if((sr*sr)==x)return sr ;
      else return 0 ;
    }
    return 0 ;
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    Long[] readArray(int n){
      Long[] a=new Long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := fs.nextInt() ;
    var k : int ; k := fs.nextInt() ;
    var ch : int ; ch := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := fs.nextInt() ;
     var d : int ; d := 0 ;
     while (a > 0) do (     if (a mod 10 = 7 or a mod 10 = 4) then     d := d + 1 ; else skip ; 
     a := a/(10) ) ; 
     if (d <= k) then     ch := ch + 1 ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation isPerfectSquare( x : int) : int
  pre: true
  post: true
  activity: (     if (x >= 0) then (     var sr : int ; sr := (x)->sqrt()->oclAsType(int) ;
     if ((sr * sr) = x) then     return sr else     return 0 ) else skip ; 
     return 0 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] a={
      1200,1400,1600,1900,2300,2400,2600,3000 };
      int k=sc.nextInt();
      for(int b : a){
        if(b>k){
          System.out.println(b);
          break ;
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Sequence{1200,1400,1600,1900,2300,2400,2600,3000} ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     for (b : a) do ( (     if (b > k) then (     OclFile["System.out"].println(b) ; 
     break ) else skip )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int r=scan.nextInt();
    if(r<1200)System.out.println(1200);
    else if(r<1400)System.out.println(1400);
    else if(r<1600)System.out.println(1600);
    else if(r<1900)System.out.println(1900);
    else if(r<2100)System.out.println(2100);
    else if(r<2300)System.out.println(2300);
    else if(r<2400)System.out.println(2400);
    else if(r<2600)System.out.println(2600);
    else if(r<3000)System.out.println(3000);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := scan.getCurrent()->toInteger() ;
     if (r < 1200) then     OclFile["System.out"].println(1200) ; else     if (r < 1400) then     OclFile["System.out"].println(1400) else     if (r < 1600) then     OclFile["System.out"].println(1600) else     if (r < 1900) then     OclFile["System.out"].println(1900) else     if (r < 2100) then     OclFile["System.out"].println(2100) else     if (r < 2300) then     OclFile["System.out"].println(2300) else     if (r < 2400) then     OclFile["System.out"].println(2400) else     if (r < 2600) then     OclFile["System.out"].println(2600) else     if (r < 3000) then     OclFile["System.out"].println(3000) ; else skip ; ;  ;  ;  ;  ;  ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MikeSeq {
  public static void main(String[] args){
    Scanner ishika=new Scanner(System.in);
    int n=ishika.nextInt();
    if(n>=2600)System.out.print("3000");
    else if(n>=2400)System.out.print("2600");
    else if(n>=2300)System.out.print("2400");
    else if(n>=2100)System.out.print("2300");
    else if(n>=1900)System.out.print("2100");
    else if(n>=1600)System.out.print("1600");
    else if(n>=1400)System.out.print("1600");
    else if(n>=1200)System.out.print("1400");
    else System.out.print("1200");
  }
}
------------------------------------------------------------
OCL File:
---------
 class MikeSeq {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ishika : OclFile ; ishika := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := ishika.getCurrent()->toInteger() ;
     if (n >= 2600) then     OclFile["System.out"].print("3000") ; else     if (n >= 2400) then     OclFile["System.out"].print("2600") else     if (n >= 2300) then     OclFile["System.out"].print("2400") else     if (n >= 2100) then     OclFile["System.out"].print("2300") else     if (n >= 1900) then     OclFile["System.out"].print("2100") else     if (n >= 1600) then     OclFile["System.out"].print("1600") else     if (n >= 1400) then     OclFile["System.out"].print("1600") else     if (n >= 1200) then     OclFile["System.out"].print("1400") else     OclFile["System.out"].print("1200") ; ;  ;  ;  ;  ;  ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=Integer.parseInt(scan.nextLine());
    int[] ranks={
      1200,1400,1600,1900,2100,2300,2400,2600,3000 };
      boolean found=false ;
      for(int i=0 ; i<ranks.length && ! found ; i++){
        if(n<ranks[i]){
          System.out.println(ranks[i]);
          found=true ;
        }
      }
      scan.close();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (scan.nextLine())->toInteger() ;
    var ranks : Sequence(int) ; ranks := Sequence{1200,1400,1600,1900,2100,2300,2400,2600,3000} ;
    var found : boolean ; found := false ;
        var i : int ; i := 0 ; while i < ranks->size() & not(found) do ( (     if (n < ranks[i+1]) then (     OclFile["System.out"].println(ranks[i+1]) ; 
     found := true ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String getSubSeq(String s,int n){
    String res="" ;
    int cr=0 ;
    while(cr<n){
      char mx=s.charAt(cr);
      for(int i=cr+1 ; i<n ; i++){
        mx=(char)Math.max(mx,s.charAt(i));
      }
      int lst=cr ;
      for(int i=cr ; i<n ; i++){
        if(s.charAt(i)==mx){
          res+=s.charAt(i);
          lst=i ;
        }
      }
      cr=lst+1 ;
    }
    return res ;
  }
  public static void main(String[] args){
    String s="geeksforgeeks" ;
    int n=s.length();
    System.out.println(getSubSeq(s,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getSubSeq( s : String, n : int) : String
  pre: true
  post: true
  activity: (     var res : String ; res := "" ;
     var cr : int ; cr := 0 ;
     while (cr < n) do (     var mx : String ; mx := s->at(cr+1) ;
         var i : int ; i := cr + 1 ; while i < n do ( (     mx := Set{mx, s->at(i+1)}->max()->oclAsType(String) )  ;     i := i + 1 ) ; 
    var lst : int ; lst := cr ;
        var i : int ; i := cr ; while i < n do ( (     if (s->at(i+1) = mx) then (     res := res+(s->at(i+1)) ; 
     lst := i ) else skip )  ;     i := i + 1 ) ; 
    cr := lst + 1 ; 
 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].println(getSubSeq(s, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
public class GfG {
  static int countSteps(int n){
    int steps=0 ;
    while(n>0){
      int largest=(int)Math.sqrt(n);
      n-=(largest*largest);
      steps++;
    }
    return steps ;
  }
  public static void main(String[] args){
    int n=85 ;
    System.out.println(countSteps(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation countSteps( n : int) : int
  pre: true
  post: true
  activity: (     var steps : int ; steps := 0 ;
     while (n > 0) do (     var largest : int ; largest := (n)->sqrt()->oclAsType(int) ;
     n := n-((largest * largest)) ; 
     steps := steps + 1 ) ; 
     return steps );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 85 ;
     OclFile["System.out"].println(countSteps(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class PetyaAndstaircases {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int count=0 ;
    int n=sc.nextInt();
    int m=sc.nextInt();
    int arr[]=new int[m+1];
    for(int i=0 ; i<m ; i++){
      arr[i]=sc.nextInt();
      if(arr[0]==1 || arr[i]==n){
        System.out.print("NO");
        return ;
      }
    }
    Arrays.sort(arr);
    for(int i=0 ; i<m-1 ; i++){
      if(arr[i]+1==arr[i+1] && arr[i]+2==arr[i+2]){
        count++;
      }
    }
    if(count>0){
      System.out.print("NO");
    }
    else {
      System.out.print("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PetyaAndstaircases {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := 0 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,m + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr[0+1] = 1 or arr[i+1] = n) then (     OclFile["System.out"].print("NO") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < m - 1 do ( (     if (arr[i+1] + 1 = arr[i + 1+1] & arr[i+1] + 2 = arr[i + 2+1]) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (count > 0) then (     OclFile["System.out"].print("NO") ) else (     OclFile["System.out"].print("YES") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Petya362B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int dirt=in.nextInt();
    ArrayList list=new ArrayList<Integer>();
    int num=0 ;
    for(int i=0 ; i<dirt ; i++){
      num=in.nextInt();
      list.add(num);
      if(num==1 || num==n){
        System.out.println("NO");
        return ;
      }
    }
    Collections.sort(list);
    for(int i=0 ; i<dirt-2 ; i++){
      if((int)list.get(i+2)-(int)list.get(i)==2){
        System.out.println("NO");
        return ;
      }
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Petya362B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var dirt : int ; dirt := in.getCurrent()->toInteger() ;
    var list : Sequence ; list := Sequence{} ;
    var num : int ; num := 0 ;
        var i : int ; i := 0 ; while i < dirt do ( (     num := in.getCurrent()->toInteger() ; 
     list := list->including(num) ; 
     if (num = 1 or num = n) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
        var i : int ; i := 0 ; while i < dirt - 2 do ( (     if (list->at(i + 2+1)->oclAsType(int) - list->at(i+1)->oclAsType(int) = 2) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),s=0 ;
    int[] p=new int[n];
    for(int i=0 ; i<n ; i++){
      p[i]=in.nextInt();
      s+=p[i];
    }
    Arrays.sort(p);
    Par : for(int i=0 ;
    i<n ;
    i++){
      if(s % 2!=0)break ;
      else {
        int s2=s ;
        for(int j=0 ; j<n ; j++){
          if((s-p[j])% 2!=0){
            s-=p[j];
            break Par ;
          }
        }
        if(s2==s)s=0 ;
      }
    }
    System.out.print(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : int ; s := 0 ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := in.getCurrent()->toInteger() ; 
     s := s+(p[i+1]) )  ;     i := i + 1 ) ; 
    p := p->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (s mod 2 /= 0) then     break else (     var s2 : int ; s2 := s ;
         var j : int ; j := 0 ; while j < n do ( (     if ((s - p[j+1]) mod 2 /= 0) then (     s := s-(p[j+1]) ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (s2 = s) then     s := 0 ; else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h1=sc.nextInt();
    int a1=sc.nextInt();
    int c1=sc.nextInt();
    int h2=sc.nextInt();
    int a2=sc.nextInt();
    List<String>list=beat(h1,a1,c1,h2,a2);
    System.out.println(list.size());
    for(String out : list){
      System.out.println(out);
    }
  }
  public static List<String>beat(int h1,int a1,int c1,int h2,int a2){
    List<String>res=new ArrayList<>();
    while(h2>0){
      if(h2<=a1){
        res.add("STRIKE");
        h1-=a2 ;
        h2-=a1 ;
      }
      else {
        if(h1<=a2){
          res.add("HEAL");
          h1+=c1 ;
          h1-=a2 ;
        }
        else {
          res.add("STRIKE");
          h1-=a2 ;
          h2-=a1 ;
        }
      }
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h1 : int ; h1 := sc.getCurrent()->toInteger() ;
    var a1 : int ; a1 := sc.getCurrent()->toInteger() ;
    var c1 : int ; c1 := sc.getCurrent()->toInteger() ;
    var h2 : int ; h2 := sc.getCurrent()->toInteger() ;
    var a2 : int ; a2 := sc.getCurrent()->toInteger() ;
    var list : Sequence(String) ; list := beat(h1, a1, c1, h2, a2) ;
    OclFile["System.out"].println(list->size()) ; 
    for (out : list) do ( (     OclFile["System.out"].println(out) )  ) ; 
 );
  static   operation beat( h1 : int, a1 : int, c1 : int, h2 : int, a2 : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var res : Sequence(String) ; res := Sequence{} ;
     while (h2 > 0) do (     if (h2 <= a1) then (     res := res->including("STRIKE") ; 
     h1 := h1-(a2) ; 
     h2 := h2-(a1) ) else (     if (h1 <= a2) then (     res := res->including("HEAL") ; 
     h1 := h1+(c1) ; 
     h1 := h1-(a2) ) else (     res := res->including("STRIKE") ; 
     h1 := h1-(a2) ; 
     h2 := h2-(a1) ) ) ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.Integer.parseInt ;
public class MikeandShortcuts {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder out=new StringBuilder();
    StringTokenizer tk ;
    int n=parseInt(in.readLine());
    int[] a=new int[n];
    tk=new StringTokenizer(in.readLine());
    for(int i=0 ; i<n ; i++)a[i]=parseInt(tk.nextToken())-1 ;
    List<Integer>[] g=new List[n];
    for(int i=0 ; i<n ; i++)g[i]=new ArrayList<>();
    for(int i=0 ; i<n-1 ; i++){
      if(a[i]!=i)g[i] .add(a[i]);
      g[i] .add(i+1);
      g[i+1] .add(i);
    }
    if(a[n-1]!=n-1)g[n-1] .add(a[n-1]);
    int[] dist=new int[n];
    Arrays.fill(dist,-1);
    dist[0]=0 ;
    Queue<Integer>q=new LinkedList<>();
    q.add(0);
    while(! q.isEmpty()){
      int u=q.remove();
      for(int v : g[u]){
        if(dist[v]==-1){
          q.add(v);
          dist[v]=dist[u]+1 ;
        }
      }
    }
    out.append(dist[0]);
    for(int i=1 ; i<n ; i++)out.append(" ").append(dist[i]);
    System.out.println(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MikeandShortcuts {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : String ; out := StringLib.newString() ;
    var tk : OclIterator ;
    var n : int ; n := parseInt(in.readLine()) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    tk := OclIterator.newOclIterator_String(in.readLine()) ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := parseInt(tk.next()) - 1 ;  ;     i := i + 1 ) ; 
    var g : Sequence(Sequence(int)) ; g := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     g[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (a[i+1] /= i) then     g[i+1]->excludes(a[i+1]) ; else skip ; 
     g[i+1]->excludes(i + 1) ; 
     g[i + 1+1]->excludes(i) )  ;     i := i + 1 ) ; 
    if (a[n - 1+1] /= n - 1) then     g[n - 1+1]->excludes(a[n - 1+1]) ; else skip ; 
    var dist : Sequence(int) ; dist := Integer.subrange(1,n)->collect(0) ;
    dist := dist->collect(-1) ; 
    dist[0+1] := 0 ; 
    var q : Sequence(int) ; q := Sequence{} ;
    q := q->including(0) ; 
    while (not(q->isEmpty())) do (     var u : int ; u := q.remove() ;
     for (v : g[u+1]) do ( (     if (dist[v+1] = -1) then (     q := q->including(v) ; 
     dist[v+1] := dist[u+1] + 1 ) else skip )  ) ) ; 
    out := out + StringLib.newString(dist[0+1]) ; 
        var i : int ; i := 1 ; while i < n do (     out := out + StringLib.newString(" ") + StringLib.newString(dist[i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeforces362B {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    int m=Integer.parseInt(st.nextToken());
    if(m>0){
      int[] arr=new int[m];
      PriorityQueue<Integer>pq=new PriorityQueue<>();
      st=new StringTokenizer(br.readLine());
      for(int i=0 ; i<m ; i++){
        pq.add(Integer.parseInt(st.nextToken()));
      }
      for(int i=0 ; i<m ; i++){
        arr[i]=pq.poll();
      }
      boolean ok=true ;
      if(arr[0]==1 || arr[m-1]==n){
        ok=false ;
      }
      int last=arr[0]-1 ;
      int currLength=0 ;
      for(int i=0 ; i<m ; i++){
        if(arr[i]==last+1){
          currLength++;
        }
        else {
          currLength=1 ;
        }
        last=arr[i];
        if(currLength>2){
          ok=false ;
        }
      }
      if(ok){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    else {
      System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces362B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    if (m > 0) then (     var arr : Sequence(int) ; arr := Integer.subrange(1,m)->collect(0) ;
     var pq : Sequence(int) ; pq := Sequence{} ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < m do ( (     pq := pq->including((st.next())->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     arr[i+1] := pq->min() ;     pq := pq->sort()->tail() )  ;     i := i + 1 ) ; 
    var ok : boolean ; ok := true ;
    if (arr[0+1] = 1 or arr[m - 1+1] = n) then (     ok := false ) else skip ; 
    var last : int ; last := arr[0+1] - 1 ;
    var currLength : int ; currLength := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     if (arr[i+1] = last + 1) then (     currLength := currLength + 1 ) else (     currLength := 1 ) ;  
     last := arr[i+1] ; 
     if (currLength > 2) then (     ok := false ) else skip )  ;     i := i + 1 ) ; 
    if (ok) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) else (     OclFile["System.out"].println("YES") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Mridul8 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    if(m==0){
      System.out.println("YES");
    }
    else {
      int[] arr=new int[m];
      int i=-1 ;
      while(i!=m-1){
        i=i+1 ;
        arr[i]=sc.nextInt();
      }
      Arrays.sort(arr);
      i=-1 ;
      if(arr[0]==1 || arr[m-1]==n){
        System.out.println("NO");
      }
      else {
        i=-1 ;
        int no=0 ;
        while(i<m-3){
          i=i+1 ;
          if(arr[i+1]-arr[i]==1 && arr[i+2]-arr[i+1]==1){
            no=1 ;
            System.out.println("NO");
            break ;
          }
        }
        if(no==0){
          System.out.println("YES");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mridul8 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     if (m = 0) then (     OclFile["System.out"].println("YES") ) else (     var arr : Sequence(int) ; arr := Integer.subrange(1,m)->collect(0) ;
     var i : int ; i := -1 ;
    while (i /= m - 1) do (     i := i + 1 ; 
     arr[i+1] := sc.getCurrent()->toInteger() ) ; 
    arr := arr->sort() ; 
    i := -1 ; 
    if (arr[0+1] = 1 or arr[m - 1+1] = n) then (     OclFile["System.out"].println("NO") ) else (     i := -1 ; 
     var no : int ; no := 0 ;
     while (i < m - 3) do (     i := i + 1 ; 
     if (arr[i + 1+1] - arr[i+1] = 1 & arr[i + 2+1] - arr[i + 1+1] = 1) then (     no := 1 ; 
     OclFile["System.out"].println("NO") ; 
     break ) else skip ) ; 
     if (no = 0) then (     OclFile["System.out"].println("YES") ) else skip ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static boolean isDefeat(String s1,String s2,int n){
    for(int i=0 ; i<n ; i++){
      if((s1.charAt(i)=='0' && s2.charAt(i)=='1')||(s1.charAt(i)=='1' && s2.charAt(i)=='0'))continue ;
      else if((s1.charAt(i)=='0' && s2.charAt(i)=='Z')||(s1.charAt(i)=='Z' && s2.charAt(i)=='0'))continue ;
      else {
        return true ;
      }
    }
    return false ;
  }
  public static void main(String[] args){
    String s1=("01001101ZZ");
    String s2=("10Z1001000");
    int n=10 ;
    if(isDefeat(s1,s2,n))System.out.println("Defeat");
    else System.out.println("Victory");
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation isDefeat( s1 : String, s2 : String, n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if ((s1->at(i+1) = '0' & s2->at(i+1) = '1') or (s1->at(i+1) = '1' & s2->at(i+1) = '0')) then     continue else     if ((s1->at(i+1) = '0' & s2->at(i+1) = 'Z') or (s1->at(i+1) = 'Z' & s2->at(i+1) = '0')) then     continue else (     return true ) ;  )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := ("01001101ZZ") ;
     var s2 : String ; s2 := ("10Z1001000") ;
     var n : int ; n := 10 ;
     if (isDefeat(s1, s2, n)) then     OclFile["System.out"].println("Defeat") ; else     OclFile["System.out"].println("Victory") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static int first(int arr[],int low,int high,int x,int n){
    if(high>=low){
      int mid=low+(high-low)/2 ;
      if((mid==0 || x>arr[mid-1])&& arr[mid]==x)return mid ;
      else if(x>arr[mid])return first(arr,(mid+1),high,x,n);
      else return first(arr,low,(mid-1),x,n);
    }
    return-1 ;
  }
  public static int last(int arr[],int low,int high,int x,int n){
    if(high>=low){
      int mid=low+(high-low)/2 ;
      if((mid==n-1 || x<arr[mid+1])&& arr[mid]==x)return mid ;
      else if(x<arr[mid])return last(arr,low,(mid-1),x,n);
      else return last(arr,(mid+1),high,x,n);
    }
    return-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,2,2,2,3,4,7,8,8 };
      int n=arr.length ;
      int x=8 ;
      System.out.println("First Occurrence="+first(arr,0,n-1,x,n));
      System.out.println("Last Occurrence="+last(arr,0,n-1,x,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation first( arr : Sequence(int), low : int, high : int, x : int, n : int) : int
  pre: true
  post: true
  activity: (     if (high >= low) then (     var mid : int ; mid := low + (high - low) / 2 ;
     if ((mid = 0 or x > arr[mid - 1+1]) & arr[mid+1] = x) then     return mid else     if (x > arr[mid+1]) then     return first(arr, (mid + 1), high, x, n) else     return first(arr, low, (mid - 1), x, n) ;  ) else skip ; 
     return -1 );
  static   operation last( arr : Sequence(int), low : int, high : int, x : int, n : int) : int
  pre: true
  post: true
  activity: (     if (high >= low) then (     var mid : int ; mid := low + (high - low) / 2 ;
     if ((mid = n - 1 or x < arr[mid + 1+1]) & arr[mid+1] = x) then     return mid else     if (x < arr[mid+1]) then     return last(arr, low, (mid - 1), x, n) else     return last(arr, (mid + 1), high, x, n) ;  ) else skip ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,2,2,2,3,4,7,8,8} ;
     var n : int ; n := arr->size() ;
    var x : int ; x := 8 ;
    OclFile["System.out"].println("First Occurrence=" + first(arr, 0, n - 1, x, n)) ; 
    OclFile["System.out"].println("Last Occurrence=" + last(arr, 0, n - 1, x, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class geeks {
  public static int fibonacciArray(int[] arr,int n){
    Set<Integer>s=new HashSet<Integer>();
    int a=1,b=1 ;
    int c ;
    s.add(a);
    if(n>2)s.add(b);
    for(int i=0 ; i<n-2 ; i++){
      c=a+b ;
      s.add(c);
      a=b ;
      b=c ;
    }
    for(int i=0 ; i<n ; i++){
      if(s.contains(arr[i]))s.remove(arr[i]);
    }
    return s.size();
  }
  public static void main(String[] args){
    int[] arr={
      3,1,21,4,2,1,8,9 };
      int n=arr.length ;
      System.out.print(fibonacciArray(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class geeks {
  static   operation fibonacciArray( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
     var a : int ; a := 1 ;
    var b : int ; b := 1 ;
    var c : int ;
    s := s->including(a) ; 
    if (n > 2) then     s := s->including(b) ; else skip ; 
        var i : int ; i := 0 ; while i < n - 2 do ( (     c := a + b ; 
     s := s->including(c) ; 
     a := b ; 
     b := c )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (s->includes(arr[i+1])) then     s := s->excludingFirst(arr[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    return s->size() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,1,21,4,2,1,8,9} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(fibonacciArray(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  boolean isPrime(int num){
    if(num==1)return(false);
    for(int r=2 ; r<=Math.sqrt(num); r++){
      if(num % r==0)return(false);
    }
    return(true);
  }
  void doIt(){
    Scanner stdIn=new Scanner(System.in);
    while(true){
      int N=stdIn.nextInt();
      int P=stdIn.nextInt();
      if(N==-1 && P==-1)break ;
      ArrayList<Integer>list=new ArrayList<Integer>(100);
      for(int r=N ; list.size()<100 ; r++){
        if(isPrime(r))list.add(r);
      }
      for(int r=0 ; r<list.size(); r++){
        if(list.get(r)>N){
          N=r ;
          break ;
        }
      }
      ArrayList<Integer>output=new ArrayList<Integer>();
      for(int r=N ; r<list.size(); r++){
        for(int c=r ; c<list.size(); c++){
          output.add(list.get(r)+list.get(c));
        }
      }
      Collections.sort(output);
      System.out.println(output.get(P-1));
    }
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation isPrime( num : int) : boolean
  pre: true
  post: true
  activity: (     if (num = 1) then     return (false) else skip ; 
         var r : int ; r := 2 ; while r <= (num)->sqrt() do ( (     if (num mod r = 0) then     return (false) else skip )  ;     r := r + 1 ) ; 
     return (true) );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var N : int ; N := stdIn.getCurrent()->toInteger() ;
     var P : int ; P := stdIn.getCurrent()->toInteger() ;
    if (N = -1 & P = -1) then     break else skip ; 
    var list : Sequence(int) ; list := Sequence{} ;
        var r : int ; r := N ; while list->size() < 100 do ( (     if (isPrime(r)) then     list := list->including(r) ; else skip )  ;     r := r + 1 ) ; 
        var r : int ; r := 0 ; while r < list->size() do ( (     if (list->at(r+1) > N) then (     N := r ; 
     break ) else skip )  ;     r := r + 1 ) ; 
    var output : Sequence(int) ; output := Sequence{} ;
        var r : int ; r := N ; while r < list->size() do ( (         var c : int ; c := r ; while c < list->size() do ( (     output := output->including(list->at(r+1) + list->at(c+1)) )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    output := output->sort() ; 
    OclFile["System.out"].println(output->at(P - 1+1)) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
class Main {
  public static Scanner sc=new Scanner(in);
  public static Random rand=new Random();
  public List<Integer>getPrimeList(int max){
    LinkedList<Integer>primes=new LinkedList<Integer>();
    PLoop : for(int i=2 ;
    i<max ;
    i++){
      for(int prime : primes){
        if(i % prime==0){
          continue PLoop ;
        }
        if(prime*prime>i){
          break ;
        }
      }
      primes.add(i);
    }
    return primes ;
  }
  public void run(){
    List<Integer>plist=new ArrayList<Integer>(getPrimeList(200000));
    TCase : while(true){
      int n=sc.nextInt(),p=sc.nextInt();
      if(n==-1)return ;
      int ind=Collections.binarySearch(plist,n+1);
      if(ind<0)ind=~ ind ;
      List<Integer>sumset=new LinkedList<Integer>();
      for(int i=ind ; i<=ind+p ; i++)for(int j=i ; j<=ind+p ; j++){
        sumset.add(plist.get(i)+plist.get(j));
      }
      Collections.sort(sumset);
      ln(sumset.get(p-1));
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  public int[] nextIntArray(int n){
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=sc.nextInt();
    }
    return res ;
  }
  public static void pr(Object o){
    out.print(o);
  }
  public static void ln(Object o){
    out.println(o);
  }
  public static void ln(){
    out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(in);
  static   attribute rand : OclRandom := OclRandom.newOclRandom();
   operation getPrimeList( max : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var primes : Sequence(int) ; primes := Sequence{} ;
         var i : int ; i := 2 ; while i < max do ( (     for (prime : primes) do ( (     if (i mod prime = 0) then (     continue ) else skip ; 
     if (prime * prime > i) then (     break ) else skip )  ) ; 
     primes := primes->including(i) )  ;     i := i + 1 ) ; 
     return primes );
   operation run() : void
  pre: true
  post: true
  activity: (     var plist : Sequence(int) ; plist := Sequence{}->union(getPrimeList(200000)) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
     if (n = -1) then     return else skip ; 
    var ind : int ; ind := .binarySearch(plist, n + 1) ;
    if (ind < 0) then     ind := -(ind + 1) ; else skip ; 
    var sumset : Sequence(int) ; sumset := Sequence{} ;
        var i : int ; i := ind ; while i <= ind + p do (         var j : int ; j := i ; while j <= ind + p do ( (     sumset := sumset->including(plist->at(i+1) + plist->at(j+1)) )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    sumset := sumset->sort() ; 
    execute ln(sumset->at(p - 1+1)) ; 
 ) ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return res );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     out.println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class Shortcuts {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int[] array=new int[n];
    int[] dist=new int[n];
    for(int i=0 ; i<n ; i++){
      array[i]=s.nextInt()-1 ;
      dist[i]=Integer.MAX_VALUE ;
    }
    ArrayList<Integer>list=new ArrayList<Integer>();
    dist[0]=0 ;
    list.add(0);
    int begin=0 ;
    int end=0 ;
    while(end>=begin){
      for(int i=begin ; i<=end ; i++){
        if(list.get(i)<n-1 && dist[list.get(i)]+1<dist[list.get(i)+1]){
          dist[list.get(i)+1]=dist[list.get(i)]+1 ;
          list.add(list.get(i)+1);
        }
        if(list.get(i)>1 && dist[list.get(i)]+1<dist[list.get(i)-1]){
          dist[list.get(i)-1]=dist[list.get(i)]+1 ;
          list.add(list.get(i)-1);
        }
        if(dist[list.get(i)]+1<dist[array[list.get(i)] ]){
          dist[array[list.get(i)] ]=dist[list.get(i)]+1 ;
          list.add(array[list.get(i)]);
        }
        begin=end+1 ;
        end=list.size()-1 ;
      }
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(dist[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Shortcuts {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
    var dist : Sequence(int) ; dist := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := s.getCurrent()->toInteger() - 1 ; 
     dist[i+1] := 2147483647 )  ;     i := i + 1 ) ; 
    var list : Sequence(int) ; list := Sequence{} ;
    dist[0+1] := 0 ; 
    list := list->including(0) ; 
    var begin : int ; begin := 0 ;
    var end : int ; end := 0 ;
    while (end >= begin) do (         var i : int ; i := begin ; while i <= end do ( (     if (list->at(i+1) < n - 1 & dist[list->at(i+1)+1] + 1 < dist[list->at(i+1) + 1+1]) then (     dist[list->at(i+1) + 1+1] := dist[list->at(i+1)+1] + 1 ; 
     list := list->including(list->at(i+1) + 1) ) else skip ; 
     if (list->at(i+1) > 1 & dist[list->at(i+1)+1] + 1 < dist[list->at(i+1) - 1+1]) then (     dist[list->at(i+1) - 1+1] := dist[list->at(i+1)+1] + 1 ; 
     list := list->including(list->at(i+1) - 1) ) else skip ; 
    if (dist[list->at(i+1)+1] + 1 < dist[array[list->at(i+1)+1]+1]) then (     dist[array[list->at(i+1)+1]+1] := dist[list->at(i+1)+1] + 1 ; 
     list := list->including(array[list->at(i+1)+1]) ) else skip ; 
    begin := end + 1 ; 
    end := list->size() - 1 ; 
 )  ;     i := i + 1 ) ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(dist[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),s=0 ;
    int[] p=new int[n];
    for(int i=0 ; i<n ; i++){
      p[i]=in.nextInt();
      s+=p[i];
    }
    Arrays.sort(p);
    Par : for(int i=0 ;
    i<n ;
    i++){
      if(s % 2!=0)break ;
      else {
        int s2=s ;
        for(int j=0 ; j<n ; j++){
          if((s-p[j])% 2!=0){
            s-=p[j];
            break Par ;
          }
        }
        if(s2==s)s=0 ;
      }
    }
    System.out.print(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : int ; s := 0 ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := in.getCurrent()->toInteger() ; 
     s := s+(p[i+1]) )  ;     i := i + 1 ) ; 
    p := p->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (s mod 2 /= 0) then     break else (     var s2 : int ; s2 := s ;
         var j : int ; j := 0 ; while j < n do ( (     if ((s - p[j+1]) mod 2 /= 0) then (     s := s-(p[j+1]) ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (s2 = s) then     s := 0 ; else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SerejaAndSuffixes {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int[] arr1=new int[n];
    for(int j=0 ; j<n ; j++){
      arr1[j]=in.nextInt();
    }
    int[] arr2=new int[m];
    for(int j=0 ; j<m ; j++){
      arr2[j]=in.nextInt();
    }
    solveIt(arr1,arr2);
    in.close();
  }
  private static void solveIt(int[] arr1,int[] arr2){
    int[] res=new int[arr1.length];
    boolean[] exists=new boolean[(int)(Math.pow(10,5)+1)];
    int count=0 ;
    for(int i=arr1.length-1 ; i>=0 ; i--){
      if(! exists[arr1[i] ]){
        exists[arr1[i] ]=true ;
        count++;
      }
      res[i]=count ;
    }
    for(int i=0 ; i<arr2.length ; i++){
      System.out.println(res[arr2[i]-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SerejaAndSuffixes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     arr1[j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,m)->collect(0) ;
        var j : int ; j := 0 ; while j < m do ( (     arr2[j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    execute solveIt(arr1, arr2) ; 
    skip ; 
 );
  static   operation solveIt( arr1 : Sequence(int), arr2 : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,arr1->size())->collect(0) ;
     var exists : Sequence(boolean) ; exists := Integer.subrange(1,(10->pow(5) + 1)->oclAsType(int))->collect(false) ;
    var count : int ; count := 0 ;
        var i : int ; i := arr1->size() - 1 ; while i >= 0 do ( (     if (not(exists[arr1[i+1]+1])) then (     exists[arr1[i+1]+1] := true ; 
     count := count + 1 ) else skip ; 
     res[i+1] := count )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < arr2->size() do ( (     OclFile["System.out"].println(res[arr2[i+1] - 1+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class SerejaAndSuffixes {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt(),m=scanner.nextInt();
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=scanner.nextInt();
    }
    int[] dps=new int[n];
    HashSet<Integer>set=new HashSet<>();
    for(int i=n-1 ; i>=0 ; i--){
      set.add(nums[i]);
      dps[i]=set.size();
    }
    for(int i=0 ; i<m ; i++){
      int q=scanner.nextInt();
      System.out.println(dps[q-1]);
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class SerejaAndSuffixes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dps : Sequence(int) ; dps := Integer.subrange(1,n)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     set := set->including(nums[i+1]) ; 
     dps[i+1] := set->size() )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var q : int ; q := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(dps[q - 1+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class BSerejaAndSuffixes {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] numbers=new int[n];
    for(int i=0 ; i<n ; i++){
      numbers[i]=sc.nextInt();
    }
    int[] distCount=new int[n];
    Set<Integer>uniqueCheck=new HashSet<>();
    distCount[n-1]=1 ;
    uniqueCheck.add(numbers[n-1]);
    for(int i=n-2 ; i>=0 ; i--){
      if(uniqueCheck.add(numbers[i])){
        distCount[i]=distCount[i+1]+1 ;
      }
      else {
        distCount[i]=distCount[i+1];
      }
    }
    while(0<m--){
      int l=sc.nextInt();
      System.out.println(distCount[l-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BSerejaAndSuffixes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var numbers : Sequence(int) ; numbers := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     numbers[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var distCount : Sequence(int) ; distCount := Integer.subrange(1,n)->collect(0) ;
    var uniqueCheck : Set(int) ; uniqueCheck := Set{} ;
    distCount[n - 1+1] := 1 ; 
    uniqueCheck := uniqueCheck->including(numbers[n - 1+1]) ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (uniqueCheck->excludes(numbers[i+1])) then (     distCount[i+1] := distCount[i + 1+1] + 1 ) else (     distCount[i+1] := distCount[i + 1+1] ) )  ;     i := i - 1 ) ; 
        while (0 < m) do (        skip ;     m := m - 1 ; (     var l : int ; l := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(distCount[l - 1+1]) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    HashSet<Integer>hs=new HashSet<>();
    for(int i=n-1 ; i>=0 ; i--){
      hs.add(arr[i]);
      arr[i]=hs.size();
    }
    PrintWriter pw=new PrintWriter(System.out);
    for(int i=0 ; i<m ; i++){
      pw.println(arr[sc.nextInt()-1]);
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var hs : Set(int) ; hs := Set{} ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     hs := hs->including(arr[i+1]) ; 
     arr[i+1] := hs->size() )  ;     i := i - 1 ) ; 
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
        var i : int ; i := 0 ; while i < m do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int arr[]=new int[n];
    Map<Integer,Integer>mp=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      mp.put(arr[i],mp.getOrDefault(arr[i],0)+1);
    }
    int dp[]=new int[n+1];
    for(int i=0 ; i<n ; i++){
      dp[i+1]=mp.size();
      if(mp.get(arr[i])==1)mp.remove(arr[i]);
      else mp.put(arr[i],mp.get(arr[i])-1);
    }
    while(m!=0){
      int l=sc.nextInt();
      System.out.println(dp[l]);
      m--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var mp : Map(int,int) ; mp := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     mp := mp->union(Map{arr[i+1] |-> (if mp->keys()->contains(arr[i+1]) then mp->at(arr[i+1]) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     dp[i + 1+1] := mp.size() ; 
     if (mp->at(arr[i+1]) = 1) then     mp := mp->antirestrict(Set{arr[i+1]}) ; else     mp := mp->union(Map{arr[i+1] |-> mp->at(arr[i+1]) - 1}) ; )  ;     i := i + 1 ) ; 
    while (m /= 0) do (     var l : int ; l := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(dp[l+1]) ; 
     m := m - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    long mod=1000000007 ;
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int[] r=new int[h+1];
    for(int i=1 ; i<=h ; i++)r[i]=sc.nextInt();
    int[] c=new int[w+1];
    for(int i=1 ; i<=w ; i++)c[i]=sc.nextInt();
    long cnt=h*w ;
    boolean flag=true ;
    for(int i=1 ; i<=h ; i++){
      for(int j=1 ; j<=w ; j++){
        if(j<=r[i]+1 || i<=c[j]+1)cnt--;
        if(r[i]>=j && c[j]==i-1 || c[j]>=i && r[i]==j-1)flag=false ;
      }
    }
    if(! flag){
      System.out.println(0);
      return ;
    }
    long ans=1 ;
    for(int i=0 ; i<cnt ; i++)ans=(ans*2)% mod ;
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mod : long ; mod := 1000000007 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var r : Sequence(int) ; r := Integer.subrange(1,h + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= h do (     r[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var c : Sequence(int) ; c := Integer.subrange(1,w + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= w do (     c[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var cnt : long ; cnt := h * w ;
    var flag : boolean ; flag := true ;
        var i : int ; i := 1 ; while i <= h do ( (         var j : int ; j := 1 ; while j <= w do ( (     if (j <= r[i+1] + 1 or i <= c[j+1] + 1) then     cnt := cnt - 1 ; else skip ; 
     if (r[i+1] >= j & c[j+1] = i - 1 or c[j+1] >= i & r[i+1] = j - 1) then     flag := false ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (not(flag)) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var ans : long ; ans := 1 ;
        var i : int ; i := 0 ; while i < cnt do (     ans := (ans * 2) mod mod ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    long mod=1000000007 ;
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int[] r=new int[h+1];
    for(int i=1 ; i<=h ; i++)r[i]=sc.nextInt();
    int[] c=new int[w+1];
    for(int i=1 ; i<=w ; i++)c[i]=sc.nextInt();
    long cnt=h*w ;
    boolean flag=true ;
    for(int i=1 ; i<=h ; i++){
      for(int j=1 ; j<=w ; j++){
        if(j<=r[i]+1 || i<=c[j]+1)cnt--;
        if(r[i]>=j && c[j]==i-1 || c[j]>=i && r[i]==j-1)flag=false ;
      }
    }
    if(! flag){
      System.out.println(0);
      return ;
    }
    long ans=1 ;
    for(int i=0 ; i<cnt ; i++)ans=(ans*2)% mod ;
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mod : long ; mod := 1000000007 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var r : Sequence(int) ; r := Integer.subrange(1,h + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= h do (     r[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var c : Sequence(int) ; c := Integer.subrange(1,w + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= w do (     c[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var cnt : long ; cnt := h * w ;
    var flag : boolean ; flag := true ;
        var i : int ; i := 1 ; while i <= h do ( (         var j : int ; j := 1 ; while j <= w do ( (     if (j <= r[i+1] + 1 or i <= c[j+1] + 1) then     cnt := cnt - 1 ; else skip ; 
     if (r[i+1] >= j & c[j+1] = i - 1 or c[j+1] >= i & r[i+1] = j - 1) then     flag := false ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (not(flag)) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var ans : long ; ans := 1 ;
        var i : int ; i := 0 ; while i < cnt do (     ans := (ans * 2) mod mod ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class trailzero {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int r=sc.nextInt();
    int c=sc.nextInt();
    int a[]=new int[r];
    int p[]=new int[c];
    int f[][]=new int[r][c];
    int v=0 ;
    for(int i=0 ; i<r ; i++){
      a[i]=sc.nextInt();
      for(int j=0 ; j<=a[i]; j++){
        if(j<c){
          f[i][j]=1 ;
        }
        if(j<c && j==a[i]){
          f[i][j]=2 ;
        }
      }
    }
    for(int i=0 ; i<c ; i++){
      p[i]=sc.nextInt();
      for(int j=0 ; j<=p[i]; j++){
        if(j<r && j!=p[i]){
          if(f[j][i]==2){
            v++;
          }
          f[j][i]=1 ;
        }
        if(j<r && j==p[i]){
          if(f[j][i]==1){
            v++;
          }
          f[j][i]=2 ;
        }
      }
    }
    long count=1 ;
    for(int i=0 ; i<r ; i++){
      for(int j=0 ; j<c ; j++){
        if(f[i][j]==0){
          count=(count*2)% 1000000007 ;
        }
      }
    }
    if(count!=0 && v==0){
      System.out.println(count);
    }
    else {
      System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class trailzero {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,r)->collect(0) ;
    var p : Sequence(int) ; p := Integer.subrange(1,c)->collect(0) ;
    var f : Sequence(Sequence(int)) ; f := Integer.subrange(1,r)->collect(Integer.subrange(1,c)->collect(0)) ;
    var v : int ; v := 0 ;
        var i : int ; i := 0 ; while i < r do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
         var j : int ; j := 0 ; while j <= a[i+1] do ( (     if (j < c) then (     f[i+1][j+1] := 1 ) else skip ; 
     if (j < c & j = a[i+1]) then (     f[i+1][j+1] := 2 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < c do ( (     p[i+1] := sc.getCurrent()->toInteger() ; 
         var j : int ; j := 0 ; while j <= p[i+1] do ( (     if (j < r & j /= p[i+1]) then (     if (f[j+1][i+1] = 2) then (     v := v + 1 ) else skip ; 
     f[j+1][i+1] := 1 ) else skip ; 
     if (j < r & j = p[i+1]) then (     if (f[j+1][i+1] = 1) then (     v := v + 1 ) else skip ; 
     f[j+1][i+1] := 2 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : long ; count := 1 ;
        var i : int ; i := 0 ; while i < r do ( (         var j : int ; j := 0 ; while j < c do ( (     if (f[i+1][j+1] = 0) then (     count := (count * 2) mod 1000000007 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (count /= 0 & v = 0) then (     OclFile["System.out"].println(count) ) else (     OclFile["System.out"].println(0) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class strange_birth_day {
  void helpBirthDayBoy(int n[],int m[]){
    Arrays.sort(n);
    long ans=0 ;
    int j=0 ;
    for(int i=n.length-1 ; i>=0 ; i--){
      int k=n[i];
      if(k<m.length){
        if(m[k]>m[j]){
          ans+=m[j];
          j++;
        }
        else {
          ans+=m[k];
        }
      }
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    FastReader in=new FastReader();
    int test=in.nextInt();
    while(test-->0){
      int n=in.nextInt();
      int m=in.nextInt();
      int arr[]=new int[n];
      int marr[]=new int[m];
      for(int i=0 ; i<n ; i++){
        arr[i]=in.nextInt()-1 ;
      }
      for(int i=0 ; i<m ; i++){
        marr[i]=in.nextInt();
      }
      strange_birth_day strange=new strange_birth_day();
      strange.helpBirthDayBoy(arr,marr);
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        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().trim();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class strange_birth_day {
   operation helpBirthDayBoy( n : Sequence(int), m : Sequence(int)) : void
  pre: true
  post: true
  activity: (     n := n->sort() ; 
     var ans : long ; ans := 0 ;
    var j : int ; j := 0 ;
        var i : int ; i := n->size() - 1 ; while i >= 0 do ( (     var k : int ; k := n[i+1] ;
     if (k < m->size()) then (     if (m[k+1] > m[j+1]) then (     ans := ans+(m[j+1]) ; 
     j := j + 1 ) else (     ans := ans+(m[k+1]) ) ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var test : int ; test := in.nextInt() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := in.nextInt() ;
     var m : int ; m := in.nextInt() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var marr : Sequence(int) ; marr := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.nextInt() - 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     marr[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    var strange : strange_birth_day ; strange := strange_birth_day.newstrange_birth_day() ;
    strange.helpBirthDayBoy(arr, marr) ; 
 ) ;  ) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine()->trim() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int N=sc.nextInt();
    int D=sc.nextInt();
    int[] x=new int[N];
    for(int i=0 ; i<N ; i++)x[i]=sc.nextInt();
    int Q=sc.nextInt();
    long[] qq=new long[Q];
    for(int i=0 ; i<Q ; i++)qq[i]=(sc.nextLong()-1)<<30 | i ;
    Arrays.sort(qq);
    int[] rest=new int[N+1];
    rest[0]=D ;
    for(int i=0 ; i<N ; i++)rest[i+1]=Math.min(rest[i],Math.abs(rest[i]-x[i]));
    boolean[] ans=new boolean[Q];
    long range=0 ;
    int idx=Q-1 ;
    for(int i=N-1 ; i>=0 ; i--){
      while(idx>=0 &&(qq[idx]>>30)==i){
        if(rest[i]>range){
          ans[(int)(qq[idx] &((1<<30)-1))]=true ;
        }
        idx--;
      }
      if(x[i]<=range*2+1){
        range+=x[i];
      }
    }
    for(int i=0 ; i<Q ; i++)pw.println(ans[i] ? "YES" : "NO");
    sc.close();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var D : int ; D := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     x[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var Q : int ; Q := sc.getCurrent()->toInteger() ;
    var qq : Sequence(long) ; qq := Integer.subrange(1,Q)->collect(0) ;
        var i : int ; i := 0 ; while i < Q do (     qq[i+1] := MathLib.bitwiseOr(((sc.getCurrent()->toLong() - 1)*(2->pow(30)))->oclAsType(long),i) ;  ;     i := i + 1 ) ; 
    qq := qq->sort() ; 
    var rest : Sequence(int) ; rest := Integer.subrange(1,N + 1)->collect(0) ;
    rest[0+1] := D ; 
        var i : int ; i := 0 ; while i < N do (     rest[i + 1+1] := Set{rest[i+1], if rest[i+1] - x[i+1] < 0 then -(rest[i+1] - x[i+1]) else rest[i+1] - x[i+1] endif}->min() ;  ;     i := i + 1 ) ; 
    var ans : Sequence(boolean) ; ans := Integer.subrange(1,Q)->collect(false) ;
    var range : long ; range := 0 ;
    var idx : int ; idx := Q - 1 ;
        var i : int ; i := N - 1 ; while i >= 0 do ( (     while (idx >= 0 & ((qq[idx+1]/(2->pow(30)))->oclAsType(long)) = i) do (     if (rest[i+1] > range) then (     ans[(qq[idx+1] & (((1*(2->pow(30)))->oclAsType(long)) - 1))->oclAsType(int)+1] := true ) else skip ; 
     idx := idx - 1 ) ; 
     if (x[i+1] <= range * 2 + 1) then (     range := range+(x[i+1]) ) else skip )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < Q do (     skip ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),s=0 ;
    int[] p=new int[n];
    for(int i=0 ; i<n ; i++){
      p[i]=in.nextInt();
      s+=p[i];
    }
    Arrays.sort(p);
    Par : for(int i=0 ;
    i<n ;
    i++){
      if(s % 2!=0)break ;
      else {
        int s2=s ;
        for(int j=0 ; j<n ; j++){
          if((s-p[j])% 2!=0 || s-p[j]==0){
            s-=p[j];
            break Par ;
          }
        }
        if(s2==s)s=0 ;
      }
    }
    System.out.print(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : int ; s := 0 ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := in.getCurrent()->toInteger() ; 
     s := s+(p[i+1]) )  ;     i := i + 1 ) ; 
    p := p->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (s mod 2 /= 0) then     break else (     var s2 : int ; s2 := s ;
         var j : int ; j := 0 ; while j < n do ( (     if ((s - p[j+1]) mod 2 /= 0 or s - p[j+1] = 0) then (     s := s-(p[j+1]) ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (s2 = s) then     s := 0 ; else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int factorial(int f){
    int fact=1 ;
    for(int i=2 ; i<=f ; i++)fact*=(int)i ;
    return fact ;
  }
  static int findPermutation(int N,int M){
    int permutation=factorial(N+M-1)/(factorial(N)*factorial(M-1));
    return permutation ;
  }
  public static void main(String[] args){
    int N=3,M=3 ;
    System.out.println(findPermutation(N,M));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation factorial( f : int) : int
  pre: true
  post: true
  activity: (     var fact : int ; fact := 1 ;
         var i : int ; i := 2 ; while i <= f do (     fact := fact*(i->oclAsType(int)) ;  ;     i := i + 1 ) ; 
     return fact );
  static   operation findPermutation( N : int, M : int) : int
  pre: true
  post: true
  activity: (     var permutation : int ; permutation := factorial(N + M - 1) / (factorial(N) * factorial(M - 1)) ;
     return permutation );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
    var M : int ; M := 3 ;
     OclFile["System.out"].println(findPermutation(N, M)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int has0(int x){
    while(x!=0){
      if(x % 10==0)return 1 ;
      x/=10 ;
    }
    return 0 ;
  }
  static int getCount(int n){
    int count=0 ;
    for(int i=1 ; i<=n ; i++)count+=has0(i);
    return count ;
  }
  public static void main(String args[]){
    int n=107 ;
    System.out.println("Count of numbers from 1"+" to "+n+" is "+getCount(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation has0( x : int) : int
  pre: true
  post: true
  activity: (     while (x /= 0) do (     if (x mod 10 = 0) then     return 1 else skip ; 
     x := x/(10) ) ; 
     return 0 );
  static   operation getCount( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i <= n do (     count := count+(has0(i)) ;  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 107 ;
     OclFile["System.out"].println("Count of numbers from 1" + " to " + n + " is " + getCount(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findPivot(int arr[],int low,int high){
    if(high<low)return-1 ;
    if(high==low)return low ;
    int mid=(low+high)/2 ;
    if(mid<high && arr[mid+1]<arr[mid]){
      return mid ;
    }
    if(mid>low && arr[mid]<arr[mid-1]){
      return mid-1 ;
    }
    if(arr[low]>arr[mid]){
      return findPivot(arr,low,mid-1);
    }
    else {
      return findPivot(arr,mid+1,high);
    }
  }
  public static boolean isRotated(int arr[],int n){
    int l=0 ;
    int r=n-1 ;
    int pivot=-1 ;
    if(arr[l]>arr[r]){
      pivot=findPivot(arr,l,r);
      if(l<pivot){
        while(pivot>l){
          if(arr[pivot]<arr[pivot-1]){
            return false ;
          }
          pivot--;
        }
      }
      else {
        pivot++;
        while(pivot<r){
          if(arr[pivot]>arr[pivot+1]){
            return false ;
          }
          pivot++;
        }
      }
      return true ;
    }
    else {
      return false ;
    }
  }
  public static void main(String[] args){
    int arr[]={
      3,4,5,1,2 };
      System.out.println(isRotated(arr,5));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findPivot( arr : Sequence(int), low : int, high : int) : int
  pre: true
  post: true
  activity: (     if (high < low) then     return -1 else skip ; 
     if (high = low) then     return low else skip ; 
    var mid : int ; mid := (low + high) / 2 ;
    if (mid < high & arr[mid + 1+1] < arr[mid+1]) then (     return mid ) else skip ; 
    if (mid > low & arr[mid+1] < arr[mid - 1+1]) then (     return mid - 1 ) else skip ; 
    if (arr[low+1] > arr[mid+1]) then (     return findPivot(arr, low, mid - 1) ) else (     return findPivot(arr, mid + 1, high) ) ;  
 );
  static   operation isRotated( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
     var r : int ; r := n - 1 ;
     var pivot : int ; pivot := -1 ;
     if (arr[l+1] > arr[r+1]) then (     pivot := findPivot(arr, l, r) ; 
     if (l < pivot) then (     while (pivot > l) do (     if (arr[pivot+1] < arr[pivot - 1+1]) then (     return false ) else skip ; 
     pivot := pivot - 1 ) ) else (     pivot := pivot + 1 ; 
     while (pivot < r) do (     if (arr[pivot+1] > arr[pivot + 1+1]) then (     return false ) else skip ; 
     pivot := pivot + 1 ) ) ;  
     return true ) else (     return false ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,4,5,1,2} ;
     OclFile["System.out"].println(isRotated(arr, 5)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int GCD(int a,int b){
    if(b==0)return a ;
    return GCD(b,a % b);
  }
  static int multiplicativeOrder(int A,int N){
    if(GCD(A,N)!=1)return-1 ;
    int result=1 ;
    int K=1 ;
    while(K<N){
      result=(result*A)% N ;
      if(result==1)return K ;
      K++;
    }
    return-1 ;
  }
  public static void main(String args[]){
    int A=4,N=7 ;
    System.out.println(multiplicativeOrder(A,N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation GCD( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return GCD(b, a mod b) );
  static   operation multiplicativeOrder( A : int, N : int) : int
  pre: true
  post: true
  activity: (     if (GCD(A, N) /= 1) then     return -1 else skip ; 
     var result : int ; result := 1 ;
    var K : int ; K := 1 ;
    while (K < N) do (     result := (result * A) mod N ; 
     if (result = 1) then     return K else skip ; 
     K := K + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 4 ;
    var N : int ; N := 7 ;
     OclFile["System.out"].println(multiplicativeOrder(A, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int primeProduct(int arr[],int n){
    int max_val=Arrays.stream(arr).max().getAsInt();
    Vector<Boolean>prime=new Vector<Boolean>(max_val+1);
    for(int i=0 ; i<max_val+1 ; i++)prime.add(i,Boolean.TRUE);
    prime.add(0,Boolean.FALSE);
    prime.add(1,Boolean.FALSE);
    for(int p=2 ; p*p<=max_val ; p++){
      if(prime.get(p)==true){
        for(int i=p*2 ; i<=max_val ; i+=p)prime.add(i,Boolean.FALSE);
      }
    }
    int prod=1 ;
    for(int i=0 ; i<n ; i++)if(prime.get(arr[i]))prod*=arr[i];
    return prod ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,6,7 };
      int n=arr.length ;
      System.out.print(primeProduct(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation primeProduct( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max_val : int ; max_val := stream(arr).max().getAsInt() ;
     var prime : Sequence(Boolean) ; prime := Sequence{}->union(max_val + 1) ;
        var i : int ; i := 0 ; while i < max_val + 1 do (     prime := prime.insertAt(i+1,true) ;  ;     i := i + 1 ) ; 
    prime := prime.insertAt(0+1,false) ; 
    prime := prime.insertAt(1+1,false) ; 
        var p : int ; p := 2 ; while p * p <= max_val do ( (     if (prime->at(p+1) = true) then (         var i : int ; i := p * 2 ; while i <= max_val do (     prime := prime.insertAt(i+1,false) ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var prod : int ; prod := 1 ;
        var i : int ; i := 0 ; while i < n do (     if (prime->at(arr[i+1]+1)) then     prod := prod*(arr[i+1]) ; else skip ;  ;     i := i + 1 ) ; 
    return prod 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(primeProduct(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int n=s.length();
    String x1=s.substring(0,(n-1)/2);
    int y=(n+3)/2 ;
    y-=1 ;
    String x2=s.substring(y);
    if(! ispal(s))System.out.println("No");
    else if(! ispal(x1))System.out.println("No");
    else if(! ispal(x2))System.out.println("No");
    else System.out.println("Yes");
  }
  public static boolean ispal(String s){
    int n=s.length();
    if(n==1)return true ;
    for(int i=0 ; i<n/2 ; i++){
      if(s.charAt(i)!=s.charAt(n-i-1))return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var n : int ; n := s->size() ;
    var x1 : String ; x1 := s.subrange(0+1,((n)->char2byte() - 1) / 2) ;
    var y : int ; y := (n + 3) / 2 ;
    y := y-(1) ; 
    var x2 : String ; x2 := s.subrange(y+1,y) ;
    if (not(ispal(s))) then     OclFile["System.out"].println("No") else     if (not(ispal(x1))) then     OclFile["System.out"].println("No") else     if (not(ispal(x2))) then     OclFile["System.out"].println("No") else     OclFile["System.out"].println("Yes") ; ;  ;  ;  
 );
  static   operation ispal( s : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     if (n = 1) then     return true else skip ; 
         var i : int ; i := 0 ; while i < n / 2 do ( (     if (s->at(i+1) /= s->at((n)->char2byte() - i - 1+1)) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class Main {
  public static boolean kaibun(String S,int N){
    int i ;
    String s1 ;
    String s2 ;
    if(N % 2!=0){
      s1=S.substring(0,(N-1)/2);
      s2=S.substring((N-1)/2+1);
    }
    else {
      s1=S.substring(0,(N)/2);
      s2=S.substring((N)/2);
    }
    StringBuffer str2=new StringBuffer(s2);
    s2=str2.reverse().toString();
    if(s1.equals(s2)){
      return true ;
    }
    else {
      return false ;
    }
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String S=scanner.nextLine();
    int N=S.length();
    if(kaibun(S,N)){
      String S2=S.substring(0,(N-1)/2);
      int N2=S2.length();
      if(kaibun(S2,N2)){
        String S3=S.substring((N+3)/2-1,N);
        int N3=S3.length();
        if(kaibun(S3,N3)){
          System.out.println("Yes");
        }
        else {
          System.out.println("No");
        }
      }
      else {
        System.out.println("No");
      }
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation kaibun( S : String, N : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ;
     var s1 : String ;
    var s2 : String ;
    if (N mod 2 /= 0) then (     s1 := S.subrange(0+1,(N - 1) / 2) ; 
     s2 := S.subrange((N - 1) / 2 + 1+1,(N - 1) / 2 + 1) ) else (     s1 := S.subrange(0+1,(N) / 2) ; 
     s2 := S.subrange((N) / 2+1,(N) / 2) ) ;  
    var str2 : String ; str2 := StringLib.newString(s2) ;
    s2 := str2->reverse()+"" ; 
    if (s1 = s2) then (     return true ) else (     return false ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := scanner.nextLine() ;
     var N : int ; N := S->size() ;
     if (kaibun(S, N)) then (     var S2 : String ; S2 := S.subrange(0+1,((N)->char2byte() - 1) / 2) ;
     var N2 : int ; N2 := S2->size() ;
     if (kaibun(S2, N2)) then (     var S3 : String ; S3 := S.subrange((N + 3) / 2 - 1+1,N) ;
     var N3 : int ; N3 := S3->size() ;
     if (kaibun(S3, N3)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ) else (     OclFile["System.out"].println("No") ) ) else (     OclFile["System.out"].println("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class Main {
  public static void main(String[] args)throws Exception {
    PrintWriter out=new PrintWriter(System.out);
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String S=br.readLine();
    StringBuilder sb=new StringBuilder(S);
    String reverse_1=sb.reverse().toString();
    String S_2=S.substring(0,(S.length()-1)/2);
    StringBuilder sb_2=new StringBuilder(S_2);
    String reverse_2=sb_2.reverse().toString();
    String S_3=S.substring((S.length()+3)/2-1,S.length());
    StringBuilder sb_3=new StringBuilder(S_3);
    String reverse_3=sb_3.reverse().toString();
    if(S.equals(reverse_1)&& S_2.equals(reverse_2)&& S_3.equals(reverse_3)){
      out.println("Yes");
    }
    else {
      out.println("No");
    }
    out.flush();
    out.close();
    br.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var S : String ; S := br.readLine() ;
    var sb : String ; sb := StringLib.newString(S) ;
    var reverse    var reverseString : String ; reverseString := sb->reverse()+"" : String ; reverse    var reverseString : String ; reverseString := sb->reverse()+"" := sb->reverse()+"" ;
    var SS.subrange(0+1,(S->size() - 1) / 2) : String ; SS.subrange(0+1,(S->size() - 1) / 2) := S.subrange(0+1,(S->size() - 1) / 2) ;
    var sbStringLib.newString(S    var sbStringLib.newString(S_2) : String ; sbStringLib.newString(S_2) := StringLib.newString(SStringLib.newString(S_2))) : String ; sbStringLib.newString(S    var sbStringLib.newString(S_2) : String ; sbStringLib.newString(S_2) := StringLib.newString(SStringLib.newString(S_2))) := StringLib.newString(SStringLib.newString(S    var sbStringLib.newString(S_2) : String ; sbStringLib.newString(S_2) := StringLib.newString(SStringLib.newString(S_2)))) ;
    var reversesbreverse()->reverse()+"" : String ; reversesbreverse()->reverse()+"" := sbreverse()->reverse()+"" ;
    var S_3 : String ; S_3 := S.subrange((S->size() + 3) / 2 - 1+1,S->size()) ;
    var sb_3 : String ; sb_3 := StringLib.newString(S_3) ;
    var reverse_3 : String ; reverse_3 := sb_3->reverse()+"" ;
    if (S = reverseS & Sequals(reverseS(     skip ) = reverse(     skip )) = reverseequals(reverseS(     skip ) = reverse(     skip )) & S(     skip ) = reverse(     skip )) then (     skip ) else (     skip ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class teest {
  public static void main(String[] args){
    Scanner a=new Scanner(System.in);
    int t=a.nextInt();
    while(t>0){
      int n=a.nextInt(),k=a.nextInt();
      if(n % 2!=k % 2 || n/k<k)System.out.println("NO");
      else System.out.println("YES");
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class teest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : OclFile ; a := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := a.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := a.getCurrent()->toInteger() ;
    var k : int ; k := a.getCurrent()->toInteger() ;
     if (n mod 2 /= k mod 2 or n / k < k) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  
     t := t - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String string=sc.next();
    boolean isHuiwen=isHuiWen(string);
    System.out.println(isHuiwen ? "Yes" : "No");
  }
  private static boolean isHuiWen(String string){
    int m=(string.length()-1)/2 ;
    int n=(string.length()+3)/2-1 ;
    for(int i=0 ; i<m ; i++){
      if(string.charAt(i)!=string.charAt(string.length()-1-i)){
        return false ;
      }
    }
    for(int i=0 ; i<m/2 ; i++){
      if(string.charAt(i)!=string.charAt(m-1-i)){
        return false ;
      }
    }
    for(int i=n ; i<(3*string.length()-1)/4 ; i++){
      if(string.charAt(i)!=string.charAt(string.length()-1-i)){
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var string : String ; string := sc.getCurrent() ;
     var isHuiwen : boolean ; isHuiwen := isHuiWen(string) ;
     OclFile["System.out"].println(if isHuiwen then "Yes" else "No" endif) );
  static   operation isHuiWen( string : String) : boolean
  pre: true
  post: true
  activity: (     var m : int ; m := (string->size() - 1) / 2 ;
     var n : int ; n := (string->size() + 3) / 2 - 1 ;
        var i : int ; i := 0 ; while i < m do ( (     if (string->at(i+1) /= string->at(string->size() - 1 - i+1)) then (     return false ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m / 2 do ( (     if (string->at(i+1) /= string->at(m - 1 - i+1)) then (     return false ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := n ; while i < (3 * string->size() - 1) / 4 do ( (     if (string->at(i+1) /= string->at(string->size() - 1 - i+1)) then (     return false ) else skip )  ;     i := i + 1 ) ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    B solver=new B();
    solver.solve(1,in,out);
    out.close();
  }
  static class B {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      String S=in.next();
      int n=S.length();
      int n1=(int)Math.ceil((n-1)/2);
      int n2=(int)Math.ceil((n+3)/2);
      String s1=S.substring(0,n1);
      String s2=S.substring(n2-1);
      boolean test1=palindrome(S);
      boolean test2=palindrome(s1);
      boolean test3=palindrome(s2);
      if(test1==true && test2==true && test3==true){
        out.println("Yes");
        return ;
      }
      out.println("No");
    }
    boolean palindrome(String arg){
      char str[]=arg.toCharArray();
      for(int i=0 ; i<str.length/2 ; i++){
        if(str[i]!=str[str.length-i-1])return false ;
      }
      return true ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : B ; solver := B.newB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class B {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var S : String ; S := in.getCurrent() ;
     var n : int ; n := S->size() ;
    var n1 : int ; n1 := (((n)->char2byte() - 1) / 2)->ceil()->oclAsType(int) ;
    var n2 : int ; n2 := ((n + 3) / 2)->ceil()->oclAsType(int) ;
    var s1 : String ; s1 := S.subrange(0+1,n1) ;
    var s2 : String ; s2 := S.subrange(n2 - 1+1,n2 - 1) ;
    var test1 : boolean ; test1 := palindrome(S) ;
    var test2 : boolean ; test2 := palindrome(s1) ;
    var test3 : boolean ; test3 := palindrome(s2) ;
    if (test1 = true & test2 = true & test3 = true) then (     skip ; 
     return ) else skip ; 
    skip ; 
 );
   operation palindrome( arg : String) : boolean
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := arg->characters() ;
         var i : int ; i := 0 ; while i < str->size() / 2 do ( (     if (str[i+1] /= str[str->size() - (i)->char2byte() - 1+1]) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class Word {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int n=cin.nextInt();
    int a[]=new int[n];
    int suma=0 ;
    int juft=0,toq=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=cin.nextInt();
      if(a[i] % 2==0){
        juft++;
        suma+=a[i];
      }
      else {
        toq++;
      }
    }
    Arrays.sort(a);
    if(toq>=1){
      if(toq % 2==0)toq--;
      for(int i=n-1 ; i>=0 && toq>=1 ; i--){
        if(a[i] % 2!=0){
          suma+=a[i];
          toq--;
        }
      }
    }
    else suma=0 ;
    System.out.println(suma);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Word {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := cin.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var suma : int ; suma := 0 ;
    var juft : int ; juft := 0 ;
    var toq : int ; toq := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := cin.getCurrent()->toInteger() ; 
     if (a[i+1] mod 2 = 0) then (     juft := juft + 1 ; 
     suma := suma+(a[i+1]) ) else (     toq := toq + 1 ) )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    if (toq >= 1) then (     if (toq mod 2 = 0) then     toq := toq - 1 ; else skip ; 
         var i : int ; i := n - 1 ; while i >= 0 & toq >= 1 do ( (     if (a[i+1] mod 2 /= 0) then (     suma := suma+(a[i+1]) ; 
     toq := toq - 1 ) else skip )  ;     i := i - 1 ) ) else     suma := 0 ; ;  
    OclFile["System.out"].println(suma) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countUnmarked(int N){
    if(N % 2==0)return N/2 ;
    else return N/2+1 ;
  }
  public static void main(String[] args){
    int N=4 ;
    System.out.println("Number of unmarked "+"elements: "+countUnmarked(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countUnmarked( N : int) : int
  pre: true
  post: true
  activity: (     if (N mod 2 = 0) then     return N / 2 else     return N / 2 + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println("Number of unmarked " + "elements: " + countUnmarked(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double nthRoot(long A,long N){
    double xPre=7 ;
    double eps=1e-3 ;
    double delX=Integer.MAX_VALUE ;
    double xK=0 ;
    while(delX>eps){
      xK=((N-1.0)*xPre+(double)A/Math.pow(xPre,N-1))/(double)N ;
      delX=Math.abs(xK-xPre);
      xPre=xK ;
    }
    return xK ;
  }
  static boolean check(long no,int k){
    double kth_root=nthRoot(no,k);
    long num=(long)kth_root ;
    if(Math.abs(num-kth_root)<1e-4)return true ;
    return false ;
  }
  static void printExpo(long arr[],int n,int k){
    for(int i=0 ; i<n ; i++){
      if(check(arr[i],k))System.out.print(arr[i]+" ");
    }
  }
  public static void main(String[] args){
    int K=6 ;
    long arr[]={
      46656,64,256,729,16,1000 };
      int n=arr.length ;
      printExpo(arr,n,K);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nthRoot( A : long, N : long) : double
  pre: true
  post: true
  activity: (     var xPre : double ; xPre := 7 ;
     var eps : double ; eps := 1e-3 ;
    var delX : double ; delX := 2147483647 ;
    var xK : double ; xK := 0 ;
    while (delX > eps) do (     xK := ((N - 1.0) * xPre + A->oclAsType(double) / xPre->pow(N - 1)) / N->oclAsType(double) ; 
     delX := if xK - xPre < 0 then -(xK - xPre) else xK - xPre endif ; 
     xPre := xK ) ; 
    return xK 
 );
  static   operation check( no : long, k : int) : boolean
  pre: true
  post: true
  activity: (     var kth_root : double ; kth_root := nthRoot(no, k) ;
     var num : long ; num := kth_root->oclAsType(long) ;
     if (if num - kth_root < 0 then -(num - kth_root) else num - kth_root endif < 1e-4) then     return true else skip ; 
     return false );
  static   operation printExpo( arr : Sequence(long), n : int, k : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (check(arr[i+1], k)) then     OclFile["System.out"].print(arr[i+1] + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var K : int ; K := 6 ;
     var arr : Sequence(long) ; arr := Sequence{46656,64,256,729,16,1000} ;
     var n : int ; n := arr->size() ;
     execute printExpo(arr, n, K) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static int map[][];
  public static int t=0,s=0 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int data[][]=new int[n][n];
      int num[]=new int[n];
      for(int i=0 ; i<n ; i++){
        num[i]=sc.nextInt();
        for(int j=0 ; j<num[i]; j++){
          data[i][j]=sc.nextInt();
        }
      }
      int know=sc.nextInt();
      int k[]=new int[know];
      for(int i=0 ; i<know ; i++){
        k[i]=sc.nextInt();
      }
      int cnt=0,ans=0,x=0 ;
      for(int i=0 ; i<n ; i++){
        cnt=0 ;
        for(int j=0 ; j<num[i]; j++){
          for(int l=0 ; l<know ; l++){
            if(data[i][j]==k[l]){
              cnt++;
            }
          }
        }
        if(cnt==know){
          ans=i+1 ;
          x++;
        }
        else if(ans==0)ans=-1 ;
      }
      if(x>1)ans=-1 ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute map : Sequence(Sequence(int));
  static   attribute t : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var data : Sequence(Sequence(int)) ; data := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var num : Sequence(int) ; num := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     num[i+1] := sc.getCurrent()->toInteger() ; 
         var j : int ; j := 0 ; while j < num[i+1] do ( (     data[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var know : int ; know := sc.getCurrent()->toInteger() ;
    var k : Sequence(int) ; k := Integer.subrange(1,know)->collect(0) ;
        var i : int ; i := 0 ; while i < know do ( (     k[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    var ans : int ; ans := 0 ;
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     cnt := 0 ; 
         var j : int ; j := 0 ; while j < num[i+1] do ( (         var l : int ; l := 0 ; while l < know do ( (     if (data[i+1][j+1] = k[l+1]) then (     cnt := cnt + 1 ) else skip )  ;     l := l + 1 ) )  ;     j := j + 1 ) ; 
     if (cnt = know) then (     ans := i + 1 ; 
     x := x + 1 ) else     if (ans = 0) then     ans := -1 ; else skip ; )  ;     i := i + 1 ) ; 
    if (x > 1) then     ans := -1 ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,k,i,j,h,res ;
    int[] m,l ;
    int[][] p ;
    for(; ; ){
      n=sc.nextInt();
      if(n==0)break ;
      m=new int[n];
      p=new int[n][n];
      for(i=0 ; i<n ; i++){
        m[i]=sc.nextInt();
        for(j=0 ; j<m[i]; j++)p[i][j]=sc.nextInt();
      }
      k=sc.nextInt();
      l=new int[k];
      for(i=0 ; i<k ; i++)l[i]=sc.nextInt();
      res=-1 ;
      for(i=0 ; i<n ; i++){
        if(m[i]<k)continue ;
        for(j=0 ; j<k ; j++){
          for(h=0 ; h<m[i]; h++)if(p[i][h]==l[j])break ;
          if(h==m[i])break ;
        }
        if(j==k && res>-1){
          res=-1 ;
          break ;
        }
        else if(j==k)res=i+1 ;
      }
      out.println(res);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var k : int ;
    var i : int ;
    var j : int ;
    var h : int ;
    var res : int ;
    var m : Sequence(int) ;
    var l : Sequence(int) ;
    var p : Sequence(Sequence(int)) ;
      while true do ( (     n := sc.nextInt() ; 
     if (n = 0) then     break else skip ; 
    m := Integer.subrange(1,n)->collect(0) ; 
    p := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
        i := 0 ; while i < n do ( (     m[i+1] := sc.nextInt() ; 
         j := 0 ; while j < m[i+1] do (     p[i+1][j+1] := sc.nextInt() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    k := sc.nextInt() ; 
    l := Integer.subrange(1,k)->collect(0) ; 
        i := 0 ; while i < k do (     l[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
    res := -1 ; 
        i := 0 ; while i < n do ( (     if (m[i+1] < k) then     continue else skip ; 
         j := 0 ; while j < k do ( (         h := 0 ; while h < m[i+1] do (     if (p[i+1][h+1] = l[j+1]) then     break else skip ;  ;     h := h + 1 ) ; 
     if (h = m[i+1]) then     break else skip )  ;     j := j + 1 ) ; 
     if (j = k & res > -1) then (     res := -1 ; 
     break ) else     if (j = k) then     res := i + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    out.println(res) ; 
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static boolean solve(){
    int n=in.nextInt();
    if(n==0)return false ;
    boolean[][] f=new boolean[n][n];
    for(int i=0 ; i<n ; i++){
      int m=in.nextInt();
      for(int j=0 ; j<m ; j++){
        f[i][in.nextInt()-1]=true ;
      }
    }
    int k=in.nextInt();
    int[] l=new int[k];
    for(int i=0 ; i<k ; i++){
      l[i]=in.nextInt()-1 ;
    }
    Arrays.sort(l);
    int ans=-1 ;
    for(int i=0 ; i<n ; i++){
      boolean ff=true ;
      for(int j=0 ; j<k ; j++){
        ff=ff && f[i][l[j] ];
      }
      if(ff){
        if(ans!=-1){
          out.println("-1");
          return true ;
        }
        ans=i+1 ;
      }
    }
    out.println(ans);
    return true ;
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    while(solve());
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return false else skip ; 
    var f : Sequence(Sequence(boolean)) ; f := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ;
        var i : int ; i := 0 ; while i < n do ( (     var m : int ; m := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < m do ( (     f[i+1][in.getCurrent()->toInteger() - 1+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var k : int ; k := in.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     l[i+1] := in.getCurrent()->toInteger() - 1 )  ;     i := i + 1 ) ; 
    l := l->sort() ; 
    var ans : int ; ans := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var ff : boolean ; ff := true ;
         var j : int ; j := 0 ; while j < k do ( (     ff := ff & f[i+1][l[j+1]+1] )  ;     j := j + 1 ) ; 
     if (ff) then (     if (ans /= -1) then (     skip ; 
     return true ) else skip ; 
     ans := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    while (solve()) do  ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int n ;
  static boolean[][] list ;
  static boolean[] k ;
  public static void main(String[] args){
    while(read()){
      solve();
    }
  }
  static boolean read(){
    n=sc.nextInt();
    if(n==0)return false ;
    list=new boolean[n+1][n+1];
    k=new boolean[n+1];
    for(boolean[] a : list)Arrays.fill(a,false);
    Arrays.fill(k,false);
    for(int i=1 ; i<list.length ; i++){
      int c=sc.nextInt();
      for(int j=1 ; j<=c ; j++){
        list[i][sc.nextInt()]=true ;
      }
    }
    int c=sc.nextInt();
    for(int i=1 ; i<=c ; i++){
      k[sc.nextInt()]=true ;
    }
    return true ;
  }
  static void solve(){
    boolean isIdentify=true ;
    boolean isHeCriminal=true ;
    int criminal=-1 ;
    for(int i=1 ; i<list.length ; i++){
      for(int j=1 ; j<list[0] .length ; j++){
        if(k[j] && ! list[i][j])isHeCriminal=false ;
      }
      if(criminal==-1 && isHeCriminal){
        criminal=i ;
      }
      else if(isHeCriminal){
        isIdentify=false ;
      }
      isHeCriminal=true ;
    }
    if(isIdentify){
      System.out.println(criminal);
    }
    else {
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   attribute list : Sequence(Sequence(boolean));
  static   attribute k : Sequence(boolean);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (read()) do (     execute solve() ) );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     return false else skip ; 
    list := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(false)) ; 
    k := Integer.subrange(1,n + 1)->collect(false) ; 
    for (a : list) do (     a := a->collect(false) ;  ) ; 
    k := k->collect(false) ; 
        var i : int ; i := 1 ; while i < list->size() do ( (     var c : int ; c := sc.getCurrent()->toInteger() ;
         var j : int ; j := 1 ; while j <= c do ( (     list[i+1][sc.getCurrent()->toInteger()+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var c : int ; c := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= c do ( (     k[sc.getCurrent()->toInteger()+1] := true )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var isIdentify : boolean ; isIdentify := true ;
     var isHeCriminal : boolean ; isHeCriminal := true ;
    var criminal : int ; criminal := -1 ;
        var i : int ; i := 1 ; while i < list->size() do ( (         var j : int ; j := 1 ; while j < list[0+1]->size() do ( (     if (k[j+1] & not(list[i+1][j+1])) then     isHeCriminal := false ; else skip )  ;     j := j + 1 ) ; 
     if (criminal = -1 & isHeCriminal) then (     criminal := i ) else     if (isHeCriminal) then (     isIdentify := false ) else skip ; ;  
     isHeCriminal := true )  ;     i := i + 1 ) ; 
    if (isIdentify) then (     OclFile["System.out"].println(criminal) ) else (     OclFile["System.out"].println(-1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(stdIn.hasNext()){
      int N=stdIn.nextInt();
      if(N==0){
        break ;
      }
      boolean[][] info=new boolean[101][101];
      for(int i=0 ; i<101 ; ++i){
        for(int j=0 ; j<101 ; ++j){
          info[i][j]=false ;
        }
      }
      for(int i=1 ; i<=N ; ++i){
        int M=stdIn.nextInt();
        for(int j=0 ; j<M ; ++j){
          int p=stdIn.nextInt();
          info[i][p]=true ;
        }
      }
      int K=stdIn.nextInt();
      List<Integer>list=new ArrayList<Integer>();
      for(int i=0 ; i<K ; ++i){
        int a=stdIn.nextInt();
        list.add(a);
      }
      int alreadyFlag=0 ;
      int ans=0 ;
      for(int i=1 ; i<=N ; ++i){
        boolean flag=true ;
        for(int j=0 ; j<K ; ++j){
          if(! info[i][list.get(j)]){
            flag=false ;
            break ;
          }
        }
        if(flag){
++alreadyFlag ;
          ans=i ;
          if(alreadyFlag>=2){
            System.out.println(-1);
            break ;
          }
        }
      }
      if(alreadyFlag==1){
        System.out.println(ans);
      }
      else if(alreadyFlag==0){
        System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (stdIn.hasNext()) do (     var N : int ; N := stdIn.getCurrent()->toInteger() ;
     if (N = 0) then (     break ) else skip ; 
    var info : Sequence(Sequence(boolean)) ; info := Integer.subrange(1,101)->collect(Integer.subrange(1,101)->collect(false)) ;
        var i : int ; i := 0 ; while i < 101 do ( (         var j : int ; j := 0 ; while j < 101 do ( (     info[i+1][j+1] := false )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (     var M : int ; M := stdIn.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < M do ( (     var p : int ; p := stdIn.getCurrent()->toInteger() ;
     info[i+1][p+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var K : int ; K := stdIn.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < K do ( (     var a : int ; a := stdIn.getCurrent()->toInteger() ;
     list := list->including(a) )  ;     i := i + 1 ) ; 
    var alreadyFlag : int ; alreadyFlag := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     var flag : boolean ; flag := true ;
         var j : int ; j := 0 ; while j < K do ( (     if (not(info[i+1][list->at(j+1)+1])) then (     flag := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (flag) then (     alreadyFlag := alreadyFlag + 1 ; 
     ans := i ; 
     if (alreadyFlag >= 2) then (     OclFile["System.out"].println(-1) ; 
     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (alreadyFlag = 1) then (     OclFile["System.out"].println(ans) ) else     if (alreadyFlag = 0) then (     OclFile["System.out"].println(-1) ) else skip ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class H {
  static Scanner sc=new Scanner(System.in);
  public static void Solve(){
    int n ;
    int m ;
    n=sc.nextInt();
    m=sc.nextInt();
    Long[] A=new Long[n+5];
    Long[] B=new Long[m+5];
    for(int i=1 ; i<=n ; i++){
      A[i]=sc.nextLong();
    }
    for(int i=1 ; i<=m ; i++){
      B[i]=sc.nextLong();
    }
    Arrays.sort(A,1,n+1,(x,y)->(int)(y-x));
    long total=0 ;
    int j=1 ;
    for(int i=1 ; i<=n ; i++){
      if(B[j]<B[A[i] .intValue()]){
        if(j<m){
          total+=B[j];
          j++;
        }
      }
      else if(B[j]>=B[A[i] .intValue()]){
        total+=B[A[i] .intValue()];
      }
    }
    System.out.println(total);
  }
  public static void main(String[] args){
    int t ;
    t=sc.nextInt();
    while(t-->0){
      Solve();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class H {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation Solve() : void
  pre: true
  post: true
  activity: (     var n : int ;
     var m : int ;
    n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
    var A : Sequence(long) ; A := Integer.subrange(1,n + 5)->collect(null) ;
    var B : Sequence(long) ; B := Integer.subrange(1,m + 5)->collect(null) ;
        var i : int ; i := 1 ; while i <= n do ( (     A[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= m do ( (     B[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    A, 1, n + 1, lambda (x , y) : OclAny in (y - x)->oclAsType(int) := A, 1, n + 1, lambda (x , y) : OclAny in (y - x)->oclAsType(int)->sort() ; 
    var total : long ; total := 0 ;
    var j : int ; j := 1 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (B[j+1] < B[A[i+1]->oclAsType(int)+1]) then (     if (j < m) then (     total := total+(B[j+1]) ; 
     j := j + 1 ) else skip ) else     if (B[j+1] >= B[A[i+1]->oclAsType(int)+1]) then (     total := total+(B[A[i+1]->oclAsType(int)+1]) ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ;
     t := sc.getCurrent()->toInteger() ; 
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute Solve() ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getMaximumSumWithLCMN(int N){
    int sum=0 ;
    int LIM=(int)Math.sqrt(N);
    for(int i=1 ; i<=LIM ; i++){
      if(N % i==0){
        if(i==(N/i))sum+=i ;
        else sum+=(i+N/i);
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int N=12 ;
    System.out.println(getMaximumSumWithLCMN(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getMaximumSumWithLCMN( N : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var LIM : int ; LIM := (N)->sqrt()->oclAsType(int) ;
         var i : int ; i := 1 ; while i <= LIM do ( (     if (N mod i = 0) then (     if (i = (N / i)) then     sum := sum+(i) ; else     sum := sum+((i + N / i)) ; ) else skip )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 12 ;
     OclFile["System.out"].println(getMaximumSumWithLCMN(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class CountSmaller {
  void constructLowerArray(int arr[],int countSmaller[],int n){
    int i,j ;
    for(i=0 ; i<n ; i++)countSmaller[i]=0 ;
    for(i=0 ; i<n ; i++){
      for(j=i+1 ; j<n ; j++){
        if(arr[j]<arr[i])countSmaller[i]++;
      }
    }
  }
  void printArray(int arr[],int size){
    int i ;
    for(i=0 ; i<size ; i++)System.out.print(arr[i]+" ");
    System.out.println("");
  }
  public static void main(String[] args){
    CountSmaller small=new CountSmaller();
    int arr[]={
      12,10,5,4,2,20,6,1,0,2 };
      int n=arr.length ;
      int low[]=new int[n];
      small.constructLowerArray(arr,low,n);
      small.printArray(low,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class CountSmaller {
   operation constructLowerArray( arr : Sequence(int), countSmaller : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := 0 ; while i < n do (     countSmaller[i+1] := 0 ;  ;     i := i + 1 ) ; 
         i := 0 ; while i < n do ( (         j := i + 1 ; while j < n do ( (     if (arr[j+1] < arr[i+1]) then     countSmaller[i+1] := countSmaller[i+1] + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
   operation printArray( arr : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
         i := 0 ; while i < size do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var small : CountSmaller ; small := CountSmaller.newCountSmaller() ;
     var arr : Sequence(int) ; arr := Sequence{12,10,5,4,2,20,6,1,0,2} ;
    var n : int ; n := arr->size() ;
    var low : Sequence(int) ; low := Integer.subrange(1,n)->collect(0) ;
    small.constructLowerArray(arr, low, n) ; 
    small.printArray(low, n) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int nCr(int n,int r){
    if(r>n/2)r=n-r ;
    int answer=1 ;
    for(int i=1 ; i<=r ; i++){
      answer*=(n-r+i);
      answer/=i ;
    }
    return answer ;
  }
  static float binomialProbability(int n,int k,float p){
    return nCr(n,k)*(float)Math.pow(p,k)*(float)Math.pow(1-p,n-k);
  }
  public static void main(String[] args){
    int n=10 ;
    int k=5 ;
    float p=(float)1.0/3 ;
    float probability=binomialProbability(n,k,p);
    System.out.print("Probability of "+k);
    System.out.print(" heads when a coin is tossed "+n);
    System.out.println(" times where probability of each head is "+p);
    System.out.println(" is="+probability);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nCr( n : int, r : int) : int
  pre: true
  post: true
  activity: (     if (r > n / 2) then     r := n - r ; else skip ; 
     var answer : int ; answer := 1 ;
         var i : int ; i := 1 ; while i <= r do ( (     answer := answer*((n - r + i)) ; 
     answer := answer/(i) )  ;     i := i + 1 ) ; 
     return answer );
  static   operation binomialProbability( n : int, k : int, p : double) : double
  pre: true
  post: true
  activity: (     return nCr(n, k) * p->pow(k)->oclAsType(double) * 1 - p->pow(n - k)->oclAsType(double) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     var k : int ; k := 5 ;
    var p : double ; p := 1.0->oclAsType(double) / 3 ;
    var probability : double ; probability := binomialProbability(n, k, p) ;
    OclFile["System.out"].print("Probability of " + k) ; 
    OclFile["System.out"].print(" heads when a coin is tossed " + n) ; 
    OclFile["System.out"].println(" times where probability of each head is " + p) ; 
    OclFile["System.out"].println(" is=" + probability) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemB {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    String s=br.readLine();
    int n=s.length();
    int ans=9,carry=0 ;
    for(int i=n-1 ; i>0 ; i--){
      int curr=s.charAt(i)-'0' ;
      if(carry>0 &&(curr+carry)% 10==0)continue ;
      ans+=(9-(curr+carry)+1);
      carry=1 ;
    }
    System.out.println(ans);
  }
  public static void sort(int arr[]){
    ArrayList<Integer>list=new ArrayList<>();
    for(int it : arr)list.add(it);
    Collections.sort(list);
    for(int i=0 ; i<arr.length ; i++)arr[i]=list.get(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var s : String ; s := br.readLine() ;
    var n : int ; n := s->size() ;
    var ans : int ; ans := 9 ;
    var carry : int ; carry := 0 ;
        var i : int ; i := (n)->char2byte() - 1 ; while i > 0 do ( (     var curr : int ; curr := s->at(i+1) - ('0')->char2byte() ;
     if (carry > 0 & (curr + carry) mod 10 = 0) then     continue else skip ; 
     ans := ans+((9 - (curr + carry) + 1)) ; 
     carry := 1 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation sort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     for (it : arr) do (     list := list->including(it) ;  ) ; 
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < arr->size() do (     arr[i+1] := list->at(i+1) ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GfG {
  static int longSubarrWthSumDivByK(int arr[],int n,int k){
    HashMap<Integer,Integer>um=new HashMap<Integer,Integer>();
    int mod_arr[]=new int[n];
    int max=0 ;
    int curr_sum=0 ;
    for(int i=0 ; i<n ; i++){
      curr_sum+=arr[i];
      mod_arr[i]=((curr_sum % k)+k)% k ;
    }
    for(int i=0 ; i<n ; i++){
      if(mod_arr[i]==0)max=i+1 ;
      else if(um.containsKey(mod_arr[i])==false)um.put(mod_arr[i],i);
      else if(max<(i-um.get(mod_arr[i])))max=i-um.get(mod_arr[i]);
    }
    return max ;
  }
  public static void main(String[] args){
    int arr[]={
      2,7,6,1,4,5 };
      int n=arr.length ;
      int k=3 ;
      System.out.println("Length="+longSubarrWthSumDivByK(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation longSubarrWthSumDivByK( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var um : Map(int,int) ; um := Map{} ;
     var mod_arr : Sequence(int) ; mod_arr := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := 0 ;
    var curr_sum : int ; curr_sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     curr_sum := curr_sum+(arr[i+1]) ; 
     mod_arr[i+1] := ((curr_sum mod k) + k) mod k )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (mod_arr[i+1] = 0) then     max := i + 1 ; else     if (um->keys()->includes(mod_arr[i+1]) = false) then     um := um->union(Map{mod_arr[i+1] |-> i}) else     if (max < (i - um->at(mod_arr[i+1]))) then     max := i - um->at(mod_arr[i+1]) ; else skip ; ;  )  ;     i := i + 1 ) ; 
    return max 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,7,6,1,4,5} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println("Length=" + longSubarrWthSumDivByK(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class ToyBlocks {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t!=0){
      solve(br,pr);
      t--;
    }
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    long max=0 ;
    String[] temp=br.readLine().split(" ");
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      int num=Integer.parseInt(temp[i]);
      sum+=num ;
      max=Math.max(max,num);
    }
    long res=(long)(n-1)*max-sum ;
    if(res<0){
      res=((res %(n-1))+n-1)%(n-1);
    }
    pr.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ToyBlocks {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
    while (t /= 0) do (     execute solve(br, pr) ; 
     t := t - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var max : long ; max := 0 ;
    var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := (temp[i+1])->toInteger() ;
     sum := sum+(num) ; 
     max := Set{max, num}->max() )  ;     i := i + 1 ) ; 
    var res : long ; res := (n - 1)->oclAsType(long) * max - sum ;
    if (res < 0) then (     res := ((res mod (n - 1)) + n - 1) mod (n - 1) ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testCases=sc.nextInt();
    for(int i=0 ; i<testCases ; i++){
      int elemNum=sc.nextInt();
      int[] arr=new int[elemNum];
      for(int j=0 ; j<elemNum ; j++){
        arr[j]=sc.nextInt();
      }
      System.out.println(solve(arr));
    }
  }
  public static long solve(int[] arr){
    int n=arr.length ;
    long sum=0 ;
    int max=Integer.MIN_VALUE ;
    for(int a : arr){
      if(a>max)max=a ;
      sum+=a ;
    }
    long elem=Long.max((sum+n-2)/(n-1),max);
    return elem*(n-1)-sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < testCases do ( (     var elemNum : int ; elemNum := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,elemNum)->collect(0) ;
         var j : int ; j := 0 ; while j < elemNum do ( (     arr[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(solve(arr)) )  ;     i := i + 1 ) );
  static   operation solve( arr : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
     var sum : long ; sum := 0 ;
    var max : int ; max := -2147483648 ;
    for (a : arr) do ( (     if (a > max) then     max := a ; else skip ; 
     sum := sum+(a) )  ) ; 
    var elem : long ; elem := Set{(sum + n - 2) / (n - 1), max}->max() ;
    return elem * (n - 1) - sum 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ToyBlocksCf {
  public static Scanner sc=new Scanner(System.in);
  public static long NoOfBoxsNeedToAdd(long arr[],int n){
    int k=n-1 ;
    long max=-1 ;
    if(n==1 || n==2){
      return 0 ;
    }
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]>=max){
        max=arr[i];
      }
      sum+=arr[i];
    }
    if(sum==0){
      return 0 ;
    }
    double f=(double)sum/k ;
    if(max<=Math.ceil(f)){
      return(long)(k*(Math.ceil(f))-sum);
    }
    else {
      return max*k-sum ;
    }
  }
  public static void main(String[] args){
    int test=sc.nextInt();
    for(int i=0 ; i<test ; i++){
      int n=sc.nextInt();
      long arr[]=new long[n];
      for(int j=0 ; j<n ; j++){
        arr[j]=sc.nextInt();
      }
      System.out.println(NoOfBoxsNeedToAdd(arr,n));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ToyBlocksCf {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation NoOfBoxsNeedToAdd( arr : Sequence(long), n : int) : long
  pre: true
  post: true
  activity: (     var k : int ; k := n - 1 ;
     var max : long ; max := -1 ;
    if (n = 1 or n = 2) then (     return 0 ) else skip ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] >= max) then (     max := arr[i+1] ) else skip ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    if (sum = 0) then (     return 0 ) else skip ; 
    var f : double ; f := sum->oclAsType(double) / k ;
    if (max <= (f)->ceil()) then (     return (k * ((f)->ceil()) - sum)->oclAsType(long) ) else (     return max * k - sum ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var test : int ; test := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < test do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
         var j : int ; j := 0 ; while j < n do ( (     arr[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(NoOfBoxsNeedToAdd(arr, n)) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String allBitsSetInTheGivenRange(int n,int l,int r){
    int num=((1<<r)-1)^((1<<(l-1))-1);
    int new_num=n & num ;
    if(num==new_num)return "Yes" ;
    return "No" ;
  }
  public static void main(String[] args){
    int n=22 ;
    int l=2,r=3 ;
    System.out.print(allBitsSetInTheGivenRange(n,l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation allBitsSetInTheGivenRange( n : int, l : int, r : int) : String
  pre: true
  post: true
  activity: (     var num : int ; num := MathLib.bitwiseXor((((1*(2->pow(r)))->oclAsType(long)) - 1),(((1*(2->pow((l - 1))))->oclAsType(long)) - 1)) ;
     var new_num : int ; new_num := MathLib.bitwiseAnd(n,num) ;
     if (num = new_num) then     return "Yes" else skip ; 
     return "No" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 22 ;
     var l : int ; l := 2 ;
    var r : int ; r := 3 ;
     OclFile["System.out"].print(allBitsSetInTheGivenRange(n, l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      int a=scan.nextInt()*4+scan.nextInt()*2+scan.nextInt();
      System.out.println((a==1 || a==6)? "Open" : "Close");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var a : int ; a := scan.getCurrent()->toInteger() * 4 + scan.getCurrent()->toInteger() * 2 + scan.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if (a = 1 or a = 6) then "Open" else "Close" endif) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Scanner ;
public class Bai8 {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    for(int x=0 ; x<t ; x++){
      int n=scan.nextInt();
      int m=scan.nextInt();
      int k[]=new int[n+1];
      int c[]=new int[m+1];
      List<Gift>list=new ArrayList<>();
      for(int i=1 ; i<=n ; i++){
        k[i]=scan.nextInt();
        list.add(new Gift(i,k[i]));
      }
      for(int j=1 ; j<=m ; j++){
        c[j]=scan.nextInt();
      }
      int[] tempC=c ;
      Collections.sort(list,new Comparator<Gift>(){
        public int compare(Gift o1,Gift o2){
          return o2.value-o1.value ;
        }
      }
);
      long sum=0 ;
      int index=1 ;
      for(Gift g : list){
        if(index<=m && c[index]<c[g.value]){
          sum+=c[index];
          index++;
        }
        else {
          sum+=c[g.value];
        }
      }
      System.out.println(sum);
    }
  }
  static class Gift {
    private int index ;
    private int value ;
    public Gift(int index,int value){
      this.index=index ;
      this.value=value ;
    }
    public int getIndex(){
      return index ;
    }
    public void setIndex(int index){
      this.index=index ;
    }
    public int getValue(){
      return value ;
    }
    public void setValue(int value){
      this.value=value ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Bai8 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         var x : int ; x := 0 ; while x < t do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var m : int ; m := scan.getCurrent()->toInteger() ;
    var k : Sequence(int) ; k := Integer.subrange(1,n + 1)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,m + 1)->collect(0) ;
    var list : Sequence(Gift) ; list := Sequence{} ;
        var i : int ; i := 1 ; while i <= n do ( (     k[i+1] := scan.getCurrent()->toInteger() ; 
     list := list->including(Gift.newGift(i, k[i+1])) )  ;     i := i + 1 ) ; 
        var j : int ; j := 1 ; while j <= m do ( (     c[j+1] := scan.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    var tempC : Sequence(int) ; tempC := c ;
    list, OclComparator<Gift>.newOclComparator() := list, OclComparator<Gift>.newOclComparator()->sort() ; 
    var sum : long ; sum := 0 ;
    var index : int ; index := 1 ;
    for (g : list) do ( (     if (index <= m & c[index+1] < c[g.value+1]) then (     sum := sum+(c[index+1]) ; 
     index := index + 1 ) else (     sum := sum+(c[g.value+1]) ) )  ) ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     x := x + 1 ) );
  static class Gift {
   attribute index : int;
   attribute value : int;
   static operation newGift( index : int, value : int) : Gift
  pre: true
  post: true
  activity:
  ( var self : Gift ;
    self := createGift();
    self.initialise(index, value);
    return self );
  operation initialise( index : int, value : int) : void
  pre: true  post: true
  activity: (     self.index := index ; 
     self.value := value );
   operation getIndex() : int
  pre: true
  post: true
  activity: (     return index );
   operation setIndex( index : int) : void
  pre: true
  post: true
  activity: (     self.index := index );
   operation getValue() : int
  pre: true
  post: true
  activity: (     return value );
   operation setValue( value : int) : void
  pre: true
  post: true
  activity: (     self.value := value );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  int a ;
  int b ;
  int c ;
  Main(){
    Scanner sc=new Scanner(System.in);
    a=sc.nextInt();
    b=sc.nextInt();
    c=sc.nextInt();
    if(a==1 && b==1 && c==0 || a==0 && b==0 && c==1){
      System.out.println("Open");
    }
    else if(a==1 && b==0 && c==0 || a==0 && b==1 && c==0 || a==0 && b==0 && c==0){
      System.out.println("Close");
    }
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute a : int;
   attribute b : int;
   attribute c : int;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    c := sc.getCurrent()->toInteger() ; 
    if (a = 1 & b = 1 & c = 0 or a = 0 & b = 0 & c = 1) then (     OclFile["System.out"].println("Open") ) else     if (a = 1 & b = 0 & c = 0 or a = 0 & b = 1 & c = 0 or a = 0 & b = 0 & c = 0) then (     OclFile["System.out"].println("Close") ) else skip ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(is);
    String str ;
    if((str=br.readLine())!=null){
      if(str.equals("1 0 0")|| str.equals("0 1 0")|| str.equals("0 0 0")){
        System.out.println("Close");
      }
      else {
        System.out.println("Open");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(is) ;
     var str : String ;
     if ((str) /= null) then (     if (str = "1 0 0" or str = "0 1 0" or str = "0 0 0") then (     OclFile["System.out"].println("Close") ) else (     OclFile["System.out"].println("Open") ) ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public void syori(){
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=a*100+b*10+c ;
    switch(d){
      case 110 : System.out.println("Open");
      break ;
      case 1 : System.out.println("Open");
      break ;
      default : System.out.println("Close");
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.syori();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation syori() : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := a * 100 + b * 10 + c ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (d) ; 
       if _switchval = 110 then
     OclFile["System.out"].println("Open") ; 
    break 
   else skip ;
       if _switchval = 1 then
     OclFile["System.out"].println("Open") ; 
    break 
   else skip ;
       if true then
     OclFile["System.out"].println("Close") ; 
   else skip ;
 )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.syori() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new AOJ0257().doIt();
  }
  class AOJ0257 {
    void doIt(){
      HashMap<String,String>map=new HashMap<String,String>();
      map.put("1 0 0","Close");
      map.put("0 1 0","Close");
      map.put("1 1 0","Open");
      map.put("0 0 1","Open");
      map.put("0 0 0","Close");
      while(in.hasNext()){
        System.out.println(map.get(in.nextLine()));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     AOJ0257.newAOJ0257().doIt() );
 class AOJ0257 {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var map : Map(String,String) ; map := Map{} ;
     map := map->union(Map{"1 0 0" |-> "Close"}) ; 
    map := map->union(Map{"0 1 0" |-> "Close"}) ; 
    map := map->union(Map{"1 1 0" |-> "Open"}) ; 
    map := map->union(Map{"0 0 1" |-> "Open"}) ; 
    map := map->union(Map{"0 0 0" |-> "Close"}) ; 
    while (in.hasNext()) do (     OclFile["System.out"].println(map->at(in.nextLine())) ) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static class Icicle implements Comparable<Icicle>{
    int t,i ;
    Icicle(int t,int i){
      this.t=t ;
      this.i=i ;
    }
    public int compareTo(Icicle ic){
      return this.t-ic.t ;
    }
  }
  public static final void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int l=sc.nextInt();
    int[] tis=new int[n];
    for(int i=0 ; i<n ; i++)tis[i]=sc.nextInt();
    PriorityQueue<Icicle>q=new PriorityQueue<Icicle>();
    boolean[] broken=new boolean[n];
    Arrays.fill(broken,false);
    for(int i=0 ; i<n ; i++)if((i==0 || tis[i]>tis[i-1])&&(i==n-1 || tis[i]>tis[i+1])){
      q.add(new Icicle(l-tis[i],i));
      broken[i]=true ;
    }
    int time=0 ;
    while(! q.isEmpty()){
      Icicle ic0=q.poll();
      time=ic0.t ;
      tis[ic0.i]=0 ;
      if(ic0.i>0){
        int i1=ic0.i-1 ;
        if(! broken[i1] &&(i1==0 || tis[i1]>tis[i1-1])){
          q.add(new Icicle(time+l-tis[i1],i1));
          broken[i1]=true ;
        }
      }
      if(ic0.i<n-1){
        int i2=ic0.i+1 ;
        if(! broken[i2] &&(i2==n-1 || tis[i2]>tis[i2+1])){
          q.add(new Icicle(time+l-tis[i2],i2));
          broken[i2]=true ;
        }
      }
    }
    System.out.println(time);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Icicle implements Comparable<Icicle> {
   attribute t : int;
   static operation newIcicle( t : int, i : int) : Icicle
  pre: true
  post: true
  activity:
  ( var self : Icicle ;
    self := createIcicle();
    self.initialise(t, i);
    return self );
  operation initialise( t : int, i : int) : void
  pre: true  post: true
  activity: (     self.t := t ; 
     self.i := i );
   operation compareTo( ic : Icicle) : int
  pre: true
  post: true
  activity: (     return self.t - ic.t );
}
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var tis : Sequence(int) ; tis := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     tis[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var q : Sequence(Icicle) ; q := Sequence{} ;
    var broken : Sequence(boolean) ; broken := Integer.subrange(1,n)->collect(false) ;
    broken := broken->collect(false) ; 
        var i : int ; i := 0 ; while i < n do (     if ((i = 0 or tis[i+1] > tis[i - 1+1]) & (i = n - 1 or tis[i+1] > tis[i + 1+1])) then (     q := q->including(Icicle.newIcicle(l - tis[i+1], i)) ; 
     broken[i+1] := true ) else skip ;  ;     i := i + 1 ) ; 
    var time : int ; time := 0 ;
    while (not(q->isEmpty())) do (     var ic0 : Icicle ; ic0 := q->min() ;
     time := ic0.t ; 
    tis[ic0.i+1] := 0 ; 
    if (ic0.i > 0) then (     var i1 : int ; i1 := ic0.i - 1 ;
     if (not(broken[i1+1]) & (i1 = 0 or tis[i1+1] > tis[i1 - 1+1])) then (     q := q->including(Icicle.newIcicle(time + l - tis[i1+1], i1)) ; 
     broken[i1+1] := true ) else skip ) else skip ; 
    if (ic0.i < n - 1) then (     var i2 : int ; i2 := ic0.i + 1 ;
     if (not(broken[i2+1]) & (i2 = n - 1 or tis[i2+1] > tis[i2 + 1+1])) then (     q := q->including(Icicle.newIcicle(time + l - tis[i2+1], i2)) ; 
     broken[i2+1] := true ) else skip ) else skip ; 
 ) ; 
    OclFile["System.out"].println(time) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc ;
  int K,X ;
  public Main(){
    sc=new Scanner(System.in);
  }
  private void calc(){
    K=sc.nextInt();
    X=sc.nextInt();
    int min=X-(K-1);
    int max=X+(K-1);
    if(min<-1000000)min=-1000000 ;
    if(max>1000000)max=1000000 ;
    for(int i=min ; i<=max ; i++){
      System.out.print(i);
      if(i<max)System.out.print(" ");
    }
    System.out.println();
    System.out.flush();
  }
  public static void main(String[] args){
    Main m=new Main();
    m.calc();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute K : int;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation calc() : void
  pre: true
  post: true
  activity: (     K := sc.getCurrent()->toInteger() ; 
     X := sc.getCurrent()->toInteger() ; 
    var min : int ; min := X - (K - 1) ;
    var max : int ; max := X + (K - 1) ;
    if (min < -1000000) then     min := -1000000 ; else skip ; 
    if (max > 1000000) then     max := 1000000 ; else skip ; 
        var i : int ; i := min ; while i <= max do ( (     OclFile["System.out"].print(i) ; 
     if (i < max) then     OclFile["System.out"].print(" ") ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    OclFile["System.out"].flush() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.calc() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static class Icicle implements Comparable<Icicle>{
    int len ;
    int pos ;
    public Icicle(int len,int pos){
      super();
      this.len=len ;
      this.pos=pos ;
    }
    @ Override public int compareTo(Icicle arg0){
      return arg0.len-this.len ;
    }
    @ Override public String toString(){
      return "Icicle[len="+len+",pos="+pos+"] " ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final int N=sc.nextInt();
    final int L=sc.nextInt();
    int[] array=new int[N];
    for(int i=0 ; i<N ; i++){
      array[i]=sc.nextInt();
    }
    int[] time=new int[N];
    Icicle[] icicles=new Icicle[N];
    for(int i=0 ; i<N ; i++){
      icicles[i]=new Icicle(array[i],i);
    }
    Arrays.sort(icicles);
    int max_t=0 ;
    for(Icicle ice : icicles){
      int pre_time=0 ;
      if(ice.pos>0 && pre_time<time[ice.pos-1]){
        pre_time=time[ice.pos-1];
      }
      if(ice.pos<N-1 && pre_time<time[ice.pos+1]){
        pre_time=time[ice.pos+1];
      }
      time[ice.pos]=L-ice.len+pre_time ;
      max_t=Math.max(max_t,time[ice.pos]);
    }
    System.out.println(max_t);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Icicle implements Comparable<Icicle> {
   attribute len : int;
   attribute pos : int;
   static operation newIcicle( len : int, pos : int) : Icicle
  pre: true
  post: true
  activity:
  ( var self : Icicle ;
    self := createIcicle();
    self.initialise(len, pos);
    return self );
  operation initialise( len : int, pos : int) : void
  pre: true  post: true
  activity: (     execute super() ; 
     self.len := len ; 
     self.pos := pos );
      operation compareTo( arg0 : Icicle) : int
  pre: true
  post: true
  activity: (     return arg0.len - self.len );
      operation toString() : String
  pre: true
  post: true
  activity: (     return "Icicle[len=" + len + ",pos=" + pos + "] " );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var L : int ; L := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     array[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var time : Sequence(int) ; time := Integer.subrange(1,N)->collect(0) ;
    var icicles : Sequence(Icicle) ; icicles := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     icicles[i+1] := Icicle.newIcicle(array[i+1], i) )  ;     i := i + 1 ) ; 
    icicles := icicles->sort() ; 
    var max_t : int ; max_t := 0 ;
    for (ice : icicles) do ( (     var pre_time : int ; pre_time := 0 ;
     if (ice.pos > 0 & pre_time < time[ice.pos - 1+1]) then (     pre_time := time[ice.pos - 1+1] ) else skip ; 
    if (ice.pos < N - 1 & pre_time < time[ice.pos + 1+1]) then (     pre_time := time[ice.pos + 1+1] ) else skip ; 
    time[ice.pos+1] := L - ice.len + pre_time ; 
    max_t := Set{max_t, time[ice.pos+1]}->max() ; 
 )  ) ; 
    OclFile["System.out"].println(max_t) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  int[] icecle ;
  P[] pair ;
  int[] mem ;
  int n,l ;
  void run(){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    l=sc.nextInt();
    mem=new int[n+2];
    icecle=new int[n+2];
    pair=new P[n+2];
    pair[0]=new P(0,INF);
    pair[n+1]=new P(0,INF);
    fill(mem,0);
    for(int i=1 ; i<=n ; i++){
      icecle[i]=sc.nextInt();
      pair[i]=new P(i,icecle[i]);
    }
    sort(pair,new MyComp());
    long max=0 ;
    mem[n+1]=0 ;
    mem[0]=0 ;
    for(int i=0 ; i<n ; i++){
      mem[pair[i] .x]=max(mem[pair[i] .x-1],mem[pair[i] .x+1])+time(pair[i] .x);
      max=max(max,mem[pair[i] .x]);
    }
    System.out.println(max);
  }
  int time(int x){
    return l-icecle[x];
  }
  class MyComp implements Comparator<P>{
    @ Override public int compare(P o1,P o2){
      return o1.y-o2.y ;
    }
  }
  class P {
    int x,y ;
    P(int x,int y){
      this.x=x ;
      this.y=y ;
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute icecle : Sequence(int);
   attribute pair : Sequence(P);
   attribute mem : Sequence(int);
   attribute n : int;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    l := sc.getCurrent()->toInteger() ; 
    mem := Integer.subrange(1,n + 2)->collect(0) ; 
    icecle := Integer.subrange(1,n + 2)->collect(0) ; 
    pair := Integer.subrange(1,n + 2)->collect(null) ; 
    pair[0+1] := P.newP(0, INF) ; 
    pair[n + 1+1] := P.newP(0, INF) ; 
    execute fill(mem, 0) ; 
        var i : int ; i := 1 ; while i <= n do ( (     icecle[i+1] := sc.getCurrent()->toInteger() ; 
     pair[i+1] := P.newP(i, icecle[i+1]) )  ;     i := i + 1 ) ; 
    execute sort(pair, MyComp.newMyComp()) ; 
    var max : long ; max := 0 ;
    mem[n + 1+1] := 0 ; 
    mem[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     mem[pair[i+1].x+1] := Set{mem[pair[i+1].x - 1+1], mem[pair[i+1].x + 1+1]}->max() + time(pair[i+1].x) ; 
     max := Set{max, mem[pair[i+1].x+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
   operation time( x : int) : int
  pre: true
  post: true
  activity: (     return l - icecle[x+1] );
 class MyComp implements Function(<P>,(<P>,boolean)) {
      operation compare( o1 : P, o2 : P) : int
  pre: true
  post: true
  activity: (     return o1.y - o2.y );
}
 class P {
   attribute x : int;
   static operation newP( x : int, y : int) : P
  pre: true
  post: true
  activity:
  ( var self : P ;
    self := createP();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int l=sc.nextInt();
    int[] a=new int[n+4];
    for(int i=0 ; i<n ; i++){
      a[i+2]=sc.nextInt();
    }
    PriorityQueue<Icicle>growing=new PriorityQueue<Icicle>();
    for(int i=2 ; i<n+2 ; i++){
      if(a[i]>=a[i-1] && a[i]>=a[i+1]){
        growing.add(new Icicle(i,l-a[i]));
      }
    }
    int ans=0 ;
    while(! growing.isEmpty()){
      Icicle icicle=growing.poll();
      int i=icicle.pos ;
      int t=icicle.time ;
      a[i]=0 ;
      if(a[i-1]>a[i-2]){
        growing.offer(new Icicle(i-1,t+l-a[i-1]));
      }
      if(a[i+1]>a[i+2]){
        growing.offer(new Icicle(i+1,t+l-a[i+1]));
      }
      ans=t ;
    }
    System.out.println(ans);
  }
}
class Icicle implements Comparable<Icicle>{
  int pos ;
  int time ;
  public Icicle(int pos,int time){
    this.pos=pos ;
    this.time=time ;
  }
  public boolean equalsTo(Object o){
    if(o instanceof Icicle){
      return time==((Icicle)o).time ;
    }
    else {
      return false ;
    }
  }
  @ Override public int compareTo(Icicle o){
    return time-o.time ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 4)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i + 2+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var growing : Sequence(Icicle) ; growing := Sequence{} ;
        var i : int ; i := 2 ; while i < n + 2 do ( (     if (a[i+1] >= a[i - 1+1] & a[i+1] >= a[i + 1+1]) then (     growing := growing->including(Icicle.newIcicle(i, l - a[i+1])) ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    while (not(growing->isEmpty())) do (     var icicle : Icicle ; icicle := growing->min() ;
     var i : int ; i := icicle.pos ;
    var t : int ; t := icicle.time ;
    a[i+1] := 0 ; 
    if (a[i - 1+1] > a[i - 2+1]) then (     growing := growing->including(Icicle.newIcicle(i - 1, t + l - a[i - 1+1])) ) else skip ; 
    if (a[i + 1+1] > a[i + 2+1]) then (     growing := growing->including(Icicle.newIcicle(i + 1, t + l - a[i + 1+1])) ) else skip ; 
    ans := t ; 
 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}
class Icicle implements Comparable<Icicle> {
   attribute pos : int;
   attribute time : int;
   static operation newIcicle( pos : int, time : int) : Icicle
  pre: true
  post: true
  activity:
  ( var self : Icicle ;
    self := createIcicle();
    self.initialise(pos, time);
    return self );
  operation initialise( pos : int, time : int) : void
  pre: true  post: true
  activity: (     self.pos := pos ; 
     self.time := time );
   operation equalsTo( o : OclAny) : boolean
  pre: true
  post: true
  activity: (     if (o->oclIsKindOf(Icicle)) then (     return time = (o->oclAsType(Icicle)).time ) else (     return false ) );
      operation compareTo( o : Icicle) : int
  pre: true
  post: true
  activity: (     return time - o.time );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findMaximumNum(int arr[],int n){
    for(int i=n ; i>=1 ; i--){
      int count=0 ;
      for(int j=0 ; j<n ; j++)if(i<=arr[j])count++;
      if(count>=i)return i ;
    }
    return 1 ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,8,10 };
      int n=arr.length ;
      System.out.println(findMaximumNum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMaximumNum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := n ; while i >= 1 do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < n do (     if (i <= arr[j+1]) then     count := count + 1 ; else skip ;  ;     j := j + 1 ) ; 
     if (count >= i) then     return i else skip )  ;     i := i - 1 ) ; 
     return 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,8,10} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMaximumNum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt(),b=sc.nextInt(),c=sc.nextInt(),d=sc.nextInt();
    int x=a/d+aa(a % d),y=c/b+aa(c % b);
    if(x>=y){
      pl("Yes");
    }
    else {
      pl("No");
    }
  }
  public static int aa(int n){
    if(n>0){
      return 1 ;
    }
    return 0 ;
  }
  public static void pr(String str){
    System.out.print(str);
  }
  public static void pl(String str){
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
     var x : int ; x := a / d + aa(a mod d) ;
    var y : int ; y := c / b + aa(c mod b) ;
     if (x >= y) then (     execute pl("Yes") ) else (     execute pl("No") ) );
  static   operation aa( n : int) : int
  pre: true
  post: true
  activity: (     if (n > 0) then (     return 1 ) else skip ; 
     return 0 );
  static   operation pr( str : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(str) );
  static   operation pl( str : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(str) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.io.PrintStream ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    FastReader in=new FastReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BBattle solver=new BBattle();
    solver.solve(1,in,out);
    out.close();
  }
  static class BBattle {
    public void solve(int testNumber,FastReader in,PrintWriter out){
      int hA=in.nextInt();
      int sA=in.nextInt();
      int hB=in.nextInt();
      int sB=in.nextInt();
      while(true){
        hB-=sA ;
        if(hB<=0){
          out.println("Yes");
          return ;
        }
        hA-=sB ;
        if(hA<=0){
          out.println("No");
          return ;
        }
      }
    }
  }
  static class FastReader {
    public BufferedReader br ;
    public StringTokenizer st ;
    String context=null ;
    public FastReader(InputStream in){
      this(new InputStreamReader(in));
    }
    public FastReader(InputStreamReader input){
      br=new BufferedReader(input);
    }
    public String next(){
      if(context!=null){
        System.err.print("["+context+"] Wait for input...");
      }
      while(st==null || ! st.hasMoreElements()){
        try {
          String s=br.readLine();
          if(s==null)return null ;
          st=new StringTokenizer(s);
        }
        catch(IOException e){
          e.printStackTrace();
          throw new RuntimeException("Could not read");
        }
      }
      String res=st.nextToken();
      if(context!=null){
        System.err.println("["+context+"] ...received : "+res);
      }
      return res ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : FastReader ; in := FastReader.newFastReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BBattle ; solver := BBattle.newBBattle() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BBattle {
   operation solve( testNumber : int, in : FastReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var hA : int ; hA := in.nextInt() ;
     var sA : int ; sA := in.nextInt() ;
    var hB : int ; hB := in.nextInt() ;
    var sB : int ; sB := in.nextInt() ;
    while (true) do (     hB := hB-(sA) ; 
     if (hB <= 0) then (     skip ; 
     return ) else skip ; 
     hA := hA-(sB) ; 
     if (hA <= 0) then (     skip ; 
     return ) else skip ) ; 
 );
}
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   attribute context : String := null;
   static operation newFastReader( in : OclFile) : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     execute this(OclFile.newOclFile_Read(in)) );
   static operation newFastReader( input : OclFile) : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise(input);
    return self );
  operation initialise( input : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(input) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (context /= null) then (     OclFile["System.err"].print("[" + context + "] Wait for input...") ) else skip ; 
     while (st = null or not(st.hasNext())) do (     try (     var s : String ; s := br.readLine() ;
     if (s = null) then     return null else skip ; 
     st := OclIterator.newOclIterator_String(s) )   catch (e : IOException) do (     e.printStackTrace() ; 
     error ProgramException("Could not read") )
 ) ; 
    var res : String ; res := st.next() ;
    if (context /= null) then (     OclFile["System.err"].println("[" + context + "] ...received : " + res) ) else skip ; 
    return res 
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class Main {
  static InputStreamReader in=new InputStreamReader(System.in);
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args)throws Exception {
    try(BufferedReader br=new BufferedReader(in)){
      String[] s=br.readLine().split(" ");
      int a=Integer.parseInt(s[0]);
      int b=Integer.parseInt(s[1]);
      int c=Integer.parseInt(s[2]);
      int d=Integer.parseInt(s[3]);
      while(true){
        c-=b ;
        if(c<=0){
          out.println("Yes");
          break ;
        }
        a-=d ;
        if(a<=0){
          out.println("No");
          break ;
        }
      }
      out.flush();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(in) ;
 (     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
     var a : int ; a := (s[0+1])->toInteger() ;
    var b : int ; b := (s[1+1])->toInteger() ;
    var c : int ; c := (s[2+1])->toInteger() ;
    var d : int ; d := (s[3+1])->toInteger() ;
    while (true) do (     c := c-(b) ; 
     if (c <= 0) then (     skip ; 
     break ) else skip ; 
     a := a-(d) ; 
     if (a <= 0) then (     skip ; 
     break ) else skip ) ; 
    skip ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  static PrintStream o=System.out ;
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    short thealth=sc.nextShort();
    short tattack=sc.nextShort();
    short ahealth=sc.nextShort();
    short aattack=sc.nextShort();
    while(true){
      ahealth-=tattack ;
      if(ahealth<=0){
        o.println("Yes");
        break ;
      }
      thealth-=aattack ;
      if(thealth<=0){
        o.println("No");
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute o : OclFile := OclFile["System.out"];
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var thealth : int ; thealth := sc.nextShort() ;
    var tattack : int ; tattack := sc.nextShort() ;
    var ahealth : int ; ahealth := sc.nextShort() ;
    var aattack : int ; aattack := sc.nextShort() ;
    while (true) do (     ahealth := ahealth-(tattack) ; 
     if (ahealth <= 0) then (     skip ; 
     break ) else skip ; 
     thealth := thealth-(aattack) ; 
     if (thealth <= 0) then (     skip ; 
     break ) else skip ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.System.*;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  static void solve()throws Exception {
    int a=scanInt(),b=scanInt(),c=scanInt(),d=scanInt();
    while(true){
      c-=b ;
      if(c<=0){
        out.println("Yes");
        break ;
      }
      a-=d ;
      if(a<=0){
        out.println("No");
        break ;
      }
    }
  }
  static int scanInt()throws IOException {
    return parseInt(scanString());
  }
  static long scanLong()throws IOException {
    return parseLong(scanString());
  }
  static String scanString()throws IOException {
    while(tok==null || ! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  public static void main(String[] args){
    try {
      in=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(System.out);
      solve();
      in.close();
      out.close();
    }
    catch(Throwable e){
      e.printStackTrace();
      exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ; a := scanInt() ;
    var b : int ; b := scanInt() ;
    var c : int ; c := scanInt() ;
    var d : int ; d := scanInt() ;
     while (true) do (     c := c-(b) ; 
     if (c <= 0) then (     out.println("Yes") ; 
     break ) else skip ; 
     a := a-(d) ; 
     if (a <= 0) then (     out.println("No") ; 
     break ) else skip ) );
  static   operation scanInt() : int
  pre: true
  post: true
  activity: (     return (scanString() + "")->toInteger() );
  static   operation scanLong() : long
  pre: true
  post: true
  activity: (     return parseLong(scanString()) );
  static   operation scanString() : String
  pre: true
  post: true
  activity: (     while (tok = null or not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return tok.next() );
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
     execute exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class GFG {
  static int maxlen=100 ;
  public static void generateSubStrings(String s,HashMap<String,Integer>mpp){
    int l=s.length();
    for(int i=0 ; i<l ; i++){
      String temp="" ;
      for(int j=i ; j<l ; j++){
        temp+=s.charAt(j);
        if(mpp.containsKey(temp)){
          int x=mpp.get(temp);
          mpp.put(temp,++x);
        }
        else mpp.put(temp,1);
      }
    }
  }
  public static void binomialCoeff(int[][] C){
    int i,j ;
    for(i=1 ; i<100 ; i++){
      for(j=0 ; j<100 ; j++){
        if(j==0 || j==i)C[i][j]=1 ;
        else C[i][j]=C[i-1][j-1]+C[i-1][j];
      }
    }
  }
  public static int answerQuery(HashMap<String,Integer>mpp,int[][] C,int k){
    int ans=0 ;
    for(HashMap.Entry<String,Integer>entry : mpp.entrySet()){
      if(entry.getValue()>=k)ans+=C[entry.getValue()][k];
    }
    return ans ;
  }
  public static void main(String[] args){
    String s="aabaab" ;
    HashMap<String,Integer>mpp=new HashMap<>();
    generateSubStrings(s,mpp);
    int[][] C=new int[maxlen][maxlen];
    binomialCoeff(C);
    int[] queries={
      2,3,4 };
      int q=queries.length ;
      for(int i=0 ; i<q ; i++)System.out.println(answerQuery(mpp,C,queries[i]));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute maxlen : int := 100;
  static   operation generateSubStrings( s : String, mpp : Map(String,int)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := s->size() ;
         var i : int ; i := 0 ; while i < l do ( (     var temp : String ; temp := "" ;
         var j : int ; j := i ; while j < l do ( (     temp := temp+(s->at(j+1)) ; 
     if (mpp.containsKey(temp)) then (     var x : int ; x := mpp->at(temp+1) ;
     mpp := mpp->union(Map{temp |-> (x + 1)}) ) else     mpp := mpp->union(Map{temp |-> 1}) ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation binomialCoeff( C : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := 1 ; while i < 100 do ( (         j := 0 ; while j < 100 do ( (     if (j = 0 or j = i) then     C[i+1][j+1] := 1 ; else     C[i+1][j+1] := C[i - 1+1][(j)->char2byte() - 1+1] + C[i - 1+1][j+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation answerQuery( mpp : Map(String,int), C : Sequence(Sequence(int)), k : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     for (entry : mpp->asSet()) do ( (     if (entry.getValue() >= k) then     ans := ans+(C[entry.getValue()+1][k+1]) ; else skip )  ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "aabaab" ;
     var mpp : Map(String,int) ; mpp := Map{} ;
    execute generateSubStrings(s, mpp) ; 
    var C : Sequence(Sequence(int)) ; C := Integer.subrange(1,maxlen)->collect(Integer.subrange(1,maxlen)->collect(0)) ;
    execute binomialCoeff(C) ; 
    var queries : Sequence(int) ; queries := Sequence{2,3,4} ;
    var q : int ; q := queries->size() ;
        var i : int ; i := 0 ; while i < q do (     OclFile["System.out"].println(answerQuery(mpp, C, queries[i+1])) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.util.Collections ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BOneClue solver=new BOneClue();
    solver.solve(1,in,out);
    out.close();
  }
  static class BOneClue {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int k=in.nextInt();
      int x=in.nextInt();
      ArrayList<Integer>a=new ArrayList<>();
      a.add(x);
      if(x-k+1>=-1000000)for(int i=1 ;
      i<=k-1 ;
      i++){
        a.add(x-i);
      }
      if(x+k-1<=1000000)for(int i=1 ;
      i<=k-1 ;
      i++){
        a.add(x+i);
      }
      Collections.sort(a);
      for(int i=0 ; i<a.size(); i++){
        out.print(a.get(i)+" ");
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BOneClue ; solver := BOneClue.newBOneClue() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BOneClue {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var k : int ; k := in.nextInt() ;
     var x : int ; x := in.nextInt() ;
    var a : Sequence(int) ; a := Sequence{} ;
    a := a->including(x) ; 
    if (x - k + 1 >= -1000000) then         var i : int ; i := 1 ; while i <= k - 1 do ( (     a := a->including(x - i) )  ;     i := i + 1 ) ; else skip ; 
    if (x + k - 1 <= 1000000) then         var i : int ; i := 1 ; while i <= k - 1 do ( (     a := a->including(x + i) )  ;     i := i + 1 ) ; else skip ; 
    a := a->sort() ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     skip )  ;     i := i + 1 ) ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class D {
  public int findMinx(int l,int r,int d){
    int x=d ;
    if(x<l || x>r){
      return x ;
    }
    x=((r/d)*d)+d ;
    return x ;
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    D test=new D();
    int num=scanner.nextInt();
    for(int i=0 ; i<num ; ++i){
      int l=scanner.nextInt();
      int r=scanner.nextInt();
      int d=scanner.nextInt();
      System.out.println(test.findMinx(l,r,d));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
   operation findMinx( l : int, r : int, d : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := d ;
     if (x < l or x > r) then (     return x ) else skip ; 
     x := ((r / d) * d) + d ; 
     return x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : D ; test := D.newD() ;
     var num : int ; num := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < num do ( (     var l : int ; l := scanner.getCurrent()->toInteger() ;
     var r : int ; r := scanner.getCurrent()->toInteger() ;
     var d : int ; d := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(test.findMinx(l, r, d)) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem20220728D {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int row=sc.nextInt();
    while(row>0){
      row--;
      int l=sc.nextInt();
      int r=sc.nextInt();
      int d=sc.nextInt();
      int res=d ;
      if(d>=l && d<=r){
        res=r+d-r % d ;
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem20220728D {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var row : int ; row := sc.getCurrent()->toInteger() ;
     while (row > 0) do (     row := row - 1 ; 
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var res : int ; res := d ;
    if (d >= l & d <= r) then (     res := r + d - r mod d ) else skip ; 
    OclFile["System.out"].println(res) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main4 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int q=scanner.nextInt();
    for(int i=0 ; i<q ; i++){
      int l=scanner.nextInt();
      int r=scanner.nextInt();
      int d=scanner.nextInt();
      if(l>d || r<d){
        System.out.println(d);
        continue ;
      }
      System.out.println((((r/d)+1)*d));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main4 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < q do ( (     var l : int ; l := scanner.getCurrent()->toInteger() ;
     var r : int ; r := scanner.getCurrent()->toInteger() ;
    var d : int ; d := scanner.getCurrent()->toInteger() ;
    if (l > d or r < d) then (     OclFile["System.out"].println(d) ; 
     continue ) else skip ; 
    OclFile["System.out"].println((((r / d) + 1) * d)) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder(br.readLine());
    int n=Integer.parseInt(br.readLine());
    StringBuilder temp ;
    for(int i=0 ; i<n ; i++){
      String[] splitCommand=br.readLine().split(" ");
      int a=Integer.parseInt(splitCommand[1]);
      int b=Integer.parseInt(splitCommand[2]);
      if(splitCommand[0] .startsWith("p")){
        System.out.println(sb.substring(a,b+1));
      }
      else if(splitCommand[0] .startsWith("rev")){
        temp=new StringBuilder(sb.substring(a,b+1));
        temp.reverse();
        sb.replace(a,b+1,new String(temp));
      }
      else {
        String p=splitCommand[3];
        sb.replace(a,b+1,p);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString(br.readLine()) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var temp : String ;
        var i : int ; i := 0 ; while i < n do ( (     var splitCommand : Sequence(String) ; splitCommand := br.readLine()->split(" ") ;
     var a : int ; a := (splitCommand[1+1])->toInteger() ;
     var b : int ; b := (splitCommand[2+1])->toInteger() ;
     if (splitCommand[0+1]->hasPrefix("p")) then (     OclFile["System.out"].println(sb.subrange(a+1,b + 1)) ) else     if (splitCommand[0+1]->hasPrefix("rev")) then (     temp := StringLib.newString(sb.subrange(a+1,b + 1)) ; 
     temp := temp->reverse() ; 
     sb.replace(a, b + 1, StringLib.newString(temp)) ) else (     var p : String ; p := splitCommand[3+1] ;
     sb.replace(a, b + 1, p) ) ;  )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class Test4 {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int caseSize=Integer.parseInt(reader.readLine());
    List<String[]>inputTestData=new ArrayList<>();
    for(int i=0 ; i<caseSize ; i++){
      String data=reader.readLine();
      inputTestData.add(data.split(" "));
    }
    inputTestData.forEach(Test4 :: deal);
  }
  public static void deal(String[] testData){
    int l=Integer.parseInt(testData[0]);
    int r=Integer.parseInt(testData[1]);
    int d=Integer.parseInt(testData[2]);
    if(d<l || d>r){
      System.out.println(d);
    }
    else {
      System.out.println((r/d+1)*d);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test4 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var caseSize : int ; caseSize := (reader.readLine())->toInteger() ;
    var inputTestData : Sequence(Sequence(String)) ; inputTestData := Sequence{} ;
        var i : int ; i := 0 ; while i < caseSize do ( (     var data : String ; data := reader.readLine() ;
     inputTestData := inputTestData->including(data->split(" ")) )  ;     i := i + 1 ) ; 
    for _forEach : inputTestData do
    (    skip ;) ; 
 );
  static   operation deal( testData : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := (testData[0+1])->toInteger() ;
     var r : int ; r := (testData[1+1])->toInteger() ;
     var d : int ; d := (testData[2+1])->toInteger() ;
     if (d < l or d > r) then (     OclFile["System.out"].println(d) ) else (     OclFile["System.out"].println((r / d + 1) * d) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int l=sc.nextInt();
      int r=sc.nextInt();
      int k=sc.nextInt();
      if(!(k>=l && k<=r))System.out.println(k);
      else {
        System.out.println(k*(r/k+1));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     if (not((k >= l & k <= r))) then     OclFile["System.out"].println(k) ; else (     OclFile["System.out"].println(k * (r / k + 1)) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    if(a+b>=c){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    if (a + b >= c) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws Exception {
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String[] coins=br.readLine().split(" ");
      int pocketMoney=Integer.parseInt(coins[0])+Integer.parseInt(coins[1]);
      int toyPrice=Integer.parseInt(coins[2]);
      String heCanBuyToy="No" ;
      if(pocketMoney>=toyPrice){
        heCanBuyToy="Yes" ;
      }
      System.out.println(heCanBuyToy);
    }
    catch(IOException | NumberFormatException e){
      e.printStackTrace();
      System.exit(0);
    }
    catch(final Exception e){
      e.printStackTrace();
      System.exit(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var coins : Sequence(String) ; coins := br.readLine()->split(" ") ;
    var pocketMoney : int ; pocketMoney := (coins[0+1])->toInteger() + (coins[1+1])->toInteger() ;
    var toyPrice : int ; toyPrice := (coins[2+1])->toInteger() ;
    var heCanBuyToy : String ; heCanBuyToy := "No" ;
    if (pocketMoney >= toyPrice) then (     heCanBuyToy := "Yes" ) else skip ; 
    OclFile["System.out"].println(heCanBuyToy) ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
 OclProcess.exit(0) )
   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(0) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    String result="No" ;
    if(a+b>=c)result="Yes" ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var result : String ; result := "No" ;
    if (a + b >= c) then     result := "Yes" ; else skip ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.Stream ;
public class Main {
  public static void main(final String[] args)throws Exception {
    final Scanner sc=new Scanner(System.in);
    final int A=sc.nextInt();
    final int B=sc.nextInt();
    final int C=sc.nextInt();
    System.out.println(A+B>=C ? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(if A + B >= C then "Yes" else "No" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    try(Scanner in=new Scanner(System.in)){
      int A=in.nextInt();
      int B=in.nextInt();
      int C=in.nextInt();
      System.out.println(A+B>=C ? "Yes" : "No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var A : int ; A := in.getCurrent()->toInteger() ;
     var B : int ; B := in.getCurrent()->toInteger() ;
     var C : int ; C := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if A + B >= C then "Yes" else "No" endif) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    String[] arr=reader.readLine().split(" ");
    int K,X ;
    K=Integer.parseInt(arr[0]);
    X=Integer.parseInt(arr[1]);
    StringJoiner sj=new StringJoiner(" ");
    for(int i=X-K+1 ; i<X+K ; i++)sj.add(String.valueOf(i));
    System.out.println(sj.toString());
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var arr : Sequence(String) ; arr := reader.readLine()->split(" ") ;
    var K : int ;
    var X : int ;
    K := (arr[0+1])->toInteger() ; 
    X := (arr[1+1])->toInteger() ; 
    var sj : StringJoiner ; sj := StringJoiner.newStringJoiner(" ") ;
        var i : int ; i := X - K + 1 ; while i < X + K do (     sj->excludes(((i) + "")) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sj+"") ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long x=scanner.nextLong();
    long y=scanner.nextLong();
    long z=y/x ;
    System.out.println(ruijou(z)+1);
  }
  public static long ruijou(long n){
    if(n<2){
      return 0 ;
    }
    else {
      return ruijou(n/2)+1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := scanner.getCurrent()->toLong() ;
    var y : long ; y := scanner.getCurrent()->toLong() ;
    var z : long ; z := y / x ;
    OclFile["System.out"].println(ruijou(z) + 1) ; 
 );
  static   operation ruijou( n : long) : long
  pre: true
  post: true
  activity: (     if (n < 2) then (     return 0 ) else (     return ruijou(n / 2) + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastScanner sc=new FastScanner(System.in);
    long x=sc.nextLong(),y=sc.nextLong();
    long ans=1 ;
    while(x<y){
      x*=2 ;
      if(x<=y){
        ans++;
      }
    }
    System.out.println(ans);
  }
  static class FastScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public FastScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
      tokenizer=null ;
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          return reader.readLine();
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken("\n");
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public int[] nextIntArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    public long[] nextLongArray(int n){
      long[] a=new long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var x : long ; x := sc.nextLong() ;
    var y : long ; y := sc.nextLong() ;
    var ans : long ; ans := 1 ;
    while (x < y) do (     x := x*(2) ; 
     if (x <= y) then (     ans := ans + 1 ) else skip ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class FastScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.nextToken("\n") );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    try {
      BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
      String str=input.readLine();
      int n=Integer.parseInt(input.readLine());
      for(int i=0 ; i<n ; i++){
        String[] line=input.readLine().split(" ");
        String command=line[0];
        int begin=Integer.parseInt(line[1]);
        int end=Integer.parseInt(line[2])+1 ;
        if(command.equals("print")){
          System.out.println(str.substring(begin,end));
        }
        else if(command.equals("reverse")){
          if(begin==0){
            str=new StringBuffer(str.substring(0,end)).reverse().toString().concat(str.substring(end));
          }
          else if(end==str.length()){
            str=str.substring(0,begin).concat(new StringBuffer(str.substring(begin)).reverse().toString());
          }
          else {
            str=str.substring(0,begin).concat(new StringBuffer(str.substring(begin,end)).reverse().toString()).concat(str.substring(end));
          }
        }
        else if(command.equals("replace")){
          if(begin==0){
            str=line[3] .concat(str.substring(end));
          }
          else if(end==str.length()){
            str=str.substring(0,begin).concat(line[3]);
          }
          else {
            str=str.substring(0,begin).concat(line[3]).concat(str.substring(end));
          }
        }
      }
      input.close();
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := input.readLine() ;
    var n : int ; n := (input.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var line : Sequence(String) ; line := input.readLine()->split(" ") ;
     var command : String ; command := line[0+1] ;
    var begin : int ; begin := (line[1+1])->toInteger() ;
    var end : int ; end := (line[2+1])->toInteger() + 1 ;
    if (command = "print") then (     OclFile["System.out"].println(str.subrange(begin+1,end)) ) else     if (command = "reverse") then (     if (begin = 0) then (     str := StringLib.newString(str.subrange(0+1,end))->reverse()+""+str.subrange(end+1,end) ) else     if (end = str->size()) then (     str := str.subrange(0+1,begin)+StringLib.newString(str.subrange(begin+1,begin))->reverse()+"" ) else (     str := str.subrange(0+1,begin)+StringLib.newString(str.subrange(begin+1,end))->reverse()+""+str.subrange(end+1,end) ) ;  ) else     if (command = "replace") then (     if (begin = 0) then (     str := line[3+1]+str.subrange(end+1,end) ) else     if (end = str->size()) then (     str := str.subrange(0+1,begin)+line[3+1] ) else (     str := str.subrange(0+1,begin)+line[3+1]+str.subrange(end+1,end) ) ;  ) else skip ; ;  ;  
 )  ;     i := i + 1 ) ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String args[])throws Exception {
    FastReader sc=new FastReader();
    PrintWriter out=new PrintWriter(System.out);
    long x=sc.nextLong();
    long y=sc.nextLong();
    int s=0 ;
    while(x<=y){
      x*=2 ;
      s++;
    }
    out.println(s);
    out.close();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var x : long ; x := sc.nextLong() ;
    var y : long ; y := sc.nextLong() ;
    var s : int ; s := 0 ;
    while (x <= y) do (     x := x*(2) ; 
     s := s + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    MyScanner sc=new MyScanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    long x=sc.nextLong(),y=sc.nextLong();
    int ans=1 ;
    while(x<<1<=y){
      x<<=1 ;
      ans++;
    }
    out.println(ans);
    out.flush();
    out.close();
  }
  private static class MyScanner {
    StringTokenizer st ;
    BufferedReader br ;
    public MyScanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public MyScanner(String filename)throws IOException {
      br=new BufferedReader(new FileReader(new File(filename)));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public double nextDouble()throws IOException {
      String x=next();
      StringBuilder sb=new StringBuilder("0");
      double res=0,f=1 ;
      boolean dec=false,neg=false ;
      int start=0 ;
      if(x.charAt(0)=='-'){
        neg=true ;
        start++;
      }
      for(int i=start ; i<x.length(); i++)if(x.charAt(i)=='.'){
        res=Long.parseLong(sb.toString());
        sb=new StringBuilder("0");
        dec=true ;
      }
      else {
        sb.append(x.charAt(i));
        if(dec)f*=10 ;
      }
      res+=Long.parseLong(sb.toString())/f ;
      return res*(neg ?-1 : 1);
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var x : long ; x := sc.nextLong() ;
    var y : long ; y := sc.nextLong() ;
    var ans : int ; ans := 1 ;
    while ((x*(2->pow(1)))->oclAsType(long) <= y) do (     x := x*(2->pow(1)) ; 
     ans := ans + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static class MyScanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newMyScanner( s : OclFile) : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newMyScanner( filename : String) : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise(filename);
    return self );
  operation initialise( filename : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(filename))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     var x : String ; x := next() ;
     var sb : String ; sb := StringLib.newString("0") ;
    var res : double ; res := 0 ;
    var f : double ; f := 1 ;
    var dec : boolean ; dec := false ;
    var neg : boolean ; neg := false ;
    var start : int ; start := 0 ;
    if (x->at(0+1) = '-') then (     neg := true ; 
     start := start + 1 ) else skip ; 
        var i : int ; i := start ; while i < x->size() do (     if (x->at(i+1) = '.') then (     res := (sb+"")->toLong() ; 
     sb := StringLib.newString("0") ; 
     dec := true ) else (     sb := sb + StringLib.newString(x->at(i+1)) ; 
     if (dec) then     f := f*(10) ; else skip ) ;   ;     i := i + 1 ) ; 
    res := res+((sb+"")->toLong() / f) ; 
    return res * (if neg then -1 else 1 endif) 
 );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(1,in,out);
    out.close();
  }
  static class Task {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      long min=in.nextLong();
      long max=in.nextLong();
      long count=0 ;
      long t=min ;
      while(max>=t){
        count++;
        t*=2 ;
      }
      out.print(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var min : long ; min := in.getCurrent()->toLong() ;
     var max : long ; max := in.getCurrent()->toLong() ;
    var count : long ; count := 0 ;
    var t : long ; t := min ;
    while (max >= t) do (     count := count + 1 ; 
     t := t*(2) ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String complement(String s){
    String comps="" ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='0')comps+='1' ;
      else comps+='0' ;
    }
    return comps ;
  }
  static String nthTerm(int n){
    String s="0" ;
    for(int i=1 ; i<n ; i++)s+=complement(s);
    return s ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.print(nthTerm(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation complement( s : String) : String
  pre: true
  post: true
  activity: (     var comps : String ; comps := "" ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '0') then     comps := comps+('1') ; else     comps := comps+('0') ; )  ;     i := i + 1 ) ; 
     return comps );
  static   operation nthTerm( n : int) : String
  pre: true
  post: true
  activity: (     var s : String ; s := "0" ;
         var i : int ; i := 1 ; while i < n do (     s := s+(complement(s)) ;  ;     i := i + 1 ) ; 
     return s );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].print(nthTerm(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class A {
  static StringBuffer str=new StringBuffer();
  static int n ;
  static int x[];
  static int solve(){
    Set<Integer>set=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        set.add(x[j]-x[i]);
      }
    }
    return set.size();
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    int q1=Integer.parseInt(bf.readLine().trim());
    while(q1-->0){
      n=Integer.parseInt(bf.readLine().trim());
      x=new int[n];
      String[] s=bf.readLine().trim().split("\\s+");
      for(int i=0 ; i<n ; i++)x[i]=Integer.parseInt(s[i]);
      str.append(solve()).append("\n");
    }
    pw.println(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute str : String := StringLib.newString();
  static   attribute n : int;
  static   attribute x : Sequence(int);
  static   operation solve() : int
  pre: true
  post: true
  activity: (     var set : Set(int) ; set := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     set := set->including(x[j+1] - x[i+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return set->size() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var q1 : int ; q1 := (bf.readLine()->trim())->toInteger() ;
        while (q1 > 0) do (        q1 := q1 - 1 ;     skip ; (     n := (bf.readLine()->trim())->toInteger() ; 
     x := Integer.subrange(1,n)->collect(0) ; 
    var s : Sequence(String) ; s := bf.readLine()->trim()->split("\\s+") ;
        var i : int ; i := 0 ; while i < n do (     x[i+1] := (s[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    str := str + StringLib.newString(solve()) + StringLib.newString("\n") ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedHashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class A1466 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      int n=scanner.nextInt();
      int[] x=new int[n];
      for(int i=0 ; i<n ; i++){
        x[i]=scanner.nextInt();
      }
      Set<Integer>set=new LinkedHashSet<>();
      for(int firstPoint=0 ; firstPoint<n-1 ; firstPoint++){
        for(int secondPoint=firstPoint+1 ; secondPoint<n ; secondPoint++){
          set.add(x[secondPoint]-x[firstPoint]);
        }
      }
      System.out.println(set.size());
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1466 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
        var firstPoint : int ; firstPoint := 0 ; while firstPoint < n - 1 do ( (         var secondPoint : int ; secondPoint := firstPoint + 1 ; while secondPoint < n do ( (     set := set->including(x[secondPoint+1] - x[firstPoint+1]) )  ;     secondPoint := secondPoint + 1 ) )  ;     firstPoint := firstPoint + 1 ) ; 
    OclFile["System.out"].println(set->size()) ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class BovineDilemma {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      Set<Integer>set=new HashSet<>();
      for(int i=0 ; i<n ; i++){
        for(int j=i+1 ; j<n ; j++){
          set.add(arr[j]-arr[i]);
        }
      }
      System.out.println(set.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BovineDilemma {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     set := set->including(arr[j+1] - arr[i+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(set->size()) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class A_Bovine_Dilemma {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int T=reader.nextInt();
    while(T!=0){
      T--;
      int N=reader.nextInt();
      int[] ip=new int[N];
      for(int i=0 ; i<N ; i++){
        ip[i]=reader.nextInt();
      }
      Set<Integer>set=new HashSet<>();
      for(int i=0 ; i<N ; i++){
        for(int j=0 ; j<i ; j++){
          set.add(ip[i]-ip[j]);
        }
      }
      System.out.println(set.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Bovine_Dilemma {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var T : int ; T := reader.nextInt() ;
     while (T /= 0) do (     T := T - 1 ; 
     var N : int ; N := reader.nextInt() ;
    var ip : Sequence(int) ; ip := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     ip[i+1] := reader.nextInt() )  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < i do ( (     set := set->including(ip[i+1] - ip[j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(set->size()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    List<Integer>list=new ArrayList<Integer>();
    int k=sc.nextInt();
    int x=sc.nextInt();
    list.add(x);
    for(int i=1 ; k>i ; i++){
      list.add(x-i);
    }
    for(int i=1 ; k>i ; i++){
      list.add(x+i);
    }
    Collections.sort(list);
    for(int i=0 ; list.size()>i ; i++){
      System.out.print(list.get(i));
      if((i+1)!=list.size()){
        System.out.print(" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(int) ; list := Sequence{} ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    list := list->including(x) ; 
        var i : int ; i := 1 ; while k > i do ( (     list := list->including(x - i) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while k > i do ( (     list := list->including(x + i) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
        var i : int ; i := 0 ; while list->size() > i do ( (     OclFile["System.out"].print(list->at(i+1)) ; 
     if ((i + 1) /= list->size()) then (     OclFile["System.out"].print(" ") ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maxSum(int arr[],int n){
    if(n<2)return-1 ;
    int ans=arr[0]+arr[1];
    for(int i=1 ; i+1<n ; i++)ans=Math.min(ans,(arr[i]+arr[i+1]));
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      1,12,2,2 };
      int n=arr.length ;
      System.out.println(maxSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n < 2) then     return -1 else skip ; 
     var ans : int ; ans := arr[0+1] + arr[1+1] ;
         var i : int ; i := 1 ; while i + 1 < n do (     ans := Set{ans, (arr[i+1] + arr[i + 1+1])}->min() ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,12,2,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.NoSuchElementException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    try {
      String s=sc.nextLine();
      int q=Integer.parseInt(sc.nextLine());
      if(s.length()>1000 || s.length()<1 || q>100 || q<1){
        throw new IllegalTestCaseException();
      }
      while(sc.hasNext()){
        String[] c_a_b_p=sc.nextLine().split(" ");
        String c=c_a_b_p[0];
        int a=Integer.parseInt(c_a_b_p[1]);
        int b=Integer.parseInt(c_a_b_p[2]);
        if(c.equals("replace")){
          s=replace(s,a,b,c_a_b_p[3]);
        }
        else if(c.equals("reverse")){
          s=reverse(s,a,b);
        }
        else if(c.equals("print")){
          System.out.println(s.substring(a,b+1));
        }
        else {
          throw new IllegalTestCaseException();
        }
      }
    }
    catch(IllegalTestCaseException | NoSuchElementException | NumberFormatException e){
      System.out.println(e);
    }
  }
  private static String replace(String s,int a,int b,String ns){
    String f="",m="",l="" ;
    if(a!=0){
      f=s.substring(0,a);
    }
    m=ns ;
    if(b!=s.length()){
      l=s.substring(b+1);
    }
    return f.concat(m).concat(l);
  }
  private static String reverse(String s,int a,int b){
    char[] cs=s.toCharArray();
    char[] ncs=cs.clone();
    for(int i=0 ; i<=b-a ; i++){
      ncs[a+i]=cs[b-i];
    }
    return String.valueOf(ncs);
  }
  private static class IllegalTestCaseException extends RuntimeException {
    IllegalTestCaseException(){
      super("Illegal condition.");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     try (     var s : String ; s := sc.nextLine() ;
     var q : int ; q := (sc.nextLine())->toInteger() ;
     if (s->size() > 1000 or s->size() < 1 or q > 100 or q < 1) then (     error IllegalTestCaseException.newIllegalTestCaseException() ) else skip ; 
     while (sc.hasNext()) do (     var c_a_b_p : Sequence(String) ; c_a_b_p := sc.nextLine()->split(" ") ;
     var c : String ; c := c_a_b_p[0+1] ;
    var a : int ; a := (c_a_b_p[1+1])->toInteger() ;
    var b : int ; b := (c_a_b_p[2+1])->toInteger() ;
    if (c = "replace") then (     s := replace(s, a, b, c_a_b_p[3+1]) ) else     if (c = "reverse") then (     s := reverse(s, a, b) ) else     if (c = "print") then (     OclFile["System.out"].println(s.subrange(a+1,b + 1)) ) else (     error IllegalTestCaseException.newIllegalTestCaseException() ) ;  ;  ;  
 ) )   catch (e : OclException) do (     OclFile["System.out"].println(e) )
 );
  static   operation replace( s : String, a : int, b : int, ns : String) : String
  pre: true
  post: true
  activity: (     var f : String ; f := "" ;
    var m : String ; m := "" ;
    var l : String ; l := "" ;
     if (a /= 0) then (     f := s.subrange(0+1,a) ) else skip ; 
    m := ns ; 
    if (b /= s->size()) then (     l := s.subrange(b + 1+1,b + 1) ) else skip ; 
    return f+m+l 
 );
  static   operation reverse( s : String, a : int, b : int) : String
  pre: true
  post: true
  activity: (     var cs : Sequence(String) ; cs := s->characters() ;
     var ncs : Sequence(String) ; ncs := cs->copy() ;
         var i : int ; i := 0 ; while i <= b - (a)->char2byte() do ( (     ncs[a + i+1] := cs[b - i+1] )  ;     i := i + 1 ) ; 
     return (ncs)->sum()  );
  static class IllegalTestCaseException extends ProgramException {
   static operation newIllegalTestCaseException() : IllegalTestCaseException
  pre: true
  post: true
  activity:
  ( var self : IllegalTestCaseException ;
    self := createIllegalTestCaseException();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super("Illegal condition.") );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Node {
    int data ;
    Node left ;
    Node right ;
  };
  static Node newNode(int data){
    Node node=new Node();
    node.data=data ;
    node.left=null ;
    node.right=null ;
    return(node);
  }
  static Node insert(Node node,int data){
    if(node==null)return(newNode(data));
    else {
      if(data<=node.data)node.left=insert(node.left,data);
      else node.right=insert(node.right,data);
      return node ;
    }
  }
  static int minValue(Node node){
    if(node.left==null)return node.data ;
    return minValue(node.left);
  }
  public static void main(String args[]){
    Node root=null ;
    root=insert(root,4);
    insert(root,2);
    insert(root,1);
    insert(root,3);
    insert(root,6);
    insert(root,5);
    System.out.println(minValue(root));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute left : Node;
   attribute right : Node;
}
  static   operation newNode( data : int) : Node
  pre: true
  post: true
  activity: (     var node : Node ; node := Node.newNode() ;
     node.data := data ; 
    node.left := null ; 
    node.right := null ; 
    return (node) 
 );
  static   operation insert( node : Node, data : int) : Node
  pre: true
  post: true
  activity: (     if (node = null) then     return (newNode(data)) else (     if (data <= node.data) then     node.left := insert(node.left, data) else     node.right := insert(node.right, data) ; ;  
     return node ) );
  static   operation minValue( node : Node) : int
  pre: true
  post: true
  activity: (     if (node.left = null) then     return node.data else skip ; 
     return minValue(node.left) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var root : Node ; root := null ;
     root := insert(root, 4) ; 
    execute insert(root, 2) ; 
    execute insert(root, 1) ; 
    execute insert(root, 3) ; 
    execute insert(root, 6) ; 
    execute insert(root, 5) ; 
    OclFile["System.out"].println(minValue(root)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maximum_one(String s,int n){
    int cnt_one=0 ;
    int max_cnt=0,temp=0 ;
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='1'){
        cnt_one++;
        temp++;
      }
      else {
        max_cnt=Math.max(max_cnt,temp);
        temp=0 ;
      }
    }
    max_cnt=Math.max(max_cnt,temp);
    int[] left=new int[n];
    int right[]=new int[n];
    if(s.charAt(0)=='1')left[0]=1 ;
    else left[0]=0 ;
    if(s.charAt(n-1)=='1')right[n-1]=1 ;
    else right[n-1]=0 ;
    for(int i=1 ; i<n ; i++){
      if(s.charAt(i)=='1')left[i]=left[i-1]+1 ;
      else left[i]=0 ;
    }
    for(int i=n-2 ; i>=0 ; i--){
      if(s.charAt(i)=='1')right[i]=right[i+1]+1 ;
      else right[i]=0 ;
    }
    for(int i=1 ; i<n-1 ; i++){
      if(s.charAt(i)=='0'){
        int sum=left[i-1]+right[i+1];
        if(sum<cnt_one)max_cnt=Math.max(max_cnt,sum+1);
        else max_cnt=Math.max(max_cnt,sum);
      }
    }
    return max_cnt ;
  }
  public static void main(String[] args){
    String s="111011101" ;
    System.out.println(maximum_one(s,s.length()));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maximum_one( s : String, n : int) : int
  pre: true
  post: true
  activity: (     var cnt_one : int ; cnt_one := 0 ;
     var max_cnt : int ; max_cnt := 0 ;
    var temp : int ; temp := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = '1') then (     cnt_one := cnt_one + 1 ; 
     temp := temp + 1 ) else (     max_cnt := Set{max_cnt, temp}->max() ; 
     temp := 0 ) )  ;     i := i + 1 ) ; 
    max_cnt := Set{max_cnt, temp}->max() ; 
    var left : Sequence(int) ; left := Integer.subrange(1,n)->collect(0) ;
    var right : Sequence(int) ; right := Integer.subrange(1,n)->collect(0) ;
    if (s->at(0+1) = '1') then     left[0+1] := 1 else     left[0+1] := 0 ; ;  
    if (s->at(n - 1+1) = '1') then     right[n - 1+1] := 1 else     right[n - 1+1] := 0 ; ;  
        var i : int ; i := 1 ; while i < n do ( (     if (s->at(i+1) = '1') then     left[i+1] := left[i - 1+1] + 1 ; else     left[i+1] := 0 ; )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (s->at(i+1) = '1') then     right[i+1] := right[i + 1+1] + 1 ; else     right[i+1] := 0 ; )  ;     i := i - 1 ) ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     if (s->at(i+1) = '0') then (     var sum : int ; sum := left[i - 1+1] + right[i + 1+1] ;
     if (sum < cnt_one) then     max_cnt := Set{max_cnt, sum + 1}->max() ; else     max_cnt := Set{max_cnt, sum}->max() ; ) else skip )  ;     i := i + 1 ) ; 
    return max_cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "111011101" ;
     OclFile["System.out"].println(maximum_one(s, s->size())) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a ;
    int b ;
    while(true){
      if(! sc.hasNext())break ;
      a=sc.nextInt();
      b=sc.nextInt();
      System.out.println(a+b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ;
     var b : int ;
     while (true) do (     if (not(sc.hasNext())) then     break else skip ; 
     a := sc.getCurrent()->toInteger() ; 
     b := sc.getCurrent()->toInteger() ; 
     OclFile["System.out"].println(a + b) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String name=br.readLine();
    int num ;
    int compare ;
    while(true){
      try {
        StringTokenizer st=new StringTokenizer(name," ");
        compare=Integer.parseInt(st.nextToken())+Integer.parseInt(st.nextToken());
        System.out.println(compare);
        name=br.readLine();
      }
      catch(Exception e){
        System.exit(0);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var name : String ; name := br.readLine() ;
    var num : int ;
    var compare : int ;
    while (true) do (     try (     var st : OclIterator ; st := OclIterator.newOclIterator_String_String(name, " ") ;
     compare := (st.next())->toInteger() + (st.next())->toInteger() ; 
     OclFile["System.out"].println(compare) ; 
     name := br.readLine() )   catch (e : ProgramException) do ( OclProcess.exit(0) )
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void doIt(){
    while(sc.hasNext()){
      System.out.println(sc.nextInt()+sc.nextInt());
    }
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     OclFile["System.out"].println(sc.getCurrent()->toInteger() + sc.getCurrent()->toInteger()) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    try {
      Main test=new Main();
      BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
      String line ;
      while((line=reader.readLine())!=null){
        String[] textArray=line.split(" ");
        System.out.println(test.plus(Integer.parseInt(textArray[0]),Integer.parseInt(textArray[1])));
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  int plus(int a,int b){
    return a+b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var test : Main ; test := Main.newMain() ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     var textArray : Sequence(String) ; textArray := line->split(" ") ;
     OclFile["System.out"].println(test.plus((textArray[0+1])->toInteger(), (textArray[1+1])->toInteger())) ) ;     line := reader.readLine() ;
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
   operation plus( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return a + b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.ArrayList ;
public class Main {
  static class Foo {
    private int val ;
    Foo(int a,int b){
      val=a+b ;
    }
    int getVal(){
      return val ;
    }
  }
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine())!=null){
      String[] nums=line.split(" ");
      int a=Integer.parseInt(nums[0]);
      int b=Integer.parseInt(nums[1]);
      Foo foo=new Foo(a,b);
      System.out.println(foo.getVal());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Foo {
   attribute val : int;
   static operation newFoo( a : int, b : int) : Foo
  pre: true
  post: true
  activity:
  ( var self : Foo ;
    self := createFoo();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     val := a + b );
   operation getVal() : int
  pre: true
  post: true
  activity: (     return val );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     var nums : Sequence(String) ; nums := line->split(" ") ;
     var a : int ; a := (nums[0+1])->toInteger() ;
    var b : int ; b := (nums[1+1])->toInteger() ;
    var foo : Foo ; foo := Foo.newFoo(a, b) ;
    OclFile["System.out"].println(foo.getVal()) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int getMod(String str,int n,int k){
    int pwrTwo[]=new int[n];
    pwrTwo[0]=1 % k ;
    for(int i=1 ; i<n ; i++){
      pwrTwo[i]=pwrTwo[i-1]*(2 % k);
      pwrTwo[i] %=k ;
    }
    int res=0 ;
    int i=0,j=n-1 ;
    while(i<n){
      if(str.charAt(j)=='1'){
        res+=(pwrTwo[i]);
        res %=k ;
      }
      i++;
      j--;
    }
    return res ;
  }
  public static void main(String[] args){
    String str="1101" ;
    int n=str.length();
    int k=45 ;
    System.out.print(getMod(str,n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getMod( str : String, n : int, k : int) : int
  pre: true
  post: true
  activity: (     var pwrTwo : Sequence(int) ; pwrTwo := Integer.subrange(1,n)->collect(0) ;
     pwrTwo[0+1] := 1 mod k ; 
        var i : int ; i := 1 ; while i < n do ( (     pwrTwo[i+1] := pwrTwo[i - 1+1] * (2 mod k) ; 
     pwrTwo[i+1] := pwrTwo[i+1] mod k )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    var i : int ; i := 0 ;
    var j : int ; j := n - 1 ;
    while (i < n) do (     if (str->at(j+1) = '1') then (     res := res+((pwrTwo[i+1])) ; 
     res := res mod k ) else skip ; 
     i := i + 1 ; 
     j := j - 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "1101" ;
     var n : int ; n := str->size() ;
     var k : int ; k := 45 ;
     OclFile["System.out"].print(getMod(str, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int INT_SIZE=32 ;
  static int Right_most_setbit(int num){
    int pos=1 ;
    for(int i=0 ; i<INT_SIZE ; i++){
      if((num &(1<<i))==0)pos++;
      else break ;
    }
    return pos ;
  }
  public static void main(String[] args){
    int num=18 ;
    int pos=Right_most_setbit(num);
    System.out.println(pos);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute INT_SIZE : int := 32;
  static   operation Right_most_setbit( num : int) : int
  pre: true
  post: true
  activity: (     var pos : int ; pos := 1 ;
         var i : int ; i := 0 ; while i < INT_SIZE do ( (     if ((num & ((1*(2->pow(i)))->oclAsType(long))) = 0) then     pos := pos + 1 ; else     break )  ;     i := i + 1 ) ; 
     return pos );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 18 ;
     var pos : int ; pos := Right_most_setbit(num) ;
     OclFile["System.out"].println(pos) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.util.stream.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    Integer k=Integer.parseInt(scanner.next());
    Integer x=Integer.parseInt(scanner.next());
    Integer range=k-1 ;
    if(k==1){
      System.out.println(x);
      System.exit(0);
    }
    String sum=new String();
    Integer start=x-range ;
    Integer end=x+range ;
    while(start<=end){
      sum+=start.toString()+" " ;
      start++;
    }
    System.out.println(sum.trim());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := (scanner.getCurrent())->toInteger() ;
    var x : int ; x := (scanner.getCurrent())->toInteger() ;
    var range : int ; range := k - 1 ;
    if (k = 1) then (     OclFile["System.out"].println(x) ; 
 OclProcess.exit(0) ) else skip ; 
    var sum : String ; sum := StringLib.newString() ;
    var start : int ; start := x - range ;
    var end : int ; end := x + range ;
    while (start <= end) do (     sum := sum+(start+"" + " ") ; 
     start := start + 1 ) ; 
    OclFile["System.out"].println(sum->trim()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class C {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int h1=input.nextInt();
    int a1=input.nextInt();
    int c1=input.nextInt();
    int h2=input.nextInt();
    int a2=input.nextInt();
    func(h1,a1,c1,h2,a2);
  }
  public static void func(int h1,int a1,int c1,int h2,int a2){
    List<String>list=new ArrayList<>();
    int count=0 ;
    while(h2>0){
      if(a1>=h2){
        list.add("STRIKE");
        h2-=a1 ;
      }
      else if(a2>=h1){
        list.add("HEAL");
        h1+=c1 ;
      }
      else {
        list.add("STRIKE");
        h2-=a1 ;
      }
      h1-=a2 ;
      count++;
    }
    System.out.println(count);
    for(String act : list){
      System.out.println(act);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h1 : int ; h1 := input.getCurrent()->toInteger() ;
    var a1 : int ; a1 := input.getCurrent()->toInteger() ;
    var c1 : int ; c1 := input.getCurrent()->toInteger() ;
    var h2 : int ; h2 := input.getCurrent()->toInteger() ;
    var a2 : int ; a2 := input.getCurrent()->toInteger() ;
    execute func(h1, a1, c1, h2, a2) ; 
 );
  static   operation func( h1 : int, a1 : int, c1 : int, h2 : int, a2 : int) : void
  pre: true
  post: true
  activity: (     var list : Sequence(String) ; list := Sequence{} ;
     var count : int ; count := 0 ;
    while (h2 > 0) do (     if (a1 >= h2) then (     list := list->including("STRIKE") ; 
     h2 := h2-(a1) ) else     if (a2 >= h1) then (     list := list->including("HEAL") ; 
     h1 := h1+(c1) ) else (     list := list->including("STRIKE") ; 
     h2 := h2-(a1) ) ;  ;  
     h1 := h1-(a2) ; 
     count := count + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    for (act : list) do ( (     OclFile["System.out"].println(act) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static Scanner sc=new Scanner(System.in);
  public static void main(String[] args)throws Exception {
    int i,j,k ;
    String str=sc.next();
    int q=sc.nextInt();
    for(i=0 ; i<q ; i++){
      String order=sc.next();
      if(order.equals("print")){
        int pr1=sc.nextInt();
        int pr2=sc.nextInt();
        System.out.println(str.substring(pr1,pr2+1));
      }
      if(order.equals("reverse")){
        int re1=sc.nextInt();
        int re2=sc.nextInt();
        StringBuffer sb=new StringBuffer(str.substring(re1,re2+1));
        String re=sb.reverse().toString();
        str=str.substring(0,re1)+re+str.substring(re2+1,str.length());
      }
      if(order.equals("replace")){
        int rep1=sc.nextInt();
        int rep2=sc.nextInt();
        String rep3=sc.next();
        str=str.substring(0,rep1)+rep3+str.substring(rep2+1,str.length());
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var k : int ;
     var str : String ; str := sc.getCurrent() ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
         i := 0 ; while i < q do ( (     var order : String ; order := sc.getCurrent() ;
     if (order = "print") then (     var pr1 : int ; pr1 := sc.getCurrent()->toInteger() ;
     var pr2 : int ; pr2 := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(str.subrange(pr1+1,pr2 + 1)) ) else skip ; 
     if (order = "reverse") then (     var re1 : int ; re1 := sc.getCurrent()->toInteger() ;
     var re2 : int ; re2 := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString(str.subrange(re1+1,re2 + 1)) ;
    var re : String ; re := sb->reverse()+"" ;
    str := str.subrange(0+1,re1) + re + str.subrange(re2 + 1+1,str->size()) ; 
 ) else skip ; 
     if (order = "replace") then (     var rep1 : int ; rep1 := sc.getCurrent()->toInteger() ;
     var rep2 : int ; rep2 := sc.getCurrent()->toInteger() ;
     var rep3 : String ; rep3 := sc.getCurrent() ;
     str := str.subrange(0+1,rep1) + rep3 + str.subrange(rep2 + 1+1,str->size()) ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class CFG {
  static int Minsteps(int n,int m){
    int ans=0 ;
    while(m>n){
      if(m % 2!=0){
        m++;
        ans++;
      }
      m/=2 ;
      ans++;
    }
    return ans+n-m ;
  }
  public static void main(String[] args){
    int n=4,m=6 ;
    System.out.println(Minsteps(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class CFG {
  static   operation Minsteps( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     while (m > n) do (     if (m mod 2 /= 0) then (     m := m + 1 ; 
     ans := ans + 1 ) else skip ; 
     m := m/(2) ; 
     ans := ans + 1 ) ; 
     return ans + n - m );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
    var m : int ; m := 6 ;
     OclFile["System.out"].println(Minsteps(n, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int a=stdIn.nextInt();
    int b=stdIn.nextInt();
    System.out.printf("%.6f\n",(double)a*b/3.305785);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := stdIn.getCurrent()->toInteger() ;
     var b : int ; b := stdIn.getCurrent()->toInteger() ;
     OclFile["System.out"].printf("%.6f\n", a->oclAsType(double) * b / 3.305785) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public void solve()throws IOException {
    int a=nextInt();
    int b=nextInt();
    double x=3.305785 ;
    writer.println(a*b/x);
  }
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  BufferedReader reader ;
  StringTokenizer tokenizer ;
  PrintWriter writer ;
  public void run()throws IOException {
    try {
      reader=new BufferedReader(new InputStreamReader(System.in));
      tokenizer=null ;
      writer=new PrintWriter(System.out);
      solve();
      reader.close();
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  public String nextToken()throws IOException {
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ; a := nextInt() ;
     var b : int ; b := nextInt() ;
     var x : double ; x := 3.305785 ;
     writer.println(a * b / x) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   attribute writer : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     try (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := null ; 
    writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
import java.util.*;
import static java.lang.System.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int min(int...ar){
    Arrays.sort(ar);
    return ar[0];
  }
  static int max(int...ar){
    Arrays.sort(ar);
    return ar[ar.length-1];
  }
  public static void main(String[] args){
    int a=sc.nextInt();
    int b=sc.nextInt();
    BigDecimal bd1=new BigDecimal(a*b);
    BigDecimal bd2=new BigDecimal(3.305785);
    BigDecimal ans=bd1.divide(bd2,5,RoundingMode.HALF_UP);
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation min( ar : Sequence(int)) : int
  pre: true
  post: true
  activity: (     ar := ar->sort() ; 
     return ar[0+1] );
  static   operation max( ar : Sequence(int)) : int
  pre: true
  post: true
  activity: (     ar := ar->sort() ; 
     return ar[ar->size() - 1+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var bd1 : double ; bd1 := double(a * b) ;
    var bd2 : double ; bd2 := double(3.305785) ;
    var ans : double ; ans := bd1.divide(bd2, 5, RoundingMode.HALF_UP) ;
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(is);
    String str ;
    if((str=br.readLine())!=null){
      String[] sp=str.split(" ");
      double tubo=3.305785 ;
      double a=Double.parseDouble(sp[0]);
      double b=Double.parseDouble(sp[1]);
      System.out.println(a*b/tubo);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(is) ;
     var str : String ;
     if ((str) /= null) then (     var sp : Sequence(String) ; sp := str->split(" ") ;
     var tubo : double ; tubo := 3.305785 ;
    var a : double ; a := (sp[0+1])->toReal() ;
    var b : double ; b := (sp[1+1])->toReal() ;
    OclFile["System.out"].println(a * b / tubo) ; 
 ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    double tsubo=3.305785 ;
    Scanner stdin=new Scanner(System.in);
    int a=stdin.nextInt();
    int b=stdin.nextInt();
    double s=(a*b)/tsubo ;
    BigDecimal land=new BigDecimal(s);
    BigDecimal land1=land.setScale(6,BigDecimal.ROUND_HALF_UP);
    System.out.println(land1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var tsubo : double ; tsubo := 3.305785 ;
     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var a : int ; a := stdin.getCurrent()->toInteger() ;
    var b : int ; b := stdin.getCurrent()->toInteger() ;
    var s : double ; s := (a * b) / tsubo ;
    var land : double ; land := double(s) ;
    var land1 : double ; land1 := land.setScale(6, ROUND_HALF_UP) ;
    OclFile["System.out"].println(land1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String findSmallest(char[] s){
    int len=s.length ;
    int[] loccur=new int[26];
    Arrays.fill(loccur,-1);
    for(int i=len-1 ; i>=0 ; --i){
      int chI=s[i]-'a' ;
      if(loccur[chI]==-1){
        loccur[chI]=i ;
      }
    }
    char[] sorted_s=s ;
    Arrays.sort(sorted_s);
    for(int i=0 ; i<len ; ++i){
      if(s[i]!=sorted_s[i]){
        int chI=sorted_s[i]-'a' ;
        int last_occ=loccur[chI];
        char temp=s[last_occ];
        s[last_occ]=s[i];
        s[i]=temp ;
        break ;
      }
    }
    return String.valueOf(s);
  }
  public static void main(String[] args){
    String s="geeks" ;
    System.out.print(findSmallest(s.toCharArray()));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSmallest( s : Sequence(String)) : String
  pre: true
  post: true
  activity: (     var len : int ; len := s->size() ;
     var loccur : Sequence(int) ; loccur := Integer.subrange(1,26)->collect(0) ;
    loccur := loccur->collect(-1) ; 
        var i : int ; i := len - 1 ; while i >= 0 do ( (     var chI : int ; chI := s[i+1] - ('a')->char2byte() ;
     if (loccur[chI+1] = -1) then (     loccur[chI+1] := i ) else skip )  ;     i := i - 1 ) ; 
    var sorted_s : Sequence(String) ; sorted_s := s ;
    sorted_s := sorted_s->sort() ; 
        var i : int ; i := 0 ; while i < len do ( (     if (s[i+1] /= sorted_s[i+1]) then (     var chI : int ; chI := sorted_s[i+1] - ('a')->char2byte() ;
     var last_occ : int ; last_occ := loccur[chI+1] ;
    var temp : String ; temp := s[last_occ+1] ;
    s[last_occ+1] := s[i+1] ; 
    s[i+1] := temp ; 
    break 
 ) else skip )  ;     i := i + 1 ) ; 
    return ((s) + "") 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeks" ;
     OclFile["System.out"].print(findSmallest(s->characters())) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static char maxRepeating(String str){
    int n=str.length();
    int count=0 ;
    char res=str.charAt(0);
    int cur_count=1 ;
    for(int i=0 ; i<n ; i++){
      if(i<n-1 && str.charAt(i)==str.charAt(i+1))cur_count++;
      else {
        if(cur_count>count){
          count=cur_count ;
          res=str.charAt(i);
        }
        cur_count=1 ;
      }
    }
    return res ;
  }
  public static void main(String args[]){
    String str="aaaabbaaccde" ;
    System.out.println(maxRepeating(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxRepeating( str : String) : String
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var count : int ; count := 0 ;
    var res : String ; res := str->at(0+1) ;
    var cur_count : int ; cur_count := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i < n - 1 & str->at(i+1) = str->at(i + 1+1)) then     cur_count := cur_count + 1 ; else (     if (cur_count > count) then (     count := cur_count ; 
     res := str->at(i+1) ) else skip ; 
     cur_count := 1 ) )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "aaaabbaaccde" ;
     OclFile["System.out"].println(maxRepeating(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static char maxRepeating(String str){
    int len=str.length();
    int count=0 ;
    char res=str.charAt(0);
    for(int i=0 ; i<len ; i++){
      int cur_count=1 ;
      for(int j=i+1 ; j<len ; j++){
        if(str.charAt(i)!=str.charAt(j))break ;
        cur_count++;
      }
      if(cur_count>count){
        count=cur_count ;
        res=str.charAt(i);
      }
    }
    return res ;
  }
  public static void main(String args[]){
    String str="aaaabbaaccde" ;
    System.out.println(maxRepeating(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxRepeating( str : String) : String
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     var count : int ; count := 0 ;
    var res : String ; res := str->at(0+1) ;
        var i : int ; i := 0 ; while i < len do ( (     var cur_count : int ; cur_count := 1 ;
         var j : int ; j := i + 1 ; while j < len do ( (     if (str->at(i+1) /= str->at(j+1)) then     break else skip ; 
     cur_count := cur_count + 1 )  ;     j := j + 1 ) ; 
     if (cur_count > count) then (     count := cur_count ; 
     res := str->at(i+1) ) else skip )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "aaaabbaaccde" ;
     OclFile["System.out"].println(maxRepeating(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long a=sc.nextInt();
    long b=sc.nextInt();
    long[] p=new long[n];
    for(int i=0 ; i<n ; i++){
      p[i]=sc.nextInt();
    }
    long[][] costDP=new long[n][n+1];
    for(int i=0 ; i<n ; i++){
      costDP[i][0]=a*(i+1);
    }
    for(int j=0 ; j<p[0]; j++){
      costDP[0][j]=a ;
    }
    for(int i=1 ; i<n ; i++){
      for(int j=1 ; j<=n ; j++){
        if(j<p[i]){
          costDP[i][j]=Math.min(costDP[i][j-1],costDP[i-1][j]+a);
        }
        else if(j>p[i]){
          costDP[i][j]=Math.min(costDP[i][j-1],costDP[i-1][j]+b);
        }
        else {
          costDP[i][j]=Math.min(costDP[i][j-1],costDP[i-1][j]);
        }
      }
    }
    long bestCost=costDP[n-1][0];
    for(int i=1 ; i<=n ; i++){
      bestCost=Math.min(costDP[n-1][i],bestCost);
    }
    System.out.println(bestCost);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : long ; a := sc.getCurrent()->toInteger() ;
    var b : long ; b := sc.getCurrent()->toInteger() ;
    var p : Sequence(long) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var costDP : Sequence(Sequence(long)) ; costDP := Integer.subrange(1,n)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     costDP[i+1][0+1] := a * (i + 1) )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < p[0+1] do ( (     costDP[0+1][j+1] := a )  ;     j := j + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 1 ; while j <= n do ( (     if (j < p[i+1]) then (     costDP[i+1][j+1] := Set{costDP[i+1][j - 1+1], costDP[i - 1+1][j+1] + a}->min() ) else     if (j > p[i+1]) then (     costDP[i+1][j+1] := Set{costDP[i+1][j - 1+1], costDP[i - 1+1][j+1] + b}->min() ) else (     costDP[i+1][j+1] := Set{costDP[i+1][j - 1+1], costDP[i - 1+1][j+1]}->min() ) ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var bestCost : long ; bestCost := costDP[n - 1+1][0+1] ;
        var i : int ; i := 1 ; while i <= n do ( (     bestCost := Set{costDP[n - 1+1][i+1], bestCost}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(bestCost) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
class Main {
  public static void main(String[] args){
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(isr);
    try {
      List<String>ret=new ArrayList<String>();
      String str=br.readLine();
      int q=Integer.parseInt(br.readLine());
      int i,j,start,from ;
      String com ;
      for(i=0 ; i<q ; i++){
        String[] line=br.readLine().split(" ");
        com=line[0];
        start=Integer.parseInt(line[1]);
        from=Integer.parseInt(line[2])+1 ;
        if(com.indexOf("replace")!=-1){
          str=str.substring(0,start)+line[3]+str.substring(from,str.length());
        }
        else if(com.indexOf("reverse")!=-1){
          String tmp="" ;
          String text=str.substring(start,from);
          for(j=text.length(); j>0 ; j--){
            tmp=tmp+text.charAt(j-1);
          }
          str=str.substring(0,start)+tmp+str.substring(from,str.length());
        }
        else if(com.indexOf("print")!=-1){
          ret.add(str.substring(start,from));
        }
      }
      for(String text : ret){
        System.out.println(text);
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
     try (     var ret : Sequence(String) ; ret := Sequence{} ;
     var str : String ; str := br.readLine() ;
    var q : int ; q := (br.readLine())->toInteger() ;
    var i : int ;
    var j : int ;
    var start : int ;
    var from : int ;
    var com : String ;
        i := 0 ; while i < q do ( (     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
     com := line[0+1] ; 
    start := (line[1+1])->toInteger() ; 
    from := (line[2+1])->toInteger() + 1 ; 
    if (com->indexOf("replace")-1 /= -1) then (     str := str.subrange(0+1,start) + line[3+1] + str.subrange(from+1,str->size()) ) else     if (com->indexOf("reverse")-1 /= -1) then (     var tmp : String ; tmp := "" ;
     var text : String ; text := str.subrange(start+1,from) ;
         j := text->size() ; while j > 0 do ( (     tmp := tmp + text->at(j - 1+1) )  ;     j := j - 1 ) ; 
     str := str.subrange(0+1,start) + tmp + str.subrange(from+1,str->size()) ) else     if (com->indexOf("print")-1 /= -1) then (     ret := ret->including(str.subrange(start+1,from)) ) else skip ; ;  ;  
 )  ;     i := i + 1 ) ; 
    for (text : ret) do ( (     OclFile["System.out"].println(text) )  ) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int prevComplement(int n,int b){
    int maxDigit,maxNum=0,digits=0,num=n ;
    while(n!=0){
      digits++;
      n=n/10 ;
    }
    maxDigit=b-1 ;
    while((digits--)>0){
      maxNum=maxNum*10+maxDigit ;
    }
    return maxNum-num ;
  }
  static int complement(int n,int b){
    return prevComplement(n,b)+1 ;
  }
  public static void main(String args[]){
    System.out.println(prevComplement(25,7));
    System.out.println(complement(25,7));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation prevComplement( n : int, b : int) : int
  pre: true
  post: true
  activity: (     var maxDigit : int ;
    var maxNum : int ; maxNum := 0 ;
    var digits : int ; digits := 0 ;
    var num : int ; num := n ;
     while (n /= 0) do (     digits := digits + 1 ; 
     n := n / 10 ) ; 
    maxDigit := b - 1 ; 
        while ((digits) > 0) do (        skip ;     skip ; (     maxNum := maxNum * 10 + maxDigit ) ;  ) ;  
    return maxNum - num 
 );
  static   operation complement( n : int, b : int) : int
  pre: true
  post: true
  activity: (     return prevComplement(n, b) + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(prevComplement(25, 7)) ; 
     OclFile["System.out"].println(complement(25, 7)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
import static java.lang.Math.min ;
import static java.lang.System.exit ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  static void solve()throws Exception {
    int n=scanInt();
    long a=scanInt(),b=scanInt();
    long dyn[]=new long[n+1];
    for(int i=0 ; i<n ; i++){
      int p=scanInt();
      long c=Long.MAX_VALUE ;
      for(int j=0 ; j<p ; j++){
        c=min(c,dyn[j]);
        dyn[j]+=a ;
      }
      dyn[p]=c ;
      for(int j=p+1 ; j<=n ; j++){
        dyn[j]+=b ;
      }
    }
    long ans=Long.MAX_VALUE ;
    for(int i=0 ; i<=n ; i++){
      ans=min(ans,dyn[i]);
    }
    out.print(ans);
  }
  static int scanInt()throws IOException {
    return parseInt(scanString());
  }
  static long scanLong()throws IOException {
    return parseLong(scanString());
  }
  static String scanString()throws IOException {
    while(tok==null || ! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  public static void main(String[] args){
    try {
      in=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(System.out);
      solve();
      in.close();
      out.close();
    }
    catch(Throwable e){
      e.printStackTrace();
      exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanInt() ;
     var a : long ; a := scanInt() ;
    var b : long ; b := scanInt() ;
    var dyn : Sequence(long) ; dyn := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var p : int ; p := scanInt() ;
     var c : long ; c := "9223372036854775807"->toLong() ;
        var j : int ; j := 0 ; while j < p do ( (     c := Set{c, dyn[j+1]}->min() ; 
     dyn[j+1] := dyn[j+1]+(a) )  ;     j := j + 1 ) ; 
    dyn[p+1] := c ; 
        var j : int ; j := p + 1 ; while j <= n do ( (     dyn[j+1] := dyn[j+1]+(b) )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := "9223372036854775807"->toLong() ;
        var i : int ; i := 0 ; while i <= n do ( (     ans := Set{ans, dyn[i+1]}->min() )  ;     i := i + 1 ) ; 
    out.print(ans) ; 
 );
  static   operation scanInt() : int
  pre: true
  post: true
  activity: (     return (scanString() + "")->toInteger() );
  static   operation scanLong() : long
  pre: true
  post: true
  activity: (     return parseLong(scanString()) );
  static   operation scanString() : String
  pre: true
  post: true
  activity: (     while (tok = null or not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return tok.next() );
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
     execute exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] A=new int[N];
    int[] B=new int[N];
    for(int i=0 ; i<N ; i++)A[i]=sc.nextInt();
    for(int i=0 ; i<N ; i++)B[i]=sc.nextInt();
    long ans=0 ;
    boolean update=true ;
    while(update){
      update=false ;
      for(int i=0 ; i<N ; i++){
        if(B[i]<A[i]){
          update=false ;
          break ;
        }
        int i0=(i-1+N)% N ;
        int i2=(i+1)% N ;
        if(B[i0]<B[i] && B[i]>B[i2]){
          int move=(B[i]-A[i])/(B[i0]+B[i2]);
          ans+=move ;
          B[i]-=move*(B[i0]+B[i2]);
          if(move>0)update=true ;
        }
      }
    }
    boolean ok=true ;
    for(int i=0 ; i<N ; i++){
      if(A[i]!=B[i]){
        ok=false ;
        break ;
      }
    }
    System.out.println(ok ? ans :-1);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     A[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do (     B[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var update : boolean ; update := true ;
    while (update) do (     update := false ; 
         var i : int ; i := 0 ; while i < N do ( (     if (B[i+1] < A[i+1]) then (     update := false ; 
     break ) else skip ; 
     var i0 : int ; i0 := (i - 1 + N) mod N ;
     var i2 : int ; i2 := (i + 1) mod N ;
     if (B[i0+1] < B[i+1] & B[i+1] > B[i2+1]) then (     var move : int ; move := (B[i+1] - A[i+1]) / (B[i0+1] + B[i2+1]) ;
     ans := ans+(move) ; 
     B[i+1] := B[i+1]-(move * (B[i0+1] + B[i2+1])) ; 
     if (move > 0) then     update := true ; else skip ) else skip )  ;     i := i + 1 ) ) ; 
    var ok : boolean ; ok := true ;
        var i : int ; i := 0 ; while i < N do ( (     if (A[i+1] /= B[i+1]) then (     ok := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if ok then ans else -1 endif) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner n=new Scanner(System.in);
    int a=n.nextInt();
    int b=1 ;
    while(a!=0){
      System.out.println("Case "+b+": "+a);
      b++;
      a=n.nextInt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : OclFile ; n := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := n.getCurrent()->toInteger() ;
     var b : int ; b := 1 ;
     while (a /= 0) do (     OclFile["System.out"].println("Case " + b + ": " + a) ; 
     b := b + 1 ; 
     a := n.getCurrent()->toInteger() ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Solution {
  public Solution(){
  }
  private static final InputReader scan=new InputReader();
  public void solve()throws IOException {
    PrintWriter out=new PrintWriter(System.out);
    boolean bool=true ;
    int c=0 ;
    while(bool){
      int x=scan.nextInt();
      if(x!=0){
        c++;
        out.println("Case "+c+": "+x);
      }
      else {
        bool=false ;
      }
    }
    out.close();
  }
}
class InputReader {
  private final BufferedReader br ;
  private StringTokenizer st=new StringTokenizer("");
  public InputReader(){
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public boolean hasNext(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        String line=br.readLine();
        if(line==null)return false ;
        st=new StringTokenizer(line);
      }
      catch(IOException ie){
        throw new RuntimeException(ie);
      }
    }
    return true ;
  }
  public String next()throws IOException {
    while(! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException ie){
        ie.printStackTrace();
      }
    }
    return st.nextToken();
  }
  public String nextLine()throws IOException {
    String str="" ;
    try {
      str=br.readLine();
    }
    catch(IOException ie){
      ie.printStackTrace();
    }
    return str ;
  }
  public double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
}
public class Main {
  public Main(){
  }
  public static void main(String[] args)throws IOException {
    new Solution().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
   static operation newSolution() : Solution
  pre: true
  post: true
  activity:
  ( var self : Solution ;
    self := createSolution();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
  static    attribute scan : InputReader := InputReader.newInputReader();
   operation solve() : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var bool : boolean ; bool := true ;
    var c : int ; c := 0 ;
    while (bool) do (     var x : int ; x := scan.nextInt() ;
     if (x /= 0) then (     c := c + 1 ; 
     skip ) else (     bool := false ) ) ; 
    skip ; 
 );
}
class InputReader {
   attribute br : OclFile;
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   static operation newInputReader() : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     var line : String ; line := br.readLine() ;
     if (line = null) then     return false else skip ; 
     st := OclIterator.newOclIterator_String(line) )   catch (ie : IOException) do (     error ProgramException(ie) )
 ) ; 
     return true );
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (ie : IOException) do (     ie.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (ie : IOException) do (     ie.printStackTrace() )
     return str );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Solution.newSolution().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int i=0 ;
    int num=0 ;
    String str ;
    ArrayList<Integer>numList=new ArrayList<Integer>();
    while(true){
      str=br.readLine();
      num=Integer.parseInt(str);
      if(num==0){
        break ;
      }
      numList.add(num);
      i++;
    }
    int length=i ;
    for(i=0 ; i<length ; i++){
      System.out.println("Case "+(i+1)+": "+numList.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var i : int ; i := 0 ;
    var num : int ; num := 0 ;
    var str : String ;
    var numList : Sequence(int) ; numList := Sequence{} ;
    while (true) do (     str := br.readLine() ; 
     num := (str)->toInteger() ; 
    if (num = 0) then (     break ) else skip ; 
    numList := numList->including(num) ; 
    i := i + 1 ; 
 ) ; 
    var length : int ; length := i ;
        i := 0 ; while i < length do ( (     OclFile["System.out"].println("Case " + (i + 1) + ": " + numList->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    ArrayList<Integer>x=new ArrayList<Integer>();
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int i=0 ;
    while(true){
      x.add(Integer.parseInt(br.readLine()));
      if(x.get(i)==0){
        break ;
      }
      i++;
    }
    for(int j=0 ; j<x.size()-1 ; j++){
      System.out.println("Case "+(j+1)+": "+x.get(j));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : Sequence(int) ; x := Sequence{} ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var i : int ; i := 0 ;
    while (true) do (     x := x->including((br.readLine())->toInteger()) ; 
     if (x->at(i+1) = 0) then (     break ) else skip ; 
     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < x->size() - 1 do ( (     OclFile["System.out"].println("Case " + (j + 1) + ": " + x->at(j+1)) )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class PrintTestCases {
  public static void main(String...args){
    final Scanner sc=new Scanner(System.in);
    for(int t=1 ; ; t++){
      final int x=sc.nextInt();
      if(x==0)break ;
      System.out.printf("Case %d: %d\n",t,x);
    }
  }
}
public class Main {
  public static void main(String...args){
    PrintTestCases.main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class PrintTestCases {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var t : int ; t := 1 ; while true do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x = 0) then     break else skip ; 
     OclFile["System.out"].printf("Case %d: %d\n", t, x) )  ;     t := t + 1 ) );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     PrintTestCases.main() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void removeDuplicates(int arr[],int n){
    int st=0 ;
    for(int i=0 ; i<n ; i++){
      if(i<n-2 && arr[i]==arr[i+1] && arr[i]==arr[i+2])continue ;
      else {
        arr[st]=arr[i];
        st++;
      }
    }
    System.out.print("{");
    for(int i=0 ; i<st ; i++){
      System.out.print(arr[i]);
      if(i!=st-1)System.out.print(",");
    }
    System.out.print("}");
  }
  public static void main(String[] args){
    int arr[]={
      1,1,1,2,2,2,3,3,3,3,3,3,4,5 };
      int n=arr.length ;
      removeDuplicates(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation removeDuplicates( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var st : int ; st := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (i < n - 2 & arr[i+1] = arr[i + 1+1] & arr[i+1] = arr[i + 2+1]) then     continue else (     arr[st+1] := arr[i+1] ; 
     st := st + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("{") ; 
        var i : int ; i := 0 ; while i < st do ( (     OclFile["System.out"].print(arr[i+1]) ; 
     if (i /= st - 1) then     OclFile["System.out"].print(",") ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("}") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,1,2,2,2,3,3,3,3,3,3,4,5} ;
     var n : int ; n := arr->size() ;
     execute removeDuplicates(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int solve(int[] A,int n){
    int[][] dp=new int[2000][2000];
    int flag=1 ;
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=A[i];
    for(int i=-sum ; i<=sum ; i++){
      try {
        dp[0][i]=Integer.MAX_VALUE ;
      }
      catch(Exception e){
      }
    }
    dp[0][0]=0 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=0 ; j<=sum ; j++){
        try {
          dp[flag][j]=Integer.MAX_VALUE ;
          if(j-A[i-1]<=sum && j-A[i-1]>=-sum)dp[flag][j]=dp[flag ^ 1][j-A[i-1] ];
          if(j+A[i-1]<=sum && j+A[i-1]>=-sum && dp[flag ^ 1][j+A[i-1] ]!=Integer.MAX_VALUE)dp[flag][j]=Math.min(dp[flag][j],dp[flag ^ 1][j+A[i-1] ]+1);
        }
        catch(Exception e){
        }
      }
      flag=flag ^ 1 ;
    }
    for(int i=0 ; i<=sum ; i++){
      if(dp[flag ^ 1][i]!=Integer.MAX_VALUE)return dp[flag ^ 1][i];
    }
    return n-1 ;
  }
  public static void main(String[] args){
    int[] arr={
      10,22,9,33,21,50,41,60 };
      int n=arr.length ;
      System.out.println(solve(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,2000)->collect(Integer.subrange(1,2000)->collect(0)) ;
     var flag : int ; flag := 1 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (     sum := sum+(A[i+1]) ;  ;     i := i + 1 ) ; 
        var i : int ; i := -sum ; while i <= sum do ( (     try (     dp[0+1][i+1] := 2147483647 )   catch (e : ProgramException) do skip
 )  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= sum do ( (     try (     dp[flag+1][j+1] := 2147483647 ; 
     if (j - A[i - 1+1] <= sum & j - A[i - 1+1] >= -sum) then     dp[flag+1][j+1] := dp[MathLib.bitwiseXor(flag,1)+1][j - A[i - 1+1]+1] ; else skip ; 
     if (j + A[i - 1+1] <= sum & j + A[i - 1+1] >= -sum & dp[MathLib.bitwiseXor(flag,1)+1][j + A[i - 1+1]+1] /= 2147483647) then     dp[flag+1][j+1] := Set{dp[flag+1][j+1], dp[MathLib.bitwiseXor(flag,1)+1][j + A[i - 1+1]+1] + 1}->min() ; else skip )   catch (e : ProgramException) do skip
 )  ;     j := j + 1 ) ; 
     flag := MathLib.bitwiseXor(flag,1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= sum do ( (     if (dp[MathLib.bitwiseXor(flag,1)+1][i+1] /= 2147483647) then     return dp[MathLib.bitwiseXor(flag,1)+1][i+1] else skip )  ;     i := i + 1 ) ; 
    return n - 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,22,9,33,21,50,41,60} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(solve(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long gcd(long a,long b){
    if(a==0){
      return b ;
    }
    return gcd(b % a,a);
  }
  static long divTermCount(long a,long b,long c,long num){
    return((num/a)+(num/b)+(num/c)-(num/((a*b)/gcd(a,b)))-(num/((c*b)/gcd(c,b)))-(num/((a*c)/gcd(a,c)))+(num/((a*b*c)/gcd(gcd(a,b),c))));
  }
  static long findNthTerm(int a,int b,int c,long n){
    long low=1,high=Long.MAX_VALUE,mid ;
    while(low<high){
      mid=low+(high-low)/2 ;
      if(divTermCount(a,b,c,mid)<n){
        low=mid+1 ;
      }
      else {
        high=mid ;
      }
    }
    return low ;
  }
  public static void main(String args[]){
    int a=2,b=3,c=5,n=100 ;
    System.out.println(findNthTerm(a,b,c,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then (     return b ) else skip ; 
     return gcd(b mod a, a) );
  static   operation divTermCount( a : long, b : long, c : long, num : long) : long
  pre: true
  post: true
  activity: (     return ((num / a) + (num / b) + (num / c) - (num / ((a * b) / gcd(a, b))) - (num / ((c * b) / gcd(c, b))) - (num / ((a * c) / gcd(a, c))) + (num / ((a * b * c) / gcd(gcd(a, b), c)))) );
  static   operation findNthTerm( a : int, b : int, c : int, n : long) : long
  pre: true
  post: true
  activity: (     var low : long ; low := 1 ;
    var high : long ; high := "9223372036854775807"->toLong() ;
    var mid : long ;
     while (low < high) do (     mid := low + (high - low) / 2 ; 
     if (divTermCount(a, b, c, mid) < n) then (     low := mid + 1 ) else (     high := mid ) ) ; 
     return low );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2 ;
    var b : int ; b := 3 ;
    var c : int ; c := 5 ;
    var n : int ; n := 100 ;
     OclFile["System.out"].println(findNthTerm(a, b, c, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int[] fact=new int[] {
    1,1,2,6,24,120,720,5040,40320,362880 };
    static boolean peterson(int n){
      int num=n ;
      int sum=0 ;
      while(n>0){
        int digit=n % 10 ;
        sum+=fact[digit];
        n=n/10 ;
      }
      return(sum==num);
    }
    static public void main(String[] args){
      int n=145 ;
      if(peterson(n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute fact : Sequence(int) := Sequence{1,1,2,6,24,120,720,5040,40320,362880};
  static   operation peterson( n : int) : boolean
  pre: true
  post: true
  activity: (     var num : int ; num := n ;
     var sum : int ; sum := 0 ;
     while (n > 0) do (     var digit : int ; digit := n mod 10 ;
     sum := sum+(fact[digit+1]) ; 
     n := n / 10 ) ; 
     return (sum = num) );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 145 ;
     if (peterson(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int N=1000 ;
  static long dp[]=new long[N+1];
  static void sieve(){
    int arr[]=new int[N+1];
    arr[0]=1 ;
    arr[1]=1 ;
    for(int i=2 ; i<=Math.sqrt(N); i++)if(arr[i]==0)for(int j=i*i ; j<=N ; j+=i)arr[j]=1 ;
    long runningPrimeSum=0 ;
    for(int i=1 ; i<=N ; i++){
      if(arr[i]==0)runningPrimeSum+=i ;
      dp[i]=runningPrimeSum ;
    }
  }
  public static void main(String[] args){
    int l=4,r=13 ;
    sieve();
    System.out.println(dp[r]-dp[l-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 1000;
  static   attribute dp : long := Integer.subrange(1,N + 1)->collect(0);
  static   operation sieve() : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,N + 1)->collect(0) ;
     arr[0+1] := 1 ; 
    arr[1+1] := 1 ; 
        var i : int ; i := 2 ; while i <= (N)->sqrt() do (     if (arr[i+1] = 0) then         var j : int ; j := i * i ; while j <= N do (     arr[j+1] := 1 ;  ;     j := j+(i) ) ; else skip ;  ;     i := i + 1 ) ; 
    var runningPrimeSum : long ; runningPrimeSum := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     if (arr[i+1] = 0) then     runningPrimeSum := runningPrimeSum+(i) ; else skip ; 
     dp[i+1] := runningPrimeSum )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 4 ;
    var r : int ; r := 13 ;
     execute sieve() ; 
     OclFile["System.out"].println(dp[r+1] - dp[l - 1+1]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static MyReader scan=new MyReader();
  public static void main(String[] args){
    int n=scan.nextInt();
    int m=scan.nextInt();
    if(n>m){
      System.out.println("YES");
      return ;
    }
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=scan.nextInt()% m ;
    }
    boolean[][] dp=new boolean[2][m];
    for(int i=0 ; i<n ; i++){
      int tarI=i % 2,preI=(i+1)% 2 ;
      for(int j=0 ; j<m ; j++){
        dp[tarI][j]=dp[preI][j] | dp[preI][(m+j-arr[i])% m];
      }
      dp[tarI][arr[i] ]=true ;
      if(dp[tarI][0]){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
}
class MyReader {
  private BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
  private StringTokenizer tokenizer=new StringTokenizer("");
  private String innerNextLine(){
    try {
      return reader.readLine();
    }
    catch(IOException ex){
      return null ;
    }
  }
  public boolean hasNext(){
    while(! tokenizer.hasMoreTokens()){
      String nextLine=innerNextLine();
      if(nextLine==null){
        return false ;
      }
      tokenizer=new StringTokenizer(nextLine);
    }
    return true ;
  }
  public String nextLine(){
    tokenizer=new StringTokenizer("");
    return innerNextLine();
  }
  public String next(){
    hasNext();
    return tokenizer.nextToken();
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public Long nextLong(){
    return Long.parseLong(next());
  }
  public double nextDouble(){
    return Double.parseDouble(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : MyReader := MyReader.newMyReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scan.nextInt() ;
     var m : int ; m := scan.nextInt() ;
    if (n > m) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scan.nextInt() mod m )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(boolean)) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,m)->collect(false)) ;
        var i : int ; i := 0 ; while i < n do ( (     var tarI : int ; tarI := i mod 2 ;
    var preI : int ; preI := (i + 1) mod 2 ;
         var j : int ; j := 0 ; while j < m do ( (     dp[tarI+1][j+1] := dp[preI+1][j+1] or dp[preI+1][(m + j - arr[i+1]) mod m+1] )  ;     j := j + 1 ) ; 
     dp[tarI+1][arr[i+1]+1] := true ; 
     if (dp[tarI+1][0+1]) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}
class MyReader {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute tokenizer : OclIterator := OclIterator.newOclIterator_String("");
   operation innerNextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (ex : IOException) do (     return null )
 );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     var nextLine : String ; nextLine := innerNextLine() ;
     if (nextLine = null) then (     return false ) else skip ; 
     tokenizer := OclIterator.newOclIterator_String(nextLine) ) ; 
     return true );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     tokenizer := OclIterator.newOclIterator_String("") ; 
     return innerNextLine() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute hasNext() ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class ModuloSum_319B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    boolean[] dp=new boolean[m+1];
    dp[m]=true ;
    dp[0]=true ;
    while(n-->0){
      int val=sc.nextInt()% m ;
      if(dp[m-val]){
        System.out.println("YES");
        return ;
      }
      boolean[] dp2=new boolean[m+1];
      for(int i=0 ; i<=m ; i++){
        dp2[i]=dp[i] || dp[(i-val+m)% m];
      }
      dp=dp2 ;
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class ModuloSum_319B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var dp : Sequence(boolean) ; dp := Integer.subrange(1,m + 1)->collect(false) ;
    dp[m+1] := true ; 
    dp[0+1] := true ; 
        while (n > 0) do (        n := n - 1 ;     skip ; (     var val : int ; val := sc.getCurrent()->toInteger() mod m ;
     if (dp[m - val+1]) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
    var dp2 : Sequence(boolean) ; dp2 := Integer.subrange(1,m + 1)->collect(false) ;
        var i : int ; i := 0 ; while i <= m do ( (     dp2[i+1] := dp[i+1] or dp[(i - val + m) mod m+1] )  ;     i := i + 1 ) ; 
    dp := dp2 ; 
 ) ;  ) ;  
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  BufferedReader in=new BufferedReader(new InputStreamReader(System.in),1000000);
  StringTokenizer tok=new StringTokenizer("");
  StringBuilder out=new StringBuilder();
  String next()throws IOException {
    if(! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  int n=0 ;
  int k=0 ;
  void go(int a,int b,int mask,char removed){
    if(removed==k-1){
      out.append(a+" "+b+" ");
    }
    else {
      int k1=0 ;
      for(int i=0 ; i<k ; i++){
        if((mask &(1<<i))==0 &&((a ^ b)&(1<<i))>0){
          mask |=(1<<i);
          removed++;
          k1=i ;
          break ;
        }
      }
      int a1=0 ;
      for(int j=0 ; j<k ; j++){
        if((mask &(1<<j))==0){
          a1=a ^(1<<j);
          break ;
        }
      }
      go(a,a1,mask,removed);
      go((a1 ^(1<<k1)),b,mask,removed);
    }
  }
  void slave()throws IOException {
    k=nextInt();
    int A=nextInt();
    int B=nextInt();
    n=1<<k ;
    if(Integer.bitCount(A ^ B)% 2==0){
      out.append("NO");
    }
    else {
      out.append("YES\n");
      go(A,B,0,(char)0);
    }
    System.out.print(out);
  }
  public static void main(String[] args)throws IOException {
    new Main().slave();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 1000000);
   attribute tok : OclIterator := OclIterator.newOclIterator_String("");
   attribute out : String := StringLib.newString();
   operation next() : String
  pre: true
  post: true
  activity: (     if (not(tok.hasNext())) then (     tok := OclIterator.newOclIterator_String(in.readLine()) ) else skip ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   attribute n : int := 0;
   attribute k : int := 0;
   operation go( a : int, b : int, mask : int, removed : String) : void
  pre: true
  post: true
  activity: (     if (removed = k - 1) then (     out := out + StringLib.newString(a + " " + b + " ") ) else (     var k1 : int ; k1 := 0 ;
         var i : int ; i := 0 ; while i < k do ( (     if ((mask & ((1*(2->pow(i)))->oclAsType(long))) = 0 & ((a xor b) & ((1*(2->pow(i)))->oclAsType(long))) > 0) then (     mask := MathLib.bitwiseOr(mask, ((1*(2->pow(i)))->oclAsType(long))) ; 
     removed := removed + 1 ; 
     k1 := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var a1 : int ; a1 := 0 ;
        var j : int ; j := 0 ; while j < k do ( (     if ((mask & ((1*(2->pow(j)))->oclAsType(long))) = 0) then (     a1 := a xor ((1*(2->pow(j)))->oclAsType(long)) ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    execute go(a, a1, mask, removed) ; 
    execute go((MathLib.bitwiseXor(a1,((1*(2->pow(k1)))->oclAsType(long)))), b, mask, removed) ; 
 ) );
   operation slave() : void
  pre: true
  post: true
  activity: (     k := nextInt() ; 
     var A : int ; A := nextInt() ;
    var B : int ; B := nextInt() ;
    n := (1*(2->pow(k)))->oclAsType(long) ; 
    if (bitCount(MathLib.bitwiseXor(A,B)) mod 2 = 0) then (     out := out + StringLib.newString("NO") ) else (     out := out + StringLib.newString("YES\n") ; 
     execute go(A, B, 0, 0->oclAsType(String)) ) ;  
    OclFile["System.out"].print(out) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().slave() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  private static int[] path ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    path=new int[1<<n];
    if(Integer.bitCount(a ^ b)% 2!=0){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
      return ;
    }
    path(a,b,0,(1<<n)-1);
    PrintWriter pw=new PrintWriter(System.out);
    for(int i=0 ; i<path.length ; i++){
      pw.print(path[i]+" ");
    }
    pw.println();
    pw.flush();
  }
  private static void path(int a,int b,int st,int mask){
    int diffBit=Integer.highestOneBit(mask &(a ^ b));
    mask=mask ^ diffBit ;
    int size=Integer.bitCount(mask);
    if(size==0){
      path[st]=a ;
      path[st+1]=b ;
    }
    else {
      int otherBit=Integer.highestOneBit(mask);
      path(a,a ^ otherBit,st,mask);
      path(a ^ diffBit ^ otherBit,b,st+(1<<size),mask);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute path : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    path := Integer.subrange(1,(1*(2->pow(n)))->oclAsType(long))->collect(0) ; 
    if (bitCount(MathLib.bitwiseXor(a,b)) mod 2 /= 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ; 
     return ) ;  
    execute path(a, b, 0, ((1*(2->pow(n)))->oclAsType(long)) - 1) ; 
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
        var i : int ; i := 0 ; while i < path->size() do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation path( a : int, b : int, st : int, mask : int) : void
  pre: true
  post: true
  activity: (     var diffBit : int ; diffBit := highestOneBit(mask & (MathLib.bitwiseXor(a,b))) ;
     mask := mask xor diffBit ; 
     var size : int ; size := bitCount(mask) ;
     if (size = 0) then (     path[st+1] := a ; 
     path[st + 1+1] := b ) else (     var otherBit : int ; otherBit := highestOneBit(mask) ;
     execute path(a, MathLib.bitwiseXor(a,otherBit), st, mask) ; 
     execute path(MathLib.bitwiseXor(MathLib.bitwiseXor(a,diffBit),otherBit), b, st + ((1*(2->pow(size)))->oclAsType(long)), mask) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
import static java.lang.System.exit ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  static void solve()throws Exception {
    int n=scanInt(),a=scanInt(),b=scanInt();
    if((Integer.bitCount(a ^ b)& 1)==0){
      out.print("NO");
    }
    else {
      out.println("YES");
      go((1<<n)-1,a,b);
    }
  }
  static void go(int mask,int a,int b){
    if((mask &(mask-1))==0){
      out.print(a+" "+b+" ");
    }
    else {
      int c=Integer.lowestOneBit(a ^ b);
      int d=Integer.lowestOneBit(mask ^ c);
      go(mask ^ c,a,a ^ d);
      go(mask ^ c,a ^ d ^ c,b);
    }
  }
  static int scanInt()throws IOException {
    return parseInt(scanString());
  }
  static long scanLong()throws IOException {
    return parseLong(scanString());
  }
  static String scanString()throws IOException {
    while(tok==null || ! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  public static void main(String[] args){
    try {
      in=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(System.out);
      solve();
      in.close();
      out.close();
    }
    catch(Throwable e){
      e.printStackTrace();
      exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanInt() ;
    var a : int ; a := scanInt() ;
    var b : int ; b := scanInt() ;
     if ((bitCount(MathLib.bitwiseXor(a,b)) & 1) = 0) then (     out.print("NO") ) else (     out.println("YES") ; 
     execute go(((1*(2->pow(n)))->oclAsType(long)) - 1, a, b) ) );
  static   operation go( mask : int, a : int, b : int) : void
  pre: true
  post: true
  activity: (     if ((mask & (mask - 1)) = 0) then (     out.print(a + " " + b + " ") ) else (     var c : int ; c := lowestOneBit(MathLib.bitwiseXor(a,b)) ;
     var d : int ; d := lowestOneBit(mask xor c) ;
     execute go(mask xor c, a, MathLib.bitwiseXor(a,d)) ; 
     execute go(mask xor c, MathLib.bitwiseXor(MathLib.bitwiseXor(a,d),c), b) ) );
  static   operation scanInt() : int
  pre: true
  post: true
  activity: (     return (scanString() + "")->toInteger() );
  static   operation scanLong() : long
  pre: true
  post: true
  activity: (     return parseLong(scanString()) );
  static   operation scanString() : String
  pre: true
  post: true
  activity: (     while (tok = null or not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return tok.next() );
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
     execute exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    final double eps=1e-10 ;
    Scanner scan=new Scanner(System.in);
    double x1,y1,x2,y2,x3,y3,x4,y4 ;
    while(scan.hasNextDouble()){
      x1=scan.nextDouble();
      y1=scan.nextDouble();
      x2=scan.nextDouble();
      y2=scan.nextDouble();
      x3=scan.nextDouble();
      y3=scan.nextDouble();
      x4=scan.nextDouble();
      y4=scan.nextDouble();
      double vax=x2-x1,vay=y2-y1 ;
      double vbx=x4-x3,vby=y4-y3 ;
      if(Math.abs(vax*vbx+vay*vby)<eps){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var eps : double ; eps := 1e-10 ;
     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : double ;
    var y1 : double ;
    var x2 : double ;
    var y2 : double ;
    var x3 : double ;
    var y3 : double ;
    var x4 : double ;
    var y4 : double ;
     while (scan.hasNextDouble()) do (     x1 := scan.getCurrent()->toReal() ; 
     y1 := scan.getCurrent()->toReal() ; 
    x2 := scan.getCurrent()->toReal() ; 
    y2 := scan.getCurrent()->toReal() ; 
    x3 := scan.getCurrent()->toReal() ; 
    y3 := scan.getCurrent()->toReal() ; 
    x4 := scan.getCurrent()->toReal() ; 
    y4 := scan.getCurrent()->toReal() ; 
    var vax : double ; vax := x2 - x1 ;
    var vay : double ; vay := y2 - y1 ;
    var vbx : double ; vbx := x4 - x3 ;
    var vby : double ; vby := y4 - y3 ;
    if (if vax * vbx + vay * vby < 0 then -(vax * vbx + vay * vby) else vax * vbx + vay * vby endif < eps) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static boolean isPowerOfTwo(int x){
    return x!=0 &&((x &(x-1))==0);
  }
  public static void main(String[] args){
    System.out.println(isPowerOfTwo(31)? "Yes" : "No");
    System.out.println(isPowerOfTwo(64)? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation isPowerOfTwo( x : int) : boolean
  pre: true
  post: true
  activity: (     return x /= 0 & ((x & (x - 1)) = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if isPowerOfTwo(31) then "Yes" else "No" endif) ; 
     OclFile["System.out"].println(if isPowerOfTwo(64) then "Yes" else "No" endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int w1=s.nextInt();
    int h1=s.nextInt();
    int w2=s.nextInt();
    int h2=s.nextInt();
    int c=0 ;
    c+=(h1+h2+2)*2 ;
    c+=w1+w2 ;
    c+=Math.abs(w1-w2);
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w1 : int ; w1 := s.getCurrent()->toInteger() ;
    var h1 : int ; h1 := s.getCurrent()->toInteger() ;
    var w2 : int ; w2 := s.getCurrent()->toInteger() ;
    var h2 : int ; h2 := s.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
    c := c+((h1 + h2 + 2) * 2) ; 
    c := c+(w1 + w2) ; 
    c := c+(if w1 - w2 < 0 then -(w1 - w2) else w1 - w2 endif) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findmax(int[] A){
    int r=A[0];
    for(int i=1 ; i<A.length ; i++)r=Math.max(r,A[i]);
    return r ;
  }
  static boolean isPossible(int[] A,int n,int H,int K){
    int time=0 ;
    for(int i=0 ; i<n ; ++i)time+=(A[i]-1)/K+1 ;
    return time<=H ;
  }
  static int minJobSpeed(int[] A,int n,int H){
    if(H<n)return-1 ;
    int max=findmax(A);
    int lo=1,hi=max ;
    while(lo<hi){
      int mi=lo+(hi-lo)/2 ;
      if(! isPossible(A,n,H,mi))lo=mi+1 ;
      else hi=mi ;
    }
    return lo ;
  }
  public static void main(String[] args){
    int[] A={
      3,6,7,11 };
      int H=8 ;
      int n=A.length ;
      System.out.println(minJobSpeed(A,n,H));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findmax( A : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var r : int ; r := A[0+1] ;
         var i : int ; i := 1 ; while i < A->size() do (     r := Set{r, A[i+1]}->max() ;  ;     i := i + 1 ) ; 
     return r );
  static   operation isPossible( A : Sequence(int), n : int, H : int, K : int) : boolean
  pre: true
  post: true
  activity: (     var time : int ; time := 0 ;
         var i : int ; i := 0 ; while i < n do (     time := time+((A[i+1] - 1) / K + 1) ;  ;     i := i + 1 ) ; 
     return time <= H );
  static   operation minJobSpeed( A : Sequence(int), n : int, H : int) : int
  pre: true
  post: true
  activity: (     if (H < n) then     return -1 else skip ; 
     var max : int ; max := findmax(A) ;
    var lo : int ; lo := 1 ;
    var hi : int ; hi := max ;
    while (lo < hi) do (     var mi : int ; mi := lo + (hi - lo) / 2 ;
     if (not(isPossible(A, n, H, mi))) then     lo := mi + 1 ; else     hi := mi ; ) ; 
    return lo 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{3,6,7,11} ;
     var H : int ; H := 8 ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].println(minJobSpeed(A, n, H)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class P1131A_SeaBattle {
  public static void main(String[] subhani)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int w1=Integer.parseInt(st.nextToken()),h1=Integer.parseInt(st.nextToken()),w2=Integer.parseInt(st.nextToken()),h2=Integer.parseInt(st.nextToken());
    int result=0 ;
    if(w1==w2){
      result=2*(h1+h2+2)+2*w1 ;
    }
    else {
      result=h1+h2+2+w1+w2+h1+h2+3+w1-w2-1 ;
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class P1131A_SeaBattle {
  static   operation main( subhani : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var w1 : int ; w1 := (st.next())->toInteger() ;
    var h1 : int ; h1 := (st.next())->toInteger() ;
    var w2 : int ; w2 := (st.next())->toInteger() ;
    var h2 : int ; h2 := (st.next())->toInteger() ;
    var result : int ; result := 0 ;
    if (w1 = w2) then (     result := 2 * (h1 + h2 + 2) + 2 * w1 ) else (     result := h1 + h2 + 2 + w1 + w2 + h1 + h2 + 3 + w1 - w2 - 1 ) ;  
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class2 {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    long a,b,c,d ;
    a=sc.nextLong();
    b=sc.nextLong();
    c=sc.nextLong();
    d=sc.nextLong();
    System.out.println(2*(a+b+d)+4);
  }
}
------------------------------------------------------------
OCL File:
---------
 class class2 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ;
    var b : long ;
    var c : long ;
    var d : long ;
    a := sc.getCurrent()->toLong() ; 
    b := sc.getCurrent()->toLong() ; 
    c := sc.getCurrent()->toLong() ; 
    d := sc.getCurrent()->toLong() ; 
    OclFile["System.out"].println(2 * (a + b + d) + 4) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class codeforces {
  public static void main(String[] args){
    Scanner ob=new Scanner(System.in);
    int w1=ob.nextInt();
    int h1=ob.nextInt();
    int w2=ob.nextInt();
    int h2=ob.nextInt();
    int ans=4+(2*h1)+(2*h2)+(2*w1);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ob : OclFile ; ob := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w1 : int ; w1 := ob.getCurrent()->toInteger() ;
    var h1 : int ; h1 := ob.getCurrent()->toInteger() ;
    var w2 : int ; w2 := ob.getCurrent()->toInteger() ;
    var h2 : int ; h2 := ob.getCurrent()->toInteger() ;
    var ans : int ; ans := 4 + (2 * h1) + (2 * h2) + (2 * w1) ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Map.Entry ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if(n==0 && m==0){
        break ;
      }
      String b[]=new String[n];
      for(int i=0 ; i<n ; i++){
        b[i]=sc.next();
      }
      Map<String,Integer>map=new HashMap<String,Integer>();
      map.put(zero(m),0);
      for(int i=0 ; i<n ; i++){
        Map<String,Integer>next=new HashMap<String,Integer>();
        next.putAll(map);
        for(Entry<String,Integer>e : map.entrySet()){
          String str=xor(e.getKey(),b[i]);
          int value=e.getValue()+1 ;
          if(! next.containsKey(str)|| value>next.get(str)){
            next.put(str,e.getValue()+1);
          }
        }
        map=next ;
      }
      System.out.println(map.get(zero(m)));
    }
  }
  String zero(int m){
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<m ; i++){
      sb.append("0");
    }
    return sb.toString();
  }
  String xor(String a,String b){
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<a.length(); i++){
      if(a.charAt(i)==b.charAt(i)){
        sb.append("0");
      }
      else {
        sb.append("1");
      }
    }
    return sb.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if (n = 0 & m = 0) then (     break ) else skip ; 
    var b : Sequence(String) ; b := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    var map : Map(String,int) ; map := Map{} ;
    map := map->union(Map{zero(m) |-> 0}) ; 
        var i : int ; i := 0 ; while i < n do ( (     var next : Map(String,int) ; next := Map{} ;
     next := next->union(map) ; 
     for (e : map->asSet()) do ( (     var str : String ; str := xor(e.getKey(), b[i+1]) ;
     var value : int ; value := e.getValue() + 1 ;
     if (not(next->keys()->includes(str)) or value > next->at(str)) then (     next := next->union(Map{str |-> e.getValue() + 1}) ) else skip )  ) ; 
     map := next )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(map->at(zero(m))) ; 
 )  ) );
   operation zero( m : int) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < m do ( (     sb := sb + StringLib.newString("0") )  ;     i := i + 1 ) ; 
     return sb+"" );
   operation xor( a : String, b : String) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < a->size() do ( (     if (a->at(i+1) = b->at(i+1)) then (     sb := sb + StringLib.newString("0") ) else (     sb := sb + StringLib.newString("1") ) )  ;     i := i + 1 ) ; 
     return sb+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    Set<Integer>S=new HashSet<>();
    int q=Integer.parseInt(in.next());
    for(int i=0 ; i<q ; i++){
      int odr=Integer.parseInt(in.next());
      if(odr==0){
        int x=Integer.parseInt(in.next());
        S.add(x);
        out.println(S.size());
      }
      else {
        int x=Integer.parseInt(in.next());
        out.println((S.contains(x))? 1 : 0);
      }
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var S : Set(int) ; S := Set{} ;
    var q : int ; q := (in.getCurrent())->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var odr : int ; odr := (in.getCurrent())->toInteger() ;
     if (odr = 0) then (     var x : int ; x := (in.getCurrent())->toInteger() ;
     S := S->including(x) ; 
     skip ) else (     var x : int ; x := (in.getCurrent())->toInteger() ;
     skip ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int times=sc.nextInt();
      Set<Long>set=new HashSet<Long>();
      for(int i=0 ; i<times ; i++){
        int query=sc.nextInt();
        long x=sc.nextLong();
        switch(query){
          case 0 : set.add(x);
          System.out.println(set.size());
          break ;
          case 1 : if(set.contains(x)){
            System.out.println(1);
          }
          else System.out.println(0);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var times : int ; times := sc.getCurrent()->toInteger() ;
     var set : Set(long) ; set := Set{} ;
         var i : int ; i := 0 ; while i < times do ( (     var query : int ; query := sc.getCurrent()->toInteger() ;
     var x : long ; x := sc.getCurrent()->toLong() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (query) ; 
       if _switchval = 0 then
     set := set->including(x) ; 
    OclFile["System.out"].println(set->size()) ; 
    break 
   else skip ;
       if _switchval = 1 then
     if (set->includes(x)) then (     OclFile["System.out"].println(1) ) else     OclFile["System.out"].println(0) ; ;  
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  static Scanner InData=new Scanner(System.in);
  static HashSet<Integer>S=new HashSet<Integer>();
  public static void main(String[] args){
    getQuery();
  }
  private static void getQuery(){
    int qNum=InData.nextInt();
    int qType,qVal ;
    for(int indexOfQuery=0 ; indexOfQuery<qNum ; indexOfQuery++){
      qType=InData.nextInt();
      qVal=InData.nextInt();
      ;
      doQuery(qType,qVal);
    }
  }
  private static void doQuery(int type,int val){
    switch(type){
      case 0 : S.add(val);
      System.out.println(S.size());
      break ;
      case 1 : System.out.println(S.contains(val)? 1 : 0);
      break ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute InData : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute S : Set(int) := Set{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute getQuery() );
  static   operation getQuery() : void
  pre: true
  post: true
  activity: (     var qNum : int ; qNum := InData.getCurrent()->toInteger() ;
     var qType : int ;
    var qVal : int ;
         var indexOfQuery : int ; indexOfQuery := 0 ; while indexOfQuery < qNum do ( (     qType := InData.getCurrent()->toInteger() ; 
     qVal := InData.getCurrent()->toInteger() ; 
     execute doQuery(qType, qVal) )  ;     indexOfQuery := indexOfQuery + 1 ) );
  static   operation doQuery( type : int, val : int) : void
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (type) ; 
       if _switchval = 0 then
     S := S->including(val) ; 
    OclFile["System.out"].println(S->size()) ; 
    break 
   else skip ;
       if _switchval = 1 then
     OclFile["System.out"].println(if S->includes(val) then 1 else 0 endif) ; 
    break 
   else skip ;
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class teest {
  public static void main(String[] args){
    Scanner a=new Scanner(System.in);
    int t=a.nextInt();
    while(t>0){
      int n=a.nextInt(),k=a.nextInt();
      if(k>n)System.out.println("NO");
      else {
        if(n % 2==0){
          if(k % 2!=0)System.out.println("NO");
          else {
            if((n/k)<k)System.out.println("NO");
            else System.out.println("YES");
          }
        }
        else {
          if(k % 2==0)System.out.println("NO");
          else {
            if((n/k)<k)System.out.println("NO");
            else System.out.println("YES");
          }
        }
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class teest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : OclFile ; a := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := a.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := a.getCurrent()->toInteger() ;
    var k : int ; k := a.getCurrent()->toInteger() ;
     if (k > n) then     OclFile["System.out"].println("NO") else (     if (n mod 2 = 0) then (     if (k mod 2 /= 0) then     OclFile["System.out"].println("NO") ; else (     if ((n / k) < k) then     OclFile["System.out"].println("NO") ; else     OclFile["System.out"].println("YES") ; ) ) else (     if (k mod 2 = 0) then     OclFile["System.out"].println("NO") ; else (     if ((n / k) < k) then     OclFile["System.out"].println("NO") ; else     OclFile["System.out"].println("YES") ; ) ) ) ;  
     t := t - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.HashSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    HashSet<Integer>list=new HashSet<Integer>();
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      if(a==0){
        list.add(b);
        System.out.println(list.size());
      }
      else {
        System.out.println(list.contains(b)? "1" : "0");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var list : Set(int) ; list := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (a = 0) then (     list := list->including(b) ; 
     OclFile["System.out"].println(list->size()) ) else (     OclFile["System.out"].println(if list->includes(b) then "1" else "0" endif) ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] arg){
    HashSet<Integer>ht=new HashSet<Integer>();
    Scanner sc=new Scanner(System.in);
    int cnt=sc.nextInt();
    for(int i=0 ; i<cnt ; i++){
      int cmt=sc.nextInt();
      switch(cmt){
        case 0 : int num=sc.nextInt();
        if(! ht.contains(num))ht.add(num);
        System.out.println(ht.size());
        break ;
        case 1 : int num2=sc.nextInt();
        int cnt2=0 ;
        if(ht.contains(num2))cnt2=1 ;
        System.out.println(cnt2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ht : Set(int) ; ht := Set{} ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cnt : int ; cnt := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < cnt do ( (     var cmt : int ; cmt := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (cmt) ; 
       if _switchval = 0 then
     var num : int ; num := sc.getCurrent()->toInteger() ;
    if (not(ht->includes(num))) then     ht := ht->including(num) ; else skip ; 
    OclFile["System.out"].println(ht->size()) ; 
    break 
   else skip ;
       if _switchval = 1 then
     var num2 : int ; num2 := sc.getCurrent()->toInteger() ;
    var cnt2 : int ; cnt2 := 0 ;
    if (ht->includes(num2)) then     cnt2 := 1 ; else skip ; 
    OclFile["System.out"].println(cnt2) ; 
   else skip ;
 )
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] A=new long[n];
    long[] K=new long[n];
    long grundy=0 ;
    for(int i=0 ; i<n ; ++i){
      A[i]=sc.nextLong();
      K[i]=sc.nextLong();
      grundy ^=f(A[i],K[i]);
    }
    if(grundy==0){
      System.out.println("Aoki");
    }
    else {
      System.out.println("Takahashi");
    }
  }
  long f(long A,long K){
    if(A % K==0){
      return A/K ;
    }
    else {
      long tmp=(A % K)/(A/K+1);
      if(tmp>1){
        return f(A-(A/K+1)*tmp,K);
      }
      else {
        return f(A-A/K-1,K);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var A : Sequence(long) ; A := Integer.subrange(1,n)->collect(0) ;
    var K : Sequence(long) ; K := Integer.subrange(1,n)->collect(0) ;
    var grundy : long ; grundy := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := sc.getCurrent()->toLong() ; 
     K[i+1] := sc.getCurrent()->toLong() ; 
     grundy := MathLib.bitwiseXor(grundy,f(A[i+1], K[i+1])) )  ;     i := i + 1 ) ; 
    if (grundy = 0) then (     OclFile["System.out"].println("Aoki") ) else (     OclFile["System.out"].println("Takahashi") ) ;  
 );
   operation f( A : long, K : long) : long
  pre: true
  post: true
  activity: (     if (A mod K = 0) then (     return A / K ) else (     var tmp : long ; tmp := (A mod K) / (A / K + 1) ;
     if (tmp > 1) then (     return f(A - (A / K + 1) * tmp, K) ) else (     return f(A - A / K - 1, K) ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    pw.println(Integer.toBinaryString(n).length());
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maxProduct(int arr[],int n){
    int minVal=arr[0];
    int maxVal=arr[0];
    int maxProduct=arr[0];
    for(int i=1 ; i<n ; i++){
      if(arr[i]<0){
        int temp=maxVal ;
        maxVal=minVal ;
        minVal=temp ;
      }
      maxVal=Math.max(arr[i],maxVal*arr[i]);
      minVal=Math.min(arr[i],minVal*arr[i]);
      maxProduct=Math.max(maxProduct,maxVal);
    }
    return maxProduct ;
  }
  public static void main(String[] args){
    int arr[]={
-1,-3,-10,0,60 };
      int n=arr.length ;
      System.out.println("Maximum Subarray product is "+maxProduct(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxProduct( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var minVal : int ; minVal := arr[0+1] ;
     var maxVal : int ; maxVal := arr[0+1] ;
    var maxProduct : int ; maxProduct := arr[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] < 0) then (     var temp : int ; temp := maxVal ;
     maxVal := minVal ; 
     minVal := temp ) else skip ; 
     maxVal := Set{arr[i+1], maxVal * arr[i+1]}->max() ; 
     minVal := Set{arr[i+1], minVal * arr[i+1]}->min() ; 
     maxProduct := Set{maxProduct, maxVal}->max() )  ;     i := i + 1 ) ; 
    return maxProduct 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-1,-3,-10,0,60} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Maximum Subarray product is " + maxProduct(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int CommomSubsequencesCount(String s,String t){
    int n1=s.length();
    int n2=t.length();
    int dp[][]=new int[n1+1][n2+1];
    char ch1,ch2 ;
    for(int i=0 ; i<=n1 ; i++){
      for(int j=0 ; j<=n2 ; j++){
        dp[i][j]=0 ;
      }
    }
    for(int i=1 ; i<=n1 ; i++){
      for(int j=1 ; j<=n2 ; j++){
        ch1=s.charAt(i-1);
        ch2=t.charAt(j-1);
        if(ch1==ch2)dp[i][j]=1+dp[i][j-1]+dp[i-1][j];
        else dp[i][j]=dp[i][j-1]+dp[i-1][j]-dp[i-1][j-1];
      }
    }
    return dp[n1][n2];
  }
  public static void main(String args[]){
    String s="ajblqcpdz" ;
    String t="aefcnbtdi" ;
    System.out.println(CommomSubsequencesCount(s,t));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation CommomSubsequencesCount( s : String, t : String) : int
  pre: true
  post: true
  activity: (     var n1 : int ; n1 := s->size() ;
     var n2 : int ; n2 := t->size() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n1 + 1)->collect(Integer.subrange(1,n2 + 1)->collect(0)) ;
    var ch1 : String ;
    var ch2 : String ;
        var i : int ; i := 0 ; while i <= n1 do ( (         var j : int ; j := 0 ; while j <= n2 do ( (     dp[i+1][j+1] := 0 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n1 do ( (         var j : int ; j := 1 ; while j <= n2 do ( (     ch1 := s->at((i)->char2byte() - 1+1) ; 
     ch2 := t->at(j - 1+1) ; 
     if (ch1 = ch2) then     dp[i+1][j+1] := 1 + dp[i+1][j - 1+1] + dp[(i)->char2byte() - 1+1][j+1] ; else     dp[i+1][j+1] := dp[i+1][j - 1+1] + dp[(i)->char2byte() - 1+1][j+1] - dp[(i)->char2byte() - 1+1][j - 1+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return dp[n1+1][n2+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "ajblqcpdz" ;
     var t : String ; t := "aefcnbtdi" ;
     OclFile["System.out"].println(CommomSubsequencesCount(s, t)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int findSum(int n){
    int[][] arr=new int[n][n];
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)arr[i][j]=Math.abs(i-j);
    int sum=0 ;
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)sum+=arr[i][j];
    return sum ;
  }
  static public void main(String[] args){
    int n=3 ;
    System.out.println(findSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSum( n : int) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (     arr[i+1][j+1] := if i - j < 0 then -(i - j) else i - j endif ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (     sum := sum+(arr[i+1][j+1]) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return sum 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(findSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int dodecahedral_num(int n){
    return n*(3*n-1)*(3*n-2)/2 ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.print(n+"the Dodecahedral"+" number:");
    System.out.println(dodecahedral_num(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation dodecahedral_num( n : int) : int
  pre: true
  post: true
  activity: (     return n * (3 * n - 1) * (3 * n - 2) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].print(n + "the Dodecahedral" + " number:") ; 
     OclFile["System.out"].println(dodecahedral_num(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Vector<Integer>find_idx(int ar[],int n){
    Vector<Integer>answer=new Vector<Integer>();
    int sum=ar[0];
    for(int i=1 ; i<n ; i++){
      if(sum==ar[i]){
        answer.add(i+1);
      }
      sum+=ar[i];
    }
    return answer ;
  }
  public static void main(String[] args){
    int ar[]={
      1,2,3,6,3,15,5 };
      int n=ar.length ;
      Vector<Integer>ans=find_idx(ar,n);
      if(ans.size()!=0){
        for(int i : ans){
          System.out.print(i+" ");
        }
      }
      else {
        System.out.println("-1");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation find_idx( ar : Sequence(int), n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var answer : Sequence(int) ; answer := Sequence{} ;
     var sum : int ; sum := ar[0+1] ;
         var i : int ; i := 1 ; while i < n do ( (     if (sum = ar[i+1]) then (     answer := answer->including(i + 1) ) else skip ; 
     sum := sum+(ar[i+1]) )  ;     i := i + 1 ) ; 
     return answer );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ar : Sequence(int) ; ar := Sequence{1,2,3,6,3,15,5} ;
     var n : int ; n := ar->size() ;
     var ans : Sequence(int) ; ans := find_idx(ar, n) ;
     if (ans->size() /= 0) then (     for (i : ans) do ( (     OclFile["System.out"].print(i + " ") )  ) ) else (     OclFile["System.out"].println("-1") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int solve(int N,int M,int cp[],int sp[]){
    Integer[] profit=new Integer[N];
    for(int i=0 ; i<N ; i++)profit[i]=sp[i]-cp[i];
    Arrays.sort(profit,Collections.reverseOrder());
    int sum=0 ;
    for(int i=0 ; i<M ; i++){
      if(profit[i]>0)sum+=profit[i];
      else break ;
    }
    return sum ;
  }
  public static void main(String args[]){
    int N=5,M=3 ;
    int CP[]={
      5,10,35,7,23 };
      int SP[]={
        11,10,0,9,19 };
        System.out.println(solve(N,M,CP,SP));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( N : int, M : int, cp : Sequence(int), sp : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var profit : Sequence(int) ; profit := Integer.subrange(1,N)->collect(null) ;
         var i : int ; i := 0 ; while i < N do (     profit[i+1] := sp[i+1] - cp[i+1] ;  ;     i := i + 1 ) ; 
    profit := OclComparator.sortWith(profit, reverseOrder()) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     if (profit[i+1] > 0) then     sum := sum+(profit[i+1]) ; else     break )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
    var M : int ; M := 3 ;
     var CP : Sequence(int) ; CP := Sequence{5,10,35,7,23} ;
     var SP : Sequence(int) ; SP := Sequence{11,10,0,9,19} ;
     OclFile["System.out"].println(solve(N, M, CP, SP)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static String judge(double[][] n){
    if(n[1][0]-n[0][0]==0 && n[3][1]-n[2][1]==0){
      return "YES" ;
    }
    if(n[3][0]-n[2][0]==0 && n[1][1]-n[0][1]==0){
      return "YES" ;
    }
    double a=(n[1][1]-n[0][1])/(n[1][0]-n[0][0]);
    double b=(n[3][0]-n[2][0])/(n[3][1]-n[2][1]);
    if(a==-b){
      return "YES" ;
    }
    return "NO" ;
  }
  public static void main(String[] args)throws IOException {
    Scanner stdIn=null ;
    List<String>result=new ArrayList<String>();
    try {
      stdIn=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
      while(stdIn.hasNext()){
        double[][] n=new double[4][2];
        for(int i=0 ; i<4 ; i++){
          for(int j=0 ; j<2 ; j++){
            n[i][j]=stdIn.nextDouble();
          }
        }
        result.add(judge(n));
      }
      for(String str : result){
        System.out.println(str);
      }
    }
    finally {
      if(stdIn!=null){
        stdIn.close();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation judge( n : Sequence(Sequence(double))) : String
  pre: true
  post: true
  activity: (     if (n[1+1][0+1] - n[0+1][0+1] = 0 & n[3+1][1+1] - n[2+1][1+1] = 0) then (     return "YES" ) else skip ; 
     if (n[3+1][0+1] - n[2+1][0+1] = 0 & n[1+1][1+1] - n[0+1][1+1] = 0) then (     return "YES" ) else skip ; 
    var a : double ; a := (n[1+1][1+1] - n[0+1][1+1]) / (n[1+1][0+1] - n[0+1][0+1]) ;
    var b : double ; b := (n[3+1][0+1] - n[2+1][0+1]) / (n[3+1][1+1] - n[2+1][1+1]) ;
    if (a = -b) then (     return "YES" ) else skip ; 
    return "NO" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := null ;
     var result : Sequence(String) ; result := Sequence{} ;
     try (     stdIn := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
     while (stdIn.hasNext()) do (     var n : Sequence(Sequence(double)) ; n := Integer.subrange(1,4)->collect(Integer.subrange(1,2)->collect(0.0)) ;
         var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < 2 do ( (     n[i+1][j+1] := stdIn.getCurrent()->toReal() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     result := result->including(judge(n)) ) ; 
     for (str : result) do ( (     OclFile["System.out"].println(str) )  ) )   finally (     if (stdIn /= null) then (     skip ) else skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void printPattern(int n){
    int arr[][]=new int[n][n];
    int k,i,j,p=1,f ;
    for(k=0 ; k<n ; k++){
      j=k ;
      i=0 ;
      while(j>=0){
        arr[i][j]=p ;
        p++;
        i=i+1 ;
        j=j-1 ;
      }
    }
    for(k=1 ; k<n ; k++){
      i=k ;
      j=n-1 ;
      f=k ;
      while(j>=f){
        arr[i][j]=p ;
        p++;
        i=i+1 ;
        j=j-1 ;
      }
    }
    for(i=0 ; i<n ; i++){
      for(j=0 ; j<n ; j++){
        System.out.print(arr[i][j]+" ");
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    int n=3 ;
    printPattern(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printPattern( n : int) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
     var k : int ;
    var i : int ;
    var j : int ;
    var p : int ; p := 1 ;
    var f : int ;
        k := 0 ; while k < n do ( (     j := k ; 
     i := 0 ; 
     while (j >= 0) do (     arr[i+1][j+1] := p ; 
     p := p + 1 ; 
     i := i + 1 ; 
     j := j - 1 ) )  ;     k := k + 1 ) ; 
        k := 1 ; while k < n do ( (     i := k ; 
     j := n - 1 ; 
     f := k ; 
     while (j >= f) do (     arr[i+1][j+1] := p ; 
     p := p + 1 ; 
     i := i + 1 ; 
     j := j - 1 ) )  ;     k := k + 1 ) ; 
        i := 0 ; while i < n do ( (         j := 0 ; while j < n do ( (     OclFile["System.out"].print(arr[i+1][j+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     execute printPattern(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    int i,j,q,order,x,L,R,next ;
    TreeSet<Integer>set=new TreeSet<Integer>();
    try(Scanner sc=new Scanner(System.in)){
      q=sc.nextInt();
      for(i=0 ; i<q ; i++){
        order=sc.nextInt();
        x=sc.nextInt();
        switch(order){
          case 0 : set.add(x);
          System.out.println(set.size());
          break ;
          case 1 : System.out.println(set.contains(x)? "1" : "0");
          break ;
          case 2 : set.remove(x);
          break ;
          case 3 : for(Integer output : set.subSet(x,true,sc.nextInt(),true)){
            System.out.println(output);
          }
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var q : int ;
    var order : int ;
    var x : int ;
    var L : int ;
    var R : int ;
    var next : int ;
     var set : Set(int) ; set := Set{} ;
     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     q := sc.getCurrent()->toInteger() ; 
         i := 0 ; while i < q do ( (     order := sc.getCurrent()->toInteger() ; 
     x := sc.getCurrent()->toInteger() ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (order) ; 
       if _switchval = 0 then
     set := set->including(x) ; 
    OclFile["System.out"].println(set->size()) ; 
    break 
   else skip ;
       if _switchval = 1 then
     OclFile["System.out"].println(if set->includes(x) then "1" else "0" endif) ; 
    break 
   else skip ;
       if _switchval = 2 then
     set := set->excludingFirst(x) ; 
    break 
   else skip ;
       if _switchval = 3 then
     for (output : set->select( _x0 | _x0 >= x & _x0 < true )) do ( (     OclFile["System.out"].println(output) )  ) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    MySet S=new MySet();
    int q=Integer.parseInt(in.next());
    for(int i=0 ; i<q ; i++){
      int odr=Integer.parseInt(in.next());
      switch(odr){
        case 0 : int x0=Integer.parseInt(in.next());
        S.add(x0);
        out.println(S.size());
        break ;
        case 1 : int x1=Integer.parseInt(in.next());
        out.println((S.contains(x1))? 1 : 0);
        break ;
        case 2 : int x2=Integer.parseInt(in.next());
        S.remove(x2);
        break ;
        case 3 : int l=Integer.parseInt(in.next()),r=Integer.parseInt(in.next());
        for(int j=l ; j<=r ; j++){
          if(S.index[j])out.println(j);
        }
      }
    }
    out.flush();
  }
}
class MySet {
  boolean index[];
  int size ;
  MySet(){
    index=new boolean[1000000001];
    Arrays.fill(index,false);
    size=0 ;
  }
  void add(int x){
    if(! index[x]){
      index[x]=true ;
      size++;
    }
  }
  int size(){
    return this.size ;
  }
  boolean contains(int x){
    return index[x];
  }
  void remove(int x){
    if(index[x]){
      index[x]=false ;
      size--;
    }
  }
  List<Integer>dump(int a,int b){
    List<Integer>ls=new ArrayList<>();
    for(int i=a ; i<=b ; i++){
      if(index[i])ls.add(i);
    }
    return ls ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var S : MySet ; S := MySet.newMySet() ;
    var q : int ; q := (in.getCurrent())->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var odr : int ; odr := (in.getCurrent())->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (odr) ; 
       if _switchval = 0 then
     var x0 : int ; x0 := (in.getCurrent())->toInteger() ;
    S->excludes(x0) ; 
    skip ; 
    break 
   else skip ;
       if _switchval = 1 then
     var x1 : int ; x1 := (in.getCurrent())->toInteger() ;
    skip ; 
    break 
   else skip ;
       if _switchval = 2 then
     var x2 : int ; x2 := (in.getCurrent())->toInteger() ;
    S := S->excludingAt(x2+1) ; 
    break 
   else skip ;
       if _switchval = 3 then
     var l : int ; l := (in.getCurrent())->toInteger() ;
    var r : int ; r := (in.getCurrent())->toInteger() ;
        var j : int ; j := l ; while j <= r do ( (     if (S.index[j+1]) then     skip ; else skip )  ;     j := j + 1 ) ; 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
class MySet {
   attribute index : Sequence(boolean);
   attribute size : int;
   static operation newMySet() : MySet
  pre: true
  post: true
  activity:
  ( var self : MySet ;
    self := createMySet();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     index := Integer.subrange(1,1000000001)->collect(false) ; 
     index := index->collect(false) ; 
     size := 0 );
   operation add( x : int) : void
  pre: true
  post: true
  activity: (     if (not(index[x+1])) then (     index[x+1] := true ; 
     size := size + 1 ) else skip );
   operation size() : int
  pre: true
  post: true
  activity: (     return self.size );
   operation contains( x : int) : boolean
  pre: true
  post: true
  activity: (     return index[x+1] );
   operation remove( x : int) : void
  pre: true
  post: true
  activity: (     if (index[x+1]) then (     index[x+1] := false ; 
     size := size - 1 ) else skip );
   operation dump( a : int, b : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ls : Sequence(int) ; ls := Sequence{} ;
         var i : int ; i := a ; while i <= b do ( (     if (index[i+1]) then     ls := ls->including(i) ; else skip )  ;     i := i + 1 ) ; 
     return ls );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;
public class Main {
  static long Function(long n){
    n+=1 ;
    while(n % 10==0 && n!=0){
      n=n/10 ;
    }
    return n ;
  }
  static int reachable(long n){
    HashSet<Long>h=new HashSet<Long>();
    h.add(n);
    n=Function(n);
    while(! h.contains(n)){
      h.add(n);
      n=Function(n);
    }
    return h.size();
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=1 ;
    while(t-->0){
      long n=Long.parseLong(br.readLine().trim());
      System.out.println(reachable(n));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation Function( n : long) : long
  pre: true
  post: true
  activity: (     n := n+(1) ; 
     while (n mod 10 = 0 & n /= 0) do (     n := n / 10 ) ; 
     return n );
  static   operation reachable( n : long) : int
  pre: true
  post: true
  activity: (     var h : Set(long) ; h := Set{} ;
     h := h->including(n) ; 
    n := Function(n) ; 
    while (not(h->includes(n))) do (     h := h->including(n) ; 
     n := Function(n) ) ; 
    return h->size() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := (br.readLine()->trim())->toLong() ;
     OclFile["System.out"].println(reachable(n)) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class Main {
  public static long ans=0L ;
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int cnt=0 ;
    while(n!=0){
      cnt++;
      n/=2 ;
    }
    System.out.println(cnt);
    sc.close();
    writer.flush();
    writer.close();
    reader.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ans : long := 0L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var cnt : int ; cnt := 0 ;
    while (n /= 0) do (     cnt := cnt + 1 ; 
     n := n/(2) ) ; 
    OclFile["System.out"].println(cnt) ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    TreeSet<Integer>set=new TreeSet<>();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      int type=sc.nextInt();
      int x=sc.nextInt();
      if(type==0){
        set.add(x);
        sb.append(set.size()).append("\n");
      }
      else if(type==1){
        if(set.contains(x)){
          sb.append(1);
        }
        else {
          sb.append(0);
        }
        sb.append("\n");
      }
      else if(type==2){
        set.remove(x);
      }
      else {
        int y=sc.nextInt();
        Integer tmp=x-1 ;
        while((tmp=set.higher(tmp))!=null && tmp<=y){
          sb.append(tmp).append("\n");
        }
      }
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     var type : int ; type := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (type = 0) then (     set := set->including(x) ; 
     sb := sb + StringLib.newString(set->size()) + StringLib.newString("\n") ) else     if (type = 1) then (     if (set->includes(x)) then (     sb := sb + StringLib.newString(1) ) else (     sb := sb + StringLib.newString(0) ) ;  
     sb := sb + StringLib.newString("\n") ) else     if (type = 2) then (     set := set->excludingAt(x+1) ) else (     var y : int ; y := sc.getCurrent()->toInteger() ;
     var tmp : int ; tmp := x - 1 ;
         tmp := set.higher(tmp) ;
    while ((tmp) /= null & tmp <= y) do (    skip ; (     sb := sb + StringLib.newString(tmp) + StringLib.newString("\n") ) ;     tmp := set.higher(tmp) ;
 ) ) ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      while(true){
        int N=sc.nextInt(),M=sc.nextInt();
        if(N==0 && M==0){
          break ;
        }
        int[] Vmin=new int[N],Vmax=new int[N];
        for(int i=0 ; i<M ; i++){
          int v=sc.nextInt();
          int num=sc.nextInt();
          for(int j=0 ; j<num ; j++){
            int p=sc.nextInt()-1 ;
            Vmax[p]+=v ;
            if(num==1){
              Vmin[p]+=v ;
            }
          }
        }
        int ansmin=0,ansmax=0 ;
        for(int i=0 ; i<N ; i++){
          if(Vmax[i]>Vmax[ansmax]){
            ansmax=i ;
          }
          else if(Vmin[i]<Vmin[ansmin]){
            ansmin=i ;
          }
        }
        System.out.println(Vmax[ansmax]-Vmin[ansmin]+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
     if (N = 0 & M = 0) then (     break ) else skip ; 
    var Vmin : Sequence(int) ; Vmin := Integer.subrange(1,N)->collect(0) ;
    var Vmax : Sequence(int) ; Vmax := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     var v : int ; v := sc.getCurrent()->toInteger() ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < num do ( (     var p : int ; p := sc.getCurrent()->toInteger() - 1 ;
     Vmax[p+1] := Vmax[p+1]+(v) ; 
     if (num = 1) then (     Vmin[p+1] := Vmin[p+1]+(v) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ansmin : int ; ansmin := 0 ;
    var ansmax : int ; ansmax := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (Vmax[i+1] > Vmax[ansmax+1]) then (     ansmax := i ) else     if (Vmin[i+1] < Vmin[ansmin+1]) then (     ansmin := i ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Vmax[ansmax+1] - Vmin[ansmin+1] + 1) ; 
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    ArrayList<Integer>result=new ArrayList<Integer>();
    Scanner insert=new Scanner(System.in);
    int n=-1 ;
    int m=-1 ;
    while(true){
      if((n==0)&&(m==0)){
        break ;
      }
      String line=insert.nextLine();
      String array1[]=line.split(" ");
      n=Integer.parseInt(array1[0]);
      m=Integer.parseInt(array1[1]);
      int[] min=new int[n];
      int[] max=new int[n];
      int sum=0 ;
      for(int i=0 ; i<m ; i++){
        String line2=insert.nextLine();
        String array2[]=line2.split(" ");
        int s=Integer.parseInt(array2[0]);
        int ninzu=Integer.parseInt(array2[1]);
        sum+=s ;
        if(ninzu==1){
          min[Integer.parseInt(array2[2])-1]+=s ;
          max[Integer.parseInt(array2[2])-1]+=s ;
        }
        else {
          for(int j=0 ; j<ninzu ; j++){
            max[Integer.parseInt(array2[j+2])-1]+=s ;
          }
        }
      }
      int minN=sum ;
      int maxN=0 ;
      int index=-1 ;
      for(int i=0 ; i<n ; i++){
        if(maxN<max[i]){
          maxN=max[i];
          index=i ;
        }
      }
      for(int i=0 ; i<n ; i++){
        if((i!=index)&&(minN>min[i])){
          minN=min[i];
        }
      }
      result.add(maxN-minN+1);
    }
    for(int i=0 ; i<(result.size()-1); i++){
      System.out.println(result.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var result : Sequence(int) ; result := Sequence{} ;
     var insert : OclFile ; insert := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := -1 ;
    var m : int ; m := -1 ;
    while (true) do (     if ((n = 0) & (m = 0)) then (     break ) else skip ; 
     var line : String ; line := insert.nextLine() ;
    var array1 : Sequence(String) ; array1 := line->split(" ") ;
    n := (array1[0+1])->toInteger() ; 
    m := (array1[1+1])->toInteger() ; 
    var min : Sequence(int) ; min := Integer.subrange(1,n)->collect(0) ;
    var max : Sequence(int) ; max := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var line2 : String ; line2 := insert.nextLine() ;
     var array2 : Sequence(String) ; array2 := line2->split(" ") ;
    var s : int ; s := (array2[0+1])->toInteger() ;
    var ninzu : int ; ninzu := (array2[1+1])->toInteger() ;
    sum := sum+(s) ; 
    if (ninzu = 1) then (     min[(array2[2+1])->toInteger() - 1+1] := min[(array2[2+1])->toInteger() - 1+1]+(s) ; 
     max[(array2[2+1])->toInteger() - 1+1] := max[(array2[2+1])->toInteger() - 1+1]+(s) ) else (         var j : int ; j := 0 ; while j < ninzu do ( (     max[(array2[j + 2+1])->toInteger() - 1+1] := max[(array2[j + 2+1])->toInteger() - 1+1]+(s) )  ;     j := j + 1 ) ) ;  
 )  ;     i := i + 1 ) ; 
    var minN : int ; minN := sum ;
    var maxN : int ; maxN := 0 ;
    var index : int ; index := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (maxN < max[i+1]) then (     maxN := max[i+1] ; 
     index := i ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if ((i /= index) & (minN > min[i+1])) then (     minN := min[i+1] ) else skip )  ;     i := i + 1 ) ; 
    result := result->including(maxN - minN + 1) ; 
 ) ; 
        var i : int ; i := 0 ; while i < (result->size() - 1) do ( (     OclFile["System.out"].println(result->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  Scanner sc=new Scanner(System.in);
  public void run(){
    while(sc.hasNext()){
      P p1=new P(sc.nextDouble(),sc.nextDouble());
      P p2=new P(sc.nextDouble(),sc.nextDouble());
      P p3=new P(sc.nextDouble(),sc.nextDouble());
      P p4=new P(sc.nextDouble(),sc.nextDouble());
      ln(P.isVertical(p1,p2,p3,p4)? "YES" : "NO");
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  public static void pr(Object o){
    System.out.print(o);
  }
  public static void ln(Object o){
    System.out.println(o);
  }
  public static void ln(){
    System.out.println();
  }
}
class P {
  double x ;
  double y ;
  P(double _x,double _y){
    x=_x ;
    y=_y ;
  }
  public static double dot(P a,P b){
    return a.x*b.x+a.y*b.y ;
  }
  public static boolean isVertical(P a1,P a2,P b1,P b2){
    return Math.abs(dot(a2.s(a1),b2.s(b1)))<Double.MIN_NORMAL ;
  }
  public P a(P a){
    return new P(x+a.x,y+a.y);
  }
  public P s(P a){
    return new P(x-a.x,y-a.y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     var p1 : P ; p1 := P.newP(sc.getCurrent()->toReal(), sc.getCurrent()->toReal()) ;
     var p2 : P ; p2 := P.newP(sc.getCurrent()->toReal(), sc.getCurrent()->toReal()) ;
    var p3 : P ; p3 := P.newP(sc.getCurrent()->toReal(), sc.getCurrent()->toReal()) ;
    var p4 : P ; p4 := P.newP(sc.getCurrent()->toReal(), sc.getCurrent()->toReal()) ;
    execute ln(if P.isVertical(p1, p2, p3, p4) then "YES" else "NO" endif) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
}
class P {
   attribute x : double;
   attribute y : double;
   static operation newP( _x : double, _y : double) : P
  pre: true
  post: true
  activity:
  ( var self : P ;
    self := createP();
    self.initialise(_x, _y);
    return self );
  operation initialise( _x : double, _y : double) : void
  pre: true  post: true
  activity: (     x := _x ; 
     y := _y );
  static   operation dot( a : P, b : P) : double
  pre: true
  post: true
  activity: (     return a.x * b.x + a.y * b.y );
  static   operation isVertical( a1 : P, a2 : P, b1 : P, b2 : P) : boolean
  pre: true
  post: true
  activity: (     return if dot(a2.s(a1), b2.s(b1)) < 0 then -(dot(a2.s(a1), b2.s(b1))) else dot(a2.s(a1), b2.s(b1)) endif < 2->pow(-1022) );
   operation a( a : P) : P
  pre: true
  post: true
  activity: (     return P.newP(x + a.x, y + a.y) );
   operation s( a : P) : P
  pre: true
  post: true
  activity: (     return P.newP(x - a.x, y - a.y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt(),m=in.nextInt();
    while(n!=0 && m!=0){
      long[] p=new long[n];
      long[] q=new long[n];
      for(int i=0 ; i<m ; i++){
        int s=in.nextInt();
        int k=in.nextInt();
        if(k==1){
          int c=in.nextInt()-1 ;
          q[c]+=s ;
          p[c]+=s ;
        }
        else {
          for(int j=0 ; j<k ; j++){
            p[in.nextInt()-1]+=s ;
          }
        }
      }
      long[] pl=new long[n+1],pr=new long[n+1];
      for(int i=0 ; i<n ; i++){
        pl[i+1]=Math.max(pl[i],p[i]);
      }
      for(int i=n-1 ; i>=0 ; i--){
        pr[i]=Math.max(pr[i+1],p[i]);
      }
      long ans=0 ;
      for(int i=0 ; i<n ; i++){
        ans=Math.max(ans,1+Math.max(pl[i],pr[i+1])-q[i]);
      }
      out.println(ans);
      n=in.nextInt();
      m=in.nextInt();
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    while (n /= 0 & m /= 0) do (     var p : Sequence(long) ; p := Integer.subrange(1,n)->collect(0) ;
     var q : Sequence(long) ; q := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     var s : int ; s := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
     if (k = 1) then (     var c : int ; c := in.getCurrent()->toInteger() - 1 ;
     q[c+1] := q[c+1]+(s) ; 
     p[c+1] := p[c+1]+(s) ) else (         var j : int ; j := 0 ; while j < k do ( (     p[in.getCurrent()->toInteger() - 1+1] := p[in.getCurrent()->toInteger() - 1+1]+(s) )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
    var pl : Sequence(long) ; pl := Integer.subrange(1,n + 1)->collect(0) ;
    var pr : Sequence(long) ; pr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     pl[i + 1+1] := Set{pl[i+1], p[i+1]}->max() )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     pr[i+1] := Set{pr[i + 1+1], p[i+1]}->max() )  ;     i := i - 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ans := Set{ans, 1 + Set{pl[i+1], pr[i + 1+1]}->max() - q[i+1]}->max() )  ;     i := i + 1 ) ; 
    skip ; 
    n := in.getCurrent()->toInteger() ; 
    m := in.getCurrent()->toInteger() ; 
 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int spiralDiaSum(int n){
    if(n==1)return 1 ;
    return(4*n*n-6*n+6+spiralDiaSum(n-2));
  }
  public static void main(String[] args){
    int n=7 ;
    System.out.print(spiralDiaSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation spiralDiaSum( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 1 else skip ; 
     return (4 * n * n - 6 * n + 6 + spiralDiaSum(n - 2)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     OclFile["System.out"].print(spiralDiaSum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static int sumofseries(int n){
    int res=0 ;
    for(int i=1 ; i<=n ; i++)res+=(i)*(i+1)*(i+2);
    return res ;
  }
  public static void main(String[] args){
    System.out.println(sumofseries(3));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumofseries( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 1 ; while i <= n do (     res := res+((i) * (i + 1) * (i + 2)) ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(sumofseries(3)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int[] ar=new int[n+2];
    ar[0]=0 ;
    ar[n+1]=0 ;
    int total=0 ;
    for(int i=1 ; i<n+1 ; i++){
      ar[i]=scanner.nextInt();
      total+=Math.abs(ar[i-1]-ar[i]);
    }
    scanner.close();
    total+=Math.abs(ar[n]-ar[n+1]);
    for(int i=1 ; i<n+1 ; i++){
      int a=Math.abs(ar[i-1]-ar[i+1]);
      int b=Math.abs(ar[i]-ar[i-1])+Math.abs(ar[i]-ar[i+1]);
      System.out.println(total+(a-b));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,n + 2)->collect(0) ;
    ar[0+1] := 0 ; 
    ar[n + 1+1] := 0 ; 
    var total : int ; total := 0 ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     ar[i+1] := scanner.getCurrent()->toInteger() ; 
     total := total+(if ar[i - 1+1] - ar[i+1] < 0 then -(ar[i - 1+1] - ar[i+1]) else ar[i - 1+1] - ar[i+1] endif) )  ;     i := i + 1 ) ; 
    skip ; 
    total := total+(if ar[n+1] - ar[n + 1+1] < 0 then -(ar[n+1] - ar[n + 1+1]) else ar[n+1] - ar[n + 1+1] endif) ; 
        var i : int ; i := 1 ; while i < n + 1 do ( (     var a : int ; a := if ar[i - 1+1] - ar[i + 1+1] < 0 then -(ar[i - 1+1] - ar[i + 1+1]) else ar[i - 1+1] - ar[i + 1+1] endif ;
     var b : int ; b := if ar[i+1] - ar[i - 1+1] < 0 then -(ar[i+1] - ar[i - 1+1]) else ar[i+1] - ar[i - 1+1] endif + if ar[i+1] - ar[i + 1+1] < 0 then -(ar[i+1] - ar[i + 1+1]) else ar[i+1] - ar[i + 1+1] endif ;
     OclFile["System.out"].println(total + (a - b)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static BufferedReader br ;
  static PrintWriter out ;
  static StringTokenizer st ;
  public static void main(String[] args)throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(new OutputStreamWriter(System.out));
    int N=readInt();
    int[] coor=new int[N+2];
    coor[0]=0 ;
    coor[N+1]=0 ;
    for(int i=1 ; i<=N ; i++){
      coor[i]=readInt();
    }
    int total=0 ;
    for(int i=1 ; i<=N+1 ; i++){
      total+=Math.abs(coor[i]-coor[i-1]);
    }
    for(int i=1 ; i<=N ; i++){
      System.out.println(total-Math.abs(coor[i]-coor[i-1])-Math.abs(coor[i+1]-coor[i])+Math.abs(coor[i+1]-coor[i-1]));
    }
  }
  static String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine().trim());
    return st.nextToken();
  }
  static long readLong()throws IOException {
    return Long.parseLong(next());
  }
  static int readInt()throws IOException {
    return Integer.parseInt(next());
  }
  static double readDouble()throws IOException {
    return Double.parseDouble(next());
  }
  static char readCharacter()throws IOException {
    return next().charAt(0);
  }
  static String readLine()throws IOException {
    return br.readLine().trim();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile;
  static   attribute out : OclFile;
  static   attribute st : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var N : int ; N := readInt() ;
    var coor : Sequence(int) ; coor := Integer.subrange(1,N + 2)->collect(0) ;
    coor[0+1] := 0 ; 
    coor[N + 1+1] := 0 ; 
        var i : int ; i := 1 ; while i <= N do ( (     coor[i+1] := readInt() )  ;     i := i + 1 ) ; 
    var total : int ; total := 0 ;
        var i : int ; i := 1 ; while i <= N + 1 do ( (     total := total+(if coor[i+1] - coor[i - 1+1] < 0 then -(coor[i+1] - coor[i - 1+1]) else coor[i+1] - coor[i - 1+1] endif) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (     OclFile["System.out"].println(total - if coor[i+1] - coor[i - 1+1] < 0 then -(coor[i+1] - coor[i - 1+1]) else coor[i+1] - coor[i - 1+1] endif - if coor[i + 1+1] - coor[i+1] < 0 then -(coor[i + 1+1] - coor[i+1]) else coor[i + 1+1] - coor[i+1] endif + if coor[i + 1+1] - coor[i - 1+1] < 0 then -(coor[i + 1+1] - coor[i - 1+1]) else coor[i + 1+1] - coor[i - 1+1] endif) )  ;     i := i + 1 ) ; 
 );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()->trim()) ; ; 
     return st.next() );
  static   operation readLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation readInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation readDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation readCharacter() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
  static   operation readLine() : String
  pre: true
  post: true
  activity: (     return br.readLine()->trim() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner((System.in));
    int n=sc.nextInt();
    int[] a=new int[n];
    int[] diff=new int[n+1];
    int sum=0,pre=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      int d=pre-a[i];
      sum+=Math.abs(d);
      diff[i]=d ;
      pre=a[i];
    }
    sum+=Math.abs(a[n-1]);
    diff[n]=a[n-1];
    for(int i=0 ; i<n ; i++){
      if((diff[i]<0 && diff[i+1]<0)||(diff[i]>0 && diff[i+1]>0)){
        System.out.println(sum);
      }
      else {
        if(Math.abs(diff[i])<=Math.abs(diff[i+1])){
          System.out.println((sum-Math.abs(diff[i]*2)));
        }
        else {
          System.out.println((sum-Math.abs(diff[i+1]*2)));
        }
      }
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read((OclFile["System.in"])) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var diff : Sequence(int) ; diff := Integer.subrange(1,n + 1)->collect(0) ;
    var sum : int ; sum := 0 ;
    var pre : int ; pre := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     var d : int ; d := pre - a[i+1] ;
    sum := sum+(if d < 0 then -(d) else d endif) ; 
    diff[i+1] := d ; 
    pre := a[i+1] ; 
 )  ;     i := i + 1 ) ; 
    sum := sum+(if a[n - 1+1] < 0 then -(a[n - 1+1]) else a[n - 1+1] endif) ; 
    diff[n+1] := a[n - 1+1] ; 
        var i : int ; i := 0 ; while i < n do ( (     if ((diff[i+1] < 0 & diff[i + 1+1] < 0) or (diff[i+1] > 0 & diff[i + 1+1] > 0)) then (     OclFile["System.out"].println(sum) ) else (     if (if diff[i+1] < 0 then -(diff[i+1]) else diff[i+1] endif <= if diff[i + 1+1] < 0 then -(diff[i + 1+1]) else diff[i + 1+1] endif) then (     OclFile["System.out"].println((sum - if diff[i+1] * 2 < 0 then -(diff[i+1] * 2) else diff[i+1] * 2 endif)) ) else (     OclFile["System.out"].println((sum - if diff[i + 1+1] * 2 < 0 then -(diff[i + 1+1] * 2) else diff[i + 1+1] * 2 endif)) ) ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import javax.lang.model.util.ElementScanner6 ;
public class ques1 {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int result=(int)(Math.log(n)/Math.log(2));
    System.out.println(result+1);
  }
  public static boolean isPrime(int n){
    boolean ans=true ;
    for(int i=2 ; i*i<=n ; i++){
      if(n % i==0){
        ans=false ;
        break ;
      }
    }
    if(ans==true)return true ;
    else return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ques1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
     var result : int ; result := ((n)->log() / (2)->log())->oclAsType(int) ;
     OclFile["System.out"].println(result + 1) );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     var ans : boolean ; ans := true ;
         var i : int ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     ans := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (ans = true) then     return true else     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.nextLine());
    String[] S=sc.nextLine().split(" ");
    int sum=0 ;
    int[] num=new int[N+1];
    for(int i=1 ; i<=N ; i++){
      num[i]=Integer.parseInt(S[i-1]);
      sum+=Math.abs(num[i]-num[i-1]);
    }
    sum+=Math.abs(num[N]);
    for(int i=1 ; i<=N ; i++){
      int ans=sum ;
      if(i!=N){
        ans=ans-Math.abs(num[i]-num[i-1])-Math.abs(num[i]-num[i+1])+Math.abs(num[i-1]-num[i+1]);
      }
      else {
        ans=ans-Math.abs(num[i]-num[i-1])-Math.abs(num[N])+Math.abs(num[N-1]);
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.nextLine())->toInteger() ;
    var S : Sequence(String) ; S := sc.nextLine()->split(" ") ;
    var sum : int ; sum := 0 ;
    var num : Sequence(int) ; num := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do ( (     num[i+1] := (S[i - 1+1])->toInteger() ; 
     sum := sum+(if num[i+1] - num[i - 1+1] < 0 then -(num[i+1] - num[i - 1+1]) else num[i+1] - num[i - 1+1] endif) )  ;     i := i + 1 ) ; 
    sum := sum+(if num[N+1] < 0 then -(num[N+1]) else num[N+1] endif) ; 
        var i : int ; i := 1 ; while i <= N do ( (     var ans : int ; ans := sum ;
     if (i /= N) then (     ans := ans - if num[i+1] - num[i - 1+1] < 0 then -(num[i+1] - num[i - 1+1]) else num[i+1] - num[i - 1+1] endif - if num[i+1] - num[i + 1+1] < 0 then -(num[i+1] - num[i + 1+1]) else num[i+1] - num[i + 1+1] endif + if num[i - 1+1] - num[i + 1+1] < 0 then -(num[i - 1+1] - num[i + 1+1]) else num[i - 1+1] - num[i + 1+1] endif ) else (     ans := ans - if num[i+1] - num[i - 1+1] < 0 then -(num[i+1] - num[i - 1+1]) else num[i+1] - num[i - 1+1] endif - if num[N+1] < 0 then -(num[N+1]) else num[N+1] endif + if num[N - 1+1] < 0 then -(num[N - 1+1]) else num[N - 1+1] endif ) ;  
     OclFile["System.out"].println(ans) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    int[] tintin=new int[n+1];
    tintin[0]=Math.abs(a[0]);
    for(int i=1 ; i<n ; i++){
      tintin[i]=tintin[i-1]+Math.abs(a[i]-a[i-1]);
    }
    tintin[n]=tintin[n-1]+Math.abs(a[n-1]);
    int[] tkb=new int[n];
    tkb[0]=Math.abs(a[1]);
    for(int i=1 ; i<n-1 ; i++){
      tkb[i]=Math.abs(a[i+1]-a[i-1]);
    }
    tkb[n-1]=Math.abs(a[n-2]);
    String ls=System.lineSeparator();
    StringBuilder sb=new StringBuilder();
    sb.append(tkb[0]+tintin[n]-tintin[1]);
    sb.append(ls);
    for(int i=1 ; i<n-1 ; i++){
      sb.append(tintin[i-1]+tkb[i]+tintin[n]-tintin[i+1]);
      sb.append(ls);
    }
    sb.append(tintin[n-2]+tkb[n-1]);
    sb.append(ls);
    System.out.println(sb.toString());
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var tintin : Sequence(int) ; tintin := Integer.subrange(1,n + 1)->collect(0) ;
    tintin[0+1] := if a[0+1] < 0 then -(a[0+1]) else a[0+1] endif ; 
        var i : int ; i := 1 ; while i < n do ( (     tintin[i+1] := tintin[i - 1+1] + if a[i+1] - a[i - 1+1] < 0 then -(a[i+1] - a[i - 1+1]) else a[i+1] - a[i - 1+1] endif )  ;     i := i + 1 ) ; 
    tintin[n+1] := tintin[n - 1+1] + if a[n - 1+1] < 0 then -(a[n - 1+1]) else a[n - 1+1] endif ; 
    var tkb : Sequence(int) ; tkb := Integer.subrange(1,n)->collect(0) ;
    tkb[0+1] := if a[1+1] < 0 then -(a[1+1]) else a[1+1] endif ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     tkb[i+1] := if a[i + 1+1] - a[i - 1+1] < 0 then -(a[i + 1+1] - a[i - 1+1]) else a[i + 1+1] - a[i - 1+1] endif )  ;     i := i + 1 ) ; 
    tkb[n - 1+1] := if a[n - 2+1] < 0 then -(a[n - 2+1]) else a[n - 2+1] endif ; 
    var ls : String ; ls := lineSeparator() ;
    var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString(tkb[0+1] + tintin[n+1] - tintin[1+1]) ; 
    sb := sb + StringLib.newString(ls) ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     sb := sb + StringLib.newString(tintin[(i)->char2byte() - 1+1] + tkb[i+1] + tintin[n+1] - tintin[i + 1+1]) ; 
     sb := sb + StringLib.newString(ls) )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(tintin[n - 2+1] + tkb[n - 1+1]) ; 
    sb := sb + StringLib.newString(ls) ; 
    OclFile["System.out"].println(sb+"") ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        int n=sc.nextInt();
        int m=sc.nextInt();
        int k=sc.nextInt();
        int x=1,y=1,cx=0 ;
        if(n*m-1==k)System.out.println("YES");
        else System.out.println("NO");
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var x : int ; x := 1 ;
    var y : int ; y := 1 ;
    var cx : int ; cx := 0 ;
    if (n * m - 1 = k) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    while(true){
      String line=reader.readLine();
      if(line==null || line.isEmpty()){
        break ;
      }
      String[] values=line.split(" ");
      double xa=Double.parseDouble(values[0]);
      double ya=Double.parseDouble(values[1]);
      double xb=Double.parseDouble(values[2]);
      double yb=Double.parseDouble(values[3]);
      double xc=Double.parseDouble(values[4]);
      double yc=Double.parseDouble(values[5]);
      double xd=Double.parseDouble(values[6]);
      double yd=Double.parseDouble(values[7]);
      double ip=(xb-xa)*(xd-xc)+(yb-ya)*(yd-yc);
      String result=ip==0.0 ? "YES" : "NO" ;
      out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     while (true) do (     var line : String ; line := reader.readLine() ;
     if (line = null or line->isEmpty()) then (     break ) else skip ; 
    var values : Sequence(String) ; values := line->split(" ") ;
    var xa : double ; xa := (values[0+1])->toReal() ;
    var ya : double ; ya := (values[1+1])->toReal() ;
    var xb : double ; xb := (values[2+1])->toReal() ;
    var yb : double ; yb := (values[3+1])->toReal() ;
    var xc : double ; xc := (values[4+1])->toReal() ;
    var yc : double ; yc := (values[5+1])->toReal() ;
    var xd : double ; xd := (values[6+1])->toReal() ;
    var yd : double ; yd := (values[7+1])->toReal() ;
    var ip : double ; ip := (xb - xa) * (xd - xc) + (yb - ya) * (yd - yc) ;
    var result : String ; result := if ip = 0.0 then "YES" else "NO" endif ;
    out.println(result) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DP_1519B {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int tc=scanner.nextInt();
    while(tc-->0){
      int x=scanner.nextInt();
      int y=scanner.nextInt();
      int k=scanner.nextInt();
      x-=1 ;
      y-=1 ;
      if(y+(x*(y+1))==k)System.out.println("YES");
      else System.out.println("NO");
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class DP_1519B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := scanner.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var x : int ; x := scanner.getCurrent()->toInteger() ;
     var y : int ; y := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
    x := x-(1) ; 
    y := y-(1) ; 
    if (y + (x * (y + 1)) = k) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TheCakeIsALie {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int dp[][]=new int[100][100];
    for(int i=0 ; i<100 ; i++){
      dp[0][i]=i ;
      dp[i][0]=i ;
    }
    for(int i=1 ; i<100 ; i++)for(int j=1 ; j<100 ; j++)dp[i][j]=dp[i-1][j]+(j+1);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int m=s.nextInt();
      int k=s.nextInt();
      if(dp[n-1][m-1]==k)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TheCakeIsALie {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(0)) ;
        var i : int ; i := 0 ; while i < 100 do ( (     dp[0+1][i+1] := i ; 
     dp[i+1][0+1] := i )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < 100 do (         var j : int ; j := 1 ; while j < 100 do (     dp[i+1][j+1] := dp[i - 1+1][j+1] + (j + 1) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var t : int ; t := s.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var m : int ; m := s.getCurrent()->toInteger() ;
     var k : int ; k := s.getCurrent()->toInteger() ;
     if (dp[n - 1+1][m - 1+1] = k) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Scanner ;
public class buildHouse {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int pointNumber=scan.nextInt();
    int highest=scan.nextInt();
    int limitNumber=scan.nextInt();
    LinkedList leftLimit=new LinkedList();
    LinkedList rightLimit=new LinkedList();
    LinkedList highestLimit=new LinkedList();
    int[] lastHigh=new int[pointNumber];
    int sum=0 ;
    for(int n=0 ; n<lastHigh.length ; n++){
      lastHigh[n]=highest ;
    }
    for(int i=0 ; i<limitNumber ; i++){
      leftLimit.add(scan.nextInt());
      rightLimit.add(scan.nextInt());
      highestLimit.add(scan.nextInt());
    }
    while(! leftLimit.isEmpty()){
      for(int k=(int)leftLimit.getFirst(); k<=(int)rightLimit.getFirst(); k++){
        if((int)highestLimit.getFirst()<=lastHigh[k-1]){
          lastHigh[k-1]=(int)highestLimit.getFirst();
        }
      }
      leftLimit.removeFirst();
      rightLimit.removeFirst();
      highestLimit.removeFirst();
    }
    for(int a=0 ; a<lastHigh.length ; a++){
      sum=sum+lastHigh[a]*lastHigh[a];
    }
    System.out.print(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class buildHouse {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pointNumber : int ; pointNumber := scan.getCurrent()->toInteger() ;
    var highest : int ; highest := scan.getCurrent()->toInteger() ;
    var limitNumber : int ; limitNumber := scan.getCurrent()->toInteger() ;
    var leftLimit : Sequence ; leftLimit := Sequence{} ;
    var rightLimit : Sequence ; rightLimit := Sequence{} ;
    var highestLimit : Sequence ; highestLimit := Sequence{} ;
    var lastHigh : Sequence(int) ; lastHigh := Integer.subrange(1,pointNumber)->collect(0) ;
    var sum : int ; sum := 0 ;
        var n : int ; n := 0 ; while n < lastHigh->size() do ( (     lastHigh[n+1] := highest )  ;     n := n + 1 ) ; 
        var i : int ; i := 0 ; while i < limitNumber do ( (     leftLimit := leftLimit->including(scan.getCurrent()->toInteger()) ; 
     rightLimit := rightLimit->including(scan.getCurrent()->toInteger()) ; 
     highestLimit := highestLimit->including(scan.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    while (not(leftLimit->isEmpty())) do (         var k : int ; k := leftLimit->first()->oclAsType(int) ; while k <= rightLimit->first()->oclAsType(int) do ( (     if (highestLimit->first()->oclAsType(int) <= lastHigh[k - 1+1]) then (     lastHigh[k - 1+1] := highestLimit->first()->oclAsType(int) ) else skip )  ;     k := k + 1 ) ; 
     leftLimit := leftLimit->tail() ; 
     rightLimit := rightLimit->tail() ; 
     highestLimit := highestLimit->tail() ) ; 
        var a : int ; a := 0 ; while a < lastHigh->size() do ( (     sum := sum + lastHigh[a+1] * lastHigh[a+1] )  ;     a := a + 1 ) ; 
    OclFile["System.out"].print(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Arrays ;
public class Main {
  static BufferedReader ins=new BufferedReader(new InputStreamReader(System.in));
  static StreamTokenizer in=new StreamTokenizer(ins);
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException {
    int[] a=new int[55];
    int n=in();
    int h=in();
    int k=in();
    Arrays.fill(a,h);
    for(int i=0 ; i<k ; i++){
      int l=in();
      int r=in();
      int x=in();
      for(int j=l ; j<=r ; j++){
        a[j]=Math.min(a[j],x);
      }
    }
    long res=0 ;
    for(int i=1 ; i<=n ; i++){
      res+=a[i]*a[i];
    }
    out.println(res);
    out.flush();
  }
  public static int in()throws IOException {
    in.nextToken();
    return(int)in.nval ;
  }
  public static long inl()throws IOException {
    in.nextToken();
    return(long)in.nval ;
  }
  public static double ind()throws IOException {
    in.nextToken();
    return in.nval ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ins : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute in : StreamTokenizer := StreamTokenizer.newStreamTokenizer(ins);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,55)->collect(0) ;
     var n : int ; n := in() ;
    var h : int ; h := in() ;
    var k : int ; k := in() ;
    a := a->collect(h) ; 
        var i : int ; i := 0 ; while i < k do ( (     var l : int ; l := in() ;
     var r : int ; r := in() ;
     var x : int ; x := in() ;
         var j : int ; j := l ; while j <= r do ( (     a[j+1] := Set{a[j+1], x}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     res := res+(a[i+1] * a[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation in() : int
  pre: true
  post: true
  activity: (     in.next() ; 
     return in.nval->oclAsType(int) );
  static   operation inl() : long
  pre: true
  post: true
  activity: (     in.next() ; 
     return in.nval->oclAsType(long) );
  static   operation ind() : double
  pre: true
  post: true
  activity: (     in.next() ; 
     return in.nval );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int h=s.nextInt();
    int m=s.nextInt();
    int[] a=new int[n];
    Arrays.fill(a,h);
    while(m-->0){
      int l=s.nextInt()-1 ;
      int r=s.nextInt()-1 ;
      int x=s.nextInt();
      for(int i=l ; i<=r ; i++){
        if(a[i]>x)a[i]=x ;
      }
    }
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=a[i]*a[i];
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var h : int ; h := s.getCurrent()->toInteger() ;
    var m : int ; m := s.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    a := a->collect(h) ; 
        while (m > 0) do (        m := m - 1 ;     skip ; (     var l : int ; l := s.getCurrent()->toInteger() - 1 ;
     var r : int ; r := s.getCurrent()->toInteger() - 1 ;
     var x : int ; x := s.getCurrent()->toInteger() ;
         var i : int ; i := l ; while i <= r do ( (     if (a[i+1] > x) then     a[i+1] := x ; else skip )  ;     i := i + 1 ) ) ;  ) ;  
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (     sum := sum+(a[i+1] * a[i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findMajority(int arr[],int n){
    int len=32 ;
    int number=0 ;
    for(int i=0 ; i<len ; i++){
      int count=0 ;
      for(int j=0 ; j<n ; j++){
        if((arr[j] &(1<<i))!=0)count++;
      }
      if(count>(n/2))number+=(1<<i);
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++)if(arr[i]==number)count++;
    if(count>(n/2))System.out.println(number);
    else System.out.println("Majority Element Not Present");
  }
  public static void main(String[] args){
    int arr[]={
      3,3,4,2,4,4,2,4,4 };
      int n=arr.length ;
      findMajority(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMajority( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var len : int ; len := 32 ;
     var number : int ; number := 0 ;
        var i : int ; i := 0 ; while i < len do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if ((arr[j+1] & ((1*(2->pow(i)))->oclAsType(long))) /= 0) then     count := count + 1 ; else skip )  ;     j := j + 1 ) ; 
     if (count > (n / 2)) then     number := number+(((1*(2->pow(i)))->oclAsType(long))) ; else skip )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (arr[i+1] = number) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
    if (count > (n / 2)) then     OclFile["System.out"].println(number) else     OclFile["System.out"].println("Majority Element Not Present") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,3,4,2,4,4,2,4,4} ;
     var n : int ; n := arr->size() ;
     execute findMajority(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import javax.lang.model.util.ElementScanner6 ;
public class ques1 {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int y=1 ;
    int ans=0 ;
    while(y<=n){
      y*=2 ;
      ans++;
    }
    System.out.println(ans);
  }
  public static boolean isPrime(int n){
    boolean ans=true ;
    for(int i=2 ; i*i<=n ; i++){
      if(n % i==0){
        ans=false ;
        break ;
      }
    }
    if(ans==true)return true ;
    else return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ques1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var y : int ; y := 1 ;
    var ans : int ; ans := 0 ;
    while (y <= n) do (     y := y*(2) ; 
     ans := ans + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     var ans : boolean ; ans := true ;
         var i : int ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     ans := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (ans = true) then     return true else     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
class GFG {
  static void getAverageCountArray(int[] a,int x,int N){
    HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();
    int[] avg=new int[N];
    int val,av ;
    for(int i=0 ; i<N ; i++){
      if(! map.containsKey(a[i])){
        map.put(a[i],1);
      }
      else {
        val=map.get(a[i]);
        val++;
        map.remove(a[i]);
        map.put(a[i],val);
      }
    }
    for(int i=0 ; i<N ; i++){
      av=(a[i]+x)/2 ;
      if(map.containsKey(av)){
        val=map.get(av);
        avg[i]=val ;
      }
    }
    for(int i=0 ; i<N ; i++){
      System.out.print(avg[i]+" ");
    }
  }
  public static void main(String args[]){
    int[] a={
      2,0,4,6,2 };
      int x=2 ;
      int N=a.length ;
      getAverageCountArray(a,x,N);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getAverageCountArray( a : Sequence(int), x : int, N : int) : void
  pre: true
  post: true
  activity: (     var map : Map(int,int) ; map := Map{} ;
     var avg : Sequence(int) ; avg := Integer.subrange(1,N)->collect(0) ;
    var val : int ;
    var av : int ;
        var i : int ; i := 0 ; while i < N do ( (     if (not(map->keys()->includes(a[i+1]))) then (     map := map->union(Map{a[i+1] |-> 1}) ) else (     val := map->at(a[i+1]) ; 
     val := val + 1 ; 
     map := map->antirestrict(Set{a[i+1]}) ; 
     map := map->union(Map{a[i+1] |-> val}) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     av := (a[i+1] + x) / 2 ; 
     if (map->keys()->includes(av)) then (     val := map->at(av) ; 
     avg[i+1] := val ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].print(avg[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,0,4,6,2} ;
     var x : int ; x := 2 ;
     var N : int ; N := a->size() ;
     execute getAverageCountArray(a, x, N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX_INDEX=51 ;
  static int MAX_SUM=2505 ;
  static int[][][] dp=new int[MAX_INDEX][MAX_SUM][MAX_INDEX];
  static int waysutil(int index,int sum,int count,Vector<Integer>arr,int K){
    if(index<0){
      return 0 ;
    }
    if(index==0){
      if(count==0){
        return 0 ;
      }
      int remainder=sum % count ;
      if(remainder!=0){
        return 0 ;
      }
      int average=sum/count ;
      if(average==K){
        return 1 ;
      }
    }
    if(dp[index][sum][count]!=-1){
      return dp[index][sum][count];
    }
    int dontpick=waysutil(index-1,sum,count,arr,K);
    int pick=waysutil(index-1,sum+arr.get(index),count+1,arr,K);
    int total=pick+dontpick ;
    dp[index][sum][count]=total ;
    return total ;
  }
  static int ways(int N,int K,int[] arr){
    Vector<Integer>Arr=new Vector<>();
    Arr.add(-1);
    for(int i=0 ; i<N ; ++i){
      Arr.add(arr[i]);
    }
    for(int i=0 ; i<MAX_INDEX ; i++){
      for(int j=0 ; j<MAX_SUM ; j++){
        for(int l=0 ; l<MAX_INDEX ; l++){
          dp[i][j][l]=-1 ;
        }
      }
    }
    int answer=waysutil(N,0,0,Arr,K);
    return answer ;
  }
  public static void main(String args[]){
    int arr[]={
      3,6,2,8,7,6,5,9 };
      int N=arr.length ;
      int K=5 ;
      System.out.println(ways(N,K,arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX_INDEX : int := 51;
  static   attribute MAX_SUM : int := 2505;
  static   attribute dp : Sequence(Sequence(Sequence(int))) := Integer.subrange(1,MAX_INDEX)->collect(Integer.subrange(1,MAX_SUM)->collect(Integer.subrange(1,MAX_INDEX)->collect(0)));
  static   operation waysutil( index : int, sum : int, count : int, arr : Sequence(int), K : int) : int
  pre: true
  post: true
  activity: (     if (index < 0) then (     return 0 ) else skip ; 
     if (index = 0) then (     if (count = 0) then (     return 0 ) else skip ; 
     var remainder : int ; remainder := sum mod count ;
    if (remainder /= 0) then (     return 0 ) else skip ; 
    var average : int ; average := sum / count ;
    if (average = K) then (     return 1 ) else skip ; 
 ) else skip ; 
    if (dp[index+1][sum+1][count+1] /= -1) then (     return dp[index+1][sum+1][count+1] ) else skip ; 
    var dontpick : int ; dontpick := waysutil(index - 1, sum, count, arr, K) ;
    var pick : int ; pick := waysutil(index - 1, sum + arr->at(index+1), count + 1, arr, K) ;
    var total : int ; total := pick + dontpick ;
    dp[index+1][sum+1][count+1] := total ; 
    return total 
 );
  static   operation ways( N : int, K : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var Arr : Sequence(int) ; Arr := Sequence{} ;
     Arr := Arr->including(-1) ; 
        var i : int ; i := 0 ; while i < N do ( (     Arr := Arr->including(arr[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < MAX_INDEX do ( (         var j : int ; j := 0 ; while j < MAX_SUM do ( (         var l : int ; l := 0 ; while l < MAX_INDEX do ( (     dp[i+1][j+1][l+1] := -1 )  ;     l := l + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var answer : int ; answer := waysutil(N, 0, 0, Arr, K) ;
    return answer 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,6,2,8,7,6,5,9} ;
     var N : int ; N := arr->size() ;
     var K : int ; K := 5 ;
     OclFile["System.out"].println(ways(N, K, arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String buf ;
    try {
      while((buf=br.readLine())!=null){
        double x[]=new double[4];
        double y[]=new double[4];
        StringTokenizer st=new StringTokenizer(buf);
        for(int i=0 ; i<4 ; i++){
          x[i]=Double.parseDouble(st.nextToken());
          y[i]=Double.parseDouble(st.nextToken());
        }
        double vx[]=new double[2];
        double vy[]=new double[2];
        vx[0]=x[1]-x[0];
        vy[0]=y[1]-y[0];
        vx[1]=x[3]-x[2];
        vy[1]=y[3]-y[2];
        double dif=vx[0]*vx[1]+vy[0]*vy[1];
        if(Math.abs(Math.round(dif*Math.pow(100000,2)))==0)System.out.println("YES");
        else System.out.println("NO");
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var buf : String ;
     try (         buf := br.readLine() ;
    while ((buf) /= null) do (    skip ; (     var x : Sequence(double) ; x := Integer.subrange(1,4)->collect(0.0) ;
     var y : Sequence(double) ; y := Integer.subrange(1,4)->collect(0.0) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(buf) ;
        var i : int ; i := 0 ; while i < 4 do ( (     x[i+1] := (st.next())->toReal() ; 
     y[i+1] := (st.next())->toReal() )  ;     i := i + 1 ) ; 
    var vx : Sequence(double) ; vx := Integer.subrange(1,2)->collect(0.0) ;
    var vy : Sequence(double) ; vy := Integer.subrange(1,2)->collect(0.0) ;
    vx[0+1] := x[1+1] - x[0+1] ; 
    vy[0+1] := y[1+1] - y[0+1] ; 
    vx[1+1] := x[3+1] - x[2+1] ; 
    vy[1+1] := y[3+1] - y[2+1] ; 
    var dif : double ; dif := vx[0+1] * vx[1+1] + vy[0+1] * vy[1+1] ;
    if (if (dif * 100000->pow(2))->round() < 0 then -((dif * 100000->pow(2))->round()) else (dif * 100000->pow(2))->round() endif = 0) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;     buf := br.readLine() ;
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int alice=0 ;
      for(int i=0 ; i<n ; i++)alice=Math.max(alice,sc.nextInt());
      int m=sc.nextInt();
      int bob=0 ;
      for(int i=0 ; i<m ; i++)bob=Math.max(bob,sc.nextInt());
      System.out.println(alice<bob ? "Bob" : "Alice");
      System.out.println(alice>bob ? "Alice" : "Bob");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var alice : int ; alice := 0 ;
        var i : int ; i := 0 ; while i < n do (     alice := Set{alice, sc.getCurrent()->toInteger()}->max() ;  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var bob : int ; bob := 0 ;
        var i : int ; i := 0 ; while i < m do (     bob := Set{bob, sc.getCurrent()->toInteger()}->max() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if alice < bob then "Bob" else "Alice" endif) ; 
    OclFile["System.out"].println(if alice > bob then "Alice" else "Bob" endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] alice=new int[n];
      for(int i=0 ; i<n ; i++)alice[i]=sc.nextInt();
      int m=sc.nextInt();
      int[] bob=new int[m];
      for(int i=0 ; i<m ; i++)bob[i]=sc.nextInt();
      Arrays.sort(alice);
      Arrays.sort(bob);
      System.out.println(alice[n-1]<bob[m-1] ? "Bob" : "Alice");
      System.out.println(alice[n-1]>bob[m-1] ? "Alice" : "Bob");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var alice : Sequence(int) ; alice := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     alice[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var bob : Sequence(int) ; bob := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     bob[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    alice := alice->sort() ; 
    bob := bob->sort() ; 
    OclFile["System.out"].println(if alice[n - 1+1] < bob[m - 1+1] then "Bob" else "Alice" endif) ; 
    OclFile["System.out"].println(if alice[n - 1+1] > bob[m - 1+1] then "Alice" else "Bob" endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class helloworld {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      int arr[]=new int[n];
      int maxA=0 ;
      for(int i=0 ; i<n ; i++){
        maxA=Math.max(maxA,sc.nextInt());
      }
      int m=sc.nextInt();
      int maxB=0 ;
      for(int i=0 ; i<m ; i++){
        maxB=Math.max(maxB,sc.nextInt());
      }
      if(maxA>maxB){
        System.out.println("Alice");
        System.out.println("Alice");
      }
      else if(maxB>maxA){
        System.out.println("Bob");
        System.out.println("Bob");
      }
      else {
        System.out.println("Alice");
        System.out.println("Bob");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class helloworld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var maxA : int ; maxA := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     maxA := Set{maxA, sc.getCurrent()->toInteger()}->max() )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var maxB : int ; maxB := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     maxB := Set{maxB, sc.getCurrent()->toInteger()}->max() )  ;     i := i + 1 ) ; 
    if (maxA > maxB) then (     OclFile["System.out"].println("Alice") ; 
     OclFile["System.out"].println("Alice") ) else     if (maxB > maxA) then (     OclFile["System.out"].println("Bob") ; 
     OclFile["System.out"].println("Bob") ) else (     OclFile["System.out"].println("Alice") ; 
     OclFile["System.out"].println("Bob") ) ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int AG=sc.nextInt();
    while(AG-->0){
      int maxa=0,maxb=0 ;
      int fr ;
      int al=sc.nextInt();
      while(al-->0){
        fr=sc.nextInt();
        maxa=Math.max(maxa,fr);
      }
      int op=sc.nextInt();
      while(op-->0){
        fr=sc.nextInt();
        maxb=Math.max(maxb,fr);
      }
      System.out.println(maxa<maxb ? "Bob" : "Alice");
      System.out.println(maxa>maxb ? "Alice" : "Bob");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var AG : int ; AG := sc.getCurrent()->toInteger() ;
         while (AG > 0) do (        AG := AG - 1 ;     skip ; (     var maxa : int ; maxa := 0 ;
    var maxb : int ; maxb := 0 ;
     var fr : int ;
    var al : int ; al := sc.getCurrent()->toInteger() ;
        while (al > 0) do (        al := al - 1 ;     skip ; (     fr := sc.getCurrent()->toInteger() ; 
     maxa := Set{maxa, fr}->max() ) ;  ) ;  
    var op : int ; op := sc.getCurrent()->toInteger() ;
        while (op > 0) do (        op := op - 1 ;     skip ; (     fr := sc.getCurrent()->toInteger() ; 
     maxb := Set{maxb, fr}->max() ) ;  ) ;  
    OclFile["System.out"].println(if maxa < maxb then "Bob" else "Alice" endif) ; 
    OclFile["System.out"].println(if maxa > maxb then "Alice" else "Bob" endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void reverseFibonacci(int n){
    int a[]=new int[n];
    a[0]=0 ;
    a[1]=1 ;
    for(int i=2 ; i<n ; i++){
      a[i]=a[i-2]+a[i-1];
    }
    for(int i=n-1 ; i>=0 ; i--){
      System.out.print(a[i]+" ");
    }
  }
  public static void main(String[] args){
    int n=5 ;
    reverseFibonacci(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation reverseFibonacci( n : int) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
     a[0+1] := 0 ; 
    a[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < n do ( (     a[i+1] := a[i - 2+1] + a[i - 1+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     OclFile["System.out"].print(a[i+1] + " ") )  ;     i := i - 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute reverseFibonacci(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int max_xor(int arr[],int n){
    int maxx=0,mask=0 ;
    HashSet<Integer>se=new HashSet<Integer>();
    for(int i=30 ; i>=0 ; i--){
      mask |=(1<<i);
      for(int j=0 ; j<n ; ++j){
        se.add(arr[j] & mask);
      }
      int newMaxx=maxx |(1<<i);
      for(int prefix : se){
        if(se.contains(newMaxx ^ prefix)){
          maxx=newMaxx ;
          break ;
        }
      }
      se.clear();
    }
    return maxx ;
  }
  public static void main(String[] args){
    int arr[]={
      25,10,2,8,5,3 };
      int n=arr.length ;
      System.out.println(max_xor(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation max_xor( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var maxx : int ; maxx := 0 ;
    var mask : int ; mask := 0 ;
     var se : Set(int) ; se := Set{} ;
         var i : int ; i := 30 ; while i >= 0 do ( (     mask := MathLib.bitwiseOr(mask, ((1*(2->pow(i)))->oclAsType(long))) ; 
         var j : int ; j := 0 ; while j < n do ( (     se := se->including(arr[j+1] & mask) )  ;     j := j + 1 ) ; 
    var newMaxx : int ; newMaxx := MathLib.bitwiseOr(maxx,((1*(2->pow(i)))->oclAsType(long))) ;
    for (prefix : se) do ( (     if (se->includes(MathLib.bitwiseXor(newMaxx,prefix))) then (     maxx := newMaxx ; 
     break ) else skip )  ) ; 
    se := se->intersection(Set{}) ; 
 )  ;     i := i - 1 ) ; 
     return maxx );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{25,10,2,8,5,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(max_xor(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class main {
  public static void main(String[] args){
    int input ;
    Scanner sc=new Scanner(System.in);
    input=sc.nextInt();
    int packets=Integer.toBinaryString(input).length();
    System.out.println(packets);
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    input := sc.getCurrent()->toInteger() ; 
    var packets : int ; packets := (MathLib.decimal2binary(input) + "")->size() ;
    OclFile["System.out"].println(packets) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.IOException ;
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.Deque ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Map.Entry ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int C=in.nextInt();
    int[][] D=new int[C][C];
    long[][] d=new long[3][C];
    for(int i=0 ; i<C ; i++){
      for(int j=0 ; j<C ; j++)D[i][j]=in.nextInt();
    }
    int[][] c=new int[N][N];
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        c[i][j]=in.nextInt();
        for(int k=1 ; k<=C ; k++){
          d[((i+j)% 3)][k-1]+=D[c[i][j]-1][k-1];
        }
      }
    }
    long min=Long.MAX_VALUE ;
    for(int i=1 ; i<=C ; i++){
      for(int j=1 ; j<=C ; j++){
        if(i==j)continue ;
        for(int k=1 ; k<=C ; k++){
          if(i==k || j==k)continue ;
          long cost=0 ;
          cost+=d[0][i-1];
          cost+=d[1][j-1];
          cost+=d[2][k-1];
          min=Math.min(min,cost);
        }
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var C : int ; C := in.getCurrent()->toInteger() ;
    var D : Sequence(Sequence(int)) ; D := Integer.subrange(1,C)->collect(Integer.subrange(1,C)->collect(0)) ;
    var d : Sequence(Sequence(long)) ; d := Integer.subrange(1,3)->collect(Integer.subrange(1,C)->collect(0)) ;
        var i : int ; i := 0 ; while i < C do ( (         var j : int ; j := 0 ; while j < C do (     D[i+1][j+1] := in.getCurrent()->toInteger() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     c[i+1][j+1] := in.getCurrent()->toInteger() ; 
         var k : int ; k := 1 ; while k <= C do ( (     d[((i + j) mod 3)+1][k - 1+1] := d[((i + j) mod 3)+1][k - 1+1]+(D[c[i+1][j+1] - 1+1][k - 1+1]) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var min : long ; min := "9223372036854775807"->toLong() ;
        var i : int ; i := 1 ; while i <= C do ( (         var j : int ; j := 1 ; while j <= C do ( (     if (i = j) then     continue else skip ; 
         var k : int ; k := 1 ; while k <= C do ( (     if (i = k or j = k) then     continue else skip ; 
     var cost : long ; cost := 0 ;
    cost := cost+(d[0+1][i - 1+1]) ; 
    cost := cost+(d[1+1][j - 1+1]) ; 
    cost := cost+(d[2+1][k - 1+1]) ; 
    min := Set{min, cost}->min() ; 
 )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new AOJ0221().doIt();
  }
  class AOJ0221 {
    boolean[] person ;
    int m,n ;
    void doIt(){
      while(true){
        m=in.nextInt();
        n=in.nextInt();
        if(m+n==0)break ;
        person=new boolean[m];
        int user=0 ;
        int cnt=0 ;
        for(int i=1 ; i<=n ; i++){
          String input=in.next();
          String talk=getTalk(i);
          if(input.equals(talk)==false && m-cnt>1){
            person[user]=true ;
            cnt++;
          }
          user=getUser(user);
        }
        int i ;
        for(i=0 ; i<m ; i++)if(person[i]==false){
          System.out.print(i+1);
          break ;
        }
        for(i=i+1 ; i<m ; i++)if(person[i]==false)System.out.print(" "+(i+1));
        System.out.println();
      }
    }
    String getTalk(int num){
      return num % 15==0 ? "FizzBuzz" : num % 3==0 ? "Fizz" : num % 5==0 ? "Buzz" : Integer.toString(num);
    }
    int getUser(int currentUser){
      for(int i=1 ; i<=m ; i++)if(! person[(currentUser+i)% m])return(currentUser+i)% m ;
      return-1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     AOJ0221.newAOJ0221().doIt() );
 class AOJ0221 {
   attribute person : Sequence(boolean);
   attribute m : int;
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (true) do (     m := in.getCurrent()->toInteger() ; 
     n := in.getCurrent()->toInteger() ; 
    if (m + n = 0) then     break else skip ; 
    person := Integer.subrange(1,m)->collect(false) ; 
    var user : int ; user := 0 ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var input : String ; input := in.getCurrent() ;
     var talk : String ; talk := getTalk(i) ;
     if (input = talk = false & m - cnt > 1) then (     person[user+1] := true ; 
     cnt := cnt + 1 ) else skip ; 
     user := getUser(user) )  ;     i := i + 1 ) ; 
    var i : int ;
        i := 0 ; while i < m do (     if (person[i+1] = false) then (     OclFile["System.out"].print(i + 1) ; 
     break ) else skip ;  ;     i := i + 1 ) ; 
        i := i + 1 ; while i < m do (     if (person[i+1] = false) then     OclFile["System.out"].print(" " + (i + 1)) ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) );
   operation getTalk( num : int) : String
  pre: true
  post: true
  activity: (     return if num mod 15 = 0 then "FizzBuzz" else if num mod 3 = 0 then "Fizz" else if num mod 5 = 0 then "Buzz" else ((num) + "") endif endif endif );
   operation getUser( currentUser : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= m do (     if (not(person[(currentUser + i) mod m+1])) then     return (currentUser + i) mod m else skip ;  ;     i := i + 1 ) ; 
     return -1 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int c=sc.nextInt();
    int[][] d=new int[c+1][c+1];
    int[][] grid=new int[3][c+1];
    for(int i=1 ; i<c+1 ; i++){
      for(int j=1 ; j<c+1 ; j++){
        d[i][j]=sc.nextInt();
      }
    }
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<c+1 ; j++){
        grid[i][j]=0 ;
      }
    }
    for(int i=1 ; i<n+1 ; i++){
      for(int j=1 ; j<n+1 ; j++){
        int tmp=sc.nextInt();
        grid[(i+j)% 3][tmp]++;
      }
    }
    int ans=Integer.MAX_VALUE ;
    for(int i=1 ; i<c+1 ; i++){
      for(int j=1 ; j<c+1 ; j++){
        if(i!=j){
          for(int k=1 ; k<c+1 ; k++){
            if(i!=k && j!=k){
              int dif=0 ;
              for(int l=1 ; l<c+1 ; l++){
                dif+=d[l][i]*grid[0][l];
                dif+=d[l][j]*grid[1][l];
                dif+=d[l][k]*grid[2][l];
              }
              ans=Math.min(ans,dif);
            }
          }
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : Sequence(Sequence(int)) ; d := Integer.subrange(1,c + 1)->collect(Integer.subrange(1,c + 1)->collect(0)) ;
    var grid : Sequence(Sequence(int)) ; grid := Integer.subrange(1,3)->collect(Integer.subrange(1,c + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i < c + 1 do ( (         var j : int ; j := 1 ; while j < c + 1 do ( (     d[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < c + 1 do ( (     grid[i+1][j+1] := 0 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n + 1 do ( (         var j : int ; j := 1 ; while j < n + 1 do ( (     var tmp : int ; tmp := sc.getCurrent()->toInteger() ;
     grid[(i + j) mod 3+1][tmp+1] := grid[(i + j) mod 3+1][tmp+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 1 ; while i < c + 1 do ( (         var j : int ; j := 1 ; while j < c + 1 do ( (     if (i /= j) then (         var k : int ; k := 1 ; while k < c + 1 do ( (     if (i /= k & j /= k) then (     var dif : int ; dif := 0 ;
         var l : int ; l := 1 ; while l < c + 1 do ( (     dif := dif+(d[l+1][i+1] * grid[0+1][l+1]) ; 
     dif := dif+(d[l+1][j+1] * grid[1+1][l+1]) ; 
     dif := dif+(d[l+1][k+1] * grid[2+1][l+1]) )  ;     l := l + 1 ) ; 
     ans := Set{ans, dif}->min() ) else skip )  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(final String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int n=scanner.nextInt();
    final int c=scanner.nextInt();
    final long[][] colorTable=new long[c][c];
    for(int i=0 ; i<c ; i++){
      for(int j=0 ; j<c ; j++){
        colorTable[i][j]=scanner.nextLong();
      }
    }
    final long[][] modTable=new long[3][c];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        final int tmp=scanner.nextInt()-1 ;
        modTable[(i+j)% 3][tmp]++;
      }
    }
    long answer=Long.MAX_VALUE ;
    for(int i=0 ; i<c ; i++){
      for(int j=0 ; j<c ; j++){
        if(i==j){
          continue ;
        }
        for(int k=0 ; k<c ; k++){
          if(i==k || j==k){
            continue ;
          }
          int tmp=0 ;
          for(int l=0 ; l<c ; l++){
            tmp+=modTable[0][l]*colorTable[l][i];
            tmp+=modTable[1][l]*colorTable[l][j];
            tmp+=modTable[2][l]*colorTable[l][k];
          }
          answer=Math.min(answer,tmp);
        }
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    var colorTable : Sequence(Sequence(long)) ; colorTable := Integer.subrange(1,c)->collect(Integer.subrange(1,c)->collect(0)) ;
        var i : int ; i := 0 ; while i < c do ( (         var j : int ; j := 0 ; while j < c do ( (     colorTable[i+1][j+1] := scanner.getCurrent()->toLong() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var modTable : Sequence(Sequence(long)) ; modTable := Integer.subrange(1,3)->collect(Integer.subrange(1,c)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     var tmp : int ; tmp := scanner.getCurrent()->toInteger() - 1 ;
     modTable[(i + j) mod 3+1][tmp+1] := modTable[(i + j) mod 3+1][tmp+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var answer : long ; answer := "9223372036854775807"->toLong() ;
        var i : int ; i := 0 ; while i < c do ( (         var j : int ; j := 0 ; while j < c do ( (     if (i = j) then (     continue ) else skip ; 
         var k : int ; k := 0 ; while k < c do ( (     if (i = k or j = k) then (     continue ) else skip ; 
     var tmp : int ; tmp := 0 ;
         var l : int ; l := 0 ; while l < c do ( (     tmp := tmp+(modTable[0+1][l+1] * colorTable[l+1][i+1]) ; 
     tmp := tmp+(modTable[1+1][l+1] * colorTable[l+1][j+1]) ; 
     tmp := tmp+(modTable[2+1][l+1] * colorTable[l+1][k+1]) )  ;     l := l + 1 ) ; 
     answer := Set{answer, tmp}->min() )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt(),C=sc.nextInt();
    int D[][]=new int[C][C];
    int c[][]=new int[N][N];
    for(int i=0 ; i<C ; i++){
      for(int j=0 ; j<C ; j++){
        D[i][j]=sc.nextInt();
      }
    }
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        c[i][j]=sc.nextInt()-1 ;
      }
    }
    sc.close();
    int costSum0[]=new int[C];
    int costSum1[]=new int[C];
    int costSum2[]=new int[C];
    for(int color=0 ; color<C ; color++){
      for(int i=0 ; i<N ; i++){
        for(int j=0 ; j<N ; j++){
          int nowColor=c[i][j];
          if((i+j)% 3==0)costSum0[color]+=D[nowColor][color];
          if((i+j)% 3==1)costSum1[color]+=D[nowColor][color];
          if((i+j)% 3==2)costSum2[color]+=D[nowColor][color];
        }
      }
    }
    int ans=Integer.MAX_VALUE/2 ;
    for(int i=0 ; i<C ; i++){
      for(int j=0 ; j<C ; j++){
        for(int k=0 ; k<C ; k++){
          if(i==j || j==k || k==i)continue ;
          int sum=costSum0[i]+costSum1[j]+costSum2[k];
          ans=Math.min(ans,sum);
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var D : Sequence(Sequence(int)) ; D := Integer.subrange(1,C)->collect(Integer.subrange(1,C)->collect(0)) ;
    var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
        var i : int ; i := 0 ; while i < C do ( (         var j : int ; j := 0 ; while j < C do ( (     D[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     c[i+1][j+1] := sc.getCurrent()->toInteger() - 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    var costSum0 : Sequence(int) ; costSum0 := Integer.subrange(1,C)->collect(0) ;
    var costSum1 : Sequence(int) ; costSum1 := Integer.subrange(1,C)->collect(0) ;
    var costSum2 : Sequence(int) ; costSum2 := Integer.subrange(1,C)->collect(0) ;
        var color : int ; color := 0 ; while color < C do ( (         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     var nowColor : int ; nowColor := c[i+1][j+1] ;
     if ((i + j) mod 3 = 0) then     costSum0[color+1] := costSum0[color+1]+(D[nowColor+1][color+1]) ; else skip ; 
     if ((i + j) mod 3 = 1) then     costSum1[color+1] := costSum1[color+1]+(D[nowColor+1][color+1]) ; else skip ; 
     if ((i + j) mod 3 = 2) then     costSum2[color+1] := costSum2[color+1]+(D[nowColor+1][color+1]) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     color := color + 1 ) ; 
    var ans : int ; ans := 2147483647 / 2 ;
        var i : int ; i := 0 ; while i < C do ( (         var j : int ; j := 0 ; while j < C do ( (         var k : int ; k := 0 ; while k < C do ( (     if (i = j or j = k or k = i) then     continue else skip ; 
     var sum : int ; sum := costSum0[i+1] + costSum1[j+1] + costSum2[k+1] ;
     ans := Set{ans, sum}->min() )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int C=scanner.nextInt();
    int[][] D=new int[C][C];
    for(int i=0 ; i<C ; i++){
      for(int j=0 ; j<C ; j++){
        D[i][j]=scanner.nextInt();
      }
    }
    int[][] c=new int[N][N];
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        c[i][j]=scanner.nextInt();
      }
    }
    int[][] cost=new int[3][C+1];
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        for(int k=1 ; k<=C ; k++){
          cost[(i+j+2)% 3][k]+=D[c[i][j]-1][k-1];
        }
      }
    }
    int min=Integer.MAX_VALUE ;
    for(int ia=1 ; ia<=C ; ia++){
      for(int ib=1 ; ib<=C ; ib++){
        if(ia==ib)continue ;
        for(int ic=1 ; ic<=C ; ic++){
          if(ia==ic || ib==ic)continue ;
          int t=cost[0][ia]+cost[1][ib]+cost[2][ic];
          if(t<min)min=t ;
        }
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var C : int ; C := scanner.getCurrent()->toInteger() ;
    var D : Sequence(Sequence(int)) ; D := Integer.subrange(1,C)->collect(Integer.subrange(1,C)->collect(0)) ;
        var i : int ; i := 0 ; while i < C do ( (         var j : int ; j := 0 ; while j < C do ( (     D[i+1][j+1] := scanner.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     c[i+1][j+1] := scanner.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var cost : Sequence(Sequence(int)) ; cost := Integer.subrange(1,3)->collect(Integer.subrange(1,C + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (         var k : int ; k := 1 ; while k <= C do ( (     cost[(i + j + 2) mod 3+1][k+1] := cost[(i + j + 2) mod 3+1][k+1]+(D[c[i+1][j+1] - 1+1][k - 1+1]) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
        var ia : int ; ia := 1 ; while ia <= C do ( (         var ib : int ; ib := 1 ; while ib <= C do ( (     if (ia = ib) then     continue else skip ; 
         var ic : int ; ic := 1 ; while ic <= C do ( (     if (ia = ic or ib = ic) then     continue else skip ; 
     var t : int ; t := cost[0+1][ia+1] + cost[1+1][ib+1] + cost[2+1][ic+1] ;
     if (t < min) then     min := t ; else skip )  ;     ic := ic + 1 ) )  ;     ib := ib + 1 ) )  ;     ia := ia + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    int x=sc.nextInt();
    if(500*k>=x)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (500 * k >= x) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String args[])throws IOException {
    final int F=500 ;
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    int k=Integer.parseInt(sa[0]);
    int x=Integer.parseInt(sa[1]);
    br.close();
    if(F*k>=x){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var F : int ; F := 500 ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var k : int ; k := (sa[0+1])->toInteger() ;
    var x : int ; x := (sa[1+1])->toInteger() ;
    skip ; 
    if (F * k >= x) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main implements Runnable {
  private static int MOD=1_000_000_007 ;
  public static void main(String[] args){
    Thread thread=new Thread(null,new Main(),"",32*1024*1024);
    thread.start();
  }
  @ Override public void run(){
    final Scanner scanner=new Scanner(System.in);
    solve(scanner);
  }
  static void solve(Scanner scanner){
    int K=Integer.parseInt(scanner.next());
    int X=Integer.parseInt(scanner.next());
    System.out.println(500*K>=X ? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
  static   attribute MOD : int := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var thread : OclProcess ; thread := OclProcess.newOclProcess(null, Main.newMain(), "", 32 * 1024 * 1024) ;
     thread.start() );
      operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute solve(scanner) );
  static   operation solve( scanner : OclFile) : void
  pre: true
  post: true
  activity: (     var K : int ; K := (scanner.getCurrent())->toInteger() ;
     var X : int ; X := (scanner.getCurrent())->toInteger() ;
     OclFile["System.out"].println(if 500 * K >= X then "Yes" else "No" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x=sc.nextInt();
    System.out.println(n*500>=x ? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if n * 500 >= x then "Yes" else "No" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    Scanner sc=new Scanner(System.in);
    int K=sc.nextInt();
    int X=sc.nextInt();
    System.out.println(500*K<X ? "No" : "Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var X : int ; X := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(if 500 * K < X then "No" else "Yes" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _622B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    int n=sc.nextInt();
    int h=getHour(s);
    int m=getMin(s);
    m+=n ;
    h+=m/60 ;
    m %=60 ;
    h %=24 ;
    System.out.println(((h<10)? "0" : "")+h+":"+((m<10)? "0" : "")+m);
  }
  static int getHour(String time){
    return toInt(time.substring(0,2));
  }
  static int getMin(String time){
    return toInt(time.substring(3));
  }
  static int toInt(String s){
    int ans=0 ;
    for(int i=0 ; i<s.length(); i++){
      ans=ans*10 ;
      ans+=s.charAt(i)-'0' ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class _622B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var h : int ; h := getHour(s) ;
    var m : int ; m := getMin(s) ;
    m := m+(n) ; 
    h := h+(m / 60) ; 
    m := m mod 60 ; 
    h := h mod 24 ; 
    OclFile["System.out"].println((if (h < 10) then "0" else "" endif) + h + ":" + (if (m < 10) then "0" else "" endif) + m) ; 
 );
  static   operation getHour( time : String) : int
  pre: true
  post: true
  activity: (     return toInt(time.subrange(0+1,2)) );
  static   operation getMin( time : String) : int
  pre: true
  post: true
  activity: (     return toInt(time.subrange(3+1,3)) );
  static   operation toInt( s : String) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     ans := ans * 10 ; 
     ans := ans+(s->at(i+1) - ('0')->char2byte()) )  ;     i := i + 1 ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class C {
  public static void main(String[] args){
    try(Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out)){
      int h1=in.nextInt();
      int a1=in.nextInt();
      int c1=in.nextInt();
      int h2=in.nextInt();
      int a2=in.nextInt();
      int hMe=h1 ;
      int hMonster=h2 ;
      List<String>actions=new ArrayList<>();
      while(hMonster>0){
        if(a1>=hMonster){
          hMonster-=a1 ;
          actions.add("STRIKE");
        }
        else {
          if(hMe>a2){
            hMonster-=a1 ;
            hMe-=a2 ;
            actions.add("STRIKE");
          }
          else {
            hMe+=c1 ;
            hMe-=a2 ;
            actions.add("HEAL");
          }
        }
      }
      out.println(actions.size());
      for(String action : actions){
        out.println(action);
      }
      out.flush();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]) ;
 (     var h1 : int ; h1 := in.getCurrent()->toInteger() ;
     var a1 : int ; a1 := in.getCurrent()->toInteger() ;
    var c1 : int ; c1 := in.getCurrent()->toInteger() ;
    var h2 : int ; h2 := in.getCurrent()->toInteger() ;
    var a2 : int ; a2 := in.getCurrent()->toInteger() ;
    var hMe : int ; hMe := h1 ;
    var hMonster : int ; hMonster := h2 ;
    var actions : Sequence(String) ; actions := Sequence{} ;
    while (hMonster > 0) do (     if (a1 >= hMonster) then (     hMonster := hMonster-(a1) ; 
     actions := actions->including("STRIKE") ) else (     if (hMe > a2) then (     hMonster := hMonster-(a1) ; 
     hMe := hMe-(a2) ; 
     actions := actions->including("STRIKE") ) else (     hMe := hMe+(c1) ; 
     hMe := hMe-(a2) ; 
     actions := actions->including("HEAL") ) ) ) ; 
    skip ; 
    for (action : actions) do ( (     skip )  ) ; 
    skip ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int m,n ;
  String[] FizzBuzz=new String[10000];
  void solve(){
    Scanner sc=new Scanner(System.in);
    getFizzBuzz();
    while(true){
      m=sc.nextInt();
      n=sc.nextInt();
      if(m==0 && n==0)break ;
      int[] player=new int[m];
      String[] s=new String[n];
      for(int i=0 ; i<n ; i++)s[i]=sc.next();
      int num=m ;
      int idx=0 ;
      for(int i=0 ; i<n ; i++){
        if(! s[i] .equals(FizzBuzz[i])){
          player[idx]=-1 ;
          num--;
        }
        if(num==1)break ;
        idx++;
        idx %=m ;
        while(player[idx]!=0){
          idx++;
          idx %=m ;
        }
      }
      idx=0 ;
      int[] ans=new int[num];
      for(int i=0 ; i<m ; i++){
        if(player[i]==0){
          ans[idx]=i+1 ;
          idx++;
        }
      }
      for(int i=0 ; i<num-1 ; i++)System.out.print(ans[i]+" ");
      System.out.println(ans[num-1]);
    }
  }
  void getFizzBuzz(){
    for(int i=1 ; i<=10000 ; i++){
      if(i % 3==0 && i % 5==0)FizzBuzz[i-1]="FizzBuzz" ;
      else if(i % 5==0)FizzBuzz[i-1]="Buzz" ;
      else if(i % 3==0)FizzBuzz[i-1]="Fizz" ;
      else FizzBuzz[i-1]=String.valueOf(i);
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute m : int;
   attribute FizzBuzz : Sequence(String) := Integer.subrange(1,10000)->collect(null);
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute getFizzBuzz() ; 
     while (true) do (     m := sc.getCurrent()->toInteger() ; 
     n := sc.getCurrent()->toInteger() ; 
    if (m = 0 & n = 0) then     break else skip ; 
    var player : Sequence(int) ; player := Integer.subrange(1,m)->collect(0) ;
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     s[i+1] := sc.getCurrent() ;  ;     i := i + 1 ) ; 
    var num : int ; num := m ;
    var idx : int ; idx := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (not(s[i+1] = FizzBuzz[i+1])) then (     player[idx+1] := -1 ; 
     num := num - 1 ) else skip ; 
     if (num = 1) then     break else skip ; 
    idx := idx + 1 ; 
    idx := idx mod m ; 
    while (player[idx+1] /= 0) do (     idx := idx + 1 ; 
     idx := idx mod m ) ; 
 )  ;     i := i + 1 ) ; 
    idx := 0 ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,num)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     if (player[i+1] = 0) then (     ans[idx+1] := i + 1 ; 
     idx := idx + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < num - 1 do (     OclFile["System.out"].print(ans[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans[num - 1+1]) ; 
 ) );
   operation getFizzBuzz() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= 10000 do ( (     if (i mod 3 = 0 & i mod 5 = 0) then     FizzBuzz[i - 1+1] := "FizzBuzz" ; else     if (i mod 5 = 0) then     FizzBuzz[i - 1+1] := "Buzz" else     if (i mod 3 = 0) then     FizzBuzz[i - 1+1] := "Fizz" else     FizzBuzz[i - 1+1] := ((i) + "") ; ;  ;  )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package code10.qualification ;
import java.io.File ;
import java.io.FileReader ;
import java.io.FileWriter ;
public class A {
  public static String solve(int N,long K,int[] times){
    String result="" ;
    int time=times[N];
    if(K<time){
      result="OFF" ;
    }
    else if(K==time){
      result="ON" ;
    }
    else {
      long remain=K-time ;
      if(remain %(time+1)==0){
        result="ON" ;
      }
      else {
        result="OFF" ;
      }
    }
    return result ;
  }
  public static void initTimes(int[] times){
    times[1]=1 ;
    for(int i=2 ; i<times.length ; i++){
      times[i]=times[i-1]*2+1 ;
    }
  }
  public static void main(String[] args)throws Exception {
    String fileName="A-large" ;
    File inputFile=new File(fileName+".in");
    File outputFile=new File(fileName+".out");
    FileReader reader=new FileReader(inputFile);
    FileWriter writer=new FileWriter(outputFile);
    StringBuilder inputLine=new StringBuilder();
    String[] inputPart ;
    int totalCase ;
    char c=0 ;
    int N=0 ;
    long K=0 ;
    int[] times=new int[31];
    initTimes(times);
    while((c=(char)reader.read())!='\n'){
      inputLine.append(c);
    }
    totalCase=Integer.parseInt(inputLine.toString());
    for(int caseIndex=1 ; caseIndex<=totalCase ; caseIndex++){
      inputLine=new StringBuilder();
      while((c=(char)reader.read())!='\n'){
        inputLine.append(c);
      }
      inputPart=inputLine.toString().split(" ");
      N=Integer.parseInt(inputPart[0]);
      K=Long.parseLong(inputPart[1]);
      String output="Case #"+caseIndex+": "+solve(N,K,times);
      System.out.println(output);
      writer.write(output+"\n");
    }
    reader.close();
    writer.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation solve( N : int, K : long, times : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var result : String ; result := "" ;
     var time : int ; time := times[N+1] ;
     if (K < time) then (     result := "OFF" ) else     if (K = time) then (     result := "ON" ) else (     var remain : long ; remain := K - (time)->char2byte() ;
     if (remain mod (time + 1) = 0) then (     result := "ON" ) else (     result := "OFF" ) ) ;  ;  
     return result );
  static   operation initTimes( times : Sequence(int)) : void
  pre: true
  post: true
  activity: (     times[1+1] := 1 ; 
         var i : int ; i := 2 ; while i < times->size() do ( (     times[i+1] := times[i - 1+1] * 2 + 1 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fileName : String ; fileName := "A-large" ;
     var inputFile : OclFile ; inputFile := OclFile(fileName + ".in") ;
    var outputFile : OclFile ; outputFile := OclFile(fileName + ".out") ;
    var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile(inputFile)) ;
    var writer : OclFile ; writer := OclFile.newOclFile_Write(outputFile) ;
    var inputLine : String ; inputLine := StringLib.newString() ;
    var inputPart : Sequence(String) ;
    var totalCase : int ;
    var c : String ; c := 0 ;
    var N : int ; N := 0 ;
    var K : long ; K := 0 ;
    var times : Sequence(int) ; times := Integer.subrange(1,31)->collect(0) ;
    execute initTimes(times) ; 
        c := reader.read()->oclAsType(String) ;
    while ((c) /= '
') do (    skip ; (     inputLine := inputLine + StringLib.newString(c) ) ;     c := reader.read()->oclAsType(String) ;
 ) ;  
    totalCase := (inputLine+"")->toInteger() ; 
        var caseIndex : int ; caseIndex := 1 ; while caseIndex <= totalCase do ( (     inputLine := StringLib.newString() ; 
         c := reader.read()->oclAsType(String) ;
    while ((c) /= '
') do (    skip ; (     inputLine := inputLine + StringLib.newString(c) ) ;     c := reader.read()->oclAsType(String) ;
 ) ;  
    inputPart := inputLine+""->split(" ") ; 
    N := (inputPart[0+1])->toInteger() ; 
    K := (inputPart[1+1])->toLong() ; 
    var output : String ; output := "Case #" + caseIndex + ": " + solve(N, K, times) ;
    OclFile["System.out"].println(output) ; 
    skip ; 
 )  ;     caseIndex := caseIndex + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.text.*;
public class SnapperChain {
  public PrintStream out=System.out ;
  public PrintStream err=System.err ;
  public Scanner in=new Scanner(System.in);
  public DecimalFormat fmt=new DecimalFormat("0.000000000");
  public void main(){
    try {
      int TCase,cc ;
      TCase=in.nextInt();
      for(cc=1 ; cc<=TCase ; ++cc){
        long n,K,L ;
        n=in.nextLong();
        K=in.nextLong();
        L=(1L<<n);
        out.println("Case #"+cc+": "+((K %(L)==(L)-1)? "ON" : "OFF"));
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  public int iInt(){
    return in.nextInt();
  }
  public long iLong(){
    return in.nextLong();
  }
  public String iToken(){
    return in.next();
  }
  public String iLine(){
    return in.nextLine();
  }
  public static void main(String[] args){
    long startTime=System.currentTimeMillis();
(new SnapperChain()).main();
    long endTime=System.currentTimeMillis();
    long ms=endTime-startTime ;
    long sec=ms/1000 ;
    ms=ms % 1000 ;
    long min=sec/60 ;
    sec=sec % 60 ;
    System.err.println("Time Spent: "+min+" minute(s)"+sec+" second(s)"+ms+"(ms)");
  }
}
------------------------------------------------------------
OCL File:
---------
 class SnapperChain {
   attribute out : OclFile := OclFile["System.out"];
   attribute err : OclFile := OclFile["System.err"];
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute fmt : DecimalFormat := DecimalFormat.newDecimalFormat("0.000000000");
   operation main() : void
  pre: true
  post: true
  activity: (     try (     var TCase : int ;
    var cc : int ;
     TCase := in.getCurrent()->toInteger() ; 
         cc := 1 ; while cc <= TCase do ( (     var n : long ;
    var K : long ;
    var L : long ;
     n := in.getCurrent()->toLong() ; 
    K := in.getCurrent()->toLong() ; 
    L := ((1L*(2->pow(n)))->oclAsType(long)) ; 
    skip ; 
 )  ;     cc := cc + 1 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
   operation iInt() : int
  pre: true
  post: true
  activity: (     return in.getCurrent()->toInteger() );
   operation iLong() : long
  pre: true
  post: true
  activity: (     return in.getCurrent()->toLong() );
   operation iToken() : String
  pre: true
  post: true
  activity: (     return in.getCurrent() );
   operation iLine() : String
  pre: true
  post: true
  activity: (     return in.nextLine() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var startTime : long ; startTime := OclDate.getSystemTime() ;
     (SnapperChain.newSnapperChain()).main() ; 
    var endTime : long ; endTime := OclDate.getSystemTime() ;
    var ms : long ; ms := endTime - startTime ;
    var sec : long ; sec := ms / 1000 ;
    ms := ms mod 1000 ; 
    var min : long ; min := sec / 60 ;
    sec := sec mod 60 ; 
    OclFile["System.err"].println("Time Spent: " + min + " minute(s)" + sec + " second(s)" + ms + "(ms)") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class AChain {
  public static void main(String[] args){
    if(args.length<1){
      System.out.println("Usage:<fnIn>");
    }
    String fn=args[0];
    String fnOut=toFnOut(fn);
    try {
      BufferedReader br=new BufferedReader(new FileReader(fn));
      BufferedWriter bw=new BufferedWriter(new FileWriter(fnOut));
      String line=null ;
      int NCase=Integer.valueOf(br.readLine().trim());
      long stime=System.currentTimeMillis();
      for(int icase=0 ; icase<NCase ; icase++){
        int[] a=toIntArray(br.readLine());
        String buf=process(a[0],a[1]);
        String out="Case #"+(icase+1)+": "+buf ;
        bw.write(out,0,out.length());
        bw.newLine();
        long ctime=System.currentTimeMillis();
        System.out.println(String.format("---Done: #%2d,%3.0fs,ends in:%2.1fm",(icase+1),(ctime-stime)*0.001,(ctime-stime)*0.001/60*NCase/(icase+1)));
      }
      br.close();
      bw.close();
    }
    catch(IOException ex){
      System.out.println(ex);
    }
  }
  static String process(int N,int K){
    int x=(1<<N);
    while(K>=x){
      K %=x ;
    }
    if(K==x-1)return "ON" ;
    return "OFF" ;
  }
  static int[] toIntArray(String line){
    String[] p=line.trim().split("\\s+");
    int[] out=new int[p.length];
    for(int i=0 ; i<out.length ; i++)out[i]=Integer.valueOf(p[i]);
    return out ;
  }
  static String toFnOut(String fn){
    if(fn.lastIndexOf('.')!=-1){
      return fn.substring(0,fn.lastIndexOf('.'))+".out" ;
    }
    else return fn+".out" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class AChain {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (args->size() < 1) then (     OclFile["System.out"].println("Usage:<fnIn>") ) else skip ; 
     var fn : String ; fn := args[0+1] ;
     var fnOut : String ; fnOut := toFnOut(fn) ;
     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(fn))) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile(fnOut))) ;
    var line : String ; line := null ;
    var NCase : int ; NCase := (br.readLine()->trim())->toInteger() ;
    var stime : long ; stime := OclDate.getSystemTime() ;
        var icase : int ; icase := 0 ; while icase < NCase do ( (     var a : Sequence(int) ; a := toIntArray(br.readLine()) ;
     var buf : String ; buf := process(a[0+1], a[1+1]) ;
    var out : String ; out := "Case #" + (icase + 1) + ": " + buf ;
    skip ; 
    skip ; 
    var ctime : long ; ctime := OclDate.getSystemTime() ;
    OclFile["System.out"].println(StringLib.format("---Done: #%2d,%3.0fs,ends in:%2.1fm",Sequence{(icase + 1),((ctime)->char2byte() - stime) * 0.001,((ctime)->char2byte() - stime) * 0.001 / 60 * NCase / (icase + 1)})) ; 
 )  ;     icase := icase + 1 ) ; 
    skip ; 
    skip ; 
 )   catch (ex : IOException) do (     OclFile["System.out"].println(ex) )
 );
  static   operation process( N : int, K : int) : String
  pre: true
  post: true
  activity: (     var x : int ; x := ((1*(2->pow(N)))->oclAsType(long)) ;
     while (K >= x) do (     K := K mod x ) ; 
     if (K = x - 1) then     return "ON" else skip ; 
     return "OFF" );
  static   operation toIntArray( line : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var p : Sequence(String) ; p := line->trim()->split("\\s+") ;
     var out : Sequence(int) ; out := Integer.subrange(1,p->size())->collect(0) ;
         var i : int ; i := 0 ; while i < out->size() do (     out[i+1] := (p[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
     return out );
  static   operation toFnOut( fn : String) : String
  pre: true
  post: true
  activity: (     if (fn->lastIndexOf('.')-1 /= -1) then (     return fn.subrange(0+1,fn->lastIndexOf('.')-1) + ".out" ) else     return fn + ".out" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package codejam2010.qualification ;
import java.io.BufferedReader ;
import java.io.Closeable ;
import java.io.File ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.PrintWriter ;
public class ProblemA {
  public static void main(String[] args){
    BufferedReader reader=null ;
    PrintWriter writer=null ;
    try {
      String fileName="A-large" ;
      File folder=new File(new File("files","codejam2010"),"qualification");
      File inputFile=new File(folder,fileName+".in");
      File outputFile=new File(folder,fileName+".out");
      reader=new BufferedReader(new FileReader(inputFile));
      writer=new PrintWriter(new FileWriter(outputFile));
      int count=Integer.parseInt(reader.readLine());
      for(int i=0 ; i<count ; i++){
        String[] parameters=reader.readLine().split("\\s");
        writer.printf("Case #%d: %s\n",i+1,solveIt(Integer.parseInt(parameters[0]),Integer.parseInt(parameters[1])));
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
    finally {
      close(reader);
      close(writer);
    }
    System.out.println("Done.");
  }
  private static String solveIt(int n,int k){
    int allOn=(1<<n)-1 ;
    return((allOn & k)==allOn)? "ON" : "OFF" ;
  }
  private static void close(Closeable file){
    if(file!=null){
      try {
        file.close();
      }
      catch(IOException e){
        e.printStackTrace();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := null ;
     var writer : OclFile ; writer := null ;
     try (     var fileName : String ; fileName := "A-large" ;
     var folder : OclFile ; folder := OclFile(OclFile("files", "codejam2010"), "qualification") ;
    var inputFile : OclFile ; inputFile := OclFile(folder, fileName + ".in") ;
    var outputFile : OclFile ; outputFile := OclFile(folder, fileName + ".out") ;
    reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputFile)) ; 
    writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputFile)) ; 
    var count : int ; count := (reader.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < count do ( (     var parameters : Sequence(String) ; parameters := reader.readLine()->split("\\s") ;
     skip )  ;     i := i + 1 ) ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
   finally (     execute close(reader) ; 
     execute close(writer) )
     OclFile["System.out"].println("Done.") );
  static   operation solveIt( n : int, k : int) : String
  pre: true
  post: true
  activity: (     var allOn : int ; allOn := ((1*(2->pow(n)))->oclAsType(long)) - 1 ;
     return if ((MathLib.bitwiseAnd(allOn,k)) = allOn) then "ON" else "OFF" endif );
  static   operation close( file : Closeable) : void
  pre: true
  post: true
  activity: (     if (file /= null) then (     try (     file.close() )   catch (e : IOException) do (     e.printStackTrace() )
 ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class A extends SolutionT {
  public static void main(String[] args){
(new A()).run();
  }
  @ Override void runOneTest(Scanner input,PrintWriter output){
    int n=input.nextInt();
    int k=input.nextInt();
    k=k %(1<<n);
    if((k+1)==(1<<n)){
      output.println("ON");
    }
    else {
      output.println("OFF");
    }
  }
}
abstract class Solution implements Runnable {
  abstract void runOneTest(Scanner input,PrintWriter output);
  public void run(){
    Scanner input=null ;
    PrintWriter output=null ;
    try {
      input=new Scanner(new File("input.txt"));
      output=new PrintWriter(new File("output.txt"));
    }
    catch(FileNotFoundException e){
    }
    int testCount=input.nextInt();
    for(int test=1 ; test<=testCount ; test++){
      output.print("Case #"+test+": ");
      runOneTest(input,output);
    }
    input.close();
    output.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A extends SolutionT {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (A.newA()).run() );
     operation runOneTest( input : OclFile, output : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := input.nextInt() ;
     var k : int ; k := input.nextInt() ;
     k := k mod ((1*(2->pow(n)))->oclAsType(long)) ; 
     if ((k + 1) = ((1*(2->pow(n)))->oclAsType(long))) then (     output.println("ON") ) else (     output.println("OFF") ) );
}
class Solution implements Runnable {
     operation runOneTest( input : OclFile, output : OclFile) : void
  pre: true
  post: true;
   operation run() : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := null ;
     var output : OclFile ; output := null ;
    try (     input := OclFile.newOclFile_Read(OclFile("input.txt")) ; 
     output := OclFile.newOclFile_Write(OclFile("output.txt")) )   catch (e : FileNotFoundException) do skip
    var testCount : int ; testCount := input.getCurrent()->toInteger() ;
        var test : int ; test := 1 ; while test <= testCount do ( (     skip ; 
     execute runOneTest(input, output) )  ;     test := test + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int count_odd_pair(int n,int a[]){
    int odd=0,even=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i] % 2==0)even++;
      else odd++;
    }
    int ans=odd*(odd-1);
    return ans ;
  }
  static int count_even_pair(int odd_product_pairs,int n){
    int total_pairs=(n*(n-1));
    int ans=total_pairs-odd_product_pairs ;
    return ans ;
  }
  public static void main(String[] args){
    int n=6 ;
    int[] a={
      2,4,5,9,1,8 };
      int odd_product_pairs=count_odd_pair(n,a);
      int even_product_pairs=count_even_pair(odd_product_pairs,n);
      System.out.println("Even Product Pairs="+even_product_pairs);
      System.out.println("Odd Product Pairs="+odd_product_pairs);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count_odd_pair( n : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var odd : int ; odd := 0 ;
    var even : int ; even := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] mod 2 = 0) then     even := even + 1 ; else     odd := odd + 1 ; )  ;     i := i + 1 ) ; 
     var ans : int ; ans := odd * (odd - 1) ;
     return ans );
  static   operation count_even_pair( odd_product_pairs : int, n : int) : int
  pre: true
  post: true
  activity: (     var total_pairs : int ; total_pairs := (n * (n - 1)) ;
     var ans : int ; ans := total_pairs - odd_product_pairs ;
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     var a : Sequence(int) ; a := Sequence{2,4,5,9,1,8} ;
    var odd_product_pairs : int ; odd_product_pairs := count_odd_pair(n, a) ;
    var even_product_pairs : int ; even_product_pairs := count_even_pair(odd_product_pairs, n) ;
    OclFile["System.out"].println("Even Product Pairs=" + even_product_pairs) ; 
    OclFile["System.out"].println("Odd Product Pairs=" + odd_product_pairs) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countsubarray(int array[],int n,int k){
    int count=0 ;
    int i,j,mul ;
    for(i=0 ; i<n ; i++){
      if(array[i]<=k)count++;
      mul=array[i];
      for(j=i+1 ; j<n ; j++){
        mul=mul*array[j];
        if(mul<=k)count++;
        else break ;
      }
    }
    return count ;
  }
  public static void main(String args[]){
    int array[]={
      1,2,3,4 };
      int k=10 ;
      int size=array.length ;
      int count=countsubarray(array,size,k);
      System.out.print(count);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countsubarray( array : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var i : int ;
    var j : int ;
    var mul : int ;
         i := 0 ; while i < n do ( (     if (array[i+1] <= k) then     count := count + 1 ; else skip ; 
     mul := array[i+1] ; 
         j := i + 1 ; while j < n do ( (     mul := mul * array[j+1] ; 
     if (mul <= k) then     count := count + 1 ; else     break )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Sequence{1,2,3,4} ;
     var k : int ; k := 10 ;
    var size : int ; size := array->size() ;
    var count : int ; count := countsubarray(array, size, k) ;
    OclFile["System.out"].print(count) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int setBitNumber(int n){
    n |=n>>1 ;
    n |=n>>2 ;
    n |=n>>4 ;
    n |=n>>8 ;
    n |=n>>16 ;
    n=n+1 ;
    return(n>>1);
  }
  public static void main(String arg[]){
    int n=273 ;
    System.out.print(setBitNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation setBitNumber( n : int) : int
  pre: true
  post: true
  activity: (     n := MathLib.bitwiseOr(n, (n/(2->pow(1)))->oclAsType(long)) ; 
     n := MathLib.bitwiseOr(n, (n/(2->pow(2)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(4)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(8)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(16)))->oclAsType(long)) ; 
    n := n + 1 ; 
    return ((n/(2->pow(1)))->oclAsType(long)) 
 );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 273 ;
     OclFile["System.out"].print(setBitNumber(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static PrintWriter out=new PrintWriter((System.out));
  public static void main(String args[])throws IOException {
    Reader sc=new Reader();
    String s=sc.next();
    if(s.equals("ABC")){
      out.println("ARC");
    }
    else {
      out.println("ABC");
    }
    out.close();
  }
  public static void solve(){
  }
  static class Reader {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(Exception e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return br.readLine();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return null ;
    }
    public boolean hasNext(){
      String next=null ;
      try {
        next=br.readLine();
      }
      catch(Exception e){
      }
      if(next==null){
        return false ;
      }
      st=new StringTokenizer(next);
      return true ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write((OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile() ;
     var s : String ; s := sc.getCurrent() ;
     if (s = "ABC") then (     skip ) else (     skip ) ;  
     skip );
  static   operation solve() : void
  pre: true
  post: true
  activity: skip;
  static class Reader {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return null );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     var next : String ; next := null ;
     try (     next := br.readLine() )   catch (e : ProgramException) do skip
    if (next = null) then (     return false ) else skip ; 
    st := OclIterator.newOclIterator_String(next) ; 
    return true 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    if("ABC".equals(str[0])){
      System.out.println("ARC");
    }
    else {
      System.out.println("ABC");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     if ("ABC" = str[0+1]) then (     OclFile["System.out"].println("ARC") ) else (     OclFile["System.out"].println("ABC") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.util.*;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String line ;
      line=in.readLine();
      int m,n ;
      m=Integer.parseInt(line.substring(0,line.indexOf(" ")));
      n=Integer.parseInt(line.substring(line.indexOf(" ")+1));
      if(n+m==0)break ;
      LinkedList<Integer>list=new LinkedList<Integer>();
      for(int i=1 ; i<=m ; i++)list.addLast(i);
      int pos=0 ;
      for(int i=1 ; i<=n ; i++){
        line=in.readLine();
        if(list.size()<=1)continue ;
        if(i % 3==0 || i % 5==0){
          boolean ok=true ;
          if(i % 3==0 && i % 5==0){
            if(! line.equals("FizzBuzz"))ok=false ;
          }
          else if(i % 3==0){
            if(! line.equals("Fizz"))ok=false ;
          }
          else {
            if(! line.equals("Buzz"))ok=false ;
          }
          if(! ok){
            list.remove(pos);
            pos--;
          }
        }
        else {
          String eq=String.valueOf(i);
          if(! eq.equals(line)){
            list.remove(pos);
            pos--;
          }
        }
        pos++;
        if(pos>=list.size())pos=0 ;
      }
      for(int i=0 ; i<list.size(); i++){
        System.out.print(list.get(i));
        if(i!=list.size()-1)System.out.print(" ");
      }
      System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var line : String ;
     line := in.readLine() ; 
    var m : int ;
    var n : int ;
    m := (line.subrange(0+1,line->indexOf(" ")-1))->toInteger() ; 
    n := (line.subrange(line->indexOf(" ")-1 + 1+1,line->indexOf(" ")-1 + 1))->toInteger() ; 
    if (n + m = 0) then     break else skip ; 
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 1 ; while i <= m do (     list := list->append(i) ;  ;     i := i + 1 ) ; 
    var pos : int ; pos := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     line := in.readLine() ; 
     if (list->size() <= 1) then     continue else skip ; 
    if (i mod 3 = 0 or i mod 5 = 0) then (     var ok : boolean ; ok := true ;
     if (i mod 3 = 0 & i mod 5 = 0) then (     if (not(line = "FizzBuzz")) then     ok := false ; else skip ) else     if (i mod 3 = 0) then (     if (not(line = "Fizz")) then     ok := false ; else skip ) else (     if (not(line = "Buzz")) then     ok := false ; else skip ) ;  ;  
     if (not(ok)) then (     list := list->excludingAt(pos+1) ; 
     pos := pos - 1 ) else skip ) else (     var eq : String ; eq := ((i) + "") ;
     if (not(eq = line)) then (     list := list->excludingAt(pos+1) ; 
     pos := pos - 1 ) else skip ) ;  
    pos := pos + 1 ; 
    if (pos >= list->size()) then     pos := 0 ; else skip ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < list->size() do ( (     OclFile["System.out"].print(list->at(i+1)) ; 
     if (i /= list->size() - 1) then     OclFile["System.out"].print(" ") ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String time=scanner.nextLine();
    int minutes=scanner.nextInt();
    int hrs=minutes/60 ;
    int min=minutes % 60 ;
    hrs=hrs % 24 ;
    String[] currentTime=time.split("\\:");
    int h=Integer.valueOf(currentTime[0]);
    int m=Integer.valueOf(currentTime[1]);
    if(min+m>=60){
      m=(min+m)% 60 ;
      h++;
    }
    else m+=min ;
    if(h+hrs>=24){
      h=(h+hrs)% 24 ;
    }
    else h+=hrs ;
    String g="" ;
    String f="" ;
    if(h<10){
      g="0" ;
    }
    if(m<10){
      f="0" ;
    }
    System.out.println(g+h+":"+f+m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var time : String ; time := scanner.nextLine() ;
    var minutes : int ; minutes := scanner.getCurrent()->toInteger() ;
    var hrs : int ; hrs := minutes / 60 ;
    var min : int ; min := minutes mod 60 ;
    hrs := hrs mod 24 ; 
    var currentTime : Sequence(String) ; currentTime := time->split("\\:") ;
    var h : int ; h := (currentTime[0+1])->toInteger() ;
    var m : int ; m := (currentTime[1+1])->toInteger() ;
    if (min + m >= 60) then (     m := (min + m) mod 60 ; 
     h := h + 1 ) else     m := m+(min) ; ;  
    if (h + hrs >= 24) then (     h := (h + hrs) mod 24 ) else     h := h+(hrs) ; ;  
    var g : String ; g := "" ;
    var f : String ; f := "" ;
    if (h < 10) then (     g := "0" ) else skip ; 
    if (m < 10) then (     f := "0" ) else skip ; 
    OclFile["System.out"].println(g + h + ":" + f + m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    String s=sc.next();
    if(s.equals("ABC"))System.out.println("ARC");
    else System.out.println("ABC");
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(String file)throws FileNotFoundException {
      br=new BufferedReader(new FileReader(file));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
    public int[] nextArr(int n)throws IOException {
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=nextInt();
      return arr ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var s : String ; s := sc.getCurrent() ;
     if (s = "ABC") then     OclFile["System.out"].println("ARC") ; else     OclFile["System.out"].println("ABC") ; );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(s))) );
   static operation newScanner( file : String) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
   operation nextArr( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     arr[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return arr );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.System.*;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  static void solve()throws Exception {
    String S=scanString();
    if(S.equals("ABC")){
      out.print("ARC");
    }
    else {
      out.print("ABC");
    }
  }
  static int scanInt()throws IOException {
    return parseInt(scanString());
  }
  static long scanLong()throws IOException {
    return parseLong(scanString());
  }
  static String scanString()throws IOException {
    while(tok==null || ! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  public static void main(String[] args){
    try {
      in=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(System.out);
      solve();
      in.close();
      out.close();
    }
    catch(Throwable e){
      e.printStackTrace();
      exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var S : String ; S := scanString() ;
     if (S = "ABC") then (     out.print("ARC") ) else (     out.print("ABC") ) );
  static   operation scanInt() : int
  pre: true
  post: true
  activity: (     return (scanString() + "")->toInteger() );
  static   operation scanLong() : long
  pre: true
  post: true
  activity: (     return parseLong(scanString()) );
  static   operation scanString() : String
  pre: true
  post: true
  activity: (     while (tok = null or not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return tok.next() );
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
     execute exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int gcd(int a,int b){
    return b>0 ? gcd(b,a % b): a ;
  }
  static int mod=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    if(S.equals("ARC")){
      System.out.println("ABC");
    }
    else {
      System.out.println("ARC");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b > 0 then gcd(b, a mod b) else a endif );
  static   attribute mod : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
     if (S = "ARC") then (     OclFile["System.out"].println("ABC") ) else (     OclFile["System.out"].println("ARC") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static int sumOfDigitsFrom1ToN(int n){
    if(n<10)return(n*(n+1)/2);
    int d=(int)(Math.log10(n));
    int a[]=new int[d+1];
    a[0]=0 ;
    a[1]=45 ;
    for(int i=2 ; i<=d ; i++)a[i]=a[i-1]*10+45*(int)(Math.ceil(Math.pow(10,i-1)));
    int p=(int)(Math.ceil(Math.pow(10,d)));
    int msd=n/p ;
    return(msd*a[d]+(msd*(msd-1)/2)*p+msd*(1+n % p)+sumOfDigitsFrom1ToN(n % p));
  }
  public static void main(String args[]){
    int n=328 ;
    System.out.println("Sum of digits in numbers "+"from 1 to "+n+" is "+sumOfDigitsFrom1ToN(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfDigitsFrom1ToN( n : int) : int
  pre: true
  post: true
  activity: (     if (n < 10) then     return (n * (n + 1) / 2) else skip ; 
     var d : int ; d := ((n)->log10())->oclAsType(int) ;
    var a : Sequence(int) ; a := Integer.subrange(1,d + 1)->collect(0) ;
    a[0+1] := 0 ; 
    a[1+1] := 45 ; 
        var i : int ; i := 2 ; while i <= d do (     a[i+1] := a[i - 1+1] * 10 + 45 * ((10->pow(i - 1))->ceil())->oclAsType(int) ;  ;     i := i + 1 ) ; 
    var p : int ; p := ((10->pow(d))->ceil())->oclAsType(int) ;
    var msd : int ; msd := n / p ;
    return (msd * a[d+1] + (msd * (msd - 1) / 2) * p + msd * (1 + n mod p) + sumOfDigitsFrom1ToN(n mod p)) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 328 ;
     OclFile["System.out"].println("Sum of digits in numbers " + "from 1 to " + n + " is " + sumOfDigitsFrom1ToN(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    for(int i=0 ; i<Math.pow(2,n); i++){
      int bitArray[]=new int[n];
      int temp=i ;
      int count=0 ;
      for(int j=0 ; temp>0 ; j++){
        if(temp % 2==1){
          bitArray[j]=1 ;
          count++;
        }
        temp/=2 ;
      }
      if(count==k){
        System.out.print(i+":");
        for(int j=0 ; j<n ; j++){
          if(bitArray[j]==1)System.out.print(" "+j);
        }
      }
      if(count==k)System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < 2->pow(n) do ( (     var bitArray : Sequence(int) ; bitArray := Integer.subrange(1,n)->collect(0) ;
     var temp : int ; temp := i ;
    var count : int ; count := 0 ;
        var j : int ; j := 0 ; while temp > 0 do ( (     if (temp mod 2 = 1) then (     bitArray[j+1] := 1 ; 
     count := count + 1 ) else skip ; 
     temp := temp/(2) )  ;     j := j + 1 ) ; 
    if (count = k) then (     OclFile["System.out"].print(i + ":") ; 
         var j : int ; j := 0 ; while j < n do ( (     if (bitArray[j+1] = 1) then     OclFile["System.out"].print(" " + j) ; else skip )  ;     j := j + 1 ) ) else skip ; 
    if (count = k) then     OclFile["System.out"].println() ; else skip ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      int k=sc.nextInt();
      for(int bit=1 ; bit<(1<<n); bit++){
        if(isTrueNum(bit,k)){
          System.out.print(bit+":");
          for(int j=0 ; j<n ; j++){
            if(((bit>>j)& 1)==1){
              System.out.print(" "+j);
            }
          }
          System.out.println();
        }
      }
    }
  }
  public static boolean isTrueNum(int flags,int num){
    int cnt=0 ;
    for(int j=0 ; j<32 ; j++){
      if((flags>>j & 1)>0)cnt++;
    }
    return num==cnt ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
         var bit : int ; bit := 1 ; while bit < ((1*(2->pow(n)))->oclAsType(long)) do ( (     if (isTrueNum(bit, k)) then (     OclFile["System.out"].print(bit + ":") ; 
         var j : int ; j := 0 ; while j < n do ( (     if ((((bit/(2->pow(j)))->oclAsType(long)) & 1) = 1) then (     OclFile["System.out"].print(" " + j) ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() ) else skip )  ;     bit := bit + 1 ) ))  );
  static   operation isTrueNum( flags : int, num : int) : boolean
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var j : int ; j := 0 ; while j < 32 do ( (     if ((MathLib.bitwiseAnd((flags/(2->pow(j)))->oclAsType(long),1)) > 0) then     cnt := cnt + 1 ; else skip )  ;     j := j + 1 ) ; 
     return num = cnt );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      int choice=sc.nextInt();
      int max=(int)Math.pow(2,n)-1 ;
      for(int i=1 ; i<=max ; i++){
        ArrayList<Integer>ans=new ArrayList<Integer>();
        ans.clear();
        String binary=Integer.toBinaryString(i);
        for(int j=0 ; j<binary.length(); j++){
          char c=binary.charAt(binary.length()-j-1);
          if(c=='1'){
            ans.add(j);
          }
        }
        if(ans.size()==choice){
          System.out.print(i+":");
          for(int j=0 ; j<ans.size(); j++)System.out.print(" "+ans.get(j));
          System.out.print('\n');
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var choice : int ; choice := sc.getCurrent()->toInteger() ;
     var max : int ; max := 2->pow(n)->oclAsType(int) - 1 ;
         var i : int ; i := 1 ; while i <= max do ( (     var ans : Sequence(int) ; ans := Sequence{} ;
     ans := ans->intersection(Set{}) ; 
    var binary : String ; binary := (MathLib.decimal2binary(i) + "") ;
        var j : int ; j := 0 ; while j < binary->size() do ( (     var c : String ; c := binary->at(binary->size() - (j)->char2byte() - 1+1) ;
     if (c = '1') then (     ans := ans->including(j) ) else skip )  ;     j := j + 1 ) ; 
    if (ans->size() = choice) then (     OclFile["System.out"].print(i + ":") ; 
         var j : int ; j := 0 ; while j < ans->size() do (     OclFile["System.out"].print(" " + ans->at(j+1)) ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].print('
') ) else skip ; 
 )  ;     i := i + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static List<binarySet>ls=new ArrayList<>();
  static char[] U ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),k=in.nextInt();
    U=new char[n];
    Arrays.fill(U,'0');
    solveSet(new ArrayList<Integer>(),n,k);
    ls.sort(Comparator.comparingInt(binarySet :: getDecimal));
    PrintWriter out=new PrintWriter(System.out);
    for(int i=0 ; i<ls.size(); i++){
      List<Integer>A=ls.get(i).ls ;
      out.print(ls.get(i).dec+":");
      for(int j=0 ; j<A.size(); j++)out.print(" "+A.get(j));
      out.println();
      out.flush();
    }
    out.flush();
  }
  static void solveSet(List<Integer>A,int n,int k){
    if(A.size()==k){
      ls.add(new binarySet(A,U));
      return ;
    }
    for(int i=0 ; i<n ; i++){
      if(A.isEmpty()|| i>A.get(A.size()-1)){
        List<Integer>t=new ArrayList<>(A);
        t.add(i);
        solveSet(t,n,k);
      }
    }
  }
}
class binarySet {
  List<Integer>ls ;
  int dec ;
  binarySet(List<Integer>A,char[] c){
    ls=A ;
    char[] t=c.clone();
    for(int i=0 ; i<ls.size(); i++){
      t[c.length-1-A.get(i)]='1' ;
    }
    dec=Integer.parseInt(String.valueOf(t),2);
  }
  int getDecimal(){
    return dec ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ls : Sequence(binarySet) := Sequence{};
  static   attribute U : Sequence(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    U := Integer.subrange(1,n)->collect(0) ; 
    U := U->collect('0') ; 
    execute solveSet(Sequence{}, n, k) ; 
    ls := ls.sort(Comparator.comparingInt(lambda _pars : OclAny in binarySet.newbinarySet().getDecimal(_pars))) ; 
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
        var i : int ; i := 0 ; while i < ls->size() do ( (     var A : Sequence(int) ; A := ls->at(i+1).ls ;
     skip ; 
        var j : int ; j := 0 ; while j < A->size() do (     skip ;  ;     j := j + 1 ) ; 
    skip ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation solveSet( A : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     if (A->size() = k) then (     ls := ls->including(binarySet.newbinarySet(A, U)) ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     if (A->isEmpty() or i > A->at(A->size() - 1+1)) then (     var t : Sequence(int) ; t := Sequence{}->union(A) ;
     t := t->including(i) ; 
     execute solveSet(t, n, k) ) else skip )  ;     i := i + 1 ) );
}
class binarySet {
   attribute ls : Sequence(int);
   attribute dec : int;
   static operation newbinarySet( A : Sequence(int), c : Sequence(String)) : binarySet
  pre: true
  post: true
  activity:
  ( var self : binarySet ;
    self := createbinarySet();
    self.initialise(A, c);
    return self );
  operation initialise( A : Sequence(int), c : Sequence(String)) : void
  pre: true  post: true
  activity: (     ls := A ; 
     var t : Sequence(String) ; t := c->copy() ;
         var i : int ; i := 0 ; while i < ls->size() do ( (     t[c->size() - 1 - A->at(i+1)+1] := '1' )  ;     i := i + 1 ) ; 
     dec := ((t)->sum() )->toInteger() );
   operation getDecimal() : int
  pre: true
  post: true
  activity: (     return dec );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    String[] str=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int k=Integer.parseInt(str[1]);
    for(int i=0 ; i<(1<<n); i++){
      int sum=0 ;
      int pow2=1 ;
      int cnt=0 ;
      ArrayList<Integer>a=new ArrayList<Integer>();
      for(int j=0 ; j<n ; j++){
        if((i &(1<<j))!=0){
          sum+=pow2 ;
          a.add(j);
          cnt++;
        }
        pow2*=2 ;
      }
      if(cnt!=k)continue ;
      pw.print(sum+":");
      if(i>0)pw.print(" ");
      for(int j=0 ; j<a.size(); j++){
        pw.print(a.get(j));
        if(j!=a.size()-1)pw.print(" ");
      }
      pw.print("\n");
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var k : int ; k := (str[1+1])->toInteger() ;
        var i : int ; i := 0 ; while i < ((1*(2->pow(n)))->oclAsType(long)) do ( (     var sum : int ; sum := 0 ;
     var pow2 : int ; pow2 := 1 ;
    var cnt : int ; cnt := 0 ;
    var a : Sequence(int) ; a := Sequence{} ;
        var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd(i,((1*(2->pow(j)))->oclAsType(long)))) /= 0) then (     sum := sum+(pow2) ; 
     a := a->including(j) ; 
     cnt := cnt + 1 ) else skip ; 
     pow2 := pow2*(2) )  ;     j := j + 1 ) ; 
    if (cnt /= k) then     continue else skip ; 
    skip ; 
    if (i > 0) then     skip ; else skip ; 
        var j : int ; j := 0 ; while j < a->size() do ( (     skip ; 
     if (j /= a->size() - 1) then     skip ; else skip )  ;     j := j + 1 ) ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    String[] fiz=new String[10001];
    for(int i=1 ; i<=10000 ; i++){
      if(i % 15==0)fiz[i]="FizzBuzz" ;
      else if(i % 5==0)fiz[i]="Buzz" ;
      else if(i % 3==0)fiz[i]="Fizz" ;
      else fiz[i]=String.valueOf(i);
    }
    while(true){
      int m=scanner.nextInt();
      int n=scanner.nextInt();
      if((m | n)==0)break ;
      List<Integer>list=new LinkedList<Integer>();
      for(int i=1 ; i<=m ; i++){
        list.add(i);
      }
      int pos=0 ;
      for(int i=1 ; i<=n ; i++){
        String str=scanner.next();
        if(list.size()==1)continue ;
        if(! str.equals(fiz[i])){
          list.remove(pos);
          pos--;
        }
        pos=pos==list.size()-1 ? 0 : pos+1 ;
      }
      for(int i=0 ; i<list.size(); i++){
        System.out.print(list.get(i));
        System.out.print(i==list.size()-1 ? '\n' : ' ');
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var fiz : Sequence(String) ; fiz := Integer.subrange(1,10001)->collect(null) ;
         var i : int ; i := 1 ; while i <= 10000 do ( (     if (i mod 15 = 0) then     fiz[i+1] := "FizzBuzz" ; else     if (i mod 5 = 0) then     fiz[i+1] := "Buzz" else     if (i mod 3 = 0) then     fiz[i+1] := "Fizz" else     fiz[i+1] := ((i) + "") ; ;  ;  )  ;     i := i + 1 ) ; 
     while (true) do (     var m : int ; m := scanner.getCurrent()->toInteger() ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(m,n)) = 0) then     break else skip ; 
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 1 ; while i <= m do ( (     list := list->including(i) )  ;     i := i + 1 ) ; 
    var pos : int ; pos := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var str : String ; str := scanner.getCurrent() ;
     if (list->size() = 1) then     continue else skip ; 
     if (not(str = fiz[i+1])) then (     list := list->excludingAt(pos+1) ; 
     pos := pos - 1 ) else skip ; 
     pos := if pos = list->size() - 1 then 0 else pos + 1 endif )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < list->size() do ( (     OclFile["System.out"].print(list->at(i+1)) ; 
     OclFile["System.out"].print(if i = list->size() - 1 then '
' else ' ' endif) )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int[] line=new int[w];
    Arrays.fill(line,Integer.MAX_VALUE);
    int max=0 ;
    for(int i=0 ; i<h ; i++){
      char[] arr=sc.next().toCharArray();
      for(int j=0 ; j<w ; j++){
        if(arr[j]=='.'){
          continue ;
        }
        for(int k=0 ; k<w ; k++){
          if(line[k]!=Integer.MAX_VALUE){
            max=Math.max(max,Math.abs(j-k)+i-line[k]);
          }
        }
        if(line[j]==Integer.MAX_VALUE){
          line[j]=i ;
        }
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var line : Sequence(int) ; line := Integer.subrange(1,w)->collect(0) ;
    line := line->collect(2147483647) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < h do ( (     var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
         var j : int ; j := 0 ; while j < w do ( (     if (arr[j+1] = '.') then (     continue ) else skip ; 
         var k : int ; k := 0 ; while k < w do ( (     if (line[k+1] /= 2147483647) then (     max := Set{max, if j - k < 0 then -(j - k) else j - k endif + i - line[k+1]}->max() ) else skip )  ;     k := k + 1 ) ; 
     if (line[j+1] = 2147483647) then (     line[j+1] := i ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class TheTime {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(":");
    int hour=Integer.parseInt(str[0]);
    int minute=Integer.parseInt(str[1]);
    int offset=Integer.parseInt(br.readLine());
    printTime(getMinute(hour,minute)+offset);
  }
  static long getMinute(int hout,int minute){
    return 60*hout+minute ;
  }
  static void printTime(long minute){
    long min=minute % 60 ;
    long h=((minute-min)/60)% 24 ;
    String s="" ;
    if(h<10){
      s="0"+h+":" ;
    }
    else {
      s=h+":" ;
    }
    if(min<10){
      s=s+"0"+min ;
    }
    else {
      s=s+min ;
    }
    System.out.print(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class TheTime {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(":") ;
    var hour : int ; hour := (str[0+1])->toInteger() ;
    var minute : int ; minute := (str[1+1])->toInteger() ;
    var offset : int ; offset := (br.readLine())->toInteger() ;
    execute printTime(getMinute(hour, minute) + offset) ; 
 );
  static   operation getMinute( hout : int, minute : int) : long
  pre: true
  post: true
  activity: (     return 60 * hout + minute );
  static   operation printTime( minute : long) : void
  pre: true
  post: true
  activity: (     var min : long ; min := minute mod 60 ;
     var h : long ; h := ((minute - min) / 60) mod 24 ;
    var s : String ; s := "" ;
    if (h < 10) then (     s := "0" + h + ":" ) else (     s := h + ":" ) ;  
    if (min < 10) then (     s := s + "0" + min ) else (     s := s + min ) ;  
    OclFile["System.out"].print(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int H=sc.nextInt();
    int W=sc.nextInt();
    int[] left=new int[H];
    int[] right=new int[H];
    Arrays.fill(left,-1);
    Arrays.fill(right,-1);
    for(int i=0 ; i<H ; i++){
      char[] row=sc.next().toCharArray();
      for(int j=0 ; j<W ; j++){
        if(row[j]=='B'){
          if(left[i]==-1)left[i]=j ;
          right[i]=j ;
        }
      }
    }
    int ans=0 ;
    for(int i=0 ; i<H ; i++){
      if(left[i]==-1)continue ;
      for(int j=i ; j<H ; j++){
        if(left[j]==-1)continue ;
        ans=Math.max(ans,j-i+Math.abs(left[i]-right[j]));
        ans=Math.max(ans,j-i+Math.abs(right[i]-left[j]));
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var H : int ; H := sc.getCurrent()->toInteger() ;
     var W : int ; W := sc.getCurrent()->toInteger() ;
    var left : Sequence(int) ; left := Integer.subrange(1,H)->collect(0) ;
    var right : Sequence(int) ; right := Integer.subrange(1,H)->collect(0) ;
    left := left->collect(-1) ; 
    right := right->collect(-1) ; 
        var i : int ; i := 0 ; while i < H do ( (     var row : Sequence(String) ; row := sc.getCurrent()->characters() ;
         var j : int ; j := 0 ; while j < W do ( (     if (row[j+1] = 'B') then (     if (left[i+1] = -1) then     left[i+1] := j ; else skip ; 
     right[i+1] := j ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < H do ( (     if (left[i+1] = -1) then     continue else skip ; 
         var j : int ; j := i ; while j < H do ( (     if (left[j+1] = -1) then     continue else skip ; 
     ans := Set{ans, j - i + if left[i+1] - right[j+1] < 0 then -(left[i+1] - right[j+1]) else left[i+1] - right[j+1] endif}->max() ; 
     ans := Set{ans, j - i + if right[i+1] - left[j+1] < 0 then -(right[i+1] - left[j+1]) else right[i+1] - left[j+1] endif}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean isDivisiblePalindrome(int n){
    int hash[]=new int[10];
    int digitSum=0 ;
    while(n!=0){
      digitSum+=n % 10 ;
      hash[n % 10]++;
      n/=10 ;
    }
    if(digitSum % 3!=0)return false ;
    int oddCount=0 ;
    for(int i=0 ; i<10 ; i++){
      if(hash[i] % 2!=0)oddCount++;
    }
    if(oddCount>1)return false ;
    else return true ;
  }
  public static void main(String[] args){
    int n=34734 ;
    System.out.print(isDivisiblePalindrome(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isDivisiblePalindrome( n : int) : boolean
  pre: true
  post: true
  activity: (     var hash : Sequence(int) ; hash := Integer.subrange(1,10)->collect(0) ;
     var digitSum : int ; digitSum := 0 ;
    while (n /= 0) do (     digitSum := digitSum+(n mod 10) ; 
     hash[n mod 10+1] := hash[n mod 10+1] + 1 ; 
     n := n/(10) ) ; 
    if (digitSum mod 3 /= 0) then     return false else skip ; 
    var oddCount : int ; oddCount := 0 ;
        var i : int ; i := 0 ; while i < 10 do ( (     if (hash[i+1] mod 2 /= 0) then     oddCount := oddCount + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (oddCount > 1) then     return false else     return true ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 34734 ;
     OclFile["System.out"].print(isDivisiblePalindrome(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int N=5 ;
  static int func(int idx,int cur,int a[],int dp[][],int n,int x){
    if(idx==n){
      return 0 ;
    }
    if(dp[idx][cur]!=-1){
      return dp[idx][cur];
    }
    int ans=0 ;
    if(cur==0){
      ans=Math.max(ans,a[idx]+func(idx+1,0,a,dp,n,x));
      ans=Math.max(ans,x*a[idx]+func(idx+1,1,a,dp,n,x));
    }
    else if(cur==1){
      ans=Math.max(ans,x*a[idx]+func(idx+1,1,a,dp,n,x));
      ans=Math.max(ans,a[idx]+func(idx+1,2,a,dp,n,x));
    }
    else {
      ans=Math.max(ans,a[idx]+func(idx+1,2,a,dp,n,x));
    }
    return dp[idx][cur]=ans ;
  }
  static int getMaximumSum(int a[],int n,int x){
    int dp[][]=new int[n][3];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<3 ; j++){
        dp[i][j]=-1 ;
      }
    }
    int maxi=0 ;
    for(int i=0 ; i<n ; i++){
      maxi=Math.max(maxi,func(i,0,a,dp,n,x));
    }
    return maxi ;
  }
  public static void main(String[] args){
    int a[]={
-3,8,-2,1,-6 };
      int n=a.length ;
      int x=-1 ;
      System.out.println(getMaximumSum(a,n,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 5;
  static   operation func( idx : int, cur : int, a : Sequence(int), dp : Sequence(Sequence(int)), n : int, x : int) : int
  pre: true
  post: true
  activity: (     if (idx = n) then (     return 0 ) else skip ; 
     if (dp[idx+1][cur+1] /= -1) then (     return dp[idx+1][cur+1] ) else skip ; 
    var ans : int ; ans := 0 ;
    if (cur = 0) then (     ans := Set{ans, a[idx+1] + func(idx + 1, 0, a, dp, n, x)}->max() ; 
     ans := Set{ans, x * a[idx+1] + func(idx + 1, 1, a, dp, n, x)}->max() ) else     if (cur = 1) then (     ans := Set{ans, x * a[idx+1] + func(idx + 1, 1, a, dp, n, x)}->max() ; 
     ans := Set{ans, a[idx+1] + func(idx + 1, 2, a, dp, n, x)}->max() ) else (     ans := Set{ans, a[idx+1] + func(idx + 1, 2, a, dp, n, x)}->max() ) ;  ;  
    return dp[idx+1][cur+1] 
 );
  static   operation getMaximumSum( a : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 3 do ( (     dp[i+1][j+1] := -1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var maxi : int ; maxi := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     maxi := Set{maxi, func(i, 0, a, dp, n, x)}->max() )  ;     i := i + 1 ) ; 
    return maxi 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{-3,8,-2,1,-6} ;
     var n : int ; n := a->size() ;
     var x : int ; x := -1 ;
     OclFile["System.out"].println(getMaximumSum(a, n, x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    if(A==B)System.out.println(C);
    if(C==B)System.out.println(A);
    if(A==C)System.out.println(B);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    if (A = B) then     OclFile["System.out"].println(C) ; else skip ; 
    if (C = B) then     OclFile["System.out"].println(A) ; else skip ; 
    if (A = C) then     OclFile["System.out"].println(B) ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Map ;
import java.util.function.Function ;
import java.util.stream.Collectors ;
class Main {
  public static void main(String[] args)throws Exception {
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String[] cellsCount=br.readLine().split(" ");
      Map<String,Long>counted=Arrays.asList(cellsCount).stream().collect(Collectors.groupingBy(Function.identity(),Collectors.counting()));
      counted.entrySet().stream().filter(e->e.getValue()==1).forEach(e->System.out.println(e.getKey()));
    }
    catch(IOException | NumberFormatException e){
      e.printStackTrace();
      System.exit(0);
    }
    catch(final Exception e){
      e.printStackTrace();
      System.exit(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var cellsCount : Sequence(String) ; cellsCount := br.readLine()->split(" ") ;
     var counted : Map(String,long) ; counted := cellsCount.collect(Collectors.groupingBy(Function.identity(), Collectors.counting())) ;
     for e : counted->asSet()->select( _x1 | (lambda e : OclAny in e.getValue() = 1)->apply(_x1) ) do
    (    OclFile["System.out"].println(e.getKey())) )   catch (e : OclException) do (     e.printStackTrace() ; 
 OclProcess.exit(0) )
   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(0) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=false ;
  private static PrintWriter _out=new PrintWriter(System.out);
  private static PrintWriter _err=new PrintWriter(System.err);
  private static final int INF=Integer.MAX_VALUE/2 ;
  private void solve(Scanner sc){
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    if(a==b){
      _out.println(c);
    }
    else if(a==c){
      _out.println(b);
    }
    else {
      _out.println(a);
    }
  }
  private static BigInteger C(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    for(long i=r ; i>1 ; --i){
      res=res.divide(BigInteger.valueOf(i));
    }
    return res ;
  }
  private static BigInteger P(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    return res ;
  }
  public static void main(String[] args){
    long S=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    new Main().solve(sc);
    _out.flush();
    long G=System.currentTimeMillis();
    if(elapsed){
      _err.println((G-S)+"ms");
    }
    _err.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := false;
  static   attribute _out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute _err : OclFile := OclFile.newOclFile_Write(OclFile["System.err"]);
  static    attribute INF : int := 2147483647 / 2;
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.nextInt() ;
     var b : int ; b := sc.nextInt() ;
     var c : int ; c := sc.nextInt() ;
     if (a = b) then (     skip ) else     if (a = c) then (     skip ) else (     skip ) ;  );
  static   operation C( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
         var i : long ; i := r ; while i > 1 do ( (     res := res.divide((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation P( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    Main.newMain().solve(sc) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void execute(){
    Scanner sc=new Scanner(System.in);
    int a=nextInt(sc);
    int b=nextInt(sc);
    int c=nextInt(sc);
    if(a==b){
      out(c);
    }
    else if(a==c){
      out(b);
    }
    else {
      out(a);
    }
  }
  public static int nextInt(Scanner sc){
    return sc.nextInt();
  }
  public static String nextString(Scanner sc){
    return sc.next();
  }
  public static int[] nextInts(Scanner sc,int n){
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=nextInt(sc);
    }
    return arr ;
  }
  public static void out(Object o){
    System.out.println(o);
  }
  public static void main(String[] args){
    execute();
  }
  public static void putCountMap(Map<Integer,Integer>map,int value){
    if(map.containsKey(value)){
      map.put(value,map.get(value)+1);
    }
    else {
      map.put(value,1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation execute() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := nextInt(sc) ;
    var b : int ; b := nextInt(sc) ;
    var c : int ; c := nextInt(sc) ;
    if (a = b) then (     execute out(c) ) else     if (a = c) then (     execute out(b) ) else (     execute out(a) ) ;  ;  
 );
  static   operation nextInt( sc : OclFile) : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
  static   operation nextString( sc : OclFile) : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
  static   operation nextInts( sc : OclFile, n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := nextInt(sc) )  ;     i := i + 1 ) ; 
     return arr );
  static   operation out( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute execute() );
  static   operation putCountMap( map : Map(int,int), value : int) : void
  pre: true
  post: true
  activity: (     if (map.containsKey(value)) then (     map := map->union(Map{value |-> map->at(value+1) + 1}) ) else (     map := map->union(Map{value |-> 1}) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(1,in,out);
    out.close();
  }
  static class Task {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int A=in.nextInt();
      int B=in.nextInt();
      int C=in.nextInt();
      if(A==B){
        out.println(C);
      }
      else if(B==C){
        out.println(A);
      }
      else {
        out.println(B);
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var A : int ; A := in.nextInt() ;
     var B : int ; B := in.nextInt() ;
     var C : int ; C := in.nextInt() ;
     if (A = B) then (     skip ) else     if (B = C) then (     skip ) else (     skip ) ;  );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      String[] a=scan.nextLine().split(" ");
      if(a[0] .equals("0")&& a[1] .equals("0")){
        break ;
      }
      int m=Integer.parseInt(a[0]);
      int n=Integer.parseInt(a[1]);
      boolean[] p=new boolean[m];
      int tp=0 ;
      int count=m ;
      String[] str=new String[n];
      for(int i=0 ; i<n ; i++){
        str[i]=scan.nextLine();
      }
      for(int i=1 ; i<=n ; i++){
        if(count==1){
          break ;
        }
        while(p[tp]){
          tp=(tp+1)% m ;
        }
        if(i % 15==0){
          if(! str[i-1] .equals("FizzBuzz")){
            p[tp]=true ;
            count--;
          }
        }
        else if(i % 5==0){
          if(! str[i-1] .equals("Buzz")){
            p[tp]=true ;
            count--;
          }
        }
        else if(i % 3==0){
          if(! str[i-1] .equals("Fizz")){
            p[tp]=true ;
            count--;
          }
        }
        else {
          if(! str[i-1] .equals(String.valueOf(i))){
            p[tp]=true ;
            count--;
          }
        }
        tp++;
        if(tp>=m){
          tp %=m ;
        }
      }
      String ans="" ;
      for(int i=0 ; i<m ; i++){
        if(! p[i]){
          ans+=(ans.equals(""))?(i+1):(" "+(i+1));
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var a : Sequence(String) ; a := scan.nextLine()->split(" ") ;
     if (a[0+1] = "0" & a[1+1] = "0") then (     break ) else skip ; 
    var m : int ; m := (a[0+1])->toInteger() ;
    var n : int ; n := (a[1+1])->toInteger() ;
    var p : Sequence(boolean) ; p := Integer.subrange(1,m)->collect(false) ;
    var tp : int ; tp := 0 ;
    var count : int ; count := m ;
    var str : Sequence(String) ; str := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     str[i+1] := scan.nextLine() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (count = 1) then (     break ) else skip ; 
     while (p[tp+1]) do (     tp := (tp + 1) mod m ) ; 
    if (i mod 15 = 0) then (     if (not(str[i - 1+1] = "FizzBuzz")) then (     p[tp+1] := true ; 
     count := count - 1 ) else skip ) else     if (i mod 5 = 0) then (     if (not(str[i - 1+1] = "Buzz")) then (     p[tp+1] := true ; 
     count := count - 1 ) else skip ) else     if (i mod 3 = 0) then (     if (not(str[i - 1+1] = "Fizz")) then (     p[tp+1] := true ; 
     count := count - 1 ) else skip ) else (     if (not(str[i - 1+1] = ((i) + ""))) then (     p[tp+1] := true ; 
     count := count - 1 ) else skip ) ;  ;  ;  
    tp := tp + 1 ; 
    if (tp >= m) then (     tp := tp mod m ) else skip ; 
 )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < m do ( (     if (not(p[i+1])) then (     ans := ans+(if (ans = "") then (i + 1) else (" " + (i + 1)) endif) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class trailzero {
  public static void main(String[] args)throws Throwable {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int m=sc.nextInt();
    String[] s=new String[n];
    for(int i=0 ; i<n ; i++)s[i]=sc.next();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    HashMap<String,Integer>map=new HashMap<String,Integer>();
    int[] c=new int[k];
    Arrays.fill(c,Integer.MAX_VALUE);
    for(int i=0 ; i<k ; i++){
      int cnt=sc.nextInt();
      while(cnt-->0){
        int x=sc.nextInt()-1 ;
        map.put(s[x],i);
        c[i]=Math.min(c[i],a[x]);
      }
    }
    long ans=0 ;
    for(int i=0 ; i<m ; i++){
      ans+=c[map.get(sc.next())];
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class trailzero {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     s[i+1] := sc.getCurrent() ;  ;     i := i + 1 ) ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var map : Map(String,int) ; map := Map{} ;
    var c : Sequence(int) ; c := Integer.subrange(1,k)->collect(0) ;
    c := c->collect(2147483647) ; 
        var i : int ; i := 0 ; while i < k do ( (     var cnt : int ; cnt := sc.getCurrent()->toInteger() ;
         while (cnt > 0) do (        cnt := cnt - 1 ;     skip ; (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
     map := map->union(Map{s[x+1] |-> i}) ; 
     c[i+1] := Set{c[i+1], a[x+1]}->min() ) ;  ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     ans := ans+(c[map->at(sc.getCurrent())+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _959B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int m=sc.nextInt();
    String[] s=new String[n];
    for(int i=0 ; i<n ; i++)s[i]=sc.next();
    int[] cost=new int[n];
    for(int i=0 ; i<n ; i++)cost[i]=sc.nextInt();
    HashMap<String,Integer>map=new HashMap<>();
    int[] min=new int[k];
    Arrays.fill(min,Integer.MAX_VALUE);
    for(int i=0 ; i<k ; i++){
      int count=sc.nextInt();
      while(count-->0){
        int x=sc.nextInt()-1 ;
        map.put(s[x],i);
        min[i]=Math.min(min[i],cost[x]);
      }
    }
    long ans=0 ;
    for(int i=0 ; i<m ; i++){
      ans+=min[map.get(sc.next())];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _959B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     s[i+1] := sc.getCurrent() ;  ;     i := i + 1 ) ; 
    var cost : Sequence(int) ; cost := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     cost[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var map : Map(String,int) ; map := Map{} ;
    var min : Sequence(int) ; min := Integer.subrange(1,k)->collect(0) ;
    min := min->collect(2147483647) ; 
        var i : int ; i := 0 ; while i < k do ( (     var count : int ; count := sc.getCurrent()->toInteger() ;
         while (count > 0) do (        count := count - 1 ;     skip ; (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
     map := map->union(Map{s[x+1] |-> i}) ; 
     min[i+1] := Set{min[i+1], cost[x+1]}->min() ) ;  ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     ans := ans+(min[map->at(sc.getCurrent())+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    int n=in.nextInt();
    String s1="" ;
    String s2="" ;
    s1+=s.charAt(0);
    s1+=s.charAt(1);
    s2+=s.charAt(3);
    s2+=s.charAt(4);
    int num1=Integer.parseInt(s1);
    int num2=Integer.parseInt(s2);
    num2+=n ;
    while(num2>=60){
      num2-=60 ;
      num1++;
      if(num1==24){
        num1=0 ;
      }
    }
    if(num1==24){
      num1=0 ;
    }
    if(num1/10==0 && num2/10==0)System.out.println("0"+num1+":"+"0"+num2);
    else if(num1/10!=0 && num2/10==0)System.out.println(num1+":"+"0"+num2);
    else if(num1/10==0 && num2/10!=0)System.out.println("0"+num1+":"+num2);
    else {
      System.out.println(num1+":"+num2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var s1 : String ; s1 := "" ;
    var s2 : String ; s2 := "" ;
    s1 := s1+(s->at(0+1)) ; 
    s1 := s1+(s->at(1+1)) ; 
    s2 := s2+(s->at(3+1)) ; 
    s2 := s2+(s->at(4+1)) ; 
    var num1 : int ; num1 := (s1)->toInteger() ;
    var num2 : int ; num2 := (s2)->toInteger() ;
    num2 := num2+(n) ; 
    while (num2 >= 60) do (     num2 := num2-(60) ; 
     num1 := num1 + 1 ; 
     if (num1 = 24) then (     num1 := 0 ) else skip ) ; 
    if (num1 = 24) then (     num1 := 0 ) else skip ; 
    if (num1 / 10 = 0 & num2 / 10 = 0) then     OclFile["System.out"].println("0" + num1 + ":" + "0" + num2) else     if (num1 / 10 /= 0 & num2 / 10 = 0) then     OclFile["System.out"].println(num1 + ":" + "0" + num2) else     if (num1 / 10 = 0 & num2 / 10 /= 0) then     OclFile["System.out"].println("0" + num1 + ":" + num2) else (     OclFile["System.out"].println(num1 + ":" + num2) ) ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int[] d=new int[a];
    for(int i=0 ; i<a ; i++){
      d[i]=sc.nextInt();
    }
    int b=d[0];
    long c=0 ;
    for(int i=0 ; i<a ; i++){
      if(d[i]>b){
        b=d[i];
      }
      c+=b-d[i];
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var d : Sequence(int) ; d := Integer.subrange(1,a)->collect(0) ;
        var i : int ; i := 0 ; while i < a do ( (     d[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var b : int ; b := d[0+1] ;
    var c : long ; c := 0 ;
        var i : int ; i := 0 ; while i < a do ( (     if (d[i+1] > b) then (     b := d[i+1] ) else skip ; 
     c := c+(b - d[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CStep solver=new CStep();
    solver.solve(1,in,out);
    out.close();
  }
  static class CStep {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int[] a=in.readIntArray(n);
      long answer=0 ;
      int max=0 ;
      for(int x : a){
        answer+=Math.max(0,max-x);
        max=Math.max(max,x);
      }
      out.println(answer);
    }
  }
  static class InputReader {
    public final BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public int[] readIntArray(int n){
      int[] x=new int[n];
      for(int i=0 ; i<n ; i++){
        x[i]=nextInt();
      }
      return x ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CStep ; solver := CStep.newCStep() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CStep {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var a : Sequence(int) ; a := in.readIntArray(n) ;
    var answer : long ; answer := 0 ;
    var max : int ; max := 0 ;
    for (x : a) do ( (     answer := answer+(Set{0, max - x}->max()) ; 
     max := Set{max, x}->max() )  ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     x[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return x );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.System.*;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  static void solve()throws Exception {
    int n=scanInt();
    long ans=0 ;
    long tmp=scanLong();
    for(int i=1 ; i<n ; i++){
      long a=scanLong();
      if(tmp>a){
        ans+=tmp-a ;
      }
      else {
        tmp=a ;
      }
    }
    out.print(ans);
  }
  static int scanInt()throws IOException {
    return parseInt(scanString());
  }
  static long scanLong()throws IOException {
    return parseLong(scanString());
  }
  static String scanString()throws IOException {
    while(tok==null || ! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  public static void main(String[] args){
    try {
      in=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(System.out);
      solve();
      in.close();
      out.close();
    }
    catch(Throwable e){
      e.printStackTrace();
      exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanInt() ;
     var ans : long ; ans := 0 ;
    var tmp : long ; tmp := scanLong() ;
        var i : int ; i := 1 ; while i < n do ( (     var a : long ; a := scanLong() ;
     if (tmp > a) then (     ans := ans+(tmp - a) ) else (     tmp := a ) )  ;     i := i + 1 ) ; 
    out.print(ans) ; 
 );
  static   operation scanInt() : int
  pre: true
  post: true
  activity: (     return (scanString() + "")->toInteger() );
  static   operation scanLong() : long
  pre: true
  post: true
  activity: (     return parseLong(scanString()) );
  static   operation scanString() : String
  pre: true
  post: true
  activity: (     while (tok = null or not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return tok.next() );
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
     execute exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.math.BigDecimal ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args)throws Exception {
    solve(System.in,System.out);
  }
  static void solve(InputStream is,PrintStream os){
    Scanner scan=new Scanner(is);
    int N=scan.nextInt();
    int A[]=new int[N];
    int maxA[]=new int[N];
    int max=0 ;
    for(int i=0 ; i<N ; i++){
      A[i]=scan.nextInt();
      if(A[i]>max){
        max=A[i];
      }
      maxA[i]=max ;
    }
    long ans=0 ;
    for(int i=0 ; i<N ; i++){
      ans+=maxA[i]-A[i];
    }
    os.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation solve( is : OclFile, os : OclFile) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(is) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var maxA : Sequence(int) ; maxA := Integer.subrange(1,N)->collect(0) ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := scan.getCurrent()->toInteger() ; 
     if (A[i+1] > max) then (     max := A[i+1] ) else skip ; 
     maxA[i+1] := max )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     ans := ans+(maxA[i+1] - A[i+1]) )  ;     i := i + 1 ) ; 
    os.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Map hs=new HashMap();
    PrintWriter ou=new PrintWriter(System.out);
    int n=Integer.parseInt(sc.next());
    long yono=0 ;
    long sum=0 ;
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(sc.next());
      if(a[i]<yono)sum+=(yono-a[i]);
      else yono=a[i];
    }
    ou.print(sum+"\n");
    ou.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var hs : Map ; hs := Map{} ;
    var ou : OclFile ; ou := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (sc.getCurrent())->toInteger() ;
    var yono : long ; yono := 0 ;
    var sum : long ; sum := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sc.getCurrent())->toInteger() ; 
     if (a[i+1] < yono) then     sum := sum+((yono - a[i+1])) ; else     yono := a[i+1] ; )  ;     i := i + 1 ) ; 
    ou := ou.print(sum + "\n") ; 
    ou := ou.flush() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=26 ;
  static String smallestStr(char[] str,int n){
    int i,j=0 ;
    int[] chk=new int[MAX];
    for(i=0 ; i<MAX ; i++)chk[i]=-1 ;
    for(i=0 ; i<n ; i++){
      if(chk[str[i]-'a']==-1)chk[str[i]-'a']=i ;
    }
    for(i=0 ; i<n ; i++){
      boolean flag=false ;
      for(j=0 ; j<str[i]-'a' ; j++){
        if(chk[j]>chk[str[i]-'a']){
          flag=true ;
          break ;
        }
      }
      if(flag)break ;
    }
    if(i<n){
      char ch1=str[i];
      char ch2=(char)(j+'a');
      for(i=0 ; i<n ; i++){
        if(str[i]==ch1)str[i]=ch2 ;
        else if(str[i]==ch2)str[i]=ch1 ;
      }
    }
    return String.valueOf(str);
  }
  public static void main(String[] args){
    String str="ccad" ;
    int n=str.length();
    System.out.println(smallestStr(str.toCharArray(),n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 26;
  static   operation smallestStr( str : Sequence(String), n : int) : String
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ; j := 0 ;
     var chk : Sequence(int) ; chk := Integer.subrange(1,MAX)->collect(0) ;
        i := 0 ; while i < MAX do (     chk[i+1] := -1 ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     if (chk[str[i+1] - ('a')->char2byte()+1] = -1) then     chk[str[i+1] - ('a')->char2byte()+1] := i ; else skip )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     var flag : boolean ; flag := false ;
         j := 0 ; while j < str[i+1] - ('a')->char2byte() do ( (     if (chk[j+1] > chk[str[i+1] - ('a')->char2byte()+1]) then (     flag := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (flag) then     break else skip )  ;     i := i + 1 ) ; 
    if (i < n) then (     var ch1 : String ; ch1 := str[i+1] ;
     var ch2 : String ; ch2 := (j + 'a')->oclAsType(String) ;
         i := 0 ; while i < n do ( (     if (str[i+1] = ch1) then     str[i+1] := ch2 ; else     if (str[i+1] = ch2) then     str[i+1] := ch1 ; else skip ; )  ;     i := i + 1 ) ) else skip ; 
    return ((str) + "") 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "ccad" ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].println(smallestStr(str->characters(), n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String A=sc.next();
    String B=sc.next();
    Node a=toNode(A);
    Node b=toNode(B);
    Node c=merge(a,b);
    System.out.println(toString(c));
  }
  static char[] S ;
  static int id ;
  public static Node toNode(String a){
    S=a.toCharArray();
    id=0 ;
    return N();
  }
  public static Node N(){
    Node node=new Node();
    if(S[id+1]!=')'){
      id++;
      node.l=N();
    }
    id+=3 ;
    String num="" ;
    while(S[id]!=']'){
      num+=S[id++];
    }
    node.number=Integer.parseInt(num);
    id++;
    if(S[id+1]!=')'){
      id++;
      node.r=N();
    }
    id++;
    return node ;
  }
  public static Node merge(Node a,Node b){
    Node next=new Node();
    next.number=a.number+b.number ;
    if(a.l!=null && b.l!=null){
      next.l=merge(a.l,b.l);
    }
    if(a.r!=null && b.r!=null){
      next.r=merge(a.r,b.r);
    }
    return next ;
  }
  public static String toString(Node a){
    String ret="(" ;
    if(a.l!=null){
      ret+=toString(a.l);
    }
    ret+=")["+a.number+"] (" ;
    if(a.r!=null){
      ret+=toString(a.r);
    }
    ret+=")" ;
    return ret ;
  }
  static class Node {
    int number ;
    Node l ;
    Node r ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : String ; A := sc.getCurrent() ;
    var B : String ; B := sc.getCurrent() ;
    var a : Node ; a := toNode(A) ;
    var b : Node ; b := toNode(B) ;
    var c : Node ; c := merge(a, b) ;
    OclFile["System.out"].println(toString(c)) ; 
 );
  static   attribute S : Sequence(String);
  static   attribute id : int;
  static   operation toNode( a : String) : Node
  pre: true
  post: true
  activity: (     S := a->characters() ; 
     id := 0 ; 
     return N() );
  static   operation N() : Node
  pre: true
  post: true
  activity: (     var node : Node ; node := Node.newNode() ;
     if (S[id + 1+1] /= ')') then (     id := id + 1 ; 
     node.l := N() ) else skip ; 
    id := id+(3) ; 
    var num : String ; num := "" ;
    while (S[id+1] /= ']') do (      num := num + S[id+1]  ; id := id + 1 ) ; 
    node.number := (num)->toInteger() ; 
    id := id + 1 ; 
    if (S[id + 1+1] /= ')') then (     id := id + 1 ; 
     node.r := N() ) else skip ; 
    id := id + 1 ; 
    return node 
 );
  static   operation merge( a : Node, b : Node) : Node
  pre: true
  post: true
  activity: (     var next : Node ; next := Node.newNode() ;
     next.number := a.number + b.number ; 
    if (a.l /= null & b.l /= null) then (     next.l := merge(a.l, b.l) ) else skip ; 
    if (a.r /= null & b.r /= null) then (     next.r := merge(a.r, b.r) ) else skip ; 
    return next 
 );
  static   operation toString( a : Node) : String
  pre: true
  post: true
  activity: (     var ret : String ; ret := "(" ;
     if (a.l /= null) then (     ret := ret+(toString(a.l)) ) else skip ; 
    ret := ret+(")[" + a.number + "] (") ; 
    if (a.r /= null) then (     ret := ret+(toString(a.r)) ) else skip ; 
    ret := ret+(")") ; 
    return ret 
 );
  static class Node {
   attribute number : int;
   attribute l : Node;
   attribute r : Node;
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int l[][]=new int[1001][1001];
  static void initialize(){
    l[0][0]=1 ;
    for(int i=1 ; i<1001 ; i++){
      l[i][0]=1 ;
      for(int j=1 ; j<i+1 ; j++){
        l[i][j]=(l[i-1][j-1]+l[i-1][j]);
      }
    }
  }
  static int nCr(int n,int r){
    return l[n][r];
  }
  public static void main(String[] args){
    initialize();
    int n=8 ;
    int r=3 ;
    System.out.println(nCr(n,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute l : int := Integer.subrange(1,1001)->collect(Integer.subrange(1,1001)->collect(0));
  static   operation initialize() : void
  pre: true
  post: true
  activity: (     l[0+1][0+1] := 1 ; 
         var i : int ; i := 1 ; while i < 1001 do ( (     l[i+1][0+1] := 1 ; 
         var j : int ; j := 1 ; while j < i + 1 do ( (     l[i+1][j+1] := (l[i - 1+1][j - 1+1] + l[i - 1+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation nCr( n : int, r : int) : int
  pre: true
  post: true
  activity: (     return l[n+1][r+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute initialize() ; 
     var n : int ; n := 8 ;
     var r : int ; r := 3 ;
     OclFile["System.out"].println(nCr(n, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int modd=1000000007 ;
  static long power(long x,long y,long p){
    long res=1 ;
    x=x % p ;
    while(y>0){
      if(y % 2==1){
        res=(res*x)% p ;
      }
      y=y>>1 ;
      x=(x*x)% p ;
    }
    return res ;
  }
  static int ways(int n,int m){
    return(int)(power(m-1,n-1,modd)*m % modd);
  }
  public static void main(String[] args){
    int n=5,m=5 ;
    System.out.println(ways(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute modd : int := 1000000007;
  static   operation power( x : long, y : long, p : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     if (y mod 2 = 1) then (     res := (res * x) mod p ) else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res );
  static   operation ways( n : int, m : int) : int
  pre: true
  post: true
  activity: (     return (power(m - 1, n - 1, modd) * m mod modd)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var m : int ; m := 5 ;
     OclFile["System.out"].println(ways(n, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
public class Solution {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    List<Integer>a=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      a.add(scan.nextInt());
    }
    Collections.sort(a);
    String result=(n<k)? "-1" : a.get(n-k)+" "+a.get(n-k);
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     a := a->including(scan.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var result : String ; result := if (n < k) then "-1" else a->at(n - k+1) + " " + a->at(n - k+1) endif ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),k=sc.nextInt();
    Integer[] ar=new Integer[n];
    for(int i=0 ; i<n ; i++){
      ar[i]=sc.nextInt();
    }
    if(k>n){
      System.out.println(-1);
    }
    else {
      Arrays.sort(ar,Collections.reverseOrder());
      System.out.println(ar[k-1]+" "+ar[k-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (k > n) then (     OclFile["System.out"].println(-1) ) else (     ar := OclComparator.sortWith(ar, reverseOrder()) ; 
     OclFile["System.out"].println(ar[k - 1+1] + " " + ar[k - 1+1]) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String time=sc.next();
    int hh=Integer.parseInt(time.substring(0,2));
    int mm=Integer.parseInt(time.substring(3));
    int a=sc.nextInt();
    int hourExtended=(mm+a)/60 ;
    mm=(mm+a)% 60 ;
    hh=(hh+hourExtended)% 24 ;
    if(hh<10 && mm<10){
      System.out.println("0"+hh+":0"+mm);
    }
    else if(hh<10){
      System.out.println("0"+hh+":"+mm);
    }
    else if(mm<10){
      System.out.println(hh+":0"+mm);
    }
    else {
      System.out.println(hh+":"+mm);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var time : String ; time := sc.getCurrent() ;
    var hh : int ; hh := (time.subrange(0+1,2))->toInteger() ;
    var mm : int ; mm := (time.subrange(3+1,3))->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var hourExtended : int ; hourExtended := (mm + a) / 60 ;
    mm := (mm + a) mod 60 ; 
    hh := (hh + hourExtended) mod 24 ; 
    if (hh < 10 & mm < 10) then (     OclFile["System.out"].println("0" + hh + ":0" + mm) ) else     if (hh < 10) then (     OclFile["System.out"].println("0" + hh + ":" + mm) ) else     if (mm < 10) then (     OclFile["System.out"].println(hh + ":0" + mm) ) else (     OclFile["System.out"].println(hh + ":" + mm) ) ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sx=new Scanner(System.in);
    int n=sx.nextInt();
    int k=sx.nextInt();
    ArrayList<Long>arr=new ArrayList<Long>();
    for(int i=0 ; i<n ; i++){
      arr.add(sx.nextLong());
    }
    Collections.sort(arr);
    if(k>n){
      System.out.println(-1);
    }
    else if(k==n){
      System.out.println(arr.get(0)+" "+0);
    }
    else {
      int c=0,d=1 ;
      for(int i=n-1 ; i>=0 ; i--){
        if(d==k){
          c=i ;
          break ;
        }
        else {
          d++;
        }
      }
      System.out.println(arr.get(c)+" "+0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sx : OclFile ; sx := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sx.getCurrent()->toInteger() ;
    var k : int ; k := sx.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr := arr->including(sx.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    if (k > n) then (     OclFile["System.out"].println(-1) ) else     if (k = n) then (     OclFile["System.out"].println(arr->at(0+1) + " " + 0) ) else (     var c : int ; c := 0 ;
    var d : int ; d := 1 ;
         var i : int ; i := n - 1 ; while i >= 0 do ( (     if (d = k) then (     c := i ; 
     break ) else (     d := d + 1 ) )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println(arr->at(c+1) + " " + 0) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=in.nextInt();
    Arrays.sort(a);
    if(k==n)System.out.println("0 0");
    else {
      int i=n-1 ;
      while(k-->0){
        i--;
      }
      if(i<0)System.out.println("-1");
      else System.out.println(a[i]+1+" "+a[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    if (k = n) then     OclFile["System.out"].println("0 0") else (     var i : int ; i := n - 1 ;
         while (k > 0) do (        k := k - 1 ;     skip ; (     i := i - 1 ) ;  ) ;  
     if (i < 0) then     OclFile["System.out"].println("-1") ; else     OclFile["System.out"].println(a[i+1] + 1 + " " + a[i+1]) ; ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
public class Squares {
  public static void main(String[] args)throws IOException {
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    String[] ars=bf.readLine().split(" ");
    int n=Integer.parseInt(ars[0]);
    int k=Integer.parseInt(ars[1]);
    String sol="" ;
    int[] arr=new int[n];
    ars=bf.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(ars[i]);
    }
    if(k>n){
      sol="-1" ;
    }
    else {
      Arrays.sort(arr);
      sol=(arr[n-k])+" "+(arr[n-k]);
    }
    pw.println(sol);
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Squares {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var ars : Sequence(String) ; ars := bf.readLine()->split(" ") ;
    var n : int ; n := (ars[0+1])->toInteger() ;
    var k : int ; k := (ars[1+1])->toInteger() ;
    var sol : String ; sol := "" ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    ars := bf.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (ars[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    if (k > n) then (     sol := "-1" ) else (     arr := arr->sort() ; 
     sol := (arr[n - k+1]) + " " + (arr[n - k+1]) ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    if((a+b)% 2==0){
      System.out.println((a+b)/2);
    }
    else {
      System.out.println("IMPOSSIBLE");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if ((a + b) mod 2 = 0) then (     OclFile["System.out"].println((a + b) / 2) ) else (     OclFile["System.out"].println("IMPOSSIBLE") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    List<Integer>list=new ArrayList<Integer>();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=Math.abs(a-b);
    if(c % 2==0){
      if(a<b){
        System.out.println(a+c/2);
      }
      else {
        System.out.println(a-c/2);
      }
    }
    else {
      System.out.println("IMPOSSIBLE");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(int) ; list := Sequence{} ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := if a - b < 0 then -(a - b) else a - b endif ;
    if (c mod 2 = 0) then (     if (a < b) then (     OclFile["System.out"].println(a + c / 2) ) else (     OclFile["System.out"].println(a - c / 2) ) ) else (     OclFile["System.out"].println("IMPOSSIBLE") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class GrowTheTree {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=sc.nextInt();
    }
    Arrays.sort(nums);
    long firstHalf=0 ;
    long secondHalf=0 ;
    int length=n/2 ;
    for(int i=0 ; i<length ; i++){
      firstHalf+=nums[i];
    }
    for(int i=length ; i<n ; i++){
      secondHalf+=nums[i];
    }
    long result=(firstHalf*firstHalf)+(secondHalf*secondHalf);
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GrowTheTree {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    nums := nums->sort() ; 
    var firstHalf : long ; firstHalf := 0 ;
    var secondHalf : long ; secondHalf := 0 ;
    var length : int ; length := n / 2 ;
        var i : int ; i := 0 ; while i < length do ( (     firstHalf := firstHalf+(nums[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := length ; while i < n do ( (     secondHalf := secondHalf+(nums[i+1]) )  ;     i := i + 1 ) ; 
    var result : long ; result := (firstHalf * firstHalf) + (secondHalf * secondHalf) ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double a=sc.nextDouble();
    double b=sc.nextDouble();
    int k=0 ;
    if((a+b)% 2==0){
      k=(int)((a+b)/2);
      System.out.println(k);
    }
    else {
      System.out.println("IMPOSSIBLE");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : double ; a := sc.getCurrent()->toReal() ;
    var b : double ; b := sc.getCurrent()->toReal() ;
    var k : int ; k := 0 ;
    if ((a + b) mod 2 = 0) then (     k := ((a + b) / 2)->oclAsType(int) ; 
     OclFile["System.out"].println(k) ) else (     OclFile["System.out"].println("IMPOSSIBLE") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int A=stdIn.nextInt();
    int B=stdIn.nextInt();
    if((A+B)% 2==0)System.out.println((A+B)/2);
    else System.out.println("IMPOSSIBLE");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := stdIn.getCurrent()->toInteger() ;
     var B : int ; B := stdIn.getCurrent()->toInteger() ;
     if ((A + B) mod 2 = 0) then     OclFile["System.out"].println((A + B) / 2) ; else     OclFile["System.out"].println("IMPOSSIBLE") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int a[][]=new int[100][100];
    int n=sc.nextInt();
    int m=sc.nextInt();
    int l=sc.nextInt();
    for(int j=0 ; j<n ; j++){
      for(int k=0 ; k<m ; k++){
        a[j][k]=sc.nextInt();
      }
    }
    int b[][]=new int[100][100];
    for(int j=0 ; j<m ; j++){
      for(int k=0 ; k<l ; k++){
        b[j][k]=sc.nextInt();
      }
    }
    long c[][]=new long[100][100];
    for(int j=0 ; j<n ; j++){
      for(int k=0 ; k<l ; k++){
        for(int i=0 ; i<m ; i++){
          c[j][k]+=a[j][i]*b[i][k];
        }
        System.out.print(c[j][k]);
        if(k!=l-1)System.out.print(" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(0)) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
        var j : int ; j := 0 ; while j < n do ( (         var k : int ; k := 0 ; while k < m do ( (     a[j+1][k+1] := sc.getCurrent()->toInteger() )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    var b : Sequence(Sequence(int)) ; b := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(0)) ;
        var j : int ; j := 0 ; while j < m do ( (         var k : int ; k := 0 ; while k < l do ( (     b[j+1][k+1] := sc.getCurrent()->toInteger() )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    var c : Sequence(Sequence(long)) ; c := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(0)) ;
        var j : int ; j := 0 ; while j < n do ( (         var k : int ; k := 0 ; while k < l do ( (         var i : int ; i := 0 ; while i < m do ( (     c[j+1][k+1] := c[j+1][k+1]+(a[j+1][i+1] * b[i+1][k+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(c[j+1][k+1]) ; 
     if (k /= l - 1) then     OclFile["System.out"].print(" ") ; else skip )  ;     k := k + 1 ) ; 
     OclFile["System.out"].println() )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    int l=scan.nextInt();
    int[][] a=new int[n][];
    for(int i=0 ; i<n ; i++){
      a[i]=new int[m];
      for(int j=0 ; j<m ; j++){
        a[i][j]=scan.nextInt();
      }
    }
    int[][] b=new int[m][];
    for(int i=0 ; i<m ; i++){
      b[i]=new int[l];
      for(int j=0 ; j<l ; j++){
        b[i][j]=scan.nextInt();
      }
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<l ; j++){
        long c=0 ;
        for(int k=0 ; k<m ; k++){
          c+=a[i][k]*b[k][j];
        }
        if(j==0){
          System.out.print(c);
        }
        else System.out.print(" "+c);
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var l : int ; l := scan.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := Integer.subrange(1,m)->collect(0) ; 
         var j : int ; j := 0 ; while j < m do ( (     a[i+1][j+1] := scan.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var b : Sequence(Sequence(int)) ; b := Integer.subrange(1,m)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := Integer.subrange(1,l)->collect(0) ; 
         var j : int ; j := 0 ; while j < l do ( (     b[i+1][j+1] := scan.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < l do ( (     var c : long ; c := 0 ;
         var k : int ; k := 0 ; while k < m do ( (     c := c+(a[i+1][k+1] * b[k+1][j+1]) )  ;     k := k + 1 ) ; 
     if (j = 0) then (     OclFile["System.out"].print(c) ) else     OclFile["System.out"].print(" " + c) ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float geometricMean(int[] arr,int n){
    float sum=0 ;
    for(int i=0 ; i<n ; i++)sum=sum+(float)Math.log(arr[i]);
    sum=sum/n ;
    return(float)Math.exp(sum);
  }
  public static void main(String[] args){
    int[] arr={
      1,2,3,4,5,6,7,8 };
      int n=arr.length ;
      System.out.println(geometricMean(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation geometricMean( arr : Sequence(int), n : int) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum + (arr[i+1])->log()->oclAsType(double) ;  ;     i := i + 1 ) ; 
     sum := sum / n ; 
     return (sum)->exp()->oclAsType(double) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6,7,8} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(geometricMean(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder builder=new StringBuilder();
    String[] str=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int m=Integer.parseInt(str[1]);
    int l=Integer.parseInt(str[2]);
    long[][] nm=new long[n][m];
    long[][] calc=new long[n][l];
    for(int i=0 ; i<n ; i++){
      str=br.readLine().split(" ");
      for(int j=0 ; j<m ; j++){
        nm[i][j]=Integer.parseInt(str[j]);
      }
    }
    for(int i=0 ; i<m ; i++){
      str=br.readLine().split(" ");
      for(int j=0 ; j<l ; j++){
        int ml=Integer.parseInt(str[j]);
        for(int k=0 ; k<n ; k++){
          calc[k][j]+=nm[k][i]*ml ;
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<l ; j++){
        if(j!=0)builder.append(" ");
        builder.append(calc[i][j]);
      }
      builder.append("\n");
    }
    System.out.print(builder);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var builder : String ; builder := StringLib.newString() ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var m : int ; m := (str[1+1])->toInteger() ;
    var l : int ; l := (str[2+1])->toInteger() ;
    var nm : Sequence(Sequence(long)) ; nm := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var calc : Sequence(Sequence(long)) ; calc := Integer.subrange(1,n)->collect(Integer.subrange(1,l)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     str := br.readLine()->split(" ") ; 
         var j : int ; j := 0 ; while j < m do ( (     nm[i+1][j+1] := (str[j+1])->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     str := br.readLine()->split(" ") ; 
         var j : int ; j := 0 ; while j < l do ( (     var ml : int ; ml := (str[j+1])->toInteger() ;
         var k : int ; k := 0 ; while k < n do ( (     calc[k+1][j+1] := calc[k+1][j+1]+(nm[k+1][i+1] * ml) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < l do ( (     if (j /= 0) then     builder := builder + StringLib.newString(" ") ; else skip ; 
     builder := builder + StringLib.newString(calc[i+1][j+1]) )  ;     j := j + 1 ) ; 
     builder := builder + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(builder) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int numN ;
    int numM ;
    int numL ;
    long[][] boxA ;
    long[][] boxB ;
    long[][] boxAnser ;
    String outPut="" ;
    Scanner sc=null ;
    try {
      sc=new Scanner(System.in);
      numN=sc.nextInt();
      numM=sc.nextInt();
      numL=sc.nextInt();
      boxA=new long[numN][numM];
      boxB=new long[numM][numL];
      boxAnser=new long[numN][numL];
      for(int i=0 ; i<boxA.length ; i++){
        for(int j=0 ; j<boxA[0] .length ; j++){
          boxA[i][j]=sc.nextInt();
        }
      }
      for(int i=0 ; i<boxB.length ; i++){
        for(int j=0 ; j<boxB[0] .length ; j++){
          boxB[i][j]=sc.nextInt();
        }
      }
      for(int i=0 ; i<boxAnser.length ; i++){
        for(int j=0 ; j<boxAnser[0] .length ; j++){
          for(int k=0 ; k<numM ; k++){
            boxAnser[i][j]+=boxA[i][k]*boxB[k][j];
          }
        }
      }
      for(int i=0 ; i<boxAnser.length ; i++){
        for(int j=0 ; j<boxAnser[0] .length ; j++){
          if(! outPut.equals("")){
            outPut+=" " ;
          }
          outPut+=boxAnser[i][j];
        }
        System.out.println(outPut);
        outPut="" ;
      }
    }
    finally {
      sc.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var numN : int ;
     var numM : int ;
    var numL : int ;
    var boxA : Sequence(Sequence(long)) ;
    var boxB : Sequence(Sequence(long)) ;
    var boxAnser : Sequence(Sequence(long)) ;
    var outPut : String ; outPut := "" ;
    var sc : OclFile ; sc := null ;
    try (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     numN := sc.getCurrent()->toInteger() ; 
    numM := sc.getCurrent()->toInteger() ; 
    numL := sc.getCurrent()->toInteger() ; 
    boxA := Integer.subrange(1,numN)->collect(Integer.subrange(1,numM)->collect(0)) ; 
    boxB := Integer.subrange(1,numM)->collect(Integer.subrange(1,numL)->collect(0)) ; 
    boxAnser := Integer.subrange(1,numN)->collect(Integer.subrange(1,numL)->collect(0)) ; 
        var i : int ; i := 0 ; while i < boxA->size() do ( (         var j : int ; j := 0 ; while j < boxA[0+1]->size() do ( (     boxA[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < boxB->size() do ( (         var j : int ; j := 0 ; while j < boxB[0+1]->size() do ( (     boxB[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < boxAnser->size() do ( (         var j : int ; j := 0 ; while j < boxAnser[0+1]->size() do ( (         var k : int ; k := 0 ; while k < numM do ( (     boxAnser[i+1][j+1] := boxAnser[i+1][j+1]+(boxA[i+1][k+1] * boxB[k+1][j+1]) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < boxAnser->size() do ( (         var j : int ; j := 0 ; while j < boxAnser[0+1]->size() do ( (     if (not(outPut = "")) then (     outPut := outPut+(" ") ) else skip ; 
     outPut := outPut+(boxAnser[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(outPut) ; 
     outPut := "" )  ;     i := i + 1 ) ; 
 )   finally (     skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int N=parseInt(br.readLine());
    StringTokenizer st=new StringTokenizer(br.readLine());
    Map<Integer,List<Integer>>map=new HashMap<>();
    String ans="" ;
    while(st.hasMoreTokens()){
      int a=parseInt(st.nextToken());
      int m=a %(N-1);
      map.putIfAbsent(m,new ArrayList<>());
      map.get(m).add(a);
      if(map.get(m).size()>1){
        ans+=map.get(m).get(0);
        ans+=" " ;
        ans+=map.get(m).get(1);
        break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var N : int ; N := parseInt(br.readLine()) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var map : Map(int,Sequence(int)) ; map := Map{} ;
    var ans : String ; ans := "" ;
    while (st.hasNext()) do (     var a : int ; a := parseInt(st.next()) ;
     var m : int ; m := a mod (N - 1) ;
    if map->keys()->includes(m) then skip else map := map->union(Map{m |-> Sequence{}}) ; 
    map->at(m)->excludes(a) ; 
    if (map->at(m)->size() > 1) then (     ans := ans+(map->at(m)->at(0+1)) ; 
     ans := ans+(" ") ; 
     ans := ans+(map->at(m)->at(1+1)) ; 
     break ) else skip ; 
 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        if(Math.abs(arr[i]-arr[j])%(n-1)==0){
          System.out.println(arr[i]+" "+arr[j]);
          return ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (if arr[i+1] - arr[j+1] < 0 then -(arr[i+1] - arr[j+1]) else arr[i+1] - arr[j+1] endif mod (n - 1) = 0) then (     OclFile["System.out"].println(arr[i+1] + " " + arr[j+1]) ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    int[] array=new int[101];
    for(int i=a ; i<b ; i++){
      array[i]++;
    }
    for(int i=c ; i<d ; i++){
      array[i]++;
    }
    int ans=0 ;
    for(int i=0 ; i<101 ; i++){
      if(array[i]==2){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,101)->collect(0) ;
        var i : int ; i := a ; while i < b do ( (     array[i+1] := array[i+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := c ; while i < d do ( (     array[i+1] := array[i+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 101 do ( (     if (array[i+1] = 2) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args){
    SC sc=new SC(System.in);
    int N=sc.nextInt();
    int[] v=new int[N];
    for(int i=0 ; i<N ; i++){
      v[i]=sc.nextInt();
    }
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<i ; j++){
        if(i!=j){
          if(Math.abs(v[i]-v[j])>0 && Math.abs(v[i]-v[j])%(N-1)==0){
            pl(v[i]+" "+v[j]);
            System.exit(0);
          }
        }
      }
    }
  }
  static class SC {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public SC(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
  public static void pl(Object o){
    System.out.println(o);
  }
  public static void pl(){
    System.out.println();
  }
  public static void p(Object o){
    System.out.print(o);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : SC ; sc := SC.newSC(OclFile["System.in"]) ;
     var N : int ; N := sc.nextInt() ;
    var v : Sequence(int) ; v := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     v[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < i do ( (     if (i /= j) then (     if (if v[i+1] - v[j+1] < 0 then -(v[i+1] - v[j+1]) else v[i+1] - v[j+1] endif > 0 & if v[i+1] - v[j+1] < 0 then -(v[i+1] - v[j+1]) else v[i+1] - v[j+1] endif mod (N - 1) = 0) then (     execute pl(v[i+1] + " " + v[j+1]) ; 
 OclProcess.exit(0) ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
  static class SC {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newSC( in : OclFile) : SC
  pre: true
  post: true
  activity:
  ( var self : SC ;
    self := createSC();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation pl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    boolean breakFlag=false ;
    for(int i=0 ; i<n ; i++){
      if(breakFlag)break ;
      for(int j=i+1 ; j<n ; j++){
        if(Math.abs(arr[i]-arr[j])%(n-1)==0){
          System.out.println(arr[i]+" "+arr[j]);
          breakFlag=true ;
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var breakFlag : boolean ; breakFlag := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (breakFlag) then     break else skip ; 
         var j : int ; j := i + 1 ; while j < n do ( (     if (if arr[i+1] - arr[j+1] < 0 then -(arr[i+1] - arr[j+1]) else arr[i+1] - arr[j+1] endif mod (n - 1) = 0) then (     OclFile["System.out"].println(arr[i+1] + " " + arr[j+1]) ; 
     breakFlag := true ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void Permutation(int n,int k){
    int[] p=new int[n+1];
    for(int i=1 ; i<=n ; i++)p[i]=i ;
    for(int i=1 ; i<n-k ; i++)p[i+1]=i ;
    p[1]=n-k ;
    for(int i=1 ; i<=n ; i++)System.out.print(p[i]+" ");
  }
  public static void main(String[] args){
    int n=5,k=2 ;
    Permutation(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Permutation( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var p : Sequence(int) ; p := Integer.subrange(1,n + 1)->collect(0) ;
         var i : int ; i := 1 ; while i <= n do (     p[i+1] := i ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n - k do (     p[i + 1+1] := i ;  ;     i := i + 1 ) ; 
    p[1+1] := n - k ; 
        var i : int ; i := 1 ; while i <= n do (     OclFile["System.out"].print(p[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var k : int ; k := 2 ;
     execute Permutation(n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    try(Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out)){
      int n=in.nextInt();
      TreeSet<Segment>set=new TreeSet<>();
      Segment query=new Segment(0,-1);
      set.add(new Segment(0,0));
      for(int i=0 ; i<n ; i++){
        query.l=in.nextInt();
        Segment res=set.floor(query);
        if(res==null){
          out.println("No");
          continue ;
        }
        out.println("Yes");
        if(res.r<query.l){
          Segment seg=new Segment(res.r+1,query.l);
          res.r--;
          if(! res.isValid())set.remove(res);
          set.add(seg);
        }
        else {
          set.remove(res);
          Segment left=new Segment(res.l,query.l-1);
          Segment right=new Segment(query.l+1,res.r);
          if(left.isValid())set.add(left);
          if(right.isValid())set.add(right);
        }
      }
    }
  }
  private static class Segment implements Comparable<Segment>{
    int l,r ;
    Segment(int l,int r){
      this.l=l ;
      this.r=r ;
    }
    @ Override public boolean equals(Object o){
      if(this==o)return true ;
      if(o==null || getClass()!=o.getClass())return false ;
      Segment segment=(Segment)o ;
      if(l!=segment.l)return false ;
      return r==segment.r ;
    }
    @ Override public int hashCode(){
      int result=l ;
      result=31*result+r ;
      return result ;
    }
    @ Override public int compareTo(Segment o){
      return Integer.compare(l,o.l);
    }
    boolean isValid(){
      return l<=r ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]) ;
 (     var n : int ; n := in.getCurrent()->toInteger() ;
     var set : Set(Segment) ; set := Set{} ;
    var query : Segment ; query := Segment.newSegment(0, -1) ;
    set := set->including(Segment.newSegment(0, 0)) ; 
        var i : int ; i := 0 ; while i < n do ( (     query.l := in.getCurrent()->toInteger() ; 
     var res : Segment ; res := set.floor(query) ;
    if (res = null) then (     skip ; 
     continue ) else skip ; 
    skip ; 
    if (res.r < query.l) then (     var seg : Segment ; seg := Segment.newSegment(res.r + 1, query.l) ;
     res.r := res.r - 1 ; 
     if (not(res.isValid())) then     set := set->excludingFirst(res) ; else skip ; 
     set := set->including(seg) ) else (     set := set->excludingFirst(res) ; 
     var left : Segment ; left := Segment.newSegment(res.l, query.l - 1) ;
    var right : Segment ; right := Segment.newSegment(query.l + 1, res.r) ;
    if (left.isValid()) then     set := set->including(left) ; else skip ; 
    if (right.isValid()) then     set := set->including(right) ; else skip ; 
 ) ;  
 )  ;     i := i + 1 ) ; 
 ))  );
  static class Segment implements Comparable<Segment> {
   attribute l : int;
   static operation newSegment( l : int, r : int) : Segment
  pre: true
  post: true
  activity:
  ( var self : Segment ;
    self := createSegment();
    self.initialise(l, r);
    return self );
  operation initialise( l : int, r : int) : void
  pre: true  post: true
  activity: (     self.l := l ; 
     self.r := r );
      operation equals( o : OclAny) : boolean
  pre: true
  post: true
  activity: (     if (self = o) then     return true else skip ; 
     if (o = null or getClass() /= o->oclType()) then     return false else skip ; 
    var segment : Segment ; segment := o->oclAsType(Segment) ;
    if (l /= segment.l) then     return false else skip ; 
    return r = segment.r 
 );
      operation hashCode() : int
  pre: true
  post: true
  activity: (     var result : int ; result := l ;
     result := 31 * result + r ; 
     return result );
      operation compareTo( o : Segment) : int
  pre: true
  post: true
  activity: (     return compare(l, o.l) );
   operation isValid() : boolean
  pre: true
  post: true
  activity: (     return l <= r );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
import java.io.*;
public class codeHundredSixty {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=input.nextInt();
      long sum=0 ;
      int[] arrayOne=new int[n];
      for(int i=0 ; i<n ; i++){
        arrayOne[i]=input.nextInt();
        sum+=arrayOne[i];
      }
      if(sum==0){
        System.out.println("No");
      }
      else {
        Arrays.sort(arrayOne);
        System.out.println("Yes");
        if(sum<0){
          for(int i=0 ; i<n ; i++){
            if(arrayOne[i]<0){
              System.out.print(arrayOne[i]+" ");
            }
          }
          for(int i=0 ; i<n ; i++){
            if(arrayOne[i]<0){
              continue ;
            }
            System.out.print(arrayOne[i]+" ");
          }
        }
        else if(sum>0){
          for(int i=0 ; i<n ; i++){
            if(arrayOne[i]>0){
              System.out.print(arrayOne[i]+" ");
            }
          }
          for(int i=0 ; i<n ; i++){
            if(arrayOne[i]>0){
              continue ;
            }
            System.out.print(arrayOne[i]+" ");
          }
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var sum : long ; sum := 0 ;
    var arrayOne : Sequence(int) ; arrayOne := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arrayOne[i+1] := input.getCurrent()->toInteger() ; 
     sum := sum+(arrayOne[i+1]) )  ;     i := i + 1 ) ; 
    if (sum = 0) then (     OclFile["System.out"].println("No") ) else (     arrayOne := arrayOne->sort() ; 
     OclFile["System.out"].println("Yes") ; 
     if (sum < 0) then (         var i : int ; i := 0 ; while i < n do ( (     if (arrayOne[i+1] < 0) then (     OclFile["System.out"].print(arrayOne[i+1] + " ") ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (arrayOne[i+1] < 0) then (     continue ) else skip ; 
     OclFile["System.out"].print(arrayOne[i+1] + " ") )  ;     i := i + 1 ) ) else     if (sum > 0) then (         var i : int ; i := 0 ; while i < n do ( (     if (arrayOne[i+1] > 0) then (     OclFile["System.out"].print(arrayOne[i+1] + " ") ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (arrayOne[i+1] > 0) then (     continue ) else skip ; 
     OclFile["System.out"].print(arrayOne[i+1] + " ") )  ;     i := i + 1 ) ) else skip ; ;  
     OclFile["System.out"].println() ) ;  
 )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public void solve(int n){
    Set<Integer>set=new HashSet<>();
    while(! set.contains(n)){
      set.add(n);
++n ;
      while(n % 10==0){
        n/=10 ;
      }
    }
    out.println(set.size());
  }
  public static PrintWriter out ;
  public static void main(String[] args)throws IOException {
    boolean fileInOut=A.class.getPackage()!=null ;
    Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(fileInOut ? A.class.getResourceAsStream("in.txt"): System.in)));
    out=new PrintWriter(new BufferedOutputStream(fileInOut ? new FileOutputStream("out.txt"): System.out),true);
    int totalTestCase=fileInOut ? sc.nextInt(): 1 ;
    for(int testCaseNumber=1 ; testCaseNumber<=totalTestCase ; testCaseNumber++){
      int N=sc.nextInt();
      new A().solve(N);
    }
    if(fileInOut){
      String outputFile="out.txt" ;
      BufferedReader reader1=new BufferedReader(new FileReader(A.class.getResource("ans.txt").getFile()));
      BufferedReader reader2=new BufferedReader(new FileReader(outputFile));
      String line1=reader1.readLine();
      String line2=reader2.readLine();
      boolean areEqual=true ;
      int lineNum=1 ;
      while(line1!=null || line2!=null){
        if(line1==null || line2==null){
          areEqual=false ;
          break ;
        }
        else if(! line1.equals(line2)){
          areEqual=false ;
          break ;
        }
        line1=reader1.readLine();
        line2=reader2.readLine();
        lineNum++;
      }
      if(areEqual){
        System.out.println("All Test Cases Passed !");
      }
      else {
        System.out.println("Output differ at line "+lineNum);
        System.out.println("ans.txt has "+line1+" and out.txt has "+line2+" at line "+lineNum);
      }
      reader1.close();
      reader2.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   operation solve( n : int) : void
  pre: true
  post: true
  activity: (     var set : Set(int) ; set := Set{} ;
     while (not(set->includes(n))) do (     set := set->including(n) ; 
     n := n + 1 ; 
     while (n mod 10 = 0) do (     n := n/(10) ) ) ; 
     out.println(set->size()) );
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fileInOut : boolean ; fileInOut := OclType["A"].getPackage() /= null ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(if fileInOut then OclType["A"].getResourceAsStream("in.txt") else OclFile["System.in"] endif))) ;
    out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(if fileInOut then OclFile.newOclFile_Write(OclFile.newOclFile("out.txt")) else OclFile["System.out"] endif), true) ; 
    var totalTestCase : int ; totalTestCase := if fileInOut then sc.getCurrent()->toInteger() else 1 endif ;
        var testCaseNumber : int ; testCaseNumber := 1 ; while testCaseNumber <= totalTestCase do ( (     var N : int ; N := sc.getCurrent()->toInteger() ;
     A.newA().solve(N) )  ;     testCaseNumber := testCaseNumber + 1 ) ; 
    if (fileInOut) then (     var outputFile : String ; outputFile := "out.txt" ;
     var reader1 : OclFile ; reader1 := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclType["A"].getResource("ans.txt").getFile())) ;
    var reader2 : OclFile ; reader2 := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(outputFile))) ;
    var line1 : String ; line1 := reader1.readLine() ;
    var line2 : String ; line2 := reader2.readLine() ;
    var areEqual : boolean ; areEqual := true ;
    var lineNum : int ; lineNum := 1 ;
    while (line1 /= null or line2 /= null) do (     if (line1 = null or line2 = null) then (     areEqual := false ; 
     break ) else     if (not(line1 = line2)) then (     areEqual := false ; 
     break ) else skip ; ;  
     line1 := reader1.readLine() ; 
     line2 := reader2.readLine() ; 
     lineNum := lineNum + 1 ) ; 
    if (areEqual) then (     OclFile["System.out"].println("All Test Cases Passed !") ) else (     OclFile["System.out"].println("Output differ at line " + lineNum) ; 
     OclFile["System.out"].println("ans.txt has " + line1 + " and out.txt has " + line2 + " at line " + lineNum) ) ;  
    skip ; 
    skip ; 
 ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class WarriorAndArcher {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=scan.nextInt();
    Arrays.sort(arr);
    int ans=Integer.MAX_VALUE ;
    for(int i=0 ; i+n/2<n ; i++){
      ans=Math.min(arr[i+n/2]-arr[i],ans);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class WarriorAndArcher {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := scan.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i + n / 2 < n do ( (     ans := Set{arr[i + n / 2+1] - arr[i+1], ans}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        int n=sc.nextInt();
        int[] arr=new int[n];
        int sum1=0 ;
        for(int i=0 ; i<n ; i++){
          arr[i]=sc.nextInt();
          sum1+=arr[i];
        }
        if(sum1==0)System.out.println("NO");
        else if(sum1>0){
          Arrays.sort(arr);
          System.out.println("YES");
          for(int i=n-1 ; i>=0 ; i--)System.out.print(arr[i]+" ");
          System.out.println();
        }
        else {
          Arrays.sort(arr);
          System.out.println("YES");
          for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
          System.out.println();
        }
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum1 : int ; sum1 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     sum1 := sum1+(arr[i+1]) )  ;     i := i + 1 ) ; 
    if (sum1 = 0) then     OclFile["System.out"].println("NO") else     if (sum1 > 0) then (     arr := arr->sort() ; 
     OclFile["System.out"].println("YES") ; 
         var i : int ; i := n - 1 ; while i >= 0 do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i - 1 ) ; 
     OclFile["System.out"].println() ) else (     arr := arr->sort() ; 
     OclFile["System.out"].println("YES") ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ;  ;  
 ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class practicee {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int arr[]=new int[n];
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        arr[i]=s.nextInt();
        sum+=arr[i];
      }
      Arrays.sort(arr);
      if(sum==0){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
        if(sum>0)for(int i=n-1 ;
        i>=0 ;
        i--)System.out.print(arr[i]+" ");
        else for(int i=0 ;
        i<n ;
        i++)System.out.print(arr[i]+" ");
        System.out.print("\n");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class practicee {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    if (sum = 0) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ; 
     if (sum > 0) then         var i : int ; i := n - 1 ; while i >= 0 do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i - 1 ) else         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; ;  
     OclFile["System.out"].print("\n") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      int arr[]=new int[n];
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
        sum+=arr[i];
      }
      Arrays.sort(arr);
      if(sum==0){
        System.out.println("NO");
      }
      else if(sum<0){
        System.out.println("YES");
        for(int i=0 ; i<n ; i++){
          System.out.print(arr[i]+" ");
        }
        System.out.println();
      }
      else {
        System.out.println("YES");
        for(int i=n-1 ; i>=0 ; i--){
          System.out.print(arr[i]+" ");
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    if (sum = 0) then (     OclFile["System.out"].println("NO") ) else     if (sum < 0) then (     OclFile["System.out"].println("YES") ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) else (     OclFile["System.out"].println("YES") ; 
         var i : int ; i := n - 1 ; while i >= 0 do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println() ) ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Set ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    int a=in.nextInt();
    int b=in.nextInt();
    int c=in.nextInt();
    int d=in.nextInt();
    if(c>b){
      System.out.println(0);
    }
    else if(a>d){
      System.out.println(0);
    }
    else if(a<c){
      System.out.println(Math.min(b,d)-c);
    }
    else {
      List<Integer>l=new ArrayList<>();
      l.add(a);
      l.add(b);
      l.add(c);
      l.add(d);
      Collections.sort(l);
      System.out.println(l.get(2)-l.get(1));
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var a : int ; a := in.nextInt() ;
    var b : int ; b := in.nextInt() ;
    var c : int ; c := in.nextInt() ;
    var d : int ; d := in.nextInt() ;
    if (c > b) then (     OclFile["System.out"].println(0) ) else     if (a > d) then (     OclFile["System.out"].println(0) ) else     if (a < c) then (     OclFile["System.out"].println(Set{b, d}->min() - c) ) else (     var l : Sequence(int) ; l := Sequence{} ;
     l := l->including(a) ; 
    l := l->including(b) ; 
    l := l->including(c) ; 
    l := l->including(d) ; 
    l := l->sort() ; 
    OclFile["System.out"].println(l->at(2+1) - l->at(1+1)) ; 
 ) ;  ;  ;  
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    char[] S=sc.next().toCharArray();
    char[] T=sc.next().toCharArray();
    System.out.println(possible(S,S,T)|| possible(S,T,S)? "Yes" : "No");
  }
  static boolean possible(char[] target,char[] s1,char[] s2){
    int[] pos={
      0,0 };
      for(int i=0 ; i<target.length ; i++){
        char[] s=i % 2==0 ? s1 : s2 ;
        while(pos[i % 2]<s.length && s[pos[i % 2] ]!=target[i]){
          pos[i % 2]++;
        }
        if(pos[i % 2]==s.length || s[pos[i % 2] ]!=target[i]){
          return false ;
        }
        pos[i % 2]++;
      }
      return true ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : Sequence(String) ; S := sc.getCurrent()->characters() ;
     var T : Sequence(String) ; T := sc.getCurrent()->characters() ;
     OclFile["System.out"].println(if possible(S, S, T) or possible(S, T, S) then "Yes" else "No" endif) );
  static   operation possible( target : Sequence(String), s1 : Sequence(String), s2 : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     var pos : Sequence(int) ; pos := Sequence{0,0} ;
         var i : int ; i := 0 ; while i < target->size() do ( (     var s : Sequence(String) ; s := if i mod 2 = 0 then s1 else s2 endif ;
     while (pos[i mod 2+1] < s->size() & s[pos[i mod 2+1]+1] /= target[i+1]) do (     pos[i mod 2+1] := pos[i mod 2+1] + 1 ) ; 
     if (pos[i mod 2+1] = s->size() or s[pos[i mod 2+1]+1] /= target[i+1]) then (     return false ) else skip ; 
     pos[i mod 2+1] := pos[i mod 2+1] + 1 )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[][] strs=new char[2][];
    strs[0]=sc.next().toCharArray();
    strs[1]=sc.next().toCharArray();
    loop : for(int i=0 ;
    i<=1 ;
    i++){
      int[] indexes={
        0,0 };
        int current=i ;
        for(int j=0 ; j<strs[0] .length ; j++){
          while(strs[current][indexes[current] ]!=strs[0][j]){
            indexes[current]++;
            if(indexes[current]==strs[0] .length){
              continue loop ;
            }
          }
          indexes[current]++;
          if(indexes[current]==strs[0] .length && j!=strs[0] .length-1){
            continue loop ;
          }
          current=(current+1)% 2 ;
        }
        System.out.println("Yes");
        return ;
      }
      System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var strs : Sequence(Sequence(String)) ; strs := Integer.subrange(1,2)->collect(Sequence{}) ;
    strs[0+1] := sc.getCurrent()->characters() ; 
    strs[1+1] := sc.getCurrent()->characters() ; 
        var i : int ; i := 0 ; while i <= 1 do ( (     var indexes : Sequence(int) ; indexes := Sequence{0,0} ;
     var current : int ; current := i ;
        var j : int ; j := 0 ; while j < strs[0+1]->size() do ( (     while (strs[current+1][indexes[current+1]+1] /= strs[0+1][j+1]) do (     indexes[current+1] := indexes[current+1] + 1 ; 
     if (indexes[current+1] = strs[0+1]->size()) then (     continue ) else skip ) ; 
     indexes[current+1] := indexes[current+1] + 1 ; 
     if (indexes[current+1] = strs[0+1]->size() & j /= strs[0+1]->size() - 1) then (     continue ) else skip ; 
     current := (current + 1) mod 2 )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println("Yes") ; 
    return 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("No") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A132 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char[] S=in.nextLine().toCharArray();
    int previous=0 ;
    for(int i=0 ; i<S.length ; i++){
      int number=reverse(S[i]);
      number=(reverse(previous)+256-number)% 256 ;
      System.out.println(number);
      previous=S[i];
    }
  }
  static int reverse(int number){
    int result=0 ;
    for(int i=0 ; i<8 ; i++){
      result<<=1 ;
      result |=(number & 1);
      number>>=1 ;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A132 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : Sequence(String) ; S := in.nextLine()->characters() ;
     var previous : int ; previous := 0 ;
         var i : int ; i := 0 ; while i < S->size() do ( (     var number : int ; number := reverse(S[i+1]) ;
     number := (reverse(previous) + 256 - number) mod 256 ; 
     OclFile["System.out"].println(number) ; 
     previous := S[i+1] )  ;     i := i + 1 ) );
  static   operation reverse( number : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < 8 do ( (     result := result*(2->pow(1)) ; 
     result := MathLib.bitwiseOr(result, (MathLib.bitwiseAnd(number,1))) ; 
     number := number/(2->pow(1)) )  ;     i := i + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String str=scanner.nextLine(),initial="00000000" ;
    int sub=0 ;
    for(int i=0 ; i<str.length(); ++i){
      String bi=initial+Integer.toBinaryString(str.charAt(i));
      bi=bi.substring(bi.length()-8,bi.length());
      int x=Integer.parseInt(new StringBuilder(bi).reverse().toString(),2);
      System.out.println(((sub-x)% 256+256)% 256);
      sub=x ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := scanner.nextLine() ;
    var initial : String ; initial := "00000000" ;
     var sub : int ; sub := 0 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     var bi : String ; bi := initial + (MathLib.decimal2binary(str->at(i+1)) + "") ;
     bi := bi.subrange(bi->size() - 8+1,bi->size()) ; 
    var x : int ; x := (StringLib.newString(bi)->reverse()+"")->toInteger() ;
    OclFile["System.out"].println((((sub)->char2byte() - (x)->char2byte()) mod 256 + 256) mod 256) ; 
    sub := x ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TuringTape {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] arr=sc.nextLine().toCharArray();
    int prev=0 ;
    for(char c : arr){
      StringBuilder s=new StringBuilder(Integer.toString((int)c,2));
      while(s.length()<8)s.insert(0,'0');
      s.reverse();
      int x=Integer.parseInt(s.toString(),2);
      System.out.println((prev-x+256)% 256);
      prev=x ;
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class TuringTape {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(String) ; arr := sc.nextLine()->characters() ;
    var prev : int ; prev := 0 ;
    for (c : arr) do ( (     var s : String ; s := StringLib.newString(((c->oclAsType(int)) + "")) ;
     while (s->size() < 8) do     s := s.insertAt(0+1, StringLib.newString('0')) ; ; 
    s := s->reverse() ; 
    var x : int ; x := (s+"")->toInteger() ;
    OclFile["System.out"].println((prev - (x)->char2byte() + 256) mod 256) ; 
    prev := x ; 
 )  ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      Integer[] x=new Integer[n];
      for(int i=0 ; i<n ; i++){
        x[i]=in.nextInt();
      }
      Arrays.sort(x);
      int m=n/2 ;
      int ans=Integer.MAX_VALUE ;
      for(int i=0 ; i<m ; i++){
        ans=Math.min(ans,x[i+m]-x[i]);
      }
      out.println(ans);
    }
  }
  static class InputReader {
    private StringTokenizer tokenizer ;
    private BufferedReader reader ;
    public InputReader(InputStream inputStream){
      reader=new BufferedReader(new InputStreamReader(inputStream));
    }
    private void fillTokenizer(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(Exception e){
          throw new RuntimeException(e);
        }
      }
    }
    public String next(){
      fillTokenizer();
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    x := x->sort() ; 
    var m : int ; m := n / 2 ;
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i < m do ( (     ans := Set{ans, x[i + m+1] - x[i+1]}->min() )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute tokenizer : OclIterator;
   attribute reader : OclFile;
   static operation newInputReader( inputStream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) );
   operation fillTokenizer() : void
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : ProgramException) do (     error ProgramException(e) )
 ) else skip );
   operation next() : String
  pre: true
  post: true
  activity: (     execute fillTokenizer() ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.stream.Collectors ;
public class CF949A_Zebras {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    Scanner sc=new Scanner(System.in);
    String s=reader.readLine();
    List<List<Integer>>seqList=new ArrayList<>();
    int pointer=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='0'){
        if(pointer==seqList.size()){
          List<Integer>seq=new ArrayList<>();
          seq.add(i+1);
          seqList.add(seq);
        }
        else {
          seqList.get(pointer).add(i+1);
        }
        pointer++;
      }
      else {
        if(pointer==0){
          System.out.println("-1");
          return ;
        }
        pointer--;
        seqList.get(pointer).add(i+1);
      }
    }
    if(pointer!=seqList.size()){
      System.out.println("-1");
      return ;
    }
    System.out.println(seqList.size());
    StringBuilder sb=new StringBuilder();
    for(int i=0,seqListSize=seqList.size(); i<seqListSize ; i++){
      List<Integer>list=seqList.get(i);
      writer.write(list.size()+" "+list.stream().map(String :: valueOf).collect(Collectors.joining(" ")));
      if(i<seqListSize-1){
        writer.newLine();
      }
    }
    sc.close();
    writer.flush();
    writer.close();
    reader.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF949A_Zebras {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var s : String ; s := reader.readLine() ;
    var seqList : Sequence(Sequence(int)) ; seqList := Sequence{} ;
    var pointer : int ; pointer := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '0') then (     if (pointer = seqList->size()) then (     var seq : Sequence(int) ; seq := Sequence{} ;
     seq := seq->including(i + 1) ; 
     seqList := seqList->including(seq) ) else (     seqList->at(pointer+1)->excludes(i + 1) ) ;  
     pointer := pointer + 1 ) else (     if (pointer = 0) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
     pointer := pointer - 1 ; 
     seqList->at(pointer+1)->excludes(i + 1) ) )  ;     i := i + 1 ) ; 
    if (pointer /= seqList->size()) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
    OclFile["System.out"].println(seqList->size()) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ;
    var seqListSize : int ; seqListSize := seqList->size() ; while i < seqListSize do ( (     var list : Sequence(int) ; list := seqList->at(i+1) ;
     skip ; 
     if (i < (seqListSize)->char2byte() - 1) then (     skip ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.stream.Collectors ;
public class CF949A_Zebras {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    Scanner sc=new Scanner(System.in);
    String s=reader.readLine();
    List<List<Integer>>seqList=new ArrayList<>();
    int pointer=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='0'){
        if(pointer==seqList.size()){
          List<Integer>seq=new ArrayList<>();
          seq.add(i+1);
          seqList.add(seq);
        }
        else {
          seqList.get(pointer).add(i+1);
        }
        pointer++;
      }
      else {
        if(pointer==0){
          System.out.println("-1");
          return ;
        }
        pointer--;
        seqList.get(pointer).add(i+1);
      }
    }
    if(pointer!=seqList.size()){
      System.out.println("-1");
      return ;
    }
    System.out.println(seqList.size());
    StringBuilder sb=new StringBuilder();
    for(List<Integer>list : seqList){
      sb.append(list.size()).append(" ").append(list.stream().map(String :: valueOf).collect(Collectors.joining(" ")));
      sb.append("\n");
    }
    sb.deleteCharAt(sb.length()-1);
    System.out.println(sb);
    sc.close();
    writer.flush();
    writer.close();
    reader.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF949A_Zebras {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var s : String ; s := reader.readLine() ;
    var seqList : Sequence(Sequence(int)) ; seqList := Sequence{} ;
    var pointer : int ; pointer := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '0') then (     if (pointer = seqList->size()) then (     var seq : Sequence(int) ; seq := Sequence{} ;
     seq := seq->including(i + 1) ; 
     seqList := seqList->including(seq) ) else (     seqList->at(pointer+1)->excludes(i + 1) ) ;  
     pointer := pointer + 1 ) else (     if (pointer = 0) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
     pointer := pointer - 1 ; 
     seqList->at(pointer+1)->excludes(i + 1) ) )  ;     i := i + 1 ) ; 
    if (pointer /= seqList->size()) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
    OclFile["System.out"].println(seqList->size()) ; 
    var sb : String ; sb := StringLib.newString() ;
    for (list : seqList) do ( (     sb := sb + StringLib.newString(list->size()) + StringLib.newString(" ") + StringLib.newString(list->collect( _x1 | (lambda _pars : OclAny in String.newString().valueOf(_pars))->apply(_x1) ).collect(Collectors.joining(" "))) ; 
     sb := sb + StringLib.newString("\n") )  ) ; 
    sb := sb->excludingAt(sb->size() - 1+1) ; 
    OclFile["System.out"].println(sb) ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=br.readLine();
    int A=Integer.parseInt(str.substring(0,str.indexOf(" ")));
    int B=Integer.parseInt(str.substring(str.indexOf(" ")+1,str.indexOf(" ",str.indexOf(" ")+1)));
    int C=Integer.parseInt(str.substring(str.indexOf(" ",str.indexOf(" ")+1)+1,str.indexOf(" ",str.indexOf(" ",str.indexOf(" ")+1)+1)));
    int D=Integer.parseInt(str.substring(str.indexOf(" ",str.indexOf(" ",str.indexOf(" ")+1)+1)+1));
    int E=0 ;
    if(A<C)E=C ;
    else E=A ;
    int F=0 ;
    if(B>D)F=D ;
    else F=B ;
    if(F-E<0)System.out.println("0");
    else System.out.println(F-E);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := br.readLine() ;
    var A : int ; A := (str.subrange(0+1,str->indexOf(" ")-1))->toInteger() ;
    var B : int ; B := (str.subrange(str->indexOf(" ")-1 + 1+1,str.subrange(str->indexOf(" ")-1 + 1+1)->indexOf(" "+"") + str->indexOf(" ")-1 + 1 - 1 ))->toInteger() ;
    var C : int ; C := (str.subrange(str.subrange(str->indexOf(" ")-1 + 1+1)->indexOf(" "+"") + str->indexOf(" ")-1 + 1 - 1  + 1+1,str.subrange(str.subrange(str->indexOf(" ")-1 + 1+1)->indexOf(" "+"") + str->indexOf(" ")-1 + 1 - 1  + 1+1)->indexOf(" "+"") + str.subrange(str->indexOf(" ")-1 + 1+1)->indexOf(" "+"") + str->indexOf(" ")-1 + 1 - 1  + 1 - 1 ))->toInteger() ;
    var D : int ; D := (str.subrange(str.subrange(str.subrange(str->indexOf(" ")-1 + 1+1)->indexOf(" "+"") + str->indexOf(" ")-1 + 1 - 1  + 1+1)->indexOf(" "+"") + str.subrange(str->indexOf(" ")-1 + 1+1)->indexOf(" "+"") + str->indexOf(" ")-1 + 1 - 1  + 1 - 1  + 1+1,str.subrange(str.subrange(str->indexOf(" ")-1 + 1+1)->indexOf(" "+"") + str->indexOf(" ")-1 + 1 - 1  + 1+1)->indexOf(" "+"") + str.subrange(str->indexOf(" ")-1 + 1+1)->indexOf(" "+"") + str->indexOf(" ")-1 + 1 - 1  + 1 - 1  + 1))->toInteger() ;
    var E : int ; E := 0 ;
    if (A < C) then     E := C else     E := A ; ;  
    var F : int ; F := 0 ;
    if (B > D) then     F := D else     F := B ; ;  
    if (F - E < 0) then     OclFile["System.out"].println("0") else     OclFile["System.out"].println(F - E) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void printSeries(int n){
    int[] nmtr=new int[] {
      1,1,1,3 };
      int[] dntr=new int[] {
        0,4,2,4 };
        for(int i=1 ; i<=n ; i++){
          if(i % 4==0)System.out.print(nmtr[i % 4]+(i/4)-1+" ");
          else {
            System.out.print(nmtr[i % 4]+((i/4)*dntr[i % 4])+"/"+dntr[i % 4]+" ");
          }
        }
      }
      public static void main(String[] args){
        int n=9 ;
        printSeries(n);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printSeries( n : int) : void
  pre: true
  post: true
  activity: (     var nmtr : Sequence(int) ; nmtr := Sequence{1,1,1,3} ;
     var dntr : Sequence(int) ; dntr := Sequence{0,4,2,4} ;
         var i : int ; i := 1 ; while i <= n do ( (     if (i mod 4 = 0) then     OclFile["System.out"].print(nmtr[i mod 4+1] + (i / 4) - 1 + " ") ; else (     OclFile["System.out"].print(nmtr[i mod 4+1] + ((i / 4) * dntr[i mod 4+1]) + "/" + dntr[i mod 4+1] + " ") ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     execute printSeries(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] input=br.readLine().trim().split(" ");
    int numTestCases=Integer.parseInt(input[0]);
    while(numTestCases-->0){
      input=br.readLine().trim().split(" ");
      int n=Integer.parseInt(input[0]);
      int k=Integer.parseInt(input[1]);
      int[] arr=new int[n];
      input=br.readLine().trim().split(" ");
      for(int i=0 ; i<n ; i++){
        arr[i]=Integer.parseInt(input[i]);
      }
      out.println(maxSpells(arr,k));
    }
    out.flush();
    out.close();
  }
  public static long maxSpells(int[] arr,int k){
    long ans=0 ;
    int n=arr.length ;
    Arrays.sort(arr);
    for(int i=1 ; i<n ; i++){
      int diff=k-arr[i];
      ans+=(diff/arr[0]);
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : Sequence(String) ; input := br.readLine()->trim()->split(" ") ;
    var numTestCases : int ; numTestCases := (input[0+1])->toInteger() ;
        while (numTestCases > 0) do (        numTestCases := numTestCases - 1 ;     skip ; (     input := br.readLine()->trim()->split(" ") ; 
     var n : int ; n := (input[0+1])->toInteger() ;
    var k : int ; k := (input[1+1])->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    input := br.readLine()->trim()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (input[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
 );
  static   operation maxSpells( arr : Sequence(int), k : int) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
     var n : int ; n := arr->size() ;
    arr := arr->sort() ; 
        var i : int ; i := 1 ; while i < n do ( (     var diff : int ; diff := k - arr[i+1] ;
     ans := ans+((diff / arr[0+1])) )  ;     i := i + 1 ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  final static int MAX_CHAR=26 ;
  static int countPalindrome(String str){
    int n=str.length();
    int sum=0 ;
    int hashTable[]=new int[MAX_CHAR];
    for(int i=0 ; i<n ; i++){
      hashTable[str.charAt(i)-'a']++;
    }
    for(int i=0 ; i<26 ; i++){
      if(hashTable[i]!=0){
        sum+=(hashTable[i]*(hashTable[i]+1)/2);
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    String str="ananananddd" ;
    System.out.println(countPalindrome(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX_CHAR : int := 26;
  static   operation countPalindrome( str : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var sum : int ; sum := 0 ;
    var hashTable : Sequence(int) ; hashTable := Integer.subrange(1,MAX_CHAR)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     hashTable[str->at(i+1) - ('a')->char2byte()+1] := hashTable[str->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 26 do ( (     if (hashTable[i+1] /= 0) then (     sum := sum+((hashTable[i+1] * (hashTable[i+1] + 1) / 2)) ) else skip )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "ananananddd" ;
     OclFile["System.out"].println(countPalindrome(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void calcSum(int arr[],int n,int k){
    for(int i=0 ; i<=n-k ; i++){
      int sum=0 ;
      for(int j=i ; j<k+i ; j++)sum+=arr[j];
      System.out.print(sum+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,6 };
      int n=arr.length ;
      int k=3 ;
      calcSum(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation calcSum( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= n - k do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := i ; while j < k + i do (     sum := sum+(arr[j+1]) ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].print(sum + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     execute calcSum(arr, n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GfG {
  private static String remainingDigit(String S,int N){
    char c[]=S.toCharArray();
    int del[]={
      0,0 };
      int count[]={
        0,0 };
        Queue<Integer>q=new LinkedList<>();
        for(int i=0 ; i<N ; i++){
          int x=c[i]=='1' ? 1 : 0 ;
          count[x]++;
          q.add(x);
        }
        while(count[0]>0 && count[1]>0){
          int t=q.poll();
          if(del[t]>0){
            del[t]--;
            count[t]--;
          }
          else {
            del[t ^ 1]++;
            q.add(t);
          }
        }
        if(count[0]>0)return "0" ;
        return "1" ;
      }
      public static void main(String args[]){
        String S="1010100100000" ;
        int N=S.length();
        System.out.print(remainingDigit(S,N));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation remainingDigit( S : String, N : int) : String
  pre: true
  post: true
  activity: (     var c : Sequence(String) ; c := S->characters() ;
     var del : Sequence(int) ; del := Sequence{0,0} ;
    var count : Sequence(int) ; count := Sequence{0,0} ;
    var q : Sequence(int) ; q := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var x : int ; x := if c[i+1] = '1' then 1 else 0 endif ;
     count[x+1] := count[x+1] + 1 ; 
     q := q->including(x) )  ;     i := i + 1 ) ; 
    while (count[0+1] > 0 & count[1+1] > 0) do (     var t : int ; t := q->min() ;
     if (del[t+1] > 0) then (     del[t+1] := del[t+1] - 1 ; 
     count[t+1] := count[t+1] - 1 ) else (     del[MathLib.bitwiseXor(t,1)+1] := del[MathLib.bitwiseXor(t,1)+1] + 1 ; 
     q := q->including(t) ) ) ; 
    if (count[0+1] > 0) then     return "0" else skip ; 
    return "1" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := "1010100100000" ;
     var N : int ; N := S->size() ;
     OclFile["System.out"].print(remainingDigit(S, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p112 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p112().run());
  }
  public String run(){
    int bouncy=0 ;
    for(int i=1 ; ; i++){
      if(isBouncy(i))bouncy++;
      if(bouncy*100==i*99)return Integer.toString(i);
    }
  }
  private static boolean isBouncy(int x){
    if(x<100)return false ;
    else {
      boolean nonincreasing=true ;
      boolean nondecreasing=true ;
      int lastDigit=x % 10 ;
      x/=10 ;
      while(x!=0){
        int digit=x % 10 ;
        if(digit>lastDigit)nondecreasing=false ;
        else if(digit<lastDigit)nonincreasing=false ;
        lastDigit=digit ;
        x/=10 ;
      }
      return ! nonincreasing && ! nondecreasing ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class p112 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p112.newp112().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var bouncy : int ; bouncy := 0 ;
         var i : int ; i := 1 ; while true do ( (     if (isBouncy(i)) then     bouncy := bouncy + 1 ; else skip ; 
     if (bouncy * 100 = i * 99) then     return ((i) + "") else skip )  ;     i := i + 1 ) );
  static   operation isBouncy( x : int) : boolean
  pre: true
  post: true
  activity: (     if (x < 100) then     return false else (     var nonincreasing : boolean ; nonincreasing := true ;
     var nondecreasing : boolean ; nondecreasing := true ;
    var lastDigit : int ; lastDigit := x mod 10 ;
    x := x/(10) ; 
    while (x /= 0) do (     var digit : int ; digit := x mod 10 ;
     if (digit > lastDigit) then     nondecreasing := false else     if (digit < lastDigit) then     nonincreasing := false ; else skip ; ;  
     lastDigit := digit ; 
     x := x/(10) ) ; 
    return not(nonincreasing) & not(nondecreasing) 
 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    try {
      InputStreamReader isr=new InputStreamReader(System.in);
      BufferedReader br=new BufferedReader(isr);
      String line ;
      while((line=br.readLine())!=null){
        int n=Integer.parseInt(line);
        int x=1 ;
        boolean flag=true ;
        while(n!=0){
          if(n % 2==1){
            if(flag){
              System.out.print(x);
              flag=false ;
            }
            else {
              System.out.print(" "+x);
            }
          }
          n/=2 ;
          x*=2 ;
        }
        System.out.println();
      }
    }
    catch(java.lang.NumberFormatException e){
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     var n : int ; n := (line)->toInteger() ;
     var x : int ; x := 1 ;
    var flag : boolean ; flag := true ;
    while (n /= 0) do (     if (n mod 2 = 1) then (     if (flag) then (     OclFile["System.out"].print(x) ; 
     flag := false ) else (     OclFile["System.out"].print(" " + x) ) ) else skip ; 
     n := n/(2) ; 
     x := x*(2) ) ; 
    OclFile["System.out"].println() ; 
 ) ;     line := br.readLine() ;
 ) )   catch (e : IncorrectElementException) do (     OclFile["System.out"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int[] vals=new int[N];
    for(int i=0 ; i<N ; i++)vals[i]=in.nextInt();
    Arrays.sort(vals);
    if(N==2){
      System.out.println(vals[1]-vals[0]);
      return ;
    }
    int interval=N/2 ;
    int min1=0 ;
    int min2=0 ;
    int min=0 ;
    for(int i=0 ; i+interval<N ; i++){
      if(min==0 || vals[i+interval]-vals[i]<min){
        min1=i ;
        min2=i+interval ;
        min=vals[i+interval]-vals[i];
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var vals : Sequence(int) ; vals := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     vals[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    vals := vals->sort() ; 
    if (N = 2) then (     OclFile["System.out"].println(vals[1+1] - vals[0+1]) ; 
     return ) else skip ; 
    var interval : int ; interval := N / 2 ;
    var min1 : int ; min1 := 0 ;
    var min2 : int ; min2 := 0 ;
    var min : int ; min := 0 ;
        var i : int ; i := 0 ; while i + interval < N do ( (     if (min = 0 or vals[i + interval+1] - vals[i+1] < min) then (     min1 := i ; 
     min2 := i + interval ; 
     min := vals[i + interval+1] - vals[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
public class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String line ;
      while((line=br.readLine())!=null){
        if(line.equals(""))break ;
        String[] splited=line.split(" ");
        int n=Integer.parseInt(splited[0]);
        int grams[]=new int[10];
        String str="" ;
        for(int i=0 ; i<10 ; i++){
          grams[i]=n % 2 ;
          n/=2 ;
          if(grams[i]==1)str+=(int)Math.pow(2,i)+" " ;
        }
        str=str.trim();
        System.out.println(str);
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line = "") then     break else skip ; 
     var splited : Sequence(String) ; splited := line->split(" ") ;
    var n : int ; n := (splited[0+1])->toInteger() ;
    var grams : Sequence(int) ; grams := Integer.subrange(1,10)->collect(0) ;
    var str : String ; str := "" ;
        var i : int ; i := 0 ; while i < 10 do ( (     grams[i+1] := n mod 2 ; 
     n := n/(2) ; 
     if (grams[i+1] = 1) then     str := str+(2->pow(i)->oclAsType(int) + " ") ; else skip )  ;     i := i + 1 ) ; 
    str := str->trim() ; 
    OclFile["System.out"].println(str) ; 
 ) ;     line := br.readLine() ;
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
class Main {
  String Name ;
  int SV ;
  int EV ;
  boolean T ;
  Main(String Name,int SV,int EV,boolean T){
    this.Name=Name ;
    this.SV=SV ;
    this.EV=EV ;
    this.T=T ;
  }
  public static void main(String[] args)throws IOException {
    Scanner Input=new Scanner(System.in);
    int A=Input.nextInt();
    int B=Input.nextInt();
    Main B1=new Main("B1",A,B,false);
    int C=Input.nextInt();
    int D=Input.nextInt();
    Main B2=new Main("B2",C,D,false);
    int Count=0 ;
    for(int I=0 ; I<=100 ; I++){
      if(I==B1.SV){
        B1.T=true ;
      }
      if(I==B2.SV){
        B2.T=true ;
      }
      if(I==B1.EV){
        B1.T=false ;
      }
      if(I==B2.EV){
        B2.T=false ;
      }
      if(B1.T && B2.T){
        Count++;
      }
    }
    System.out.println(Count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute Name : String;
   attribute SV : int;
   attribute EV : int;
   attribute T : boolean;
   static operation newMain( Name : String, SV : int, EV : int, T : boolean) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(Name, SV,EV,T);
    return self );
  operation initialise( Name : String, SV : int, EV : int, T : boolean) : void
  pre: true  post: true
  activity: (     self.Name := Name ; 
     self.SV := SV ; 
     self.EV := EV ; 
     self.T := T );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Input : OclFile ; Input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := Input.getCurrent()->toInteger() ;
    var B : int ; B := Input.getCurrent()->toInteger() ;
    var B1 : Main ; B1 := Main.newMain("B1", A, B, false) ;
    var C : int ; C := Input.getCurrent()->toInteger() ;
    var D : int ; D := Input.getCurrent()->toInteger() ;
    var B2 : Main ; B2 := Main.newMain("B2", C, D, false) ;
    var Count : int ; Count := 0 ;
        var I : int ; I := 0 ; while I <= 100 do ( (     if (I = B1.SV) then (     B1.T := true ) else skip ; 
     if (I = B2.SV) then (     B2.T := true ) else skip ; 
    if (I = B1.EV) then (     B1.T := false ) else skip ; 
    if (I = B2.EV) then (     B2.T := false ) else skip ; 
    if (B1.T & B2.T) then (     Count := Count + 1 ) else skip ; 
 )  ;     I := I + 1 ) ; 
    OclFile["System.out"].println(Count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Stack ;
public class Main {
  Stack<Integer>stack=new Stack<Integer>();
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      if(! sc.hasNext()){
        break ;
      }
      int a=sc.nextInt();
      int[] b={
        1,2,4,8,16,32,64,128,256,512 };
        solve(a,b,b.length-1);
        StringBuilder sb=new StringBuilder();
        while(! stack.empty()){
          sb.append(stack.pop()+" ");
        }
        System.out.println(sb.deleteCharAt(sb.length()-1));
      }
    }
    void solve(int a,int[] b,int i){
      if(a>=b[i] && a!=0){
        a-=b[i];
        stack.push(b[i]);
      }
      if(i!=0){
        solve(a,b,--i);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute stack : Sequence(int) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     if (not(sc.hasNext())) then (     break ) else skip ; 
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Sequence{1,2,4,8,16,32,64,128,256,512} ;
    execute solve(a, b, b->size() - 1) ; 
    var sb : String ; sb := StringLib.newString() ;
    while (not(stack->isEmpty())) do (     sb := sb + StringLib.newString(stack->last() + " ") ) ; 
    OclFile["System.out"].println(sb->excludingAt(sb->size() - 1+1)) ; 
 ) );
   operation solve( a : int, b : Sequence(int), i : int) : void
  pre: true
  post: true
  activity: (     if (a >= b[i+1] & a /= 0) then (     a := a-(b[i+1]) ; 
     stack := stack->append(b[i+1]) ) else skip ; 
     if (i /= 0) then (     execute solve(a, b, (i - 1)) ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.BufferedReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s ;
    while((s=br.readLine())!=null){
      String binary=Integer.toBinaryString(Integer.parseInt(s));
      int n=binary.length();
      for(int i=n-1 ; i>0 ; i--){
        if(binary.charAt(i)=='0')continue ;
        System.out.print((int)Math.pow(2,n-i-1)+" ");
      }
      char last=binary.charAt(0);
      System.out.print(Integer.parseInt(last+"")*(int)Math.pow(2,n-1));
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ;
         s := br.readLine() ;
    while ((s) /= null) do (    skip ; (     var binary : String ; binary := (MathLib.decimal2binary((s)->toInteger()) + "") ;
     var n : int ; n := binary->size() ;
        var i : int ; i := (n)->char2byte() - 1 ; while i > 0 do ( (     if (binary->at(i+1) = '0') then     continue else skip ; 
     OclFile["System.out"].print(2->pow((n)->char2byte() - i - 1)->oclAsType(int) + " ") )  ;     i := i - 1 ) ; 
    var last : String ; last := binary->at(0+1) ;
    OclFile["System.out"].print((last + "")->toInteger() * 2->pow((n)->char2byte() - 1)->oclAsType(int)) ; 
    OclFile["System.out"].println() ; 
 ) ;     s := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int num,idx=0 ;
  static int dfs(int pos,int[] weight){
    int ret=0 ;
    if(pos>=weight.length)return(0);
    ret+=dfs(pos+1,weight);
    if(num-weight[pos]>=0){
      num-=weight[pos];
      ret+=weight[pos];
    }
    return(ret);
  }
  static int len(int[] array){
    int len=0 ;
    for(int r=0 ; r<10 ; r++){
      if(array[r]==0)break ;
      len++;
    }
    return(len);
  }
  static void input(int numeric,int[] weight,int[] input){
    int count=0 ;
    for(int r=9 ; r>=0 ; r--){
      int minus=weight[r];
      if(numeric-minus>=0){
        input[count++]=minus ;
        numeric-=minus ;
      }
    }
  }
  static void output(int[] output){
    int len=len(output);
    for(int r=len-1 ; r>=0 ; r--){
      System.out.print(output[r]);
      if(r!=0)System.out.print(" ");
    }
  }
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int[] weight={
      1,2,4,8,16,32,64,128,256,512 };
      while(stdIn.hasNext()){
        int[] output=new int[10];
        num=stdIn.nextInt();
        input(dfs(0,weight),weight,output);
        output(output);
        System.out.println();
        idx=0 ;
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute num : int;
  static   operation dfs( pos : int, weight : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
     if (pos >= weight->size()) then     return (0) else skip ; 
    ret := ret+(dfs(pos + 1, weight)) ; 
    if (num - weight[pos+1] >= 0) then (     num := num-(weight[pos+1]) ; 
     ret := ret+(weight[pos+1]) ) else skip ; 
    return (ret) 
 );
  static   operation len( array : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var len : int ; len := 0 ;
         var r : int ; r := 0 ; while r < 10 do ( (     if (array[r+1] = 0) then     break else skip ; 
     len := len + 1 )  ;     r := r + 1 ) ; 
     return (len) );
  static   operation input( numeric : int, weight : Sequence(int), input : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var r : int ; r := 9 ; while r >= 0 do ( (     var minus : int ; minus := weight[r+1] ;
     if (numeric - minus >= 0) then (      input[count+1] := minus  ; count := count + 1 ; 
     numeric := numeric-(minus) ) else skip )  ;     r := r - 1 ) );
  static   operation output( output : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var len : int ; len := len(output) ;
         var r : int ; r := len - 1 ; while r >= 0 do ( (     OclFile["System.out"].print(output[r+1]) ; 
     if (r /= 0) then     OclFile["System.out"].print(" ") ; else skip )  ;     r := r - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var weight : Sequence(int) ; weight := Sequence{1,2,4,8,16,32,64,128,256,512} ;
     while (stdIn.hasNext()) do (     var output : Sequence(int) ; output := Integer.subrange(1,10)->collect(0) ;
     num := stdIn.getCurrent()->toInteger() ; 
    execute input(dfs(0, weight), weight, output) ; 
    execute output(output) ; 
    OclFile["System.out"].println() ; 
    idx := 0 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class CircleLine {
  public static void main(String[] args)throws NumberFormatException,IOException {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(is);
    int n=Integer.parseInt(br.readLine());
    String[] nums=br.readLine().split(" ");
    String[] stations=br.readLine().split(" ");
    int a=Integer.parseInt(stations[0]);
    int b=Integer.parseInt(stations[1]);
    int l=Math.min(a,b);
    int r=Math.max(a,b);
    int seq_sum=0 ;
    int tot_sum=0 ;
    for(int i=0 ; i<nums.length ; i++){
      int x=Integer.parseInt(nums[i]);
      if(i>=l-1 && i<r-1){
        seq_sum+=x ;
      }
      tot_sum+=x ;
    }
    System.out.println(Math.min(seq_sum,tot_sum-seq_sum));
  }
}
------------------------------------------------------------
OCL File:
---------
 class CircleLine {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(is) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var nums : Sequence(String) ; nums := br.readLine()->split(" ") ;
    var stations : Sequence(String) ; stations := br.readLine()->split(" ") ;
    var a : int ; a := (stations[0+1])->toInteger() ;
    var b : int ; b := (stations[1+1])->toInteger() ;
    var l : int ; l := Set{a, b}->min() ;
    var r : int ; r := Set{a, b}->max() ;
    var seq_sum : int ; seq_sum := 0 ;
    var tot_sum : int ; tot_sum := 0 ;
        var i : int ; i := 0 ; while i < nums->size() do ( (     var x : int ; x := (nums[i+1])->toInteger() ;
     if (i >= l - 1 & i < r - 1) then (     seq_sum := seq_sum+(x) ) else skip ; 
     tot_sum := tot_sum+(x) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{seq_sum, tot_sum - seq_sum}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Hackerrank {
  public static void main(String[] args){
    Scanner sc1=new Scanner(System.in);
    int n=sc1.nextInt();
    int arr[]=new int[n+1];
    int total=0 ;
    for(int i=1 ; i<=n ; i++){
      int temp=sc1.nextInt();
      total+=temp ;
      arr[i]=temp ;
    }
    int s=sc1.nextInt();
    int t=sc1.nextInt();
    int index=s ;
    int m1=0 ;
    while(index+1!=t){
      index=s %(n+1);
      m1+=arr[index];
      s++;
    }
    System.out.println(Math.min(m1,total-m1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hackerrank {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc1 : OclFile ; sc1 := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc1.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
    var total : int ; total := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var temp : int ; temp := sc1.getCurrent()->toInteger() ;
     total := total+(temp) ; 
     arr[i+1] := temp )  ;     i := i + 1 ) ; 
    var s : int ; s := sc1.getCurrent()->toInteger() ;
    var t : int ; t := sc1.getCurrent()->toInteger() ;
    var index : int ; index := s ;
    var m1 : int ; m1 := 0 ;
    while (index + 1 /= t) do (     index := s mod (n + 1) ; 
     m1 := m1+(arr[index+1]) ; 
     s := s + 1 ) ; 
    OclFile["System.out"].println(Set{m1, total - m1}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Hackerrank {
  public static void main(String[] args){
    Scanner sc1=new Scanner(System.in);
    int n=sc1.nextInt();
    int arr[]=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      arr[i]=sc1.nextInt();
    }
    int s=sc1.nextInt();
    int t=sc1.nextInt();
    int s1=s ;
    int m1=0 ;
    int index1=s ;
    while((index1+1)!=t){
      index1=s %(n+1);
      m1+=arr[index1];
      s++;
    }
    int m2=0 ;
    int index2=(t-1);
    while((index2+1)!=s1){
      index2=t %(n+1);
      m2+=arr[index2];
      t++;
    }
    sc1.close();
    System.out.println(Math.min(m1,m2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hackerrank {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc1 : OclFile ; sc1 := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc1.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc1.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var s : int ; s := sc1.getCurrent()->toInteger() ;
    var t : int ; t := sc1.getCurrent()->toInteger() ;
    var s1 : int ; s1 := s ;
    var m1 : int ; m1 := 0 ;
    var index1 : int ; index1 := s ;
    while ((index1 + 1) /= t) do (     index1 := s mod (n + 1) ; 
     m1 := m1+(arr[index1+1]) ; 
     s := s + 1 ) ; 
    var m2 : int ; m2 := 0 ;
    var index2 : int ; index2 := (t - 1) ;
    while ((index2 + 1) /= s1) do (     index2 := t mod (n + 1) ; 
     m2 := m2+(arr[index2+1]) ; 
     t := t + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(Set{m1, m2}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class serious {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] s=br.readLine().split(" ");
    int[] stn=new int[n];
    int sum=0 ;
    int[] pre=new int[n];
    for(int i=0 ; i<n ; i++){
      stn[i]=Integer.parseInt(s[i]);
      pre[i]=sum ;
      sum+=stn[i];
    }
    s=br.readLine().split(" ");
    int start=Integer.parseInt(s[0]);
    int end=Integer.parseInt(s[1]);
    int ans=Math.min(Math.abs(pre[end-1]-pre[start-1]),sum-Math.abs(pre[end-1]-pre[start-1]));
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class serious {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var s : Sequence(String) ; s := br.readLine()->split(" ") ;
    var stn : Sequence(int) ; stn := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
    var pre : Sequence(int) ; pre := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     stn[i+1] := (s[i+1])->toInteger() ; 
     pre[i+1] := sum ; 
     sum := sum+(stn[i+1]) )  ;     i := i + 1 ) ; 
    s := br.readLine()->split(" ") ; 
    var start : int ; start := (s[0+1])->toInteger() ;
    var end : int ; end := (s[1+1])->toInteger() ;
    var ans : int ; ans := Set{if pre[end - 1+1] - pre[start - 1+1] < 0 then -(pre[end - 1+1] - pre[start - 1+1]) else pre[end - 1+1] - pre[start - 1+1] endif, sum - if pre[end - 1+1] - pre[start - 1+1] < 0 then -(pre[end - 1+1] - pre[start - 1+1]) else pre[end - 1+1] - pre[start - 1+1] endif}->min() ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt(),b=sc.nextInt(),c=sc.nextInt(),ans=3 ;
    if(a==b)ans--;
    if(b==c)ans--;
    if(a==c)ans--;
    if((a==b)&&(b==c)&&(a==c))ans++;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 3 ;
    if (a = b) then     ans := ans - 1 ; else skip ; 
    if (b = c) then     ans := ans - 1 ; else skip ; 
    if (a = c) then     ans := ans - 1 ; else skip ; 
    if ((a = b) & (b = c) & (a = c)) then     ans := ans + 1 ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Integer tmp[]=new Integer[n];
    for(int i=0 ; i<n ; i++)tmp[i]=sc.nextInt();
    Arrays.sort(tmp);
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=tmp[i];
    int res=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(i+n/2>=n)break ;
      res=Math.min(res,arr[i+n/2]-arr[i]);
    }
    System.out.println(res);
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(FileReader f){
      br=new BufferedReader(f);
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var tmp : Sequence(int) ; tmp := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     tmp[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    tmp := tmp->sort() ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := tmp[i+1] ;  ;     i := i + 1 ) ; 
    var res : int ; res := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i + n / 2 >= n) then     break else skip ; 
     res := Set{res, arr[i + n / 2+1] - arr[i+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( f : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(f) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do skip
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.Math.*;
import static java.lang.System.*;
public class Main {
  public static int M=5 ;
  public static void main(String[] args){
    int i,j,k ;
    Scanner sc=new Scanner(in);
    int n=parseInt(sc.next());
    char[] s=null ;
    long[] ma=new long[M];
    for(i=0 ; i<n ; i++){
      s=sc.next().toCharArray();
      switch(s[0]){
        case 'M' : ma[0]++;
        break ;
        case 'A' : ma[1]++;
        break ;
        case 'R' : ma[2]++;
        break ;
        case 'C' : ma[3]++;
        break ;
        case 'H' : ma[4]++;
        break ;
      }
    }
    sc.close();
    long ans=0L ;
    for(i=0 ; i<M-2 ; i++){
      for(j=i+1 ; j<M-1 ; j++){
        for(k=j+1 ; k<M ; k++){
          ans+=ma[i]*ma[j]*ma[k];
        }
      }
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute M : int := 5;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var k : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
    var n : int ; n := parseInt(sc.getCurrent()) ;
    var s : Sequence(String) ; s := null ;
    var ma : Sequence(long) ; ma := Integer.subrange(1,M)->collect(0) ;
        i := 0 ; while i < n do ( (     s := sc.getCurrent()->characters() ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (s[0+1]) ; 
       if _switchval = 'M' then
     ma[0+1] := ma[0+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 'A' then
     ma[1+1] := ma[1+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 'R' then
     ma[2+1] := ma[2+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 'C' then
     ma[3+1] := ma[3+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 'H' then
     ma[4+1] := ma[4+1] + 1 ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : long ; ans := 0L ;
        i := 0 ; while i < M - 2 do ( (         j := i + 1 ; while j < M - 1 do ( (         k := j + 1 ; while k < M do ( (     ans := ans+(ma[i+1] * ma[j+1] * ma[k+1]) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] A=new int[2];
    int[] B=new int[2];
    int max_low=0 ;
    int min_high=0 ;
    A[0]=sc.nextInt();
    A[1]=sc.nextInt();
    B[0]=sc.nextInt();
    B[1]=sc.nextInt();
    max_low=Math.max(A[0],B[0]);
    min_high=Math.min(A[1],B[1]);
    if(max_low>min_high)System.out.println("0");
    else System.out.println(min_high-max_low);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : Sequence(int) ; A := Integer.subrange(1,2)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,2)->collect(0) ;
    var max_low : int ; max_low := 0 ;
    var min_high : int ; min_high := 0 ;
    A[0+1] := sc.getCurrent()->toInteger() ; 
    A[1+1] := sc.getCurrent()->toInteger() ; 
    B[0+1] := sc.getCurrent()->toInteger() ; 
    B[1+1] := sc.getCurrent()->toInteger() ; 
    max_low := Set{A[0+1], B[0+1]}->max() ; 
    min_high := Set{A[1+1], B[1+1]}->min() ; 
    if (max_low > min_high) then     OclFile["System.out"].println("0") else     OclFile["System.out"].println(min_high - max_low) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] ss0=br.readLine().trim().split(" ",0);
    int a=Integer.parseInt(ss0[0]);
    int b=Integer.parseInt(ss0[1]);
    int c=Integer.parseInt(ss0[2]);
    int iCount=0 ;
    if(a!=b){
      iCount=iCount+1 ;
    }
    if(a!=c){
      iCount=iCount+1 ;
    }
    if(b!=c){
      iCount=iCount+1 ;
    }
    if(iCount==0){
      iCount=1 ;
    }
    System.out.print(iCount);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var ss0 : Sequence(String) ; ss0 := br.readLine()->trim()->split(" ") ;
    var a : int ; a := (ss0[0+1])->toInteger() ;
    var b : int ; b := (ss0[1+1])->toInteger() ;
    var c : int ; c := (ss0[2+1])->toInteger() ;
    var iCount : int ; iCount := 0 ;
    if (a /= b) then (     iCount := iCount + 1 ) else skip ; 
    if (a /= c) then (     iCount := iCount + 1 ) else skip ; 
    if (b /= c) then (     iCount := iCount + 1 ) else skip ; 
    if (iCount = 0) then (     iCount := 1 ) else skip ; 
    OclFile["System.out"].print(iCount) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
import java.util.Set ;
class Main {
  public static void main(String[] args)throws Exception {
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String[] dailyColors=br.readLine().split("\\s");
      int sizeOfColorList=getSizeOfColorList(dailyColors);
      System.out.println(sizeOfColorList);
    }
    catch(IOException | NumberFormatException e){
      e.printStackTrace();
      System.exit(0);
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(0);
    }
  }
  public static int getSizeOfColorList(String[] dailyColors){
    Set<String>colorList=new HashSet<>();
    for(String color : dailyColors){
      colorList.add(color);
    }
    return colorList.size();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var dailyColors : Sequence(String) ; dailyColors := br.readLine()->split("\\s") ;
     var sizeOfColorList : int ; sizeOfColorList := getSizeOfColorList(dailyColors) ;
     OclFile["System.out"].println(sizeOfColorList) )   catch (e : OclException) do (     e.printStackTrace() ; 
 OclProcess.exit(0) )
   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(0) )
 );
  static   operation getSizeOfColorList( dailyColors : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var colorList : Set(String) ; colorList := Set{} ;
     for (color : dailyColors) do ( (     colorList := colorList->including(color) )  ) ; 
     return colorList->size() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int[] pen=new int[3];
    for(int i=0 ; i<3 ; i++){
      pen[i]=stdIn.nextInt();
    }
    int cnt=3 ;
    if(pen[0]==pen[1]){
      cnt--;
    }
    if(pen[1]==pen[2]){
      cnt--;
    }
    if(pen[0]==pen[2]){
      cnt--;
    }
    if(pen[0]==pen[1] && pen[1]==pen[2]){
      System.out.println(1);
      System.exit(0);
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pen : Sequence(int) ; pen := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     pen[i+1] := stdIn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 3 ;
    if (pen[0+1] = pen[1+1]) then (     cnt := cnt - 1 ) else skip ; 
    if (pen[1+1] = pen[2+1]) then (     cnt := cnt - 1 ) else skip ; 
    if (pen[0+1] = pen[2+1]) then (     cnt := cnt - 1 ) else skip ; 
    if (pen[0+1] = pen[1+1] & pen[1+1] = pen[2+1]) then (     OclFile["System.out"].println(1) ; 
 OclProcess.exit(0) ) else skip ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static void printNumbers(int arr[],int n){
    Arrays.sort(arr);
    int A=arr[n-1],B=-1 ;
    for(int i=n-2 ; i>=0 ; i--){
      if(A % arr[i]!=0){
        B=arr[i];
        break ;
      }
      if(i-1>=0 && arr[i]==arr[i-1]){
        B=arr[i];
        break ;
      }
    }
    System.out.print("A="+A+",B="+B);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,4,8,16,1,2,4 };
      int n=arr.length ;
      printNumbers(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation printNumbers( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var A : int ; A := arr[n - 1+1] ;
    var B : int ; B := -1 ;
         var i : int ; i := n - 2 ; while i >= 0 do ( (     if (A mod arr[i+1] /= 0) then (     B := arr[i+1] ; 
     break ) else skip ; 
     if (i - 1 >= 0 & arr[i+1] = arr[i - 1+1]) then (     B := arr[i+1] ; 
     break ) else skip )  ;     i := i - 1 ) ; 
     OclFile["System.out"].print("A=" + A + ",B=" + B) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,4,8,16,1,2,4} ;
     var n : int ; n := arr->size() ;
     execute printNumbers(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      int m=scanner.nextInt();
      int p=scanner.nextInt();
      if((n | m | p)==0)break ;
      m--;
      int[] x=new int[n];
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        x[i]=scanner.nextInt();
        sum+=x[i];
      }
      System.out.println(x[m]==0 ? 0 :(100-p)*sum/x[m]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
    var p : int ; p := scanner.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(n,m),p)) = 0) then     break else skip ; 
    m := m - 1 ; 
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := scanner.getCurrent()->toInteger() ; 
     sum := sum+(x[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if x[m+1] = 0 then 0 else (100 - p) * sum / x[m+1] endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
class Main {
  public static Scanner sc=new Scanner(in);
  public static Random rand=new Random();
  public void run(){
    while(true){
      int n=sc.nextInt(),m=sc.nextInt(),p=sc.nextInt();
      if(n==0 && m==0 && p==0)return ;
      int[] x=nextIntArray(n);
      int sum=0,winner=x[m-1];
      for(int i=0 ; i<n ; i++){
        sum+=x[i];
      }
      ln(winner==0 ? 0 : sum*(100-p)/winner);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  public int[] nextIntArray(int n){
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=sc.nextInt();
    }
    return res ;
  }
  public static void pr(Object o){
    out.print(o);
  }
  public static void ln(Object o){
    out.println(o);
  }
  public static void ln(){
    out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(in);
  static   attribute rand : OclRandom := OclRandom.newOclRandom();
   operation run() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
     if (n = 0 & m = 0 & p = 0) then     return else skip ; 
    var x : Sequence(int) ; x := nextIntArray(n) ;
    var sum : int ; sum := 0 ;
    var winner : int ; winner := x[m - 1+1] ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(x[i+1]) )  ;     i := i + 1 ) ; 
    execute ln(if winner = 0 then 0 else sum * (100 - p) / winner endif) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return res );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     out.println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class GFG {
  static int minOperations(int[] a,int n,int k){
    HashMap<Integer,Boolean>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(map.containsKey(a[i])&& map.get(a[i]))return 0 ;
      map.put(a[i],true);
    }
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++)b[i]=a[i] ^ k ;
    map.clear();
    for(int i=0 ; i<n ; i++){
      if(a[i]!=b[i])map.put(b[i],true);
    }
    for(int i=0 ; i<n ; i++)if(map.containsKey(a[i])&& map.get(a[i]))return 1 ;
    map.clear();
    for(int i=0 ; i<n ; i++){
      if(map.containsKey(b[i])&& map.get(b[i]))return 2 ;
      map.put(b[i],true);
    }
    return-1 ;
  }
  public static void main(String[] args){
    int K=3 ;
    int[] a={
      1,9,4,3 };
      int n=a.length ;
      System.out.println(minOperations(a,n,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minOperations( a : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var map : Map(int,Boolean) ; map := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (map->keys()->includes(a[i+1]) & map->at(a[i+1])) then     return 0 else skip ; 
     map := map->union(Map{a[i+1] |-> true}) )  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     b[i+1] := a[i+1] xor k ;  ;     i := i + 1 ) ; 
    map := map->intersection(Map{}) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] /= b[i+1]) then     map := map->union(Map{b[i+1] |-> true}) ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     if (map->keys()->includes(a[i+1]) & map->at(a[i+1])) then     return 1 else skip ;  ;     i := i + 1 ) ; 
    map := map->intersection(Map{}) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (map->keys()->includes(b[i+1]) & map->at(b[i+1])) then     return 2 else skip ; 
     map := map->union(Map{b[i+1] |-> true}) )  ;     i := i + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var K : int ; K := 3 ;
     var a : Sequence(int) ; a := Sequence{1,9,4,3} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(minOperations(a, n, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void calculate(int a[],int b[],int n,int m){
    int mul=1 ;
    for(int i=0 ; i<m ; i++)if(b[i]!=0)mul=mul*b[i];
    for(int i=0 ; i<n ; i++){
      int x=(int)Math.floor(a[i]/mul);
      System.out.print(x+" ");
    }
  }
  public static void main(String[] args){
    int a[]={
      5,100,8 };
      int b[]={
        2,3 };
        int n=a.length ;
        int m=b.length ;
        calculate(a,b,n,m);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculate( a : Sequence(int), b : Sequence(int), n : int, m : int) : void
  pre: true
  post: true
  activity: (     var mul : int ; mul := 1 ;
         var i : int ; i := 0 ; while i < m do (     if (b[i+1] /= 0) then     mul := mul * b[i+1] ; else skip ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := (a[i+1] / mul)->floor()->oclAsType(int) ;
     OclFile["System.out"].print(x + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{5,100,8} ;
     var b : Sequence(int) ; b := Sequence{2,3} ;
    var n : int ; n := a->size() ;
    var m : int ; m := b->size() ;
    execute calculate(a, b, n, m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    boolean[] isRights=new boolean[n];
    for(int i=0 ; i<n ; i++){
      isRights[i]=(sc.nextInt()==0);
    }
    PriorityQueue<Integer>rights=new PriorityQueue<>();
    PriorityQueue<Integer>lefts=new PriorityQueue<>();
    for(int i=0 ; i<n ; i++){
      if(isRights[i]){
        rights.add(sc.nextInt());
      }
      else {
        lefts.add(sc.nextInt());
      }
    }
    if(rights.size()==0 || lefts.size()==0){
      System.out.println(0);
    }
    else {
      System.out.println(rights.peek()+lefts.peek());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var isRights : Sequence(boolean) ; isRights := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     isRights[i+1] := (sc.getCurrent()->toInteger() = 0) )  ;     i := i + 1 ) ; 
    var rights : Sequence(int) ; rights := Sequence{} ;
    var lefts : Sequence(int) ; lefts := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (isRights[i+1]) then (     rights := rights->including(sc.getCurrent()->toInteger()) ) else (     lefts := lefts->including(sc.getCurrent()->toInteger()) ) )  ;     i := i + 1 ) ; 
    if (rights->size() = 0 or lefts->size() = 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(rights->min() + lefts->min()) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class GFG {
  public static int minOperations(int[] a,int n,int K){
    HashMap<Integer,Boolean>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(map.containsKey(a[i]))return 0 ;
      map.put(a[i],true);
    }
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++)b[i]=a[i] | K ;
    map.clear();
    for(int i=0 ; i<n ; i++){
      if(a[i]!=b[i])map.put(b[i],true);
    }
    for(int i=0 ; i<n ; i++){
      if(map.containsKey(a[i]))return 1 ;
    }
    map.clear();
    for(int i=0 ; i<n ; i++){
      if(map.containsKey(b[i]))return 2 ;
      map.put(b[i],true);
    }
    return-1 ;
  }
  public static void main(String[] args){
    int K=3 ;
    int[] a={
      1,9,4,3 };
      int n=a.length ;
      System.out.println(minOperations(a,n,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minOperations( a : Sequence(int), n : int, K : int) : int
  pre: true
  post: true
  activity: (     var map : Map(int,Boolean) ; map := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (map->keys()->includes(a[i+1])) then     return 0 else skip ; 
     map := map->union(Map{a[i+1] |-> true}) )  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     b[i+1] := a[i+1] or K ;  ;     i := i + 1 ) ; 
    map := map->intersection(Map{}) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] /= b[i+1]) then     map := map->union(Map{b[i+1] |-> true}) ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (map->keys()->includes(a[i+1])) then     return 1 else skip )  ;     i := i + 1 ) ; 
    map := map->intersection(Map{}) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (map->keys()->includes(b[i+1])) then     return 2 else skip ; 
     map := map->union(Map{b[i+1] |-> true}) )  ;     i := i + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var K : int ; K := 3 ;
     var a : Sequence(int) ; a := Sequence{1,9,4,3} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(minOperations(a, n, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long spellsCount(String num){
    int n=num.length();
    long result=1 ;
    for(int i=0 ; i<n ; i++){
      int count=1 ;
      while(i<n-1 && num.charAt(i+1)==num.charAt(i)){
        count++;
        i++;
      }
      result=result*(long)Math.pow(2,count-1);
    }
    return result ;
  }
  public static void main(String[] args){
    String num="11112" ;
    System.out.print(spellsCount(num));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation spellsCount( num : String) : long
  pre: true
  post: true
  activity: (     var n : int ; n := num->size() ;
     var result : long ; result := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     var count : int ; count := 1 ;
     while (i < n - 1 & num->at(i + 1+1) = num->at(i+1)) do (     count := count + 1 ; 
     i := i + 1 ) ; 
     result := result * 2->pow(count - 1)->oclAsType(long) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : String ; num := "11112" ;
     OclFile["System.out"].print(spellsCount(num)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p068 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p068().run());
  }
  public String run(){
    int[] state=new int[10];
    for(int i=0 ; i<state.length ; i++)state[i]=i+1 ;
    String max=null ;
    do {
      int sum=state[0]+state[5]+state[6];
      if(state[1]+state[6]+state[7]!=sum || state[2]+state[7]+state[8]!=sum || state[3]+state[8]+state[9]!=sum || state[4]+state[9]+state[5]!=sum)continue ;
      int minOuterIndex=-1 ;
      int minOuter=Integer.MAX_VALUE ;
      for(int i=0 ; i<5 ; i++){
        if(state[i]<minOuter){
          minOuterIndex=i ;
          minOuter=state[i];
        }
      }
      String s="" ;
      for(int i=0 ; i<5 ; i++)s+=""+state[(minOuterIndex+i)% 5]+state[(minOuterIndex+i)% 5+5]+state[(minOuterIndex+i+1)% 5+5];
      if(s.length()==16 &&(max==null || s.compareTo(max)>0))max=s ;
    }
    while(Library.nextPermutation(state));
    if(max==null)throw new AssertionError();
    return max ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p068 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p068.newp068().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var state : Sequence(int) ; state := Integer.subrange(1,10)->collect(0) ;
         var i : int ; i := 0 ; while i < state->size() do (     state[i+1] := i + 1 ;  ;     i := i + 1 ) ; 
    var max : String ; max := null ;
  while true do ((     var sum : int ; sum := state[0+1] + state[5+1] + state[6+1] ;
     if (state[1+1] + state[6+1] + state[7+1] /= sum or state[2+1] + state[7+1] + state[8+1] /= sum or state[3+1] + state[8+1] + state[9+1] /= sum or state[4+1] + state[9+1] + state[5+1] /= sum) then     continue else skip ; 
    var minOuterIndex : int ; minOuterIndex := -1 ;
    var minOuter : int ; minOuter := 2147483647 ;
        var i : int ; i := 0 ; while i < 5 do ( (     if (state[i+1] < minOuter) then (     minOuterIndex := i ; 
     minOuter := state[i+1] ) else skip )  ;     i := i + 1 ) ; 
    var s : String ; s := "" ;
        var i : int ; i := 0 ; while i < 5 do (     s := s+("" + state[(minOuterIndex + i) mod 5+1] + state[(minOuterIndex + i) mod 5 + 5+1] + state[(minOuterIndex + i + 1) mod 5 + 5+1]) ;  ;     i := i + 1 ) ; 
    if (s->size() = 16 & (max = null or s->compareTo(max) > 0)) then     max := s ; else skip ; 
 ) ;
    if (Library.nextPermutation(state)) then skip else break) ; 
    if (max = null) then     error AssertionException() ; else skip ; 
    return max 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void newvol(double x){
    System.out.print("percentage increase "+"in the volume of the cube is "+(Math.pow(x,3)/10000+3*x+(3*Math.pow(x,2))/100));
    System.out.print("%");
  }
  public static void main(String[] args){
    double x=10 ;
    newvol(x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation newvol( x : double) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("percentage increase " + "in the volume of the cube is " + (x->pow(3) / 10000 + 3 * x + (3 * x->pow(2)) / 100)) ; 
     OclFile["System.out"].print("%") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : double ; x := 10 ;
     execute newvol(x) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void newvol(double x){
    System.out.print("percentage increase "+"in the volume of the cylinder is "+x+"%");
  }
  public static void main(String[] args){
    double x=10 ;
    newvol(x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation newvol( x : double) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("percentage increase " + "in the volume of the cylinder is " + x + "%") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : double ; x := 10 ;
     execute newvol(x) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void newvol(double x){
    System.out.print("percentage increase in the"+" volume of the sphere is "+(Math.pow(x,3)/10000+3*x+(3*Math.pow(x,2))/100)+"%");
  }
  public static void main(String[] args){
    double x=10 ;
    newvol(x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation newvol( x : double) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("percentage increase in the" + " volume of the sphere is " + (x->pow(3) / 10000 + 3 * x + (3 * x->pow(2)) / 100) + "%") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : double ; x := 10 ;
     execute newvol(x) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  long M=1000000007 ;
  public void run(){
    Scanner sc=new Scanner(System.in);
    int[] a=new int[100000];
    long[] f=new long[100001];
    f[0]=1 ;
    for(int i=1 ; i<=100000 ; i++)f[i]=f[i-1]*i % M ;
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      for(int i=0 ; i<n ; i++)a[i]=i+1 ;
      int r=sc.nextInt();
      while(r--!=0){
        int s=sc.nextInt()-1,t=sc.nextInt()-1 ;
        int x=a[s];
        a[s]=a[t];
        a[t]=x ;
      }
      BIT bit=new BIT(100001);
      for(int i=2 ; i<=100000 ; i++){
        bit.add(i,1);
      }
      long res=0 ;
      for(int i=0 ; i<n ; i++){
        res+=bit.sum(a[i])*f[n-1-i];
        res %=M ;
        bit.add(a[i],-1);
      }
      System.out.println(res);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  public static class BIT {
    public int n ;
    private int[] bit ;
    public BIT(int n){
      this.n=n ;
      bit=new int[n+1];
    }
    public int sum(int i){
      int s=0 ;
      while(i>0){
        s+=bit[i];
        i-=i &-i ;
      }
      return s ;
    }
    public void add(int i,int x){
      while(i<=n){
        bit[i]+=x ;
        i+=i &-i ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute M : long := 1000000007;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,100000)->collect(0) ;
    var f : Sequence(long) ; f := Integer.subrange(1,100001)->collect(0) ;
    f[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= 100000 do (     f[i+1] := f[i - 1+1] * i mod M ;  ;     i := i + 1 ) ; 
      while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := i + 1 ;  ;     i := i + 1 ) ; 
    var r : int ; r := sc.getCurrent()->toInteger() ;
        while (r /= 0) do (    skip ; (     var s : int ; s := sc.getCurrent()->toInteger() - 1 ;
    var t : int ; t := sc.getCurrent()->toInteger() - 1 ;
     var x : int ; x := a[s+1] ;
     a[s+1] := a[t+1] ; 
     a[t+1] := x ) ;  ) ;  
    var bit : BIT ; bit := BIT.newBIT(100001) ;
        var i : int ; i := 2 ; while i <= 100000 do ( (     bit->excludes(i, 1) )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     res := res+(bit.sum(a[i+1]) * f[n - 1 - i+1]) ; 
     res := res mod M ; 
     bit->excludes(a[i+1], -1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 )  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
  static class BIT {
   attribute n : int;
   attribute bit : Sequence(int);
   static operation newBIT( n : int) : BIT
  pre: true
  post: true
  activity:
  ( var self : BIT ;
    self := createBIT();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     self.n := n ; 
     bit := Integer.subrange(1,n + 1)->collect(0) );
   operation sum( i : int) : int
  pre: true
  post: true
  activity: (     var s : int ; s := 0 ;
     while (i > 0) do (     s := s+(bit[i+1]) ; 
     i := i-(MathLib.bitwiseAnd(i,-i)) ) ; 
     return s );
   operation add( i : int, x : int) : void
  pre: true
  post: true
  activity: (     while (i <= n) do (     bit[i+1] := bit[i+1]+(x) ; 
     i := i+(MathLib.bitwiseAnd(i,-i)) ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int MOD=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    while(true){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      int r=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=i+1 ;
      }
      long[] kaijos=new long[n];
      kaijos[0]=1 ;
      kaijos[1]=1 ;
      for(int i=2 ; i<n ; i++){
        kaijos[i]=(i*kaijos[i-1])% MOD ;
      }
      for(int i=0 ; i<r ; i++){
        int s=sc.nextInt()-1 ;
        int t=sc.nextInt()-1 ;
        int tmp=arr[s];
        arr[s]=arr[t];
        arr[t]=tmp ;
      }
      long total=0 ;
      ArrayList<Integer>used=new ArrayList<>();
      used.add(0);
      used.add(Integer.MAX_VALUE);
      for(int i=0 ; i<n ; i++){
        int x=arr[i];
        int left=0 ;
        int right=used.size()-1 ;
        while(right-left>1){
          int m=(left+right)/2 ;
          if(used.get(m)<x){
            left=m ;
          }
          else {
            right=m ;
          }
        }
        used.add(right,x);
        total+=(kaijos[n-i-1]*(x-right))% MOD ;
        total %=MOD ;
      }
      sb.append(total).append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := i + 1 )  ;     i := i + 1 ) ; 
    var kaijos : Sequence(long) ; kaijos := Integer.subrange(1,n)->collect(0) ;
    kaijos[0+1] := 1 ; 
    kaijos[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < n do ( (     kaijos[i+1] := (i * kaijos[i - 1+1]) mod MOD )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < r do ( (     var s : int ; s := sc.getCurrent()->toInteger() - 1 ;
     var t : int ; t := sc.getCurrent()->toInteger() - 1 ;
    var tmp : int ; tmp := arr[s+1] ;
    arr[s+1] := arr[t+1] ; 
    arr[t+1] := tmp ; 
 )  ;     i := i + 1 ) ; 
    var total : long ; total := 0 ;
    var used : Sequence(int) ; used := Sequence{} ;
    used := used->including(0) ; 
    used := used->including(2147483647) ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := arr[i+1] ;
     var left : int ; left := 0 ;
    var right : int ; right := used->size() - 1 ;
    while (right - left > 1) do (     var m : int ; m := (left + right) / 2 ;
     if (used->at(m+1) < x) then (     left := m ) else (     right := m ) ) ; 
    used := used.insertAt(right+1,x) ; 
    total := total+((kaijos[(n)->char2byte() - i - 1+1] * (x - right)) mod MOD) ; 
    total := total mod MOD ; 
 )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(total) + StringLib.newString("\n") ; 
 ) ; 
     OclFile["System.out"].print(sb) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    System.out.print(6*n*(n-1)+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].print(6 * n * (n - 1) + 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class problemB {
  public static void quickSort(int a[],int d,int c){
    int i=d ;
    int j=c ;
    int mid=a[(d+c)/2];
    while(i<=j){
      while(a[i]<mid)i++;
      while(a[j]>mid)j--;
      if(i<=j){
        int tg=a[i];
        a[i]=a[j];
        a[j]=tg ;
        i++;
        j--;
      }
    }
    if(d<j)quickSort(a,d,j);
    if(i<c)quickSort(a,i,c);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n+5];
    for(int i=1 ; i<=n ; i++)a[i]=sc.nextInt();
    int b[]=new int[n+5];
    for(int i=1 ; i<n ; i++)b[i]=sc.nextInt();
    int c[]=new int[n+5];
    for(int i=1 ; i<=n-2 ; i++)c[i]=sc.nextInt();
    quickSort(a,1,n);
    quickSort(b,1,n-1);
    quickSort(c,1,n-2);
    int resA=a[n];
    for(int i=1 ; i<n ; i++){
      if(a[i]!=b[i]){
        resA=a[i];
        break ;
      }
    }
    System.out.println(resA);
    int resB=b[n-1];
    for(int i=1 ; i<=n-2 ; i++){
      if(b[i]!=c[i]){
        resB=b[i];
        break ;
      }
    }
    System.out.println(resB);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class problemB {
  static   operation quickSort( a : Sequence(int), d : int, c : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := d ;
     var j : int ; j := c ;
    var mid : int ; mid := a[(d + c) / 2+1] ;
    while (i <= j) do (     while (a[i+1] < mid) do     i := i + 1 ; ; 
     while (a[j+1] > mid) do     j := j - 1 ; ; 
     if (i <= j) then (     var tg : int ; tg := a[i+1] ;
     a[i+1] := a[j+1] ; 
    a[j+1] := tg ; 
    i := i + 1 ; 
    j := j - 1 ; 
 ) else skip ) ; 
    if (d < j) then     execute quickSort(a, d, j) ; else skip ; 
    if (i < c) then     execute quickSort(a, i, c) ; else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 5)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,n + 5)->collect(0) ;
        var i : int ; i := 1 ; while i < n do (     b[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var c : Sequence(int) ; c := Integer.subrange(1,n + 5)->collect(0) ;
        var i : int ; i := 1 ; while i <= n - 2 do (     c[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    execute quickSort(a, 1, n) ; 
    execute quickSort(b, 1, n - 1) ; 
    execute quickSort(c, 1, n - 2) ; 
    var resA : int ; resA := a[n+1] ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] /= b[i+1]) then (     resA := a[i+1] ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(resA) ; 
    var resB : int ; resB := b[n - 1+1] ;
        var i : int ; i := 1 ; while i <= n - 2 do ( (     if (b[i+1] /= c[i+1]) then (     resB := b[i+1] ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(resB) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class PrB {
  public static long time ;
  public static void main(String[] args)throws Exception {
    time=System.currentTimeMillis();
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    System.out.println(go(br));
    br.close();
    System.exit(0);
  }
  public static int go(BufferedReader br)throws Exception {
    int a=Integer.parseInt(br.readLine());
    a--;
    return 1+12*(a*(a+1)/2);
  }
  public static void checkTime(){
    System.out.println(System.currentTimeMillis()-time);
    time=System.currentTimeMillis();
  }
}
------------------------------------------------------------
OCL File:
---------
 class PrB {
  static   attribute time : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     time := OclDate.getSystemTime() ; 
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    OclFile["System.out"].println(go(br)) ; 
    skip ; 
OclProcess.exit(0) ; 
 );
  static   operation go( br : OclFile) : int
  pre: true
  post: true
  activity: (     var a : int ; a := (br.readLine())->toInteger() ;
     a := a - 1 ; 
     return 1 + 12 * (a * (a + 1) / 2) );
  static   operation checkTime() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(OclDate.getSystemTime() - time) ; 
     time := OclDate.getSystemTime() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n],w=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      w[i]=sc.nextInt();
    }
    int zeroMin=Integer.MAX_VALUE ;
    int oneMin=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(a[i]==0){
        zeroMin=Math.min(zeroMin,w[i]);
      }
      else {
        oneMin=Math.min(oneMin,w[i]);
      }
    }
    if(Arrays.stream(a).allMatch(value->value==0)|| Arrays.stream(a).allMatch(value->value==1)){
      System.out.println(0);
    }
    else {
      System.out.println(oneMin+zeroMin);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var w : Sequence(int) ; w := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     w[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var zeroMin : int ; zeroMin := 2147483647 ;
    var oneMin : int ; oneMin := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = 0) then (     zeroMin := Set{zeroMin, w[i+1]}->min() ) else (     oneMin := Set{oneMin, w[i+1]}->min() ) )  ;     i := i + 1 ) ; 
    if (stream(a)->forAll( _x2 | (lambda value : OclAny in value = 0)->apply(_x2) ) or stream(a)->forAll( _x2 | (lambda value : OclAny in value = 1)->apply(_x2) )) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(oneMin + zeroMin) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B171 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long N=in.nextInt();
    long answer=6*N*(N-1)+1 ;
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B171 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := in.getCurrent()->toInteger() ;
     var answer : long ; answer := 6 * N * (N - 1) + 1 ;
     OclFile["System.out"].println(answer) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String agrs[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int ans=6*n*(n-1)+1 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ans : int ; ans := 6 * n * (n - 1) + 1 ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    String t=sc.nextLine();
    String[] s_s=s.split("");
    String[] t_s=t.split("");
    int cnt=0 ;
    for(int i=0 ; i<s_s.length ; i++){
      if(s_s[i] .equals(t_s[i])){
        cnt+=1 ;
      }
    }
    System.out.println(cnt);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var t : String ; t := sc.nextLine() ;
    var s_s : Sequence(String) ; s_s := s->split("") ;
    var t_s : Sequence(String) ; t_s := t->split("") ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < s_s->size() do ( (     if (s_s[i+1] = t_s[i+1]) then (     cnt := cnt+(1) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static class InputReader {
    BufferedReader reader ;
    StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
  }
  static InputReader r=new InputReader(System.in);
  static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args){
    String s=r.next();
    String t=r.next();
    int ans=0 ;
    for(int i=0 ; i<3 ; i++){
      if(s.charAt(i)==t.charAt(i)){
        ans++;
      }
    }
    pw.println(ans);
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
  static   attribute r : InputReader := InputReader.newInputReader(OclFile["System.in"]);
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := r.next() ;
     var t : String ; t := r.next() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (s->at(i+1) = t->at(i+1)) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=null ;
    PrintStream out=null ;
    try {
      sc=new Scanner(System.in);
      out=System.out ;
      exec(sc,out);
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
    finally {
      if(out!=null){
        out.close();
      }
      if(sc!=null){
        sc.close();
      }
    }
    System.exit(0);
  }
  public static void exec(final Scanner sc,final PrintStream out)throws Exception {
    final String S=sc.next();
    final String T=sc.next();
    int cnt=0 ;
    for(int i=0 ; i<3 ; i++){
      if(S.charAt(i)==T.charAt(i)){
        cnt++;
      }
    }
    out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := null ;
     var out : OclFile ; out := null ;
     try (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     out := OclFile["System.out"] ; 
     execute exec(sc, out) )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
   finally (     if (out /= null) then (     skip ) else skip ; 
     if (sc /= null) then (     skip ) else skip )
 OclProcess.exit(0) );
  static   operation exec( sc : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var S : String ; S := sc.getCurrent() ;
     var T : String ; T := sc.getCurrent() ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (S->at(i+1) = T->at(i+1)) then (     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String m=sc.nextLine();
    String n=sc.nextLine();
    String m1=m.substring(0,1);
    String n1=n.substring(0,1);
    String m2=m.substring(1,2);
    String n2=n.substring(1,2);
    String m3=m.substring(2);
    String n3=n.substring(2);
    int i=0 ;
    if(m.equals(n)){
      System.out.println(3);
    }
    else {
      if(m1.equals(n1))i++;
      if(m2.equals(n2))i++;
      if(m3.equals(n3))i++;
      System.out.println(i);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : String ; m := sc.nextLine() ;
    var n : String ; n := sc.nextLine() ;
    var m1 : String ; m1 := m.subrange(0+1,1) ;
    var n1 : String ; n1 := n.subrange(0+1,1) ;
    var m2 : String ; m2 := m.subrange(1+1,2) ;
    var n2 : String ; n2 := n.subrange(1+1,2) ;
    var m3 : String ; m3 := m.subrange(2+1,2) ;
    var n3 : String ; n3 := n.subrange(2+1,2) ;
    var i : int ; i := 0 ;
    if (m = n) then (     OclFile["System.out"].println(3) ) else (     if (m1 = n1) then     i := i + 1 ; else skip ; 
     if (m2 = n2) then     i := i + 1 ; else skip ; 
     if (m3 = n3) then     i := i + 1 ; else skip ; 
     OclFile["System.out"].println(i) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    char[] before=scan.next().toCharArray();
    char[] after=scan.next().toCharArray();
    int answer=0 ;
    for(int i=0 ; i<3 ; i++){
      if(before[i]==after[i]){
        answer++;
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var before : Sequence(String) ; before := scan.getCurrent()->characters() ;
    var after : Sequence(String) ; after := scan.getCurrent()->characters() ;
    var answer : int ; answer := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (before[i+1] = after[i+1]) then (     answer := answer + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class Main {
  static void minAbsSumPair(int arr[],int arr_size){
    int inv_count=0 ;
    int l,r,min_sum,sum,min_l,min_r ;
    if(arr_size<2){
      System.out.println("Invalid Input");
      return ;
    }
    min_l=0 ;
    min_r=1 ;
    min_sum=arr[0]+arr[1];
    for(l=0 ; l<arr_size-1 ; l++){
      for(r=l+1 ; r<arr_size ; r++){
        sum=arr[l]+arr[r];
        if(Math.abs(min_sum)>Math.abs(sum)){
          min_sum=sum ;
          min_l=l ;
          min_r=r ;
        }
      }
    }
    System.out.println(" The two elements whose "+"sum is minimum are "+arr[min_l]+" and "+arr[min_r]);
  }
  public static void main(String[] args){
    int arr[]={
      1,60,-10,70,-80,85 };
      minAbsSumPair(arr,6);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation minAbsSumPair( arr : Sequence(int), arr_size : int) : void
  pre: true
  post: true
  activity: (     var inv_count : int ; inv_count := 0 ;
     var l : int ;
    var r : int ;
    var min_sum : int ;
    var sum : int ;
    var min_l : int ;
    var min_r : int ;
    if (arr_size < 2) then (     OclFile["System.out"].println("Invalid Input") ; 
     return ) else skip ; 
    min_l := 0 ; 
    min_r := 1 ; 
    min_sum := arr[0+1] + arr[1+1] ; 
        l := 0 ; while l < arr_size - 1 do ( (         r := l + 1 ; while r < arr_size do ( (     sum := arr[l+1] + arr[r+1] ; 
     if (if min_sum < 0 then -(min_sum) else min_sum endif > if sum < 0 then -(sum) else sum endif) then (     min_sum := sum ; 
     min_l := l ; 
     min_r := r ) else skip )  ;     r := r + 1 ) )  ;     l := l + 1 ) ; 
    OclFile["System.out"].println(" The two elements whose " + "sum is minimum are " + arr[min_l+1] + " and " + arr[min_r+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,60,-10,70,-80,85} ;
     execute minAbsSumPair(arr, 6) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class tasks {
  public static void main(String...args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    List<Integer>nums=new ArrayList<>();
    List<Integer>nums1=new ArrayList<>();
    List<Integer>nums2=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      nums.add(in.nextInt());
    }
    for(int i=0 ; i<n-1 ; i++){
      nums1.add(in.nextInt());
    }
    for(int i=0 ; i<n-2 ; i++){
      nums2.add(in.nextInt());
    }
    Collections.sort(nums);
    Collections.sort(nums1);
    Collections.sort(nums2);
    int i=0 ;
    while(true){
      if(nums1.size()>i && nums.get(i).equals(nums1.get(i))){
        nums.set(i,nums.get(i)-nums1.get(i));
        i++;
      }
      else {
        System.out.println(nums.get(i));
        break ;
      }
    }
    i=0 ;
    while(true){
      if(nums2.size()>i && nums1.get(i).equals(nums2.get(i))){
        nums1.set(i,nums1.get(i)-nums2.get(i));
        i++;
      }
      else {
        System.out.println(nums1.get(i));
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class tasks {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Sequence{} ;
    var nums1 : Sequence(int) ; nums1 := Sequence{} ;
    var nums2 : Sequence(int) ; nums2 := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     nums := nums->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     nums1 := nums1->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 2 do ( (     nums2 := nums2->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    nums := nums->sort() ; 
    nums1 := nums1->sort() ; 
    nums2 := nums2->sort() ; 
    var i : int ; i := 0 ;
    while (true) do (     if (nums1->size() > i & nums->at(i+1) = nums1->at(i+1)) then (     nums := nums.setAt(i+1,nums->at(i+1) - nums1->at(i+1)) ; 
     i := i + 1 ) else (     OclFile["System.out"].println(nums->at(i+1)) ; 
     break ) ) ; 
    i := 0 ; 
    while (true) do (     if (nums2->size() > i & nums1->at(i+1) = nums2->at(i+1)) then (     nums1 := nums1.setAt(i+1,nums1->at(i+1) - nums2->at(i+1)) ; 
     i := i + 1 ) else (     OclFile["System.out"].println(nums1->at(i+1)) ; 
     break ) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int n,m ;
    n=s.nextInt();
    m=s.nextInt();
    String dtr ;
    dtr=s.next();
    char str[]=dtr.toCharArray();
    final int CHAR=26 ;
    int count[]=new int[CHAR];
    for(int i=0 ; i<n ; i++){
      count[str[i]-'a']++;
    }
    for(int i=0 ; i<m ; i++){
      for(int j=0 ; j<CHAR ; j++){
        if(count[j]>0){
          count[j]--;
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      if(count[str[i]-'a']>0){
        System.out.print("NO");
        return ;
      }
    }
    System.out.print("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var m : int ;
    n := s.getCurrent()->toInteger() ; 
    m := s.getCurrent()->toInteger() ; 
    var dtr : String ;
    dtr := s.getCurrent() ; 
    var str : Sequence(String) ; str := dtr->characters() ;
    var CHAR : int ; CHAR := 26 ;
    var count : Sequence(int) ; count := Integer.subrange(1,CHAR)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     count[str[i+1] - ('a')->char2byte()+1] := count[str[i+1] - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j < CHAR do ( (     if (count[j+1] > 0) then (     count[j+1] := count[j+1] - 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (count[str[i+1] - ('a')->char2byte()+1] > 0) then (     OclFile["System.out"].print("NO") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int baloons=sc.nextInt();
    int friends=sc.nextInt();
    String str=sc.next();
    int freq[]=new int[26];
    for(int i=0 ; i<str.length(); i++){
      freq[str.charAt(i)-'a']++;
    }
    for(int i=0 ; i<26 ; i++){
      if(freq[i]>friends){
        System.out.println("NO");
        return ;
      }
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var baloons : int ; baloons := sc.getCurrent()->toInteger() ;
    var friends : int ; friends := sc.getCurrent()->toInteger() ;
    var str : String ; str := sc.getCurrent() ;
    var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < str->size() do ( (     freq[str->at(i+1) - ('a')->char2byte()+1] := freq[str->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 26 do ( (     if (freq[i+1] > friends) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long n,d ;
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),k=in.nextInt();
    char ch[]=in.next().toCharArray();
    Map<Character,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(! map.containsKey(ch[i])){
        map.put(ch[i],1);
      }
      else {
        map.put(ch[i],map.get(ch[i])+1);
      }
    }
    int max=Integer.MIN_VALUE ;
    for(Integer i : map.values()){
      max=Math.max(i,max);
    }
    if(max<=k){
      pw.println("YES");
    }
    else {
      pw.println("NO");
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var ch : Sequence(String) ; ch := in.getCurrent()->characters() ;
    var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (not(map->keys()->includes(ch[i+1]))) then (     map := map->union(Map{ch[i+1] |-> 1}) ) else (     map := map->union(Map{ch[i+1] |-> map->at(ch[i+1]) + 1}) ) )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
    for (i : map->values()) do ( (     max := Set{i, max}->max() )  ) ; 
    if (max <= k) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printFloydTriangle(int n){
    int i,j,val=1 ;
    for(i=1 ; i<=n ; i++){
      for(j=1 ; j<=i ; j++){
        System.out.print(val+" ");
        val++;
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    printFloydTriangle(6);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printFloydTriangle( n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var val : int ; val := 1 ;
         i := 1 ; while i <= n do ( (         j := 1 ; while j <= i do ( (     OclFile["System.out"].print(val + " ") ; 
     val := val + 1 )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute printFloydTriangle(6) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class Node {
    Node left ;
    Node right ;
    int data ;
    Node(int data){
      this.data=data ;
      this.left=null ;
      this.right=null ;
    }
  };
  static class Info {
    int num_BST ;
    int max ;
    int min ;
    boolean isBST ;
    Info(int a,int b,int c,boolean d){
      num_BST=a ;
      max=b ;
      min=c ;
      isBST=d ;
    }
    Info(){
    }
  };
  static Info NumberOfBST(Node root){
    if(root==null)return new Info(0,Integer.MIN_VALUE,Integer.MAX_VALUE,true);
    if(root.left==null && root.right==null)return new Info(1,root.data,root.data,true);
    Info L=NumberOfBST(root.left);
    Info R=NumberOfBST(root.right);
    Info bst=new Info();
    bst.min=Math.min(root.data,(Math.min(L.min,R.min)));
    bst.max=Math.max(root.data,(Math.max(L.max,R.max)));
    if(L.isBST && R.isBST && root.data>L.max && root.data<R.min){
      bst.isBST=true ;
      bst.num_BST=1+L.num_BST+R.num_BST ;
    }
    else {
      bst.isBST=false ;
      bst.num_BST=L.num_BST+R.num_BST ;
    }
    return bst ;
  }
  public static void main(String args[]){
    Node root=new Node(5);
    root.left=new Node(9);
    root.right=new Node(3);
    root.left.left=new Node(6);
    root.right.right=new Node(4);
    root.left.left.left=new Node(8);
    root.left.left.right=new Node(7);
    System.out.print(NumberOfBST(root).num_BST);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Node {
   attribute left : Node;
   attribute right : Node;
   attribute data : int;
   static operation newNode( data : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(data);
    return self );
  operation initialise( data : int) : void
  pre: true  post: true
  activity: (     self.data := data ; 
     self.left := null ; 
     self.right := null );
}
  static class Info {
   attribute num_BST : int;
   attribute max : int;
   attribute min : int;
   attribute isBST : boolean;
   static operation newInfo( a : int, b : int, c : int, d : boolean) : Info
  pre: true
  post: true
  activity:
  ( var self : Info ;
    self := createInfo();
    self.initialise(a, b,c,d);
    return self );
  operation initialise( a : int, b : int, c : int, d : boolean) : void
  pre: true  post: true
  activity: (     num_BST := a ; 
     max := b ; 
     min := c ; 
     isBST := d );
   static operation newInfo() : Info
  pre: true
  post: true
  activity:
  ( var self : Info ;
    self := createInfo();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
}
  static   operation NumberOfBST( root : Node) : Info
  pre: true
  post: true
  activity: (     if (root = null) then     return Info.newInfo(0, -2147483648, 2147483647, true) else skip ; 
     if (root.left = null & root.right = null) then     return Info.newInfo(1, root.data, root.data, true) else skip ; 
    var L : Info ; L := NumberOfBST(root.left) ;
    var R : Info ; R := NumberOfBST(root.right) ;
    var bst : Info ; bst := Info.newInfo() ;
    bst.min := Set{root.data, (Set{L.min, R.min}->min())}->min() ; 
    bst.max := Set{root.data, (Set{L.max, R.max}->max())}->max() ; 
    if (L.isBST & R.isBST & root.data > L.max & root.data < R.min) then (     bst.isBST := true ; 
     bst.num_BST := 1 + L.num_BST + R.num_BST ) else (     bst.isBST := false ; 
     bst.num_BST := L.num_BST + R.num_BST ) ;  
    return bst 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var root : Node ; root := Node.newNode(5) ;
     root.left := Node.newNode(9) ; 
    root.right := Node.newNode(3) ; 
    root.left.left := Node.newNode(6) ; 
    root.right.right := Node.newNode(4) ; 
    root.left.left.left := Node.newNode(8) ; 
    root.left.left.right := Node.newNode(7) ; 
    OclFile["System.out"].print(NumberOfBST(root).num_BST) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int smallestIndex(int[] a,int n){
    int right1=0,right0=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]==1)right1=i ;
      else right0=i ;
    }
    return Math.min(right1,right0);
  }
  public static void main(String[] args){
    int[] a={
      1,1,1,0,0,1,0,1,1 };
      int n=a.length ;
      System.out.println(smallestIndex(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation smallestIndex( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var right1 : int ; right1 := 0 ;
    var right0 : int ; right0 := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = 1) then     right1 := i ; else     right0 := i ; )  ;     i := i + 1 ) ; 
     return Set{right1, right0}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,1,1,0,0,1,0,1,1} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(smallestIndex(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void MinimumSwapOperations(String s){
    boolean zero_exist=false ;
    boolean multiple_of_2=false ;
    int sum=0 ;
    int index_of_zero=0 ;
    boolean more_zero=false ;
    for(int i=0 ; i<s.length(); i++){
      int val=s.charAt(i)-'0' ;
      if(zero_exist==true)more_zero=true ;
      if(val==0){
        zero_exist=true ;
        index_of_zero=i ;
      }
      sum+=val ;
    }
    if(zero_exist==false || sum % 3!=0){
      System.out.println("-1");
      return ;
    }
    for(int i=0 ; i<s.length(); i++){
      int val=s.charAt(i)-'0' ;
      if(val % 2==0 && i!=index_of_zero)multiple_of_2=true ;
    }
    if(multiple_of_2==false){
      System.out.println("-1");
      return ;
    }
    int last_val=s.charAt(s.length()-1)-'0' ;
    int second_last_val=s.charAt(s.length()-2)-'0' ;
    if(last_val==0 && second_last_val % 2==0)System.out.println(0);
    else if((last_val==0 && second_last_val % 2!=0)||(last_val % 2==0 && second_last_val==0))System.out.println(1);
    else if(more_zero==true &&(last_val==0 && second_last_val % 2!=0))System.out.println(1);
    else System.out.println(2);
  }
  public static void main(String[] args){
    String N="20" ;
    MinimumSwapOperations(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation MinimumSwapOperations( s : String) : void
  pre: true
  post: true
  activity: (     var zero_exist : boolean ; zero_exist := false ;
     var multiple_offalse : boolean ; multiple_offalse := false ;
    var sum : int ; sum := 0 ;
    var index_of_zero : int ; index_of_zero := 0 ;
    var more_zero : boolean ; more_zero := false ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var val : int ; val := s->at(i+1) - ('0')->char2byte() ;
     if (zero_exist = true) then     more_zero := true ; else skip ; 
     if (val = 0) then (     zero_exist := true ; 
     index_of_zero := i ) else skip ; 
     sum := sum+(val) )  ;     i := i + 1 ) ; 
    if (zero_exist = false or sum mod 3 /= 0) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     var val : int ; val := s->at(i+1) - ('0')->char2byte() ;
     if (val mod 2 = 0 & i /= index_of_zero) then     multiple_oftrue := true ; else skip )  ;     i := i + 1 ) ; 
    if (multiple_offalse = false) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
    var last_val : int ; last_val := s->at(s->size() - 1+1) - ('0')->char2byte() ;
    var second_last_val : int ; second_last_val := s->at(s->size() - 2+1) - ('0')->char2byte() ;
    if (last_val = 0 & second_last_val mod 2 = 0) then     OclFile["System.out"].println(0) else     if ((last_val = 0 & second_last_val mod 2 /= 0) or (last_val mod 2 = 0 & second_last_val = 0)) then     OclFile["System.out"].println(1) else     if (more_zero = true & (last_val = 0 & second_last_val mod 2 /= 0)) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println(2) ; ;  ;  ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : String ; N := "20" ;
     execute MinimumSwapOperations(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(new File("A-small-attempt0.in"));
    PrintWriter out=new PrintWriter(new FileWriter(new File("A-small.out")));
    int t=in.nextInt();
    for(int x=0 ; x<t ; x++){
      int row1=in.nextInt()-1 ;
      HashSet<Integer>cards=new HashSet<Integer>();
      for(int y=0 ; y<4 ; y++){
        for(int z=0 ; z<4 ; z++){
          int card=in.nextInt();
          if(y==row1){
            cards.add(card);
          }
        }
      }
      int row2=in.nextInt()-1 ;
      int chosen=-1 ;
      int count=0 ;
      for(int a=0 ; a<4 ; a++){
        for(int b=0 ; b<4 ; b++){
          int card=in.nextInt();
          if(a==row2 && cards.contains(card)){
            chosen=card ;
            count++;
          }
        }
      }
      out.print("Case #"+(x+1)+": ");
      if(count==1){
        out.println(chosen);
      }
      else if(count==0){
        out.println("Volunteer cheated!");
      }
      else {
        out.println("Bad magician!");
      }
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("A-small-attempt0.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile("A-small.out"))) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        var x : int ; x := 0 ; while x < t do ( (     var row1 : int ; row1 := in.getCurrent()->toInteger() - 1 ;
     var cards : Set(int) ; cards := Set{} ;
        var y : int ; y := 0 ; while y < 4 do ( (         var z : int ; z := 0 ; while z < 4 do ( (     var card : int ; card := in.getCurrent()->toInteger() ;
     if (y = row1) then (     cards := cards->including(card) ) else skip )  ;     z := z + 1 ) )  ;     y := y + 1 ) ; 
    var row2 : int ; row2 := in.getCurrent()->toInteger() - 1 ;
    var chosen : int ; chosen := -1 ;
    var count : int ; count := 0 ;
        var a : int ; a := 0 ; while a < 4 do ( (         var b : int ; b := 0 ; while b < 4 do ( (     var card : int ; card := in.getCurrent()->toInteger() ;
     if (a = row2 & cards->includes(card)) then (     chosen := card ; 
     count := count + 1 ) else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    skip ; 
    if (count = 1) then (     skip ) else     if (count = 0) then (     skip ) else (     skip ) ;  ;  
 )  ;     x := x + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int cases=in.nextInt();
    for(int i=1 ; i<=cases ; i++){
      int poss=0 ;
      int ans=-1 ;
      int a=in.nextInt()-1 ;
      int[][] first=new int[4][4];
      int[][] second=new int[4][4];
      for(int j=0 ; j<4 ; j++){
        for(int k=0 ; k<4 ; k++){
          first[j][k]=in.nextInt();
        }
      }
      int b=in.nextInt()-1 ;
      for(int j=0 ; j<4 ; j++){
        for(int k=0 ; k<4 ; k++){
          second[j][k]=in.nextInt();
        }
      }
      for(int j=0 ; j<4 ; j++){
        for(int k=0 ; k<4 ; k++){
          if(first[a][k]==second[b][j]){
            ans=first[a][k];
            poss++;
          }
        }
      }
      if(poss>1){
        System.out.printf("Case #%d: Bad magician!\n",i);
      }
      else if(poss==1){
        System.out.printf("Case #%d: %d\n",i,ans);
      }
      else {
        System.out.printf("Case #%d: Volunteer cheated!\n",i);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cases : int ; cases := in.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= cases do ( (     var poss : int ; poss := 0 ;
     var ans : int ; ans := -1 ;
    var a : int ; a := in.getCurrent()->toInteger() - 1 ;
    var first : Sequence(Sequence(int)) ; first := Integer.subrange(1,4)->collect(Integer.subrange(1,4)->collect(0)) ;
    var second : Sequence(Sequence(int)) ; second := Integer.subrange(1,4)->collect(Integer.subrange(1,4)->collect(0)) ;
        var j : int ; j := 0 ; while j < 4 do ( (         var k : int ; k := 0 ; while k < 4 do ( (     first[j+1][k+1] := in.getCurrent()->toInteger() )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    var b : int ; b := in.getCurrent()->toInteger() - 1 ;
        var j : int ; j := 0 ; while j < 4 do ( (         var k : int ; k := 0 ; while k < 4 do ( (     second[j+1][k+1] := in.getCurrent()->toInteger() )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < 4 do ( (         var k : int ; k := 0 ; while k < 4 do ( (     if (first[a+1][k+1] = second[b+1][j+1]) then (     ans := first[a+1][k+1] ; 
     poss := poss + 1 ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    if (poss > 1) then (     OclFile["System.out"].printf("Case #%d: Bad magician!\n", i) ) else     if (poss = 1) then (     OclFile["System.out"].printf("Case #%d: %d\n", i, ans) ) else (     OclFile["System.out"].printf("Case #%d: Volunteer cheated!\n", i) ) ;  ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=0,b=0,c=0 ;
    for(int i=0 ; i<n ; i++)a+=sc.nextInt();
    for(int i=0 ; i<n-1 ; i++)b+=sc.nextInt();
    for(int i=0 ; i<n-2 ; i++)c+=sc.nextInt();
    int x=a-b,y=b-c ;
    System.out.println(x);
    System.out.println(y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do (     a := a+(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do (     b := b+(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 2 do (     c := c+(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    var x : int ; x := a - b ;
    var y : int ; y := b - c ;
    OclFile["System.out"].println(x) ; 
    OclFile["System.out"].println(y) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedWriter ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.util.Scanner ;
public class MagicTrick {
  public void magic()throws IOException {
    Scanner sc=new Scanner(new FileReader("jam.in"));
    BufferedWriter bw=new BufferedWriter(new FileWriter("jam.out"));
    int cases ;
    cases=sc.nextInt();
    for(int z=1 ; z<=cases ; z++){
      int[][] map1=new int[4][4];
      int[][] map2=new int[4][4];
      int i,j ;
      int r1,r2 ;
      r1=sc.nextInt()-1 ;
      for(i=0 ; i<4 ; i++)for(j=0 ; j<4 ; j++)map1[i][j]=sc.nextInt();
      r2=sc.nextInt()-1 ;
      for(i=0 ; i<4 ; i++)for(j=0 ; j<4 ; j++)map2[i][j]=sc.nextInt();
      int ans=0 ;
      int sameNum=0 ;
      for(i=0 ; i<4 ; i++)for(j=0 ; j<4 ; j++)if(map1[r1][i]==map2[r2][j]){
        sameNum++;
        ans=map1[r1][i];
      }
      bw.write("Case #"+z+": ");
      if(sameNum==0)bw.write("Volunteer cheated!");
      else if(sameNum==1)bw.write(""+ans);
      else bw.write("Bad magician!");
      bw.write("\n");
    }
    bw.close();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class MagicTrick {
   operation magic() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("jam.in"))) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("jam.out"))) ;
    var cases : int ;
    cases := sc.getCurrent()->toInteger() ; 
        var z : int ; z := 1 ; while z <= cases do ( (     var map1 : Sequence(Sequence(int)) ; map1 := Integer.subrange(1,4)->collect(Integer.subrange(1,4)->collect(0)) ;
     var map2 : Sequence(Sequence(int)) ; map2 := Integer.subrange(1,4)->collect(Integer.subrange(1,4)->collect(0)) ;
    var i : int ;
    var j : int ;
    var r1 : int ;
    var r2 : int ;
    r1 := sc.getCurrent()->toInteger() - 1 ; 
        i := 0 ; while i < 4 do (         j := 0 ; while j < 4 do (     map1[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    r2 := sc.getCurrent()->toInteger() - 1 ; 
        i := 0 ; while i < 4 do (         j := 0 ; while j < 4 do (     map2[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var sameNum : int ; sameNum := 0 ;
        i := 0 ; while i < 4 do (         j := 0 ; while j < 4 do (     if (map1[r1+1][i+1] = map2[r2+1][j+1]) then (     sameNum := sameNum + 1 ; 
     ans := map1[r1+1][i+1] ) else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    skip ; 
    if (sameNum = 0) then     skip else     if (sameNum = 1) then     skip else     skip ; ;  ;  
    skip ; 
 )  ;     z := z + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package con2014Q ;
import java.io.*;
import java.util.*;
public class A {
  private static final String fileName="results/con2014Q/"+A.class.getSimpleName().toLowerCase();
  private static final String inputFileName=fileName+".in" ;
  private static final String outputFileName=fileName+".out" ;
  private static Scanner in ;
  private static PrintWriter out ;
  static final String BAD="Bad magician!",CHEAT="Volunteer cheated!" ;
  private void solve(){
    int R1=in.nextInt();
    int possible=0 ;
    for(int i=1 ; i<=4 ; i++){
      for(int j=1 ; j<=4 ; j++){
        int n=in.nextInt();
        if(i==R1){
          possible |=(1<<n);
        }
      }
    }
    {
      R1=in.nextInt();
      int possible2=0 ;
      for(int i=1 ; i<=4 ; i++){
        for(int j=1 ; j<=4 ; j++){
          int n=in.nextInt();
          if(i==R1){
            possible2 |=(1<<n);
          }
        }
      }
      possible &=possible2 ;
    }
    if(possible==0){
      out.println(CHEAT);
    }
    else {
      int res=-1 ;
      for(int i=0 ; i<=16 ; i++){
        if((possible &(1<<i))==0)continue ;
        if(res!=-1){
          out.println(BAD);
          return ;
        }
        res=i ;
      }
      out.println(res);
    }
  }
  public static void main(String[] args)throws IOException {
    long start=System.currentTimeMillis();
    in=new Scanner(new FileReader(inputFileName));
    out=new PrintWriter(outputFileName);
    int tests=in.nextInt();
    for(int t=1 ; t<=tests ; t++){
      out.print("Case #"+t+": ");
      new A().solve();
      System.out.println("Case #"+t+": solved");
    }
    in.close();
    out.close();
    long stop=System.currentTimeMillis();
    System.out.println(stop-start+" ms");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static    attribute fileName : String := "results/con2014Q/" + OclType["A"].getSimpleName()->toLowerCase();
  static    attribute inputFileName : String := fileName + ".in";
  static    attribute outputFileName : String := fileName + ".out";
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static    attribute BAD : String := "Bad magician!";
   operation solve() : void
  pre: true
  post: true
  activity: (     var R1 : int ; R1 := in.getCurrent()->toInteger() ;
     var possible : int ; possible := 0 ;
        var i : int ; i := 1 ; while i <= 4 do ( (         var j : int ; j := 1 ; while j <= 4 do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (i = R1) then (     possible := MathLib.bitwiseOr(possible, ((1*(2->pow(n)))->oclAsType(long))) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
(     R1 := in.getCurrent()->toInteger() ; 
     var possible2 : int ; possible2 := 0 ;
         var i : int ; i := 1 ; while i <= 4 do ( (         var j : int ; j := 1 ; while j <= 4 do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (i = R1) then (     possible2 := MathLib.bitwiseOr(possible2, ((1*(2->pow(n)))->oclAsType(long))) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     possible := MathLib.bitwiseAnd(possible, possible2) ) 
    if (possible = 0) then (     skip ) else (     var res : int ; res := -1 ;
         var i : int ; i := 0 ; while i <= 16 do ( (     if ((MathLib.bitwiseAnd(possible,((1*(2->pow(i)))->oclAsType(long)))) = 0) then     continue else skip ; 
     if (res /= -1) then (     skip ; 
     return ) else skip ; 
     res := i )  ;     i := i + 1 ) ; 
     skip ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : long ; start := OclDate.getSystemTime() ;
     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(inputFileName))) ; 
    out := OclFile.newOclFile_Write(OclFile.newOclFile(outputFileName)) ; 
    var tests : int ; tests := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= tests do ( (     skip ; 
     A.newA().solve() ; 
     OclFile["System.out"].println("Case #" + t + ": solved") )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
    var stop : long ; stop := OclDate.getSystemTime() ;
    OclFile["System.out"].println(stop - start + " ms") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileInputStream ;
import java.io.FileOutputStream ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class ProblemA {
  public static void main(String[] args)throws Exception {
    System.setIn(new FileInputStream("A-small-attempt0.in"));
    System.setOut(new PrintStream(new FileOutputStream("A-small-attempt0.out")));
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int caseNum=1 ; caseNum<=T ; caseNum++){
      int[] counts=new int[17];
      for(int turn=0 ; turn<2 ; turn++){
        int row=in.nextInt()-1 ;
        for(int r=0 ; r<4 ; r++){
          for(int c=0 ; c<4 ; c++){
            int n=in.nextInt();
            if(r==row){
              counts[n]++;
            }
          }
        }
      }
      int res=-2 ;
      for(int i=1 ; i<=16 ; i++){
        if(counts[i]==2){
          if(res==-2){
            res=i ;
          }
          else {
            res=-1 ;
          }
        }
      }
      if(res>0){
        System.out.printf("Case #%d: %d%n",caseNum,res);
      }
      else {
        System.out.printf("Case #%d: %s%n",caseNum,(res==-2)? "Volunteer cheated!" : "Bad magician!");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("A-small-attempt0.in"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("A-small-attempt0.out")))) ; 
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var caseNum : int ; caseNum := 1 ; while caseNum <= T do ( (     var counts : Sequence(int) ; counts := Integer.subrange(1,17)->collect(0) ;
         var turn : int ; turn := 0 ; while turn < 2 do ( (     var row : int ; row := in.getCurrent()->toInteger() - 1 ;
         var r : int ; r := 0 ; while r < 4 do ( (         var c : int ; c := 0 ; while c < 4 do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (r = row) then (     counts[n+1] := counts[n+1] + 1 ) else skip )  ;     c := c + 1 ) )  ;     r := r + 1 ) )  ;     turn := turn + 1 ) ; 
    var res : int ; res := -2 ;
        var i : int ; i := 1 ; while i <= 16 do ( (     if (counts[i+1] = 2) then (     if (res = -2) then (     res := i ) else (     res := -1 ) ) else skip )  ;     i := i + 1 ) ; 
    if (res > 0) then (     OclFile["System.out"].printf("Case #%d: %d%n", caseNum, res) ) else (     OclFile["System.out"].printf("Case #%d: %s%n", caseNum, if (res = -2) then "Volunteer cheated!" else "Bad magician!" endif) ) ;  
 )  ;     caseNum := caseNum + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int str=sc.nextInt();
      int ing=sc.nextInt();
      int exp=sc.nextInt();
      int count=0 ;
      if(str+exp>ing){
        if(ing>=str){
          exp-=ing-str+1 ;
          str=ing+1 ;
        }
        long diff=str+exp-ing ;
        long x=(int)diff/2+diff % 2 ;
        count=min(exp+1,x);
      }
      System.out.println(count);
    }
  }
  public static int min(long a,long b){
    return a<b ?(int)a :(int)b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var str : int ; str := sc.getCurrent()->toInteger() ;
     var ing : int ; ing := sc.getCurrent()->toInteger() ;
    var exp : int ; exp := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    if (str + exp > ing) then (     if (ing >= str) then (     exp := exp-(ing - str + 1) ; 
     str := ing + 1 ) else skip ; 
     var diff : long ; diff := str + exp - ing ;
     var x : long ; x := diff->oclAsType(int) / 2 + diff mod 2 ;
     count := Set{exp + 1, x}->min() ) else skip ; 
    OclFile["System.out"].println(count) ; 
 )  ;     i := i + 1 ) );
  static   operation min( a : long, b : long) : int
  pre: true
  post: true
  activity: (     return if a < b then a->oclAsType(int) else b->oclAsType(int) endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int min(int a,int b,int c){
    if(a<b && a<c)return a ;
    else if(b<c)return b ;
    else return c ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s1=sc.nextLine();
    String s2=sc.nextLine();
    int l1=s1.length();
    int l2=s2.length();
    int[][] dp=new int[l1+1][l2+1];
    for(int i1=0 ; i1<=l1 ; i1++){
      dp[i1][0]=i1 ;
    }
    for(int i2=0 ; i2<=l2 ; i2++){
      dp[0][i2]=i2 ;
    }
    for(int i1=1 ; i1<=l1 ; i1++){
      for(int i2=1 ; i2<=l2 ; i2++){
        int cost=(s1.charAt(i1-1)==s2.charAt(i2-1))? 0 : 1 ;
        dp[i1][i2]=min(dp[i1-1][i2-1]+cost,dp[i1-1][i2]+1,dp[i1][i2-1]+1);
      }
    }
    System.out.println(dp[l1][l2]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation min( a : int, b : int, c : int) : int
  pre: true
  post: true
  activity: (     if (a < b & a < c) then     return a else     if (b < c) then     return b else     return c ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := sc.nextLine() ;
    var s2 : String ; s2 := sc.nextLine() ;
    var l1 : int ; l1 := s1->size() ;
    var l2 : int ; l2 := s2->size() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,l1 + 1)->collect(Integer.subrange(1,l2 + 1)->collect(0)) ;
        var i1 : int ; i1 := 0 ; while i1 <= l1 do ( (     dp[i1+1][0+1] := i1 )  ;     i1 := i1 + 1 ) ; 
        var i2 : int ; i2 := 0 ; while i2 <= l2 do ( (     dp[0+1][i2+1] := i2 )  ;     i2 := i2 + 1 ) ; 
        var i1 : int ; i1 := 1 ; while i1 <= l1 do ( (         var i2 : int ; i2 := 1 ; while i2 <= l2 do ( (     var cost : int ; cost := if (s1->at(i1 - 1+1) = s2->at(i2 - 1+1)) then 0 else 1 endif ;
     dp[i1+1][i2+1] := Set{dp[i1 - 1+1][i2 - 1+1] + cost, dp[i1 - 1+1][i2+1] + 1, dp[i1+1][i2 - 1+1] + 1}->min() )  ;     i2 := i2 + 1 ) )  ;     i1 := i1 + 1 ) ; 
    OclFile["System.out"].println(dp[l1+1][l2+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    LevenshteinDistance solver=new LevenshteinDistance();
    solver.solve(1,in,out);
    out.close();
  }
  static class LevenshteinDistance {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      final String x=in.next();
      final String y=in.next();
      out.printf("%d\n",editDistance(x,x.length(),y,y.length()));
    }
    private int editDistance(final String a,final int alen,final String b,final int blen){
      int[][] dp=new int[alen+1][blen+1];
      for(int i=0 ; i<alen+1 ; i++){
        dp[i][0]=i ;
      }
      for(int j=0 ; j<blen+1 ; j++){
        dp[0][j]=j ;
      }
      for(int i=1 ; i<alen+1 ; i++){
        for(int j=1 ; j<blen+1 ; j++){
          dp[i][j]=Math.min(dp[i][j-1]+1,dp[i-1][j]+1);
          if(a.charAt(i-1)==b.charAt(j-1)){
            dp[i][j]=Math.min(dp[i][j],dp[i-1][j-1]);
          }
          else {
            dp[i][j]=Math.min(dp[i][j],dp[i-1][j-1]+1);
          }
        }
      }
      return dp[alen][blen];
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : LevenshteinDistance ; solver := LevenshteinDistance.newLevenshteinDistance() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class LevenshteinDistance {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var x : String ; x := in.getCurrent() ;
     var y : String ; y := in.getCurrent() ;
     skip );
   operation editDistance( a : String, alen : int, b : String, blen : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,alen + 1)->collect(Integer.subrange(1,blen + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i < alen + 1 do ( (     dp[i+1][0+1] := i )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < blen + 1 do ( (     dp[0+1][j+1] := j )  ;     j := j + 1 ) ; 
        var i : int ; i := 1 ; while i < alen + 1 do ( (         var j : int ; j := 1 ; while j < blen + 1 do ( (     dp[i+1][j+1] := Set{dp[i+1][j - 1+1] + 1, dp[i - 1+1][j+1] + 1}->min() ; 
     if (a->at(i - 1+1) = b->at(j - 1+1)) then (     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i - 1+1][j - 1+1]}->min() ) else (     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i - 1+1][j - 1+1] + 1}->min() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return dp[alen+1][blen+1] 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static InputStreamReader isr ;
  private static BufferedReader br ;
  public static void main(String args[]){
    isr=new InputStreamReader(System.in);
    br=new BufferedReader(isr);
    System.out.println(Levenshtein(getstrp(),getstrp()));
  }
  public static char[] getstrp(){
    String buf ;
    try {
      buf=br.readLine();
    }
    catch(Exception e){
      buf="" ;
    }
    buf=" "+buf ;
    return buf.toCharArray();
  }
  public static int Levenshtein(char[] a,char[] b){
    int al=a.length,bl=b.length ;
    int[][] state=new int[al][bl];
    int v=0,h=0 ;
    state[v][h]=0 ;
    for(h=1 ; h<bl ; h++){
      state[v][h]=state[v][h-1]+1 ;
    }
    for(v=1 ; v<al ; v++){
      h=0 ;
      state[v][h]=state[v-1][h]+1 ;
      for(h=1 ; h<bl ; h++){
        if(a[v]==b[h]){
          state[v][h]=Math.min(Math.min(state[v-1][h],state[v][h-1]),state[v-1][h-1]-1)+1 ;
        }
        else {
          state[v][h]=Math.min(Math.min(state[v-1][h],state[v][h-1]),state[v-1][h-1])+1 ;
        }
      }
    }
    return state[al-1][bl-1];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute isr : OclFile;
  static   attribute br : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     isr := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     br := OclFile.newOclFile_Read(isr) ; 
     OclFile["System.out"].println(Levenshtein(getstrp(), getstrp())) );
  static   operation getstrp() : Sequence(String)
  pre: true
  post: true
  activity: (     var buf : String ;
     try (     buf := br.readLine() )   catch (e : ProgramException) do (     buf := "" )
     buf := " " + buf ; 
     return buf->characters() );
  static   operation Levenshtein( a : Sequence(String), b : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var al : int ; al := a->size() ;
    var bl : int ; bl := b->size() ;
     var state : Sequence(Sequence(int)) ; state := Integer.subrange(1,al)->collect(Integer.subrange(1,bl)->collect(0)) ;
    var v : int ; v := 0 ;
    var h : int ; h := 0 ;
    state[v+1][h+1] := 0 ; 
        h := 1 ; while h < bl do ( (     state[v+1][h+1] := state[v+1][h - 1+1] + 1 )  ;     h := h + 1 ) ; 
        v := 1 ; while v < al do ( (     h := 0 ; 
     state[v+1][h+1] := state[v - 1+1][h+1] + 1 ; 
         h := 1 ; while h < bl do ( (     if (a[v+1] = b[h+1]) then (     state[v+1][h+1] := Set{Set{state[v - 1+1][h+1], state[v+1][h - 1+1]}->min(), state[v - 1+1][h - 1+1] - 1}->min() + 1 ) else (     state[v+1][h+1] := Set{Set{state[v - 1+1][h+1], state[v+1][h - 1+1]}->min(), state[v - 1+1][h - 1+1]}->min() + 1 ) )  ;     h := h + 1 ) )  ;     v := v + 1 ) ; 
    return state[(al)->char2byte() - 1+1][(bl)->char2byte() - 1+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int minDistance(String word1,String word2){
    int[][] dp ;
    dp=new int[word1.length()+1][word2.length()+1];
    for(int i=0 ; i<=word1.length(); i++){
      dp[i]=new int[word2.length()+1];
    }
    for(int w1Idx=word1.length(); w1Idx>=0 ; w1Idx--){
      for(int w2Idx=word2.length(); w2Idx>=0 ; w2Idx--){
        if(w1Idx==word1.length()|| w2Idx==word2.length()){
          dp[w1Idx][w2Idx]=Math.max(word1.length()-w1Idx,word2.length()-w2Idx);
          continue ;
        }
        int replaceCost=dp[w1Idx+1][w2Idx+1]+(word1.charAt(w1Idx)==word2.charAt(w2Idx)? 0 : 1);
        int insert1Cost=dp[w1Idx+1][w2Idx]+1 ;
        int insert2Cost=dp[w1Idx][w2Idx+1]+1 ;
        dp[w1Idx][w2Idx]=Math.min(insert1Cost,insert2Cost);
        dp[w1Idx][w2Idx]=Math.min(dp[w1Idx][w2Idx],replaceCost);
      }
    }
    return dp[0][0];
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String w1=in.nextLine();
    String w2=in.nextLine();
    System.out.println(minDistance(w1,w2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation minDistance( word1 : String, word2 : String) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ;
     dp := Integer.subrange(1,word1->size() + 1)->collect(Integer.subrange(1,word2->size() + 1)->collect(0)) ; 
        var i : int ; i := 0 ; while i <= word1->size() do ( (     dp[i+1] := Integer.subrange(1,word2->size() + 1)->collect(0) )  ;     i := i + 1 ) ; 
        var w1Idx : int ; w1Idx := word1->size() ; while w1Idx >= 0 do ( (         var w2Idx : int ; w2Idx := word2->size() ; while w2Idx >= 0 do ( (     if (w1Idx = word1->size() or w2Idx = word2->size()) then (     dp[w1Idx+1][w2Idx+1] := Set{word1->size() - w1Idx, word2->size() - w2Idx}->max() ; 
     continue ) else skip ; 
     var replaceCost : int ; replaceCost := dp[w1Idx + 1+1][w2Idx + 1+1] + (if word1->at(w1Idx+1) = word2->at(w2Idx+1) then 0 else 1 endif) ;
    var insert1Cost : int ; insert1Cost := dp[w1Idx + 1+1][w2Idx+1] + 1 ;
    var insert2Cost : int ; insert2Cost := dp[w1Idx+1][w2Idx + 1+1] + 1 ;
    dp[w1Idx+1][w2Idx+1] := Set{insert1Cost, insert2Cost}->min() ; 
    dp[w1Idx+1][w2Idx+1] := Set{dp[w1Idx+1][w2Idx+1], replaceCost}->min() ; 
 )  ;     w2Idx := w2Idx - 1 ) )  ;     w1Idx := w1Idx - 1 ) ; 
    return dp[0+1][0+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w1 : String ; w1 := in.nextLine() ;
     var w2 : String ; w2 := in.nextLine() ;
     OclFile["System.out"].println(minDistance(w1, w2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static String target ;
  static String base ;
  static int[][] dp ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    base=sc.next();
    target=sc.next();
    dp=new int[base.length()][target.length()];
    for(int[] arr : dp){
      Arrays.fill(arr,Integer.MIN_VALUE);
    }
    System.out.println(getLength(0,0));
  }
  static int getLength(int idx,int tidx){
    if(tidx>=target.length()){
      return base.length()-idx ;
    }
    if(idx>=base.length()){
      return target.length()-tidx ;
    }
    if(dp[idx][tidx]>=0){
      return dp[idx][tidx];
    }
    if(base.charAt(idx)==target.charAt(tidx)){
      return dp[idx][tidx]=getLength(idx+1,tidx+1);
    }
    return dp[idx][tidx]=Math.min(getLength(idx+1,tidx+1)+1,Math.min(getLength(idx,tidx+1)+1,getLength(idx+1,tidx)+1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute target : String;
  static   attribute base : String;
  static   attribute dp : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     base := sc.getCurrent() ; 
    target := sc.getCurrent() ; 
    dp := Integer.subrange(1,base->size())->collect(Integer.subrange(1,target->size())->collect(0)) ; 
    for (arr : dp) do ( (     arr := arr->collect(-2147483648) )  ) ; 
    OclFile["System.out"].println(getLength(0, 0)) ; 
 );
  static   operation getLength( idx : int, tidx : int) : int
  pre: true
  post: true
  activity: (     if (tidx >= target->size()) then (     return base->size() - idx ) else skip ; 
     if (idx >= base->size()) then (     return target->size() - tidx ) else skip ; 
    if (dp[idx+1][tidx+1] >= 0) then (     return dp[idx+1][tidx+1] ) else skip ; 
    if (base->at(idx+1) = target->at(tidx+1)) then (     return dp[idx+1][tidx+1] ) else skip ; 
    return dp[idx+1][tidx+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int numLen(int K){
    if(K % 2==0 || K % 5==0)return-1 ;
    int number=0 ;
    int len=1 ;
    for(len=1 ; len<=K ; len++){
      number=(number*10+1)% K ;
      if(number==0)return len ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    int K=7 ;
    System.out.print(numLen(K));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation numLen( K : int) : int
  pre: true
  post: true
  activity: (     if (K mod 2 = 0 or K mod 5 = 0) then     return -1 else skip ; 
     var number : int ; number := 0 ;
    var len : int ; len := 1 ;
        len := 1 ; while len <= K do ( (     number := (number * 10 + 1) mod K ; 
     if (number = 0) then     return len else skip )  ;     len := len + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var K : int ; K := 7 ;
     OclFile["System.out"].print(numLen(K)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
public class TEST {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0){
      int n=sc.nextInt();
      char c[]=sc.next().toCharArray();
      int del=n-1 ;
      for(int i=0 ; i<n ; i++){
        if(c[i]=='>' || c[n-1-i]=='<'){
          System.out.println(i);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TEST {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var c : Sequence(String) ; c := sc.getCurrent()->characters() ;
     var del : int ; del := n - 1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (c[i+1] = '>' or c[n - 1 - i+1] = '<') then (     OclFile["System.out"].println(i) ; 
     break ) else skip )  ;     i := i + 1 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int numLen(int K){
    if(K % 2==0 || K % 5==0){
      return-1 ;
    }
    int number=0 ;
    int len=1 ;
    for(len=1 ; len<=K ; len++){
      number=number*10+1 ;
      if((number % K==0)){
        return len ;
      }
    }
    return-1 ;
  }
  public static void main(String[] args){
    int K=7 ;
    System.out.println(numLen(K));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation numLen( K : int) : int
  pre: true
  post: true
  activity: (     if (K mod 2 = 0 or K mod 5 = 0) then (     return -1 ) else skip ; 
     var number : int ; number := 0 ;
    var len : int ; len := 1 ;
        len := 1 ; while len <= K do ( (     number := number * 10 + 1 ; 
     if ((number mod K = 0)) then (     return len ) else skip )  ;     len := len + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var K : int ; K := 7 ;
     OclFile["System.out"].println(numLen(K)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int numbers(int n,int arr[],int m){
    int isZero=0,isFive=0 ;
    int result=0 ;
    if(m<n){
      return-1 ;
    }
    for(int i=0 ; i<m ; i++){
      if(arr[i]==0){
        isZero=1 ;
      }
      if(arr[i]==5){
        isFive=1 ;
      }
    }
    if(isZero==1 && isFive==1){
      result=2 ;
      for(int i=0 ; i<n-1 ; i++){
        result=result*(--m);
      }
    }
    else if(isZero==1 || isFive==1){
      result=1 ;
      for(int i=0 ; i<n-1 ; i++){
        result=result*(--m);
      }
    }
    else {
      result=-1 ;
    }
    return result ;
  }
  public static void main(String[] args){
    int n=3,m=6 ;
    int arr[]={
      2,3,5,6,7,9 };
      System.out.println(numbers(n,arr,m));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation numbers( n : int, arr : Sequence(int), m : int) : int
  pre: true
  post: true
  activity: (     var isZero : int ; isZero := 0 ;
    var isFive : int ; isFive := 0 ;
     var result : int ; result := 0 ;
    if (m < n) then (     return -1 ) else skip ; 
        var i : int ; i := 0 ; while i < m do ( (     if (arr[i+1] = 0) then (     isZero := 1 ) else skip ; 
     if (arr[i+1] = 5) then (     isFive := 1 ) else skip )  ;     i := i + 1 ) ; 
    if (isZero = 1 & isFive = 1) then (     result := 2 ; 
         var i : int ; i := 0 ; while i < n - 1 do ( (         m := m - 1 ;
 result := result * (m)  )  ;     i := i + 1 ) ) else     if (isZero = 1 or isFive = 1) then (     result := 1 ; 
         var i : int ; i := 0 ; while i < n - 1 do ( (         m := m - 1 ;
 result := result * (m)  )  ;     i := i + 1 ) ) else (     result := -1 ) ;  ;  
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
    var m : int ; m := 6 ;
     var arr : Sequence(int) ; arr := Sequence{2,3,5,6,7,9} ;
     OclFile["System.out"].println(numbers(n, arr, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int sum_odd(int n){
    int sum=0,pos=1 ;
    while(n>0){
      if(pos % 2==1)sum+=n % 10 ;
      n=n/10 ;
      pos++;
    }
    return sum ;
  }
  static boolean check_prime(int n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  public static void main(String[] args){
    int n=223 ;
    int sum=sum_odd(n);
    if(check_prime(sum))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sum_odd( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
    var pos : int ; pos := 1 ;
     while (n > 0) do (     if (pos mod 2 = 1) then     sum := sum+(n mod 10) ; else skip ; 
     n := n / 10 ; 
     pos := pos + 1 ) ; 
     return sum );
  static   operation check_prime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 223 ;
     var sum : int ; sum := sum_odd(n) ;
     if (check_prime(sum)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      int m=scanner.nextInt();
      if((n | m)==0)break ;
      int[] num=new int[n+1];
      for(int i=1 ; i<=n ; i++)num[i]=scanner.nextInt();
      List<Integer>list=new ArrayList<Integer>();
      for(int i=0 ; i<=n ; i++)for(int j=i ; j<=n ; j++)if(num[i]+num[j]<=m)list.add(num[i]+num[j]);
      int ans=0 ;
      int i=0 ;
      int l=0 ;
      int r=list.size()-1 ;
      Collections.sort(list);
      while(i<r){
        l=i ;
        while(l<=r){
          int mid=(l+r)/2 ;
          int ret=list.get(i)+list.get(mid);
          if(ret<=m){
            ans=Math.max(ans,ret);
            l=mid+1 ;
          }
          else {
            r=mid-1 ;
          }
        }
        i++;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,m)) = 0) then     break else skip ; 
    var num : Sequence(int) ; num := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     num[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i <= n do (         var j : int ; j := i ; while j <= n do (     if (num[i+1] + num[j+1] <= m) then     list := list->including(num[i+1] + num[j+1]) ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var i : int ; i := 0 ;
    var l : int ; l := 0 ;
    var r : int ; r := list->size() - 1 ;
    list := list->sort() ; 
    while (i < r) do (     l := i ; 
     while (l <= r) do (     var mid : int ; mid := (l + r) / 2 ;
     var ret : int ; ret := list->at(i+1) + list->at(mid+1) ;
     if (ret <= m) then (     ans := Set{ans, ret}->max() ; 
     l := mid + 1 ) else (     r := mid - 1 ) ) ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int str=s.nextInt(),in=s.nextInt(),exp=s.nextInt();
      int ans=exp+in-str ;
      if(ans<0){
        System.out.println(exp+1);
        continue ;
      }
      ans/=2 ;
      ans++;
      System.out.println(Math.max(0,exp-ans+1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var str : int ; str := s.getCurrent()->toInteger() ;
    var in : int ; in := s.getCurrent()->toInteger() ;
    var exp : int ; exp := s.getCurrent()->toInteger() ;
     var ans : int ; ans := exp + in - str ;
    if (ans < 0) then (     OclFile["System.out"].println(exp + 1) ; 
     continue ) else skip ; 
    ans := ans/(2) ; 
    ans := ans + 1 ; 
    OclFile["System.out"].println(Set{0, exp - ans + 1}->max()) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] $){
    while(true){
      int n=sc.nextInt();
      long m=sc.nextLong();
      if(n==0 && m==0)break ;
      long[] p=new long[n+1];
      for(int i=0 ; i<n ; i++){
        p[i]=sc.nextLong();
      }
      p[n]=0 ;
      long[] data=new long[(n+1)*(n+1)+1];
      int c=0 ;
      for(int i=0 ; i<n+1 ; i++){
        for(int j=0 ; j<n+1 ; j++){
          data[c++]=p[i]+p[j];
        }
      }
      data[c++]=Long.MIN_VALUE ;
      Arrays.sort(data);
      int index=0 ;
      long ans=0 ;
      for(int i=0 ; i<c ; i++){
        index=Arrays.binarySearch(data,m-data[i]);
        if(index<0)index=~ index-1 ;
        ans=max(ans,data[i]+data[index]);
      }
      out.println(ans);
    }
    out.close();
  }
  static PrintWriter out=new PrintWriter(System.out);
  static class sc {
    static Scanner s=new Scanner(System.in);
    static String next(){
      return s.next();
    }
    static int nextInt(){
      return Integer.parseInt(s.next());
    }
    static long nextLong(){
      return Long.parseLong(s.next());
    }
    static double nextDouble(){
      return Double.parseDouble(s.next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.nextInt() ;
     var m : long ; m := sc.nextLong() ;
    if (n = 0 & m = 0) then     break else skip ; 
    var p : Sequence(long) ; p := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := sc.nextLong() )  ;     i := i + 1 ) ; 
    p[n+1] := 0 ; 
    var data : Sequence(long) ; data := Integer.subrange(1,(n + 1) * (n + 1) + 1)->collect(0) ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n + 1 do ( (         var j : int ; j := 0 ; while j < n + 1 do ( (      data[c+1] := p[i+1] + p[j+1]  ; c := c + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     data[c+1] := "-9223372036854775808"->toLong()  ; c := c + 1 ; 
    data := data->sort() ; 
    var index : int ; index := 0 ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < c do ( (     index := (data->indexOf(m - data[i+1]) - 1) ; 
     if (index < 0) then     index := -(index + 1) - 1 ; else skip ; 
     ans := Set{ans, data[i+1] + data[index+1]}->max() )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 ) ; 
     out.close() );
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static class sc {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation next() : String
  pre: true
  post: true
  activity: (     return s.getCurrent() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toLong() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if((n | m)==0)break ;
      int p[]=new int[n+1];
      p[0]=0 ;
      for(int i=1 ; i<=n ; i++)p[i]=sc.nextInt();
      int num[]=new int[(n+1)*(n+1)];
      int size=0 ;
      for(int i=0 ; i<=n ; i++)for(int j=0 ; j<=n ; j++){
        if(p[i]+p[j]<=m)num[size++]=p[i]+p[j];
      }
      sort(num);
      int max=0 ;
      for(int i=0 ; i<(n+1)*(n+1); i++){
        int lim=m-num[i];
        int left=0 ;
        int right=size ;
        while(left<right){
          int c=(left+right)/2 ;
          if(lim>num[c]){
            left=c+1 ;
          }
          else if(lim<num[c]){
            right=c ;
          }
          else {
            break ;
          }
        }
        max=max(max,num[i]+num[right-1]);
      }
      System.out.println(max);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,m)) = 0) then     break else skip ; 
    var p : Sequence(int) ; p := Integer.subrange(1,n + 1)->collect(0) ;
    p[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do (     p[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var num : Sequence(int) ; num := Integer.subrange(1,(n + 1) * (n + 1))->collect(0) ;
    var size : int ; size := 0 ;
        var i : int ; i := 0 ; while i <= n do (         var j : int ; j := 0 ; while j <= n do ( (     if (p[i+1] + p[j+1] <= m) then      num[size+1] := p[i+1] + p[j+1]  ; size := size + 1 ; else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    execute sort(num) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < (n + 1) * (n + 1) do ( (     var lim : int ; lim := m - num[i+1] ;
     var left : int ; left := 0 ;
    var right : int ; right := size ;
    while (left < right) do (     var c : int ; c := (left + right) / 2 ;
     if (lim > num[c+1]) then (     left := c + 1 ) else     if (lim < num[c+1]) then (     right := c ) else (     break ) ;  ) ; 
    max := Set{max, num[i+1] + num[right - 1+1]}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  private static final Integer Z=Integer.valueOf(0);
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n,m ;
    TreeSet<Integer>_1=new TreeSet<Integer>();
    TreeSet<Integer>_2=new TreeSet<Integer>();
    _1.add(Integer.valueOf(0));
    while((n=in.nextInt())>0 &&(m=in.nextInt())>0){
      _1.clear();
      _1.add(Integer.valueOf(0));
      _2.clear();
      _2.add(Integer.valueOf(0));
      int floor=0 ;
      for(int i=0 ; i<n && floor<m ; i++){
        final int sc=in.nextInt();
        _1.add(Integer.valueOf(sc));
        for(Integer pt : _1){
          int pti=pt.intValue();
          pti+=sc ;
          if(pti<=m)_2.add(Integer.valueOf(pti));
        }
      }
      for(Integer pt : _2){
        int pti=pt.intValue();
        final int i=m-pti ;
        int _2floor=_2.floor(Integer.valueOf(i)).intValue();
        floor=Math.max(floor,_2floor+pti);
        if(floor==m){
          break ;
        }
      }
      System.out.println(floor);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute Z : int := (0)->toInteger();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var m : int ;
    var     var Set(int) : int ; Set(int) := Set{} : Set(int) ;     var Set(int) : int ; Set(int) := Set{} := Set{} ;
    var Set{} : Set(int) ; Set{} := Set{} ;
    _1->excludes((0)->toInteger())->excludes((0)->toInteger()) ; 
        n := in.getCurrent()->toInteger() ;
    m := in.getCurrent()->toInteger() ;
    while ((n) > 0 & (m) > 0) do (    skip ; (     _1.clear() := _1.clear()->intersection(Set{}) ; 
     _1->excludes((0)->toInteger())->excludes((0)->toInteger()) ; 
    clear() := clear()->intersection(Set{}) ; 
    add((0)->toInteger())->excludes((0)->toInteger()) ; 
    var floor : int ; floor := 0 ;
        var i : int ; i := 0 ; while i < n & floor < m do ( (     var sc : int ; sc := in.getCurrent()->toInteger() ;
     _1->excludes((sc)->toInteger())->excludes((sc)->toInteger()) ; 
     for (pt :     for (pt :     var sc : int ; sc := in.getCurrent()->toInteger() ;
) do ( (     var pti : int ; pti := pt->oclAsType(int) ;
     pti := pti+(sc) ; 
     if (pti <= m) then     add((pti)->toInteger())->excludes((pti)->toInteger()) ; else skip )  ) ;) do ( (     var pti : int ; pti := pt->oclAsType(int) ;
     pti := pti+(sc) ; 
     if (pti <= m) then     add((pti)->toInteger())->excludes((pti)->toInteger()) ; else skip )  ) )  ;     i := i + 1 ) ; 
    for (pt : (     var pti : int ; pti := pt->oclAsType(int) ;
     var i : int ; i := m - pti ;
    var floor((i)->toInteger()).floor((i)->toInteger())->oclAsType(int)floor : int ; floor((i)->toInteger()).floor((i)->toInteger())->oclAsType(int)floor := floor((i)->toInteger()).floor((i)->toInteger())->oclAsType(int) ;
    floor := Set{floor, ptifloor + pti}->max() ; 
    if (floor = m) then (     break ) else skip ; 
 )) do ( (     var pti : int ; pti := pt->oclAsType(int) ;
     var i : int ; i := m - pti ;
    var floor((i)->toInteger()).floor((i)->toInteger())->oclAsType(int)floor : int ; floor((i)->toInteger()).floor((i)->toInteger())->oclAsType(int)floor := floor((i)->toInteger()).floor((i)->toInteger())->oclAsType(int) ;
    floor := Set{floor, ptifloor + pti}->max() ; 
    if (floor = m) then (     break ) else skip ; 
 )  ) ; 
    OclFile["System.out"].println(floor) ; 
 ) ;     n := in.getCurrent()->toInteger() ;
    m := in.getCurrent()->toInteger() ;
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String line[]=br.readLine().split(" ");
      int n=Integer.parseInt(line[0]);
      int m=Integer.parseInt(line[1]);
      if(n==0){
        break ;
      }
      int[] onelist=new int[n+1];
      for(int i=1 ; i<=n ; i++){
        onelist[i]=Integer.parseInt(br.readLine());
      }
      int[] twolist=new int[(n+2)*(n+1)/2];
      for(int i=0 ; i<=n ; i++){
        for(int j=i ; j<=n ; j++){
          twolist[i*(n+1)-i*(i+1)/2+j]=onelist[i]+onelist[j];
        }
      }
      Arrays.sort(twolist);
      int maxi=(n+2)*(n+1)/2 ;
      KOKO : for(int i=0 ;
      i<m ;
      i++){
        for(int j=0 ; j<maxi ; j++){
          if(Arrays.binarySearch(twolist,m-i-twolist[j])>0){
            System.out.println(m-i);
            break KOKO ;
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
     var n : int ; n := (line[0+1])->toInteger() ;
    var m : int ; m := (line[1+1])->toInteger() ;
    if (n = 0) then (     break ) else skip ; 
    var onelist : Sequence(int) ; onelist := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     onelist[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    var twolist : Sequence(int) ; twolist := Integer.subrange(1,(n + 2) * (n + 1) / 2)->collect(0) ;
        var i : int ; i := 0 ; while i <= n do ( (         var j : int ; j := i ; while j <= n do ( (     twolist[i * (n + 1) - i * (i + 1) / 2 + j+1] := onelist[i+1] + onelist[j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    twolist := twolist->sort() ; 
    var maxi : int ; maxi := (n + 2) * (n + 1) / 2 ;
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j < maxi do ( (     if ((twolist->indexOf(m - i - twolist[j+1]) - 1) > 0) then (     OclFile["System.out"].println(m - i) ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] in=sc.next().toCharArray();
    int max=0 ;
    int jsum=0 ;
    int osum=0 ;
    int isum=0 ;
    for(int i=0 ; i<in.length ; i++){
      if(i!=0 && in[i]=='J' && in[i-1]!='J')jsum=0 ;
      if(i!=0 && in[i]=='O' && in[i-1]=='I'){
        jsum=0 ;
        osum=0 ;
        isum=0 ;
      }
      if(i!=0 && in[i]=='I' && in[i-1]=='J'){
        jsum=0 ;
        osum=0 ;
        isum=0 ;
      }
      if(in[i]=='J'){
        jsum++;
        osum=0 ;
        isum=0 ;
      }
      if(in[i]=='O'){
        osum++;
        isum=0 ;
      }
      if(in[i]=='I'){
        isum++;
      }
      if(jsum>=osum && isum>=osum)max=Math.max(osum,max);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var in : Sequence(String) ; in := sc.getCurrent()->characters() ;
    var max : int ; max := 0 ;
    var jsum : int ; jsum := 0 ;
    var osum : int ; osum := 0 ;
    var isum : int ; isum := 0 ;
        var i : int ; i := 0 ; while i < in->size() do ( (     if (i /= 0 & in[i+1] = 'J' & in[i - 1+1] /= 'J') then     jsum := 0 ; else skip ; 
     if (i /= 0 & in[i+1] = 'O' & in[i - 1+1] = 'I') then (     jsum := 0 ; 
     osum := 0 ; 
     isum := 0 ) else skip ; 
    if (i /= 0 & in[i+1] = 'I' & in[i - 1+1] = 'J') then (     jsum := 0 ; 
     osum := 0 ; 
     isum := 0 ) else skip ; 
    if (in[i+1] = 'J') then (     jsum := jsum + 1 ; 
     osum := 0 ; 
     isum := 0 ) else skip ; 
    if (in[i+1] = 'O') then (     osum := osum + 1 ; 
     isum := 0 ) else skip ; 
    if (in[i+1] = 'I') then (     isum := isum + 1 ) else skip ; 
    if (jsum >= osum & isum >= osum) then     max := Set{osum, max}->max() ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
      Arrays.sort(arr);
      long s1=0,s2=0 ;
      for(int i=n-1 ; i>=n/2 ; i--){
        s1+=arr[i];
      }
      for(int i=0 ; i<n/2 ; i++){
        s2+=arr[i];
      }
      long ans=((s1*s1)+(s2*s2));
      System.out.println(ans);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var s1 : long ; s1 := 0 ;
    var s2 : long ; s2 := 0 ;
        var i : int ; i := n - 1 ; while i >= n / 2 do ( (     s1 := s1+(arr[i+1]) )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n / 2 do ( (     s2 := s2+(arr[i+1]) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := ((s1 * s1) + (s2 * s2)) ;
    OclFile["System.out"].println(ans) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  int J ;
  int O ;
  int I ;
  int max ;
  char t ;
  public void run(){
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      String str=scan.nextLine();
      if(str.indexOf("J")<0 || str.indexOf("O")<0 || str.indexOf("I")<0){
        System.out.println(0);
        continue ;
      }
      J=0 ;
      O=0 ;
      I=0 ;
      max=0 ;
      for(int i=0 ; i<str.length(); i++){
        t=str.charAt(i);
        if(t=='J'){
          if(I>0){
            int a=(O>I)? 0 : Math.min(I,Math.min(O,J));
            max=(max<a)? a : max ;
            J=0 ;
            O=0 ;
            I=0 ;
          }
          else if(O>0){
            J=0 ;
            O=0 ;
          }
          J++;
        }
        else if(t=='O'){
          if(I>0){
            int a=(O>I)? 0 : Math.min(I,Math.min(O,J));
            max=(max<a)? a : max ;
            J=0 ;
            O=0 ;
            I=0 ;
          }
          else if(J>0){
            O++;
            if(J<O){
              J=0 ;
              O=0 ;
            }
          }
        }
        else if(t=='I'){
          if(J>0 && O>0){
            I++;
          }
          else {
            J=0 ;
            O=0 ;
            I=0 ;
          }
        }
      }
      if(I>0){
        int a=(O>I)? 0 : Math.min(I,Math.min(O,J));
        max=(max<a)? a : max ;
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute J : int;
   attribute O : int;
   attribute I : int;
   attribute max : int;
   attribute t : String;
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var str : String ; str := scan.nextLine() ;
     if (str->indexOf("J")-1 < 0 or str->indexOf("O")-1 < 0 or str->indexOf("I")-1 < 0) then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
    J := 0 ; 
    O := 0 ; 
    I := 0 ; 
    max := 0 ; 
        var i : int ; i := 0 ; while i < str->size() do ( (     t := str->at(i+1) ; 
     if (t = 'J') then (     if (I > 0) then (     var a : int ; a := if (O > I) then 0 else Set{I, Set{O, J}->min()}->min() endif ;
     max := if (max < a) then a else max endif ; 
    J := 0 ; 
    O := 0 ; 
    I := 0 ; 
 ) else     if (O > 0) then (     J := 0 ; 
     O := 0 ) else skip ; ;  
     J := J + 1 ) else     if (t = 'O') then (     if (I > 0) then (     var a : int ; a := if (O > I) then 0 else Set{I, Set{O, J}->min()}->min() endif ;
     max := if (max < a) then a else max endif ; 
    J := 0 ; 
    O := 0 ; 
    I := 0 ; 
 ) else     if (J > 0) then (     O := O + 1 ; 
     if (J < O) then (     J := 0 ; 
     O := 0 ) else skip ) else skip ; ) else     if (t = 'I') then (     if (J > 0 & O > 0) then (     I := I + 1 ) else (     J := 0 ; 
     O := 0 ; 
     I := 0 ) ) else skip ; ;  )  ;     i := i + 1 ) ; 
    if (I > 0) then (     var a : int ; a := if (O > I) then 0 else Set{I, Set{O, J}->min()}->min() endif ;
     max := if (max < a) then a else max endif ) else skip ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  class R {
    char ch ;
    int c ;
    public R(char ch,int c){
      this.ch=ch ;
      this.c=c ;
    }
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    char[] s=sc.next().toCharArray();
    int n=s.length,c=1 ;
    char r=s[0];
    List<R>l=new ArrayList<R>();
    for(int i=1 ; i<n ; i++){
      if(s[i]!=r){
        l.add(new R(r,c));
        r=s[i];
        c=0 ;
      }
      c++;
    }
    l.add(new R(r,c));
    int res=0 ;
    for(int i=1 ; i<l.size()-1 ; i++){
      R r1=l.get(i-1),r2=l.get(i),r3=l.get(i+1);
      if(r1.ch=='J' && r2.ch=='O' && r3.ch=='I' && r2.c<=r1.c && r2.c<=r3.c)res=Math.max(res,r2.c);
    }
    System.out.println(res);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class R {
   attribute ch : String;
   attribute c : int;
   static operation newR( ch : String, c : int) : R
  pre: true
  post: true
  activity:
  ( var self : R ;
    self := createR();
    self.initialise(ch, c);
    return self );
  operation initialise( ch : String, c : int) : void
  pre: true  post: true
  activity: (     self.ch := ch ; 
     self.c := c );
}
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var n : int ; n := s->size() ;
    var c : int ; c := 1 ;
    var r : String ; r := s[0+1] ;
    var l : Sequence(R) ; l := Sequence{} ;
        var i : int ; i := 1 ; while i < n do ( (     if (s[i+1] /= r) then (     l := l->including(R.newR(r, c)) ; 
     r := s[i+1] ; 
     c := 0 ) else skip ; 
     c := c + 1 )  ;     i := i + 1 ) ; 
    l := l->including(R.newR(r, c)) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 1 ; while i < l->size() - 1 do ( (     var r1 : R ; r1 := l->at(i - 1+1) ;
    var r2 : R ; r2 := l->at(i+1) ;
    var r3 : R ; r3 := l->at(i + 1+1) ;
     if (r1.ch = 'J' & r2.ch = 'O' & r3.ch = 'I' & r2.c <= r1.c & r2.c <= r3.c) then     res := Set{res, r2.c}->max() ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      List<Character>cs=new ArrayList<Character>();
      List<Integer>ls=new ArrayList<Integer>();
      int last=0 ;
      cs.add('X');
      ls.add(1);
      for(int i=0 ; i<line.length(); i++){
        if(cs.get(last)==line.charAt(i)){
          ls.set(last,ls.get(last)+1);
        }
        else {
          cs.add(line.charAt(i));
          ls.add(1);
          last++;
        }
      }
      cs.add('X');
      ls.add(1);
      int k=0 ;
      for(int i=0 ; i<cs.size(); i++){
        if(cs.get(i)=='O'){
          int l=ls.get(i);
          if(l<=k)continue ;
          if(cs.get(i-1)=='J' && cs.get(i+1)=='I' && ls.get(i-1)>=l && ls.get(i+1)>=l){
            k=Math.max(k,l);
          }
        }
      }
      System.out.println(k);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var cs : Sequence(String) ; cs := Sequence{} ;
     var ls : Sequence(int) ; ls := Sequence{} ;
    var last : int ; last := 0 ;
    cs := cs->including('X') ; 
    ls := ls->including(1) ; 
        var i : int ; i := 0 ; while i < line->size() do ( (     if (cs->at(last+1) = line->at(i+1)) then (     ls := ls.setAt(last+1,ls->at(last+1) + 1) ) else (     cs := cs->including(line->at(i+1)) ; 
     ls := ls->including(1) ; 
     last := last + 1 ) )  ;     i := i + 1 ) ; 
    cs := cs->including('X') ; 
    ls := ls->including(1) ; 
    var k : int ; k := 0 ;
        var i : int ; i := 0 ; while i < cs->size() do ( (     if (cs->at(i+1) = 'O') then (     var l : int ; l := ls->at(i+1) ;
     if (l <= k) then     continue else skip ; 
     if (cs->at(i - 1+1) = 'J' & cs->at(i + 1+1) = 'I' & ls->at(i - 1+1) >= l & ls->at(i + 1+1) >= l) then (     k := Set{k, l}->max() ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(k) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static {
    for(int i=0 ; i<30000 ; i++){
    }
    for(int i=0 ; i<30000 ; i++){
    }
    for(int i=0 ; i<30000 ; i++){
    }
  }
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    char[] s=cin.next().toCharArray();
    int N=300000 ;
    String J="J" ;
    String O="O" ;
    String I="I" ;
    int ans=0 ;
    for(int i=0 ; i<s.length ; i++){
      while(i<s.length && s[i]=='J'){
        int cntj=0 ;
        while(i<s.length && s[i]=='J'){
          cntj++;
          i++;
        }
        int cnto=0 ;
        while(i<s.length && s[i]=='O'){
          cnto++;
          i++;
        }
        if(cntj<cnto){
          continue ;
        }
        int cnti=0 ;
        while(i<s.length && s[i]=='I'){
          cnti++;
          i++;
        }
        if(cnto<=cnti){
          ans=Math.max(ans,cnto);
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static operation initialiseClass()
  pre: true post: true
  activity:         var i : int ; i := 0 ; while i < 30000 do ( skip  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 30000 do ( skip  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 30000 do ( skip  ;     i := i + 1 ) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := cin.getCurrent()->characters() ;
    var N : int ; N := 300000 ;
    var J : String ; J := "J" ;
    var O : String ; O := "O" ;
    var I : String ; I := "I" ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     while (i < s->size() & s[i+1] = 'J') do (     var cntj : int ; cntj := 0 ;
     while (i < s->size() & s[i+1] = 'J') do (     cntj := cntj + 1 ; 
     i := i + 1 ) ; 
    var cnto : int ; cnto := 0 ;
    while (i < s->size() & s[i+1] = 'O') do (     cnto := cnto + 1 ; 
     i := i + 1 ) ; 
    if (cntj < cnto) then (     continue ) else skip ; 
    var cnti : int ; cnti := 0 ;
    while (i < s->size() & s[i+1] = 'I') do (     cnti := cnti + 1 ; 
     i := i + 1 ) ; 
    if (cnto <= cnti) then (     ans := Set{ans, cnto}->max() ) else skip ; 
 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int M=4 ;
  static int arr[][]={
    {
      1,7,3,4 },{
        4,2,5,1 },{
          9,5,1,8 }
        };
        static void sort(int a[][],int row,int n){
          for(int i=0 ; i<M-1 ; i++){
            if(a[row][i]>a[row][i+1]){
              int temp=a[row][i];
              a[row][i]=a[row][i+1];
              a[row][i+1]=temp ;
            }
          }
        }
        static int maximumSum(int a[][],int n){
          for(int i=0 ; i<n ; i++)sort(a,i,n);
          int sum=a[n-1][M-1];
          int prev=a[n-1][M-1];
          int i,j ;
          for(i=n-2 ; i>=0 ; i--){
            for(j=M-1 ; j>=0 ; j--){
              if(a[i][j]<prev){
                prev=a[i][j];
                sum+=prev ;
                break ;
              }
            }
            if(j==-1)return 0 ;
          }
          return sum ;
        }
        public static void main(String args[]){
          int n=arr.length ;
          System.out.print(maximumSum(arr,n));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute M : int := 4;
  static   attribute arr : int := Sequence{Sequence{1,7,3,4},Sequence{4,2,5,1},Sequence{9,5,1,8}};
  static   operation sort( a : Sequence(Sequence(int)), row : int, n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < M - 1 do ( (     if (a[row+1][i+1] > a[row+1][i + 1+1]) then (     var temp : int ; temp := a[row+1][i+1] ;
     a[row+1][i+1] := a[row+1][i + 1+1] ; 
     a[row+1][i + 1+1] := temp ) else skip )  ;     i := i + 1 ) );
  static   operation maximumSum( a : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     execute sort(a, i, n) ;  ;     i := i + 1 ) ; 
     var sum : int ; sum := a[n - 1+1][M - 1+1] ;
    var prev : int ; prev := a[n - 1+1][M - 1+1] ;
    var i : int ;
    var j : int ;
        i := n - 2 ; while i >= 0 do ( (         j := M - 1 ; while j >= 0 do ( (     if (a[i+1][j+1] < prev) then (     prev := a[i+1][j+1] ; 
     sum := sum+(prev) ; 
     break ) else skip )  ;     j := j - 1 ) ; 
     if (j = -1) then     return 0 else skip )  ;     i := i - 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(maximumSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
    int T=Integer.parseInt(in.readLine());
    for(int i=0 ; i<T ; i++){
      String[] data=in.readLine().split(" ");
      int st=Integer.parseInt(data[0]);
      int it=Integer.parseInt(data[1]);
      int xp=Integer.parseInt(data[2]);
      if(st<it){
        xp-=it-st ;
        st=it ;
      }
      if(st==it){
        st++;
        xp--;
      }
      st-=it ;
      it=0 ;
      if(xp<0){
        out.write("0\n");
      }
      else {
        out.write(Math.min(xp+1,(st+xp+1)/2)+"\n");
      }
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var T : int ; T := (in.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < T do ( (     var data : Sequence(String) ; data := in.readLine()->split(" ") ;
     var st : int ; st := (data[0+1])->toInteger() ;
    var it : int ; it := (data[1+1])->toInteger() ;
    var xp : int ; xp := (data[2+1])->toInteger() ;
    if (st < it) then (     xp := xp-(it - st) ; 
     st := it ) else skip ; 
    if (st = it) then (     st := st + 1 ; 
     xp := xp - 1 ) else skip ; 
    st := st-(it) ; 
    it := 0 ; 
    if (xp < 0) then (     skip ) else (     skip ) ;  
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long A=in.nextLong();
    long B=in.nextLong();
    pw.println(calc(B)-calc(A-1));
    pw.close();
  }
  public static long calc(long B){
    if(B<10)return B ;
    long res=B/10+8 ;
    String lol=B+"" ;
    if(lol.charAt(0)<=lol.charAt(lol.length()-1))res++;
    return res ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var A : long ; A := in.getCurrent()->toLong() ;
    var B : long ; B := in.getCurrent()->toLong() ;
    skip ; 
    skip ; 
 );
  static   operation calc( B : long) : long
  pre: true
  post: true
  activity: (     if (B < 10) then     return B else skip ; 
     var res : long ; res := B / 10 + 8 ;
    var lol : String ; lol := B + "" ;
    if (lol->at(0+1) <= lol->at(lol->size() - 1+1)) then     res := res + 1 ; else skip ; 
    return res 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[]){
    FastReader input=new FastReader();
    PrintWriter out=new PrintWriter(System.out);
    int T=1 ;
    while(T-->0){
      int k=input.nextInt();
      int len=0,sec=0,x=0 ;
      for(int l=2 ; l<=2000 ; l++){
        int f=0 ;
        for(int y=1 ; y<=2000 ; y++){
          int p=k+y*l ;
          if(p %(l-1)==0){
            int q=p/(l-1);
            if(q<=1000000){
              f=1 ;
              len=l ;
              sec=y ;
              x=q ;
              break ;
            }
          }
        }
        if(f==1){
          break ;
        }
      }
      out.println(len);
      for(int i=0 ; i<len-2 ; i++){
        out.print(0+" ");
      }
      out.print(-sec+" "+x);
    }
    out.close();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastReader ; input := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := 1 ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     var k : int ; k := input.nextInt() ;
     var len : int ; len := 0 ;
    var sec : int ; sec := 0 ;
    var x : int ; x := 0 ;
        var l : int ; l := 2 ; while l <= 2000 do ( (     var f : int ; f := 0 ;
         var y : int ; y := 1 ; while y <= 2000 do ( (     var p : int ; p := k + y * l ;
     if (p mod (l - 1) = 0) then (     var q : int ; q := p / (l - 1) ;
     if (q <= 1000000) then (     f := 1 ; 
     len := l ; 
    sec := y ; 
    x := q ; 
    break 
 ) else skip ) else skip )  ;     y := y + 1 ) ; 
     if (f = 1) then (     break ) else skip )  ;     l := l + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < len - 2 do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class E {
  public static void main(String[] args){
    new E();
  }
  public E(){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int T=1 ;
    while(T-->0){
      int K=fs.nextInt();
      int[] arr=new int[1999];
      arr[0]=-1 ;
      for(int i=1 ; i<arr.length-1 ; i++)arr[i]=1 ;
      arr[arr.length-1]=2 ;
      for(int elem=arr.length-1 ; elem>0 ; elem--){
        int canTake=1000000-arr[elem];
        canTake=Math.min(canTake,K);
        arr[elem]+=canTake ;
        K-=canTake ;
      }
      out.println(arr.length);
      for(int i=0 ; i<arr.length ; i++){
        if(i>0)out.print(" ");
        out.print(arr[i]);
      }
      out.println();
    }
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class E {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( E.newE() );
   static operation newE() : E
  pre: true
  post: true
  activity:
  ( var self : E ;
    self := createE();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := 1 ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     var K : int ; K := fs.nextInt() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,1999)->collect(0) ;
    arr[0+1] := -1 ; 
        var i : int ; i := 1 ; while i < arr->size() - 1 do (     arr[i+1] := 1 ;  ;     i := i + 1 ) ; 
    arr[arr->size() - 1+1] := 2 ; 
        var elem : int ; elem := arr->size() - 1 ; while elem > 0 do ( (     var canTake : int ; canTake := 1000000 - arr[elem+1] ;
     canTake := Set{canTake, K}->min() ; 
     arr[elem+1] := arr[elem+1]+(canTake) ; 
     K := K-(canTake) )  ;     elem := elem - 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (i > 0) then     skip ; else skip ; 
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Comparator ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class ProblemB {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    PriorityQueue pq=new PriorityQueue<int[]>(Comparator.comparingInt(o->((int[])o)[0]).reversed());
    for(int i=1 ; i<2*n ; i++)for(int j=0 ; j<i ; j++)pq.add(new int[] { sc.nextInt(),i,j } );
      int[] used=new int[2*n];
      while(! pq.isEmpty()){
        int[] value=(int[])pq.poll();
        if(used[value[1] ]==0 && used[value[2] ]==0){
          used[value[1] ]=value[2]+1 ;
          used[value[2] ]=value[1]+1 ;
        }
      }
      StringBuilder builder=new StringBuilder();
      for(int i=0 ; i<2*n ; i++){
        builder.append(used[i]);
        if(i!=2*n-1)builder.append(" ");
      }
      System.out.println(builder);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var pq : Sequence ; pq := Sequence{}->union(Comparator.comparingInt(lambda o : OclAny in (o->oclAsType(Sequence(int)))[0+1]).reversed()) ;
        var i : int ; i := 1 ; while i < 2 * n do (         var j : int ; j := 0 ; while j < i do (     pq := pq->including(Sequence{sc.getCurrent()->toInteger(),i,j}) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var used : Sequence(int) ; used := Integer.subrange(1,2 * n)->collect(0) ;
    while (not(pq->isEmpty())) do (     var value : Sequence(int) ; value := pq->min()->oclAsType(Sequence(int)) ;
     if (used[value[1+1]+1] = 0 & used[value[2+1]+1] = 0) then (     used[value[1+1]+1] := value[2+1] + 1 ; 
     used[value[2+1]+1] := value[1+1] + 1 ) else skip ) ; 
    var builder : String ; builder := StringLib.newString() ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     builder := builder + StringLib.newString(used[i+1]) ; 
     if (i /= 2 * n - 1) then     builder := builder + StringLib.newString(" ") ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(builder) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.util.*;
public class B1140 {
  public static void main(String[] args)throws IOException {
    StringBuffer ans=new StringBuffer();
    StringTokenizer st ;
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    st=new StringTokenizer(f.readLine());
    int t=Integer.parseInt(st.nextToken());
    for(; t>0 ; t--){
      st=new StringTokenizer(f.readLine());
      int n=Integer.parseInt(st.nextToken());
      st=new StringTokenizer(f.readLine());
      String str=st.nextToken();
      int curr=0 ;
      for(; curr<n && str.charAt(curr)!='>' ; curr++);
      int j=n-1 ;
      for(; j>-1 && str.charAt(j)!='<' ; j--);
      ans.append(Math.min(n-1-j,curr)).append("\n");
    }
    f.close();
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1140 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ans : String ; ans := StringLib.newString() ;
     var st : OclIterator ;
    var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    st := OclIterator.newOclIterator_String(f.readLine()) ; 
    var t : int ; t := (st.next())->toInteger() ;
      while t > 0 do ( (     st := OclIterator.newOclIterator_String(f.readLine()) ; 
     var n : int ; n := (st.next())->toInteger() ;
    st := OclIterator.newOclIterator_String(f.readLine()) ; 
    var str : String ; str := st.next() ;
    var curr : int ; curr := 0 ;
      while curr < n & str->at(curr+1) /= '>' do (   ;     curr := curr + 1 ) ; 
    var j : int ; j := n - 1 ;
      while j > -1 & str->at(j+1) /= '<' do (   ;     j := j - 1 ) ; 
    ans := ans + StringLib.newString(Set{n - 1 - j, curr}->min()) + StringLib.newString("\n") ; 
 )  ;     t := t - 1 ) ; 
    skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int n=Integer.parseInt(f.readLine());
    int[][] strength=new int[2*n][2*n];
    for(int i=1 ; i<2*n ; i++){
      StringTokenizer st=new StringTokenizer(f.readLine());
      for(int j=0 ; j<i ; j++){
        strength[i][j]=Integer.parseInt(st.nextToken());
        strength[j][i]=strength[i][j];
      }
    }
    HashSet<Integer>seen=new HashSet<Integer>();
    int[] teams=new int[2*n];
    for(int i=0 ; i<n ; i++){
      int maxr=-1 ;
      int maxc=-1 ;
      int maxS=Integer.MIN_VALUE ;
      for(int j=0 ; j<2*n ; j++){
        if(seen.contains(j))continue ;
        for(int k=0 ; k<=j ; k++){
          if(seen.contains(k))continue ;
          if(strength[j][k]>maxS){
            maxr=j ;
            maxc=k ;
            maxS=strength[j][k];
          }
        }
      }
      seen.add(maxc);
      seen.add(maxr);
      teams[maxr]=maxc+1 ;
      teams[maxc]=maxr+1 ;
    }
    StringBuilder ans=new StringBuilder();
    for(int i : teams){
      ans.append(i);
      ans.append(" ");
    }
    out.println(ans.toString().trim());
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := (f.readLine())->toInteger() ;
    var strength : Sequence(Sequence(int)) ; strength := Integer.subrange(1,2 * n)->collect(Integer.subrange(1,2 * n)->collect(0)) ;
        var i : int ; i := 1 ; while i < 2 * n do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
         var j : int ; j := 0 ; while j < i do ( (     strength[i+1][j+1] := (st.next())->toInteger() ; 
     strength[j+1][i+1] := strength[i+1][j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var seen : Set(int) ; seen := Set{} ;
    var teams : Sequence(int) ; teams := Integer.subrange(1,2 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var maxr : int ; maxr := -1 ;
     var maxc : int ; maxc := -1 ;
    var maxS : int ; maxS := -2147483648 ;
        var j : int ; j := 0 ; while j < 2 * n do ( (     if (seen->includes(j)) then     continue else skip ; 
         var k : int ; k := 0 ; while k <= j do ( (     if (seen->includes(k)) then     continue else skip ; 
     if (strength[j+1][k+1] > maxS) then (     maxr := j ; 
     maxc := k ; 
     maxS := strength[j+1][k+1] ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    seen := seen->including(maxc) ; 
    seen := seen->including(maxr) ; 
    teams[maxr+1] := maxc + 1 ; 
    teams[maxc+1] := maxr + 1 ; 
 )  ;     i := i + 1 ) ; 
    var ans : String ; ans := StringLib.newString() ;
    for (i : teams) do ( (     ans := ans + StringLib.newString(i) ; 
     ans := ans + StringLib.newString(" ") )  ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class B {
  public static void main(String omkar[])throws Exception {
    BufferedReader infile=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(infile.readLine());
    int N=Integer.parseInt(st.nextToken());
    ArrayList<Thing>ls=new ArrayList<Thing>();
    for(int i=0 ; i<2*N-1 ; i++){
      st=new StringTokenizer(infile.readLine());
      int a=i+2 ;
      for(int b=1 ; b<a ; b++){
        int v=Integer.parseInt(st.nextToken());
        ls.add(new Thing(a,b,v));
      }
    }
    Collections.sort(ls);
    HashSet<Integer>seen=new HashSet<Integer>();
    int[] res=new int[2*N+1];
    for(Thing t : ls){
      if(seen.contains(t.a)|| seen.contains(t.b))continue ;
      seen.add(t.a);
      seen.add(t.b);
      res[t.a]=t.b ;
      res[t.b]=t.a ;
    }
    StringBuilder sb=new StringBuilder();
    for(int i=1 ; i<=2*N ; i++)sb.append(res[i]+" ");
    System.out.println(sb);
  }
}
class Thing implements Comparable<Thing>{
  public int a ;
  public int b ;
  public int val ;
  public Thing(int x,int y,int z){
    a=x ;
    b=y ;
    val=z ;
  }
  public int compareTo(Thing oth){
    return oth.val-val ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( omkar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var infile : OclFile ; infile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(infile.readLine()) ;
    var N : int ; N := (st.next())->toInteger() ;
    var ls : Sequence(Thing) ; ls := Sequence{} ;
        var i : int ; i := 0 ; while i < 2 * N - 1 do ( (     st := OclIterator.newOclIterator_String(infile.readLine()) ; 
     var a : int ; a := i + 2 ;
         var b : int ; b := 1 ; while b < a do ( (     var v : int ; v := (st.next())->toInteger() ;
     ls := ls->including(Thing.newThing(a, b, v)) )  ;     b := b + 1 ) )  ;     i := i + 1 ) ; 
    ls := ls->sort() ; 
    var seen : Set(int) ; seen := Set{} ;
    var res : Sequence(int) ; res := Integer.subrange(1,2 * N + 1)->collect(0) ;
    for (t : ls) do ( (     if (seen->includes(t.a) or seen->includes(t.b)) then     continue else skip ; 
     seen := seen->including(t.a) ; 
    seen := seen->including(t.b) ; 
    res[t.a+1] := t.b ; 
    res[t.b+1] := t.a ; 
 )  ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 1 ; while i <= 2 * N do (     sb := sb + StringLib.newString(res[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}
class Thing implements Comparable<Thing> {
   attribute a : int;
   attribute b : int;
   attribute val : int;
   static operation newThing( x : int, y : int, z : int) : Thing
  pre: true
  post: true
  activity:
  ( var self : Thing ;
    self := createThing();
    self.initialise(x, y,z);
    return self );
  operation initialise( x : int, y : int, z : int) : void
  pre: true  post: true
  activity: (     a := x ; 
     b := y ; 
     val := z );
   operation compareTo( oth : Thing) : int
  pre: true
  post: true
  activity: (     return oth.val - val );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class test {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    int[] teammates=new int[2*n+1];
    int[][] strength=new int[2*n+1][2*n+1];
    for(int i=2 ; i<=2*n ; i++){
      StringTokenizer st=new StringTokenizer(br.readLine());
      for(int j=1 ; j<i ; j++){
        strength[i][j]=Integer.parseInt(st.nextToken());
      }
    }
    for(int t=0 ; t<n ; t++){
      int max=0 ;
      int[] maxIdx=new int[2];
      for(int i=2 ; i<=2*n ; i++){
        for(int j=1 ; j<i ; j++){
          if(teammates[i]!=0 || teammates[j]!=0)continue ;
          if(strength[i][j]>max){
            maxIdx[0]=i ;
            maxIdx[1]=j ;
            max=strength[i][j];
          }
        }
      }
      teammates[maxIdx[0] ]=maxIdx[1];
      teammates[maxIdx[1] ]=maxIdx[0];
    }
    for(int i=1 ; i<=2*n ; i++)sb.append(teammates[i]).append(" ");
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var teammates : Sequence(int) ; teammates := Integer.subrange(1,2 * n + 1)->collect(0) ;
    var strength : Sequence(Sequence(int)) ; strength := Integer.subrange(1,2 * n + 1)->collect(Integer.subrange(1,2 * n + 1)->collect(0)) ;
        var i : int ; i := 2 ; while i <= 2 * n do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
         var j : int ; j := 1 ; while j < i do ( (     strength[i+1][j+1] := (st.next())->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var t : int ; t := 0 ; while t < n do ( (     var max : int ; max := 0 ;
     var maxIdx : Sequence(int) ; maxIdx := Integer.subrange(1,2)->collect(0) ;
        var i : int ; i := 2 ; while i <= 2 * n do ( (         var j : int ; j := 1 ; while j < i do ( (     if (teammates[i+1] /= 0 or teammates[j+1] /= 0) then     continue else skip ; 
     if (strength[i+1][j+1] > max) then (     maxIdx[0+1] := i ; 
     maxIdx[1+1] := j ; 
     max := strength[i+1][j+1] ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    teammates[maxIdx[0+1]+1] := maxIdx[1+1] ; 
    teammates[maxIdx[1+1]+1] := maxIdx[0+1] ; 
 )  ;     t := t + 1 ) ; 
        var i : int ; i := 1 ; while i <= 2 * n do (     sb := sb + StringLib.newString(teammates[i+1]) + StringLib.newString(" ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int MAX=7368792 ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(true){
      int m=in.nextInt(),n=in.nextInt();
      if(m==0)break ;
      List<Integer>list=getSeed(m,n);
      int res=0 ;
      boolean A[]=new boolean[MAX];
      for(int i=0 ; i<list.size(); i++){
        int g=list.get(i);
        for(int j=g ; j<MAX ; j+=g)A[j]=true ;
      }
      for(int i=m ; i<MAX ; i++){
        if(! A[i]){
          res=i ;
          break ;
        }
      }
      System.out.println(res);
    }
  }
  static List<Integer>getSeed(int m,int n){
    boolean list[]=new boolean[MAX];
    for(int i=m ; i<(MAX); i++){
      if(! list[i]){
        for(int j=i*2 ; j<MAX ; j+=i)list[j]=true ;
      }
    }
    List<Integer>res=new ArrayList<>();
    int i=m ;
    while(res.size()<n){
      if(! list[i]){
        res.add(i);
      }
      i++;
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MAX : int := 7368792;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var m : int ; m := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
     if (m = 0) then     break else skip ; 
    var list : Sequence(int) ; list := getSeed(m, n) ;
    var res : int ; res := 0 ;
    var A : Sequence(boolean) ; A := Integer.subrange(1,MAX)->collect(false) ;
        var i : int ; i := 0 ; while i < list->size() do ( (     var g : int ; g := list->at(i+1) ;
         var j : int ; j := g ; while j < MAX do (     A[j+1] := true ;  ;     j := j+(g) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := m ; while i < MAX do ( (     if (not(A[i+1])) then (     res := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 ) );
  static   operation getSeed( m : int, n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Integer.subrange(1,MAX)->collect(false) ;
         var i : int ; i := m ; while i < (MAX) do ( (     if (not(list[i+1])) then (         var j : int ; j := i * 2 ; while j < MAX do (     list[j+1] := true ;  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    var res : Sequence(int) ; res := Sequence{} ;
    var i : int ; i := m ;
    while (res->size() < n) do (     if (not(list[i+1])) then (     res := res->including(i) ) else skip ; 
     i := i + 1 ) ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static boolean solve(){
    int m=in.nextInt();
    int n=in.nextInt();
    if(m+n==0)return false ;
    int N=10000000 ;
    boolean[] f=new boolean[N];
    int cnt=0 ;
    Arrays.fill(f,true);
    for(int i=m ; i<N ; i++){
      if(! f[i])continue ;
      cnt++;
      if(cnt>n){
        out.println(i);
        return true ;
      }
      for(int j=i+i ; j<N ; j+=i){
        f[j]=false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    while(solve());
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : boolean
  pre: true
  post: true
  activity: (     var m : int ; m := in.getCurrent()->toInteger() ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    if (m + n = 0) then     return false else skip ; 
    var N : int ; N := 10000000 ;
    var f : Sequence(boolean) ; f := Integer.subrange(1,N)->collect(false) ;
    var cnt : int ; cnt := 0 ;
    f := f->collect(true) ; 
        var i : int ; i := m ; while i < N do ( (     if (not(f[i+1])) then     continue else skip ; 
     cnt := cnt + 1 ; 
     if (cnt > n) then (     skip ; 
     return true ) else skip ; 
         var j : int ; j := i + i ; while j < N do ( (     f[j+1] := false )  ;     j := j+(i) ) )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    while (solve()) do  ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.util.Scanner sc,java.io.PrintStream out){
    for(; ; ){
      final int m=sc.nextInt();
      int n=sc.nextInt();
      if(m==0 && n==0)break ;
      final boolean[] d=new boolean[7368792];
      for(int i=m ; ; ++i){
        if(d[i])continue ;
        if(n==0){
          out.println(i);
          break ;
        }
        for(int j=i ; j<d.length ; j+=i)d[j]=true ;
        n-=1 ;
      }
    }
  }
  public static void main(String[] args){
(new Main()).run(new java.util.Scanner(System.in),System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( sc : Scanner, out : PrintStream) : void
  pre: true
  post: true
  activity: (       while true do ( (     var m : int ; m := sc.nextInt() ;
     var n : int ; n := sc.nextInt() ;
    if (m = 0 & n = 0) then     break else skip ; 
    var d : Sequence(boolean) ; d := Integer.subrange(1,7368792)->collect(false) ;
        var i : int ; i := m ; while true do ( (     if (d[i+1]) then     continue else skip ; 
     if (n = 0) then (     out.println(i) ; 
     break ) else skip ; 
         var j : int ; j := i ; while j < d->size() do (     d[j+1] := true ;  ;     j := j+(i) ) ; 
     n := n-(1) )  ;     i := i + 1 ) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(Scanner.newScanner(OclFile["System.in"]), OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static final List<String>WEEK_STR=Collections.unmodifiableList(Arrays.asList("Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"));
  static final List<Integer>MONTH_DATE=Collections.unmodifiableList(Arrays.asList(31,29,31,30,31,30,31,31,30,31,30,31));
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int month=in.nextInt();
    int date=in.nextInt();
    while(month>0){
      int weekDate=2+date ;
      for(int m=0 ; m<month-1 ; m++){
        weekDate+=MONTH_DATE.get(m);
      }
      System.out.println(WEEK_STR.get(weekDate % 7));
      month=in.nextInt();
      date=in.nextInt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute WEEK_STR : Sequence(String) := Sequence{"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};
  static    attribute MONTH_DATE : Sequence(int) := Sequence{31,29,31,30,31,30,31,31,30,31,30,31};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var month : int ; month := in.getCurrent()->toInteger() ;
     var date : int ; date := in.getCurrent()->toInteger() ;
     while (month > 0) do (     var weekDate : int ; weekDate := 2 + date ;
         var m : int ; m := 0 ; while m < month - 1 do ( (     weekDate := weekDate+(MONTH_DATE->at(m+1)) )  ;     m := m + 1 ) ; 
    OclFile["System.out"].println(WEEK_STR->at(weekDate mod 7+1)) ; 
    month := in.getCurrent()->toInteger() ; 
    date := in.getCurrent()->toInteger() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public void solve(int n){
    Set<Integer>set=new HashSet<>();
    while(! set.contains(n)){
      set.add(n);
++n ;
      while(n % 10==0)n/=10 ;
    }
    out.println(set.size());
  }
  public static PrintWriter out ;
  public static void main(String[] args)throws IOException {
    boolean fileInOut=A.class.getPackage()!=null ;
    Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(fileInOut ? A.class.getResourceAsStream("in.txt"): System.in)));
    out=new PrintWriter(new BufferedOutputStream(fileInOut ? new FileOutputStream("out.txt"): System.out),true);
    int totalTestCase=fileInOut ? sc.nextInt(): 1 ;
    for(int testCaseNumber=1 ; testCaseNumber<=totalTestCase ; testCaseNumber++){
      int N=sc.nextInt();
      new A().solve(N);
    }
    if(fileInOut){
      String outputFile="out.txt" ;
      BufferedReader reader1=new BufferedReader(new FileReader(A.class.getResource("ans.txt").getFile()));
      BufferedReader reader2=new BufferedReader(new FileReader(outputFile));
      String line1=reader1.readLine();
      String line2=reader2.readLine();
      boolean areEqual=true ;
      int lineNum=1 ;
      while(line1!=null || line2!=null){
        if(line1==null || line2==null){
          areEqual=false ;
          break ;
        }
        else if(! line1.equals(line2)){
          areEqual=false ;
          break ;
        }
        line1=reader1.readLine();
        line2=reader2.readLine();
        lineNum++;
      }
      if(areEqual){
        System.out.println("All Test Cases Passed !");
      }
      else {
        System.out.println("Output differ at line "+lineNum);
        System.out.println("ans.txt has "+line1+" and out.txt has "+line2+" at line "+lineNum);
      }
      reader1.close();
      reader2.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   operation solve( n : int) : void
  pre: true
  post: true
  activity: (     var set : Set(int) ; set := Set{} ;
     while (not(set->includes(n))) do (     set := set->including(n) ; 
     n := n + 1 ; 
     while (n mod 10 = 0) do     n := n/(10) ; ) ; 
     out.println(set->size()) );
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fileInOut : boolean ; fileInOut := OclType["A"].getPackage() /= null ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(if fileInOut then OclType["A"].getResourceAsStream("in.txt") else OclFile["System.in"] endif))) ;
    out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(if fileInOut then OclFile.newOclFile_Write(OclFile.newOclFile("out.txt")) else OclFile["System.out"] endif), true) ; 
    var totalTestCase : int ; totalTestCase := if fileInOut then sc.getCurrent()->toInteger() else 1 endif ;
        var testCaseNumber : int ; testCaseNumber := 1 ; while testCaseNumber <= totalTestCase do ( (     var N : int ; N := sc.getCurrent()->toInteger() ;
     A.newA().solve(N) )  ;     testCaseNumber := testCaseNumber + 1 ) ; 
    if (fileInOut) then (     var outputFile : String ; outputFile := "out.txt" ;
     var reader1 : OclFile ; reader1 := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclType["A"].getResource("ans.txt").getFile())) ;
    var reader2 : OclFile ; reader2 := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(outputFile))) ;
    var line1 : String ; line1 := reader1.readLine() ;
    var line2 : String ; line2 := reader2.readLine() ;
    var areEqual : boolean ; areEqual := true ;
    var lineNum : int ; lineNum := 1 ;
    while (line1 /= null or line2 /= null) do (     if (line1 = null or line2 = null) then (     areEqual := false ; 
     break ) else     if (not(line1 = line2)) then (     areEqual := false ; 
     break ) else skip ; ;  
     line1 := reader1.readLine() ; 
     line2 := reader2.readLine() ; 
     lineNum := lineNum + 1 ) ; 
    if (areEqual) then (     OclFile["System.out"].println("All Test Cases Passed !") ) else (     OclFile["System.out"].println("Output differ at line " + lineNum) ; 
     OclFile["System.out"].println("ans.txt has " + line1 + " and out.txt has " + line2 + " at line " + lineNum) ) ;  
    skip ; 
    skip ; 
 ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int sumOfRange(int a,int b){
    int i=(a*(a+1))>>1 ;
    int j=(b*(b+1))>>1 ;
    return(i-j);
  }
  static int sumofproduct(int n){
    int sum=0 ;
    int root=(int)Math.sqrt(n);
    for(int i=1 ; i<=root ; i++){
      int up=n/i ;
      int low=Math.max(n/(i+1),root);
      sum+=(i*sumOfRange(up,low));
      sum+=(i*(n/i));
    }
    return sum ;
  }
  static public void main(String[] args){
    int n=10 ;
    System.out.println(sumofproduct(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfRange( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := ((a * (a + 1))/(2->pow(1)))->oclAsType(long) ;
     var j : int ; j := ((b * (b + 1))/(2->pow(1)))->oclAsType(long) ;
     return (i - j) );
  static   operation sumofproduct( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var root : int ; root := (n)->sqrt()->oclAsType(int) ;
         var i : int ; i := 1 ; while i <= root do ( (     var up : int ; up := n / i ;
     var low : int ; low := Set{n / (i + 1), root}->max() ;
     sum := sum+((i * sumOfRange(up, low))) ; 
     sum := sum+((i * (n / i))) )  ;     i := i + 1 ) ; 
     return sum );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(sumofproduct(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      while(sc.hasNext()){
        boolean[] v=new boolean[8000000];
        int m=sc.nextInt();
        int n=sc.nextInt();
        int pos=m ;
        if(m+n==0){
          break ;
        }
        for(int i=0 ; i<n ; i++){
          while(v[pos]){
            pos++;
          }
          for(int j=pos ; j<=7368791 ; j=j+pos){
            v[j]=true ;
          }
        }
        while(v[pos]){
          pos++;
        }
        System.out.println(pos);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (sc.hasNext()) do (     var v : Sequence(boolean) ; v := Integer.subrange(1,8000000)->collect(false) ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var pos : int ; pos := m ;
    if (m + n = 0) then (     break ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     while (v[pos+1]) do (     pos := pos + 1 ) ; 
         var j : int ; j := pos ; while j <= 7368791 do ( (     v[j+1] := true )  ;     j := j + pos ) )  ;     i := i + 1 ) ; 
    while (v[pos+1]) do (     pos := pos + 1 ) ; 
    OclFile["System.out"].println(pos) ; 
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Div2B {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    FastReader fsr=new FastReader();
    int T=fsr.nextInt();
    for(int i=1 ; i<=T ; i++){
      int n=fsr.nextInt();
      String s=fsr.nextLine();
      solution(n,s,out);
    }
    out.flush();
    out.close();
  }
  private static void solution(int n,String s,PrintWriter out){
    if(n==1){
      out.println(0);
    }
    else if(s.charAt(0)=='<' && s.charAt(n-1)=='>'){
      int num_open=s.indexOf('>');
      int num_close=n-1-s.lastIndexOf('<');
      out.println(Math.min(num_close,num_open));
    }
    else {
      out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Div2B {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var fsr : FastReader ; fsr := FastReader.newFastReader() ;
    var T : int ; T := fsr.nextInt() ;
        var i : int ; i := 1 ; while i <= T do ( (     var n : int ; n := fsr.nextInt() ;
     var s : String ; s := fsr.nextLine() ;
     execute solution(n, s, out) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solution( n : int, s : String, out : OclFile) : void
  pre: true
  post: true
  activity: (     if (n = 1) then (     skip ) else     if (s->at(0+1) = '<' & s->at(n - 1+1) = '>') then (     var num_open : int ; num_open := s->indexOf('>')-1 ;
     var num_close : int ; num_close := n - 1 - s->lastIndexOf('<')-1 ;
     skip ) else (     skip ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p549 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p549().run());
  }
  private static final int LIMIT=Library.pow(10,8);
  public String run(){
    int[] smallestDivisibleFactorials=new int[LIMIT+1];
    for(int i=2 ; i<smallestDivisibleFactorials.length ; i++){
      if(smallestDivisibleFactorials[i]==0){
        long power=1 ;
        middle : for(int j=i ;
        ;
        j+=i){
          power*=i ;
          if(power>LIMIT)break ;
          for(int inc=(int)power,k=inc ; k<smallestDivisibleFactorials.length ; k+=inc)smallestDivisibleFactorials[k]=Math.max(j,smallestDivisibleFactorials[k]);
          for(int temp=j/i ; temp % i==0 ; temp/=i){
            power*=i ;
            if(power>LIMIT)break middle ;
          }
        }
      }
    }
    long sum=0 ;
    for(int x : smallestDivisibleFactorials)sum+=x ;
    return Long.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
class p549 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p549.newp549().run()) );
  static    attribute LIMIT : int := Library.pow(10, 8);
   operation run() : String
  pre: true
  post: true
  activity: (     var smallestDivisibleFactorials : Sequence(int) ; smallestDivisibleFactorials := Integer.subrange(1,LIMIT + 1)->collect(0) ;
         var i : int ; i := 2 ; while i < smallestDivisibleFactorials->size() do ( (     if (smallestDivisibleFactorials[i+1] = 0) then (     var power : long ; power := 1 ;
         var j : int ; j := i ; while true do ( (     power := power*(i) ; 
     if (power > LIMIT) then     break else skip ; 
         var inc : int ; inc := power->oclAsType(int) ;
    var k : int ; k := inc ; while k < smallestDivisibleFactorials->size() do (     smallestDivisibleFactorials[k+1] := Set{j, smallestDivisibleFactorials[k+1]}->max() ;  ;     k := k+(inc) ) ; 
         var temp : int ; temp := j / i ; while temp mod i = 0 do ( (     power := power*(i) ; 
     if (power > LIMIT) then     break else skip )  ;     temp := temp/(i) ) )  ;     j := j+(i) ) ; ) else skip )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    for (x : smallestDivisibleFactorials) do (     sum := sum+(x) ;  ) ; 
    return ((sum) + "") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Arrays ;
class Main {
  public static void main(String[] args)throws IOException {
    int i,j ;
    int[] n=new int[990];
    String[] str=new String[990];
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    for(; ; ){
      str=in.readLine().split(" ");
      for(i=0 ; i<2 ; i++){
        n[i]=Integer.parseInt(str[i]);
      }
      if(n[0]+n[1]==0)break ;
      for(i=0 ; i<n[0]; i++){
        for(j=0 ; j<n[1]; j++){
          System.out.print("#");
        }
        System.out.println();
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var n : Sequence(int) ; n := Integer.subrange(1,990)->collect(0) ;
    var str : Sequence(String) ; str := Integer.subrange(1,990)->collect(null) ;
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
      while true do ( (     str := in.readLine()->split(" ") ; 
         i := 0 ; while i < 2 do ( (     n[i+1] := (str[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    if (n[0+1] + n[1+1] = 0) then     break else skip ; 
        i := 0 ; while i < n[0+1] do ( (         j := 0 ; while j < n[1+1] do ( (     OclFile["System.out"].print("#") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public static void main(String[] args){
    java.util.Scanner sc=new java.util.Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    while(true){
      int h=sc.nextInt();
      int w=sc.nextInt();
      if(h==0 && w==0)break ;
      for(int i=0 ; i<h ; i++){
        for(int j=0 ; j<w ; j++){
          sb.append("#");
        }
        sb.append("\n");
      }
      sb.append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
     while (true) do (     var h : int ; h := sc.nextInt() ;
     var w : int ; w := sc.nextInt() ;
    if (h = 0 & w = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     sb := sb + StringLib.newString("#") )  ;     j := j + 1 ) ; 
     sb := sb + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString("\n") ; 
 ) ; 
     OclFile["System.out"].print(sb) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.List ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    br.lines().forEach(s->{
      List<Integer>list=Arrays.stream(s.split(" ")).map(Integer :: parseInt).collect(Collectors.toList());
      int h=list.get(0);
      int w=list.get(1);
      if(h==0 && w==0){
        return ;
      }
      for(int i=0 ; i<h ; i++){
        for(int j=0 ; j<w ; j++){
          System.out.print("#");
        }
        System.out.println();
      }
      System.out.println();
    }
);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     for s : br.lines() do
    (    skip) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    List<Integer>A=new ArrayList<>();
    List<Integer>B=new ArrayList<>();
    int t=0 ;
    while(true){
      A.add(sc.nextInt());
      B.add(sc.nextInt());
      if(A.get(A.size()-1)==0)break ;
      if(B.get(A.size()-1)==0)break ;
      t++;
    }
    for(int n=0 ; n<t ; n++){
      for(int i=0 ; i<A.get(n); i++){
        for(int j=0 ; j<B.get(n); j++){
          System.out.print("#");
        }
        System.out.print("\n");
      }
      System.out.print("\n");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : Sequence(int) ; A := Sequence{} ;
    var B : Sequence(int) ; B := Sequence{} ;
    var t : int ; t := 0 ;
    while (true) do (     A := A->including(sc.getCurrent()->toInteger()) ; 
     B := B->including(sc.getCurrent()->toInteger()) ; 
    if (A->at(A->size() - 1+1) = 0) then     break else skip ; 
    if (B->at(A->size() - 1+1) = 0) then     break else skip ; 
    t := t + 1 ; 
 ) ; 
        var n : int ; n := 0 ; while n < t do ( (         var i : int ; i := 0 ; while i < A->at(n+1) do ( (         var j : int ; j := 0 ; while j < B->at(n+1) do ( (     OclFile["System.out"].print("#") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     n := n + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    List<Integer>H=new ArrayList<Integer>();
    List<Integer>W=new ArrayList<Integer>();
    int lastH=0 ;
    int lastW=0 ;
    do {
      lastH=stdIn.nextInt();
      lastW=stdIn.nextInt();
      H.add(lastH);
      W.add(lastW);
    }
    while(lastH!=0 || lastW!=0);
    for(int i=0 ; i<H.size()-1 ; i++){
      for(int j=0 ; j<H.get(i); j++){
        for(int k=0 ; k<W.get(i); k++){
          System.out.print("#");
        }
        System.out.println();
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : Sequence(int) ; H := Sequence{} ;
    var W : Sequence(int) ; W := Sequence{} ;
    var lastH : int ; lastH := 0 ;
    var lastW : int ; lastW := 0 ;
  while true do ((     lastH := stdIn.getCurrent()->toInteger() ; 
     lastW := stdIn.getCurrent()->toInteger() ; 
     H := H->including(lastH) ; 
     W := W->including(lastW) ) ;
    if (lastH /= 0 or lastW /= 0) then skip else break) ; 
        var i : int ; i := 0 ; while i < H->size() - 1 do ( (         var j : int ; j := 0 ; while j < H->at(i+1) do ( (         var k : int ; k := 0 ; while k < W->at(i+1) do ( (     OclFile["System.out"].print("#") )  ;     k := k + 1 ) ; 
     OclFile["System.out"].println() )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
public class GFG {
  public static void printArray(int arr[][],int row,int col){
    HashSet<String>set=new HashSet<String>();
    for(int i=0 ; i<row ; i++){
      String s="" ;
      for(int j=0 ; j<col ; j++)s+=String.valueOf(arr[i][j]);
      if(! set.contains(s)){
        set.add(s);
        System.out.println(s);
      }
    }
  }
  public static void main(String[] args){
    int arr[][]={
      {
        0,1,0,0,1 },{
          1,0,1,1,0 },{
            0,1,0,0,1 },{
              1,1,1,0,0 }
            };
            printArray(arr,4,5);
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printArray( arr : Sequence(Sequence(int)), row : int, col : int) : void
  pre: true
  post: true
  activity: (     var set : Set(String) ; set := Set{} ;
         var i : int ; i := 0 ; while i < row do ( (     var s : String ; s := "" ;
         var j : int ; j := 0 ; while j < col do (     s := s+(((arr[i+1][j+1]) + "")) ;  ;     j := j + 1 ) ; 
     if (not(set->includes(s))) then (     set := set->including(s) ; 
     OclFile["System.out"].println(s) ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{0,1,0,0,1},Sequence{1,0,1,1,0},Sequence{0,1,0,0,1},Sequence{1,1,1,0,0}} ;
     execute printArray(arr, 4, 5) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static ArrayList<Integer>seive(int n){
    ArrayList<Integer>prime=new ArrayList<Integer>();
    for(int i=0 ; i<n+1 ; i++)prime.add(0);
    int p=2 ;
    while(p*p<=n){
      if(prime.get(p)==0){
        for(int i=2*p ; i<n+1 ; i+=p)prime.set(i,1);
      }
      p+=1 ;
    }
    ArrayList<Integer>allPrimes=new ArrayList<Integer>();
    for(int i=2 ; i<n ; i++){
      if(prime.get(i)==0)allPrimes.add(i);
    }
    return allPrimes ;
  }
  static ArrayList<Integer>distPrime(ArrayList<Integer>arr,ArrayList<Integer>allPrimes){
    ArrayList<Integer>list1=new ArrayList<Integer>();
    for(int i=0 ; i<allPrimes.size(); i++){
      for(int j=0 ; j<arr.size(); j++){
        if(arr.get(j)% allPrimes.get(i)==0){
          list1.add(allPrimes.get(i));
          break ;
        }
      }
    }
    return list1 ;
  }
  public static void main(String args[]){
    ArrayList<Integer>allPrimes=new ArrayList<Integer>(seive(10000));
    ArrayList<Integer>arr=new ArrayList<Integer>();
    arr.add(15);
    arr.add(30);
    arr.add(60);
    ArrayList<Integer>ans=new ArrayList<Integer>(distPrime(arr,allPrimes));
    System.out.print("[");
    for(int i=0 ; i<ans.size(); i++)System.out.print(ans.get(i)+" ");
    System.out.print("] ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation seive( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var prime : Sequence(int) ; prime := Sequence{} ;
         var i : int ; i := 0 ; while i < n + 1 do (     prime := prime->including(0) ;  ;     i := i + 1 ) ; 
    var p : int ; p := 2 ;
    while (p * p <= n) do (     if (prime->at(p+1) = 0) then (         var i : int ; i := 2 * p ; while i < n + 1 do (     prime := prime.setAt(i+1,1) ;  ;     i := i+(p) ) ) else skip ; 
     p := p+(1) ) ; 
    var allPrimes : Sequence(int) ; allPrimes := Sequence{} ;
        var i : int ; i := 2 ; while i < n do ( (     if (prime->at(i+1) = 0) then     allPrimes := allPrimes->including(i) ; else skip )  ;     i := i + 1 ) ; 
    return allPrimes 
 );
  static   operation distPrime( arr : Sequence(int), allPrimes : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var list1 : Sequence(int) ; list1 := Sequence{} ;
         var i : int ; i := 0 ; while i < allPrimes->size() do ( (         var j : int ; j := 0 ; while j < arr->size() do ( (     if (arr->at(j+1) mod allPrimes->at(i+1) = 0) then (     list1 := list1->including(allPrimes->at(i+1)) ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return list1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var allPrimes : Sequence(int) ; allPrimes := Sequence{}->union(seive(10000)) ;
     var arr : Sequence(int) ; arr := Sequence{} ;
    arr := arr->including(15) ; 
    arr := arr->including(30) ; 
    arr := arr->including(60) ; 
    var ans : Sequence(int) ; ans := Sequence{}->union(distPrime(arr, allPrimes)) ;
    OclFile["System.out"].print("[") ; 
        var i : int ; i := 0 ; while i < ans->size() do (     OclFile["System.out"].print(ans->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("] ") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  private static final int MOD=(int)Math.pow(10,9);
  public static void main(String[] args){
    FastReader sc=new FastReader();
    Set<Integer>set=new HashSet<>();
    int n=sc.nextInt();
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=sc.nextInt();
    }
    for(int bit=0 ; bit<(1<<n); bit++){
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        if((bit &(1<<i))!=0){
          sum+=nums[i];
        }
      }
      set.add(sum);
    }
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      int num=sc.nextInt();
      if(set.contains(num)){
        System.out.println("yes");
      }
      else {
        System.out.println("no");
      }
    }
    System.exit(0);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 10->pow(9)->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var set : Set(int) ; set := Set{} ;
    var n : int ; n := sc.nextInt() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
        var bit : int ; bit := 0 ; while bit < ((1*(2->pow(n)))->oclAsType(long)) do ( (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if ((MathLib.bitwiseAnd(bit,((1*(2->pow(i)))->oclAsType(long)))) /= 0) then (     sum := sum+(nums[i+1]) ) else skip )  ;     i := i + 1 ) ; 
     set := set->including(sum) )  ;     bit := bit + 1 ) ; 
    var q : int ; q := sc.nextInt() ;
        var i : int ; i := 0 ; while i < q do ( (     var num : int ; num := sc.nextInt() ;
     if (set->includes(num)) then (     OclFile["System.out"].println("yes") ) else (     OclFile["System.out"].println("no") ) )  ;     i := i + 1 ) ; 
OclProcess.exit(0) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class RollerCoasterScheduling {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner cin=new Scanner(new File("B-large.in"));
    PrintStream cout=new PrintStream("B-large.out");
    int _case=0 ;
    for(int T=cin.nextInt(); T>0 ; T--){
      _case++;
      int N=cin.nextInt();
      int C=cin.nextInt();
      int M=cin.nextInt();
      int[][] a=new int[C+1][N+1];
      for(int i=0 ; i<M ; i++){
        int p=cin.nextInt();
        int b=cin.nextInt();
        a[b][p]++;
      }
      int totalTrains=0 ;
      for(int i=1 ; i<=C ; i++){
        int sum=0 ;
        for(int j=1 ; j<=N ; j++)sum+=a[i][j];
        totalTrains=Math.max(totalTrains,sum);
      }
      int prefixColSum=0 ;
      for(int j=1 ; j<=N ; j++){
        for(int i=1 ; i<=C ; i++)prefixColSum+=a[i][j];
        totalTrains=Math.max(totalTrains,(prefixColSum+j-1)/j);
      }
      int promotion=0 ;
      for(int j=N ; j>=1 ; j--){
        int sum=0 ;
        for(int i=1 ; i<=C ; i++)sum+=a[i][j];
        int extra=Math.max(0,sum-totalTrains);
        promotion+=extra ;
      }
      String ans=""+totalTrains+" "+promotion ;
      cout.printf("Case #%d: %s%n",_case,ans);
    }
    cin.close();
    cout.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class RollerCoasterScheduling {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile("B-large.in")) ;
     var cout : OclFile ; cout := OclFile.newOclFile_Write(OclFile.newOclFile("B-large.out")) ;
    var _case : int ; _case := 0 ;
        var T : int ; T := cin.getCurrent()->toInteger() ; while T > 0 do ( (     _case := _case + 1 ; 
     var N : int ; N := cin.getCurrent()->toInteger() ;
    var C : int ; C := cin.getCurrent()->toInteger() ;
    var M : int ; M := cin.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,C + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < M do ( (     var p : int ; p := cin.getCurrent()->toInteger() ;
     var b : int ; b := cin.getCurrent()->toInteger() ;
     a[b+1][p+1] := a[b+1][p+1] + 1 )  ;     i := i + 1 ) ; 
    var totalTrains : int ; totalTrains := 0 ;
        var i : int ; i := 1 ; while i <= C do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 1 ; while j <= N do (     sum := sum+(a[i+1][j+1]) ;  ;     j := j + 1 ) ; 
     totalTrains := Set{totalTrains, sum}->max() )  ;     i := i + 1 ) ; 
    var prefixColSum : int ; prefixColSum := 0 ;
        var j : int ; j := 1 ; while j <= N do ( (         var i : int ; i := 1 ; while i <= C do (     prefixColSum := prefixColSum+(a[i+1][j+1]) ;  ;     i := i + 1 ) ; 
     totalTrains := Set{totalTrains, (prefixColSum + j - 1) / j}->max() )  ;     j := j + 1 ) ; 
    var promotion : int ; promotion := 0 ;
        var j : int ; j := N ; while j >= 1 do ( (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= C do (     sum := sum+(a[i+1][j+1]) ;  ;     i := i + 1 ) ; 
     var extra : int ; extra := Set{0, sum - totalTrains}->max() ;
     promotion := promotion+(extra) )  ;     j := j - 1 ) ; 
    var ans : String ; ans := "" + totalTrains + " " + promotion ;
    skip ; 
 )  ;     T := T - 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int a=sc.nextInt();
    if(a<1200){
      System.out.println("ABC");
    }
    else if(a<2800){
      System.out.println("ARC");
    }
    else {
      System.out.println("AGC");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (a < 1200) then (     OclFile["System.out"].println("ABC") ) else     if (a < 2800) then (     OclFile["System.out"].println("ARC") ) else (     OclFile["System.out"].println("AGC") ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Reader {
  Scanner sc=new Scanner(System.in);
  public int ini(){
    return sc.nextInt();
  }
  public String insl(){
    return sc.nextLine();
  }
  public void skip(){
    sc.nextLine();
  }
  public int[] vi(int n){
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    return a ;
  }
  public long[] vl(int n){
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextLong();
    return a ;
  }
  public String[] vsl(int n){
    String[] a=new String[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextLine();
    return a ;
  }
}
public class Main extends Reader {
  public static void main(String[] args){
    Main main=new Main();
    main.show(main.solve());
  }
  int r ;
  int a[];
  public Main(){
    r=ini();
  }
  int solve(){
    if(2800<=r)return 1 ;
    if(1200<=r)return 2 ;
    return 3 ;
  }
  void show(int ans){
    System.out.println(ans==1 ? "AGC" : ans==2 ? "ARC" : "ABC");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Reader {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation ini() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
   operation insl() : String
  pre: true
  post: true
  activity: (     return sc.nextLine() );
   operation skip() : void
  pre: true
  post: true
  activity: (     skip );
   operation vi( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
     return a );
   operation vl( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation vsl( n : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.nextLine() ;  ;     i := i + 1 ) ; 
     return a );
}
class Main extends OclFile {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.show(main.solve()) );
   attribute r : int;
   attribute a : Sequence(int);
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     r := ini() );
   operation solve() : int
  pre: true
  post: true
  activity: (     if (2800 <= r) then     return 1 else skip ; 
     if (1200 <= r) then     return 2 else skip ; 
     return 3 );
   operation show( ans : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if ans = 1 then "AGC" else if ans = 2 then "ARC" else "ABC" endif endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    int r=Integer.parseInt(br.readLine());
    if(r<1200){
      bw.write("ABC");
    }
    else if(r<2800){
      bw.write("ARC");
    }
    else {
      bw.write("AGC");
    }
    bw.flush();
    bw.close();
    br.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var r : int ; r := (br.readLine())->toInteger() ;
    if (r < 1200) then (     skip ) else     if (r < 2800) then (     skip ) else (     skip ) ;  ;  
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.io.*;
import java.util.*;
class Main {
  public static void main(String args[])throws FileNotFoundException {
    FScanner fs=new FScanner();
    int n=fs.readInt();
    if(n<=1199){
      System.out.println("ABC");
    }
    else if(n<=2799){
      System.out.println("ARC");
    }
    else {
      System.out.println("AGC");
    }
  }
  static void disp(int[] data){
    for(int i=0 ; i<data.length ; i++){
      System.out.printf("%d ",data[i]);
    }
    System.out.println();
  }
  static class FScanner {
    Scanner sc ;
    FScanner()throws FileNotFoundException {
      sc=new Scanner(System.in);
    }
    int readInt(){
      int i=Integer.parseInt(sc.nextLine());
      return i ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FScanner ; fs := FScanner.newFScanner() ;
     var n : int ; n := fs.readInt() ;
     if (n <= 1199) then (     OclFile["System.out"].println("ABC") ) else     if (n <= 2799) then (     OclFile["System.out"].println("ARC") ) else (     OclFile["System.out"].println("AGC") ) ;  );
  static   operation disp( data : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < data->size() do ( (     OclFile["System.out"].printf("%d ", data[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static class FScanner {
   attribute sc : OclFile;
   static operation newFScanner() : FScanner
  pre: true
  post: true
  activity:
  ( var self : FScanner ;
    self := createFScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation readInt() : int
  pre: true
  post: true
  activity: (     var i : int ; i := (sc.nextLine())->toInteger() ;
     return i );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int R=Integer.parseInt(br.readLine());
    if(R<1200){
      System.out.println("ABC");
    }
    else if(R<2800){
      System.out.println("ARC");
    }
    else {
      System.out.println("AGC");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var R : int ; R := (br.readLine())->toInteger() ;
     if (R < 1200) then (     OclFile["System.out"].println("ABC") ) else     if (R < 2800) then (     OclFile["System.out"].println("ARC") ) else (     OclFile["System.out"].println("AGC") ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  Scanner sc=new Scanner(System.in);
  int n ;
  int[] a ;
  int ans ;
  boolean flag ;
  void run(){
    while(sc.hasNext()){
      n=sc.nextInt();
      a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      Arrays.sort(a);
      flag=false ;
      ans=a[n-1];
      check(ans);
      while(! flag){
        ans+=a[n-1];
        check(ans);
      }
      System.out.println(ans);
    }
  }
  void check(int lcm){
    for(int i=0 ; i<n ; i++)if(lcm % a[i]!=0)return ;
    flag=true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute n : int;
   attribute a : Sequence(int);
   attribute ans : int;
   attribute flag : boolean;
   operation run() : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     n := sc.getCurrent()->toInteger() ; 
     a := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    flag := false ; 
    ans := a[n - 1+1] ; 
    execute check(ans) ; 
    while (not(flag)) do (     ans := ans+(a[n - 1+1]) ; 
     execute check(ans) ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
   operation check( lcm : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     if (lcm mod a[i+1] /= 0) then     return else skip ;  ;     i := i + 1 ) ; 
     flag := true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static int numint[];
  public static int multiplied[];
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=br.readLine();
    String countstr=str ;
    int countint=Integer.parseInt(countstr);
    str=br.readLine();
    String numstr[]=str.split(" ",0);
    numint=new int[countint];
    for(int i=1 ; i<=countint ; i++){
      numint[i-1]=Integer.parseInt(numstr[i-1]);
    }
    multiplied=new int[countint];
    multiplied[0]=numint[0];
    for(int j=1 ; j<countint ; j++){
      int gcm=Euclid(j-1);
      multiplied[j]=multiplied[j-1]*numint[j]/gcm ;
    }
    System.out.println(multiplied[countint-1]);
  }
  public static int Euclid(int k){
    int x=multiplied[k];
    int y=numint[k+1];
    while(x!=y){
      if(x<y){
        y=y-x ;
      }
      else {
        x=x-y ;
      }
    }
    return x ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute numint : Sequence(int);
  static   attribute multiplied : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := br.readLine() ;
    var countstr : String ; countstr := str ;
    var countint : int ; countint := (countstr)->toInteger() ;
    str := br.readLine() ; 
    var numstr : Sequence(String) ; numstr := str->split(" ") ;
    numint := Integer.subrange(1,countint)->collect(0) ; 
        var i : int ; i := 1 ; while i <= countint do ( (     numint[(i)->char2byte() - 1+1] := (numstr[(i)->char2byte() - 1+1])->toInteger() )  ;     i := i + 1 ) ; 
    multiplied := Integer.subrange(1,countint)->collect(0) ; 
    multiplied[0+1] := numint[0+1] ; 
        var j : int ; j := 1 ; while j < countint do ( (     var gcm : int ; gcm := Euclid(j - 1) ;
     multiplied[j+1] := multiplied[j - 1+1] * numint[j+1] / gcm )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(multiplied[(countint)->char2byte() - 1+1]) ; 
 );
  static   operation Euclid( k : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := multiplied[k+1] ;
     var y : int ; y := numint[k + 1+1] ;
     while (x /= y) do (     if (x < y) then (     y := y - x ) else (     x := x - y ) ) ; 
     return x );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    AizuLCM solver=new AizuLCM();
    solver.solve(1,in,out);
    out.close();
  }
  static class AizuLCM {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int[] a=new int[n];
      long p=1L ;
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
        p*=a[i];
      }
      int g=0 ;
      int l=0 ;
      if(n==1){
        g=a[0];
      }
      else {
        g=gcd(a[0],a[1]);
        l=(a[0]*a[1])/g ;
        for(int i=2 ; i<n ; i++){
          g=gcd(l,a[i]);
          l=(l*a[i])/g ;
        }
      }
      out.printf("%d\n",l);
    }
    private int gcd(int x,int y){
      while(y!=0){
        int t=x % y ;
        x=y ;
        y=t ;
      }
      return x ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : AizuLCM ; solver := AizuLCM.newAizuLCM() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class AizuLCM {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var p : long ; p := 1L ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     p := p*(a[i+1]) )  ;     i := i + 1 ) ; 
    var g : int ; g := 0 ;
    var l : int ; l := 0 ;
    if (n = 1) then (     g := a[0+1] ) else (     g := gcd(a[0+1], a[1+1]) ; 
     l := (a[0+1] * a[1+1]) / g ; 
         var i : int ; i := 2 ; while i < n do ( (     g := gcd(l, a[i+1]) ; 
     l := (l * a[i+1]) / g )  ;     i := i + 1 ) ) ;  
    skip ; 
 );
   operation gcd( x : int, y : int) : int
  pre: true
  post: true
  activity: (     while (y /= 0) do (     var t : int ; t := x mod y ;
     x := y ; 
     y := t ) ; 
     return x );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main implements Runnable {
  private static int MOD=1_000_000_007 ;
  public static void main(String[] args){
    Thread thread=new Thread(null,new Main(),"",32*1024*1024);
    thread.start();
  }
  @ Override public void run(){
    final Scanner scanner=new Scanner(System.in);
    solve(scanner);
  }
  static void solve(Scanner scanner){
    scanner.nextLine();
    int[] n=Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    Gcd gcd=new Gcd();
    long lcm=n[0]*n[1]/gcd.gcd(n[0],n[1]);
    for(int i=2 ; i<n.length ; i++){
      lcm=lcm*n[i]/gcd.gcd(lcm,n[i]);
    }
    System.out.println(lcm);
  }
}
class Gcd {
  class GcdResult {
    final long a ;
    final long b ;
    final long gcd ;
    public GcdResult(long a,long b,long gcd){
      this.a=a ;
      this.b=b ;
      this.gcd=gcd ;
    }
  }
  public GcdResult extGcd(long x,long y){
    if(x<y){
      return extGcd(y,x);
    }
    if(y==0){
      return new GcdResult(1,0,x);
    }
    GcdResult res=extGcd(y,x % y);
    long a=res.b ;
    long b=res.a-(x/y)*res.b ;
    return new GcdResult(a,b,res.gcd);
  }
  public long gcd(long x,long y){
    if(x<y){
      return gcd(y,x);
    }
    if(y==0){
      return x ;
    }
    return gcd(y,x % y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
  static   attribute MOD : int := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var thread : OclProcess ; thread := OclProcess.newOclProcess(null, Main.newMain(), "", 32 * 1024 * 1024) ;
     thread.start() );
      operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute solve(scanner) );
  static   operation solve( scanner : OclFile) : void
  pre: true
  post: true
  activity: (     skip ; 
     var n : Sequence(int) ; n := stream(scanner.nextLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var gcd : Gcd ; gcd := Gcd.newGcd() ;
    var lcm : long ; lcm := n[0+1] * n[1+1] / gcd.gcd(n[0+1], n[1+1]) ;
        var i : int ; i := 2 ; while i < n->size() do ( (     lcm := lcm * n[i+1] / gcd.gcd(lcm, n[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(lcm) ; 
 );
}
class Gcd {
 class GcdResult {
   attribute a : long;
   attribute b : long;
   attribute gcd : long;
   static operation newGcdResult( a : long, b : long, gcd : long) : GcdResult
  pre: true
  post: true
  activity:
  ( var self : GcdResult ;
    self := createGcdResult();
    self.initialise(a, b,gcd);
    return self );
  operation initialise( a : long, b : long, gcd : long) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b ; 
     self.gcd := gcd );
}
   operation extGcd( x : long, y : long) : GcdResult
  pre: true
  post: true
  activity: (     if (x < y) then (     return extGcd(y, x) ) else skip ; 
     if (y = 0) then (     return GcdResult.newGcdResult(1, 0, x) ) else skip ; 
    var res : GcdResult ; res := extGcd(y, x mod y) ;
    var a : long ; a := res.b ;
    var b : long ; b := res.a - (x / y) * res.b ;
    return GcdResult.newGcdResult(a, b, res.gcd) 
 );
   operation gcd( x : long, y : long) : long
  pre: true
  post: true
  activity: (     if (x < y) then (     return gcd(y, x) ) else skip ; 
     if (y = 0) then (     return x ) else skip ; 
     return gcd(y, x mod y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n ;
    int[] a,p,max ;
    int i,j,res,pn ;
    n=sc.nextInt();
    pn=1000 ;
    a=new int[n];
    p=new int[pn];
    max=new int[pn];
    for(i=0 ; i<n ; i++)a[i]=sc.nextInt();
    for(i=0 ; i<n ; i++){
      for(j=0 ; j<pn ; j++)p[j]=0 ;
      for(; a[i]!=1 ; ){
        for(j=2 ; j*j<=a[i]; j++){
          if(a[i] % j==0){
            p[j]++;
            a[i]=a[i]/j ;
            break ;
          }
        }
        if(j*j>a[i]){
          p[a[i] ]++;
          break ;
        }
      }
      for(j=2 ; j<pn ; j++)if(max[j]<p[j])max[j]=p[j];
    }
    res=1 ;
    for(i=2 ; i<pn ; i++)if(isprime(i))for(j=0 ; j<max[i]; j++)res*=i ;
    System.out.println(res);
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
  private static boolean isprime(int p){
    int i ;
    if(p==1)return false ;
    for(i=2 ; i*i<=p ; i++){
      if(p % i==0)return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var a : Sequence(int) ;
    var p : Sequence(int) ;
    var max : Sequence(int) ;
    var i : int ;
    var j : int ;
    var res : int ;
    var pn : int ;
    n := sc.nextInt() ; 
    pn := 1000 ; 
    a := Integer.subrange(1,n)->collect(0) ; 
    p := Integer.subrange(1,pn)->collect(0) ; 
    max := Integer.subrange(1,pn)->collect(0) ; 
        i := 0 ; while i < n do (     a[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (         j := 0 ; while j < pn do (     p[j+1] := 0 ;  ;     j := j + 1 ) ; 
       while a[i+1] /= 1 do ( (         j := 2 ; while j * j <= a[i+1] do ( (     if (a[i+1] mod j = 0) then (     p[j+1] := p[j+1] + 1 ; 
     a[i+1] := a[i+1] / j ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (j * j > a[i+1]) then (     p[a[i+1]+1] := p[a[i+1]+1] + 1 ; 
     break ) else skip )  ) ; 
         j := 2 ; while j < pn do (     if (max[j+1] < p[j+1]) then     max[j+1] := p[j+1] ; else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    res := 1 ; 
        i := 2 ; while i < pn do (     if (isprime(i)) then         j := 0 ; while j < max[i+1] do (     res := res*(i) ;  ;     j := j + 1 ) ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
  static   operation isprime( p : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ;
     if (p = 1) then     return false else skip ; 
         i := 2 ; while i * i <= p do ( (     if (p mod i = 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskC solver=new TaskC();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskC {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      long[] cnt=new long[5];
      Arrays.fill(cnt,0);
      for(int i=0 ; i<n ; ++i){
        String str=in.next();
        if(str.charAt(0)=='M'){
          cnt[0]++;
        }
        else if(str.charAt(0)=='A'){
          cnt[1]++;
        }
        else if(str.charAt(0)=='R'){
          cnt[2]++;
        }
        else if(str.charAt(0)=='C'){
          cnt[3]++;
        }
        else if(str.charAt(0)=='H'){
          cnt[4]++;
        }
      }
      long res=cnt[0]*cnt[1]*cnt[2]+cnt[0]*cnt[1]*cnt[3]+cnt[0]*cnt[1]*cnt[4]+cnt[0]*cnt[2]*cnt[3]+cnt[0]*cnt[2]*cnt[4]+cnt[0]*cnt[3]*cnt[4]+cnt[1]*cnt[2]*cnt[3]+cnt[1]*cnt[2]*cnt[4]+cnt[1]*cnt[3]*cnt[4]+cnt[2]*cnt[3]*cnt[4];
      out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskC ; solver := TaskC.newTaskC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskC {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var cnt : Sequence(long) ; cnt := Integer.subrange(1,5)->collect(0) ;
    cnt := cnt->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := in.getCurrent() ;
     if (str->at(0+1) = 'M') then (     cnt[0+1] := cnt[0+1] + 1 ) else     if (str->at(0+1) = 'A') then (     cnt[1+1] := cnt[1+1] + 1 ) else     if (str->at(0+1) = 'R') then (     cnt[2+1] := cnt[2+1] + 1 ) else     if (str->at(0+1) = 'C') then (     cnt[3+1] := cnt[3+1] + 1 ) else     if (str->at(0+1) = 'H') then (     cnt[4+1] := cnt[4+1] + 1 ) else skip ; ;  ;  ;  )  ;     i := i + 1 ) ; 
    var res : long ; res := cnt[0+1] * cnt[1+1] * cnt[2+1] + cnt[0+1] * cnt[1+1] * cnt[3+1] + cnt[0+1] * cnt[1+1] * cnt[4+1] + cnt[0+1] * cnt[2+1] * cnt[3+1] + cnt[0+1] * cnt[2+1] * cnt[4+1] + cnt[0+1] * cnt[3+1] * cnt[4+1] + cnt[1+1] * cnt[2+1] * cnt[3+1] + cnt[1+1] * cnt[2+1] * cnt[4+1] + cnt[1+1] * cnt[3+1] * cnt[4+1] + cnt[2+1] * cnt[3+1] * cnt[4+1] ;
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cjB {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int cas=sc.nextInt();
    for(int cass=1 ; cass<=cas ; cass++){
      System.out.print("Case #"+cass+": ");
      int seats=sc.nextInt();
      int customers=sc.nextInt();
      int tickets=sc.nextInt();
      int[] perCust=new int[customers];
      int[] perSeat=new int[seats];
      int maxPerCust=0 ;
      for(int ttt=0 ; ttt<tickets ; ttt++){
        int ssss=sc.nextInt()-1 ;
        int cccc=sc.nextInt()-1 ;
        perCust[cccc]++;
        perSeat[ssss]++;
        if(perCust[cccc]>maxPerCust){
          maxPerCust=perCust[cccc];
        }
      }
      int tt=tickets ;
      int minCoast=0 ;
      while(tt>0){
        minCoast++;
        tt-=seats ;
      }
      if(minCoast<maxPerCust)minCoast=maxPerCust ;
      int tot=0 ;
      for(int qw=0 ; qw<seats ; qw++){
        tot+=perSeat[qw];
        while((minCoast*(qw+1)<tot)){
          minCoast++;
        }
      }
      int promo=0 ;
      for(int qq=0 ; qq<seats ; qq++){
        if(perSeat[qq]>minCoast){
          promo+=(perSeat[qq]-minCoast);
        }
      }
      System.out.println(minCoast+" "+promo);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cjB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cas : int ; cas := sc.getCurrent()->toInteger() ;
         var cass : int ; cass := 1 ; while cass <= cas do ( (     OclFile["System.out"].print("Case #" + cass + ": ") ; 
     var seats : int ; seats := sc.getCurrent()->toInteger() ;
    var customers : int ; customers := sc.getCurrent()->toInteger() ;
    var tickets : int ; tickets := sc.getCurrent()->toInteger() ;
    var perCust : Sequence(int) ; perCust := Integer.subrange(1,customers)->collect(0) ;
    var perSeat : Sequence(int) ; perSeat := Integer.subrange(1,seats)->collect(0) ;
    var maxPerCust : int ; maxPerCust := 0 ;
        var ttt : int ; ttt := 0 ; while ttt < tickets do ( (     var ssss : int ; ssss := sc.getCurrent()->toInteger() - 1 ;
     var cccc : int ; cccc := sc.getCurrent()->toInteger() - 1 ;
    perCust[cccc+1] := perCust[cccc+1] + 1 ; 
    perSeat[ssss+1] := perSeat[ssss+1] + 1 ; 
    if (perCust[cccc+1] > maxPerCust) then (     maxPerCust := perCust[cccc+1] ) else skip ; 
 )  ;     ttt := ttt + 1 ) ; 
    var tt : int ; tt := tickets ;
    var minCoast : int ; minCoast := 0 ;
    while (tt > 0) do (     minCoast := minCoast + 1 ; 
     tt := tt-(seats) ) ; 
    if (minCoast < maxPerCust) then     minCoast := maxPerCust ; else skip ; 
    var tot : int ; tot := 0 ;
        var qw : int ; qw := 0 ; while qw < seats do ( (     tot := tot+(perSeat[qw+1]) ; 
     while ((minCoast * (qw + 1) < tot)) do (     minCoast := minCoast + 1 ) )  ;     qw := qw + 1 ) ; 
    var promo : int ; promo := 0 ;
        var qq : int ; qq := 0 ; while qq < seats do ( (     if (perSeat[qq+1] > minCoast) then (     promo := promo+((perSeat[qq+1] - minCoast)) ) else skip )  ;     qq := qq + 1 ) ; 
    OclFile["System.out"].println(minCoast + " " + promo) ; 
 )  ;     cass := cass + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  static boolean[] isExist=new boolean[2001];
  static int n ;
  static int[] A ;
  public static void main(String[] args){
    try {
      BufferedReader kb=new BufferedReader(new InputStreamReader(System.in));
      n=Integer.parseInt(kb.readLine());
      String[] buf=kb.readLine().split(" ");
      A=new int[n];
      int num ;
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        num=Integer.parseInt(buf[i]);
        for(int j=2000-num ; 0<j ; j--){
          if(isExist[j]){
            isExist[j+num]=true ;
          }
        }
        isExist[num]=true ;
        A[i]=num ;
      }
      StringBuilder output=new StringBuilder();
      int q=Integer.parseInt(kb.readLine());
      buf=kb.readLine().split(" ");
      for(int i=0 ; i<q ; i++){
        if(isExist[Integer.parseInt(buf[i])]){
          output.append("yes").append("\n");
        }
        else {
          output.append("no").append("\n");
        }
      }
      System.out.print(output);
    }
    catch(IOException e){
      System.err.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute isExist : Sequence(boolean) := Integer.subrange(1,2001)->collect(false);
  static   attribute n : int;
  static   attribute A : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var kb : OclFile ; kb := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     n := (kb.readLine())->toInteger() ; 
    var buf : Sequence(String) ; buf := kb.readLine()->split(" ") ;
    A := Integer.subrange(1,n)->collect(0) ; 
    var num : int ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     num := (buf[i+1])->toInteger() ; 
         var j : int ; j := 2000 - num ; while 0 < j do ( (     if (isExist[j+1]) then (     isExist[j + num+1] := true ) else skip )  ;     j := j - 1 ) ; 
     isExist[num+1] := true ; 
     A[i+1] := num )  ;     i := i + 1 ) ; 
    var output : String ; output := StringLib.newString() ;
    var q : int ; q := (kb.readLine())->toInteger() ;
    buf := kb.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < q do ( (     if (isExist[(buf[i+1])->toInteger()+1]) then (     output := output + StringLib.newString("yes") + StringLib.newString("\n") ) else (     output := output + StringLib.newString("no") + StringLib.newString("\n") ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(output) ; 
 )   catch (e : IOException) do (     OclFile["System.err"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAX=10 ;
  static void binomialCoeff(int C[][],int n,int k){
    for(int i=0 ; i<=n ; i++){
      for(int j=0 ; j<=Math.min(i,k); j++){
        if(j==0 || j==i)C[i][j]=1 ;
        else C[i][j]=C[i-1][j-1]+C[i-1][j];
      }
    }
  }
  static int countParallelogram(int n,int m){
    int C[][]=new int[MAX][MAX];
    binomialCoeff(C,Math.max(n,m),2);
    return C[n][2]*C[m][2];
  }
  public static void main(String arg[]){
    int n=5,m=5 ;
    System.out.println(countParallelogram(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 10;
  static   operation binomialCoeff( C : Sequence(Sequence(int)), n : int, k : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= Set{i, k}->min() do ( (     if (j = 0 or j = i) then     C[i+1][j+1] := 1 ; else     C[i+1][j+1] := C[i - 1+1][j - 1+1] + C[i - 1+1][j+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation countParallelogram( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var C : Sequence(Sequence(int)) ; C := Integer.subrange(1,MAX)->collect(Integer.subrange(1,MAX)->collect(0)) ;
     execute binomialCoeff(C, Set{n, m}->max(), 2) ; 
     return C[n+1][2+1] * C[m+1][2+1] );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var m : int ; m := 5 ;
     OclFile["System.out"].println(countParallelogram(n, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int mm=sc.nextInt();
    TreeMap<Integer,Integer>counts=new TreeMap<>();
    int start=sc.nextInt();
    int prev=start ;
    for(int i=1 ; i<mm ; i++){
      int x=sc.nextInt();
      if(counts.containsKey(x-prev)){
        counts.put(x-prev,counts.get(x-prev)+1);
      }
      else {
        counts.put(x-prev,1);
      }
      prev=x ;
    }
    if(counts.containsKey(n+1-prev)){
      counts.put(n+1-prev,counts.get(n+1-prev)+1);
    }
    else {
      counts.put(n+1-prev,1);
    }
    int[] sums=new int[n+1];
    for(Map.Entry<Integer,Integer>entry : counts.entrySet()){
      for(int i=0 ; i<entry.getKey(); i++){
        sums[i]+=(entry.getKey()-i)*entry.getValue();
      }
    }
    int q=sc.nextInt();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<q ; i++){
      int x=sc.nextInt();
      if(x<start-1){
        sb.append(-1).append("\n");
        continue ;
      }
      x-=start-1 ;
      int left=0 ;
      int right=n ;
      while(right-left>1){
        int m=(left+right)/2 ;
        if(sums[m]>x){
          left=m ;
        }
        else {
          right=m ;
        }
      }
      sb.append(right).append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var mm : int ; mm := sc.getCurrent()->toInteger() ;
    var counts : Map(int,int) ; counts := Map{} ;
    var start : int ; start := sc.getCurrent()->toInteger() ;
    var prev : int ; prev := start ;
        var i : int ; i := 1 ; while i < mm do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (counts->keys()->includes(x - prev)) then (     counts := counts->union(Map{x - prev |-> counts->at(x - prev) + 1}) ) else (     counts := counts->union(Map{x - prev |-> 1}) ) ;  
     prev := x )  ;     i := i + 1 ) ; 
    if (counts->keys()->includes(n + 1 - prev)) then (     counts := counts->union(Map{n + 1 - prev |-> counts->at(n + 1 - prev) + 1}) ) else (     counts := counts->union(Map{n + 1 - prev |-> 1}) ) ;  
    var sums : Sequence(int) ; sums := Integer.subrange(1,n + 1)->collect(0) ;
    for (entry : counts->asSet()) do ( (         var i : int ; i := 0 ; while i < entry.getKey() do ( (     sums[i+1] := sums[i+1]+((entry.getKey() - i) * entry.getValue()) )  ;     i := i + 1 ) )  ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < q do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x < start - 1) then (     sb := sb + StringLib.newString(-1) + StringLib.newString("\n") ; 
     continue ) else skip ; 
    x := x-(start - 1) ; 
    var left : int ; left := 0 ;
    var right : int ; right := n ;
    while (right - left > 1) do (     var m : int ; m := (left + right) / 2 ;
     if (sums[m+1] > x) then (     left := m ) else (     right := m ) ) ; 
    sb := sb + StringLib.newString(right) + StringLib.newString("\n") ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line=null ;
    try {
      while((line=br.readLine())!=null){
        line=line.trim();
        line=line.replaceAll("apple","ELPPAHCAEP");
        line=line.replaceAll("peach","apple");
        line=line.replaceAll("ELPPAHCAEP","peach");
        System.out.println(line);
      }
      br.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := null ;
     try (         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     line := line->trim() ; 
     line := line.replaceAllMatches("apple", "ELPPAHCAEP" ) ; 
    line := line.replaceAllMatches("peach", "apple" ) ; 
    line := line.replaceAllMatches("ELPPAHCAEP", "peach" ) ; 
    OclFile["System.out"].println(line) ; 
 ) ;     line := br.readLine() ;
 ) ;  
     skip )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.out ;
public class Main {
  public static void main(String[] args){
    new Main().AOJ0050();
  }
  Scanner sc=new Scanner(System.in);
  void AOJ0050(){
    while(sc.hasNext())out.println(sc.nextLine().replaceAll("apple","PEACH").replaceAll("peach","apple").replaceAll("PEACH","peach"));
  }
  void AOJ0039(){
    HashMap<Character,Integer>dic=new HashMap<Character,Integer>();
    dic.put('I',1);
    dic.put('V',5);
    dic.put('X',10);
    dic.put('L',50);
    dic.put('C',100);
    dic.put('D',500);
    dic.put('M',1000);
    while(sc.hasNext()){
      char[] c=sc.next().toCharArray();
      int ans=0,last=dic.get(c[0]);
      for(int i=0 ; i<c.length ; i++){
        if(last>=dic.get(c[i])){
          ans+=dic.get(c[i]);
          last=dic.get(c[i]);
        }
        else {
          ans+=dic.get(c[i])-last-last ;
          last=dic.get(c[i]);
        }
      }
      out.println(ans);
    }
  }
  void AOJ0020(){
    while(sc.hasNext())out.println(sc.nextLine().toUpperCase());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().AOJ0050() );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation AOJ0050() : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do     out.println(sc.nextLine().replaceAllMatches("apple", "PEACH" ).replaceAllMatches("peach", "apple" ).replaceAllMatches("PEACH", "peach" )) ; );
   operation AOJ0039() : void
  pre: true
  post: true
  activity: (     var dic : Map(String,int) ; dic := Map{} ;
     dic := dic->union(Map{'I' |-> 1}) ; 
    dic := dic->union(Map{'V' |-> 5}) ; 
    dic := dic->union(Map{'X' |-> 10}) ; 
    dic := dic->union(Map{'L' |-> 50}) ; 
    dic := dic->union(Map{'C' |-> 100}) ; 
    dic := dic->union(Map{'D' |-> 500}) ; 
    dic := dic->union(Map{'M' |-> 1000}) ; 
    while (sc.hasNext()) do (     var c : Sequence(String) ; c := sc.getCurrent()->characters() ;
     var ans : int ; ans := 0 ;
    var last : int ; last := dic->at(c[0+1]) ;
         var i : int ; i := 0 ; while i < c->size() do ( (     if (last >= dic->at(c[i+1])) then (     ans := ans+(dic->at(c[i+1])) ; 
     last := dic->at(c[i+1]) ) else (     ans := ans+(dic->at(c[i+1]) - last - last) ; 
     last := dic->at(c[i+1]) ) )  ;     i := i + 1 ) ; 
     out.println(ans) ) ; 
 );
   operation AOJ0020() : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do     out.println(sc.nextLine()->toUpperCase()) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    String s ;
    char[] c ;
    int i ;
    s=sc.nextLine();
    c=new char[s.length()];
    for(i=0 ; i<s.length(); i++)c[i]=s.charAt(i);
    for(i=0 ; i<s.length()-4 ; i++){
      if(c[i]=='a' && c[i+1]=='p' && c[i+2]=='p' && c[i+3]=='l' && c[i+4]=='e'){
        c[i]='p' ;
        c[i+1]='e' ;
        c[i+2]='a' ;
        c[i+3]='c' ;
        c[i+4]='h' ;
      }
      else if(c[i]=='p' && c[i+1]=='e' && c[i+2]=='a' && c[i+3]=='c' && c[i+4]=='h'){
        c[i]='a' ;
        c[i+1]='p' ;
        c[i+2]='p' ;
        c[i+3]='l' ;
        c[i+4]='e' ;
      }
    }
    for(i=0 ; i<s.length(); i++)out.print(c[i]);
    out.println();
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var s : String ;
    var c : Sequence(String) ;
    var i : int ;
    s := sc.nextLine() ; 
    c := Integer.subrange(1,s->size())->collect(0) ; 
        i := 0 ; while i < s->size() do (     c[i+1] := s->at(i+1) ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < s->size() - 4 do ( (     if (c[i+1] = 'a' & c[i + 1+1] = 'p' & c[i + 2+1] = 'p' & c[i + 3+1] = 'l' & c[i + 4+1] = 'e') then (     c[i+1] := 'p' ; 
     c[i + 1+1] := 'e' ; 
    c[i + 2+1] := 'a' ; 
    c[i + 3+1] := 'c' ; 
    c[i + 4+1] := 'h' ; 
 ) else     if (c[i+1] = 'p' & c[i + 1+1] = 'e' & c[i + 2+1] = 'a' & c[i + 3+1] = 'c' & c[i + 4+1] = 'h') then (     c[i+1] := 'a' ; 
     c[i + 1+1] := 'p' ; 
    c[i + 2+1] := 'p' ; 
    c[i + 3+1] := 'l' ; 
    c[i + 4+1] := 'e' ; 
 ) else skip ; )  ;     i := i + 1 ) ; 
        i := 0 ; while i < s->size() do (     out.print(c[i+1]) ;  ;     i := i + 1 ) ; 
    out.println() ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    System.out.println(fixString(br.readLine()));
  }
  public static String fixString(String str){
    String[] word=str.split(" ");
    StringBuffer bf=new StringBuffer();
    for(int i=0 ; i<word.length ; i++){
      bf.append(fixWord(word[i]));
      if(i!=word.length-1){
        bf.append(" ");
      }
    }
    return bf.toString();
  }
  private static String fixWord(String target){
    StringBuffer stringFixed=new StringBuffer();
    int indexHead ;
    int indexTail ;
    if((indexHead=target.indexOf("apple"))>-1){
      indexTail=indexHead+"apple".length();
      stringFixed.append(target.substring(0,indexHead));
      stringFixed.append("peach");
      stringFixed.append(target.substring(indexTail,target.length()));
    }
    else if((indexHead=target.indexOf("peach"))>-1){
      indexTail=indexHead+"peach".length();
      stringFixed.append(target.substring(0,indexHead));
      stringFixed.append("apple");
      stringFixed.append(target.substring(indexTail,target.length()));
    }
    else {
      stringFixed.append(target);
    }
    return stringFixed.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     OclFile["System.out"].println(fixString(br.readLine())) );
  static   operation fixString( str : String) : String
  pre: true
  post: true
  activity: (     var word : Sequence(String) ; word := str->split(" ") ;
     var bf : String ; bf := StringLib.newString() ;
         var i : int ; i := 0 ; while i < word->size() do ( (     bf := bf + StringLib.newString(fixWord(word[i+1])) ; 
     if (i /= word->size() - 1) then (     bf := bf + StringLib.newString(" ") ) else skip )  ;     i := i + 1 ) ; 
     return bf+"" );
  static   operation fixWord( target : String) : String
  pre: true
  post: true
  activity: (     var stringFixed : String ; stringFixed := StringLib.newString() ;
     var indexHead : int ;
    var indexTail : int ;
    if ((indexHead) > -1) then (     indexTail := indexHead + "apple"->size() ; 
     stringFixed := stringFixed + StringLib.newString(target.subrange(0+1,indexHead)) ; 
     stringFixed := stringFixed + StringLib.newString("peach") ; 
     stringFixed := stringFixed + StringLib.newString(target.subrange(indexTail+1,target->size())) ) else     if ((indexHead) > -1) then (     indexTail := indexHead + "peach"->size() ; 
     stringFixed := stringFixed + StringLib.newString(target.subrange(0+1,indexHead)) ; 
     stringFixed := stringFixed + StringLib.newString("apple") ; 
     stringFixed := stringFixed + StringLib.newString(target.subrange(indexTail+1,target->size())) ) else (     stringFixed := stringFixed + StringLib.newString(target) ) ;  ;  
    return stringFixed+"" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    char c[];
    c=sc.nextLine().toCharArray();
    for(int i=0 ; i<c.length ; i++){
      if(c[i]=='a'){
        if(i+1<c.length && c[i+1]=='p'){
          if(i+2<c.length && c[i+2]=='p'){
            if(i+3<c.length && c[i+3]=='l'){
              if(i+4<c.length && c[i+4]=='e'){
                c[i]='p' ;
                c[i+1]='e' ;
                c[i+2]='a' ;
                c[i+3]='c' ;
                c[i+4]='h' ;
              }
            }
          }
        }
      }
      else if(c[i]=='p'){
        if(i+1<c.length && c[i+1]=='e'){
          if(i+2<c.length && c[i+2]=='a'){
            if(i+3<c.length && c[i+3]=='c'){
              if(i+4<c.length && c[i+4]=='h'){
                c[i]='a' ;
                c[i+1]='p' ;
                c[i+2]='p' ;
                c[i+3]='l' ;
                c[i+4]='e' ;
              }
            }
          }
        }
      }
    }
    System.out.println((char[])c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : Sequence(String) ;
    c := sc.nextLine()->characters() ; 
        var i : int ; i := 0 ; while i < c->size() do ( (     if (c[i+1] = 'a') then (     if (i + 1 < c->size() & c[i + 1+1] = 'p') then (     if (i + 2 < c->size() & c[i + 2+1] = 'p') then (     if (i + 3 < c->size() & c[i + 3+1] = 'l') then (     if (i + 4 < c->size() & c[i + 4+1] = 'e') then (     c[i+1] := 'p' ; 
     c[i + 1+1] := 'e' ; 
    c[i + 2+1] := 'a' ; 
    c[i + 3+1] := 'c' ; 
    c[i + 4+1] := 'h' ; 
 ) else skip ) else skip ) else skip ) else skip ) else     if (c[i+1] = 'p') then (     if (i + 1 < c->size() & c[i + 1+1] = 'e') then (     if (i + 2 < c->size() & c[i + 2+1] = 'a') then (     if (i + 3 < c->size() & c[i + 3+1] = 'c') then (     if (i + 4 < c->size() & c[i + 4+1] = 'h') then (     c[i+1] := 'a' ; 
     c[i + 1+1] := 'p' ; 
    c[i + 2+1] := 'p' ; 
    c[i + 3+1] := 'l' ; 
    c[i + 4+1] := 'e' ; 
 ) else skip ) else skip ) else skip ) else skip ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c->oclAsType(Sequence(String))) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    long ans=m,a[]=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      long sum=m/a[i];
      for(int j=i+1 ; j<n ; j++){
        ans=Math.max(ans,sum*a[j]+(m % a[i]));
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var ans : long ; ans := m ;
    var a : Sequence(void) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var sum : long ; sum := m / a[i+1] ;
         var j : int ; j := i + 1 ; while j < n do ( (     ans := Set{ans, sum * a[j+1] + (m mod a[i+1])}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class pre91 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int n=obj.nextInt(),sum=obj.nextInt(),cost[]=new int[n];
    for(int i=0 ; i<n ; i++)cost[i]=obj.nextInt();
    int ans=sum ;
    for(int i=0 ; i<n ; i++){
      int l=sum/cost[i];
      for(int j=i ; j<n ; j++){
        int k=l*cost[j]+sum % cost[i];
        ans=Math.max(ans,k);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre91 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var n : int ; n := obj.nextInt() ;
    var sum : int ; sum := obj.nextInt() ;
    var cost : Sequence(void) ; cost := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     cost[i+1] := obj.nextInt() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := sum ;
        var i : int ; i := 0 ; while i < n do ( (     var l : int ; l := sum / cost[i+1] ;
         var j : int ; j := i ; while j < n do ( (     var k : int ; k := l * cost[j+1] + sum mod cost[i+1] ;
     ans := Set{ans, k}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round2 ;
import java.util.Scanner ;
public class B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int cases=sc.nextInt();
    for(int caze=1 ; caze<=cases ; caze++){
      int N=sc.nextInt();
      int C=sc.nextInt();
      int M=sc.nextInt();
      int[] seats=new int[N];
      int[] clients=new int[C];
      for(int i=0 ; i<M ; i++){
        int pos=sc.nextInt()-1 ;
        int client=sc.nextInt()-1 ;
        seats[pos]++;
        clients[client]++;
      }
      int ansA=0 ;
      for(int i=0 ; i<clients.length ; i++){
        int client=clients[i];
        ansA=Math.max(ansA,client);
      }
      int acum=0 ;
      for(int i=0 ; i<seats.length ; i++){
        int seat=seats[i];
        acum+=seat ;
        ansA=Math.max(ansA,(acum+i)/(i+1));
      }
      int ansB=0 ;
      for(int i=0 ; i<seats.length ; i++){
        int seat=seats[i];
        if(seat>ansA)ansB+=seat-ansA ;
      }
      System.out.println("Case #"+caze+": "+ansA+" "+ansB);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cases : int ; cases := sc.getCurrent()->toInteger() ;
         var caze : int ; caze := 1 ; while caze <= cases do ( (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var C : int ; C := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var seats : Sequence(int) ; seats := Integer.subrange(1,N)->collect(0) ;
    var clients : Sequence(int) ; clients := Integer.subrange(1,C)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     var pos : int ; pos := sc.getCurrent()->toInteger() - 1 ;
     var client : int ; client := sc.getCurrent()->toInteger() - 1 ;
     seats[pos+1] := seats[pos+1] + 1 ; 
     clients[client+1] := clients[client+1] + 1 )  ;     i := i + 1 ) ; 
    var ansA : int ; ansA := 0 ;
        var i : int ; i := 0 ; while i < clients->size() do ( (     var client : int ; client := clients[i+1] ;
     ansA := Set{ansA, client}->max() )  ;     i := i + 1 ) ; 
    var acum : int ; acum := 0 ;
        var i : int ; i := 0 ; while i < seats->size() do ( (     var seat : int ; seat := seats[i+1] ;
     acum := acum+(seat) ; 
     ansA := Set{ansA, (acum + i) / (i + 1)}->max() )  ;     i := i + 1 ) ; 
    var ansB : int ; ansB := 0 ;
        var i : int ; i := 0 ; while i < seats->size() do ( (     var seat : int ; seat := seats[i+1] ;
     if (seat > ansA) then     ansB := ansB+(seat - ansA) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Case #" + caze + ": " + ansA + " " + ansB) ; 
 )  ;     caze := caze + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B41 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int B=in.nextInt();
    int[] A=new int[N];
    for(int n=0 ; n<N ; n++){
      A[n]=in.nextInt();
    }
    int answer=B ;
    int maxSeen=0 ;
    for(int n=N-1 ; n>=0 ; n--){
      int a=A[n];
      int canBuy=B/a ;
      int wouldHave=B % a+canBuy*maxSeen ;
      answer=Math.max(answer,wouldHave);
      maxSeen=Math.max(a,maxSeen);
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B41 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var B : int ; B := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var answer : int ; answer := B ;
    var maxSeen : int ; maxSeen := 0 ;
        var n : int ; n := N - 1 ; while n >= 0 do ( (     var a : int ; a := A[n+1] ;
     var canBuy : int ; canBuy := B / a ;
    var wouldHave : int ; wouldHave := B mod a + canBuy * maxSeen ;
    answer := Set{answer, wouldHave}->max() ; 
    maxSeen := Set{a, maxSeen}->max() ; 
 )  ;     n := n - 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.HashMap ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ExhaustiveSearch solver=new ExhaustiveSearch();
    solver.solve(1,in,out);
    out.close();
  }
  static class ExhaustiveSearch {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      int m=in.nextInt();
      HashMap<Integer,Boolean>hm=new HashMap<>();
      int[] q=new int[m];
      for(int i=0 ; i<m ; i++){
        q[i]=in.nextInt();
        hm.putIfAbsent(q[i],false);
      }
      for(int i=0 ; i<Math.pow(2,n); i++){
        int cmp=0 ;
        for(int j=0 ; j<n ; j++)if((i &(int)Math.pow(2,j))==(int)Math.pow(2,j))cmp+=a[j];
        if(hm.containsKey(cmp))hm.replace(cmp,false,true);
      }
      for(int value : q){
        out.println(hm.get(value)? "yes" : "no");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ExhaustiveSearch ; solver := ExhaustiveSearch.newExhaustiveSearch() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ExhaustiveSearch {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := in.getCurrent()->toInteger() ;
    var hm : Map(int,Boolean) ; hm := Map{} ;
    var q : Sequence(int) ; q := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     q[i+1] := in.getCurrent()->toInteger() ; 
     if hm->keys()->includes(q[i+1]) then skip else hm := hm->union(Map{q[i+1] |-> false}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 2->pow(n) do ( (     var cmp : int ; cmp := 0 ;
         var j : int ; j := 0 ; while j < n do (     if ((MathLib.bitwiseAnd(i,2->pow(j)->oclAsType(int))) = 2->pow(j)->oclAsType(int)) then     cmp := cmp+(a[j+1]) ; else skip ;  ;     j := j + 1 ) ; 
     if (hm->keys()->includes(cmp)) then     hm := hm.replace(cmp, false, true) ; else skip )  ;     i := i + 1 ) ; 
    for (value : q) do ( (     skip )  ) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    long ans=m,a[]=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      long sum=m/a[i];
      for(int j=i+1 ; j<n ; j++){
        ans=Math.max(ans,sum*a[j]+(m % a[i]));
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var ans : long ; ans := m ;
    var a : Sequence(void) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var sum : long ; sum := m / a[i+1] ;
         var j : int ; j := i + 1 ; while j < n do ( (     ans := Set{ans, sum * a[j+1] + (m mod a[i+1])}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int modInverse(int a,int m){
    int m0=m ;
    int y=0,x=1 ;
    if(m==1)return 0 ;
    while(a>1){
      int q=a/m ;
      int t=m ;
      m=a % m ;
      a=t ;
      t=y ;
      y=x-q*y ;
      x=t ;
    }
    if(x<0)x+=m0 ;
    return x ;
  }
  public static void main(String args[]){
    int a=3,m=11 ;
    System.out.println("Modular multiplicative "+"inverse is "+modInverse(a,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation modInverse( a : int, m : int) : int
  pre: true
  post: true
  activity: (     var m0 : int ; m0 := m ;
     var y : int ; y := 0 ;
    var x : int ; x := 1 ;
    if (m = 1) then     return 0 else skip ; 
    while (a > 1) do (     var q : int ; q := a / m ;
     var t : int ; t := m ;
    m := a mod m ; 
    a := t ; 
    t := y ; 
    y := x - q * y ; 
    x := t ; 
 ) ; 
    if (x < 0) then     x := x+(m0) ; else skip ; 
    return x 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var m : int ; m := 11 ;
     OclFile["System.out"].println("Modular multiplicative " + "inverse is " + modInverse(a, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.*;
public class teest extends PrintWriter {
  teest(){
    super(System.out);
  }
  public static void main(String[] $)throws IOException {
    teest o=new teest();
    o.main();
    o.flush();
  }
  void main()throws IOException {
    Scanner a=new Scanner(System.in);
    long m=a.nextLong(),n=a.nextLong(),mod=m % n,c=(m-mod)/n,an=(n-mod)*((c*(c-1))/2);
    c++;
    an+=(mod)*((c*(c-1))/2);
    System.out.print(an+" ");
    m-=(n-1);
    System.out.println((m*(m-1))/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class teest extends OclFile {
   static operation newteest() : teest
  pre: true
  post: true
  activity:
  ( var self : teest ;
    self := createteest();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"]) );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : teest ; o := teest.newteest() ;
     o.main() ; 
     o.flush() );
   operation main() : void
  pre: true
  post: true
  activity: (     var a : OclFile ; a := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : long ; m := a.getCurrent()->toLong() ;
    var n : long ; n := a.getCurrent()->toLong() ;
    var mod : long ; mod := m mod n ;
    var c : long ; c := (m - mod) / n ;
    var an : long ; an := (n - mod) * ((c * (c - 1)) / 2) ;
    c := c + 1 ; 
    an := an+((mod) * ((c * (c - 1)) / 2)) ; 
    OclFile["System.out"].print(an + " ") ; 
    m := m-((n - 1)) ; 
    OclFile["System.out"].println((m * (m - 1)) / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long n=in.nextInt();
    long m=in.nextInt();
    long div=n/m ;
    long mod=n % m ;
    System.out.println(((div*(div-1))/2)*(m-mod)+((div*(div+1))/2)*mod+" "+(((n-m+1)*(n-m))/2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toInteger() ;
    var m : long ; m := in.getCurrent()->toInteger() ;
    var div : long ; div := n / m ;
    var mod : long ; mod := n mod m ;
    OclFile["System.out"].println(((div * (div - 1)) / 2) * (m - mod) + ((div * (div + 1)) / 2) * mod + " " + (((n - m + 1) * (n - m)) / 2)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf478b {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    findPairs(n,m);
  }
  public static void findPairs(int n,int m){
    long max=n-m ;
    max=(1+max)*max/2 ;
    long l=n % m ;
    long min=(n-m)/m ;
    min=(1+min)*min/2*m ;
    if(l!=0){
      min+=((n-m)/m+1)*l ;
    }
    System.out.printf("%d %d%n",min,max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf478b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
     execute findPairs(n, m) );
  static   operation findPairs( n : int, m : int) : void
  pre: true
  post: true
  activity: (     var max : long ; max := n - m ;
     max := (1 + max) * max / 2 ; 
    var l : long ; l := n mod m ;
    var min : long ; min := (n - m) / m ;
    min := (1 + min) * min / 2 * m ; 
    if (l /= 0) then (     min := min+(((n - m) / m + 1) * l) ) else skip ; 
    OclFile["System.out"].printf("%d %d%n", min, max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countBits(int number){
    return(int)(Math.log(number)/Math.log(2)+1);
  }
  public static void main(String[] args){
    int num=65 ;
    System.out.println(countBits(num));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countBits( number : int) : int
  pre: true
  post: true
  activity: (     return ((number)->log() / (2)->log() + 1)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 65 ;
     OclFile["System.out"].println(countBits(num)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Alpha {
  private int ch ;
  void uppercaseAlphabets(){
    for(int c=65 ; c<=90 ; ++c)System.out.print(" "+c);
    System.out.print("\n");
  }
  void lowercaseAlphabets(){
    for(int c=97 ; c<=122 ; ++c)System.out.print(" "+c);
    System.out.print("\n");
  }
  public static void main(String[] args){
    int ch ;
    System.out.println("Uppercase Alphabets");
    Alpha ob=new Alpha();
    ob.uppercaseAlphabets();
    System.out.println("Lowercase Alphabets ");
    ob.lowercaseAlphabets();
  }
}
------------------------------------------------------------
OCL File:
---------
class Alpha {
   attribute ch : int;
   operation uppercaseAlphabets() : void
  pre: true
  post: true
  activity: (         var c : int ; c := 65 ; while c <= 90 do (     OclFile["System.out"].print(" " + c) ;  ;     c := c + 1 ) ; 
     OclFile["System.out"].print("\n") );
   operation lowercaseAlphabets() : void
  pre: true
  post: true
  activity: (         var c : int ; c := 97 ; while c <= 122 do (     OclFile["System.out"].print(" " + c) ;  ;     c := c + 1 ) ; 
     OclFile["System.out"].print("\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ch : int ;
     OclFile["System.out"].println("Uppercase Alphabets") ; 
    var ob : Alpha ; ob := Alpha.newAlpha() ;
    ob.uppercaseAlphabets() ; 
    OclFile["System.out"].println("Lowercase Alphabets ") ; 
    ob.lowercaseAlphabets() ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long hexadecagonalNum(long n){
    return((14*n*n)-12*n)/2 ;
  }
  public static void main(String[] args){
    long n=5 ;
    System.out.println(n+"th "+"Hexadecagonal number : "+hexadecagonalNum(n));
    n=9 ;
    System.out.println(n+"th "+"Hexadecagonal number : "+hexadecagonalNum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation hexadecagonalNum( n : long) : long
  pre: true
  post: true
  activity: (     return ((14 * n * n) - 12 * n) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 5 ;
     OclFile["System.out"].println(n + "th " + "Hexadecagonal number : " + hexadecagonalNum(n)) ; 
     n := 9 ; 
     OclFile["System.out"].println(n + "th " + "Hexadecagonal number : " + hexadecagonalNum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class B {
  public static void main(String[] arg){
    Scanner sc=new Scanner(System.in);
    int TT=sc.nextInt();
    for(int ii=1 ; ii<=TT ; ++ii){
      int N=sc.nextInt();
      int C=sc.nextInt();
      int M=sc.nextInt();
      int[] COUNT=new int[C+1];
      int[] coast=new int[N+1];
      for(int i=0 ; i<M ; ++i){
        int pos=sc.nextInt();
        int buyer=sc.nextInt();
        COUNT[buyer]++;
        coast[pos]++;
      }
      int min=0 ;
      for(int i=0 ; i<COUNT.length ; ++i){
        if(COUNT[i]>min)min=COUNT[i];
      }
      min=Math.max(min,coast[1]);
      int max=M ;
      while(min<max){
        int piv=(min+max)/2 ;
        int promotions=canDo(coast,piv);
        if(promotions>=0){
          if(max==piv)System.err.println("whoops");
          max=piv ;
        }
        else {
          min=piv+1 ;
        }
      }
      if(min!=max)System.err.println("never");
      int ans=canDo(coast,max);
      System.out.printf("Case #%d: %d %d\n",ii,max,ans);
    }
  }
  public static int canDo(int[] coast,int R){
    int slots_available=0 ;
    int promotions=0 ;
    for(int i=1 ; i<coast.length ; ++i){
      if(coast[i]>R){
        if(coast[i]-R>slots_available){
          return-1 ;
        }
        int p=(coast[i]-R);
        slots_available-=p ;
        promotions+=p ;
      }
      else if(coast[i]==R){
      }
      else {
        slots_available+=R-coast[i];
      }
    }
    return promotions ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var TT : int ; TT := sc.getCurrent()->toInteger() ;
         var ii : int ; ii := 1 ; while ii <= TT do ( (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var C : int ; C := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var COUNT : Sequence(int) ; COUNT := Integer.subrange(1,C + 1)->collect(0) ;
    var coast : Sequence(int) ; coast := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     var pos : int ; pos := sc.getCurrent()->toInteger() ;
     var buyer : int ; buyer := sc.getCurrent()->toInteger() ;
     COUNT[buyer+1] := COUNT[buyer+1] + 1 ; 
     coast[pos+1] := coast[pos+1] + 1 )  ;     i := i + 1 ) ; 
    var min : int ; min := 0 ;
        var i : int ; i := 0 ; while i < COUNT->size() do ( (     if (COUNT[i+1] > min) then     min := COUNT[i+1] ; else skip )  ;     i := i + 1 ) ; 
    min := Set{min, coast[1+1]}->max() ; 
    var max : int ; max := M ;
    while (min < max) do (     var piv : int ; piv := (min + max) / 2 ;
     var promotions : int ; promotions := canDo(coast, piv) ;
     if (promotions >= 0) then (     if (max = piv) then     OclFile["System.err"].println("whoops") ; else skip ; 
     max := piv ) else (     min := piv + 1 ) ) ; 
    if (min /= max) then     OclFile["System.err"].println("never") ; else skip ; 
    var ans : int ; ans := canDo(coast, max) ;
    OclFile["System.out"].printf("Case #%d: %d %d\n", ii, max, ans) ; 
 )  ;     ii := ii + 1 ) );
  static   operation canDo( coast : Sequence(int), R : int) : int
  pre: true
  post: true
  activity: (     var slots_available : int ; slots_available := 0 ;
     var promotions : int ; promotions := 0 ;
         var i : int ; i := 1 ; while i < coast->size() do ( (     if (coast[i+1] > R) then (     if (coast[i+1] - R > slots_available) then (     return -1 ) else skip ; 
     var p : int ; p := (coast[i+1] - R) ;
     slots_available := slots_available-(p) ; 
     promotions := promotions+(p) ) else     if (coast[i+1] = R) then skip else (     slots_available := slots_available+(R - coast[i+1]) ) ;  )  ;     i := i + 1 ) ; 
     return promotions );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
    try {
      while(true){
        int n=Integer.valueOf(sc.readLine());
        if(n==0)break ;
        int[][] dp=new int[n][n];
        int max=0 ;
        for(int j=0 ; j<n ; j++){
          String sp=sc.readLine();
          for(int i=0 ; i<n ; i++)if(sp.charAt(i)=='*')dp[j][i]=0 ;
          else if(j==0 || i==0)dp[j][i]=1 ;
          else {
            dp[j][i]=Math.min(Math.min(dp[j][i-1],dp[j-1][i]),dp[j-1][i-1])+1 ;
            max=Math.max(max,dp[j][i]);
          }
        }
        System.out.println(max);
      }
    }
    catch(Exception e){
      System.out.println("Error");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     while (true) do (     var n : int ; n := (sc.readLine())->toInteger() ;
     if (n = 0) then     break else skip ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var max : int ; max := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     var sp : String ; sp := sc.readLine() ;
         var i : int ; i := 0 ; while i < n do (     if (sp->at(i+1) = '*') then     dp[j+1][i+1] := 0 else     if (j = 0 or i = 0) then     dp[j+1][i+1] := 1 else (     dp[j+1][i+1] := Set{Set{dp[j+1][(i)->char2byte() - 1+1], dp[j - 1+1][i+1]}->min(), dp[j - 1+1][(i)->char2byte() - 1+1]}->min() + 1 ; 
     max := Set{max, dp[j+1][i+1]}->max() ) ;  ;   ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) )   catch (e : ProgramException) do (     OclFile["System.out"].println("Error") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.min ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while(!(line=br.readLine()).equals("0")){
      int n=Integer.parseInt(line);
      int[][] grid=new int[n+2][n+2];
      for(int i=0 ; i<n ; i++){
        line=br.readLine();
        for(int j=0 ; j<n ; j++){
          grid[i+1][j+1]=line.charAt(j)=='.' ? 1 : 0 ;
        }
      }
      int max=0 ;
      for(int i=1 ; i<n+1 ; i++){
        for(int j=1 ; j<n+1 ; j++){
          if(grid[i][j]!=0){
            int min ;
            min=(int)min(grid[i-1][j-1],grid[i-1][j]);
            min=(int)min(min,grid[i][j-1]);
            grid[i][j]=min+1 ;
            if(grid[i][j]>max){
              max=grid[i][j];
            }
          }
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
     while (not((line) = "0")) do (     var n : int ; n := (line)->toInteger() ;
     var grid : Sequence(Sequence(int)) ; grid := Integer.subrange(1,n + 2)->collect(Integer.subrange(1,n + 2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     line := br.readLine() ; 
         var j : int ; j := 0 ; while j < n do ( (     grid[i + 1+1][j + 1+1] := if line->at(j+1) = '.' then 1 else 0 endif )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i < n + 1 do ( (         var j : int ; j := 1 ; while j < n + 1 do ( (     if (grid[i+1][j+1] /= 0) then (     var min : int ;
     min := Set{grid[i - 1+1][j - 1+1], grid[i - 1+1][j+1]}->min()->oclAsType(int) ; 
    min := Set{min, grid[i+1][j - 1+1]}->min()->oclAsType(int) ; 
    grid[i+1][j+1] := min + 1 ; 
    if (grid[i+1][j+1] > max) then (     max := grid[i+1][j+1] ) else skip ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      StrSplitToInt str ;
      int n=Integer.parseInt(br.readLine());
      int[] seqA=new int[n];
      str=new StrSplitToInt(br.readLine()," ");
      for(int i=0 ; i<n ; i++){
        seqA[i]=str.nextInt();
      }
      int q=Integer.parseInt(br.readLine());
      str=new StrSplitToInt(br.readLine()," ");
      for(int i=0 ; i<q ; i++){
        if(solve(n,seqA,0,str.nextInt()))System.out.println("yes");
        else System.out.println("no");
      }
    }
  }
  private static boolean solve(int n,int[] a,int i,int m){
    if(m==0)return true ;
    if(i>=n)return false ;
    boolean res=solve(n,a,i+1,m)|| solve(n,a,i+1,m-a[i]);
    return res ;
  }
}
class StrSplitToInt {
  final String s ;
  final String split ;
  final int endPos ;
  final int splitLen ;
  int currentPos ;
  int nextPos ;
  public StrSplitToInt(String s,String split){
    this.s=s ;
    this.split=split ;
    currentPos=0 ;
    nextPos=s.indexOf(split,currentPos);
    endPos=s.length();
    splitLen=split.length();
  }
  public int nextInt(){
    if(currentPos<endPos){
      int ret=Integer.parseInt(s.substring(currentPos,nextPos));
      currentPos=nextPos+splitLen ;
      nextPos=s.indexOf(split,currentPos);
      if(nextPos==-1)nextPos=endPos ;
      return ret ;
    }
    else return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var str : StrSplitToInt ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var seqA : Sequence(int) ; seqA := Integer.subrange(1,n)->collect(0) ;
    str := StrSplitToInt.newStrSplitToInt(br.readLine(), " ") ; 
        var i : int ; i := 0 ; while i < n do ( (     seqA[i+1] := str.nextInt() )  ;     i := i + 1 ) ; 
    var q : int ; q := (br.readLine())->toInteger() ;
    str := StrSplitToInt.newStrSplitToInt(br.readLine(), " ") ; 
        var i : int ; i := 0 ; while i < q do ( (     if (solve(n, seqA, 0, str.nextInt())) then     OclFile["System.out"].println("yes") ; else     OclFile["System.out"].println("no") ; )  ;     i := i + 1 ) ; 
 ))  );
  static   operation solve( n : int, a : Sequence(int), i : int, m : int) : boolean
  pre: true
  post: true
  activity: (     if (m = 0) then     return true else skip ; 
     if (i >= n) then     return false else skip ; 
     var res : boolean ; res := solve(n, a, i + 1, m) or solve(n, a, i + 1, m - a[i+1]) ;
     return res );
}
class StrSplitToInt {
   attribute s : String;
   attribute split : String;
   attribute endPos : int;
   attribute splitLen : int;
   attribute currentPos : int;
   attribute nextPos : int;
   static operation newStrSplitToInt( s : String, split : String) : StrSplitToInt
  pre: true
  post: true
  activity:
  ( var self : StrSplitToInt ;
    self := createStrSplitToInt();
    self.initialise(s, split);
    return self );
  operation initialise( s : String, split : String) : void
  pre: true  post: true
  activity: (     self.s := s ; 
     self.split := split ; 
    currentPos := 0 ; 
    nextPos := s.subrange(currentPos+1)->indexOf(split+"") + currentPos - 1  ; 
    endPos := s->size() ; 
    splitLen := split->size() ; 
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     if (currentPos < endPos) then (     var ret : int ; ret := (s.subrange(currentPos+1,nextPos))->toInteger() ;
     currentPos := nextPos + splitLen ; 
    nextPos := s.subrange(currentPos+1)->indexOf(split+"") + currentPos - 1  ; 
    if (nextPos = -1) then     nextPos := endPos ; else skip ; 
    return ret 
 ) else     return -1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static int n ;
  static char[][] field ;
  static int[][] greatestSize ;
  static void solve(){
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(field[i][j]=='*'){
          greatestSize[i][j]=0 ;
        }
        else if(i==0 || j==0){
          greatestSize[i][j]=1 ;
        }
        else {
          greatestSize[i][j]=Math.min(greatestSize[i-1][j-1],Math.min(greatestSize[i-1][j],greatestSize[i][j-1]))+1 ;
        }
      }
    }
    int result=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        result=Math.max(result,greatestSize[i][j]);
      }
    }
    System.out.println(result);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      n=sc.nextInt();
      if(n==0)break ;
      field=new char[n][n];
      greatestSize=new int[n][n];
      for(int i=0 ; i<n ; i++){
        field[i]=sc.next().toCharArray();
        for(int j=0 ; j<n ; j++){
          greatestSize[i][j]=0 ;
        }
      }
      solve();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute field : Sequence(Sequence(String));
  static   attribute greatestSize : Sequence(Sequence(int));
  static   operation solve() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (field[i+1][j+1] = '*') then (     greatestSize[i+1][j+1] := 0 ) else     if (i = 0 or j = 0) then (     greatestSize[i+1][j+1] := 1 ) else (     greatestSize[i+1][j+1] := Set{greatestSize[i - 1+1][j - 1+1], Set{greatestSize[i - 1+1][j+1], greatestSize[i+1][j - 1+1]}->min()}->min() + 1 ) ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     result := Set{result, greatestSize[i+1][j+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(result) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
    field := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
    greatestSize := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
        var i : int ; i := 0 ; while i < n do ( (     field[i+1] := sc.getCurrent()->characters() ; 
         var j : int ; j := 0 ; while j < n do ( (     greatestSize[i+1][j+1] := 0 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    execute solve() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static char[][] field ;
  static int[][] dp ;
  static int n ;
  public static void main(String[] args){
    while(read()){
      slove();
    }
  }
  static boolean read(){
    n=sc.nextInt();
    if(n==0)return false ;
    field=new char[n+1][n+1];
    dp=new int[n+1][n+1];
    String line ;
    for(int i=1 ; i<=n ; i++){
      line=sc.next();
      for(int j=1 ; j<=n ; j++){
        field[i][j]=line.charAt(j-1);
        dp[i][j]=0 ;
      }
    }
    for(int k=1 ; k<=n ; k++){
      dp[k][0]=1 ;
      dp[0][k]=1 ;
    }
    return true ;
  }
  static int min(int a,int b,int c){
    int temp=Math.min(a,b);
    int min=Math.min(c,temp);
    return min ;
  }
  static void slove(){
    int maxWidth=0 ;
    int count=0 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=n ; j++){
        if(field[i][j]=='*'){
          dp[i][j]=0 ;
        }
        else {
          dp[i][j]=min(dp[i-1][j-1],dp[i-1][j],dp[i][j-1])+1 ;
          maxWidth=Math.max(maxWidth,dp[i][j]);
        }
      }
    }
    System.out.println(maxWidth);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute field : Sequence(Sequence(String));
  static   attribute dp : Sequence(Sequence(int));
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (read()) do (     execute slove() ) );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     return false else skip ; 
    field := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ; 
    dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ; 
    var line : String ;
        var i : int ; i := 1 ; while i <= n do ( (     line := sc.getCurrent() ; 
         var j : int ; j := 1 ; while j <= n do ( (     field[i+1][j+1] := line->at(j - 1+1) ; 
     dp[i+1][j+1] := 0 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var k : int ; k := 1 ; while k <= n do ( (     dp[k+1][0+1] := 1 ; 
     dp[0+1][k+1] := 1 )  ;     k := k + 1 ) ; 
    return true 
 );
  static   operation min( a : int, b : int, c : int) : int
  pre: true
  post: true
  activity: (     var temp : int ; temp := Set{a, b}->min() ;
     var min : int ; min := Set{c, temp}->min() ;
     return min );
  static   operation slove() : void
  pre: true
  post: true
  activity: (     var maxWidth : int ; maxWidth := 0 ;
     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     if (field[i+1][j+1] = '*') then (     dp[i+1][j+1] := 0 ) else (     dp[i+1][j+1] := Set{dp[(i)->char2byte() - 1+1][j - 1+1], dp[(i)->char2byte() - 1+1][j+1], dp[i+1][j - 1+1]}->min() + 1 ; 
     maxWidth := Set{maxWidth, dp[i+1][j+1]}->max() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(maxWidth) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static int solve(char[][] map){
    int count=1 ;
    int max=0 ;
    for(int i=1 ; i<map.length-max ; i++){
      for(int j=1 ; j<map.length-max ; j++){
        if(map[i][j]=='.'){
          int k=1 ;
          for(int l=0 ; l<count ; l++){
            while(map[i+l][j+k+l]=='.' && map[i+k+l][j+l]=='.'){
              k++;
            }
            if(l==0){
              count=k+l ;
            }
            else if(count>k+l){
              count=k+l ;
            }
            if(k==0){
              break ;
            }
            k=0 ;
          }
          if(count>max){
            max=count ;
          }
          count=1 ;
        }
      }
    }
    return max ;
  }
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int n ;
    while((n=stdIn.nextInt())!=0){
      String[] s=new String[n];
      stdIn.nextLine();
      for(int i=0 ; i<n ; i++){
        s[i]=stdIn.nextLine();
      }
      char[][] map=new char[n+2][n+2];
      for(int i=1 ; i<=n ; i++){
        for(int j=1 ; j<=n ; j++){
          map[i][j]=s[i-1] .charAt(j-1);
        }
      }
      System.out.println(solve(map));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( map : Sequence(Sequence(String))) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 1 ;
     var max : int ; max := 0 ;
         var i : int ; i := 1 ; while i < map->size() - max do ( (         var j : int ; j := 1 ; while j < map->size() - max do ( (     if (map[i+1][j+1] = '.') then (     var k : int ; k := 1 ;
         var l : int ; l := 0 ; while l < count do ( (     while (map[i + l+1][j + k + l+1] = '.' & map[i + k + l+1][j + l+1] = '.') do (     k := k + 1 ) ; 
     if (l = 0) then (     count := k + l ) else     if (count > k + l) then (     count := k + l ) else skip ; ;  
     if (k = 0) then (     break ) else skip ; 
     k := 0 )  ;     l := l + 1 ) ; 
     if (count > max) then (     max := count ) else skip ; 
     count := 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return max );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
         n := stdIn.getCurrent()->toInteger() ;
    while ((n) /= 0) do (    skip ; (     var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
     skip ; 
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := stdIn.nextLine() )  ;     i := i + 1 ) ; 
    var map : Sequence(Sequence(String)) ; map := Integer.subrange(1,n + 2)->collect(Integer.subrange(1,n + 2)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     map[i+1][j+1] := s[i - 1+1]->at(j - 1+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(map)) ; 
 ) ;     n := stdIn.getCurrent()->toInteger() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void main(String[] args){
    char i ;
    System.out.printf("The Alphabets from A to Z are: \n");
    for(i='A' ; i<='Z' ; i++){
      System.out.printf("%c ",i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : String ;
     OclFile["System.out"].printf("The Alphabets from A to Z are: \n") ; 
         i := 'A' ; while i <= 'Z' do ( (     OclFile["System.out"].printf("%c ", i) )  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B_Equivalent_Strings {
  static Scanner in=new Scanner(System.in);
  static int n,m ;
  static String a,b ;
  static String solve(String a){
    int len=a.length();
    if((len & 1)==1){
      return a ;
    }
    String s1=solve(a.substring(0,len/2));
    String s2=solve(a.substring(len/2,len));
    if(s1.compareTo(s2)<=0){
      return s1+s2 ;
    }
    else {
      return s2+s1 ;
    }
  }
  public static void main(String[] priya){
    a=in.next();
    b=in.next();
    if(solve(a).equals(solve(b))){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Equivalent_Strings {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   attribute a : String;
  static   operation solve( a : String) : String
  pre: true
  post: true
  activity: (     var len : int ; len := a->size() ;
     if ((MathLib.bitwiseAnd(len,1)) = 1) then (     return a ) else skip ; 
    var s1 : String ; s1 := solve(a.subrange(0+1,len / 2)) ;
    var s2 : String ; s2 := solve(a.subrange(len / 2+1,len)) ;
    if (s1->compareTo(s2) <= 0) then (     return s1 + s2 ) else (     return s2 + s1 ) ;  
 );
  static   operation main( priya : Sequence(String)) : void
  pre: true
  post: true
  activity: (     a := in.getCurrent() ; 
     b := in.getCurrent() ; 
     if (solve(a) = solve(b)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B_Equivalent_Strings {
  static Scanner in=new Scanner(System.in);
  static int n,m ;
  static String a,b ;
  static String solve(String a){
    int len=a.length();
    if((len & 1)==1){
      return a ;
    }
    String s1=solve(a.substring(0,len/2));
    String s2=solve(a.substring(len/2,len));
    if(s1.compareTo(s2)<=0){
      return s1+s2 ;
    }
    else {
      return s2+s1 ;
    }
  }
  public static void main(String[] priya){
    a=in.next();
    b=in.next();
    if(solve(a).equals(solve(b))){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Equivalent_Strings {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   attribute a : String;
  static   operation solve( a : String) : String
  pre: true
  post: true
  activity: (     var len : int ; len := a->size() ;
     if ((MathLib.bitwiseAnd(len,1)) = 1) then (     return a ) else skip ; 
    var s1 : String ; s1 := solve(a.subrange(0+1,len / 2)) ;
    var s2 : String ; s2 := solve(a.subrange(len / 2+1,len)) ;
    if (s1->compareTo(s2) <= 0) then (     return s1 + s2 ) else (     return s2 + s1 ) ;  
 );
  static   operation main( priya : Sequence(String)) : void
  pre: true
  post: true
  activity: (     a := in.getCurrent() ; 
     b := in.getCurrent() ; 
     if (solve(a) = solve(b)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class EQSTRING {
  static boolean cal(String a,String b){
    if(a.length()!=b.length())return false ;
    if(a.equals(b))return true ;
    if(a.length()==1){
      if(a.equals(b))return true ;
      else return false ;
    }
    if(a.length()% 2!=0)return false ;
    int mid=a.length()/2 ;
    String a1=a.substring(0,mid);
    String a2=a.substring(mid);
    String b1=b.substring(0,mid);
    String b2=b.substring(mid);
    return cal(a1,b1)&& cal(a2,b2)|| cal(a2,b1)&& cal(a1,b2);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String a=sc.next();
    String b=sc.next();
    if(cal(a,b)){
      System.out.println("YES");
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class EQSTRING {
  static   operation cal( a : String, b : String) : boolean
  pre: true
  post: true
  activity: (     if (a->size() /= b->size()) then     return false else skip ; 
     if (a = b) then     return true else skip ; 
    if (a->size() = 1) then (     if (a = b) then     return true else     return false ) else skip ; 
    if (a->size() mod 2 /= 0) then     return false else skip ; 
    var mid : int ; mid := a->size() / 2 ;
    var a1 : String ; a1 := a.subrange(0+1,mid) ;
    var a2 : String ; a2 := a.subrange(mid+1,mid) ;
    var b1 : String ; b1 := b.subrange(0+1,mid) ;
    var b2 : String ; b2 := b.subrange(mid+1,mid) ;
    return cal(a1, b1) & cal(a2, b2) or cal(a2, b1) & cal(a1, b2) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := sc.getCurrent() ;
     var b : String ; b := sc.getCurrent() ;
     if (cal(a, b)) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.ArrayList ;
public class codforce {
  public static void main(String[] args){
    Scanner str=new Scanner(System.in);
    int n=str.nextInt();
    String s="" ;
    while(n>0){
      int x=n % 2 ;
      n/=2 ;
      s+=x+"" ;
    }
    int ans=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='1'){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codforce {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : OclFile ; str := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := str.getCurrent()->toInteger() ;
    var s : String ; s := "" ;
    while (n > 0) do (     var x : int ; x := n mod 2 ;
     n := n/(2) ; 
     s := s+(x + "") ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '1') then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
public class AllPalindromeSubstringsPossible {
  public static List<String>allPalindromeSubstring(String s){
    List<String>list=new ArrayList<String>();
    for(float pivot=0 ; pivot<s.length(); pivot+=.5){
      float palindromeRadius=pivot-(int)pivot ;
      while((pivot+palindromeRadius)<s.length()&&(pivot-palindromeRadius)>=0 && s.charAt((int)(pivot-palindromeRadius))==s.charAt((int)(pivot+palindromeRadius))){
        list.add(s.substring((int)(pivot-palindromeRadius),(int)(pivot+palindromeRadius+1)));
        palindromeRadius++;
      }
    }
    return list ;
  }
  public static void main(String[] args){
    List<String>list=allPalindromeSubstring("hellolle");
    System.out.println(list.size());
    System.out.println(list);
    list=allPalindromeSubstring("geeksforgeeks");
    System.out.println(list.size());
    System.out.println(list);
  }
}
------------------------------------------------------------
OCL File:
---------
 class AllPalindromeSubstringsPossible {
  static   operation allPalindromeSubstring( s : String) : Sequence(String)
  pre: true
  post: true
  activity: (     var list : Sequence(String) ; list := Sequence{} ;
         var pivot : double ; pivot := 0 ; while pivot < s->size() do ( (     var palindromeRadius : double ; palindromeRadius := pivot - pivot->oclAsType(int) ;
     while ((pivot + palindromeRadius) < s->size() & (pivot - palindromeRadius) >= 0 & s->at((pivot - palindromeRadius)->oclAsType(int)+1) = s->at((pivot + palindromeRadius)->oclAsType(int)+1)) do (     list := list->including(s.subrange((pivot - palindromeRadius)->oclAsType(int)+1,(pivot + palindromeRadius + 1)->oclAsType(int))) ; 
     palindromeRadius := palindromeRadius + 1 ) )  ;     pivot := pivot+(.5) ) ; 
     return list );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(String) ; list := allPalindromeSubstring("hellolle") ;
     OclFile["System.out"].println(list->size()) ; 
    OclFile["System.out"].println(list) ; 
    list := allPalindromeSubstring("geeksforgeeks") ; 
    OclFile["System.out"].println(list->size()) ; 
    OclFile["System.out"].println(list) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String decimalToBinary(double num,int k_prec){
    String binary="" ;
    int Integral=(int)num ;
    double fractional=num-Integral ;
    while(Integral>0){
      int rem=Integral % 2 ;
      binary+=((char)(rem+'0'));
      Integral/=2 ;
    }
    binary=reverse(binary);
    binary+=('.');
    while(k_prec-->0){
      fractional*=2 ;
      int fract_bit=(int)fractional ;
      if(fract_bit==1){
        fractional-=fract_bit ;
        binary+=(char)(1+'0');
      }
      else {
        binary+=(char)(0+'0');
      }
    }
    return binary ;
  }
  static String reverse(String input){
    char[] temparray=input.toCharArray();
    int left,right=0 ;
    right=temparray.length-1 ;
    for(left=0 ; left<right ; left++,right--){
      char temp=temparray[left];
      temparray[left]=temparray[right];
      temparray[right]=temp ;
    }
    return String.valueOf(temparray);
  }
  public static void main(String[] args){
    double n=4.47 ;
    int k=3 ;
    System.out.println(decimalToBinary(n,k));
    n=6.986 ;
    k=5 ;
    System.out.println(decimalToBinary(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation decimalToBinary( num : double, k_prec : int) : String
  pre: true
  post: true
  activity: (     var binary : String ; binary := "" ;
     var Integral : int ; Integral := num->oclAsType(int) ;
    var fractional : double ; fractional := num - (Integral)->char2byte() ;
    while (Integral > 0) do (     var rem : int ; rem := Integral mod 2 ;
     binary := binary+(((rem + '0')->oclAsType(String))) ; 
     Integral := Integral/(2) ) ; 
    binary := reverse(binary) ; 
    binary := binary+(('.')) ; 
        while (k_prec > 0) do (        k_prec := k_prec - 1 ;     skip ; (     fractional := fractional*(2) ; 
     var fract_bit : int ; fract_bit := fractional->oclAsType(int) ;
     if (fract_bit = 1) then (     fractional := fractional-(fract_bit) ; 
     binary := binary+((1 + '0')->oclAsType(String)) ) else (     binary := binary+((0 + '0')->oclAsType(String)) ) ) ;  ) ;  
    return binary 
 );
  static   operation reverse( input : String) : String
  pre: true
  post: true
  activity: (     var temparray : Sequence(String) ; temparray := input->characters() ;
     var left : int ;
    var right : int ; right := 0 ;
    right := temparray->size() - 1 ; 
        left := 0 ; while left < right do ( (     var temp : String ; temp := temparray[left+1] ;
     temparray[left+1] := temparray[right+1] ; 
     temparray[right+1] := temp )  ;     left := left + 1 ;     right := right - 1 ) ; 
    return (temparray)->sum()  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 4.47 ;
     var k : int ; k := 3 ;
    OclFile["System.out"].println(decimalToBinary(n, k)) ; 
    n := 6.986 ; 
    k := 5 ; 
    OclFile["System.out"].println(decimalToBinary(n, k)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ParallelogramPoints {
  public static void main(String[] s){
    int ax=5,ay=0 ;
    int bx=1,by=1 ;
    int cx=2,cy=5 ;
    System.out.println(ax+bx-cx+","+(ay+by-cy));
    System.out.println(ax+cx-bx+","+(ay+cy-by));
    System.out.println(cx+bx-ax+","+(cy+by-ax));
  }
}
------------------------------------------------------------
OCL File:
---------
class ParallelogramPoints {
  static   operation main( s : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ax : int ; ax := 5 ;
    var ay : int ; ay := 0 ;
     var bx : int ; bx := 1 ;
    var by : int ; by := 1 ;
    var cx : int ; cx := 2 ;
    var cy : int ; cy := 5 ;
    OclFile["System.out"].println(ax + bx - cx + "," + (ay + by - cy)) ; 
    OclFile["System.out"].println(ax + cx - bx + "," + (ay + cy - by)) ; 
    OclFile["System.out"].println(cx + bx - ax + "," + (cy + by - ax)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static boolean check(ArrayList<Integer>a,int m){
    ArrayList<Integer>buf=new ArrayList<Integer>();
    buf.add(0);
    if(m==0){
      return true ;
    }
    for(int i=0 ; i<a.size(); i++){
      int bufLength=buf.size();
      for(int j=0 ; j<bufLength ; j++){
        int x=buf.get(j)+a.get(i);
        if(x==m){
          return true ;
        }
        else if(x<m && ! buf.contains(x)){
          buf.add(x);
        }
      }
    }
    return false ;
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    ArrayList<Integer>a=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      a.add(scanner.nextInt());
    }
    int q=scanner.nextInt();
    for(int i=0 ; i<q ; i++){
      if(check(a,scanner.nextInt())){
        System.out.println("yes");
      }
      else {
        System.out.println("no");
      }
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation check( a : Sequence(int), m : int) : boolean
  pre: true
  post: true
  activity: (     var buf : Sequence(int) ; buf := Sequence{} ;
     buf := buf->including(0) ; 
    if (m = 0) then (     return true ) else skip ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     var bufLength : int ; bufLength := buf->size() ;
         var j : int ; j := 0 ; while j < bufLength do ( (     var x : int ; x := buf->at(j+1) + a->at(i+1) ;
     if (x = m) then (     return true ) else     if (x < m & not(buf->includes(x))) then (     buf := buf->including(x) ) else skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     a := a->including(scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var q : int ; q := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     if (check(a, scanner.getCurrent()->toInteger())) then (     OclFile["System.out"].println("yes") ) else (     OclFile["System.out"].println("no") ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class AprilFool {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t1=0,t2=0 ;
    String a1=sc.next();
    String a2=sc.next();
    String a="8<" ;
    String b="[] " ;
    String c="()" ;
    for(int i=0 ; i<a1.length(); i+=2){
      if(a1.substring(i,i+2).equals(a)&& a2.substring(i,i+2).equals(b))t1++;
      else if(a2.substring(i,i+2).equals(a)&& a1.substring(i,i+2).equals(b))t2++;
      else if(a1.substring(i,i+2).equals(b)&& a2.substring(i,i+2).equals(c))t1+=1 ;
      else if(a2.substring(i,i+2).equals(b)&& a1.substring(i,i+2).equals(c))t2+=1 ;
      else if(a1.substring(i,i+2).equals(c)&& a2.substring(i,i+2).equals(a))t1+=1 ;
      else if(a2.substring(i,i+2).equals(c)&& a1.substring(i,i+2).equals(a))t2+=1 ;
    }
    if(t1>t2)System.out.println("TEAM 1 WINS");
    else if(t2>t1)System.out.println("TEAM 2 WINS");
    else System.out.println("TIE");
  }
}
------------------------------------------------------------
OCL File:
---------
 class AprilFool {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t1 : int ; t1 := 0 ;
    var t2 : int ; t2 := 0 ;
    var a1 : String ; a1 := sc.getCurrent() ;
    var a2 : String ; a2 := sc.getCurrent() ;
    var a : String ; a := "8<" ;
    var b : String ; b := "[] " ;
    var c : String ; c := "()" ;
        var i : int ; i := 0 ; while i < a1->size() do ( (     if (a1.subrange(i+1,i + 2) = a & a2.subrange(i+1,i + 2) = b) then     t1 := t1 + 1 ; else     if (a2.subrange(i+1,i + 2) = a & a1.subrange(i+1,i + 2) = b) then     t2 := t2 + 1 else     if (a1.subrange(i+1,i + 2) = b & a2.subrange(i+1,i + 2) = c) then     t1 := t1+(1) else     if (a2.subrange(i+1,i + 2) = b & a1.subrange(i+1,i + 2) = c) then     t2 := t2+(1) else     if (a1.subrange(i+1,i + 2) = c & a2.subrange(i+1,i + 2) = a) then     t1 := t1+(1) else     if (a2.subrange(i+1,i + 2) = c & a1.subrange(i+1,i + 2) = a) then     t2 := t2+(1) ; else skip ; ;  ;  ;  ;  )  ;     i := i+(2) ) ; 
    if (t1 > t2) then     OclFile["System.out"].println("TEAM 1 WINS") else     if (t2 > t1) then     OclFile["System.out"].println("TEAM 2 WINS") else     OclFile["System.out"].println("TIE") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class AprilFoolsDayPrank_A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String a=in.next(),b=in.next();
    String A[]=new String[a.length()/2];
    String B[]=new String[b.length()/2];
    int k=0 ;
    Arrays.fill(A,"");
    Arrays.fill(B,"");
    for(int i=0 ; i<a.length(); i++){
      A[k]+=a.charAt(i);
      B[k]+=b.charAt(i);
      if(i % 2!=0)k++;
    }
    int As=0,Bs=0 ;
    for(int i=0 ; i<A.length ; i++){
      if(A[i] .equals(B[i]))continue ;
      else {
        if(A[i] .equals("()")){
          if(B[i] .equals("[] "))Bs++;
          else if(B[i] .equals("8<"))As++;
        }
        else if(A[i] .equals("[] ")){
          if(B[i] .equals("()"))As++;
          else if(B[i] .equals("8<"))Bs++;
        }
        else if(A[i] .equals("8<")){
          if(B[i] .equals("[] "))As++;
          else if(B[i] .equals("()"))Bs++;
        }
      }
    }
    if(As>Bs)System.out.println("TEAM 1 WINS");
    else if(Bs==As)System.out.println("TIE");
    else System.out.println("TEAM 2 WINS");
  }
}
------------------------------------------------------------
OCL File:
---------
 class AprilFoolsDayPrank_A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := in.getCurrent() ;
    var b : String ; b := in.getCurrent() ;
    var A : Sequence(String) ; A := Integer.subrange(1,a->size() / 2)->collect(null) ;
    var B : Sequence(String) ; B := Integer.subrange(1,b->size() / 2)->collect(null) ;
    var k : int ; k := 0 ;
    A := A->collect("") ; 
    B := B->collect("") ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     A[k+1] := A[k+1]+(a->at(i+1)) ; 
     B[k+1] := B[k+1]+(b->at(i+1)) ; 
     if (i mod 2 /= 0) then     k := k + 1 ; else skip )  ;     i := i + 1 ) ; 
    var As : int ; As := 0 ;
    var Bs : int ; Bs := 0 ;
        var i : int ; i := 0 ; while i < A->size() do ( (     if (A[i+1] = B[i+1]) then     continue else (     if (A[i+1] = "()") then (     if (B[i+1] = "[] ") then     Bs := Bs + 1 ; else     if (B[i+1] = "8<") then     As := As + 1 ; else skip ; ) else     if (A[i+1] = "[] ") then (     if (B[i+1] = "()") then     As := As + 1 ; else     if (B[i+1] = "8<") then     Bs := Bs + 1 ; else skip ; ) else     if (A[i+1] = "8<") then (     if (B[i+1] = "[] ") then     As := As + 1 ; else     if (B[i+1] = "()") then     Bs := Bs + 1 ; else skip ; ) else skip ; ;  ) )  ;     i := i + 1 ) ; 
    if (As > Bs) then     OclFile["System.out"].println("TEAM 1 WINS") else     if (Bs = As) then     OclFile["System.out"].println("TIE") else     OclFile["System.out"].println("TEAM 2 WINS") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileInputStream ;
import java.util.Scanner ;
public class Project_01 {
  public static void main(String[] args){
    try {
      Scanner sc=new Scanner(System.in);
      String s1=sc.next();
      String s2=sc.next();
      int t=s1.length()/2 ;
      char a ;
      char b ;
      int an=0 ;
      int bn=0 ;
      int index=0 ;
      for(int i=0 ; i<t ; i++){
        a=s1.charAt(index);
        b=s2.charAt(index);
        if((a=='[' && b=='[')||(a=='(' && b=='(')||(a=='8' && b=='8')){
          index+=2 ;
          continue ;
        }
        if((a=='[' && b=='8')||(a=='(' && b=='[')||(a=='8' && b=='(')){
          bn++;
        }
        else if((a=='8' && b=='[')||(a=='[' && b=='(')||(a=='(' && b=='8')){
          an++;
        }
        index+=2 ;
      }
      if(an==bn){
        System.out.println("TIE");
      }
      else if(an>bn){
        System.out.println("TEAM 1 WINS");
      }
      else {
        System.out.println("TEAM 2 WINS");
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Project_01 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := sc.getCurrent() ;
    var s2 : String ; s2 := sc.getCurrent() ;
    var t : int ; t := s1->size() / 2 ;
    var a : String ;
    var b : String ;
    var an : int ; an := 0 ;
    var bn : int ; bn := 0 ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < t do ( (     a := s1->at(index+1) ; 
     b := s2->at(index+1) ; 
    if ((a = '[' & b = '[') or (a = '(' & b = '(') or (a = '8' & b = '8')) then (     index := index+(2) ; 
     continue ) else skip ; 
    if ((a = '[' & b = '8') or (a = '(' & b = '[') or (a = '8' & b = '(')) then (     bn := bn + 1 ) else     if ((a = '8' & b = '[') or (a = '[' & b = '(') or (a = '(' & b = '8')) then (     an := an + 1 ) else skip ; ;  
    index := index+(2) ; 
 )  ;     i := i + 1 ) ; 
    if (an = bn) then (     OclFile["System.out"].println("TIE") ) else     if (an > bn) then (     OclFile["System.out"].println("TEAM 1 WINS") ) else (     OclFile["System.out"].println("TEAM 2 WINS") ) ;  ;  
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,Scanner sc,PrintWriter out){
      char[] s1=sc.next().toCharArray();
      char[] s2=sc.next().toCharArray();
      int res=0 ;
      for(int i=0 ; i<s1.length ; i+=2)if(s1[i]=='['){
        if(s2[i]=='8')res++;
        else if(s2[i]=='(')res--;
      }
      else if(s1[i]=='8'){
        if(s2[i]=='(')res++;
        else if(s2[i]=='[')res--;
      }
      else {
        if(s2[i]=='[')res++;
        else if(s2[i]=='8')res--;
      }
      out.println(res<0 ? "TEAM 1 WINS" : res>0 ? "TEAM 2 WINS" : "TIE");
    }
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(FileReader f){
      br=new BufferedReader(f);
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
      }
      return st.nextToken();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, sc : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s1 : Sequence(String) ; s1 := sc.next()->characters() ;
     var s2 : Sequence(String) ; s2 := sc.next()->characters() ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < s1->size() do (     if (s1[i+1] = '[') then (     if (s2[i+1] = '8') then     res := res + 1 ; else     if (s2[i+1] = '(') then     res := res - 1 ; else skip ; ) else     if (s1[i+1] = '8') then (     if (s2[i+1] = '(') then     res := res + 1 ; else     if (s2[i+1] = '[') then     res := res - 1 ; else skip ; ) else (     if (s2[i+1] = '[') then     res := res + 1 ; else     if (s2[i+1] = '8') then     res := res - 1 ; else skip ; ) ;  ;   ;     i := i+(2) ) ; 
    skip ; 
 );
}
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( f : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(f) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do skip
 ; 
     return st.next() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class AA {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s1=sc.nextLine();
    String s2=sc.nextLine();
    int n=s1.length();
    int wa=0 ;
    int wb=0 ;
    for(int i=0 ; i<n ; i+=2){
      char a=s1.charAt(i);
      char b=s2.charAt(i);
      if(a==b){
        continue ;
      }
      switch(a){
        case '[' : if(b=='(')wa++;
        else wb++;
        break ;
        case '(' : if(b=='[')wb++;
        else wa++;
        break ;
        case '8' : if(b=='(')wb++;
        else wa++;
        break ;
        default : break ;
      }
    }
    if(wa>wb)System.out.println("TEAM 1 WINS");
    else if(wa<wb)System.out.println("TEAM 2 WINS");
    else System.out.println("TIE");
  }
}
------------------------------------------------------------
OCL File:
---------
 class AA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := sc.nextLine() ;
    var s2 : String ; s2 := sc.nextLine() ;
    var n : int ; n := s1->size() ;
    var wa : int ; wa := 0 ;
    var wb : int ; wb := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : String ; a := s1->at(i+1) ;
     var b : String ; b := s2->at(i+1) ;
     if (a = b) then (     continue ) else skip ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (a) ; 
       if _switchval = '[' then
     if (b = '(') then     wa := wa + 1 else     wb := wb + 1 ; ;  
    break 
   else skip ;
       if _switchval = '(' then
     if (b = '[') then     wb := wb + 1 else     wa := wa + 1 ; ;  
    break 
   else skip ;
       if _switchval = '8' then
     if (b = '(') then     wb := wb + 1 else     wa := wa + 1 ; ;  
    break 
   else skip ;
       if true then
     break 
   else skip ;
 )
 )  ;     i := i+(2) ) ; 
    if (wa > wb) then     OclFile["System.out"].println("TEAM 1 WINS") else     if (wa < wb) then     OclFile["System.out"].println("TEAM 2 WINS") else     OclFile["System.out"].println("TIE") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxElement(int a[],int n){
    if(n<3)return-1 ;
    int maxElement=a[0];
    int maxProd=a[n-1]*a[1];
    for(int i=1 ; i<n ; i++){
      int currProd=a[i-1]*a[(i+1)% n];
      if(currProd>maxProd){
        maxProd=currProd ;
        maxElement=a[i];
      }
      else if(currProd==maxProd){
        maxElement=Math.max(maxElement,a[i]);
      }
    }
    return maxElement ;
  }
  public static void main(String[] args){
    int[] a={
      5,6,4,3,2 };
      int n=a.length ;
      System.out.println(maxElement(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxElement( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n < 3) then     return -1 else skip ; 
     var maxElement : int ; maxElement := a[0+1] ;
    var maxProd : int ; maxProd := a[n - 1+1] * a[1+1] ;
        var i : int ; i := 1 ; while i < n do ( (     var currProd : int ; currProd := a[i - 1+1] * a[(i + 1) mod n+1] ;
     if (currProd > maxProd) then (     maxProd := currProd ; 
     maxElement := a[i+1] ) else     if (currProd = maxProd) then (     maxElement := Set{maxElement, a[i+1]}->max() ) else skip ; )  ;     i := i + 1 ) ; 
    return maxElement 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{5,6,4,3,2} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(maxElement(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  static FastScanner in=new FastScanner();
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    int n=in.nextInt();
    int count=0 ;
    while(n!=0){
      count+=n % 2 ;
      n/=2 ;
    }
    out.println(count);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   attribute in : FastScanner := FastScanner.newFastScanner();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var count : int ; count := 0 ;
    while (n /= 0) do (     count := count+(n mod 2) ; 
     n := n/(2) ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    ArrayList<ArrayDeque<Integer>>lanes=new ArrayList<>();
    for(int i=0 ; i<=n ; i++){
      lanes.add(new ArrayDeque<>());
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<m ; i++){
      int x=sc.nextInt();
      if(x==0){
        int idx=sc.nextInt();
        sb.append(lanes.get(idx).poll()).append("\n");
      }
      else {
        int car=sc.nextInt();
        int min=Integer.MAX_VALUE ;
        int minIdx=0 ;
        for(int j=1 ; j<=n ; j++){
          if(min>lanes.get(j).size()){
            min=lanes.get(j).size();
            minIdx=j ;
            if(min==0){
              break ;
            }
          }
        }
        lanes.get(minIdx).add(car);
      }
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var lanes : Sequence(Sequence(int)) ; lanes := Sequence{} ;
        var i : int ; i := 0 ; while i <= n do ( (     lanes := lanes->including(ArrayDeque<OclAny>.newArrayDeque()) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x = 0) then (     var idx : int ; idx := sc.getCurrent()->toInteger() ;
     sb := sb + StringLib.newString(lanes->at(idx+1)->min()) + StringLib.newString("\n") ) else (     var car : int ; car := sc.getCurrent()->toInteger() ;
     var min : int ; min := 2147483647 ;
    var minIdx : int ; minIdx := 0 ;
        var j : int ; j := 1 ; while j <= n do ( (     if (min > lanes->at(j+1)->size()) then (     min := lanes->at(j+1)->size() ; 
     minIdx := j ; 
     if (min = 0) then (     break ) else skip ) else skip )  ;     j := j + 1 ) ; 
    lanes->at(minIdx+1)->excludes(car) ; 
 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class pizzaseparate {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    StringTokenizer st=new StringTokenizer(f.readLine());
    int n=Integer.parseInt((st.nextToken()));
    int ans=360 ;
    int[] slices=new int[360];
    st=new StringTokenizer(f.readLine());
    int total=360 ;
    for(int i=0 ; i<n ; i++){
      slices[i]=Integer.parseInt((st.nextToken()));
    }
    for(int i=0 ; i<n ; i++){
      int currentDiff=0 ;
      for(int j=i ; j<n ; j++){
        currentDiff+=slices[j];
        ans=Math.min(ans,Math.abs((total-currentDiff)-currentDiff));
      }
    }
    out.println(ans);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class pizzaseparate {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
    var n : int ; n := ((st.next()))->toInteger() ;
    var ans : int ; ans := 360 ;
    var slices : Sequence(int) ; slices := Integer.subrange(1,360)->collect(0) ;
    st := OclIterator.newOclIterator_String(f.readLine()) ; 
    var total : int ; total := 360 ;
        var i : int ; i := 0 ; while i < n do ( (     slices[i+1] := ((st.next()))->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var currentDiff : int ; currentDiff := 0 ;
         var j : int ; j := i ; while j < n do ( (     currentDiff := currentDiff+(slices[j+1]) ; 
     ans := Set{ans, if (total - currentDiff) - currentDiff < 0 then -((total - currentDiff) - currentDiff) else (total - currentDiff) - currentDiff endif}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A895 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int[] A=new int[N];
    for(int n=0 ; n<N ; n++){
      A[n]=in.nextInt();
    }
    int min=360 ;
    for(int start=0 ; start<N ; start++){
      int end=start ;
      int sum=0 ;
      while(end<N){
        sum+=A[end++];
        min=Math.min(min,Math.abs(360-2*sum));
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A895 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var min : int ; min := 360 ;
        var start : int ; start := 0 ; while start < N do ( (     var end : int ; end := start ;
     var sum : int ; sum := 0 ;
     while (end < N) do (      sum := sum + A[end+1]  ; end := end + 1 ; 
     min := Set{min, if 360 - 2 * sum < 0 then -(360 - 2 * sum) else 360 - 2 * sum endif}->min() ) )  ;     start := start + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int a=scanner.nextInt();
    int b=scanner.nextInt();
    String answer="" ;
    if(a>b){
      answer=createString(a,b);
    }
    else {
      answer=createString(b,a);
    }
    System.out.println(answer);
  }
  private static String createString(int a,int b){
    StringBuilder builder=new StringBuilder();
    for(int i=0 ; i<a ; i++){
      builder.append(b);
    }
    return builder.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var answer : String ; answer := "" ;
    if (a > b) then (     answer := createString(a, b) ) else (     answer := createString(b, a) ) ;  
    OclFile["System.out"].println(answer) ; 
 );
  static   operation createString( a : int, b : int) : String
  pre: true
  post: true
  activity: (     var builder : String ; builder := StringLib.newString() ;
         var i : int ; i := 0 ; while i < a do ( (     builder := builder + StringLib.newString(b) )  ;     i := i + 1 ) ; 
     return builder+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      System.out.println(arr[0]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(arr[0+1]) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader reader=new BufferedReader(is);
    List<String>mylist=new ArrayList<>();
    String strinput=reader.readLine();
    while(strinput!=null){
      mylist.add(strinput);
      strinput=reader.readLine();
    }
    String arr01[]=mylist.get(0).split(" ");
    int a=Integer.valueOf(arr01[0]);
    int b=Integer.valueOf(arr01[1]);
    StringBuffer sb=new StringBuffer();
    if(a==b){
      for(int i=1 ; i<=a ; i++){
        sb.append(String.valueOf(a));
      }
    }
    else if(a>b){
      for(int i=1 ; i<=a ; i++){
        sb.append(String.valueOf(b));
      }
    }
    else if(a<b){
      for(int i=1 ; i<=b ; i++){
        sb.append(String.valueOf(a));
      }
    }
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(is) ;
    var mylist : Sequence(String) ; mylist := Sequence{} ;
    var strinput : String ; strinput := reader.readLine() ;
    while (strinput /= null) do (     mylist := mylist->including(strinput) ; 
     strinput := reader.readLine() ) ; 
    var arr01 : Sequence(String) ; arr01 := mylist->at(0+1)->split(" ") ;
    var a : int ; a := (arr01[0+1])->toInteger() ;
    var b : int ; b := (arr01[1+1])->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
    if (a = b) then (         var i : int ; i := 1 ; while i <= a do ( (     sb := sb + StringLib.newString(((a) + "")) )  ;     i := i + 1 ) ) else     if (a > b) then (         var i : int ; i := 1 ; while i <= a do ( (     sb := sb + StringLib.newString(((b) + "")) )  ;     i := i + 1 ) ) else     if (a < b) then (         var i : int ; i := 1 ; while i <= b do ( (     sb := sb + StringLib.newString(((a) + "")) )  ;     i := i + 1 ) ) else skip ; ;  ;  
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.Collectors ;
import java.io.*;
import java.nio.charset.StandardCharsets ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader reader=new InputStreamReader(System.in,StandardCharsets.UTF_8);
    BufferedReader in=new BufferedReader(reader);
    Main ins=new Main(in);
    ins.calc();
    ins.showResult();
  }
  Main(BufferedReader in)throws IOException {
    String[] tokens=in.readLine().split(" ");
    int a=Integer.parseInt(tokens[0]);
    int b=Integer.parseInt(tokens[1]);
    StringBuilder strBuilder=new StringBuilder();
    for(int i=0 ; i<b ; ++i){
      strBuilder.append(a);
    }
    String strA=strBuilder.toString();
    strBuilder=new StringBuilder();
    for(int i=0 ; i<a ; ++i){
      strBuilder.append(b);
    }
    String strB=strBuilder.toString();
    if(strA.compareTo(strB)<=0){
      System.out.println(strA);
    }
    else {
      System.out.println(strB);
    }
  }
  void calc(){
  }
  void showResult(){
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"], StandardCharsets.UTF_8) ;
     var in : OclFile ; in := OclFile.newOclFile_Read(reader) ;
    var ins : Main ; ins := Main.newMain(in) ;
    ins.calc() ; 
    ins.showResult() ; 
 );
   static operation newMain( in : OclFile) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     var tokens : Sequence(String) ; tokens := in.readLine()->split(" ") ;
     var a : int ; a := (tokens[0+1])->toInteger() ;
    var b : int ; b := (tokens[1+1])->toInteger() ;
    var strBuilder : String ; strBuilder := StringLib.newString() ;
        var i : int ; i := 0 ; while i < b do ( (     strBuilder := strBuilder + StringLib.newString(a) )  ;     i := i + 1 ) ; 
    var strA : String ; strA := strBuilder+"" ;
    strBuilder := StringLib.newString() ; 
        var i : int ; i := 0 ; while i < a do ( (     strBuilder := strBuilder + StringLib.newString(b) )  ;     i := i + 1 ) ; 
    var strB : String ; strB := strBuilder+"" ;
    if (strA->compareTo(strB) <= 0) then (     OclFile["System.out"].println(strA) ) else (     OclFile["System.out"].println(strB) ) ;  
 );
   operation calc() : void
  pre: true
  post: true
  activity: skip;
   operation showResult() : void
  pre: true
  post: true
  activity: skip;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(new BufferedInputStream(System.in));
    int a=sc.nextInt();
    int b=sc.nextInt();
    int max=(a>b)? a : b ;
    int min=(a<b)? a : b ;
    for(int i=0 ; i<max ; i++)System.out.print(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var max : int ; max := if (a > b) then a else b endif ;
    var min : int ; min := if (a < b) then a else b endif ;
        var i : int ; i := 0 ; while i < max do (     OclFile["System.out"].print(min) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static int n,k ;
  static String line ;
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    Integer a=s.nextInt();
    Integer b=s.nextInt();
    String ret1="" ;
    for(int i=0 ; i<a ; i++){
      ret1+=b.toString();
    }
    String ret2="" ;
    for(int i=0 ; i<b ; i++){
      ret2+=a.toString();
    }
    if(ret1.compareTo(ret2)<0){
      System.out.println(ret1);
    }
    else {
      System.out.println(ret2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute line : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := s.getCurrent()->toInteger() ;
    var b : int ; b := s.getCurrent()->toInteger() ;
    var ret1 : String ; ret1 := "" ;
        var i : int ; i := 0 ; while i < a do ( (     ret1 := ret1+(b+"") )  ;     i := i + 1 ) ; 
    var ret2 : String ; ret2 := "" ;
        var i : int ; i := 0 ; while i < b do ( (     ret2 := ret2+(a+"") )  ;     i := i + 1 ) ; 
    if (ret1->compareTo(ret2) < 0) then (     OclFile["System.out"].println(ret1) ) else (     OclFile["System.out"].println(ret2) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Simstrings {
  static final int MAX_CHAR=26 ;
  static void printCommon(String s1,String s2){
    int[] a1=new int[MAX_CHAR];
    int[] a2=new int[MAX_CHAR];
    int length1=s1.length();
    int length2=s2.length();
    for(int i=0 ; i<length1 ; i++)a1[s1.charAt(i)-'a']+=1 ;
    for(int i=0 ; i<length2 ; i++)a2[s2.charAt(i)-'a']+=1 ;
    for(int i=0 ; i<MAX_CHAR ; i++){
      if(a1[i]!=0 && a2[i]!=0){
        for(int j=0 ; j<Math.min(a1[i],a2[i]); j++)System.out.print(((char)(i+'a')));
      }
    }
  }
  public static void main(String[] args)throws IOException {
    String s1="geeksforgeeks",s2="practiceforgeeks" ;
    printCommon(s1,s2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Simstrings {
  static    attribute MAX_CHAR : int := 26;
  static   operation printCommon( s1 : String, s2 : String) : void
  pre: true
  post: true
  activity: (     var a1 : Sequence(int) ; a1 := Integer.subrange(1,MAX_CHAR)->collect(0) ;
     var a2 : Sequence(int) ; a2 := Integer.subrange(1,MAX_CHAR)->collect(0) ;
    var length1 : int ; length1 := s1->size() ;
    var length2 : int ; length2 := s2->size() ;
        var i : int ; i := 0 ; while i < length1 do (     a1[s1->at(i+1) - ('a')->char2byte()+1] := a1[s1->at(i+1) - ('a')->char2byte()+1]+(1) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < length2 do (     a2[s2->at(i+1) - ('a')->char2byte()+1] := a2[s2->at(i+1) - ('a')->char2byte()+1]+(1) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < MAX_CHAR do ( (     if (a1[i+1] /= 0 & a2[i+1] /= 0) then (         var j : int ; j := 0 ; while j < Set{a1[i+1], a2[i+1]}->min() do (     OclFile["System.out"].print(((i + 'a')->oclAsType(String))) ;  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "geeksforgeeks" ;
    var s2 : String ; s2 := "practiceforgeeks" ;
     execute printCommon(s1, s2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF579_D2_A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int num=scanner.nextInt();
    int ans=1 ;
    while(num!=1){
      if(num % 2==1){
        ans+=1 ;
        num/=2 ;
      }
      else {
        num/=2 ;
      }
    }
    System.out.println(ans);
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF579_D2_A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := scanner.getCurrent()->toInteger() ;
    var ans : int ; ans := 1 ;
    while (num /= 1) do (     if (num mod 2 = 1) then (     ans := ans+(1) ; 
     num := num/(2) ) else (     num := num/(2) ) ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    System.out.println(getString(n));
  }
  public static String getString(int n){
    if(n==0){
      return "a" ;
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<26 && n>0 ; i++){
      int cur=1 ;
      int sum=0 ;
      while(sum+cur<=n){
        sum+=cur++;
      }
      n-=sum ;
      char c=(char)('a'+i);
      for(int j=0 ; j<cur ; j++){
        sb.append(c);
      }
    }
    return sb.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
     OclFile["System.out"].println(getString(n)) );
  static   operation getString( n : int) : String
  pre: true
  post: true
  activity: (     if (n = 0) then (     return "a" ) else skip ; 
     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < 26 & n > 0 do ( (     var cur : int ; cur := 1 ;
     var sum : int ; sum := 0 ;
    while (sum + cur <= n) do (      sum := sum + cur  ; cur := cur + 1 ) ; 
    n := n-(sum) ; 
    var c : String ; c := ('a' + i)->oclAsType(String) ;
        var j : int ; j := 0 ; while j < cur do ( (     sb := sb + StringLib.newString(c) )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
     return sb+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    System.out.println(getString(n));
  }
  public static String getString(int n){
    if(n==0){
      return "a" ;
    }
    StringBuilder sb=new StringBuilder();
    int need=n ;
    int cur ;
    int sum ;
    int idx=0 ;
    int count ;
    while(need>0){
      cur=1 ;
      sum=0 ;
      count=0 ;
      while(sum+cur<=need){
        sum+=cur++;
        count++;
      }
      char c=(char)('a'+idx);
      for(int i=0 ; i<=count ; i++){
        sb.append(c);
      }
      idx++;
      need-=sum ;
    }
    return sb.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
     OclFile["System.out"].println(getString(n)) );
  static   operation getString( n : int) : String
  pre: true
  post: true
  activity: (     if (n = 0) then (     return "a" ) else skip ; 
     var sb : String ; sb := StringLib.newString() ;
    var need : int ; need := n ;
    var cur : int ;
    var sum : int ;
    var idx : int ; idx := 0 ;
    var count : int ;
    while (need > 0) do (     cur := 1 ; 
     sum := 0 ; 
    count := 0 ; 
    while (sum + cur <= need) do (      sum := sum + cur  ; cur := cur + 1 ; 
     count := count + 1 ) ; 
    var c : String ; c := ('a' + idx)->oclAsType(String) ;
        var i : int ; i := 0 ; while i <= count do ( (     sb := sb + StringLib.newString(c) )  ;     i := i + 1 ) ; 
    idx := idx + 1 ; 
    need := need-(sum) ; 
 ) ; 
    return sb+"" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class A {
  public static void main(String hi[])throws Exception {
    BufferedReader infile=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(infile.readLine());
    int K=Integer.parseInt(st.nextToken());
    if(K==0){
      System.out.println("a");
      return ;
    }
    StringBuilder sb=new StringBuilder();
    for(int c=0 ; c<26 ; c++){
      if(K==0)break ;
      int low=1 ;
      int high=446 ;
      while(low!=high){
        int mid=(low+high+1)/2 ;
        if(mid*(mid+1)/2>K)high=mid-1 ;
        else low=mid ;
      }
      K-=low*(low+1)/2 ;
      while(low-->-1)sb.append((char)('a'+c));
    }
    if(K>0){
      int lol=4/0 ;
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( hi : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var infile : OclFile ; infile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(infile.readLine()) ;
    var K : int ; K := (st.next())->toInteger() ;
    if (K = 0) then (     OclFile["System.out"].println("a") ; 
     return ) else skip ; 
    var sb : String ; sb := StringLib.newString() ;
        var c : int ; c := 0 ; while c < 26 do ( (     if (K = 0) then     break else skip ; 
     var low : int ; low := 1 ;
    var high : int ; high := 446 ;
    while (low /= high) do (     var mid : int ; mid := (low + high + 1) / 2 ;
     if (mid * (mid + 1) / 2 > K) then     high := mid - 1 ; else     low := mid ; ) ; 
    K := K-(low * (low + 1) / 2) ; 
        while (low > -1) do (        low := low - 1 ;  ;     sb := sb + StringLib.newString(('a' + c)->oclAsType(String)) ; ;  ) ;  
 )  ;     c := c + 1 ) ; 
    if (K > 0) then (     var lol : int ; lol := 4 / 0 ) else skip ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long mod=(long)(1e9+7);
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    ArrayList<Integer>list=new ArrayList<>();
    HashSet<Integer>set=new HashSet<>();
    for(int i=0 ; i<2*n ; i++){
      int v=in.nextInt();
      list.add(v);
      set.add(v);
    }
    if(set.size()==1){
      pw.println(-1);
    }
    else {
      Collections.sort(list);
      for(int i : list){
        pw.print(i+" ");
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := (1e9 + 7)->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     var v : int ; v := in.getCurrent()->toInteger() ;
     list := list->including(v) ; 
     set := set->including(v) )  ;     i := i + 1 ) ; 
    if (set->size() = 1) then (     skip ) else (     list := list->sort() ; 
     for (i : list) do ( (     skip )  ) ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class MainClass {
  public static void main(String[] agrs){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt()*2 ;
    int[] lst=new int[n];
    for(int i=0 ; i<n ; i++)lst[i]=sc.nextInt();
    Arrays.sort(lst);
    if(lst[0]!=lst[n-1]){
      for(int i=0 ; i<n ; i++){
        System.out.print(lst[i]+" ");
      }
    }
    else System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() * 2 ;
    var lst : Sequence(int) ; lst := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     lst[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    lst := lst->sort() ; 
    if (lst[0+1] /= lst[n - 1+1]) then (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(lst[i+1] + " ") )  ;     i := i + 1 ) ) else     OclFile["System.out"].println(-1) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Solution {
  static PrintWriter pw ;
  static FastScanner s ;
  public static void main(String[] args)throws Exception {
    pw=new PrintWriter(System.out);
    s=new FastScanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=s.nextInt();
      pw.println(a[0]);
    }
    pw.flush();
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public FastScanner(String s)throws Exception {
    br=new BufferedReader(new FileReader(new File(s)));
  }
  public String next()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(next());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute pw : OclFile;
  static   attribute s : FastScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     pw := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     s := FastScanner.newFastScanner(OclFile["System.in"]) ; 
    var t : int ; t := s.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := s.nextInt() ;  ;     i := i + 1 ) ; 
     skip ) ;  ) ;  
    skip ; 
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=2*n ;
    long a[]=new long[m];
    for(int i=0 ; i<m ; i++)a[i]=sc.nextLong();
    Arrays.sort(a);
    if(a[0]==a[m-1])System.out.print(-1);
    else {
      for(int i=0 ; i<m ; i++){
        System.out.print(a[i]+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := 2 * n ;
    var a : Sequence(long) ; a := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     a[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    if (a[0+1] = a[m - 1+1]) then     OclFile["System.out"].print(-1) else (         var i : int ; i := 0 ; while i < m do ( (     OclFile["System.out"].print(a[i+1] + " ") )  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void MinimumMaximumPairs(int n,int m){
    int max_pairs=((n-m+1)*(n-m))/2 ;
    int min_pairs=m*(((n-m)/m+1)*((n-m)/m))/2+(int)Math.ceil((double)((n-m)/(double)(m)))*((n-m)% m);
    System.out.println("Minimum no.of pairs="+min_pairs);
    System.out.println("Maximum no.of pairs="+max_pairs);
  }
  public static void main(String[] args){
    int n=5,m=2 ;
    MinimumMaximumPairs(n,m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MinimumMaximumPairs( n : int, m : int) : void
  pre: true
  post: true
  activity: (     var max_pairs : int ; max_pairs := ((n - m + 1) * (n - m)) / 2 ;
     var min_pairs : int ; min_pairs := m * (((n - m) / m + 1) * ((n - m) / m)) / 2 + (((n - m) / (m)->oclAsType(double))->oclAsType(double))->ceil()->oclAsType(int) * ((n - m) mod m) ;
     OclFile["System.out"].println("Minimum no.of pairs=" + min_pairs) ; 
     OclFile["System.out"].println("Maximum no.of pairs=" + max_pairs) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var m : int ; m := 2 ;
     execute MinimumMaximumPairs(n, m) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int LengthlongestPrefixSuffix(String s){
    int n=s.length();
    int lps[]=new int[n];
    lps[0]=0 ;
    int len=0 ;
    int i=1 ;
    while(i<n){
      if(s.charAt(i)==s.charAt(len)){
        len++;
        lps[i]=len ;
        i++;
      }
      else {
        if(len!=0){
          len=lps[len-1];
        }
        else {
          lps[i]=0 ;
          i++;
        }
      }
    }
    int res=lps[n-1];
    return(res>n/2)? n/2 : res ;
  }
  static String longestPrefixSuffix(String s){
    int len=LengthlongestPrefixSuffix(s);
    String prefix="" ;
    for(int i=0 ; i<len ; i++)prefix+=s.charAt(i);
    return prefix ;
  }
  public static void main(String[] args){
    String s="abcab" ;
    String ans=longestPrefixSuffix(s);
    if(ans=="")System.out.println("-1");
    else System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation LengthlongestPrefixSuffix( s : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var lps : Sequence(int) ; lps := Integer.subrange(1,n)->collect(0) ;
    lps[0+1] := 0 ; 
    var len : int ; len := 0 ;
    var i : int ; i := 1 ;
    while (i < n) do (     if (s->at(i+1) = s->at(len+1)) then (     len := len + 1 ; 
     lps[i+1] := len ; 
     i := i + 1 ) else (     if (len /= 0) then (     len := lps[len - 1+1] ) else (     lps[i+1] := 0 ; 
     i := i + 1 ) ) ) ; 
    var res : int ; res := lps[n - 1+1] ;
    return if (res > n / 2) then n / 2 else res endif 
 );
  static   operation longestPrefixSuffix( s : String) : String
  pre: true
  post: true
  activity: (     var len : int ; len := LengthlongestPrefixSuffix(s) ;
     var prefix : String ; prefix := "" ;
         var i : int ; i := 0 ; while i < len do (     prefix := prefix+(s->at(i+1)) ;  ;     i := i + 1 ) ; 
     return prefix );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abcab" ;
     var ans : String ; ans := longestPrefixSuffix(s) ;
     if (ans = "") then     OclFile["System.out"].println("-1") ; else     OclFile["System.out"].println(ans) ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p139 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p139().run());
  }
  private static final int LIMIT=100000000 ;
  public String run(){
    int count=0 ;
    for(int s=3 ; s*s/2<LIMIT ; s+=2){
      for(int t=1 ; t<s ; t+=2){
        int a=s*t ;
        int b=(s*s-t*t)/2 ;
        int c=(s*s+t*t)/2 ;
        int p=a+b+c ;
        if(p>=LIMIT)break ;
        if(c %(a-b)==0 && Library.gcd(s,t)==1)count+=(LIMIT-1)/p ;
      }
    }
    return Integer.toString(count);
  }
}
------------------------------------------------------------
OCL File:
---------
class p139 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p139.newp139().run()) );
  static    attribute LIMIT : int := 100000000;
   operation run() : String
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var s : int ; s := 3 ; while s * s / 2 < LIMIT do ( (         var t : int ; t := 1 ; while t < s do ( (     var a : int ; a := s * t ;
     var b : int ; b := (s * s - t * t) / 2 ;
    var c : int ; c := (s * s + t * t) / 2 ;
    var p : int ; p := a + b + c ;
    if (p >= LIMIT) then     break else skip ; 
    if (c mod (a - b) = 0 & Library.gcd(s, t) = 1) then     count := count+((LIMIT - 1) / p) ; else skip ; 
 )  ;     t := t+(2) ) )  ;     s := s+(2) ) ; 
     return ((count) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cp {
  public static void main(String[] args){
    Scanner userinput=new Scanner(System.in);
    long bac=userinput.nextLong();
    int count=0 ;
    while(bac>0){
      if(bac % 2==1){
        count++;
      }
      bac=bac/2 ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var userinput : OclFile ; userinput := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var bac : long ; bac := userinput.getCurrent()->toLong() ;
    var count : int ; count := 0 ;
    while (bac > 0) do (     if (bac mod 2 = 1) then (     count := count + 1 ) else skip ; 
     bac := bac / 2 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int Log2n(int n){
    return(n>1)? 1+Log2n(n/2): 0 ;
  }
  static boolean isPowerOfd(int n,int d){
    int count=0 ;
    if(n>0 &&(n &(n-1))==0){
      while(n>1){
        n>>=1 ;
        count+=1 ;
      }
      return(count %(Log2n(d))==0);
    }
    return false ;
  }
  public static void main(String[] args){
    int n=64,d=8 ;
    if(isPowerOfd(n,d))System.out.println(n+" is a power of "+d);
    else System.out.println(n+" is not a power of "+d);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Log2n( n : int) : int
  pre: true
  post: true
  activity: (     return if (n > 1) then 1 + Log2n(n / 2) else 0 endif );
  static   operation isPowerOfd( n : int, d : int) : boolean
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     if (n > 0 & (n & (n - 1)) = 0) then (     while (n > 1) do (     n := n/(2->pow(1)) ; 
     count := count+(1) ) ; 
     return (count mod (Log2n(d)) = 0) ) else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 64 ;
    var d : int ; d := 8 ;
     if (isPowerOfd(n, d)) then     OclFile["System.out"].println(n + " is a power of " + d) ; else     OclFile["System.out"].println(n + " is not a power of " + d) ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int frequencyDigits(int n,int d){
    int c=0 ;
    while(n>0){
      if(n % 10==d)c++;
      n=n/10 ;
    }
    return c ;
  }
  public static void main(String args[]){
    int N=1122322 ;
    int D=2 ;
    System.out.println(frequencyDigits(N,D));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation frequencyDigits( n : int, d : int) : int
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
     while (n > 0) do (     if (n mod 10 = d) then     c := c + 1 ; else skip ; 
     n := n / 10 ) ; 
     return c );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 1122322 ;
     var D : int ; D := 2 ;
     OclFile["System.out"].println(frequencyDigits(N, D)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    StringTokenizer st=new StringTokenizer(r.readLine());
    int n=Integer.parseInt(st.nextToken());
    int[] length=new int[n];
    int[] cost0=new int[n];
    int[] cost1=new int[n];
    int[] change=new int[n];
    String[] strings=new String[n];
    for(int i=0 ; i<n ; i++){
      st=new StringTokenizer(r.readLine());
      length[i]=Integer.parseInt(st.nextToken());
      cost0[i]=Integer.parseInt(st.nextToken());
      cost1[i]=Integer.parseInt(st.nextToken());
      change[i]=Integer.parseInt(st.nextToken());
      st=new StringTokenizer(r.readLine());
      strings[i]=st.nextToken();
      int num0=0 ;
      int num1=0 ;
      for(int j=0 ; j<length[i]; j++){
        if(strings[i] .charAt(j)=='0'){
          num0++;
        }
        if(strings[i] .charAt(j)=='1'){
          num1++;
        }
      }
      if(cost0[i]-cost1[i]>change[i]){
        pw.println((cost1[i]*length[i])+(change[i]*num0));
      }
      else if(cost1[i]-cost0[i]>change[i]){
        pw.println((cost0[i]*length[i])+(change[i]*num1));
      }
      else {
        pw.println((num1*cost1[i])+(num0*cost0[i]));
      }
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(r.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var length : Sequence(int) ; length := Integer.subrange(1,n)->collect(0) ;
    var cost0 : Sequence(int) ; cost0 := Integer.subrange(1,n)->collect(0) ;
    var cost1 : Sequence(int) ; cost1 := Integer.subrange(1,n)->collect(0) ;
    var change : Sequence(int) ; change := Integer.subrange(1,n)->collect(0) ;
    var strings : Sequence(String) ; strings := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     st := OclIterator.newOclIterator_String(r.readLine()) ; 
     length[i+1] := (st.next())->toInteger() ; 
    cost0[i+1] := (st.next())->toInteger() ; 
    cost1[i+1] := (st.next())->toInteger() ; 
    change[i+1] := (st.next())->toInteger() ; 
    st := OclIterator.newOclIterator_String(r.readLine()) ; 
    strings[i+1] := st.next() ; 
    var num0 : int ; num0 := 0 ;
    var num1 : int ; num1 := 0 ;
        var j : int ; j := 0 ; while j < length[i+1] do ( (     if (strings[i+1]->at(j+1) = '0') then (     num0 := num0 + 1 ) else skip ; 
     if (strings[i+1]->at(j+1) = '1') then (     num1 := num1 + 1 ) else skip )  ;     j := j + 1 ) ; 
    if (cost0[i+1] - cost1[i+1] > change[i+1]) then (     skip ) else     if (cost1[i+1] - cost0[i+1] > change[i+1]) then (     skip ) else (     skip ) ;  ;  
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class practice_791 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int c0=sc.nextInt();
      int c1=sc.nextInt();
      int h=sc.nextInt();
      String a=sc.next();
      int ones=0 ;
      int zero=0 ;
      for(int i=0 ; i<n ; i++){
        if(a.charAt(i)=='0'){
          zero++;
        }
        else {
          ones++;
        }
      }
      if(c0>(c1+h)){
        System.out.println((zero*(c1+h))+(ones*(c1)));
      }
      else if(c1>(c0+h)){
        System.out.println((zero*c0)+(ones*(c0+h)));
      }
      else {
        System.out.println((zero*c0)+(ones*c1));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice_791 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var c0 : int ; c0 := sc.getCurrent()->toInteger() ;
    var c1 : int ; c1 := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var a : String ; a := sc.getCurrent() ;
    var ones : int ; ones := 0 ;
    var zero : int ; zero := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a->at(i+1) = '0') then (     zero := zero + 1 ) else (     ones := ones + 1 ) )  ;     i := i + 1 ) ; 
    if (c0 > (c1 + h)) then (     OclFile["System.out"].println((zero * (c1 + h)) + (ones * (c1))) ) else     if (c1 > (c0 + h)) then (     OclFile["System.out"].println((zero * c0) + (ones * (c0 + h))) ) else (     OclFile["System.out"].println((zero * c0) + (ones * c1)) ) ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BuyTheString {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int l=s.nextInt();
    int n,c0,c1,h ;
    String b ;
    while(l>0){
      n=s.nextInt();
      c0=s.nextInt();
      c1=s.nextInt();
      h=s.nextInt();
      b=s.next();
      int count1=0,count0=0 ;
      boolean change=false ;
      int coins=0 ;
      for(int i=0 ; i<b.length(); i++){
        if(b.charAt(i)=='0'){
          count0++;
        }
        else {
          count1++;
        }
      }
      if(Math.abs(c0-c1)>h){
        change=true ;
      }
      if(change){
        if(c0<c1){
          coins=coins+(count1*h);
          coins=coins+(b.length()*c0);
        }
        else {
          coins=coins+(count0*h);
          coins=coins+(b.length()*c1);
        }
      }
      else {
        coins=coins+(count0*c0)+(count1*c1);
      }
      System.out.println(coins);
      l--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BuyTheString {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := s.getCurrent()->toInteger() ;
    var n : int ;
    var c0 : int ;
    var c1 : int ;
    var h : int ;
    var b : String ;
    while (l > 0) do (     n := s.getCurrent()->toInteger() ; 
     c0 := s.getCurrent()->toInteger() ; 
    c1 := s.getCurrent()->toInteger() ; 
    h := s.getCurrent()->toInteger() ; 
    b := s.getCurrent() ; 
    var count1 : int ; count1 := 0 ;
    var count0 : int ; count0 := 0 ;
    var change : boolean ; change := false ;
    var coins : int ; coins := 0 ;
        var i : int ; i := 0 ; while i < b->size() do ( (     if (b->at(i+1) = '0') then (     count0 := count0 + 1 ) else (     count1 := count1 + 1 ) )  ;     i := i + 1 ) ; 
    if (if c0 - c1 < 0 then -(c0 - c1) else c0 - c1 endif > h) then (     change := true ) else skip ; 
    if (change) then (     if (c0 < c1) then (     coins := coins + (count1 * h) ; 
     coins := coins + (b->size() * c0) ) else (     coins := coins + (count0 * h) ; 
     coins := coins + (b->size() * c1) ) ) else (     coins := coins + (count0 * c0) + (count1 * c1) ) ;  
    OclFile["System.out"].println(coins) ; 
    l := l - 1 ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Main {
  public static void solve(int n,int c0,int c1,int h,String bS){
    int vwoc=0,numOf1=0,numOf0=0,vwc=0 ;
    for(int i=0 ; i<bS.length(); i++){
      if(bS.charAt(i)=='0'){
        numOf0+=1 ;
      }
      else {
        numOf1+=1 ;
      }
    }
    vwoc=(numOf0*c0)+(numOf1*c1);
    if(c0<c1){
      c1=c0+h ;
    }
    else {
      c0=c1+h ;
    }
    vwc=(numOf0*c0)+(numOf1*c1);
    int minCost=vwoc ;
    if(vwc<vwoc){
      minCost=vwc ;
    }
    System.out.println(minCost);
  }
  public static void main(String[] args)throws IOException {
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int noOfTestCases=Integer.parseInt(r.readLine());
    for(int i=0 ; i<noOfTestCases ; i++){
      String firstLine=r.readLine();
      StringTokenizer st=new StringTokenizer(firstLine);
      int n=Integer.parseInt(st.nextToken());
      int c0=Integer.parseInt(st.nextToken());
      int c1=Integer.parseInt(st.nextToken());
      int h=Integer.parseInt(st.nextToken());
      String binaryString=r.readLine();
      solve(n,c0,c1,h,binaryString);
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( n : int, c0 : int, c1 : int, h : int, bS : String) : void
  pre: true
  post: true
  activity: (     var vwoc : int ; vwoc := 0 ;
    var numOf1 : int ; numOf1 := 0 ;
    var numOf0 : int ; numOf0 := 0 ;
    var vwc : int ; vwc := 0 ;
         var i : int ; i := 0 ; while i < bS->size() do ( (     if (bS->at(i+1) = '0') then (     numOf0 := numOf0+(1) ) else (     numOf1 := numOf1+(1) ) )  ;     i := i + 1 ) ; 
    vwoc := (numOf0 * c0) + (numOf1 * c1) ; 
    if (c0 < c1) then (     c1 := c0 + h ) else (     c0 := c1 + h ) ;  
    vwc := (numOf0 * c0) + (numOf1 * c1) ; 
    var minCost : int ; minCost := vwoc ;
    if (vwc < vwoc) then (     minCost := vwc ) else skip ; 
    OclFile["System.out"].println(minCost) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var noOfTestCases : int ; noOfTestCases := (r.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < noOfTestCases do ( (     var firstLine : String ; firstLine := r.readLine() ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(firstLine) ;
    var n : int ; n := (st.next())->toInteger() ;
    var c0 : int ; c0 := (st.next())->toInteger() ;
    var c1 : int ; c1 := (st.next())->toInteger() ;
    var h : int ; h := (st.next())->toInteger() ;
    var binaryString : String ; binaryString := r.readLine() ;
    execute solve(n, c0, c1, h, binaryString) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CD_1698_A_XOR_Mixup {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    sc.nextLine();
    while(t-->0){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      int result=0 ;
      for(int i=0 ; i<n ; i++){
        result=0 ;
        for(int j=0 ; j<n ; j++){
          if(j==i)continue ;
          result=result ^ a[j];
        }
        if(result==i)break ;
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CD_1698_A_XOR_Mixup {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     skip ; 
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     result := 0 ; 
         var j : int ; j := 0 ; while j < n do ( (     if (j = i) then     continue else skip ; 
     result := MathLib.bitwiseXor(result,a[j+1]) )  ;     j := j + 1 ) ; 
     if (result = i) then     break else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
    int t=Integer.parseInt(in.readLine());
    while(t-->0){
      String[] s=in.readLine().split(" ");
      int n=Integer.parseInt(s[0]);
      int sum=Integer.parseInt(s[1]);
      if(n>sum){
        out.write("No\n");
        out.flush();
        continue ;
      }
      if(n % 2==0){
        if(sum % 2!=0){
          out.write("No\n");
        }
        else {
          out.write("Yes\n");
          for(int i=0 ; i<n-2 ; i++){
            out.write("1 ");
            sum--;
          }
          out.write((sum/2)+" "+(sum/2)+"\n");
        }
      }
      else {
        out.write("Yes\n");
        for(int i=0 ; i<n-1 ; i++){
          out.write("1 ");
          sum--;
        }
        out.write(sum+"\n");
      }
      out.flush();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var t : int ; t := (in.readLine())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : Sequence(String) ; s := in.readLine()->split(" ") ;
     var n : int ; n := (s[0+1])->toInteger() ;
    var sum : int ; sum := (s[1+1])->toInteger() ;
    if (n > sum) then (     skip ; 
     skip ; 
     continue ) else skip ; 
    if (n mod 2 = 0) then (     if (sum mod 2 /= 0) then (     skip ) else (     skip ; 
         var i : int ; i := 0 ; while i < n - 2 do ( (     skip ; 
     sum := sum - 1 )  ;     i := i + 1 ) ; 
     skip ) ) else (     skip ; 
         var i : int ; i := 0 ; while i < n - 1 do ( (     skip ; 
     sum := sum - 1 )  ;     i := i + 1 ) ; 
     skip ) ;  
    skip ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Vector<Integer>PrimeFactors(int n){
    Vector<Integer>v=new Vector<Integer>();
    int x=n ;
    for(int i=2 ; i*i<=n ; i++){
      if(x % i==0){
        v.add(i);
        while(x % i==0)x/=i ;
      }
    }
    if(x>1)v.add(x);
    return v ;
  }
  static int GoodNumber(int n){
    Vector<Integer>v=new Vector<Integer>(PrimeFactors(n));
    int ans=1 ;
    for(int i=0 ; i<v.size(); i++)ans*=v.get(i);
    return ans ;
  }
  public static void main(String[] args){
    int n=12 ;
    System.out.println(GoodNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation PrimeFactors( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Sequence{} ;
     var x : int ; x := n ;
        var i : int ; i := 2 ; while i * i <= n do ( (     if (x mod i = 0) then (     v := v->including(i) ; 
     while (x mod i = 0) do     x := x/(i) ; ) else skip )  ;     i := i + 1 ) ; 
    if (x > 1) then     v := v->including(x) ; else skip ; 
    return v 
 );
  static   operation GoodNumber( n : int) : int
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Sequence{}->union(PrimeFactors(n)) ;
     var ans : int ; ans := 1 ;
         var i : int ; i := 0 ; while i < v->size() do (     ans := ans*(v->at(i+1)) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     OclFile["System.out"].println(GoodNumber(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX_CHAR=256 ;
  static int countSubStrings(String s,String anotherStr,int k){
    boolean illegal[]=new boolean[MAX_CHAR];
    for(int i=0 ; i<anotherStr.length(); i++){
      illegal[anotherStr.charAt(i)]=true ;
    }
    HashSet<String>us=new HashSet<String>();
    for(int i=0 ; i<s.length(); ++i){
      String ss="" ;
      int count=0 ;
      for(int j=i ; j<s.length(); ++j){
        if(illegal[s.charAt(j)]){
++count ;
        }
        ss=ss+s.charAt(j);
        if(count<=k){
          us.add(ss);
        }
        else {
          break ;
        }
      }
    }
    return us.size();
  }
  public static void main(String[] args){
    String str="acbacbacaa" ;
    String anotherStr="abcdefghijklmnopqrstuvwxyz" ;
    int k=2 ;
    System.out.println(countSubStrings(str,anotherStr,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX_CHAR : int := 256;
  static   operation countSubStrings( s : String, anotherStr : String, k : int) : int
  pre: true
  post: true
  activity: (     var illegal : Sequence(boolean) ; illegal := Integer.subrange(1,MAX_CHAR)->collect(false) ;
         var i : int ; i := 0 ; while i < anotherStr->size() do ( (     illegal[anotherStr->at(i+1)+1] := true )  ;     i := i + 1 ) ; 
    var us : Set(String) ; us := Set{} ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var ss : String ; ss := "" ;
     var count : int ; count := 0 ;
         var j : int ; j := i ; while j < s->size() do ( (     if (illegal[s->at(j+1)+1]) then (     count := count + 1 ) else skip ; 
     ss := ss + s->at(j+1) ; 
     if (count <= k) then (     us := us->including(ss) ) else (     break ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return us->size() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "acbacbacaa" ;
     var anotherStr : String ; anotherStr := "abcdefghijklmnopqrstuvwxyz" ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(countSubStrings(str, anotherStr, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B1248 {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    long[] arr=new long[n];
    int forward=0,backwards=arr.length-1 ;
    ;
    long xCord=0,yCord=0 ;
    StringTokenizer st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(st.nextToken());
    }
    Arrays.sort(arr);
    for(int i=0 ; i<arr.length ; i++){
      if(i % 2==0){
        xCord+=arr[backwards];
        backwards--;
      }
      else {
        yCord+=arr[forward];
        forward++;
      }
    }
    long m=xCord*xCord+yCord*yCord ;
    System.out.println(m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1248 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
    var forward : int ; forward := 0 ;
    var backwards : int ; backwards := arr->size() - 1 ;
    var xCord : long ; xCord := 0 ;
    var yCord : long ; yCord := 0 ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (i mod 2 = 0) then (     xCord := xCord+(arr[backwards+1]) ; 
     backwards := backwards - 1 ) else (     yCord := yCord+(arr[forward+1]) ; 
     forward := forward + 1 ) )  ;     i := i + 1 ) ; 
    var m : long ; m := xCord * xCord + yCord * yCord ;
    OclFile["System.out"].println(m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void maxProduct(int arr[],int n){
    if(n<2){
      System.out.println("No pairs exists");
      return ;
    }
    int a=arr[0],b=arr[1];
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++)if(arr[i]*arr[j]>a*b){
      a=arr[i];
      b=arr[j];
    }
    System.out.println("Max product pair is {"+a+","+b+"}");
  }
  public static void main(String[] args){
    int arr[]={
      1,4,3,6,7,0 };
      int n=arr.length ;
      maxProduct(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxProduct( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     if (n < 2) then (     OclFile["System.out"].println("No pairs exists") ; 
     return ) else skip ; 
     var a : int ; a := arr[0+1] ;
    var b : int ; b := arr[1+1] ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do (     if (arr[i+1] * arr[j+1] > a * b) then (     a := arr[i+1] ; 
     b := arr[j+1] ) else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Max product pair is {" + a + "," + b + "}") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,4,3,6,7,0} ;
     var n : int ; n := arr->size() ;
     execute maxProduct(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T>0){
      String str=sc.next();
      int count=0 ;
      char[] arr=str.toCharArray();
      for(char i : arr){
        if(i=='0')count++;
      }
      if(count==0)System.out.println("0");
      else if(str.lastIndexOf('0')-str.indexOf('0')+1==count)System.out.println("1");
      else System.out.println("2");
      T--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
     while (T > 0) do (     var str : String ; str := sc.getCurrent() ;
     var count : int ; count := 0 ;
    var arr : Sequence(String) ; arr := str->characters() ;
    for (i : arr) do ( (     if (i = '0') then     count := count + 1 ; else skip )  ) ; 
    if (count = 0) then     OclFile["System.out"].println("0") else     if (str->lastIndexOf('0')-1 - str->indexOf('0')-1 + 1 = count) then     OclFile["System.out"].println("1") else     OclFile["System.out"].println("2") ; ;  ;  
    T := T - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Rough {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test_cases=sc.nextInt();
    sc.nextLine();
    for(int i=0 ; i<test_cases ; i++){
      String binstr=sc.nextLine();
      int count=0 ;
      boolean flag=false ;
      for(int j=0 ; j<binstr.length(); j++){
        if(binstr.charAt(j)=='0'){
          flag=true ;
          continue ;
        }
        if(flag)count++;
        flag=false ;
      }
      if(flag)count++;
      if(count>2)count=2 ;
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Rough {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test_cases : int ; test_cases := sc.getCurrent()->toInteger() ;
     skip ; 
         var i : int ; i := 0 ; while i < test_cases do ( (     var binstr : String ; binstr := sc.nextLine() ;
     var count : int ; count := 0 ;
    var flag : boolean ; flag := false ;
        var j : int ; j := 0 ; while j < binstr->size() do ( (     if (binstr->at(j+1) = '0') then (     flag := true ; 
     continue ) else skip ; 
     if (flag) then     count := count + 1 ; else skip ; 
     flag := false )  ;     j := j + 1 ) ; 
    if (flag) then     count := count + 1 ; else skip ; 
    if (count > 2) then     count := 2 ; else skip ; 
    OclFile["System.out"].println(count) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Objects ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    input.nextLine();
    while(t-->0){
      String s=input.nextLine();
      char c=s.charAt(0);
      int sum=0 ;
      for(int i=1 ; i<s.length(); i++){
        if(s.charAt(i)!=c){
          if(c=='0')sum++;
          c=s.charAt(i);
        }
      }
      if(c=='0')sum++;
      if(sum>2)sum=2 ;
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
     skip ; 
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : String ; s := input.nextLine() ;
     var c : String ; c := s->at(0+1) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 1 ; while i < s->size() do ( (     if (s->at(i+1) /= c) then (     if (c = '0') then     sum := sum + 1 ; else skip ; 
     c := s->at(i+1) ) else skip )  ;     i := i + 1 ) ; 
    if (c = '0') then     sum := sum + 1 ; else skip ; 
    if (sum > 2) then     sum := 2 ; else skip ; 
    OclFile["System.out"].println(sum) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.HashSet ;
public class sol {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      String s=sc.next();
      if(s.length()==1){
        if(s.charAt(0)=='0'){
          System.out.println(1);
        }
        else {
          System.out.println(0);
        }
      }
      else {
        int i=0,tot=0 ;
        while(i<s.length()){
          char ch=s.charAt(i);
          if(tot==2)break ;
          if(ch=='0'){
            tot+=1 ;
          }
          int j=i+1 ;
          while(j<s.length()&& ch==s.charAt(j)){
            j++;
          }
          i=j ;
        }
        System.out.println(tot);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class sol {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : String ; s := sc.getCurrent() ;
     if (s->size() = 1) then (     if (s->at(0+1) = '0') then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(0) ) ) else (     var i : int ; i := 0 ;
    var tot : int ; tot := 0 ;
     while (i < s->size()) do (     var ch : String ; ch := s->at(i+1) ;
     if (tot = 2) then     break else skip ; 
    if (ch = '0') then (     tot := tot+(1) ) else skip ; 
    var j : int ; j := i + 1 ;
    while (j < s->size() & ch = s->at(j+1)) do (     j := j + 1 ) ; 
    i := j ; 
 ) ; 
     OclFile["System.out"].println(tot) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.TreeSet ;
public class DuffInLove {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    long n=Long.parseLong(reader.readLine());
    TreeSet<Long>factors=new TreeSet<>((x,y)->Long.compare(y,x));
    for(long i=1 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        factors.add(i);
        factors.add(n/i);
      }
    }
    for(Long item : factors){
      boolean isNiceNum=true ;
      for(long i=2 ; i<=Math.sqrt(item); i++){
        if(item %(i*i)==0){
          isNiceNum=false ;
          break ;
        }
      }
      if(isNiceNum){
        writer.write(item+"\n");
        break ;
      }
    }
    writer.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class DuffInLove {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : long ; n := (reader.readLine())->toLong() ;
    var factors : Set(long) ; factors := Set{}->union(lambda (x , y) : OclAny in compare(y, x)) ;
        var i : long ; i := 1 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     factors := factors->including(i) ; 
     factors := factors->including(n / i) ) else skip )  ;     i := i + 1 ) ; 
    for (item : factors) do ( (     var isNiceNum : boolean ; isNiceNum := true ;
         var i : long ; i := 2 ; while i <= (item)->sqrt() do ( (     if (item mod (i * i) = 0) then (     isNiceNum := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (isNiceNum) then (     skip ; 
     break ) else skip )  ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class duffInLove {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    for(long i=2 ; i*i<=n ; i++){
      while(n %(i*i)==0){
        n=n/i ;
      }
    }
    System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class duffInLove {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
         var i : long ; i := 2 ; while i * i <= n do ( (     while (n mod (i * i) = 0) do (     n := n / i ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int maxOfSegmentMins(int[] a,int n,int k){
    if(k==1){
      Arrays.sort(a);
      return a[0];
    }
    if(k==2)return Math.max(a[0],a[n-1]);
    return a[n-1];
  }
  static public void main(String[] args){
    int[] a={
-10,-9,-8,2,7,-6,-5 };
      int n=a.length ;
      int k=2 ;
      System.out.println(maxOfSegmentMins(a,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxOfSegmentMins( a : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     if (k = 1) then (     a := a->sort() ; 
     return a[0+1] ) else skip ; 
     if (k = 2) then     return Set{a[0+1], a[n - 1+1]}->max() else skip ; 
     return a[n - 1+1] );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{-10,-9,-8,2,7,-6,-5} ;
     var n : int ; n := a->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(maxOfSegmentMins(a, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class Duff_in_love {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    FastReader sc=new FastReader();
    long n=sc.nextLong();
    for(long i=2 ; i<=Math.sqrt(n); i++){
      while(n %(i*i)==0){
        n=n/i ;
      }
    }
    System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Duff_in_love {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : long ; n := sc.nextLong() ;
         var i : long ; i := 2 ; while i <= (n)->sqrt() do ( (     while (n mod (i * i) = 0) do (     n := n / i ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.io.BufferedReader ;
import java.io.FileNotFoundException ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Random ;
import java.util.StringTokenizer ;
public class Main {
  static final Random random=new Random();
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    long x=sc.nextLong();
    for(long i=2 ; i*i<=x ; i++){
      while(x %(i*i)==0)x/=i ;
    }
    out.println(x);
    out.flush();
  }
  static void Arrayssort(int[] a){
    int n=a.length ;
    for(int i=0 ; i<n ; i++){
      int oi=random.nextInt(n);
      int temp=a[oi];
      a[oi]=a[i];
      a[i]=temp ;
    }
    java.util.Arrays.sort(a);
  }
  private static class Scanner {
    public BufferedReader reader ;
    public StringTokenizer st ;
    public Scanner(InputStream file)throws FileNotFoundException {
      reader=new BufferedReader(new InputStreamReader(file));
      st=null ;
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          String line=reader.readLine();
          if(line==null)return null ;
          st=new StringTokenizer(line);
        }
        catch(Exception e){
          throw(new RuntimeException());
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine()throws IOException {
      return reader.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute random : OclRandom := OclRandom.newOclRandom();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := sc.getCurrent()->toLong() ;
        var i : long ; i := 2 ; while i * i <= x do ( (     while (x mod (i * i) = 0) do     x := x/(i) ; )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation Arrayssort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() ;
         var i : int ; i := 0 ; while i < n do ( (     var oi : int ; oi := random.nextInt(n) ;
     var temp : int ; temp := a[oi+1] ;
     a[oi+1] := a[i+1] ; 
     a[i+1] := temp )  ;     i := i + 1 ) ; 
     java.util.Arrays.sort(a) );
  static class Scanner {
   attribute reader : OclFile;
   attribute st : OclIterator;
   static operation newScanner( file : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(file);
    return self );
  operation initialise( file : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) ; 
     st := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     var line : String ; line := reader.readLine() ;
     if (line = null) then     return null else skip ; 
     st := OclIterator.newOclIterator_String(line) )   catch (e : ProgramException) do (     error (ProgramException()) )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return reader.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int res=0 ;
    int n=sc.nextInt();
    for(int i=31 ; i>=0 ; i--){
      if(n>=1L<<i){
        n-=1<<i ;
        res++;
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var res : int ; res := 0 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 31 ; while i >= 0 do ( (     if (n >= (1L*(2->pow(i)))->oclAsType(long)) then (     n := n-((1*(2->pow(i)))->oclAsType(long)) ; 
     res := res + 1 ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int msbPos(int n){
    int pos=0 ;
    while(n!=0){
      pos++;
      n=n>>1 ;
    }
    return pos ;
  }
  static int josephify(int n){
    int position=msbPos(n);
    int j=1<<(position-1);
    n=n ^ j ;
    n=n<<1 ;
    n=n | 1 ;
    return n ;
  }
  public static void main(String[] args){
    int n=41 ;
    System.out.println(josephify(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation msbPos( n : int) : int
  pre: true
  post: true
  activity: (     var pos : int ; pos := 0 ;
     while (n /= 0) do (     pos := pos + 1 ; 
     n := (n/(2->pow(1)))->oclAsType(long) ) ; 
     return pos );
  static   operation josephify( n : int) : int
  pre: true
  post: true
  activity: (     var position : int ; position := msbPos(n) ;
     var j : int ; j := (1*(2->pow((position - 1))))->oclAsType(long) ;
    n := n xor j ; 
    n := (n*(2->pow(1)))->oclAsType(long) ; 
    n := n or 1 ; 
    return n 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 41 ;
     OclFile["System.out"].println(josephify(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      Integer[] arr=new Integer[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      Arrays.sort(arr);
      int x=arr[arr.length-2]-1 ;
      int y=arr.length-2 ;
      System.out.println(Math.min(x,y));
      t--;
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var x : int ; x := arr[arr->size() - 2+1] - 1 ;
    var y : int ; y := arr->size() - 2 ;
    OclFile["System.out"].println(Set{x, y}->min()) ; 
    t := t - 1 ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.List ;
public class DIYWoodenLadder {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    while(t>0){
      int n=Integer.parseInt(br.readLine());
      String[] str=br.readLine().split(" ");
      List<Integer>list=new ArrayList<>();
      for(int i=0 ; i<n ; i++)list.add(Integer.parseInt(str[i]));
      Collections.sort(list);
      System.out.println(Integer.min(list.get(n-2)-1,n-2));
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DIYWoodenLadder {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
     while (t > 0) do (     var n : int ; n := (br.readLine())->toInteger() ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     list := list->including((str[i+1])->toInteger()) ;  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    OclFile["System.out"].println(Set{list->at(n - 2+1) - 1, n - 2}->min()) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int reverseNum(int x){
    String s=Integer.toString(x);
    String str="" ;
    for(int i=s.length()-1 ; i>=0 ; i--){
      str=str+s.charAt(i);
    }
    int rev=Integer.parseInt(str);
    return rev ;
  }
  static boolean isMysteryNumber(int n){
    for(int i=1 ; i<=n/2 ; i++){
      int j=reverseNum(i);
      if(i+j==n){
        System.out.println(i+" "+j);
        return true ;
      }
    }
    System.out.println("Not a Mystery Number");
    return false ;
  }
  public static void main(String[] args){
    int n=121 ;
    isMysteryNumber(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation reverseNum( x : int) : int
  pre: true
  post: true
  activity: (     var s : String ; s := ((x) + "") ;
     var str : String ; str := "" ;
        var i : int ; i := s->size() - 1 ; while i >= 0 do ( (     str := str + s->at(i+1) )  ;     i := i - 1 ) ; 
    var rev : int ; rev := (str)->toInteger() ;
    return rev 
 );
  static   operation isMysteryNumber( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= n / 2 do ( (     var j : int ; j := reverseNum(i) ;
     if (i + j = n) then (     OclFile["System.out"].println(i + " " + j) ; 
     return true ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Not a Mystery Number") ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 121 ;
     execute isMysteryNumber(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.*;
public class ques {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      double[] arr=new double[n];
      double largest=sc.nextFloat();
      double sum=largest ;
      for(int j=1 ; j<n ; j++){
        arr[j]=sc.nextInt();
        sum+=arr[j];
        if(arr[j]>largest){
          largest=arr[j];
        }
      }
      double ans=(sum-largest)/(n-1);
      System.out.printf("%.9f",ans+largest);
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ques {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(double) ; arr := Integer.subrange(1,n)->collect(0.0) ;
    var largest : double ; largest := sc.nextFloat() ;
    var sum : double ; sum := largest ;
        var j : int ; j := 1 ; while j < n do ( (     arr[j+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(arr[j+1]) ; 
     if (arr[j+1] > largest) then (     largest := arr[j+1] ) else skip )  ;     j := j + 1 ) ; 
    var ans : double ; ans := (sum - largest) / (n - 1) ;
    OclFile["System.out"].printf("%.9f", ans + largest) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; ++i){
        a[i]=sc.nextInt();
      }
      System.out.println(String.format("%.9f",solve(a)));
    }
    sc.close();
  }
  static double solve(int[] a){
    int max=Arrays.stream(a).max().getAsInt();
    long otherSum=Arrays.stream(a).asLongStream().sum()-max ;
    return max+otherSum/(a.length-1.0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(StringLib.format("%.9f",Sequence{solve(a)})) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : Sequence(int)) : double
  pre: true
  post: true
  activity: (     var max : int ; max := stream(a).max().getAsInt() ;
     var otherSum : long ; otherSum := stream(a)->sum() - max ;
     return max + otherSum / (a->size() - 1.0) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class EzzatAndTwoSubsequences {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int num=sc.nextInt();
      double largest=-Double.MAX_VALUE ;
      double sum=0 ;
      for(int j=0 ; j<num ; j++){
        int next=sc.nextInt();
        if(next>largest){
          largest=next ;
        }
        sum+=next ;
      }
      sum-=largest ;
      double a1=sum/(num-1);
      System.out.println(a1+largest);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class EzzatAndTwoSubsequences {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := sc.getCurrent()->toInteger() ;
     var largest : double ; largest := -(2 - 2->pow(-52))*(2->pow(1023)) ;
    var sum : double ; sum := 0 ;
        var j : int ; j := 0 ; while j < num do ( (     var next : int ; next := sc.getCurrent()->toInteger() ;
     if (next > largest) then (     largest := next ) else skip ; 
     sum := sum+(next) )  ;     j := j + 1 ) ; 
    sum := sum-(largest) ; 
    var a1 : double ; a1 := sum / (num - 1) ;
    OclFile["System.out"].println(a1 + largest) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test243 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      double max=in.nextInt();
      double sum=max ;
      for(int i=0 ; i<n-1 ; i++){
        int x=in.nextInt();
        sum+=x ;
        if(x>max){
          max=x ;
        }
      }
      sum-=max ;
      System.out.println(sum/(n-1)+max);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test243 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var max : double ; max := in.getCurrent()->toInteger() ;
    var sum : double ; sum := max ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     sum := sum+(x) ; 
     if (x > max) then (     max := x ) else skip )  ;     i := i + 1 ) ; 
    sum := sum-(max) ; 
    OclFile["System.out"].println(sum / (n - 1) + max) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),count=0 ;
    while(n>9){
      n++;
      count++;
      while(n % 10==0){
        n/=10 ;
      }
    }
    pw.print(count+9);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    while (n > 9) do (     n := n + 1 ; 
     count := count + 1 ; 
     while (n mod 10 = 0) do (     n := n/(10) ) ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findCost(String s1,String s2,int a,int b,int c,int d,int n){
    int cost=0 ;
    for(int i=0 ; i<n ; i++){
      if(s1.charAt(i)==s2.charAt(i))continue ;
      else {
        if((s1.charAt(i)=='1' && s2.charAt(i)=='2')||(s2.charAt(i)=='1' && s1.charAt(i)=='2'))cost+=Math.min(d,Math.min(a,b+c));
        else if((s1.charAt(i)=='2' && s2.charAt(i)=='3')||(s2.charAt(i)=='2' && s1.charAt(i)=='3'))cost+=Math.min(d,Math.min(b,a+c));
        else if((s1.charAt(i)=='1' && s2.charAt(i)=='3')||(s2.charAt(i)=='1' && s1.charAt(i)=='3'))cost+=Math.min(d,Math.min(c,a+b));
      }
    }
    return cost ;
  }
  public static void main(String[] args){
    String s1="121" ;
    String s2="223" ;
    int a=2,b=3,c=4,d=10 ;
    int n=s1.length();
    System.out.println(findCost(s1,s2,a,b,c,d,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findCost( s1 : String, s2 : String, a : int, b : int, c : int, d : int, n : int) : int
  pre: true
  post: true
  activity: (     var cost : int ; cost := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (s1->at(i+1) = s2->at(i+1)) then     continue else (     if ((s1->at(i+1) = '1' & s2->at(i+1) = '2') or (s2->at(i+1) = '1' & s1->at(i+1) = '2')) then     cost := cost+(Set{d, Set{a, b + c}->min()}->min()) ; else     if ((s1->at(i+1) = '2' & s2->at(i+1) = '3') or (s2->at(i+1) = '2' & s1->at(i+1) = '3')) then     cost := cost+(Set{d, Set{b, a + c}->min()}->min()) else     if ((s1->at(i+1) = '1' & s2->at(i+1) = '3') or (s2->at(i+1) = '1' & s1->at(i+1) = '3')) then     cost := cost+(Set{d, Set{c, a + b}->min()}->min()) ; else skip ; ;  ) )  ;     i := i + 1 ) ; 
     return cost );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "121" ;
     var s2 : String ; s2 := "223" ;
    var a : int ; a := 2 ;
    var b : int ; b := 3 ;
    var c : int ; c := 4 ;
    var d : int ; d := 10 ;
    var n : int ; n := s1->size() ;
    OclFile["System.out"].println(findCost(s1, s2, a, b, c, d, n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B148 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    double VP=in.nextInt();
    double VD=in.nextInt();
    double T=in.nextInt();
    double F=in.nextInt();
    double C=in.nextInt();
    if(VD<=VP){
      System.out.println("0");
      return ;
    }
    int answer=0 ;
    double start=T ;
    while(true){
      double x=start*VP/(VD-VP);
      if((start+x)*VP>=C){
        break ;
      }
      start+=2*x+F ;
      answer++;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B148 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var VP : double ; VP := in.getCurrent()->toInteger() ;
    var VD : double ; VD := in.getCurrent()->toInteger() ;
    var T : double ; T := in.getCurrent()->toInteger() ;
    var F : double ; F := in.getCurrent()->toInteger() ;
    var C : double ; C := in.getCurrent()->toInteger() ;
    if (VD <= VP) then (     OclFile["System.out"].println("0") ; 
     return ) else skip ; 
    var answer : int ; answer := 0 ;
    var start : double ; start := T ;
    while (true) do (     var x : double ; x := start * VP / (VD - VP) ;
     if ((start + x) * VP >= C) then (     break ) else skip ; 
     start := start+(2 * x + F) ; 
     answer := answer + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    int M=Integer.parseInt(sc.next());
    long xyz[][]=new long[4][N];
    int d[]={
-1,1 };
      for(int i=0 ; i<N ; i++){
        long x=Long.parseLong(sc.next());
        long y=Long.parseLong(sc.next());
        long z=Long.parseLong(sc.next());
        for(int j=0 ; j<2 ; j++){
          for(int k=0 ; k<2 ; k++){
            xyz[2*j+k][i]=x+y*d[j]+z*d[k];
          }
        }
      }
      for(int i=0 ; i<4 ; i++){
        Arrays.sort(xyz[i]);
      }
      long ans=0,sum ;
      for(int i=0 ; i<4 ; i++){
        sum=0 ;
        for(int j=0 ; j<M ; j++){
          sum+=-xyz[i][j];
        }
        ans=Math.max(ans,sum);
        sum=0 ;
        for(int j=N-1 ; j>N-1-M ; j--){
          sum+=xyz[i][j];
        }
        ans=Math.max(ans,sum);
      }
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var M : int ; M := (sc.getCurrent())->toInteger() ;
    var xyz : Sequence(Sequence(long)) ; xyz := Integer.subrange(1,4)->collect(Integer.subrange(1,N)->collect(0)) ;
    var d : Sequence(int) ; d := Sequence{-1,1} ;
        var i : int ; i := 0 ; while i < N do ( (     var x : long ; x := (sc.getCurrent())->toLong() ;
     var y : long ; y := (sc.getCurrent())->toLong() ;
     var z : long ; z := (sc.getCurrent())->toLong() ;
         var j : int ; j := 0 ; while j < 2 do ( (         var k : int ; k := 0 ; while k < 2 do ( (     xyz[2 * j + k+1][i+1] := x + y * d[j+1] + z * d[k+1] )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 4 do ( (     xyz[i+1] := xyz[i+1]->sort() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var sum : long ;
        var i : int ; i := 0 ; while i < 4 do ( (     sum := 0 ; 
         var j : int ; j := 0 ; while j < M do ( (     sum := sum+(-xyz[i+1][j+1]) )  ;     j := j + 1 ) ; 
    ans := Set{ans, sum}->max() ; 
    sum := 0 ; 
        var j : int ; j := N - 1 ; while j > N - 1 - M do ( (     sum := sum+(xyz[i+1][j+1]) )  ;     j := j - 1 ) ; 
    ans := Set{ans, sum}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  private static final int N=3 ;
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt(),m=scanner.nextInt();
      long[] x=new long[n],y=new long[n],z=new long[n];
      IntStream.range(0,n).forEach(i->{
        x[i]=scanner.nextLong();
        y[i]=scanner.nextLong();
        z[i]=scanner.nextLong();
      }
);
      System.out.println(IntStream.range(0,1<<N).mapToLong(i->IntStream.range(0,n).mapToLong(j->(((i & 1)>0)?-1 : 1)*x[j]+((((i>>1)& 1)>0)?-1 : 1)*y[j]+((((i>>2)& 1)>0)?-1 : 1)*z[j]).sorted().skip(n-m).sum()).max().getAsLong());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute N : int := 3;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
     var x : Sequence(long) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(long) ; y := Integer.subrange(1,n)->collect(0) ;
    var z : Sequence(long) ; z := Integer.subrange(1,n)->collect(0) ;
     for i : Integer.subrange(0, n-1) do
    (    skip) ; 
     OclFile["System.out"].println(Integer.subrange(0, (1*(2->pow(N)))->oclAsType(long)-1)->collect( _x1 | (lambda i : OclAny in Integer.subrange(0, n-1)->collect( _x1 | (lambda j : OclAny in (if ((i & 1) > 0) then -1 else 1 endif) * x[j+1] + (if ((((i/(2->pow(1)))->oclAsType(long)) & 1) > 0) then -1 else 1 endif) * y[j+1] + (if ((((i/(2->pow(2)))->oclAsType(long)) & 1) > 0) then -1 else 1 endif) * z[j+1])->apply(_x1) )->sort().subrange(n - m+1)->sum())->apply(_x1) ).max().getAsLong()) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    Cake[] cakes=new Cake[n];
    for(int i=0 ; i<n ; i++){
      cakes[i]=new Cake(new long[] {
        sc.nextLong(),sc.nextLong(),sc.nextLong()}
);
      }
      long max=Long.MIN_VALUE ;
      for(int i=0 ; i<4 ; i++){
        Cake.type=i ;
        Arrays.sort(cakes);
        max=Math.max(max,getMax(cakes,m));
      }
      System.out.println(max);
    }
    static long getMax(Cake[] cakes,int count){
      long fore=0 ;
      long reer=0 ;
      for(int i=0 ; i<count ; i++){
        fore+=cakes[i] .getValue();
        reer+=cakes[cakes.length-i-1] .getValue();
      }
      return Math.max(Math.abs(fore),Math.abs(reer));
    }
    static class Cake implements Comparable<Cake>{
      static int[][] sw=new int[][] {
        {
          1,1,1 },{
-1,1,1 },{
              1,-1,1 },{
                1,1,-1 }
              };
              static int type ;
              long[] values ;
              public Cake(long[] values){
                this.values=values ;
              }
              public long getValue(){
                long ans=0 ;
                for(int i=0 ; i<3 ; i++){
                  ans+=sw[type][i]*values[i];
                }
                return ans ;
              }
              public int compareTo(Cake another){
                long x=getValue();
                long y=another.getValue();
                if(x==y){
                  return 0 ;
                }
                else if(x<y){
                  return-1 ;
                }
                else {
                  return 1 ;
                }
              }
            }
          }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var cakes : Sequence(Cake) ; cakes := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     cakes[i+1] := Cake.newCake(Sequence{sc.getCurrent()->toLong(),sc.getCurrent()->toLong(),sc.getCurrent()->toLong()}) )  ;     i := i + 1 ) ; 
    var max : long ; max := "-9223372036854775808"->toLong() ;
        var i : int ; i := 0 ; while i < 4 do ( (     Cake.type := i ; 
     cakes := cakes->sort() ; 
     max := Set{max, getMax(cakes, m)}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static   operation getMax( cakes : Sequence(Cake), count : int) : long
  pre: true
  post: true
  activity: (     var fore : long ; fore := 0 ;
     var reer : long ; reer := 0 ;
         var i : int ; i := 0 ; while i < count do ( (     fore := fore+(cakes[i+1].getValue()) ; 
     reer := reer+(cakes[cakes->size() - i - 1+1].getValue()) )  ;     i := i + 1 ) ; 
     return Set{if fore < 0 then -(fore) else fore endif, if reer < 0 then -(reer) else reer endif}->max() );
  static class Cake implements Comparable<Cake> {
  static   attribute sw : Sequence(Sequence(int)) := Sequence{Sequence{1,1,1},Sequence{-1,1,1},Sequence{1,-1,1},Sequence{1,1,-1}};
  static   attribute type : int;
   attribute values : Sequence(long);
   static operation newCake( values : Sequence(long)) : Cake
  pre: true
  post: true
  activity:
  ( var self : Cake ;
    self := createCake();
    self.initialise(values);
    return self );
  operation initialise( values : Sequence(long)) : void
  pre: true  post: true
  activity: (     self.values := values );
   operation getValue() : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
         var i : int ; i := 0 ; while i < 3 do ( (     ans := ans+(sw[type+1][i+1] * values[i+1]) )  ;     i := i + 1 ) ; 
     return ans );
   operation compareTo( another : Cake) : int
  pre: true
  post: true
  activity: (     var x : long ; x := getValue() ;
     var y : long ; y := another.getValue() ;
     if (x = y) then (     return 0 ) else     if (x < y) then (     return -1 ) else (     return 1 ) ;  );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.Collectors ;
public class Main {
  static int N ;
  static int M ;
  static List<long[]>list ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    M=sc.nextInt();
    list=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      long x=sc.nextLong();
      long y=sc.nextLong();
      long z=sc.nextLong();
      list.add(new long[] {
        x,y,z }
);
      }
      solve();
    }
    static void solve(){
      List<int[]>signs=new ArrayList<>();
      signs.add(new int[] {
        1,1,1 }
);
        signs.add(new int[] {
          1,1,-1 }
);
          signs.add(new int[] {
            1,-1,1 }
);
            signs.add(new int[] {
              1,-1,-1 }
);
              signs.add(new int[] {
-1,1,1 }
);
                signs.add(new int[] {
-1,1,-1 }
);
                  signs.add(new int[] {
-1,-1,1 }
);
                    signs.add(new int[] {
-1,-1,-1 }
);
                      long max=0 ;
                      for(int[] sign : signs){
                        max=Math.max(max,list.stream().map(xyz->xyz[0]*sign[0]+xyz[1]*sign[1]+xyz[2]*sign[2]).sorted(Comparator.reverseOrder()).limit(M).mapToLong(Long :: longValue).sum());
                      }
                      System.out.println(max);
                    }
                  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute M : int;
  static   attribute list : Sequence(Sequence(long));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
    M := sc.getCurrent()->toInteger() ; 
    list := Sequence{} ; 
        var i : int ; i := 0 ; while i < N do ( (     var x : long ; x := sc.getCurrent()->toLong() ;
     var y : long ; y := sc.getCurrent()->toLong() ;
     var z : long ; z := sc.getCurrent()->toLong() ;
     list := list->including(Sequence{x,y,z}) )  ;     i := i + 1 ) ; 
    execute solve() ; 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var signs : Sequence(Sequence(int)) ; signs := Sequence{} ;
     signs := signs->including(Sequence{1,1,1}) ; 
    signs := signs->including(Sequence{1,1,-1}) ; 
    signs := signs->including(Sequence{1,-1,1}) ; 
    signs := signs->including(Sequence{1,-1,-1}) ; 
    signs := signs->including(Sequence{-1,1,1}) ; 
    signs := signs->including(Sequence{-1,1,-1}) ; 
    signs := signs->including(Sequence{-1,-1,1}) ; 
    signs := signs->including(Sequence{-1,-1,-1}) ; 
    var max : long ; max := 0 ;
    for (sign : signs) do ( (     max := Set{max, list->collect( _x1 | (lambda xyz : OclAny in xyz[0+1] * sign[0+1] + xyz[1+1] * sign[1+1] + xyz[2+1] * sign[2+1])->apply(_x1) )->sort().subrange(1,M)->collect( _x1 | (lambda _pars : OclAny in Long.newLong().longValue(_pars))->apply(_x1) )->sum()}->max() )  ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
import java.util.Comparator ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    Cake[] cake=new Cake[n];
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      long x=sc.nextLong();
      long y=sc.nextLong();
      long z=sc.nextLong();
      cake[i]=new Cake(x,y,z);
    }
    int[] xyz=new int[3];
    for(int i=0 ; i<8 ; i++){
      Arrays.fill(xyz,1);
      int ii=i ;
      long an=0 ;
      int count=0 ;
      while(ii>0){
        if((ii & 1)==1){
          xyz[count]*=-1 ;
        }
        ii>>=1 ;
        count++;
      }
      for(int j=0 ; j<n ; j++){
        cake[j] .x1=cake[j] .x*xyz[0];
        cake[j] .y1=cake[j] .y*xyz[1];
        cake[j] .z1=cake[j] .z*xyz[2];
      }
      Arrays.sort(cake,Comparator.comparing(Cake :: getSum).reversed());
      for(int k=0 ; k<m ; k++){
        an+=cake[k] .getSum();
      }
      ans=Math.max(ans,an);
    }
    System.out.println(ans);
  }
  static class Cake {
    long x ;
    long y ;
    long z ;
    long x1 ;
    long y1 ;
    long z1 ;
    public Cake(long x,long y,long z){
      this.x=x ;
      this.y=y ;
      this.z=z ;
    }
    public long getSum(){
      return this.x1+this.y1+this.z1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var cake : Sequence(Cake) ; cake := Integer.subrange(1,n)->collect(null) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : long ; x := sc.getCurrent()->toLong() ;
     var y : long ; y := sc.getCurrent()->toLong() ;
     var z : long ; z := sc.getCurrent()->toLong() ;
     cake[i+1] := Cake.newCake(x, y, z) )  ;     i := i + 1 ) ; 
    var xyz : Sequence(int) ; xyz := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 8 do ( (     xyz := xyz->collect(1) ; 
     var ii : int ; ii := i ;
    var an : long ; an := 0 ;
    var count : int ; count := 0 ;
    while (ii > 0) do (     if ((MathLib.bitwiseAnd(ii,1)) = 1) then (     xyz[count+1] := xyz[count+1]*(-1) ) else skip ; 
     ii := ii/(2->pow(1)) ; 
     count := count + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     cake[j+1].x1 := cake[j+1].x * xyz[0+1] ; 
     cake[j+1].y1 := cake[j+1].y * xyz[1+1] ; 
     cake[j+1].z1 := cake[j+1].z * xyz[2+1] )  ;     j := j + 1 ) ; 
    cake := OclComparator.sortWith(cake, Comparator.comparing(lambda _pars : OclAny in Cake.newCake().getSum(_pars)).reversed()) ; 
        var k : int ; k := 0 ; while k < m do ( (     an := an+(cake[k+1].getSum()) )  ;     k := k + 1 ) ; 
    ans := Set{ans, an}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class Cake {
   attribute x : long;
   attribute y : long;
   attribute z : long;
   attribute x1 : long;
   attribute y1 : long;
   attribute z1 : long;
   static operation newCake( x : long, y : long, z : long) : Cake
  pre: true
  post: true
  activity:
  ( var self : Cake ;
    self := createCake();
    self.initialise(x, y,z);
    return self );
  operation initialise( x : long, y : long, z : long) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y ; 
     self.z := z );
   operation getSum() : long
  pre: true
  post: true
  activity: (     return self.x1 + self.y1 + self.z1 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import java.io.*;
public class Hello {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int a[]=new int[n];
    int b[]=new int[n];
    ArrayList<Integer>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
      list.add(a[i]);
    }
    for(int i=0 ; i<n ; i++){
      b[i]=in.nextInt();
      list.add(b[i]);
    }
    int c=0 ;
    pw.println("Karen");
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hello {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     list := list->including(a[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := in.getCurrent()->toInteger() ; 
     list := list->including(b[i+1]) )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner in=new Scanner(System.in)){
      int N=in.nextInt();
      int x=in.nextInt();
      int[] a=new int[N];
      for(int i=0 ; i<N ; i++){
        a[i]=in.nextInt();
      }
      long count=0 ;
      for(int i=0 ; i+1<N ; i++){
        if(a[i]+a[i+1]>x){
          int c=(a[i]+a[i+1])-x ;
          count+=c ;
          a[i+1]-=c ;
          if(a[i+1]<0){
            a[i]+=a[i+1];
            a[i+1]=0 ;
          }
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := in.getCurrent()->toInteger() ;
     var x : int ; x := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : long ; count := 0 ;
        var i : int ; i := 0 ; while i + 1 < N do ( (     if (a[i+1] + a[i + 1+1] > x) then (     var c : int ; c := (a[i+1] + a[i + 1+1]) - x ;
     count := count+(c) ; 
     a[i + 1+1] := a[i + 1+1]-(c) ; 
     if (a[i + 1+1] < 0) then (     a[i+1] := a[i+1]+(a[i + 1+1]) ; 
     a[i + 1+1] := 0 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    HashMap<Character,Integer>cnt=new HashMap<Character,Integer>();
    char[] march={
      'M','A','R','C','H' };
      for(char c : march)cnt.put(c,0);
      int N=sc.nextInt();
      for(int i=0 ; i<N ; i++){
        String S=sc.next();
        char st=S.charAt(0);
        boolean exist=false ;
        for(char c : march)exist |=(st==c);
        if(exist)cnt.put(st,cnt.get(st)+1);
      }
      long ans=0 ;
      int comb=(1<<3)-1 ;
      while(comb<(1<<5)){
        boolean make=true ;
        for(int i=0 ; i<5 ; i++){
          if(((comb>>i)& 1)==1)make &=(cnt.get(march[i])>0);
        }
        if(! make){
          int x=(comb &-comb),y=comb+x ;
          comb=((comb & ~ y)/x>>1)| y ;
          continue ;
        }
        long tmp=1 ;
        for(int i=0 ; i<5 ; i++){
          if(((comb>>i)& 1)==1){
            tmp*=(long)cnt.get(march[i]);
          }
        }
        ans+=tmp ;
        int x=(comb &-comb),y=comb+x ;
        comb=((comb & ~ y)/x>>1)| y ;
      }
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cnt : Map(String,int) ; cnt := Map{} ;
    var march : Sequence(String) ; march := Sequence{'M','A','R','C','H'} ;
    for (c : march) do (     cnt := cnt->union(Map{c |-> 0}) ;  ) ; 
    var N : int ; N := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < N do ( (     var S : String ; S := sc.getCurrent() ;
     var st : String ; st := S->at(0+1) ;
    var exist : boolean ; exist := false ;
    for (c : march) do (     exist := MathLib.bitwiseOr(exist, (st = c)) ;  ) ; 
    if (exist) then     cnt := cnt->union(Map{st |-> cnt->at(st) + 1}) ; else skip ; 
 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var comb : int ; comb := ((1*(2->pow(3)))->oclAsType(long)) - 1 ;
    while (comb < ((1*(2->pow(5)))->oclAsType(long))) do (     var make : boolean ; make := true ;
         var i : int ; i := 0 ; while i < 5 do ( (     if ((((comb/(2->pow(i)))->oclAsType(long)) & 1) = 1) then     make := MathLib.bitwiseAnd(make, (cnt->at(march[i+1]) > 0)) ; else skip )  ;     i := i + 1 ) ; 
    if (not(make)) then (     var x : int ; x := (MathLib.bitwiseAnd(comb,-comb)) ;
    var y : int ; y := comb + x ;
     comb := (((MathLib.bitwiseAnd(comb,-(y + 1))) / x/(2->pow(1)))->oclAsType(long)) or y ; 
     continue ) else skip ; 
    var tmp : long ; tmp := 1 ;
        var i : int ; i := 0 ; while i < 5 do ( (     if ((((comb/(2->pow(i)))->oclAsType(long)) & 1) = 1) then (     tmp := tmp*(cnt->at(march[i+1])->oclAsType(long)) ) else skip )  ;     i := i + 1 ) ; 
    ans := ans+(tmp) ; 
    var x : int ; x := (MathLib.bitwiseAnd(comb,-comb)) ;
    var y : int ; y := comb + x ;
    comb := (((MathLib.bitwiseAnd(comb,-(y + 1))) / x/(2->pow(1)))->oclAsType(long)) or y ; 
 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Escape {
  public static void main(String[] args){
    CustomScanner cs=new CustomScanner();
    int vp=cs.nextInt();
    int vd=cs.nextInt();
    int t=cs.nextInt();
    int f=cs.nextInt();
    int c=cs.nextInt();
    if(vp>=vd){
      System.out.println(0);
      return ;
    }
    double dZeroAndReadyTime=(double)t ;
    double princessPosAtDZero=vp*t ;
    double overtakeTime=dZeroAndReadyTime+(princessPosAtDZero/(vd-vp));
    double overtakePos=(princessPosAtDZero/(vd-vp))*vd ;
    int bizous=0 ;
    while(overtakePos<c){
      bizous++;
      dZeroAndReadyTime=overtakeTime+(f+(overtakePos/vd));
      princessPosAtDZero=dZeroAndReadyTime*vp ;
      overtakePos=(princessPosAtDZero/(vd-vp))*vd ;
      overtakeTime=dZeroAndReadyTime+overtakePos/vd ;
    }
    System.out.println(bizous);
  }
  static class CustomScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=nextInt();
      }
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Escape {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cs : CustomScanner ; cs := CustomScanner.newCustomScanner() ;
     var vp : int ; vp := cs.nextInt() ;
    var vd : int ; vd := cs.nextInt() ;
    var t : int ; t := cs.nextInt() ;
    var f : int ; f := cs.nextInt() ;
    var c : int ; c := cs.nextInt() ;
    if (vp >= vd) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var dZeroAndReadyTime : double ; dZeroAndReadyTime := t->oclAsType(double) ;
    var princessPosAtDZero : double ; princessPosAtDZero := vp * t ;
    var overtakeTime : double ; overtakeTime := dZeroAndReadyTime + (princessPosAtDZero / (vd - vp)) ;
    var overtakePos : double ; overtakePos := (princessPosAtDZero / (vd - vp)) * vd ;
    var bizous : int ; bizous := 0 ;
    while (overtakePos < c) do (     bizous := bizous + 1 ; 
     dZeroAndReadyTime := overtakeTime + (f + (overtakePos / vd)) ; 
    princessPosAtDZero := dZeroAndReadyTime * vp ; 
    overtakePos := (princessPosAtDZero / (vd - vp)) * vd ; 
    overtakeTime := dZeroAndReadyTime + overtakePos / vd ; 
 ) ; 
    OclFile["System.out"].println(bizous) ; 
 );
  static class CustomScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void add_factors(int n,HashMap<Integer,Integer>mp){
    for(int i=1 ; i<=(Math.sqrt(n)); i++){
      if(n % i==0){
        if(n/i==i){
          if(mp.containsKey(i))mp.put(i,mp.get(i)+1);
          else mp.put(i,1);
        }
        else {
          if(mp.containsKey(i))mp.put(i,mp.get(i)+1);
          else mp.put(i,1);
          if(mp.containsKey(n/i))mp.put(n/i,mp.get(n/i)+1);
          else mp.put(n/i,1);
        }
      }
    }
  }
  static void count_divisors(int a[],int n){
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      System.out.print(mp.get(a[i])==null ? 0+" " : mp.get(a[i])+" ");
      add_factors(a[i],mp);
    }
  }
  public static void main(String[] args){
    int arr[]={
      8,1,28,4,2,6,7 };
      int n=arr.length ;
      count_divisors(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation add_factors( n : int, mp : Map(int,int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= ((n)->sqrt()) do ( (     if (n mod i = 0) then (     if (n / i = i) then (     if (mp.containsKey(i)) then     mp := mp->union(Map{i |-> mp->at(i+1) + 1}) ; else     mp := mp->union(Map{i |-> 1}) ; ) else (     if (mp.containsKey(i)) then     mp := mp->union(Map{i |-> mp->at(i+1) + 1}) else     mp := mp->union(Map{i |-> 1}) ; ;  
     if (mp.containsKey(n / i)) then     mp := mp->union(Map{n / i |-> mp->at(n / i+1) + 1}) ; else     mp := mp->union(Map{n / i |-> 1}) ; ) ) else skip )  ;     i := i + 1 ) );
  static   operation count_divisors( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(if mp->at(a[i+1]) = null then 0 + " " else mp->at(a[i+1]) + " " endif) ; 
     execute add_factors(a[i+1], mp) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,1,28,4,2,6,7} ;
     var n : int ; n := arr->size() ;
     execute count_divisors(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long x=sc.nextLong();
    long kosu=0L ;
    long[] ame=new long[N];
    for(int i=0 ; i<N ; i++){
      ame[i]=sc.nextInt();
    }
    long tmp1=0 ;
    long tmp2=0 ;
    if(N>=3){
      for(int i=0 ; i<=N-2 ; i++){
        if(ame[i]+ame[i+1]>x){
          tmp1=ame[i];
          tmp2=ame[i+1];
          if(ame[i]+ame[i+1]-x>ame[i+1]){
            ame[i]=tmp1-x ;
            ame[i+1]=0 ;
            kosu+=(tmp1+tmp2-x);
          }
          else if(ame[i]+ame[i+1]-x<=ame[i+1]){
            ame[i+1]=tmp2-(tmp1+tmp2-x);
            kosu+=(tmp1+tmp2-x);
          }
        }
      }
    }
    else if(N==2){
      kosu=Math.max(ame[0]+ame[1]-x,0);
    }
    System.out.println(kosu);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var x : long ; x := sc.getCurrent()->toLong() ;
    var kosu : long ; kosu := 0L ;
    var ame : Sequence(long) ; ame := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     ame[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var tmp1 : long ; tmp1 := 0 ;
    var tmp2 : long ; tmp2 := 0 ;
    if (N >= 3) then (         var i : int ; i := 0 ; while i <= N - 2 do ( (     if (ame[i+1] + ame[i + 1+1] > x) then (     tmp1 := ame[i+1] ; 
     tmp2 := ame[i + 1+1] ; 
     if (ame[i+1] + ame[i + 1+1] - x > ame[i + 1+1]) then (     ame[i+1] := tmp1 - x ; 
     ame[i + 1+1] := 0 ; 
     kosu := kosu+((tmp1 + tmp2 - x)) ) else     if (ame[i+1] + ame[i + 1+1] - x <= ame[i + 1+1]) then (     ame[i + 1+1] := tmp2 - (tmp1 + tmp2 - x) ; 
     kosu := kosu+((tmp1 + tmp2 - x)) ) else skip ; ) else skip )  ;     i := i + 1 ) ) else     if (N = 2) then (     kosu := Set{ame[0+1] + ame[1+1] - x, 0}->max() ) else skip ; ;  
    OclFile["System.out"].println(kosu) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    BoxesandCandies bc=new BoxesandCandies();
    bc.run();
  }
}
class BoxesandCandies {
  int N ;
  long x ;
  long[] nums ;
  BoxesandCandies(){
    Scanner cin=new Scanner(System.in);
    this.N=cin.nextInt();
    this.x=cin.nextLong();
    this.nums=new long[N];
    for(int i=0 ; i<N ; i++){
      nums[i]=cin.nextLong();
    }
  }
  void run(){
    long count=0 ;
    long prev=nums[0];
    for(int i=1 ; i<N ; i++){
      long next=nums[i];
      if(prev+next>x){
        long sum=prev+next ;
        long k=sum-x ;
        count+=k ;
        nums[i]=Math.max(0,nums[i]-k);
      }
      prev=nums[i];
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bc : BoxesandCandies ; bc := BoxesandCandies.newBoxesandCandies() ;
     bc.run() );
}
class BoxesandCandies {
   attribute N : int;
   attribute x : long;
   attribute nums : Sequence(long);
   static operation newBoxesandCandies() : BoxesandCandies
  pre: true
  post: true
  activity:
  ( var self : BoxesandCandies ;
    self := createBoxesandCandies();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     self.N := cin.getCurrent()->toInteger() ; 
    self.x := cin.getCurrent()->toLong() ; 
    self.nums := Integer.subrange(1,N)->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     nums[i+1] := cin.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
     var prev : long ; prev := nums[0+1] ;
         var i : int ; i := 1 ; while i < N do ( (     var next : long ; next := nums[i+1] ;
     if (prev + next > x) then (     var sum : long ; sum := prev + next ;
     var k : long ; k := sum - x ;
     count := count+(k) ; 
     nums[i+1] := Set{0, nums[i+1] - k}->max() ) else skip ; 
     prev := nums[i+1] )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.reflect.Array ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int x=sc.nextInt();
    long ans=0 ;
    int a[]=new int[N+2];
    a[0]=0 ;
    a[N+1]=0 ;
    for(int i=1 ; i<=N ; i++){
      a[i]=sc.nextInt();
    }
    for(int j=1 ; j<=N-1 ; j++){
      if(a[j]+a[j+1]>x){
        if(a[j]<=x){
          ans=ans+(a[j+1]-(x-a[j]));
          a[j+1]=x-a[j];
        }
        else {
          ans=ans+(a[j]-x)+(a[j+1]);
          a[j]=x ;
          a[j+1]=0 ;
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var ans : long ; ans := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,N + 2)->collect(0) ;
    a[0+1] := 0 ; 
    a[N + 1+1] := 0 ; 
        var i : int ; i := 1 ; while i <= N do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var j : int ; j := 1 ; while j <= N - 1 do ( (     if (a[j+1] + a[j + 1+1] > x) then (     if (a[j+1] <= x) then (     ans := ans + (a[j + 1+1] - (x - a[j+1])) ; 
     a[j + 1+1] := x - a[j+1] ) else (     ans := ans + (a[j+1] - x) + (a[j + 1+1]) ; 
     a[j+1] := x ; 
     a[j + 1+1] := 0 ) ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findLength(String str){
    int n=str.length();
    int maxlen=0 ;
    int sum[][]=new int[n][n];
    for(int i=0 ; i<n ; i++)sum[i][i]=str.charAt(i)-'0' ;
    for(int len=2 ; len<=n ; len++){
      for(int i=0 ; i<n-len+1 ; i++){
        int j=i+len-1 ;
        int k=len/2 ;
        sum[i][j]=sum[i][j-k]+sum[j-k+1][j];
        if(len % 2==0 && sum[i][j-k]==sum[(j-k+1)][j] && len>maxlen)maxlen=len ;
      }
    }
    return maxlen ;
  }
  public static void main(String[] args){
    String str="153803" ;
    System.out.println("Length of the substring is "+findLength(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findLength( str : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var maxlen : int ; maxlen := 0 ;
    var sum : Sequence(Sequence(int)) ; sum := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do (     sum[i+1][i+1] := str->at(i+1) - ('0')->char2byte() ;  ;     i := i + 1 ) ; 
        var len : int ; len := 2 ; while len <= n do ( (         var i : int ; i := 0 ; while i < n - len + 1 do ( (     var j : int ; j := i + len - 1 ;
     var k : int ; k := len / 2 ;
     sum[i+1][j+1] := sum[i+1][j - k+1] + sum[j - k + 1+1][j+1] ; 
     if (len mod 2 = 0 & sum[i+1][j - k+1] = sum[(j - k + 1)+1][j+1] & len > maxlen) then     maxlen := len ; else skip )  ;     i := i + 1 ) )  ;     len := len + 1 ) ; 
    return maxlen 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "153803" ;
     OclFile["System.out"].println("Length of the substring is " + findLength(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static long countSubstr(String s,int k){
    int n=s.length();
    int l=n-1 ;
    int r=n-1 ;
    int[] arr=new int[n];
    int last_indexof1=-1 ;
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='1'){
        arr[i]=i ;
        last_indexof1=i ;
      }
      else {
        arr[i]=last_indexof1 ;
      }
    }
    long no_of_substr=0 ;
    for(r=n-1 ; r>=0 ; r--){
      l=r ;
      while(l>=0 &&(r-l+1)<=64 && Integer.valueOf(s.substring(l,r+1),2)<k){
        l--;
      }
      if(r-l+1<=64)no_of_substr+=l+1 ;
      else {
        no_of_substr+=arr[l+1]+1 ;
      }
    }
    return no_of_substr ;
  }
  public static void main(String[] args){
    String s="11100" ;
    int k=3 ;
    System.out.println(countSubstr(s,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSubstr( s : String, k : int) : long
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var l : int ; l := n - 1 ;
    var r : int ; r := n - 1 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var last_indexof1 : int ; last_indexof1 := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = '1') then (     arr[i+1] := i ; 
     last_indexof1 := i ) else (     arr[i+1] := last_indexof1 ) )  ;     i := i + 1 ) ; 
    var no_of_substr : long ; no_of_substr := 0 ;
        r := n - 1 ; while r >= 0 do ( (     l := r ; 
     while (l >= 0 & (r - l + 1) <= 64 & (s.subrange(l+1,r + 1))->toInteger() < k) do (     l := l - 1 ) ; 
     if (r - l + 1 <= 64) then     no_of_substr := no_of_substr+(l + 1) ; else (     no_of_substr := no_of_substr+(arr[l + 1+1] + 1) ) )  ;     r := r - 1 ) ; 
    return no_of_substr 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "11100" ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println(countSubstr(s, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int DP_s=9 ;
  static int getNumStrictMonotone(int len){
    int[][] DP=new int[len][DP_s];
    for(int i=0 ; i<DP_s ; ++i)DP[0][i]=i+1 ;
    for(int i=1 ; i<len ; ++i)for(int j=1 ; j<DP_s ; ++j)DP[i][j]=DP[i-1][j-1]+DP[i][j-1];
    return DP[len-1][DP_s-1];
  }
  public static void main(String[] args){
    int n=2 ;
    System.out.println(getNumStrictMonotone(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute DP_s : int := 9;
  static   operation getNumStrictMonotone( len : int) : int
  pre: true
  post: true
  activity: (     var DP : Sequence(Sequence(int)) ; DP := Integer.subrange(1,len)->collect(Integer.subrange(1,DP_s)->collect(0)) ;
         var i : int ; i := 0 ; while i < DP_s do (     DP[0+1][i+1] := i + 1 ;  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i < len do (         var j : int ; j := 1 ; while j < DP_s do (     DP[i+1][j+1] := DP[i - 1+1][j - 1+1] + DP[i+1][j - 1+1] ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return DP[len - 1+1][DP_s - 1+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(getNumStrictMonotone(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void numberOfSubarrays(int arr[],int n){
    int[] v=new int[n+1];
    v[0]=0 ;
    for(int i=0 ; i<n ; i++){
      v[i+1]=v[i]+arr[i];
    }
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    int begin=0,end=0,answer=0 ;
    mp.put(0,1);
    while(begin<n){
      while(end<n && ! mp.containsKey(v[end+1])){
        end++;
        mp.put(v[end],1);
      }
      answer=answer+end-begin ;
      mp.remove(v[begin]);
      begin++;
    }
    System.out.print(answer+"\n");
  }
  public static void main(String[] args){
    int arr[]={
      2,4,-6 };
      int size=arr.length ;
      numberOfSubarrays(arr,size);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation numberOfSubarrays( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Integer.subrange(1,n + 1)->collect(0) ;
     v[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     v[i + 1+1] := v[i+1] + arr[i+1] )  ;     i := i + 1 ) ; 
    var mp : Map(int,int) ; mp := Map{} ;
    var begin : int ; begin := 0 ;
    var end : int ; end := 0 ;
    var answer : int ; answer := 0 ;
    mp := mp->union(Map{0 |-> 1}) ; 
    while (begin < n) do (     while (end < n & not(mp->keys()->includes(v[end + 1+1]))) do (     end := end + 1 ; 
     mp := mp->union(Map{v[end+1] |-> 1}) ) ; 
     answer := answer + end - begin ; 
     mp := mp->antirestrict(Set{v[begin+1]}) ; 
     begin := begin + 1 ) ; 
    OclFile["System.out"].print(answer + "\n") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,-6} ;
     var size : int ; size := arr->size() ;
     execute numberOfSubarrays(arr, size) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.time.LocalTime ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    String[] s=sc.next().split(":");
    String[] t=sc.next().split(":");
    LocalTime x=LocalTime.of(Integer.parseInt(s[0]),Integer.parseInt(s[1]));
    LocalTime y=LocalTime.of(Integer.parseInt(t[0]),Integer.parseInt(t[1]));
    System.out.println(x.minusHours(y.getHour()).minusMinutes(y.getMinute()));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc.getCurrent()->split(":") ;
    var t : Sequence(String) ; t := sc.getCurrent()->split(":") ;
    var x : LocalTime ; x := LocalTime.of((s[0+1])->toInteger(), (s[1+1])->toInteger()) ;
    var y : LocalTime ; y := LocalTime.of((t[0+1])->toInteger(), (t[1+1])->toInteger()) ;
    OclFile["System.out"].println(x.minusHours(y.getHour()).minusMinutes(y.getMinute())) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class C181A {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int row=Integer.parseInt(st.nextToken());
    int col=Integer.parseInt(st.nextToken());
    char[][] mat=new char[row][col];
    for(int r=0 ; r<row ; r++){
      String line=br.readLine();
      for(int c=0 ; c<col ; c++)mat[r][c]=line.charAt(c);
    }
    int ans_row=0,ans_col=0 ;
    for(int r=0 ; r<row ; r++){
      int cnt=0 ;
      for(int c=0 ; c<col ; c++)if(mat[r][c]=='*')cnt++;
      if(cnt==1)ans_row=r+1 ;
    }
    for(int c=0 ; c<col ; c++){
      int cnt=0 ;
      for(int r=0 ; r<row ; r++)if(mat[r][c]=='*')cnt++;
      if(cnt==1)ans_col=c+1 ;
    }
    System.out.println(ans_row+" "+ans_col);
  }
}
------------------------------------------------------------
OCL File:
---------
 class C181A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var row : int ; row := (st.next())->toInteger() ;
    var col : int ; col := (st.next())->toInteger() ;
    var mat : Sequence(Sequence(String)) ; mat := Integer.subrange(1,row)->collect(Integer.subrange(1,col)->collect(0)) ;
        var r : int ; r := 0 ; while r < row do ( (     var line : String ; line := br.readLine() ;
         var c : int ; c := 0 ; while c < col do (     mat[r+1][c+1] := line->at(c+1) ;  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    var ans_row : int ; ans_row := 0 ;
    var ans_col : int ; ans_col := 0 ;
        var r : int ; r := 0 ; while r < row do ( (     var cnt : int ; cnt := 0 ;
         var c : int ; c := 0 ; while c < col do (     if (mat[r+1][c+1] = '*') then     cnt := cnt + 1 ; else skip ;  ;     c := c + 1 ) ; 
     if (cnt = 1) then     ans_row := r + 1 ; else skip )  ;     r := r + 1 ) ; 
        var c : int ; c := 0 ; while c < col do ( (     var cnt : int ; cnt := 0 ;
         var r : int ; r := 0 ; while r < row do (     if (mat[r+1][c+1] = '*') then     cnt := cnt + 1 ; else skip ;  ;     r := r + 1 ) ; 
     if (cnt = 1) then     ans_col := c + 1 ; else skip )  ;     c := c + 1 ) ; 
    OclFile["System.out"].println(ans_row + " " + ans_col) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class LectureSleep {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),k=in.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=in.nextLong();
    int[] t=new int[n];
    for(int i=0 ; i<n ; i++)t[i]=in.nextInt();
    pw.println(solve(a,t,n,k));
    pw.close();
  }
  static long solve(long[] a,int[] t,int n,int k){
    long[] dp=new long[n];
    for(int i=0 ; i<n ; i++)dp[i]=(t[i]==0)? a[i] : 0 ;
    long ans=0 ;
    for(int i=0 ; i<n ; i++)if(t[i]!=0)ans+=a[i];
    long sum=0 ;
    for(int i=0 ; i<k ; i++)sum+=dp[i];
    long max=sum ;
    for(int i=k,j=0 ; i<n ; i++,j++){
      sum-=dp[j];
      sum+=dp[i];
      max=Math.max(max,sum);
    }
    return ans+max ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class LectureSleep {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     t[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( a : Sequence(long), t : Sequence(int), n : int, k : int) : long
  pre: true
  post: true
  activity: (     var dp : Sequence(long) ; dp := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     dp[i+1] := if (t[i+1] = 0) then a[i+1] else 0 endif ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (t[i+1] /= 0) then     ans := ans+(a[i+1]) ; else skip ;  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < k do (     sum := sum+(dp[i+1]) ;  ;     i := i + 1 ) ; 
    var max : long ; max := sum ;
        var i : int ; i := k ;
    var j : int ; j := 0 ; while i < n do ( (     sum := sum-(dp[j+1]) ; 
     sum := sum+(dp[i+1]) ; 
     max := Set{max, sum}->max() )  ;     i := i + 1 ;     j := j + 1 ) ; 
    return ans + max 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CustomClass {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    sc.nextLine();
    char arr[][]=new char[n][m];
    int col[]=new int[m];
    int row[]=new int[n];
    for(int i=0 ; i<n ; i++){
      char s[]=sc.nextLine().toCharArray();
      for(int j=0 ; j<m ; j++){
        arr[i][j]=s[j];
        if(arr[i][j]=='*'){
          row[i]++;
          col[j]++;
        }
      }
    }
    for(int i=0 ; i<row.length ; i++){
      if(row[i]==1){
        System.out.print((i+1)+" ");
        break ;
      }
    }
    for(int i=0 ; i<col.length ; i++){
      if(col[i]==1){
        System.out.print((i+1)+" ");
        break ;
      }
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CustomClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    skip ; 
    var arr : Sequence(Sequence(String)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var col : Sequence(int) ; col := Integer.subrange(1,m)->collect(0) ;
    var row : Sequence(int) ; row := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var s : Sequence(String) ; s := sc.nextLine()->characters() ;
         var j : int ; j := 0 ; while j < m do ( (     arr[i+1][j+1] := s[j+1] ; 
     if (arr[i+1][j+1] = '*') then (     row[i+1] := row[i+1] + 1 ; 
     col[j+1] := col[j+1] + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < row->size() do ( (     if (row[i+1] = 1) then (     OclFile["System.out"].print((i + 1) + " ") ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < col->size() do ( (     if (col[i+1] = 1) then (     OclFile["System.out"].print((i + 1) + " ") ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findMax(int[] a,int n){
    int dp[][]=new int[n][2];
    int i,j ;
    for(i=0 ; i<n ; i++)for(j=0 ; j<2 ; j++)dp[i][j]=0 ;
    dp[0][0]=a[0]+a[1];
    dp[0][1]=a[0]*a[1];
    for(i=1 ; i<=n-2 ; i++){
      dp[i][0]=Math.max(dp[i-1][0],dp[i-1][1])+a[i+1];
      dp[i][1]=dp[i-1][0]-a[i]+a[i]*a[i+1];
    }
    System.out.println(Math.max(dp[n-2][0],dp[n-2][1]));
  }
  public static void main(String[] args){
    int arr[]={
      5,-1,-5,-3,2,9,-4 };
      findMax(arr,7);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMax( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
     var i : int ;
    var j : int ;
        i := 0 ; while i < n do (         j := 0 ; while j < 2 do (     dp[i+1][j+1] := 0 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := a[0+1] + a[1+1] ; 
    dp[0+1][1+1] := a[0+1] * a[1+1] ; 
        i := 1 ; while i <= n - 2 do ( (     dp[i+1][0+1] := Set{dp[i - 1+1][0+1], dp[i - 1+1][1+1]}->max() + a[i + 1+1] ; 
     dp[i+1][1+1] := dp[i - 1+1][0+1] - a[i+1] + a[i+1] * a[i + 1+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{dp[n - 2+1][0+1], dp[n - 2+1][1+1]}->max()) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,-1,-5,-3,2,9,-4} ;
     execute findMax(arr, 7) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static class Pair {
    int min ;
    int max ;
  }
  static Pair getMinMax(int arr[],int n){
    Pair minmax=new Pair();
    int i ;
    if(n==1){
      minmax.max=arr[0];
      minmax.min=arr[0];
      return minmax ;
    }
    if(arr[0]>arr[1]){
      minmax.max=arr[0];
      minmax.min=arr[1];
    }
    else {
      minmax.max=arr[1];
      minmax.min=arr[0];
    }
    for(i=2 ; i<n ; i++){
      if(arr[i]>minmax.max){
        minmax.max=arr[i];
      }
      else if(arr[i]<minmax.min){
        minmax.min=arr[i];
      }
    }
    return minmax ;
  }
  public static void main(String args[]){
    int arr[]={
      1000,11,445,1,330,3000 };
      int arr_size=6 ;
      Pair minmax=getMinMax(arr,arr_size);
      System.out.printf("\nMinimum element is %d",minmax.min);
      System.out.printf("\nMaximum element is %d",minmax.max);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Pair {
   attribute min : int;
   attribute max : int;
}
  static   operation getMinMax( arr : Sequence(int), n : int) : Map
  pre: true
  post: true
  activity: (     var minmax : Map ; minmax := Map() ;
     var i : int ;
    if (n = 1) then (     minmax.max := arr[0+1] ; 
     minmax.min := arr[0+1] ; 
     return minmax ) else skip ; 
    if (arr[0+1] > arr[1+1]) then (     minmax.max := arr[0+1] ; 
     minmax.min := arr[1+1] ) else (     minmax.max := arr[1+1] ; 
     minmax.min := arr[0+1] ) ;  
        i := 2 ; while i < n do ( (     if (arr[i+1] > minmax.max) then (     minmax.max := arr[i+1] ) else     if (arr[i+1] < minmax.min) then (     minmax.min := arr[i+1] ) else skip ; )  ;     i := i + 1 ) ; 
    return minmax 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1000,11,445,1,330,3000} ;
     var arr_size : int ; arr_size := 6 ;
    var minmax : Map ; minmax := getMinMax(arr, arr_size) ;
    OclFile["System.out"].printf("\nMinimum element is %d", minmax.min) ; 
    OclFile["System.out"].printf("\nMaximum element is %d", minmax.max) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static class Pair {
    int min ;
    int max ;
  }
  static Pair getMinMax(int arr[],int n){
    Pair minmax=new Pair();
    int i ;
    if(n % 2==0){
      if(arr[0]>arr[1]){
        minmax.max=arr[0];
        minmax.min=arr[1];
      }
      else {
        minmax.min=arr[0];
        minmax.max=arr[1];
      }
      i=2 ;
    }
    else {
      minmax.min=arr[0];
      minmax.max=arr[0];
      i=1 ;
    }
    while(i<n-1){
      if(arr[i]>arr[i+1]){
        if(arr[i]>minmax.max){
          minmax.max=arr[i];
        }
        if(arr[i+1]<minmax.min){
          minmax.min=arr[i+1];
        }
      }
      else {
        if(arr[i+1]>minmax.max){
          minmax.max=arr[i+1];
        }
        if(arr[i]<minmax.min){
          minmax.min=arr[i];
        }
      }
      i+=2 ;
    }
    return minmax ;
  }
  public static void main(String args[]){
    int arr[]={
      1000,11,445,1,330,3000 };
      int arr_size=6 ;
      Pair minmax=getMinMax(arr,arr_size);
      System.out.printf("\nMinimum element is %d",minmax.min);
      System.out.printf("\nMaximum element is %d",minmax.max);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Pair {
   attribute min : int;
   attribute max : int;
}
  static   operation getMinMax( arr : Sequence(int), n : int) : Map
  pre: true
  post: true
  activity: (     var minmax : Map ; minmax := Map() ;
     var i : int ;
    if (n mod 2 = 0) then (     if (arr[0+1] > arr[1+1]) then (     minmax.max := arr[0+1] ; 
     minmax.min := arr[1+1] ) else (     minmax.min := arr[0+1] ; 
     minmax.max := arr[1+1] ) ;  
     i := 2 ) else (     minmax.min := arr[0+1] ; 
     minmax.max := arr[0+1] ; 
     i := 1 ) ;  
    while (i < n - 1) do (     if (arr[i+1] > arr[i + 1+1]) then (     if (arr[i+1] > minmax.max) then (     minmax.max := arr[i+1] ) else skip ; 
     if (arr[i + 1+1] < minmax.min) then (     minmax.min := arr[i + 1+1] ) else skip ) else (     if (arr[i + 1+1] > minmax.max) then (     minmax.max := arr[i + 1+1] ) else skip ; 
     if (arr[i+1] < minmax.min) then (     minmax.min := arr[i+1] ) else skip ) ;  
     i := i+(2) ) ; 
    return minmax 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1000,11,445,1,330,3000} ;
     var arr_size : int ; arr_size := 6 ;
    var minmax : Map ; minmax := getMinMax(arr, arr_size) ;
    OclFile["System.out"].printf("\nMinimum element is %d", minmax.min) ; 
    OclFile["System.out"].printf("\nMaximum element is %d", minmax.max) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findpair(int l,int r){
    int ans1=l ;
    int ans2=2*l ;
    System.out.println(ans1+","+ans2);
  }
  public static void main(String args[]){
    int l=1,r=10 ;
    findpair(l,r);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findpair( l : int, r : int) : void
  pre: true
  post: true
  activity: (     var ans1 : int ; ans1 := l ;
     var ans2 : int ; ans2 := 2 * l ;
     OclFile["System.out"].println(ans1 + "," + ans2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 1 ;
    var r : int ; r := 10 ;
     execute findpair(l, r) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int binarysearch(Vector<Integer>v,int x){
    int low=0,high=v.size()-1 ;
    while(low<=high){
      int mid=(low+high)/2 ;
      if(v.get(mid)<=x)low=mid+1 ;
      else if(v.get(mid)>x && v.get(mid)<=x)return mid ;
      else if(v.get(mid)>x && mid==0)return mid ;
      else high=mid-1 ;
    }
    return-1 ;
  }
  static int CountContiguousParts(int arr[],int n){
    int count=0 ;
    int[] prefix=new int[n];
    prefix[0]=arr[0];
    for(int i=1 ; i<n ; i++)prefix[i]=prefix[i-1]+arr[i];
    int total_sum=prefix[n-1];
    if(total_sum % 3!=0)return 0 ;
    int[] suffix=new int[n];
    suffix[n-1]=arr[n-1];
    for(int i=n-2 ; i>=0 ; i--)suffix[i]=suffix[i+1]+arr[i];
    Vector<Integer>v=new Vector<>();
    for(int i=0 ; i<n ; i++)if(suffix[i]==total_sum/3)v.add(i);
    for(int i=0 ; i<n ; i++){
      if(prefix[i]==total_sum/3){
        int res=binarysearch(v,i+1);
        if(res!=-1)count+=v.size()-res ;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,0,3 };
      int n=arr.length ;
      System.out.println(CountContiguousParts(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation binarysearch( v : Sequence(int), x : int) : int
  pre: true
  post: true
  activity: (     var low : int ; low := 0 ;
    var high : int ; high := v->size() - 1 ;
     while (low <= high) do (     var mid : int ; mid := (low + high) / 2 ;
     if (v->at(mid+1) <= x) then     low := mid + 1 ; else     if (v->at(mid+1) > x & v->at(mid+1) <= x) then     return mid else     if (v->at(mid+1) > x & mid = 0) then     return mid else     high := mid - 1 ; ;  ;  ) ; 
     return -1 );
  static   operation CountContiguousParts( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var prefix : Sequence(int) ; prefix := Integer.subrange(1,n)->collect(0) ;
    prefix[0+1] := arr[0+1] ; 
        var i : int ; i := 1 ; while i < n do (     prefix[i+1] := prefix[i - 1+1] + arr[i+1] ;  ;     i := i + 1 ) ; 
    var total_sum : int ; total_sum := prefix[n - 1+1] ;
    if (total_sum mod 3 /= 0) then     return 0 else skip ; 
    var suffix : Sequence(int) ; suffix := Integer.subrange(1,n)->collect(0) ;
    suffix[n - 1+1] := arr[n - 1+1] ; 
        var i : int ; i := n - 2 ; while i >= 0 do (     suffix[i+1] := suffix[i + 1+1] + arr[i+1] ;  ;     i := i - 1 ) ; 
    var v : Sequence(int) ; v := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     if (suffix[i+1] = total_sum / 3) then     v := v->including(i) ; else skip ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (prefix[i+1] = total_sum / 3) then (     var res : int ; res := binarysearch(v, i + 1) ;
     if (res /= -1) then     count := count+(v->size() - res) ; else skip ) else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,0,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(CountContiguousParts(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    SortedSet<Integer>ss=new TreeSet<>();
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      for(int i=0 ; i<n ; i++){
        int k=sc.nextInt();
        if(k % 2==0)ss.add(k);
      }
      int res=0 ;
      while(! ss.isEmpty()){
        res+=1 ;
        int x=ss.last();
        ss.remove(x);
        x/=2 ;
        if(x % 2==0)ss.add(x);
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ss : Set(int) ; ss := Set{} ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var k : int ; k := sc.getCurrent()->toInteger() ;
     if (k mod 2 = 0) then     ss := ss->including(k) ; else skip )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    while (not(ss->isEmpty())) do (     res := res+(1) ; 
     var x : int ; x := ss->last() ;
    ss := ss->excludingAt(x+1) ; 
    x := x/(2) ; 
    if (x mod 2 = 0) then     ss := ss->including(x) ; else skip ; 
 ) ; 
    OclFile["System.out"].println(res) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int longestAlternatingSubarray(int a[],int n){
    int longest=1 ;
    int cnt=1 ;
    for(int i=1 ; i<n ; i++){
      if(a[i]*a[i-1]<0){
        cnt++;
        longest=Math.max(longest,cnt);
      }
      else cnt=1 ;
    }
    return longest ;
  }
  public static void main(String[] args){
    int a[]={
-5,-1,-1,2,-2,-3 };
      int n=a.length ;
      System.out.println(longestAlternatingSubarray(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation longestAlternatingSubarray( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var longest : int ; longest := 1 ;
     var cnt : int ; cnt := 1 ;
         var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] * a[i - 1+1] < 0) then (     cnt := cnt + 1 ; 
     longest := Set{longest, cnt}->max() ) else     cnt := 1 ; )  ;     i := i + 1 ) ; 
     return longest );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{-5,-1,-1,2,-2,-3} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(longestAlternatingSubarray(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; tc++){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; i++){
        a[i]=sc.nextInt();
      }
      System.out.println(solve(a));
    }
    sc.close();
  }
  static int solve(int[] a){
    Map<Integer,Integer>remainToMoveNum=new HashMap<>();
    for(int ai : a){
      int remain=ai ;
      int moveNum=0 ;
      while(remain % 2==0){
        remain/=2 ;
        moveNum++;
      }
      remainToMoveNum.put(remain,Math.max(remainToMoveNum.getOrDefault(remain,0),moveNum));
    }
    return remainToMoveNum.values().stream().mapToInt(x->x).sum();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(solve(a)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var remainToMoveNum : Map(int,int) ; remainToMoveNum := Map{} ;
     for (ai : a) do ( (     var remain : int ; remain := ai ;
     var moveNum : int ; moveNum := 0 ;
     while (remain mod 2 = 0) do (     remain := remain/(2) ; 
     moveNum := moveNum + 1 ) ; 
     remainToMoveNum := remainToMoveNum->union(Map{remain |-> Set{(if remainToMoveNum->keys()->contains(remain) then remainToMoveNum->at(remain) else 0 endif), moveNum}->max()}) )  ) ; 
     return remainToMoveNum->values()->collect( _x1 | (lambda x : OclAny in x)->apply(_x1) )->sum() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.nio.Buffer ;
import java.util.*;
public class Main2 {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int testCases=sc.nextInt();
    while(testCases-->0){
      int n=sc.nextInt();
      Integer[] array=new Integer[n];
      HashSet<Integer>set=new HashSet<>();
      for(int i=0 ; i<array.length ; i++){
        array[i]=sc.nextInt();
        set.add(array[i]);
      }
      Arrays.sort(array);
      long ans=0 ;
      for(int i=array.length-1 ; i>=0 ; i--){
        int number=array[i];
        if(! set.contains(number))continue ;
        while(number % 2==0){
          set.remove(number);
          ans++;
          number=number/2 ;
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := sc.getCurrent()->toInteger() ;
         while (testCases > 0) do (        testCases := testCases - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(null) ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < array->size() do ( (     array[i+1] := sc.getCurrent()->toInteger() ; 
     set := set->including(array[i+1]) )  ;     i := i + 1 ) ; 
    array := array->sort() ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := array->size() - 1 ; while i >= 0 do ( (     var number : int ; number := array[i+1] ;
     if (not(set->includes(number))) then     continue else skip ; 
     while (number mod 2 = 0) do (     set := set->excludingAt(number+1) ; 
     ans := ans + 1 ; 
     number := number / 2 ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class LectureSleep {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),k=in.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=in.nextLong();
    int[] t=new int[n];
    for(int i=0 ; i<n ; i++)t[i]=in.nextInt();
    pw.println(solve(a,t,n,k));
    pw.close();
  }
  static long solve(long[] a,int[] t,int n,int k){
    ArrayList<Long>ls=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      if(t[i]==0)ls.add(a[i]);
      else ls.add(0L);
    }
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(t[i]!=0)sum+=a[i];
    }
    int cnt=0 ;
    long max=0 ;
    long val=0 ;
    int minus=1 ;
    for(int i=ls.size()-1 ; i>=0 ; i--){
      max+=ls.get(i);
      cnt++;
      if(cnt==k){
        val=Math.max(val,max);
        cnt--;
        max-=ls.get(ls.size()-minus);
        minus++;
      }
    }
    val=Math.max(max,val);
    return sum+val ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class LectureSleep {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     t[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( a : Sequence(long), t : Sequence(int), n : int, k : int) : long
  pre: true
  post: true
  activity: (     var ls : Sequence(long) ; ls := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (t[i+1] = 0) then     ls := ls->including(a[i+1]) ; else     ls := ls->including(0L) ; )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (t[i+1] /= 0) then     sum := sum+(a[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    var max : long ; max := 0 ;
    var val : long ; val := 0 ;
    var minus : int ; minus := 1 ;
        var i : int ; i := ls->size() - 1 ; while i >= 0 do ( (     max := max+(ls->at(i+1)) ; 
     cnt := cnt + 1 ; 
     if (cnt = k) then (     val := Set{val, max}->max() ; 
     cnt := cnt - 1 ; 
     max := max-(ls->at(ls->size() - minus+1)) ; 
     minus := minus + 1 ) else skip )  ;     i := i - 1 ) ; 
    val := Set{max, val}->max() ; 
    return sum + val 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.*;
public class D {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    TreeSet<Integer>ts1=new TreeSet<>();
    while(t-->0){
      int n=sc.nextInt();
      TreeSet<Integer>ts=new TreeSet<>();
      for(int i=0 ; i<n ; i++){
        int num=sc.nextInt();
        if(num % 2==0){
          ts.add(-num);
          ts1.add(-num);
        }
      }
      int moves=0 ;
      for(int num : ts1){
        if(ts.contains(num)){
          while(num % 2==0){
            boolean isThere=ts.remove(num);
            if(isThere)moves++;
            num/=2 ;
            ts.add(num);
          }
        }
      }
      System.out.println(moves);
    }
  }
  static ArrayList<Integer>primeFactors(int n){
    ArrayList<Integer>factors=new ArrayList<>();
    for(int j=2 ; j*j<=n ; j++){
      while(n>1 && n % j==0){
        factors.add(j);
        n/=j ;
      }
    }
    if(n!=1)factors.add(n);
    return factors ;
  }
  static BitSet sieve(int n){
    BitSet bs=new BitSet(n+1);
    bs.flip(0,n);
    double sqrtN=Math.ceil(Math.sqrt(n));
    bs.set(2,true);
    for(int i=4 ; i<n+1 ; i+=2){
      bs.set(i,false);
    }
    for(int i=3 ; i<sqrtN ; i+=2){
      if(bs.get(i))for(int j=i*i ;
      j<n+1 ;
      j=j+i){
        bs.set(j,false);
      }
    }
    return bs ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     var ts1 : Set(int) ; ts1 := Set{} ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ts : Set(int) ; ts := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := sc.getCurrent()->toInteger() ;
     if (num mod 2 = 0) then (     ts := ts->including(-num) ; 
     ts1 := ts1->including(-num) ) else skip )  ;     i := i + 1 ) ; 
    var moves : int ; moves := 0 ;
    for (num : ts1) do ( (     if (ts->includes(num)) then (     while (num mod 2 = 0) do (     var isThere : boolean ; isThere := ts->at(num+1) ;
     if (isThere) then     moves := moves + 1 ; else skip ; 
     num := num/(2) ; 
     ts := ts->including(num) ) ) else skip )  ) ; 
    OclFile["System.out"].println(moves) ; 
 ) ;  ) );
  static   operation primeFactors( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var factors : Sequence(int) ; factors := Sequence{} ;
         var j : int ; j := 2 ; while j * j <= n do ( (     while (n > 1 & n mod j = 0) do (     factors := factors->including(j) ; 
     n := n/(j) ) )  ;     j := j + 1 ) ; 
     if (n /= 1) then     factors := factors->including(n) ; else skip ; 
     return factors );
  static   operation sieve( n : int) : Sequence(boolean)
  pre: true
  post: true
  activity: (     var bs : Sequence(boolean) ; bs := MathLib.toBitSequence(n + 1) ;
     bs := bs.flip(0, n) ; 
    var sqrtN : double ; sqrtN := ((n)->sqrt())->ceil() ;
    bs := bs.setAt(2+1,true) ; 
        var i : int ; i := 4 ; while i < n + 1 do ( (     bs := bs.setAt(i+1,false) )  ;     i := i+(2) ) ; 
        var i : int ; i := 3 ; while i < sqrtN do ( (     if (bs->at(i+1)) then         var j : int ; j := i * i ; while j < n + 1 do ( (     bs := bs.setAt(j+1,false) )  ;     j := j + i ) ; else skip )  ;     i := i+(2) ) ; 
    return bs 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public boolean isRectangleOverlap(int[] rec1,int[] rec2){
    return(Math.min(rec1[2],rec2[2])>Math.max(rec1[0],rec2[0])&& Math.min(rec1[3],rec2[3])>Math.max(rec1[1],rec2[1]));
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation isRectangleOverlap( rec1 : Sequence(int), rec2 : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     return (Set{rec1[2+1], rec2[2+1]}->min() > Set{rec1[0+1], rec2[0+1]}->max() & Set{rec1[3+1], rec2[3+1]}->min() > Set{rec1[1+1], rec2[1+1]}->max()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class pair {
    int first,second ;
    public pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static int digitSum(int n){
    int sum=0 ;
    while(n>0){
      sum+=n % 10 ;
      n=n/10 ;
    }
    return sum ;
  }
  static int totalPairs(int arr1[],int arr2[],int n,int m){
    Set<pair>s=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(digitSum(arr1[i])==digitSum(arr2[j])){
          if(arr1[i]<arr2[j])s.add(new pair(arr1[i],arr2[j]));
          else s.add(new pair(arr2[j],arr1[i]));
        }
      }
    }
    return s.size();
  }
  public static void main(String[] args){
    int arr1[]={
      100,3,7,50 };
      int arr2[]={
        5,1,10,4 };
        int n=arr1.length ;
        int m=arr2.length ;
        System.out.println(totalPairs(arr1,arr2,n,m));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class pair {
   attribute first : int;
   static operation newpair( first : int, second : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation digitSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n > 0) do (     sum := sum+(n mod 10) ; 
     n := n / 10 ) ; 
     return sum );
  static   operation totalPairs( arr1 : Sequence(int), arr2 : Sequence(int), n : int, m : int) : int
  pre: true
  post: true
  activity: (     var s : Set(pair) ; s := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (digitSum(arr1[i+1]) = digitSum(arr2[j+1])) then (     if (arr1[i+1] < arr2[j+1]) then     s := s->including(pair.newpair(arr1[i+1], arr2[j+1])) ; else     s := s->including(pair.newpair(arr2[j+1], arr1[i+1])) ; ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return s->size() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{100,3,7,50} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{5,1,10,4} ;
    var n : int ; n := arr1->size() ;
    var m : int ; m := arr2->size() ;
    OclFile["System.out"].println(totalPairs(arr1, arr2, n, m)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class pair {
    int first,second ;
    public pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static int totalPairs(int[] arr1,int[] arr2,int K,int n,int m){
    HashSet<pair>s=new HashSet<pair>();
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(arr1[i]>arr2[j]){
          if(arr1[i] % arr2[j]==K)s.add(new pair(arr1[i],arr2[j]));
        }
        else {
          if(arr2[j] % arr1[i]==K)s.add(new pair(arr2[j],arr1[i]));
        }
      }
    }
    return s.size();
  }
  public static void main(String[] args){
    int[] arr1={
      8,3,7,50 };
      int[] arr2={
        5,1,10,4 };
        int K=3 ;
        int n=arr1.length ;
        int m=arr2.length ;
        System.out.println(totalPairs(arr1,arr2,K,n,m));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class pair {
   attribute first : int;
   static operation newpair( first : int, second : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation totalPairs( arr1 : Sequence(int), arr2 : Sequence(int), K : int, n : int, m : int) : int
  pre: true
  post: true
  activity: (     var s : Set(pair) ; s := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (arr1[i+1] > arr2[j+1]) then (     if (arr1[i+1] mod arr2[j+1] = K) then     s := s->including(pair.newpair(arr1[i+1], arr2[j+1])) ; else skip ) else (     if (arr2[j+1] mod arr1[i+1] = K) then     s := s->including(pair.newpair(arr2[j+1], arr1[i+1])) ; else skip ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return s->size() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{8,3,7,50} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{5,1,10,4} ;
    var K : int ; K := 3 ;
    var n : int ; n := arr1->size() ;
    var m : int ; m := arr2->size() ;
    OclFile["System.out"].println(totalPairs(arr1, arr2, K, n, m)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    double[][] p=new double[n][3];
    for(int i=0 ; i<n ; i++){
      p[i][0]=sc.nextDouble();
      p[i][1]=sc.nextDouble();
      p[i][2]=sc.nextDouble();
    }
    double ans=0 ;
    for(int i=0 ; i<1<<n ; i++){
      if(Integer.bitCount(i)!=m)continue ;
      ans=Math.max(ans,a(p,i));
    }
    System.out.println(ans);
  }
  static double a(double[][] p,int bit){
    int[] num=new int[Integer.bitCount(bit)];
    int cnt=0 ;
    for(int i=0 ; bit!=0 ; i++){
      if(bit % 2==1){
        num[cnt]=i ;
        cnt++;
      }
      bit=bit>>1 ;
    }
    double res=0.0 ;
    for(int i=0 ; i<num.length ; i++){
      for(int j=i+1 ; j<num.length ; j++){
        double x1=p[num[i] ][0];
        double y1=p[num[i] ][1];
        double z1=p[num[i] ][2];
        double x2=p[num[j] ][0];
        double y2=p[num[j] ][1];
        double z2=p[num[j] ][2];
        x1-=x2 ;
        y1-=y2 ;
        z1-=z2 ;
        x1*=x1 ;
        y1*=y1 ;
        z1*=z1 ;
        res+=(x1+y1+z1);
      }
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var p : Sequence(Sequence(double)) ; p := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1][0+1] := sc.getCurrent()->toReal() ; 
     p[i+1][1+1] := sc.getCurrent()->toReal() ; 
     p[i+1][2+1] := sc.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
    var ans : double ; ans := 0 ;
        var i : int ; i := 0 ; while i < (1*(2->pow(n)))->oclAsType(long) do ( (     if (bitCount(i) /= m) then     continue else skip ; 
     ans := Set{ans, a(p, i)}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation a( p : Sequence(Sequence(double)), bit : int) : double
  pre: true
  post: true
  activity: (     var num : Sequence(int) ; num := Integer.subrange(1,bitCount(bit))->collect(0) ;
     var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while bit /= 0 do ( (     if (bit mod 2 = 1) then (     num[cnt+1] := i ; 
     cnt := cnt + 1 ) else skip ; 
     bit := (bit/(2->pow(1)))->oclAsType(long) )  ;     i := i + 1 ) ; 
    var res : double ; res := 0.0 ;
        var i : int ; i := 0 ; while i < num->size() do ( (         var j : int ; j := i + 1 ; while j < num->size() do ( (     var x1 : double ; x1 := p[num[i+1]+1][0+1] ;
     var y1 : double ; y1 := p[num[i+1]+1][1+1] ;
    var z1 : double ; z1 := p[num[i+1]+1][2+1] ;
    var x2 : double ; x2 := p[num[j+1]+1][0+1] ;
    var y2 : double ; y2 := p[num[j+1]+1][1+1] ;
    var z2 : double ; z2 := p[num[j+1]+1][2+1] ;
    x1 := x1-(x2) ; 
    y1 := y1-(y2) ; 
    z1 := z1-(z2) ; 
    x1 := x1*(x1) ; 
    y1 := y1*(y1) ; 
    z1 := z1*(z1) ; 
    res := res+((x1 + y1 + z1)) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskC solver=new TaskC();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskC {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int odds=0,evens=0,fours=0 ;
      for(int i=0 ; i<n ; ++i){
        int x=in.nextInt();
        if(x % 4==0)fours++;
        else if(x % 2==0)evens++;
        else odds++;
      }
      if(fours>=odds ||(fours+1==odds && n==odds+fours))out.println("Yes");
      else out.println("No");
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskC ; solver := TaskC.newTaskC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskC {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var odds : int ; odds := 0 ;
    var evens : int ; evens := 0 ;
    var fours : int ; fours := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.nextInt() ;
     if (x mod 4 = 0) then     fours := fours + 1 ; else     if (x mod 2 = 0) then     evens := evens + 1 else     odds := odds + 1 ; ;  )  ;     i := i + 1 ) ; 
     if (fours >= odds or (fours + 1 = odds & n = odds + fours)) then     skip ; else     skip ; );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static void solve(){
    int n=in.nextInt();
    int m=in.nextInt();
    double[][] p=new double[n][3];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<3 ; j++){
        p[i][j]=in.nextDouble();
      }
    }
    double max=0 ;
    for(int k=0 ; k<1<<n ; k++){
      if(Integer.bitCount(k)!=m)continue ;
      double sum=0 ;
      for(int i=0 ; i<n ; i++){
        if((k>>i & 1)!=1)continue ;
        for(int j=i+1 ; j<n ; j++){
          if((k>>j & 1)!=1)continue ;
          for(int c=0 ; c<3 ; c++)sum+=(p[i][c]-p[j][c])*(p[i][c]-p[j][c]);
        }
      }
      max=Math.max(max,sum);
    }
    out.printf("%.6f\n",max);
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    solve();
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var p : Sequence(Sequence(double)) ; p := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 3 do ( (     p[i+1][j+1] := in.getCurrent()->toReal() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : double ; max := 0 ;
        var k : int ; k := 0 ; while k < (1*(2->pow(n)))->oclAsType(long) do ( (     if (bitCount(k) /= m) then     continue else skip ; 
     var sum : double ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if ((MathLib.bitwiseAnd((k/(2->pow(i)))->oclAsType(long),1)) /= 1) then     continue else skip ; 
         var j : int ; j := i + 1 ; while j < n do ( (     if ((MathLib.bitwiseAnd((k/(2->pow(j)))->oclAsType(long),1)) /= 1) then     continue else skip ; 
         var c : int ; c := 0 ; while c < 3 do (     sum := sum+((p[i+1][c+1] - p[j+1][c+1]) * (p[i+1][c+1] - p[j+1][c+1])) ;  ;     c := c + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     max := Set{max, sum}->max() )  ;     k := k + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    execute solve() ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int m=sc.nextInt();
      double[][] data=new double[n][3];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<3 ; j++){
          data[i][j]=sc.nextDouble();
        }
      }
      double totalmax=0 ;
      for(int i=0 ; i<(1<<n); i++){
        ArrayList<Integer>list=new ArrayList<Integer>();
        for(int j=0 ; j<n ; j++){
          if((i &(1<<j))==0)continue ;
          list.add(j);
        }
        if(list.size()!=m)continue ;
        double sum=0 ;
        for(int j=0 ; j<list.size(); j++){
          for(int k=j+1 ; k<list.size(); k++){
            int indj=list.get(j);
            int indk=list.get(k);
            double a=data[indj][0]-data[indk][0];
            double b=data[indj][1]-data[indk][1];
            double c=data[indj][2]-data[indk][2];
            double sumsq=a*a+b*b+c*c ;
            sum+=sumsq ;
          }
        }
        totalmax=Math.max(totalmax,sum);
      }
      System.out.printf("%.8f\n",totalmax);
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var data : Sequence(Sequence(double)) ; data := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 3 do ( (     data[i+1][j+1] := sc.getCurrent()->toReal() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var totalmax : double ; totalmax := 0 ;
        var i : int ; i := 0 ; while i < ((1*(2->pow(n)))->oclAsType(long)) do ( (     var list : Sequence(int) ; list := Sequence{} ;
         var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd(i,((1*(2->pow(j)))->oclAsType(long)))) = 0) then     continue else skip ; 
     list := list->including(j) )  ;     j := j + 1 ) ; 
    if (list->size() /= m) then     continue else skip ; 
    var sum : double ; sum := 0 ;
        var j : int ; j := 0 ; while j < list->size() do ( (         var k : int ; k := j + 1 ; while k < list->size() do ( (     var indj : int ; indj := list->at(j+1) ;
     var indk : int ; indk := list->at(k+1) ;
    var a : double ; a := data[indj+1][0+1] - data[indk+1][0+1] ;
    var b : double ; b := data[indj+1][1+1] - data[indk+1][1+1] ;
    var c : double ; c := data[indj+1][2+1] - data[indk+1][2+1] ;
    var sumsq : double ; sumsq := a * a + b * b + c * c ;
    sum := sum+(sumsq) ; 
 )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    totalmax := Set{totalmax, sum}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.8f\n", totalmax) ; 
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int waysToKAdjacentSetBits(int n,int k,int currentIndex,int adjacentSetBits,int lastBit){
    if(currentIndex==n){
      if(adjacentSetBits==k)return 1 ;
      return 0 ;
    }
    int noOfWays=0 ;
    if(lastBit==1){
      noOfWays+=waysToKAdjacentSetBits(n,k,currentIndex+1,adjacentSetBits+1,1);
      noOfWays+=waysToKAdjacentSetBits(n,k,currentIndex+1,adjacentSetBits,0);
    }
    else if(lastBit==0){
      noOfWays+=waysToKAdjacentSetBits(n,k,currentIndex+1,adjacentSetBits,1);
      noOfWays+=waysToKAdjacentSetBits(n,k,currentIndex+1,adjacentSetBits,0);
    }
    return noOfWays ;
  }
  public static void main(String args[]){
    int n=5,k=2 ;
    int totalWays=waysToKAdjacentSetBits(n,k,1,0,1)+waysToKAdjacentSetBits(n,k,1,0,0);
    System.out.println("Number of ways="+totalWays);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation waysToKAdjacentSetBits( n : int, k : int, currentIndex : int, adjacentSetBits : int, lastBit : int) : int
  pre: true
  post: true
  activity: (     if (currentIndex = n) then (     if (adjacentSetBits = k) then     return 1 else skip ; 
     return 0 ) else skip ; 
     var noOfWays : int ; noOfWays := 0 ;
     if (lastBit = 1) then (     noOfWays := noOfWays+(waysToKAdjacentSetBits(n, k, currentIndex + 1, adjacentSetBits + 1, 1)) ; 
     noOfWays := noOfWays+(waysToKAdjacentSetBits(n, k, currentIndex + 1, adjacentSetBits, 0)) ) else     if (lastBit = 0) then (     noOfWays := noOfWays+(waysToKAdjacentSetBits(n, k, currentIndex + 1, adjacentSetBits, 1)) ; 
     noOfWays := noOfWays+(waysToKAdjacentSetBits(n, k, currentIndex + 1, adjacentSetBits, 0)) ) else skip ; ;  
     return noOfWays );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var k : int ; k := 2 ;
     var totalWays : int ; totalWays := waysToKAdjacentSetBits(n, k, 1, 0, 1) + waysToKAdjacentSetBits(n, k, 1, 0, 0) ;
     OclFile["System.out"].println("Number of ways=" + totalWays) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner kb=new Scanner(System.in);
    int n=kb.nextInt(),k=kb.nextInt(),sum=0 ;
    int arr[]=new int[n];
    int brr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=kb.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      int temp=kb.nextInt();
      sum+=(temp*arr[i]);
      if(temp==0){
        brr[i]=arr[i];
      }
      brr[i]+=(i==0 ? 0 : brr[i-1]);
    }
    int i=0,j=k-1 ;
    int max=Integer.MIN_VALUE ;
    while(j<brr.length){
      max=Math.max(max,brr[j]-(i==0 ? 0 : brr[i-1]));
      i++;
      j++;
    }
    System.out.println(sum+max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var kb : OclFile ; kb := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := kb.getCurrent()->toInteger() ;
    var k : int ; k := kb.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var brr : Sequence(int) ; brr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := kb.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var temp : int ; temp := kb.getCurrent()->toInteger() ;
     sum := sum+((temp * arr[i+1])) ; 
     if (temp = 0) then (     brr[i+1] := arr[i+1] ) else skip ; 
     brr[i+1] := brr[i+1]+((if i = 0 then 0 else brr[i - 1+1] endif)) )  ;     i := i + 1 ) ; 
    var i : int ; i := 0 ;
    var j : int ; j := k - 1 ;
    var max : int ; max := -2147483648 ;
    while (j < brr->size()) do (     max := Set{max, brr[j+1] - (if i = 0 then 0 else brr[i - 1+1] endif)}->max() ; 
     i := i + 1 ; 
     j := j + 1 ) ; 
    OclFile["System.out"].println(sum + max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    long lbase=0 ;
    long rbase=0 ;
    PriorityQueue<Long>lindex=new PriorityQueue<>(Collections.reverseOrder());
    PriorityQueue<Long>rindex=new PriorityQueue<>();
    long[] l=new long[N];
    long[] w=new long[N];
    for(int i=0 ; i<N ; ++i){
      l[i]=scan.nextLong();
      w[i]=scan.nextLong()-l[i];
    }
    lindex.add(l[0]);
    rindex.add(l[0]);
    long ans=0 ;
    for(int i=1 ; i<N ; ++i){
      lbase+=w[i];
      rbase+=w[i-1];
      if(lindex.peek()>=(l[i]+lbase)){
        lindex.add(l[i]+lbase);
        lindex.add(l[i]+lbase);
        ans+=Math.abs(lindex.peek()-(l[i]+lbase));
        rindex.add(lindex.poll()-lbase-rbase);
      }
      else if(rindex.peek()<=(l[i]-rbase)){
        rindex.add(l[i]-rbase);
        rindex.add(l[i]-rbase);
        ans+=Math.abs(rindex.peek()-(l[i]-rbase));
        lindex.add(rindex.poll()+lbase+rbase);
      }
      else {
        lindex.add(l[i]+lbase);
        rindex.add(l[i]-rbase);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var lbase : long ; lbase := 0 ;
    var rbase : long ; rbase := 0 ;
    var lindex : Sequence(long) ; lindex := Sequence{}->union(reverseOrder()) ;
    var rindex : Sequence(long) ; rindex := Sequence{} ;
    var l : Sequence(long) ; l := Integer.subrange(1,N)->collect(0) ;
    var w : Sequence(long) ; w := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     l[i+1] := scan.getCurrent()->toLong() ; 
     w[i+1] := scan.getCurrent()->toLong() - l[i+1] )  ;     i := i + 1 ) ; 
    lindex := lindex->including(l[0+1]) ; 
    rindex := rindex->including(l[0+1]) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i < N do ( (     lbase := lbase+(w[i+1]) ; 
     rbase := rbase+(w[i - 1+1]) ; 
     if (lindex->min() >= (l[i+1] + lbase)) then (     lindex := lindex->including(l[i+1] + lbase) ; 
     lindex := lindex->including(l[i+1] + lbase) ; 
     ans := ans+(if lindex->min() - (l[i+1] + lbase) < 0 then -(lindex->min() - (l[i+1] + lbase)) else lindex->min() - (l[i+1] + lbase) endif) ; 
     rindex := rindex->including(lindex->min() - lbase - rbase) ) else     if (rindex->min() <= (l[i+1] - rbase)) then (     rindex := rindex->including(l[i+1] - rbase) ; 
     rindex := rindex->including(l[i+1] - rbase) ; 
     ans := ans+(if rindex->min() - (l[i+1] - rbase) < 0 then -(rindex->min() - (l[i+1] - rbase)) else rindex->min() - (l[i+1] - rbase) endif) ; 
     lindex := lindex->including(rindex->min() + lbase + rbase) ) else (     lindex := lindex->including(l[i+1] + lbase) ; 
     rindex := rindex->including(l[i+1] - rbase) ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] x=new int[N];
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++){
      x[i]=sc.nextInt();
      a[i]=sc.nextInt()-x[i];
    }
    PriorityQueue<Long>lset=new PriorityQueue<>(new Comparator<Long>(){
      public int compare(Long l1,Long l2){
        return-Long.compare(l1,l2);
      }
    }
);
    lset.add((long)x[0]);
    long ladd=0 ;
    PriorityQueue<Long>rset=new PriorityQueue<>();
    rset.add((long)x[0]);
    long radd=0 ;
    long min=0 ;
    for(int i=1 ; i<N ; i++){
      ladd-=a[i];
      radd+=a[i-1];
      if(x[i]<lset.peek()+ladd){
        min=min+(lset.peek()+ladd-x[i]);
        lset.add(x[i]-ladd);
        lset.add(x[i]-ladd);
        rset.add(lset.poll()+ladd-radd);
      }
      else if(rset.peek()+radd<x[i]){
        min=min+(x[i]-(rset.peek()+radd));
        rset.add(x[i]-radd);
        rset.add(x[i]-radd);
        lset.add(rset.poll()+radd-ladd);
      }
      else {
        lset.add(x[i]-ladd);
        rset.add(x[i]-radd);
      }
    }
    System.out.println(min);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,N)->collect(0) ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     a[i+1] := sc.getCurrent()->toInteger() - x[i+1] )  ;     i := i + 1 ) ; 
    var lset : Sequence(long) ; lset := Sequence{}->union(OclComparator<long>.newOclComparator()) ;
    lset := lset->including(x[0+1]->oclAsType(long)) ; 
    var ladd : long ; ladd := 0 ;
    var rset : Sequence(long) ; rset := Sequence{} ;
    rset := rset->including(x[0+1]->oclAsType(long)) ; 
    var radd : long ; radd := 0 ;
    var min : long ; min := 0 ;
        var i : int ; i := 1 ; while i < N do ( (     ladd := ladd-(a[i+1]) ; 
     radd := radd+(a[i - 1+1]) ; 
     if (x[i+1] < lset->min() + ladd) then (     min := min + (lset->min() + ladd - x[i+1]) ; 
     lset := lset->including(x[i+1] - ladd) ; 
     lset := lset->including(x[i+1] - ladd) ; 
     rset := rset->including(lset->min() + ladd - radd) ) else     if (rset->min() + radd < x[i+1]) then (     min := min + (x[i+1] - (rset->min() + radd)) ; 
     rset := rset->including(x[i+1] - radd) ; 
     rset := rset->including(x[i+1] - radd) ; 
     lset := lset->including(rset->min() + radd - ladd) ) else (     lset := lset->including(x[i+1] - ladd) ; 
     rset := rset->including(x[i+1] - radd) ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Cards {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    long a,b,j ;
    a=s.nextInt();
    b=s.nextInt();
    long m=-b*b ;
    j=0 ;
    if(a==0){
      BigInteger bg=BigInteger.valueOf(b);
      BigInteger mg=bg.multiply(bg);
      System.out.println(mg.negate());
      for(int i=0 ; i<b ; i++){
        System.out.print("x");
      }
    }
    if(b==0){
      BigInteger ag=BigInteger.valueOf(a);
      BigInteger mg=ag.multiply(ag);
      System.out.println(mg);
      for(int i=0 ; i<a ; i++){
        System.out.print("o");
      }
    }
    else if(a!=0 && b!=0){
      for(int i=2 ; i<=a+1 ; i++){
        long n=(a+2-i)*(a+2-i)+(i-2)-(b % i)*(b/i+1)*(b/i+1)-(i-b % i)*(b/i)*(b/i);
        if(m<n){
          m=n ;
          j=i ;
        }
      }
      System.out.println(m);
    }
    for(int k=0 ; k<j ; k++){
      if(k<j){
        for(int l=0 ; l<b/j ; l++){
          System.out.print("x");
        }
      }
      if(k<b % j){
        System.out.print("x");
      }
      if(k==j-2){
        for(int p=0 ; p<a+2-j ; p++){
          System.out.print("o");
        }
      }
      if(k<j-2){
        System.out.print("o");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cards {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ;
    var b : long ;
    var j : long ;
    a := s.getCurrent()->toInteger() ; 
    b := s.getCurrent()->toInteger() ; 
    var m : long ; m := -b * b ;
    j := 0 ; 
    if (a = 0) then (     var bg : long ; bg := (b + "")->toLong() ;
     var mg : long ; mg := bg.multiply(bg) ;
     OclFile["System.out"].println(mg.negate()) ; 
         var i : int ; i := 0 ; while i < b do ( (     OclFile["System.out"].print("x") )  ;     i := i + 1 ) ) else skip ; 
    if (b = 0) then (     var ag : long ; ag := (a + "")->toLong() ;
     var mg : long ; mg := ag.multiply(ag) ;
     OclFile["System.out"].println(mg) ; 
         var i : int ; i := 0 ; while i < a do ( (     OclFile["System.out"].print("o") )  ;     i := i + 1 ) ) else     if (a /= 0 & b /= 0) then (         var i : int ; i := 2 ; while i <= a + 1 do ( (     var n : long ; n := (a + 2 - i) * (a + 2 - i) + (i - 2) - (b mod i) * (b / i + 1) * (b / i + 1) - (i - b mod i) * (b / i) * (b / i) ;
     if (m < n) then (     m := n ; 
     j := i ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(m) ) else skip ; ;  
        var k : int ; k := 0 ; while k < j do ( (     if (k < j) then (         var l : int ; l := 0 ; while l < b / j do ( (     OclFile["System.out"].print("x") )  ;     l := l + 1 ) ) else skip ; 
     if (k < b mod j) then (     OclFile["System.out"].print("x") ) else skip ; 
     if (k = j - 2) then (         var p : int ; p := 0 ; while p < a + 2 - j do ( (     OclFile["System.out"].print("o") )  ;     p := p + 1 ) ) else skip ; 
     if (k < j - 2) then (     OclFile["System.out"].print("o") ) else skip )  ;     k := k + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printModulus(int X,int Y){
    int n=Math.max(X,Y);
    for(int i=1 ; i<=n ; i++){
      if(X % i==Y % i)System.out.print(i+" ");
    }
  }
  public static void main(String[] args){
    int X,Y ;
    X=10 ;
    Y=20 ;
    printModulus(X,Y);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printModulus( X : int, Y : int) : void
  pre: true
  post: true
  activity: (     var n : int ; n := Set{X, Y}->max() ;
         var i : int ; i := 1 ; while i <= n do ( (     if (X mod i = Y mod i) then     OclFile["System.out"].print(i + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ;
    var Y : int ;
     X := 10 ; 
     Y := 20 ; 
     execute printModulus(X, Y) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class maxUniqueNumWindow {
  static int maxUniqueNum(int arr[],int M){
    HashMap<Integer,Integer>hM=new HashMap<Integer,Integer>();
    int dist_count=0 ;
    for(int i=0 ; i<M ; i++){
      if(hM.get(arr[i])==null){
        hM.put(arr[i],1);
        dist_count++;
      }
      else {
        int count=hM.get(arr[i]);
        hM.put(arr[i],count+1);
      }
    }
    int res=dist_count ;
    for(int i=M ; i<arr.length ; i++){
      if(hM.get(arr[i-M])==1){
        hM.remove(arr[i-M]);
        dist_count--;
      }
      else {
        int count=hM.get(arr[i-M]);
        hM.put(arr[i-M],count-1);
      }
      if(hM.get(arr[i])==null){
        hM.put(arr[i],1);
        dist_count++;
      }
      else {
        int count=hM.get(arr[i]);
        hM.put(arr[i],count+1);
      }
      res=Math.max(res,dist_count);
    }
    return res ;
  }
  public static void main(String arg[]){
    int arr[]={
      1,2,1,3,4,2,3 };
      int M=4 ;
      System.out.println(maxUniqueNum(arr,M));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class maxUniqueNumWindow {
  static   operation maxUniqueNum( arr : Sequence(int), M : int) : int
  pre: true
  post: true
  activity: (     var hM : Map(int,int) ; hM := Map{} ;
     var dist_count : int ; dist_count := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     if (hM->at(arr[i+1]) = null) then (     hM := hM->union(Map{arr[i+1] |-> 1}) ; 
     dist_count := dist_count + 1 ) else (     var count : int ; count := hM->at(arr[i+1]) ;
     hM := hM->union(Map{arr[i+1] |-> count + 1}) ) )  ;     i := i + 1 ) ; 
    var res : int ; res := dist_count ;
        var i : int ; i := M ; while i < arr->size() do ( (     if (hM->at(arr[i - M+1]) = 1) then (     hM := hM->antirestrict(Set{arr[i - M+1]}) ; 
     dist_count := dist_count - 1 ) else (     var count : int ; count := hM->at(arr[i - M+1]) ;
     hM := hM->union(Map{arr[i - M+1] |-> count - 1}) ) ;  
     if (hM->at(arr[i+1]) = null) then (     hM := hM->union(Map{arr[i+1] |-> 1}) ; 
     dist_count := dist_count + 1 ) else (     var count : int ; count := hM->at(arr[i+1]) ;
     hM := hM->union(Map{arr[i+1] |-> count + 1}) ) ;  
     res := Set{res, dist_count}->max() )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,1,3,4,2,3} ;
     var M : int ; M := 4 ;
     OclFile["System.out"].println(maxUniqueNum(arr, M)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Solution {
  static class NodeDetails {
    int data ;
    int min,max ;
  };
  static boolean levelOrderIsOfBST(int arr[],int n){
    if(n==0)return true ;
    Queue<NodeDetails>q=new LinkedList<NodeDetails>();
    int i=0 ;
    NodeDetails newNode=new NodeDetails();
    newNode.data=arr[i++];
    newNode.min=Integer.MIN_VALUE ;
    newNode.max=Integer.MAX_VALUE ;
    q.add(newNode);
    while(i!=n && q.size()>0){
      NodeDetails temp=q.peek();
      q.remove();
      newNode=new NodeDetails();
      if(i<n &&(arr[i]<(int)temp.data && arr[i]>(int)temp.min)){
        newNode.data=arr[i++];
        newNode.min=temp.min ;
        newNode.max=temp.data ;
        q.add(newNode);
      }
      newNode=new NodeDetails();
      if(i<n &&(arr[i]>(int)temp.data && arr[i]<(int)temp.max)){
        newNode.data=arr[i++];
        newNode.min=temp.data ;
        newNode.max=temp.max ;
        q.add(newNode);
      }
    }
    if(i==n)return true ;
    return false ;
  }
  public static void main(String args[]){
    int arr[]={
      7,4,12,3,6,8,1,5,10 };
      int n=arr.length ;
      if(levelOrderIsOfBST(arr,n))System.out.print("Yes");
      else System.out.print("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Solution {
  static class NodeDetails {
   attribute data : int;
   attribute min : int;
}
  static   operation levelOrderIsOfBST( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 0) then     return true else skip ; 
     var q : Sequence(NodeDetails) ; q := Sequence{} ;
    var i : int ; i := 0 ;
    var newNode : NodeDetails ; newNode := NodeDetails.newNodeDetails() ;
     newNode.data := arr[i+1]  ; i := i + 1 ; 
    newNode.min := -2147483648 ; 
    newNode.max := 2147483647 ; 
    q := q->including(newNode) ; 
    while (i /= n & q->size() > 0) do (     var temp : NodeDetails ; temp := q->min() ;
     q := q.remove() ; 
    newNode := NodeDetails.newNodeDetails() ; 
    if (i < n & (arr[i+1] < temp.data->oclAsType(int) & arr[i+1] > temp.min->oclAsType(int))) then (      newNode.data := arr[i+1]  ; i := i + 1 ; 
     newNode.min := temp.min ; 
     newNode.max := temp.data ; 
     q := q->including(newNode) ) else skip ; 
    newNode := NodeDetails.newNodeDetails() ; 
    if (i < n & (arr[i+1] > temp.data->oclAsType(int) & arr[i+1] < temp.max->oclAsType(int))) then (      newNode.data := arr[i+1]  ; i := i + 1 ; 
     newNode.min := temp.data ; 
     newNode.max := temp.max ; 
     q := q->including(newNode) ) else skip ; 
 ) ; 
    if (i = n) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{7,4,12,3,6,8,1,5,10} ;
     var n : int ; n := arr->size() ;
     if (levelOrderIsOfBST(arr, n)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Throwable {
    MyScanner sc=new MyScanner();
    PrintWriter pw=new PrintWriter(System.out);
    int n=sc.nextInt();
    int c4=0,c1=0 ;
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt()% 4 ;
      if(x==0)c4++;
      else if(x!=2)c1++;
    }
    if(c1+c4==n)pw.println(c4>=c1-1 ? "Yes" : "No");
    else pw.println(c4>=c1 ? "Yes" : "No");
    pw.flush();
    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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.nextInt() ;
    var c4 : int ; c4 := 0 ;
    var c1 : int ; c1 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.nextInt() mod 4 ;
     if (x = 0) then     c4 := c4 + 1 ; else     if (x /= 2) then     c1 := c1 + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    if (c1 + c4 = n) then     skip else     skip ; ;  
    skip ; 
    skip ; 
 );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  long MOD=1000000000+7 ;
  private void slove(){
    int n=sc.nextInt();
    int[] a=new int[n];
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      b[n-i-1]=sc.nextInt();
    }
    int c=-1 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]==b[i]){
        c=a[i];
        break ;
      }
    }
    int l=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]==c && b[i]==c){
        l=i ;
        break ;
      }
    }
    int r=-1 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(a[i]==c && b[i]==c){
        r=i ;
        break ;
      }
    }
    for(int i=0 ; i<n ; i++){
      if(c!=-1 && a[i]!=c && b[i]!=c && l<=r){
        int tmp=b[i];
        b[i]=b[l];
        b[l]=tmp ;
        l++;
      }
    }
    if(l<=r){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
      for(int i=0 ; i<n ; i++){
        System.out.print(b[i]+" ");
      }
    }
  }
  public static void main(String[] args){
    new Main().slove();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute MOD : long := 1000000000 + 7;
   operation slove() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[n - i - 1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var c : int ; c := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = b[i+1]) then (     c := a[i+1] ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var l : int ; l := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = c & b[i+1] = c) then (     l := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var r : int ; r := -1 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (a[i+1] = c & b[i+1] = c) then (     r := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (c /= -1 & a[i+1] /= c & b[i+1] /= c & l <= r) then (     var tmp : int ; tmp := b[i+1] ;
     b[i+1] := b[l+1] ; 
     b[l+1] := tmp ; 
     l := l + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (l <= r) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(b[i+1] + " ") )  ;     i := i + 1 ) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().slove() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int[] a=new int[200005];
    int[] b=new int[200005];
    int left=-1,right=-1 ;
    int flag=-1 ;
    for(int i=0 ; i<n ; i++){
      a[i]=scanner.nextInt();
    }
    for(int i=n-1 ; i>=0 ; i--){
      b[i]=scanner.nextInt();
      if(b[i]==a[i]){
        if(right==-1){
          right=i ;
          flag=b[i];
        }
        left=i ;
      }
    }
    int[] indexArray=new int[200005];
    int index=0 ;
    for(int i=0 ; i<n ; i++){
      if(i==left){
        i=right ;
        continue ;
      }
      if(b[i]!=flag && a[i]!=flag){
        indexArray[index++]=i ;
      }
    }
    if(left==-1 || index>=(right-left+1)){
      System.out.println("Yes");
      index=0 ;
      for(int i=left ; i<=right ; i++){
        if(i==-1){
          break ;
        }
        int tmp=b[i];
        b[i]=b[indexArray[index] ];
        b[indexArray[index] ]=tmp ;
        index++;
      }
      for(int i=0 ; i<n ; i++){
        if(i!=0)System.out.print(" ");
        System.out.print(b[i]);
      }
      System.out.println();
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,200005)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,200005)->collect(0) ;
    var left : int ; left := -1 ;
    var right : int ; right := -1 ;
    var flag : int ; flag := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     b[i+1] := scanner.getCurrent()->toInteger() ; 
     if (b[i+1] = a[i+1]) then (     if (right = -1) then (     right := i ; 
     flag := b[i+1] ) else skip ; 
     left := i ) else skip )  ;     i := i - 1 ) ; 
    var indexArray : Sequence(int) ; indexArray := Integer.subrange(1,200005)->collect(0) ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i = left) then (     i := right ; 
     continue ) else skip ; 
     if (b[i+1] /= flag & a[i+1] /= flag) then (      indexArray[index+1] := i  ; index := index + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (left = -1 or index >= (right - left + 1)) then (     OclFile["System.out"].println("Yes") ; 
     index := 0 ; 
        var i : int ; i := left ; while i <= right do ( (     if (i = -1) then (     break ) else skip ; 
     var tmp : int ; tmp := b[i+1] ;
    b[i+1] := b[indexArray[index+1]+1] ; 
    b[indexArray[index+1]+1] := tmp ; 
    index := index + 1 ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i /= 0) then     OclFile["System.out"].print(" ") ; else skip ; 
     OclFile["System.out"].print(b[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.stream.Stream ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int[] a=Stream.of(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    int[] b=Stream.of(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    br.close();
    int[] a_cnt=new int[n+1];
    int[] b_cnt=new int[n+1];
    int[] c=new int[n+1];
    int[] d=new int[n+1];
    for(int i=0 ; i<n ; i++){
      a_cnt[a[i] ]++;
      b_cnt[b[i] ]++;
    }
    int max_d=0 ;
    String[] array=new String[n];
    for(int i=1 ; i<=n ; i++){
      if(a_cnt[i]+b_cnt[i]>n){
        System.out.println("No");
        return ;
      }
      c[i]=c[i-1]+a_cnt[i];
      d[i]=d[i-1]+b_cnt[i];
      max_d=Math.max(max_d,c[i]-d[i-1]);
    }
    System.out.println("Yes");
    for(int i=0 ; i<n ; i++){
      array[i]=String.valueOf(b[(i+n-max_d)% n]);
    }
    System.out.println(String.join(" ",array));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var a : Sequence(int) ; a := Sequence{br.readLine()->split(" ")}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var b : Sequence(int) ; b := Sequence{br.readLine()->split(" ")}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    skip ; 
    var a_cnt : Sequence(int) ; a_cnt := Integer.subrange(1,n + 1)->collect(0) ;
    var b_cnt : Sequence(int) ; b_cnt := Integer.subrange(1,n + 1)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n + 1)->collect(0) ;
    var d : Sequence(int) ; d := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a_cnt[a[i+1]+1] := a_cnt[a[i+1]+1] + 1 ; 
     b_cnt[b[i+1]+1] := b_cnt[b[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var max_d : int ; max_d := 0 ;
    var array : Sequence(String) ; array := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 1 ; while i <= n do ( (     if (a_cnt[i+1] + b_cnt[i+1] > n) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
     c[i+1] := c[i - 1+1] + a_cnt[i+1] ; 
     d[i+1] := d[i - 1+1] + b_cnt[i+1] ; 
     max_d := Set{max_d, c[i+1] - d[i - 1+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Yes") ; 
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := ((b[(i + n - max_d) mod n+1]) + "") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(join(" ", array)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
@ SuppressWarnings("unchecked")public class Main {
  private static final long MOD=(int)1e9+7 ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] a=new int[n];
    int[] b=new int[n];
    for(int i=0 ; i<n ; ++i){
      a[i]=in.nextInt();
    }
    for(int i=0 ; i<n ; ++i){
      b[n-i-1]=in.nextInt();
    }
    int x=-1 ;
    int maxI=Integer.MIN_VALUE ;
    int minI=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; ++i){
      if(a[i]==b[i]){
        minI=Math.min(minI,i);
        maxI=Math.max(maxI,i);
        x=a[i];
      }
    }
    int i=0 ;
    int idx=minI ;
    while(i<n){
      if(idx>=minI && idx<=maxI && a[i]!=x && b[i]!=x && minI<=maxI){
        int temp=b[i];
        b[i]=x ;
        b[idx++]=temp ;
      }
++i ;
    }
    for(i=0 ; i<n ; ++i){
      if(a[i]==b[i]){
        System.out.println("No");
        return ;
      }
    }
    System.out.println("Yes");
    for(i=0 ; i<n ; ++i){
      System.out.print(b[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 1e9->oclAsType(int) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[n - i - 1+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var x : int ; x := -1 ;
    var maxI : int ; maxI := -2147483648 ;
    var minI : int ; minI := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = b[i+1]) then (     minI := Set{minI, i}->min() ; 
     maxI := Set{maxI, i}->max() ; 
     x := a[i+1] ) else skip )  ;     i := i + 1 ) ; 
    var i : int ; i := 0 ;
    var idx : int ; idx := minI ;
    while (i < n) do (     if (idx >= minI & idx <= maxI & a[i+1] /= x & b[i+1] /= x & minI <= maxI) then (     var temp : int ; temp := b[i+1] ;
     b[i+1] := x ; 
      b[idx+1] := temp  ; idx := idx + 1 ) else skip ; 
     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     if (a[i+1] = b[i+1]) then (     OclFile["System.out"].println("No") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Yes") ; 
        i := 0 ; while i < n do ( (     OclFile["System.out"].print(b[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void pattern(int n){
    int i,j ;
    for(i=1 ; i<=n ; i++){
      for(j=1 ; j<=(2*n); j++){
        if(i<j)System.out.print(" ");
        else System.out.print("*");
        if(i<=((2*n)-j))System.out.print(" ");
        else System.out.print("*");
      }
      System.out.println("");
    }
    for(i=1 ; i<=n ; i++){
      for(j=1 ; j<=(2*n); j++){
        if(i>(n-j+1))System.out.print(" ");
        else System.out.print("*");
        if((i+n)>j)System.out.print(" ");
        else System.out.print("*");
      }
      System.out.println("");
    }
  }
  public static void main(String[] args){
    pattern(7);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pattern( n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := 1 ; while i <= n do ( (         j := 1 ; while j <= (2 * n) do ( (     if (i < j) then     OclFile["System.out"].print(" ") else     OclFile["System.out"].print("*") ; ;  
     if (i <= ((2 * n) - j)) then     OclFile["System.out"].print(" ") ; else     OclFile["System.out"].print("*") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("") )  ;     i := i + 1 ) ; 
         i := 1 ; while i <= n do ( (         j := 1 ; while j <= (2 * n) do ( (     if (i > (n - j + 1)) then     OclFile["System.out"].print(" ") else     OclFile["System.out"].print("*") ; ;  
     if ((i + n) > j) then     OclFile["System.out"].print(" ") ; else     OclFile["System.out"].print("*") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute pattern(7) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int K=sc.nextInt();
    sc.nextLine();
    int A=sc.nextInt();
    int B=sc.nextInt();
    for(int i=A ; i<=B ; i++){
      if(i % K==0){
        System.out.println("OK");
        System.exit(0);
      }
    }
    System.out.println("NG");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    skip ; 
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
        var i : int ; i := A ; while i <= B do ( (     if (i mod K = 0) then (     OclFile["System.out"].println("OK") ; 
 OclProcess.exit(0) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NG") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.io.PrintStream ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    FastReader in=new FastReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    AWeLoveGolf solver=new AWeLoveGolf();
    solver.solve(1,in,out);
    out.close();
  }
  static class AWeLoveGolf {
    public void solve(int testNumber,FastReader in,PrintWriter out){
      int k=in.nextInt();
      int a=in.nextInt();
      int b=in.nextInt();
      for(int i=a ; i<=b ; i++){
        if(i % k==0){
          out.println("OK");
          return ;
        }
      }
      out.print("NG");
    }
  }
  static class FastReader {
    public BufferedReader br ;
    public StringTokenizer st ;
    String context=null ;
    public FastReader(InputStream in){
      this(new InputStreamReader(in));
    }
    public FastReader(InputStreamReader input){
      br=new BufferedReader(input);
    }
    public String next(){
      if(context!=null){
        System.err.print("["+context+"] Wait for input...");
      }
      while(st==null || ! st.hasMoreElements()){
        try {
          String s=br.readLine();
          if(s==null)return null ;
          st=new StringTokenizer(s);
        }
        catch(IOException e){
          e.printStackTrace();
          throw new RuntimeException("Could not read");
        }
      }
      String res=st.nextToken();
      if(context!=null){
        System.err.println("["+context+"] ...received : "+res);
      }
      return res ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : FastReader ; in := FastReader.newFastReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : AWeLoveGolf ; solver := AWeLoveGolf.newAWeLoveGolf() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class AWeLoveGolf {
   operation solve( testNumber : int, in : FastReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var k : int ; k := in.nextInt() ;
     var a : int ; a := in.nextInt() ;
    var b : int ; b := in.nextInt() ;
        var i : int ; i := a ; while i <= b do ( (     if (i mod k = 0) then (     skip ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   attribute context : String := null;
   static operation newFastReader( in : OclFile) : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     execute this(OclFile.newOclFile_Read(in)) );
   static operation newFastReader( input : OclFile) : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise(input);
    return self );
  operation initialise( input : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(input) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (context /= null) then (     OclFile["System.err"].print("[" + context + "] Wait for input...") ) else skip ; 
     while (st = null or not(st.hasNext())) do (     try (     var s : String ; s := br.readLine() ;
     if (s = null) then     return null else skip ; 
     st := OclIterator.newOclIterator_String(s) )   catch (e : IOException) do (     e.printStackTrace() ; 
     error ProgramException("Could not read") )
 ) ; 
    var res : String ; res := st.next() ;
    if (context /= null) then (     OclFile["System.err"].println("[" + context + "] ...received : " + res) ) else skip ; 
    return res 
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String args[])throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int q=Integer.parseInt(br.readLine());
    String str[]=br.readLine().split(" ");
    int a=Integer.parseInt(str[0]);
    int b=Integer.parseInt(str[1]);
    if(a % q==0 || b % q==0 || b/q-a/q>0)pw.println("OK");
    else pw.println("NG");
    pw.flush();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var q : int ; q := (br.readLine())->toInteger() ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var a : int ; a := (str[0+1])->toInteger() ;
    var b : int ; b := (str[1+1])->toInteger() ;
    if (a mod q = 0 or b mod q = 0 or b / q - a / q > 0) then     skip else     skip ; ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.*;
public class Main {
  public static void main(String args[])throws IOException {
    Scanner scan=new Scanner(System.in);
    int K=scan.nextInt();
    int A=scan.nextInt();
    int B=scan.nextInt();
    boolean t=true ;
    for(int i=A ; i<=B ; i++){
      if(i % K==0){
        t=false ;
        break ;
      }
    }
    if(t){
      System.out.println("NG");
    }
    else {
      System.out.println("OK");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var K : int ; K := scan.getCurrent()->toInteger() ;
    var A : int ; A := scan.getCurrent()->toInteger() ;
    var B : int ; B := scan.getCurrent()->toInteger() ;
    var t : boolean ; t := true ;
        var i : int ; i := A ; while i <= B do ( (     if (i mod K = 0) then (     t := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (t) then (     OclFile["System.out"].println("NG") ) else (     OclFile["System.out"].println("OK") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    try(Scanner s=new Scanner(System.in)){
      int k=s.nextInt();
      int a=s.nextInt();
      int b=s.nextInt();
      int mod=a % k ;
      int d=b-a ;
      System.out.println((mod==0 ||(k-mod)<=d)? "OK" : "NG");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var k : int ; k := s.getCurrent()->toInteger() ;
     var a : int ; a := s.getCurrent()->toInteger() ;
    var b : int ; b := s.getCurrent()->toInteger() ;
    var mod : int ; mod := a mod k ;
    var d : int ; d := b - a ;
    OclFile["System.out"].println(if (mod = 0 or (k - mod) <= d) then "OK" else "NG" endif) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  void solve(BufferedReader in)throws Exception {
    int n=toInt(in.readLine());
    int[] a=toInts(in.readLine());
    int d2=0 ;
    int d4=0 ;
    int d1=0 ;
    for(int x : a){
      if(x % 4==0)d4++;
      else if(x % 2==0)d2++;
      else d1++;
    }
    if(d2!=0)d1++;
    if(d4>=d1-1){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
  int toInt(String s){
    return Integer.parseInt(s);
  }
  int[] toInts(String s){
    String[] a=s.split(" ");
    int[] o=new int[a.length];
    for(int i=0 ; i<a.length ; i++)o[i]=toInt(a[i]);
    return o ;
  }
  void e(Object o){
    System.err.println(o);
  }
  public static void main(String[] args)throws Exception {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
(new Main()).solve(in);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve( in : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := toInt(in.readLine()) ;
     var a : Sequence(int) ; a := toInts(in.readLine()) ;
    var d2 : int ; d2 := 0 ;
    var d4 : int ; d4 := 0 ;
    var d1 : int ; d1 := 0 ;
    for (x : a) do ( (     if (x mod 4 = 0) then     d4 := d4 + 1 ; else     if (x mod 2 = 0) then     d2 := d2 + 1 else     d1 := d1 + 1 ; ;  )  ) ; 
    if (d2 /= 0) then     d1 := d1 + 1 ; else skip ; 
    if (d4 >= d1 - 1) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
   operation toInt( s : String) : int
  pre: true
  post: true
  activity: (     return (s)->toInteger() );
   operation toInts( s : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := s->split(" ") ;
     var o : Sequence(int) ; o := Integer.subrange(1,a->size())->collect(0) ;
         var i : int ; i := 0 ; while i < a->size() do (     o[i+1] := toInt(a[i+1]) ;  ;     i := i + 1 ) ; 
     return o );
   operation e( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println(o) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     (Main.newMain()).solve(in) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    String S=sc.next();
    sc.close();
    int len=S.length();
    int left=0,right=0 ;
    int addLeft=0,addRight=0 ;
    for(int i=0 ; i<len ; i++){
      if(S.charAt(i)=='('){
        left++;
      }
      else {
        right++;
      }
      int leftLack=Math.max(0,right-left);
      addLeft+=leftLack ;
      left+=leftLack ;
    }
    addRight=Math.max(0,left-right);
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<addLeft ; i++){
      sb.append('(');
    }
    sb.append(S);
    for(int i=0 ; i<addRight ; i++){
      sb.append(')');
    }
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var S : String ; S := sc.getCurrent() ;
    skip ; 
    var len : int ; len := S->size() ;
    var left : int ; left := 0 ;
    var right : int ; right := 0 ;
    var addLeft : int ; addLeft := 0 ;
    var addRight : int ; addRight := 0 ;
        var i : int ; i := 0 ; while i < len do ( (     if (S->at(i+1) = '(') then (     left := left + 1 ) else (     right := right + 1 ) ;  
     var leftLack : int ; leftLack := Set{0, right - left}->max() ;
     addLeft := addLeft+(leftLack) ; 
     left := left+(leftLack) )  ;     i := i + 1 ) ; 
    addRight := Set{0, left - right}->max() ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < addLeft do ( (     sb := sb + StringLib.newString('(') )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(S) ; 
        var i : int ; i := 0 ; while i < addRight do ( (     sb := sb + StringLib.newString(')') )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String str=sc.next();
    int counta=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      char c=str.charAt(i);
      if(c==')'){
        counta++;
      }
      else {
        if(counta>0){
          counta--;
        }
      }
    }
    String stra="" ;
    while(counta-->0){
      stra+="(" ;
    }
    counta=0 ;
    for(int i=0 ; i<n ; i++){
      char c=str.charAt(i);
      if(c=='('){
        counta++;
      }
      else {
        if(counta>0){
          counta--;
        }
      }
    }
    String strb="" ;
    while(counta-->0){
      strb+=")" ;
    }
    System.out.println(stra+str+strb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var str : String ; str := sc.getCurrent() ;
    var counta : int ; counta := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     var c : String ; c := str->at(i+1) ;
     if (c = ')') then (     counta := counta + 1 ) else (     if (counta > 0) then (     counta := counta - 1 ) else skip ) )  ;     i := i - 1 ) ; 
    var stra : String ; stra := "" ;
        while (counta > 0) do (        counta := counta - 1 ;     skip ; (     stra := stra+("(") ) ;  ) ;  
    counta := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     var c : String ; c := str->at(i+1) ;
     if (c = '(') then (     counta := counta + 1 ) else (     if (counta > 0) then (     counta := counta - 1 ) else skip ) )  ;     i := i + 1 ) ; 
    var strb : String ; strb := "" ;
        while (counta > 0) do (        counta := counta - 1 ;     skip ; (     strb := strb+(")") ) ;  ) ;  
    OclFile["System.out"].println(stra + str + strb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.*;
import java.awt.geom.Point2D ;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] $){
    Scanner sc=new Scanner(in);
    int n=sc.nextInt();
    int[] c=new int[n+1];
    String s=sc.next();
    String r="" ;
    String l="" ;
    int neg=101 ;
    for(int i=0 ; i<n ; i++){
      char a=s.charAt(i);
      if(a=='(')c[i+1]=c[i]+1 ;
      else c[i+1]=c[i]-1 ;
      neg=min(c[i+1],neg);
    }
    for(int i=0 ; i<-neg ; i++){
      l+="(" ;
    }
    s=l+s ;
    int temp=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='(')temp++;
      else temp--;
    }
    for(int i=0 ; i<temp ; i++){
      r+=")" ;
    }
    out.println(s+r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : Sequence(int) ; c := Integer.subrange(1,n + 1)->collect(0) ;
    var s : String ; s := sc.getCurrent() ;
    var r : String ; r := "" ;
    var l : String ; l := "" ;
    var neg : int ; neg := 101 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : String ; a := s->at(i+1) ;
     if (a = '(') then     c[i + 1+1] := c[i+1] + 1 else     c[i + 1+1] := c[i+1] - 1 ; ;  
     neg := Set{c[i + 1+1], neg}->min() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < -neg do ( (     l := l+("(") )  ;     i := i + 1 ) ; 
    s := l + s ; 
    var temp : int ; temp := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '(') then     temp := temp + 1 ; else     temp := temp - 1 ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < temp do ( (     r := r+(")") )  ;     i := i + 1 ) ; 
    out.println(s + r) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
public class Main {
  public static void main(String[] args)throws IOException {
    StringBuilder builder=new StringBuilder();
    StringBuilder left=new StringBuilder();
    StringBuilder right=new StringBuilder();
    int buf ;
    while((buf=System.in.read())!='\n');
    while((buf=System.in.read())!='\n'){
      builder.appendCodePoint(buf);
    }
    String str=builder.toString();
    int idx ;
    while((idx=builder.indexOf("()"))!=-1){
      builder.delete(idx,idx+2);
    }
    for(char c : builder.toString().toCharArray()){
      if(c==')')left.append('(');
      else right.append(')');
    }
    System.out.print(left.toString()+str+right.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var builder : String ; builder := StringLib.newString() ;
     var left : String ; left := StringLib.newString() ;
    var right : String ; right := StringLib.newString() ;
    var buf : int ;
        buf := OclFile["System.in"].read() ;
    while ((buf) /= '
') do (    skip ;  ;     buf := OclFile["System.in"].read() ;
 ) ;  
        buf := OclFile["System.in"].read() ;
    while ((buf) /= '
') do (    skip ; (     builder.appendCodePoint(buf) ) ;     buf := OclFile["System.in"].read() ;
 ) ;  
    var str : String ; str := builder+"" ;
    var idx : int ;
        idx := builder->indexOf("()")-1 ;
    while ((idx) /= -1) do (    skip ; (     builder := builder->antirestrict( Integer.subrange(idx+1,idx + 2) ) ) ;     idx := builder->indexOf("()")-1 ;
 ) ;  
    for (c : builder+""->characters()) do ( (     if (c = ')') then     left := left + StringLib.newString('(') ; else     right := right + StringLib.newString(')') ; )  ) ; 
    OclFile["System.out"].print(left+"" + str + right+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  static IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static IntStream REPS(int l,int r){
    return IntStream.rangeClosed(l,r);
  }
  static IntStream INS(int n){
    return REPS(n).map(i->getInt());
  }
  static Scanner s=new Scanner(System.in);
  static int getInt(){
    return Integer.parseInt(s.next());
  }
  public static void main(String[] $){
    int n=getInt();
    char[] in=s.next().toCharArray();
    int l=0 ;
    for(int i=0 ; i<n ; ++i){
      if(in[i]==')' && l>0)--l ;
      if(in[i]=='(')++l ;
    }
    int r=0 ;
    for(int i=n-1 ; i>=0 ; --i){
      if(in[i]=='(' && r>0)--r ;
      if(in[i]==')')++r ;
    }
    String res="" ;
    for(int i=0 ; i<r ; ++i)res+='(' ; res+=String.valueOf(in); for(int i=0 ; i<l ; ++i)res+=')' ;
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static   operation REPS( l : int, r : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(l, r) );
  static   operation INS( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return REPS(n)->collect( _x1 | (lambda i : OclAny in getInt())->apply(_x1) ) );
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := getInt() ;
     var in : Sequence(String) ; in := s.getCurrent()->characters() ;
    var l : int ; l := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (in[i+1] = ')' & l > 0) then     l := l - 1 ; else skip ; 
     if (in[i+1] = '(') then     l := l + 1 ; else skip )  ;     i := i + 1 ) ; 
    var r : int ; r := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (in[i+1] = '(' & r > 0) then     r := r - 1 ; else skip ; 
     if (in[i+1] = ')') then     r := r + 1 ; else skip )  ;     i := i - 1 ) ; 
    var res : String ; res := "" ;
        var i : int ; i := 0 ; while i < r do (     res := res+('(') ;  ;     i := i + 1 ) ; 
    res := res+((in)->sum() ) ; 
        var i : int ; i := 0 ; while i < l do (     res := res+(')') ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void pattern(int n){
    int i,j ;
    for(i=1 ; i<=n ; i++){
      for(j=1 ; j<=(2*n); j++){
        if(i>(n-j+1))System.out.print(" ");
        else System.out.print("*");
        if((i+n)>j)System.out.print(" ");
        else System.out.print("*");
      }
      System.out.println("");
    }
    for(i=1 ; i<=n ; i++){
      for(j=1 ; j<=(2*n); j++){
        if(i<j)System.out.print(" ");
        else System.out.print("*");
        if(i<=((2*n)-j))System.out.print(" ");
        else System.out.print("*");
      }
      System.out.println("");
    }
  }
  public static void main(String[] args){
    pattern(7);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pattern( n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := 1 ; while i <= n do ( (         j := 1 ; while j <= (2 * n) do ( (     if (i > (n - j + 1)) then     OclFile["System.out"].print(" ") else     OclFile["System.out"].print("*") ; ;  
     if ((i + n) > j) then     OclFile["System.out"].print(" ") ; else     OclFile["System.out"].print("*") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("") )  ;     i := i + 1 ) ; 
         i := 1 ; while i <= n do ( (         j := 1 ; while j <= (2 * n) do ( (     if (i < j) then     OclFile["System.out"].print(" ") else     OclFile["System.out"].print("*") ; ;  
     if (i <= ((2 * n) - j)) then     OclFile["System.out"].print(" ") ; else     OclFile["System.out"].print("*") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute pattern(7) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p025 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p025().run());
  }
  private static final int DIGITS=1000 ;
  public String run(){
    BigInteger lowerThres=BigInteger.TEN.pow(DIGITS-1);
    BigInteger upperThres=BigInteger.TEN.pow(DIGITS);
    BigInteger prev=BigInteger.ONE ;
    BigInteger cur=BigInteger.ZERO ;
    for(int i=0 ; ; i++){
      if(cur.compareTo(upperThres)>=0)throw new RuntimeException("Not found");
      else if(cur.compareTo(lowerThres)>=0)return Integer.toString(i);
      BigInteger temp=cur.add(prev);
      prev=cur ;
      cur=temp ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class p025 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p025.newp025().run()) );
  static    attribute DIGITS : int := 1000;
   operation run() : String
  pre: true
  post: true
  activity: (     var lowerThres : long ; lowerThres := 10.pow(DIGITS - 1) ;
     var upperThres : long ; upperThres := 10.pow(DIGITS) ;
    var prev : long ; prev := 1 ;
    var cur : long ; cur := 0 ;
        var i : int ; i := 0 ; while true do ( (     if (cur->compareTo(upperThres) >= 0) then     error ProgramException("Not found") else     if (cur->compareTo(lowerThres) >= 0) then     return ((i) + "") else skip ; ;  
     var temp : long ; temp := cur->excludes(prev) ;
     prev := cur ; 
     cur := temp )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import com.sun.org.apache.bcel.internal.generic.FSUB ;
import java.io.*;
import java.sql.SQLOutput ;
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String s=in.next();
    int f=0 ;
    int d=0 ;
    int a=Integer.parseInt(s.substring(0,1));
    if(a==0){
      f=0 ;
      d++;
    }
    else {
      f=1 ;
    }
    int ff=0 ;
    for(int i=1 ; i<n ; i++){
      a=Integer.parseInt(s.substring(i,i+1));
      if(a==1){
        d=0 ;
        if(f==0){
          f=1 ;
        }
        else {
          ff=1 ;
          break ;
        }
      }
      else {
        f=0 ;
        d++;
        if(d==3){
          ff=1 ;
          break ;
        }
      }
      if(i==n-1 || i==1){
        if(d==2){
          ff=1 ;
        }
      }
    }
    if(n==1 && s.equals("0"))ff=1 ;
    if(ff==1){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var f : int ; f := 0 ;
    var d : int ; d := 0 ;
    var a : int ; a := (s.subrange(0+1,1))->toInteger() ;
    if (a = 0) then (     f := 0 ; 
     d := d + 1 ) else (     f := 1 ) ;  
    var ff : int ; ff := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     a := (s.subrange(i+1,i + 1))->toInteger() ; 
     if (a = 1) then (     d := 0 ; 
     if (f = 0) then (     f := 1 ) else (     ff := 1 ; 
     break ) ) else (     f := 0 ; 
     d := d + 1 ; 
     if (d = 3) then (     ff := 1 ; 
     break ) else skip ) ;  
     if (i = n - 1 or i = 1) then (     if (d = 2) then (     ff := 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (n = 1 & s = "0") then     ff := 1 ; else skip ; 
    if (ff = 1) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int n=in.nextInt();
      String a=in.next();
      String b[]=a.split("");
      if(n==1){
        if(a.equals("1"))System.out.println("Yes");
        else System.out.println("No");
      }
      else if(n==2){
        if(! b[0] .equals(b[1]))System.out.println("Yes");
        else System.out.println("No");
      }
      else {
        int s=1 ;
        int q=1 ;
        for(int i=1 ; i<n ; i++){
          if(b[i-1] .equals(b[i])&& b[i-1] .equals("0"))q++;
          else if(b[i-1] .equals(b[i])&& b[i-1] .equals("1")){
            s=-1 ;
            break ;
          }
          else q=1 ;
          if(q==3 ||(i==n-1 && q==2)||(b[0] .equals(b[1])&& b[0] .equals("0"))){
            s=-1 ;
            break ;
          }
        }
        if(s==-1)System.out.println("No");
        else System.out.println("Yes");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : String ; a := in.getCurrent() ;
     var b : Sequence(String) ; b := a->split("") ;
     if (n = 1) then (     if (a = "1") then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; ) else     if (n = 2) then (     if (not(b[0+1] = b[1+1])) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; ) else (     var s : int ; s := 1 ;
     var q : int ; q := 1 ;
         var i : int ; i := 1 ; while i < n do ( (     if (b[i - 1+1] = b[i+1] & b[i - 1+1] = "0") then     q := q + 1 else     if (b[i - 1+1] = b[i+1] & b[i - 1+1] = "1") then (     s := -1 ; 
     break ) else     q := 1 ; ;  ;  
     if (q = 3 or (i = n - 1 & q = 2) or (b[0+1] = b[1+1] & b[0+1] = "0")) then (     s := -1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (s = -1) then     OclFile["System.out"].println("No") ; else     OclFile["System.out"].println("Yes") ; ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A_Row {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    char[] s=in.next().toCharArray();
    if(s.length==1){
      if(s[0]=='1')pw.println("YES");
      else pw.println("NO");
      pw.close();
      return ;
    }
    if(solve(s,n)&& possible(s,n))pw.println("YES");
    else pw.println("NO");
    pw.close();
  }
  static boolean solve(char[] s,int n){
    for(int i=0 ; i<n ; i++){
      if(s[i]=='1')continue ;
      int cnt=0 ;
      int j=i ;
      while(j<n && s[j]=='0'){
        cnt++;
        j++;
      }
      if(j>i)i=j-1 ;
      if(cnt>=3)return false ;
    }
    if(s[0]=='0' && s[1]=='0')return false ;
    if(s[n-1]=='0' && s[n-2]=='0')return false ;
    return true ;
  }
  static boolean possible(char[] s,int n){
    for(int i=1 ; i<n ; i++){
      if(s[i-1]==s[i] && s[i]=='1')return false ;
    }
    return true ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Row {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := in.getCurrent()->characters() ;
    if (s->size() = 1) then (     if (s[0+1] = '1') then     skip else     skip ; ;  
     skip ; 
     return ) else skip ; 
    if (solve(s, n) & possible(s, n)) then     skip else     skip ; ;  
    skip ; 
 );
  static   operation solve( s : Sequence(String), n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] = '1') then     continue else skip ; 
     var cnt : int ; cnt := 0 ;
    var j : int ; j := i ;
    while (j < n & s[j+1] = '0') do (     cnt := cnt + 1 ; 
     j := j + 1 ) ; 
    if (j > i) then     i := j - 1 ; else skip ; 
    if (cnt >= 3) then     return false else skip ; 
 )  ;     i := i + 1 ) ; 
     if (s[0+1] = '0' & s[1+1] = '0') then     return false else skip ; 
     if (s[n - 1+1] = '0' & s[n - 2+1] = '0') then     return false else skip ; 
     return true );
  static   operation possible( s : Sequence(String), n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < n do ( (     if (s[i - 1+1] = s[i+1] & s[i+1] = '1') then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String str[]=br.readLine().split(" ");
    int count4=0 ;
    int count2=0 ;
    int odd=0 ;
    for(int i=0 ; i<n ; i++){
      int a=Integer.parseInt(str[i]);
      if(a % 4==0){
        count4++;
      }
      else if(a % 2==0){
        count2++;
      }
      else {
        odd++;
      }
    }
    if((count4+1)==odd && count4+odd==n){
      System.out.println("Yes");
    }
    else if(count4<odd){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var count4 : int ; count4 := 0 ;
    var count2 : int ; count2 := 0 ;
    var odd : int ; odd := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := (str[i+1])->toInteger() ;
     if (a mod 4 = 0) then (     count4 := count4 + 1 ) else     if (a mod 2 = 0) then (     count2 := count2 + 1 ) else (     odd := odd + 1 ) ;  )  ;     i := i + 1 ) ; 
    if ((count4 + 1) = odd & count4 + odd = n) then (     OclFile["System.out"].println("Yes") ) else     if (count4 < odd) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class gfg {
  static int countNums(int n,int x,int y){
    boolean[] arr=new boolean[n+1];
    if(x<=n)arr[x]=true ;
    if(y<=n)arr[y]=true ;
    int result=0 ;
    for(int i=Math.min(x,y); i<=n ; i++){
      if(arr[i]){
        if(i+x<=n)arr[i+x]=true ;
        if(i+y<=n)arr[i+y]=true ;
        result++;
      }
    }
    return result ;
  }
  public static void main(String[] args){
    int n=15,x=5,y=7 ;
    System.out.println(countNums(n,x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
class gfg {
  static   operation countNums( n : int, x : int, y : int) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(boolean) ; arr := Integer.subrange(1,n + 1)->collect(false) ;
     if (x <= n) then     arr[x+1] := true ; else skip ; 
    if (y <= n) then     arr[y+1] := true ; else skip ; 
    var result : int ; result := 0 ;
        var i : int ; i := Set{x, y}->min() ; while i <= n do ( (     if (arr[i+1]) then (     if (i + x <= n) then     arr[i + x+1] := true ; else skip ; 
     if (i + y <= n) then     arr[i + y+1] := true ; else skip ; 
     result := result + 1 ) else skip )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
    var x : int ; x := 5 ;
    var y : int ; y := 7 ;
     OclFile["System.out"].println(countNums(n, x, y)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.SortedSet ;
import java.util.TreeSet ;
public final class p119 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p119().run());
  }
  private static final int INDEX=30 ;
  public String run(){
    for(BigInteger limit=BigInteger.ONE ; ; limit=limit.shiftLeft(8)){
      SortedSet<BigInteger>candidates=new TreeSet<>();
      for(int k=2 ; BigInteger.valueOf(1).shiftLeft(k).compareTo(limit)<0 ; k++){
        for(int n=2 ; ; n++){
          BigInteger pow=BigInteger.valueOf(n).pow(k);
          if(pow.compareTo(limit)>=0 && pow.toString().length()*9<n)break ;
          if(pow.compareTo(BigInteger.TEN)>=0 && isDigitSumPower(pow))candidates.add(pow);
        }
      }
      if(candidates.size()>=INDEX)return new ArrayList<>(candidates).get(INDEX-1).toString();
    }
  }
  private static boolean isDigitSumPower(BigInteger x){
    int digitSum=digitSum(x);
    if(digitSum==1)return false ;
    BigInteger base=BigInteger.valueOf(digitSum);
    BigInteger pow=base ;
    while(pow.compareTo(x)<0)pow=pow.multiply(base);
    return pow.equals(x);
  }
  private static int digitSum(BigInteger x){
    if(x.signum()<1)throw new IllegalArgumentException("Only for positive integers");
    int sum=0 ;
    for(char c : x.toString().toCharArray())sum+=c-'0' ;
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class p119 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p119.newp119().run()) );
  static    attribute INDEX : int := 30;
   operation run() : String
  pre: true
  post: true
  activity: (         var limit : long ; limit := 1 ; while true do ( (     var candidates : Set(long) ; candidates := Set{} ;
         var k : int ; k := 2 ; while (1 + "")->toLong().shiftLeft(k)->compareTo(limit) < 0 do ( (         var n : int ; n := 2 ; while true do ( (     var pow : long ; pow := (n + "")->toLong().pow(k) ;
     if (pow->compareTo(limit) >= 0 & pow+""->size() * 9 < n) then     break else skip ; 
     if (pow->compareTo(10) >= 0 & isDigitSumPower(pow)) then     candidates := candidates->including(pow) ; else skip )  ;     n := n + 1 ) )  ;     k := k + 1 ) ; 
     if (candidates->size() >= INDEX) then     return Sequence{}->union(candidates)->at(INDEX - 1+1)+"" else skip )  ;     limit := limit.shiftLeft(8) ) );
  static   operation isDigitSumPower( x : long) : boolean
  pre: true
  post: true
  activity: (     var digitSum : int ; digitSum := digitSum(x) ;
     if (digitSum = 1) then     return false else skip ; 
    var base : long ; base := (digitSum + "")->toLong() ;
    var pow : long ; pow := base ;
    while (pow->compareTo(x) < 0) do     pow := pow.multiply(base) ; ; 
    return pow = x 
 );
  static   operation digitSum( x : long) : int
  pre: true
  post: true
  activity: (     if (x.signum() < 1) then     error IllegalArgumentException.newIllegalArgumentException("Only for positive integers") ; else skip ; 
     var sum : int ; sum := 0 ;
     for (c : x+""->characters()) do (     sum := sum+(c - ('0')->char2byte()) ;  ) ; 
     return sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A[][],B[][];
    A=new int[3][3];
    B=new int[3][3];
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<3 ; j++){
        A[i][j]=sc.nextInt();
        B[i][j]=0 ;
      }
    }
    int N ;
    N=sc.nextInt();
    for(int i=0 ; i<N ; i++){
      int c=sc.nextInt();
      for(int j=0 ; j<3 ; j++){
        for(int k=0 ; k<3 ; k++){
          if(A[j][k]==c){
            B[j][k]=1 ;
          }
        }
      }
    }
    for(int i=0 ; i<3 ; i++){
      if(B[i][0]==1 && B[i][1]==1 && B[i][2]==1){
        System.out.println("Yes");
        return ;
      }
    }
    for(int i=0 ; i<3 ; i++){
      if(B[0][i]==1 && B[1][i]==1 && B[2][i]==1){
        System.out.println("Yes");
        return ;
      }
    }
    if(B[0][0]==1 && B[1][1]==1 && B[2][2]==1){
      System.out.println("Yes");
      return ;
    }
    if(B[2][0]==1 && B[1][1]==1 && B[0][2]==1){
      System.out.println("Yes");
      return ;
    }
    System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : Sequence(Sequence(int)) ;
    var B : Sequence(Sequence(void)) ;
    A := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ; 
    B := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ; 
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     A[i+1][j+1] := sc.getCurrent()->toInteger() ; 
     B[i+1][j+1] := 0 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var N : int ;
    N := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < N do ( (     var c : int ; c := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < 3 do ( (         var k : int ; k := 0 ; while k < 3 do ( (     if (A[j+1][k+1] = c) then (     B[j+1][k+1] := 1 ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do ( (     if (B[i+1][0+1] = 1 & B[i+1][1+1] = 1 & B[i+1][2+1] = 1) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do ( (     if (B[0+1][i+1] = 1 & B[1+1][i+1] = 1 & B[2+1][i+1] = 1) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    if (B[0+1][0+1] = 1 & B[1+1][1+1] = 1 & B[2+1][2+1] = 1) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
    if (B[2+1][0+1] = 1 & B[1+1][1+1] = 1 & B[0+1][2+1] = 1) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
    OclFile["System.out"].println("No") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static String s="" ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String ans="No" ;
    int[][] A=new int[3][3];
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<3 ; j++){
        A[i][j]=sc.nextInt();
      }
    }
    int N=sc.nextInt();
    int[] b=new int[N];
    for(int i=0 ; i<N ; i++){
      b[i]=sc.nextInt();
    }
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<3 ; j++){
        for(int k=0 ; k<N ; k++){
          if(A[i][j]==b[k])A[i][j]=0 ;
        }
      }
    }
    for(int i=0 ; i<3 ; i++){
      if(A[i][0]==0 && A[i][1]==0 && A[i][2]==0)ans="Yes" ;
    }
    for(int j=0 ; j<3 ; j++){
      if(A[0][j]==0 && A[1][j]==0 && A[2][j]==0)ans="Yes" ;
    }
    if(A[0][0]==0 && A[1][1]==0 && A[2][2]==0)ans="Yes" ;
    if(A[0][2]==0 && A[1][1]==0 && A[2][0]==0)ans="Yes" ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : String := "";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ans : String ; ans := "No" ;
    var A : Sequence(Sequence(int)) ; A := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     A[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (         var k : int ; k := 0 ; while k < N do ( (     if (A[i+1][j+1] = b[k+1]) then     A[i+1][j+1] := 0 ; else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do ( (     if (A[i+1][0+1] = 0 & A[i+1][1+1] = 0 & A[i+1][2+1] = 0) then     ans := "Yes" ; else skip )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < 3 do ( (     if (A[0+1][j+1] = 0 & A[1+1][j+1] = 0 & A[2+1][j+1] = 0) then     ans := "Yes" ; else skip )  ;     j := j + 1 ) ; 
    if (A[0+1][0+1] = 0 & A[1+1][1+1] = 0 & A[2+1][2+1] = 0) then     ans := "Yes" ; else skip ; 
    if (A[0+1][2+1] = 0 & A[1+1][1+1] = 0 & A[2+1][0+1] = 0) then     ans := "Yes" ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[][] A=new int[3][3];
    boolean[][] flg=new boolean[3][3];
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<3 ; j++){
        A[i][j]=sc.nextInt();
        flg[i][j]=false ;
      }
    }
    int N=sc.nextInt();
    int[] B=new int[N];
    for(int i=0 ; i<N ; i++){
      B[i]=sc.nextInt();
      for(int j=0 ; j<3 ; j++){
        for(int k=0 ; k<3 ; k++){
          if(B[i]==A[j][k]){
            flg[j][k]=true ;
          }
        }
      }
    }
    boolean isBingo=false ;
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<3 ; j++){
        if(flg[i][0] && flg[i][1] && flg[i][2]){
          isBingo=true ;
        }
        if(flg[0][j] && flg[1][j] && flg[2][j]){
          isBingo=true ;
        }
        if(flg[0][0] && flg[1][1] && flg[2][2]){
          isBingo=true ;
        }
        if(flg[0][2] && flg[1][1] && flg[2][0]){
          isBingo=true ;
        }
      }
    }
    if(isBingo){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : Sequence(Sequence(int)) ; A := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
    var flg : Sequence(Sequence(boolean)) ; flg := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(false)) ;
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     A[i+1][j+1] := sc.getCurrent()->toInteger() ; 
     flg[i+1][j+1] := false )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var B : Sequence(int) ; B := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     B[i+1] := sc.getCurrent()->toInteger() ; 
         var j : int ; j := 0 ; while j < 3 do ( (         var k : int ; k := 0 ; while k < 3 do ( (     if (B[i+1] = A[j+1][k+1]) then (     flg[j+1][k+1] := true ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var isBingo : boolean ; isBingo := false ;
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     if (flg[i+1][0+1] & flg[i+1][1+1] & flg[i+1][2+1]) then (     isBingo := true ) else skip ; 
     if (flg[0+1][j+1] & flg[1+1][j+1] & flg[2+1][j+1]) then (     isBingo := true ) else skip ; 
     if (flg[0+1][0+1] & flg[1+1][1+1] & flg[2+1][2+1]) then (     isBingo := true ) else skip ; 
     if (flg[0+1][2+1] & flg[1+1][1+1] & flg[2+1][0+1]) then (     isBingo := true ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (isBingo) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int[] bingoArr ;
  public static void main(String[] args){
    Main mainObj=new Main();
    mainObj.solve();
  }
  public void solve(){
    Scanner sc=new Scanner(System.in);
    bingoArr=new int[9];
    for(int i=0 ; i<9 ; i++){
      bingoArr[i]=sc.nextInt();
    }
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int hole=sc.nextInt();
      for(int j=0 ; j<9 ; j++){
        if(bingoArr[j]==hole){
          bingoArr[j]=-1 ;
          break ;
        }
      }
      if(checkBingo()){
        System.out.println("Yes");
        return ;
      }
    }
    sc.close();
    System.out.println("No");
  }
  public boolean checkBingo(){
    if(bingoArr[0]==-1 && bingoArr[1]==-1 && bingoArr[2]==-1){
      return true ;
    }
    if(bingoArr[3]==-1 && bingoArr[4]==-1 && bingoArr[5]==-1){
      return true ;
    }
    if(bingoArr[6]==-1 && bingoArr[7]==-1 && bingoArr[8]==-1){
      return true ;
    }
    if(bingoArr[0]==-1 && bingoArr[3]==-1 && bingoArr[6]==-1){
      return true ;
    }
    if(bingoArr[1]==-1 && bingoArr[4]==-1 && bingoArr[7]==-1){
      return true ;
    }
    if(bingoArr[2]==-1 && bingoArr[5]==-1 && bingoArr[8]==-1){
      return true ;
    }
    if(bingoArr[0]==-1 && bingoArr[4]==-1 && bingoArr[8]==-1){
      return true ;
    }
    if(bingoArr[2]==-1 && bingoArr[4]==-1 && bingoArr[6]==-1){
      return true ;
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute bingoArr : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mainObj : Main ; mainObj := Main.newMain() ;
     mainObj.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     bingoArr := Integer.subrange(1,9)->collect(0) ; 
        var i : int ; i := 0 ; while i < 9 do ( (     bingoArr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var hole : int ; hole := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < 9 do ( (     if (bingoArr[j+1] = hole) then (     bingoArr[j+1] := -1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (checkBingo()) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.out"].println("No") ; 
 );
   operation checkBingo() : boolean
  pre: true
  post: true
  activity: (     if (bingoArr[0+1] = -1 & bingoArr[1+1] = -1 & bingoArr[2+1] = -1) then (     return true ) else skip ; 
     if (bingoArr[3+1] = -1 & bingoArr[4+1] = -1 & bingoArr[5+1] = -1) then (     return true ) else skip ; 
    if (bingoArr[6+1] = -1 & bingoArr[7+1] = -1 & bingoArr[8+1] = -1) then (     return true ) else skip ; 
    if (bingoArr[0+1] = -1 & bingoArr[3+1] = -1 & bingoArr[6+1] = -1) then (     return true ) else skip ; 
    if (bingoArr[1+1] = -1 & bingoArr[4+1] = -1 & bingoArr[7+1] = -1) then (     return true ) else skip ; 
    if (bingoArr[2+1] = -1 & bingoArr[5+1] = -1 & bingoArr[8+1] = -1) then (     return true ) else skip ; 
    if (bingoArr[0+1] = -1 & bingoArr[4+1] = -1 & bingoArr[8+1] = -1) then (     return true ) else skip ; 
    if (bingoArr[2+1] = -1 & bingoArr[4+1] = -1 & bingoArr[6+1] = -1) then (     return true ) else skip ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class PeakElement {
  static int findPeakUtil(int arr[],int low,int high,int n){
    int mid=low+(high-low)/2 ;
    if((mid==0 || arr[mid-1]<=arr[mid])&&(mid==n-1 || arr[mid+1]<=arr[mid]))return mid ;
    else if(mid>0 && arr[mid-1]>arr[mid])return findPeakUtil(arr,low,(mid-1),n);
    else return findPeakUtil(arr,(mid+1),high,n);
  }
  static int findPeak(int arr[],int n){
    return findPeakUtil(arr,0,n-1,n);
  }
  public static void main(String[] args){
    int arr[]={
      1,3,20,4,1,0 };
      int n=arr.length ;
      System.out.println("Index of a peak point is "+findPeak(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class PeakElement {
  static   operation findPeakUtil( arr : Sequence(int), low : int, high : int, n : int) : int
  pre: true
  post: true
  activity: (     var mid : int ; mid := low + (high - low) / 2 ;
     if ((mid = 0 or arr[mid - 1+1] <= arr[mid+1]) & (mid = n - 1 or arr[mid + 1+1] <= arr[mid+1])) then     return mid else     if (mid > 0 & arr[mid - 1+1] > arr[mid+1]) then     return findPeakUtil(arr, low, (mid - 1), n) else     return findPeakUtil(arr, (mid + 1), high, n) ;  );
  static   operation findPeak( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     return findPeakUtil(arr, 0, n - 1, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,20,4,1,0} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Index of a peak point is " + findPeak(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Map.Entry ;
class Main {
  static int mod=(int)(Math.pow(10,9)+7);
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] b=new int[9];
    for(int i=0 ; i<9 ; i++){
      b[i]=sc.nextInt();
    }
    int N=sc.nextInt();
    boolean[] m=new boolean[9];
    for(int i=0 ; i<N ; i++){
      int tmp=sc.nextInt();
      for(int j=0 ; j<9 ; j++){
        if(tmp==b[j]){
          m[j]=true ;
        }
      }
    }
    String ans="No" ;
    if(m[0] && m[1] && m[2] || m[3] && m[4] && m[5] || m[6] && m[7] && m[8] || m[0] && m[3] && m[6] || m[1] && m[4] && m[7] || m[2] && m[5] && m[8] || m[0] && m[4] && m[8] || m[2] && m[4] && m[6]){
      ans="Yes" ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := (10->pow(9) + 7)->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var b : Sequence(int) ; b := Integer.subrange(1,9)->collect(0) ;
        var i : int ; i := 0 ; while i < 9 do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var m : Sequence(boolean) ; m := Integer.subrange(1,9)->collect(false) ;
        var i : int ; i := 0 ; while i < N do ( (     var tmp : int ; tmp := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < 9 do ( (     if (tmp = b[j+1]) then (     m[j+1] := true ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "No" ;
    if (m[0+1] & m[1+1] & m[2+1] or m[3+1] & m[4+1] & m[5+1] or m[6+1] & m[7+1] & m[8+1] or m[0+1] & m[3+1] & m[6+1] or m[1+1] & m[4+1] & m[7+1] or m[2+1] & m[5+1] & m[8+1] or m[0+1] & m[4+1] & m[8+1] or m[2+1] & m[4+1] & m[6+1]) then (     ans := "Yes" ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p023 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p023().run());
  }
  private static final int LIMIT=28123 ;
  private boolean[] isAbundant=new boolean[LIMIT+1];
  public String run(){
    for(int i=1 ; i<isAbundant.length ; i++)isAbundant[i]=isAbundant(i);
    int sum=0 ;
    for(int i=1 ; i<=LIMIT ; i++){
      if(! isSumOf2Abundants(i))sum+=i ;
    }
    return Integer.toString(sum);
  }
  private boolean isSumOf2Abundants(int n){
    for(int i=0 ; i<=n ; i++){
      if(isAbundant[i] && isAbundant[n-i])return true ;
    }
    return false ;
  }
  private static boolean isAbundant(int n){
    if(n<1)throw new IllegalArgumentException();
    int sum=1 ;
    int end=Library.sqrt(n);
    for(int i=2 ; i<=end ; i++){
      if(n % i==0)sum+=i+n/i ;
    }
    if(end*end==n)sum-=end ;
    return sum>n ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p023 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p023.newp023().run()) );
  static    attribute LIMIT : int := 28123;
   attribute isAbundant : Sequence(boolean) := Integer.subrange(1,LIMIT + 1)->collect(false);
   operation run() : String
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < isAbundant->size() do (     isAbundant[i+1] := isAbundant(i) ;  ;     i := i + 1 ) ; 
     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= LIMIT do ( (     if (not(isSumOf2Abundants(i))) then     sum := sum+(i) ; else skip )  ;     i := i + 1 ) ; 
     return ((sum) + "") );
   operation isSumOf2Abundants( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= n do ( (     if (isAbundant[i+1] & isAbundant[n - i+1]) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation isAbundant( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n < 1) then     error IllegalArgumentException.newIllegalArgumentException() ; else skip ; 
     var sum : int ; sum := 1 ;
    var end : int ; end := Library.sqrt(n) ;
        var i : int ; i := 2 ; while i <= end do ( (     if (n mod i = 0) then     sum := sum+(i + n / i) ; else skip )  ;     i := i + 1 ) ; 
    if (end * end = n) then     sum := sum-(end) ; else skip ; 
    return sum > n 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int binomialCoeffSum(int n){
    int C[][]=new int[n+1][n+1];
    for(int i=0 ; i<=n ; i++){
      for(int j=0 ; j<=Math.min(i,n); j++){
        if(j==0 || j==i)C[i][j]=1 ;
        else C[i][j]=C[i-1][j-1]+C[i-1][j];
      }
    }
    int sum=0 ;
    for(int i=0 ; i<=n ; i++)sum+=C[n][i];
    return sum ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(binomialCoeffSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation binomialCoeffSum( n : int) : int
  pre: true
  post: true
  activity: (     var C : Sequence(Sequence(int)) ; C := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= Set{i, n}->min() do ( (     if (j = 0 or j = i) then     C[i+1][j+1] := 1 ; else     C[i+1][j+1] := C[i - 1+1][j - 1+1] + C[i - 1+1][j+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i <= n do (     sum := sum+(C[n+1][i+1]) ;  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(binomialCoeffSum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  public static ArrayList<String>s=new ArrayList<String>();
  public static void main(String[] args)throws IOException {
    FastScanner in=new FastScanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt();
    int[] a=new int[n];
    int num4=0 ;
    int num2=0 ;
    int b=0 ;
    for(int i=0 ; i<a.length ; i++){
      a[i]=in.nextInt();
      if(a[i] % 4==0){
        num4++;
      }
      else if(a[i] % 2==0){
        num2++;
      }
      else {
        b++;
      }
    }
    if(b==num4+1 && num2==0){
      System.out.println("Yes");
      return ;
    }
    if(b>num4){
      System.out.println("No");
      return ;
    }
    System.out.println("Yes");
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(InputStream in){
      br=new BufferedReader(new InputStreamReader(in));
      st=new StringTokenizer("");
    }
    public double nextDouble()throws NumberFormatException,IOException {
      return Double.parseDouble(next());
    }
    public String next()throws IOException {
      if(! st.hasMoreTokens()){
        st=new StringTokenizer(br.readLine());
        return next();
      }
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : Sequence(String) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var num4 : int ; num4 := 0 ;
    var num2 : int ; num2 := 0 ;
    var b : int ; b := 0 ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := in.nextInt() ; 
     if (a[i+1] mod 4 = 0) then (     num4 := num4 + 1 ) else     if (a[i+1] mod 2 = 0) then (     num2 := num2 + 1 ) else (     b := b + 1 ) ;  )  ;     i := i + 1 ) ; 
    if (b = num4 + 1 & num2 = 0) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
    if (b > num4) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
    OclFile["System.out"].println("Yes") ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     st := OclIterator.newOclIterator_String("") );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation next() : String
  pre: true
  post: true
  activity: (     if (not(st.hasNext())) then (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     return next() ) else skip ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    Obj[] array=new Obj[m];
    for(int i=0 ; i<m ; i++){
      Obj o=new Obj();
      o.a=sc.nextInt();
      o.b=sc.nextInt();
      array[i]=o ;
    }
    sc.close();
    Arrays.sort(array,new Comparator<Obj>(){
      public int compare(Obj o1,Obj o2){
        return o1.b-o2.b ;
      }
    }
);
    int ans=1 ;
    int br=array[0] .b ;
    for(int i=1 ; i<m ; i++){
      if(array[i] .a>=br){
        ans++;
        br=array[i] .b ;
      }
    }
    System.out.println(ans);
  }
  static class Obj {
    int a,b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var array : Sequence(Obj) ; array := Integer.subrange(1,m)->collect(null) ;
        var i : int ; i := 0 ; while i < m do ( (     var o : Obj ; o := Obj.newObj() ;
     o.a := sc.getCurrent()->toInteger() ; 
     o.b := sc.getCurrent()->toInteger() ; 
     array[i+1] := o )  ;     i := i + 1 ) ; 
    skip ; 
    array := OclComparator.sortWith(array, OclComparator<Obj>.newOclComparator()) ; 
    var ans : int ; ans := 1 ;
    var br : int ; br := array[0+1].b ;
        var i : int ; i := 1 ; while i < m do ( (     if (array[i+1].a >= br) then (     ans := ans + 1 ; 
     br := array[i+1].b ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class Obj {
   attribute a : int;
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String...args){
    int N=IN.nextInt();
    int M=IN.nextInt();
    int[] a=new int[M];
    int[] b=new int[M];
    ArrayList<Integer>xr=new ArrayList<Integer>();
    for(int i=0 ; i<M ; i++){
      a[i]=IN.nextInt();
      b[i]=IN.nextInt();
      xr.add(i);
    }
    xr.sort((i,j)->{
      int tmp=a[i]-a[j];
      return tmp!=0 ? tmp : b[i]-b[j];
    }
);
    int sunk=N ;
    int ans=0 ;
    int left=-1 ;
    int rMin=-1 ;
    for(int x : xr){
      if(left!=a[x]){
        left=a[x];
        rMin=b[x];
      }
      else {
        continue ;
      }
      if(sunk<=left){
        sunk=rMin ;
        ans++;
      }
      else {
        if(rMin<sunk){
          sunk=rMin ;
        }
      }
    }
    puts(ans+1);
  }
  static final Scanner IN=new Scanner(System.in);
  static<T>void puts(T arg){
    System.out.println(arg);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := IN.nextInt() ;
     var M : int ; M := IN.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,M)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,M)->collect(0) ;
    var xr : Sequence(int) ; xr := Sequence{} ;
        var i : int ; i := 0 ; while i < M do ( (     a[i+1] := IN.nextInt() ; 
     b[i+1] := IN.nextInt() ; 
     xr := xr->including(i) )  ;     i := i + 1 ) ; 
    xr := xr.sort(lambda (i , j) : OclAny in (     var tmp : int ; tmp := a[i+1] - a[j+1] ;
     return if tmp /= 0 then tmp else b[i+1] - b[j+1] endif )) ; 
    var sunk : int ; sunk := N ;
    var ans : int ; ans := 0 ;
    var left : int ; left := -1 ;
    var rMin : int ; rMin := -1 ;
    for (x : xr) do ( (     if (left /= a[x+1]) then (     left := a[x+1] ; 
     rMin := b[x+1] ) else (     continue ) ;  
     if (sunk <= left) then (     sunk := rMin ; 
     ans := ans + 1 ) else (     if (rMin < sunk) then (     sunk := rMin ) else skip ) )  ) ; 
    execute puts(ans + 1) ; 
 );
  static    attribute IN : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation puts<T>( arg : T) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(arg) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class demand implements Comparable {
  int from ;
  int to ;
  public int compareTo(Object other){
    demand otherdemand=(demand)other ;
    return to-otherdemand.to ;
  }
}
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    demand[] demands=new demand[m];
    for(int i=0 ; i<m ; i++){
      demand newdemand=new demand();
      newdemand.from=sc.nextInt();
      newdemand.to=sc.nextInt();
      demands[i]=newdemand ;
    }
    Arrays.sort(demands);
    int ans=0 ;
    int nowclear=0 ;
    for(int i=0 ; i<m ; i++){
      int nowfrom=demands[i] .from ;
      int nowto=demands[i] .to ;
      if(nowclear<nowfrom){
        ans++;
        nowclear=nowto-1 ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class demand implements OclAny {
   attribute from : int;
   attribute to : int;
   operation compareTo( other : OclAny) : int
  pre: true
  post: true
  activity: (     var otherdemand : demand ; otherdemand := other->oclAsType(demand) ;
     return to - otherdemand.to );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var demands : Sequence(demand) ; demands := Integer.subrange(1,m)->collect(null) ;
        var i : int ; i := 0 ; while i < m do ( (     var newdemand : demand ; newdemand := demand.newdemand() ;
     newdemand.from := sc.getCurrent()->toInteger() ; 
     newdemand.to := sc.getCurrent()->toInteger() ; 
     demands[i+1] := newdemand )  ;     i := i + 1 ) ; 
    demands := demands->sort() ; 
    var ans : int ; ans := 0 ;
    var nowclear : int ; nowclear := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var nowfrom : int ; nowfrom := demands[i+1].from ;
     var nowto : int ; nowto := demands[i+1].to ;
     if (nowclear < nowfrom) then (     ans := ans + 1 ; 
     nowclear := nowto - 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public void _main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[][] ab=new int[M][2];
    for(int i=0 ; i<M ; i++){
      ab[i]=new int[] {
        sc.nextInt(),sc.nextInt()};
      }
      Arrays.sort(ab,(x,y)->Integer.compare(y[0],x[0]));
      int ans=0 ;
      int prev=Integer.MAX_VALUE ;
      for(int i=0 ; i<M ; i++){
        if(!(prev<ab[i][1])){
          prev=ab[i][0];
          ans++;
        }
      }
      System.out.println(ans);
      sc.close();
    }
    public static void main(String[] args){
      new Main()._main(args);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   operation _main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var ab : Sequence(Sequence(int)) ; ab := Integer.subrange(1,M)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < M do ( (     ab[i+1] := Sequence{sc.getCurrent()->toInteger(),sc.getCurrent()->toInteger()} )  ;     i := i + 1 ) ; 
    ab := OclComparator.sortWith(ab, lambda (x , y) : OclAny in compare(y[0+1], x[0+1])) ; 
    var ans : int ; ans := 0 ;
    var prev : int ; prev := 2147483647 ;
        var i : int ; i := 0 ; while i < M do ( (     if (not((prev < ab[i+1][1+1]))) then (     prev := ab[i+1][0+1] ; 
     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain()._main(args) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    PriorityQueue<Bridge>queue=new PriorityQueue<>();
    for(int i=0 ; i<m ; i++){
      queue.add(new Bridge(sc.nextInt(),sc.nextInt()));
    }
    int count=0 ;
    while(queue.size()>0){
      count++;
      Bridge b=queue.poll();
      while(queue.size()>0 && b.right>queue.peek().left){
        queue.poll();
      }
    }
    System.out.println(count);
  }
  static class Bridge implements Comparable<Bridge>{
    int left ;
    int right ;
    public Bridge(int left,int right){
      this.left=left ;
      this.right=right ;
    }
    public int compareTo(Bridge another){
      if(right==another.right){
        return left-another.left ;
      }
      else {
        return right-another.right ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var queue : Sequence(Bridge) ; queue := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     queue := queue->including(Bridge.newBridge(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    while (queue->size() > 0) do (     count := count + 1 ; 
     var b : Bridge ; b := queue->min() ;
     while (queue->size() > 0 & b.right > queue->min().left) do (     queue := queue->sort()->tail() ) ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static class Bridge implements Comparable<Bridge> {
   attribute left : int;
   attribute right : int;
   static operation newBridge( left : int, right : int) : Bridge
  pre: true
  post: true
  activity:
  ( var self : Bridge ;
    self := createBridge();
    self.initialise(left, right);
    return self );
  operation initialise( left : int, right : int) : void
  pre: true  post: true
  activity: (     self.left := left ; 
     self.right := right );
   operation compareTo( another : Bridge) : int
  pre: true
  post: true
  activity: (     if (right = another.right) then (     return left - another.left ) else (     return right - another.right ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class hw17 {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    {
    }
    {
      String in=scan.next();
      StringBuilder sb=new StringBuilder();
      long heavycnt=0 ;
      long powerful=0 ;
      for(int i=0 ; i<in.length(); i++){
        sb.append(in.charAt(i));
        if(sb.length()>=5 && sb.substring(sb.length()-5).equals("heavy")){
          heavycnt++;
        }
        else if(sb.length()>=5 && sb.substring(sb.length()-5).equals("metal")){
          powerful+=heavycnt ;
        }
      }
      System.out.println(powerful);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class hw17 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 skip 
 (     var in : String ; in := scan.getCurrent() ;
     var sb : String ; sb := StringLib.newString() ;
    var heavycnt : long ; heavycnt := 0 ;
    var powerful : long ; powerful := 0 ;
        var i : int ; i := 0 ; while i < in->size() do ( (     sb := sb + StringLib.newString(in->at(i+1)) ; 
     if (sb->size() >= 5 & sb.subrange(sb->size() - 5+1,sb->size() - 5) = "heavy") then (     heavycnt := heavycnt + 1 ) else     if (sb->size() >= 5 & sb.subrange(sb->size() - 5+1,sb->size() - 5) = "metal") then (     powerful := powerful+(heavycnt) ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(powerful) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf318B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String str=scan.next();
    long counter=0 ;
    long out=0 ;
    for(int i=str.length()-5 ; i>=0 ; i--){
      if(str.substring(i,i+5).equals("metal")){
        counter++;
      }
      if(str.substring(i,i+5).equals("heavy")){
        out=counter+out ;
      }
    }
    System.out.println(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf318B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := scan.getCurrent() ;
    var counter : long ; counter := 0 ;
    var out : long ; out := 0 ;
        var i : int ; i := str->size() - 5 ; while i >= 0 do ( (     if (str.subrange(i+1,i + 5) = "metal") then (     counter := counter + 1 ) else skip ; 
     if (str.subrange(i+1,i + 5) = "heavy") then (     out := counter + out ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder builder=new StringBuilder();
    String line ;
    int[] num=new int[3];
    num[0]=1 ;
    while((line=reader.readLine())!=null){
      if(line.isEmpty())break ;
      if(line.equals("A,B")|| line.equals("B,A")){
        int t=num[0];
        num[0]=num[1];
        num[1]=t ;
      }
      else if(line.equals("A,C")|| line.equals("C,A")){
        int t=num[0];
        num[0]=num[2];
        num[2]=t ;
      }
      else if(line.equals("B,C")|| line.equals("C,B")){
        int t=num[1];
        num[1]=num[2];
        num[2]=t ;
      }
    }
    int result=0 ;
    for(int i=0 ; i<3 ; i++){
      if(num[i]==1){
        result=i ;
      }
    }
    System.out.println(result==0 ? "A" : result==1 ? "B" : "C");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var builder : String ; builder := StringLib.newString() ;
    var line : String ;
    var num : Sequence(int) ; num := Integer.subrange(1,3)->collect(0) ;
    num[0+1] := 1 ; 
        line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->isEmpty()) then     break else skip ; 
     if (line = "A,B" or line = "B,A") then (     var t : int ; t := num[0+1] ;
     num[0+1] := num[1+1] ; 
     num[1+1] := t ) else     if (line = "A,C" or line = "C,A") then (     var t : int ; t := num[0+1] ;
     num[0+1] := num[2+1] ; 
     num[2+1] := t ) else     if (line = "B,C" or line = "C,B") then (     var t : int ; t := num[1+1] ;
     num[1+1] := num[2+1] ; 
     num[2+1] := t ) else skip ; ;  ) ;     line := reader.readLine() ;
 ) ;  
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (num[i+1] = 1) then (     result := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if result = 0 then "A" else if result = 1 then "B" else "C" endif endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class cf318B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String str=scan.nextLine();
    long counter=0L ;
    List<Integer>h=new ArrayList<>();
    List<Integer>m=new ArrayList<>();
    for(int i=0 ; i<str.length()-4 ; i++){
      if(str.substring(i,i+5).equals("heavy")){
        h.add(i);
        i+=3 ;
      }
    }
    for(int i=0 ; i<str.length()-4 ; i++){
      if(str.substring(i,i+5).equals("metal")){
        m.add(i);
        i+=3 ;
      }
    }
    int hp=0 ;
    int mp=0 ;
    while(hp<h.size()&& mp<m.size()){
      if(h.get(hp)<m.get(mp)){
        counter+=m.size()-mp ;
        hp++;
      }
      else {
        mp++;
      }
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf318B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := scan.nextLine() ;
    var counter : long ; counter := 0L ;
    var h : Sequence(int) ; h := Sequence{} ;
    var m : Sequence(int) ; m := Sequence{} ;
        var i : int ; i := 0 ; while i < str->size() - 4 do ( (     if (str.subrange(i+1,i + 5) = "heavy") then (     h := h->including(i) ; 
     i := i+(3) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < str->size() - 4 do ( (     if (str.subrange(i+1,i + 5) = "metal") then (     m := m->including(i) ; 
     i := i+(3) ) else skip )  ;     i := i + 1 ) ; 
    var hp : int ; hp := 0 ;
    var mp : int ; mp := 0 ;
    while (hp < h->size() & mp < m->size()) do (     if (h->at(hp+1) < m->at(mp+1)) then (     counter := counter+(m->size() - mp) ; 
     hp := hp + 1 ) else (     mp := mp + 1 ) ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test1 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int d=in.nextInt();
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=in.nextInt();
    }
    int result=0 ;
    int a=0 ;
    for(int i=1 ; i<n ; i++){
      a=(nums[i-1]-nums[i]);
      if(a>=0){
        result+=a/d+1 ;
        nums[i]+=(a/d+1)*d ;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
    var a : int ; a := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     a := (nums[i - 1+1] - nums[i+1]) ; 
     if (a >= 0) then (     result := result+(a / d + 1) ; 
     nums[i+1] := nums[i+1]+((a / d + 1) * d) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf318B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    StringBuilder input=new StringBuilder();
    input.append(scan.next());
    long heavy=0 ;
    long heavymetal=0 ;
    for(int i=0 ; i<input.length()-4 ; i++){
      if(input.substring(i,i+5).equals("heavy")){
        heavy++;
      }
      else if(input.substring(i,i+5).equals("metal")){
        if(heavy!=0){
          heavymetal+=heavy ;
        }
      }
    }
    System.out.println(heavymetal);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf318B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : String ; input := StringLib.newString() ;
    input := input + StringLib.newString(scan.getCurrent()) ; 
    var heavy : long ; heavy := 0 ;
    var heavymetal : long ; heavymetal := 0 ;
        var i : int ; i := 0 ; while i < input->size() - 4 do ( (     if (input.subrange(i+1,i + 5) = "heavy") then (     heavy := heavy + 1 ) else     if (input.subrange(i+1,i + 5) = "metal") then (     if (heavy /= 0) then (     heavymetal := heavymetal+(heavy) ) else skip ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(heavymetal) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
public class Main {
  static long findSmallestNonZeroY(long A_num){
    String A_binary=Long.toBinaryString(A_num);
    long B=1 ;
    int len=A_binary.length();
    int no_ones=Long.bitCount(A_num);
    if(len==no_ones){
      return A_num+1 ;
    }
    for(int i=0 ; i<len ; i++){
      char ch=A_binary.charAt(len-i-1);
      if(ch=='0'){
        B=(long)Math.pow(2.0,(double)i);
        break ;
      }
    }
    return B ;
  }
  public static void main(String[] args){
    long X=findSmallestNonZeroY(10);
    System.out.println(X);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation findSmallestNonZeroY( A_num : long) : long
  pre: true
  post: true
  activity: (     var A_binary : String ; A_binary := (MathLib.decimal2binary(A_num) + "") ;
     var B : long ; B := 1 ;
    var len : int ; len := A_binary->size() ;
    var no_ones : int ; no_ones := bitCount(A_num) ;
    if (len = no_ones) then (     return A_num + 1 ) else skip ; 
        var i : int ; i := 0 ; while i < len do ( (     var ch : String ; ch := A_binary->at(len - i - 1+1) ;
     if (ch = '0') then (     B := 2.0->pow(i->oclAsType(double))->oclAsType(long) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    return B 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : long ; X := findSmallestNonZeroY(10) ;
     OclFile["System.out"].println(X) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class MatrixChainMultiplication {
  static int MatrixChainOrder(int p[],int i,int j){
    if(i==j)return 0 ;
    int min=Integer.MAX_VALUE ;
    for(int k=i ; k<j ; k++){
      int count=MatrixChainOrder(p,i,k)+MatrixChainOrder(p,k+1,j)+p[i-1]*p[k]*p[j];
      if(count<min)min=count ;
    }
    return min ;
  }
  public static void main(String args[]){
    int arr[]=new int[] {
      1,2,3,4,3 };
      int n=arr.length ;
      System.out.println("Minimum number of multiplications is "+MatrixChainOrder(arr,1,n-1));
    }
  }

------------------------------------------------------------
OCL File:
---------
class MatrixChainMultiplication {
  static   operation MatrixChainOrder( p : Sequence(int), i : int, j : int) : int
  pre: true
  post: true
  activity: (     if (i = j) then     return 0 else skip ; 
     var min : int ; min := 2147483647 ;
         var k : int ; k := i ; while k < j do ( (     var count : int ; count := MatrixChainOrder(p, i, k) + MatrixChainOrder(p, k + 1, j) + p[i - 1+1] * p[k+1] * p[j+1] ;
     if (count < min) then     min := count ; else skip )  ;     k := k + 1 ) ; 
     return min );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Minimum number of multiplications is " + MatrixChainOrder(arr, 1, n - 1)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int minimumMoves(int k,int l,int r){
    int count=r-l+1 ;
    if(count % k==0)return 0 ;
    return(k-(count % k));
  }
  public static void main(String[] args){
    int k=3,l=10,r=10 ;
    System.out.print(minimumMoves(k,l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumMoves( k : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := r - l + 1 ;
     if (count mod k = 0) then     return 0 else skip ; 
     return (k - (count mod k)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 3 ;
    var l : int ; l := 10 ;
    var r : int ; r := 10 ;
     OclFile["System.out"].print(minimumMoves(k, l, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int calculate_change(int length,int breadth){
    int change=0 ;
    change=length+breadth+((length*breadth)/100);
    return change ;
  }
  public static void main(String args[]){
    int cL=20 ;
    int cB=-10 ;
    int cA=calculate_change(cL,cB);
    System.out.println(+cA);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculate_change( length : int, breadth : int) : int
  pre: true
  post: true
  activity: (     var change : int ; change := 0 ;
     change := length + breadth + ((length * breadth) / 100) ; 
     return change );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cL : int ; cL := 20 ;
     var cB : int ; cB := -10 ;
     var cA : int ; cA := calculate_change(cL, cB) ;
     OclFile["System.out"].println(cA) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isMultipleof5(int n){
    if((n & 1)==1)n<<=1 ;
    float x=n ;
    x=((int)(x*0.1))*10 ;
    if((int)x==n)return true ;
    return false ;
  }
  public static void main(String[] args){
    int i=19 ;
    if(isMultipleof5(i)==true)System.out.println(i+"is multiple of 5");
    else System.out.println(i+" is not a "+"multiple of 5");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isMultipleof5( n : int) : boolean
  pre: true
  post: true
  activity: (     if ((n & 1) = 1) then     n := n*(2->pow(1)) ; else skip ; 
     var x : double ; x := n ;
    x := ((x * 0.1)->oclAsType(int)) * 10 ; 
    if (x->oclAsType(int) = n) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 19 ;
     if (isMultipleof5(i) = true) then     OclFile["System.out"].println(i + "is multiple of 5") ; else     OclFile["System.out"].println(i + " is not a " + "multiple of 5") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static ArrayList<Integer>primes=new ArrayList<Integer>();
  static void segmentedSieve(){
    int n=10000 ;
    int nNew=(n-2)/2 ;
    boolean[] marked=new boolean[nNew+1];
    for(int i=1 ; i<=nNew ; i++)for(int j=i ; (i+j+2*i*j)<=nNew ; j++)marked[i+j+2*i*j]=true ;
    primes.add(2);
    for(int i=1 ; i<=nNew ; i++)if(marked[i]==false)primes.add(2*i+1);
  }
  static int Nfactors(int a,int b,int n){
    segmentedSieve();
    int result=0 ;
    for(int i=a ; i<=b ; i++){
      int tmp=(int)Math.sqrt(i),copy=i ;
      int count=0 ;
      for(int j=0 ; primes.get(j)<=tmp ; j++){
        if(copy % primes.get(j)==0){
          count++;
          while(copy % primes.get(j)==0)copy=copy/primes.get(j);
        }
      }
      if(copy!=1)count++;
      if(count==n)result++;
    }
    return result ;
  }
  public static void main(String[] args){
    int a=1,b=100,n=3 ;
    System.out.println(Nfactors(a,b,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute primes : Sequence(int) := Sequence{};
  static   operation segmentedSieve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10000 ;
     var nNew : int ; nNew := (n - 2) / 2 ;
    var marked : Sequence(boolean) ; marked := Integer.subrange(1,nNew + 1)->collect(false) ;
        var i : int ; i := 1 ; while i <= nNew do (         var j : int ; j := i ; while (i + j + 2 * i * j) <= nNew do (     marked[i + j + 2 * i * j+1] := true ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    primes := primes->including(2) ; 
        var i : int ; i := 1 ; while i <= nNew do (     if (marked[i+1] = false) then     primes := primes->including(2 * i + 1) ; else skip ;  ;     i := i + 1 ) ; 
 );
  static   operation Nfactors( a : int, b : int, n : int) : int
  pre: true
  post: true
  activity: (     execute segmentedSieve() ; 
     var result : int ; result := 0 ;
         var i : int ; i := a ; while i <= b do ( (     var tmp : int ; tmp := (i)->sqrt()->oclAsType(int) ;
    var copy : int ; copy := i ;
     var count : int ; count := 0 ;
        var j : int ; j := 0 ; while primes->at(j+1) <= tmp do ( (     if (copy mod primes->at(j+1) = 0) then (     count := count + 1 ; 
     while (copy mod primes->at(j+1) = 0) do     copy := copy / primes->at(j+1) ; ) else skip )  ;     j := j + 1 ) ; 
    if (copy /= 1) then     count := count + 1 ; else skip ; 
    if (count = n) then     result := result + 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 1 ;
    var b : int ; b := 100 ;
    var n : int ; n := 3 ;
     OclFile["System.out"].println(Nfactors(a, b, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String ans="" ;
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    if(a>b && a>c)ans="A" ;
    if(b>a && b>c)ans="B" ;
    if(c>a && c>b)ans="C" ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ans : String ; ans := "" ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    if (a > b & a > c) then     ans := "A" ; else skip ; 
    if (b > a & b > c) then     ans := "B" ; else skip ; 
    if (c > a & c > b) then     ans := "C" ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    String[] indexToAlphabet={
      "A","B","C" };
      Map<String,Integer>alphabetToIndex=new HashMap<>();
      for(int cur=0 ; cur<indexToAlphabet.length ; cur++){
        alphabetToIndex.put(indexToAlphabet[cur],cur);
      }
      Integer[] cup={
        1,0,0 };
        List<String[]>splitStringList=readStdInput(",");
        for(String[] stringLine : splitStringList){
          swap(cup,alphabetToIndex.get(stringLine[0]).intValue(),alphabetToIndex.get(stringLine[1]).intValue());
        }
        for(int cur=0 ; cur<cup.length ; cur++){
          if(cup[cur]==1){
            formatPrintln("%s",indexToAlphabet[cur]);
            break ;
          }
        }
      }
      private static void formatPrint(String format,Object...args){
        System.out.print(String.format(format,args));
      }
      private static void formatPrintln(String format,Object...args){
        formatPrint(format,args);
        System.out.println();
      }
      private static List<String[]>readStdInput(String delim){
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        String buffer=null ;
        List<String[]>splitStringList=new ArrayList<>();
        try {
          while((buffer=br.readLine())!=null){
            if(buffer.isEmpty()){
              break ;
            }
            splitStringList.add(buffer.split(delim));
          }
          br.close();
        }
        catch(IOException e){
        }
        return splitStringList ;
      }
      private static<T>void swap(T[] array,int leftIndex,int rightIndex){
        T temp=array[leftIndex];
        array[leftIndex]=array[rightIndex];
        array[rightIndex]=temp ;
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var indexToAlphabet : Sequence(String) ; indexToAlphabet := Sequence{"A","B","C"} ;
     var alphabetToIndex : Map(String,int) ; alphabetToIndex := Map{} ;
        var cur : int ; cur := 0 ; while cur < indexToAlphabet->size() do ( (     alphabetToIndex := alphabetToIndex->union(Map{indexToAlphabet[cur+1] |-> cur}) )  ;     cur := cur + 1 ) ; 
    var cup : Sequence(int) ; cup := Sequence{1,0,0} ;
    var splitStringList : Sequence(Sequence(String)) ; splitStringList := readStdInput(",") ;
    for (stringLine : splitStringList) do ( (     execute swap(cup, alphabetToIndex->at(stringLine[0+1])->oclAsType(int), alphabetToIndex->at(stringLine[1+1])->oclAsType(int)) )  ) ; 
        var cur : int ; cur := 0 ; while cur < cup->size() do ( (     if (cup[cur+1] = 1) then (     execute formatPrintln("%s", indexToAlphabet[cur+1]) ; 
     break ) else skip )  ;     cur := cur + 1 ) ; 
 );
  static   operation formatPrint( format : String, args : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(StringLib.format(format,Sequence{args})) );
  static   operation formatPrintln( format : String, args : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     execute formatPrint(format, args) ; 
     OclFile["System.out"].println() );
  static   operation readStdInput( delim : String) : Sequence(Sequence(String))
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var buffer : String ; buffer := null ;
    var splitStringList : Sequence(Sequence(String)) ; splitStringList := Sequence{} ;
    try (         buffer := br.readLine() ;
    while ((buffer) /= null) do (    skip ; (     if (buffer->isEmpty()) then (     break ) else skip ; 
     splitStringList := splitStringList->including(buffer->split(delim)) ) ;     buffer := br.readLine() ;
 ) ;  
     skip )   catch (e : IOException) do skip
    return splitStringList 
 );
  static   operation swap<T>( array : Sequence(T), leftIndex : int, rightIndex : int) : void
  pre: true
  post: true
  activity: (     var temp : T ; temp := array[leftIndex+1] ;
     array[leftIndex+1] := array[rightIndex+1] ; 
     array[rightIndex+1] := temp );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int max=0 ;
    int idx=0 ;
    for(int i=0 ; i<3 ; i++){
      int x=sc.nextInt();
      if(max<x){
        max=x ;
        idx=i ;
      }
    }
    System.out.println((char)('A'+idx));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var max : int ; max := 0 ;
    var idx : int ; idx := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (max < x) then (     max := x ; 
     idx := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(('A' + idx)->oclAsType(String)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int nums[]=new int[n];
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      nums[i]=sc.nextInt();
      sum+=nums[i];
    }
    Arrays.sort(nums);
    int count=(n+1)/2 ;
    int i=0 ;
    long ans=0 ;
    while(i<count){
      ans+=nums[n-1-i];
      i++;
    }
    sum-=ans ;
    long res=(ans*ans)+(sum*sum);
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(nums[i+1]) )  ;     i := i + 1 ) ; 
    nums := nums->sort() ; 
    var count : int ; count := (n + 1) / 2 ;
    var i : int ; i := 0 ;
    var ans : long ; ans := 0 ;
    while (i < count) do (     ans := ans+(nums[n - 1 - i+1]) ; 
     i := i + 1 ) ; 
    sum := sum-(ans) ; 
    var res : long ; res := (ans * ans) + (sum * sum) ;
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner input=new Scanner(System.in);
  static public void solve(){
    int a=input.nextInt();
    int b=input.nextInt();
    int c=input.nextInt();
    input.close();
    int max=a ;
    String ans="A" ;
    if(b>max){
      max=b ;
      ans="B" ;
    }
    if(c>max){
      max=c ;
      ans="C" ;
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute input : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ; a := input.getCurrent()->toInteger() ;
     var b : int ; b := input.getCurrent()->toInteger() ;
    var c : int ; c := input.getCurrent()->toInteger() ;
    skip ; 
    var max : int ; max := a ;
    var ans : String ; ans := "A" ;
    if (b > max) then (     max := b ; 
     ans := "B" ) else skip ; 
    if (c > max) then (     max := c ; 
     ans := "C" ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    if(a<b){
      if(b<c)System.out.println("C");
      else System.out.println("B");
    }
    else if(a<c)System.out.println("C");
    else System.out.println("A");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    if (a < b) then (     if (b < c) then     OclFile["System.out"].println("C") ; else     OclFile["System.out"].println("B") ; ) else     if (a < c) then     OclFile["System.out"].println("C") else     OclFile["System.out"].println("A") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int countOddPair(int A[],int N){
    int count=0 ;
    for(int i=0 ; i<N ; i++){
      if((A[i] % 2!=1)){
        count++;
      }
    }
    int evenPairCount=count*(count-1)/2 ;
    int totPairs=N*(N-1)/2 ;
    return totPairs-evenPairCount ;
  }
  public static void main(String[] args){
    int A[]={
      5,6,2,8 };
      int N=A.length ;
      System.out.println(countOddPair(A,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countOddPair( A : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     if ((A[i+1] mod 2 /= 1)) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    var evenPairCount : int ; evenPairCount := count * (count - 1) / 2 ;
    var totPairs : int ; totPairs := N * (N - 1) / 2 ;
    return totPairs - evenPairCount 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{5,6,2,8} ;
     var N : int ; N := A->size() ;
     OclFile["System.out"].println(countOddPair(A, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long minOperations(long n){
    long count=0 ;
    long d=0 ;
    if(n==1)return 0 ;
    while(n>9){
      d=Math.max(n % 10,d);
      n/=10 ;
      count+=10 ;
    }
    d=Math.max(d,n-1);
    count+=Math.abs(d);
    return count-1 ;
  }
  public static void main(String[] args){
    long n=240 ;
    System.out.println(minOperations(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minOperations( n : long) : long
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
     var d : long ; d := 0 ;
    if (n = 1) then     return 0 else skip ; 
    while (n > 9) do (     d := Set{n mod 10, d}->max() ; 
     n := n/(10) ; 
     count := count+(10) ) ; 
    d := Set{d, n - 1}->max() ; 
    count := count+(if d < 0 then -(d) else d endif) ; 
    return count - 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 240 ;
     OclFile["System.out"].println(minOperations(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static void main(String[] args){
    InputReader in=new InputReader();
    PrintWriter out=new PrintWriter(System.out);
    Solver s=new Solver();
    int test=1 ;
    for(int i=1 ; i<=test ; i++){
      s.solve(i,in,out);
    }
    out.close();
  }
  static class Solver {
    void solve(int test_case,InputReader in,PrintWriter out){
      int n=in.nextInt();
      out.println((long)Math.sqrt(n)*(long)Math.sqrt(n));
    }
  }
  static class InputReader {
    BufferedReader br ;
    StringTokenizer st ;
    public InputReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : InputReader ; in := InputReader.newInputReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : Solver ; s := Solver.newSolver() ;
    var test : int ; test := 1 ;
        var i : int ; i := 1 ; while i <= test do ( (     s.solve(i, in, out) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class Solver {
   operation solve( test_case : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     skip );
}
  static class InputReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newInputReader() : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    AtCoder solver=new AtCoder();
    solver.solve(1,in,out);
    out.close();
  }
  static class AtCoder {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      long n=in.nextLong();
      for(int i=0 ; ; i++){
        if(i*i>n){
          out.println((i-1)*(i-1));
          break ;
        }
        else if(i*i==n){
          out.println(i*i);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : AtCoder ; solver := AtCoder.newAtCoder() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class AtCoder {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : long ; n := in.getCurrent()->toLong() ;
         var i : int ; i := 0 ; while true do ( (     if (i * i > n) then (     skip ; 
     break ) else     if (i * i = n) then (     skip ; 
     break ) else skip ; )  ;     i := i + 1 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  static Scanner s=new Scanner(System.in);
  static int gInt(){
    return Integer.parseInt(s.next());
  }
  public static void main(String[] $){
    System.out.println((int)Math.pow((int)Math.sqrt(gInt()),2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation gInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((gInt())->sqrt()->oclAsType(int)->pow(2)->oclAsType(int)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  int n ;
  public static void main(String args[]){
    new Main().run();
  }
  void run(){
    FastReader sc=new FastReader();
    n=sc.nextInt();
    solve();
  }
  void solve(){
    int sqrtN=(int)Math.sqrt(n);
    System.out.println(sqrtN*sqrtN);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     n := sc.nextInt() ; 
     execute solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sqrtN : int ; sqrtN := (n)->sqrt()->oclAsType(int) ;
     OclFile["System.out"].println(sqrtN * sqrtN) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    long count=0 ;
    long max=0 ;
    while(true){
      if(count*count>N){
        System.out.println(max);
        System.exit(0);
      }
      else {
        max=count*count ;
      }
++count ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    var count : long ; count := 0 ;
    var max : long ; max := 0 ;
    while (true) do (     if (count * count > N) then (     OclFile["System.out"].println(max) ; 
 OclProcess.exit(0) ) else (     max := count * count ) ;  
     count := count + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minimumProduct(int[] arr,int n){
    Arrays.sort(arr);
    int product=1 ;
    for(int i=0 ; i<n ; i+=2){
      product*=(arr[i]+arr[i+1]);
    }
    return product ;
  }
  public static void main(String[] args){
    int arr[]={
      1,6,3,1,7,8 };
      int n=arr.length ;
      System.out.print(minimumProduct(arr,n)+"\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumProduct( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var product : int ; product := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     product := product*((arr[i+1] + arr[i + 1+1])) )  ;     i := i+(2) ) ; 
     return product );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,6,3,1,7,8} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(minimumProduct(arr, n) + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    C(sc);
  }
  public static void A(Scanner sc){
    out.println(sc.nextInt()/3);
  }
  public static void B(Scanner sc){
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      if(sc.next().charAt(0)=='Y'){
        out.println("Four");
        return ;
      }
    }
    out.println("Three");
  }
  public static void C(Scanner sc){
    HashMap<Character,Integer>map=new HashMap<Character,Integer>();
    int N=sc.nextInt();
    for(int i=0 ; i<N ; i++){
      char c=sc.next().charAt(0);
      if(map.containsKey(c))map.put(c,map.get(c)+1);
      else map.put(c,1);
    }
    ArrayList<Integer>arr=new ArrayList<Integer>();
    HashSet<Character>lis=new HashSet<Character>(Arrays.asList('M','A','R','C','H'));
    for(Character c : map.keySet()){
      if(lis.contains(c)){
        arr.add(map.get(c));
      }
    }
    out.println(retksum(arr.toArray(new Integer[arr.size()]),0,3));
  }
  public static long retksum(Integer[] arr,int idx,int k){
    if(k==0)return 1 ;
    if(arr.length-idx<k)return 0 ;
    return arr[idx]*retksum(arr,idx+1,k-1)+retksum(arr,idx+1,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute C(sc) );
  static   operation A( sc : OclFile) : void
  pre: true
  post: true
  activity: (     out.println(sc.getCurrent()->toInteger() / 3) );
  static   operation B( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     if (sc.getCurrent()->at(0+1) = 'Y') then (     out.println("Four") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     out.println("Three") );
  static   operation C( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var map : Map(String,int) ; map := Map{} ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < N do ( (     var c : String ; c := sc.getCurrent()->at(0+1) ;
     if (map->keys()->includes(c)) then     map := map->union(Map{c |-> map->at(c) + 1}) ; else     map := map->union(Map{c |-> 1}) ; )  ;     i := i + 1 ) ; 
    var arr : Sequence(int) ; arr := Sequence{} ;
    var lis : Set(String) ; lis := Set{}->union(Sequence{'M','A','R','C','H'}) ;
    for (c : map->keys()) do ( (     if (lis->includes(c)) then (     arr := arr->including(map->at(c)) ) else skip )  ) ; 
    out.println(retksum(arr->asSequence(), 0, 3)) ; 
 );
  static   operation retksum( arr : Sequence(int), idx : int, k : int) : long
  pre: true
  post: true
  activity: (     if (k = 0) then     return 1 else skip ; 
     if (arr->size() - idx < k) then     return 0 else skip ; 
     return arr[idx+1] * retksum(arr, idx + 1, k - 1) + retksum(arr, idx + 1, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void checkTypeOfTriangle(int a,int b,int c){
    int sqa=(int)Math.pow(a,2);
    int sqb=(int)Math.pow(b,2);
    int sqc=(int)Math.pow(c,2);
    if(sqa==sqa+sqb || sqb==sqa+sqc || sqc==sqa+sqb){
      System.out.print("Right-angled Triangle");
    }
    else if(sqa>sqc+sqb || sqb>sqa+sqc || sqc>sqa+sqb){
      System.out.print("Obtuse-angled Triangle");
    }
    else {
      System.out.print("Acute-angled Triangle");
    }
  }
  public static void main(String[] args){
    int a,b,c ;
    a=2 ;
    b=2 ;
    c=2 ;
    checkTypeOfTriangle(a,b,c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkTypeOfTriangle( a : int, b : int, c : int) : void
  pre: true
  post: true
  activity: (     var sqa : int ; sqa := a->pow(2)->oclAsType(int) ;
     var sqb : int ; sqb := b->pow(2)->oclAsType(int) ;
     var sqc : int ; sqc := c->pow(2)->oclAsType(int) ;
     if (sqa = sqa + sqb or sqb = sqa + sqc or sqc = sqa + sqb) then (     OclFile["System.out"].print("Right-angled Triangle") ) else     if (sqa > sqc + sqb or sqb > sqa + sqc or sqc > sqa + sqb) then (     OclFile["System.out"].print("Obtuse-angled Triangle") ) else (     OclFile["System.out"].print("Acute-angled Triangle") ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ;
    var b : int ;
    var c : int ;
     a := 2 ; 
    b := 2 ; 
    c := 2 ; 
    execute checkTypeOfTriangle(a, b, c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class Main {
  public static void main(String[] args){
    try {
      BufferedReader questionreader=new BufferedReader(new InputStreamReader(System.in));
      PrintWriter answerwriter=new PrintWriter(System.out);
      String answer="A" ;
      String[] params=null ;
      String question=null ;
      while(questionreader.ready()){
        if("".equals(question=questionreader.readLine()))break ;
        params=question.split(",");
        if(answer.equals(params[0]))answer=params[1];
        else if(answer.equals(params[1]))answer=params[0];
      }
      answerwriter.println(answer);
      answerwriter.close();
      questionreader.close();
    }
    catch(FileNotFoundException e){
      e.printStackTrace();
      return ;
    }
    catch(IOException e){
      e.printStackTrace();
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var questionreader : OclFile ; questionreader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var answerwriter : OclFile ; answerwriter := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var answer : String ; answer := "A" ;
    var params : Sequence(String) ; params := null ;
    var question : String ; question := null ;
    while (questionreader.canRead()) do (     if ("" = question) then     break else skip ; 
     params := question->split(",") ; 
     if (answer = params[0+1]) then     answer := params[1+1] ; else     if (answer = params[1+1]) then     answer := params[0+1] ; else skip ; ) ; 
    skip ; 
    skip ; 
    skip ; 
 )   catch (e : FileNotFoundException) do (     e.printStackTrace() ; 
     return )
   catch (e : IOException) do (     e.printStackTrace() ; 
     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void nDigitPerfectCubes(int n){
    int smallest=(int)Math.pow(Math.ceil(Math.cbrt(Math.pow(10,(n-1)))),3);
    System.out.print(smallest+" ");
    int largest=(int)Math.pow(Math.ceil(Math.cbrt(Math.pow(10,(n))))-1,3);
    System.out.print(largest);
  }
  public static void main(String args[]){
    int n=3 ;
    nDigitPerfectCubes(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nDigitPerfectCubes( n : int) : void
  pre: true
  post: true
  activity: (     var smallest : int ; smallest := ((10->pow((n - 1)))->cbrt())->ceil()->pow(3)->oclAsType(int) ;
     OclFile["System.out"].print(smallest + " ") ; 
     var largest : int ; largest := ((10->pow((n)))->cbrt())->ceil() - 1->pow(3)->oclAsType(int) ;
     OclFile["System.out"].print(largest) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     execute nDigitPerfectCubes(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countNumbersWith4(int n){
    int result=0 ;
    for(int x=1 ; x<=n ; x++)result+=has4(x)? 1 : 0 ;
    return result ;
  }
  static boolean has4(int x){
    while(x!=0){
      if(x % 10==4)return true ;
      x=x/10 ;
    }
    return false ;
  }
  public static void main(String args[]){
    int n=328 ;
    System.out.println("Count of numbers from 1 to "+" that have 4 as a a digit is "+countNumbersWith4(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countNumbersWith4( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var x : int ; x := 1 ; while x <= n do (     result := result+(if has4(x) then 1 else 0 endif) ;  ;     x := x + 1 ) ; 
     return result );
  static   operation has4( x : int) : boolean
  pre: true
  post: true
  activity: (     while (x /= 0) do (     if (x mod 10 = 4) then     return true else skip ; 
     x := x / 10 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 328 ;
     OclFile["System.out"].println("Count of numbers from 1 to " + " that have 4 as a a digit is " + countNumbersWith4(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;
import java.util.regex.*;
class GFG {
  static int summingSeries(long n){
    int S=0 ;
    for(i=1 ; i<=n ; i++)S+=i*i-(i-1)*(i-1);
    return S ;
  }
  public static void main(String[] args){
    int n=100 ;
    System.out.println("The sum of n term is: "+summingSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation summingSeries( n : long) : int
  pre: true
  post: true
  activity: (     var S : int ; S := 0 ;
         i := 1 ; while i <= n do (     S := S+(i * i - (i - 1) * (i - 1)) ;  ;     i := i + 1 ) ; 
     return S );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 100 ;
     OclFile["System.out"].println("The sum of n term is: " + summingSeries(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;
import java.util.regex.*;
class GFG {
  static int summingSeries(long n){
    return(int)Math.pow(n,2);
  }
  public static void main(String[] args){
    int n=100 ;
    System.out.println("The sum of n term is: "+summingSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation summingSeries( n : long) : int
  pre: true
  post: true
  activity: (     return n->pow(2)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 100 ;
     OclFile["System.out"].println("The sum of n term is: " + summingSeries(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int w=stdIn.nextInt();
    int h=stdIn.nextInt();
    int n=stdIn.nextInt();
    int nowx=stdIn.nextInt();
    int nowy=stdIn.nextInt();
    int counter=0 ;
    for(int i=1 ; i<n ; i++){
      int tox=stdIn.nextInt();
      int toy=stdIn.nextInt();
      if((nowx>tox && nowy<toy)||(nowx<tox && nowy>toy)){
        counter+=Math.abs(nowx-tox)+Math.abs(nowy-toy);
      }
      else {
        counter+=Math.max(Math.abs(nowx-tox),Math.abs(nowy-toy));
      }
      nowx=tox ;
      nowy=toy ;
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := stdIn.getCurrent()->toInteger() ;
    var h : int ; h := stdIn.getCurrent()->toInteger() ;
    var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var nowx : int ; nowx := stdIn.getCurrent()->toInteger() ;
    var nowy : int ; nowy := stdIn.getCurrent()->toInteger() ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     var tox : int ; tox := stdIn.getCurrent()->toInteger() ;
     var toy : int ; toy := stdIn.getCurrent()->toInteger() ;
    if ((nowx > tox & nowy < toy) or (nowx < tox & nowy > toy)) then (     counter := counter+(if nowx - tox < 0 then -(nowx - tox) else nowx - tox endif + if nowy - toy < 0 then -(nowy - toy) else nowy - toy endif) ) else (     counter := counter+(Set{if nowx - tox < 0 then -(nowx - tox) else nowx - tox endif, if nowy - toy < 0 then -(nowy - toy) else nowy - toy endif}->max()) ) ;  
    nowx := tox ; 
    nowy := toy ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public int now_x ;
  public int now_y ;
  public Main(){
  }
  public int walk(int por_x,int por_y){
    int min=0 ;
    int x=por_x-now_x ;
    int y=por_y-now_y ;
    if(x>0 && y>0){
      min+=Math.min(x,y);
      min+=Math.abs(x-y);
    }
    else if(x<0 && y>0){
      x=-x ;
      min+=x+y ;
    }
    else if(x<0 && y<0){
      x=-x ;
      y=-y ;
      min+=Math.min(x,y);
      min+=Math.abs(x-y);
    }
    else if(x>0 && y<0){
      y=-y ;
      min+=x+y ;
    }
    else if(x==0 && y!=0){
      min+=Math.abs(y);
    }
    else if(x!=0 && y==0){
      min+=Math.abs(x);
    }
    now_x=por_x ;
    now_y=por_y ;
    return min ;
  }
  public void doIt(){
    Scanner sc=new Scanner(System.in);
    int W=sc.nextInt();
    int H=sc.nextInt();
    int N=sc.nextInt();
    now_x=sc.nextInt();
    now_y=sc.nextInt();
    int answer=0 ;
    for(int i=0 ; i<N-1 ; i++){
      int por_x=sc.nextInt();
      int por_y=sc.nextInt();
      answer+=walk(por_x,por_y);
    }
    System.out.println(answer);
  }
  public static void main(String[] args){
    Main m=new Main();
    m.doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute now_x : int;
   attribute now_y : int;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   operation walk( por_x : int, por_y : int) : int
  pre: true
  post: true
  activity: (     var min : int ; min := 0 ;
     var x : int ; x := por_x - now_x ;
    var y : int ; y := por_y - now_y ;
    if (x > 0 & y > 0) then (     min := min+(Set{x, y}->min()) ; 
     min := min+(if x - y < 0 then -(x - y) else x - y endif) ) else     if (x < 0 & y > 0) then (     x := -x ; 
     min := min+(x + y) ) else     if (x < 0 & y < 0) then (     x := -x ; 
     y := -y ; 
     min := min+(Set{x, y}->min()) ; 
     min := min+(if x - y < 0 then -(x - y) else x - y endif) ) else     if (x > 0 & y < 0) then (     y := -y ; 
     min := min+(x + y) ) else     if (x = 0 & y /= 0) then (     min := min+(if y < 0 then -(y) else y endif) ) else     if (x /= 0 & y = 0) then (     min := min+(if x < 0 then -(x) else x endif) ) else skip ; ;  ;  ;  ;  ;  
    now_x := por_x ; 
    now_y := por_y ; 
    return min 
 );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var W : int ; W := sc.getCurrent()->toInteger() ;
    var H : int ; H := sc.getCurrent()->toInteger() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    now_x := sc.getCurrent()->toInteger() ; 
    now_y := sc.getCurrent()->toInteger() ; 
    var answer : int ; answer := 0 ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     var por_x : int ; por_x := sc.getCurrent()->toInteger() ;
     var por_y : int ; por_y := sc.getCurrent()->toInteger() ;
     answer := answer+(walk(por_x, por_y)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int W,H,N ;
    words=br.readLine().split(" ");
    W=parseInt(words[0]);
    H=parseInt(words[1]);
    N=parseInt(words[2]);
    int sX,sY,tX,tY ;
    int ans=0 ;
    line=br.readLine();
    sX=parseInt(line.substring(0,line.indexOf(' ')));
    sY=parseInt(line.substring(line.indexOf(' ')+1));
    for(int i=0 ; i<N-1 ; i++){
      line=br.readLine();
      tX=parseInt(line.substring(0,line.indexOf(' ')));
      tY=parseInt(line.substring(line.indexOf(' ')+1));
      if((sX<tX && sY<tY)||(sX>tX && sY>tY)){
        ans+=Math.min(Math.abs(sX-tX),Math.abs(sY-tY))+Math.abs(Math.abs(sX-tX)-Math.abs(sY-tY));
      }
      else {
        ans+=Math.abs(Math.abs(sX-tX)+Math.abs(sY-tY));
      }
      sX=tX ;
      sY=tY ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var W : int ;
    var H : int ;
    var N : int ;
    words := br.readLine()->split(" ") ; 
    W := (words[0+1] + "")->toInteger() ; 
    H := (words[1+1] + "")->toInteger() ; 
    N := (words[2+1] + "")->toInteger() ; 
    var sX : int ;
    var sY : int ;
    var tX : int ;
    var tY : int ;
    var ans : int ; ans := 0 ;
    line := br.readLine() ; 
    sX := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    sY := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     line := br.readLine() ; 
     tX := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    tY := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    if ((sX < tX & sY < tY) or (sX > tX & sY > tY)) then (     ans := ans+(Set{if sX - tX < 0 then -(sX - tX) else sX - tX endif, if sY - tY < 0 then -(sY - tY) else sY - tY endif}->min() + if if sX - tX < 0 then -(sX - tX) else sX - tX endif - if sY - tY < 0 then -(sY - tY) else sY - tY endif < 0 then -(if sX - tX < 0 then -(sX - tX) else sX - tX endif - if sY - tY < 0 then -(sY - tY) else sY - tY endif) else if sX - tX < 0 then -(sX - tX) else sX - tX endif - if sY - tY < 0 then -(sY - tY) else sY - tY endif endif) ) else (     ans := ans+(if if sX - tX < 0 then -(sX - tX) else sX - tX endif + if sY - tY < 0 then -(sY - tY) else sY - tY endif < 0 then -(if sX - tX < 0 then -(sX - tX) else sX - tX endif + if sY - tY < 0 then -(sY - tY) else sY - tY endif) else if sX - tX < 0 then -(sX - tX) else sX - tX endif + if sY - tY < 0 then -(sY - tY) else sY - tY endif endif) ) ;  
    sX := tX ; 
    sY := tY ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public static void main(String[] args){
    java.util.Scanner sc=new java.util.Scanner(System.in);
    int w=sc.nextInt();
    int h=sc.nextInt();
    int n=sc.nextInt();
    int spot[][]=new int[n][2];
    int idou[][]=new int[n-1][2];
    for(int i=0 ; i<n ; i++){
      spot[i][0]=sc.nextInt();
      spot[i][1]=sc.nextInt();
    }
    int result=0 ;
    for(int i=0 ; i<n-1 ; i++){
      idou[i][0]=Math.abs(spot[i][0]-spot[i+1][0]);
      idou[i][1]=Math.abs(spot[i][1]-spot[i+1][1]);
      if(((spot[i][1]>spot[i+1][1])&&(spot[i][0]<spot[i+1][0]))||((spot[i][1]<spot[i+1][1])&&(spot[i][0]>spot[i+1][0]))){
        idou[i][0]=idou[i][0]+idou[i][1];
      }
      if(idou[i][0]>idou[i][1]){
        result=result+idou[i][0];
      }
      else {
        result=result+idou[i][1];
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(OclFile["System.in"]) ;
     var w : int ; w := sc.nextInt() ;
    var h : int ; h := sc.nextInt() ;
    var n : int ; n := sc.nextInt() ;
    var spot : Sequence(Sequence(int)) ; spot := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
    var idou : Sequence(Sequence(int)) ; idou := Integer.subrange(1,n - 1)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     spot[i+1][0+1] := sc.nextInt() ; 
     spot[i+1][1+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     idou[i+1][0+1] := if spot[i+1][0+1] - spot[i + 1+1][0+1] < 0 then -(spot[i+1][0+1] - spot[i + 1+1][0+1]) else spot[i+1][0+1] - spot[i + 1+1][0+1] endif ; 
     idou[i+1][1+1] := if spot[i+1][1+1] - spot[i + 1+1][1+1] < 0 then -(spot[i+1][1+1] - spot[i + 1+1][1+1]) else spot[i+1][1+1] - spot[i + 1+1][1+1] endif ; 
     if (((spot[i+1][1+1] > spot[i + 1+1][1+1]) & (spot[i+1][0+1] < spot[i + 1+1][0+1])) or ((spot[i+1][1+1] < spot[i + 1+1][1+1]) & (spot[i+1][0+1] > spot[i + 1+1][0+1]))) then (     idou[i+1][0+1] := idou[i+1][0+1] + idou[i+1][1+1] ) else skip ; 
     if (idou[i+1][0+1] > idou[i+1][1+1]) then (     result := result + idou[i+1][0+1] ) else (     result := result + idou[i+1][1+1] ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int W=sc.nextInt();
    int H=sc.nextInt();
    int N=sc.nextInt();
    int x=sc.nextInt();
    int y=sc.nextInt();
    int d=0 ;
    for(int i=0 ; i<N-1 ; ++i){
      int nx=sc.nextInt();
      int ny=sc.nextInt();
      d+=dist(x,y,nx,ny);
      x=nx ;
      y=ny ;
    }
    System.out.println(d);
  }
  static int dist(int x1,int y1,int x2,int y2){
    if(x1>x2){
      int tmp=x1 ;
      x1=x2 ;
      x2=tmp ;
      tmp=y1 ;
      y1=y2 ;
      y2=tmp ;
    }
    if(y1<y2){
      int diag=Math.min(x2-x1,y2-y1);
      x1+=diag ;
      y1+=diag ;
      return diag+x2-x1+y2-y1 ;
    }
    else {
      return x2-x1+Math.abs(y2-y1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var W : int ; W := sc.getCurrent()->toInteger() ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var d : int ; d := 0 ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     var nx : int ; nx := sc.getCurrent()->toInteger() ;
     var ny : int ; ny := sc.getCurrent()->toInteger() ;
    d := d+(dist(x, y, nx, ny)) ; 
    x := nx ; 
    y := ny ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(d) ; 
 );
  static   operation dist( x1 : int, y1 : int, x2 : int, y2 : int) : int
  pre: true
  post: true
  activity: (     if (x1 > x2) then (     var tmp : int ; tmp := x1 ;
     x1 := x2 ; 
    x2 := tmp ; 
    tmp := y1 ; 
    y1 := y2 ; 
    y2 := tmp ; 
 ) else skip ; 
     if (y1 < y2) then (     var diag : int ; diag := Set{x2 - x1, y2 - y1}->min() ;
     x1 := x1+(diag) ; 
     y1 := y1+(diag) ; 
     return diag + x2 - x1 + y2 - y1 ) else (     return x2 - x1 + if y2 - y1 < 0 then -(y2 - y1) else y2 - y1 endif ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int max=100 ;
  static void countSubsequence(String s,int n){
    int cntG=0,cntF=0,result=0,C=0 ;
    for(int i=0 ; i<n ; i++){
      switch(s.charAt(i)){
        case 'G' : cntG++;
        result+=C ;
        break ;
        case 'F' : cntF++;
        C+=cntG ;
        break ;
        default : continue ;
      }
    }
    System.out.println(result);
  }
  public static void main(String args[]){
    String s="GFGFG" ;
    int n=s.length();
    countSubsequence(s,n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute max : int := 100;
  static   operation countSubsequence( s : String, n : int) : void
  pre: true
  post: true
  activity: (     var cntG : int ; cntG := 0 ;
    var cntF : int ; cntF := 0 ;
    var result : int ; result := 0 ;
    var C : int ; C := 0 ;
         var i : int ; i := 0 ; while i < n do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (s->at(i+1)) ; 
       if _switchval = 'G' then
     cntG := cntG + 1 ; 
    result := result+(C) ; 
    break 
   else skip ;
       if _switchval = 'F' then
     cntF := cntF + 1 ; 
    C := C+(cntG) ; 
    break 
   else skip ;
       if true then
     continue 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(result) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "GFGFG" ;
     var n : int ; n := s->size() ;
     execute countSubsequence(s, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class MaxConsecutiveOnes {
  private static int maxConsecutiveOnes(int x){
    int count=0 ;
    while(x!=0){
      x=(x &(x<<1));
      count++;
    }
    return count ;
  }
  public static void main(String strings[]){
    System.out.println(maxConsecutiveOnes(14));
    System.out.println(maxConsecutiveOnes(222));
  }
}
------------------------------------------------------------
OCL File:
---------
class MaxConsecutiveOnes {
  static   operation maxConsecutiveOnes( x : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (x /= 0) do (     x := (x & ((x*(2->pow(1)))->oclAsType(long))) ; 
     count := count + 1 ) ; 
     return count );
  static   operation main( strings : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(maxConsecutiveOnes(14)) ; 
     OclFile["System.out"].println(maxConsecutiveOnes(222)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    int[] a={
      1,0,0 };
      for(; sc.hasNext(); ){
        String s=sc.next();
        char c1=s.charAt(0);
        char c2=s.charAt(2);
        swap(a,c1-'A',c2-'A');
      }
      for(int i=0 ; i<a.length ; i++){
        if(a[i]==1){
          System.out.println((char)('A'+i));
        }
      }
    }
    void swap(int[] a,int i,int j){
      int t=a[i];
      a[i]=a[j];
      a[j]=t ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,0,0} ;
       while sc.hasNext() do ( (     var s : String ; s := sc.getCurrent() ;
     var c1 : String ; c1 := s->at(0+1) ;
     var c2 : String ; c2 := s->at(2+1) ;
     execute swap(a, (c1)->char2byte() - ('A')->char2byte(), (c2)->char2byte() - ('A')->char2byte()) )  ) ; 
         var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] = 1) then (     OclFile["System.out"].println(('A' + i)->oclAsType(String)) ) else skip )  ;     i := i + 1 ) );
   operation swap( a : Sequence(int), i : int, j : int) : void
  pre: true
  post: true
  activity: (     var t : int ; t := a[i+1] ;
     a[i+1] := a[j+1] ; 
     a[j+1] := t );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s=br.readLine();
    if((s.charAt(s.indexOf(" ")-1)& 1)==0){
      System.out.println("Even");
    }
    else if((s.charAt(s.length()-1)& 1)==0){
      System.out.println("Even");
    }
    else {
      System.out.println("Odd");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := br.readLine() ;
     if ((s->at(s->indexOf(" ")-1 - 1+1) & 1) = 0) then (     OclFile["System.out"].println("Even") ) else     if ((s->at(s->size() - 1+1) & 1) = 0) then (     OclFile["System.out"].println("Even") ) else (     OclFile["System.out"].println("Odd") ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    String result ;
    if(a*b % 2==0){
      result="Even" ;
    }
    else {
      result="Odd" ;
    }
    PrintWriter out=new PrintWriter(System.out);
    out.println(result);
    sc.close();
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := (sc.getCurrent())->toInteger() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    var result : String ;
    if (a * b mod 2 = 0) then (     result := "Even" ) else (     result := "Odd" ) ;  
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int a=scan.nextInt();
    int b=scan.nextInt();
    if(a % 2==1 && b % 2==1){
      System.out.println("Odd");
    }
    else {
      System.out.println("Even");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
     var b : int ; b := scan.getCurrent()->toInteger() ;
     if (a mod 2 = 1 & b mod 2 = 1) then (     OclFile["System.out"].println("Odd") ) else (     OclFile["System.out"].println("Even") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[])throws Exception {
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt(),b=sc.nextInt();
    double p=a*b ;
    if(p % 2==0)System.out.println("Even");
    else System.out.println("Odd");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
     var p : double ; p := a * b ;
     if (p mod 2 = 0) then     OclFile["System.out"].println("Even") ; else     OclFile["System.out"].println("Odd") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    String resMes ;
    Scanner scan=new Scanner(System.in);
    int array[]=new int[2];
    for(int i=0 ; i<array.length ; i++){
      array[i]=scan.nextInt();
    }
    if((array[0]*array[1])% 2==0){
      resMes="Even" ;
    }
    else {
      resMes="Odd" ;
    }
    System.out.println(resMes);
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var resMes : String ;
     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var array : Sequence(int) ; array := Integer.subrange(1,2)->collect(0) ;
        var i : int ; i := 0 ; while i < array->size() do ( (     array[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if ((array[0+1] * array[1+1]) mod 2 = 0) then (     resMes := "Even" ) else (     resMes := "Odd" ) ;  
    OclFile["System.out"].println(resMes) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  private final String[] LESS_THAN_20={
    "","One","Two","Three","Four","Five","Six","Seven","Eight","Nine","Ten","Eleven","Twelve","Thirteen","Fourteen","Fifteen","Sixteen","Seventeen","Eighteen","Nineteen" };
    private final String[] TENS={
      "","Ten","Twenty","Thirty","Forty","Fifty","Sixty","Seventy","Eighty","Ninety" };
      private final String[] THOUSANDS={
        "","Thousand","Million","Billion" };
        public String numberToWords(int num){
          if(num==0)return "Zero" ;
          int i=0 ;
          String words="" ;
          while(num>0){
            if(num % 1000!=0)words=helper(num % 1000)+THOUSANDS[i]+" "+words ;
            num/=1000 ;
            i++;
          }
          return words.trim();
        }
        private String helper(int num){
          if(num==0)return "" ;
          else if(num<20)return LESS_THAN_20[num]+" " ;
          else if(num<100)return TENS[num/10]+" "+helper(num % 10);
          else return LESS_THAN_20[num/100]+" Hundred "+helper(num % 100);
        }
      }

------------------------------------------------------------
OCL File:
---------
class Solution {
   attribute LESS_THANSequence{"","One","Two","Three","Four","Five","Six","Seven","Eight","Nine","Ten","Eleven","Twelve","Thirteen","Fourteen","Fifteen","Sixteen","Seventeen","Eighteen","Nineteen"}0 : Sequence(String) := Sequence{"","One","Two","Three","Four","Five","Six","Seven","Eight","Nine","Ten","Eleven","Twelve","Thirteen","Fourteen","Fifteen","Sixteen","Seventeen","Eighteen","Nineteen"};
   attribute TENS : Sequence(String) := Sequence{"","Ten","Twenty","Thirty","Forty","Fifty","Sixty","Seventy","Eighty","Ninety"};
   attribute THOUSANDS : Sequence(String) := Sequence{"","Thousand","Million","Billion"};
   operation numberToWords( num : int) : String
  pre: true
  post: true
  activity: (     if (num = 0) then     return "Zero" else skip ; 
     var i : int ; i := 0 ;
    var words : String ; words := "" ;
    while (num > 0) do (     if (num mod 1000 /= 0) then     words := helper(num mod 1000) + THOUSANDS[i+1] + " " + words ; else skip ; 
     num := num/(1000) ; 
     i := i + 1 ) ; 
    return words->trim() 
 );
   operation helper( num : int) : String
  pre: true
  post: true
  activity: (     if (num = 0) then     return "" else     if (num < 20) then     return LESS_THANnum0[num+1] + " " else     if (num < 100) then     return TENS[num / 10+1] + " " + helper(num mod 10) else     return LESS_THANnum / 1000[num / 100+1] + " Hundred " + helper(num mod 100) ;  ;  );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      int k=sc.nextInt();
      int each=n/k ;
      int ans=0 ;
      ans+=(each*k);
      n-=(k*each);
      ans+=Math.min(n,k/2);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var each : int ; each := n / k ;
    var ans : int ; ans := 0 ;
    ans := ans+((each * k)) ; 
    n := n-((k * each)) ; 
    ans := ans+(Set{n, k / 2}->min()) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CandiesDivision {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    while(test-->0){
      int n=sc.nextInt();
      int k=sc.nextInt();
      int total=n-n % k ;
      total+=Math.min(k/2,n % k);
      System.out.println(total);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CandiesDivision {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var total : int ; total := n - n mod k ;
    total := total+(Set{k / 2, n mod k}->min()) ; 
    OclFile["System.out"].println(total) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  private static final int MAX=100 ;
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      int[] x=new int[n],y=new int[n],h=new int[n];
      IntStream.range(0,n).forEach(i->{
        x[i]=scanner.nextInt();
        y[i]=scanner.nextInt();
        h[i]=scanner.nextInt();
      }
);
      for(int i=0 ; i<=MAX ; i++){
        for(int j=0 ; j<=MAX ; j++){
          int ch=check(n,x,y,h,i,j);
          if(ch>0){
            System.out.println(i+" "+j+" "+ch);
          }
        }
      }
    }
  }
  private static int check(int n,int[] x,int[] y,int[] h,int cx,int cy){
    int ch=-1 ;
    for(int i=0 ; i<n ; i++){
      if(h[i]>0){
        ch=Math.abs(x[i]-cx)+Math.abs(y[i]-cy)+h[i];
        break ;
      }
    }
    for(int i=0 ; i<n ; i++){
      if(h[i]!=Math.max(ch-Math.abs(x[i]-cx)-Math.abs(y[i]-cy),0)){
        return-1 ;
      }
    }
    return ch ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 100;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
    var h : Sequence(int) ; h := Integer.subrange(1,n)->collect(0) ;
     for i : Integer.subrange(0, n-1) do
    (    skip) ; 
         var i : int ; i := 0 ; while i <= MAX do ( (         var j : int ; j := 0 ; while j <= MAX do ( (     var ch : int ; ch := check(n, x, y, h, i, j) ;
     if (ch > 0) then (     OclFile["System.out"].println(i + " " + j + " " + ch) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ))  );
  static   operation check( n : int, x : Sequence(int), y : Sequence(int), h : Sequence(int), cx : int, cy : int) : int
  pre: true
  post: true
  activity: (     var ch : int ; ch := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (h[i+1] > 0) then (     ch := if x[i+1] - cx < 0 then -(x[i+1] - cx) else x[i+1] - cx endif + if y[i+1] - cy < 0 then -(y[i+1] - cy) else y[i+1] - cy endif + h[i+1] ; 
     break ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (h[i+1] /= Set{ch - if x[i+1] - cx < 0 then -(x[i+1] - cx) else x[i+1] - cx endif - if y[i+1] - cy < 0 then -(y[i+1] - cy) else y[i+1] - cy endif, 0}->max()) then (     return -1 ) else skip )  ;     i := i + 1 ) ; 
     return ch );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class ProblemA {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int test=Integer.parseInt(br.readLine());
    while(test-->0){
      String line[]=br.readLine().split(" ");
      int n=Integer.parseInt(line[0]);
      int k=Integer.parseInt(line[1]);
      int ans=n ;
      if(n % k!=0){
        int num=(n/k)*k ;
        int min=Math.min(n % k,k/2);
        ans=num+min ;
      }
      System.out.println(ans);
    }
  }
  public static void sort(long arr[]){
    ArrayList<Long>list=new ArrayList<>();
    for(long it : arr)list.add(it);
    Collections.sort(list);
    for(int i=0 ; i<arr.length ; i++)arr[i]=list.get(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var test : int ; test := (br.readLine())->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
     var n : int ; n := (line[0+1])->toInteger() ;
    var k : int ; k := (line[1+1])->toInteger() ;
    var ans : int ; ans := n ;
    if (n mod k /= 0) then (     var num : int ; num := (n / k) * k ;
     var min : int ; min := Set{n mod k, k / 2}->min() ;
     ans := num + min ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
  static   operation sort( arr : Sequence(long)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(long) ; list := Sequence{} ;
     for (it : arr) do (     list := list->including(it) ;  ) ; 
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < arr->size() do (     arr[i+1] := list->at(i+1) ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int k=sc.nextInt();
      System.out.println(solve(n,k));
    }
    sc.close();
  }
  static int solve(int n,int k){
    return n/k*k+Math.min(k/2,n % k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(n, k)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( n : int, k : int) : int
  pre: true
  post: true
  activity: (     return n / k * k + Set{k / 2, n mod k}->min() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws java.io.IOException {
    Scanner scan=new Scanner(System.in);
    int a=1 ;
    int b=0 ;
    int c=0 ;
    while(scan.hasNext()){
      String str=scan.next();
      String[] text=str.split(",",0);
      if(text[0] .equals("A")){
        if(text[1] .equals("B")){
          if(a==1){
            a=0 ;
            b=1 ;
          }
          else if(b==1){
            a=1 ;
            b=0 ;
          }
        }
        else if(text[1] .equals("C")){
          if(a==1){
            a=0 ;
            c=1 ;
          }
          else if(c==0){
            a=1 ;
            c=0 ;
          }
        }
      }
      else if(text[0] .equals("B")){
        if(text[1] .equals("A")){
          if(b==1){
            b=0 ;
            a=1 ;
          }
          else if(a==1){
            b=1 ;
            a=0 ;
          }
        }
        else if(text[1] .equals("C")){
          if(b==1){
            b=0 ;
            c=1 ;
          }
          else if(c==0){
            b=1 ;
            c=0 ;
          }
        }
      }
      else {
        if(text[1] .equals("A")){
          if(c==1){
            c=0 ;
            a=1 ;
          }
          else if(a==1){
            c=1 ;
            a=0 ;
          }
        }
        else if(text[1] .equals("B")){
          if(c==1){
            c=0 ;
            b=1 ;
          }
          else if(b==1){
            c=1 ;
            b=0 ;
          }
        }
      }
    }
    if(a==1){
      System.out.println("A");
    }
    else if(b==1){
      System.out.println("B");
    }
    else {
      System.out.println("C");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := 1 ;
    var b : int ; b := 0 ;
    var c : int ; c := 0 ;
    while (scan.hasNext()) do (     var str : String ; str := scan.getCurrent() ;
     var text : Sequence(String) ; text := str->split(",") ;
     if (text[0+1] = "A") then (     if (text[1+1] = "B") then (     if (a = 1) then (     a := 0 ; 
     b := 1 ) else     if (b = 1) then (     a := 1 ; 
     b := 0 ) else skip ; ) else     if (text[1+1] = "C") then (     if (a = 1) then (     a := 0 ; 
     c := 1 ) else     if (c = 0) then (     a := 1 ; 
     c := 0 ) else skip ; ) else skip ; ) else     if (text[0+1] = "B") then (     if (text[1+1] = "A") then (     if (b = 1) then (     b := 0 ; 
     a := 1 ) else     if (a = 1) then (     b := 1 ; 
     a := 0 ) else skip ; ) else     if (text[1+1] = "C") then (     if (b = 1) then (     b := 0 ; 
     c := 1 ) else     if (c = 0) then (     b := 1 ; 
     c := 0 ) else skip ; ) else skip ; ) else (     if (text[1+1] = "A") then (     if (c = 1) then (     c := 0 ; 
     a := 1 ) else     if (a = 1) then (     c := 1 ; 
     a := 0 ) else skip ; ) else     if (text[1+1] = "B") then (     if (c = 1) then (     c := 0 ; 
     b := 1 ) else     if (b = 1) then (     c := 1 ; 
     b := 0 ) else skip ; ) else skip ; ) ;  ) ; 
    if (a = 1) then (     OclFile["System.out"].println("A") ) else     if (b = 1) then (     OclFile["System.out"].println("B") ) else (     OclFile["System.out"].println("C") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int w=sc.nextInt();
    int[] countCh=new int[26];
    int[][] countChp=new int[26][26];
    ArrayList<String>str=new ArrayList<String>();
    for(int i=0 ; i<w ; i++){
      String t=sc.next();
      char[] arr=t.toCharArray();
      Arrays.sort(arr);
      int count=0 ;
      char check=arr[0];
      for(char c : arr){
        if(c!=check){
          count++;
          check=c ;
        }
        if(count==2)break ;
      }
      if(count<2){
        str.add(t);
        if(count==0){
          countCh[arr[0]-'a']+=t.length();
        }
        if(count==1){
          countChp[arr[0]-'a'][check-'a']+=t.length();
        }
      }
    }
    int max=0 ;
    for(int i=0 ; i<26 ; i++){
      for(int j=0 ; j<26 ; j++){
        if(i==j)continue ;
        if(countCh[i]+countCh[j]+countChp[i][j]>max)max=countCh[i]+countCh[j]+countChp[i][j];
      }
    }
    System.out.print(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    var countCh : Sequence(int) ; countCh := Integer.subrange(1,26)->collect(0) ;
    var countChp : Sequence(Sequence(int)) ; countChp := Integer.subrange(1,26)->collect(Integer.subrange(1,26)->collect(0)) ;
    var str : Sequence(String) ; str := Sequence{} ;
        var i : int ; i := 0 ; while i < w do ( (     var t : String ; t := sc.getCurrent() ;
     var arr : Sequence(String) ; arr := t->characters() ;
    arr := arr->sort() ; 
    var count : int ; count := 0 ;
    var check : String ; check := arr[0+1] ;
    for (c : arr) do ( (     if (c /= check) then (     count := count + 1 ; 
     check := c ) else skip ; 
     if (count = 2) then     break else skip )  ) ; 
    if (count < 2) then (     str := str->including(t) ; 
     if (count = 0) then (     countCh[arr[0+1] - ('a')->char2byte()+1] := countCh[arr[0+1] - ('a')->char2byte()+1]+(t->size()) ) else skip ; 
     if (count = 1) then (     countChp[arr[0+1] - ('a')->char2byte()+1][(check)->char2byte() - ('a')->char2byte()+1] := countChp[arr[0+1] - ('a')->char2byte()+1][(check)->char2byte() - ('a')->char2byte()+1]+(t->size()) ) else skip ) else skip ; 
 )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < 26 do ( (         var j : int ; j := 0 ; while j < 26 do ( (     if (i = j) then     continue else skip ; 
     if (countCh[i+1] + countCh[j+1] + countChp[i+1][j+1] > max) then     max := countCh[i+1] + countCh[j+1] + countChp[i+1][j+1] ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int w=sc.nextInt();
    int[] countCh=new int[26];
    int[][] countChp=new int[26][26];
    ArrayList<String>str=new ArrayList<String>();
    for(int i=0 ; i<w ; i++){
      String t=sc.next();
      char[] arr=t.toCharArray();
      Arrays.sort(arr);
      int count=0 ;
      char check=arr[0];
      for(char c : arr){
        if(c!=check){
          count++;
          check=c ;
        }
        if(count==2)break ;
      }
      if(count<2){
        str.add(t);
        if(count==0){
          countCh[arr[0]-'a']+=t.length();
        }
        if(count==1){
          countChp[arr[0]-'a'][check-'a']+=t.length();
        }
      }
    }
    int max=0,idx1=-1,idx2=-1 ;
    for(int i=0 ; i<26 ; i++){
      for(int j=0 ; j<26 ; j++){
        if(i==j)continue ;
        if(countCh[i]+countCh[j]+countChp[i][j]>max){
          max=countCh[i]+countCh[j]+countChp[i][j];
          idx1=i ;
          idx2=j ;
        }
      }
    }
    int ans=0 ;
    for(int i=0 ; i<str.size(); i++){
      ans+=str.get(i).length();
      char[] arr=str.get(i).toCharArray();
      for(char c : arr){
        if(c-'a'-idx1!=0 && c-'a'-idx2!=0){
          ans-=str.get(i).length();
          break ;
        }
      }
    }
    System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    var countCh : Sequence(int) ; countCh := Integer.subrange(1,26)->collect(0) ;
    var countChp : Sequence(Sequence(int)) ; countChp := Integer.subrange(1,26)->collect(Integer.subrange(1,26)->collect(0)) ;
    var str : Sequence(String) ; str := Sequence{} ;
        var i : int ; i := 0 ; while i < w do ( (     var t : String ; t := sc.getCurrent() ;
     var arr : Sequence(String) ; arr := t->characters() ;
    arr := arr->sort() ; 
    var count : int ; count := 0 ;
    var check : String ; check := arr[0+1] ;
    for (c : arr) do ( (     if (c /= check) then (     count := count + 1 ; 
     check := c ) else skip ; 
     if (count = 2) then     break else skip )  ) ; 
    if (count < 2) then (     str := str->including(t) ; 
     if (count = 0) then (     countCh[arr[0+1] - ('a')->char2byte()+1] := countCh[arr[0+1] - ('a')->char2byte()+1]+(t->size()) ) else skip ; 
     if (count = 1) then (     countChp[arr[0+1] - ('a')->char2byte()+1][(check)->char2byte() - ('a')->char2byte()+1] := countChp[arr[0+1] - ('a')->char2byte()+1][(check)->char2byte() - ('a')->char2byte()+1]+(t->size()) ) else skip ) else skip ; 
 )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var idx1 : int ; idx1 := -1 ;
    var idx2 : int ; idx2 := -1 ;
        var i : int ; i := 0 ; while i < 26 do ( (         var j : int ; j := 0 ; while j < 26 do ( (     if (i = j) then     continue else skip ; 
     if (countCh[i+1] + countCh[j+1] + countChp[i+1][j+1] > max) then (     max := countCh[i+1] + countCh[j+1] + countChp[i+1][j+1] ; 
     idx1 := i ; 
     idx2 := j ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     ans := ans+(str->at(i+1)->size()) ; 
     var arr : Sequence(String) ; arr := str->at(i+1)->characters() ;
     for (c : arr) do ( (     if (c - ('a')->char2byte() - (idx1)->char2byte() /= 0 & c - ('a')->char2byte() - (idx2)->char2byte() /= 0) then (     ans := ans-(str->at(i+1)->size()) ; 
     break ) else skip )  ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    while(true){
      int cnt=s.nextInt();
      if(cnt==0)break ;
      int[] times=new int[cnt];
      for(int i=0 ; i<cnt ; i++){
        times[i]=s.nextInt();
      }
      Arrays.sort(times);
      System.out.println(solve(times));
    }
  }
  public static long solve(int[] times){
    long sumWaitTime=0 ;
    long waitT=0 ;
    for(int i=0 ; i<times.length-1 ; i++){
      waitT+=times[i];
      sumWaitTime+=waitT ;
    }
    return sumWaitTime ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var cnt : int ; cnt := s.getCurrent()->toInteger() ;
     if (cnt = 0) then     break else skip ; 
    var times : Sequence(int) ; times := Integer.subrange(1,cnt)->collect(0) ;
        var i : int ; i := 0 ; while i < cnt do ( (     times[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    times := times->sort() ; 
    OclFile["System.out"].println(solve(times)) ; 
 ) );
  static   operation solve( times : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var sumWaitTime : long ; sumWaitTime := 0 ;
     var waitT : long ; waitT := 0 ;
         var i : int ; i := 0 ; while i < times->size() - 1 do ( (     waitT := waitT+(times[i+1]) ; 
     sumWaitTime := sumWaitTime+(waitT) )  ;     i := i + 1 ) ; 
     return sumWaitTime );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    int N=readIntArray()[0];
    if(N==0)return false ;
    int[] k=new int[N];
    for(int i=0 ; i<N ; i++){
      k[i]=readIntArray()[0];
    }
    Arrays.sort(k);
    long sum=0 ;
    long t=0 ;
    for(int i=0 ; i<N ; i++){
      sum+=t ;
      t+=k[i];
    }
    System.out.printf("%d\n",sum);
    return true ;
  }
  private final static boolean DEBUG=false ;
  public static void main(String[] args)throws IOException {
    if(DEBUG){
      log=System.out ;
      String inputStr="3\n100\n100\n500\n0\n" ;
      reader=new BufferedReader(new StringReader(inputStr));
    }
    else {
      log=new PrintStream(new OutputStream(){
        public void write(int b){
        }
      }
);
      reader=new BufferedReader(new InputStreamReader(System.in));
    }
    for(int i=0 ; ; i++){
      boolean b=new Main().main();
      if(! b)break ;
    }
    reader.close();
  }
  static PrintStream log ;
  static BufferedReader reader ;
  private static int[] readIntArray()throws IOException {
    String s=reader.readLine();
    String[] sp=s.split(" ");
    int[] a=new int[sp.length];
    for(int i=0 ; i<sp.length ; i++){
      a[i]=Integer.parseInt(sp[i]);
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var N : int ; N := readIntArray()[0+1] ;
     if (N = 0) then     return false else skip ; 
    var k : Sequence(int) ; k := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     k[i+1] := readIntArray()[0+1] )  ;     i := i + 1 ) ; 
    k := k->sort() ; 
    var sum : long ; sum := 0 ;
    var t : long ; t := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     sum := sum+(t) ; 
     t := t+(k[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%d\n", sum) ; 
    return true 
 );
  static   attribute DEBUG : boolean := false;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (DEBUG) then (     log := OclFile["System.out"] ; 
     var inputStr : String ; inputStr := "3\n100\n100\n500\n0\n" ;
     reader := OclFile.newOclFile_Read(StringReader.newStringReader(inputStr)) ) else (     log := OclFile.newOclFile_Write(OclFile()) ; 
     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ) ;  
         var i : int ; i := 0 ; while true do ( (     var b : boolean ; b := Main.newMain().main() ;
     if (not(b)) then     break else skip )  ;     i := i + 1 ) ; 
     reader.close() );
  static   attribute log : OclFile;
  static   attribute reader : OclFile;
  static   operation readIntArray() : Sequence(int)
  pre: true
  post: true
  activity: (     var s : String ; s := reader.readLine() ;
     var sp : Sequence(String) ; sp := s->split(" ") ;
    var a : Sequence(int) ; a := Integer.subrange(1,sp->size())->collect(0) ;
        var i : int ; i := 0 ; while i < sp->size() do ( (     a[i+1] := (sp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    return a 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    long[] wait=null ;
    while((wait=parseWait())!=null){
      long out=0 ;
      for(int l=0 ; l<wait.length ; l++){
        out+=wait[l]*((long)(wait.length)-1L-(long)(l));
      }
      System.out.println(out);
    }
  }
  private static long[] parseWait(){
    int num=0 ;
    long[] wait=null ;
    if((num=parseNum())!=0){
      wait=new long[num];
      for(int l=0 ; l<num ; l++){
        wait[l]=(long)(parseNum());
      }
      Arrays.sort(wait);
    }
    return wait ;
  }
  private static int parseNum(){
    int num=0 ;
    String str=null ;
    if((str=parseStdin())!=null){
      num=Integer.parseInt(str);
    }
    return num ;
  }
  private static String parseStdin(){
    String stdin=null ;
    try {
      String tmp=br.readLine();
      if(tmp!=null){
        if(! tmp.isEmpty()){
          stdin=tmp ;
        }
      }
    }
    catch(IOException e){
    }
    return stdin ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var wait : Sequence(long) ; wait := null ;
         wait := parseWait() ;
    while ((wait) /= null) do (    skip ; (     var out : long ; out := 0 ;
         var l : int ; l := 0 ; while l < wait->size() do ( (     out := out+(wait[l+1] * ((wait->size())->oclAsType(long) - 1L - (l)->oclAsType(long))) )  ;     l := l + 1 ) ; 
     OclFile["System.out"].println(out) ) ;     wait := parseWait() ;
 ) );
  static   operation parseWait() : Sequence(long)
  pre: true
  post: true
  activity: (     var num : int ; num := 0 ;
     var wait : Sequence(long) ; wait := null ;
     if ((num) /= 0) then (     wait := Integer.subrange(1,num)->collect(0) ; 
         var l : int ; l := 0 ; while l < num do ( (     wait[l+1] := (parseNum())->oclAsType(long) )  ;     l := l + 1 ) ; 
     wait := wait->sort() ) else skip ; 
     return wait );
  static   operation parseNum() : int
  pre: true
  post: true
  activity: (     var num : int ; num := 0 ;
     var str : String ; str := null ;
     if ((str) /= null) then (     num := (str)->toInteger() ) else skip ; 
     return num );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var stdin : String ; stdin := null ;
     try (     var tmp : String ; tmp := br.readLine() ;
     if (tmp /= null) then (     if (not(tmp->isEmpty())) then (     stdin := tmp ) else skip ) else skip )   catch (e : IOException) do skip
     return stdin );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
import java.math.BigDecimal ;
public class Main {
  public static Scanner sc ;
  public static void main(String[] args)throws Exception {
    sc=new Scanner(System.in);
    while(sc.hasNext()){
      ArrayList<Integer>list=new ArrayList<>();
      int n=sc.nextInt();
      if(n==0)break ;
      for(int i=0 ; i<n ; i++){
        list.add(sc.nextInt());
      }
      Collections.sort(list);
      BigDecimal sum=new BigDecimal(0);
      for(int i=1 ; i<=n ; i++){
        sum=sum.add(new BigDecimal(list.get(i-1)).multiply(new BigDecimal(n-i)));
      }
      System.out.println(sum.toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     while (sc.hasNext()) do (     var list : Sequence(int) ; list := Sequence{} ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    if (n = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var sum : double ; sum := double(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     sum := sum->excludes(double(list->at(i - 1+1)).multiply(double(n - i))) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum+"") ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.awt.geom.Point2D ;
import java.io.BufferedReader ;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new aoj0112().doIt();
  }
  class aoj0112 {
    long waitsum(int a[]){
      long result=0 ;
      long sum=0 ;
      for(int i=0 ; i<a.length ; i++){
        result=result+sum ;
        sum=sum+a[i];
      }
      return result ;
    }
    void doIt(){
      while(true){
        int n=sc.nextInt();
        int a[]=new int[n];
        if(n==0)break ;
        for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
        Arrays.sort(a);
        System.out.println(waitsum(a));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     aoj0112.newaoj0112().doIt() );
 class aoj0112 {
   operation waitsum( a : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 0 ;
     var sum : long ; sum := 0 ;
         var i : int ; i := 0 ; while i < a->size() do ( (     result := result + sum ; 
     sum := sum + a[i+1] )  ;     i := i + 1 ) ; 
     return result );
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    if (n = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    OclFile["System.out"].println(waitsum(a)) ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    LinkedList<Coord>nzlist=new LinkedList<Coord>();
    LinkedList<Coord>zlist=new LinkedList<Coord>();
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      int h=sc.nextInt();
      if(h!=0){
        nzlist.add(new Coord(x,y,h));
      }
      else {
        zlist.add(new Coord(x,y,h));
      }
    }
    LinkedList<Coord>alllist=(LinkedList<Coord>)nzlist.clone();
    alllist.addAll(zlist);
    boolean okFlag=false ;
    Coord center=new Coord(-1,-1,-1);
    for(int x=0 ; x<=100 ; x++){
      for(int y=0 ; y<=100 ; y++){
        Coord c=nzlist.get(0);
        int h=c.h+Math.abs(c.x-x)+Math.abs(c.y-y);
        center=new Coord(x,y,h);
        okFlag=true ;
        for(Coord e : alllist){
          if(e.h!=Math.max(h-Math.abs(x-e.x)-Math.abs(y-e.y),0)){
            okFlag=false ;
            break ;
          }
        }
        if(okFlag){
          break ;
        }
      }
      if(okFlag){
        break ;
      }
    }
    System.out.print(center.show()+"\n");
  }
}
class Coord {
  public int x ;
  public int y ;
  public int h ;
  Coord(int x,int y,int h){
    this.x=x ;
    this.y=y ;
    this.h=h ;
  }
  public String show(){
    return String.valueOf(x)+' '+String.valueOf(y)+' '+String.valueOf(h);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var nzlist : Sequence(Coord) ; nzlist := Sequence{} ;
    var zlist : Sequence(Coord) ; zlist := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
     if (h /= 0) then (     nzlist := nzlist->including(Coord.newCoord(x, y, h)) ) else (     zlist := zlist->including(Coord.newCoord(x, y, h)) ) )  ;     i := i + 1 ) ; 
    var alllist : Sequence(Coord) ; alllist := nzlist->copy()->oclAsType(Sequence(Coord)) ;
    alllist := alllist->union(zlist) ; 
    var okFlag : boolean ; okFlag := false ;
    var center : Coord ; center := Coord.newCoord(-1, -1, -1) ;
        var x : int ; x := 0 ; while x <= 100 do ( (         var y : int ; y := 0 ; while y <= 100 do ( (     var c : Coord ; c := nzlist->at(0+1) ;
     var h : int ; h := c.h + if c.x - x < 0 then -(c.x - x) else c.x - x endif + if c.y - y < 0 then -(c.y - y) else c.y - y endif ;
    center := Coord.newCoord(x, y, h) ; 
    okFlag := true ; 
    for (e : alllist) do ( (     if (e.h /= Set{h - if x - e.x < 0 then -(x - e.x) else x - e.x endif - if y - e.y < 0 then -(y - e.y) else y - e.y endif, 0}->max()) then (     okFlag := false ; 
     break ) else skip )  ) ; 
    if (okFlag) then (     break ) else skip ; 
 )  ;     y := y + 1 ) ; 
     if (okFlag) then (     break ) else skip )  ;     x := x + 1 ) ; 
    OclFile["System.out"].print(center.show() + "\n") ; 
 );
}
class Coord {
   attribute x : int;
   attribute y : int;
   attribute h : int;
   static operation newCoord( x : int, y : int, h : int) : Coord
  pre: true
  post: true
  activity:
  ( var self : Coord ;
    self := createCoord();
    self.initialise(x, y,h);
    return self );
  operation initialise( x : int, y : int, h : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y ; 
     self.h := h );
   operation show() : String
  pre: true
  post: true
  activity: (     return ((x) + "") + ' ' + ((y) + "") + ' ' + ((h) + "") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class LargestSubArray2 {
  int min(int x,int y){
    return(x<y)? x : y ;
  }
  int max(int x,int y){
    return(x>y)? x : y ;
  }
  int findLength(int arr[],int n){
    int max_len=1 ;
    for(int i=0 ; i<n-1 ; i++){
      int mn=arr[i],mx=arr[i];
      for(int j=i+1 ; j<n ; j++){
        mn=min(mn,arr[j]);
        mx=max(mx,arr[j]);
        if((mx-mn)==j-i)max_len=max(max_len,mx-mn+1);
      }
    }
    return max_len ;
  }
  public static void main(String[] args){
    LargestSubArray2 large=new LargestSubArray2();
    int arr[]={
      1,56,58,57,90,92,94,93,91,45 };
      int n=arr.length ;
      System.out.println("Length of the longest contiguous subarray is "+large.findLength(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class LargestSubArray2 {
   operation min( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return if (x < y) then x else y endif );
   operation max( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return if (x > y) then x else y endif );
   operation findLength( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max_len : int ; max_len := 1 ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     var mn : int ; mn := arr[i+1] ;
    var mx : int ; mx := arr[i+1] ;
         var j : int ; j := i + 1 ; while j < n do ( (     mn := Set{mn, arr[j+1]}->min() ; 
     mx := Set{mx, arr[j+1]}->max() ; 
     if ((mx - mn) = j - i) then     max_len := Set{max_len, mx - mn + 1}->max() ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return max_len );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var large : LargestSubArray2 ; large := LargestSubArray2.newLargestSubArray2() ;
     var arr : Sequence(int) ; arr := Sequence{1,56,58,57,90,92,94,93,91,45} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Length of the longest contiguous subarray is " + large.findLength(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p055 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p055().run());
  }
  public String run(){
    int count=0 ;
    for(int i=0 ; i<10000 ; i++){
      if(isLychrel(i))count++;
    }
    return Integer.toString(count);
  }
  private static boolean isLychrel(int n){
    BigInteger temp=BigInteger.valueOf(n);
    for(int i=0 ; i<49 ; i++){
      temp=temp.add(new BigInteger(Library.reverse(temp.toString())));
      if(Library.isPalindrome(temp.toString()))return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class p055 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p055.newp055().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < 10000 do ( (     if (isLychrel(i)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return ((count) + "") );
  static   operation isLychrel( n : int) : boolean
  pre: true
  post: true
  activity: (     var temp : long ; temp := (n + "")->toLong() ;
         var i : int ; i := 0 ; while i < 49 do ( (     temp := temp->excludes(long(Library.reverse(temp+""))) ; 
     if (Library.isPalindrome(temp+"")) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p031 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p031().run());
  }
  private static final int TOTAL=200 ;
  private static int[] COINS={
    1,2,5,10,20,50,100,200 };
    public String run(){
      int[][] ways=new int[COINS.length+1][TOTAL+1];
      ways[0][0]=1 ;
      for(int i=0 ; i<COINS.length ; i++){
        int coin=COINS[i];
        for(int j=0 ; j<=TOTAL ; j++)ways[i+1][j]=ways[i][j]+(j>=coin ? ways[i+1][j-coin] : 0);
      }
      return Integer.toString(ways[COINS.length][TOTAL]);
    }
  }

------------------------------------------------------------
OCL File:
---------
class p031 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p031.newp031().run()) );
  static    attribute TOTAL : int := 200;
  static   attribute COINS : Sequence(int) := Sequence{1,2,5,10,20,50,100,200};
   operation run() : String
  pre: true
  post: true
  activity: (     var ways : Sequence(Sequence(int)) ; ways := Integer.subrange(1,COINS->size() + 1)->collect(Integer.subrange(1,TOTAL + 1)->collect(0)) ;
     ways[0+1][0+1] := 1 ; 
         var i : int ; i := 0 ; while i < COINS->size() do ( (     var coin : int ; coin := COINS[i+1] ;
         var j : int ; j := 0 ; while j <= TOTAL do (     ways[i + 1+1][j+1] := ways[i+1][j+1] + (if j >= coin then ways[i + 1+1][j - coin+1] else 0 endif) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ((ways[COINS->size()+1][TOTAL+1]) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int summ(int n){
    if(n==0)return 0 ;
    return(n % 9==0)? 9 :(n % 9);
  }
  static void printDigitalRoot(int n){
    int maxi=1 ;
    int dig=1 ;
    for(int i=1 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        int d1=summ(n/i);
        int d2=summ(i);
        if(d1>maxi){
          dig=n/i ;
          maxi=d1 ;
        }
        if(d2>maxi){
          dig=i ;
          maxi=d2 ;
        }
        if(d1==maxi){
          if(dig<(n/i)){
            dig=n/i ;
            maxi=d1 ;
          }
        }
        if(d2==maxi){
          if(dig<i){
            dig=i ;
            maxi=d2 ;
          }
        }
      }
    }
    System.out.println(dig+" "+maxi);
  }
  public static void main(String[] args){
    int n=10 ;
    printDigitalRoot(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation summ( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else skip ; 
     return if (n mod 9 = 0) then 9 else (n mod 9) endif );
  static   operation printDigitalRoot( n : int) : void
  pre: true
  post: true
  activity: (     var maxi : int ; maxi := 1 ;
     var dig : int ; dig := 1 ;
         var i : int ; i := 1 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     var d1 : int ; d1 := summ(n / i) ;
     var d2 : int ; d2 := summ(i) ;
    if (d1 > maxi) then (     dig := n / i ; 
     maxi := d1 ) else skip ; 
    if (d2 > maxi) then (     dig := i ; 
     maxi := d2 ) else skip ; 
    if (d1 = maxi) then (     if (dig < (n / i)) then (     dig := n / i ; 
     maxi := d1 ) else skip ) else skip ; 
    if (d2 = maxi) then (     if (dig < i) then (     dig := i ; 
     maxi := d2 ) else skip ) else skip ; 
 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(dig + " " + maxi) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     execute printDigitalRoot(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long L=sc.nextLong();
    long R=sc.nextLong();
    if(R>=2019 && L<=2019){
      System.out.println(0);
    }
    else {
      long min=Long.MAX_VALUE ;
      boolean flag=true ;
      for(long index=L ; index<R ; index++){
        if(flag==false){
          break ;
        }
        for(long index2=index+1 ; index2<=R ; index2++){
          if((index*index2)% 2019==0){
            flag=false ;
            min=0 ;
            break ;
          }
          if(min>(index*index2)% 2019){
            min=(index*index2)% 2019 ;
          }
        }
      }
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var L : long ; L := sc.getCurrent()->toLong() ;
     var R : long ; R := sc.getCurrent()->toLong() ;
     if (R >= 2019 & L <= 2019) then (     OclFile["System.out"].println(0) ) else (     var min : long ; min := "9223372036854775807"->toLong() ;
     var flag : boolean ; flag := true ;
         var index : long ; index := L ; while index < R do ( (     if (flag = false) then (     break ) else skip ; 
         var index2 : long ; index2 := index + 1 ; while index2 <= R do ( (     if ((index * index2) mod 2019 = 0) then (     flag := false ; 
     min := 0 ; 
     break ) else skip ; 
     if (min > (index * index2) mod 2019) then (     min := (index * index2) mod 2019 ) else skip )  ;     index2 := index2 + 1 ) )  ;     index := index + 1 ) ; 
     OclFile["System.out"].println(min) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CRemainderMinimization2019 solver=new CRemainderMinimization2019();
    solver.solve(1,in,out);
    out.close();
  }
  static class CRemainderMinimization2019 {
    static final int M=2019 ;
    public void solve(int testNumber,InputReader in,PrintWriter out){
      long l=in.nextLong(),r=in.nextLong();
      r=Math.min(r,l+2100);
      long answer=Integer.MAX_VALUE ;
      for(long i=l ; i<=r ; i++){
        for(long j=i+1 ; j<=r ; j++){
          long c=((i % M)*(j % M))% M ;
          answer=Math.min(answer,c);
        }
      }
      out.println(answer);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CRemainderMinimization2019 ; solver := CRemainderMinimization2019.newCRemainderMinimization2019() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CRemainderMinimization2019 {
  static    attribute M : int := 2019;
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var l : long ; l := in.nextLong() ;
    var r : long ; r := in.nextLong() ;
     r := Set{r, l + 2100}->min() ; 
    var answer : long ; answer := 2147483647 ;
        var i : long ; i := l ; while i <= r do ( (         var j : long ; j := i + 1 ; while j <= r do ( (     var c : long ; c := ((i mod M) * (j mod M)) mod M ;
     answer := Set{answer, c}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int L=Integer.parseInt(sc.next());
    int R=Integer.parseInt(sc.next());
    sc.close();
    long min=2019 ;
    for(int i=L ; i<=R-1 ; i++){
      for(int j=i+1 ; j<=R ; j++){
        long calc=((long)i*j)% 2019 ;
        if(calc<min){
          min=calc ;
        }
        if(min==0){
          break ;
        }
      }
      if(min==0){
        break ;
      }
    }
    out.printf("%d\n",min);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var L : int ; L := (sc.getCurrent())->toInteger() ;
    var R : int ; R := (sc.getCurrent())->toInteger() ;
    skip ; 
    var min : long ; min := 2019 ;
        var i : int ; i := L ; while i <= R - 1 do ( (         var j : int ; j := i + 1 ; while j <= R do ( (     var calc : long ; calc := (i->oclAsType(long) * j) mod 2019 ;
     if (calc < min) then (     min := calc ) else skip ; 
     if (min = 0) then (     break ) else skip )  ;     j := j + 1 ) ; 
     if (min = 0) then (     break ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long l=in.nextInt();
    long r=in.nextInt();
    if(r-l>=2019){
      System.out.println(0);
      return ;
    }
    l=l % 2019 ;
    r=r % 2019 ;
    int tes=2*1000000000 ;
    if((l*r)% 2019==0){
      System.out.println(0);
      return ;
    }
    long min=2019 ;
    for(long i=l ; i<=r-1 ; i++){
      for(long j=i+1 ; j<=r ; j++){
        long tmp=(i*j)% 2019 ;
        min=(min<=tmp)? min : tmp ;
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : long ; l := in.getCurrent()->toInteger() ;
    var r : long ; r := in.getCurrent()->toInteger() ;
    if (r - l >= 2019) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    l := l mod 2019 ; 
    r := r mod 2019 ; 
    var tes : int ; tes := 2 * 1000000000 ;
    if ((l * r) mod 2019 = 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var min : long ; min := 2019 ;
        var i : long ; i := l ; while i <= r - 1 do ( (         var j : long ; j := i + 1 ; while j <= r do ( (     var tmp : long ; tmp := (i * j) mod 2019 ;
     min := if (min <= tmp) then min else tmp endif )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long l=sc.nextLong();
    long r=sc.nextLong();
    long gap=Math.min((r-l),2018);
    l %=2019 ;
    r %=2019 ;
    long ans=2019 ;
    if(r<=l){
      ans=0 ;
    }
    else {
      for(long i=l ; i<l+gap ; i++){
        for(long j=i+1 ; j<=l+gap ; j++){
          long value=i*j % 2019 ;
          ans=Math.min(ans,value);
          if(ans==0){
            break ;
          }
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : long ; l := sc.getCurrent()->toLong() ;
    var r : long ; r := sc.getCurrent()->toLong() ;
    var gap : long ; gap := Set{(r - l), 2018}->min() ;
    l := l mod 2019 ; 
    r := r mod 2019 ; 
    var ans : long ; ans := 2019 ;
    if (r <= l) then (     ans := 0 ) else (         var i : long ; i := l ; while i < l + gap do ( (         var j : long ; j := i + 1 ; while j <= l + gap do ( (     var value : long ; value := i * j mod 2019 ;
     ans := Set{ans, value}->min() ; 
     if (ans = 0) then (     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static double ReuleauxArea(float a){
    if(a<0)return-1 ;
    double A=(double)0.70477*Math.pow(a,2);
    return A ;
  }
  public static void main(String args[]){
    float a=6 ;
    System.out.println(ReuleauxArea(a));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation ReuleauxArea( a : double) : double
  pre: true
  post: true
  activity: (     if (a < 0) then     return -1 else skip ; 
     var A : double ; A := 0.70477->oclAsType(double) * a->pow(2) ;
     return A );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 6 ;
     OclFile["System.out"].println(ReuleauxArea(a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Reader r=new Reader();
    int N=r.i();
    int[][] xyh=new int[N][3];
    for(int i=0 ; i<N ; i++){
      xyh[i]=r.ii();
    }
    for(int Cx=0 ; Cx<101 ; Cx++){
      loop : for(int Cy=0 ;
      Cy<101 ;
      Cy++){
        int H=0 ;
        int j=0 ;
        while(true){
          int[] xyhi=xyh[j++];
          if(xyhi[2]>0){
            H=Math.abs(Cx-xyhi[0])+Math.abs(Cy-xyhi[1])+xyhi[2];
            break ;
          }
        }
        for(int i=0 ; i<N ; i++){
          int[] xyhi=xyh[i];
          if(xyhi[2]!=Math.max(H-Math.abs(Cx-xyh[i][0])-Math.abs(Cy-xyh[i][1]),0))continue loop ;
        }
        System.out.println(Cx+" "+Cy+" "+H);
        return ;
      }
    }
  }
  static void print(Object o){
    System.out.println(o.toString());
  }
  static class Reader extends BufferedReader {
    Reader(){
      super(new InputStreamReader(System.in));
    }
    String s()throws IOException {
      return readLine();
    }
    String[] ss()throws IOException {
      return s().split(" ");
    }
    int Int(String s){
      return Integer.parseInt(s);
    }
    int i()throws IOException {
      return Int(s());
    }
    int[] ii()throws IOException {
      String[] ss=ss();
      int size=ss.length ;
      int[] ii=new int[size];
      for(int j=0 ; j<size ; j++)ii[j]=Int(ss[j]);
      return ii ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile() ;
     var N : int ; N := r.i() ;
    var xyh : Sequence(Sequence(int)) ; xyh := Integer.subrange(1,N)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     xyh[i+1] := r.ii() )  ;     i := i + 1 ) ; 
        var Cx : int ; Cx := 0 ; while Cx < 101 do ( (         var Cy : int ; Cy := 0 ; while Cy < 101 do ( (     var H : int ; H := 0 ;
     var j : int ; j := 0 ;
    while (true) do (     var xyhi : Sequence(int) ; xyhi := xyh[j+1] ;
     if (xyhi[2+1] > 0) then (     H := if Cx - xyhi[0+1] < 0 then -(Cx - xyhi[0+1]) else Cx - xyhi[0+1] endif + if Cy - xyhi[1+1] < 0 then -(Cy - xyhi[1+1]) else Cy - xyhi[1+1] endif + xyhi[2+1] ; 
     break ) else skip ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var xyhi : Sequence(int) ; xyhi := xyh[i+1] ;
     if (xyhi[2+1] /= Set{H - if Cx - xyh[i+1][0+1] < 0 then -(Cx - xyh[i+1][0+1]) else Cx - xyh[i+1][0+1] endif - if Cy - xyh[i+1][1+1] < 0 then -(Cy - xyh[i+1][1+1]) else Cy - xyh[i+1][1+1] endif, 0}->max()) then     continue else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Cx + " " + Cy + " " + H) ; 
    return 
 )  ;     Cy := Cy + 1 ) ; )  ;     Cx := Cx + 1 ) ; 
 );
  static   operation print( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o+"") );
  static class Reader extends OclFile {
   static operation newReader() : Reader
  pre: true
  post: true
  activity:
  ( var self : Reader ;
    self := createReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation s() : String
  pre: true
  post: true
  activity: (     return readLine() );
   operation ss() : Sequence(String)
  pre: true
  post: true
  activity: (     return s()->split(" ") );
   operation Int( s : String) : int
  pre: true
  post: true
  activity: (     return (s)->toInteger() );
   operation i() : int
  pre: true
  post: true
  activity: (     return Int(s()) );
   operation ii() : Sequence(int)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var size : int ; size := ss->size() ;
    var ii : Sequence(int) ; ii := Integer.subrange(1,size)->collect(0) ;
        var j : int ; j := 0 ; while j < size do (     ii[j+1] := Int(ss[j+1]) ;  ;     j := j + 1 ) ; 
    return ii 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    HashMap<Integer,Integer>frontMod=new HashMap<>();
    HashMap<Integer,Integer>reerMod=new HashMap<>();
    ArrayList<Integer>ans=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      int x=arr[i];
      int y=arr[n-i-1];
      if(x!=y){
        if(reerMod.containsKey(x)){
          int z=reerMod.get(x);
          if(z==1){
            reerMod.remove(x);
          }
          else {
            reerMod.put(x,z-1);
          }
        }
        else if(frontMod.containsKey(x)){
          frontMod.put(x,frontMod.get(x)+1);
        }
        else {
          frontMod.put(x,1);
        }
        if(frontMod.containsKey(y)){
          int z=frontMod.get(y);
          if(z==1){
            frontMod.remove(y);
          }
          else {
            frontMod.put(y,z-1);
          }
        }
        else if(reerMod.containsKey(y)){
          reerMod.put(y,reerMod.get(y)+1);
        }
        else {
          reerMod.put(y,1);
        }
      }
      if(frontMod.size()==0 && reerMod.size()==0){
        ans.add(i+1);
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<ans.size(); i++){
      if(i!=0){
        sb.append(" ");
      }
      sb.append(ans.get(i));
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var frontMod : Map(int,int) ; frontMod := Map{} ;
    var reerMod : Map(int,int) ; reerMod := Map{} ;
    var ans : Sequence(int) ; ans := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := arr[i+1] ;
     var y : int ; y := arr[n - i - 1+1] ;
     if (x /= y) then (     if (reerMod->keys()->includes(x)) then (     var z : int ; z := reerMod->at(x) ;
     if (z = 1) then (     reerMod := reerMod->antirestrict(Set{x}) ) else (     reerMod := reerMod->union(Map{x |-> z - 1}) ) ) else     if (frontMod->keys()->includes(x)) then (     frontMod := frontMod->union(Map{x |-> frontMod->at(x) + 1}) ) else (     frontMod := frontMod->union(Map{x |-> 1}) ) ;  ;  
     if (frontMod->keys()->includes(y)) then (     var z : int ; z := frontMod->at(y) ;
     if (z = 1) then (     frontMod := frontMod->antirestrict(Set{y}) ) else (     frontMod := frontMod->union(Map{y |-> z - 1}) ) ) else     if (reerMod->keys()->includes(y)) then (     reerMod := reerMod->union(Map{y |-> reerMod->at(y) + 1}) ) else (     reerMod := reerMod->union(Map{y |-> 1}) ) ;  ) else skip ; 
     if (frontMod.size() = 0 & reerMod.size() = 0) then (     ans := ans->including(i + 1) ) else skip )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < ans->size() do ( (     if (i /= 0) then (     sb := sb + StringLib.newString(" ") ) else skip ; 
     sb := sb + StringLib.newString(ans->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] lst=new int[n];
    for(int i=0 ; i<n ; i++){
      lst[i]=sc.nextInt();
    }
    HashMap<Integer,Integer>dict=new HashMap<Integer,Integer>();
    ArrayList<Integer>ans=new ArrayList<Integer>();
    for(int k=0 ; k<n ; k++){
      if(dict.get(lst[k])==null){
        dict.put(lst[k],1);
      }
      else {
        dict.put(lst[k],dict.get(lst[k])+1);
        if(dict.get(lst[k])==0)dict.remove(lst[k]);
      }
      if(dict.get(lst[n-1-k])==null){
        dict.put(lst[n-1-k],-1);
      }
      else {
        dict.put(lst[n-1-k],dict.get(lst[n-1-k])-1);
        if(dict.get(lst[n-1-k])==0)dict.remove(lst[n-1-k]);
      }
      if(dict.isEmpty())ans.add(k+1);
    }
    for(int i=0 ; i<ans.size(); i++){
      if(i>0)System.out.print(" ");
      System.out.print(ans.get(i));
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var lst : Sequence(int) ; lst := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     lst[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dict : Map(int,int) ; dict := Map{} ;
    var ans : Sequence(int) ; ans := Sequence{} ;
        var k : int ; k := 0 ; while k < n do ( (     if (dict->at(lst[k+1]) = null) then (     dict := dict->union(Map{lst[k+1] |-> 1}) ) else (     dict := dict->union(Map{lst[k+1] |-> dict->at(lst[k+1]) + 1}) ; 
     if (dict->at(lst[k+1]) = 0) then     dict := dict->antirestrict(Set{lst[k+1]}) ; else skip ) ;  
     if (dict->at(lst[n - 1 - k+1]) = null) then (     dict := dict->union(Map{lst[n - 1 - k+1] |-> -1}) ) else (     dict := dict->union(Map{lst[n - 1 - k+1] |-> dict->at(lst[n - 1 - k+1]) - 1}) ; 
     if (dict->at(lst[n - 1 - k+1]) = 0) then     dict := dict->antirestrict(Set{lst[n - 1 - k+1]}) ; else skip ) ;  
     if (dict->isEmpty()) then     ans := ans->including(k + 1) ; else skip )  ;     k := k + 1 ) ; 
        var i : int ; i := 0 ; while i < ans->size() do ( (     if (i > 0) then     OclFile["System.out"].print(" ") ; else skip ; 
     OclFile["System.out"].print(ans->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javax.xml.crypto.Data ;
import java.util.*;
import java.io.*;
public class Main {
  public static int SENTINEL=100000007 ;
  public static int MAX=1000 ;
  public static int VMAX=10000 ;
  public static int[] A=new int[MAX];
  public static int n,s ;
  public static int[] B=new int[MAX];
  public static int[] T=new int[VMAX+1];
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    s=VMAX ;
    for(int i=0 ; i<n ; i++){
      A[i]=sc.nextInt();
      s=Math.min(s,A[i]);
    }
    System.out.println(solve());
  }
  public static int solve(){
    int ans=0 ;
    boolean[] V=new boolean[MAX];
    for(int i=0 ; i<n ; i++){
      B[i]=A[i];
      V[i]=false ;
    }
    Arrays.sort(B,0,n);
    for(int i=0 ; i<n ; i++)T[B[i] ]=i ;
    for(int i=0 ; i<n ; i++){
      if(V[i])continue ;
      int S=0 ;
      int an=0 ;
      int m=VMAX ;
      int cur=i ;
      while(true){
        V[cur]=true ;
        an++;
        int v=A[cur];
        m=Math.min(m,v);
        S+=v ;
        cur=T[v];
        if(V[cur])break ;
      }
      ans+=Math.min(S+(an-2)*m,m+S+(an+1)*s);
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute SENTINEL : int := 100000007;
  static   attribute MAX : int := 1000;
  static   attribute VMAX : int := 10000;
  static   attribute A : Sequence(int) := Integer.subrange(1,MAX)->collect(0);
  static   attribute n : int;
  static   attribute B : Sequence(int) := Integer.subrange(1,MAX)->collect(0);
  static   attribute T : Sequence(int) := Integer.subrange(1,VMAX + 1)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    s := VMAX ; 
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := sc.getCurrent()->toInteger() ; 
     s := Set{s, A[i+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve()) ; 
 );
  static   operation solve() : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var V : Sequence(boolean) ; V := Integer.subrange(1,MAX)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     B[i+1] := A[i+1] ; 
     V[i+1] := false )  ;     i := i + 1 ) ; 
    B := B.subrange(1,0)^(B.subrange(0+1,n)->sort())^B.subrange(n+1,B.size) ; 
        var i : int ; i := 0 ; while i < n do (     T[B[i+1]+1] := i ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (V[i+1]) then     continue else skip ; 
     var S : int ; S := 0 ;
    var an : int ; an := 0 ;
    var m : int ; m := VMAX ;
    var cur : int ; cur := i ;
    while (true) do (     V[cur+1] := true ; 
     an := an + 1 ; 
    var v : int ; v := A[cur+1] ;
    m := Set{m, v}->min() ; 
    S := S+(v) ; 
    cur := T[v+1] ; 
    if (V[cur+1]) then     break else skip ; 
 ) ; 
    ans := ans+(Set{S + (an - 2) * m, m + S + (an + 1) * s}->min()) ; 
 )  ;     i := i + 1 ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int find_extra_element_index(int[] arrA,int[] arrB){
    int extra_element=sum(arrA)-sum(arrB);
    return indexOf(arrA,extra_element);
  }
  static int sum(int[] arr){
    int sum=0 ;
    for(int i=0 ; i<arr.length ; i++){
      sum+=arr[i];
    }
    return sum ;
  }
  static int indexOf(int[] arr,int element){
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]==element){
        return i ;
      }
    }
    return-1 ;
  }
  public static void main(String[] args){
    int[] arrA={
      2,4,6,8,10,12,13 };
      int[] arrB={
        2,4,6,8,10,12 };
        System.out.println(find_extra_element_index(arrA,arrB));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find_extra_element_index( arrA : Sequence(int), arrB : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var extra_element : int ; extra_element := sum(arrA) - sum(arrB) ;
     return indexOf(arrA, extra_element) );
  static   operation sum( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation indexOf( arr : Sequence(int), element : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = element) then (     return i ) else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arrA : Sequence(int) ; arrA := Sequence{2,4,6,8,10,12,13} ;
     var arrB : Sequence(int) ; arrB := Sequence{2,4,6,8,10,12} ;
     OclFile["System.out"].println(find_extra_element_index(arrA, arrB)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.stream.Stream ;
class Main {
  final static int MAX=1_000 ;
  final static int VMAX=10_000 ;
  static int n,small ;
  static int[] a ;
  static int[] b=new int[MAX];
  static int[] truery=new int[VMAX+1];
  public static void main(String[] args){
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      n=Integer.parseInt(br.readLine());
      a=Stream.of(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    }
    catch(IOException e){
      e.printStackTrace();
    }
    small=VMAX ;
    for(int w : a){
      small=Math.min(small,w);
    }
    int ans=solve();
    System.out.println(ans);
  }
  private static int solve(){
    int ans=0 ;
    b=Arrays.copyOf(a,n);
    boolean[] valid=new boolean[MAX];
    Arrays.sort(b);
    for(int i=0 ; i<n ; i++)truery[b[i] ]=i ;
    for(int i=0 ; i<n ; i++){
      if(valid[i])continue ;
      int cur=i ;
      int sum=0 ;
      int min=VMAX ;
      int an=0 ;
      while(true){
        valid[cur]=true ;
        an++;
        int val=a[cur];
        min=Math.min(min,val);
        sum+=val ;
        cur=truery[val];
        if(valid[cur])break ;
      }
      ans+=Math.min(sum+(an-2)*min,min+sum+(an+1)*small);
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MAX : int := 1_000;
  static   attribute VMAX : int := 10_000;
  static   attribute n : int;
  static   attribute a : Sequence(int);
  static   attribute b : Sequence(int) := Integer.subrange(1,MAX)->collect(0);
  static   attribute truery : Sequence(int) := Integer.subrange(1,VMAX + 1)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     n := (br.readLine())->toInteger() ; 
     a := Sequence{br.readLine()->split(" ")}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ))   catch (e : IOException) do (     e.printStackTrace() )
     small := VMAX ; 
    for (w : a) do ( (     small := Set{small, w}->min() )  ) ; 
    var ans : int ; ans := solve() ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation solve() : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     b := a.subrange(1,n) ; 
    var valid : Sequence(boolean) ; valid := Integer.subrange(1,MAX)->collect(false) ;
    b := b->sort() ; 
        var i : int ; i := 0 ; while i < n do (     truery[b[i+1]+1] := i ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (valid[i+1]) then     continue else skip ; 
     var cur : int ; cur := i ;
    var sum : int ; sum := 0 ;
    var min : int ; min := VMAX ;
    var an : int ; an := 0 ;
    while (true) do (     valid[cur+1] := true ; 
     an := an + 1 ; 
    var val : int ; val := a[cur+1] ;
    min := Set{min, val}->min() ; 
    sum := sum+(val) ; 
    cur := truery[val+1] ; 
    if (valid[cur+1]) then     break else skip ; 
 ) ; 
    ans := ans+(Set{sum + (an - 2) * min, min + sum + (an + 1) * small}->min()) ; 
 )  ;     i := i + 1 ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int[] w=new int[n];
    int x=10000 ;
    for(int i=0 ; i<n ; i++){
      w[i]=Integer.parseInt(sc.next());
      if(w[i]<x)x=w[i];
    }
    int[] w2=w.clone();
    Arrays.sort(w2);
    Map<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      map.put(w2[i],i);
    }
    int ans=0 ;
    boolean[] done=new boolean[n];
    for(int i=0 ; i<n ; i++){
      if(done[i])continue ;
      List<Integer>list=new ArrayList<>();
      list.add(i);
      done[i]=true ;
      int j=map.get(w[i]);
      while(j!=i){
        list.add(j);
        done[j]=true ;
        j=map.get(w[j]);
      }
      int sum=0 ;
      int min=10000 ;
      for(Integer k : list){
        sum+=w[k];
        if(w[k]<min)min=w[k];
      }
      ans+=Math.min(sum+(list.size()-2)*min,sum+min+(list.size()+1)*x);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var w : Sequence(int) ; w := Integer.subrange(1,n)->collect(0) ;
    var x : int ; x := 10000 ;
        var i : int ; i := 0 ; while i < n do ( (     w[i+1] := (sc.getCurrent())->toInteger() ; 
     if (w[i+1] < x) then     x := w[i+1] ; else skip )  ;     i := i + 1 ) ; 
    var w2 : Sequence(int) ; w2 := w->copy() ;
    w2 := w2->sort() ; 
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     map := map->union(Map{w2[i+1] |-> i}) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var done : Sequence(boolean) ; done := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     if (done[i+1]) then     continue else skip ; 
     var list : Sequence(int) ; list := Sequence{} ;
    list := list->including(i) ; 
    done[i+1] := true ; 
    var j : int ; j := map->at(w[i+1]) ;
    while (j /= i) do (     list := list->including(j) ; 
     done[j+1] := true ; 
     j := map->at(w[j+1]) ) ; 
    var sum : int ; sum := 0 ;
    var min : int ; min := 10000 ;
    for (k : list) do ( (     sum := sum+(w[k+1]) ; 
     if (w[k+1] < min) then     min := w[k+1] ; else skip )  ) ; 
    ans := ans+(Set{sum + (list->size() - 2) * min, sum + min + (list->size() + 1) * x}->min()) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  final int VMAX=10000 ;
  public static void main(String[] args){
    new Main().run();
  }
  public void run(){
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      int n=Integer.parseInt(br.readLine());
      int[] seq=new int[n];
      String[] line=br.readLine().split(" ");
      int min=VMAX ;
      for(int i=0 ; i<n ; i++){
        seq[i]=Integer.parseInt(line[i]);
        if(seq[i]<min)min=seq[i];
      }
      System.out.println(minimumCostSort(seq,min));
    }
    catch(IOException e){
      System.err.println(e);
    }
  }
  private int minimumCostSort(int[] seq,int s){
    int result=0 ;
    int n=seq.length ;
    boolean[] v=new boolean[VMAX];
    int[] b=Arrays.copyOf(seq,n);
    int[] t=new int[VMAX+1];
    Arrays.sort(b);
    for(int i=0 ; i<n ; i++)t[b[i] ]=i ;
    for(int i=0 ; i<n ; i++){
      if(v[i])continue ;
      int cur=i ;
      int S=0 ;
      int m=VMAX ;
      int an=0 ;
      while(true){
        v[cur]=true ;
        an++;
        int iv=seq[cur];
        m=Math.min(m,iv);
        S+=iv ;
        cur=t[iv];
        if(v[cur])break ;
      }
      result+=Math.min(S+(an-2)*m,m+S+(an+1)*s);
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute VMAX : int := 10000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var n : int ; n := (br.readLine())->toInteger() ;
     var seq : Sequence(int) ; seq := Integer.subrange(1,n)->collect(0) ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var min : int ; min := VMAX ;
        var i : int ; i := 0 ; while i < n do ( (     seq[i+1] := (line[i+1])->toInteger() ; 
     if (seq[i+1] < min) then     min := seq[i+1] ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(minimumCostSort(seq, min)) ; 
 ))   catch (e : IOException) do (     OclFile["System.err"].println(e) )
  );
   operation minimumCostSort( seq : Sequence(int), s : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var n : int ; n := seq->size() ;
    var v : Sequence(boolean) ; v := Integer.subrange(1,VMAX)->collect(false) ;
    var b : Sequence(int) ; b := seq.subrange(1,n) ;
    var t : Sequence(int) ; t := Integer.subrange(1,VMAX + 1)->collect(0) ;
    b := b->sort() ; 
        var i : int ; i := 0 ; while i < n do (     t[b[i+1]+1] := i ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (v[i+1]) then     continue else skip ; 
     var cur : int ; cur := i ;
    var S : int ; S := 0 ;
    var m : int ; m := VMAX ;
    var an : int ; an := 0 ;
    while (true) do (     v[cur+1] := true ; 
     an := an + 1 ; 
    var iv : int ; iv := seq[cur+1] ;
    m := Set{m, iv}->min() ; 
    S := S+(iv) ; 
    cur := t[iv+1] ; 
    if (v[cur+1]) then     break else skip ; 
 ) ; 
    result := result+(Set{S + (an - 2) * m, m + S + (an + 1) * s}->min()) ; 
 )  ;     i := i + 1 ) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication31 {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String length=input.next();
    String x=input.next();
    int zero=0,one=0 ;
    char[] x1=x.toCharArray();
    for(int i=0 ; i<x1.length ; i++){
      if(x1[i]=='1'){
        one++;
      }
      else {
        zero++;
      }
    }
    System.out.println(Math.abs(one-zero));
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication31 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var length : String ; length := input.getCurrent() ;
    var x : String ; x := input.getCurrent() ;
    var zero : int ; zero := 0 ;
    var one : int ; one := 0 ;
    var x1 : Sequence(String) ; x1 := x->characters() ;
        var i : int ; i := 0 ; while i < x1->size() do ( (     if (x1[i+1] = '1') then (     one := one + 1 ) else (     zero := zero + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if (one)->char2byte() - (zero)->char2byte() < 0 then -((one)->char2byte() - (zero)->char2byte()) else (one)->char2byte() - (zero)->char2byte() endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class lol {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    String s=in.next();
    char[] ch=s.toCharArray();
    int zer=0 ;
    int cnt=0 ;
    for(int i=0 ; i<ch.length ; i++){
      if(ch[i]=='0'){
        zer++;
      }
      else {
        cnt++;
      }
    }
    System.out.println(Math.abs(zer-cnt));
  }
}
------------------------------------------------------------
OCL File:
---------
 class lol {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var ch : Sequence(String) ; ch := s->characters() ;
    var zer : int ; zer := 0 ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < ch->size() do ( (     if (ch[i+1] = '0') then (     zer := zer + 1 ) else (     cnt := cnt + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if zer - cnt < 0 then -(zer - cnt) else zer - cnt endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder();
    int n=fs.nextInt();
    String s=fs.next();
    int one=0,z=0 ;
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='1')one++;
      else z++;
    }
    out.print(Math.abs(one-z));
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    Long[] readArray(int n){
      Long[] a=new Long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := fs.nextInt() ;
    var s : String ; s := fs.next() ;
    var one : int ; one := 0 ;
    var z : int ; z := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = '1') then     one := one + 1 ; else     z := z + 1 ; )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.ArrayList ;
public class codforce {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int s=scan.nextInt();
    String ss=scan.next();
    int count=0 ;
    int sum=0 ;
    for(int i=0 ; i<ss.length(); i++){
      if(ss.charAt(i)=='1'){
        count++;
      }
      else if(ss.charAt(i)=='0'){
        sum++;
      }
    }
    System.out.println(Math.abs(sum-count));
  }
}
------------------------------------------------------------
OCL File:
---------
 class codforce {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : int ; s := scan.getCurrent()->toInteger() ;
    var ss : String ; ss := scan.getCurrent() ;
    var count : int ; count := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < ss->size() do ( (     if (ss->at(i+1) = '1') then (     count := count + 1 ) else     if (ss->at(i+1) = '0') then (     sum := sum + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if sum - (count)->char2byte() < 0 then -(sum - (count)->char2byte()) else sum - (count)->char2byte() endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countWays(int[] arr,int n){
    int max_val=0 ;
    for(int i=0 ; i<n ; i++)max_val=Math.max(max_val,arr[i]);
    int[] freq=new int[max_val+1];
    for(int i=0 ; i<n ; i++)freq[arr[i] ]++;
    int ans=0 ;
    ans+=freq[0]*(freq[0]-1)*(freq[0]-2)/6 ;
    for(int i=1 ; i<=max_val ; i++)ans+=freq[0]*freq[i]*(freq[i]-1)/2 ;
    for(int i=1 ; 2*i<=max_val ; i++)ans+=freq[i]*(freq[i]-1)/2*freq[2*i];
    for(int i=1 ; i<=max_val ; i++){
      for(int j=i+1 ; i+j<=max_val ; j++)ans+=freq[i]*freq[j]*freq[i+j];
    }
    return ans ;
  }
  public static void main(String[] args){
    int[] arr=new int[] {
      1,2,3,4,5 };
      int n=arr.length ;
      System.out.println(countWays(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countWays( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max_val : int ; max_val := 0 ;
         var i : int ; i := 0 ; while i < n do (     max_val := Set{max_val, arr[i+1]}->max() ;  ;     i := i + 1 ) ; 
    var freq : Sequence(int) ; freq := Integer.subrange(1,max_val + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     freq[arr[i+1]+1] := freq[arr[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    ans := ans+(freq[0+1] * (freq[0+1] - 1) * (freq[0+1] - 2) / 6) ; 
        var i : int ; i := 1 ; while i <= max_val do (     ans := ans+(freq[0+1] * freq[i+1] * (freq[i+1] - 1) / 2) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while 2 * i <= max_val do (     ans := ans+(freq[i+1] * (freq[i+1] - 1) / 2 * freq[2 * i+1]) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= max_val do ( (         var j : int ; j := i + 1 ; while i + j <= max_val do (     ans := ans+(freq[i+1] * freq[j+1] * freq[i + j+1]) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countWays(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class P2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int d=0 ;
    int C=0 ;
    int S=0 ;
    if(s.length()>=5){
      for(int i=0 ; i<s.length(); i++){
        if(s.charAt(i)>=48 && s.charAt(i)<=57){
          d++;
        }
        else if(s.charAt(i)>=65 && s.charAt(i)<=90){
          C++;
        }
        else if(s.charAt(i)>=97 && s.charAt(i)<=122){
          S++;
        }
      }
      if(d>=1 && C>=1 && S>=1){
        System.out.println("Correct");
      }
      else {
        System.out.println("Too weak");
      }
    }
    else System.out.println("Too weak");
  }
}
------------------------------------------------------------
OCL File:
---------
 class P2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var d : int ; d := 0 ;
    var C : int ; C := 0 ;
    var S : int ; S := 0 ;
    if (s->size() >= 5) then (         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) >= 48 & s->at(i+1) <= 57) then (     d := d + 1 ) else     if (s->at(i+1) >= 65 & s->at(i+1) <= 90) then (     C := C + 1 ) else     if (s->at(i+1) >= 97 & s->at(i+1) <= 122) then (     S := S + 1 ) else skip ; ;  )  ;     i := i + 1 ) ; 
     if (d >= 1 & C >= 1 & S >= 1) then (     OclFile["System.out"].println("Correct") ) else (     OclFile["System.out"].println("Too weak") ) ) else     OclFile["System.out"].println("Too weak") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PasswordChecker {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    String str=s.nextLine();
    if(str.length()<4)System.out.println("Too weak");
    else {
      char a[]=new char[str.length()];
      for(int i=0 ; i<str.length(); i++){
        a[i]=str.charAt(i);
      }
      boolean p=false ;
      boolean q=false ;
      boolean r=false ;
      for(int i=0 ; i<a.length ; i++){
        if(a.length>4){
          int temp=(int)(a[i]);
          if(temp>=97 && temp<=122)p=true ;
          if(temp>=65 && temp<=90)q=true ;
          if(temp>=48 && temp<=57)r=true ;
        }
      }
      if(p && q && r)System.out.println("Correct");
      else System.out.println("Too weak");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PasswordChecker {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := s.nextLine() ;
     if (str->size() < 4) then     OclFile["System.out"].println("Too weak") ; else (     var a : Sequence(String) ; a := Integer.subrange(1,str->size())->collect(0) ;
         var i : int ; i := 0 ; while i < str->size() do ( (     a[i+1] := str->at(i+1) )  ;     i := i + 1 ) ; 
    var p : boolean ; p := false ;
    var q : boolean ; q := false ;
    var r : boolean ; r := false ;
        var i : int ; i := 0 ; while i < a->size() do ( (     if (a->size() > 4) then (     var temp : int ; temp := (a[i+1])->oclAsType(int) ;
     if (temp >= 97 & temp <= 122) then     p := true ; else skip ; 
     if (temp >= 65 & temp <= 90) then     q := true ; else skip ; 
     if (temp >= 48 & temp <= 57) then     r := true ; else skip ) else skip )  ;     i := i + 1 ) ; 
    if (p & q & r) then     OclFile["System.out"].println("Correct") else     OclFile["System.out"].println("Too weak") ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class InfiniteSequence {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    boolean exists=false ;
    if(a==b)System.out.println("YES");
    else if(a!=b && c==0)System.out.println("NO");
    else {
      if((b-a)% c==0 &&((b-a>0 && c>0)||(b-a<0 && c<0)))exists=true ;
      if(exists)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class InfiniteSequence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var exists : boolean ; exists := false ;
    if (a = b) then     OclFile["System.out"].println("YES") else     if (a /= b & c = 0) then     OclFile["System.out"].println("NO") else (     if ((b - a) mod c = 0 & ((b - a > 0 & c > 0) or (b - a < 0 & c < 0))) then     exists := true ; else skip ; 
     if (exists) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    boolean count=false,count2=false,count3=false ;
    String s=sc.next();
    if(s.length()<5){
      System.out.println("Too weak");
      return ;
    }
    for(int i=0 ; i<s.length(); i++){
      if(Character.isUpperCase(s.charAt(i))){
        count=true ;
      }
      else if(Character.isDigit(s.charAt(i))){
        count2=true ;
      }
      else if(Character.isLowerCase(s.charAt(i))){
        count3=true ;
      }
    }
    if(count && count2 && count3)System.out.println("Correct");
    else System.out.println("Too weak");
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : boolean ; count := false ;
    var count2 : boolean ; count2 := false ;
    var count3 : boolean ; count3 := false ;
    var s : String ; s := sc.getCurrent() ;
    if (s->size() < 5) then (     OclFile["System.out"].println("Too weak") ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     if ((s->at(i+1)->toUpperCase() = s->at(i+1))) then (     count := true ) else     if ((s->at(i+1) + "")->isMatch("[0-9]")) then (     count2 := true ) else     if ((s->at(i+1)->toLowerCase() = s->at(i+1))) then (     count3 := true ) else skip ; ;  )  ;     i := i + 1 ) ; 
    if (count & count2 & count3) then     OclFile["System.out"].println("Correct") else     OclFile["System.out"].println("Too weak") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class PasswordCheck {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String S=scan.nextLine();
    char[] A=S.toCharArray();
    if(A.length<5){
      System.out.println("Too weak");
      return ;
    }
    boolean lower=false ;
    boolean upper=false ;
    boolean digits=false ;
    for(char c : A){
      if(c>='a' && c<='z')lower=true ;
      if(c>='A' && c<='Z')upper=true ;
      if(c>='0' && c<='9')digits=true ;
    }
    if(! lower || ! upper || ! digits){
      System.out.println("Too weak");
    }
    else {
      System.out.println("Correct");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PasswordCheck {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := scan.nextLine() ;
    var A : Sequence(String) ; A := S->characters() ;
    if (A->size() < 5) then (     OclFile["System.out"].println("Too weak") ; 
     return ) else skip ; 
    var lower : boolean ; lower := false ;
    var upper : boolean ; upper := false ;
    var digits : boolean ; digits := false ;
    for (c : A) do ( (     if (c >= 'a' & c <= 'z') then     lower := true ; else skip ; 
     if (c >= 'A' & c <= 'Z') then     upper := true ; else skip ; 
     if (c >= '0' & c <= '9') then     digits := true ; else skip )  ) ; 
    if (not(lower) or not(upper) or not(digits)) then (     OclFile["System.out"].println("Too weak") ) else (     OclFile["System.out"].println("Correct") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Ex3 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int oo=0 ; oo<t ; oo++){
      int n=in.nextInt();
      int m=in.nextInt();
      if((n*m)% 2==0){
        System.out.println((n*m)/2);
      }
      else {
        System.out.println((n*m)/2+1);
      }
    }
  }
  public class ListNode<E>{
    private E value ;
    private ListNode next ;
    public ListNode(E newVal,ListNode<E>newNext){
      value=newVal ;
      next=newNext ;
    }
    public E getValue(){
      return value ;
    }
    public ListNode<E>getNext(){
      return next ;
    }
    public void setValue(E newValue){
      value=newValue ;
    }
    public void setNext(ListNode<E>newNext){
      next=newNext ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ex3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var oo : int ; oo := 0 ; while oo < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
     if ((n * m) mod 2 = 0) then (     OclFile["System.out"].println((n * m) / 2) ) else (     OclFile["System.out"].println((n * m) / 2 + 1) ) )  ;     oo := oo + 1 ) );
 class ListNode<E> {
   attribute value : E;
   attribute next : ListNode;
   static operation newListNode( newVal : E, newNext : ListNode<E>) : ListNode
  pre: true
  post: true
  activity:
  ( var self : ListNode ;
    self := createListNode();
    self.initialise(newVal, newNext);
    return self );
  operation initialise( newVal : E, newNext : ListNode<E>) : void
  pre: true  post: true
  activity: (     value := newVal ; 
     next := newNext );
   operation getValue() : E
  pre: true
  post: true
  activity: (     return value );
   operation getNext() : ListNode<E>
  pre: true
  post: true
  activity: (     return next );
   operation setValue( newValue : E) : void
  pre: true
  post: true
  activity: (     value := newValue );
   operation setNext( newNext : ListNode<E>) : void
  pre: true
  post: true
  activity: (     next := newNext );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test161 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      int a=in.nextInt();
      int b=in.nextInt();
      if((a*b)% 2==0){
        System.out.println(a*b/2);
      }
      else {
        System.out.println(a*b/2+1);
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test161 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
     if ((a * b) mod 2 = 0) then (     OclFile["System.out"].println(a * b / 2) ) else (     OclFile["System.out"].println(a * b / 2 + 1) ) )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int[] inx=new int[N];
    int[] iny=new int[N];
    int[] inh=new int[N];
    int H=0 ;
    int Cx=0 ;
    int Cy=0 ;
    int w ;
    int temp=0 ;
    int flag ;
    int memo=0 ;
    for(int i=0 ; i<N ; i++){
      inx[i]=scan.nextInt();
      iny[i]=scan.nextInt();
      inh[i]=scan.nextInt();
      if(inh[i]!=0){
        memo=i ;
      }
    }
    for(int k=0 ; k<=100 ; k++){
      for(int r=0 ; r<=100 ; r++){
        flag=1 ;
        temp=getH(inx[memo],iny[memo],k,r,inh[memo]);
        for(int s=0 ; s<N ; s++){
          w=getH(inx[s],iny[s],k,r,inh[s]);
          if(temp!=w){
            if(inh[s]==0 && temp<=w){
              continue ;
            }
            flag=-1 ;
            break ;
          }
        }
        if(flag==1){
          Cx=k ;
          Cy=r ;
          H=temp ;
        }
      }
    }
    System.out.println(Cx+" "+Cy+" "+H);
  }
  public static int getH(int x,int y,int Cx,int Cy,int h){
    int t=x-Cx>0 ? x-Cx : Cx-x ;
    int u=y-Cy>0 ? y-Cy : Cy-y ;
    int H=h+t+u ;
    if(h>=0){
      return H ;
    }
    else {
      return 0 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var inx : Sequence(int) ; inx := Integer.subrange(1,N)->collect(0) ;
    var iny : Sequence(int) ; iny := Integer.subrange(1,N)->collect(0) ;
    var inh : Sequence(int) ; inh := Integer.subrange(1,N)->collect(0) ;
    var H : int ; H := 0 ;
    var Cx : int ; Cx := 0 ;
    var Cy : int ; Cy := 0 ;
    var w : int ;
    var temp : int ; temp := 0 ;
    var flag : int ;
    var memo : int ; memo := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     inx[i+1] := scan.getCurrent()->toInteger() ; 
     iny[i+1] := scan.getCurrent()->toInteger() ; 
     inh[i+1] := scan.getCurrent()->toInteger() ; 
     if (inh[i+1] /= 0) then (     memo := i ) else skip )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k <= 100 do ( (         var r : int ; r := 0 ; while r <= 100 do ( (     flag := 1 ; 
     temp := getH(inx[memo+1], iny[memo+1], k, r, inh[memo+1]) ; 
         var s : int ; s := 0 ; while s < N do ( (     w := getH(inx[s+1], iny[s+1], k, r, inh[s+1]) ; 
     if (temp /= w) then (     if (inh[s+1] = 0 & temp <= w) then (     continue ) else skip ; 
     flag := -1 ; 
     break ) else skip )  ;     s := s + 1 ) ; 
     if (flag = 1) then (     Cx := k ; 
     Cy := r ; 
     H := temp ) else skip )  ;     r := r + 1 ) )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(Cx + " " + Cy + " " + H) ; 
 );
  static   operation getH( x : int, y : int, Cx : int, Cy : int, h : int) : int
  pre: true
  post: true
  activity: (     var t : int ; t := if x - Cx > 0 then x - Cx else Cx - x endif ;
     var u : int ; u := if y - Cy > 0 then y - Cy else Cy - y endif ;
     var H : int ; H := h + t + u ;
     if (h >= 0) then (     return H ) else (     return 0 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1358A_ParkLighting {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int row=input.nextInt();
      int col=input.nextInt();
      int area=row*col ;
      if(area % 2==1){
        System.out.println((area+1)/2);
      }
      else {
        System.out.println(area/2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1358A_ParkLighting {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var row : int ; row := input.getCurrent()->toInteger() ;
     var col : int ; col := input.getCurrent()->toInteger() ;
     var area : int ; area := row * col ;
     if (area mod 2 = 1) then (     OclFile["System.out"].println((area + 1) / 2) ) else (     OclFile["System.out"].println(area / 2) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Park {
  int number ;
  public Park(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  public void input(int numberOne,int numberTwo){
    if((numberOne*numberTwo)% 2==0){
      System.out.println((numberOne*numberTwo)/2);
    }
    else {
      System.out.println((numberOne*numberTwo)/2+1);
    }
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    Park instance=new Park(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      int n=input.nextInt();
      int m=input.nextInt();
      instance.input(n,m);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Park {
   attribute number : int;
   static operation newPark( number : int) : Park
  pre: true
  post: true
  activity:
  ( var self : Park ;
    self := createPark();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
   operation input( numberOne : int, numberTwo : int) : void
  pre: true
  post: true
  activity: (     if ((numberOne * numberTwo) mod 2 = 0) then (     OclFile["System.out"].println((numberOne * numberTwo) / 2) ) else (     OclFile["System.out"].println((numberOne * numberTwo) / 2 + 1) ) );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
     var instance : Park ; instance := Park.newPark(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var m : int ; m := input.getCurrent()->toInteger() ;
     instance.input(n, m) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewClass49 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    while(n-->0){
      int a=in.nextInt();
      int b=in.nextInt();
      System.out.println((a*b+1)/2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass49 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println((a * b + 1) / 2) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public List<String>readBinaryWatch(int num){
    List<String>times=new ArrayList<>();
    for(int h=0 ; h<12 ; h++)for(int m=0 ; m<60 ; m++)if(Integer.bitCount(h*64+m)==num)times.add(String.format("%d:%02d",h,m));
    return times ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation readBinaryWatch( num : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var times : Sequence(String) ; times := Sequence{} ;
         var h : int ; h := 0 ; while h < 12 do (         var m : int ; m := 0 ; while m < 60 do (     if (bitCount(h * 64 + m) = num) then     times := times->including(StringLib.format("%d:%02d",Sequence{h,m})) ; else skip ;  ;     m := m + 1 ) ;  ;     h := h + 1 ) ; 
     return times );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String lexNext(String str,int n){
    char[] s=str.toCharArray();
    for(int i=n-1 ; i>=0 ; i--){
      if(s[i]!='z'){
        s[i]++;
        return String.valueOf(s);
      }
      s[i]='a' ;
    }
    return null ;
  }
  static public void main(String[] args){
    String S="abcdeg",T="abcfgh" ;
    int n=S.length();
    String res=lexNext(S,n);
    if(res!=T){
      System.out.println(res);
    }
    else {
      System.out.println("-1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation lexNext( str : String, n : int) : String
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := str->characters() ;
         var i : int ; i := n - 1 ; while i >= 0 do ( (     if (s[i+1] /= 'z') then (     s[i+1] := s[i+1] + 1 ; 
     return (s)->sum()  ) else skip ; 
     s[i+1] := 'a' )  ;     i := i - 1 ) ; 
     return null );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := "abcdeg" ;
    var T : String ; T := "abcfgh" ;
     var n : int ; n := S->size() ;
     var res : String ; res := lexNext(S, n) ;
     if (res /= T) then (     OclFile["System.out"].println(res) ) else (     OclFile["System.out"].println("-1") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static ArrayList md=new ArrayList();
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int l=in.nextInt();
    int r=in.nextInt();
    int a=in.nextInt();
    int total=0 ;
    if(r==l){
      total=r+l+a ;
      if(total % 2!=0){
        total--;
      }
    }
    else {
      if(r<l){
        r+=a ;
        if(r<l){
          total=r*2 ;
        }
        else total=r+l ;
      }
      else if(r>l){
        l+=a ;
        if(r>l){
          total=l*2 ;
        }
        else total=r+l ;
      }
    }
    if(total % 2!=0){
      total--;
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute md : Sequence := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := in.getCurrent()->toInteger() ;
    var r : int ; r := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var total : int ; total := 0 ;
    if (r = l) then (     total := r + l + a ; 
     if (total mod 2 /= 0) then (     total := total - 1 ) else skip ) else (     if (r < l) then (     r := r+(a) ; 
     if (r < l) then (     total := r * 2 ) else     total := r + l ; ) else     if (r > l) then (     l := l+(a) ; 
     if (r > l) then (     total := l * 2 ) else     total := r + l ; ) else skip ; ) ;  
    if (total mod 2 /= 0) then (     total := total - 1 ) else skip ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class InfiniteSequence {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long a=in.nextLong(),b=in.nextLong(),c=in.nextLong();
    long diff=b-a ;
    if((a+c)<a && a<b){
      pw.println("NO");
      pw.close();
      return ;
    }
    if(diff<0 && c>=0){
      pw.println("NO");
      pw.close();
      return ;
    }
    if(diff==c){
      pw.println("YES");
      pw.close();
      return ;
    }
    if(c==0 && diff>0){
      pw.println("NO");
      pw.close();
      return ;
    }
    if(diff % c==0)pw.println("YES");
    else pw.println("NO");
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class InfiniteSequence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : long ; a := in.getCurrent()->toLong() ;
    var b : long ; b := in.getCurrent()->toLong() ;
    var c : long ; c := in.getCurrent()->toLong() ;
    var diff : long ; diff := b - a ;
    if ((a + c) < a & a < b) then (     skip ; 
     skip ; 
     return ) else skip ; 
    if (diff < 0 & c >= 0) then (     skip ; 
     skip ; 
     return ) else skip ; 
    if (diff = c) then (     skip ; 
     skip ; 
     return ) else skip ; 
    if (c = 0 & diff > 0) then (     skip ; 
     skip ; 
     return ) else skip ; 
    if (diff mod c = 0) then     skip else     skip ; ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Testt_2 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int l=in.nextInt();
    int r=in.nextInt();
    int a=in.nextInt();
    while(a>0){
      if(l<r)l++;
      else r++;
      a--;
    }
    System.out.println(Math.min(l,r)*2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Testt{
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := in.getCurrent()->toInteger() ;
    var r : int ; r := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    while (a > 0) do (     if (l < r) then     l := l + 1 else     r := r + 1 ; ;  
     a := a - 1 ) ; 
    OclFile["System.out"].println(Set{l, r}->min() * 2) ; 
 );
}
 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := in.getCurrent()->toInteger() ;
    var r : int ; r := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    while (a > 0) do (     if (l < r) then     l := l + 1 else     r := r + 1 ; ;  
     a := a - 1 ) ; 
    OclFile["System.out"].println(Set{l, r}->min() * 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class problemsolving {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int l=input.nextInt();
    int r=input.nextInt();
    int b=input.nextInt();
    while(b!=0){
      if(l<=r)l++;
      else r++;
      b--;
    }
    if(l<r)System.out.println(l*2);
    else System.out.println(r*2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class problemsolving {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := input.getCurrent()->toInteger() ;
    var r : int ; r := input.getCurrent()->toInteger() ;
    var b : int ; b := input.getCurrent()->toInteger() ;
    while (b /= 0) do (     if (l <= r) then     l := l + 1 else     r := r + 1 ; ;  
     b := b - 1 ) ; 
    if (l < r) then     OclFile["System.out"].println(l * 2) else     OclFile["System.out"].println(r * 2) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _950A_LeftRightAmbidexters {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int left=input.nextInt();
    int right=input.nextInt();
    int both=input.nextInt();
    int min=Math.min(left,right);
    int max=Math.max(left,right);
    while(max!=min && both>0){
      min++;
      both--;
    }
    int result=2*(min+both/2);
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _950A_LeftRightAmbidexters {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var left : int ; left := input.getCurrent()->toInteger() ;
    var right : int ; right := input.getCurrent()->toInteger() ;
    var both : int ; both := input.getCurrent()->toInteger() ;
    var min : int ; min := Set{left, right}->min() ;
    var max : int ; max := Set{left, right}->max() ;
    while (max /= min & both > 0) do (     min := min + 1 ; 
     both := both - 1 ) ; 
    var result : int ; result := 2 * (min + both / 2) ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSteps(int n){
    int steps=0 ;
    while(n>0){
      int largest=(int)Math.cbrt(n);
      n-=(largest*largest*largest);
      steps++;
    }
    return steps ;
  }
  public static void main(String[] args){
    int n=150 ;
    System.out.print(countSteps(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSteps( n : int) : int
  pre: true
  post: true
  activity: (     var steps : int ; steps := 0 ;
     while (n > 0) do (     var largest : int ; largest := (n)->cbrt()->oclAsType(int) ;
     n := n-((largest * largest * largest)) ; 
     steps := steps + 1 ) ; 
     return steps );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 150 ;
     OclFile["System.out"].print(countSteps(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getMaxLength(boolean arr[],int n){
    int count=0 ;
    int result=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==false)count=0 ;
      else {
        count++;
        result=Math.max(result,count);
      }
    }
    return result ;
  }
  public static void main(String[] args){
    boolean arr[]={
      true,true,false,false,true,false,true,false,true,true,true,true };
      int n=arr.length ;
      System.out.println(getMaxLength(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getMaxLength( arr : Sequence(boolean), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = false) then     count := 0 ; else (     count := count + 1 ; 
     result := Set{result, count}->max() ) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(boolean) ; arr := Sequence{true,true,false,false,true,false,true,false,true,true,true,true} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(getMaxLength(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int countSetBits(int n){
    int i=0 ;
    int ans=0 ;
    while((1<<i)<=n){
      boolean k=false ;
      int change=1<<i ;
      for(int j=0 ; j<=n ; j++){
        if(k==true)ans+=1 ;
        else ans+=0 ;
        if(change==1){
          k=! k ;
          change=1<<i ;
        }
        else {
          change--;
        }
      }
      i++;
    }
    return ans ;
  }
  public static void main(String[] args){
    int n=17 ;
    System.out.println(countSetBits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var ans : int ; ans := 0 ;
     while (((1*(2->pow(i)))->oclAsType(long)) <= n) do (     var k : boolean ; k := false ;
     var change : int ; change := (1*(2->pow(i)))->oclAsType(long) ;
         var j : int ; j := 0 ; while j <= n do ( (     if (k = true) then     ans := ans+(1) else     ans := ans+(0) ; ;  
     if (change = 1) then (     k := not(k) ; 
     change := (1*(2->pow(i)))->oclAsType(long) ) else (     change := change - 1 ) )  ;     j := j + 1 ) ; 
     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 17 ;
     OclFile["System.out"].println(countSetBits(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int[] values ;
  static int[] prevs ;
  static long[] dp ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    values=new int[n];
    for(int i=0 ; i<n ; i++){
      values[i]=sc.nextInt();
    }
    prevs=new int[n];
    PriorityQueue<Area>queue=new PriorityQueue<>();
    for(int i=0 ; i<m ; i++){
      queue.add(new Area(sc.nextInt()-1,sc.nextInt()-1));
    }
    for(int i=0 ; i<n ; i++){
      while(queue.size()>0 && queue.peek().right<i){
        queue.poll();
      }
      if(queue.size()==0 || queue.peek().left>i){
        prevs[i]=i-1 ;
      }
      else {
        prevs[i]=queue.peek().left-1 ;
      }
    }
    dp=new long[n];
    Arrays.fill(dp,Long.MIN_VALUE);
    for(int i=0 ; i<n ; i++){
      dfw(i);
    }
    System.out.println(dfw(n-1));
  }
  static long dfw(int idx){
    if(idx<0){
      return 0 ;
    }
    if(dp[idx]>=0){
      return dp[idx];
    }
    return dp[idx]=Math.max(dfw(idx-1),dfw(prevs[idx])+values[idx]);
  }
  static class Area implements Comparable<Area>{
    int left ;
    int right ;
    public Area(int left,int right){
      this.left=left ;
      this.right=right ;
    }
    public int compareTo(Area another){
      return left-another.left ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute values : Sequence(int);
  static   attribute prevs : Sequence(int);
  static   attribute dp : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    values := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     values[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    prevs := Integer.subrange(1,n)->collect(0) ; 
    var queue : Sequence(Area) ; queue := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     queue := queue->including(Area.newArea(sc.getCurrent()->toInteger() - 1, sc.getCurrent()->toInteger() - 1)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     while (queue->size() > 0 & queue->min().right < i) do (     queue := queue->sort()->tail() ) ; 
     if (queue->size() = 0 or queue->min().left > i) then (     prevs[i+1] := i - 1 ) else (     prevs[i+1] := queue->min().left - 1 ) )  ;     i := i + 1 ) ; 
    dp := Integer.subrange(1,n)->collect(0) ; 
    dp := dp->collect("-9223372036854775808"->toLong()) ; 
        var i : int ; i := 0 ; while i < n do ( (     execute dfw(i) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dfw(n - 1)) ; 
 );
  static   operation dfw( idx : int) : long
  pre: true
  post: true
  activity: (     if (idx < 0) then (     return 0 ) else skip ; 
     if (dp[idx+1] >= 0) then (     return dp[idx+1] ) else skip ; 
     return dp[idx+1] );
  static class Area implements Comparable<Area> {
   attribute left : int;
   attribute right : int;
   static operation newArea( left : int, right : int) : Area
  pre: true
  post: true
  activity:
  ( var self : Area ;
    self := createArea();
    self.initialise(left, right);
    return self );
  operation initialise( left : int, right : int) : void
  pre: true  post: true
  activity: (     self.left := left ; 
     self.right := right );
   operation compareTo( another : Area) : int
  pre: true
  post: true
  activity: (     return left - another.left );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double areaCircle(double b){
    double area=(double)3.1415926*b*b ;
    return area ;
  }
  public static void main(String args[]){
    float a=10,b=8 ;
    System.out.println(areaCircle(b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation areaCircle( b : double) : double
  pre: true
  post: true
  activity: (     var area : double ; area := 3.1415926->oclAsType(double) * b * b ;
     return area );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 10 ;
    var b : double ; b := 8 ;
     OclFile["System.out"].println(areaCircle(b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _119A_ApicGame {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int a=input.nextInt();
    int b=input.nextInt();
    int n=input.nextInt();
    input.nextLine();
    int counter=0 ;
    while(n>0){
      if(counter % 2==0){
        n-=gcd(n,a);
      }
      else {
        n-=gcd(n,b);
      }
      counter++;
    }
    counter--;
    System.out.println(counter % 2);
  }
  static int gcd(int a,int b){
    int min=Math.min(a,b);
    int result=min ;
    for(int i=min ; i>=1 ; i--){
      if(a % i==0 && b % i==0){
        result=i ;
        break ;
      }
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class _119A_ApicGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := input.getCurrent()->toInteger() ;
    var b : int ; b := input.getCurrent()->toInteger() ;
    var n : int ; n := input.getCurrent()->toInteger() ;
    skip ; 
    var counter : int ; counter := 0 ;
    while (n > 0) do (     if (counter mod 2 = 0) then (     n := n-(gcd(n, a)) ) else (     n := n-(gcd(n, b)) ) ;  
     counter := counter + 1 ) ; 
    counter := counter - 1 ; 
    OclFile["System.out"].println(counter mod 2) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var min : int ; min := Set{a, b}->min() ;
     var result : int ; result := min ;
         var i : int ; i := min ; while i >= 1 do ( (     if (a mod i = 0 & b mod i = 0) then (     result := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class EpicGame {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String in=input.nextLine();
    int simon=Integer.valueOf(in.split(" ")[0]);
    int Ant=Integer.valueOf(in.split(" ")[1]);
    int heap=Integer.valueOf(in.split(" ")[2]);
    int counter=3 ;
    getRemained(counter,simon,Ant,simon,heap);
  }
  static void getRemained(int counter,int simon,int ant,int number,int heap){
    int gcd=0 ;
    for(int i=1 ; i<=heap ; i++){
      if(number % i==0 && heap % i==0){
        gcd=i ;
      }
    }
    heap=heap-gcd ;
    if(counter % 2==0){
      if(gcd>heap){
        System.out.println("1");
        return ;
      }
      counter++;
      getRemained(counter,simon,ant,simon,heap);
    }
    else {
      if(gcd>heap){
        System.out.println("0");
        return ;
      }
      counter++;
      getRemained(counter,simon,ant,ant,heap);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class EpicGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var in : String ; in := input.nextLine() ;
    var simon : int ; simon := (in->split(" ")[0+1])->toInteger() ;
    var Ant : int ; Ant := (in->split(" ")[1+1])->toInteger() ;
    var heap : int ; heap := (in->split(" ")[2+1])->toInteger() ;
    var counter : int ; counter := 3 ;
    execute getRemained(counter, simon, Ant, simon, heap) ; 
 );
  static   operation getRemained( counter : int, simon : int, ant : int, number : int, heap : int) : void
  pre: true
  post: true
  activity: (     var gcd : int ; gcd := 0 ;
         var i : int ; i := 1 ; while i <= heap do ( (     if (number mod i = 0 & heap mod i = 0) then (     gcd := i ) else skip )  ;     i := i + 1 ) ; 
     heap := heap - gcd ; 
     if (counter mod 2 = 0) then (     if (gcd > heap) then (     OclFile["System.out"].println("1") ; 
     return ) else skip ; 
     counter := counter + 1 ; 
     execute getRemained(counter, simon, ant, simon, heap) ) else (     if (gcd > heap) then (     OclFile["System.out"].println("0") ; 
     return ) else skip ; 
     counter := counter + 1 ; 
     execute getRemained(counter, simon, ant, ant, heap) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int seriesSum(int calculated,int current,int N){
    int i,cur=1 ;
    if(current==N+1)return 0 ;
    for(i=calculated ; i<calculated+current ; i++)cur*=i ;
    return cur+seriesSum(i,current+1,N);
  }
  public static void main(String[] args){
    int N=5 ;
    System.out.println(seriesSum(1,1,N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation seriesSum( calculated : int, current : int, N : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var cur : int ; cur := 1 ;
     if (current = N + 1) then     return 0 else skip ; 
         i := calculated ; while i < calculated + current do (     cur := cur*(i) ;  ;     i := i + 1 ) ; 
     return cur + seriesSum(i, current + 1, N) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     OclFile["System.out"].println(seriesSum(1, 1, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class tp {
  public static void main(String[] args)throws IOException {
    BufferedReader bs=new BufferedReader(new InputStreamReader(System.in));
    String[] ip=bs.readLine().split(" ");
    int a=Integer.parseInt(ip[0]);
    int b=Integer.parseInt(ip[1]);
    int c=Integer.parseInt(ip[2]);
    int turn=0 ;
    while(c>0){
      if(turn==0){
        c-=gcd(a,c);
        turn=1 ;
      }
      else {
        c-=gcd(b,c);
        turn=0 ;
      }
    }
    System.out.println(Math.abs(turn-1));
  }
  public static int gcd(int a,int b){
    if(b==0){
      return a ;
    }
    return gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class tp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bs : OclFile ; bs := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var ip : Sequence(String) ; ip := bs.readLine()->split(" ") ;
    var a : int ; a := (ip[0+1])->toInteger() ;
    var b : int ; b := (ip[1+1])->toInteger() ;
    var c : int ; c := (ip[2+1])->toInteger() ;
    var turn : int ; turn := 0 ;
    while (c > 0) do (     if (turn = 0) then (     c := c-(gcd(a, c)) ; 
     turn := 1 ) else (     c := c-(gcd(b, c)) ; 
     turn := 0 ) ) ; 
    OclFile["System.out"].println(if turn - 1 < 0 then -(turn - 1) else turn - 1 endif) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else skip ; 
     return gcd(b, a mod b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test255 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    int b=in.nextInt();
    int c=in.nextInt();
    boolean x=true ;
    while(true){
      if(x){
        int k=Check(a,c);
        if(k==0){
          System.out.println("1");
          break ;
        }
        else {
          x=false ;
          c-=k ;
        }
      }
      else {
        int k=Check(b,c);
        if(k==0){
          System.out.println("0");
          break ;
        }
        else {
          x=true ;
          c-=k ;
        }
      }
    }
    in.close();
  }
  private static int Check(int a,int c){
    if(a==0 || c==0){
      return 0 ;
    }
    if(a==c){
      return a ;
    }
    if(a>c){
      return Check(a-c,c);
    }
    else {
      return Check(a,c-a);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class test255 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var x : boolean ; x := true ;
    while (true) do (     if (x) then (     var k : int ; k := Check(a, c) ;
     if (k = 0) then (     OclFile["System.out"].println("1") ; 
     break ) else (     x := false ; 
     c := c-(k) ) ) else (     var k : int ; k := Check(b, c) ;
     if (k = 0) then (     OclFile["System.out"].println("0") ; 
     break ) else (     x := true ; 
     c := c-(k) ) ) ) ; 
    skip ; 
 );
  static   operation Check( a : int, c : int) : int
  pre: true
  post: true
  activity: (     if (a = 0 or c = 0) then (     return 0 ) else skip ; 
     if (a = c) then (     return a ) else skip ; 
     if (a > c) then (     return Check(a - c, c) ) else (     return Check(a, c - a) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=null ;
    int x=0 ;
    BigInteger factorial=new BigInteger("1");
    int count=0 ;
    try {
      sc=new Scanner(System.in);
      while((x=sc.nextInt())!=0){
        for(int i=1 ; i<=x ; i++){
          factorial=factorial.multiply(new BigInteger(String.valueOf(i)));
        }
        String[] str=String.valueOf(factorial).split("");
        for(int i=str.length-1 ; Integer.parseInt(str[i])==0 ; i--){
          count++;
        }
        System.out.println(count);
        factorial=new BigInteger("1");
        count=0 ;
      }
    }
    finally {
      sc.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := null ;
     var x : int ; x := 0 ;
    var factorial : long ; factorial := long("1") ;
    var count : int ; count := 0 ;
    try (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
         x := sc.getCurrent()->toInteger() ;
    while ((x) /= 0) do (    skip ; (         var i : int ; i := 1 ; while i <= x do ( (     factorial := factorial.multiply(long(((i) + ""))) )  ;     i := i + 1 ) ; 
     var str : Sequence(String) ; str := ((factorial) + "")->split("") ;
        var i : int ; i := str->size() - 1 ; while (str[i+1])->toInteger() = 0 do ( (     count := count + 1 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(count) ; 
    factorial := long("1") ; 
    count := 0 ; 
 ) ;     x := sc.getCurrent()->toInteger() ;
 ) )   finally (     skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int n ;
    Scanner sc=new Scanner(System.in);
    for(n=sc.nextInt(); n!=0 ; n=sc.nextInt()){
      int num=0 ;
      for(int i=5 ; i<=n ; i=i*5){
        num=num+n/i ;
      }
      System.out.println(num);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         n := sc.getCurrent()->toInteger() ; while n /= 0 do ( (     var num : int ; num := 0 ;
         var i : int ; i := 5 ; while i <= n do ( (     num := num + n / i )  ;     i := i * 5 ) ; 
     OclFile["System.out"].println(num) )  ;     n := sc.getCurrent()->toInteger() ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  static int[] ints=new int[10];
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String input=reader.readLine();
      if(input==null || input.equals("0")){
        break ;
      }
      long value=Long.parseLong(input);
      int count=0 ;
      for(long i=5 ; i<=value ; i*=5){
        count+=value/i ;
      }
      System.out.println(count);
    }
  }
  public static void main2(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String line ;
      while((line=br.readLine())!=null){
        if(line.isEmpty())break ;
        int nn=Integer.parseInt(line),count=0 ;
        if(nn==0)break ;
        for(int i=5 ; i<nn ; i*=5){
          count+=nn/i ;
        }
        System.out.println(count);
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ints : Sequence(int) := Integer.subrange(1,10)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var input : String ; input := reader.readLine() ;
     if (input = null or input = "0") then (     break ) else skip ; 
    var value : long ; value := (input)->toLong() ;
    var count : int ; count := 0 ;
        var i : long ; i := 5 ; while i <= value do ( (     count := count+(value / i) )  ;     i := i*(5) ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
  static   operation main2( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->isEmpty()) then     break else skip ; 
     var nn : int ; nn := (line)->toInteger() ;
    var count : int ; count := 0 ;
    if (nn = 0) then     break else skip ; 
        var i : int ; i := 5 ; while i < nn do ( (     count := count+(nn / i) )  ;     i := i*(5) ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;     line := br.readLine() ;
 ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    int num=0 ;
    while((num=parseNum())!=0){
      fact(num);
    }
  }
  private static void fact(int n){
    int t=0 ;
    int[] a=new int[2];
    for(int i=2 ; i<=n ; i++){
      for(t=i ; t % 2==0 ; t/=2){
        a[0]++;
      }
      for(t=i ; t % 5==0 ; t/=5){
        a[1]++;
      }
    }
    System.out.println(Math.min(a[0],a[1]));
  }
  private static int parseNum(){
    int num=0 ;
    String strNum=parseStdin();
    if(strNum!=null){
      num=Integer.parseInt(strNum);
    }
    return num ;
  }
  private static String parseStdin(){
    String strNum=null ;
    try {
      String line=br.readLine();
      if(line!=null){
        if(! line.isEmpty()){
          strNum=line ;
        }
      }
    }
    catch(IOException e){
    }
    return strNum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 0 ;
         num := parseNum() ;
    while ((num) /= 0) do (    skip ; (     execute fact(num) ) ;     num := parseNum() ;
 ) );
  static   operation fact( n : int) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 0 ;
     var a : Sequence(int) ; a := Integer.subrange(1,2)->collect(0) ;
         var i : int ; i := 2 ; while i <= n do ( (         t := i ; while t mod 2 = 0 do ( (     a[0+1] := a[0+1] + 1 )  ;     t := t/(2) ) ; 
         t := i ; while t mod 5 = 0 do ( (     a[1+1] := a[1+1] + 1 )  ;     t := t/(5) ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(Set{a[0+1], a[1+1]}->min()) );
  static   operation parseNum() : int
  pre: true
  post: true
  activity: (     var num : int ; num := 0 ;
     var strNum : String ; strNum := parseStdin() ;
     if (strNum /= null) then (     num := (strNum)->toInteger() ) else skip ; 
     return num );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var strNum : String ; strNum := null ;
     try (     var line : String ; line := br.readLine() ;
     if (line /= null) then (     if (not(line->isEmpty())) then (     strNum := line ) else skip ) else skip )   catch (e : IOException) do skip
     return strNum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Researcher {
  int n ;
  int c[]={
    0,0,0 };
    Researcher(int n){
      this.n=n ;
    }
    int Two(){
      while(this.n % 2==0){
        c[2]++;
        this.n/=2 ;
      }
      return c[2];
    }
    int Five(){
      while(this.n % 5==0){
        c[1]++;
        this.n/=5 ;
      }
      return c[1];
    }
    int Ten(){
      while(this.n % 10==0){
        c[0]++;
        this.n/=10 ;
      }
      return c[0];
    }
  }
  class Main {
    public static void main(String args[]){
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String buf ;
      try {
        while((buf=br.readLine()).equals("0")==false){
          int c[]={
            0,0,0 };
            int n=Integer.parseInt(buf);
            for(int i=1 ; i<=n ; i++){
              Researcher r=new Researcher(i);
              c[0]+=r.Ten();
              c[1]+=r.Five();
              c[2]+=r.Two();
            }
            System.out.println(c[0]+Math.min(c[1],c[2]));
          }
        }
        catch(Exception e){
          e.printStackTrace();
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Researcher {
   attribute n : int;
   attribute c : int := Sequence{0,0,0};
   static operation newResearcher( n : int) : Researcher
  pre: true
  post: true
  activity:
  ( var self : Researcher ;
    self := createResearcher();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     self.n := n );
   operation Two() : int
  pre: true
  post: true
  activity: (     while (self.n mod 2 = 0) do (     c[2+1] := c[2+1] + 1 ; 
     self.n := self.n/(2) ) ; 
     return c[2+1] );
   operation Five() : int
  pre: true
  post: true
  activity: (     while (self.n mod 5 = 0) do (     c[1+1] := c[1+1] + 1 ; 
     self.n := self.n/(5) ) ; 
     return c[1+1] );
   operation Ten() : int
  pre: true
  post: true
  activity: (     while (self.n mod 10 = 0) do (     c[0+1] := c[0+1] + 1 ; 
     self.n := self.n/(10) ) ; 
     return c[0+1] );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var buf : String ;
     try (         buf := br.readLine() ;
    while ((buf) = "0" = false) do (        buf := br.readLine() ;
    (buf) = "0" ;     skip ; (     var c : Sequence(int) ; c := Sequence{0,0,0} ;
     var n : int ; n := (buf)->toInteger() ;
         var i : int ; i := 1 ; while i <= n do ( (     var r : Researcher ; r := Researcher.newResearcher(i) ;
     c[0+1] := c[0+1]+(r.Ten()) ; 
     c[1+1] := c[1+1]+(r.Five()) ; 
     c[2+1] := c[2+1]+(r.Two()) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(c[0+1] + Set{c[1+1], c[2+1]}->min()) ) ;     buf := br.readLine() ;
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Ps {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int k=in.nextInt(),d=in.nextInt();
    if(d>0 && k>1){
      System.out.print(d);
      for(int i=0 ; i<k-1 ; i++){
        System.out.print("0");
      }
    }
    else {
      if(k==1)System.out.print(d);
      else System.out.println("No solution");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ps {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
     if (d > 0 & k > 1) then (     OclFile["System.out"].print(d) ; 
         var i : int ; i := 0 ; while i < k - 1 do ( (     OclFile["System.out"].print("0") )  ;     i := i + 1 ) ) else (     if (k = 1) then     OclFile["System.out"].print(d) ; else     OclFile["System.out"].println("No solution") ; ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DigitalRoot {
  static void digital(int k,int d){
    if(k>1 && d==0)System.out.println("No solution");
    else {
      System.out.print(d);
      for(int i=1 ; i<k ; i++)System.out.print("0");
    }
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int k=in.nextInt();
    int d=in.nextInt();
    digital(k,d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class DigitalRoot {
  static   operation digital( k : int, d : int) : void
  pre: true
  post: true
  activity: (     if (k > 1 & d = 0) then     OclFile["System.out"].println("No solution") ; else (     OclFile["System.out"].print(d) ; 
         var i : int ; i := 1 ; while i < k do (     OclFile["System.out"].print("0") ;  ;     i := i + 1 ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := in.getCurrent()->toInteger() ;
     var d : int ; d := in.getCurrent()->toInteger() ;
     execute digital(k, d) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DigitalRoot {
  static void digital(int k,int d){
    if(k>1 && d==0)System.out.println("No solution");
    else {
      System.out.print(d);
      for(int i=1 ; i<k ; i++)System.out.print("0");
    }
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int k=in.nextInt();
    int d=in.nextInt();
    digital(k,d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class DigitalRoot {
  static   operation digital( k : int, d : int) : void
  pre: true
  post: true
  activity: (     if (k > 1 & d = 0) then     OclFile["System.out"].println("No solution") ; else (     OclFile["System.out"].print(d) ; 
         var i : int ; i := 1 ; while i < k do (     OclFile["System.out"].print("0") ;  ;     i := i + 1 ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := in.getCurrent()->toInteger() ;
     var d : int ; d := in.getCurrent()->toInteger() ;
     execute digital(k, d) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void swapOperations(char[] a,char[] b,char[] c){
    int l=a.length ;
    int i=0 ;
    int total_swaps=0 ;
    char temp ;
    for(i=0 ; i<l ; i++){
      if(a[i]==b[i])continue ;
      if(a[i]==c[i]){
        temp=b[i];
        b[i]=c[i];
        c[i]=temp ;
        total_swaps++;
        continue ;
      }
      if(b[i]==c[i]){
        temp=a[i];
        a[i]=c[i];
        c[i]=temp ;
        total_swaps++;
        continue ;
      }
      break ;
    }
    if(i==l)System.out.println(total_swaps);
    else System.out.println(-1);
  }
  public static void main(String[] args){
    String a="xyz" ;
    String b="yzx" ;
    String c="yzx" ;
    swapOperations(a.toCharArray(),b.toCharArray(),c.toCharArray());
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation swapOperations( a : Sequence(String), b : Sequence(String), c : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := a->size() ;
     var i : int ; i := 0 ;
    var total_swaps : int ; total_swaps := 0 ;
    var temp : String ;
        i := 0 ; while i < l do ( (     if (a[i+1] = b[i+1]) then     continue else skip ; 
     if (a[i+1] = c[i+1]) then (     temp := b[i+1] ; 
     b[i+1] := c[i+1] ; 
    c[i+1] := temp ; 
    total_swaps := total_swaps + 1 ; 
    continue 
 ) else skip ; 
     if (b[i+1] = c[i+1]) then (     temp := a[i+1] ; 
     a[i+1] := c[i+1] ; 
    c[i+1] := temp ; 
    total_swaps := total_swaps + 1 ; 
    continue 
 ) else skip ; 
     break )  ;     i := i + 1 ) ; 
    if (i = l) then     OclFile["System.out"].println(total_swaps) else     OclFile["System.out"].println(-1) ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ; a := "xyz" ;
     var b : String ; b := "yzx" ;
     var c : String ; c := "yzx" ;
     execute swapOperations(a->characters(), b->characters(), c->characters()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class codeforces {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    int d=sc.nextInt();
    String s=String.valueOf(d);
    if(d==0 && k==1)System.out.println("0");
    else if(d==0 && k>1)System.out.println("No solution");
    else {
      for(int i=2 ; i<=k ; i++){
        s=s+"0" ;
      }
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var s : String ; s := ((d) + "") ;
    if (d = 0 & k = 1) then     OclFile["System.out"].println("0") else     if (d = 0 & k > 1) then     OclFile["System.out"].println("No solution") else (         var i : int ; i := 2 ; while i <= k do ( (     s := s + "0" )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(s) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  class AOJ_0138 implements Comparable<AOJ_0138>{
    Integer num ;
    Double time ;
    public int compareTo(AOJ_0138 o){
      return time.compareTo(o.time);
    }
  }
  void doIt(){
    int m=0 ;
    Scanner sc=new Scanner(System.in);
    AOJ_0138[] data=new AOJ_0138[8];
    AOJ_0138[] sub=new AOJ_0138[18];
    for(int i=0 ; i<3 ; i++){
      for(int k=0 ; k<8 ; k++){
        data[k]=new AOJ_0138();
        data[k] .num=sc.nextInt();
        data[k] .time=sc.nextDouble();
      }
      Arrays.sort(data);
      System.out.printf("%d %.2f\n",data[0] .num,data[0] .time);
      System.out.printf("%d %.2f\n",data[1] .num,data[1] .time);
      for(int k=2 ; k<8 ; k++,m++){
        sub[m]=data[k];
      }
    }
    Arrays.sort(sub);
    System.out.printf("%d %.2f\n",sub[0] .num,sub[0] .time);
    System.out.printf("%d %.2f\n",sub[1] .num,sub[1] .time);
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class AOJ_0138 implements Comparable<AOJ_0138> {
   attribute num : int;
   attribute time : double;
   operation compareTo( o : AOJ_0138) : int
  pre: true
  post: true
  activity: (     return time->compareTo(o.time) );
}
   operation doIt() : void
  pre: true
  post: true
  activity: (     var m : int ; m := 0 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var data : Sequence(AOJ_0138) ; data := Integer.subrange(1,8)->collect(null) ;
    var sub : Sequence(AOJ_0138) ; sub := Integer.subrange(1,18)->collect(null) ;
        var i : int ; i := 0 ; while i < 3 do ( (         var k : int ; k := 0 ; while k < 8 do ( (     data[k+1] := AOJ_0138.newAOJ_0138() ; 
     data[k+1].num := sc.getCurrent()->toInteger() ; 
     data[k+1].time := sc.getCurrent()->toReal() )  ;     k := k + 1 ) ; 
     data := data->sort() ; 
    OclFile["System.out"].printf("%d %.2f\n", data[0+1].num, data[0+1].time) ; 
    OclFile["System.out"].printf("%d %.2f\n", data[1+1].num, data[1+1].time) ; 
        var k : int ; k := 2 ; while k < 8 do ( (     sub[m+1] := data[k+1] )  ;     k := k + 1 ;     m := m + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    sub := sub->sort() ; 
    OclFile["System.out"].printf("%d %.2f\n", sub[0+1].num, sub[0+1].time) ; 
    OclFile["System.out"].printf("%d %.2f\n", sub[1+1].num, sub[1+1].time) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      int n=Integer.parseInt(reader.readLine());
      int result=0 ;
      result=n/25 ;
      n=n % 25 ;
      result+=n/10 ;
      n=n % 10 ;
      result+=n/5 ;
      n=n % 5 ;
      System.out.println(result+n);
      reader.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  static int gcd(int a,int b){
    return b>0 ? gcd(b,a % b): a ;
  }
  static int lcm(int a,int b){
    return a*b/gcd(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var n : int ; n := (reader.readLine())->toInteger() ;
     var result : int ; result := 0 ;
    result := n / 25 ; 
    n := n mod 25 ; 
    result := result+(n / 10) ; 
    n := n mod 10 ; 
    result := result+(n / 5) ; 
    n := n mod 5 ; 
    OclFile["System.out"].println(result + n) ; 
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b > 0 then gcd(b, a mod b) else a endif );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return a * b / gcd(a, b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int[] coins=new int[] {
    1,5,10,25 };
    public static void main(String[] args){
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int total=n/50*2 ;
      n %=50 ;
      int[][] dp=new int[4][50];
      System.out.println(dfw(dp,3,n)+total);
    }
    static int dfw(int[][] dp,int idx,int amount){
      if(amount==0){
        return 0 ;
      }
      if(idx<0){
        return Integer.MAX_VALUE/10 ;
      }
      if(dp[idx][amount]!=0){
        return dp[idx][amount];
      }
      int min=Integer.MAX_VALUE ;
      for(int i=0 ; i*coins[idx]<=amount ; i++){
        min=Math.min(min,dfw(dp,idx-1,amount-i*coins[idx])+i);
      }
      dp[idx][amount]=min ;
      return min ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute coins : Sequence(int) := Sequence{1,5,10,25};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var total : int ; total := n / 50 * 2 ;
    n := n mod 50 ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,4)->collect(Integer.subrange(1,50)->collect(0)) ;
    OclFile["System.out"].println(dfw(dp, 3, n) + total) ; 
 );
  static   operation dfw( dp : Sequence(Sequence(int)), idx : int, amount : int) : int
  pre: true
  post: true
  activity: (     if (amount = 0) then (     return 0 ) else skip ; 
     if (idx < 0) then (     return 2147483647 / 10 ) else skip ; 
    if (dp[idx+1][amount+1] /= 0) then (     return dp[idx+1][amount+1] ) else skip ; 
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i * coins[idx+1] <= amount do ( (     min := Set{min, dfw(dp, idx - 1, amount - i * coins[idx+1]) + i}->min() )  ;     i := i + 1 ) ; 
    dp[idx+1][amount+1] := min ; 
    return min 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
class Edge {
  int to ;
  int cost ;
  Edge(int to,int cost){
    this.to=to ;
    this.cost=cost ;
  }
}
class Pair implements Comparable<Pair>{
  int dist ;
  int index ;
  Pair(int dist,int index){
    this.dist=dist ;
    this.index=index ;
  }
  public int compareTo(Pair p2){
    return dist-p2.dist ;
  }
}
public class Main {
  static final int INF=2000000000 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int res=0 ;
    int[] coin={
      1,5,10,25 };
      for(int i=coin.length-1 ; i>=0 ; i--){
        res+=n/coin[i];
        n %=coin[i];
      }
      System.out.println(res);
      sc.close();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Edge {
   attribute to : int;
   attribute cost : int;
   static operation newEdge( to : int, cost : int) : Edge
  pre: true
  post: true
  activity:
  ( var self : Edge ;
    self := createEdge();
    self.initialise(to, cost);
    return self );
  operation initialise( to : int, cost : int) : void
  pre: true  post: true
  activity: (     self.to := to ; 
     self.cost := cost );
}
class Pair implements Comparable<Map> {
   attribute dist : int;
   attribute index : int;
   static operation newPair( dist : int, index : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(dist, index);
    return self );
  operation initialise( dist : int, index : int) : void
  pre: true  post: true
  activity: (     self.dist := dist ; 
     self.index := index );
   operation compareTo( p2 : Map) : int
  pre: true
  post: true
  activity: (     return dist - p2.dist );
}
class Main {
  static    attribute INF : int := 2000000000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
    var coin : Sequence(int) ; coin := Sequence{1,5,10,25} ;
        var i : int ; i := coin->size() - 1 ; while i >= 0 do ( (     res := res+(n / coin[i+1]) ; 
     n := n mod coin[i+1] )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(res) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(reader.readLine());
    reader.close();
    final int[] coins={
      25,10,5,1 };
      int ans=0 ;
      int remain=n ;
      for(int coin : coins){
        int tmp=remain/coin ;
        ans+=tmp ;
        remain-=coin*tmp ;
      }
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (reader.readLine())->toInteger() ;
    skip ; 
    var coins : Sequence(int) ; coins := Sequence{25,10,5,1} ;
    var ans : int ; ans := 0 ;
    var remain : int ; remain := n ;
    for (coin : coins) do ( (     var tmp : int ; tmp := remain / coin ;
     ans := ans+(tmp) ; 
     remain := remain-(coin * tmp) )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    int[] money={
      1,5,10,25 };
      int sum=0 ;
      for(int i=3 ; i>=0 ; i--){
        sum+=n/money[i];
        n-=n/money[i]*money[i];
      }
      System.out.println(sum);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var money : Sequence(int) ; money := Sequence{1,5,10,25} ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 3 ; while i >= 0 do ( (     sum := sum+(n / money[i+1]) ; 
     n := n-(n / money[i+1] * money[i+1]) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countSubSeq(int arr[],int n,int k){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] % k==0){
        count++;
      }
    }
    return(int)(Math.pow(2,count)-1);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,6 };
      int n=arr.length ;
      int k=3 ;
      System.out.println(countSubSeq(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSubSeq( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod k = 0) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     return (2->pow(count) - 1)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,6} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println(countSubSeq(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long l=sc.nextLong(),r=sc.nextLong();
      while((l |(l+1))<=r){
        l |=l+1 ;
      }
      System.out.println(l);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var l : long ; l := sc.getCurrent()->toLong() ;
    var r : long ; r := sc.getCurrent()->toLong() ;
     while ((MathLib.bitwiseOr(l,(l + 1))) <= r) do (     l := MathLib.bitwiseOr(l, l + 1) ) ; 
     OclFile["System.out"].println(l) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static MyReader scan=new MyReader();
  public static void main(String[] args){
    Main m=new Main();
    int q=scan.nextInt();
    while(q-->0)m.solve();
  }
  void solve(){
    long l=scan.nextLong();
    long r=scan.nextLong();
    while((l | l+1)<=r){
      l |=l+1 ;
    }
    System.out.println(l);
  }
}
class MyReader {
  private BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
  private StringTokenizer tokenizer=new StringTokenizer("");
  private String innerNextLine(){
    try {
      return reader.readLine();
    }
    catch(IOException ex){
      return null ;
    }
  }
  public boolean hasNext(){
    while(! tokenizer.hasMoreTokens()){
      String nextLine=innerNextLine();
      if(nextLine==null){
        return false ;
      }
      tokenizer=new StringTokenizer(nextLine);
    }
    return true ;
  }
  public String nextLine(){
    tokenizer=new StringTokenizer("");
    return innerNextLine();
  }
  public String next(){
    hasNext();
    return tokenizer.nextToken();
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public Long nextLong(){
    return Long.parseLong(next());
  }
  public double nextDouble(){
    return Double.parseDouble(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : MyReader := MyReader.newMyReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     var q : int ; q := scan.nextInt() ;
         while (q > 0) do (        q := q - 1 ;     skip ;     m.solve() ; ;  ) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var l : long ; l := scan.nextLong() ;
     var r : long ; r := scan.nextLong() ;
     while ((MathLib.bitwiseOr(l,l + 1)) <= r) do (     l := MathLib.bitwiseOr(l, l + 1) ) ; 
     OclFile["System.out"].println(l) );
}
class MyReader {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute tokenizer : OclIterator := OclIterator.newOclIterator_String("");
   operation innerNextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (ex : IOException) do (     return null )
 );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     var nextLine : String ; nextLine := innerNextLine() ;
     if (nextLine = null) then (     return false ) else skip ; 
     tokenizer := OclIterator.newOclIterator_String(nextLine) ) ; 
     return true );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     tokenizer := OclIterator.newOclIterator_String("") ; 
     return innerNextLine() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute hasNext() ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] input ;
    int m,f,r,sum ;
    char grade ;
    while(true){
      input=br.readLine().split(" ");
      m=Integer.parseInt(input[0]);
      f=Integer.parseInt(input[1]);
      r=Integer.parseInt(input[2]);
      sum=m+f ;
      if(m==-1 && f==-1 && r==-1){
        break ;
      }
      if(m==-1 || f==-1 || sum<30){
        grade='F' ;
      }
      else if(sum>=80){
        grade='A' ;
      }
      else if(sum>=65){
        grade='B' ;
      }
      else if(sum>=50 ||(sum>=30 && r>=50)){
        grade='C' ;
      }
      else {
        grade='D' ;
      }
      System.out.println(grade);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : Sequence(String) ;
    var m : int ;
    var f : int ;
    var r : int ;
    var sum : int ;
    var grade : String ;
    while (true) do (     input := br.readLine()->split(" ") ; 
     m := (input[0+1])->toInteger() ; 
    f := (input[1+1])->toInteger() ; 
    r := (input[2+1])->toInteger() ; 
    sum := m + f ; 
    if (m = -1 & f = -1 & r = -1) then (     break ) else skip ; 
    if (m = -1 or f = -1 or sum < 30) then (     grade := 'F' ) else     if (sum >= 80) then (     grade := 'A' ) else     if (sum >= 65) then (     grade := 'B' ) else     if (sum >= 50 or (sum >= 30 & r >= 50)) then (     grade := 'C' ) else (     grade := 'D' ) ;  ;  ;  ;  
    OclFile["System.out"].println(grade) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.stream.IntStream ;
public class Main {
  private static final int N=3 ;
  private static final Set<Character>MARCHS=Set.of('M','A','R','C','H');
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      Map<Character,Integer>map=new HashMap<>();
      IntStream.range(0,n).forEach(i->{
        String s=scanner.next();
        char c=s.charAt(0);
        if(MARCHS.contains(c)){
          map.put(c,map.getOrDefault(c,0)+1);
        }
      }
);
      int[] count=map.values().stream().mapToInt(Integer :: intValue).toArray();
      System.out.println(IntStream.range((1<<N)-1,(1<<count.length)).filter(i->N==Integer.bitCount(i)).mapToLong(i->IntStream.range(0,count.length).filter(j->0!=(i &(1<<j))).mapToLong(j->(long)count[j]).reduce(1L,(a,b)->a*b)).sum());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute N : int := 3;
  static    attribute MARCHS : Set(String) := Set.of('M', 'A', 'R', 'C', 'H');
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var map : Map(String,int) ; map := Map{} ;
    for i : Integer.subrange(0, n-1) do
    (    skip) ; 
    var count : Sequence(int) ; count := map->values()->collect( _x1 | (lambda _pars : OclAny in Integer.newInteger().intValue(_pars))->apply(_x1) )->asSequence() ;
    OclFile["System.out"].println(Integer.subrange(((1*(2->pow(N)))->oclAsType(long)) - 1, ((1*(2->pow(count->size())))->oclAsType(long))-1)->select( _x1 | (lambda i : OclAny in N = bitCount(i))->apply(_x1) )->collect( _x1 | (lambda i : OclAny in Integer.subrange(0, count->size()-1)->select( _x1 | (lambda j : OclAny in 0 /= (i & ((1*(2->pow(j)))->oclAsType(long))))->apply(_x1) )->collect( _x1 | (lambda j : OclAny in count[j+1]->oclAsType(long))->apply(_x1) )->iterate( _var; _acc : OclAny | 1L, lambda (a , b) : OclAny in a * b->apply((_acc,_var)) ))->apply(_x1) )->sum()) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maxSubArraySum(int arr[],int size){
    int max_so_far=arr[0];
    int curr_max=arr[0];
    for(int i=1 ; i<size ; i++){
      curr_max=Math.max(arr[i],curr_max+arr[i]);
      max_so_far=Math.max(max_so_far,curr_max);
    }
    return max_so_far ;
  }
  static int lenOfLongSubarrWithGivenSum(int arr[],int n,int k){
    HashMap<Integer,Integer>um=new HashMap<Integer,Integer>();
    int sum=0,maxLen=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=arr[i];
      if(sum==k)maxLen=i+1 ;
      if(um.containsKey(sum))um.put(sum,i);
      if(um.containsKey(sum-k)){
        if(maxLen<(i-um.get(sum-k)))maxLen=i-um.get(sum-k);
      }
    }
    return maxLen ;
  }
  static int lenLongSubarrWithMaxSum(int arr[],int n){
    int maxSum=maxSubArraySum(arr,n);
    return lenOfLongSubarrWithGivenSum(arr,n,maxSum);
  }
  public static void main(String args[]){
    int arr[]={
      5,-2,-1,3,-4 };
      int n=arr.length ;
      System.out.println("Length of longest subarray "+"having maximum sum="+lenLongSubarrWithMaxSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSubArraySum( arr : Sequence(int), size : int) : int
  pre: true
  post: true
  activity: (     var max_so_far : int ; max_so_far := arr[0+1] ;
     var curr_max : int ; curr_max := arr[0+1] ;
         var i : int ; i := 1 ; while i < size do ( (     curr_max := Set{arr[i+1], curr_max + arr[i+1]}->max() ; 
     max_so_far := Set{max_so_far, curr_max}->max() )  ;     i := i + 1 ) ; 
     return max_so_far );
  static   operation lenOfLongSubarrWithGivenSum( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var um : Map(int,int) ; um := Map{} ;
     var sum : int ; sum := 0 ;
    var maxLen : int ; maxLen := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(arr[i+1]) ; 
     if (sum = k) then     maxLen := i + 1 ; else skip ; 
     if (um->keys()->includes(sum)) then     um := um->union(Map{sum |-> i}) ; else skip ; 
     if (um->keys()->includes(sum - k)) then (     if (maxLen < (i - um->at(sum - k))) then     maxLen := i - um->at(sum - k) ; else skip ) else skip )  ;     i := i + 1 ) ; 
     return maxLen );
  static   operation lenLongSubarrWithMaxSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var maxSum : int ; maxSum := maxSubArraySum(arr, n) ;
     return lenOfLongSubarrWithGivenSum(arr, n, maxSum) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,-2,-1,3,-4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Length of longest subarray " + "having maximum sum=" + lenLongSubarrWithMaxSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isValidNesbitt(double a,double b,double c){
    double A=a/(b+c);
    double B=b/(a+c);
    double C=c/(a+b);
    double inequality=A+B+C ;
    return(inequality>=1.5);
  }
  public static void main(String args[]){
    double a=1.0,b=2.0,c=3.0 ;
    if(isValidNesbitt(a,b,c)==true){
      System.out.print("Nesbitt's inequality"+" satisfied.");
      System.out.println("for real numbers "+a+","+b+","+c);
    }
    else System.out.println("Nesbitts inequality"+" not satisfied");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isValidNesbitt( a : double, b : double, c : double) : boolean
  pre: true
  post: true
  activity: (     var A : double ; A := a / (b + c) ;
     var B : double ; B := b / (a + c) ;
    var C : double ; C := c / (a + b) ;
    var inequality : double ; inequality := A + B + C ;
    return (inequality >= 1.5) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 1.0 ;
    var b : double ; b := 2.0 ;
    var c : double ; c := 3.0 ;
     if (isValidNesbitt(a, b, c) = true) then (     OclFile["System.out"].print("Nesbitt's inequality" + " satisfied.") ; 
     OclFile["System.out"].println("for real numbers " + a + "," + b + "," + c) ) else     OclFile["System.out"].println("Nesbitts inequality" + " not satisfied") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void swap(int xp,int yp){
    if(xp==yp)return ;
    xp=xp+yp ;
    yp=xp-yp ;
    xp=xp-yp ;
  }
  public static void main(String[] args){
    int x=10 ;
    swap(x,x);
    System.out.println("After swap(&x,&x): x="+x);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation swap( xp : int, yp : int) : void
  pre: true
  post: true
  activity: (     if (xp = yp) then     return else skip ; 
     xp := xp + yp ; 
     yp := xp - yp ; 
     xp := xp - yp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 10 ;
     execute swap(x, x) ; 
     OclFile["System.out"].println("After swap(&x,&x): x=" + x) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void swap(int[] xp,int[] yp){
    xp[0]=xp[0] ^ yp[0];
    yp[0]=xp[0] ^ yp[0];
    xp[0]=xp[0] ^ yp[0];
  }
  public static void main(String[] args){
    int[] x={
      10 };
      swap(x,x);
      System.out.println("After swap(&x,&x): x="+x[0]);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation swap( xp : Sequence(int), yp : Sequence(int)) : void
  pre: true
  post: true
  activity: (     xp[0+1] := xp[0+1] xor yp[0+1] ; 
     yp[0+1] := xp[0+1] xor yp[0+1] ; 
     xp[0+1] := xp[0+1] xor yp[0+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : Sequence(int) ; x := Sequence{10} ;
     execute swap(x, x) ; 
     OclFile["System.out"].println("After swap(&x,&x): x=" + x[0+1]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxProduct(int[] arr,int n){
    if(n<3)return-1 ;
    int max_product=Integer.MIN_VALUE ;
    for(int i=0 ; i<n-2 ; i++)for(int j=i+1 ; j<n-1 ; j++)for(int k=j+1 ; k<n ; k++)max_product=Math.max(max_product,arr[i]*arr[j]*arr[k]);
    return max_product ;
  }
  public static void main(String[] args){
    int[] arr={
      10,3,5,6,20 };
      int n=arr.length ;
      ;
      int max=maxProduct(arr,n);
      if(max==-1)System.out.println("No Triplet Exists");
      else System.out.println("Maximum product is "+max);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxProduct( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n < 3) then     return -1 else skip ; 
     var max_product : int ; max_product := -2147483648 ;
         var i : int ; i := 0 ; while i < n - 2 do (         var j : int ; j := i + 1 ; while j < n - 1 do (         var k : int ; k := j + 1 ; while k < n do (     max_product := Set{max_product, arr[i+1] * arr[j+1] * arr[k+1]}->max() ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return max_product );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,3,5,6,20} ;
     var n : int ; n := arr->size() ;
    var max : int ; max := maxProduct(arr, n) ;
    if (max = -1) then     OclFile["System.out"].println("No Triplet Exists") else     OclFile["System.out"].println("Maximum product is " + max) ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedOutputStream ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.util.StringTokenizer ;
public class suitandtie {
  static int N ;
  static int nextInt(StringTokenizer s){
    return Integer.parseInt(s.nextToken());
  }
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(in.readLine());
    OutputStream out=new BufferedOutputStream(System.out);
    N=nextInt(st)*2 ;
    st=new StringTokenizer(in.readLine());
    int[] arr=new int[N];
    for(int i=0 ; i<N ; i++){
      arr[i]=nextInt(st);
    }
    int temp ;
    int ans=0 ;
    for(int i=0 ; i<N ; i++){
      for(int j=i+1 ; j<N ; j++){
        if(arr[i]==arr[j]){
          while(j>i+1){
            temp=arr[j];
            arr[j]=arr[j-1];
            arr[j-1]=temp ;
            j--;
            ans++;
          }
          i++;
          break ;
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class suitandtie {
  static   attribute N : int;
  static   operation nextInt( s : OclIterator) : int
  pre: true
  post: true
  activity: (     return (s.next())->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(in.readLine()) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    N := nextInt(st) * 2 ; 
    st := OclIterator.newOclIterator_String(in.readLine()) ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := nextInt(st) )  ;     i := i + 1 ) ; 
    var temp : int ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := i + 1 ; while j < N do ( (     if (arr[i+1] = arr[j+1]) then (     while (j > i + 1) do (     temp := arr[j+1] ; 
     arr[j+1] := arr[j - 1+1] ; 
    arr[j - 1+1] := temp ; 
    j := j - 1 ; 
    ans := ans + 1 ; 
 ) ; 
     i := i + 1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
public class SuitAndTie {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    int[] nums=new int[n*2];
    String[] temp=br.readLine().split(" ");
    for(int i=0 ; i<n*2 ; i++){
      nums[i]=Integer.parseInt(temp[i]);
    }
    int start=-1 ;
    int res=0 ;
    for(int i=0 ; i<n*2 ; i+=2){
      if(nums[i]==nums[i+1]){
        nums[i]=-1 ;
        nums[i+1]=-1 ;
      }
      else {
        start=i ;
        break ;
      }
    }
    if(start==-1){
      pr.println(0);
      return ;
    }
    for(int i=start ; i<n*2 ; i+=2){
      if(nums[i]==nums[i+1]){
        continue ;
      }
      for(int j=i+2 ; j<n*2 ; j++){
        if(nums[j]==nums[i]){
          res+=j-(i+1);
          swap(nums,i+1,j);
        }
      }
    }
    pr.println(res);
  }
  public static void swap(int[] nums,int i,int j){
    while(j!=i){
      nums[j] ^=nums[j-1];
      nums[j-1] ^=nums[j];
      nums[j] ^=nums[j-1];
      j--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SuitAndTie {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var nums : Sequence(int) ; nums := Integer.subrange(1,n * 2)->collect(0) ;
    var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < n * 2 do ( (     nums[i+1] := (temp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var start : int ; start := -1 ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n * 2 do ( (     if (nums[i+1] = nums[i + 1+1]) then (     nums[i+1] := -1 ; 
     nums[i + 1+1] := -1 ) else (     start := i ; 
     break ) )  ;     i := i+(2) ) ; 
    if (start = -1) then (     skip ; 
     return ) else skip ; 
        var i : int ; i := start ; while i < n * 2 do ( (     if (nums[i+1] = nums[i + 1+1]) then (     continue ) else skip ; 
         var j : int ; j := i + 2 ; while j < n * 2 do ( (     if (nums[j+1] = nums[i+1]) then (     res := res+(j - (i + 1)) ; 
     execute swap(nums, i + 1, j) ) else skip )  ;     j := j + 1 ) )  ;     i := i+(2) ) ; 
    skip ; 
 );
  static   operation swap( nums : Sequence(int), i : int, j : int) : void
  pre: true
  post: true
  activity: (     while (j /= i) do (     nums[j+1] := MathLib.bitwiseXor(nums[j+1],nums[j - 1+1]) ; 
     nums[j - 1+1] := MathLib.bitwiseXor(nums[j - 1+1],nums[j+1]) ; 
     nums[j+1] := MathLib.bitwiseXor(nums[j+1],nums[j - 1+1]) ; 
     j := j - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class pair {
    double first,second ;
    public pair(double first,double second){
      this.first=first ;
      this.second=second ;
    }
  }
  static pair mirrorImage(double a,double b,double c,double x1,double y1){
    double temp=-2*(a*x1+b*y1+c)/(a*a+b*b);
    double x=temp*a+x1 ;
    double y=temp*b+y1 ;
    return new pair(x,y);
  }
  public static void main(String[] args){
    double a=-1.0 ;
    double b=1.0 ;
    double c=0.0 ;
    double x1=1.0 ;
    double y1=0.0 ;
    pair image=mirrorImage(a,b,c,x1,y1);
    System.out.print("Image of point("+x1+","+y1+")");
    System.out.print("by mirror("+a+")x+("+b+")y+("+c+")=0,is :");
    System.out.println("("+image.first+","+image.second+")");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class pair {
   attribute first : double;
   static operation newpair( first : double, second : double) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : double, second : double) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation mirrorImage( a : double, b : double, c : double, x1 : double, y1 : double) : pair
  pre: true
  post: true
  activity: (     var temp : double ; temp := -2 * (a * x1 + b * y1 + c) / (a * a + b * b) ;
     var x : double ; x := temp * a + x1 ;
     var y : double ; y := temp * b + y1 ;
     return pair.newpair(x, y) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := -1.0 ;
     var b : double ; b := 1.0 ;
    var c : double ; c := 0.0 ;
    var x1 : double ; x1 := 1.0 ;
    var y1 : double ; y1 := 0.0 ;
    var image : pair ; image := mirrorImage(a, b, c, x1, y1) ;
    OclFile["System.out"].print("Image of point(" + x1 + "," + y1 + ")") ; 
    OclFile["System.out"].print("by mirror(" + a + ")x+(" + b + ")y+(" + c + ")=0,is :") ; 
    OclFile["System.out"].println("(" + image->at("first") + "," + image->at("second") + ")") ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int solve(int freq[]){
    int n=0 ;
    int max_freq=0 ;
    int first=0 ;
    int flag=0 ;
    for(int i=0 ; i<26 ; i++){
      n+=freq[i];
      if(freq[i]!=0 && flag==0){
        first=freq[i];
        flag=1 ;
      }
      if(max_freq<freq[i]){
        max_freq=freq[i];
      }
    }
    if(n==0){
      return 0 ;
    }
    if(first!=max_freq){
      flag=1 ;
    }
    else {
      flag=0 ;
    }
    return Math.min((n-1)/2,n-max_freq-flag);
  }
  static void solve(String s){
    int freq[]=new int[26];
    for(int i=0 ; i<s.length(); i++){
      freq[s.charAt(i)-'a']++;
    }
    System.out.println(solve(freq));
  }
  public static void main(String[] args){
    String s="geeks" ;
    solve(s);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( freq : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := 0 ;
     var max_freq : int ; max_freq := 0 ;
    var first : int ; first := 0 ;
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < 26 do ( (     n := n+(freq[i+1]) ; 
     if (freq[i+1] /= 0 & flag = 0) then (     first := freq[i+1] ; 
     flag := 1 ) else skip ; 
     if (max_freq < freq[i+1]) then (     max_freq := freq[i+1] ) else skip )  ;     i := i + 1 ) ; 
    if (n = 0) then (     return 0 ) else skip ; 
    if (first /= max_freq) then (     flag := 1 ) else (     flag := 0 ) ;  
    return Set{(n - 1) / 2, n - max_freq - flag}->min() 
 );
  static   operation solve( s : String) : void
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
         var i : int ; i := 0 ; while i < s->size() do ( (     freq[s->at(i+1) - ('a')->char2byte()+1] := freq[s->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(solve(freq)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeks" ;
     execute solve(s) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      double sa=slove(n,scanner);
      int m=scanner.nextInt();
      double sb=slove(m,scanner);
      if(Math.abs(sa-sb)<1e-7){
        System.out.println(0);
      }
      else if(sa>sb){
        System.out.println(1);
      }
      else {
        System.out.println(2);
      }
    }
  }
  public static double slove(int n,Scanner scanner){
    double sa=0 ;
    int s=360 ;
    while(n-->1){
      int t=scanner.nextInt();
      s-=t ;
      sa+=Math.sin(Math.toRadians(t));
    }
    sa+=Math.sin(Math.toRadians(s));
    return sa ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var sa : double ; sa := slove(n, scanner) ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var sb : double ; sb := slove(m, scanner) ;
    if (if sa - sb < 0 then -(sa - sb) else sa - sb endif < 1e-7) then (     OclFile["System.out"].println(0) ) else     if (sa > sb) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(2) ) ;  ;  
 ) );
  static   operation slove( n : int, scanner : OclFile) : double
  pre: true
  post: true
  activity: (     var sa : double ; sa := 0 ;
     var s : int ; s := 360 ;
        while (n > 1) do (        n := n - 1 ;     skip ; (     var t : int ; t := scanner.getCurrent()->toInteger() ;
     s := s-(t) ; 
     sa := sa+(((0.017453292519943295*(t)))->sin()) ) ;  ) ;  
    sa := sa+(((0.017453292519943295*(s)))->sin()) ; 
    return sa 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  double calc(int deg){
    double rad=Math.toRadians(deg);
    return Math.sin(rad);
  }
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      int deg[]=new int[n+1];
      deg[0]=0 ;
      deg[n]=360 ;
      for(int i=1 ; i<n ; i++){
        deg[i]=sc.nextInt();
      }
      double area=0 ;
      int degsum=360 ;
      for(int i=0 ; i<n ; i++){
        area+=calc(deg[i]);
        degsum-=deg[i];
      }
      area+=calc(degsum);
      n=sc.nextInt();
      deg=new int[n+1];
      deg[0]=0 ;
      deg[n]=360 ;
      for(int i=1 ; i<n ; i++){
        deg[i]=sc.nextInt();
      }
      double area2=0 ;
      degsum=360 ;
      for(int i=0 ; i<n ; i++){
        area2+=calc(deg[i]);
        degsum-=deg[i];
      }
      area2+=calc(degsum);
      if(Math.abs(area-area2)<1e-8){
        System.out.println(0);
      }
      else if(area>area2){
        System.out.println(1);
      }
      else {
        System.out.println(2);
      }
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation calc( deg : int) : double
  pre: true
  post: true
  activity: (     var rad : double ; rad := (0.017453292519943295*(deg)) ;
     return (rad)->sin() );
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var deg : Sequence(int) ; deg := Integer.subrange(1,n + 1)->collect(0) ;
    deg[0+1] := 0 ; 
    deg[n+1] := 360 ; 
        var i : int ; i := 1 ; while i < n do ( (     deg[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var area : double ; area := 0 ;
    var degsum : int ; degsum := 360 ;
        var i : int ; i := 0 ; while i < n do ( (     area := area+(calc(deg[i+1])) ; 
     degsum := degsum-(deg[i+1]) )  ;     i := i + 1 ) ; 
    area := area+(calc(degsum)) ; 
    n := sc.getCurrent()->toInteger() ; 
    deg := Integer.subrange(1,n + 1)->collect(0) ; 
    deg[0+1] := 0 ; 
    deg[n+1] := 360 ; 
        var i : int ; i := 1 ; while i < n do ( (     deg[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var area2 : double ; area2 := 0 ;
    degsum := 360 ; 
        var i : int ; i := 0 ; while i < n do ( (     area2 := area2+(calc(deg[i+1])) ; 
     degsum := degsum-(deg[i+1]) )  ;     i := i + 1 ) ; 
    area2 := area2+(calc(degsum)) ; 
    if (if area - area2 < 0 then -(area - area2) else area - area2 endif < 1e-8) then (     OclFile["System.out"].println(0) ) else     if (area > area2) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(2) ) ;  ;  
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  class data implements Comparable<data>{
    int no ;
    double time ;
    data(int no,double time){
      this.no=no ;
      this.time=time ;
    }
    public int compareTo(data o){
      return(this.time-o.time)>0 ? 1 :-1 ;
    }
    public String toString(){
      return no+" "+time ;
    }
  }
  void run(){
    data[][] in=new data[3][8];
    for(int i=0 ; i<24 ; i++){
      in[i/8][i % 8]=new data(sc.nextInt(),sc.nextDouble());
    }
    for(int i=0 ; i<3 ; i++){
      Arrays.sort(in[i]);
    }
    for(int i=0 ; i<3 ; i++){
      System.out.println(in[i][0]);
      System.out.println(in[i][1]);
    }
    data[] cand=new data[6];
    int z=0 ;
    for(int i=0 ; i<3 ; i++){
      for(int j=2 ; j<=3 ; j++){
        cand[z++]=in[i][j];
      }
    }
    Arrays.sort(cand);
    System.out.println(cand[0]);
    System.out.println(cand[1]);
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
 class data implements Comparable<data> {
   attribute no : int;
   attribute time : double;
   static operation newdata( no : int, time : double) : data
  pre: true
  post: true
  activity:
  ( var self : data ;
    self := createdata();
    self.initialise(no, time);
    return self );
  operation initialise( no : int, time : double) : void
  pre: true  post: true
  activity: (     self.no := no ; 
     self.time := time );
   operation compareTo( o : data) : int
  pre: true
  post: true
  activity: (     return if (self.time - o.time) > 0 then 1 else -1 endif );
   operation toString() : String
  pre: true
  post: true
  activity: (     return no + " " + time );
}
   operation run() : void
  pre: true
  post: true
  activity: (     var in : Sequence(Sequence(data)) ; in := Integer.subrange(1,3)->collect(Integer.subrange(1,8)->collect(null)) ;
         var i : int ; i := 0 ; while i < 24 do ( (     in[i / 8+1][i mod 8+1] := data.newdata(sc.getCurrent()->toInteger(), sc.getCurrent()->toReal()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do ( (     in[i+1] := in[i+1]->sort() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do ( (     OclFile["System.out"].println(in[i+1][0+1]) ; 
     OclFile["System.out"].println(in[i+1][1+1]) )  ;     i := i + 1 ) ; 
    var cand : Sequence(data) ; cand := Integer.subrange(1,6)->collect(null) ;
    var z : int ; z := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 2 ; while j <= 3 do ( (      cand[z+1] := in[i+1][j+1]  ; z := z + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    cand := cand->sort() ; 
    OclFile["System.out"].println(cand[0+1]) ; 
    OclFile["System.out"].println(cand[1+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.Map ;
import java.text.DecimalFormat ;
import java.lang.Math ;
import java.util.Iterator ;
public class b90 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x1=sc.nextInt();
    int y1=sc.nextInt();
    int r1=sc.nextInt();
    int x2=sc.nextInt();
    int y2=sc.nextInt();
    int r2=sc.nextInt();
    double d=Math.sqrt(Math.pow(x1-x2,2)+Math.pow(y1-y2,2));
    if(Math.pow(x1,2)+Math.pow(y1,2)==Math.pow(r1,2)&& Math.pow(x2,2)+Math.pow(y2,2)==Math.pow(r2,2)){
      System.out.println(0);
    }
    else if(d<=(double)(r1+r2)&& 2*d>=(double)(r1+r2)){
      System.out.println(0);
    }
    else if(d<(double)Math.max(r1,r2)){
      System.out.println(((double)Math.max(r1,r2)-(d+(double)Math.min(r1,r2)))/2);
    }
    else {
      System.out.println((d-(double)(r1+r2))/2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class b90 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : int ; x1 := sc.getCurrent()->toInteger() ;
    var y1 : int ; y1 := sc.getCurrent()->toInteger() ;
    var r1 : int ; r1 := sc.getCurrent()->toInteger() ;
    var x2 : int ; x2 := sc.getCurrent()->toInteger() ;
    var y2 : int ; y2 := sc.getCurrent()->toInteger() ;
    var r2 : int ; r2 := sc.getCurrent()->toInteger() ;
    var d : double ; d := (x1 - x2->pow(2) + y1 - y2->pow(2))->sqrt() ;
    if (x1->pow(2) + y1->pow(2) = r1->pow(2) & x2->pow(2) + y2->pow(2) = r2->pow(2)) then (     OclFile["System.out"].println(0) ) else     if (d <= (r1 + r2)->oclAsType(double) & 2 * d >= (r1 + r2)->oclAsType(double)) then (     OclFile["System.out"].println(0) ) else     if (d < Set{r1, r2}->max()->oclAsType(double)) then (     OclFile["System.out"].println((Set{r1, r2}->max()->oclAsType(double) - (d + Set{r1, r2}->min()->oclAsType(double))) / 2) ) else (     OclFile["System.out"].println((d - (r1 + r2)->oclAsType(double)) / 2) ) ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.HashSet ;
import java.util.InputMismatchException ;
import java.util.NoSuchElementException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    while(true){
      int m=scanner.nextInt();
      int f=scanner.nextInt();
      int r=scanner.nextInt();
      if(m==-1 && f==-1 && r==-1){
        scanner.close();
        return ;
      }
      if(m==-1 || f==-1){
        System.out.println("F");
      }
      else if(m+f>=80){
        System.out.println("A");
      }
      else if(m+f>=65 && m+f<80){
        System.out.println("B");
      }
      else if(m+f>=50 && m+f<65){
        System.out.println("C");
      }
      else if(m+f>=30 && m+f<50){
        if(r>=50){
          System.out.println("C");
        }
        else {
          System.out.println("D");
        }
      }
      else {
        System.out.println("F");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var m : int ; m := scanner.getCurrent()->toInteger() ;
     var f : int ; f := scanner.getCurrent()->toInteger() ;
    var r : int ; r := scanner.getCurrent()->toInteger() ;
    if (m = -1 & f = -1 & r = -1) then (     skip ; 
     return ) else skip ; 
    if (m = -1 or f = -1) then (     OclFile["System.out"].println("F") ) else     if (m + f >= 80) then (     OclFile["System.out"].println("A") ) else     if (m + f >= 65 & m + f < 80) then (     OclFile["System.out"].println("B") ) else     if (m + f >= 50 & m + f < 65) then (     OclFile["System.out"].println("C") ) else     if (m + f >= 30 & m + f < 50) then (     if (r >= 50) then (     OclFile["System.out"].println("C") ) else (     OclFile["System.out"].println("D") ) ) else (     OclFile["System.out"].println("F") ) ;  ;  ;  ;  ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      int A=sc.nextInt();
      if(A==0)break ;
      double a=0 ;
      int remain=360 ;
      for(int i=0 ; i<A-1 ; i++){
        int x=sc.nextInt();
        a+=Math.sin(Math.PI*x/180);
        remain-=x ;
      }
      a+=Math.sin(Math.PI*remain/180);
      int B=sc.nextInt();
      remain=360 ;
      for(int i=0 ; i<B-1 ; i++){
        int x=sc.nextInt();
        a-=Math.sin(Math.PI*x/180);
        remain-=x ;
      }
      a-=Math.sin(Math.PI*remain/180);
      final double EPS=1e-10 ;
      int ans=a>EPS ? 1 : a<-EPS ? 2 : 0 ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var A : int ; A := sc.getCurrent()->toInteger() ;
     if (A = 0) then     break else skip ; 
    var a : double ; a := 0 ;
    var remain : int ; remain := 360 ;
        var i : int ; i := 0 ; while i < A - 1 do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     a := a+((3.141592653589793 * x / 180)->sin()) ; 
     remain := remain-(x) )  ;     i := i + 1 ) ; 
    a := a+((3.141592653589793 * remain / 180)->sin()) ; 
    var B : int ; B := sc.getCurrent()->toInteger() ;
    remain := 360 ; 
        var i : int ; i := 0 ; while i < B - 1 do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     a := a-((3.141592653589793 * x / 180)->sin()) ; 
     remain := remain-(x) )  ;     i := i + 1 ) ; 
    a := a-((3.141592653589793 * remain / 180)->sin()) ; 
    var EPS : double ; EPS := 1e-10 ;
    var ans : int ; ans := if a > EPS then 1 else if a < -EPS then 2 else 0 endif endif ;
    OclFile["System.out"].println(ans) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.BigDecimal ;
import java.awt.geom.*;
import static java.util.Arrays.*;
class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    while(true){
      int m=Integer.parseInt(stdIn.next());
      if(m==0){
        break ;
      }
      int[] vm=new int[m];
      int vmcount=0 ;
      for(int i=0 ; i<m-1 ; i++){
        vm[i]=Integer.parseInt(stdIn.next());
        vmcount+=vm[i];
      }
      vm[m-1]=360-vmcount ;
      int n=Integer.parseInt(stdIn.next());
      int[] vn=new int[n];
      int vncount=0 ;
      for(int i=0 ; i<n-1 ; i++){
        vn[i]=Integer.parseInt(stdIn.next());
        vncount+=vn[i];
      }
      vn[n-1]=360-vncount ;
      double marea=0 ;
      double narea=0 ;
      for(int i=0 ; i<m ; i++){
        marea+=Math.sin(Math.toRadians(vm[i]));
      }
      for(int i=0 ; i<n ; i++){
        narea+=Math.sin(Math.toRadians(vn[i]));
      }
      if(Math.abs(marea-narea)<Math.pow(10,-8)){
        out.println(0);
      }
      else if(marea<narea){
        out.println(2);
      }
      else {
        out.println(1);
      }
      out.flush();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     while (true) do (     var m : int ; m := (stdIn.getCurrent())->toInteger() ;
     if (m = 0) then (     break ) else skip ; 
    var vm : Sequence(int) ; vm := Integer.subrange(1,m)->collect(0) ;
    var vmcount : int ; vmcount := 0 ;
        var i : int ; i := 0 ; while i < m - 1 do ( (     vm[i+1] := (stdIn.getCurrent())->toInteger() ; 
     vmcount := vmcount+(vm[i+1]) )  ;     i := i + 1 ) ; 
    vm[m - 1+1] := 360 - vmcount ; 
    var n : int ; n := (stdIn.getCurrent())->toInteger() ;
    var vn : Sequence(int) ; vn := Integer.subrange(1,n)->collect(0) ;
    var vncount : int ; vncount := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     vn[i+1] := (stdIn.getCurrent())->toInteger() ; 
     vncount := vncount+(vn[i+1]) )  ;     i := i + 1 ) ; 
    vn[n - 1+1] := 360 - vncount ; 
    var marea : double ; marea := 0 ;
    var narea : double ; narea := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     marea := marea+(((0.017453292519943295*(vm[i+1])))->sin()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     narea := narea+(((0.017453292519943295*(vn[i+1])))->sin()) )  ;     i := i + 1 ) ; 
    if (if marea - narea < 0 then -(marea - narea) else marea - narea endif < 10->pow(-8)) then (     skip ) else     if (marea < narea) then (     skip ) else (     skip ) ;  ;  
    skip ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    for(; ; ){
      double[] area=new double[2];
      for(int j=0 ; j<2 ; j++){
        int m=sc.nextInt();
        if(m==0){
          return ;
        }
        int sum=0 ;
        for(int i=0 ; i<m-1 ; i++){
          int deg=sc.nextInt();
          area[j]+=Math.sin(Math.toRadians(deg))/2 ;
          sum+=deg ;
        }
        area[j]+=Math.sin(Math.toRadians(360-sum))/2 ;
      }
      if(area[0]>area[1]+EPS){
        println("1");
      }
      else if(area[0]+EPS<area[1]){
        println("2");
      }
      else {
        println("0");
      }
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var area : Sequence(double) ; area := Integer.subrange(1,2)->collect(0.0) ;
         var j : int ; j := 0 ; while j < 2 do ( (     var m : int ; m := sc.getCurrent()->toInteger() ;
     if (m = 0) then (     return ) else skip ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < m - 1 do ( (     var deg : int ; deg := sc.getCurrent()->toInteger() ;
     area[j+1] := area[j+1]+(((0.017453292519943295*(deg)))->sin() / 2) ; 
     sum := sum+(deg) )  ;     i := i + 1 ) ; 
    area[j+1] := area[j+1]+(((0.017453292519943295*(360 - sum)))->sin() / 2) ; 
 )  ;     j := j + 1 ) ; 
     if (area[0+1] > area[1+1] + EPS) then (     execute println("1") ) else     if (area[0+1] + EPS < area[1+1]) then (     execute println("2") ) else (     execute println("0") ) ;  )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class GFG {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int k=sc.nextInt();
      if(n==1 && k==0){
        System.out.println("1");
        continue ;
      }
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=i+1 ;
      if(Math.max(k,(int)Math.ceil((double)n/2))==k){
        System.out.println("-1");
        continue ;
      }
      int start=1,end=n-1 ;
      int[] dp=new int[n];
      Arrays.fill(dp,-1);
      while(k-->0){
        dp[start]=arr[end];
        start+=2 ;
        end--;
      }
      end=0 ;
      for(int i=0 ; i<n ; i++){
        if(dp[i]==-1){
          dp[i]=arr[end];
          end++;
        }
      }
      for(int i=0 ; i<n ; i++)System.out.print(dp[i]+" ");
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    if (n = 1 & k = 0) then (     OclFile["System.out"].println("1") ; 
     continue ) else skip ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := i + 1 ;  ;     i := i + 1 ) ; 
    if (Set{k, (n->oclAsType(double) / 2)->ceil()->oclAsType(int)}->max() = k) then (     OclFile["System.out"].println("-1") ; 
     continue ) else skip ; 
    var start : int ; start := 1 ;
    var end : int ; end := n - 1 ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
    dp := dp->collect(-1) ; 
        while (k > 0) do (        k := k - 1 ;     skip ; (     dp[start+1] := arr[end+1] ; 
     start := start+(2) ; 
     end := end - 1 ) ;  ) ;  
    end := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     if (dp[i+1] = -1) then (     dp[i+1] := arr[end+1] ; 
     end := end + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(dp[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    StringBuffer out=new StringBuffer();
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=in.nextInt();
    OUTER : while(t--!=0){
      int n=in.nextInt();
      int k=in.nextInt();
      if(k>(n-1)/2){
        out.append("-1");
      }
      else {
        int arr[]=new int[n];
        for(int i=0 ; i<n ; i++)arr[i]=i+1 ;
        for(int i=1,j=0 ; i<n && j<k ; i+=2,j+=1){
          int temp=arr[i];
          arr[i]=arr[i+1];
          arr[i+1]=temp ;
        }
        for(int item : arr)out.append(item+" ");
      }
      out.append("\n");
    }
    System.out.print(out);
  }
  private static int length(int n){
    return new StringBuffer().append(n).toString().length();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : String ; out := StringLib.newString() ;
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        while (t /= 0) do (    skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
     if (k > (n - 1) / 2) then (     out := out + StringLib.newString("-1") ) else (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     arr[i+1] := i + 1 ;  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ;
    var j : int ; j := 0 ; while i < n & j < k do ( (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := arr[i + 1+1] ; 
     arr[i + 1+1] := temp )  ;     i := i+(2) ;     j := j+(1) ) ; 
     for (item : arr) do (     out := out + StringLib.newString(item + " ") ;  ) ) ;  
     out := out + StringLib.newString("\n") ) ;  ) ;  
    OclFile["System.out"].print(out) ; 
 );
  static   operation length( n : int) : int
  pre: true
  post: true
  activity: (     return StringLib.newString() + StringLib.newString(n)+""->size() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class ArrayPeaks {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int k=sc.nextInt();
      if((2*k)<n){
        int num=n ;
        int a[]=new int[n+1];
        Arrays.fill(a,0);
        for(int i=2 ; i<n ; i+=2){
          if(k==0){
            break ;
          }
          else {
            a[i]=num ;
            k--;
            num--;
          }
        }
        int cur=1 ;
        for(int i=1 ; i<=n ; i++){
          if(a[i]==0){
            a[i]=cur++;
          }
        }
        for(int i=1 ; i<=n ; i++){
          System.out.print(a[i]+" ");
        }
        System.out.println();
      }
      else {
        System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ArrayPeaks {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     if ((2 * k) < n) then (     var num : int ; num := n ;
     var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    a := a->collect(0) ; 
        var i : int ; i := 2 ; while i < n do ( (     if (k = 0) then (     break ) else (     a[i+1] := num ; 
     k := k - 1 ; 
     num := num - 1 ) )  ;     i := i+(2) ) ; 
    var cur : int ; cur := 1 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (a[i+1] = 0) then (      a[i+1] := cur  ; cur := cur + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].print(a[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) else (     OclFile["System.out"].println(-1) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  StringBuilder s1=new StringBuilder();
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int t=1 ;
    t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int k=sc.nextInt();
      int max=(n-1)/2 ;
      if(max<k){
        pw.println(-1);
      }
      else {
        int ans[]=new int[n];
        int nums=n ;
        int j=0 ;
        for(int i=1 ; j<k ; i+=2,j++){
          ans[i]=nums--;
        }
        for(int i=n-1 ; i>=0 ; i--){
          if(ans[i]==0){
            ans[i]=nums--;
          }
        }
        for(int x : ans)pw.print(x+" ");
        pw.println();
      }
    }
    pw.flush();
  }
  static class Scanner {
    BufferedReader br ;
    StringTokenizer st ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(FileReader f){
      br=new BufferedReader(f);
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public int[] nextIntArr(int n)throws IOException {
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=Integer.parseInt(next());
      }
      return arr ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute s1 : String := StringLib.newString();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := 1 ;
    t := sc.getCurrent()->toInteger() ; 
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     var max : int ; max := (n - 1) / 2 ;
     if (max < k) then (     skip ) else (     var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
     var nums : int ; nums := n ;
    var j : int ; j := 0 ;
        var i : int ; i := 1 ; while j < k do ( (      ans[i+1] := nums  ; nums := nums - 1 )  ;     i := i+(2) ;     j := j + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (ans[i+1] = 0) then (      ans[i+1] := nums  ; nums := nums - 1 ) else skip )  ;     i := i - 1 ) ; 
    for (x : ans) do (     skip ;  ) ; 
    skip ; 
 ) ) ;  ) ;  
    skip ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( f : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(f) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArr( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (next())->toInteger() )  ;     i := i + 1 ) ; 
     return arr );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static class Node {
    int data ;
    Node left,right ;
    Node(int data){
      this.data=data ;
      left=null ;
      right=null ;
    }
  }
  static void updateParent(int parent[],Node node){
    if(node==null)return ;
    if(node.left!=null)parent[node.left.data]=node.data ;
    if(node.right!=null)parent[node.right.data]=node.data ;
    updateParent(parent,node.left);
    updateParent(parent,node.right);
  }
  static int getMaxXor(Node root,int n,int val,int x){
    int parent[]=new int[n+1];
    updateParent(parent,root);
    int max=x ^ val ;
    val=parent[val];
    while(val!=0){
      max=Math.max(max,x ^ val);
      val=parent[val];
    }
    return max ;
  }
  public static void main(String[] args){
    int n=6 ;
    Node root=new Node(1);
    root.left=new Node(2);
    root.right=new Node(3);
    root.left.left=new Node(4);
    root.right.right=new Node(5);
    root.right.right.left=new Node(6);
    int val=6,x=4 ;
    System.out.println(getMaxXor(root,n,val,x));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute left : Node;
   static operation newNode( data : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(data);
    return self );
  operation initialise( data : int) : void
  pre: true  post: true
  activity: (     self.data := data ; 
     left := null ; 
     right := null );
}
  static   operation updateParent( parent : Sequence(int), node : Node) : void
  pre: true
  post: true
  activity: (     if (node = null) then     return else skip ; 
     if (node.left /= null) then     parent[node.left.data+1] := node.data ; else skip ; 
    if (node.right /= null) then     parent[node.right.data+1] := node.data ; else skip ; 
    execute updateParent(parent, node.left) ; 
    execute updateParent(parent, node.right) ; 
 );
  static   operation getMaxXor( root : Node, n : int, val : int, x : int) : int
  pre: true
  post: true
  activity: (     var parent : Sequence(int) ; parent := Integer.subrange(1,n + 1)->collect(0) ;
     execute updateParent(parent, root) ; 
    var max : int ; max := MathLib.bitwiseXor(x,val) ;
    val := parent[val+1] ; 
    while (val /= 0) do (     max := Set{max, x xor val}->max() ; 
     val := parent[val+1] ) ; 
    return max 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     var root : Node ; root := Node.newNode(1) ;
    root.left := Node.newNode(2) ; 
    root.right := Node.newNode(3) ; 
    root.left.left := Node.newNode(4) ; 
    root.right.right := Node.newNode(5) ; 
    root.right.right.left := Node.newNode(6) ; 
    var val : int ; val := 6 ;
    var x : int ; x := 4 ;
    OclFile["System.out"].println(getMaxXor(root, n, val, x)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Arrays ;
import java.util.Scanner ;
import javax.swing.plaf.basic.BasicComboBoxUI.ComboBoxLayoutManager ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      P ps[][]=new P[3][8];
      for(int k=0 ; k<3 ; k++)for(int i=0 ; i<8 ; i++){
        P p=new P();
        p.id=sc.nextInt();
        p.score=sc.nextDouble();
        ps[k][i]=p ;
      }
      P[] rs=new P[6*3];
      int rss=0 ;
      for(int k=0 ; k<3 ; k++){
        Arrays.sort(ps[k]);
        for(int i=0 ; i<2 ; i++){
          System.out.printf("%d %.2f\n",ps[k][i] .id,ps[k][i] .score);
        }
        for(int i=2 ; i<8 ; i++){
          rs[rss++]=ps[k][i];
        }
      }
      Arrays.sort(rs);
      for(int i=0 ; i<2 ; i++){
        System.out.printf("%d %.2f\n",rs[i] .id,rs[i] .score);
      }
    }
  }
  class P implements Comparable<P>{
    int id ;
    double score ;
    @ Override public int compareTo(P o){
      return Double.compare(score,o.score);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var ps : Sequence(Sequence(P)) ; ps := Integer.subrange(1,3)->collect(Integer.subrange(1,8)->collect(null)) ;
         var k : int ; k := 0 ; while k < 3 do (         var i : int ; i := 0 ; while i < 8 do ( (     var p : P ; p := P.newP() ;
     p.id := sc.getCurrent()->toInteger() ; 
     p.score := sc.getCurrent()->toReal() ; 
     ps[k+1][i+1] := p )  ;     i := i + 1 ) ;  ;     k := k + 1 ) ; 
    var rs : Sequence(P) ; rs := Integer.subrange(1,6 * 3)->collect(null) ;
    var rss : int ; rss := 0 ;
        var k : int ; k := 0 ; while k < 3 do ( (     ps[k+1] := ps[k+1]->sort() ; 
         var i : int ; i := 0 ; while i < 2 do ( (     OclFile["System.out"].printf("%d %.2f\n", ps[k+1][i+1].id, ps[k+1][i+1].score) )  ;     i := i + 1 ) ; 
         var i : int ; i := 2 ; while i < 8 do ( (      rs[rss+1] := ps[k+1][i+1]  ; rss := rss + 1 )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    rs := rs->sort() ; 
        var i : int ; i := 0 ; while i < 2 do ( (     OclFile["System.out"].printf("%d %.2f\n", rs[i+1].id, rs[i+1].score) )  ;     i := i + 1 ) ; 
 )  ) );
 class P implements Comparable<P> {
   attribute id : int;
   attribute score : double;
      operation compareTo( o : P) : int
  pre: true
  post: true
  activity: (     return (score)->compareTo(o.score) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class p139B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int s=in.nextInt();
    int k=in.nextInt();
    int i,t=0 ;
    long[] S=new long[100005];
    long[] sum=new long[100005];
    long[] v=new long[100005];
    S[0]=1 ;
    S[1]=1 ;
    sum[0]=0 ;
    sum[1]=1 ;
    sum[2]=2 ;
    for(i=2 ; ; ++i){
      if(i<=k){
        S[i]=S[i-1]+S[i-1];
        sum[i]=sum[i-1]+S[i];
      }
      else {
        S[i]=sum[i-1]-sum[i-k-1];
        sum[i]=sum[i-1]+S[i];
      }
      if(S[i]>=s)break ;
    }
    for(; ; --i){
      if(S[i]<=s){
        s-=S[i];
        v[t++]=S[i];
      }
      if(s==0)break ;
    }
    System.out.println(t+1);
    System.out.print("0 ");
    for(i=0 ; i<t ; ++i){
      System.out.print(v[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class p139B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : int ; s := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var i : int ;
    var t : int ; t := 0 ;
    var S : Sequence(long) ; S := Integer.subrange(1,100005)->collect(0) ;
    var sum : Sequence(long) ; sum := Integer.subrange(1,100005)->collect(0) ;
    var v : Sequence(long) ; v := Integer.subrange(1,100005)->collect(0) ;
    S[0+1] := 1 ; 
    S[1+1] := 1 ; 
    sum[0+1] := 0 ; 
    sum[1+1] := 1 ; 
    sum[2+1] := 2 ; 
        i := 2 ; while true do ( (     if (i <= k) then (     S[i+1] := S[i - 1+1] + S[i - 1+1] ; 
     sum[i+1] := sum[i - 1+1] + S[i+1] ) else (     S[i+1] := sum[i - 1+1] - sum[i - k - 1+1] ; 
     sum[i+1] := sum[i - 1+1] + S[i+1] ) ;  
     if (S[i+1] >= s) then     break else skip )  ;     i := i + 1 ) ; 
      while true do ( (     if (S[i+1] <= s) then (     s := s-(S[i+1]) ; 
      v[t+1] := S[i+1]  ; t := t + 1 ) else skip ; 
     if (s = 0) then     break else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(t + 1) ; 
    OclFile["System.out"].print("0 ") ; 
        i := 0 ; while i < t do ( (     OclFile["System.out"].print(v[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String findLargest(int N){
    String largest="" ;
    for(int i=0 ; i<N ; i++)largest+='F' ;
    return largest ;
  }
  static String findSmallest(int N){
    String smallest="1" ;
    for(int i=0 ; i<N-1 ; i++)smallest+='0' ;
    return smallest ;
  }
  static void print(int largest){
    System.out.println("Largest: "+findLargest(largest));
    System.out.println("Smallest: "+findSmallest(largest));
  }
  public static void main(String[] args){
    int N=4 ;
    print(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findLargest( N : int) : String
  pre: true
  post: true
  activity: (     var largest : String ; largest := "" ;
         var i : int ; i := 0 ; while i < N do (     largest := largest+('F') ;  ;     i := i + 1 ) ; 
     return largest );
  static   operation findSmallest( N : int) : String
  pre: true
  post: true
  activity: (     var smallest : String ; smallest := "1" ;
         var i : int ; i := 0 ; while i < N - 1 do (     smallest := smallest+('0') ;  ;     i := i + 1 ) ; 
     return smallest );
  static   operation print( largest : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Largest: " + findLargest(largest)) ; 
     OclFile["System.out"].println("Smallest: " + findSmallest(largest)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     execute print(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  private static String[] ten=new String[100];
  public void kami(){
    Scanner sc=new Scanner(System.in);
    int x=0 ;
    int m=sc.nextInt();
    int f=sc.nextInt();
    int r=sc.nextInt();
    while(m!=-1 || f!=-1 || r!=-1){
      if(m<=50 && f<=50){
        if(m==-1 || f==-1){
          ten[x]="F" ;
        }
        else if(m+f>=80){
          ten[x]="A" ;
        }
        else if(m+f>=65){
          ten[x]="B" ;
        }
        else if(m+f>=50 ||(m+f>=30 && r>=50)){
          ten[x]="C" ;
        }
        else if(m+f>=30){
          ten[x]="D" ;
        }
        else if(m+f<30){
          ten[x]="F" ;
        }
      }
      x++;
      m=sc.nextInt();
      f=sc.nextInt();
      r=sc.nextInt();
    }
    for(int i=0 ; i<=x-1 ; i++){
      System.out.println(ten[i]);
    }
  }
  public static void main(String[] args){
    new Main().kami();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ten : Sequence(String) := Integer.subrange(1,100)->collect(null);
   operation kami() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := 0 ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var f : int ; f := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    while (m /= -1 or f /= -1 or r /= -1) do (     if (m <= 50 & f <= 50) then (     if (m = -1 or f = -1) then (     ten[x+1] := "F" ) else     if (m + f >= 80) then (     ten[x+1] := "A" ) else     if (m + f >= 65) then (     ten[x+1] := "B" ) else     if (m + f >= 50 or (m + f >= 30 & r >= 50)) then (     ten[x+1] := "C" ) else     if (m + f >= 30) then (     ten[x+1] := "D" ) else     if (m + f < 30) then (     ten[x+1] := "F" ) else skip ; ;  ;  ;  ;  ) else skip ; 
     x := x + 1 ; 
    m := sc.getCurrent()->toInteger() ; 
    f := sc.getCurrent()->toInteger() ; 
    r := sc.getCurrent()->toInteger() ; 
 ) ; 
        var i : int ; i := 0 ; while i <= x - 1 do ( (     OclFile["System.out"].println(ten[i+1]) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().kami() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAX=26 ;
  static void printAnagramAndChanges(char[] X,char[] Y){
    int countx[]=new int[MAX],county[]=new int[MAX],ctrx[]=new int[MAX],ctry[]=new int[MAX];
    int change=0 ;
    int l=X.length ;
    for(int i=0 ; i<l ; i++){
      countx[X[i]-'A']++;
      county[Y[i]-'A']++;
    }
    for(int i=0 ; i<MAX ; i++){
      if(countx[i]>county[i]){
        ctrx[i]+=(countx[i]-county[i]);
      }
      else if(countx[i]<county[i]){
        ctry[i]+=(county[i]-countx[i]);
      }
      change+=Math.abs(county[i]-countx[i]);
    }
    for(int i=0 ; i<l ; i++){
      if(ctrx[X[i]-'A']==0){
        continue ;
      }
      int j ;
      for(j=0 ; j<MAX ; j++){
        if((ctry[j])>0){
          break ;
        }
      }
      if(countx[X[i]-'A']==ctrx[X[i]-'A'] || X[i]-'A'>j){
        countx[X[i]-'A']--;
        ctrx[X[i]-'A']--;
        ctry[j]--;
        X[i]=(char)('A'+j);
      }
      else {
        countx[X[i]-'A']--;
      }
    }
    System.out.println("Anagram : "+String.valueOf(X));
    System.out.println("Number of changes made : "+change/2);
  }
  public static void main(String[] args){
    String x="CDBABC",y="ADCABD" ;
    printAnagramAndChanges(x.toCharArray(),y.toCharArray());
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 26;
  static   operation printAnagramAndChanges( X : Sequence(String), Y : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var countx : Sequence(void) ; countx := Integer.subrange(1,MAX)->collect(0) ;
    var county : Sequence(void) ; county := Integer.subrange(1,MAX)->collect(0) ;
    var ctrx : Sequence(void) ; ctrx := Integer.subrange(1,MAX)->collect(0) ;
    var ctry : Sequence(void) ; ctry := Integer.subrange(1,MAX)->collect(0) ;
     var change : int ; change := 0 ;
    var l : int ; l := X->size() ;
        var i : int ; i := 0 ; while i < l do ( (     countx[X[i+1] - ('A')->char2byte()+1] := countx[X[i+1] - ('A')->char2byte()+1] + 1 ; 
     county[Y[i+1] - ('A')->char2byte()+1] := county[Y[i+1] - ('A')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < MAX do ( (     if (countx[i+1] > county[i+1]) then (     ctrx[i+1] := ctrx[i+1]+((countx[i+1] - county[i+1])) ) else     if (countx[i+1] < county[i+1]) then (     ctry[i+1] := ctry[i+1]+((county[i+1] - countx[i+1])) ) else skip ; ;  
     change := change+(if county[i+1] - countx[i+1] < 0 then -(county[i+1] - countx[i+1]) else county[i+1] - countx[i+1] endif) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < l do ( (     if (ctrx[X[i+1] - ('A')->char2byte()+1] = 0) then (     continue ) else skip ; 
     var j : int ;
         j := 0 ; while j < MAX do ( (     if ((ctry[j+1]) > 0) then (     break ) else skip )  ;     j := j + 1 ) ; 
     if (countx[X[i+1] - ('A')->char2byte()+1] = ctrx[X[i+1] - ('A')->char2byte()+1] or X[i+1] - ('A')->char2byte() > j) then (     countx[X[i+1] - ('A')->char2byte()+1] := countx[X[i+1] - ('A')->char2byte()+1] - 1 ; 
     ctrx[X[i+1] - ('A')->char2byte()+1] := ctrx[X[i+1] - ('A')->char2byte()+1] - 1 ; 
     ctry[j+1] := ctry[j+1] - 1 ; 
     X[i+1] := ('A' + j)->oclAsType(String) ) else (     countx[X[i+1] - ('A')->char2byte()+1] := countx[X[i+1] - ('A')->char2byte()+1] - 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Anagram : " + ((X) + "")) ; 
    OclFile["System.out"].println("Number of changes made : " + change / 2) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : String ; x := "CDBABC" ;
    var y : String ; y := "ADCABD" ;
     execute printAnagramAndChanges(x->characters(), y->characters()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static int countSubArrays(int arr[],int x){
    int count=0 ;
    int start=-1,end=-1 ;
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]<x){
        if(start==-1){
          start=i ;
          end=i ;
        }
        else {
          end=i ;
        }
      }
      else {
        if(start!=-1 && end!=-1){
          int length=end-start+1 ;
          count=count+((length*(length+1))/2);
        }
        start=-1 ;
        end=-1 ;
      }
    }
    if(start!=-1 && end!=-1){
      int length=end-start+1 ;
      count=count+((length*(length+1))/2);
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      1,5,7,8,2,3,9 };
      int x=6 ;
      System.out.println(countSubArrays(arr,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSubArrays( arr : Sequence(int), x : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var start : int ; start := -1 ;
    var end : int ; end := -1 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] < x) then (     if (start = -1) then (     start := i ; 
     end := i ) else (     end := i ) ) else (     if (start /= -1 & end /= -1) then (     var length : int ; length := end - start + 1 ;
     count := count + ((length * (length + 1)) / 2) ) else skip ; 
     start := -1 ; 
     end := -1 ) )  ;     i := i + 1 ) ; 
    if (start /= -1 & end /= -1) then (     var length : int ; length := end - start + 1 ;
     count := count + ((length * (length + 1)) / 2) ) else skip ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,7,8,2,3,9} ;
     var x : int ; x := 6 ;
     OclFile["System.out"].println(countSubArrays(arr, x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    for(; ; ){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if(n==0 && m==0)break ;
      int[] d=new int[n];
      int[] v=new int[n];
      for(int i=0 ; i<n ; ++i){
        d[i]=sc.nextInt()-1 ;
        v[i]=sc.nextInt();
      }
      int[] maxRecommendation=new int[m];
      for(int i=0 ; i<n ; ++i){
        maxRecommendation[d[i] ]=Math.max(maxRecommendation[d[i] ],v[i]);
      }
      int result=0 ;
      for(int i=0 ; i<m ; ++i){
        result+=maxRecommendation[i];
      }
      out.println(result);
    }
    sc.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
      while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if (n = 0 & m = 0) then     break else skip ; 
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     d[i+1] := sc.getCurrent()->toInteger() - 1 ; 
     v[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var maxRecommendation : Sequence(int) ; maxRecommendation := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     maxRecommendation[d[i+1]+1] := Set{maxRecommendation[d[i+1]+1], v[i+1]}->max() )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     result := result+(maxRecommendation[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int N,M ;
      N=parseInt(line.substring(0,line.indexOf(' ')));
      M=parseInt(line.substring(line.indexOf(' ')+1));
      if((N | M)==0)break ;
      int[] vs=new int[M+1];
      for(int i=0 ; i<N ; i++){
        line=br.readLine();
        int d,v ;
        d=parseInt(line.substring(0,line.indexOf(' ')));
        v=parseInt(line.substring(line.indexOf(' ')+1));
        vs[d]=Math.max(vs[d],v);
      }
      System.out.println(Arrays.stream(vs).sum());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var N : int ;
    var M : int ;
     N := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    M := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    if ((MathLib.bitwiseOr(N,M)) = 0) then     break else skip ; 
    var vs : Sequence(int) ; vs := Integer.subrange(1,M + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     line := br.readLine() ; 
     var d : int ;
    var v : int ;
    d := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    v := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    vs[d+1] := Set{vs[d+1], v}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(stream(vs)->sum()) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  private static int n,m ;
  public static void main(String...args){
    Scanner scanner=new Scanner(System.in);
    while((n=scanner.nextInt())!=0){
      m=scanner.nextInt();
      Map<Integer,Integer>map=new HashMap<>();
      IntStream.range(0,n).map(d->scanner.nextInt()).forEach(d->map.put(d,Math.max(map.getOrDefault(d,0),scanner.nextInt())));
      System.out.println(map.values().stream().mapToInt(i->i).sum());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         n := scanner.getCurrent()->toInteger() ;
    while ((n) /= 0) do (    skip ; (     m := scanner.getCurrent()->toInteger() ; 
     var map : Map(int,int) ; map := Map{} ;
     for d : Integer.subrange(0, n-1)->collect( _x1 | (lambda d : OclAny in scanner.getCurrent()->toInteger())->apply(_x1) ) do
    (    map := map->union(Map{d |-> Set{(if map->keys()->contains(d) then map->at(d) else 0 endif), scanner.getCurrent()->toInteger()}->max()})) ; 
     OclFile["System.out"].println(map->values()->collect( _x1 | (lambda i : OclAny in i)->apply(_x1) )->sum()) ) ;     n := scanner.getCurrent()->toInteger() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String input=br.readLine();
      String[] tmpArray=input.split(" ");
      int n=Integer.parseInt(tmpArray[0]);
      int m=Integer.parseInt(tmpArray[1]);
      if(n==0 && m==0){
        break ;
      }
      Problem problems[]=new Problem[n];
      for(int i=0 ; i<n ; i++){
        tmpArray=br.readLine().split(" ");
        problems[i]=new Problem(Integer.parseInt(tmpArray[0]),Integer.parseInt(tmpArray[1]));
      }
      Arrays.sort(problems);
      boolean selected[]=new boolean[m+1];
      int result=0 ;
      for(int i=0 ; i<n ; i++){
        if(! selected[problems[i] .difficulty]){
          selected[problems[i] .difficulty]=true ;
          result+=problems[i] .recommended ;
        }
      }
      System.out.println(result);
    }
  }
}
class Problem implements Comparable<Problem>{
  int difficulty ;
  int recommended ;
  Problem(int diff,int rec){
    difficulty=diff ;
    recommended=rec ;
  }
  @ Override public int compareTo(Problem p1){
    return p1.recommended-this.recommended ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var input : String ; input := br.readLine() ;
     var tmpArray : Sequence(String) ; tmpArray := input->split(" ") ;
    var n : int ; n := (tmpArray[0+1])->toInteger() ;
    var m : int ; m := (tmpArray[1+1])->toInteger() ;
    if (n = 0 & m = 0) then (     break ) else skip ; 
    var problems : Sequence(Problem) ; problems := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     tmpArray := br.readLine()->split(" ") ; 
     problems[i+1] := Problem.newProblem((tmpArray[0+1])->toInteger(), (tmpArray[1+1])->toInteger()) )  ;     i := i + 1 ) ; 
    problems := problems->sort() ; 
    var selected : Sequence(boolean) ; selected := Integer.subrange(1,m + 1)->collect(false) ;
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (not(selected[problems[i+1].difficulty+1])) then (     selected[problems[i+1].difficulty+1] := true ; 
     result := result+(problems[i+1].recommended) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ) );
}
class Problem implements Comparable<Problem> {
   attribute difficulty : int;
   attribute recommended : int;
   static operation newProblem( diff : int, rec : int) : Problem
  pre: true
  post: true
  activity:
  ( var self : Problem ;
    self := createProblem();
    self.initialise(diff, rec);
    return self );
  operation initialise( diff : int, rec : int) : void
  pre: true  post: true
  activity: (     difficulty := diff ; 
     recommended := rec );
      operation compareTo( p1 : Problem) : int
  pre: true
  post: true
  activity: (     return p1.recommended - self.recommended );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  private static final int MOD=(int)1e9+7 ;
  public static void main(String[] args)throws FileNotFoundException {
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt(),m=in.nextInt();
    while(n!=0 && m!=0){
      int[] max=new int[m];
      for(int i=0 ; i<n ; i++){
        int d=in.nextInt()-1 ;
        max[d]=Math.max(max[d],in.nextInt());
      }
      long ans=0 ;
      for(int i=0 ; i<m ; i++){
        ans+=max[i];
      }
      out.println(ans);
      n=in.nextInt();
      m=in.nextInt();
    }
    out.close();
  }
  private static class Task {
    int d,p ;
    public Task(int d,int p){
      this.d=d ;
      this.p=p ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1e9->oclAsType(int) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    while (n /= 0 & m /= 0) do (     var max : Sequence(int) ; max := Integer.subrange(1,m)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     var d : int ; d := in.getCurrent()->toInteger() - 1 ;
     max[d+1] := Set{max[d+1], in.getCurrent()->toInteger()}->max() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     ans := ans+(max[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
    n := in.getCurrent()->toInteger() ; 
    m := in.getCurrent()->toInteger() ; 
 ) ; 
    skip ; 
 );
  static class Task {
   attribute d : int;
   static operation newTask( d : int, p : int) : Task
  pre: true
  post: true
  activity:
  ( var self : Task ;
    self := createTask();
    self.initialise(d, p);
    return self );
  operation initialise( d : int, p : int) : void
  pre: true  post: true
  activity: (     self.d := d ; 
     self.p := p );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int runner ;
  int cnt=0 ;
  int cnt2=0 ;
  String time ;
  Player pArray[][]=new Player[3][8];
  Player rank[]=new Player[8];
  Player otherArray[]=new Player[18];
  private Scanner sc ;
  void doIt(){
    sc=new Scanner(System.in);
    for(int i=0 ; i<3 ; i++){
      for(int k=0 ; k<8 ; k++){
        runner=sc.nextInt();
        time=sc.next();
        pArray[i][k]=new Player(runner,time);
      }
    }
    for(int i=0 ; i<pArray.length ; i++){
      Arrays.sort(pArray[i]);
      Arrays.toString(pArray[i]);
      rank[cnt]=pArray[i][0];
      cnt++;
      rank[cnt]=pArray[i][1];
      cnt++;
      for(int k=2 ; k<8 ; k++){
        otherArray[cnt2]=pArray[i][k];
        cnt2++;
      }
    }
    Arrays.sort(otherArray);
    rank[6]=otherArray[0];
    rank[7]=otherArray[1];
    for(int i=0 ; i<rank.length ; i++){
      System.out.println(rank[i] .pnumber+" "+rank[i] .time);
    }
  }
  class Player implements Comparable<Player>{
    int pnumber ;
    String time ;
    Player(int pnumber,String time){
      this.pnumber=runner ;
      this.time=time ;
    }
    @ Override public String toString(){
      return pnumber+" "+time ;
    }
    @ Override public int compareTo(Player p){
      return this.time.compareTo(p.time);
    }
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute runner : int;
   attribute cnt : int := 0;
   attribute cnt2 : int := 0;
   attribute time : String;
   attribute pArray : Player := Integer.subrange(1,3)->collect(Integer.subrange(1,8)->collect(null));
   attribute rank : Player := Integer.subrange(1,8)->collect(null);
   attribute otherArray : Player := Integer.subrange(1,18)->collect(null);
   attribute sc : OclFile;
   operation doIt() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
         var i : int ; i := 0 ; while i < 3 do ( (         var k : int ; k := 0 ; while k < 8 do ( (     runner := sc.getCurrent()->toInteger() ; 
     time := sc.getCurrent() ; 
     pArray[i+1][k+1] := Player.newPlayer(runner, time) )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < pArray->size() do ( (     pArray[i+1] := pArray[i+1]->sort() ; 
 (pArray[i+1] + "") ; 
    rank[cnt+1] := pArray[i+1][0+1] ; 
    cnt := cnt + 1 ; 
    rank[cnt+1] := pArray[i+1][1+1] ; 
    cnt := cnt + 1 ; 
        var k : int ; k := 2 ; while k < 8 do ( (     otherArray[cnt2+1] := pArray[i+1][k+1] ; 
     cnt2 := cnt2 + 1 )  ;     k := k + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    otherArray := otherArray->sort() ; 
    rank[6+1] := otherArray[0+1] ; 
    rank[7+1] := otherArray[1+1] ; 
        var i : int ; i := 0 ; while i < rank->size() do ( (     OclFile["System.out"].println(rank[i+1].pnumber + " " + rank[i+1].time) )  ;     i := i + 1 ) ; 
 );
 class Player implements Comparable<Player> {
   attribute pnumber : int;
   attribute time : String;
   static operation newPlayer( pnumber : int, time : String) : Player
  pre: true
  post: true
  activity:
  ( var self : Player ;
    self := createPlayer();
    self.initialise(pnumber, time);
    return self );
  operation initialise( pnumber : int, time : String) : void
  pre: true  post: true
  activity: (     self.pnumber := runner ; 
     self.time := time );
      operation toString() : String
  pre: true
  post: true
  activity: (     return pnumber + " " + time );
      operation compareTo( p : Player) : int
  pre: true
  post: true
  activity: (     return self.time->compareTo(p.time) );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
class GFG {
  static void Maximum_xor_Triplet(int n,int a[]){
    HashSet<Integer>s=new HashSet<Integer>();
    for(int i=0 ; i<n ; i++){
      for(int j=i ; j<n ; j++){
        s.add(a[i] ^ a[j]);
      }
    }
    int ans=0 ;
    for(Integer i : s){
      for(int j=0 ; j<n ; j++){
        ans=Math.max(ans,i ^ a[j]);
      }
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    int a[]={
      1,3,8,15 };
      int n=a.length ;
      Maximum_xor_Triplet(n,a);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Maximum_xor_Triplet( n : int, a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i ; while j < n do ( (     s := s->including(a[i+1] xor a[j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (i : s) do ( (         var j : int ; j := 0 ; while j < n do ( (     ans := Set{ans, MathLib.bitwiseXor(i,a[j+1])}->max() )  ;     j := j + 1 ) )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,3,8,15} ;
     var n : int ; n := a->size() ;
     execute Maximum_xor_Triplet(n, a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String arg[]){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      char ch[]=in.next().toCharArray();
      if((ch[0]=='o' && ch[1]=='o' && ch[2]=='o')||(ch[3]=='o' && ch[4]=='o' && ch[5]=='o')||(ch[6]=='o' && ch[7]=='o' && ch[8]=='o')||(ch[0]=='o' && ch[3]=='o' && ch[6]=='o')||(ch[1]=='o' && ch[4]=='o' && ch[7]=='o')||(ch[2]=='o' && ch[5]=='o' && ch[8]=='o')||(ch[0]=='o' && ch[4]=='o' && ch[8]=='o')||(ch[2]=='o' && ch[4]=='o' && ch[6]=='o'))System.out.println("o");
      else if((ch[0]=='x' && ch[1]=='x' && ch[2]=='x')||(ch[3]=='x' && ch[4]=='x' && ch[5]=='x')||(ch[6]=='x' && ch[7]=='x' && ch[8]=='x')||(ch[0]=='x' && ch[3]=='x' && ch[6]=='x')||(ch[1]=='x' && ch[4]=='x' && ch[7]=='x')||(ch[2]=='x' && ch[5]=='x' && ch[8]=='x')||(ch[0]=='x' && ch[4]=='x' && ch[8]=='x')||(ch[2]=='x' && ch[4]=='x' && ch[6]=='x'))System.out.println("x");
      else System.out.println("d");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var ch : Sequence(String) ; ch := in.getCurrent()->characters() ;
     if ((ch[0+1] = 'o' & ch[1+1] = 'o' & ch[2+1] = 'o') or (ch[3+1] = 'o' & ch[4+1] = 'o' & ch[5+1] = 'o') or (ch[6+1] = 'o' & ch[7+1] = 'o' & ch[8+1] = 'o') or (ch[0+1] = 'o' & ch[3+1] = 'o' & ch[6+1] = 'o') or (ch[1+1] = 'o' & ch[4+1] = 'o' & ch[7+1] = 'o') or (ch[2+1] = 'o' & ch[5+1] = 'o' & ch[8+1] = 'o') or (ch[0+1] = 'o' & ch[4+1] = 'o' & ch[8+1] = 'o') or (ch[2+1] = 'o' & ch[4+1] = 'o' & ch[6+1] = 'o')) then     OclFile["System.out"].println("o") ; else     if ((ch[0+1] = 'x' & ch[1+1] = 'x' & ch[2+1] = 'x') or (ch[3+1] = 'x' & ch[4+1] = 'x' & ch[5+1] = 'x') or (ch[6+1] = 'x' & ch[7+1] = 'x' & ch[8+1] = 'x') or (ch[0+1] = 'x' & ch[3+1] = 'x' & ch[6+1] = 'x') or (ch[1+1] = 'x' & ch[4+1] = 'x' & ch[7+1] = 'x') or (ch[2+1] = 'x' & ch[5+1] = 'x' & ch[8+1] = 'x') or (ch[0+1] = 'x' & ch[4+1] = 'x' & ch[8+1] = 'x') or (ch[2+1] = 'x' & ch[4+1] = 'x' & ch[6+1] = 'x')) then     OclFile["System.out"].println("x") else     OclFile["System.out"].println("d") ; ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.regex.Pattern ;
public class Main {
  public static void main(String[] args)throws IOException {
    List<TicTacToe>ticTacToeList=readTicTacToe();
    for(TicTacToe ticTacToe : ticTacToeList){
      System.out.println(ticTacToe.judge());
    }
  }
  private static List<TicTacToe>readTicTacToe()throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    List<TicTacToe>ticTacToeList=new ArrayList<>();
    String line=null ;
    while((line=reader.readLine())!=null){
      ticTacToeList.add(new TicTacToe(line));
    }
    return ticTacToeList ;
  }
  private static class TicTacToe {
    Pattern[] WIN_PATTERN={
      Pattern.compile(".*1.*4.*7.*"),Pattern.compile(".*2.*5.*8.*"),Pattern.compile(".*3.*6.*9.*"),Pattern.compile(".*1.*2.*3.*"),Pattern.compile(".*4.*5.*6.*"),Pattern.compile(".*7.*8.*9.*"),Pattern.compile(".*1.*5.*9.*"),Pattern.compile(".*3.*5.*7.*")};
      private String o="" ;
      private String x="" ;
      public TicTacToe(String input){
        for(int i=0 ; i<input.length(); i++){
          if(input.charAt(i)=='o'){
            o=o+(i+1);
          }
          else if(input.charAt(i)=='x'){
            x=x+(i+1);
          }
        }
      }
      private char judge(){
        for(Pattern p : WIN_PATTERN){
          if(p.matcher(o).matches()){
            return 'o' ;
          }
        }
        for(Pattern p : WIN_PATTERN){
          if(p.matcher(x).matches()){
            return 'x' ;
          }
        }
        return 'd' ;
      }
      @ Override public String toString(){
        return "o: "+o+",x: "+x ;
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ticTacToeList : Sequence(TicTacToe) ; ticTacToeList := readTicTacToe() ;
     for (ticTacToe : ticTacToeList) do ( (     OclFile["System.out"].println(ticTacToe.judge()) )  ) );
  static   operation readTicTacToe() : Sequence(TicTacToe)
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var ticTacToeList : Sequence(TicTacToe) ; ticTacToeList := Sequence{} ;
    var line : String ; line := null ;
        line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     ticTacToeList := ticTacToeList->including(TicTacToe.newTicTacToe(line)) ) ;     line := reader.readLine() ;
 ) ;  
    return ticTacToeList 
 );
  static class TicTacToe {
   attribute WIN_PATTERN : Sequence(OclRegex) := Sequence{OclRegex.compile(".*1.*4.*7.*"),OclRegex.compile(".*2.*5.*8.*"),OclRegex.compile(".*3.*6.*9.*"),OclRegex.compile(".*1.*2.*3.*"),OclRegex.compile(".*4.*5.*6.*"),OclRegex.compile(".*7.*8.*9.*"),OclRegex.compile(".*1.*5.*9.*"),OclRegex.compile(".*3.*5.*7.*")};
   attribute o : String := "";
   attribute x : String := "";
   static operation newTicTacToe( input : String) : TicTacToe
  pre: true
  post: true
  activity:
  ( var self : TicTacToe ;
    self := createTicTacToe();
    self.initialise(input);
    return self );
  operation initialise( input : String) : void
  pre: true  post: true
  activity: (         var i : int ; i := 0 ; while i < input->size() do ( (     if (input->at(i+1) = 'o') then (     o := o + (i + 1) ) else     if (input->at(i+1) = 'x') then (     x := x + (i + 1) ) else skip ; )  ;     i := i + 1 ) );
   operation judge() : String
  pre: true
  post: true
  activity: (     for (p : WIN_PATTERN) do ( (     if (p.matcher(o).isMatch()) then (     return 'o' ) else skip )  ) ; 
     for (p : WIN_PATTERN) do ( (     if (p.matcher(x).isMatch()) then (     return 'x' ) else skip )  ) ; 
     return 'd' );
      operation toString() : String
  pre: true
  post: true
  activity: (     return "o: " + o + ",x: " + x );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    ArrayList<String>scoreArrays=new ArrayList<String>();
    while(true){
      String strTensu=br.readLine();
      if("-1-1-1".equals(strTensu)){
        break ;
      }
      String[] strTensuArrays=strTensu.split(" ");
      Integer totalScore=Integer.parseInt(strTensuArrays[0])+Integer.parseInt(strTensuArrays[1]);
      if(! "-1".equals(strTensuArrays[0])&& ! "-1".equals(strTensuArrays[1])){
        if(80<=totalScore){
          scoreArrays.add("A");
        }
        else if(totalScore<80 && 65<=totalScore){
          scoreArrays.add("B");
        }
        else if(totalScore<65 && 50<=totalScore){
          scoreArrays.add("C");
        }
        else if(totalScore<50 && 30<=totalScore){
          if(50<=Integer.parseInt(strTensuArrays[2])){
            scoreArrays.add("C");
          }
          else {
            scoreArrays.add("D");
          }
        }
        else {
          scoreArrays.add("F");
        }
      }
      else {
        scoreArrays.add("F");
      }
    }
    for(int i=0 ; i<scoreArrays.size(); i++){
      System.out.println(scoreArrays.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var scoreArrays : Sequence(String) ; scoreArrays := Sequence{} ;
     while (true) do (     var strTensu : String ; strTensu := br.readLine() ;
     if ("-1-1-1" = strTensu) then (     break ) else skip ; 
    var strTensuArrays : Sequence(String) ; strTensuArrays := strTensu->split(" ") ;
    var totalScore : int ; totalScore := (strTensuArrays[0+1])->toInteger() + (strTensuArrays[1+1])->toInteger() ;
    if (not("-1" = strTensuArrays[0+1]) & not("-1" = strTensuArrays[1+1])) then (     if (80 <= totalScore) then (     scoreArrays := scoreArrays->including("A") ) else     if (totalScore < 80 & 65 <= totalScore) then (     scoreArrays := scoreArrays->including("B") ) else     if (totalScore < 65 & 50 <= totalScore) then (     scoreArrays := scoreArrays->including("C") ) else     if (totalScore < 50 & 30 <= totalScore) then (     if (50 <= (strTensuArrays[2+1])->toInteger()) then (     scoreArrays := scoreArrays->including("C") ) else (     scoreArrays := scoreArrays->including("D") ) ) else (     scoreArrays := scoreArrays->including("F") ) ;  ;  ;  ) else (     scoreArrays := scoreArrays->including("F") ) ;  
 ) ; 
         var i : int ; i := 0 ; while i < scoreArrays->size() do ( (     OclFile["System.out"].println(scoreArrays->at(i+1)) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Researcher {
  int mat[][]=new int[3][3];
  String index="oxs" ;
  Researcher(String s){
    for(int i=0 ; i<9 ; i++){
      mat[i/3][i % 3]=index.indexOf(s.charAt(i));
    }
  }
  char Research(){
    if(mat[1][1]<=1){
      if(mat[0][0]==mat[1][1] && mat[1][1]==mat[2][2])return index.charAt(mat[0][0]);
      else if(mat[2][0]==mat[1][1] && mat[1][1]==mat[0][2])return index.charAt(mat[2][0]);
    }
    for(int i=0 ; i<3 ; i++){
      if(mat[i][0]<=1){
        if(mat[i][0]==mat[i][1] && mat[i][1]==mat[i][2])return index.charAt(mat[i][0]);
      }
      if(mat[0][i]<=1){
        if(mat[0][i]==mat[1][i] && mat[1][i]==mat[2][i])return index.charAt(mat[0][i]);
      }
    }
    return 'd' ;
  }
}
class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String buf ;
    try {
      while((buf=br.readLine())!=null){
        System.out.println(new Researcher(buf).Research());
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Researcher {
   attribute mat : int := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0));
   attribute index : String := "oxs";
   static operation newResearcher( s : String) : Researcher
  pre: true
  post: true
  activity:
  ( var self : Researcher ;
    self := createResearcher();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (         var i : int ; i := 0 ; while i < 9 do ( (     mat[i / 3+1][i mod 3+1] := index->indexOf(s->at(i+1))-1 )  ;     i := i + 1 ) );
   operation Research() : String
  pre: true
  post: true
  activity: (     if (mat[1+1][1+1] <= 1) then (     if (mat[0+1][0+1] = mat[1+1][1+1] & mat[1+1][1+1] = mat[2+1][2+1]) then     return index->at(mat[0+1][0+1]+1) else     if (mat[2+1][0+1] = mat[1+1][1+1] & mat[1+1][1+1] = mat[0+1][2+1]) then     return index->at(mat[2+1][0+1]+1) else skip ; ) else skip ; 
         var i : int ; i := 0 ; while i < 3 do ( (     if (mat[i+1][0+1] <= 1) then (     if (mat[i+1][0+1] = mat[i+1][1+1] & mat[i+1][1+1] = mat[i+1][2+1]) then     return index->at(mat[i+1][0+1]+1) else skip ) else skip ; 
     if (mat[0+1][i+1] <= 1) then (     if (mat[0+1][i+1] = mat[1+1][i+1] & mat[1+1][i+1] = mat[2+1][i+1]) then     return index->at(mat[0+1][i+1]+1) else skip ) else skip )  ;     i := i + 1 ) ; 
     return 'd' );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var buf : String ;
     try (         buf := br.readLine() ;
    while ((buf) /= null) do (    skip ; (     OclFile["System.out"].println(Researcher.newResearcher(buf).Research()) ) ;     buf := br.readLine() ;
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static int eqaualValue(char[] x,int i,int j){
    if(x[i]==x[i+j] && x[i]==x[i+2*j]){
      if(x[i]=='o'){
        return 0 ;
      }
      else if(x[i]=='x'){
        return 1 ;
      }
    }
    return-1 ;
  }
  public static String judge(String str){
    char[] x=str.toCharArray();
    for(int i=0 ; i<str.length(); i++){
      x[i]=str.charAt(i);
    }
    for(int i=0 ; i<3 ; i++){
      if(eqaualValue(x,i,3)==0){
        return "o" ;
      }
      else if(eqaualValue(x,i,3)==1){
        return "x" ;
      }
    }
    for(int i=0 ; i<3 ; i++){
      if(eqaualValue(x,3*i,1)==0){
        return "o" ;
      }
      else if(eqaualValue(x,3*i,1)==1){
        return "x" ;
      }
    }
    if(eqaualValue(x,0,4)==0){
      return "o" ;
    }
    else if(eqaualValue(x,0,4)==1){
      return "x" ;
    }
    if(eqaualValue(x,2,2)==0){
      return "o" ;
    }
    else if(eqaualValue(x,2,2)==0){
      return "x" ;
    }
    return "d" ;
  }
  public static void main(String[] args)throws IOException {
    Scanner stdIn=null ;
    List<String>result=new ArrayList<String>();
    try {
      stdIn=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
      while(stdIn.hasNext()){
        String str=stdIn.next();
        result.add(judge(str));
      }
      for(String s : result){
        System.out.println(s);
      }
    }
    finally {
      if(stdIn!=null){
        stdIn.close();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation eqaualValue( x : Sequence(String), i : int, j : int) : int
  pre: true
  post: true
  activity: (     if (x[i+1] = x[i + j+1] & x[i+1] = x[i + 2 * j+1]) then (     if (x[i+1] = 'o') then (     return 0 ) else     if (x[i+1] = 'x') then (     return 1 ) else skip ; ) else skip ; 
     return -1 );
  static   operation judge( str : String) : String
  pre: true
  post: true
  activity: (     var x : Sequence(String) ; x := str->characters() ;
         var i : int ; i := 0 ; while i < str->size() do ( (     x[i+1] := str->at(i+1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do ( (     if (eqaualValue(x, i, 3) = 0) then (     return "o" ) else     if (eqaualValue(x, i, 3) = 1) then (     return "x" ) else skip ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do ( (     if (eqaualValue(x, 3 * i, 1) = 0) then (     return "o" ) else     if (eqaualValue(x, 3 * i, 1) = 1) then (     return "x" ) else skip ; )  ;     i := i + 1 ) ; 
    if (eqaualValue(x, 0, 4) = 0) then (     return "o" ) else     if (eqaualValue(x, 0, 4) = 1) then (     return "x" ) else skip ; ;  
    if (eqaualValue(x, 2, 2) = 0) then (     return "o" ) else     if (eqaualValue(x, 2, 2) = 0) then (     return "x" ) else skip ; ;  
    return "d" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := null ;
     var result : Sequence(String) ; result := Sequence{} ;
     try (     stdIn := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
     while (stdIn.hasNext()) do (     var str : String ; str := stdIn.getCurrent() ;
     result := result->including(judge(str)) ) ; 
     for (s : result) do ( (     OclFile["System.out"].println(s) )  ) )   finally (     if (stdIn /= null) then (     skip ) else skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
class Main {
  static char[] ca ;
  static PrintWriter out=new PrintWriter(System.out);
  static boolean judge ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      judge=true ;
      ca=sc.next().toCharArray();
      doing('o');
      if(judge)doing('x');
      if(judge)out.println('d');
      out.flush();
    }
  }
  static void doing(char temp){
    if(ca[0]==temp & ca[1]==temp & ca[2]==temp | ca[3]==temp & ca[4]==temp & ca[5]==temp | ca[6]==temp & ca[7]==temp & ca[8]==temp | ca[0]==temp & ca[3]==temp & ca[6]==temp | ca[1]==temp & ca[4]==temp & ca[7]==temp | ca[2]==temp & ca[5]==temp & ca[8]==temp | ca[0]==temp & ca[4]==temp & ca[8]==temp | ca[2]==temp & ca[4]==temp & ca[6]==temp){
      out.println(temp);
      judge=false ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ca : Sequence(String);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute judge : boolean;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     judge := true ; 
     ca := sc.getCurrent()->characters() ; 
    execute doing('o') ; 
    if (judge) then     execute doing('x') ; else skip ; 
    if (judge) then     skip ; else skip ; 
    skip ; 
 ) );
  static   operation doing( temp : String) : void
  pre: true
  post: true
  activity: (     if (ca[0+1] = temp & ca[1+1] = temp & ca[2+1] = temp or ca[3+1] = temp & ca[4+1] = temp & ca[5+1] = temp or ca[6+1] = temp & ca[7+1] = temp & ca[8+1] = temp or ca[0+1] = temp & ca[3+1] = temp & ca[6+1] = temp or ca[1+1] = temp & ca[4+1] = temp & ca[7+1] = temp or ca[2+1] = temp & ca[5+1] = temp & ca[8+1] = temp or ca[0+1] = temp & ca[4+1] = temp & ca[8+1] = temp or ca[2+1] = temp & ca[4+1] = temp & ca[6+1] = temp) then (     skip ; 
     judge := false ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int reverseNum(int n){
    int rem,rev=0 ;
    while(n>0){
      rem=n % 10 ;
      rev=rev*10+rem ;
      n/=10 ;
    }
    return rev ;
  }
  static boolean isPalindrom(int num){
    return num==reverseNum(num);
  }
  static int nthPalindrome(int n,int k){
    int num=(int)Math.pow(10,k-1);
    while(true){
      if(isPalindrom(num))--n ;
      if(n==0)break ;
++num ;
    }
    return num ;
  }
  public static void main(String[] args){
    int n=6,k=5 ;
    System.out.println(n+"th palindrome of "+k+" digit="+nthPalindrome(n,k));
    n=10 ;
    k=6 ;
    System.out.println(n+"th palindrome of "+k+" digit="+nthPalindrome(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation reverseNum( n : int) : int
  pre: true
  post: true
  activity: (     var rem : int ;
    var rev : int ; rev := 0 ;
     while (n > 0) do (     rem := n mod 10 ; 
     rev := rev * 10 + rem ; 
     n := n/(10) ) ; 
     return rev );
  static   operation isPalindrom( num : int) : boolean
  pre: true
  post: true
  activity: (     return num = reverseNum(num) );
  static   operation nthPalindrome( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := 10->pow(k - 1)->oclAsType(int) ;
     while (true) do (     if (isPalindrom(num)) then     n := n - 1 ; else skip ; 
     if (n = 0) then     break else skip ; 
     num := num + 1 ) ; 
     return num );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
    var k : int ; k := 5 ;
     OclFile["System.out"].println(n + "th palindrome of " + k + " digit=" + nthPalindrome(n, k)) ; 
    n := 10 ; 
    k := 6 ; 
    OclFile["System.out"].println(n + "th palindrome of " + k + " digit=" + nthPalindrome(n, k)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    int[] alphabetCount=new int[26];
    char[] chars=sc.next().toCharArray();
    for(int i=0 ; i<chars.length ; i++){
      int index=chars[i]-97 ;
      alphabetCount[index]=alphabetCount[index]+1 ;
    }
    for(int i=1 ; i<N ; i++){
      chars=sc.next().toCharArray();
      int[] tempAlphabetCount=new int[26];
      for(int j=0 ; j<chars.length ; j++){
        int index=chars[j]-97 ;
        tempAlphabetCount[index]=tempAlphabetCount[index]+1 ;
      }
      for(int j=0 ; j<26 ; j++){
        alphabetCount[j]=Math.min(tempAlphabetCount[j],alphabetCount[j]);
      }
    }
    String ans="" ;
    for(int i=0 ; i<26 ; i++){
      if(alphabetCount[i]>0){
        for(int j=0 ; j<alphabetCount[i]; j++){
          ans+=(char)(i+97);
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var alphabetCount : Sequence(int) ; alphabetCount := Integer.subrange(1,26)->collect(0) ;
    var chars : Sequence(String) ; chars := sc.getCurrent()->characters() ;
        var i : int ; i := 0 ; while i < chars->size() do ( (     var index : int ; index := chars[i+1] - 97 ;
     alphabetCount[index+1] := alphabetCount[index+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < N do ( (     chars := sc.getCurrent()->characters() ; 
     var tempAlphabetCount : Sequence(int) ; tempAlphabetCount := Integer.subrange(1,26)->collect(0) ;
         var j : int ; j := 0 ; while j < chars->size() do ( (     var index : int ; index := chars[j+1] - 97 ;
     tempAlphabetCount[index+1] := tempAlphabetCount[index+1] + 1 )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < 26 do ( (     alphabetCount[j+1] := Set{tempAlphabetCount[j+1], alphabetCount[j+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < 26 do ( (     if (alphabetCount[i+1] > 0) then (         var j : int ; j := 0 ; while j < alphabetCount[i+1] do ( (     ans := ans+((i + 97)->oclAsType(String)) )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  static String alphabet="abcdefghijklmnopqrstuvwxyz" ;
  public static void main(String[] args)throws IOException {
    int n=sc.nextInt();
    sc.nextLine();
    int[] counts=new int[26];
    Arrays.fill(counts,50);
    for(int i=0 ; i<n ; i++){
      String curr=sc.nextLine();
      int[] countsCurr=new int[26];
      for(int j=0 ; j<curr.length(); j++){
        String letter=curr.substring(j,j+1);
        int index=alphabet.indexOf(letter);
        countsCurr[index]++;
      }
      for(int j=0 ; j<26 ; j++){
        counts[j]=Math.min(counts[j],countsCurr[j]);
      }
    }
    String ans="" ;
    for(int i=0 ; i<26 ; i++){
      if(counts[i]>0){
        int countLetter=counts[i];
        for(int j=0 ; j<countLetter ; j++){
          ans+=alphabet.charAt(i);
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute alphabet : String := "abcdefghijklmnopqrstuvwxyz";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     skip ; 
    var counts : Sequence(int) ; counts := Integer.subrange(1,26)->collect(0) ;
    counts := counts->collect(50) ; 
        var i : int ; i := 0 ; while i < n do ( (     var curr : String ; curr := sc.nextLine() ;
     var countsCurr : Sequence(int) ; countsCurr := Integer.subrange(1,26)->collect(0) ;
         var j : int ; j := 0 ; while j < curr->size() do ( (     var letter : String ; letter := curr.subrange(j+1,j + 1) ;
     var index : int ; index := alphabet->indexOf(letter)-1 ;
     countsCurr[index+1] := countsCurr[index+1] + 1 )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < 26 do ( (     counts[j+1] := Set{counts[j+1], countsCurr[j+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < 26 do ( (     if (counts[i+1] > 0) then (     var countLetter : int ; countLetter := counts[i+1] ;
         var j : int ; j := 0 ; while j < countLetter do ( (     ans := ans+(alphabet->at(i+1)) )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Map ;
import java.util.Map.Entry ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Map<Double,Integer>h=new TreeMap<>();
    int c ;
    for(int i=0 ; i<3 ; i++){
      Map<Double,Integer>m=new TreeMap<>();
      for(int j=0 ; j<8 ; j++){
        int n=sc.nextInt();
        double t=sc.nextDouble();
        m.put(t,n);
      }
      c=0 ;
      for(Entry<Double,Integer>entry : m.entrySet()){
        if(c++<2){
          System.out.println(entry.getValue()+" "+entry.getKey());
        }
        else if(c<4){
          h.put(entry.getKey(),entry.getValue());
        }
        else {
          break ;
        }
      }
    }
    c=0 ;
    for(Entry<Double,Integer>entry : h.entrySet()){
      if(c++<2)System.out.println(entry.getValue()+" "+entry.getKey());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : Map(double,int) ; h := Map{} ;
    var c : int ;
        var i : int ; i := 0 ; while i < 3 do ( (     var m : Map(double,int) ; m := Map{} ;
         var j : int ; j := 0 ; while j < 8 do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var t : double ; t := sc.getCurrent()->toReal() ;
     m := m->union(Map{t |-> n}) )  ;     j := j + 1 ) ; 
     c := 0 ; 
     for (entry : m->asSet()) do ( (     if (c < 2) then (     OclFile["System.out"].println(entry.getValue() + " " + entry.getKey()) ) else     if (c < 4) then (     h := h->union(Map{entry.getKey() |-> entry.getValue()}) ) else (     break ) ;  )  ) )  ;     i := i + 1 ) ; 
    c := 0 ; 
    for (entry : h->asSet()) do ( (     if (c < 2) then     OclFile["System.out"].println(entry.getValue() + " " + entry.getKey()) ; else skip )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    List<Map<Character,Integer>>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      String s=sc.next();
      Map<Character,Integer>map=new TreeMap<>();
      for(int j=0 ; j<s.length(); j++){
        map.merge(s.charAt(j),1,Integer :: sum);
      }
      list.add(map);
    }
    Map<Character,Integer>map2=list.get(0);
    StringBuilder sb=new StringBuilder();
    if(list.size()==0){
      for(Map.Entry<Character,Integer>s : map2.entrySet()){
        int num=s.getValue();
        for(int i=0 ; i<num ; i++){
          sb.append(s.getKey());
        }
      }
      sb.append("\n");
    }
    else {
      for(Map.Entry<Character,Integer>s : map2.entrySet()){
        int num=s.getValue();
        boolean hasC=true ;
        for(int i=1 ; i<list.size(); i++){
          Map<Character,Integer>tempMap=list.get(i);
          if(tempMap.containsKey(s.getKey())){
            num=Math.min(tempMap.get(s.getKey()),num);
          }
          else {
            hasC=false ;
            break ;
          }
        }
        if(hasC){
          for(int i=0 ; i<num ; i++){
            sb.append(s.getKey());
          }
        }
      }
    }
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var list : Sequence(Map(String,int)) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
     var map : Map(String,int) ; map := Map{} ;
         var j : int ; j := 0 ; while j < s->size() do ( (     map := map.merge(s->at(j+1), 1, lambda _pars : OclAny in Integer.newInteger().sum(_pars)) )  ;     j := j + 1 ) ; 
     list := list->including(map) )  ;     i := i + 1 ) ; 
    var map2 : Map(String,int) ; map2 := list->at(0+1) ;
    var sb : String ; sb := StringLib.newString() ;
    if (list->size() = 0) then (     for (s : map2->asSet()) do ( (     var num : int ; num := s.getValue() ;
         var i : int ; i := 0 ; while i < num do ( (     sb := sb + StringLib.newString(s.getKey()) )  ;     i := i + 1 ) )  ) ; 
     sb := sb + StringLib.newString("\n") ) else (     for (s : map2->asSet()) do ( (     var num : int ; num := s.getValue() ;
     var hasC : boolean ; hasC := true ;
         var i : int ; i := 1 ; while i < list->size() do ( (     var tempMap : Map(String,int) ; tempMap := list->at(i+1) ;
     if (tempMap->keys()->includes(s.getKey())) then (     num := Set{tempMap->at(s.getKey()), num}->min() ) else (     hasC := false ; 
     break ) )  ;     i := i + 1 ) ; 
     if (hasC) then (         var i : int ; i := 0 ; while i < num do ( (     sb := sb + StringLib.newString(s.getKey()) )  ;     i := i + 1 ) ) else skip )  ) ) ;  
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    String[] s=new String[n];
    int min=51 ;
    int k=51 ;
    StringBuffer sb=new StringBuffer();
    for(int i=0 ; i<n ; i++){
      s[i]=scan.next();
      if(s[i] .length()<min){
        min=s[i] .length();
        k=i ;
      }
    }
    String[] o=s[k] .split("",0);
    for(int i=0 ; i<min ; i++){
      int count=0 ;
      for(int j=0 ; j<n ; j++){
        if(j==k){
          continue ;
        }
        if(s[j] .contains(o[i])){
          s[j]=s[j] .replaceFirst(o[i],".");
          count++;
        }
      }
      if(count==n-1){
        sb.append(o[i]);
      }
    }
    String ans=sb.toString();
    String[] answer=ans.split("",0);
    Arrays.sort(answer);
    for(int i=0 ; i<ans.length()-1 ; i++){
      System.out.print(answer[i]);
    }
    if(ans.length()==0){
      String t="" ;
      System.out.println(t);
    }
    else {
      System.out.println(answer[ans.length()-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
    var min : int ; min := 51 ;
    var k : int ; k := 51 ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := scan.getCurrent() ; 
     if (s[i+1]->size() < min) then (     min := s[i+1]->size() ; 
     k := i ) else skip )  ;     i := i + 1 ) ; 
    var o : Sequence(String) ; o := s[k+1]->split("") ;
        var i : int ; i := 0 ; while i < min do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (j = k) then (     continue ) else skip ; 
     if (s[j+1]->includes(o[i+1])) then (     s[j+1] := s[j+1].replaceFirstMatch(o[i+1], ".") ; 
     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (count = n - 1) then (     sb := sb + StringLib.newString(o[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    var ans : String ; ans := sb+"" ;
    var answer : Sequence(String) ; answer := ans->split("") ;
    answer := answer->sort() ; 
        var i : int ; i := 0 ; while i < ans->size() - 1 do ( (     OclFile["System.out"].print(answer[i+1]) )  ;     i := i + 1 ) ; 
    if (ans->size() = 0) then (     var t : String ; t := "" ;
     OclFile["System.out"].println(t) ) else (     OclFile["System.out"].println(answer[ans->size() - 1+1]) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Map ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  @ SuppressWarnings("resource")public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    Map<Character,Integer>map=new TreeMap<>();
    for(int i=0 ; i<n ; i++){
      String s=scanner.next();
      for(char c='a' ; c<='z' ; c++){
        int cnt=0 ;
        for(int j=0 ; j<s.length(); j++){
          if(c==s.charAt(j)){
            cnt++;
          }
        }
        if(map.containsKey(c)){
          int tmp=map.get(c);
          tmp=Math.min(tmp,cnt);
          map.put(c,tmp);
        }
        else {
          map.put(c,cnt);
        }
      }
    }
    for(char c : map.keySet()){
      for(int i=0 ; i<map.get(c); i++){
        System.out.print(c);
      }
    }
    System.out.println("");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := scanner.getCurrent() ;
         var c : String ; c := 'a' ; while c <= 'z' do ( (     var cnt : int ; cnt := 0 ;
         var j : int ; j := 0 ; while j < s->size() do ( (     if (c = s->at(j+1)) then (     cnt := cnt + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (map->keys()->includes(c)) then (     var tmp : int ; tmp := map->at(c) ;
     tmp := Set{tmp, cnt}->min() ; 
     map := map->union(Map{c |-> tmp}) ) else (     map := map->union(Map{c |-> cnt}) ) )  ;     c := c + 1 ) )  ;     i := i + 1 ) ; 
    for (c : map->keys()) do ( (         var i : int ; i := 0 ; while i < map->at(c) do ( (     OclFile["System.out"].print(c) )  ;     i := i + 1 ) )  ) ; 
    OclFile["System.out"].println("") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class OddPosition {
  public static long getFinalElement(long n){
    long finalNum ;
    for(finalNum=2 ; finalNum*2<=n ; finalNum*=2);
    return finalNum ;
  }
  public static void main(String[] args){
    int N=12 ;
    System.out.println(getFinalElement(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class OddPosition {
  static   operation getFinalElement( n : long) : long
  pre: true
  post: true
  activity: (     var finalNum : long ;
         finalNum := 2 ; while finalNum * 2 <= n do (   ;     finalNum := finalNum*(2) ) ; 
     return finalNum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 12 ;
     OclFile["System.out"].println(getFinalElement(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  static StringBuilder sb=new StringBuilder();
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String work[]=new String[3];
    int m ;
    int f ;
    int r ;
    try {
      while(true){
        work=br.readLine().split("\\s+");
        m=Integer.parseInt(work[0]);
        f=Integer.parseInt(work[1]);
        r=Integer.parseInt(work[2]);
        if(m==-1 && f==-1 && r==-1){
          break ;
        }
        if(m==-1 || f==-1){
          sb.append("F");
          sb.append(String.format("%n",""));
        }
        else if(m+f>=80){
          sb.append("A");
          sb.append(String.format("%n",""));
        }
        else if(m+f>=65){
          sb.append("B");
          sb.append(String.format("%n",""));
        }
        else if(m+f>=50){
          sb.append("C");
          sb.append(String.format("%n",""));
        }
        else if((m+f>=30)&&(r>=50)){
          sb.append("C");
          sb.append(String.format("%n",""));
        }
        else if(m+f>=30){
          sb.append("D");
          sb.append(String.format("%n",""));
        }
        else {
          sb.append("F");
          sb.append(String.format("%n",""));
        }
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sb : String := StringLib.newString();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var work : Sequence(String) ; work := Integer.subrange(1,3)->collect(null) ;
    var m : int ;
    var f : int ;
    var r : int ;
    try (     while (true) do (     work := br.readLine()->split("\\s+") ; 
     m := (work[0+1])->toInteger() ; 
    f := (work[1+1])->toInteger() ; 
    r := (work[2+1])->toInteger() ; 
    if (m = -1 & f = -1 & r = -1) then (     break ) else skip ; 
    if (m = -1 or f = -1) then (     sb := sb + StringLib.newString("F") ; 
     sb := sb + StringLib.newString(StringLib.format("%n",Sequence{""})) ) else     if (m + f >= 80) then (     sb := sb + StringLib.newString("A") ; 
     sb := sb + StringLib.newString(StringLib.format("%n",Sequence{""})) ) else     if (m + f >= 65) then (     sb := sb + StringLib.newString("B") ; 
     sb := sb + StringLib.newString(StringLib.format("%n",Sequence{""})) ) else     if (m + f >= 50) then (     sb := sb + StringLib.newString("C") ; 
     sb := sb + StringLib.newString(StringLib.format("%n",Sequence{""})) ) else     if ((m + f >= 30) & (r >= 50)) then (     sb := sb + StringLib.newString("C") ; 
     sb := sb + StringLib.newString(StringLib.format("%n",Sequence{""})) ) else     if (m + f >= 30) then (     sb := sb + StringLib.newString("D") ; 
     sb := sb + StringLib.newString(StringLib.format("%n",Sequence{""})) ) else (     sb := sb + StringLib.newString("F") ; 
     sb := sb + StringLib.newString(StringLib.format("%n",Sequence{""})) ) ;  ;  ;  ;  ;  ;  
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.System.*;
class GFG {
  static int findBucketNo(int p){
    return(int)Math.ceil((Math.sqrt(8*p+1)-1)/2);
  }
  public static void main(String[] args){
    int p=10 ;
    System.out.println(findBucketNo(p));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findBucketNo( p : int) : int
  pre: true
  post: true
  activity: (     return (((8 * p + 1)->sqrt() - 1) / 2)->ceil()->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : int ; p := 10 ;
     OclFile["System.out"].println(findBucketNo(p)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static void printPattern(int N){
    for(int i=1 ; i<=N ; i++){
      System.out.print(" "+((i % 2==0)?(i-1):(i+1)));
    }
  }
  public static void main(String args[]){
    int N=10 ;
    printPattern(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printPattern( N : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= N do ( (     OclFile["System.out"].print(" " + (if (i mod 2 = 0) then (i - 1) else (i + 1) endif)) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 10 ;
     execute printPattern(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class MaximumDiffrence {
  int maxDiff(int arr[],int arr_size){
    int max_diff=arr[1]-arr[0];
    int i,j ;
    for(i=0 ; i<arr_size ; i++){
      for(j=i+1 ; j<arr_size ; j++){
        if(arr[j]-arr[i]>max_diff)max_diff=arr[j]-arr[i];
      }
    }
    return max_diff ;
  }
  public static void main(String[] args){
    MaximumDiffrence maxdif=new MaximumDiffrence();
    int arr[]={
      1,2,90,10,110 };
      System.out.println("Maximum differnce is "+maxdif.maxDiff(arr,5));
    }
  }

------------------------------------------------------------
OCL File:
---------
class MaximumDiffrence {
   operation maxDiff( arr : Sequence(int), arr_size : int) : int
  pre: true
  post: true
  activity: (     var max_diff : int ; max_diff := arr[1+1] - arr[0+1] ;
     var i : int ;
    var j : int ;
         i := 0 ; while i < arr_size do ( (         j := i + 1 ; while j < arr_size do ( (     if (arr[j+1] - arr[i+1] > max_diff) then     max_diff := arr[j+1] - arr[i+1] ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return max_diff );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var maxdif : MaximumDiffrence ; maxdif := MaximumDiffrence.newMaximumDiffrence() ;
     var arr : Sequence(int) ; arr := Sequence{1,2,90,10,110} ;
     OclFile["System.out"].println("Maximum differnce is " + maxdif.maxDiff(arr, 5)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws java.io.IOException {
    try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in))){
      final String s=reader.readLine();
      System.out.println(s.contains("2")? "No" : "Yes");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var s : String ; s := reader.readLine() ;
     OclFile["System.out"].println(if s->includes("2") then "No" else "Yes" endif) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(a*b % 2==0){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
    }
  }
}
class Pair implements Comparable {
  int from ;
  int end ;
  int num ;
  int bango ;
  @ Override public int compareTo(Object other){
    Pair otherpair=(Pair)other ;
    return from-otherpair.from ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (a * b mod 2 = 0) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) );
}
class Pair implements OclAny {
   attribute from : int;
   attribute end : int;
   attribute num : int;
   attribute bango : int;
      operation compareTo( other : OclAny) : int
  pre: true
  post: true
  activity: (     var otherpair : Map ; otherpair := other->oclAsType(Map) ;
     return from - otherpair.from );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long arr[]=new long[n];
    long mx=Long.MIN_VALUE,mn=Long.MAX_VALUE,mxCount=0,mnCount=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      mx=Math.max(arr[i],mx);
      mn=Math.min(arr[i],mn);
    }
    for(int i=0 ; i<n ; i++){
      if(arr[i]==mx)mxCount++;
      if(arr[i]==mn)mnCount++;
    }
    if(mx!=mn)System.out.println(mx-mn+" "+mxCount*mnCount);
    else System.out.println(mx-mn+" "+mxCount*(mxCount-1)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
    var mx : long ; mx := "-9223372036854775808"->toLong() ;
    var mn : long ; mn := "9223372036854775807"->toLong() ;
    var mxCount : long ; mxCount := 0 ;
    var mnCount : long ; mnCount := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     mx := Set{arr[i+1], mx}->max() ; 
     mn := Set{arr[i+1], mn}->min() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = mx) then     mxCount := mxCount + 1 ; else skip ; 
     if (arr[i+1] = mn) then     mnCount := mnCount + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (mx /= mn) then     OclFile["System.out"].println(mx - mn + " " + mxCount * mnCount) else     OclFile["System.out"].println(mx - mn + " " + mxCount * (mxCount - 1) / 2) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    BufferedReader in_stream ;
    String in_str ;
    String[] in_str_split ;
    int in_A ;
    int in_B ;
    try {
      in_stream=new BufferedReader(new InputStreamReader(System.in));
      in_str=new String(in_stream.readLine());
      in_str_split=in_str.split(" ");
      in_A=Integer.parseInt(in_str_split[0]);
      in_B=Integer.parseInt(in_str_split[1]);
      if((0!=(in_A % 2))&&(0!=(in_B % 2))){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in_stream : OclFile ;
     var in_str : String ;
    var in_str_split : Sequence(String) ;
    var in_A : int ;
    var in_B : int ;
    try (     in_stream := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     in_str := StringLib.newString(in_stream.readLine()) ; 
    in_str_split := in_str->split(" ") ; 
    in_A := (in_str_split[0+1])->toInteger() ; 
    in_B := (in_str_split[1+1])->toInteger() ; 
    if ((0 /= (in_A mod 2)) & (0 /= (in_B mod 2))) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(a==2 || b==2){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (a = 2 or b = 2) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(a*b % 2==1 || a*b*3 % 2==1)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (a * b mod 2 = 1 or a * b * 3 mod 2 = 1) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int CntDivbyX(int arr[],int n,int x){
    int number=0 ;
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      number=(number*2+arr[i])% x ;
      if(number==0)count+=1 ;
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      1,0,1,0,1,1,0 };
      int n=7 ;
      int x=2 ;
      System.out.print(CntDivbyX(arr,n,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation CntDivbyX( arr : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var number : int ; number := 0 ;
     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     number := (number * 2 + arr[i+1]) mod x ; 
     if (number = 0) then     count := count+(1) ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,0,1,0,1,1,0} ;
     var n : int ; n := 7 ;
     var x : int ; x := 2 ;
     OclFile["System.out"].print(CntDivbyX(arr, n, x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int[] status=new int[100000];
  static int countSteps(int[] val,int n){
    int sol=0 ;
    Vector<Integer>vec=new Vector<>(1);
    vec.add(0);
    status[0]=-1 ;
    for(int i=1 ; i<n ; ++i){
      status[i]=0 ;
      while(vec.size()>0 && val[vec.lastElement()]>=val[i]){
        status[i]=Math.max(status[i],status[vec.lastElement()]+1);
        vec.remove(vec.lastElement());
      }
      if(vec.isEmpty()){
        status[i]=-1 ;
      }
      vec.add(i);
      sol=Math.max(sol,status[i]+1);
    }
    return sol ;
  }
  public static void main(String[] args){
    int val[]={
      6,5,8,4,7,10,9 };
      int n=val.length ;
      System.out.println(countSteps(val,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute status : Sequence(int) := Integer.subrange(1,100000)->collect(0);
  static   operation countSteps( val : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sol : int ; sol := 0 ;
     var vec : Sequence(int) ; vec := Sequence{} ;
    vec := vec->including(0) ; 
    status[0+1] := -1 ; 
        var i : int ; i := 1 ; while i < n do ( (     status[i+1] := 0 ; 
     while (vec->size() > 0 & val[vec->last()+1] >= val[i+1]) do (     status[i+1] := Set{status[i+1], status[vec->last()+1] + 1}->max() ; 
     vec := vec->excludingFirst(vec->last()) ) ; 
    if (vec->isEmpty()) then (     status[i+1] := -1 ) else skip ; 
    vec := vec->including(i) ; 
    sol := Set{sol, status[i+1] + 1}->max() ; 
 )  ;     i := i + 1 ) ; 
    return sol 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var val : Sequence(int) ; val := Sequence{6,5,8,4,7,10,9} ;
     var n : int ; n := val->size() ;
     OclFile["System.out"].println(countSteps(val, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int mod=1000000007 ;
  static int sumOddFibonacci(int n){
    int Sum[]=new int[n+1];
    Sum[0]=0 ;
    Sum[1]=1 ;
    Sum[2]=2 ;
    Sum[3]=5 ;
    Sum[4]=10 ;
    Sum[5]=23 ;
    for(int i=6 ; i<=n ; i++){
      Sum[i]=((Sum[i-1]+(4*Sum[i-2])% mod-(4*Sum[i-3])% mod+mod)% mod+(Sum[i-4]-Sum[i-5]+mod)% mod)% mod ;
    }
    return Sum[n];
  }
  public static void main(String[] args){
    int n=6 ;
    System.out.println(sumOddFibonacci(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute mod : int := 1000000007;
  static   operation sumOddFibonacci( n : int) : int
  pre: true
  post: true
  activity: (     var Sum : Sequence(int) ; Sum := Integer.subrange(1,n + 1)->collect(0) ;
     Sum[0+1] := 0 ; 
    Sum[1+1] := 1 ; 
    Sum[2+1] := 2 ; 
    Sum[3+1] := 5 ; 
    Sum[4+1] := 10 ; 
    Sum[5+1] := 23 ; 
        var i : int ; i := 6 ; while i <= n do ( (     Sum[i+1] := ((Sum[i - 1+1] + (4 * Sum[i - 2+1]) mod mod - (4 * Sum[i - 3+1]) mod mod + mod) mod mod + (Sum[i - 4+1] - Sum[i - 5+1] + mod) mod mod) mod mod )  ;     i := i + 1 ) ; 
    return Sum[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(sumOddFibonacci(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    ArrayList<Integer>l=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      int v=in.nextInt();
      if(! l.contains(v)){
        l.add(v);
      }
    }
    HashSet<Integer>set=new HashSet<>(l);
    if(n<=2){
      if(set.size()==1){
        pw.println(-1);
      }
      else {
        pw.println(1);
        int min=Collections.min(l);
        pw.println(l.indexOf(min)+1);
      }
    }
    else {
      pw.println(1);
      int min=Collections.min(l);
      pw.println(l.indexOf(min)+1);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := in.getCurrent()->toInteger() ;
     if (not(l->includes(v))) then (     l := l->including(v) ) else skip )  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{}->union(l) ;
    if (n <= 2) then (     if (set->size() = 1) then (     skip ) else (     skip ; 
     var min : int ; min := .min(l) ;
     skip ) ) else (     skip ; 
     var min : int ; min := .min(l) ;
     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    ArrayList<Integer>l=new ArrayList<>();
    Integer a[]=new Integer[n];
    for(int i=0 ; i<n ; i++){
      int v=in.nextInt();
      a[i]=v ;
      l.add(v);
    }
    HashSet<Integer>set=new HashSet<>(l);
    if(set.size()==1){
      if(n<=2){
        pw.println(-1);
      }
      else {
        pw.println(1);
        int min=(int)Collections.min(Arrays.asList(a));
        for(int i=0 ; i<n ; i++){
          if(a[i]==min){
            pw.println(i+1);
            break ;
          }
        }
      }
    }
    else {
      pw.println(1);
      int min=(int)Collections.min(Arrays.asList(a));
      for(int i=0 ; i<n ; i++){
        if(a[i]==min){
          pw.println(i+1);
          break ;
        }
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Sequence{} ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := in.getCurrent()->toInteger() ;
     a[i+1] := v ; 
     l := l->including(v) )  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{}->union(l) ;
    if (set->size() = 1) then (     if (n <= 2) then (     skip ) else (     skip ; 
     var min : int ; min := .min(a)->oclAsType(int) ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = min) then (     skip ; 
     break ) else skip )  ;     i := i + 1 ) ) ) else (     skip ; 
     var min : int ; min := .min(a)->oclAsType(int) ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = min) then (     skip ; 
     break ) else skip )  ;     i := i + 1 ) ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Andrey {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int packets=sc.nextInt();
    ArrayList<Integer>balloon=new ArrayList<Integer>();
    for(int x=0 ; x<packets ; x++){
      balloon.add(sc.nextInt());
    }
    if(packets==2){
      if(balloon.get(0)==balloon.get(1))System.out.println(-1);
      else {
        System.out.println(1);
        System.out.println(1);
      }
    }
    if(packets==1){
      System.out.println(-1);
    }
    int min=1000000000 ;
    int index=0 ;
    for(int i=0 ; i<balloon.size(); i++){
      if(balloon.get(i)<min){
        min=balloon.get(i);
        index=i ;
      }
    }
    if(packets>2){
      System.out.println(1);
      System.out.println(index+1);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Andrey {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var packets : int ; packets := sc.getCurrent()->toInteger() ;
    var balloon : Sequence(int) ; balloon := Sequence{} ;
        var x : int ; x := 0 ; while x < packets do ( (     balloon := balloon->including(sc.getCurrent()->toInteger()) )  ;     x := x + 1 ) ; 
    if (packets = 2) then (     if (balloon->at(0+1) = balloon->at(1+1)) then     OclFile["System.out"].println(-1) ; else (     OclFile["System.out"].println(1) ; 
     OclFile["System.out"].println(1) ) ) else skip ; 
    if (packets = 1) then (     OclFile["System.out"].println(-1) ) else skip ; 
    var min : int ; min := 1000000000 ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < balloon->size() do ( (     if (balloon->at(i+1) < min) then (     min := balloon->at(i+1) ; 
     index := i ) else skip )  ;     i := i + 1 ) ; 
    if (packets > 2) then (     OclFile["System.out"].println(1) ; 
     OclFile["System.out"].println(index + 1) ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.InputStream ;
import java.nio.channels.Channel ;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    if(n<2){
      System.out.println(-1);
      return ;
    }
    int[] arr=new int[n];
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=scan.nextInt();
      sum+=arr[i];
    }
    for(int i=0 ; i<n ; i++){
      if(sum-arr[i]!=arr[i]){
        StringBuilder sb=new StringBuilder();
        sb.append(n-1);
        sb.append("\n");
        for(int j=0 ; j<n ; j++){
          if(j==i)continue ;
          sb.append(j+1);
          sb.append(" ");
        }
        System.out.println(sb.toString());
        return ;
      }
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    if (n < 2) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scan.getCurrent()->toInteger() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (sum - arr[i+1] /= arr[i+1]) then (     var sb : String ; sb := StringLib.newString() ;
     sb := sb + StringLib.newString(n - 1) ; 
    sb := sb + StringLib.newString("\n") ; 
        var j : int ; j := 0 ; while j < n do ( (     if (j = i) then     continue else skip ; 
     sb := sb + StringLib.newString(j + 1) ; 
     sb := sb + StringLib.newString(" ") )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
    return 
 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int N=in.nextInt();
    int[] A=new int[N];
    for(int n=0 ; n<N ; n++){
      A[n]=in.nextInt();
    }
    Arrays.sort(A);
    int min=A[0];
    int max=A[N-1];
    long mins=0 ;
    long maxs=0 ;
    for(int value : A){
      if(value==min)mins++;
      if(value==max)maxs++;
    }
    if(min==max){
      pw.println((max-min)+" "+mins*(mins-1)/2);
    }
    else {
      pw.println((max-min)+" "+mins*maxs);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    A := A->sort() ; 
    var min : int ; min := A[0+1] ;
    var max : int ; max := A[N - 1+1] ;
    var mins : long ; mins := 0 ;
    var maxs : long ; maxs := 0 ;
    for (value : A) do ( (     if (value = min) then     mins := mins + 1 ; else skip ; 
     if (value = max) then     maxs := maxs + 1 ; else skip )  ) ; 
    if (min = max) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static long sumAP(long n,long d){
    n/=d ;
    return(n)*(1+n)*d/2 ;
  }
  static long sumMultiples(long n){
    n--;
    return sumAP(n,3)+sumAP(n,7)-sumAP(n,21);
  }
  public static void main(String args[]){
    long n=24 ;
    System.out.println(sumMultiples(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation sumAP( n : long, d : long) : long
  pre: true
  post: true
  activity: (     n := n/(d) ; 
     return (n) * (1 + n) * d / 2 );
  static   operation sumMultiples( n : long) : long
  pre: true
  post: true
  activity: (     n := n - 1 ; 
     return sumAP(n, 3) + sumAP(n, 7) - sumAP(n, 21) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 24 ;
     OclFile["System.out"].println(sumMultiples(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeforcesc {
  static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int gg=gcd(a,b);
      if(gg==1)System.out.println("Finite");
      else System.out.println("Infinite");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforcesc {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     var gg : int ; gg := gcd(a, b) ;
     if (gg = 1) then     OclFile["System.out"].println("Finite") ; else     OclFile["System.out"].println("Infinite") ; ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Sol {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int a=sc.nextInt();
      int b=sc.nextInt();
      if(gcd(a,b)==1)System.out.println("Finite");
      else System.out.println("Infinite");
    }
    sc.close();
  }
  private static int gcd(int a,int b){
    int t ;
    while(b!=0){
      t=a ;
      a=b ;
      b=t % b ;
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sol {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (gcd(a, b) = 1) then     OclFile["System.out"].println("Finite") ; else     OclFile["System.out"].println("Infinite") ; ) ;  ) ;  
     skip );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var t : int ;
     while (b /= 0) do (     t := a ; 
     a := b ; 
     b := t mod b ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class GoodolNumbersColoring {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int wh=sc.nextInt();
    while(wh>0){
      int a=sc.nextInt(),b=sc.nextInt();
      if(a==1 || b==1){
        System.out.println("finite");
        wh--;
        continue ;
      }
      while(b!=0){
        int temp=b ;
        b=a % b ;
        a=temp ;
      }
      if(a==1){
        System.out.println("finite");
      }
      else {
        System.out.println("infinite");
      }
      wh--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GoodolNumbersColoring {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var wh : int ; wh := sc.getCurrent()->toInteger() ;
     while (wh > 0) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
     if (a = 1 or b = 1) then (     OclFile["System.out"].println("finite") ; 
     wh := wh - 1 ; 
     continue ) else skip ; 
    while (b /= 0) do (     var temp : int ; temp := b ;
     b := a mod b ; 
     a := temp ) ; 
    if (a = 1) then (     OclFile["System.out"].println("finite") ) else (     OclFile["System.out"].println("infinite") ) ;  
    wh := wh - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String args[])throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int test=Integer.parseInt(br.readLine());
    while(test-->0){
      String[] tokens=br.readLine().split(" ");
      int a=Integer.parseInt(tokens[0]);
      int b=Integer.parseInt(tokens[1]);
      if(lcm(a,b)==a*b){
        System.out.println("Finite");
      }
      else {
        System.out.println("Infinite");
      }
    }
  }
  private static int lcm(int a,int b){
    return(a*b)/gcd(Math.max(a,b),Math.min(a,b));
  }
  private static int gcd(int max,int min){
    return min==0 ? max : gcd(min,max % min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var test : int ; test := (br.readLine())->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var tokens : Sequence(String) ; tokens := br.readLine()->split(" ") ;
     var a : int ; a := (tokens[0+1])->toInteger() ;
     var b : int ; b := (tokens[1+1])->toInteger() ;
     if (lcm(a, b) = a * b) then (     OclFile["System.out"].println("Finite") ) else (     OclFile["System.out"].println("Infinite") ) ) ;  ) );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return (a * b) / gcd(Set{a, b}->max(), Set{a, b}->min()) );
  static   operation gcd( max : int, min : int) : int
  pre: true
  post: true
  activity: (     return if min = 0 then max else gcd(min, max mod min) endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Set ;
public final class p095 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p095().run());
  }
  private static final int LIMIT=Library.pow(10,6);
  public String run(){
    int[] divisorSum=new int[LIMIT+1];
    for(int i=1 ; i<=LIMIT ; i++){
      for(int j=i*2 ; j<=LIMIT ; j+=i)divisorSum[j]+=i ;
    }
    int maxChainLen=0 ;
    int minChainElem=-1 ;
    for(int i=0 ; i<=LIMIT ; i++){
      Set<Integer>visited=new HashSet<>();
      for(int count=1,cur=i ; ; count++){
        visited.add(cur);
        int next=divisorSum[cur];
        if(next==i){
          if(count>maxChainLen){
            minChainElem=i ;
            maxChainLen=count ;
          }
          break ;
        }
        else if(next>LIMIT || visited.contains(next))break ;
        else cur=next ;
      }
    }
    return Integer.toString(minChainElem);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p095 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p095.newp095().run()) );
  static    attribute LIMIT : int := Library.pow(10, 6);
   operation run() : String
  pre: true
  post: true
  activity: (     var divisorSum : Sequence(int) ; divisorSum := Integer.subrange(1,LIMIT + 1)->collect(0) ;
         var i : int ; i := 1 ; while i <= LIMIT do ( (         var j : int ; j := i * 2 ; while j <= LIMIT do (     divisorSum[j+1] := divisorSum[j+1]+(i) ;  ;     j := j+(i) ) )  ;     i := i + 1 ) ; 
    var maxChainLen : int ; maxChainLen := 0 ;
    var minChainElem : int ; minChainElem := -1 ;
        var i : int ; i := 0 ; while i <= LIMIT do ( (     var visited : Set(int) ; visited := Set{} ;
         var count : int ; count := 1 ;
    var cur : int ; cur := i ; while true do ( (     visited := visited->including(cur) ; 
     var next : int ; next := divisorSum[cur+1] ;
     if (next = i) then (     if (count > maxChainLen) then (     minChainElem := i ; 
     maxChainLen := count ) else skip ; 
     break ) else     if (next > LIMIT or visited->includes(next)) then     break else     cur := next ; ;  )  ;     count := count + 1 ) )  ;     i := i + 1 ) ; 
    return ((minChainElem) + "") 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long answer(int n){
    int[] dp=new int[10];
    int[] prev=new int[10];
    if(n==1)return 10 ;
    for(int j=0 ; j<=9 ; j++)dp[j]=1 ;
    for(int i=2 ; i<=n ; i++){
      for(int j=0 ; j<=9 ; j++){
        prev[j]=dp[j];
      }
      for(int j=0 ; j<=9 ; j++){
        if(j==0)dp[j]=prev[j+1];
        else if(j==9)dp[j]=prev[j-1];
        else dp[j]=prev[j-1]+prev[j+1];
      }
    }
    long sum=0 ;
    for(int j=1 ; j<=9 ; j++)sum+=dp[j];
    return sum ;
  }
  public static void main(String[] args){
    int n=2 ;
    System.out.println(answer(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation answer( n : int) : long
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,10)->collect(0) ;
     var prev : Sequence(int) ; prev := Integer.subrange(1,10)->collect(0) ;
    if (n = 1) then     return 10 else skip ; 
        var j : int ; j := 0 ; while j <= 9 do (     dp[j+1] := 1 ;  ;     j := j + 1 ) ; 
        var i : int ; i := 2 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= 9 do ( (     prev[j+1] := dp[j+1] )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j <= 9 do ( (     if (j = 0) then     dp[j+1] := prev[j + 1+1] ; else     if (j = 9) then     dp[j+1] := prev[j - 1+1] else     dp[j+1] := prev[j - 1+1] + prev[j + 1+1] ; ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var j : int ; j := 1 ; while j <= 9 do (     sum := sum+(dp[j+1]) ;  ;     j := j + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(answer(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class xr {
  public static void main(String[] args){
    int res=1 ;
    Scanner sc=new Scanner(System.in);
    int[] a=new int[10];
    a[0]=2 ;
    a[1]=7 ;
    a[2]=2 ;
    a[3]=3 ;
    a[4]=3 ;
    a[5]=4 ;
    a[6]=2 ;
    a[7]=5 ;
    a[8]=1 ;
    a[9]=2 ;
    String s=sc.next();
    for(int i=0 ; i<s.length(); i++){
      int x=s.charAt(i)-'0' ;
      res=res*a[x];
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class xr {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var a : Sequence(int) ; a := Integer.subrange(1,10)->collect(0) ;
    a[0+1] := 2 ; 
    a[1+1] := 7 ; 
    a[2+1] := 2 ; 
    a[3+1] := 3 ; 
    a[4+1] := 3 ; 
    a[5+1] := 4 ; 
    a[6+1] := 2 ; 
    a[7+1] := 5 ; 
    a[8+1] := 1 ; 
    a[9+1] := 2 ; 
    var s : String ; s := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var x : int ; x := s->at(i+1) - ('0')->char2byte() ;
     res := res * a[x+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.time.chrono.MinguoChronology ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Hashtable ;
import java.util.Stack ;
import java.util.StringTokenizer ;
import java.util.TreeMap ;
import javax.xml.namespace.QName ;
public class A {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    HashMap<Integer,Integer>vals=new HashMap<Integer,Integer>();
    vals.put(0,2);
    vals.put(1,7);
    vals.put(2,2);
    vals.put(3,3);
    vals.put(4,3);
    vals.put(5,4);
    vals.put(6,2);
    vals.put(7,5);
    vals.put(8,1);
    vals.put(9,2);
    int n=sc.nextInt();
    int f=n/10 ;
    int s=n % 10 ;
    System.out.println(vals.get(f)*vals.get(s));
  }
}
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 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var vals : Map(int,int) ; vals := Map{} ;
    vals := vals->union(Map{0 |-> 2}) ; 
    vals := vals->union(Map{1 |-> 7}) ; 
    vals := vals->union(Map{2 |-> 2}) ; 
    vals := vals->union(Map{3 |-> 3}) ; 
    vals := vals->union(Map{4 |-> 3}) ; 
    vals := vals->union(Map{5 |-> 4}) ; 
    vals := vals->union(Map{6 |-> 2}) ; 
    vals := vals->union(Map{7 |-> 5}) ; 
    vals := vals->union(Map{8 |-> 1}) ; 
    vals := vals->union(Map{9 |-> 2}) ; 
    var n : int ; n := sc.nextInt() ;
    var f : int ; f := n / 10 ;
    var s : int ; s := n mod 10 ;
    OclFile["System.out"].println(vals->at(f) * vals->at(s)) ; 
 );
}
class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n ;
    n=in.nextInt();
    int fdigit,sdigit ;
    fdigit=n/10 ;
    sdigit=n % 10 ;
    int fmult=0,smult=0 ;
    switch(fdigit){
      case 0 : fmult=2 ;
      break ;
      case 1 : fmult=7 ;
      break ;
      case 2 : fmult=2 ;
      break ;
      case 3 : fmult=3 ;
      break ;
      case 4 : fmult=3 ;
      break ;
      case 5 : fmult=4 ;
      break ;
      case 6 : fmult=2 ;
      break ;
      case 7 : fmult=5 ;
      break ;
      case 8 : fmult=1 ;
      break ;
      case 9 : fmult=2 ;
      break ;
    }
    switch(sdigit){
      case 0 : smult=2 ;
      break ;
      case 1 : smult=7 ;
      break ;
      case 2 : smult=2 ;
      break ;
      case 3 : smult=3 ;
      break ;
      case 4 : smult=3 ;
      break ;
      case 5 : smult=4 ;
      break ;
      case 6 : smult=2 ;
      break ;
      case 7 : smult=5 ;
      break ;
      case 8 : smult=1 ;
      break ;
      case 9 : smult=2 ;
      break ;
    }
    System.out.println(fmult*smult);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    n := in.getCurrent()->toInteger() ; 
    var fdigit : int ;
    var sdigit : int ;
    fdigit := n / 10 ; 
    sdigit := n mod 10 ; 
    var fmult : int ; fmult := 0 ;
    var smult : int ; smult := 0 ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (fdigit) ; 
       if _switchval = 0 then
     fmult := 2 ; 
    break 
   else skip ;
       if _switchval = 1 then
     fmult := 7 ; 
    break 
   else skip ;
       if _switchval = 2 then
     fmult := 2 ; 
    break 
   else skip ;
       if _switchval = 3 then
     fmult := 3 ; 
    break 
   else skip ;
       if _switchval = 4 then
     fmult := 3 ; 
    break 
   else skip ;
       if _switchval = 5 then
     fmult := 4 ; 
    break 
   else skip ;
       if _switchval = 6 then
     fmult := 2 ; 
    break 
   else skip ;
       if _switchval = 7 then
     fmult := 5 ; 
    break 
   else skip ;
       if _switchval = 8 then
     fmult := 1 ; 
    break 
   else skip ;
       if _switchval = 9 then
     fmult := 2 ; 
    break 
   else skip ;
 )
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (sdigit) ; 
       if _switchval = 0 then
     smult := 2 ; 
    break 
   else skip ;
       if _switchval = 1 then
     smult := 7 ; 
    break 
   else skip ;
       if _switchval = 2 then
     smult := 2 ; 
    break 
   else skip ;
       if _switchval = 3 then
     smult := 3 ; 
    break 
   else skip ;
       if _switchval = 4 then
     smult := 3 ; 
    break 
   else skip ;
       if _switchval = 5 then
     smult := 4 ; 
    break 
   else skip ;
       if _switchval = 6 then
     smult := 2 ; 
    break 
   else skip ;
       if _switchval = 7 then
     smult := 5 ; 
    break 
   else skip ;
       if _switchval = 8 then
     smult := 1 ; 
    break 
   else skip ;
       if _switchval = 9 then
     smult := 2 ; 
    break 
   else skip ;
 )
    OclFile["System.out"].println(fmult * smult) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int Maxsum(int c1,int c2,int c3,int c4){
    int sum=0 ;
    int two34=Math.min(c2,Math.min(c3,c4));
    sum=two34*234 ;
    c2-=two34 ;
    sum+=Math.min(c2,c1)*12 ;
    return sum ;
  }
  public static void main(String[] args){
    int c1=5,c2=2,c3=3,c4=4 ;
    System.out.println(Maxsum(c1,c2,c3,c4));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Maxsum( c1 : int, c2 : int, c3 : int, c4 : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var two34 : int ; two34 := Set{c2, Set{c3, c4}->min()}->min() ;
    sum := two34 * 234 ; 
    c2 := c2-(two34) ; 
    sum := sum+(Set{c2, c1}->min() * 12) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var c1 : int ; c1 := 5 ;
    var c2 : int ; c2 := 2 ;
    var c3 : int ; c3 := 3 ;
    var c4 : int ; c4 := 4 ;
     OclFile["System.out"].println(Maxsum(c1, c2, c3, c4)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeforces52B {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    int m=Integer.parseInt(st.nextToken());
    int[] rows=new int[n];
    int[] columns=new int[m];
    char[][] arr=new char[n][m];
    for(int a=0 ; a<n ; a++){
      String str=br.readLine();
      for(int b=0 ; b<m ; b++){
        arr[a][b]=str.charAt(b);
        if(arr[a][b]=='*'){
          rows[a]++;
          columns[b]++;
        }
      }
    }
    long count=0 ;
    for(int a=0 ; a<n ; a++){
      for(int b=0 ; b<m ; b++){
        if(arr[a][b]=='*'){
          if(rows[a]-1>0 && columns[b]-1>0){
            count+=(rows[a]-1)*(columns[b]-1);
          }
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces52B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var rows : Sequence(int) ; rows := Integer.subrange(1,n)->collect(0) ;
    var columns : Sequence(int) ; columns := Integer.subrange(1,m)->collect(0) ;
    var arr : Sequence(Sequence(String)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var a : int ; a := 0 ; while a < n do ( (     var str : String ; str := br.readLine() ;
         var b : int ; b := 0 ; while b < m do ( (     arr[a+1][b+1] := str->at(b+1) ; 
     if (arr[a+1][b+1] = '*') then (     rows[a+1] := rows[a+1] + 1 ; 
     columns[b+1] := columns[b+1] + 1 ) else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    var count : long ; count := 0 ;
        var a : int ; a := 0 ; while a < n do ( (         var b : int ; b := 0 ; while b < m do ( (     if (arr[a+1][b+1] = '*') then (     if (rows[a+1] - 1 > 0 & columns[b+1] - 1 > 0) then (     count := count+((rows[a+1] - 1) * (columns[b+1] - 1)) ) else skip ) else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    int m=Integer.parseInt(st.nextToken());
    char[][] in=new char[n][m];
    for(int i=0 ; i<n ; i++){
      in[i]=br.readLine().toCharArray();
    }
    int[] rows=new int[n];
    int[] columns=new int[m];
    for(int i=0 ; i<n ; i++){
      int c=0 ;
      for(int j=0 ; j<m ; j++){
        if(in[i][j]=='*')c++;
      }
      rows[i]=c ;
    }
    for(int i=0 ; i<m ; i++){
      int c=0 ;
      for(int j=0 ; j<n ; j++){
        if(in[j][i]=='*')c++;
      }
      columns[i]=c ;
    }
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(in[i][j]=='*'){
          long r=rows[i]-1 ;
          long c=columns[j]-1 ;
          ans+=r*c ;
        }
      }
    }
    pw.println(ans);
    pw.close();
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var in : Sequence(Sequence(String)) ; in := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     in[i+1] := br.readLine()->characters() )  ;     i := i + 1 ) ; 
    var rows : Sequence(int) ; rows := Integer.subrange(1,n)->collect(0) ;
    var columns : Sequence(int) ; columns := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var c : int ; c := 0 ;
         var j : int ; j := 0 ; while j < m do ( (     if (in[i+1][j+1] = '*') then     c := c + 1 ; else skip )  ;     j := j + 1 ) ; 
     rows[i+1] := c )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var c : int ; c := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (in[j+1][i+1] = '*') then     c := c + 1 ; else skip )  ;     j := j + 1 ) ; 
     columns[i+1] := c )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (in[i+1][j+1] = '*') then (     var r : long ; r := rows[i+1] - 1 ;
     var c : long ; c := columns[j+1] - 1 ;
     ans := ans+(r * c) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
import java.util.Collections ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    scan.nextLine();
    int[][] stars=new int[n][m];
    int[] cntH=new int[m];
    int[] cntV=new int[n];
    for(int i=0 ; i<n ; i++){
      String l=scan.nextLine();
      for(int j=0 ; j<m ; j++){
        int yes=l.charAt(j)=='*' ? 1 : 0 ;
        stars[i][j]=yes ;
        cntH[j]+=yes ;
        cntV[i]+=yes ;
      }
    }
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(stars[i][j]==1){
          ans+=(cntH[j]-1)*(cntV[i]-1);
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    skip ; 
    var stars : Sequence(Sequence(int)) ; stars := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var cntH : Sequence(int) ; cntH := Integer.subrange(1,m)->collect(0) ;
    var cntV : Sequence(int) ; cntV := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var l : String ; l := scan.nextLine() ;
         var j : int ; j := 0 ; while j < m do ( (     var yes : int ; yes := if l->at(j+1) = '*' then 1 else 0 endif ;
     stars[i+1][j+1] := yes ; 
     cntH[j+1] := cntH[j+1]+(yes) ; 
     cntV[i+1] := cntV[i+1]+(yes) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (stars[i+1][j+1] = 1) then (     ans := ans+((cntH[j+1] - 1) * (cntV[i+1] - 1)) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void ifPossible(int X,int Y){
    if(X>Y)swap(X,Y);
    if((X+Y)% 5==0 && 3*X>=2*Y)System.out.print("Yes");
    else System.out.print("No");
  }
  static void swap(int x,int y){
    int temp=x ;
    x=y ;
    y=temp ;
  }
  public static void main(String[] args){
    int X=33,Y=27 ;
    ifPossible(X,Y);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation ifPossible( X : int, Y : int) : void
  pre: true
  post: true
  activity: (     if (X > Y) then     execute swap(X, Y) ; else skip ; 
     if ((X + Y) mod 5 = 0 & 3 * X >= 2 * Y) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
  static   operation swap( x : int, y : int) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := x ;
     x := y ; 
     y := temp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 33 ;
    var Y : int ; Y := 27 ;
     execute ifPossible(X, Y) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class trailzero {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    StringBuilder st=new StringBuilder(s);
    int n=sc.nextInt();
    int j=s.length()-1 ;
    int c=0 ;
    int num=(int)Math.pow(10,n);
    while(Integer.valueOf(st.toString())% num!=0 && j>0){
      if(s.charAt(j)=='0'){
      }
      else {
        st.deleteCharAt(j);
        c++;
      }
      j--;
    }
    if(n>=s.length()||(j==0 && Integer.valueOf(st.toString())% num!=0)){
      System.out.println(s.length()-1);
    }
    else {
      System.out.println(c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class trailzero {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var st : String ; st := StringLib.newString(s) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var j : int ; j := s->size() - 1 ;
    var c : int ; c := 0 ;
    var num : int ; num := 10->pow(n)->oclAsType(int) ;
    while ((st+"")->toInteger() mod num /= 0 & j > 0) do (     if (s->at(j+1) = '0') then skip else (     st := st->excludingAt(j+1) ; 
     c := c + 1 ) ;  
     j := j - 1 ) ; 
    if (n >= s->size() or (j = 0 & (st+"")->toInteger() mod num /= 0)) then (     OclFile["System.out"].println(s->size() - 1) ) else (     OclFile["System.out"].println(c) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Practice {
  static Scanner scn=new Scanner(System.in);
  static StringBuilder sb=new StringBuilder();
  public static void main(String[] HastaLaVistaLa){
    int t=1 ;
    for(int tests=0 ; tests<t ; tests++)solve();
    System.out.println(sb);
  }
  public static void solve(){
    String s=scn.next();
    int k=scn.nextInt(),t=k ;
    char[] ch=s.toCharArray();
    int n=ch.length ;
    int res=n-1 ;
    for(int i=n-1 ; i>=0 ; i--)if(ch[i]=='0'){
      k--;
      if(k==0){
        sb.append(n-i-t);
        return ;
      }
    }
    sb.append(res);
  }
  public static void go(String s,String t){
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   attribute scn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute sb : String := StringLib.newString();
  static   operation main( HastaLaVistaLa : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
         var tests : int ; tests := 0 ; while tests < t do (     execute solve() ;  ;     tests := tests + 1 ) ; 
     OclFile["System.out"].println(sb) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var s : String ; s := scn.getCurrent() ;
     var k : int ; k := scn.getCurrent()->toInteger() ;
    var t : int ; t := k ;
    var ch : Sequence(String) ; ch := s->characters() ;
    var n : int ; n := ch->size() ;
    var res : int ; res := n - 1 ;
        var i : int ; i := n - 1 ; while i >= 0 do (     if (ch[i+1] = '0') then (     k := k - 1 ; 
     if (k = 0) then (     sb := sb + StringLib.newString(n - i - (t)->char2byte()) ; 
     return ) else skip ) else skip ;  ;     i := i - 1 ) ; 
    sb := sb + StringLib.newString(res) ; 
 );
  static   operation go( s : String, t : String) : void
  pre: true
  post: true
  activity: skip;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int __gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static int getFib(int n){
    int f[]=new int[n+2];
    int i ;
    f[0]=0 ;
    f[1]=1 ;
    for(i=2 ; i<=n ; i++){
      f[i]=f[i-1]+f[i-2];
    }
    return f[n];
  }
  static int find(int arr[],int n){
    int gcd_1=0 ;
    for(int i=0 ; i<n ; i++){
      gcd_1=__gcd(gcd_1,arr[i]);
    }
    return getFib(gcd_1);
  }
  public static void main(String[] args){
    int indices[]={
      3,6,9 };
      int N=indices.length ;
      System.out.println(find(indices,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
    if (a = b) then     return a else skip ; 
    if (a > b) then     return __gcd(a - b, b) else skip ; 
    return __gcd(a, b - a) 
 );
  static   operation getFib( n : int) : int
  pre: true
  post: true
  activity: (     var f : Sequence(int) ; f := Integer.subrange(1,n + 2)->collect(0) ;
     var i : int ;
    f[0+1] := 0 ; 
    f[1+1] := 1 ; 
        i := 2 ; while i <= n do ( (     f[i+1] := f[i - 1+1] + f[i - 2+1] )  ;     i := i + 1 ) ; 
    return f[n+1] 
 );
  static   operation find( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var gcd    var gcdint : int ; gcdint := 0 : int ; gcd    var gcdint : int ; gcdint := 0 := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     gcdgcd    gcdgcd    gcdgcd_1 := __gcd(gcdgcd_1, arr[i+1]) ; 
 := __gcd(gcdgcd    gcdgcd_1 := __gcd(gcdgcd_1, arr[i+1]) ; 
, arr[i+1]) ; := __gcd(gcdgcd    gcdgcd    gcdgcd_1 := __gcd(gcdgcd_1, arr[i+1]) ; 
 := __gcd(gcdgcd    gcdgcd_1 := __gcd(gcdgcd_1, arr[i+1]) ; 
, arr[i+1]) ;, arr[i+1]) )  ;     i := i + 1 ) ; 
     return getFib(gcd    return getFib(gcd    var gcd    var gcdint : int ; gcdint := 0 : int ; gcd    var gcdint : int ; gcdint := 0 := 0 ;
)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var indices : Sequence(int) ; indices := Sequence{3,6,9} ;
     var N : int ; N := indices->size() ;
     OclFile["System.out"].println(find(indices, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class pre551 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    String s=obj.next();
    int k=obj.nextInt();
    int zero=0,del=0,n=s.length();
    for(int i=n-1 ; i>=0 ; i--){
      if(s.charAt(i)=='0')zero++;
      else del++;
      if(zero==k)break ;
    }
    if(zero<k)System.out.println(n-1);
    else System.out.print(del);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre551 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var s : String ; s := obj.next() ;
    var k : int ; k := obj.nextInt() ;
    var zero : int ; zero := 0 ;
    var del : int ; del := 0 ;
    var n : int ; n := s->size() ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (s->at(i+1) = '0') then     zero := zero + 1 else     del := del + 1 ; ;  
     if (zero = k) then     break else skip )  ;     i := i - 1 ) ; 
    if (zero < k) then     OclFile["System.out"].println(n - 1) else     OclFile["System.out"].print(del) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class pre551 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    String s=obj.next();
    int k=obj.nextInt();
    int zero=0,del=0,n=s.length();
    for(int i=n-1 ; i>=0 ; i--){
      if(s.charAt(i)=='0')zero++;
      else del++;
      if(zero==k)break ;
    }
    if(zero<k)System.out.println(n-1);
    else System.out.println(del);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre551 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var s : String ; s := obj.next() ;
    var k : int ; k := obj.nextInt() ;
    var zero : int ; zero := 0 ;
    var del : int ; del := 0 ;
    var n : int ; n := s->size() ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (s->at(i+1) = '0') then     zero := zero + 1 else     del := del + 1 ; ;  
     if (zero = k) then     break else skip )  ;     i := i - 1 ) ; 
    if (zero < k) then     OclFile["System.out"].println(n - 1) else     OclFile["System.out"].println(del) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Rounding779B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long num=in.nextLong();
    int k=in.nextInt();
    String s=String.valueOf(num);
    StringBuffer sb=new StringBuffer(s);
    int length=s.length();
    long pow=(long)Math.pow(10,k);
    if(k>length-1){
      System.out.println(length-1);
      return ;
    }
    int ans=0 ;
    for(int i=length-1 ; i>=0 ; i--){
      if(Integer.parseInt(String.valueOf(sb))% pow!=0){
        if(sb.charAt(i)!='0'){
          sb.delete(i,i+1);
          ans++;
        }
      }
      else {
        System.out.println(ans);
        return ;
      }
    }
    System.out.println(length-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Rounding779B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : long ; num := in.getCurrent()->toLong() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var s : String ; s := ((num) + "") ;
    var sb : String ; sb := StringLib.newString(s) ;
    var length : int ; length := s->size() ;
    var pow : long ; pow := 10->pow(k)->oclAsType(long) ;
    if (k > (length)->char2byte() - 1) then (     OclFile["System.out"].println((length)->char2byte() - 1) ; 
     return ) else skip ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := (length)->char2byte() - 1 ; while i >= 0 do ( (     if ((((sb) + ""))->toInteger() mod pow /= 0) then (     if (sb->at(i+1) /= '0') then (     sb := sb->antirestrict( Integer.subrange(i+1,i + 1) ) ; 
     ans := ans + 1 ) else skip ) else (     OclFile["System.out"].println(ans) ; 
     return ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println((length)->char2byte() - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String X="AGGT12" ;
  static String Y="12TXAYB" ;
  static String Z="12XBA" ;
  static int[][][] dp=new int[100][100][100];
  static int lcsOf3(int i,int j,int k){
    if(i==-1 || j==-1 || k==-1){
      return 0 ;
    }
    if(dp[i][j][k]!=-1){
      return dp[i][j][k];
    }
    if(X.charAt(i)==Y.charAt(j)&& Y.charAt(j)==Z.charAt(k)){
      return dp[i][j][k]=1+lcsOf3(i-1,j-1,k-1);
    }
    else {
      return dp[i][j][k]=Math.max(Math.max(lcsOf3(i-1,j,k),lcsOf3(i,j-1,k)),lcsOf3(i,j,k-1));
    }
  }
  public static void main(String[] args){
    for(int i=0 ; i<100 ; i++){
      for(int j=0 ; j<100 ; j++){
        for(int k=0 ; k<100 ; k++){
          dp[i][j][k]=-1 ;
        }
      }
    }
    int m=X.length();
    int n=Y.length();
    int o=Z.length();
    System.out.print("Length of LCS is "+lcsOf3(m-1,n-1,o-1));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute X : String := "AGGT12";
  static   attribute Y : String := "12TXAYB";
  static   attribute Z : String := "12XBA";
  static   attribute dp : Sequence(Sequence(Sequence(int))) := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(0)));
  static   operation lcsOf3( i : int, j : int, k : int) : int
  pre: true
  post: true
  activity: (     if (i = -1 or j = -1 or k = -1) then (     return 0 ) else skip ; 
     if (dp[i+1][j+1][k+1] /= -1) then (     return dp[i+1][j+1][k+1] ) else skip ; 
     if (X->at(i+1) = Y->at(j+1) & Y->at(j+1) = Z->at(k+1)) then (     return dp[i+1][j+1][k+1] ) else (     return dp[i+1][j+1][k+1] ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 100 do ( (         var j : int ; j := 0 ; while j < 100 do ( (         var k : int ; k := 0 ; while k < 100 do ( (     dp[i+1][j+1][k+1] := -1 )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     var m : int ; m := X->size() ;
    var n : int ; n := Y->size() ;
    var o : int ; o := Z->size() ;
    OclFile["System.out"].print("Length of LCS is " + lcsOf3(m - 1, n - 1, o - 1)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextInt()){
      int E=sc.nextInt();
      int Y=sc.nextInt();
      if(E==0){
        Y-=1867 ;
        if(Y<=44){
          System.out.println("M"+Y);
          continue ;
        }
        Y-=44 ;
        if(Y<=14){
          System.out.println("T"+Y);
          continue ;
        }
        Y-=14 ;
        if(Y<=63){
          System.out.println("S"+Y);
          continue ;
        }
        Y-=63 ;
        System.out.println("H"+Y);
      }
      else {
        Y+=1867 ;
        if(E>1){
          Y+=44 ;
        }
        if(E>2){
          Y+=14 ;
        }
        if(E>3){
          Y+=63 ;
        }
        System.out.println(Y);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextInt()) do (     var E : int ; E := sc.getCurrent()->toInteger() ;
     var Y : int ; Y := sc.getCurrent()->toInteger() ;
     if (E = 0) then (     Y := Y-(1867) ; 
     if (Y <= 44) then (     OclFile["System.out"].println("M" + Y) ; 
     continue ) else skip ; 
    Y := Y-(44) ; 
    if (Y <= 14) then (     OclFile["System.out"].println("T" + Y) ; 
     continue ) else skip ; 
    Y := Y-(14) ; 
    if (Y <= 63) then (     OclFile["System.out"].println("S" + Y) ; 
     continue ) else skip ; 
    Y := Y-(63) ; 
    OclFile["System.out"].println("H" + Y) ; 
 ) else (     Y := Y+(1867) ; 
     if (E > 1) then (     Y := Y+(44) ) else skip ; 
    if (E > 2) then (     Y := Y+(14) ) else skip ; 
    if (E > 3) then (     Y := Y+(63) ) else skip ; 
    OclFile["System.out"].println(Y) ; 
 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Comparator ;
import java.util.Collections ;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      String str=reader.readLine();
      String s[]=str.split(" ");
      int e=Integer.parseInt(s[0]);
      int y=Integer.parseInt(s[1]);
      StringBuffer sb=new StringBuffer();
      switch(e){
        case 0 : int year=0 ;
        if(y<=1911){
          year=y-1867 ;
          sb.append("M");
        }
        else if(y<=1925){
          year=y-1911 ;
          sb.append("T");
        }
        else if(y<=1988){
          year=y-1925 ;
          sb.append("S");
        }
        else if(y<=2016){
          year=y-1988 ;
          sb.append("H");
        }
        sb.append(year);
        break ;
        case 1 : y+=1867 ;
        sb.append(y);
        break ;
        case 2 : y+=1911 ;
        sb.append(y);
        break ;
        case 3 : y+=1925 ;
        sb.append(y);
        break ;
        case 4 : y+=1988 ;
        sb.append(y);
        break ;
      }
      System.out.println(sb);
      reader.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var str : String ; str := reader.readLine() ;
     var s : Sequence(String) ; s := str->split(" ") ;
    var e : int ; e := (s[0+1])->toInteger() ;
    var y : int ; y := (s[1+1])->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (e) ; 
       if _switchval = 0 then
     var year : int ; year := 0 ;
    if (y <= 1911) then (     year := y - 1867 ; 
     sb := sb + StringLib.newString("M") ) else     if (y <= 1925) then (     year := y - 1911 ; 
     sb := sb + StringLib.newString("T") ) else     if (y <= 1988) then (     year := y - 1925 ; 
     sb := sb + StringLib.newString("S") ) else     if (y <= 2016) then (     year := y - 1988 ; 
     sb := sb + StringLib.newString("H") ) else skip ; ;  ;  ;  
    sb := sb + StringLib.newString(year) ; 
    break 
   else skip ;
       if _switchval = 1 then
     y := y+(1867) ; 
    sb := sb + StringLib.newString(y) ; 
    break 
   else skip ;
       if _switchval = 2 then
     y := y+(1911) ; 
    sb := sb + StringLib.newString(y) ; 
    break 
   else skip ;
       if _switchval = 3 then
     y := y+(1925) ; 
    sb := sb + StringLib.newString(y) ; 
    break 
   else skip ;
       if _switchval = 4 then
     y := y+(1988) ; 
    sb := sb + StringLib.newString(y) ; 
    break 
   else skip ;
 )
    OclFile["System.out"].println(sb) ; 
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner s=new Scanner(System.in);
    int E=s.nextInt();
    int Y=s.nextInt();
    if(1912>Y && Y>1867){
      int A=Y-1867 ;
      System.out.print("M");
      System.out.println(A);
    }
    else if(1926>Y && Y>1911){
      int B=Y-1911 ;
      System.out.print("T");
      System.out.println(B);
    }
    else if(1989>Y && Y>1925){
      int C=Y-1925 ;
      System.out.print("S");
      System.out.println(C);
    }
    else if(2017>Y && Y>1988){
      int D=Y-1988 ;
      System.out.print("H");
      System.out.println(D);
    }
    else if(E==1){
      System.out.println(Y+1867);
    }
    else if(E==2){
      System.out.println(Y+1911);
    }
    else if(E==3){
      System.out.println(Y+1925);
    }
    else if(E==4){
      System.out.println(Y+1988);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var E : int ; E := s.getCurrent()->toInteger() ;
     var Y : int ; Y := s.getCurrent()->toInteger() ;
     if (1912 > Y & Y > 1867) then (     var A : int ; A := Y - 1867 ;
     OclFile["System.out"].print("M") ; 
     OclFile["System.out"].println(A) ) else     if (1926 > Y & Y > 1911) then (     var B : int ; B := Y - 1911 ;
     OclFile["System.out"].print("T") ; 
     OclFile["System.out"].println(B) ) else     if (1989 > Y & Y > 1925) then (     var C : int ; C := Y - 1925 ;
     OclFile["System.out"].print("S") ; 
     OclFile["System.out"].println(C) ) else     if (2017 > Y & Y > 1988) then (     var D : int ; D := Y - 1988 ;
     OclFile["System.out"].print("H") ; 
     OclFile["System.out"].println(D) ) else     if (E = 1) then (     OclFile["System.out"].println(Y + 1867) ) else     if (E = 2) then (     OclFile["System.out"].println(Y + 1911) ) else     if (E = 3) then (     OclFile["System.out"].println(Y + 1925) ) else     if (E = 4) then (     OclFile["System.out"].println(Y + 1988) ) else skip ; ;  ;  ;  ;  ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    line=br.readLine();
    int E,Y ;
    E=parseInt(line.substring(0,line.indexOf(' ')));
    Y=parseInt(line.substring(line.indexOf(' ')+1));
    switch(E){
      case 0 : if(Y<1912){
        System.out.printf("M%d%n",Y-1868+1);
      }
      else if(Y<1926){
        System.out.printf("T%d%n",Y-1912+1);
      }
      else if(Y<1989){
        System.out.printf("S%d%n",Y-1926+1);
      }
      else {
        System.out.printf("H%d%n",Y-1989+1);
      }
      break ;
      case 1 : System.out.println(1868+Y-1);
      break ;
      case 2 : System.out.println(1912+Y-1);
      break ;
      case 3 : System.out.println(1926+Y-1);
      break ;
      case 4 : System.out.println(1989+Y-1);
      break ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    line := br.readLine() ; 
    var E : int ;
    var Y : int ;
    E := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    Y := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (E) ; 
       if _switchval = 0 then
     if (Y < 1912) then (     OclFile["System.out"].printf("M%d%n", Y - 1868 + 1) ) else     if (Y < 1926) then (     OclFile["System.out"].printf("T%d%n", Y - 1912 + 1) ) else     if (Y < 1989) then (     OclFile["System.out"].printf("S%d%n", Y - 1926 + 1) ) else (     OclFile["System.out"].printf("H%d%n", Y - 1989 + 1) ) ;  ;  ;  
    break 
   else skip ;
       if _switchval = 1 then
     OclFile["System.out"].println(1868 + Y - 1) ; 
    break 
   else skip ;
       if _switchval = 2 then
     OclFile["System.out"].println(1912 + Y - 1) ; 
    break 
   else skip ;
       if _switchval = 3 then
     OclFile["System.out"].println(1926 + Y - 1) ; 
    break 
   else skip ;
       if _switchval = 4 then
     OclFile["System.out"].println(1989 + Y - 1) ; 
    break 
   else skip ;
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.security.NoSuchAlgorithmException ;
import java.util.ArrayList ;
import java.util.HashMap ;
public class Main {
  public static HashMap<String,String>map=new HashMap<>();
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int e=sc.nextInt();
    int y=sc.nextInt();
    if(e==0){
      if(y>=1868 && y<=1911)System.out.println("M"+(y-1867));
      else if(y>=1912 && y<=1925)System.out.println("T"+(y-1911));
      else if(y>=1926 && y<=1988)System.out.println("S"+(y-1925));
      else if(y>=1989 && y<=2016)System.out.println("H"+(y-1988));
    }
    else if(e==1){
      System.out.println((y+1867));
    }
    else if(e==2){
      System.out.println((y+1911));
    }
    else if(e==3){
      System.out.println((y+1925));
    }
    else if(e==4){
      System.out.println((y+1988));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute map : Map(String,String) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var e : int ; e := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     if (e = 0) then (     if (y >= 1868 & y <= 1911) then     OclFile["System.out"].println("M" + (y - 1867)) ; else     if (y >= 1912 & y <= 1925) then     OclFile["System.out"].println("T" + (y - 1911)) else     if (y >= 1926 & y <= 1988) then     OclFile["System.out"].println("S" + (y - 1925)) else     if (y >= 1989 & y <= 2016) then     OclFile["System.out"].println("H" + (y - 1988)) ; else skip ; ;  ;  ) else     if (e = 1) then (     OclFile["System.out"].println((y + 1867)) ) else     if (e = 2) then (     OclFile["System.out"].println((y + 1911)) ) else     if (e = 3) then (     OclFile["System.out"].println((y + 1925)) ) else     if (e = 4) then (     OclFile["System.out"].println((y + 1988)) ) else skip ; ;  ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class divisible {
  public static void check(int n,int x,int y){
    long fact=1 ;
    for(int i=2 ; i<=n ; i++){
      fact*=i ;
    }
    long divisor=(long)Math.pow(x,y);
    if(fact % divisor==0)System.out.println("YES");
    else System.out.println("NO");
  }
  public static void main(String args[]){
    int n=10 ;
    int x=2 ;
    int y=8 ;
    check(n,x,y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class divisible {
  static   operation check( n : int, x : int, y : int) : void
  pre: true
  post: true
  activity: (     var fact : long ; fact := 1 ;
         var i : int ; i := 2 ; while i <= n do ( (     fact := fact*(i) )  ;     i := i + 1 ) ; 
     var divisor : long ; divisor := x->pow(y)->oclAsType(long) ;
     if (fact mod divisor = 0) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     var x : int ; x := 2 ;
     var y : int ; y := 8 ;
     execute check(n, x, y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void sortPerfectSquare(int arr[],int n){
    int a ;
    float b ;
    Vector<Integer>v1=new Vector<Integer>();
    Vector<Integer>v2=new Vector<Integer>();
    for(int i=0 ; i<n ; i++){
      b=(float)Math.sqrt(arr[i]);
      a=(int)b ;
      if(a==b){
        v1.add(i);
        v2.add(arr[i]);
      }
    }
    Collections.sort(v2);
    int j=0 ;
    for(int i=0 ; i<n ; i++){
      if(v1.get(j)==i){
        arr[i]=v2.get(j);
        j++;
      }
    }
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String[] args){
    int arr[]={
      9,44,100,81,21,64 };
      int n=arr.length ;
      sortPerfectSquare(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sortPerfectSquare( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var a : int ;
     var b : double ;
    var v1 : Sequence(int) ; v1 := Sequence{} ;
    var v2 : Sequence(int) ; v2 := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     b := (arr[i+1])->sqrt()->oclAsType(double) ; 
     a := b->oclAsType(int) ; 
     if (a = b) then (     v1 := v1->including(i) ; 
     v2 := v2->including(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    v2 := v2->sort() ; 
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (v1->at(j+1) = i) then (     arr[i+1] := v2->at(j+1) ; 
     j := j + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{9,44,100,81,21,64} ;
     var n : int ; n := arr->size() ;
     execute sortPerfectSquare(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class pair {
    int first,second ;
    public pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static boolean isPerfectSquare(double x){
    double sr=Math.sqrt(x);
    return((sr-Math.floor(sr))==0);
  }
  static boolean isFibonacci(int n){
    return isPerfectSquare(5*n*n+4)|| isPerfectSquare(5*n*n-4);
  }
  static int totalPairs(int a[],int b[],int n,int m){
    List<pair>s=new LinkedList<>();
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(isFibonacci(a[i]+b[j])==true){
          if(a[i]<b[j]){
            if(checkDuplicate(s,new pair(a[i],b[j])))s.add(new pair(a[i],b[j]));
          }
          else {
            if(checkDuplicate(s,new pair(b[j],a[i])))s.add(new pair(b[j],a[i]));
          }
        }
      }
    }
    return s.size();
  }
  static boolean checkDuplicate(List<pair>pairList,pair newPair){
    for(pair p : pairList){
      if(p.first==newPair.first && p.second==newPair.second)return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    int a[]={
      99,1,33,2 };
      int b[]={
        1,11,2 };
        int n=a.length ;
        int m=b.length ;
        System.out.println(totalPairs(a,b,n,m));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class pair {
   attribute first : int;
   static operation newpair( first : int, second : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation isPerfectSquare( x : double) : boolean
  pre: true
  post: true
  activity: (     var sr : double ; sr := (x)->sqrt() ;
     return ((sr - (sr)->floor()) = 0) );
  static   operation isFibonacci( n : int) : boolean
  pre: true
  post: true
  activity: (     return isPerfectSquare(5 * n * n + 4) or isPerfectSquare(5 * n * n - 4) );
  static   operation totalPairs( a : Sequence(int), b : Sequence(int), n : int, m : int) : int
  pre: true
  post: true
  activity: (     var s : Sequence(pair) ; s := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (isFibonacci(a[i+1] + b[j+1]) = true) then (     if (a[i+1] < b[j+1]) then (     if (checkDuplicate(s, pair.newpair(a[i+1], b[j+1]))) then     s := s->including(pair.newpair(a[i+1], b[j+1])) ; else skip ) else (     if (checkDuplicate(s, pair.newpair(b[j+1], a[i+1]))) then     s := s->including(pair.newpair(b[j+1], a[i+1])) ; else skip ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return s->size() );
  static   operation checkDuplicate( pairList : Sequence(pair), newPair : pair) : boolean
  pre: true
  post: true
  activity: (     for (p : pairList) do ( (     if (p->at("first") = newPair->at("first") & p->at("second") = newPair->at("second")) then     return false else skip )  ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{99,1,33,2} ;
     var b : Sequence(int) ; b := Sequence{1,11,2} ;
    var n : int ; n := a->size() ;
    var m : int ; m := b->size() ;
    OclFile["System.out"].println(totalPairs(a, b, n, m)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int find_count(int[] arr){
    int ans=0 ;
    for(int i : arr){
      int x=Integer.bitCount(i);
      if(i % x==0)ans+=1 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int[] arr={
      1,2,3,4,5,6 };
      System.out.print(find_count(arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find_count( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     for (i : arr) do ( (     var x : int ; x := bitCount(i) ;
     if (i mod x = 0) then     ans := ans+(1) ; else skip )  ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6} ;
     OclFile["System.out"].print(find_count(arr)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int[] a ;
  int n=1 ;
  public static void main(String[] args){
    Main test=new Main();
    Scanner inputScanner=new Scanner(System.in).useDelimiter("\\s");
    int n1=inputScanner.nextInt();
    int q=inputScanner.nextInt();
    while(test.n<n1){
      test.n*=2 ;
    }
    test.a=new int[(2*test.n)-1];
    for(int i=0 ; i<test.a.length ; i++){
      test.a[i]=Integer.MAX_VALUE ;
    }
    int cmd=-1 ;
    int arg1 ;
    int arg2 ;
    for(int j=0 ; j<q ; j++){
      cmd=inputScanner.nextInt();
      arg1=inputScanner.nextInt();
      arg2=inputScanner.nextInt();
      if(cmd==0)test.update(arg1,arg2);
      else if(cmd==1)System.out.println(test.findMin(arg1,arg2));
    }
  }
  public void update(int k,int b){
    k+=(n-1);
    a[k]=b ;
    while(k>0){
      k=(k-1)/2 ;
      a[k]=Integer.min(a[(k*2)+1],a[(k*2)+2]);
    }
  }
  public int findMin(int b,int c){
    return query(b,c+1,0,0,n);
  }
  public int query(int b,int c,int k,int l,int r){
    if(r<=b || c<=l)return Integer.MAX_VALUE ;
    if((b<=l && r<=c))return a[k];
    int o1=query(b,c,(k*2)+1,l,(l+r)/2);
    int o2=query(b,c,(k*2)+2,(l+r)/2,r);
    return Integer.min(o1,o2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute a : Sequence(int);
   attribute n : int := 1;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var test : Main ; test := Main.newMain() ;
     var inputScanner : OclFile ; inputScanner := OclFile.newOclFile_Read(OclFile["System.in"]).useDelimiter("\\s") ;
    var n1 : int ; n1 := inputScanner.getCurrent()->toInteger() ;
    var q : int ; q := inputScanner.getCurrent()->toInteger() ;
    while (test.n < n1) do (     test.n := test.n*(2) ) ; 
    test.a := Integer.subrange(1,(2 * test.n) - 1)->collect(0) ; 
        var i : int ; i := 0 ; while i < test.a->size() do ( (     test.a[i+1] := 2147483647 )  ;     i := i + 1 ) ; 
    var cmd : int ; cmd := -1 ;
    var arg1 : int ;
    var arg2 : int ;
        var j : int ; j := 0 ; while j < q do ( (     cmd := inputScanner.getCurrent()->toInteger() ; 
     arg1 := inputScanner.getCurrent()->toInteger() ; 
     arg2 := inputScanner.getCurrent()->toInteger() ; 
     if (cmd = 0) then     test.update(arg1, arg2) ; else     if (cmd = 1) then     OclFile["System.out"].println(test.findMin(arg1, arg2)) ; else skip ; )  ;     j := j + 1 ) ; 
 );
   operation update( k : int, b : int) : void
  pre: true
  post: true
  activity: (     k := k+((n - 1)) ; 
     a[k+1] := b ; 
     while (k > 0) do (     k := (k - 1) / 2 ; 
     a[k+1] := Set{a[(k * 2) + 1+1], a[(k * 2) + 2+1]}->min() ) );
   operation findMin( b : int, c : int) : int
  pre: true
  post: true
  activity: (     return query(b, c + 1, 0, 0, n) );
   operation query( b : int, c : int, k : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     if (r <= b or c <= l) then     return 2147483647 else skip ; 
     if ((b <= l & r <= c)) then     return a[k+1] else skip ; 
    var o1 : int ; o1 := query(b, c, (k * 2) + 1, l, (l + r) / 2) ;
    var o2 : int ; o2 := query(b, c, (k * 2) + 2, (l + r) / 2, r) ;
    return Set{o1, o2}->min() 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  static int[] A=new int[100000];
  static void update(int i,int x){
    A[i]=x ;
  }
  static void find(int s,int t){
    int min=Integer.MAX_VALUE ;
    for(int i=s ; i<t+1 ; i++){
      if(A[i]<min){
        min=A[i];
      }
    }
    System.out.println(min);
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] line=br.readLine().split(" ");
    int n=Integer.parseInt(line[0]);
    int q=Integer.parseInt(line[1]);
    for(int j=0 ; j<100000 ; j++){
      A[j]=Integer.MAX_VALUE ;
    }
    for(int i=0 ; i<q ; i++){
      String[] ln=br.readLine().split(" ");
      int com=Integer.parseInt(ln[0]);
      int x=Integer.parseInt(ln[1]);
      int y=Integer.parseInt(ln[2]);
      if(com==0){
        update(x,y);
      }
      else {
        find(x,y);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute A : Sequence(int) := Integer.subrange(1,100000)->collect(0);
  static   operation update( i : int, x : int) : void
  pre: true
  post: true
  activity: (     A[i+1] := x );
  static   operation find( s : int, t : int) : void
  pre: true
  post: true
  activity: (     var min : int ; min := 2147483647 ;
         var i : int ; i := s ; while i < t + 1 do ( (     if (A[i+1] < min) then (     min := A[i+1] ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(min) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var n : int ; n := (line[0+1])->toInteger() ;
    var q : int ; q := (line[1+1])->toInteger() ;
        var j : int ; j := 0 ; while j < 100000 do ( (     A[j+1] := 2147483647 )  ;     j := j + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var ln : Sequence(String) ; ln := br.readLine()->split(" ") ;
     var com : int ; com := (ln[0+1])->toInteger() ;
    var x : int ; x := (ln[1+1])->toInteger() ;
    var y : int ; y := (ln[2+1])->toInteger() ;
    if (com = 0) then (     execute update(x, y) ) else (     execute find(x, y) ) ;  
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=Integer.parseInt(scan.next());
    int q=Integer.parseInt(scan.next());
    SegTree st=new SegTree(n);
    for(int i=0 ; i<q ; i++){
      int com=Integer.parseInt(scan.next());
      int x=Integer.parseInt(scan.next());
      int y=Integer.parseInt(scan.next());
      if(com==0){
        st.update(x,y);
      }
      else {
        System.out.println(st.find(x,y+1));
      }
    }
    scan.close();
  }
  static class SegTree {
    int size=1 ;
    int[] node ;
    public SegTree(int n){
      while(size<n){
        size*=2 ;
      }
      node=new int[2*size];
      for(int i=0 ; i<2*size ; i++){
        node[i]=Integer.MAX_VALUE ;
      }
    }
    public void update(int i,int x){
      int index=i+size-1 ;
      node[index]=x ;
      while(index>0){
        index=(index-1)/2 ;
        node[index]=Math.min(node[2*index+1],node[2*index+2]);
      }
    }
    public int find(int s,int t){
      return find(s,t,0,0,size);
    }
    private int find(int s,int t,int i,int left,int right){
      if(t<=left || right<=s){
        return Integer.MAX_VALUE ;
      }
      if(s<=left && right<=t){
        return node[i];
      }
      int l=find(s,t,2*i+1,left,(left+right)/2);
      int r=find(s,t,2*i+2,(left+right)/2,right);
      return Math.min(l,r);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (scan.getCurrent())->toInteger() ;
    var q : int ; q := (scan.getCurrent())->toInteger() ;
    var st : SegTree ; st := SegTree.newSegTree(n) ;
        var i : int ; i := 0 ; while i < q do ( (     var com : int ; com := (scan.getCurrent())->toInteger() ;
     var x : int ; x := (scan.getCurrent())->toInteger() ;
     var y : int ; y := (scan.getCurrent())->toInteger() ;
     if (com = 0) then (     st.update(x, y) ) else (     OclFile["System.out"].println(st.find(x, y + 1)) ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class SegTree {
   attribute size : int := 1;
   attribute node : Sequence(int);
   static operation newSegTree( n : int) : SegTree
  pre: true
  post: true
  activity:
  ( var self : SegTree ;
    self := createSegTree();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     while (size < n) do (     size := size*(2) ) ; 
     node := Integer.subrange(1,2 * size)->collect(0) ; 
         var i : int ; i := 0 ; while i < 2 * size do ( (     node[i+1] := 2147483647 )  ;     i := i + 1 ) );
   operation update( i : int, x : int) : void
  pre: true
  post: true
  activity: (     var index : int ; index := i + size - 1 ;
     node[index+1] := x ; 
     while (index > 0) do (     index := (index - 1) / 2 ; 
     node[index+1] := Set{node[2 * index + 1+1], node[2 * index + 2+1]}->min() ) );
   operation find( s : int, t : int) : int
  pre: true
  post: true
  activity: (     return find(s, t, 0, 0, size) );
   operation find( s : int, t : int, i : int, left : int, right : int) : int
  pre: true
  post: true
  activity: (     if (t <= left or right <= s) then (     return 2147483647 ) else skip ; 
     if (s <= left & right <= t) then (     return node[i+1] ) else skip ; 
    var l : int ; l := find(s, t, 2 * i + 1, left, (left + right) / 2) ;
    var r : int ; r := find(s, t, 2 * i + 2, (left + right) / 2, right) ;
    return Set{l, r}->min() 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.*;
import java.awt.event.*;
import java.lang.*;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new TEST().doIt();
  }
  class TEST {
    int data[];
    int n,m ;
    void update(int i,int x){
      i+=n-1 ;
      data[i]=x ;
      while(i>0){
        i=(i-1)/2 ;
        data[i]=Math.min(data[i*2+1],data[i*2+2]);
      }
    }
    int query(int a,int b,int k,int l,int r){
      if(r<=a || b<=l)return Integer.MAX_VALUE ;
      if(a<=l && r<=b)return data[k];
      else {
        int vl=query(a,b,k*2+1,l,(l+r)/2);
        int vr=query(a,b,k*2+2,(l+r)/2,r);
        return Math.min(vl,vr);
      }
    }
    void doIt(){
      int num=sc.nextInt();
      m=sc.nextInt();
      n=1 ;
      while(n<num)n<<=1 ;
      data=new int[n*2-1];
      Arrays.fill(data,Integer.MAX_VALUE);
      for(int i=0 ; i<m ; i++){
        int com=sc.nextInt();
        int x=sc.nextInt();
        int y=sc.nextInt();
        if(com==0)update(x,y);
        else System.out.println(query(x,y+1,0,0,n));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     TEST.newTEST().doIt() );
 class TEST {
   attribute data : Sequence(int);
   attribute n : int;
   operation update( i : int, x : int) : void
  pre: true
  post: true
  activity: (     i := i+(n - 1) ; 
     data[i+1] := x ; 
     while (i > 0) do (     i := (i - 1) / 2 ; 
     data[i+1] := Set{data[i * 2 + 1+1], data[i * 2 + 2+1]}->min() ) );
   operation query( a : int, b : int, k : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     if (r <= a or b <= l) then     return 2147483647 else skip ; 
     if (a <= l & r <= b) then     return data[k+1] else (     var vl : int ; vl := query(a, b, k * 2 + 1, l, (l + r) / 2) ;
     var vr : int ; vr := query(a, b, k * 2 + 2, (l + r) / 2, r) ;
     return Set{vl, vr}->min() ) );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var num : int ; num := sc.getCurrent()->toInteger() ;
     m := sc.getCurrent()->toInteger() ; 
    n := 1 ; 
    while (n < num) do     n := n*(2->pow(1)) ; ; 
    data := Integer.subrange(1,n * 2 - 1)->collect(0) ; 
    data := data->collect(2147483647) ; 
        var i : int ; i := 0 ; while i < m do ( (     var com : int ; com := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     if (com = 0) then     execute update(x, y) ; else     OclFile["System.out"].println(query(x, y + 1, 0, 0, n)) ; )  ;     i := i + 1 ) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int[][] r ;
  int c ;
  int[] p ;
  void dfs(int k){
    if(k==8){
      boolean[][] a=new boolean[4][4];
      k=0 ;
      boolean f=true ;
      for(int i=0 ; i<4 ; i++){
        for(int j=0 ; j<4 ; j++){
          if(a[i][j])continue ;
          a[i][j]=true ;
          int ni=i+r[p[k] ][0];
          int nj=j+r[p[k] ][1];
          if(0<=ni && ni<4 && 0<=nj && nj<4 && ! a[ni][nj]){
            a[ni][nj]=true ;
            k++;
          }
          else {
            f=false ;
            break ;
          }
        }
      }
      if(f)c++;
      return ;
    }
    for(int i=0 ; i<4 ; i++){
      p[k]=i ;
      dfs(k+1);
    }
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int x=sc.nextInt();
      if(x>4)break ;
      int y=sc.nextInt();
      r=new int[4][2];
      p=new int[8];
      r[0][0]=y ;
      r[0][1]=x ;
      for(int i=1 ; i<4 ; i++)for(int j=1 ; j>=0 ; j--)r[i][j]=sc.nextInt();
      c=0 ;
      dfs(0);
      System.out.println(c);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute r : Sequence(Sequence(int));
   attribute c : int;
   attribute p : Sequence(int);
   operation dfs( k : int) : void
  pre: true
  post: true
  activity: (     if (k = 8) then (     var a : Sequence(Sequence(boolean)) ; a := Integer.subrange(1,4)->collect(Integer.subrange(1,4)->collect(false)) ;
     k := 0 ; 
    var f : boolean ; f := true ;
        var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < 4 do ( (     if (a[i+1][j+1]) then     continue else skip ; 
     a[i+1][j+1] := true ; 
    var ni : int ; ni := i + r[p[k+1]+1][0+1] ;
    var nj : int ; nj := j + r[p[k+1]+1][1+1] ;
    if (0 <= ni & ni < 4 & 0 <= nj & nj < 4 & not(a[ni+1][nj+1])) then (     a[ni+1][nj+1] := true ; 
     k := k + 1 ) else (     f := false ; 
     break ) ;  
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (f) then     c := c + 1 ; else skip ; 
    return 
 ) else skip ; 
         var i : int ; i := 0 ; while i < 4 do ( (     p[k+1] := i ; 
     execute dfs(k + 1) )  ;     i := i + 1 ) );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x > 4) then     break else skip ; 
    var y : int ; y := sc.getCurrent()->toInteger() ;
    r := Integer.subrange(1,4)->collect(Integer.subrange(1,2)->collect(0)) ; 
    p := Integer.subrange(1,8)->collect(0) ; 
    r[0+1][0+1] := y ; 
    r[0+1][1+1] := x ; 
        var i : int ; i := 1 ; while i < 4 do (         var j : int ; j := 1 ; while j >= 0 do (     r[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j - 1 ) ;  ;     i := i + 1 ) ; 
    c := 0 ; 
    execute dfs(0) ; 
    OclFile["System.out"].println(c) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int[][] setted ;
  int[] xcard ;
  int[] ycard ;
  int ans ;
  private boolean isRange(int x,int y){
    if(x<0 || x>=4 || y<0 || y>=4){
      return false ;
    }
    else {
      return true ;
    }
  }
  private void solve(int deep){
    if(deep==9){
      ans++;
      return ;
    }
    for(int i=0 ; i<4 ; i++){
      for(int j=0 ; j<4 ; j++){
        if(setted[i][j]==0){
          for(int k=0 ; k<4 ; k++){
            int xdis=xcard[k]+j ;
            int ydis=ycard[k]+i ;
            if(isRange(xdis,ydis)&&(setted[ydis][xdis]==0)){
              setted[i][j]=deep ;
              setted[ydis][xdis]=deep ;
              solve(deep+1);
              setted[i][j]=0 ;
              setted[ydis][xdis]=0 ;
            }
          }
          return ;
        }
      }
    }
    return ;
  }
  public void doIt(){
    Scanner sc=new Scanner(System.in);
    while(true){
      xcard=new int[4];
      ycard=new int[4];
      setted=new int[4][4];
      ans=0 ;
      int n=sc.nextInt();
      if(n>4){
        break ;
      }
      xcard[0]=n ;
      ycard[0]=sc.nextInt();
      for(int i=1 ; i<4 ; i++){
        xcard[i]=sc.nextInt();
        ycard[i]=sc.nextInt();
      }
      solve(1);
      System.out.println(ans);
    }
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute setted : Sequence(Sequence(int));
   attribute xcard : Sequence(int);
   attribute ycard : Sequence(int);
   attribute ans : int;
   operation isRange( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     if (x < 0 or x >= 4 or y < 0 or y >= 4) then (     return false ) else (     return true ) );
   operation solve( deep : int) : void
  pre: true
  post: true
  activity: (     if (deep = 9) then (     ans := ans + 1 ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < 4 do ( (     if (setted[i+1][j+1] = 0) then (         var k : int ; k := 0 ; while k < 4 do ( (     var xdis : int ; xdis := xcard[k+1] + j ;
     var ydis : int ; ydis := ycard[k+1] + i ;
     if (isRange(xdis, ydis) & (setted[ydis+1][xdis+1] = 0)) then (     setted[i+1][j+1] := deep ; 
     setted[ydis+1][xdis+1] := deep ; 
    execute solve(deep + 1) ; 
    setted[i+1][j+1] := 0 ; 
    setted[ydis+1][xdis+1] := 0 ; 
 ) else skip )  ;     k := k + 1 ) ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     xcard := Integer.subrange(1,4)->collect(0) ; 
     ycard := Integer.subrange(1,4)->collect(0) ; 
    setted := Integer.subrange(1,4)->collect(Integer.subrange(1,4)->collect(0)) ; 
    ans := 0 ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
    if (n > 4) then (     break ) else skip ; 
    xcard[0+1] := n ; 
    ycard[0+1] := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i < 4 do ( (     xcard[i+1] := sc.getCurrent()->toInteger() ; 
     ycard[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute solve(1) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int[] dx=new int[4];
  static int[] dy=new int[4];
  static int dfs(int x,int y,boolean[][] used){
    while(used[x][y]){
++x ;
      if(x==4){
        x=0 ;
++y ;
        if(y==4)return 1 ;
      }
    }
    int ret=0 ;
    used[x][y]=true ;
    for(int i=0 ; i<4 ; ++i){
      int nx=x+dx[i];
      int ny=y+dy[i];
      if(0<=nx && nx<4 && 0<=ny && ny<4 && ! used[nx][ny]){
        used[nx][ny]=true ;
        ret+=dfs(x,y,used);
        used[nx][ny]=false ;
      }
    }
    used[x][y]=false ;
    return ret ;
  }
  static int solve(){
    boolean[][] used=new boolean[4][4];
    return dfs(0,0,used);
  }
  public static void main(String[] args){
    while(true){
      dx[0]=sc.nextInt();
      if(dx[0]>4)break ;
      dy[0]=sc.nextInt();
      for(int i=1 ; i<4 ; ++i){
        dx[i]=sc.nextInt();
        dy[i]=sc.nextInt();
      }
      System.out.println(solve());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute dx : Sequence(int) := Integer.subrange(1,4)->collect(0);
  static   attribute dy : Sequence(int) := Integer.subrange(1,4)->collect(0);
  static   operation dfs( x : int, y : int, used : Sequence(Sequence(boolean))) : int
  pre: true
  post: true
  activity: (     while (used[x+1][y+1]) do (     x := x + 1 ; 
     if (x = 4) then (     x := 0 ; 
     y := y + 1 ; 
     if (y = 4) then     return 1 else skip ) else skip ) ; 
     var ret : int ; ret := 0 ;
    used[x+1][y+1] := true ; 
        var i : int ; i := 0 ; while i < 4 do ( (     var nx : int ; nx := x + dx[i+1] ;
     var ny : int ; ny := y + dy[i+1] ;
     if (0 <= nx & nx < 4 & 0 <= ny & ny < 4 & not(used[nx+1][ny+1])) then (     used[nx+1][ny+1] := true ; 
     ret := ret+(dfs(x, y, used)) ; 
     used[nx+1][ny+1] := false ) else skip )  ;     i := i + 1 ) ; 
    used[x+1][y+1] := false ; 
    return ret 
 );
  static   operation solve() : int
  pre: true
  post: true
  activity: (     var used : Sequence(Sequence(boolean)) ; used := Integer.subrange(1,4)->collect(Integer.subrange(1,4)->collect(false)) ;
     return dfs(0, 0, used) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     dx[0+1] := sc.getCurrent()->toInteger() ; 
     if (dx[0+1] > 4) then     break else skip ; 
    dy[0+1] := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i < 4 do ( (     dx[i+1] := sc.getCurrent()->toInteger() ; 
     dy[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int HEIGHT=4 ;
  int WIDTH=4 ;
  int[][] relationXY ;
  void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int[][] temp=new int[4][2];
      int x=sc.nextInt();
      if(x>4){
        break ;
      }
      int y=sc.nextInt();
      temp[0][0]=x ;
      temp[0][1]=y ;
      for(int i=1 ; i<4 ; i++){
        temp[i][0]=sc.nextInt();
        temp[i][1]=sc.nextInt();
      }
      relationXY=temp ;
      boolean[][] visited=new boolean[HEIGHT][WIDTH];
      System.out.println(dfs(visited,HEIGHT*WIDTH,0));
    }
  }
  int dfs(boolean[][] visited,int remain,int next){
    if(remain==0){
      return 1 ;
    }
    if(next>=HEIGHT*WIDTH){
      return 0 ;
    }
    int count=0 ;
    int y=next/HEIGHT ;
    int x=next % WIDTH ;
    if(visited[y][x]){
      count+=dfs(visited,remain,next+1);
    }
    else {
      for(int i=0 ; i<relationXY.length ; i++){
        int rx=x+relationXY[i][0];
        int ry=y+relationXY[i][1];
        if(rx<0 || WIDTH<=rx || ry<0 || HEIGHT<=ry){
          continue ;
        }
        if(! visited[ry][rx]){
          visited[y][x]=true ;
          visited[ry][rx]=true ;
          count+=dfs(visited,remain-2,next+1);
          visited[y][x]=false ;
          visited[ry][rx]=false ;
        }
      }
    }
    return count ;
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute HEIGHT : int := 4;
   attribute WIDTH : int := 4;
   attribute relationXY : Sequence(Sequence(int));
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var temp : Sequence(Sequence(int)) ; temp := Integer.subrange(1,4)->collect(Integer.subrange(1,2)->collect(0)) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    if (x > 4) then (     break ) else skip ; 
    var y : int ; y := sc.getCurrent()->toInteger() ;
    temp[0+1][0+1] := x ; 
    temp[0+1][1+1] := y ; 
        var i : int ; i := 1 ; while i < 4 do ( (     temp[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     temp[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    relationXY := temp ; 
    var visited : Sequence(Sequence(boolean)) ; visited := Integer.subrange(1,HEIGHT)->collect(Integer.subrange(1,WIDTH)->collect(false)) ;
    OclFile["System.out"].println(dfs(visited, HEIGHT * WIDTH, 0)) ; 
 ) );
   operation dfs( visited : Sequence(Sequence(boolean)), remain : int, next : int) : int
  pre: true
  post: true
  activity: (     if (remain = 0) then (     return 1 ) else skip ; 
     if (next >= HEIGHT * WIDTH) then (     return 0 ) else skip ; 
    var count : int ; count := 0 ;
    var y : int ; y := next / HEIGHT ;
    var x : int ; x := next mod WIDTH ;
    if (visited[y+1][x+1]) then (     count := count+(dfs(visited, remain, next + 1)) ) else (         var i : int ; i := 0 ; while i < relationXY->size() do ( (     var rx : int ; rx := x + relationXY[i+1][0+1] ;
     var ry : int ; ry := y + relationXY[i+1][1+1] ;
     if (rx < 0 or WIDTH <= rx or ry < 0 or HEIGHT <= ry) then (     continue ) else skip ; 
     if (not(visited[ry+1][rx+1])) then (     visited[y+1][x+1] := true ; 
     visited[ry+1][rx+1] := true ; 
    count := count+(dfs(visited, remain - 2, next + 1)) ; 
    visited[y+1][x+1] := false ; 
    visited[ry+1][rx+1] := false ; 
 ) else skip )  ;     i := i + 1 ) ) ;  
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=parseInt(line);
      if(n==0)break ;
      int[][] league=new int[n][5];
      for(int i=0 ; i<n ; i++){
        StringTokenizer st=new StringTokenizer(br.readLine());
        league[i][3]=i ;
        league[i][4]=st.nextToken().charAt(0);
        for(int j=0 ; j<n-1 ; j++){
          league[i][parseInt(st.nextToken())]++;
        }
      }
      Arrays.sort(league,new Comparator<int[]>(){
        @ Override public int compare(int[] o1,int[] o2){
          if(o1[0]!=o2[0]){
            return o2[0]-o1[0];
          }
          else {
            if(o1[1]!=o2[1]){
              return o1[1]-o2[1];
            }
            else {
              return o1[3]-o2[3];
            }
          }
        }
      }
);
      for(int[] team : league){
        System.out.println((char)team[4]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := parseInt(line) ;
     if (n = 0) then     break else skip ; 
    var league : Sequence(Sequence(int)) ; league := Integer.subrange(1,n)->collect(Integer.subrange(1,5)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     league[i+1][3+1] := i ; 
     league[i+1][4+1] := st.next()->at(0+1) ; 
         var j : int ; j := 0 ; while j < (n)->char2byte() - 1 do ( (     league[i+1][parseInt(st.next())+1] := league[i+1][parseInt(st.next())+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    league := OclComparator.sortWith(league, OclComparator<Sequence(int)>.newOclComparator()) ; 
    for (team : league) do ( (     OclFile["System.out"].println(team[4+1]->oclAsType(String)) )  ) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printArray(int N,int arr[]){
    for(int i=0 ; i<N ; i++)System.out.print(arr[i]+" ");
    System.out.println();
  }
  static void replacedArray(int N,int arr[]){
    int pos_sum,neg_sum,i,j,diff ;
    pos_sum=0 ;
    neg_sum=0 ;
    for(i=N-1 ; i>=0 ; i--){
      diff=Math.abs(pos_sum)-Math.abs(neg_sum);
      if(arr[i]>0)pos_sum+=arr[i];
      else neg_sum+=arr[i];
      arr[i]=Math.abs(diff);
    }
  }
  public static void main(String[] args){
    int N=5 ;
    int arr[]={
      1,-1,2,3,-2 };
      replacedArray(N,arr);
      printArray(N,arr);
      N=6 ;
      int arr1[]={
-3,-4,-2,5,1,-2 };
        replacedArray(N,arr1);
        printArray(N,arr1);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printArray( N : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation replacedArray( N : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var pos_sum : int ;
    var neg_sum : int ;
    var i : int ;
    var j : int ;
    var diff : int ;
     pos_sum := 0 ; 
     neg_sum := 0 ; 
         i := N - 1 ; while i >= 0 do ( (     diff := if pos_sum < 0 then -(pos_sum) else pos_sum endif - if neg_sum < 0 then -(neg_sum) else neg_sum endif ; 
     if (arr[i+1] > 0) then     pos_sum := pos_sum+(arr[i+1]) else     neg_sum := neg_sum+(arr[i+1]) ; ;  
     arr[i+1] := if diff < 0 then -(diff) else diff endif )  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     var arr : Sequence(int) ; arr := Sequence{1,-1,2,3,-2} ;
    execute replacedArray(N, arr) ; 
    execute printArray(N, arr) ; 
    N := 6 ; 
    var arr1 : Sequence(int) ; arr1 := Sequence{-3,-4,-2,5,1,-2} ;
    execute replacedArray(N, arr1) ; 
    execute printArray(N, arr1) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++)A[i]=sc.nextInt();
    System.out.println(check(A)? "YES" : "NO");
    sc.close();
  }
  static boolean check(int[] A){
    int N=A.length ;
    long sum=0 ;
    for(int i=0 ; i<N ; i++)sum+=A[i];
    if(sum %((long)N*(N+1)/2)!=0)return false ;
    int op=(int)(sum/((long)N*(N+1)/2));
    for(int i=0 ; i<N ; i++){
      int diff=A[(i+1)% N]-A[i];
      if((diff>op))return false ;
      if((op-diff)% N!=0)return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     A[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if check(A) then "YES" else "NO" endif) ; 
    skip ; 
 );
  static   operation check( A : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var N : int ; N := A->size() ;
     var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do (     sum := sum+(A[i+1]) ;  ;     i := i + 1 ) ; 
    if (sum mod (N->oclAsType(long) * (N + 1) / 2) /= 0) then     return false else skip ; 
    var op : int ; op := (sum / (N->oclAsType(long) * (N + 1) / 2))->oclAsType(int) ;
        var i : int ; i := 0 ; while i < N do ( (     var diff : int ; diff := A[(i + 1) mod N+1] - A[i+1] ;
     if ((diff > op)) then     return false else skip ; 
     if ((op - diff) mod N /= 0) then     return false else skip )  ;     i := i + 1 ) ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int HEIGHT=4 ;
  int WIDTH=4 ;
  int[][] relationXY ;
  void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int[][] temp=new int[4][2];
      int x=sc.nextInt();
      if(x>4){
        break ;
      }
      int y=sc.nextInt();
      temp[0][0]=x ;
      temp[0][1]=y ;
      for(int i=1 ; i<4 ; i++){
        temp[i][0]=sc.nextInt();
        temp[i][1]=sc.nextInt();
      }
      relationXY=temp ;
      boolean[][] visited=new boolean[HEIGHT][WIDTH];
      System.out.println(dfs(visited,HEIGHT*WIDTH,0));
    }
  }
  int dfs(boolean[][] visited,int remain,int next){
    if(remain==0){
      return 1 ;
    }
    if(next>=HEIGHT*WIDTH){
      return 0 ;
    }
    int count=0 ;
    int y=next/HEIGHT ;
    int x=next % WIDTH ;
    if(visited[y][x]){
      count+=dfs(visited,remain,next+1);
    }
    else {
      for(int i=0 ; i<relationXY.length ; i++){
        int rx=x+relationXY[i][0];
        int ry=y+relationXY[i][1];
        if(rx<0 || WIDTH<=rx || ry<0 || HEIGHT<=ry){
          continue ;
        }
        if(! visited[ry][rx]){
          visited[y][x]=true ;
          visited[ry][rx]=true ;
          count+=dfs(visited,remain-2,next+1);
          visited[y][x]=false ;
          visited[ry][rx]=false ;
        }
      }
    }
    return count ;
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute HEIGHT : int := 4;
   attribute WIDTH : int := 4;
   attribute relationXY : Sequence(Sequence(int));
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var temp : Sequence(Sequence(int)) ; temp := Integer.subrange(1,4)->collect(Integer.subrange(1,2)->collect(0)) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    if (x > 4) then (     break ) else skip ; 
    var y : int ; y := sc.getCurrent()->toInteger() ;
    temp[0+1][0+1] := x ; 
    temp[0+1][1+1] := y ; 
        var i : int ; i := 1 ; while i < 4 do ( (     temp[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     temp[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    relationXY := temp ; 
    var visited : Sequence(Sequence(boolean)) ; visited := Integer.subrange(1,HEIGHT)->collect(Integer.subrange(1,WIDTH)->collect(false)) ;
    OclFile["System.out"].println(dfs(visited, HEIGHT * WIDTH, 0)) ; 
 ) );
   operation dfs( visited : Sequence(Sequence(boolean)), remain : int, next : int) : int
  pre: true
  post: true
  activity: (     if (remain = 0) then (     return 1 ) else skip ; 
     if (next >= HEIGHT * WIDTH) then (     return 0 ) else skip ; 
    var count : int ; count := 0 ;
    var y : int ; y := next / HEIGHT ;
    var x : int ; x := next mod WIDTH ;
    if (visited[y+1][x+1]) then (     count := count+(dfs(visited, remain, next + 1)) ) else (         var i : int ; i := 0 ; while i < relationXY->size() do ( (     var rx : int ; rx := x + relationXY[i+1][0+1] ;
     var ry : int ; ry := y + relationXY[i+1][1+1] ;
     if (rx < 0 or WIDTH <= rx or ry < 0 or HEIGHT <= ry) then (     continue ) else skip ; 
     if (not(visited[ry+1][rx+1])) then (     visited[y+1][x+1] := true ; 
     visited[ry+1][rx+1] := true ; 
    count := count+(dfs(visited, remain - 2, next + 1)) ; 
    visited[y+1][x+1] := false ; 
    visited[ry+1][rx+1] := false ; 
 ) else skip )  ;     i := i + 1 ) ) ;  
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Iterator ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeSet ;
public class Test1 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    Set<Integer>set=new TreeSet<>();
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      set.add(in.nextInt());
    }
    Iterator<Integer>it=set.iterator();
    int first ;
    int sec ;
    if(set.size()>1){
      it.next();
      sec=it.next();
      System.out.println(sec);
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var set : Set(int) ; set := Set{} ;
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     set := set->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var it : OclIterator ; it := set->iterator() ;
    var first : int ;
    var sec : int ;
    if (set->size() > 1) then (     it.next() ; 
     sec := it.next() ; 
     OclFile["System.out"].println(sec) ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CodeForces22A {
  public static void main(String[] args){
    Scanner inp=new Scanner(System.in);
    int[] b=new int[204];
    int n=inp.nextInt();
    for(int i=0 ; i<n ; i++){
      b[inp.nextInt()+100]++;
    }
    boolean firstFound=false ;
    int val=-1000 ;
    for(int i=0 ; i<b.length ; i++){
      if(b[i]!=0){
        if(firstFound){
          val=i-100 ;
          break ;
        }
        else firstFound=true ;
      }
    }
    if(val>-1000){
      System.out.println(val);
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces22A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inp : OclFile ; inp := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var b : Sequence(int) ; b := Integer.subrange(1,204)->collect(0) ;
    var n : int ; n := inp.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     b[inp.getCurrent()->toInteger() + 100+1] := b[inp.getCurrent()->toInteger() + 100+1] + 1 )  ;     i := i + 1 ) ; 
    var firstFound : boolean ; firstFound := false ;
    var val : int ; val := -1000 ;
        var i : int ; i := 0 ; while i < b->size() do ( (     if (b[i+1] /= 0) then (     if (firstFound) then (     val := i - 100 ; 
     break ) else     firstFound := true ; ) else skip )  ;     i := i + 1 ) ; 
    if (val > -1000) then (     OclFile["System.out"].println(val) ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner pc=new Scanner(System.in);
    int p=pc.nextInt();
    int e[]=new int[p];
    for(int o=0 ; o<p ; o++)e[o]=pc.nextInt();
    Arrays.sort(e);
    int f=0 ;
    for(int o=1 ; o<p ; o++){
      if(e[o]>e[o-1]){
        System.out.println(e[o]);
        f=1 ;
        break ;
      }
    }
    if(f==0)System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var pc : OclFile ; pc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : int ; p := pc.getCurrent()->toInteger() ;
    var e : Sequence(int) ; e := Integer.subrange(1,p)->collect(0) ;
        var o : int ; o := 0 ; while o < p do (     e[o+1] := pc.getCurrent()->toInteger() ;  ;     o := o + 1 ) ; 
    e := e->sort() ; 
    var f : int ; f := 0 ;
        var o : int ; o := 1 ; while o < p do ( (     if (e[o+1] > e[o - 1+1]) then (     OclFile["System.out"].println(e[o+1]) ; 
     f := 1 ; 
     break ) else skip )  ;     o := o + 1 ) ; 
    if (f = 0) then     OclFile["System.out"].println("NO") ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class CF937_D2_B {
  public static void main(String[] args){
    FastScanner scanner=new FastScanner();
    int p=scanner.nextInt();
    int y=scanner.nextInt();
    for(int i=y ; i>p ; i--){
      boolean found=true ;
      for(int j=2 ; j*j<=i ; j++){
        if(i % j==0 && j<=p){
          found=false ;
          break ;
        }
      }
      if(found){
        System.out.println(i);
        return ;
      }
    }
    System.out.println(-1);
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      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 ;
    }
    int[] nextArray(int n){
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=nextInt();
      }
      return arr ;
    }
    Integer[] nextArray(int n,boolean object){
      Integer[] arr=new Integer[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=nextInt();
      }
      return arr ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF937_D2_B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : FastScanner ; scanner := FastScanner.newFastScanner() ;
     var p : int ; p := scanner.nextInt() ;
    var y : int ; y := scanner.nextInt() ;
        var i : int ; i := y ; while i > p do ( (     var found : boolean ; found := true ;
         var j : int ; j := 2 ; while j * j <= i do ( (     if (i mod j = 0 & j <= p) then (     found := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (found) then (     OclFile["System.out"].println(i) ; 
     return ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(-1) ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return arr );
   operation nextArray( n : int, object : boolean) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return arr );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class B {
  public static void main(String[] args)throws IOException {
    int p=readInt(),y=readInt();
    outer : for(int k=y ;
    k>p ;
    k--){
      for(int j=2 ; j*j<=k && j<=p ; j++){
        if(k % j==0)continue outer ;
      }
      out.println(k);
      out.close();
      break ;
    }
    out.println(-1);
    out.close();
  }
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
  static StringTokenizer st=new StringTokenizer("");
  static String read()throws IOException {
    return st.hasMoreTokens()? st.nextToken():(st=new StringTokenizer(br.readLine())).nextToken();
  }
  static int readInt()throws IOException {
    return Integer.parseInt(read());
  }
  static long readLong()throws IOException {
    return Long.parseLong(read());
  }
  static double readDouble()throws IOException {
    return Double.parseDouble(read());
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : int ; p := readInt() ;
    var y : int ; y := readInt() ;
         var k : int ; k := y ; while k > p do ( (         var j : int ; j := 2 ; while j * j <= k & j <= p do ( (     if (k mod j = 0) then     continue else skip )  ;     j := j + 1 ) ; 
     out.println(k) ; 
     out.close() ; 
     break )  ;     k := k - 1 ) ; 
     out.println(-1) ; 
     out.close() );
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute st : OclIterator := OclIterator.newOclIterator_String("");
  static   operation read() : String
  pre: true
  post: true
  activity: (     return if st.hasNext() then st.next() else (st).next() endif );
  static   operation readInt() : int
  pre: true
  post: true
  activity: (     return (read())->toInteger() );
  static   operation readLong() : long
  pre: true
  post: true
  activity: (     return (read())->toLong() );
  static   operation readDouble() : double
  pre: true
  post: true
  activity: (     return (read())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    StringTokenizer st ;
    st=new StringTokenizer(br.readLine());
    int p=Integer.parseInt(st.nextToken());
    int y=Integer.parseInt(st.nextToken());
    boolean[] isPrime=new boolean[1000001];
    for(int i=0 ; i<=1000000 ; i++){
      isPrime[i]=true ;
    }
    isPrime[0]=false ;
    isPrime[1]=false ;
    for(int i=2 ; i<=1000000 ; i++){
      if(isPrime[i]){
        for(int j=i+i ; j<=1000000 ; j+=i){
          isPrime[j]=false ;
        }
      }
    }
    int answer=-1 ;
    for(int i=y ; i>p ; i--){
      boolean flag=true ;
      for(int j=2 ; j<=Math.min(1000000,p); j++){
        if(isPrime[j] && i % j==0){
          flag=false ;
        }
      }
      if(flag){
        answer=i ;
        break ;
      }
    }
    bw.write(answer+"");
    bw.flush();
    bw.close();
    br.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var st : OclIterator ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    var p : int ; p := (st.next())->toInteger() ;
    var y : int ; y := (st.next())->toInteger() ;
    var isPrime : Sequence(boolean) ; isPrime := Integer.subrange(1,1000001)->collect(false) ;
        var i : int ; i := 0 ; while i <= 1000000 do ( (     isPrime[i+1] := true )  ;     i := i + 1 ) ; 
    isPrime[0+1] := false ; 
    isPrime[1+1] := false ; 
        var i : int ; i := 2 ; while i <= 1000000 do ( (     if (isPrime[i+1]) then (         var j : int ; j := i + i ; while j <= 1000000 do ( (     isPrime[j+1] := false )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    var answer : int ; answer := -1 ;
        var i : int ; i := y ; while i > p do ( (     var flag : boolean ; flag := true ;
         var j : int ; j := 2 ; while j <= Set{1000000, p}->min() do ( (     if (isPrime[j+1] & i mod j = 0) then (     flag := false ) else skip )  ;     j := j + 1 ) ; 
     if (flag) then (     answer := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class VileGrasshoppers {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  static int p ;
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    String[] temp=br.readLine().split(" ");
    p=Integer.parseInt(temp[0]);
    int y=Integer.parseInt(temp[1]);
    for(int i=y ; i>p ; i--){
      if(i % 2==0){
        continue ;
      }
      if(primeFactorization(i)){
        pr.println(i);
        return ;
      }
    }
    pr.println(-1);
  }
  public static boolean primeFactorization(int num){
    for(int i=2 ; i*i<=num ; i++){
      while(num % i==0){
        num/=i ;
        if(i<=p){
          return false ;
        }
      }
    }
    if(num>1 && num<=p){
      return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class VileGrasshoppers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   attribute p : int;
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
     p := (temp[0+1])->toInteger() ; 
    var y : int ; y := (temp[1+1])->toInteger() ;
        var i : int ; i := y ; while i > p do ( (     if (i mod 2 = 0) then (     continue ) else skip ; 
     if (primeFactorization(i)) then (     skip ; 
     return ) else skip )  ;     i := i - 1 ) ; 
    skip ; 
 );
  static   operation primeFactorization( num : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= num do ( (     while (num mod i = 0) do (     num := num/(i) ; 
     if (i <= p) then (     return false ) else skip ) )  ;     i := i + 1 ) ; 
     if (num > 1 & num <= p) then (     return false ) else skip ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
class GFG {
  static long findSum(int n){
    long sum2,sum5,sum10 ;
    sum2=((n/2)*(4+(n/2-1)*2))/2 ;
    sum5=((n/5)*(10+(n/5-1)*5))/2 ;
    sum10=((n/10)*(20+(n/10-1)*10))/2 ;
    return sum2+sum5-sum10 ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(findSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSum( n : int) : long
  pre: true
  post: true
  activity: (     var sum2 : long ;
    var sum5 : long ;
    var sum10 : long ;
     sum2 := ((n / 2) * (4 + (n / 2 - 1) * 2)) / 2 ; 
    sum5 := ((n / 5) * (10 + (n / 5 - 1) * 5)) / 2 ; 
    sum10 := ((n / 10) * (20 + (n / 10 - 1) * 10)) / 2 ; 
    return sum2 + sum5 - sum10 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(findSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void maxRegions(int n){
    int num ;
    num=n*(n+1)/2+1 ;
    System.out.println(num);
    ;
  }
  public static void main(String[] args){
    int n=10 ;
    maxRegions(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxRegions( n : int) : void
  pre: true
  post: true
  activity: (     var num : int ;
     num := n * (n + 1) / 2 + 1 ; 
     OclFile["System.out"].println(num) ; 
  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     execute maxRegions(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static void solve(){
    int n=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    int ans=-1 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        String s=String.valueOf(a[i]*a[j]);
        boolean f=true ;
        for(int k=0 ; k<s.length()-1 ; k++){
          if(s.charAt(k)+1!=s.charAt(k+1))f=false ;
        }
        if(f){
          ans=Math.max(ans,a[i]*a[j]);
        }
      }
    }
    out.println(ans);
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    solve();
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -1 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var s : String ; s := ((a[i+1] * a[j+1]) + "") ;
     var f : boolean ; f := true ;
         var k : int ; k := 0 ; while k < s->size() - 1 do ( (     if (s->at(k+1) + 1 /= s->at(k + 1+1)) then     f := false ; else skip )  ;     k := k + 1 ) ; 
     if (f) then (     ans := Set{ans, a[i+1] * a[j+1]}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    execute solve() ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  private static class Team implements Comparable<Team>{
    public String name ;
    public int win ;
    public int lose ;
    public Team(String name,int win,int lose){
      this.name=name ;
      this.win=win ;
      this.lose=lose ;
    }
    @ Override public String toString(){
      return name ;
    }
    @ Override public int compareTo(Team other){
      if(this.win>other.win){
        return-1 ;
      }
      else if(this.win==other.win){
        if(this.lose<other.lose){
          return-1 ;
        }
        else if(this.lose==other.lose){
          return 0 ;
        }
        else {
          return 1 ;
        }
      }
      else {
        return 1 ;
      }
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      final int teams=Integer.parseInt(sc.nextLine());
      if(teams==0){
        break ;
      }
      ArrayList<Team>list=new ArrayList<Team>(teams);
      for(int i=0 ; i<teams ; i++){
        String[] strs=sc.nextLine().split(" ");
        int win=0,lose=0 ;
        for(int j=1 ; j<strs.length ; j++){
          int tmp=Integer.parseInt(strs[j]);
          if(tmp==0){
            win++;
          }
          else if(tmp==1){
            lose++;
          }
        }
        list.add(new Team(strs[0],win,lose));
      }
      Collections.sort(list);
      for(Team t : list){
        System.out.println(t);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Team implements Comparable<Team> {
   attribute name : String;
   attribute win : int;
   attribute lose : int;
   static operation newTeam( name : String, win : int, lose : int) : Team
  pre: true
  post: true
  activity:
  ( var self : Team ;
    self := createTeam();
    self.initialise(name, win,lose);
    return self );
  operation initialise( name : String, win : int, lose : int) : void
  pre: true  post: true
  activity: (     self.name := name ; 
     self.win := win ; 
     self.lose := lose );
      operation toString() : String
  pre: true
  post: true
  activity: (     return name );
      operation compareTo( other : Team) : int
  pre: true
  post: true
  activity: (     if (self.win > other.win) then (     return -1 ) else     if (self.win = other.win) then (     if (self.lose < other.lose) then (     return -1 ) else     if (self.lose = other.lose) then (     return 0 ) else (     return 1 ) ;  ) else (     return 1 ) ;  );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var teams : int ; teams := (sc.nextLine())->toInteger() ;
     if (teams = 0) then (     break ) else skip ; 
    var list : Sequence(Team) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < teams do ( (     var strs : Sequence(String) ; strs := sc.nextLine()->split(" ") ;
     var win : int ; win := 0 ;
    var lose : int ; lose := 0 ;
         var j : int ; j := 1 ; while j < strs->size() do ( (     var tmp : int ; tmp := (strs[j+1])->toInteger() ;
     if (tmp = 0) then (     win := win + 1 ) else     if (tmp = 1) then (     lose := lose + 1 ) else skip ; )  ;     j := j + 1 ) ; 
     list := list->including(Team.newTeam(strs[0+1], win, lose)) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    for (t : list) do ( (     OclFile["System.out"].println(t) )  ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findTriangles(int n){
    int num ;
    num=n*(n-4);
    System.out.println(num);
  }
  public static void main(String[] args){
    int n ;
    n=6 ;
    findTriangles(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findTriangles( n : int) : void
  pre: true
  post: true
  activity: (     var num : int ;
     num := n * (n - 4) ; 
     OclFile["System.out"].println(num) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     n := 6 ; 
     execute findTriangles(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int[] v=new int[5005];
    for(int i=0 ; i<5005 ; i++){
      v[i]=1 ;
    }
    int p=3 ;
    while(true){
      if(p*p>10010){
        break ;
      }
      else {
        if(v[(p-1)/2]==0){
          p+=2 ;
        }
        else {
          int t=p*p ;
          while(t<10010){
            v[(t-1)/2]=0 ;
            t+=2*p ;
          }
          p+=2 ;
        }
      }
    }
    while(scan.hasNext()){
      int n=scan.nextInt();
      if(n==0){
        break ;
      }
      else if(n % 2==0){
        n--;
      }
      for(int i=n/2 ; i>1 ; i--){
        if(v[i]*v[i-1]==1){
          System.out.println(2*(i-1)+1+" "+(2*i+1));
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var v : Sequence(int) ; v := Integer.subrange(1,5005)->collect(0) ;
        var i : int ; i := 0 ; while i < 5005 do ( (     v[i+1] := 1 )  ;     i := i + 1 ) ; 
    var p : int ; p := 3 ;
    while (true) do (     if (p * p > 10010) then (     break ) else (     if (v[(p - 1) / 2+1] = 0) then (     p := p+(2) ) else (     var t : int ; t := p * p ;
     while (t < 10010) do (     v[(t - 1) / 2+1] := 0 ; 
     t := t+(2 * p) ) ; 
     p := p+(2) ) ) ) ; 
    while (scan.hasNext()) do (     var n : int ; n := scan.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else     if (n mod 2 = 0) then (     n := n - 1 ) else skip ; ;  
         var i : int ; i := n / 2 ; while i > 1 do ( (     if (v[i+1] * v[i - 1+1] = 1) then (     OclFile["System.out"].println(2 * (i - 1) + 1 + " " + (2 * i + 1)) ; 
     break ) else skip )  ;     i := i - 1 ) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  static int N=10001 ;
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int[] p ;
    int pn,i,n,p1,q1 ;
    p=new int[N/6];
    pn=getprime(p);
    for(; ; ){
      n=sc.nextInt();
      if(n==0)break ;
      p1=3 ;
      q1=5 ;
      for(i=2 ; p[i]<=n && i<pn ; i++)if(p[i]-p[i-1]==2){
        p1=p[i-1];
        q1=p[i];
      }
      out.println(p1+" "+q1);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
  private static int getprime(int[] p){
    int i,j,count=0 ;
    boolean[] e ;
    e=new boolean[N];
    e[0]=true ;
    e[1]=true ;
    for(i=2 ; i<N ; i++)if(! e[i]){
      p[count++]=i ;
      for(j=i*2 ; j<N ; j+=i)e[j]=true ;
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   attribute N : int := 10001;
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var p : Sequence(int) ;
    var pn : int ;
    var i : int ;
    var n : int ;
    var p1 : int ;
    var q1 : int ;
    p := Integer.subrange(1,N / 6)->collect(0) ; 
    pn := getprime(p) ; 
      while true do ( (     n := sc.nextInt() ; 
     if (n = 0) then     break else skip ; 
    p1 := 3 ; 
    q1 := 5 ; 
        i := 2 ; while p[i+1] <= n & i < pn do (     if (p[i+1] - p[i - 1+1] = 2) then (     p1 := p[i - 1+1] ; 
     q1 := p[i+1] ) else skip ;  ;     i := i + 1 ) ; 
    out.println(p1 + " " + q1) ; 
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
  static   operation getprime( p : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var count : int ; count := 0 ;
     var e : Sequence(boolean) ;
    e := Integer.subrange(1,N)->collect(false) ; 
    e[0+1] := true ; 
    e[1+1] := true ; 
        i := 2 ; while i < N do (     if (not(e[i+1])) then (      p[count+1] := i  ; count := count + 1 ; 
         j := i * 2 ; while j < N do (     e[j+1] := true ;  ;     j := j+(i) ) ) else skip ;  ;     i := i + 1 ) ; 
    return count 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  List<Integer>prime ;
  public List<Integer>initialize(){
    List<Integer>list=new ArrayList<Integer>();
    list.add(2);
    list.add(3);
    for(int i=5 ; i<102 ; i+=2){
      for(Integer x : list){
        if(x>Math.sqrt(i)){
          list.add(i);
          break ;
        }
        if(i % x==0){
          break ;
        }
      }
    }
    return list ;
  }
  public void solve()throws IOException {
    prime=new ArrayList<Integer>(initialize());
    int n ;
    while((n=nextInt())!=0){
      boolean flag=false ;
      n=(n % 2==0)? n-1 : n ;
      out : for(int i=n ;
      ;
      i-=2){
        for(Integer x : prime){
          if(x>Math.sqrt(i)){
            if(flag){
              writer.println(i+" "+(i+2));
              break out ;
            }
            else {
              flag=true ;
              break ;
            }
          }
          if(i % x==0){
            flag=false ;
            break ;
          }
        }
      }
    }
    writer.flush();
  }
  public static void main(String args[])throws IOException {
    new Main().run();
  }
  BufferedReader reader ;
  StringTokenizer tokenizer ;
  PrintWriter writer ;
  public void run()throws IOException {
    try {
      reader=new BufferedReader(new InputStreamReader(System.in));
      tokenizer=null ;
      writer=new PrintWriter(System.out);
      solve();
      reader.close();
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public String nextToken()throws IOException {
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute prime : Sequence(int);
   operation initialize() : Sequence(int)
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     list := list->including(2) ; 
    list := list->including(3) ; 
        var i : int ; i := 5 ; while i < 102 do ( (     for (x : list) do ( (     if (x > (i)->sqrt()) then (     list := list->including(i) ; 
     break ) else skip ; 
     if (i mod x = 0) then (     break ) else skip )  ) )  ;     i := i+(2) ) ; 
    return list 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     prime := Sequence{}->union(initialize()) ; 
     var n : int ;
         n := nextInt() ;
    while ((n) /= 0) do (    skip ; (     var flag : boolean ; flag := false ;
     n := if (n mod 2 = 0) then n - 1 else n endif ; 
         var i : int ; i := n ; while true do ( (     for (x : prime) do ( (     if (x > (i)->sqrt()) then (     if (flag) then (     writer.println(i + " " + (i + 2)) ; 
     break ) else (     flag := true ; 
     break ) ) else skip ; 
     if (i mod x = 0) then (     flag := false ; 
     break ) else skip )  ) )  ;     i := i-(2) ) ; ) ;     n := nextInt() ;
 ) ;  
     writer.flush() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   attribute writer : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     try (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := null ; 
    writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    boolean[] fs=new boolean[10001];
    for(int i=0 ; i<10001 ; i++){
      fs[i]=isPrime(i-2)&& isPrime(i);
    }
    for(; sc.hasNext(); ){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      for(; ! fs[n]; n--);
      println((n-2)+" "+n);
    }
  }
  boolean isPrime(int n){
    for(int i=2 ; i*i<=n ; i++){
      if(n % i==0){
        return false ;
      }
    }
    return n>=2 ;
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     var fs : Sequence(boolean) ; fs := Integer.subrange(1,10001)->collect(false) ;
         var i : int ; i := 0 ; while i < 10001 do ( (     fs[i+1] := isPrime(i - 2) & isPrime(i) )  ;     i := i + 1 ) ; 
       while sc.hasNext() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
       while not(fs[n+1]) do (   ;     n := n - 1 ) ; 
     execute println((n - 2) + " " + n) )  ) );
   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return n >= 2 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class PalinPath {
  public static boolean isPalin(String str){
    int len=str.length()/2 ;
    for(int i=0 ; i<len ; i++){
      if(str.charAt(i)!=str.charAt(str.length()-i-1))return false ;
    }
    return true ;
  }
  public static void palindromicPath(String str,char a[][],int i,int j,int m,int n){
    if(j<m-1 || i<n-1){
      if(i<n-1)palindromicPath(str+a[i][j],a,i+1,j,m,n);
      if(j<m-1)palindromicPath(str+a[i][j],a,i,j+1,m,n);
    }
    else {
      str=str+a[n-1][m-1];
      if(isPalin(str))System.out.println(str);
    }
  }
  public static void main(String args[]){
    char arr[][]={
      {
        'a','a','a','b' },{
          'b','a','a','a' },{
            'a','b','b','a' }
          };
          String str="" ;
          palindromicPath(str,arr,0,0,4,3);
        }
      }

------------------------------------------------------------
OCL File:
---------
class PalinPath {
  static   operation isPalin( str : String) : boolean
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() / 2 ;
         var i : int ; i := 0 ; while i < len do ( (     if (str->at(i+1) /= str->at(str->size() - i - 1+1)) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation palindromicPath( str : String, a : Sequence(Sequence(String)), i : int, j : int, m : int, n : int) : void
  pre: true
  post: true
  activity: (     if (j < m - 1 or i < n - 1) then (     if (i < n - 1) then     execute palindromicPath(str + a[i+1][j+1], a, i + 1, j, m, n) ; else skip ; 
     if (j < m - 1) then     execute palindromicPath(str + a[i+1][j+1], a, i, j + 1, m, n) ; else skip ) else (     str := str + a[n - 1+1][m - 1+1] ; 
     if (isPalin(str)) then     OclFile["System.out"].println(str) ; else skip ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(String)) ; arr := Sequence{Sequence{'a','a','a','b'},Sequence{'b','a','a','a'},Sequence{'a','b','b','a'}} ;
     var str : String ; str := "" ;
     execute palindromicPath(str, arr, 0, 0, 4, 3) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.nio.Buffer ;
import java.util.*;
public class Main2 {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int testCases=sc.nextInt();
    while(testCases-->0){
      int length=sc.nextInt();
      int[] array=new int[length];
      int p=sc.nextInt();
      for(int i=0 ; i<length ; i++)array[i]=sc.nextInt();
      HashSet<Integer>set=new HashSet<>();
      for(int i=0 ; i<p ; i++)set.add(sc.nextInt());
      for(int i=0 ; i<length ; i++){
        for(int j=0 ; j<length-1 ; j++){
          if(array[j]>array[j+1]){
            if(set.contains(j+1)){
              int temp=array[j+1];
              array[j+1]=array[j];
              array[j]=temp ;
            }
          }
        }
      }
      boolean sorted=true ;
      for(int i=0 ; i<array.length-1 ; i++){
        if(array[i]>array[i+1])sorted=false ;
      }
      if(sorted){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := sc.getCurrent()->toInteger() ;
         while (testCases > 0) do (        testCases := testCases - 1 ;     skip ; (     var length : int ; length := sc.getCurrent()->toInteger() ;
     var array : Sequence(int) ; array := Integer.subrange(1,length)->collect(0) ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < length do (     array[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < p do (     set := set->including(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < length do ( (         var j : int ; j := 0 ; while j < length - 1 do ( (     if (array[j+1] > array[j + 1+1]) then (     if (set->includes(j + 1)) then (     var temp : int ; temp := array[j + 1+1] ;
     array[j + 1+1] := array[j+1] ; 
     array[j+1] := temp ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sorted : boolean ; sorted := true ;
        var i : int ; i := 0 ; while i < array->size() - 1 do ( (     if (array[i+1] > array[i + 1+1]) then     sorted := false ; else skip )  ;     i := i + 1 ) ; 
    if (sorted) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    st=new StringTokenizer(br.readLine());
    int array[]=new int[n+1];
    long sum=0 ;
    for(int i=1 ; i<=n ; i++){
      int a=Integer.parseInt(st.nextToken());
      array[i]=a ;
      sum+=a ;
    }
    if(sum*2 %(n*1L*(n+1))!=0){
      System.out.println("NO");
      return ;
    }
    long times=sum*2/(n*1L*(n+1));
    int cnt=0 ;
    array[0]=array[n];
    for(int i=1 ; i<=n ; i++){
      long diff=array[i]-array[i-1]-times ;
      if(diff>0){
        System.out.println("NO");
        return ;
      }
      if(diff<0){
        if(Math.abs(diff)% n>0){
          System.out.println("NO");
          return ;
        }
        cnt+=Math.abs(diff)/n ;
      }
    }
    if(cnt>times){
      System.out.println("NO");
      return ;
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    var array : Sequence(int) ; array := Integer.subrange(1,n + 1)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var a : int ; a := (st.next())->toInteger() ;
     array[i+1] := a ; 
     sum := sum+(a) )  ;     i := i + 1 ) ; 
    if (sum * 2 mod (n * 1L * (n + 1)) /= 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    var times : long ; times := sum * 2 / (n * 1L * (n + 1)) ;
    var cnt : int ; cnt := 0 ;
    array[0+1] := array[n+1] ; 
        var i : int ; i := 1 ; while i <= n do ( (     var diff : long ; diff := array[i+1] - array[i - 1+1] - times ;
     if (diff > 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
     if (diff < 0) then (     if (if diff < 0 then -(diff) else diff endif mod n > 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
     cnt := cnt+(if diff < 0 then -(diff) else diff endif / n) ) else skip )  ;     i := i + 1 ) ; 
    if (cnt > times) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int binomialCoeff(int n,int k){
    int C[][]=new int[n+1][k+1];
    int i,j ;
    for(i=0 ; i<=n ; i++){
      for(j=0 ; j<=Math.min(i,k); j++){
        if(j==0 || j==i)C[i][j]=1 ;
        else C[i][j]=C[i-1][j-1]+C[i-1][j];
      }
    }
    return C[n][k];
  }
  public static void main(String[] args){
    int n=5,k=3 ;
    System.out.println("Total number of "+"different ways are "+binomialCoeff(n-1,k-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation binomialCoeff( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var C : Sequence(Sequence(int)) ; C := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,k + 1)->collect(0)) ;
     var i : int ;
    var j : int ;
         i := 0 ; while i <= n do ( (         j := 0 ; while j <= Set{i, k}->min() do ( (     if (j = 0 or j = i) then     C[i+1][j+1] := 1 ; else     C[i+1][j+1] := C[i - 1+1][j - 1+1] + C[i - 1+1][j+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return C[n+1][k+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var k : int ; k := 3 ;
     OclFile["System.out"].println("Total number of " + "different ways are " + binomialCoeff(n - 1, k - 1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static char[] CHARS="0123456789ABCDEF".toCharArray();
  static int DIGITS=16 ;
  static boolean isDivisible(String s,int m){
    Map<Character,Integer>mp=new HashMap<>();
    for(int i=0 ; i<DIGITS ; i++){
      mp.put(CHARS[i],i);
    }
    int r=0 ;
    for(int i=0 ; i<s.length(); i++){
      r=(r*16+mp.get(s.charAt(i)))% m ;
    }
    if(r==0)return true ;
    return false ;
  }
  public static void main(String[] args){
    String s="10" ;
    int m=3 ;
    if(isDivisible(s,m))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute CHARS : Sequence(String) := "0123456789ABCDEF"->characters();
  static   attribute DIGITS : int := 16;
  static   operation isDivisible( s : String, m : int) : boolean
  pre: true
  post: true
  activity: (     var mp : Map(String,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < DIGITS do ( (     mp := mp->union(Map{CHARS[i+1] |-> i}) )  ;     i := i + 1 ) ; 
    var r : int ; r := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     r := (r * 16 + mp->at(s->at(i+1))) mod m )  ;     i := i + 1 ) ; 
    if (r = 0) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "10" ;
     var m : int ; m := 3 ;
     if (isDivisible(s, m)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      R[] rs=new R[n];
      for(int j=0 ; j<n ; j++){
        rs[j]=new R();
        rs[j] .name=sc.next();
        for(int i=0 ; i<n-1 ; i++){
          switch(sc.nextInt()){
            case 0 : rs[j] .win--;
            break ;
            case 1 : rs[j] .lose++;
            break ;
          }
        }
      }
      Arrays.sort(rs);
      for(R r : rs){
        println(r.name);
      }
    }
  }
  class R implements Comparable<R>{
    int win,lose ;
    String name ;
    @ Override public int compareTo(R r){
      if(win!=r.win){
        return win-r.win ;
      }
      else {
        return lose-r.lose ;
      }
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var rs : Sequence(R) ; rs := Integer.subrange(1,n)->collect(null) ;
        var j : int ; j := 0 ; while j < n do ( (     rs[j+1] := R.newR() ; 
     rs[j+1].name := sc.getCurrent() ; 
         var i : int ; i := 0 ; while i < n - 1 do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (sc.getCurrent()->toInteger()) ; 
       if _switchval = 0 then
     rs[j+1].win := rs[j+1].win - 1 ; 
    break 
   else skip ;
       if _switchval = 1 then
     rs[j+1].lose := rs[j+1].lose + 1 ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    rs := rs->sort() ; 
    for (r : rs) do ( (     execute println(r.name) )  ) ; 
 )  ) );
 class R implements Comparable<R> {
   attribute win : int;
   attribute name : String;
      operation compareTo( r : R) : int
  pre: true
  post: true
  activity: (     if (win /= r.win) then (     return win - r.win ) else (     return lose - r.lose ) );
}
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void CheckSubarray(int arr[],int N){
    int presum[]=new int[N+1];
    for(int i=1 ; i<=N ; i+=1){
      presum[i]=presum[i-1]+arr[i-1];
    }
    for(int i=1 ; i<=N ; i+=1){
      for(int j=i ; j<=N ; j+=1){
        if((presum[j]-presum[i-1])% N==0){
          System.out.print((i-1)+" "+(j-1));
          return ;
        }
      }
    }
    System.out.print(-1);
  }
  public static void main(String[] args){
    int[] arr={
      7,5,3,7 };
      int N=arr.length ;
      CheckSubarray(arr,N);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation CheckSubarray( arr : Sequence(int), N : int) : void
  pre: true
  post: true
  activity: (     var presum : Sequence(int) ; presum := Integer.subrange(1,N + 1)->collect(0) ;
         var i : int ; i := 1 ; while i <= N do ( (     presum[i+1] := presum[i - 1+1] + arr[i - 1+1] )  ;     i := i+(1) ) ; 
         var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := i ; while j <= N do ( (     if ((presum[j+1] - presum[i - 1+1]) mod N = 0) then (     OclFile["System.out"].print((i - 1) + " " + (j - 1)) ; 
     return ) else skip )  ;     j := j+(1) ) )  ;     i := i+(1) ) ; 
     OclFile["System.out"].print(-1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{7,5,3,7} ;
     var N : int ; N := arr->size() ;
     execute CheckSubarray(arr, N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static void maxSum(int[] a,int n){
    int maxAnd=Arrays.stream(a).max().getAsInt();
    int maxOR=0 ;
    for(int i=0 ; i<n ; i++){
      maxOR |=a[i];
    }
    System.out.println((maxAnd+maxOR));
  }
  public static void main(String[] args){
    int n=4 ;
    int[] a={
      3,5,6,1 };
      maxSum(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSum( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var maxAnd : int ; maxAnd := stream(a).max().getAsInt() ;
     var maxOR : int ; maxOR := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     maxOR := MathLib.bitwiseOr(maxOR, a[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println((maxAnd + maxOR)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var a : Sequence(int) ; a := Sequence{3,5,6,1} ;
     execute maxSum(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findGreatest(int arr[],int n){
    Map<Integer,Integer>m=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(m.containsKey(arr[i])){
        m.put(arr[i],m.get(arr[i])+1);
      }
      else {
        m.put(arr[i],m.get(arr[i]));
      }
    }
    Arrays.sort(arr);
    for(int i=n-1 ; i>1 ; i--){
      for(int j=0 ; j<i && arr[j]<=Math.sqrt(arr[i]); j++){
        if(arr[i] % arr[j]==0){
          int result=arr[i]/arr[j];
          if(result!=arr[j] && m.get(result)==null || m.get(result)>0){
            return arr[i];
          }
          else if(result==arr[j] && m.get(result)>1){
            return arr[i];
          }
        }
      }
    }
    return-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      17,2,1,15,30 };
      int n=arr.length ;
      System.out.println(findGreatest(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findGreatest( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var m : Map(int,int) ; m := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (m->keys()->includes(arr[i+1])) then (     m := m->union(Map{arr[i+1] |-> m->at(arr[i+1]) + 1}) ) else (     m := m->union(Map{arr[i+1] |-> m->at(arr[i+1])}) ) )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := n - 1 ; while i > 1 do ( (         var j : int ; j := 0 ; while j < i & arr[j+1] <= (arr[i+1])->sqrt() do ( (     if (arr[i+1] mod arr[j+1] = 0) then (     var result : int ; result := arr[i+1] / arr[j+1] ;
     if (result /= arr[j+1] & m->at(result) = null or m->at(result) > 0) then (     return arr[i+1] ) else     if (result = arr[j+1] & m->at(result) > 1) then (     return arr[i+1] ) else skip ; ) else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{17,2,1,15,30} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findGreatest(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int divisor(int a){
    int div=1,count=0 ;
    for(int i=2 ; i<=Math.sqrt(a); i++){
      while(a % i==0){
        count++;
        a=a/i ;
      }
      div=div*(count+1);
      count=0 ;
    }
    if(a>1){
      div=div*(2);
    }
    return div ;
  }
  static int OddDivCount(int a,int b){
    int res=0 ;
    for(int i=a ; i<=b ; ++i){
      int divCount=divisor(i);
      if(divCount % 2==1){
++res ;
      }
    }
    return res ;
  }
  public static void main(String[] args){
    int a=1,b=10 ;
    System.out.println(OddDivCount(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation divisor( a : int) : int
  pre: true
  post: true
  activity: (     var div : int ; div := 1 ;
    var count : int ; count := 0 ;
         var i : int ; i := 2 ; while i <= (a)->sqrt() do ( (     while (a mod i = 0) do (     count := count + 1 ; 
     a := a / i ) ; 
     div := div * (count + 1) ; 
     count := 0 )  ;     i := i + 1 ) ; 
     if (a > 1) then (     div := div * (2) ) else skip ; 
     return div );
  static   operation OddDivCount( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := a ; while i <= b do ( (     var divCount : int ; divCount := divisor(i) ;
     if (divCount mod 2 = 1) then (     res := res + 1 ) else skip )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 1 ;
    var b : int ; b := 10 ;
     OclFile["System.out"].println(OddDivCount(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static class LongInteger {
    ArrayList<Integer>n ;
    int dsum=-1 ;
    public LongInteger(String str){
      n=new ArrayList<>();
      for(int i=str.length()-1 ; i>=0 ; i--){
        n.add(str.charAt(i)-'0');
      }
    }
    public int dsum(){
      if(dsum==-1){
        dsum=0 ;
        for(int i : n)dsum+=i ;
      }
      return dsum ;
    }
    public void multi(int x){
      ArrayList<Integer>nn=new ArrayList<>();
      int carry=0 ;
      for(int i : n){
        int temp=i*x+carry ;
        nn.add(temp % 10);
        carry=temp/10 ;
      }
      while(carry>0){
        nn.add(carry % 10);
        carry/=10 ;
      }
      n=nn ;
      dsum=-1 ;
    }
    public void add(int x){
      int carry=x ;
      int idx=0 ;
      while(carry>0){
        int temp=(idx<n.size()? n.get(idx): 0)+carry ;
        dsum+=temp % 10-(idx<n.size()? n.get(idx): 0);
        if(idx<n.size())n.set(idx,temp % 10);
        else n.add(temp % 10);
        carry=temp/10 ;
        idx++;
      }
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    LongInteger N=new LongInteger(str);
    N.multi(9);
    for(int i=0 ; i<=str.length(); i++){
      if(N.dsum()<=i*9){
        System.out.println(i);
        break ;
      }
      N.add(9);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class LongInteger {
   attribute n : Sequence(int);
   attribute dsum : int := -1;
   static operation newLongInteger( str : String) : LongInteger
  pre: true
  post: true
  activity:
  ( var self : LongInteger ;
    self := createLongInteger();
    self.initialise(str);
    return self );
  operation initialise( str : String) : void
  pre: true  post: true
  activity: (     n := Sequence{} ; 
         var i : int ; i := str->size() - 1 ; while i >= 0 do ( (     n := n->including(str->at(i+1) - ('0')->char2byte()) )  ;     i := i - 1 ) );
   operation dsum() : int
  pre: true
  post: true
  activity: (     if (dsum = -1) then (     dsum := 0 ; 
     for (i : n) do (     dsum := dsum+(i) ;  ) ) else skip ; 
     return dsum );
   operation multi( x : int) : void
  pre: true
  post: true
  activity: (     var nn : Sequence(int) ; nn := Sequence{} ;
     var carry : int ; carry := 0 ;
    for (i : n) do ( (     var temp : int ; temp := i * x + carry ;
     nn := nn->including(temp mod 10) ; 
     carry := temp / 10 )  ) ; 
    while (carry > 0) do (     nn := nn->including(carry mod 10) ; 
     carry := carry/(10) ) ; 
    n := nn ; 
    dsum := -1 ; 
 );
   operation add( x : int) : void
  pre: true
  post: true
  activity: (     var carry : int ; carry := x ;
     var idx : int ; idx := 0 ;
     while (carry > 0) do (     var temp : int ; temp := (if idx < n->size() then n->at(idx+1) else 0 endif) + carry ;
     dsum := dsum+(temp mod 10 - (if idx < n->size() then n->at(idx+1) else 0 endif)) ; 
    if (idx < n->size()) then     n := n.setAt(idx+1,temp mod 10) else     n := n->including(temp mod 10) ; ;  
    carry := temp / 10 ; 
    idx := idx + 1 ; 
 ) );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var N : LongInteger ; N := LongInteger.newLongInteger(str) ;
    N.multi(9) ; 
        var i : int ; i := 0 ; while i <= str->size() do ( (     if (N.dsum() <= i * 9) then (     OclFile["System.out"].println(i) ; 
     break ) else skip ; 
     N->excludes(9) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskE solver=new TaskE();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskE {
    static final int BASE=10 ;
    public void solve(int testNumber,InputReader in,PrintWriter out){
      String n=in.next();
      long left=0 ;
      long right=1 ;
      while(! enough(n,right))right*=2 ;
      while(right-left>1){
        long middle=(left+right)/2 ;
        if(enough(n,middle)){
          right=middle ;
        }
        else {
          left=middle ;
        }
      }
      out.println(right);
    }
    private boolean enough(String n,long limit){
      limit*=(BASE-1);
      long carry=0 ;
      for(int i=n.length()-1 ; i>=0 ; --i){
        long cur=n.charAt(i)-'0' ;
        cur-=carry ;
        carry=0 ;
        if(cur>limit)return false ;
        long sub=(limit-cur)% BASE ;
        limit-=sub ;
        carry+=(limit-cur)/BASE ;
        if(limit<0)return false ;
      }
      return true ;
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskE ; solver := TaskE.newTaskE() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskE {
  static    attribute BASE : int := 10;
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : String ; n := in.next() ;
     var left : long ; left := 0 ;
    var right : long ; right := 1 ;
    while (not(enough(n, right))) do     right := right*(2) ; ; 
    while (right - (left)->char2byte() > 1) do (     var middle : long ; middle := (left + right) / 2 ;
     if (enough(n, middle)) then (     right := middle ) else (     left := middle ) ) ; 
    skip ; 
 );
   operation enough( n : String, limit : long) : boolean
  pre: true
  post: true
  activity: (     limit := limit*((BASE - 1)) ; 
     var carry : long ; carry := 0 ;
         var i : int ; i := n->size() - 1 ; while i >= 0 do ( (     var cur : long ; cur := n->at(i+1) - ('0')->char2byte() ;
     cur := cur-(carry) ; 
    carry := 0 ; 
    if (cur > limit) then     return false else skip ; 
    var sub : long ; sub := (limit - cur) mod BASE ;
    limit := limit-(sub) ; 
    carry := carry+((limit - cur) / BASE) ; 
    if (limit < 0) then     return false else skip ; 
 )  ;     i := i - 1 ) ; 
     return true );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    Scanner sc=new Scanner(systemin);
    long N=sc.nextLong();
    int A=sc.nextInt();
    int B=sc.nextInt();
    N=N % 12 ;
    for(int i=0 ; i<N ; i++){
      if(i % 2==0){
        A=A-B ;
      }
      else {
        B=A+B ;
      }
    }
    System.out.printf("%d %d\n",A,B);
    sc.close();
    return false ;
  }
  PrintStream log ;
  PrintStream result=System.out ;
  BufferedReader systemin ;
  static Main instance=new Main();
  Main(){
    systemin=new BufferedReader(new InputStreamReader(System.in));
    log=new PrintStream(new OutputStream(){
      public void write(int b){
      }
    }
);
  }
  public static void main(String[] args)throws IOException {
    instance.main();
    instance.systemin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(systemin) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    N := N mod 12 ; 
        var i : int ; i := 0 ; while i < N do ( (     if (i mod 2 = 0) then (     A := A - B ) else (     B := A + B ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%d %d\n", A, B) ; 
    skip ; 
    return false 
 );
   attribute log : OclFile;
   attribute result : OclFile := OclFile["System.out"];
   attribute systemin : OclFile;
  static   attribute instance : Main := Main.newMain();
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     systemin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     log := OclFile.newOclFile_Write(OclFile()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     instance.main() ; 
     instance.systemin.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++)A[i]=scanner.nextInt();
    if(possible(N,A)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
  private static boolean possible(int N,int[] A){
    long sum=0 ;
    for(int i=0 ; i<N ; i++)sum+=A[i];
    long NS=(long)N*(N+1)/2 ;
    if(sum % NS!=0)return false ;
    long K=sum/NS ;
    for(int i=0 ; i<N ; i++){
      int j=i==0 ? N-1 : i-1 ;
      long d=K-(A[i]-A[j]);
      if(d<0 || d % N!=0)return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     A[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    if (possible(N, A)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
  static   operation possible( N : int, A : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var i : int ; i := 0 ; while i < N do (     sum := sum+(A[i+1]) ;  ;     i := i + 1 ) ; 
    var NS : long ; NS := N->oclAsType(long) * (N + 1) / 2 ;
    if (sum mod NS /= 0) then     return false else skip ; 
    var K : long ; K := sum / NS ;
        var i : int ; i := 0 ; while i < N do ( (     var j : int ; j := if i = 0 then N - 1 else i - 1 endif ;
     var d : long ; d := K - (A[i+1] - A[j+1]) ;
     if (d < 0 or d mod N /= 0) then     return false else skip )  ;     i := i + 1 ) ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long a=sc.nextInt();
    long b=sc.nextInt();
    n %=12 ;
    for(int i=0 ; i<n ; i++){
      if(i % 2==0){
        a=a-b ;
      }
      else {
        b=a+b ;
      }
    }
    System.out.println(a+" "+b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var a : long ; a := sc.getCurrent()->toInteger() ;
    var b : long ; b := sc.getCurrent()->toInteger() ;
    n := n mod 12 ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then (     a := a - b ) else (     b := a + b ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a + " " + b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long a=sc.nextInt();
    long b=sc.nextInt();
    n %=12 ;
    for(int i=1 ; i<n+1 ; i++){
      if(i % 2==1)a=a-b ;
      else b=a+b ;
    }
    System.out.println(a+" "+b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var a : long ; a := sc.getCurrent()->toInteger() ;
    var b : long ; b := sc.getCurrent()->toInteger() ;
    n := n mod 12 ; 
        var i : int ; i := 1 ; while i < n + 1 do ( (     if (i mod 2 = 1) then     a := a - b ; else     b := a + b ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a + " " + b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void findCombinationsUtil(int arr[],int index,int num,int reducedNum){
    if(reducedNum<0)return ;
    if(reducedNum==0){
      for(int i=0 ; i<index ; i++)System.out.print(arr[i]+" ");
      System.out.println();
      return ;
    }
    int prev=(index==0)? 1 : arr[index-1];
    for(int k=prev ; k<=num ; k++){
      arr[index]=k ;
      findCombinationsUtil(arr,index+1,num,reducedNum-k);
    }
  }
  static void findCombinations(int n){
    int arr[]=new int[n];
    findCombinationsUtil(arr,0,n,n);
  }
  public static void main(String[] args){
    int n=5 ;
    findCombinations(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findCombinationsUtil( arr : Sequence(int), index : int, num : int, reducedNum : int) : void
  pre: true
  post: true
  activity: (     if (reducedNum < 0) then     return else skip ; 
     if (reducedNum = 0) then (         var i : int ; i := 0 ; while i < index do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ; 
     return ) else skip ; 
     var prev : int ; prev := if (index = 0) then 1 else arr[index - 1+1] endif ;
         var k : int ; k := prev ; while k <= num do ( (     arr[index+1] := k ; 
     execute findCombinationsUtil(arr, index + 1, num, reducedNum - k) )  ;     k := k + 1 ) );
  static   operation findCombinations( n : int) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
     execute findCombinationsUtil(arr, 0, n, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute findCombinations(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] srgs){
    Scanner scan=new Scanner(System.in);
    int a=scan.nextInt();
    long c[]=new long[a+1];
    long count=0 ;
    for(int i=1 ; i!=a+1 ; i++){
      int b=scan.nextInt();
      count+=b ;
      c[i]=count ;
    }
    Arrays.sort(c);
    long co=0 ;
    for(int i=0 ; i!=a+1 ; i++){
    }
    count=0 ;
    for(int i=0 ; i!=a ; i++){
      co++;
      if(c[i]!=c[i+1]){
        count+=co*(co-1)/2 ;
        co=0 ;
      }
    }
    count+=(co+1)*(co)/2 ;
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( srgs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
    var c : Sequence(long) ; c := Integer.subrange(1,a + 1)->collect(0) ;
    var count : long ; count := 0 ;
        var i : int ; i := 1 ; while i /= a + 1 do ( (     var b : int ; b := scan.getCurrent()->toInteger() ;
     count := count+(b) ; 
     c[i+1] := count )  ;     i := i + 1 ) ; 
    c := c->sort() ; 
    var co : long ; co := 0 ;
        var i : int ; i := 0 ; while i /= a + 1 do ( skip  ;     i := i + 1 ) ; 
    count := 0 ; 
        var i : int ; i := 0 ; while i /= a do ( (     co := co + 1 ; 
     if (c[i+1] /= c[i + 1+1]) then (     count := count+(co * (co - 1) / 2) ; 
     co := 0 ) else skip )  ;     i := i + 1 ) ; 
    count := count+((co + 1) * (co) / 2) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
class Main {
  static long getCom(long i){
    return i*(i-1)/2 ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] input=br.readLine().split(" ");
    HashMap<Long,Long>data=new HashMap<Long,Long>();
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      long x=Long.parseLong(input[i]);
      sum+=x ;
      if(data.containsKey(sum)){
        data.put(sum,data.get(sum)+1);
      }
      else {
        data.put(sum,1l);
      }
    }
    long ans=0 ;
    for(long x : data.keySet()){
      long hindo=data.get(x);
      ans+=getCom(hindo);
    }
    if(data.containsKey(0l))ans+=data.get(0l);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation getCom( i : long) : long
  pre: true
  post: true
  activity: (     return i * (i - 1) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var input : Sequence(String) ; input := br.readLine()->split(" ") ;
    var data : Map(long,long) ; data := Map{} ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : long ; x := (input[i+1])->toLong() ;
     sum := sum+(x) ; 
     if (data->keys()->includes(sum)) then (     data := data->union(Map{sum |-> data->at(sum) + 1}) ) else (     data := data->union(Map{sum |-> 1l}) ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    for (x : data->keys()) do ( (     var hindo : long ; hindo := data->at(x) ;
     ans := ans+(getCom(hindo)) )  ) ; 
    if (data->keys()->includes(0l)) then     ans := ans+(data->at(0l)) ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Map ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[] A=new long[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextLong();
    }
    sc.close();
    long[] b=new long[N+1];
    for(int i=0 ; i<N ; i++){
      b[i+1]=b[i]+A[i];
    }
    Map<Long,Long>m=new TreeMap<Long,Long>();
    for(int i=1 ; i<=N ; i++){
      m.merge(b[i],1l,(v1,v2)->(v1+v2));
    }
    long ans=0 ;
    for(long k : m.keySet()){
      if(k==0){
        long t=m.get(k);
        ans+=t*(t+1)/2 ;
      }
      else {
        long t=m.get(k);
        ans+=t*(t-1)/2 ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    skip ; 
    var b : Sequence(long) ; b := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     b[i + 1+1] := b[i+1] + A[i+1] )  ;     i := i + 1 ) ; 
    var m : Map(long,long) ; m := Map{} ;
        var i : int ; i := 1 ; while i <= N do ( (     m := m.merge(b[i+1], 1l, lambda (v1 , v2) : OclAny in (v1 + v2)) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    for (k : m->keys()) do ( (     if (k = 0) then (     var t : long ; t := m->at(k) ;
     ans := ans+(t * (t + 1) / 2) ) else (     var t : long ; t := m->at(k) ;
     ans := ans+(t * (t - 1) / 2) ) )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[] sum=new long[N+1];
    int max=0 ;
    sum[0]=0 ;
    Map<Long,Integer>count=new HashMap<>();
    count.put(0L,1);
    for(int i=1 ; i<=N ; i++){
      sum[i]=sum[i-1]+sc.nextLong();
      if(count.containsKey(sum[i])){
        int new_c=count.get(sum[i])+1 ;
        count.put(sum[i],new_c);
        max=Math.max(max,new_c);
      }
      else {
        count.put(sum[i],1);
        max=Math.max(max,1);
      }
    }
    long ans=0 ;
    for(int value : count.values()){
      ans+=(long)value*(value-1)/2 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var sum : Sequence(long) ; sum := Integer.subrange(1,N + 1)->collect(0) ;
    var max : int ; max := 0 ;
    sum[0+1] := 0 ; 
    var count : Map(long,int) ; count := Map{} ;
    count := count->union(Map{0L |-> 1}) ; 
        var i : int ; i := 1 ; while i <= N do ( (     sum[i+1] := sum[i - 1+1] + sc.getCurrent()->toLong() ; 
     if (count->keys()->includes(sum[i+1])) then (     var new_c : int ; new_c := count->at(sum[i+1]) + 1 ;
     count := count->union(Map{sum[i+1] |-> new_c}) ; 
     max := Set{max, new_c}->max() ) else (     count := count->union(Map{sum[i+1] |-> 1}) ; 
     max := Set{max, 1}->max() ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    for (value : count->values()) do ( (     ans := ans+(value->oclAsType(long) * (value - 1) / 2) )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=Integer.parseInt(scanner.nextLine());
    long[] sums=new long[N];
    String[] array=scanner.nextLine().split(" ");
    long sum=0 ;
    for(int i=0 ; i<N ; ++i){
      sum+=Long.parseLong(array[i]);
      sums[i]=sum ;
    }
    Arrays.sort(sums);
    long count=0 ;
    long prep=sums[0];
    long subCount=0 ;
    for(int i=1 ; i<N ; ++i){
      if(sums[i]==prep){
++subCount ;
      }
      else {
        if(prep==0){
          subCount+=1 ;
        }
        if(subCount>0){
          count+=(subCount*(subCount+1))/2 ;
          subCount=0 ;
        }
        prep=sums[i];
      }
    }
    if(prep==0){
      subCount+=1 ;
    }
    if(subCount>0){
      count+=(subCount*(subCount+1))/2 ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (scanner.nextLine())->toInteger() ;
    var sums : Sequence(long) ; sums := Integer.subrange(1,N)->collect(0) ;
    var array : Sequence(String) ; array := scanner.nextLine()->split(" ") ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     sum := sum+((array[i+1])->toLong()) ; 
     sums[i+1] := sum )  ;     i := i + 1 ) ; 
    sums := sums->sort() ; 
    var count : long ; count := 0 ;
    var prep : long ; prep := sums[0+1] ;
    var subCount : long ; subCount := 0 ;
        var i : int ; i := 1 ; while i < N do ( (     if (sums[i+1] = prep) then (     subCount := subCount + 1 ) else (     if (prep = 0) then (     subCount := subCount+(1) ) else skip ; 
     if (subCount > 0) then (     count := count+((subCount * (subCount + 1)) / 2) ; 
     subCount := 0 ) else skip ; 
     prep := sums[i+1] ) )  ;     i := i + 1 ) ; 
    if (prep = 0) then (     subCount := subCount+(1) ) else skip ; 
    if (subCount > 0) then (     count := count+((subCount * (subCount + 1)) / 2) ) else skip ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findNthTerm(int n){
    if(n % 2==0){
      n=n/2 ;
      n=2*(n-1);
      System.out.println(n/2);
    }
    else {
      n=(n/2)+1 ;
      n=2*(n-1);
      System.out.println(n);
    }
  }
  public static void main(String args[]){
    int X=10 ;
    findNthTerm(X);
    X=7 ;
    findNthTerm(X);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNthTerm( n : int) : void
  pre: true
  post: true
  activity: (     if (n mod 2 = 0) then (     n := n / 2 ; 
     n := 2 * (n - 1) ; 
     OclFile["System.out"].println(n / 2) ) else (     n := (n / 2) + 1 ; 
     n := 2 * (n - 1) ; 
     OclFile["System.out"].println(n) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 10 ;
     execute findNthTerm(X) ; 
     X := 7 ; 
     execute findNthTerm(X) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.LongStream ;
public class Main {
  public static void main(String[] args){
    new Main().solve();
  }
  void solve(){
    try(Scanner in=new Scanner(System.in)){
      int n=in.nextInt();
      long a[]=new long[n];
      for(int i=0 ; i<n ; ++i){
        a[i]=in.nextInt();
      }
      long sum=LongStream.of(a).sum();
      long x=(long)(n+1)*n/2L ;
      if(sum % x!=0){
        System.out.println("NO");
        return ;
      }
      long k=sum/x ;
      for(int i=0 ; i<n ; ++i){
        long d=a[i]-a[(i+1)% n];
        if((d+k)% n!=0 ||(d+k)<0){
          System.out.println("NO");
          return ;
        }
      }
      System.out.println("YES");
    }
  }
  void tr(Object...o){
    System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := Sequence{a}->sum() ;
    var x : long ; x := (n + 1)->oclAsType(long) * n / 2L ;
    if (sum mod x /= 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    var k : long ; k := sum / x ;
        var i : int ; i := 0 ; while i < n do ( (     var d : long ; d := a[i+1] - a[(i + 1) mod n+1] ;
     if ((d + k) mod n /= 0 or (d + k) < 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 ))  );
   operation tr( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean check(String s,int l){
    Vector<Integer>pos=new Vector<Integer>();
    for(int i=0 ; i<l ; i++){
      if(s.charAt(i)=='1')pos.add(i);
    }
    int t=pos.size();
    for(int i=1 ; i<t ; i++){
      if((pos.get(i)-pos.get(i-1))!=(pos.get(1)-pos.get(0)))return false ;
    }
    return true ;
  }
  public static void main(String args[]){
    String s="100010001000" ;
    int l=s.length();
    if(check(s,l))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( s : String, l : int) : boolean
  pre: true
  post: true
  activity: (     var pos : Sequence(int) ; pos := Sequence{} ;
         var i : int ; i := 0 ; while i < l do ( (     if (s->at(i+1) = '1') then     pos := pos->including(i) ; else skip )  ;     i := i + 1 ) ; 
    var t : int ; t := pos->size() ;
        var i : int ; i := 1 ; while i < t do ( (     if ((pos->at(i+1) - pos->at(i - 1+1)) /= (pos->at(1+1) - pos->at(0+1))) then     return false else skip )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "100010001000" ;
     var l : int ; l := s->size() ;
     if (check(s, l)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int t ;
    Scanner scanner=new Scanner(System.in);
    t=scanner.nextInt();
    while(t-->0){
      int n ;
      n=scanner.nextInt();
      String s1=new String();
      String s=scanner.next();
      for(int i=0 ; i<s.length(); i+=2){
        s1+=s.charAt(i);
      }
      System.out.println(s1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     t := scanner.getCurrent()->toInteger() ; 
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ;
     n := scanner.getCurrent()->toInteger() ; 
    var s1 : String ; s1 := StringLib.newString() ;
    var s : String ; s := scanner.getCurrent() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     s1 := s1+(s->at(i+1)) )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(s1) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    sc.nextLine();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt(),c=0,j=0,k=n ;
      sc.nextLine();
      String s=sc.nextLine(),w="" ;
      while(k!=(2*n)&& j!=(n+1)){
        String x=s.substring(j,k);
        w=w+x.charAt(c);
        c++;
        k++;
        j++;
      }
      System.out.println(w);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     skip ; 
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
    var j : int ; j := 0 ;
    var k : int ; k := n ;
     skip ; 
    var s : String ; s := sc.nextLine() ;
    var w : String ; w := "" ;
    while (k /= (2 * n) & j /= (n + 1)) do (     var x : String ; x := s.subrange(j+1,k) ;
     w := w + x->at(c+1) ; 
    c := c + 1 ; 
    k := k + 1 ; 
    j := j + 1 ; 
 ) ; 
    OclFile["System.out"].println(w) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test233 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      char[] a=in.next().toCharArray();
      int x=0 ;
      for(int i=0 ; i<n ; i++){
        System.out.print(a[x]);
        x+=2 ;
      }
      System.out.println();
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test233 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(String) ; a := in.getCurrent()->characters() ;
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(a[x+1]) ; 
     x := x+(2) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ss_729A {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    String str=s.next();
    while(hasFiller(str))str=str.replaceFirst(nearestMaxFiller(str),"***");
    System.out.println(str);
  }
  static boolean hasFiller(String str){
    String minFiller="ogo" ;
    return str.contains(minFiller);
  }
  static String nearestMaxFiller(String str){
    int start=str.indexOf("ogo")+3 ;
    String s="ogo" ;
    for(int i=start ; i<str.length()-1 ; i++){
      if(str.charAt(i)=='g' && str.charAt(i+1)=='o'){
        s+="go" ;
        i++;
      }
      else break ;
    }
    return s ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ss_729A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var str : String ; str := s.getCurrent() ;
    while (hasFiller(str)) do     str := str.replaceFirstMatch(nearestMaxFiller(str), "***") ; ; 
    OclFile["System.out"].println(str) ; 
 );
  static   operation hasFiller( str : String) : boolean
  pre: true
  post: true
  activity: (     var minFiller : String ; minFiller := "ogo" ;
     return str->includes(minFiller) );
  static   operation nearestMaxFiller( str : String) : String
  pre: true
  post: true
  activity: (     var start : int ; start := str->indexOf("ogo")-1 + 3 ;
     var s : String ; s := "ogo" ;
         var i : int ; i := start ; while i < str->size() - 1 do ( (     if (str->at(i+1) = 'g' & str->at(i + 1+1) = 'o') then (     s := s+("go") ; 
     i := i + 1 ) else     break )  ;     i := i + 1 ) ; 
     return s );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sc.nextInt();
    String s=sc.next();
    System.out.println(solve(s));
    sc.close();
  }
  static String solve(String s){
    StringBuilder result=new StringBuilder();
    int index=0 ;
    while(index!=s.length()){
      if(s.startsWith("ogo",index)){
        result.append("***");
        index+="ogo".length();
        while(s.startsWith("go",index)){
          index+="go".length();
        }
      }
      else {
        result.append(s.charAt(index));
        index++;
      }
    }
    return result.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var s : String ; s := sc.getCurrent() ;
    OclFile["System.out"].println(solve(s)) ; 
    skip ; 
 );
  static   operation solve( s : String) : String
  pre: true
  post: true
  activity: (     var result : String ; result := StringLib.newString() ;
     var index : int ; index := 0 ;
     while (index /= s->size()) do (     if (s.subrange(index+1,index+("ogo".size))->hasPrefix("ogo") ) then (     result := result + StringLib.newString("***") ; 
     index := index+("ogo"->size()) ; 
     while (s.subrange(index+1,index+("go".size))->hasPrefix("go") ) do (     index := index+("go"->size()) ) ) else (     result := result + StringLib.newString(s->at(index+1)) ; 
     index := index + 1 ) ) ; 
     return result+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class CodeForces {
  public static void main(String[] args){
    Scanner input=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int n=input.nextInt();
    String s=input.next();
    boolean run=true ;
    while(run){
      boolean check=false ;
      outerloop : for(int i=0 ;
      i<s.length();
      i++){
        for(int j=s.length()-1 ; j>=i+2 ; j--){
          if((j-i)% 2==0){
            boolean check2=true ;
            for(int k=i ; k<=j ; k++){
              if((k-i)% 2==0 && s.charAt(k)!='o'){
                check2=false ;
                break ;
              }
              if((k-i)% 2==1 && s.charAt(k)!='g'){
                check2=false ;
                break ;
              }
            }
            if(check2){
              s=s.substring(0,i)+"***"+s.substring(j+1,s.length());
              check=true ;
            }
          }
          if(check){
            break outerloop ;
          }
        }
      }
      if(! check){
        break ;
      }
    }
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var s : String ; s := input.getCurrent() ;
    var run : boolean ; run := true ;
    while (run) do (     var check : boolean ; check := false ;
         var i : int ; i := 0 ; while i < s->size() do ( (         var j : int ; j := s->size() - 1 ; while j >= i + 2 do ( (     if ((j - i) mod 2 = 0) then (     var check2 : boolean ; check2 := true ;
         var k : int ; k := i ; while k <= j do ( (     if ((k - i) mod 2 = 0 & s->at(k+1) /= 'o') then (     check2 := false ; 
     break ) else skip ; 
     if ((k - i) mod 2 = 1 & s->at(k+1) /= 'g') then (     check2 := false ; 
     break ) else skip )  ;     k := k + 1 ) ; 
     if (check2) then (     s := s.subrange(0+1,i) + "***" + s.subrange(j + 1+1,s->size()) ; 
     check := true ) else skip ) else skip ; 
     if (check) then (     break ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
     if (not(check)) then (     break ) else skip ) ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner read=new Scanner(System.in);
    int n=Integer.parseInt(read.nextLine());
    String s=read.nextLine();
    StringBuilder output=new StringBuilder();
    int i=0 ;
    while(i<n){
      if(i+2<n && s.charAt(i)=='o' && s.charAt(i+1)=='g' && s.charAt(i+2)=='o'){
        i+=3 ;
        while(i+1<n && s.charAt(i)=='g' && s.charAt(i+1)=='o'){
          i+=2 ;
        }
        output.append("***");
      }
      else {
        output.append(s.charAt(i));
        i++;
      }
    }
    System.out.println(output);
    read.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : OclFile ; read := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (read.nextLine())->toInteger() ;
    var s : String ; s := read.nextLine() ;
    var output : String ; output := StringLib.newString() ;
    var i : int ; i := 0 ;
    while (i < n) do (     if (i + 2 < n & s->at(i+1) = 'o' & s->at(i + 1+1) = 'g' & s->at(i + 2+1) = 'o') then (     i := i+(3) ; 
     while (i + 1 < n & s->at(i+1) = 'g' & s->at(i + 1+1) = 'o') do (     i := i+(2) ) ; 
     output := output + StringLib.newString("***") ) else (     output := output + StringLib.newString(s->at(i+1)) ; 
     i := i + 1 ) ) ; 
    OclFile["System.out"].println(output) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    boolean get=false ;
    for(int i=0 ; i<s.length(); i++){
      while(s.charAt(i)=='o'){
        if(i+2<s.length()){
          if(s.substring(i+1,i+3).equals("go")){
            i=i+2 ;
            get=true ;
            if(i>=s.length())break ;
          }
          else {
            break ;
          }
        }
        else break ;
      }
      if(get){
        System.out.print("***");
        get=false ;
      }
      else System.out.print(s.charAt(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var get : boolean ; get := false ;
        var i : int ; i := 0 ; while i < s->size() do ( (     while (s->at(i+1) = 'o') do (     if (i + 2 < s->size()) then (     if (s.subrange(i + 1+1,i + 3) = "go") then (     i := i + 2 ; 
     get := true ; 
     if (i >= s->size()) then     break else skip ) else (     break ) ) else     break ) ; 
     if (get) then (     OclFile["System.out"].print("***") ; 
     get := false ) else     OclFile["System.out"].print(s->at(i+1)) ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner as=new Scanner(System.in);
    int n=as.nextInt();
    int[] a ;
    a=new int[n];
    long t=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(as.next());
      t+=a[i];
    }
    long l=0 ;
    boolean asa=true ;
    if(t %((n+1)*(long)n/2)==0){
      long k=t/((n+1)*(long)n/2);
      for(int i=0 ; i<n ; i++){
        l=a[(i+1)% n]-a[i];
        if(l>k ||(k-l)% n!=0){
          asa=false ;
          break ;
        }
      }
    }
    else {
      asa=false ;
    }
    if(asa){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var as : OclFile ; as := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := as.getCurrent()->toInteger() ;
    var a : Sequence(int) ;
    a := Integer.subrange(1,n)->collect(0) ; 
    var t : long ; t := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (as.getCurrent())->toInteger() ; 
     t := t+(a[i+1]) )  ;     i := i + 1 ) ; 
    var l : long ; l := 0 ;
    var asa : boolean ; asa := true ;
    if (t mod ((n + 1) * n->oclAsType(long) / 2) = 0) then (     var k : long ; k := t / ((n + 1) * n->oclAsType(long) / 2) ;
         var i : int ; i := 0 ; while i < n do ( (     l := a[(i + 1) mod n+1] - a[i+1] ; 
     if (l > k or (k - l) mod n /= 0) then (     asa := false ; 
     break ) else skip )  ;     i := i + 1 ) ) else (     asa := false ) ;  
    if (asa) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String CHARS="qwertyuiopasdfghjklzxcvbnm" ;
  static int MAX=26 ;
  static String getString(char[] str,int n){
    Map<Character,Character>uMap=new HashMap<>();
    for(int i=0 ; i<MAX ; i++){
      uMap.put(CHARS.charAt(i),CHARS.charAt((i+1)% MAX));
    }
    for(int i=0 ; i<n ; i++){
      str[i]=uMap.get(str[i]);
    }
    return String.valueOf(str);
  }
  public static void main(String[] args){
    String str="geeks" ;
    int n=str.length();
    System.out.println(getString(str.toCharArray(),n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute CHARS : String := "qwertyuiopasdfghjklzxcvbnm";
  static   attribute MAX : int := 26;
  static   operation getString( str : Sequence(String), n : int) : String
  pre: true
  post: true
  activity: (     var uMap : Map(String,String) ; uMap := Map{} ;
         var i : int ; i := 0 ; while i < MAX do ( (     uMap := uMap->union(Map{CHARS->at(i+1) |-> CHARS->at((i + 1) mod MAX+1)}) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     str[i+1] := uMap->at(str[i+1]) )  ;     i := i + 1 ) ; 
     return ((str) + "") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeks" ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].println(getString(str->characters(), n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.*;
public class App {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws Exception {
    if(System.getProperty("ONLINE_JUDGE")==null){
      File inputFile=new File("/Users/vipinjain/self/cp/input.txt");
      File outputFile=new File("/Users/vipinjain/self/cp/output.txt");
      br=new BufferedReader(new FileReader(inputFile));
      bw=new BufferedWriter(new FileWriter(outputFile));
    }
    int tests ;
    tests=Integer.parseInt(br.readLine());
    while(tests-->0){
      solve();
    }
    bw.flush();
    bw.close();
    br.close();
  }
  static void solve()throws Exception {
    String[] tmp=br.readLine().split(" ");
    int n=Integer.parseInt(tmp[0]);
    int s=Integer.parseInt(tmp[1]);
    int t=n-(n+1)/2+1 ;
    int ans=t==0 ? s : s/t ;
    bw.write(ans+"");
    bw.write("\n");
  }
  static int gcd(int a,int b){
    if(a==0){
      return b ;
    }
    return gcd(b % a,a);
  }
  static boolean isPrime(long n){
    for(long i=2 ; i*i<=n ; i++){
      if(n % i==0){
        return false ;
      }
    }
    return true ;
  }
  static long minDivisor(long n){
    for(long i=2 ; i*i<=n ; ++i){
      if(n % i==0){
        return i ;
      }
    }
    return n ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null) then (     var inputFile : OclFile ; inputFile := OclFile("/Users/vipinjain/self/cp/input.txt") ;
     var outputFile : OclFile ; outputFile := OclFile("/Users/vipinjain/self/cp/output.txt") ;
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputFile)) ; 
     bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputFile)) ) else skip ; 
     var tests : int ;
    tests := (br.readLine())->toInteger() ; 
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var tmp : Sequence(String) ; tmp := br.readLine()->split(" ") ;
     var n : int ; n := (tmp[0+1])->toInteger() ;
    var s : int ; s := (tmp[1+1])->toInteger() ;
    var t : int ; t := n - (n + 1) / 2 + 1 ;
    var ans : int ; ans := if t = 0 then s else s / t endif ;
    skip ; 
    skip ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then (     return b ) else skip ; 
     return gcd(b mod a, a) );
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (         var i : long ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation minDivisor( n : long) : long
  pre: true
  post: true
  activity: (         var i : long ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     return i ) else skip )  ;     i := i + 1 ) ; 
     return n );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Exercise2b {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      long n=sc.nextLong();
      long s=sc.nextLong();
      long mid=(n/2)+1 ;
      long ans=s/mid ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Exercise2b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : long ; n := sc.getCurrent()->toLong() ;
     var s : long ; s := sc.getCurrent()->toLong() ;
    var mid : long ; mid := (n / 2) + 1 ;
    var ans : long ; ans := s / mid ;
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Exercise2b {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      long n=sc.nextLong();
      long s=sc.nextLong();
      long mid=(n/2)+1 ;
      long ans=s/mid ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Exercise2b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : long ; n := sc.getCurrent()->toLong() ;
     var s : long ; s := sc.getCurrent()->toLong() ;
    var mid : long ; mid := (n / 2) + 1 ;
    var ans : long ; ans := s / mid ;
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
public class Solution {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    StringBuilder result=new StringBuilder();
    for(int i=0 ; i<t ; i++){
      int n=scan.nextInt();
      int s=scan.nextInt();
      int res=0 ;
      if(n==1){
        res=s ;
      }
      else {
        int k=(n % 2==0)? n/2 :(n/2)+1 ;
        int p=n-k+1 ;
        res=s/p ;
      }
      result.append(res+"\n");
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
    var result : String ; result := StringLib.newString() ;
        var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var s : int ; s := scan.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
    if (n = 1) then (     res := s ) else (     var k : int ; k := if (n mod 2 = 0) then n / 2 else (n / 2) + 1 endif ;
     var p : int ; p := n - k + 1 ;
     res := s / p ) ;  
    result := result + StringLib.newString(res + "\n") ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Pair {
  static int mod=1000000007 ;
  static int n ;
  static int m ;
  static int k ;
  static long a[];
  static long b[];
  public static void main(String[] args){
    FastScanner s=new FastScanner();
    int t=1 ;
    while(t-->0){
      n=s.nextInt();
      m=s.nextInt();
      StringBuilder sb1=new StringBuilder();
      StringBuilder sb2=new StringBuilder();
      for(int i=0 ; i<2230 ; i++){
        if(i==2229){
          sb1.append(5);
        }
        else {
          sb1.append(4);
        }
        sb2.append(5);
      }
      System.out.println(sb1);
      System.out.println(sb2);
    }
  }
  static void sort(int[] a){
    ArrayList<Integer>l=new ArrayList<>();
    for(int i : a)l.add(i);
    Collections.sort(l);
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Pair {
  static   attribute mod : int := 1000000007;
  static   attribute n : int;
  static   attribute m : int;
  static   attribute k : int;
  static   attribute a : Sequence(long);
  static   attribute b : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : FastScanner ; s := FastScanner.newFastScanner() ;
     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     n := s.nextInt() ; 
     m := s.nextInt() ; 
    var sb1 : String ; sb1 := StringLib.newString() ;
    var sb2 : String ; sb2 := StringLib.newString() ;
        var i : int ; i := 0 ; while i < 2230 do ( (     if (i = 2229) then (     sb1 := sb1 + StringLib.newString(5) ) else (     sb1 := sb1 + StringLib.newString(4) ) ;  
     sb2 := sb2 + StringLib.newString(5) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb1) ; 
    OclFile["System.out"].println(sb2) ; 
 ) ;  ) );
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l := l->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner ss=new Scanner(System.in);
    int number=ss.nextInt();
    for(int i=1 ; i<=number ; i++){
      long x=ss.nextLong();
      long s=ss.nextLong();
      long result=s/(x*x);
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ss : OclFile ; ss := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := ss.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= number do ( (     var x : long ; x := ss.getCurrent()->toLong() ;
     var s : long ; s := ss.getCurrent()->toLong() ;
     var result : long ; result := s / (x * x) ;
     OclFile["System.out"].println(result) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  static FastReader sc=null ;
  public static void main(String[] args){
    sc=new FastReader();
    int t=sc.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      int n=sc.nextInt();
      long s=sc.nextLong();
      long times=s/(n*1L*n);
      System.out.println(times);
    }
  }
  static int[] ruffleSort(int a[]){
    ArrayList<Integer>al=new ArrayList<>();
    for(int i : a)al.add(i);
    Collections.sort(al);
    for(int i=0 ; i<a.length ; i++)a[i]=al.get(i);
    return a ;
  }
  static void print(int a[]){
    for(int e : a){
      System.out.print(e+" ");
    }
    System.out.println();
  }
  static class FastReader {
    StringTokenizer st=new StringTokenizer("");
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String next(){
      while(! st.hasMoreTokens())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());
    }
    int[] readArray(int n){
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute sc : FastReader := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := FastReader.newFastReader() ; 
     var t : int ; t := sc.nextInt() ;
         var tt : int ; tt := 0 ; while tt < t do ( (     var n : int ; n := sc.nextInt() ;
     var s : long ; s := sc.nextLong() ;
     var times : long ; times := s / (n * 1L * n) ;
     OclFile["System.out"].println(times) )  ;     tt := tt + 1 ) );
  static   operation ruffleSort( a : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var al : Sequence(int) ; al := Sequence{} ;
     for (i : a) do (     al := al->including(i) ;  ) ; 
    al := al->sort() ; 
        var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := al->at(i+1) ;  ;     i := i + 1 ) ; 
    return a 
 );
  static   operation print( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     for (e : a) do ( (     OclFile["System.out"].print(e + " ") )  ) ; 
     OclFile["System.out"].println() );
  static class FastReader {
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      Long n=sc.nextLong();
      Long s=sc.nextLong();
      System.out.println(s/(n*n));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := sc.getCurrent()->toLong() ;
     var s : long ; s := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println(s / (n * n)) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class P1646A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      long n,s ;
      n=sc.nextLong();
      s=sc.nextLong();
      System.out.println(s/(n*n));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P1646A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : long ;
    var s : long ;
     n := sc.getCurrent()->toLong() ; 
     s := sc.getCurrent()->toLong() ; 
     OclFile["System.out"].println(s / (n * n)) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maxProd(int N){
    if(N==0)return 1 ;
    if(N<10)return N ;
    return Math.max(maxProd(N/10)*(N % 10),maxProd(N/10-1)*9);
  }
  public static void main(String[] args){
    int N=390 ;
    System.out.println(maxProd(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxProd( N : int) : int
  pre: true
  post: true
  activity: (     if (N = 0) then     return 1 else skip ; 
     if (N < 10) then     return N else skip ; 
     return Set{maxProd(N / 10) * (N mod 10), maxProd(N / 10 - 1) * 9}->max() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 390 ;
     OclFile["System.out"].println(maxProd(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class C {
  public static void main(String args[]){
(new C()).exec();
  }
  void exec(){
    Scanner cin=new Scanner(System.in);
    int t=cin.nextInt();
    for(int z=0 ; z<t ; ++z){
      int k=cin.nextInt();
      int value[]=new int[k];
      boolean used[]=new boolean[k];
      int count=0 ;
      int cur=0 ;
      while(count<k){
        for(int i=0 ; i<k ; ++i){
          if(used[i]){
            continue ;
          }
          if(cur==count){
            value[i]=++count ;
            cur=0 ;
            used[i]=true ;
          }
          else {
++cur ;
          }
        }
      }
      System.out.print("Case #"+(z+1)+":");
      int n=cin.nextInt();
      for(int i=0 ; i<n ; ++i){
        System.out.print(" "+value[cin.nextInt()-1]);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (C.newC()).exec() );
   operation exec() : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := cin.getCurrent()->toInteger() ;
         var z : int ; z := 0 ; while z < t do ( (     var k : int ; k := cin.getCurrent()->toInteger() ;
     var value : Sequence(int) ; value := Integer.subrange(1,k)->collect(0) ;
    var used : Sequence(boolean) ; used := Integer.subrange(1,k)->collect(false) ;
    var count : int ; count := 0 ;
    var cur : int ; cur := 0 ;
    while (count < k) do (         var i : int ; i := 0 ; while i < k do ( (     if (used[i+1]) then (     continue ) else skip ; 
     if (cur = count) then (         count := count + 1 ;
 value[i+1] := count  ; 
     cur := 0 ; 
     used[i+1] := true ) else (     cur := cur + 1 ) )  ;     i := i + 1 ) ) ; 
    OclFile["System.out"].print("Case #" + (z + 1) + ":") ; 
    var n : int ; n := cin.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(" " + value[cin.getCurrent()->toInteger() - 1+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     z := z + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class TaskC implements Runnable {
  private String IFILE="C-large.in" ;
  private Scanner in ;
  private PrintWriter out ;
  public void Run()throws IOException {
    in=new Scanner(new File(IFILE));
    out=new PrintWriter("output.txt");
    int ntest=in.nextInt();
    for(int test=1 ; test<=ntest ; test++){
      out.print("Case #"+test+":");
      int n=in.nextInt();
      int m=in.nextInt();
      int[] mas=new int[m];
      for(int i=0 ; i<m ; i++){
        int v=in.nextInt()-1 ;
        int count=n ;
        for(int j=0 ; j<n ; j++){
          int pos=j % count ;
          if(pos==v){
            out.print(" "+(j+1));
            break ;
          }
          if(pos>v){
            v+=count-pos-1 ;
          }
          else {
            v=v-pos-1 ;
          }
          count--;
        }
      }
      out.println();
    }
    in.close();
    out.close();
  }
  public void run(){
    try {
      Run();
    }
    catch(IOException e){
    }
  }
  public static void main(String[] args)throws IOException {
    new TaskC().Run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class TaskC implements Runnable {
   attribute IFILE : String := "C-large.in";
   attribute in : OclFile;
   attribute out : OclFile;
   operation Run() : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile(IFILE)) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ; 
    var ntest : int ; ntest := in.getCurrent()->toInteger() ;
        var test : int ; test := 1 ; while test <= ntest do ( (     skip ; 
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var mas : Sequence(int) ; mas := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     var v : int ; v := in.getCurrent()->toInteger() - 1 ;
     var count : int ; count := n ;
         var j : int ; j := 0 ; while j < n do ( (     var pos : int ; pos := j mod count ;
     if (pos = v) then (     skip ; 
     break ) else skip ; 
     if (pos > v) then (     v := v+(count - pos - 1) ) else (     v := v - pos - 1 ) ;  
     count := count - 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     test := test + 1 ) ; 
    skip ; 
    skip ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     execute Run() )   catch (e : IOException) do skip
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     TaskC.newTaskC().Run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package common ;
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
public class Helper {
  public static String[] getAllFileContentAsArray(String filename)throws Exception {
    BufferedReader in=new BufferedReader(new FileReader(filename));
    List<String>all=new ArrayList<String>();
    String s=in.readLine();
    while(s!=null){
      all.add(s);
      s=in.readLine();
    }
    in.close();
    return all.toArray(new String[0]);
  }
  public static void writeToFile(String[] cont,String filename)throws Exception {
    File file=new File(filename);
    file.delete();
    FileWriter w=null ;
    try {
      w=new FileWriter(file,true);
      for(String s : cont){
        w.write(s+"\n");
      }
    }
    finally {
      if(w!=null){
        w.close();
      }
    }
  }
  public static int[] getIntegersFromString(String s)throws Exception {
    List<Integer>a=new ArrayList<Integer>();
    for(String se : s.split(" ")){
      try {
        Integer x=Integer.parseInt(se);
        a.add(x);
      }
      catch(Exception e){
      }
    }
    int[] ret=new int[a.size()];
    for(int i=0 ; i<a.size(); ++i){
      ret[i]=a.get(i).intValue();
    }
    return ret ;
  }
  private Helper(){
  }
}
------------------------------------------------------------
OCL File:
---------
 class Helper {
  static   operation getAllFileContentAsArray( filename : String) : Sequence(String)
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(filename)) ;
     var all : Sequence(String) ; all := Sequence{} ;
    var s : String ; s := in.readLine() ;
    while (s /= null) do (     all := all->including(s) ; 
     s := in.readLine() ) ; 
    skip ; 
    return all->asSequence() 
 );
  static   operation writeToFile( cont : Sequence(String), filename : String) : void
  pre: true
  post: true
  activity: (     var file : OclFile ; file := OclFile(filename) ;
     skip ; 
     var w : OclFile ; w := null ;
     try (     w := OclFile.newOclFile_Write(file, true) ; 
     for (s : cont) do ( (     skip )  ) )   finally (     if (w /= null) then (     skip ) else skip )
 );
  static   operation getIntegersFromString( s : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{} ;
     for (se : s->split(" ")) do ( (     try (     var x : int ; x := (se)->toInteger() ;
     a := a->including(x) )   catch (e : ProgramException) do skip
 )  ) ; 
    var ret : Sequence(int) ; ret := Integer.subrange(1,a->size())->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     ret[i+1] := a->at(i+1)->oclAsType(int) )  ;     i := i + 1 ) ; 
    return ret 
 );
   static operation newHelper() : Helper
  pre: true
  post: true
  activity:
  ( var self : Helper ;
    self := createHelper();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class C {
  public static void main(String args[])throws IOException {
    new C().solve();
  }
  void solve()throws IOException {
    br=new BufferedReader(new FileReader("C-small-attempt0.in"));
    pw=new PrintWriter("C-small.out");
    int T=Integer.parseInt(br.readLine());
    for(int c=1 ; c<=T ; ++c){
      System.out.println(c);
      int K=Integer.parseInt(br.readLine());
      StringTokenizer st=new StringTokenizer(br.readLine());
      int n=Integer.parseInt(st.nextToken());
      int[] d=new int[n];
      for(int i=0 ; i<n ; ++i){
        d[i]=Integer.parseInt(st.nextToken());
      }
      int[] v=new int[K];
      int s=0 ;
      for(int k=1 ; k<=K ; ++k){
        for(int p=1 ; p<k ; ++p){
          s++;
          if(s==K)s=0 ;
          while(v[s]!=0){
            s++;
            if(s==K)s=0 ;
          }
        }
        v[s]=k ;
        if(k<K){
          s++;
          if(s==K)s=0 ;
          while(v[s]!=0){
            s++;
            if(s==K)s=0 ;
          }
        }
      }
      pw.print("Case #"+c+":");
      for(int i=0 ; i<n ; ++i){
        pw.print(" "+v[d[i]-1]);
      }
      pw.println();
    }
    pw.close();
  }
  BufferedReader br ;
  PrintWriter pw ;
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     C.newC().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("C-small-attempt0.in"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile("C-small.out")) ; 
    var T : int ; T := (br.readLine())->toInteger() ;
        var c : int ; c := 1 ; while c <= T do ( (     OclFile["System.out"].println(c) ; 
     var K : int ; K := (br.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     d[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    var v : Sequence(int) ; v := Integer.subrange(1,K)->collect(0) ;
    var s : int ; s := 0 ;
        var k : int ; k := 1 ; while k <= K do ( (         var p : int ; p := 1 ; while p < k do ( (     s := s + 1 ; 
     if (s = K) then     s := 0 ; else skip ; 
     while (v[s+1] /= 0) do (     s := s + 1 ; 
     if (s = K) then     s := 0 ; else skip ) )  ;     p := p + 1 ) ; 
     v[s+1] := k ; 
     if (k < K) then (     s := s + 1 ; 
     if (s = K) then     s := 0 ; else skip ; 
     while (v[s+1] /= 0) do (     s := s + 1 ; 
     if (s = K) then     s := 0 ; else skip ) ) else skip )  ;     k := k + 1 ) ; 
    pw.print("Case #" + c + ":") ; 
        var i : int ; i := 0 ; while i < n do ( (     pw.print(" " + v[d[i+1] - 1+1]) )  ;     i := i + 1 ) ; 
    pw.println() ; 
 )  ;     c := c + 1 ) ; 
    pw.close() ; 
 );
   attribute br : OclFile;
   attribute pw : OclFile;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CSmall {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int T=sc.nextInt();
    for(int caseID=1 ; caseID<=T ; caseID++){
      int K=sc.nextInt();
      int n=sc.nextInt();
      int[] ds=new int[n];
      for(int i=0 ; i<n ; i++){
        ds[i]=sc.nextInt();
      }
      boolean[] visited=new boolean[K];
      int[] cards=new int[K];
      int iter=0 ;
      for(int i=1 ; i<=K ; i++){
        int cnt=0 ;
        int next=(i-1)%(K-i+1);
        while(true){
          if(iter==K)iter=0 ;
          if(! visited[iter]){
            if(cnt==next){
              visited[iter]=true ;
              cards[iter]=i ;
              cnt++;
              iter++;
              break ;
            }
            else {
              cnt++;
              iter++;
            }
          }
          else {
            iter++;
          }
        }
      }
      System.out.printf("Case #%d:",caseID);
      for(int i=0 ; i<n ; i++){
        System.out.printf(" %d",cards[ds[i]-1]);
      }
      System.out.printf("%n");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CSmall {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := sc.getCurrent()->toInteger() ;
         var caseID : int ; caseID := 1 ; while caseID <= T do ( (     var K : int ; K := sc.getCurrent()->toInteger() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ds : Sequence(int) ; ds := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ds[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,K)->collect(false) ;
    var cards : Sequence(int) ; cards := Integer.subrange(1,K)->collect(0) ;
    var iter : int ; iter := 0 ;
        var i : int ; i := 1 ; while i <= K do ( (     var cnt : int ; cnt := 0 ;
     var next : int ; next := (i - 1) mod (K - i + 1) ;
     while (true) do (     if (iter = K) then     iter := 0 ; else skip ; 
     if (not(visited[iter+1])) then (     if (cnt = next) then (     visited[iter+1] := true ; 
     cards[iter+1] := i ; 
    cnt := cnt + 1 ; 
    iter := iter + 1 ; 
    break 
 ) else (     cnt := cnt + 1 ; 
     iter := iter + 1 ) ) else (     iter := iter + 1 ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("Case #%d:", caseID) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].printf(" %d", cards[ds[i+1] - 1+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%n") ; 
 )  ;     caseID := caseID + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.List ;
public class AsSimpleAsOneAndTwo {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t!=0){
      solve(br,pr);
      t--;
    }
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    String s=br.readLine();
    StringBuffer res=new StringBuffer();
    List<Integer>indexes=new ArrayList<>();
    int n=s.length();
    for(int i=0 ; i<n ; i++){
      char c=s.charAt(i);
      if(c!='w' && c!='n'){
        res.append(c);
      }
      else {
        if(c=='w'){
          if(i+3<n && s.substring(i+1,i+4).equals("one")){
            res.append(c);
            indexes.add(i+1);
            i++;
          }
          else {
            if(res.length()!=0 && res.charAt(res.length()-1)=='t' && i+1<n && s.charAt(i+1)=='o'){
              indexes.add(i);
            }
            else {
              res.append(c);
            }
          }
        }
        else if(c=='n'){
          if(res.length()!=0 && res.charAt(res.length()-1)=='o' && i+1<n && s.charAt(i+1)=='e'){
            indexes.add(i);
          }
          else {
            res.append(c);
          }
        }
      }
    }
    pr.println(indexes.size());
    for(int i : indexes){
      pr.print((i+1)+" ");
    }
    pr.println("");
  }
}
------------------------------------------------------------
OCL File:
---------
 class AsSimpleAsOneAndTwo {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
    while (t /= 0) do (     execute solve(br, pr) ; 
     t := t - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := br.readLine() ;
     var res : String ; res := StringLib.newString() ;
    var indexes : Sequence(int) ; indexes := Sequence{} ;
    var n : int ; n := s->size() ;
        var i : int ; i := 0 ; while i < n do ( (     var c : String ; c := s->at(i+1) ;
     if (c /= 'w' & c /= 'n') then (     res := res + StringLib.newString(c) ) else (     if (c = 'w') then (     if (i + 3 < n & s.subrange(i + 1+1,i + 4) = "one") then (     res := res + StringLib.newString(c) ; 
     indexes := indexes->including(i + 1) ; 
     i := i + 1 ) else (     if (res->size() /= 0 & res->at(res->size() - 1+1) = 't' & i + 1 < n & s->at(i + 1+1) = 'o') then (     indexes := indexes->including(i) ) else (     res := res + StringLib.newString(c) ) ) ) else     if (c = 'n') then (     if (res->size() /= 0 & res->at(res->size() - 1+1) = 'o' & i + 1 < n & s->at(i + 1+1) = 'e') then (     indexes := indexes->including(i) ) else (     res := res + StringLib.newString(c) ) ) else skip ; ) )  ;     i := i + 1 ) ; 
    skip ; 
    for (i : indexes) do ( (     skip )  ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CF1028B {
  public static void main(String args[]){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int m=scn.nextInt();
    for(int i=0 ; i<n ; i++)System.out.print(4);
    System.out.println("");
    for(int j=0 ; j<n-1 ; j++)System.out.print(5);
    System.out.print(6);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF1028B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var m : int ; m := scn.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(4) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
        var j : int ; j := 0 ; while j < n - 1 do (     OclFile["System.out"].print(5) ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].print(6) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  static final String[] PATTERNS={
    "twone","one","two" };
    static final int[] OFFSETS={
      2,1,1 };
      public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int t=sc.nextInt();
        for(int tc=0 ; tc<t ; ++tc){
          String s=sc.next();
          System.out.println(solve(s));
        }
        sc.close();
      }
      static String solve(String s){
        List<Integer>removedIndices=new ArrayList<>();
        int index=0 ;
        while(index<s.length()){
          boolean removed=false ;
          for(int i=0 ; i<PATTERNS.length ; ++i){
            if(s.startsWith(PATTERNS[i],index)){
              removedIndices.add(index+OFFSETS[i]);
              index+=PATTERNS[i] .length();
              removed=true ;
              break ;
            }
          }
          if(! removed){
++index ;
          }
        }
        return String.format("%d\n%s",removedIndices.size(),removedIndices.stream().map(x->String.valueOf(x+1)).collect(Collectors.joining(" ")));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute PATTERNS : Sequence(String) := Sequence{"twone","one","two"};
  static    attribute OFFSETS : Sequence(int) := Sequence{2,1,1};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var s : String ; s := sc.getCurrent() ;
     OclFile["System.out"].println(solve(s)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( s : String) : String
  pre: true
  post: true
  activity: (     var removedIndices : Sequence(int) ; removedIndices := Sequence{} ;
     var index : int ; index := 0 ;
     while (index < s->size()) do (     var removed : boolean ; removed := false ;
         var i : int ; i := 0 ; while i < PATTERNS->size() do ( (     if (s.subrange(index+1,index+(PATTERNS[i+1].size))->hasPrefix(PATTERNS[i+1]) ) then (     removedIndices := removedIndices->including(index + OFFSETS[i+1]) ; 
     index := index+(PATTERNS[i+1]->size()) ; 
     removed := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (not(removed)) then (     index := index + 1 ) else skip ) ; 
     return StringLib.format("%d\n%s",Sequence{removedIndices->size(),removedIndices->collect( _x1 | (lambda x : OclAny in ((x + 1) + ""))->apply(_x1) ).collect(Collectors.joining(" "))}) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CF {
  private static void sport(String[] a){
    int[][] dp=new int[26][26];
    boolean[][] can=new boolean[26][26];
    int ans=0 ;
    for(String s : a){
      int l=s.charAt(0)-'a' ;
      int r=s.charAt(s.length()-1)-'a' ;
      for(int i=0 ; i<26 ; i++){
        if(can[i][l]){
          can[i][r]=true ;
          dp[i][r]=Math.max(dp[i][r],dp[i][l]+s.length());
        }
      }
      can[l][r]=true ;
      dp[l][r]=Math.max(dp[l][r],s.length());
    }
    for(int i=0 ; i<26 ; i++){
      ans=Math.max(ans,dp[i][i]);
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String[] a=new String[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.next();
    }
    sport(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF {
  static   operation sport( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,26)->collect(Integer.subrange(1,26)->collect(0)) ;
     var can : Sequence(Sequence(boolean)) ; can := Integer.subrange(1,26)->collect(Integer.subrange(1,26)->collect(false)) ;
    var ans : int ; ans := 0 ;
    for (s : a) do ( (     var l : int ; l := s->at(0+1) - ('a')->char2byte() ;
     var r : int ; r := s->at(s->size() - 1+1) - ('a')->char2byte() ;
        var i : int ; i := 0 ; while i < 26 do ( (     if (can[i+1][l+1]) then (     can[i+1][r+1] := true ; 
     dp[i+1][r+1] := Set{dp[i+1][r+1], dp[i+1][l+1] + s->size()}->max() ) else skip )  ;     i := i + 1 ) ; 
    can[l+1][r+1] := true ; 
    dp[l+1][r+1] := Set{dp[l+1][r+1], s->size()}->max() ; 
 )  ) ; 
        var i : int ; i := 0 ; while i < 26 do ( (     ans := Set{ans, dp[i+1][i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(String) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    execute sport(a) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class A191 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int[][] length=new int[26][26];
    for(int i=0 ; i<26 ; i++){
      for(int j=0 ; j<26 ; j++){
        length[i][j]=(i==j)? 0 : Integer.MIN_VALUE ;
      }
    }
    int N=in.nextInt();
    for(int n=0 ; n<N ; n++){
      String name=in.next();
      int start=name.charAt(0)-'a' ;
      int end=name.charAt(name.length()-1)-'a' ;
      for(int i=0 ; i<26 ; i++){
        length[i][end]=Math.max(length[i][end],length[i][start]+name.length());
      }
    }
    int answer=0 ;
    for(int i=0 ; i<26 ; i++){
      answer=Math.max(answer,length[i][i]);
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A191 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var length : Sequence(Sequence(int)) ; length := Integer.subrange(1,26)->collect(Integer.subrange(1,26)->collect(0)) ;
        var i : int ; i := 0 ; while i < 26 do ( (         var j : int ; j := 0 ; while j < 26 do ( (     length[i+1][j+1] := if (i = j) then 0 else -2147483648 endif )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var N : int ; N := in.getCurrent()->toInteger() ;
        var n : int ; n := 0 ; while n < N do ( (     var name : String ; name := in.getCurrent() ;
     var start : int ; start := name->at(0+1) - ('a')->char2byte() ;
     var end : int ; end := name->at(name->size() - 1+1) - ('a')->char2byte() ;
         var i : int ; i := 0 ; while i < 26 do ( (     length[i+1][end+1] := Set{length[i+1][end+1], length[i+1][start+1] + name->size()}->max() )  ;     i := i + 1 ) )  ;     n := n + 1 ) ; 
    var answer : int ; answer := 0 ;
        var i : int ; i := 0 ; while i < 26 do ( (     answer := Set{answer, length[i+1][i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int n=sc.nextInt();
  static String sugoroku="" ;
  public static void main(String[] args){
    inputSugoroku();
    solveSugoroku();
  }
  private static void solveSugoroku(){
    int dice=0 ;
    String[] safes=sugoroku.split("0");
    for(int i=0 ; i<safes.length ; i++){
      dice=Math.max(dice,safes[i] .length());
    }
    System.out.println(dice+1);
  }
  private static void inputSugoroku(){
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      sb.append(sc.nextInt());
    }
    sugoroku=sb.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int := sc.getCurrent()->toInteger();
  static   attribute sugoroku : String := "";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute inputSugoroku() ; 
     execute solveSugoroku() );
  static   operation solveSugoroku() : void
  pre: true
  post: true
  activity: (     var dice : int ; dice := 0 ;
     var safes : Sequence(String) ; safes := sugoroku->split("0") ;
         var i : int ; i := 0 ; while i < safes->size() do ( (     dice := Set{dice, safes[i+1]->size()}->max() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(dice + 1) );
  static   operation inputSugoroku() : void
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < n do ( (     sb := sb + StringLib.newString(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
     sugoroku := sb+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String[][] arr=new String[12][2];
    arr[0][0]="C" ;
    arr[1][0]="C#" ;
    arr[2][0]="D" ;
    arr[3][0]="D#" ;
    arr[4][0]="E" ;
    arr[5][0]="F" ;
    arr[6][0]="F#" ;
    arr[7][0]="G" ;
    arr[8][0]="G#" ;
    arr[9][0]="A" ;
    arr[10][0]="B" ;
    arr[11][0]="H" ;
    String str="" ;
    for(int i=0 ; i<3 ; i++){
      str=sc.next();
      for(int j=0 ; j<12 ; j++){
        if(arr[j][0] .equals(str)){
          arr[j][1]="1" ;
        }
        if(arr[j][1]==null)arr[j][1]="0" ;
      }
    }
    int cnt=0 ;
    for(int k=0 ; k<12 ; k++){
      if(arr[k][1] .equals("1")){
        if(arr[(k+3)% 12][1] .equals("1")&& arr[(k+7)% 12][1] .equals("1")){
          cnt+=2 ;
          break ;
        }
        else if(arr[(k+4)% 12][1] .equals("1")&& arr[(k+7)% 12][1] .equals("1")){
          cnt+=1 ;
          break ;
        }
      }
    }
    if(cnt==1)System.out.println("major");
    else if(cnt==2)System.out.println("minor");
    else System.out.println("strange");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(Sequence(String)) ; arr := Integer.subrange(1,12)->collect(Integer.subrange(1,2)->collect(null)) ;
    arr[0+1][0+1] := "C" ; 
    arr[1+1][0+1] := "C#" ; 
    arr[2+1][0+1] := "D" ; 
    arr[3+1][0+1] := "D#" ; 
    arr[4+1][0+1] := "E" ; 
    arr[5+1][0+1] := "F" ; 
    arr[6+1][0+1] := "F#" ; 
    arr[7+1][0+1] := "G" ; 
    arr[8+1][0+1] := "G#" ; 
    arr[9+1][0+1] := "A" ; 
    arr[10+1][0+1] := "B" ; 
    arr[11+1][0+1] := "H" ; 
    var str : String ; str := "" ;
        var i : int ; i := 0 ; while i < 3 do ( (     str := sc.getCurrent() ; 
         var j : int ; j := 0 ; while j < 12 do ( (     if (arr[j+1][0+1] = str) then (     arr[j+1][1+1] := "1" ) else skip ; 
     if (arr[j+1][1+1] = null) then     arr[j+1][1+1] := "0" ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var k : int ; k := 0 ; while k < 12 do ( (     if (arr[k+1][1+1] = "1") then (     if (arr[(k + 3) mod 12+1][1+1] = "1" & arr[(k + 7) mod 12+1][1+1] = "1") then (     cnt := cnt+(2) ; 
     break ) else     if (arr[(k + 4) mod 12+1][1+1] = "1" & arr[(k + 7) mod 12+1][1+1] = "1") then (     cnt := cnt+(1) ; 
     break ) else skip ; ) else skip )  ;     k := k + 1 ) ; 
    if (cnt = 1) then     OclFile["System.out"].println("major") else     if (cnt = 2) then     OclFile["System.out"].println("minor") else     OclFile["System.out"].println("strange") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  private void doit(){
    while(true){
      String s=sc.next();
      if(s.equals("0000"))break ;
      for(int i=0 ; ; i++){
        StringBuilder sb=new StringBuilder();
        for(int j=0 ; s.length()+j<4 ; j++){
          sb.append(0);
        }
        sb.append(s);
        s=sb.toString();
        if(s.toString().equals("6174")){
          System.out.println(i);
          break ;
        }
        if(isNA(s.toString())){
          System.out.println("NA");
          break ;
        }
        int[] res=create(s.toString());
        s=new String((res[1]-res[0])+"");
      }
    }
  }
  private int[] create(String s){
    char[] c=s.toCharArray();
    Arrays.sort(c);
    StringBuilder sb=new StringBuilder(new String(c));
    int[] res=new int[2];
    res[0]=Integer.parseInt(sb.toString());
    res[1]=Integer.parseInt(sb.reverse().toString());
    return res ;
  }
  private boolean isNA(String s){
    char c=s.charAt(0);
    for(int i=1 ; i<s.length(); i++){
      if(c!=s.charAt(i))return false ;
    }
    return true ;
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation doit() : void
  pre: true
  post: true
  activity: (     while (true) do (     var s : String ; s := sc.getCurrent() ;
     if (s = "0000") then     break else skip ; 
         var i : int ; i := 0 ; while true do ( (     var sb : String ; sb := StringLib.newString() ;
         var j : int ; j := 0 ; while s->size() + j < 4 do ( (     sb := sb + StringLib.newString(0) )  ;     j := j + 1 ) ; 
    sb := sb + StringLib.newString(s) ; 
    s := sb+"" ; 
    if (s+"" = "6174") then (     OclFile["System.out"].println(i) ; 
     break ) else skip ; 
    if (isNA(s+"")) then (     OclFile["System.out"].println("NA") ; 
     break ) else skip ; 
    var res : Sequence(int) ; res := create(s+"") ;
    s := StringLib.newString((res[1+1] - res[0+1]) + "") ; 
 )  ;     i := i + 1 ) ) );
   operation create( s : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var c : Sequence(String) ; c := s->characters() ;
     c := c->sort() ; 
    var sb : String ; sb := StringLib.newString(StringLib.newString(c)) ;
    var res : Sequence(int) ; res := Integer.subrange(1,2)->collect(0) ;
    res[0+1] := (sb+"")->toInteger() ; 
    res[1+1] := (sb->reverse()+"")->toInteger() ; 
    return res 
 );
   operation isNA( s : String) : boolean
  pre: true
  post: true
  activity: (     var c : String ; c := s->at(0+1) ;
         var i : int ; i := 1 ; while i < s->size() do ( (     if (c /= s->at(i+1)) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      Integer[] l=d(n);
      if(l[0]==l[1] && l[1]==l[2] && l[2]==l[3]){
        System.out.println("NA");
        continue ;
      }
      int c=0 ;
      while(n!=6174){
        c++;
        l=d(n);
        Arrays.sort(l,Comparator.reverseOrder());
        int a=c(l);
        Arrays.sort(l);
        int b=c(l);
        n=a-b ;
      }
      System.out.println(c);
    }
  }
  static int c(Integer[] l){
    int n=0 ;
    for(int i=0,j=1000 ; i<4 ; i++,j/=10){
      n+=l[i]*j ;
    }
    return n ;
  }
  static Integer[] d(int n){
    Integer[] l=new Integer[4];
    for(int i=0,j=1000 ; i<4 ; i++,j/=10){
      l[i]=n/j ;
      n %=j ;
    }
    return l ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var l : Sequence(int) ; l := d(n) ;
    if (l[0+1] = l[1+1] & l[1+1] = l[2+1] & l[2+1] = l[3+1]) then (     OclFile["System.out"].println("NA") ; 
     continue ) else skip ; 
    var c : int ; c := 0 ;
    while (n /= 6174) do (     c := c + 1 ; 
     l := d(n) ; 
    l := OclComparator.sortWith(l, Comparator.reverseOrder()) ; 
    var a : int ; a := c(l) ;
    l := l->sort() ; 
    var b : int ; b := c(l) ;
    n := a - b ; 
 ) ; 
    OclFile["System.out"].println(c) ; 
 )  ) );
  static   operation c( l : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := 0 ;
         var i : int ; i := 0 ;
    var j : int ; j := 1000 ; while i < 4 do ( (     n := n+(l[i+1] * j) )  ;     i := i + 1 ;     j := j/(10) ) ; 
     return n );
  static   operation d( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Integer.subrange(1,4)->collect(null) ;
         var i : int ; i := 0 ;
    var j : int ; j := 1000 ; while i < 4 do ( (     l[i+1] := n / j ; 
     n := n mod j )  ;     i := i + 1 ;     j := j/(10) ) ; 
     return l );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Comparator ;
public class Main {
  BufferedReader reader ;
  class CharComparator implements Comparator<Character>{
    private boolean descend ;
    @ Override public int compare(Character o1,Character o2){
      if(descend)return o2-o1 ;
      else return o1-o2 ;
    }
    CharComparator(boolean descend){
      this.descend=descend ;
    }
  }
  int charArray2int(final Character[] s){
    int n=0 ;
    for(int i=0 ; i<s.length ; ++i){
      n*=10 ;
      n+=s[i]-'0' ;
    }
    return n ;
  }
  void int2charArray(Character[] s,int n){
    for(int i=s.length-1 ; i>=0 ; --i){
      s[i]=(char)(n % 10+'0');
      n/=10 ;
    }
  }
  int solve(String n0){
    Character N[]=new Character[4];
    for(int i=0 ; i<4 ; ++i){
      N[i]=n0.charAt(i);
    }
    if(charArray2int(N)% 1111==0)return-1 ;
    int k ;
    for(k=0 ; charArray2int(N)!=6174 ; ++k){
      Arrays.sort(N,new CharComparator(true));
      int L=charArray2int(N);
      Arrays.sort(N,new CharComparator(false));
      int S=charArray2int(N);
      int2charArray(N,L-S);
    }
    return k ;
  }
  String ns()throws Exception {
    return reader.readLine();
  }
  void io(){
    reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      String s ;
      while((s=ns()).compareTo("0000")!=0){
        int ans=solve(s);
        System.out.println(ans==-1 ? "NA" : ans);
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  public static void main(String[] args){
    new Main().io();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute reader : OclFile;
 class CharComparator implements Function(<String>,(<String>,boolean)) {
   attribute descend : boolean;
      operation compare( o1 : String, o2 : String) : int
  pre: true
  post: true
  activity: (     if (descend) then     return o2 - o1 else     return o1 - o2 );
   static operation newCharComparator( descend : boolean) : CharComparator
  pre: true
  post: true
  activity:
  ( var self : CharComparator ;
    self := createCharComparator();
    self.initialise(descend);
    return self );
  operation initialise( descend : boolean) : void
  pre: true  post: true
  activity: (     self.descend := descend );
}
   operation charArray2int( s : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     n := n*(10) ; 
     n := n+(s[i+1] - ('0')->char2byte()) )  ;     i := i + 1 ) ; 
     return n );
   operation int2charArray( s : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := s->size() - 1 ; while i >= 0 do ( (     s[i+1] := (n mod 10 + '0')->oclAsType(String) ; 
     n := n/(10) )  ;     i := i - 1 ) );
   operation solve( n0 : String) : int
  pre: true
  post: true
  activity: (     var N : Sequence(String) ; N := Integer.subrange(1,4)->collect(null) ;
         var i : int ; i := 0 ; while i < 4 do ( (     N[i+1] := n0->at(i+1) )  ;     i := i + 1 ) ; 
    if (charArray2int(N) mod 1111 = 0) then     return -1 else skip ; 
    var k : int ;
        k := 0 ; while charArray2int(N) /= 6174 do ( (     N := OclComparator.sortWith(N, CharComparator.newCharComparator(true)) ; 
     var L : int ; L := charArray2int(N) ;
    N := OclComparator.sortWith(N, CharComparator.newCharComparator(false)) ; 
    var S : int ; S := charArray2int(N) ;
    execute int2charArray(N, L - S) ; 
 )  ;     k := k + 1 ) ; 
    return k 
 );
   operation ns() : String
  pre: true
  post: true
  activity: (     return reader.readLine() );
   operation io() : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     try (     var s : String ;
         s := ns() ;
    while ((s)->compareTo("0000") /= 0) do (    skip ; (     var ans : int ; ans := solve(s) ;
     OclFile["System.out"].println(if ans = -1 then "NA" else ans endif) ) ;     s := ns() ;
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().io() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new AOJ0259().doIt();
  }
  class AOJ0259 {
    String solve(String input){
      int[] num=new int[4];
      for(int i=0 ; i<4 ; i++)num[i]=Integer.parseInt(input.charAt(i)+"");
      if(num[0]==num[1] && num[0]==num[2] && num[0]==num[3])return "NA" ;
      int cnt=0 ;
      while(true){
        if(num[0]==6 && num[1]==1 && num[2]==7 && num[3]==4)break ;
        Arrays.sort(num);
        int l=Integer.parseInt(Integer.toString(num[3])+Integer.toString(num[2])+Integer.toString(num[1])+Integer.toString(num[0]));
        int s=Integer.parseInt(Integer.toString(num[0])+Integer.toString(num[1])+Integer.toString(num[2])+Integer.toString(num[3]));
        String a=Integer.toString(l-s);
        if(a.length()<4)for(int i=0 ;
        i<4-a.length();
        i++)a="0"+a ;
        for(int i=0 ; i<a.length(); i++)num[i]=Integer.parseInt(a.charAt(i)+"");
        cnt++;
      }
      return Integer.toString(cnt);
    }
    void doIt(){
      while(true){
        String input=in.next();
        if(input.equals("0000"))break ;
        String solve=solve(input);
        System.out.println(solve);
      }
    }
  }
  class AOJ0260 {
    void doIt(){
      while(true){
        int n=in.nextInt();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     AOJ0259.newAOJ0259().doIt() );
 class AOJ0259 {
   operation solve( input : String) : String
  pre: true
  post: true
  activity: (     var num : Sequence(int) ; num := Integer.subrange(1,4)->collect(0) ;
         var i : int ; i := 0 ; while i < 4 do (     num[i+1] := (input->at(i+1) + "")->toInteger() ;  ;     i := i + 1 ) ; 
    if (num[0+1] = num[1+1] & num[0+1] = num[2+1] & num[0+1] = num[3+1]) then     return "NA" else skip ; 
    var cnt : int ; cnt := 0 ;
    while (true) do (     if (num[0+1] = 6 & num[1+1] = 1 & num[2+1] = 7 & num[3+1] = 4) then     break else skip ; 
     num := num->sort() ; 
    var l : int ; l := (((num[3+1]) + "") + ((num[2+1]) + "") + ((num[1+1]) + "") + ((num[0+1]) + ""))->toInteger() ;
    var s : int ; s := (((num[0+1]) + "") + ((num[1+1]) + "") + ((num[2+1]) + "") + ((num[3+1]) + ""))->toInteger() ;
    var a : String ; a := ((l - s) + "") ;
    if (a->size() < 4) then         var i : int ; i := 0 ; while i < 4 - a->size() do (     a := "0" + a ;  ;     i := i + 1 ) ; else skip ; 
        var i : int ; i := 0 ; while i < a->size() do (     num[i+1] := (a->at(i+1) + "")->toInteger() ;  ;     i := i + 1 ) ; 
    cnt := cnt + 1 ; 
 ) ; 
    return ((cnt) + "") 
 );
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (true) do (     var input : String ; input := in.getCurrent() ;
     if (input = "0000") then     break else skip ; 
     var solve : String ; solve := solve(input) ;
     OclFile["System.out"].println(solve) ) );
}
 class AOJ0260 {
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := in.getCurrent()->toInteger() ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
class Main {
  public static void main(String[] args){
    BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
    try {
      while(true){
        String st=sc.readLine();
        if(st.equals("0000"))break ;
        if(st.charAt(0)==st.charAt(1)&& st.charAt(1)==st.charAt(2)&& st.charAt(2)==st.charAt(3))System.out.println("NA");
        else {
          int num=0 ;
          while(! st.equals("6174")){
            char[] ini=new char[4];
            for(int i=0 ; i<st.length(); i++)ini[i]=st.charAt(i);
            for(int i=st.length(); i<4 ; i++)ini[i]=Character.forDigit(0,10);
            Arrays.sort(ini);
            String s=new StringBuilder().append(ini[0]).append(ini[1]).append(ini[2]).append(ini[3]).toString();
            String l=new StringBuilder().append(ini[3]).append(ini[2]).append(ini[1]).append(ini[0]).toString();
            int now=Integer.valueOf(l)-Integer.valueOf(s);
            st=Integer.toString(now);
            num++;
          }
          System.out.println(num);
        }
      }
    }
    catch(Exception e){
      System.out.println("Error");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     while (true) do (     var st : String ; st := sc.readLine() ;
     if (st = "0000") then     break else skip ; 
     if (st->at(0+1) = st->at(1+1) & st->at(1+1) = st->at(2+1) & st->at(2+1) = st->at(3+1)) then     OclFile["System.out"].println("NA") ; else (     var num : int ; num := 0 ;
     while (not(st = "6174")) do (     var ini : Sequence(String) ; ini := Integer.subrange(1,4)->collect(0) ;
         var i : int ; i := 0 ; while i < st->size() do (     ini[i+1] := st->at(i+1) ;  ;     i := i + 1 ) ; 
        var i : int ; i := st->size() ; while i < 4 do (     ini[i+1] := (0 + "") ;  ;     i := i + 1 ) ; 
    ini := ini->sort() ; 
    var s : String ; s := StringLib.newString() + StringLib.newString(ini[0+1]) + StringLib.newString(ini[1+1]) + StringLib.newString(ini[2+1]) + StringLib.newString(ini[3+1])+"" ;
    var l : String ; l := StringLib.newString() + StringLib.newString(ini[3+1]) + StringLib.newString(ini[2+1]) + StringLib.newString(ini[1+1]) + StringLib.newString(ini[0+1])+"" ;
    var now : int ; now := (l)->toInteger() - (s)->toInteger() ;
    st := ((now) + "") ; 
    num := num + 1 ; 
 ) ; 
     OclFile["System.out"].println(num) ) ) )   catch (e : ProgramException) do (     OclFile["System.out"].println("Error") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
import java.io.*;
public class codeHundredSixty {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      int x1=input.nextInt();
      int y1=input.nextInt();
      int z1=input.nextInt();
      int x2=input.nextInt();
      int y2=input.nextInt();
      int z2=input.nextInt();
      long sum=0 ;
      sum+=Math.min(z1,y2)*2 ;
      z1-=Math.min(z1,y2);
      int k=Math.min(x1,z2);
      z2-=k ;
      if(z1!=0){
        z2-=z1 ;
      }
      if(z2>0){
        sum-=z2*2 ;
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var x1 : int ; x1 := input.getCurrent()->toInteger() ;
     var y1 : int ; y1 := input.getCurrent()->toInteger() ;
    var z1 : int ; z1 := input.getCurrent()->toInteger() ;
    var x2 : int ; x2 := input.getCurrent()->toInteger() ;
    var y2 : int ; y2 := input.getCurrent()->toInteger() ;
    var z2 : int ; z2 := input.getCurrent()->toInteger() ;
    var sum : long ; sum := 0 ;
    sum := sum+(Set{z1, y2}->min() * 2) ; 
    z1 := z1-(Set{z1, y2}->min()) ; 
    var k : int ; k := Set{x1, z2}->min() ;
    z2 := z2-(k) ; 
    if (z1 /= 0) then (     z2 := z2-(z1) ) else skip ; 
    if (z2 > 0) then (     sum := sum-(z2 * 2) ) else skip ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class pre22 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int n=obj.nextInt(),m=obj.nextInt();
    int l=(n+3)/4 ;
    for(int i=1 ; i<=l ; i++)out.print(5);
    out.println();
    for(int i=1 ; i<l ; i++)out.print(4);
    out.println(5);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre22 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var n : int ; n := obj.nextInt() ;
    var m : int ; m := obj.nextInt() ;
    var l : int ; l := (n + 3) / 4 ;
        var i : int ; i := 1 ; while i <= l do (     out.print(5) ;  ;     i := i + 1 ) ; 
    out.println() ; 
        var i : int ; i := 1 ; while i < l do (     out.print(4) ;  ;     i := i + 1 ) ; 
    out.println(5) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=100000 ;
  static ArrayList<Integer>primes=new ArrayList<Integer>();
  static void sieve(){
    boolean[] isComposite=new boolean[MAX+1];
    for(int i=2 ; i*i<=MAX ; i++){
      if(isComposite[i]==false)for(int j=2 ;
      j*i<=MAX ;
      j++)isComposite[i*j]=true ;
    }
    for(int i=2 ; i<=MAX ; i++)if(isComposite[i]==false)primes.add(i);
  }
  static long LCM(int n){
    long lcm=1 ;
    for(int i=0 ; i<primes.size()&& primes.get(i)<=n ; i++){
      int pp=primes.get(i);
      while(pp*primes.get(i)<=n)pp=pp*primes.get(i);
      lcm*=pp ;
      lcm %=1000000007 ;
    }
    return lcm ;
  }
  public static void main(String[] args){
    sieve();
    int N=7 ;
    System.out.println(LCM(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100000;
  static   attribute primes : Sequence(int) := Sequence{};
  static   operation sieve() : void
  pre: true
  post: true
  activity: (     var isComposite : Sequence(boolean) ; isComposite := Integer.subrange(1,MAX + 1)->collect(false) ;
         var i : int ; i := 2 ; while i * i <= MAX do ( (     if (isComposite[i+1] = false) then         var j : int ; j := 2 ; while j * i <= MAX do (     isComposite[i * j+1] := true ;  ;     j := j + 1 ) ; else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 2 ; while i <= MAX do (     if (isComposite[i+1] = false) then     primes := primes->including(i) ; else skip ;  ;     i := i + 1 ) );
  static   operation LCM( n : int) : long
  pre: true
  post: true
  activity: (     var lcm : long ; lcm := 1 ;
         var i : int ; i := 0 ; while i < primes->size() & primes->at(i+1) <= n do ( (     var pp : int ; pp := primes->at(i+1) ;
     while (pp * primes->at(i+1) <= n) do     pp := pp * primes->at(i+1) ; ; 
     lcm := lcm*(pp) ; 
     lcm := lcm mod 1000000007 )  ;     i := i + 1 ) ; 
     return lcm );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute sieve() ; 
     var N : int ; N := 7 ;
     OclFile["System.out"].println(LCM(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void print_asterisk(int asterisk){
    if(asterisk==0)return ;
    System.out.print("*");
    print_asterisk(asterisk-1);
  }
  static void print_space(int space){
    if(space==0)return ;
    System.out.print(" ");
    System.out.print(" ");
    print_space(space-1);
  }
  static void pattern(int n,int num){
    if(n==0)return ;
    print_asterisk(n);
    print_space(2*(num-n)+1);
    print_asterisk(n);
    System.out.print("\n");
    pattern(n-1,num);
  }
  public static void main(String[] args){
    int n=5 ;
    pattern(n,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation print_asterisk( asterisk : int) : void
  pre: true
  post: true
  activity: (     if (asterisk = 0) then     return else skip ; 
     OclFile["System.out"].print("*") ; 
     execute print_asterisk(asterisk - 1) );
  static   operation print_space( space : int) : void
  pre: true
  post: true
  activity: (     if (space = 0) then     return else skip ; 
     OclFile["System.out"].print(" ") ; 
     OclFile["System.out"].print(" ") ; 
     execute print_space(space - 1) );
  static   operation pattern( n : int, num : int) : void
  pre: true
  post: true
  activity: (     if (n = 0) then     return else skip ; 
     execute print_asterisk(n) ; 
    execute print_space(2 * (num - n) + 1) ; 
    execute print_asterisk(n) ; 
    OclFile["System.out"].print("\n") ; 
    execute pattern(n - 1, num) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute pattern(n, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] input=br.readLine().split(" ");
    int max=0 ;
    boolean onCheck=false ;
    int cl=1 ;
    for(String x : input){
      if(x.equals("1")){
        cl++;
        onCheck=true ;
      }
      else if(onCheck){
        max=Math.max(cl,max);
        cl=1 ;
        onCheck=false ;
      }
    }
    max=Math.max(cl,max);
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var input : Sequence(String) ; input := br.readLine()->split(" ") ;
    var max : int ; max := 0 ;
    var onCheck : boolean ; onCheck := false ;
    var cl : int ; cl := 1 ;
    for (x : input) do ( (     if (x = "1") then (     cl := cl + 1 ; 
     onCheck := true ) else     if (onCheck) then (     max := Set{cl, max}->max() ; 
     cl := 1 ; 
     onCheck := false ) else skip ; )  ) ; 
    max := Set{cl, max}->max() ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void print_asterisk(int asterisk){
    if(asterisk==0)return ;
    System.out.print("*");
    print_asterisk(asterisk-1);
  }
  static void print_space(int space){
    if(space==0)return ;
    System.out.print(" ");
    System.out.print(" ");
    print_space(space-1);
  }
  static void pattern(int n,int num){
    if(n==0)return ;
    print_asterisk(num-n+1);
    print_space(2*n-1);
    print_asterisk(num-n+1);
    System.out.println();
    pattern(n-1,num);
  }
  public static void main(String[] args){
    int n=5 ;
    pattern(n,n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation print_asterisk( asterisk : int) : void
  pre: true
  post: true
  activity: (     if (asterisk = 0) then     return else skip ; 
     OclFile["System.out"].print("*") ; 
     execute print_asterisk(asterisk - 1) );
  static   operation print_space( space : int) : void
  pre: true
  post: true
  activity: (     if (space = 0) then     return else skip ; 
     OclFile["System.out"].print(" ") ; 
     OclFile["System.out"].print(" ") ; 
     execute print_space(space - 1) );
  static   operation pattern( n : int, num : int) : void
  pre: true
  post: true
  activity: (     if (n = 0) then     return else skip ; 
     execute print_asterisk(num - n + 1) ; 
    execute print_space(2 * n - 1) ; 
    execute print_asterisk(num - n + 1) ; 
    OclFile["System.out"].println() ; 
    execute pattern(n - 1, num) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute pattern(n, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int number=sc.nextInt(),flag=0 ;
    int[] arr=new int[number+1];
    for(int i=0 ; i<number ; i++){
      arr[i]=sc.nextInt();
    }
    boolean choose=false ;
    for(int i=0 ; i<number ; i++){
      if(arr[i]==i){
        flag++;
      }
      else {
        if(i==arr[arr[i] ]){
          choose=true ;
        }
      }
    }
    System.out.print(number==flag ? number :(choose ? flag+2 : flag+1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := sc.getCurrent()->toInteger() ;
    var flag : int ; flag := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,number + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < number do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var choose : boolean ; choose := false ;
        var i : int ; i := 0 ; while i < number do ( (     if (arr[i+1] = i) then (     flag := flag + 1 ) else (     if (i = arr[arr[i+1]+1]) then (     choose := true ) else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(if number = flag then number else (if choose then flag + 2 else flag + 1 endif) endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner a=new Scanner(System.in);
    int n=a.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<arr.length ; i++)arr[i]=a.nextInt();
    int count=0 ;
    int swap=1 ;
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]==i)count++;
      else if(swap>0){
        int n1=arr[i];
        int n2=arr[n1];
        if(n2==i){
          count+=2 ;
          swap=0 ;
        }
      }
    }
    if(swap==1 && count!=n)count+=1 ;
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : OclFile ; a := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := a.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do (     arr[i+1] := a.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var swap : int ; swap := 1 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = i) then     count := count + 1 ; else     if (swap > 0) then (     var n1 : int ; n1 := arr[i+1] ;
     var n2 : int ; n2 := arr[n1+1] ;
     if (n2 = i) then (     count := count+(2) ; 
     swap := 0 ) else skip ) else skip ; )  ;     i := i + 1 ) ; 
    if (swap = 1 & count /= n) then     count := count+(1) ; else skip ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int AVLnodes(int height){
    if(height==0)return 1 ;
    else if(height==1)return 2 ;
    return(1+AVLnodes(height-1)+AVLnodes(height-2));
  }
  public static void main(String args[]){
    int H=3 ;
    System.out.println(AVLnodes(H));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation AVLnodes( height : int) : int
  pre: true
  post: true
  activity: (     if (height = 0) then     return 1 else     if (height = 1) then     return 2 else skip ; ;  
     return (1 + AVLnodes(height - 1) + AVLnodes(height - 2)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var H : int ; H := 3 ;
     OclFile["System.out"].println(AVLnodes(H)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int longest_gap(int N){
    int distance=0,count=0,first_1=-1,last_1=-1 ;
    while(N!=0){
      count++;
      int r=N & 1 ;
      if(r==1){
        first_1=first_1==-1 ? count : first_1 ;
        last_1=count ;
      }
      N=N/2 ;
    }
    if(last_1<=first_1){
      return-1 ;
    }
    else {
      distance=(last_1-first_1-1);
      return distance ;
    }
  }
  public static void main(String[] args){
    int N=131 ;
    System.out.println(longest_gap(N));
    N=8 ;
    System.out.println(longest_gap(N));
    N=17 ;
    System.out.println(longest_gap(N));
    N=33 ;
    System.out.println(longest_gap(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation longest_gap( N : int) : int
  pre: true
  post: true
  activity: (     var distance : int ; distance := 0 ;
    var count : int ; count := 0 ;
    var first    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 : int ; first    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 := -1 ;
    var last    var last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 :  ; last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 := -1 : int ; last    var last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 :  ; last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 := -1 := -1 ;
     while (N /= 0) do (     count := count + 1 ; 
     var r : int ; r := MathLib.bitwiseAnd(N,1) ;
     if (r = 1) then (     firstfirst_1 := if firstfirst_1 = -1 then count else firstfirst_1 endif ; 
     lastlast    lastlast    firstfirst_1 := if firstfirst_1 = -1 then count else firstfirst_1 endif ; 
 := count ; := count ) else skip ; 
     N := N / 2 ) ; 
     if (last    if (last    var distance : int ; distance := 0 ;
    var count : int ; count := 0 ;
    var first    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 : int ; first    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 := -1 ;
    var last    var last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 :  ; last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 := -1 : int ; last    var last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 :  ; last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 := -1 := -1 ;
 <= first    var distance : int ; distance := 0 ;
    var count : int ; count := 0 ;
    var first    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 : int ; first    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 := -1 ;
    var last    var last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 :  ; last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 := -1 : int ; last    var last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 :  ; last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 := -1 := -1 ;
) then (     return -1 ) else (     distance := (lastlastlastlastdistance - firstlastdistance - firstlastlastlastdistance - firstlastdistance - 1) ; 
     return distance ) ;  <= first    if (last    var distance : int ; distance := 0 ;
    var count : int ; count := 0 ;
    var first    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 : int ; first    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 := -1 ;
    var last    var last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 :  ; last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 := -1 : int ; last    var last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 :  ; last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 := -1 := -1 ;
 <= first    var distance : int ; distance := 0 ;
    var count : int ; count := 0 ;
    var first    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 : int ; first    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 := -1 ;
    var last    var last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 :  ; last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 := -1 : int ; last    var last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 :  ; last    var first    var count :  ; count := 0 :  ; first    var count :  ; count := 0 := -1 := -1 := -1 ;
) then (     return -1 ) else (     distance := (lastlastlastlastdistance - firstlastdistance - firstlastlastlastdistance - firstlastdistance - 1) ; 
     return distance ) ; ) then (     return -1 ) else (     distance := (lastlastlastlastdistance - firstlastdistance - firstlastlastlastdistance - firstlastdistance - 1) ; 
     return distance ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 131 ;
     OclFile["System.out"].println(longest_gap(N)) ; 
    N := 8 ; 
    OclFile["System.out"].println(longest_gap(N)) ; 
    N := 17 ; 
    OclFile["System.out"].println(longest_gap(N)) ; 
    N := 33 ; 
    OclFile["System.out"].println(longest_gap(N)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int CalculateDifference(int arr[],int n){
    int max_val=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]>max_val)max_val=arr[i];
    }
    boolean[] prime=new boolean[max_val+1];
    for(int i=0 ; i<=max_val ; i++)prime[i]=true ;
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=max_val ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=max_val ; i+=p)prime[i]=false ;
      }
    }
    int S1=0,S2=0 ;
    for(int i=0 ; i<n ; i++){
      if(prime[arr[i] ]){
        S1+=arr[i];
      }
      else if(arr[i]!=1){
        S2+=arr[i];
      }
    }
    return Math.abs(S2-S1);
  }
  public static void main(String[] args){
    int arr[]={
      1,3,5,10,15,7 };
      int n=arr.length ;
      System.out.println(CalculateDifference(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation CalculateDifference( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max_val : int ; max_val := -2147483648 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] > max_val) then     max_val := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
    var prime : Sequence(boolean) ; prime := Integer.subrange(1,max_val + 1)->collect(false) ;
        var i : int ; i := 0 ; while i <= max_val do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
    prime[0+1] := false ; 
    prime[1+1] := false ; 
        var p : int ; p := 2 ; while p * p <= max_val do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= max_val do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var S1 : int ; S1 := 0 ;
    var S2 : int ; S2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (prime[arr[i+1]+1]) then (     S1 := S1+(arr[i+1]) ) else     if (arr[i+1] /= 1) then (     S2 := S2+(arr[i+1]) ) else skip ; )  ;     i := i + 1 ) ; 
    return if S2 - S1 < 0 then -(S2 - S1) else S2 - S1 endif 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,5,10,15,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(CalculateDifference(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long center_pentadecagonal_num(long n){
    return(15*n*n-15*n+2)/2 ;
  }
  public static void main(String[] args){
    long n=3 ;
    System.out.print(n+"th number : ");
    System.out.println(center_pentadecagonal_num(n));
    n=10 ;
    System.out.print(n+"th number : ");
    System.out.println(center_pentadecagonal_num(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation center_pentadecagonal_num( n : long) : long
  pre: true
  post: true
  activity: (     return (15 * n * n - 15 * n + 2) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 3 ;
     OclFile["System.out"].print(n + "th number : ") ; 
    OclFile["System.out"].println(center_pentadecagonal_num(n)) ; 
    n := 10 ; 
    OclFile["System.out"].print(n + "th number : ") ; 
    OclFile["System.out"].println(center_pentadecagonal_num(n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DigitsSequenceDividing {
  void solve(String x){
    if(x.length()==2 && x.charAt(0)>=x.charAt(1)){
      System.out.println("NO");
    }
    else {
      System.out.println("YES"+"\n"+"2"+"\n"+x.charAt(0)+" "+x.substring(1,x.length()));
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      String s=sc.next();
      DigitsSequenceDividing obj=new DigitsSequenceDividing();
      obj.solve(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DigitsSequenceDividing {
   operation solve( x : String) : void
  pre: true
  post: true
  activity: (     if (x->size() = 2 & x->at(0+1) >= x->at(1+1)) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES" + "\n" + "2" + "\n" + x->at(0+1) + " " + x.subrange(1+1,x->size())) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
     var obj : DigitsSequenceDividing ; obj := DigitsSequenceDividing.newDigitsSequenceDividing() ;
     obj.solve(s) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
public class Contest_yandexA {
  static final int MAXN=(int)1e6 ;
  public static void main(String[] args)throws IOException {
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int m=input.nextInt();
    if(n<5){
      System.out.println("5 5");
    }
    else {
      int count1=((n-5)+3)/4 ;
      for(int i=0 ; i<count1 ; i++){
        System.out.print("4");
      }
      System.out.print("5 ");
      System.out.println();
      for(int i=0 ; i<=count1 ; i++){
        System.out.print("5");
      }
    }
  }
  public static long gcd(long a,long b){
    if(b==0){
      return a ;
    }
    return gcd(b,a % b);
  }
}
class Pair implements Comparable<Pair>{
  int x ;
  int w ;
  int idx ;
  Pair(int x,int w,int idx){
    this.x=x ;
    this.w=w ;
    this.idx=idx ;
  }
  @ Override public int compareTo(Pair p){
    return this.w-p.w ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Contest_yandexA {
  static    attribute MAXN : int := 1e6->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
     var m : int ; m := input.getCurrent()->toInteger() ;
     if (n < 5) then (     OclFile["System.out"].println("5 5") ) else (     var count1 : int ; count1 := ((n - 5) + 3) / 4 ;
         var i : int ; i := 0 ; while i < count1 do ( (     OclFile["System.out"].print("4") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("5 ") ; 
    OclFile["System.out"].println() ; 
        var i : int ; i := 0 ; while i <= count1 do ( (     OclFile["System.out"].print("5") )  ;     i := i + 1 ) ; 
 ) );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else skip ; 
     return gcd(b, a mod b) );
}
class Pair implements Comparable<Map> {
   attribute x : int;
   attribute w : int;
   attribute idx : int;
   static operation newPair( x : int, w : int, idx : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, w,idx);
    return self );
  operation initialise( x : int, w : int, idx : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.w := w ; 
     self.idx := idx );
      operation compareTo( p : Map) : int
  pre: true
  post: true
  activity: (     return self.w - p.w );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DigitsSequenceDividing {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0){
      int n=sc.nextInt();
      String s=sc.next();
      if(s.length()==2){
        if(Character.getNumericValue(s.charAt(0))>=Character.getNumericValue(s.charAt(1))){
          System.out.println("NO");
          continue ;
        }
      }
      System.out.println("YES");
      System.out.println(2);
      System.out.print(s.charAt(0)+" ");
      for(int i=1 ; i<s.length(); i++){
        System.out.print(s.charAt(i));
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DigitsSequenceDividing {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
    if (s->size() = 2) then (     if (("" + s->at(0+1))->toInteger() >= ("" + s->at(1+1))->toInteger()) then (     OclFile["System.out"].println("NO") ; 
     continue ) else skip ) else skip ; 
    OclFile["System.out"].println("YES") ; 
    OclFile["System.out"].println(2) ; 
    OclFile["System.out"].print(s->at(0+1) + " ") ; 
        var i : int ; i := 1 ; while i < s->size() do ( (     OclFile["System.out"].print(s->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int masu=sc.nextInt();
    List<Integer>masuList=new ArrayList<Integer>();
    for(int i=0 ; i<masu ; i++){
      masuList.add(sc.nextInt());
    }
    List<Integer>meList=new ArrayList<Integer>();
    int memory=0 ;
    for(int k=0 ; k<masu ; k++){
      memory++;
      if(masuList.get(k)==0){
        meList.add(memory);
        memory=0 ;
      }
      else if(k==masu-1){
        meList.add(memory+1);
      }
    }
    int ret=0 ;
    for(int l=0 ; l<meList.size(); l++){
      if(ret<meList.get(l)){
        ret=meList.get(l);
      }
    }
    System.out.println(ret);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var masu : int ; masu := sc.getCurrent()->toInteger() ;
    var masuList : Sequence(int) ; masuList := Sequence{} ;
        var i : int ; i := 0 ; while i < masu do ( (     masuList := masuList->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var meList : Sequence(int) ; meList := Sequence{} ;
    var memory : int ; memory := 0 ;
        var k : int ; k := 0 ; while k < masu do ( (     memory := memory + 1 ; 
     if (masuList->at(k+1) = 0) then (     meList := meList->including(memory) ; 
     memory := 0 ) else     if (k = masu - 1) then (     meList := meList->including(memory + 1) ) else skip ; )  ;     k := k + 1 ) ; 
    var ret : int ; ret := 0 ;
        var l : int ; l := 0 ; while l < meList->size() do ( (     if (ret < meList->at(l+1)) then (     ret := meList->at(l+1) ) else skip )  ;     l := l + 1 ) ; 
    OclFile["System.out"].println(ret) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      String s=sc.next();
      if(s.length()>2)out.printf("YES\n2\n%s %s\n",s.charAt(0),s.substring(1));
      else {
        int x=s.charAt(0)-'0' ;
        int y=s.charAt(1)-'0' ;
        if(x<y)out.printf("YES\n2\n%d %d\n",x,y);
        else out.println("NO");
      }
    }
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
     if (s->size() > 2) then     skip ; else (     var x : int ; x := s->at(0+1) - ('0')->char2byte() ;
     var y : int ; y := s->at(1+1) - ('0')->char2byte() ;
     if (x < y) then     skip ; else     skip ; ) ) ;  ) ;  
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int min(int x,int y,int z){
    return Math.min(Math.min(x,y),z);
  }
  static int editDistDP(String str1,String str2,int m,int n){
    int dp[][]=new int[m+1][n+1];
    for(int i=0 ; i<=m ; i++){
      for(int j=0 ; j<=n ; j++){
        if(i==0)dp[i][j]=j ;
        else if(j==0)dp[i][j]=i ;
        else if(str1.charAt(i-1)==str2.charAt(j-1))dp[i][j]=dp[i-1][j-1];
        else dp[i][j]=1+min(dp[i][j-1],dp[i-1][j],dp[i-1][j-1]);
      }
    }
    return dp[m][n];
  }
  static boolean areKDistant(String str1,String str2,int k){
    int m=str1.length();
    int n=str2.length();
    if(Math.abs(m-n)>k)return false ;
    return(editDistDP(str1,str2,m,n)<=k);
  }
  public static void main(String[] args){
    String str1="geek" ;
    String str2="gks" ;
    int k=3 ;
    if(areKDistant(str1,str2,k))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation min( x : int, y : int, z : int) : int
  pre: true
  post: true
  activity: (     return Set{Set{x, y}->min(), z}->min() );
  static   operation editDistDP( str1 : String, str2 : String, m : int, n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i <= m do ( (         var j : int ; j := 0 ; while j <= n do ( (     if (i = 0) then     dp[i+1][j+1] := j ; else     if (j = 0) then     dp[i+1][j+1] := i else     if (str1->at(i - 1+1) = str2->at(j - 1+1)) then     dp[i+1][j+1] := dp[i - 1+1][j - 1+1] else     dp[i+1][j+1] := 1 + Set{dp[i+1][j - 1+1], dp[i - 1+1][j+1], dp[i - 1+1][j - 1+1]}->min() ; ;  ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return dp[m+1][n+1] );
  static   operation areKDistant( str1 : String, str2 : String, k : int) : boolean
  pre: true
  post: true
  activity: (     var m : int ; m := str1->size() ;
     var n : int ; n := str2->size() ;
     if (if m - n < 0 then -(m - n) else m - n endif > k) then     return false else skip ; 
     return (editDistDP(str1, str2, m, n) <= k) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "geek" ;
     var str2 : String ; str2 := "gks" ;
     var k : int ; k := 3 ;
     if (areKDistant(str1, str2, k)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class geeksforgeeks {
  static int markingScheme(int N,int answerKey[],int studentAnswer[]){
    int positive=0,negative=0,notattempt=0 ;
    for(int i=0 ; i<N ; i++){
      if(studentAnswer[i]==0)notattempt++;
      else if(answerKey[i]==studentAnswer[i])positive++;
      else if(answerKey[i]!=studentAnswer[i])negative++;
    }
    return(positive*3)+(negative*-1);
  }
  public static void main(String args[]){
    int answerKey[]={
      1,2,3,4,1 };
      int studentAnswer[]={
        1,2,3,4,0 };
        int N=answerKey.length ;
        int marking_Scheme=markingScheme(N,answerKey,studentAnswer);
        System.out.println(marking_Scheme);
      }
    }

------------------------------------------------------------
OCL File:
---------
class geeksforgeeks {
  static   operation markingScheme( N : int, answerKey : Sequence(int), studentAnswer : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var positive : int ; positive := 0 ;
    var negative : int ; negative := 0 ;
    var notattempt : int ; notattempt := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     if (studentAnswer[i+1] = 0) then     notattempt := notattempt + 1 ; else     if (answerKey[i+1] = studentAnswer[i+1]) then     positive := positive + 1 else     if (answerKey[i+1] /= studentAnswer[i+1]) then     negative := negative + 1 ; else skip ; ;  )  ;     i := i + 1 ) ; 
     return (positive * 3) + (negative * -1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var answerKey : Sequence(int) ; answerKey := Sequence{1,2,3,4,1} ;
     var studentAnswer : Sequence(int) ; studentAnswer := Sequence{1,2,3,4,0} ;
    var N : int ; N := answerKey->size() ;
    var marking_Scheme : int ; marking_Scheme := markingScheme(N, answerKey, studentAnswer) ;
    OclFile["System.out"].println(marking_Scheme) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
    int tests=Integer.parseInt(in.readLine());
    while(tests-->0){
      long[] values=new long[2];
      StringTokenizer st=new StringTokenizer(in.readLine());
      for(int i=0 ; i<values.length ; i++){
        values[i]=Long.parseLong(st.nextToken());
      }
      long u=values[0],v=values[1];
      out.write(-(u*u)+" "+(v*v));
      out.newLine();
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var tests : int ; tests := (in.readLine())->toInteger() ;
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     var values : Sequence(long) ; values := Integer.subrange(1,2)->collect(0) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(in.readLine()) ;
        var i : int ; i := 0 ; while i < values->size() do ( (     values[i+1] := (st.next())->toLong() )  ;     i := i + 1 ) ; 
    var u : long ; u := values[0+1] ;
    var v : long ; v := values[1+1] ;
    skip ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
import java.util.*;
import java.lang.Math ;
import java.util.StringTokenizer ;
public class twentyseven {
  public static void main(String[] args){
    int a,b,t ;
    String str ;
    FastReader in=new FastReader();
    t=in.nextInt();
    while(t-->0){
      long u=in.nextInt();
      long v=in.nextInt();
      System.out.println(u*u*-1+" "+v*v);
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=nextInt();
      }
      return a ;
    }
    String nextLine(){
      String str="" ;
      try {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class twentyseven {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ;
    var b : int ;
    var t : int ;
     var str : String ;
    var in : FastReader ; in := FastReader.newFastReader() ;
    t := in.nextInt() ; 
        while (t > 0) do (        t := t - 1 ;     skip ; (     var u : long ; u := in.nextInt() ;
     var v : long ; v := in.nextInt() ;
     OclFile["System.out"].println(u * u * -1 + " " + v * v) ) ;  ) ;  
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return a );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
    int tests=Integer.parseInt(in.readLine());
    while(tests-->0){
      long[] values=new long[2];
      StringTokenizer st=new StringTokenizer(in.readLine());
      for(int i=0 ; i<values.length ; i++){
        values[i]=Long.parseLong(st.nextToken());
      }
      long u=values[0],v=values[1];
      out.write(-(u*u)+" "+(v*v));
      out.newLine();
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var tests : int ; tests := (in.readLine())->toInteger() ;
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     var values : Sequence(long) ; values := Integer.subrange(1,2)->collect(0) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(in.readLine()) ;
        var i : int ; i := 0 ; while i < values->size() do ( (     values[i+1] := (st.next())->toLong() )  ;     i := i + 1 ) ; 
    var u : long ; u := values[0+1] ;
    var v : long ; v := values[1+1] ;
    skip ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    FastReader a=new FastReader();
    int test=a.nextInt();
    while(test-->0){
      long num1=a.nextInt();
      long num2=a.nextInt();
      long ans1=num1*num1 ;
      long ans2=num2*num2 ;
      System.out.println(-ans1+" "+ans2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : FastReader ; a := FastReader.newFastReader() ;
     var test : int ; test := a.nextInt() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var num1 : long ; num1 := a.nextInt() ;
     var num2 : long ; num2 := a.nextInt() ;
    var ans1 : long ; ans1 := num1 * num1 ;
    var ans2 : long ; ans2 := num2 * num2 ;
    OclFile["System.out"].println(-ans1 + " " + ans2) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=64 ;
  static int getBitmask(char[] s){
    int temp=0 ;
    for(int j=0 ; j<s.length ; j++){
      switch(s[j]){
        case 's' : temp=temp |(1);
        break ;
        case 't' : temp=temp |(2);
        break ;
        case 'r' : temp=temp |(4);
        break ;
        case 'i' : temp=temp |(8);
        break ;
        case 'n' : temp=temp |(16);
        break ;
        case 'g' : temp=temp |(32);
        break ;
        default : break ;
      }
    }
    return temp ;
  }
  static int countPairs(String arr[],int n){
    int[] bitMask=new int[MAX];
    for(int i=0 ; i<n ; i++)bitMask[getBitmask(arr[i] .toCharArray())]++;
    int cnt=0 ;
    for(int i=0 ; i<MAX ; i++){
      for(int j=i ; j<MAX ; j++){
        if((i | j)==(MAX-1)){
          if(i==j)cnt+=((bitMask[i]*bitMask[i]-1)/2);
          else cnt+=(bitMask[i]*bitMask[j]);
        }
      }
    }
    return cnt ;
  }
  public static void main(String[] args){
    String arr[]={
      "strrr","strring","gstrin" };
      int n=arr.length ;
      System.out.println(countPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 64;
  static   operation getBitmask( s : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var temp : int ; temp := 0 ;
         var j : int ; j := 0 ; while j < s->size() do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (s[j+1]) ; 
       if _switchval = 's' then
     temp := MathLib.bitwiseOr(temp,(1)) ; 
    break 
   else skip ;
       if _switchval = 't' then
     temp := MathLib.bitwiseOr(temp,(2)) ; 
    break 
   else skip ;
       if _switchval = 'r' then
     temp := MathLib.bitwiseOr(temp,(4)) ; 
    break 
   else skip ;
       if _switchval = 'i' then
     temp := MathLib.bitwiseOr(temp,(8)) ; 
    break 
   else skip ;
       if _switchval = 'n' then
     temp := MathLib.bitwiseOr(temp,(16)) ; 
    break 
   else skip ;
       if _switchval = 'g' then
     temp := MathLib.bitwiseOr(temp,(32)) ; 
    break 
   else skip ;
       if true then
     break 
   else skip ;
 )
 )  ;     j := j + 1 ) ; 
     return temp );
  static   operation countPairs( arr : Sequence(String), n : int) : int
  pre: true
  post: true
  activity: (     var bitMask : Sequence(int) ; bitMask := Integer.subrange(1,MAX)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     bitMask[getBitmask(arr[i+1]->characters())+1] := bitMask[getBitmask(arr[i+1]->characters())+1] + 1 ;  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < MAX do ( (         var j : int ; j := i ; while j < MAX do ( (     if ((MathLib.bitwiseOr(i,j)) = (MAX - 1)) then (     if (i = j) then     cnt := cnt+(((bitMask[i+1] * bitMask[i+1] - 1) / 2)) ; else     cnt := cnt+((bitMask[i+1] * bitMask[j+1])) ; ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"strrr","strring","gstrin"} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countPairs(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Codeforce24 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int x=0 ; x<t ; x++){
      int n=sc.nextInt();
      long arr[]=new long[n];
      for(int i=0 ; i<n ; i++)arr[i]=sc.nextLong();
      boolean flag=false ;
      for(int i=0 ; i<n-1 ; i++){
        if(arr[i]<arr[i+1]){
          flag=true ;
          break ;
        }
      }
      if(flag==false){
        System.out.println("YES");
        continue ;
      }
      int i=0 ;
      while(i<n-1 && arr[i]<=arr[i+1])i++;
      if(i==n-1 || i==n-2)System.out.println("YES");
      else {
        i++;
        while(i<n-1 && arr[i]>=arr[i+1])i++;
        if(i==n-1)System.out.println("YES");
        else System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforce24 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var x : int ; x := 0 ; while x < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] < arr[i + 1+1]) then (     flag := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = false) then (     OclFile["System.out"].println("YES") ; 
     continue ) else skip ; 
    var i : int ; i := 0 ;
    while (i < n - 1 & arr[i+1] <= arr[i + 1+1]) do     i := i + 1 ; ; 
    if (i = n - 1 or i = n - 2) then     OclFile["System.out"].println("YES") else (     i := i + 1 ; 
     while (i < n - 1 & arr[i+1] >= arr[i + 1+1]) do     i := i + 1 ; ; 
     if (i = n - 1) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) ;  
 )  ;     x := x + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class UnnaturalConditions {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    in.next();
    in.next();
    String a="" ;
    String b="" ;
    for(int i=0 ; i<288 ; i++)a=a+"5" ;
    for(int i=0 ; i<287 ; i++)b=b+"4" ;
    b=b+"5" ;
    pw.println(a);
    pw.println(b);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class UnnaturalConditions {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    skip ; 
    skip ; 
    var a : String ; a := "" ;
    var b : String ; b := "" ;
        var i : int ; i := 0 ; while i < 288 do (     a := a + "5" ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 287 do (     b := b + "4" ;  ;     i := i + 1 ) ; 
    b := b + "5" ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    List<Integer>factors=primeFactor(N);
    int count=0 ;
    for(int i=0 ; i<factors.size(); i++){
      int pow=factors.get(i);
      int increase=1 ;
      while(pow-increase>=0){
        pow-=increase ;
        increase++;
        count++;
      }
    }
    System.out.println(count);
  }
  static List<Integer>primeFactor(long N){
    List<Integer>res=new ArrayList<>();
    for(long i=2 ; i*i<=N ; i++){
      int count=0 ;
      while(N % i==0){
        N/=i ;
        count++;
      }
      if(count!=0)res.add(count);
    }
    if(N!=1){
      res.add(1);
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    var factors : Sequence(int) ; factors := primeFactor(N) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < factors->size() do ( (     var pow : int ; pow := factors->at(i+1) ;
     var increase : int ; increase := 1 ;
     while (pow - increase >= 0) do (     pow := pow-(increase) ; 
     increase := increase + 1 ; 
     count := count + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation primeFactor( N : long) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Sequence{} ;
         var i : long ; i := 2 ; while i * i <= N do ( (     var count : int ; count := 0 ;
     while (N mod i = 0) do (     N := N/(i) ; 
     count := count + 1 ) ; 
     if (count /= 0) then     res := res->including(count) ; else skip )  ;     i := i + 1 ) ; 
     if (N /= 1) then (     res := res->including(1) ) else skip ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class InterceptedMessage {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int totalFirstFiles=scanner.nextInt();
    int totalSecondFiles=scanner.nextInt();
    int[] firstFiles=new int[totalFirstFiles];
    int[] secondFiles=new int[totalSecondFiles];
    for(int i=0 ; i<totalFirstFiles ; i++){
      firstFiles[i]=scanner.nextInt();
    }
    for(int i=0 ; i<totalSecondFiles ; i++){
      secondFiles[i]=scanner.nextInt();
    }
    System.out.println(interceptedMessage(firstFiles,secondFiles));
  }
  private static int interceptedMessage(int[] firstFiles,int[] secondFiles){
    int maxFiles=0 ;
    int firstPointer=0 ;
    int secondPointer=0 ;
    boolean hasFinished=false ;
    int tempFirstNumber=0 ;
    int tempSecondNumber=0 ;
    while(! hasFinished){
      if(firstPointer==0 && secondPointer==0){
        tempFirstNumber+=firstFiles[firstPointer];
        tempSecondNumber+=secondFiles[secondPointer];
      }
      if(tempFirstNumber==tempSecondNumber){
        maxFiles++;
        firstPointer++;
        secondPointer++;
        if(firstPointer>firstFiles.length-1 && secondPointer>secondFiles.length-1){
          break ;
        }
        tempFirstNumber=firstFiles[firstPointer];
        tempSecondNumber=secondFiles[secondPointer];
      }
      else if(tempFirstNumber<tempSecondNumber){
        firstPointer++;
        tempFirstNumber+=firstFiles[firstPointer];
      }
      else {
        secondPointer++;
        tempSecondNumber+=secondFiles[secondPointer];
      }
    }
    return maxFiles ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class InterceptedMessage {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var totalFirstFiles : int ; totalFirstFiles := scanner.getCurrent()->toInteger() ;
    var totalSecondFiles : int ; totalSecondFiles := scanner.getCurrent()->toInteger() ;
    var firstFiles : Sequence(int) ; firstFiles := Integer.subrange(1,totalFirstFiles)->collect(0) ;
    var secondFiles : Sequence(int) ; secondFiles := Integer.subrange(1,totalSecondFiles)->collect(0) ;
        var i : int ; i := 0 ; while i < totalFirstFiles do ( (     firstFiles[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < totalSecondFiles do ( (     secondFiles[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(interceptedMessage(firstFiles, secondFiles)) ; 
 );
  static   operation interceptedMessage( firstFiles : Sequence(int), secondFiles : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var maxFiles : int ; maxFiles := 0 ;
     var firstPointer : int ; firstPointer := 0 ;
    var secondPointer : int ; secondPointer := 0 ;
    var hasFinished : boolean ; hasFinished := false ;
    var tempFirstNumber : int ; tempFirstNumber := 0 ;
    var tempSecondNumber : int ; tempSecondNumber := 0 ;
    while (not(hasFinished)) do (     if (firstPointer = 0 & secondPointer = 0) then (     tempFirstNumber := tempFirstNumber+(firstFiles[firstPointer+1]) ; 
     tempSecondNumber := tempSecondNumber+(secondFiles[secondPointer+1]) ) else skip ; 
     if (tempFirstNumber = tempSecondNumber) then (     maxFiles := maxFiles + 1 ; 
     firstPointer := firstPointer + 1 ; 
    secondPointer := secondPointer + 1 ; 
    if (firstPointer > firstFiles->size() - 1 & secondPointer > secondFiles->size() - 1) then (     break ) else skip ; 
    tempFirstNumber := firstFiles[firstPointer+1] ; 
    tempSecondNumber := secondFiles[secondPointer+1] ; 
 ) else     if (tempFirstNumber < tempSecondNumber) then (     firstPointer := firstPointer + 1 ; 
     tempFirstNumber := tempFirstNumber+(firstFiles[firstPointer+1]) ) else (     secondPointer := secondPointer + 1 ; 
     tempSecondNumber := tempSecondNumber+(secondFiles[secondPointer+1]) ) ;  ) ; 
    return maxFiles 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String...args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Integer>list=new ArrayList<>();
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(sc.nextInt()==0){
        count=0 ;
        continue ;
      }
      count++;
      list.add(count);
    }
    if(list.isEmpty()){
      System.out.println(1);
    }
    else {
      System.out.println(Collections.max(list)+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (sc.getCurrent()->toInteger() = 0) then (     count := 0 ; 
     continue ) else skip ; 
     count := count + 1 ; 
     list := list->including(count) )  ;     i := i + 1 ) ; 
    if (list->isEmpty()) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println( list->max() + 1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader line=new BufferedReader(new InputStreamReader(System.in));
    int casos=Integer.parseInt(line.readLine());
    int n,x ;
    int[] l ;
    boolean min,ok ;
    while(casos-->0){
      n=Integer.parseInt(line.readLine());
      l=new int[n];
      StringTokenizer st=new StringTokenizer(line.readLine()," ");
      min=false ;
      ok=true ;
      for(int index=0 ; index<n ; index++){
        l[index]=Integer.parseInt(st.nextToken());
      }
      x=1 ;
      while(ok && x<n){
        if(l[x]<l[x-1]){
          min=true ;
        }
        else if(l[x]>l[x-1] && min){
          ok=false ;
        }
        x++;
      }
      if(ok){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var line : OclFile ; line := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var casos : int ; casos := (line.readLine())->toInteger() ;
    var n : int ;
    var x : int ;
    var l : Sequence(int) ;
    var min : boolean ;
    var ok : boolean ;
        while (casos > 0) do (        casos := casos - 1 ;     skip ; (     n := (line.readLine())->toInteger() ; 
     l := Integer.subrange(1,n)->collect(0) ; 
    var st : OclIterator ; st := OclIterator.newOclIterator_String_String(line.readLine(), " ") ;
    min := false ; 
    ok := true ; 
        var index : int ; index := 0 ; while index < n do ( (     l[index+1] := (st.next())->toInteger() )  ;     index := index + 1 ) ; 
    x := 1 ; 
    while (ok & x < n) do (     if (l[x+1] < l[x - 1+1]) then (     min := true ) else     if (l[x+1] > l[x - 1+1] & min) then (     ok := false ) else skip ; ;  
     x := x + 1 ) ; 
    if (ok) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      ArrayList<Integer>a=new ArrayList<>();
      int prev=-1 ;
      for(int i=0 ; i<n ; i++){
        int value=input.nextInt();
        if(prev==-1){
          a.add(value);
          prev=value ;
        }
        else if(prev!=value){
          prev=value ;
          a.add(value);
        }
      }
      if(n==1 || n==2){
        System.out.println("YES");
      }
      else {
        for(int i=0 ; i<a.size()-2 ; i++){
          if(a.get(i)>a.get(i+1)&& a.get(i+1)<a.get(i+2)){
            System.out.println("NO");
            continue work ;
          }
        }
        System.out.println("YES");
      }
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var tc : int ; tc := input.nextInt() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.nextInt() ;
     var a : Sequence(int) ; a := Sequence{} ;
    var prev : int ; prev := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var value : int ; value := input.nextInt() ;
     if (prev = -1) then (     a := a->including(value) ; 
     prev := value ) else     if (prev /= value) then (     prev := value ; 
     a := a->including(value) ) else skip ; )  ;     i := i + 1 ) ; 
    if (n = 1 or n = 2) then (     OclFile["System.out"].println("YES") ) else (         var i : int ; i := 0 ; while i < a->size() - 2 do ( (     if (a->at(i+1) > a->at(i + 1+1) & a->at(i + 1+1) < a->at(i + 2+1)) then (     OclFile["System.out"].println("NO") ; 
     continue ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("YES") ) ;  
 ) ;  ) ;  );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Solution {
  static PrintWriter pw ;
  static FastScanner s ;
  public static void main(String[] args)throws Exception {
    pw=new PrintWriter(System.out);
    s=new FastScanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int a[]=new int[n+1];
      for(int i=1 ; i<=n ; i++){
        a[i]=s.nextInt();
      }
      int preLen=1 ;
      while(preLen<n && a[preLen]<=a[preLen+1]){
        preLen++;
      }
      int sufLen=1 ;
      while(sufLen<n && a[n-sufLen]>=a[n-sufLen+1])sufLen++;
      if(sufLen+preLen>=n)pw.println("YES");
      else pw.println("NO");
    }
    pw.flush();
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public FastScanner(String s)throws Exception {
    br=new BufferedReader(new FileReader(new File(s)));
  }
  public String next()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(next());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute pw : OclFile;
  static   attribute s : FastScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     pw := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     s := FastScanner.newFastScanner(OclFile["System.in"]) ; 
    var t : int ; t := s.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := s.nextInt() )  ;     i := i + 1 ) ; 
    var preLen : int ; preLen := 1 ;
    while (preLen < n & a[preLen+1] <= a[preLen + 1+1]) do (     preLen := preLen + 1 ) ; 
    var sufLen : int ; sufLen := 1 ;
    while (sufLen < n & a[n - sufLen+1] >= a[n - sufLen + 1+1]) do     sufLen := sufLen + 1 ; ; 
    if (sufLen + preLen >= n) then     skip else     skip ; ;  
 ) ;  ) ;  
    skip ; 
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class FedorAndNewGame {
  static String addLeadingZeros(String a,int len){
    int nb=len-a.length();
    StringBuffer sb=new StringBuffer();
    while(nb-->0)sb.append("0");
    sb.append(a);
    return sb.toString();
  }
  static boolean canBeFriends(int a,int b,int k){
    int max=Math.max(a,b);
    int len=Integer.toBinaryString(max).length();
    char[] aBinRep=addLeadingZeros(Integer.toBinaryString(a),len).toCharArray();
    char[] bBinRep=addLeadingZeros(Integer.toBinaryString(b),len).toCharArray();
    int count=0 ;
    for(int i=0 ; i<len ; i++){
      count+=Math.abs(aBinRep[i]-bBinRep[i]);
    }
    return count<=k ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int k=in.nextInt();
    int[] players=new int[m+1];
    for(int i=0 ; i<m+1 ; i++){
      players[i]=in.nextInt();
    }
    int friends=0 ;
    for(int i=0 ; i<m ; i++){
      friends+=canBeFriends(players[m],players[i],k)? 1 : 0 ;
    }
    System.out.print(friends);
  }
}
------------------------------------------------------------
OCL File:
---------
 class FedorAndNewGame {
  static   operation addLeadingZeros( a : String, len : int) : String
  pre: true
  post: true
  activity: (     var nb : int ; nb := len - a->size() ;
     var sb : String ; sb := StringLib.newString() ;
        while (nb > 0) do (        nb := nb - 1 ;     skip ;     sb := sb + StringLib.newString("0") ; ;  ) ;  
    sb := sb + StringLib.newString(a) ; 
    return sb+"" 
 );
  static   operation canBeFriends( a : int, b : int, k : int) : boolean
  pre: true
  post: true
  activity: (     var max : int ; max := Set{a, b}->max() ;
     var len : int ; len := (MathLib.decimal2binary(max) + "")->size() ;
    var aBinRep : Sequence(String) ; aBinRep := addLeadingZeros((MathLib.decimal2binary(a) + ""), len)->characters() ;
    var bBinRep : Sequence(String) ; bBinRep := addLeadingZeros((MathLib.decimal2binary(b) + ""), len)->characters() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < len do ( (     count := count+(if aBinRep[i+1] - bBinRep[i+1] < 0 then -(aBinRep[i+1] - bBinRep[i+1]) else aBinRep[i+1] - bBinRep[i+1] endif) )  ;     i := i + 1 ) ; 
    return count <= k 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var players : Sequence(int) ; players := Integer.subrange(1,m + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < m + 1 do ( (     players[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var friends : int ; friends := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     friends := friends+(if canBeFriends(players[m+1], players[i+1], k) then 1 else 0 endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(friends) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf467b {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt(),k=sc.nextInt();
    int[] arr=new int[m+1];
    for(int i=0 ; i<m+1 ; i++){
      arr[i]=sc.nextInt();
    }
    int res=0,f=arr[m];
    for(int i=0 ; i<m ; i++){
      if(valid(arr[i],f,k)){
        res++;
      }
    }
    System.out.println(res);
  }
  public static boolean valid(int a,int b,int k){
    int count=0 ;
    while(a>0 && b>0){
      boolean f1=a % 2==0,f2=b % 2==0 ;
      if(f1!=f2)count++;
      a>>=1 ;
      b>>=1 ;
    }
    if(a>0)count+=Integer.bitCount(a);
    if(b>0)count+=Integer.bitCount(b);
    return count<=k ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf467b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,m + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < m + 1 do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    var f : int ; f := arr[m+1] ;
        var i : int ; i := 0 ; while i < m do ( (     if (valid(arr[i+1], f, k)) then (     res := res + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static   operation valid( a : int, b : int, k : int) : boolean
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (a > 0 & b > 0) do (     var f1 : boolean ; f1 := a mod 2 = 0 ;
    var f2 : boolean ; f2 := b mod 2 = 0 ;
     if (f1 /= f2) then     count := count + 1 ; else skip ; 
     a := a/(2->pow(1)) ; 
     b := b/(2->pow(1)) ) ; 
    if (a > 0) then     count := count+(bitCount(a)) ; else skip ; 
    if (b > 0) then     count := count+(bitCount(b)) ; else skip ; 
    return count <= k 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Codeforce {
  public static void main(String[] args){
    Scanner tec=new Scanner(System.in);
    int n=tec.nextInt();
    int m=tec.nextInt();
    int k=tec.nextInt();
    long xi[]=new long[m+1];
    for(int i=0 ; i<=m ; i++){
      xi[i]=tec.nextInt();
    }
    int count=0 ;
    long res=0 ;
    for(int i=0 ; i<m ; i++){
      res=xi[i] ^ xi[m];
      if(countOne(res)<=k){
        count++;
      }
    }
    System.out.println(count);
  }
  private static int countOne(long n){
    int c=0 ;
    while(n!=0){
      n=n & n-1 ;
      c++;
    }
    return c ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforce {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var tec : OclFile ; tec := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := tec.getCurrent()->toInteger() ;
    var m : int ; m := tec.getCurrent()->toInteger() ;
    var k : int ; k := tec.getCurrent()->toInteger() ;
    var xi : Sequence(long) ; xi := Integer.subrange(1,m + 1)->collect(0) ;
        var i : int ; i := 0 ; while i <= m do ( (     xi[i+1] := tec.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     res := xi[i+1] xor xi[m+1] ; 
     if (countOne(res) <= k) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation countOne( n : long) : int
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
     while (n /= 0) do (     n := MathLib.bitwiseAnd(n,n - 1) ; 
     c := c + 1 ) ; 
     return c );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    int m=Integer.parseInt(st.nextToken());
    int k=Integer.parseInt(st.nextToken());
    long arr[]=new long[m+1];
    for(int i=0 ; i<m+1 ; i++){
      arr[i]=Long.parseLong(br.readLine());
    }
    Long fedor=arr[m];
    int ans=0 ;
    for(int i=0 ; i<arr.length-1 ; i++){
      Long x=fedor ^ arr[i];
      int diff=Long.bitCount(x);
      if(diff<=k)ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var k : int ; k := (st.next())->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,m + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < m + 1 do ( (     arr[i+1] := (br.readLine())->toLong() )  ;     i := i + 1 ) ; 
    var fedor : long ; fedor := arr[m+1] ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < arr->size() - 1 do ( (     var x : long ; x := MathLib.bitwiseXor(fedor,arr[i+1]) ;
     var diff : int ; diff := bitCount(x) ;
     if (diff <= k) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Mridul8 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int k=sc.nextInt();
    int[] arr=new int[m+1];
    int i=-1 ;
    while(i!=m){
      i=i+1 ;
      arr[i]=sc.nextInt();
    }
    i=-1 ;
    int sum=0,sum1=0 ;
    while(i!=m-1){
      i=i+1 ;
      sum1=0 ;
      int u=0 ;
      u=arr[m] ^ arr[i];
      while(u!=0){
        if((u & 1)==1){
          sum1=sum1+1 ;
        }
        u=u>>1 ;
      }
      if(sum1<=k){
        sum=sum+1 ;
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mridul8 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,m + 1)->collect(0) ;
    var i : int ; i := -1 ;
    while (i /= m) do (     i := i + 1 ; 
     arr[i+1] := sc.getCurrent()->toInteger() ) ; 
    i := -1 ; 
    var sum : int ; sum := 0 ;
    var sum1 : int ; sum1 := 0 ;
    while (i /= m - 1) do (     i := i + 1 ; 
     sum1 := 0 ; 
    var u : int ; u := 0 ;
    u := arr[m+1] xor arr[i+1] ; 
    while (u /= 0) do (     if ((MathLib.bitwiseAnd(u,1)) = 1) then (     sum1 := sum1 + 1 ) else skip ; 
     u := (u/(2->pow(1)))->oclAsType(long) ) ; 
    if (sum1 <= k) then (     sum := sum + 1 ) else skip ; 
 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countSubString(char[] S,char L[],int n){
    int[] freq=new int[26];
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      freq[(int)(L[i]-'a')]=1 ;
    }
    int count=0 ;
    for(int x : S){
      if(freq[(int)(x-'a')]>0){
        ans+=(count*count+count)/2 ;
        count=0 ;
      }
      else count++;
    }
    ans+=(count*count+count)/2 ;
    return ans ;
  }
  public static void main(String[] args){
    String S="abcpxyz" ;
    char L[]={
      'a','p','q' };
      int n=L.length ;
      System.out.print(countSubString(S.toCharArray(),L,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSubString( S : Sequence(String), L : Sequence(String), n : int) : int
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
     var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     freq[(L[i+1] - ('a')->char2byte())->oclAsType(int)+1] := 1 )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    for (x : S) do ( (     if (freq[(x - ('a')->char2byte())->oclAsType(int)+1] > 0) then (     ans := ans+((count * count + count) / 2) ; 
     count := 0 ) else     count := count + 1 ; )  ) ; 
    ans := ans+((count * count + count) / 2) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := "abcpxyz" ;
     var L : Sequence(String) ; L := Sequence{'a','p','q'} ;
     var n : int ; n := L->size() ;
     OclFile["System.out"].print(countSubString(S->characters(), L, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int money=input.nextInt();
    input.nextLine();
    int i ;
    for(i=1 ; i<=4 ; i++){
      int a=input.nextInt();
      int b=input.nextInt();
      int c=input.nextInt();
      int d=input.nextInt();
      int firstGuard=a<b ? a : b ;
      int secondGuard=c<d ? c : d ;
      if(firstGuard+secondGuard<=money){
        System.out.println(i+" "+firstGuard+" "+(money-firstGuard));
        return ;
      }
      input.nextLine();
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var money : int ; money := input.getCurrent()->toInteger() ;
    skip ; 
    var i : int ;
        i := 1 ; while i <= 4 do ( (     var a : int ; a := input.getCurrent()->toInteger() ;
     var b : int ; b := input.getCurrent()->toInteger() ;
    var c : int ; c := input.getCurrent()->toInteger() ;
    var d : int ; d := input.getCurrent()->toInteger() ;
    var firstGuard : int ; firstGuard := if a < b then a else b endif ;
    var secondGuard : int ; secondGuard := if c < d then c else d endif ;
    if (firstGuard + secondGuard <= money) then (     OclFile["System.out"].println(i + " " + firstGuard + " " + (money - firstGuard)) ; 
     return ) else skip ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String str ;
      while((str=br.readLine())!=null){
        int N=Integer.parseInt(str);
        str=br.readLine();
        String[] Field=str.split(" ");
        int MaxDice=1 ;
        int tmp=1 ;
        for(int i=0 ; i<N ; i++){
          if(Field[i] .equals("1")){
            tmp++;
          }
          else {
            MaxDice=Math.max(MaxDice,tmp);
            tmp=1 ;
          }
        }
        MaxDice=Math.max(MaxDice,tmp);
        System.out.println(MaxDice);
      }
    }
    catch(Exception e){
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ;
         str := br.readLine() ;
    while ((str) /= null) do (    skip ; (     var N : int ; N := (str)->toInteger() ;
     str := br.readLine() ; 
    var Field : Sequence(String) ; Field := str->split(" ") ;
    var MaxDice : int ; MaxDice := 1 ;
    var tmp : int ; tmp := 1 ;
        var i : int ; i := 0 ; while i < N do ( (     if (Field[i+1] = "1") then (     tmp := tmp + 1 ) else (     MaxDice := Set{MaxDice, tmp}->max() ; 
     tmp := 1 ) )  ;     i := i + 1 ) ; 
    MaxDice := Set{MaxDice, tmp}->max() ; 
    OclFile["System.out"].println(MaxDice) ; 
 ) ;     str := br.readLine() ;
 ) )   catch (e : ProgramException) do (     OclFile["System.out"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    if(N==1){
      System.out.println(M);
      return ;
    }
    int maxDiv=1 ;
    for(int i=M/2 ; i>=2 ; i--){
      if(M % i==0){
        if(N<=M/i){
          maxDiv=i ;
          break ;
        }
      }
    }
    System.out.println(maxDiv);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    if (N = 1) then (     OclFile["System.out"].println(M) ; 
     return ) else skip ; 
    var maxDiv : int ; maxDiv := 1 ;
        var i : int ; i := M / 2 ; while i >= 2 do ( (     if (M mod i = 0) then (     if (N <= M / i) then (     maxDiv := i ; 
     break ) else skip ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(maxDiv) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class DimaandGuards {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x=0 ;
    for(int i=0 ; i<4 ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int d=sc.nextInt();
      if(x==0 &&(a+c<=n || a+d<=n || b+c<=n || b+d<=n)){
        System.out.print((i+1)+" ");
        x=-1 ;
        if(a+c<=n || a+d<=n)System.out.print(a+" "+(n-a));
        else System.out.println(b+" "+(n-b));
      }
    }
    if(x==0)System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class DimaandGuards {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    if (x = 0 & (a + c <= n or a + d <= n or b + c <= n or b + d <= n)) then (     OclFile["System.out"].print((i + 1) + " ") ; 
     x := -1 ; 
     if (a + c <= n or a + d <= n) then     OclFile["System.out"].print(a + " " + (n - a)) ; else     OclFile["System.out"].println(b + " " + (n - b)) ; ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (x = 0) then     OclFile["System.out"].println(-1) ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A_Dima_and_Guards {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    FastReader scan=new FastReader();
    int n=scan.nextInt();
    for(int i=0 ; i<4 ; i++){
      String[] arr=scan.nextLine().split(" ");
      int minOne=Math.min(Integer.parseInt(arr[0]),Integer.parseInt(arr[1]));
      int minTwo=Math.min(Integer.parseInt(arr[2]),Integer.parseInt(arr[3]));
      if(minOne+minTwo<=n){
        int rem=n-minOne-minTwo ;
        System.out.println(i+1+" "+minOne+" "+(minTwo+rem));
        return ;
      }
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Dima_and_Guards {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : FastReader ; scan := FastReader.newFastReader() ;
     var n : int ; n := scan.nextInt() ;
         var i : int ; i := 0 ; while i < 4 do ( (     var arr : Sequence(String) ; arr := scan.nextLine()->split(" ") ;
     var minOne : int ; minOne := Set{(arr[0+1])->toInteger(), (arr[1+1])->toInteger()}->min() ;
     var minTwo : int ; minTwo := Set{(arr[2+1])->toInteger(), (arr[3+1])->toInteger()}->min() ;
     if (minOne + minTwo <= n) then (     var rem : int ; rem := n - minOne - minTwo ;
     OclFile["System.out"].println(i + 1 + " " + minOne + " " + (minTwo + rem)) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(-1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static boolean isRevDiffDivisible(int x,int k){
    int n=x ;
    int m=0 ;
    int flag ;
    while(x>0){
      m=m*10+x % 10 ;
      x/=10 ;
    }
    return(Math.abs(n-m)% k==0);
  }
  static int countNumbers(int l,int r,int k){
    int count=0 ;
    for(int i=l ; i<=r ; i++)if(isRevDiffDivisible(i,k))++count ;
    return count ;
  }
  public static void main(String args[]){
    int l=35,r=45,k=5 ;
    System.out.println(countNumbers(l,r,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isRevDiffDivisible( x : int, k : int) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := x ;
     var m : int ; m := 0 ;
    var flag : int ;
    while (x > 0) do (     m := m * 10 + x mod 10 ; 
     x := x/(10) ) ; 
    return (if n - m < 0 then -(n - m) else n - m endif mod k = 0) 
 );
  static   operation countNumbers( l : int, r : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := l ; while i <= r do (     if (isRevDiffDivisible(i, k)) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 35 ;
    var r : int ; r := 45 ;
    var k : int ; k := 5 ;
     OclFile["System.out"].println(countNumbers(l, r, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p108 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p108().run());
  }
  public String run(){
    for(int n=1 ; ; n++){
      if((countDivisorsSquared(n)+1)/2>1000)return Integer.toString(n);
    }
  }
  private static int countDivisorsSquared(int n){
    int count=1 ;
    for(int i=2,end=Library.sqrt(n); i<=end ; i++){
      if(n % i==0){
        int j=0 ;
        do {
          n/=i ;
          j++;
        }
        while(n % i==0);
        count*=j*2+1 ;
        end=Library.sqrt(n);
      }
    }
    if(n!=1)count*=3 ;
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p108 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p108.newp108().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (         var n : int ; n := 1 ; while true do ( (     if ((countDivisorsSquared(n) + 1) / 2 > 1000) then     return ((n) + "") else skip )  ;     n := n + 1 ) );
  static   operation countDivisorsSquared( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 1 ;
         var i : int ; i := 2 ;
    var end : int ; end := Library.sqrt(n) ; while i <= end do ( (     if (n mod i = 0) then (     var j : int ; j := 0 ;
   while true do ((     n := n/(i) ; 
     j := j + 1 ) ;
    if (n mod i = 0) then skip else break) ; 
     count := count*(j * 2 + 1) ; 
     end := Library.sqrt(n) ) else skip )  ;     i := i + 1 ) ; 
     if (n /= 1) then     count := count*(3) ; else skip ; 
     return count );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(true){
      int h=stdIn.nextInt();
      int m=stdIn.nextInt();
      int s=stdIn.nextInt();
      if(h==-1 && m==-1 && s==-1){
        return ;
      }
      int min=120-((h*60)+m);
      int hour=0 ;
      if(s!=0){
        if(min==0){
          hour--;
        }
        min--;
        s=60-s ;
      }
      int[] a=new int[6];
      if(min>=120){
        a[0]=2 ;
        a[1]=0 ;
      }
      else if(min>=60){
        a[0]++;
        a[1]=min-60 ;
      }
      else {
        a[1]=min ;
      }
      a[2]=s ;
      a[0]+=hour ;
      System.out.printf("%02d:%02d:%02d\n",a[0],a[1],a[2]);
      a[3]=a[0]*3 ;
      a[4]=a[1]*3 ;
      a[5]=a[2]*3 ;
      if(a[5]>=60){
        a[4]++;
        a[5]-=60 ;
      }
      if(a[5]>=60){
        a[4]++;
        a[5]-=60 ;
      }
      if(a[4]>=60){
        a[3]++;
        a[4]-=60 ;
      }
      if(a[4]>=60){
        a[3]++;
        a[4]-=60 ;
      }
      System.out.printf("%02d:%02d:%02d\n",a[3],a[4],a[5]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var h : int ; h := stdIn.getCurrent()->toInteger() ;
     var m : int ; m := stdIn.getCurrent()->toInteger() ;
    var s : int ; s := stdIn.getCurrent()->toInteger() ;
    if (h = -1 & m = -1 & s = -1) then (     return ) else skip ; 
    var min : int ; min := 120 - ((h * 60) + m) ;
    var hour : int ; hour := 0 ;
    if (s /= 0) then (     if (min = 0) then (     hour := hour - 1 ) else skip ; 
     min := min - 1 ; 
     s := 60 - s ) else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,6)->collect(0) ;
    if (min >= 120) then (     a[0+1] := 2 ; 
     a[1+1] := 0 ) else     if (min >= 60) then (     a[0+1] := a[0+1] + 1 ; 
     a[1+1] := min - 60 ) else (     a[1+1] := min ) ;  ;  
    a[2+1] := s ; 
    a[0+1] := a[0+1]+(hour) ; 
    OclFile["System.out"].printf("%02d:%02d:%02d\n", a[0+1], a[1+1], a[2+1]) ; 
    a[3+1] := a[0+1] * 3 ; 
    a[4+1] := a[1+1] * 3 ; 
    a[5+1] := a[2+1] * 3 ; 
    if (a[5+1] >= 60) then (     a[4+1] := a[4+1] + 1 ; 
     a[5+1] := a[5+1]-(60) ) else skip ; 
    if (a[5+1] >= 60) then (     a[4+1] := a[4+1] + 1 ; 
     a[5+1] := a[5+1]-(60) ) else skip ; 
    if (a[4+1] >= 60) then (     a[3+1] := a[3+1] + 1 ; 
     a[4+1] := a[4+1]-(60) ) else skip ; 
    if (a[4+1] >= 60) then (     a[3+1] := a[3+1] + 1 ; 
     a[4+1] := a[4+1]-(60) ) else skip ; 
    OclFile["System.out"].printf("%02d:%02d:%02d\n", a[3+1], a[4+1], a[5+1]) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  void run(){
    sc=new Scanner(System.in);
    for(; ; ){
      int h=sc.nextInt();
      int m=sc.nextInt();
      int s=sc.nextInt();
      if(h==-1 && m==-1 && s==-1)break ;
      h=2-h ;
      m=0-m ;
      s=0-s ;
      if(s<0){
        s+=60 ;
        m--;
      }
      if(m<0){
        m+=60 ;
        h--;
      }
      println(String.format("%02d:%02d:%02d",h,m,s));
      h*=3 ;
      m*=3 ;
      s*=3 ;
      m+=s/60 ;
      s %=60 ;
      h+=m/60 ;
      m %=60 ;
      println(String.format("%02d:%02d:%02d",h,m,s));
    }
    sc.close();
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
       while true do ( (     var h : int ; h := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    if (h = -1 & m = -1 & s = -1) then     break else skip ; 
    h := 2 - h ; 
    m := 0 - m ; 
    s := 0 - s ; 
    if (s < 0) then (     s := s+(60) ; 
     m := m - 1 ) else skip ; 
    if (m < 0) then (     m := m+(60) ; 
     h := h - 1 ) else skip ; 
    execute println(StringLib.format("%02d:%02d:%02d",Sequence{h,m,s})) ; 
    h := h*(3) ; 
    m := m*(3) ; 
    s := s*(3) ; 
    m := m+(s / 60) ; 
    s := s mod 60 ; 
    h := h+(m / 60) ; 
    m := m mod 60 ; 
    execute println(StringLib.format("%02d:%02d:%02d",Sequence{h,m,s})) ; 
 )  ) ; 
     skip );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    String line=null ;
    while((line=reader.readLine())!=null){
      if(line.isEmpty()){
        continue ;
      }
      String[] values=line.split(" ");
      int h=Integer.parseInt(values[0]);
      int m=Integer.parseInt(values[1]);
      int s=Integer.parseInt(values[2]);
      if(h==-1 && m==-1 && s==-1){
        break ;
      }
      int time=(h*60+m)*60+s ;
      int rest=120*60-time ;
      out.println(format(rest));
      out.println(format(rest*3));
    }
  }
  private static String format(int time){
    int h=time/3600 ;
    int m=(time/60)% 60 ;
    int s=time % 60 ;
    return String.format("%02d:%02d:%02d",h,m,s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     var line : String ; line := null ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->isEmpty()) then (     continue ) else skip ; 
     var values : Sequence(String) ; values := line->split(" ") ;
    var h : int ; h := (values[0+1])->toInteger() ;
    var m : int ; m := (values[1+1])->toInteger() ;
    var s : int ; s := (values[2+1])->toInteger() ;
    if (h = -1 & m = -1 & s = -1) then (     break ) else skip ; 
    var time : int ; time := (h * 60 + m) * 60 + s ;
    var rest : int ; rest := 120 * 60 - time ;
    out.println(format(rest)) ; 
    out.println(format(rest * 3)) ; 
 ) ;     line := reader.readLine() ;
 ) );
  static   operation format( time : int) : String
  pre: true
  post: true
  activity: (     var h : int ; h := time / 3600 ;
     var m : int ; m := (time / 60) mod 60 ;
     var s : int ; s := time mod 60 ;
     return StringLib.format("%02d:%02d:%02d",Sequence{h,m,s}) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean solve(){
    int h=in.nextInt();
    int m=in.nextInt();
    int s=in.nextInt();
    if(h+m+s==-3)return false ;
    int x=h*3600+m*60+s ;
    x=7200-x ;
    out.println(toString(x));
    out.println(toString(x*3));
    return true ;
  }
  static String toString(int t){
    String res="" ;
    res+=String.valueOf(t/3600).length()==1 ? "0"+String.valueOf(t/3600): String.valueOf(t/3600);
    t %=3600 ;
    res+=":" ;
    res+=String.valueOf(t/60).length()==1 ? "0"+String.valueOf(t/60): String.valueOf(t/60);
    t %=60 ;
    res+=":" ;
    res+=String.valueOf(t).length()==1 ? "0"+String.valueOf(t): String.valueOf(t);
    return res ;
  }
  public static void main(String[] args){
    long start=System.currentTimeMillis();
    while(solve());
    out.flush();
    long end=System.currentTimeMillis();
    in.close();
    out.close();
  }
  static void trace(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   operation solve() : boolean
  pre: true
  post: true
  activity: (     var h : int ; h := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var s : int ; s := in.getCurrent()->toInteger() ;
    if (h + m + s = -3) then     return false else skip ; 
    var x : int ; x := h * 3600 + m * 60 + s ;
    x := 7200 - x ; 
    skip ; 
    skip ; 
    return true 
 );
  static   operation toString( t : int) : String
  pre: true
  post: true
  activity: (     var res : String ; res := "" ;
     res := res+(if ((t / 3600) + "")->size() = 1 then "0" + ((t / 3600) + "") else ((t / 3600) + "") endif) ; 
    t := t mod 3600 ; 
    res := res+(":") ; 
    res := res+(if ((t / 60) + "")->size() = 1 then "0" + ((t / 60) + "") else ((t / 60) + "") endif) ; 
    t := t mod 60 ; 
    res := res+(":") ; 
    res := res+(if ((t) + "")->size() = 1 then "0" + ((t) + "") else ((t) + "") endif) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : long ; start := OclDate.getSystemTime() ;
     while (solve()) do  ; 
    skip ; 
    var end : long ; end := OclDate.getSystemTime() ;
    skip ; 
    skip ; 
 );
  static   operation trace( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String line ;
      while((line=br.readLine())!=null){
        if(line.isEmpty())break ;
        String spl[]=line.split(" ");
        int a=Integer.parseInt(spl[0]);
        int b=Integer.parseInt(spl[1]);
        int c=Integer.parseInt(spl[2]);
        if(a==-1 && b==-1 && c==-1)break ;
        int all=120*60 ;
        int tukatta=a*60*60+b*60+c ;
        int nokori=all-tukatta ;
        for(int i=0 ; i<2 ; i++){
          if(i==1){
            nokori=nokori*3 ;
          }
          int nokoriFun=nokori/60 ;
          int nokoriByou=nokori % 60 ;
          String top=(nokoriFun/60==0)? "00" : "0"+(nokoriFun/60);
          nokoriFun=nokoriFun % 60 ;
          String mid=(nokoriFun==0)? "00" :(nokoriFun/10==0)? "0"+nokoriFun : nokoriFun+"" ;
          String las=(nokoriByou/10==0)? "0"+nokoriByou : nokoriByou+"" ;
          System.out.println(top+":"+mid+":"+las);
        }
      }
      br.close();
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->isEmpty()) then     break else skip ; 
     var spl : Sequence(String) ; spl := line->split(" ") ;
    var a : int ; a := (spl[0+1])->toInteger() ;
    var b : int ; b := (spl[1+1])->toInteger() ;
    var c : int ; c := (spl[2+1])->toInteger() ;
    if (a = -1 & b = -1 & c = -1) then     break else skip ; 
    var all : int ; all := 120 * 60 ;
    var tukatta : int ; tukatta := a * 60 * 60 + b * 60 + c ;
    var nokori : int ; nokori := all - tukatta ;
        var i : int ; i := 0 ; while i < 2 do ( (     if (i = 1) then (     nokori := nokori * 3 ) else skip ; 
     var nokoriFun : int ; nokoriFun := nokori / 60 ;
    var nokoriByou : int ; nokoriByou := nokori mod 60 ;
    var top : String ; top := if (nokoriFun / 60 = 0) then "00" else "0" + (nokoriFun / 60) endif ;
    nokoriFun := nokoriFun mod 60 ; 
    var mid : String ; mid := if (nokoriFun = 0) then "00" else if (nokoriFun / 10 = 0) then "0" + nokoriFun else nokoriFun + "" endif endif ;
    var las : String ; las := if (nokoriByou / 10 = 0) then "0" + nokoriByou else nokoriByou + "" endif ;
    OclFile["System.out"].println(top + ":" + mid + ":" + las) ; 
 )  ;     i := i + 1 ) ; 
 ) ;     line := br.readLine() ;
 ) ;  
     skip )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math ;
import java.math.BigInteger ;
public class Main {
  static int check(int x){
    String xx=String.valueOf(x);
    char k[]=xx.toCharArray();
    int flag=1 ;
    for(int i=1 ; i<xx.length(); i++){
      if(k[i]<k[i-1] || k[i]-k[i-1]!=1){
        flag=0 ;
        break ;
      }
    }
    if(flag==0){
      return 0 ;
    }
    else {
      return 1 ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int m[]=new int[n];
      for(int i=0 ; i<n ; i++){
        m[i]=sc.nextInt();
      }
      int max=-1 ;
      for(int i=0 ; i<n-1 ; i++){
        for(int j=i+1 ; j<n ; j++){
          int t=m[i]*m[j];
          if(check(t)==1 && t>max){
            max=t ;
          }
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation check( x : int) : int
  pre: true
  post: true
  activity: (     var xx : String ; xx := ((x) + "") ;
     var k : Sequence(String) ; k := xx->characters() ;
    var flag : int ; flag := 1 ;
        var i : int ; i := 1 ; while i < xx->size() do ( (     if (k[i+1] < k[i - 1+1] or k[i+1] - k[i - 1+1] /= 1) then (     flag := 0 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 0) then (     return 0 ) else (     return 1 ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : Sequence(int) ; m := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     m[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var max : int ; max := -1 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var t : int ; t := m[i+1] * m[j+1] ;
     if (check(t) = 1 & t > max) then (     max := t ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    if(m==1){
      System.out.println(n);
      return ;
    }
    int[][] all=new int[n][m];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        all[i][j]=sc.nextInt();
      }
    }
    int[] idxes=new int[n];
    int min=Integer.MAX_VALUE ;
    HashSet<Integer>set=new HashSet<>();
    for(int i=0 ; i<m-1 ; i++){
      int[] counts=new int[m+1];
      int max=0 ;
      int maxSport=0 ;
      for(int j=0 ; j<n ; j++){
        int x=all[j][idxes[j] ];
        counts[x]++;
        if(max<counts[x]){
          max=counts[x];
          maxSport=x ;
        }
      }
      if(min>max){
        min=max ;
      }
      set.add(maxSport);
      for(int j=0 ; j<n ; j++){
        while(set.contains(all[j][idxes[j] ])){
          idxes[j]++;
        }
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    if (m = 1) then (     OclFile["System.out"].println(n) ; 
     return ) else skip ; 
    var all : Sequence(Sequence(int)) ; all := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     all[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var idxes : Sequence(int) ; idxes := Integer.subrange(1,n)->collect(0) ;
    var min : int ; min := 2147483647 ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < m - 1 do ( (     var counts : Sequence(int) ; counts := Integer.subrange(1,m + 1)->collect(0) ;
     var max : int ; max := 0 ;
    var maxSport : int ; maxSport := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     var x : int ; x := all[j+1][idxes[j+1]+1] ;
     counts[x+1] := counts[x+1] + 1 ; 
     if (max < counts[x+1]) then (     max := counts[x+1] ; 
     maxSport := x ) else skip )  ;     j := j + 1 ) ; 
    if (min > max) then (     min := max ) else skip ; 
    set := set->including(maxSport) ; 
        var j : int ; j := 0 ; while j < n do ( (     while (set->includes(all[j+1][idxes[j+1]+1])) do (     idxes[j+1] := idxes[j+1] + 1 ) )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  static LinkedList<Integer>fact(int n){
    int tn=n ;
    LinkedList<Integer>ans=new LinkedList<Integer>();
    if(ip(n)){
      ans.add(n);
      return ans ;
    }
    for(int i=2 ; i<=tn ; i++){
      if(n==1)break ;
      if(ip(i)){
        while(n % i==0){
          ans.add(i);
          n/=i ;
        }
      }
    }
    return ans ;
  }
  static boolean ip(long x){
    if(x==1)return false ;
    for(long i=2 ; i*i<=x ; i++)if(x % i==0)return false ;
    return true ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt(),M=sc.nextInt();
    LinkedList<Integer>yaku=new LinkedList<Integer>();
    for(int i=1 ; i*i<=M ; i++){
      if(M % i==0){
        yaku.add(i);
        yaku.add(M/i);
      }
    }
    int ans=0 ;
    for(int y : yaku){
      if(M/y>=N)ans=Math.max(ans,y);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation fact( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var tn : int ; tn := n ;
     var ans : Sequence(int) ; ans := Sequence{} ;
    if (ip(n)) then (     ans := ans->including(n) ; 
     return ans ) else skip ; 
        var i : int ; i := 2 ; while i <= tn do ( (     if (n = 1) then     break else skip ; 
     if (ip(i)) then (     while (n mod i = 0) do (     ans := ans->including(i) ; 
     n := n/(i) ) ) else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation ip( x : long) : boolean
  pre: true
  post: true
  activity: (     if (x = 1) then     return false else skip ; 
         var i : long ; i := 2 ; while i * i <= x do (     if (x mod i = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var yaku : Sequence(int) ; yaku := Sequence{} ;
        var i : int ; i := 1 ; while i * i <= M do ( (     if (M mod i = 0) then (     yaku := yaku->including(i) ; 
     yaku := yaku->including(M / i) ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (y : yaku) do ( (     if (M / y >= N) then     ans := Set{ans, y}->max() ; else skip )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BSportsFestival solver=new BSportsFestival();
    solver.solve(1,in,out);
    out.close();
  }
  static class BSportsFestival {
    boolean[] use ;
    int[][] fav ;
    int[] cnt ;
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int m=in.nextInt();
      use=new boolean[m];
      fav=new int[n][m];
      cnt=new int[m];
      Arrays.fill(use,true);
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<m ; j++){
          fav[i][j]=in.nextInt()-1 ;
        }
      }
      out.println(f());
    }
    int f(){
      int dec=0 ;
      Arrays.fill(cnt,0);
      for(int i=0 ; i<fav.length ; i++){
        for(int j=0 ; j<fav[i] .length ; j++){
          if(use[fav[i][j] ]){
            cnt[fav[i][j] ]++;
            break ;
          }
          if(j==fav[i] .length-1)return fav.length+100 ;
        }
      }
      for(int i=0 ; i<cnt.length ; i++){
        if(cnt[dec]<cnt[i])dec=i ;
      }
      use[dec]=false ;
      return Math.min(cnt[dec],f());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BSportsFestival ; solver := BSportsFestival.newBSportsFestival() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BSportsFestival {
   attribute use : Sequence(boolean);
   attribute fav : Sequence(Sequence(int));
   attribute cnt : Sequence(int);
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    use := Integer.subrange(1,m)->collect(false) ; 
    fav := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ; 
    cnt := Integer.subrange(1,m)->collect(0) ; 
    use := use->collect(true) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     fav[i+1][j+1] := in.getCurrent()->toInteger() - 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation f() : int
  pre: true
  post: true
  activity: (     var dec : int ; dec := 0 ;
     cnt := cnt->collect(0) ; 
        var i : int ; i := 0 ; while i < fav->size() do ( (         var j : int ; j := 0 ; while j < fav[i+1]->size() do ( (     if (use[fav[i+1][j+1]+1]) then (     cnt[fav[i+1][j+1]+1] := cnt[fav[i+1][j+1]+1] + 1 ; 
     break ) else skip ; 
     if (j = fav[i+1]->size() - 1) then     return fav->size() + 100 else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < cnt->size() do ( (     if (cnt[dec+1] < cnt[i+1]) then     dec := i ; else skip )  ;     i := i + 1 ) ; 
    use[dec+1] := false ; 
    return Set{cnt[dec+1], f()}->min() 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Comparator.naturalOrder ;
import static java.util.stream.Collectors.toList ;
import java.util.*;
import java.util.Map.Entry ;
import java.util.stream.IntStream ;
public class Main {
  static final Scanner s=new Scanner(System.in);
  static IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static IntStream INS(int n){
    return REPS(n).map(i->getInt());
  }
  static int getInt(){
    return Integer.parseInt(s.next());
  }
  public static void main(String[] $){
    int n=getInt(),m=getInt();
    List<List<Integer>>a=REPS(n).mapToObj(i->INS(m).boxed().collect(toList())).collect(toList());
    HashMap<Integer,Integer>count=new HashMap<>();
    int r=n ;
    for(int i=0 ; i<m-1 ; ++i){
      count.clear();
      for(int j=0 ; j<n ; ++j)count.merge(a.get(j).get(0),1,Integer :: sum);
      r=Math.min(r,count.values().stream().max(naturalOrder()).get());
      Integer remove=count.entrySet().stream().max(Entry.comparingByValue()).get().getKey();
      a.stream().forEach(o->o.remove(remove));
    }
    System.out.println(r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static   operation INS( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return REPS(n)->collect( _x1 | (lambda i : OclAny in getInt())->apply(_x1) ) );
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := getInt() ;
    var m : int ; m := getInt() ;
     var a : Sequence(Sequence(int)) ; a := REPS(n).mapToObj(lambda i : OclAny in INS(m).collect(toList())).collect(toList()) ;
    var count : Map(int,int) ; count := Map{} ;
    var r : int ; r := n ;
        var i : int ; i := 0 ; while i < m - 1 do ( (     count := count->intersection(Map{}) ; 
         var j : int ; j := 0 ; while j < n do (     count := count.merge(a->at(j+1)->at(0+1), 1, lambda _pars : OclAny in Integer.newInteger().sum(_pars)) ;  ;     j := j + 1 ) ; 
    r := Set{r, count->values()->max().get()}->min() ; 
    var remove : int ; remove := count->asSet()->max().get().getKey() ;
    for o : a do
    (    o := o->excludingAt(remove+1)) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(r) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.Map.Entry ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  static final Scanner s=new Scanner(System.in);
  static IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static IntStream REPS(int l,int r){
    return IntStream.rangeClosed(l,r);
  }
  static IntStream INS(int n){
    return REPS(n).map(i->getInt());
  }
  static int getInt(){
    return Integer.parseInt(s.next());
  }
  public static void main(String[] $){
    int n=getInt(),m=getInt();
    ArrayList<ArrayList<Integer>>a=new ArrayList<>();
    for(int i=0 ; i<n ; ++i){
      ArrayList<Integer>d=new ArrayList<>();
      a.add(d);
      INS(m).forEach(d :: add);
    }
    HashMap<Integer,Integer>count=new HashMap<>();
    int r=n ;
    for(int i=0 ; i<m-1 ; ++i){
      count.clear();
      for(int j=0 ; j<n ; ++j){
        count.merge(a.get(j).get(0),1,Integer :: sum);
      }
      r=Math.min(r,count.values().stream().max(Comparator.naturalOrder()).get());
      int hoge=count.entrySet().stream().max(Entry.comparingByValue()).get().getKey();
      a.stream().forEach(o->o.removeIf(oo->oo==hoge));
    }
    System.out.println(r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static   operation REPS( l : int, r : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(l, r) );
  static   operation INS( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return REPS(n)->collect( _x1 | (lambda i : OclAny in getInt())->apply(_x1) ) );
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := getInt() ;
    var m : int ; m := getInt() ;
     var a : Sequence(Sequence(int)) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var d : Sequence(int) ; d := Sequence{} ;
     a := a->including(d) ; 
     for _forEach : INS(m) do
    (    skip ;) )  ;     i := i + 1 ) ; 
    var count : Map(int,int) ; count := Map{} ;
    var r : int ; r := n ;
        var i : int ; i := 0 ; while i < m - 1 do ( (     count := count->intersection(Map{}) ; 
         var j : int ; j := 0 ; while j < n do ( (     count := count.merge(a->at(j+1)->at(0+1), 1, lambda _pars : OclAny in Integer.newInteger().sum(_pars)) )  ;     j := j + 1 ) ; 
    r := Set{r, count->values()->max().get()}->min() ; 
    var hoge : int ; hoge := count->asSet()->max().get().getKey() ;
    for o : a do
    (    o.removeIf(lambda oo : OclAny in oo = hoge)) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(r) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    ArrayList<ArrayDeque<Integer>>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      ArrayDeque<Integer>deq=new ArrayDeque<>();
      for(int j=0 ; j<m ; j++){
        deq.add(sc.nextInt());
      }
      list.add(deq);
    }
    boolean[] canceled=new boolean[m+1];
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<m ; i++){
      int[] counts=new int[m+1];
      for(ArrayDeque<Integer>deq : list){
        while(canceled[deq.peek()]){
          deq.poll();
        }
        counts[deq.peek()]++;
      }
      int max=0 ;
      int maxIdx=0 ;
      for(int j=1 ; j<=m ; j++){
        if(max<counts[j]){
          max=counts[j];
          maxIdx=j ;
        }
      }
      min=Math.min(min,max);
      canceled[maxIdx]=true ;
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var list : Sequence(Sequence(int)) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var deq : Sequence(int) ; deq := ArrayDeque<OclAny>.newArrayDeque() ;
         var j : int ; j := 0 ; while j < m do ( (     deq := deq->including(sc.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
     list := list->including(deq) )  ;     i := i + 1 ) ; 
    var canceled : Sequence(boolean) ; canceled := Integer.subrange(1,m + 1)->collect(false) ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < m do ( (     var counts : Sequence(int) ; counts := Integer.subrange(1,m + 1)->collect(0) ;
     for (deq : list) do ( (     while (canceled[deq->min()+1]) do (     deq := deq->sort()->tail() ) ; 
     counts[deq->min()+1] := counts[deq->min()+1] + 1 )  ) ; 
    var max : int ; max := 0 ;
    var maxIdx : int ; maxIdx := 0 ;
        var j : int ; j := 1 ; while j <= m do ( (     if (max < counts[j+1]) then (     max := counts[j+1] ; 
     maxIdx := j ) else skip )  ;     j := j + 1 ) ; 
    min := Set{min, max}->min() ; 
    canceled[maxIdx+1] := true ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class PlayingWithPaper {
  public static void main(String[] args){
    new PlayingWithPaper().runApp();
  }
  static void runApp(){
    Scanner in=new Scanner(System.in);
    long a=in.nextLong();
    long b=in.nextLong();
    long i=0 ;
    while(a>=1 && b>=1){
      i=i+a/b ;
      long c=a ;
      long d=b ;
      a=d ;
      b=c % d ;
      a=d ;
    }
    System.out.print(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class PlayingWithPaper {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     PlayingWithPaper.newPlayingWithPaper().runApp() );
  static   operation runApp() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := in.getCurrent()->toLong() ;
    var b : long ; b := in.getCurrent()->toLong() ;
    var i : long ; i := 0 ;
    while (a >= 1 & b >= 1) do (     i := i + a / b ; 
     var c : long ; c := a ;
    var d : long ; d := b ;
    a := d ; 
    b := c mod d ; 
    a := d ; 
 ) ; 
    OclFile["System.out"].print(i) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test2 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long a=in.nextLong();
    long b=in.nextLong();
    long result=0 ;
    while(a!=0 && b!=0){
      if(a>b){
        result+=a/b ;
        a=a % b ;
      }
      else {
        result+=b/a ;
        b=b % a ;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := in.getCurrent()->toLong() ;
    var b : long ; b := in.getCurrent()->toLong() ;
    var result : long ; result := 0 ;
    while (a /= 0 & b /= 0) do (     if (a > b) then (     result := result+(a / b) ; 
     a := a mod b ) else (     result := result+(b / a) ; 
     b := b mod a ) ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PlayingWithPaper {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    long a=s.nextLong();
    long b=s.nextLong();
    long strips=0 ;
    while(a!=b){
      if(a>b && b!=0){
        strips+=a/b ;
        a %=b ;
      }
      else if(b>a && a!=0){
        strips+=b/a ;
        b %=a ;
      }
      else break ;
    }
    System.out.println(strips);
  }
}
------------------------------------------------------------
OCL File:
---------
 class PlayingWithPaper {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := s.getCurrent()->toLong() ;
    var b : long ; b := s.getCurrent()->toLong() ;
    var strips : long ; strips := 0 ;
    while (a /= b) do (     if (a > b & b /= 0) then (     strips := strips+(a / b) ; 
     a := a mod b ) else     if (b > a & a /= 0) then (     strips := strips+(b / a) ; 
     b := b mod a ) else     break ;  ) ; 
    OclFile["System.out"].println(strips) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.Arrays ;
import java.util.Scanner ;
public class practice2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      long[] x=new long[n];
      long[] y=new long[n];
      int t1=0,t2=0 ;
      for(int i=0 ; i<2*n ; i++){
        long x1=sc.nextInt(),y1=sc.nextInt();
        if(x1==0)y[t2++]=y1*y1 ;
        else x[t1++]=x1*x1 ;
      }
      Arrays.sort(x);
      Arrays.sort(y);
      double sum=0 ;
      for(int i=n-1 ; i>-1 ; i--){
        sum+=Math.sqrt(x[i]+y[i]);
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : Sequence(long) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(long) ; y := Integer.subrange(1,n)->collect(0) ;
    var t1 : int ; t1 := 0 ;
    var t2 : int ; t2 := 0 ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     var x1 : long ; x1 := sc.getCurrent()->toInteger() ;
    var y1 : long ; y1 := sc.getCurrent()->toInteger() ;
     if (x1 = 0) then      y[t2+1] := y1 * y1  ; t2 := t2 + 1 ; else      x[t1+1] := x1 * x1  ; t1 := t1 + 1 ; )  ;     i := i + 1 ) ; 
    x := x->sort() ; 
    y := y->sort() ; 
    var sum : double ; sum := 0 ;
        var i : int ; i := n - 1 ; while i > -1 do ( (     sum := sum+((x[i+1] + y[i+1])->sqrt()) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class water {
  static long compute(long a,long b,long c){
    if(b==0)return c ;
    else {
      c+=a/b ;
      return compute(b,a % b,c);
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a,b,c=0 ;
    a=sc.nextLong();
    b=sc.nextLong();
    System.out.println(compute(a,b,c));
  }
}
------------------------------------------------------------
OCL File:
---------
 class water {
  static   operation compute( a : long, b : long, c : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return c else (     c := c+(a / b) ; 
     return compute(b, a mod b, c) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ;
    var b : long ;
    var c : long ; c := 0 ;
    a := sc.getCurrent()->toLong() ; 
    b := sc.getCurrent()->toLong() ; 
    OclFile["System.out"].println(compute(a, b, c)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PwP {
  public static void main(String[] args){
    new PwP().runApp();
  }
  void runApp(){
    Scanner scan=new Scanner(System.in);
    long a=scan.nextLong();
    long b=scan.nextLong();
    long r=0 ;
    long temp ;
    long aa=a ;
    long bb=b ;
    long rr=0 ;
    long d=0 ;
    long count=0 ;
    if(a % b==0){
      System.out.println(a/b);
    }
    else {
      do {
        r=a % b ;
        a=r ;
        if(b>a){
          temp=a ;
          a=b ;
          b=temp ;
        }
      }
      while(a % b!=0);
      do {
        d=aa/bb ;
        rr=aa % bb ;
        count=count+d ;
        aa=rr ;
        temp=aa ;
        aa=bb ;
        bb=temp ;
      }
      while(aa!=a && bb!=b);
      count=count+(a/b);
      System.out.print(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PwP {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     PwP.newPwP().runApp() );
   operation runApp() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := scan.getCurrent()->toLong() ;
    var b : long ; b := scan.getCurrent()->toLong() ;
    var r : long ; r := 0 ;
    var temp : long ;
    var aa : long ; aa := a ;
    var bb : long ; bb := b ;
    var rr : long ; rr := 0 ;
    var d : long ; d := 0 ;
    var count : long ; count := 0 ;
    if (a mod b = 0) then (     OclFile["System.out"].println(a / b) ) else (   while true do ((     r := a mod b ; 
     a := r ; 
     if (b > a) then (     temp := a ; 
     a := b ; 
     b := temp ) else skip ) ;
    if (a mod b /= 0) then skip else break) ; 
   while true do ((     d := aa / bb ; 
     rr := aa mod bb ; 
    count := count + d ; 
    aa := rr ; 
    temp := aa ; 
    aa := bb ; 
    bb := temp ; 
 ) ;
    if (aa /= a & bb /= b) then skip else break) ; 
     count := count + (a / b) ; 
     OclFile["System.out"].print(count) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.BitSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    BitSet bs=new BitSet(n);
    for(int i=0 ; i<m ; i++){
      bs.set(in.nextInt()-1);
    }
    int bf=-1 ;
    int[] dist=new int[n];
    for(int i=0 ; i<n ; i++){
      if(bs.get(i))bf=i ;
      if(bf>=0){
        dist[i]=Math.abs(i-bf);
      }
      else {
        dist[i]=Integer.MAX_VALUE ;
      }
    }
    bf=-1 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(bs.get(i))bf=i ;
      if(bf>=0){
        dist[i]=Math.min(dist[i],Math.abs(i-bf));
      }
    }
    int max=0 ;
    for(int i=0 ; i<n ; i++){
    }
    for(int i=0 ; i<n ; i++)max=Math.max(max,dist[i]);
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var bs : Sequence(boolean) ; bs := MathLib.toBitSequence(n) ;
        var i : int ; i := 0 ; while i < m do ( (     bs := bs.setAt(in.getCurrent()->toInteger() - 1+1, true) )  ;     i := i + 1 ) ; 
    var bf : int ; bf := -1 ;
    var dist : Sequence(int) ; dist := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     if (bs->at(i+1)) then     bf := i ; else skip ; 
     if (bf >= 0) then (     dist[i+1] := if i - bf < 0 then -(i - bf) else i - bf endif ) else (     dist[i+1] := 2147483647 ) )  ;     i := i + 1 ) ; 
    bf := -1 ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (bs->at(i+1)) then     bf := i ; else skip ; 
     if (bf >= 0) then (     dist[i+1] := Set{dist[i+1], if i - bf < 0 then -(i - bf) else i - bf endif}->min() ) else skip )  ;     i := i - 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( skip  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     max := Set{max, dist[i+1]}->max() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.stream.Stream ;
public class Main {
  private static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  private static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException {
    func();
    pw.flush();
    return ;
  }
  static void func()throws IOException {
    int[] input=arrayOfInt();
    int n=input[0];
    int m=input[1];
    int MAX=Math.floorDiv(m,n);
    long ans=1 ;
    for(int i=1 ; i*i<=m ; i++){
      if(m % i!=0)continue ;
      if(i<=MAX)ans=Math.max(ans,i);
      if(m/i<=MAX)ans=Math.max(ans,m/i);
    }
    println(ans);
  }
  static String next()throws IOException {
    return br.readLine();
  }
  static int nextInt()throws IOException {
    return getInt(br.readLine());
  }
  static long nextLong()throws IOException {
    return getLong(br.readLine());
  }
  static String[] arrayOfString()throws IOException {
    return br.readLine().split(" ");
  }
  static int[] arrayOfInt()throws IOException {
    return toIntArray(arrayOfString());
  }
  static long getLong(String val){
    return Long.parseLong(val);
  }
  static int getInt(String val){
    return Integer.parseInt(val);
  }
  static int[] toIntArray(String[] array){
    return Stream.of(array.clone()).mapToInt(Integer :: parseInt).toArray();
  }
  static String joinToString(String[] array){
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<array.length ; i++)sb.append(array[i]);
    return sb.toString();
  }
  static void println(Object val){
    pw.println(val);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute func() ; 
     skip ; 
     return );
  static   operation func() : void
  pre: true
  post: true
  activity: (     var input : Sequence(int) ; input := arrayOfInt() ;
     var n : int ; n := input[0+1] ;
    var m : int ; m := input[1+1] ;
    var MAX : int ; MAX := floorDiv(m, n) ;
    var ans : long ; ans := 1 ;
        var i : int ; i := 1 ; while i * i <= m do ( (     if (m mod i /= 0) then     continue else skip ; 
     if (i <= MAX) then     ans := Set{ans, i}->max() ; else skip ; 
     if (m / i <= MAX) then     ans := Set{ans, m / i}->max() ; else skip )  ;     i := i + 1 ) ; 
    execute println(ans) ; 
 );
  static   operation next() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return getInt(br.readLine()) );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return getLong(br.readLine()) );
  static   operation arrayOfString() : Sequence(String)
  pre: true
  post: true
  activity: (     return br.readLine()->split(" ") );
  static   operation arrayOfInt() : Sequence(int)
  pre: true
  post: true
  activity: (     return toIntArray(arrayOfString()) );
  static   operation getLong( val : String) : long
  pre: true
  post: true
  activity: (     return (val)->toLong() );
  static   operation getInt( val : String) : int
  pre: true
  post: true
  activity: (     return (val)->toInteger() );
  static   operation toIntArray( array : Sequence(String)) : Sequence(int)
  pre: true
  post: true
  activity: (     return Sequence{array->copy()}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() );
  static   operation joinToString( array : Sequence(String)) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < array->size() do (     sb := sb + StringLib.newString(array[i+1]) ;  ;     i := i + 1 ) ; 
     return sb+"" );
  static   operation println( val : OclAny) : void
  pre: true
  post: true
  activity: (     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isSellingPossible(int n,int a[]){
    int i,c25=0,c50=0 ;
    for(i=0 ; i<n ; i++){
      if(a[i]==25)c25++;
      else if(a[i]==50){
        c50++;
        if(c25==0)break ;
        c25--;
      }
      else {
        if(c50>0 && c25>0){
          c50--;
          c25--;
        }
        else if(c25>=3)c25-=3 ;
        else break ;
      }
    }
    if(i==n)return true ;
    else return false ;
  }
  public static void main(String[] args){
    int a[]={
      25,25,50,100 };
      int n=a.length ;
      if(isSellingPossible(n,a)){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isSellingPossible( n : int, a : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var i : int ;
    var c25 : int ; c25 := 0 ;
    var c50 : int ; c50 := 0 ;
         i := 0 ; while i < n do ( (     if (a[i+1] = 25) then     c25 := c25 + 1 ; else     if (a[i+1] = 50) then (     c50 := c50 + 1 ; 
     if (c25 = 0) then     break else skip ; 
     c25 := c25 - 1 ) else (     if (c50 > 0 & c25 > 0) then (     c50 := c50 - 1 ; 
     c25 := c25 - 1 ) else     if (c25 >= 3) then     c25 := c25-(3) else     break ;  ) ;  )  ;     i := i + 1 ) ; 
     if (i = n) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{25,25,50,100} ;
     var n : int ; n := a->size() ;
     if (isSellingPossible(n, a)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean areSetBitsIncreasing(int n){
    int prev_count=Integer.MAX_VALUE ;
    while(n>0){
      while(n>0 && n % 2==0)n=n/2 ;
      int curr_count=1 ;
      while(n>0 && n % 2==1){
        n=n/2 ;
        curr_count++;
      }
      if(curr_count>=prev_count)return false ;
      prev_count=curr_count ;
    }
    return true ;
  }
  static public void main(String[] args){
    int n=10 ;
    if(areSetBitsIncreasing(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation areSetBitsIncreasing( n : int) : boolean
  pre: true
  post: true
  activity: (     var prev_count : int ; prev_count := 2147483647 ;
     while (n > 0) do (     while (n > 0 & n mod 2 = 0) do     n := n / 2 ; ; 
     var curr_count : int ; curr_count := 1 ;
    while (n > 0 & n mod 2 = 1) do (     n := n / 2 ; 
     curr_count := curr_count + 1 ) ; 
    if (curr_count >= prev_count) then     return false else skip ; 
    prev_count := curr_count ; 
 ) ; 
     return true );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     if (areSetBitsIncreasing(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int lenghtOfLongestAP(int set[],int n){
    if(n<=2)return n ;
    int L[][]=new int[n][n];
    int llap=2 ;
    for(int i=0 ; i<n ; i++)L[i][n-1]=2 ;
    for(int j=n-2 ; j>=1 ; j--){
      int i=j-1,k=j+1 ;
      while(i>=0 && k<=n-1){
        if(set[i]+set[k]<2*set[j])k++;
        else if(set[i]+set[k]>2*set[j]){
          L[i][j]=2 ;
          i--;
        }
        else {
          L[i][j]=L[j][k]+1 ;
          llap=Math.max(llap,L[i][j]);
          i--;
          k++;
        }
      }
      while(i>=0){
        L[i][j]=2 ;
        i--;
      }
    }
    return llap ;
  }
  public static void main(String[] args){
    int set1[]={
      1,7,10,13,14,19 };
      int n1=set1.length ;
      System.out.println(lenghtOfLongestAP(set1,n1));
      int set2[]={
        1,7,10,15,27,29 };
        int n2=set2.length ;
        System.out.println(lenghtOfLongestAP(set2,n2));
        int set3[]={
          2,4,6,8,10 };
          int n3=set3.length ;
          System.out.println(lenghtOfLongestAP(set3,n3));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation lenghtOfLongestAP( set : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n <= 2) then     return n else skip ; 
     var L : Sequence(Sequence(int)) ; L := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var llap : int ; llap := 2 ;
        var i : int ; i := 0 ; while i < n do (     L[i+1][n - 1+1] := 2 ;  ;     i := i + 1 ) ; 
        var j : int ; j := n - 2 ; while j >= 1 do ( (     var i : int ; i := j - 1 ;
    var k : int ; k := j + 1 ;
     while (i >= 0 & k <= n - 1) do (     if (set[i+1] + set[k+1] < 2 * set[j+1]) then     k := k + 1 ; else     if (set[i+1] + set[k+1] > 2 * set[j+1]) then (     L[i+1][j+1] := 2 ; 
     i := i - 1 ) else (     L[i+1][j+1] := L[j+1][k+1] + 1 ; 
     llap := Set{llap, L[i+1][j+1]}->max() ; 
     i := i - 1 ; 
     k := k + 1 ) ;  ) ; 
     while (i >= 0) do (     L[i+1][j+1] := 2 ; 
     i := i - 1 ) )  ;     j := j - 1 ) ; 
    return llap 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var set1 : Sequence(int) ; set1 := Sequence{1,7,10,13,14,19} ;
     var n1 : int ; n1 := set1->size() ;
    OclFile["System.out"].println(lenghtOfLongestAP(set1, n1)) ; 
    var set2 : Sequence(int) ; set2 := Sequence{1,7,10,15,27,29} ;
    var n2 : int ; n2 := set2->size() ;
    OclFile["System.out"].println(lenghtOfLongestAP(set2, n2)) ; 
    var set3 : Sequence(int) ; set3 := Sequence{2,4,6,8,10} ;
    var n3 : int ; n3 := set3->size() ;
    OclFile["System.out"].println(lenghtOfLongestAP(set3, n3)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Queue ;
class GFG {
  public static int minIndex(Queue<Integer>list,int sortIndex){
    int min_index=-1 ;
    int min_value=Integer.MAX_VALUE ;
    int s=list.size();
    for(int i=0 ; i<s ; i++){
      int current=list.peek();
      list.poll();
      if(current<=min_value && i<=sortIndex){
        min_index=i ;
        min_value=current ;
      }
      list.add(current);
    }
    return min_index ;
  }
  public static void insertMinToRear(Queue<Integer>list,int min_index){
    int min_value=0 ;
    int s=list.size();
    for(int i=0 ; i<s ; i++){
      int current=list.peek();
      list.poll();
      if(i!=min_index)list.add(current);
      else min_value=current ;
    }
    list.add(min_value);
  }
  public static void sortQueue(Queue<Integer>list){
    for(int i=1 ; i<=list.size(); i++){
      int min_index=minIndex(list,list.size()-i);
      insertMinToRear(list,min_index);
    }
  }
  public static void main(String[] args){
    Queue<Integer>list=new LinkedList<Integer>();
    list.add(30);
    list.add(11);
    list.add(15);
    list.add(4);
    sortQueue(list);
    while(list.isEmpty()==false){
      System.out.print(list.peek()+" ");
      list.poll();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minIndex( list : Sequence(int), sortIndex : int) : int
  pre: true
  post: true
  activity: (     var min_index : int ; min_index := -1 ;
     var min_value : int ; min_value := 2147483647 ;
    var s : int ; s := list->size() ;
        var i : int ; i := 0 ; while i < s do ( (     var current : int ; current := list->min() ;
     list := list->sort()->tail() ; 
     if (current <= min_value & i <= sortIndex) then (     min_index := i ; 
     min_value := current ) else skip ; 
     list->excludes(current) )  ;     i := i + 1 ) ; 
    return min_index 
 );
  static   operation insertMinToRear( list : Sequence(int), min_index : int) : void
  pre: true
  post: true
  activity: (     var min_value : int ; min_value := 0 ;
     var s : int ; s := list->size() ;
         var i : int ; i := 0 ; while i < s do ( (     var current : int ; current := list->min() ;
     list := list->sort()->tail() ; 
     if (i /= min_index) then     list->excludes(current) ; else     min_value := current ; )  ;     i := i + 1 ) ; 
     list->excludes(min_value) );
  static   operation sortQueue( list : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= list->size() do ( (     var min_index : int ; min_index := minIndex(list, list->size() - i) ;
     execute insertMinToRear(list, min_index) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     list := list->including(30) ; 
    list := list->including(11) ; 
    list := list->including(15) ; 
    list := list->including(4) ; 
    execute sortQueue(list) ; 
    while (list->isEmpty() = false) do (     OclFile["System.out"].print(list->min() + " ") ; 
     list := list->sort()->tail() ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int reverse(int x){
    if(x==0)return 0 ;
    long res=0 ;
    while(x!=0){
      res=res*10+x % 10 ;
      if(res>Integer.MAX_VALUE || res<Integer.MIN_VALUE)return 0 ;
      x/=10 ;
    }
    return(int)res ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation reverse( x : int) : int
  pre: true
  post: true
  activity: (     if (x = 0) then     return 0 else skip ; 
     var res : long ; res := 0 ;
     while (x /= 0) do (     res := res * 10 + x mod 10 ; 
     if (res > 2147483647 or res < -2147483648) then     return 0 else skip ; 
     x := x/(10) ) ; 
     return res->oclAsType(int) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=b-a ;
    int b_=0 ;
    for(int i=1 ; i<=c ; i++){
      b_+=i ;
    }
    System.out.println(b_-b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := b - a ;
    var b_ : int ; b_ := 0 ;
        var i : int ; i := 1 ; while i <= c do ( (     b_ := b_+(i) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(b_ - b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.Arrays ;
import java.util.Scanner ;
public class practice2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt(),ind1=0,ind2=0 ;
      long[] a=new long[n],b=new long[n];
      for(int i=0 ; i<2*n ; ++i){
        long x=sc.nextInt(),y=sc.nextInt();
        if(y==0)a[ind1++]=x*x ;
        else b[ind2++]=y*y ;
      }
      Arrays.sort(a);
      Arrays.sort(b);
      double result=0 ;
      for(int i=n-1 ; i>-1 ; --i)result+=Math.sqrt(a[i]+b[i]);
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ind1 : int ; ind1 := 0 ;
    var ind2 : int ; ind2 := 0 ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     var x : long ; x := sc.getCurrent()->toInteger() ;
    var y : long ; y := sc.getCurrent()->toInteger() ;
     if (y = 0) then      a[ind1+1] := x * x  ; ind1 := ind1 + 1 ; else      b[ind2+1] := y * y  ; ind2 := ind2 + 1 ; )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    var result : double ; result := 0 ;
        var i : int ; i := n - 1 ; while i > -1 do (     result := result+((a[i+1] + b[i+1])->sqrt()) ;  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  InputStream in=System.in ;
  PrintStream out=System.out ;
  public void _main(String[] args){
    Scanner sc=new Scanner(in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    sc.close();
    int na=b-a-1 ;
    int ans=(na+1)*na/2-a ;
    out.println(ans);
  }
  public static void main(String[] args){
    new Main()._main(args);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile["System.in"];
   attribute out : OclFile := OclFile["System.out"];
   operation _main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    skip ; 
    var na : int ; na := b - a - 1 ;
    var ans : int ; ans := (na + 1) * na / 2 - a ;
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain()._main(args) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ABC099_B solver=new ABC099_B();
    solver.solve(1,in,out);
    out.close();
  }
  static class ABC099_B {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int a=in.nextInt();
      int b=in.nextInt();
      int snow=0 ;
      for(int i=b-a ; i>0 ; i--){
        snow+=i ;
      }
      out.print(snow-b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ABC099_B ; solver := ABC099_B.newABC099_B() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ABC099_B {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    var snow : int ; snow := 0 ;
        var i : int ; i := b - a ; while i > 0 do ( (     snow := snow+(i) )  ;     i := i - 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] tmpArray=br.readLine().split(" ");
    int a=Integer.parseInt(tmpArray[0]);
    int b=Integer.parseInt(tmpArray[1]);
    int dif=b-a ;
    long result=(dif-1)*dif/2-a ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
    var a : int ; a := (tmpArray[0+1])->toInteger() ;
    var b : int ; b := (tmpArray[1+1])->toInteger() ;
    var dif : int ; dif := b - a ;
    var result : long ; result := (dif - 1) * dif / 2 - a ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner in=new Scanner(System.in);
    int m=in.nextInt();
    int n=in.nextInt();
    System.out.println(((n-m)*(n-m+1))/2-n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := in.getCurrent()->toInteger() ;
     var n : int ; n := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println(((n - m) * (n - m + 1)) / 2 - n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    long N=gl();
    long M=gl();
    List<Long>l=new ArrayList<Long>();
    for(long i=1 ; i<=Math.sqrt(M); i++){
      if(M % i==0){
        l.add(i);
        l.add(M/i);
      }
    }
    Collections.sort(l);
    long ans=1 ;
    for(int i=0 ; i<l.size(); i++){
      long v=l.get(i);
      if(v>=N){
        ans=M/v ;
        break ;
      }
    }
    System.out.print(ans);
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : long ; N := gl() ;
    var M : long ; M := gl() ;
    var l : Sequence(long) ; l := Sequence{} ;
        var i : long ; i := 1 ; while i <= (M)->sqrt() do ( (     if (M mod i = 0) then (     l := l->including(i) ; 
     l := l->including(M / i) ) else skip )  ;     i := i + 1 ) ; 
    l := l->sort() ; 
    var ans : long ; ans := 1 ;
        var i : int ; i := 0 ; while i < l->size() do ( (     var v : long ; v := l->at(i+1) ;
     if (v >= N) then (     ans := M / v ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(ans) ; 
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] s=new int[n];
    int[] t=new int[m];
    for(int i=0 ; i<n ; i++){
      s[i]=sc.nextInt();
    }
    for(int i=0 ; i<m ; i++){
      t[i]=sc.nextInt();
    }
    int mod=1_000_000_007 ;
    long[][] dp=new long[n+1][m+1];
    long[][] sum=new long[n+1][m+1];
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=m ; j++){
        if(s[i-1]==t[j-1])dp[i][j]=(sum[i-1][j-1]+1)% mod ;
        sum[i][j]=(sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+dp[i][j]+mod)% mod ;
      }
    }
    System.out.println(sum[n][m]+1);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
    var t : Sequence(int) ; t := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     t[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var mod : int ; mod := 1_000_000_007 ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
    var sum : Sequence(Sequence(long)) ; sum := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= m do ( (     if (s[i - 1+1] = t[j - 1+1]) then     dp[i+1][j+1] := (sum[i - 1+1][j - 1+1] + 1) mod mod ; else skip ; 
     sum[i+1][j+1] := (sum[i - 1+1][j+1] + sum[i+1][j - 1+1] - sum[i - 1+1][j - 1+1] + dp[i+1][j+1] + mod) mod mod )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum[n+1][m+1] + 1) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[] S=new int[N];
    int[] T=new int[M];
    for(int i=0 ; i<N ; i++)S[i]=sc.nextInt();
    for(int i=0 ; i<M ; i++)T[i]=sc.nextInt();
    long[][] dp=new long[N+1][M+1];
    int mod=1000_000_007 ;
    for(int i=1 ; i<=N ; i++){
      for(int j=1 ; j<=M ; j++){
        if(S[i-1]==T[j-1])dp[i][j]=dp[i-1][j]+dp[i][j-1]+1 ;
        else dp[i][j]=dp[i-1][j]+dp[i][j-1]-dp[i-1][j-1]+mod ;
        dp[i][j] %=mod ;
      }
    }
    System.out.println(dp[N][M]+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var S : Sequence(int) ; S := Integer.subrange(1,N)->collect(0) ;
    var T : Sequence(int) ; T := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     S[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do (     T[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,M + 1)->collect(0)) ;
    var mod : int ; mod := 1000_000_007 ;
        var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := 1 ; while j <= M do ( (     if (S[i - 1+1] = T[j - 1+1]) then     dp[i+1][j+1] := dp[i - 1+1][j+1] + dp[i+1][j - 1+1] + 1 else     dp[i+1][j+1] := dp[i - 1+1][j+1] + dp[i+1][j - 1+1] - dp[i - 1+1][j - 1+1] + mod ; ;  
     dp[i+1][j+1] := dp[i+1][j+1] mod mod )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[N+1][M+1] + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] s=new int[n];
    int[] t=new int[m];
    long[][] dp=new long[n+1][m+1];
    long[][] sum=new long[n+1][m+1];
    long mod=1000000007 ;
    for(int i=0 ; i<n ; i++){
      s[i]=sc.nextInt();
    }
    for(int i=0 ; i<m ; i++){
      t[i]=sc.nextInt();
    }
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=m ; j++){
        if(s[i-1]==t[j-1]){
          dp[i][j]=1+sum[i-1][j-1];
          dp[i][j] %=mod ;
        }
        sum[i][j]=sum[i-1][j]-sum[i-1][j-1]+sum[i][j-1]+dp[i][j]+mod ;
        sum[i][j] %=mod ;
      }
    }
    System.out.println((sum[n][m]+1)% mod);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
    var t : Sequence(int) ; t := Integer.subrange(1,m)->collect(0) ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
    var sum : Sequence(Sequence(long)) ; sum := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
    var mod : long ; mod := 1000000007 ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     t[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= m do ( (     if (s[i - 1+1] = t[j - 1+1]) then (     dp[i+1][j+1] := 1 + sum[i - 1+1][j - 1+1] ; 
     dp[i+1][j+1] := dp[i+1][j+1] mod mod ) else skip ; 
     sum[i+1][j+1] := sum[i - 1+1][j+1] - sum[i - 1+1][j - 1+1] + sum[i+1][j - 1+1] + dp[i+1][j+1] + mod ; 
     sum[i+1][j+1] := sum[i+1][j+1] mod mod )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((sum[n+1][m+1] + 1) mod mod) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int m=Integer.parseInt(sc.next());
    int[] s=new int[n];
    int[] t=new int[m];
    int mod=1000000007 ;
    for(int i=0 ; i<n ; i++){
      s[i]=Integer.parseInt(sc.next());
    }
    for(int i=0 ; i<m ; i++){
      t[i]=Integer.parseInt(sc.next());
    }
    sc.close();
    long[][] dp=new long[n+1][m+1];
    for(int i=0 ; i<n+1 ; i++)dp[i][0]=1 ;
    for(int i=0 ; i<m+1 ; i++)dp[0][i]=1 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(s[i]==t[j]){
          dp[i+1][j+1]=(dp[i][j+1]+dp[i+1][j])% mod ;
        }
        else {
          dp[i+1][j+1]=(dp[i][j+1]+dp[i+1][j]-dp[i][j])% mod ;
          dp[i+1][j+1]+=mod ;
          dp[i+1][j+1] %=mod ;
        }
      }
    }
    System.out.println(dp[n][m]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var m : int ; m := (sc.getCurrent())->toInteger() ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
    var t : Sequence(int) ; t := Integer.subrange(1,m)->collect(0) ;
    var mod : int ; mod := 1000000007 ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     t[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < n + 1 do (     dp[i+1][0+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m + 1 do (     dp[0+1][i+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (s[i+1] = t[j+1]) then (     dp[i + 1+1][j + 1+1] := (dp[i+1][j + 1+1] + dp[i + 1+1][j+1]) mod mod ) else (     dp[i + 1+1][j + 1+1] := (dp[i+1][j + 1+1] + dp[i + 1+1][j+1] - dp[i+1][j+1]) mod mod ; 
     dp[i + 1+1][j + 1+1] := dp[i + 1+1][j + 1+1]+(mod) ; 
     dp[i + 1+1][j + 1+1] := dp[i + 1+1][j + 1+1] mod mod ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[n+1][m+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.Collectors ;
public class Main {
  private static int MOD=1_000_000_007 ;
  public static void main(String[] args){
    final Scanner scanner=new Scanner(System.in);
    solve(scanner);
  }
  static void solve(Scanner scanner){
    int N=scanner.nextInt(),M=scanner.nextInt();
    scanner.nextLine();
    int[] S=Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    int[] T=Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    long[][] dp=new long[N+1][M+1];
    long[][] sum=new long[N+1][M+1];
    for(int i=1 ; i<=N ; i++){
      for(int j=1 ; j<=M ; j++){
        if(S[i-1]==T[j-1]){
          dp[i][j]=(sum[i-1][j-1]+1)% MOD ;
        }
        sum[i][j]=(sum[i][j-1]+sum[i-1][j]+(MOD-sum[i-1][j-1])+dp[i][j])% MOD ;
      }
    }
    long ans=1 ;
    for(int i=1 ; i<=N ; i++){
      for(int j=1 ; j<=M ; j++){
        ans=(ans+dp[i][j])% MOD ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : int := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute solve(scanner) );
  static   operation solve( scanner : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var M : int ; M := scanner.getCurrent()->toInteger() ;
     skip ; 
    var S : Sequence(int) ; S := stream(scanner.nextLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var T : Sequence(int) ; T := stream(scanner.nextLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,M + 1)->collect(0)) ;
    var sum : Sequence(Sequence(long)) ; sum := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,M + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := 1 ; while j <= M do ( (     if (S[i - 1+1] = T[j - 1+1]) then (     dp[i+1][j+1] := (sum[i - 1+1][j - 1+1] + 1) mod MOD ) else skip ; 
     sum[i+1][j+1] := (sum[i+1][j - 1+1] + sum[i - 1+1][j+1] + (MOD - sum[i - 1+1][j - 1+1]) + dp[i+1][j+1]) mod MOD )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 1 ;
        var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := 1 ; while j <= M do ( (     ans := (ans + dp[i+1][j+1]) mod MOD )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static long countNonDecreasing(int n){
    int N=10 ;
    long count=1 ;
    for(int i=1 ; i<=n ; i++){
      count*=(N+i-1);
      count/=i ;
    }
    return count ;
  }
  public static void main(String args[]){
    int n=3 ;
    System.out.print(countNonDecreasing(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countNonDecreasing( n : int) : long
  pre: true
  post: true
  activity: (     var N : int ; N := 10 ;
     var count : long ; count := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (     count := count*((N + i - 1)) ; 
     count := count/(i) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].print(countNonDecreasing(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String tribWord(int n){
    String Sn_1="1" ;
    String Sn_2="12" ;
    String Sn_3="1213" ;
    String tmp ;
    for(int i=3 ; i<=n ; i++){
      tmp=Sn_3 ;
      Sn_3+=(Sn_2+Sn_1);
      Sn_1=Sn_2 ;
      Sn_2=tmp ;
    }
    return Sn_3 ;
  }
  public static void main(String[] args){
    int n=6 ;
    System.out.print(tribWord(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation tribWord( n : int) : String
  pre: true
  post: true
  activity: (     var Sn    var SnString :  ; SnString := "1" : String ; Sn    var SnString :  ; SnString := "1" := "1" ;
     var Sn"12" : String ; Sn"12" := "12" ;
    var Sn_3 : String ; Sn_3 := "1213" ;
    var tmp : String ;
        var i : int ; i := 3 ; while i <= n do ( (     tmp := Sn    SnSn_1 := Sn_2 ; 
 ; 
     Sn    SnSn_1 := Sn_2 ; 
 := Sn    SnSn_1 := Sn_2 ; 
+((SnSnSn    SnSn_1 := Sn_2 ; 
 + SnSn    SnSn_1 := Sn_2 ; 
)) ; 
     SnSn_1 := Sn_2 ; 
     Sntmp := tmp )  ;     i := i + 1 ) ; 
    return Sn_3 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].print(tribWord(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isRotation(long x,long y){
    long x64=x |(x<<32);
    while(x64>=y){
      if(x64==y){
        return true ;
      }
      x64>>=1 ;
    }
    return false ;
  }
  public static void main(String[] args){
    long x=122 ;
    long y=2147483678L ;
    if(isRotation(x,y)==false){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isRotation( x : long, y : long) : boolean
  pre: true
  post: true
  activity: (     var x64 : long ; x64 := MathLib.bitwiseOr(x,((x*(2->pow(32)))->oclAsType(long))) ;
     while (x64 >= y) do (     if (x64 = y) then (     return true ) else skip ; 
     x64 := x64/(2->pow(1)) ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : long ; x := 122 ;
     var y : long ; y := 2147483678L ;
     if (isRotation(x, y) = false) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  long gcd(long a,long b){
    if(a<b){
      long tmp=a ;
      a=b ;
      b=tmp ;
    }
    while(b!=0){
      long r=a % b ;
      a=b ;
      b=r ;
    }
    return a ;
  }
  long sum(long a,long k){
    return(k*(a+a*k))/2 ;
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      long n=sc.nextLong();
      int m=sc.nextInt();
      if((n | m)==0)break ;
      long[] a=new long[m];
      long[] subsum=new long[m];
      for(int i=0 ; i<m ; i++){
        a[i]=sc.nextLong();
        subsum[i]=sum(a[i],n/a[i]);
      }
      long sum=n*(n+1)/2 ;
      long res=0 ;
      for(int i=1 ; i<(1<<m); i++){
        int num=0 ;
        for(int j=0 ; j<m ; j++)if(((i>>j)& 1)>0)num++;
        long LCM=1 ;
        for(int j=0 ; j<m ; j++){
          if(((i>>j)& 1)>0){
            LCM=LCM/gcd(LCM,a[j])*a[j];
            if(LCM>n)break ;
          }
        }
        if(num % 2==0)sum+=sum(LCM,n/LCM);
        else sum-=sum(LCM,n/LCM);
        if(num % 2==0)res-=n/LCM ;
        else res+=n/LCM ;
      }
      long N=n-res ;
      System.out.printf("%.6f\n",N==0 ? 0.0 :(1.0*sum/N));
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a < b) then (     var tmp : long ; tmp := a ;
     a := b ; 
     b := tmp ) else skip ; 
     while (b /= 0) do (     var r : long ; r := a mod b ;
     a := b ; 
     b := r ) ; 
     return a );
   operation sum( a : long, k : long) : long
  pre: true
  post: true
  activity: (     return (k * (a + a * k)) / 2 );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : long ; n := sc.getCurrent()->toLong() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,m)) = 0) then     break else skip ; 
    var a : Sequence(long) ; a := Integer.subrange(1,m)->collect(0) ;
    var subsum : Sequence(long) ; subsum := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := sc.getCurrent()->toLong() ; 
     subsum[i+1] := sum(a[i+1], n / a[i+1]) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := n * (n + 1) / 2 ;
    var res : long ; res := 0 ;
        var i : int ; i := 1 ; while i < ((1*(2->pow(m)))->oclAsType(long)) do ( (     var num : int ; num := 0 ;
         var j : int ; j := 0 ; while j < m do (     if ((((i/(2->pow(j)))->oclAsType(long)) & 1) > 0) then     num := num + 1 ; else skip ;  ;     j := j + 1 ) ; 
    var LCM : long ; LCM := 1 ;
        var j : int ; j := 0 ; while j < m do ( (     if ((((i/(2->pow(j)))->oclAsType(long)) & 1) > 0) then (     LCM := LCM / gcd(LCM, a[j+1]) * a[j+1] ; 
     if (LCM > n) then     break else skip ) else skip )  ;     j := j + 1 ) ; 
    if (num mod 2 = 0) then     sum := sum+(sum(LCM, n / LCM)) else     sum := sum-(sum(LCM, n / LCM)) ; ;  
    if (num mod 2 = 0) then     res := res-(n / LCM) else     res := res+(n / LCM) ; ;  
 )  ;     i := i + 1 ) ; 
    var N : long ; N := n - res ;
    OclFile["System.out"].printf("%.6f\n", if N = 0 then 0.0 else (1.0 * sum / N) endif) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args)throws Exception {
    while(true){
      int N=sc.nextInt();
      int M=sc.nextInt();
      if(N==0)break ;
      int min=N ;
      for(int i=0 ; i<M ; ++i){
        min=Math.min(min,sc.nextInt());
      }
      System.out.printf("%.5f\n",min==1 ? 0.0 : N/2.0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var M : int ; M := sc.getCurrent()->toInteger() ;
    if (N = 0) then     break else skip ; 
    var min : int ; min := N ;
        var i : int ; i := 0 ; while i < M do ( (     min := Set{min, sc.getCurrent()->toInteger()}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.5f\n", if min = 1 then 0.0 else N / 2.0 endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      long n=sc.nextLong();
      int m=sc.nextInt();
      if((n | m)==0){
        break ;
      }
      long[] p=new long[m];
      for(int i=0 ; i<m ; i++){
        p[i]=sc.nextLong();
      }
      long sum=0 ;
      long num=0 ;
      for(int i=1 ; i<1<<m ; i++){
        int bit=Integer.bitCount(i);
        long lcm=1 ;
        for(int k=0 ; k<m ; k++){
          if((i>>k & 1)==1){
            lcm=lcm/gcd(lcm,p[k])*p[k];
            if(lcm>n){
              break ;
            }
          }
        }
        if(bit % 2==0){
          num-=n/lcm ;
          sum-=lcm*(n/lcm+1)*(n/lcm)/2 ;
        }
        else {
          num+=n/lcm ;
          sum+=lcm*(n/lcm+1)*(n/lcm)/2 ;
        }
      }
      long a=n*(n+1)/2-sum ;
      long b=n-num ;
      if(b==0){
        println("0");
      }
      else {
        println(String.format("%.10f",(double)a/b));
      }
    }
  }
  long gcd(long m,long n){
    return m==0 ? n : gcd(n % m,m);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : long ; n := sc.getCurrent()->toLong() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,m)) = 0) then (     break ) else skip ; 
    var p : Sequence(long) ; p := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     p[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    var num : long ; num := 0 ;
        var i : int ; i := 1 ; while i < (1*(2->pow(m)))->oclAsType(long) do ( (     var bit : int ; bit := bitCount(i) ;
     var lcm : long ; lcm := 1 ;
         var k : int ; k := 0 ; while k < m do ( (     if ((MathLib.bitwiseAnd((i/(2->pow(k)))->oclAsType(long),1)) = 1) then (     lcm := lcm / gcd(lcm, p[k+1]) * p[k+1] ; 
     if (lcm > n) then (     break ) else skip ) else skip )  ;     k := k + 1 ) ; 
     if (bit mod 2 = 0) then (     num := num-(n / lcm) ; 
     sum := sum-(lcm * (n / lcm + 1) * (n / lcm) / 2) ) else (     num := num+(n / lcm) ; 
     sum := sum+(lcm * (n / lcm + 1) * (n / lcm) / 2) ) )  ;     i := i + 1 ) ; 
    var a : long ; a := n * (n + 1) / 2 - sum ;
    var b : long ; b := n - num ;
    if (b = 0) then (     execute println("0") ) else (     execute println(StringLib.format("%.10f",Sequence{a->oclAsType(double) / b})) ) ;  
 )  ) );
   operation gcd( m : long, n : long) : long
  pre: true
  post: true
  activity: (     return if m = 0 then n else gcd(n mod m, m) endif );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static long n ;
  static long m ;
  public static void main(String[] args){
    n=sc.nextLong();
    m=sc.nextLong();
    long result=solve(n,m);
    System.out.println(result);
  }
  private static long solve(long n,long m){
    long num=m/n ;
    while(num>0){
      if(m % num==0 && m/num>=n){
        return num ;
      }
      num--;
    }
    return 0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : long;
  static   attribute m : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toLong() ; 
     m := sc.getCurrent()->toLong() ; 
     var result : long ; result := solve(n, m) ;
     OclFile["System.out"].println(result) );
  static   operation solve( n : long, m : long) : long
  pre: true
  post: true
  activity: (     var num : long ; num := m / n ;
     while (num > 0) do (     if (m mod num = 0 & m / num >= n) then (     return num ) else skip ; 
     num := num - 1 ) ; 
     return 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1560B_WhosOpposite {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int a=input.nextInt();
      int b=input.nextInt();
      int c=input.nextInt();
      input.nextLine();
      int distance=Math.abs(a-b);
      int max=Math.max(a,b);
      if(distance>1){
        int len=distance*2 ;
        if(c>len || max>len){
          System.out.println(-1);
        }
        else if(c<=distance){
          System.out.println(c+distance);
        }
        else {
          System.out.println(c-distance);
        }
      }
      else {
        System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1560B_WhosOpposite {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var a : int ; a := input.getCurrent()->toInteger() ;
     var b : int ; b := input.getCurrent()->toInteger() ;
    var c : int ; c := input.getCurrent()->toInteger() ;
    skip ; 
    var distance : int ; distance := if a - b < 0 then -(a - b) else a - b endif ;
    var max : int ; max := Set{a, b}->max() ;
    if (distance > 1) then (     var len : int ; len := distance * 2 ;
     if (c > len or max > len) then (     OclFile["System.out"].println(-1) ) else     if (c <= distance) then (     OclFile["System.out"].println(c + distance) ) else (     OclFile["System.out"].println(c - distance) ) ;  ) else (     OclFile["System.out"].println(-1) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int arr[]=new int[3];
      for(int p=0 ; p<3 ; p++){
        arr[p]=sc.nextInt();
      }
      int total=2*(Math.abs(arr[0]-arr[1]));
      if(Math.max(Math.max(total,arr[2]),Math.max(arr[0],arr[1]))==total){
        int ans=arr[2]+Math.abs(arr[0]-arr[1]);
        if(ans>total){
          System.out.println(ans-total);
        }
        else {
          System.out.println(ans);
        }
      }
      else {
        System.out.println("-1");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var arr : Sequence(int) ; arr := Integer.subrange(1,3)->collect(0) ;
         var p : int ; p := 0 ; while p < 3 do ( (     arr[p+1] := sc.getCurrent()->toInteger() )  ;     p := p + 1 ) ; 
     var total : int ; total := 2 * (if arr[0+1] - arr[1+1] < 0 then -(arr[0+1] - arr[1+1]) else arr[0+1] - arr[1+1] endif) ;
     if (Set{Set{total, arr[2+1]}->max(), Set{arr[0+1], arr[1+1]}->max()}->max() = total) then (     var ans : int ; ans := arr[2+1] + if arr[0+1] - arr[1+1] < 0 then -(arr[0+1] - arr[1+1]) else arr[0+1] - arr[1+1] endif ;
     if (ans > total) then (     OclFile["System.out"].println(ans - total) ) else (     OclFile["System.out"].println(ans) ) ) else (     OclFile["System.out"].println("-1") ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Who_Opposite {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long testcase=sc.nextLong();
    for(long i=0 ; i<testcase ; i++){
      long a=sc.nextLong(),b=sc.nextLong(),c=sc.nextLong(),circle=0,opposite=0 ;
      circle=Math.abs(a-b)*2 ;
      if(c>circle || circle/2==1 || a>circle || b>circle)System.out.print(-1);
      else {
        opposite=c+circle/2 ;
        if(opposite>circle)opposite=c-circle/2 ;
        System.out.print(opposite);
      }
      if(i<testcase-1)System.out.println();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Who_Opposite {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testcase : long ; testcase := sc.getCurrent()->toLong() ;
         var i : long ; i := 0 ; while i < testcase do ( (     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var c : long ; c := sc.getCurrent()->toLong() ;
    var circle : long ; circle := 0 ;
    var opposite : long ; opposite := 0 ;
     circle := if a - b < 0 then -(a - b) else a - b endif * 2 ; 
     if (c > circle or circle / 2 = 1 or a > circle or b > circle) then     OclFile["System.out"].print(-1) else (     opposite := c + circle / 2 ; 
     if (opposite > circle) then     opposite := c - circle / 2 ; else skip ; 
     OclFile["System.out"].print(opposite) ) ;  
     if (i < testcase - 1) then     OclFile["System.out"].println() ; else skip )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test182 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int a=in.nextInt();
      int b=in.nextInt();
      int c=in.nextInt();
      int n ;
      if(a>b){
        if(a-b>=b){
          n=2*(a-b);
          if(n>=c){
            if(c>n/2){
              System.out.println(c-n/2);
            }
            else {
              System.out.println(c+n/2);
            }
          }
          else {
            System.out.println("-1");
          }
        }
        else {
          System.out.println("-1");
        }
      }
      else {
        if(b-a>=a){
          n=2*(b-a);
          if(n>=c){
            if(c>n/2){
              System.out.println(c-n/2);
            }
            else {
              System.out.println(c+n/2);
            }
          }
          else {
            System.out.println("-1");
          }
        }
        else {
          System.out.println("-1");
        }
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test182 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var n : int ;
    if (a > b) then (     if (a - b >= b) then (     n := 2 * (a - b) ; 
     if (n >= c) then (     if (c > n / 2) then (     OclFile["System.out"].println(c - n / 2) ) else (     OclFile["System.out"].println(c + n / 2) ) ) else (     OclFile["System.out"].println("-1") ) ) else (     OclFile["System.out"].println("-1") ) ) else (     if (b - a >= a) then (     n := 2 * (b - a) ; 
     if (n >= c) then (     if (c > n / 2) then (     OclFile["System.out"].println(c - n / 2) ) else (     OclFile["System.out"].println(c + n / 2) ) ) else (     OclFile["System.out"].println("-1") ) ) else (     OclFile["System.out"].println("-1") ) ) ;  
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
class GFG {
  static int reduceString(String s,int l){
    int count=1,steps=0 ;
    for(int i=1 ; i<l ; i++){
      if(s.charAt(i)==s.charAt(i-1))count+=1 ;
      else {
        steps+=(count/2);
        count=1 ;
      }
    }
    steps+=count/2 ;
    return steps ;
  }
  public static void main(String[] args){
    String s="geeksforgeeks" ;
    int l=s.length();
    System.out.print(reduceString(s,l)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation reduceString( s : String, l : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 1 ;
    var steps : int ; steps := 0 ;
         var i : int ; i := 1 ; while i < l do ( (     if (s->at(i+1) = s->at(i - 1+1)) then     count := count+(1) ; else (     steps := steps+((count / 2)) ; 
     count := 1 ) )  ;     i := i + 1 ) ; 
     steps := steps+(count / 2) ; 
     return steps );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     var l : int ; l := s->size() ;
     OclFile["System.out"].print(reduceString(s, l) + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GFG {
  final static int MAXN=1000001 ;
  static int spf[]=new int[MAXN];
  static void sieve(){
    spf[1]=1 ;
    for(int i=2 ; i<MAXN ; i++)spf[i]=i ;
    for(int i=4 ; i<MAXN ; i+=2)spf[i]=2 ;
    for(int i=3 ; i*i<MAXN ; i++){
      if(spf[i]==i){
        for(int j=i*i ; j<MAXN ; j+=i)if(spf[j]==j)spf[j]=i ;
      }
    }
  }
  static int sumFactors(int arr[],int n){
    sieve();
    Map map=new HashMap();
    for(int i=0 ; i<MAXN ; ++i)map.put(i,0);
    for(int i=0 ; i<n ; ++i)map.put(arr[i],1);
    int sum=0 ;
    for(int i=0 ; i<n ; ++i){
      int num=arr[i];
      while(num!=1 &&(int)(map.get(spf[num]))==1){
        num/=spf[num];
      }
      if(num==1)sum+=arr[i];
    }
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      5,11,55,25,100 };
      int n=arr.length ;
      System.out.println(sumFactors(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAXN : int := 1000001;
  static   attribute spf : int := Integer.subrange(1,MAXN)->collect(0);
  static   operation sieve() : void
  pre: true
  post: true
  activity: (     spf[1+1] := 1 ; 
         var i : int ; i := 2 ; while i < MAXN do (     spf[i+1] := i ;  ;     i := i + 1 ) ; 
         var i : int ; i := 4 ; while i < MAXN do (     spf[i+1] := 2 ;  ;     i := i+(2) ) ; 
         var i : int ; i := 3 ; while i * i < MAXN do ( (     if (spf[i+1] = i) then (         var j : int ; j := i * i ; while j < MAXN do (     if (spf[j+1] = j) then     spf[j+1] := i ; else skip ;  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) );
  static   operation sumFactors( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     execute sieve() ; 
     var map : Map ; map := Map{} ;
        var i : int ; i := 0 ; while i < MAXN do (     map := map->union(Map{i |-> 0}) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     map := map->union(Map{arr[i+1] |-> 1}) ;  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := arr[i+1] ;
     while (num /= 1 & (map->at(spf[num+1]))->oclAsType(int) = 1) do (     num := num/(spf[num+1]) ) ; 
     if (num = 1) then     sum := sum+(arr[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,11,55,25,100} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(sumFactors(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int a=0,b=0 ;
  static int isPrime(int x){
    int s=(int)Math.sqrt(x);
    for(int i=2 ; i<=s ; i++)if(x % i==0)return 0 ;
    return 1 ;
  }
  static void Num(int x){
    for(int i=2 ; i<=x/2 ; i++){
      if(isPrime(i)!=0 && isPrime(x-i)!=0){
        a=i ;
        b=x-i ;
        return ;
      }
    }
  }
  static void generate(int n){
    if(n<=7)System.out.println("Impossible"+" to form");
    if(n % 2!=0){
      Num(n-5);
      System.out.println("2 3 "+a+" "+b);
    }
    else {
      Num(n-4);
      System.out.println("2 2 "+a+" "+b);
    }
  }
  public static void main(String[] args){
    int n=28 ;
    generate(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute a : int := 0;
  static   operation isPrime( x : int) : int
  pre: true
  post: true
  activity: (     var s : int ; s := (x)->sqrt()->oclAsType(int) ;
         var i : int ; i := 2 ; while i <= s do (     if (x mod i = 0) then     return 0 else skip ;  ;     i := i + 1 ) ; 
     return 1 );
  static   operation Num( x : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i <= x / 2 do ( (     if (isPrime(i) /= 0 & isPrime(x - i) /= 0) then (     a := i ; 
     b := x - i ; 
     return ) else skip )  ;     i := i + 1 ) );
  static   operation generate( n : int) : void
  pre: true
  post: true
  activity: (     if (n <= 7) then     OclFile["System.out"].println("Impossible" + " to form") ; else skip ; 
     if (n mod 2 /= 0) then (     execute Num(n - 5) ; 
     OclFile["System.out"].println("2 3 " + a + " " + b) ) else (     execute Num(n - 4) ; 
     OclFile["System.out"].println("2 2 " + a + " " + b) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 28 ;
     execute generate(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new AOJ0278();
  }
  class AOJ0278 {
    void doIt(){
      int x=in.nextInt(),y=in.nextInt(),a=in.nextInt(),b=in.nextInt();
      int result=Integer.MAX_VALUE ;
      if(a>=5 && b>=2)result=(int)((x*a+y*b)*0.8);
      else if(a>=5)result=Math.min((int)((x*a+y*2)*0.8),x*a+y*b);
      else if(b>=2)result=Math.min((int)((x*5+y*b)*0.8),x*a+y*b);
      else result=Math.min((int)((x*5+y*2)*0.8),x*a+y*b);
      System.out.println(result);
    }
    public AOJ0278(){
      int n=in.nextInt();
      for(int i=0 ; i<n ; i++)doIt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: ( AOJ0278.newAOJ0278() );
 class AOJ0278 {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var x : int ; x := in.getCurrent()->toInteger() ;
    var y : int ; y := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
     var result : int ; result := 2147483647 ;
     if (a >= 5 & b >= 2) then     result := ((x * a + y * b) * 0.8)->oclAsType(int) else     if (a >= 5) then     result := Set{((x * a + y * 2) * 0.8)->oclAsType(int), x * a + y * b}->min() else     if (b >= 2) then     result := Set{((x * 5 + y * b) * 0.8)->oclAsType(int), x * a + y * b}->min() else     result := Set{((x * 5 + y * 2) * 0.8)->oclAsType(int), x * a + y * b}->min() ; ;  ;  ;  
     OclFile["System.out"].println(result) );
   static operation newAOJ0278() : AOJ0278
  pre: true
  post: true
  activity:
  ( var self : AOJ0278 ;
    self := createAOJ0278();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do (     execute doIt() ;  ;     i := i + 1 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    StringBuilder sb=new StringBuilder();
    br.readLine();
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int x,y,b,p ;
      double regular,discount ;
      StringTokenizer st=new StringTokenizer(line);
      x=Integer.parseInt(st.nextToken());
      y=Integer.parseInt(st.nextToken());
      b=Integer.parseInt(st.nextToken());
      p=Integer.parseInt(st.nextToken());
      regular=x*b+y*p ;
      discount=(x*(b>5 ? b : 5)+y*(p>2 ? p : 2))*0.8 ;
      sb.append(Double.valueOf(regular<discount ? regular : discount).intValue()).append('\n');
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
    var sb : String ; sb := StringLib.newString() ;
    skip ; 
        line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var x : int ;
    var y : int ;
    var b : int ;
    var p : int ;
     var regular : double ;
    var discount : double ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(line) ;
    x := (st.next())->toInteger() ; 
    y := (st.next())->toInteger() ; 
    b := (st.next())->toInteger() ; 
    p := (st.next())->toInteger() ; 
    regular := x * b + y * p ; 
    discount := (x * (if b > 5 then b else 5 endif) + y * (if p > 2 then p else 2 endif)) * 0.8 ; 
    sb := sb + StringLib.newString((if regular < discount then regular else discount endif)->toReal()->oclAsType(int)) + StringLib.newString('
') ; 
 ) ;     line := br.readLine() ;
 ) ;  
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner r=new Scanner(System.in);
    int n ;
    int x,y,b,p ;
    double salex,saley ;
    double saleans,ans ;
    n=r.nextInt();
    while(true){
      x=r.nextInt();
      y=r.nextInt();
      b=r.nextInt();
      p=r.nextInt();
      salex=(double)x*0.8 ;
      saley=(double)y*0.8 ;
      ans=x*b+y*p ;
      if(b<5)b=5 ;
      if(p<2)p=2 ;
      saleans=salex*b+saley*p ;
      System.out.println((int)Math.min(ans,saleans));
      n--;
      if(n==0)break ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var x : int ;
    var y : int ;
    var b : int ;
    var p : int ;
    var salex : double ;
    var saley : double ;
    var saleans : double ;
    var ans : double ;
    n := r.getCurrent()->toInteger() ; 
    while (true) do (     x := r.getCurrent()->toInteger() ; 
     y := r.getCurrent()->toInteger() ; 
    b := r.getCurrent()->toInteger() ; 
    p := r.getCurrent()->toInteger() ; 
    salex := x->oclAsType(double) * 0.8 ; 
    saley := y->oclAsType(double) * 0.8 ; 
    ans := x * b + y * p ; 
    if (b < 5) then     b := 5 ; else skip ; 
    if (p < 2) then     p := 2 ; else skip ; 
    saleans := salex * b + saley * p ; 
    OclFile["System.out"].println(Set{ans, saleans}->min()->oclAsType(int)) ; 
    n := n - 1 ; 
    if (n = 0) then     break else skip ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int k=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr);
    int cnt=0 ;
    while(m>k){
      if(k!=0){
        if(n==0){
          cnt=-1 ;
          break ;
        }
        m=m-arr[n-1];
        k--;
      }
      else {
        if(n==0){
          cnt=-1 ;
          break ;
        }
        m=m-arr[n-1]+1 ;
      }
      n--;
      cnt++;
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var cnt : int ; cnt := 0 ;
    while (m > k) do (     if (k /= 0) then (     if (n = 0) then (     cnt := -1 ; 
     break ) else skip ; 
     m := m - arr[n - 1+1] ; 
     k := k - 1 ) else (     if (n = 0) then (     cnt := -1 ; 
     break ) else skip ; 
     m := m - arr[n - 1+1] + 1 ) ;  
     n := n - 1 ; 
     cnt := cnt + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public void solve(){
    Scanner sc=new Scanner(System.in);
    int niti,nyuryo,puluryo,nyumai,pulumai,nyukei,pulukei,goukei ;
    niti=sc.nextInt();
    for(int i=0 ; i<niti ; i++){
      nyuryo=sc.nextInt();
      puluryo=sc.nextInt();
      nyumai=sc.nextInt();
      pulumai=sc.nextInt();
      nyukei=nyuryo*nyumai ;
      pulukei=puluryo*pulumai ;
      goukei=nyukei+pulukei ;
      if(nyumai<=5){
        nyumai=5 ;
      }
      if(pulumai<=2){
        pulumai=2 ;
      }
      nyukei=nyuryo*nyumai ;
      pulukei=puluryo*pulumai ;
      int goukei2=nyukei+pulukei ;
      goukei2=goukei2*4/5 ;
      if(goukei>goukei2){
        System.out.println(goukei2);
      }
      else {
        System.out.println(goukei);
      }
    }
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var niti : int ;
    var nyuryo : int ;
    var puluryo : int ;
    var nyumai : int ;
    var pulumai : int ;
    var nyukei : int ;
    var pulukei : int ;
    var goukei : int ;
     niti := sc.getCurrent()->toInteger() ; 
         var i : int ; i := 0 ; while i < niti do ( (     nyuryo := sc.getCurrent()->toInteger() ; 
     puluryo := sc.getCurrent()->toInteger() ; 
    nyumai := sc.getCurrent()->toInteger() ; 
    pulumai := sc.getCurrent()->toInteger() ; 
    nyukei := nyuryo * nyumai ; 
    pulukei := puluryo * pulumai ; 
    goukei := nyukei + pulukei ; 
    if (nyumai <= 5) then (     nyumai := 5 ) else skip ; 
    if (pulumai <= 2) then (     pulumai := 2 ) else skip ; 
    nyukei := nyuryo * nyumai ; 
    pulukei := puluryo * pulumai ; 
    var goukei2 : int ; goukei2 := nyukei + pulukei ;
    goukei2 := goukei2 * 4 / 5 ; 
    if (goukei > goukei2) then (     OclFile["System.out"].println(goukei2) ) else (     OclFile["System.out"].println(goukei) ) ;  
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int Tests=sc.nextInt();
    for(int test=0 ; test<Tests ; test++){
      long a=sc.nextInt();
      long b=sc.nextInt();
      long l=sc.nextInt();
      long r=sc.nextInt();
      long len=(Math.max(a,b)-1)/(Math.min(a,b)+1)+1 ;
      long lena,lenb ;
      if(a>=len*b){
        lena=a+b ;
        lenb=0 ;
      }
      else if(b>=len*a){
        lena=0 ;
        lenb=a+b ;
      }
      else {
        lena=(len*a-b)/(len-1);
        lenb=(len*b-a)/(len-1);
      }
      boolean B=a-lena+lena/(len+1)-lenb/(len+1)==0 ;
      for(long i=l-1 ; i<r ; ++i){
        char pc ;
        if(i<lena){
          if(i %(len+1)==len)pc='B' ;
          else pc='A' ;
        }
        else if(i>=a+b-lenb){
          if((a+b-i-1)%(len+1)!=len)pc='B' ;
          else pc='A' ;
        }
        else if(B)pc='B' ;
        else pc='A' ;
        System.out.print(pc);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var Tests : int ; Tests := sc.getCurrent()->toInteger() ;
         var test : int ; test := 0 ; while test < Tests do ( (     var a : long ; a := sc.getCurrent()->toInteger() ;
     var b : long ; b := sc.getCurrent()->toInteger() ;
    var l : long ; l := sc.getCurrent()->toInteger() ;
    var r : long ; r := sc.getCurrent()->toInteger() ;
    var len : long ; len := (Set{a, b}->max() - 1) / (Set{a, b}->min() + 1) + 1 ;
    var lena : long ;
    var lenb : long ;
    if (a >= len * b) then (     lena := a + b ; 
     lenb := 0 ) else     if (b >= len * a) then (     lena := 0 ; 
     lenb := a + b ) else (     lena := (len * a - b) / (len - 1) ; 
     lenb := (len * b - a) / (len - 1) ) ;  ;  
    var B : boolean ; B := a - lena + lena / (len + 1) - lenb / (len + 1) = 0 ;
        var i : long ; i := l - 1 ; while i < r do ( (     var pc : String ;
     if (i < lena) then (     if (i mod (len + 1) = len) then     pc := 'B' ; else     pc := 'A' ; ) else     if (i >= a + b - lenb) then (     if ((a + b - i - 1) mod (len + 1) /= len) then     pc := 'B' ; else     pc := 'A' ; ) else     if (B) then     pc := 'B' else     pc := 'A' ; ;  ;  ;  
     OclFile["System.out"].print(pc) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     test := test + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int Tests=sc.nextInt();
    for(int test=0 ; test<Tests ; test++){
      long a=sc.nextInt();
      long b=sc.nextInt();
      long l=sc.nextInt();
      long r=sc.nextInt();
      long len=(Math.max(a,b)-1)/(Math.min(a,b)+1)+1 ;
      long lena,lenb ;
      if(a>=len*b){
        lena=a+b ;
        lenb=0 ;
      }
      else if(b>=len*a){
        lena=0 ;
        lenb=a+b ;
      }
      else {
        lena=(len*a-b)/(len-1);
        lenb=(len*b-a)/(len-1);
      }
      boolean B=a-lena+lena/(len+1)-lenb/(len+1)==0 ;
      for(long i=l-1 ; i<r ; ++i){
        char pc ;
        if(i<lena){
          if(i %(len+1)==len)pc='B' ;
          else pc='A' ;
        }
        else if(i>=a+b-lenb){
          if((a+b-i-1)%(len+1)!=len)pc='B' ;
          else pc='A' ;
        }
        else if(B)pc='B' ;
        else pc='A' ;
        System.out.print(pc);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var Tests : int ; Tests := sc.getCurrent()->toInteger() ;
         var test : int ; test := 0 ; while test < Tests do ( (     var a : long ; a := sc.getCurrent()->toInteger() ;
     var b : long ; b := sc.getCurrent()->toInteger() ;
    var l : long ; l := sc.getCurrent()->toInteger() ;
    var r : long ; r := sc.getCurrent()->toInteger() ;
    var len : long ; len := (Set{a, b}->max() - 1) / (Set{a, b}->min() + 1) + 1 ;
    var lena : long ;
    var lenb : long ;
    if (a >= len * b) then (     lena := a + b ; 
     lenb := 0 ) else     if (b >= len * a) then (     lena := 0 ; 
     lenb := a + b ) else (     lena := (len * a - b) / (len - 1) ; 
     lenb := (len * b - a) / (len - 1) ) ;  ;  
    var B : boolean ; B := a - lena + lena / (len + 1) - lenb / (len + 1) = 0 ;
        var i : long ; i := l - 1 ; while i < r do ( (     var pc : String ;
     if (i < lena) then (     if (i mod (len + 1) = len) then     pc := 'B' ; else     pc := 'A' ; ) else     if (i >= a + b - lenb) then (     if ((a + b - i - 1) mod (len + 1) /= len) then     pc := 'B' ; else     pc := 'A' ; ) else     if (B) then     pc := 'B' else     pc := 'A' ; ;  ;  ;  
     OclFile["System.out"].print(pc) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     test := test + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int Tests=sc.nextInt();
    for(int test=0 ; test<Tests ; test++){
      long a=sc.nextInt();
      long b=sc.nextInt();
      long l=sc.nextInt();
      long r=sc.nextInt();
      long len=(Math.max(a,b)-1)/(Math.min(a,b)+1)+1 ;
      long lena,lenb ;
      if(a>=len*b){
        lena=a+b ;
        lenb=0 ;
      }
      else if(b>=len*a){
        lena=0 ;
        lenb=a+b ;
      }
      else {
        lena=(len*a-b)/(len-1);
        lenb=(len*b-a)/(len-1);
      }
      boolean B=a-lena+lena/(len+1)-lenb/(len+1)==0 ;
      for(long i=l-1 ; i<r ; ++i){
        char pc ;
        if(i<lena){
          if(i %(len+1)==len)pc='B' ;
          else pc='A' ;
        }
        else if(i>=a+b-lenb){
          if((a+b-i-1)%(len+1)!=len)pc='B' ;
          else pc='A' ;
        }
        else if(B)pc='B' ;
        else pc='A' ;
        System.out.print(pc);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var Tests : int ; Tests := sc.getCurrent()->toInteger() ;
         var test : int ; test := 0 ; while test < Tests do ( (     var a : long ; a := sc.getCurrent()->toInteger() ;
     var b : long ; b := sc.getCurrent()->toInteger() ;
    var l : long ; l := sc.getCurrent()->toInteger() ;
    var r : long ; r := sc.getCurrent()->toInteger() ;
    var len : long ; len := (Set{a, b}->max() - 1) / (Set{a, b}->min() + 1) + 1 ;
    var lena : long ;
    var lenb : long ;
    if (a >= len * b) then (     lena := a + b ; 
     lenb := 0 ) else     if (b >= len * a) then (     lena := 0 ; 
     lenb := a + b ) else (     lena := (len * a - b) / (len - 1) ; 
     lenb := (len * b - a) / (len - 1) ) ;  ;  
    var B : boolean ; B := a - lena + lena / (len + 1) - lenb / (len + 1) = 0 ;
        var i : long ; i := l - 1 ; while i < r do ( (     var pc : String ;
     if (i < lena) then (     if (i mod (len + 1) = len) then     pc := 'B' ; else     pc := 'A' ; ) else     if (i >= a + b - lenb) then (     if ((a + b - i - 1) mod (len + 1) /= len) then     pc := 'B' ; else     pc := 'A' ; ) else     if (B) then     pc := 'B' else     pc := 'A' ; ;  ;  ;  
     OclFile["System.out"].print(pc) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     test := test + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int Q=scan.nextInt();
    while(Q-->0){
      long A=scan.nextLong();
      long B=scan.nextLong();
      long k=(A+B)/(Math.min(A,B)+1);
      if(k<=1){
        int C=scan.nextInt()-1 ;
        int D=scan.nextInt()-1 ;
        String even=(A>=B ? "A" : "B");
        String odd=(A>=B ? "B" : "A");
        String ans="" ;
        for(int i=C ; i<=D ; ++i){
          if(i % 2==0)ans+=even ;
          else ans+=odd ;
        }
        System.out.println(ans);
        continue ;
      }
      long n=(k*A-B)/(k*k-1);
      long m=(k*B-A)/(k*k-1);
      long a=A-n*k-m ;
      long b=B-m*k-n ;
      int C=scan.nextInt()-1 ;
      int D=scan.nextInt()-1 ;
      String ans="" ;
      for(int i=C ; i<=D ; ++i){
        if(i<n*(k+1)){
          if((i+1)%(k+1)==0)ans+="B" ;
          else ans+="A" ;
        }
        else if(i>=n*(k+1)+a+b){
          long index=i-(n*(k+1))-a-b ;
          if(index %(k+1)==0)ans+="A" ;
          else ans+="B" ;
        }
        else {
          long index=i-n*(k+1);
          if(index<a)ans+="A" ;
          else ans+="B" ;
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var Q : int ; Q := scan.getCurrent()->toInteger() ;
         while (Q > 0) do (        Q := Q - 1 ;     skip ; (     var A : long ; A := scan.getCurrent()->toLong() ;
     var B : long ; B := scan.getCurrent()->toLong() ;
    var k : long ; k := (A + B) / (Set{A, B}->min() + 1) ;
    if (k <= 1) then (     var C : int ; C := scan.getCurrent()->toInteger() - 1 ;
     var D : int ; D := scan.getCurrent()->toInteger() - 1 ;
    var even : String ; even := (if A >= B then "A" else "B" endif) ;
    var odd : String ; odd := (if A >= B then "B" else "A" endif) ;
    var ans : String ; ans := "" ;
        var i : int ; i := C ; while i <= D do ( (     if (i mod 2 = 0) then     ans := ans+(even) ; else     ans := ans+(odd) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    continue 
 ) else skip ; 
    var n : long ; n := (k * A - B) / (k * k - 1) ;
    var m : long ; m := (k * B - A) / (k * k - 1) ;
    var a : long ; a := A - n * k - m ;
    var b : long ; b := B - m * k - n ;
    var C : int ; C := scan.getCurrent()->toInteger() - 1 ;
    var D : int ; D := scan.getCurrent()->toInteger() - 1 ;
    var ans : String ; ans := "" ;
        var i : int ; i := C ; while i <= D do ( (     if (i < n * (k + 1)) then (     if ((i + 1) mod (k + 1) = 0) then     ans := ans+("B") ; else     ans := ans+("A") ; ) else     if (i >= n * (k + 1) + a + b) then (     var index : long ; index := (i)->char2byte() - (n * (k + 1)) - a - b ;
     if (index mod (k + 1) = 0) then     ans := ans+("A") ; else     ans := ans+("B") ; ) else (     var index : long ; index := (i)->char2byte() - n * (k + 1) ;
     if (index < a) then     ans := ans+("A") ; else     ans := ans+("B") ; ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class boredom {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    long[] a=new long[100001];
    for(int i=0 ; i<n ; i++){
      int x=s.nextInt();
      a[x]+=x ;
    }
    for(int i=2 ; i<100001 ; i++){
      a[i]=Math.max(a[i]+a[i-2],a[i-1]);
    }
    System.out.println(a[100000]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class boredom {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,100001)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := s.getCurrent()->toInteger() ;
     a[x+1] := a[x+1]+(x) )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i < 100001 do ( (     a[i+1] := Set{a[i+1] + a[i - 2+1], a[i - 1+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a[100000+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    int testCases=1 ;
    while(testCases>0){
      int n=Integer.parseInt(bufferedReader.readLine());
      int[] arr=new int[n];
      String arrLine=bufferedReader.readLine();
      String[] arrLineParts=arrLine.split(" ");
      int i,maxEle=-1 ;
      for(i=0 ; i<arrLineParts.length ; i++){
        arr[i]=Integer.parseInt(arrLineParts[i]);
        maxEle=Math.max(maxEle,arr[i]);
      }
      long[] cnt=new long[maxEle+1];
      long[] ans=new long[maxEle+1];
      for(i=0 ; i<n ; i++){
        cnt[arr[i] ]++;
      }
      ans[0]=0 ;
      ans[1]=cnt[1];
      for(i=2 ; i<=maxEle ; i++){
        ans[i]=Math.max(ans[i-1],ans[i-2]+i*cnt[i]);
      }
      System.out.println(ans[maxEle]);
      testCases--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var testCases : int ; testCases := 1 ;
     while (testCases > 0) do (     var n : int ; n := (bufferedReader.readLine())->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var arrLine : String ; arrLine := bufferedReader.readLine() ;
    var arrLineParts : Sequence(String) ; arrLineParts := arrLine->split(" ") ;
    var i : int ;
    var maxEle : int ; maxEle := -1 ;
        i := 0 ; while i < arrLineParts->size() do ( (     arr[i+1] := (arrLineParts[i+1])->toInteger() ; 
     maxEle := Set{maxEle, arr[i+1]}->max() )  ;     i := i + 1 ) ; 
    var cnt : Sequence(long) ; cnt := Integer.subrange(1,maxEle + 1)->collect(0) ;
    var ans : Sequence(long) ; ans := Integer.subrange(1,maxEle + 1)->collect(0) ;
        i := 0 ; while i < n do ( (     cnt[arr[i+1]+1] := cnt[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    ans[0+1] := 0 ; 
    ans[1+1] := cnt[1+1] ; 
        i := 2 ; while i <= maxEle do ( (     ans[i+1] := Set{ans[i - 1+1], ans[i - 2+1] + i * cnt[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans[maxEle+1]) ; 
    testCases := testCases - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    int testCases=1 ;
    while(testCases>0){
      int n=Integer.parseInt(bufferedReader.readLine());
      int[] arr=new int[n];
      String arrLine=bufferedReader.readLine();
      String[] arrLineParts=arrLine.split(" ");
      int i,maxEle=-1 ;
      for(i=0 ; i<arrLineParts.length ; i++){
        arr[i]=Integer.parseInt(arrLineParts[i]);
        maxEle=Math.max(maxEle,arr[i]);
      }
      int[] cnt=new int[maxEle+1];
      long[] ans=new long[maxEle+1];
      for(i=0 ; i<n ; i++){
        cnt[arr[i] ]++;
      }
      ans[0]=0 ;
      ans[1]=cnt[1];
      for(i=2 ; i<=maxEle ; i++){
        ans[i]=Math.max(ans[i-1],ans[i-2]+i*(long)cnt[i]);
      }
      System.out.println(ans[maxEle]);
      testCases--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var testCases : int ; testCases := 1 ;
     while (testCases > 0) do (     var n : int ; n := (bufferedReader.readLine())->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var arrLine : String ; arrLine := bufferedReader.readLine() ;
    var arrLineParts : Sequence(String) ; arrLineParts := arrLine->split(" ") ;
    var i : int ;
    var maxEle : int ; maxEle := -1 ;
        i := 0 ; while i < arrLineParts->size() do ( (     arr[i+1] := (arrLineParts[i+1])->toInteger() ; 
     maxEle := Set{maxEle, arr[i+1]}->max() )  ;     i := i + 1 ) ; 
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,maxEle + 1)->collect(0) ;
    var ans : Sequence(long) ; ans := Integer.subrange(1,maxEle + 1)->collect(0) ;
        i := 0 ; while i < n do ( (     cnt[arr[i+1]+1] := cnt[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    ans[0+1] := 0 ; 
    ans[1+1] := cnt[1+1] ; 
        i := 2 ; while i <= maxEle do ( (     ans[i+1] := Set{ans[i - 1+1], ans[i - 2+1] + i * cnt[i+1]->oclAsType(long)}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans[maxEle+1]) ; 
    testCases := testCases - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
import java.util.Arrays ;
public class codeforces {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] temp=new long[100001];
    ArrayList<Integer>b=new ArrayList();
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      temp[x]+=x ;
    }
    for(int i=2 ; i<100001 ; i++){
      temp[i]=Math.max(temp[i-1],temp[i-2]+temp[i]);
    }
    System.out.println(temp[100000]);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var temp : Sequence(long) ; temp := Integer.subrange(1,100001)->collect(0) ;
    var b : Sequence(int) ; b := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     temp[x+1] := temp[x+1]+(x) )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i < 100001 do ( (     temp[i+1] := Set{temp[i - 1+1], temp[i - 2+1] + temp[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(temp[100000+1]) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class cf455A {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    int n=Integer.parseInt(br.readLine());
    StringTokenizer st=new StringTokenizer(br.readLine());
    long[] sums=new long[100001];
    for(int i=0 ; i<n ; i++){
      int next=Integer.parseInt(st.nextToken());
      sums[next]+=next ;
    }
    long[][] dp=new long[2][100001];
    for(int i=1 ; i<100001 ; i++){
      dp[0][i]=dp[1][i-1]+sums[i];
      dp[1][i]=Math.max(dp[0][i-1],dp[1][i-1]);
    }
    bw.write(Math.max(dp[0][100000],dp[1][100000])+"\n");
    bw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf455A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var sums : Sequence(long) ; sums := Integer.subrange(1,100001)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var next : int ; next := (st.next())->toInteger() ;
     sums[next+1] := sums[next+1]+(next) )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,100001)->collect(0)) ;
        var i : int ; i := 1 ; while i < 100001 do ( (     dp[0+1][i+1] := dp[1+1][i - 1+1] + sums[i+1] ; 
     dp[1+1][i+1] := Set{dp[0+1][i - 1+1], dp[1+1][i - 1+1]}->max() )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A257 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int k=sc.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    for(int i=0 ; i<n-1 ; i++){
      int max=a[i];
      int pos=i ;
      for(int j=i+1 ; j<n ; j++){
        if(a[j]>max){
          max=a[j];
          pos=j ;
        }
      }
      int temp=a[pos];
      a[pos]=a[i];
      a[i]=temp ;
    }
    int count=0 ;
    int flag=0 ;
    while(m>k){
      if(count==n){
        flag=1 ;
        break ;
      }
      k+=a[count]-1 ;
      count++;
    }
    if(flag==1){
      System.out.println("-1");
    }
    else {
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A257 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var max : int ; max := a[i+1] ;
     var pos : int ; pos := i ;
        var j : int ; j := i + 1 ; while j < n do ( (     if (a[j+1] > max) then (     max := a[j+1] ; 
     pos := j ) else skip )  ;     j := j + 1 ) ; 
    var temp : int ; temp := a[pos+1] ;
    a[pos+1] := a[i+1] ; 
    a[i+1] := temp ; 
 )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var flag : int ; flag := 0 ;
    while (m > k) do (     if (count = n) then (     flag := 1 ; 
     break ) else skip ; 
     k := k+(a[count+1] - 1) ; 
     count := count + 1 ) ; 
    if (flag = 1) then (     OclFile["System.out"].println("-1") ) else (     OclFile["System.out"].println(count) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static String nextWord(String str){
    if(str=="")return "a" ;
    int i=str.length()-1 ;
    while(str.charAt(i)=='z' && i>=0)i--;
    if(i==-1)str=str+'a' ;
    else str=str.substring(0,i)+(char)((int)(str.charAt(i))+1)+str.substring(i+1);
    return str ;
  }
  public static void main(String[] args){
    String str="samez" ;
    System.out.print(nextWord(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nextWord( str : String) : String
  pre: true
  post: true
  activity: (     if (str = "") then     return "a" else skip ; 
     var i : int ; i := str->size() - 1 ;
    while (str->at(i+1) = 'z' & i >= 0) do     i := i - 1 ; ; 
    if (i = -1) then     str := str + 'a' else     str := str.subrange(0+1,i) + ((str->at(i+1))->oclAsType(int) + 1)->oclAsType(String) + str.subrange(i + 1+1,i + 1) ; ;  
    return str 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "samez" ;
     OclFile["System.out"].print(nextWord(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector ;
class GFG {
  static int getsum(int a){
    int r=0,sum=0 ;
    while(a>0){
      r=a % 10 ;
      sum=sum+r ;
      a=a/10 ;
    }
    return sum ;
  }
  static void value(int a,int b,int c){
    int co=0,p=0 ;
    int no,r=0,x=0,q=0,w=0 ;
    Vector<Integer>v=new Vector<Integer>();
    for(int i=1 ; i<82 ; i++){
      no=(int)Math.pow(i,a);
      no=b*no+c ;
      if(no>0 && no<1000000000){
        x=getsum(no);
        if(x==i){
          q++;
          v.add(no);
          w++;
        }
      }
    }
    for(int i=0 ; i<v.size(); i++){
      System.out.print(v.get(i)+" ");
    }
  }
  public static void main(String[] args){
    int a=2,b=2,c=-1 ;
    value(a,b,c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getsum( a : int) : int
  pre: true
  post: true
  activity: (     var r : int ; r := 0 ;
    var sum : int ; sum := 0 ;
     while (a > 0) do (     r := a mod 10 ; 
     sum := sum + r ; 
     a := a / 10 ) ; 
     return sum );
  static   operation value( a : int, b : int, c : int) : void
  pre: true
  post: true
  activity: (     var co : int ; co := 0 ;
    var p : int ; p := 0 ;
     var no : int ;
    var r : int ; r := 0 ;
    var x : int ; x := 0 ;
    var q : int ; q := 0 ;
    var w : int ; w := 0 ;
    var v : Sequence(int) ; v := Sequence{} ;
        var i : int ; i := 1 ; while i < 82 do ( (     no := i->pow(a)->oclAsType(int) ; 
     no := b * no + c ; 
     if (no > 0 & no < 1000000000) then (     x := getsum(no) ; 
     if (x = i) then (     q := q + 1 ; 
     v := v->including(no) ; 
     w := w + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < v->size() do ( (     OclFile["System.out"].print(v->at(i+1) + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2 ;
    var b : int ; b := 2 ;
    var c : int ; c := -1 ;
     execute value(a, b, c) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Constructive20 {
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    for(int i=0 ; i<T ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int n=sc.nextInt();
      Object result=getOps(a,b,n);
      System.out.println(result);
    }
  }
  public static Object getOps(int a,int b,int n){
    int count=0 ;
    if(a>n || b>n){
      return 0 ;
    }
    while(true){
      if(a>b){
        b+=a ;
      }
      else {
        a+=b ;
      }
      count++;
      if(a>n || b>n){
        break ;
      }
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Constructive20 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < T do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var result : OclAny ; result := getOps(a, b, n) ;
    OclFile["System.out"].println(result) ; 
 )  ;     i := i + 1 ) );
  static   operation getOps( a : int, b : int, n : int) : OclAny
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     if (a > n or b > n) then (     return 0 ) else skip ; 
     while (true) do (     if (a > b) then (     b := b+(a) ) else (     a := a+(b) ) ;  
     count := count + 1 ; 
     if (a > n or b > n) then (     break ) else skip ) ; 
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class _20_1368A {
  public static void main(String[] args){
    Scanner test=new Scanner(System.in);
    long t=test.nextInt();
    while(t>0){
      long a=test.nextLong();
      long b=test.nextLong();
      long n=test.nextLong();
      if(a>=b)System.out.println(calculate(a,b,n));
      else System.out.println(calculate(b,a,n));
      t--;
    }
  }
  private static long calculate(long a,long b,long n){
    long count=0 ;
    while(a<=n){
      long res=a+b ;
      b=a ;
      a=res ;
      count++;
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var test : OclFile ; test := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : long ; t := test.getCurrent()->toInteger() ;
     while (t > 0) do (     var a : long ; a := test.getCurrent()->toLong() ;
     var b : long ; b := test.getCurrent()->toLong() ;
    var n : long ; n := test.getCurrent()->toLong() ;
    if (a >= b) then     OclFile["System.out"].println(calculate(a, b, n)) else     OclFile["System.out"].println(calculate(b, a, n)) ; ;  
    t := t - 1 ; 
 ) );
  static   operation calculate( a : long, b : long, n : long) : long
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
     while (a <= n) do (     var res : long ; res := a + b ;
     b := a ; 
     a := res ; 
     count := count + 1 ) ; 
     return count );
}
0_1368A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var test : OclFile ; test := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : long ; t := test.getCurrent()->toInteger() ;
     while (t > 0) do (     var a : long ; a := test.getCurrent()->toLong() ;
     var b : long ; b := test.getCurrent()->toLong() ;
    var n : long ; n := test.getCurrent()->toLong() ;
    if (a >= b) then     OclFile["System.out"].println(calculate(a, b, n)) else     OclFile["System.out"].println(calculate(b, a, n)) ; ;  
    t := t - 1 ; 
 ) );
  static   operation calculate( a : long, b : long, n : long) : long
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
     while (a <= n) do (     var res : long ; res := a + b ;
     b := a ; 
     a := res ; 
     count := count + 1 ) ; 
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class c20 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int ans[]=new int[t];
    for(int i=0 ; i<t ; i++){
      long a=sc.nextLong();
      long b=sc.nextLong();
      long n=sc.nextLong();
      int count=0 ;
      while(true){
        if(a<b){
          a+=b ;
        }
        else {
          b+=a ;
        }
        count++;
        if(a>n || b>n)break ;
      }
      ans[i]=count ;
    }
    for(int i=0 ; i<t ; i++){
      System.out.println(ans[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class c20 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,t)->collect(0) ;
        var i : int ; i := 0 ; while i < t do ( (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
    var n : long ; n := sc.getCurrent()->toLong() ;
    var count : int ; count := 0 ;
    while (true) do (     if (a < b) then (     a := a+(b) ) else (     b := b+(a) ) ;  
     count := count + 1 ; 
     if (a > n or b > n) then     break else skip ) ; 
    ans[i+1] := count ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < t do ( (     OclFile["System.out"].println(ans[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CPlusEqual {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int tests=scn.nextInt();
    for(int t=0 ; t<tests ; t++){
      int a=scn.nextInt();
      int b=scn.nextInt();
      int n=scn.nextInt();
      int count=0 ;
      while(a<=n && b<=n){
        int c=a+b ;
        if(a<b){
          a=c ;
        }
        else {
          b=c ;
        }
        count++;
      }
      System.out.println(count);
    }
    scn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CPlusEqual {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tests : int ; tests := scn.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < tests do ( (     var a : int ; a := scn.getCurrent()->toInteger() ;
     var b : int ; b := scn.getCurrent()->toInteger() ;
    var n : int ; n := scn.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    while (a <= n & b <= n) do (     var c : int ; c := a + b ;
     if (a < b) then (     a := c ) else (     b := c ) ;  
     count := count + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )  ;     t := t + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int maxUniqueNum(int arr[],int N,int M){
    int maxUnique=0 ;
    for(int i=0 ; i<N-M ; i++){
      int currentUnique=0 ;
      HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();
      for(int k=i ; k<i+M ; k++){
        if(! map.containsKey(arr[k])){
          map.put(arr[i],1);
          currentUnique++;
          continue ;
        }
      }
      if(currentUnique>maxUnique)maxUnique=currentUnique ;
    }
    return maxUnique ;
  }
  public static void main(String[] args){
    int[] arr={
      5,3,5,2,3,2 };
      int N=6 ;
      int M=3 ;
      System.out.println(maxUniqueNum(arr,N,M));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxUniqueNum( arr : Sequence(int), N : int, M : int) : int
  pre: true
  post: true
  activity: (     var maxUnique : int ; maxUnique := 0 ;
         var i : int ; i := 0 ; while i < N - M do ( (     var currentUnique : int ; currentUnique := 0 ;
     var map : Map(int,int) ; map := Map{} ;
         var k : int ; k := i ; while k < i + M do ( (     if (not(map->keys()->includes(arr[k+1]))) then (     map := map->union(Map{arr[i+1] |-> 1}) ; 
     currentUnique := currentUnique + 1 ; 
     continue ) else skip )  ;     k := k + 1 ) ; 
     if (currentUnique > maxUnique) then     maxUnique := currentUnique ; else skip )  ;     i := i + 1 ) ; 
     return maxUnique );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,3,5,2,3,2} ;
     var N : int ; N := 6 ;
     var M : int ; M := 3 ;
     OclFile["System.out"].println(maxUniqueNum(arr, N, M)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  static final PrintStream out=System.out ;
  static final Scanner sc=new Scanner(System.in);
  static final long Mod=1000_000_007L ;
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
    System.exit(0);
  }
  void solve(){
    int a=nextInt();
    String s=next();
    out.println(a<3200 ? "red" : s);
  }
  public int[] nextIntArray(int n){
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public long[] nextLongArray(int n){
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=nextLong();
    return a ;
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
  public String next(){
    return sc.next();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute out : OclFile := OclFile["System.out"];
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute Mod : long := 1000_000_007L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() ; 
 OclProcess.exit(0) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ; a := nextInt() ;
     var s : String ; s := next() ;
     skip );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation next() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int a=in.nextInt();
      String s=in.next();
      if(a>=3200)out.println(s);
      else out.println("red");
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.nextInt() ;
     var s : String ; s := in.next() ;
     if (a >= 3200) then     skip ; else     skip ; );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.function.DoubleToIntFunction ;
public class Main {
  public static boolean debug=true ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    String s=sc.next();
    if(a>=3200){
      System.out.println(s);
    }
    else {
      System.out.println("red");
    }
  }
  public static void d(String message){
    if(debug){
      System.out.println(message);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := true;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
     if (a >= 3200) then (     OclFile["System.out"].println(s) ) else (     OclFile["System.out"].println("red") ) );
  static   operation d( message : String) : void
  pre: true
  post: true
  activity: (     if (debug) then (     OclFile["System.out"].println(message) ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedOutputStream ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.StringTokenizer ;
public class Practice1 {
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    int m=sc.nextInt();
    int k=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      arr[i]--;
    }
    Arrays.sort(arr);
    if(m<=k){
      System.out.println("0");
    }
    else {
      int count=0 ;
      m-=k ;
      for(int i=n-1 ; i>=0 ; i--){
        m-=arr[i];
        count++;
        if(m<=0)break ;
      }
      if(m<=0){
        System.out.println(count);
      }
      else {
        System.out.println("-1");
      }
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : int ; n := sc.nextInt() ;
    var m : int ; m := sc.nextInt() ;
    var k : int ; k := sc.nextInt() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.nextInt() ; 
     arr[i+1] := arr[i+1] - 1 )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    if (m <= k) then (     OclFile["System.out"].println("0") ) else (     var count : int ; count := 0 ;
     m := m-(k) ; 
         var i : int ; i := n - 1 ; while i >= 0 do ( (     m := m-(arr[i+1]) ; 
     count := count + 1 ; 
     if (m <= 0) then     break else skip )  ;     i := i - 1 ) ; 
     if (m <= 0) then (     OclFile["System.out"].println(count) ) else (     OclFile["System.out"].println("-1") ) ) ;  
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    MyReader r=new MyReader();
    int a=r.i();
    String s=r.s();
    println(a>=3200 ? s : "red");
  }
  static void print(Object o){
    System.out.print(o.toString());
  }
  static void println(Object o){
    System.out.println(o.toString());
  }
  static int Int(String s){
    return Integer.parseInt(s);
  }
  static long Long(String s){
    return Long.parseLong(s);
  }
  static class MyReader extends BufferedReader {
    MyReader(){
      super(new InputStreamReader(System.in));
    }
    String s()throws IOException {
      return readLine();
    }
    String[] ss()throws IOException {
      return s().split(" ");
    }
    int i()throws IOException {
      return Int(s());
    }
    int[] ii()throws IOException {
      String[] ss=ss();
      int size=ss.length ;
      int[] ii=new int[size];
      for(int j=0 ; j<size ; j++)ii[j]=Integer.parseInt(ss[j]);
      return ii ;
    }
    long l()throws IOException {
      return Long(s());
    }
    long[] ll()throws IOException {
      String[] ss=ss();
      int size=ss.length ;
      long[] ll=new long[size];
      for(int j=0 ; j<size ; j++)ll[j]=Long.parseLong(ss[j]);
      return ll ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : MyReader ; r := MyReader.newMyReader() ;
     var a : int ; a := r.i() ;
     var s : String ; s := r.s() ;
     execute println(if a >= 3200 then s else "red" endif) );
  static   operation print( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o+"") );
  static   operation println( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o+"") );
  static   operation Int( s : String) : int
  pre: true
  post: true
  activity: (     return (s)->toInteger() );
  static   operation Long( s : String) : long
  pre: true
  post: true
  activity: (     return (s)->toLong() );
  static class MyReader extends OclFile {
   static operation newMyReader() : MyReader
  pre: true
  post: true
  activity:
  ( var self : MyReader ;
    self := createMyReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation s() : String
  pre: true
  post: true
  activity: (     return readLine() );
   operation ss() : Sequence(String)
  pre: true
  post: true
  activity: (     return s()->split(" ") );
   operation i() : int
  pre: true
  post: true
  activity: (     return Int(s()) );
   operation ii() : Sequence(int)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var size : int ; size := ss->size() ;
    var ii : Sequence(int) ; ii := Integer.subrange(1,size)->collect(0) ;
        var j : int ; j := 0 ; while j < size do (     ii[j+1] := (ss[j+1])->toInteger() ;  ;     j := j + 1 ) ; 
    return ii 
 );
   operation l() : long
  pre: true
  post: true
  activity: (     return Long(s()) );
   operation ll() : Sequence(long)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var size : int ; size := ss->size() ;
    var ll : Sequence(long) ; ll := Integer.subrange(1,size)->collect(0) ;
        var j : int ; j := 0 ; while j < size do (     ll[j+1] := (ss[j+1])->toLong() ;  ;     j := j + 1 ) ; 
    return ll 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.concurrent.SynchronousQueue ;
class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    if(A<=B){
      System.out.println("Impossible");
      return ;
    }
    ArrayDeque<Integer>stack=new ArrayDeque<>();
    stack.add(0);
    int Asz=A ;
    int Bsz=B ;
    for(int i=1 ; stack.size()<=Bsz ; ++i){
      if(! stack.isEmpty())System.out.println("? "+stack.getFirst()+" "+i);
      else {
        stack.addFirst(i);
        continue ;
      }
      String s=sc.next();
      if(s.equals("Y")){
        stack.addFirst(i);
      }
      else {
--Bsz ;
        stack.removeFirst();
      }
    }
    int ori=stack.getFirst();
    boolean[] beHonest=new boolean[A+B];
    beHonest[ori]=true ;
    for(int i=0 ; i<A+B ; ++i){
      if(i==ori)continue ;
      System.out.println("? "+ori+" "+i);
      String s=sc.next();
      if(s.equals("Y")){
        beHonest[i]=true ;
      }
    }
    StringBuilder ans=new StringBuilder();
    for(int i=0 ; i<A+B ; ++i){
      if(beHonest[i]){
        ans.append("1");
      }
      else {
        ans.append("0");
      }
    }
    System.out.println("! "+ans);
  }
  void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    if (A <= B) then (     OclFile["System.out"].println("Impossible") ; 
     return ) else skip ; 
    var stack : Sequence(int) ; stack := ArrayDeque<OclAny>.newArrayDeque() ;
    stack := stack->including(0) ; 
    var Asz : int ; Asz := A ;
    var Bsz : int ; Bsz := B ;
        var i : int ; i := 1 ; while stack->size() <= Bsz do ( (     if (not(stack->isEmpty())) then     OclFile["System.out"].println("? " + stack->first() + " " + i) else (     stack := stack->prepend(i) ; 
     continue ) ;  
     var s : String ; s := sc.getCurrent() ;
     if (s = "Y") then (     stack := stack->prepend(i) ) else (     Bsz := Bsz - 1 ; 
     stack := stack->tail() ) )  ;     i := i + 1 ) ; 
    var ori : int ; ori := stack->first() ;
    var beHonest : Sequence(boolean) ; beHonest := Integer.subrange(1,A + B)->collect(false) ;
    beHonest[ori+1] := true ; 
        var i : int ; i := 0 ; while i < A + B do ( (     if (i = ori) then     continue else skip ; 
     OclFile["System.out"].println("? " + ori + " " + i) ; 
     var s : String ; s := sc.getCurrent() ;
     if (s = "Y") then (     beHonest[i+1] := true ) else skip )  ;     i := i + 1 ) ; 
    var ans : String ; ans := StringLib.newString() ;
        var i : int ; i := 0 ; while i < A + B do ( (     if (beHonest[i+1]) then (     ans := ans + StringLib.newString("1") ) else (     ans := ans + StringLib.newString("0") ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("! " + ans) ; 
 );
   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ARedOrNot solver=new ARedOrNot();
    solver.solve(1,in,out);
    out.close();
  }
  static class ARedOrNot {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int a=in.nextInt();
      String clr=in.nextLine();
      String s=in.nextLine();
      out.println(a<3200 ? "red" : s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ARedOrNot ; solver := ARedOrNot.newARedOrNot() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ARedOrNot {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.getCurrent()->toInteger() ;
     var clr : String ; clr := in.nextLine() ;
     var s : String ; s := in.nextLine() ;
     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    DoubleFactorial solver=new DoubleFactorial();
    solver.solve(1,in,out);
    out.close();
  }
  static class DoubleFactorial {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      long n=in.nextLong();
      if(n % 2==1){
        out.println(0);
        return ;
      }
      long result=0 ;
      int s=1 ;
      n/=2 ;
      while(true){
        long num=n/(long)Math.pow(5,s);
        s++;
        result+=num ;
        if(num==0){
          break ;
        }
      }
      out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : DoubleFactorial ; solver := DoubleFactorial.newDoubleFactorial() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class DoubleFactorial {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : long ; n := in.getCurrent()->toLong() ;
     if (n mod 2 = 1) then (     skip ; 
     return ) else skip ; 
    var result : long ; result := 0 ;
    var s : int ; s := 1 ;
    n := n/(2) ; 
    while (true) do (     var num : long ; num := n / 5->pow(s)->oclAsType(long) ;
     s := s + 1 ; 
     result := result+(num) ; 
     if (num = 0) then (     break ) else skip ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  final int MOD=1000000007 ;
  final int MAX=Integer.MAX_VALUE ;
  final long LMAX=Long.MAX_VALUE ;
  long LEN=(long)1e18 ;
  void doIt(){
    long n=sc.nextLong();
    if(n % 2!=0){
      System.out.println(0);
      return ;
    }
    long cnt=0 ;
    long base=5 ;
    while(base<=n){
      cnt+=n/base/2 ;
      if(base>LEN/5)break ;
      base*=5 ;
    }
    System.out.println(cnt);
  }
  long gcd(long a,long b){
    return(b!=0)? gcd(b,a % b): a ;
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute MOD : int := 1000000007;
   attribute MAX : int := 2147483647;
   attribute LMAX : long := "9223372036854775807"->toLong();
   attribute LEN : long := 1e18->oclAsType(long);
   operation doIt() : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.getCurrent()->toLong() ;
     if (n mod 2 /= 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var cnt : long ; cnt := 0 ;
    var base : long ; base := 5 ;
    while (base <= n) do (     cnt := cnt+(n / base / 2) ; 
     if (base > LEN / 5) then     break else skip ; 
     base := base*(5) ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return if (b /= 0) then gcd(b, a mod b) else a endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    System.out.println(solve(n));
  }
  public static long solve(long n){
    if(n % 2!=0 || n<10){
      return 0 ;
    }
    long ret=0 ;
    int i=0 ;
    while(10*Math.pow(5,i)<=n){
      long def=10*(long)Math.pow(5,i);
      ret+=n/def ;
      i++;
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println(solve(n)) );
  static   operation solve( n : long) : long
  pre: true
  post: true
  activity: (     if (n mod 2 /= 0 or n < 10) then (     return 0 ) else skip ; 
     var ret : long ; ret := 0 ;
    var i : int ; i := 0 ;
    while (10 * 5->pow(i) <= n) do (     var def : long ; def := 10 * 5->pow(i)->oclAsType(long) ;
     ret := ret+(n / def) ; 
     i := i + 1 ) ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    sc.close();
    long count=0 ;
    if(n % 2==0){
      for(int i=0 ; i<25 ; i++){
        count+=(n/(long)(Math.pow(5,i+1)*2));
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    skip ; 
    var count : long ; count := 0 ;
    if (n mod 2 = 0) then (         var i : int ; i := 0 ; while i < 25 do ( (     count := count+((n / (5->pow(i + 1) * 2)->oclAsType(long))) )  ;     i := i + 1 ) ) else skip ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static private Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    long n=sc.nextLong();
    if(n % 2==1){
      System.out.println(0);
      return ;
    }
    long ans=0 ;
    for(long num=10 ; num<=n ; num*=5){
      ans+=n/num ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.getCurrent()->toLong() ;
     if (n mod 2 = 1) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var ans : long ; ans := 0 ;
        var num : long ; num := 10 ; while num <= n do ( (     ans := ans+(n / num) )  ;     num := num*(5) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class XXXXX {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int x=sc.nextInt();
      int si=-1,ei=-1 ;
      long sum=0 ;
      boolean flag=true ;
      for(int i=0 ; i<n ; i++){
        int num=sc.nextInt();
        sum+=num ;
        if(num % x!=0){
          if(flag){
            si=i ;
            flag=false ;
          }
          ei=i ;
        }
      }
      if(sum % x!=0){
        System.out.println(n);
      }
      else if(si==-1 || ei==-1){
        System.out.println(-1);
      }
      else {
        System.out.println(Math.max(n-si-1,ei));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class XXXXX {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var si : int ; si := -1 ;
    var ei : int ; ei := -1 ;
    var sum : long ; sum := 0 ;
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := sc.getCurrent()->toInteger() ;
     sum := sum+(num) ; 
     if (num mod x /= 0) then (     if (flag) then (     si := i ; 
     flag := false ) else skip ; 
     ei := i ) else skip )  ;     i := i + 1 ) ; 
    if (sum mod x /= 0) then (     OclFile["System.out"].println(n) ) else     if (si = -1 or ei = -1) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(Set{n - si - 1, ei}->max()) ) ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int a=1 ; a<=t ; a++){
      int n=sc.nextInt();
      int x=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      int max=0 ;
      int[] prefixSumRem=new int[n];
      prefixSumRem[0]=arr[0] % x ;
      int[] suffixSumRem=new int[n];
      suffixSumRem[n-1]=arr[n-1] % x ;
      for(int i=1,j=n-2 ; i<n ; i++,j--){
        prefixSumRem[i]=(prefixSumRem[i-1]+arr[i])% x ;
        suffixSumRem[j]=(suffixSumRem[j+1]+arr[j])% x ;
      }
      for(int i=0 ; i<n ; i++){
        if(prefixSumRem[n-i-1]!=0 || suffixSumRem[i]!=0){
          max=n-i ;
          break ;
        }
      }
      System.out.println((max>0 ? max :-1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var a : int ; a := 1 ; while a <= t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var prefixSumRem : Sequence(int) ; prefixSumRem := Integer.subrange(1,n)->collect(0) ;
    prefixSumRem[0+1] := arr[0+1] mod x ; 
    var suffixSumRem : Sequence(int) ; suffixSumRem := Integer.subrange(1,n)->collect(0) ;
    suffixSumRem[n - 1+1] := arr[n - 1+1] mod x ; 
        var i : int ; i := 1 ;
    var j : int ; j := n - 2 ; while i < n do ( (     prefixSumRem[i+1] := (prefixSumRem[i - 1+1] + arr[i+1]) mod x ; 
     suffixSumRem[j+1] := (suffixSumRem[j + 1+1] + arr[j+1]) mod x )  ;     i := i + 1 ;     j := j - 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (prefixSumRem[n - i - 1+1] /= 0 or suffixSumRem[i+1] /= 0) then (     max := n - i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((if max > 0 then max else -1 endif)) ; 
 )  ;     a := a + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      t--;
      int n=sc.nextInt();
      int x=sc.nextInt();
      long sum=0 ;
      int l=-1 ;
      int r=0 ;
      for(int i=0 ; i<n ; i++){
        int a=sc.nextInt();
        sum+=a ;
        if(a % x!=0){
          if(l==-1){
            l=i ;
          }
          r=i ;
        }
      }
      if(sum % x!=0){
        System.out.println(n);
      }
      else if(l==-1){
        System.out.println(-1);
      }
      else {
        System.out.println(Math.max(n-l-1,r));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     t := t - 1 ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var sum : long ; sum := 0 ;
    var l : int ; l := -1 ;
    var r : int ; r := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     sum := sum+(a) ; 
     if (a mod x /= 0) then (     if (l = -1) then (     l := i ) else skip ; 
     r := i ) else skip )  ;     i := i + 1 ) ; 
    if (sum mod x /= 0) then (     OclFile["System.out"].println(n) ) else     if (l = -1) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(Set{n - l - 1, r}->max()) ) ;  ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String nthprimedigitsnumber(int number){
    int rem ;
    String num="" ;
    while(number>0){
      rem=number % 4 ;
      switch(rem){
        case 1 : num+='2' ;
        break ;
        case 2 : num+='3' ;
        break ;
        case 3 : num+='5' ;
        break ;
        case 0 : num+='7' ;
        break ;
      }
      if(number % 4==0)number--;
      number=number/4 ;
    }
    return new StringBuilder(num).reverse().toString();
  }
  public static void main(String[] args){
    int number=21 ;
    System.out.println(nthprimedigitsnumber(10));
    System.out.println(nthprimedigitsnumber(21));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nthprimedigitsnumber( number : int) : String
  pre: true
  post: true
  activity: (     var rem : int ;
     var num : String ; num := "" ;
     while (number > 0) do (     rem := number mod 4 ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (rem) ; 
       if _switchval = 1 then
     num := num+('2') ; 
    break 
   else skip ;
       if _switchval = 2 then
     num := num+('3') ; 
    break 
   else skip ;
       if _switchval = 3 then
     num := num+('5') ; 
    break 
   else skip ;
       if _switchval = 0 then
     num := num+('7') ; 
    break 
   else skip ;
 )
     if (number mod 4 = 0) then     number := number - 1 ; else skip ; 
     number := number / 4 ) ; 
     return StringLib.newString(num)->reverse()+"" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var number : int ; number := 21 ;
     OclFile["System.out"].println(nthprimedigitsnumber(10)) ; 
     OclFile["System.out"].println(nthprimedigitsnumber(21)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class one {
  public static void main(String[] args)throws IOException {
    BufferedReader xx=new BufferedReader(new InputStreamReader(System.in));
    String input1[]=xx.readLine().split(" ");
    int n=Integer.parseInt(input1[0]);
    int m=Integer.parseInt(input1[1]);
    String input2[]=xx.readLine().split(" ");
    String input3[]=xx.readLine().split(" ");
    int ans=0,sumn=0,summ=0 ;
    int in=0,im=0 ;
    while((in<n)&&(im<m)){
      int tempn=Integer.parseInt(input2[in])+sumn ;
      int tempm=Integer.parseInt(input3[im])+summ ;
      if(tempn==tempm){
++ans ;
++in ;
++im ;
        sumn=0 ;
        summ=0 ;
      }
      else if(tempn<tempm){
++in ;
        sumn=tempn ;
      }
      else {
++im ;
        summ=tempm ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class one {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var xx : OclFile ; xx := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input1 : Sequence(String) ; input1 := xx.readLine()->split(" ") ;
    var n : int ; n := (input1[0+1])->toInteger() ;
    var m : int ; m := (input1[1+1])->toInteger() ;
    var input2 : Sequence(String) ; input2 := xx.readLine()->split(" ") ;
    var input3 : Sequence(String) ; input3 := xx.readLine()->split(" ") ;
    var ans : int ; ans := 0 ;
    var sumn : int ; sumn := 0 ;
    var summ : int ; summ := 0 ;
    var in : int ; in := 0 ;
    var im : int ; im := 0 ;
    while ((in < n) & (im < m)) do (     var tempn : int ; tempn := (input2[in+1])->toInteger() + sumn ;
     var tempm : int ; tempm := (input3[im+1])->toInteger() + summ ;
     if (tempn = tempm) then (     ans := ans + 1 ; 
     in := in + 1 ; 
    im := im + 1 ; 
    sumn := 0 ; 
    summ := 0 ; 
 ) else     if (tempn < tempm) then (     in := in + 1 ; 
     sumn := tempn ) else (     im := im + 1 ; 
     summ := tempm ) ;  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner in ;
  static PrintWriter out ;
  static String INPUT="" ;
  static boolean get(int a,int b){
    out.println("? "+a+" "+b);
    out.flush();
    return in.next().charAt(0)=='Y' ;
  }
  static void solve(){
    int A=ni(),B=ni();
    if(A<=B){
      out.println("Impossible");
      return ;
    }
    int n=A+B ;
    int[] stack=new int[n];
    int sp=0 ;
    for(int i=0 ; i<n ; i++){
      stack[sp++]=i ;
      if(sp>=2){
        if(! get(stack[sp-2],stack[sp-1])){
          sp-=2 ;
        }
      }
    }
    assert sp-1>=0 ;
    int honest=stack[sp-1];
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      if(get(honest,i)){
        sb.append(1);
      }
      else {
        sb.append(0);
      }
    }
    out.print("! ");
    out.print(sb);
    out.println();
    out.flush();
  }
  public static void main(String[] args)throws Exception {
    in=INPUT.isEmpty()? new Scanner(System.in): new Scanner(INPUT);
    out=new PrintWriter(System.out);
    solve();
    out.flush();
  }
  static int ni(){
    return Integer.parseInt(in.next());
  }
  static long nl(){
    return Long.parseLong(in.next());
  }
  static double nd(){
    return Double.parseDouble(in.next());
  }
  static void tr(Object...o){
    if(INPUT.length()!=0)System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute INPUT : String := "";
  static   operation get( a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     skip ; 
     skip ; 
     return in.getCurrent()->at(0+1) = 'Y' );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var A : int ; A := ni() ;
    var B : int ; B := ni() ;
     if (A <= B) then (     skip ; 
     return ) else skip ; 
    var n : int ; n := A + B ;
    var stack : Sequence(int) ; stack := Integer.subrange(1,n)->collect(0) ;
    var sp : int ; sp := 0 ;
        var i : int ; i := 0 ; while i < n do ( (      stack[sp+1] := i  ; sp := sp + 1 ; 
     if (sp >= 2) then (     if (not(at(stack[sp - 2+1], stack[sp - 1+1]+1))) then (     sp := sp-(2) ) else skip ) else skip )  ;     i := i + 1 ) ; 
    assert sp - 1 >= 0 ; 
    var honest : int ; honest := stack[sp - 1+1] ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     if (at(honest, i+1)) then (     sb := sb + StringLib.newString(1) ) else (     sb := sb + StringLib.newString(0) ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := if INPUT->isEmpty() then OclFile.newOclFile_Read(OclFile["System.in"]) else OclFile.newOclFile_Read(OclFile.newOclFile(INPUT)) endif ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     execute solve() ; 
     skip );
  static   operation ni() : int
  pre: true
  post: true
  activity: (     return (in.getCurrent())->toInteger() );
  static   operation nl() : long
  pre: true
  post: true
  activity: (     return (in.getCurrent())->toLong() );
  static   operation nd() : double
  pre: true
  post: true
  activity: (     return (in.getCurrent())->toReal() );
  static   operation tr( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (INPUT->size() /= 0) then     OclFile["System.out"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  static Scanner scanner=new Scanner();
  static PrintWriter out=new PrintWriter(System.out);
  void solve(){
    int n=scanner.nextInt();
    char[][] s=new char[n][n*2];
    for(int i=0 ; i<n ; i++){
      String t=scanner.next();
      s[i]=(t+t).toCharArray();
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      boolean f=true ;
      for(int j=1 ; j<n ; j++){
        for(int k=0 ; k<j ; k++){
          f &=s[j][i+k]==s[k][i+j];
        }
      }
      if(f){
        count+=n ;
      }
    }
    System.out.println(count);
  }
  public static void main(String[] $){
    new Main().solve();
    out.close();
  }
  static class Scanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),32768);
    StringTokenizer tokenizer ;
    String next(){
      try {
        while(tokenizer==null || ! tokenizer.hasMoreTokens()){
          tokenizer=new StringTokenizer(reader.readLine());
        }
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := (arguments ( ));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var s : Sequence(Sequence(String)) ; s := Integer.subrange(1,n)->collect(Integer.subrange(1,n * 2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var t : String ; t := scanner.getCurrent() ;
     s[i+1] := (t + t)->characters() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var f : boolean ; f := true ;
         var j : int ; j := 1 ; while j < n do ( (         var k : int ; k := 0 ; while k < j do ( (     f := MathLib.bitwiseAnd(f, s[j+1][i + k+1] = s[k+1][i + j+1]) )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
     if (f) then (     count := count+(n) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() ; 
     skip );
  static class Scanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 32768);
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (e : IOException) do (     error ProgramException(e) )
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class Main {
  public void solve(BufferedReader stdin,PrintWriter stdout)throws NumberFormatException,IOException {
    int n=Integer.parseInt(stdin.readLine());
    char[][] s=new char[n][n];
    for(int i=0 ; i<n ; i++)s[i]=stdin.readLine().toCharArray();
    int a=0 ;
    int c=0 ;
    for(int b=0 ; b<n ; b++){
      char[][] t=new char[n][n];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          t[(i+a)% n][(j+b)% n]=s[i][j];
        }
      }
      if(ok(n,t))c++;
    }
    stdout.println(c*n);
  }
  private boolean ok(int n,char[][] s){
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(s[i][j]!=s[j][i])return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter stdout=new PrintWriter(System.out,false);
    new Main().solve(stdin,stdout);
    stdout.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve( stdin : OclFile, stdout : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (stdin.readLine())->toInteger() ;
     var s : Sequence(Sequence(String)) ; s := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do (     s[i+1] := stdin.readLine()->characters() ;  ;     i := i + 1 ) ; 
    var a : int ; a := 0 ;
    var c : int ; c := 0 ;
        var b : int ; b := 0 ; while b < n do ( (     var t : Sequence(Sequence(String)) ; t := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     t[(i + a) mod n+1][(j + b) mod n+1] := s[i+1][j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (ok(n, t)) then     c := c + 1 ; else skip )  ;     b := b + 1 ) ; 
    stdout.println(c * n) ; 
 );
   operation ok( n : int, s : Sequence(Sequence(String))) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (s[i+1][j+1] /= s[j+1][i+1]) then     return false else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var stdout : OclFile ; stdout := OclFile.newOclFile_Write(OclFile["System.out"], false) ;
     Main.newMain().solve(stdin, stdout) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(input.readLine());
    char[][] c=new char[n][n];
    for(int i=0 ; i<n ; i++){
      String s=input.readLine();
      for(int j=0 ; j<n ; j++){
        c[i][j]=s.charAt(j);
      }
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(sym(n,c,i))count+=n ;
    }
    System.out.println(count);
  }
  static boolean sym(int n,char c[][],int offset){
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        int x=(j+offset+n)% n ;
        int y=(i-offset+n)% n ;
        if(c[i][j]!=c[x][y])return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (input.readLine())->toInteger() ;
    var c : Sequence(Sequence(String)) ; c := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := input.readLine() ;
         var j : int ; j := 0 ; while j < n do ( (     c[i+1][j+1] := s->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (sym(n, c, i)) then     count := count+(n) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation sym( n : int, c : Sequence(Sequence(String)), offset : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     var x : int ; x := (j + offset + n) mod n ;
     var y : int ; y := (i - offset + n) mod n ;
     if (c[i+1][j+1] /= c[x+1][y+1]) then     return false else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    char[][] s=new char[N][N];
    int ans=0 ;
    String line ;
    for(int i=0 ; i<N ; i++){
      line=sc.next();
      for(int j=0 ; j<N ; j++){
        s[i][j]=line.charAt(j);
      }
    }
    boolean good ;
    for(int A=0 ; A<N ; A++){
      good=true ;
      for(int i=0 ; i<N ; i++){
        for(int j=0 ; j<N ; j++){
          int tmpI=(i+A)% N ;
          int tmpJ=(j+A)% N ;
          if(s[tmpI][j]!=s[tmpJ][i]){
            good=false ;
          }
        }
      }
      if(good){
        ans++;
      }
    }
    System.out.println(ans*N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var s : Sequence(Sequence(String)) ; s := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
    var ans : int ; ans := 0 ;
    var line : String ;
        var i : int ; i := 0 ; while i < N do ( (     line := sc.getCurrent() ; 
         var j : int ; j := 0 ; while j < N do ( (     s[i+1][j+1] := line->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var good : boolean ;
        var A : int ; A := 0 ; while A < N do ( (     good := true ; 
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     var tmpI : int ; tmpI := (i + A) mod N ;
     var tmpJ : int ; tmpJ := (j + A) mod N ;
     if (s[tmpI+1][j+1] /= s[tmpJ+1][i+1]) then (     good := false ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (good) then (     ans := ans + 1 ) else skip )  ;     A := A + 1 ) ; 
    OclFile["System.out"].println(ans * N) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int toggle(int n){
    int temp=1 ;
    while(temp<=n){
      n=n ^ temp ;
      temp=temp<<1 ;
    }
    return n ;
  }
  public static void main(String arg[]){
    int n=10 ;
    n=toggle(n);
    System.out.print(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation toggle( n : int) : int
  pre: true
  post: true
  activity: (     var temp : int ; temp := 1 ;
     while (temp <= n) do (     n := n xor temp ; 
     temp := (temp*(2->pow(1)))->oclAsType(long) ) ; 
     return n );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     n := toggle(n) ; 
     OclFile["System.out"].print(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int BitCount[]=new int[10000];
  static void fillSetBitsMatrix(int arr[],int n){
    for(int i=0 ; i<32 ; i++){
      for(int j=0 ; j<n ; j++){
        long temp=arr[j]>>i ;
        if(temp % 2!=0)BitCount[j]+=1 ;
      }
    }
    for(int i=1 ; i<n ; i++)BitCount[i]+=BitCount[i-1];
  }
  static void Query(int Q[][],int q){
    for(int i=0 ; i<q ; i++)System.out.println((BitCount[Q[i][1] ]-BitCount[Q[i][0]-1]));
  }
  public static void main(String[] args){
    int Arr[]={
      1,5,6,10,9,4,67 };
      int n=Arr.length ;
      fillSetBitsMatrix(Arr,n);
      int q=2 ;
      int Q[][]={
        {
          1,5 },{
            2,6 }
          };
          Query(Q,q);
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute BitCount : int := Integer.subrange(1,10000)->collect(0);
  static   operation fillSetBitsMatrix( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 32 do ( (         var j : int ; j := 0 ; while j < n do ( (     var temp : long ; temp := (arr[j+1]/(2->pow(i)))->oclAsType(long) ;
     if (temp mod 2 /= 0) then     BitCount[j+1] := BitCount[j+1]+(1) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i < n do (     BitCount[i+1] := BitCount[i+1]+(BitCount[i - 1+1]) ;  ;     i := i + 1 ) );
  static   operation Query( Q : Sequence(Sequence(int)), q : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < q do (     OclFile["System.out"].println((BitCount[Q[i+1][1+1]+1] - BitCount[Q[i+1][0+1] - 1+1])) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Arr : Sequence(int) ; Arr := Sequence{1,5,6,10,9,4,67} ;
     var n : int ; n := Arr->size() ;
    execute fillSetBitsMatrix(Arr, n) ; 
    var q : int ; q := 2 ;
    var Q : Sequence(Sequence(int)) ; Q := Sequence{Sequence{1,5},Sequence{2,6}} ;
    execute Query(Q, q) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double longestRodInCuboid(int length,int breadth,int height){
    double result ;
    int temp ;
    temp=length*length+breadth*breadth+height*height ;
    result=Math.sqrt(temp);
    return result ;
  }
  public static void main(String[] args){
    int length=12,breadth=9,height=8 ;
    System.out.println((int)longestRodInCuboid(length,breadth,height));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation longestRodInCuboid( length : int, breadth : int, height : int) : double
  pre: true
  post: true
  activity: (     var result : double ;
     var temp : int ;
    temp := length * length + breadth * breadth + height * height ; 
    result := (temp)->sqrt() ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var length : int ; length := 12 ;
    var breadth : int ; breadth := 9 ;
    var height : int ; height := 8 ;
     OclFile["System.out"].println(longestRodInCuboid(length, breadth, height)->oclAsType(int)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printPattern(int r){
    r=r/2 ;
    int count=r ;
    for(int i=0 ; i<r ; i++){
      for(int j=r ; j>i ; j--){
        if(j!=r){
          System.out.print("*"+count);
        }
        else {
          System.out.print(count);
        }
      }
      count--;
      System.out.print("\n");
    }
    count++;
    for(int i=0 ; i<r ; i++){
      for(int j=0 ; j<=i ; j++){
        if(j!=0){
          System.out.print("*"+count);
        }
        else {
          System.out.print(count);
        }
      }
      count++;
      System.out.print("\n");
    }
  }
  public static void main(String[] args){
    int n ;
    n=6 ;
    printPattern(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printPattern( r : int) : void
  pre: true
  post: true
  activity: (     r := r / 2 ; 
     var count : int ; count := r ;
        var i : int ; i := 0 ; while i < r do ( (         var j : int ; j := r ; while j > i do ( (     if (j /= r) then (     OclFile["System.out"].print("*" + count) ) else (     OclFile["System.out"].print(count) ) )  ;     j := j - 1 ) ; 
     count := count - 1 ; 
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) ; 
    count := count + 1 ; 
        var i : int ; i := 0 ; while i < r do ( (         var j : int ; j := 0 ; while j <= i do ( (     if (j /= 0) then (     OclFile["System.out"].print("*" + count) ) else (     OclFile["System.out"].print(count) ) )  ;     j := j + 1 ) ; 
     count := count + 1 ; 
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     n := 6 ; 
     execute printPattern(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int fact(int n){
    int result=1 ;
    for(int i=1 ; i<=n ; i++)result*=i ;
    return result ;
  }
  static int getResult(String str,char ch){
    int has[]=new int[26];
    for(int i=0 ; i<26 ; i++)has[i]=0 ;
    for(int i=0 ; i<str.length(); i++)has[str.charAt(i)-'A']++;
    int particular=has[ch-'A'];
    if(particular==0)return 0 ;
    has[ch-'A']=0 ;
    int total=str.length();
    total=total-particular+1 ;
    int result=fact(total);
    for(int i=0 ; i<26 ; i++){
      if(has[i]>1){
        result=result/fact(has[i]);
      }
    }
    return result ;
  }
  public static void main(String args[]){
    String str="MISSISSIPPI" ;
    System.out.println(getResult(str,'S'));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation fact( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 1 ;
         var i : int ; i := 1 ; while i <= n do (     result := result*(i) ;  ;     i := i + 1 ) ; 
     return result );
  static   operation getResult( str : String, ch : String) : int
  pre: true
  post: true
  activity: (     var has : Sequence(int) ; has := Integer.subrange(1,26)->collect(0) ;
         var i : int ; i := 0 ; while i < 26 do (     has[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < str->size() do (     has[str->at(i+1) - ('A')->char2byte()+1] := has[str->at(i+1) - ('A')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    var particular : int ; particular := has[ch - ('A')->char2byte()+1] ;
    if (particular = 0) then     return 0 else skip ; 
    has[ch - ('A')->char2byte()+1] := 0 ; 
    var total : int ; total := str->size() ;
    total := total - particular + 1 ; 
    var result : int ; result := fact(total) ;
        var i : int ; i := 0 ; while i < 26 do ( (     if (has[i+1] > 1) then (     result := result / fact(has[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "MISSISSIPPI" ;
     OclFile["System.out"].println(getResult(str, 'S')) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    StringBuffer out=new StringBuffer();
    int T=in.nextInt();
    LABEL : while(T--!=0){
      int n=in.nextInt();
      String s=in.next();
      if(n<=2){
        out.append(n).append("\n");
        continue ;
      }
      int lo,hi ;
      if(n % 2==0){
        hi=n/2 ;
        lo=hi-1 ;
      }
      else {
        hi=n/2 ;
        lo=hi ;
      }
      while(hi<n && s.charAt(hi)==s.charAt(n/2)){
        hi+=1 ;
      }
      while(lo>=0 && s.charAt(lo)==s.charAt(n/2)){
        lo-=1 ;
      }
      out.append(hi-lo-1).append("\n");
    }
    System.out.print(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : String ; out := StringLib.newString() ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        while (T /= 0) do (    skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var s : String ; s := in.getCurrent() ;
    if (n <= 2) then (     out := out + StringLib.newString(n) + StringLib.newString("\n") ; 
     continue ) else skip ; 
    var lo : int ;
    var hi : int ;
    if (n mod 2 = 0) then (     hi := n / 2 ; 
     lo := (hi)->char2byte() - 1 ) else (     hi := n / 2 ; 
     lo := hi ) ;  
    while (hi < n & s->at(hi+1) = s->at(n / 2+1)) do (     hi := hi+(1) ) ; 
    while (lo >= 0 & s->at(lo+1) = s->at(n / 2+1)) do (     lo := lo-(1) ) ; 
    out := out + StringLib.newString((hi)->char2byte() - (lo)->char2byte() - 1) + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].print(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
class GFG {
  static String wordReverse(String str){
    int i=str.length()-1 ;
    int start,end=i+1 ;
    String result="" ;
    while(i>=0){
      if(str.charAt(i)==' '){
        start=i+1 ;
        while(start!=end)result+=str.charAt(start++);
        result+=' ' ;
        end=i ;
      }
      i--;
    }
    start=0 ;
    while(start!=end)result+=str.charAt(start++);
    return result ;
  }
  public static void main(String[] args){
    String str="I AM A GEEK" ;
    System.out.print(wordReverse(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation wordReverse( str : String) : String
  pre: true
  post: true
  activity: (     var i : int ; i := str->size() - 1 ;
     var start : int ;
    var end : int ; end := i + 1 ;
    var result : String ; result := "" ;
    while (i >= 0) do (     if (str->at(i+1) = ' ') then (     start := i + 1 ; 
     while (start /= end) do     result := result+(str->at(start+1)) ; ; 
     result := result+(' ') ; 
     end := i ) else skip ; 
     i := i - 1 ) ; 
    start := 0 ; 
    while (start /= end) do     result := result+(str->at(start+1)) ; ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "I AM A GEEK" ;
     OclFile["System.out"].print(wordReverse(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class AVarietyOfOperations {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int c=sc.nextInt();
      int d=sc.nextInt();
      if(c==0 && d==0){
        System.out.println(0);
      }
      else if((c+d)% 2==0 &&(c+d)/2==c){
        System.out.println(1);
      }
      else if((c+d)% 2==0){
        System.out.println(2);
      }
      else {
        System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AVarietyOfOperations {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var c : int ; c := sc.getCurrent()->toInteger() ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
     if (c = 0 & d = 0) then (     OclFile["System.out"].println(0) ) else     if ((c + d) mod 2 = 0 & (c + d) / 2 = c) then (     OclFile["System.out"].println(1) ) else     if ((c + d) mod 2 = 0) then (     OclFile["System.out"].println(2) ) else (     OclFile["System.out"].println(-1) ) ;  ;  ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    int t=fs.nextInt();
    while(t-->0){
      int a=fs.nextInt();
      int b=fs.nextInt();
      if(a==0 && b==0)System.out.println(0);
      else if(a==b)System.out.println(1);
      else if(Math.abs(a-b)% 2==0)System.out.println(2);
      else System.out.println(-1);
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! 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());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var t : int ; t := fs.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := fs.nextInt() ;
     var b : int ; b := fs.nextInt() ;
     if (a = 0 & b = 0) then     OclFile["System.out"].println(0) ; else     if (a = b) then     OclFile["System.out"].println(1) else     if (if a - b < 0 then -(a - b) else a - b endif mod 2 = 0) then     OclFile["System.out"].println(2) else     OclFile["System.out"].println(-1) ; ;  ;  ) ;  ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p003 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p003().run());
  }
  public String run(){
    long n=600851475143L ;
    while(true){
      long p=smallestFactor(n);
      if(p<n)n/=p ;
      else return Long.toString(n);
    }
  }
  private static long smallestFactor(long n){
    if(n<=1)throw new IllegalArgumentException();
    for(long i=2,end=Library.sqrt(n); i<=end ; i++){
      if(n % i==0)return i ;
    }
    return n ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p003 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p003.newp003().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var n : long ; n := 600851475143L ;
     while (true) do (     var p : long ; p := smallestFactor(n) ;
     if (p < n) then     n := n/(p) ; else     return ((n) + "") ) );
  static   operation smallestFactor( n : long) : long
  pre: true
  post: true
  activity: (     if (n <= 1) then     error IllegalArgumentException.newIllegalArgumentException() ; else skip ; 
         var i : long ; i := 2 ;
    var end : long ; end := Library.sqrt(n) ; while i <= end do ( (     if (n mod i = 0) then     return i else skip )  ;     i := i + 1 ) ; 
     return n );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxBitElement(int arr[],int n){
    int num=0,max=-1 ;
    for(int i=0 ; i<n ; i++){
      int cnt=Integer.bitCount(arr[i]);
      if(cnt>max){
        max=cnt ;
        num=arr[i];
      }
    }
    return num ;
  }
  public static void main(String[] args){
    int arr[]={
      3,2,4,7,1,10,5,8,9,6 };
      int n=arr.length ;
      System.out.print(maxBitElement(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxBitElement( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := 0 ;
    var max : int ; max := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     var cnt : int ; cnt := bitCount(arr[i+1]) ;
     if (cnt > max) then (     max := cnt ; 
     num := arr[i+1] ) else skip )  ;     i := i + 1 ) ; 
     return num );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,2,4,7,1,10,5,8,9,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(maxBitElement(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void maxLengthArr(int x,int y){
    boolean[] ex=new boolean[(1<<x)];
    ex[0]=true ;
    Vector<Integer>pre=new Vector<Integer>();
    pre.add(0);
    for(int i=1 ; i<(1<<x); i++){
      if(ex[i ^ y])continue ;
      pre.add(i);
      ex[i]=true ;
    }
    if(pre.size()==1){
      System.out.print("-1");
      return ;
    }
    for(int i=1 ; i<pre.size(); i++)System.out.print((pre.get(i)^ pre.get(i-1))+" ");
  }
  public static void main(String[] args){
    int X=3,Y=5 ;
    maxLengthArr(X,Y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxLengthArr( x : int, y : int) : void
  pre: true
  post: true
  activity: (     var ex : Sequence(boolean) ; ex := Integer.subrange(1,((1*(2->pow(x)))->oclAsType(long)))->collect(false) ;
     ex[0+1] := true ; 
    var pre : Sequence(int) ; pre := Sequence{} ;
    pre := pre->including(0) ; 
        var i : int ; i := 1 ; while i < ((1*(2->pow(x)))->oclAsType(long)) do ( (     if (ex[MathLib.bitwiseXor(i,y)+1]) then     continue else skip ; 
     pre := pre->including(i) ; 
     ex[i+1] := true )  ;     i := i + 1 ) ; 
    if (pre->size() = 1) then (     OclFile["System.out"].print("-1") ; 
     return ) else skip ; 
        var i : int ; i := 1 ; while i < pre->size() do (     OclFile["System.out"].print((pre->at(i+1) xor pre->at(i - 1+1)) + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 3 ;
    var Y : int ; Y := 5 ;
     execute maxLengthArr(X, Y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      int[][] list=new int[n+1][n+1];
      for(int i=0 ; i<n+1 ; i++){
        if(i==n){
          int sum=0 ;
          for(int j=0 ; j<n ; j++){
            sum+=list[n][j];
            System.out.printf("%5d",list[n][j]);
          }
          System.out.printf("%5d\n",sum);
        }
        else {
          for(int j=0 ; j<n ; j++){
            int m=sc.nextInt();
            list[i][j]=m ;
            list[i][n]+=m ;
            list[n][j]+=m ;
            System.out.printf("%5d",m);
          }
          System.out.printf("%5d\n",list[i][n]);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
     var list : Sequence(Sequence(int)) ; list := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i < n + 1 do ( (     if (i = n) then (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     sum := sum+(list[n+1][j+1]) ; 
     OclFile["System.out"].printf("%5d", list[n+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].printf("%5d\n", sum) ) else (         var j : int ; j := 0 ; while j < n do ( (     var m : int ; m := sc.getCurrent()->toInteger() ;
     list[i+1][j+1] := m ; 
    list[i+1][n+1] := list[i+1][n+1]+(m) ; 
    list[n+1][j+1] := list[n+1][j+1]+(m) ; 
    OclFile["System.out"].printf("%5d", m) ; 
 )  ;     j := j + 1 ) ; 
     OclFile["System.out"].printf("%5d\n", list[i+1][n+1]) ) )  ;     i := i + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static String _5keta(int n){
    if(n/10000>0){
      return ""+n ;
    }
    if(n/1000>0){
      return " "+n ;
    }
    if(n/100>0){
      return "  "+n ;
    }
    if(n/10>0){
      return "   "+n ;
    }
    return "    "+n ;
  }
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String line ;
      while((line=br.readLine())!=null){
        if(line.isEmpty())break ;
        String[] spl=line.split(" ");
        int n=Integer.parseInt(spl[0]);
        if(n==0){
          break ;
        }
        int[][] matrix=new int[n][n];
        for(int i=0 ; i<n ; i++){
          line=br.readLine();
          spl=line.split(" ");
          for(int j=0 ; j<n ; j++){
            matrix[i][j]=Integer.parseInt(spl[j]);
          }
        }
        for(int i=0 ; i<n ; i++){
          int sum=0 ;
          for(int j=0 ; j<n ; j++){
            sum+=matrix[i][j];
            System.out.print(_5keta(matrix[i][j]));
          }
          System.out.println(_5keta(sum));
        }
        int totalSum=0 ;
        for(int j=0 ; j<n ; j++){
          int sum=0 ;
          for(int i=0 ; i<n ; i++){
            sum+=matrix[i][j];
          }
          totalSum+=sum ;
          System.out.print(_5keta(sum));
        }
        System.out.println(_5keta(totalSum));
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation _5keta( n : int) : String
  pre: true
  post: true
  activity: (     if (n / 10000 > 0) then (     return "" + n ) else skip ; 
     if (n / 1000 > 0) then (     return " " + n ) else skip ; 
    if (n / 100 > 0) then (     return "  " + n ) else skip ; 
    if (n / 10 > 0) then (     return "   " + n ) else skip ; 
    return "    " + n 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->isEmpty()) then     break else skip ; 
     var spl : Sequence(String) ; spl := line->split(" ") ;
    var n : int ; n := (spl[0+1])->toInteger() ;
    if (n = 0) then (     break ) else skip ; 
    var matrix : Sequence(Sequence(int)) ; matrix := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     line := br.readLine() ; 
     spl := line->split(" ") ; 
         var j : int ; j := 0 ; while j < n do ( (     matrix[i+1][j+1] := (spl[j+1])->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     sum := sum+(matrix[i+1][j+1]) ; 
     OclFile["System.out"].print(_5keta(matrix[i+1][j+1])) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(_5keta(sum)) )  ;     i := i + 1 ) ; 
    var totalSum : int ; totalSum := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(matrix[i+1][j+1]) )  ;     i := i + 1 ) ; 
     totalSum := totalSum+(sum) ; 
     OclFile["System.out"].print(_5keta(sum)) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(_5keta(totalSum)) ; 
 ) ;     line := br.readLine() ;
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int size ;
    while((size=Integer.parseInt(br.readLine()))!=0){
      int[][] table=new int[size+1][size+1];
      for(int i=0 ; i<size ; i++){
        String[] horizontal=br.readLine().split(" ");
        for(int j=0 ; j<size ; j++){
          table[i][j]=Integer.parseInt(horizontal[j]);
        }
      }
      deploySum(table);
      for(int i=0 ; i<=size ; i++){
        for(int j=0 ; j<size ; j++){
          System.out.print(String.format("%5s",table[i][j]));
        }
        System.out.println(String.format("%5s",table[i][size]));
      }
    }
  }
  public static void deploySum(int[][] data){
    int size=data.length ;
    for(int i=0 ; i<size-1 ; i++){
      for(int j=0 ; j<size-1 ; j++){
        data[i][size-1]+=data[i][j];
      }
    }
    for(int i=0 ; i<size ; i++){
      for(int j=0 ; j<size-1 ; j++){
        data[size-1][i]+=data[j][i];
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var size : int ;
         size := (br.readLine())->toInteger() ;
    while ((size) /= 0) do (    skip ; (     var table : Sequence(Sequence(int)) ; table := Integer.subrange(1,size + 1)->collect(Integer.subrange(1,size + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i < size do ( (     var horizontal : Sequence(String) ; horizontal := br.readLine()->split(" ") ;
         var j : int ; j := 0 ; while j < size do ( (     table[i+1][j+1] := (horizontal[j+1])->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     execute deploySum(table) ; 
         var i : int ; i := 0 ; while i <= size do ( (         var j : int ; j := 0 ; while j < size do ( (     OclFile["System.out"].print(StringLib.format("%5s",Sequence{table[i+1][j+1]})) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(StringLib.format("%5s",Sequence{table[i+1][size+1]})) )  ;     i := i + 1 ) ) ;     size := (br.readLine())->toInteger() ;
 ) );
  static   operation deploySum( data : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var size : int ; size := data->size() ;
         var i : int ; i := 0 ; while i < size - 1 do ( (         var j : int ; j := 0 ; while j < size - 1 do ( (     data[i+1][size - 1+1] := data[i+1][size - 1+1]+(data[i+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < size do ( (         var j : int ; j := 0 ; while j < size - 1 do ( (     data[size - 1+1][i+1] := data[size - 1+1][i+1]+(data[j+1][i+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int x=in.nextInt(),y=in.nextInt(),a=in.nextInt(),b=in.nextInt();
    ArrayList<String>res=new ArrayList<>();
    for(int i=a ; i<=x ; i++){
      for(int j=b ; j<=y ; j++){
        if(i<=j)continue ;
        res.add(i+" "+j);
      }
    }
    pw.println(res.size());
    for(String str : res)pw.println(str);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var x : int ; x := in.getCurrent()->toInteger() ;
    var y : int ; y := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var res : Sequence(String) ; res := Sequence{} ;
        var i : int ; i := a ; while i <= x do ( (         var j : int ; j := b ; while j <= y do ( (     if (i <= j) then     continue else skip ; 
     res := res->including(i + " " + j) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    for (str : res) do (     skip ;  ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.regex.Pattern ;
public class Main {
  public static Scanner sc ;
  public static int[][] ary ;
  public static void main(String[] args)throws Exception {
    sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      if(n==0)break ;
      ary=new int[n+1][n+1];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          ary[i][j]=sc.nextInt();
        }
      }
      for(int i=0 ; i<n ; i++){
        int sum=0 ;
        for(int j=0 ; j<n ; j++){
          sum+=ary[i][j];
        }
        ary[i][n]=sum ;
      }
      for(int i=0 ; i<n ; i++){
        int sum=0 ;
        for(int j=0 ; j<n ; j++){
          sum+=ary[j][i];
        }
        ary[n][i]=sum ;
      }
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        sum+=ary[i][n];
      }
      ary[n][n]=sum ;
      for(int i=0 ; i<n+1 ; i++){
        StringBuilder sb=new StringBuilder();
        for(int j=0 ; j<n+1 ; j++){
          int num=ary[i][j];
          for(int k=0 ; k<(5-Integer.toString(num).length()); k++){
            sb.append(" ");
          }
          sb.append(num);
        }
        System.out.println(sb.toString());
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile;
  static   attribute ary : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    ary := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     ary[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     sum := sum+(ary[i+1][j+1]) )  ;     j := j + 1 ) ; 
     ary[i+1][n+1] := sum )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     sum := sum+(ary[j+1][i+1]) )  ;     j := j + 1 ) ; 
     ary[n+1][i+1] := sum )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(ary[i+1][n+1]) )  ;     i := i + 1 ) ; 
    ary[n+1][n+1] := sum ; 
        var i : int ; i := 0 ; while i < n + 1 do ( (     var sb : String ; sb := StringLib.newString() ;
         var j : int ; j := 0 ; while j < n + 1 do ( (     var num : int ; num := ary[i+1][j+1] ;
         var k : int ; k := 0 ; while k < (5 - ((num) + "")->size()) do ( (     sb := sb + StringLib.newString(" ") )  ;     k := k + 1 ) ; 
     sb := sb + StringLib.newString(num) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(sb+"") )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PalindromicIndices {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      String s=sc.next();
      if(n==2){
        System.out.println(2);
      }
      else if(n==1){
        System.out.println(1);
      }
      else {
        int start=0 ;
        if(n % 2==0){
          start=n/2-1 ;
        }
        else {
          start=n/2 ;
        }
        int res=1 ;
        char x=s.charAt(start);
        int i=start+1 ;
        while(i<s.length()&& s.charAt(i)==x){
          i++;
          res++;
        }
        i=start-1 ;
        while(i>=0 && s.charAt(i)==x){
          res++;
          i--;
        }
        System.out.println(res);
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PalindromicIndices {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
     if (n = 2) then (     OclFile["System.out"].println(2) ) else     if (n = 1) then (     OclFile["System.out"].println(1) ) else (     var start : int ; start := 0 ;
     if (n mod 2 = 0) then (     start := n / 2 - 1 ) else (     start := n / 2 ) ;  
    var res : int ; res := 1 ;
    var x : String ; x := s->at(start+1) ;
    var i : int ; i := start + 1 ;
    while (i < s->size() & s->at(i+1) = x) do (     i := i + 1 ; 
     res := res + 1 ) ; 
    i := (start)->char2byte() - 1 ; 
    while (i >= 0 & s->at(i+1) = x) do (     res := res + 1 ; 
     i := i - 1 ) ; 
    OclFile["System.out"].println(res) ; 
 ) ;  ;  
     t := t - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  void run(){
    sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] s=new int[n];
      for(int j=0 ; j<n ; j++){
        int sum=0 ;
        for(int i=0 ; i<n ; i++){
          int d=sc.nextInt();
          print(String.format("%5d",d));
          sum+=d ;
          s[i]+=d ;
        }
        println(String.format("%5d",sum));
      }
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        print(String.format("%5d",s[i]));
        sum+=s[i];
      }
      println(String.format("%5d",sum));
    }
    sc.close();
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var d : int ; d := sc.getCurrent()->toInteger() ;
     execute print(StringLib.format("%5d",Sequence{d})) ; 
     sum := sum+(d) ; 
     s[i+1] := s[i+1]+(d) )  ;     i := i + 1 ) ; 
     execute println(StringLib.format("%5d",Sequence{sum})) )  ;     j := j + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     execute print(StringLib.format("%5d",Sequence{s[i+1]})) ; 
     sum := sum+(s[i+1]) )  ;     i := i + 1 ) ; 
    execute println(StringLib.format("%5d",Sequence{sum})) ; 
 )  ) ; 
     skip );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int a,b,c,sum ;
    a=scan.nextInt();
    b=scan.nextInt();
    sum=a*b ;
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ;
    var b : int ;
    var c : int ;
    var sum : int ;
    a := scan.getCurrent()->toInteger() ; 
    b := scan.getCurrent()->toInteger() ; 
    sum := a * b ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    words=br.readLine().split(" ");
    int d,c ;
    d=parseInt(words[0]);
    c=parseInt(words[1]);
    System.out.println(d*c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    words := br.readLine()->split(" ") ; 
    var d : int ;
    var c : int ;
    d := (words[0+1] + "")->toInteger() ; 
    c := (words[1+1] + "")->toInteger() ; 
    OclFile["System.out"].println(d * c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  Main(){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt(),y=sc.nextInt();
    int ans=0 ;
    for(int i=0 ; i<10000000 ; i++){
      ans++;
      ans--;
    }
    for(int i=0 ; i<x ; i++){
      for(int j=0 ; j<y ; j++){
        ans++;
      }
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 10000000 do ( (     ans := ans + 1 ; 
     ans := ans - 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < x do ( (         var j : int ; j := 0 ; while j < y do ( (     ans := ans + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    int[] i=ArrconvAtoi(s);
    System.out.println(i[0]*i[1]);
  }
  private static int[] ArrconvAtoi(String s){
    String[] strs=s.split(" ");
    int[] ints=new int[strs.length];
    int i=0 ;
    for(String st : strs){
      ints[i]=Integer.parseInt(st);
      i++;
    }
    return ints ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
     var i : Sequence(int) ; i := ArrconvAtoi(s) ;
     OclFile["System.out"].println(i[0+1] * i[1+1]) );
  static   operation ArrconvAtoi( s : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var strs : Sequence(String) ; strs := s->split(" ") ;
     var ints : Sequence(int) ; ints := Integer.subrange(1,strs->size())->collect(0) ;
    var i : int ; i := 0 ;
    for (st : strs) do ( (     ints[i+1] := (st)->toInteger() ; 
     i := i + 1 )  ) ; 
    return ints 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    System.out.println(scanner.nextInt()*scanner.nextInt());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println(scanner.getCurrent()->toInteger() * scanner.getCurrent()->toInteger()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int N,K,size,i ;
    N=input.nextInt();
    K=input.nextInt();
    i=0 ;
    List<Integer>list=new Vector<>();
    while(K-->0)list.add(input.nextInt());
    String number=Integer.toString(N);
    size=number.length();
    while(i<size){
      int num=number.charAt(i)-48 ;
      if(list.contains(num)){
        N++;
        number=Integer.toString(N);
        size=number.length();
        i=0 ;
      }
      else i++;
    }
    System.out.println(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ;
    var K : int ;
    var size : int ;
    var i : int ;
    N := input.getCurrent()->toInteger() ; 
    K := input.getCurrent()->toInteger() ; 
    i := 0 ; 
    var list : Sequence(int) ; list := Sequence{} ;
        while (K > 0) do (        K := K - 1 ;     skip ;     list := list->including(input.getCurrent()->toInteger()) ; ;  ) ;  
    var number : String ; number := ((N) + "") ;
    size := number->size() ; 
    while (i < size) do (     var num : int ; num := number->at(i+1) - 48 ;
     if (list->includes(num)) then (     N := N + 1 ; 
     number := ((N) + "") ; 
     size := number->size() ; 
     i := 0 ) else     i := i + 1 ; ) ; 
    OclFile["System.out"].println(N) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),l=sc.nextInt();
    int i,tmp,flag ;
    int[] array=new int[11],check=new int[11];
    for(i=0 ; i<9 ; i++)check[i]=0 ;
    for(i=0 ; i<l ; i++){
      array[i]=sc.nextInt();
      check[array[i] ]=1 ;
    }
    for(i=n ; ; i++){
      tmp=i ;
      flag=1 ;
      for(; ; ){
        if(tmp==0)break ;
        if(check[tmp % 10]==1){
          flag=0 ;
          break ;
        }
        tmp/=10 ;
      }
      if(flag==1){
        System.out.println(i);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var i : int ;
    var tmp : int ;
    var flag : int ;
    var array : Sequence(int) ; array := Integer.subrange(1,11)->collect(0) ;
    var check : Sequence(int) ; check := Integer.subrange(1,11)->collect(0) ;
        i := 0 ; while i < 9 do (     check[i+1] := 0 ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < l do ( (     array[i+1] := sc.getCurrent()->toInteger() ; 
     check[array[i+1]+1] := 1 )  ;     i := i + 1 ) ; 
        i := n ; while true do ( (     tmp := i ; 
     flag := 1 ; 
       while true do ( (     if (tmp = 0) then     break else skip ; 
     if (check[tmp mod 10+1] = 1) then (     flag := 0 ; 
     break ) else skip ; 
     tmp := tmp/(10) )  ) ; 
     if (flag = 1) then (     OclFile["System.out"].println(i) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] tmpArray=br.readLine().split(" ");
    int[] numbers=new int[n];
    for(int i=0 ; i<n ; i++){
      numbers[i]=Integer.parseInt(tmpArray[i]);
    }
    System.out.println(solve(numbers));
  }
  static int solve(int[] numbers){
    int n=numbers.length ;
    int bestNum=-1 ;
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        int tmp=numbers[i]*numbers[j];
        if(increasing(tmp)&& bestNum<tmp){
          bestNum=tmp ;
        }
      }
    }
    return bestNum ;
  }
  static boolean increasing(int n){
    char[] num=Integer.toString(n).toCharArray();
    for(int i=1 ; i<num.length ; i++){
      if(num[i]!=num[i-1]+1){
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
    var numbers : Sequence(int) ; numbers := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     numbers[i+1] := (tmpArray[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(numbers)) ; 
 );
  static   operation solve( numbers : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := numbers->size() ;
     var bestNum : int ; bestNum := -1 ;
         var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var tmp : int ; tmp := numbers[i+1] * numbers[j+1] ;
     if (increasing(tmp) & bestNum < tmp) then (     bestNum := tmp ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return bestNum );
  static   operation increasing( n : int) : boolean
  pre: true
  post: true
  activity: (     var num : Sequence(String) ; num := ((n) + "")->characters() ;
         var i : int ; i := 1 ; while i < num->size() do ( (     if (num[i+1] /= num[i - 1+1] + 1) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.regex.Pattern ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  private static java.util.Scanner scanner=new java.util.Scanner(System.in);
  public static void main(String[] args){
    int n=scanner.nextInt();
    Pattern pattern=Pattern.compile(IntStream.range(0,scanner.nextInt()).mapToObj(i->Integer.toString(scanner.nextInt())).collect(Collectors.joining("","[^","]+")));
    IntStream.iterate(n,i->++i).filter(i->pattern.matcher(Integer.toString(i)).matches()).findFirst().ifPresent(System.out :: println);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : Scanner := Scanner.newScanner(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.nextInt() ;
     var pattern : OclRegex ; pattern := OclRegex.compile(Integer.subrange(0, scanner.nextInt()-1).mapToObj(lambda i : OclAny in ((scanner.nextInt()) + "")).collect(Collectors.joining("", "[^", "]+"))) ;
     .iterate(n, lambda i : OclAny in (i + 1))->select( _x1 | (lambda i : OclAny in pattern.matcher(((i) + "")).isMatch())->apply(_x1) )->first().ifPresent(lambda _pars : OclAny in OclFile["System.out"].println(_pars)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int price=sc.nextInt();
    int unlikeNum=sc.nextInt();
    int pay=price ;
    int[] array=new int[unlikeNum];
    for(int i=0 ; i<unlikeNum ; i++){
      array[i]=sc.nextInt();
    }
    while(!(jadgeUnlikeNum(pay,unlikeNum,array))){
      pay++;
    }
    System.out.println(pay);
  }
  public static boolean jadgeUnlikeNum(int pay,int unlikeNum,int[] array){
    boolean ans=true ;
    String payStr=String.valueOf(pay);
    String payNum[]=new String[payStr.length()];
    String arrayStr[]=new String[unlikeNum];
    for(int i=0 ; i<payStr.length(); i++){
      payNum[i]=payStr.substring(i,i+1);
    }
    for(int i=0 ; i<array.length ; i++){
      arrayStr[i]=String.valueOf(array[i]);
    }
    for(int i=0 ; i<payNum.length ; i++){
      for(int j=0 ; j<arrayStr.length ; j++){
        if(payNum[i] .equals(arrayStr[j])){
          ans=false ;
          break ;
        }
      }
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var price : int ; price := sc.getCurrent()->toInteger() ;
    var unlikeNum : int ; unlikeNum := sc.getCurrent()->toInteger() ;
    var pay : int ; pay := price ;
    var array : Sequence(int) ; array := Integer.subrange(1,unlikeNum)->collect(0) ;
        var i : int ; i := 0 ; while i < unlikeNum do ( (     array[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    while (not((jadgeUnlikeNum(pay, unlikeNum, array)))) do (     pay := pay + 1 ) ; 
    OclFile["System.out"].println(pay) ; 
 );
  static   operation jadgeUnlikeNum( pay : int, unlikeNum : int, array : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var ans : boolean ; ans := true ;
     var payStr : String ; payStr := ((pay) + "") ;
    var payNum : Sequence(String) ; payNum := Integer.subrange(1,payStr->size())->collect(null) ;
    var arrayStr : Sequence(String) ; arrayStr := Integer.subrange(1,unlikeNum)->collect(null) ;
        var i : int ; i := 0 ; while i < payStr->size() do ( (     payNum[i+1] := payStr.subrange(i+1,i + 1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < array->size() do ( (     arrayStr[i+1] := ((array[i+1]) + "") )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < payNum->size() do ( (         var j : int ; j := 0 ; while j < arrayStr->size() do ( (     if (payNum[i+1] = arrayStr[j+1]) then (     ans := false ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import static java.lang.System.out ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      int size=in.nextInt();
      String s=in.next();
      long answ=0 ;
      for(int j=size/2 ; j>0 ; j--){
        if(size % 2!=0 && j==size/2){
          answ++;
        }
        if(s.charAt(j)==s.charAt(j-1)){
          answ+=2 ;
        }
        else {
          break ;
        }
      }
      out.println(answ);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var size : int ; size := in.getCurrent()->toInteger() ;
     var s : String ; s := in.getCurrent() ;
    var answ : long ; answ := 0 ;
        var j : int ; j := size / 2 ; while j > 0 do ( (     if (size mod 2 /= 0 & j = size / 2) then (     answ := answ + 1 ) else skip ; 
     if (s->at(j+1) = s->at(j - 1+1)) then (     answ := answ+(2) ) else (     break ) )  ;     j := j - 1 ) ; 
    out.println(answ) ; 
 )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] line=br.readLine().split(" ");
    int N=Integer.parseInt(line[0]);
    int K=Integer.parseInt(line[1]);
    String[] D=br.readLine().split(" ");
    int tf=0 ;
    while(true){
      tf=0 ;
      for(String s : D){
        if(String.valueOf(N).indexOf(s)!=-1){
          tf++;
        }
      }
      if(tf==0){
        System.out.println(N);
        break ;
      }
      N++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var N : int ; N := (line[0+1])->toInteger() ;
    var K : int ; K := (line[1+1])->toInteger() ;
    var D : Sequence(String) ; D := br.readLine()->split(" ") ;
    var tf : int ; tf := 0 ;
    while (true) do (     tf := 0 ; 
     for (s : D) do ( (     if (((N) + "")->indexOf(s)-1 /= -1) then (     tf := tf + 1 ) else skip )  ) ; 
     if (tf = 0) then (     OclFile["System.out"].println(N) ; 
     break ) else skip ; 
     N := N + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class MaxLengthBitonic {
  static int maxLenBitonic(int[] A,int n){
    if(n==0)return 0 ;
    int maxLen=1 ;
    int start=0 ;
    int nextStart=0 ;
    int j=0 ;
    while(j<n-1){
      while(j<n-1 && A[j]<=A[j+1])j++;
      while(j<n-1 && A[j]>=A[j+1]){
        if(j<n-1 && A[j]>A[j+1])nextStart=j+1 ;
        j++;
      }
      maxLen=Math.max(maxLen,j-(start-1));
      start=nextStart ;
    }
    return maxLen ;
  }
  public static void main(String[] args){
    int A[]={
      12,4,78,90,45,23 };
      System.out.println("Length of maximal length bitonic "+"subarray is "+maxLenBitonic(A,A.length));
    }
  }

------------------------------------------------------------
OCL File:
---------
class MaxLengthBitonic {
  static   operation maxLenBitonic( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else skip ; 
     var maxLen : int ; maxLen := 1 ;
    var start : int ; start := 0 ;
    var nextStart : int ; nextStart := 0 ;
    var j : int ; j := 0 ;
    while (j < n - 1) do (     while (j < n - 1 & A[j+1] <= A[j + 1+1]) do     j := j + 1 ; ; 
     while (j < n - 1 & A[j+1] >= A[j + 1+1]) do (     if (j < n - 1 & A[j+1] > A[j + 1+1]) then     nextStart := j + 1 ; else skip ; 
     j := j + 1 ) ; 
     maxLen := Set{maxLen, j - (start - 1)}->max() ; 
     start := nextStart ) ; 
    return maxLen 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{12,4,78,90,45,23} ;
     OclFile["System.out"].println("Length of maximal length bitonic " + "subarray is " + maxLenBitonic(A, A->size())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class Improve {
  static int number_of_tower(int house[],int range,int n){
    Arrays.sort(house);
    int numOfTower=0 ;
    int i=0 ;
    while(i<n){
      numOfTower++;
      int loc=house[i]+range ;
      while(i<n && house[i]<=loc)i++;
--i ;
      loc=house[i]+range ;
      while(i<n && house[i]<=loc)i++;
    }
    return numOfTower ;
  }
  public static void main(String args[]){
    int house[]={
      7,2,4,6,5,9,12,11 };
      int range=2 ;
      int n=house.length ;
      System.out.println(number_of_tower(house,range,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Improve {
  static   operation number_of_tower( house : Sequence(int), range : int, n : int) : int
  pre: true
  post: true
  activity: (     house := house->sort() ; 
     var numOfTower : int ; numOfTower := 0 ;
    var i : int ; i := 0 ;
    while (i < n) do (     numOfTower := numOfTower + 1 ; 
     var loc : int ; loc := house[i+1] + range ;
    while (i < n & house[i+1] <= loc) do     i := i + 1 ; ; 
    i := i - 1 ; 
    loc := house[i+1] + range ; 
    while (i < n & house[i+1] <= loc) do     i := i + 1 ; ; 
 ) ; 
    return numOfTower 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var house : Sequence(int) ; house := Sequence{7,2,4,6,5,9,12,11} ;
     var range : int ; range := 2 ;
     var n : int ; n := house->size() ;
     OclFile["System.out"].println(number_of_tower(house, range, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean check(int arr[],int n){
    for(int i=0 ; i<n ; i++){
      if(arr[i] % 2==1){
        return true ;
      }
    }
    return false ;
  }
  public static void main(String args[]){
    int arr[]={
      3,9,12,13,15 };
      int n=arr.length ;
      if(check(arr,n)){
        System.out.println("Odd Bit-wise OR");
      }
      else {
        System.out.println("Even Bit-wise OR");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation check( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 = 1) then (     return true ) else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,9,12,13,15} ;
     var n : int ; n := arr->size() ;
     if (check(arr, n)) then (     OclFile["System.out"].println("Odd Bit-wise OR") ) else (     OclFile["System.out"].println("Even Bit-wise OR") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int MOD=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a=sc.nextLong();
    long b=sc.nextLong();
    long x=sc.nextLong();
    long s=a-b ;
    long count=Math.max(x-a,0)/s ;
    long total=(count % MOD)*(a % MOD)% MOD ;
    x-=count*s ;
    while(x>=a){
      total+=a ;
      x+=-a+b ;
    }
    total+=x ;
    total %=MOD ;
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var x : long ; x := sc.getCurrent()->toLong() ;
    var s : long ; s := a - b ;
    var count : long ; count := Set{x - a, 0}->max() / s ;
    var total : long ; total := (count mod MOD) * (a mod MOD) mod MOD ;
    x := x-(count * s) ; 
    while (x >= a) do (     total := total+(a) ; 
     x := x+(-a + b) ) ; 
    total := total+(x) ; 
    total := total mod MOD ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a=sc.nextLong();
    long b=sc.nextLong();
    long x=sc.nextLong();
    long count=0 ;
    if(x>=a){
      long figure=(x-a)/(a-b)+1 ;
      count=x % 1000000007+(figure % 1000000007)*(b % 1000000007);
      System.out.println(count % 1000000007);
    }
    else System.out.println(x % 1000000007);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var x : long ; x := sc.getCurrent()->toLong() ;
    var count : long ; count := 0 ;
    if (x >= a) then (     var figure : long ; figure := (x - a) / (a - b) + 1 ;
     count := x mod 1000000007 + (figure mod 1000000007) * (b mod 1000000007) ; 
     OclFile["System.out"].println(count mod 1000000007) ) else     OclFile["System.out"].println(x mod 1000000007) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Headstails_242A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int x,y,a,b ;
    x=in.nextInt();
    y=in.nextInt();
    a=in.nextInt();
    b=in.nextInt();
    int count=0 ;
    for(int i=a ; i<=x ; i++){
      for(int j=b ; j<=y ; ++j){
        if(i<=j)continue ;
        count++;
      }
    }
    System.out.println(count);
    for(int i=a ; i<=x ; i++){
      for(int j=b ; j<=y ; ++j){
        if(i<=j)continue ;
        System.out.println(i+" "+j);
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Headstails{
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ;
    var y : int ;
    var a : int ;
    var b : int ;
    x := in.getCurrent()->toInteger() ; 
    y := in.getCurrent()->toInteger() ; 
    a := in.getCurrent()->toInteger() ; 
    b := in.getCurrent()->toInteger() ; 
    var count : int ; count := 0 ;
        var i : int ; i := a ; while i <= x do ( (         var j : int ; j := b ; while j <= y do ( (     if (i <= j) then     continue else skip ; 
     count := count + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
        var i : int ; i := a ; while i <= x do ( (         var j : int ; j := b ; while j <= y do ( (     if (i <= j) then     continue else skip ; 
     OclFile["System.out"].println(i + " " + j) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
42A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ;
    var y : int ;
    var a : int ;
    var b : int ;
    x := in.getCurrent()->toInteger() ; 
    y := in.getCurrent()->toInteger() ; 
    a := in.getCurrent()->toInteger() ; 
    b := in.getCurrent()->toInteger() ; 
    var count : int ; count := 0 ;
        var i : int ; i := a ; while i <= x do ( (         var j : int ; j := b ; while j <= y do ( (     if (i <= j) then     continue else skip ; 
     count := count + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
        var i : int ; i := a ; while i <= x do ( (         var j : int ; j := b ; while j <= y do ( (     if (i <= j) then     continue else skip ; 
     OclFile["System.out"].println(i + " " + j) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      String n=sc.nextLine();
      if("0".equals(n))break ;
      int[][] array=new int[Integer.parseInt(n)][4];
      for(int i=0 ; i<array.length ; i++){
        String data=sc.nextLine();
        String[] adata=data.split(" ");
        for(int j=0 ; j<adata.length ; j++){
          array[i][j]=Integer.parseInt(adata[j]);
        }
      }
      String max=sc.nextLine();
      String[] amax=max.split(" ");
      int p=Integer.parseInt(amax[0]);
      int q=Integer.parseInt(amax[1]);
      int r=Integer.parseInt(amax[2]);
      int c=Integer.parseInt(amax[3]);
      for(int i=0 ; i<array.length ; i++){
        if(array[i][1]>p || array[i][2]>q || array[i][3]>r || 4*array[i][1]+9*array[i][2]+4*array[i][3]>c){
          array[i][0]=0 ;
        }
      }
      int sum=0 ;
      for(int i=0 ; i<array.length ; i++){
        if(array[i][0]!=0){
          System.out.println(array[i][0]);
        }
        sum+=array[i][0];
      }
      if(sum==0)System.out.println("NA");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : String ; n := sc.nextLine() ;
     if ("0" = n) then     break else skip ; 
    var array : Sequence(Sequence(int)) ; array := Integer.subrange(1,(n)->toInteger())->collect(Integer.subrange(1,4)->collect(0)) ;
        var i : int ; i := 0 ; while i < array->size() do ( (     var data : String ; data := sc.nextLine() ;
     var adata : Sequence(String) ; adata := data->split(" ") ;
         var j : int ; j := 0 ; while j < adata->size() do ( (     array[i+1][j+1] := (adata[j+1])->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : String ; max := sc.nextLine() ;
    var amax : Sequence(String) ; amax := max->split(" ") ;
    var p : int ; p := (amax[0+1])->toInteger() ;
    var q : int ; q := (amax[1+1])->toInteger() ;
    var r : int ; r := (amax[2+1])->toInteger() ;
    var c : int ; c := (amax[3+1])->toInteger() ;
        var i : int ; i := 0 ; while i < array->size() do ( (     if (array[i+1][1+1] > p or array[i+1][2+1] > q or array[i+1][3+1] > r or 4 * array[i+1][1+1] + 9 * array[i+1][2+1] + 4 * array[i+1][3+1] > c) then (     array[i+1][0+1] := 0 ) else skip )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < array->size() do ( (     if (array[i+1][0+1] /= 0) then (     OclFile["System.out"].println(array[i+1][0+1]) ) else skip ; 
     sum := sum+(array[i+1][0+1]) )  ;     i := i + 1 ) ; 
    if (sum = 0) then     OclFile["System.out"].println("NA") ; else skip ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Integer.parseInt ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while(!(line=br.readLine().trim()).equals("0")&& ! line.isEmpty()){
      int n=parseInt(line);
      int[][] cs=new int[n][5];
      for(int i=0 ; i<n ; i++){
        StringTokenizer st=new StringTokenizer(br.readLine());
        cs[i][0]=parseInt(st.nextToken());
        cs[i][1]=parseInt(st.nextToken());
        cs[i][2]=parseInt(st.nextToken());
        cs[i][3]=parseInt(st.nextToken());
        cs[i][4]=cs[i][1]*4+cs[i][2]*9+cs[i][3]*4 ;
      }
      int[] lim=new int[5];
      StringTokenizer st=new StringTokenizer(br.readLine());
      lim[1]=parseInt(st.nextToken());
      lim[2]=parseInt(st.nextToken());
      lim[3]=parseInt(st.nextToken());
      lim[4]=parseInt(st.nextToken());
      int sum=0 ;
      outer : for(int i=0 ;
      i<n ;
      i++){
        for(int j=1 ; j<5 ; j++){
          if(cs[i][j]>lim[j])continue outer ;
        }
        System.out.println(cs[i][0]);
        sum++;
      }
      if(sum==0)System.out.println("NA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
     while (not((line) = "0") & not(line->isEmpty())) do (     var n : int ; n := parseInt(line) ;
     var cs : Sequence(Sequence(int)) ; cs := Integer.subrange(1,n)->collect(Integer.subrange(1,5)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     cs[i+1][0+1] := (st.next() + "")->toInteger() ; 
    cs[i+1][1+1] := (st.next() + "")->toInteger() ; 
    cs[i+1][2+1] := (st.next() + "")->toInteger() ; 
    cs[i+1][3+1] := (st.next() + "")->toInteger() ; 
    cs[i+1][4+1] := cs[i+1][1+1] * 4 + cs[i+1][2+1] * 9 + cs[i+1][3+1] * 4 ; 
 )  ;     i := i + 1 ) ; 
    var lim : Sequence(int) ; lim := Integer.subrange(1,5)->collect(0) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    lim[1+1] := (st.next() + "")->toInteger() ; 
    lim[2+1] := (st.next() + "")->toInteger() ; 
    lim[3+1] := (st.next() + "")->toInteger() ; 
    lim[4+1] := (st.next() + "")->toInteger() ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 1 ; while j < 5 do ( (     if (cs[i+1][j+1] > lim[j+1]) then     continue else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(cs[i+1][0+1]) ; 
     sum := sum + 1 )  ;     i := i + 1 ) ; 
    if (sum = 0) then     OclFile["System.out"].println("NA") ; else skip ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  private void doit(){
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int[][] data=new int[n+1][4];
      for(int i=0 ; i<=n ; i++){
        for(int j=0 ; j<4 ; j++){
          data[i][j]=sc.nextInt();
        }
      }
      boolean NA=true ;
      for(int i=0 ; i<n ; i++){
        int nowC=4*data[i][1]+9*data[i][2]+4*data[i][3];
        if(data[i][1]<=data[n][0] && data[i][2]<=data[n][1] && data[i][3]<=data[n][2] && nowC<=data[n][3]){
          NA=false ;
          System.out.println(data[i][0]);
        }
      }
      if(NA)System.out.println("NA");
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation doit() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var data : Sequence(Sequence(int)) ; data := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,4)->collect(0)) ;
        var i : int ; i := 0 ; while i <= n do ( (         var j : int ; j := 0 ; while j < 4 do ( (     data[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var NA : boolean ; NA := true ;
        var i : int ; i := 0 ; while i < n do ( (     var nowC : int ; nowC := 4 * data[i+1][1+1] + 9 * data[i+1][2+1] + 4 * data[i+1][3+1] ;
     if (data[i+1][1+1] <= data[n+1][0+1] & data[i+1][2+1] <= data[n+1][1+1] & data[i+1][3+1] <= data[n+1][2+1] & nowC <= data[n+1][3+1]) then (     NA := false ; 
     OclFile["System.out"].println(data[i+1][0+1]) ) else skip )  ;     i := i + 1 ) ; 
    if (NA) then     OclFile["System.out"].println("NA") ; else skip ; 
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    PrintWriter pw=new PrintWriter(System.out);
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] L=new int[m];
    for(int i=0 ; i<m ; i++){
      L[i]=sc.nextInt();
    }
    int gap=0 ;
    for(int i=0 ; i<m-1 ; i++){
      if(gap<Math.abs(L[i]-L[i+1])){
        gap=Math.abs(L[i]-L[i+1]);
      }
    }
    if(gap<Math.abs(L[0]-(1-L[0]))){
      gap=Math.abs(L[0]-(1-L[0]));
    }
    if(gap<Math.abs(L[m-1]-(n+1+n-L[m-1]))){
      gap=Math.abs(L[m-1]-(n+1+n-L[m-1]));
    }
    if((gap-1)% 2==0){
      pw.println((gap-1)/2);
    }
    if((gap-1)% 2==1){
      pw.println((gap-1-1)/2+1);
    }
    sc.close();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var L : Sequence(int) ; L := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     L[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var gap : int ; gap := 0 ;
        var i : int ; i := 0 ; while i < m - 1 do ( (     if (gap < if L[i+1] - L[i + 1+1] < 0 then -(L[i+1] - L[i + 1+1]) else L[i+1] - L[i + 1+1] endif) then (     gap := if L[i+1] - L[i + 1+1] < 0 then -(L[i+1] - L[i + 1+1]) else L[i+1] - L[i + 1+1] endif ) else skip )  ;     i := i + 1 ) ; 
    if (gap < if L[0+1] - (1 - L[0+1]) < 0 then -(L[0+1] - (1 - L[0+1])) else L[0+1] - (1 - L[0+1]) endif) then (     gap := if L[0+1] - (1 - L[0+1]) < 0 then -(L[0+1] - (1 - L[0+1])) else L[0+1] - (1 - L[0+1]) endif ) else skip ; 
    if (gap < if L[m - 1+1] - (n + 1 + n - L[m - 1+1]) < 0 then -(L[m - 1+1] - (n + 1 + n - L[m - 1+1])) else L[m - 1+1] - (n + 1 + n - L[m - 1+1]) endif) then (     gap := if L[m - 1+1] - (n + 1 + n - L[m - 1+1]) < 0 then -(L[m - 1+1] - (n + 1 + n - L[m - 1+1])) else L[m - 1+1] - (n + 1 + n - L[m - 1+1]) endif ) else skip ; 
    if ((gap - 1) mod 2 = 0) then (     skip ) else skip ; 
    if ((gap - 1) mod 2 = 1) then (     skip ) else skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Set ;
public final class p061 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p061().run());
  }
  private Set<Integer>[][] numbers ;
  @ SuppressWarnings("unchecked")public String run(){
    numbers=new Set[9][100];
    for(int i=0 ; i<numbers.length ; i++){
      for(int j=0 ; j<numbers[i] .length ; j++)numbers[i][j]=new HashSet<>();
    }
    for(int sides=3 ; sides<=8 ; sides++){
      for(int n=1 ; ; n++){
        int num=figurateNumber(sides,n);
        if(num>=10000)break ;
        if(num>=1000)numbers[sides][num/100] .add(num);
      }
    }
    for(int i=10 ; i<100 ; i++){
      for(int num : numbers[3][i]){
        int temp=findSolutionSum(num,num,1<<3,num);
        if(temp!=-1)return Integer.toString(temp);
      }
    }
    throw new AssertionError("No solution");
  }
  private int findSolutionSum(int begin,int current,int sidesUsed,int sum){
    if(sidesUsed==0x1F8){
      if(current % 100==begin/100)return sum ;
    }
    else {
      for(int sides=4 ; sides<=8 ; sides++){
        if(((sidesUsed>>>sides)& 1)!=0)continue ;
        for(int num : numbers[sides][current % 100]){
          int temp=findSolutionSum(begin,num,sidesUsed |(1<<sides),sum+num);
          if(temp!=-1)return temp ;
        }
      }
    }
    return-1 ;
  }
  private static int figurateNumber(int sides,int n){
    return n*((sides-2)*n-(sides-4))/2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class p061 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p061.newp061().run()) );
   attribute numbers : Sequence(Sequence(Set(int)));
      operation run() : String
  pre: true
  post: true
  activity: (     numbers := Integer.subrange(1,9)->collect(Integer.subrange(1,100)->collect(null)) ; 
         var i : int ; i := 0 ; while i < numbers->size() do ( (         var j : int ; j := 0 ; while j < numbers[i+1]->size() do (     numbers[i+1][j+1] := Set{} ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var sides : int ; sides := 3 ; while sides <= 8 do ( (         var n : int ; n := 1 ; while true do ( (     var num : int ; num := figurateNumber(sides, n) ;
     if (num >= 10000) then     break else skip ; 
     if (num >= 1000) then     numbers[sides+1][num / 100+1]->excludes(num) ; else skip )  ;     n := n + 1 ) )  ;     sides := sides + 1 ) ; 
        var i : int ; i := 10 ; while i < 100 do ( (     for (num : numbers[3+1][i+1]) do ( (     var temp : int ; temp := findSolutionSum(num, num, (1*(2->pow(3)))->oclAsType(long), num) ;
     if (temp /= -1) then     return ((temp) + "") else skip )  ) )  ;     i := i + 1 ) ; 
    error AssertionException("No solution") ; 
 );
   operation findSolutionSum( begin : int, current : int, sidesUsed : int, sum : int) : int
  pre: true
  post: true
  activity: (     if (sidesUsed = 0x1F8) then (     if (current mod 100 = begin / 100) then     return sum else skip ) else (         var sides : int ; sides := 4 ; while sides <= 8 do ( (     if ((((sidesUsed/(2->pow(sides)))->oclAsType(long)) & 1) /= 0) then     continue else skip ; 
     for (num : numbers[sides+1][current mod 100+1]) do ( (     var temp : int ; temp := findSolutionSum(begin, num, sidesUsed or ((1*(2->pow(sides)))->oclAsType(long)), sum + num) ;
     if (temp /= -1) then     return temp else skip )  ) )  ;     sides := sides + 1 ) ) ;  
     return -1 );
  static   operation figurateNumber( sides : int, n : int) : int
  pre: true
  post: true
  activity: (     return n * ((sides - 2) * n - (sides - 4)) / 2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n ;
    String[] name=new String[1000];
    int[][] pqr=new int[1000][3];
    while((n=in.nextInt())!=0){
      for(int i=0 ; i<n ; i++){
        name[i]=in.next();
        pqr[i][0]=in.nextInt();
        pqr[i][1]=in.nextInt();
        pqr[i][2]=in.nextInt();
      }
      int P=in.nextInt();
      int Q=in.nextInt();
      int R=in.nextInt();
      int C=in.nextInt();
      boolean isNA=true ;
      for(int i=0 ; i<n ; i++){
        if(pqr[i][0]<=P && pqr[i][1]<=Q && pqr[i][2]<=R &&(pqr[i][0]+pqr[i][2])*4+pqr[i][1]*9<=C){
          System.out.println(name[i]);
          isNA=isNA && false ;
        }
      }
      if(isNA){
        System.out.println("NA");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var name : Sequence(String) ; name := Integer.subrange(1,1000)->collect(null) ;
    var pqr : Sequence(Sequence(int)) ; pqr := Integer.subrange(1,1000)->collect(Integer.subrange(1,3)->collect(0)) ;
        n := in.getCurrent()->toInteger() ;
    while ((n) /= 0) do (    skip ; (         var i : int ; i := 0 ; while i < n do ( (     name[i+1] := in.getCurrent() ; 
     pqr[i+1][0+1] := in.getCurrent()->toInteger() ; 
     pqr[i+1][1+1] := in.getCurrent()->toInteger() ; 
     pqr[i+1][2+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     var P : int ; P := in.getCurrent()->toInteger() ;
    var Q : int ; Q := in.getCurrent()->toInteger() ;
    var R : int ; R := in.getCurrent()->toInteger() ;
    var C : int ; C := in.getCurrent()->toInteger() ;
    var isNA : boolean ; isNA := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (pqr[i+1][0+1] <= P & pqr[i+1][1+1] <= Q & pqr[i+1][2+1] <= R & (pqr[i+1][0+1] + pqr[i+1][2+1]) * 4 + pqr[i+1][1+1] * 9 <= C) then (     OclFile["System.out"].println(name[i+1]) ; 
     isNA := isNA & false ) else skip )  ;     i := i + 1 ) ; 
    if (isNA) then (     OclFile["System.out"].println("NA") ) else skip ; 
 ) ;     n := in.getCurrent()->toInteger() ;
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GEE {
  static void printPFsInPairs(int n){
    for(int i=1 ; i*i<=n ; i++)if(n % i==0)System.out.println(i+"*"+n/i);
  }
  public static void main(String[] args){
    int n=24 ;
    printPFsInPairs(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GEE {
  static   operation printPFsInPairs( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i * i <= n do (     if (n mod i = 0) then     OclFile["System.out"].println(i + "*" + n / i) ; else skip ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 24 ;
     execute printPFsInPairs(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n-->0){
      String order=sc.next(),m=sc.next();
      int len=m.length();
      for(int i=order.length()-1 ; i>=0 ; i--){
        switch(order.charAt(i)){
          case 'J' : m=m.substring(len-1)+m.substring(0,len-1);
          break ;
          case 'C' : m=m.substring(1)+m.substring(0,1);
          break ;
          case 'E' : if(len % 2==0)m=m.substring(len/2)+m.substring(0,len/2);
          else m=m.substring(len/2+1)+m.substring(len/2,len/2+1)+m.substring(0,len/2);
          break ;
          case 'A' : m=new StringBuilder(m).reverse().toString();
          break ;
          case 'P' : String s="" ;
          for(int j=0 ; j<len ; j++){
            char c=m.charAt(j);
            if('0'<=c && c<='9'){
              if(c=='0')c='9' ;
              else c--;
            }
            s+=c ;
          }
          m=s ;
          break ;
          case 'M' : s="" ;
          for(int j=0 ; j<len ; j++){
            char c=m.charAt(j);
            if('0'<=c && c<='9'){
              if(c=='9')c='0' ;
              else c++;
            }
            s+=c ;
          }
          m=s ;
          break ;
        }
      }
      System.out.println(m);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var order : String ; order := sc.getCurrent() ;
    var m : String ; m := sc.getCurrent() ;
     var len : int ; len := m->size() ;
         var i : int ; i := order->size() - 1 ; while i >= 0 do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (order->at(i+1)) ; 
       if _switchval = 'J' then
     m := m.subrange((len)->char2byte() - 1+1,(len)->char2byte() - 1) + m.subrange(0+1,(len)->char2byte() - 1) ; 
    break 
   else skip ;
       if _switchval = 'C' then
     m := m.subrange(1+1,1) + m.subrange(0+1,1) ; 
    break 
   else skip ;
       if _switchval = 'E' then
     if (len mod 2 = 0) then     m := m.subrange(len / 2+1,len / 2) + m.subrange(0+1,len / 2) else     m := m.subrange(len / 2 + 1+1,len / 2 + 1) + m.subrange(len / 2+1,len / 2 + 1) + m.subrange(0+1,len / 2) ; ;  
    break 
   else skip ;
       if _switchval = 'A' then
     m := StringLib.newString(m)->reverse()+"" ; 
    break 
   else skip ;
       if _switchval = 'P' then
     var s : String ; s := "" ;
        var j : int ; j := 0 ; while j < len do ( (     var c : String ; c := m->at(j+1) ;
     if ('0' <= c & c <= '9') then (     if (c = '0') then     c := '9' ; else     c := c - 1 ; ) else skip ; 
     s := s+(c) )  ;     j := j + 1 ) ; 
    m := s ; 
    break 
   else skip ;
       if _switchval = 'M' then
     s := "" ; 
        var j : int ; j := 0 ; while j < len do ( (     var c : String ; c := m->at(j+1) ;
     if ('0' <= c & c <= '9') then (     if (c = '9') then     c := '0' ; else     c := c + 1 ; ) else skip ; 
     s := s+(c) )  ;     j := j + 1 ) ; 
    m := s ; 
    break 
   else skip ;
 )
 )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println(m) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static Scanner s=new Scanner(System.in);
  public static void main(String[] $){
    int n=s.nextInt();
    for(int q=0 ; q<n ; ++q){
      String m=s.next();
      StringBuilder v=new StringBuilder(s.next());
      for(int i=m.length()-1 ; i>=0 ; --i){
        switch(m.charAt(i)){
          case 'J' : v.insert(0,v.charAt(v.length()-1)).deleteCharAt(v.length()-1);
          break ;
          case 'C' : v.append(v.charAt(0)).deleteCharAt(0);
          break ;
          case 'E' : String t=v.substring(0,v.length()/2);
          String u=v.substring(v.length()-v.length()/2,v.length());
          v.replace(0,v.length()/2,u);
          v.replace(v.length()-v.length()/2,v.length(),t);
          break ;
          case 'A' : v.reverse();
          break ;
          case 'P' : for(int j=0 ;
          j<v.length();
++j){
            char c=v.charAt(j);
            if(Character.isDigit(c))v.setCharAt(j,(char)((c-'0'+9)% 10+'0'));
          }
          break ;
          case 'M' : for(int j=0 ;
          j<v.length();
++j){
            char c=v.charAt(j);
            if(Character.isDigit(c))v.setCharAt(j,(char)((c-'0'+1)% 10+'0'));
          }
          break ;
        }
      }
      System.out.println(v);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s.getCurrent()->toInteger() ;
         var q : int ; q := 0 ; while q < n do ( (     var m : String ; m := s.getCurrent() ;
     var v : String ; v := StringLib.newString(s.getCurrent()) ;
         var i : int ; i := m->size() - 1 ; while i >= 0 do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (m->at(i+1)) ; 
       if _switchval = 'J' then
     v := v.insertAt(0+1, StringLib.newString(v->at(v->size() - 1+1)))->excludingAt(v->size() - 1+1) ; 
    break 
   else skip ;
       if _switchval = 'C' then
     v := v + StringLib.newString(v->at(0+1))->excludingAt(0+1) ; 
    break 
   else skip ;
       if _switchval = 'E' then
     var t : String ; t := v.subrange(0+1,v->size() / 2) ;
    var u : String ; u := v.subrange(v->size() - v->size() / 2+1,v->size()) ;
    v.replace(0, v->size() / 2, u) ; 
    v.replace(v->size() - v->size() / 2, v->size(), t) ; 
    break 
   else skip ;
       if _switchval = 'A' then
     v := v->reverse() ; 
    break 
   else skip ;
       if _switchval = 'P' then
         var j : int ; j := 0 ; while j < v->size() do ( (     var c : String ; c := v->at(j+1) ;
     if ((c + "")->isMatch("[0-9]")) then     v := v.setAt(j+1, (((c)->char2byte() - ('0')->char2byte() + 9) mod 10 + '0')->oclAsType(String)) ; else skip )  ;     j := j + 1 ) ; 
    break 
   else skip ;
       if _switchval = 'M' then
         var j : int ; j := 0 ; while j < v->size() do ( (     var c : String ; c := v->at(j+1) ;
     if ((c + "")->isMatch("[0-9]")) then     v := v.setAt(j+1, (((c)->char2byte() - ('0')->char2byte() + 1) mod 10 + '0')->oclAsType(String)) ; else skip )  ;     j := j + 1 ) ; 
    break 
   else skip ;
 )
 )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println(v) )  ;     q := q + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf242a {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int x=in.nextInt();
    int y=in.nextInt();
    int a=in.nextInt();
    int b=in.nextInt();
    ArrayList<String>al=new ArrayList<String>();
    for(int i=a ; i<=x ; i++){
      for(int j=b ; j<=y ; j++){
        if(i>j){
          String d=i+" "+j ;
          al.add(d);
        }
      }
    }
    System.out.println(al.size());
    for(String d : al){
      System.out.println(d);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf242a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := in.getCurrent()->toInteger() ;
    var y : int ; y := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var al : Sequence(String) ; al := Sequence{} ;
        var i : int ; i := a ; while i <= x do ( (         var j : int ; j := b ; while j <= y do ( (     if (i > j) then (     var d : String ; d := i + " " + j ;
     al := al->including(d) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(al->size()) ; 
    for (d : al) do ( (     OclFile["System.out"].println(d) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class first {
  public static void main(String arg[]){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    while((t--)!=0){
      int x=input.nextInt();
      if(x % 2==0)System.out.println(0);
      else {
        int[] num ;
        num=new int[15];
        int pos=1 ;
        for(int i=1 ; i<=10 ; ++i){
          if((x % 10)!=0){
            num[i]=x % 10 ;
            x/=10 ;
          }
          else {
            pos=i-1 ;
            break ;
          }
        }
        if(num[pos] % 2==0)System.out.println(1);
        else {
          boolean k=false ;
          for(int i=1 ; i<=pos ; ++i){
            if(num[i] % 2==0){
              k=true ;
              System.out.println(2);
              break ;
            }
          }
          if(! k)System.out.println(-1);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class first {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         while ((t) /= 0) do (    skip ; (     var x : int ; x := input.getCurrent()->toInteger() ;
     if (x mod 2 = 0) then     OclFile["System.out"].println(0) ; else (     var num : Sequence(int) ;
     num := Integer.subrange(1,15)->collect(0) ; 
    var pos : int ; pos := 1 ;
        var i : int ; i := 1 ; while i <= 10 do ( (     if ((x mod 10) /= 0) then (     num[i+1] := x mod 10 ; 
     x := x/(10) ) else (     pos := i - 1 ; 
     break ) )  ;     i := i + 1 ) ; 
    if (num[pos+1] mod 2 = 0) then     OclFile["System.out"].println(1) else (     var k : boolean ; k := false ;
         var i : int ; i := 1 ; while i <= pos do ( (     if (num[i+1] mod 2 = 0) then (     k := true ; 
     OclFile["System.out"].println(2) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (not(k)) then     OclFile["System.out"].println(-1) ; else skip ) ;  
 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    for(int t=in.nextInt(); t>0 ; t--){
      minOp(in.nextInt());
    }
  }
  private static void minOp(int n){
    int[] digits=getDigits(n);
    int size=digits.length ;
    if((digits[size-1] & 1)==0)System.out.println(0);
    else if((digits[0] & 1)==0)System.out.println(1);
    else {
      int count=0 ;
      for(int i=size-2 ; i>0 ; i--){
        if((digits[i] & 1)==0)count++;
      }
      if(count>0)System.out.println(2);
      else System.out.println(-1);
    }
  }
  private static int[] getDigits(int n){
    List<Integer>digits=new ArrayList<>();
    while(n>0){
      digits.add(n % 10);
      n/=10 ;
    }
    int size=digits.size();
    int[] res=new int[size];
    for(int i=size-1 ; i>=0 ; i--)res[i]=digits.get(size-1-i);
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var t : int ; t := in.getCurrent()->toInteger() ; while t > 0 do ( (     execute minOp(in.getCurrent()->toInteger()) )  ;     t := t - 1 ) );
  static   operation minOp( n : int) : void
  pre: true
  post: true
  activity: (     var digits : Sequence(int) ; digits := getDigits(n) ;
     var size : int ; size := digits->size() ;
     if ((digits[size - 1+1] & 1) = 0) then     OclFile["System.out"].println(0) ; else     if ((digits[0+1] & 1) = 0) then     OclFile["System.out"].println(1) else (     var count : int ; count := 0 ;
         var i : int ; i := size - 2 ; while i > 0 do ( (     if ((digits[i+1] & 1) = 0) then     count := count + 1 ; else skip )  ;     i := i - 1 ) ; 
     if (count > 0) then     OclFile["System.out"].println(2) ; else     OclFile["System.out"].println(-1) ; ) ;  );
  static   operation getDigits( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var digits : Sequence(int) ; digits := Sequence{} ;
     while (n > 0) do (     digits := digits->including(n mod 10) ; 
     n := n/(10) ) ; 
    var size : int ; size := digits->size() ;
    var res : Sequence(int) ; res := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := size - 1 ; while i >= 0 do (     res[i+1] := digits->at(size - 1 - i+1) ;  ;     i := i - 1 ) ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Make_Even {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testcase=sc.nextInt();
    while(testcase!=0){
      testcase--;
      long num=sc.nextLong(),move=0,arr[]=new long[100],chuso ;
      int j=0 ;
      chuso=digit(num)-1 ;
      boolean okay=false ;
      if(num % 2==1){
        while(num!=0){
          arr[j]=num/pow(10,chuso);
          num %=pow(10,chuso);
          chuso--;
          j++;
        }
        if(arr[0] % 2==0){
          okay=true ;
          move=1 ;
        }
        else {
          for(int i=1 ; i<j ; i++){
            if(arr[i] % 2==0){
              okay=true ;
              move=2 ;
              break ;
            }
          }
        }
      }
      else if(num % 2==0)okay=true ;
      if(okay)System.out.print(move);
      else System.out.print(-1);
      if(testcase>0)System.out.println();
    }
    sc.close();
  }
  public static long digit(long x){
    long count=0 ;
    while(x!=0){
      x/=10 ;
      count++;
    }
    return count ;
  }
  public static long pow(long x,long y){
    if(y==0)return 1 ;
    else return pow(x,y-1)*x ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Make_Even {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testcase : int ; testcase := sc.getCurrent()->toInteger() ;
     while (testcase /= 0) do (     testcase := testcase - 1 ; 
     var num : long ; num := sc.getCurrent()->toLong() ;
    var move : long ; move := 0 ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,100)->collect(0) ;
    var chuso : long ;
    var j : int ; j := 0 ;
    chuso := digit(num) - 1 ; 
    var okay : boolean ; okay := false ;
    if (num mod 2 = 1) then (     while (num /= 0) do (     arr[j+1] := num / pow(10, chuso) ; 
     num := num mod pow(10, chuso) ; 
     chuso := chuso - 1 ; 
     j := j + 1 ) ; 
     if (arr[0+1] mod 2 = 0) then (     okay := true ; 
     move := 1 ) else (         var i : int ; i := 1 ; while i < j do ( (     if (arr[i+1] mod 2 = 0) then (     okay := true ; 
     move := 2 ; 
     break ) else skip )  ;     i := i + 1 ) ) ) else     if (num mod 2 = 0) then     okay := true ; else skip ; ;  
    if (okay) then     OclFile["System.out"].print(move) else     OclFile["System.out"].print(-1) ; ;  
    if (testcase > 0) then     OclFile["System.out"].println() ; else skip ; 
 ) ; 
     skip );
  static   operation digit( x : long) : long
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
     while (x /= 0) do (     x := x/(10) ; 
     count := count + 1 ) ; 
     return count );
  static   operation pow( x : long, y : long) : long
  pre: true
  post: true
  activity: (     if (y = 0) then     return 1 else     return pow(x, y - 1) * x );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long n=sc.nextInt();
      String str=String.valueOf(n);
      if(n % 2==0){
        System.out.println(0);
        continue ;
      }
      for(int j=0 ; j<str.length(); j++){
        if(str.charAt(j)% 2==0){
          if(j==0)System.out.println(1);
          else System.out.println(2);
          break ;
        }
        else if(j==str.length()-1){
          System.out.println(-1);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := sc.getCurrent()->toInteger() ;
     var str : String ; str := ((n) + "") ;
     if (n mod 2 = 0) then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
         var j : int ; j := 0 ; while j < str->size() do ( (     if (str->at(j+1) mod 2 = 0) then (     if (j = 0) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println(2) ; ;  
     break ) else     if (j = str->size() - 1) then (     OclFile["System.out"].println(-1) ) else skip ; )  ;     j := j + 1 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int a=sc.nextInt();
      int b=sc.nextInt();
      int ans=Math.min(b,a-b);
      if(b!=0)System.out.println(ans);
      else {
        System.out.println(1);
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := Set{b, a - b}->min() ;
    if (b /= 0) then     OclFile["System.out"].println(ans) else (     OclFile["System.out"].println(1) ) ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int s1=sc.nextInt();
    int s3=sc.nextInt();
    System.out.println((s1+s3)% 24);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : int ; s1 := sc.getCurrent()->toInteger() ;
     var s3 : int ; s3 := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println((s1 + s3) mod 24) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class vc {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    if(m==0){
      System.out.println((n==0)? 0 : 1);
    }
    else System.out.println((m>(n/2))?(n-m): m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class vc {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     if (m = 0) then (     OclFile["System.out"].println(if (n = 0) then 0 else 1 endif) ) else     OclFile["System.out"].println(if (m > (n / 2)) then (n - m) else m endif) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class EatingSoup {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    if(m==0){
      System.out.println(1);
      return ;
    }
    System.out.println(Math.min(m,n-m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class EatingSoup {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    if (m = 0) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    OclFile["System.out"].println(Set{m, n - m}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int N=sc.nextInt();
    int x=0 ;
    int s,f ;
    for(int i=0 ; i<N ; i++){
      s=sc.nextInt();
      f=sc.nextInt();
      if((b>s)&&(f>a)){
        System.out.println(1);
        x=1 ;
        return ;
      }
    }
    if(x==0){
      System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var x : int ; x := 0 ;
    var s : int ;
    var f : int ;
        var i : int ; i := 0 ; while i < N do ( (     s := sc.getCurrent()->toInteger() ; 
     f := sc.getCurrent()->toInteger() ; 
     if ((b > s) & (f > a)) then (     OclFile["System.out"].println(1) ; 
     x := 1 ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    if (x = 0) then (     OclFile["System.out"].println(0) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String args[]){
    BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    String str="" ;
    int[] syugo ;
    StringTokenizer stk ;
    int mae_y_s,mae_y_e=0 ;
    syugo=new int[1001];
    for(int i=0 ; i<1001 ; i++){
      syugo[i]=0 ;
    }
    try {
      str=bfr.readLine();
      if(str==""){
        System.exit(0);
      }
      stk=new StringTokenizer(str," ");
      int yoyaku_s,yoyaku_e=0 ;
      yoyaku_s=Integer.parseInt(stk.nextToken());
      yoyaku_e=Integer.parseInt(stk.nextToken());
      str=bfr.readLine();
      int yoyaku=Integer.parseInt(str);
      for(int i=0 ; i<yoyaku ; i++){
        str=bfr.readLine();
        if(str==""){
          System.exit(0);
        }
        stk=new StringTokenizer(str," ");
        mae_y_s=Integer.parseInt(stk.nextToken());
        mae_y_e=Integer.parseInt(stk.nextToken());
        for(int j=mae_y_s ; j<=mae_y_e-1 ; j++){
          syugo[j]=1 ;
        }
      }
      for(int a=yoyaku_s ; a<=yoyaku_e-1 ; a++){
        if(syugo[a]==0){
        }
        else {
          System.out.println("1");
          System.exit(0);
        }
      }
      System.out.println("0");
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bfr : OclFile ; bfr := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := "" ;
    var syugo : Sequence(int) ;
    var stk : OclIterator ;
    var mae_y_s : int ;
    var mae_y_e : int ; mae_y_e := 0 ;
    syugo := Integer.subrange(1,1001)->collect(0) ; 
        var i : int ; i := 0 ; while i < 1001 do ( (     syugo[i+1] := 0 )  ;     i := i + 1 ) ; 
    try (     str := bfr.readLine() ; 
     if (str = "") then ( OclProcess.exit(0) ) else skip ; 
    stk := OclIterator.newOclIterator_String_String(str, " ") ; 
    var yoyaku_s : int ;
    var yoyaku_e : int ; yoyaku_e := 0 ;
    yoyaku_s := (stk.next())->toInteger() ; 
    yoyaku_e := (stk.next())->toInteger() ; 
    str := bfr.readLine() ; 
    var yoyaku : int ; yoyaku := (str)->toInteger() ;
        var i : int ; i := 0 ; while i < yoyaku do ( (     str := bfr.readLine() ; 
     if (str = "") then ( OclProcess.exit(0) ) else skip ; 
    stk := OclIterator.newOclIterator_String_String(str, " ") ; 
    mae_y_s := (stk.next())->toInteger() ; 
    mae_y_e := (stk.next())->toInteger() ; 
        var j : int ; j := mae_y_s ; while j <= mae_y_e - 1 do ( (     syugo[j+1] := 1 )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
        var a : int ; a := yoyaku_s ; while a <= yoyaku_e - 1 do ( (     if (syugo[a+1] = 0) then skip else (     OclFile["System.out"].println("1") ; 
 OclProcess.exit(0) ) )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println("0") ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long mod=1000000007L ;
  static long mult(long a,long b){
    return((a % mod)*(b % mod))% mod ;
  }
  static long calculate_factors(long n){
    long ans,cnt ;
    cnt=0 ;
    ans=1 ;
    while(n % 2==0){
      cnt++;
      n=n/2 ;
    }
    if(cnt % 2==1){
      ans=mult(ans,(cnt+1));
    }
    for(int i=3 ; i<=Math.sqrt(n); i+=2){
      cnt=0 ;
      while(n % i==0){
        cnt++;
        n=n/i ;
      }
      if(cnt % 2==1){
        ans=mult(ans,(cnt+1));
      }
    }
    if(n>2){
      ans=mult(ans,(2));
    }
    return ans % mod ;
  }
  public static void main(String[] args){
    long n=193748576239475639L ;
    mod=17 ;
    System.out.print(calculate_factors(n)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute mod : long := 1000000007L;
  static   operation mult( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return ((a mod mod) * (b mod mod)) mod mod );
  static   operation calculate_factors( n : long) : long
  pre: true
  post: true
  activity: (     var ans : long ;
    var cnt : long ;
     cnt := 0 ; 
    ans := 1 ; 
    while (n mod 2 = 0) do (     cnt := cnt + 1 ; 
     n := n / 2 ) ; 
    if (cnt mod 2 = 1) then (     ans := mult(ans, (cnt + 1)) ) else skip ; 
        var i : int ; i := 3 ; while i <= (n)->sqrt() do ( (     cnt := 0 ; 
     while (n mod i = 0) do (     cnt := cnt + 1 ; 
     n := n / i ) ; 
     if (cnt mod 2 = 1) then (     ans := mult(ans, (cnt + 1)) ) else skip )  ;     i := i+(2) ) ; 
    if (n > 2) then (     ans := mult(ans, (2)) ) else skip ; 
    return ans mod mod 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 193748576239475639L ;
     mod := 17 ; 
     OclFile["System.out"].print(calculate_factors(n) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  static IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static IntStream REPS(int l,int r){
    return IntStream.rangeClosed(l,r);
  }
  static IntStream INS(int n){
    return REPS(n).map(i->getInt());
  }
  static Scanner s=new Scanner(System.in);
  static int getInt(){
    return Integer.parseInt(s.next());
  }
  public static void main(String[] $){
    int a=getInt(),b=getInt();
    for(int i=getInt(); i>0 ; --i){
      int A=getInt(),B=getInt();
      if(Math.min(b,B)-Math.max(a,A)>0){
        System.out.println(1);
        return ;
      }
    }
    System.out.println(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static   operation REPS( l : int, r : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(l, r) );
  static   operation INS( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return REPS(n)->collect( _x1 | (lambda i : OclAny in getInt())->apply(_x1) ) );
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := getInt() ;
    var b : int ; b := getInt() ;
         var i : int ; i := getInt() ; while i > 0 do ( (     var A : int ; A := getInt() ;
    var B : int ; B := getInt() ;
     if (Set{b, B}->min() - Set{a, A}->max() > 0) then (     OclFile["System.out"].println(1) ; 
     return ) else skip )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println(0) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int[] reserve=new int[1001];
    line=br.readLine();
    int a,b ;
    a=parseInt(line.substring(0,line.indexOf(' ')));
    b=parseInt(line.substring(line.indexOf(' ')+1));
    int N=parseInt(br.readLine());
    for(int i=0 ; i<N ; i++){
      line=br.readLine();
      int s,f ;
      s=parseInt(line.substring(0,line.indexOf(' ')));
      f=parseInt(line.substring(line.indexOf(' ')+1));
      reserve[s]++;
      reserve[f]--;
    }
    for(int i=1 ; i<=1000 ; i++){
      reserve[i]+=reserve[i-1];
    }
    int ans=0 ;
    for(int i=a ; i<b ; i++){
      if(reserve[i]>0){
        ans=1 ;
        break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var reserve : Sequence(int) ; reserve := Integer.subrange(1,1001)->collect(0) ;
    line := br.readLine() ; 
    var a : int ;
    var b : int ;
    a := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    b := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var N : int ; N := parseInt(br.readLine()) ;
        var i : int ; i := 0 ; while i < N do ( (     line := br.readLine() ; 
     var s : int ;
    var f : int ;
    s := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    f := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    reserve[s+1] := reserve[s+1] + 1 ; 
    reserve[f+1] := reserve[f+1] - 1 ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 1000 do ( (     reserve[i+1] := reserve[i+1]+(reserve[i - 1+1]) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := a ; while i < b do ( (     if (reserve[i+1] > 0) then (     ans := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      String str=reader.readLine();
      String s1[]=str.split(" ");
      int a=Integer.parseInt(s1[0]);
      int b=Integer.parseInt(s1[1]);
      int count=Integer.parseInt(reader.readLine());
      int s[]=new int[count];
      int f[]=new int[count];
      int tf=0 ;
      for(int i=0 ; i<count ; i++){
        String str2=reader.readLine();
        String s2[]=str2.split(" ");
        s[i]=Integer.parseInt(s2[0]);
        f[i]=Integer.parseInt(s2[1]);
      }
      for(int i=0 ; i<count ; i++){
        if(s[i]==a || f[i]==b){
          tf=1 ;
          break ;
        }
        else if(s[i]<a && a<f[i]){
          tf=1 ;
          break ;
        }
        else if(s[i]<b && b<f[i]){
          tf=1 ;
          break ;
        }
        else if(a<s[i] && f[i]<b){
          tf=1 ;
          break ;
        }
        else if(s[i]<a && b<f[i]){
          tf=1 ;
          break ;
        }
      }
      System.out.println(tf);
      reader.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  static int gcd(int a,int b){
    return b>0 ? gcd(b,a % b): a ;
  }
  static int lcm(int a,int b){
    return a*b/gcd(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var str : String ; str := reader.readLine() ;
     var s1 : Sequence(String) ; s1 := str->split(" ") ;
    var a : int ; a := (s1[0+1])->toInteger() ;
    var b : int ; b := (s1[1+1])->toInteger() ;
    var count : int ; count := (reader.readLine())->toInteger() ;
    var s : Sequence(int) ; s := Integer.subrange(1,count)->collect(0) ;
    var f : Sequence(int) ; f := Integer.subrange(1,count)->collect(0) ;
    var tf : int ; tf := 0 ;
        var i : int ; i := 0 ; while i < count do ( (     var str2 : String ; str2 := reader.readLine() ;
     var s2 : Sequence(String) ; s2 := str2->split(" ") ;
     s[i+1] := (s2[0+1])->toInteger() ; 
     f[i+1] := (s2[1+1])->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < count do ( (     if (s[i+1] = a or f[i+1] = b) then (     tf := 1 ; 
     break ) else     if (s[i+1] < a & a < f[i+1]) then (     tf := 1 ; 
     break ) else     if (s[i+1] < b & b < f[i+1]) then (     tf := 1 ; 
     break ) else     if (a < s[i+1] & f[i+1] < b) then (     tf := 1 ; 
     break ) else     if (s[i+1] < a & b < f[i+1]) then (     tf := 1 ; 
     break ) else skip ; ;  ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(tf) ; 
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b > 0 then gcd(b, a mod b) else a endif );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return a * b / gcd(a, b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int max_sum(int a[],int n){
    int[][] dp=new int[n+1][2];
    dp[0][0]=0 ;
    dp[0][1]=-999999 ;
    for(int i=0 ; i<=n-1 ; i++){
      dp[i+1][0]=Math.max(dp[i][0]+a[i],dp[i][1]-a[i]);
      dp[i+1][1]=Math.max(dp[i][0]-a[i],dp[i][1]+a[i]);
    }
    return dp[n][0];
  }
  public static void main(String[] args){
    int a[]={
-10,5,-4 };
      int n=a.length ;
      System.out.println(max_sum(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation max_sum( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,2)->collect(0)) ;
     dp[0+1][0+1] := 0 ; 
    dp[0+1][1+1] := -999999 ; 
        var i : int ; i := 0 ; while i <= n - 1 do ( (     dp[i + 1+1][0+1] := Set{dp[i+1][0+1] + a[i+1], dp[i+1][1+1] - a[i+1]}->max() ; 
     dp[i + 1+1][1+1] := Set{dp[i+1][0+1] - a[i+1], dp[i+1][1+1] + a[i+1]}->max() )  ;     i := i + 1 ) ; 
    return dp[n+1][0+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{-10,5,-4} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(max_sum(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  static void nearestGcd(int[] arr,int n){
    for(int i=0 ; i<n ; ++i){
      int closest=-1 ;
      for(int j=i-1,k=i+1 ; j>0 || k<=n ; --j,++k){
        if(j>=0 && __gcd(arr[i],arr[j])>1){
          closest=j+1 ;
          break ;
        }
        if(k<n && __gcd(arr[i],arr[k])>1){
          closest=k+1 ;
          break ;
        }
      }
      System.out.print(closest+" ");
    }
  }
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  public static void main(String args[]){
    int[] arr={
      2,9,4,3,13 };
      int n=arr.length ;
      nearestGcd(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nearestGcd( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var closest : int ; closest := -1 ;
         var j : int ; j := i - 1 ;
    var k : int ; k := i + 1 ; while j > 0 or k <= n do ( (     if (j >= 0 & __gcd(arr[i+1], arr[j+1]) > 1) then (     closest := j + 1 ; 
     break ) else skip ; 
     if (k < n & __gcd(arr[i+1], arr[k+1]) > 1) then (     closest := k + 1 ; 
     break ) else skip )  ;     j := j - 1 ;     k := k + 1 ) ; 
     OclFile["System.out"].print(closest + " ") )  ;     i := i + 1 ) );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,9,4,3,13} ;
     var n : int ; n := arr->size() ;
     execute nearestGcd(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPrefix(String str,int len,int i,int k){
    if(i+k>len)return false ;
    for(int j=0 ; j<k ; j++){
      if(str.charAt(i)!=str.charAt(j))return false ;
      i++;
    }
    return true ;
  }
  static boolean isKPeriodic(String str,int len,int k){
    for(int i=k ; i<len ; i+=k)if(! isPrefix(str,len,i,k))return false ;
    return true ;
  }
  public static void main(String[] args){
    String str="geeksgeeks" ;
    int len=str.length();
    int k=5 ;
    if(isKPeriodic(str,len,k))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrefix( str : String, len : int, i : int, k : int) : boolean
  pre: true
  post: true
  activity: (     if (i + k > len) then     return false else skip ; 
         var j : int ; j := 0 ; while j < k do ( (     if (str->at(i+1) /= str->at(j+1)) then     return false else skip ; 
     i := i + 1 )  ;     j := j + 1 ) ; 
     return true );
  static   operation isKPeriodic( str : String, len : int, k : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := k ; while i < len do (     if (not(isPrefix(str, len, i, k))) then     return false else skip ;  ;     i := i+(k) ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksgeeks" ;
     var len : int ; len := str->size() ;
     var k : int ; k := 5 ;
     if (isKPeriodic(str, len, k)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  void solve(){
    int a=inint(),b=inint();
    out.println((a+b)% 24);
  }
  public static Scanner in=new Scanner(System.in);
  public static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    new Main().solve();
    out.flush();
  }
  public int inint(){
    return in.nextInt();
  }
  public long inlong(){
    return in.nextLong();
  }
  public String instr(){
    return in.next();
  }
  public char inchar(){
    return in.next().charAt(0);
  }
  public int[] inintar(int num){
    int[] a=new int[num];
    for(int i=0 ; i<num ; i++){
      a[i]=in.nextInt();
    }
    return a ;
  }
  public char[] incharar(){
    return in.next().toCharArray();
  }
  public char[][] incharmap(int h,int w){
    char[][] a=new char[h][w];
    for(int i=0 ; i<h ; i++){
      String temp=in.next();
      for(int j=0 ; j<w ; j++){
        a[i][j]=temp.charAt(j);
      }
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ; a := inint() ;
    var b : int ; b := inint() ;
     out.println((a + b) mod 24) );
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() ; 
     skip );
   operation inint() : int
  pre: true
  post: true
  activity: (     return in.getCurrent()->toInteger() );
   operation inlong() : long
  pre: true
  post: true
  activity: (     return in.getCurrent()->toLong() );
   operation instr() : String
  pre: true
  post: true
  activity: (     return in.getCurrent() );
   operation inchar() : String
  pre: true
  post: true
  activity: (     return in.getCurrent()->at(0+1) );
   operation inintar( num : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,num)->collect(0) ;
         var i : int ; i := 0 ; while i < num do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return a );
   operation incharar() : Sequence(String)
  pre: true
  post: true
  activity: (     return in.getCurrent()->characters() );
   operation incharmap( h : int, w : int) : Sequence(Sequence(String))
  pre: true
  post: true
  activity: (     var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
         var i : int ; i := 0 ; while i < h do ( (     var temp : String ; temp := in.getCurrent() ;
         var j : int ; j := 0 ; while j < w do ( (     a[i+1][j+1] := temp->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int tt=0 ; tt<T ; tt++){
      long x=in.nextLong(),y=in.nextLong();
      long a=in.nextLong(),b=in.nextLong();
      long ans=0 ;
      if(x>0 && y>0){
        if(a*2>b){
          ans+=Math.min(x,y)*b ;
        }
        else {
          ans+=Math.min(x,y)*a*2 ;
        }
        long temp=Math.min(x,y);
        x-=temp ;
        y-=temp ;
      }
      if(x==0){
        ans+=y*a ;
      }
      else {
        ans+=x*a ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var tt : int ; tt := 0 ; while tt < T do ( (     var x : long ; x := in.getCurrent()->toLong() ;
    var y : long ; y := in.getCurrent()->toLong() ;
     var a : long ; a := in.getCurrent()->toLong() ;
    var b : long ; b := in.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
    if (x > 0 & y > 0) then (     if (a * 2 > b) then (     ans := ans+(Set{x, y}->min() * b) ) else (     ans := ans+(Set{x, y}->min() * a * 2) ) ;  
     var temp : long ; temp := Set{x, y}->min() ;
     x := x-(temp) ; 
     y := y-(temp) ) else skip ; 
    if (x = 0) then (     ans := ans+(y * a) ) else (     ans := ans+(x * a) ) ;  
    OclFile["System.out"].println(ans) ; 
 )  ;     tt := tt + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        long x=sc.nextInt();
        long y=sc.nextInt();
        long a=sc.nextInt();
        long b=sc.nextInt();
        if(x==0 && y==0)System.out.println(0);
        else {
          b=Math.min(b,2*a);
          if(x<y){
            long temp=x ;
            x=y ;
            y=temp ;
          }
          System.out.println(y*b+(x-y)*a);
        }
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x : long ; x := sc.getCurrent()->toInteger() ;
     var y : long ; y := sc.getCurrent()->toInteger() ;
    var a : long ; a := sc.getCurrent()->toInteger() ;
    var b : long ; b := sc.getCurrent()->toInteger() ;
    if (x = 0 & y = 0) then     OclFile["System.out"].println(0) else (     b := Set{b, 2 * a}->min() ; 
     if (x < y) then (     var temp : long ; temp := x ;
     x := y ; 
     y := temp ) else skip ; 
     OclFile["System.out"].println(y * b + (x - y) * a) ) ;  
 ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A1342 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    long x,y,a,b,ans,diff ;
    for(int i=0 ; i<t ; i++){
      x=sc.nextInt();
      y=sc.nextInt();
      a=sc.nextInt();
      b=sc.nextInt();
      diff=Math.abs(x-y);
      ans=(x+y)*a ;
      if(x<y){
        ans=Math.min(ans,x*b+a*diff);
      }
      else {
        ans=Math.min(ans,y*b+a*diff);
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1342 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     var x : long ;
    var y : long ;
    var a : long ;
    var b : long ;
    var ans : long ;
    var diff : long ;
         var i : int ; i := 0 ; while i < t do ( (     x := sc.getCurrent()->toInteger() ; 
     y := sc.getCurrent()->toInteger() ; 
    a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    diff := if x - y < 0 then -(x - y) else x - y endif ; 
    ans := (x + y) * a ; 
    if (x < y) then (     ans := Set{ans, x * b + a * diff}->min() ) else (     ans := Set{ans, y * b + a * diff}->min() ) ;  
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf32A {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String s=input.next();
    String str="" ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='.')str+=0 ;
      else {
        if(s.charAt(i)=='-' && s.charAt(i+1)=='.')str+=1 ;
        else str+=2 ;
        i++;
      }
    }
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf32A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := input.getCurrent() ;
    var str : String ; str := "" ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '.') then     str := str+(0) ; else (     if (s->at(i+1) = '-' & s->at(i + 1+1) = '.') then     str := str+(1) else     str := str+(2) ; ;  
     i := i + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      long x=sc.nextLong();
      long y=sc.nextLong();
      long a=sc.nextLong();
      long b=sc.nextLong();
      System.out.println(Math.min((a*x+a*y),(b*Math.min(x,y)+a*(Math.abs(x-y)))));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var x : long ; x := sc.getCurrent()->toLong() ;
     var y : long ; y := sc.getCurrent()->toLong() ;
    var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    OclFile["System.out"].println(Set{(a * x + a * y), (b * Set{x, y}->min() + a * (if x - y < 0 then -(x - y) else x - y endif))}->min()) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  static int digitProduct(int[] digits,int start,int end){
    int pro=1 ;
    for(int i=start ; i<=end ; i++){
      pro*=digits[i];
    }
    return pro ;
  }
  static boolean isDistinct(int N){
    String s=""+N ;
    int len=s.length();
    int[] digits=new int[len];
    ArrayList<Integer>products=new ArrayList<>();
    for(int i=0 ; i<len ; i++){
      digits[i]=Integer.parseInt(""+s.charAt(i));
    }
    for(int i=0 ; i<len ; i++){
      for(int j=i ; j<len ; j++){
        int val=digitProduct(digits,i,j);
        if(products.contains(val))return false ;
        else products.add(val);
      }
    }
    return true ;
  }
  public static void main(String args[]){
    int N=324 ;
    if(isDistinct(N))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation digitProduct( digits : Sequence(int), start : int, end : int) : int
  pre: true
  post: true
  activity: (     var pro : int ; pro := 1 ;
         var i : int ; i := start ; while i <= end do ( (     pro := pro*(digits[i+1]) )  ;     i := i + 1 ) ; 
     return pro );
  static   operation isDistinct( N : int) : boolean
  pre: true
  post: true
  activity: (     var s : String ; s := "" + N ;
     var len : int ; len := s->size() ;
    var digits : Sequence(int) ; digits := Integer.subrange(1,len)->collect(0) ;
    var products : Sequence(int) ; products := Sequence{} ;
        var i : int ; i := 0 ; while i < len do ( (     digits[i+1] := ("" + s->at(i+1))->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < len do ( (         var j : int ; j := i ; while j < len do ( (     var val : int ; val := digitProduct(digits, i, j) ;
     if (products->includes(val)) then     return false else     products := products->including(val) ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 324 ;
     if (isDistinct(N)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int tmpsu=sc.nextInt();
    int[] iki_tra=new int[tmpsu];
    int[] kae_tra=new int[tmpsu];
    int iki_toutatuka=0 ;
    int kae_toutatuka=0 ;
    for(int i=0 ; i<tmpsu ; i++){
      iki_tra[i]=sc.nextInt();
      kae_tra[tmpsu-1-i]=iki_tra[i];
    }
    for(int i=0 ; i<tmpsu ; i++){
      if(iki_toutatuka<10*i){
        System.out.println("no");
        System.exit(0);
      }
      int tmp=i*10+iki_tra[i];
      if(tmp>iki_toutatuka){
        iki_toutatuka=tmp ;
      }
    }
    for(int i=0 ; i<tmpsu ; i++){
      if(kae_toutatuka<10*i){
        System.out.println("no");
        System.exit(0);
      }
      int tmp=i*10+kae_tra[i];
      if(tmp>kae_toutatuka){
        kae_toutatuka=tmp ;
      }
    }
    System.out.println("yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tmpsu : int ; tmpsu := sc.getCurrent()->toInteger() ;
    var iki_tra : Sequence(int) ; iki_tra := Integer.subrange(1,tmpsu)->collect(0) ;
    var kae_tra : Sequence(int) ; kae_tra := Integer.subrange(1,tmpsu)->collect(0) ;
    var iki_toutatuka : int ; iki_toutatuka := 0 ;
    var kae_toutatuka : int ; kae_toutatuka := 0 ;
        var i : int ; i := 0 ; while i < tmpsu do ( (     iki_tra[i+1] := sc.getCurrent()->toInteger() ; 
     kae_tra[tmpsu - 1 - i+1] := iki_tra[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < tmpsu do ( (     if (iki_toutatuka < 10 * i) then (     OclFile["System.out"].println("no") ; 
 OclProcess.exit(0) ) else skip ; 
     var tmp : int ; tmp := i * 10 + iki_tra[i+1] ;
     if (tmp > iki_toutatuka) then (     iki_toutatuka := tmp ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < tmpsu do ( (     if (kae_toutatuka < 10 * i) then (     OclFile["System.out"].println("no") ; 
 OclProcess.exit(0) ) else skip ; 
     var tmp : int ; tmp := i * 10 + kae_tra[i+1] ;
     if (tmp > kae_toutatuka) then (     kae_toutatuka := tmp ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("yes") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(in.readLine());
    int[] trump=new int[n];
    int i=0 ;
    String line ;
    for(int u=0 ; u<n ; u++){
      line=in.readLine();
      trump[i]=Integer.parseInt(line);
      i++;
    }
    boolean isok=true ;
    for(int j=0 ; j<n ; j++){
      if(trump[j]<10){
        if(j==0){
          isok=false ;
        }
        else {
          for(int k=j-1 ; k>=0 ; k--){
            if(trump[k]>=(j-k+1)*10){
              isok=true ;
              break ;
            }
            else {
              isok=false ;
            }
          }
        }
        if(! isok)break ;
      }
    }
    if(isok){
      int[] trumpreturn=new int[n];
      for(int y=0 ; y<n ; y++){
        trumpreturn[y]=trump[n-y-1];
      }
      for(int j=0 ; j<n ; j++){
        if(trumpreturn[j]<10){
          if(j==0){
            isok=false ;
          }
          else {
            for(int k=j-1 ; k>=0 ; k--){
              if(trumpreturn[k]>=(j-k+1)*10){
                isok=true ;
                break ;
              }
              else {
                isok=false ;
              }
            }
          }
          if(! isok)break ;
        }
      }
    }
    String judge ;
    if(isok){
      judge="yes" ;
    }
    else {
      judge="no" ;
    }
    System.out.println(judge);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (in.readLine())->toInteger() ;
    var trump : Sequence(int) ; trump := Integer.subrange(1,n)->collect(0) ;
    var i : int ; i := 0 ;
    var line : String ;
        var u : int ; u := 0 ; while u < n do ( (     line := in.readLine() ; 
     trump[i+1] := (line)->toInteger() ; 
     i := i + 1 )  ;     u := u + 1 ) ; 
    var isok : boolean ; isok := true ;
        var j : int ; j := 0 ; while j < n do ( (     if (trump[j+1] < 10) then (     if (j = 0) then (     isok := false ) else (         var k : int ; k := j - 1 ; while k >= 0 do ( (     if (trump[k+1] >= (j - k + 1) * 10) then (     isok := true ; 
     break ) else (     isok := false ) )  ;     k := k - 1 ) ) ;  
     if (not(isok)) then     break else skip ) else skip )  ;     j := j + 1 ) ; 
    if (isok) then (     var trumpreturn : Sequence(int) ; trumpreturn := Integer.subrange(1,n)->collect(0) ;
         var y : int ; y := 0 ; while y < n do ( (     trumpreturn[y+1] := trump[n - y - 1+1] )  ;     y := y + 1 ) ; 
         var j : int ; j := 0 ; while j < n do ( (     if (trumpreturn[j+1] < 10) then (     if (j = 0) then (     isok := false ) else (         var k : int ; k := j - 1 ; while k >= 0 do ( (     if (trumpreturn[k+1] >= (j - k + 1) * 10) then (     isok := true ; 
     break ) else (     isok := false ) )  ;     k := k - 1 ) ) ;  
     if (not(isok)) then     break else skip ) else skip )  ;     j := j + 1 ) ) else skip ; 
    var judge : String ;
    if (isok) then (     judge := "yes" ) else (     judge := "no" ) ;  
    OclFile["System.out"].println(judge) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  int n=0 ;
  ArrayList<Integer>m_bounce=new ArrayList<Integer>();
  boolean IsReachable(){
    int current=0 ;
    for(int i=0 ; i<n ; ++i){
      if(current<10*i)return false ;
      current=Math.max(current,10*i+m_bounce.get(i));
      if(current>=10*n)return true ;
    }
    return false ;
  }
  void solve(){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    for(int i=0 ; i<n ; ++i)m_bounce.add(sc.nextInt());
    if(! IsReachable()){
      System.out.println("no");
      return ;
    }
    Collections.reverse(m_bounce);
    if(! IsReachable())System.out.println("no");
    else System.out.println("yes");
  }
  public static void main(String[] a){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int := 0;
   attribute m_bounce : Sequence(int) := Sequence{};
   operation IsReachable() : boolean
  pre: true
  post: true
  activity: (     var current : int ; current := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (current < 10 * i) then     return false else skip ; 
     current := Set{current, 10 * i + m_bounce->at(i+1)}->max() ; 
     if (current >= 10 * n) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do (     m_bounce := m_bounce->including(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    if (not(IsReachable())) then (     OclFile["System.out"].println("no") ; 
     return ) else skip ; 
    m_bounce := m_bounce->reverse() ; 
    if (not(IsReachable())) then     OclFile["System.out"].println("no") else     OclFile["System.out"].println("yes") ; ;  
 );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Comparator ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args)throws Exception {
    new Main().run();
  }
  void run(){
    int n=nint();
    int[] ds=new int[n];
    for(int i=0 ; i<n ; i++)ds[i]=nint();
    System.out.println(judge(n,ds)? "yes" : "no");
  }
  boolean judge(int n,int[] ds){
    PriorityQueue<Integer>minHeap=new PriorityQueue<>(n,Comparator.naturalOrder());
    minHeap.offer(ds[0]);
    for(int i=1 ; i<n ; i++){
      while(! minHeap.isEmpty()){
        int x=minHeap.peek();
        if(x<i*10)minHeap.poll();
        else break ;
      }
      if(minHeap.isEmpty())return false ;
      minHeap.offer(i*10+ds[i]);
    }
    PriorityQueue<Integer>maxHeap=new PriorityQueue<>(n,Comparator.reverseOrder());
    maxHeap.offer((n-1)*10-ds[n-1]);
    for(int i=n-2 ; i>=0 ; i--){
      while(! maxHeap.isEmpty()){
        int x=maxHeap.peek();
        if(x>i*10)maxHeap.poll();
        else break ;
      }
      if(maxHeap.isEmpty())return false ;
      maxHeap.offer(i*10-ds[i]);
    }
    return true ;
  }
  int nint(){
    return Integer.parseInt(sc.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nint() ;
     var ds : Sequence(int) ; ds := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     ds[i+1] := nint() ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if judge(n, ds) then "yes" else "no" endif) );
   operation judge( n : int, ds : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var minHeap : Sequence(int) ; minHeap := Sequence{} ;
     minHeap := minHeap->including(ds[0+1]) ; 
        var i : int ; i := 1 ; while i < n do ( (     while (not(minHeap->isEmpty())) do (     var x : int ; x := minHeap->min() ;
     if (x < i * 10) then     minHeap := minHeap->sort()->tail() ; else     break ) ; 
     if (minHeap->isEmpty()) then     return false else skip ; 
     minHeap := minHeap->including(i * 10 + ds[i+1]) )  ;     i := i + 1 ) ; 
    var maxHeap : Sequence(int) ; maxHeap := Sequence{} ;
    maxHeap := maxHeap->including((n - 1) * 10 - ds[n - 1+1]) ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     while (not(maxHeap->isEmpty())) do (     var x : int ; x := maxHeap->min() ;
     if (x > i * 10) then     maxHeap := maxHeap->sort()->tail() ; else     break ) ; 
     if (maxHeap->isEmpty()) then     return false else skip ; 
     maxHeap := maxHeap->including(i * 10 - ds[i+1]) )  ;     i := i - 1 ) ; 
    return true 
 );
   operation nint() : int
  pre: true
  post: true
  activity: (     return (sc.getCurrent())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.InputMismatchException ;
import java.util.Map ;
import java.util.StringTokenizer ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskX solver=new TaskX();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskX {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int a=in.nextInt();
      int b=in.nextInt();
      out.println((a+b)% 24);
    }
  }
  static class ArrayUtils {
    public static Map<Integer,Integer>getCountMap(int[] array){
      Map<Integer,Integer>map=new TreeMap<>();
      for(int x : array)map.merge(x,1,Integer :: sum);
      return map ;
    }
  }
  static class InputReader {
    BufferedReader in ;
    StringTokenizer tok ;
    public String nextString(){
      while(! tok.hasMoreTokens()){
        try {
          tok=new StringTokenizer(in.readLine()," ");
        }
        catch(IOException e){
          throw new InputMismatchException();
        }
      }
      return tok.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(nextString());
    }
    public long nextLong(){
      return Long.parseLong(nextString());
    }
    public int[] nextIntArray(int n){
      int[] res=new int[n];
      for(int i=0 ; i<n ; i++){
        res[i]=nextInt();
      }
      return res ;
    }
    public InputReader(InputStream inputStream){
      in=new BufferedReader(new InputStreamReader(inputStream));
      tok=new StringTokenizer("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskX ; solver := TaskX.newTaskX() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskX {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.nextInt() ;
     var b : int ; b := in.nextInt() ;
     skip );
}
  static class ArrayUtils {
  static   operation getCountMap( array : Sequence(int)) : Map(int,int)
  pre: true
  post: true
  activity: (     var map : Map(int,int) ; map := Map{} ;
     for (x : array) do (     map := map.merge(x, 1, lambda _pars : OclAny in Integer.newInteger().sum(_pars)) ;  ) ; 
     return map );
}
  static class InputReader {
   attribute in : OclFile;
   attribute tok : OclIterator;
   operation nextString() : String
  pre: true
  post: true
  activity: (     while (not(tok.hasNext())) do (     try (     tok := OclIterator.newOclIterator_String_String(in.readLine(), " ") )   catch (e : IOException) do (     error IncorrectElementException() )
 ) ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextString())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextString())->toLong() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return res );
   static operation newInputReader( inputStream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) ; 
     tok := OclIterator.newOclIterator_String("") );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class practice {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int l=s.nextInt();
      int r=s.nextInt();
      int k=s.nextInt();
      if(l==r && l==1){
        System.out.println("NO");
        continue ;
      }
      if(l==r){
        System.out.println("YES");
        continue ;
      }
      int oddc=0 ;
      if(l % 2!=0){
        oddc=1 ;
        l++;
      }
      if(r % 2!=0){
        oddc++;
        r--;
      }
      oddc+=(r-l)/2 ;
      if(k>=oddc){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var l : int ; l := s.getCurrent()->toInteger() ;
     var r : int ; r := s.getCurrent()->toInteger() ;
    var k : int ; k := s.getCurrent()->toInteger() ;
    if (l = r & l = 1) then (     OclFile["System.out"].println("NO") ; 
     continue ) else skip ; 
    if (l = r) then (     OclFile["System.out"].println("YES") ; 
     continue ) else skip ; 
    var oddc : int ; oddc := 0 ;
    if (l mod 2 /= 0) then (     oddc := 1 ; 
     l := l + 1 ) else skip ; 
    if (r mod 2 /= 0) then (     oddc := oddc + 1 ; 
     r := r - 1 ) else skip ; 
    oddc := oddc+((r - l) / 2) ; 
    if (k >= oddc) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1629 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    StringBuilder output=new StringBuilder();
    for(int t=0 ; t<T ; t++){
      int L=in.nextInt();
      int R=in.nextInt();
      int K=in.nextInt();
      boolean possible ;
      if(L==R){
        possible=(L!=1);
      }
      else {
        int oddCount=(R+1)/2-L/2 ;
        possible=oddCount<=K ;
      }
      output.append(possible ? "YES\n" : "NO\n");
    }
    System.out.print(output);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1629 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
    var output : String ; output := StringLib.newString() ;
        var t : int ; t := 0 ; while t < T do ( (     var L : int ; L := in.getCurrent()->toInteger() ;
     var R : int ; R := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    var possible : boolean ;
    if (L = R) then (     possible := (L /= 1) ) else (     var oddCount : int ; oddCount := (R + 1) / 2 - L / 2 ;
     possible := oddCount <= K ) ;  
    output := output + StringLib.newString(if possible then "YES\n" else "NO\n" endif) ; 
 )  ;     t := t + 1 ) ; 
    OclFile["System.out"].print(output) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test122 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char[] n=in.next().toCharArray();
    boolean s=false ;
    for(int i=0 ; i<n.length ; i++){
      if(n[i]=='.'){
        if(s){
          System.out.print(1);
          s=false ;
        }
        else {
          System.out.print(0);
        }
      }
      else {
        if(s){
          System.out.print(2);
          s=false ;
        }
        else {
          s=true ;
        }
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test122 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : Sequence(String) ; n := in.getCurrent()->characters() ;
    var s : boolean ; s := false ;
        var i : int ; i := 0 ; while i < n->size() do ( (     if (n[i+1] = '.') then (     if (s) then (     OclFile["System.out"].print(1) ; 
     s := false ) else (     OclFile["System.out"].print(0) ) ) else (     if (s) then (     OclFile["System.out"].print(2) ; 
     s := false ) else (     s := true ) ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GCDArrays {
  public static void main(String[] args)throws IOException {
    Scanner file=new Scanner(System.in);
    for(int N=file.nextInt(); N>0 ; --N){
      int l=file.nextInt(),r=file.nextInt(),k=file.nextInt();
      int odds=r/2+r % 2 ;
      odds-=l/2 ;
      System.out.println(k>=odds || l>1 && l==r ? "YES" : "NO");
    }
    file.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class GCDArrays {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var file : OclFile ; file := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var N : int ; N := file.getCurrent()->toInteger() ; while N > 0 do ( (     var l : int ; l := file.getCurrent()->toInteger() ;
    var r : int ; r := file.getCurrent()->toInteger() ;
    var k : int ; k := file.getCurrent()->toInteger() ;
     var odds : int ; odds := r / 2 + r mod 2 ;
     odds := odds-(l / 2) ; 
     OclFile["System.out"].println(if k >= odds or l > 1 & l = r then "YES" else "NO" endif) )  ;     N := N - 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class EDU_11A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=in.nextLong();
    ArrayList<Long>ans=new ArrayList<>();
    ans.add(a[0]);
    for(int i=1 ; i<n ; i++){
      long gcd=gcd(a[i-1],a[i]);
      if(gcd==1)ans.add(a[i]);
      else {
        ans.add(1L);
        ans.add(a[i]);
      }
    }
    pw.println(ans.size()-n);
    for(long x : ans)pw.print(x+" ");
    pw.println();
    pw.close();
  }
  static long gcd(long a,long b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class EDU_11A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var ans : Sequence(long) ; ans := Sequence{} ;
    ans := ans->including(a[0+1]) ; 
        var i : int ; i := 1 ; while i < n do ( (     var gcd : long ; gcd := gcd(a[i - 1+1], a[i+1]) ;
     if (gcd = 1) then     ans := ans->including(a[i+1]) ; else (     ans := ans->including(1L) ; 
     ans := ans->including(a[i+1]) ) )  ;     i := i + 1 ) ; 
    skip ; 
    for (x : ans) do (     skip ;  ) ; 
    skip ; 
    skip ; 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maxSquareSubsetSum(int[] A,int N){
    int sub1=0,sub2=0 ;
    Arrays.sort(A);
    for(int i=0 ; i<N ; i++){
      if(i<(N/2)-1)sub1+=A[i];
      else sub2+=A[i];
    }
    return sub1*sub1+sub2*sub2 ;
  }
  public static void main(String[] args){
    int arr[]={
      7,2,13,4,25,8 };
      int N=arr.length ;
      System.out.println(maxSquareSubsetSum(arr,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSquareSubsetSum( A : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var sub1 : int ; sub1 := 0 ;
    var sub2 : int ; sub2 := 0 ;
     A := A->sort() ; 
         var i : int ; i := 0 ; while i < N do ( (     if (i < (N / 2) - 1) then     sub1 := sub1+(A[i+1]) ; else     sub2 := sub2+(A[i+1]) ; )  ;     i := i + 1 ) ; 
     return sub1 * sub1 + sub2 * sub2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{7,2,13,4,25,8} ;
     var N : int ; N := arr->size() ;
     OclFile["System.out"].println(maxSquareSubsetSum(arr, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int reversDigits(int num){
    int rev_num=0 ;
    while(num>0){
      rev_num=rev_num*10+num % 10 ;
      num=num/10 ;
    }
    return rev_num ;
  }
  static void icanobifNumbers(int N){
    int first=0,second=1 ;
    if(N==1)System.out.print(first);
    else if(N==2)System.out.print(first+" "+second);
    else {
      System.out.print(first+" "+second+" ");
      for(int i=3 ; i<=N ; i++){
        int x=reversDigits(first);
        int y=reversDigits(second);
        System.out.print(x+y+" ");
        int temp=second ;
        second=x+y ;
        first=temp ;
      }
    }
  }
  public static void main(String[] args){
    int N=12 ;
    icanobifNumbers(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation reversDigits( num : int) : int
  pre: true
  post: true
  activity: (     var rev_num : int ; rev_num := 0 ;
     while (num > 0) do (     rev_num := rev_num * 10 + num mod 10 ; 
     num := num / 10 ) ; 
     return rev_num );
  static   operation icanobifNumbers( N : int) : void
  pre: true
  post: true
  activity: (     var first : int ; first := 0 ;
    var second : int ; second := 1 ;
     if (N = 1) then     OclFile["System.out"].print(first) ; else     if (N = 2) then     OclFile["System.out"].print(first + " " + second) else (     OclFile["System.out"].print(first + " " + second + " ") ; 
         var i : int ; i := 3 ; while i <= N do ( (     var x : int ; x := reversDigits(first) ;
     var y : int ; y := reversDigits(second) ;
    OclFile["System.out"].print(x + y + " ") ; 
    var temp : int ; temp := second ;
    second := x + y ; 
    first := temp ; 
 )  ;     i := i + 1 ) ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 12 ;
     execute icanobifNumbers(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int octalToDecimal(int n){
    int num=n ;
    int dec_value=0 ;
    int base=1 ;
    int temp=num ;
    while(temp>0){
      int last_digit=temp % 10 ;
      temp=temp/10 ;
      dec_value+=last_digit*base ;
      base=base*8 ;
    }
    return dec_value ;
  }
  public static void main(String[] args){
    int num=67 ;
    System.out.println(octalToDecimal(num));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation octalToDecimal( n : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := n ;
     var dec_value : int ; dec_value := 0 ;
    var base : int ; base := 1 ;
    var temp : int ; temp := num ;
    while (temp > 0) do (     var last_digit : int ; last_digit := temp mod 10 ;
     temp := temp / 10 ; 
     dec_value := dec_value+(last_digit * base) ; 
     base := base * 8 ) ; 
    return dec_value 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 67 ;
     OclFile["System.out"].println(octalToDecimal(num)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static void printCubes(int a,int b){
    int acrt=(int)Math.cbrt(a);
    int bcrt=(int)Math.cbrt(b);
    for(int i=acrt ; i<=bcrt ; i++)if(i*i*i>=a && i*i*i<=b)System.out.print(i*i*i+" ");
  }
  public static void main(String[] args){
    int a=24,b=576 ;
    System.out.println("Perfect cubes in given range:");
    printCubes(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation printCubes( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var acrt : int ; acrt := (a)->cbrt()->oclAsType(int) ;
     var bcrt : int ; bcrt := (b)->cbrt()->oclAsType(int) ;
         var i : int ; i := acrt ; while i <= bcrt do (     if (i * i * i >= a & i * i * i <= b) then     OclFile["System.out"].print(i * i * i + " ") ; else skip ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 24 ;
    var b : int ; b := 576 ;
     OclFile["System.out"].println("Perfect cubes in given range:") ; 
     execute printCubes(a, b) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] check=new int[100001];
    Arrays.fill(check,0);
    int ans=1 ;
    for(int i=0 ; i<n ; i++){
      check[in.nextInt()]++;
    }
    for(int i=2 ; i<check.length ; i++){
      for(int j=i*2 ; j<check.length ; j+=i){
        check[i]+=check[j];
      }
      ans=Math.max(ans,check[i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var check : Sequence(int) ; check := Integer.subrange(1,100001)->collect(0) ;
    check := check->collect(0) ; 
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     check[in.getCurrent()->toInteger()+1] := check[in.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i < check->size() do ( (         var j : int ; j := i * 2 ; while j < check->size() do ( (     check[i+1] := check[i+1]+(check[j+1]) )  ;     j := j+(i) ) ; 
     ans := Set{ans, check[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().trim().split(" ",0);
    int a=Integer.parseInt(str[0]);
    int b=Integer.parseInt(str[1]);
    System.out.println((a+b)% 24);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->trim()->split(" ") ;
    var a : int ; a := (str[0+1])->toInteger() ;
    var b : int ; b := (str[1+1])->toInteger() ;
    OclFile["System.out"].println((a + b) mod 24) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] check=new int[100001];
    Arrays.fill(check,0);
    int ans=1 ;
    for(int i=0 ; i<n ; i++){
      check[in.nextInt()]++;
    }
    for(int i=2 ; i<check.length ; i++){
      for(int j=i*2 ; j<check.length ; j+=i){
        check[i]+=check[j];
      }
      ans=Math.max(ans,check[i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var check : Sequence(int) ; check := Integer.subrange(1,100001)->collect(0) ;
    check := check->collect(0) ; 
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     check[in.getCurrent()->toInteger()+1] := check[in.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i < check->size() do ( (         var j : int ; j := i * 2 ; while j < check->size() do ( (     check[i+1] := check[i+1]+(check[j+1]) )  ;     j := j+(i) ) ; 
     ans := Set{ans, check[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Broze {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int l=s.length();
    int i=0 ;
    while(i<l-1){
      if(s.charAt(i)=='.'){
        System.out.print(0);
      }
      else {
        if(s.charAt(i+1)=='.'){
          System.out.print(1);
        }
        else {
          System.out.print(2);
        }
        i++;
      }
      i++;
    }
    if(i==l-1)System.out.println(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Broze {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var l : int ; l := s->size() ;
    var i : int ; i := 0 ;
    while (i < (l)->char2byte() - 1) do (     if (s->at(i+1) = '.') then (     OclFile["System.out"].print(0) ) else (     if (s->at(i + 1+1) = '.') then (     OclFile["System.out"].print(1) ) else (     OclFile["System.out"].print(2) ) ;  
     i := i + 1 ) ;  
     i := i + 1 ) ; 
    if (i = (l)->char2byte() - 1) then     OclFile["System.out"].println(0) ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class BashBigDay {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    String[] temp=br.readLine().split(" ");
    int[] count=new int[(int)1e5+1];
    for(int i=0 ; i<n ; i++){
      int num=Integer.parseInt(temp[i]);
      for(int j=1 ; j*j<=num ; j++){
        if(num % j==0){
          count[j]++;
          if(num/j!=j){
            count[num/j]++;
          }
        }
      }
    }
    int res=1 ;
    for(int i=2 ; i<=(int)1e5 ; i++){
      res=Math.max(res,count[i]);
    }
    pr.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class BashBigDay {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
    var count : Sequence(int) ; count := Integer.subrange(1,1e5->oclAsType(int) + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := (temp[i+1])->toInteger() ;
         var j : int ; j := 1 ; while j * j <= num do ( (     if (num mod j = 0) then (     count[j+1] := count[j+1] + 1 ; 
     if (num / j /= j) then (     count[num / j+1] := count[num / j+1] + 1 ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : int ; res := 1 ;
        var i : int ; i := 2 ; while i <= 1e5->oclAsType(int) do ( (     res := Set{res, count[i+1]}->max() )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    if(n>=13){
      System.out.println(solve(12)+(long)(n-12)*49);
    }
    else {
      System.out.println(solve(n));
    }
  }
  private static long solve(int n){
    HashSet<Integer>set=new HashSet<>();
    set.add(1);
    set.add(5);
    set.add(10);
    set.add(50);
    for(int i=2 ; i<=n ; i++){
      HashSet<Integer>set2=new HashSet<>();
      set.forEach((x)->{
        set2.add(x+1);
        set2.add(x+5);
        set2.add(x+10);
        set2.add(x+50);
      }
);
      set=set2 ;
    }
    return set.size();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
     if (n >= 13) then (     OclFile["System.out"].println(solve(12) + (n - 12)->oclAsType(long) * 49) ) else (     OclFile["System.out"].println(solve(n)) ) );
  static   operation solve( n : int) : long
  pre: true
  post: true
  activity: (     var set : Set(int) ; set := Set{} ;
     set := set->including(1) ; 
    set := set->including(5) ; 
    set := set->including(10) ; 
    set := set->including(50) ; 
        var i : int ; i := 2 ; while i <= n do ( (     var set2 : Set(int) ; set2 := Set{} ;
     for x : set do
    (    skip) ; 
     set := set2 )  ;     i := i + 1 ) ; 
    return set->size() 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int[] a=new int[] {
      0,4,10,20,35,56,83,116,155,198,244,292 };
      int n=cin.nextInt();
      if(n<=11)System.out.println(a[n]);
      else {
        long ans=1L*49*(n-11)+292 ;
        System.out.println(ans);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Sequence{0,4,10,20,35,56,83,116,155,198,244,292} ;
     var n : int ; n := cin.getCurrent()->toInteger() ;
     if (n <= 11) then     OclFile["System.out"].println(a[n+1]) ; else (     var ans : long ; ans := 1L * 49 * (n - 11) + 292 ;
     OclFile["System.out"].println(ans) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.*;
import java.util.List ;
public class Main {
  public static void main(String[] args)throws Exception {
    FastReader sc=new FastReader();
    StringBuilder sb=new StringBuilder();
    int t=sc.nextInt();
    TreeSet<Long>treeSet=new TreeSet<>();
    int i=1 ;
    while(true){
      long temp=i*(3*i+1)/2 ;
      if(temp>1e9)break ;
      else treeSet.add(temp);
      i++;
    }
    while(t-->0){
      long n=sc.nextInt();
      int count=0 ;
      while(true){
        Long temp=treeSet.floor(n);
        if(temp!=null)count++;
        else break ;
        n-=temp ;
      }
      sb.append(count+"\n");
    }
    System.out.println(sb);
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    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 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var sb : String ; sb := StringLib.newString() ;
    var t : int ; t := sc.nextInt() ;
    var treeSet : Set(long) ; treeSet := Set{} ;
    var i : int ; i := 1 ;
    while (true) do (     var temp : long ; temp := i * (3 * i + 1) / 2 ;
     if (temp > 1e9) then     break else     treeSet := treeSet->including(temp) ; ;  
     i := i + 1 ) ; 
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := sc.nextInt() ;
     var count : int ; count := 0 ;
     while (true) do (     var temp : long ; temp := treeSet.floor(n) ;
     if (temp /= null) then     count := count + 1 else     break ;  
     n := n-(temp) ) ; 
     sb := sb + StringLib.newString(count + "\n") ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int t=1 ; t<=test ; t++){
      long n=in.nextLong(),nc=n ;
      int ans=0 ;
      int i=0 ;
      long previous=0 ;
      if(n==1){
        ans=0 ;
      }
      while(true){
        i++;
        long card=2*((i*(i+1))/2)+((i-1)*(i-1+1))/2 ;
        if(card>n){
          ans++;
          n-=previous ;
          i=0 ;
        }
        else {
          previous=card ;
        }
        if(n<=1){
          break ;
        }
      }
      if(nc==1){
        pw.println(0);
      }
      else {
        pw.println(ans);
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= test do ( (     var n : long ; n := in.getCurrent()->toLong() ;
    var nc : long ; nc := n ;
     var ans : int ; ans := 0 ;
    var i : int ; i := 0 ;
    var previous : long ; previous := 0 ;
    if (n = 1) then (     ans := 0 ) else skip ; 
    while (true) do (     i := i + 1 ; 
     var card : long ; card := 2 * ((i * (i + 1)) / 2) + ((i - 1) * (i - 1 + 1)) / 2 ;
     if (card > n) then (     ans := ans + 1 ; 
     n := n-(previous) ; 
     i := 0 ) else (     previous := card ) ;  
     if (n <= 1) then (     break ) else skip ) ; 
    if (nc = 1) then (     skip ) else (     skip ) ;  
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static long solve(long a){
    if(a<=1)return 0 ;
    if(a==2)return 1 ;
    int i=2 ;
    int n=7 ;
    while(n<=a){
      i++;
      n=(i*((3*i)+1))/2 ;
    }
    i--;
    a-=(i*((3*i)+1))/2 ;
    return 1+solve(a);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      long a=sc.nextLong();
      System.out.println(solve(a));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation solve( a : long) : long
  pre: true
  post: true
  activity: (     if (a <= 1) then     return 0 else skip ; 
     if (a = 2) then     return 1 else skip ; 
    var i : int ; i := 2 ;
    var n : int ; n := 7 ;
    while (n <= a) do (     i := i + 1 ; 
     n := (i * ((3 * i) + 1)) / 2 ) ; 
    i := i - 1 ; 
    a := a-((i * ((3 * i) + 1)) / 2) ; 
    return 1 + solve(a) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : long ; a := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println(solve(a)) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPalindrome(int n){
    String str=String.valueOf(n);
    int s=0,e=str.length()-1 ;
    while(s<e){
      if(str.charAt(s)!=str.charAt(e)){
        return false ;
      }
      s++;
      e--;
    }
    return true ;
  }
  static void palindromicDivisors(int n){
    Vector<Integer>PalindromDivisors=new Vector<Integer>();
    for(int i=1 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        if(n/i==i){
          if(isPalindrome(i)){
            PalindromDivisors.add(i);
          }
        }
        else {
          if(isPalindrome(i)){
            PalindromDivisors.add(i);
          }
          if(isPalindrome(n/i)){
            PalindromDivisors.add(n/i);
          }
        }
      }
    }
    Collections.sort(PalindromDivisors);
    for(int i=0 ; i<PalindromDivisors.size(); i++){
      System.out.print(PalindromDivisors.get(i)+" ");
    }
  }
  public static void main(String[] args){
    int n=66 ;
    palindromicDivisors(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPalindrome( n : int) : boolean
  pre: true
  post: true
  activity: (     var str : String ; str := ((n) + "") ;
     var s : int ; s := 0 ;
    var e : int ; e := str->size() - 1 ;
     while (s < e) do (     if (str->at(s+1) /= str->at(e+1)) then (     return false ) else skip ; 
     s := s + 1 ; 
     e := e - 1 ) ; 
     return true );
  static   operation palindromicDivisors( n : int) : void
  pre: true
  post: true
  activity: (     var PalindromDivisors : Sequence(int) ; PalindromDivisors := Sequence{} ;
         var i : int ; i := 1 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     if (n / i = i) then (     if (isPalindrome(i)) then (     PalindromDivisors := PalindromDivisors->including(i) ) else skip ) else (     if (isPalindrome(i)) then (     PalindromDivisors := PalindromDivisors->including(i) ) else skip ; 
     if (isPalindrome(n / i)) then (     PalindromDivisors := PalindromDivisors->including(n / i) ) else skip ) ) else skip )  ;     i := i + 1 ) ; 
     PalindromDivisors := PalindromDivisors->sort() ; 
         var i : int ; i := 0 ; while i < PalindromDivisors->size() do ( (     OclFile["System.out"].print(PalindromDivisors->at(i+1) + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 66 ;
     execute palindromicDivisors(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final long MOD=1000000007 ;
    int N=sc.nextInt();
    long A=sc.nextLong();
    long B=sc.nextLong();
    if(A>B){
      long temp=A ;
      A=B ;
      B=temp ;
    }
    long[] S=new long[N+1];
    S[0]=-(B+1);
    for(int i=0 ; i<N ; i++)S[i+1]=sc.nextLong();
    for(int i=2 ; i<N+1 ; i++){
      if(S[i]-S[i-2]<A){
        System.out.println(0);
        sc.close();
        return ;
      }
    }
    long[] dp=new long[N+1];
    dp[0]=1 ;
    int idxZero=0 ;
    int idxB=0 ;
    long sum=0 ;
    for(int i=1 ; i<=N ; i++){
      while(S[i]-S[idxB]>=B){
        sum=(sum+dp[idxB])% MOD ;
        idxB++;
      }
      dp[i]=sum ;
      if(S[i]-S[i-1]<A){
        while(idxZero<i-1){
          if(idxZero<idxB)sum=(sum-dp[idxZero]+MOD)% MOD ;
          dp[idxZero]=0 ;
          idxZero++;
        }
      }
    }
    long ans=0 ;
    for(int i=0 ; i<N+1 ; i++)ans=(ans+dp[i])% MOD ;
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var MOD : long ; MOD := 1000000007 ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : long ; A := sc.getCurrent()->toLong() ;
    var B : long ; B := sc.getCurrent()->toLong() ;
    if (A > B) then (     var temp : long ; temp := A ;
     A := B ; 
     B := temp ) else skip ; 
    var S : Sequence(long) ; S := Integer.subrange(1,N + 1)->collect(0) ;
    S[0+1] := -(B + 1) ; 
        var i : int ; i := 0 ; while i < N do (     S[i + 1+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i < N + 1 do ( (     if (S[i+1] - S[i - 2+1] < A) then (     OclFile["System.out"].println(0) ; 
     skip ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    var dp : Sequence(long) ; dp := Integer.subrange(1,N + 1)->collect(0) ;
    dp[0+1] := 1 ; 
    var idxZero : int ; idxZero := 0 ;
    var idxB : int ; idxB := 0 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     while (S[i+1] - S[idxB+1] >= B) do (     sum := (sum + dp[idxB+1]) mod MOD ; 
     idxB := idxB + 1 ) ; 
     dp[i+1] := sum ; 
     if (S[i+1] - S[i - 1+1] < A) then (     while (idxZero < i - 1) do (     if (idxZero < idxB) then     sum := (sum - dp[idxZero+1] + MOD) mod MOD ; else skip ; 
     dp[idxZero+1] := 0 ; 
     idxZero := idxZero + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < N + 1 do (     ans := (ans + dp[i+1]) mod MOD ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    System.out.println((A+B)% 24);
  }
  void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println((A + B) mod 24) );
   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxAbsDiff(int arr[],int n){
    int minEle=arr[0];
    int maxEle=arr[0];
    for(int i=1 ; i<n ; i++){
      minEle=Math.min(minEle,arr[i]);
      maxEle=Math.max(maxEle,arr[i]);
    }
    return(maxEle-minEle);
  }
  public static void main(String[] args){
    int[] arr={
      2,1,5,3 };
      int n=arr.length ;
      System.out.print(maxAbsDiff(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxAbsDiff( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var minEle : int ; minEle := arr[0+1] ;
     var maxEle : int ; maxEle := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do ( (     minEle := Set{minEle, arr[i+1]}->min() ; 
     maxEle := Set{maxEle, arr[i+1]}->max() )  ;     i := i + 1 ) ; 
     return (maxEle - minEle) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,1,5,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(maxAbsDiff(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static void findIndex(int a[],int n,int key){
    int start=-1 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]==key){
        start=i ;
        break ;
      }
    }
    if(start==-1){
      System.out.println("Key not present in array");
      return ;
    }
    int end=start ;
    for(int i=n-1 ; i>=start ; i--){
      if(a[i]==key){
        end=i ;
        break ;
      }
    }
    if(start==end)System.out.println("Only one key is present at index : "+start);
    else {
      System.out.println("Start index: "+start);
      System.out.println("Last index: "+end);
    }
  }
  public static void main(String args[]){
    int a[]={
      1,2,7,8,8,9,8,0,0,0,8 };
      int key=8 ;
      findIndex(a,a.length,key);
    }
  }

------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation findIndex( a : Sequence(int), n : int, key : int) : void
  pre: true
  post: true
  activity: (     var start : int ; start := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = key) then (     start := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (start = -1) then (     OclFile["System.out"].println("Key not present in array") ; 
     return ) else skip ; 
    var end : int ; end := start ;
        var i : int ; i := n - 1 ; while i >= start do ( (     if (a[i+1] = key) then (     end := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    if (start = end) then     OclFile["System.out"].println("Only one key is present at index : " + start) else (     OclFile["System.out"].println("Start index: " + start) ; 
     OclFile["System.out"].println("Last index: " + end) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,7,8,8,9,8,0,0,0,8} ;
     var key : int ; key := 8 ;
     execute findIndex(a, a->size(), key) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t ;
    t=sc.nextInt();
    for(int j=0 ; j<t ; j++){
      int a,count=0 ;
      a=sc.nextInt();
      String s=Integer.toString(a);
      char[] p=s.toCharArray();
      String ans="" ;
      for(int i=0 ; i<s.length(); i++){
        int c=(int)p[i];
        if(c>=49 && c<=57){
          count++;
          int b=(p[i]-'0')*((int)Math.pow(10,s.length()-i-1));
          ans=ans+b+" " ;
        }
      }
      System.out.println(count);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ;
     t := sc.getCurrent()->toInteger() ; 
         var j : int ; j := 0 ; while j < t do ( (     var a : int ;
    var count : int ; count := 0 ;
     a := sc.getCurrent()->toInteger() ; 
    var s : String ; s := ((a) + "") ;
    var p : Sequence(String) ; p := s->characters() ;
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var c : int ; c := p[i+1]->oclAsType(int) ;
     if (c >= 49 & c <= 57) then (     count := count + 1 ; 
     var b : int ; b := (p[i+1] - ('0')->char2byte()) * (10->pow(s->size() - (i)->char2byte() - 1)->oclAsType(int)) ;
     ans := ans + b + " " ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Iterator ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Trying {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int cases=scan.nextInt();
    int numbers[]=new int[cases];
    for(int i=0 ; i<cases ; i++){
      numbers[i]=scan.nextInt();
    }
    LinkedList<Integer>list=new LinkedList<>();
    int mod=1 ;
    int forTest=1 ;
    int counter=0 ;
    for(int i=0 ; i<numbers.length ; i++){
      while(numbers[i]>0){
        forTest*=10 ;
        mod=numbers[i] % forTest ;
        if(mod!=0){
          numbers[i]=numbers[i]-mod ;
          counter++;
          list.addFirst(mod);
        }
      }
      list.addFirst(counter);
      Iterator iterator=list.iterator();
      while(iterator.hasNext()){
        System.out.println(iterator.next());
      }
      counter=0 ;
      forTest=1 ;
      list.clear();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Trying {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cases : int ; cases := scan.getCurrent()->toInteger() ;
    var numbers : Sequence(int) ; numbers := Integer.subrange(1,cases)->collect(0) ;
        var i : int ; i := 0 ; while i < cases do ( (     numbers[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var list : Sequence(int) ; list := Sequence{} ;
    var mod : int ; mod := 1 ;
    var forTest : int ; forTest := 1 ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < numbers->size() do ( (     while (numbers[i+1] > 0) do (     forTest := forTest*(10) ; 
     mod := numbers[i+1] mod forTest ; 
     if (mod /= 0) then (     numbers[i+1] := numbers[i+1] - mod ; 
     counter := counter + 1 ; 
     list := list->prepend(mod) ) else skip ) ; 
     list := list->prepend(counter) ; 
    var iterator : OclIterator ; iterator := list->iterator() ;
    while (iterator.hasNext()) do (     OclFile["System.out"].println(iterator.next()) ) ; 
    counter := 0 ; 
    forTest := 1 ; 
    list := list->intersection(Set{}) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int howMany=s.nextInt();
    int[] numbers=new int[howMany];
    for(int i=0 ; i<numbers.length ; i++){
      numbers[i]=s.nextInt();
    }
    System.out.println();
    for(int number : numbers){
      String numStr=number+"" ;
      double[] nums=new double[numStr.length()];
      int digitOrder=0 ;
      int count=0 ;
      for(int i=numStr.length()-1 ; i>=0 ; i--){
        int digit=Integer.parseInt(numStr.charAt(i)+"");
        if(digit!=0){
          nums[count]=digit*Math.pow(10,digitOrder);
          count++;
        }
        digitOrder++;
      }
      System.out.println(count);
      for(double num : nums){
        if(num==0)continue ;
        System.out.print((int)num+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var howMany : int ; howMany := s.getCurrent()->toInteger() ;
    var numbers : Sequence(int) ; numbers := Integer.subrange(1,howMany)->collect(0) ;
        var i : int ; i := 0 ; while i < numbers->size() do ( (     numbers[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    for (number : numbers) do ( (     var numStr : String ; numStr := number + "" ;
     var nums : Sequence(double) ; nums := Integer.subrange(1,numStr->size())->collect(0.0) ;
    var digitOrder : int ; digitOrder := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := numStr->size() - 1 ; while i >= 0 do ( (     var digit : int ; digit := (numStr->at(i+1) + "")->toInteger() ;
     if (digit /= 0) then (     nums[count+1] := digit * 10->pow(digitOrder) ; 
     count := count + 1 ) else skip ; 
     digitOrder := digitOrder + 1 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(count) ; 
    for (num : nums) do ( (     if (num = 0) then     continue else skip ; 
     OclFile["System.out"].print(num->oclAsType(int) + " ") )  ) ; 
    OclFile["System.out"].println() ; 
 )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    FastReader in=new FastReader();
    BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      ArrayList<Integer>list=new ArrayList<Integer>();
      int n=in.nextInt();
      int count=0 ;
      int POW=0 ;
      while(n>0){
        int temp=n % 10 ;
        if(temp!=0){
          list.add((int)(temp*Math.pow(10.0,count)));
          POW++;
        }
        count++;
        n/=10 ;
      }
      out.write(POW+"\n");
      for(int x : list)out.write(x+" ");
      out.write("\n");
    }
    out.flush();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var t : int ; t := in.nextInt() ;
        var i : int ; i := 0 ; while i < t do ( (     var list : Sequence(int) ; list := Sequence{} ;
     var n : int ; n := in.nextInt() ;
    var count : int ; count := 0 ;
    var POW : int ; POW := 0 ;
    while (n > 0) do (     var temp : int ; temp := n mod 10 ;
     if (temp /= 0) then (     list := list->including((temp * 10.0->pow(count))->oclAsType(int)) ; 
     POW := POW + 1 ) else skip ; 
     count := count + 1 ; 
     n := n/(10) ) ; 
    skip ; 
    for (x : list) do (     skip ;  ) ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int MOD=1000000007 ;
  static int max=101 ;
  static long C[][]=new long[max][max];
  static long power(long x,long y){
    long res=1 ;
    x=x % MOD ;
    while(y>0){
      if(y % 2==1){
        res=(res*x)% MOD ;
      }
      y=y>>1 ;
      x=(x*x)% MOD ;
    }
    return res % MOD ;
  }
  static void combi(int n,int k){
    int i,j ;
    for(i=0 ; i<=n ; i++){
      for(j=0 ; j<=Math.min(i,k); j++){
        if(j==0 || j==i)C[i][j]=1 ;
        else C[i][j]=(C[i-1][j-1] % MOD+C[i-1][j] % MOD)% MOD ;
      }
    }
  }
  static long product(long a[],int n,int k){
    long ans=1 ;
    Arrays.sort(a);
    long powa=C[n-1][k-1];
    for(int i=0 ; i<n ; i++){
      long powla=C[i][k-1];
      long powfa=C[n-i-1][k-1];
      long powe=((powa % MOD)-(powla+powfa)% MOD+MOD)% MOD ;
      long mul=power(a[i],powe)% MOD ;
      ans=((ans % MOD)*(mul % MOD))% MOD ;
    }
    return ans % MOD ;
  }
  public static void main(String[] args){
    combi(100,100);
    long arr[]={
      1,2,3,4 };
      int n=arr.length ;
      int k=3 ;
      long ans=product(arr,n,k);
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MOD : int := 1000000007;
  static   attribute max : int := 101;
  static   attribute C : long := Integer.subrange(1,max)->collect(Integer.subrange(1,max)->collect(0));
  static   operation power( x : long, y : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     x := x mod MOD ; 
     while (y > 0) do (     if (y mod 2 = 1) then (     res := (res * x) mod MOD ) else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod MOD ) ; 
     return res mod MOD );
  static   operation combi( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := 0 ; while i <= n do ( (         j := 0 ; while j <= Set{i, k}->min() do ( (     if (j = 0 or j = i) then     C[i+1][j+1] := 1 ; else     C[i+1][j+1] := (C[i - 1+1][j - 1+1] mod MOD + C[i - 1+1][j+1] mod MOD) mod MOD ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation product( a : Sequence(long), n : int, k : int) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
     a := a->sort() ; 
    var powa : long ; powa := C[n - 1+1][k - 1+1] ;
        var i : int ; i := 0 ; while i < n do ( (     var powla : long ; powla := C[i+1][k - 1+1] ;
     var powfa : long ; powfa := C[n - i - 1+1][k - 1+1] ;
    var powe : long ; powe := ((powa mod MOD) - (powla + powfa) mod MOD + MOD) mod MOD ;
    var mul : long ; mul := power(a[i+1], powe) mod MOD ;
    ans := ((ans mod MOD) * (mul mod MOD)) mod MOD ; 
 )  ;     i := i + 1 ) ; 
    return ans mod MOD 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute combi(100, 100) ; 
     var arr : Sequence(long) ; arr := Sequence{1,2,3,4} ;
    var n : int ; n := arr->size() ;
    var k : int ; k := 3 ;
    var ans : long ; ans := product(arr, n, k) ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    Rectangle base=new Rectangle(0,0,0,0);
    for(int i=0 ; ; i++){
      if(base.contains(x,y)){
        System.out.println(i % 3+1);
        return ;
      }
      if(i % 4==0){
        base.endX=base.endX+base.endY-base.startY+1 ;
      }
      else if(i % 4==1){
        base.endY=base.endY+base.endX-base.startX+1 ;
      }
      else if(i % 4==2){
        base.startX=base.startX-(base.endY-base.startY+1);
      }
      else {
        base.startY=base.startY-(base.endX-base.startX+1);
      }
    }
  }
  static class Rectangle {
    int startX ;
    int startY ;
    int endX ;
    int endY ;
    public Rectangle(int startX,int startY,int endX,int endY){
      this.startX=startX ;
      this.startY=startY ;
      this.endX=endX ;
      this.endY=endY ;
    }
    public boolean contains(int x,int y){
      return x>=startX && x<=endX && y>=startY && y<=endY ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var base : Rectangle ; base := Rectangle.newRectangle(0, 0, 0, 0) ;
        var i : int ; i := 0 ; while true do ( (     if (base->includes(x, y)) then (     OclFile["System.out"].println(i mod 3 + 1) ; 
     return ) else skip ; 
     if (i mod 4 = 0) then (     base.endX := base.endX + base.endY - base.startY + 1 ) else     if (i mod 4 = 1) then (     base.endY := base.endY + base.endX - base.startX + 1 ) else     if (i mod 4 = 2) then (     base.startX := base.startX - (base.endY - base.startY + 1) ) else (     base.startY := base.startY - (base.endX - base.startX + 1) ) ;  ;  )  ;     i := i + 1 ) ; 
 );
  static class Rectangle {
   attribute startX : int;
   attribute startY : int;
   attribute endX : int;
   attribute endY : int;
   static operation newRectangle( startX : int, startY : int, endX : int, endY : int) : Rectangle
  pre: true
  post: true
  activity:
  ( var self : Rectangle ;
    self := createRectangle();
    self.initialise(startX, startY,endX,endY);
    return self );
  operation initialise( startX : int, startY : int, endX : int, endY : int) : void
  pre: true  post: true
  activity: (     self.startX := startX ; 
     self.startY := startY ; 
     self.endX := endX ; 
     self.endY := endY );
   operation contains( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return x >= startX & x <= endX & y >= startY & y <= endY );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  long search(long x,long y){
    long x_min=0 ;
    long y_min=0 ;
    long x_max=0 ;
    long y_max=0 ;
    long f,f1=1,f2=0 ;
    long p ;
    for(p=0 ; ; p++){
      if(x_min<=x && x<=x_max && y_min<=y && y<=y_max)return p % 3+1 ;
      f=f1+f2 ;
      if(p % 4==0)x_max+=f ;
      else if(p % 4==1)y_max+=f ;
      else if(p % 4==2)x_min-=f ;
      else y_min-=f ;
      f2=f1 ;
      f1=f ;
    }
  }
  void solve(){
    long x,y ;
    Scanner sc=new Scanner(System.in);
    x=sc.nextLong();
    y=sc.nextLong();
    System.out.println(search(x,y));
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation search( x : long, y : long) : long
  pre: true
  post: true
  activity: (     var x_min : long ; x_min := 0 ;
     var y_min : long ; y_min := 0 ;
    var x_max : long ; x_max := 0 ;
    var y_max : long ; y_max := 0 ;
    var f : long ;
    var f1 : long ; f1 := 1 ;
    var f2 : long ; f2 := 0 ;
    var p : long ;
        p := 0 ; while true do ( (     if (x_min <= x & x <= x_max & y_min <= y & y <= y_max) then     return p mod 3 + 1 else skip ; 
     f := f1 + f2 ; 
    if (p mod 4 = 0) then     x_max := x_max+(f) else     if (p mod 4 = 1) then     y_max := y_max+(f) else     if (p mod 4 = 2) then     x_min := x_min-(f) else     y_min := y_min-(f) ; ;  ;  ;  
    f2 := f1 ; 
    f1 := f ; 
 )  ;     p := p + 1 ) ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var x : long ;
    var y : long ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    x := sc.getCurrent()->toLong() ; 
    y := sc.getCurrent()->toLong() ; 
    OclFile["System.out"].println(search(x, y)) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package codejam15 ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class A {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(new FileReader(new File("a.in")));
    PrintWriter pw=new PrintWriter("a.out");
    int tc=sc.nextInt();
    for(int t=1 ; t<=tc ; t++){
      int l=sc.nextInt();
      String s=sc.nextLine();
      int cnt=0 ;
      int added=0 ;
      for(int i=0 ; i<=l ; i++){
        if(i>cnt){
          int need=i-cnt ;
          added+=need ;
          cnt+=need ;
        }
        cnt+=s.charAt(i+1)-'0' ;
      }
      pw.printf("Case #%d: %d\n",t,added);
    }
    sc.close();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile("a.in"))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile("a.out")) ;
    var tc : int ; tc := sc.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= tc do ( (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.nextLine() ;
    var cnt : int ; cnt := 0 ;
    var added : int ; added := 0 ;
        var i : int ; i := 0 ; while i <= l do ( (     if (i > cnt) then (     var need : int ; need := i - (cnt)->char2byte() ;
     added := added+(need) ; 
     cnt := cnt+(need) ) else skip ; 
     cnt := cnt+(s->at(i + 1+1) - ('0')->char2byte()) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.concurrent.*;
public class A {
  int n ;
  String s ;
  String solve(){
    int up=0 ;
    int ans=0 ;
    for(int i=0 ; i<=n ; i++){
      int count=s.charAt(i)-'0' ;
      if(count==0){
        continue ;
      }
      if(up<i){
        ans+=i-up ;
        up=i ;
      }
      up+=count ;
    }
    return ""+ans ;
  }
  public A(Scanner in){
    n=in.nextInt();
    s=in.next();
  }
  private static String fileName=A.class.getSimpleName().replaceFirst("_.*","").toLowerCase();
  private static String inputFileName=fileName+".in" ;
  private static String outputFileName=fileName+".out" ;
  public static void main(String[] args)throws IOException,InterruptedException,ExecutionException {
    ExecutorService executor=Executors.newFixedThreadPool(4);
    Locale.setDefault(Locale.US);
    Scanner in=new Scanner(new File(inputFileName));
    PrintWriter out=new PrintWriter(outputFileName);
    int tests=in.nextInt();
    in.nextLine();
    @ SuppressWarnings("unchecked")Future<String>[] outputs=new Future[tests];
    for(int t=0 ; t<tests ; t++){
      final A testCase=new A(in);
      final int testCaseNumber=t ;
      outputs[t]=executor.submit(new Callable<String>(){
        @ Override public String call(){
          String answer=testCase.solve();
          String printed="Case #"+(testCaseNumber+1)+": "+answer ;
          System.out.println(printed);
          return printed ;
        }
      }
);
    }
    for(int t=0 ; t<tests ; t++){
      out.println(outputs[t] .get());
    }
    in.close();
    out.close();
    executor.shutdown();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   attribute n : int;
   attribute s : String;
   operation solve() : String
  pre: true
  post: true
  activity: (     var up : int ; up := 0 ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i <= n do ( (     var count : int ; count := s->at(i+1) - ('0')->char2byte() ;
     if (count = 0) then (     continue ) else skip ; 
     if (up < i) then (     ans := ans+(i - up) ; 
     up := i ) else skip ; 
     up := up+(count) )  ;     i := i + 1 ) ; 
     return "" + ans );
   static operation newA( in : OclFile) : A
  pre: true
  post: true
  activity:
  ( var self : A ;
    self := createA();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     n := in.nextInt() ; 
     s := in.next() );
  static   attribute fileName : String := OclType["A"].getSimpleName().replaceFirstMatch("_.*", "")->toLowerCase();
  static   attribute inputFileName : String := fileName + ".in";
  static   attribute outputFileName : String := fileName + ".out";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var executor : ExecutorService ; executor := Executors.newFixedThreadPool(4) ;
     Locale.setDefault(Locale.US) ; 
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile(inputFileName)) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile(outputFileName)) ;
    var tests : int ; tests := in.getCurrent()->toInteger() ;
    skip ; 
    var outputs : Sequence(Future<String>) ; outputs := Integer.subrange(1,tests)->collect(null) ;
        var t : int ; t := 0 ; while t < tests do ( (     var testCase : A ; testCase := A.newA(in) ;
     var testCaseNumber : int ; testCaseNumber := t ;
     outputs[t+1] := executor.submit(Callable<String>.newCallable()) )  ;     t := t + 1 ) ; 
        var t : int ; t := 0 ; while t < tests do ( (     skip )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
    executor.shutdown() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    int a,b,c,N ;
    Scanner sc=new Scanner(System.in);
    while(true){
      a=sc.nextInt();
      b=sc.nextInt();
      c=sc.nextInt();
      if(a==0 && b==0 && c==0){
        System.exit(0);
      }
      N=sc.nextInt();
      int[] checking=new int[a+b+c];
      LinkedList<Integer>temp=new LinkedList<Integer>();
      Arrays.fill(checking,0);
      for(int j=0 ; j<2 ; j++){
        for(int i=0 ; i<N ; i++){
          if(j==0){
            int a1,b1,c1,check ;
            a1=sc.nextInt();
            b1=sc.nextInt();
            c1=sc.nextInt();
            check=sc.nextInt();
            if(check==1){
              checking[a1-1]=1 ;
              checking[b1-1]=1 ;
              checking[c1-1]=1 ;
            }
            else {
              temp.add(a1);
              temp.add(b1);
              temp.add(c1);
            }
          }
          else {
            if(temp.isEmpty()){
              break ;
            }
            int a2=temp.pop();
            int b2=temp.pop();
            int c2=temp.pop();
            if(checking[a2-1]+checking[b2-1]+checking[c2-1]==2){
              if(checking[a2-1]!=1){
                checking[a2-1]=3 ;
              }
              else if(checking[b2-1]!=1){
                checking[b2-1]=3 ;
              }
              else {
                checking[c2-1]=3 ;
              }
            }
          }
        }
      }
      for(int contents : checking){
        int result ;
        if(contents==3){
          result=0 ;
        }
        else if(contents==0){
          result=2 ;
        }
        else {
          result=1 ;
        }
        System.out.println(result);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ;
    var b : int ;
    var c : int ;
    var N : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     a := sc.getCurrent()->toInteger() ; 
     b := sc.getCurrent()->toInteger() ; 
    c := sc.getCurrent()->toInteger() ; 
    if (a = 0 & b = 0 & c = 0) then ( OclProcess.exit(0) ) else skip ; 
    N := sc.getCurrent()->toInteger() ; 
    var checking : Sequence(int) ; checking := Integer.subrange(1,a + b + c)->collect(0) ;
    var temp : Sequence(int) ; temp := Sequence{} ;
    checking := checking->collect(0) ; 
        var j : int ; j := 0 ; while j < 2 do ( (         var i : int ; i := 0 ; while i < N do ( (     if (j = 0) then (     var a1 : int ;
    var b1 : int ;
    var c1 : int ;
    var check : int ;
     a1 := sc.getCurrent()->toInteger() ; 
    b1 := sc.getCurrent()->toInteger() ; 
    c1 := sc.getCurrent()->toInteger() ; 
    check := sc.getCurrent()->toInteger() ; 
    if (check = 1) then (     checking[a1 - 1+1] := 1 ; 
     checking[b1 - 1+1] := 1 ; 
     checking[c1 - 1+1] := 1 ) else (     temp := temp->including(a1) ; 
     temp := temp->including(b1) ; 
     temp := temp->including(c1) ) ;  
 ) else (     if (temp->isEmpty()) then (     break ) else skip ; 
     var a2 : int ; a2 := temp->last() ;
    var b2 : int ; b2 := temp->last() ;
    var c2 : int ; c2 := temp->last() ;
    if (checking[a2 - 1+1] + checking[b2 - 1+1] + checking[c2 - 1+1] = 2) then (     if (checking[a2 - 1+1] /= 1) then (     checking[a2 - 1+1] := 3 ) else     if (checking[b2 - 1+1] /= 1) then (     checking[b2 - 1+1] := 3 ) else (     checking[c2 - 1+1] := 3 ) ;  ) else skip ; 
 ) )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    for (contents : checking) do ( (     var result : int ;
     if (contents = 3) then (     result := 0 ) else     if (contents = 0) then (     result := 2 ) else (     result := 1 ) ;  ;  
     OclFile["System.out"].println(result) )  ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public boolean backspaceCompare(String S,String T){
    return trans(S).equals(trans(T));
  }
  private String trans(String str){
    StringBuilder sb=new StringBuilder();
    for(char c : str.toCharArray()){
      if(c!='#'){
        sb.append(c);
      }
      else if(sb.length()>0){
        sb.deleteCharAt(sb.length()-1);
      }
    }
    return sb.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation backspaceCompare( S : String, T : String) : boolean
  pre: true
  post: true
  activity: (     return trans(S) = trans(T) );
   operation trans( str : String) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     for (c : str->characters()) do ( (     if (c /= '#') then (     sb := sb + StringLib.newString(c) ) else     if (sb->size() > 0) then (     sb := sb->excludingAt(sb->size() - 1+1) ) else skip ; )  ) ; 
     return sb+"" );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class StandingOvation {
  static final String filename="C:/Users/Kevin/algs4/CodeJam/StandingOvation/A-large.in" ;
  static final String output="largefinaloutput.txt" ;
  public static int numOfFriends(int[] shylevels){
    int total=0 ;
    int ret=0 ;
    for(int i=0 ; i<shylevels.length ; ++i){
      ret=Math.max(ret,i-total);
      total+=shylevels[i];
    }
    return ret ;
  }
  public static void main(String[] args){
    try {
      Scanner sc=new Scanner(new FileInputStream(new File(filename)));
      int no_of_times=sc.nextInt();
      for(int i=0 ; i<no_of_times ; ++i){
        sc.nextInt();
        char[] shylevelchars=sc.nextLine().toCharArray();
        int[] shylevels=new int[shylevelchars.length-1];
        for(int j=1 ; j<shylevelchars.length ; ++j){
          shylevels[j-1]=Integer.parseInt(((Character)shylevelchars[j]).toString());
        }
        FileOutputStream fos=new FileOutputStream(output,true);
        fos.write(("Case #"+(i+1)+": "+numOfFriends(shylevels)+"\n").getBytes());
        fos.close();
      }
      sc.close();
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class StandingOvation {
  static    attribute filename : String := "C:/Users/Kevin/algs4/CodeJam/StandingOvation/A-large.in";
  static    attribute output : String := "largefinaloutput.txt";
  static   operation numOfFriends( shylevels : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var total : int ; total := 0 ;
     var ret : int ; ret := 0 ;
         var i : int ; i := 0 ; while i < shylevels->size() do ( (     ret := Set{ret, i - total}->max() ; 
     total := total+(shylevels[i+1]) )  ;     i := i + 1 ) ; 
     return ret );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(filename))) ;
     var no_of_times : int ; no_of_times := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < no_of_times do ( (     skip ; 
     var shylevelchars : Sequence(String) ; shylevelchars := sc.nextLine()->characters() ;
    var shylevels : Sequence(int) ; shylevels := Integer.subrange(1,shylevelchars->size() - 1)->collect(0) ;
        var j : int ; j := 1 ; while j < shylevelchars->size() do ( (     shylevels[j - 1+1] := ((shylevelchars[j+1]->oclAsType(String))+"")->toInteger() )  ;     j := j + 1 ) ; 
    var fos : OclFile ; fos := OclFile.newOclFile_Write(output, true) ;
    skip ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
     skip )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round0 ;
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
public class StandingOvation {
  private static FileWriter writer ;
  public static void main(String[] args)throws IOException {
    File file=new File("round0/A-large.in");
    BufferedReader reader=new BufferedReader(new FileReader(file));
    File outputFile=new File("round0/output-ovation.txt");
    writer=new FileWriter(outputFile);
    int numberOfPerformances=Integer.parseInt(reader.readLine());
    for(int show=1 ; show<=numberOfPerformances ; show++){
      String[] split=reader.readLine().split(" ");
      int length=Integer.parseInt(split[0]);
      char[] audience=split[1] .toCharArray();
      generateOutput("Case #"+show+": "+invitedFriends(length,audience));
    }
    reader.close();
    writer.close();
  }
  private static int invitedFriends(int length,char[] audience){
    int friends=0 ;
    int totalStanding=0 ;
    for(int i=0 ; i<length+1 ; i++){
      totalStanding+=Integer.parseInt(""+audience[i]);
      if(totalStanding<i+1){
        friends++;
        totalStanding++;
      }
    }
    return friends ;
  }
  private static void generateOutput(String line)throws IOException {
    System.out.println(line);
    writer.write(line+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class StandingOvation {
  static   attribute writer : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var file : OclFile ; file := OclFile("round0/A-large.in") ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) ;
    var outputFile : OclFile ; outputFile := OclFile("round0/output-ovation.txt") ;
    writer := OclFile.newOclFile_Write(outputFile) ; 
    var numberOfPerformances : int ; numberOfPerformances := (reader.readLine())->toInteger() ;
        var show : int ; show := 1 ; while show <= numberOfPerformances do ( (     var split : Sequence(String) ; split := reader.readLine()->split(" ") ;
     var length : int ; length := (split[0+1])->toInteger() ;
     var audience : Sequence(String) ; audience := split[1+1]->characters() ;
     execute generateOutput("Case #" + show + ": " + invitedFriends(length, audience)) )  ;     show := show + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation invitedFriends( length : int, audience : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var friends : int ; friends := 0 ;
     var totalStanding : int ; totalStanding := 0 ;
         var i : int ; i := 0 ; while i < length + 1 do ( (     totalStanding := totalStanding+(("" + audience[i+1])->toInteger()) ; 
     if (totalStanding < i + 1) then (     friends := friends + 1 ; 
     totalStanding := totalStanding + 1 ) else skip )  ;     i := i + 1 ) ; 
     return friends );
  static   operation generateOutput( line : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(line) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package gcj2015.qualif ;
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.logging.Level ;
import java.util.logging.Logger ;
public class ExoA {
  public static void main(final String[] args){
    final String base="/home/jean/gcj2015/q/ExoA/" ;
    final String input=base+"b1.in" ;
    final String output=base+"b1.out" ;
    try {
      final Scanner sc=new Scanner(new FileReader(input));
      final PrintWriter pw=new PrintWriter(output);
      final int n=sc.nextInt();
      sc.nextLine();
      for(int c=0 ; c<n ; c++){
        System.out.println("Test case "+(c+1)+"...");
        pw.print("Case #"+(c+1)+": ");
        test(sc,pw);
        pw.println();
      }
      pw.println();
      pw.flush();
      pw.close();
      sc.close();
    }
    catch(final FileNotFoundException ex){
      Logger.getLogger(ExoA.class.getName()).log(Level.SEVERE,null,ex);
    }
  }
  private static void test(final Scanner sc,final PrintWriter pw){
    final int Smax=sc.nextInt();
    final String levels=sc.next();
    final int[] ls=new int[levels.length()];
    int ts=0 ;
    int toAdd=0 ;
    for(int i=0 ; i<levels.length(); i++){
      if(ts<i){
        toAdd+=(i-ts);
        ts=i ;
      }
      ls[i]=levels.charAt(i)-'0' ;
      ts+=ls[i];
    }
    pw.print(toAdd);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ExoA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var base : String ; base := "/home/jean/gcj2015/q/ExoA/" ;
     var input : String ; input := base + "b1.in" ;
     var output : String ; output := base + "b1.out" ;
     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(input))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile(output)) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
        var c : int ; c := 0 ; while c < n do ( (     OclFile["System.out"].println("Test case " + (c + 1) + "...") ; 
     skip ; 
     execute test(sc, pw) ; 
     skip )  ;     c := c + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 )   catch (ex : FileNotFoundException) do (     Logger.getLogger(OclType["ExoA"].getName()).log(Level.SEVERE, null, ex) )
 );
  static   operation test( sc : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var Smax : int ; Smax := sc.getCurrent()->toInteger() ;
     var levels : String ; levels := sc.getCurrent() ;
    var ls : Sequence(int) ; ls := Integer.subrange(1,levels->size())->collect(0) ;
    var ts : int ; ts := 0 ;
    var toAdd : int ; toAdd := 0 ;
        var i : int ; i := 0 ; while i < levels->size() do ( (     if (ts < i) then (     toAdd := toAdd+((i - ts)) ; 
     ts := i ) else skip ; 
     ls[i+1] := levels->at(i+1) - ('0')->char2byte() ; 
     ts := ts+(ls[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int power[]=new int[31];
  static int pre[]=new int[31];
  static void PowerOfTwo(){
    int x=1 ;
    for(int i=0 ; i<31 ; i++){
      power[i]=x ;
      x*=2 ;
    }
    pre[0]=1 ;
    for(int i=1 ; i<31 ; i++)pre[i]=pre[i-1]+power[i];
  }
  static int Sum(int n){
    int ans=n*(n+1)/2 ;
    for(int i=0 ; i<31 ; i++){
      if(power[i]>n){
        ans-=2*pre[i-1];
        break ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    PowerOfTwo();
    int n=4 ;
    System.out.println(Sum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute power : int := Integer.subrange(1,31)->collect(0);
  static   attribute pre : int := Integer.subrange(1,31)->collect(0);
  static   operation PowerOfTwo() : void
  pre: true
  post: true
  activity: (     var x : int ; x := 1 ;
         var i : int ; i := 0 ; while i < 31 do ( (     power[i+1] := x ; 
     x := x*(2) )  ;     i := i + 1 ) ; 
     pre[0+1] := 1 ; 
         var i : int ; i := 1 ; while i < 31 do (     pre[i+1] := pre[i - 1+1] + power[i+1] ;  ;     i := i + 1 ) );
  static   operation Sum( n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := n * (n + 1) / 2 ;
         var i : int ; i := 0 ; while i < 31 do ( (     if (power[i+1] > n) then (     ans := ans-(2 * pre[i - 1+1]) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute PowerOfTwo() ; 
     var n : int ; n := 4 ;
     OclFile["System.out"].println(Sum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  @ SuppressWarnings("unchecked")private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    List<Pair>[] lists=new ArrayList[n];
    for(int i=0 ; i<n ; i++)lists[i]=new ArrayList<Pair>();
    while(true){
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      int c=scanner.nextInt();
      if((a | b | c)==0)break ;
      lists[a-1] .add(new Pair(b-1,c));
    }
    int r=scanner.nextInt();
    while(r-->0){
      int[] b=new int[m];
      for(int i=0 ; i<m ; i++)b[i]=scanner.nextInt();
      int res=0 ;
      for(Pair p : lists[0]){
        res+=b[p.b]*p.cost ;
      }
      System.out.print(res);
      for(int i=1 ; i<n ; i++){
        res=0 ;
        for(Pair pair : lists[i]){
          res+=b[pair.b]*pair.cost ;
        }
        System.out.print(" "+res);
      }
      System.out.println();
    }
  }
  class Pair {
    int b,cost ;
    public Pair(int b,int cost){
      super();
      this.b=b ;
      this.cost=cost ;
    }
    @ Override public String toString(){
      return "Pair[b="+b+",cost="+cost+"] " ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
      operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var lists : Sequence(Sequence(Map)) ; lists := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     lists[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
    while (true) do (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(a,b),c)) = 0) then     break else skip ; 
    lists[a - 1+1]->excludes(Map(b - 1, c)) ; 
 ) ; 
    var r : int ; r := scanner.getCurrent()->toInteger() ;
        while (r > 0) do (        r := r - 1 ;     skip ; (     var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
         var i : int ; i := 0 ; while i < m do (     b[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    for (p : lists[0+1]) do ( (     res := res+(b[p.b+1] * p.cost) )  ) ; 
    OclFile["System.out"].print(res) ; 
        var i : int ; i := 1 ; while i < n do ( (     res := 0 ; 
     for (pair : lists[i+1]) do ( (     res := res+(b[pair.b+1] * pair.cost) )  ) ; 
     OclFile["System.out"].print(" " + res) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) ;  
 );
 class Pair {
   attribute b : int;
   static operation newPair( b : int, cost : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(b, cost);
    return self );
  operation initialise( b : int, cost : int) : void
  pre: true  post: true
  activity: (     execute super() ; 
     self.b := b ; 
     self.cost := cost );
      operation toString() : String
  pre: true
  post: true
  activity: (     return "Pair[b=" + b + ",cost=" + cost + "] " );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    line=br.readLine();
    int N,M ;
    N=parseInt(line.substring(0,line.indexOf(' ')));
    M=parseInt(line.substring(line.indexOf(' ')+1));
    Map<Integer,Map<Integer,Integer>>map=new HashMap<>();
    while((line=br.readLine())!=null && ! line.isEmpty()){
      if(line.equals("0 0 0"))break ;
      StringTokenizer st=new StringTokenizer(line);
      int s,t,e ;
      s=parseInt(st.nextToken());
      t=parseInt(st.nextToken());
      e=parseInt(st.nextToken());
      map.putIfAbsent(s,new HashMap<>());
      map.get(s).put(t,e);
    }
    int L=parseInt(br.readLine());
    for(int i=0 ; i<L ; i++){
      int[] b=new int[M+1];
      StringTokenizer st=new StringTokenizer(br.readLine());
      for(int j=1 ; j<=M ; j++){
        b[j]=parseInt(st.nextToken());
      }
      List<String>list=new ArrayList<>();
      for(int j=1 ; j<=N ; j++){
        int c=0 ;
        if(map.containsKey(j)){
          for(int t : map.get(j).keySet()){
            c+=b[t]*map.get(j).get(t);
          }
        }
        list.add(String.valueOf(c));
      }
      System.out.println(String.join(" ",list));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    line := br.readLine() ; 
    var N : int ;
    var M : int ;
    N := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    M := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var map : Map(int,Map(int,int)) ; map := Map{} ;
        line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     if (line = "0 0 0") then     break else skip ; 
     var st : OclIterator ; st := OclIterator.newOclIterator_String(line) ;
    var s : int ;
    var t : int ;
    var e : int ;
    s := (st.next() + "")->toInteger() ; 
    t := (st.next() + "")->toInteger() ; 
    e := (st.next() + "")->toInteger() ; 
    if map->keys()->includes(s) then skip else map := map->union(Map{s |-> Map{}}) ; 
    map := map->at(s)->union(Map{t |-> e}) ; 
 ) ;     line := br.readLine() ;
 ) ;  
    var L : int ; L := parseInt(br.readLine()) ;
        var i : int ; i := 0 ; while i < L do ( (     var b : Sequence(int) ; b := Integer.subrange(1,M + 1)->collect(0) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var j : int ; j := 1 ; while j <= M do ( (     b[j+1] := (st.next() + "")->toInteger() )  ;     j := j + 1 ) ; 
    var list : Sequence(String) ; list := Sequence{} ;
        var j : int ; j := 1 ; while j <= N do ( (     var c : int ; c := 0 ;
     if (map->keys()->includes(j)) then (     for (t : map->at(j).keySet()) do ( (     c := c+(b[t+1] * map->at(j)->at(t+1)) )  ) ) else skip ; 
     list := list->including(((c) + "")) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(join(" ", list)) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  E[] G ;
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    E[] G=new E[(int)n];
    for(int i=0 ; i<n ; i++)G[i]=new E();
    for(; ; ){
      long s=sc.nextInt(),t=sc.nextInt(),e=sc.nextInt();
      if((s | t | e)==0)break ;
      s--;
      t--;
      G[(int)s] .add(new P((int)t,e));
    }
    int l=sc.nextInt();
    long[] b=new long[m];
    for(int i=0 ; i<l ; i++){
      for(int j=0 ; j<m ; j++)b[j]=sc.nextInt();
      for(int k=0 ; k<n ; k++){
        int sum=0 ;
        for(P p : G[k])sum+=b[p.t]*p.c ;
        System.out.print(sum+(k==n-1 ? "\n" : " "));
      }
    }
  }
  class E extends ArrayList<P>{
  }
  class P {
    int t ;
    long c ;
    P(int t,long c){
      this.t=t ;
      this.c=c ;
    }
  }
  void debug(Object...os){
    System.out.println(deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute G : Sequence(E);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var G : Sequence(E) ; G := Integer.subrange(1,n->oclAsType(int))->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     G[i+1] := E.newE() ;  ;     i := i + 1 ) ; 
      while true do ( (     var s : long ; s := sc.getCurrent()->toInteger() ;
    var t : long ; t := sc.getCurrent()->toInteger() ;
    var e : long ; e := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseOr(MathLib.bitwiseOr(s,t),e)) = 0) then     break else skip ; 
    s := s - 1 ; 
    t := t - 1 ; 
    G[s->oclAsType(int)+1]->excludes(P.newP(t->oclAsType(int), e)) ; 
 )  ) ; 
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var b : Sequence(long) ; b := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < l do ( (         var j : int ; j := 0 ; while j < m do (     b[j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ; 
         var k : int ; k := 0 ; while k < n do ( (     var sum : int ; sum := 0 ;
     for (p : G[k+1]) do (     sum := sum+(b[p.t+1] * p.c) ;  ) ; 
     OclFile["System.out"].print(sum + (if k = n - 1 then "\n" else " " endif)) )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
 );
 class E extends Sequence(P) { }
 class P {
   attribute t : int;
   attribute c : long;
   static operation newP( t : int, c : long) : P
  pre: true
  post: true
  activity:
  ( var self : P ;
    self := createP();
    self.initialise(t, c);
    return self );
  operation initialise( t : int, c : long) : void
  pre: true  post: true
  activity: (     self.t := t ; 
     self.c := c );
}
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    ArrayList<Work>works=new ArrayList<>();
    while(true){
      int s=sc.nextInt();
      int t=sc.nextInt();
      int w=sc.nextInt();
      if(s==0 && t==0 && w==0){
        break ;
      }
      works.add(new Work(s,t,w));
    }
    int l=sc.nextInt();
    int[][] fees=new int[l][m+1];
    for(int i=0 ; i<l ; i++){
      for(int j=1 ; j<=m ; j++){
        fees[i][j]=sc.nextInt();
      }
    }
    int[][] matrix=new int[l][n+1];
    for(Work w : works){
      for(int i=0 ; i<l ; i++){
        matrix[i][w.person]+=fees[i][w.type]*w.count ;
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<l ; i++){
      for(int j=1 ; j<=n ; j++){
        if(j!=1){
          sb.append(" ");
        }
        sb.append(matrix[i][j]);
      }
      sb.append("\n");
    }
    System.out.print(sb);
  }
  static class Work {
    int person ;
    int type ;
    int count ;
    public Work(int person,int type,int count){
      this.person=person ;
      this.type=type ;
      this.count=count ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var works : Sequence(Work) ; works := Sequence{} ;
    while (true) do (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    if (s = 0 & t = 0 & w = 0) then (     break ) else skip ; 
    works := works->including(Work.newWork(s, t, w)) ; 
 ) ; 
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var fees : Sequence(Sequence(int)) ; fees := Integer.subrange(1,l)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < l do ( (         var j : int ; j := 1 ; while j <= m do ( (     fees[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var matrix : Sequence(Sequence(int)) ; matrix := Integer.subrange(1,l)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
    for (w : works) do ( (         var i : int ; i := 0 ; while i < l do ( (     matrix[i+1][w.person+1] := matrix[i+1][w.person+1]+(fees[i+1][w.type+1] * w.count) )  ;     i := i + 1 ) )  ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < l do ( (         var j : int ; j := 1 ; while j <= n do ( (     if (j /= 1) then (     sb := sb + StringLib.newString(" ") ) else skip ; 
     sb := sb + StringLib.newString(matrix[i+1][j+1]) )  ;     j := j + 1 ) ; 
     sb := sb + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
  static class Work {
   attribute person : int;
   attribute type : int;
   attribute count : int;
   static operation newWork( person : int, type : int, count : int) : Work
  pre: true
  post: true
  activity:
  ( var self : Work ;
    self := createWork();
    self.initialise(person, type,count);
    return self );
  operation initialise( person : int, type : int, count : int) : void
  pre: true  post: true
  activity: (     self.person := person ; 
     self.type := type ; 
     self.count := count );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    line=br.readLine();
    int N,M ;
    N=parseInt(line.substring(0,line.indexOf(' ')));
    M=parseInt(line.substring(line.indexOf(' ')+1));
    Map<Integer,Map<Integer,Integer>>map=new HashMap<>();
    for(int i=1 ; i<=N ; i++)map.put(i,new HashMap<>());
    while((line=br.readLine())!=null && ! line.isEmpty()){
      if(line.equals("0 0 0"))break ;
      StringTokenizer st=new StringTokenizer(line);
      int s,t,e ;
      s=parseInt(st.nextToken());
      t=parseInt(st.nextToken());
      e=parseInt(st.nextToken());
      map.get(s).put(t,e);
    }
    int L=parseInt(br.readLine());
    for(int i=0 ; i<L ; i++){
      int[] b=new int[M+1];
      StringTokenizer st=new StringTokenizer(br.readLine());
      for(int j=1 ; j<=M ; j++){
        b[j]=parseInt(st.nextToken());
      }
      List<String>list=new ArrayList<>();
      for(int j=1 ; j<=N ; j++){
        int c=0 ;
        for(int t : map.get(j).keySet()){
          c+=b[t]*map.get(j).get(t);
        }
        list.add(String.valueOf(c));
      }
      System.out.println(String.join(" ",list));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    line := br.readLine() ; 
    var N : int ;
    var M : int ;
    N := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    M := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var map : Map(int,Map(int,int)) ; map := Map{} ;
        var i : int ; i := 1 ; while i <= N do (     map := map->union(Map{i |-> Map{}}) ;  ;     i := i + 1 ) ; 
        line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     if (line = "0 0 0") then     break else skip ; 
     var st : OclIterator ; st := OclIterator.newOclIterator_String(line) ;
    var s : int ;
    var t : int ;
    var e : int ;
    s := (st.next() + "")->toInteger() ; 
    t := (st.next() + "")->toInteger() ; 
    e := (st.next() + "")->toInteger() ; 
    map := map->at(s)->union(Map{t |-> e}) ; 
 ) ;     line := br.readLine() ;
 ) ;  
    var L : int ; L := parseInt(br.readLine()) ;
        var i : int ; i := 0 ; while i < L do ( (     var b : Sequence(int) ; b := Integer.subrange(1,M + 1)->collect(0) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var j : int ; j := 1 ; while j <= M do ( (     b[j+1] := (st.next() + "")->toInteger() )  ;     j := j + 1 ) ; 
    var list : Sequence(String) ; list := Sequence{} ;
        var j : int ; j := 1 ; while j <= N do ( (     var c : int ; c := 0 ;
     for (t : map->at(j).keySet()) do ( (     c := c+(b[t+1] * map->at(j)->at(t+1)) )  ) ; 
     list := list->including(((c) + "")) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(join(" ", list)) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int l=0 ;
    boolean ok=true ;
    for(int i=0 ; i<n ; i++){
      String in=sc.next();
      int count=sc.nextInt();
      if(in.equals("("))l+=count ;
      else l-=count ;
      if(l<0)ok=false ;
    }
    System.out.println((l==0 && ok)? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var l : int ; l := 0 ;
    var ok : boolean ; ok := true ;
        var i : int ; i := 0 ; while i < n do ( (     var in : String ; in := sc.getCurrent() ;
     var count : int ; count := sc.getCurrent()->toInteger() ;
     if (in = "(") then     l := l+(count) else     l := l-(count) ; ;  
     if (l < 0) then     ok := false ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if (l = 0 & ok) then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class MST_599B {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken()),m=Integer.parseInt(st.nextToken());
    Map<Integer,Set<Integer>>map=new HashMap<>();
    for(int i=0 ; i<m ; i++){
      st=new StringTokenizer(br.readLine());
      int u=Integer.parseInt(st.nextToken())-1 ;
      int v=Integer.parseInt(st.nextToken())-1 ;
      map.putIfAbsent(u,new HashSet<>());
      map.putIfAbsent(v,new HashSet<>());
      map.get(u).add(v);
      map.get(v).add(u);
    }
    Queue<Integer>waitList=new LinkedList<>();
    for(int i=0 ; i<n ; i++)waitList.add(i);
    Queue<Integer>queue=new LinkedList<>();
    int components=0 ;
    while(! waitList.isEmpty()){
      queue.add(waitList.poll());
      components++;
      while(! queue.isEmpty()){
        int curr=queue.poll();
        for(int s=waitList.size(); s>0 ; s--){
          int next=waitList.poll();
          if(! map.containsKey(curr)|| ! map.get(curr).contains(next)){
            queue.add(next);
          }
          else {
            waitList.add(next);
          }
        }
      }
    }
    System.out.println(components-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MST_599B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var map : Map(int,Set(int)) ; map := Map{} ;
        var i : int ; i := 0 ; while i < m do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var u : int ; u := (st.next())->toInteger() - 1 ;
    var v : int ; v := (st.next())->toInteger() - 1 ;
    if map->keys()->includes(u) then skip else map := map->union(Map{u |-> Set{}}) ; 
    if map->keys()->includes(v) then skip else map := map->union(Map{v |-> Set{}}) ; 
    map->at(u)->excludes(v) ; 
    map->at(v)->excludes(u) ; 
 )  ;     i := i + 1 ) ; 
    var waitList : Sequence(int) ; waitList := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     waitList := waitList->including(i) ;  ;     i := i + 1 ) ; 
    var queue : Sequence(int) ; queue := Sequence{} ;
    var components : int ; components := 0 ;
    while (not(waitList->isEmpty())) do (     queue := queue->including(waitList->min()) ; 
     components := components + 1 ; 
     while (not(queue->isEmpty())) do (     var curr : int ; curr := queue->min() ;
         var s : int ; s := waitList->size() ; while s > 0 do ( (     var next : int ; next := waitList->min() ;
     if (not(map->keys()->includes(curr)) or not(map->at(curr)->includes(next))) then (     queue := queue->including(next) ) else (     waitList := waitList->including(next) ) )  ;     s := s - 1 ) ) ) ; 
    OclFile["System.out"].println(components - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.Scanner ;
import java.util.TreeSet ;
import javax.print.attribute.standard.MediaSize.Other ;
import javax.xml.bind.ParseConversionEvent ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    final int n=sc.nextInt();
    boolean broken=false ;
    int un_closed=0 ;
    for(int i=0 ; i<n ; i++){
      final boolean open=sc.next().toCharArray()[0]=='(' ;
      final int num=sc.nextInt();
      if(broken){
        continue ;
      }
      if(open){
        un_closed+=num ;
      }
      else {
        un_closed-=num ;
        if(un_closed<0){
          broken=true ;
        }
      }
    }
    if(broken || un_closed>0){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var broken : boolean ; broken := false ;
    var un_closed : int ; un_closed := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var open : boolean ; open := sc.getCurrent()->characters()[0+1] = '(' ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
     if (broken) then (     continue ) else skip ; 
     if (open) then (     un_closed := un_closed+(num) ) else (     un_closed := un_closed-(num) ; 
     if (un_closed < 0) then (     broken := true ) else skip ) )  ;     i := i + 1 ) ; 
    if (broken or un_closed > 0) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  int n ;
  int[] a,b ;
  void run(){
    n=sc.nextInt();
    a=new int[n];
    b=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.next().charAt(0);
      b[i]=sc.nextInt();
    }
    solve();
  }
  void solve(){
    int left=0 ;
    boolean ok=true ;
    for(int i=0 ; i<n ; i++){
      if(a[i]=='('){
        left+=b[i];
      }
      else {
        left-=b[i];
      }
      ok &=left>=0 ;
    }
    ok &=left==0 ;
    println(ok ? "YES" : "NO");
  }
  void println(String s){
    System.out.println(s);
  }
  void debug(Object...os){
    System.err.println(deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute n : int;
   attribute a : Sequence(int);
   operation run() : void
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
     a := Integer.subrange(1,n)->collect(0) ; 
    b := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->at(0+1) ; 
     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute solve() ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var left : int ; left := 0 ;
     var ok : boolean ; ok := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = '(') then (     left := left+(b[i+1]) ) else (     left := left-(b[i+1]) ) ;  
     ok := MathLib.bitwiseAnd(ok, left >= 0) )  ;     i := i + 1 ) ; 
    ok := MathLib.bitwiseAnd(ok, left = 0) ; 
    execute println(if ok then "YES" else "NO" endif) ; 
 );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayDeque ;
import java.util.Deque ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    Deque<Character>stackP=new ArrayDeque<>();
    Deque<Integer>stackX=new ArrayDeque<>();
    stackP.push('\0');
    stackX.push(-1);
    int n=parseInt(br.readLine());
    for(int i=0 ; i<n ; i++){
      line=br.readLine();
      char p=line.charAt(0);
      int x=parseInt(line.substring(line.indexOf(' ')+1));
      if(stackP.peek()==p){
        x+=stackX.pop();
        stackX.push(x);
      }
      else if(stackP.peek()=='(' && p==')'){
        if(stackX.peek()==x){
          stackX.pop();
          stackP.pop();
        }
        else if(stackX.peek()>x){
          int y=stackX.pop()-x ;
          stackX.push(y);
        }
        else {
          stackP.pop();
          x-=stackX.pop();
          stackP.push(p);
          stackX.push(x);
        }
      }
      else {
        stackP.push(p);
        stackX.push(x);
      }
    }
    System.out.println(stackX.peek()==-1 ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var stackP : Sequence(String) ; stackP := ArrayDeque<OclAny>.newArrayDeque() ;
    var stackX : Sequence(int) ; stackX := ArrayDeque<OclAny>.newArrayDeque() ;
    stackP := stackP->append('\0') ; 
    stackX := stackX->append(-1) ; 
    var n : int ; n := parseInt(br.readLine()) ;
        var i : int ; i := 0 ; while i < n do ( (     line := br.readLine() ; 
     var p : String ; p := line->at(0+1) ;
     var x : int ; x := parseInt(line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1)) ;
     if (stackP->min() = p) then (     x := x + stackX->last() ;     stackX := stackX->front() ; 
     stackX := stackX->append(x) ) else     if (stackP->min() = '(' & p = ')') then (     if (stackX->min() = x) then (     stackX := stackX->front() ; 
     stackP := stackP->front() ) else     if (stackX->min() > x) then (     var y : int ; y := stackX->last() - (x)->char2byte() ;
     stackX := stackX->append(y) ) else (     stackP := stackP->front() ; 
     x := x - (stackX->last()) ;     stackX := stackX->front() ; 
     stackP := stackP->append(p) ; 
     stackX := stackX->append(x) ) ;  ) else (     stackP := stackP->append(p) ; 
     stackX := stackX->append(x) ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if stackX->min() = -1 then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    sc.nextLine();
    boolean flg=true ;
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      String[] s=sc.nextLine().split(" ");
      if(s[0] .equals("("))cnt+=Integer.parseInt(s[1]);
      if(s[0] .equals(")"))cnt-=Integer.parseInt(s[1]);
      if(cnt<0)flg=false ;
    }
    if(flg && cnt==0)System.out.println("YES");
    else System.out.println("NO");
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
    var flg : boolean ; flg := true ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var s : Sequence(String) ; s := sc.nextLine()->split(" ") ;
     if (s[0+1] = "(") then     cnt := cnt+((s[1+1])->toInteger()) ; else skip ; 
     if (s[0+1] = ")") then     cnt := cnt-((s[1+1])->toInteger()) ; else skip ; 
     if (cnt < 0) then     flg := false ; else skip )  ;     i := i + 1 ) ; 
    if (flg & cnt = 0) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    ArrayList<Integer>result=new ArrayList<Integer>();
    Scanner insert=new Scanner(System.in);
    int n=-1 ;
    while(true){
      String line=insert.nextLine();
      n=Integer.parseInt(line);
      if(n==0){
        break ;
      }
      for(int i=0 ; i<n ; i++){
      }
      line=insert.nextLine();
      String array2[]=line.split(" ");
      int[] input=new int[n];
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        input[i]=(Integer.parseInt(array2[i]));
        sum+=input[i];
      }
      double avg=(double)sum/(double)n ;
      int num=0 ;
      for(int i=0 ; i<n ; i++){
        if(input[i]<=avg){
          num++;
        }
      }
      result.add(num);
    }
    for(int i=0 ; i<(result.size()); i++){
      if(result.get(i)==-1){
        System.out.println("NONE");
      }
      else {
        System.out.println(result.get(i));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var result : Sequence(int) ; result := Sequence{} ;
     var insert : OclFile ; insert := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := -1 ;
    while (true) do (     var line : String ; line := insert.nextLine() ;
     n := (line)->toInteger() ; 
    if (n = 0) then (     break ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( skip  ;     i := i + 1 ) ; 
    line := insert.nextLine() ; 
    var array2 : Sequence(String) ; array2 := line->split(" ") ;
    var input : Sequence(int) ; input := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     input[i+1] := ((array2[i+1])->toInteger()) ; 
     sum := sum+(input[i+1]) )  ;     i := i + 1 ) ; 
    var avg : double ; avg := sum->oclAsType(double) / n->oclAsType(double) ;
    var num : int ; num := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (input[i+1] <= avg) then (     num := num + 1 ) else skip )  ;     i := i + 1 ) ; 
    result := result->including(num) ; 
 ) ; 
        var i : int ; i := 0 ; while i < (result->size()) do ( (     if (result->at(i+1) = -1) then (     OclFile["System.out"].println("NONE") ) else (     OclFile["System.out"].println(result->at(i+1)) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      int n=Integer.parseInt(br.readLine());
      if(n==0){
        break ;
      }
      int input[]=new int[n];
      String[] tmpArray=br.readLine().split(" ");
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        input[i]=Integer.parseInt(tmpArray[i]);
        sum+=input[i];
      }
      double ave=(double)sum/n ;
      int count=0 ;
      for(int i=0 ; i<n ; i++){
        if(input[i]<=ave){
          count++;
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var n : int ; n := (br.readLine())->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var input : Sequence(int) ; input := Integer.subrange(1,n)->collect(0) ;
    var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     input[i+1] := (tmpArray[i+1])->toInteger() ; 
     sum := sum+(input[i+1]) )  ;     i := i + 1 ) ; 
    var ave : double ; ave := sum->oclAsType(double) / n ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (input[i+1] <= ave) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] arg){
    Main m=new Main();
    m.run();
  }
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      int a[]=new int[n];
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
        sum+=a[i];
      }
      int res=0 ;
      for(int i=0 ; i<n ; i++){
        if(a[i]*n<=sum){
          res++;
        }
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] * n <= sum) then (     res := res + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int i=0 ;
    int count=0 ;
    String strMoney ;
    StringBuilder result=new StringBuilder();
    while(true){
      String line=sc.nextLine();
      if(line.equals("0")){
        break ;
      }
      else if(i>0 && i % 2==0){
        result.append("\n");
      }
      if(i % 2==0){
        count=Integer.valueOf(line);
      }
      else {
        strMoney=line ;
        result.append(calculate(count,strMoney));
      }
      i++;
    }
    System.out.println(result.toString());
  }
  public static int calculate(int count,String strMoney){
    String[] arrMoney=strMoney.split(" ");
    int total=0 ;
    for(String money : arrMoney){
      total+=Integer.valueOf(money);
    }
    int result=0 ;
    for(String money : arrMoney){
      if(Integer.valueOf(money)*count<=total){
        result++;
      }
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ; i := 0 ;
    var count : int ; count := 0 ;
    var strMoney : String ;
    var result : String ; result := StringLib.newString() ;
    while (true) do (     var line : String ; line := sc.nextLine() ;
     if (line = "0") then (     break ) else     if (i > 0 & i mod 2 = 0) then (     result := result + StringLib.newString("\n") ) else skip ; ;  
     if (i mod 2 = 0) then (     count := (line)->toInteger() ) else (     strMoney := line ; 
     result := result + StringLib.newString(calculate(count, strMoney)) ) ;  
     i := i + 1 ) ; 
    OclFile["System.out"].println(result+"") ; 
 );
  static   operation calculate( count : int, strMoney : String) : int
  pre: true
  post: true
  activity: (     var arrMoney : Sequence(String) ; arrMoney := strMoney->split(" ") ;
     var total : int ; total := 0 ;
    for (money : arrMoney) do ( (     total := total+((money)->toInteger()) )  ) ; 
    var result : int ; result := 0 ;
    for (money : arrMoney) do ( (     if ((money)->toInteger() * count <= total) then (     result := result + 1 ) else skip )  ) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    List<List<Integer>>bookList=new ArrayList<List<Integer>>();
    List<Double>ave=new ArrayList<Double>();
    int j=0 ;
    Scanner scan=new Scanner(System.in);
    while(true){
      if(j==0){
        String str=scan.nextLine();
        j=1 ;
        if("0".equals(str))break ;
      }
      else {
        String str=scan.nextLine();
        if("0".equals(str))break ;
        String[] result=str.split(" ",0);
        List<Integer>sumlist=new ArrayList<Integer>();
        double d1=0.0 ;
        for(String d : result){
          d1+=Integer.parseInt(d);
          sumlist.add(Integer.parseInt(d));
        }
        ave.add(d1/sumlist.size());
        bookList.add(sumlist);
        j=0 ;
      }
    }
    int i=0 ;
    for(List<Integer>d1 : bookList){
      int num=0 ;
      for(Integer d2 : d1){
        if(d2<=ave.get(i)){
          num++;
        }
      }
      System.out.println(num);
      i++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bookList : Sequence(Sequence(int)) ; bookList := Sequence{} ;
     var ave : Sequence(double) ; ave := Sequence{} ;
    var j : int ; j := 0 ;
    var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (true) do (     if (j = 0) then (     var str : String ; str := scan.nextLine() ;
     j := 1 ; 
     if ("0" = str) then     break else skip ) else (     var str : String ; str := scan.nextLine() ;
     if ("0" = str) then     break else skip ; 
    var result : Sequence(String) ; result := str->split(" ") ;
    var sumlist : Sequence(int) ; sumlist := Sequence{} ;
    var d1 : double ; d1 := 0.0 ;
    for (d : result) do ( (     d1 := d1+((d)->toInteger()) ; 
     sumlist := sumlist->including((d)->toInteger()) )  ) ; 
    ave := ave->including(d1 / sumlist->size()) ; 
    bookList := bookList->including(sumlist) ; 
    j := 0 ; 
 ) ) ; 
    var i : int ; i := 0 ;
    for (d1 : bookList) do ( (     var num : int ; num := 0 ;
     for (d2 : d1) do ( (     if (d2 <= ave->at(i+1)) then (     num := num + 1 ) else skip )  ) ; 
     OclFile["System.out"].println(num) ; 
     i := i + 1 )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class CountZeros {
  int firstZero(int arr[],int low,int high){
    if(high>=low){
      int mid=low+(high-low)/2 ;
      if((mid==0 || arr[mid-1]==1)&& arr[mid]==0)return mid ;
      if(arr[mid]==1)return firstZero(arr,(mid+1),high);
      else return firstZero(arr,low,(mid-1));
    }
    return-1 ;
  }
  int countZeroes(int arr[],int n){
    int first=firstZero(arr,0,n-1);
    if(first==-1)return 0 ;
    return(n-first);
  }
  public static void main(String[] args){
    CountZeros count=new CountZeros();
    int arr[]={
      1,1,1,0,0,0,0,0 };
      int n=arr.length ;
      System.out.println("Count of zeroes is "+count.countZeroes(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class CountZeros {
   operation firstZero( arr : Sequence(int), low : int, high : int) : int
  pre: true
  post: true
  activity: (     if (high >= low) then (     var mid : int ; mid := low + (high - low) / 2 ;
     if ((mid = 0 or arr[mid - 1+1] = 1) & arr[mid+1] = 0) then     return mid else skip ; 
     if (arr[mid+1] = 1) then     return firstZero(arr, (mid + 1), high) else     return firstZero(arr, low, (mid - 1)) ) else skip ; 
     return -1 );
   operation countZeroes( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var first : int ; first := firstZero(arr, 0, n - 1) ;
     if (first = -1) then     return 0 else skip ; 
     return (n - first) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var count : CountZeros ; count := CountZeros.newCountZeros() ;
     var arr : Sequence(int) ; arr := Sequence{1,1,1,0,0,0,0,0} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Count of zeroes is " + count.countZeroes(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner scn=new Scanner(System.in);
    int X=scn.nextInt();
    X+=scn.nextInt()/2 ;
    System.out.println(X);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : int ; X := scn.getCurrent()->toInteger() ;
     X := X+(scn.getCurrent()->toInteger() / 2) ; 
     OclFile["System.out"].println(X) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    int x=Integer.parseInt(in.readLine());
    int ans=0 ;
    while(x>=5){
      if(x>=500){
        ans+=1000*(x/500);
        x %=500 ;
      }
      else {
        ans+=5*(x/5);
        x %=5 ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var x : int ; x := (in.readLine())->toInteger() ;
    var ans : int ; ans := 0 ;
    while (x >= 5) do (     if (x >= 500) then (     ans := ans+(1000 * (x / 500)) ; 
     x := x mod 500 ) else (     ans := ans+(5 * (x / 5)) ; 
     x := x mod 5 ) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.BigDecimal ;
public class Main {
  private static void solve(){
    int X=ni();
    System.out.println(X/500*1000+(X % 500)/5*5);
  }
  private static BufferedReader br ;
  public static void main(String[] args){
    br=new BufferedReader(new InputStreamReader(System.in));
    String debugDataPath=System.getenv("DD_PATH");
    if(debugDataPath!=null){
      try {
        br=new BufferedReader(new InputStreamReader(new FileInputStream(new File(debugDataPath))));
      }
      catch(Exception e){
        throw new RuntimeException(e);
      }
    }
    boolean hasNext=true ;
    while(hasNext){
      solve();
      try {
        br.mark(1);
        if(br.read()>0){
          br.reset();
          System.out.println("---");
        }
        else {
          hasNext=false ;
        }
      }
      catch(Exception e){
        throw new RuntimeException(e);
      }
    }
  }
  private static StringTokenizer tokenizer=null ;
  public static String next(){
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        tokenizer=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }
  private static int ni(){
    return Integer.parseInt(next());
  }
  private static long nl(){
    return Long.parseLong(next());
  }
  private static double nd(){
    return Double.parseDouble(next());
  }
  private static int[] na(int n){
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=ni();
    return a ;
  }
  private static char[] ns(){
    return next().toCharArray();
  }
  private static long[] nal(int n){
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=nl();
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var X : int ; X := ni() ;
     OclFile["System.out"].println(X / 500 * 1000 + (X mod 500) / 5 * 5) );
  static   attribute br : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     var debugDataPath : String ; debugDataPath := OclProcess.getEnvironmentProperty("DD_PATH") ;
    if (debugDataPath /= null) then (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(debugDataPath)))) )   catch (e : ProgramException) do (     error ProgramException(e) )
 ) else skip ; 
    var hasNext : boolean ; hasNext := true ;
    while (hasNext) do (     execute solve() ; 
     try (     skip ; 
     if (br.read() > 0) then (     skip ; 
     OclFile["System.out"].println("---") ) else (     hasNext := false ) )   catch (e : ProgramException) do (     error ProgramException(e) )
 ) ; 
 );
  static   attribute tokenizer : OclIterator := null;
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
  static   operation ni() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nl() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nd() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation na( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := ni() ;  ;     i := i + 1 ) ; 
     return a );
  static   operation ns() : Sequence(String)
  pre: true
  post: true
  activity: (     return next()->characters() );
  static   operation nal( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nl() ;  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int X=sc.nextInt();
    int ans=0 ;
    for(int i=0 ; i<1000000000 ; i++){
      if(X>=500){
        X=X-500 ;
        ans=ans+1000 ;
      }
    }
    for(int i=0 ; i<1000000000 ; i++){
      if(X>=5){
        X=X-5 ;
        ans=ans+5 ;
      }
    }
    System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : int ; X := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 1000000000 do ( (     if (X >= 500) then (     X := X - 500 ; 
     ans := ans + 1000 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 1000000000 do ( (     if (X >= 5) then (     X := X - 5 ; 
     ans := ans + 5 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  static int[] S ;
  public static void main(String[] args)throws Exception {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String W=in.readLine();
    int N=Integer.parseInt(W);
    int x500=N/500 ;
    N=N % 500 ;
    int x5=N/5 ;
    System.out.println(x500*1000+x5*5);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute S : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var W : String ; W := in.readLine() ;
    var N : int ; N := (W)->toInteger() ;
    var x500 : int ; x500 := N / 500 ;
    N := N mod 500 ; 
    var x5 : int ; x5 := N / 5 ;
    OclFile["System.out"].println(x500 * 1000 + x5 * 5) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static final Scanner in=new Scanner(System.in);
  public static void main(String args[]){
    int n=in.nextInt();
    int a=n/500 ;
    int sum=0 ;
    sum+=a*1000 ;
    n=n % 500 ;
    int b=n/5 ;
    sum+=b*5 ;
    System.out.print(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : int ; a := n / 500 ;
    var sum : int ; sum := 0 ;
    sum := sum+(a * 1000) ; 
    n := n mod 500 ; 
    var b : int ; b := n / 5 ;
    sum := sum+(b * 5) ; 
    OclFile["System.out"].print(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF425B extends PrintWriter {
  CF425B(){
    super(System.out,true);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    CF425B o=new CF425B();
    o.main();
    o.flush();
  }
  void main(){
    int n=sc.nextInt();
    int m=sc.nextInt();
    int k=sc.nextInt();
    int[][] aa=new int[n][m];
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<m ; j++)aa[i][j]=sc.nextInt();
    int ans=k+1 ;
    if(m>k)for(int j_=0 ;
    j_<m ;
    j_++){
      int sum=0 ;
      for(int j=0 ; j<m ; j++){
        int cnt=0 ;
        for(int i=0 ; i<n ; i++)if(aa[i][j]!=aa[i][j_])cnt++;
        sum+=Math.min(cnt,n-cnt);
      }
      ans=Math.min(ans,sum);
    }
    else for(int b=0 ;
    b<1<<m ;
    b++){
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        int cnt=0 ;
        for(int j=0 ; j<m ; j++)if((aa[i][j]==0)!=((b & 1<<j)==0))cnt++;
        sum+=Math.min(cnt,m-cnt);
      }
      ans=Math.min(ans,sum);
    }
    println(ans>k ?-1 : ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF425B extends OclFile {
   static operation newCF425B() : CF425B
  pre: true
  post: true
  activity:
  ( var self : CF425B ;
    self := createCF425B();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"], true) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : CF425B ; o := CF425B.newCF425B() ;
     o.main() ; 
     o.flush() );
   operation main() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var aa : Sequence(Sequence(int)) ; aa := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < m do (     aa[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := k + 1 ;
    if (m > k) then         var j_ : int ; j_ := 0 ; while j_ < m do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < m do ( (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < n do (     if (aa[i+1][j+1] /= aa[i+1][j_+1]) then     cnt := cnt + 1 ; else skip ;  ;     i := i + 1 ) ; 
     sum := sum+(Set{cnt, n - cnt}->min()) )  ;     j := j + 1 ) ; 
     ans := Set{ans, sum}->min() )  ;     j_ := j_ + 1 ) else         var b : int ; b := 0 ; while b < (1*(2->pow(m)))->oclAsType(long) do ( (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var cnt : int ; cnt := 0 ;
         var j : int ; j := 0 ; while j < m do (     if ((aa[i+1][j+1] = 0) /= ((MathLib.bitwiseAnd(b,(1*(2->pow(j)))->oclAsType(long))) = 0)) then     cnt := cnt + 1 ; else skip ;  ;     j := j + 1 ) ; 
     sum := sum+(Set{cnt, m - cnt}->min()) )  ;     i := i + 1 ) ; 
     ans := Set{ans, sum}->min() )  ;     b := b + 1 ) ; ;  
    execute println(if ans > k then -1 else ans endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public void run(){
    int n=sc.nextInt();
    calc(n);
  }
  public void calc(int n){
    ArrayList<Integer>list=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      list.add(sc.nextInt());
    }
    Collections.sort(list);
    int max=-1 ;
    for(int i=n-1 ; i>=0 ; i--){
      for(int j=i-1 ; j>=0 ; j--){
        int pro=list.get(i)*list.get(j);
        if(pro<max)break ;
        else if(pro>max && check(pro/10,pro % 10)==1){
          max=pro ;
        }
      }
    }
    System.out.println(max);
  }
  public int check(int p,int b){
    if(p==0)return 1 ;
    int nb=p % 10 ;
    int np=p/10 ;
    if(nb==b-1){
      return check(np,nb);
    }
    else return 0 ;
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     execute calc(n) );
   operation calc( n : int) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     list := list->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var max : int ; max := -1 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (         var j : int ; j := i - 1 ; while j >= 0 do ( (     var pro : int ; pro := list->at(i+1) * list->at(j+1) ;
     if (pro < max) then     break else     if (pro > max & check(pro / 10, pro mod 10) = 1) then (     max := pro ) else skip ; )  ;     j := j - 1 ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
   operation check( p : int, b : int) : int
  pre: true
  post: true
  activity: (     if (p = 0) then     return 1 else skip ; 
     var nb : int ; nb := p mod 10 ;
     var np : int ; np := p / 10 ;
     if (nb = b - 1) then (     return check(np, nb) ) else     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
class Main {
  public static void main(final String[] args){
    final Scanner stdin=new Scanner(System.in);
    while(true){
      final int n=stdin.nextInt();
      if(n==0){
        break ;
      }
      final int[] ns=new int[n-1];
      for(int i=1 ; i<=n-1 ; i++){
        ns[i-1]=(i*i)% n ;
      }
      Set<Integer>set=new HashSet<Integer>();
      for(int i : ns){
        if(! set.contains(i)){
          set.add(i);
        }
      }
      int[] ans=new int[n/2];
      for(final int i : set){
        for(final int j : set){
          if(i!=j){
            int diff=(i-j+n)% n ;
            if(diff>n/2){
              diff=n-diff ;
            }
            ans[diff-1]++;
          }
        }
      }
      for(int i : ans){
        System.out.println(i);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := stdin.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var ns : Sequence(int) ; ns := Integer.subrange(1,n - 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n - 1 do ( (     ns[i - 1+1] := (i * i) mod n )  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
    for (i : ns) do ( (     if (not(set->includes(i))) then (     set := set->including(i) ) else skip )  ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,n / 2)->collect(0) ;
    for (i : set) do ( (     for (j : set) do ( (     if (i /= j) then (     var diff : int ; diff := (i - j + n) mod n ;
     if (diff > n / 2) then (     diff := n - diff ) else skip ; 
     ans[diff - 1+1] := ans[diff - 1+1] + 1 ) else skip )  ) )  ) ; 
    for (i : ans) do ( (     OclFile["System.out"].println(i) )  ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      int n=sc.nextInt();
      if(n==0)break ;
      Set<Integer>S=new HashSet<Integer>();
      for(int i=1 ; i<n ; i++){
        int x=(i*i)% n ;
        S.add(x);
      }
      int H=(n-1)/2 ;
      Integer[] L=S.toArray(new Integer[0]);
      int[] count=new int[H+1];
      for(int a : L){
        for(int b : L){
          if(a!=b){
            int d=a-b ;
            if(d<0)d+=n ;
            if(d>H)d=n-d ;
            count[d]++;
          }
        }
      }
      for(int i=1 ; i<=H ; i++)System.out.println(count[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var S : Set(int) ; S := Set{} ;
        var i : int ; i := 1 ; while i < n do ( (     var x : int ; x := (i * i) mod n ;
     S := S->including(x) )  ;     i := i + 1 ) ; 
    var H : int ; H := (n - 1) / 2 ;
    var L : Sequence(int) ; L := S->asSequence() ;
    var count : Sequence(int) ; count := Integer.subrange(1,H + 1)->collect(0) ;
    for (a : L) do ( (     for (b : L) do ( (     if (a /= b) then (     var d : int ; d := a - b ;
     if (d < 0) then     d := d+(n) ; else skip ; 
     if (d > H) then     d := n - d ; else skip ; 
     count[d+1] := count[d+1] + 1 ) else skip )  ) )  ) ; 
        var i : int ; i := 1 ; while i <= H do (     OclFile["System.out"].println(count[i+1]) ;  ;     i := i + 1 ) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public void solve()throws IOException {
    int n ;
    while((n=nextInt())!=0){
      int[] ans=new int[n/2+1];
      Set<Integer>set=new HashSet<Integer>();
      for(int i=1 ; i<n ; i++){
        int x=i*i % n ;
        set.add(x);
      }
      List<Integer>list=new ArrayList<Integer>(set);
      Collections.sort(list);
      for(int i=0 ; i<list.size(); i++){
        for(int j=i+1 ; j<list.size(); j++){
          int key=((list.get(i)-list.get(j))+n)% n ;
          key=Math.min(n-key,key);
          ans[key]+=2 ;
        }
      }
      for(int i=1 ; i<ans.length ; i++){
        writer.println(ans[i]);
      }
    }
    writer.flush();
  }
  public static void main(String args[])throws IOException {
    new Main().run();
  }
  BufferedReader reader ;
  StringTokenizer tokenizer ;
  PrintWriter writer ;
  public void run()throws IOException {
    try {
      reader=new BufferedReader(new InputStreamReader(System.in));
      tokenizer=null ;
      writer=new PrintWriter(System.out);
      solve();
      reader.close();
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public String nextToken()throws IOException {
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ;
         n := nextInt() ;
    while ((n) /= 0) do (    skip ; (     var ans : Sequence(int) ; ans := Integer.subrange(1,n / 2 + 1)->collect(0) ;
     var set : Set(int) ; set := Set{} ;
        var i : int ; i := 1 ; while i < n do ( (     var x : int ; x := i * i mod n ;
     set := set->including(x) )  ;     i := i + 1 ) ; 
    var list : Sequence(int) ; list := Sequence{}->union(set) ;
    list := list->sort() ; 
        var i : int ; i := 0 ; while i < list->size() do ( (         var j : int ; j := i + 1 ; while j < list->size() do ( (     var key : int ; key := ((list->at(i+1) - list->at(j+1)) + n) mod n ;
     key := Set{n - key, key}->min() ; 
     ans[key+1] := ans[key+1]+(2) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < ans->size() do ( (     writer.println(ans[i+1]) )  ;     i := i + 1 ) ; 
 ) ;     n := nextInt() ;
 ) ;  
     writer.flush() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   attribute writer : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     try (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := null ; 
    writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  public void run(){
    try(BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out)){
      String[] lines=in.readLine().split(" ");
      int x=Integer.parseInt(lines[0]);
      int y=Integer.parseInt(lines[1]);
      int ans=x+(y>>1);
      System.out.println(ans);
    }
    catch(IOException e){
      System.err.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]) ;
 (     var lines : Sequence(String) ; lines := in.readLine()->split(" ") ;
     var x : int ; x := (lines[0+1])->toInteger() ;
    var y : int ; y := (lines[1+1])->toInteger() ;
    var ans : int ; ans := x + ((y/(2->pow(1)))->oclAsType(long)) ;
    OclFile["System.out"].println(ans) ; 
 ))   catch (e : IOException) do (     OclFile["System.err"].println(e) )
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
class Main {
  private static void solve(){
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      if(n==0){
        break ;
      }
      Set<Integer>numbers=new HashSet<Integer>();
      for(int i=1 ; i<n ; i++){
        numbers.add((i*i)% n);
      }
      int[] results=new int[(n-1)/2+1];
      int[] numbersArray=new int[numbers.size()];
      int index=0 ;
      for(int i : numbers.toArray(new Integer[numbers.size()])){
        numbersArray[index++]=i ;
      }
      for(int i=0 ; i<numbersArray.length ; i++){
        int a=numbersArray[i];
        for(int j=0 ; j<numbersArray.length ; j++){
          if(i==j){
            continue ;
          }
          int b=numbersArray[j];
          int c=a-b ;
          if(c<0){
            c+=n ;
          }
          if(c>(n-1)/2){
            c=n-c ;
          }
          results[c]++;
        }
      }
      for(int i=1 ; i<(n-1)/2+1 ; i++){
        System.out.println(results[i]);
      }
    }
  }
  public static void main(String...arg){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var numbers : Set(int) ; numbers := Set{} ;
        var i : int ; i := 1 ; while i < n do ( (     numbers := numbers->including((i * i) mod n) )  ;     i := i + 1 ) ; 
    var results : Sequence(int) ; results := Integer.subrange(1,(n - 1) / 2 + 1)->collect(0) ;
    var numbersArray : Sequence(int) ; numbersArray := Integer.subrange(1,numbers->size())->collect(0) ;
    var index : int ; index := 0 ;
    for (i : numbers->asSequence()) do ( (      numbersArray[index+1] := i  ; index := index + 1 )  ) ; 
        var i : int ; i := 0 ; while i < numbersArray->size() do ( (     var a : int ; a := numbersArray[i+1] ;
         var j : int ; j := 0 ; while j < numbersArray->size() do ( (     if (i = j) then (     continue ) else skip ; 
     var b : int ; b := numbersArray[j+1] ;
    var c : int ; c := a - b ;
    if (c < 0) then (     c := c+(n) ) else skip ; 
    if (c > (n - 1) / 2) then (     c := n - c ) else skip ; 
    results[c+1] := results[c+1] + 1 ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < (n - 1) / 2 + 1 do ( (     OclFile["System.out"].println(results[i+1]) )  ;     i := i + 1 ) ; 
 ) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      int n=in.nextInt();
      if(n==0)return ;
      TreeSet<Integer>TS=new TreeSet<Integer>();
      for(int i=1 ; i<n ; i++)TS.add((i*i)% n);
      int a[]=new int[TS.size()];
      int k=0 ;
      for(int p : TS)a[k++]=p ;
      int c[]=new int[k*(k-1)];
      int x=0 ;
      for(int i=0 ; i<k ; i++)for(int j=0 ; j<k ; j++){
        if(i==j)continue ;
        int rem=a[i]-a[j];
        if(rem<0)rem+=n ;
        if(rem>(n-1)/2)rem=n-rem ;
        c[x++]=rem ;
      }
      int b[]=new int[(n-1)/2+1];
      for(int i=0 ; i<k*(k-1); i++)b[c[i] ]++;
      for(int i=1 ; i<=(n-1)/2 ; i++)System.out.println(b[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var TS : Set(int) ; TS := Set{} ;
        var i : int ; i := 1 ; while i < n do (     TS := TS->including((i * i) mod n) ;  ;     i := i + 1 ) ; 
    var a : Sequence(int) ; a := Integer.subrange(1,TS->size())->collect(0) ;
    var k : int ; k := 0 ;
    for (p : TS) do (      a[k+1] := p  ; k := k + 1 ;  ) ; 
    var c : Sequence(int) ; c := Integer.subrange(1,k * (k - 1))->collect(0) ;
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < k do (         var j : int ; j := 0 ; while j < k do ( (     if (i = j) then     continue else skip ; 
     var rem : int ; rem := a[i+1] - a[j+1] ;
    if (rem < 0) then     rem := rem+(n) ; else skip ; 
    if (rem > (n - 1) / 2) then     rem := n - rem ; else skip ; 
     c[x+1] := rem  ; x := x + 1 ; 
 )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,(n - 1) / 2 + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < k * (k - 1) do (     b[c[i+1]+1] := b[c[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= (n - 1) / 2 do (     OclFile["System.out"].println(b[i+1]) ;  ;     i := i + 1 ) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class KindAnton {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int a[]=new int[n];
      int b[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      for(int i=0 ; i<n ; i++)b[i]=sc.nextInt();
      int minus=-1,plus=-1 ;
      boolean is=true ;
      for(int i=0 ; i<n ; i++){
        if(a[i]<b[i] && plus==-1){
          is=false ;
          break ;
        }
        if(a[i]>b[i] && minus==-1){
          is=false ;
          break ;
        }
        if(a[i]==1 && plus==-1)plus=i ;
        if(a[i]==-1 && minus==-1)minus=i ;
      }
      System.out.println(is ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class KindAnton {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     b[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var minus : int ; minus := -1 ;
    var plus : int ; plus := -1 ;
    var is : boolean ; is := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] < b[i+1] & plus = -1) then (     is := false ; 
     break ) else skip ; 
     if (a[i+1] > b[i+1] & minus = -1) then (     is := false ; 
     break ) else skip ; 
     if (a[i+1] = 1 & plus = -1) then     plus := i ; else skip ; 
     if (a[i+1] = -1 & minus = -1) then     minus := i ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if is then "YES" else "NO" endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
import java.io.*;
public class codeHundredSixty {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=input.nextInt();
      int[] arrayOne=new int[n];
      int[] arrayTwo=new int[n];
      for(int i=0 ; i<n ; i++){
        arrayOne[i]=input.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        arrayTwo[i]=input.nextInt();
      }
      int a=0 ;
      int b=0 ;
      int flag=0 ;
      for(int i=0 ; i<n ; i++){
        if(arrayOne[i]<arrayTwo[i] && a==0){
          flag=1 ;
          break ;
        }
        else if(arrayOne[i]>arrayTwo[i] && b==0){
          flag=1 ;
          break ;
        }
        if(arrayOne[i]==1){
          a=1 ;
        }
        if(arrayOne[i]==-1){
          b=1 ;
        }
      }
      if(flag==0){
        System.out.println("YES");
      }
      else if(flag==1){
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var arrayOne : Sequence(int) ; arrayOne := Integer.subrange(1,n)->collect(0) ;
    var arrayTwo : Sequence(int) ; arrayTwo := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arrayOne[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     arrayTwo[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arrayOne[i+1] < arrayTwo[i+1] & a = 0) then (     flag := 1 ; 
     break ) else     if (arrayOne[i+1] > arrayTwo[i+1] & b = 0) then (     flag := 1 ; 
     break ) else skip ; ;  
     if (arrayOne[i+1] = 1) then (     a := 1 ) else skip ; 
     if (arrayOne[i+1] = -1) then (     b := 1 ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 0) then (     OclFile["System.out"].println("YES") ) else     if (flag = 1) then (     OclFile["System.out"].println("NO") ) else skip ; ;  
 )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
class GFG {
  public static double sumOfSeries(double num){
    double res=0,fact=1 ;
    for(int i=1 ; i<=num ; i++){
      fact=fact*i ;
      res=res+(i/fact);
    }
    return(res);
  }
  public static void main(String[] args){
    double n=5 ;
    System.out.println("Sum: "+sumOfSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfSeries( num : double) : double
  pre: true
  post: true
  activity: (     var res : double ; res := 0 ;
    var fact : double ; fact := 1 ;
         var i : int ; i := 1 ; while i <= num do ( (     fact := fact * i ; 
     res := res + (i / fact) )  ;     i := i + 1 ) ; 
     return (res) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 5 ;
     OclFile["System.out"].println("Sum: " + sumOfSeries(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.io.*;
class GFG {
  static void maxProductSum(String str,int m){
    int n=str.length();
    int product=1,sum=0 ;
    for(int i=0 ; i<m ; i++){
      sum+=(str.charAt(i)-'0');
      product*=(str.charAt(i)-'0');
    }
    int maxProd=product ;
    int maxSum=sum ;
    for(int i=m ; i<n ; i++){
      product=product*(str.charAt(i)-'0')/((str.charAt(i-m))-'0');
      sum=sum+(str.charAt(i)-'0')-((str.charAt(i-m))-'0');
      maxProd=Math.max(maxProd,product);
      maxSum=Math.max(maxSum,sum);
    }
    System.out.println("Maximum Product="+maxProd);
    System.out.println("\nMaximum Sum="+maxSum);
  }
  public static void main(String[] args){
    String str="3675356291" ;
    int m=5 ;
    maxProductSum(str,m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxProductSum( str : String, m : int) : void
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var product : int ; product := 1 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     sum := sum+((str->at(i+1) - ('0')->char2byte())) ; 
     product := product*((str->at(i+1) - ('0')->char2byte())) )  ;     i := i + 1 ) ; 
    var maxProd : int ; maxProd := product ;
    var maxSum : int ; maxSum := sum ;
        var i : int ; i := m ; while i < n do ( (     product := product * (str->at(i+1) - ('0')->char2byte()) / ((str->at(i - m+1)) - ('0')->char2byte()) ; 
     sum := sum + (str->at(i+1) - ('0')->char2byte()) - ((str->at(i - m+1)) - ('0')->char2byte()) ; 
     maxProd := Set{maxProd, product}->max() ; 
     maxSum := Set{maxSum, sum}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Maximum Product=" + maxProd) ; 
    OclFile["System.out"].println("\nMaximum Sum=" + maxSum) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "3675356291" ;
     var m : int ; m := 5 ;
     execute maxProductSum(str, m) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.geom.*;
public class Main {
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      if((a | b | c)==0)break ;
      int n=sc.nextInt();
      int[][] data=new int[n][4];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<4 ; j++){
          data[i][j]=sc.nextInt();
        }
      }
      int[] state=new int[a+b+c];
      Arrays.fill(state,2);
      for(int i=0 ; i<n ; i++){
        if(data[i][3]==1){
          for(int j=0 ; j<3 ; j++){
            state[data[i][j]-1]=1 ;
          }
        }
      }
      for(int i=0 ; i<n ; i++){
        int count=0 ;
        for(int j=0 ; j<3 ; j++){
          if(state[data[i][j]-1]!=1){
            count++;
          }
        }
        if(count==1){
          for(int j=0 ; j<3 ; j++){
            if(state[data[i][j]-1]==2){
              state[data[i][j]-1]=0 ;
            }
          }
        }
      }
      for(int i=0 ; i<state.length ; i++){
        System.out.println(state[i]);
      }
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(a,b),c)) = 0) then     break else skip ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var data : Sequence(Sequence(int)) ; data := Integer.subrange(1,n)->collect(Integer.subrange(1,4)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 4 do ( (     data[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var state : Sequence(int) ; state := Integer.subrange(1,a + b + c)->collect(0) ;
    state := state->collect(2) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (data[i+1][3+1] = 1) then (         var j : int ; j := 0 ; while j < 3 do ( (     state[data[i+1][j+1] - 1+1] := 1 )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < 3 do ( (     if (state[data[i+1][j+1] - 1+1] /= 1) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (count = 1) then (         var j : int ; j := 0 ; while j < 3 do ( (     if (state[data[i+1][j+1] - 1+1] = 2) then (     state[data[i+1][j+1] - 1+1] := 0 ) else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < state->size() do ( (     OclFile["System.out"].println(state[i+1]) )  ;     i := i + 1 ) ; 
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class demo1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int max=Math.max(a,b);
    switch(max){
      case 1 : System.out.println("1/1");
      break ;
      case 2 : System.out.println("5/6");
      break ;
      case 3 : System.out.println("2/3");
      break ;
      case 4 : System.out.println("1/2");
      break ;
      case 5 : System.out.println("1/3");
      break ;
      case 6 : System.out.println("1/6");
      break ;
      default : System.out.println(" ");
      break ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class demo1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var max : int ; max := Set{a, b}->max() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (max) ; 
       if _switchval = 1 then
     OclFile["System.out"].println("1/1") ; 
    break 
   else skip ;
       if _switchval = 2 then
     OclFile["System.out"].println("5/6") ; 
    break 
   else skip ;
       if _switchval = 3 then
     OclFile["System.out"].println("2/3") ; 
    break 
   else skip ;
       if _switchval = 4 then
     OclFile["System.out"].println("1/2") ; 
    break 
   else skip ;
       if _switchval = 5 then
     OclFile["System.out"].println("1/3") ; 
    break 
   else skip ;
       if _switchval = 6 then
     OclFile["System.out"].println("1/6") ; 
    break 
   else skip ;
       if true then
     OclFile["System.out"].println(" ") ; 
    break 
   else skip ;
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Code_9A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int Y=sc.nextInt();
    int W=sc.nextInt();
    int t=6-Math.max(Y,W)+1 ;
    if(t==6)System.out.println("1/1");
    else if(t==5)System.out.println("5/6");
    else if(t==4)System.out.println("2/3");
    else if(t==3)System.out.println("1/2");
    else if(t==2)System.out.println("1/3");
    else System.out.println("1/6");
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code_9A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var Y : int ; Y := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var t : int ; t := 6 - Set{Y, W}->max() + 1 ;
    if (t = 6) then     OclFile["System.out"].println("1/1") else     if (t = 5) then     OclFile["System.out"].println("5/6") else     if (t = 4) then     OclFile["System.out"].println("2/3") else     if (t = 3) then     OclFile["System.out"].println("1/2") else     if (t = 2) then     OclFile["System.out"].println("1/3") else     OclFile["System.out"].println("1/6") ; ;  ;  ;  ;  ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF0009A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int y=sc.nextInt();
    int w=sc.nextInt();
    String Die_probability[]={
      "1/6","1/3","1/2","2/3","5/6","1/1" };
      int max=Math.max(y,w);
      System.out.println(Die_probability[6-max]);
      sc.close();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class CF0009A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var Die_probability : Sequence(String) ; Die_probability := Sequence{"1/6","1/3","1/2","2/3","5/6","1/1"} ;
    var max : int ; max := Set{y, w}->max() ;
    OclFile["System.out"].println(Die_probability[6 - (max)->char2byte()+1]) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BuyAShovel {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int y,w ;
    int numerator ;
    int denominator=6 ;
    y=scan.nextInt();
    w=scan.nextInt();
    if(w>y){
      numerator=7-w ;
    }
    else {
      numerator=7-y ;
    }
    int divider=numerator ;
    for(int i=divider ; i>=2 ; i--){
      if(numerator % i==0 && denominator % i==0){
        numerator/=i ;
        denominator/=i ;
        break ;
      }
    }
    System.out.print(numerator+"/"+denominator);
  }
}
------------------------------------------------------------
OCL File:
---------
 class BuyAShovel {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var y : int ;
    var w : int ;
    var numerator : int ;
    var denominator : int ; denominator := 6 ;
    y := scan.getCurrent()->toInteger() ; 
    w := scan.getCurrent()->toInteger() ; 
    if (w > y) then (     numerator := 7 - w ) else (     numerator := 7 - y ) ;  
    var divider : int ; divider := numerator ;
        var i : int ; i := divider ; while i >= 2 do ( (     if (numerator mod i = 0 & denominator mod i = 0) then (     numerator := numerator/(i) ; 
     denominator := denominator/(i) ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].print(numerator + "/" + denominator) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int max=0 ;
    int prev=0 ;
    for(int i=0 ; i<m ; i++){
      int x=sc.nextInt();
      max=Math.max((x-prev)/2,max);
      prev=x ;
      if(i==0){
        max=Math.max(max,x-1);
      }
      if(i==m-1){
        max=Math.max(max,n-x);
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var max : int ; max := 0 ;
    var prev : int ; prev := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     max := Set{(x - prev) / 2, max}->max() ; 
    prev := x ; 
    if (i = 0) then (     max := Set{max, x - 1}->max() ) else skip ; 
    if (i = m - 1) then (     max := Set{max, n - x}->max() ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main implements Runnable {
  private static int MOD=1_000_000_007 ;
  public static void main(String[] args){
    Thread thread=new Thread(null,new Main(),"",32*1024*1024);
    thread.start();
  }
  @ Override public void run(){
    final Scanner scanner=new Scanner(System.in);
    solve(scanner);
  }
  static void solve(Scanner scanner){
    System.out.println(Integer.parseInt(scanner.next())+Integer.parseInt(scanner.next())/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
  static   attribute MOD : int := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var thread : OclProcess ; thread := OclProcess.newOclProcess(null, Main.newMain(), "", 32 * 1024 * 1024) ;
     thread.start() );
      operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute solve(scanner) );
  static   operation solve( scanner : OclFile) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((scanner.getCurrent())->toInteger() + (scanner.getCurrent())->toInteger() / 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class CF9a {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt(),b=sc.nextInt();
    int t=Math.max(a,b);
    if(t==1){
      System.out.println("1/1");
    }
    else if(t==2){
      System.out.println("5/6");
    }
    else if(t==3){
      System.out.println("2/3");
    }
    else if(t==4){
      System.out.println("1/2");
    }
    else if(t==5){
      System.out.println("1/3");
    }
    else if(t==6){
      System.out.println("1/6");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF9a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var t : int ; t := Set{a, b}->max() ;
    if (t = 1) then (     OclFile["System.out"].println("1/1") ) else     if (t = 2) then (     OclFile["System.out"].println("5/6") ) else     if (t = 3) then (     OclFile["System.out"].println("2/3") ) else     if (t = 4) then (     OclFile["System.out"].println("1/2") ) else     if (t = 5) then (     OclFile["System.out"].println("1/3") ) else     if (t = 6) then (     OclFile["System.out"].println("1/6") ) else skip ; ;  ;  ;  ;  ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String[] l="11010: :11011:.:11100:,:11101:-:11110:':11111:?:00000:A:00001:B:00010:C:00011:D:00100:E:00101:F:00110:G:00111:H:01000:I:01001:J:01010:K:01011:L:01100:M:01101:N:01110:O:01111:P:10000:Q:10001:R:10010:S:10011:T:10100:U:10101:V:10110:W:10111:X:11000:Y:11001:Z".split(":");
    String[] l2="101:010001:000011:10010001:000000:000001:100101:10011010:0101:0001:110:01001:10011011:010000:0111:10011000:0110:00100:10011001:10011110:00101:111:10011111:1000:00110:00111:10011100:10011101:000010:10010010:10010011:10010000".split(":");
    String[] n2=new String[l2.length];
    String[] n=new String[l.length/2];
    char[] c=new char[l.length/2];
    for(int i=0 ; i<l.length/2 ; i++){
      n[i]=l[i*2];
      n2[i]=l2[i];
      c[i]=l[i*2+1] .charAt(0);
    }
    while(sc.hasNext()){
      String t=sc.nextLine();
      String a="" ;
      for(char cc : t.toCharArray()){
        for(int i=0 ; i<c.length ; i++){
          if(cc==c[i]){
            a+=n[i];
          }
        }
      }
      int start=0 ;
      String r="" ;
      boolean f=true ;
      while(f){
        for(int i=0 ; i<l2.length ; i++){
          if(start+l2[i] .length()>a.length()){
            continue ;
          }
          if(a.substring(start,start+l2[i] .length()).equals(l2[i])){
            r+=c[i];
            start+=l2[i] .length();
            f=false ;
            break ;
          }
        }
        if(f){
          break ;
        }
        else {
          f=true ;
        }
      }
      System.out.println(r);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : Sequence(String) ; l := "11010: :11011:.:11100:,:11101:-:11110:':11111:?:00000:A:00001:B:00010:C:00011:D:00100:E:00101:F:00110:G:00111:H:01000:I:01001:J:01010:K:01011:L:01100:M:01101:N:01110:O:01111:P:10000:Q:10001:R:10010:S:10011:T:10100:U:10101:V:10110:W:10111:X:11000:Y:11001:Z"->split(":") ;
    var l2 : Sequence(String) ; l2 := "101:010001:000011:10010001:000000:000001:100101:10011010:0101:0001:110:01001:10011011:010000:0111:10011000:0110:00100:10011001:10011110:00101:111:10011111:1000:00110:00111:10011100:10011101:000010:10010010:10010011:10010000"->split(":") ;
    var n2 : Sequence(String) ; n2 := Integer.subrange(1,l2->size())->collect(null) ;
    var n : Sequence(String) ; n := Integer.subrange(1,l->size() / 2)->collect(null) ;
    var c : Sequence(String) ; c := Integer.subrange(1,l->size() / 2)->collect(0) ;
        var i : int ; i := 0 ; while i < l->size() / 2 do ( (     n[i+1] := l[i * 2+1] ; 
     n2[i+1] := l2[i+1] ; 
     c[i+1] := l[i * 2 + 1+1]->at(0+1) )  ;     i := i + 1 ) ; 
    while (sc.hasNext()) do (     var t : String ; t := sc.nextLine() ;
     var a : String ; a := "" ;
    for (cc : t->characters()) do ( (         var i : int ; i := 0 ; while i < c->size() do ( (     if (cc = c[i+1]) then (     a := a+(n[i+1]) ) else skip )  ;     i := i + 1 ) )  ) ; 
    var start : int ; start := 0 ;
    var r : String ; r := "" ;
    var f : boolean ; f := true ;
    while (f) do (         var i : int ; i := 0 ; while i < l2->size() do ( (     if (start + l2[i+1]->size() > a->size()) then (     continue ) else skip ; 
     if (a.subrange(start+1,start + l2[i+1]->size()) = l2[i+1]) then (     r := r+(c[i+1]) ; 
     start := start+(l2[i+1]->size()) ; 
     f := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (f) then (     break ) else (     f := true ) ) ; 
    OclFile["System.out"].println(r) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    String p[]={
      "101","000000","000011","10010001","010001","000001","100101","10011010","0101","0001","110","01001","10011011","010000","0111","10011000","0110","00100","10011001","10011110","00101","111","10011111","1000","00110","00111","10011100","10011101","000010","10010010","10010011","10010000" };
      String c=" ',-.?ABCDEFGHIJKLMNOPQRSTUVWXYZ" ;
      String q[]={
        "11010","11110","11100","11101","11011","11111","00000","00001","00010","00011","00100","00101","00110","00111","01000","01001","01010","01011","01100","01101","01110","01111","10000","10001","10010","10011","10100","10101","10110","10111","11000","11001" };
        while(s.hasNext()){
          String k=s.nextLine();
          String a="" ;
          for(int i=0 ; i<k.length(); i++)for(int j=0 ; j<32 ; j++)if(k.charAt(i)==c.charAt(j))a+=q[j];
          String e="" ;
          int at=0 ;
          for(int i=0 ; i<a.length()/5 ; i++){
            for(int j=0 ; j<32 ; j++){
              if(at+p[j] .length()<=a.length()&& a.substring(at,at+p[j] .length()).equals(p[j])){
                e+=c.charAt(j);
                at+=p[j] .length();
              }
            }
          }
          System.out.println(e);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : Sequence(String) ; p := Sequence{"101","000000","000011","10010001","010001","000001","100101","10011010","0101","0001","110","01001","10011011","010000","0111","10011000","0110","00100","10011001","10011110","00101","111","10011111","1000","00110","00111","10011100","10011101","000010","10010010","10010011","10010000"} ;
    var c : String ; c := " ',-.?ABCDEFGHIJKLMNOPQRSTUVWXYZ" ;
    var q : Sequence(String) ; q := Sequence{"11010","11110","11100","11101","11011","11111","00000","00001","00010","00011","00100","00101","00110","00111","01000","01001","01010","01011","01100","01101","01110","01111","10000","10001","10010","10011","10100","10101","10110","10111","11000","11001"} ;
    while (s.hasNext()) do (     var k : String ; k := s.nextLine() ;
     var a : String ; a := "" ;
        var i : int ; i := 0 ; while i < k->size() do (         var j : int ; j := 0 ; while j < 32 do (     if (k->at(i+1) = c->at(j+1)) then     a := a+(q[j+1]) ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var e : String ; e := "" ;
    var at : int ; at := 0 ;
        var i : int ; i := 0 ; while i < a->size() / 5 do ( (         var j : int ; j := 0 ; while j < 32 do ( (     if (at + p[j+1]->size() <= a->size() & a.subrange(at+1,at + p[j+1]->size()) = p[j+1]) then (     e := e+(c->at(j+1)) ; 
     at := at+(p[j+1]->size()) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(e) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    String[] a={
      " ","'",",","-",".","?","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z" };
      String[] b1={
        "101","000000","000011","10010001","010001","000001","100101","10011010","0101","0001","110","01001","10011011","010000","0111","10011000","0110","00100","10011001","10011110","00101","111","10011111","1000","00110","00111","10011100","10011101","000010","10010010","10010011","10010000" };
        String[] b2={
          "11010","11110","11100","11101","11011","11111","00000","00001","00010","00011","00100","00101","00110","00111","01000","01001","01010","01011","01100","01101","01110","01111","10000","10001","10010","10011","10100","10101","10110","10111","11000","11001" };
          Scanner sc=new Scanner(System.in);
          while(sc.hasNextLine()){
            char[] c1=sc.nextLine().toCharArray();
            String str1="" ;
            for(int i=0 ; i<c1.length ; i++){
              for(int j=0 ; j<a.length ; j++){
                if(a[j] .equals(c1[i]+"")){
                  str1+=b2[j];
                  break ;
                }
              }
            }
            String str2="" ;
            String answer="" ;
            for(int i=0 ; i<str1.length(); i++){
              str2+=str1.charAt(i);
              for(int j=0 ; j<b1.length ; j++){
                if(str2.equals(b1[j])){
                  answer+=a[j];
                  str2="" ;
                  break ;
                }
              }
            }
            System.out.println(answer);
          }
        }
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := Sequence{" ","'",",","-",".","?","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"} ;
     var b1 : Sequence(String) ; b1 := Sequence{"101","000000","000011","10010001","010001","000001","100101","10011010","0101","0001","110","01001","10011011","010000","0111","10011000","0110","00100","10011001","10011110","00101","111","10011111","1000","00110","00111","10011100","10011101","000010","10010010","10010011","10010000"} ;
    var b2 : Sequence(String) ; b2 := Sequence{"11010","11110","11100","11101","11011","11111","00000","00001","00010","00011","00100","00101","00110","00111","01000","01001","01010","01011","01100","01101","01110","01111","10000","10001","10010","10011","10100","10101","10110","10111","11000","11001"} ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (sc.hasNextLine()) do (     var c1 : Sequence(String) ; c1 := sc.nextLine()->characters() ;
     var str1 : String ; str1 := "" ;
        var i : int ; i := 0 ; while i < c1->size() do ( (         var j : int ; j := 0 ; while j < a->size() do ( (     if (a[j+1] = c1[i+1] + "") then (     str1 := str1+(b2[j+1]) ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var str2 : String ; str2 := "" ;
    var answer : String ; answer := "" ;
        var i : int ; i := 0 ; while i < str1->size() do ( (     str2 := str2+(str1->at(i+1)) ; 
         var j : int ; j := 0 ; while j < b1->size() do ( (     if (str2 = b1[j+1]) then (     answer := answer+(a[j+1]) ; 
     str2 := "" ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    String p[]={
      "101","000000","000011","10010001","010001","000001","100101","10011010","0101","0001","110","01001","10011011","010000","0111","10011000","0110","00100","10011001","10011110","00101","111","10011111","1000","00110","00111","10011100","10011101","000010","10010010","10010011","10010000" };
      String c=" ',-.?ABCDEFGHIJKLMNOPQRSTUVWXYZ" ;
      String q[]={
        "11010","11110","11100","11101","11011","11111","00000","00001","00010","00011","00100","00101","00110","00111","01000","01001","01010","01011","01100","01101","01110","01111","10000","10001","10010","10011","10100","10101","10110","10111","11000","11001" };
        while(s.hasNext()){
          String k=s.nextLine();
          String a="" ;
          for(int i=0 ; i<k.length(); i++)for(int j=0 ; j<32 ; j++)if(k.charAt(i)==c.charAt(j))a+=q[j];
          String e="" ;
          int at=0 ;
          for(int i=0 ; i<a.length()/5 ; i++){
            for(int j=0 ; j<32 ; j++){
              if(at+p[j] .length()<=a.length()&& a.substring(at,at+p[j] .length()).equals(p[j])){
                e+=c.charAt(j);
                at+=p[j] .length();
              }
            }
          }
          System.out.println(e);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : Sequence(String) ; p := Sequence{"101","000000","000011","10010001","010001","000001","100101","10011010","0101","0001","110","01001","10011011","010000","0111","10011000","0110","00100","10011001","10011110","00101","111","10011111","1000","00110","00111","10011100","10011101","000010","10010010","10010011","10010000"} ;
    var c : String ; c := " ',-.?ABCDEFGHIJKLMNOPQRSTUVWXYZ" ;
    var q : Sequence(String) ; q := Sequence{"11010","11110","11100","11101","11011","11111","00000","00001","00010","00011","00100","00101","00110","00111","01000","01001","01010","01011","01100","01101","01110","01111","10000","10001","10010","10011","10100","10101","10110","10111","11000","11001"} ;
    while (s.hasNext()) do (     var k : String ; k := s.nextLine() ;
     var a : String ; a := "" ;
        var i : int ; i := 0 ; while i < k->size() do (         var j : int ; j := 0 ; while j < 32 do (     if (k->at(i+1) = c->at(j+1)) then     a := a+(q[j+1]) ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var e : String ; e := "" ;
    var at : int ; at := 0 ;
        var i : int ; i := 0 ; while i < a->size() / 5 do ( (         var j : int ; j := 0 ; while j < 32 do ( (     if (at + p[j+1]->size() <= a->size() & a.subrange(at+1,at + p[j+1]->size()) = p[j+1]) then (     e := e+(c->at(j+1)) ; 
     at := at+(p[j+1]->size()) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(e) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;
public class Zadacha_B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    List<Integer>arr1=new ArrayList<Integer>();
    for(int i=0 ; i<3 ; i++){
      arr1.add(i,scan.nextInt());
    }
    Collections.sort(arr1);
    if((arr1.get(0)+arr1.get(1))>arr1.get(2)){
      System.out.println(0);
    }
    else {
      System.out.println((arr1.get(2)+1)-(arr1.get(0)+arr1.get(1)));
    }
  }
  public static void method(List<Integer>arr1,List<Integer>arr2,int raznic){
    for(int i=0 ; i<raznic ; i++){
      for(int j=0 ; j<arr1.size(); j++){
        if(arr1.get(j)==0){
          continue ;
        }
        else {
          arr1.set(j,arr1.get(j)-1);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Zadacha_B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr1 : Sequence(int) ; arr1 := Sequence{} ;
        var i : int ; i := 0 ; while i < 3 do ( (     arr1 := arr1.insertAt(i+1,scan.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    arr1 := arr1->sort() ; 
    if ((arr1->at(0+1) + arr1->at(1+1)) > arr1->at(2+1)) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println((arr1->at(2+1) + 1) - (arr1->at(0+1) + arr1->at(1+1))) ) ;  
 );
  static   operation method( arr1 : Sequence(int), arr2 : Sequence(int), raznic : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < raznic do ( (         var j : int ; j := 0 ; while j < arr1->size() do ( (     if (arr1->at(j+1) = 0) then (     continue ) else (     arr1 := arr1.setAt(j+1,arr1->at(j+1) - 1) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int a[]=new int[3];
    a[0]=sc.nextInt();
    a[1]=sc.nextInt();
    a[2]=sc.nextInt();
    Arrays.sort(a);
    if(a[0]+a[1]>a[2])System.out.println("0");
    else System.out.println(1-(a[0]+a[1]-a[2]));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
    a[0+1] := sc.getCurrent()->toInteger() ; 
    a[1+1] := sc.getCurrent()->toInteger() ; 
    a[2+1] := sc.getCurrent()->toInteger() ; 
    a := a->sort() ; 
    if (a[0+1] + a[1+1] > a[2+1]) then     OclFile["System.out"].println("0") else     OclFile["System.out"].println(1 - (a[0+1] + a[1+1] - a[2+1])) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class tt_1 {
  static Scanner sc ;
  public static void main(String[] args){
    sc=new Scanner(System.in);
    int a=getInt();
    int b=getInt();
    int c=getInt();
    int m1=Math.max(a,Math.max(b,c));
    int m3=Math.min(a,Math.min(b,c));
    int m2=a+b+c-m1-m3 ;
    int time=m1-m2-m3 ;
    if(time>=0){
      time=time+1 ;
    }
    else {
      time=0 ;
    }
    System.out.println(time);
  }
  public static int getInt(){
    return sc.nextInt();
  }
  public static String getString(){
    return sc.next();
  }
  public static String nextLine(){
    return sc.nextLine();
  }
}
------------------------------------------------------------
OCL File:
---------
 class tt_1 {
  static   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var a : int ; a := getInt() ;
    var b : int ; b := getInt() ;
    var c : int ; c := getInt() ;
    var m1 : int ; m1 := Set{a, Set{b, c}->max()}->max() ;
    var m3 : int ; m3 := Set{a, Set{b, c}->min()}->min() ;
    var m2 : int ; m2 := a + b + c - m1 - m3 ;
    var time : int ; time := m1 - m2 - m3 ;
    if (time >= 0) then (     time := time + 1 ) else (     time := 0 ) ;  
    OclFile["System.out"].println(time) ; 
 );
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
  static   operation getString() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     return sc.nextLine() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1064A_Makeatriangle {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    List<Integer>list=new ArrayList<>();
    for(int i=0 ; i<3 ; i++){
      list.add(input.nextInt());
    }
    Collections.sort(list);
    int a=list.get(0)+list.get(1);
    int b=list.get(2);
    if(a>b){
      System.out.println(0);
    }
    else {
      System.out.println(b-a+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1064A_Makeatriangle {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < 3 do ( (     list := list->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var a : int ; a := list->at(0+1) + list->at(1+1) ;
    var b : int ; b := list->at(2+1) ;
    if (a > b) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(b - a + 1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
import java.util.ArrayList ;
import java.util.Collections ;
public class Main {
  public static void main(String args[])throws InterruptedException {
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    System.out.println(x+y/2);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(x + y / 2) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int i ;
    Scanner scan=new Scanner(System.in);
    while(scan.hasNextInt()){
      int n=scan.nextInt();
      int m=scan.nextInt();
      ArrayList<Integer>a=new ArrayList<Integer>();
      ArrayList<Integer>b=new ArrayList<Integer>();
      ArrayList<Integer>c=new ArrayList<Integer>();
      for(i=0 ; i<n ; i++)c.add(i);
      while(m-->0){
        int r=scan.nextInt();
        for(i=0 ; i<n/2 ; i++)b.add(c.remove(0));
        for(; i<n ; i++)a.add(c.remove(0));
        while(! a.isEmpty()|| ! b.isEmpty()){
          int sa=a.size();
          int sb=b.size();
          for(i=0 ; i<sa && i<r ; i++)c.add(a.remove(0));
          for(i=0 ; i<sb && i<r ; i++)c.add(b.remove(0));
        }
      }
      System.out.println(c.get(n-1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNextInt()) do (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var m : int ; m := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
    var b : Sequence(int) ; b := Sequence{} ;
    var c : Sequence(int) ; c := Sequence{} ;
        i := 0 ; while i < n do (     c := c->including(i) ;  ;     i := i + 1 ) ; 
        while (m > 0) do (        m := m - 1 ;     skip ; (     var r : int ; r := scan.getCurrent()->toInteger() ;
         i := 0 ; while i < n / 2 do (     b := b->including(c->at(0+1)) ;  ;     i := i + 1 ) ; 
       while i < n do (     a := a->including(c->at(0+1)) ;  ;     i := i + 1 ) ; 
     while (not(a->isEmpty()) or not(b->isEmpty())) do (     var sa : int ; sa := a->size() ;
     var sb : int ; sb := b->size() ;
         i := 0 ; while i < sa & i < r do (     c := c->including(a->at(0+1)) ;  ;     i := i + 1 ) ; 
         i := 0 ; while i < sb & i < r do (     c := c->including(b->at(0+1)) ;  ;     i := i + 1 ) ) ) ;  ) ;  
    OclFile["System.out"].println(c->at(n - 1+1)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int r=sc.nextInt();
      LinkedList<Integer>l=new LinkedList<Integer>();
      for(int i=0 ; i<n ; i++)l.add(i);
      while(r--!=0){
        int k=sc.nextInt();
        LinkedList<Integer>b=new LinkedList<Integer>();
        LinkedList<Integer>c=new LinkedList<Integer>();
        for(int i=0 ; i<n/2 ; i++)b.add(l.removeFirst());
        while(! l.isEmpty()|| ! b.isEmpty()){
          for(int j=0 ; j<k ; j++){
            if(l.isEmpty())break ;
            c.add(l.removeFirst());
          }
          for(int j=0 ; j<k ; j++){
            if(b.isEmpty())break ;
            c.add(b.removeFirst());
          }
        }
        l=c ;
      }
      System.out.println(l.getLast());
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     l := l->including(i) ;  ;     i := i + 1 ) ; 
        while (r /= 0) do (    skip ; (     var k : int ; k := sc.getCurrent()->toInteger() ;
     var b : Sequence(int) ; b := Sequence{} ;
    var c : Sequence(int) ; c := Sequence{} ;
        var i : int ; i := 0 ; while i < n / 2 do (     b := b->including(l->first()) ;  ;     i := i + 1 ) ; 
    while (not(l->isEmpty()) or not(b->isEmpty())) do (         var j : int ; j := 0 ; while j < k do ( (     if (l->isEmpty()) then     break else skip ; 
     c := c->including(l->first()) )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < k do ( (     if (b->isEmpty()) then     break else skip ; 
     c := c->including(b->first()) )  ;     j := j + 1 ) ) ; 
    l := c ; 
 ) ;  ) ;  
    OclFile["System.out"].println(l->last()) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String line ;
      while((line=br.readLine())!=null){
        int n=Integer.parseInt(line.split(" ")[0]),r=Integer.parseInt(line.split(" ")[1]);
        int[] c=new int[r];
        line=br.readLine();
        String[] l=line.split(" ");
        for(int i=0 ; i<r ; i++){
          c[i]=Integer.parseInt(l[i]);
        }
        ArrayList<Integer>A=new ArrayList<Integer>();
        ArrayList<Integer>B=new ArrayList<Integer>();
        ArrayList<Integer>C=new ArrayList<Integer>();
        int k ;
        for(k=0 ; k<n ; k++){
          C.add(k);
        }
        for(int i=0 ; i<r ; i++){
          for(k=0 ; k<n/2 ; k++){
            B.add(C.get(0));
            C.remove(0);
          }
          for(; k<n ; k++){
            A.add(C.get(0));
            C.remove(0);
          }
          while(A.size()>0 || B.size()>0){
            for(int j=0 ; j<c[i] && A.size()>0 ; j++){
              C.add(A.get(0));
              A.remove(0);
            }
            for(int j=0 ; j<c[i] && B.size()>0 ; j++){
              C.add(B.get(0));
              B.remove(0);
            }
          }
        }
        System.out.println(C.get(C.size()-1));
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     var n : int ; n := (line->split(" ")[0+1])->toInteger() ;
    var r : int ; r := (line->split(" ")[1+1])->toInteger() ;
     var c : Sequence(int) ; c := Integer.subrange(1,r)->collect(0) ;
    line := br.readLine() ; 
    var l : Sequence(String) ; l := line->split(" ") ;
        var i : int ; i := 0 ; while i < r do ( (     c[i+1] := (l[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var A : Sequence(int) ; A := Sequence{} ;
    var B : Sequence(int) ; B := Sequence{} ;
    var C : Sequence(int) ; C := Sequence{} ;
    var k : int ;
        k := 0 ; while k < n do ( (     C := C->including(k) )  ;     k := k + 1 ) ; 
        var i : int ; i := 0 ; while i < r do ( (         k := 0 ; while k < n / 2 do ( (     B := B->including(C->at(0+1)) ; 
     C := C->excludingAt(0+1) )  ;     k := k + 1 ) ; 
       while k < n do ( (     A := A->including(C->at(0+1)) ; 
     C := C->excludingAt(0+1) )  ;     k := k + 1 ) ; 
     while (A->size() > 0 or B->size() > 0) do (         var j : int ; j := 0 ; while j < c[i+1] & A->size() > 0 do ( (     C := C->including(A->at(0+1)) ; 
     A := A->excludingAt(0+1) )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < c[i+1] & B->size() > 0 do ( (     C := C->including(B->at(0+1)) ; 
     B := B->excludingAt(0+1) )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(C->at(C->size() - 1+1)) ; 
 ) ;     line := br.readLine() ;
 ) )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int minRemove(int a[],int b[],int n,int m){
    HashMap<Integer,Integer>countA=new HashMap<Integer,Integer>();
    HashMap<Integer,Integer>countB=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      if(countA.containsKey(a[i]))countA.put(a[i],countA.get(a[i])+1);
      else countA.put(a[i],1);
    }
    for(int i=0 ; i<m ; i++){
      if(countB.containsKey(b[i]))countB.put(b[i],countB.get(b[i])+1);
      else countB.put(b[i],1);
    }
    int res=0 ;
    Set<Integer>s=countA.keySet();
    for(int x : s)if(countB.containsKey(x))res+=Math.min(countB.get(x),countA.get(x));
    return res ;
  }
  public static void main(String[] args){
    int a[]={
      1,2,3,4 };
      int b[]={
        2,3,4,5,8 };
        int n=a.length ;
        int m=b.length ;
        System.out.println(minRemove(a,b,n,m));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minRemove( a : Sequence(int), b : Sequence(int), n : int, m : int) : int
  pre: true
  post: true
  activity: (     var countA : Map(int,int) ; countA := Map{} ;
     var countB : Map(int,int) ; countB := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (countA->keys()->includes(a[i+1])) then     countA := countA->union(Map{a[i+1] |-> countA->at(a[i+1]) + 1}) ; else     countA := countA->union(Map{a[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     if (countB->keys()->includes(b[i+1])) then     countB := countB->union(Map{b[i+1] |-> countB->at(b[i+1]) + 1}) ; else     countB := countB->union(Map{b[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    var s : Set(int) ; s := countA->keys() ;
    for (x : s) do (     if (countB->keys()->includes(x)) then     res := res+(Set{countB->at(x), countA->at(x)}->min()) ; else skip ;  ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,4} ;
     var b : Sequence(int) ; b := Sequence{2,3,4,5,8} ;
    var n : int ; n := a->size() ;
    var m : int ; m := b->size() ;
    OclFile["System.out"].println(minRemove(a, b, n, m)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] arg)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String is ;
    String[] ia ;
    while((is=in.readLine())!=null){
      ia=is.split(" ");
      int n=Integer.parseInt(ia[0]);
      int r=Integer.parseInt(ia[1]);
      LinkedList<Integer>a,b,d ;
      d=new LinkedList<Integer>();
      for(int i=0 ; i<n ; ++i){
        d.addFirst(i);
      }
      ia=in.readLine().split(" ");
      for(int j=0 ; j<r ; ++j){
        int c=Integer.parseInt(ia[j]);
        a=new LinkedList<Integer>();
        int x=d.size();
        for(int i=0 ; i<x/2.0 ; ++i){
          a.addLast(d.removeFirst());
        }
        b=d ;
        d=new LinkedList<Integer>();
        while(a.size()>0 || b.size()>0){
          for(int i=0 ; i<c && a.size()>0 ; ++i){
            d.addFirst(a.removeLast());
          }
          for(int i=0 ; i<c && b.size()>0 ; ++i){
            d.addFirst(b.removeLast());
          }
        }
      }
      System.out.println(d.getFirst());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var is : String ;
     var ia : Sequence(String) ;
         is := in.readLine() ;
    while ((is) /= null) do (    skip ; (     ia := is->split(" ") ; 
     var n : int ; n := (ia[0+1])->toInteger() ;
    var r : int ; r := (ia[1+1])->toInteger() ;
    var a : Sequence(int) ;
    var b : Sequence(int) ;
    var d : Sequence(int) ;
    d := Sequence{} ; 
        var i : int ; i := 0 ; while i < n do ( (     d := d->prepend(i) )  ;     i := i + 1 ) ; 
    ia := in.readLine()->split(" ") ; 
        var j : int ; j := 0 ; while j < r do ( (     var c : int ; c := (ia[j+1])->toInteger() ;
     a := Sequence{} ; 
    var x : int ; x := d->size() ;
        var i : int ; i := 0 ; while i < x / 2.0 do ( (     a := a->append(d->first()) )  ;     i := i + 1 ) ; 
    b := d ; 
    d := Sequence{} ; 
    while (a->size() > 0 or b->size() > 0) do (         var i : int ; i := 0 ; while i < c & a->size() > 0 do ( (     d := d->prepend(a->last()) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < c & b->size() > 0 do ( (     d := d->prepend(b->last()) )  ;     i := i + 1 ) ) ; 
 )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(d->first()) ; 
 ) ;     is := in.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(stdIn.hasNext()){
      int n=stdIn.nextInt();
      int r=stdIn.nextInt();
      Queue<Integer>deckA=new ArrayDeque<Integer>();
      Queue<Integer>deckB=new ArrayDeque<Integer>();
      Queue<Integer>deckC=new ArrayDeque<Integer>();
      for(int i=0 ; i<n ; ++i){
        deckC.add(i);
      }
      while(r--!=0){
        int c=stdIn.nextInt();
        if(n % 2==1){
          for(int i=0 ; i<n/2 ; ++i){
            deckB.add(deckC.poll());
          }
          for(int i=0 ; i<n/2+1 ; ++i){
            deckA.add(deckC.poll());
          }
        }
        else {
          for(int i=0 ; i<n/2 ; ++i){
            deckB.add(deckC.poll());
          }
          for(int i=0 ; i<n/2 ; ++i){
            deckA.add(deckC.poll());
          }
        }
        while(! deckA.isEmpty()){
          for(int i=0 ; i<c ; ++i){
            if(deckA.isEmpty()){
              break ;
            }
            deckC.add(deckA.poll());
          }
          for(int i=0 ; i<c ; ++i){
            if(deckB.isEmpty()){
              break ;
            }
            deckC.add(deckB.poll());
          }
        }
      }
      for(int i=0 ; i<n-1 ; ++i){
        deckC.poll();
      }
      System.out.println(deckC.peek());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (stdIn.hasNext()) do (     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     var r : int ; r := stdIn.getCurrent()->toInteger() ;
    var deckA : Sequence(int) ; deckA := ArrayDeque<int>.newArrayDeque() ;
    var deckB : Sequence(int) ; deckB := ArrayDeque<int>.newArrayDeque() ;
    var deckC : Sequence(int) ; deckC := ArrayDeque<int>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < n do ( (     deckC := deckC->including(i) )  ;     i := i + 1 ) ; 
        while (r /= 0) do (    skip ; (     var c : int ; c := stdIn.getCurrent()->toInteger() ;
     if (n mod 2 = 1) then (         var i : int ; i := 0 ; while i < n / 2 do ( (     deckB := deckB->including(deckC->min()) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n / 2 + 1 do ( (     deckA := deckA->including(deckC->min()) )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < n / 2 do ( (     deckB := deckB->including(deckC->min()) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n / 2 do ( (     deckA := deckA->including(deckC->min()) )  ;     i := i + 1 ) ) ;  
     while (not(deckA->isEmpty())) do (         var i : int ; i := 0 ; while i < c do ( (     if (deckA->isEmpty()) then (     break ) else skip ; 
     deckC := deckC->including(deckA->min()) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < c do ( (     if (deckB->isEmpty()) then (     break ) else skip ; 
     deckC := deckC->including(deckB->min()) )  ;     i := i + 1 ) ) ) ;  ) ;  
        var i : int ; i := 0 ; while i < n - 1 do ( (     deckC := deckC->sort()->tail() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(deckC->min()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    double a=scan.nextInt();
    double t=scan.nextInt();
    double r=scan.nextInt();
    System.out.println(r*t/a);
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : double ; a := scan.getCurrent()->toInteger() ;
    var t : double ; t := scan.getCurrent()->toInteger() ;
    var r : double ; r := scan.getCurrent()->toInteger() ;
    OclFile["System.out"].println(r * t / a) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    double t=sc.nextInt();
    int r=sc.nextInt();
    System.out.println(t/a*r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var t : double ; t := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(t / a * r) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAX=100000 ;
  static long prefix[]=new long[MAX];
  static void sieve_modified(){
    for(int i=2 ; i<MAX ; i+=2){
      for(int j=i ; j<MAX ; j+=i)prefix[j]+=i ;
    }
    for(int i=1 ; i<MAX ; i++)prefix[i]+=prefix[i-1];
  }
  static long sumEvenFactors(int L,int R){
    return(prefix[R]-prefix[L-1]);
  }
  public static void main(String args[]){
    sieve_modified();
    int l=6,r=10 ;
    System.out.print(sumEvenFactors(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 100000;
  static   attribute prefix : long := Integer.subrange(1,MAX)->collect(0);
  static   operation sieve_modified() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i < MAX do ( (         var j : int ; j := i ; while j < MAX do (     prefix[j+1] := prefix[j+1]+(i) ;  ;     j := j+(i) ) )  ;     i := i+(2) ) ; 
         var i : int ; i := 1 ; while i < MAX do (     prefix[i+1] := prefix[i+1]+(prefix[i - 1+1]) ;  ;     i := i + 1 ) );
  static   operation sumEvenFactors( L : int, R : int) : long
  pre: true
  post: true
  activity: (     return (prefix[R+1] - prefix[L - 1+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute sieve_modified() ; 
     var l : int ; l := 6 ;
    var r : int ; r := 10 ;
     OclFile["System.out"].print(sumEvenFactors(l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GfG {
  public static int getSum(int n){
    int sum=0 ;
    while(n!=0){
      sum=sum+n % 10 ;
      n=n/10 ;
    }
    return sum ;
  }
  public static int largestDigitSumdivisior(int n){
    int res=0 ;
    for(int i=1 ; i<=n ; i++)if(n % i==0)res=Math.max(res,getSum(i));
    return res ;
  }
  public static void main(String argc[]){
    int n=14 ;
    System.out.println(largestDigitSumdivisior(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation getSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n /= 0) do (     sum := sum + n mod 10 ; 
     n := n / 10 ) ; 
     return sum );
  static   operation largestDigitSumdivisior( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 1 ; while i <= n do (     if (n mod i = 0) then     res := Set{res, getSum(i)}->max() ; else skip ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 14 ;
     OclFile["System.out"].println(largestDigitSumdivisior(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class DIVaddMOD {
  public static int function(int r,int a){
    return(r/a)+(r % a);
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int l=sc.nextInt();
      int r=sc.nextInt();
      int a=sc.nextInt();
      if(a==1){
        System.out.println(r);
      }
      else {
        if(r % a==0 && l!=r){
          int c=function(r-1,a);
          System.out.println(c);
        }
        else if(l==r){
          int c=function(r,a);
          System.out.println(c);
        }
        else {
          int c=0 ;
          int d=0 ;
          if(l<=r-r % a-1){
            c=function(r-r % a-1,a);
          }
          d=function(r,a);
          if(c>d){
            System.out.println(c);
          }
          else {
            System.out.println(d);
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DIVaddMOD {
  static   operation function( r : int, a : int) : int
  pre: true
  post: true
  activity: (     return (r / a) + (r mod a) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (a = 1) then (     OclFile["System.out"].println(r) ) else (     if (r mod a = 0 & l /= r) then (     var c : int ; c := function(r - 1, a) ;
     OclFile["System.out"].println(c) ) else     if (l = r) then (     var c : int ; c := function(r, a) ;
     OclFile["System.out"].println(c) ) else (     var c : int ; c := 0 ;
     var d : int ; d := 0 ;
    if (l <= r - r mod a - 1) then (     c := function(r - r mod a - 1, a) ) else skip ; 
    d := function(r, a) ; 
    if (c > d) then (     OclFile["System.out"].println(c) ) else (     OclFile["System.out"].println(d) ) ;  
 ) ;  ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] strs=br.readLine().split(" ");
    int train=Integer.parseInt(strs[0]);
    int bus=Integer.parseInt(strs[1]);
    System.out.println(train+bus/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var strs : Sequence(String) ; strs := br.readLine()->split(" ") ;
    var train : int ; train := (strs[0+1])->toInteger() ;
    var bus : int ; bus := (strs[1+1])->toInteger() ;
    OclFile["System.out"].println(train + bus / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isDivisible(String str,int k){
    int n=str.length();
    int c=0 ;
    for(int i=0 ; i<k ; i++)if(str.charAt(n-i-1)=='0')c++;
    return(c==k);
  }
  public static void main(String args[]){
    String str1="10101100" ;
    int k=2 ;
    if(isDivisible(str1,k)==true)System.out.println("Yes");
    else System.out.println("No");
    String str2="111010100" ;
    k=2 ;
    if(isDivisible(str2,k)==true)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isDivisible( str : String, k : int) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var c : int ; c := 0 ;
         var i : int ; i := 0 ; while i < k do (     if (str->at(n - i - 1+1) = '0') then     c := c + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return (c = k) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "10101100" ;
     var k : int ; k := 2 ;
    if (isDivisible(str1, k) = true) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
    var str2 : String ; str2 := "111010100" ;
    k := 2 ; 
    if (isDivisible(str2, k) = true) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Solution {
  static int sumOfElements(int arr[],int n){
    boolean prime[]=new boolean[n+1];
    int i,j ;
    HashMap<Integer,Integer>m=new HashMap<Integer,Integer>();
    for(i=0 ; i<n ; i++){
      if(m.get(arr[i])==null)m.put(arr[i],1);
      else m.put(arr[i],m.get(arr[i])+1);
    }
    int sum=0 ;
    Iterator hmIterator=m.entrySet().iterator();
    while(hmIterator.hasNext()){
      Map.Entry mapElement=(Map.Entry)hmIterator.next();
      if(((int)mapElement.getValue())>=((int)mapElement.getKey())){
        sum+=((int)mapElement.getKey());
      }
    }
    return sum ;
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3,3,2,3,2,3,3 };
      int n=arr.length ;
      System.out.println(sumOfElements(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation sumOfElements( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,n + 1)->collect(false) ;
     var i : int ;
    var j : int ;
    var m : Map(int,int) ; m := Map{} ;
        i := 0 ; while i < n do ( (     if (m->at(arr[i+1]) = null) then     m := m->union(Map{arr[i+1] |-> 1}) ; else     m := m->union(Map{arr[i+1] |-> m->at(arr[i+1]) + 1}) ; )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var hmIterator : OclIterator ; hmIterator := m->asSet()->iterator() ;
    while (hmIterator.hasNext()) do (     var mapElement : Map ; mapElement := hmIterator.next()->oclAsType(Map) ;
     if ((mapElement->values->any()->oclAsType(int)) >= (mapElement->keys()->any()->oclAsType(int))) then (     sum := sum+((mapElement->keys()->any()->oclAsType(int))) ) else skip ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,3,2,3,2,3,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(sumOfElements(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int MOD=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    HashMap<Integer,Integer>map=new HashMap<>();
    ArrayList<Integer>list=new ArrayList<>();
    int prev=0 ;
    int idx=0 ;
    int last=1 ;
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      if(x==prev){
        continue ;
      }
      int count ;
      if(map.containsKey(x)){
        count=(list.get(map.get(x))+last)% MOD ;
      }
      else {
        count=last ;
      }
      map.put(x,idx);
      last=count ;
      idx++;
      prev=x ;
      list.add(count);
    }
    System.out.println(last);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var map : Map(int,int) ; map := Map{} ;
    var list : Sequence(int) ; list := Sequence{} ;
    var prev : int ; prev := 0 ;
    var idx : int ; idx := 0 ;
    var last : int ; last := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x = prev) then (     continue ) else skip ; 
    var count : int ;
    if (map->keys()->includes(x)) then (     count := (list->at(map->at(x)+1) + last) mod MOD ) else (     count := last ) ;  
    map := map->union(Map{x |-> idx}) ; 
    last := count ; 
    idx := idx + 1 ; 
    prev := x ; 
    list := list->including(count) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(last) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.System.in ;
public class Main {
  static int n,m ;
  static long mod=1000000000+7 ;
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    int maxn=200000+5 ;
    ArrayList<Integer>[] rec=new ArrayList[maxn+1];
    for(int i=0 ; i<=maxn ; i++)rec[i]=new ArrayList<>();
    int[] idx=new int[maxn+1];
    int[] c=new int[n];
    for(int i=0 ; i<n ; i++){
      c[i]=sc.nextInt();
      rec[c[i] ] .add(i);
    }
    long[] dp=new long[n];
    dp[0]=1 ;
    idx[c[0] ]++;
    for(int i=1 ; i<n ; i++){
      int cur=c[i];
      if(idx[cur]==0){
        dp[i]=dp[i-1];
      }
      else {
        int former=rec[cur] .get(idx[cur]-1);
        if(former==i-1){
          dp[i]=dp[i-1];
        }
        else {
          if(former==0)dp[i]=(dp[i-1]+1)% mod ;
          else {
            dp[i]=(dp[i-1]+dp[former])% mod ;
          }
        }
      }
      idx[cur]++;
    }
    System.out.println(dp[n-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute mod : long := 1000000000 + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    var maxn : int ; maxn := 200000 + 5 ;
    var rec : Sequence(Sequence(int)) ; rec := Integer.subrange(1,maxn + 1)->collect(null) ;
        var i : int ; i := 0 ; while i <= maxn do (     rec[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
    var idx : Sequence(int) ; idx := Integer.subrange(1,maxn + 1)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := sc.getCurrent()->toInteger() ; 
     rec[c[i+1]+1]->excludes(i) )  ;     i := i + 1 ) ; 
    var dp : Sequence(long) ; dp := Integer.subrange(1,n)->collect(0) ;
    dp[0+1] := 1 ; 
    idx[c[0+1]+1] := idx[c[0+1]+1] + 1 ; 
        var i : int ; i := 1 ; while i < n do ( (     var cur : int ; cur := c[i+1] ;
     if (idx[cur+1] = 0) then (     dp[i+1] := dp[i - 1+1] ) else (     var former : int ; former := rec[cur+1]->at(idx[cur+1] - 1+1) ;
     if (former = i - 1) then (     dp[i+1] := dp[i - 1+1] ) else (     if (former = 0) then     dp[i+1] := (dp[i - 1+1] + 1) mod mod ; else (     dp[i+1] := (dp[i - 1+1] + dp[former+1]) mod mod ) ) ) ;  
     idx[cur+1] := idx[cur+1] + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[n - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayDeque ;
import java.util.Deque ;
import java.util.HashMap ;
import java.util.Map ;
public class Main {
  public void solve(BufferedReader stdin,PrintWriter stdout)throws NumberFormatException,IOException {
    int n=Integer.parseInt(stdin.readLine());
    int[] c=new int[n];
    for(int i=0 ; i<n ; i++){
      c[i]=Integer.parseInt(stdin.readLine());
    }
    Deque<Integer>b=new ArrayDeque<>();
    b.addLast(c[0]);
    for(int i=1 ; i<n ; i++){
      if(b.getLast()!=c[i]){
        b.addLast(c[i]);
      }
    }
    long mod=1000000000+7 ;
    Map<Integer,Long>sm=new HashMap<>();
    long[] dp=new long[b.size()+1];
    dp[0]=1 ;
    for(int i=0 ; i<dp.length-1 ; i++){
      int v=b.removeFirst();
      dp[i+1]+=dp[i]+sm.getOrDefault(v,0L);
      dp[i+1] %=mod ;
      sm.put(v,sm.getOrDefault(v,0L)+dp[i]);
    }
    stdout.println(dp[dp.length-1]);
  }
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter stdout=new PrintWriter(System.out,false);
    new Main().solve(stdin,stdout);
    stdout.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve( stdin : OclFile, stdout : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (stdin.readLine())->toInteger() ;
     var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := (stdin.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := ArrayDeque<OclAny>.newArrayDeque() ;
    b := b->append(c[0+1]) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (b->last() /= c[i+1]) then (     b := b->append(c[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    var mod : long ; mod := 1000000000 + 7 ;
    var sm : Map(int,long) ; sm := Map{} ;
    var dp : Sequence(long) ; dp := Integer.subrange(1,b->size() + 1)->collect(0) ;
    dp[0+1] := 1 ; 
        var i : int ; i := 0 ; while i < dp->size() - 1 do ( (     var v : int ; v := b->first() ;
     dp[i + 1+1] := dp[i + 1+1]+(dp[i+1] + (if sm->keys()->contains(v) then sm->at(v) else 0L endif)) ; 
     dp[i + 1+1] := dp[i + 1+1] mod mod ; 
     sm := sm->union(Map{v |-> (if sm->keys()->contains(v) then sm->at(v) else 0L endif) + dp[i+1]}) )  ;     i := i + 1 ) ; 
    stdout.println(dp[dp->size() - 1+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var stdout : OclFile ; stdout := OclFile.newOclFile_Write(OclFile["System.out"], false) ;
     Main.newMain().solve(stdin, stdout) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] c=new int[n];
    HashMap<Integer,ArrayList<Integer>>map=new HashMap<>();
    int[] place=new int[n];
    for(int i=0 ; i<=200_000 ; i++){
      map.put(i,new ArrayList<Integer>());
    }
    for(int i=0 ; i<n ; i++){
      c[i]=sc.nextInt();
      place[i]=map.get(c[i]).size();
      map.get(c[i]).add(i);
    }
    long MOD=1_000_000_007 ;
    long[] ans=new long[n];
    ans[0]=1 ;
    for(int i=1 ; i<n ; i++){
      ans[i]=ans[i-1];
      if(c[i]!=c[i-1]){
        if(place[i]==1){
          if(map.get(c[i]).get(0)>0){
            ans[i]+=ans[map.get(c[i]).get(0)-1];
          }
          else {
            ans[i]++;
          }
          ans[i] %=MOD ;
        }
        if(place[i]>1){
          ans[i]+=ans[map.get(c[i]).get(place[i]-1)];
          ans[i] %=MOD ;
        }
      }
    }
    System.out.println(ans[n-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    var map : Map(int,Sequence(int)) ; map := Map{} ;
    var place : Sequence(int) ; place := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i <= 200_000 do ( (     map := map->union(Map{i |-> Sequence{}}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := sc.getCurrent()->toInteger() ; 
     place[i+1] := map->at(c[i+1])->size() ; 
     map->at(c[i+1])->excludes(i) )  ;     i := i + 1 ) ; 
    var MOD : long ; MOD := 1_000_000_007 ;
    var ans : Sequence(long) ; ans := Integer.subrange(1,n)->collect(0) ;
    ans[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < n do ( (     ans[i+1] := ans[i - 1+1] ; 
     if (c[i+1] /= c[i - 1+1]) then (     if (place[i+1] = 1) then (     if (map->at(c[i+1])->at(0+1) > 0) then (     ans[i+1] := ans[i+1]+(ans[map->at(c[i+1])->at(0+1) - 1+1]) ) else (     ans[i+1] := ans[i+1] + 1 ) ;  
     ans[i+1] := ans[i+1] mod MOD ) else skip ; 
     if (place[i+1] > 1) then (     ans[i+1] := ans[i+1]+(ans[map->at(c[i+1])->at(place[i+1] - 1+1)+1]) ; 
     ans[i+1] := ans[i+1] mod MOD ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans[n - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int N ;
  int[] C ;
  Map<Integer,List<Integer>>indexes ;
  static final long MOD=1000000007 ;
  long result ;
  long[] memo ;
  long add(long a,long b){
    return(a+b)% MOD ;
  }
  Main(){
    Scanner in=new Scanner(System.in);
    N=Integer.parseInt(in.nextLine());
    C=new int[N];
    int cMax=-1 ;
    for(int i=0 ; i<N ; ++i){
      C[i]=Integer.parseInt(in.nextLine());
      cMax=Math.max(cMax,C[i]);
    }
    in.close();
    this.memo=new long[cMax+1];
    Arrays.fill(this.memo,0);
    this.memo[C[0] ]=1 ;
    for(int i=1 ; i<N ; ++i){
      if(C[i-1]!=C[i]){
        this.memo[C[i] ]=this.add(this.memo[C[i] ],this.memo[C[i-1] ]);
      }
    }
    this.result=this.memo[C[C.length-1] ];
  }
  public static void main(String[] args){
    Main ins=new Main();
    System.out.println(ins.result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute N : int;
   attribute C : Sequence(int);
   attribute indexes : Map(int,Sequence(int));
  static    attribute MOD : long := 1000000007;
   attribute result : long;
   attribute memo : Sequence(long);
   operation add( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a + b) mod MOD );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := (in.nextLine())->toInteger() ; 
    C := Integer.subrange(1,N)->collect(0) ; 
    var cMax : int ; cMax := -1 ;
        var i : int ; i := 0 ; while i < N do ( (     C[i+1] := (in.nextLine())->toInteger() ; 
     cMax := Set{cMax, C[i+1]}->max() )  ;     i := i + 1 ) ; 
    skip ; 
    self.memo := Integer.subrange(1,cMax + 1)->collect(0) ; 
    self.memo := self.memo->collect(0) ; 
    self.memo[C[0+1]+1] := 1 ; 
        var i : int ; i := 1 ; while i < N do ( (     if (C[i - 1+1] /= C[i+1]) then (     self.memo[C[i+1]+1] := self->excludes(self.memo[C[i+1]+1], self.memo[C[i - 1+1]+1]) ) else skip )  ;     i := i + 1 ) ; 
    self.result := self.memo[C[C->size() - 1+1]+1] ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ins : Main ; ins := Main.newMain() ;
     OclFile["System.out"].println(ins.result) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  static long[] factorial ;
  static long[] invfac ;
  static long mod=(long)1e9+7 ;
  static long inverse(long m){
    long res=1 ;
    for(int i=0 ; i<32 ; ++i){
      if((((mod-2)>>i)& 1)==1)res=(res*m)% mod ;
      m=(m*m)% mod ;
    }
    return res ;
  }
  static long C(int i,int j){
    return(((factorial[i]*invfac[i-j])% mod)*invfac[j])% mod ;
  }
  static long func(int N,int j){
    if(N==j)return factorial[N];
    return((C(j-1,N-j-1)*factorial[j])% mod*factorial[N-j-1])% mod ;
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    factorial=new long[N+1];
    factorial[0]=1 ;
    for(int i=1 ; i<=N ; ++i)factorial[i]=(factorial[i-1]*i)% mod ;
    invfac=new long[N+1];
    for(int i=0 ; i<=N ; ++i)invfac[i]=inverse(factorial[i]);
    long ans=(func(N,(N+1)/2)*((N+1)/2))% mod ;
    for(int j=(N+1)/2+1 ; j<N ; ++j){
      ans=(ans+j*((func(N,j)-func(N,j-1)+mod)% mod)% mod)% mod ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute factorial : Sequence(long);
  static   attribute invfac : Sequence(long);
  static   attribute mod : long := 1e9->oclAsType(long) + 7;
  static   operation inverse( m : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : int ; i := 0 ; while i < 32 do ( (     if (((((mod - 2)/(2->pow(i)))->oclAsType(long)) & 1) = 1) then     res := (res * m) mod mod ; else skip ; 
     m := (m * m) mod mod )  ;     i := i + 1 ) ; 
     return res );
  static   operation C( i : int, j : int) : long
  pre: true
  post: true
  activity: (     return (((factorial[i+1] * invfac[i - j+1]) mod mod) * invfac[j+1]) mod mod );
  static   operation func( N : int, j : int) : long
  pre: true
  post: true
  activity: (     if (N = j) then     return factorial[N+1] else skip ; 
     return ((C(j - 1, N - j - 1) * factorial[j+1]) mod mod * factorial[N - j - 1+1]) mod mod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    factorial := Integer.subrange(1,N + 1)->collect(0) ; 
    factorial[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= N do (     factorial[i+1] := (factorial[i - 1+1] * i) mod mod ;  ;     i := i + 1 ) ; 
    invfac := Integer.subrange(1,N + 1)->collect(0) ; 
        var i : int ; i := 0 ; while i <= N do (     invfac[i+1] := inverse(factorial[i+1]) ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := (func(N, (N + 1) / 2) * ((N + 1) / 2)) mod mod ;
        var j : int ; j := (N + 1) / 2 + 1 ; while j < N do ( (     ans := (ans + j * ((func(N, j) - func(N, j - 1) + mod) mod mod) mod mod) mod mod )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static void multiple(int a,int b,int x){
    if(b<0){
      if(a==1 && x==1)System.out.println("1");
      else System.out.println("0");
    }
    int mul=(int)Math.pow(a,b);
    int ans=mul/x ;
    int ans1=x*ans ;
    int ans2=x*(ans+1);
    System.out.println(((mul-ans1)<=(ans2-mul))? ans1 : ans2);
  }
  static public void main(String[] args){
    int a=349,b=1,x=4 ;
    multiple(a,b,x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation multiple( a : int, b : int, x : int) : void
  pre: true
  post: true
  activity: (     if (b < 0) then (     if (a = 1 & x = 1) then     OclFile["System.out"].println("1") ; else     OclFile["System.out"].println("0") ; ) else skip ; 
     var mul : int ; mul := a->pow(b)->oclAsType(int) ;
    var ans : int ; ans := mul / x ;
    var ans1 : int ; ans1 := x * ans ;
    var ans2 : int ; ans2 := x * (ans + 1) ;
    OclFile["System.out"].println(if ((mul - ans1) <= (ans2 - mul)) then ans1 else ans2 endif) ; 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 349 ;
    var b : int ; b := 1 ;
    var x : int ; x := 4 ;
     execute multiple(a, b, x) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int l=sc.nextInt();
      int r=sc.nextInt();
      System.out.println(solve(l,r));
    }
    sc.close();
  }
  static String solve(int l,int r){
    return(l*2<=r)? String.format("%d %d",l,l*2): "-1-1" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(l, r)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( l : int, r : int) : String
  pre: true
  post: true
  activity: (     return if (l * 2 <= r) then StringLib.format("%d %d",Sequence{l,l * 2}) else "-1-1" endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication125 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    int old=-1 ;
    long ans=0 ;
    for(int i=0 ; i<num ; i++){
      int s=sc.nextInt();
      if(s==1){
        if(old>=0){
          ans*=(i-old);
        }
        else {
          ans=1 ;
        }
        old=i ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication125 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
    var old : int ; old := -1 ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < num do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     if (s = 1) then (     if (old >= 0) then (     ans := ans*((i - old)) ) else (     ans := 1 ) ;  
     old := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class A_LCM_Problem {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int T=reader.nextInt();
    while(T!=0){
      T--;
      int l=reader.nextInt();
      int r=reader.nextInt();
      if(r<l){
        int temp=l ;
        l=r ;
        r=temp ;
      }
      if((long)l*2<=r){
        System.out.println(l+" "+(long)l*2);
      }
      else {
        System.out.println(-1+" "+-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_LCM_Problem {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var T : int ; T := reader.nextInt() ;
     while (T /= 0) do (     T := T - 1 ; 
     var l : int ; l := reader.nextInt() ;
    var r : int ; r := reader.nextInt() ;
    if (r < l) then (     var temp : int ; temp := l ;
     l := r ; 
     r := temp ) else skip ; 
    if (l->oclAsType(long) * 2 <= r) then (     OclFile["System.out"].println(l + " " + l->oclAsType(long) * 2) ) else (     OclFile["System.out"].println(-1 + " " + -1) ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test174 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int x=in.nextInt();
      int y=in.nextInt();
      if(y>=x*2){
        System.out.println(x+" "+2*x);
      }
      else {
        System.out.println("-1-1");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test174 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var y : int ; y := in.getCurrent()->toInteger() ;
     if (y >= x * 2) then (     OclFile["System.out"].println(x + " " + 2 * x) ) else (     OclFile["System.out"].println("-1-1") ) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1389 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int l=in.nextInt();
      int r=in.nextInt();
      if(2*l>r){
        System.out.println(-1+" "+-1);
      }
      else {
        System.out.println(l+" "+2*l);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1389 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var l : int ; l := in.getCurrent()->toInteger() ;
     var r : int ; r := in.getCurrent()->toInteger() ;
     if (2 * l > r) then (     OclFile["System.out"].println(-1 + " " + -1) ) else (     OclFile["System.out"].println(l + " " + 2 * l) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int find_leftmost_unsetbit(int n){
    int ind=-1 ;
    int i=1 ;
    while(n>0){
      if((n % 2)!=1){
        ind=i ;
      }
      i++;
      n>>=1 ;
    }
    return ind ;
  }
  static void perform_steps(int n){
    int left=find_leftmost_unsetbit(n);
    if(left==-1){
      System.out.print("No steps required");
      return ;
    }
    int step=1 ;
    while(find_leftmost_unsetbit(n)!=-1){
      if(step % 2==0){
        n+=1 ;
        System.out.println("Step"+step+": Increase by 1");
      }
      else {
        int m=find_leftmost_unsetbit(n);
        int num=(int)(Math.pow(2,m)-1);
        n=n ^ num ;
        System.out.println("Step"+step+": Xor with "+num);
      }
      step+=1 ;
    }
  }
  public static void main(String[] args){
    int n=39 ;
    perform_steps(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find_leftmost_unsetbit( n : int) : int
  pre: true
  post: true
  activity: (     var ind : int ; ind := -1 ;
     var i : int ; i := 1 ;
     while (n > 0) do (     if ((n mod 2) /= 1) then (     ind := i ) else skip ; 
     i := i + 1 ; 
     n := n/(2->pow(1)) ) ; 
     return ind );
  static   operation perform_steps( n : int) : void
  pre: true
  post: true
  activity: (     var left : int ; left := find_leftmost_unsetbit(n) ;
     if (left = -1) then (     OclFile["System.out"].print("No steps required") ; 
     return ) else skip ; 
     var step : int ; step := 1 ;
     while (find_leftmost_unsetbit(n) /= -1) do (     if (step mod 2 = 0) then (     n := n+(1) ; 
     OclFile["System.out"].println("Step" + step + ": Increase by 1") ) else (     var m : int ; m := find_leftmost_unsetbit(n) ;
     var num : int ; num := (2->pow(m) - 1)->oclAsType(int) ;
     n := n xor num ; 
     OclFile["System.out"].println("Step" + step + ": Xor with " + num) ) ;  
     step := step+(1) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 39 ;
     execute perform_steps(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static String findTwoscomplement(StringBuffer str){
    int n=str.length();
    int i ;
    for(i=n-1 ; i>=0 ; i--)if(str.charAt(i)=='1')break ;
    if(i==-1)return "1"+str ;
    for(int k=i-1 ; k>=0 ; k--){
      if(str.charAt(k)=='1')str.replace(k,k+1,"0");
      else str.replace(k,k+1,"1");
    }
    return str.toString();
  }
  public static void main(String[] args){
    StringBuffer str=new StringBuffer("00000101");
    System.out.println(findTwoscomplement(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation findTwoscomplement( str : String) : String
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var i : int ;
        i := n - 1 ; while i >= 0 do (     if (str->at(i+1) = '1') then     break else skip ;  ;     i := i - 1 ) ; 
    if (i = -1) then     return "1" + str else skip ; 
        var k : int ; k := i - 1 ; while k >= 0 do ( (     if (str->at(k+1) = '1') then     str.replace(k, k + 1, "0") ; else     str.replace(k, k + 1, "1") ; )  ;     k := k - 1 ) ; 
    return str+"" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := StringLib.newString("00000101") ;
     OclFile["System.out"].println(findTwoscomplement(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  public static Scanner scn=new Scanner(System.in);
  public static int CountDecreasingPathsCell(int mat[][],int dp[][],int n,int x,int y){
    if(dp[x][y]!=-1)return dp[x][y];
    int delta[][]={
      {
        0,1 },{
          1,0 },{
-1,0 },{
              0,-1 }
            };
            int newx,newy ;
            int ans=1 ;
            for(int i=0 ; i<4 ; i++){
              newx=x+delta[i][0];
              newy=y+delta[i][1];
              if(newx>=0 && newx<n && newy>=0 && newy<n && mat[newx][newy]<mat[x][y]){
                ans+=CountDecreasingPathsCell(mat,dp,n,newx,newy);
              }
            }
            return dp[x][y]=ans ;
          }
          public static int countDecreasingPathsMatrix(int n,int mat[][]){
            int dp[][]=new int[n][n];
            for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)dp[i][j]=-1 ;
            int sum=0 ;
            for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)sum+=CountDecreasingPathsCell(mat,dp,n,i,j);
            return sum ;
          }
          public static void main(String[] args){
            int n=2 ;
            int mat[][]={
              {
                1,2 },{
                  1,3 }
                };
                System.out.println(countDecreasingPathsMatrix(n,mat));
              }
            }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute scn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation CountDecreasingPathsCell( mat : Sequence(Sequence(int)), dp : Sequence(Sequence(int)), n : int, x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (dp[x+1][y+1] /= -1) then     return dp[x+1][y+1] else skip ; 
     var delta : Sequence(Sequence(int)) ; delta := Sequence{Sequence{0,1},Sequence{1,0},Sequence{-1,0},Sequence{0,-1}} ;
    var newx : int ;
    var newy : int ;
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < 4 do ( (     newx := x + delta[i+1][0+1] ; 
     newy := y + delta[i+1][1+1] ; 
     if (newx >= 0 & newx < n & newy >= 0 & newy < n & mat[newx+1][newy+1] < mat[x+1][y+1]) then (     ans := ans+(CountDecreasingPathsCell(mat, dp, n, newx, newy)) ) else skip )  ;     i := i + 1 ) ; 
    return dp[x+1][y+1] 
 );
  static   operation countDecreasingPathsMatrix( n : int, mat : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (     dp[i+1][j+1] := -1 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (     sum := sum+(CountDecreasingPathsCell(mat, dp, n, i, j)) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,2},Sequence{1,3}} ;
     OclFile["System.out"].println(countDecreasingPathsMatrix(n, mat)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int m=sc.nextInt();
      int k=sc.nextInt();
      int[] arr=new int[n];
      int c1=0,c2=0,ans=0 ;
      for(int i=0 ; i<n ; i++){
        int t=sc.nextInt();
        if(t==1){
          if(m==0)ans++;
          else m--;
        }
        else if(t==2){
          if(k!=0){
            k--;
            continue ;
          }
          if(m!=0){
            m--;
            continue ;
          }
          ans++;
        }
      }
      System.out.println(ans);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var c1 : int ; c1 := 0 ;
    var c2 : int ; c2 := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var t : int ; t := sc.getCurrent()->toInteger() ;
     if (t = 1) then (     if (m = 0) then     ans := ans + 1 ; else     m := m - 1 ; ) else     if (t = 2) then (     if (k /= 0) then (     k := k - 1 ; 
     continue ) else skip ; 
     if (m /= 0) then (     m := m - 1 ; 
     continue ) else skip ; 
     ans := ans + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class solution12 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int days=sc.nextInt();
    int bowls=sc.nextInt();
    int plates=sc.nextInt();
    int one=0 ;
    int two=0 ;
    int[] arr=new int[days];
    for(int i=0 ; i<days ; i++){
      arr[i]=sc.nextInt();
      if(arr[i]==1)one++;
      else if(arr[i]==2)two++;
    }
    if(bowls>=one && plates+(bowls-one)>=two){
      System.out.println(0);
    }
    else if(bowls<one){
      int answer=one-bowls ;
      if(plates<two)answer+=two-plates ;
      System.out.println(answer);
    }
    else if(bowls>=one && plates+(bowls-one)<two){
      System.out.println(two-plates-(bowls-one));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution12 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var days : int ; days := sc.getCurrent()->toInteger() ;
    var bowls : int ; bowls := sc.getCurrent()->toInteger() ;
    var plates : int ; plates := sc.getCurrent()->toInteger() ;
    var one : int ; one := 0 ;
    var two : int ; two := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,days)->collect(0) ;
        var i : int ; i := 0 ; while i < days do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr[i+1] = 1) then     one := one + 1 ; else     if (arr[i+1] = 2) then     two := two + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    if (bowls >= one & plates + (bowls - one) >= two) then (     OclFile["System.out"].println(0) ) else     if (bowls < one) then (     var answer : int ; answer := one - bowls ;
     if (plates < two) then     answer := answer+(two - plates) ; else skip ; 
     OclFile["System.out"].println(answer) ) else     if (bowls >= one & plates + (bowls - one) < two) then (     OclFile["System.out"].println(two - plates - (bowls - one)) ) else skip ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner ip=new Scanner(System.in);
    int n=ip.nextInt();
    int m=ip.nextInt();
    int k=ip.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=ip.nextInt();
    }
    int c=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==1){
        if(m>0){
          m--;
        }
        else {
          c++;
        }
      }
      else {
        if(k>0){
          k--;
        }
        else if(m>0){
          m--;
        }
        else {
          c++;
        }
      }
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ip : OclFile ; ip := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := ip.getCurrent()->toInteger() ;
    var m : int ; m := ip.getCurrent()->toInteger() ;
    var k : int ; k := ip.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := ip.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 1) then (     if (m > 0) then (     m := m - 1 ) else (     c := c + 1 ) ) else (     if (k > 0) then (     k := k - 1 ) else     if (m > 0) then (     m := m - 1 ) else (     c := c + 1 ) ;  ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class cp {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t-->0){
      String[] str=br.readLine().split(" ");
      int n=Integer.parseInt(str[0]);
      String[] str1=br.readLine().split(" ");
      int[] arr=new int[n+1];
      for(int i=0 ; i<n ; i++){
        arr[i+1]=Integer.parseInt(str1[i]);
      }
      boolean ans=false ;
      for(int i=1 ; i<=n ; i++){
        ans=false ;
        for(int j=2 ; j<i+2 ; j++){
          if(arr[i] % j!=0){
            ans=true ;
            break ;
          }
        }
        if(! ans)break ;
      }
      if(ans)pw.println("YES");
      else pw.println("NO");
    }
    pw.flush();
  }
  public static ArrayList<Integer>findSquare(int n){
    ArrayList<Integer>ans=new ArrayList<>();
    int i=0 ;
    while(i*i<=2*(n-1)){
      ans.add(i*i);
      i++;
    }
    return ans ;
  }
  public static ArrayList<Long>findAllFactors(long num){
    ArrayList<Long>factors=new ArrayList<Long>();
    for(long i=1 ; i<=num/i ; ++i){
      if(num % i==0){
        factors.add(i);
        factors.add(num/i);
      }
    }
    Collections.sort(factors);
    return factors ;
  }
  public static long gcd(long a,long b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     var n : int ; n := (str[0+1])->toInteger() ;
    var str1 : Sequence(String) ; str1 := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i + 1+1] := (str1[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var ans : boolean ; ans := false ;
        var i : int ; i := 1 ; while i <= n do ( (     ans := false ; 
         var j : int ; j := 2 ; while j < i + 2 do ( (     if (arr[i+1] mod j /= 0) then (     ans := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (not(ans)) then     break else skip )  ;     i := i + 1 ) ; 
    if (ans) then     skip else     skip ; ;  
 ) ;  ) ;  
    skip ; 
 );
  static   operation findSquare( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Sequence{} ;
     var i : int ; i := 0 ;
     while (i * i <= 2 * (n - 1)) do (     ans := ans->including(i * i) ; 
     i := i + 1 ) ; 
     return ans );
  static   operation findAllFactors( num : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var factors : Sequence(long) ; factors := Sequence{} ;
         var i : long ; i := 1 ; while i <= num / i do ( (     if (num mod i = 0) then (     factors := factors->including(i) ; 
     factors := factors->including(num / i) ) else skip )  ;     i := i + 1 ) ; 
     factors := factors->sort() ; 
     return factors );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int a=Integer.parseInt(sc.next());
      String op=sc.next();
      int b=Integer.parseInt(sc.next());
      sc.nextLine();
      if(op.equals("?"))break ;
      if(op.equals("+"))System.out.println(a+b);
      if(op.equals("-"))System.out.println(a-b);
      if(op.equals("*"))System.out.println(a*b);
      if(op.equals("/"))System.out.println(a/b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var a : int ; a := (sc.getCurrent())->toInteger() ;
     var op : String ; op := sc.getCurrent() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    skip ; 
    if (op = "?") then     break else skip ; 
    if (op = "+") then     OclFile["System.out"].println(a + b) ; else skip ; 
    if (op = "-") then     OclFile["System.out"].println(a - (b)->char2byte()) ; else skip ; 
    if (op = "*") then     OclFile["System.out"].println(a * b) ; else skip ; 
    if (op = "/") then     OclFile["System.out"].println(a / b) ; else skip ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Chocolate {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    int n=Integer.parseInt(br.readLine());
    StringTokenizer st=new StringTokenizer(br.readLine());
    int[] arr=new int[n];
    boolean found1=false ;
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(st.nextToken());
      if(arr[i]==1){
        found1=true ;
      }
    }
    if(! found1)pr.println(0);
    else {
      long result=NoWays(arr);
      pr.println(result);
    }
    pr.flush();
  }
  private static long NoWays(int[] arr){
    boolean found=false ;
    int count0=0 ;
    long result=1 ;
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]==1 && found==false){
        found=true ;
      }
      else if(arr[i]==1 && found==true){
        result=result*(count0+1);
        count0=0 ;
      }
      else if(arr[i]==0 && found==true){
        count0++;
      }
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Chocolate {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var found1 : boolean ; found1 := false ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (st.next())->toInteger() ; 
     if (arr[i+1] = 1) then (     found1 := true ) else skip )  ;     i := i + 1 ) ; 
    if (not(found1)) then     skip else (     var result : long ; result := NoWays(arr) ;
     skip ) ;  
    skip ; 
 );
  static   operation NoWays( arr : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var found : boolean ; found := false ;
     var count0 : int ; count0 := 0 ;
    var result : long ; result := 1 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = 1 & found = false) then (     found := true ) else     if (arr[i+1] = 1 & found = true) then (     result := result * (count0 + 1) ; 
     count0 := 0 ) else     if (arr[i+1] = 0 & found = true) then (     count0 := count0 + 1 ) else skip ; ;  )  ;     i := i + 1 ) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication116 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    int num1=sc.nextInt();
    int num2=sc.nextInt();
    int counter1=0 ;
    int counter2=0 ;
    int all=0 ;
    for(int i=0 ; i<num ; i++){
      int h=sc.nextInt();
      if(h==2){
        counter2++;
      }
      else {
        counter1++;
      }
    }
    if(counter2>=num2){
      all+=counter2-num2 ;
    }
    if(counter1>=num1){
      all+=counter1-num1 ;
    }
    else {
      if(all>0){
        all-=num1-counter1 ;
      }
    }
    if(all<0){
      System.out.println(0);
    }
    else {
      System.out.println(all);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication116 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
    var num1 : int ; num1 := sc.getCurrent()->toInteger() ;
    var num2 : int ; num2 := sc.getCurrent()->toInteger() ;
    var counter1 : int ; counter1 := 0 ;
    var counter2 : int ; counter2 := 0 ;
    var all : int ; all := 0 ;
        var i : int ; i := 0 ; while i < num do ( (     var h : int ; h := sc.getCurrent()->toInteger() ;
     if (h = 2) then (     counter2 := counter2 + 1 ) else (     counter1 := counter1 + 1 ) )  ;     i := i + 1 ) ; 
    if (counter2 >= num2) then (     all := all+(counter2 - num2) ) else skip ; 
    if (counter1 >= num1) then (     all := all+(counter1 - num1) ) else (     if (all > 0) then (     all := all-(num1 - counter1) ) else skip ) ;  
    if (all < 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(all) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Stack ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String str=br.readLine();
      if(str.equals(".")){
        break ;
      }
      boolean f=true ;
      Stack<Integer>stack=new Stack<Integer>();
      char[] s=str.toCharArray();
      for(int i=0 ; i<s.length ; i++){
        if(s[i]=='('){
          stack.push(1);
        }
        else if(s[i]=='['){
          stack.push(2);
        }
        else if(s[i]==')'){
          if(stack.size()==0){
            f=false ;
            break ;
          }
          int a=stack.pop();
          if(a!=1){
            f=false ;
            break ;
          }
        }
        else if(s[i]==']'){
          if(stack.size()==0){
            f=false ;
            break ;
          }
          int a=stack.pop();
          if(a!=2){
            f=false ;
            break ;
          }
        }
      }
      if(stack.size()!=0)f=false ;
      if(f){
        System.out.println("yes");
      }
      else {
        System.out.println("no");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var str : String ; str := br.readLine() ;
     if (str = ".") then (     break ) else skip ; 
    var f : boolean ; f := true ;
    var stack : Sequence(int) ; stack := Sequence{} ;
    var s : Sequence(String) ; s := str->characters() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s[i+1] = '(') then (     stack := stack->append(1) ) else     if (s[i+1] = '[') then (     stack := stack->append(2) ) else     if (s[i+1] = ')') then (     if (stack->size() = 0) then (     f := false ; 
     break ) else skip ; 
     var a : int ; a := stack->last() ;
     if (a /= 1) then (     f := false ; 
     break ) else skip ) else     if (s[i+1] = ']') then (     if (stack->size() = 0) then (     f := false ; 
     break ) else skip ; 
     var a : int ; a := stack->last() ;
     if (a /= 2) then (     f := false ; 
     break ) else skip ) else skip ; ;  ;  )  ;     i := i + 1 ) ; 
    if (stack->size() /= 0) then     f := false ; else skip ; 
    if (f) then (     OclFile["System.out"].println("yes") ) else (     OclFile["System.out"].println("no") ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.*;
public class Main {
  public static void main(String args[]){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      while(1>0){
        String line=reader.readLine();
        if(line.equals("."))break ;
        int len=line.length();
        int flag=0 ;
        int[][] data ;
        int[] rank_n ;
        int rank=0 ;
        data=new int[120][120];
        rank_n=new int[120];
        for(int i=0 ; i<len ; i++){
          if(rank<0 || flag==1)continue ;
          String s=line.substring(i,i+1);
          if("(".equals(s)){
            rank_n[rank]++;
            data[rank][rank_n[rank] ]=1 ;
            rank++;
          }
          if("[".equals(s)){
            rank_n[rank]++;
            data[rank][rank_n[rank] ]=2 ;
            rank++;
          }
          if(")".equals(s)){
            rank--;
            if(rank<=-1)flag=1 ;
            else {
              if(data[rank][rank_n[rank] ]==1)rank_n[rank]--;
              else flag=1 ;
            }
          }
          if("] ".equals(s)){
            rank--;
            if(rank<=-1)flag=1 ;
            else {
              if(data[rank][rank_n[rank] ]==2)rank_n[rank]--;
              else flag=1 ;
            }
          }
        }
        if(rank!=0)flag=1 ;
        System.out.printf("%s\n",flag==0 ? "yes" : "no");
      }
    }
    catch(IOException e){
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     while (1 > 0) do (     var line : String ; line := reader.readLine() ;
     if (line = ".") then     break else skip ; 
    var len : int ; len := line->size() ;
    var flag : int ; flag := 0 ;
    var data : Sequence(Sequence(int)) ;
    var rank_n : Sequence(int) ;
    var rank : int ; rank := 0 ;
    data := Integer.subrange(1,120)->collect(Integer.subrange(1,120)->collect(0)) ; 
    rank_n := Integer.subrange(1,120)->collect(0) ; 
        var i : int ; i := 0 ; while i < len do ( (     if (rank < 0 or flag = 1) then     continue else skip ; 
     var s : String ; s := line.subrange(i+1,i + 1) ;
    if ("(" = s) then (     rank_n[rank+1] := rank_n[rank+1] + 1 ; 
     data[rank+1][rank_n[rank+1]+1] := 1 ; 
     rank := rank + 1 ) else skip ; 
    if ("[" = s) then (     rank_n[rank+1] := rank_n[rank+1] + 1 ; 
     data[rank+1][rank_n[rank+1]+1] := 2 ; 
     rank := rank + 1 ) else skip ; 
    if (")" = s) then (     rank := rank - 1 ; 
     if (rank <= -1) then     flag := 1 ; else (     if (data[rank+1][rank_n[rank+1]+1] = 1) then     rank_n[rank+1] := rank_n[rank+1] - 1 ; else     flag := 1 ; ) ) else skip ; 
    if ("] " = s) then (     rank := rank - 1 ; 
     if (rank <= -1) then     flag := 1 ; else (     if (data[rank+1][rank_n[rank+1]+1] = 2) then     rank_n[rank+1] := rank_n[rank+1] - 1 ; else     flag := 1 ; ) ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (rank /= 0) then     flag := 1 ; else skip ; 
    OclFile["System.out"].printf("%s\n", if flag = 0 then "yes" else "no" endif) ; 
 ) )   catch (e : IOException) do (     OclFile["System.out"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static String a ;
  static boolean solve(int p,int q){
    if(p==q)return true ;
    boolean ok=false ;
    if(a.charAt(p)==')')return false ;
    else if(a.charAt(p)==']')return false ;
    else if(a.charAt(p)=='('){
      int c=0 ;
      for(int i=p ; i<q ; i++){
        if(a.charAt(i)=='(')c++;
        if(a.charAt(i)==')')c--;
        if(c==0){
          if(solve(p+1,i)&& solve(i+1,q))ok=true ;
          break ;
        }
      }
    }
    else if(a.charAt(p)=='['){
      int c=0 ;
      for(int i=p ; i<q ; i++){
        if(a.charAt(i)=='[')c++;
        if(a.charAt(i)==']')c--;
        if(c==0){
          if(solve(p+1,i)&& solve(i+1,q))ok=true ;
          break ;
        }
      }
    }
    return ok ;
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    while(true){
      String str=s.nextLine();
      if(str.equals("."))System.exit(0);
      a="" ;
      for(int i=0 ; i<str.length(); i++)
        if(str.charAt(i)=='(' || str.charAt(i)==')' || str.charAt(i)=='[' || str.charAt(i)==']')
          a=a+str.charAt(i);
      System.out.println(solve(0,a.length())? "yes" : "no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a : String;
  static   operation solve( p : int, q : int) : boolean
  pre: true
  post: true
  activity: (     if (p = q) then     return true else skip ; 
     var ok : boolean ; ok := false ;
     if (a->at(p+1) = ')') then     return false else     if (a->at(p+1) = ']') then     return false else     if (a->at(p+1) = '(') then (     var c : int ; c := 0 ;
         var i : int ; i := p ; while i < q do ( (     if (a->at(i+1) = '(') then     c := c + 1 ; else skip ; 
     if (a->at(i+1) = ')') then     c := c - 1 ; else skip ; 
     if (c = 0) then (     if (solve(p + 1, i) & solve(i + 1, q)) then     ok := true ; else skip ; 
     break ) else skip )  ;     i := i + 1 ) ) else     if (a->at(p+1) = '[') then (     var c : int ; c := 0 ;
         var i : int ; i := p ; while i < q do ( (     if (a->at(i+1) = '[') then     c := c + 1 ; else skip ; 
     if (a->at(i+1) = ']') then     c := c - 1 ; else skip ; 
     if (c = 0) then (     if (solve(p + 1, i) & solve(i + 1, q)) then     ok := true ; else skip ; 
     break ) else skip )  ;     i := i + 1 ) ) else skip ; ;  ;  ;  
     return ok );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var str : String ; str := s.nextLine() ;
     if (str = ".") then OclProcess.exit(0) ; else skip ; 
    a := "" ; 
        var i : int ; i := 0 ; while i < str->size() do (     if (str->at(i+1) = '(' or str->at(i+1) = ')' or str->at(i+1) = '[' or str->at(i+1) = ']') then     a := a + str->at(i+1) ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if solve(0, a->size()) then "yes" else "no" endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static char[] s ;
  static int k ;
  static boolean f(char ch){
    while(k<s.length){
      char c=s[k++];
      if((c=='(' || c=='[')&& ! f(c))return false ;
      else if(ch=='(' && c==']')return false ;
      else if(ch=='[' && c==')')return false ;
      else if(ch=='(' && c==')')return true ;
      else if(ch=='[' && c==']')return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      s=sc.nextLine().toCharArray();
      if(s.length==1)break ;
      k=0 ;
      boolean f=true ;
      while(k<s.length){
        char c=s[k++];
        if(c=='(' || c=='[')f &=f(c);
        else if(c==')' || c==']')f=false ;
      }
      System.out.println(f ? "yes" : "no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : Sequence(String);
  static   attribute k : int;
  static   operation f( ch : String) : boolean
  pre: true
  post: true
  activity: (     while (k < s->size()) do (     var c : String ; c := s[k+1] ;
     if ((c = '(' or c = '[') & not(f(c))) then     return false else     if (ch = '(' & c = ']') then     return false else     if (ch = '[' & c = ')') then     return false else     if (ch = '(' & c = ')') then     return true else     if (ch = '[' & c = ']') then     return true else skip ; ;  ;  ;  ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     s := sc.nextLine()->characters() ; 
     if (s->size() = 1) then     break else skip ; 
    k := 0 ; 
    var f : boolean ; f := true ;
    while (k < s->size()) do (     var c : String ; c := s[k+1] ;
     if (c = '(' or c = '[') then     f := MathLib.bitwiseAnd(f, f(c)) ; else     if (c = ')' or c = ']') then     f := false ; else skip ; ) ; 
    OclFile["System.out"].println(if f then "yes" else "no" endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.*;
public class TestClass {
  public static void main(String args[])throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int T=Integer.parseInt(br.readLine());
    for(int i=0 ; i<T ; i++){
      int N=Integer.parseInt(br.readLine());
      String[] strNums=br.readLine().split(" ");
      int[] A=new int[strNums.length];
      for(int j=0 ; j<strNums.length ; j++){
        A[j]=Integer.parseInt(strNums[j]);
      }
      int min=0 ;
      int max=0 ;
      for(int j=0 ; j<A.length ; j++){
        if(A[j]!=j+1){
          min=j+1 ;
          break ;
        }
      }
      for(int j=0 ; j<A.length ; j++){
        if(A[j]==min){
          max=j ;
          break ;
        }
      }
      if(max==0 && min==0){
        for(int j=0 ; j<N ; j++){
          System.out.print(A[j]+" ");
        }
        System.out.println();
        continue ;
      }
      min--;
      while(max>=min){
        int temp=A[min];
        A[min]=A[max];
        A[max]=temp ;
        min++;
        max--;
      }
      for(int j=0 ; j<A.length ; j++){
        System.out.print(A[j]+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TestClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var T : int ; T := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < T do ( (     var N : int ; N := (br.readLine())->toInteger() ;
     var strNums : Sequence(String) ; strNums := br.readLine()->split(" ") ;
    var A : Sequence(int) ; A := Integer.subrange(1,strNums->size())->collect(0) ;
        var j : int ; j := 0 ; while j < strNums->size() do ( (     A[j+1] := (strNums[j+1])->toInteger() )  ;     j := j + 1 ) ; 
    var min : int ; min := 0 ;
    var max : int ; max := 0 ;
        var j : int ; j := 0 ; while j < A->size() do ( (     if (A[j+1] /= j + 1) then (     min := j + 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < A->size() do ( (     if (A[j+1] = min) then (     max := j ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (max = 0 & min = 0) then (         var j : int ; j := 0 ; while j < N do ( (     OclFile["System.out"].print(A[j+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() ; 
     continue ) else skip ; 
    min := min - 1 ; 
    while (max >= min) do (     var temp : int ; temp := A[min+1] ;
     A[min+1] := A[max+1] ; 
    A[max+1] := temp ; 
    min := min + 1 ; 
    max := max - 1 ; 
 ) ; 
        var j : int ; j := 0 ; while j < A->size() do ( (     OclFile["System.out"].print(A[j+1] + " ") )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class codeChef {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      StringBuilder sb=new StringBuilder();
      int i=0,j=n-1 ;
      while(i<n && arr[i]==i+1)i++;
      while(j>=0 && arr[j]!=i+1)j--;
      while(i<j){
        int tmp=arr[i];
        arr[i]=arr[j];
        arr[j]=tmp ;
        i++;
        j--;
      }
      for(int k=0 ; k<n ; k++){
        sb.append(arr[k]+" ");
      }
      System.out.println(sb);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeChef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    var i : int ; i := 0 ;
    var j : int ; j := n - 1 ;
    while (i < n & arr[i+1] = i + 1) do     i := i + 1 ; ; 
    while (j >= 0 & arr[j+1] /= i + 1) do     j := j - 1 ; ; 
    while (i < j) do (     var tmp : int ; tmp := arr[i+1] ;
     arr[i+1] := arr[j+1] ; 
    arr[j+1] := tmp ; 
    i := i + 1 ; 
    j := j - 1 ; 
 ) ; 
        var k : int ; k := 0 ; while k < n do ( (     sb := sb + StringLib.newString(arr[k+1] + " ") )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      StringBuilder sb=new StringBuilder();
      int i=0,j=n-1 ;
      while(i<n && arr[i]==i+1)i++;
      while(j>=0 && arr[j]!=i+1)j--;
      while(i<j){
        int tmp=arr[i];
        arr[i]=arr[j];
        arr[j]=tmp ;
        i++;
        j--;
      }
      for(int k=0 ; k<n ; k++){
        sb.append(arr[k]+" ");
      }
      System.out.println(sb);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    var i : int ; i := 0 ;
    var j : int ; j := n - 1 ;
    while (i < n & arr[i+1] = i + 1) do     i := i + 1 ; ; 
    while (j >= 0 & arr[j+1] /= i + 1) do     j := j - 1 ; ; 
    while (i < j) do (     var tmp : int ; tmp := arr[i+1] ;
     arr[i+1] := arr[j+1] ; 
    arr[j+1] := tmp ; 
    i := i + 1 ; 
    j := j - 1 ; 
 ) ; 
        var k : int ; k := 0 ; while k < n do ( (     sb := sb + StringLib.newString(arr[k+1] + " ") )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int N=100005 ;
  static boolean prime[]=new boolean[N];
  static void SieveOfEratosthenes(){
    for(int i=0 ; i<N ; i++)prime[i]=true ;
    prime[1]=false ;
    for(int p=2 ; p*p<N ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<N ; i+=p)prime[i]=false ;
      }
    }
  }
  static int almostPrimes(int n){
    int ans=0 ;
    for(int i=6 ; i<=n ; i++){
      int c=0 ;
      for(int j=2 ; j*j<=i ; j++){
        if(i % j==0){
          if(j*j==i){
            if(prime[j])c++;
          }
          else {
            if(prime[j])c++;
            if(prime[i/j])c++;
          }
        }
      }
      if(c==2)ans++;
    }
    return ans ;
  }
  public static void main(String[] args){
    SieveOfEratosthenes();
    int n=21 ;
    System.out.println(almostPrimes(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 100005;
  static   attribute prime : boolean := Integer.subrange(1,N)->collect(false);
  static   operation SieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p < N do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i < N do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation almostPrimes( n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 6 ; while i <= n do ( (     var c : int ; c := 0 ;
         var j : int ; j := 2 ; while j * j <= i do ( (     if (i mod j = 0) then (     if (j * j = i) then (     if (prime[j+1]) then     c := c + 1 ; else skip ) else (     if (prime[j+1]) then     c := c + 1 ; else skip ; 
     if (prime[i / j+1]) then     c := c + 1 ; else skip ) ) else skip )  ;     j := j + 1 ) ; 
     if (c = 2) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes() ; 
     var n : int ; n := 21 ;
     OclFile["System.out"].println(almostPrimes(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  static Scanner input=new Scanner(System.in);
  public static void main(String[] args){
    int n=input.nextInt();
    List<Integer>arr=new ArrayList<>();
    for(int i=0 ; i<n ; i++)if(input.nextInt()==1)arr.add(i);
    if(arr.isEmpty())System.out.println(0);
    else {
      long result=1 ;
      for(int i=1 ; i<arr.size(); i++)result*=arr.get(i)-arr.get(i-1);
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute input : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := input.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Sequence{} ;
         var i : int ; i := 0 ; while i < n do (     if (input.getCurrent()->toInteger() = 1) then     arr := arr->including(i) ; else skip ;  ;     i := i + 1 ) ; 
     if (arr->isEmpty()) then     OclFile["System.out"].println(0) ; else (     var result : long ; result := 1 ;
         var i : int ; i := 1 ; while i < arr->size() do (     result := result*(arr->at(i+1) - arr->at(i - 1+1)) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(result) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; ++i){
        a[i]=sc.nextInt();
      }
      System.out.println(solve(a)? "YES" : "NO");
    }
    sc.close();
  }
  static boolean solve(int[] a){
    List<Integer>rest=Arrays.stream(a).boxed().collect(Collectors.toList());
    while(! rest.isEmpty()){
      int index=rest.size()-1 ;
      while(index!=-1 && rest.get(index)%(index+2)==0){
--index ;
      }
      if(index==-1){
        return false ;
      }
      rest.remove(index);
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if solve(a) then "YES" else "NO" endif) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var rest : Sequence(int) ; rest := stream(a).collect(Collectors.toList()) ;
     while (not(rest->isEmpty())) do (     var index : int ; index := rest->size() - 1 ;
     while (index /= -1 & rest->at(index+1) mod (index + 2) = 0) do (     index := index - 1 ) ; 
     if (index = -1) then (     return false ) else skip ; 
     rest := rest->excludingAt(index+1) ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void thirdLargest(int arr[],int arr_size){
    if(arr_size<3){
      System.out.printf(" Invalid Input ");
      return ;
    }
    int first=arr[0],second=Integer.MIN_VALUE,third=Integer.MIN_VALUE ;
    for(int i=1 ; i<arr_size ; i++){
      if(arr[i]>first){
        third=second ;
        second=first ;
        first=arr[i];
      }
      else if(arr[i]>second){
        third=second ;
        second=arr[i];
      }
      else if(arr[i]>third){
        third=arr[i];
      }
    }
    System.out.printf("The third Largest element is %d\n",third);
  }
  public static void main(String[] args){
    int arr[]={
      12,13,1,10,34,16 };
      int n=arr.length ;
      thirdLargest(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation thirdLargest( arr : Sequence(int), arr_size : int) : void
  pre: true
  post: true
  activity: (     if (arr_size < 3) then (     OclFile["System.out"].printf(" Invalid Input ") ; 
     return ) else skip ; 
     var first : int ; first := arr[0+1] ;
    var second : int ; second := -2147483648 ;
    var third : int ; third := -2147483648 ;
         var i : int ; i := 1 ; while i < arr_size do ( (     if (arr[i+1] > first) then (     third := second ; 
     second := first ; 
     first := arr[i+1] ) else     if (arr[i+1] > second) then (     third := second ; 
     second := arr[i+1] ) else     if (arr[i+1] > third) then (     third := arr[i+1] ) else skip ; ;  )  ;     i := i + 1 ) ; 
     OclFile["System.out"].printf("The third Largest element is %d\n", third) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,13,1,10,34,16} ;
     var n : int ; n := arr->size() ;
     execute thirdLargest(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void thirdLargest(int arr[],int arr_size){
    if(arr_size<3){
      System.out.printf(" Invalid Input ");
      return ;
    }
    int first=arr[0];
    for(int i=1 ; i<arr_size ; i++)if(arr[i]>first)first=arr[i];
    int second=Integer.MIN_VALUE ;
    for(int i=0 ; i<arr_size ; i++)if(arr[i]>second && arr[i]<first)second=arr[i];
    int third=Integer.MIN_VALUE ;
    for(int i=0 ; i<arr_size ; i++)if(arr[i]>third && arr[i]<second)third=arr[i];
    System.out.printf("The third Largest "+"element is %d\n",third);
  }
  public static void main(String[] args){
    int arr[]={
      12,13,1,10,34,16 };
      int n=arr.length ;
      thirdLargest(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation thirdLargest( arr : Sequence(int), arr_size : int) : void
  pre: true
  post: true
  activity: (     if (arr_size < 3) then (     OclFile["System.out"].printf(" Invalid Input ") ; 
     return ) else skip ; 
     var first : int ; first := arr[0+1] ;
        var i : int ; i := 1 ; while i < arr_size do (     if (arr[i+1] > first) then     first := arr[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    var second : int ; second := -2147483648 ;
        var i : int ; i := 0 ; while i < arr_size do (     if (arr[i+1] > second & arr[i+1] < first) then     second := arr[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    var third : int ; third := -2147483648 ;
        var i : int ; i := 0 ; while i < arr_size do (     if (arr[i+1] > third & arr[i+1] < second) then     third := arr[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("The third Largest " + "element is %d\n", third) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,13,1,10,34,16} ;
     var n : int ; n := arr->size() ;
     execute thirdLargest(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int d=sc.nextInt();
    int[] numbers=new int[m];
    for(int i=0 ; i<m ; i++){
      numbers[i]=sc.nextInt();
    }
    int[][] dayNums=new int[d][m];
    for(int i=0 ; i<d ; i++){
      for(int j=0 ; j<m ; j++){
        dayNums[i][j]=sc.nextInt();
      }
    }
    for(int i=0 ; i<d ; i++){
      boolean flag=true ;
      while(flag && n>=0){
        flag=false ;
        for(int j=0 ; j<m ; j++){
          int x=dayNums[i][j];
          if(x==-1){
            continue ;
          }
          if(n % numbers[j]!=x){
            flag=true ;
            n-=(n % numbers[j]-x+numbers[j])% numbers[j];
            break ;
          }
        }
      }
    }
    if(n<0){
      System.out.println(-1);
    }
    else {
      System.out.println(n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var numbers : Sequence(int) ; numbers := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     numbers[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dayNums : Sequence(Sequence(int)) ; dayNums := Integer.subrange(1,d)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < d do ( (         var j : int ; j := 0 ; while j < m do ( (     dayNums[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < d do ( (     var flag : boolean ; flag := true ;
     while (flag & n >= 0) do (     flag := false ; 
         var j : int ; j := 0 ; while j < m do ( (     var x : int ; x := dayNums[i+1][j+1] ;
     if (x = -1) then (     continue ) else skip ; 
     if (n mod numbers[j+1] /= x) then (     flag := true ; 
     n := n-((n mod numbers[j+1] - x + numbers[j+1]) mod numbers[j+1]) ; 
     break ) else skip )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
    if (n < 0) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(n) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countAnomalies(int arr[],int n,int k){
    int cnt=0 ;
    int i,sum=0 ;
    for(i=0 ; i<n ; i++)sum+=arr[i];
    for(i=0 ; i<n ; i++)if(Math.abs(arr[i]-(sum-arr[i]))>k)cnt++;
    return cnt ;
  }
  public static void main(String[] args){
    int arr[]={
      1,3,5 };
      int n=arr.length ;
      int k=1 ;
      System.out.print(countAnomalies(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countAnomalies( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var i : int ;
    var sum : int ; sum := 0 ;
        i := 0 ; while i < n do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do (     if (if arr[i+1] - (sum - arr[i+1]) < 0 then -(arr[i+1] - (sum - arr[i+1])) else arr[i+1] - (sum - arr[i+1]) endif > k) then     cnt := cnt + 1 ; else skip ;  ;     i := i + 1 ) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,5} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 1 ;
     OclFile["System.out"].print(countAnomalies(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  static int findBitonicity(int[] arr,int n){
    int bt=0 ;
    for(int i=1 ; i<n ; i++){
      if(arr[i]>arr[i-1])bt++;
      else if(arr[i]<arr[i-1])bt--;
    }
    return bt ;
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3,4,5,6,4,3 };
      int n=arr.length ;
      System.out.print("Bitonicity="+findBitonicity(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findBitonicity( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var bt : int ; bt := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] > arr[i - 1+1]) then     bt := bt + 1 ; else     if (arr[i+1] < arr[i - 1+1]) then     bt := bt - 1 ; else skip ; )  ;     i := i + 1 ) ; 
     return bt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6,4,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print("Bitonicity=" + findBitonicity(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int N=scn.nextInt(),M=scn.nextInt();
    boolean AC[]=new boolean[N];
    int WA[]=new int[N];
    int ac=0 ;
    int wa=0 ;
    for(int i=0 ; i<M ; i++){
      int p=scn.nextInt();
      char[] s=scn.next().toCharArray();
      if(s[0]=='A'){
        AC[p-1]=true ;
      }
      else {
        if(! AC[p-1]){
          WA[p-1]++;
        }
      }
    }
    for(int i=0 ; i<N ; i++){
      if(AC[i]){
        ac++;
        wa+=WA[i];
      }
    }
    System.out.println(ac+" "+wa);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scn.getCurrent()->toInteger() ;
    var M : int ; M := scn.getCurrent()->toInteger() ;
    var AC : Sequence(boolean) ; AC := Integer.subrange(1,N)->collect(false) ;
    var WA : Sequence(int) ; WA := Integer.subrange(1,N)->collect(0) ;
    var ac : int ; ac := 0 ;
    var wa : int ; wa := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     var p : int ; p := scn.getCurrent()->toInteger() ;
     var s : Sequence(String) ; s := scn.getCurrent()->characters() ;
     if (s[0+1] = 'A') then (     AC[p - 1+1] := true ) else (     if (not(AC[p - 1+1])) then (     WA[p - 1+1] := WA[p - 1+1] + 1 ) else skip ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (AC[i+1]) then (     ac := ac + 1 ; 
     wa := wa+(WA[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ac + " " + wa) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main extends PrintWriter {
  Main(){
    super(System.out,true);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    Main o=new Main();
    o.main();
    o.flush();
  }
  void main(){
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] wa=new int[n+1];
    int correct=0,penalty=0 ;
    while(m-->0){
      int p=sc.nextInt();
      String s=sc.next();
      if(wa[p]==-1)continue ;
      if(s.equals("WA"))wa[p]++;
      else {
        correct++;
        penalty+=wa[p];
        wa[p]=-1 ;
      }
    }
    println(correct+" "+penalty);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends OclFile {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"], true) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : Main ; o := Main.newMain() ;
     o.main() ; 
     o.flush() );
   operation main() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var wa : Sequence(int) ; wa := Integer.subrange(1,n + 1)->collect(0) ;
    var correct : int ; correct := 0 ;
    var penalty : int ; penalty := 0 ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     var p : int ; p := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
     if (wa[p+1] = -1) then     continue else skip ; 
     if (s = "WA") then     wa[p+1] := wa[p+1] + 1 ; else (     correct := correct + 1 ; 
     penalty := penalty+(wa[p+1]) ; 
     wa[p+1] := -1 ) ) ;  ) ;  
    execute println(correct + " " + penalty) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.HashMap ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(1,in,out);
    out.close();
  }
  static class Task {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int N=in.nextInt();
      int M=in.nextInt();
      Map<Integer,List<Integer>>subsMap=new HashMap<>();
      while(M-->0){
        int problem=in.nextInt();
        String answer=in.next();
        List<Integer>answers=subsMap.getOrDefault(problem,new ArrayList<>());
        answers.add(answer.equals("WA")? 0 : 1);
        subsMap.put(problem,answers);
      }
      int p=0 ;
      int correct=0 ;
      for(int problem : subsMap.keySet()){
        List<Integer>answers=subsMap.get(problem);
        int i=0 ;
        boolean wasSolved=false ;
        int localP=0 ;
        while(i<answers.size()){
          if(answers.get(i)==0){
            localP++;
          }
          else {
            wasSolved=true ;
            break ;
          }
          i++;
        }
        if(wasSolved){
          correct++;
          p+=localP ;
        }
      }
      out.print(correct+" "+p);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
     var M : int ; M := in.getCurrent()->toInteger() ;
    var subsMap : Map(int,Sequence(int)) ; subsMap := Map{} ;
        while (M > 0) do (        M := M - 1 ;     skip ; (     var problem : int ; problem := in.getCurrent()->toInteger() ;
     var answer : String ; answer := in.getCurrent() ;
    var answers : Sequence(int) ; answers := (if subsMap->keys()->contains(problem) then subsMap->at(problem) else Sequence{} endif) ;
    answers := answers->including(if answer = "WA" then 0 else 1 endif) ; 
    subsMap := subsMap->union(Map{problem |-> answers}) ; 
 ) ;  ) ;  
    var p : int ; p := 0 ;
    var correct : int ; correct := 0 ;
    for (problem : subsMap->keys()) do ( (     var answers : Sequence(int) ; answers := subsMap->at(problem) ;
     var i : int ; i := 0 ;
    var wasSolved : boolean ; wasSolved := false ;
    var localP : int ; localP := 0 ;
    while (i < answers->size()) do (     if (answers->at(i+1) = 0) then (     localP := localP + 1 ) else (     wasSolved := true ; 
     break ) ;  
     i := i + 1 ) ; 
    if (wasSolved) then (     correct := correct + 1 ; 
     p := p+(localP) ) else skip ; 
 )  ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    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 ;
  }
}
class Solution {
  void solve(){
    FastReader sc=new FastReader();
    int N=sc.nextInt();
    int M=sc.nextInt();
    int wa=0,ac=0 ;
    boolean c[]=new boolean[N];
    int q[]=new int[N];
    Arrays.fill(c,true);
    Arrays.fill(q,0);
    for(int i=0 ; i<M ; i++){
      int qno=sc.nextInt()-1 ;
      String st=sc.next();
      if(st.equals("WA")&& c[qno])q[qno]++;
      if(st.equals("AC")&& c[qno]){
        c[qno]=false ;
        wa+=q[qno];
        ac++;
      }
    }
    System.out.println(ac+" "+wa);
  }
}
public class Main {
  public static void main(String[] args){
    Solution ob=new Solution();
    ob.solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
class Solution {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var N : int ; N := sc.nextInt() ;
    var M : int ; M := sc.nextInt() ;
    var wa : int ; wa := 0 ;
    var ac : int ; ac := 0 ;
    var c : Sequence(boolean) ; c := Integer.subrange(1,N)->collect(false) ;
    var q : Sequence(int) ; q := Integer.subrange(1,N)->collect(0) ;
    c := c->collect(true) ; 
    q := q->collect(0) ; 
        var i : int ; i := 0 ; while i < M do ( (     var qno : int ; qno := sc.nextInt() - 1 ;
     var st : String ; st := sc.next() ;
     if (st = "WA" & c[qno+1]) then     q[qno+1] := q[qno+1] + 1 ; else skip ; 
     if (st = "AC" & c[qno+1]) then (     c[qno+1] := false ; 
     wa := wa+(q[qno+1]) ; 
     ac := ac + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ac + " " + wa) ; 
 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ob : Solution ; ob := Solution.newSolution() ;
     ob.solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] ch=sc.next().toCharArray();
    sc.close();
    int n=ch.length ;
    String ans ;
    if(ch[0]==ch[n-1]){
      ans=n % 2==0 ? "First" : "Second" ;
    }
    else {
      ans=n % 2==0 ? "Second" : "First" ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ch : Sequence(String) ; ch := sc.getCurrent()->characters() ;
    skip ; 
    var n : int ; n := ch->size() ;
    var ans : String ;
    if (ch[0+1] = ch[n - 1+1]) then (     ans := if n mod 2 = 0 then "First" else "Second" endif ) else (     ans := if n mod 2 = 0 then "Second" else "First" endif ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    solve(System.in,System.out);
  }
  static void solve(InputStream is,PrintStream os){
    Scanner scan=new Scanner(is);
    int N=scan.nextInt();
    int M=scan.nextInt();
    boolean[] isCorrect=new boolean[N];
    int correct=0 ;
    int wa=0 ;
    int wrong[]=new int[N];
    for(int i=0 ; i<M ; i++){
      int p=scan.nextInt()-1 ;
      String str=scan.next();
      if(isCorrect[p])continue ;
      if(str.equals("AC")){
        isCorrect[p]=true ;
        correct++;
        wa+=wrong[p];
      }
      else {
        wrong[p]++;
      }
    }
    os.println(correct+" "+wa);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation solve( is : OclFile, os : OclFile) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(is) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var M : int ; M := scan.getCurrent()->toInteger() ;
    var isCorrect : Sequence(boolean) ; isCorrect := Integer.subrange(1,N)->collect(false) ;
    var correct : int ; correct := 0 ;
    var wa : int ; wa := 0 ;
    var wrong : Sequence(int) ; wrong := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     var p : int ; p := scan.getCurrent()->toInteger() - 1 ;
     var str : String ; str := scan.getCurrent() ;
     if (isCorrect[p+1]) then     continue else skip ; 
     if (str = "AC") then (     isCorrect[p+1] := true ; 
     correct := correct + 1 ; 
     wa := wa+(wrong[p+1]) ) else (     wrong[p+1] := wrong[p+1] + 1 ) )  ;     i := i + 1 ) ; 
    os.println(correct + " " + wa) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int TOTAL_BITS=32 ;
  static boolean isPossible(int n){
    int cnt=Integer.bitCount(n);
    if(cnt==TOTAL_BITS/2)return true ;
    return false ;
  }
  static public void main(String[] arr){
    int n=524280 ;
    if(isPossible(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute TOTAL_BITS : int := 32;
  static   operation isPossible( n : int) : boolean
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := bitCount(n) ;
     if (cnt = TOTAL_BITS / 2) then     return true else skip ; 
     return false );
  static    operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 524280 ;
     if (isPossible(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.*;
import static java.util.Arrays.sort ;
import javafx.util.Pair ;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int n=input.nextInt();
    for(int i=0 ; i*1234567<=n ; i++){
      for(int j=0 ; j*123456<=n ; j++){
        int remain=(n-((i*1234567)+(123456*j)));
        if(remain>=0 &&(remain)% 1234==0){
          System.out.println("YES");
          return ;
        }
      }
    }
    System.out.println("NO");
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var n : int ; n := input.nextInt() ;
         var i : int ; i := 0 ; while i * 1234567 <= n do ( (         var j : int ; j := 0 ; while j * 123456 <= n do ( (     var remain : int ; remain := (n - ((i * 1234567) + (123456 * j))) ;
     if (remain >= 0 & (remain) mod 1234 = 0) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("NO") );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF357B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    for(int i=0 ; i<=n/1234567 ; i++){
      for(int j=0 ; j<=n/123456 ; j++){
        if(n-i*1234567-j*123456>=0 &&(n-i*1234567-j*123456)% 1234==0){
          System.out.println("YES");
          return ;
        }
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF357B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
         var i : int ; i := 0 ; while i <= n / 1234567 do ( (         var j : int ; j := 0 ; while j <= n / 123456 do ( (     if (n - i * 1234567 - j * 123456 >= 0 & (n - i * 1234567 - j * 123456) mod 1234 = 0) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("NO") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  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);
  }
  static boolean check(int x1,int y1,int x2,int y2,int x3,int y3,int x4,int y4,int x,int y){
    float A=area(x1,y1,x2,y2,x3,y3)+area(x1,y1,x4,y4,x3,y3);
    float A1=area(x,y,x1,y1,x2,y2);
    float A2=area(x,y,x2,y2,x3,y3);
    float A3=area(x,y,x3,y3,x4,y4);
    float A4=area(x,y,x1,y1,x4,y4);
    return(A==A1+A2+A3+A4);
  }
  public static void main(String[] args){
    if(check(0,10,10,0,0,-10,-10,0,10,15))System.out.print("yes");
    else System.out.print("no");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation area( x1 : int, y1 : int, x2 : int, y2 : int, x3 : int, y3 : int) : double
  pre: true
  post: true
  activity: (     return if (x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0 < 0 then -((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0) else (x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0 endif->oclAsType(double) );
  static   operation check( x1 : int, y1 : int, x2 : int, y2 : int, x3 : int, y3 : int, x4 : int, y4 : int, x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     var A : double ; A := area(x1, y1, x2, y2, x3, y3) + area(x1, y1, x4, y4, x3, y3) ;
     var A1 : double ; A1 := area(x, y, x1, y1, x2, y2) ;
    var A2 : double ; A2 := area(x, y, x2, y2, x3, y3) ;
    var A3 : double ; A3 := area(x, y, x3, y3, x4, y4) ;
    var A4 : double ; A4 := area(x, y, x1, y1, x4, y4) ;
    return (A = A1 + A2 + A3 + A4) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (check(0, 10, 10, 0, 0, -10, -10, 0, 10, 15)) then     OclFile["System.out"].print("yes") ; else     OclFile["System.out"].print("no") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void ReplaceElements(int arr[],int n){
    int prod=1 ;
    for(int i=0 ; i<n ; ++i){
      prod*=arr[i];
    }
    for(int i=0 ; i<n ; ++i){
      arr[i]=prod/arr[i];
    }
  }
  public static void main(String[] args){
    int arr[]={
      2,3,3,5,7 };
      int n=arr.length ;
      ReplaceElements(arr,n);
      for(int i=0 ; i<n ; ++i){
        System.out.print(arr[i]+" ");
      }
      System.out.println("");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation ReplaceElements( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var prod : int ; prod := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     prod := prod*(arr[i+1]) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := prod / arr[i+1] )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,3,5,7} ;
     var n : int ; n := arr->size() ;
    execute ReplaceElements(arr, n) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskD solver=new TaskD();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskD {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int cm=in.nextInt();
      int[] s=new int[n];
      int[] e=new int[n];
      int[] c=new int[n];
      for(int i=0 ; i<n ; i++){
        s[i]=in.nextInt();
        e[i]=in.nextInt();
        c[i]=in.nextInt();
      }
      int[] recordingMachines=new int[100001];
      for(int i=0 ; i<100001 ; i++)recordingMachines[i]=0 ;
      for(int i=1 ; i<=cm ; i++){
        int[] onAir=new int[100002];
        for(int j=0 ; j<n ; j++){
          if(c[j]==i){
            onAir[s[j] ]++;
            onAir[e[j]+1]--;
          }
        }
        for(int j=1 ; j<onAir.length ; j++){
          onAir[j]+=onAir[j-1];
        }
        for(int j=0 ; j<recordingMachines.length ; j++){
          if(onAir[j]>=1)recordingMachines[j]++;
        }
      }
      int ans=0 ;
      for(int i=0 ; i<recordingMachines.length ; i++){
        if(recordingMachines[i]>ans)ans=recordingMachines[i];
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskD ; solver := TaskD.newTaskD() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskD {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var cm : int ; cm := in.getCurrent()->toInteger() ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
    var e : Sequence(int) ; e := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := in.getCurrent()->toInteger() ; 
     e[i+1] := in.getCurrent()->toInteger() ; 
     c[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var recordingMachines : Sequence(int) ; recordingMachines := Integer.subrange(1,100001)->collect(0) ;
        var i : int ; i := 0 ; while i < 100001 do (     recordingMachines[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= cm do ( (     var onAir : Sequence(int) ; onAir := Integer.subrange(1,100002)->collect(0) ;
         var j : int ; j := 0 ; while j < n do ( (     if (c[j+1] = i) then (     onAir[s[j+1]+1] := onAir[s[j+1]+1] + 1 ; 
     onAir[e[j+1] + 1+1] := onAir[e[j+1] + 1+1] - 1 ) else skip )  ;     j := j + 1 ) ; 
         var j : int ; j := 1 ; while j < onAir->size() do ( (     onAir[j+1] := onAir[j+1]+(onAir[j - 1+1]) )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < recordingMachines->size() do ( (     if (onAir[j+1] >= 1) then     recordingMachines[j+1] := recordingMachines[j+1] + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < recordingMachines->size() do ( (     if (recordingMachines[i+1] > ans) then     ans := recordingMachines[i+1] ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main implements Runnable {
  public static void main(String[] args){
    new Thread(null,new Main(),"",128*1024*1024).start();
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt(),C=sc.nextInt();
    int[][] u=new int[C][200002];
    for(int i=0 ; i<N ; i++){
      int s=sc.nextInt(),t=sc.nextInt(),c=sc.nextInt()-1 ;
      for(int j=s*2-1 ; j<t*2 ; j++){
        u[c][j]=1 ;
      }
    }
    int max=0 ;
    for(int i=1 ; i<200002 ; i++){
      int sum=0 ;
      for(int j=0 ; j<C ; j++){
        sum+=u[j][i];
      }
      max=Math.max(max,sum);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(null, Main.newMain(), "", 128 * 1024 * 1024).start() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var u : Sequence(Sequence(int)) ; u := Integer.subrange(1,C)->collect(Integer.subrange(1,200002)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() - 1 ;
         var j : int ; j := s * 2 - 1 ; while j < t * 2 do ( (     u[c+1][j+1] := 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i < 200002 do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < C do ( (     sum := sum+(u[j+1][i+1]) )  ;     j := j + 1 ) ; 
     max := Set{max, sum}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String input=br.readLine();
    String[] tmpArray=input.split(" ");
    int n=Integer.parseInt(tmpArray[0]);
    int c=Integer.parseInt(tmpArray[1]);
    Program[] programs=new Program[n];
    for(int i=0 ; i<n ; i++){
      tmpArray=br.readLine().split(" ");
      programs[i]=new Program(Integer.parseInt(tmpArray[0]),Integer.parseInt(tmpArray[1]),Integer.parseInt(tmpArray[2]));
    }
    Arrays.sort(programs);
    Program[] recorder=new Program[c+1];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<c ; j++){
        if(recorder[j]==null){
          recorder[j]=programs[i];
          break ;
        }
        else if(recorder[j] .channel==programs[i] .channel && programs[i] .start>=recorder[j] .end){
          recorder[j]=programs[i];
          break ;
        }
        else if((double)programs[i] .start>=recorder[j] .end+0.5){
          recorder[j]=programs[i];
          break ;
        }
      }
    }
    for(int i=0 ; i<=c ; i++){
      if(recorder[i]==null){
        System.out.println(i);
        break ;
      }
    }
  }
}
class Program implements Comparable<Program>{
  int start ;
  int end ;
  int channel ;
  public Program(int s,int e,int c){
    start=s ;
    end=e ;
    channel=c ;
  }
  public int compareTo(Program p){
    return this.start-p.start ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : String ; input := br.readLine() ;
    var tmpArray : Sequence(String) ; tmpArray := input->split(" ") ;
    var n : int ; n := (tmpArray[0+1])->toInteger() ;
    var c : int ; c := (tmpArray[1+1])->toInteger() ;
    var programs : Sequence(Program) ; programs := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     tmpArray := br.readLine()->split(" ") ; 
     programs[i+1] := Program.newProgram((tmpArray[0+1])->toInteger(), (tmpArray[1+1])->toInteger(), (tmpArray[2+1])->toInteger()) )  ;     i := i + 1 ) ; 
    programs := programs->sort() ; 
    var recorder : Sequence(Program) ; recorder := Integer.subrange(1,c + 1)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < c do ( (     if (recorder[j+1] = null) then (     recorder[j+1] := programs[i+1] ; 
     break ) else     if (recorder[j+1].channel = programs[i+1].channel & programs[i+1].start >= recorder[j+1].end) then (     recorder[j+1] := programs[i+1] ; 
     break ) else     if (programs[i+1].start->oclAsType(double) >= recorder[j+1].end + 0.5) then (     recorder[j+1] := programs[i+1] ; 
     break ) else skip ; ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= c do ( (     if (recorder[i+1] = null) then (     OclFile["System.out"].println(i) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}
class Program implements Comparable<Program> {
   attribute start : int;
   attribute end : int;
   attribute channel : int;
   static operation newProgram( s : int, e : int, c : int) : Program
  pre: true
  post: true
  activity:
  ( var self : Program ;
    self := createProgram();
    self.initialise(s, e,c);
    return self );
  operation initialise( s : int, e : int, c : int) : void
  pre: true  post: true
  activity: (     start := s ; 
     end := e ; 
     channel := c );
   operation compareTo( p : Program) : int
  pre: true
  post: true
  activity: (     return self.start - p.start );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static List<ban>bans ;
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int C=scan.nextInt();
    bans=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      bans.add(new ban(scan.nextInt()*2,scan.nextInt()*2,scan.nextInt()));
    }
    bans.sort(Comparator.comparingInt(x->x.s));
    for(int i=1 ; i<=C ; i++){
      boolean success=func(i);
      if(success){
        System.out.println(i);
        return ;
      }
    }
  }
  private static boolean func(int num){
    List<tv>tvs=new ArrayList<>();
    for(int i=0 ; i<num ; i++){
      tvs.add(new tv(-1,-1));
    }
    for(int i=0 ; i<bans.size(); i++){
      int now=bans.get(i).s ;
      int can=bans.get(i).c ;
      Optional<tv>tmp=tvs.stream().filter(x->x.c==-1 ||(x.c==can && x.t<=now)|| x.t<=now-1).sorted(Comparator.comparingInt(x->-x.t)).findFirst();
      if(tmp.isPresent()){
        tv temp=tmp.get();
        temp.t=bans.get(i).t ;
        temp.c=can ;
      }
      else {
        return false ;
      }
    }
    return true ;
  }
  static class tv {
    int t ;
    int c ;
    public tv(int t,int c){
      this.t=t ;
      this.c=c ;
    }
  }
  static class ban {
    int s ;
    int t ;
    int c ;
    ban(int s,int t,int c){
      this.s=s ;
      this.t=t ;
      this.c=c ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute bans : Sequence(ban);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var C : int ; C := scan.getCurrent()->toInteger() ;
    bans := Sequence{} ; 
        var i : int ; i := 0 ; while i < n do ( (     bans := bans->including(ban.newban(scan.getCurrent()->toInteger() * 2, scan.getCurrent()->toInteger() * 2, scan.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    bans := bans.sort(Comparator.comparingInt(lambda x : OclAny in x.s)) ; 
        var i : int ; i := 1 ; while i <= C do ( (     var success : boolean ; success := func(i) ;
     if (success) then (     OclFile["System.out"].println(i) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation func( num : int) : boolean
  pre: true
  post: true
  activity: (     var tvs : Sequence(tv) ; tvs := Sequence{} ;
         var i : int ; i := 0 ; while i < num do ( (     tvs := tvs->including(tv.newtv(-1, -1)) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < bans->size() do ( (     var now : int ; now := bans->at(i+1).s ;
     var can : int ; can := bans->at(i+1).c ;
     var tmp : Optional<tv> ; tmp := tvs->select( _x1 | (lambda x : OclAny in x.c = -1 or (x.c = can & x.t <= now) or x.t <= now - 1)->apply(_x1) )->sort()->first() ;
     if (tmp.isPresent()) then (     var temp : tv ; temp := tmp.get() ;
     temp.t := bans->at(i+1).t ; 
     temp.c := can ) else (     return false ) )  ;     i := i + 1 ) ; 
     return true );
  static class tv {
   attribute t : int;
   attribute c : int;
   static operation newtv( t : int, c : int) : tv
  pre: true
  post: true
  activity:
  ( var self : tv ;
    self := createtv();
    self.initialise(t, c);
    return self );
  operation initialise( t : int, c : int) : void
  pre: true  post: true
  activity: (     self.t := t ; 
     self.c := c );
}
  static class ban {
   attribute s : int;
   attribute t : int;
   attribute c : int;
   static operation newban( s : int, t : int, c : int) : ban
  pre: true
  post: true
  activity:
  ( var self : ban ;
    self := createban();
    self.initialise(s, t,c);
    return self );
  operation initialise( s : int, t : int, c : int) : void
  pre: true  post: true
  activity: (     self.s := s ; 
     self.t := t ; 
     self.c := c );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  void solve()throws IOException {
    String s=ns();
    int n=s.length();
    if(s.charAt(0)==s.charAt(n-1))n++;
    out.println(n % 2==1 ? "First" : "Second");
  }
  String ns()throws IOException {
    while(! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine()," ");
    }
    return tok.nextToken();
  }
  int ni()throws IOException {
    return Integer.parseInt(ns());
  }
  long nl()throws IOException {
    return Long.parseLong(ns());
  }
  double nd()throws IOException {
    return Double.parseDouble(ns());
  }
  String[] nsa(int n)throws IOException {
    String[] res=new String[n];
    for(int i=0 ; i<n ; i++){
      res[i]=ns();
    }
    return res ;
  }
  int[] nia(int n)throws IOException {
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=ni();
    }
    return res ;
  }
  long[] nla(int n)throws IOException {
    long[] res=new long[n];
    for(int i=0 ; i<n ; i++){
      res[i]=nl();
    }
    return res ;
  }
  public static void main(String[] args)throws IOException {
    in=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(System.out);
    tok=new StringTokenizer("");
    Main main=new Main();
    main.solve();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
   operation solve() : void
  pre: true
  post: true
  activity: (     var s : String ; s := ns() ;
     var n : int ; n := s->size() ;
     if (s->at(0+1) = s->at((n)->char2byte() - 1+1)) then     n := n + 1 ; else skip ; 
     skip );
   operation ns() : String
  pre: true
  post: true
  activity: (     while (not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String_String(in.readLine(), " ") ) ; 
     return tok.next() );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (ns())->toInteger() );
   operation nl() : long
  pre: true
  post: true
  activity: (     return (ns())->toLong() );
   operation nd() : double
  pre: true
  post: true
  activity: (     return (ns())->toReal() );
   operation nsa( n : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var res : Sequence(String) ; res := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := ns() )  ;     i := i + 1 ) ; 
     return res );
   operation nia( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := ni() )  ;     i := i + 1 ) ; 
     return res );
   operation nla( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var res : Sequence(long) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := nl() )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    tok := OclIterator.newOclIterator_String("") ; 
    var main : Main ; main := Main.newMain() ;
    main.solve() ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String[] array=br.readLine().split(" ");
      int N=Integer.parseInt(array[0]);
      int C=Integer.parseInt(array[1]);
      TVData[] dataArray=new TVData[N];
      for(int i=0 ; i<N ; i++){
        dataArray[i]=new TVData(br.readLine());
      }
      final int[] table=new int[2*100_001];
      final boolean[] tmp=new boolean[2*100_001];
      boolean updated=false ;
      for(int channel=1 ; channel<=C ; channel++){
        if(updated){
          for(int i=0 ; i<tmp.length ; i++){
            tmp[i]=false ;
          }
          updated=false ;
        }
        for(TVData data : dataArray){
          if(data.channel==channel){
            for(int i=data.start*2-1 ; i<=data.end*2 ; i++){
              tmp[i]=true ;
            }
            updated=true ;
          }
        }
        for(int i=0 ; i<table.length ; i++){
          if(tmp[i]){
            table[i]++;
          }
        }
      }
      System.out.println(Arrays.stream(table).max().getAsInt());
    }
  }
  public static class TVData {
    private final int channel ;
    private final int start ;
    private final int end ;
    public TVData(String line){
      int[] tmp=Arrays.stream(line.split(" ")).mapToInt(Integer :: parseInt).toArray();
      start=tmp[0];
      end=tmp[1];
      channel=tmp[2];
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var array : Sequence(String) ; array := br.readLine()->split(" ") ;
     var N : int ; N := (array[0+1])->toInteger() ;
    var C : int ; C := (array[1+1])->toInteger() ;
    var dataArray : Sequence(TVData) ; dataArray := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     dataArray[i+1] := TVData.newTVData(br.readLine()) )  ;     i := i + 1 ) ; 
    var table : Sequence(int) ; table := Integer.subrange(1,2 * 100_001)->collect(0) ;
    var tmp : Sequence(boolean) ; tmp := Integer.subrange(1,2 * 100_001)->collect(false) ;
    var updated : boolean ; updated := false ;
        var channel : int ; channel := 1 ; while channel <= C do ( (     if (updated) then (         var i : int ; i := 0 ; while i < tmp->size() do ( (     tmp[i+1] := false )  ;     i := i + 1 ) ; 
     updated := false ) else skip ; 
     for (data : dataArray) do ( (     if (data.channel = channel) then (         var i : int ; i := data.start * 2 - 1 ; while i <= data.end * 2 do ( (     tmp[i+1] := true )  ;     i := i + 1 ) ; 
     updated := true ) else skip )  ) ; 
         var i : int ; i := 0 ; while i < table->size() do ( (     if (tmp[i+1]) then (     table[i+1] := table[i+1] + 1 ) else skip )  ;     i := i + 1 ) )  ;     channel := channel + 1 ) ; 
    OclFile["System.out"].println(stream(table).max().getAsInt()) ; 
 ))  );
  static class TVData {
   attribute channel : int;
   attribute start : int;
   attribute end : int;
   static operation newTVData( line : String) : TVData
  pre: true
  post: true
  activity:
  ( var self : TVData ;
    self := createTVData();
    self.initialise(line);
    return self );
  operation initialise( line : String) : void
  pre: true  post: true
  activity: (     var tmp : Sequence(int) ; tmp := stream(line->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
     start := tmp[0+1] ; 
     end := tmp[1+1] ; 
     channel := tmp[2+1] );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static void printFirstRepeating(int arr[]){
    int min=-1 ;
    HashSet<Integer>set=new HashSet<>();
    for(int i=arr.length-1 ; i>=0 ; i--){
      if(set.contains(arr[i]))min=i ;
      else set.add(arr[i]);
    }
    if(min!=-1)System.out.println("The first repeating element is "+arr[min]);
    else System.out.println("There are no repeating elements");
  }
  public static void main(String[] args)throws java.lang.Exception {
    int arr[]={
      10,5,3,4,3,5,6 };
      printFirstRepeating(arr);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation printFirstRepeating( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var min : int ; min := -1 ;
     var set : Set(int) ; set := Set{} ;
         var i : int ; i := arr->size() - 1 ; while i >= 0 do ( (     if (set->includes(arr[i+1])) then     min := i ; else     set := set->including(arr[i+1]) ; )  ;     i := i - 1 ) ; 
     if (min /= -1) then     OclFile["System.out"].println("The first repeating element is " + arr[min+1]) ; else     OclFile["System.out"].println("There are no repeating elements") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,5,3,4,3,5,6} ;
     execute printFirstRepeating(arr) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double calTime(double arr[],int n){
    double work=0 ;
    for(int i=0 ; i<n ; i++)work+=1/arr[i];
    return 1/work ;
  }
  public static void main(String[] args){
    double arr[]={
      6.0,3.0,4.0 };
      int n=arr.length ;
      System.out.println(calTime(arr,n)+" Hours");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calTime( arr : Sequence(double), n : int) : double
  pre: true
  post: true
  activity: (     var work : double ; work := 0 ;
         var i : int ; i := 0 ; while i < n do (     work := work+(1 / arr[i+1]) ;  ;     i := i + 1 ) ; 
     return 1 / work );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(double) ; arr := Sequence{6.0,3.0,4.0} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(calTime(arr, n) + " Hours") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countSubarrays(int a[],int n){
    int count=0 ;
    int[] pre=new int[n+1];
    Arrays.fill(pre,0);
    for(int i=1 ; i<n+1 ; i++){
      pre[i]=pre[i-1]+a[i-1];
    }
    for(int i=1 ; i<n+1 ; i++){
      for(int j=i ; j<n+1 ; j++){
        int sum1=pre[j]-pre[i-1],count1=j-i+1 ;
        int sum2=pre[n]-sum1,count2=((n-count1)==0)? 1 :(n-count1);
        int includ=sum1/count1 ;
        int exclud=sum2/count2 ;
        if(includ>exclud)count++;
      }
    }
    return count ;
  }
  public static void main(String args[]){
    int arr[]={
      6,3,5 };
      int n=arr.length ;
      System.out.println(countSubarrays(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSubarrays( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var pre : Sequence(int) ; pre := Integer.subrange(1,n + 1)->collect(0) ;
    pre := pre->collect(0) ; 
        var i : int ; i := 1 ; while i < n + 1 do ( (     pre[i+1] := pre[i - 1+1] + a[i - 1+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n + 1 do ( (         var j : int ; j := i ; while j < n + 1 do ( (     var sum1 : int ; sum1 := pre[j+1] - pre[i - 1+1] ;
    var count1 : int ; count1 := j - i + 1 ;
     var sum2 : int ; sum2 := pre[n+1] - sum1 ;
    var count2 : int ; count2 := if ((n - count1) = 0) then 1 else (n - count1) endif ;
    var includ : int ; includ := sum1 / count1 ;
    var exclud : int ; exclud := sum2 / count2 ;
    if (includ > exclud) then     count := count + 1 ; else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,3,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countSubarrays(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B {
  private static long d ;
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    long n=cin.nextLong();
    long m=cin.nextLong();
    d=1 ;
    for(int i=0 ; i<m-1 ; i++){
      d*=10 ;
    }
    long[] a=new long[(int)(n/m)];
    long[] b=new long[(int)(n/m)];
    for(int i=0 ; i<n/m ; i++){
      a[i]=cin.nextLong();
    }
    for(int i=0 ; i<n/m ; i++){
      b[i]=cin.nextLong();
    }
    cin.close();
    long mod=1000000000+7 ;
    long ans=1 ;
    for(int i=0 ; i<n/m ; i++){
      long all=d*10/a[i];
      if(d*10 % a[i]==0){
        all--;
      }
      long now=d*b[i]/a[i];
      if(d*b[i] % a[i]==0){
        now--;
      }
      now+=all-(d*(b[i]+1))/a[i];
      if(d*(b[i]+1)% a[i]==0){
        now+=1 ;
      }
      now+=1 ;
      ans=(ans*now)% mod ;
    }
    System.out.println(ans);
  }
  private static boolean isOK(long value,long head){
    return value/d!=head ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute d : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := cin.getCurrent()->toLong() ;
    var m : long ; m := cin.getCurrent()->toLong() ;
    d := 1 ; 
        var i : int ; i := 0 ; while i < m - 1 do ( (     d := d*(10) )  ;     i := i + 1 ) ; 
    var a : Sequence(long) ; a := Integer.subrange(1,(n / m)->oclAsType(int))->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,(n / m)->oclAsType(int))->collect(0) ;
        var i : int ; i := 0 ; while i < n / m do ( (     a[i+1] := cin.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n / m do ( (     b[i+1] := cin.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    skip ; 
    var mod : long ; mod := 1000000000 + 7 ;
    var ans : long ; ans := 1 ;
        var i : int ; i := 0 ; while i < n / m do ( (     var all : long ; all := d * 10 / a[i+1] ;
     if (d * 10 mod a[i+1] = 0) then (     all := all - 1 ) else skip ; 
    var now : long ; now := d * b[i+1] / a[i+1] ;
    if (d * b[i+1] mod a[i+1] = 0) then (     now := now - 1 ) else skip ; 
    now := now+(all - (d * (b[i+1] + 1)) / a[i+1]) ; 
    if (d * (b[i+1] + 1) mod a[i+1] = 0) then (     now := now+(1) ) else skip ; 
    now := now+(1) ; 
    ans := (ans * now) mod mod ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation isOK( value : long, head : long) : boolean
  pre: true
  post: true
  activity: (     return value / d /= head );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class Main {
  public static int inf=(int)1e9+7 ;
  public static int mod=(int)1e9+7 ;
  public static void main(String[] args)throws IOException,InterruptedException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(reader.readLine());
    String[] s=reader.readLine().split("\\s+");
    int[] a=new int[n];
    int max=Integer.MIN_VALUE ;
    int min=Integer.MAX_VALUE ;
    int maxIdx=-1 ;
    int minIdx=-1 ;
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(s[i]);
    }
    Arrays.sort(a);
    swap(a,0,n-1);
    for(int i=0 ; i<n ; i++){
      System.out.print(a[i]+" ");
    }
    sc.close();
    writer.flush();
    writer.close();
    reader.close();
  }
  public static void swap(int[] a,int i,int j){
    int temp=a[i];
    a[i]=a[j];
    a[j]=temp ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute inf : int := 1e9->oclAsType(int) + 7;
  static   attribute mod : int := 1e9->oclAsType(int) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := (reader.readLine())->toInteger() ;
    var s : Sequence(String) ; s := reader.readLine()->split("\\s+") ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := -2147483648 ;
    var min : int ; min := 2147483647 ;
    var maxIdx : int ; maxIdx := -1 ;
    var minIdx : int ; minIdx := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (s[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    execute swap(a, 0, n - 1) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(a[i+1] + " ") )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation swap( a : Sequence(int), i : int, j : int) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := a[i+1] ;
     a[i+1] := a[j+1] ; 
     a[j+1] := temp );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner a=new Scanner(System.in);
    int n=a.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=a.nextInt();
    Arrays.sort(arr);
    int temp=arr[0];
    arr[0]=arr[n-1];
    arr[n-1]=temp ;
    for(int i : arr)System.out.print(i+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : OclFile ; a := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := a.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := a.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var temp : int ; temp := arr[0+1] ;
    arr[0+1] := arr[n - 1+1] ; 
    arr[n - 1+1] := temp ; 
    for (i : arr) do (     OclFile["System.out"].print(i + " ") ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class CodeForces {
  public static void main(String[] args)throws FileNotFoundException {
    FastScanner fs=new FastScanner();
    int n=fs.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=fs.nextInt();
    }
    Arrays.sort(a);
    int temp=a[0];
    a[0]=a[n-1];
    a[n-1]=temp ;
    for(int i=0 ; i<n ; i++){
      System.out.print(a[i]+" ");
    }
  }
  static void sort(int[] a){
    ArrayList<Integer>l=new ArrayList<>();
    for(int i : a)l.add(i);
    Collections.sort(l);
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var n : int ; n := fs.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := fs.nextInt() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var temp : int ; temp := a[0+1] ;
    a[0+1] := a[n - 1+1] ; 
    a[n - 1+1] := temp ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(a[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l := l->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Mridul4 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    int i=-1 ;
    while(i!=n-1){
      i=i+1 ;
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr);
    int temp=arr[0];
    arr[0]=arr[n-1];
    arr[n-1]=temp ;
    i=-1 ;
    while(i!=n-1){
      i=i+1 ;
      System.out.printf("%d ",arr[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mridul4 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var i : int ; i := -1 ;
    while (i /= n - 1) do (     i := i + 1 ; 
     arr[i+1] := sc.getCurrent()->toInteger() ) ; 
    arr := arr->sort() ; 
    var temp : int ; temp := arr[0+1] ;
    arr[0+1] := arr[n - 1+1] ; 
    arr[n - 1+1] := temp ; 
    i := -1 ; 
    while (i /= n - 1) do (     i := i + 1 ; 
     OclFile["System.out"].printf("%d ", arr[i+1]) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    long ans=0 ;
    String string=input.next();
    int len=string.length();
    if(string.charAt(0)==string.charAt(len-1)){
      if((len-2)% 2==1){
        System.out.println("Second");
      }
      else System.out.println("First");
    }
    else {
      if((len-2)% 2==1){
        System.out.println("First");
      }
      else System.out.println("Second");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ans : long ; ans := 0 ;
    var string : String ; string := input.getCurrent() ;
    var len : int ; len := string->size() ;
    if (string->at(0+1) = string->at((len)->char2byte() - 1+1)) then (     if (((len)->char2byte() - 2) mod 2 = 1) then (     OclFile["System.out"].println("Second") ) else     OclFile["System.out"].println("First") ; ) else (     if (((len)->char2byte() - 2) mod 2 = 1) then (     OclFile["System.out"].println("First") ) else     OclFile["System.out"].println("Second") ; ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class lics {
  static int LongIncrConseqSubseq(int arr[],int n){
    HashMap<Integer,Integer>map=new HashMap<>();
    map.put(arr[0],1);
    for(int i=1 ; i<n ; i++){
      if(map.containsKey(arr[i]-1)){
        map.put(arr[i],map.get(arr[i]-1)+1);
        map.remove(arr[i]-1);
      }
      else {
        map.put(arr[i],1);
      }
    }
    return Collections.max(map.values());
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    System.out.println(LongIncrConseqSubseq(arr,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class lics {
  static   operation LongIncrConseqSubseq( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var map : Map(int,int) ; map := Map{} ;
     map := map->union(Map{arr[0+1] |-> 1}) ; 
         var i : int ; i := 1 ; while i < n do ( (     if (map->keys()->includes(arr[i+1] - 1)) then (     map := map->union(Map{arr[i+1] |-> map->at(arr[i+1] - 1) + 1}) ; 
     map := map->antirestrict(Set{arr[i+1] - 1}) ) else (     map := map->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
     return  map->values()->max() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(LongIncrConseqSubseq(arr, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPalindrome(String s,int i,int j){
    while(i<j){
      if(s.charAt(i)!=s.charAt(j))return false ;
      i++;
      j--;
    }
    return true ;
  }
  static int getIndex(String s1,String s2,int len){
    int i=0,j=len-1 ;
    while(i<j){
      if(s1.charAt(i)!=s2.charAt(j)){
        break ;
      }
      i++;
      j--;
    }
    if(i==j){
      return i-1 ;
    }
    else if(isPalindrome(s2,i,j))return i-1 ;
    else if(isPalindrome(s1,i,j))return j ;
    return-1 ;
  }
  public static void main(String args[]){
    String s1="abcdf",s2="sfgba" ;
    int len=s1.length();
    System.out.println(getIndex(s1,s2,len));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPalindrome( s : String, i : int, j : int) : boolean
  pre: true
  post: true
  activity: (     while (i < j) do (     if (s->at(i+1) /= s->at(j+1)) then     return false else skip ; 
     i := i + 1 ; 
     j := j - 1 ) ; 
     return true );
  static   operation getIndex( s1 : String, s2 : String, len : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var j : int ; j := len - 1 ;
     while (i < j) do (     if (s1->at(i+1) /= s2->at(j+1)) then (     break ) else skip ; 
     i := i + 1 ; 
     j := j - 1 ) ; 
     if (i = j) then (     return i - 1 ) else     if (isPalindrome(s2, i, j)) then     return i - 1 else     if (isPalindrome(s1, i, j)) then     return j else skip ; ;  ;  
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "abcdf" ;
    var s2 : String ; s2 := "sfgba" ;
     var len : int ; len := s1->size() ;
     OclFile["System.out"].println(getIndex(s1, s2, len)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p069 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p069().run());
  }
  private static final int LIMIT=Library.pow(10,6);
  public String run(){
    int maxNumer=0 ;
    int maxDenom=1 ;
    int[] totients=Library.listTotients(LIMIT);
    for(int n=1 ; n<totients.length ; n++){
      if((long)n*maxDenom>(long)maxNumer*totients[n]){
        maxNumer=n ;
        maxDenom=totients[n];
      }
    }
    return Integer.toString(maxNumer);
  }
}
------------------------------------------------------------
OCL File:
---------
class p069 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p069.newp069().run()) );
  static    attribute LIMIT : int := Library.pow(10, 6);
   operation run() : String
  pre: true
  post: true
  activity: (     var maxNumer : int ; maxNumer := 0 ;
     var maxDenom : int ; maxDenom := 1 ;
    var totients : Sequence(int) ; totients := Library.listTotients(LIMIT) ;
        var n : int ; n := 1 ; while n < totients->size() do ( (     if (n->oclAsType(long) * maxDenom > maxNumer->oclAsType(long) * totients[n+1]) then (     maxNumer := n ; 
     maxDenom := totients[n+1] ) else skip )  ;     n := n + 1 ) ; 
    return ((maxNumer) + "") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int h=sc.nextInt();
      int w=sc.nextInt();
      if((h | w)==0)break ;
      String[] field=new String[h];
      for(int i=0 ; i<h ; i++){
        field[i]=sc.next();
      }
      String result="" ;
      Set<String>set=new HashSet<String>(0);
      for(int i=0 ; i<h ; i++)for(int j=0 ; j<w ; j++){
        int[] dx={
          1,1,0,-1,-1,-1,0,1 };
          int[] dy={
            0,1,1,1,0,-1,-1,-1 };
            int px=j ;
            int py=i ;
            for(int k=0 ; k<8 ; k++){
              StringBuilder s=new StringBuilder("");
              do {
                s.append(field[py] .charAt(px));
                px=(px+dx[k]+w)% w ;
                py=(py+dy[k]+h)% h ;
                if(s.length()>=Math.max(2,result.length())&& ! set.add(s.toString())&&(result.length()<s.length()||(result.length()==s.length()&& result.compareTo(s.toString())>0))){
                  result=s.toString();
                }
              }
              while(!(px==j && py==i));
            }
          }
          if(result.length()<2)System.out.println(0);
          else System.out.println(result);
        }
        sc.close();
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var h : int ; h := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(h,w)) = 0) then     break else skip ; 
    var field : Sequence(String) ; field := Integer.subrange(1,h)->collect(null) ;
        var i : int ; i := 0 ; while i < h do ( (     field[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    var result : String ; result := "" ;
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := 0 ; while i < h do (         var j : int ; j := 0 ; while j < w do ( (     var dx : Sequence(int) ; dx := Sequence{1,1,0,-1,-1,-1,0,1} ;
     var dy : Sequence(int) ; dy := Sequence{0,1,1,1,0,-1,-1,-1} ;
    var px : int ; px := j ;
    var py : int ; py := i ;
        var k : int ; k := 0 ; while k < 8 do ( (     var s : String ; s := StringLib.newString("") ;
   while true do ((     s := s + StringLib.newString(field[py+1]->at(px+1)) ; 
     px := (px + dx[k+1] + w) mod w ; 
     py := (py + dy[k+1] + h) mod h ; 
     if (s->size() >= Set{2, result->size()}->max() & not(set->excludes(s+"")) & (result->size() < s->size() or (result->size() = s->size() & result->compareTo(s+"") > 0))) then (     result := s+"" ) else skip ) ;
    if (not((px = j & py = i))) then skip else break) )  ;     k := k + 1 ) ; 
 )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    if (result->size() < 2) then     OclFile["System.out"].println(0) else     OclFile["System.out"].println(result) ; ;  
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static float rainDayProbability(int a[],int n){
    float count=0,m ;
    for(int i=0 ; i<n ; i++){
      if(a[i]==1)count++;
    }
    m=count/n ;
    return m ;
  }
  public static void main(String args[]){
    int a[]={
      1,0,1,0,1,1,1,1 };
      int n=a.length ;
      System.out.print(rainDayProbability(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation rainDayProbability( a : Sequence(int), n : int) : double
  pre: true
  post: true
  activity: (     var count : double ; count := 0 ;
    var m : double ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = 1) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     m := count / n ; 
     return m );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,0,1,0,1,1,1,1} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(rainDayProbability(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int validPosition(int arr[],int N,int K){
    int count=0,sum=0 ;
    for(int i=0 ; i<N ; i++){
      sum+=arr[i];
    }
    for(int i=0 ; i<N ; i++){
      if((arr[i]+K)>(sum-arr[i]))count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      2,1,6,7 },K=4 ;
      int N=arr.length ;
      System.out.println(validPosition(arr,N,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation validPosition( arr : Sequence(int), N : int, K : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
    var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < N do ( (     if ((arr[i+1] + K) > (sum - arr[i+1])) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,1,6,7} ;
    var K : int ; K := 4 ;
     var N : int ; N := arr->size() ;
     OclFile["System.out"].println(validPosition(arr, N, K)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void maximumSuffix(String s,int n,int k){
    int i=s.length()-1 ;
    int arr[]=new int[26];
    String suffix="" ;
    while(i>-1){
      int index=s.charAt(i)-'a' ;
      if(arr[index]<n){
        arr[index]++;
        suffix+=s.charAt(i);
        i--;
        continue ;
      }
      if(k==0)break ;
      k--;
      i--;
    }
    suffix=reverse(suffix);
    System.out.print(suffix);
  }
  static String reverse(String input){
    char[] a=input.toCharArray();
    int l,r=a.length-1 ;
    for(l=0 ; l<r ; l++,r--){
      char temp=a[l];
      a[l]=a[r];
      a[r]=temp ;
    }
    return String.valueOf(a);
  }
  public static void main(String[] args){
    String str="iahagafedcba" ;
    int n=1,k=2 ;
    maximumSuffix(str,n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maximumSuffix( s : String, n : int, k : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := s->size() - 1 ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,26)->collect(0) ;
    var suffix : String ; suffix := "" ;
    while (i > -1) do (     var index : int ; index := s->at(i+1) - ('a')->char2byte() ;
     if (arr[index+1] < n) then (     arr[index+1] := arr[index+1] + 1 ; 
     suffix := suffix+(s->at(i+1)) ; 
     i := i - 1 ; 
     continue ) else skip ; 
    if (k = 0) then     break else skip ; 
    k := k - 1 ; 
    i := i - 1 ; 
 ) ; 
    suffix := reverse(suffix) ; 
    OclFile["System.out"].print(suffix) ; 
 );
  static   operation reverse( input : String) : String
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := input->characters() ;
     var l : int ;
    var r : int ; r := a->size() - 1 ;
         l := 0 ; while l < r do ( (     var temp : String ; temp := a[l+1] ;
     a[l+1] := a[r+1] ; 
     a[r+1] := temp )  ;     l := l + 1 ;     r := r - 1 ) ; 
     return (a)->sum()  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "iahagafedcba" ;
     var n : int ; n := 1 ;
    var k : int ; k := 2 ;
     execute maximumSuffix(str, n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='R' || s.charAt(i)=='L'){
        if(i % 2==1 && s.charAt(i)!='L'){
          System.out.println("No");
          return ;
        }
        else if(i % 2==0 && s.charAt(i)!='R'){
          System.out.println("No");
          return ;
        }
      }
      sc.close();
    }
    System.out.println("Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'R' or s->at(i+1) = 'L') then (     if (i mod 2 = 1 & s->at(i+1) /= 'L') then (     OclFile["System.out"].println("No") ; 
     return ) else     if (i mod 2 = 0 & s->at(i+1) /= 'R') then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; ) else skip ; 
     skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Yes") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    InputStreamReader isr ;
    BufferedReader br ;
    try {
      br=createBufferedReader();
      String line=br.readLine();
      char[] arr=line.toCharArray();
      String res="Yes" ;
      for(int i=0 ; i<arr.length ; i++){
        if(i % 2==0 && arr[i]=='L'){
          res="No" ;
          break ;
        }
        if(i % 2==1 && arr[i]=='R'){
          res="No" ;
          break ;
        }
      }
      System.out.println(res);
    }
    catch(IOException ioe){
      ioe.printStackTrace();
    }
    catch(IllegalArgumentException iae){
      iae.printStackTrace();
      System.err.println("aa aa");
    }
  }
  private static BufferedReader createBufferedReader(){
    InputStreamReader isr=new InputStreamReader(System.in);
    return new BufferedReader(isr);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ;
     var br : OclFile ;
     try (     br := createBufferedReader() ; 
     var line : String ; line := br.readLine() ;
    var arr : Sequence(String) ; arr := line->characters() ;
    var res : String ; res := "Yes" ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (i mod 2 = 0 & arr[i+1] = 'L') then (     res := "No" ; 
     break ) else skip ; 
     if (i mod 2 = 1 & arr[i+1] = 'R') then (     res := "No" ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 )   catch (ioe : IOException) do (     ioe.printStackTrace() )
   catch (iae : IllegalArgumentException) do (     iae.printStackTrace() ; 
     OclFile["System.err"].println("aa aa") )
 );
  static   operation createBufferedReader() : OclFile
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     return OclFile.newOclFile_Read(isr) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String S=br.readLine();
    for(int i=0 ; i<S.length(); ++i){
      if(i % 2==1 && ! checkEven(S.charAt(i))){
        System.out.println("No");
        return ;
      }
      else if(i % 2==0 && ! checkOdd(S.charAt(i))){
        System.out.println("No");
        return ;
      }
    }
    System.out.println("Yes");
  }
  public static boolean checkEven(char a){
    if(a=='L' || a=='U' || a=='D')return true ;
    return false ;
  }
  public static boolean checkOdd(char a){
    if(a=='R' || a=='U' || a=='D')return true ;
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var S : String ; S := br.readLine() ;
         var i : int ; i := 0 ; while i < S->size() do ( (     if (i mod 2 = 1 & not(checkEven(S->at(i+1)))) then (     OclFile["System.out"].println("No") ; 
     return ) else     if (i mod 2 = 0 & not(checkOdd(S->at(i+1)))) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Yes") );
  static   operation checkEven( a : String) : boolean
  pre: true
  post: true
  activity: (     if (a = 'L' or a = 'U' or a = 'D') then     return true else skip ; 
     return false );
  static   operation checkOdd( a : String) : boolean
  pre: true
  post: true
  activity: (     if (a = 'R' or a = 'U' or a = 'D') then     return true else skip ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Comparator ;
import java.util.SortedSet ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int N=parseInt(br.readLine());
    int[] a=new int[N];
    StringTokenizer st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<N ; i++){
      a[i]=parseInt(st.nextToken());
    }
    SortedSet<Integer>pairs=new TreeSet<>(Comparator.reverseOrder());
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        if(i!=j)pairs.add(a[i]*a[j]);
      }
    }
    int ans=-1 ;
    for(int p : pairs){
      if(check(p)){
        ans=p ;
        break ;
      }
    }
    System.out.println(ans);
  }
  static boolean check(int p){
    String s=String.valueOf(p);
    boolean ret=true ;
    char t=s.charAt(0);
    for(int i=1 ; i<s.length(); i++){
      if(t+1!=s.charAt(i)){
        ret=false ;
        break ;
      }
      t=s.charAt(i);
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var N : int ; N := parseInt(br.readLine()) ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := (st.next() + "")->toInteger() )  ;     i := i + 1 ) ; 
    var pairs : Set(int) ; pairs := Set{}->union(Comparator.reverseOrder()) ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     if (i /= j) then     pairs := pairs->including(a[i+1] * a[j+1]) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -1 ;
    for (p : pairs) do ( (     if (check(p)) then (     ans := p ; 
     break ) else skip )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation check( p : int) : boolean
  pre: true
  post: true
  activity: (     var s : String ; s := ((p) + "") ;
     var ret : boolean ; ret := true ;
    var t : String ; t := s->at(0+1) ;
        var i : int ; i := 1 ; while i < s->size() do ( (     if (t + 1 /= s->at(i+1)) then (     ret := false ; 
     break ) else skip ; 
     t := s->at(i+1) )  ;     i := i + 1 ) ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    boolean flag=false ;
    for(int i=0 ; i<s.length(); i+=2){
      if(s.charAt(i)=='L'){
        flag=true ;
      }
    }
    for(int j=1 ; j<s.length(); j+=2){
      if(s.charAt(j)=='R'){
        flag=true ;
        ;
      }
    }
    if(flag==false){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'L') then (     flag := true ) else skip )  ;     i := i+(2) ) ; 
        var j : int ; j := 1 ; while j < s->size() do ( (     if (s->at(j+1) = 'R') then (     flag := true ; 
  ) else skip )  ;     j := j+(2) ) ; 
    if (flag = false) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.nextLine();
    String Sk[]=S.split("");
    int N=S.length();
    boolean easyFlag=true ;
    for(int i=0 ; i<N ; i++){
      if(Sk[i] .equals("R")){
        if((i % 2)==1){
          easyFlag=false ;
          break ;
        }
      }
      if(Sk[i] .equals("L")){
        if((i % 2)==0){
          easyFlag=false ;
          break ;
        }
      }
    }
    if(easyFlag)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.nextLine() ;
    var Sk : Sequence(String) ; Sk := S->split("") ;
    var N : int ; N := S->size() ;
    var easyFlag : boolean ; easyFlag := true ;
        var i : int ; i := 0 ; while i < N do ( (     if (Sk[i+1] = "R") then (     if ((i mod 2) = 1) then (     easyFlag := false ; 
     break ) else skip ) else skip ; 
     if (Sk[i+1] = "L") then (     if ((i mod 2) = 0) then (     easyFlag := false ; 
     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (easyFlag) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.out ;
import static java.lang.Math.*;
class Main {
  class P implements Comparable<P>{
    int fr,sc ;
    public P(int fr,int sc){
      super();
      this.fr=fr ;
      this.sc=sc ;
    }
    public int compareTo(P p){
      return sc-p.sc ;
    }
  }
  void run(){
    Scanner scan=new Scanner(System.in);
    int n ;
    while((n=scan.nextInt())!=0){
      P p[]=new P[n];
      for(int i=0 ; i<n ; i++){
        int a=scan.nextInt();
        int b=scan.nextInt();
        p[i]=new P(a,b);
      }
      Arrays.sort(p);
      boolean ok=true ;
      for(int i=0,sum=0 ; i<n ; i++){
        sum+=p[i] .fr ;
        if(p[i] .sc<sum)ok=false ;
      }
      out.println((ok ? "Yes" : "No"));
    }
  }
  public static void main(String args[]){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class P implements Comparable<P> {
   attribute fr : int;
   static operation newP( fr : int, sc : int) : P
  pre: true
  post: true
  activity:
  ( var self : P ;
    self := createP();
    self.initialise(fr, sc);
    return self );
  operation initialise( fr : int, sc : int) : void
  pre: true  post: true
  activity: (     execute super() ; 
     self.fr := fr ; 
     self.sc := sc );
   operation compareTo( p : P) : int
  pre: true
  post: true
  activity: (     return sc - p.sc );
}
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
         n := scan.getCurrent()->toInteger() ;
    while ((n) /= 0) do (    skip ; (     var p : Sequence(P) ; p := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scan.getCurrent()->toInteger() ;
     var b : int ; b := scan.getCurrent()->toInteger() ;
     p[i+1] := P.newP(a, b) )  ;     i := i + 1 ) ; 
    p := p->sort() ; 
    var ok : boolean ; ok := true ;
        var i : int ; i := 0 ;
    var sum : int ; sum := 0 ; while i < n do ( (     sum := sum+(p[i+1].fr) ; 
     if (p[i+1].sc < sum) then     ok := false ; else skip )  ;     i := i + 1 ) ; 
    out.println((if ok then "Yes" else "No" endif)) ; 
 ) ;     n := scan.getCurrent()->toInteger() ;
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    try(Scanner scn=new Scanner(System.in)){
      int n ;
      while((n=scn.nextInt())>0){
        ArrayList<Island>islands=new ArrayList<>();
        while(n-->0){
          islands.add(new Island(scn.nextInt(),scn.nextInt()));
        }
        Collections.sort(islands);
        boolean fail=false ;
        int weight=0 ;
        for(Island island : islands){
          weight+=island.getTreasure();
          if(weight>island.getDurability()){
            fail=true ;
          }
        }
        System.out.println(fail ? "No" : "Yes");
      }
    }
  }
}
class Island implements Comparable<Island>{
  private int treasure ;
  private int durability ;
  public Island(int treasure,int durability){
    this.treasure=treasure ;
    this.durability=durability ;
  }
  public int getTreasure(){
    return treasure ;
  }
  public int getDurability(){
    return durability ;
  }
  public int compareTo(Island another){
    return this.getDurability()>another.getDurability()? 1 :-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ;
         n := scn.getCurrent()->toInteger() ;
    while ((n) > 0) do (        skip ;     skip ; (     var islands : Sequence(Island) ; islands := Sequence{} ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     islands := islands->including(Island.newIsland(scn.getCurrent()->toInteger(), scn.getCurrent()->toInteger())) ) ;  ) ;  
    islands := islands->sort() ; 
    var fail : boolean ; fail := false ;
    var weight : int ; weight := 0 ;
    for (island : islands) do ( (     weight := weight+(island.getTreasure()) ; 
     if (weight > island.getDurability()) then (     fail := true ) else skip )  ) ; 
    OclFile["System.out"].println(if fail then "No" else "Yes" endif) ; 
 ) ;     n := scn.getCurrent()->toInteger() ;
 ) ))  );
}
class Island implements Comparable<Island> {
   attribute treasure : int;
   attribute durability : int;
   static operation newIsland( treasure : int, durability : int) : Island
  pre: true
  post: true
  activity:
  ( var self : Island ;
    self := createIsland();
    self.initialise(treasure, durability);
    return self );
  operation initialise( treasure : int, durability : int) : void
  pre: true  post: true
  activity: (     self.treasure := treasure ; 
     self.durability := durability );
   operation getTreasure() : int
  pre: true
  post: true
  activity: (     return treasure );
   operation getDurability() : int
  pre: true
  post: true
  activity: (     return durability );
   operation compareTo( another : Island) : int
  pre: true
  post: true
  activity: (     return if self.getDurability() > another.getDurability() then 1 else -1 endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int minToggle(int arr[],int n){
    int zero[]=new int[n+1];
    zero[0]=0 ;
    for(int i=1 ; i<=n ; ++i){
      if(arr[i-1]==0)zero[i]=zero[i-1]+1 ;
      else zero[i]=zero[i-1];
    }
    int ans=n ;
    for(int i=1 ; i<=n ; ++i)ans=Math.min(ans,i-zero[i]+zero[n]-zero[i]);
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      1,0,1,1,0 };
      int n=arr.length ;
      System.out.println(minToggle(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minToggle( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var zero : Sequence(int) ; zero := Integer.subrange(1,n + 1)->collect(0) ;
     zero[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (arr[i - 1+1] = 0) then     zero[i+1] := zero[i - 1+1] + 1 ; else     zero[i+1] := zero[i - 1+1] ; )  ;     i := i + 1 ) ; 
    var ans : int ; ans := n ;
        var i : int ; i := 1 ; while i <= n do (     ans := Set{ans, i - zero[i+1] + zero[n+1] - zero[i+1]}->min() ;  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,0,1,1,0} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minToggle(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String args[]){
    while(true){
      int N=sc.nextInt();
      if(N==0)break ;
      int[] v=new int[N];
      int[] w=new int[N];
      for(int i=0 ; i<N ; i++){
        v[i]=sc.nextInt();
        w[i]=sc.nextInt();
      }
      int[] tmp=new int[2];
      for(int i=0 ; i<N-1 ; i++){
        for(int j=i+1 ; j<N ; j++){
          if(w[i]==w[j] && v[i]>v[j]){
            tmp[0]=w[i];
            tmp[1]=v[i];
            w[i]=w[j];
            v[i]=v[j];
            w[j]=tmp[0];
            v[j]=tmp[1];
          }
          if(w[i]>w[j]){
            tmp[0]=w[i];
            tmp[1]=v[i];
            w[i]=w[j];
            v[i]=v[j];
            w[j]=tmp[0];
            v[j]=tmp[1];
          }
        }
      }
      int t=0 ;
      boolean f=true ;
      for(int i=0 ; i<N ; i++){
        t+=v[i];
        if(t>w[i]){
          System.out.println("No");
          f=false ;
          break ;
        }
      }
      if(f)System.out.println("Yes");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then     break else skip ; 
    var v : Sequence(int) ; v := Integer.subrange(1,N)->collect(0) ;
    var w : Sequence(int) ; w := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     v[i+1] := sc.getCurrent()->toInteger() ; 
     w[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var tmp : Sequence(int) ; tmp := Integer.subrange(1,2)->collect(0) ;
        var i : int ; i := 0 ; while i < N - 1 do ( (         var j : int ; j := i + 1 ; while j < N do ( (     if (w[i+1] = w[j+1] & v[i+1] > v[j+1]) then (     tmp[0+1] := w[i+1] ; 
     tmp[1+1] := v[i+1] ; 
    w[i+1] := w[j+1] ; 
    v[i+1] := v[j+1] ; 
    w[j+1] := tmp[0+1] ; 
    v[j+1] := tmp[1+1] ; 
 ) else skip ; 
     if (w[i+1] > w[j+1]) then (     tmp[0+1] := w[i+1] ; 
     tmp[1+1] := v[i+1] ; 
    w[i+1] := w[j+1] ; 
    v[i+1] := v[j+1] ; 
    w[j+1] := tmp[0+1] ; 
    v[j+1] := tmp[1+1] ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var t : int ; t := 0 ;
    var f : boolean ; f := true ;
        var i : int ; i := 0 ; while i < N do ( (     t := t+(v[i+1]) ; 
     if (t > w[i+1]) then (     OclFile["System.out"].println("No") ; 
     f := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (f) then     OclFile["System.out"].println("Yes") ; else skip ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
class Main {
  private static void solve(){
    final Scanner scanner=new Scanner(System.in);
    while(true){
      final int n=scanner.nextInt();
      if(n==0){
        break ;
      }
      int[][] islands=new int[n][2];
      for(int i=0 ; i<n ; i++){
        islands[i][0]=scanner.nextInt();
        islands[i][1]=scanner.nextInt();
      }
      Arrays.sort(islands,new Comparator<int[]>(){
        public int compare(int[] o1,int[] o2){
          if(o1[1]==o2[1]){
            return o1[0]==o2[0] ? 0 :(o1[0]>o2[0] ? 1 :-1);
          }
          else {
            return o1[1]>o2[1] ? 1 :-1 ;
          }
        }
      }
);
      int sum=0 ;
      boolean possible=true ;
      for(int i=0 ; i<n ; i++){
        sum+=islands[i][0];
        if(sum>islands[i][1]){
          possible=false ;
        }
      }
      System.out.println(possible ? "Yes" : "No");
    }
  }
  public static void main(String...args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var islands : Sequence(Sequence(int)) ; islands := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     islands[i+1][0+1] := scanner.getCurrent()->toInteger() ; 
     islands[i+1][1+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    islands := OclComparator.sortWith(islands, OclComparator<Sequence(int)>.newOclComparator()) ; 
    var sum : int ; sum := 0 ;
    var possible : boolean ; possible := true ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(islands[i+1][0+1]) ; 
     if (sum > islands[i+1][1+1]) then (     possible := false ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if possible then "Yes" else "No" endif) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int flag=in.nextInt();
    while(flag!=0){
      int n=flag ;
      Island[] island=new Island[n];
      int w=0 ;
      for(int i=0 ; i<n ; i++){
        island[i]=new Island(in.nextInt(),in.nextInt());
        w+=island[i] .juel ;
      }
      Arrays.sort(island);
      boolean isYes=true ;
      for(Island a : island){
        if(w>a.bridge){
          isYes=false ;
          break ;
        }
        w-=a.juel ;
      }
      System.out.println(isYes ? "Yes" : "No");
      flag=in.nextInt();
    }
  }
  static class Island implements Comparable<Island>{
    final int juel ;
    final int bridge ;
    Island(int juel,int bridge){
      this.juel=juel ;
      this.bridge=bridge ;
    }
    @ Override public int compareTo(Island o){
      return o.bridge<bridge ?-1 : o.bridge==bridge ? 0 : 1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var flag : int ; flag := in.getCurrent()->toInteger() ;
     while (flag /= 0) do (     var n : int ; n := flag ;
     var island : Sequence(Island) ; island := Integer.subrange(1,n)->collect(null) ;
    var w : int ; w := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     island[i+1] := Island.newIsland(in.getCurrent()->toInteger(), in.getCurrent()->toInteger()) ; 
     w := w+(island[i+1].juel) )  ;     i := i + 1 ) ; 
    island := island->sort() ; 
    var isYes : boolean ; isYes := true ;
    for (a : island) do ( (     if (w > a.bridge) then (     isYes := false ; 
     break ) else skip ; 
     w := w-(a.juel) )  ) ; 
    OclFile["System.out"].println(if isYes then "Yes" else "No" endif) ; 
    flag := in.getCurrent()->toInteger() ; 
 ) );
  static class Island implements Comparable<Island> {
   attribute juel : int;
   attribute bridge : int;
   static operation newIsland( juel : int, bridge : int) : Island
  pre: true
  post: true
  activity:
  ( var self : Island ;
    self := createIsland();
    self.initialise(juel, bridge);
    return self );
  operation initialise( juel : int, bridge : int) : void
  pre: true  post: true
  activity: (     self.juel := juel ; 
     self.bridge := bridge );
      operation compareTo( o : Island) : int
  pre: true
  post: true
  activity: (     return if o.bridge < bridge then -1 else if o.bridge = bridge then 0 else 1 endif endif );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] x=new int[n];
    int[] y=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=sc.nextInt();
      y[i]=x[i];
    }
    Arrays.sort(x);
    for(int i=0 ; i<n ; i++){
      if(y[i]<=x[n/2-1])System.out.println(x[n/2]);
      else System.out.println(x[n/2-1]);
    }
  }
  public static int lcm(int x,int y){
    return x*y/gcd(x,y);
  }
  public static int gcd(int x,int y){
    if(x<y)return gcd(y,x);
    if(y==0)return x ;
    return gcd(y,x % y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     y[i+1] := x[i+1] )  ;     i := i + 1 ) ; 
    x := x->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (y[i+1] <= x[n / 2 - 1+1]) then     OclFile["System.out"].println(x[n / 2+1]) ; else     OclFile["System.out"].println(x[n / 2 - 1+1]) ; )  ;     i := i + 1 ) ; 
 );
  static   operation lcm( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return x * y / gcd(x, y) );
  static   operation gcd( x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (x < y) then     return gcd(y, x) else skip ; 
     if (y = 0) then     return x else skip ; 
     return gcd(y, x mod y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.List ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    int N=Integer.parseInt(br.readLine());
    List<Integer>X=Arrays.stream(br.readLine().split(" ")).mapToInt(Integer :: parseInt).boxed().collect(Collectors.toList());
    List<Integer>sortedX=new ArrayList<>(X);
    sortedX.sort(null);
    for(Integer v : X){
      int idx=Collections.binarySearch(sortedX,v);
      if(idx<N/2){
        bw.write(String.format("%d\n",sortedX.get(N/2)));
      }
      else {
        bw.write(String.format("%d\n",sortedX.get(N/2-1)));
      }
    }
    bw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var N : int ; N := (br.readLine())->toInteger() ;
    var X : Sequence(int) ; X := stream(br.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) ).collect(Collectors.toList()) ;
    var sortedX : Sequence(int) ; sortedX := Sequence{}->union(X) ;
    sortedX := sortedX.sort(null) ; 
    for (v : X) do ( (     var idx : int ; idx := .binarySearch(sortedX, v) ;
     if (idx < N / 2) then (     skip ) else (     skip ) )  ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=br.readLine();
    int cnt[]=new int[26];
    for(int i=0 ; i<str.length(); i++){
      cnt[str.charAt(i)-'a']++;
    }
    int diff=0 ;
    for(int i=0 ; i<cnt.length ; i++){
      if(cnt[i]>0)++diff ;
    }
    if(diff==2){
      System.out.println("Second");
    }
    else {
      if(str.charAt(0)==str.charAt(str.length()-1)){
        String str1=((str.length()-3)& 1)==0 ? "Second" : "First" ;
        System.out.println(str1);
      }
      else {
        String str1=((str.length()-2)& 1)==0 ? "Second" : "First" ;
        System.out.println(str1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := br.readLine() ;
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < str->size() do ( (     cnt[str->at(i+1) - ('a')->char2byte()+1] := cnt[str->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    var diff : int ; diff := 0 ;
        var i : int ; i := 0 ; while i < cnt->size() do ( (     if (cnt[i+1] > 0) then     diff := diff + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (diff = 2) then (     OclFile["System.out"].println("Second") ) else (     if (str->at(0+1) = str->at(str->size() - 1+1)) then (     var str1 : String ; str1 := if (MathLib.bitwiseAnd((str->size() - 3),1)) = 0 then "Second" else "First" endif ;
     OclFile["System.out"].println(str1) ) else (     var str1 : String ; str1 := if (MathLib.bitwiseAnd((str->size() - 2),1)) = 0 then "Second" else "First" endif ;
     OclFile["System.out"].println(str1) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  InputStream in=System.in ;
  PrintStream out=System.out ;
  public void _main(String[] args){
    Scanner sc=new Scanner(in);
    int N=sc.nextInt();
    int[] X=nextIntArray(sc,N);
    sc.close();
    int[] b=new int[N];
    System.arraycopy(X,0,b,0,N);
    Arrays.sort(b);
    int m1=b[N/2-1];
    int m2=b[N/2];
    StringBuilder ans=new StringBuilder();
    for(int i=0 ; i<N ; i++){
      if(X[i]<=m1){
        ans.append(m2);
        ans.append("\r\n");
      }
      else {
        ans.append(m1);
        ans.append("\r\n");
      }
    }
    out.print(ans.toString());
  }
  public static void main(String[] args){
    new Main()._main(args);
  }
  @ SuppressWarnings("unused")private int[] nextIntArray(Scanner sc,int n){
    int[] result=new int[n];
    for(int i=0 ; i<n ; i++){
      result[i]=sc.nextInt();
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile["System.in"];
   attribute out : OclFile := OclFile["System.out"];
   operation _main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var X : Sequence(int) ; X := nextIntArray(sc, N) ;
    skip ; 
    var b : Sequence(int) ; b := Integer.subrange(1,N)->collect(0) ;
    for _x : Integer.subrange(1,N) do b[0 + _x] := X[0 + _x] ; 
    b := b->sort() ; 
    var m1 : int ; m1 := b[N / 2 - 1+1] ;
    var m2 : int ; m2 := b[N / 2+1] ;
    var ans : String ; ans := StringLib.newString() ;
        var i : int ; i := 0 ; while i < N do ( (     if (X[i+1] <= m1) then (     ans := ans + StringLib.newString(m2) ; 
     ans := ans + StringLib.newString("\r\n") ) else (     ans := ans + StringLib.newString(m1) ; 
     ans := ans + StringLib.newString("\r\n") ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain()._main(args) );
      operation nextIntArray( sc : OclFile, n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var result : Sequence(int) ; result := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     result[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  private static java.util.Scanner scanner=new java.util.Scanner(System.in);
  public static void main(String[] args){
    int n=scanner.nextInt();
    List<Integer>x=IntStream.range(0,n).map(i->scanner.nextInt()).boxed().collect(Collectors.toList());
    List<Integer>xSorted=new ArrayList<>(x);
    Collections.sort(xSorted);
    int m1=xSorted.get(n/2-1),m2=xSorted.get(n/2);
    for(Integer i : x)System.out.println(i>m1 ? m1 : m2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : Scanner := Scanner.newScanner(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.nextInt() ;
     var x : Sequence(int) ; x := Integer.subrange(0, n-1)->collect( _x1 | (lambda i : OclAny in scanner.nextInt())->apply(_x1) ).collect(Collectors.toList()) ;
    var xSorted : Sequence(int) ; xSorted := Sequence{}->union(x) ;
    xSorted := xSorted->sort() ; 
    var m1 : int ; m1 := xSorted->at(n / 2 - 1+1) ;
    var m2 : int ; m2 := xSorted->at(n / 2+1) ;
    for (i : x) do (     OclFile["System.out"].println(if i > m1 then m1 else m2 endif) ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x[]=new int[n];
    int buf[]=new int[n];
    for(int ct=0 ; ct<x.length ; ct++){
      x[ct]=sc.nextInt();
      buf[ct]=x[ct];
    }
    Arrays.sort(buf);
    if(buf[n/2-1]<buf[n/2]){
      for(int oki : x){
        if(oki<=buf[n/2-1]){
          System.out.println(buf[n/2]);
        }
        else {
          System.out.println(buf[n/2-1]);
        }
      }
    }
    else {
      for(int ct=0 ; ct<x.length ; ct++){
        System.out.println(buf[n/2-1]);
      }
      System.exit(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var buf : Sequence(int) ; buf := Integer.subrange(1,n)->collect(0) ;
        var ct : int ; ct := 0 ; while ct < x->size() do ( (     x[ct+1] := sc.getCurrent()->toInteger() ; 
     buf[ct+1] := x[ct+1] )  ;     ct := ct + 1 ) ; 
    buf := buf->sort() ; 
    if (buf[n / 2 - 1+1] < buf[n / 2+1]) then (     for (oki : x) do ( (     if (oki <= buf[n / 2 - 1+1]) then (     OclFile["System.out"].println(buf[n / 2+1]) ) else (     OclFile["System.out"].println(buf[n / 2 - 1+1]) ) )  ) ) else (         var ct : int ; ct := 0 ; while ct < x->size() do ( (     OclFile["System.out"].println(buf[n / 2 - 1+1]) )  ;     ct := ct + 1 ) ; 
 OclProcess.exit(0) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int highestPower(int n,int k){
    int i=0 ;
    int a=(int)Math.pow(n,i);
    while(a<=k){
      i+=1 ;
      a=(int)Math.pow(n,i);
    }
    return i-1 ;
  }
  static int b[]=new int[50];
  static int PowerArray(int n,int k){
    while(k>0){
      int t=highestPower(n,k);
      if(b[t]>0){
        System.out.print(-1);
        return 0 ;
      }
      else b[t]=1 ;
      k-=Math.pow(n,t);
    }
    for(int i=0 ; i<50 ; i++){
      if(b[i]>0){
        System.out.print(i+",");
      }
    }
    return 0 ;
  }
  public static void main(String[] args){
    int N=3 ;
    int K=40 ;
    PowerArray(N,K);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation highestPower( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var a : int ; a := n->pow(i)->oclAsType(int) ;
     while (a <= k) do (     i := i+(1) ; 
     a := n->pow(i)->oclAsType(int) ) ; 
     return i - 1 );
  static   attribute b : int := Integer.subrange(1,50)->collect(0);
  static   operation PowerArray( n : int, k : int) : int
  pre: true
  post: true
  activity: (     while (k > 0) do (     var t : int ; t := highestPower(n, k) ;
     if (b[t+1] > 0) then (     OclFile["System.out"].print(-1) ; 
     return 0 ) else     b[t+1] := 1 ; ;  
     k := k-(n->pow(t)) ) ; 
         var i : int ; i := 0 ; while i < 50 do ( (     if (b[i+1] > 0) then (     OclFile["System.out"].print(i + ",") ) else skip )  ;     i := i + 1 ) ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
     var K : int ; K := 40 ;
     execute PowerArray(N, K) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static final int M=26 ;
  static int getIdx(char ch){
    return(ch-'a');
  }
  static boolean allSame(int freq[],int N){
    int same=0 ;
    int i ;
    for(i=0 ; i<N ; i++){
      if(freq[i]>0){
        same=freq[i];
        break ;
      }
    }
    for(int j=i+1 ; j<N ; j++)if(freq[j]>0 && freq[j]!=same)return false ;
    return true ;
  }
  static boolean possibleSameCharFreqByOneRemoval(String str){
    int l=str.length();
    int[] freq=new int[M];
    for(int i=0 ; i<l ; i++)freq[getIdx(str.charAt(i))]++;
    if(allSame(freq,M))return true ;
    for(char c='a' ; c<='z' ; c++){
      int i=getIdx(c);
      if(freq[i]>0){
        freq[i]--;
        if(allSame(freq,M))return true ;
        freq[i]++;
      }
    }
    return false ;
  }
  public static void main(String args[]){
    String str="xyyzz" ;
    if(possibleSameCharFreqByOneRemoval(str))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute M : int := 26;
  static   operation getIdx( ch : String) : int
  pre: true
  post: true
  activity: (     return (ch - ('a')->char2byte()) );
  static   operation allSame( freq : Sequence(int), N : int) : boolean
  pre: true
  post: true
  activity: (     var same : int ; same := 0 ;
     var i : int ;
        i := 0 ; while i < N do ( (     if (freq[i+1] > 0) then (     same := freq[i+1] ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var j : int ; j := i + 1 ; while j < N do (     if (freq[j+1] > 0 & freq[j+1] /= same) then     return false else skip ;  ;     j := j + 1 ) ; 
    return true 
 );
  static   operation possibleSameCharFreqByOneRemoval( str : String) : boolean
  pre: true
  post: true
  activity: (     var l : int ; l := str->size() ;
     var freq : Sequence(int) ; freq := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < l do (     freq[getIdx(str->at(i+1))+1] := freq[getIdx(str->at(i+1))+1] + 1 ;  ;     i := i + 1 ) ; 
    if (allSame(freq, M)) then     return true else skip ; 
        var c : String ; c := 'a' ; while c <= 'z' do ( (     var i : int ; i := getIdx(c) ;
     if (freq[i+1] > 0) then (     freq[i+1] := freq[i+1] - 1 ; 
     if (allSame(freq, M)) then     return true else skip ; 
     freq[i+1] := freq[i+1] + 1 ) else skip )  ;     c := c + 1 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "xyyzz" ;
     if (possibleSameCharFreqByOneRemoval(str)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int GetMinSubarrayLength(int a[],int n){
    int ans=Math.max(a[0],a[n-1]);
    int lo=0,hi=n-1 ;
    while(lo<n && a[lo] % ans==0)lo++;
    while(hi>lo && a[hi] % ans==0)hi--;
    return(hi-lo+1);
  }
  public static void main(String[] args){
    int arr[]={
      4,8,2,1,4 };
      int N=arr.length ;
      int Length=GetMinSubarrayLength(arr,N);
      System.out.println(Length);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation GetMinSubarrayLength( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := Set{a[0+1], a[n - 1+1]}->max() ;
     var lo : int ; lo := 0 ;
    var hi : int ; hi := n - 1 ;
    while (lo < n & a[lo+1] mod ans = 0) do     lo := lo + 1 ; ; 
    while (hi > lo & a[hi+1] mod ans = 0) do     hi := hi - 1 ; ; 
    return (hi - lo + 1) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,8,2,1,4} ;
     var N : int ; N := arr->size() ;
     var Length : int ; Length := GetMinSubarrayLength(arr, N) ;
     OclFile["System.out"].println(Length) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int factorial(int n){
    return(n==1 || n==0)? 1 : factorial(n-1)*n ;
  }
  static int gcdOfFactorial(int[] arr,int n){
    int minm=arr[0];
    for(int i=1 ; i<n ; i++)minm=minm>arr[i] ? arr[i] : minm ;
    return factorial(minm);
  }
  public static void main(String[] args){
    int[] arr={
      9,12,122,34,15 };
      int n=arr.length ;
      System.out.println(gcdOfFactorial(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation factorial( n : int) : int
  pre: true
  post: true
  activity: (     return if (n = 1 or n = 0) then 1 else factorial(n - 1) * n endif );
  static   operation gcdOfFactorial( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var minm : int ; minm := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do (     minm := if minm > arr[i+1] then arr[i+1] else minm endif ;  ;     i := i + 1 ) ; 
     return factorial(minm) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{9,12,122,34,15} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(gcdOfFactorial(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CP19 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt(),sum=t ;
    for(int i=1 ; i<t ; i++){
      sum+=(t-i)*i ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CP19 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var sum : int ; sum := t ;
         var i : int ; i := 1 ; while i < t do ( (     sum := sum+((t - i) * i) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sum) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x=1 ;
    int sum=n ;
    n--;
    while(n>0){
      sum+=(n-1+((n-1)*x)+1);
      x++;
      n--;
    }
    System.out.print(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := 1 ;
    var sum : int ; sum := n ;
    n := n - 1 ; 
    while (n > 0) do (     sum := sum+((n - 1 + ((n - 1) * x) + 1)) ; 
     x := x + 1 ; 
     n := n - 1 ) ; 
    OclFile["System.out"].print(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.math.BigInteger ;
import java.net.SocketOption ;
import java.util.ArrayList ;
public class Code {
  public static Scanner scan ;
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int result=0 ;
    for(int k=1 ; k<n ; k++){
      result+=k*(n-k);
    }
    result+=n ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code {
  static   attribute scan : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var result : int ; result := 0 ;
        var k : int ; k := 1 ; while k < n do ( (     result := result+(k * (n - k)) )  ;     k := k + 1 ) ; 
    result := result+(n) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    boolean startStringIsOdd=(s.length()% 2!=0);
    boolean endStringIsOdd=(s.charAt(0)==s.charAt(s.length()-1));
    System.out.println(startStringIsOdd ^ endStringIsOdd ? "First" : "Second");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var startStringIsOdd : boolean ; startStringIsOdd := (s->size() mod 2 /= 0) ;
    var endStringIsOdd : boolean ; endStringIsOdd := (s->at(0+1) = s->at(s->size() - 1+1)) ;
    OclFile["System.out"].println(if startStringIsOdd xor endStringIsOdd then "First" else "Second" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Sol {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int sum=n ;
    for(int i=1 ; i<n ; i++){
      sum+=i*(n-i);
    }
    System.out.print(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sol {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := n ;
        var i : int ; i := 1 ; while i < n do ( (     sum := sum+(i * (n - i)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Buttons {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int sum=n ;
    for(int i=1 ; i<n ; i++)sum+=(n-i)*i ;
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Buttons {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := n ;
        var i : int ; i := 1 ; while i < n do (     sum := sum+((n - i) * i) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int sum=1 ;
    for(int i=1 ; i<n ; i++){
      sum=sum+i ;
      if(sum!=n)sum %=n ;
      System.out.print(sum+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var sum : int ; sum := 1 ;
         var i : int ; i := 1 ; while i < n do ( (     sum := sum + i ; 
     if (sum /= n) then     sum := sum mod n ; else skip ; 
     OclFile["System.out"].print(sum + " ") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int sum=1 ;
    for(int i=1 ; i<n ; i++){
      sum=sum+i ;
      if(sum!=n)sum %=n ;
      System.out.print(sum+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var sum : int ; sum := 1 ;
         var i : int ; i := 1 ; while i < n do ( (     sum := sum + i ; 
     if (sum /= n) then     sum := sum mod n ; else skip ; 
     OclFile["System.out"].print(sum + " ") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CodeForces {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int kids=sc.nextInt();
    int ans=1 ;
    for(int i=1 ; i<kids ; i++){
      ans=ans+i ;
      if(ans<=kids){
        System.out.println(ans);
      }
      else {
        ans=ans-kids ;
        System.out.println(ans);
      }
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var kids : int ; kids := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 1 ;
        var i : int ; i := 1 ; while i < kids do ( (     ans := ans + i ; 
     if (ans <= kids) then (     OclFile["System.out"].println(ans) ) else (     ans := ans - kids ; 
     OclFile["System.out"].println(ans) ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=2 ;
    int j=2 ;
    int i=0 ;
    while(i<n-1){
      System.out.print(a+" ");
      a=(a+j)% n ;
      if(a==0)a=n ;
      j++;
      i++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := 2 ;
    var j : int ; j := 2 ;
    var i : int ; i := 0 ;
    while (i < n - 1) do (     OclFile["System.out"].print(a + " ") ; 
     a := (a + j) mod n ; 
    if (a = 0) then     a := n ; else skip ; 
    j := j + 1 ; 
    i := i + 1 ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int sum=1 ;
    for(int i=1 ; i<n ; i++){
      sum=sum+i ;
      if(sum!=n)sum %=n ;
      System.out.print(sum+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var sum : int ; sum := 1 ;
         var i : int ; i := 1 ; while i < n do ( (     sum := sum + i ; 
     if (sum /= n) then     sum := sum mod n ; else skip ; 
     OclFile["System.out"].print(sum + " ") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Nth {
  static float CalculateRatio(float m,float n){
    return(2*m-1)/(2*n-1);
  }
}
class GFG {
  public static void main(String[] args){
    float m=6,n=2 ;
    Nth a=new Nth();
    System.out.println(a.CalculateRatio(m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Nth {
  static   operation CalculateRatio( m : double, n : double) : double
  pre: true
  post: true
  activity: (     return (2 * m - 1) / (2 * n - 1) );
}
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : double ; m := 6 ;
    var n : double ; n := 2 ;
     var a : Nth ; a := Nth.newNth() ;
     OclFile["System.out"].println(a.CalculateRatio(m, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static void printNonSquare(int n){
    int curr_count=2,num=2,count=0 ;
    while(count<n){
      for(int i=0 ; i<curr_count && count<n ; i++){
        System.out.print(num+" ");
        count++;
        num++;
      }
      num++;
      curr_count+=2 ;
    }
  }
  public static void main(String args[]){
    int n=10 ;
    printNonSquare(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printNonSquare( n : int) : void
  pre: true
  post: true
  activity: (     var curr_count : int ; curr_count := 2 ;
    var num : int ; num := 2 ;
    var count : int ; count := 0 ;
     while (count < n) do (         var i : int ; i := 0 ; while i < curr_count & count < n do ( (     OclFile["System.out"].print(num + " ") ; 
     count := count + 1 ; 
     num := num + 1 )  ;     i := i + 1 ) ; 
     num := num + 1 ; 
     curr_count := curr_count+(2) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     execute printNonSquare(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int magicIndex(int arr[],int start,int end){
    if(start>end)return-1 ;
    int midIndex=(start+end)/2 ;
    int midValue=arr[midIndex];
    if(midIndex==midValue)return midIndex ;
    int left=magicIndex(arr,start,Math.min(midValue,midIndex-1));
    if(left>=0)return left ;
    return magicIndex(arr,Math.max(midValue,midIndex+1),end);
  }
  public static void main(String[] args){
    int arr[]={
-10,-5,2,2,2,3,4,7,9,12,13 };
      int n=arr.length ;
      int index=magicIndex(arr,0,n-1);
      if(index==-1)System.out.print("No Magic Index");
      else System.out.print("Magic Index is : "+index);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation magicIndex( arr : Sequence(int), start : int, end : int) : int
  pre: true
  post: true
  activity: (     if (start > end) then     return -1 else skip ; 
     var midIndex : int ; midIndex := (start + end) / 2 ;
    var midValue : int ; midValue := arr[midIndex+1] ;
    if (midIndex = midValue) then     return midIndex else skip ; 
    var left : int ; left := magicIndex(arr, start, Set{midValue, midIndex - 1}->min()) ;
    if (left >= 0) then     return left else skip ; 
    return magicIndex(arr, Set{midValue, midIndex + 1}->max(), end) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-10,-5,2,2,2,3,4,7,9,12,13} ;
     var n : int ; n := arr->size() ;
     var index : int ; index := magicIndex(arr, 0, n - 1) ;
     if (index = -1) then     OclFile["System.out"].print("No Magic Index") ; else     OclFile["System.out"].print("Magic Index is : " + index) ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int bit(int x){
    int ans=0 ;
    while(x>0){
      x/=2 ;
      ans++;
    }
    return ans ;
  }
  static boolean check(int d,int x){
    if(bit(x/d)<=bit(d))return true ;
    return false ;
  }
  static int bs(int n){
    int l=1,r=(int)Math.sqrt(n);
    while(l<r){
      int m=(l+r)/2 ;
      if(check(m,n))r=m ;
      else l=m+1 ;
    }
    if(! check(l,n))return l+1 ;
    else return l ;
  }
  static int countDivisor(int n){
    return n-bs(n)+1 ;
  }
  static public void main(String[] args){
    int n=5 ;
    System.out.println(countDivisor(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation bit( x : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     while (x > 0) do (     x := x/(2) ; 
     ans := ans + 1 ) ; 
     return ans );
  static   operation check( d : int, x : int) : boolean
  pre: true
  post: true
  activity: (     if (bit(x / d) <= bit(d)) then     return true else skip ; 
     return false );
  static   operation bs( n : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 1 ;
    var r : int ; r := (n)->sqrt()->oclAsType(int) ;
     while (l < r) do (     var m : int ; m := (l + r) / 2 ;
     if (check(m, n)) then     r := m ; else     l := m + 1 ; ) ; 
     if (not(check(l, n))) then     return l + 1 else     return l );
  static   operation countDivisor( n : int) : int
  pre: true
  post: true
  activity: (     return n - bs(n) + 1 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(countDivisor(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maxProfit(int price[],int n,int k){
    int profit[][]=new int[k+1][n+1];
    for(int i=0 ; i<=k ; i++)profit[i][0]=0 ;
    for(int j=0 ; j<=n ; j++)profit[0][j]=0 ;
    for(int i=1 ; i<=k ; i++){
      int prevDiff=Integer.MIN_VALUE ;
      for(int j=1 ; j<n ; j++){
        prevDiff=Math.max(prevDiff,profit[i-1][j-1]-price[j-1]);
        profit[i][j]=Math.max(profit[i][j-1],price[j]+prevDiff);
      }
    }
    return profit[k][n-1];
  }
  public static void main(String[] args){
    int k=3 ;
    int price[]={
      12,14,17,10,14,13,12,15 };
      int n=price.length ;
      System.out.println("Maximum profit is: "+maxProfit(price,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxProfit( price : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var profit : Sequence(Sequence(int)) ; profit := Integer.subrange(1,k + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i <= k do (     profit[i+1][0+1] := 0 ;  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j <= n do (     profit[0+1][j+1] := 0 ;  ;     j := j + 1 ) ; 
        var i : int ; i := 1 ; while i <= k do ( (     var prevDiff : int ; prevDiff := -2147483648 ;
         var j : int ; j := 1 ; while j < n do ( (     prevDiff := Set{prevDiff, profit[i - 1+1][j - 1+1] - price[j - 1+1]}->max() ; 
     profit[i+1][j+1] := Set{profit[i+1][j - 1+1], price[j+1] + prevDiff}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return profit[k+1][n - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 3 ;
     var price : Sequence(int) ; price := Sequence{12,14,17,10,14,13,12,15} ;
     var n : int ; n := price->size() ;
     OclFile["System.out"].println("Maximum profit is: " + maxProfit(price, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class p1422B {
  public static void main(String[] arg){
    Scanner sc=new Scanner(System.in);
    for(long t=sc.nextInt(),sum=0 ; t-->0 ; sum=0){
      int n=sc.nextInt(),m=sc.nextInt(),a[][]=new int[n][m];
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<m ; j++)a[i][j]=sc.nextInt();
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<m ; j++){
        int p[]={
          a[i][j],a[i][m-1-j],a[n-1-i][j],a[n-1-i][m-1-j] };
          Arrays.sort(p);
          sum+=p[2]+p[3]-p[0]-p[1];
        }
        System.out.println(sum/4);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class p1422B {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var t : long ; t := sc.getCurrent()->toInteger() ;
    var sum : long ; sum := 0 ; while t > 0 do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(void)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < m do (     a[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < m do ( (     var p : Sequence(int) ; p := Sequence{a[i+1][j+1],a[i+1][m - 1 - j+1],a[n - 1 - i+1][j+1],a[n - 1 - i+1][m - 1 - j+1]} ;
     p := p->sort() ; 
     sum := sum+(p[2+1] + p[3+1] - p[0+1] - p[1+1]) )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sum / 4) )  ;     sum := 0 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class1 {
  public static void main(String arg[]){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    while(t-->0){
      int n=input.nextInt();
      int m=input.nextInt();
      String s=input.next();
      char c[]=s.toCharArray();
      while(m-->0){
        int flag=0 ;
        int temp=-1 ;
        for(int i=0 ; i<s.length(); i++){
          if(i==0){
            if(c[i]=='0'){
              if(c[i+1]=='1'){
                c[i]='1' ;
                flag=1 ;
              }
            }
            continue ;
          }
          if(i==n-1){
            if(c[i]=='0'){
              if(c[i-1]=='1' && temp!=i-1){
                c[i]='1' ;
                flag=1 ;
              }
            }
            continue ;
          }
          int x=0 ;
          if(c[i]=='0'){
            if(temp!=i-1){
              if(c[i-1]=='1'){
                x++;
              }
            }
            else {
              temp=-1 ;
            }
            if(c[i+1]=='1'){
              x++;
            }
            if(x==1){
              flag=1 ;
              c[i]='1' ;
              temp=i ;
            }
          }
        }
        if(flag==0){
          break ;
        }
      }
      for(int i=0 ; i<s.length(); i++){
        System.out.print(c[i]);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class1 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := input.getCurrent()->toInteger() ;
     var m : int ; m := input.getCurrent()->toInteger() ;
    var s : String ; s := input.getCurrent() ;
    var c : Sequence(String) ; c := s->characters() ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     var flag : int ; flag := 0 ;
     var temp : int ; temp := -1 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (i = 0) then (     if (c[i+1] = '0') then (     if (c[i + 1+1] = '1') then (     c[i+1] := '1' ; 
     flag := 1 ) else skip ) else skip ; 
     continue ) else skip ; 
     if (i = n - 1) then (     if (c[i+1] = '0') then (     if (c[i - 1+1] = '1' & temp /= i - 1) then (     c[i+1] := '1' ; 
     flag := 1 ) else skip ) else skip ; 
     continue ) else skip ; 
     var x : int ; x := 0 ;
     if (c[i+1] = '0') then (     if (temp /= i - 1) then (     if (c[i - 1+1] = '1') then (     x := x + 1 ) else skip ) else (     temp := -1 ) ;  
     if (c[i + 1+1] = '1') then (     x := x + 1 ) else skip ; 
     if (x = 1) then (     flag := 1 ; 
     c[i+1] := '1' ; 
     temp := i ) else skip ) else skip )  ;     i := i + 1 ) ; 
     if (flag = 0) then (     break ) else skip ) ;  ) ;  
        var i : int ; i := 0 ; while i < s->size() do ( (     OclFile["System.out"].print(c[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static double e=2.71828 ;
  static int roundNo(float num){
    return(int)(num<0 ? num-0.5 : num+0.5);
  }
  static void printBestCandidate(int candidate[],int n){
    int sample_size=roundNo((float)(n/e));
    System.out.println("\n\nSample size is "+sample_size);
    int best=0 ;
    for(int i=1 ; i<sample_size ; i++)if(candidate[i]>candidate[best])best=i ;
    for(int i=sample_size ; i<n ; i++)if(candidate[i]>=candidate[best]){
      best=i ;
      break ;
    }
    if(best>=sample_size)System.out.println("\nBest candidate found is "+(best+1)+" with talent "+candidate[best]);
    else System.out.print("Couldn't find a best candidate\n");
  }
  public static void main(String[] args){
    int n=8 ;
    int[] candidate=new int[n];
    Random rand=new Random();
    for(int i=0 ; i<n ; i++)candidate[i]=1+rand.nextInt((8-1)+1);
    System.out.print("Candidate : ");
    for(int i=0 ; i<n ; i++)System.out.print(i+1+" ");
    System.out.println();
    System.out.print("Talents : ");
    for(int i=0 ; i<n ; i++)System.out.print(candidate[i]+" ");
    printBestCandidate(candidate,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute e : double := 2.71828;
  static   operation roundNo( num : double) : int
  pre: true
  post: true
  activity: (     return (if num < 0 then num - 0.5 else num + 0.5 endif)->oclAsType(int) );
  static   operation printBestCandidate( candidate : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var sample_size : int ; sample_size := roundNo((n / e)->oclAsType(double)) ;
     OclFile["System.out"].println("\n\nSample size is " + sample_size) ; 
    var best : int ; best := 0 ;
        var i : int ; i := 1 ; while i < sample_size do (     if (candidate[i+1] > candidate[best+1]) then     best := i ; else skip ;  ;     i := i + 1 ) ; 
        var i : int ; i := sample_size ; while i < n do (     if (candidate[i+1] >= candidate[best+1]) then (     best := i ; 
     break ) else skip ;  ;     i := i + 1 ) ; 
    if (best >= sample_size) then     OclFile["System.out"].println("\nBest candidate found is " + (best + 1) + " with talent " + candidate[best+1]) else     OclFile["System.out"].print("Couldn't find a best candidate\n") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     var candidate : Sequence(int) ; candidate := Integer.subrange(1,n)->collect(0) ;
    var rand : OclRandom ; rand := OclRandom.newOclRandom() ;
        var i : int ; i := 0 ; while i < n do (     candidate[i+1] := 1 + rand.nextInt((8 - 1) + 1) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("Candidate : ") ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(i + 1 + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    OclFile["System.out"].print("Talents : ") ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(candidate[i+1] + " ") ;  ;     i := i + 1 ) ; 
    execute printBestCandidate(candidate, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class WOW_Factor {
  static Scanner sc=new Scanner(System.in);
  static PrintWriter pw=new PrintWriter(System.out);
  static String str ;
  public static long find(int i,boolean f,boolean o,boolean s){
    if(i==str.length())return 0 ;
    if(f && o && s){
      System.out.println("we are here");
      return 1 ;
    }
    long ans=0 ;
    if(str.charAt(i)=='w'){
      if(! f){
        ans=find(i+1,true,false,false)+find(i+1,f,o,s);
      }
      else if(f && o){
        ans=find(i+1,true,true,true)+find(i+1,true,false,false)+find(i+1,false,false,false);
      }
    }
    else if(str.charAt(i)=='o'){
      System.out.println("ooo");
      if(f){
        ans=find(i+1,f,true,false)+find(i+1,false,false,false);
      }
    }
    return ans ;
  }
  public static void main(String[] args)throws IOException {
    String instr=sc.next();
    str="" ;
    str=instr ;
    long a=0 ;
    long b=0 ;
    long c=0 ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)=='o'){
        b=b+a ;
      }
      else if(i!=0 && str.charAt(i-1)=='v'){
        a++;
        c=c+b ;
      }
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class WOW_Factor {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute str : String;
  static   operation find( i : int, f : boolean, o : boolean, s : boolean) : long
  pre: true
  post: true
  activity: (     if (i = str->size()) then     return 0 else skip ; 
     if (f & o & s) then (     OclFile["System.out"].println("we are here") ; 
     return 1 ) else skip ; 
    var ans : long ; ans := 0 ;
    if (str->at(i+1) = 'w') then (     if (not(f)) then (     ans := find(i + 1, true, false, false) + find(i + 1, f, o, s) ) else     if (f & o) then (     ans := find(i + 1, true, true, true) + find(i + 1, true, false, false) + find(i + 1, false, false, false) ) else skip ; ) else     if (str->at(i+1) = 'o') then (     OclFile["System.out"].println("ooo") ; 
     if (f) then (     ans := find(i + 1, f, true, false) + find(i + 1, false, false, false) ) else skip ) else skip ; ;  
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var instr : String ; instr := sc.getCurrent() ;
     str := "" ; 
    str := instr ; 
    var a : long ; a := 0 ;
    var b : long ; b := 0 ;
    var c : long ; c := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = 'o') then (     b := b + a ) else     if (i /= 0 & str->at(i - 1+1) = 'v') then (     a := a + 1 ; 
     c := c + b ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
public class Main {
  public static int solution(int[] read,int pages){
    int day=0 ;
    int finished=0 ;
    while(finished<pages){
      int flag=0 ;
      for(int i=0 ; i<7 ; i++){
        day++;
        finished+=read[i];
        if(finished>=pages){
          flag=1 ;
          break ;
        }
      }
      if(flag==1)break ;
      day=0 ;
    }
    return day ;
  }
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int pages=input.nextInt();
    int[] read=new int[7];
    for(int i=0 ; i<7 ; i++){
      read[i]=input.nextInt();
    }
    System.out.println(solution(read,pages));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solution( read : Sequence(int), pages : int) : int
  pre: true
  post: true
  activity: (     var day : int ; day := 0 ;
     var finished : int ; finished := 0 ;
     while (finished < pages) do (     var flag : int ; flag := 0 ;
         var i : int ; i := 0 ; while i < 7 do ( (     day := day + 1 ; 
     finished := finished+(read[i+1]) ; 
     if (finished >= pages) then (     flag := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (flag = 1) then     break else skip ; 
     day := 0 ) ; 
     return day );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pages : int ; pages := input.getCurrent()->toInteger() ;
    var read : Sequence(int) ; read := Integer.subrange(1,7)->collect(0) ;
        var i : int ; i := 0 ; while i < 7 do ( (     read[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solution(read, pages)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class code {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[7];
    for(int j=0 ; j<7 ; j++){
      arr[j]=sc.nextInt();
    }
    int i=0 ;
    while(n>0){
      n=n-arr[i % 7];
      i++;
    }
    System.out.println(i % 7==0 ? 7 : i % 7);
  }
}
------------------------------------------------------------
OCL File:
---------
 class code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,7)->collect(0) ;
        var j : int ; j := 0 ; while j < 7 do ( (     arr[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    var i : int ; i := 0 ;
    while (n > 0) do (     n := n - arr[i mod 7+1] ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println(if i mod 7 = 0 then 7 else i mod 7 endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class jk {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    while(k--!=0){
      int len=sc.nextInt();
      int ans=0 ;
      String a ;
      String b ;
      a=sc.next();
      b=sc.next();
      char[] c=a.toCharArray();
      char[] d=b.toCharArray();
      for(int i=0 ; i<len ; i++){
        if(d[i]=='1'){
          if(c[i]=='0')ans++;
          else if(i!=0 && c[i-1]=='1'){
            ans++;
            c[i-1]='0' ;
            continue ;
          }
          else if(i!=len-1 && c[i+1]=='1'){
            ans++;
            c[i+1]='0' ;
            continue ;
          }
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class jk {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
         while (k /= 0) do (    skip ; (     var len : int ; len := sc.getCurrent()->toInteger() ;
     var ans : int ; ans := 0 ;
    var a : String ;
    var b : String ;
    a := sc.getCurrent() ; 
    b := sc.getCurrent() ; 
    var c : Sequence(String) ; c := a->characters() ;
    var d : Sequence(String) ; d := b->characters() ;
        var i : int ; i := 0 ; while i < len do ( (     if (d[i+1] = '1') then (     if (c[i+1] = '0') then     ans := ans + 1 ; else     if (i /= 0 & c[i - 1+1] = '1') then (     ans := ans + 1 ; 
     c[i - 1+1] := '0' ; 
     continue ) else     if (i /= len - 1 & c[i + 1+1] = '1') then (     ans := ans + 1 ; 
     c[i + 1+1] := '0' ; 
     continue ) else skip ; ;  ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Mridul8 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[7];
    int i=-1 ;
    while(i!=6){
      i=i+1 ;
      arr[i]=sc.nextInt();
    }
    int sum=0 ;
    i=-1 ;
    while(sum<n){
      i=i+1 ;
      sum=sum+arr[i % 7];
    }
    System.out.println((i % 7)+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mridul8 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,7)->collect(0) ;
    var i : int ; i := -1 ;
    while (i /= 6) do (     i := i + 1 ; 
     arr[i+1] := sc.getCurrent()->toInteger() ) ; 
    var sum : int ; sum := 0 ;
    i := -1 ; 
    while (sum < n) do (     i := i + 1 ; 
     sum := sum + arr[i mod 7+1] ) ; 
    OclFile["System.out"].println((i mod 7) + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minimalSteps(String s,int n){
    int[] dp=new int[n];
    for(int i=0 ; i<n ; i++)dp[i]=Integer.MAX_VALUE ;
    String s1="",s2="" ;
    dp[0]=1 ;
    s1+=s.charAt(0);
    for(int i=1 ; i<n ; i++){
      s1+=s.charAt(i);
      s2=s.substring(i+1,i+1);
      dp[i]=Math.min(dp[i],dp[i-1]+1);
      if(s1==s2)dp[i*2+1]=Math.min(dp[i]+1,dp[i*2+1]);
    }
    return dp[n-1];
  }
  public static void main(String args[]){
    String s="aaaaaaaa" ;
    int n=s.length();
    System.out.println(minimalSteps(s,n)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimalSteps( s : String, n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     dp[i+1] := 2147483647 ;  ;     i := i + 1 ) ; 
    var s1 : String ; s1 := "" ;
    var s2 : String ; s2 := "" ;
    dp[0+1] := 1 ; 
    s1 := s1+(s->at(0+1)) ; 
        var i : int ; i := 1 ; while i < n do ( (     s1 := s1+(s->at(i+1)) ; 
     s2 := s.subrange(i + 1+1,i + 1) ; 
     dp[i+1] := Set{dp[i+1], dp[(i)->char2byte() - 1+1] + 1}->min() ; 
     if (s1 = s2) then     dp[i * 2 + 1+1] := Set{dp[i+1] + 1, dp[i * 2 + 1+1]}->min() ; else skip )  ;     i := i + 1 ) ; 
    return dp[n - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "aaaaaaaa" ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].println(minimalSteps(s, n) / 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class CP12 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    sc.nextLine();
    int[] n1=new int[7];
    for(int i=0 ; i<7 ; i++){
      n1[i]=sc.nextInt();
    }
    int i=0 ;
    while(n>0){
      n=n-n1[i];
      if(n<=0){
        i++;
        break ;
      }
      if(n>0 && i==6){
        i=-1 ;
      }
      i++;
    }
    System.out.println(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CP12 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
    var n1 : Sequence(int) ; n1 := Integer.subrange(1,7)->collect(0) ;
        var i : int ; i := 0 ; while i < 7 do ( (     n1[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var i : int ; i := 0 ;
    while (n > 0) do (     n := n - n1[i+1] ; 
     if (n <= 0) then (     i := i + 1 ; 
     break ) else skip ; 
     if (n > 0 & i = 6) then (     i := -1 ) else skip ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println(i) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class PetrAndBook {
  public static void main(String[] args)throws IOException {
    FastIO io=new FastIO();
    int n=io.nextInt();
    int day=0 ;
    int[] arr=new int[7];
    for(int i=0 ; i<7 ; i++){
      arr[i]=io.nextInt();
    }
    while(true){
      n-=arr[day];
      if(n<=0)break ;
      day=(day+1)% 7 ;
    }
    io.println(day+1);
    io.close();
  }
  static class FastIO extends PrintWriter {
    private BufferedReader br ;
    private StringTokenizer st ;
    public FastIO(){
      this(System.in,System.out);
    }
    public FastIO(InputStream in,OutputStream out){
      super(out);
      br=new BufferedReader(new InputStreamReader(in));
    }
    public FastIO(String problemName)throws IOException {
      super(new FileWriter(problemName+".out"));
      br=new BufferedReader(new FileReader(problemName+".in"));
    }
    public String next(){
      try {
        while(st==null || ! st.hasMoreTokens()){
          st=new StringTokenizer(br.readLine());
        }
        return st.nextToken();
      }
      catch(Exception e){
      }
      return null ;
    }
    public String nextLine(){
      try {
        return br.readLine();
      }
      catch(Exception e){
      }
      return null ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public boolean nextBoolean(){
      return Boolean.parseBoolean(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PetrAndBook {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : FastIO ; io := FastIO.newFastIO() ;
     var n : int ; n := io.nextInt() ;
    var day : int ; day := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,7)->collect(0) ;
        var i : int ; i := 0 ; while i < 7 do ( (     arr[i+1] := io.nextInt() )  ;     i := i + 1 ) ; 
    while (true) do (     n := n-(arr[day+1]) ; 
     if (n <= 0) then     break else skip ; 
     day := (day + 1) mod 7 ) ; 
    io.println(day + 1) ; 
    io.close() ; 
 );
  static class FastIO extends OclFile {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastIO() : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile["System.in"], OclFile["System.out"]) );
   static operation newFastIO( in : OclFile, out : OclFile) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(in, out);
    return self );
  operation initialise( in : OclFile, out : OclFile) : void
  pre: true  post: true
  activity: (     execute super(out) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   static operation newFastIO( problemName : String) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(problemName);
    return self );
  operation initialise( problemName : String) : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Write(problemName + ".out")) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(problemName + ".in")) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() )   catch (e : ProgramException) do skip
     return null );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : ProgramException) do skip
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextBoolean() : boolean
  pre: true
  post: true
  activity: (     return parseBoolean(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printArray(int arr[],int size){
    for(int i=0 ; i<size ; i++){
      System.out.printf("%d ",arr[i]);
    }
    System.out.printf("\n");
    return ;
  }
  static int getSuccessor(int arr[],int k,int n){
    int p=k-1 ;
    while(arr[p]==n){
      p--;
      if(p<0){
        break ;
      }
    }
    if(p<0){
      return 0 ;
    }
    arr[p]=arr[p]+1 ;
    for(int i=p+1 ; i<k ; i++){
      arr[i]=1 ;
    }
    return 1 ;
  }
  static void printSequences(int n,int k){
    int[] arr=new int[k];
    for(int i=0 ; i<k ; i++){
      arr[i]=1 ;
    }
    while(true){
      printArray(arr,k);
      if(getSuccessor(arr,k,n)==0){
        break ;
      }
    }
  }
  public static void main(String[] args){
    int n=3 ;
    int k=2 ;
    printSequences(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printArray( arr : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < size do ( (     OclFile["System.out"].printf("%d ", arr[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].printf("\n") ; 
     return );
  static   operation getSuccessor( arr : Sequence(int), k : int, n : int) : int
  pre: true
  post: true
  activity: (     var p : int ; p := k - 1 ;
     while (arr[p+1] = n) do (     p := p - 1 ; 
     if (p < 0) then (     break ) else skip ) ; 
    if (p < 0) then (     return 0 ) else skip ; 
    arr[p+1] := arr[p+1] + 1 ; 
        var i : int ; i := p + 1 ; while i < k do ( (     arr[i+1] := 1 )  ;     i := i + 1 ) ; 
    return 1 
 );
  static   operation printSequences( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,k)->collect(0) ;
         var i : int ; i := 0 ; while i < k do ( (     arr[i+1] := 1 )  ;     i := i + 1 ) ; 
     while (true) do (     execute printArray(arr, k) ; 
     if (getSuccessor(arr, k, n) = 0) then (     break ) else skip ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var k : int ; k := 2 ;
     execute printSequences(n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Solution {
  public int findUnsortedSubarray(int[] nums){
    Stack<Integer>stack=new Stack<Integer>();
    int l=nums.length,r=0 ;
    for(int i=0 ; i<nums.length ; i++){
      while(! stack.isEmpty()&& nums[stack.peek()]>nums[i])l=Math.min(l,stack.pop());
      stack.push(i);
    }
    stack.clear();
    for(int i=nums.length-1 ; i>=0 ; i--){
      while(! stack.isEmpty()&& nums[stack.peek()]<nums[i])r=Math.max(r,stack.pop());
      stack.push(i);
    }
    return r-l>0 ? r-l+1 : 0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation findUnsortedSubarray( nums : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var stack : Sequence(int) ; stack := Sequence{} ;
     var l : int ; l := nums->size() ;
    var r : int ; r := 0 ;
        var i : int ; i := 0 ; while i < nums->size() do ( (     while (not(stack->isEmpty()) & nums[stack->min()+1] > nums[i+1]) do     l := Set{l, stack->last()}->min() ; ; 
     stack := stack->append(i) )  ;     i := i + 1 ) ; 
    stack := stack->intersection(Set{}) ; 
        var i : int ; i := nums->size() - 1 ; while i >= 0 do ( (     while (not(stack->isEmpty()) & nums[stack->min()+1] < nums[i+1]) do     r := Set{r, stack->last()}->max() ; ; 
     stack := stack->append(i) )  ;     i := i - 1 ) ; 
    return if r - l > 0 then r - l + 1 else 0 endif 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] p=new int[n+1];
    for(int i=1 ; i<=n ; i++)p[i]=sc.nextInt();
    int[] root=new int[n+1];
    for(int i=1 ; i<=n ; i++)root[i]=i ;
    int[] size=new int[n+1];
    while(m-->0){
      int u=sc.nextInt();
      int v=sc.nextInt();
      union(root,size,u,v);
    }
    for(int i=1 ; i<=n ; i++)find(root,i);
    int cnt=0 ;
    for(int i=1 ; i<=n ; i++){
      if(p[i]==i || root[p[i] ]==root[i]){
        cnt++;
      }
    }
    System.out.println(cnt);
  }
  private static void union(int[] root,int[] size,int u,int v){
    int rootU=find(root,u);
    int rootV=find(root,v);
    if(rootU==rootV)return ;
    if(size[rootU]>size[rootV]){
      root[rootV]=rootU ;
      size[rootU]+=size[rootV];
    }
    else {
      root[rootU]=rootV ;
      size[rootV]+=size[rootU];
    }
  }
  private static int find(int[] root,int node){
    if(root[node]!=node){
      root[node]=find(root,root[node]);
    }
    return root[node];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     p[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var root : Sequence(int) ; root := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     root[i+1] := i ;  ;     i := i + 1 ) ; 
    var size : Sequence(int) ; size := Integer.subrange(1,n + 1)->collect(0) ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     var u : int ; u := sc.getCurrent()->toInteger() ;
     var v : int ; v := sc.getCurrent()->toInteger() ;
     execute union(root, size, u, v) ) ;  ) ;  
        var i : int ; i := 1 ; while i <= n do (     execute find(root, i) ;  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (p[i+1] = i or root[p[i+1]+1] = root[i+1]) then (     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
  static   operation union( root : Sequence(int), size : Sequence(int), u : int, v : int) : void
  pre: true
  post: true
  activity: (     var rootU : int ; rootU := find(root, u) ;
     var rootV : int ; rootV := find(root, v) ;
     if (rootU = rootV) then     return else skip ; 
     if (size[rootU+1] > size[rootV+1]) then (     root[rootV+1] := rootU ; 
     size[rootU+1] := size[rootU+1]+(size[rootV+1]) ) else (     root[rootU+1] := rootV ; 
     size[rootV+1] := size[rootV+1]+(size[rootU+1]) ) );
  static   operation find( root : Sequence(int), node : int) : int
  pre: true
  post: true
  activity: (     if (root[node+1] /= node) then (     root[node+1] := find(root, root[node+1]) ) else skip ; 
     return root[node+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static class UnionFind {
    private int[] parent ;
    public UnionFind(int n){
      parent=new int[n];
      for(int i=0 ; i<n ; i++){
        parent[i]=i ;
      }
    }
    private int root(int x){
      if(parent[x]==x){
        return x ;
      }
      return parent[x]=root(parent[x]);
    }
    private void unite(int x,int y){
      int rx=root(x);
      int ry=root(y);
      if(rx==ry){
        return ;
      }
      parent[rx]=ry ;
    }
    private boolean same(int x,int y){
      int rx=root(x);
      int ry=root(y);
      return rx==ry ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] p=new int[n];
    int[] x=new int[m];
    int[] y=new int[m];
    for(int i=0 ; i<n ; i++){
      p[i]=sc.nextInt();
    }
    for(int i=0 ; i<m ; i++){
      x[i]=sc.nextInt();
      y[i]=sc.nextInt();
    }
    UnionFind uf=new UnionFind(n);
    for(int i=0 ; i<m ; i++){
      uf.unite(x[i]-1,y[i]-1);
    }
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(uf.same(i,p[i]-1)){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class UnionFind {
   attribute parent : Sequence(int);
   static operation newUnionFind( n : int) : UnionFind
  pre: true
  post: true
  activity:
  ( var self : UnionFind ;
    self := createUnionFind();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     parent := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do ( (     parent[i+1] := i )  ;     i := i + 1 ) );
   operation root( x : int) : int
  pre: true
  post: true
  activity: (     if (parent[x+1] = x) then (     return x ) else skip ; 
     return parent[x+1] );
   operation unite( x : int, y : int) : void
  pre: true
  post: true
  activity: (     var rx : int ; rx := root(x) ;
     var ry : int ; ry := root(y) ;
     if (rx = ry) then (     return ) else skip ; 
     parent[rx+1] := ry );
   operation same( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     var rx : int ; rx := root(x) ;
     var ry : int ; ry := root(y) ;
     return rx = ry );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    var x : Sequence(int) ; x := Integer.subrange(1,m)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     y[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var uf : UnionFind ; uf := UnionFind.newUnionFind(n) ;
        var i : int ; i := 0 ; while i < m do ( (     uf.unite(x[i+1] - 1, y[i+1] - 1) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (uf.same(i, p[i+1] - 1)) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt(),m=scanner.nextInt();
      int[] q=new int[n];
      IntStream.range(0,n).forEach(i->q[scanner.nextInt()-1]=i);
      UnionFindTree uft=new UnionFindTree(n);
      IntStream.range(0,m).forEach(i->uft.union(scanner.nextInt()-1,scanner.nextInt()-1));
      System.out.println(IntStream.range(0,n).filter(i->uft.same(q[i],i)).count());
    }
  }
  private static class UnionFindTree {
    int[] parent ;
    int[] count ;
    UnionFindTree(int size){
      parent=new int[size];
      IntStream.range(0,size).forEach(i->parent[i]=i);
      count=new int[size];
      Arrays.fill(count,1);
    }
    int find(int x){
      if(parent[x]==x){
        return x ;
      }
      else {
        int v=find(parent[x]);
        parent[x]=v ;
        return v ;
      }
    }
    boolean same(int x,int y){
      return find(x)==find(y);
    }
    void union(int x,int y){
      int rootX=find(x);
      int rootY=find(y);
      if(rootX==rootY){
        return ;
      }
      parent[rootX]=rootY ;
      parent[x]=rootY ;
      count[rootY]+=count[rootX];
    }
    @ SuppressWarnings("unused")public int count(int x){
      return count[find(x)];
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
     var q : Sequence(int) ; q := Integer.subrange(1,n)->collect(0) ;
    for i : Integer.subrange(0, n-1) do
    (    q[scanner.getCurrent()->toInteger() - 1+1] := i) ; 
    var uft : UnionFindTree ; uft := UnionFindTree.newUnionFindTree(n) ;
    for i : Integer.subrange(0, m-1) do
    (    uft.union(scanner.getCurrent()->toInteger() - 1, scanner.getCurrent()->toInteger() - 1)) ; 
    OclFile["System.out"].println(Integer.subrange(0, n-1)->select( _x1 | (lambda i : OclAny in uft.same(q[i+1], i))->apply(_x1) )->size()) ; 
 ))  );
  static class UnionFindTree {
   attribute parent : Sequence(int);
   attribute count : Sequence(int);
   static operation newUnionFindTree( size : int) : UnionFindTree
  pre: true
  post: true
  activity:
  ( var self : UnionFindTree ;
    self := createUnionFindTree();
    self.initialise(size);
    return self );
  operation initialise( size : int) : void
  pre: true  post: true
  activity: (     parent := Integer.subrange(1,size)->collect(0) ; 
     for i : Integer.subrange(0, size-1) do
    (    parent[i+1] := i) ; 
     count := Integer.subrange(1,size)->collect(0) ; 
     count := count->collect(1) );
   operation find( x : int) : int
  pre: true
  post: true
  activity: (     if (parent[x+1] = x) then (     return x ) else (     var v : int ; v := find(parent[x+1]) ;
     parent[x+1] := v ; 
     return v ) );
   operation same( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return find(x) = find(y) );
   operation union( x : int, y : int) : void
  pre: true
  post: true
  activity: (     var rootX : int ; rootX := find(x) ;
     var rootY : int ; rootY := find(y) ;
    if (rootX = rootY) then (     return ) else skip ; 
    parent[rootX+1] := rootY ; 
    parent[x+1] := rootY ; 
    count[rootY+1] := count[rootY+1]+(count[rootX+1]) ; 
 );
      operation count( x : int) : int
  pre: true
  post: true
  activity: (     return count[find(x)+1] );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class UnionFind {
  int[] roots ;
  public UnionFind(int N){
    this.roots=new int[N];
    for(int i=0 ; i<N ; ++i)this.roots[i]=i ;
  }
  int getRoot(int x){
    if(this.roots[x]==x)return x ;
    else return this.roots[x]=getRoot(this.roots[x]);
  }
  boolean isSameSet(int x,int y){
    return getRoot(x)==getRoot(y);
  }
  void unite(int x,int y){
    if(getRoot(x)!=getRoot(y))roots[x]=y ;
  }
}
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    UnionFind uf=new UnionFind(N);
    int M=sc.nextInt();
    int[] p=new int[N];
    for(int i=0 ; i<N ; ++i)p[i]=sc.nextInt()-1 ;
    for(int i=0 ; i<M ; ++i){
      uf.unite(uf.getRoot(sc.nextInt()-1),sc.nextInt()-1);
    }
    int ans=0 ;
    for(int i=0 ; i<N ; ++i){
      if(uf.isSameSet(i,p[i]))++ans ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class UnionFind {
   attribute roots : Sequence(int);
   static operation newUnionFind( N : int) : UnionFind
  pre: true
  post: true
  activity:
  ( var self : UnionFind ;
    self := createUnionFind();
    self.initialise(N);
    return self );
  operation initialise( N : int) : void
  pre: true  post: true
  activity: (     self.roots := Integer.subrange(1,N)->collect(0) ; 
         var i : int ; i := 0 ; while i < N do (     self.roots[i+1] := i ;  ;     i := i + 1 ) );
   operation getRoot( x : int) : int
  pre: true
  post: true
  activity: (     if (self.roots[x+1] = x) then     return x else     return self.roots[x+1] );
   operation isSameSet( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return getRoot(x) = getRoot(y) );
   operation unite( x : int, y : int) : void
  pre: true
  post: true
  activity: (     if (getRoot(x) /= getRoot(y)) then     roots[x+1] := y ; else skip );
}
class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var uf : UnionFind ; uf := UnionFind.newUnionFind(N) ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     p[i+1] := sc.getCurrent()->toInteger() - 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     uf.unite(uf.getRoot(sc.getCurrent()->toInteger() - 1), sc.getCurrent()->toInteger() - 1) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (uf.isSameSet(i, p[i+1])) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static class Unionfind {
    private static int par[];
    public Unionfind(int n){
      par=new int[n];
      for(int i=0 ; i<n ; ++i)par[i]=i ;
    }
    public int root(int x){
      if(par[x]==x)return x ;
      return par[x]=root(par[x]);
    }
    public void unite(int x,int y){
      int rx=root(x);
      int ry=root(y);
      if(rx==ry)return ;
      par[rx]=ry ;
    }
    public boolean isSame(int x,int y){
      int rx=root(x);
      int ry=root(y);
      return rx==ry ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    int p[]=new int[n];
    for(int i=0 ; i<n ; ++i)p[i]=sc.nextInt();
    Unionfind union=new Unionfind(n);
    for(int i=0 ; i<m ; ++i){
      int x=sc.nextInt();
      int y=sc.nextInt();
      union.unite(p[x-1]-1,p[y-1]-1);
    }
    sc.close();
    int ans=0 ;
    for(int i=n-1 ; i>=0 ; --i){
      if(union.isSame(p[i]-1,i))ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Unionfind {
  static   attribute par : Sequence(int);
   static operation newUnionfind( n : int) : Unionfind
  pre: true
  post: true
  activity:
  ( var self : Unionfind ;
    self := createUnionfind();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     par := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do (     par[i+1] := i ;  ;     i := i + 1 ) );
   operation root( x : int) : int
  pre: true
  post: true
  activity: (     if (par[x+1] = x) then     return x else skip ; 
     return par[x+1] );
   operation unite( x : int, y : int) : void
  pre: true
  post: true
  activity: (     var rx : int ; rx := root(x) ;
     var ry : int ; ry := root(y) ;
     if (rx = ry) then     return else skip ; 
     par[rx+1] := ry );
   operation isSame( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     var rx : int ; rx := root(x) ;
     var ry : int ; ry := root(y) ;
     return rx = ry );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     p[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var union : Unionfind ; union := Unionfind.newUnionfind(n) ;
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     union.unite(p[x - 1+1] - 1, p[y - 1+1] - 1) )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (union.isSame(p[i+1] - 1, i)) then     ans := ans + 1 ; else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int t=sc.nextInt();
    while(t-->0){
      solve();
    }
  }
  public static void solve(){
    int n=sc.nextInt();
    char[] s1=sc.next().toCharArray();
    char[] s2=sc.next().toCharArray();
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(s2[i]=='0')continue ;
      else if(s1[i]=='0'){
++ans ;
      }
      else if(i-1>=0 && s1[i-1]=='1'){
        ans++;
      }
      else if(i+1<n && s1[i+1]=='1'){
        ans++;
        s1[i+1]='2' ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s1 : Sequence(String) ; s1 := sc.getCurrent()->characters() ;
    var s2 : Sequence(String) ; s2 := sc.getCurrent()->characters() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s2[i+1] = '0') then     continue else     if (s1[i+1] = '0') then (     ans := ans + 1 ) else     if (i - 1 >= 0 & s1[i - 1+1] = '1') then (     ans := ans + 1 ) else     if (i + 1 < n & s1[i + 1+1] = '1') then (     ans := ans + 1 ; 
     s1[i + 1+1] := '2' ) else skip ; ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.sql.Array ;
import java.util.*;
public class Main {
  static long gcd(long a,long b){
    return b>0 ? gcd(b,a % b): a ;
  }
  static long lcm(long a,long b){
    return a*b/gcd(a,b);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayList<Integer>arrayList=new ArrayList<Integer>();
    while(true){
      int a=sc.nextInt();
      String s=sc.next();
      int b=sc.nextInt();
      if(s.equals("+")){
        arrayList.add(a+b);
      }
      else if(s.equals("-")){
        arrayList.add(a-b);
      }
      else if(s.equals("/")){
        arrayList.add(a/b);
      }
      else if(s.equals("*")){
        arrayList.add(a*b);
      }
      else {
        break ;
      }
    }
    for(int i=0 ; i<arrayList.size(); i++){
      System.out.println(arrayList.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return if b > 0 then gcd(b, a mod b) else a endif );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return a * b / gcd(a, b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arrayList : Sequence(int) ; arrayList := Sequence{} ;
     while (true) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (s = "+") then (     arrayList := arrayList->including(a + b) ) else     if (s = "-") then (     arrayList := arrayList->including(a - (b)->char2byte()) ) else     if (s = "/") then (     arrayList := arrayList->including(a / b) ) else     if (s = "*") then (     arrayList := arrayList->including(a * b) ) else (     break ) ;  ;  ;  ) ; 
         var i : int ; i := 0 ; while i < arrayList->size() do ( (     OclFile["System.out"].println(arrayList->at(i+1)) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean checkUtil(int num,int dig,int base){
    if(dig==1 && num<base)return true ;
    if(dig>1 && num>=base)return checkUtil(num/base,--dig,base);
    return false ;
  }
  static boolean check(int num,int dig){
    for(int base=2 ; base<=32 ; base++)if(checkUtil(num,dig,base))return true ;
    return false ;
  }
  public static void main(String[] args){
    int num=8 ;
    int dig=3 ;
    if(check(num,dig))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkUtil( num : int, dig : int, base : int) : boolean
  pre: true
  post: true
  activity: (     if (dig = 1 & num < base) then     return true else skip ; 
     if (dig > 1 & num >= base) then     return checkUtil(num / base, (dig - 1), base) else skip ; 
     return false );
  static   operation check( num : int, dig : int) : boolean
  pre: true
  post: true
  activity: (         var base : int ; base := 2 ; while base <= 32 do (     if (checkUtil(num, dig, base)) then     return true else skip ;  ;     base := base + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 8 ;
     var dig : int ; dig := 3 ;
     if (check(num, dig)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p135 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p135().run());
  }
  private static final int LIMIT=Library.pow(10,6);
  public String run(){
    int[] solutions=new int[LIMIT];
    for(int m=1 ; m<LIMIT*2 ; m++){
      for(int k=m/5+1 ; k*2<m ; k++){
        long temp=(long)(m-k)*(k*5-m);
        if(temp>=solutions.length)break ;
        solutions[(int)temp]++;
      }
    }
    int count=0 ;
    for(int x : solutions){
      if(x==10)count++;
    }
    return Integer.toString(count);
  }
}
------------------------------------------------------------
OCL File:
---------
class p135 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p135.newp135().run()) );
  static    attribute LIMIT : int := Library.pow(10, 6);
   operation run() : String
  pre: true
  post: true
  activity: (     var solutions : Sequence(int) ; solutions := Integer.subrange(1,LIMIT)->collect(0) ;
         var m : int ; m := 1 ; while m < LIMIT * 2 do ( (         var k : int ; k := m / 5 + 1 ; while k * 2 < m do ( (     var temp : long ; temp := (m - k)->oclAsType(long) * (k * 5 - m) ;
     if (temp >= solutions->size()) then     break else skip ; 
     solutions[temp->oclAsType(int)+1] := solutions[temp->oclAsType(int)+1] + 1 )  ;     k := k + 1 ) )  ;     m := m + 1 ) ; 
    var count : int ; count := 0 ;
    for (x : solutions) do ( (     if (x = 10) then     count := count + 1 ; else skip )  ) ; 
    return ((count) + "") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Set ;
import java.util.HashSet ;
class GfG {
  static int countChanges(int arr[],int n){
    Set<Integer>s=new HashSet<>();
    for(int i=0 ; i<n ; i++)s.add(arr[i]);
    int count=0 ;
    for(int i=1 ; i<=n ; i++)if(! s.contains(i))count++;
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      8,55,22,1,3,22,4,5 };
      int n=arr.length ;
      System.out.println(countChanges(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation countChanges( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
         var i : int ; i := 0 ; while i < n do (     s := s->including(arr[i+1]) ;  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= n do (     if (not(s->includes(i))) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,55,22,1,3,22,4,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countChanges(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean Prime(int n){
    if(n<2)return false ;
    for(int i=2 ; i<=(int)Math.sqrt(n); i++)if(n % i==0)return false ;
    return true ;
  }
  static boolean primeCountDivisors(int n){
    if(n<2)return false ;
    for(int i=2 ; i<=(int)Math.sqrt(n); i++)if(n % i==0){
      long a=n,c=0 ;
      while(a % i==0){
        a/=i ;
        c++;
      }
      if(a==1 && Prime((int)c+1)==true)return true ;
      else return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    int n=13 ;
    if(primeCountDivisors(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Prime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n < 2) then     return false else skip ; 
         var i : int ; i := 2 ; while i <= (n)->sqrt()->oclAsType(int) do (     if (n mod i = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation primeCountDivisors( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n < 2) then     return false else skip ; 
         var i : int ; i := 2 ; while i <= (n)->sqrt()->oclAsType(int) do (     if (n mod i = 0) then (     var a : long ; a := n ;
    var c : long ; c := 0 ;
     while (a mod i = 0) do (     a := a/(i) ; 
     c := c + 1 ) ; 
     if (a = 1 & Prime(c->oclAsType(int) + 1) = true) then     return true else     return false ) else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 13 ;
     if (primeCountDivisors(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean sameJavaharAdj(char str[]){
    int n=str.length,i ;
    TreeSet<Character>st=new TreeSet<>();
    st.add(str[0]);
    for(i=1 ; i<n ; i++){
      if(str[i]==str[i-1]){
        continue ;
      }
      if(st.contains(str[i])&(str[i]!=st.last())){
        return false ;
      }
      st.add(str[i]);
    }
    return true ;
  }
  static int minSwaps(char str[],int l,int r,int cnt,int minm){
    if(l==r){
      if(sameJavaharAdj(str)){
        return cnt ;
      }
      else {
        return Integer.MAX_VALUE ;
      }
    }
    for(int i=l+1 ; i<=r ; i++){
      swap(str,i,l);
      cnt++;
      int x=minSwaps(str,l+1,r,cnt,minm);
      swap(str,i,l);
      cnt--;
      int y=minSwaps(str,l+1,r,cnt,minm);
      minm=Math.min(minm,Math.min(x,y));
    }
    return minm ;
  }
  static void swap(char[] arr,int i,int j){
    char temp=arr[i];
    arr[i]=arr[j];
    arr[j]=temp ;
  }
  public static void main(String[] args){
    String str="abbaacb" ;
    int n=str.length(),cnt=0,minm=Integer.MAX_VALUE ;
    System.out.print(minSwaps(str.toCharArray(),0,n-1,cnt,minm));
    ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sameJavaharAdj( str : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
    var i : int ;
     var st : Set(String) ; st := Set{} ;
    st := st->including(str[0+1]) ; 
        i := 1 ; while i < n do ( (     if (str[i+1] = str[i - 1+1]) then (     continue ) else skip ; 
     if (st->includes(str[i+1]) & (str[i+1] /= st->last())) then (     return false ) else skip ; 
     st := st->including(str[i+1]) )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation minSwaps( str : Sequence(String), l : int, r : int, cnt : int, minm : int) : int
  pre: true
  post: true
  activity: (     if (l = r) then (     if (sameJavaharAdj(str)) then (     return cnt ) else (     return 2147483647 ) ) else skip ; 
         var i : int ; i := l + 1 ; while i <= r do ( (     execute swap(str, i, l) ; 
     cnt := cnt + 1 ; 
    var x : int ; x := minSwaps(str, l + 1, r, cnt, minm) ;
    execute swap(str, i, l) ; 
    cnt := cnt - 1 ; 
    var y : int ; y := minSwaps(str, l + 1, r, cnt, minm) ;
    minm := Set{minm, Set{x, y}->min()}->min() ; 
 )  ;     i := i + 1 ) ; 
     return minm );
  static   operation swap( arr : Sequence(String), i : int, j : int) : void
  pre: true
  post: true
  activity: (     var temp : String ; temp := arr[i+1] ;
     arr[i+1] := arr[j+1] ; 
     arr[j+1] := temp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abbaacb" ;
     var n : int ; n := str->size() ;
    var cnt : int ; cnt := 0 ;
    var minm : int ; minm := 2147483647 ;
     OclFile["System.out"].print(minSwaps(str->characters(), 0, (n)->char2byte() - 1, cnt, minm)) ; 
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
class Main {
  static BigInteger gcd(BigInteger a,BigInteger b){
    while(!(a.equals(BigInteger.ZERO))){
      b=b.mod(a);
      BigInteger c=new BigInteger(a.toString());
      a=new BigInteger(b.toString());
      b=new BigInteger(c.toString());
    }
    return b ;
  }
  static BigInteger lcm(BigInteger a,BigInteger b){
    return a.multiply(b).divide(gcd(a,b));
  }
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    while(true){
      int a=s.nextInt();
      if(a==0)System.exit(0);
      BigInteger bi[]=new BigInteger[a];
      for(int i=0 ; i<a ; i++)bi[i]=BigInteger.ONE ;
      for(int i=0 ; i<a ; i++){
        BigInteger b=s.nextBigInteger();
        BigInteger c=s.nextBigInteger();
        bi[i]=bi[i] .multiply(b);
        for(int j=0 ; j<a ; j++)if(i!=j)bi[j]=bi[j] .multiply(c);
      }
      BigInteger res=BigInteger.ONE ;
      for(int i=0 ; i<a ; i++)res=lcm(res,bi[i]);
      for(int i=0 ; i<a ; i++)System.out.println(res.divide(bi[i]).toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     while (not((a = 0))) do (     b := b.mod(a) ; 
     var c : long ; c := long(a+"") ;
     a := long(b+"") ; 
     b := long(c+"") ) ; 
     return b );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return a.multiply(b).divide(gcd(a, b)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var a : int ; a := s.getCurrent()->toInteger() ;
     if (a = 0) then OclProcess.exit(0) ; else skip ; 
    var bi : Sequence(long) ; bi := Integer.subrange(1,a)->collect(null) ;
        var i : int ; i := 0 ; while i < a do (     bi[i+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a do ( (     var b : long ; b := s.nextBigInteger() ;
     var c : long ; c := s.nextBigInteger() ;
     bi[i+1] := bi[i+1].multiply(b) ; 
         var j : int ; j := 0 ; while j < a do (     if (i /= j) then     bi[j+1] := bi[j+1].multiply(c) ; else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : long ; res := 1 ;
        var i : int ; i := 0 ; while i < a do (     res := lcm(res, bi[i+1]) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a do (     OclFile["System.out"].println(res.divide(bi[i+1])+"") ;  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  static long gcd(int[] a){
    long gcd=a[0];
    for(int i=1 ; i<a.length ; i++){
      gcd=gcd(a[i],gcd);
    }
    return gcd ;
  }
  static long lcm(int[] a){
    long lcm=a[0];
    for(int i=1 ; i<a.length ; i++){
      lcm=lcm(lcm,a[i]);
    }
    return lcm ;
  }
  static long lcm(long m,long n){
    return(m*n)/gcd(m,n);
  }
  static long gcd(long m,long n){
    if(m<n){
      long tmp=m ;
      m=n ;
      n=tmp ;
    }
    if(n==0)return m ;
    return gcd(n,m % n);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] d=new int[n];
      int[] v=new int[n];
      for(int i=0 ; i<n ; i++){
        d[i]=sc.nextInt();
        v[i]=sc.nextInt();
        int T=(int)gcd(d[i],v[i]);
        d[i]=d[i]/T ;
        v[i]=v[i]/T ;
      }
      long dd=lcm(d);
      long vv=gcd(v);
      long T=dd/vv ;
      for(int i=0 ; i<n ; i++){
        System.out.println((v[i]/vv)*(dd/d[i]));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var gcd : long ; gcd := a[0+1] ;
         var i : int ; i := 1 ; while i < a->size() do ( (     gcd := gcd(a[i+1], gcd) )  ;     i := i + 1 ) ; 
     return gcd );
  static   operation lcm( a : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var lcm : long ; lcm := a[0+1] ;
         var i : int ; i := 1 ; while i < a->size() do ( (     lcm := lcm(lcm, a[i+1]) )  ;     i := i + 1 ) ; 
     return lcm );
  static   operation lcm( m : long, n : long) : long
  pre: true
  post: true
  activity: (     return (m * n) / gcd(m, n) );
  static   operation gcd( m : long, n : long) : long
  pre: true
  post: true
  activity: (     if (m < n) then (     var tmp : long ; tmp := m ;
     m := n ; 
     n := tmp ) else skip ; 
     if (n = 0) then     return m else skip ; 
     return gcd(n, m mod n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     d[i+1] := sc.getCurrent()->toInteger() ; 
     v[i+1] := sc.getCurrent()->toInteger() ; 
    var T : int ; T := gcd(d[i+1], v[i+1])->oclAsType(int) ;
    d[i+1] := d[i+1] / T ; 
    v[i+1] := v[i+1] / T ; 
 )  ;     i := i + 1 ) ; 
    var dd : long ; dd := lcm(d) ;
    var vv : long ; vv := gcd(v) ;
    var T : long ; T := dd / vv ;
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println((v[i+1] / vv) * (dd / d[i+1])) )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=parseInt(line);
      if(n==0)break ;
      long[] d=new long[n];
      long[] v=new long[n];
      for(int i=0 ; i<n ; i++){
        line=br.readLine();
        d[i]=parseInt(line.substring(0,line.indexOf(' ')));
        v[i]=parseInt(line.substring(line.indexOf(' ')+1));
      }
      for(int i=0 ; i<n ; i++){
        long gcd=gcd(d[i],v[i]);
        d[i]/=gcd ;
        v[i]/=gcd ;
      }
      long lcm=lcm(d[0],d[1]);
      for(int i=2 ; i<n ; i++){
        lcm=lcm(lcm,d[i]);
      }
      for(int i=0 ; i<n ; i++){
        v[i]*=lcm/d[i];
      }
      long gcd=gcd(v[0],v[1]);
      for(int i=2 ; i<n ; i++){
        gcd=gcd(gcd,v[i]);
      }
      for(int i=0 ; i<n ; i++){
        System.out.println(v[i]/gcd);
      }
    }
  }
  static long gcd(long a,long b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  static long lcm(long a,long b){
    return a*(b/gcd(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := parseInt(line) ;
     if (n = 0) then     break else skip ; 
    var d : Sequence(long) ; d := Integer.subrange(1,n)->collect(0) ;
    var v : Sequence(long) ; v := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     line := br.readLine() ; 
     d[i+1] := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
     v[i+1] := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var gcd : long ; gcd := gcd(d[i+1], v[i+1]) ;
     d[i+1] := d[i+1]/(gcd) ; 
     v[i+1] := v[i+1]/(gcd) )  ;     i := i + 1 ) ; 
    var lcm : long ; lcm := lcm(d[0+1], d[1+1]) ;
        var i : int ; i := 2 ; while i < n do ( (     lcm := lcm(lcm, d[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     v[i+1] := v[i+1]*(lcm / d[i+1]) )  ;     i := i + 1 ) ; 
    var gcd : long ; gcd := gcd(v[0+1], v[1+1]) ;
        var i : int ; i := 2 ; while i < n do ( (     gcd := gcd(gcd, v[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(v[i+1] / gcd) )  ;     i := i + 1 ) ; 
 ) ;     line := br.readLine() ;
 ) );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return a * (b / gcd(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.math.BigInteger ;
class Main {
  private static BigInteger gcd(BigInteger a,BigInteger b){
    if(a.mod(b).equals(BigInteger.ZERO)){
      return b ;
    }
    else {
      return gcd(b,a.mod(b));
    }
  }
  private static BigInteger lcm(BigInteger a,BigInteger b){
    BigInteger gcd=gcd(a,b);
    return a.multiply(b).divide(gcd);
  }
  private static void solve(){
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      if(n==0){
        break ;
      }
      BigInteger[][] dv=new BigInteger[n][2];
      for(int i=0 ; i<n ; i++){
        dv[i][0]=BigInteger.valueOf(scanner.nextInt());
        dv[i][1]=BigInteger.valueOf(scanner.nextInt());
      }
      BigInteger lcmV=dv[0][1];
      for(int i=1 ; i<n ; i++){
        lcmV=lcm(dv[i][1],lcmV);
      }
      for(int i=0 ; i<n ; i++){
        dv[i][0]=dv[i][0] .multiply(lcmV).divide(dv[i][1]);
      }
      BigInteger lcmD=dv[0][0];
      for(int i=1 ; i<n ; i++){
        lcmD=lcm(dv[i][0],lcmD);
      }
      for(int i=0 ; i<n ; i++){
        System.out.println(lcmD.divide(dv[i][0]));
      }
    }
  }
  public static void main(String...args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a.mod(b) = 0) then (     return b ) else (     return gcd(b, a.mod(b)) ) );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var gcd : long ; gcd := gcd(a, b) ;
     return a.multiply(b).divide(gcd) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var dv : Sequence(Sequence(long)) ; dv := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(null)) ;
        var i : int ; i := 0 ; while i < n do ( (     dv[i+1][0+1] := (scanner.getCurrent()->toInteger() + "")->toLong() ; 
     dv[i+1][1+1] := (scanner.getCurrent()->toInteger() + "")->toLong() )  ;     i := i + 1 ) ; 
    var lcmV : long ; lcmV := dv[0+1][1+1] ;
        var i : int ; i := 1 ; while i < n do ( (     lcmV := lcm(dv[i+1][1+1], lcmV) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     dv[i+1][0+1] := dv[i+1][0+1].multiply(lcmV).divide(dv[i+1][1+1]) )  ;     i := i + 1 ) ; 
    var lcmD : long ; lcmD := dv[0+1][0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     lcmD := lcm(dv[i+1][0+1], lcmD) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(lcmD.divide(dv[i+1][0+1])) )  ;     i := i + 1 ) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int INF=1<<24 ;
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] dis=new int[n];
      int[] v=new int[n];
      for(int i=0 ; i<n ; i++){
        dis[i]=sc.nextInt();
        v[i]=sc.nextInt();
      }
      long[] data=new long[n];
      data[0]=v[0];
      long m=dis[0];
      for(int i=1 ; i<n ; i++){
        long g=gcd(dis[i],v[i]);
        long dis1=dis[i]/g ;
        long v1=v[i]/g ;
        long l=lcm(m,dis1);
        for(int j=0 ; j<i ; j++){
          data[j]=data[j]*(l/m);
        }
        v1=v1*(l/dis1);
        data[i]=v1 ;
        m=l ;
      }
      long gg=data[0];
      for(int i=1 ; i<n ; i++){
        gg=gcd(gg,data[i]);
      }
      for(int i=0 ; i<n-1 ; i++){
        System.out.println(data[i]/gg);
      }
      System.out.println(data[n-1]/gg);
    }
  }
  private long lcm(long a,long b){
    return a/gcd(a,b)*b ;
  }
  private long gcd(long a,long b){
    if(b==0){
      return a ;
    }
    else {
      return gcd(b,a % b);
    }
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(24)))->oclAsType(long);
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var dis : Sequence(int) ; dis := Integer.subrange(1,n)->collect(0) ;
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     dis[i+1] := sc.getCurrent()->toInteger() ; 
     v[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var data : Sequence(long) ; data := Integer.subrange(1,n)->collect(0) ;
    data[0+1] := v[0+1] ; 
    var m : long ; m := dis[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     var g : long ; g := gcd(dis[i+1], v[i+1]) ;
     var dis1 : long ; dis1 := dis[i+1] / g ;
    var v1 : long ; v1 := v[i+1] / g ;
    var l : long ; l := lcm(m, dis1) ;
        var j : int ; j := 0 ; while j < i do ( (     data[j+1] := data[j+1] * (l / m) )  ;     j := j + 1 ) ; 
    v1 := v1 * (l / dis1) ; 
    data[i+1] := v1 ; 
    m := l ; 
 )  ;     i := i + 1 ) ; 
    var gg : long ; gg := data[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     gg := gcd(gg, data[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     OclFile["System.out"].println(data[i+1] / gg) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(data[n - 1+1] / gg) ; 
 ) );
   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return a / gcd(a, b) * b );
   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else (     return gcd(b, a mod b) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int previousFibonacci(int n){
    double a=n/((1+Math.sqrt(5))/2.0);
    return(int)Math.round(a);
  }
  public static void main(String[] args){
    int n=8 ;
    System.out.println(previousFibonacci(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation previousFibonacci( n : int) : int
  pre: true
  post: true
  activity: (     var a : double ; a := n / ((1 + (5)->sqrt()) / 2.0) ;
     return (a)->round()->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     OclFile["System.out"].println(previousFibonacci(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static int m=0 ;
  private static int x=0 ;
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    m=scan.nextInt();
    x=scan.nextInt();
    int[][] c=new int[n][m+1];
    for(int row=0 ; row<n ; row++){
      for(int line=0 ; line<=m ; line++){
        c[row][line]=scan.nextInt();
      }
    }
    int minPrice=-1 ;
    for(int all=1 ; all<Math.pow(2,n); all++){
      int price=0 ;
      String binary=Integer.toBinaryString(all);
      int[] level=new int[m];
      for(int row=0,choice=binary.length(); 0<choice ; choice--,row++){
        String judge=binary.substring(choice-1,choice);
        if(judge.equals("1")){
          price+=c[row][0];
          for(int line=0 ; line<m ; line++){
            level[line]+=c[row][line+1];
          }
        }
      }
      if(achieve(level)){
        if(minPrice>price || minPrice==-1){
          minPrice=price ;
        }
      }
    }
    System.out.println(minPrice);
  }
  private static boolean achieve(int[] level){
    for(int a=0 ; a<m ; a++){
      if(level[a]<x){
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute m : int := 0;
  static   attribute x : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    m := scan.getCurrent()->toInteger() ; 
    x := scan.getCurrent()->toInteger() ; 
    var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,n)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
        var row : int ; row := 0 ; while row < n do ( (         var line : int ; line := 0 ; while line <= m do ( (     c[row+1][line+1] := scan.getCurrent()->toInteger() )  ;     line := line + 1 ) )  ;     row := row + 1 ) ; 
    var minPrice : int ; minPrice := -1 ;
        var all : int ; all := 1 ; while all < 2->pow(n) do ( (     var price : int ; price := 0 ;
     var binary : String ; binary := (MathLib.decimal2binary(all) + "") ;
    var level : Sequence(int) ; level := Integer.subrange(1,m)->collect(0) ;
        var row : int ; row := 0 ;
    var choice : int ; choice := binary->size() ; while 0 < choice do ( (     var judge : String ; judge := binary.subrange(choice - 1+1,choice) ;
     if (judge = "1") then (     price := price+(c[row+1][0+1]) ; 
         var line : int ; line := 0 ; while line < m do ( (     level[line+1] := level[line+1]+(c[row+1][line + 1+1]) )  ;     line := line + 1 ) ) else skip )  ;     choice := choice - 1 ;     row := row + 1 ) ; 
    if (achieve(level)) then (     if (minPrice > price or minPrice = -1) then (     minPrice := price ) else skip ) else skip ; 
 )  ;     all := all + 1 ) ; 
    OclFile["System.out"].println(minPrice) ; 
 );
  static   operation achieve( level : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var a : int ; a := 0 ; while a < m do ( (     if (level[a+1] < x) then (     return false ) else skip )  ;     a := a + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.fill ;
public class Main {
  public static void main(String[] args)throws IOException {
    run();
    end();
  }
  static void run()throws IOException {
    long h=nextLong();
    int count=0 ;
    long i=1 ;
    for(; i*i<=h ; ++i)if(h % i==0)count+=2 ;
--i ;
    if(i*i==h)--count ;
    out.println(count);
  }
  static void end(){
    out.flush();
    out.close();
  }
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter out=new PrintWriter(System.out);
  static StringTokenizer in=new StringTokenizer("");
  public static String nextToken()throws IOException {
    while(in==null || ! in.hasMoreTokens()){
      String s=br.readLine();
      if(s==null)return null ;
      in=new StringTokenizer(s);
    }
    return in.nextToken();
  }
  public static int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public static double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  public static long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute run() ; 
     execute end() );
  static   operation run() : void
  pre: true
  post: true
  activity: (     var h : long ; h := nextLong() ;
     var count : int ; count := 0 ;
    var i : long ; i := 1 ;
      while i * i <= h do (     if (h mod i = 0) then     count := count+(2) ; else skip ;  ;     i := i + 1 ) ; 
    i := i - 1 ; 
    if (i * i = h) then     count := count - 1 ; else skip ; 
    out.println(count) ; 
 );
  static   operation end() : void
  pre: true
  post: true
  activity: (     out.flush() ; 
     out.close() );
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclIterator := OclIterator.newOclIterator_String("");
  static   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (in = null or not(in.hasNext())) do (     var s : String ; s := br.readLine() ;
     if (s = null) then     return null else skip ; 
     in := OclIterator.newOclIterator_String(s) ) ; 
     return in.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printIndex(String str,String s){
    boolean flag=false ;
    for(int i=0 ; i<str.length()-s.length()+1 ; i++){
      if(str.substring(i,i+s.length()).equals(s)){
        System.out.print(i+" ");
        flag=true ;
      }
    }
    if(flag==false){
      System.out.println("NONE");
    }
  }
  public static void main(String[] args){
    String str1="GeeksforGeeks" ;
    String str2="Geeks" ;
    printIndex(str1,str2);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printIndex( str : String, s : String) : void
  pre: true
  post: true
  activity: (     var flag : boolean ; flag := false ;
         var i : int ; i := 0 ; while i < str->size() - s->size() + 1 do ( (     if (str.subrange(i+1,i + s->size()) = s) then (     OclFile["System.out"].print(i + " ") ; 
     flag := true ) else skip )  ;     i := i + 1 ) ; 
     if (flag = false) then (     OclFile["System.out"].println("NONE") ) else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "GeeksforGeeks" ;
     var str2 : String ; str2 := "Geeks" ;
     execute printIndex(str1, str2) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int mod=1000000007 ;
  static int[][] dp=new int[1000][1000];
  static int calculate(int pos,int prev,String s,Vector<Integer>index){
    if(pos==s.length())return 1 ;
    if(dp[pos][prev]!=-1)return dp[pos][prev];
    int answer=0 ;
    for(int i=0 ; i<index.size(); i++){
      if(index.get(i).compareTo(prev)>=0){
        answer=(answer % mod+calculate(pos+1,index.get(i),s,index)% mod)% mod ;
      }
    }
    return dp[pos][prev]=answer ;
  }
  static int countWays(Vector<String>a,String s){
    int n=a.size();
    Vector<Integer>[] index=new Vector[26];
    for(int i=0 ; i<26 ; i++)index[i]=new Vector<Integer>();
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<a.get(i).length(); j++){
        index[a.get(i).charAt(j)-'a'] .add(j+1);
      }
    }
    for(int i=0 ; i<1000 ; i++){
      for(int j=0 ; j<1000 ; j++){
        dp[i][j]=-1 ;
      }
    }
    return calculate(0,0,s,index[0]);
  }
  public static void main(String[] args){
    Vector<String>A=new Vector<String>();
    A.add("adc");
    A.add("aec");
    A.add("erg");
    String S="ac" ;
    System.out.print(countWays(A,S));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute mod : int := 1000000007;
  static   attribute dp : Sequence(Sequence(int)) := Integer.subrange(1,1000)->collect(Integer.subrange(1,1000)->collect(0));
  static   operation calculate( pos : int, prev : int, s : String, index : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (pos = s->size()) then     return 1 else skip ; 
     if (dp[pos+1][prev+1] /= -1) then     return dp[pos+1][prev+1] else skip ; 
    var answer : int ; answer := 0 ;
        var i : int ; i := 0 ; while i < index->size() do ( (     if (index->at(i+1)->compareTo(prev) >= 0) then (     answer := (answer mod mod + calculate(pos + 1, index->at(i+1), s, index) mod mod) mod mod ) else skip )  ;     i := i + 1 ) ; 
    return dp[pos+1][prev+1] 
 );
  static   operation countWays( a : Sequence(String), s : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() ;
     var index : Sequence(Sequence(int)) ; index := Integer.subrange(1,26)->collect(null) ;
        var i : int ; i := 0 ; while i < 26 do (     index[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < a->at(i+1)->size() do ( (     index[a->at(i+1)->at(j+1) - ('a')->char2byte()+1]->excludes(j + 1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 1000 do ( (         var j : int ; j := 0 ; while j < 1000 do ( (     dp[i+1][j+1] := -1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return calculate(0, 0, s, index[0+1]) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(String) ; A := Sequence{} ;
     A := A->including("adc") ; 
    A := A->including("aec") ; 
    A := A->including("erg") ; 
    var S : String ; S := "ac" ;
    OclFile["System.out"].print(countWays(A, S)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static float sumOfSeries(int x,int k){
    float y=(float)(((float)(x)/81)*(9*k-1+Math.pow(10,(-1)*k)));
    return y ;
  }
  public static void main(String args[]){
    int x=9 ;
    int k=20 ;
    System.out.println(sumOfSeries(x,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumOfSeries( x : int, k : int) : double
  pre: true
  post: true
  activity: (     var y : double ; y := (((x)->oclAsType(double) / 81) * (9 * k - 1 + 10->pow((-1) * k)))->oclAsType(double) ;
     return y );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 9 ;
     var k : int ; k := 20 ;
     OclFile["System.out"].println(sumOfSeries(x, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPerfectCubeString(String str){
    int sum=0 ;
    for(int i=0 ; i<str.length(); i++)sum+=(int)str.charAt(i);
    double cr=Math.round(Math.cbrt(sum));
    return(cr*cr*cr==sum);
  }
  public static void main(String[] args){
    String str="ll" ;
    if(isPerfectCubeString(str))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPerfectCubeString( str : String) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < str->size() do (     sum := sum+(str->at(i+1)->oclAsType(int)) ;  ;     i := i + 1 ) ; 
     var cr : double ; cr := ((sum)->cbrt())->round() ;
     return (cr * cr * cr = sum) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "ll" ;
     if (isPerfectCubeString(str)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static float findRadiusOfcircumcircle(float l,float b){
    if(l<0 || b<0)return-1 ;
    float radius=(float)Math.sqrt(Math.pow(l,2)+Math.pow(b,2))/2 ;
    return radius ;
  }
  public static void main(String args[]){
    float l=4,b=3 ;
    System.out.println(findRadiusOfcircumcircle(l,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findRadiusOfcircumcircle( l : double, b : double) : double
  pre: true
  post: true
  activity: (     if (l < 0 or b < 0) then     return -1 else skip ; 
     var radius : double ; radius := (l->pow(2) + b->pow(2))->sqrt()->oclAsType(double) / 2 ;
     return radius );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : double ; l := 4 ;
    var b : double ; b := 3 ;
     OclFile["System.out"].println(findRadiusOfcircumcircle(l, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=1000 ;
  static boolean lineExists(int x[],int y[],int v[],int n){
    int size=(2*MAX)+1 ;
    long[] arr=new long[size];
    for(int i=0 ; i<n ; i++){
      arr[x[i]+MAX]+=v[i];
    }
    for(int i=1 ; i<size ; i++)arr[i]+=arr[i-1];
    if(arr[size-1]==0)return true ;
    if(arr[size-1]-arr[0]==0)return true ;
    for(int i=1 ; i<size-1 ; i++){
      if(arr[i-1]==arr[size-1]-arr[i-1])return true ;
      if(arr[i-1]==arr[size-1]-arr[i])return true ;
      if(arr[i]==arr[size-1]-arr[i])return true ;
    }
    if(arr[size-2]==0)return true ;
    return false ;
  }
  public static void main(String[] args){
    int x[]={
-3,5,8 };
      int y[]={
        8,7,9 };
        int v[]={
          8,2,10 };
          int n=x.length ;
          if(lineExists(x,y,v,n))System.out.printf("Yes");
          else System.out.printf("No");
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 1000;
  static   operation lineExists( x : Sequence(int), y : Sequence(int), v : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var size : int ; size := (2 * MAX) + 1 ;
     var arr : Sequence(long) ; arr := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[x[i+1] + MAX+1] := arr[x[i+1] + MAX+1]+(v[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < size do (     arr[i+1] := arr[i+1]+(arr[i - 1+1]) ;  ;     i := i + 1 ) ; 
    if (arr[size - 1+1] = 0) then     return true else skip ; 
    if (arr[size - 1+1] - arr[0+1] = 0) then     return true else skip ; 
        var i : int ; i := 1 ; while i < size - 1 do ( (     if (arr[i - 1+1] = arr[size - 1+1] - arr[i - 1+1]) then     return true else skip ; 
     if (arr[i - 1+1] = arr[size - 1+1] - arr[i+1]) then     return true else skip ; 
     if (arr[i+1] = arr[size - 1+1] - arr[i+1]) then     return true else skip )  ;     i := i + 1 ) ; 
    if (arr[size - 2+1] = 0) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : Sequence(int) ; x := Sequence{-3,5,8} ;
     var y : Sequence(int) ; y := Sequence{8,7,9} ;
    var v : Sequence(int) ; v := Sequence{8,2,10} ;
    var n : int ; n := x->size() ;
    if (lineExists(x, y, v, n)) then     OclFile["System.out"].printf("Yes") else     OclFile["System.out"].printf("No") ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void shortestLength(int n,int x[],int y[]){
    int answer=0 ;
    int i=0 ;
    while(n!=0 && i<x.length){
      if(x[i]+y[i]>answer)answer=x[i]+y[i];
      i++;
    }
    System.out.println("Length->"+answer);
    System.out.println("Path->"+"(1,"+answer+")"+"and("+answer+",1)");
  }
  public static void main(String[] args){
    int n=4 ;
    int x[]=new int[] {
      1,4,2,1 };
      int y[]=new int[] {
        4,1,1,2 };
        shortestLength(n,x,y);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation shortestLength( n : int, x : Sequence(int), y : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var answer : int ; answer := 0 ;
     var i : int ; i := 0 ;
    while (n /= 0 & i < x->size()) do (     if (x[i+1] + y[i+1] > answer) then     answer := x[i+1] + y[i+1] ; else skip ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println("Length->" + answer) ; 
    OclFile["System.out"].println("Path->" + "(1," + answer + ")" + "and(" + answer + ",1)") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var x : Sequence(int) ; x := Sequence{1,4,2,1} ;
     var y : Sequence(int) ; y := Sequence{4,1,1,2} ;
     execute shortestLength(n, x, y) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] origin=br.readLine().split("");
    String[] serch=br.readLine().split("");
    for(int i=0 ; i<origin.length ; i++){
      if(origin[i] .equals(serch[0])){
        int ans=i ;
        int wordlength=0 ;
        for(int j=0 ; j<serch.length ; j++){
          if(i+j<origin.length){
            if(serch[j] .equals(origin[i+j])){
              wordlength++;
            }
          }
        }
        if(wordlength==serch.length){
          System.out.println(ans);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var origin : Sequence(String) ; origin := br.readLine()->split("") ;
     var serch : Sequence(String) ; serch := br.readLine()->split("") ;
         var i : int ; i := 0 ; while i < origin->size() do ( (     if (origin[i+1] = serch[0+1]) then (     var ans : int ; ans := i ;
     var wordlength : int ; wordlength := 0 ;
         var j : int ; j := 0 ; while j < serch->size() do ( (     if (i + j < origin->size()) then (     if (serch[j+1] = origin[i + j+1]) then (     wordlength := wordlength + 1 ) else skip ) else skip )  ;     j := j + 1 ) ; 
     if (wordlength = serch->size()) then (     OclFile["System.out"].println(ans) ) else skip ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  private static FastScanner sc=new FastScanner();
  public static void main(String[] args){
    char[] S=sc.next().toCharArray();
    char[] P=sc.next().toCharArray();
    int n=S.length ;
    int m=P.length ;
    int[] T=new int[m+1];
    T[0]=-1 ;
    T[1]=0 ;
    int i=2 ;
    int j=0 ;
    while(i<=m){
      if(P[i-1]==P[j]){
        T[i]=j+1 ;
        i++;
        j++;
      }
      else if(j>0){
        j=T[j];
      }
      else {
        T[i]=0 ;
        i++;
      }
    }
    i=0 ;
    j=0 ;
    while(i+j<n){
      if(P[j]==S[i+j]){
        j++;
        if(j==m){
          System.out.println(i);
        }
        else {
          continue ;
        }
      }
      i=i+j-T[j];
      if(j>0){
        j=T[j];
      }
    }
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : FastScanner := FastScanner.newFastScanner();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : Sequence(String) ; S := sc.next()->characters() ;
     var P : Sequence(String) ; P := sc.next()->characters() ;
    var n : int ; n := S->size() ;
    var m : int ; m := P->size() ;
    var T : Sequence(int) ; T := Integer.subrange(1,m + 1)->collect(0) ;
    T[0+1] := -1 ; 
    T[1+1] := 0 ; 
    var i : int ; i := 2 ;
    var j : int ; j := 0 ;
    while (i <= m) do (     if (P[i - 1+1] = P[j+1]) then (     T[i+1] := j + 1 ; 
     i := i + 1 ; 
     j := j + 1 ) else     if (j > 0) then (     j := T[j+1] ) else (     T[i+1] := 0 ; 
     i := i + 1 ) ;  ) ; 
    i := 0 ; 
    j := 0 ; 
    while (i + j < n) do (     if (P[j+1] = S[i + j+1]) then (     j := j + 1 ; 
     if (j = m) then (     OclFile["System.out"].println(i) ) else (     continue ) ) else skip ; 
     i := i + j - T[j+1] ; 
     if (j > 0) then (     j := T[j+1] ) else skip ) ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Map ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    solve(System.in,System.out);
  }
  static void solve(InputStream is,PrintStream os){
    Scanner scan=new Scanner(is);
    int N=scan.nextInt();
    int M=scan.nextInt();
    int X=scan.nextInt();
    int C[]=new int[N];
    int A[][]=new int[N][M];
    for(int i=0 ; i<N ; i++){
      C[i]=scan.nextInt();
      for(int j=0 ; j<M ; j++){
        A[i][j]=scan.nextInt();
      }
    }
    int ans=Integer.MAX_VALUE ;
    for(int bit=0 ; bit<(1<<N); bit++){
      int sum[]=new int[M];
      int cost=0 ;
      for(int i=0 ; i<N ; ++i){
        if((bit &(1<<i))>0){
          cost+=C[i];
          for(int j=0 ; j<M ; j++){
            sum[j]+=A[i][j];
          }
        }
      }
      boolean isSatisfy=true ;
      for(int i=0 ; i<M ; i++){
        if(sum[i]<X){
          isSatisfy=false ;
          break ;
        }
      }
      if(isSatisfy){
        ans=Math.min(ans,cost);
      }
    }
    if(ans==Integer.MAX_VALUE)os.println(-1);
    else os.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation solve( is : OclFile, os : OclFile) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(is) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var M : int ; M := scan.getCurrent()->toInteger() ;
    var X : int ; X := scan.getCurrent()->toInteger() ;
    var C : Sequence(int) ; C := Integer.subrange(1,N)->collect(0) ;
    var A : Sequence(Sequence(int)) ; A := Integer.subrange(1,N)->collect(Integer.subrange(1,M)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     C[i+1] := scan.getCurrent()->toInteger() ; 
         var j : int ; j := 0 ; while j < M do ( (     A[i+1][j+1] := scan.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
        var bit : int ; bit := 0 ; while bit < ((1*(2->pow(N)))->oclAsType(long)) do ( (     var sum : Sequence(int) ; sum := Integer.subrange(1,M)->collect(0) ;
     var cost : int ; cost := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if ((MathLib.bitwiseAnd(bit,((1*(2->pow(i)))->oclAsType(long)))) > 0) then (     cost := cost+(C[i+1]) ; 
         var j : int ; j := 0 ; while j < M do ( (     sum[j+1] := sum[j+1]+(A[i+1][j+1]) )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    var isSatisfy : boolean ; isSatisfy := true ;
        var i : int ; i := 0 ; while i < M do ( (     if (sum[i+1] < X) then (     isSatisfy := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (isSatisfy) then (     ans := Set{ans, cost}->min() ) else skip ; 
 )  ;     bit := bit + 1 ) ; 
    if (ans = 2147483647) then     os.println(-1) else     os.println(ans) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
class Edge {
  int to ;
  int cost ;
  Edge(int to,int cost){
    this.to=to ;
    this.cost=cost ;
  }
}
class Pair implements Comparable<Pair>{
  int dist ;
  int index ;
  Pair(int dist,int index){
    this.dist=dist ;
    this.index=index ;
  }
  public int compareTo(Pair p2){
    return dist-p2.dist ;
  }
}
public class Main {
  static final int INF=2000000000 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String t=sc.next();
    String p=sc.next();
    for(int i=0 ; i<=t.length()-p.length(); i++){
      if(t.substring(i,i+p.length()).equals(p)){
        System.out.println(i);
      }
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Edge {
   attribute to : int;
   attribute cost : int;
   static operation newEdge( to : int, cost : int) : Edge
  pre: true
  post: true
  activity:
  ( var self : Edge ;
    self := createEdge();
    self.initialise(to, cost);
    return self );
  operation initialise( to : int, cost : int) : void
  pre: true  post: true
  activity: (     self.to := to ; 
     self.cost := cost );
}
class Pair implements Comparable<Map> {
   attribute dist : int;
   attribute index : int;
   static operation newPair( dist : int, index : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(dist, index);
    return self );
  operation initialise( dist : int, index : int) : void
  pre: true  post: true
  activity: (     self.dist := dist ; 
     self.index := index );
   operation compareTo( p2 : Map) : int
  pre: true
  post: true
  activity: (     return dist - p2.dist );
}
class Main {
  static    attribute INF : int := 2000000000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : String ; t := sc.getCurrent() ;
    var p : String ; p := sc.getCurrent() ;
        var i : int ; i := 0 ; while i <= t->size() - p->size() do ( (     if (t.subrange(i+1,i + p->size()) = p) then (     OclFile["System.out"].println(i) ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.TreeMap ;
import java.util.TreeSet ;
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Stack ;
import java.util.Set ;
public class q {
  static Scanner scn=new Scanner(System.in);
  static int mod=1000000007 ;
  static int count=0 ;
  public static void main(String[] args){
    long n,k,l,m,y=0 ;
    n=scn.nextLong();
    for(int i=1 ; i<=Math.sqrt(n); i++){
      if(n % i==0)y++;
      if(n %(n/i)==0 && n/i!=i)y++;
    }
    System.out.println(y);
  }
  public static void forloop(int st,int en,int arr[]){
    for(int i=st ; i<en ; i++)arr[i]=scn.nextInt();
  }
  public static int gcd(int a,int b){
    if(a==0)return b ;
    int l=gcd(b % a,a);
    return l ;
  }
  public static void permu(String str,String ans){
    if(str.length()==0){
      System.out.println(ans+" ");
      return ;
    }
    for(int i=0 ; i<str.length(); i++){
      char ch=str.charAt(i);
      String res=str.substring(0,i)+str.substring(i+1);
      permu(res,ans+ch);
    }
  }
  public static String factorial(int n){
    BigInteger fact=new BigInteger("1");
    for(int i=1 ; i<=n ; i++){
      fact=fact.multiply(new BigInteger(i+""));
    }
    return fact.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class q {
  static   attribute scn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute mod : int := 1000000007;
  static   attribute count : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ;
    var k : long ;
    var l : long ;
    var m : long ;
    var y : long ; y := 0 ;
     n := scn.getCurrent()->toLong() ; 
         var i : int ; i := 1 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then     y := y + 1 ; else skip ; 
     if (n mod (n / i) = 0 & n / i /= i) then     y := y + 1 ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(y) );
  static   operation forloop( st : int, en : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := st ; while i < en do (     arr[i+1] := scn.getCurrent()->toInteger() ;  ;     i := i + 1 ) );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     var l : int ; l := gcd(b mod a, a) ;
     return l );
  static   operation permu( str : String, ans : String) : void
  pre: true
  post: true
  activity: (     if (str->size() = 0) then (     OclFile["System.out"].println(ans + " ") ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < str->size() do ( (     var ch : String ; ch := str->at(i+1) ;
     var res : String ; res := str.subrange(0+1,i) + str.subrange(i + 1+1,i + 1) ;
     execute permu(res, ans + ch) )  ;     i := i + 1 ) );
  static   operation factorial( n : int) : String
  pre: true
  post: true
  activity: (     var fact : long ; fact := long("1") ;
         var i : int ; i := 1 ; while i <= n do ( (     fact := fact.multiply(long(i + "")) )  ;     i := i + 1 ) ; 
     return fact+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static boolean find(String w,String t,int i){
    int j=0 ;
    while(j<w.length()){
      if(i>=t.length())return false ;
      if(w.charAt(j)!=t.charAt(i))return false ;
      i++;
      j++;
    }
    return true ;
  }
  public static void count(String w,String t){
    int i=0 ;
    boolean found=false ;
    while(i<t.length()){
      if(t.charAt(i)==w.charAt(0)){
        found=find(w,t,i);
        if(find(w,t,i))System.out.println(i);
      }
      i++;
    }
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    String text=s.nextLine();
    String w=s.next();
    s.close();
    count(w,text);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation find( w : String, t : String, i : int) : boolean
  pre: true
  post: true
  activity: (     var j : int ; j := 0 ;
     while (j < w->size()) do (     if (i >= t->size()) then     return false else skip ; 
     if (w->at(j+1) /= t->at(i+1)) then     return false else skip ; 
     i := i + 1 ; 
     j := j + 1 ) ; 
     return true );
  static   operation count( w : String, t : String) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var found : boolean ; found := false ;
     while (i < t->size()) do (     if (t->at(i+1) = w->at(0+1)) then (     found := find(w, t, i) ; 
     if (find(w, t, i)) then     OclFile["System.out"].println(i) ; else skip ) else skip ; 
     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var text : String ; text := s.nextLine() ;
    var w : String ; w := s.getCurrent() ;
    skip ; 
    execute count(w, text) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str1=br.readLine();
    String str2=br.readLine();
    int[] x=new int[4];
    LinkedList list=new LinkedList();
    if(str1.length()<str2.length()){
      return ;
    }
    else if(str1.indexOf(str2)==-1){
      return ;
    }
    else if(str1.equals(str2)){
      System.out.println("0");
      return ;
    }
    list.insert(str1.indexOf(str2));
    while(str1.indexOf(str2,list.getData()+1)!=-1){
      list.insert(str1.indexOf(str2,list.getData()+1));
    }
    System.out.print(list.toString());
  }
}
class Room {
  Room prev ;
  Room next ;
  int data ;
  public Room(int data){
    this.data=data ;
    prev=null ;
    next=null ;
  }
}
class LinkedList {
  Room head ;
  Room leg ;
  public LinkedList(){
    head=new Room(0);
    head.next=head ;
    head.prev=head ;
    leg=head ;
  }
  void insert(int data){
    Room x=new Room(data);
    x.prev=head ;
    x.next=head.next ;
    head.next.prev=x ;
    head.next=x ;
    leg=head.prev ;
  }
  public int getData(){
    Room p=head.next ;
    return p.data ;
  }
  public String toString(){
    StringBuilder st=new StringBuilder();
    for(Room p=head.prev ; p!=head ; p=p.prev){
      st.append(p.data+"\r\n");
    }
    return st.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str1 : String ; str1 := br.readLine() ;
    var str2 : String ; str2 := br.readLine() ;
    var x : Sequence(int) ; x := Integer.subrange(1,4)->collect(0) ;
    var list : Sequence ; list := Sequence{} ;
    if (str1->size() < str2->size()) then (     return ) else     if (str1->indexOf(str2)-1 = -1) then (     return ) else     if (str1 = str2) then (     OclFile["System.out"].println("0") ; 
     return ) else skip ; ;  ;  
    list := list.insert(str1->indexOf(str2)-1) ; 
    while (str1.subrange(list.getData() + 1+1)->indexOf(str2+"") + list.getData() + 1 - 1  /= -1) do (     list := list.insert(str1.subrange(list.getData() + 1+1)->indexOf(str2+"") + list.getData() + 1 - 1 ) ) ; 
    OclFile["System.out"].print(list+"") ; 
 );
}
class Room {
   attribute prev : Room;
   attribute next : Room;
   attribute data : int;
   static operation newRoom( data : int) : Room
  pre: true
  post: true
  activity:
  ( var self : Room ;
    self := createRoom();
    self.initialise(data);
    return self );
  operation initialise( data : int) : void
  pre: true  post: true
  activity: (     self.data := data ; 
     prev := null ; 
     next := null );
}
class LinkedList {
   attribute head : Room;
   attribute leg : Room;
   static operation newLinkedList() : LinkedList
  pre: true
  post: true
  activity:
  ( var self : LinkedList ;
    self := createLinkedList();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     head := Room.newRoom(0) ; 
     head.next := head ; 
     head.prev := head ; 
     leg := head );
   operation insert( data : int) : void
  pre: true
  post: true
  activity: (     var x : Room ; x := Room.newRoom(data) ;
     x.prev := head ; 
    x.next := head.next ; 
    head.next.prev := x ; 
    head.next := x ; 
    leg := head.prev ; 
 );
   operation getData() : int
  pre: true
  post: true
  activity: (     var p : Room ; p := head.next ;
     return p.data );
   operation toString() : String
  pre: true
  post: true
  activity: (     var st : String ; st := StringLib.newString() ;
         var p : Room ; p := head.prev ; while p /= head do ( (     st := st + StringLib.newString(p.data + "\r\n") )  ;     p := p.prev ) ; 
     return st+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printValue(char digit){
    switch(digit){
      case '0' : System.out.print("Zero ");
      break ;
      case '1' : System.out.print("One ");
      break ;
      case '2' : System.out.print("Two ");
      break ;
      case '3' : System.out.print("Three ");
      break ;
      case '4' : System.out.print("Four ");
      break ;
      case '5' : System.out.print("Five ");
      break ;
      case '6' : System.out.print("Six ");
      break ;
      case '7' : System.out.print("Seven ");
      break ;
      case '8' : System.out.print("Eight ");
      break ;
      case '9' : System.out.print("Nine ");
      break ;
    }
  }
  static void printWord(String N){
    int i,length=N.length();
    for(i=0 ; i<length ; i++){
      printValue(N.charAt(i));
    }
  }
  public static void main(String[] args){
    String N="123" ;
    printWord(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printValue( digit : String) : void
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (digit) ; 
       if _switchval = '0' then
     OclFile["System.out"].print("Zero ") ; 
    break 
   else skip ;
       if _switchval = '1' then
     OclFile["System.out"].print("One ") ; 
    break 
   else skip ;
       if _switchval = '2' then
     OclFile["System.out"].print("Two ") ; 
    break 
   else skip ;
       if _switchval = '3' then
     OclFile["System.out"].print("Three ") ; 
    break 
   else skip ;
       if _switchval = '4' then
     OclFile["System.out"].print("Four ") ; 
    break 
   else skip ;
       if _switchval = '5' then
     OclFile["System.out"].print("Five ") ; 
    break 
   else skip ;
       if _switchval = '6' then
     OclFile["System.out"].print("Six ") ; 
    break 
   else skip ;
       if _switchval = '7' then
     OclFile["System.out"].print("Seven ") ; 
    break 
   else skip ;
       if _switchval = '8' then
     OclFile["System.out"].print("Eight ") ; 
    break 
   else skip ;
       if _switchval = '9' then
     OclFile["System.out"].print("Nine ") ; 
    break 
   else skip ;
 )
 );
  static   operation printWord( N : String) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var length : int ; length := N->size() ;
         i := 0 ; while i < length do ( (     execute printValue(N->at(i+1)) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : String ; N := "123" ;
     execute printWord(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  int n ;
  int[] as ;
  public static void main(String args[]){
    new Main().run();
  }
  void run(){
    FastReader sc=new FastReader();
    n=sc.nextInt();
    as=new int[n];
    for(int i=0 ; i<n ; i++){
      as[i]=sc.nextInt();
    }
    solve();
  }
  void solve(){
    int[] counts=new int[100001];
    for(int i=0 ; i<n ; i++){
      if(as[i]>0){
        counts[as[i]-1]++;
      }
      counts[as[i] ]++;
      counts[as[i]+1]++;
    }
    int max=0 ;
    for(int i=0 ; i<100001 ; i++){
      if(counts[i]>max){
        max=counts[i];
      }
    }
    System.out.println(max);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute as : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     n := sc.nextInt() ; 
    as := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     as[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    execute solve() ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var counts : Sequence(int) ; counts := Integer.subrange(1,100001)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     if (as[i+1] > 0) then (     counts[as[i+1] - 1+1] := counts[as[i+1] - 1+1] + 1 ) else skip ; 
     counts[as[i+1]+1] := counts[as[i+1]+1] + 1 ; 
     counts[as[i+1] + 1+1] := counts[as[i+1] + 1+1] + 1 )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < 100001 do ( (     if (counts[i+1] > max) then (     max := counts[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class Pair implements Comparable<Pair>{
  int a ;
  int cnt ;
  public Pair(int i,int j){
    this.a=i ;
    this.cnt=j ;
  }
  public int compareTo(Pair p){
    if(this.cnt==p.cnt)return 0 ;
    if(this.cnt<p.cnt)return-1 ;
    return 1 ;
  }
}
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    HashMap<Integer,Pair>map=new HashMap<>();
    ArrayList<Pair>l=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      int c=Integer.parseInt(sc.next());
      for(int j=0 ; j<3 ; j++){
        if(j==1)c--;
        else if(j==2)c+=2 ;
        if(! map.containsKey(c)){
          Pair p=new Pair(c,1);
          map.put(c,p);
          l.add(p);
        }
        else {
          Pair p=map.get(c);
          p.cnt++;
        }
      }
    }
    Collections.sort(l);
    Pair res=l.get(l.size()-1);
    System.out.println(res.cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Pair implements Comparable<Map> {
   attribute a : int;
   attribute cnt : int;
   static operation newPair( i : int, j : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(i, j);
    return self );
  operation initialise( i : int, j : int) : void
  pre: true  post: true
  activity: (     self.a := i ; 
     self.cnt := j );
   operation compareTo( p : Map) : int
  pre: true
  post: true
  activity: (     if (self.cnt = p.cnt) then     return 0 else skip ; 
     if (self.cnt < p.cnt) then     return -1 else skip ; 
     return 1 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var map : Map(int,Map) ; map := Map{} ;
    var l : Sequence(Map) ; l := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var c : int ; c := (sc.getCurrent())->toInteger() ;
         var j : int ; j := 0 ; while j < 3 do ( (     if (j = 1) then     c := c - 1 else     if (j = 2) then     c := c+(2) ; else skip ; ;  
     if (not(map->keys()->includes(c))) then (     var p : Map ; p := Map(c, 1) ;
     map := map->union(Map{c |-> p}) ; 
     l := l->including(p) ) else (     var p : Map ; p := map->at(c) ;
     p.cnt := p.cnt + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    l := l->sort() ; 
    var res : Map ; res := l->at(l->size() - 1+1) ;
    OclFile["System.out"].println(res.cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CTogether solver=new CTogether();
    solver.solve(1,in,out);
    out.close();
  }
  static class CTogether {
    static final int MAX=100_000 ;
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int[] count=new int[MAX+1];
      for(int i=0 ; i<n ; i++){
        count[in.nextInt()]++;
      }
      int answer=0 ;
      for(int i=1 ; i+1<=MAX ; i++){
        answer=Math.max(answer,count[i-1]+count[i]+count[i+1]);
      }
      out.println(answer);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CTogether ; solver := CTogether.newCTogether() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CTogether {
  static    attribute MAX : int := 100_000;
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var count : Sequence(int) ; count := Integer.subrange(1,MAX + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     count[in.nextInt()+1] := count[in.nextInt()+1] + 1 )  ;     i := i + 1 ) ; 
    var answer : int ; answer := 0 ;
        var i : int ; i := 1 ; while i + 1 <= MAX do ( (     answer := Set{answer, count[i - 1+1] + count[i+1] + count[i + 1+1]}->max() )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int N=gi();
    int[] A=new int[100001];
    for(int i=0 ; i<N ; i++){
      int ind=gi();
      A[ind]++;
      ;
    }
    int max=0 ;
    for(int i=0 ; i<100001 ; i++){
      int v=A[i];
      if(i+1<N)v+=A[i+1];
      if(i+2<N)v+=A[i+2];
      if(v>max)max=v ;
    }
    System.out.println(max);
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : int ; N := gi() ;
    var A : Sequence(int) ; A := Integer.subrange(1,100001)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     var ind : int ; ind := gi() ;
     A[ind+1] := A[ind+1] + 1 ; 
  )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < 100001 do ( (     var v : int ; v := A[i+1] ;
     if (i + 1 < N) then     v := v+(A[i + 1+1]) ; else skip ; 
     if (i + 2 < N) then     v := v+(A[i + 2+1]) ; else skip ; 
     if (v > max) then     max := v ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.ByteArrayInputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Throwable {
    InputStream is=null ;
    if(false){
      String input="1\n"+"99999" ;
      is=new ByteArrayInputStream(input.getBytes());
    }
    else {
      is=System.in ;
    }
    try(BufferedReader r=new BufferedReader(new InputStreamReader(is))){
      int N=readInt(r);
      int[] as=readInts(r);
      int[] counts=new int[(int)Math.pow(10,5)];
      for(int a : as){
        counts[a]++;
      }
      int max=-1 ;
      int maxIndex=-1 ;
      for(int i=0 ; i<counts.length ; i++){
        int before=i==0 ? 0 : counts[i-1];
        int after=i==counts.length-1 ? 0 : counts[i+1];
        int total=before+after+counts[i];
        if(total>max){
          max=total ;
          maxIndex=i ;
        }
      }
      System.out.println(max);
    }
  }
  private static int readInt(BufferedReader r)throws IOException {
    return Integer.parseInt(r.readLine());
  }
  private static int[] readInts(BufferedReader r)throws IOException {
    String[] data=r.readLine().split("\\s");
    int[] vals=new int[data.length];
    for(int i=0 ; i<vals.length ; i++){
      vals[i]=Integer.parseInt(data[i]);
    }
    return vals ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := null ;
     if (false) then (     var input : String ; input := "1\n" + "99999" ;
     is := ByteArrayInputStream.newByteArrayInputStream(input->characters()->collect( _c | _c->char2byte() )) ) else (     is := OclFile["System.in"] ) ;  
     try (    var r : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) ;
 (     var N : int ; N := readInt(r) ;
     var as : Sequence(int) ; as := readInts(r) ;
    var counts : Sequence(int) ; counts := Integer.subrange(1,10->pow(5)->oclAsType(int))->collect(0) ;
    for (a : as) do ( (     counts[a+1] := counts[a+1] + 1 )  ) ; 
    var max : int ; max := -1 ;
    var maxIndex : int ; maxIndex := -1 ;
        var i : int ; i := 0 ; while i < counts->size() do ( (     var before : int ; before := if i = 0 then 0 else counts[i - 1+1] endif ;
     var after : int ; after := if i = counts->size() - 1 then 0 else counts[i + 1+1] endif ;
     var total : int ; total := before + after + counts[i+1] ;
     if (total > max) then (     max := total ; 
     maxIndex := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ))  );
  static   operation readInt( r : OclFile) : int
  pre: true
  post: true
  activity: (     return (r.readLine())->toInteger() );
  static   operation readInts( r : OclFile) : Sequence(int)
  pre: true
  post: true
  activity: (     var data : Sequence(String) ; data := r.readLine()->split("\\s") ;
     var vals : Sequence(int) ; vals := Integer.subrange(1,data->size())->collect(0) ;
         var i : int ; i := 0 ; while i < vals->size() do ( (     vals[i+1] := (data[i+1])->toInteger() )  ;     i := i + 1 ) ; 
     return vals );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Map.Entry ;
import java.util.*;
import java.math.*;
import org.w3c.dom.css.Counter ;
public class Main {
  public static void main(final String[] args){
    final Scanner s=new Scanner(System.in);
    final int N=Integer.parseInt(s.next());
    final int M=Integer.parseInt(s.next());
    final int X=Integer.parseInt(s.next());
    final HashMap<Integer,ArrayList<Integer>>bookList=new HashMap<Integer,ArrayList<Integer>>();
    for(int i=0 ; i<N ; i++){
      ArrayList<Integer>bookInfo=new ArrayList<Integer>();
      for(int i2=0 ; i2<M+1 ; i2++){
        bookInfo.add(Integer.parseInt(s.next()));
      }
      bookList.put(i,bookInfo);
    }
    long price=-1 ;
    for(int Mnum=0 ; Mnum<(1<<N); Mnum++){
      int tmpPrice=0 ;
      int testFirst=0 ;
      ArrayList<Integer>targetBookInfo ;
      for(int j=0 ; j<N ; j++){
        if((1 & Mnum>>j)==1){
          targetBookInfo=bookList.get(j);
          Iterator<Integer>hoge=targetBookInfo.iterator();
          tmpPrice+=hoge.next();
          testFirst+=hoge.next();
        };
      }
      if(testFirst>=X &&(price==-1 || tmpPrice<price)){
        boolean Hoge=false ;
        int argoChecker=0 ;
        for(int targetArgo=2 ; targetArgo<M+1 ; targetArgo++){
          for(int j=0 ; j<N ; j++){
            if((1 & Mnum>>j)==1){
              argoChecker+=bookList.get(j).get(targetArgo);
            }
          }
          if(argoChecker<X){
            argoChecker=0 ;
            Hoge=true ;
            break ;
          }
          else {
            argoChecker=0 ;
          }
        }
        if(Hoge==false){
          price=tmpPrice ;
        }
      }
    }
    System.out.println(price);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (s.getCurrent())->toInteger() ;
    var M : int ; M := (s.getCurrent())->toInteger() ;
    var X : int ; X := (s.getCurrent())->toInteger() ;
    var bookList : Map(int,Sequence(int)) ; bookList := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     var bookInfo : Sequence(int) ; bookInfo := Sequence{} ;
         var i2 : int ; i2 := 0 ; while i2 < M + 1 do ( (     bookInfo := bookInfo->including((s.getCurrent())->toInteger()) )  ;     i2 := i2 + 1 ) ; 
     bookList := bookList->union(Map{i |-> bookInfo}) )  ;     i := i + 1 ) ; 
    var price : long ; price := -1 ;
        var Mnum : int ; Mnum := 0 ; while Mnum < ((1*(2->pow(N)))->oclAsType(long)) do ( (     var tmpPrice : int ; tmpPrice := 0 ;
     var testFirst : int ; testFirst := 0 ;
    var targetBookInfo : Sequence(int) ;
        var j : int ; j := 0 ; while j < N do ( (     if ((MathLib.bitwiseAnd(1,(Mnum/(2->pow(j)))->oclAsType(long))) = 1) then (     targetBookInfo := bookList->at(j) ; 
     var hoge : OclIterator ; hoge := targetBookInfo->iterator() ;
     tmpPrice := tmpPrice+(hoge.next()) ; 
     testFirst := testFirst+(hoge.next()) ) else skip ; 
  )  ;     j := j + 1 ) ; 
    if (testFirst >= X & (price = -1 or tmpPrice < price)) then (     var Hoge : boolean ; Hoge := false ;
     var argoChecker : int ; argoChecker := 0 ;
         var targetArgo : int ; targetArgo := 2 ; while targetArgo < M + 1 do ( (         var j : int ; j := 0 ; while j < N do ( (     if ((MathLib.bitwiseAnd(1,(Mnum/(2->pow(j)))->oclAsType(long))) = 1) then (     argoChecker := argoChecker+(bookList->at(j)->at(targetArgo+1)) ) else skip )  ;     j := j + 1 ) ; 
     if (argoChecker < X) then (     argoChecker := 0 ; 
     Hoge := true ; 
     break ) else (     argoChecker := 0 ) )  ;     targetArgo := targetArgo + 1 ) ; 
     if (Hoge = false) then (     price := tmpPrice ) else skip ) else skip ; 
 )  ;     Mnum := Mnum + 1 ) ; 
    OclFile["System.out"].println(price) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    boolean[] ps=new boolean[1000000+1];
    Arrays.fill(ps,true);
    ps[0]=false ;
    ps[1]=false ;
    for(int i=2 ; i<=Math.sqrt(ps.length); i++){
      if(ps[i]){
        for(int j=i*2 ; j<ps.length ; j+=i){
          ps[j]=false ;
        }
      }
    }
    while((line=br.readLine())!=null && ! line.isEmpty()){
      StringTokenizer st=new StringTokenizer(line);
      int a,d,n ;
      a=parseInt(st.nextToken());
      d=parseInt(st.nextToken());
      n=parseInt(st.nextToken());
      if((a | d | n)==0)break ;
      int i=a,c=0 ;
      while(true){
        if(ps[i]){
          c++;
          if(c==n)break ;
        }
        i+=d ;
      }
      System.out.println(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var ps : Sequence(boolean) ; ps := Integer.subrange(1,1000000 + 1)->collect(false) ;
    ps := ps->collect(true) ; 
    ps[0+1] := false ; 
    ps[1+1] := false ; 
        var i : int ; i := 2 ; while i <= (ps->size())->sqrt() do ( (     if (ps[i+1]) then (         var j : int ; j := i * 2 ; while j < ps->size() do ( (     ps[j+1] := false )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
        line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var st : OclIterator ; st := OclIterator.newOclIterator_String(line) ;
     var a : int ;
    var d : int ;
    var n : int ;
    a := (st.next() + "")->toInteger() ; 
    d := (st.next() + "")->toInteger() ; 
    n := (st.next() + "")->toInteger() ; 
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(a,d),n)) = 0) then     break else skip ; 
    var i : int ; i := a ;
    var c : int ; c := 0 ;
    while (true) do (     if (ps[i+1]) then (     c := c + 1 ; 
     if (c = n) then     break else skip ) else skip ; 
     i := i+(d) ) ; 
    OclFile["System.out"].println(i) ; 
 ) ;     line := br.readLine() ;
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class LCM {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long n=in.nextLong();
    pw.println(solve(n));
    pw.close();
  }
  static int solve(long n){
    HashSet<Long>set=new HashSet<>();
    for(long i=1 ; i*i<=n ; i++){
      if(n % i==0){
        long another=n/i ;
        set.add(another);
        set.add(i);
      }
    }
    return set.size();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class LCM {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := in.getCurrent()->toLong() ;
    skip ; 
    skip ; 
 );
  static   operation solve( n : long) : int
  pre: true
  post: true
  activity: (     var set : Set(long) ; set := Set{} ;
         var i : long ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     var another : long ; another := n / i ;
     set := set->including(another) ; 
     set := set->including(i) ) else skip )  ;     i := i + 1 ) ; 
     return set->size() );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    try {
      Scanner sc=new Scanner(System.in);
      while(true){
        int a=sc.nextInt(),d=sc.nextInt(),n=sc.nextInt();
        if(a==0 && d==0 && n==0){
          sc.close();
          break ;
        }
        int index=0 ;
        while(true){
          if(prime(a)){
            index++;
          }
          if(index==n)break ;
          a+=d ;
        }
        System.out.println(a);
      }
      sc.close();
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  public static boolean prime(int a){
    if(a==1)return false ;
    int limit=(int)Math.sqrt(a);
    boolean p=true ;
    for(int i=2 ; i<=limit ; i++){
      if(a % i==0){
        p=false ;
        break ;
      }
    }
    return p ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
     if (a = 0 & d = 0 & n = 0) then (     skip ; 
     break ) else skip ; 
    var index : int ; index := 0 ;
    while (true) do (     if (prime(a)) then (     index := index + 1 ) else skip ; 
     if (index = n) then     break else skip ; 
     a := a+(d) ) ; 
    OclFile["System.out"].println(a) ; 
 ) ; 
     skip )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
  static   operation prime( a : int) : boolean
  pre: true
  post: true
  activity: (     if (a = 1) then     return false else skip ; 
     var limit : int ; limit := (a)->sqrt()->oclAsType(int) ;
    var p : boolean ; p := true ;
        var i : int ; i := 2 ; while i <= limit do ( (     if (a mod i = 0) then (     p := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    return p 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  void run(){
    for(; ; ){
      long a,d,n ;
      a=ni();
      d=ni();
      n=ni();
      if((a | d | n)==0)break ;
      int cnt=0 ;
      for(long ite=a ; ; ite+=d){
        boolean f=true ;
        f=2<=ite ;
        for(int j=2 ; j*j<=ite ; ++j){
          f &=ite % j!=0 ;
        }
        if(f){
          if(++cnt==n){
            System.out.println(ite);
            break ;
          }
        }
      }
    }
  }
  Main(){
    sc=new Scanner(System.in);
  }
  int ni(){
    return sc.nextInt();
  }
  String ns(){
    return sc.next();
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var a : long ;
    var d : long ;
    var n : long ;
     a := ni() ; 
    d := ni() ; 
    n := ni() ; 
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(a,d),n)) = 0) then     break else skip ; 
    var cnt : int ; cnt := 0 ;
        var ite : long ; ite := a ; while true do ( (     var f : boolean ; f := true ;
     f := 2 <= ite ; 
         var j : int ; j := 2 ; while j * j <= ite do ( (     f := MathLib.bitwiseAnd(f, ite mod j /= 0) )  ;     j := j + 1 ) ; 
     if (f) then (     if ((cnt + 1) = n) then (     OclFile["System.out"].println(ite) ; 
     break ) else skip ) else skip )  ;     ite := ite+(d) ) ; 
 )  ) );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
   operation ns() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxNormalSubString(char[] P,char[] Q,int K,int N){
    if(K==0)return 0 ;
    int count=0 ;
    int left=0,right=0 ;
    int ans=0 ;
    while(right<N){
      while(right<N && count<=K){
        int pos=P[right]-'a' ;
        if(Q[pos]=='0'){
          if(count+1>K)break ;
          else count++;
        }
        right++;
        if(count<=K)ans=Math.max(ans,right-left);
      }
      while(left<right){
        int pos=P[left]-'a' ;
        left++;
        if(Q[pos]=='0')count--;
        if(count<K)break ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    String P="giraffe",Q="01111001111111111011111111" ;
    int K=2 ;
    int N=P.length();
    System.out.print(maxNormalSubString(P.toCharArray(),Q.toCharArray(),K,N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxNormalSubString( P : Sequence(String), Q : Sequence(String), K : int, N : int) : int
  pre: true
  post: true
  activity: (     if (K = 0) then     return 0 else skip ; 
     var count : int ; count := 0 ;
    var left : int ; left := 0 ;
    var right : int ; right := 0 ;
    var ans : int ; ans := 0 ;
    while (right < N) do (     while (right < N & count <= K) do (     var pos : int ; pos := P[right+1] - ('a')->char2byte() ;
     if (Q[pos+1] = '0') then (     if (count + 1 > K) then     break else     count := count + 1 ; ) else skip ; 
     right := right + 1 ; 
     if (count <= K) then     ans := Set{ans, right - left}->max() ; else skip ) ; 
     while (left < right) do (     var pos : int ; pos := P[left+1] - ('a')->char2byte() ;
     left := left + 1 ; 
     if (Q[pos+1] = '0') then     count := count - 1 ; else skip ; 
     if (count < K) then     break else skip ) ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var P : String ; P := "giraffe" ;
    var Q : String ; Q := "01111001111111111011111111" ;
     var K : int ; K := 2 ;
     var N : int ; N := P->size() ;
     OclFile["System.out"].print(maxNormalSubString(P->characters(), Q->characters(), K, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  static int insertSorted(int arr[],int n,int key,int capacity){
    if(n>=capacity)return n ;
    int i ;
    for(i=n-1 ; (i>=0 && arr[i]>key); i--)arr[i+1]=arr[i];
    arr[i+1]=key ;
    return(n+1);
  }
  public static void main(String[] args){
    int arr[]=new int[20];
    arr[0]=12 ;
    arr[1]=16 ;
    arr[2]=20 ;
    arr[3]=40 ;
    arr[4]=50 ;
    arr[5]=70 ;
    int capacity=arr.length ;
    int n=6 ;
    int key=26 ;
    System.out.print("\nBefore Insertion: ");
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    n=insertSorted(arr,n,key,capacity);
    System.out.print("\nAfter Insertion: ");
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation insertSorted( arr : Sequence(int), n : int, key : int, capacity : int) : int
  pre: true
  post: true
  activity: (     if (n >= capacity) then     return n else skip ; 
     var i : int ;
        i := n - 1 ; while (i >= 0 & arr[i+1] > key) do (     arr[i + 1+1] := arr[i+1] ;  ;     i := i - 1 ) ; 
    arr[i + 1+1] := key ; 
    return (n + 1) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,20)->collect(0) ;
     arr[0+1] := 12 ; 
    arr[1+1] := 16 ; 
    arr[2+1] := 20 ; 
    arr[3+1] := 40 ; 
    arr[4+1] := 50 ; 
    arr[5+1] := 70 ; 
    var capacity : int ; capacity := arr->size() ;
    var n : int ; n := 6 ;
    var key : int ; key := 26 ;
    OclFile["System.out"].print("\nBefore Insertion: ") ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
    n := insertSorted(arr, n, key, capacity) ; 
    OclFile["System.out"].print("\nAfter Insertion: ") ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class geeks {
  public static void findDandZeroes(int[] a,int[] b,int n){
    HashMap<Double,Integer>mpp=new HashMap<>();
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(b[i]!=0 && a[i]!=0){
        double val=(double)(-1.0*b[i])/(double)(a[i]);
        if(mpp.get(val)!=null){
          int x=mpp.get(val);
          mpp.put(val,++x);
        }
        else mpp.put(val,1);
      }
      else if(b[i]==0 && a[i]==0)count+=1 ;
    }
    int maxi=0 ;
    for(HashMap.Entry<Double,Integer>entry : mpp.entrySet()){
      maxi=Math.max(entry.getValue(),maxi);
    }
    for(HashMap.Entry<Double,Integer>entry : mpp.entrySet()){
      if(entry.getValue()==maxi){
        System.out.println("Value of d is: "+entry.getKey());
        break ;
      }
    }
    System.out.println("The number of zeros in array C is: "+(maxi+count));
  }
  public static void main(String[] args){
    int[] a={
      13,37,39 };
      int[] b={
        1,2,3 };
        int n=a.length ;
        findDandZeroes(a,b,n);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class geeks {
  static   operation findDandZeroes( a : Sequence(int), b : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var mpp : Map(double,int) ; mpp := Map{} ;
     var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (b[i+1] /= 0 & a[i+1] /= 0) then (     var val : double ; val := (-1.0 * b[i+1])->oclAsType(double) / (a[i+1])->oclAsType(double) ;
     if (mpp->at(val) /= null) then (     var x : int ; x := mpp->at(val) ;
     mpp := mpp->union(Map{val |-> (x + 1)}) ) else     mpp := mpp->union(Map{val |-> 1}) ; ) else     if (b[i+1] = 0 & a[i+1] = 0) then     count := count+(1) ; else skip ; )  ;     i := i + 1 ) ; 
    var maxi : int ; maxi := 0 ;
    for (entry : mpp->asSet()) do ( (     maxi := Set{entry.getValue(), maxi}->max() )  ) ; 
    for (entry : mpp->asSet()) do ( (     if (entry.getValue() = maxi) then (     OclFile["System.out"].println("Value of d is: " + entry.getKey()) ; 
     break ) else skip )  ) ; 
    OclFile["System.out"].println("The number of zeros in array C is: " + (maxi + count)) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{13,37,39} ;
     var b : Sequence(int) ; b := Sequence{1,2,3} ;
     var n : int ; n := a->size() ;
     execute findDandZeroes(a, b, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
class GFG {
  static int solveQuery(int start,int end,int arr[]){
    Map<Integer,Integer>mp=new HashMap<>();
    for(int i=start ; i<=end ; i++)mp.put(arr[i],mp.get(arr[i])==null ? 1 : mp.get(arr[i])+1);
    int count=0 ;
    for(Map.Entry<Integer,Integer>entry : mp.entrySet())if(entry.getKey()==entry.getValue())count++;
    return count ;
  }
  public static void main(String[] args){
    int A[]={
      1,2,2,3,3,3 };
      int n=A.length ;
      int[][] queries={
        {
          0,1 },{
            1,1 },{
              0,2 },{
                1,3 },{
                  3,5 },{
                    0,5 }
                  };
                  int q=queries.length ;
                  for(int i=0 ; i<q ; i++){
                    int start=queries[i][0];
                    int end=queries[i][1];
                    System.out.println("Answer for Query "+(i+1)+"="+solveQuery(start,end,A));
                  }
                }
              }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solveQuery( start : int, end : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := start ; while i <= end do (     mp := mp->union(Map{arr[i+1] |-> if mp->at(arr[i+1]) = null then 1 else mp->at(arr[i+1]) + 1 endif}) ;  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    for (entry : mp->asSet()) do (     if (entry.getKey() = entry.getValue()) then     count := count + 1 ; else skip ;  ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{1,2,2,3,3,3} ;
     var n : int ; n := A->size() ;
    var queries : Sequence(Sequence(int)) ; queries := Sequence{Sequence{0,1},Sequence{1,1},Sequence{0,2},Sequence{1,3},Sequence{3,5},Sequence{0,5}} ;
    var q : int ; q := queries->size() ;
        var i : int ; i := 0 ; while i < q do ( (     var start : int ; start := queries[i+1][0+1] ;
     var end : int ; end := queries[i+1][1+1] ;
     OclFile["System.out"].println("Answer for Query " + (i + 1) + "=" + solveQuery(start, end, A)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static boolean ff=false ;
  static long maxx(int tot,int ind,int[] c,int ulev[][],int x){
    if(ind>=c.length){
      long[] t=new long[ulev[0] .length];
      for(int j=0 ; j<c.length ; j++){
        int i=((1<<j)& tot);
        if(i!=0){
          for(int k=0 ; k<ulev[0] .length ; k++){
            t[k]=t[k]+ulev[j][k];
          }
        }
      }
      long ij=0 ;
      for(int j=0 ; j<t.length ; j++){
        if(t[j]>=x){
          ij++;
        }
      }
      if(ij==t.length){
        ff=true ;
        return 0 ;
      }
      else {
        return Integer.MAX_VALUE ;
      }
    }
    return Math.min(maxx(tot |(1<<ind),ind+1,c,ulev,x)+c[ind],maxx(tot,ind+1,c,ulev,x));
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    int x=scanner.nextInt();
    int[] c=new int[n];
    int[][] ul=new int[n][m];
    for(int j=0 ; j<n ; j++){
      c[j]=scanner.nextInt();
      for(int i=0 ; i<m ; i++){
        ul[j][i]=scanner.nextInt();
      }
    }
    ff=false ;
    long ans=maxx(0,0,c,ul,x);
    if(! ff){
      System.out.println(-1);
    }
    else {
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ff : boolean := false;
  static   operation maxx( tot : int, ind : int, c : Sequence(int), ulev : Sequence(Sequence(int)), x : int) : long
  pre: true
  post: true
  activity: (     if (ind >= c->size()) then (     var t : Sequence(long) ; t := Integer.subrange(1,ulev[0+1]->size())->collect(0) ;
         var j : int ; j := 0 ; while j < c->size() do ( (     var i : int ; i := (MathLib.bitwiseAnd(((1*(2->pow(j)))->oclAsType(long)),tot)) ;
     if (i /= 0) then (         var k : int ; k := 0 ; while k < ulev[0+1]->size() do ( (     t[k+1] := t[k+1] + ulev[j+1][k+1] )  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) ; 
    var ij : long ; ij := 0 ;
        var j : int ; j := 0 ; while j < t->size() do ( (     if (t[j+1] >= x) then (     ij := ij + 1 ) else skip )  ;     j := j + 1 ) ; 
    if (ij = t->size()) then (     ff := true ; 
     return 0 ) else (     return 2147483647 ) ;  
 ) else skip ; 
     return Set{maxx(tot or ((1*(2->pow(ind)))->oclAsType(long)), ind + 1, c, ulev, x) + c[ind+1], maxx(tot, ind + 1, c, ulev, x)}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var x : int ; x := scanner.getCurrent()->toInteger() ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    var ul : Sequence(Sequence(int)) ; ul := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var j : int ; j := 0 ; while j < n do ( (     c[j+1] := scanner.getCurrent()->toInteger() ; 
         var i : int ; i := 0 ; while i < m do ( (     ul[j+1][i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    ff := false ; 
    var ans : long ; ans := maxx(0, 0, c, ul, x) ;
    if (not(ff)) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(ans) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int r=sc.nextInt();
    System.out.print(r*6.28);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].print(r * 6.28) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastScanner sc=new FastScanner(System.in);
    double n=sc.nextDouble();
    System.out.println(n*2*Math.PI);
    ;
  }
  static int getDigit(int n,int d){
    return n/d!=0 ? 1+getDigit(n/d,d): 1 ;
  }
  static class FastScanner {
    private BufferedReader reader ;
    private StringTokenizer tokenizer ;
    public FastScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
      tokenizer=null ;
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          return reader.readLine();
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken("\n");
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long[] nextLongArray(int n){
      long[] a=new long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var n : double ; n := sc.nextDouble() ;
     OclFile["System.out"].println(n * 2 * 3.141592653589793) ; 
  );
  static   operation getDigit( n : int, d : int) : int
  pre: true
  post: true
  activity: (     return if n / d /= 0 then 1 + getDigit(n / d, d) else 1 endif );
  static class FastScanner {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.nextToken("\n") );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.acos ;
import java.math.BigDecimal ;
import java.math.RoundingMode ;
import java.text.DecimalFormat ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    double r=in.nextDouble();
    double pi=acos(-1.0);
    Double are=2*pi*r ;
    Double toBeTruncated=new Double(are);
    Double truncatedDouble=BigDecimal.valueOf(toBeTruncated).setScale(3,RoundingMode.HALF_UP).doubleValue();
    System.out.println(toBeTruncated);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : double ; r := in.getCurrent()->toReal() ;
    var pi : double ; pi := acos(-1.0) ;
    var are : double ; are := 2 * pi * r ;
    var toBeTruncated : double ; toBeTruncated := ("" + (are))->toReal() ;
    var truncatedDouble : double ; truncatedDouble := (toBeTruncated + "")->toReal().setScale(3, RoundingMode.HALF_UP)->oclAsType(double) ;
    OclFile["System.out"].println(toBeTruncated) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
class GFG {
  static void printRect(Integer X[],Integer Y[],int n){
    int Xmax=Collections.max(Arrays.asList(X));
    int Xmin=Collections.min(Arrays.asList(X));
    int Ymax=Collections.max(Arrays.asList(Y));
    int Ymin=Collections.min(Arrays.asList(Y));
    System.out.println("{"+Xmin+","+Ymin+"}");
    System.out.println("{"+Xmin+","+Ymax+"}");
    System.out.println("{"+Xmax+","+Ymax+"}");
    System.out.println("{"+Xmax+","+Ymin+"}");
  }
  public static void main(String[] args){
    Integer X[]={
      4,3,6,1,-1,12 };
      Integer Y[]={
        4,1,10,3,7,-1 };
        int n=X.length ;
        printRect(X,Y,n);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printRect( X : Sequence(int), Y : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var Xmax : int ; Xmax := .max(X) ;
     var Xmin : int ; Xmin := .min(X) ;
    var Ymax : int ; Ymax := .max(Y) ;
    var Ymin : int ; Ymin := .min(Y) ;
    OclFile["System.out"].println("{" + Xmin + "," + Ymin + "}") ; 
    OclFile["System.out"].println("{" + Xmin + "," + Ymax + "}") ; 
    OclFile["System.out"].println("{" + Xmax + "," + Ymax + "}") ; 
    OclFile["System.out"].println("{" + Xmax + "," + Ymin + "}") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : Sequence(int) ; X := Sequence{4,3,6,1,-1,12} ;
     var Y : Sequence(int) ; Y := Sequence{4,1,10,3,7,-1} ;
     var n : int ; n := X->size() ;
     execute printRect(X, Y, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int min=Integer.MAX_VALUE ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println(2*N*Math.PI);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute min : int := 2147483647;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(2 * N * 3.141592653589793) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  static final int MOD=1000000007 ;
  static final int INF=1<<30 ;
  static final int ALF=26 ;
  Main(){
    Scanner sc=new Scanner(System.in);
    double R=sc.nextInt();
    System.out.println(Math.PI*R*2);
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1000000007;
  static    attribute INF : int := (1*(2->pow(30)))->oclAsType(long);
  static    attribute ALF : int := 26;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var R : double ; R := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(3.141592653589793 * R * 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isPerfectSquareString(String str){
    int sum=0 ;
    int len=str.length();
    for(int i=0 ; i<len ; i++)sum+=(int)str.charAt(i);
    long squareRoot=(long)Math.sqrt(sum);
    return((squareRoot-Math.floor(squareRoot))==0);
  }
  public static void main(String[] args){
    String str="d" ;
    if(isPerfectSquareString(str))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPerfectSquareString( str : String) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var len : int ; len := str->size() ;
        var i : int ; i := 0 ; while i < len do (     sum := sum+(str->at(i+1)->oclAsType(int)) ;  ;     i := i + 1 ) ; 
    var squareRoot : long ; squareRoot := (sum)->sqrt()->oclAsType(long) ;
    return ((squareRoot - (squareRoot)->floor()) = 0) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "d" ;
     if (isPerfectSquareString(str)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countEvenSum(int arr[],int n){
    int result=0 ;
    for(int i=0 ; i<=n-1 ; i++){
      int sum=0 ;
      for(int j=i ; j<=n-1 ; j++){
        sum=sum+arr[j];
        if(sum % 2==0)result++;
      }
    }
    return(result);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,2,3,4,1 };
      int n=arr.length ;
      System.out.print("The Number of Subarrays"+" with even sum is ");
      System.out.println(countEvenSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countEvenSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i <= n - 1 do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := i ; while j <= n - 1 do ( (     sum := sum + arr[j+1] ; 
     if (sum mod 2 = 0) then     result := result + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return (result) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,2,3,4,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print("The Number of Subarrays" + " with even sum is ") ; 
     OclFile["System.out"].println(countEvenSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countEvenSum(int arr[],int n){
    int temp[]={
      1,0 };
      int result=0,sum=0 ;
      for(int i=0 ; i<=n-1 ; i++){
        sum=((sum+arr[i])% 2+2)% 2 ;
        temp[sum]++;
      }
      result=result+(temp[0]*(temp[0]-1)/2);
      result=result+(temp[1]*(temp[1]-1)/2);
      return(result);
    }
    public static void main(String[] args){
      int arr[]={
        1,2,2,3,4,1 };
        int n=arr.length ;
        System.out.println("The Number of Subarrays"+" with even sum is "+countEvenSum(arr,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countEvenSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var temp : Sequence(int) ; temp := Sequence{1,0} ;
     var result : int ; result := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i <= n - 1 do ( (     sum := ((sum + arr[i+1]) mod 2 + 2) mod 2 ; 
     temp[sum+1] := temp[sum+1] + 1 )  ;     i := i + 1 ) ; 
    result := result + (temp[0+1] * (temp[0+1] - 1) / 2) ; 
    result := result + (temp[1+1] * (temp[1+1] - 1) / 2) ; 
    return (result) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,2,3,4,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("The Number of Subarrays" + " with even sum is " + countEvenSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner s=new Scanner(System.in);
  public static void main(String[] __){
    int[] from,to ;
    {
      String buf=s.next();
      from=new int[buf.length()+1];
      for(int i=0 ; i<buf.length(); i++)from[i+1]=buf.charAt(i)=='A' ? 1 : 2 ;
      buf=s.next();
      to=new int[buf.length()+1];
      for(int i=0 ; i<buf.length(); i++)to[i+1]=buf.charAt(i)=='A' ? 1 : 2 ;
      Arrays.parallelPrefix(from,(a,b)->a+b);
      Arrays.parallelPrefix(to,(a,b)->a+b);
    }
    for(int q=s.nextInt(); q>0 ; q--){
      int f=-from[s.nextInt()-1]+from[s.nextInt()],t=-to[s.nextInt()-1]+to[s.nextInt()];
      System.out.println(f % 3==t % 3 ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( __ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var from : Sequence(int) ;
    var to : Sequence(int) ;
 (     var buf : String ; buf := s.getCurrent() ;
     from := Integer.subrange(1,buf->size() + 1)->collect(0) ; 
        var i : int ; i := 0 ; while i < buf->size() do (     from[i + 1+1] := if buf->at(i+1) = 'A' then 1 else 2 endif ;  ;     i := i + 1 ) ; 
    buf := s.getCurrent() ; 
    to := Integer.subrange(1,buf->size() + 1)->collect(0) ; 
        var i : int ; i := 0 ; while i < buf->size() do (     to[i + 1+1] := if buf->at(i+1) = 'A' then 1 else 2 endif ;  ;     i := i + 1 ) ; 
parallelPrefix(from, lambda (a , b) : OclAny in a + b) ; 
parallelPrefix(to, lambda (a , b) : OclAny in a + b) ; 
 ) 
         var q : int ; q := s.getCurrent()->toInteger() ; while q > 0 do ( (     var f : int ; f := -from[s.getCurrent()->toInteger() - 1+1] + from[s.getCurrent()->toInteger()+1] ;
    var t : int ; t := -to[s.getCurrent()->toInteger() - 1+1] + to[s.getCurrent()->toInteger()+1] ;
     OclFile["System.out"].println(if f mod 3 = t mod 3 then "YES" else "NO" endif) )  ;     q := q - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt(),x=sc.nextInt(),min=Integer.MAX_VALUE ;
    int[][] a=new int[n][m+1];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<=m ; j++)a[i][j]=sc.nextInt();
    }
    for(int i=0 ; i<Math.pow(2,n); i++){
      int[] status=new int[n];
      for(int j=0 ; j<n ; j++){
        if((1 & i>>j)==1){
          status[j]=1 ;
        }
      }
      int[] res=new int[m+1];
      for(int j=0 ; j<n ; j++){
        if(status[j]==1){
          for(int k=0 ; k<=m ; k++){
            res[k]+=a[j][k];
          }
        }
      }
      boolean flag=true ;
      for(int j=1 ; j<=m ; j++){
        if(res[j]<x){
          flag=false ;
          break ;
        }
      }
      if(flag)min=Math.min(min,res[0]);
    }
    if(min==Integer.MAX_VALUE)System.out.println(-1);
    else System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var min : int ; min := 2147483647 ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j <= m do (     a[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 2->pow(n) do ( (     var status : Sequence(int) ; status := Integer.subrange(1,n)->collect(0) ;
         var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd(1,(i/(2->pow(j)))->oclAsType(long))) = 1) then (     status[j+1] := 1 ) else skip )  ;     j := j + 1 ) ; 
    var res : Sequence(int) ; res := Integer.subrange(1,m + 1)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     if (status[j+1] = 1) then (         var k : int ; k := 0 ; while k <= m do ( (     res[k+1] := res[k+1]+(a[j+1][k+1]) )  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) ; 
    var flag : boolean ; flag := true ;
        var j : int ; j := 1 ; while j <= m do ( (     if (res[j+1] < x) then (     flag := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (flag) then     min := Set{min, res[0+1]}->min() ; else skip ; 
 )  ;     i := i + 1 ) ; 
    if (min = 2147483647) then     OclFile["System.out"].println(-1) else     OclFile["System.out"].println(min) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    String T=sc.next();
    int q=sc.nextInt();
    char[] s=S.toCharArray();
    char[] t=T.toCharArray();
    int[] fs=new int[s.length+1];
    int[] ft=new int[t.length+1];
    for(int i=1 ; i<=s.length ; i++)fs[i]=fs[i-1]+(s[i-1]=='A' ? 1 : 2);
    for(int i=1 ; i<=t.length ; i++)ft[i]=ft[i-1]+(t[i-1]=='A' ? 1 : 2);
    for(int i=0 ; i<q ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int d=sc.nextInt();
      int curS=fs[b]-fs[a-1];
      int curT=ft[d]-ft[c-1];
      String ans=(curS % 3)==(curT % 3)? "YES" : "NO" ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    var T : String ; T := sc.getCurrent() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := S->characters() ;
    var t : Sequence(String) ; t := T->characters() ;
    var fs : Sequence(int) ; fs := Integer.subrange(1,s->size() + 1)->collect(0) ;
    var ft : Sequence(int) ; ft := Integer.subrange(1,t->size() + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= s->size() do (     fs[i+1] := fs[i - 1+1] + (if s[i - 1+1] = 'A' then 1 else 2 endif) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= t->size() do (     ft[i+1] := ft[i - 1+1] + (if t[i - 1+1] = 'A' then 1 else 2 endif) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var curS : int ; curS := fs[b+1] - fs[a - 1+1] ;
    var curT : int ; curT := ft[d+1] - ft[c - 1+1] ;
    var ans : String ; ans := if (curS mod 3) = (curT mod 3) then "YES" else "NO" endif ;
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int ni(){
    return cin.nextInt();
  }
  long nl(){
    return cin.nextLong();
  }
  String line(){
    return cin.nextLine();
  }
  void println(String str){
    System.out.println(str);
  }
  void print(String str){
    System.out.print(str);
  }
  static final int MOD=1000000007 ;
  Scanner cin=new Scanner(System.in);
  String output ;
  public static void main(String[] args){
    new Main().run();
  }
  public void run(){
    solve();
  }
  String S ;
  String T ;
  int N ;
  void solve(){
    S=line();
    T=line();
    int[] sums=new int[S.length()+1];
    int[] sumt=new int[T.length()+1];
    sums[1]=S.charAt(0)-'A'+1 ;
    for(int i=1 ; i<S.length(); i++){
      sums[i+1]=sums[i]+S.charAt(i)-'A'+1 ;
    }
    sumt[1]=T.charAt(0)-'A'+1 ;
    for(int i=1 ; i<T.length(); i++){
      sumt[i+1]=sumt[i]+T.charAt(i)-'A'+1 ;
    }
    N=ni();
    for(int i=0 ; i<N ; i++){
      int a=ni();
      int b=ni();
      int c=ni();
      int d=ni();
      if((sums[b]-sums[a-1])% 3==(sumt[d]-sumt[c-1])% 3){
        println("YES");
      }
      else {
        println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation ni() : int
  pre: true
  post: true
  activity: (     return cin.nextInt() );
   operation nl() : long
  pre: true
  post: true
  activity: (     return cin.nextLong() );
   operation line() : String
  pre: true
  post: true
  activity: (     return cin.nextLine() );
   operation println( str : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(str) );
   operation print( str : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(str) );
  static    attribute MOD : int := 1000000007;
   attribute cin : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute output : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     execute solve() );
   attribute S : String;
   attribute T : String;
   attribute N : int;
   operation solve() : void
  pre: true
  post: true
  activity: (     S := line() ; 
     T := line() ; 
    var sums : Sequence(int) ; sums := Integer.subrange(1,S->size() + 1)->collect(0) ;
    var sumt : Sequence(int) ; sumt := Integer.subrange(1,T->size() + 1)->collect(0) ;
    sums[1+1] := S->at(0+1) - ('A')->char2byte() + 1 ; 
        var i : int ; i := 1 ; while i < S->size() do ( (     sums[i + 1+1] := sums[i+1] + S->at(i+1) - ('A')->char2byte() + 1 )  ;     i := i + 1 ) ; 
    sumt[1+1] := T->at(0+1) - ('A')->char2byte() + 1 ; 
        var i : int ; i := 1 ; while i < T->size() do ( (     sumt[i + 1+1] := sumt[i+1] + T->at(i+1) - ('A')->char2byte() + 1 )  ;     i := i + 1 ) ; 
    N := ni() ; 
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := ni() ;
     var b : int ; b := ni() ;
    var c : int ; c := ni() ;
    var d : int ; d := ni() ;
    if ((sums[b+1] - sums[a - 1+1]) mod 3 = (sumt[d+1] - sumt[c - 1+1]) mod 3) then (     execute println("YES") ) else (     execute println("NO") ) ;  
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String t=sc.next();
    int q=sc.nextInt();
    int[] sMod=new int[s.length()+1];
    sMod[0]=0 ;
    for(int i=1 ; i<=s.length(); i++){
      sMod[i]=(sMod[i-1]+(s.charAt(i-1)=='A' ? 1 : 2))% 3 ;
    }
    int[] tMod=new int[t.length()+1];
    tMod[0]=0 ;
    for(int i=1 ; i<=t.length(); i++){
      tMod[i]=(tMod[i-1]+(t.charAt(i-1)=='A' ? 1 : 2))% 3 ;
    }
    for(int i=0 ; i<q ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int d=sc.nextInt();
      int x=(sMod[b]-sMod[a-1]+3)% 3 ;
      int y=(tMod[d]-tMod[c-1]+3)% 3 ;
      System.out.println(x==y ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var sMod : Sequence(int) ; sMod := Integer.subrange(1,s->size() + 1)->collect(0) ;
    sMod[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= s->size() do ( (     sMod[i+1] := (sMod[i - 1+1] + (if s->at(i - 1+1) = 'A' then 1 else 2 endif)) mod 3 )  ;     i := i + 1 ) ; 
    var tMod : Sequence(int) ; tMod := Integer.subrange(1,t->size() + 1)->collect(0) ;
    tMod[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= t->size() do ( (     tMod[i+1] := (tMod[i - 1+1] + (if t->at(i - 1+1) = 'A' then 1 else 2 endif)) mod 3 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var x : int ; x := (sMod[b+1] - sMod[a - 1+1] + 3) mod 3 ;
    var y : int ; y := (tMod[d+1] - tMod[c - 1+1] + 3) mod 3 ;
    OclFile["System.out"].println(if x = y then "YES" else "NO" endif) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int a=scan.nextInt();
    int b=scan.nextInt();
    int max=Math.max(a,b);
    for(int i=1 ; i<=max+1 ; i++){
      if(i % 2==1){
        a-=i ;
        if(a<0){
          System.out.println("Vladik");
          return ;
        }
      }
      else {
        b-=i ;
        if(b<0){
          System.out.println("Valera");
          return ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    var max : int ; max := Set{a, b}->max() ;
        var i : int ; i := 1 ; while i <= max + 1 do ( (     if (i mod 2 = 1) then (     a := a-(i) ; 
     if (a < 0) then (     OclFile["System.out"].println("Vladik") ; 
     return ) else skip ) else (     b := b-(i) ; 
     if (b < 0) then (     OclFile["System.out"].println("Valera") ; 
     return ) else skip ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findSum(int N,int K){
    int ans=0 ;
    int y=N/K ;
    int x=N % K ;
    ans=(K*(K-1)/2)*y+(x*(x+1))/2 ;
    return ans ;
  }
  static public void main(String[] args){
    int N=10,K=2 ;
    System.out.println(findSum(N,K));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSum( N : int, K : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var y : int ; y := N / K ;
    var x : int ; x := N mod K ;
    ans := (K * (K - 1) / 2) * y + (x * (x + 1)) / 2 ; 
    return ans 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 10 ;
    var K : int ; K := 2 ;
     OclFile["System.out"].println(findSum(N, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    String t=sc.nextLine();
    if(s.equals(t.substring(0,s.length()))){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var t : String ; t := sc.nextLine() ;
    if (s = t.subrange(0+1,s->size())) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.*;
import java.util.*;
import java.util.ArrayList ;
import java.util.Iterator ;
import java.util.List ;
import java.util.Collections ;
import java.io.Serializable ;
public class Main {
  public static void main(final String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String t=sc.next();
    int count=0 ;
    char[] work1=new char[s.length()];
    char[] work2=new char[t.length()];
    for(int i=0 ; i<s.length(); i++){
      work1[i]=s.charAt(i);
    }
    for(int i=0 ; i<t.length(); i++){
      work2[i]=t.charAt(i);
    }
    for(int i=0 ; i<s.length(); i++){
      if(work1[i]==work2[i]){
      }
      else {
        count++;
      }
    }
    if(count==0){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var count : int ; count := 0 ;
    var work1 : Sequence(String) ; work1 := Integer.subrange(1,s->size())->collect(0) ;
    var work2 : Sequence(String) ; work2 := Integer.subrange(1,t->size())->collect(0) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     work1[i+1] := s->at(i+1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < t->size() do ( (     work2[i+1] := t->at(i+1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     if (work1[i+1] = work2[i+1]) then skip else (     count := count + 1 ) )  ;     i := i + 1 ) ; 
    if (count = 0) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long m=(long)(1e9+7);
  public static void main(String[] args)throws IOException {
    Scanner scn=new Scanner(System.in);
    String s=scn.next(),t=scn.next();
    System.out.println(s.equals(t.substring(0,t.length()-1))? "Yes" : "No");
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute m : long := (1e9 + 7)->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scn.getCurrent() ;
    var t : String ; t := scn.getCurrent() ;
     OclFile["System.out"].println(if s = t.subrange(0+1,t->size() - 1) then "Yes" else "No" endif) );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
import java.util.List ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String input1=sc.nextLine();
    String input2=sc.nextLine();
    String before=input2.substring(0,input2.length()-1);
    String result=input1.equals(before)? "Yes" : "No" ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input1 : String ; input1 := sc.nextLine() ;
    var input2 : String ; input2 := sc.nextLine() ;
    var before : String ; before := input2.subrange(0+1,input2->size() - 1) ;
    var result : String ; result := if input1 = before then "Yes" else "No" endif ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    String S=scan.next();
    String T=scan.next();
    if(T.startsWith(S)&& S.length()+1==T.length()){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var S : String ; S := scan.getCurrent() ;
     var T : String ; T := scan.getCurrent() ;
     if (T->hasPrefix(S) & S->size() + 1 = T->size()) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int[] find(int dividend,int divisor,int start,int end){
    if(start>end)return new int[] {
      0,dividend };
      int mid=start+(end-start)/2 ;
      int n=dividend-divisor*mid ;
      if(n>divisor)start=mid+1 ;
      else if(n<0)end=mid-1 ;
      else {
        if(n==divisor){
++mid ;
          n=0 ;
        }
        return new int[] {
          mid,n };
        }
        return find(dividend,divisor,start,end);
      }
      static int[] divide(int dividend,int divisor){
        return find(dividend,divisor,1,dividend);
      }
      public static void main(String[] args){
        int dividend=10,divisor=3 ;
        int[] ans=divide(dividend,divisor);
        System.out.print(ans[0]+",");
        System.out.print(ans[1]+"\n");
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find( dividend : int, divisor : int, start : int, end : int) : Sequence(int)
  pre: true
  post: true
  activity: (     if (start > end) then     return Sequence{0,dividend} else skip ; 
     var mid : int ; mid := start + (end - start) / 2 ;
    var n : int ; n := dividend - divisor * mid ;
    if (n > divisor) then     start := mid + 1 else     if (n < 0) then     end := mid - 1 else (     if (n = divisor) then (     mid := mid + 1 ; 
     n := 0 ) else skip ; 
     return Sequence{mid,n} ) ;  ;  
    return find(dividend, divisor, start, end) 
 );
  static   operation divide( dividend : int, divisor : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return find(dividend, divisor, 1, dividend) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var dividend : int ; dividend := 10 ;
    var divisor : int ; divisor := 3 ;
     var ans : Sequence(int) ; ans := divide(dividend, divisor) ;
     OclFile["System.out"].print(ans[0+1] + ",") ; 
     OclFile["System.out"].print(ans[1+1] + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.nio.Buffer ;
import java.util.*;
public class Main2 {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int testCases=sc.nextInt();
    while(testCases-->0){
      int length=sc.nextInt();
      int[] array=new int[length];
      TreeSet<Integer>set=new TreeSet<>();
      for(int i=1 ; i<=length ; i++){
        array[i-1]=sc.nextInt();
        set.add(i);
      }
      ArrayList<Integer>ans=new ArrayList<>();
      boolean can=true ;
      for(int i=0 ; i<length ; i++){
        int number=array[i];
        Integer shouldPrint=set.floor(number);
        if(shouldPrint==null){
          can=false ;
          break ;
        }
        ans.add(shouldPrint);
        set.remove(shouldPrint);
      }
      if(can){
        for(int i=0 ; i<ans.size(); i++){
          if(i!=0)System.out.print(" ");
          System.out.print(ans.get(i));
        }
        System.out.println();
      }
      else System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := sc.getCurrent()->toInteger() ;
         while (testCases > 0) do (        testCases := testCases - 1 ;     skip ; (     var length : int ; length := sc.getCurrent()->toInteger() ;
     var array : Sequence(int) ; array := Integer.subrange(1,length)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 1 ; while i <= length do ( (     array[i - 1+1] := sc.getCurrent()->toInteger() ; 
     set := set->including(i) )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Sequence{} ;
    var can : boolean ; can := true ;
        var i : int ; i := 0 ; while i < length do ( (     var number : int ; number := array[i+1] ;
     var shouldPrint : int ; shouldPrint := set.floor(number) ;
    if (shouldPrint = null) then (     can := false ; 
     break ) else skip ; 
    ans := ans->including(shouldPrint) ; 
    set := set->excludingAt(shouldPrint+1) ; 
 )  ;     i := i + 1 ) ; 
    if (can) then (         var i : int ; i := 0 ; while i < ans->size() do ( (     if (i /= 0) then     OclFile["System.out"].print(" ") ; else skip ; 
     OclFile["System.out"].print(ans->at(i+1)) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) else     OclFile["System.out"].println(-1) ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    for(int i=0 ; i<N ; i++){
      int M=sc.nextInt();
      int num[]=new int[M];
      for(int j=0 ; j<M ; j++){
        num[j]=sc.nextInt();
      }
      int upper_max=0 ;
      int down_max=0 ;
      for(int j=0 ; j<M-1 ; j++){
        if(num[j]<num[j+1]){
          if(upper_max<num[j+1]-num[j])upper_max=num[j+1]-num[j];
        }
        if(num[j]>num[j+1]){
          if(down_max<num[j]-num[j+1])down_max=num[j]-num[j+1];
        }
      }
      System.out.println(upper_max+" "+down_max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < N do ( (     var M : int ; M := sc.getCurrent()->toInteger() ;
     var num : Sequence(int) ; num := Integer.subrange(1,M)->collect(0) ;
        var j : int ; j := 0 ; while j < M do ( (     num[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    var upper_max : int ; upper_max := 0 ;
    var down_max : int ; down_max := 0 ;
        var j : int ; j := 0 ; while j < M - 1 do ( (     if (num[j+1] < num[j + 1+1]) then (     if (upper_max < num[j + 1+1] - num[j+1]) then     upper_max := num[j + 1+1] - num[j+1] ; else skip ) else skip ; 
     if (num[j+1] > num[j + 1+1]) then (     if (down_max < num[j+1] - num[j + 1+1]) then     down_max := num[j+1] - num[j + 1+1] ; else skip ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(upper_max + " " + down_max) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int t,n,u,d,i,a,b ;
    t=sc.nextInt();
    for(; t-->0 ; ){
      n=sc.nextInt();
      u=0 ;
      d=0 ;
      a=sc.nextInt();
      for(i=1 ; i<n ; i++){
        b=sc.nextInt();
        if(b-a>0 && b-a>u)u=b-a ;
        if(a-b>0 && a-b>d)d=a-b ;
        a=b ;
      }
      out.println(u+" "+d);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var t : int ;
    var n : int ;
    var u : int ;
    var d : int ;
    var i : int ;
    var a : int ;
    var b : int ;
    t := sc.nextInt() ; 
      while t > 0 do ( (     n := sc.nextInt() ; 
     u := 0 ; 
    d := 0 ; 
    a := sc.nextInt() ; 
        i := 1 ; while i < n do ( (     b := sc.nextInt() ; 
     if (b - a > 0 & b - a > u) then     u := b - a ; else skip ; 
     if (a - b > 0 & a - b > d) then     d := a - b ; else skip ; 
     a := b )  ;     i := i + 1 ) ; 
    out.println(u + " " + d) ; 
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class Main {
  public static void main(String[] args){
    BufferedReader insBR=new BufferedReader(new InputStreamReader(System.in));
    List<Integer>listAnswer=new ArrayList<Integer>();
    try {
      String strTurn=insBR.readLine();
      int intTurn=Integer.parseInt(strTurn);
      for(int i=0 ; i<intTurn ; i++){
        insBR.readLine();
        List<Integer>listMountain=new ArrayList<Integer>();
        String[] strMountain=insBR.readLine().split(" ");
        for(int j=0 ; j<strMountain.length ; j++){
          int intMountain=Integer.parseInt(strMountain[j]);
          listMountain.add(intMountain);
        }
        int intClimb=0 ;
        int intDescend=0 ;
        for(int j=0 ; j+1<listMountain.size(); j++){
          int intDistance=listMountain.get(j+1)-listMountain.get(j);
          if(intClimb<intDistance){
            intClimb=intDistance ;
          }
          else if(intDistance<0){
            intDistance=Math.abs(intDistance);
            if(intDescend<intDistance){
              intDescend=intDistance ;
            }
          }
        }
        listAnswer.add(intClimb);
        listAnswer.add(intDescend);
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
    catch(NumberFormatException e){
      e.printStackTrace();
    }
    for(int i=0 ; i<listAnswer.size(); i++){
      int intDiv=i % 2 ;
      if(intDiv==0){
        System.out.print(listAnswer.get(i)+" ");
      }
      else {
        System.out.println(listAnswer.get(i));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var insBR : OclFile ; insBR := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var listAnswer : Sequence(int) ; listAnswer := Sequence{} ;
     try (     var strTurn : String ; strTurn := insBR.readLine() ;
     var intTurn : int ; intTurn := (strTurn)->toInteger() ;
         var i : int ; i := 0 ; while i < intTurn do ( (     skip ; 
     var listMountain : Sequence(int) ; listMountain := Sequence{} ;
    var strMountain : Sequence(String) ; strMountain := insBR.readLine()->split(" ") ;
        var j : int ; j := 0 ; while j < strMountain->size() do ( (     var intMountain : int ; intMountain := (strMountain[j+1])->toInteger() ;
     listMountain := listMountain->including(intMountain) )  ;     j := j + 1 ) ; 
    var intClimb : int ; intClimb := 0 ;
    var intDescend : int ; intDescend := 0 ;
        var j : int ; j := 0 ; while j + 1 < listMountain->size() do ( (     var intDistance : int ; intDistance := listMountain->at(j + 1+1) - listMountain->at(j+1) ;
     if (intClimb < intDistance) then (     intClimb := intDistance ) else     if (intDistance < 0) then (     intDistance := if intDistance < 0 then -(intDistance) else intDistance endif ; 
     if (intDescend < intDistance) then (     intDescend := intDistance ) else skip ) else skip ; )  ;     j := j + 1 ) ; 
    listAnswer := listAnswer->including(intClimb) ; 
    listAnswer := listAnswer->including(intDescend) ; 
 )  ;     i := i + 1 ) )   catch (e : IOException) do (     e.printStackTrace() )
   catch (e : IncorrectElementException) do (     e.printStackTrace() )
         var i : int ; i := 0 ; while i < listAnswer->size() do ( (     var intDiv : int ; intDiv := i mod 2 ;
     if (intDiv = 0) then (     OclFile["System.out"].print(listAnswer->at(i+1) + " ") ) else (     OclFile["System.out"].println(listAnswer->at(i+1)) ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
    String s ;
    int n ;
    int box ;
    String[] HIGH ;
    int[] h ;
    try {
      while((s=r.readLine())!=null){
        n=Integer.parseInt(s);
        for(int i=0 ; i<n ; i++){
          String kosuu=r.readLine();
          String highdata=r.readLine();
          box=Integer.parseInt(kosuu);
          HIGH=highdata.split(" ");
          h=new int[HIGH.length];
          for(int a=0 ; a<HIGH.length ; a++){
            h[a]=Integer.parseInt(HIGH[a]);
          }
          int[] highdifup=new int[box-1];
          int[] highdifdown=new int[box-1];
          for(int b=0 ; b<box-1 ; b++){
            highdifup[b]=h[b+1]-h[b];
          }
          for(int c=0 ; c<box-1 ; c++){
            highdifdown[c]=h[c]-h[c+1];
          }
          Arrays.sort(highdifup);
          Arrays.sort(highdifdown);
          if(highdifup[box-2]<0){
            highdifup[box-2]=0 ;
          }
          if(highdifdown[box-2]<0){
            highdifdown[box-2]=0 ;
          }
          System.out.println(highdifup[box-2]+" "+highdifdown[box-2]);
          for(int w=0 ; w<box-1 ; w++){
            highdifup[w]=0 ;
            highdifdown[w]=0 ;
          }
        }
      }
    }
    catch(IOException e){
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ;
    var n : int ;
    var box : int ;
    var HIGH : Sequence(String) ;
    var h : Sequence(int) ;
    try (         s := r.readLine() ;
    while ((s) /= null) do (    skip ; (     n := (s)->toInteger() ; 
         var i : int ; i := 0 ; while i < n do ( (     var kosuu : String ; kosuu := r.readLine() ;
     var highdata : String ; highdata := r.readLine() ;
    box := (kosuu)->toInteger() ; 
    HIGH := highdata->split(" ") ; 
    h := Integer.subrange(1,HIGH->size())->collect(0) ; 
        var a : int ; a := 0 ; while a < HIGH->size() do ( (     h[a+1] := (HIGH[a+1])->toInteger() )  ;     a := a + 1 ) ; 
    var highdifup : Sequence(int) ; highdifup := Integer.subrange(1,box - 1)->collect(0) ;
    var highdifdown : Sequence(int) ; highdifdown := Integer.subrange(1,box - 1)->collect(0) ;
        var b : int ; b := 0 ; while b < box - 1 do ( (     highdifup[b+1] := h[b + 1+1] - h[b+1] )  ;     b := b + 1 ) ; 
        var c : int ; c := 0 ; while c < box - 1 do ( (     highdifdown[c+1] := h[c+1] - h[c + 1+1] )  ;     c := c + 1 ) ; 
    highdifup := highdifup->sort() ; 
    highdifdown := highdifdown->sort() ; 
    if (highdifup[box - 2+1] < 0) then (     highdifup[box - 2+1] := 0 ) else skip ; 
    if (highdifdown[box - 2+1] < 0) then (     highdifdown[box - 2+1] := 0 ) else skip ; 
    OclFile["System.out"].println(highdifup[box - 2+1] + " " + highdifdown[box - 2+1]) ; 
        var w : int ; w := 0 ; while w < box - 1 do ( (     highdifup[w+1] := 0 ; 
     highdifdown[w+1] := 0 )  ;     w := w + 1 ) ; 
 )  ;     i := i + 1 ) ) ;     s := r.readLine() ;
 ) )   catch (e : IOException) do (     OclFile["System.out"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPrime(long n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    if(n % 2==0 || n % 3==0)return false ;
    for(long i=5 ; i*i<=n ; i=i+6)if(n % i==0 || n %(i+2)==0)return false ;
    return true ;
  }
  static boolean isDiffPrime(long a,long b){
    if(isPrime(a+b)&& a-b==1)return true ;
    else return false ;
  }
  public static void main(String[] args){
    long a=6,b=5 ;
    if(isDiffPrime(a,b))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : long ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation isDiffPrime( a : long, b : long) : boolean
  pre: true
  post: true
  activity: (     if (isPrime(a + b) & a - b = 1) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ; a := 6 ;
    var b : long ; b := 5 ;
     if (isDiffPrime(a, b)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    try {
      System.setIn(new FileInputStream("src/aoj2100/input.txt"));
    }
    catch(FileNotFoundException e){
    }
    new Main().run();
  }
  Scanner sc ;
  void run(){
    sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0){
      solve();
    }
  }
  void solve(){
    int N=sc.nextInt();
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++)a[i]=sc.nextInt();
    int A=0,B=0 ;
    for(int i=1 ; i<N ; i++)A=max(A,a[i]-a[i-1]);
    for(int i=1 ; i<N ; i++)B=max(B,a[i-1]-a[i]);
    System.out.println(A+" "+B);
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("src/aoj2100/input.txt"))) )   catch (e : FileNotFoundException) do skip
     Main.newMain().run() );
   attribute sc : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var T : int ; T := sc.getCurrent()->toInteger() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     execute solve() ) ;  ) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var A : int ; A := 0 ;
    var B : int ; B := 0 ;
        var i : int ; i := 1 ; while i < N do (     A := Set{A, a[i+1] - a[i - 1+1]}->max() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < N do (     B := Set{B, a[i - 1+1] - a[i+1]}->max() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(A + " " + B) ; 
 );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Number {
  private static boolean run(final char[] s,final int[] d1,final int[] d,final int k){
    if(k==s.length){
      for(int i=1 ; i<10 ; ++i){
        if(d1[i]!=d[i]){
          return false ;
        }
      }
      return true ;
    }
    while(true){
      char c=s[k];
      if(c>'9'){
        s[k]='0' ;
        return false ;
      }
      int x=c-'0' ;
      if(d1[x]<d[x]){
++d1[x];
        if(run(s,d1,d,k+1)){
          return true ;
        }
--d1[x];
      }
++s[k];
    }
  }
  public static void main(final String...args)throws IOException {
    final String fname="B-large" ;
    final Scanner sc=new Scanner(new File(fname+".in"));
    final PrintWriter pw=new PrintWriter(fname+".out");
    final int t=sc.nextInt();
    sc.nextLine();
    for(int i=0 ; i<t ; ++i){
      final char[] s=('0'+sc.nextLine()).toCharArray();
      final int[] d=new int[10];
      for(char c : s){
        d[c-'0']++;
      }
++s[s.length-1];
      final int[] d1=new int[10];
      if(! run(s,d1,d,0)){
        throw new RuntimeException();
      }
      final String r=String.valueOf(s);
      pw.println("Case #"+(i+1)+": "+(s[0]=='0' ? r.substring(1): r));
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Number {
  static   operation run( s : Sequence(String), d1 : Sequence(int), d : Sequence(int), k : int) : boolean
  pre: true
  post: true
  activity: (     if (k = s->size()) then (         var i : int ; i := 1 ; while i < 10 do ( (     if (d1[i+1] /= d[i+1]) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true ) else skip ; 
     while (true) do (     var c : String ; c := s[k+1] ;
     if (c > '9') then (     s[k+1] := '0' ; 
     return false ) else skip ; 
    var x : int ; x := (c)->char2byte() - ('0')->char2byte() ;
    if (d1[x+1] < d[x+1]) then (     d1[x+1] := d1[x+1] + 1 ; 
     if (run(s, d1, d, k + 1)) then (     return true ) else skip ; 
     d1[x+1] := d1[x+1] - 1 ) else skip ; 
    s[k+1] := s[k+1] + 1 ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fname : String ; fname := "B-large" ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile(fname + ".in")) ;
    var pw : OclFile ; pw := OclFile.newOclFile_Write(fname + ".out") ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    skip ; 
        var i : int ; i := 0 ; while i < t do ( (     var s : Sequence(String) ; s := ('0' + sc.nextLine())->characters() ;
     var d : Sequence(int) ; d := Integer.subrange(1,10)->collect(0) ;
    for (c : s) do ( (     d[(c)->char2byte() - ('0')->char2byte()+1] := d[(c)->char2byte() - ('0')->char2byte()+1] + 1 )  ) ; 
    s[s->size() - 1+1] := s[s->size() - 1+1] + 1 ; 
    var d1 : Sequence(int) ; d1 := Integer.subrange(1,10)->collect(0) ;
    if (not(run(s, d1, d, 0))) then (     error ProgramException() ) else skip ; 
    var r : String ; r := (s)->sum()  ;
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
import java.io.File ;
import java.io.PrintWriter ;
import java.io.FileNotFoundException ;
public class B {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner in=new Scanner(new File("B.in"));
    PrintWriter out=new PrintWriter("B.out");
    int t=in.nextInt();
    in.nextLine();
    for(int tn=0 ; tn<t ; tn++){
      out.println("Case #"+(tn+1)+": "+solve(in));
    }
    out.close();
  }
  private static String solve(Scanner in){
    String s=in.nextLine().trim();
    if(s.length()==1)return s+"0" ;
    char[] a=s.toCharArray();
    int i=s.length()-2 ;
    while(i>-1 && a[i]>=a[i+1])i--;
    if(i==-1){
      Arrays.sort(a);
      i=0 ;
      while(a[i]=='0')i++;
      char p=a[i];
      a[i]='0' ;
      return p+new String(a);
    }
    else {
      int j=s.length()-1 ;
      while(a[j]<=a[i])j--;
      char t=a[i];
      a[i]=a[j];
      a[j]=t ;
      Arrays.sort(a,i+1,a.length);
      return new String(a);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("B.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("B.out")) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
    skip ; 
        var tn : int ; tn := 0 ; while tn < t do ( (     skip )  ;     tn := tn + 1 ) ; 
    skip ; 
 );
  static   operation solve( in : OclFile) : String
  pre: true
  post: true
  activity: (     var s : String ; s := in.nextLine()->trim() ;
     if (s->size() = 1) then     return s + "0" else skip ; 
    var a : Sequence(String) ; a := s->characters() ;
    var i : int ; i := s->size() - 2 ;
    while (i > -1 & a[i+1] >= a[i + 1+1]) do     i := i - 1 ; ; 
    if (i = -1) then (     a := a->sort() ; 
     i := 0 ; 
    while (a[i+1] = '0') do     i := i + 1 ; ; 
    var p : String ; p := a[i+1] ;
    a[i+1] := '0' ; 
    return p + StringLib.newString(a) 
 ) else (     var j : int ; j := s->size() - 1 ;
     while (a[j+1] <= a[i+1]) do     j := j - 1 ; ; 
    var t : String ; t := a[i+1] ;
    a[i+1] := a[j+1] ; 
    a[j+1] := t ; 
    a := a.subrange(1,i + 1)^(a.subrange(i + 1+1,a->size())->sort())^a.subrange(a->size()+1,a.size) ; 
    return StringLib.newString(a) 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.util.Arrays ;
public class B {
  public static final String FILE_NAME="B-large" ;
  public static void main(String[] args)throws Exception {
    BufferedReader input=new BufferedReader(new FileReader(FILE_NAME+".in"));
    BufferedWriter output=new BufferedWriter(new FileWriter(FILE_NAME+".out"));
    final int T=Integer.parseInt(input.readLine());
    for(int t=0 ; t<T ; t++){
      output.append("Case #"+(t+1)+": ");
      char[] chars=input.readLine().trim().toCharArray();
      int k=chars.length-1 ;
      while(k>0 && chars[k]<=chars[k-1])k--;
      if(k>0){
        int p=k ;
        char min='9'+1 ;
        for(int q=k ; q<chars.length ; q++){
          if(chars[q]>chars[k-1] && chars[q]<min){
            min=chars[q];
            p=q ;
          }
        }
        char c=chars[p];
        chars[p]=chars[k-1];
        chars[k-1]=c ;
        Arrays.sort(chars,k,chars.length);
        for(int x=0 ; x<chars.length ; x++)output.append(chars[x]);
      }
      else {
        Arrays.sort(chars);
        int j=0 ;
        while(chars[j]=='0')j++;
        output.append(chars[j]);
        for(int x=0 ; x<j+1 ; x++)output.append('0');
        for(int x=j+1 ; x<chars.length ; x++)output.append(chars[x]);
      }
      output.append('\n');
    }
    output.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static    attribute FILE_NAME : String := "B-large";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(FILE_NAME + ".in")) ;
     var output : OclFile ; output := OclFile.newOclFile_Write(OclFile.newOclFile_Write(FILE_NAME + ".out")) ;
    var T : int ; T := (input.readLine())->toInteger() ;
        var t : int ; t := 0 ; while t < T do ( (     skip ; 
     var chars : Sequence(String) ; chars := input.readLine()->trim()->characters() ;
    var k : int ; k := chars->size() - 1 ;
    while (k > 0 & chars[k+1] <= chars[k - 1+1]) do     k := k - 1 ; ; 
    if (k > 0) then (     var p : int ; p := k ;
     var min : String ; min := '9' + 1 ;
        var q : int ; q := k ; while q < chars->size() do ( (     if (chars[q+1] > chars[k - 1+1] & chars[q+1] < min) then (     min := chars[q+1] ; 
     p := q ) else skip )  ;     q := q + 1 ) ; 
    var c : String ; c := chars[p+1] ;
    chars[p+1] := chars[k - 1+1] ; 
    chars[k - 1+1] := c ; 
    chars := chars.subrange(1,k)^(chars.subrange(k+1,chars->size())->sort())^chars.subrange(chars->size()+1,chars.size) ; 
        var x : int ; x := 0 ; while x < chars->size() do (     skip ;  ;     x := x + 1 ) ; 
 ) else (     chars := chars->sort() ; 
     var j : int ; j := 0 ;
    while (chars[j+1] = '0') do     j := j + 1 ; ; 
    skip ; 
        var x : int ; x := 0 ; while x < j + 1 do (     skip ;  ;     x := x + 1 ) ; 
        var x : int ; x := j + 1 ; while x < chars->size() do (     skip ;  ;     x := x + 1 ) ; 
 ) ;  
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printArray(int arr[],int n){
    for(int i=0 ; i<n ; i++){
      System.out.print(arr[i]+" ");
    }
  }
  static int getMin(int arr[],int i,int j){
    int minVal=arr[i++];
    while(i<=j){
      minVal=Math.min(minVal,arr[i]);
      i++;
    }
    return minVal ;
  }
  static int getMax(int arr[],int i,int j){
    int maxVal=arr[i++];
    while(i<=j){
      maxVal=Math.max(maxVal,arr[i]);
      i++;
    }
    return maxVal ;
  }
  static void generateArr(int arr[],int n){
    if(n==0)return ;
    if(n==1){
      System.out.println(arr[0]);
      return ;
    }
    int tmpArr[]=new int[n];
    tmpArr[0]=getMax(arr,1,n-1);
    for(int i=1 ; i<n-1 ; i++){
      tmpArr[i]=Math.abs(getMax(arr,i+1,n-1)-getMin(arr,0,i-1));
    }
    tmpArr[n-1]=getMin(arr,0,n-2);
    printArray(tmpArr,n);
  }
  public static void main(String[] args){
    int arr[]={
      1,5,2,4,3 };
      int n=arr.length ;
      generateArr(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
  static   operation getMin( arr : Sequence(int), i : int, j : int) : int
  pre: true
  post: true
  activity: (     var minVal : int ; minVal := arr[i+1] ;
     while (i <= j) do (     minVal := Set{minVal, arr[i+1]}->min() ; 
     i := i + 1 ) ; 
     return minVal );
  static   operation getMax( arr : Sequence(int), i : int, j : int) : int
  pre: true
  post: true
  activity: (     var maxVal : int ; maxVal := arr[i+1] ;
     while (i <= j) do (     maxVal := Set{maxVal, arr[i+1]}->max() ; 
     i := i + 1 ) ; 
     return maxVal );
  static   operation generateArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     if (n = 0) then     return else skip ; 
     if (n = 1) then (     OclFile["System.out"].println(arr[0+1]) ; 
     return ) else skip ; 
    var tmpArr : Sequence(int) ; tmpArr := Integer.subrange(1,n)->collect(0) ;
    tmpArr[0+1] := getMax(arr, 1, n - 1) ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     tmpArr[i+1] := if getMax(arr, i + 1, n - 1) - getMin(arr, 0, i - 1) < 0 then -(getMax(arr, i + 1, n - 1) - getMin(arr, 0, i - 1)) else getMax(arr, i + 1, n - 1) - getMin(arr, 0, i - 1) endif )  ;     i := i + 1 ) ; 
    tmpArr[n - 1+1] := getMin(arr, 0, n - 2) ; 
    execute printArray(tmpArr, n) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,2,4,3} ;
     var n : int ; n := arr->size() ;
     execute generateArr(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileInputStream ;
import java.io.FileOutputStream ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
import java.math.BigInteger ;
import java.util.StringTokenizer ;
public class B {
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  public static void main(String args[])throws Exception {
    in=new BufferedReader(new InputStreamReader(new FileInputStream("b.in")));
    out=new PrintWriter(new OutputStreamWriter(new FileOutputStream("b.out")));
    int T=nextInt();
    for(int t=0 ; t<T ; t++){
      String n="0"+next();
      int cnts[]=new int[10];
      String ans ;
      PLoop : for(int p=n.length()-1 ;
      ;
      p--){
        int c=n.charAt(p)-'0' ;
++cnts[c];
        for(int nc=c+1 ; nc<10 ; ++nc){
          if(cnts[nc]>0){
            StringBuilder sb=new StringBuilder();
            sb.append(n.substring(0,p));
            sb.append((char)('0'+nc));
--cnts[nc];
            for(int i=0 ; i<10 ; ++i){
              while(cnts[i]>0){
                sb.append((char)('0'+i));
--cnts[i];
              }
            }
            ans=sb.toString();
            break PLoop ;
          }
        }
        if(p==0){
          throw new AssertionError();
        }
      }
      out.println("Case #"+(t+1)+": "+new BigInteger(ans).toString());
    }
    in.close();
    out.close();
  }
  static String next()throws IOException {
    while(tok==null || ! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("b.in")))) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("b.out")))) ; 
    var T : int ; T := nextInt() ;
        var t : int ; t := 0 ; while t < T do ( (     var n : String ; n := "0" + next() ;
     var cnts : Sequence(int) ; cnts := Integer.subrange(1,10)->collect(0) ;
    var ans : String ;
        var p : int ; p := n->size() - 1 ; while true do ( (     var c : int ; c := n->at(p+1) - ('0')->char2byte() ;
     cnts[c+1] := cnts[c+1] + 1 ; 
         var nc : int ; nc := c + 1 ; while nc < 10 do ( (     if (cnts[nc+1] > 0) then (     var sb : String ; sb := StringLib.newString() ;
     sb := sb + StringLib.newString(n.subrange(0+1,p)) ; 
    sb := sb + StringLib.newString(('0' + nc)->oclAsType(String)) ; 
    cnts[nc+1] := cnts[nc+1] - 1 ; 
        var i : int ; i := 0 ; while i < 10 do ( (     while (cnts[i+1] > 0) do (     sb := sb + StringLib.newString(('0' + i)->oclAsType(String)) ; 
     cnts[i+1] := cnts[i+1] - 1 ) )  ;     i := i + 1 ) ; 
    ans := sb+"" ; 
    break 
 ) else skip )  ;     nc := nc + 1 ) ; 
     if (p = 0) then (     error AssertionException() ) else skip )  ;     p := p - 1 ) ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (tok = null or not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return tok.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.math.BigInteger ;
import java.util.StringTokenizer ;
public class B {
  String test(){
    char[] s=("0"+nextToken()).toCharArray();
    int[] cnt=new int[128];
    fori : for(int i=s.length-1 ;
    i>=0 ;
    i--){
      cnt[s[i] ]++;
      for(char j=(char)(s[i]+1); j<='9' ; j++){
        if(cnt[j]>0){
          s[i]=j ;
          cnt[j]--;
          for(int k=i+1 ; k<cnt.length ; k++){
            for(char d='0' ; d<='9' ; d++){
              if(cnt[d]>0){
                s[k]=d ;
                cnt[d]--;
                break ;
              }
            }
          }
          break fori ;
        }
      }
    }
    return new BigInteger(new String(s)).toString();
  }
  private void solve(){
    int n=nextInt();
    for(int i=0 ; i<n ; i++){
      out.println("Case #"+(i+1)+": "+test());
    }
  }
  PrintWriter out ;
  BufferedReader br ;
  StringTokenizer st ;
  private void run(){
    try {
      br=new BufferedReader(new FileReader("B-large.in"));
      out=new PrintWriter("B-large.out");
      solve();
      out.close();
    }
    catch(FileNotFoundException e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  String nextToken(){
    try {
      while(st==null || ! st.hasMoreTokens()){
        st=new StringTokenizer(br.readLine());
      }
      return st.nextToken();
    }
    catch(IOException e){
      return "" ;
    }
  }
  int nextInt(){
    return Integer.parseInt(nextToken());
  }
  public static void main(String[] args){
    new B().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
   operation test() : String
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := ("0" + nextToken())->characters() ;
     var cnt : Sequence(int) ; cnt := Integer.subrange(1,128)->collect(0) ;
         var i : int ; i := s->size() - 1 ; while i >= 0 do ( (     cnt[s[i+1]+1] := cnt[s[i+1]+1] + 1 ; 
         var j : String ; j := (s[i+1] + 1)->oclAsType(String) ; while j <= '9' do ( (     if (cnt[j+1] > 0) then (     s[i+1] := j ; 
     cnt[j+1] := cnt[j+1] - 1 ; 
         var k : int ; k := i + 1 ; while k < cnt->size() do ( (         var d : String ; d := '0' ; while d <= '9' do ( (     if (cnt[d+1] > 0) then (     s[k+1] := d ; 
     cnt[d+1] := cnt[d+1] - 1 ; 
     break ) else skip )  ;     d := d + 1 ) )  ;     k := k + 1 ) ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
     return long(StringLib.newString(s))+"" );
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
         var i : int ; i := 0 ; while i < n do ( (     out.println("Case #" + (i + 1) + ": " + test()) )  ;     i := i + 1 ) );
   attribute out : OclFile;
   attribute br : OclFile;
   attribute st : OclIterator;
   operation run() : void
  pre: true
  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("B-large.in"))) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile("B-large.out")) ; 
     execute solve() ; 
     skip )   catch (e : FileNotFoundException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() )   catch (e : IOException) do (     return "" )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     B.newB().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[] A=new long[N];
    HashMap<Long,Integer>map=new HashMap<Long,Integer>();
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextLong();
      if(map.containsKey(A[i]))map.put(A[i],1+map.get(A[i]));
      else map.put(A[i],1);
    }
    Arrays.sort(A);
    int ret=0 ;
    for(int i=N-1 ; i>=0 ; i--){
      if(map.get(A[i])==0)continue ;
      map.put(A[i],map.get(A[i])-1);
      long k2=2*Long.highestOneBit(A[i]);
      long diff=k2-A[i];
      if(map.containsKey(diff)&& map.get(diff)>0){
        map.put(diff,map.get(diff)-1);
        ret++;
      }
    }
    System.out.println(ret);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
    var map : Map(long,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toLong() ; 
     if (map->keys()->includes(A[i+1])) then     map := map->union(Map{A[i+1] |-> 1 + map->at(A[i+1])}) ; else     map := map->union(Map{A[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    var ret : int ; ret := 0 ;
        var i : int ; i := N - 1 ; while i >= 0 do ( (     if (map->at(A[i+1]) = 0) then     continue else skip ; 
     map := map->union(Map{A[i+1] |-> map->at(A[i+1]) - 1}) ; 
    var k2 : long ; k2 := 2 * highestOneBit(A[i+1]) ;
    var diff : long ; diff := k2 - A[i+1] ;
    if (map->keys()->includes(diff) & map->at(diff) > 0) then (     map := map->union(Map{diff |-> map->at(diff) - 1}) ; 
     ret := ret + 1 ) else skip ; 
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ret) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextLong();
    Arrays.sort(a);
    Map<Long,Integer>map=new HashMap<>();
    for(Long l : a)map.put(l,map.getOrDefault(l,0)+1);
    long ans=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(map.get(a[i])==0)continue ;
      map.put(a[i],map.get(a[i])-1);
      long diff=2*Long.highestOneBit(a[i])-a[i];
      if(map.containsKey(diff)&& map.get(diff)>0){
        ans++;
        map.put(diff,map.get(diff)-1);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var map : Map(long,int) ; map := Map{} ;
    for (l : a) do (     map := map->union(Map{l |-> (if map->keys()->contains(l) then map->at(l) else 0 endif) + 1}) ;  ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (map->at(a[i+1]) = 0) then     continue else skip ; 
     map := map->union(Map{a[i+1] |-> map->at(a[i+1]) - 1}) ; 
     var diff : long ; diff := 2 * highestOneBit(a[i+1]) - a[i+1] ;
     if (map->keys()->includes(diff) & map->at(diff) > 0) then (     ans := ans + 1 ; 
     map := map->union(Map{diff |-> map->at(diff) - 1}) ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Counter<T>extends HashMap<T,Integer>{
  public Counter(){
    super();
  }
  public Integer get(Object elm){
    return getOrDefault(elm,0);
  }
  public void add(T elm,int amount){
    if(! this.containsKey(elm))put(elm,amount);
    else replace(elm,get(elm)+amount);
  }
  public void addOne(T elm){
    add(elm,1);
  }
  public void remove(T elm,int amount){
    replace(elm,Math.max(get(elm)-amount,0));
  }
  public void removeOne(T elm){
    remove(elm,1);
  }
}
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    Counter<Long>ball=new Counter<>();
    for(int n=0 ; n<N ; n++)ball.addOne(sc.nextLong());
    long[] power=new long[32];
    power[31]=2 ;
    for(int i=30 ; i>=0 ; i--)power[i]=2*power[i+1];
    long ans=0 ;
    for(long p : power){
      for(Long b : ball.keySet()){
        int r=(p!=b*2)? Math.min(ball.get(b),ball.get(p-b)): ball.get(b)/2 ;
        ball.remove(b,r);
        ball.remove(new Long(p-b),r);
        ans+=r ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Counter<T> extends Map(T,int) {
   static operation newCounter() : Counter
  pre: true
  post: true
  activity:
  ( var self : Counter ;
    self := createCounter();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super() );
   operation get( elm : OclAny) : int
  pre: true
  post: true
  activity: (     return getOrDefault(elm, 0) );
   operation add( elm : T, amount : int) : void
  pre: true
  post: true
  activity: (     if (not(self.containsKey(elm))) then     execute put(elm, amount) ; else     execute replace(elm, at(elm+1) + amount) ; );
   operation addOne( elm : T) : void
  pre: true
  post: true
  activity: (     execute add(elm, 1) );
   operation remove( elm : T, amount : int) : void
  pre: true
  post: true
  activity: (     execute replace(elm, Set{get(elm) - amount, 0}->max()) );
   operation removeOne( elm : T) : void
  pre: true
  post: true
  activity: (     execute remove(elm, 1) );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var ball : Counter<long> ; ball := Counter<OclAny>.newCounter() ;
        var n : int ; n := 0 ; while n < N do (     ball.addOne(sc.getCurrent()->toLong()) ;  ;     n := n + 1 ) ; 
    var power : Sequence(long) ; power := Integer.subrange(1,32)->collect(0) ;
    power[31+1] := 2 ; 
        var i : int ; i := 30 ; while i >= 0 do (     power[i+1] := 2 * power[i + 1+1] ;  ;     i := i - 1 ) ; 
    var ans : long ; ans := 0 ;
    for (p : power) do ( (     for (b : ball.keySet()) do ( (     var r : int ; r := if (p /= b * 2) then Set{ball->at(b+1), ball->at(p - b+1)}->min() else ball->at(b+1) / 2 endif ;
     ball := ball - Integer.subrange(1,r)->collect(b) ; 
     ball := ball - Integer.subrange(1,r)->collect(("" + (p - b))->toLong()) ; 
     ans := ans+(r) )  ) )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    FastScanner scanner=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int ans=0 ;
    int n=scanner.nextInt();
    TreeMap<Long,Integer>mapping=new TreeMap<>();
    for(int i=0 ; i<n ; i++){
      long v=scanner.nextInt();
      if(! mapping.containsKey(v))mapping.put(v,0);
      mapping.put(v,mapping.get(v)+1);
    }
    while(! mapping.isEmpty()){
      long cur=mapping.lastKey();
      mapping.put(cur,mapping.get(cur)-1);
      if(mapping.get(cur)==0)mapping.remove(cur);
      long next=(Long.highestOneBit(cur))<<1 ;
      long val=next-cur ;
      if(mapping.containsKey(val)){
        ans++;
        mapping.put(val,mapping.get(val)-1);
        if(mapping.get(val)==0)mapping.remove(val);
      }
    }
    out.println(ans);
    out.flush();
  }
  public static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(Reader in){
      br=new BufferedReader(in);
    }
    public FastScanner(){
      this(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 readNextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : FastScanner ; scanner := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var ans : int ; ans := 0 ;
    var n : int ; n := scanner.nextInt() ;
    var mapping : Map(long,int) ; mapping := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var v : long ; v := scanner.nextInt() ;
     if (not(mapping->keys()->includes(v))) then     mapping := mapping->union(Map{v |-> 0}) ; else skip ; 
     mapping := mapping->union(Map{v |-> mapping->at(v) + 1}) )  ;     i := i + 1 ) ; 
    while (not(mapping->isEmpty())) do (     var cur : long ; cur := mapping->keys()->max() ;
     mapping := mapping->union(Map{cur |-> mapping->at(cur) - 1}) ; 
    if (mapping->at(cur) = 0) then     mapping := mapping->antirestrict(Set{cur}) ; else skip ; 
    var next : long ; next := ((highestOneBit(cur))*(2->pow(1)))->oclAsType(long) ;
    var val : long ; val := next - cur ;
    if (mapping->keys()->includes(val)) then (     ans := ans + 1 ; 
     mapping := mapping->union(Map{val |-> mapping->at(val) - 1}) ; 
     if (mapping->at(val) = 0) then     mapping := mapping->antirestrict(Set{val}) ; else skip ) else skip ; 
 ) ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(in) );
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation readNextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long ans[][]=new long[2][21];
    ans[0][sc.nextInt()]=1 ;
    for(int i=0 ; i<n-2 ; i++){
      int val=sc.nextInt();
      fill(ans[i % 2==0 ? 1 : 0],0);
      for(int j=0 ; j<=20 ; j++){
        if(j+val<=20)ans[i % 2==0 ? 1 : 0][j+val]+=ans[i % 2==0 ? 0 : 1][j];
        if(j-val>=0)ans[i % 2==0 ? 1 : 0][j-val]+=ans[i % 2==0 ? 0 : 1][j];
      }
    }
    System.out.println(ans[n % 2][sc.nextInt()]);
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : Sequence(Sequence(long)) ; ans := Integer.subrange(1,2)->collect(Integer.subrange(1,21)->collect(0)) ;
    ans[0+1][sc.getCurrent()->toInteger()+1] := 1 ; 
        var i : int ; i := 0 ; while i < n - 2 do ( (     var val : int ; val := sc.getCurrent()->toInteger() ;
     execute fill(ans[if i mod 2 = 0 then 1 else 0 endif+1], 0) ; 
         var j : int ; j := 0 ; while j <= 20 do ( (     if (j + val <= 20) then     ans[if i mod 2 = 0 then 1 else 0 endif+1][j + val+1] := ans[if i mod 2 = 0 then 1 else 0 endif+1][j + val+1]+(ans[if i mod 2 = 0 then 0 else 1 endif+1][j+1]) ; else skip ; 
     if (j - val >= 0) then     ans[if i mod 2 = 0 then 1 else 0 endif+1][j - val+1] := ans[if i mod 2 = 0 then 1 else 0 endif+1][j - val+1]+(ans[if i mod 2 = 0 then 0 else 1 endif+1][j+1]) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans[n mod 2+1][sc.getCurrent()->toInteger()+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int sum=sc.nextInt();
    int limit=sc.nextInt();
    ArrayList<Integer>ans=new ArrayList<>();
    for(int i=limit ; i>=1 ; i--){
      int lowbit=0 ;
      int tmp=i ;
      while(tmp>0){
        if((tmp & 1)==1){
          break ;
        }
        lowbit++;
        tmp>>=1 ;
      }
      if(Math.pow(2,lowbit)<=sum){
        sum-=Math.pow(2,lowbit);
        ans.add(i);
      }
      if(sum==0){
        pw.println(ans.size());
        for(int j=0 ; j<ans.size(); j++){
          pw.print(ans.get(j)+" ");
        }
        break ;
      }
    }
    if(sum!=0)pw.println(-1);
    sc.close();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sum : int ; sum := sc.getCurrent()->toInteger() ;
    var limit : int ; limit := sc.getCurrent()->toInteger() ;
    var ans : Sequence(int) ; ans := Sequence{} ;
        var i : int ; i := limit ; while i >= 1 do ( (     var lowbit : int ; lowbit := 0 ;
     var tmp : int ; tmp := i ;
    while (tmp > 0) do (     if ((MathLib.bitwiseAnd(tmp,1)) = 1) then (     break ) else skip ; 
     lowbit := lowbit + 1 ; 
     tmp := tmp/(2->pow(1)) ) ; 
    if (2->pow(lowbit) <= sum) then (     sum := sum-(2->pow(lowbit)) ; 
     ans := ans->including(i) ) else skip ; 
    if (sum = 0) then (     skip ; 
         var j : int ; j := 0 ; while j < ans->size() do ( (     skip )  ;     j := j + 1 ) ; 
     break ) else skip ; 
 )  ;     i := i - 1 ) ; 
    if (sum /= 0) then     skip ; else skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Map ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    TreeMap<Integer,Integer>map=new TreeMap<>();
    for(int i=0 ; i<N ; i++){
      int a=scanner.nextInt();
      map.put(a,map.getOrDefault(a,0)+1);
    }
    int cnt=0 ;
    while(! map.isEmpty()){
      Map.Entry<Integer,Integer>entry=map.lastEntry();
      int a=entry.getKey();
      int va=entry.getValue()-1 ;
      if(va==0)map.remove(a);
      else map.put(a,va);
      int b=(Integer.highestOneBit(a)<<1)-a ;
      if(map.containsKey(b)&& map.get(b)>0){
        int vb=map.get(b)-1 ;
        if(vb==0)map.remove(b);
        else map.put(b,vb);
        cnt++;
      }
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     map := map->union(Map{a |-> (if map->keys()->contains(a) then map->at(a) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    while (not(map->isEmpty())) do (     var entry : Map(int,int) ; entry := map.lastEntry() ;
     var a : int ; a := entry->keys()->any() ;
    var va : int ; va := entry->values->any() - 1 ;
    if (va = 0) then     map := map->antirestrict(Set{a}) else     map := map->union(Map{a |-> va}) ; ;  
    var b : int ; b := ((highestOneBit(a)*(2->pow(1)))->oclAsType(long)) - a ;
    if (map->keys()->includes(b) & map->at(b) > 0) then (     var vb : int ; vb := map->at(b) - 1 ;
     if (vb = 0) then     map := map->antirestrict(Set{b}) else     map := map->union(Map{b |-> vb}) ; ;  
     cnt := cnt + 1 ) else skip ; 
 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class geeks {
  public static int nCr(int n,int r){
    int res=1 ;
    for(int i=1 ; i<=r ; i++){
      res*=(n-r+i);
      res/=i ;
    }
    return res ;
  }
  public static int NoofSequences(int N,int M){
    HashMap<Integer,Integer>prime=new HashMap<>();
    for(int i=2 ; i<=Math.sqrt(M); i++){
      while(M % i==0){
        if(prime.get(i)==null)prime.put(i,1);
        else {
          int x=prime.get(i);
          prime.put(i,++x);
        }
        M/=i ;
      }
    }
    if(M>1){
      if(prime.get(M)!=null){
        int x=prime.get(M);
        prime.put(M,++x);
      }
      else prime.put(M,1);
    }
    int ans=1 ;
    for(HashMap.Entry<Integer,Integer>entry : prime.entrySet()){
      ans*=(nCr(N+entry.getValue()-1,N-1));
    }
    return ans ;
  }
  public static void main(String[] args){
    int N=2,M=6 ;
    System.out.println(NoofSequences(N,M));
  }
}
------------------------------------------------------------
OCL File:
---------
 class geeks {
  static   operation nCr( n : int, r : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
         var i : int ; i := 1 ; while i <= r do ( (     res := res*((n - r + i)) ; 
     res := res/(i) )  ;     i := i + 1 ) ; 
     return res );
  static   operation NoofSequences( N : int, M : int) : int
  pre: true
  post: true
  activity: (     var prime : Map(int,int) ; prime := Map{} ;
         var i : int ; i := 2 ; while i <= (M)->sqrt() do ( (     while (M mod i = 0) do (     if (prime->at(i) = null) then     prime := prime->union(Map{i |-> 1}) else (     var x : int ; x := prime->at(i) ;
     prime := prime->union(Map{i |-> (x + 1)}) ) ;  
     M := M/(i) ) )  ;     i := i + 1 ) ; 
    if (M > 1) then (     if (prime->at(M) /= null) then (     var x : int ; x := prime->at(M) ;
     prime := prime->union(Map{M |-> (x + 1)}) ) else     prime := prime->union(Map{M |-> 1}) ; ) else skip ; 
    var ans : int ; ans := 1 ;
    for (entry : prime->asSet()) do ( (     ans := ans*((nCr(N + entry.getValue() - 1, N - 1))) )  ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 2 ;
    var M : int ; M := 6 ;
     OclFile["System.out"].println(NoofSequences(N, M)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    String s=sc.next();
    long sum=0 ;
    for(int i=0 ; i<s.length(); i++){
      char ch=s.charAt(i);
      if(ch=='B')sum+=a[i];
    }
    long ans=sum ;
    long sum1=sum ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='A')sum1+=a[i];
      else sum1-=a[i];
      ans=Math.max(ans,sum1);
    }
    sum1=sum ;
    for(int i=s.length()-1 ; i>=0 ; i--){
      if(s.charAt(i)=='A')sum1+=a[i];
      else sum1-=a[i];
      ans=Math.max(ans,sum1);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var s : String ; s := sc.getCurrent() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var ch : String ; ch := s->at(i+1) ;
     if (ch = 'B') then     sum := sum+(a[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    var ans : long ; ans := sum ;
    var sum1 : long ; sum1 := sum ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'A') then     sum1 := sum1+(a[i+1]) else     sum1 := sum1-(a[i+1]) ; ;  
     ans := Set{ans, sum1}->max() )  ;     i := i + 1 ) ; 
    sum1 := sum ; 
        var i : int ; i := s->size() - 1 ; while i >= 0 do ( (     if (s->at(i+1) = 'A') then     sum1 := sum1+(a[i+1]) else     sum1 := sum1-(a[i+1]) ; ;  
     ans := Set{ans, sum1}->max() )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int INT_SIZE=32 ;
  static class TrieNode {
    int value ;
    TrieNode[] Child=new TrieNode[2];
    public TrieNode(){
      value=0 ;
      Child[0]=null ;
      Child[1]=null ;
    }
  }
  static TrieNode root ;
  static void insert(int key){
    TrieNode temp=root ;
    for(int i=INT_SIZE-1 ; i>=0 ; i--){
      int current_bit=(key &(1<<i))>=1 ? 1 : 0 ;
      if(temp!=null && temp.Child[current_bit]==null)temp.Child[current_bit]=new TrieNode();
      temp=temp.Child[current_bit];
    }
    temp.value=key ;
  }
  static int minXORUtil(int key){
    TrieNode temp=root ;
    for(int i=INT_SIZE-1 ; i>=0 ; i--){
      int current_bit=(key &(1<<i))>=1 ? 1 : 0 ;
      if(temp.Child[current_bit]!=null)temp=temp.Child[current_bit];
      else if(temp.Child[1-current_bit]!=null)temp=temp.Child[1-current_bit];
    }
    return key ^ temp.value ;
  }
  static int minXOR(int arr[],int n){
    int min_xor=Integer.MAX_VALUE ;
    root=new TrieNode();
    insert(arr[0]);
    for(int i=1 ; i<n ; i++){
      min_xor=Math.min(min_xor,minXORUtil(arr[i]));
      insert(arr[i]);
    }
    return min_xor ;
  }
  public static void main(String args[]){
    int arr[]={
      9,5,3 };
      int n=arr.length ;
      System.out.println(minXOR(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute INT_SIZE : int := 32;
  static class TrieNode {
   attribute value : int;
   attribute Child : Sequence(TrieNode) := Integer.subrange(1,2)->collect(null);
   static operation newTrieNode() : TrieNode
  pre: true
  post: true
  activity:
  ( var self : TrieNode ;
    self := createTrieNode();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     value := 0 ; 
     Child[0+1] := null ; 
     Child[1+1] := null );
}
  static   attribute root : TrieNode;
  static   operation insert( key : int) : void
  pre: true
  post: true
  activity: (     var temp : TrieNode ; temp := root ;
         var i : int ; i := INT_SIZE - 1 ; while i >= 0 do ( (     var current_bit : int ; current_bit := if (MathLib.bitwiseAnd(key,((1*(2->pow(i)))->oclAsType(long)))) >= 1 then 1 else 0 endif ;
     if (temp /= null & temp.Child[current_bit+1] = null) then     temp.Child[current_bit+1] := TrieNode.newTrieNode() ; else skip ; 
     temp := temp.Child[current_bit+1] )  ;     i := i - 1 ) ; 
     temp.value := key );
  static   operation minXORUtil( key : int) : int
  pre: true
  post: true
  activity: (     var temp : TrieNode ; temp := root ;
         var i : int ; i := INT_SIZE - 1 ; while i >= 0 do ( (     var current_bit : int ; current_bit := if (MathLib.bitwiseAnd(key,((1*(2->pow(i)))->oclAsType(long)))) >= 1 then 1 else 0 endif ;
     if (temp.Child[current_bit+1] /= null) then     temp := temp.Child[current_bit+1] ; else     if (temp.Child[1 - current_bit+1] /= null) then     temp := temp.Child[1 - current_bit+1] ; else skip ; )  ;     i := i - 1 ) ; 
     return key xor temp.value );
  static   operation minXOR( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var min_xor : int ; min_xor := 2147483647 ;
     root := TrieNode.newTrieNode() ; 
    execute insert(arr[0+1]) ; 
        var i : int ; i := 1 ; while i < n do ( (     min_xor := Set{min_xor, minXORUtil(arr[i+1])}->min() ; 
     execute insert(arr[i+1]) )  ;     i := i + 1 ) ; 
    return min_xor 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{9,5,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minXOR(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void ladder_pattern(int N){
    for(int i=0 ; i<=N ; i++){
      System.out.println("**");
      System.out.println("**");
      if(i<N){
        System.out.println("*****");
      }
    }
  }
  public static void main(String args[]){
    int N=3 ;
    ladder_pattern(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation ladder_pattern( N : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= N do ( (     OclFile["System.out"].println("**") ; 
     OclFile["System.out"].println("**") ; 
     if (i < N) then (     OclFile["System.out"].println("*****") ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
     execute ladder_pattern(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int atari=0 ;
    int hazure=0 ;
    int okane=0 ;
    int[] amari=new int[1000];
    int goods=M-1 ;
    for(int i=0 ; i<M ; i++){
      atari=sc.nextInt();
      hazure=sc.nextInt();
      if(atari>=N){
        goods--;
      }
      else {
        amari[okane]=atari ;
        okane++;
      }
    }
    int kingaku=0 ;
    if(goods>0){
      Arrays.sort(amari);
      for(int i=0 ; i<goods ; i++){
        kingaku+=N-amari[999-i];
      }
    }
    System.out.println(Math.max(kingaku,0));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var atari : int ; atari := 0 ;
    var hazure : int ; hazure := 0 ;
    var okane : int ; okane := 0 ;
    var amari : Sequence(int) ; amari := Integer.subrange(1,1000)->collect(0) ;
    var goods : int ; goods := M - 1 ;
        var i : int ; i := 0 ; while i < M do ( (     atari := sc.getCurrent()->toInteger() ; 
     hazure := sc.getCurrent()->toInteger() ; 
     if (atari >= N) then (     goods := goods - 1 ) else (     amari[okane+1] := atari ; 
     okane := okane + 1 ) )  ;     i := i + 1 ) ; 
    var kingaku : int ; kingaku := 0 ;
    if (goods > 0) then (     amari := amari->sort() ; 
         var i : int ; i := 0 ; while i < goods do ( (     kingaku := kingaku+(N - amari[999 - i+1]) )  ;     i := i + 1 ) ) else skip ; 
    OclFile["System.out"].println(Set{kingaku, 0}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  private static BufferedReader br ;
  private static ArrayList<String>dataSet=new ArrayList<String>();
  public static void main(String[] args)throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    String line=br.readLine();
    String[] splitedLine=line.split(" ");
    int N=Integer.parseInt(splitedLine[0]);
    int M=Integer.parseInt(splitedLine[1]);
    inputDataSet(M);
    int costSum=0 ;
    int max=0 ;
    for(String data : dataSet){
      int missNum=Integer.parseInt((data.split(" "))[1]);
      if(missNum>N){
        if(missNum>max){
          max=missNum ;
        }
        costSum+=missNum-N ;
      }
    }
    if(max>N){
      costSum-=max-N ;
    }
    System.out.println(costSum);
  }
  public static void inputDataSet(int rawNum){
    for(int i=0 ; i<rawNum ; i++){
      String line=null ;
      try {
        line=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      if(line==null)break ;
      dataSet.add(line);
    }
  }
  public static void inputDataSet(String terminal){
    while(true){
      String line=null ;
      try {
        line=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      if(line==null || line.equals(terminal))break ;
      dataSet.add(line);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile;
  static   attribute dataSet : Sequence(String) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     var line : String ; line := br.readLine() ;
    var splitedLine : Sequence(String) ; splitedLine := line->split(" ") ;
    var N : int ; N := (splitedLine[0+1])->toInteger() ;
    var M : int ; M := (splitedLine[1+1])->toInteger() ;
    execute inputDataSet(M) ; 
    var costSum : int ; costSum := 0 ;
    var max : int ; max := 0 ;
    for (data : dataSet) do ( (     var missNum : int ; missNum := ((data->split(" "))[1+1])->toInteger() ;
     if (missNum > N) then (     if (missNum > max) then (     max := missNum ) else skip ; 
     costSum := costSum+(missNum - N) ) else skip )  ) ; 
    if (max > N) then (     costSum := costSum-(max - N) ) else skip ; 
    OclFile["System.out"].println(costSum) ; 
 );
  static   operation inputDataSet( rawNum : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < rawNum do ( (     var line : String ; line := null ;
     try (     line := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     if (line = null) then     break else skip ; 
     dataSet := dataSet->including(line) )  ;     i := i + 1 ) );
  static   operation inputDataSet( terminal : String) : void
  pre: true
  post: true
  activity: (     while (true) do (     var line : String ; line := null ;
     try (     line := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     if (line = null or line = terminal) then     break else skip ; 
     dataSet := dataSet->including(line) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    Scanner sc=new Scanner(systemin);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int sum=0 ;
    int max=0 ;
    for(int i=0 ; i<M ; i++){
      int A=sc.nextInt();
      int B=sc.nextInt();
      int cnt=Math.max(N-A,0);
      sum+=cnt ;
      max=Math.max(max,cnt);
    }
    result.printf("%d\n",sum-max);
    sc.close();
    return false ;
  }
  PrintStream log ;
  PrintStream result=System.out ;
  BufferedReader systemin ;
  static Main instance=new Main();
  Main(){
    systemin=new BufferedReader(new InputStreamReader(System.in));
    log=new PrintStream(new OutputStream(){
      public void write(int b){
      }
    }
);
  }
  public static void main(String[] args)throws IOException {
    instance.main();
    instance.systemin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(systemin) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
    var cnt : int ; cnt := Set{N - A, 0}->max() ;
    sum := sum+(cnt) ; 
    max := Set{max, cnt}->max() ; 
 )  ;     i := i + 1 ) ; 
    result.printf("%d\n", sum - max) ; 
    skip ; 
    return false 
 );
   attribute log : OclFile;
   attribute result : OclFile := OclFile["System.out"];
   attribute systemin : OclFile;
  static   attribute instance : Main := Main.newMain();
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     systemin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     log := OclFile.newOclFile_Write(OclFile()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     instance.main() ; 
     instance.systemin.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    int[] arg=new int[100];
    int i=0,sum=0,mono=0,point=0 ;
    int[] atari=null ;
    boolean first=true ;
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String line ;
      while((line=br.readLine())!=null){
        String[] str=line.split(" ");
        if(first){
          point=Integer.parseInt(str[0]);
          mono=Integer.parseInt(str[1]);
          atari=new int[mono];
          first=false ;
        }
        else {
          atari[i]=Integer.parseInt(str[0]);
          i++;
          if(mono==i){
            break ;
          }
        }
      }
      for(int j=0 ; j<atari.length ; j++){
        int store=j ;
        int max=atari[j];
        for(int k=j+1 ; k<atari.length ; k++){
          if(atari[k]>max){
            max=atari[k];
            store=k ;
          }
        }
        int w=atari[j];
        atari[j]=atari[store];
        atari[store]=w ;
      }
      for(int j=0 ; j<atari.length-1 ; j++){
        if(atari[j]<point){
          sum+=(point-atari[j]);
        }
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arg : Sequence(int) ; arg := Integer.subrange(1,100)->collect(0) ;
     var i : int ; i := 0 ;
    var sum : int ; sum := 0 ;
    var mono : int ; mono := 0 ;
    var point : int ; point := 0 ;
    var atari : Sequence(int) ; atari := null ;
    var first : boolean ; first := true ;
    try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     var str : Sequence(String) ; str := line->split(" ") ;
     if (first) then (     point := (str[0+1])->toInteger() ; 
     mono := (str[1+1])->toInteger() ; 
     atari := Integer.subrange(1,mono)->collect(0) ; 
     first := false ) else (     atari[i+1] := (str[0+1])->toInteger() ; 
     i := i + 1 ; 
     if (mono = i) then (     break ) else skip ) ) ;     line := br.readLine() ;
 ) ;  
        var j : int ; j := 0 ; while j < atari->size() do ( (     var store : int ; store := j ;
     var max : int ; max := atari[j+1] ;
        var k : int ; k := j + 1 ; while k < atari->size() do ( (     if (atari[k+1] > max) then (     max := atari[k+1] ; 
     store := k ) else skip )  ;     k := k + 1 ) ; 
    var w : int ; w := atari[j+1] ;
    atari[j+1] := atari[store+1] ; 
    atari[store+1] := w ; 
 )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < atari->size() - 1 do ( (     if (atari[j+1] < point) then (     sum := sum+((point - atari[j+1])) ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ))  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static final Scanner s=new Scanner(System.in);
  static int getInt(){
    return Integer.parseInt(s.next());
  }
  public static void main(String[] $){
    int n=getInt(),m=getInt(),p[]=new int[m];
    for(int i=0 ; i<m ; i++){
      p[i]=getInt();
      s.next();
    }
    System.out.println(Arrays.stream(p).map(i->Math.max(0,n-i)).sorted().limit(m-1).sum());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := getInt() ;
    var m : int ; m := getInt() ;
    var p : Sequence(void) ; p := Integer.subrange(1,m)->collect(0) ;
         var i : int ; i := 0 ; while i < m do ( (     p[i+1] := getInt() ; 
     skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(stream(p)->collect( _x1 | (lambda i : OclAny in Set{0, n - i}->max())->apply(_x1) )->sort().subrange(1,m - 1)->sum()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String head=sc.nextLine();
    String text=sc.nextLine();
    HashMap<Character,Integer>hm=new HashMap<>();
    for(int i=0 ; i<head.length(); i++){
      char c=head.charAt(i);
      if(c!=' '){
        hm.put(c,hm.getOrDefault(c,0)+1);
      }
    }
    boolean flag=true ;
    for(int i=0 ; i<text.length(); i++){
      char c=text.charAt(i);
      if(c!=' '){
        if(! hm.containsKey(c)){
          flag=false ;
          break ;
        }
        else {
          hm.put(c,hm.get(c)-1);
          if(hm.get(c)==0){
            hm.remove(c);
          }
        }
      }
    }
    if(! flag){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var head : String ; head := sc.nextLine() ;
    var text : String ; text := sc.nextLine() ;
    var hm : Map(String,int) ; hm := Map{} ;
        var i : int ; i := 0 ; while i < head->size() do ( (     var c : String ; c := head->at(i+1) ;
     if (c /= ' ') then (     hm := hm->union(Map{c |-> (if hm->keys()->contains(c) then hm->at(c) else 0 endif) + 1}) ) else skip )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < text->size() do ( (     var c : String ; c := text->at(i+1) ;
     if (c /= ' ') then (     if (not(hm->keys()->includes(c))) then (     flag := false ; 
     break ) else (     hm := hm->union(Map{c |-> hm->at(c) - 1}) ; 
     if (hm->at(c) = 0) then (     hm := hm->antirestrict(Set{c}) ) else skip ) ) else skip )  ;     i := i + 1 ) ; 
    if (not(flag)) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int sum=sc.nextInt();
    int limit=sc.nextInt();
    StringBuilder ans=new StringBuilder();
    int len=0 ;
    for(int i=limit ; i>0 ; i--){
      int rmsb=(int)((Math.log10(i &-i))/Math.log10(2));
      int val=(int)Math.pow(2,rmsb);
      if(val<=sum){
        sum-=val ;
        ans.append(i+" ");
        len++;
      }
      if(sum==0)break ;
    }
    if(sum!=0){
      System.out.println(-1);
    }
    else {
      System.out.println(len);
      System.out.println(ans.toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sum : int ; sum := sc.getCurrent()->toInteger() ;
    var limit : int ; limit := sc.getCurrent()->toInteger() ;
    var ans : String ; ans := StringLib.newString() ;
    var len : int ; len := 0 ;
        var i : int ; i := limit ; while i > 0 do ( (     var rmsb : int ; rmsb := (((MathLib.bitwiseAnd(i,-i))->log10()) / (2)->log10())->oclAsType(int) ;
     var val : int ; val := 2->pow(rmsb)->oclAsType(int) ;
     if (val <= sum) then (     sum := sum-(val) ; 
     ans := ans + StringLib.newString(i + " ") ; 
     len := len + 1 ) else skip ; 
     if (sum = 0) then     break else skip )  ;     i := i - 1 ) ; 
    if (sum /= 0) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(len) ; 
     OclFile["System.out"].println(ans+"") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Letter {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int[] source=stats(in.nextLine());
    int[] target=stats(in.nextLine());
    boolean ok=true ;
    for(int i=0 ; i<source.length ; i++){
      if(source[i]<target[i]){
        ok=false ;
        break ;
      }
    }
    pw.println(ok ? "YES" : "NO");
    pw.close();
  }
  private static int[] stats(String s){
    int[] result=new int[256];
    for(char c : s.toCharArray()){
      if(c!=' '){
        result[c]++;
      }
    }
    return result ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Letter {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var source : Sequence(int) ; source := stats(in.nextLine()) ;
    var target : Sequence(int) ; target := stats(in.nextLine()) ;
    var ok : boolean ; ok := true ;
        var i : int ; i := 0 ; while i < source->size() do ( (     if (source[i+1] < target[i+1]) then (     ok := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation stats( s : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var result : Sequence(int) ; result := Integer.subrange(1,256)->collect(0) ;
     for (c : s->characters()) do ( (     if (c /= ' ') then (     result[c+1] := result[c+1] + 1 ) else skip )  ) ; 
     return result );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B632 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int[] A=new int[N];
    for(int n=0 ; n<N ; n++){
      A[n]=in.nextInt();
    }
    char[] S=in.next().toCharArray();
    long[] aSum=new long[N+1];
    long[] bSum=new long[N+1];
    for(int n=0 ; n<N ; n++){
      aSum[n+1]=aSum[n]+((S[n]=='A')? A[n] : 0);
      bSum[n+1]=bSum[n]+((S[n]=='B')? A[n] : 0);
    }
    long max=0 ;
    for(int n=0 ; n<=N ; n++){
      long score=aSum[n]+bSum[N]-bSum[n];
      max=Math.max(max,score);
      score=bSum[n]+aSum[N]-aSum[n];
      max=Math.max(max,score);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B632 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var S : Sequence(String) ; S := in.getCurrent()->characters() ;
    var aSum : Sequence(long) ; aSum := Integer.subrange(1,N + 1)->collect(0) ;
    var bSum : Sequence(long) ; bSum := Integer.subrange(1,N + 1)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     aSum[n + 1+1] := aSum[n+1] + (if (S[n+1] = 'A') then A[n+1] else 0 endif) ; 
     bSum[n + 1+1] := bSum[n+1] + (if (S[n+1] = 'B') then A[n+1] else 0 endif) )  ;     n := n + 1 ) ; 
    var max : long ; max := 0 ;
        var n : int ; n := 0 ; while n <= N do ( (     var score : long ; score := aSum[n+1] + bSum[N+1] - bSum[n+1] ;
     max := Set{max, score}->max() ; 
     score := bSum[n+1] + aSum[N+1] - aSum[n+1] ; 
     max := Set{max, score}->max() )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class problemB {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int dd[]=new int[10005];
    String heading=sc.nextLine();
    for(char character : heading.toCharArray()){
      dd[(int)character]++;
    }
    String line=sc.nextLine();
    for(char character : line.toCharArray()){
      if(character==' ')continue ;
      if(dd[(int)character]>0)dd[(int)character]--;
      else {
        System.out.println("NO");
        System.exit(0);
      }
    }
    System.out.println("YES");
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class problemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dd : Sequence(int) ; dd := Integer.subrange(1,10005)->collect(0) ;
    var heading : String ; heading := sc.nextLine() ;
    for (character : heading->characters()) do ( (     dd[character->oclAsType(int)+1] := dd[character->oclAsType(int)+1] + 1 )  ) ; 
    var line : String ; line := sc.nextLine() ;
    for (character : line->characters()) do ( (     if (character = ' ') then     continue else skip ; 
     if (dd[character->oclAsType(int)+1] > 0) then     dd[character->oclAsType(int)+1] := dd[character->oclAsType(int)+1] - 1 ; else (     OclFile["System.out"].println("NO") ; 
 OclProcess.exit(0) ) )  ) ; 
    OclFile["System.out"].println("YES") ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner ir=new Scanner(System.in);
    for(; ; ){
      int n=ir.nextInt();
      int m=ir.nextInt();
      if(n==0){
        return ;
      }
      Graph[] g=new Graph[n];
      int[] col=new int[n];
      for(int i=0 ; i<n ; i++){
        g[i]=new Graph();
      }
      for(int i=0 ; i<m ; i++){
        int u=ir.nextInt()-1 ;
        int v=ir.nextInt()-1 ;
        g[u] .add(v);
        g[v] .add(u);
      }
      if(! dfs(0,1,col,g)){
        System.out.println(0);
      }
      else {
        int b=0 ;
        for(int i=0 ; i<n ; i++){
          if(col[i]==1){
            b++;
          }
        }
        TreeSet<Integer>st=new TreeSet<>();
        if(b>=2 && b % 2==0){
          st.add(b/2);
        }
        if(n-b>=2 &&(n-b)% 2==0){
          st.add((n-b)/2);
        }
        System.out.println(st.size());
        for(int x : st){
          System.out.println(x);
        }
      }
    }
  }
  static boolean dfs(int cur,int c,int[] col,Graph[] g){
    if(col[cur]==0){
      col[cur]=c ;
    }
    else if(col[cur]!=c){
      return false ;
    }
    else {
      return true ;
    }
    for(int to : g[cur]){
      if(! dfs(to,c*-1,col,g)){
        return false ;
      }
    }
    return true ;
  }
  static class Graph extends ArrayList<Integer>{
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ir : OclFile ; ir := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := ir.getCurrent()->toInteger() ;
     var m : int ; m := ir.getCurrent()->toInteger() ;
    if (n = 0) then (     return ) else skip ; 
    var g : Sequence(Graph) ; g := Integer.subrange(1,n)->collect(null) ;
    var col : Sequence(int) ; col := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     g[i+1] := Graph.newGraph() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var u : int ; u := ir.getCurrent()->toInteger() - 1 ;
     var v : int ; v := ir.getCurrent()->toInteger() - 1 ;
     g[u+1]->excludes(v) ; 
     g[v+1]->excludes(u) )  ;     i := i + 1 ) ; 
    if (not(dfs(0, 1, col, g))) then (     OclFile["System.out"].println(0) ) else (     var b : int ; b := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (col[i+1] = 1) then (     b := b + 1 ) else skip )  ;     i := i + 1 ) ; 
    var st : Set(int) ; st := Set{} ;
    if (b >= 2 & b mod 2 = 0) then (     st := st->including(b / 2) ) else skip ; 
    if (n - b >= 2 & (n - b) mod 2 = 0) then (     st := st->including((n - b) / 2) ) else skip ; 
    OclFile["System.out"].println(st->size()) ; 
    for (x : st) do ( (     OclFile["System.out"].println(x) )  ) ; 
 ) ;  
 )  ) );
  static   operation dfs( cur : int, c : int, col : Sequence(int), g : Sequence(Graph)) : boolean
  pre: true
  post: true
  activity: (     if (col[cur+1] = 0) then (     col[cur+1] := c ) else     if (col[cur+1] /= c) then (     return false ) else (     return true ) ;  ;  
     for (to : g[cur+1]) do ( (     if (not(dfs(to, c * -1, col, g))) then (     return false ) else skip )  ) ; 
     return true );
  static class Graph extends Sequence(int) { }
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int nthTerm(int n){
    return 4*(int)Math.pow(n,2)-7*n+3 ;
  }
  public static void main(String args[]){
    int N=4 ;
    System.out.print(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nthTerm( n : int) : int
  pre: true
  post: true
  activity: (     return 4 * n->pow(2)->oclAsType(int) - 7 * n + 3 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].print(nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double PI=(3.14159/180);
  static float areaOfKite(int a,int b,double angle){
    angle=angle*PI ;
    double area=a*b*Math.sin(angle);
    return(float)area ;
  }
  public static void main(String[] args){
    int a=4,b=7,angle=78 ;
    System.out.println("Area of Kite="+areaOfKite(a,b,angle));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute PI : double := (3.14159 / 180);
  static   operation areaOfKite( a : int, b : int, angle : double) : double
  pre: true
  post: true
  activity: (     angle := angle * PI ; 
     var area : double ; area := a * b * (angle)->sin() ;
     return area->oclAsType(double) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 4 ;
    var b : int ; b := 7 ;
    var angle : int ; angle := 78 ;
     OclFile["System.out"].println("Area of Kite=" + areaOfKite(a, b, angle)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findK(int n,int k){
    ArrayList<Integer>a=new ArrayList<Integer>(n);
    for(int i=1 ; i<n ; i++)if(i % 2==1)a.add(i);
    for(int i=1 ; i<n ; i++)if(i % 2==0)a.add(i);
    return(a.get(k-1));
  }
  public static void main(String[] args){
    int n=10,k=3 ;
    System.out.println(findK(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findK( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{}->union(n) ;
         var i : int ; i := 1 ; while i < n do (     if (i mod 2 = 1) then     a := a->including(i) ; else skip ;  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i < n do (     if (i mod 2 = 0) then     a := a->including(i) ; else skip ;  ;     i := i + 1 ) ; 
     return (a->at(k - 1+1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
    var k : int ; k := 3 ;
     OclFile["System.out"].println(findK(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  final static long mod=1000000007 ;
  static long fact(long n){
    if(n==1)return 1 ;
    else return(fact(n-1)*n)% mod ;
  }
  static long countPairs(int m,int n){
    long ans=fact(2*m+n-1)/(fact(n-1)*fact(2*m));
    return(ans % mod);
  }
  public static void main(String[] args){
    int n=5,m=3 ;
    System.out.println(countPairs(m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute mod : long := 1000000007;
  static   operation fact( n : long) : long
  pre: true
  post: true
  activity: (     if (n = 1) then     return 1 else     return (fact(n - 1) * n) mod mod );
  static   operation countPairs( m : int, n : int) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := fact(2 * m + n - 1) / (fact(n - 1) * fact(2 * m)) ;
     return (ans mod mod) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var m : int ; m := 3 ;
     OclFile["System.out"].println(countPairs(m, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Solution {
  public boolean canPlaceFlowers(int[] flowerbed,int n){
    int count=0,curr ;
    for(int i=0 ; i<flowerbed.length ; i++){
      curr=flowerbed[i];
      if(i-1>=0)curr+=flowerbed[i-1];
      if(i+1<flowerbed.length)curr+=flowerbed[i+1];
      if(curr==0){
        count++;
        flowerbed[i]=1 ;
      }
      if(count>=n)return true ;
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation canPlaceFlowers( flowerbed : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
    var curr : int ;
         var i : int ; i := 0 ; while i < flowerbed->size() do ( (     curr := flowerbed[i+1] ; 
     if (i - 1 >= 0) then     curr := curr+(flowerbed[i - 1+1]) ; else skip ; 
    if (i + 1 < flowerbed->size()) then     curr := curr+(flowerbed[i + 1+1]) ; else skip ; 
    if (curr = 0) then (     count := count + 1 ; 
     flowerbed[i+1] := 1 ) else skip ; 
    if (count >= n) then     return true else skip ; 
 )  ;     i := i + 1 ) ; 
     return false );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  private TreeNode ans ;
  public Solution(){
    this.ans=null ;
  }
  private boolean recurseTree(TreeNode currentNode,TreeNode p,TreeNode q){
    if(currentNode==null){
      return false ;
    }
    int left=this.recurseTree(currentNode.left,p,q)? 1 : 0 ;
    int right=this.recurseTree(currentNode.right,p,q)? 1 : 0 ;
    int mid=(currentNode==p || currentNode==q)? 1 : 0 ;
    if(mid+left+right>=2){
      this.ans=currentNode ;
    }
    return(mid+left+right>0);
  }
  public TreeNode lowestCommonAncestor(TreeNode root,TreeNode p,TreeNode q){
    this.recurseTree(root,p,q);
    return this.ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   attribute ans : TreeNode;
   static operation newSolution() : Solution
  pre: true
  post: true
  activity:
  ( var self : Solution ;
    self := createSolution();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.ans := null );
   operation recurseTree( currentNode : TreeNode, p : TreeNode, q : TreeNode) : boolean
  pre: true
  post: true
  activity: (     if (currentNode = null) then (     return false ) else skip ; 
     var left : int ; left := if self.recurseTree(currentNode.left, p, q) then 1 else 0 endif ;
    var right : int ; right := if self.recurseTree(currentNode.right, p, q) then 1 else 0 endif ;
    var mid : int ; mid := if (currentNode = p or currentNode = q) then 1 else 0 endif ;
    if (mid + left + right >= 2) then (     self.ans := currentNode ) else skip ; 
    return (mid + left + right > 0) 
 );
   operation lowestCommonAncestor( root : TreeNode, p : TreeNode, q : TreeNode) : TreeNode
  pre: true
  post: true
  activity: (     self.recurseTree(root, p, q) ; 
     return self.ans );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class coin {
  static int minCoins(int coins[],int m,int V){
    if(V==0)return 0 ;
    int res=Integer.MAX_VALUE ;
    for(int i=0 ; i<m ; i++){
      if(coins[i]<=V){
        int sub_res=minCoins(coins,m,V-coins[i]);
        if(sub_res!=Integer.MAX_VALUE && sub_res+1<res)res=sub_res+1 ;
      }
    }
    return res ;
  }
  public static void main(String args[]){
    int coins[]={
      9,6,5,1 };
      int m=coins.length ;
      int V=11 ;
      System.out.println("Minimum coins required is "+minCoins(coins,m,V));
    }
  }

------------------------------------------------------------
OCL File:
---------
class coin {
  static   operation minCoins( coins : Sequence(int), m : int, V : int) : int
  pre: true
  post: true
  activity: (     if (V = 0) then     return 0 else skip ; 
     var res : int ; res := 2147483647 ;
         var i : int ; i := 0 ; while i < m do ( (     if (coins[i+1] <= V) then (     var sub_res : int ; sub_res := minCoins(coins, m, V - coins[i+1]) ;
     if (sub_res /= 2147483647 & sub_res + 1 < res) then     res := sub_res + 1 ; else skip ) else skip )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var coins : Sequence(int) ; coins := Sequence{9,6,5,1} ;
     var m : int ; m := coins->size() ;
     var V : int ; V := 11 ;
     OclFile["System.out"].println("Minimum coins required is " + minCoins(coins, m, V)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Scanner ;
public class B437 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int sum=in.nextInt();
    int limit=in.nextInt();
    Data[] D=new Data[limit];
    for(int i=1 ; i<=limit ; i++){
      D[i-1]=new Data(i);
    }
    Arrays.sort(D,new Comparator<Data>(){
      @ Override public int compare(Data o1,Data o2){
        return o2.lowBit-o1.lowBit ;
      }
    }
);
    List<Data>list=new ArrayList<>();
    for(Data d : D){
      if(d.lowBit<=sum){
        list.add(d);
        sum-=d.lowBit ;
      }
    }
    if(sum==0){
      StringBuilder out=new StringBuilder();
      out.append(list.size()).append('\n');
      for(Data d : list){
        out.append(d.number).append(' ');
      }
      System.out.println(out);
    }
    else {
      System.out.println("-1");
    }
  }
  static class Data {
    int number ;
    int lowBit ;
    Data(int number){
      this.number=number ;
      this.lowBit=Integer.lowestOneBit(number);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B437 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sum : int ; sum := in.getCurrent()->toInteger() ;
    var limit : int ; limit := in.getCurrent()->toInteger() ;
    var D : Sequence(Data) ; D := Integer.subrange(1,limit)->collect(null) ;
        var i : int ; i := 1 ; while i <= limit do ( (     D[i - 1+1] := Data.newData(i) )  ;     i := i + 1 ) ; 
    D := OclComparator.sortWith(D, OclComparator<Data>.newOclComparator()) ; 
    var list : Sequence(Data) ; list := Sequence{} ;
    for (d : D) do ( (     if (d.lowBit <= sum) then (     list := list->including(d) ; 
     sum := sum-(d.lowBit) ) else skip )  ) ; 
    if (sum = 0) then (     var out : String ; out := StringLib.newString() ;
     out := out + StringLib.newString(list->size()) + StringLib.newString('
') ; 
     for (d : list) do ( (     out := out + StringLib.newString(d.number) + StringLib.newString(' ') )  ) ; 
     OclFile["System.out"].println(out) ) else (     OclFile["System.out"].println("-1") ) ;  
 );
  static class Data {
   attribute number : int;
   attribute lowBit : int;
   static operation newData( number : int) : Data
  pre: true
  post: true
  activity:
  ( var self : Data ;
    self := createData();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number ; 
     self.lowBit := lowestOneBit(number) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args){
    String[] data=new String[3];
    int output=0 ;
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      while(true){
        data=(br.readLine()).split(" ");
        if(data[1] .equals("?"))break ;
        switch(data[1]){
          case "+" : output=Integer.parseInt(data[0])+Integer.parseInt(data[2]);
          break ;
          case "-" : output=Integer.parseInt(data[0])-Integer.parseInt(data[2]);
          break ;
          case "*" : output=Integer.parseInt(data[0])*Integer.parseInt(data[2]);
          break ;
          case "/" : output=Integer.parseInt(data[0])/Integer.parseInt(data[2]);
          break ;
        }
        System.out.println(output);
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
    finally {
      try {
        br.close();
      }
      catch(IOException e){
        e.printStackTrace();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var data : Sequence(String) ; data := Integer.subrange(1,3)->collect(null) ;
     var output : int ; output := 0 ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     while (true) do (     data := (br.readLine())->split(" ") ; 
     if (data[1+1] = "?") then     break else skip ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (data[1+1]) ; 
       if _switchval = "+" then
     output := (data[0+1])->toInteger() + (data[2+1])->toInteger() ; 
    break 
   else skip ;
       if _switchval = "-" then
     output := (data[0+1])->toInteger() - (data[2+1])->toInteger() ; 
    break 
   else skip ;
       if _switchval = "*" then
     output := (data[0+1])->toInteger() * (data[2+1])->toInteger() ; 
    break 
   else skip ;
       if _switchval = "/" then
     output := (data[0+1])->toInteger() / (data[2+1])->toInteger() ; 
    break 
   else skip ;
 )
     OclFile["System.out"].println(output) ) )   catch (e : IOException) do (     e.printStackTrace() )
   finally (     try (     skip )   catch (e : IOException) do (     e.printStackTrace() )
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    String s=sc.next();
    long sum=0 ;
    for(int i=0 ; i<s.length(); i++){
      char ch=s.charAt(i);
      if(ch=='B')sum+=a[i];
    }
    long ans=sum ;
    long sum1=sum ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='A')sum1+=a[i];
      else sum1-=a[i];
      ans=Math.max(ans,sum1);
    }
    sum1=sum ;
    for(int i=s.length()-1 ; i>=0 ; i--){
      if(s.charAt(i)=='A')sum1+=a[i];
      else sum1-=a[i];
      ans=Math.max(ans,sum1);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var s : String ; s := sc.getCurrent() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var ch : String ; ch := s->at(i+1) ;
     if (ch = 'B') then     sum := sum+(a[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    var ans : long ; ans := sum ;
    var sum1 : long ; sum1 := sum ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'A') then     sum1 := sum1+(a[i+1]) else     sum1 := sum1-(a[i+1]) ; ;  
     ans := Set{ans, sum1}->max() )  ;     i := i + 1 ) ; 
    sum1 := sum ; 
        var i : int ; i := s->size() - 1 ; while i >= 0 do ( (     if (s->at(i+1) = 'A') then     sum1 := sum1+(a[i+1]) else     sum1 := sum1-(a[i+1]) ; ;  
     ans := Set{ans, sum1}->max() )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int[][][] house=new int[4][3][10];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int b=sc.nextInt()-1 ;
      int f=sc.nextInt()-1 ;
      int r=sc.nextInt()-1 ;
      house[b][f][r]+=sc.nextInt();
    }
    String s="" ;
    for(int i=0 ; i<4 ; i++){
      if(i!=0){
        s+="\n####################\n" ;
      }
      for(int k=0 ; k<3 ; k++){
        if(k!=0){
          s+="\n" ;
        }
        for(int l=0 ; l<10 ; l++){
          s+=" "+house[i][k][l];
        }
      }
    }
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute house : Sequence(Sequence(Sequence(int))) := Integer.subrange(1,4)->collect(Integer.subrange(1,3)->collect(Integer.subrange(1,10)->collect(0)));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
     var f : int ; f := sc.getCurrent()->toInteger() - 1 ;
     var r : int ; r := sc.getCurrent()->toInteger() - 1 ;
     house[b+1][f+1][r+1] := house[b+1][f+1][r+1]+(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var s : String ; s := "" ;
        var i : int ; i := 0 ; while i < 4 do ( (     if (i /= 0) then (     s := s+("\n####################\n") ) else skip ; 
         var k : int ; k := 0 ; while k < 3 do ( (     if (k /= 0) then (     s := s+("\n") ) else skip ; 
         var l : int ; l := 0 ; while l < 10 do ( (     s := s+(" " + house[i+1][k+1][l+1]) )  ;     l := l + 1 ) )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      int[][][] rooms=new int[4][3][10];
      for(int i=0 ; i<4 ; i++){
        for(int j=0 ; j<3 ; j++){
          Arrays.fill(rooms[i][j],0);
        }
      }
      String[] lines=br.readLine().split(" ");
      int n=Integer.parseInt(lines[0]);
      int b,f,r ;
      for(int i=0 ; i<n ; i++){
        lines=br.readLine().split(" ");
        b=Integer.parseInt(lines[0]);
        f=Integer.parseInt(lines[1]);
        r=Integer.parseInt(lines[2]);
        rooms[b-1][f-1][r-1]+=Integer.parseInt(lines[3]);
      }
      StringBuilder result=new StringBuilder(300);
      String sep="####################\n" ;
      for(int i=0 ; i<4 ; i++){
        for(int j=0 ; j<3 ; j++){
          for(int k=0 ; k<10 ; k++){
            result.append(" "+rooms[i][j][k]);
          }
          result.append("\n");
        }
        if(i!=3)result.append(sep);
      }
      System.out.print(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var rooms : Sequence(Sequence(Sequence(int))) ; rooms := Integer.subrange(1,4)->collect(Integer.subrange(1,3)->collect(Integer.subrange(1,10)->collect(0))) ;
         var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     rooms[i+1][j+1] := rooms[i+1][j+1]->collect(0) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var lines : Sequence(String) ; lines := br.readLine()->split(" ") ;
    var n : int ; n := (lines[0+1])->toInteger() ;
    var b : int ;
    var f : int ;
    var r : int ;
        var i : int ; i := 0 ; while i < n do ( (     lines := br.readLine()->split(" ") ; 
     b := (lines[0+1])->toInteger() ; 
    f := (lines[1+1])->toInteger() ; 
    r := (lines[2+1])->toInteger() ; 
    rooms[b - 1+1][f - 1+1][r - 1+1] := rooms[b - 1+1][f - 1+1][r - 1+1]+((lines[3+1])->toInteger()) ; 
 )  ;     i := i + 1 ) ; 
    var result : String ; result := StringLib.newString(300) ;
    var sep : String ; sep := "####################\n" ;
        var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < 3 do ( (         var k : int ; k := 0 ; while k < 10 do ( (     result := result + StringLib.newString(" " + rooms[i+1][j+1][k+1]) )  ;     k := k + 1 ) ; 
     result := result + StringLib.newString("\n") )  ;     j := j + 1 ) ; 
     if (i /= 3) then     result := result + StringLib.newString(sep) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(result) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      int n=Integer.parseInt(br.readLine());
      int[][][] count=new int[4][3][10];
      for(int i=0 ; i<4 ; i++){
        for(int j=0 ; j<3 ; j++){
          for(int k=0 ; k<10 ; k++){
            count[i][j][k]=0 ;
          }
        }
      }
      for(int i=0 ; i<n ; i++){
        String[] line=br.readLine().split(" ");
        int b=Integer.parseInt(line[0])-1 ;
        int f=Integer.parseInt(line[1])-1 ;
        int r=Integer.parseInt(line[2])-1 ;
        int v=Integer.parseInt(line[3]);
        count[b][f][r]+=v ;
      }
      for(int i=0 ; i<4 ; i++){
        if(i!=0){
          System.out.println("####################");
        }
        for(int j=0 ; j<3 ; j++){
          for(int k=0 ; k<10 ; k++){
            System.out.print(" ");
            System.out.print(count[i][j][k]);
          }
          System.out.print("\n");
        }
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var count : Sequence(Sequence(Sequence(int))) ; count := Integer.subrange(1,4)->collect(Integer.subrange(1,3)->collect(Integer.subrange(1,10)->collect(0))) ;
        var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < 3 do ( (         var k : int ; k := 0 ; while k < 10 do ( (     count[i+1][j+1][k+1] := 0 )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
     var b : int ; b := (line[0+1])->toInteger() - 1 ;
    var f : int ; f := (line[1+1])->toInteger() - 1 ;
    var r : int ; r := (line[2+1])->toInteger() - 1 ;
    var v : int ; v := (line[3+1])->toInteger() ;
    count[b+1][f+1][r+1] := count[b+1][f+1][r+1]+(v) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 4 do ( (     if (i /= 0) then (     OclFile["System.out"].println("####################") ) else skip ; 
         var j : int ; j := 0 ; while j < 3 do ( (         var k : int ; k := 0 ; while k < 10 do ( (     OclFile["System.out"].print(" ") ; 
     OclFile["System.out"].print(count[i+1][j+1][k+1]) )  ;     k := k + 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int xo=sc.nextInt();
    int yo=sc.nextInt();
    int xt=sc.nextInt();
    int yt=sc.nextInt();
    int b1=0,r1=0,k1=0 ;
    if(xo==xt && yo==yt){
      r1=0 ;
      b1=0 ;
      k1=0 ;
    }
    else if(xo==xt || yo==yt){
      r1=1 ;
      if(xo==xt)k1=Math.abs(yo-yt);
      else k1=Math.abs(xo-xt);
    }
    else {
      r1=2 ;
      k1=Math.max(Math.abs(xt-xo),Math.abs(yt-yo));
    }
    if(Math.abs(xo-xt)==Math.abs(yt-yo)){
      b1=1 ;
    }
    else if((xo+xt+yo+yt)% 2!=0)b1=0 ;
    else b1=2 ;
    System.out.println(r1+" "+b1+" "+k1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var xo : int ; xo := sc.getCurrent()->toInteger() ;
    var yo : int ; yo := sc.getCurrent()->toInteger() ;
    var xt : int ; xt := sc.getCurrent()->toInteger() ;
    var yt : int ; yt := sc.getCurrent()->toInteger() ;
    var b1 : int ; b1 := 0 ;
    var r1 : int ; r1 := 0 ;
    var k1 : int ; k1 := 0 ;
    if (xo = xt & yo = yt) then (     r1 := 0 ; 
     b1 := 0 ; 
     k1 := 0 ) else     if (xo = xt or yo = yt) then (     r1 := 1 ; 
     if (xo = xt) then     k1 := if yo - yt < 0 then -(yo - yt) else yo - yt endif ; else     k1 := if xo - xt < 0 then -(xo - xt) else xo - xt endif ; ) else (     r1 := 2 ; 
     k1 := Set{if xt - xo < 0 then -(xt - xo) else xt - xo endif, if yt - yo < 0 then -(yt - yo) else yt - yo endif}->max() ) ;  ;  
    if (if xo - xt < 0 then -(xo - xt) else xo - xt endif = if yt - yo < 0 then -(yt - yo) else yt - yo endif) then (     b1 := 1 ) else     if ((xo + xt + yo + yt) mod 2 /= 0) then     b1 := 0 else     b1 := 2 ; ;  ;  
    OclFile["System.out"].println(r1 + " " + b1 + " " + k1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class codeforces370A {
  public static void main(String[] args)throws IOException {
    boolean[][] bishop=new boolean[8][8];
    for(int i=0 ; i<8 ; i+=2){
      for(int a=0 ; a<8 ; a+=2){
        bishop[i][a]=true ;
      }
    }
    for(int i=1 ; i<8 ; i+=2){
      for(int a=1 ; a<8 ; a+=2){
        bishop[i][a]=true ;
      }
    }
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int r1=Integer.parseInt(st.nextToken())-1 ;
    int c1=Integer.parseInt(st.nextToken())-1 ;
    int r2=Integer.parseInt(st.nextToken())-1 ;
    int c2=Integer.parseInt(st.nextToken())-1 ;
    if(r1==r2 || c1==c2){
      System.out.print(1+" ");
    }
    else {
      System.out.print(2+" ");
    }
    if(bishop[r1][c1]==bishop[r2][c2]){
      if(Math.abs(r1-r2)==Math.abs(c1-c2)){
        System.out.print(1+" ");
      }
      else {
        System.out.print(2+" ");
      }
    }
    else {
      System.out.print(0+" ");
    }
    int a=Math.abs(r1-r2);
    int b=Math.abs(c1-c2);
    if(a>b){
      System.out.print(a);
    }
    else {
      System.out.print(b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces370A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bishop : Sequence(Sequence(boolean)) ; bishop := Integer.subrange(1,8)->collect(Integer.subrange(1,8)->collect(false)) ;
         var i : int ; i := 0 ; while i < 8 do ( (         var a : int ; a := 0 ; while a < 8 do ( (     bishop[i+1][a+1] := true )  ;     a := a+(2) ) )  ;     i := i+(2) ) ; 
        var i : int ; i := 1 ; while i < 8 do ( (         var a : int ; a := 1 ; while a < 8 do ( (     bishop[i+1][a+1] := true )  ;     a := a+(2) ) )  ;     i := i+(2) ) ; 
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var r1 : int ; r1 := (st.next())->toInteger() - 1 ;
    var c1 : int ; c1 := (st.next())->toInteger() - 1 ;
    var r2 : int ; r2 := (st.next())->toInteger() - 1 ;
    var c2 : int ; c2 := (st.next())->toInteger() - 1 ;
    if (r1 = r2 or c1 = c2) then (     OclFile["System.out"].print(1 + " ") ) else (     OclFile["System.out"].print(2 + " ") ) ;  
    if (bishop[r1+1][c1+1] = bishop[r2+1][c2+1]) then (     if (if r1 - r2 < 0 then -(r1 - r2) else r1 - r2 endif = if c1 - c2 < 0 then -(c1 - c2) else c1 - c2 endif) then (     OclFile["System.out"].print(1 + " ") ) else (     OclFile["System.out"].print(2 + " ") ) ) else (     OclFile["System.out"].print(0 + " ") ) ;  
    var a : int ; a := if r1 - r2 < 0 then -(r1 - r2) else r1 - r2 endif ;
    var b : int ; b := if c1 - c2 < 0 then -(c1 - c2) else c1 - c2 endif ;
    if (a > b) then (     OclFile["System.out"].print(a) ) else (     OclFile["System.out"].print(b) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.Math ;
public class Main {
  private static String solucion(int x1,int y1,int x2,int y2){
    String respuesta="" ;
    for(int i=0 ; i<3 ; i++){
      if(i==0){
        if(x1==x2 || y1==y2){
          respuesta=respuesta+""+1 ;
        }
        else {
          respuesta=respuesta+""+2 ;
        }
      }
      else if(i==1){
        if(Math.abs(x1-x2)==Math.abs(y1-y2)){
          respuesta=respuesta+" "+1 ;
        }
        else if((Math.abs(x1-x2)% 2==0)&&(Math.abs(y1-y2)% 2==1)){
          respuesta=respuesta+" "+0 ;
        }
        else if((Math.abs(x1-x2)% 2==1)&&(Math.abs(y1-y2)% 2==0)){
          respuesta=respuesta+" "+0 ;
        }
        else {
          respuesta=respuesta+" "+2 ;
        }
      }
      else if(i==2){
        int restax=(Math.abs(x1-x2));
        int restay=(Math.abs(y1-y2));
        int resp=Math.max(restax,restay);
        respuesta=respuesta+" "+resp ;
      }
    }
    return respuesta ;
  }
  public static void main(String[] argv)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] line=br.readLine().split(" ");
    int x1=Integer.parseInt(line[0]);
    int y1=Integer.parseInt(line[1]);
    int x2=Integer.parseInt(line[2]);
    int y2=Integer.parseInt(line[3]);
    String respuesta=solucion(x1,y1,x2,y2);
    System.out.println(respuesta);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solucion( x1 : int, y1 : int, x2 : int, y2 : int) : String
  pre: true
  post: true
  activity: (     var respuesta : String ; respuesta := "" ;
         var i : int ; i := 0 ; while i < 3 do ( (     if (i = 0) then (     if (x1 = x2 or y1 = y2) then (     respuesta := respuesta + "" + 1 ) else (     respuesta := respuesta + "" + 2 ) ) else     if (i = 1) then (     if (if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif = if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif) then (     respuesta := respuesta + " " + 1 ) else     if ((if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif mod 2 = 0) & (if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif mod 2 = 1)) then (     respuesta := respuesta + " " + 0 ) else     if ((if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif mod 2 = 1) & (if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif mod 2 = 0)) then (     respuesta := respuesta + " " + 0 ) else (     respuesta := respuesta + " " + 2 ) ;  ;  ) else     if (i = 2) then (     var restax : int ; restax := (if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif) ;
     var restay : int ; restay := (if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif) ;
     var resp : int ; resp := Set{restax, restay}->max() ;
     respuesta := respuesta + " " + resp ) else skip ; ;  )  ;     i := i + 1 ) ; 
     return respuesta );
  static   operation main( argv : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var x1 : int ; x1 := (line[0+1])->toInteger() ;
    var y1 : int ; y1 := (line[1+1])->toInteger() ;
    var x2 : int ; x2 := (line[2+1])->toInteger() ;
    var y2 : int ; y2 := (line[3+1])->toInteger() ;
    var respuesta : String ; respuesta := solucion(x1, y1, x2, y2) ;
    OclFile["System.out"].println(respuesta) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
class GFG {
  static long nthTermOfTheSeries(int n){
    long nthTerm ;
    if(n % 2==0)nthTerm=(long)Math.pow(n-1,2)+n ;
    else nthTerm=(long)Math.pow(n+1,2)+n ;
    return nthTerm ;
  }
  public static void main(String[] args){
    int n ;
    n=8 ;
    System.out.println(nthTermOfTheSeries(n));
    n=12 ;
    System.out.println(nthTermOfTheSeries(n));
    n=102 ;
    System.out.println(nthTermOfTheSeries(n));
    n=999 ;
    System.out.println(nthTermOfTheSeries(n));
    n=9999 ;
    System.out.println(nthTermOfTheSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nthTermOfTheSeries( n : int) : long
  pre: true
  post: true
  activity: (     var nthTerm : long ;
     if (n mod 2 = 0) then     nthTerm := n - 1->pow(2)->oclAsType(long) + n else     nthTerm := n + 1->pow(2)->oclAsType(long) + n ; ;  
     return nthTerm );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     n := 8 ; 
    OclFile["System.out"].println(nthTermOfTheSeries(n)) ; 
    n := 12 ; 
    OclFile["System.out"].println(nthTermOfTheSeries(n)) ; 
    n := 102 ; 
    OclFile["System.out"].println(nthTermOfTheSeries(n)) ; 
    n := 999 ; 
    OclFile["System.out"].println(nthTermOfTheSeries(n)) ; 
    n := 9999 ; 
    OclFile["System.out"].println(nthTermOfTheSeries(n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int distribution(int arr[],int n){
    Set<Integer>resources=new HashSet<Integer>();
    for(int i=0 ; i<n ; i++)resources.add(arr[i]);
    return Math.min(resources.size(),n/2);
  }
  public static void main(String[] args){
    int arr[]={
      1,1,2,1,3,4 };
      int n=arr.length ;
      System.out.print(distribution(arr,n)+"\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation distribution( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var resources : Set(int) ; resources := Set{} ;
         var i : int ; i := 0 ; while i < n do (     resources := resources->including(arr[i+1]) ;  ;     i := i + 1 ) ; 
     return Set{resources->size(), n / 2}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,2,1,3,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(distribution(arr, n) + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  int n,max=-1000000 ;
  int[] v,c ;
  Main(Scanner in,PrintWriter out){
    n=in.nextInt();
    v=new int[n];
    c=new int[n];
    for(int i=0 ; i<n ; i++)v[i]=in.nextInt();
    for(int i=0 ; i<n ; i++)c[i]=in.nextInt();
    for(int i=0 ; i<(1<<n); i++){
      int V=0,C=0 ;
      for(int j=0 ; j<n ; j++)if((i &(1<<j))>0){
        V+=v[j];
        C+=c[j];
      }
      max=Math.max(max,V-C);
    }
    out.println(max);
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    new Main(in,out);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute v : Sequence(int);
   static operation newMain( in : OclFile, out : OclFile) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(in, out);
    return self );
  operation initialise( in : OclFile, out : OclFile) : void
  pre: true  post: true
  activity: (     n := in.nextInt() ; 
     v := Integer.subrange(1,n)->collect(0) ; 
    c := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     v[i+1] := in.nextInt() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     c[i+1] := in.nextInt() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < ((1*(2->pow(n)))->oclAsType(long)) do ( (     var V : int ; V := 0 ;
    var C : int ; C := 0 ;
         var j : int ; j := 0 ; while j < n do (     if ((MathLib.bitwiseAnd(i,((1*(2->pow(j)))->oclAsType(long)))) > 0) then (     V := V+(v[j+1]) ; 
     C := C+(c[j+1]) ) else skip ;  ;     j := j + 1 ) ; 
     max := Set{max, V - C}->max() )  ;     i := i + 1 ) ; 
    out.println(max) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
 Main.newMain(in, out) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int getIndex(int a[],int n){
    if(n==1)return 0 ;
    int ptrL=0,ptrR=n-1,sumL=a[0],sumR=a[n-1];
    while(ptrR-ptrL>1){
      if(sumL<sumR){
        ptrL++;
        sumL+=a[ptrL];
      }
      else if(sumL>sumR){
        ptrR--;
        sumR+=a[ptrR];
      }
      else {
        break ;
      }
    }
    return ptrL ;
  }
  public static void main(String[] args){
    int a[]={
      2,7,9,8,7 };
      int n=a.length ;
      System.out.println(getIndex(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getIndex( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 0 else skip ; 
     var ptrL : int ; ptrL := 0 ;
    var ptrR : int ; ptrR := n - 1 ;
    var sumL : int ; sumL := a[0+1] ;
    var sumR : int ; sumR := a[n - 1+1] ;
     while (ptrR - ptrL > 1) do (     if (sumL < sumR) then (     ptrL := ptrL + 1 ; 
     sumL := sumL+(a[ptrL+1]) ) else     if (sumL > sumR) then (     ptrR := ptrR - 1 ; 
     sumR := sumR+(a[ptrR+1]) ) else (     break ) ;  ) ; 
     return ptrL );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,7,9,8,7} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(getIndex(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void rgb_to_hsv(double r,double g,double b){
    r=r/255.0 ;
    g=g/255.0 ;
    b=b/255.0 ;
    double cmax=Math.max(r,Math.max(g,b));
    double cmin=Math.min(r,Math.min(g,b));
    double diff=cmax-cmin ;
    double h=-1,s=-1 ;
    if(cmax==cmin)h=0 ;
    else if(cmax==r)h=(60*((g-b)/diff)+360)% 360 ;
    else if(cmax==g)h=(60*((b-r)/diff)+120)% 360 ;
    else if(cmax==b)h=(60*((r-g)/diff)+240)% 360 ;
    if(cmax==0)s=0 ;
    else s=(diff/cmax)*100 ;
    double v=cmax*100 ;
    System.out.println("("+h+" "+s+" "+v+")");
  }
  public static void main(String[] args){
    rgb_to_hsv(129,88,47);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation rgb_to_hsv( r : double, g : double, b : double) : void
  pre: true
  post: true
  activity: (     r := r / 255.0 ; 
     g := g / 255.0 ; 
    b := b / 255.0 ; 
    var cmax : double ; cmax := Set{r, Set{g, b}->max()}->max() ;
    var cmin : double ; cmin := Set{r, Set{g, b}->min()}->min() ;
    var diff : double ; diff := cmax - cmin ;
    var h : double ; h := -1 ;
    var s : double ; s := -1 ;
    if (cmax = cmin) then     h := 0 else     if (cmax = r) then     h := (60 * ((g - b) / diff) + 360) mod 360 else     if (cmax = g) then     h := (60 * ((b - r) / diff) + 120) mod 360 else     if (cmax = b) then     h := (60 * ((r - g) / diff) + 240) mod 360 ; else skip ; ;  ;  ;  
    if (cmax = 0) then     s := 0 else     s := (diff / cmax) * 100 ; ;  
    var v : double ; v := cmax * 100 ;
    OclFile["System.out"].println("(" + h + " " + s + " " + v + ")") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute rgb_to_hsv(129, 88, 47) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static void printThreeParts(int N){
    if(N % 3==0)System.out.println("x=1,y=1,z="+(N-2));
    else System.out.println(" x=1,y=2,z="+(N-3));
  }
  public static void main(String args[]){
    int N=10 ;
    printThreeParts(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation printThreeParts( N : int) : void
  pre: true
  post: true
  activity: (     if (N mod 3 = 0) then     OclFile["System.out"].println("x=1,y=1,z=" + (N - 2)) ; else     OclFile["System.out"].println(" x=1,y=2,z=" + (N - 3)) ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 10 ;
     execute printThreeParts(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.Stream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long xMin=1L<<30 ;
    long xMax=0 ;
    long yMin=1L<<30 ;
    long yMax=0 ;
    long[][] bg=new long[n][2];
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      if(x>y){
        int tmp=x ;
        x=y ;
        y=tmp ;
      }
      bg[i][0]=x ;
      bg[i][1]=y ;
      xMin=Math.min(xMin,x);
      xMax=Math.max(xMax,x);
      yMin=Math.min(yMin,y);
      yMax=Math.max(yMax,y);
    }
    long ans=(xMax-xMin)*(yMax-yMin);
    Arrays.sort(bg,new Comparator<long[]>(){
      public int compare(long[] p1,long[] p2){
        if(p1[0]<p2[0])return-1 ;
        if(p1[0]>p2[0])return 1 ;
        return 0 ;
      }
    }
);
    long yUsedMax=0 ;
    long yUsedMin=1L<<30 ;
    for(int i=0 ; i<n-1 ; i++){
      yUsedMin=Math.min(yUsedMin,bg[i][1]);
      yUsedMax=Math.max(yUsedMax,bg[i][1]);
      long bMin=Math.min(yUsedMin,bg[i+1][0]);
      long bMax=Math.max(yUsedMax,bg[n-1][0]);
      ans=Math.min(ans,(yMax-xMin)*(bMax-bMin));
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var xMin : long ; xMin := (1L*(2->pow(30)))->oclAsType(long) ;
    var xMax : long ; xMax := 0 ;
    var yMin : long ; yMin := (1L*(2->pow(30)))->oclAsType(long) ;
    var yMax : long ; yMax := 0 ;
    var bg : Sequence(Sequence(long)) ; bg := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    if (x > y) then (     var tmp : int ; tmp := x ;
     x := y ; 
     y := tmp ) else skip ; 
    bg[i+1][0+1] := x ; 
    bg[i+1][1+1] := y ; 
    xMin := Set{xMin, x}->min() ; 
    xMax := Set{xMax, x}->max() ; 
    yMin := Set{yMin, y}->min() ; 
    yMax := Set{yMax, y}->max() ; 
 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := (xMax - xMin) * (yMax - yMin) ;
    bg := OclComparator.sortWith(bg, OclComparator<Sequence(long)>.newOclComparator()) ; 
    var yUsedMax : long ; yUsedMax := 0 ;
    var yUsedMin : long ; yUsedMin := (1L*(2->pow(30)))->oclAsType(long) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     yUsedMin := Set{yUsedMin, bg[i+1][1+1]}->min() ; 
     yUsedMax := Set{yUsedMax, bg[i+1][1+1]}->max() ; 
    var bMin : long ; bMin := Set{yUsedMin, bg[i + 1+1][0+1]}->min() ;
    var bMax : long ; bMax := Set{yUsedMax, bg[n - 1+1][0+1]}->max() ;
    ans := Set{ans, (yMax - xMin) * (bMax - bMin)}->min() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int R=4 ;
  static int C=4 ;
  static int countPaths(int maze[][]){
    if(maze[0][0]==-1)return 0 ;
    for(int i=0 ; i<R ; i++){
      if(maze[i][0]==0)maze[i][0]=1 ;
      else break ;
    }
    for(int i=1 ; i<C ; i++){
      if(maze[0][i]==0)maze[0][i]=1 ;
      else break ;
    }
    for(int i=1 ; i<R ; i++){
      for(int j=1 ; j<C ; j++){
        if(maze[i][j]==-1)continue ;
        if(maze[i-1][j]>0)maze[i][j]=(maze[i][j]+maze[i-1][j]);
        if(maze[i][j-1]>0)maze[i][j]=(maze[i][j]+maze[i][j-1]);
      }
    }
    return(maze[R-1][C-1]>0)? maze[R-1][C-1] : 0 ;
  }
  static int numberOfPaths(int m,int n){
    int path=1 ;
    for(int i=n ; i<(m+n-1); i++){
      path*=i ;
      path/=(i-n+1);
    }
    return path ;
  }
  static int solve(int maze[][]){
    int ans=numberOfPaths(R,C)-countPaths(maze);
    return ans ;
  }
  public static void main(String[] args){
    int maze[][]={
      {
        0,0,0,0 },{
          0,-1,0,0 },{
-1,0,0,0 },{
              0,0,0,0 }
            };
            System.out.println(solve(maze));
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute R : int := 4;
  static   attribute C : int := 4;
  static   operation countPaths( maze : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     if (maze[0+1][0+1] = -1) then     return 0 else skip ; 
         var i : int ; i := 0 ; while i < R do ( (     if (maze[i+1][0+1] = 0) then     maze[i+1][0+1] := 1 ; else     break )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < C do ( (     if (maze[0+1][i+1] = 0) then     maze[0+1][i+1] := 1 ; else     break )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < R do ( (         var j : int ; j := 1 ; while j < C do ( (     if (maze[i+1][j+1] = -1) then     continue else skip ; 
     if (maze[i - 1+1][j+1] > 0) then     maze[i+1][j+1] := (maze[i+1][j+1] + maze[i - 1+1][j+1]) ; else skip ; 
     if (maze[i+1][j - 1+1] > 0) then     maze[i+1][j+1] := (maze[i+1][j+1] + maze[i+1][j - 1+1]) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return if (maze[R - 1+1][C - 1+1] > 0) then maze[R - 1+1][C - 1+1] else 0 endif 
 );
  static   operation numberOfPaths( m : int, n : int) : int
  pre: true
  post: true
  activity: (     var path : int ; path := 1 ;
         var i : int ; i := n ; while i < (m + n - 1) do ( (     path := path*(i) ; 
     path := path/((i - n + 1)) )  ;     i := i + 1 ) ; 
     return path );
  static   operation solve( maze : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := numberOfPaths(R, C) - countPaths(maze) ;
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var maze : Sequence(Sequence(int)) ; maze := Sequence{Sequence{0,0,0,0},Sequence{0,-1,0,0},Sequence{-1,0,0,0},Sequence{0,0,0,0}} ;
     OclFile["System.out"].println(solve(maze)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B877 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char[] S=in.next().toCharArray();
    int N=S.length ;
    int[] aBefore=new int[N+1];
    for(int n=0 ; n<N ; n++){
      aBefore[n+1]=aBefore[n]+(S[n]=='a' ? 1 : 0);
    }
    int min=Integer.MAX_VALUE ;
    for(int cut1=0 ; cut1<=N ; cut1++){
      int aInFirst=aBefore[cut1];
      int bInFirst=cut1-aInFirst ;
      for(int cut2=cut1 ; cut2<=N ; cut2++){
        int aInSecond=aBefore[cut2]-aInFirst ;
        int aInThird=aBefore[N]-aBefore[cut2];
        int bInThird=N-cut2-aInThird ;
        int remove=bInFirst+aInSecond+bInThird ;
        min=Math.min(min,remove);
      }
    }
    int answer=N-min ;
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B877 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : Sequence(String) ; S := in.getCurrent()->characters() ;
    var N : int ; N := S->size() ;
    var aBefore : Sequence(int) ; aBefore := Integer.subrange(1,N + 1)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     aBefore[n + 1+1] := aBefore[n+1] + (if S[n+1] = 'a' then 1 else 0 endif) )  ;     n := n + 1 ) ; 
    var min : int ; min := 2147483647 ;
        var cut1 : int ; cut1 := 0 ; while cut1 <= N do ( (     var aInFirst : int ; aInFirst := aBefore[cut1+1] ;
     var bInFirst : int ; bInFirst := cut1 - aInFirst ;
         var cut2 : int ; cut2 := cut1 ; while cut2 <= N do ( (     var aInSecond : int ; aInSecond := aBefore[cut2+1] - aInFirst ;
     var aInThird : int ; aInThird := aBefore[N+1] - aBefore[cut2+1] ;
    var bInThird : int ; bInThird := N - cut2 - aInThird ;
    var remove : int ; remove := bInFirst + aInSecond + bInThird ;
    min := Set{min, remove}->min() ; 
 )  ;     cut2 := cut2 + 1 ) )  ;     cut1 := cut1 + 1 ) ; 
    var answer : int ; answer := N - min ;
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sumofFactors(int n){
    int res=1 ;
    for(int i=2 ; i<=Math.sqrt(n); i++){
      int count=0,curr_sum=1 ;
      int curr_term=1 ;
      while(n % i==0){
        count++;
        n=n/i ;
        curr_term*=i ;
        curr_sum+=curr_term ;
      }
      res*=curr_sum ;
    }
    if(n>=2)res*=(1+n);
    return res ;
  }
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static boolean checkFriendly(int n,int m){
    int sumFactors_n=sumofFactors(n);
    int sumFactors_m=sumofFactors(m);
    int gcd_n=gcd(n,sumFactors_n);
    int gcd_m=gcd(m,sumFactors_m);
    if(n/gcd_n==m/gcd_m && sumFactors_n/gcd_n==sumFactors_m/gcd_m)return true ;
    else return false ;
  }
  public static void main(String[] args){
    int n=6,m=28 ;
    if(checkFriendly(n,m))System.out.print("Yes\n");
    else System.out.print("No\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumofFactors( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
         var i : int ; i := 2 ; while i <= (n)->sqrt() do ( (     var count : int ; count := 0 ;
    var curr_sum : int ; curr_sum := 1 ;
     var curr_term : int ; curr_term := 1 ;
     while (n mod i = 0) do (     count := count + 1 ; 
     n := n / i ; 
     curr_term := curr_term*(i) ; 
     curr_sum := curr_sum+(curr_term) ) ; 
     res := res*(curr_sum) )  ;     i := i + 1 ) ; 
     if (n >= 2) then     res := res*((1 + n)) ; else skip ; 
     return res );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation checkFriendly( n : int, m : int) : boolean
  pre: true
  post: true
  activity: (     var sumFactors_n : int ; sumFactors_n := sumofFactors(n) ;
     var sumFactors_m : int ; sumFactors_m := sumofFactors(m) ;
    var gcd_n : int ; gcd_n := gcd(n, sumFactors_n) ;
    var gcd_m : int ; gcd_m := gcd(m, sumFactors_m) ;
    if (n / gcd_n = m / gcd_m & sumFactors_n / gcd_n = sumFactors_m / gcd_m) then     return true else     return false ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
    var m : int ; m := 28 ;
     if (checkFriendly(n, m)) then     OclFile["System.out"].print("Yes\n") ; else     OclFile["System.out"].print("No\n") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s ;
    String sd="abcdefghijklmnopqrstuvwxyz" ;
    String sdnum="0123456789" ;
    s=sc.next();
    int count[];
    int countnum[];
    count=new int[26];
    countnum=new int[10];
    for(int i=0 ; i<s.length(); ++i){
      if(s.charAt(i)>='0' && s.charAt(i)<='9'){
++countnum[s.charAt(i)-'0'];
      }
      if(s.charAt(i)>='a' && s.charAt(i)<='z'){
++count[s.charAt(i)-'a'];
      }
    }
    int ans=0 ;
    for(int i=26 ; i>=3 ; --i){
      for(int j=0 ; j<=26-i ; ++j){
        int tmp=10000 ;
        for(int k=j ; k<j+i ; ++k){
          tmp=Math.min(tmp,count[k]);
        }
        ans+=tmp*3 ;
        for(int k=j ; k<j+i ; ++k){
          count[k]-=tmp ;
        }
      }
    }
    for(int i=0 ; i<26 ; ++i){
      ans+=count[i];
    }
    for(int i=10 ; i>=3 ; --i){
      for(int j=0 ; j<=10-i ; ++j){
        int tmp=10000 ;
        for(int k=j ; k<j+i ; ++k){
          tmp=Math.min(tmp,countnum[k]);
        }
        ans+=tmp*3 ;
        for(int k=j ; k<j+i ; ++k){
          countnum[k]-=tmp ;
        }
      }
    }
    for(int i=0 ; i<10 ; ++i){
      ans+=countnum[i];
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ;
    var sd : String ; sd := "abcdefghijklmnopqrstuvwxyz" ;
    var sdnum : String ; sdnum := "0123456789" ;
    s := sc.getCurrent() ; 
    var count : Sequence(int) ;
    var countnum : Sequence(int) ;
    count := Integer.subrange(1,26)->collect(0) ; 
    countnum := Integer.subrange(1,10)->collect(0) ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) >= '0' & s->at(i+1) <= '9') then (     countnum[s->at(i+1) - ('0')->char2byte()+1] := countnum[s->at(i+1) - ('0')->char2byte()+1] + 1 ) else skip ; 
     if (s->at(i+1) >= 'a' & s->at(i+1) <= 'z') then (     count[s->at(i+1) - ('a')->char2byte()+1] := count[s->at(i+1) - ('a')->char2byte()+1] + 1 ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 26 ; while i >= 3 do ( (         var j : int ; j := 0 ; while j <= 26 - i do ( (     var tmp : int ; tmp := 10000 ;
         var k : int ; k := j ; while k < j + i do ( (     tmp := Set{tmp, count[k+1]}->min() )  ;     k := k + 1 ) ; 
     ans := ans+(tmp * 3) ; 
         var k : int ; k := j ; while k < j + i do ( (     count[k+1] := count[k+1]-(tmp) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < 26 do ( (     ans := ans+(count[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 10 ; while i >= 3 do ( (         var j : int ; j := 0 ; while j <= 10 - i do ( (     var tmp : int ; tmp := 10000 ;
         var k : int ; k := j ; while k < j + i do ( (     tmp := Set{tmp, countnum[k+1]}->min() )  ;     k := k + 1 ) ; 
     ans := ans+(tmp * 3) ; 
         var k : int ; k := j ; while k < j + i do ( (     countnum[k+1] := countnum[k+1]-(tmp) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < 10 do ( (     ans := ans+(countnum[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAXN=100005 ;
  static int spf[]=new int[MAXN];
  static int sum_digits[]=new int[MAXN];
  static boolean isValid[]=new boolean[MAXN];
  static int ans[]=new int[MAXN];
  static void Smallest_prime_factor(){
    for(int i=1 ; i<MAXN ; i++)spf[i]=i ;
    for(int i=4 ; i<MAXN ; i+=2)spf[i]=2 ;
    for(int i=3 ; i*i<=MAXN ; i+=2)if(spf[i]==i)for(int j=i*i ; j<MAXN ; j+=i)if(spf[j]==j)spf[j]=i ;
  }
  static int Digit_Sum(int copy){
    int d=0 ;
    while(copy>0){
      d+=copy % 10 ;
      copy/=10 ;
    }
    return d ;
  }
  static void Sum_Of_All_Digits(){
    for(int n=2 ; n<MAXN ; n++){
      sum_digits[n]=sum_digits[n/spf[n] ]+Digit_Sum(spf[n]);
      if(Digit_Sum(n)==sum_digits[n])isValid[n]=true ;
    }
    for(int n=2 ; n<MAXN ; n++){
      if(isValid[n])ans[n]=1 ;
      ans[n]+=ans[n-1];
    }
  }
  public static void main(String[] args){
    Smallest_prime_factor();
    Sum_Of_All_Digits();
    int l,r ;
    l=2 ;
    r=3 ;
    System.out.println("Valid numbers in the range "+l+" "+r+" are "+(ans[r]-ans[l-1]));
    l=2 ;
    r=10 ;
    System.out.println("Valid numbers in the range "+l+" "+r+" are "+(ans[r]-ans[l-1]));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAXN : int := 100005;
  static   attribute spf : int := Integer.subrange(1,MAXN)->collect(0);
  static   attribute sum_digits : int := Integer.subrange(1,MAXN)->collect(0);
  static   attribute isValid : boolean := Integer.subrange(1,MAXN)->collect(false);
  static   attribute ans : int := Integer.subrange(1,MAXN)->collect(0);
  static   operation Smallest_prime_factor() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < MAXN do (     spf[i+1] := i ;  ;     i := i + 1 ) ; 
         var i : int ; i := 4 ; while i < MAXN do (     spf[i+1] := 2 ;  ;     i := i+(2) ) ; 
         var i : int ; i := 3 ; while i * i <= MAXN do (     if (spf[i+1] = i) then         var j : int ; j := i * i ; while j < MAXN do (     if (spf[j+1] = j) then     spf[j+1] := i ; else skip ;  ;     j := j+(i) ) ; else skip ;  ;     i := i+(2) ) );
  static   operation Digit_Sum( copy : int) : int
  pre: true
  post: true
  activity: (     var d : int ; d := 0 ;
     while (copy > 0) do (     d := d+(copy mod 10) ; 
     copy := copy/(10) ) ; 
     return d );
  static   operation Sum_Of_All_Digits() : void
  pre: true
  post: true
  activity: (         var n : int ; n := 2 ; while n < MAXN do ( (     sum_digits[n+1] := sum_digits[n / spf[n+1]+1] + Digit_Sum(spf[n+1]) ; 
     if (Digit_Sum(n) = sum_digits[n+1]) then     isValid[n+1] := true ; else skip )  ;     n := n + 1 ) ; 
         var n : int ; n := 2 ; while n < MAXN do ( (     if (isValid[n+1]) then     ans[n+1] := 1 ; else skip ; 
     ans[n+1] := ans[n+1]+(ans[n - 1+1]) )  ;     n := n + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute Smallest_prime_factor() ; 
     execute Sum_Of_All_Digits() ; 
    var l : int ;
    var r : int ;
    l := 2 ; 
    r := 3 ; 
    OclFile["System.out"].println("Valid numbers in the range " + l + " " + r + " are " + (ans[r+1] - ans[l - 1+1])) ; 
    l := 2 ; 
    r := 10 ; 
    OclFile["System.out"].println("Valid numbers in the range " + l + " " + r + " are " + (ans[r+1] - ans[l - 1+1])) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  static int maxAND(int arr[],int n){
    int res=0 ;
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++)res=res>(arr[i] & arr[j])? res :(arr[i] & arr[j]);
    return res ;
  }
  public static void main(String argc[]){
    int arr[]={
      4,8,6,2 };
      int n=arr.length ;
      System.out.println("Maximum AND Value="+maxAND(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation maxAND( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do (     res := if res > (arr[i+1] & arr[j+1]) then res else (arr[i+1] & arr[j+1]) endif ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,8,6,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Maximum AND Value=" + maxAND(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BResale solver=new BResale();
    solver.solve(1,in,out);
    out.close();
  }
  static class BResale {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int v[]=new int[n];
      int c[]=new int[n];
      long ans=0 ;
      for(int i=0 ; i<n ; i++)v[i]=in.nextInt();
      for(int i=0 ; i<n ; i++)c[i]=in.nextInt();
      for(int i=0 ; i<n ; i++){
        if(v[i]>c[i])ans+=v[i]-c[i];
      }
      out.println(ans);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BResale ; solver := BResale.newBResale() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BResale {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do (     v[i+1] := in.nextInt() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     c[i+1] := in.nextInt() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (v[i+1] > c[i+1]) then     ans := ans+(v[i+1] - c[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int A,B ;
    final int N=scanner.nextInt();
    prepare(N);
    int[] except=new int[N];
    final int M=scanner.nextInt();
    final int K=scanner.nextInt();
    for(int i=0 ; i<M ; i++){
      A=scanner.nextInt()-1 ;
      B=scanner.nextInt()-1 ;
      union(A,B);
      except[A]++;
      except[B]++;
    }
    for(int i=0 ; i<K ; i++){
      A=scanner.nextInt()-1 ;
      B=scanner.nextInt()-1 ;
      if(find(A)==find(B)){
        except[A]++;
        except[B]++;
      }
    }
    scanner.close();
    for(int i=0 ; i<N ; i++){
      System.out.print(desc[find(i)]-except[i]);
      System.out.print(i==N-1 ? "\n" : " ");
    }
  }
  static int[] parent ;
  static int[] desc ;
  static void prepare(int n){
    parent=new int[n];
    for(int i=0 ; i<n ; i++){
      parent[i]=i ;
    }
    desc=new int[n];
  }
  static int find(int x){
    if(parent[x]==x)return x ;
    else return find(parent[x]);
  }
  static void union(int x,int y){
    int xRoot=find(x);
    int yRoot=find(y);
    if(xRoot==yRoot)return ;
    if(desc[xRoot]>=desc[yRoot]){
      parent[yRoot]=xRoot ;
      desc[xRoot]+=desc[yRoot]+1 ;
    }
    else {
      parent[xRoot]=yRoot ;
      desc[yRoot]+=desc[xRoot]+1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ;
    var B : int ;
    var N : int ; N := scanner.getCurrent()->toInteger() ;
    execute prepare(N) ; 
    var except : Sequence(int) ; except := Integer.subrange(1,N)->collect(0) ;
    var M : int ; M := scanner.getCurrent()->toInteger() ;
    var K : int ; K := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < M do ( (     A := scanner.getCurrent()->toInteger() - 1 ; 
     B := scanner.getCurrent()->toInteger() - 1 ; 
    execute union(A, B) ; 
    except[A+1] := except[A+1] + 1 ; 
    except[B+1] := except[B+1] + 1 ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < K do ( (     A := scanner.getCurrent()->toInteger() - 1 ; 
     B := scanner.getCurrent()->toInteger() - 1 ; 
     if (find(A) = find(B)) then (     except[A+1] := except[A+1] + 1 ; 
     except[B+1] := except[B+1] + 1 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].print(desc[find(i)+1] - except[i+1]) ; 
     OclFile["System.out"].print(if i = N - 1 then "\n" else " " endif) )  ;     i := i + 1 ) ; 
 );
  static   attribute parent : Sequence(int);
  static   attribute desc : Sequence(int);
  static   operation prepare( n : int) : void
  pre: true
  post: true
  activity: (     parent := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do ( (     parent[i+1] := i )  ;     i := i + 1 ) ; 
     desc := Integer.subrange(1,n)->collect(0) );
  static   operation find( x : int) : int
  pre: true
  post: true
  activity: (     if (parent[x+1] = x) then     return x else     return find(parent[x+1]) );
  static   operation union( x : int, y : int) : void
  pre: true
  post: true
  activity: (     var xRoot : int ; xRoot := find(x) ;
     var yRoot : int ; yRoot := find(y) ;
     if (xRoot = yRoot) then     return else skip ; 
     if (desc[xRoot+1] >= desc[yRoot+1]) then (     parent[yRoot+1] := xRoot ; 
     desc[xRoot+1] := desc[xRoot+1]+(desc[yRoot+1] + 1) ) else (     parent[xRoot+1] := yRoot ; 
     desc[yRoot+1] := desc[yRoot+1]+(desc[xRoot+1] + 1) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String maxInt(char str[]){
    for(int i=0 ; i<str.length ; i++){
      if(str[i]<'5'){
        str[i]=(char)(('9'-str[i])+'0');
      }
    }
    if(str[0]=='0')str[0]='9' ;
    String str2=new String(str);
    return str2 ;
  }
  public static void main(String[] args){
    String str="42" ;
    System.out.println(maxInt(str.toCharArray()));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxInt( str : Sequence(String)) : String
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < str->size() do ( (     if (str[i+1] < '5') then (     str[i+1] := ((('9')->char2byte() - str[i+1]) + '0')->oclAsType(String) ) else skip )  ;     i := i + 1 ) ; 
     if (str[0+1] = '0') then     str[0+1] := '9' ; else skip ; 
     var str2 : String ; str2 := StringLib.newString(str) ;
     return str2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "42" ;
     OclFile["System.out"].println(maxInt(str->characters())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int A,B ;
    final int N=scanner.nextInt();
    visited=new boolean[N];
    root=new int[N];
    size=new int[N];
    int[] except=new int[N];
    graph=new ArrayList[N];
    for(int i=0 ; i<N ; i++){
      graph[i]=new ArrayList<Integer>();
    }
    final int M=scanner.nextInt();
    final int K=scanner.nextInt();
    for(int i=0 ; i<M ; i++){
      A=scanner.nextInt()-1 ;
      B=scanner.nextInt()-1 ;
      graph[A] .add(B);
      graph[B] .add(A);
      except[A]++;
      except[B]++;
    }
    for(int i=0 ; i<N ; i++){
      if(! visited[i]){
        DFS(i,i);
      }
    }
    for(int i=0 ; i<K ; i++){
      A=scanner.nextInt()-1 ;
      B=scanner.nextInt()-1 ;
      if(root[A]==root[B]){
        except[A]++;
        except[B]++;
      }
    }
    for(int i=0 ; i<N ; i++){
      System.out.print(size[root[i] ]-except[i]-1);
      System.out.print(i==N-1 ? "\n" : " ");
    }
  }
  static List<Integer>[] graph ;
  static boolean[] visited ;
  static int[] root ;
  static int[] size ;
  static void DFS(int rep,int vertex){
    visited[vertex]=true ;
    root[vertex]=rep ;
    size[rep]++;
    graph[vertex] .forEach(neighbor->{
      if(! visited[neighbor]){
        DFS(rep,neighbor);
      }
    }
);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ;
    var B : int ;
    var N : int ; N := scanner.getCurrent()->toInteger() ;
    visited := Integer.subrange(1,N)->collect(false) ; 
    root := Integer.subrange(1,N)->collect(0) ; 
    size := Integer.subrange(1,N)->collect(0) ; 
    var except : Sequence(int) ; except := Integer.subrange(1,N)->collect(0) ;
    graph := Integer.subrange(1,N)->collect(null) ; 
        var i : int ; i := 0 ; while i < N do ( (     graph[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
    var M : int ; M := scanner.getCurrent()->toInteger() ;
    var K : int ; K := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < M do ( (     A := scanner.getCurrent()->toInteger() - 1 ; 
     B := scanner.getCurrent()->toInteger() - 1 ; 
    graph[A+1]->excludes(B) ; 
    graph[B+1]->excludes(A) ; 
    except[A+1] := except[A+1] + 1 ; 
    except[B+1] := except[B+1] + 1 ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (not(visited[i+1])) then (     execute DFS(i, i) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < K do ( (     A := scanner.getCurrent()->toInteger() - 1 ; 
     B := scanner.getCurrent()->toInteger() - 1 ; 
     if (root[A+1] = root[B+1]) then (     except[A+1] := except[A+1] + 1 ; 
     except[B+1] := except[B+1] + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].print(size[root[i+1]+1] - except[i+1] - 1) ; 
     OclFile["System.out"].print(if i = N - 1 then "\n" else " " endif) )  ;     i := i + 1 ) ; 
 );
  static   attribute graph : Sequence(Sequence(int));
  static   attribute visited : Sequence(boolean);
  static   attribute root : Sequence(int);
  static   attribute size : Sequence(int);
  static   operation DFS( rep : int, vertex : int) : void
  pre: true
  post: true
  activity: (     visited[vertex+1] := true ; 
     root[vertex+1] := rep ; 
     size[rep+1] := size[rep+1] + 1 ; 
     for neighbor : graph[vertex+1] do
    (    skip) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int xorPairSum(int ar[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum=sum ^ ar[i];
    return 2*sum ;
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3 };
      int n=arr.length ;
      System.out.println(xorPairSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation xorPairSum( ar : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := MathLib.bitwiseXor(sum,ar[i+1]) ;  ;     i := i + 1 ) ; 
     return 2 * sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(xorPairSum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void asciiToSentence(String str,int len){
    int num=0 ;
    for(int i=0 ; i<len ; i++){
      num=num*10+(str.charAt(i)-'0');
      if(num>=32 && num<=122){
        char ch=(char)num ;
        System.out.print(ch);
        num=0 ;
      }
    }
  }
  public static void main(String args[]){
    String str="7110110110711510211111471101101107115" ;
    int len=str.length();
    asciiToSentence(str,len);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation asciiToSentence( str : String, len : int) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 0 ;
         var i : int ; i := 0 ; while i < len do ( (     num := num * 10 + (str->at(i+1) - ('0')->char2byte()) ; 
     if (num >= 32 & num <= 122) then (     var ch : String ; ch := num->oclAsType(String) ;
     OclFile["System.out"].print(ch) ; 
     num := 0 ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "7110110110711510211111471101101107115" ;
     var len : int ; len := str->size() ;
     execute asciiToSentence(str, len) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findSetBits(int n){
    for(int i=0 ; i<=n ; i++)System.out.print(Integer.bitCount(i)+" ");
  }
  public static void main(String[] args){
    int n=5 ;
    findSetBits(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findSetBits( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= n do (     OclFile["System.out"].print(bitCount(i) + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute findSetBits(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package common ;
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
public class Helper {
  public static String[] getAllFileContentAsArray(String filename)throws Exception {
    BufferedReader in=new BufferedReader(new FileReader(filename));
    List<String>all=new ArrayList<String>();
    String s=in.readLine();
    while(s!=null){
      all.add(s);
      s=in.readLine();
    }
    in.close();
    return all.toArray(new String[0]);
  }
  public static void writeToFile(String[] cont,String filename)throws Exception {
    File file=new File(filename);
    file.delete();
    FileWriter w=null ;
    try {
      w=new FileWriter(file,true);
      for(String s : cont){
        w.write(s+"\n");
      }
    }
    finally {
      if(w!=null){
        w.close();
      }
    }
  }
  public static int[] getIntegersFromString(String s)throws Exception {
    List<Integer>a=new ArrayList<Integer>();
    for(String se : s.split(" ")){
      try {
        Integer x=Integer.parseInt(se);
        a.add(x);
      }
      catch(Exception e){
      }
    }
    int[] ret=new int[a.size()];
    for(int i=0 ; i<a.size(); ++i){
      ret[i]=a.get(i).intValue();
    }
    return ret ;
  }
  private Helper(){
  }
}
------------------------------------------------------------
OCL File:
---------
 class Helper {
  static   operation getAllFileContentAsArray( filename : String) : Sequence(String)
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(filename)) ;
     var all : Sequence(String) ; all := Sequence{} ;
    var s : String ; s := in.readLine() ;
    while (s /= null) do (     all := all->including(s) ; 
     s := in.readLine() ) ; 
    skip ; 
    return all->asSequence() 
 );
  static   operation writeToFile( cont : Sequence(String), filename : String) : void
  pre: true
  post: true
  activity: (     var file : OclFile ; file := OclFile(filename) ;
     skip ; 
     var w : OclFile ; w := null ;
     try (     w := OclFile.newOclFile_Write(file, true) ; 
     for (s : cont) do ( (     skip )  ) )   finally (     if (w /= null) then (     skip ) else skip )
 );
  static   operation getIntegersFromString( s : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{} ;
     for (se : s->split(" ")) do ( (     try (     var x : int ; x := (se)->toInteger() ;
     a := a->including(x) )   catch (e : ProgramException) do skip
 )  ) ; 
    var ret : Sequence(int) ; ret := Integer.subrange(1,a->size())->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     ret[i+1] := a->at(i+1)->oclAsType(int) )  ;     i := i + 1 ) ; 
    return ret 
 );
   static operation newHelper() : Helper
  pre: true
  post: true
  activity:
  ( var self : Helper ;
    self := createHelper();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.File ;
import java.io.FileWriter ;
import java.io.PrintWriter ;
public class B {
  static int parents[];
  public static void main(String args[])throws Exception {
    Scanner in=new Scanner(new File("B.in"));
    FileWriter fw=new FileWriter("B.out");
    PrintWriter out=new PrintWriter(fw);
    int test=in.nextInt();
    for(int t=1 ; t<=test ; t++){
      long A=in.nextLong();
      long B=in.nextLong();
      long P=in.nextLong();
      parents=new int[(int)(B-A+1)];
      for(int i=0 ; i<parents.length ; i++){
        parents[i]=i ;
      }
      int group=parents.length ;
      for(long i=P ; i<=B-A ; i++){
        if(isPrime(i)==true){
          long number=A/i*i ;
          if(number<A){
            number+=i ;
          }
          int root1=getRoot((int)(number-A));
          for(long j=number+i ; j<=B ; j+=i){
            int root2=getRoot((int)(j-A));
            if(root1!=root2){
              parents[root2]=root1 ;
              group--;
            }
          }
        }
      }
      out.println("Case #"+t+": "+group);
    }
    out.close();
    fw.close();
  }
  static boolean isPrime(long number){
    for(long i=2 ; i*i<=number ; i++){
      if(number % i==0){
        return false ;
      }
    }
    return true ;
  }
  static int getRoot(int node){
    int root=node ;
    while(parents[root]!=root){
      root=parents[root];
    }
    while(node!=root){
      int temp=parents[node];
      parents[node]=root ;
      node=temp ;
    }
    return root ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute parents : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("B.in")) ;
     var fw : OclFile ; fw := OclFile.newOclFile_Write(OclFile.newOclFile("B.out")) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(fw) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= test do ( (     var A : long ; A := in.getCurrent()->toLong() ;
     var B : long ; B := in.getCurrent()->toLong() ;
    var P : long ; P := in.getCurrent()->toLong() ;
    parents := Integer.subrange(1,(B - A + 1)->oclAsType(int))->collect(0) ; 
        var i : int ; i := 0 ; while i < parents->size() do ( (     parents[i+1] := i )  ;     i := i + 1 ) ; 
    var group : int ; group := parents->size() ;
        var i : long ; i := P ; while i <= B - A do ( (     if (isPrime(i) = true) then (     var number : long ; number := A / i * i ;
     if (number < A) then (     number := number+(i) ) else skip ; 
     var root1 : int ; root1 := getRoot((number - A)->oclAsType(int)) ;
         var j : long ; j := number + i ; while j <= B do ( (     var root2 : int ; root2 := getRoot((j - A)->oclAsType(int)) ;
     if (root1 /= root2) then (     parents[root2+1] := root1 ; 
     group := group - 1 ) else skip )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation isPrime( number : long) : boolean
  pre: true
  post: true
  activity: (         var i : long ; i := 2 ; while i * i <= number do ( (     if (number mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation getRoot( node : int) : int
  pre: true
  post: true
  activity: (     var root : int ; root := node ;
     while (parents[root+1] /= root) do (     root := parents[root+1] ) ; 
     while (node /= root) do (     var temp : int ; temp := parents[node+1] ;
     parents[node+1] := root ; 
     node := temp ) ; 
     return root );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.HashSet ;
import java.util.Scanner ;
public class R1B_B {
  public static void main(String[] args){
    Scanner scin=new Scanner(System.in);
    int N=scin.nextInt();
    for(int z=1 ; z<=N ; ++z){
      long A=scin.nextLong();
      long B=scin.nextLong();
      long P=scin.nextLong();
      int[] equiv=new int[(int)(B+1)];
      for(int i=(int)A ; i<=B ; ++i)equiv[i]=i ;
      for(int i=(int)A ; i<=B ; ++i){
        for(int j=i+1 ; j<=B ; ++j){
          if(equiv[i]==equiv[j])continue ;
          int gcd=(int)gcd(i,j);
          boolean ok=false ;
          for(int k=(int)P ; k<=gcd ; ++k){
            if(new BigInteger(""+k).isProbablePrime(1024)&& gcd % k==0){
              ok=true ;
              break ;
            }
          }
          if(ok){
            for(int k=(int)A ; k<=B ; ++k){
              if(equiv[k]==equiv[j])equiv[k]=equiv[i];
            }
          }
        }
      }
      HashSet<Integer>set=new HashSet<Integer>();
      for(int i : equiv)set.add(i);
      System.out.println("Case #"+z+": "+(set.size()-1));
    }
  }
  static long gcd(long a,long b){
    return new BigInteger(""+a).gcd(new BigInteger(""+b)).longValue();
  }
}
------------------------------------------------------------
OCL File:
---------
 class R1B_B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scin : OclFile ; scin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scin.getCurrent()->toInteger() ;
         var z : int ; z := 1 ; while z <= N do ( (     var A : long ; A := scin.getCurrent()->toLong() ;
     var B : long ; B := scin.getCurrent()->toLong() ;
    var P : long ; P := scin.getCurrent()->toLong() ;
    var equiv : Sequence(int) ; equiv := Integer.subrange(1,(B + 1)->oclAsType(int))->collect(0) ;
        var i : int ; i := A->oclAsType(int) ; while i <= B do (     equiv[i+1] := i ;  ;     i := i + 1 ) ; 
        var i : int ; i := A->oclAsType(int) ; while i <= B do ( (         var j : int ; j := i + 1 ; while j <= B do ( (     if (equiv[i+1] = equiv[j+1]) then     continue else skip ; 
     var gcd : int ; gcd := gcd(i, j)->oclAsType(int) ;
    var ok : boolean ; ok := false ;
        var k : int ; k := P->oclAsType(int) ; while k <= gcd do ( (     if (long("" + k).isProbablePrime(1024) & gcd mod k = 0) then (     ok := true ; 
     break ) else skip )  ;     k := k + 1 ) ; 
    if (ok) then (         var k : int ; k := A->oclAsType(int) ; while k <= B do ( (     if (equiv[k+1] = equiv[j+1]) then     equiv[k+1] := equiv[i+1] ; else skip )  ;     k := k + 1 ) ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
    for (i : equiv) do (     set := set->including(i) ;  ) ; 
    OclFile["System.out"].println("Case #" + z + ": " + (set->size() - 1)) ; 
 )  ;     z := z + 1 ) );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return long("" + a).gcd(long("" + b))->oclAsType(long) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static void main(String[] args){
    int side=4 ;
    System.out.print("Volume of dodecahedron=");
    System.out.println(vol_of_dodecahedron(side));
  }
  static double vol_of_dodecahedron(int side){
    return(((15+(7*(Math.sqrt(5))))/4)*(Math.pow(side,3)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var side : int ; side := 4 ;
     OclFile["System.out"].print("Volume of dodecahedron=") ; 
     OclFile["System.out"].println(vol_of_dodecahedron(side)) );
  static   operation vol_of_dodecahedron( side : int) : double
  pre: true
  post: true
  activity: (     return (((15 + (7 * ((5)->sqrt()))) / 4) * (side->pow(3))) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    int n=0 ;
    int[] diffArray=null ;
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      n=Integer.parseInt(br.readLine());
      String[] v=br.readLine().split("\\s");
      String[] c=br.readLine().split("\\s");
      diffArray=new int[n];
      for(int i=0 ; i<n ; i++){
        int vi=Integer.parseInt(v[i]);
        int ci=Integer.parseInt(c[i]);
        int diff=vi-ci ;
        if(0<diff){
          diffArray[i]=diff ;
        }
      }
    }
    catch(IOException e){
      e.printStackTrace();
      System.exit(1);
    }
    int sum=0 ;
    for(int i=0 ; i<diffArray.length ; i++){
      sum+=diffArray[i];
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 0 ;
     var diffArray : Sequence(int) ; diffArray := null ;
    try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     n := (br.readLine())->toInteger() ; 
     var v : Sequence(String) ; v := br.readLine()->split("\\s") ;
    var c : Sequence(String) ; c := br.readLine()->split("\\s") ;
    diffArray := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     var vi : int ; vi := (v[i+1])->toInteger() ;
     var ci : int ; ci := (c[i+1])->toInteger() ;
     var diff : int ; diff := vi - ci ;
     if (0 < diff) then (     diffArray[i+1] := diff ) else skip )  ;     i := i + 1 ) ; 
 ))   catch (e : IOException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < diffArray->size() do ( (     sum := sum+(diffArray[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static class Rect implements Comparable<Rect>{
    int h ;
    int w ;
    int d2 ;
    public Rect(int h,int w){
      this.h=h ;
      this.w=w ;
      this.d2=h*h+w*w ;
    }
    @ Override public int compareTo(Rect other){
      if(d2!=other.d2){
        return d2-other.d2 ;
      }
      return h-other.h ;
    }
    @ Override public boolean equals(Object other){
      return compareTo((Rect)other)==0 ;
    }
  }
  public static void main(String[] args){
    List<Rect>candidates=new ArrayList<Rect>();
    for(int h=1 ; h<=150 ; h++){
      for(int w=h+1 ; w<=150 ; w++){
        candidates.add(new Rect(h,w));
      }
    }
    Collections.sort(candidates);
    Scanner sc=new Scanner(System.in);
    while(true){
      int h=sc.nextInt();
      int w=sc.nextInt();
      if(h==0 && w==0){
        break ;
      }
      Rect rect=new Rect(h,w);
      Rect ansRect=candidates.get(candidates.indexOf(rect)+1);
      System.out.println(ansRect.h+" "+ansRect.w);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Rect implements Comparable<Rect> {
   attribute h : int;
   attribute w : int;
   attribute d2 : int;
   static operation newRect( h : int, w : int) : Rect
  pre: true
  post: true
  activity:
  ( var self : Rect ;
    self := createRect();
    self.initialise(h, w);
    return self );
  operation initialise( h : int, w : int) : void
  pre: true  post: true
  activity: (     self.h := h ; 
     self.w := w ; 
     self.d2 := h * h + w * w );
      operation compareTo( other : Rect) : int
  pre: true
  post: true
  activity: (     if (d2 /= other.d2) then (     return d2 - other.d2 ) else skip ; 
     return h - other.h );
      operation equals( other : OclAny) : boolean
  pre: true
  post: true
  activity: (     return compareTo(other->oclAsType(Rect)) = 0 );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var candidates : Sequence(Rect) ; candidates := Sequence{} ;
         var h : int ; h := 1 ; while h <= 150 do ( (         var w : int ; w := h + 1 ; while w <= 150 do ( (     candidates := candidates->including(Rect.newRect(h, w)) )  ;     w := w + 1 ) )  ;     h := h + 1 ) ; 
    candidates := candidates->sort() ; 
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (true) do (     var h : int ; h := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    if (h = 0 & w = 0) then (     break ) else skip ; 
    var rect : Rect ; rect := Rect.newRect(h, w) ;
    var ansRect : Rect ; ansRect := candidates->at(candidates->indexOf(rect)-1 + 1+1) ;
    OclFile["System.out"].println(ansRect.h + " " + ansRect.w) ; 
 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class ring {
  public static boolean checkcircle(int r,int R,int r1,int x1,int y1){
    int dis=(int)Math.sqrt(x1*x1+y1*y1);
    return(dis-r1>=R && dis+r1<=r);
  }
  public static void main(String args[]){
    int r=8,R=4,r1=2,x1=6,y1=0 ;
    if(checkcircle(r,R,r1,x1,y1))System.out.println("yes");
    else System.out.println("no");
  }
}
------------------------------------------------------------
OCL File:
---------
 class ring {
  static   operation checkcircle( r : int, R : int, r1 : int, x1 : int, y1 : int) : boolean
  pre: true
  post: true
  activity: (     var dis : int ; dis := (x1 * x1 + y1 * y1)->sqrt()->oclAsType(int) ;
     return (dis - r1 >= R & dis + r1 <= r) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : int ; r := 8 ;
    var R : int ; R := 4 ;
    var r1 : int ; r1 := 2 ;
    var x1 : int ; x1 := 6 ;
    var y1 : int ; y1 := 0 ;
     if (checkcircle(r, R, r1, x1, y1)) then     OclFile["System.out"].println("yes") ; else     OclFile["System.out"].println("no") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(true){
      int h=stdIn.nextInt();
      int w=stdIn.nextInt();
      if(h==0 && w==0){
        break ;
      }
      int diagonal=h*h+w*w ;
      int i=1 ;
      boolean flag=false ;
      int diagonal_min=100000 ;
      int h_min=151 ;
      int w_min=151 ;
      while(true){
        for(int j=i+1 ; j<150 ; j++){
          if((i!=h || j!=w)&& diagonal==(i*i+j*j)&& i>h){
            System.out.println(i+" "+j);
            flag=true ;
            break ;
          }
          if(diagonal<(i*i+j*j)&&(i*i+j*j)==diagonal && h_min>i && i>h){
            h_min=i ;
            w_min=j ;
          }
          if(diagonal<(i*i+j*j)&&(i*i+j*j)<diagonal_min){
            diagonal_min=i*i+j*j ;
            h_min=i ;
            w_min=j ;
          }
          if(j==i+1 && diagonal<(i*i+j*j)){
            System.out.println(h_min+" "+w_min);
            flag=true ;
            break ;
          }
        }
        if(flag){
          break ;
        }
        if(i==149){
          System.out.println(h_min+" "+w_min);
          break ;
        }
        i++;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var h : int ; h := stdIn.getCurrent()->toInteger() ;
     var w : int ; w := stdIn.getCurrent()->toInteger() ;
    if (h = 0 & w = 0) then (     break ) else skip ; 
    var diagonal : int ; diagonal := h * h + w * w ;
    var i : int ; i := 1 ;
    var flag : boolean ; flag := false ;
    var diagonal_min : int ; diagonal_min := 100000 ;
    var h_min : int ; h_min := 151 ;
    var w_min : int ; w_min := 151 ;
    while (true) do (         var j : int ; j := i + 1 ; while j < 150 do ( (     if ((i /= h or j /= w) & diagonal = (i * i + j * j) & i > h) then (     OclFile["System.out"].println(i + " " + j) ; 
     flag := true ; 
     break ) else skip ; 
     if (diagonal < (i * i + j * j) & (i * i + j * j) = diagonal & h_min > i & i > h) then (     h_min := i ; 
     w_min := j ) else skip ; 
     if (diagonal < (i * i + j * j) & (i * i + j * j) < diagonal_min) then (     diagonal_min := i * i + j * j ; 
     h_min := i ; 
     w_min := j ) else skip ; 
     if (j = i + 1 & diagonal < (i * i + j * j)) then (     OclFile["System.out"].println(h_min + " " + w_min) ; 
     flag := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (flag) then (     break ) else skip ; 
     if (i = 149) then (     OclFile["System.out"].println(h_min + " " + w_min) ; 
     break ) else skip ; 
     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static final Scanner scn=new Scanner(System.in);
  private static final List<IntegralRectangle>RECTANGLES ;
  private static final int MAX=150 ;
  static {
    RECTANGLES=new ArrayList<>();
    Main main=new Main();
    for(int y=1 ; y<MAX ; y++){
      for(int x=-~ y ; x<-~ MAX ; x++){
        RECTANGLES.add(main.new IntegralRectangle(y,x));
      }
    }
    Collections.sort(RECTANGLES);
  }
  public static void main(String[] args){
    new Main().solve();
  }
  void solve(){
    int height ;
    int width ;
    while((height=scn.nextInt())>0 |(width=scn.nextInt())>0){
      IntegralRectangle base=new IntegralRectangle(height,width);
      for(IntegralRectangle rectangle : RECTANGLES){
        if(base.compareTo(rectangle)<0){
          System.out.println(rectangle);
          break ;
        }
      }
    }
  }
  class IntegralRectangle implements Comparable<IntegralRectangle>{
    private int height ;
    private int width ;
    public IntegralRectangle(int height,int width){
      this.height=height ;
      this.width=width ;
    }
    private int squareDiagonal(){
      return height*height+width*width ;
    }
    @ Override public int compareTo(IntegralRectangle another){
      if(this.squareDiagonal()>another.squareDiagonal()){
        return 1 ;
      }
      else if(this.squareDiagonal()<another.squareDiagonal()){
        return-1 ;
      }
      else {
        if(this.height!=another.height){
          return this.height>another.height ? 1 :-1 ;
        }
        else {
          return 0 ;
        }
      }
    }
    @ Override public String toString(){
      return height+" "+width ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute scn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute RECTANGLES : Sequence(IntegralRectangle);
  static    attribute MAX : int := 150;
  static operation initialiseClass()
  pre: true post: true
  activity:     RECTANGLES := Sequence{} ; 
    var main : Main ; main := Main.newMain() ;
        var y : int ; y := 1 ; while y < MAX do ( (         var x : int ; x := --(y + 1) ; while x < --(MAX + 1) do ( (     RECTANGLES := RECTANGLES->including((main).newIntegralRectangle(y, x)) )  ;     x := x + 1 ) )  ;     y := y + 1 ) ; 
    RECTANGLES := RECTANGLES->sort() ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var height : int ;
     var width : int ;
         height := scn.getCurrent()->toInteger() ;
    width := scn.getCurrent()->toInteger() ;
    while ((height) > 0 or (width) > 0) do (    skip ; (     var base : IntegralRectangle ; base := IntegralRectangle.newIntegralRectangle(height, width) ;
     for (rectangle : RECTANGLES) do ( (     if (base->compareTo(rectangle) < 0) then (     OclFile["System.out"].println(rectangle) ; 
     break ) else skip )  ) ) ;     height := scn.getCurrent()->toInteger() ;
    width := scn.getCurrent()->toInteger() ;
 ) );
 class IntegralRectangle implements Comparable<IntegralRectangle> {
   attribute height : int;
   attribute width : int;
   static operation newIntegralRectangle( height : int, width : int) : IntegralRectangle
  pre: true
  post: true
  activity:
  ( var self : IntegralRectangle ;
    self := createIntegralRectangle();
    self.initialise(height, width);
    return self );
  operation initialise( height : int, width : int) : void
  pre: true  post: true
  activity: (     self.height := height ; 
     self.width := width );
   operation squareDiagonal() : int
  pre: true
  post: true
  activity: (     return height * height + width * width );
      operation compareTo( another : IntegralRectangle) : int
  pre: true
  post: true
  activity: (     if (self.squareDiagonal() > another.squareDiagonal()) then (     return 1 ) else     if (self.squareDiagonal() < another.squareDiagonal()) then (     return -1 ) else (     if (self.height /= another.height) then (     return if self.height > another.height then 1 else -1 endif ) else (     return 0 ) ) ;  );
      operation toString() : String
  pre: true
  post: true
  activity: (     return height + " " + width );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int h,w ;
  void run(){
    for(; ; ){
      h=sc.nextInt();
      w=sc.nextInt();
      if((h | w)==0){
        break ;
      }
      solve();
    }
  }
  void solve(){
    int ww=200,hh=200 ;
    for(int i=1 ; i<200 ; i++){
      for(int j=1 ; j<i ; j++){
        if(comp(i,j,w,h)>0 && comp(i,j,ww,hh)<0){
          ww=i ;
          hh=j ;
        }
      }
    }
    println(hh+" "+ww);
  }
  int comp(int w1,int h1,int w2,int h2){
    if(w1*w1+h1*h1!=w2*w2+h2*h2){
      return(w1*w1+h1*h1)-(w2*w2+h2*h2);
    }
    else {
      return h1-h2 ;
    }
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute h : int;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     h := sc.getCurrent()->toInteger() ; 
     w := sc.getCurrent()->toInteger() ; 
     if ((MathLib.bitwiseOr(h,w)) = 0) then (     break ) else skip ; 
     execute solve() )  ) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var ww : int ; ww := 200 ;
    var hh : int ; hh := 200 ;
         var i : int ; i := 1 ; while i < 200 do ( (         var j : int ; j := 1 ; while j < i do ( (     if (comp(i, j, w, h) > 0 & comp(i, j, ww, hh) < 0) then (     ww := i ; 
     hh := j ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     execute println(hh + " " + ww) );
   operation comp( w1 : int, h1 : int, w2 : int, h2 : int) : int
  pre: true
  post: true
  activity: (     if (w1 * w1 + h1 * h1 /= w2 * w2 + h2 * h2) then (     return (w1 * w1 + h1 * h1) - (w2 * w2 + h2 * h2) ) else (     return h1 - h2 ) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findSum(int N,int k){
    int sum=0 ;
    for(int i=1 ; i<=N ; i++){
      sum+=(int)Math.pow(i,k);
    }
    return sum ;
  }
  public static void main(String[] args){
    int N=8,k=4 ;
    System.out.println(findSum(N,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findSum( N : int, k : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= N do ( (     sum := sum+(i->pow(k)->oclAsType(int)) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 8 ;
    var k : int ; k := 4 ;
     OclFile["System.out"].println(findSum(N, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int count(int N){
    int sum=0 ;
    for(int i=1 ; i<=N ; i++){
      sum+=7*Math.pow(8,i-1);
    }
    return sum ;
  }
  public static void main(String[] args){
    int N=4 ;
    System.out.println(count(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation count( N : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= N do ( (     sum := sum+(7 * 8->pow(i - 1)) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(count(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int factorial(int n){
    int res=1 ;
    for(int i=2 ; i<=n ; i++)res=res*i ;
    return res ;
  }
  static int calculateSeries(int n){
    return 2+(n*n+n-2)*factorial(n+1);
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(calculateSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation factorial( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
         var i : int ; i := 2 ; while i <= n do (     res := res * i ;  ;     i := i + 1 ) ; 
     return res );
  static   operation calculateSeries( n : int) : int
  pre: true
  post: true
  activity: (     return 2 + (n * n + n - 2) * factorial(n + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(calculateSeries(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int factorial(int n){
    int res=1 ;
    for(int i=2 ; i<=n ; i++)res=res*i ;
    return res ;
  }
  static int calculateSeries(int n){
    return factorial(n+1)-1 ;
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(calculateSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation factorial( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
         var i : int ; i := 2 ; while i <= n do (     res := res * i ;  ;     i := i + 1 ) ; 
     return res );
  static   operation calculateSeries( n : int) : int
  pre: true
  post: true
  activity: (     return factorial(n + 1) - 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(calculateSeries(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Integer n=Integer.valueOf(sc.nextLine());
    String vStr=sc.nextLine();
    Map<Integer,Integer>vList=str2List(vStr);
    String cStr=sc.nextLine();
    Map<Integer,Integer>cList=str2List(cStr);
    Integer max=0 ;
    for(Integer i=0 ; i<n ; i++){
      Integer profit=vList.get(i)-cList.get(i);
      if(profit>0){
        max+=profit ;
      }
    }
    System.out.println(max);
  }
  static Map<Integer,Integer>str2List(String str){
    String[] vArrStr=str.split(" ");
    Map<Integer,Integer>ret=new HashMap<>();
    Integer key=0 ;
    for(String val : vArrStr){
      ret.put(key,Integer.valueOf(val));
      key++;
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.nextLine())->toInteger() ;
    var vStr : String ; vStr := sc.nextLine() ;
    var vList : Map(int,int) ; vList := str2List(vStr) ;
    var cStr : String ; cStr := sc.nextLine() ;
    var cList : Map(int,int) ; cList := str2List(cStr) ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var profit : int ; profit := vList->at(i) - cList->at(i) ;
     if (profit > 0) then (     max := max+(profit) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static   operation str2List( str : String) : Map(int,int)
  pre: true
  post: true
  activity: (     var vArrStr : Sequence(String) ; vArrStr := str->split(" ") ;
     var ret : Map(int,int) ; ret := Map{} ;
    var key : int ; key := 0 ;
    for (val : vArrStr) do ( (     ret := ret->union(Map{key |-> (val)->toInteger()}) ; 
     key := key + 1 )  ) ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int arr[]=new int[] {
    4,7,3,6,7 };
    public static void printTriangle(int n){
      int tri[][]=new int[n][n];
      for(int i=0 ; i<n ; i++)tri[n-1][i]=arr[i];
      for(int i=n-2 ; i>=0 ; i--)for(int j=0 ; j<=i ; j++)tri[i][j]=tri[i+1][j]+tri[i+1][j+1];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<=i ; j++)System.out.print(tri[i][j]+" ");
        System.out.println();
      }
    }
    public static void main(String[] args){
      printTriangle(arr.length);
    }
  }

------------------------------------------------------------
OCL File:
---------
class Test {
  static   attribute arr : int := Sequence{4,7,3,6,7};
  static   operation printTriangle( n : int) : void
  pre: true
  post: true
  activity: (     var tri : Sequence(Sequence(int)) ; tri := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do (     tri[n - 1+1][i+1] := arr[i+1] ;  ;     i := i + 1 ) ; 
         var i : int ; i := n - 2 ; while i >= 0 do (         var j : int ; j := 0 ; while j <= i do (     tri[i+1][j+1] := tri[i + 1+1][j+1] + tri[i + 1+1][j + 1+1] ;  ;     j := j + 1 ) ;  ;     i := i - 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j <= i do (     OclFile["System.out"].print(tri[i+1][j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute printTriangle(arr->size()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class cf1093 {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    while(t-->0){
      String s1=scan.next();
      char[] s=s1.toCharArray();
      Arrays.sort(s);
      if(s[0]==s[s.length-1])System.out.println(-1);
      else System.out.println(s);
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1093 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s1 : String ; s1 := scan.getCurrent() ;
     var s : Sequence(String) ; s := s1->characters() ;
     s := s->sort() ; 
     if (s[0+1] = s[s->size() - 1+1]) then     OclFile["System.out"].println(-1) ; else     OclFile["System.out"].println(s) ; ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class letter {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    for(int i=0 ; i<t ; i++){
      String string=scan.next();
      if(string.length()==1){
        System.out.println("-1");
      }
      char[] array=string.toCharArray();
      Arrays.sort(array);
      for(int x=0 ; x<string.length()-1 ; x++){
        if(array[x]!=(array[x+1])){
          String out=String.copyValueOf(array);
          System.out.println(out);
          break ;
        }
        else if(x==string.length()-2){
          System.out.println("-1");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class letter {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var string : String ; string := scan.getCurrent() ;
     if (string->size() = 1) then (     OclFile["System.out"].println("-1") ) else skip ; 
    var array : Sequence(String) ; array := string->characters() ;
    array := array->sort() ; 
        var x : int ; x := 0 ; while x < string->size() - 1 do ( (     if (array[x+1] /= (array[x + 1+1])) then (     var out : String ; out := (array)->sum() ;
     OclFile["System.out"].println(out) ; 
     break ) else     if (x = string->size() - 2) then (     OclFile["System.out"].println("-1") ) else skip ; )  ;     x := x + 1 ) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class JavAki {
  public static Scanner sc=new Scanner(System.in);
  public static String s ;
  public static void Input(){
    s=sc.next();
  }
  public static void Solve(){
    ArrayList<Integer>olist=new ArrayList<>();
    ArrayList<Integer>clist=new ArrayList<>();
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='(')olist.add(i);
      if(s.charAt(i)==')')clist.add(i);
    }
    ArrayList<Integer>r=new ArrayList<>();
    int optr=0,cptr=clist.size()-1 ;
    while(optr<olist.size()&& cptr>=0){
      if(olist.get(optr)>clist.get(cptr))break ;
      r.add(olist.get(optr));
      r.add(clist.get(cptr));
      optr++;
      cptr--;
    }
    Collections.sort(r);
    if(r.size()==0)System.out.println(0);
    else {
      System.out.println(1);
      System.out.println(r.size());
      for(int x : r)System.out.print((x+1)+" ");
      System.out.println();
    }
  }
  public static void main(String[] args){
    Input();
    Solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavAki {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute s : String;
  static   operation Input() : void
  pre: true
  post: true
  activity: (     s := sc.getCurrent() );
  static   operation Solve() : void
  pre: true
  post: true
  activity: (     var olist : Sequence(int) ; olist := Sequence{} ;
     var clist : Sequence(int) ; clist := Sequence{} ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '(') then     olist := olist->including(i) ; else skip ; 
     if (s->at(i+1) = ')') then     clist := clist->including(i) ; else skip )  ;     i := i + 1 ) ; 
    var r : Sequence(int) ; r := Sequence{} ;
    var optr : int ; optr := 0 ;
    var cptr : int ; cptr := clist->size() - 1 ;
    while (optr < olist->size() & cptr >= 0) do (     if (olist->at(optr+1) > clist->at(cptr+1)) then     break else skip ; 
     r := r->including(olist->at(optr+1)) ; 
    r := r->including(clist->at(cptr+1)) ; 
    optr := optr + 1 ; 
    cptr := cptr - 1 ; 
 ) ; 
    r := r->sort() ; 
    if (r->size() = 0) then     OclFile["System.out"].println(0) else (     OclFile["System.out"].println(1) ; 
     OclFile["System.out"].println(r->size()) ; 
     for (x : r) do (     OclFile["System.out"].print((x + 1) + " ") ;  ) ; 
     OclFile["System.out"].println() ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute Input() ; 
     execute Solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class abc {
  public static void main(String args[]){
    Scanner scn=new Scanner(System.in);
    int t=scn.nextInt();
    while(t-->0){
      String str=scn.next();
      char[] arr=str.toCharArray();
      int n=arr.length ;
      Arrays.sort(arr);
      if(arr[0]==arr[n-1]){
        System.out.println(-1);
      }
      else {
        String ans=new String(arr);
        System.out.println(ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class abc {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scn.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var str : String ; str := scn.getCurrent() ;
     var arr : Sequence(String) ; arr := str->characters() ;
    var n : int ; n := arr->size() ;
    arr := arr->sort() ; 
    if (arr[0+1] = arr[n - 1+1]) then (     OclFile["System.out"].println(-1) ) else (     var ans : String ; ans := StringLib.newString(arr) ;
     OclFile["System.out"].println(ans) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class cf1039b {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    while(t-->0){
      String str=scan.next();
      char[] arr=str.toCharArray();
      Arrays.sort(arr);
      if(arr[0]==arr[str.length()-1]){
        System.out.println("-1");
      }
      else {
        System.out.println(String.valueOf(arr));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1039b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var str : String ; str := scan.getCurrent() ;
     var arr : Sequence(String) ; arr := str->characters() ;
     arr := arr->sort() ; 
     if (arr[0+1] = arr[str->size() - 1+1]) then (     OclFile["System.out"].println("-1") ) else (     OclFile["System.out"].println((arr)->sum() ) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf1093B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    while(t-->0){
      String s=scan.next();
      char[] arr=s.toCharArray();
      Arrays.sort(arr);
      if(arr[0]==arr[arr.length-1])System.out.println(-1);
      else System.out.println(arr);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1093B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : String ; s := scan.getCurrent() ;
     var arr : Sequence(String) ; arr := s->characters() ;
     arr := arr->sort() ; 
     if (arr[0+1] = arr[arr->size() - 1+1]) then     OclFile["System.out"].println(-1) ; else     OclFile["System.out"].println(arr) ; ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Div2A {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    FastReader fsr=new FastReader();
    long n=fsr.nextLong();
    long x=fsr.nextLong();
    long y=fsr.nextLong();
    solution(n,x,y,out);
    out.flush();
    out.close();
  }
  private static void solution(long n,long x,long y,PrintWriter out){
    if(x+y<=n+1){
      out.println("White");
    }
    else {
      out.println("Black");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Div2A {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var fsr : FastReader ; fsr := FastReader.newFastReader() ;
    var n : long ; n := fsr.nextLong() ;
    var x : long ; x := fsr.nextLong() ;
    var y : long ; y := fsr.nextLong() ;
    execute solution(n, x, y, out) ; 
    skip ; 
    skip ; 
 );
  static   operation solution( n : long, x : long, y : long, out : OclFile) : void
  pre: true
  post: true
  activity: (     if (x + y <= n + 1) then (     skip ) else (     skip ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class310 {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long x,y ;
    x=sc.nextLong();
    y=sc.nextLong();
    if(Math.max(n-x,n-y)<Math.max(x-1,y-1)){
      System.out.println("BLACK");
    }
    else {
      System.out.println("WHITE");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class310 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var x : long ;
    var y : long ;
    x := sc.getCurrent()->toLong() ; 
    y := sc.getCurrent()->toLong() ; 
    if (Set{n - x, n - y}->max() < Set{x - 1, y - 1}->max()) then (     OclFile["System.out"].println("BLACK") ) else (     OclFile["System.out"].println("WHITE") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TheKingsRace {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long x=sc.nextLong();
    long y=sc.nextLong();
    n=n-x-y ;
    if(n>=-1)System.out.println("White");
    else System.out.println("Black");
  }
}
------------------------------------------------------------
OCL File:
---------
 class TheKingsRace {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var x : long ; x := sc.getCurrent()->toLong() ;
    var y : long ; y := sc.getCurrent()->toLong() ;
    n := n - x - y ; 
    if (n >= -1) then     OclFile["System.out"].println("White") else     OclFile["System.out"].println("Black") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String args[])throws Exception {
    BufferedReader stdR=new BufferedReader(new InputStreamReader(System.in));
    int N=Integer.parseInt(stdR.readLine());
    String[] str=stdR.readLine().split(" ");
    String[] str2=stdR.readLine().split(" ");
    int res=0 ;
    for(int i=0 ; i<N ; i++){
      int V=Integer.parseInt(str[i]);
      int C=Integer.parseInt(str2[i]);
      if(V>C){
        res+=V-C ;
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdR : OclFile ; stdR := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var N : int ; N := (stdR.readLine())->toInteger() ;
    var str : Sequence(String) ; str := stdR.readLine()->split(" ") ;
    var str2 : Sequence(String) ; str2 := stdR.readLine()->split(" ") ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var V : int ; V := (str[i+1])->toInteger() ;
     var C : int ; C := (str2[i+1])->toInteger() ;
     if (V > C) then (     res := res+(V - C) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double mulmod(long a,long b,long mod){
    long res=0 ;
    a=a % mod ;
    while(b>0){
      if(b % 2==1)res=(res+a)% mod ;
      a=(a*2)% mod ;
      b/=2 ;
    }
    return res % mod ;
  }
  static long findProduct(long N){
    long product=1,fact=1 ;
    long MOD=(long)(1e9+7);
    for(int i=1 ; i<=N ; i++){
      fact=(long)mulmod(fact,i,MOD);
      product=(long)mulmod(product,fact,MOD);
      if(product==0)return 0 ;
    }
    return product ;
  }
  public static void main(String[] args){
    long N=3 ;
    System.out.println(findProduct(N));
    N=5 ;
    System.out.println(findProduct(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation mulmod( a : long, b : long, mod : long) : double
  pre: true
  post: true
  activity: (     var res : long ; res := 0 ;
     a := a mod mod ; 
     while (b > 0) do (     if (b mod 2 = 1) then     res := (res + a) mod mod ; else skip ; 
     a := (a * 2) mod mod ; 
     b := b/(2) ) ; 
     return res mod mod );
  static   operation findProduct( N : long) : long
  pre: true
  post: true
  activity: (     var product : long ; product := 1 ;
    var fact : long ; fact := 1 ;
     var MOD : long ; MOD := (1e9 + 7)->oclAsType(long) ;
         var i : int ; i := 1 ; while i <= N do ( (     fact := mulmod(fact, i, MOD)->oclAsType(long) ; 
     product := mulmod(product, fact, MOD)->oclAsType(long) ; 
     if (product = 0) then     return 0 else skip )  ;     i := i + 1 ) ; 
     return product );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := 3 ;
     OclFile["System.out"].println(findProduct(N)) ; 
     N := 5 ; 
     OclFile["System.out"].println(findProduct(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemC {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int test=Integer.parseInt(br.readLine());
    while(test-->0){
      int n=Integer.parseInt(br.readLine());
      String line[]=br.readLine().split(" ");
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=Integer.parseInt(line[i]);
      int st=arr[0];
      boolean ok1=true,ok2=true ;
      for(int i=1 ; i<n ; i++){
        st++;
        if(st>n)st=1 ;
        if(st!=arr[i])ok1=false ;
      }
      st=arr[0];
      for(int i=1 ; i<n ; i++){
        st--;
        if(st==0)st=n ;
        if(st!=arr[i])ok2=false ;
      }
      String ans="NO" ;
      if(ok1 || ok2)ans="YES" ;
      sb.append(ans);
      sb.append("\n");
    }
    System.out.println(sb);
  }
  public static void swap(int i,int j,int builder[]){
    int t=builder[i];
    builder[i]=builder[j];
    builder[j]=t ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemC {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var test : int ; test := (br.readLine())->toInteger() ;
        while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := (line[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var st : int ; st := arr[0+1] ;
    var ok1 : boolean ; ok1 := true ;
    var ok2 : boolean ; ok2 := true ;
        var i : int ; i := 1 ; while i < n do ( (     st := st + 1 ; 
     if (st > n) then     st := 1 ; else skip ; 
     if (st /= arr[i+1]) then     ok1 := false ; else skip )  ;     i := i + 1 ) ; 
    st := arr[0+1] ; 
        var i : int ; i := 1 ; while i < n do ( (     st := st - 1 ; 
     if (st = 0) then     st := n ; else skip ; 
     if (st /= arr[i+1]) then     ok2 := false ; else skip )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "NO" ;
    if (ok1 or ok2) then     ans := "YES" ; else skip ; 
    sb := sb + StringLib.newString(ans) ; 
    sb := sb + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
  static   operation swap( i : int, j : int, builder : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := builder[i+1] ;
     builder[i+1] := builder[j+1] ; 
     builder[j+1] := t );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeHundredSixtyOne {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=input.nextInt();
      int[] arrayOne=new int[n];
      for(int i=0 ; i<n ; i++){
        arrayOne[i]=input.nextInt();
      }
      int flag=0 ;
      int gabe=arrayOne[0];
      for(int i=1 ; i<n ; i++){
        if(arrayOne[i]==arrayOne[i-1]+1){
          flag++;
        }
        else if(arrayOne[i]==arrayOne[i-1]-n+1){
          flag++;
        }
      }
      int flag2=0 ;
      int gabe2=arrayOne[0];
      for(int i=1 ; i<n ; i++){
        if(arrayOne[i]==arrayOne[i-1]-1){
          flag2++;
        }
        else if(arrayOne[i]==arrayOne[i-1]+n-1){
          flag2++;
        }
      }
      if(flag==n-1 || flag2==n-1){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixtyOne {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var arrayOne : Sequence(int) ; arrayOne := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arrayOne[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var flag : int ; flag := 0 ;
    var gabe : int ; gabe := arrayOne[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     if (arrayOne[i+1] = arrayOne[i - 1+1] + 1) then (     flag := flag + 1 ) else     if (arrayOne[i+1] = arrayOne[i - 1+1] - n + 1) then (     flag := flag + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    var flag2 : int ; flag2 := 0 ;
    var gabe2 : int ; gabe2 := arrayOne[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     if (arrayOne[i+1] = arrayOne[i - 1+1] - 1) then (     flag2 := flag2 + 1 ) else     if (arrayOne[i+1] = arrayOne[i - 1+1] + n - 1) then (     flag2 := flag2 + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    if (flag = n - 1 or flag2 = n - 1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      try {
        br=new BufferedReader(new FileReader("input.rtf"));
        PrintStream out=new PrintStream(new FileOutputStream("output.rtf"));
        System.setOut(out);
      }
      catch(Exception e){
        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 ;
    }
  }
  public static void main(String[] args){
    FastReader read=new FastReader();
    long t=read.nextLong();
    for(int i=0 ; i<t ; i++){
      int n=read.nextInt();
      int[] arr=new int[n];
      for(int j=0 ; j<n ; j++)arr[j]=read.nextInt();
      boolean t1=true ;
      for(int j=0 ; j<n-1 ; j++){
        if(((arr[j]+1)% n)!=(arr[j+1] % n)){
          t1=false ;
          break ;
        }
      }
      boolean t2=true ;
      for(int j=n-1 ; j>=1 ; j--){
        if(((arr[j]+1)% n)!=(arr[j-1] % n)){
          t2=false ;
          break ;
        }
      }
      if(t1 || t2)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.rtf"))) ; 
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.rtf"))) ;
 setOut(out) )   catch (e : ProgramException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : FastReader ; read := FastReader.newFastReader() ;
     var t : long ; t := read.nextLong() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := read.nextInt() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do (     arr[j+1] := read.nextInt() ;  ;     j := j + 1 ) ; 
    var t1 : boolean ; t1 := true ;
        var j : int ; j := 0 ; while j < n - 1 do ( (     if (((arr[j+1] + 1) mod n) /= (arr[j + 1+1] mod n)) then (     t1 := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    var t2 : boolean ; t2 := true ;
        var j : int ; j := n - 1 ; while j >= 1 do ( (     if (((arr[j+1] + 1) mod n) /= (arr[j - 1+1] mod n)) then (     t2 := false ; 
     break ) else skip )  ;     j := j - 1 ) ; 
    if (t1 or t2) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Run {
  public static void main(String[] Z)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder op=new StringBuilder();
    char[] s=br.readLine().toCharArray();
    int n=s.length ;
    ArrayList<Integer>list=new ArrayList<>();
    int left,right ;
    left=0 ;
    right=n-1 ;
    int count=0 ;
    while(left<right){
      while(left<n && s[left]==')')++left ;
      while(right>=0 && s[right]=='(')--right ;
      if(left>=right)break ;
      op.append(String.format("%d ",left+1));
      list.add(right+1);
      count+=2 ;
++left ;
--right ;
    }
    if(count==0){
      System.out.println("0");
      return ;
    }
    Collections.reverse(list);
    for(int e : list)op.append(String.format("%d ",e));
    System.out.printf("1\n%d\n%s",count,op);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Run {
  static   operation main( Z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var op : String ; op := StringLib.newString() ;
    var s : Sequence(String) ; s := br.readLine()->characters() ;
    var n : int ; n := s->size() ;
    var list : Sequence(int) ; list := Sequence{} ;
    var left : int ;
    var right : int ;
    left := 0 ; 
    right := n - 1 ; 
    var count : int ; count := 0 ;
    while (left < right) do (     while (left < n & s[left+1] = ')') do     left := left + 1 ; ; 
     while (right >= 0 & s[right+1] = '(') do     right := right - 1 ; ; 
    if (left >= right) then     break else skip ; 
    op := op + StringLib.newString(StringLib.format("%d ",Sequence{left + 1})) ; 
    list := list->including(right + 1) ; 
    count := count+(2) ; 
    left := left + 1 ; 
    right := right - 1 ; 
 ) ; 
    if (count = 0) then (     OclFile["System.out"].println("0") ; 
     return ) else skip ; 
    list := list->reverse() ; 
    for (e : list) do (     op := op + StringLib.newString(StringLib.format("%d ",Sequence{e})) ;  ) ; 
    OclFile["System.out"].printf("1\n%d\n%s", count, op) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import java.util.*;
public class Solution {
  public static void main(String args[]){
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    boolean breakd=false ;
    int temp,last ;
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      int t=sc.nextInt();
      breakd=false ;
      last=sc.nextInt();
      for(int s=1 ; s<t ; s++){
        temp=sc.nextInt();
        if(breakd){
          continue ;
        }
        if(last!=temp+1 && last!=temp-1){
          if(!((temp==t && last==1)||(temp==1 && last==t))){
            breakd=true ;
            sb.append("NO").append("\n");
          }
        }
        last=temp ;
      }
      if(! breakd){
        sb.append("YES").append("\n");
      }
    }
    System.out.println(sb);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : int ; n := sc.nextInt() ;
    var breakd : boolean ; breakd := false ;
    var temp : int ;
    var last : int ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     var t : int ; t := sc.nextInt() ;
     breakd := false ; 
    last := sc.nextInt() ; 
        var s : int ; s := 1 ; while s < t do ( (     temp := sc.nextInt() ; 
     if (breakd) then (     continue ) else skip ; 
     if (last /= temp + 1 & last /= temp - 1) then (     if (not(((temp = t & last = 1) or (temp = 1 & last = t)))) then (     breakd := true ; 
     sb := sb + StringLib.newString("NO") + StringLib.newString("\n") ) else skip ) else skip ; 
     last := temp )  ;     s := s + 1 ) ; 
    if (not(breakd)) then (     sb := sb + StringLib.newString("YES") + StringLib.newString("\n") ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf1203A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    while(t-->0){
      int n=scan.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=scan.nextInt();
      }
      int pointer=a[0];
      boolean isInc=true ;
      for(int i=1 ; i<n ; i++){
        pointer++;
        if(pointer>n)pointer=1 ;
        if(pointer!=a[i]){
          isInc=false ;
        }
      }
      pointer=a[0];
      boolean isDec=true ;
      for(int i=1 ; i<n ; i++){
        pointer--;
        if(pointer<1)pointer=n ;
        if(pointer!=a[i]){
          isDec=false ;
        }
      }
      if(isDec || isInc){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1203A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var pointer : int ; pointer := a[0+1] ;
    var isInc : boolean ; isInc := true ;
        var i : int ; i := 1 ; while i < n do ( (     pointer := pointer + 1 ; 
     if (pointer > n) then     pointer := 1 ; else skip ; 
     if (pointer /= a[i+1]) then (     isInc := false ) else skip )  ;     i := i + 1 ) ; 
    pointer := a[0+1] ; 
    var isDec : boolean ; isDec := true ;
        var i : int ; i := 1 ; while i < n do ( (     pointer := pointer - 1 ; 
     if (pointer < 1) then     pointer := n ; else skip ; 
     if (pointer /= a[i+1]) then (     isDec := false ) else skip )  ;     i := i + 1 ) ; 
    if (isDec or isInc) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final Scanner scan=new Scanner(System.in);
  static int n,m ;
  public static void main(String[] args){
    n=scan.nextInt();
    m=scan.nextInt();
    if(n<=m){
      if(n % 2==0)System.out.println("Malvika");
      else System.out.println("Akshat");
    }
    else {
      if(m % 2==0)System.out.println("Malvika");
      else System.out.println("Akshat");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := scan.getCurrent()->toInteger() ; 
     m := scan.getCurrent()->toInteger() ; 
     if (n <= m) then (     if (n mod 2 = 0) then     OclFile["System.out"].println("Malvika") ; else     OclFile["System.out"].println("Akshat") ; ) else (     if (m mod 2 = 0) then     OclFile["System.out"].println("Malvika") ; else     OclFile["System.out"].println("Akshat") ; ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import com.sun.javafx.scene.control.skin.VirtualFlow ;
import com.sun.scenario.effect.Merge ;
import java.awt.BorderLayout ;
import static java.lang.Math.*;
import java.math.BigDecimal ;
import java.text.DecimalFormat ;
import java.util.Scanner ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.BitSet ;
import java.util.Collection ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.Deque ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Iterator ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Map ;
import java.util.Queue ;
import java.util.Set ;
import java.util.Stack ;
import java.util.TreeSet ;
import java.util.Vector ;
import java.util.concurrent.atomic.AtomicMarkableReference ;
import javafx.util.Pair ;
import java.util.Scanner ;
public class NewClass1 {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int times=Math.min(n,m);
    if(times % 2==0)System.out.println("Malvika");
    else System.out.println("Akshat");
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var times : int ; times := Set{n, m}->min() ;
    if (times mod 2 = 0) then     OclFile["System.out"].println("Malvika") else     OclFile["System.out"].println("Akshat") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Code_451A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int m=sc.nextInt();
    int n=sc.nextInt();
    int min=Math.min(m,n);
    if(min % 2==1)System.out.println("Akshat");
    else System.out.println("Malvika");
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code_451A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var min : int ; min := Set{m, n}->min() ;
    if (min mod 2 = 1) then     OclFile["System.out"].println("Akshat") else     OclFile["System.out"].println("Malvika") ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n-->0){
      float xa=sc.nextFloat();
      float ya=sc.nextFloat();
      float xb=sc.nextFloat();
      float yb=sc.nextFloat();
      float xc=sc.nextFloat();
      float yc=sc.nextFloat();
      float xd=sc.nextFloat();
      float yd=sc.nextFloat();
      float katamukiab=(yb-ya)/(xb-xa);
      float katamukicd=(yd-yc)/(xd-xc);
      if(katamukiab==katamukicd){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var xa : double ; xa := sc.nextFloat() ;
     var ya : double ; ya := sc.nextFloat() ;
    var xb : double ; xb := sc.nextFloat() ;
    var yb : double ; yb := sc.nextFloat() ;
    var xc : double ; xc := sc.nextFloat() ;
    var yc : double ; yc := sc.nextFloat() ;
    var xd : double ; xd := sc.nextFloat() ;
    var yd : double ; yd := sc.nextFloat() ;
    var katamukiab : double ; katamukiab := (yb - ya) / (xb - xa) ;
    var katamukicd : double ; katamukicd := (yd - yc) / (xd - xc) ;
    if (katamukiab = katamukicd) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CodeForces_GameWithSticks {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int min=Math.min(n,m);
    if(min % 2==0)System.out.println("Malvika");
    else System.out.println("Akshat");
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces_GameWithSticks {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var min : int ; min := Set{n, m}->min() ;
    if (min mod 2 = 0) then     OclFile["System.out"].println("Malvika") else     OclFile["System.out"].println("Akshat") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Id_11_Game_of_Sticks {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(Math.min(a,b)% 2==0)System.out.println("Malvika");
    else System.out.println("Akshat");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Id_11_Game_of_Sticks {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (Set{a, b}->min() mod 2 = 0) then     OclFile["System.out"].println("Malvika") ; else     OclFile["System.out"].println("Akshat") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void _printParenthesis(char str[],int pos,int n,int open,int close){
    if(close==n){
      for(int i=0 ; i<str.length ; i++)System.out.print(str[i]);
      System.out.println();
      return ;
    }
    else {
      if(open>close){
        str[pos]='}' ;
        _printParenthesis(str,pos+1,n,open,close+1);
      }
      if(open<n){
        str[pos]='{' ;
        _printParenthesis(str,pos+1,n,open+1,close);
      }
    }
  }
  static void printParenthesis(char str[],int n){
    if(n>0)_printParenthesis(str,0,n,0,0);
    return ;
  }
  public static void main(String[] args){
    int n=3 ;
    char[] str=new char[2*n];
    printParenthesis(str,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation _printParenthesis( str : Sequence(String), pos : int, n : int, open : int, close : int) : void
  pre: true
  post: true
  activity: (     if (close = n) then (         var i : int ; i := 0 ; while i < str->size() do (     OclFile["System.out"].print(str[i+1]) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ; 
     return ) else (     if (open > close) then (     str[pos+1] := '}' ; 
     execute _printParenthesis(str, pos + 1, n, open, close + 1) ) else skip ; 
     if (open < n) then (     str[pos+1] := '{' ; 
     execute _printParenthesis(str, pos + 1, n, open + 1, close) ) else skip ) );
  static   operation printParenthesis( str : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (     if (n > 0) then     execute _printParenthesis(str, 0, n, 0, 0) ; else skip ; 
     return );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var str : Sequence(String) ; str := Integer.subrange(1,2 * n)->collect(0) ;
     execute printParenthesis(str, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int longestSubarray(int a[],int n,int x){
    int count=0 ;
    int length=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]>x){
        count+=1 ;
      }
      else {
        length=Math.max(length,count);
        count=0 ;
      }
    }
    if(count>0)length=Math.max(length,count);
    return length ;
  }
  public static void main(String[] args){
    int[] a={
      8,25,10,19,19,18,20,11,18 };
      int n=a.length ;
      int k=13 ;
      System.out.println(longestSubarray(a,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation longestSubarray( a : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var length : int ; length := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] > x) then (     count := count+(1) ) else (     length := Set{length, count}->max() ; 
     count := 0 ) )  ;     i := i + 1 ) ; 
    if (count > 0) then     length := Set{length, count}->max() ; else skip ; 
    return length 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{8,25,10,19,19,18,20,11,18} ;
     var n : int ; n := a->size() ;
     var k : int ; k := 13 ;
     OclFile["System.out"].println(longestSubarray(a, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] a=new int[n];
    int min=Integer.MAX_VALUE ;
    int minIdx=0 ;
    int max=Integer.MIN_VALUE ;
    int maxIdx=0 ;
    for(int i=0 ; i<n ; i++){
      int x=in.nextInt();
      a[i]=x ;
      if(x<min){
        min=x ;
        minIdx=i ;
      }
      if(x>max){
        max=x ;
        maxIdx=i ;
      }
    }
    in.close();
    boolean plus=Math.abs(max)>=Math.abs(min);
    StringBuilder sb=new StringBuilder();
    String ls=System.lineSeparator();
    if(plus){
      for(int i=0 ; i<n ; i++){
        if(i==maxIdx)continue ;
        sb.append((maxIdx+1)+" "+(i+1)+ls);
      }
      for(int i=1 ; i<n ; i++){
        sb.append(i+" "+(i+1)+ls);
      }
    }
    else {
      for(int i=0 ; i<n ; i++){
        if(i==minIdx)continue ;
        sb.append((minIdx+1)+" "+(i+1)+ls);
      }
      for(int i=n-1 ; i>=1 ; i--){
        sb.append((i+1)+" "+i+ls);
      }
    }
    System.out.println(2*n-2);
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var min : int ; min := 2147483647 ;
    var minIdx : int ; minIdx := 0 ;
    var max : int ; max := -2147483648 ;
    var maxIdx : int ; maxIdx := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     a[i+1] := x ; 
     if (x < min) then (     min := x ; 
     minIdx := i ) else skip ; 
     if (x > max) then (     max := x ; 
     maxIdx := i ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    var plus : boolean ; plus := if max < 0 then -(max) else max endif >= if min < 0 then -(min) else min endif ;
    var sb : String ; sb := StringLib.newString() ;
    var ls : String ; ls := lineSeparator() ;
    if (plus) then (         var i : int ; i := 0 ; while i < n do ( (     if (i = maxIdx) then     continue else skip ; 
     sb := sb + StringLib.newString((maxIdx + 1) + " " + (i + 1) + ls) )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i < n do ( (     sb := sb + StringLib.newString(i + " " + (i + 1) + ls) )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < n do ( (     if (i = minIdx) then     continue else skip ; 
     sb := sb + StringLib.newString((minIdx + 1) + " " + (i + 1) + ls) )  ;     i := i + 1 ) ; 
         var i : int ; i := n - 1 ; while i >= 1 do ( (     sb := sb + StringLib.newString((i + 1) + " " + i + ls) )  ;     i := i - 1 ) ) ;  
    OclFile["System.out"].println(2 * n - 2) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isLucky(int n){
    boolean arr[]=new boolean[10];
    for(int i=0 ; i<10 ; i++)arr[i]=false ;
    while(n>0){
      int digit=n % 10 ;
      if(arr[digit])return false ;
      arr[digit]=true ;
      n=n/10 ;
    }
    return true ;
  }
  public static void main(String[] args){
    int arr[]={
      1291,897,4566,1232,80,700 };
      int n=arr.length ;
      for(int i=0 ; i<n ; i++)if(isLucky(arr[i]))System.out.print(arr[i]+" is Lucky \n");
      else System.out.print(arr[i]+" is not Lucky \n");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isLucky( n : int) : boolean
  pre: true
  post: true
  activity: (     var arr : Sequence(boolean) ; arr := Integer.subrange(1,10)->collect(false) ;
         var i : int ; i := 0 ; while i < 10 do (     arr[i+1] := false ;  ;     i := i + 1 ) ; 
     while (n > 0) do (     var digit : int ; digit := n mod 10 ;
     if (arr[digit+1]) then     return false else skip ; 
     arr[digit+1] := true ; 
     n := n / 10 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1291,897,4566,1232,80,700} ;
     var n : int ; n := arr->size() ;
         var i : int ; i := 0 ; while i < n do (     if (isLucky(arr[i+1])) then     OclFile["System.out"].print(arr[i+1] + " is Lucky \n") else     OclFile["System.out"].print(arr[i+1] + " is not Lucky \n") ; ;   ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] A=new int[N];
    int max=-1000001 ;
    int min=1000001 ;
    int maxi=0 ;
    int mini=0 ;
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
      max=Math.max(max,A[i]);
      min=Math.min(min,A[i]);
      if(max==A[i]){
        maxi=i+1 ;
      }
      if(min==A[i]){
        mini=i+1 ;
      }
    }
    if(min>=0){
      System.out.println(N-1);
      for(int i=1 ; i<=N-1 ; i++){
        System.out.println(i+" "+(int)(i+1));
      }
    }
    else {
      System.out.println(2*N-1);
      if(Math.abs(max)>=Math.abs(min)){
        for(int i=1 ; i<=N ; i++){
          System.out.println(maxi+" "+i);
        }
        for(int i=1 ; i<=N-1 ; i++){
          System.out.println(i+" "+(int)(i+1));
        }
      }
      else {
        for(int i=1 ; i<=N ; i++){
          System.out.println(mini+" "+i);
        }
        for(int i=N-1 ; i>=1 ; i--){
          System.out.println(i+1+" "+i);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var max : int ; max := -1000001 ;
    var min : int ; min := 1000001 ;
    var maxi : int ; maxi := 0 ;
    var mini : int ; mini := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() ; 
     max := Set{max, A[i+1]}->max() ; 
    min := Set{min, A[i+1]}->min() ; 
    if (max = A[i+1]) then (     maxi := i + 1 ) else skip ; 
    if (min = A[i+1]) then (     mini := i + 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (min >= 0) then (     OclFile["System.out"].println(N - 1) ; 
         var i : int ; i := 1 ; while i <= N - 1 do ( (     OclFile["System.out"].println(i + " " + (i + 1)->oclAsType(int)) )  ;     i := i + 1 ) ) else (     OclFile["System.out"].println(2 * N - 1) ; 
     if (if max < 0 then -(max) else max endif >= if min < 0 then -(min) else min endif) then (         var i : int ; i := 1 ; while i <= N do ( (     OclFile["System.out"].println(maxi + " " + i) )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i <= N - 1 do ( (     OclFile["System.out"].println(i + " " + (i + 1)->oclAsType(int)) )  ;     i := i + 1 ) ) else (         var i : int ; i := 1 ; while i <= N do ( (     OclFile["System.out"].println(mini + " " + i) )  ;     i := i + 1 ) ; 
         var i : int ; i := N - 1 ; while i >= 1 do ( (     OclFile["System.out"].println(i + 1 + " " + i) )  ;     i := i - 1 ) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    DNonDecreasing solver=new DNonDecreasing();
    solver.solve(1,in,out);
    out.close();
  }
  static class DNonDecreasing {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      out.println(2*n-1);
      int max=0 ;
      int index=0 ;
      for(int i=0 ; i<n ; i++){
        int a=in.nextInt();
        if(Math.abs(max)<Math.abs(a)){
          max=a ;
          index=i ;
        }
      }
      for(int i=0 ; i<n ; i++){
        out.print(index+1);
        out.print(' ');
        out.println(i+1);
      }
      if(max<0){
        for(int i=n ; i>1 ; i--){
          out.print(i);
          out.print(' ');
          out.println(i-1);
        }
      }
      else {
        for(int i=1 ; i<n ; i++){
          out.print(i);
          out.print(' ');
          out.println(i+1);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : DNonDecreasing ; solver := DNonDecreasing.newDNonDecreasing() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class DNonDecreasing {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     skip ; 
    var max : int ; max := 0 ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     if (if max < 0 then -(max) else max endif < if a < 0 then -(a) else a endif) then (     max := a ; 
     index := i ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     skip ; 
     skip ; 
     skip )  ;     i := i + 1 ) ; 
    if (max < 0) then (         var i : int ; i := n ; while i > 1 do ( (     skip ; 
     skip ; 
     skip )  ;     i := i - 1 ) ) else (         var i : int ; i := 1 ; while i < n do ( (     skip ; 
     skip ; 
     skip )  ;     i := i + 1 ) ) ;  
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.io.*;
import java.util.*;
class Main {
  static Scanner scanner=new Scanner();
  public static void main(String[] $){
    int n=scanner.nextInt();
    int max=0 ;
    int maxIndex=0 ;
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scanner.nextInt();
      if(Math.abs(max)<Math.abs(a[i])){
        max=a[i];
        maxIndex=i ;
      }
    }
    List<Point>ans=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      if(maxIndex!=i){
        ans.add(new Point(maxIndex+1,i+1));
      }
    }
    if(max==0){
      System.out.println(0);
      return ;
    }
    else if(max>0){
      for(int i=2 ; i<=n ; i++){
        ans.add(new Point(i-1,i));
      }
    }
    else {
      for(int i=n-1 ; i>0 ; i--){
        ans.add(new Point(i+1,i));
      }
    }
    System.out.println(ans.size());
    for(Point point : ans){
      System.out.println(point.x+" "+point.y);
    }
  }
  static class Scanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),1<<15);
    StringTokenizer tokenizer ;
    String next(){
      try {
        while(tokenizer==null || ! tokenizer.hasMoreTokens()){
          tokenizer=new StringTokenizer(reader.readLine());
        }
      }
      catch(IOException ignored){
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := (arguments ( ));
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var max : int ; max := 0 ;
    var maxIndex : int ; maxIndex := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() ; 
     if (if max < 0 then -(max) else max endif < if a[i+1] < 0 then -(a[i+1]) else a[i+1] endif) then (     max := a[i+1] ; 
     maxIndex := i ) else skip )  ;     i := i + 1 ) ; 
    var ans : Sequence(Point) ; ans := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (maxIndex /= i) then (     ans := ans->including(Point.newPoint(maxIndex + 1, i + 1)) ) else skip )  ;     i := i + 1 ) ; 
    if (max = 0) then (     OclFile["System.out"].println(0) ; 
     return ) else     if (max > 0) then (         var i : int ; i := 2 ; while i <= n do ( (     ans := ans->including(Point.newPoint(i - 1, i)) )  ;     i := i + 1 ) ) else (         var i : int ; i := n - 1 ; while i > 0 do ( (     ans := ans->including(Point.newPoint(i + 1, i)) )  ;     i := i - 1 ) ) ;  ;  
    OclFile["System.out"].println(ans->size()) ; 
    for (point : ans) do ( (     OclFile["System.out"].println(point.x + " " + point.y) )  ) ; 
 );
  static class Scanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (1*(2->pow(15)))->oclAsType(long));
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (ignored : IOException) do skip
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] a=new int[N];
    for(int i=0 ; i<a.length ; ++i){
      a[i]=sc.nextInt();
    }
    System.out.println(solve(a));
    sc.close();
  }
  static String solve(int[] a){
    int minIndex=0 ;
    int maxIndex=0 ;
    for(int i=1 ; i<a.length ; ++i){
      if(a[i]<a[minIndex]){
        minIndex=i ;
      }
      if(a[i]>a[maxIndex]){
        maxIndex=i ;
      }
    }
    List<String>operations=new ArrayList<>();
    if(a[minIndex]+a[maxIndex]>=0){
      for(int i=0 ; i<a.length ; ++i){
        operations.add(String.format("%d %d",maxIndex+1,i+1));
      }
      for(int i=0 ; i<a.length-1 ; ++i){
        operations.add(String.format("%d %d",i+1,i+2));
      }
    }
    else {
      for(int i=0 ; i<a.length ; ++i){
        operations.add(String.format("%d %d",minIndex+1,i+1));
      }
      for(int i=a.length-1 ; i>=1 ; --i){
        operations.add(String.format("%d %d",i+1,i));
      }
    }
    return String.format("%d\n%s",operations.size(),String.join("\n",operations));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(a)) ; 
    skip ; 
 );
  static   operation solve( a : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var minIndex : int ; minIndex := 0 ;
     var maxIndex : int ; maxIndex := 0 ;
        var i : int ; i := 1 ; while i < a->size() do ( (     if (a[i+1] < a[minIndex+1]) then (     minIndex := i ) else skip ; 
     if (a[i+1] > a[maxIndex+1]) then (     maxIndex := i ) else skip )  ;     i := i + 1 ) ; 
    var operations : Sequence(String) ; operations := Sequence{} ;
    if (a[minIndex+1] + a[maxIndex+1] >= 0) then (         var i : int ; i := 0 ; while i < a->size() do ( (     operations := operations->including(StringLib.format("%d %d",Sequence{maxIndex + 1,i + 1})) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < a->size() - 1 do ( (     operations := operations->including(StringLib.format("%d %d",Sequence{i + 1,i + 2})) )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < a->size() do ( (     operations := operations->including(StringLib.format("%d %d",Sequence{minIndex + 1,i + 1})) )  ;     i := i + 1 ) ; 
         var i : int ; i := a->size() - 1 ; while i >= 1 do ( (     operations := operations->including(StringLib.format("%d %d",Sequence{i + 1,i})) )  ;     i := i - 1 ) ) ;  
    return StringLib.format("%d\n%s",Sequence{operations->size(),join("\n", operations)}) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.function.IntPredicate ;
import org.omg.CORBA.Current ;
import static java.lang.Math.abs ;
import java.math.BigInteger ;
public class omar {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int size=input.nextInt();
    int min=0,max=0 ;
    int[] arr=new int[size];
    for(int i=0 ; i<size ; i++){
      arr[i]=input.nextInt();
    }
    for(int i=0 ; i<size ; i++){
      if(i==0){
        min=abs(arr[i]-arr[i+1]);
        max=abs(arr[i]-arr[size-1]);
      }
      else if(i==size-1){
        min=abs(arr[i]-arr[i-1]);
        max=abs(arr[i]-arr[0]);
      }
      else if(i!=0 && i!=size-1){
        min=Math.min(abs(arr[i]-arr[i-1]),abs(arr[i]-arr[i+1]));
        max=Math.max(abs(arr[i]-arr[size-1]),abs(arr[i]-arr[0]));
      }
      System.out.println(min+" "+max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class omar {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var size : int ; size := input.getCurrent()->toInteger() ;
    var min : int ; min := 0 ;
    var max : int ; max := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < size do ( (     arr[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < size do ( (     if (i = 0) then (     min := abs(arr[i+1] - arr[i + 1+1]) ; 
     max := abs(arr[i+1] - arr[size - 1+1]) ) else     if (i = size - 1) then (     min := abs(arr[i+1] - arr[i - 1+1]) ; 
     max := abs(arr[i+1] - arr[0+1]) ) else     if (i /= 0 & i /= size - 1) then (     min := Set{abs(arr[i+1] - arr[i - 1+1]), abs(arr[i+1] - arr[i + 1+1])}->min() ; 
     max := Set{abs(arr[i+1] - arr[size - 1+1]), abs(arr[i+1] - arr[0+1])}->max() ) else skip ; ;  ;  
     OclFile["System.out"].println(min + " " + max) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Node root ;
  public void run(){
    Scanner sc=new Scanner(System.in);
    int m=sc.nextInt();
    for(int i=0 ; i<m ; i++){
      String str=sc.next();
      if(str.startsWith("i")){
        insert(sc.nextInt());
      }
      else {
        inorder(root);
        System.out.println();
        preorder(root);
        System.out.println();
      }
    }
    sc.close();
  }
  public void insert(int v){
    Node x=root ;
    Node y=null ;
    Node z=new Node(v);
    while(x!=null){
      y=x ;
      if(z.id<x.id){
        x=x.left ;
      }
      else {
        x=x.right ;
      }
    }
    if(y==null){
      root=z ;
    }
    else if(z.id<y.id){
      y.left=z ;
    }
    else {
      y.right=z ;
    }
  }
  public void inorder(Node tree){
    if(tree==null){
      return ;
    }
    inorder(tree.left);
    System.out.print(" "+tree.id);
    inorder(tree.right);
  }
  public void preorder(Node tree){
    if(tree==null){
      return ;
    }
    System.out.print(" "+tree.id);
    preorder(tree.left);
    preorder(tree.right);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
class Node {
  int id ;
  Node left ;
  Node right ;
  Node(int id){
    this.id=id ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute root : Node;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < m do ( (     var str : String ; str := sc.getCurrent() ;
     if (str->hasPrefix("i")) then (     execute insert(sc.getCurrent()->toInteger()) ) else (     execute inorder(root) ; 
     OclFile["System.out"].println() ; 
     execute preorder(root) ; 
     OclFile["System.out"].println() ) )  ;     i := i + 1 ) ; 
     skip );
   operation insert( v : int) : void
  pre: true
  post: true
  activity: (     var x : Node ; x := root ;
     var y : Node ; y := null ;
    var z : Node ; z := Node.newNode(v) ;
    while (x /= null) do (     y := x ; 
     if (z.id < x.id) then (     x := x.left ) else (     x := x.right ) ) ; 
    if (y = null) then (     root := z ) else     if (z.id < y.id) then (     y.left := z ) else (     y.right := z ) ;  ;  
 );
   operation inorder( tree : Node) : void
  pre: true
  post: true
  activity: (     if (tree = null) then (     return ) else skip ; 
     execute inorder(tree.left) ; 
     OclFile["System.out"].print(" " + tree.id) ; 
     execute inorder(tree.right) );
   operation preorder( tree : Node) : void
  pre: true
  post: true
  activity: (     if (tree = null) then (     return ) else skip ; 
     OclFile["System.out"].print(" " + tree.id) ; 
     execute preorder(tree.left) ; 
     execute preorder(tree.right) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}
class Node {
   attribute id : int;
   attribute left : Node;
   attribute right : Node;
   static operation newNode( id : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(id);
    return self );
  operation initialise( id : int) : void
  pre: true  post: true
  activity: (     self.id := id );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.List ;
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
class Node {
  int id ;
  Node left ;
  Node right ;
}
class Main {
  static Node root ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      String command=sc.next();
      if(command.charAt(0)=='i'){
        int id=sc.nextInt();
        insert(id);
      }
      else if(command.charAt(0)=='p'){
        System.out.println(inParse(root));
        System.out.println(preParse(root));
      }
    }
  }
  public static void insert(int id){
    Node insertedNode=new Node();
    insertedNode.id=id ;
    if(root==null){
      root=insertedNode ;
      return ;
    }
    Node node=root ;
    while(true){
      if(id<node.id){
        if(node.left==null){
          node.left=insertedNode ;
          return ;
        }
        node=node.left ;
      }
      else {
        if(node.right==null){
          node.right=insertedNode ;
          return ;
        }
        node=node.right ;
      }
    }
  }
  public static String preParse(Node node){
    if(node==null){
      return "" ;
    }
    return " "+node.id+preParse(node.left)+preParse(node.right);
  }
  public static String inParse(Node node){
    if(node==null){
      return "" ;
    }
    return inParse(node.left)+" "+node.id+inParse(node.right);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Node {
   attribute id : int;
   attribute left : Node;
   attribute right : Node;
}
class Main {
  static   attribute root : Node;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var command : String ; command := sc.getCurrent() ;
     if (command->at(0+1) = 'i') then (     var id : int ; id := sc.getCurrent()->toInteger() ;
     execute insert(id) ) else     if (command->at(0+1) = 'p') then (     OclFile["System.out"].println(inParse(root)) ; 
     OclFile["System.out"].println(preParse(root)) ) else skip ; )  ;     i := i + 1 ) );
  static   operation insert( id : int) : void
  pre: true
  post: true
  activity: (     var insertedNode : Node ; insertedNode := Node.newNode() ;
     insertedNode.id := id ; 
    if (root = null) then (     root := insertedNode ; 
     return ) else skip ; 
    var node : Node ; node := root ;
    while (true) do (     if (id < node.id) then (     if (node.left = null) then (     node.left := insertedNode ; 
     return ) else skip ; 
     node := node.left ) else (     if (node.right = null) then (     node.right := insertedNode ; 
     return ) else skip ; 
     node := node.right ) ) ; 
 );
  static   operation preParse( node : Node) : String
  pre: true
  post: true
  activity: (     if (node = null) then (     return "" ) else skip ; 
     return " " + node.id + preParse(node.left) + preParse(node.right) );
  static   operation inParse( node : Node) : String
  pre: true
  post: true
  activity: (     if (node = null) then (     return "" ) else skip ; 
     return inParse(node.left) + " " + node.id + inParse(node.right) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Node {
  Integer data ;
  Node left ;
  Node right ;
  Node(Integer data){
    left=null ;
    right=null ;
    this.data=data ;
  }
}
public class Main {
  Scanner sc=new Scanner(System.in);
  private static Node root ;
  int m ;
  String order ;
  int[] T ;
  public Main(){
    root=null ;
  }
  public Node insert(Integer key){
    Node p=root ;
    Node parent=null ;
    boolean isLeftChild=false ;
    while(p!=null){
      int result=key.compareTo(p.data);
      if(result==0){
        return null ;
      }
      else if(result<0){
        parent=p ;
        isLeftChild=true ;
        p=p.left ;
      }
      else {
        parent=p ;
        isLeftChild=false ;
        p=p.right ;
      }
    }
    Node newNode=new Node(key);
    if(parent==null){
      root=newNode ;
    }
    else if(isLeftChild){
      parent.left=newNode ;
    }
    else {
      parent.right=newNode ;
    }
    return newNode ;
  }
  public void input(){
    m=sc.nextInt();
    T=new int[m];
    for(int i=0 ; i<m ; i++){
      order=sc.next();
      if(order.equals("print")){
        inorder(root);
        System.out.println();
        preorder(root);
        System.out.println();
      }
      else {
        T[i]=sc.nextInt();
        insert(T[i]);
      }
    }
  }
  public void inorder(Node p){
    if(p==null){
      return ;
    }
    else {
      inorder(p.left);
      System.out.print(" "+p.data);
      inorder(p.right);
    }
  }
  public void preorder(Node p){
    if(p==null){
      return ;
    }
    else {
      System.out.print(" "+p.data);
      preorder(p.left);
      preorder(p.right);
    }
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.input();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Node {
   attribute data : int;
   attribute left : Node;
   attribute right : Node;
   static operation newNode( data : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(data);
    return self );
  operation initialise( data : int) : void
  pre: true  post: true
  activity: (     left := null ; 
     right := null ; 
     self.data := data );
}
class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute root : Node;
   attribute m : int;
   attribute order : String;
   attribute T : Sequence(int);
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     root := null );
   operation insert( key : int) : Node
  pre: true
  post: true
  activity: (     var p : Node ; p := root ;
     var parent : Node ; parent := null ;
    var isLeftChild : boolean ; isLeftChild := false ;
    while (p /= null) do (     var result : int ; result := key->compareTo(p.data) ;
     if (result = 0) then (     return null ) else     if (result < 0) then (     parent := p ; 
     isLeftChild := true ; 
     p := p.left ) else (     parent := p ; 
     isLeftChild := false ; 
     p := p.right ) ;  ) ; 
    var newNode : Node ; newNode := Node.newNode(key) ;
    if (parent = null) then (     root := newNode ) else     if (isLeftChild) then (     parent.left := newNode ) else (     parent.right := newNode ) ;  ;  
    return newNode 
 );
   operation input() : void
  pre: true
  post: true
  activity: (     m := sc.getCurrent()->toInteger() ; 
     T := Integer.subrange(1,m)->collect(0) ; 
         var i : int ; i := 0 ; while i < m do ( (     order := sc.getCurrent() ; 
     if (order = "print") then (     execute inorder(root) ; 
     OclFile["System.out"].println() ; 
     execute preorder(root) ; 
     OclFile["System.out"].println() ) else (     T[i+1] := sc.getCurrent()->toInteger() ; 
     execute insert(T[i+1]) ) )  ;     i := i + 1 ) );
   operation inorder( p : Node) : void
  pre: true
  post: true
  activity: (     if (p = null) then (     return ) else (     execute inorder(p.left) ; 
     OclFile["System.out"].print(" " + p.data) ; 
     execute inorder(p.right) ) );
   operation preorder( p : Node) : void
  pre: true
  post: true
  activity: (     if (p = null) then (     return ) else (     OclFile["System.out"].print(" " + p.data) ; 
     execute preorder(p.left) ; 
     execute preorder(p.right) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.input() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static void possibleOrNot(long a1,long a2,long b1,long b2,long c1,long c2){
    long dis1=(long)Math.pow(b1-a1,2)+(long)Math.pow(b2-a2,2);
    long dis2=(long)Math.pow(c1-b1,2)+(long)Math.pow(c2-b2,2);
    if(dis1!=dis2)System.out.print("No");
    else if(b1==((a1+c1)/2.0)&& b2==((a2+c2)/2.0))System.out.print("No");
    else System.out.print("Yes");
  }
  public static void main(String[] args){
    long a1=1,a2=0,b1=2,b2=0,c1=3,c2=0 ;
    possibleOrNot(a1,a2,b1,b2,c1,c2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation possibleOrNot( a1 : long, a2 : long, b1 : long, b2 : long, c1 : long, c2 : long) : void
  pre: true
  post: true
  activity: (     var dis1 : long ; dis1 := b1 - a1->pow(2)->oclAsType(long) + b2 - a2->pow(2)->oclAsType(long) ;
     var dis2 : long ; dis2 := c1 - b1->pow(2)->oclAsType(long) + c2 - b2->pow(2)->oclAsType(long) ;
     if (dis1 /= dis2) then     OclFile["System.out"].print("No") ; else     if (b1 = ((a1 + c1) / 2.0) & b2 = ((a2 + c2) / 2.0)) then     OclFile["System.out"].print("No") else     OclFile["System.out"].print("Yes") ; ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a1 : long ; a1 := 1 ;
    var a2 : long ; a2 := 0 ;
    var b1 : long ; b1 := 2 ;
    var b2 : long ; b2 := 0 ;
    var c1 : long ; c1 := 3 ;
    var c2 : long ; c2 := 0 ;
     execute possibleOrNot(a1, a2, b1, b2, c1, c2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    if(A+B+C<=21){
      System.out.println("win");
    }
    else {
      System.out.println("bust");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    if (A + B + C <= 21) then (     OclFile["System.out"].println("win") ) else (     OclFile["System.out"].println("bust") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getRightMostSetBit(int n){
    return(int)((Math.log(n &-n))/(Math.log(2)))+1 ;
  }
  static int posOfRightMostSameBit(int m,int n){
    return getRightMostSetBit(~(m ^ n));
  }
  public static void main(String[] args){
    int m=16,n=7 ;
    System.out.print("Position="+posOfRightMostSameBit(m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getRightMostSetBit( n : int) : int
  pre: true
  post: true
  activity: (     return (((n & -n)->log()) / ((2)->log()))->oclAsType(int) + 1 );
  static   operation posOfRightMostSameBit( m : int, n : int) : int
  pre: true
  post: true
  activity: (     return getRightMostSetBit(-((m xor n) + 1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 16 ;
    var n : int ; n := 7 ;
     OclFile["System.out"].print("Position=" + posOfRightMostSameBit(m, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float Calculate_GST(float org_cost,float N_price){
    return(((N_price-org_cost)*100)/org_cost);
  }
  public static void main(String[] args){
    float org_cost=100 ;
    float N_price=120 ;
    System.out.print(" GST="+Calculate_GST(org_cost,N_price)+"%");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Calculate_GST( org_cost : double, N_price : double) : double
  pre: true
  post: true
  activity: (     return (((N_price - org_cost) * 100) / org_cost) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var org_cost : double ; org_cost := 100 ;
     var N_price : double ; N_price := 120 ;
     OclFile["System.out"].print(" GST=" + Calculate_GST(org_cost, N_price) + "%") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printInSortedOrder(String arr[],int n){
    int index[]=new int[n];
    int i,j,min ;
    for(i=0 ; i<n ; i++){
      index[i]=i ;
    }
    for(i=0 ; i<n-1 ; i++){
      min=i ;
      for(j=i+1 ; j<n ; j++){
        if(arr[index[min] ] .compareTo(arr[index[j] ])>0){
          min=j ;
        }
      }
      if(min!=i){
        int temp=index[min];
        index[min]=index[i];
        index[i]=temp ;
      }
    }
    for(i=0 ; i<n ; i++){
      System.out.print(arr[index[i] ]+" ");
    }
  }
  static public void main(String[] args){
    String arr[]={
      "geeks","quiz","geeks","for" };
      int n=4 ;
      printInSortedOrder(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printInSortedOrder( arr : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (     var index : Sequence(int) ; index := Integer.subrange(1,n)->collect(0) ;
     var i : int ;
    var j : int ;
    var min : int ;
        i := 0 ; while i < n do ( (     index[i+1] := i )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n - 1 do ( (     min := i ; 
         j := i + 1 ; while j < n do ( (     if (arr[index[min+1]+1]->compareTo(arr[index[j+1]+1]) > 0) then (     min := j ) else skip )  ;     j := j + 1 ) ; 
     if (min /= i) then (     var temp : int ; temp := index[min+1] ;
     index[min+1] := index[i+1] ; 
     index[i+1] := temp ) else skip )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[index[i+1]+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"geeks","quiz","geeks","for"} ;
     var n : int ; n := 4 ;
     execute printInSortedOrder(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    int n=Integer.parseInt(reader.readLine());
    for(int i=0 ; i<n ; i++){
      String line=reader.readLine();
      String[] values=line.split(" ");
      double x1=Double.parseDouble(values[0]);
      double y1=Double.parseDouble(values[1]);
      double x2=Double.parseDouble(values[2]);
      double y2=Double.parseDouble(values[3]);
      double x3=Double.parseDouble(values[4]);
      double y3=Double.parseDouble(values[5]);
      double x4=Double.parseDouble(values[6]);
      double y4=Double.parseDouble(values[7]);
      double det=(x2-x1)*(y4-y3)-(y2-y1)*(x4-x3);
      out.println(det==0.0 ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     var n : int ; n := (reader.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var line : String ; line := reader.readLine() ;
     var values : Sequence(String) ; values := line->split(" ") ;
    var x1 : double ; x1 := (values[0+1])->toReal() ;
    var y1 : double ; y1 := (values[1+1])->toReal() ;
    var x2 : double ; x2 := (values[2+1])->toReal() ;
    var y2 : double ; y2 := (values[3+1])->toReal() ;
    var x3 : double ; x3 := (values[4+1])->toReal() ;
    var y3 : double ; y3 := (values[5+1])->toReal() ;
    var x4 : double ; x4 := (values[6+1])->toReal() ;
    var y4 : double ; y4 := (values[7+1])->toReal() ;
    var det : double ; det := (x2 - x1) * (y4 - y3) - (y2 - y1) * (x4 - x3) ;
    out.println(if det = 0.0 then "YES" else "NO" endif) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    out=new PrintWriter(new BufferedOutputStream(System.out));
    int n=sc.nextInt();
    long t=sc.nextInt();
    long[] h=new long[n];
    for(int i=0 ; i<n ; ++i)h[i]=sc.nextInt();
    long[] ans=new long[n];
    long m=0 ;
    long r=t ;
    for(int i=0 ; i<n ; ++i){
      m=Math.max(m,h[i]);
      ans[i]=r>=0 ? r/m+1 : 1 ;
      if(r>=0 && r % m>=h[i])ans[i]++;
      r-=h[i];
    }
    for(long a : ans)out.println(a);
    out.close();
  }
  public static PrintWriter out ;
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var n : int ; n := sc.nextInt() ;
    var t : long ; t := sc.nextInt() ;
    var h : Sequence(long) ; h := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     h[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
    var ans : Sequence(long) ; ans := Integer.subrange(1,n)->collect(0) ;
    var m : long ; m := 0 ;
    var r : long ; r := t ;
        var i : int ; i := 0 ; while i < n do ( (     m := Set{m, h[i+1]}->max() ; 
     ans[i+1] := if r >= 0 then r / m + 1 else 1 endif ; 
     if (r >= 0 & r mod m >= h[i+1]) then     ans[i+1] := ans[i+1] + 1 ; else skip ; 
     r := r-(h[i+1]) )  ;     i := i + 1 ) ; 
    for (a : ans) do (     out.println(a) ;  ) ; 
    out.close() ; 
 );
  static   attribute out : OclFile;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1660_VasyaandCoins {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int yaki=input.nextInt();
      int doyii=input.nextInt();
      input.nextLine();
      int scale=yaki+doyii*2 ;
      if(yaki==0 && scale % 2==0){
        System.out.println(1);
      }
      else {
        System.out.println(scale+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1660_VasyaandCoins {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var yaki : int ; yaki := input.getCurrent()->toInteger() ;
     var doyii : int ; doyii := input.getCurrent()->toInteger() ;
    skip ; 
    var scale : int ; scale := yaki + doyii * 2 ;
    if (yaki = 0 & scale mod 2 = 0) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(scale + 1) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class VasayaAndCoin {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int a=sc.nextInt();
      int b=sc.nextInt();
      b*=2 ;
      if(a==0){
        System.out.println(1);
      }
      else {
        int c=(b+a)+1 ;
        System.out.println(c);
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class VasayaAndCoin {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    b := b*(2) ; 
    if (a = 0) then (     OclFile["System.out"].println(1) ) else (     var c : int ; c := (b + a) + 1 ;
     OclFile["System.out"].println(c) ) ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      if(a==0){
        System.out.println(1);
      }
      else {
        System.out.println(a+b*2+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (a = 0) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(a + b * 2 + 1) ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    MyScanner scanner=new MyScanner();
    int numOfTests=scanner.nextInt();
    for(int i=1 ; i<=numOfTests ; i++){
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      if(a==0){
        out.println("1");
      }
      else {
        out.println(a+2*b+1);
      }
    }
    out.close();
  }
  private static void printResult(int caseIdx,boolean res){
    out.println("Case #"+caseIdx+": "+(res ? "YES" : "NO"));
  }
  public static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : MyScanner ; scanner := MyScanner.newMyScanner() ;
     var numOfTests : int ; numOfTests := scanner.nextInt() ;
         var i : int ; i := 1 ; while i <= numOfTests do ( (     var a : int ; a := scanner.nextInt() ;
     var b : int ; b := scanner.nextInt() ;
     if (a = 0) then (     out.println("1") ) else (     out.println(a + 2 * b + 1) ) )  ;     i := i + 1 ) ; 
     out.close() );
  static   operation printResult( caseIdx : int, res : boolean) : void
  pre: true
  post: true
  activity: (     out.println("Case #" + caseIdx + ": " + (if res then "YES" else "NO" endif)) );
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test183 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int a=in.nextInt();
      int b=in.nextInt();
      if(a==0){
        System.out.println("1");
      }
      else {
        System.out.println(a+(2*b)+1);
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test183 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
     if (a = 0) then (     OclFile["System.out"].println("1") ) else (     OclFile["System.out"].println(a + (2 * b) + 1) ) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void equation_plane(int x1,int y1,int z1,int x2,int y2,int z2,int x3,int y3,int z3,int x,int y,int z){
    int a1=x2-x1 ;
    int b1=y2-y1 ;
    int c1=z2-z1 ;
    int a2=x3-x1 ;
    int b2=y3-y1 ;
    int c2=z3-z1 ;
    int a=b1*c2-b2*c1 ;
    int b=a2*c1-a1*c2 ;
    int c=a1*b2-b1*a2 ;
    int d=(-a*x1-b*y1-c*z1);
    if(a*x+b*y+c*z+d==0)System.out.println("Coplanar");
    else System.out.println("Not Coplanar");
  }
  public static void main(String[] args){
    int x1=3 ;
    int y1=2 ;
    int z1=-5 ;
    int x2=-1 ;
    int y2=4 ;
    int z2=-3 ;
    int x3=-3 ;
    int y3=8 ;
    int z3=-5 ;
    int x4=-3 ;
    int y4=2 ;
    int z4=1 ;
    equation_plane(x1,y1,z1,x2,y2,z2,x3,y3,z3,x4,y4,z4);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation equation_plane( x1 : int, y1 : int, z1 : int, x2 : int, y2 : int, z2 : int, x3 : int, y3 : int, z3 : int, x : int, y : int, z : int) : void
  pre: true
  post: true
  activity: (     var a1 : int ; a1 := x2 - x1 ;
     var b1 : int ; b1 := y2 - y1 ;
    var c1 : int ; c1 := z2 - z1 ;
    var a2 : int ; a2 := x3 - x1 ;
    var b2 : int ; b2 := y3 - y1 ;
    var c2 : int ; c2 := z3 - z1 ;
    var a : int ; a := b1 * c2 - b2 * c1 ;
    var b : int ; b := a2 * c1 - a1 * c2 ;
    var c : int ; c := a1 * b2 - b1 * a2 ;
    var d : int ; d := (-a * x1 - b * y1 - c * z1) ;
    if (a * x + b * y + c * z + d = 0) then     OclFile["System.out"].println("Coplanar") else     OclFile["System.out"].println("Not Coplanar") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x1 : int ; x1 := 3 ;
     var y1 : int ; y1 := 2 ;
    var z1 : int ; z1 := -5 ;
    var x2 : int ; x2 := -1 ;
    var y2 : int ; y2 := 4 ;
    var z2 : int ; z2 := -3 ;
    var x3 : int ; x3 := -3 ;
    var y3 : int ; y3 := 8 ;
    var z3 : int ; z3 := -5 ;
    var x4 : int ; x4 := -3 ;
    var y4 : int ; y4 := 2 ;
    var z4 : int ; z4 := 1 ;
    execute equation_plane(x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
class Main {
  static Map<Integer,Integer>monthDay=null ;
  static String[] dayOfTheWeek={
    "Wednesday","Thursday","Friday","Saturday","Sunday","Monday","Tuesday" };
    public static void main(String[] args){
      Scanner sc=null ;
      try {
        sc=new Scanner(System.in);
        while(sc.hasNextInt()){
          int month=sc.nextInt();
          int day=sc.nextInt();
          if(month==0 || day==0){
            break ;
          }
          if(monthDay==null){
            createMonth();
          }
          System.out.println(getDayOfTheWeek(month,day,monthDay));
        }
      }
      finally {
        sc.close();
      }
    }
    public static String getDayOfTheWeek(int m,int d,Map<Integer,Integer>map){
      int sum=0 ;
      for(int i=1 ; i<m ; i++){
        sum+=map.get(i);
      }
      sum+=d ;
      return dayOfTheWeek[sum % 7];
    }
    public static Map<Integer,Integer>createMonth(){
      monthDay=new HashMap<Integer,Integer>();
      monthDay.put(1,31);
      monthDay.put(2,29);
      monthDay.put(3,31);
      monthDay.put(4,30);
      monthDay.put(5,31);
      monthDay.put(6,30);
      monthDay.put(7,31);
      monthDay.put(8,31);
      monthDay.put(9,30);
      monthDay.put(10,31);
      monthDay.put(11,30);
      monthDay.put(12,31);
      return monthDay ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute monthDay : Map(int,int) := null;
  static   attribute dayOfTheWeek : Sequence(String) := Sequence{"Wednesday","Thursday","Friday","Saturday","Sunday","Monday","Tuesday"};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := null ;
     try (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     while (sc.hasNextInt()) do (     var month : int ; month := sc.getCurrent()->toInteger() ;
     var day : int ; day := sc.getCurrent()->toInteger() ;
    if (month = 0 or day = 0) then (     break ) else skip ; 
    if (monthDay = null) then (     execute createMonth() ) else skip ; 
    OclFile["System.out"].println(getDayOfTheWeek(month, day, monthDay)) ; 
 ) )   finally (     skip )
 );
  static   operation getDayOfTheWeek( m : int, d : int, map : Map(int,int)) : String
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i < m do ( (     sum := sum+(map->at(i+1)) )  ;     i := i + 1 ) ; 
     sum := sum+(d) ; 
     return dayOfTheWeek[sum mod 7+1] );
  static   operation createMonth() : Map(int,int)
  pre: true
  post: true
  activity: (     monthDay := Map{} ; 
     monthDay := monthDay->union(Map{1 |-> 31}) ; 
    monthDay := monthDay->union(Map{2 |-> 29}) ; 
    monthDay := monthDay->union(Map{3 |-> 31}) ; 
    monthDay := monthDay->union(Map{4 |-> 30}) ; 
    monthDay := monthDay->union(Map{5 |-> 31}) ; 
    monthDay := monthDay->union(Map{6 |-> 30}) ; 
    monthDay := monthDay->union(Map{7 |-> 31}) ; 
    monthDay := monthDay->union(Map{8 |-> 31}) ; 
    monthDay := monthDay->union(Map{9 |-> 30}) ; 
    monthDay := monthDay->union(Map{10 |-> 31}) ; 
    monthDay := monthDay->union(Map{11 |-> 30}) ; 
    monthDay := monthDay->union(Map{12 |-> 31}) ; 
    return monthDay 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static final int MAX=20 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final int N=sc.nextInt();
    int[] array=new int[N];
    for(int i=0 ; i<N ; i++){
      array[i]=sc.nextInt();
    }
    long[][] DP=new long[N][MAX+1];
    DP[0][array[0] ]=1L ;
    for(int i=0 ; i<N-1 ; i++){
      for(int number=0 ; number<=MAX ; number++){
        if(DP[i][number]>0){
          if(number+array[i+1]<=20){
            DP[i+1][number+array[i+1] ]+=DP[i][number];
          }
          if(number-array[i+1]>=0){
            DP[i+1][number-array[i+1] ]+=DP[i][number];
          }
        }
      }
    }
    System.out.println(DP[N-2][array[N-1] ]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 20;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     array[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var DP : Sequence(Sequence(long)) ; DP := Integer.subrange(1,N)->collect(Integer.subrange(1,MAX + 1)->collect(0)) ;
    DP[0+1][array[0+1]+1] := 1L ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (         var number : int ; number := 0 ; while number <= MAX do ( (     if (DP[i+1][number+1] > 0) then (     if (number + array[i + 1+1] <= 20) then (     DP[i + 1+1][number + array[i + 1+1]+1] := DP[i + 1+1][number + array[i + 1+1]+1]+(DP[i+1][number+1]) ) else skip ; 
     if (number - array[i + 1+1] >= 0) then (     DP[i + 1+1][number - array[i + 1+1]+1] := DP[i + 1+1][number - array[i + 1+1]+1]+(DP[i+1][number+1]) ) else skip ) else skip )  ;     number := number + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(DP[N - 2+1][array[N - 1+1]+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] as=br.readLine().split(" ");
    int a1=Integer.parseInt(as[0]);
    int a2=Integer.parseInt(as[1]);
    int a3=Integer.parseInt(as[2]);
    System.out.println(problem147a(a1,a2,a3));
  }
  private static String problem147a(int a1,int a2,int a3){
    return((a1+a2+a3)>=22)? "bust" : "win" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var as : Sequence(String) ; as := br.readLine()->split(" ") ;
    var a1 : int ; a1 := (as[0+1])->toInteger() ;
    var a2 : int ; a2 := (as[1+1])->toInteger() ;
    var a3 : int ; a3 := (as[2+1])->toInteger() ;
    OclFile["System.out"].println(problem147a(a1, a2, a3)) ; 
 );
  static   operation problem147a( a1 : int, a2 : int, a3 : int) : String
  pre: true
  post: true
  activity: (     return if ((a1 + a2 + a3) >= 22) then "bust" else "win" endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    try {
      System.setIn(new FileInputStream("src/aoj0021/aoj0021.in"));
      System.setOut(new PrintStream(new FileOutputStream("src/aoj0021/result.txt")));
    }
    catch(FileNotFoundException e){
    }
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    for(int N=sc.nextInt(); N>0 ; N--){
      P a=new P(sc.nextDouble(),sc.nextDouble());
      P b=new P(sc.nextDouble(),sc.nextDouble());
      P c=new P(sc.nextDouble(),sc.nextDouble());
      P d=new P(sc.nextDouble(),sc.nextDouble());
      boolean parallel=abs(b.sub(a).cross(c.sub(d)))<EPS ;
      System.out.println(parallel ? "YES" : "NO");
    }
  }
  double EPS=1e-8 ;
  class P implements Comparable<P>{
    double x,y ;
    P(double x,double y){
      this.x=x ;
      this.y=y ;
    }
    P sub(P p){
      return new P(x-p.x,y-p.y);
    }
    double dot(P p){
      return x*p.x+y*p.y ;
    }
    double cross(P p){
      return x*p.y-y*p.x ;
    }
    double abs(){
      return hypot(x,y);
    }
    public int compareTo(P o){
      if(x!=o.x)return Double.compare(x,o.x);
      return Double.compare(y,o.y);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("src/aoj0021/aoj0021.in"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("src/aoj0021/result.txt")))) )   catch (e : FileNotFoundException) do skip
     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var N : int ; N := sc.getCurrent()->toInteger() ; while N > 0 do ( (     var a : P ; a := P.newP(sc.getCurrent()->toReal(), sc.getCurrent()->toReal()) ;
     var b : P ; b := P.newP(sc.getCurrent()->toReal(), sc.getCurrent()->toReal()) ;
    var c : P ; c := P.newP(sc.getCurrent()->toReal(), sc.getCurrent()->toReal()) ;
    var d : P ; d := P.newP(sc.getCurrent()->toReal(), sc.getCurrent()->toReal()) ;
    var parallel : boolean ; parallel := abs(b.sub(a).cross(c.sub(d))) < EPS ;
    OclFile["System.out"].println(if parallel then "YES" else "NO" endif) ; 
 )  ;     N := N - 1 ) );
   attribute EPS : double := 1e-8;
 class P implements Comparable<P> {
   attribute x : double;
   static operation newP( x : double, y : double) : P
  pre: true
  post: true
  activity:
  ( var self : P ;
    self := createP();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation sub( p : P) : P
  pre: true
  post: true
  activity: (     return P.newP(x - p.x, y - p.y) );
   operation dot( p : P) : double
  pre: true
  post: true
  activity: (     return x * p.x + y * p.y );
   operation cross( p : P) : double
  pre: true
  post: true
  activity: (     return x * p.y - y * p.x );
   operation abs() : double
  pre: true
  post: true
  activity: (     return hypot(x, y) );
   operation compareTo( o : P) : int
  pre: true
  post: true
  activity: (     if (x /= o.x) then     return (x)->compareTo(o.x) else skip ; 
     return (y)->compareTo(o.y) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<ArrayDeque<Integer>>matrix=new ArrayList<>();
    ArrayDeque<Integer>deq=new ArrayDeque<>();
    ArrayDeque<Integer>next=new ArrayDeque<>();
    for(int i=0 ; i<n ; i++){
      ArrayDeque<Integer>tmp=new ArrayDeque<>();
      for(int j=0 ; j<n-1 ; j++){
        tmp.add(sc.nextInt()-1);
      }
      matrix.add(tmp);
      deq.add(i);
    }
    int times=0 ;
    while(deq.size()>0){
      times++;
      boolean[] used=new boolean[n];
      while(deq.size()>0){
        int x=deq.poll();
        if(! used[x] && matrix.get(x).size()>0){
          int y=matrix.get(x).peek();
          if(! used[y] && matrix.get(y).peek()==x){
            next.add(x);
            next.add(y);
            used[x]=true ;
            used[y]=true ;
            matrix.get(x).poll();
            matrix.get(y).poll();
          }
        }
      }
      ArrayDeque<Integer>tmp=next ;
      next=deq ;
      deq=tmp ;
    }
    int count=0 ;
    for(ArrayDeque tmp : matrix){
      count+=tmp.size();
    }
    if(count>0){
      System.out.println(-1);
      return ;
    }
    System.out.println(times-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var matrix : Sequence(Sequence(int)) ; matrix := Sequence{} ;
    var deq : Sequence(int) ; deq := ArrayDeque<OclAny>.newArrayDeque() ;
    var next : Sequence(int) ; next := ArrayDeque<OclAny>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < n do ( (     var tmp : Sequence(int) ; tmp := ArrayDeque<OclAny>.newArrayDeque() ;
         var j : int ; j := 0 ; while j < n - 1 do ( (     tmp := tmp->including(sc.getCurrent()->toInteger() - 1) )  ;     j := j + 1 ) ; 
     matrix := matrix->including(tmp) ; 
     deq := deq->including(i) )  ;     i := i + 1 ) ; 
    var times : int ; times := 0 ;
    while (deq->size() > 0) do (     times := times + 1 ; 
     var used : Sequence(boolean) ; used := Integer.subrange(1,n)->collect(false) ;
    while (deq->size() > 0) do (     var x : int ; x := deq->min() ;
     if (not(used[x+1]) & matrix->at(x+1)->size() > 0) then (     var y : int ; y := matrix->at(x+1)->min() ;
     if (not(used[y+1]) & matrix->at(y+1)->min() = x) then (     next := next->including(x) ; 
     next := next->including(y) ; 
    used[x+1] := true ; 
    used[y+1] := true ; 
    matrix := matrix->at(x+1)->sort()->tail() ; 
    matrix := matrix->at(y+1)->sort()->tail() ; 
 ) else skip ) else skip ) ; 
    var tmp : Sequence(int) ; tmp := next ;
    next := deq ; 
    deq := tmp ; 
 ) ; 
    var count : int ; count := 0 ;
    for (tmp : matrix) do ( (     count := count+(tmp->size()) )  ) ; 
    if (count > 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    OclFile["System.out"].println(times - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MOD=2019 ;
  static int min_modulo(int l,int r){
    if(r-l>=MOD)return 0 ;
    else {
      int ans=MOD-1 ;
      for(int i=l ; i<=r ; i++){
        for(int j=i+1 ; j<=r ; j++){
          ans=Math.min(ans,(i*j)% MOD);
        }
      }
      return ans ;
    }
  }
  public static void main(String[] args){
    int l=2020,r=2040 ;
    System.out.println(min_modulo(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MOD : int := 2019;
  static   operation min_modulo( l : int, r : int) : int
  pre: true
  post: true
  activity: (     if (r - l >= MOD) then     return 0 else (     var ans : int ; ans := MOD - 1 ;
         var i : int ; i := l ; while i <= r do ( (         var j : int ; j := i + 1 ; while j <= r do ( (     ans := Set{ans, (i * j) mod MOD}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 2020 ;
    var r : int ; r := 2040 ;
     OclFile["System.out"].println(min_modulo(l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int count(int arr[],int N,int K){
    int count=0,ans=0 ;
    for(int i=0 ; i<N ; i++){
      if(arr[i]==K){
        count=count+1 ;
      }
      else {
        ans+=(count*(count+1))/2 ;
        count=0 ;
      }
    }
    ans=ans+(count*(count+1))/2 ;
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      1,0,0,1,1,0,0 };
      int N=arr.length ;
      int K=0 ;
      System.out.print(count(arr,N,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation count( arr : Sequence(int), N : int, K : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
    var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     if (arr[i+1] = K) then (     count := count + 1 ) else (     ans := ans+((count * (count + 1)) / 2) ; 
     count := 0 ) )  ;     i := i + 1 ) ; 
     ans := ans + (count * (count + 1)) / 2 ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,0,0,1,1,0,0} ;
     var N : int ; N := arr->size() ;
     var K : int ; K := 0 ;
     OclFile["System.out"].print(count(arr, N, K)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javafx.util.Pair ;
import java.util.*;
import java.lang.*;
public class solve {
  static Scanner sc ;
  public static void main(String[] args){
    sc=new Scanner(System.in);
    int testCases=1 ;
    while(testCases>0){
      justDoIt();
      testCases--;
    }
  }
  static void justDoIt(){
    int s1=sc.nextInt(),s2=sc.nextInt(),s3=sc.nextInt(),a,b,c ;
    a=(int)Math.sqrt((double)s1*s3/s2);
    b=(int)Math.sqrt((double)s1*s2/s3);
    c=(int)Math.sqrt((double)s2*s3/s1);
    System.out.println(4*(a+b+c));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solve {
  static   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var testCases : int ; testCases := 1 ;
     while (testCases > 0) do (     execute justDoIt() ; 
     testCases := testCases - 1 ) );
  static   operation justDoIt() : void
  pre: true
  post: true
  activity: (     var s1 : int ; s1 := sc.getCurrent()->toInteger() ;
    var s2 : int ; s2 := sc.getCurrent()->toInteger() ;
    var s3 : int ; s3 := sc.getCurrent()->toInteger() ;
    var a : int ;
    var b : int ;
    var c : int ;
     a := (s1->oclAsType(double) * s3 / s2)->sqrt()->oclAsType(int) ; 
    b := (s1->oclAsType(double) * s2 / s3)->sqrt()->oclAsType(int) ; 
    c := (s2->oclAsType(double) * s3 / s1)->sqrt()->oclAsType(int) ; 
    OclFile["System.out"].println(4 * (a + b + c)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Parallelepiped {
  public static void main(String[] args)throws IOException {
    FastIO io=new FastIO();
    int ab=io.nextInt();
    int ac=io.nextInt();
    int bc=io.nextInt();
    int a=(int)Math.sqrt(ab*ac/bc);
    int b=(int)Math.sqrt(ab*bc/ac);
    int c=(int)Math.sqrt(ac*bc/ab);
    io.println(4*(a+b+c));
    io.close();
  }
  static class FastIO extends PrintWriter {
    private BufferedReader br ;
    private StringTokenizer st ;
    public FastIO(){
      this(System.in,System.out);
    }
    public FastIO(InputStream in,OutputStream out){
      super(out);
      br=new BufferedReader(new InputStreamReader(in));
    }
    public FastIO(String problemName)throws IOException {
      super(new FileWriter(problemName+".out"));
      br=new BufferedReader(new FileReader(problemName+".in"));
    }
    public String next(){
      try {
        while(st==null || ! st.hasMoreTokens()){
          st=new StringTokenizer(br.readLine());
        }
        return st.nextToken();
      }
      catch(Exception e){
      }
      return null ;
    }
    public String nextLine(){
      try {
        return br.readLine();
      }
      catch(Exception e){
      }
      return null ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public boolean nextBoolean(){
      return Boolean.parseBoolean(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Parallelepiped {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : FastIO ; io := FastIO.newFastIO() ;
     var ab : int ; ab := io.nextInt() ;
    var ac : int ; ac := io.nextInt() ;
    var bc : int ; bc := io.nextInt() ;
    var a : int ; a := (ab * ac / bc)->sqrt()->oclAsType(int) ;
    var b : int ; b := (ab * bc / ac)->sqrt()->oclAsType(int) ;
    var c : int ; c := (ac * bc / ab)->sqrt()->oclAsType(int) ;
    io.println(4 * (a + b + c)) ; 
    io.close() ; 
 );
  static class FastIO extends OclFile {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastIO() : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile["System.in"], OclFile["System.out"]) );
   static operation newFastIO( in : OclFile, out : OclFile) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(in, out);
    return self );
  operation initialise( in : OclFile, out : OclFile) : void
  pre: true  post: true
  activity: (     execute super(out) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   static operation newFastIO( problemName : String) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(problemName);
    return self );
  operation initialise( problemName : String) : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Write(problemName + ".out")) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(problemName + ".in")) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() )   catch (e : ProgramException) do skip
     return null );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : ProgramException) do skip
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextBoolean() : boolean
  pre: true
  post: true
  activity: (     return parseBoolean(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class WilburandSwimmingPool {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    if(n==1){
      System.out.println(-1);
      System.exit(0);
    }
    int[] x=new int[n];
    int[] y=new int[n];
    for(int i=0 ; i<n ; i++){
      String temp[]=br.readLine().split(" ");
      x[i]=Integer.parseInt(temp[0]);
      y[i]=Integer.parseInt(temp[1]);
    }
    if(n==2){
      if(x[0]==x[1] || y[0]==y[1]){
        System.out.println(-1);
        System.exit(0);
      }
      int w=Math.abs(x[0]-x[1]);
      int h=Math.abs(y[0]-y[1]);
      System.out.println(w*h);
      System.exit(0);
    }
    if(n==3 || n==4){
      Arrays.sort(x);
      Arrays.sort(y);
      int w=x[n-1]-x[0];
      int h=y[n-1]-y[0];
      System.out.println(w*h);
      System.exit(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class WilburandSwimmingPool {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    if (n = 1) then (     OclFile["System.out"].println(-1) ; 
 OclProcess.exit(0) ) else skip ; 
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
     x[i+1] := (temp[0+1])->toInteger() ; 
     y[i+1] := (temp[1+1])->toInteger() )  ;     i := i + 1 ) ; 
    if (n = 2) then (     if (x[0+1] = x[1+1] or y[0+1] = y[1+1]) then (     OclFile["System.out"].println(-1) ; 
 OclProcess.exit(0) ) else skip ; 
     var w : int ; w := if x[0+1] - x[1+1] < 0 then -(x[0+1] - x[1+1]) else x[0+1] - x[1+1] endif ;
    var h : int ; h := if y[0+1] - y[1+1] < 0 then -(y[0+1] - y[1+1]) else y[0+1] - y[1+1] endif ;
    OclFile["System.out"].println(w * h) ; 
OclProcess.exit(0) ; 
 ) else skip ; 
    if (n = 3 or n = 4) then (     x := x->sort() ; 
     y := y->sort() ; 
    var w : int ; w := x[n - 1+1] - x[0+1] ;
    var h : int ; h := y[n - 1+1] - y[0+1] ;
    OclFile["System.out"].println(w * h) ; 
OclProcess.exit(0) ; 
 ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class VitalityAndNight {
  public static void main(String[] args)throws Exception {
    new VitalityAndNight().start();
  }
  public void start()throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    System.out.println(calc(br));
  }
  int calc(BufferedReader br)throws Exception {
    int vertices=Integer.parseInt(br.readLine());
    int[] x=new int[vertices];
    int[] y=new int[vertices];
    for(int i=0 ; i<=vertices-1 ; i++){
      String[] xy=br.readLine().split(" ");
      x[i]=Integer.parseInt(xy[0]);
      y[i]=Integer.parseInt(xy[1]);
    }
    return getArea(x,y);
  }
  int getArea(int[] x,int[] y){
    if(x.length<=1){
      return-1 ;
    }
    if(x.length==2){
      if(x[0]==x[1] || y[0]==y[1]){
        return-1 ;
      }
    }
    int area=0 ;
    int x_diff=0,y_diff=0 ;
    for(int i=0 ; i<=x.length-1 ; i++){
      for(int j=i+1 ; j<=x.length-1 ; j++){
        x_diff=Math.max(x_diff,Math.abs(x[j]-x[i]));
        y_diff=Math.max(y_diff,Math.abs(y[j]-y[i]));
      }
    }
    return(x_diff*y_diff);
  }
}
------------------------------------------------------------
OCL File:
---------
 class VitalityAndNight {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     VitalityAndNight.newVitalityAndNight().start() );
   operation start() : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     OclFile["System.out"].println(calc(br)) );
   operation calc( br : OclFile) : int
  pre: true
  post: true
  activity: (     var vertices : int ; vertices := (br.readLine())->toInteger() ;
     var x : Sequence(int) ; x := Integer.subrange(1,vertices)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,vertices)->collect(0) ;
        var i : int ; i := 0 ; while i <= vertices - 1 do ( (     var xy : Sequence(String) ; xy := br.readLine()->split(" ") ;
     x[i+1] := (xy[0+1])->toInteger() ; 
     y[i+1] := (xy[1+1])->toInteger() )  ;     i := i + 1 ) ; 
    return getArea(x, y) 
 );
   operation getArea( x : Sequence(int), y : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (x->size() <= 1) then (     return -1 ) else skip ; 
     if (x->size() = 2) then (     if (x[0+1] = x[1+1] or y[0+1] = y[1+1]) then (     return -1 ) else skip ) else skip ; 
    var area : int ; area := 0 ;
    var x_diff : int ; x_diff := 0 ;
    var y_diff : int ; y_diff := 0 ;
        var i : int ; i := 0 ; while i <= x->size() - 1 do ( (         var j : int ; j := i + 1 ; while j <= x->size() - 1 do ( (     x_diff := Set{x_diff, if x[j+1] - x[i+1] < 0 then -(x[j+1] - x[i+1]) else x[j+1] - x[i+1] endif}->max() ; 
     y_diff := Set{y_diff, if y[j+1] - y[i+1] < 0 then -(y[j+1] - y[i+1]) else y[j+1] - y[i+1] endif}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return (x_diff * y_diff) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    List<Integer>num=new ArrayList<>();
    List<Integer>min=new ArrayList<>();
    int n,m=Integer.MAX_VALUE,M=Integer.MIN_VALUE ;
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    int tmp ;
    for(int i=0 ; i<n ; i++){
      tmp=sc.nextInt();
      if(tmp<m){
        m=tmp ;
      }
      num.add(tmp);
      min.add(m);
    }
    sc.close();
    for(int i=1 ; i<n ; i++){
      tmp=num.get(i)-min.get(i-1);
      if(tmp>M){
        M=tmp ;
      }
    }
    System.out.println(M);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : Sequence(int) ; num := Sequence{} ;
     var min : Sequence(int) ; min := Sequence{} ;
    var n : int ;
    var m : int ; m := 2147483647 ;
    var M : int ; M := -2147483648 ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := sc.getCurrent()->toInteger() ; 
    var tmp : int ;
        var i : int ; i := 0 ; while i < n do ( (     tmp := sc.getCurrent()->toInteger() ; 
     if (tmp < m) then (     m := tmp ) else skip ; 
     num := num->including(tmp) ; 
     min := min->including(m) )  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 1 ; while i < n do ( (     tmp := num->at(i+1) - min->at(i - 1+1) ; 
     if (tmp > M) then (     M := tmp ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(M) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.List ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
class Main {
  public static void main(String[] args){
    Input stdIn=new Input();
    int n=stdIn.getValue();
    List<Integer>r=stdIn.getValueLines(n);
    int maxv=r.get(1)-r.get(0);
    ;
    int minv=r.get(0);
    for(int i=0 ; i<n-1 ; i++){
      if(maxv<r.get(i+1)-minv){
        maxv=r.get(i+1)-minv ;
      }
      if(minv>r.get(i+1)){
        minv=r.get(i+1);
      }
    }
    System.out.println(maxv);
    stdIn.close();
  }
}
class Input {
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  public int getValue(){
    int n=0 ;
    try {
      n=Integer.parseInt(br.readLine());
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return n ;
  }
  public List<Integer>getValueLines(int n){
    List<Integer>values=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      values.add(getValue());
    }
    return values ;
  }
  public List<Integer>getLine(){
    try {
      String[] s=br.readLine().trim().split(" ");
      List<Integer>ary=new ArrayList<>();
      for(int i=0 ; i<s.length ; i++){
        ary.add(Integer.parseInt(s[i]));
      }
      return ary ;
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return null ;
  }
  public void close(){
    try {
      br.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : Input ; stdIn := Input.newInput() ;
     var n : int ; n := stdIn.getValue() ;
    var r : Sequence(int) ; r := stdIn.getValueLines(n) ;
    var maxv : int ; maxv := r->at(1+1) - r->at(0+1) ;
    var minv : int ; minv := r->at(0+1) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (maxv < r->at(i + 1+1) - minv) then (     maxv := r->at(i + 1+1) - minv ) else skip ; 
     if (minv > r->at(i + 1+1)) then (     minv := r->at(i + 1+1) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(maxv) ; 
    stdIn.close() ; 
 );
}
class Input {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   operation getValue() : int
  pre: true
  post: true
  activity: (     var n : int ; n := 0 ;
     try (     n := (br.readLine())->toInteger() )   catch (e : IOException) do (     e.printStackTrace() )
     return n );
   operation getValueLines( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var values : Sequence(int) ; values := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     values := values->including(getValue()) )  ;     i := i + 1 ) ; 
     return values );
   operation getLine() : Sequence(int)
  pre: true
  post: true
  activity: (     try (     var s : Sequence(String) ; s := br.readLine()->trim()->split(" ") ;
     var ary : Sequence(int) ; ary := Sequence{} ;
         var i : int ; i := 0 ; while i < s->size() do ( (     ary := ary->including((s[i+1])->toInteger()) )  ;     i := i + 1 ) ; 
     return ary )   catch (e : IOException) do (     e.printStackTrace() )
     return null );
   operation close() : void
  pre: true
  post: true
  activity: (     try (     skip )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String[] str=br.readLine().split(" ");
      int a=Integer.parseInt(str[0]);
      int b=Integer.parseInt(str[2]);
      if(str[1] .equals("+")){
        System.out.println(a+b);
      }
      else if(str[1] .equals("-")){
        System.out.println(a-b);
      }
      else if(str[1] .equals("*")){
        System.out.println(a*b);
      }
      else if(str[1] .equals("/")){
        System.out.println(a/b);
      }
      else if(str[1] .equals("?")){
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     var a : int ; a := (str[0+1])->toInteger() ;
     var b : int ; b := (str[2+1])->toInteger() ;
     if (str[1+1] = "+") then (     OclFile["System.out"].println(a + b) ) else     if (str[1+1] = "-") then (     OclFile["System.out"].println(a - b) ) else     if (str[1+1] = "*") then (     OclFile["System.out"].println(a * b) ) else     if (str[1+1] = "/") then (     OclFile["System.out"].println(a / b) ) else     if (str[1+1] = "?") then (     break ) else skip ; ;  ;  ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    try {
      BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
      int problemCount=Integer.parseInt(reader.readLine());
      for(int i=0 ; i<problemCount ; i++){
        String[] textArray=reader.readLine().split(" ");
        GeometricVector vector1=new GeometricVector(Double.parseDouble(textArray[0]),Double.parseDouble(textArray[1]),Double.parseDouble(textArray[2]),Double.parseDouble(textArray[3]));
        GeometricVector vector2=new GeometricVector(Double.parseDouble(textArray[4]),Double.parseDouble(textArray[5]),Double.parseDouble(textArray[6]),Double.parseDouble(textArray[7]));
        if(vector1.isParallelTo(vector2)){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
class GeometricVector {
  private double xlength ;
  private double ylength ;
  GeometricVector(double x1,double y1,double x2,double y2){
    xlength=x2-x1 ;
    ylength=y2-y1 ;
  }
  boolean isParallelTo(GeometricVector otherVector){
    double otherXlength=otherVector.getXlength();
    double otherYlength=otherVector.getYlength();
    if(getXlength()*otherYlength-getYlength()*otherXlength==0){
      return true ;
    }
    else {
      return false ;
    }
  }
  double getXlength(){
    return xlength ;
  }
  double getYlength(){
    return ylength ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var problemCount : int ; problemCount := (reader.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < problemCount do ( (     var textArray : Sequence(String) ; textArray := reader.readLine()->split(" ") ;
     var vector1 : GeometricVector ; vector1 := GeometricVector.newGeometricVector((textArray[0+1])->toReal(), (textArray[1+1])->toReal(), (textArray[2+1])->toReal(), (textArray[3+1])->toReal()) ;
     var vector2 : GeometricVector ; vector2 := GeometricVector.newGeometricVector((textArray[4+1])->toReal(), (textArray[5+1])->toReal(), (textArray[6+1])->toReal(), (textArray[7+1])->toReal()) ;
     if (vector1.isParallelTo(vector2)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) )  ;     i := i + 1 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}
class GeometricVector {
   attribute xlength : double;
   attribute ylength : double;
   static operation newGeometricVector( x1 : double, y1 : double, x2 : double, y2 : double) : GeometricVector
  pre: true
  post: true
  activity:
  ( var self : GeometricVector ;
    self := createGeometricVector();
    self.initialise(x1, y1,x2,y2);
    return self );
  operation initialise( x1 : double, y1 : double, x2 : double, y2 : double) : void
  pre: true  post: true
  activity: (     xlength := x2 - x1 ; 
     ylength := y2 - y1 );
   operation isParallelTo( otherVector : GeometricVector) : boolean
  pre: true
  post: true
  activity: (     var otherXlength : double ; otherXlength := otherVector.getXlength() ;
     var otherYlength : double ; otherYlength := otherVector.getYlength() ;
     if (getXlength() * otherYlength - getYlength() * otherXlength = 0) then (     return true ) else (     return false ) );
   operation getXlength() : double
  pre: true
  post: true
  activity: (     return xlength );
   operation getYlength() : double
  pre: true
  post: true
  activity: (     return ylength );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.nio.charset.StandardCharsets ;
public class Main {
  int[] A ;
  boolean isBurst=false ;
  public static void main(String[] args)throws IOException {
    InputStreamReader reader=new InputStreamReader(System.in,StandardCharsets.UTF_8);
    BufferedReader in=new BufferedReader(reader);
    Main ins=new Main(in);
    ins.calc();
    ins.showResult();
  }
  Main(BufferedReader in)throws IOException {
    A=new int[3];
    String[] tokens=in.readLine().split(" ");
    for(int i=0 ; i<3 ; ++i){
      A[i]=Integer.parseInt(tokens[i]);
    }
  }
  void calc(){
    int sum=0 ;
    for(int i=0 ; i<3 ; ++i){
      sum+=A[i];
    }
    if(sum>=22){
      isBurst=true ;
    }
  }
  void showResult(){
    System.out.println((isBurst ? "bust" : "win"));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute A : Sequence(int);
   attribute isBurst : boolean := false;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"], StandardCharsets.UTF_8) ;
     var in : OclFile ; in := OclFile.newOclFile_Read(reader) ;
    var ins : Main ; ins := Main.newMain(in) ;
    ins.calc() ; 
    ins.showResult() ; 
 );
   static operation newMain( in : OclFile) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     A := Integer.subrange(1,3)->collect(0) ; 
     var tokens : Sequence(String) ; tokens := in.readLine()->split(" ") ;
         var i : int ; i := 0 ; while i < 3 do ( (     A[i+1] := (tokens[i+1])->toInteger() )  ;     i := i + 1 ) );
   operation calc() : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < 3 do ( (     sum := sum+(A[i+1]) )  ;     i := i + 1 ) ; 
     if (sum >= 22) then (     isBurst := true ) else skip );
   operation showResult() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((if isBurst then "bust" else "win" endif)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int compute_maxprofit1(int[] R){
    int max_profit=Integer.MIN_VALUE ;
    for(int i=1 ; i<R.length ; i++)for(int j=1 ; j<R.length ; j++)if(R[j]-R[i]>max_profit)max_profit=R[j]-R[i];
    return max_profit ;
  }
  public static int compute_maxprofit2(int[] R){
    int min=Integer.MAX_VALUE ;
    int max=Integer.MIN_VALUE ;
    for(int i=0 ; i<R.length ; i++){
      if(max<R[i]-min)max=R[i]-min ;
      if(min>R[i])min=R[i];
    }
    return max ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] R=new int[n];
    for(int i=0 ; i<n ; i++)R[i]=in.nextInt();
    in.close();
    System.out.println(compute_maxprofit2(R));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation compute_maxprofit1( R : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var max_profit : int ; max_profit := -2147483648 ;
         var i : int ; i := 1 ; while i < R->size() do (         var j : int ; j := 1 ; while j < R->size() do (     if (R[j+1] - R[i+1] > max_profit) then     max_profit := R[j+1] - R[i+1] ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return max_profit );
  static   operation compute_maxprofit2( R : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var min : int ; min := 2147483647 ;
     var max : int ; max := -2147483648 ;
         var i : int ; i := 0 ; while i < R->size() do ( (     if (max < R[i+1] - min) then     max := R[i+1] - min ; else skip ; 
     if (min > R[i+1]) then     min := R[i+1] ; else skip )  ;     i := i + 1 ) ; 
     return max );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var R : Sequence(int) ; R := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     R[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(compute_maxprofit2(R)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static Scanner scan=new Scanner(System.in);
  public static int n ;
  public static void main(String args[]){
    run();
  }
  static void run(){
    int n,firstPriceTmp,priceTmp ;
    int minPrice,maxPrice ;
    int maxBenefit,benefit ;
    maxBenefit=-(1000000000-1);
    minPrice=1000000000 ;
    maxPrice=1 ;
    n=scan.nextInt();
    firstPriceTmp=scan.nextInt();
    for(int i=1 ; i<n ; i++){
      priceTmp=scan.nextInt();
      minPrice=Math.min(minPrice,firstPriceTmp);
      firstPriceTmp=priceTmp ;
      benefit=priceTmp-minPrice ;
      maxBenefit=Math.max(benefit,maxBenefit);
    }
    System.out.println(maxBenefit);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute run() );
  static   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ;
    var firstPriceTmp : int ;
    var priceTmp : int ;
     var minPrice : int ;
    var maxPrice : int ;
    var maxBenefit : int ;
    var benefit : int ;
    maxBenefit := -(1000000000 - 1) ; 
    minPrice := 1000000000 ; 
    maxPrice := 1 ; 
    n := scan.getCurrent()->toInteger() ; 
    firstPriceTmp := scan.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i < n do ( (     priceTmp := scan.getCurrent()->toInteger() ; 
     minPrice := Set{minPrice, firstPriceTmp}->min() ; 
    firstPriceTmp := priceTmp ; 
    benefit := priceTmp - minPrice ; 
    maxBenefit := Set{benefit, maxBenefit}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(maxBenefit) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    final BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    final int n=Integer.parseInt(br.readLine());
    int r=Integer.parseInt(br.readLine());
    int rm=r ;
    r=Integer.parseInt(br.readLine());
    int ans=r-rm ;
    if(r<rm)rm=r ;
    for(int i=2 ; i<n ; i++){
      r=Integer.parseInt(br.readLine());
      if(ans<r-rm)ans=r-rm ;
      if(r<rm)rm=r ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var r : int ; r := (br.readLine())->toInteger() ;
    var rm : int ; rm := r ;
    r := (br.readLine())->toInteger() ; 
    var ans : int ; ans := r - rm ;
    if (r < rm) then     rm := r ; else skip ; 
        var i : int ; i := 2 ; while i < n do ( (     r := (br.readLine())->toInteger() ; 
     if (ans < r - rm) then     ans := r - rm ; else skip ; 
     if (r < rm) then     rm := r ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int upper_bound(int[] array,int length,int value){
    int low=0 ;
    int high=length ;
    while(low<high){
      final int mid=(low+high)/2 ;
      if(value>=array[mid]){
        low=mid+1 ;
      }
      else {
        high=mid ;
      }
    }
    return low ;
  }
  static int lower_bound(int[] array,int length,int value){
    int low=0 ;
    int high=length ;
    while(low<high){
      final int mid=(low+high)/2 ;
      if(value<=array[mid]){
        high=mid ;
      }
      else {
        low=mid+1 ;
      }
    }
    return low ;
  }
  static int findSextuplets(int[] arr,int n){
    int index=0 ;
    int[] RHS=new int[n*n*n+1];
    for(int i=0 ; i<n ; i++){
      if(arr[i]!=0){
        for(int j=0 ; j<n ; j++){
          for(int k=0 ; k<n ; k++){
            RHS[index++]=arr[i]*(arr[j]+arr[k]);
          }
        }
      }
    }
    Arrays.sort(RHS);
    int result=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        for(int k=0 ; k<n ; k++){
          int val=arr[i]*arr[j]+arr[k];
          result+=(upper_bound(RHS,index,val)-lower_bound(RHS,index,val));
        }
      }
    }
    return result ;
  }
  public static void main(String[] args){
    int[] arr={
      2,3 };
      int n=arr.length ;
      System.out.println(findSextuplets(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation upper_bound( array : Sequence(int), length : int, value : int) : int
  pre: true
  post: true
  activity: (     var low : int ; low := 0 ;
     var high : int ; high := length ;
     while (low < high) do (     var mid : int ; mid := (low + high) / 2 ;
     if (value >= array[mid+1]) then (     low := mid + 1 ) else (     high := mid ) ) ; 
     return low );
  static   operation lower_bound( array : Sequence(int), length : int, value : int) : int
  pre: true
  post: true
  activity: (     var low : int ; low := 0 ;
     var high : int ; high := length ;
     while (low < high) do (     var mid : int ; mid := (low + high) / 2 ;
     if (value <= array[mid+1]) then (     high := mid ) else (     low := mid + 1 ) ) ; 
     return low );
  static   operation findSextuplets( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var index : int ; index := 0 ;
     var RHS : Sequence(int) ; RHS := Integer.subrange(1,n * n * n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] /= 0) then (         var j : int ; j := 0 ; while j < n do ( (         var k : int ; k := 0 ; while k < n do ( (      RHS[index+1] := arr[i+1] * (arr[j+1] + arr[k+1])  ; index := index + 1 )  ;     k := k + 1 ) )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    RHS := RHS->sort() ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (         var k : int ; k := 0 ; while k < n do ( (     var val : int ; val := arr[i+1] * arr[j+1] + arr[k+1] ;
     result := result+((upper_bound(RHS, index, val) - lower_bound(RHS, index, val))) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findSextuplets(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import javax.swing.RowFilter.Entry ;
public class Main {
  Scanner sc=new Scanner(System.in);
  class log implements Comparable<log>{
    int key ;
    int value ;
    log(int key,int value){
      this.key=key ;
      this.value=value ;
    }
    @ Override public int compareTo(log o){
      return key-o.key ;
    }
  }
  void run(){
    HashMap<Integer,Integer>l=new HashMap<Integer,Integer>();
    HashMap<Integer,Integer>l2=new HashMap<Integer,Integer>();
    for(; ; ){
      String buffer=sc.nextLine();
      if(buffer.length()==0)break ;
      int k=new Scanner(buffer.replace(',',' ')).nextInt();
      if(l.containsKey(k)){
        l.put(k,l.get(k)+1);
      }
      else {
        l.put(k,1);
      }
    }
    for(; sc.hasNextLine(); ){
      String buffer=sc.nextLine();
      int k=new Scanner(buffer.replace(',',' ')).nextInt();
      if(l2.containsKey(k)){
        l2.put(k,l2.get(k)+1);
      }
      else {
        l2.put(k,1);
      }
    }
    LinkedList<log>l3=new LinkedList<Main.log>();
    for(int i : l.keySet()){
      if(l2.containsKey(i)){
        l3.add(new log(i,l.get(i)+l2.get(i)));
      }
    }
    log[] arr=l3.toArray(new log[0]);
    Arrays.sort(arr);
    for(log ans : arr){
      System.out.println(ans.key+" "+ans.value);
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
 class log implements Comparable<log> {
   attribute key : int;
   attribute value : int;
   static operation newlog( key : int, value : int) : log
  pre: true
  post: true
  activity:
  ( var self : log ;
    self := createlog();
    self.initialise(key, value);
    return self );
  operation initialise( key : int, value : int) : void
  pre: true  post: true
  activity: (     self.key := key ; 
     self.value := value );
      operation compareTo( o : log) : int
  pre: true
  post: true
  activity: (     return key - o.key );
}
   operation run() : void
  pre: true
  post: true
  activity: (     var l : Map(int,int) ; l := Map{} ;
     var l2 : Map(int,int) ; l2 := Map{} ;
      while true do ( (     var buffer : String ; buffer := sc.nextLine() ;
     if (buffer->size() = 0) then     break else skip ; 
     var k : int ; k := OclFile.newOclFile_Read(buffer.replace(',', ' ')).nextInt() ;
     if (l->keys()->includes(k)) then (     l := l->union(Map{k |-> l->at(k) + 1}) ) else (     l := l->union(Map{k |-> 1}) ) )  ) ; 
      while sc.hasNextLine() do ( (     var buffer : String ; buffer := sc.nextLine() ;
     var k : int ; k := OclFile.newOclFile_Read(buffer.replace(',', ' ')).nextInt() ;
     if (l2->keys()->includes(k)) then (     l2 := l2->union(Map{k |-> l2->at(k) + 1}) ) else (     l2 := l2->union(Map{k |-> 1}) ) )  ) ; 
    var l3 : Sequence(log) ; l3 := Sequence{} ;
    for (i : l->keys()) do ( (     if (l2->keys()->includes(i)) then (     l3 := l3->including(log.newlog(i, l->at(i) + l2->at(i))) ) else skip )  ) ; 
    var arr : Sequence(log) ; arr := l3->asSequence() ;
    arr := arr->sort() ; 
    for (ans : arr) do ( (     OclFile["System.out"].println(ans.key + " " + ans.value) )  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.ArrayList ;
import java.util.Arrays ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    ArrayList<Integer>cont=new ArrayList<Integer>();
    HashMap<Integer,Integer>times=new HashMap<Integer,Integer>();
    String line ;
    while(!(line=br.readLine()).equals("")){
      String[] input=line.split(",");
      int company=Integer.parseInt(input[0]);
      if(! cont.contains(company)){
        cont.add(company);
      }
      if(times.containsKey(company)){
        times.put(company,times.get(company)+1);
      }
      else {
        times.put(company,1);
      }
    }
    ArrayList<Integer>ok=new ArrayList<Integer>();
    while((line=br.readLine())!=null){
      String[] input=line.split(",");
      int company=Integer.parseInt(input[0]);
      if(cont.contains(company)){
        if(! ok.contains(company))ok.add(company);
      }
      if(times.containsKey(company)){
        times.put(company,times.get(company)+1);
      }
    }
    Object[] companiesO=ok.toArray();
    int[] companies=new int[companiesO.length];
    for(int i=0 ; i<companies.length ; i++){
      companies[i]=(int)companiesO[i];
    }
    Arrays.sort(companies);
    for(int i=0 ; i<companies.length ; i++){
      System.out.println(companies[i]+" "+times.get(companies[i]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var cont : Sequence(int) ; cont := Sequence{} ;
    var times : Map(int,int) ; times := Map{} ;
    var line : String ;
    while (not((line) = "")) do (     var input : Sequence(String) ; input := line->split(",") ;
     var company : int ; company := (input[0+1])->toInteger() ;
     if (not(cont->includes(company))) then (     cont := cont->including(company) ) else skip ; 
     if (times->keys()->includes(company)) then (     times := times->union(Map{company |-> times->at(company) + 1}) ) else (     times := times->union(Map{company |-> 1}) ) ) ; 
    var ok : Sequence(int) ; ok := Sequence{} ;
        line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     var input : Sequence(String) ; input := line->split(",") ;
     var company : int ; company := (input[0+1])->toInteger() ;
     if (cont->includes(company)) then (     if (not(ok->includes(company))) then     ok := ok->including(company) ; else skip ) else skip ; 
     if (times->keys()->includes(company)) then (     times := times->union(Map{company |-> times->at(company) + 1}) ) else skip ) ;     line := br.readLine() ;
 ) ;  
    var companiesO : Sequence(OclAny) ; companiesO := ok->asSequence() ;
    var companies : Sequence(int) ; companies := Integer.subrange(1,companiesO->size())->collect(0) ;
        var i : int ; i := 0 ; while i < companies->size() do ( (     companies[i+1] := companiesO[i+1]->oclAsType(int) )  ;     i := i + 1 ) ; 
    companies := companies->sort() ; 
        var i : int ; i := 0 ; while i < companies->size() do ( (     OclFile["System.out"].println(companies[i+1] + " " + times->at(companies[i+1])) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static List<Integer>sengetu=new ArrayList<Integer>();
  static List<Integer>result=new ArrayList<Integer>();
  static boolean hantei(int n){
    for(int i=0 ; i<sengetu.size(); i++)if(n==sengetu.get(i))return true ;
    return false ;
  }
  static boolean hantei2(int n){
    for(int i=0 ; i<result.size(); i++)if(n==result.get(i))return true ;
    return false ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    boolean sw=false ;
    Map<Integer,Integer>m=new HashMap<Integer,Integer>();
    while(in.hasNext()){
      String input=in.nextLine();
      if(input.length()==0){
        sw=true ;
        continue ;
      }
      String data[]=input.split(",");
      int ban=Integer.parseInt(data[0]);
      int num=Integer.parseInt(data[1]);
      if(m.containsKey(ban)){
        m.put(ban,m.get(ban)+1);
      }
      else m.put(ban,1);
      if(! sw)if(! hantei(ban))sengetu.add(ban);
      if(sw)if(hantei(ban))if(! hantei2(ban))result.add(ban);
    }
    Collections.sort(result);
    for(int i=0 ; i<result.size(); i++)System.out.println(result.get(i)+" "+m.get(result.get(i)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sengetu : Sequence(int) := Sequence{};
  static   attribute result : Sequence(int) := Sequence{};
  static   operation hantei( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < sengetu->size() do (     if (n = sengetu->at(i+1)) then     return true else skip ;  ;     i := i + 1 ) ; 
     return false );
  static   operation hantei2( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < result->size() do (     if (n = result->at(i+1)) then     return true else skip ;  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sw : boolean ; sw := false ;
    var m : Map(int,int) ; m := Map{} ;
    while (in.hasNext()) do (     var input : String ; input := in.nextLine() ;
     if (input->size() = 0) then (     sw := true ; 
     continue ) else skip ; 
    var data : Sequence(String) ; data := input->split(",") ;
    var ban : int ; ban := (data[0+1])->toInteger() ;
    var num : int ; num := (data[1+1])->toInteger() ;
    if (m->keys()->includes(ban)) then (     m := m->union(Map{ban |-> m->at(ban) + 1}) ) else     m := m->union(Map{ban |-> 1}) ; ;  
    if (not(sw)) then     if (not(hantei(ban))) then     sengetu := sengetu->including(ban) ; else skip ; else skip ; 
    if (sw) then     if (hantei(ban)) then     if (not(hantei2(ban))) then     result := result->including(ban) ; else skip ; else skip ; else skip ; 
 ) ; 
    result := result->sort() ; 
        var i : int ; i := 0 ; while i < result->size() do (     OclFile["System.out"].println(result->at(i+1) + " " + m->at(result->at(i+1))) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.*;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  static void tr(Object...os){
    System.err.println(deepToString(os));
  }
  void solve(){
    int[][] on=new int[2][1024];
    for(; ; ){
      String line=sc.nextLine();
      if(line.length()==0)break ;
      String[] ss=line.split(",");
      int num=Integer.parseInt(ss[0]);
      int day=Integer.parseInt(ss[1]);
      on[0][num]++;
    }
    for(; sc.hasNextLine(); ){
      String line=sc.nextLine();
      String[] ss=line.split(",");
      int num=Integer.parseInt(ss[0]);
      int day=Integer.parseInt(ss[1]);
      on[1][num]++;
    }
    for(int i=0 ; i<1024 ; i++){
      if(on[0][i]>0 && on[1][i]>0){
        out.println(i+" "+(on[0][i]+on[1][i]));
      }
    }
  }
  public static void main(String[] args)throws Exception {
    new Main().run();
  }
  Scanner sc=null ;
  PrintWriter out=null ;
  public void run()throws Exception {
    sc=new Scanner(System.in);
    out=new PrintWriter(System.out);
    solve();
    out.flush();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var on : Sequence(Sequence(int)) ; on := Integer.subrange(1,2)->collect(Integer.subrange(1,1024)->collect(0)) ;
       while true do ( (     var line : String ; line := sc.nextLine() ;
     if (line->size() = 0) then     break else skip ; 
    var ss : Sequence(String) ; ss := line->split(",") ;
    var num : int ; num := (ss[0+1])->toInteger() ;
    var day : int ; day := (ss[1+1])->toInteger() ;
    on[0+1][num+1] := on[0+1][num+1] + 1 ; 
 )  ) ; 
       while sc.hasNextLine() do ( (     var line : String ; line := sc.nextLine() ;
     var ss : Sequence(String) ; ss := line->split(",") ;
    var num : int ; num := (ss[0+1])->toInteger() ;
    var day : int ; day := (ss[1+1])->toInteger() ;
    on[1+1][num+1] := on[1+1][num+1] + 1 ; 
 )  ) ; 
         var i : int ; i := 0 ; while i < 1024 do ( (     if (on[0+1][i+1] > 0 & on[1+1][i+1] > 0) then (     out.println(i + " " + (on[0+1][i+1] + on[1+1][i+1])) ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute sc : OclFile := null;
   attribute out : OclFile := null;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Map.Entry ;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  void run(){
    sc=new Scanner(System.in);
    TreeMap<Integer,Integer>map1=new TreeMap<Integer,Integer>();
    TreeMap<Integer,Integer>map2=new TreeMap<Integer,Integer>();
    for(; ; ){
      String s=sc.nextLine();
      if(s.equals(""))break ;
      String[] ss=s.split(",");
      int id=Integer.parseInt(ss[0]);
      if(! map1.containsKey(id))map1.put(id,0);
      map1.put(id,map1.get(id)+1);
    }
    for(; sc.hasNext(); ){
      String[] ss=sc.nextLine().split(",");
      int id=Integer.parseInt(ss[0]);
      if(! map2.containsKey(id))map2.put(id,0);
      map2.put(id,map2.get(id)+1);
    }
    for(Entry<Integer,Integer>entry : map1.entrySet()){
      int id=entry.getKey();
      if(map2.containsKey(id)){
        println(id+" "+(entry.getValue()+map2.get(id)));
      }
    }
    sc.close();
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var map1 : Map(int,int) ; map1 := Map{} ;
    var map2 : Map(int,int) ; map2 := Map{} ;
      while true do ( (     var s : String ; s := sc.nextLine() ;
     if (s = "") then     break else skip ; 
    var ss : Sequence(String) ; ss := s->split(",") ;
    var id : int ; id := (ss[0+1])->toInteger() ;
    if (not(map1->keys()->includes(id))) then     map1 := map1->union(Map{id |-> 0}) ; else skip ; 
    map1 := map1->union(Map{id |-> map1->at(id) + 1}) ; 
 )  ) ; 
      while sc.hasNext() do ( (     var ss : Sequence(String) ; ss := sc.nextLine()->split(",") ;
     var id : int ; id := (ss[0+1])->toInteger() ;
     if (not(map2->keys()->includes(id))) then     map2 := map2->union(Map{id |-> 0}) ; else skip ; 
     map2 := map2->union(Map{id |-> map2->at(id) + 1}) )  ) ; 
    for (entry : map1->asSet()) do ( (     var id : int ; id := entry.getKey() ;
     if (map2->keys()->includes(id)) then (     execute println(id + " " + (entry.getValue() + map2->at(id))) ) else skip )  ) ; 
    skip ; 
 );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  class P {
    Double x ;
    Double y ;
    P(){
    };
    P(Double x,Double y){
      this.x=x ;
      this.y=y ;
    }
    Double vec(P p){
      return this.x*p.y-p.x*this.y ;
    }
    P org(P p){
      return new P(this.x-p.x,this.y-p.y);
    }
  }
  void run(){
    int n=sc.nextInt();
    double EPS=0.00000001 ;
    for(int i=0 ; i<n ; i++){
      P[] data=new P[4];
      for(int j=0 ; j<4 ; j++){
        data[j]=new P(sc.nextDouble(),sc.nextDouble());
      }
      System.out.println(Math.abs(data[0] .org(data[1]).vec(data[2] .org(data[3])))<EPS ? "YES" : "NO");
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
 class P {
   attribute x : double;
   attribute y : double;
   static operation newP() : P
  pre: true
  post: true
  activity:
  ( var self : P ;
    self := createP();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   static operation newP( x : double, y : double) : P
  pre: true
  post: true
  activity:
  ( var self : P ;
    self := createP();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation vec( p : P) : double
  pre: true
  post: true
  activity: (     return self.x * p.y - p.x * self.y );
   operation org( p : P) : P
  pre: true
  post: true
  activity: (     return P.newP(self.x - p.x, self.y - p.y) );
}
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var EPS : double ; EPS := 0.00000001 ;
         var i : int ; i := 0 ; while i < n do ( (     var data : Sequence(P) ; data := Integer.subrange(1,4)->collect(null) ;
         var j : int ; j := 0 ; while j < 4 do ( (     data[j+1] := P.newP(sc.getCurrent()->toReal(), sc.getCurrent()->toReal()) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(if if data[0+1].org(data[1+1]).vec(data[2+1].org(data[3+1])) < 0 then -(data[0+1].org(data[1+1]).vec(data[2+1].org(data[3+1]))) else data[0+1].org(data[1+1]).vec(data[2+1].org(data[3+1])) endif < EPS then "YES" else "NO" endif) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void SieveOfEratosthenes(boolean prime[],int p_size){
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=p_size ; p++){
      if(prime[p]){
        for(int i=p*2 ; i<=p_size ; i+=p)prime[i]=false ;
      }
    }
  }
  static int sumOfElements(int arr[],int n){
    boolean prime[]=new boolean[n+1];
    Arrays.fill(prime,true);
    SieveOfEratosthenes(prime,n+1);
    int i,j ;
    HashMap<Integer,Integer>m=new HashMap<>();
    for(i=0 ; i<n ; i++){
      if(m.containsKey(arr[i]))m.put(arr[i],m.get(arr[i])+1);
      else m.put(arr[i],1);
    }
    int sum=0 ;
    for(Map.Entry<Integer,Integer>entry : m.entrySet()){
      int key=entry.getKey();
      int value=entry.getValue();
      if(prime[value]){
        sum+=(key);
      }
    }
    return sum ;
  }
  public static void main(String args[]){
    int arr[]={
      5,4,6,5,4,6 };
      int n=arr.length ;
      System.out.println(sumOfElements(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation SieveOfEratosthenes( prime : Sequence(boolean), p_size : int) : void
  pre: true
  post: true
  activity: (     prime[0+1] := false ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p <= p_size do ( (     if (prime[p+1]) then (         var i : int ; i := p * 2 ; while i <= p_size do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation sumOfElements( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,n + 1)->collect(false) ;
     prime := prime->collect(true) ; 
    execute SieveOfEratosthenes(prime, n + 1) ; 
    var i : int ;
    var j : int ;
    var m : Map(int,int) ; m := Map{} ;
        i := 0 ; while i < n do ( (     if (m->keys()->includes(arr[i+1])) then     m := m->union(Map{arr[i+1] |-> m->at(arr[i+1]) + 1}) ; else     m := m->union(Map{arr[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    for (entry : m->asSet()) do ( (     var key : int ; key := entry.getKey() ;
     var value : int ; value := entry.getValue() ;
     if (prime[value+1]) then (     sum := sum+((key)) ) else skip )  ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,4,6,5,4,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(sumOfElements(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.stream.Stream ;
public class Main {
  public static void main(String[] args)throws Exception {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader reader=new BufferedReader(is);
    List<String>mylist=new ArrayList<>();
    String strinput=reader.readLine();
    while(strinput!=null){
      mylist.add(strinput);
      strinput=reader.readLine();
    }
    String arr01[]=mylist.get(0).split(" ");
    Stream<String>stream=Arrays.stream(arr01);
    int arr02[]=stream.mapToInt(Integer :: parseInt).toArray();
    int mysum=Arrays.stream(arr02).sum();
    System.out.println(mysum>=22 ? "bust" : "win");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(is) ;
    var mylist : Sequence(String) ; mylist := Sequence{} ;
    var strinput : String ; strinput := reader.readLine() ;
    while (strinput /= null) do (     mylist := mylist->including(strinput) ; 
     strinput := reader.readLine() ) ; 
    var arr01 : Sequence(String) ; arr01 := mylist->at(0+1)->split(" ") ;
    var stream : Stream<String> ; stream := stream(arr01) ;
    var arr02 : Sequence(int) ; arr02 := stream->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var mysum : int ; mysum := stream(arr02)->sum() ;
    OclFile["System.out"].println(if mysum >= 22 then "bust" else "win" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void SieveOfEratosthenes(boolean prime[],int p_size){
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=p_size ; p++){
      if(prime[p]){
        for(int i=p*2 ; i<=p_size ; i+=p)prime[i]=false ;
      }
    }
  }
  static int xorOfElements(int arr[],int n){
    boolean prime[]=new boolean[n+1];
    Arrays.fill(prime,true);
    SieveOfEratosthenes(prime,n+1);
    int i,j ;
    HashMap<Integer,Integer>m=new HashMap<>();
    for(i=0 ; i<n ; i++){
      if(m.containsKey(arr[i]))m.put(arr[i],m.get(arr[i])+1);
      else m.put(arr[i],1);
    }
    int xor=0 ;
    for(Map.Entry<Integer,Integer>entry : m.entrySet()){
      int key=entry.getKey();
      int value=entry.getValue();
      if(prime[value]){
        xor ^=(key);
      }
    }
    return xor ;
  }
  public static void main(String args[]){
    int arr[]={
      5,4,6,5,4,6 };
      int n=arr.length ;
      System.out.println(xorOfElements(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation SieveOfEratosthenes( prime : Sequence(boolean), p_size : int) : void
  pre: true
  post: true
  activity: (     prime[0+1] := false ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p <= p_size do ( (     if (prime[p+1]) then (         var i : int ; i := p * 2 ; while i <= p_size do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation xorOfElements( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,n + 1)->collect(false) ;
     prime := prime->collect(true) ; 
    execute SieveOfEratosthenes(prime, n + 1) ; 
    var i : int ;
    var j : int ;
    var m : Map(int,int) ; m := Map{} ;
        i := 0 ; while i < n do ( (     if (m->keys()->includes(arr[i+1])) then     m := m->union(Map{arr[i+1] |-> m->at(arr[i+1]) + 1}) ; else     m := m->union(Map{arr[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
    var xor : int ; xor := 0 ;
    for (entry : m->asSet()) do ( (     var key : int ; key := entry.getKey() ;
     var value : int ; value := entry.getValue() ;
     if (prime[value+1]) then (     xor := MathLib.bitwiseXor(xor,(key)) ) else skip )  ) ; 
    return xor 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,4,6,5,4,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(xorOfElements(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX_CHAR=256 ;
  public static boolean isPalindrome(String str,int l,int h){
    while(h>l)if(str.charAt(l++)!=str.charAt(h--))return false ;
    return true ;
  }
  public static boolean check(String str){
    int n=str.length();
    int[] freq=new int[MAX_CHAR];
    for(int i=0 ; i<n ; i++){
      freq[str.charAt(i)]++;
      if(freq[str.charAt(i)]>2)return true ;
    }
    int k=0 ;
    for(int i=0 ; i<n ; i++)if(freq[str.charAt(i)]>1)str.replace(str.charAt(k++),str.charAt(i));
    str.replace(str.charAt(k),'\0');
    if(isPalindrome(str,0,k-1)){
      if((k & 1)==1){
        if(k/2>=1)return(str.charAt(k/2)==str.charAt(k/2-1));
      }
      return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    String str="ABCABD" ;
    if(check(str))System.out.println("Repeated Subsequence Exists");
    else System.out.println("Repeated Subsequence"+" Doesn't Exists");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX_CHAR : int := 256;
  static   operation isPalindrome( str : String, l : int, h : int) : boolean
  pre: true
  post: true
  activity: (     while (h > l) do     if (str->at(l+1) /= str->at(h+1)) then     return false else skip ; ; 
     return true );
  static   operation check( str : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var freq : Sequence(int) ; freq := Integer.subrange(1,MAX_CHAR)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     freq[str->at(i+1)+1] := freq[str->at(i+1)+1] + 1 ; 
     if (freq[str->at(i+1)+1] > 2) then     return true else skip )  ;     i := i + 1 ) ; 
    var k : int ; k := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (freq[str->at(i+1)+1] > 1) then     str.replace(str->at(k+1), str->at(i+1)) ; else skip ;  ;     i := i + 1 ) ; 
    str.replace(str->at(k+1), '\0') ; 
    if (isPalindrome(str, 0, k - 1)) then (     if ((MathLib.bitwiseAnd(k,1)) = 1) then (     if (k / 2 >= 1) then     return (str->at(k / 2+1) = str->at(k / 2 - 1+1)) else skip ) else skip ; 
     return false ) else skip ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "ABCABD" ;
     if (check(str)) then     OclFile["System.out"].println("Repeated Subsequence Exists") ; else     OclFile["System.out"].println("Repeated Subsequence" + " Doesn't Exists") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    long A=sc.nextLong();
    if(A==3 || A==5 || A==7){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : long ; A := sc.getCurrent()->toLong() ;
     if (A = 3 or A = 5 or A = 7) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Main {
  private static PrintWriter out ;
  public static void main(String[] args){
    Main main=new Main();
    try {
      main.run(args);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  private void run(String[] arguments)throws Exception {
    MyScanner sc=new MyScanner();
    out=new PrintWriter(new BufferedOutputStream(System.out));
    int n=sc.nextInt();
    if(n==3 || n==5 || n==7){
      out.println("YES");
    }
    else {
      out.println("NO");
    }
    out.flush();
    out.close();
  }
  private class MyScanner {
    BufferedReader br ;
    StringTokenizer st ;
    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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     try (     main.run(args) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
   operation run( arguments : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var n : int ; n := sc.nextInt() ;
    if (n = 3 or n = 5 or n = 7) then (     skip ) else (     skip ) ;  
    skip ; 
    skip ; 
 );
 class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.InputStreamReader ;
import java.io.BufferedReader ;
import java.util.Arrays ;
import java.util.ArrayList ;
import java.util.ArrayDeque ;
import java.util.Deque ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    if(n==3 || n==5 || n==7){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
     if (n = 3 or n = 5 or n = 7) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=Integer.parseInt(sc.next());
    System.out.println((x==7 || x==5 || x==3)? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := (sc.getCurrent())->toInteger() ;
     OclFile["System.out"].println(if (x = 7 or x = 5 or x = 3) then "YES" else "NO" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String ans="NO" ;
    if(n==7 || n==5 || n==3)ans="YES" ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : String ; ans := "NO" ;
    if (n = 7 or n = 5 or n = 3) then     ans := "YES" ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static int cubesum(int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=(2*i+1)*(2*i+1)*(2*i+1);
    return sum ;
  }
  public static void main(String args[]){
    int a=5 ;
    System.out.println(cubesum(a));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation cubesum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+((2 * i + 1) * (2 * i + 1) * (2 * i + 1)) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 5 ;
     OclFile["System.out"].println(cubesum(a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int nthXorFib(int n,int a,int b){
    if(n==0)return a ;
    if(n==1)return b ;
    if(n==2)return(a ^ b);
    return nthXorFib(n % 3,a,b);
  }
  public static void main(String[] args){
    int a=1,b=2,n=10 ;
    System.out.println(nthXorFib(n,a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nthXorFib( n : int, a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return a else skip ; 
     if (n = 1) then     return b else skip ; 
     if (n = 2) then     return (a xor b) else skip ; 
     return nthXorFib(n mod 3, a, b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 1 ;
    var b : int ; b := 2 ;
    var n : int ; n := 10 ;
     OclFile["System.out"].println(nthXorFib(n, a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static int cubesum(int n){
    int sum=0 ;
    for(int i=1 ; i<=n ; i++)sum+=(2*i)*(2*i)*(2*i);
    return sum ;
  }
  public static void main(String args[]){
    int a=8 ;
    System.out.println(cubesum(a));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation cubesum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do (     sum := sum+((2 * i) * (2 * i) * (2 * i)) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 8 ;
     OclFile["System.out"].println(cubesum(a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int m=Integer.parseInt(sc.next());
    int k=Integer.parseInt(sc.next());
    sc.nextLine();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(sc.next());
    }
    int left=m-2 ;
    int right=m ;
    int res=101 ;
    for(int i=left ; i>=0 ; i--){
      if(arr[i]>0 && arr[i]<=k){
        res=(m-i-1);
        break ;
      }
    }
    for(int i=right ; i<n ; i++){
      if(arr[i]>0 && arr[i]<=k){
        res=Math.min(res,i-m+1);
        break ;
      }
    }
    System.out.println(res*10);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var m : int ; m := (sc.getCurrent())->toInteger() ;
    var k : int ; k := (sc.getCurrent())->toInteger() ;
    skip ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var left : int ; left := m - 2 ;
    var right : int ; right := m ;
    var res : int ; res := 101 ;
        var i : int ; i := left ; while i >= 0 do ( (     if (arr[i+1] > 0 & arr[i+1] <= k) then (     res := (m - i - 1) ; 
     break ) else skip )  ;     i := i - 1 ) ; 
        var i : int ; i := right ; while i < n do ( (     if (arr[i+1] > 0 & arr[i+1] <= k) then (     res := Set{res, i - m + 1}->min() ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res * 10) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int A1=scanner.nextInt();
    int A2=scanner.nextInt();
    int A3=scanner.nextInt();
    if(A1+A2+A3>=22){
      System.out.println("bust");
    }
    else {
      System.out.println("win");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A1 : int ; A1 := scanner.getCurrent()->toInteger() ;
    var A2 : int ; A2 := scanner.getCurrent()->toInteger() ;
    var A3 : int ; A3 := scanner.getCurrent()->toInteger() ;
    if (A1 + A2 + A3 >= 22) then (     OclFile["System.out"].println("bust") ) else (     OclFile["System.out"].println("win") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ABuyingAHouse solver=new ABuyingAHouse();
    solver.solve(1,in,out);
    out.close();
  }
  static class ABuyingAHouse {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt(),m=in.nextInt(),k=in.nextInt();
      int[] a=new int[n];
      int dist=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; i++){
        int price=in.nextInt();
        if(price==0 || price>k)continue ;
        dist=Math.min(dist,Math.abs(i+1-m));
      }
      out.println(dist*10);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ABuyingAHouse ; solver := ABuyingAHouse.newABuyingAHouse() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ABuyingAHouse {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var dist : int ; dist := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     var price : int ; price := in.getCurrent()->toInteger() ;
     if (price = 0 or price > k) then     continue else skip ; 
     dist := Set{dist, if i + 1 - m < 0 then -(i + 1 - m) else i + 1 - m endif}->min() )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A796 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int houseNumber=scanner.nextInt();
    int crushHouse=scanner.nextInt()-1 ;
    int money=scanner.nextInt();
    int[] price=new int[houseNumber];
    for(int i=0 ; i<houseNumber ; i++){
      price[i]=scanner.nextInt();
    }
    int distance=leastDistance(money,crushHouse,price)*10 ;
    System.out.println(distance);
  }
  private static int leastDistance(int money,int destination,int[] prices){
    int minimumDistance=10000 ;
    for(int i=0 ; i<prices.length ; i++){
      if(prices[i]>0 && prices[i]<=money && Math.abs(destination-i)<minimumDistance){
        minimumDistance=Math.abs(destination-i);
      }
    }
    return minimumDistance ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A796 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var houseNumber : int ; houseNumber := scanner.getCurrent()->toInteger() ;
    var crushHouse : int ; crushHouse := scanner.getCurrent()->toInteger() - 1 ;
    var money : int ; money := scanner.getCurrent()->toInteger() ;
    var price : Sequence(int) ; price := Integer.subrange(1,houseNumber)->collect(0) ;
        var i : int ; i := 0 ; while i < houseNumber do ( (     price[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var distance : int ; distance := leastDistance(money, crushHouse, price) * 10 ;
    OclFile["System.out"].println(distance) ; 
 );
  static   operation leastDistance( money : int, destination : int, prices : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var minimumDistance : int ; minimumDistance := 10000 ;
         var i : int ; i := 0 ; while i < prices->size() do ( (     if (prices[i+1] > 0 & prices[i+1] <= money & if destination - i < 0 then -(destination - i) else destination - i endif < minimumDistance) then (     minimumDistance := if destination - i < 0 then -(destination - i) else destination - i endif ) else skip )  ;     i := i + 1 ) ; 
     return minimumDistance );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
import java.io.*;
public class test {
  int a[];
  Scanner sc=new Scanner(System.in);
  PrintWriter pr=new PrintWriter(System.out,true);
  public static void main(String...args){
    test c=new test();
    c.prop();
  }
  public void prop(){
    int n,m,k,x=0,y=0 ;
    n=sc.nextInt();
    m=sc.nextInt();
    k=sc.nextInt();
    a=new int[n+1];
    a[0]=0 ;
    for(int i=1 ; i<=n ; ++i){
      a[i]=sc.nextInt();
    }
    x=-1 ;
    y=-1 ;
    for(int i=m-1 ; i>=1 ; --i){
      if(k>=a[i] && a[i]!=0){
        x=i ;
        break ;
      }
      if(i==1)x=-1 ;
    }
    for(int i=m+1 ; i<=n ; ++i){
      if(k>=a[i] && a[i]!=0){
        y=i ;
        break ;
      }
      if(i==n)y=-1 ;
    }
    if(x==-1)pr.println((y-m)*10);
    else if(y==-1)pr.println((m-x)*10);
    else {
      x=m-x ;
      y=y-m ;
      if(y>=x)pr.println(x*10);
      else pr.println(y*10);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
   attribute a : Sequence(int);
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute pr : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], true);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var c : test ; c := test.newtest() ;
     c.prop() );
   operation prop() : void
  pre: true
  post: true
  activity: (     var n : int ;
    var m : int ;
    var k : int ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
     n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
    k := sc.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,n + 1)->collect(0) ; 
    a[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    x := -1 ; 
    y := -1 ; 
        var i : int ; i := m - 1 ; while i >= 1 do ( (     if (k >= a[i+1] & a[i+1] /= 0) then (     x := i ; 
     break ) else skip ; 
     if (i = 1) then     x := -1 ; else skip )  ;     i := i - 1 ) ; 
        var i : int ; i := m + 1 ; while i <= n do ( (     if (k >= a[i+1] & a[i+1] /= 0) then (     y := i ; 
     break ) else skip ; 
     if (i = n) then     y := -1 ; else skip )  ;     i := i + 1 ) ; 
    if (x = -1) then     skip else     if (y = -1) then     skip else (     x := m - x ; 
     y := y - m ; 
     if (y >= x) then     skip ; else     skip ; ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  static int MOD=1000000007 ;
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=1 ;
    while(t-->0){
      solve(s);
    }
  }
  public static void solve(Scanner s){
    int n=s.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=s.nextInt();
    }
    int m=s.nextInt();
    int[] b=new int[m];
    for(int i=0 ; i<m ; i++){
      b[i]=s.nextInt();
    }
    int ans=0 ;
    List<Integer>ratios=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(b[j] % a[i]==0)ratios.add(b[j]/a[i]);
      }
    }
    Collections.sort(ratios);
    int largest=Collections.max(ratios);
    for(int i=ratios.size()-1 ; i>=0 ; i--){
      if(ratios.get(i)==largest)ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve(s) ) ;  ) );
  static   operation solve( s : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := s.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var ratios : Sequence(int) ; ratios := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (b[j+1] mod a[i+1] = 0) then     ratios := ratios->including(b[j+1] / a[i+1]) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    ratios := ratios->sort() ; 
    var largest : int ; largest := .max(ratios) ;
        var i : int ; i := ratios->size() - 1 ; while i >= 0 do ( (     if (ratios->at(i+1) = largest) then     ans := ans + 1 ; else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    int m=sc.nextInt();
    int[] b=new int[m];
    for(int i=0 ; i<m ; i++){
      b[i]=sc.nextInt();
    }
    int count=0 ;
    int max=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(b[j] % a[i]==0){
          int val=b[j]/a[i];
          if(val>max){
            max=val ;
            count=1 ;
          }
          else if(val==max){
            count++;
          }
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (b[j+1] mod a[i+1] = 0) then (     var val : int ; val := b[j+1] / a[i+1] ;
     if (val > max) then (     max := val ; 
     count := 1 ) else     if (val = max) then (     count := count + 1 ) else skip ; ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.OutputStream ;
import java.io.PrintStream ;
import java.util.*;
public class P215A {
  public static void main(String[] args)throws Exception {
    new P215A().run();
  }
  void run()throws Exception {
    Scanner scanner=new Scanner(getInputStream());
    int n=scanner.nextInt();
    int[] as=new int[n];
    for(int i=0 ; i<n ; i++){
      as[i]=scanner.nextInt();
    }
    int m=scanner.nextInt();
    int[] bs=new int[m];
    for(int i=0 ; i<m ; i++){
      bs[i]=scanner.nextInt();
    }
    int max=Integer.MIN_VALUE ;
    int count=0 ;
    for(int a : as){
      for(int b : bs){
        if(b % a!=0){
          continue ;
        }
        int rat=b/a ;
        if(rat<max){
          continue ;
        }
        if(rat==max){
          count++;
        }
        if(rat>max){
          count=1 ;
          max=rat ;
        }
      }
    }
    getOutputStream().println(count);
  }
  InputStream getInputStream(){
    return System.in ;
  }
  PrintStream getOutputStream(){
    return System.out ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class P215A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     P215A.newP215A().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(getInputStream()) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var as : Sequence(int) ; as := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     as[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var bs : Sequence(int) ; bs := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     bs[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
    var count : int ; count := 0 ;
    for (a : as) do ( (     for (b : bs) do ( (     if (b mod a /= 0) then (     continue ) else skip ; 
     var rat : int ; rat := b / a ;
    if (rat < max) then (     continue ) else skip ; 
    if (rat = max) then (     count := count + 1 ) else skip ; 
    if (rat > max) then (     count := 1 ; 
     max := rat ) else skip ; 
 )  ) )  ) ; 
    getOutputStream().println(count) ; 
 );
   operation getInputStream() : OclFile
  pre: true
  post: true
  activity: (     return OclFile["System.in"] );
   operation getOutputStream() : OclFile
  pre: true
  post: true
  activity: (     return OclFile["System.out"] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class code {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    int max=0,count=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    int m=sc.nextInt();
    int[] arrb=new int[m];
    for(int i=0 ; i<m ; i++){
      arrb[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(arrb[j] % arr[i]==0){
          if(max<arrb[j]/arr[i]){
            max=arrb[j]/arr[i];
            count=1 ;
          }
          else if(max==arrb[j]/arr[i]){
            count++;
          }
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arrb : Sequence(int) ; arrb := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     arrb[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (arrb[j+1] mod arr[i+1] = 0) then (     if (max < arrb[j+1] / arr[i+1]) then (     max := arrb[j+1] / arr[i+1] ; 
     count := 1 ) else     if (max = arrb[j+1] / arr[i+1]) then (     count := count + 1 ) else skip ; ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String card1,card2 ;
    int player1=0,player2=0 ;
    for(int i=0 ; i<n ; i++){
      card1=sc.next();
      card2=sc.next();
      if(card1.compareTo(card2)>=1){
        player1+=3 ;
      }
      else if(card1.compareTo(card2)<=-1){
        player2+=3 ;
      }
      else if(card1.compareTo(card2)==0){
        player1++;
        player2++;
      }
    }
    System.out.println(player1+" "+player2);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var card1 : String ;
    var card2 : String ;
    var player1 : int ; player1 := 0 ;
    var player2 : int ; player2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     card1 := sc.getCurrent() ; 
     card2 := sc.getCurrent() ; 
     if (card1->compareTo(card2) >= 1) then (     player1 := player1+(3) ) else     if (card1->compareTo(card2) <= -1) then (     player2 := player2+(3) ) else     if (card1->compareTo(card2) = 0) then (     player1 := player1 + 1 ; 
     player2 := player2 + 1 ) else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(player1 + " " + player2) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int INT_MAX=Integer.MAX_VALUE ;
  static int min_index(int p[],int n){
    int ans=0 ;
    int mini=INT_MAX ;
    for(int i=0 ; i<n ; i++){
      if(p[i]<=mini)mini=p[i];
      if(mini==p[i])ans++;
    }
    return ans ;
  }
  public static void main(String[] args){
    int P[]={
      4,2,5,1,3 };
      int n=P.length ;
      System.out.println(min_index(P,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute INT_MAX : int := 2147483647;
  static   operation min_index( p : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var mini : int ; mini := INT_MAX ;
         var i : int ; i := 0 ; while i < n do ( (     if (p[i+1] <= mini) then     mini := p[i+1] ; else skip ; 
     if (mini = p[i+1]) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var P : Sequence(int) ; P := Sequence{4,2,5,1,3} ;
     var n : int ; n := P->size() ;
     OclFile["System.out"].println(min_index(P, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class RepeatElement {
  void printRepeating(int arr[],int size){
    int xor=arr[0];
    int set_bit_no ;
    int i ;
    int n=size-2 ;
    int x=0,y=0 ;
    for(i=1 ; i<size ; i++)xor ^=arr[i];
    for(i=1 ; i<=n ; i++)xor ^=i ;
    set_bit_no=(xor & ~(xor-1));
    for(i=0 ; i<size ; i++){
      int a=arr[i] & set_bit_no ;
      if(a!=0)x=x ^ arr[i];
      else y=y ^ arr[i];
    }
    for(i=1 ; i<=n ; i++){
      int a=i & set_bit_no ;
      if(a!=0)x=x ^ i ;
      else y=y ^ i ;
    }
    System.out.println("The two reppeated elements are :");
    System.out.println(x+" "+y);
  }
  public static void main(String[] args){
    RepeatElement repeat=new RepeatElement();
    int arr[]={
      4,2,4,5,2,3,1 };
      int arr_size=arr.length ;
      repeat.printRepeating(arr,arr_size);
    }
  }

------------------------------------------------------------
OCL File:
---------
class RepeatElement {
   operation printRepeating( arr : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (     var xor : int ; xor := arr[0+1] ;
     var set_bit_no : int ;
    var i : int ;
    var n : int ; n := size - 2 ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
        i := 1 ; while i < size do (     xor := MathLib.bitwiseXor(xor,arr[i+1]) ;  ;     i := i + 1 ) ; 
        i := 1 ; while i <= n do (     xor := MathLib.bitwiseXor(xor,i) ;  ;     i := i + 1 ) ; 
    set_bit_no := (MathLib.bitwiseAnd(xor,-((xor - 1) + 1))) ; 
        i := 0 ; while i < size do ( (     var a : int ; a := MathLib.bitwiseAnd(arr[i+1],set_bit_no) ;
     if (a /= 0) then     x := MathLib.bitwiseXor(x,arr[i+1]) ; else     y := MathLib.bitwiseXor(y,arr[i+1]) ; )  ;     i := i + 1 ) ; 
        i := 1 ; while i <= n do ( (     var a : int ; a := MathLib.bitwiseAnd(i,set_bit_no) ;
     if (a /= 0) then     x := MathLib.bitwiseXor(x,i) ; else     y := MathLib.bitwiseXor(y,i) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("The two reppeated elements are :") ; 
    OclFile["System.out"].println(x + " " + y) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var repeat : RepeatElement ; repeat := RepeatElement.newRepeatElement() ;
     var arr : Sequence(int) ; arr := Sequence{4,2,4,5,2,3,1} ;
     var arr_size : int ; arr_size := arr->size() ;
     repeat.printRepeating(arr, arr_size) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] posArr=br.readLine().split(" ");
    int atox=Math.max(Integer.parseInt(posArr[0]),Integer.parseInt(posArr[1]))-Math.min(Integer.parseInt(posArr[0]),Integer.parseInt(posArr[1]));
    int btox=Math.max(Integer.parseInt(posArr[0]),Integer.parseInt(posArr[2]))-Math.min(Integer.parseInt(posArr[0]),Integer.parseInt(posArr[2]));
    if(atox>btox){
      System.out.println("B");
    }
    else {
      System.out.println("A");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var posArr : Sequence(String) ; posArr := br.readLine()->split(" ") ;
    var atox : int ; atox := Set{(posArr[0+1])->toInteger(), (posArr[1+1])->toInteger()}->max() - Set{(posArr[0+1])->toInteger(), (posArr[1+1])->toInteger()}->min() ;
    var btox : int ; btox := Set{(posArr[0+1])->toInteger(), (posArr[2+1])->toInteger()}->max() - Set{(posArr[0+1])->toInteger(), (posArr[2+1])->toInteger()}->min() ;
    if (atox > btox) then (     OclFile["System.out"].println("B") ) else (     OclFile["System.out"].println("A") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int arr[]={
    100,1000,100,1000,1 };
    static int sum[]=new int[10000];
    static int maxSumWO3Consec(int n){
      if(sum[n]!=-1)return sum[n];
      if(n==0)return sum[n]=0 ;
      if(n==1)return sum[n]=arr[0];
      if(n==2)return sum[n]=arr[1]+arr[0];
      return sum[n]=Math.max(Math.max(maxSumWO3Consec(n-1),maxSumWO3Consec(n-2)+arr[n-1]),arr[n-2]+arr[n-1]+maxSumWO3Consec(n-3));
    }
    public static void main(String[] args){
      int n=arr.length ;
      Arrays.fill(sum,-1);
      System.out.println(maxSumWO3Consec(n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute arr : int := Sequence{100,1000,100,1000,1};
  static   attribute sum : int := Integer.subrange(1,10000)->collect(0);
  static   operation maxSumWO3Consec( n : int) : int
  pre: true
  post: true
  activity: (     if (sum[n+1] /= -1) then     return sum[n+1] else skip ; 
     if (n = 0) then     return sum[n+1] else skip ; 
    if (n = 1) then     return sum[n+1] else skip ; 
    if (n = 2) then     return sum[n+1] else skip ; 
    return sum[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
     sum := sum->collect(-1) ; 
     OclFile["System.out"].println(maxSumWO3Consec(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=false ;
  private static PrintWriter _out=new PrintWriter(System.out);
  private static PrintWriter _err=new PrintWriter(System.err);
  private void solve(Scanner sc){
    int x=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(Math.abs(x-a)<Math.abs(x-b)){
      _out.println("A");
    }
    else {
      _out.println("B");
    }
  }
  private static BigInteger C(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    for(long i=r ; i>1 ; --i){
      res=res.divide(BigInteger.valueOf(i));
    }
    return res ;
  }
  private static BigInteger P(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    return res ;
  }
  public static void main(String[] args){
    long S=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    new Main().solve(sc);
    _out.flush();
    long G=System.currentTimeMillis();
    if(elapsed){
      _err.println((G-S)+"ms");
    }
    _err.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := false;
  static   attribute _out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute _err : OclFile := OclFile.newOclFile_Write(OclFile["System.err"]);
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var x : int ; x := sc.nextInt() ;
     var a : int ; a := sc.nextInt() ;
     var b : int ; b := sc.nextInt() ;
     if (if x - a < 0 then -(x - a) else x - a endif < if x - b < 0 then -(x - b) else x - b endif) then (     skip ) else (     skip ) );
  static   operation C( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
         var i : long ; i := r ; while i > 1 do ( (     res := res.divide((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation P( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    Main.newMain().solve(sc) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    String result="B" ;
    if(Math.abs(x-a)<Math.abs(x-b))result="A" ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var result : String ; result := "B" ;
    if (if x - a < 0 then -(x - a) else x - a endif < if x - b < 0 then -(x - b) else x - b endif) then     result := "A" ; else skip ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int x=in.nextInt();
      int a=in.nextInt();
      int b=in.nextInt();
      int c=Math.abs(x-a);
      int d=Math.abs(b-x);
      if(c<d){
        out.print("A");
      }
      else {
        out.print("B");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var x : int ; x := in.getCurrent()->toInteger() ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := if x - a < 0 then -(x - a) else x - a endif ;
    var d : int ; d := if b - x < 0 then -(b - x) else b - x endif ;
    if (c < d) then (     skip ) else (     skip ) ;  
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int x=Integer.parseInt(st.nextToken());
    int a=Integer.parseInt(st.nextToken());
    int b=Integer.parseInt(st.nextToken());
    if(Math.abs(x-a)<Math.abs(x-b))System.out.println("A");
    else System.out.println("B");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var x : int ; x := (st.next())->toInteger() ;
    var a : int ; a := (st.next())->toInteger() ;
    var b : int ; b := (st.next())->toInteger() ;
    if (if x - a < 0 then -(x - a) else x - a endif < if x - b < 0 then -(x - b) else x - b endif) then     OclFile["System.out"].println("A") else     OclFile["System.out"].println("B") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class Node {
    int data ;
    Node next ;
  };
  static Node push(Node head_ref,int data){
    Node ptr1=new Node();
    Node temp=head_ref ;
    ptr1.data=data ;
    ptr1.next=head_ref ;
    if(head_ref!=null){
      while(temp.next!=head_ref)temp=temp.next ;
      temp.next=ptr1 ;
    }
    else ptr1.next=ptr1 ;
    head_ref=ptr1 ;
    return head_ref ;
  }
  static int sumOfList(Node head){
    Node temp=head ;
    int sum=0 ;
    if(head!=null){
      do {
        temp=temp.next ;
        sum+=temp.data ;
      }
      while(temp!=head);
    }
    return sum ;
  }
  public static void main(String args[]){
    Node head=null ;
    head=push(head,12);
    head=push(head,56);
    head=push(head,2);
    head=push(head,11);
    System.out.println("Sum of Circular linked"+" list is="+sumOfList(head));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   operation push( head_ref : Node, data : int) : Node
  pre: true
  post: true
  activity: (     var ptr1 : Node ; ptr1 := Node.newNode() ;
     var temp : Node ; temp := head_ref ;
    ptr1.data := data ; 
    ptr1.next := head_ref ; 
    if (head_ref /= null) then (     while (temp.next /= head_ref) do     temp := temp.next ; ; 
     temp.next := ptr1 ) else     ptr1.next := ptr1 ; ;  
    head_ref := ptr1 ; 
    return head_ref 
 );
  static   operation sumOfList( head : Node) : int
  pre: true
  post: true
  activity: (     var temp : Node ; temp := head ;
     var sum : int ; sum := 0 ;
     if (head /= null) then (   while true do ((     temp := temp.next ; 
     sum := sum+(temp.data) ) ;
    if (temp /= head) then skip else break) ) else skip ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := null ;
     head := push(head, 12) ; 
    head := push(head, 56) ; 
    head := push(head, 2) ; 
    head := push(head, 11) ; 
    OclFile["System.out"].println("Sum of Circular linked" + " list is=" + sumOfList(head)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class SymmetricPairs {
  static void findSymPairs(int arr[][]){
    HashMap<Integer,Integer>hM=new HashMap<Integer,Integer>();
    for(int i=0 ; i<arr.length ; i++){
      int first=arr[i][0];
      int sec=arr[i][1];
      Integer val=hM.get(sec);
      if(val!=null && val==first)System.out.println("("+sec+","+first+")");
      else hM.put(first,sec);
    }
  }
  public static void main(String arg[]){
    int arr[][]=new int[5][2];
    arr[0][0]=11 ;
    arr[0][1]=20 ;
    arr[1][0]=30 ;
    arr[1][1]=40 ;
    arr[2][0]=5 ;
    arr[2][1]=10 ;
    arr[3][0]=40 ;
    arr[3][1]=30 ;
    arr[4][0]=10 ;
    arr[4][1]=5 ;
    findSymPairs(arr);
  }
}
------------------------------------------------------------
OCL File:
---------
 class SymmetricPairs {
  static   operation findSymPairs( arr : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var hM : Map(int,int) ; hM := Map{} ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     var first : int ; first := arr[i+1][0+1] ;
     var sec : int ; sec := arr[i+1][1+1] ;
     var val : int ; val := hM->at(sec) ;
     if (val /= null & val = first) then     OclFile["System.out"].println("(" + sec + "," + first + ")") ; else     hM := hM->union(Map{first |-> sec}) ; )  ;     i := i + 1 ) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,5)->collect(Integer.subrange(1,2)->collect(0)) ;
     arr[0+1][0+1] := 11 ; 
    arr[0+1][1+1] := 20 ; 
    arr[1+1][0+1] := 30 ; 
    arr[1+1][1+1] := 40 ; 
    arr[2+1][0+1] := 5 ; 
    arr[2+1][1+1] := 10 ; 
    arr[3+1][0+1] := 40 ; 
    arr[3+1][1+1] := 30 ; 
    arr[4+1][0+1] := 10 ; 
    arr[4+1][1+1] := 5 ; 
    execute findSymPairs(arr) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
enum Type {
  SAME,A_BIG,B_BIG };
  public class Main {
    public static final int BIG_NUM=2000000000 ;
    public static final int MOD=1000000007 ;
    public static void main(String[] args){
      Scanner scanner=new Scanner(System.in);
      int N=scanner.nextInt();
      String TARO,HANAKO ;
      int score_TARO=0,score_HANAKO=0 ;
      for(int loop=0 ; loop<N ; loop++){
        TARO=scanner.next();
        HANAKO=scanner.next();
        switch(compString(TARO,HANAKO)){
          case SAME : score_TARO+=1 ;
          score_HANAKO+=1 ;
          break ;
          case A_BIG : score_TARO+=3 ;
          break ;
          case B_BIG : score_HANAKO+=3 ;
          break ;
        }
      }
      System.out.printf("%d %d\n",score_TARO,score_HANAKO);
    }
    public static Type compString(String A,String B){
      int a_index=0,b_index=0 ;
      while(a_index<A.length()&& b_index<B.length()&& A.charAt(a_index)==B.charAt(b_index)){
        a_index++;
        b_index++;
      }
      if(a_index<A.length()&& b_index<B.length()){
        if(A.charAt(a_index)>B.charAt(b_index)){
          return Type.A_BIG ;
        }
        else {
          return Type.B_BIG ;
        }
      }
      else if(a_index<A.length()&& b_index==B.length()){
        return Type.A_BIG ;
      }
      else if(a_index==A.length()&& b_index<B.length()){
        return Type.B_BIG ;
      }
      else {
        return Type.SAME ;
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
   enumeration Type {  literal SAME;  literal A_BIG;  literal B_BIG }
;class Main {
  static    attribute BIG_NUM : int := 2000000000;
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var TARO : String ;
    var HANAKO : String ;
    var score_TARO : int ; score_TARO := 0 ;
    var score_HANAKO : int ; score_HANAKO := 0 ;
        var loop : int ; loop := 0 ; while loop < N do ( (     TARO := scanner.getCurrent() ; 
     HANAKO := scanner.getCurrent() ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (compString(TARO, HANAKO)) ; 
       if _switchval = SAME then
     score_TARO := score_TARO+(1) ; 
    score_HANAKO := score_HANAKO+(1) ; 
    break 
   else skip ;
       if _switchval = A_BIG then
     score_TARO := score_TARO+(3) ; 
    break 
   else skip ;
       if _switchval = B_BIG then
     score_HANAKO := score_HANAKO+(3) ; 
    break 
   else skip ;
 )
 )  ;     loop := loop + 1 ) ; 
    OclFile["System.out"].printf("%d %d\n", score_TARO, score_HANAKO) ; 
 );
  static   operation compString( A : String, B : String) : Type
  pre: true
  post: true
  activity: (     var a_index : int ; a_index := 0 ;
    var b_index : int ; b_index := 0 ;
     while (a_index < A->size() & b_index < B->size() & A->at(a_index+1) = B->at(b_index+1)) do (     a_index := a_index + 1 ; 
     b_index := b_index + 1 ) ; 
     if (a_index < A->size() & b_index < B->size()) then (     if (A->at(a_index+1) > B->at(b_index+1)) then (     return Type.A_BIG ) else (     return Type.B_BIG ) ) else     if (a_index < A->size() & b_index = B->size()) then (     return Type.A_BIG ) else     if (a_index = A->size() & b_index < B->size()) then (     return Type.B_BIG ) else (     return Type.SAME ) ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int Divisible(int arr[],int n){
    int count_even=0 ;
    for(int i=0 ; i<n ; i++)if(arr[i] % 2==0)count_even++;
    return count_even+(n-count_even)/2 ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5 };
      int n=arr.length ;
      System.out.println(Divisible(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Divisible( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count_even : int ; count_even := 0 ;
         var i : int ; i := 0 ; while i < n do (     if (arr[i+1] mod 2 = 0) then     count_even := count_even + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return count_even + (n - count_even) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(Divisible(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void solve(int interval[][],int N,int Q){
    int Mark[]=new int[Q];
    for(int i=0 ; i<N ; i++){
      int l=interval[i][0]-1 ;
      int r=interval[i][1]-1 ;
      for(int j=l ; j<=r ; j++)Mark[j]++;
    }
    int count=0 ;
    for(int i=0 ; i<Q ; i++){
      if(Mark[i]!=0)count++;
    }
    int count1[]=new int[Q];
    if(Mark[0]==1)count1[0]=1 ;
    for(int i=1 ; i<Q ; i++){
      if(Mark[i]==1)count1[i]=count1[i-1]+1 ;
      else count1[i]=count1[i-1];
    }
    int maxindex=0 ;
    int maxcoverage=0 ;
    for(int i=0 ; i<N ; i++){
      int l=interval[i][0]-1 ;
      int r=interval[i][1]-1 ;
      int elem1 ;
      if(l!=0)elem1=count1[r]-count1[l-1];
      else elem1=count1[r];
      if(count-elem1>=maxcoverage){
        maxcoverage=count-elem1 ;
        maxindex=i ;
      }
    }
    System.out.println("Maximum Coverage is "+maxcoverage+" after removing interval at index "+maxindex);
  }
  public static void main(String[] args){
    int interval[][]={
      {
        1,4 },{
          4,5 },{
            5,6 },{
              6,7 },{
                3,5 }
              };
              int N=interval.length ;
              int Q=7 ;
              solve(interval,N,Q);
            }
          }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( interval : Sequence(Sequence(int)), N : int, Q : int) : void
  pre: true
  post: true
  activity: (     var Mark : Sequence(int) ; Mark := Integer.subrange(1,Q)->collect(0) ;
         var i : int ; i := 0 ; while i < N do ( (     var l : int ; l := interval[i+1][0+1] - 1 ;
     var r : int ; r := interval[i+1][1+1] - 1 ;
         var j : int ; j := l ; while j <= r do (     Mark[j+1] := Mark[j+1] + 1 ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < Q do ( (     if (Mark[i+1] /= 0) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    var count1 : Sequence(int) ; count1 := Integer.subrange(1,Q)->collect(0) ;
    if (Mark[0+1] = 1) then     count1[0+1] := 1 ; else skip ; 
        var i : int ; i := 1 ; while i < Q do ( (     if (Mark[i+1] = 1) then     count1[i+1] := count1[i - 1+1] + 1 ; else     count1[i+1] := count1[i - 1+1] ; )  ;     i := i + 1 ) ; 
    var maxindex : int ; maxindex := 0 ;
    var maxcoverage : int ; maxcoverage := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var l : int ; l := interval[i+1][0+1] - 1 ;
     var r : int ; r := interval[i+1][1+1] - 1 ;
    var elem1 : int ;
    if (l /= 0) then     elem1 := count1[r+1] - count1[l - 1+1] else     elem1 := count1[r+1] ; ;  
    if (count - elem1 >= maxcoverage) then (     maxcoverage := count - elem1 ; 
     maxindex := i ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Maximum Coverage is " + maxcoverage + " after removing interval at index " + maxindex) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var interval : Sequence(Sequence(int)) ; interval := Sequence{Sequence{1,4},Sequence{4,5},Sequence{5,6},Sequence{6,7},Sequence{3,5}} ;
     var N : int ; N := interval->size() ;
     var Q : int ; Q := 7 ;
     execute solve(interval, N, Q) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static void convertOpposite(StringBuffer str){
    int ln=str.length();
    for(int i=0 ; i<ln ; i++){
      Character c=str.charAt(i);
      if(Character.isLowerCase(c))str.replace(i,i+1,Character.toUpperCase(c)+"");
      else str.replace(i,i+1,Character.toLowerCase(c)+"");
    }
  }
  public static void main(String[] args){
    StringBuffer str=new StringBuffer("GeEkSfOrGeEkS");
    convertOpposite(str);
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation convertOpposite( str : String) : void
  pre: true
  post: true
  activity: (     var ln : int ; ln := str->size() ;
         var i : int ; i := 0 ; while i < ln do ( (     var c : String ; c := str->at(i+1) ;
     if ((c->toLowerCase() = c)) then     str.replace(i, i + 1, (c + "")->toUpperCase() + "") ; else     str.replace(i, i + 1, (c + "")->toLowerCase() + "") ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := StringLib.newString("GeEkSfOrGeEkS") ;
     execute convertOpposite(str) ; 
     OclFile["System.out"].println(str) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int search(int arr[],int n,int x){
    int i ;
    for(i=0 ; i<n ; i++){
      if(arr[i]==x){
        return i ;
      }
    }
    return-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      1,10,30,15 };
      int x=30 ;
      int n=arr.length ;
      System.out.printf("%d is present at index %d",x,search(arr,n,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation search( arr : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
         i := 0 ; while i < n do ( (     if (arr[i+1] = x) then (     return i ) else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,10,30,15} ;
     var x : int ; x := 30 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].printf("%d is present at index %d", x, search(arr, n, x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int FindElement(int[] A,int n){
    for(int i=0 ; i<n ; i++){
      int flag=0 ;
      for(int j=0 ; j<i ; j++)if(A[j]>=A[i]){
        flag=1 ;
        break ;
      }
      for(int j=i+1 ; j<n ; j++)if(A[j]<=A[i]){
        flag=1 ;
        break ;
      }
      if(flag==0)return A[i];
    }
    return-1 ;
  }
  static public void main(String[] args){
    int[] A={
      4,3,2,5,8,6,7 };
      int n=A.length ;
      System.out.println(FindElement(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation FindElement( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var flag : int ; flag := 0 ;
         var j : int ; j := 0 ; while j < i do (     if (A[j+1] >= A[i+1]) then (     flag := 1 ; 
     break ) else skip ;  ;     j := j + 1 ) ; 
         var j : int ; j := i + 1 ; while j < n do (     if (A[j+1] <= A[i+1]) then (     flag := 1 ; 
     break ) else skip ;  ;     j := j + 1 ) ; 
     if (flag = 0) then     return A[i+1] else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{4,3,2,5,8,6,7} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].println(FindElement(A, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static char a[][];
  static int t[][];
  static int n ;
  static int k ;
  static int w=1 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    k=sc.nextInt();
    a=new char[2][n+k+10];
    t=new int[2][n+k+10];
    for(int i=0 ; i<2 ; i++){
      char c[]=sc.next().toCharArray();
      a[i][0]='X' ;
      for(int j=0 ; j<c.length ; j++){
        a[i][j+1]=c[j];
      }
    }
    if(D(0,1)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
  public static boolean D(int pos,int cur){
    if(cur>n){
      return true ;
    }
    if(a[pos][cur]=='X' || t[pos][cur]==1 || w>cur){
      return false ;
    }
    t[pos][cur]=1 ;
    w++;
    boolean T=false ;
    if(D(pos,cur-1)==true || D(1-pos,cur+k)==true || D(pos,cur+1)==true){
      T=true ;
    }
    w--;
    return T ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a : Sequence(Sequence(String));
  static   attribute t : Sequence(Sequence(int));
  static   attribute n : int;
  static   attribute k : int;
  static   attribute w : int := 1;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    k := sc.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,2)->collect(Integer.subrange(1,n + k + 10)->collect(0)) ; 
    t := Integer.subrange(1,2)->collect(Integer.subrange(1,n + k + 10)->collect(0)) ; 
        var i : int ; i := 0 ; while i < 2 do ( (     var c : Sequence(String) ; c := sc.getCurrent()->characters() ;
     a[i+1][0+1] := 'X' ; 
         var j : int ; j := 0 ; while j < c->size() do ( (     a[i+1][j + 1+1] := c[j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (D(0, 1)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
  static   operation D( pos : int, cur : int) : boolean
  pre: true
  post: true
  activity: (     if (cur > n) then (     return true ) else skip ; 
     if (a[pos+1][cur+1] = 'X' or t[pos+1][cur+1] = 1 or w > cur) then (     return false ) else skip ; 
    t[pos+1][cur+1] := 1 ; 
    w := w + 1 ; 
    var T : boolean ; T := false ;
    if (D(pos, cur - 1) = true or D(1 - pos, cur + k) = true or D(pos, cur + 1) = true) then (     T := true ) else skip ; 
    w := w - 1 ; 
    return T 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSubStr(String str,int len){
    int ans=0 ;
    for(int i=0 ; i<len ; i++){
      if(str.charAt(i)=='0')ans+=(i+1);
    }
    return ans ;
  }
  public static void main(String[] args){
    String str="10010" ;
    int len=str.length();
    System.out.println(countSubStr(str,len));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSubStr( str : String, len : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < len do ( (     if (str->at(i+1) = '0') then     ans := ans+((i + 1)) ; else skip )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "10010" ;
     var len : int ; len := str->size() ;
     OclFile["System.out"].println(countSubStr(str, len)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int highestPower(String str,int len){
    int ans=0 ;
    for(int i=len-1 ; i>=0 ; i--){
      if(str.charAt(i)=='0')ans++;
      else break ;
    }
    return ans ;
  }
  public static void main(String[] args){
    String str="100100" ;
    int len=str.length();
    System.out.println(highestPower(str,len));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation highestPower( str : String, len : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := len - 1 ; while i >= 0 do ( (     if (str->at(i+1) = '0') then     ans := ans + 1 ; else     break )  ;     i := i - 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "100100" ;
     var len : int ; len := str->size() ;
     OclFile["System.out"].println(highestPower(str, len)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countdigits(int N){
    int count=0 ;
    while(N>0){
      count++;
      N=N/10 ;
    }
    return count ;
  }
  static void cyclic(int N){
    int num=N ;
    int n=countdigits(N);
    while(true){
      System.out.println(num);
      int rem=num % 10 ;
      int dev=num/10 ;
      num=(int)((Math.pow(10,n-1))*rem+dev);
      if(num==N)break ;
    }
  }
  public static void main(String[] args){
    int N=5674 ;
    cyclic(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countdigits( N : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (N > 0) do (     count := count + 1 ; 
     N := N / 10 ) ; 
     return count );
  static   operation cyclic( N : int) : void
  pre: true
  post: true
  activity: (     var num : int ; num := N ;
     var n : int ; n := countdigits(N) ;
     while (true) do (     OclFile["System.out"].println(num) ; 
     var rem : int ; rem := num mod 10 ;
    var dev : int ; dev := num / 10 ;
    num := ((10->pow(n - 1)) * rem + dev)->oclAsType(int) ; 
    if (num = N) then     break else skip ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5674 ;
     execute cyclic(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printArr(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  static void constructArr(int pair[],int n){
    int size=(1+(int)Math.sqrt(1+8*n))/2 ;
    int[] arr=new int[size];
    arr[0]=(int)Math.sqrt((pair[0]*pair[1])/pair[size-1]);
    for(int i=1 ; i<size ; i++)arr[i]=pair[i-1]/arr[0];
    printArr(arr,size);
  }
  public static void main(String[] args){
    int pair[]={
      48,18,24,24,32,12 };
      int n=pair.length ;
      constructArr(pair,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation constructArr( pair : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var size : int ; size := (1 + (1 + 8 * n)->sqrt()->oclAsType(int)) / 2 ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
    arr[0+1] := ((pair[0+1] * pair[1+1]) / pair[size - 1+1])->sqrt()->oclAsType(int) ; 
        var i : int ; i := 1 ; while i < size do (     arr[i+1] := pair[i - 1+1] / arr[0+1] ;  ;     i := i + 1 ) ; 
    execute printArr(arr, size) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var pair : Sequence(int) ; pair := Sequence{48,18,24,24,32,12} ;
     var n : int ; n := pair->size() ;
     execute constructArr(pair, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
class Main {
  public static void main(String...args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int times=Integer.valueOf(br.readLine());
    int[] result=new int[2];
    for(int i=0 ; i<times ; i++){
      String[] animals=br.readLine().split(" ");
      if(animals[0] .compareTo(animals[1])==0){
        result[0]+=1 ;
        result[1]+=1 ;
      }
      else if(animals[0] .compareTo(animals[1])>=1){
        result[0]+=3 ;
      }
      else if(animals[0] .compareTo(animals[1])<=-1){
        result[1]+=3 ;
      }
    }
    System.out.println(result[0]+" "+result[1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var times : int ; times := (br.readLine())->toInteger() ;
    var result : Sequence(int) ; result := Integer.subrange(1,2)->collect(0) ;
        var i : int ; i := 0 ; while i < times do ( (     var animals : Sequence(String) ; animals := br.readLine()->split(" ") ;
     if (animals[0+1]->compareTo(animals[1+1]) = 0) then (     result[0+1] := result[0+1]+(1) ; 
     result[1+1] := result[1+1]+(1) ) else     if (animals[0+1]->compareTo(animals[1+1]) >= 1) then (     result[0+1] := result[0+1]+(3) ) else     if (animals[0+1]->compareTo(animals[1+1]) <= -1) then (     result[1+1] := result[1+1]+(3) ) else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result[0+1] + " " + result[1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class GrandfatherDovletsCalculator {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int[] arr={
      6,2,5,5,4,5,6,3,7,6 };
      String[] str=br.readLine().split(" ");
      int a=Integer.parseInt(str[0]);
      int b=Integer.parseInt(str[1]);
      long count=0 ;
      for(int i=a ; i<=b ; i++){
        count+=getLightingLights(i,arr);
      }
      System.out.println(count);
    }
    private static long getLightingLights(int i,int[] arr){
      long sum=0 ;
      while(i>0){
        sum+=arr[i % 10];
        i=i/10 ;
      }
      return sum ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GrandfatherDovletsCalculator {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var arr : Sequence(int) ; arr := Sequence{6,2,5,5,4,5,6,3,7,6} ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var a : int ; a := (str[0+1])->toInteger() ;
    var b : int ; b := (str[1+1])->toInteger() ;
    var count : long ; count := 0 ;
        var i : int ; i := a ; while i <= b do ( (     count := count+(getLightingLights(i, arr)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation getLightingLights( i : int, arr : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     while (i > 0) do (     sum := sum+(arr[i mod 10+1]) ; 
     i := i / 10 ) ; 
     return sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int a=sc.nextInt();
      int b=sc.nextInt();
      int ans=0 ;
      int[] temp={
        6,2,5,5,4,5,6,3,7,6 };
        for(int i=a ; i<=b ; i++){
          int t=i ;
          while(t>0){
            ans+=temp[t % 10];
            t/=10 ;
          }
        }
        System.out.println(ans);
      }
      catch(Exception e){
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    var temp : Sequence(int) ; temp := Sequence{6,2,5,5,4,5,6,3,7,6} ;
        var i : int ; i := a ; while i <= b do ( (     var t : int ; t := i ;
     while (t > 0) do (     ans := ans+(temp[t mod 10+1]) ; 
     t := t/(10) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
import java.util.Vector ;
public class grandfathercalculator {
  public static void main(String[] args){
    Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int[] arr={
      6,2,5,5,4,5,6,3,7,6 };
      int a=sc.nextInt();
      int b=sc.nextInt();
      long sum=0 ;
      for(int i=a ; i<=b ; i++){
        int s=i ;
        while(s>0){
          int rem=s % 10 ;
          sum+=arr[rem];
          s=s/10 ;
        }
      }
      System.out.println(sum);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class grandfathercalculator {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var arr : Sequence(int) ; arr := Sequence{6,2,5,5,4,5,6,3,7,6} ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := a ; while i <= b do ( (     var s : int ; s := i ;
     while (s > 0) do (     var rem : int ; rem := s mod 10 ;
     sum := sum+(arr[rem+1]) ; 
     s := s / 10 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int ara[]={
      6,2,5,5,4,5,6,3,7,6 };
      int a=in.nextInt(),b=in.nextInt();
      long sum=0 ;
      for(int i=a ; i<=b ; i++){
        int k=i ;
        while(k!=0){
          sum+=ara[k % 10];
          k=k/10 ;
        }
      }
      pw.println(sum);
      pw.close();
    }
    static void debug(Object...obj){
      System.err.println(Arrays.deepToString(obj));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var ara : Sequence(int) ; ara := Sequence{6,2,5,5,4,5,6,3,7,6} ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := a ; while i <= b do ( (     var k : int ; k := i ;
     while (k /= 0) do (     sum := sum+(ara[k mod 10+1]) ; 
     k := k / 10 ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int[] nums=new int[n+10];
      for(int i=0 ; i<n ; i++){
        nums[i]=sc.nextInt();
      }
      sc.nextLine();
      boolean flag=true ;
      String[] s=new String[n+10];
      for(int i=0 ; i<n ; i++){
        s[i]=sc.nextLine();
        int count=0 ;
        for(int j=0 ; j<s[i] .length(); j++){
          if((s[i] .charAt(j)=='a' || s[i] .charAt(j)=='e' || s[i] .charAt(j)=='i' || s[i] .charAt(j)=='o' || s[i] .charAt(j)=='u' || s[i] .charAt(j)=='y')){
            count++;
          }
        }
        if(count!=nums[i]){
          flag=false ;
        }
      }
      if(flag==true){
        System.out.println("YES");
      }
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var nums : Sequence(int) ; nums := Integer.subrange(1,n + 10)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var flag : boolean ; flag := true ;
    var s : Sequence(String) ; s := Integer.subrange(1,n + 10)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := sc.nextLine() ; 
     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < s[i+1]->size() do ( (     if ((s[i+1]->at(j+1) = 'a' or s[i+1]->at(j+1) = 'e' or s[i+1]->at(j+1) = 'i' or s[i+1]->at(j+1) = 'o' or s[i+1]->at(j+1) = 'u' or s[i+1]->at(j+1) = 'y')) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (count /= nums[i+1]) then (     flag := false ) else skip )  ;     i := i + 1 ) ; 
    if (flag = true) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector ;
class GFG {
  static Vector<Integer>deleteElement(int A[],int L,int R,int N){
    Vector<Integer>B=new Vector<>();
    for(int i=0 ; i<N ; i++){
      if(i<=L || i>=R){
        B.add(A[i]);
      }
    }
    return B ;
  }
  public static void main(String[] args){
    int A[]={
      3,5,3,4,9,3,1,6,3,11,12,3 };
      int L=2,R=7 ;
      int n=A.length ;
      Vector<Integer>res=deleteElement(A,L,R,n);
      for(Integer x : res){
        System.out.print(x+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation deleteElement( A : Sequence(int), L : int, R : int, N : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var B : Sequence(int) ; B := Sequence{} ;
         var i : int ; i := 0 ; while i < N do ( (     if (i <= L or i >= R) then (     B := B->including(A[i+1]) ) else skip )  ;     i := i + 1 ) ; 
     return B );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{3,5,3,4,9,3,1,6,3,11,12,3} ;
     var L : int ; L := 2 ;
    var R : int ; R := 7 ;
    var n : int ; n := A->size() ;
    var res : Sequence(int) ; res := deleteElement(A, L, R, n) ;
    for (x : res) do ( (     OclFile["System.out"].print(x + " ") )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int num=Integer.valueOf(s.nextLine());
    Boolean b=true ;
    String[] resultNum=s.nextLine().split(" ");
    for(int i=0 ; i<num ; i++){
      String data=s.nextLine();
      int n=solution(data);
      if(n!=Integer.valueOf(resultNum[i])){
        b=false ;
      }
    }
    if(b==true){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
  private static int solution(String data){
    char[] datas=data.toCharArray();
    int count=0 ;
    for(char c : datas){
      if(c=='a' || c=='e' || c=='i' || c=='o' || c=='u' || c=='y'){
        count++;
      }
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := (s.nextLine())->toInteger() ;
    var b : Boolean ; b := true ;
    var resultNum : Sequence(String) ; resultNum := s.nextLine()->split(" ") ;
        var i : int ; i := 0 ; while i < num do ( (     var data : String ; data := s.nextLine() ;
     var n : int ; n := solution(data) ;
     if (n /= (resultNum[i+1])->toInteger()) then (     b := false ) else skip )  ;     i := i + 1 ) ; 
    if (b = true) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
  static   operation solution( data : String) : int
  pre: true
  post: true
  activity: (     var datas : Sequence(String) ; datas := data->characters() ;
     var count : int ; count := 0 ;
     for (c : datas) do ( (     if (c = 'a' or c = 'e' or c = 'i' or c = 'o' or c = 'u' or c = 'y') then (     count := count + 1 ) else skip )  ) ; 
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[] aa=new int[n];
    for(int i=0 ; i<n ; i++){
      aa[i]=scan.nextInt();
    }
    String[] bb=new String[n];
    scan.nextLine();
    for(int i=0 ; i<n ; i++){
      bb[i]=scan.nextLine();
    }
    String[] base={
      "a","e","i","o","u","y" };
      boolean flag=true ;
      for(int i=0 ; i<n ; i++){
        int start=0 ;
        int count=0 ;
        for(int j=1 ; j<=bb[i] .length(); j++){
          if(bb[i] .substring(start,j).matches("[a-zA-Z\\s]*[aeiouy] {1}")){
            start=j-1 ;
            count++;
          }
        }
        if(count!=aa[i]){
          flag=false ;
          break ;
        }
      }
      if(flag){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var aa : Sequence(int) ; aa := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     aa[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var bb : Sequence(String) ; bb := Integer.subrange(1,n)->collect(null) ;
    skip ; 
        var i : int ; i := 0 ; while i < n do ( (     bb[i+1] := scan.nextLine() )  ;     i := i + 1 ) ; 
    var base : Sequence(String) ; base := Sequence{"a","e","i","o","u","y"} ;
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < n do ( (     var start : int ; start := 0 ;
     var count : int ; count := 0 ;
         var j : int ; j := 1 ; while j <= bb[i+1]->size() do ( (     if (bb[i+1].subrange(start+1,j)->isMatch("[a-zA-Z\\s]*[aeiouy] {1}")) then (     start := j - 1 ; 
     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (count /= aa[i+1]) then (     flag := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int[] jl=new int[n+10];
      for(int i=0 ; i<n ; i++){
        jl[i]=sc.nextInt();
      }
      sc.nextLine();
      boolean flag=true ;
      String[] s=new String[n+10];
      for(int i=0 ; i<n ; i++){
        s[i]=sc.nextLine();
        int js=0 ;
        for(int j=0 ; j<s[i] .length(); j++){
          if((s[i] .charAt(j)=='a' || s[i] .charAt(j)=='e' || s[i] .charAt(j)=='i' || s[i] .charAt(j)=='o' || s[i] .charAt(j)=='u' || s[i] .charAt(j)=='y')){
            js++;
          }
        }
        if(js!=jl[i]){
          flag=false ;
        }
      }
      if(flag==true){
        System.out.println("YES");
      }
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var jl : Sequence(int) ; jl := Integer.subrange(1,n + 10)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     jl[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var flag : boolean ; flag := true ;
    var s : Sequence(String) ; s := Integer.subrange(1,n + 10)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := sc.nextLine() ; 
     var js : int ; js := 0 ;
         var j : int ; j := 0 ; while j < s[i+1]->size() do ( (     if ((s[i+1]->at(j+1) = 'a' or s[i+1]->at(j+1) = 'e' or s[i+1]->at(j+1) = 'i' or s[i+1]->at(j+1) = 'o' or s[i+1]->at(j+1) = 'u' or s[i+1]->at(j+1) = 'y')) then (     js := js + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (js /= jl[i+1]) then (     flag := false ) else skip )  ;     i := i + 1 ) ; 
    if (flag = true) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int[] jl=new int[n+10];
      for(int i=0 ; i<n ; i++){
        jl[i]=sc.nextInt();
      }
      sc.nextLine();
      int flag=1 ;
      String[] s=new String[n+10];
      for(int i=0 ; i<n ; i++){
        s[i]=sc.nextLine();
        int js=0 ;
        for(int j=0 ; j<s[i] .length(); j++){
          if((s[i] .charAt(j)=='a' || s[i] .charAt(j)=='e' || s[i] .charAt(j)=='i' || s[i] .charAt(j)=='o' || s[i] .charAt(j)=='u' || s[i] .charAt(j)=='y')){
            js++;
          }
        }
        if(js!=jl[i]){
          flag=0 ;
        }
      }
      if(flag==1){
        System.out.println("YES");
      }
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var jl : Sequence(int) ; jl := Integer.subrange(1,n + 10)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     jl[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var flag : int ; flag := 1 ;
    var s : Sequence(String) ; s := Integer.subrange(1,n + 10)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := sc.nextLine() ; 
     var js : int ; js := 0 ;
         var j : int ; j := 0 ; while j < s[i+1]->size() do ( (     if ((s[i+1]->at(j+1) = 'a' or s[i+1]->at(j+1) = 'e' or s[i+1]->at(j+1) = 'i' or s[i+1]->at(j+1) = 'o' or s[i+1]->at(j+1) = 'u' or s[i+1]->at(j+1) = 'y')) then (     js := js + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (js /= jl[i+1]) then (     flag := 0 ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 1) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner kbd=new Scanner(System.in);
  public static void main(String[] args){
    while(kbd.hasNext()){
      int n=kbd.nextInt();
      if(n!=0)solve(n);
    }
  }
  static void solve(int n){
    int taro=0 ;
    int hana=0 ;
    String t,h ;
    while(n>0){
      t=kbd.next();
      h=kbd.next();
      int j=t.compareToIgnoreCase(h);
      if(j<0){
        hana+=3 ;
      }
      else if(j>0){
        taro+=3 ;
      }
      else {
        hana+=1 ;
        taro+=1 ;
      }
      n--;
    }
    System.out.println(taro+" "+hana);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute kbd : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (kbd.hasNext()) do (     var n : int ; n := kbd.getCurrent()->toInteger() ;
     if (n /= 0) then     execute solve(n) ; else skip ) );
  static   operation solve( n : int) : void
  pre: true
  post: true
  activity: (     var taro : int ; taro := 0 ;
     var hana : int ; hana := 0 ;
    var t : String ;
    var h : String ;
    while (n > 0) do (     t := kbd.getCurrent() ; 
     h := kbd.getCurrent() ; 
    var j : int ; j := t->toLowerCase()->compareTo(h->toLowerCase()) ;
    if (j < 0) then (     hana := hana+(3) ) else     if (j > 0) then (     taro := taro+(3) ) else (     hana := hana+(1) ; 
     taro := taro+(1) ) ;  ;  
    n := n - 1 ; 
 ) ; 
    OclFile["System.out"].println(taro + " " + hana) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int center_octadecagon_num(int n){
    return 9*n*n-9*n+1 ;
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.print(n+"th centered "+"octadecagonal number : ");
    System.out.println(center_octadecagon_num(n));
    n=13 ;
    System.out.print(n+"th centered "+"octadecagonal number : ");
    System.out.println(center_octadecagon_num(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation center_octadecagon_num( n : int) : int
  pre: true
  post: true
  activity: (     return 9 * n * n - 9 * n + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].print(n + "th centered " + "octadecagonal number : ") ; 
    OclFile["System.out"].println(center_octadecagon_num(n)) ; 
    n := 13 ; 
    OclFile["System.out"].print(n + "th centered " + "octadecagonal number : ") ; 
    OclFile["System.out"].println(center_octadecagon_num(n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countPairs(int arr1[],int arr2[],int m,int n,int x){
    int count=0 ;
    int l=0,r=n-1 ;
    while(l<m && r>=0){
      if((arr1[l]+arr2[r])==x){
        l++;
        r--;
        count++;
      }
      else if((arr1[l]+arr2[r])<x)l++;
      else r--;
    }
    return count ;
  }
  public static void main(String[] args){
    int arr1[]={
      1,3,5,7 };
      int arr2[]={
        2,3,5,8 };
        int m=arr1.length ;
        int n=arr2.length ;
        int x=10 ;
        System.out.println("Count="+countPairs(arr1,arr2,m,n,x));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPairs( arr1 : Sequence(int), arr2 : Sequence(int), m : int, n : int, x : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var l : int ; l := 0 ;
    var r : int ; r := n - 1 ;
     while (l < m & r >= 0) do (     if ((arr1[l+1] + arr2[r+1]) = x) then (     l := l + 1 ; 
     r := r - 1 ; 
     count := count + 1 ) else     if ((arr1[l+1] + arr2[r+1]) < x) then     l := l + 1 else     r := r - 1 ; ;  ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{1,3,5,7} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{2,3,5,8} ;
    var m : int ; m := arr1->size() ;
    var n : int ; n := arr2->size() ;
    var x : int ; x := 10 ;
    OclFile["System.out"].println("Count=" + countPairs(arr1, arr2, m, n, x)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long countPairs(int[] arr,int n){
    int count_2=0,count_others=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==2){
        count_2++;
      }
      else if(arr[i]>2){
        count_others++;
      }
    }
    long ans=1L*count_2*count_others+(1L*count_others*(count_others-1))/2 ;
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      5,0,3,1,2 };
      int n=arr.length ;
      System.out.println(countPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countPairs( arr : Sequence(int), n : int) : long
  pre: true
  post: true
  activity: (     var count0 : int ; count0 := 0 ;
    var count_others : int ; count_others := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 2) then (     count_2 := count_2 + 1 ) else     if (arr[i+1] > 2) then (     count_others := count_others + 1 ) else skip ; )  ;     i := i + 1 ) ; 
     var ans : long ; ans := 1L * countcountcount_others * count_others + (1L * count_others * (count_others - 1)) / 2 ;
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,0,3,1,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countPairs(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int N=1000001 ;
  static Vector<Integer>[] v=new Vector[N];
  static void preprocess(){
    for(int i=1 ; i<N ; i++){
      int num=i ;
      for(int j=2 ; j<=Math.sqrt(num); j++){
        if(num % j==0){
          v[i] .add(j);
          while(num % j==0){
            num=num/j ;
          }
        }
      }
      if(num>2)v[i] .add(num);
    }
  }
  static int query(int number,int n){
    return v[number] .get(n-1);
  }
  public static void main(String[] args){
    for(int i=0 ; i<N ; i++)v[i]=new Vector<Integer>();
    preprocess();
    int number=6,n=1 ;
    System.out.print(query(number,n)+"\n");
    number=210 ;
    n=3 ;
    System.out.print(query(number,n)+"\n");
    number=210 ;
    n=2 ;
    System.out.print(query(number,n)+"\n");
    number=60 ;
    n=2 ;
    System.out.print(query(number,n)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 1000001;
  static   attribute v : Sequence(Sequence(int)) := Integer.subrange(1,N)->collect(null);
  static   operation preprocess() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < N do ( (     var num : int ; num := i ;
         var j : int ; j := 2 ; while j <= (num)->sqrt() do ( (     if (num mod j = 0) then (     v[i+1]->excludes(j) ; 
     while (num mod j = 0) do (     num := num / j ) ) else skip )  ;     j := j + 1 ) ; 
     if (num > 2) then     v[i+1]->excludes(num) ; else skip )  ;     i := i + 1 ) );
  static   operation query( number : int, n : int) : int
  pre: true
  post: true
  activity: (     return v[number+1]->at(n - 1+1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do (     v[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
     execute preprocess() ; 
    var number : int ; number := 6 ;
    var n : int ; n := 1 ;
    OclFile["System.out"].print(query(number, n) + "\n") ; 
    number := 210 ; 
    n := 3 ; 
    OclFile["System.out"].print(query(number, n) + "\n") ; 
    number := 210 ; 
    n := 2 ; 
    OclFile["System.out"].print(query(number, n) + "\n") ; 
    number := 60 ; 
    n := 2 ; 
    OclFile["System.out"].print(query(number, n) + "\n") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isPresent(int B[],int m,int x){
    for(int i=0 ; i<m ; i++)if(B[i]==x)return true ;
    return false ;
  }
  static int findMaxSubarraySumUtil(int A[],int B[],int n,int m){
    int max_so_far=-2147483648,curr_max=0 ;
    for(int i=0 ; i<n ; i++){
      if(isPresent(B,m,A[i])){
        curr_max=0 ;
        continue ;
      }
      curr_max=Math.max(A[i],curr_max+A[i]);
      max_so_far=Math.max(max_so_far,curr_max);
    }
    return max_so_far ;
  }
  static void findMaxSubarraySum(int A[],int B[],int n,int m){
    int maxSubarraySum=findMaxSubarraySumUtil(A,B,n,m);
    if(maxSubarraySum==-2147483648){
      System.out.println("Maximum Subarray Sum"+" "+"can't be found");
    }
    else {
      System.out.println("The Maximum Subarray Sum="+maxSubarraySum);
    }
  }
  public static void main(String[] args){
    int A[]={
      3,4,5,-4,6 };
      int B[]={
        1,8,5 };
        int n=A.length ;
        int m=B.length ;
        findMaxSubarraySum(A,B,n,m);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPresent( B : Sequence(int), m : int, x : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < m do (     if (B[i+1] = x) then     return true else skip ;  ;     i := i + 1 ) ; 
     return false );
  static   operation findMaxSubarraySumUtil( A : Sequence(int), B : Sequence(int), n : int, m : int) : int
  pre: true
  post: true
  activity: (     var max_so_far : int ; max_so_far := -2147483648 ;
    var curr_max : int ; curr_max := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (isPresent(B, m, A[i+1])) then (     curr_max := 0 ; 
     continue ) else skip ; 
     curr_max := Set{A[i+1], curr_max + A[i+1]}->max() ; 
     max_so_far := Set{max_so_far, curr_max}->max() )  ;     i := i + 1 ) ; 
     return max_so_far );
  static   operation findMaxSubarraySum( A : Sequence(int), B : Sequence(int), n : int, m : int) : void
  pre: true
  post: true
  activity: (     var maxSubarraySum : int ; maxSubarraySum := findMaxSubarraySumUtil(A, B, n, m) ;
     if (maxSubarraySum = -2147483648) then (     OclFile["System.out"].println("Maximum Subarray Sum" + " " + "can't be found") ) else (     OclFile["System.out"].println("The Maximum Subarray Sum=" + maxSubarraySum) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{3,4,5,-4,6} ;
     var B : Sequence(int) ; B := Sequence{1,8,5} ;
    var n : int ; n := A->size() ;
    var m : int ; m := B->size() ;
    execute findMaxSubarraySum(A, B, n, m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class ReverseDigits {
  static int reversDigits(int num){
    boolean negativeFlag=false ;
    if(num<0){
      negativeFlag=true ;
      num=-num ;
    }
    int prev_rev_num=0,rev_num=0 ;
    while(num!=0){
      int curr_digit=num % 10 ;
      rev_num=(rev_num*10)+curr_digit ;
      if((rev_num-curr_digit)/10!=prev_rev_num){
        System.out.println("WARNING OVERFLOWED!!!");
        return 0 ;
      }
      prev_rev_num=rev_num ;
      num=num/10 ;
    }
    return(negativeFlag==true)?-rev_num : rev_num ;
  }
  public static void main(String[] args){
    int num=12345 ;
    System.out.println("Reverse of no.is "+reversDigits(num));
    num=1000000045 ;
    System.out.println("Reverse of no.is "+reversDigits(num));
  }
}
------------------------------------------------------------
OCL File:
---------
class ReverseDigits {
  static   operation reversDigits( num : int) : int
  pre: true
  post: true
  activity: (     var negativeFlag : boolean ; negativeFlag := false ;
     if (num < 0) then (     negativeFlag := true ; 
     num := -num ) else skip ; 
    var prev_rev_num : int ; prev_rev_num := 0 ;
    var rev_num : int ; rev_num := 0 ;
    while (num /= 0) do (     var curr_digit : int ; curr_digit := num mod 10 ;
     rev_num := (rev_num * 10) + curr_digit ; 
    if ((rev_num - curr_digit) / 10 /= prev_rev_num) then (     OclFile["System.out"].println("WARNING OVERFLOWED!!!") ; 
     return 0 ) else skip ; 
    prev_rev_num := rev_num ; 
    num := num / 10 ; 
 ) ; 
    return if (negativeFlag = true) then -rev_num else rev_num endif 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 12345 ;
     OclFile["System.out"].println("Reverse of no.is " + reversDigits(num)) ; 
     num := 1000000045 ; 
     OclFile["System.out"].println("Reverse of no.is " + reversDigits(num)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int[] z_function(char[] s){
    int n=s.length ;
    int[] z=new int[n];
    for(int i=1,l=0,r=0 ; i<n ; i++){
      if(i<=r)z[i]=Math.min(r-i+1,z[i-l]);
      while(i+z[i]<n && s[z[i] ]==s[i+z[i] ])z[i]++;
      if(i+z[i]-1>r){
        l=i ;
        r=i+z[i]-1 ;
      }
    }
    return z ;
  }
  static int n,len=0 ;
  static int[] bit=new int[1000005];
  static String s ;
  static int[] z ;
  static void update(int idx,int val){
    if(idx==0)return ;
    while(idx<=n){
      bit[idx]+=val ;
      idx+=(idx &-idx);
    }
  }
  static int pref(int idx){
    int ans=0 ;
    while(idx>0){
      ans+=bit[idx];
      idx-=(idx &-idx);
    }
    return ans ;
  }
  public static void main(String[] args){
    s="geeksisforgeeksinplatformgeeks" ;
    z=new int[s.length()];
    n=s.length();
    z=z_function(s.toCharArray());
    for(int i=1 ; i<n ; i++){
      update(z[i],1);
    }
    for(int i=n-1 ; i>1 ; i--){
      if(z[i]!=(n-i))continue ;
      if(pref(n)-pref(z[i]-1)>=2){
        len=Math.max(len,z[i]);
      }
    }
    if(len==0)System.out.println("-1");
    else System.out.println(s.substring(0,len));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation z_function( s : Sequence(String)) : Sequence(int)
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var z : Sequence(int) ; z := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 1 ;
    var l : int ; l := 0 ;
    var r : int ; r := 0 ; while i < n do ( (     if (i <= r) then     z[i+1] := Set{r - i + 1, z[i - l+1]}->min() ; else skip ; 
     while (i + z[i+1] < n & s[z[i+1]+1] = s[i + z[i+1]+1]) do     z[i+1] := z[i+1] + 1 ; ; 
     if (i + z[i+1] - 1 > r) then (     l := i ; 
     r := i + z[i+1] - 1 ) else skip )  ;     i := i + 1 ) ; 
     return z );
  static   attribute n : int;
  static   attribute bit : Sequence(int) := Integer.subrange(1,1000005)->collect(0);
  static   attribute s : String;
  static   attribute z : Sequence(int);
  static   operation update( idx : int, val : int) : void
  pre: true
  post: true
  activity: (     if (idx = 0) then     return else skip ; 
     while (idx <= n) do (     bit[idx+1] := bit[idx+1]+(val) ; 
     idx := idx+((idx & -idx)) ) );
  static   operation pref( idx : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     while (idx > 0) do (     ans := ans+(bit[idx+1]) ; 
     idx := idx-((idx & -idx)) ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     s := "geeksisforgeeksinplatformgeeks" ; 
     z := Integer.subrange(1,s->size())->collect(0) ; 
    n := s->size() ; 
    z := z_function(s->characters()) ; 
        var i : int ; i := 1 ; while i < n do ( (     execute update(z[i+1], 1) )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i > 1 do ( (     if (z[i+1] /= (n - i)) then     continue else skip ; 
     if (pref(n) - pref(z[i+1] - 1) >= 2) then (     len := Set{len, z[i+1]}->max() ) else skip )  ;     i := i - 1 ) ; 
    if (len = 0) then     OclFile["System.out"].println("-1") else     OclFile["System.out"].println(s.subrange(0+1,len)) ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=90 ;
  public static void main(String[] args){
    long[] arr=new long[MAX];
    long[] index1=new long[MAX];
    long[] index2=new long[MAX];
    long[] index3=new long[MAX];
    long[] index4=new long[MAX];
    arr[0]=0 ;
    arr[1]=1 ;
    for(int i=2 ; i<MAX ; i++)arr[i]=arr[i-1]+arr[i-2];
    int c1=0,c2=0,c3=0,c4=0 ;
    for(int i=0 ; i<MAX ; i++){
      if(arr[i] % 2==0)index1[c1++]=i ;
      if(arr[i] % 3==0)index2[c2++]=i ;
      if(arr[i] % 5==0)index3[c3++]=i ;
      if(arr[i] % 8==0)index4[c4++]=i ;
    }
    System.out.print("Index of Fibonacci numbers divisible by"+" 2 are :\n");
    for(int i=0 ; i<c1 ; i++)System.out.print(index1[i]+" ");
    System.out.print("\n");
    System.out.print("Index of Fibonacci number divisible by"+" 3 are :\n");
    for(int i=0 ; i<c2 ; i++)System.out.print(index2[i]+" ");
    System.out.print("\n");
    System.out.print("Index of Fibonacci number divisible by"+" 5 are :\n");
    for(int i=0 ; i<c3 ; i++)System.out.print(index3[i]+" ");
    System.out.print("\n");
    System.out.print("Index of Fibonacci number divisible by"+" 8 are :\n");
    for(int i=0 ; i<c4 ; i++)System.out.print(index4[i]+" ");
    System.out.print("\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 90;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(long) ; arr := Integer.subrange(1,MAX)->collect(0) ;
     var index1 : Sequence(long) ; index1 := Integer.subrange(1,MAX)->collect(0) ;
    var index2 : Sequence(long) ; index2 := Integer.subrange(1,MAX)->collect(0) ;
    var index3 : Sequence(long) ; index3 := Integer.subrange(1,MAX)->collect(0) ;
    var index4 : Sequence(long) ; index4 := Integer.subrange(1,MAX)->collect(0) ;
    arr[0+1] := 0 ; 
    arr[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < MAX do (     arr[i+1] := arr[i - 1+1] + arr[i - 2+1] ;  ;     i := i + 1 ) ; 
    var c1 : int ; c1 := 0 ;
    var c2 : int ; c2 := 0 ;
    var c3 : int ; c3 := 0 ;
    var c4 : int ; c4 := 0 ;
        var i : int ; i := 0 ; while i < MAX do ( (     if (arr[i+1] mod 2 = 0) then      index1[c1+1] := i  ; c1 := c1 + 1 ; else skip ; 
     if (arr[i+1] mod 3 = 0) then      index2[c2+1] := i  ; c2 := c2 + 1 ; else skip ; 
     if (arr[i+1] mod 5 = 0) then      index3[c3+1] := i  ; c3 := c3 + 1 ; else skip ; 
     if (arr[i+1] mod 8 = 0) then      index4[c4+1] := i  ; c4 := c4 + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("Index of Fibonacci numbers divisible by" + " 2 are :\n") ; 
        var i : int ; i := 0 ; while i < c1 do (     OclFile["System.out"].print(index1[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("\n") ; 
    OclFile["System.out"].print("Index of Fibonacci number divisible by" + " 3 are :\n") ; 
        var i : int ; i := 0 ; while i < c2 do (     OclFile["System.out"].print(index2[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("\n") ; 
    OclFile["System.out"].print("Index of Fibonacci number divisible by" + " 5 are :\n") ; 
        var i : int ; i := 0 ; while i < c3 do (     OclFile["System.out"].print(index3[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("\n") ; 
    OclFile["System.out"].print("Index of Fibonacci number divisible by" + " 8 are :\n") ; 
        var i : int ; i := 0 ; while i < c4 do (     OclFile["System.out"].print(index4[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("\n") ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  int Circumference(int a){
    return 4*a ;
  }
  public static void main(String args[]){
    GFG obj=new GFG();
    int a=5 ;
    System.out.println("Circumference of "+"a square is "+obj.Circumference(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
   operation Circumference( a : int) : int
  pre: true
  post: true
  activity: (     return 4 * a );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : GFG ; obj := GFG.newGFG() ;
     var a : int ; a := 5 ;
     OclFile["System.out"].println("Circumference of " + "a square is " + obj.Circumference(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.StringTokenizer ;
public class A {
  public static void main(String args[]){
    FastReader in=new FastReader();
    int w=in.nextInt();
    int h=in.nextInt();
    int k=in.nextInt();
    int sum=0 ;
    for(int i=0 ; i<k ; i++){
      sum+=2*(w-1)+2*(h-1);
      w-=4 ;
      h-=4 ;
    }
    System.out.println(sum);
  }
  public static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var w : int ; w := in.nextInt() ;
    var h : int ; h := in.nextInt() ;
    var k : int ; k := in.nextInt() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     sum := sum+(2 * (w - 1) + 2 * (h - 1)) ; 
     w := w-(4) ; 
     h := h-(4) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    String game_times=input.readLine();
    int game_num=Integer.parseInt(game_times);
    int taro_point=0 ;
    int hanako_point=0 ;
    for(int match_spot=0 ; match_spot<game_num ; match_spot++){
      String two_person_card=input.readLine();
      String[] cards_array=two_person_card.split(" ");
      String taro_card=cards_array[0];
      String hanako_card=cards_array[1];
      if(taro_card.compareToIgnoreCase(hanako_card)>0){
        taro_point+=3 ;
      }
      else if(taro_card.compareToIgnoreCase(hanako_card)<0){
        hanako_point+=3 ;
      }
      else {
        taro_point+=1 ;
        hanako_point+=1 ;
      }
    }
    System.out.println(taro_point+" "+hanako_point);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var game_times : String ; game_times := input.readLine() ;
    var game_num : int ; game_num := (game_times)->toInteger() ;
    var taro_point : int ; taro_point := 0 ;
    var hanako_point : int ; hanako_point := 0 ;
        var match_spot : int ; match_spot := 0 ; while match_spot < game_num do ( (     var two_person_card : String ; two_person_card := input.readLine() ;
     var cards_array : Sequence(String) ; cards_array := two_person_card->split(" ") ;
    var taro_card : String ; taro_card := cards_array[0+1] ;
    var hanako_card : String ; hanako_card := cards_array[1+1] ;
    if (taro_card->toLowerCase()->compareTo(hanako_card->toLowerCase()) > 0) then (     taro_point := taro_point+(3) ) else     if (taro_card->toLowerCase()->compareTo(hanako_card->toLowerCase()) < 0) then (     hanako_point := hanako_point+(3) ) else (     taro_point := taro_point+(1) ; 
     hanako_point := hanako_point+(1) ) ;  ;  
 )  ;     match_spot := match_spot + 1 ) ; 
    OclFile["System.out"].println(taro_point + " " + hanako_point) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1031 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int w=scanner.nextInt(),h=scanner.nextInt(),k=scanner.nextInt(),ans=0 ;
    for(int i=0 ; i<k ; i++){
      ans+=(2*(w+h)-4);
      w-=4 ;
      h-=4 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1031 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := scanner.getCurrent()->toInteger() ;
    var h : int ; h := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < k do ( (     ans := ans+((2 * (w + h) - 4)) ; 
     w := w-(4) ; 
     h := h-(4) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class P2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int w=sc.nextInt();
    int h=sc.nextInt();
    int k=sc.nextInt();
    int r=0 ;
    for(int i=0 ; i<k ; i++){
      r+=2*(h);
      r+=2*(w-2);
      w-=4 ;
      h-=4 ;
    }
    System.out.println(r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class P2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var r : int ; r := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     r := r+(2 * (h)) ; 
     r := r+(2 * (w - 2)) ; 
     w := w-(4) ; 
     h := h-(4) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(r) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    try(Scanner sc=new Scanner(System.in)){
      int N=sc.nextInt();
      long A=1,B=1 ;
      for(int i=0 ; i<N ; i++){
        long X=sc.nextInt(),Y=sc.nextInt();
        long num ;
        A=((A-1)/X+1)*X ;
        B=Math.max(B,A/X*Y);
        B=((B-1)/Y+1)*Y ;
        A=Math.max(A,B/Y*X);
      }
      System.out.println(A+B);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var A : long ; A := 1 ;
    var B : long ; B := 1 ;
         var i : int ; i := 0 ; while i < N do ( (     var X : long ; X := sc.getCurrent()->toInteger() ;
    var Y : long ; Y := sc.getCurrent()->toInteger() ;
     var num : long ;
    A := ((A - 1) / X + 1) * X ; 
    B := Set{B, A / X * Y}->max() ; 
    B := ((B - 1) / Y + 1) * Y ; 
    A := Set{A, B / Y * X}->max() ; 
 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(A + B) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.math.BigInteger ;
public class Main {
  public static void main(String args[]){
    BigInteger T,A ;
    T=BigInteger.ZERO ;
    A=T ;
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    for(int i=1 ; i<=n ; i++){
      int _x=scanner.nextInt();
      int _y=scanner.nextInt();
      BigInteger x=BigInteger.valueOf(_x);
      BigInteger y=BigInteger.valueOf(_y);
      if(i==1){
        T=x ;
        A=y ;
        continue ;
      }
      BigInteger D=x.multiply(A).subtract(T.multiply(y));
      if(D.compareTo(BigInteger.ZERO)>=0){
        for(int j=0 ; j<=1000 ; j++){
          BigInteger Z=D.add(x.multiply(BigInteger.valueOf(j)));
          if(Z.mod(y).compareTo(BigInteger.ZERO)==0){
            BigInteger q=BigInteger.valueOf(j);
            BigInteger p=Z.divide(y);
            T=T.add(p);
            A=A.add(q);
            break ;
          }
        }
      }
      else {
        for(int j=0 ; j<=1000 ; j++){
          BigInteger Z=y.multiply(BigInteger.valueOf(j)).subtract(D);
          if(Z.mod(x).compareTo(BigInteger.ZERO)==0){
            BigInteger q=Z.divide(x);
            BigInteger p=BigInteger.valueOf(j);
            T=T.add(p);
            A=A.add(q);
            break ;
          }
        }
      }
    }
    System.out.println(T.add(A).toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : long ;
    var A : long ;
     T := 0 ; 
    A := T ; 
    var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= n do ( (     var _x : int ; _x := scanner.getCurrent()->toInteger() ;
     var _y : int ; _y := scanner.getCurrent()->toInteger() ;
    var x : long ; x := (_x + "")->toLong() ;
    var y : long ; y := (_y + "")->toLong() ;
    if (i = 1) then (     T := x ; 
     A := y ; 
     continue ) else skip ; 
    var D : long ; D := x.multiply(A).subtract(T.multiply(y)) ;
    if (D->compareTo(0) >= 0) then (         var j : int ; j := 0 ; while j <= 1000 do ( (     var Z : long ; Z := D->excludes(x.multiply((j + "")->toLong())) ;
     if (Z.mod(y)->compareTo(0) = 0) then (     var q : long ; q := (j + "")->toLong() ;
     var p : long ; p := Z.divide(y) ;
    T := T->excludes(p) ; 
    A := A->excludes(q) ; 
    break 
 ) else skip )  ;     j := j + 1 ) ) else (         var j : int ; j := 0 ; while j <= 1000 do ( (     var Z : long ; Z := y.multiply((j + "")->toLong()).subtract(D) ;
     if (Z.mod(x)->compareTo(0) = 0) then (     var q : long ; q := Z.divide(x) ;
     var p : long ; p := (j + "")->toLong() ;
    T := T->excludes(p) ; 
    A := A->excludes(q) ; 
    break 
 ) else skip )  ;     j := j + 1 ) ) ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(T->excludes(A)+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int N=gi();
    long[] T=new long[N];
    long[] A=new long[N];
    for(int i=0 ; i<N ; i++){
      T[i]=gl();
      A[i]=gl();
    }
    long ht=1 ;
    long ha=1 ;
    for(int i=0 ; i<N ; i++){
      long tn=ht % T[i]==0 ? ht/T[i] : Math.floorDiv(ht,T[i])+1 ;
      long ta=ha % A[i]==0 ? ha/A[i] : Math.floorDiv(ha,A[i])+1 ;
      long hi=Math.max(tn,ta);
      ht=hi*T[i];
      ha=hi*A[i];
    }
    System.out.println(ht+ha);
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : int ; N := gi() ;
    var T : Sequence(long) ; T := Integer.subrange(1,N)->collect(0) ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     T[i+1] := gl() ; 
     A[i+1] := gl() )  ;     i := i + 1 ) ; 
    var ht : long ; ht := 1 ;
    var ha : long ; ha := 1 ;
        var i : int ; i := 0 ; while i < N do ( (     var tn : long ; tn := if ht mod T[i+1] = 0 then ht / T[i+1] else floorDiv(ht, T[i+1]) + 1 endif ;
     var ta : long ; ta := if ha mod A[i+1] = 0 then ha / A[i+1] else floorDiv(ha, A[i+1]) + 1 endif ;
    var hi : long ; hi := Set{tn, ta}->max() ;
    ht := hi * T[i+1] ; 
    ha := hi * A[i+1] ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ht + ha) ; 
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] t=new int[n];
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      t[i]=sc.nextInt();
      a[i]=sc.nextInt();
    }
    sc.close();
    long t_now=t[0],a_now=a[0],t_next1=0,a_next1=0,t_next2=0,a_next2=0 ;
    for(int i=1 ; i<n ; i++){
      if(t_now % t[i]==0){
        t_next1=t_now ;
        a_next1=(t_next1/t[i])*a[i];
      }
      else {
        t_next1=t_now+t[i]-t_now % t[i];
        a_next1=(t_next1/t[i])*a[i];
      }
      if(a_now % a[i]==0){
        a_next2=a_now ;
        t_next2=(a_next2/a[i])*t[i];
      }
      else {
        a_next2=a_now+a[i]-a_now % a[i];
        t_next2=(a_next2/a[i])*t[i];
      }
      if(t_now+a_now>t_next1+a_next1 || t_now>t_next1 || a_now>a_next1){
        t_now=t_next2 ;
        a_now=a_next2 ;
      }
      else if(t_now+a_now>t_next2+a_next2 || t_now>t_next2 || a_now>a_next2){
        t_now=t_next1 ;
        a_now=a_next1 ;
      }
      else if(t_next1+a_next1>t_next2+a_next2){
        t_now=t_next2 ;
        a_now=a_next2 ;
      }
      else {
        t_now=t_next1 ;
        a_now=a_next1 ;
      }
    }
    System.out.println(t_now+a_now);
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     t[i+1] := sc.getCurrent()->toInteger() ; 
     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var t_now : long ; t_now := t[0+1] ;
    var a_now : long ; a_now := a[0+1] ;
    var t_next1 : long ; t_next1 := 0 ;
    var a_next1 : long ; a_next1 := 0 ;
    var t_next2 : long ; t_next2 := 0 ;
    var a_next2 : long ; a_next2 := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (t_now mod t[i+1] = 0) then (     t_next1 := t_now ; 
     a_next1 := (t_next1 / t[i+1]) * a[i+1] ) else (     t_next1 := t_now + t[i+1] - t_now mod t[i+1] ; 
     a_next1 := (t_next1 / t[i+1]) * a[i+1] ) ;  
     if (a_now mod a[i+1] = 0) then (     a_next2 := a_now ; 
     t_next2 := (a_next2 / a[i+1]) * t[i+1] ) else (     a_next2 := a_now + a[i+1] - a_now mod a[i+1] ; 
     t_next2 := (a_next2 / a[i+1]) * t[i+1] ) ;  
     if (t_now + a_now > t_next1 + a_next1 or t_now > t_next1 or a_now > a_next1) then (     t_now := t_next2 ; 
     a_now := a_next2 ) else     if (t_now + a_now > t_next2 + a_next2 or t_now > t_next2 or a_now > a_next2) then (     t_now := t_next1 ; 
     a_now := a_next1 ) else     if (t_next1 + a_next1 > t_next2 + a_next2) then (     t_now := t_next2 ; 
     a_now := a_next2 ) else (     t_now := t_next1 ; 
     a_now := a_next1 ) ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(t_now + a_now) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static long divCeil(long a,long b){
    return(a+b-1)/b ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long tak=1 ;
    long aok=1 ;
    for(int n=0 ; n<N ; n++){
      long t=sc.nextLong();
      long a=sc.nextLong();
      long scale=Math.max(divCeil(tak,t),divCeil(aok,a));
      tak=t*scale ;
      aok=a*scale ;
    }
    System.out.println(tak+aok);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation divCeil( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a + b - 1) / b );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var tak : long ; tak := 1 ;
    var aok : long ; aok := 1 ;
        var n : int ; n := 0 ; while n < N do ( (     var t : long ; t := sc.getCurrent()->toLong() ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var scale : long ; scale := Set{divCeil(tak, t), divCeil(aok, a)}->max() ;
    tak := t * scale ; 
    aok := a * scale ; 
 )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(tak + aok) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void checkAllOnes(int arr[],int n,int k){
    int brr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      if(arr[i]==1){
        int h=k+1 ;
        int j=i ;
        while((j>=0)&&(h--!=0)){
          brr[j]=1 ;
          j--;
        }
        h=k+1 ;
        j=i ;
        while((j<n)&&(h--!=0)){
          brr[j]=1 ;
          j++;
        }
      }
    }
    int flag=0 ;
    for(int i=0 ; i<n ; i++){
      if(brr[i]==0){
        flag=1 ;
        break ;
      }
    }
    if(flag==1)System.out.println("0");
    else System.out.println("1");
  }
  public static void main(String[] args){
    int arr[]={
      1,0,1,0 };
      int k=2 ;
      int n=arr.length ;
      checkAllOnes(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkAllOnes( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var brr : Sequence(int) ; brr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 1) then (     var h : int ; h := k + 1 ;
     var j : int ; j := i ;
        while ((j >= 0) & (h /= 0)) do (    skip ; (     brr[j+1] := 1 ; 
     j := j - 1 ) ;  ) ;  
    h := k + 1 ; 
    j := i ; 
        while ((j < n) & (h /= 0)) do (    skip ; (     brr[j+1] := 1 ; 
     j := j + 1 ) ;  ) ;  
 ) else skip )  ;     i := i + 1 ) ; 
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (brr[i+1] = 0) then (     flag := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 1) then     OclFile["System.out"].println("0") else     OclFile["System.out"].println("1") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,0,1,0} ;
     var k : int ; k := 2 ;
     var n : int ; n := arr->size() ;
     execute checkAllOnes(arr, n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int max ;
  static int Count ;
  static int len ;
  static String[] ans ;
  static int n ;
  public static void main(String[] agrs){
    Scanner sc=new Scanner(System.in);
    while(true){
      max=-1 ;
      Count=-1 ;
      len=-1 ;
      ans=new String[100];
      n=sc.nextInt();
      String in=sc.next();
      if(n==0 && in.equals("0"))break ;
      dfs(in,0,1,new String[in.length()+1],0,0);
      if(max==-1)System.out.println("error");
      else if(Count>=2)System.out.println("rejected");
      else {
        System.out.print(max);
        for(int i=0 ; i<len ; i++){
          System.out.print(" "+ans[i]);
        }
        System.out.println();
      }
    }
  }
  public static void dfs(String a,int l,int r,String[] b,int sum,int count){
    if(l==a.length()){
      if(max<sum && sum<=n){
        max=sum ;
        ans=b ;
        Count=1 ;
        len=count ;
      }
      else if(sum==max){
        Count++;
      }
      return ;
    }
    if(r==a.length()+1){
      return ;
    }
    dfs(a,l,r+1,b,sum,count);
    String[] cp=Arrays.copyOf(b,b.length);
    cp[count]=a.substring(l,r);
    sum+=Integer.parseInt(a.substring(l,r));
    dfs(a,r,r+1,cp,sum,count+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute max : int;
  static   attribute Count : int;
  static   attribute len : int;
  static   attribute ans : Sequence(String);
  static   attribute n : int;
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     max := -1 ; 
     Count := -1 ; 
    len := -1 ; 
    ans := Integer.subrange(1,100)->collect(null) ; 
    n := sc.getCurrent()->toInteger() ; 
    var in : String ; in := sc.getCurrent() ;
    if (n = 0 & in = "0") then     break else skip ; 
    execute dfs(in, 0, 1, Integer.subrange(1,in->size() + 1)->collect(null), 0, 0) ; 
    if (max = -1) then     OclFile["System.out"].println("error") else     if (Count >= 2) then     OclFile["System.out"].println("rejected") else (     OclFile["System.out"].print(max) ; 
         var i : int ; i := 0 ; while i < len do ( (     OclFile["System.out"].print(" " + ans[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ;  ;  
 ) );
  static   operation dfs( a : String, l : int, r : int, b : Sequence(String), sum : int, count : int) : void
  pre: true
  post: true
  activity: (     if (l = a->size()) then (     if (max < sum & sum <= n) then (     max := sum ; 
     ans := b ; 
     Count := 1 ; 
     len := count ) else     if (sum = max) then (     Count := Count + 1 ) else skip ; ;  
     return ) else skip ; 
     if (r = a->size() + 1) then (     return ) else skip ; 
    execute dfs(a, l, r + 1, b, sum, count) ; 
    var cp : Sequence(String) ; cp := b.subrange(1,b->size()) ;
    cp[count+1] := a.subrange(l+1,r) ; 
    sum := sum+((a.subrange(l+1,r))->toInteger()) ; 
    execute dfs(a, r, r + 1, cp, sum, count + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  int n,target ;
  int ans=-1 ;
  boolean rejected=true ;
  int nums[];
  int temp[]=new int[6];
  public void shred(int x,int num,int index){
    for(int i=10 ; i<=(num*10); i*=10){
      int mod=num % i ;
      temp[index]=mod ;
      if(x+mod>n)break ;
      if(num/i==0){
        if(x+mod>ans){
          rejected=false ;
          ans=x+mod ;
          nums=Arrays.copyOf(temp,temp.length);
        }
        else if(x+mod==ans){
          rejected=true ;
        }
      }
      else {
        shred(x+mod,num/i,index+1);
      }
      temp[index]=-1 ;
    }
  }
  public void run(){
    Scanner in=new Scanner(System.in);
    while(true){
      ans=-1 ;
      Arrays.fill(temp,-1);
      n=in.nextInt();
      target=in.nextInt();
      if((n | target)==0)break ;
      shred(0,target,0);
      if(ans==-1)System.out.println("error");
      else if(rejected)System.out.println("rejected");
      else {
        System.out.print(ans);
        for(int i=nums.length-1 ; i>=0 ; i--){
          if(nums[i]==-1)continue ;
          System.out.print(" "+nums[i]);
        }
        System.out.println();
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute ans : int := -1;
   attribute rejected : boolean := true;
   attribute nums : Sequence(int);
   attribute temp : int := Integer.subrange(1,6)->collect(0);
   operation shred( x : int, num : int, index : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 10 ; while i <= (num * 10) do ( (     var mod : int ; mod := num mod i ;
     temp[index+1] := mod ; 
    if (x + mod > n) then     break else skip ; 
    if (num / i = 0) then (     if (x + mod > ans) then (     rejected := false ; 
     ans := x + mod ; 
     nums := temp.subrange(1,temp->size()) ) else     if (x + mod = ans) then (     rejected := true ) else skip ; ) else (     execute shred(x + mod, num / i, index + 1) ) ;  
    temp[index+1] := -1 ; 
 )  ;     i := i*(10) ) );
   operation run() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     ans := -1 ; 
     temp := temp->collect(-1) ; 
    n := in.getCurrent()->toInteger() ; 
    target := in.getCurrent()->toInteger() ; 
    if ((MathLib.bitwiseOr(n,target)) = 0) then     break else skip ; 
    execute shred(0, target, 0) ; 
    if (ans = -1) then     OclFile["System.out"].println("error") else     if (rejected) then     OclFile["System.out"].println("rejected") else (     OclFile["System.out"].print(ans) ; 
         var i : int ; i := nums->size() - 1 ; while i >= 0 do ( (     if (nums[i+1] = -1) then     continue else skip ; 
     OclFile["System.out"].print(" " + nums[i+1]) )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println() ) ;  ;  
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=input.nextInt();
    System.out.println(Math.abs(arr[0]-arr[1])+" "+Math.abs(arr[0]-arr[n-1]));
    for(int i=1 ; i<n-1 ; i++){
      System.out.print(Math.min(Math.abs(arr[i]-arr[i-1]),Math.abs(arr[i]-arr[i+1])));
      System.out.print(" "+Math.max(Math.abs(arr[i]-arr[0]),Math.abs(arr[i]-arr[n-1])));
      System.out.println();
    }
    System.out.println(Math.abs(arr[n-1]-arr[n-2])+" "+Math.abs(arr[n-1]-arr[0]));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := input.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if arr[0+1] - arr[1+1] < 0 then -(arr[0+1] - arr[1+1]) else arr[0+1] - arr[1+1] endif + " " + if arr[0+1] - arr[n - 1+1] < 0 then -(arr[0+1] - arr[n - 1+1]) else arr[0+1] - arr[n - 1+1] endif) ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     OclFile["System.out"].print(Set{if arr[i+1] - arr[i - 1+1] < 0 then -(arr[i+1] - arr[i - 1+1]) else arr[i+1] - arr[i - 1+1] endif, if arr[i+1] - arr[i + 1+1] < 0 then -(arr[i+1] - arr[i + 1+1]) else arr[i+1] - arr[i + 1+1] endif}->min()) ; 
     OclFile["System.out"].print(" " + Set{if arr[i+1] - arr[0+1] < 0 then -(arr[i+1] - arr[0+1]) else arr[i+1] - arr[0+1] endif, if arr[i+1] - arr[n - 1+1] < 0 then -(arr[i+1] - arr[n - 1+1]) else arr[i+1] - arr[n - 1+1] endif}->max()) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if arr[n - 1+1] - arr[n - 2+1] < 0 then -(arr[n - 1+1] - arr[n - 2+1]) else arr[n - 1+1] - arr[n - 2+1] endif + " " + if arr[n - 1+1] - arr[0+1] < 0 then -(arr[n - 1+1] - arr[0+1]) else arr[n - 1+1] - arr[0+1] endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int target=sc.nextInt();
      int sheet=sc.nextInt();
      if(target==0 && sheet==0)break ;
      int n=0 ;
      while(sheet>Math.pow(10,n+1))n++;
      n++;
      int[] list=new int[n];
      int sheet2=sheet ;
      for(int i=n-1 ; i>=0 ; i--){
        list[i]=sheet2 % 10 ;
        sheet2/=10 ;
      }
      int max=-1 ;
      int part=-1 ;
      for(int mask=1 ; mask<1<<n ; mask+=2){
        int sum=0 ;
        int num=0 ;
        for(int j=0 ; j<n ; j++){
          if((mask &(1<<j))>0){
            sum+=num ;
            num=list[j];
          }
          else {
            num*=10 ;
            num+=list[j];
          }
        }
        sum+=num ;
        if(sum==max){
          part=-1 ;
        }
        if(sum>max && sum<=target){
          max=sum ;
          part=mask ;
        }
      }
      if(max==-1)System.out.println("error");
      else if(part==-1)System.out.println("rejected");
      else {
        System.out.print(max);
        int num=-1 ;
        for(int i=0 ; i<n ; i++){
          if((part &(1<<i))>0){
            if(num!=-1)System.out.print(" "+num);
            num=list[i];
          }
          else {
            num*=10 ;
            num+=list[i];
          }
        }
        System.out.println(" "+num);
      }
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var target : int ; target := sc.getCurrent()->toInteger() ;
     var sheet : int ; sheet := sc.getCurrent()->toInteger() ;
    if (target = 0 & sheet = 0) then     break else skip ; 
    var n : int ; n := 0 ;
    while (sheet > 10->pow(n + 1)) do     n := n + 1 ; ; 
    n := n + 1 ; 
    var list : Sequence(int) ; list := Integer.subrange(1,n)->collect(0) ;
    var sheet2 : int ; sheet2 := sheet ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     list[i+1] := sheet2 mod 10 ; 
     sheet2 := sheet2/(10) )  ;     i := i - 1 ) ; 
    var max : int ; max := -1 ;
    var part : int ; part := -1 ;
        var mask : int ; mask := 1 ; while mask < (1*(2->pow(n)))->oclAsType(long) do ( (     var sum : int ; sum := 0 ;
     var num : int ; num := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd(mask,((1*(2->pow(j)))->oclAsType(long)))) > 0) then (     sum := sum+(num) ; 
     num := list[j+1] ) else (     num := num*(10) ; 
     num := num+(list[j+1]) ) )  ;     j := j + 1 ) ; 
    sum := sum+(num) ; 
    if (sum = max) then (     part := -1 ) else skip ; 
    if (sum > max & sum <= target) then (     max := sum ; 
     part := mask ) else skip ; 
 )  ;     mask := mask+(2) ) ; 
    if (max = -1) then     OclFile["System.out"].println("error") else     if (part = -1) then     OclFile["System.out"].println("rejected") else (     OclFile["System.out"].print(max) ; 
     var num : int ; num := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     if ((MathLib.bitwiseAnd(part,((1*(2->pow(i)))->oclAsType(long)))) > 0) then (     if (num /= -1) then     OclFile["System.out"].print(" " + num) ; else skip ; 
     num := list[i+1] ) else (     num := num*(10) ; 
     num := num+(list[i+1]) ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(" " + num) ) ;  ;  
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int t=sc.nextInt();
      String s=sc.next();
      if(t==0 && "0".equals(s))break ;
      int max=-1 ;
      List<String>piece=new ArrayList<String>();
      boolean col=false ;
      int n=s.length()-1 ;
      for(int i=0 ; i<1<<n ; i++){
        int p=0 ;
        int sum=0 ;
        List<String>sub=new ArrayList<String>();
        for(int j=0 ; j<n ; j++){
          if((i>>j & 1)==0)continue ;
          String u=s.substring(p,j+1);
          sub.add(u);
          sum+=Integer.parseInt(u);
          p=j+1 ;
        }
        sub.add(s.substring(p));
        sum+=Integer.parseInt(s.substring(p));
        if(sum<=t && max<sum){
          max=sum ;
          col=false ;
          piece=sub ;
        }
        else if(sum==max){
          col=true ;
        }
      }
      if(max==-1)System.out.println("error");
      else if(col)System.out.println("rejected");
      else {
        System.out.print(max+" ");
        for(int i=0 ; i<piece.size(); i++)System.out.print(piece.get(i)+(i==piece.size()-1 ? "\n" : " "));
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
    if (t = 0 & "0" = s) then     break else skip ; 
    var max : int ; max := -1 ;
    var piece : Sequence(String) ; piece := Sequence{} ;
    var col : boolean ; col := false ;
    var n : int ; n := s->size() - 1 ;
        var i : int ; i := 0 ; while i < (1*(2->pow(n)))->oclAsType(long) do ( (     var p : int ; p := 0 ;
     var sum : int ; sum := 0 ;
    var sub : Sequence(String) ; sub := Sequence{} ;
        var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd((i/(2->pow(j)))->oclAsType(long),1)) = 0) then     continue else skip ; 
     var u : String ; u := s.subrange(p+1,j + 1) ;
    sub := sub->including(u) ; 
    sum := sum+((u)->toInteger()) ; 
    p := j + 1 ; 
 )  ;     j := j + 1 ) ; 
    sub := sub->including(s.subrange(p+1,p)) ; 
    sum := sum+((s.subrange(p+1,p))->toInteger()) ; 
    if (sum <= t & max < sum) then (     max := sum ; 
     col := false ; 
     piece := sub ) else     if (sum = max) then (     col := true ) else skip ; ;  
 )  ;     i := i + 1 ) ; 
    if (max = -1) then     OclFile["System.out"].println("error") else     if (col) then     OclFile["System.out"].println("rejected") else (     OclFile["System.out"].print(max + " ") ; 
         var i : int ; i := 0 ; while i < piece->size() do (     OclFile["System.out"].print(piece->at(i+1) + (if i = piece->size() - 1 then "\n" else " " endif)) ;  ;     i := i + 1 ) ) ;  ;  
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args)throws Exception {
    while(true){
      int T=sc.nextInt();
      String N=sc.next();
      int num=Integer.parseInt(N);
      if(T==0 && num==0)break ;
      int L=N.length();
      int[][] v=new int[L][L+1];
      for(int i=0 ; i<L ; ++i){
        for(int j=i+1 ; j<=L ; ++j){
          v[i][j]=Integer.parseInt(N.substring(i,j));
        }
      }
      int best=-1 ;
      int bestI=-1 ;
      for(int i=0 ; i<(1<<(L-1)); ++i){
        int idx=(1<<L)+(i<<1)+1 ;
        int sum=0 ;
        int left=0 ;
        while(left<L){
          int right=left+1 ;
          while((idx &(1<<right))==0){
++right ;
          }
          sum+=v[left][right];
          left=right ;
        }
        if(sum<=T){
          if(sum>best){
            best=sum ;
            bestI=idx ;
          }
          else if(sum==best){
            bestI=-2 ;
          }
        }
      }
      if(bestI==-1){
        System.out.println("error");
      }
      else if(bestI==-2){
        System.out.println("rejected");
      }
      else {
        System.out.print(best);
        int left=0 ;
        while(left<L){
          int right=left+1 ;
          while((bestI &(1<<right))==0){
++right ;
          }
          System.out.print(" "+v[left][right]);
          left=right ;
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var T : int ; T := sc.getCurrent()->toInteger() ;
     var N : String ; N := sc.getCurrent() ;
    var num : int ; num := (N)->toInteger() ;
    if (T = 0 & num = 0) then     break else skip ; 
    var L : int ; L := N->size() ;
    var v : Sequence(Sequence(int)) ; v := Integer.subrange(1,L)->collect(Integer.subrange(1,L + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < L do ( (         var j : int ; j := i + 1 ; while j <= L do ( (     v[i+1][j+1] := (N.subrange(i+1,j))->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var best : int ; best := -1 ;
    var bestI : int ; bestI := -1 ;
        var i : int ; i := 0 ; while i < ((1*(2->pow((L - 1))))->oclAsType(long)) do ( (     var idx : int ; idx := ((1*(2->pow(L)))->oclAsType(long)) + ((i*(2->pow(1)))->oclAsType(long)) + 1 ;
     var sum : int ; sum := 0 ;
    var left : int ; left := 0 ;
    while (left < L) do (     var right : int ; right := left + 1 ;
     while ((MathLib.bitwiseAnd(idx,((1*(2->pow(right)))->oclAsType(long)))) = 0) do (     right := right + 1 ) ; 
     sum := sum+(v[left+1][right+1]) ; 
     left := right ) ; 
    if (sum <= T) then (     if (sum > best) then (     best := sum ; 
     bestI := idx ) else     if (sum = best) then (     bestI := -2 ) else skip ; ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (bestI = -1) then (     OclFile["System.out"].println("error") ) else     if (bestI = -2) then (     OclFile["System.out"].println("rejected") ) else (     OclFile["System.out"].print(best) ; 
     var left : int ; left := 0 ;
     while (left < L) do (     var right : int ; right := left + 1 ;
     while ((MathLib.bitwiseAnd(bestI,((1*(2->pow(right)))->oclAsType(long)))) = 0) do (     right := right + 1 ) ; 
     OclFile["System.out"].print(" " + v[left+1][right+1]) ; 
     left := right ) ; 
     OclFile["System.out"].println() ) ;  ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    int sum=0 ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)=='/')sum++;
    }
    if(sum==str.length()){
      System.out.println("/");
      return ;
    }
    ArrayList<Character>ans=new ArrayList<>();
    ans.add(str.charAt(0));
    for(int i=1 ; i<str.length(); i++){
      if(str.charAt(i-1)=='/' && str.charAt(i)=='/')continue ;
      ans.add(str.charAt(i));
    }
    sum=ans.size()-1 ;
    while(ans.get(sum)=='/'){
      ans.remove(sum);
      sum--;
    }
    for(Character c : ans){
      System.out.print(c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '/') then     sum := sum + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (sum = str->size()) then (     OclFile["System.out"].println("/") ; 
     return ) else skip ; 
    var ans : Sequence(String) ; ans := Sequence{} ;
    ans := ans->including(str->at(0+1)) ; 
        var i : int ; i := 1 ; while i < str->size() do ( (     if (str->at(i - 1+1) = '/' & str->at(i+1) = '/') then     continue else skip ; 
     ans := ans->including(str->at(i+1)) )  ;     i := i + 1 ) ; 
    sum := ans->size() - 1 ; 
    while (ans->at(sum+1) = '/') do (     ans := ans->excludingAt(sum+1) ; 
     sum := sum - 1 ) ; 
    for (c : ans) do ( (     OclFile["System.out"].print(c) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String n=input.next();
    char[] ch=n.toCharArray();
    int i ;
    int c=0 ;
    String s="" ;
    for(i=0 ; i<n.length(); i++){
      if(ch[i]=='/'){
        c++;
        if(c==1){
          s=s+ch[i];
        }
      }
      else {
        c=0 ;
        s=s+ch[i];
      }
    }
    if(ch[i-1]=='/'){
      s=s.substring(0,s.length()-1);
    }
    if(n.length()==c){
      System.out.println("/");
    }
    else {
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : String ; n := input.getCurrent() ;
    var ch : Sequence(String) ; ch := n->characters() ;
    var i : int ;
    var c : int ; c := 0 ;
    var s : String ; s := "" ;
        i := 0 ; while i < n->size() do ( (     if (ch[i+1] = '/') then (     c := c + 1 ; 
     if (c = 1) then (     s := s + ch[i+1] ) else skip ) else (     c := 0 ; 
     s := s + ch[i+1] ) )  ;     i := i + 1 ) ; 
    if (ch[i - 1+1] = '/') then (     s := s.subrange(0+1,s->size() - 1) ) else skip ; 
    if (n->size() = c) then (     OclFile["System.out"].println("/") ) else (     OclFile["System.out"].println(s) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class codeforces {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String s="",str="/",st="" ;
    s=sc.next();
    s=s+"/" ;
    for(int i=1 ; i<s.length(); i++){
      char ch=s.charAt(i);
      if(ch!='/'){
        st=st+ch ;
      }
      else {
        char ch1=s.charAt(i-1);
        if(ch1!='/'){
          str=str+st+"/" ;
          st="" ;
        }
      }
    }
    if(str.length()!=1)str=str.substring(0,str.length()-1);
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := "" ;
    var str : String ; str := "/" ;
    var st : String ; st := "" ;
    s := sc.getCurrent() ; 
    s := s + "/" ; 
        var i : int ; i := 1 ; while i < s->size() do ( (     var ch : String ; ch := s->at(i+1) ;
     if (ch /= '/') then (     st := st + ch ) else (     var ch1 : String ; ch1 := s->at((i)->char2byte() - 1+1) ;
     if (ch1 /= '/') then (     str := str + st + "/" ; 
     st := "" ) else skip ) )  ;     i := i + 1 ) ; 
    if (str->size() /= 1) then     str := str.subrange(0+1,str->size() - 1) ; else skip ; 
    OclFile["System.out"].println(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      while(testNumber--!=0){
        String str=in.nextLine();
        String[] slipt=str.split("/");
        boolean done=false ;
        for(int i=0 ; i<slipt.length ; i++){
          if(! slipt[i] .isEmpty()){
            out.print("/"+slipt[i]);
            done=true ;
          }
        }
        if(! done){
          out.println("/");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (         while (testNumber /= 0) do (    skip ; (     var str : String ; str := in.nextLine() ;
     var slipt : Sequence(String) ; slipt := str->split("/") ;
    var done : boolean ; done := false ;
        var i : int ; i := 0 ; while i < slipt->size() do ( (     if (not(slipt[i+1]->isEmpty())) then (     skip ; 
     done := true ) else skip )  ;     i := i + 1 ) ; 
    if (not(done)) then (     skip ) else skip ; 
 ) ;  ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    int sum=0 ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)=='/')sum++;
    }
    if(sum==str.length()){
      System.out.println("/");
      return ;
    }
    ArrayList<Character>ans=new ArrayList<>();
    ans.add(str.charAt(0));
    for(int i=1 ; i<str.length(); i++){
      if(str.charAt(i-1)=='/' && str.charAt(i)=='/')continue ;
      ans.add(str.charAt(i));
    }
    sum=ans.size()-1 ;
    while(ans.get(sum)=='/'){
      ans.remove(sum);
      sum--;
    }
    for(Character c : ans){
      System.out.print(c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '/') then     sum := sum + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (sum = str->size()) then (     OclFile["System.out"].println("/") ; 
     return ) else skip ; 
    var ans : Sequence(String) ; ans := Sequence{} ;
    ans := ans->including(str->at(0+1)) ; 
        var i : int ; i := 1 ; while i < str->size() do ( (     if (str->at(i - 1+1) = '/' & str->at(i+1) = '/') then     continue else skip ; 
     ans := ans->including(str->at(i+1)) )  ;     i := i + 1 ) ; 
    sum := ans->size() - 1 ; 
    while (ans->at(sum+1) = '/') do (     ans := ans->excludingAt(sum+1) ; 
     sum := sum - 1 ) ; 
    for (c : ans) do ( (     OclFile["System.out"].print(c) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class Node {
    int data ;
    Node left,right ;
  }
  static Node newNode(int val){
    Node temp=new Node();
    temp.left=null ;
    temp.right=null ;
    temp.data=val ;
    return temp ;
  }
  static int maxAtLevel(Node root,int level){
    if(root==null)return 0 ;
    if(level==0)return root.data ;
    int x=maxAtLevel(root.left,level-1);
    int y=maxAtLevel(root.right,level-1);
    return Math.max(x,y);
  }
  public static void main(String args[]){
    Node root=null ;
    root=newNode(45);
    root.left=newNode(46);
    root.left.left=newNode(18);
    root.left.left.left=newNode(16);
    root.left.left.right=newNode(23);
    root.left.right=newNode(17);
    root.left.right.left=newNode(24);
    root.left.right.right=newNode(21);
    root.right=newNode(15);
    root.right.left=newNode(22);
    root.right.left.left=newNode(37);
    root.right.left.right=newNode(41);
    root.right.right=newNode(19);
    root.right.right.left=newNode(49);
    root.right.right.right=newNode(29);
    int level=3 ;
    System.out.println(maxAtLevel(root,level));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Node {
   attribute data : int;
   attribute left : Node;
}
  static   operation newNode( val : int) : Node
  pre: true
  post: true
  activity: (     var temp : Node ; temp := Node.newNode() ;
     temp.left := null ; 
    temp.right := null ; 
    temp.data := val ; 
    return temp 
 );
  static   operation maxAtLevel( root : Node, level : int) : int
  pre: true
  post: true
  activity: (     if (root = null) then     return 0 else skip ; 
     if (level = 0) then     return root.data else skip ; 
    var x : int ; x := maxAtLevel(root.left, level - 1) ;
    var y : int ; y := maxAtLevel(root.right, level - 1) ;
    return Set{x, y}->max() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var root : Node ; root := null ;
     root := newNode(45) ; 
    root.left := newNode(46) ; 
    root.left.left := newNode(18) ; 
    root.left.left.left := newNode(16) ; 
    root.left.left.right := newNode(23) ; 
    root.left.right := newNode(17) ; 
    root.left.right.left := newNode(24) ; 
    root.left.right.right := newNode(21) ; 
    root.right := newNode(15) ; 
    root.right.left := newNode(22) ; 
    root.right.left.left := newNode(37) ; 
    root.right.left.right := newNode(41) ; 
    root.right.right := newNode(19) ; 
    root.right.right.left := newNode(49) ; 
    root.right.right.right := newNode(29) ; 
    var level : int ; level := 3 ;
    OclFile["System.out"].println(maxAtLevel(root, level)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B88 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int R=in.nextInt();
    int C=in.nextInt();
    int X=in.nextInt();
    int Xsquared=X*X ;
    char[][] keyboard=new char[R][];
    for(int r=0 ; r<R ; r++){
      keyboard[r]=in.next().toCharArray();
    }
    boolean[] lowercase=new boolean[26];
    boolean[] uppercase=new boolean[26];
    boolean shiftExists=false ;
    for(int r1=0 ; r1<R ; r1++){
      for(int c1=0 ; c1<C ; c1++){
        char c=keyboard[r1][c1];
        if(c=='S'){
          shiftExists=true ;
          for(int r2=0 ; r2<R ; r2++){
            for(int c2=0 ; c2<C ; c2++){
              char cc=keyboard[r2][c2];
              if(cc!='S'){
                int dr=r1-r2 ;
                int dc=c1-c2 ;
                int dist=dr*dr+dc*dc ;
                if(dist<=Xsquared){
                  uppercase[cc-'a']=true ;
                }
              }
            }
          }
        }
        else {
          lowercase[c-'a']=true ;
        }
      }
    }
    in.next();
    char[] S=in.next().toCharArray();
    boolean possible=true ;
    int answer=0 ;
    for(char c : S){
      if('a'<=c && c<='z'){
        if(! lowercase[c-'a']){
          possible=false ;
          break ;
        }
      }
      else {
        if(! uppercase[c-'A']){
          if(lowercase[c-'A'] && shiftExists){
            answer++;
          }
          else {
            possible=false ;
            break ;
          }
        }
      }
    }
    if(! possible){
      answer=-1 ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B88 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var R : int ; R := in.getCurrent()->toInteger() ;
    var C : int ; C := in.getCurrent()->toInteger() ;
    var X : int ; X := in.getCurrent()->toInteger() ;
    var Xsquared : int ; Xsquared := X * X ;
    var keyboard : Sequence(Sequence(String)) ; keyboard := Integer.subrange(1,R)->collect(Sequence{}) ;
        var r : int ; r := 0 ; while r < R do ( (     keyboard[r+1] := in.getCurrent()->characters() )  ;     r := r + 1 ) ; 
    var lowercase : Sequence(boolean) ; lowercase := Integer.subrange(1,26)->collect(false) ;
    var uppercase : Sequence(boolean) ; uppercase := Integer.subrange(1,26)->collect(false) ;
    var shiftExists : boolean ; shiftExists := false ;
        var r1 : int ; r1 := 0 ; while r1 < R do ( (         var c1 : int ; c1 := 0 ; while c1 < C do ( (     var c : String ; c := keyboard[r1+1][c1+1] ;
     if (c = 'S') then (     shiftExists := true ; 
         var r2 : int ; r2 := 0 ; while r2 < R do ( (         var c2 : int ; c2 := 0 ; while c2 < C do ( (     var cc : String ; cc := keyboard[r2+1][c2+1] ;
     if (cc /= 'S') then (     var dr : int ; dr := r1 - (r2)->char2byte() ;
     var dc : int ; dc := c1 - c2 ;
     var dist : int ; dist := dr * dr + dc * dc ;
     if (dist <= Xsquared) then (     uppercase[(cc)->char2byte() - ('a')->char2byte()+1] := true ) else skip ) else skip )  ;     c2 := c2 + 1 ) )  ;     r2 := r2 + 1 ) ) else (     lowercase[(c)->char2byte() - ('a')->char2byte()+1] := true ) )  ;     c1 := c1 + 1 ) )  ;     r1 := r1 + 1 ) ; 
    skip ; 
    var S : Sequence(String) ; S := in.getCurrent()->characters() ;
    var possible : boolean ; possible := true ;
    var answer : int ; answer := 0 ;
    for (c : S) do ( (     if ('a' <= c & c <= 'z') then (     if (not(lowercase[(c)->char2byte() - ('a')->char2byte()+1])) then (     possible := false ; 
     break ) else skip ) else (     if (not(uppercase[(c)->char2byte() - ('A')->char2byte()+1])) then (     if (lowercase[(c)->char2byte() - ('A')->char2byte()+1] & shiftExists) then (     answer := answer + 1 ) else (     possible := false ; 
     break ) ) else skip ) )  ) ; 
    if (not(possible)) then (     answer := -1 ) else skip ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float Area(float a){
    if(a<0)return-1 ;
    float h=(float)1.268*a ;
    float A=(float)(0.70477*Math.pow(h,2));
    return A ;
  }
  public static void main(String[] args){
    float a=5 ;
    System.out.println(Area(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Area( a : double) : double
  pre: true
  post: true
  activity: (     if (a < 0) then     return -1 else skip ; 
     var h : double ; h := 1.268->oclAsType(double) * a ;
     var A : double ; A := (0.70477 * h->pow(2))->oclAsType(double) ;
     return A );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 5 ;
     OclFile["System.out"].println(Area(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication58 {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    ArrayList<Long>list=new ArrayList();
    long x=input.nextLong();
    System.out.println(x);
    for(int i=0 ; i<x ; i++)System.out.print("1 ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication58 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(long) ; list := Sequence{} ;
    var x : long ; x := input.getCurrent()->toLong() ;
    OclFile["System.out"].println(x) ; 
        var i : int ; i := 0 ; while i < x do (     OclFile["System.out"].print("1 ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class P1104A {
  public static void main(String[] args)throws IOException {
    BufferedReader io=new BufferedReader(new InputStreamReader(System.in));
    Integer n=Integer.valueOf(io.readLine());
    List<Integer>rs=new ArrayList<Integer>();
    int divider=9 ;
    while(n>0){
      if(n % divider!=0){
        divider--;
      }
      else {
        rs.add(divider);
        n=n-divider ;
      }
    }
    System.out.println(rs.size());
    for(Integer integer : rs){
      System.out.print(integer+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P1104A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (io.readLine())->toInteger() ;
    var rs : Sequence(int) ; rs := Sequence{} ;
    var divider : int ; divider := 9 ;
    while (n > 0) do (     if (n mod divider /= 0) then (     divider := divider - 1 ) else (     rs := rs->including(divider) ; 
     n := n - divider ) ) ; 
    OclFile["System.out"].println(rs->size()) ; 
    for (integer : rs) do ( (     OclFile["System.out"].print(integer + " ") )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.*;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    System.out.println(k);
    for(int i=0 ; i<k ; i++){
      System.out.println(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(k) ; 
         var i : int ; i := 0 ; while i < k do ( (     OclFile["System.out"].println(1) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static void majority(int a[],int p,int q,int size){
    int start=0,ends=q ;
    int[] arr=new int[p];
    int k=0 ;
    while(k<p){
      int one=0 ;
      for(int j=start ; j<ends ; j++){
        if(a[j]==1){
          one++;
        }
      }
      start=ends ;
      ends=ends+q ;
      arr[k]=one ;
      k++;
    }
    start=0 ;
    ends=q ;
    boolean found=false ;
    while(ends>0){
      int dist_one=0 ;
      for(int i=0 ; i<p ; i++)if(arr[i]>q/2)dist_one++;
      if(dist_one>p/2){
        found=true ;
        System.out.println("Yes");
        return ;
      }
      start--;
      ends--;
      if(start<0)start=size+start ;
      int st=start,en=ends,l=0 ;
      while(en<size){
        if(a[st % size]!=a[en % size]){
          if(a[st % size]==1)arr[l]++;
          else arr[l]--;
        }
        l++;
        st=(st+q);
        en=en+q ;
      }
    }
    if(found==false){
      System.out.println("No");
    }
  }
  public static void main(String args[]){
    int p=3,q=3 ;
    int n=p*q ;
    int a[]={
      0,0,1,1,0,1,1,0,0 };
      majority(a,p,q,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation majority( a : Sequence(int), p : int, q : int, size : int) : void
  pre: true
  post: true
  activity: (     var start : int ; start := 0 ;
    var ends : int ; ends := q ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,p)->collect(0) ;
    var k : int ; k := 0 ;
    while (k < p) do (     var one : int ; one := 0 ;
         var j : int ; j := start ; while j < ends do ( (     if (a[j+1] = 1) then (     one := one + 1 ) else skip )  ;     j := j + 1 ) ; 
    start := ends ; 
    ends := ends + q ; 
    arr[k+1] := one ; 
    k := k + 1 ; 
 ) ; 
    start := 0 ; 
    ends := q ; 
    var found : boolean ; found := false ;
    while (ends > 0) do (     var dist_one : int ; dist_one := 0 ;
         var i : int ; i := 0 ; while i < p do (     if (arr[i+1] > q / 2) then     dist_one := dist_one + 1 ; else skip ;  ;     i := i + 1 ) ; 
    if (dist_one > p / 2) then (     found := true ; 
     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
    start := start - 1 ; 
    ends := ends - 1 ; 
    if (start < 0) then     start := size + start ; else skip ; 
    var st : int ; st := start ;
    var en : int ; en := ends ;
    var l : int ; l := 0 ;
    while (en < size) do (     if (a[st mod size+1] /= a[en mod size+1]) then (     if (a[st mod size+1] = 1) then     arr[l+1] := arr[l+1] + 1 ; else     arr[l+1] := arr[l+1] - 1 ; ) else skip ; 
     l := l + 1 ; 
     st := (st + q) ; 
     en := en + q ) ; 
 ) ; 
    if (found = false) then (     OclFile["System.out"].println("No") ) else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : int ; p := 3 ;
    var q : int ; q := 3 ;
     var n : int ; n := p * q ;
     var a : Sequence(int) ; a := Sequence{0,0,1,1,0,1,1,0,0} ;
     execute majority(a, p, q, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static double sumProductDifference(int a,int b,int c,int d,int e){
    double rootSum=(double)(-1*b)/a ;
    double rootProduct=(double)e/a ;
    return Math.abs(rootSum-rootProduct);
  }
  public static void main(String args[]){
    System.out.println(sumProductDifference(8,4,6,4,1));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumProductDifference( a : int, b : int, c : int, d : int, e : int) : double
  pre: true
  post: true
  activity: (     var rootSum : double ; rootSum := (-1 * b)->oclAsType(double) / a ;
     var rootProduct : double ; rootProduct := e->oclAsType(double) / a ;
     return if rootSum - rootProduct < 0 then -(rootSum - rootProduct) else rootSum - rootProduct endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(sumProductDifference(8, 4, 6, 4, 1)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void createHash(HashSet<Integer>hash,int maxElement){
    int prev=0,curr=1 ;
    hash.add(prev);
    hash.add(curr);
    while(curr<=maxElement){
      int temp=curr+prev ;
      hash.add(temp);
      prev=curr ;
      curr=temp ;
    }
  }
  static void fibonacci(int arr[],int n){
    int max_val=Arrays.stream(arr).max().getAsInt();
    HashSet<Integer>hash=new HashSet<Integer>();
    createHash(hash,max_val);
    int minimum=Integer.MAX_VALUE ;
    int maximum=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(hash.contains(arr[i])){
        minimum=Math.min(minimum,arr[i]);
        maximum=Math.max(maximum,arr[i]);
      }
    }
    System.out.print(minimum+","+maximum+"\n");
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,6,7 };
      int n=arr.length ;
      fibonacci(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation createHash( hash : Set(int), maxElement : int) : void
  pre: true
  post: true
  activity: (     var prev : int ; prev := 0 ;
    var curr : int ; curr := 1 ;
     hash->excludes(prev) ; 
     hash->excludes(curr) ; 
     while (curr <= maxElement) do (     var temp : int ; temp := curr + prev ;
     hash->excludes(temp) ; 
     prev := curr ; 
     curr := temp ) );
  static   operation fibonacci( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var max_val : int ; max_val := stream(arr).max().getAsInt() ;
     var hash : Set(int) ; hash := Set{} ;
    execute createHash(hash, max_val) ; 
    var minimum : int ; minimum := 2147483647 ;
    var maximum : int ; maximum := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     if (hash->includes(arr[i+1])) then (     minimum := Set{minimum, arr[i+1]}->min() ; 
     maximum := Set{maximum, arr[i+1]}->max() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(minimum + "," + maximum + "\n") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6,7} ;
     var n : int ; n := arr->size() ;
     execute fibonacci(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    ArrayList<Integer>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      int mode=sc.nextInt();
      if(mode==0){
        list.add(sc.nextInt());
      }
      else if(mode==1){
        System.out.println(list.get(sc.nextInt()));
      }
      else if(mode==2){
        list.remove(list.size()-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var list : Sequence(int) ; list := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     var mode : int ; mode := sc.getCurrent()->toInteger() ;
     if (mode = 0) then (     list := list->including(sc.getCurrent()->toInteger()) ) else     if (mode = 1) then (     OclFile["System.out"].println(list->at(sc.getCurrent()->toInteger()+1)) ) else     if (mode = 2) then (     list := list->excludingFirst(list->size() - 1) ) else skip ; ;  )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      int q=Integer.parseInt(br.readLine());
      List<String>vector=new ArrayList<>();
      String[] query ;
      int op ;
      Integer num ;
      for(int i=0 ; i<q ; i++){
        query=br.readLine().split(" ");
        switch(query[0]){
          case "0" : vector.add(query[1]);
          break ;
          case "1" : System.out.println(vector.get(Integer.parseInt(query[1])));
          break ;
          case "2" : vector.remove(vector.size()-1);
          break ;
          default : }
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var q : int ; q := (br.readLine())->toInteger() ;
     var vector : Sequence(String) ; vector := Sequence{} ;
    var query : Sequence(String) ;
    var op : int ;
    var num : int ;
        var i : int ; i := 0 ; while i < q do ( (     query := br.readLine()->split(" ") ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (query[0+1]) ; 
       if _switchval = "0" then
     vector := vector->including(query[1+1]) ; 
    break 
   else skip ;
       if _switchval = "1" then
     OclFile["System.out"].println(vector->at((query[1+1])->toInteger()+1)) ; 
    break 
   else skip ;
       if _switchval = "2" then
     vector := vector->excludingFirst(vector->size() - 1) ; 
    break 
   else skip ;
   if true then
 )
 )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Vector {
  int[] A ;
  int length=0 ;
  Vector(int n){
    A=new int[n];
  }
  void add(int x){
    if(length==A.length){
      A=Arrays.copyOf(A,length*2);
    }
    A[length]=x ;
    length++;
  }
  int get(int i){
    return A[i];
  }
  void deleteBack(){
    length--;
  }
}
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    Vector v=new Vector(20);
    for(int i=0 ; i<q ; ++i){
      switch(sc.nextInt()){
        case 0 : v.add(sc.nextInt());
        break ;
        case 1 : System.out.println(v.get(sc.nextInt()));
        break ;
        case 2 : v.deleteBack();
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Vector {
   attribute A : Sequence(int);
   attribute length : int := 0;
   static operation newVector( n : int) : Vector
  pre: true
  post: true
  activity:
  ( var self : Vector ;
    self := createVector();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     A := Integer.subrange(1,n)->collect(0) );
   operation add( x : int) : void
  pre: true
  post: true
  activity: (     if (length = A->size()) then (     A := A.subrange(1,length * 2) ) else skip ; 
     A[length+1] := x ; 
     length := length + 1 );
   operation get( i : int) : int
  pre: true
  post: true
  activity: (     return A[i+1] );
   operation deleteBack() : void
  pre: true
  post: true
  activity: (     length := length - 1 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
     var v : Sequence ; v := Sequence{} ;
         var i : int ; i := 0 ; while i < q do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (sc.getCurrent()->toInteger()) ; 
       if _switchval = 0 then
     v := v->including(sc.getCurrent()->toInteger()) ; 
    break 
   else skip ;
       if _switchval = 1 then
     OclFile["System.out"].println(v->at(sc.getCurrent()->toInteger()+1)) ; 
    break 
   else skip ;
       if _switchval = 2 then
     v := v.deleteBack() ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] tmp=br.readLine().split(" ");
    int[] arr=Arrays.asList(tmp).stream().mapToInt(x->Integer.parseInt(x)).toArray();
    long[][] dp=new long[n][21];
    dp[0][arr[0] ]=1 ;
    for(int i=1 ; i<n-1 ; i++){
      for(int j=0 ; j<21 ; j++){
        if(dp[i-1][j]<=0){
          continue ;
        }
        if(j+arr[i]<=20){
          dp[i][j+arr[i] ]+=dp[i-1][j];
        }
        if(j-arr[i]>=0){
          dp[i][j-arr[i] ]+=dp[i-1][j];
        }
      }
    }
    int answer=arr[n-1];
    long count=dp[n-2][answer];
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var tmp : Sequence(String) ; tmp := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := tmp->collect( _x1 | (lambda x : OclAny in (x)->toInteger())->apply(_x1) )->asSequence() ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,21)->collect(0)) ;
    dp[0+1][arr[0+1]+1] := 1 ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (         var j : int ; j := 0 ; while j < 21 do ( (     if (dp[i - 1+1][j+1] <= 0) then (     continue ) else skip ; 
     if (j + arr[i+1] <= 20) then (     dp[i+1][j + arr[i+1]+1] := dp[i+1][j + arr[i+1]+1]+(dp[i - 1+1][j+1]) ) else skip ; 
     if (j - arr[i+1] >= 0) then (     dp[i+1][j - arr[i+1]+1] := dp[i+1][j - arr[i+1]+1]+(dp[i - 1+1][j+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var answer : int ; answer := arr[n - 1+1] ;
    var count : long ; count := dp[n - 2+1][answer+1] ;
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    for(; ; ){
      String str=br.readLine();
      double a=Double.parseDouble(str.substring(0,str.indexOf(" ")));
      int i=str.indexOf(" ");
      String b=str.substring(i+1,str.indexOf(" ",i+1));
      double c=Double.parseDouble(str.substring(str.indexOf(" ",i+1)));
      double d=0 ;
      ;
      if(b.equals("?"))break ;
      else if(b.equals("+"))d=a+c ;
      else if(b.equals("-"))d=a-c ;
      else if(b.equals("*"))d=a*c ;
      else if(b.equals("/"))d=a/c ;
      System.out.println((int)d);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
       while true do ( (     var str : String ; str := br.readLine() ;
     var a : double ; a := (str.subrange(0+1,str->indexOf(" ")-1))->toReal() ;
    var i : int ; i := str->indexOf(" ")-1 ;
    var b : String ; b := str.subrange(i + 1+1,str.subrange(i + 1+1)->indexOf(" "+"") + i + 1 - 1 ) ;
    var c : double ; c := (str.subrange(str.subrange(i + 1+1)->indexOf(" "+"") + i + 1 - 1 +1,str.subrange(i + 1+1)->indexOf(" "+"") + i + 1 - 1 ))->toReal() ;
    var d : double ; d := 0 ;
    if (b = "?") then     break else     if (b = "+") then     d := a + c else     if (b = "-") then     d := (a)->char2byte() - (c)->char2byte() else     if (b = "*") then     d := a * c else     if (b = "/") then     d := a / c ; else skip ; ;  ;  ;  ;  
    OclFile["System.out"].println(d->oclAsType(int)) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    Arrays.sort(a);
    int ans=0 ;
    for(int i=0 ; i<k ; i++){
      ans+=a[i];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     ans := ans+(a[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.*;
import java.math.*;
import java.util.Arrays ;
class Main {
  long even[]=new long[1000];
  long gcd(long a,long b){
    return b==0 ? a : gcd(b,a % b);
  }
  void solve(int n,long oddmin){
    Arrays.sort(even,0,n);
    long ta=even[0];
    for(int i=0 ; i<n ; i++){
      ta=gcd(ta,even[i]);
    }
    long tx0=even[0]/ta,tx1=even[1]/ta ;
    long g2=oddmin/tx0/tx1 ;
    long g=(long)(Math.sqrt(g2));
    long evenans=ta/g ;
    System.out.println(evenans);
    for(int i=0 ; i<n ; i++){
      if(i!=0)System.out.print(" ");
      System.out.print(even[i]/evenans);
    }
    System.out.print("\n");
  }
  void run(){
    Scanner in=new Scanner(System.in);
    int n ;
    while(true){
      n=in.nextInt();
      if(n==0)break ;
      int m=n*(n+1)/2 ;
      int evenp=0 ;
      long oddmin=9223372036854775807L ;
      for(int i=0 ; i<m ; i++){
        long tmp ;
        tmp=in.nextLong();
        if(tmp % 2==0)even[evenp++]=tmp ;
        else oddmin=(oddmin>tmp)? tmp : oddmin ;
      }
      solve(n,oddmin);
    }
  }
  public static void main(String args[]){
    Main a=new Main();
    a.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute even : long := Integer.subrange(1,1000)->collect(0);
   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
   operation solve( n : int, oddmin : long) : void
  pre: true
  post: true
  activity: (     even := even.subrange(1,0)^(even.subrange(0+1,n)->sort())^even.subrange(n+1,even.size) ; 
     var ta : long ; ta := even[0+1] ;
        var i : int ; i := 0 ; while i < n do ( (     ta := gcd(ta, even[i+1]) )  ;     i := i + 1 ) ; 
    var tx0 : long ; tx0 := even[0+1] / ta ;
    var tx1 : long ; tx1 := even[1+1] / ta ;
    var g2 : long ; g2 := oddmin / tx0 / tx1 ;
    var g : long ; g := ((g2)->sqrt())->oclAsType(long) ;
    var evenans : long ; evenans := ta / g ;
    OclFile["System.out"].println(evenans) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i /= 0) then     OclFile["System.out"].print(" ") ; else skip ; 
     OclFile["System.out"].print(even[i+1] / evenans) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("\n") ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
     while (true) do (     n := in.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
    var m : int ; m := n * (n + 1) / 2 ;
    var evenp : int ; evenp := 0 ;
    var oddmin : long ; oddmin := 9223372036854775807L ;
        var i : int ; i := 0 ; while i < m do ( (     var tmp : long ;
     tmp := in.getCurrent()->toLong() ; 
     if (tmp mod 2 = 0) then      even[evenp+1] := tmp  ; evenp := evenp + 1 ; else     oddmin := if (oddmin > tmp) then tmp else oddmin endif ; )  ;     i := i + 1 ) ; 
    execute solve(n, oddmin) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Main ; a := Main.newMain() ;
     a.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int a=scan.nextInt();
    for(int i=0 ; i<a ; i++){
      int b=scan.nextInt();
      if(b==0){
        int c=scan.nextInt();
        kadai.pushBack(c);
      }
      else if(b==1){
        int c=scan.nextInt();
        int ab=kadai.randomAccess(c);
        System.out.println(ab);
      }
      else if(b==2){
        kadai.popBack();
      }
    }
    scan.close();
  }
}
class kadai {
  static ArrayList<Integer>retu=new ArrayList<>();
  static void pushBack(int a){
    retu.add(a);
  }
  static int randomAccess(int a){
    int d=0 ;
    d=retu.get(a);
    return d ;
  }
  static void popBack(){
    int d=0 ;
    d=retu.size();
    retu.remove(d-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < a do ( (     var b : int ; b := scan.getCurrent()->toInteger() ;
     if (b = 0) then (     var c : int ; c := scan.getCurrent()->toInteger() ;
     kadai.pushBack(c) ) else     if (b = 1) then (     var c : int ; c := scan.getCurrent()->toInteger() ;
     var ab : int ; ab := kadai.randomAccess(c) ;
     OclFile["System.out"].println(ab) ) else     if (b = 2) then (     kadai.popBack() ) else skip ; ;  )  ;     i := i + 1 ) ; 
     skip );
}
class kadai {
  static   attribute retu : Sequence(int) := Sequence{};
  static   operation pushBack( a : int) : void
  pre: true
  post: true
  activity: (     retu := retu->including(a) );
  static   operation randomAccess( a : int) : int
  pre: true
  post: true
  activity: (     var d : int ; d := 0 ;
     d := retu->at(a+1) ; 
     return d );
  static   operation popBack() : void
  pre: true
  post: true
  activity: (     var d : int ; d := 0 ;
     d := retu->size() ; 
     retu := retu->excludingFirst(d - 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    List<Integer>A=new ArrayList<>();
    int x ;
    int q ;
    int y ;
    x=sc.nextInt();
    for(int i=0 ; i<x ; i++){
      q=sc.nextInt();
      if(q==0){
        y=sc.nextInt();
        A.add(y);
      }
      else if(q==1){
        y=sc.nextInt();
        System.out.println(A.get(y));
      }
      else if(q==2){
        A.remove(A.size()-1);
      }
      else {
        System.out.println("error");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : Sequence(int) ; A := Sequence{} ;
    var x : int ;
    var q : int ;
    var y : int ;
    x := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < x do ( (     q := sc.getCurrent()->toInteger() ; 
     if (q = 0) then (     y := sc.getCurrent()->toInteger() ; 
     A := A->including(y) ) else     if (q = 1) then (     y := sc.getCurrent()->toInteger() ; 
     OclFile["System.out"].println(A->at(y+1)) ) else     if (q = 2) then (     A := A->excludingFirst(A->size() - 1) ) else (     OclFile["System.out"].println("error") ) ;  ;  )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] arr=new int[n];
    HashMap<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      map.put(arr[i],map.getOrDefault(arr[i],0)+1);
    }
    int bad=0 ;
    int good=0 ;
    for(Map.Entry e : map.entrySet()){
      int num=(Integer)e.getValue();
      bad+=(num % 2);
      good+=((num/2)*2);
    }
    int ans=good+((bad+1)/2);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     map := map->union(Map{arr[i+1] |-> (if map->keys()->contains(arr[i+1]) then map->at(arr[i+1]) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var bad : int ; bad := 0 ;
    var good : int ; good := 0 ;
    for (e : map->asSet()) do ( (     var num : int ; num := e.getValue()->oclAsType(int) ;
     bad := bad+((num mod 2)) ; 
     good := good+(((num / 2) * 2)) )  ) ; 
    var ans : int ; ans := good + ((bad + 1) / 2) ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
public class DrinksChoosing {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] inp=br.readLine().split(" ");
    int size=Integer.parseInt(inp[0]);
    int set=Integer.parseInt(inp[1]);
    HashMap<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<size ; i++){
      int p=Integer.parseInt(br.readLine());
      map.put(p,map.getOrDefault(p,0)+1);
    }
    int count=0 ;
    int rem=0 ;
    for(int i : map.keySet()){
      int n=map.get(i);
      if(n % 2==0)count+=n ;
      else {
        if(rem==0){
          count+=n ;
          rem+=1 ;
        }
        else {
          count+=n-1 ;
          rem--;
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class DrinksChoosing {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var inp : Sequence(String) ; inp := br.readLine()->split(" ") ;
    var size : int ; size := (inp[0+1])->toInteger() ;
    var set : int ; set := (inp[1+1])->toInteger() ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < size do ( (     var p : int ; p := (br.readLine())->toInteger() ;
     map := map->union(Map{p |-> (if map->keys()->contains(p) then map->at(p) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var rem : int ; rem := 0 ;
    for (i : map->keys()) do ( (     var n : int ; n := map->at(i) ;
     if (n mod 2 = 0) then     count := count+(n) ; else (     if (rem = 0) then (     count := count+(n) ; 
     rem := rem+(1) ) else (     count := count+(n - 1) ; 
     rem := rem - 1 ) ) )  ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class _0713DrinksChoosing {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int students=sc.nextInt();
    int drinks=sc.nextInt();
    int[] arr=new int[drinks+1];
    for(int i=0 ; i<students ; i++){
      arr[sc.nextInt()]++;
    }
    int count=0 ;
    for(int i=0 ; i<arr.length ; i++){
      count+=2*(arr[i]/2);
    }
    count+=((students+2-1)/2-count/2);
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _0713DrinksChoosing {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var students : int ; students := sc.getCurrent()->toInteger() ;
    var drinks : int ; drinks := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,drinks + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < students do ( (     arr[sc.getCurrent()->toInteger()+1] := arr[sc.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     count := count+(2 * (arr[i+1] / 2)) )  ;     i := i + 1 ) ; 
    count := count+(((students + 2 - 1) / 2 - count / 2)) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
import java.util.StringTokenizer ;
public class DrinksChoosing {
  public static void main(String[] args){
    FastReader in=new FastReader();
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt();
    int k=in.nextInt();
    int[] freq=new int[k];
    for(int i=0 ; i<n ; i++){
      freq[in.nextInt()-1]++;
    }
    int i=k-1 ;
    int good=0 ;
    while(i>=0){
      good+=freq[i]/2 ;
      i--;
    }
    out.println((good*2+(n-good*2+1)/2));
    out.close();
  }
  static void sort(int[] a){
    ArrayList<Integer>l=new ArrayList<>();
    for(int i : a)l.add(i);
    Collections.sort(l);
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DrinksChoosing {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.nextInt() ;
    var k : int ; k := in.nextInt() ;
    var freq : Sequence(int) ; freq := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     freq[in.nextInt() - 1+1] := freq[in.nextInt() - 1+1] + 1 )  ;     i := i + 1 ) ; 
    var i : int ; i := k - 1 ;
    var good : int ; good := 0 ;
    while (i >= 0) do (     good := good+(freq[i+1] / 2) ; 
     i := i - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l := l->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long A=sc.nextLong();
    long B=sc.nextLong();
    if(A==B){
      System.out.println(1);
    }
    else {
      int abi=62 ;
      for(; abi>=0 ; abi--)if(((A ^ B)&(1l<<abi))!=0)break ;
      long mask=(1l<<abi)-1 ;
      long ans=mask-(A & mask)+1 ;
      int bi=abi-1 ;
      for(; bi>=0 ; bi--)if(((1l<<bi)& B)!=0)break ;
      long temp=1l<<(bi+1);
      ans+=temp+(1l<<abi)-Math.max(temp,A & mask);
      System.out.println(ans);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : long ; A := sc.getCurrent()->toLong() ;
    var B : long ; B := sc.getCurrent()->toLong() ;
    if (A = B) then (     OclFile["System.out"].println(1) ) else (     var abi : int ; abi := 62 ;
       while abi >= 0 do (     if (((MathLib.bitwiseXor(A,B)) & ((1l*(2->pow(abi)))->oclAsType(long))) /= 0) then     break else skip ;  ;     abi := abi - 1 ) ; 
    var mask : long ; mask := ((1l*(2->pow(abi)))->oclAsType(long)) - 1 ;
    var ans : long ; ans := mask - (MathLib.bitwiseAnd(A,mask)) + 1 ;
    var bi : int ; bi := abi - 1 ;
      while bi >= 0 do (     if ((((1l*(2->pow(bi)))->oclAsType(long)) & B) /= 0) then     break else skip ;  ;     bi := bi - 1 ) ; 
    var temp : long ; temp := (1l*(2->pow((bi + 1))))->oclAsType(long) ;
    ans := ans+(temp + ((1l*(2->pow(abi)))->oclAsType(long)) - Set{temp, MathLib.bitwiseAnd(A,mask)}->max()) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    long A=sc.nextLong();
    long B=sc.nextLong();
    while(A>0 && Long.highestOneBit(A)==Long.highestOneBit(B)){
      long flip=Long.highestOneBit(A);
      A ^=flip ;
      B ^=flip ;
    }
    if(B==0){
      System.out.println(1);
      return ;
    }
    int first=Long.numberOfTrailingZeros(Long.highestOneBit(B));
    int second=-1 ;
    if(B==(1L<<first)){
      second=-1 ;
    }
    else {
      second=Long.numberOfTrailingZeros(Long.highestOneBit(B ^(1L<<first)));
    }
    long l1=A ;
    long r1=((1L<<first)+((1L<<(second+1))-1));
    long l2=A+(1L<<first);
    long r2=(1L<<(first+1))-1 ;
    long res=-1 ;
    if(l2<=r1 && r1<=r2){
      res=r2-l1+1 ;
    }
    else if(l1<=r2 && r2<=r1){
      res=r1-l1+1 ;
    }
    else if(r1<=l2){
      res=(r1-l1+1)+(r2-l2+1);
    }
    System.out.println(res);
  }
  static void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : long ; A := sc.getCurrent()->toLong() ;
    var B : long ; B := sc.getCurrent()->toLong() ;
    while (A > 0 & highestOneBit(A) = highestOneBit(B)) do (     var flip : long ; flip := highestOneBit(A) ;
     A := MathLib.bitwiseXor(A,flip) ; 
     B := MathLib.bitwiseXor(B,flip) ) ; 
    if (B = 0) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    var first : int ; first := numberOfTrailingZeros(highestOneBit(B)) ;
    var second : int ; second := -1 ;
    if (B = ((1L*(2->pow(first)))->oclAsType(long))) then (     second := -1 ) else (     second := numberOfTrailingZeros(highestOneBit(MathLib.bitwiseXor(B,((1L*(2->pow(first)))->oclAsType(long))))) ) ;  
    var l1 : long ; l1 := A ;
    var r1 : long ; r1 := (((1L*(2->pow(first)))->oclAsType(long)) + (((1L*(2->pow((second + 1))))->oclAsType(long)) - 1)) ;
    var l2 : long ; l2 := A + ((1L*(2->pow(first)))->oclAsType(long)) ;
    var r2 : long ; r2 := ((1L*(2->pow((first + 1))))->oclAsType(long)) - 1 ;
    var res : long ; res := -1 ;
    if (l2 <= r1 & r1 <= r2) then (     res := r2 - l1 + 1 ) else     if (l1 <= r2 & r2 <= r1) then (     res := r1 - l1 + 1 ) else     if (r1 <= l2) then (     res := (r1 - l1 + 1) + (r2 - l2 + 1) ) else skip ; ;  ;  
    OclFile["System.out"].println(res) ; 
 );
  static   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long A=sc.nextLong();
    long B=sc.nextLong();
    System.out.println(calc(A,B));
  }
  public static long calc(long A,long B){
    if(A==B){
      return 1 ;
    }
    long ans=0 ;
    long k=1 ;
    for(int i=0 ; i<=60 ; i++){
      k=k*2 ;
    }
    while((A & k)==(B & k)){
      A=(A | k)^ k ;
      B=(B | k)^ k ;
      k=k/2 ;
    }
    long s1=k-A ;
    long s2=k-A ;
    long s3=maxbit(B-k);
    ans=s1+s2+s3 ;
    long rb=k+s3-1 ;
    long lb=k+A ;
    if(rb>=lb){
      ans=ans-(rb-lb+1);
    }
    return ans ;
  }
  public static long maxbit(long n){
    if(n==0){
      return 1 ;
    }
    long k=1,ans=0 ;
    for(int i=0 ; i<=60 ; i++){
      if((n & k)>0){
        ans=k ;
      }
      k=k*2 ;
    }
    return ans*2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : long ; A := sc.getCurrent()->toLong() ;
     var B : long ; B := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println(calc(A, B)) );
  static   operation calc( A : long, B : long) : long
  pre: true
  post: true
  activity: (     if (A = B) then (     return 1 ) else skip ; 
     var ans : long ; ans := 0 ;
    var k : long ; k := 1 ;
        var i : int ; i := 0 ; while i <= 60 do ( (     k := k * 2 )  ;     i := i + 1 ) ; 
    while ((MathLib.bitwiseAnd(A,k)) = (MathLib.bitwiseAnd(B,k))) do (     A := (MathLib.bitwiseOr(A,k)) xor k ; 
     B := (MathLib.bitwiseOr(B,k)) xor k ; 
     k := k / 2 ) ; 
    var s1 : long ; s1 := k - A ;
    var s2 : long ; s2 := k - A ;
    var s3 : long ; s3 := maxbit(B - k) ;
    ans := s1 + s2 + s3 ; 
    var rb : long ; rb := k + s3 - 1 ;
    var lb : long ; lb := k + A ;
    if (rb >= lb) then (     ans := ans - (rb - lb + 1) ) else skip ; 
    return ans 
 );
  static   operation maxbit( n : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then (     return 1 ) else skip ; 
     var k : long ; k := 1 ;
    var ans : long ; ans := 0 ;
         var i : int ; i := 0 ; while i <= 60 do ( (     if ((n & k) > 0) then (     ans := k ) else skip ; 
     k := k * 2 )  ;     i := i + 1 ) ; 
     return ans * 2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Solution sol=new Solution();
    sol.solve(in,out);
    out.close();
  }
  private static class Solution {
    private void solve(InputReader in,PrintWriter out){
      int n=in.ni(),k=in.ni();
      int[] a=new int[n];
      for(int i=0 ; i<n ; ++i)a[i]=in.ni();
      Arrays.parallelSort(a);
      int ans=0 ;
      for(int i=0 ; i<k ; ++i)ans+=a[i];
      out.println(ans);
    }
  }
  private static class InputReader {
    private BufferedReader reader ;
    private StringTokenizer tokenizer ;
    private InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    private String n(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    private int ni(){
      return Integer.parseInt(n());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var sol : Solution ; sol := Solution.newSolution() ;
    sol.solve(in, out) ; 
    skip ; 
 );
  static class Solution {
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.ni() ;
    var k : int ; k := in.ni() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.ni() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < k do (     ans := ans+(a[i+1]) ;  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation n() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (n())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner io=new Scanner(System.in);
    long A=io.nextLong();
    long B=io.nextLong();
    System.out.println(orNum(A,B));
  }
  public static long orNum(long A,long B){
    long q=1L<<59 ;
    for(; q>0 ; q=q>>1){
      if((A & q)==0 &&(B & q)==0)continue ;
      if((A & q)!=0 &&(B & q)!=0){
        A-=q ;
        B-=q ;
        continue ;
      }
      if((A & q)==0 &&(B & q)!=0){
        break ;
      }
      if(((A & q)!=0 &&(B & q)==0)){
        return 0 ;
      }
    }
    if(A==B){
      return 1 ;
    }
    long ans=q-A ;
    ans=ans*2+1 ;
    B-=q ;
    ans+=Math.min(A-1,orNum(1,B));
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : long ; A := io.getCurrent()->toLong() ;
     var B : long ; B := io.getCurrent()->toLong() ;
     OclFile["System.out"].println(orNum(A, B)) );
  static   operation orNum( A : long, B : long) : long
  pre: true
  post: true
  activity: (     var q : long ; q := (1L*(2->pow(59)))->oclAsType(long) ;
       while q > 0 do ( (     if ((MathLib.bitwiseAnd(A,q)) = 0 & (MathLib.bitwiseAnd(B,q)) = 0) then     continue else skip ; 
     if ((MathLib.bitwiseAnd(A,q)) /= 0 & (MathLib.bitwiseAnd(B,q)) /= 0) then (     A := A-(q) ; 
     B := B-(q) ; 
     continue ) else skip ; 
     if ((MathLib.bitwiseAnd(A,q)) = 0 & (MathLib.bitwiseAnd(B,q)) /= 0) then (     break ) else skip ; 
     if (((MathLib.bitwiseAnd(A,q)) /= 0 & (MathLib.bitwiseAnd(B,q)) = 0)) then (     return 0 ) else skip )  ;     q := (q/(2->pow(1)))->oclAsType(long) ) ; 
    if (A = B) then (     return 1 ) else skip ; 
    var ans : long ; ans := q - A ;
    ans := ans * 2 + 1 ; 
    B := B-(q) ; 
    ans := ans+(Set{A - 1, orNum(1, B)}->min()) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      long[] e=new long[n];
      long[] o=new long[n*(n-1)/2];
      for(int i=0 ; i<n ; i++){
        e[i]=sc.nextLong();
      }
      for(int i=0 ; i<o.length ; i++){
        o[i]=sc.nextLong();
      }
      Arrays.sort(e);
      Arrays.sort(o);
      if(o[0]==0){
      }
      BigInteger bi=new BigInteger(""+e[0]);
      bi=bi.multiply(new BigInteger(""+e[1]));
      bi=bi.divide(new BigInteger(""+o[0]));
      long E=(long)Math.sqrt(Long.parseLong(bi.toString()));
      System.out.println(E);
      for(int i=0 ; i<e.length ; i++){
        if(E==0){
        }
        System.out.print(e[i]/E);
        if(i!=e.length-1)System.out.print(" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var e : Sequence(long) ; e := Integer.subrange(1,n)->collect(0) ;
    var o : Sequence(long) ; o := Integer.subrange(1,n * (n - 1) / 2)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     e[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < o->size() do ( (     o[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    e := e->sort() ; 
    o := o->sort() ; 
    if (o[0+1] = 0) then skip else skip ; 
    var bi : long ; bi := long("" + e[0+1]) ;
    bi := bi.multiply(long("" + e[1+1])) ; 
    bi := bi.divide(long("" + o[0+1])) ; 
    var E : long ; E := ((bi+"")->toLong())->sqrt()->oclAsType(long) ;
    OclFile["System.out"].println(E) ; 
        var i : int ; i := 0 ; while i < e->size() do ( (     if (E = 0) then skip else skip ; 
     OclFile["System.out"].print(e[i+1] / E) ; 
     if (i /= e->size() - 1) then     OclFile["System.out"].print(" ") ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    long A=scan.nextLong();
    long B=scan.nextLong();
    long[] two=new long[61];
    two[0]=1 ;
    for(int i=1 ; i<61 ; i++){
      two[i]=two[i-1]*2 ;
    }
    int maxk=0 ;
    out : for(int j=60 ;
    j>=0 ;
    j--){
      for(int i=j ; i>=0 ; i--){
        if(A<=two[i] && B>=two[i]){
          maxk=i ;
          break out ;
        }
        if(i==0){
          for(int k=1 ; k<=60 ; k++){
            if(A<two[k]){
              A-=two[k-1];
              B-=two[k-1];
              break ;
            }
          }
        }
      }
    }
    long ans=two[maxk]-A ;
    B-=two[maxk];
    int maxk_=0 ;
    for(int i=0 ; i<=60 ; i++){
      if(B<two[i]){
        maxk_=i ;
        break ;
      }
    }
    ans+=two[maxk_];
    if(two[maxk_]<=A){
      ans+=two[maxk]-A ;
    }
    else {
      ans+=two[maxk]-two[maxk_];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : long ; A := scan.getCurrent()->toLong() ;
    var B : long ; B := scan.getCurrent()->toLong() ;
    var two : Sequence(long) ; two := Integer.subrange(1,61)->collect(0) ;
    two[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < 61 do ( (     two[i+1] := two[i - 1+1] * 2 )  ;     i := i + 1 ) ; 
    var maxk : int ; maxk := 0 ;
        var j : int ; j := 60 ; while j >= 0 do ( (         var i : int ; i := j ; while i >= 0 do ( (     if (A <= two[i+1] & B >= two[i+1]) then (     maxk := i ; 
     break ) else skip ; 
     if (i = 0) then (         var k : int ; k := 1 ; while k <= 60 do ( (     if (A < two[k+1]) then (     A := A-(two[k - 1+1]) ; 
     B := B-(two[k - 1+1]) ; 
     break ) else skip )  ;     k := k + 1 ) ) else skip )  ;     i := i - 1 ) )  ;     j := j - 1 ) ; 
    var ans : long ; ans := two[maxk+1] - A ;
    B := B-(two[maxk+1]) ; 
    var maxk_ : int ; maxk_ := 0 ;
        var i : int ; i := 0 ; while i <= 60 do ( (     if (B < two[i+1]) then (     maxk_ := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    ans := ans+(two[maxk_+1]) ; 
    if (two[maxk_+1] <= A) then (     ans := ans+(two[maxk+1] - A) ) else (     ans := ans+(two[maxk+1] - two[maxk_+1]) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int sumDigitSquare(int n){
    int sq=0 ;
    while(n>0){
      int digit=n % 10 ;
      sq+=digit*digit ;
      n=n/10 ;
    }
    return sq ;
  }
  static boolean isHappy(int n){
    HashSet<Integer>s=new HashSet<Integer>();
    s.add(n);
    while(true){
      if(n==1)return true ;
      n=sumDigitSquare(n);
      if((s.contains(n)&& n!=(int)s.toArray()[s.size()-1]))return false ;
      s.add(n);
    }
  }
  public static void main(String[] args){
    int n=23 ;
    if(isHappy(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumDigitSquare( n : int) : int
  pre: true
  post: true
  activity: (     var sq : int ; sq := 0 ;
     while (n > 0) do (     var digit : int ; digit := n mod 10 ;
     sq := sq+(digit * digit) ; 
     n := n / 10 ) ; 
     return sq );
  static   operation isHappy( n : int) : boolean
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
     s := s->including(n) ; 
     while (true) do (     if (n = 1) then     return true else skip ; 
     n := sumDigitSquare(n) ; 
     if ((s->includes(n) & n /= s->asSequence()[s->size() - 1+1]->oclAsType(int))) then     return false else skip ; 
     s := s->including(n) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 23 ;
     if (isHappy(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  static FastReader sc=null ;
  public static void main(String[] args){
    sc=new FastReader();
    int t=sc.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      int n=sc.nextInt();
      int a[]=sc.readArray(n);
      ruffleSort(a);
      long left=a[0],right=0 ;
      boolean good=false ;
      for(int l=1,r=n-1 ; l<r ; l++,r--){
        left+=a[l];
        right+=a[r];
        if(right>left){
          good=true ;
          break ;
        }
      }
      System.out.println(good ? "YES" : "NO");
    }
  }
  static int[] ruffleSort(int a[]){
    ArrayList<Integer>al=new ArrayList<>();
    for(int i : a)al.add(i);
    Collections.sort(al);
    for(int i=0 ; i<a.length ; i++)a[i]=al.get(i);
    return a ;
  }
  static void print(int a[]){
    for(int e : a){
      System.out.print(e+" ");
    }
    System.out.println();
  }
  static class FastReader {
    StringTokenizer st=new StringTokenizer("");
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String next(){
      while(! st.hasMoreTokens())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());
    }
    int[] readArray(int n){
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute sc : FastReader := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := FastReader.newFastReader() ; 
     var t : int ; t := sc.nextInt() ;
         var tt : int ; tt := 0 ; while tt < t do ( (     var n : int ; n := sc.nextInt() ;
     var a : Sequence(int) ; a := sc.readArray(n) ;
    execute ruffleSort(a) ; 
    var left : long ; left := a[0+1] ;
    var right : long ; right := 0 ;
    var good : boolean ; good := false ;
        var l : int ; l := 1 ;
    var r : int ; r := n - 1 ; while l < r do ( (     left := left+(a[l+1]) ; 
     right := right+(a[r+1]) ; 
     if (right > left) then (     good := true ; 
     break ) else skip )  ;     l := l + 1 ;     r := r - 1 ) ; 
    OclFile["System.out"].println(if good then "YES" else "NO" endif) ; 
 )  ;     tt := tt + 1 ) );
  static   operation ruffleSort( a : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var al : Sequence(int) ; al := Sequence{} ;
     for (i : a) do (     al := al->including(i) ;  ) ; 
    al := al->sort() ; 
        var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := al->at(i+1) ;  ;     i := i + 1 ) ; 
    return a 
 );
  static   operation print( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     for (e : a) do ( (     OclFile["System.out"].print(e + " ") )  ) ; 
     OclFile["System.out"].println() );
  static class FastReader {
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
public class Sequence {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    StringBuilder result=new StringBuilder();
    for(int i=0 ; i<t ; i++){
      int n=scan.nextInt();
      List<Long>a=new ArrayList<>();
      for(int j=0 ; j<n ; j++){
        a.add(scan.nextLong());
      }
      Collections.sort(a);
      String res="NO" ;
      int k=1 ;
      long sumLargest=a.get(n-1);
      long sumSmallest=a.get(0)+a.get(1);
      while(sumLargest<=sumSmallest){
        k++;
        if(k<n-k){
          sumLargest+=a.get(n-k);
          sumSmallest+=a.get(k);
        }
        else {
          break ;
        }
      }
      if(sumLargest>sumSmallest){
        res="YES" ;
      }
      result.append(res+"\n");
    }
    System.out.println(result);
  }
  private static int sum(List<Integer>a,int startInd,int endInd){
    int res=0 ;
    for(int j=startInd ; j<endInd ; j++){
      res+=a.get(j);
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sequence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
    var result : String ; result := StringLib.newString() ;
        var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Sequence{} ;
        var j : int ; j := 0 ; while j < n do ( (     a := a->including(scan.getCurrent()->toLong()) )  ;     j := j + 1 ) ; 
    a := a->sort() ; 
    var res : String ; res := "NO" ;
    var k : int ; k := 1 ;
    var sumLargest : long ; sumLargest := a->at(n - 1+1) ;
    var sumSmallest : long ; sumSmallest := a->at(0+1) + a->at(1+1) ;
    while (sumLargest <= sumSmallest) do (     k := k + 1 ; 
     if (k < n - (k)->char2byte()) then (     sumLargest := sumLargest+(a->at(n - (k)->char2byte()+1)) ; 
     sumSmallest := sumSmallest+(a->at(k+1)) ) else (     break ) ) ; 
    if (sumLargest > sumSmallest) then (     res := "YES" ) else skip ; 
    result := result + StringLib.newString(res + "\n") ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation sum( a : Sequence(int), startInd : int, endInd : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var j : int ; j := startInd ; while j < endInd do ( (     res := res+(a->at(j+1)) )  ;     j := j + 1 ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Geeks {
  static boolean isInGivenBase(String str,int base){
    if(base>16)return false ;
    else if(base<=10){
      for(int i=0 ; i<str.length(); i++)if(!(str.charAt(i)>='0' && str.charAt(i)<('0'+base)))return false ;
    }
    else {
      for(int i=0 ; i<str.length(); i++)if(!((str.charAt(i)>='0' && str.charAt(i)<('0'+base))||(str.charAt(i)>='A' && str.charAt(i)<('A'+base-10))))return false ;
    }
    return true ;
  }
  public static void main(String args[]){
    String str="AF87" ;
    if(isInGivenBase(str,16)==true)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class Geeks {
  static   operation isInGivenBase( str : String, base : int) : boolean
  pre: true
  post: true
  activity: (     if (base > 16) then     return false else     if (base <= 10) then (         var i : int ; i := 0 ; while i < str->size() do (     if (not((str->at(i+1) >= '0' & str->at(i+1) < ('0' + base)))) then     return false else skip ;  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < str->size() do (     if (not(((str->at(i+1) >= '0' & str->at(i+1) < ('0' + base)) or (str->at(i+1) >= 'A' & str->at(i+1) < ('A' + base - 10))))) then     return false else skip ;  ;     i := i + 1 ) ) ;  ;  
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "AF87" ;
     if (isInGivenBase(str, 16) = true) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class template {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[][] arr=new char[n][n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.next().toCharArray();
    }
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(arr[i][j]=='#'){
          cnt++;
        }
      }
    }
    int cnt2=0 ;
    for(int i=1 ; i<n-1 ; i++){
      for(int j=1 ; j<n-1 ; j++){
        if(arr[i][j]=='#'){
          if(arr[i-1][j]=='#' && arr[i+1][j]=='#' && arr[i][j-1]=='#' && arr[i][j+1]=='#'){
            cnt2++;
            arr[i-1][j]='.' ;
            arr[i+1][j]='.' ;
            arr[i][j-1]='.' ;
            arr[i][j+1]='.' ;
          }
        }
      }
    }
    if(cnt==0){
      System.out.println("YES");
    }
    else if(cnt>0 && cnt2*5==cnt){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class template {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(String)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (arr[i+1][j+1] = '#') then (     cnt := cnt + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var cnt2 : int ; cnt2 := 0 ;
        var i : int ; i := 1 ; while i < n - 1 do ( (         var j : int ; j := 1 ; while j < n - 1 do ( (     if (arr[i+1][j+1] = '#') then (     if (arr[i - 1+1][j+1] = '#' & arr[i + 1+1][j+1] = '#' & arr[i+1][j - 1+1] = '#' & arr[i+1][j + 1+1] = '#') then (     cnt2 := cnt2 + 1 ; 
     arr[i - 1+1][j+1] := '.' ; 
    arr[i + 1+1][j+1] := '.' ; 
    arr[i+1][j - 1+1] := '.' ; 
    arr[i+1][j + 1+1] := '.' ; 
 ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (cnt = 0) then (     OclFile["System.out"].println("YES") ) else     if (cnt > 0 & cnt2 * 5 = cnt) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int countSol(int coeff[],int n,int rhs){
    int dp[]=new int[rhs+1];
    Arrays.fill(dp,0);
    dp[0]=1 ;
    for(int i=0 ; i<n ; i++)for(int j=coeff[i]; j<=rhs ; j++)dp[j]+=dp[j-coeff[i] ];
    return dp[rhs];
  }
  public static void main(String[] args){
    int coeff[]={
      2,2,5 };
      int rhs=4 ;
      int n=coeff.length ;
      System.out.print(countSol(coeff,n,rhs));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSol( coeff : Sequence(int), n : int, rhs : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,rhs + 1)->collect(0) ;
     dp := dp->collect(0) ; 
    dp[0+1] := 1 ; 
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := coeff[i+1] ; while j <= rhs do (     dp[j+1] := dp[j+1]+(dp[j - coeff[i+1]+1]) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return dp[rhs+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var coeff : Sequence(int) ; coeff := Sequence{2,2,5} ;
     var rhs : int ; rhs := 4 ;
     var n : int ; n := coeff->size() ;
     OclFile["System.out"].print(countSol(coeff, n, rhs)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt(),k=scanner.nextInt();
      int[] p=new int[n];
      IntStream.range(0,n).forEach(i->p[i]=scanner.nextInt());
      System.out.println(Arrays.stream(p).sorted().limit(k).sum());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
     var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
     for i : Integer.subrange(0, n-1) do
    (    p[i+1] := scanner.getCurrent()->toInteger()) ; 
     OclFile["System.out"].println(stream(p)->sort().subrange(1,k)->sum()) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int[] sum ;
  static int n ;
  public static void main(String[] args){
    while(read()){
      solve();
    }
  }
  static boolean read(){
    n=sc.nextInt();
    if(n==0)return false ;
    sum=new int[n];
    int score=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<5 ; j++){
        score+=sc.nextInt();
      }
      sum[i]=score ;
      score=0 ;
    }
    return true ;
  }
  static void solve(){
    Arrays.sort(sum);
    System.out.println(sum[sum.length-1]+" "+sum[0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute sum : Sequence(int);
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (read()) do (     execute solve() ) );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     return false else skip ; 
    sum := Integer.subrange(1,n)->collect(0) ; 
    var score : int ; score := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 5 do ( (     score := score+(sc.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
     sum[i+1] := score ; 
     score := 0 )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     sum := sum->sort() ; 
     OclFile["System.out"].println(sum[sum->size() - 1+1] + " " + sum[0+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=parseInt(line);
      if(n==0)break ;
      int max=0 ;
      int min=500 ;
      for(int i=0 ; i<n ; i++){
        StringTokenizer st=new StringTokenizer(br.readLine());
        int sum=0 ;
        while(st.hasMoreElements()){
          sum+=parseInt(st.nextToken());
        }
        max=Math.max(max,sum);
        min=Math.min(min,sum);
      }
      System.out.println(max+" "+min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := parseInt(line) ;
     if (n = 0) then     break else skip ; 
    var max : int ; max := 0 ;
    var min : int ; min := 500 ;
        var i : int ; i := 0 ; while i < n do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var sum : int ; sum := 0 ;
    while (st.hasNext()) do (     sum := sum+((st.next() + "")->toInteger()) ) ; 
    max := Set{max, sum}->max() ; 
    min := Set{min, sum}->min() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max + " " + min) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
    try {
      String[] st ;
      while(true){
        int n=Integer.valueOf(sc.readLine());
        if(n==0)break ;
        int max=0,min=0,now=0 ;
        st=sc.readLine().split(" ");
        for(int j=0 ; j<5 ; j++)now+=Integer.valueOf(st[j]);
        max=now ;
        min=now ;
        for(int i=1 ; i<n ; i++){
          now=0 ;
          st=sc.readLine().split(" ");
          for(int j=0 ; j<5 ; j++)now+=Integer.valueOf(st[j]);
          if(now>max)max=now ;
          if(now<min)min=now ;
        }
        System.out.println(max+" "+min);
      }
    }
    catch(Exception e){
      System.out.println("Error");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var st : Sequence(String) ;
     while (true) do (     var n : int ; n := (sc.readLine())->toInteger() ;
     if (n = 0) then     break else skip ; 
    var max : int ; max := 0 ;
    var min : int ; min := 0 ;
    var now : int ; now := 0 ;
    st := sc.readLine()->split(" ") ; 
        var j : int ; j := 0 ; while j < 5 do (     now := now+((st[j+1])->toInteger()) ;  ;     j := j + 1 ) ; 
    max := now ; 
    min := now ; 
        var i : int ; i := 1 ; while i < n do ( (     now := 0 ; 
     st := sc.readLine()->split(" ") ; 
        var j : int ; j := 0 ; while j < 5 do (     now := now+((st[j+1])->toInteger()) ;  ;     j := j + 1 ) ; 
    if (now > max) then     max := now ; else skip ; 
    if (now < min) then     min := now ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max + " " + min) ; 
 ) )   catch (e : ProgramException) do (     OclFile["System.out"].println("Error") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,i,j,max,min,sum,a ;
    for(; ; ){
      n=sc.nextInt();
      if(n==0)break ;
      max=0 ;
      min=500 ;
      for(i=0 ; i<n ; i++){
        sum=0 ;
        for(j=0 ; j<5 ; j++){
          a=sc.nextInt();
          sum+=a ;
        }
        if(max<sum)max=sum ;
        if(min>sum)min=sum ;
      }
      System.out.println(max+" "+min);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var i : int ;
    var j : int ;
    var max : int ;
    var min : int ;
    var sum : int ;
    var a : int ;
       while true do ( (     n := sc.nextInt() ; 
     if (n = 0) then     break else skip ; 
    max := 0 ; 
    min := 500 ; 
        i := 0 ; while i < n do ( (     sum := 0 ; 
         j := 0 ; while j < 5 do ( (     a := sc.nextInt() ; 
     sum := sum+(a) )  ;     j := j + 1 ) ; 
     if (max < sum) then     max := sum ; else skip ; 
     if (min > sum) then     min := sum ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max + " " + min) ; 
 )  ) ; 
     sc.close() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    int n,m,aaa,max=0,h=0 ;
    Scanner in=new Scanner(System.in);
    n=in.nextInt();
    m=in.nextInt();
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        aaa=in.nextInt();
        if(aaa==1)h++;
      }
      if(max<h)max=h ;
      h=0 ;
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var m : int ;
    var aaa : int ;
    var max : int ; max := 0 ;
    var h : int ; h := 0 ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := in.getCurrent()->toInteger() ; 
    m := in.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     aaa := in.getCurrent()->toInteger() ; 
     if (aaa = 1) then     h := h + 1 ; else skip )  ;     j := j + 1 ) ; 
     if (max < h) then     max := h ; else skip ; 
     h := 0 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,m,a,max,i,j ;
    m=sc.nextInt();
    n=sc.nextInt();
    max=-1 ;
    for(i=0 ; i<m ; i++){
      a=0 ;
      for(j=0 ; j<n ; j++)a+=sc.nextInt();
      if(max<a)max=a ;
    }
    out.println(max);
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var m : int ;
    var a : int ;
    var max : int ;
    var i : int ;
    var j : int ;
    m := sc.nextInt() ; 
    n := sc.nextInt() ; 
    max := -1 ; 
        i := 0 ; while i < m do ( (     a := 0 ; 
         j := 0 ; while j < n do (     a := a+(sc.nextInt()) ;  ;     j := j + 1 ) ; 
     if (max < a) then     max := a ; else skip )  ;     i := i + 1 ) ; 
    out.println(max) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
    String s=r.readLine();
    String[] t ;
    t=s.split(" ");
    int[] n=new int[t.length];
    for(int i=0 ; i<t.length ; i++){
      n[i]=Integer.parseInt(t[i]);
    }
    int nm=n[0];
    int[] count=new int[nm];
    for(int j=0 ; j<n[0]; j++){
      String a=r.readLine();
      String[] alpha ;
      alpha=a.split(" ");
      int gh=alpha.length ;
      int[] number=new int[gh];
      for(int k=0 ; k<alpha.length ; k++){
        number[k]=Integer.parseInt(alpha[k]);
      }
      for(int l=0 ; l<n[1]; l++){
        if(number[l]==1){
          count[j]++;
        }
      }
    }
    Arrays.sort(count);
    System.out.println(count[nm-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := r.readLine() ;
    var t : Sequence(String) ;
    t := s->split(" ") ; 
    var n : Sequence(int) ; n := Integer.subrange(1,t->size())->collect(0) ;
        var i : int ; i := 0 ; while i < t->size() do ( (     n[i+1] := (t[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var nm : int ; nm := n[0+1] ;
    var count : Sequence(int) ; count := Integer.subrange(1,nm)->collect(0) ;
        var j : int ; j := 0 ; while j < n[0+1] do ( (     var a : String ; a := r.readLine() ;
     var alpha : Sequence(String) ;
    alpha := a->split(" ") ; 
    var gh : int ; gh := alpha->size() ;
    var number : Sequence(int) ; number := Integer.subrange(1,gh)->collect(0) ;
        var k : int ; k := 0 ; while k < alpha->size() do ( (     number[k+1] := (alpha[k+1])->toInteger() )  ;     k := k + 1 ) ; 
        var l : int ; l := 0 ; while l < n[1+1] do ( (     if (number[l+1] = 1) then (     count[j+1] := count[j+1] + 1 ) else skip )  ;     l := l + 1 ) ; 
 )  ;     j := j + 1 ) ; 
    count := count->sort() ; 
    OclFile["System.out"].println(count[nm - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    final int M=sc.nextInt();
    final int N=sc.nextInt();
    int max=0 ;
    for(int i=0 ; i<M ; i++){
      int count=0 ;
      for(int j=0 ; j<N ; j++){
        if(sc.nextInt()==1){
          count++;
        }
      }
      max=Math.max(count,max);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var M : int ; M := sc.getCurrent()->toInteger() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < N do ( (     if (sc.getCurrent()->toInteger() = 1) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
     max := Set{count, max}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static Scanner scan=new Scanner(System.in);
  public static void main(String[] args){
    int N=scan.nextInt();
    int K=scan.nextInt();
    int[] arr=new int[N];
    takeInput(arr);
    System.out.println(minPrice(arr,K));
  }
  private static void takeInput(int[] arr){
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=scan.nextInt();
    }
  }
  private static int minPrice(int[] arr,int K){
    Arrays.sort(arr);
    int sum=0 ;
    for(int i=0 ; i<K ; i++){
      sum+=arr[i];
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := scan.getCurrent()->toInteger() ;
     var K : int ; K := scan.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
    execute takeInput(arr) ; 
    OclFile["System.out"].println(minPrice(arr, K)) ; 
 );
  static   operation takeInput( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) );
  static   operation minPrice( arr : Sequence(int), K : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < K do ( (     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
     return sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    line=br.readLine();
    int m=parseInt(line.substring(0,line.indexOf(' ')));
    int n=parseInt(line.substring(line.indexOf(' ')+1));
    int max=-1 ;
    for(int i=0 ; i<m ; i++){
      line=br.readLine();
      int sum=0 ;
      for(int j=0 ; j<n ; j++){
        if(line.charAt(j*2)=='1')sum++;
      }
      max=Math.max(max,sum);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    line := br.readLine() ; 
    var m : int ; m := parseInt(line.subrange(0+1,line->indexOf(' ')-1)) ;
    var n : int ; n := parseInt(line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1)) ;
    var max : int ; max := -1 ;
        var i : int ; i := 0 ; while i < m do ( (     line := br.readLine() ; 
     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (line->at(j * 2+1) = '1') then     sum := sum + 1 ; else skip )  ;     j := j + 1 ) ; 
     max := Set{max, sum}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int checkArray(int[] arr,int n){
    return((arr[0] % 2)>0 &&(arr[n-1] % 2)>0 &&(n % 2)>0)? 1 : 0 ;
  }
  public static void main(String[] args){
    int[] arr={
      1,2,3,4,5 };
      int n=arr.length ;
      System.out.println(checkArray(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkArray( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     return if ((arr[0+1] mod 2) > 0 & (arr[n - 1+1] mod 2) > 0 & (n mod 2) > 0) then 1 else 0 endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(checkArray(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float find_angle(int x,int y,int z){
    int volume=x*x*y ;
    float ans=0 ;
    if(z<volume/2){
      float d=(float)((x*y*y)/(2.0*z));
      ans=(float)Math.atan(d);
    }
    else {
      z=volume-z ;
      float d=(2*z)/(float)(x*x*x);
      ans=(float)Math.atan(d);
    }
    ans=(float)((ans*180)/3.14159265);
    return ans ;
  }
  public static void main(String[] args){
    int x=12 ;
    int y=21 ;
    int z=10 ;
    System.out.print(find_angle(x,y,z)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find_angle( x : int, y : int, z : int) : double
  pre: true
  post: true
  activity: (     var volume : int ; volume := x * x * y ;
     var ans : double ; ans := 0 ;
    if (z < volume / 2) then (     var d : double ; d := ((x * y * y) / (2.0 * z))->oclAsType(double) ;
     ans := (d)->atan()->oclAsType(double) ) else (     z := volume - z ; 
     var d : double ; d := (2 * z) / (x * x * x)->oclAsType(double) ;
     ans := (d)->atan()->oclAsType(double) ) ;  
    ans := ((ans * 180) / 3.14159265)->oclAsType(double) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 12 ;
     var y : int ; y := 21 ;
     var z : int ; z := 10 ;
     OclFile["System.out"].print(find_angle(x, y, z) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAX=1000001 ;
  static int factor[]=new int[MAX];
  static void cal_factor(){
    factor[1]=1 ;
    for(int i=2 ; i<MAX ; i++)factor[i]=i ;
    for(int i=4 ; i<MAX ; i+=2)factor[i]=2 ;
    for(int i=3 ; i*i<MAX ; i++){
      if(factor[i]==i){
        for(int j=i*i ; j<MAX ; j+=i){
          if(factor[j]==j)factor[j]=i ;
        }
      }
    }
  }
  static int no_of_representations(int a[],int n){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int temp=a[i];
      int flag=0 ;
      while(factor[temp]!=1){
        flag=-1 ;
        count++;
        temp=temp/factor[temp];
      }
      count+=flag ;
    }
    return count ;
  }
  public static void main(String[] args){
    cal_factor();
    int a[]={
      4,4,4 };
      int n=a.length ;
      System.out.print(no_of_representations(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 1000001;
  static   attribute factor : int := Integer.subrange(1,MAX)->collect(0);
  static   operation cal_factor() : void
  pre: true
  post: true
  activity: (     factor[1+1] := 1 ; 
         var i : int ; i := 2 ; while i < MAX do (     factor[i+1] := i ;  ;     i := i + 1 ) ; 
         var i : int ; i := 4 ; while i < MAX do (     factor[i+1] := 2 ;  ;     i := i+(2) ) ; 
         var i : int ; i := 3 ; while i * i < MAX do ( (     if (factor[i+1] = i) then (         var j : int ; j := i * i ; while j < MAX do ( (     if (factor[j+1] = j) then     factor[j+1] := i ; else skip )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) );
  static   operation no_of_representations( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var temp : int ; temp := a[i+1] ;
     var flag : int ; flag := 0 ;
     while (factor[temp+1] /= 1) do (     flag := -1 ; 
     count := count + 1 ; 
     temp := temp / factor[temp+1] ) ; 
     count := count+(flag) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute cal_factor() ; 
     var a : Sequence(int) ; a := Sequence{4,4,4} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(no_of_representations(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.math.BigInteger ;
import java.nio.Buffer ;
import java.util.*;
public class Main {
  public static Scanner r=new Scanner(System.in);
  public static void solve(int n,int m){
    int l1=1,r1=n/2 ;
    int l2=n/2+1,r2=n ;
    while(l1<r1 && m>0){
      System.out.println(l1+" "+r1);
++l1 ;
--r1 ;
--m ;
    }
    while(l2<r2 && m>0){
      System.out.println(l2+" "+r2);
++l2 ;
--r2 ;
--m ;
    }
  }
  public static void main(String[] args){
    int n=r.nextInt();
    int m=r.nextInt();
    if(n % 2==0){
      solve(n-1,m);
    }
    else {
      solve(n,m);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute r : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation solve( n : int, m : int) : void
  pre: true
  post: true
  activity: (     var l1 : int ; l1 := 1 ;
    var r1 : int ; r1 := n / 2 ;
     var l2 : int ; l2 := n / 2 + 1 ;
    var r2 : int ; r2 := n ;
     while (l1 < r1 & m > 0) do (     OclFile["System.out"].println(l1 + " " + r1) ; 
     l1 := l1 + 1 ; 
     r1 := r1 - 1 ; 
     m := m - 1 ) ; 
     while (l2 < r2 & m > 0) do (     OclFile["System.out"].println(l2 + " " + r2) ; 
     l2 := l2 + 1 ; 
     r2 := r2 - 1 ; 
     m := m - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := r.getCurrent()->toInteger() ;
     var m : int ; m := r.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (     execute solve(n - 1, m) ) else (     execute solve(n, m) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int k=Integer.parseInt(sc.next());
    int[][] p=new int[k][2];
    int r=1 ;
    int l=k+1 ;
    int r0=k+2 ;
    int l0=2*k+1 ;
    int cnt=0 ;
    for(int i=k ; i>=1 ; i--){
      if(cnt % 2==0){
        p[k-i][0]=r ;
        p[k-i][1]=l ;
        r++;
        l--;
      }
      else {
        p[k-i][0]=r0 ;
        p[k-i][1]=l0 ;
        r0++;
        l0--;
      }
      cnt++;
    }
    for(int i=0 ; i<k ; i++){
      System.out.println(p[i][0]+" "+p[i][1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var k : int ; k := (sc.getCurrent())->toInteger() ;
    var p : Sequence(Sequence(int)) ; p := Integer.subrange(1,k)->collect(Integer.subrange(1,2)->collect(0)) ;
    var r : int ; r := 1 ;
    var l : int ; l := k + 1 ;
    var r0 : int ; r0 := k + 2 ;
    var l0 : int ; l0 := 2 * k + 1 ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := k ; while i >= 1 do ( (     if (cnt mod 2 = 0) then (     p[k - i+1][0+1] := r ; 
     p[k - i+1][1+1] := l ; 
     r := r + 1 ; 
     l := l - 1 ) else (     p[k - i+1][0+1] := r0 ; 
     p[k - i+1][1+1] := l0 ; 
     r0 := r0 + 1 ; 
     l0 := l0 - 1 ) ;  
     cnt := cnt + 1 )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < k do ( (     OclFile["System.out"].println(p[i+1][0+1] + " " + p[i+1][1+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    StringTokenizer st=new StringTokenizer(f.readLine());
    int n=Integer.parseInt(st.nextToken());
    int m=Integer.parseInt(st.nextToken());
    HashSet<Integer>hset=new HashSet<Integer>();
    Pair[] answer=new Pair[m];
    for(int k=1 ; k<=m ; k++){
      int i=n-k+1 ;
      while(hset.contains(i-k)|| hset.contains(n-(i-k))|| i-k==(n-(i-k))){
        i--;
      }
      hset.add(i-k);
      hset.add(n-(i-k));
      answer[k-1]=new Pair(k,i);
    }
    for(int k=0 ; k<m ; k++){
      out.println(answer[k] .a+" "+answer[k] .b);
    }
    out.close();
  }
  public static class Pair {
    int a ;
    int b ;
    public Pair(int c,int d){
      a=c ;
      b=d ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var hset : Set(int) ; hset := Set{} ;
    var answer : Sequence(Map) ; answer := Integer.subrange(1,m)->collect(null) ;
        var k : int ; k := 1 ; while k <= m do ( (     var i : int ; i := n - k + 1 ;
     while (hset->includes(i - k) or hset->includes(n - (i - k)) or i - k = (n - (i - k))) do (     i := i - 1 ) ; 
    hset := hset->including(i - k) ; 
    hset := hset->including(n - (i - k)) ; 
    answer[k - 1+1] := Map(k, i) ; 
 )  ;     k := k + 1 ) ; 
        var k : int ; k := 0 ; while k < m do ( (     skip )  ;     k := k + 1 ) ; 
    skip ; 
 );
  static class Pair {
   attribute a : int;
   attribute b : int;
   static operation newPair( c : int, d : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(c, d);
    return self );
  operation initialise( c : int, d : int) : void
  pre: true  post: true
  activity: (     a := c ; 
     b := d );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(final String[] args){
    final FastScanner scanner=new FastScanner(System.in);
    final int n=scanner.nextInt();
    final int m=scanner.nextInt();
    if(n % 2==1){
      for(int i=1 ; i<=m ; i++){
        System.out.println(i+" "+(n-i+1));
      }
      return ;
    }
    boolean flag=false ;
    for(int i=1 ; i<=m ; i++){
      if(n-2*i+1<=n/2){
        flag=true ;
      }
      if(flag){
        System.out.println(i+" "+(n-i));
      }
      else {
        System.out.println(i+" "+(n-i+1));
      }
    }
  }
  private static class FastScanner {
    private final BufferedReader reader ;
    private StringTokenizer tokenizer ;
    FastScanner(final InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(final IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    String nextLine(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          return reader.readLine();
        }
        catch(final IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken("\n");
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : FastScanner ; scanner := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var n : int ; n := scanner.nextInt() ;
    var m : int ; m := scanner.nextInt() ;
    if (n mod 2 = 1) then (         var i : int ; i := 1 ; while i <= m do ( (     OclFile["System.out"].println(i + " " + (n - i + 1)) )  ;     i := i + 1 ) ; 
     return ) else skip ; 
    var flag : boolean ; flag := false ;
        var i : int ; i := 1 ; while i <= m do ( (     if (n - 2 * i + 1 <= n / 2) then (     flag := true ) else skip ; 
     if (flag) then (     OclFile["System.out"].println(i + " " + (n - i)) ) else (     OclFile["System.out"].println(i + " " + (n - i + 1)) ) )  ;     i := i + 1 ) ; 
 );
  static class FastScanner {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.nextToken("\n") );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; ++i)a[i]=sc.nextInt();
    int ans=0 ;
    for(int i=1 ; i<n-1 ; ++i)if((a[i]-a[i-1])*(a[i]-a[i+1])>=1)++ans ;
    out.println(ans);
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < n - 1 do (     if ((a[i+1] - a[i - 1+1]) * (a[i+1] - a[i + 1+1]) >= 1) then     ans := ans + 1 ; else skip ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    ArrayList<Integer>a=new ArrayList<Integer>();
    while(n-->0){
      a.add(sc.nextInt());
    }
    Collections.sort(a);
    int ans=0 ;
    for(int i=0 ; i<k ; i++){
      ans+=a.get(i);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     a := a->including(sc.getCurrent()->toInteger()) ) ;  ) ;  
    a := a->sort() ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     ans := ans+(a->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      int count=0 ;
      if(n==2){
        System.out.println(0);
      }
      else {
        for(int i=1 ; i<n-1 ; i++){
          if((arr[i]>arr[i-1] && arr[i]>arr[i+1])||(arr[i]<arr[i-1] && arr[i]<arr[i+1])){
            count++;
          }
        }
        System.out.println(count);
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    if (n = 2) then (     OclFile["System.out"].println(0) ) else (         var i : int ; i := 1 ; while i < n - 1 do ( (     if ((arr[i+1] > arr[i - 1+1] & arr[i+1] > arr[i + 1+1]) or (arr[i+1] < arr[i - 1+1] & arr[i+1] < arr[i + 1+1])) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) ) ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] scores=new int[n];
    for(int i=0 ; i<scores.length ; i++){
      scores[i]=in.nextInt();
    }
    int res=0 ;
    for(int i=1 ; i<n-1 ; i++){
      if(scores[i]>scores[i-1] && scores[i]>scores[i+1]){
        res++;
      }
      else if(scores[i]<scores[i-1] && scores[i]<scores[i+1]){
        res++;
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var scores : Sequence(int) ; scores := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < scores->size() do ( (     scores[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 1 ; while i < n - 1 do ( (     if (scores[i+1] > scores[i - 1+1] & scores[i+1] > scores[i + 1+1]) then (     res := res + 1 ) else     if (scores[i+1] < scores[i - 1+1] & scores[i+1] < scores[i + 1+1]) then (     res := res + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(sc.next());
    }
    int res=0 ;
    if(n<3){
      System.out.println(0);
    }
    else {
      for(int i=1 ; i<n-1 ; i++){
        if(arr[i]>arr[i-1] && arr[i]>arr[i+1]){
          res++;
        }
        else if(arr[i]<arr[i-1] && arr[i]<arr[i+1]){
          res++;
        }
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    if (n < 3) then (     OclFile["System.out"].println(0) ) else (         var i : int ; i := 1 ; while i < n - 1 do ( (     if (arr[i+1] > arr[i - 1+1] & arr[i+1] > arr[i + 1+1]) then (     res := res + 1 ) else     if (arr[i+1] < arr[i - 1+1] & arr[i+1] < arr[i + 1+1]) then (     res := res + 1 ) else skip ; )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(res) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
public class B1618 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      int n=scanner.nextInt();
      List<String>list=new LinkedList<>();
      for(int i=0 ; i<n-2 ; i++){
        list.add(scanner.next());
      }
      String ans="" ;
      if(list.size()==1){
        ans=list.get(0)+'a' ;
      }
      else {
        ans+=list.get(0).charAt(0);
        for(int i=1 ; i<=n-3 ; i++){
          if(list.get(i).charAt(0)==list.get(i-1).charAt(1)){
            ans+=""+list.get(i).charAt(0);
          }
          else {
            ans+=""+list.get(i-1).charAt(1)+""+list.get(i).charAt(0);
          }
        }
        ans+=list.get(list.size()-1).charAt(1);
        if(ans.length()<n){
          ans+=""+'a' ;
        }
      }
      System.out.println(ans);
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1618 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var list : Sequence(String) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n - 2 do ( (     list := list->including(scanner.getCurrent()) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "" ;
    if (list->size() = 1) then (     ans := list->at(0+1) + 'a' ) else (     ans := ans+(list->at(0+1)->at(0+1)) ; 
         var i : int ; i := 1 ; while i <= n - 3 do ( (     if (list->at(i+1)->at(0+1) = list->at((i)->char2byte() - 1+1)->at(1+1)) then (     ans := ans+("" + list->at(i+1)->at(0+1)) ) else (     ans := ans+("" + list->at((i)->char2byte() - 1+1)->at(1+1) + "" + list->at(i+1)->at(0+1)) ) )  ;     i := i + 1 ) ; 
     ans := ans+(list->at(list->size() - 1+1)->at(1+1)) ; 
     if (ans->size() < n) then (     ans := ans+("" + 'a') ) else skip ) ;  
    OclFile["System.out"].println(ans) ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void kmax(int arr[],int k,int n){
    for(int c=0 ; c<k ; c++){
      int max_so_far=Integer.MIN_VALUE ;
      int max_here=0 ;
      int start=0,end=0,s=0 ;
      for(int i=0 ; i<n ; i++){
        max_here+=arr[i];
        if(max_so_far<max_here){
          max_so_far=max_here ;
          start=s ;
          end=i ;
        }
        if(max_here<0){
          max_here=0 ;
          s=i+1 ;
        }
      }
      System.out.println("Maximum non-overlapping sub-arraysum"+(c+1)+": "+max_so_far+",starting index: "+start+",ending index: "+end+".");
      for(int l=start ; l<=end ; l++)arr[l]=Integer.MIN_VALUE ;
    }
    System.out.println();
  }
  public static void main(String[] args){
    int arr1[]={
      4,1,1,-1,-3,-5,6,2,-6,-2 };
      int k1=3 ;
      int n1=arr1.length ;
      kmax(arr1,k1,n1);
      int arr2[]={
        5,1,2,-6,2,-1,3,1 };
        int k2=2 ;
        int n2=arr2.length ;
        kmax(arr2,k2,n2);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation kmax( arr : Sequence(int), k : int, n : int) : void
  pre: true
  post: true
  activity: (         var c : int ; c := 0 ; while c < k do ( (     var max_so_far : int ; max_so_far := -2147483648 ;
     var max_here : int ; max_here := 0 ;
    var start : int ; start := 0 ;
    var end : int ; end := 0 ;
    var s : int ; s := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     max_here := max_here+(arr[i+1]) ; 
     if (max_so_far < max_here) then (     max_so_far := max_here ; 
     start := s ; 
     end := i ) else skip ; 
     if (max_here < 0) then (     max_here := 0 ; 
     s := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Maximum non-overlapping sub-arraysum" + (c + 1) + ": " + max_so_far + ",starting index: " + start + ",ending index: " + end + ".") ; 
        var l : int ; l := start ; while l <= end do (     arr[l+1] := -2147483648 ;  ;     l := l + 1 ) ; 
 )  ;     c := c + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{4,1,1,-1,-3,-5,6,2,-6,-2} ;
     var k1 : int ; k1 := 3 ;
    var n1 : int ; n1 := arr1->size() ;
    execute kmax(arr1, k1, n1) ; 
    var arr2 : Sequence(int) ; arr2 := Sequence{5,1,2,-6,2,-1,3,1} ;
    var k2 : int ; k2 := 2 ;
    var n2 : int ; n2 := arr2->size() ;
    execute kmax(arr2, k2, n2) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1618 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    int flag=0 ;
    String[] s ;
    String res ;
    while(t-->0){
      int n ;
      n=in.nextInt();
      s=new String[n-2];
      for(int i=0 ; i<n-2 ; i++){
        s[i]=in.next();
      }
      res=s[0];
      if(s.length>1){
        flag=0 ;
        for(int i=0 ; i<n-3 ; i++){
          if(s[i] .charAt(1)!=s[i+1] .charAt(0)){
            res=res+s[i+1] .charAt(0);
            flag=1 ;
          }
          res=res+s[i+1] .charAt(1);
        }
        if(flag==0)res=res+'a' ;
        System.out.println(res);
      }
      else {
        System.out.println("b"+s[0]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1618 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var flag : int ; flag := 0 ;
    var s : Sequence(String) ;
    var res : String ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ;
     n := in.getCurrent()->toInteger() ; 
    s := Integer.subrange(1,(n)->char2byte() - 2)->collect(null) ; 
        var i : int ; i := 0 ; while i < (n)->char2byte() - 2 do ( (     s[i+1] := in.getCurrent() )  ;     i := i + 1 ) ; 
    res := s[0+1] ; 
    if (s->size() > 1) then (     flag := 0 ; 
         var i : int ; i := 0 ; while i < (n)->char2byte() - 3 do ( (     if (s[i+1]->at(1+1) /= s[i + 1+1]->at(0+1)) then (     res := res + s[i + 1+1]->at(0+1) ; 
     flag := 1 ) else skip ; 
     res := res + s[i + 1+1]->at(1+1) )  ;     i := i + 1 ) ; 
     if (flag = 0) then     res := res + 'a' ; else skip ; 
     OclFile["System.out"].println(res) ) else (     OclFile["System.out"].println("b" + s[0+1]) ) ;  
 ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class ProblemA {
  static long k ;
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int test=Integer.parseInt(br.readLine());
    while(test-->0){
      int n=Integer.parseInt(br.readLine());
      String line[]=br.readLine().split(" ");
      String res=line[0];
      for(int i=1 ; i<line.length ; i++){
        res+=(res.charAt(res.length()-1)==line[i] .charAt(0)? line[i] .charAt(1): line[i]);
      }
      if(res.length()!=n)res+="a" ;
      sb.append(res);
      sb.append("\n");
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
  static   attribute k : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var test : int ; test := (br.readLine())->toInteger() ;
        while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var res : String ; res := line[0+1] ;
        var i : int ; i := 1 ; while i < line->size() do ( (     res := res+((if res->at(res->size() - 1+1) = line[i+1]->at(0+1) then line[i+1]->at(1+1) else line[i+1] endif)) )  ;     i := i + 1 ) ; 
    if (res->size() /= n) then     res := res+("a") ; else skip ; 
    sb := sb + StringLib.newString(res) ; 
    sb := sb + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int flag=0 ;
    String[] s ;
    String res ;
    while(t-->0){
      int n ;
      n=sc.nextInt();
      s=new String[n-2];
      for(int i=0 ; i<n-2 ; i++){
        s[i]=sc.next();
      }
      res=s[0];
      if(s.length>1){
        flag=0 ;
        for(int i=0 ; i<n-3 ; i++){
          if(s[i] .charAt(1)!=s[i+1] .charAt(0)){
            res=res+s[i+1] .charAt(0);
            flag=1 ;
          }
          res=res+s[i+1] .charAt(1);
        }
        if(flag==0)res=res+'a' ;
        System.out.println(res);
      }
      else {
        System.out.println("b"+s[0]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var flag : int ; flag := 0 ;
    var s : Sequence(String) ;
    var res : String ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ;
     n := sc.getCurrent()->toInteger() ; 
    s := Integer.subrange(1,(n)->char2byte() - 2)->collect(null) ; 
        var i : int ; i := 0 ; while i < (n)->char2byte() - 2 do ( (     s[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    res := s[0+1] ; 
    if (s->size() > 1) then (     flag := 0 ; 
         var i : int ; i := 0 ; while i < (n)->char2byte() - 3 do ( (     if (s[i+1]->at(1+1) /= s[i + 1+1]->at(0+1)) then (     res := res + s[i + 1+1]->at(0+1) ; 
     flag := 1 ) else skip ; 
     res := res + s[i + 1+1]->at(1+1) )  ;     i := i + 1 ) ; 
     if (flag = 0) then     res := res + 'a' ; else skip ; 
     OclFile["System.out"].println(res) ) else (     OclFile["System.out"].println("b" + s[0+1]) ) ;  
 ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader read=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter prnt=new PrintWriter(System.out);
    String str=read.readLine();
    int n=parseInt(read.readLine());
    ArrayList<String>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      String s=read.readLine();
      int ind=s.indexOf(str);
      if(ind==0){
        list.add(s);
      }
    }
    Collections.sort(list);
    if(list.isEmpty()){
      prnt.println(str);
    }
    else {
      prnt.println(list.get(0));
    }
    prnt.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : OclFile ; read := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var prnt : OclFile ; prnt := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var str : String ; str := read.readLine() ;
    var n : int ; n := parseInt(read.readLine()) ;
    var list : Sequence(String) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := read.readLine() ;
     var ind : int ; ind := s->indexOf(str)-1 ;
     if (ind = 0) then (     list := list->including(s) ) else skip )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    if (list->isEmpty()) then (     skip ) else (     skip ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class S {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    int t=in.nextInt();
    String k=s ;
    int temp=0 ;
    while(t--!=0){
      String str=in.next();
      if(str.indexOf(s)==0){
        if(temp==0){
          k=str ;
          temp=1 ;
        }
        else {
          if(k.compareTo(str)>0)k=str ;
        }
      }
    }
    System.out.print(k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class S {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
    var t : int ; t := in.getCurrent()->toInteger() ;
    var k : String ; k := s ;
    var temp : int ; temp := 0 ;
        while (t /= 0) do (    skip ; (     var str : String ; str := in.getCurrent() ;
     if (str->indexOf(s)-1 = 0) then (     if (temp = 0) then (     k := str ; 
     temp := 1 ) else (     if (k->compareTo(str) > 0) then     k := str ; else skip ) ) else skip ) ;  ) ;  
    OclFile["System.out"].print(k) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p073 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p073().run());
  }
  public String run(){
    return Integer.toString(sternBrocotCount(1,3,1,2));
  }
  private static int sternBrocotCount(int leftN,int leftD,int rightN,int rightD){
    int n=leftN+rightN ;
    int d=leftD+rightD ;
    if(d>12000)return 0 ;
    else return 1+sternBrocotCount(leftN,leftD,n,d)+sternBrocotCount(n,d,rightN,rightD);
  }
}
------------------------------------------------------------
OCL File:
---------
class p073 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p073.newp073().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     return ((sternBrocotCount(1, 3, 1, 2)) + "") );
  static   operation sternBrocotCount( leftN : int, leftD : int, rightN : int, rightD : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := leftN + rightN ;
     var d : int ; d := leftD + rightD ;
     if (d > 12000) then     return 0 else     return 1 + sternBrocotCount(leftN, leftD, n, d) + sternBrocotCount(n, d, rightN, rightD) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Autocomplete {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int n=sc.nextInt();
    String str[]=new String[n];
    ArrayList<String>l=new ArrayList();
    for(int i=0 ; i<n ; i++){
      str[i]=sc.next();
      if(str[i] .startsWith(s)){
        l.add(str[i]);
      }
    }
    if(l.size()>=1){
      Collections.sort(l);
      System.out.println(l.get(0));
    }
    else {
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Autocomplete {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var str : Sequence(String) ; str := Integer.subrange(1,n)->collect(null) ;
    var l : Sequence(String) ; l := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     str[i+1] := sc.getCurrent() ; 
     if (str[i+1]->hasPrefix(s)) then (     l := l->including(str[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    if (l->size() >= 1) then (     l := l->sort() ; 
     OclFile["System.out"].println(l->at(0+1)) ) else (     OclFile["System.out"].println(s) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.stream.IntStream ;
public class CodeForces {
  public static void main(String[] args){
    FastIO io=FastIO.create();
    String prefix=io.nextLine();
    String bestMatch=null ;
    int n=io.nextInt();
    for(int i=0 ; i<n ; i++){
      String candidate=io.nextLine();
      if(candidate.startsWith(prefix)){
        if(bestMatch==null || candidate.compareTo(bestMatch)<1){
          bestMatch=candidate ;
        }
      }
    }
    if(bestMatch==null){
      bestMatch=prefix ;
    }
    io.println(bestMatch);
    io.close();
  }
  static class FastIO extends PrintWriter {
    BufferedReader br ;
    StringTokenizer st ;
    public FastIO(InputStream is,OutputStream os){
      super(new BufferedOutputStream(os));
      br=new BufferedReader(new InputStreamReader(is));
    }
    public static FastIO create(){
      return new FastIO(System.in,System.out);
    }
    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 nextToken(){
      while(st==null || ! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    String nextLine(){
      try {
        return br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return "" ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : FastIO ; io := FastIO.create() ;
     var prefix : String ; prefix := io.nextLine() ;
    var bestMatch : String ; bestMatch := null ;
    var n : int ; n := io.nextInt() ;
        var i : int ; i := 0 ; while i < n do ( (     var candidate : String ; candidate := io.nextLine() ;
     if (candidate->hasPrefix(prefix)) then (     if (bestMatch = null or candidate->compareTo(bestMatch) < 1) then (     bestMatch := candidate ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (bestMatch = null) then (     bestMatch := prefix ) else skip ; 
    io.println(bestMatch) ; 
    io.close() ; 
 );
  static class FastIO extends OclFile {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastIO( is : OclFile, os : OclFile) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(is, os);
    return self );
  operation initialise( is : OclFile, os : OclFile) : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Write(os)) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
  static   operation create() : FastIO
  pre: true
  post: true
  activity: (     return FastIO.newFastIO(OclFile["System.in"], OclFile["System.out"]) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return "" );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int ii=0 ; ii<test ; ii++){
      int n=in.nextInt();
      int T=in.nextInt();
      int f=1 ;
      int x ;
      for(int i=0 ; i<n ; i++){
        int r ;
        x=in.nextInt();
        if(T % 2==0 && x==T/2){
          r=f ;
          if(f==0)f=1 ;
          else f=0 ;
        }
        else if(2*x<T){
          r=0 ;
        }
        else {
          r=1 ;
        }
        pw.print(r+" ");
      }
      pw.println();
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var ii : int ; ii := 0 ; while ii < test do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var T : int ; T := in.getCurrent()->toInteger() ;
    var f : int ; f := 1 ;
    var x : int ;
        var i : int ; i := 0 ; while i < n do ( (     var r : int ;
     x := in.getCurrent()->toInteger() ; 
     if (T mod 2 = 0 & x = T / 2) then (     r := f ; 
     if (f = 0) then     f := 1 ; else     f := 0 ; ) else     if (2 * x < T) then (     r := 0 ) else (     r := 1 ) ;  ;  
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     ii := ii + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public final class p211 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p211().run());
  }
  private static final int LIMIT=64000000 ;
  public String run(){
    long[] sigma2=new long[LIMIT];
    Arrays.fill(sigma2,1,sigma2.length,1);
    for(int i=2 ; i<sigma2.length ; i++){
      if(sigma2[i]==1){
        for(int j=i ; j<sigma2.length ; j+=i)sigma2[j]*=powerSquareSum(j,i);
      }
    }
    long sum=0 ;
    SquareTester sqt=new SquareTester(3*5*7*11*13*17);
    for(int i=1 ; i<sigma2.length ; i++){
      if(sqt.isPerfectSquare(sigma2[i]))sum+=i ;
    }
    return Long.toString(sum);
  }
  private static long powerSquareSum(int n,int k){
    long result=1 ;
    long k2=(long)k*k ;
    while(n % k==0){
      n/=k ;
      result=result*k2+1 ;
    }
    return result ;
  }
  private static final class SquareTester {
    private boolean[] isResidue ;
    public SquareTester(int modulus){
      if(modulus<1)throw new IllegalArgumentException();
      isResidue=new boolean[modulus];
      for(int i=0 ; i<modulus ; i++)isResidue[(int)((long)i*i % modulus)]=true ;
    }
    public boolean isPerfectSquare(long x){
      if(! isResidue[(int)(x % isResidue.length)])return false ;
      long y=0 ;
      for(long i=1L<<31 ; i!=0 ; i>>>=1){
        y |=i ;
        if(y>3037000499L || y*y>x)y ^=i ;
      }
      return y*y==x ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class p211 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p211.newp211().run()) );
  static    attribute LIMIT : int := 64000000;
   operation run() : String
  pre: true
  post: true
  activity: (     var sigma2 : Sequence(long) ; sigma2 := Integer.subrange(1,LIMIT)->collect(0) ;
     sigma2 := sigma2->collect(1) ; 
        var i : int ; i := 2 ; while i < sigma2->size() do ( (     if (sigma2[i+1] = 1) then (         var j : int ; j := i ; while j < sigma2->size() do (     sigma2[j+1] := sigma2[j+1]*(powerSquareSum(j, i)) ;  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    var sqt : SquareTester ; sqt := SquareTester.newSquareTester(3 * 5 * 7 * 11 * 13 * 17) ;
        var i : int ; i := 1 ; while i < sigma2->size() do ( (     if (sqt.isPerfectSquare(sigma2[i+1])) then     sum := sum+(i) ; else skip )  ;     i := i + 1 ) ; 
    return ((sum) + "") 
 );
  static   operation powerSquareSum( n : int, k : int) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 1 ;
     var k2 : long ; k2 := k->oclAsType(long) * k ;
     while (n mod k = 0) do (     n := n/(k) ; 
     result := result * k2 + 1 ) ; 
     return result );
  static  class SquareTester {
   attribute isResidue : Sequence(boolean);
   static operation newSquareTester( modulus : int) : SquareTester
  pre: true
  post: true
  activity:
  ( var self : SquareTester ;
    self := createSquareTester();
    self.initialise(modulus);
    return self );
  operation initialise( modulus : int) : void
  pre: true  post: true
  activity: (     if (modulus < 1) then     error IllegalArgumentException.newIllegalArgumentException() ; else skip ; 
     isResidue := Integer.subrange(1,modulus)->collect(false) ; 
         var i : int ; i := 0 ; while i < modulus do (     isResidue[(i->oclAsType(long) * i mod modulus)->oclAsType(int)+1] := true ;  ;     i := i + 1 ) );
   operation isPerfectSquare( x : long) : boolean
  pre: true
  post: true
  activity: (     if (not(isResidue[(x mod isResidue->size())->oclAsType(int)+1])) then     return false else skip ; 
     var y : long ; y := 0 ;
         var i : long ; i := (1L*(2->pow(31)))->oclAsType(long) ; while i /= 0 do ( (     y := MathLib.bitwiseOr(y, i) ; 
     if (y > 3037000499L or y * y > x) then     y := MathLib.bitwiseXor(y,i) ; else skip )  ;     i := i/(2->pow(1)) ) ; 
     return y * y = x );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int getElement(int a[],int n,int S){
    Arrays.sort(a);
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(sum+(a[i]*(n-i))==S)return a[i];
      sum+=a[i];
    }
    return-1 ;
  }
  public static void main(String[] args){
    int S=5 ;
    int a[]={
      1,3,2,5,8 };
      int n=a.length ;
      System.out.println(getElement(a,n,S));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getElement( a : Sequence(int), n : int, S : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (sum + (a[i+1] * (n - i)) = S) then     return a[i+1] else skip ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : int ; S := 5 ;
     var a : Sequence(int) ; a := Sequence{1,3,2,5,8} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(getElement(a, n, S)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minimalLength(int a[],int n){
    int[][] dp=new int[n+1][n+1];
    int[] dp1=new int[n];
    int i,j,k ;
    for(i=0 ; i<n+1 ; i++){
      for(j=0 ; j<n+1 ; j++){
        dp[i][j]=-1 ;
      }
    }
    for(int size=1 ; size<=n ; size++){
      for(i=0 ; i<n-size+1 ; i++){
        j=i+size-1 ;
        if(i==j)dp[i][j]=a[i];
        else {
          for(k=i ; k<j ; k++){
            if(dp[i][k]!=-1 && dp[i][k]==dp[k+1][j])dp[i][j]=dp[i][k]+1 ;
          }
        }
      }
    }
    for(i=0 ; i<n ; i++)dp1[i]=(int)1e7 ;
    for(i=0 ; i<n ; i++){
      for(j=0 ; j<=i ; j++){
        if(dp[j][i]!=-1){
          if(j==0)dp1[i]=1 ;
          else dp1[i]=Math.min(dp1[i],dp1[j-1]+1);
        }
      }
    }
    return dp1[n-1];
  }
  public static void main(String[] args){
    int n=7 ;
    int a[]={
      3,3,4,4,4,3,3 };
      System.out.print(minimalLength(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimalLength( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
     var dp1 : Sequence(int) ; dp1 := Integer.subrange(1,n)->collect(0) ;
    var i : int ;
    var j : int ;
    var k : int ;
        i := 0 ; while i < n + 1 do ( (         j := 0 ; while j < n + 1 do ( (     dp[i+1][j+1] := -1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var size : int ; size := 1 ; while size <= n do ( (         i := 0 ; while i < n - size + 1 do ( (     j := i + size - 1 ; 
     if (i = j) then     dp[i+1][j+1] := a[i+1] ; else (         k := i ; while k < j do ( (     if (dp[i+1][k+1] /= -1 & dp[i+1][k+1] = dp[k + 1+1][j+1]) then     dp[i+1][j+1] := dp[i+1][k+1] + 1 ; else skip )  ;     k := k + 1 ) ) )  ;     i := i + 1 ) )  ;     size := size + 1 ) ; 
        i := 0 ; while i < n do (     dp1[i+1] := 1e7->oclAsType(int) ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (         j := 0 ; while j <= i do ( (     if (dp[j+1][i+1] /= -1) then (     if (j = 0) then     dp1[i+1] := 1 ; else     dp1[i+1] := Set{dp1[i+1], dp1[j - 1+1] + 1}->min() ; ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return dp1[n - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     var a : Sequence(int) ; a := Sequence{3,3,4,4,4,3,3} ;
     OclFile["System.out"].print(minimalLength(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public String longestWord(String[] words){
    Trie trie=new Trie();
    int index=0 ;
    for(String word : words){
      trie.insert(word,++index);
    }
    trie.words=words ;
    return trie.dfs();
  }
}
class Node {
  char c ;
  HashMap<Character,Node>children=new HashMap();
  int end ;
  public Node(char c){
    this.c=c ;
  }
}
class Trie {
  Node root ;
  String[] words ;
  public Trie(){
    root=new Node('0');
  }
  public void insert(String word,int index){
    Node cur=root ;
    for(char c : word.toCharArray()){
      cur.children.putIfAbsent(c,new Node(c));
      cur=cur.children.get(c);
    }
    cur.end=index ;
  }
  public String dfs(){
    String ans="" ;
    Stack<Node>stack=new Stack();
    stack.push(root);
    while(! stack.empty()){
      Node node=stack.pop();
      if(node.end>0 || node==root){
        if(node!=root){
          String word=words[node.end-1];
          if(word.length()>ans.length()|| word.length()==ans.length()&& word.compareTo(ans)<0){
            ans=word ;
          }
        }
        for(Node nei : node.children.values()){
          stack.push(nei);
        }
      }
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation longestWord( words : Sequence(String)) : String
  pre: true
  post: true
  activity: (     var trie : Trie ; trie := Trie.newTrie() ;
     var index : int ; index := 0 ;
    for (word : words) do ( (     trie := trie.insertAt(word+1, StringLib.newString((index + 1))) )  ) ; 
    trie.words := words ; 
    return trie.dfs() 
 );
}
 class Node {
   attribute c : String;
   attribute children : Map(String,Node) := Map{};
   attribute end : int;
   static operation newNode( c : String) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(c);
    return self );
  operation initialise( c : String) : void
  pre: true  post: true
  activity: (     self.c := c );
}
class Trie {
   attribute root : Node;
   attribute words : Sequence(String);
   static operation newTrie() : Trie
  pre: true
  post: true
  activity:
  ( var self : Trie ;
    self := createTrie();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     root := Node.newNode('0') );
   operation insert( word : String, index : int) : void
  pre: true
  post: true
  activity: (     var cur : Node ; cur := root ;
     for (c : word->characters()) do ( (     cur.children.putIfAbsent(c, Node.newNode(c)) ; 
     cur := cur.children->at(c+1) )  ) ; 
     cur.end := index );
   operation dfs() : String
  pre: true
  post: true
  activity: (     var ans : String ; ans := "" ;
     var stack : Sequence(Node) ; stack := Sequence{} ;
    stack := stack->append(root) ; 
    while (not(stack->isEmpty())) do (     var node : Node ; node := stack->last() ;
     if (node.end > 0 or node = root) then (     if (node /= root) then (     var word : String ; word := words[node.end - 1+1] ;
     if (word->size() > ans->size() or word->size() = ans->size() & word->compareTo(ans) < 0) then (     ans := word ) else skip ) else skip ; 
     for (nei : node.children.allInstances()) do ( (     stack := stack->append(nei) )  ) ) else skip ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countFactors(int n,int p){
    int pwr=0 ;
    while(n>0 && n % p==0){
      n/=p ;
      pwr++;
    }
    return pwr ;
  }
  static int getCount(int l,int r,int p){
    int cnt=0 ;
    for(int i=l ; i<=r ; i++){
      cnt+=countFactors(i,p);
    }
    return cnt ;
  }
  public static void main(String[] args){
    int l=2,r=8,p=2 ;
    System.out.println(getCount(l,r,p));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countFactors( n : int, p : int) : int
  pre: true
  post: true
  activity: (     var pwr : int ; pwr := 0 ;
     while (n > 0 & n mod p = 0) do (     n := n/(p) ; 
     pwr := pwr + 1 ) ; 
     return pwr );
  static   operation getCount( l : int, r : int, p : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := l ; while i <= r do ( (     cnt := cnt+(countFactors(i, p)) )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 2 ;
    var r : int ; r := 8 ;
    var p : int ; p := 2 ;
     OclFile["System.out"].println(getCount(l, r, p)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int mod=1000000007 ;
  static long power(long a,long n){
    if(n==0)return 1 ;
    long p=power(a,n/2)% mod ;
    p=(p*p)% mod ;
    if((n & 1)==1)p=(p*a)% mod ;
    return p ;
  }
  static int countPermutations(int n){
    if(n==1){
      return 0 ;
    }
    return((int)power(2,n-1)-2)% mod ;
  }
  public static void main(String args[]){
    int n=5 ;
    System.out.println(countPermutations(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute mod : int := 1000000007;
  static   operation power( a : long, n : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     var p : long ; p := power(a, n / 2) mod mod ;
    p := (p * p) mod mod ; 
    if ((n & 1) = 1) then     p := (p * a) mod mod ; else skip ; 
    return p 
 );
  static   operation countPermutations( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then (     return 0 ) else skip ; 
     return (power(2, n - 1)->oclAsType(int) - 2) mod mod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(countPermutations(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Filling_Shapes {
  static Scanner sc=new Scanner(System.in);
  static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args){
    int n=sc.nextInt();
    pw.println((n % 2)==1 ? 0 :(int)Math.pow(2,n/2));
    pw.close();
  }
  public static int find(int n){
    int arr[]=new int[60+1];
    arr[1]=0 ;
    arr[2]=2 ;
    for(int i=3 ; i<=n ; i++){
      arr[i]=arr[i-2]*2 ;
    }
    return arr[n];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Filling_Shapes {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     skip ; 
     skip );
  static   operation find( n : int) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,60 + 1)->collect(0) ;
     arr[1+1] := 0 ; 
    arr[2+1] := 2 ; 
        var i : int ; i := 3 ; while i <= n do ( (     arr[i+1] := arr[i - 2+1] * 2 )  ;     i := i + 1 ) ; 
    return arr[n+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countOperations(int arr[],int n){
    int count=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if(arr[i] % 2==1){
        arr[i]++;
        arr[i+1]++;
        count+=2 ;
      }
    }
    for(int i=0 ; i<n ; i++){
      if(arr[i] % 2==1)return-1 ;
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      2,3,4,5,6 };
      int n=arr.length ;
      System.out.print(countOperations(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countOperations( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] mod 2 = 1) then (     arr[i+1] := arr[i+1] + 1 ; 
     arr[i + 1+1] := arr[i + 1+1] + 1 ; 
     count := count+(2) ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 = 1) then     return -1 else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4,5,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(countOperations(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import java.util.*;
import java.io.*;
public class x1496B {
  public static void main(String omkar[])throws Exception {
    BufferedReader infile=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(infile.readLine());
    int T=Integer.parseInt(st.nextToken());
    StringBuilder sb=new StringBuilder();
    while(T-->0){
      st=new StringTokenizer(infile.readLine());
      int N=Integer.parseInt(st.nextToken());
      int K=Integer.parseInt(st.nextToken());
      int[] arr=readArr(N,infile,st);
      TreeSet<Integer>set=new TreeSet<Integer>();
      for(int x : arr)set.add(x);
      int mex=0 ;
      while(set.contains(mex))mex++;
      boolean stuck=false ;
      while(K>0){
        if(set.first()==0 && set.last()==set.size()-1)break ;
        int val=(set.last()+mex+1)/2 ;
        if(set.contains(val)){
          stuck=true ;
          break ;
        }
        set.add(val);
        while(set.contains(mex))mex++;
        K--;
      }
      int res=set.size();
      if(! stuck)res+=K ;
      sb.append(res+"\n");
    }
    System.out.print(sb);
  }
  public static int[] readArr(int N,BufferedReader infile,StringTokenizer st)throws Exception {
    int[] arr=new int[N];
    st=new StringTokenizer(infile.readLine());
    for(int i=0 ; i<N ; i++)arr[i]=Integer.parseInt(st.nextToken());
    return arr ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class x1496B {
  static   operation main( omkar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var infile : OclFile ; infile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(infile.readLine()) ;
    var T : int ; T := (st.next())->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     st := OclIterator.newOclIterator_String(infile.readLine()) ; 
     var N : int ; N := (st.next())->toInteger() ;
    var K : int ; K := (st.next())->toInteger() ;
    var arr : Sequence(int) ; arr := readArr(N, infile, st) ;
    var set : Set(int) ; set := Set{} ;
    for (x : arr) do (     set := set->including(x) ;  ) ; 
    var mex : int ; mex := 0 ;
    while (set->includes(mex)) do     mex := mex + 1 ; ; 
    var stuck : boolean ; stuck := false ;
    while (K > 0) do (     if (set->first() = 0 & set->last() = set->size() - 1) then     break else skip ; 
     var val : int ; val := (set->last() + mex + 1) / 2 ;
    if (set->includes(val)) then (     stuck := true ; 
     break ) else skip ; 
    set := set->including(val) ; 
    while (set->includes(mex)) do     mex := mex + 1 ; ; 
    K := K - 1 ; 
 ) ; 
    var res : int ; res := set->size() ;
    if (not(stuck)) then     res := res+(K) ; else skip ; 
    sb := sb + StringLib.newString(res + "\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].print(sb) ; 
 );
  static   operation readArr( N : int, infile : OclFile, st : OclIterator) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
     st := OclIterator.newOclIterator_String(infile.readLine()) ; 
         var i : int ; i := 0 ; while i < N do (     arr[i+1] := (st.next())->toInteger() ;  ;     i := i + 1 ) ; 
     return arr );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Application {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    for(int i=0 ; i<n ; i++){
      long a=scan.nextLong();
      long b=scan.nextLong();
      long c=scan.nextLong();
      if(Math.min(a,b)*(c+1)>=Math.max(a,b))System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Application {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : long ; a := scan.getCurrent()->toLong() ;
     var b : long ; b := scan.getCurrent()->toLong() ;
     var c : long ; c := scan.getCurrent()->toLong() ;
     if (Set{a, b}->min() * (c + 1) >= Set{a, b}->max()) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test228 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int a=in.nextInt();
      int b=in.nextInt();
      int c=in.nextInt();
      if(a>b){
        if(a % b==0){
          if(a/b-1<=c){
            System.out.println("YES");
          }
          else {
            System.out.println("NO");
          }
        }
        else {
          if(a/b<=c){
            System.out.println("YES");
          }
          else {
            System.out.println("NO");
          }
        }
      }
      else {
        if(b % a==0){
          if(b/a-1<=c){
            System.out.println("YES");
          }
          else {
            System.out.println("NO");
          }
        }
        else {
          if(b/a<=c){
            System.out.println("YES");
          }
          else {
            System.out.println("NO");
          }
        }
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test228 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
     var c : int ; c := in.getCurrent()->toInteger() ;
     if (a > b) then (     if (a mod b = 0) then (     if (a / b - 1 <= c) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else (     if (a / b <= c) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ) else (     if (b mod a = 0) then (     if (b / a - 1 <= c) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else (     if (b / a <= c) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class QQQ {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long n=in.nextLong();
    for(int i=0 ; i<n ; i++){
      long r=in.nextLong();
      long b=in.nextLong();
      long d=in.nextLong();
      double c=Math.abs(r-b)/(double)Math.min(r,b);
      if(c<=d)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class QQQ {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toLong() ;
         var i : int ; i := 0 ; while i < n do ( (     var r : long ; r := in.getCurrent()->toLong() ;
     var b : long ; b := in.getCurrent()->toLong() ;
    var d : long ; d := in.getCurrent()->toLong() ;
    var c : double ; c := if r - b < 0 then -(r - b) else r - b endif / Set{r, b}->min()->oclAsType(double) ;
    if (c <= d) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class gfg {
  static boolean isPrime(int n){
    for(int i=2 ; i*i<=n ; i++){
      if(n % i==0)return false ;
    }
    return true ;
  }
  static int sum(int l,int r){
    int sum=0 ;
    for(int i=l ; i<=r ; i++){
      if(isPrime(i))continue ;
      for(int j=2 ; j<i ; j++){
        if(i % j==0 && isPrime(j))sum+=j ;
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int l=18,r=25 ;
    System.out.println(sum(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class gfg {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation sum( l : int, r : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := l ; while i <= r do ( (     if (isPrime(i)) then     continue else skip ; 
         var j : int ; j := 2 ; while j < i do ( (     if (i mod j = 0 & isPrime(j)) then     sum := sum+(j) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 18 ;
    var r : int ; r := 25 ;
     OclFile["System.out"].println(sum(l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static void main(String[] args){
    int n=3 ;
    int sum=5 ;
    findCount(n,sum);
  }
  private static void findCount(int n,int sum){
    int start=(int)Math.pow(10,n-1);
    int end=(int)Math.pow(10,n)-1 ;
    int count=0 ;
    int i=start ;
    while(i<end){
      int cur=0 ;
      int temp=i ;
      while(temp!=0){
        cur+=temp % 10 ;
        temp=temp/10 ;
      }
      if(cur==sum){
        count++;
        i+=9 ;
      }
      else i++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var sum : int ; sum := 5 ;
     execute findCount(n, sum) );
  static   operation findCount( n : int, sum : int) : void
  pre: true
  post: true
  activity: (     var start : int ; start := 10->pow(n - 1)->oclAsType(int) ;
     var end : int ; end := 10->pow(n)->oclAsType(int) - 1 ;
    var count : int ; count := 0 ;
    var i : int ; i := start ;
    while (i < end) do (     var cur : int ; cur := 0 ;
     var temp : int ; temp := i ;
     while (temp /= 0) do (     cur := cur+(temp mod 10) ; 
     temp := temp / 10 ) ; 
     if (cur = sum) then (     count := count + 1 ; 
     i := i+(9) ) else     i := i + 1 ; ) ; 
    OclFile["System.out"].println(count) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.*;
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String str=scan.nextLine();
    String st=st=str.substring(str.length()-1)+str.substring(0,str.length()-1);
    int counter=1 ;
    while(! st.equals(str)){
      st=st.substring(st.length()-1)+st.substring(0,st.length()-1);
      counter++;
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := scan.nextLine() ;
    var st : String ;     st := str.subrange(str->size() - 1+1,str->size() - 1) + str.subrange(0+1,str->size() - 1) ;
st := st ;
    var counter : int ; counter := 1 ;
    while (not(st = str)) do (     st := st.subrange(st->size() - 1+1,st->size() - 1) + st.subrange(0+1,st->size() - 1) ; 
     counter := counter + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String s=input.nextLine();
    String[] v=new String[s.length()];
    int c=1 ;
    boolean found=false ;
    for(int i=0 ; i<s.length()-1 ; i++){
      v[i]=s ;
      s=s.charAt(s.length()-1)+s ;
      s=s.substring(0,s.length()-1);
      for(int j=0 ; j<i+1 && ! found ; j++){
        if(s.equals(v[j]))found=true ;
      }
      if(! found)c++;
      found=false ;
    }
    System.out.print(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := input.nextLine() ;
    var v : Sequence(String) ; v := Integer.subrange(1,s->size())->collect(null) ;
    var c : int ; c := 1 ;
    var found : boolean ; found := false ;
        var i : int ; i := 0 ; while i < s->size() - 1 do ( (     v[i+1] := s ; 
     s := s->at(s->size() - 1+1) + s ; 
    s := s.subrange(0+1,s->size() - 1) ; 
        var j : int ; j := 0 ; while j < i + 1 & not(found) do ( (     if (s = v[j+1]) then     found := true ; else skip )  ;     j := j + 1 ) ; 
    if (not(found)) then     c := c + 1 ; else skip ; 
    found := false ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class myMain {
  public static int cyclicShift(String in){
    int counter=0 ;
    String temp2="" ;
    for(int i=0 ; i<in.length(); i++){
      String temp="" ;
      String tempC="" ;
      tempC=tempC+in.substring(0,i+1);
      temp=temp+in.substring(i+1)+tempC ;
      if(temp2.contains(temp))continue ;
      counter++;
      temp2=temp2+" "+temp ;
    }
    return counter ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String Input=sc.nextLine();
    System.out.println(cyclicShift(Input));
  }
}
------------------------------------------------------------
OCL File:
---------
 class myMain {
  static   operation cyclicShift( in : String) : int
  pre: true
  post: true
  activity: (     var counter : int ; counter := 0 ;
     var temp2 : String ; temp2 := "" ;
         var i : int ; i := 0 ; while i < in->size() do ( (     var temp : String ; temp := "" ;
     var tempC : String ; tempC := "" ;
    tempC := tempC + in.subrange(0+1,i + 1) ; 
    temp := temp + in.subrange(i + 1+1,i + 1) + tempC ; 
    if (temp2->includes(temp)) then     continue else skip ; 
    counter := counter + 1 ; 
    temp2 := temp2 + " " + temp ; 
 )  ;     i := i + 1 ) ; 
     return counter );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var Input : String ; Input := sc.nextLine() ;
     OclFile["System.out"].println(cyclicShift(Input)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  static Scanner sc=new Scanner(System.in);
  public static void solve(){
  }
  public static void main(String[] args){
    int n=sc.nextInt();
    if(n<2 || n % 2!=0){
      System.out.println(0);
    }
    else System.out.println((int)Math.pow(2,n/2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation solve() : void
  pre: true
  post: true
  activity: skip;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n < 2 or n mod 2 /= 0) then (     OclFile["System.out"].println(0) ) else     OclFile["System.out"].println(2->pow(n / 2)->oclAsType(int)) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HongcowLearnstheCyclicShift {
  public static String cyc(String str){
    String nstr="" ;
    nstr+=str.substring(str.length()-1)+str.substring(0,str.length()-1);
    return nstr ;
  }
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    String str=scn.nextLine();
    Set<String>diffs=new HashSet<String>();
    for(int i=0 ; i<str.length(); i++){
      diffs.add(str);
      str=cyc(str);
    }
    System.out.println(diffs.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class HongcowLearnstheCyclicShift {
  static   operation cyc( str : String) : String
  pre: true
  post: true
  activity: (     var nstr : String ; nstr := "" ;
     nstr := nstr+(str.subrange(str->size() - 1+1,str->size() - 1) + str.subrange(0+1,str->size() - 1)) ; 
     return nstr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := scn.nextLine() ;
    var diffs : Set(String) ; diffs := Set{} ;
        var i : int ; i := 0 ; while i < str->size() do ( (     diffs := diffs->including(str) ; 
     str := cyc(str) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(diffs->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class _748_HonCOw {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String s=input.nextLine();
    ArrayList<String>names=new ArrayList<>();
    names.add(s);
    for(int i=1 ; i<s.length(); i++){
      String newS=s.substring(s.length()-i)+s.substring(0,s.length()-i);
      if(! names.contains(newS)){
        names.add(newS);
      }
    }
    System.out.println(names.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class _748_HonCOw {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := input.nextLine() ;
    var names : Sequence(String) ; names := Sequence{} ;
    names := names->including(s) ; 
        var i : int ; i := 1 ; while i < s->size() do ( (     var newS : String ; newS := s.subrange(s->size() - i+1,s->size() - i) + s.subrange(0+1,s->size() - i) ;
     if (not(names->includes(newS))) then (     names := names->including(newS) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(names->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static void main(String args[]){
    int n=5,i,j,num=1,gap ;
    gap=n-1 ;
    for(j=1 ; j<=n ; j++){
      num=j ;
      for(i=1 ; i<=gap ; i++)System.out.print(" ");
      gap--;
      for(i=1 ; i<=j ; i++){
        System.out.print(num);
        num++;
      }
      num--;
      num--;
      for(i=1 ; i<j ; i++){
        System.out.print(num);
        num--;
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var i : int ;
    var j : int ;
    var num : int ; num := 1 ;
    var gap : int ;
     gap := n - 1 ; 
         j := 1 ; while j <= n do ( (     num := j ; 
         i := 1 ; while i <= gap do (     OclFile["System.out"].print(" ") ;  ;     i := i + 1 ) ; 
    gap := gap - 1 ; 
        i := 1 ; while i <= j do ( (     OclFile["System.out"].print(num) ; 
     num := num + 1 )  ;     i := i + 1 ) ; 
    num := num - 1 ; 
    num := num - 1 ; 
        i := 1 ; while i < j do ( (     OclFile["System.out"].print(num) ; 
     num := num - 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float power(float x,int y){
    float temp ;
    if(y==0)return 1 ;
    temp=power(x,y/2);
    if(y % 2==0)return temp*temp ;
    else {
      if(y>0)return x*temp*temp ;
      else return(temp*temp)/x ;
    }
  }
  public static void main(String[] args){
    float x=2 ;
    int y=-3 ;
    System.out.printf("%f",power(x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation power( x : double, y : int) : double
  pre: true
  post: true
  activity: (     var temp : double ;
     if (y = 0) then     return 1 else skip ; 
     temp := power(x, y / 2) ; 
     if (y mod 2 = 0) then     return temp * temp else (     if (y > 0) then     return x * temp * temp else     return (temp * temp) / x ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : double ; x := 2 ;
     var y : int ; y := -3 ;
     OclFile["System.out"].printf("%f", power(x, y)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class gfg {
  public int digitsum(int n){
    int r=n % 9 ;
    if(r==0)return 9 ;
    else return r ;
  }
  public int find(int n,int d){
    int minimum=10 ;
    for(int i=0 ; i<9 ; i++){
      int current=(n+i*d);
      minimum=Math.min(minimum,digitsum(current));
    }
    return minimum ;
  }
}
class geek {
  public static void main(String[] args){
    gfg g=new gfg();
    int n=2546,d=124 ;
    System.out.println("Minimum possible digitsum is : "+(g.find(n,d)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class gfg {
   operation digitsum( n : int) : int
  pre: true
  post: true
  activity: (     var r : int ; r := n mod 9 ;
     if (r = 0) then     return 9 else     return r );
   operation find( n : int, d : int) : int
  pre: true
  post: true
  activity: (     var minimum : int ; minimum := 10 ;
         var i : int ; i := 0 ; while i < 9 do ( (     var current : int ; current := (n + i * d) ;
     minimum := Set{minimum, digitsum(current)}->min() )  ;     i := i + 1 ) ; 
     return minimum );
}
class geek {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : gfg ; g := gfg.newgfg() ;
     var n : int ; n := 2546 ;
    var d : int ; d := 124 ;
     OclFile["System.out"].println("Minimum possible digitsum is : " + (g.find(n, d))) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Sums {
  static void printXYZ(int n){
    if(n==1)System.out.println(-1);
    else {
      System.out.println("x is "+n);
      System.out.println("y is "+(n+1));
      System.out.println("z is "+(n*(n+1)));
    }
  }
  public static void main(String[] args){
    int n=7 ;
    printXYZ(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sums {
  static   operation printXYZ( n : int) : void
  pre: true
  post: true
  activity: (     if (n = 1) then     OclFile["System.out"].println(-1) ; else (     OclFile["System.out"].println("x is " + n) ; 
     OclFile["System.out"].println("y is " + (n + 1)) ; 
     OclFile["System.out"].println("z is " + (n * (n + 1))) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     execute printXYZ(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int merge(int arr[],int temp[],int left,int mid,int right){
    int inv_count=0 ;
    int i=left ;
    int j=mid ;
    int k=left ;
    while((i<=mid-1)&&(j<=right)){
      if(arr[i]<=arr[j])temp[k++]=arr[i++];
      else {
        temp[k++]=arr[j++];
        inv_count=inv_count+(mid-i);
      }
    }
    while(i<=mid-1)temp[k++]=arr[i++];
    while(j<=right)temp[k++]=arr[j++];
    for(i=left ; i<=right ; i++)arr[i]=temp[i];
    return inv_count ;
  }
  static int _mergeSort(int arr[],int temp[],int left,int right){
    int mid,inv_count=0 ;
    if(right>left){
      mid=(right+left)/2 ;
      inv_count=_mergeSort(arr,temp,left,mid);
      inv_count+=_mergeSort(arr,temp,mid+1,right);
      inv_count+=merge(arr,temp,left,mid+1,right);
    }
    return inv_count ;
  }
  static int countSwaps(int arr[],int n){
    int temp[]=new int[n];
    return _mergeSort(arr,temp,0,n-1);
  }
  public static void main(String[] args){
    int arr[]={
      1,20,6,4,5 };
      int n=arr.length ;
      System.out.println("Number of swaps is "+countSwaps(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation merge( arr : Sequence(int), temp : Sequence(int), left : int, mid : int, right : int) : int
  pre: true
  post: true
  activity: (     var inv_count : int ; inv_count := 0 ;
     var i : int ; i := left ;
    var j : int ; j := mid ;
    var k : int ; k := left ;
    while ((i <= mid - 1) & (j <= right)) do (     if (arr[i+1] <= arr[j+1]) then       temp[k+1] := arr[i+1]  ; k := k + 1  ; i := i + 1 ; else (       temp[k+1] := arr[j+1]  ; k := k + 1  ; j := j + 1 ; 
     inv_count := inv_count + (mid - i) ) ) ; 
    while (i <= mid - 1) do       temp[k+1] := arr[i+1]  ; k := k + 1  ; i := i + 1 ; ; 
    while (j <= right) do       temp[k+1] := arr[j+1]  ; k := k + 1  ; j := j + 1 ; ; 
        i := left ; while i <= right do (     arr[i+1] := temp[i+1] ;  ;     i := i + 1 ) ; 
    return inv_count 
 );
  static   operation _mergeSort( arr : Sequence(int), temp : Sequence(int), left : int, right : int) : int
  pre: true
  post: true
  activity: (     var mid : int ;
    var inv_count : int ; inv_count := 0 ;
     if (right > left) then (     mid := (right + left) / 2 ; 
     inv_count := _mergeSort(arr, temp, left, mid) ; 
     inv_count := inv_count+(_mergeSort(arr, temp, mid + 1, right)) ; 
     inv_count := inv_count+(merge(arr, temp, left, mid + 1, right)) ) else skip ; 
     return inv_count );
  static   operation countSwaps( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var temp : Sequence(int) ; temp := Integer.subrange(1,n)->collect(0) ;
     return _mergeSort(arr, temp, 0, n - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,20,6,4,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Number of swaps is " + countSwaps(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Comparator ;
import java.util.PriorityQueue ;
public class GFG {
  static final int MAX_CHAR=26 ;
  static class IntCompare implements Comparator<Integer>{
    @ Override public int compare(Integer arg0,Integer arg1){
      if(arg0>arg1)return-1 ;
      else if(arg0<arg1)return 1 ;
      else return 0 ;
    }
  }
  static int minStringValue(String str,int k){
    int l=str.length();
    if(k>=l)return 0 ;
    int[] frequency=new int[MAX_CHAR];
    for(int i=0 ; i<l ; i++)frequency[str.charAt(i)-'a']++;
    Comparator<Integer>c=new IntCompare();
    PriorityQueue<Integer>q=new PriorityQueue<>(c);
    for(int i=0 ; i<MAX_CHAR ; i++){
      if(frequency[i]!=0)q.add(frequency[i]);
    }
    while(k!=0){
      int temp=q.peek();
      q.poll();
      temp=temp-1 ;
      q.add(temp);
      k--;
    }
    int result=0 ;
    while(! q.isEmpty()){
      int temp=q.peek();
      result+=temp*temp ;
      q.poll();
    }
    return result ;
  }
  public static void main(String args[]){
    String str="abbccc" ;
    int k=2 ;
    System.out.println(minStringValue(str,k));
    str="aaab" ;
    k=2 ;
    System.out.println(minStringValue(str,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX_CHAR : int := 26;
  static class IntCompare implements Function(<int>,(<int>,boolean)) {
      operation compare( arg0 : int, arg1 : int) : int
  pre: true
  post: true
  activity: (     if (arg0 > arg1) then     return -1 else     if (arg0 < arg1) then     return 1 else     return 0 ;  );
}
  static   operation minStringValue( str : String, k : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := str->size() ;
     if (k >= l) then     return 0 else skip ; 
    var frequency : Sequence(int) ; frequency := Integer.subrange(1,MAX_CHAR)->collect(0) ;
        var i : int ; i := 0 ; while i < l do (     frequency[str->at(i+1) - ('a')->char2byte()+1] := frequency[str->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    var c : Function(<int>,(<int>,boolean)) ; c := IntCompare.newIntCompare() ;
    var q : Sequence(int) ; q := Sequence{}->union(c) ;
        var i : int ; i := 0 ; while i < MAX_CHAR do ( (     if (frequency[i+1] /= 0) then     q := q->including(frequency[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    while (k /= 0) do (     var temp : int ; temp := q->min() ;
     q := q->sort()->tail() ; 
    temp := temp - 1 ; 
    q := q->including(temp) ; 
    k := k - 1 ; 
 ) ; 
    var result : int ; result := 0 ;
    while (not(q->isEmpty())) do (     var temp : int ; temp := q->min() ;
     result := result+(temp * temp) ; 
     q := q->sort()->tail() ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abbccc" ;
     var k : int ; k := 2 ;
    OclFile["System.out"].println(minStringValue(str, k)) ; 
    str := "aaab" ; 
    k := 2 ; 
    OclFile["System.out"].println(minStringValue(str, k)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int lenOfLongSubarr(int arr[],int n){
    HashMap<Integer,Integer>um=new HashMap<Integer,Integer>();
    int sum=0,maxLen=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=arr[i]==0 ?-1 : 1 ;
      if(sum==1)maxLen=i+1 ;
      else if(! um.containsKey(sum))um.put(sum,i);
      if(um.containsKey(sum-1)){
        if(maxLen<(i-um.get(sum-1)))maxLen=i-um.get(sum-1);
      }
    }
    return maxLen ;
  }
  public static void main(String[] args){
    int arr[]={
      0,1,1,0,0,1 };
      int n=arr.length ;
      System.out.println("Length="+lenOfLongSubarr(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation lenOfLongSubarr( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var um : Map(int,int) ; um := Map{} ;
     var sum : int ; sum := 0 ;
    var maxLen : int ; maxLen := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(if arr[i+1] = 0 then -1 else 1 endif) ; 
     if (sum = 1) then     maxLen := i + 1 else     if (not(um->keys()->includes(sum))) then     um := um->union(Map{sum |-> i}) ; else skip ; ;  
     if (um->keys()->includes(sum - 1)) then (     if (maxLen < (i - um->at(sum - 1))) then     maxLen := i - um->at(sum - 1) ; else skip ) else skip )  ;     i := i + 1 ) ; 
     return maxLen );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,1,1,0,0,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Length=" + lenOfLongSubarr(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Filling_Shapes {
  static Scanner sc=new Scanner(System.in);
  static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args){
    int n=sc.nextInt();
    System.out.println(find(n));
  }
  public static int find(int n){
    int arr[]=new int[60+1];
    arr[1]=0 ;
    arr[2]=2 ;
    for(int i=3 ; i<=n ; i++){
      arr[i]=arr[i-2]*2 ;
    }
    return arr[n];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Filling_Shapes {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(find(n)) );
  static   operation find( n : int) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,60 + 1)->collect(0) ;
     arr[1+1] := 0 ; 
    arr[2+1] := 2 ; 
        var i : int ; i := 3 ; while i <= n do ( (     arr[i+1] := arr[i - 2+1] * 2 )  ;     i := i + 1 ) ; 
    return arr[n+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printArr(int[] arr,int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  static void findArrangement(int arr[],int n){
    if(n<2){
      System.out.print("-1");
      return ;
    }
    int minVal=Arrays.stream(arr).min().getAsInt();
    for(int i=0 ; i<n ; i++){
      if(arr[i]==minVal){
        swap(arr,i,n-1);
        break ;
      }
    }
    int andVal=arr[0];
    for(int i=1 ; i<n-1 ; i++){
      andVal &=arr[i];
    }
    if(andVal==arr[n-1])printArr(arr,n);
    else System.out.print("-1");
  }
  static int[] swap(int[] arr,int i,int j){
    int temp=arr[i];
    arr[i]=arr[j];
    arr[j]=temp ;
    return arr ;
  }
  public static void main(String[] args){
    int arr[]={
      1,5,3,3 };
      int n=arr.length ;
      findArrangement(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation findArrangement( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     if (n < 2) then (     OclFile["System.out"].print("-1") ; 
     return ) else skip ; 
     var minVal : int ; minVal := stream(arr).min().getAsInt() ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = minVal) then (     execute swap(arr, i, n - 1) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var andVal : int ; andVal := arr[0+1] ;
        var i : int ; i := 1 ; while i < n - 1 do ( (     andVal := MathLib.bitwiseAnd(andVal, arr[i+1]) )  ;     i := i + 1 ) ; 
    if (andVal = arr[n - 1+1]) then     execute printArr(arr, n) else     OclFile["System.out"].print("-1") ; ;  
 );
  static   operation swap( arr : Sequence(int), i : int, j : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := arr[j+1] ; 
     arr[j+1] := temp ; 
     return arr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,3,3} ;
     var n : int ; n := arr->size() ;
     execute findArrangement(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findProduct(int arr[],int n,int k){
    int prod=1 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] % k==0){
        prod*=arr[i];
      }
    }
    return prod ;
  }
  public static void main(String[] args){
    int arr[]={
      15,16,10,9,6,7,17 };
      int n=arr.length ;
      int k=3 ;
      System.out.println(findProduct(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findProduct( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var prod : int ; prod := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod k = 0) then (     prod := prod*(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
     return prod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{15,16,10,9,6,7,17} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println(findProduct(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int ways(int n){
    if(n==1){
      return 1 ;
    }
    if(n==2){
      return 2 ;
    }
    else {
      return ways(n-1)+ways(n-2);
    }
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println("Number of ways="+ways(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation ways( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then (     return 1 ) else skip ; 
     if (n = 2) then (     return 2 ) else (     return ways(n - 1) + ways(n - 2) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println("Number of ways=" + ways(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1567A_DominoDisaster {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int len=parseInt(input.nextLine());
      String row=input.nextLine();
      String result="" ;
      for(int i=0 ; i<len ; i++){
        char c=row.charAt(i);
        if(c=='U'){
          result+='D' ;
        }
        else if(c=='D'){
          result+='U' ;
        }
        else {
          result+=c ;
        }
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1567A_DominoDisaster {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var len : int ; len := parseInt(input.nextLine()) ;
     var row : String ; row := input.nextLine() ;
    var result : String ; result := "" ;
        var i : int ; i := 0 ; while i < len do ( (     var c : String ; c := row->at(i+1) ;
     if (c = 'U') then (     result := result+('D') ) else     if (c = 'D') then (     result := result+('U') ) else (     result := result+(c) ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Domino_Disaster {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testcase=sc.nextInt();
    while(testcase!=0){
      testcase--;
      int len=sc.nextInt();
      String str=sc.next();
      char[] s=str.toCharArray();
      for(int i=0 ; i<len ; i++){
        if(s[i]=='U')s[i]='D' ;
        else if(s[i]=='D')s[i]='U' ;
      }
      String a=new String(s);
      System.out.print(a);
      if(testcase>0)System.out.println();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Domino_Disaster {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testcase : int ; testcase := sc.getCurrent()->toInteger() ;
     while (testcase /= 0) do (     testcase := testcase - 1 ; 
     var len : int ; len := sc.getCurrent()->toInteger() ;
    var str : String ; str := sc.getCurrent() ;
    var s : Sequence(String) ; s := str->characters() ;
        var i : int ; i := 0 ; while i < len do ( (     if (s[i+1] = 'U') then     s[i+1] := 'D' ; else     if (s[i+1] = 'D') then     s[i+1] := 'U' ; else skip ; )  ;     i := i + 1 ) ; 
    var a : String ; a := StringLib.newString(s) ;
    OclFile["System.out"].print(a) ; 
    if (testcase > 0) then     OclFile["System.out"].println() ; else skip ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
import java.io.*;
public class codeHundredSixty {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=input.nextInt();
      String gabe=input.next();
      for(int i=0 ; i<n ; i++){
        if(gabe.charAt(i)=='D'){
          System.out.print("U");
        }
        else if(gabe.charAt(i)=='U'){
          System.out.print("D");
        }
        else if(gabe.charAt(i)=='R'){
          System.out.print("R");
        }
        else if(gabe.charAt(i)=='L'){
          System.out.print("L");
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var gabe : String ; gabe := input.getCurrent() ;
         var i : int ; i := 0 ; while i < n do ( (     if (gabe->at(i+1) = 'D') then (     OclFile["System.out"].print("U") ) else     if (gabe->at(i+1) = 'U') then (     OclFile["System.out"].print("D") ) else     if (gabe->at(i+1) = 'R') then (     OclFile["System.out"].print("R") ) else     if (gabe->at(i+1) = 'L') then (     OclFile["System.out"].print("L") ) else skip ; ;  ;  )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class problemB {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num_tc=1 ;
    num_tc=sc.nextInt();
    for(int tc=1 ; tc<=num_tc ; tc++){
      solve(sc);
    }
  }
  static void solve(Scanner sc){
    int n=sc.nextInt();
    int arr[]=new int[n];
    Boolean oddPresent=false ;
    int cnteven=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      if(arr[i] % 2==1)oddPresent=true ;
      else cnteven++;
    }
    int ans=-1 ;
    if(oddPresent){
      ans=cnteven ;
    }
    else {
      int minOperations=Integer.MAX_VALUE ;
      for(int val : arr){
        int cnt=0 ;
        while(val % 2==0){
          val>>=1 ;
          cnt++;
        }
        minOperations=Math.min(minOperations,cnt);
      }
      ans=n-1+minOperations ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class problemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num_tc : int ; num_tc := 1 ;
     num_tc := sc.getCurrent()->toInteger() ; 
         var tc : int ; tc := 1 ; while tc <= num_tc do ( (     execute solve(sc) )  ;     tc := tc + 1 ) );
  static   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var oddPresent : Boolean ; oddPresent := false ;
    var cnteven : int ; cnteven := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr[i+1] mod 2 = 1) then     oddPresent := true ; else     cnteven := cnteven + 1 ; )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -1 ;
    if (oddPresent) then (     ans := cnteven ) else (     var minOperations : int ; minOperations := 2147483647 ;
     for (val : arr) do ( (     var cnt : int ; cnt := 0 ;
     while (val mod 2 = 0) do (     val := val/(2->pow(1)) ; 
     cnt := cnt + 1 ) ; 
     minOperations := Set{minOperations, cnt}->min() )  ) ; 
     ans := n - 1 + minOperations ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static int toOdd(int v){
    int i=0 ;
    while((v & 1)==0){
      i++;
      v>>=1 ;
    }
    return i ;
  }
  public static void main(String args[])throws Exception {
    Scanner scn=new Scanner(System.in);
    int cases=scn.nextInt();
    while(cases-->0){
      int len=scn.nextInt();
      int min=Integer.MAX_VALUE ;
      int oddCount=0 ;
      int evenCount=0 ;
      for(int i=0 ; i<len ; i++){
        int v=scn.nextInt();
        if((v & 1)==0){
          evenCount++;
          min=Math.min(min,toOdd(v));
        }
        else {
          oddCount++;
        }
      }
      if(oddCount!=0){
        System.out.println(evenCount);
      }
      else {
        System.out.println(min+(evenCount-1));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation toOdd( v : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     while ((v & 1) = 0) do (     i := i + 1 ; 
     v := v/(2->pow(1)) ) ; 
     return i );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cases : int ; cases := scn.getCurrent()->toInteger() ;
         while (cases > 0) do (        cases := cases - 1 ;     skip ; (     var len : int ; len := scn.getCurrent()->toInteger() ;
     var min : int ; min := 2147483647 ;
    var oddCount : int ; oddCount := 0 ;
    var evenCount : int ; evenCount := 0 ;
        var i : int ; i := 0 ; while i < len do ( (     var v : int ; v := scn.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseAnd(v,1)) = 0) then (     evenCount := evenCount + 1 ; 
     min := Set{min, toOdd(v)}->min() ) else (     oddCount := oddCount + 1 ) )  ;     i := i + 1 ) ; 
    if (oddCount /= 0) then (     OclFile["System.out"].println(evenCount) ) else (     OclFile["System.out"].println(min + (evenCount - 1)) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(true){
      int n=stdIn.nextInt();
      if(n==0)break ;
      int[] tmp=new int[n];
      int[] map=new int[1000];
      for(int i=0 ; i<n ; i++){
        tmp[i]=stdIn.nextInt();
      }
      int counter=0 ;
      while(true){
        map=new int[1000];
        for(int i=0 ; i<n ; i++){
          map[tmp[i] ]++;
        }
        boolean change=false ;
        for(int i=0 ; i<n ; i++){
          if(tmp[i]!=map[tmp[i] ]){
            tmp[i]=map[tmp[i] ];
            change=true ;
          }
        }
        if(! change){
          break ;
        }
        counter++;
      }
      System.out.println(counter);
      System.out.print(tmp[0]);
      for(int i=1 ; i<n ; i++){
        System.out.print(" "+tmp[i]);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var tmp : Sequence(int) ; tmp := Integer.subrange(1,n)->collect(0) ;
    var map : Sequence(int) ; map := Integer.subrange(1,1000)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     tmp[i+1] := stdIn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var counter : int ; counter := 0 ;
    while (true) do (     map := Integer.subrange(1,1000)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do ( (     map[tmp[i+1]+1] := map[tmp[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var change : boolean ; change := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (tmp[i+1] /= map[tmp[i+1]+1]) then (     tmp[i+1] := map[tmp[i+1]+1] ; 
     change := true ) else skip )  ;     i := i + 1 ) ; 
    if (not(change)) then (     break ) else skip ; 
    counter := counter + 1 ; 
 ) ; 
    OclFile["System.out"].println(counter) ; 
    OclFile["System.out"].print(tmp[0+1]) ; 
        var i : int ; i := 1 ; while i < n do ( (     OclFile["System.out"].print(" " + tmp[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1688B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      int minPosOfOne=Integer.MAX_VALUE ;
      int ceven=0 ;
      int codd=0 ;
      for(int i=0 ; i<n ; i++){
        int pos=0 ;
        int val=arr[i];
        if(val % 2==0)ceven++;
        else codd++;
        while((val & 1)!=1){
          pos++;
          val>>=1 ;
        }
        minPosOfOne=Math.min(minPosOfOne,pos);
      }
      System.out.println(ceven+minPosOfOne+(codd==0 ?-1 : 0));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1688B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var minPosOfOne : int ; minPosOfOne := 2147483647 ;
    var ceven : int ; ceven := 0 ;
    var codd : int ; codd := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var pos : int ; pos := 0 ;
     var val : int ; val := arr[i+1] ;
    if (val mod 2 = 0) then     ceven := ceven + 1 else     codd := codd + 1 ; ;  
    while ((MathLib.bitwiseAnd(val,1)) /= 1) do (     pos := pos + 1 ; 
     val := val/(2->pow(1)) ) ; 
    minPosOfOne := Set{minPosOfOne, pos}->min() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ceven + minPosOfOne + (if codd = 0 then -1 else 0 endif)) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class IncreasingSequence {
  public static void main(String[] args){
    new IncreasingSequence().runApp();
  }
  void runApp(){
    Scanner in=new Scanner(System.in);
    int len=in.nextInt();
    int d=in.nextInt();
    int def=0 ;
    int[] seq=new int[len];
    int moves=0 ;
    int i=0 ;
    do {
      seq[i]=in.nextInt();
      if(i>0){
        def=seq[i-1]-seq[i];
        if(def>=0){
          moves+=def/d+1 ;
          seq[i]+=(def/d+1)*d ;
        }
      }
      i++;
    }
    while(i<len);
    System.out.println(moves);
  }
}
------------------------------------------------------------
OCL File:
---------
 class IncreasingSequence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     IncreasingSequence.newIncreasingSequence().runApp() );
   operation runApp() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var def : int ; def := 0 ;
    var seq : Sequence(int) ; seq := Integer.subrange(1,len)->collect(0) ;
    var moves : int ; moves := 0 ;
    var i : int ; i := 0 ;
  while true do ((     seq[i+1] := in.getCurrent()->toInteger() ; 
     if (i > 0) then (     def := seq[i - 1+1] - seq[i+1] ; 
     if (def >= 0) then (     moves := moves+(def / d + 1) ; 
     seq[i+1] := seq[i+1]+((def / d + 1) * d) ) else skip ) else skip ; 
     i := i + 1 ) ;
    if (i < len) then skip else break) ; 
    OclFile["System.out"].println(moves) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt(),a=0,b=0,min=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; i++){
        int d=sc.nextInt();
        if(d % 2==1){
          a++;
        }
        else {
          b++;
          int index=0 ;
          while(d % 2==0){
            d/=2 ;
            index++;
          }
          min=Math.min(min,index);
        }
      }
      if(a!=0){
        System.out.println(b);
      }
      else {
        int p=b-1+min ;
        System.out.println(p);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
    var min : int ; min := 2147483647 ;
         var i : int ; i := 0 ; while i < n do ( (     var d : int ; d := sc.getCurrent()->toInteger() ;
     if (d mod 2 = 1) then (     a := a + 1 ) else (     b := b + 1 ; 
     var index : int ; index := 0 ;
     while (d mod 2 = 0) do (     d := d/(2) ; 
     index := index + 1 ) ; 
     min := Set{min, index}->min() ) )  ;     i := i + 1 ) ; 
     if (a /= 0) then (     OclFile["System.out"].println(b) ) else (     var p : int ; p := b - 1 + min ;
     OclFile["System.out"].println(p) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void sum(int mat[][],int r,int c){
    int i,j ;
    int upper_sum=0 ;
    int lower_sum=0 ;
    for(i=0 ; i<r ; i++)for(j=0 ; j<c ; j++){
      if(i<=j){
        upper_sum+=mat[i][j];
      }
    }
    System.out.println("Upper sum is "+upper_sum);
    for(i=0 ; i<r ; i++)for(j=0 ; j<c ; j++){
      if(j<=i){
        lower_sum+=mat[i][j];
      }
    }
    System.out.print("Lower sum is "+lower_sum);
  }
  public static void main(String[] args){
    int r=3 ;
    int c=3 ;
    int mat[][]={
      {
        6,5,4 },{
          1,2,5 },{
            7,9,7 }
          };
          sum(mat,r,c);
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sum( mat : Sequence(Sequence(int)), r : int, c : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var upper_sum : int ; upper_sum := 0 ;
    var lower_sum : int ; lower_sum := 0 ;
        i := 0 ; while i < r do (         j := 0 ; while j < c do ( (     if (i <= j) then (     upper_sum := upper_sum+(mat[i+1][j+1]) ) else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Upper sum is " + upper_sum) ; 
        i := 0 ; while i < r do (         j := 0 ; while j < c do ( (     if (j <= i) then (     lower_sum := lower_sum+(mat[i+1][j+1]) ) else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("Lower sum is " + lower_sum) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : int ; r := 3 ;
     var c : int ; c := 3 ;
     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{6,5,4},Sequence{1,2,5},Sequence{7,9,7}} ;
     execute sum(mat, r, c) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int lcs(int dp[][],String a,String b,int m,int n){
    for(int i=0 ; i<100 ; i++)for(int j=0 ; j<100 ; j++)dp[i][j]=-1 ;
    if(m<0 || n<0){
      return 0 ;
    }
    if(dp[m][n]!=-1)return dp[m][n];
    int ans=0 ;
    if(a.charAt(m)==b.charAt(n)){
      ans=(a.charAt(m)-48)+lcs(dp,a,b,m-1,n-1);
    }
    else ans=Math.max(lcs(dp,a,b,m-1,n),lcs(dp,a,b,m,n-1));
    dp[m][n]=ans ;
    return ans ;
  }
  static int costOfString(String str){
    int cost=0 ;
    for(int i=0 ; i<str.length(); i++)cost+=(str.charAt(i)-48);
    return cost ;
  }
  public static void main(String[] args){
    String a,b ;
    a="9142" ;
    b="1429" ;
    int dp[][]=new int[101][101];
    System.out.print((costOfString(a)+costOfString(b)-2*lcs(dp,a,b,a.length()-1,b.length()-1)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation lcs( dp : Sequence(Sequence(int)), a : String, b : String, m : int, n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 100 do (         var j : int ; j := 0 ; while j < 100 do (     dp[i+1][j+1] := -1 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     if (m < 0 or n < 0) then (     return 0 ) else skip ; 
    if (dp[m+1][n+1] /= -1) then     return dp[m+1][n+1] else skip ; 
    var ans : int ; ans := 0 ;
    if (a->at(m+1) = b->at(n+1)) then (     ans := (a->at(m+1) - 48) + lcs(dp, a, b, m - 1, n - 1) ) else     ans := Set{lcs(dp, a, b, m - 1, n), lcs(dp, a, b, m, n - 1)}->max() ; ;  
    dp[m+1][n+1] := ans ; 
    return ans 
 );
  static   operation costOfString( str : String) : int
  pre: true
  post: true
  activity: (     var cost : int ; cost := 0 ;
         var i : int ; i := 0 ; while i < str->size() do (     cost := cost+((str->at(i+1) - 48)) ;  ;     i := i + 1 ) ; 
     return cost );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ;
    var b : String ;
     a := "9142" ; 
    b := "1429" ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,101)->collect(Integer.subrange(1,101)->collect(0)) ;
    OclFile["System.out"].print((costOfString(a) + costOfString(b) - 2 * lcs(dp, a, b, a->size() - 1, b->size() - 1))) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
class GFG {
  static double MinimumMail(int n,int k,int x){
    double m=(n-1)+Math.ceil((n-1)*1.0/x)*(n-1)+Math.ceil(n*1.0/x)*(k-n);
    return m ;
  }
  public static void main(String[] args){
    int N=4 ;
    int K=9 ;
    int X=2 ;
    System.out.print((int)MinimumMail(N,K,X)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MinimumMail( n : int, k : int, x : int) : double
  pre: true
  post: true
  activity: (     var m : double ; m := (n - 1) + ((n - 1) * 1.0 / x)->ceil() * (n - 1) + (n * 1.0 / x)->ceil() * (k - n) ;
     return m );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     var K : int ; K := 9 ;
     var X : int ; X := 2 ;
     OclFile["System.out"].print(MinimumMail(N, K, X)->oclAsType(int) + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int getMin(int arr[],int n){
    int res=arr[0];
    for(int i=1 ; i<n ; i++)res=Math.min(res,arr[i]);
    return res ;
  }
  static int getMax(int arr[],int n){
    int res=arr[0];
    for(int i=1 ; i<n ; i++)res=Math.max(res,arr[i]);
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      12,1234,45,67,1 };
      int n=arr.length ;
      System.out.println("Minimum element"+" of array: "+getMin(arr,n));
      System.out.println("Maximum element"+" of array: "+getMax(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getMin( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do (     res := Set{res, arr[i+1]}->min() ;  ;     i := i + 1 ) ; 
     return res );
  static   operation getMax( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do (     res := Set{res, arr[i+1]}->max() ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,1234,45,67,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Minimum element" + " of array: " + getMin(arr, n)) ; 
     OclFile["System.out"].println("Maximum element" + " of array: " + getMax(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getMin(int arr[],int i,int n){
    return(n==1)? arr[i] : Math.min(arr[i],getMin(arr,i+1,n-1));
  }
  static int getMax(int arr[],int i,int n){
    return(n==1)? arr[i] : Math.max(arr[i],getMax(arr,i+1,n-1));
  }
  public static void main(String[] args){
    int arr[]={
      12,1234,45,67,1 };
      int n=arr.length ;
      System.out.print("Minimum element of array: "+getMin(arr,0,n)+"\n");
      System.out.println("Maximum element of array: "+getMax(arr,0,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getMin( arr : Sequence(int), i : int, n : int) : int
  pre: true
  post: true
  activity: (     return if (n = 1) then arr[i+1] else Set{arr[i+1], getMin(arr, i + 1, n - 1)}->min() endif );
  static   operation getMax( arr : Sequence(int), i : int, n : int) : int
  pre: true
  post: true
  activity: (     return if (n = 1) then arr[i+1] else Set{arr[i+1], getMax(arr, i + 1, n - 1)}->max() endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,1234,45,67,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print("Minimum element of array: " + getMin(arr, 0, n) + "\n") ; 
     OclFile["System.out"].println("Maximum element of array: " + getMax(arr, 0, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countHexadecimal(int L,int R){
    int count=0 ;
    for(int i=L ; i<=R ; i++){
      if(i>=10 && i<=15)count++;
      else if(i>15){
        int k=i ;
        while(k!=0){
          if(k % 16>=10)count++;
          k=k/16 ;
        }
      }
    }
    return count ;
  }
  public static void main(String args[]){
    int L=5,R=100 ;
    System.out.print(countHexadecimal(L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countHexadecimal( L : int, R : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := L ; while i <= R do ( (     if (i >= 10 & i <= 15) then     count := count + 1 ; else     if (i > 15) then (     var k : int ; k := i ;
     while (k /= 0) do (     if (k mod 16 >= 10) then     count := count + 1 ; else skip ; 
     k := k / 16 ) ) else skip ; )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 5 ;
    var R : int ; R := 100 ;
     OclFile["System.out"].print(countHexadecimal(L, R)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int nextGreater(int N){
    int power_of_2=1,shift_count=0 ;
    while(true){
      if(((N>>shift_count)& 1)% 2==0)break ;
      shift_count++;
      power_of_2=power_of_2*2 ;
    }
    return(N+power_of_2);
  }
  public static void main(String[] a){
    int N=11 ;
    System.out.println("The next number is="+nextGreater(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nextGreater( N : int) : int
  pre: true
  post: true
  activity: (     var power_of1 : int ; power_of1 := 1 ;
    var shift_count : int ; shift_count := 0 ;
     while (true) do (     if ((((N/(2->pow(shift_count)))->oclAsType(long)) & 1) mod 2 = 0) then     break else skip ; 
     shift_count := shift_count + 1 ; 
     power_ofpower_of2 * 2 := power_of2 * 2 ) ; 
     return (N + power_of    while (true) do (     if ((((N/(2->pow(shift_count)))->oclAsType(long)) & 1) mod 2 = 0) then     break else skip ; 
     shift_count := shift_count + 1 ; 
     power_ofpower_of2 * 2 := power_of2 * 2 ) ; 
) );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 11 ;
     OclFile["System.out"].println("The next number is=" + nextGreater(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.lang.reflect.Array ;
import java.util.*;
import static java.lang.System.out ;
public class Solution {
  static MyScanner str=new MyScanner();
  public static void main(String[] args)throws IOException {
    long T=l();
    while(T-->0){
      solve();
    }
  }
  static void solve()throws IOException {
    int n=i(),k=i(),a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=i();
    }
    long res=0 ;
    long cur=a[0];
    for(int i=1 ; i<n ; i++){
      res=Math.max(res,(100L*a[i]-k*cur+k-1)/k);
      cur+=a[i];
    }
    out.println(res);
  }
  public static int i()throws IOException {
    return str.nextInt();
  }
  public static long l()throws IOException {
    return str.nextLong();
  }
  public static double d()throws IOException {
    return str.nextDouble();
  }
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute str : MyScanner := MyScanner.newMyScanner();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : long ; T := l() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := i() ;
    var k : int ; k := i() ;
    var a : Sequence(void) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := i() )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
    var cur : long ; cur := a[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     res := Set{res, (100L * a[i+1] - k * cur + k - 1) / k}->max() ; 
     cur := cur+(a[i+1]) )  ;     i := i + 1 ) ; 
    out.println(res) ; 
 );
  static   operation i() : int
  pre: true
  post: true
  activity: (     return str.nextInt() );
  static   operation l() : long
  pre: true
  post: true
  activity: (     return str.nextLong() );
  static   operation d() : double
  pre: true
  post: true
  activity: (     return str.nextDouble() );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static int[] next(int[] a){
    int n=a.length ;
    int[] cnt=new int[10000];
    for(int i=0 ; i<n ; i++){
      cnt[a[i] ]++;
    }
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=cnt[a[i] ];
    }
    return res ;
  }
  static boolean solve(){
    int n=in.nextInt();
    if(n==0)return false ;
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    int cnt=0 ;
    while(true){
      int[] b=next(a);
      boolean f=true ;
      for(int i=0 ; i<n ; i++){
        if(a[i]!=b[i])f=false ;
      }
      if(f){
        out.println(cnt);
        for(int i=0 ; i<n-1 ; i++){
          out.print(a[i]+" ");
        }
        out.println(a[n-1]);
        break ;
      }
      a=b ;
      cnt++;
    }
    return true ;
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.currentTimeMillis();
    while(solve());
    out.flush();
    long end=System.currentTimeMillis();
    dump((end-start)+"ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation next( a : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() ;
     var cnt : Sequence(int) ; cnt := Integer.subrange(1,10000)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     cnt[a[i+1]+1] := cnt[a[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     res[i+1] := cnt[a[i+1]+1] )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation solve() : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return false else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    while (true) do (     var b : Sequence(int) ; b := next(a) ;
     var f : boolean ; f := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] /= b[i+1]) then     f := false ; else skip )  ;     i := i + 1 ) ; 
    if (f) then (     skip ; 
         var i : int ; i := 0 ; while i < n - 1 do ( (     skip )  ;     i := i + 1 ) ; 
     skip ; 
     break ) else skip ; 
    a := b ; 
    cnt := cnt + 1 ; 
 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := OclDate.getSystemTime() ;
    while (solve()) do  ; 
    skip ; 
    var end : long ; end := OclDate.getSystemTime() ;
    execute dump((end - start) + "ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int N=stdIn.nextInt();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=stdIn.nextInt();
    }
    int count=0 ;
    for(int i=0 ; i<N ; i++){
      if(i==N-1)count++;
      else if(A[i]==A[i+1]);
      else if(A[i]<A[i+1]){
        while(A[i]<=A[i+1]){
          i++;
          if(i==N-1)break ;
        }
        count++;
      }
      else {
        while(A[i]>=A[i+1]){
          i++;
          if(i==N-1)break ;
        }
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := stdIn.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := stdIn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (i = N - 1) then     count := count + 1 ; else     if (A[i+1] = A[i + 1+1]) then  else     if (A[i+1] < A[i + 1+1]) then (     while (A[i+1] <= A[i + 1+1]) do (     i := i + 1 ; 
     if (i = N - 1) then     break else skip ) ; 
     count := count + 1 ) else (     while (A[i+1] >= A[i + 1+1]) do (     i := i + 1 ; 
     if (i = N - 1) then     break else skip ) ; 
     count := count + 1 ) ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import javax.swing.JOptionPane ;
public class Worksheet3 {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int a=s.nextInt();
    int ar[]=new int[a];
    int max=0,min=0 ;
    for(int i=0 ; i<ar.length ; i++)ar[i]=s.nextInt();
    for(int i=0 ; i<ar.length ; i++){
      max=Math.max(ar[i]-ar[0],ar[ar.length-1]-ar[i]);
      if(i==0)min=ar[i+1]-ar[i];
      else if(i==ar.length-1)min=ar[i]-ar[i-1];
      else min=Math.min(ar[i]-ar[i-1],ar[i+1]-ar[i]);
      System.out.println(min+" "+max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Worksheet3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := s.getCurrent()->toInteger() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,a)->collect(0) ;
    var max : int ; max := 0 ;
    var min : int ; min := 0 ;
        var i : int ; i := 0 ; while i < ar->size() do (     ar[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < ar->size() do ( (     max := Set{ar[i+1] - ar[0+1], ar[ar->size() - 1+1] - ar[i+1]}->max() ; 
     if (i = 0) then     min := ar[i + 1+1] - ar[i+1] else     if (i = ar->size() - 1) then     min := ar[i+1] - ar[i - 1+1] else     min := Set{ar[i+1] - ar[i - 1+1], ar[i + 1+1] - ar[i+1]}->min() ; ;  ;  
     OclFile["System.out"].println(min + " " + max) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  static final int INF=0x3f3f3f3f ;
  static final long LNF=0x3f3f3f3f3f3f3f3fL ;
  public static void main(String[] args)throws IOException {
    initReader();
    int t=nextInt();
    for(int i=0 ; i<t ; i++){
      int a=nextInt(),b=nextInt(),max=1,min=INF ;
      for(int j=0 ; j<a ; j++){
        int n=nextInt();
        if(n>max)max=n ;
        if(n<min)min=n ;
      }
      if(max-min<=b*2){
        pw.println(min+b);
      }
      else {
        pw.println(-1);
      }
    }
    pw.close();
  }
  static BufferedReader reader ;
  static StringTokenizer tokenizer ;
  static PrintWriter pw ;
  public static void initReader()throws IOException {
    reader=new BufferedReader(new InputStreamReader(System.in));
    tokenizer=new StringTokenizer("");
    pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  }
  public static boolean hasNext(){
    try {
      while(! tokenizer.hasMoreTokens()){
        tokenizer=new StringTokenizer(reader.readLine());
      }
    }
    catch(Exception e){
      return false ;
    }
    return true ;
  }
  public static String next()throws IOException {
    while(! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  public static String nextLine(){
    try {
      return reader.readLine();
    }
    catch(Exception e){
      return null ;
    }
  }
  public static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public static long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public static char nextChar()throws IOException {
    return next().charAt(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := 0x3f3f3f3f;
  static    attribute LNF : long := 0x3f3f3f3f3f3f3f3fL;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute initReader() ; 
     var t : int ; t := nextInt() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : int ; a := nextInt() ;
    var b : int ; b := nextInt() ;
    var max : int ; max := 1 ;
    var min : int ; min := INF ;
         var j : int ; j := 0 ; while j < a do ( (     var n : int ; n := nextInt() ;
     if (n > max) then     max := n ; else skip ; 
     if (n < min) then     min := n ; else skip )  ;     j := j + 1 ) ; 
     if (max - min <= b * 2) then (     pw.println(min + b) ) else (     pw.println(-1) ) )  ;     i := i + 1 ) ; 
     pw.close() );
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   attribute pw : OclFile;
  static   operation initReader() : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := OclIterator.newOclIterator_String("") ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) );
  static   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     try (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (e : ProgramException) do (     return false )
     return true );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : ProgramException) do (     return null )
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  static final int INF=0x3f3f3f3f ;
  static final long LNF=0x3f3f3f3f3f3f3f3fL ;
  public static void main(String[] args)throws IOException {
    initReader();
    int t=nextInt();
    for(int i=0 ; i<t ; i++){
      int a=nextInt(),b=nextInt(),max=1,min=INF ;
      for(int j=0 ; j<a ; j++){
        int n=nextInt();
        if(n>max)max=n ;
        if(n<min)min=n ;
      }
      if(max-min<=b*2){
        pw.println(min+b);
      }
      else {
        pw.println(-1);
      }
    }
    pw.close();
  }
  static BufferedReader reader ;
  static StringTokenizer tokenizer ;
  static PrintWriter pw ;
  public static void initReader()throws IOException {
    reader=new BufferedReader(new InputStreamReader(System.in));
    tokenizer=new StringTokenizer("");
    pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  }
  public static boolean hasNext(){
    try {
      while(! tokenizer.hasMoreTokens()){
        tokenizer=new StringTokenizer(reader.readLine());
      }
    }
    catch(Exception e){
      return false ;
    }
    return true ;
  }
  public static String next()throws IOException {
    while(! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  public static String nextLine(){
    try {
      return reader.readLine();
    }
    catch(Exception e){
      return null ;
    }
  }
  public static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public static long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public static char nextChar()throws IOException {
    return next().charAt(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := 0x3f3f3f3f;
  static    attribute LNF : long := 0x3f3f3f3f3f3f3f3fL;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute initReader() ; 
     var t : int ; t := nextInt() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : int ; a := nextInt() ;
    var b : int ; b := nextInt() ;
    var max : int ; max := 1 ;
    var min : int ; min := INF ;
         var j : int ; j := 0 ; while j < a do ( (     var n : int ; n := nextInt() ;
     if (n > max) then     max := n ; else skip ; 
     if (n < min) then     min := n ; else skip )  ;     j := j + 1 ) ; 
     if (max - min <= b * 2) then (     pw.println(min + b) ) else (     pw.println(-1) ) )  ;     i := i + 1 ) ; 
     pw.close() );
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   attribute pw : OclFile;
  static   operation initReader() : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := OclIterator.newOclIterator_String("") ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) );
  static   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     try (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (e : ProgramException) do (     return false )
     return true );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : ProgramException) do (     return null )
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  static final int INF=0x3f3f3f3f ;
  static final long LNF=0x3f3f3f3f3f3f3f3fL ;
  public static void main(String[] args)throws IOException {
    initReader();
    int t=nextInt();
    while(t--!=0){
      int n=nextInt();
      int k=nextInt();
      int[] a=new int[n+1];
      for(int i=1 ; i<=n ; i++){
        a[i]=nextInt();
      }
      Arrays.sort(a,1,n+1);
      int p1=a[1]+k ;
      if(Math.abs(p1-a[n])<=k)pw.println(p1);
      else pw.println("-1");
    }
    pw.close();
  }
  static BufferedReader reader ;
  static StringTokenizer tokenizer ;
  static PrintWriter pw ;
  public static void initReader()throws IOException {
    reader=new BufferedReader(new InputStreamReader(System.in));
    tokenizer=new StringTokenizer("");
    pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  }
  public static boolean hasNext(){
    try {
      while(! tokenizer.hasMoreTokens()){
        tokenizer=new StringTokenizer(reader.readLine());
      }
    }
    catch(Exception e){
      return false ;
    }
    return true ;
  }
  public static String next()throws IOException {
    while(! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  public static String nextLine(){
    try {
      return reader.readLine();
    }
    catch(Exception e){
      return null ;
    }
  }
  public static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public static long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public static char nextChar()throws IOException {
    return next().charAt(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := 0x3f3f3f3f;
  static    attribute LNF : long := 0x3f3f3f3f3f3f3f3fL;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute initReader() ; 
     var t : int ; t := nextInt() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := nextInt() ;
     var k : int ; k := nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := nextInt() )  ;     i := i + 1 ) ; 
    a := a.subrange(1,1)^(a.subrange(1+1,n + 1)->sort())^a.subrange(n + 1+1,a.size) ; 
    var p1 : int ; p1 := a[1+1] + k ;
    if (if p1 - a[n+1] < 0 then -(p1 - a[n+1]) else p1 - a[n+1] endif <= k) then     pw.println(p1) else     pw.println("-1") ; ;  
 ) ;  ) ;  
     pw.close() );
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   attribute pw : OclFile;
  static   operation initReader() : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := OclIterator.newOclIterator_String("") ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) );
  static   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     try (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (e : ProgramException) do (     return false )
     return true );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : ProgramException) do (     return null )
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class EqualizePrices {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    while(test-->0){
      int n=sc.nextInt();
      long k=sc.nextLong();
      long[] nums=new long[n];
      long maximumDiff=Long.MIN_VALUE ;
      long minimumDiff=Long.MAX_VALUE ;
      for(int i=0 ; i<n ; i++){
        nums[i]=sc.nextLong();
        maximumDiff=Math.max(maximumDiff,nums[i]);
        minimumDiff=Math.min(minimumDiff,nums[i]);
      }
      if(maximumDiff-minimumDiff>2*k){
        System.out.println("-1");
      }
      else {
        System.out.println(minimumDiff+k);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class EqualizePrices {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : long ; k := sc.getCurrent()->toLong() ;
    var nums : Sequence(long) ; nums := Integer.subrange(1,n)->collect(0) ;
    var maximumDiff : long ; maximumDiff := "-9223372036854775808"->toLong() ;
    var minimumDiff : long ; minimumDiff := "9223372036854775807"->toLong() ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := sc.getCurrent()->toLong() ; 
     maximumDiff := Set{maximumDiff, nums[i+1]}->max() ; 
     minimumDiff := Set{minimumDiff, nums[i+1]}->min() )  ;     i := i + 1 ) ; 
    if (maximumDiff - minimumDiff > 2 * k) then (     OclFile["System.out"].println("-1") ) else (     OclFile["System.out"].println(minimumDiff + k) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int prvs=1 ;
    int current=0 ;
    int m=1 ;
    for(int i=2 ; i<=n ; i++){
      current=(m*4)+prvs ;
      prvs=current ;
      m++;
    }
    System.out.println(prvs);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var prvs : int ; prvs := 1 ;
    var current : int ; current := 0 ;
    var m : int ; m := 1 ;
        var i : int ; i := 2 ; while i <= n do ( (     current := (m * 4) + prvs ; 
     prvs := current ; 
     m := m + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(prvs) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int prvs=1 ;
    int current=0 ;
    int m=1 ;
    for(int i=2 ; i<=n ; i++){
      int temp=current ;
      current=(m*4)+prvs ;
      prvs=current ;
      m++;
    }
    System.out.println(prvs);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var prvs : int ; prvs := 1 ;
    var current : int ; current := 0 ;
    var m : int ; m := 1 ;
        var i : int ; i := 2 ; while i <= n do ( (     var temp : int ; temp := current ;
     current := (m * 4) + prvs ; 
     prvs := current ; 
     m := m + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(prvs) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  static final int INF=0x3f3f3f3f ;
  static final long LNF=0x3f3f3f3f3f3f3f3fL ;
  public static void main(String[] args)throws IOException {
    initReader();
    int[] f=new int[110];
    f[1]=1 ;
    for(int i=2 ; i<=100 ; i++){
      f[i]=f[i-1]+(i-1)*4 ;
    }
    int n=nextInt();
    pw.println(f[n]);
    pw.close();
  }
  static BufferedReader reader ;
  static StringTokenizer tokenizer ;
  static PrintWriter pw ;
  public static void initReader()throws IOException {
    reader=new BufferedReader(new InputStreamReader(System.in));
    tokenizer=new StringTokenizer("");
    pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  }
  public static boolean hasNext(){
    try {
      while(! tokenizer.hasMoreTokens()){
        tokenizer=new StringTokenizer(reader.readLine());
      }
    }
    catch(Exception e){
      return false ;
    }
    return true ;
  }
  public static String next()throws IOException {
    while(! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  public static String nextLine(){
    try {
      return reader.readLine();
    }
    catch(Exception e){
      return null ;
    }
  }
  public static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public static long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public static char nextChar()throws IOException {
    return next().charAt(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := 0x3f3f3f3f;
  static    attribute LNF : long := 0x3f3f3f3f3f3f3f3fL;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute initReader() ; 
     var f : Sequence(int) ; f := Integer.subrange(1,110)->collect(0) ;
    f[1+1] := 1 ; 
        var i : int ; i := 2 ; while i <= 100 do ( (     f[i+1] := f[i - 1+1] + (i - 1) * 4 )  ;     i := i + 1 ) ; 
    var n : int ; n := nextInt() ;
    pw.println(f[n+1]) ; 
    pw.close() ; 
 );
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   attribute pw : OclFile;
  static   operation initReader() : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := OclIterator.newOclIterator_String("") ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) );
  static   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     try (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (e : ProgramException) do (     return false )
     return true );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : ProgramException) do (     return null )
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int calculateCycleOperations(int len){
    int cycle_operations=0 ;
    while(len>0){
      len/=3 ;
++cycle_operations ;
    }
    return--cycle_operations ;
  }
  static int minimumOperations(int p[],int n){
    int[] visited=new int[n+1];
    Arrays.fill(visited,0);
    int ans=0 ;
    for(int i=1 ; i<=n ; i++){
      int ele=p[i];
      if(visited[ele]==0){
        visited[ele]=1 ;
        int len=1 ;
        ele=p[ele];
        while(visited[ele]==0){
          visited[ele]=1 ;
++len ;
          ele=p[ele];
        }
        int operations=calculateCycleOperations(len);
        int num=(int)Math.pow(3,operations);
        if(num!=len){
          return-1 ;
        }
        ans=Math.max(ans,operations);
      }
    }
    return ans ;
  }
  public static void main(String args[]){
    int P[]={
-1,4,6,5,3,2,7,8,9,1 };
      int n=P.length-1 ;
      System.out.println(minimumOperations(P,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculateCycleOperations( len : int) : int
  pre: true
  post: true
  activity: (     var cycle_operations : int ; cycle_operations := 0 ;
     while (len > 0) do (     len := len/(3) ; 
     cycle_operations := cycle_operations + 1 ) ; 
     return (cycle_operations - 1) );
  static   operation minimumOperations( p : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var visited : Sequence(int) ; visited := Integer.subrange(1,n + 1)->collect(0) ;
     visited := visited->collect(0) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var ele : int ; ele := p[i+1] ;
     if (visited[ele+1] = 0) then (     visited[ele+1] := 1 ; 
     var len : int ; len := 1 ;
    ele := p[ele+1] ; 
    while (visited[ele+1] = 0) do (     visited[ele+1] := 1 ; 
     len := len + 1 ; 
     ele := p[ele+1] ) ; 
    var operations : int ; operations := calculateCycleOperations(len) ;
    var num : int ; num := 3->pow(operations)->oclAsType(int) ;
    if (num /= len) then (     return -1 ) else skip ; 
    ans := Set{ans, operations}->max() ; 
 ) else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var P : Sequence(int) ; P := Sequence{-1,4,6,5,3,2,7,8,9,1} ;
     var n : int ; n := P->size() - 1 ;
     OclFile["System.out"].println(minimumOperations(P, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int N=s.nextInt();
    int x=1 ;
    while(N>=x){
      x=x*2 ;
    }
    System.out.println(x/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := s.getCurrent()->toInteger() ;
    var x : int ; x := 1 ;
    while (N >= x) do (     x := x * 2 ) ; 
    OclFile["System.out"].println(x / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    FastScanner sc=new FastScanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int input=sc.nextInt();
    int ans=1 ;
    while(input>=ans*2){
      ans*=2 ;
    }
    out.println(ans);
    out.flush();
  }
  static class FastScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public FastScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
      tokenizer=null ;
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          return reader.readLine();
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken("\n");
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var input : int ; input := sc.nextInt() ;
    var ans : int ; ans := 1 ;
    while (input >= ans * 2) do (     ans := ans*(2) ) ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.nextToken("\n") );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Filling_Shapes {
  static Scanner sc=new Scanner(System.in);
  static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args){
    int n=sc.nextInt();
    System.out.println(find(n));
  }
  public static int find(int n){
    if(n % 2==1)return 0 ;
    int arr[]=new int[60+1];
    arr[1]=0 ;
    arr[2]=2 ;
    for(int i=3 ; i<=n ; i++){
      arr[i]=arr[i-2]*2 ;
    }
    return arr[n];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Filling_Shapes {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(find(n)) );
  static   operation find( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 = 1) then     return 0 else skip ; 
     var arr : Sequence(int) ; arr := Integer.subrange(1,60 + 1)->collect(0) ;
    arr[1+1] := 0 ; 
    arr[2+1] := 2 ; 
        var i : int ; i := 3 ; while i <= n do ( (     arr[i+1] := arr[i - 2+1] * 2 )  ;     i := i + 1 ) ; 
    return arr[n+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.math.BigDecimal ;
public class Main {
  BigDecimal[][] memo ;
  BigDecimal one=new BigDecimal(1);
  BigDecimal zero=new BigDecimal(0);
  Main(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt(),s ;
      if(n==0){
        break ;
      }
      int[] a=new int[n];
      for(int i=0 ; i<n-1 ; i++){
        a[i]=sc.nextInt();
      }
      s=sc.nextInt();
      BigDecimal c=zero ;
      memo=new BigDecimal[21][];
      for(int i=0 ; i<21 ; i++){
        memo[i]=new BigDecimal[n];
        for(int j=0 ; j<n ; j++){
          memo[i][j]=new BigDecimal(-1);
        }
      }
      c=func(a,n-1,s,1,a[0]);
      System.out.println(c.toString());
    }
  }
  BigDecimal func(int[] a,int n,int s,int p,int t){
    if(p==n){
      if(t==s){
        return one ;
      }
      else {
        return zero ;
      }
    }
    if(!(new BigDecimal(-1)).equals(memo[t][p])){
      return memo[t][p];
    }
    BigDecimal bd=new BigDecimal("0");
    if(t-a[p]>=0){
      bd=bd.add(func(a,n,s,p+1,t-a[p]));
    }
    if(t+a[p]<=20){
      bd=bd.add(func(a,n,s,p+1,t+a[p]));
    }
    memo[t][p]=bd ;
    return bd ;
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute memo : Sequence(Sequence(double));
   attribute one : double := double(1);
   attribute zero : double := double(0);
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : int ;
     if (n = 0) then (     break ) else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    s := sc.getCurrent()->toInteger() ; 
    var c : double ; c := zero ;
    memo := Integer.subrange(1,21)->collect(Sequence{}) ; 
        var i : int ; i := 0 ; while i < 21 do ( (     memo[i+1] := Integer.subrange(1,n)->collect(null) ; 
         var j : int ; j := 0 ; while j < n do ( (     memo[i+1][j+1] := double(-1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    c := func(a, n - 1, s, 1, a[0+1]) ; 
    OclFile["System.out"].println(c+"") ; 
 ) );
   operation func( a : Sequence(int), n : int, s : int, p : int, t : int) : double
  pre: true
  post: true
  activity: (     if (p = n) then (     if (t = s) then (     return one ) else (     return zero ) ) else skip ; 
     if (not((double(-1)) = memo[t+1][p+1])) then (     return memo[t+1][p+1] ) else skip ; 
    var bd : double ; bd := double("0") ;
    if (t - a[p+1] >= 0) then (     bd := bd->excludes(func(a, n, s, p + 1, t - a[p+1])) ) else skip ; 
    if (t + a[p+1] <= 20) then (     bd := bd->excludes(func(a, n, s, p + 1, t + a[p+1])) ) else skip ; 
    memo[t+1][p+1] := bd ; 
    return bd 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.Scanner ;
import java.util.TreeMap ;
import java.util.ArrayList ;
public class Main {
  public static Scanner sc ;
  public static ArrayList<Integer>list ;
  public static int number ;
  public static void main(String[] args)throws Exception {
    sc=new Scanner(System.in);
    number=0 ;
    while(sc.hasNext()){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] ary=new int[n];
      int[] tmp=new int[n];
      for(int i=0 ; i<n ; i++){
        ary[i]=sc.nextInt();
      }
      calc(ary,n);
    }
  }
  public static void calc(int[] a,int n){
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++){
      int num=a[i];
      int res=0 ;
      for(int j=0 ; j<n ; j++){
        if(num==a[j]){
          res++;
        }
      }
      b[i]=res ;
    }
    boolean bn=true ;
    for(int i=0 ; i<n ; i++){
      if(a[i]!=b[i]){
        bn=false ;
      }
    }
    if(bn){
      StringBuilder sb=new StringBuilder();
      for(int i=0 ; i<n ; i++){
        sb.append(a[i]).append(" ");
      }
      sb.deleteCharAt(sb.length()-1);
      System.out.println(number);
      System.out.println(sb.toString());
      number=0 ;
    }
    else {
      number++;
      calc(b,n);
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile;
  static   attribute list : Sequence(int);
  static   attribute number : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     number := 0 ; 
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var ary : Sequence(int) ; ary := Integer.subrange(1,n)->collect(0) ;
    var tmp : Sequence(int) ; tmp := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ary[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute calc(ary, n) ; 
 ) );
  static   operation calc( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := a[i+1] ;
     var res : int ; res := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (num = a[j+1]) then (     res := res + 1 ) else skip )  ;     j := j + 1 ) ; 
     b[i+1] := res )  ;     i := i + 1 ) ; 
    var bn : boolean ; bn := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] /= b[i+1]) then (     bn := false ) else skip )  ;     i := i + 1 ) ; 
    if (bn) then (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < n do ( (     sb := sb + StringLib.newString(a[i+1]) + StringLib.newString(" ") )  ;     i := i + 1 ) ; 
    sb := sb->excludingAt(sb->size() - 1+1) ; 
    OclFile["System.out"].println(number) ; 
    OclFile["System.out"].println(sb+"") ; 
    number := 0 ; 
 ) else (     number := number + 1 ; 
     execute calc(b, n) ) ;  
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    System.out.printf("%d\n",Integer.highestOneBit(sc.nextInt()));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].printf("%d\n", highestOneBit(sc.getCurrent()->toInteger())) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int c=0,n=sc.nextInt();
    while(n>1){
      n>>=1 ;
++c ;
    }
    System.out.println(1<<c);
  }
  public static void main(String[] a){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : int ; c := 0 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
     while (n > 1) do (     n := n/(2->pow(1)) ; 
     c := c + 1 ) ; 
     OclFile["System.out"].println((1*(2->pow(c)))->oclAsType(long)) );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int out=2 ;
    if(n==out){
      System.out.println(2);
      return ;
    }
    while(out<=n){
      out*=2 ;
    }
    System.out.println(out/2);
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var out : int ; out := 2 ;
    if (n = out) then (     OclFile["System.out"].println(2) ; 
     return ) else skip ; 
    while (out <= n) do (     out := out*(2) ) ; 
    OclFile["System.out"].println(out / 2) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int merge(int arr[],int temp[],int left,int mid,int right){
    int inv_count=0 ;
    int i=left ;
    int j=mid ;
    int k=left ;
    while((i<=mid-1)&&(j<=right)){
      if(arr[i]<=arr[j]){
        temp[k++]=arr[i++];
      }
      else {
        temp[k++]=arr[j++];
        inv_count=inv_count+(mid-i);
      }
    }
    while(i<=mid-1){
      temp[k++]=arr[i++];
    }
    while(j<=right){
      temp[k++]=arr[j++];
    }
    for(i=left ; i<=right ; i++){
      arr[i]=temp[i];
    }
    return inv_count ;
  }
  static int _mergeSort(int arr[],int temp[],int left,int right){
    int mid,inv_count=0 ;
    if(right>left){
      mid=(right+left)/2 ;
      inv_count=_mergeSort(arr,temp,left,mid);
      inv_count+=_mergeSort(arr,temp,mid+1,right);
      inv_count+=merge(arr,temp,left,mid+1,right);
    }
    return inv_count ;
  }
  static int mergeSort(int arr[],int array_size){
    int[] temp=new int[array_size];
    return _mergeSort(arr,temp,0,array_size-1);
  }
  static int minSwapToReachArr(int arr[],int N){
    for(int i=0 ; i<N ; i++){
      if((arr[i]-1)-i>2){
        return-1 ;
      }
    }
    int numOfInversion=mergeSort(arr,N);
    return numOfInversion ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,5,3,4 };
      int N=arr.length ;
      int res=minSwapToReachArr(arr,N);
      System.out.println(res==-1 ? "Not Possible\n" : res);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation merge( arr : Sequence(int), temp : Sequence(int), left : int, mid : int, right : int) : int
  pre: true
  post: true
  activity: (     var inv_count : int ; inv_count := 0 ;
     var i : int ; i := left ;
    var j : int ; j := mid ;
    var k : int ; k := left ;
    while ((i <= mid - 1) & (j <= right)) do (     if (arr[i+1] <= arr[j+1]) then (       temp[k+1] := arr[i+1]  ; k := k + 1  ; i := i + 1 ) else (       temp[k+1] := arr[j+1]  ; k := k + 1  ; j := j + 1 ; 
     inv_count := inv_count + (mid - i) ) ) ; 
    while (i <= mid - 1) do (       temp[k+1] := arr[i+1]  ; k := k + 1  ; i := i + 1 ) ; 
    while (j <= right) do (       temp[k+1] := arr[j+1]  ; k := k + 1  ; j := j + 1 ) ; 
        i := left ; while i <= right do ( (     arr[i+1] := temp[i+1] )  ;     i := i + 1 ) ; 
    return inv_count 
 );
  static   operation _mergeSort( arr : Sequence(int), temp : Sequence(int), left : int, right : int) : int
  pre: true
  post: true
  activity: (     var mid : int ;
    var inv_count : int ; inv_count := 0 ;
     if (right > left) then (     mid := (right + left) / 2 ; 
     inv_count := _mergeSort(arr, temp, left, mid) ; 
     inv_count := inv_count+(_mergeSort(arr, temp, mid + 1, right)) ; 
     inv_count := inv_count+(merge(arr, temp, left, mid + 1, right)) ) else skip ; 
     return inv_count );
  static   operation mergeSort( arr : Sequence(int), array_size : int) : int
  pre: true
  post: true
  activity: (     var temp : Sequence(int) ; temp := Integer.subrange(1,array_size)->collect(0) ;
     return _mergeSort(arr, temp, 0, array_size - 1) );
  static   operation minSwapToReachArr( arr : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do ( (     if ((arr[i+1] - 1) - i > 2) then (     return -1 ) else skip )  ;     i := i + 1 ) ; 
     var numOfInversion : int ; numOfInversion := mergeSort(arr, N) ;
     return numOfInversion );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,5,3,4} ;
     var N : int ; N := arr->size() ;
     var res : int ; res := minSwapToReachArr(arr, N) ;
     OclFile["System.out"].println(if res = -1 then "Not Possible\n" else res endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=1 ; i<n ; i++){
      a[sc.nextInt()-1]+=1 ;
    }
    for(int i=0 ; i<n ; i++){
      System.out.println(a[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 1 ; while i < n do ( (     a[sc.getCurrent()->toInteger() - 1+1] := a[sc.getCurrent()->toInteger() - 1+1]+(1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(a[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  final static long MOD=1000000007 ;
  public static String[] Ws=null ;
  public static int wsIndx=0 ;
  public static BufferedReader in=null ;
  public static void main(String[] args)throws Exception {
    int N=nextInt();
    int[] ans=new int[N+1];
    Arrays.fill(ans,0);
    for(int i=2 ; i<=N ; i++){
      ans[nextInt()]++;
    }
    for(int i=1 ; i<ans.length ; i++){
      System.out.println(ans[i]);
    }
  }
  public static void check()throws Exception {
    if(in==null){
      in=new BufferedReader(new InputStreamReader(System.in));
    }
    if(Ws==null || Ws.length<=wsIndx){
      Ws=in.readLine().split(" ");
      wsIndx=0 ;
    }
  }
  public static int nextInt()throws Exception {
    check();
    return Integer.parseInt(Ws[wsIndx++]);
  }
  public static long nextLong()throws Exception {
    check();
    return Long.parseLong(Ws[wsIndx++]);
  }
  public static String nextString()throws Exception {
    check();
    return Ws[wsIndx++];
  }
  public static int[] nextInts()throws Exception {
    check();
    int[] tmp=new int[Ws.length];
    for(int i=0 ; i<tmp.length ; i++){
      tmp[i]=Integer.parseInt(Ws[i]);
    }
    wsIndx=Ws.length ;
    return tmp ;
  }
  public static long[] nextLongs()throws Exception {
    check();
    long[] tmp=new long[Ws.length];
    for(int i=0 ; i<tmp.length ; i++){
      tmp[i]=Long.parseLong(Ws[i]);
    }
    wsIndx=Ws.length ;
    return tmp ;
  }
  public static String[] nextStrings()throws Exception {
    check();
    wsIndx=Ws.length ;
    return Ws ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : long := 1000000007;
  static   attribute Ws : Sequence(String) := null;
  static   attribute wsIndx : int := 0;
  static   attribute in : OclFile := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := nextInt() ;
     var ans : Sequence(int) ; ans := Integer.subrange(1,N + 1)->collect(0) ;
    ans := ans->collect(0) ; 
        var i : int ; i := 2 ; while i <= N do ( (     ans[nextInt()+1] := ans[nextInt()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < ans->size() do ( (     OclFile["System.out"].println(ans[i+1]) )  ;     i := i + 1 ) ; 
 );
  static   operation check() : void
  pre: true
  post: true
  activity: (     if (in = null) then (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ) else skip ; 
     if (Ws = null or Ws->size() <= wsIndx) then (     Ws := in.readLine()->split(" ") ; 
     wsIndx := 0 ) else skip );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     execute check() ; 
     return (Ws[wsIndx+1])->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     execute check() ; 
     return (Ws[wsIndx+1])->toLong() );
  static   operation nextString() : String
  pre: true
  post: true
  activity: (     execute check() ; 
     return Ws[wsIndx+1] );
  static   operation nextInts() : Sequence(int)
  pre: true
  post: true
  activity: (     execute check() ; 
     var tmp : Sequence(int) ; tmp := Integer.subrange(1,Ws->size())->collect(0) ;
        var i : int ; i := 0 ; while i < tmp->size() do ( (     tmp[i+1] := (Ws[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    wsIndx := Ws->size() ; 
    return tmp 
 );
  static   operation nextLongs() : Sequence(long)
  pre: true
  post: true
  activity: (     execute check() ; 
     var tmp : Sequence(long) ; tmp := Integer.subrange(1,Ws->size())->collect(0) ;
        var i : int ; i := 0 ; while i < tmp->size() do ( (     tmp[i+1] := (Ws[i+1])->toLong() )  ;     i := i + 1 ) ; 
    wsIndx := Ws->size() ; 
    return tmp 
 );
  static   operation nextStrings() : Sequence(String)
  pre: true
  post: true
  activity: (     execute check() ; 
     wsIndx := Ws->size() ; 
     return Ws );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int[] A=new int[N+1];
    for(int i=2 ; i<=N ; i++){
      A[i]=scan.nextInt();
    }
    int[] answer=new int[N+1];
    for(int i=1 ; i<=N ; i++){
      answer[A[i] ]+=1 ;
    }
    for(int i=1 ; i<=N ; i++){
      System.out.println(answer[i]);
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 2 ; while i <= N do ( (     A[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var answer : Sequence(int) ; answer := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do ( (     answer[A[i+1]+1] := answer[A[i+1]+1]+(1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (     OclFile["System.out"].println(answer[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(final String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int n=scanner.nextInt();
    final int[] array=new int[n+1];
    IntStream.rangeClosed(2,n).mapToObj(i->scanner.nextInt()).forEach(i->array[i]++);
    for(int i=1 ; i<=n ; i++){
      System.out.println(array[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,n + 1)->collect(0) ;
    for i : Integer.subrange(2, n).mapToObj(lambda i : OclAny in scanner.getCurrent()->toInteger()) do
    (    array[i+1] := array[i+1] + 1) ; 
        var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].println(array[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    if(n % 2==0){
      System.out.println((int)Math.pow(2,n/2));
    }
    else {
      System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (     OclFile["System.out"].println(2->pow(n / 2)->oclAsType(int)) ) else (     OclFile["System.out"].println(0) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(bf.readLine());
    int[] ls=Arrays.stream(bf.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    int[] dic=new int[n];
    for(int i=0 ; i<n ; i++)dic[i]=0 ;
    for(int i=0 ; i<n-1 ; i++){
      dic[ls[i]-1]++;
    }
    for(int i=0 ; i<n ; i++){
      System.out.println(dic[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (bf.readLine())->toInteger() ;
    var ls : Sequence(int) ; ls := stream(bf.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var dic : Sequence(int) ; dic := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     dic[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     dic[ls[i+1] - 1+1] := dic[ls[i+1] - 1+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(dic[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static void main(String[] args){
    int arr[]={
      4,2,12,13,5,19 };
      int n=arr.length ;
      int k=3 ;
      primeSumAndProduct(arr,n,k);
    }
    static boolean[] SieveOfEratosthenes(int max_val){
      boolean[] prime=new boolean[max_val+1];
      for(int i=0 ; i<=max_val ; i++)prime[i]=true ;
      for(int p=2 ; p*p<=max_val ; p++){
        if(prime[p]==true){
          for(int i=p*2 ; i<=max_val ; i+=p)prime[i]=false ;
        }
      }
      return prime ;
    }
    static void primeSumAndProduct(int arr[],int n,int k){
      int max_val=0 ;
      for(int i=0 ; i<n ; i++)max_val=Math.max(max_val,arr[i]);
      boolean[] prime=SieveOfEratosthenes(max_val);
      prime[0]=false ;
      prime[1]=false ;
      PriorityQueue<Integer>maxHeap=new PriorityQueue<Integer>(Collections.reverseOrder());
      PriorityQueue<Integer>minHeap=new PriorityQueue<Integer>();
      for(int i=0 ; i<n ; i++)if(prime[arr[i] ]){
        minHeap.add(arr[i]);
        maxHeap.add(arr[i]);
      }
      long minProduct=1,maxProduct=1,minSum=0,maxSum=0 ;
      while(k>0){
        k--;
        minProduct*=minHeap.peek();
        maxProduct*=maxHeap.peek();
        minSum+=minHeap.peek();
        maxSum+=maxHeap.peek();
        minHeap.remove();
        maxHeap.remove();
      }
      System.out.println("Sum of k-minimum prime numbers is "+minSum);
      System.out.println("Sum of k-maximum prime numbers is "+maxSum);
      System.out.println("Product of k-minimum prime numbers is "+minProduct);
      System.out.println("Product of k-maximum prime numbers is "+maxProduct);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,2,12,13,5,19} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     execute primeSumAndProduct(arr, n, k) );
  static   operation SieveOfEratosthenes( max_val : int) : Sequence(boolean)
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,max_val + 1)->collect(false) ;
         var i : int ; i := 0 ; while i <= max_val do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
         var p : int ; p := 2 ; while p * p <= max_val do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= max_val do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
     return prime );
  static   operation primeSumAndProduct( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var max_val : int ; max_val := 0 ;
         var i : int ; i := 0 ; while i < n do (     max_val := Set{max_val, arr[i+1]}->max() ;  ;     i := i + 1 ) ; 
    var prime : Sequence(boolean) ; prime := SieveOfEratosthenes(max_val) ;
    prime[0+1] := false ; 
    prime[1+1] := false ; 
    var maxHeap : Sequence(int) ; maxHeap := Sequence{}->union(reverseOrder()) ;
    var minHeap : Sequence(int) ; minHeap := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     if (prime[arr[i+1]+1]) then (     minHeap := minHeap->including(arr[i+1]) ; 
     maxHeap := maxHeap->including(arr[i+1]) ) else skip ;  ;     i := i + 1 ) ; 
    var minProduct : long ; minProduct := 1 ;
    var maxProduct : long ; maxProduct := 1 ;
    var minSum : long ; minSum := 0 ;
    var maxSum : long ; maxSum := 0 ;
    while (k > 0) do (     k := k - 1 ; 
     minProduct := minProduct*(minHeap->min()) ; 
    maxProduct := maxProduct*(maxHeap->min()) ; 
    minSum := minSum+(minHeap->min()) ; 
    maxSum := maxSum+(maxHeap->min()) ; 
    minHeap := minHeap.remove() ; 
    maxHeap := maxHeap.remove() ; 
 ) ; 
    OclFile["System.out"].println("Sum of k-minimum prime numbers is " + minSum) ; 
    OclFile["System.out"].println("Sum of k-maximum prime numbers is " + maxSum) ; 
    OclFile["System.out"].println("Product of k-minimum prime numbers is " + minProduct) ; 
    OclFile["System.out"].println("Product of k-maximum prime numbers is " + maxProduct) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while(!(line=br.readLine()).equals("0")){
      int n=Integer.parseInt(line);
      int[] prog,freq ;
      prog=new int[n];
      freq=new int[n];
      line=br.readLine();
      StringTokenizer st=new StringTokenizer(line);
      for(int i=0 ; i<n ; i++){
        prog[i]=Integer.parseInt(st.nextToken());
      }
      int op=0 ;
      while(true){
        boolean[] chk=new boolean[n];
        for(int i=0 ; i<n ; i++){
          if(! chk[i]){
            int f=1,t=1 ;
            int[] idx=new int[n];
            chk[i]=true ;
            idx[0]=i ;
            for(int j=0 ; j<n ; j++){
              if(! chk[j] && prog[i]==prog[j]){
                chk[j]=true ;
                f++;
                idx[t]=j ;
                t++;
              }
            }
            for(int j=0 ; j<t ; j++){
              freq[idx[j] ]=f ;
            }
          }
        }
        if(! Arrays.equals(prog,freq)){
          prog=Arrays.copyOf(freq,n);
          op++;
        }
        else {
          prog=freq ;
          break ;
        }
      }
      System.out.println(op);
      for(int i=0 ; i<n ; i++){
        if(i!=n-1){
          System.out.print(prog[i]+" ");
        }
        else System.out.println(prog[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
     while (not((line) = "0")) do (     var n : int ; n := (line)->toInteger() ;
     var prog : Sequence(int) ;
    var freq : Sequence(int) ;
    prog := Integer.subrange(1,n)->collect(0) ; 
    freq := Integer.subrange(1,n)->collect(0) ; 
    line := br.readLine() ; 
    var st : OclIterator ; st := OclIterator.newOclIterator_String(line) ;
        var i : int ; i := 0 ; while i < n do ( (     prog[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    var op : int ; op := 0 ;
    while (true) do (     var chk : Sequence(boolean) ; chk := Integer.subrange(1,n)->collect(false) ;
         var i : int ; i := 0 ; while i < n do ( (     if (not(chk[i+1])) then (     var f : int ; f := 1 ;
    var t : int ; t := 1 ;
     var idx : Sequence(int) ; idx := Integer.subrange(1,n)->collect(0) ;
    chk[i+1] := true ; 
    idx[0+1] := i ; 
        var j : int ; j := 0 ; while j < n do ( (     if (not(chk[j+1]) & prog[i+1] = prog[j+1]) then (     chk[j+1] := true ; 
     f := f + 1 ; 
     idx[t+1] := j ; 
     t := t + 1 ) else skip )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < t do ( (     freq[idx[j+1]+1] := f )  ;     j := j + 1 ) ; 
 ) else skip )  ;     i := i + 1 ) ; 
     if (not(prog = freq)) then (     prog := freq.subrange(1,n) ; 
     op := op + 1 ) else (     prog := freq ; 
     break ) ) ; 
    OclFile["System.out"].println(op) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i /= (n)->char2byte() - 1) then (     OclFile["System.out"].print(prog[i+1] + " ") ) else     OclFile["System.out"].println(prog[i+1]) ; )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class YES {
  public static void main(String[] args){
    Scanner o=new Scanner(System.in);
    int t=o.nextInt();
    while(t-->0){
      String s=o.next();
      System.out.println(s.equalsIgnoreCase("YES")? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class YES {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : OclFile ; o := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := o.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : String ; s := o.getCurrent() ;
     OclFile["System.out"].println(if s->equalsIgnoreCase("YES") then "YES" else "NO" endif) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Tes {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String[] yes=new String[n];
    String[] yes1=new String[n];
    for(int i=0 ; i<n ; i++){
      yes[i]=sc.next();
      yes1[i]=yes[i] .toLowerCase();
      if(yes1[i] .equals("yes")){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Tes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var yes : Sequence(String) ; yes := Integer.subrange(1,n)->collect(null) ;
    var yes1 : Sequence(String) ; yes1 := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     yes[i+1] := sc.getCurrent() ; 
     yes1[i+1] := yes[i+1]->toLowerCase() ; 
     if (yes1[i+1] = "yes") then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class YES_or_YES {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testcase=sc.nextInt();
    String yes="yes" ;
    for(int i=0 ; i<testcase ; i++){
      String str=sc.next();
      if(str.toLowerCase().compareTo(yes)==0)System.out.print("YES");
      else System.out.print("NO");
      if(i<testcase-1)System.out.println();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class YES_or_YES {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testcase : int ; testcase := sc.getCurrent()->toInteger() ;
    var yes : String ; yes := "yes" ;
        var i : int ; i := 0 ; while i < testcase do ( (     var str : String ; str := sc.getCurrent() ;
     if (str->toLowerCase()->compareTo(yes) = 0) then     OclFile["System.out"].print("YES") else     OclFile["System.out"].print("NO") ; ;  
     if (i < testcase - 1) then     OclFile["System.out"].println() ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      String s=sc.next();
      if((s.charAt(0)=='y' || s.charAt(0)=='Y')&&(s.charAt(1)=='e' || s.charAt(1)=='E')&&(s.charAt(2)=='s' || s.charAt(2)=='S')){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var s : String ; s := sc.getCurrent() ;
     if ((s->at(0+1) = 'y' or s->at(0+1) = 'Y') & (s->at(1+1) = 'e' or s->at(1+1) = 'E') & (s->at(2+1) = 's' or s->at(2+1) = 'S')) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    String text=scanner.nextLine();
    while(t--!=0){
      text=scanner.nextLine();
      if(text.toLowerCase().equals("yes")){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
     var text : String ; text := scanner.nextLine() ;
         while (t /= 0) do (    skip ; (     text := scanner.nextLine() ; 
     if (text->toLowerCase() = "yes") then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Arrays ;
import java.util.Locale ;
import java.util.StringTokenizer ;
public class A {
  BufferedReader in ;
  StringTokenizer str ;
  PrintWriter out ;
  String SK ;
  String next()throws IOException {
    while((str==null)||(! str.hasMoreTokens())){
      SK=in.readLine();
      if(SK==null)return null ;
      str=new StringTokenizer(SK);
    }
    return str.nextToken();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  class Sob implements Comparable<Sob>{
    int t ;
    int p ;
    int num ;
    public int compareTo(Sob o){
      return o.p*t-p*o.t ;
    }
  }
  void solve()throws IOException {
    int n=nextInt();
    Sob[] a=new Sob[n];
    for(int i=0 ; i<n ; i++){
      a[i]=new Sob();
      a[i] .num=i ;
    }
    for(int i=0 ; i<n ; i++){
      a[i] .t=nextInt();
    }
    for(int i=0 ; i<n ; i++){
      a[i] .p=nextInt();
    }
    Arrays.sort(a);
    for(int i=0 ; i<n ; i++){
      out.print(" "+a[i] .num);
    }
    out.println();
  }
  void run()throws IOException {
    in=new BufferedReader(new FileReader("input.txt"));
    out=new PrintWriter("output.txt");
    int t=nextInt();
    for(int i=0 ; i<t ; i++){
      out.print("Case #"+(i+1)+":");
      solve();
    }
    out.close();
  }
  public static void main(String[] args)throws IOException {
    new A().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   attribute in : OclFile;
   attribute str : OclIterator;
   attribute out : OclFile;
   attribute SK : String;
   operation next() : String
  pre: true
  post: true
  activity: (     while ((str = null) or (not(str.hasNext()))) do (     SK := in.readLine() ; 
     if (SK = null) then     return null else skip ; 
     str := OclIterator.newOclIterator_String(SK) ) ; 
     return str.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
 class Sob implements Comparable<Sob> {
   attribute t : int;
   attribute p : int;
   attribute num : int;
   operation compareTo( o : Sob) : int
  pre: true
  post: true
  activity: (     return o.p * t - p * o.t );
}
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var a : Sequence(Sob) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := Sob.newSob() ; 
     a[i+1].num := i )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1].t := nextInt() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1].p := nextInt() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ; 
    var t : int ; t := nextInt() ;
        var i : int ; i := 0 ; while i < t do ( (     skip ; 
     execute solve() )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     A.newA().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    double tmp1=sc.nextDouble();
    double tmp2=sc.nextDouble();
    double h=tmp1/6.*Math.PI+tmp2/30.*Math.PI/12.;
    double m=tmp2/30.*Math.PI+tmp1/6.*Math.PI*12.;
    double rad=h-m ;
    double res=Math.sqrt(Math.pow(a,2)+Math.pow(b,2)-(2.*a*b*Math.cos(rad)));
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var tmp1 : double ; tmp1 := sc.getCurrent()->toReal() ;
    var tmp2 : double ; tmp2 := sc.getCurrent()->toReal() ;
    var h : double ; h := tmp1 / 6. * 3.141592653589793 + tmp2 / 30. * 3.141592653589793 / 12. ;
    var m : double ; m := tmp2 / 30. * 3.141592653589793 + tmp1 / 6. * 3.141592653589793 * 12. ;
    var rad : double ; rad := h - m ;
    var res : double ; res := (a->pow(2) + b->pow(2) - (2. * a * b * (rad)->cos()))->sqrt() ;
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
import java.awt.*;
public class A {
  public static Comparator<Point>cmp=new Comparator<Point>(){
    public int compare(Point a,Point b){
      if(a.y>b.y)return-1 ;
      if(a.y<b.y)return 1 ;
      return a.x-b.x ;
    }
  };
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int T=scan.nextInt();
    for(int ca=1 ; ca<=T ; ca++){
      int n=scan.nextInt();
      for(int i=0 ; i<n ; i++)scan.nextInt();
      Point[] a=new Point[n];
      for(int i=0 ; i<n ; i++)a[i]=new Point(i,scan.nextInt());
      Arrays.sort(a,cmp);
      System.out.print("Case #"+ca+":");
      for(int i=0 ; i<n ; i++)System.out.print(" "+a[i] .x);
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute cmp : Function(<Point>,(<Point>,boolean)) := OclComparator<Point>.newOclComparator();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := scan.getCurrent()->toInteger() ;
         var ca : int ; ca := 1 ; while ca <= T do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do (     skip ;  ;     i := i + 1 ) ; 
    var a : Sequence(Point) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := Point.newPoint(i, scan.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    a := OclComparator.sortWith(a, cmp) ; 
    OclFile["System.out"].print("Case #" + ca + ":") ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(" " + a[i+1].x) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     ca := ca + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main implements Runnable {
  public static void main(String[] args)throws IOException {
    new Thread(new Main()).start();
  }
  public void run(){
    try {
      run1();
    }
    catch(IOException e){
      throw new RuntimeException();
    }
  }
  public void run1()throws IOException {
    Scanner sc=new Scanner(new FileReader("input.txt"));
    PrintWriter pw=new PrintWriter(new FileWriter("output.txt"));
    int tN=sc.nextInt();
    sc.nextLine();
    for(int tn=0 ; tn<tN ; tn++){
      int n=sc.nextInt();
      int[] p=new int[n];
      int[] len=new int[n];
      for(int i=0 ; i<n ; i++){
        p[i]=sc.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        len[i]=sc.nextInt();
      }
      boolean[] oppa=new boolean[n];
      pw.print("Case #"+(tn+1)+":");
      c : for(int i=0 ;
      i<n ;
      i++){
        int be=-1 ;
        for(int j=0 ; j<n ; j++){
          if(! oppa[j]){
            if(be==-1 || len[j]*p[be]>len[be]*p[j]){
              be=j ;
            }
          }
        }
        oppa[be]=true ;
        pw.print(" "+be);
      }
      pw.println();
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(Main.newMain()).start() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     execute run1() )   catch (e : IOException) do (     error ProgramException() )
 );
   operation run1() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt"))) ;
    var tN : int ; tN := sc.getCurrent()->toInteger() ;
    skip ; 
        var tn : int ; tn := 0 ; while tn < tN do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    var len : Sequence(int) ; len := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     len[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var oppa : Sequence(boolean) ; oppa := Integer.subrange(1,n)->collect(false) ;
    skip ; 
        var i : int ; i := 0 ; while i < n do ( (     var be : int ; be := -1 ;
         var j : int ; j := 0 ; while j < n do ( (     if (not(oppa[j+1])) then (     if (be = -1 or len[j+1] * p[be+1] > len[be+1] * p[j+1]) then (     be := j ) else skip ) else skip )  ;     j := j + 1 ) ; 
     oppa[be+1] := true ; 
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     tn := tn + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  private Scanner sc ;
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    sc=new Scanner(System.in);
    String line=sc.nextLine();
    while(line.equals("0")==false){
      int num=Integer.parseInt(line);
      String[] nico=sc.nextLine().split(" ");
      int[] a=new int[num];
      for(int i=0 ; i<num ; i++){
        a[i]=Integer.parseInt(nico[i]);
      }
      operation(a,0);
      line=sc.nextLine();
    }
  }
  private void operation(int[] a,int n){
    int[] b=new int[a.length];
    HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();
    for(int i=0 ; i<a.length ; i++){
      if(map.containsKey(a[i])){
        map.put(a[i],map.get(a[i])+1);
      }
      else {
        map.put(a[i],1);
      }
    }
    for(int i=0 ; i<b.length ; i++){
      b[i]=map.get(a[i]);
    }
    boolean flag=true ;
    for(int i=0 ; i<b.length ; i++){
      if(a[i]!=b[i]){
        flag=false ;
        break ;
      }
    }
    if(flag==true){
      System.out.println(n);
      for(int i=0 ; i<b.length ; i++){
        System.out.print(b[i]);
        if(i<(b.length-1))System.out.print(" ");
      }
      System.out.println();
    }
    else {
      operation(b,(n+1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var line : String ; line := sc.nextLine() ;
     while (line = "0" = false) do (     var num : int ; num := (line)->toInteger() ;
     var nico : Sequence(String) ; nico := sc.nextLine()->split(" ") ;
    var a : Sequence(int) ; a := Integer.subrange(1,num)->collect(0) ;
        var i : int ; i := 0 ; while i < num do ( (     a[i+1] := (nico[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    execute operation(a, 0) ; 
    line := sc.nextLine() ; 
 ) );
   operation operation( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var b : Sequence(int) ; b := Integer.subrange(1,a->size())->collect(0) ;
     var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < a->size() do ( (     if (map->keys()->includes(a[i+1])) then (     map := map->union(Map{a[i+1] |-> map->at(a[i+1]) + 1}) ) else (     map := map->union(Map{a[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < b->size() do ( (     b[i+1] := map->at(a[i+1]) )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < b->size() do ( (     if (a[i+1] /= b[i+1]) then (     flag := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = true) then (     OclFile["System.out"].println(n) ; 
         var i : int ; i := 0 ; while i < b->size() do ( (     OclFile["System.out"].print(b[i+1]) ; 
     if (i < (b->size() - 1)) then     OclFile["System.out"].print(" ") ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) else (     execute operation(b, (n + 1)) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class P {
  int name ;
  int time ;
  P(int name,int time){
    this.name=name ;
    this.time=time ;
  }
}
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(stdIn.hasNext()){
      int n=stdIn.nextInt();
      if(n==0){
        break ;
      }
      List<P>list=new ArrayList<P>();
      for(int i=0 ; i<n ; ++i){
        int c1=stdIn.nextInt();
        int m1=stdIn.nextInt();
        int s1=stdIn.nextInt();
        int m2=stdIn.nextInt();
        int s2=stdIn.nextInt();
        int m3=stdIn.nextInt();
        int s3=stdIn.nextInt();
        int m4=stdIn.nextInt();
        int s4=stdIn.nextInt();
        list.add(new P(c1,(m1+m2+m3+m4)*60+(s1+s2+s3+s4)));
      }
      Collections.sort(list,new Comparator<P>(){
        public int compare(P t1,P t2){
          return(t1.time-t2.time);
        }
      }
);
      System.out.println(list.get(0).name);
      System.out.println(list.get(1).name);
      System.out.println(list.get(n-2).name);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P {
   attribute name : int;
   attribute time : int;
   static operation newP( name : int, time : int) : P
  pre: true
  post: true
  activity:
  ( var self : P ;
    self := createP();
    self.initialise(name, time);
    return self );
  operation initialise( name : int, time : int) : void
  pre: true  post: true
  activity: (     self.name := name ; 
     self.time := time );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (stdIn.hasNext()) do (     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var list : Sequence(P) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var c1 : int ; c1 := stdIn.getCurrent()->toInteger() ;
     var m1 : int ; m1 := stdIn.getCurrent()->toInteger() ;
    var s1 : int ; s1 := stdIn.getCurrent()->toInteger() ;
    var m2 : int ; m2 := stdIn.getCurrent()->toInteger() ;
    var s2 : int ; s2 := stdIn.getCurrent()->toInteger() ;
    var m3 : int ; m3 := stdIn.getCurrent()->toInteger() ;
    var s3 : int ; s3 := stdIn.getCurrent()->toInteger() ;
    var m4 : int ; m4 := stdIn.getCurrent()->toInteger() ;
    var s4 : int ; s4 := stdIn.getCurrent()->toInteger() ;
    list := list->including(P.newP(c1, (m1 + m2 + m3 + m4) * 60 + (s1 + s2 + s3 + s4))) ; 
 )  ;     i := i + 1 ) ; 
    list, OclComparator<P>.newOclComparator() := list, OclComparator<P>.newOclComparator()->sort() ; 
    OclFile["System.out"].println(list->at(0+1).name) ; 
    OclFile["System.out"].println(list->at(1+1).name) ; 
    OclFile["System.out"].println(list->at(n - 2+1).name) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  int n ;
  R[] rs ;
  void run(){
    for(; ; ){
      n=sc.nextInt();
      if(n==0){
        break ;
      }
      rs=new R[n];
      for(int i=0 ; i<n ; i++){
        rs[i]=new R();
        rs[i] .c=sc.nextInt();
        for(int k=0 ; k<4 ; k++){
          rs[i] .sec+=sc.nextInt()*60 ;
          rs[i] .sec+=sc.nextInt();
        }
      }
      Arrays.sort(rs);
      println(""+rs[0] .c);
      println(""+rs[1] .c);
      println(""+rs[n-2] .c);
    }
  }
  class R implements Comparable<R>{
    int c,sec ;
    @ Override public int compareTo(R r){
      return sec-r.sec ;
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   attribute n : int;
   attribute rs : Sequence(R);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then (     break ) else skip ; 
    rs := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do ( (     rs[i+1] := R.newR() ; 
     rs[i+1].c := sc.getCurrent()->toInteger() ; 
         var k : int ; k := 0 ; while k < 4 do ( (     rs[i+1].sec := rs[i+1].sec+(sc.getCurrent()->toInteger() * 60) ; 
     rs[i+1].sec := rs[i+1].sec+(sc.getCurrent()->toInteger()) )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    rs := rs->sort() ; 
    execute println("" + rs[0+1].c) ; 
    execute println("" + rs[1+1].c) ; 
    execute println("" + rs[n - 2+1].c) ; 
 )  ) );
 class R implements Comparable<R> {
   attribute c : int;
      operation compareTo( r : R) : int
  pre: true
  post: true
  activity: (     return sec - r.sec );
}
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static class Team {
    int num,time ;
    public Team(int n,int t1,int t2,int t3,int t4){
      num=n ;
      time=t1+t2+t3+t4 ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(! sc.hasNext("0")){
      LinkedList<Team>list=new LinkedList<Team>();
      int n=sc.nextInt();
      for(int i=0 ; i<n ; i++){
        int g=sc.nextInt();
        int t1=sc.nextInt()*60+sc.nextInt();
        int t2=sc.nextInt()*60+sc.nextInt();
        int t3=sc.nextInt()*60+sc.nextInt();
        int t4=sc.nextInt()*60+sc.nextInt();
        Team t=new Team(g,t1,t2,t3,t4);
        list.add(t);
      }
      Team win=list.get(0),swin=list.get(1),boo=win,worst=win ;
      for(int i=1 ; i<list.size(); i++){
        if(win.time>list.get(i).time){
          swin=win ;
          win=list.get(i);
        }
        else if(swin.time>list.get(i).time)swin=list.get(i);
        if(worst.time<list.get(i).time){
          boo=worst ;
          worst=list.get(i);
        }
        else if(boo.time<list.get(i).time)boo=list.get(i);
      }
      System.out.println(win.num+"\n"+swin.num+"\n"+boo.num);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Team {
   attribute num : int;
   static operation newTeam( n : int, t1 : int, t2 : int, t3 : int, t4 : int) : Team
  pre: true
  post: true
  activity:
  ( var self : Team ;
    self := createTeam();
    self.initialise(n, t1,t2,t3,t4);
    return self );
  operation initialise( n : int, t1 : int, t2 : int, t3 : int, t4 : int) : void
  pre: true  post: true
  activity: (     num := n ; 
     time := t1 + t2 + t3 + t4 );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (not(sc.hasNext("0"))) do (     var list : Sequence(Team) ; list := Sequence{} ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var g : int ; g := sc.getCurrent()->toInteger() ;
     var t1 : int ; t1 := sc.getCurrent()->toInteger() * 60 + sc.getCurrent()->toInteger() ;
    var t2 : int ; t2 := sc.getCurrent()->toInteger() * 60 + sc.getCurrent()->toInteger() ;
    var t3 : int ; t3 := sc.getCurrent()->toInteger() * 60 + sc.getCurrent()->toInteger() ;
    var t4 : int ; t4 := sc.getCurrent()->toInteger() * 60 + sc.getCurrent()->toInteger() ;
    var t : Team ; t := Team.newTeam(g, t1, t2, t3, t4) ;
    list := list->including(t) ; 
 )  ;     i := i + 1 ) ; 
    var win : Team ; win := list->at(0+1) ;
    var swin : Team ; swin := list->at(1+1) ;
    var boo : Team ; boo := win ;
    var worst : Team ; worst := win ;
        var i : int ; i := 1 ; while i < list->size() do ( (     if (win.time > list->at(i+1).time) then (     swin := win ; 
     win := list->at(i+1) ) else     if (swin.time > list->at(i+1).time) then     swin := list->at(i+1) ; else skip ; ;  
     if (worst.time < list->at(i+1).time) then (     boo := worst ; 
     worst := list->at(i+1) ) else     if (boo.time < list->at(i+1).time) then     boo := list->at(i+1) ; else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(win.num + "\n" + swin.num + "\n" + boo.num) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n ;
    int id ;
    int s ;
    while(true){
      n=scan.nextInt();
      if(n==0)break ;
      T[] t=new T[n];
      for(int i=0 ; i<n ; i++){
        id=scan.nextInt();
        s=0 ;
        for(int j=0 ; j<4 ; j++){
          s+=scan.nextInt()*60+scan.nextInt();
        }
        t[i]=new T(id,s);
      }
      Arrays.sort(t);
      System.out.println(t[0] .id+"\n"+t[1] .id+"\n"+t[n-2] .id);
    }
  }
  static class T implements Comparable<T>{
    int id,t ;
    public T(int id,int t){
      this.id=id ;
      this.t=t ;
    }
    public int compareTo(T o){
      return t-o.t ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var id : int ;
    var s : int ;
    while (true) do (     n := scan.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
    var t : Sequence(T) ; t := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     id := scan.getCurrent()->toInteger() ; 
     s := 0 ; 
         var j : int ; j := 0 ; while j < 4 do ( (     s := s+(scan.getCurrent()->toInteger() * 60 + scan.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
     t[i+1] := T.newT(id, s) )  ;     i := i + 1 ) ; 
    t := t->sort() ; 
    OclFile["System.out"].println(t[0+1].id + "\n" + t[1+1].id + "\n" + t[n - 2+1].id) ; 
 ) ; 
 );
  static class T implements Comparable<T> {
   attribute id : int;
   static operation newT( id : int, t : int) : T
  pre: true
  post: true
  activity:
  ( var self : T ;
    self := createT();
    self.initialise(id, t);
    return self );
  operation initialise( id : int, t : int) : void
  pre: true  post: true
  activity: (     self.id := id ; 
     self.t := t );
   operation compareTo( o : T) : int
  pre: true
  post: true
  activity: (     return t - o.t );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import static java.util.Arrays.fill ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      int n=sc.nextInt();
      if(n==0)break ;
      T[] ts=new T[n];
      for(int i=0 ; i<n ; i++){
        T t=new T();
        t.id=sc.nextInt();
        for(int j=0 ; j<4 ; j++){
          int m=sc.nextInt();
          int s=sc.nextInt();
          t.time+=m*60+s ;
        }
        ts[i]=t ;
      }
      Arrays.sort(ts);
      System.out.println(ts[0] .id);
      System.out.println(ts[1] .id);
      System.out.println(ts[n-2] .id);
    }
  }
  public class T implements Comparable<T>{
    int id ;
    int time ;
    @ Override public int compareTo(T o){
      if(time!=o.time)return time-o.time ;
      return id-o.id ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var ts : Sequence(T) ; ts := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var t : T ; t := T.newT() ;
     t.id := sc.getCurrent()->toInteger() ; 
         var j : int ; j := 0 ; while j < 4 do ( (     var m : int ; m := sc.getCurrent()->toInteger() ;
     var s : int ; s := sc.getCurrent()->toInteger() ;
     t.time := t.time+(m * 60 + s) )  ;     j := j + 1 ) ; 
     ts[i+1] := t )  ;     i := i + 1 ) ; 
    ts := ts->sort() ; 
    OclFile["System.out"].println(ts[0+1].id) ; 
    OclFile["System.out"].println(ts[1+1].id) ; 
    OclFile["System.out"].println(ts[n - 2+1].id) ; 
 )  ) );
 class T implements Comparable<T> {
   attribute id : int;
   attribute time : int;
      operation compareTo( o : T) : int
  pre: true
  post: true
  activity: (     if (time /= o.time) then     return time - o.time else skip ; 
     return id - o.id );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void minSet(ArrayList<Integer>nums){
    ArrayList<Integer>A=new ArrayList<Integer>();
    Collections.sort(nums);
    int sum=0 ;
    for(int i=0 ; i<nums.size(); i++)sum+=nums.get(i);
    int temp=0 ;
    for(int i=nums.size()-1 ; i>=0 && temp<=sum/2 ; i--){
      A.add(nums.get(i));
      temp+=nums.get(i);
    }
    for(int i=0 ; i<A.size(); i++)System.out.print(A.get(i)+" ");
  }
  public static void main(String[] args){
    ArrayList<Integer>gfg=new ArrayList<Integer>();
    gfg.add(7);
    gfg.add(6);
    gfg.add(13);
    gfg.add(13);
    gfg.add(12);
    gfg.add(11);
    minSet(gfg);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minSet( nums : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{} ;
     nums := nums->sort() ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < nums->size() do (     sum := sum+(nums->at(i+1)) ;  ;     i := i + 1 ) ; 
    var temp : int ; temp := 0 ;
        var i : int ; i := nums->size() - 1 ; while i >= 0 & temp <= sum / 2 do ( (     A := A->including(nums->at(i+1)) ; 
     temp := temp+(nums->at(i+1)) )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < A->size() do (     OclFile["System.out"].print(A->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var gfg : Sequence(int) ; gfg := Sequence{} ;
     gfg := gfg->including(7) ; 
    gfg := gfg->including(6) ; 
    gfg := gfg->including(13) ; 
    gfg := gfg->including(13) ; 
    gfg := gfg->including(12) ; 
    gfg := gfg->including(11) ; 
    execute minSet(gfg) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    new Thread(null,new Runnable(){
      public void run(){
        solve();
      }
    },"1",1<<26).start();
  }
  static void solve(){
    FastReader fr=new FastReader();
    PrintWriter op=new PrintWriter(System.out);
    int i=fr.nextInt(),j=fr.nextInt();
    double a=i*i,b=j*j ;
    int h=fr.nextInt(),m=fr.nextInt();
    double H=h*30.0+(m*30.0)/60.0,M=m*6.0,ang=Math.abs(H-M);
    ang=Math.min(ang,360.0-ang);
    double rad=Math.PI/180.0 ;
    rad*=ang ;
    double c=a+b-(2.0*i*j*Math.cos(rad));
    c=Math.sqrt(c);
    op.println(c);
    op.flush();
    op.close();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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();
    }
    String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(null, Runnable(), "1", (1*(2->pow(26)))->oclAsType(long)).start() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var fr : FastReader ; fr := FastReader.newFastReader() ;
     var op : OclFile ; op := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var i : int ; i := fr.nextInt() ;
    var j : int ; j := fr.nextInt() ;
    var a : double ; a := i * i ;
    var b : double ; b := j * j ;
    var h : int ; h := fr.nextInt() ;
    var m : int ; m := fr.nextInt() ;
    var H : double ; H := h * 30.0 + (m * 30.0) / 60.0 ;
    var M : double ; M := m * 6.0 ;
    var ang : double ; ang := if H - M < 0 then -(H - M) else H - M endif ;
    ang := Set{ang, 360.0 - ang}->min() ; 
    var rad : double ; rad := 3.141592653589793 / 180.0 ;
    rad := rad*(ang) ; 
    var c : double ; c := a + b - (2.0 * i * j * (rad)->cos()) ;
    c := (c)->sqrt() ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or (not(st.hasNext()))) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class KirillAndTheGame {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long l=in.nextInt(),r=in.nextInt(),x=in.nextInt(),y=in.nextInt(),k=in.nextInt();
    boolean good=false ;
    for(long i=x ; i<=y ; i++){
      long temp=i*k ;
      if(temp>=l && temp<=r){
        good=true ;
        break ;
      }
    }
    pw.println((good)? "YES" : "NO");
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class KirillAndTheGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var l : long ; l := in.getCurrent()->toInteger() ;
    var r : long ; r := in.getCurrent()->toInteger() ;
    var x : long ; x := in.getCurrent()->toInteger() ;
    var y : long ; y := in.getCurrent()->toInteger() ;
    var k : long ; k := in.getCurrent()->toInteger() ;
    var good : boolean ; good := false ;
        var i : long ; i := x ; while i <= y do ( (     var temp : long ; temp := i * k ;
     if (temp >= l & temp <= r) then (     good := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.System.out ;
public class pre27 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    long l=obj.nextInt(),r=obj.nextInt(),x=obj.nextInt(),y=obj.nextInt(),k=obj.nextInt();
    boolean ans=false ;
    for(long i=x ; i<=y ; i++){
      if(i*k>=l && i*k<=r){
        ans=true ;
        break ;
      }
    }
    out.println(ans ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre27 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var l : long ; l := obj.nextInt() ;
    var r : long ; r := obj.nextInt() ;
    var x : long ; x := obj.nextInt() ;
    var y : long ; y := obj.nextInt() ;
    var k : long ; k := obj.nextInt() ;
    var ans : boolean ; ans := false ;
        var i : long ; i := x ; while i <= y do ( (     if (i * k >= l & i * k <= r) then (     ans := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    out.println(if ans then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.System.*;
import static java.lang.Math.max ;
import static java.lang.Math.min ;
import static java.lang.Math.*;
public class pre1 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    long l=obj.nextInt(),r=obj.nextInt();
    long x=obj.nextInt(),y=obj.nextInt();
    long k=obj.nextInt();
    boolean ans=false ;
    for(long i=x ; i<=y ; i++){
      if(l<=k*i && k*i<=r){
        ans=true ;
        break ;
      }
    }
    out.println(ans ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre1 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var l : long ; l := obj.nextInt() ;
    var r : long ; r := obj.nextInt() ;
    var x : long ; x := obj.nextInt() ;
    var y : long ; y := obj.nextInt() ;
    var k : long ; k := obj.nextInt() ;
    var ans : boolean ; ans := false ;
        var i : long ; i := x ; while i <= y do ( (     if (l <= k * i & k * i <= r) then (     ans := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    out.println(if ans then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class KirillAndTheGame {
  public static PrintWriter out ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    out=new PrintWriter(System.out);
    long l=Integer.parseInt(st.nextToken());
    long r=Integer.parseInt(st.nextToken());
    long x=Integer.parseInt(st.nextToken());
    long y=Integer.parseInt(st.nextToken());
    long k=Integer.parseInt(st.nextToken());
    for(long i=x ; i<=y ; i++){
      if(i*k>=l && i*k<=r){
        out.println("YES");
        out.close();
      }
    }
    out.println("NO");
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class KirillAndTheGame {
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    var l : long ; l := (st.next())->toInteger() ;
    var r : long ; r := (st.next())->toInteger() ;
    var x : long ; x := (st.next())->toInteger() ;
    var y : long ; y := (st.next())->toInteger() ;
    var k : long ; k := (st.next())->toInteger() ;
        var i : long ; i := x ; while i <= y do ( (     if (i * k >= l & i * k <= r) then (     skip ; 
     skip ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isDivisible(long n){
    while(n/100>0){
      long d=n % 10 ;
      n/=10 ;
      n-=d*5 ;
    }
    return(n % 17==0);
  }
  public static void main(String[] args){
    long n=19877658 ;
    if(isDivisible(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isDivisible( n : long) : boolean
  pre: true
  post: true
  activity: (     while (n / 100 > 0) do (     var d : long ; d := n mod 10 ;
     n := n/(10) ; 
     n := n-(d * 5) ) ; 
     return (n mod 17 = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 19877658 ;
     if (isDivisible(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import javax.lang.model.util.ElementScanner6 ;
public class Solution9 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    int[] arr=new int[4];
    int j=0 ;
    for(int i=0 ; i<s.length(); i++){
      char ch=s.charAt(i);
      if(ch==' '){
        arr[j]=i ;
        j++;
      }
    }
    int l=Integer.parseInt(s.substring(0,arr[0]));
    int r=Integer.parseInt(s.substring(arr[0]+1,arr[1]));
    int x=Integer.parseInt(s.substring(arr[1]+1,arr[2]));
    int y=Integer.parseInt(s.substring(arr[2]+1,arr[3]));
    Double k=Double.parseDouble(s.substring(arr[3]+1));
    if(Double.valueOf(r/x)<k){
      System.out.println("NO");
    }
    else if(Double.valueOf(l/y)>k){
      System.out.println("NO");
    }
    else {
      int c=0 ;
      for(int i=x ; i<=y ; i++){
        int z=(int)(i*k);
        if(z>=l && z<=r){
          System.out.println("YES");
          c++;
          break ;
        }
      }
      if(c==0){
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution9 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,4)->collect(0) ;
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var ch : String ; ch := s->at(i+1) ;
     if (ch = ' ') then (     arr[j+1] := i ; 
     j := j + 1 ) else skip )  ;     i := i + 1 ) ; 
    var l : int ; l := (s.subrange(0+1,arr[0+1]))->toInteger() ;
    var r : int ; r := (s.subrange(arr[0+1] + 1+1,arr[1+1]))->toInteger() ;
    var x : int ; x := (s.subrange(arr[1+1] + 1+1,arr[2+1]))->toInteger() ;
    var y : int ; y := (s.subrange(arr[2+1] + 1+1,arr[3+1]))->toInteger() ;
    var k : double ; k := (s.subrange(arr[3+1] + 1+1,arr[3+1] + 1))->toReal() ;
    if ((r / x)->toReal() < k) then (     OclFile["System.out"].println("NO") ) else     if ((l / y)->toReal() > k) then (     OclFile["System.out"].println("NO") ) else (     var c : int ; c := 0 ;
         var i : int ; i := x ; while i <= y do ( (     var z : int ; z := (i * k)->oclAsType(int) ;
     if (z >= l & z <= r) then (     OclFile["System.out"].println("YES") ; 
     c := c + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (c = 0) then (     OclFile["System.out"].println("NO") ) else skip ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countTransformation(String a,String b){
    int n=a.length(),m=b.length();
    if(m==0){
      return 1 ;
    }
    int dp[][]=new int[m][n];
    for(int i=0 ; i<m ; i++){
      for(int j=i ; j<n ; j++){
        if(i==0){
          if(j==0){
            dp[i][j]=(a.charAt(j)==b.charAt(i))? 1 : 0 ;
          }
          else if(a.charAt(j)==b.charAt(i)){
            dp[i][j]=dp[i][j-1]+1 ;
          }
          else {
            dp[i][j]=dp[i][j-1];
          }
        }
        else if(a.charAt(j)==b.charAt(i)){
          dp[i][j]=dp[i][j-1]+dp[i-1][j-1];
        }
        else {
          dp[i][j]=dp[i][j-1];
        }
      }
    }
    return dp[m-1][n-1];
  }
  public static void main(String[] args){
    String a="abcccdf",b="abccdf" ;
    System.out.println(countTransformation(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countTransformation( a : String, b : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() ;
    var m : int ; m := b->size() ;
     if (m = 0) then (     return 1 ) else skip ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,m)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := i ; while j < n do ( (     if (i = 0) then (     if (j = 0) then (     dp[i+1][j+1] := if (a->at(j+1) = b->at(i+1)) then 1 else 0 endif ) else     if (a->at(j+1) = b->at(i+1)) then (     dp[i+1][j+1] := dp[i+1][j - 1+1] + 1 ) else (     dp[i+1][j+1] := dp[i+1][j - 1+1] ) ;  ) else     if (a->at(j+1) = b->at(i+1)) then (     dp[i+1][j+1] := dp[i+1][j - 1+1] + dp[i - 1+1][j - 1+1] ) else (     dp[i+1][j+1] := dp[i+1][j - 1+1] ) ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return dp[m - 1+1][n - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ; a := "abcccdf" ;
    var b : String ; b := "abccdf" ;
     OclFile["System.out"].println(countTransformation(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B638 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    String[] parts=new String[N];
    for(int n=0 ; n<N ; n++){
      parts[n]=in.next();
    }
    StringBuilder out=new StringBuilder();
    int processed=0 ;
    int pos=0 ;
    while(processed<N){
      for(char c='a' ; c<='z' ; c++){
        boolean seen=false ;
        boolean ok=true ;
        for(String part : parts){
          if(part!=null){
            int idx=part.indexOf(c);
            if(idx!=-1){
              seen=true ;
              if(idx!=0){
                ok=false ;
              }
            }
          }
        }
        if(seen && ok){
          out.append(c);
          break ;
        }
      }
      while(pos<out.length()){
        char c=out.charAt(pos);
        for(int n=0 ; n<N ; n++){
          String part=parts[n];
          if(part!=null && part.charAt(0)==c){
            for(int i=out.length()-pos ; i<part.length(); i++){
              out.append(part.charAt(i));
            }
            parts[n]=null ;
            processed++;
          }
        }
        pos++;
      }
    }
    System.out.println(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B638 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var parts : Sequence(String) ; parts := Integer.subrange(1,N)->collect(null) ;
        var n : int ; n := 0 ; while n < N do ( (     parts[n+1] := in.getCurrent() )  ;     n := n + 1 ) ; 
    var out : String ; out := StringLib.newString() ;
    var processed : int ; processed := 0 ;
    var pos : int ; pos := 0 ;
    while (processed < N) do (         var c : String ; c := 'a' ; while c <= 'z' do ( (     var seen : boolean ; seen := false ;
     var ok : boolean ; ok := true ;
     for (part : parts) do ( (     if (part /= null) then (     var idx : int ; idx := part->indexOf(c)-1 ;
     if (idx /= -1) then (     seen := true ; 
     if (idx /= 0) then (     ok := false ) else skip ) else skip ) else skip )  ) ; 
     if (seen & ok) then (     out := out + StringLib.newString(c) ; 
     break ) else skip )  ;     c := c + 1 ) ; 
     while (pos < out->size()) do (     var c : String ; c := out->at(pos+1) ;
         var n : int ; n := 0 ; while n < N do ( (     var part : String ; part := parts[n+1] ;
     if (part /= null & part->at(0+1) = c) then (         var i : int ; i := out->size() - pos ; while i < part->size() do ( (     out := out + StringLib.newString(part->at(i+1)) )  ;     i := i + 1 ) ; 
     parts[n+1] := null ; 
     processed := processed + 1 ) else skip )  ;     n := n + 1 ) ; 
     pos := pos + 1 ) ) ; 
    OclFile["System.out"].println(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    PrintWriter pw=new PrintWriter(System.out);
    Scanner sc=new Scanner(System.in);
    int w=sc.nextInt();
    int h=sc.nextInt();
    int n=sc.nextInt();
    int p1=0 ;
    int p2=0 ;
    int move=0 ;
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      move=sc.nextInt();
      if(move==0){
        p1++;
      }
      else if(move==1){
        p2++;
      }
      cnt+=cnt(p1,p2,w,h);
    }
    pw.println(cnt);
    sc.close();
    pw.close();
  }
  public static int cnt(int p1,int p2,int w,int h){
    if(p1<w-1){
      if(p2==p1){
        return 1 ;
      }
      else {
        return 0 ;
      }
    }
    if(p1==w-1){
      return 0 ;
    }
    if(p1>w-1 && p1<w+h-2){
      if(p2+2==p1){
        return 1 ;
      }
      else {
        return 0 ;
      }
    }
    if(p1==w+h-2){
      return 0 ;
    }
    if(p1>w+h-2){
      if(p2+4==p1){
        return 1 ;
      }
      else {
        return 0 ;
      }
    }
    return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var p1 : int ; p1 := 0 ;
    var p2 : int ; p2 := 0 ;
    var move : int ; move := 0 ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     move := sc.getCurrent()->toInteger() ; 
     if (move = 0) then (     p1 := p1 + 1 ) else     if (move = 1) then (     p2 := p2 + 1 ) else skip ; ;  
     cnt := cnt+(cnt(p1, p2, w, h)) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation cnt( p1 : int, p2 : int, w : int, h : int) : int
  pre: true
  post: true
  activity: (     if (p1 < w - 1) then (     if (p2 = p1) then (     return 1 ) else (     return 0 ) ) else skip ; 
     if (p1 = w - 1) then (     return 0 ) else skip ; 
    if (p1 > w - 1 & p1 < w + h - 2) then (     if (p2 + 2 = p1) then (     return 1 ) else (     return 0 ) ) else skip ; 
    if (p1 = w + h - 2) then (     return 0 ) else skip ; 
    if (p1 > w + h - 2) then (     if (p2 + 4 = p1) then (     return 1 ) else (     return 0 ) ) else skip ; 
    return -1 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int w=sc.nextInt();
    int h=sc.nextInt();
    int in=0 ;
    int out=0 ;
    int n=sc.nextInt();
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      if(x==0){
        out++;
      }
      else {
        in++;
      }
      if(out<w-1){
        if(in==out){
          count++;
        }
      }
      else if(out>w-1 && out<w-1+h-1){
        if(in+2==out){
          count++;
        }
      }
      else if(out>w-1+h-1){
        if(in+4==out){
          count++;
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var in : int ; in := 0 ;
    var out : int ; out := 0 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x = 0) then (     out := out + 1 ) else (     in := in + 1 ) ;  
     if (out < w - 1) then (     if (in = out) then (     count := count + 1 ) else skip ) else     if (out > w - 1 & out < w - 1 + h - 1) then (     if (in + 2 = out) then (     count := count + 1 ) else skip ) else     if (out > w - 1 + h - 1) then (     if (in + 4 = out) then (     count := count + 1 ) else skip ) else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigDecimal ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int H=sc.nextInt();
    int M=sc.nextInt();
    BigDecimal AA=new BigDecimal(A);
    BigDecimal BB=new BigDecimal(B);
    BigDecimal HH=new BigDecimal(H);
    BigDecimal MM=new BigDecimal(M);
    BigDecimal ans2 ;
    BigDecimal kaku ;
    BigDecimal mkaku ;
    BigDecimal hkaku ;
    BigDecimal AA2 ;
    BigDecimal BB2 ;
    BigDecimal CC ;
    BigDecimal DD ;
    double dkaku ;
    double dans2 ;
    mkaku=MM.multiply(BigDecimal.valueOf(6));
    hkaku=HH.multiply(BigDecimal.valueOf(30));
    hkaku=hkaku.add(BigDecimal.valueOf((double)M/2));
    kaku=mkaku.subtract(hkaku);
    dkaku=Math.abs(Math.toRadians(kaku.doubleValue()));
    AA2=AA.multiply(AA);
    BB2=BB.multiply(BB);
    CC=AA2.add(BB2);
    DD=BigDecimal.valueOf(Math.cos(dkaku));
    DD=DD.multiply(BigDecimal.valueOf(2));
    DD=DD.multiply(AA);
    DD=DD.multiply(BB);
    ans2=CC.subtract(DD);
    dans2=ans2.doubleValue();
    double ans=Math.sqrt(dans2);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var H : int ; H := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var AA : double ; AA := double(A) ;
    var BB : double ; BB := double(B) ;
    var HH : double ; HH := double(H) ;
    var MM : double ; MM := double(M) ;
    var ans2 : double ;
    var kaku : double ;
    var mkaku : double ;
    var hkaku : double ;
    var AA2 : double ;
    var BB2 : double ;
    var CC : double ;
    var DD : double ;
    var dkaku : double ;
    var dans2 : double ;
    mkaku := MM.multiply((6 + "")->toReal()) ; 
    hkaku := HH.multiply((30 + "")->toReal()) ; 
    hkaku := hkaku->excludes((M->oclAsType(double) / 2 + "")->toReal()) ; 
    kaku := mkaku.subtract(hkaku) ; 
    dkaku := if (0.017453292519943295*(kaku->oclAsType(double))) < 0 then -((0.017453292519943295*(kaku->oclAsType(double)))) else (0.017453292519943295*(kaku->oclAsType(double))) endif ; 
    AA2 := AA.multiply(AA) ; 
    BB2 := BB.multiply(BB) ; 
    CC := AA2->excludes(BB2) ; 
    DD := ((dkaku)->cos() + "")->toReal() ; 
    DD := DD.multiply((2 + "")->toReal()) ; 
    DD := DD.multiply(AA) ; 
    DD := DD.multiply(BB) ; 
    ans2 := CC.subtract(DD) ; 
    dans2 := ans2->oclAsType(double) ; 
    var ans : double ; ans := (dans2)->sqrt() ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static final int MAX_CHAR=26 ;
  static boolean checkCorrectOrNot(String s){
    int[] count1=new int[MAX_CHAR];
    int[] count2=new int[MAX_CHAR];
    int n=s.length();
    if(n==1)return true ;
    for(int i=0,j=n-1 ; i<j ; i++,j--){
      count1[s.charAt(i)-'a']++;
      count2[s.charAt(j)-'a']++;
    }
    for(int i=0 ; i<MAX_CHAR ; i++)if(count1[i]!=count2[i])return false ;
    return true ;
  }
  public static void main(String args[]){
    String s="abab" ;
    if(checkCorrectOrNot(s))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX_CHAR : int := 26;
  static   operation checkCorrectOrNot( s : String) : boolean
  pre: true
  post: true
  activity: (     var count1 : Sequence(int) ; count1 := Integer.subrange(1,MAX_CHAR)->collect(0) ;
     var count2 : Sequence(int) ; count2 := Integer.subrange(1,MAX_CHAR)->collect(0) ;
    var n : int ; n := s->size() ;
    if (n = 1) then     return true else skip ; 
        var i : int ; i := 0 ;
    var j : int ; j := n - 1 ; while i < j do ( (     count1[s->at(i+1) - ('a')->char2byte()+1] := count1[s->at(i+1) - ('a')->char2byte()+1] + 1 ; 
     count2[s->at(j+1) - ('a')->char2byte()+1] := count2[s->at(j+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ;     j := j - 1 ) ; 
        var i : int ; i := 0 ; while i < MAX_CHAR do (     if (count1[i+1] /= count2[i+1]) then     return false else skip ;  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abab" ;
     if (checkCorrectOrNot(s)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static final int MAX_CHAR=26 ;
  static boolean checkCorrectOrNot(String s){
    int[] count=new int[MAX_CHAR];
    int n=s.length();
    if(n==1)return true ;
    for(int i=0,j=n-1 ; i<j ; i++,j--){
      count[s.charAt(i)-'a']++;
      count[s.charAt(j)-'a']--;
    }
    for(int i=0 ; i<MAX_CHAR ; i++)if(count[i]!=0)return false ;
    return true ;
  }
  public static void main(String args[]){
    String s="abab" ;
    if(checkCorrectOrNot(s))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX_CHAR : int := 26;
  static   operation checkCorrectOrNot( s : String) : boolean
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,MAX_CHAR)->collect(0) ;
     var n : int ; n := s->size() ;
    if (n = 1) then     return true else skip ; 
        var i : int ; i := 0 ;
    var j : int ; j := n - 1 ; while i < j do ( (     count[s->at(i+1) - ('a')->char2byte()+1] := count[s->at(i+1) - ('a')->char2byte()+1] + 1 ; 
     count[s->at(j+1) - ('a')->char2byte()+1] := count[s->at(j+1) - ('a')->char2byte()+1] - 1 )  ;     i := i + 1 ;     j := j - 1 ) ; 
        var i : int ; i := 0 ; while i < MAX_CHAR do (     if (count[i+1] /= 0) then     return false else skip ;  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abab" ;
     if (checkCorrectOrNot(s)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Node {
    int data ;
    Node next ;
  };
  static Node newNode(int data){
    Node temp=new Node();
    temp.data=data ;
    temp.next=null ;
    return temp ;
  }
  static void printList(Node node){
    while(node!=null){
      System.out.print(node.data+" ");
      node=node.next ;
    }
  }
  static void replaceNodes(Node head){
    Node p=head ;
    Node x=null ;
    int count=0 ;
    int i ;
    while(p!=null){
      count=0 ;
      i=0 ;
      x=p ;
      while(x!=null){
        if(x.data>p.data)count++;
        x=x.next ;
      }
      p.data=count ;
      p=p.next ;
    }
  }
  public static void main(String[] args){
    Node head=newNode(10);
    head.next=newNode(12);
    head.next.next=newNode(5);
    head.next.next.next=newNode(40);
    head.next.next.next.next=newNode(21);
    head.next.next.next.next.next=newNode(70);
    head.next.next.next.next.next.next=newNode(1);
    head.next.next.next.next.next.next.next=newNode(49);
    head.next.next.next.next.next.next.next.next=newNode(37);
    replaceNodes(head);
    printList(head);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   operation newNode( data : int) : Node
  pre: true
  post: true
  activity: (     var temp : Node ; temp := Node.newNode() ;
     temp.data := data ; 
     temp.next := null ; 
     return temp );
  static   operation printList( node : Node) : void
  pre: true
  post: true
  activity: (     while (node /= null) do (     OclFile["System.out"].print(node.data + " ") ; 
     node := node.next ) );
  static   operation replaceNodes( head : Node) : void
  pre: true
  post: true
  activity: (     var p : Node ; p := head ;
     var x : Node ; x := null ;
    var count : int ; count := 0 ;
    var i : int ;
    while (p /= null) do (     count := 0 ; 
     i := 0 ; 
    x := p ; 
    while (x /= null) do (     if (x.data > p.data) then     count := count + 1 ; else skip ; 
     x := x.next ) ; 
    p.data := count ; 
    p := p.next ; 
 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := newNode(10) ;
     head.next := newNode(12) ; 
    head.next.next := newNode(5) ; 
    head.next.next.next := newNode(40) ; 
    head.next.next.next.next := newNode(21) ; 
    head.next.next.next.next.next := newNode(70) ; 
    head.next.next.next.next.next.next := newNode(1) ; 
    head.next.next.next.next.next.next.next := newNode(49) ; 
    head.next.next.next.next.next.next.next.next := newNode(37) ; 
    execute replaceNodes(head) ; 
    execute printList(head) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findGCDSum(int n,int a[]){
    int GCDSum=0 ;
    int tempGCD=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i ; j<n ; j++){
        tempGCD=0 ;
        for(int k=i ; k<=j ; k++){
          tempGCD=__gcd(tempGCD,a[k]);
        }
        GCDSum+=tempGCD ;
      }
    }
    return GCDSum ;
  }
  static int __gcd(int a,int b){
    return b==0 ? a : __gcd(b,a % b);
  }
  public static void main(String[] args){
    int n=5 ;
    int a[]={
      1,2,3,4,5 };
      int totalSum=findGCDSum(n,a);
      System.out.print(totalSum+"\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findGCDSum( n : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var GCDSum : int ; GCDSum := 0 ;
     var tempGCD : int ; tempGCD := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i ; while j < n do ( (     tempGCD := 0 ; 
         var k : int ; k := i ; while k <= j do ( (     tempGCD := __gcd(tempGCD, a[k+1]) )  ;     k := k + 1 ) ; 
     GCDSum := GCDSum+(tempGCD) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return GCDSum );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else __gcd(b, a mod b) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var a : Sequence(int) ; a := Sequence{1,2,3,4,5} ;
     var totalSum : int ; totalSum := findGCDSum(n, a) ;
     OclFile["System.out"].print(totalSum + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class PrimeAndFib {
  Boolean isSquare(int n){
    int sr=(int)Math.sqrt(n);
    return(sr*sr==n);
  }
  static void printPrimeAndFib(int n){
    Boolean[] prime=new Boolean[n+1];
    for(int p=0 ; p<=n ; p++)prime[p]=true ;
    for(int p=2 ; p*p<=n ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=n ; i+=p)prime[i]=false ;
      }
    }
    for(int i=2 ; i<=n ; i++){
      double sqrt=Math.sqrt(5*i*i+4);
      double sqrt1=Math.sqrt(5*i*i-4);
      int x=(int)sqrt ;
      int y=(int)sqrt1 ;
      if(prime[i]==true &&(Math.pow(sqrt,2)==Math.pow(x,2)|| Math.pow(sqrt1,2)==Math.pow(y,2)))System.out.print(i+" ");
    }
  }
  public static void main(String s[]){
    int n=30 ;
    printPrimeAndFib(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class PrimeAndFib {
   operation isSquare( n : int) : Boolean
  pre: true
  post: true
  activity: (     var sr : int ; sr := (n)->sqrt()->oclAsType(int) ;
     return (sr * sr = n) );
  static   operation printPrimeAndFib( n : int) : void
  pre: true
  post: true
  activity: (     var prime : Sequence(Boolean) ; prime := Integer.subrange(1,n + 1)->collect(null) ;
         var p : int ; p := 0 ; while p <= n do (     prime[p+1] := true ;  ;     p := p + 1 ) ; 
         var p : int ; p := 2 ; while p * p <= n do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= n do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
         var i : int ; i := 2 ; while i <= n do ( (     var sqrt : double ; sqrt := (5 * i * i + 4)->sqrt() ;
     var sqrt1 : double ; sqrt1 := (5 * i * i - 4)->sqrt() ;
    var x : int ; x := sqrt->oclAsType(int) ;
    var y : int ; y := sqrt1->oclAsType(int) ;
    if (prime[i+1] = true & (sqrt->pow(2) = x->pow(2) or sqrt1->pow(2) = y->pow(2))) then     OclFile["System.out"].print(i + " ") ; else skip ; 
 )  ;     i := i + 1 ) );
  static   operation main( s : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 30 ;
     execute printPrimeAndFib(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isDivisible(long n){
    while(n/100>0){
      int last_digit=(int)n % 10 ;
      n/=10 ;
      n+=last_digit*3 ;
    }
    return(n % 29==0);
  }
  public static void main(String[] args){
    long n=348 ;
    if(isDivisible(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isDivisible( n : long) : boolean
  pre: true
  post: true
  activity: (     while (n / 100 > 0) do (     var last_digit : int ; last_digit := n->oclAsType(int) mod 10 ;
     n := n/(10) ; 
     n := n+(last_digit * 3) ) ; 
     return (n mod 29 = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 348 ;
     if (isDivisible(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      String line=sc.next();
      if(line.equals(".")){
        sc.close();
        break ;
      }
      int ans=0 ;
      for(int p=0 ; p<=2 ; p++){
        for(int q=0 ; q<=2 ; q++){
          for(int r=0 ; r<=2 ; r++){
            String tmp=line.replaceAll("P",String.valueOf(p));
            tmp=tmp.replaceAll("Q",String.valueOf(q));
            tmp=tmp.replaceAll("R",String.valueOf(r));
            while(tmp.length()>1){
              while(true){
                int k=tmp.length();
                tmp=tmp.replaceAll("-0","2");
                tmp=tmp.replaceAll("-1","1");
                tmp=tmp.replaceAll("-2","0");
                if(tmp.length()==k){
                  break ;
                }
              }
              while(true){
                int k=tmp.length();
                tmp=tmp.replaceAll("\\(2\\*2\\)","2");
                tmp=tmp.replaceAll("\\([12] \\*1\\)","1");
                tmp=tmp.replaceAll("\\(1\\*[12] \\)","1");
                tmp=tmp.replaceAll("\\([012] \\*0\\)","0");
                tmp=tmp.replaceAll("\\(0\\*[012] \\)","0");
                tmp=tmp.replaceAll("\\(0\\+0\\)","0");
                tmp=tmp.replaceAll("\\(1\\+[01] \\)","1");
                tmp=tmp.replaceAll("\\([01] \\+1\\)","1");
                tmp=tmp.replaceAll("\\([012] \\+2\\)","2");
                tmp=tmp.replaceAll("\\(2\\+[012] \\)","2");
                if(tmp.length()==k){
                  break ;
                }
              }
            }
            if(tmp.equals("2")){
              ans++;
            }
          }
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var line : String ; line := sc.getCurrent() ;
     if (line = ".") then (     skip ; 
     break ) else skip ; 
    var ans : int ; ans := 0 ;
        var p : int ; p := 0 ; while p <= 2 do ( (         var q : int ; q := 0 ; while q <= 2 do ( (         var r : int ; r := 0 ; while r <= 2 do ( (     var tmp : String ; tmp := line.replaceAllMatches("P", ((p) + "") ) ;
     tmp := tmp.replaceAllMatches("Q", ((q) + "") ) ; 
    tmp := tmp.replaceAllMatches("R", ((r) + "") ) ; 
    while (tmp->size() > 1) do (     while (true) do (     var k : int ; k := tmp->size() ;
     tmp := tmp.replaceAllMatches("-0", "2" ) ; 
    tmp := tmp.replaceAllMatches("-1", "1" ) ; 
    tmp := tmp.replaceAllMatches("-2", "0" ) ; 
    if (tmp->size() = k) then (     break ) else skip ; 
 ) ; 
     while (true) do (     var k : int ; k := tmp->size() ;
     tmp := tmp.replaceAllMatches("\\(2\\*2\\)", "2" ) ; 
    tmp := tmp.replaceAllMatches("\\([12] \\*1\\)", "1" ) ; 
    tmp := tmp.replaceAllMatches("\\(1\\*[12] \\)", "1" ) ; 
    tmp := tmp.replaceAllMatches("\\([012] \\*0\\)", "0" ) ; 
    tmp := tmp.replaceAllMatches("\\(0\\*[012] \\)", "0" ) ; 
    tmp := tmp.replaceAllMatches("\\(0\\+0\\)", "0" ) ; 
    tmp := tmp.replaceAllMatches("\\(1\\+[01] \\)", "1" ) ; 
    tmp := tmp.replaceAllMatches("\\([01] \\+1\\)", "1" ) ; 
    tmp := tmp.replaceAllMatches("\\([012] \\+2\\)", "2" ) ; 
    tmp := tmp.replaceAllMatches("\\(2\\+[012] \\)", "2" ) ; 
    if (tmp->size() = k) then (     break ) else skip ; 
 ) ) ; 
    if (tmp = "2") then (     ans := ans + 1 ) else skip ; 
 )  ;     r := r + 1 ) )  ;     q := q + 1 ) )  ;     p := p + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  String[] AND={
    "(0*0)","(0*1)","(0*2)","(1*0)","(1*1)","(1*2)","(2*0)","(2*1)","(2*2)" };
    String[] AND_RESULT={
      "0","0","0","0","1","1","0","1","2" };
      String[] OR={
        "(0+0)","(0+1)","(0+2)","(1+0)","(1+1)","(1+2)","(2+0)","(2+1)","(2+2)" };
        String[] OR_RESULT={
          "0","1","2","1","1","2","2","2","2" };
          String[] INV={
            "-0","-1","-2" };
            String[] INV_RESULT={
              "2","1","0" };
              void run(){
                Scanner sc=new Scanner(System.in);
                while(true){
                  String exp=sc.next().replace("--","");
                  if(exp.equals(".")){
                    break ;
                  }
                  int count=0 ;
                  for(int p=0 ; p<=2 ; p++){
                    for(int q=0 ; q<=2 ; q++){
                      for(int r=0 ; r<=2 ; r++){
                        String tmp=exp.replace("P",p+"");
                        tmp=tmp.replace("Q",q+"");
                        tmp=tmp.replace("R",r+"");
                        if(calc(tmp).equals("2")){
                          count++;
                        }
                      }
                    }
                  }
                  System.out.println(count);
                }
              }
              String calc(String exp){
                while(exp.length()!=1){
                  for(int i=0 ; i<INV.length ; i++){
                    exp=exp.replace(INV[i],INV_RESULT[i]);
                  }
                  for(int i=0 ; i<AND.length ; i++){
                    exp=exp.replace(AND[i],AND_RESULT[i]);
                  }
                  for(int i=0 ; i<OR.length ; i++){
                    exp=exp.replace(OR[i],OR_RESULT[i]);
                  }
                }
                return exp ;
              }
              public static void main(String[] args){
                new Main().run();
              }
            }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute AND : Sequence(String) := Sequence{"(0*0)","(0*1)","(0*2)","(1*0)","(1*1)","(1*2)","(2*0)","(2*1)","(2*2)"};
   attribute AND_RESULT : Sequence(String) := Sequence{"0","0","0","0","1","1","0","1","2"};
   attribute OR : Sequence(String) := Sequence{"(0+0)","(0+1)","(0+2)","(1+0)","(1+1)","(1+2)","(2+0)","(2+1)","(2+2)"};
   attribute OR_RESULT : Sequence(String) := Sequence{"0","1","2","1","1","2","2","2","2"};
   attribute INV : Sequence(String) := Sequence{"-0","-1","-2"};
   attribute INV_RESULT : Sequence(String) := Sequence{"2","1","0"};
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var exp : String ; exp := sc.getCurrent().replace("--", "") ;
     if (exp = ".") then (     break ) else skip ; 
    var count : int ; count := 0 ;
        var p : int ; p := 0 ; while p <= 2 do ( (         var q : int ; q := 0 ; while q <= 2 do ( (         var r : int ; r := 0 ; while r <= 2 do ( (     var tmp : String ; tmp := exp.replace("P", p + "") ;
     tmp := tmp.replace("Q", q + "") ; 
     tmp := tmp.replace("R", r + "") ; 
     if (calc(tmp) = "2") then (     count := count + 1 ) else skip )  ;     r := r + 1 ) )  ;     q := q + 1 ) )  ;     p := p + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
   operation calc( exp : String) : String
  pre: true
  post: true
  activity: (     while (exp->size() /= 1) do (         var i : int ; i := 0 ; while i < INV->size() do ( (     exp := exp.replace(INV[i+1], INV_RESULT[i+1]) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < AND->size() do ( (     exp := exp.replace(AND[i+1], AND_RESULT[i+1]) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < OR->size() do ( (     exp := exp.replace(OR[i+1], OR_RESULT[i+1]) )  ;     i := i + 1 ) ) ; 
     return exp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static char[] s ;
  static int index ;
  static int[] table ;
  static char c(){
    return s[index++];
  }
  static int formura(){
    int r=term();
    while(index<s.length){
      char c=c();
      if(c=='*'){
        int p=term();
        r=Math.min(r,p);
      }
      else if(c=='+'){
        int p=term();
        r=Math.max(r,p);
      }
      else break ;
    }
    return r ;
  }
  static int term(){
    char c=c();
    if(c=='('){
      int r=formura();
      return r ;
    }
    if(c=='-'){
      int r=term();
      return r==0 ? 2 : r==1 ? 1 : 0 ;
    }
    if(Character.isDigit(c))return c-'0' ;
    return table[c-'P'];
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      String str=sc.next();
      if(str.equals("."))break ;
      s=(str+"$").toCharArray();
      table=new int[3];
      int ans=0 ;
      for(int i=0 ; i<3 ; i++){
        table[0]=i ;
        for(int j=0 ; j<3 ; j++){
          table[1]=j ;
          for(int k=0 ; k<3 ; k++){
            table[2]=k ;
            index=0 ;
            ans+=formura()==2 ? 1 : 0 ;
          }
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : Sequence(String);
  static   attribute index : int;
  static   attribute table : Sequence(int);
  static   operation c() : String
  pre: true
  post: true
  activity: (     return s[index+1] );
  static   operation formura() : int
  pre: true
  post: true
  activity: (     var r : int ; r := term() ;
     while (index < s->size()) do (     var c : String ; c := c() ;
     if (c = '*') then (     var p : int ; p := term() ;
     r := Set{r, p}->min() ) else     if (c = '+') then (     var p : int ; p := term() ;
     r := Set{r, p}->max() ) else     break ;  ) ; 
     return r );
  static   operation term() : int
  pre: true
  post: true
  activity: (     var c : String ; c := c() ;
     if (c = '(') then (     var r : int ; r := formura() ;
     return r ) else skip ; 
    if (c = '-') then (     var r : int ; r := term() ;
     return if r = 0 then 2 else if r = 1 then 1 else 0 endif endif ) else skip ; 
    if ((c + "")->isMatch("[0-9]")) then     return (c)->char2byte() - ('0')->char2byte() else skip ; 
    return table[(c)->char2byte() - ('P')->char2byte()+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var str : String ; str := sc.getCurrent() ;
     if (str = ".") then     break else skip ; 
    s := (str + "$")->characters() ; 
    table := Integer.subrange(1,3)->collect(0) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     table[0+1] := i ; 
         var j : int ; j := 0 ; while j < 3 do ( (     table[1+1] := j ; 
         var k : int ; k := 0 ; while k < 3 do ( (     table[2+1] := k ; 
     index := 0 ; 
     ans := ans+(if formura() = 2 then 1 else 0 endif) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String iShortNeedle=sc.next();
    String iLongNeedle=sc.next();
    String h=sc.next();
    String m=sc.next();
    double hour=Double.parseDouble(h);
    double min=Double.parseDouble(m);
    double wholeMin=(hour*60)+min ;
    double shortNeedle=Double.parseDouble(iShortNeedle);
    double longNeedle=Double.parseDouble(iLongNeedle);
    double shortAngleByOneMin=(360.0/12.0)/60.0 ;
    double longAngleByOneMin=360.0/60.0 ;
    double rHour=0 ;
    double rMin=0 ;
    if(wholeMin!=0){
      rHour=shortAngleByOneMin*wholeMin ;
    }
    if(min!=0){
      rMin=longAngleByOneMin*min ;
    }
    double diffAngle=Math.abs(rHour-rMin);
    double aLength=0 ;
    if(diffAngle!=0 || diffAngle!=180){
      aLength=Math.sqrt(Math.pow(shortNeedle,2)+Math.pow(longNeedle,2)-2*shortNeedle*longNeedle*Math.cos(Math.toRadians(diffAngle)));
    }
    else if(diffAngle==0){
      aLength=longNeedle-shortNeedle ;
    }
    else if(diffAngle==180){
      aLength=longNeedle+shortNeedle ;
    }
    System.out.println(aLength);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var iShortNeedle : String ; iShortNeedle := sc.getCurrent() ;
    var iLongNeedle : String ; iLongNeedle := sc.getCurrent() ;
    var h : String ; h := sc.getCurrent() ;
    var m : String ; m := sc.getCurrent() ;
    var hour : double ; hour := (h)->toReal() ;
    var min : double ; min := (m)->toReal() ;
    var wholeMin : double ; wholeMin := (hour * 60) + min ;
    var shortNeedle : double ; shortNeedle := (iShortNeedle)->toReal() ;
    var longNeedle : double ; longNeedle := (iLongNeedle)->toReal() ;
    var shortAngleByOneMin : double ; shortAngleByOneMin := (360.0 / 12.0) / 60.0 ;
    var longAngleByOneMin : double ; longAngleByOneMin := 360.0 / 60.0 ;
    var rHour : double ; rHour := 0 ;
    var rMin : double ; rMin := 0 ;
    if (wholeMin /= 0) then (     rHour := shortAngleByOneMin * wholeMin ) else skip ; 
    if (min /= 0) then (     rMin := longAngleByOneMin * min ) else skip ; 
    var diffAngle : double ; diffAngle := if rHour - rMin < 0 then -(rHour - rMin) else rHour - rMin endif ;
    var aLength : double ; aLength := 0 ;
    if (diffAngle /= 0 or diffAngle /= 180) then (     aLength := (shortNeedle->pow(2) + longNeedle->pow(2) - 2 * shortNeedle * longNeedle * ((0.017453292519943295*(diffAngle)))->cos())->sqrt() ) else     if (diffAngle = 0) then (     aLength := longNeedle - shortNeedle ) else     if (diffAngle = 180) then (     aLength := longNeedle + shortNeedle ) else skip ; ;  ;  
    OclFile["System.out"].println(aLength) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static int pos ;
  private static int p ;
  private static int q ;
  private static int r ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      String input=sc.nextLine();
      if(input.equals("."))break ;
      int count=0 ;
      for(p=0 ; p<3 ; p++){
        for(q=0 ; q<3 ; q++){
          for(r=0 ; r<3 ; r++){
            pos=0 ;
            int ret=formula(input);
            if(ret==2)count++;
          }
        }
      }
      System.out.println(count);
    }
  }
  private static int formula(String input){
    char c=input.charAt(pos++);
    if(c=='0')return 0 ;
    if(c=='1')return 1 ;
    if(c=='2')return 2 ;
    if(c=='P')return p ;
    if(c=='Q')return q ;
    if(c=='R')return r ;
    if(c=='-'){
      int ret=formula(input);
      return(2-ret);
    }
    int n1=formula(input);
    boolean multi=(input.charAt(pos++)=='*');
    int n2=formula(input);
    pos++;
    if(multi){
      if(n1==n2)return n1 ;
      if(n1*n2>0)return 1 ;
      return 0 ;
    }
    else {
      return Math.max(n1,n2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute pos : int;
  static   attribute p : int;
  static   attribute q : int;
  static   attribute r : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var input : String ; input := sc.nextLine() ;
     if (input = ".") then     break else skip ; 
    var count : int ; count := 0 ;
        p := 0 ; while p < 3 do ( (         q := 0 ; while q < 3 do ( (         r := 0 ; while r < 3 do ( (     pos := 0 ; 
     var ret : int ; ret := formula(input) ;
     if (ret = 2) then     count := count + 1 ; else skip )  ;     r := r + 1 ) )  ;     q := q + 1 ) )  ;     p := p + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
  static   operation formula( input : String) : int
  pre: true
  post: true
  activity: (     var c : String ; c := input->at(pos+1) ;
     if (c = '0') then     return 0 else skip ; 
    if (c = '1') then     return 1 else skip ; 
    if (c = '2') then     return 2 else skip ; 
    if (c = 'P') then     return p else skip ; 
    if (c = 'Q') then     return q else skip ; 
    if (c = 'R') then     return r else skip ; 
    if (c = '-') then (     var ret : int ; ret := formula(input) ;
     return (2 - (ret)->char2byte()) ) else skip ; 
    var n1 : int ; n1 := formula(input) ;
    var multi : boolean ; multi := (input->at(pos+1) = '*') ;
    var n2 : int ; n2 := formula(input) ;
    pos := pos + 1 ; 
    if (multi) then (     if (n1 = n2) then     return n1 else skip ; 
     if (n1 * n2 > 0) then     return 1 else skip ; 
     return 0 ) else (     return Set{n1, n2}->max() ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void printBracketNumber(String exp,int n){
    int left_bnum=1 ;
    Stack<Integer>right_bnum=new Stack<Integer>();
    for(int i=0 ; i<n ; i++){
      if(exp.charAt(i)=='('){
        System.out.print(left_bnum+" ");
        right_bnum.push(left_bnum);
        left_bnum++;
      }
      else if(exp.charAt(i)==')'){
        System.out.print(right_bnum.peek()+" ");
        right_bnum.pop();
      }
    }
  }
  public static void main(String args[]){
    String exp="(a+(b*c))+(d/e)" ;
    int n=exp.length();
    printBracketNumber(exp,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printBracketNumber( exp : String, n : int) : void
  pre: true
  post: true
  activity: (     var left_bnum : int ; left_bnum := 1 ;
     var right_bnum : Sequence(int) ; right_bnum := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (exp->at(i+1) = '(') then (     OclFile["System.out"].print(left_bnum + " ") ; 
     right_bnum := right_bnum->append(left_bnum) ; 
     left_bnum := left_bnum + 1 ) else     if (exp->at(i+1) = ')') then (     OclFile["System.out"].print(right_bnum->min() + " ") ; 
     right_bnum := right_bnum->front() ) else skip ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var exp : String ; exp := "(a+(b*c))+(d/e)" ;
     var n : int ; n := exp->size() ;
     execute printBracketNumber(exp, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minXOR(int arr[],int n){
    int min_xor=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++)min_xor=Math.min(min_xor,arr[i] ^ arr[j]);
    return min_xor ;
  }
  public static void main(String args[]){
    int arr[]={
      9,5,3 };
      int n=arr.length ;
      System.out.println(minXOR(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minXOR( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var min_xor : int ; min_xor := 2147483647 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do (     min_xor := Set{min_xor, arr[i+1] xor arr[j+1]}->min() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return min_xor );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{9,5,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minXOR(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p041 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p041().run());
  }
  public String run(){
    for(int n=9 ; n>=1 ; n--){
      int[] digits=new int[n];
      for(int i=0 ; i<digits.length ; i++)digits[i]=i+1 ;
      int result=-1 ;
      do {
        if(Library.isPrime(toInteger(digits)))result=toInteger(digits);
      }
      while(Library.nextPermutation(digits));
      if(result!=-1)return Integer.toString(result);
    }
    throw new RuntimeException("Not found");
  }
  private static int toInteger(int[] digits){
    int result=0 ;
    for(int x : digits)result=result*10+x ;
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p041 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p041.newp041().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (         var n : int ; n := 9 ; while n >= 1 do ( (     var digits : Sequence(int) ; digits := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < digits->size() do (     digits[i+1] := i + 1 ;  ;     i := i + 1 ) ; 
    var result : int ; result := -1 ;
  while true do ((     if (Library.isPrime(toInteger(digits))) then     result := toInteger(digits) ; else skip ) ;
    if (Library.nextPermutation(digits)) then skip else break) ; 
    if (result /= -1) then     return ((result) + "") else skip ; 
 )  ;     n := n - 1 ) ; 
     error ProgramException("Not found") );
  static   operation toInteger( digits : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     for (x : digits) do (     result := result * 10 + x ;  ) ; 
     return result );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPalindrome(String r){
    String p=r ;
    p=reverse(p);
    return(r.equals(p));
  }
  static String PrefixSuffixPalindrome(String str){
    int n=str.length(),len=0 ;
    for(int i=0 ; i<n/2 ; i++){
      if(str.charAt(i)!=str.charAt(n-i-1)){
        len=i ;
        break ;
      }
    }
    String prefix="",suffix="" ;
    String midPal="" ;
    prefix=str.substring(0,len);
    suffix=str.substring(n-len);
    str=str.substring(len,(n-2*len)+len);
    for(int i=1 ; i<=str.length(); i++){
      String y=str.substring(0,i);
      if(isPalindrome(y)){
        if(midPal.length()<y.length()){
          midPal=y ;
        }
      }
    }
    for(int i=1 ; i<=str.length(); i++){
      String y=str.substring(str.length()-i);
      if(isPalindrome(y)){
        if(midPal.length()<y.length()){
          midPal=y ;
        }
      }
    }
    String answer=prefix+midPal+suffix ;
    return answer ;
  }
  static String reverse(String input){
    char[] a=input.toCharArray();
    int l,r=a.length-1 ;
    for(l=0 ; l<r ; l++,r--){
      char temp=a[l];
      a[l]=a[r];
      a[r]=temp ;
    }
    return String.valueOf(a);
  }
  public static void main(String[] args){
    String str="abcdfdcecba" ;
    System.out.print(PrefixSuffixPalindrome(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPalindrome( r : String) : boolean
  pre: true
  post: true
  activity: (     var p : String ; p := r ;
     p := reverse(p) ; 
     return (r = p) );
  static   operation PrefixSuffixPalindrome( str : String) : String
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
    var len : int ; len := 0 ;
         var i : int ; i := 0 ; while i < n / 2 do ( (     if (str->at(i+1) /= str->at((n)->char2byte() - i - 1+1)) then (     len := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var prefix : String ; prefix := "" ;
    var suffix : String ; suffix := "" ;
    var midPal : String ; midPal := "" ;
    prefix := str.subrange(0+1,len) ; 
    suffix := str.subrange((n)->char2byte() - (len)->char2byte()+1,(n)->char2byte() - (len)->char2byte()) ; 
    str := str.subrange(len+1,((n)->char2byte() - 2 * len) + len) ; 
        var i : int ; i := 1 ; while i <= str->size() do ( (     var y : String ; y := str.subrange(0+1,i) ;
     if (isPalindrome(y)) then (     if (midPal->size() < y->size()) then (     midPal := y ) else skip ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= str->size() do ( (     var y : String ; y := str.subrange(str->size() - (i)->char2byte()+1,str->size() - (i)->char2byte()) ;
     if (isPalindrome(y)) then (     if (midPal->size() < y->size()) then (     midPal := y ) else skip ) else skip )  ;     i := i + 1 ) ; 
    var answer : String ; answer := prefix + midPal + suffix ;
    return answer 
 );
  static   operation reverse( input : String) : String
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := input->characters() ;
     var l : int ;
    var r : int ; r := a->size() - 1 ;
         l := 0 ; while l < r do ( (     var temp : String ; temp := a[l+1] ;
     a[l+1] := a[r+1] ; 
     a[r+1] := temp )  ;     l := l + 1 ;     r := r - 1 ) ; 
     return (a)->sum()  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abcdfdcecba" ;
     OclFile["System.out"].print(PrefixSuffixPalindrome(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double solve(int s){
    double area=(1.732*Math.pow(s,2))/8 ;
    return area ;
  }
  public static void main(String[] args){
    int n=14 ;
    System.out.println(solve(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( s : int) : double
  pre: true
  post: true
  activity: (     var area : double ; area := (1.732 * s->pow(2)) / 8 ;
     return area );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 14 ;
     OclFile["System.out"].println(solve(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isDivisible(long n){
    while(n/100!=0){
      long d=n % 10 ;
      n/=10 ;
      n+=d*7 ;
    }
    return(n % 23==0);
  }
  public static void main(String[] args){
    long n=1191216 ;
    if(isDivisible(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isDivisible( n : long) : boolean
  pre: true
  post: true
  activity: (     while (n / 100 /= 0) do (     var d : long ; d := n mod 10 ;
     n := n/(10) ; 
     n := n+(d * 7) ) ; 
     return (n mod 23 = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 1191216 ;
     if (isDivisible(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  static void checkSquare(String s1,String s2){
    int c=Integer.valueOf(s1+s2);
    int d=(int)Math.sqrt(c);
    if(d*d==c){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
  public static void main(String[] args){
    String s1="12" ;
    String s2="1" ;
    checkSquare(s1,s2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkSquare( s1 : String, s2 : String) : void
  pre: true
  post: true
  activity: (     var c : int ; c := (s1 + s2)->toInteger() ;
     var d : int ; d := (c)->sqrt()->oclAsType(int) ;
     if (d * d = c) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "12" ;
     var s2 : String ; s2 := "1" ;
     execute checkSquare(s1, s2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int size=scn.nextInt();
    int[] arr=new int[size];
    for(int i=0 ; i<size ; i++){
      arr[i]=scn.nextInt();
    }
    System.out.println(asd(arr));
  }
  public static String asd(int[] arr){
    int winner=1 ;
    int max=arr[0];
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]>max){
        max=arr[i];
        winner=i+1 ;
      }
    }
    Arrays.sort(arr);
    int res=arr[arr.length-2];
    return winner+" "+res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var size : int ; size := scn.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < size do ( (     arr[i+1] := scn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(asd(arr)) ; 
 );
  static   operation asd( arr : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var winner : int ; winner := 1 ;
     var max : int ; max := arr[0+1] ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] > max) then (     max := arr[i+1] ; 
     winner := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var res : int ; res := arr[arr->size() - 2+1] ;
    return winner + " " + res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.*;
public class MainClass {
  private static BufferedReader br=null ;
  private static StringTokenizer st=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  private static String str()throws IOException {
    return br.readLine();
  }
  private static int ints()throws IOException {
    return Integer.parseInt(br.readLine());
  }
  private static int[] ints(int N)throws IOException {
    st=new StringTokenizer(br.readLine());
    int[] nums=new int[N];
    for(int i=0 ; i<N ; i+=1){
      nums[i]=Integer.parseInt(st.nextToken());
    }
    return nums ;
  }
  public static void main(String[] args)throws IOException {
    int N=ints();
    int[] prices=ints(N);
    Solution obj=new Solution();
    int[] ans=obj.secondPriceAuction(prices,N);
    System.out.println(ans[0]+" "+ans[1]);
    br.close();
  }
}
class Solution {
  public int[] secondPriceAuction(int[] prices,int N){
    PriorityQueue<int[]>max=new PriorityQueue<>((a,b)->b[1]-a[1]);
    for(int i=0 ; i<N ; i+=1){
      max.add(new int[] {
        i+1,prices[i] }
);
      }
      int index=max.poll()[0];
      return new int[] {
        index,max.poll()[1] };
      }
    }

------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   attribute br : OclFile := null;
  static   attribute st : OclIterator := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation str() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
  static   operation ints() : int
  pre: true
  post: true
  activity: (     return (br.readLine())->toInteger() );
  static   operation ints( N : int) : Sequence(int)
  pre: true
  post: true
  activity: (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var nums : Sequence(int) ; nums := Integer.subrange(1,N)->collect(0) ;
         var i : int ; i := 0 ; while i < N do ( (     nums[i+1] := (st.next())->toInteger() )  ;     i := i+(1) ) ; 
     return nums );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := ints() ;
     var prices : Sequence(int) ; prices := ints(N) ;
    var obj : Solution ; obj := Solution.newSolution() ;
    var ans : Sequence(int) ; ans := obj.secondPriceAuction(prices, N) ;
    OclFile["System.out"].println(ans[0+1] + " " + ans[1+1]) ; 
    skip ; 
 );
}
class Solution {
   operation secondPriceAuction( prices : Sequence(int), N : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var max : Sequence(Sequence(int)) ; max := Sequence{}->union(lambda (a , b) : OclAny in b[1+1] - a[1+1]) ;
         var i : int ; i := 0 ; while i < N do ( (     max := max->including(Sequence{i + 1,prices[i+1]}) )  ;     i := i+(1) ) ; 
     var index : int ; index := max->min()[0+1] ;
     return Sequence{index,max->min()[1+1]} );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    int h=Integer.parseInt(sc.next());
    int m=Integer.parseInt(sc.next());
    sc.close();
    double hour=(h % 12*30)+(m*0.5);
    double minute=m*6 ;
    double kakudo=Math.max(hour,minute)-Math.min(hour,minute);
    if(180<kakudo){
      kakudo=360-kakudo ;
    }
    double numA=Math.pow(a,2);
    double numB=Math.pow(b,2);
    double numC=2*a*b*Math.cos(Math.toRadians(kakudo));
    double result=Math.sqrt(numA+numB-numC);
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := (sc.getCurrent())->toInteger() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    var h : int ; h := (sc.getCurrent())->toInteger() ;
    var m : int ; m := (sc.getCurrent())->toInteger() ;
    skip ; 
    var hour : double ; hour := (h mod 12 * 30) + (m * 0.5) ;
    var minute : double ; minute := m * 6 ;
    var kakudo : double ; kakudo := Set{hour, minute}->max() - Set{hour, minute}->min() ;
    if (180 < kakudo) then (     kakudo := 360 - kakudo ) else skip ; 
    var numA : double ; numA := a->pow(2) ;
    var numB : double ; numB := b->pow(2) ;
    var numC : double ; numC := 2 * a * b * ((0.017453292519943295*(kakudo)))->cos() ;
    var result : double ; result := (numA + numB - numC)->sqrt() ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Stairs {
  private static Scanner s=new Scanner(System.in);
  private static void findNiceStairs(){
    long x=s.nextLong();
    long niceStairs=1 ;
    long currentNumberOfCells=1 ;
    long ans=0 ;
    while(x>=currentNumberOfCells){
      x-=currentNumberOfCells ;
      ans++;
      niceStairs=niceStairs*2+1 ;
      currentNumberOfCells=(niceStairs*(niceStairs+1)/2);
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    int t=s.nextInt();
    while(t-->0){
      findNiceStairs();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Stairs {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation findNiceStairs() : void
  pre: true
  post: true
  activity: (     var x : long ; x := s.getCurrent()->toLong() ;
     var niceStairs : long ; niceStairs := 1 ;
    var currentNumberOfCells : long ; currentNumberOfCells := 1 ;
    var ans : long ; ans := 0 ;
    while (x >= currentNumberOfCells) do (     x := x-(currentNumberOfCells) ; 
     ans := ans + 1 ; 
     niceStairs := niceStairs * 2 + 1 ; 
     currentNumberOfCells := (niceStairs * (niceStairs + 1) / 2) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute findNiceStairs() ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int pivotIndex(int[] nums){
    int totalsum=0,leftsum=0 ;
    for(int i=0 ; i<nums.length ; i++)totalsum+=nums[i];
    for(int i=0 ; i<nums.length ; i++){
      if(leftsum==totalsum-leftsum-nums[i])return i ;
      leftsum+=nums[i];
    }
    return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation pivotIndex( nums : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var totalsum : int ; totalsum := 0 ;
    var leftsum : int ; leftsum := 0 ;
         var i : int ; i := 0 ; while i < nums->size() do (     totalsum := totalsum+(nums[i+1]) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < nums->size() do ( (     if (leftsum = totalsum - leftsum - nums[i+1]) then     return i else skip ; 
     leftsum := leftsum+(nums[i+1]) )  ;     i := i + 1 ) ; 
     return -1 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static long ispowerof2(long num){
    if((num &(num-1))==0)return 1 ;
    return 0 ;
  }
  public static void main(String[] args){
    long num=549755813888L ;
    System.out.println(ispowerof2(num));
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation ispowerof2( num : long) : long
  pre: true
  post: true
  activity: (     if ((num & (num - 1)) = 0) then     return 1 else skip ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : long ; num := 549755813888L ;
     OclFile["System.out"].println(ispowerof2(num)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int count ;
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int arr[]=new int[1000000];
    for(int i=0 ; i<n ; i++){
      arr[i]=scan.nextInt();
    }
    shellSort(arr,n);
    printArray(arr,n);
  }
  public void insertSort(int arr[],int n,int g){
    for(int i=g ; i<n ; i++){
      int v=arr[i];
      int j=i-g ;
      while(j>=0 && arr[j]>v){
        arr[j+g]=arr[j];
        j=j-g ;
        count++;
      }
      arr[j+g]=v ;
    }
  }
  public void shellSort(int arr[],int n){
    count=0 ;
    int i,j,m ;
    int G[]=new int[100];
    if(n<3){
      G[0]=n ;
      G[1]=n-1 ;
      G[2]=1 ;
      m=n ;
    }
    else {
      j=0 ;
      for(i=1 ; i<n ; i=i*3+1){
        G[j++]=i ;
      }
      m=j ;
    }
    System.out.println(m);
    for(i=m-1 ; i>=1 ; i--){
      System.out.print(G[i]+" ");
    }
    System.out.println(G[i]);
    for(i=m-1 ; i>=0 ; i--){
      insertSort(arr,n,G[i]);
    }
    System.out.println(count);
  }
  public static void printArray(int arr[],int n){
    int i ;
    for(i=0 ; i<n ; i++){
      System.out.println(arr[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute count : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,1000000)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute shellSort(arr, n) ; 
    execute printArray(arr, n) ; 
 );
   operation insertSort( arr : Sequence(int), n : int, g : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := g ; while i < n do ( (     var v : int ; v := arr[i+1] ;
     var j : int ; j := i - g ;
     while (j >= 0 & arr[j+1] > v) do (     arr[j + g+1] := arr[j+1] ; 
     j := j - g ; 
     count := count + 1 ) ; 
     arr[j + g+1] := v )  ;     i := i + 1 ) );
   operation shellSort( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     count := 0 ; 
     var i : int ;
    var j : int ;
    var m : int ;
    var G : Sequence(int) ; G := Integer.subrange(1,100)->collect(0) ;
    if (n < 3) then (     G[0+1] := n ; 
     G[1+1] := n - 1 ; 
     G[2+1] := 1 ; 
     m := n ) else (     j := 0 ; 
         i := 1 ; while i < n do ( (      G[j+1] := i  ; j := j + 1 )  ;     i := i * 3 + 1 ) ; 
     m := j ) ;  
    OclFile["System.out"].println(m) ; 
        i := m - 1 ; while i >= 1 do ( (     OclFile["System.out"].print(G[i+1] + " ") )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(G[i+1]) ; 
        i := m - 1 ; while i >= 0 do ( (     execute insertSort(arr, n, G[i+1]) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation printArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
         i := 0 ; while i < n do ( (     OclFile["System.out"].println(arr[i+1]) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  static PrintStream out=System.out ;
  static Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    int n=in.nextInt();
    int[] A=new int[n];
    for(int i=0 ; i<n ; i++){
      A[i]=in.nextInt();
    }
    shellSort(A,n);
  }
  public static int insertionSort(int[] A,int n,int g,int cnt){
    for(int i=g ; i<n ; i++){
      int v=A[i];
      int j=i-g ;
      while(j>=0 && A[j]>v){
        A[j+g]=A[j];
        j=j-g ;
        cnt++;
      }
      A[j+g]=v ;
    }
    return cnt ;
  }
  public static void shellSort(int[] A,int n){
    int cnt=0 ;
    int m=1 ;
    for(int tmp=1 ; m<n ; m++){
      tmp=tmp*3+1 ;
      if(n<tmp)break ;
    }
    int[] G=new int[m];
    G[m-1]=1 ;
    for(int i=m-2 ; i>=0 ; i--){
      G[i]=G[i+1]*3+1 ;
    }
    for(int i=0 ; i<m ; i++){
      cnt=insertionSort(A,n,G[i],cnt);
    }
    out.println(m);
    StringBuilder sb=new StringBuilder();
    for(int x : G){
      sb.append(x).append(' ');
    }
    out.println(sb.toString().trim());
    out.println(cnt);
    for(int x : A){
      out.println(x);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile["System.out"];
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var A : Sequence(int) ; A := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     A[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     execute shellSort(A, n) );
  static   operation insertionSort( A : Sequence(int), n : int, g : int, cnt : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := g ; while i < n do ( (     var v : int ; v := A[i+1] ;
     var j : int ; j := i - g ;
     while (j >= 0 & A[j+1] > v) do (     A[j + g+1] := A[j+1] ; 
     j := j - g ; 
     cnt := cnt + 1 ) ; 
     A[j + g+1] := v )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation shellSort( A : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var m : int ; m := 1 ;
        var tmp : int ; tmp := 1 ; while m < n do ( (     tmp := tmp * 3 + 1 ; 
     if (n < tmp) then     break else skip )  ;     m := m + 1 ) ; 
    var G : Sequence(int) ; G := Integer.subrange(1,m)->collect(0) ;
    G[m - 1+1] := 1 ; 
        var i : int ; i := m - 2 ; while i >= 0 do ( (     G[i+1] := G[i + 1+1] * 3 + 1 )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     cnt := insertionSort(A, n, G[i+1], cnt) )  ;     i := i + 1 ) ; 
    skip ; 
    var sb : String ; sb := StringLib.newString() ;
    for (x : G) do ( (     sb := sb + StringLib.newString(x) + StringLib.newString(' ') )  ) ; 
    skip ; 
    skip ; 
    for (x : A) do ( (     skip )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class Main {
  private List<Integer>G=new ArrayList<Integer>();
  private int cnt=0 ;
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(reader.readLine());
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(reader.readLine());
    }
    reader.close();
    shellSort(a,n);
    System.out.println(G.size());
    for(int i=G.size()-1 ; i>=0 ; i--){
      System.out.print(G.get(i));
      if(i!=0)System.out.print(" ");
    }
    System.out.println();
    System.out.println(cnt);
    for(int i=0 ; i<n ; i++){
      System.out.println(a[i]);
    }
  }
  private void shellSort(int[] a,int n){
    int h=1 ;
    while(h<=n){
      G.add(h);
      h=h*3+1 ;
    }
    for(int i=G.size()-1 ; i>=0 ; i--){
      insertionSort(a,n,G.get(i));
    }
  }
  private void insertionSort(int[] a,int n,int g){
    for(int i=g ; i<n ; i++){
      int v=a[i];
      int j=i-g ;
      while(j>=0 && a[j]>v){
        a[j+g]=a[j];
        j-=g ;
        cnt+=1 ;
      }
      a[j+g]=v ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute G : Sequence(int) := Sequence{};
   attribute cnt : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (reader.readLine())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (reader.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    execute shellSort(a, n) ; 
    OclFile["System.out"].println(G->size()) ; 
        var i : int ; i := G->size() - 1 ; while i >= 0 do ( (     OclFile["System.out"].print(G->at(i+1)) ; 
     if (i /= 0) then     OclFile["System.out"].print(" ") ; else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println() ; 
    OclFile["System.out"].println(cnt) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(a[i+1]) )  ;     i := i + 1 ) ; 
 );
   operation shellSort( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var h : int ; h := 1 ;
     while (h <= n) do (     G := G->including(h) ; 
     h := h * 3 + 1 ) ; 
         var i : int ; i := G->size() - 1 ; while i >= 0 do ( (     execute insertionSort(a, n, G->at(i+1)) )  ;     i := i - 1 ) );
   operation insertionSort( a : Sequence(int), n : int, g : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := g ; while i < n do ( (     var v : int ; v := a[i+1] ;
     var j : int ; j := i - g ;
     while (j >= 0 & a[j+1] > v) do (     a[j + g+1] := a[j+1] ; 
     j := j-(g) ; 
     cnt := cnt+(1) ) ; 
     a[j + g+1] := v )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    try {
      int lim=Integer.parseInt(in.readLine());
      int[] a=new int[lim];
      for(int i=0 ; i<lim ; i++){
        a[i]=Integer.parseInt(in.readLine());
      }
      int cnt=0 ;
      int m=(int)Math.sqrt(lim);
      if(m>100)m=100 ;
      int[] g=new int[m];
      for(int i=0 ; i<m ; i++){
        g[i]=(m-i)*(m-i);
      }
      for(int k=0 ; k<m ; k++){
        for(int i=g[k]; i<a.length ; i++){
          int v=a[i];
          int j=i-g[k];
          while((j>=0)&&(a[j]>v)){
            a[j+g[k] ]=a[j];
            j=j-g[k];
            cnt++;
          }
          a[j+g[k] ]=v ;
        }
      }
      System.out.println(m);
      System.out.print(g[0]);
      for(int i=1 ; i<g.length ; i++){
        System.out.print(" "+g[i]);
      }
      System.out.println();
      System.out.println(cnt);
      for(int i=0 ; i<a.length ; i++){
        System.out.println(a[i]);
      }
    }
    catch(NumberFormatException e){
      e.printStackTrace();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var lim : int ; lim := (in.readLine())->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,lim)->collect(0) ;
        var i : int ; i := 0 ; while i < lim do ( (     a[i+1] := (in.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    var m : int ; m := (lim)->sqrt()->oclAsType(int) ;
    if (m > 100) then     m := 100 ; else skip ; 
    var g : Sequence(int) ; g := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     g[i+1] := (m - i) * (m - i) )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < m do ( (         var i : int ; i := g[k+1] ; while i < a->size() do ( (     var v : int ; v := a[i+1] ;
     var j : int ; j := i - g[k+1] ;
     while ((j >= 0) & (a[j+1] > v)) do (     a[j + g[k+1]+1] := a[j+1] ; 
     j := j - g[k+1] ; 
     cnt := cnt + 1 ) ; 
     a[j + g[k+1]+1] := v )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(m) ; 
    OclFile["System.out"].print(g[0+1]) ; 
        var i : int ; i := 1 ; while i < g->size() do ( (     OclFile["System.out"].print(" " + g[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    OclFile["System.out"].println(cnt) ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     OclFile["System.out"].println(a[i+1]) )  ;     i := i + 1 ) ; 
 )   catch (e : IncorrectElementException) do (     e.printStackTrace() )
   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isDivisible(long n){
    while(n/100!=0){
      int d=(int)(n % 10);
      n/=10 ;
      n-=d*4 ;
    }
    return(n % 41==0);
  }
  public static void main(String[] args){
    long n=104413920565933L ;
    if(isDivisible(n)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isDivisible( n : long) : boolean
  pre: true
  post: true
  activity: (     while (n / 100 /= 0) do (     var d : int ; d := (n mod 10)->oclAsType(int) ;
     n := n/(10) ; 
     n := n-(d * 4) ) ; 
     return (n mod 41 = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 104413920565933L ;
     if (isDivisible(n)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  static StringBuilder builder=new StringBuilder();
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    final int n=Integer.parseInt(reader.readLine());
    final int[] a=new int[n];
    for(int i=0 ; i<n ; ++i){
      a[i]=Integer.parseInt(reader.readLine());
    }
    shellSort(a,n);
    for(int i=0 ; i<n ; ++i){
      builder.append(a[i]).append("\n");
    }
    System.out.print(builder);
  }
  private static void shellSort(int[] a,int n){
    ArrayList<Integer>nums=new ArrayList<Integer>();
    int m=0 ;
    for(int i=1 ; i<=n ; i=i*3+1){
      nums.add(m,i);
      m++;
    }
    builder.append(m).append("\n");
    m--;
    int cnt=0 ;
    for(int i=m ; i>=0 ; i--){
      if(i!=m)builder.append(" ");
      builder.append(nums.get(i));
      cnt+=insertionSort(a,n,nums.get(i));
    }
    builder.append("\n").append(cnt).append("\n");
  }
  private static int insertionSort(int[] a,int n,int g){
    int cnt=0 ;
    for(int i=g ; i<n ; ++i){
      final int key=a[i];
      int j=i-g ;
      while(j>=0 && a[j]>key){
        a[j+g]=a[j];
        j=j-g ;
        cnt++;
      }
      a[j+g]=key ;
    }
    return cnt ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute builder : String := StringLib.newString();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (reader.readLine())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (reader.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    execute shellSort(a, n) ; 
        var i : int ; i := 0 ; while i < n do ( (     builder := builder + StringLib.newString(a[i+1]) + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(builder) ; 
 );
  static   operation shellSort( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var nums : Sequence(int) ; nums := Sequence{} ;
     var m : int ; m := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     nums := nums.insertAt(m+1,i) ; 
     m := m + 1 )  ;     i := i * 3 + 1 ) ; 
    builder := builder + StringLib.newString(m) + StringLib.newString("\n") ; 
    m := m - 1 ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := m ; while i >= 0 do ( (     if (i /= m) then     builder := builder + StringLib.newString(" ") ; else skip ; 
     builder := builder + StringLib.newString(nums->at(i+1)) ; 
     cnt := cnt+(insertionSort(a, n, nums->at(i+1))) )  ;     i := i - 1 ) ; 
    builder := builder + StringLib.newString("\n") + StringLib.newString(cnt) + StringLib.newString("\n") ; 
 );
  static   operation insertionSort( a : Sequence(int), n : int, g : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := g ; while i < n do ( (     var key : int ; key := a[i+1] ;
     var j : int ; j := i - g ;
     while (j >= 0 & a[j+1] > key) do (     a[j + g+1] := a[j+1] ; 
     j := j - g ; 
     cnt := cnt + 1 ) ; 
     a[j + g+1] := key )  ;     i := i + 1 ) ; 
     return cnt );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int findMinSum(int arr[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=arr[i]*(n-i);
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      3,5,7,8 };
      int n=arr.length ;
      System.out.println(findMinSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation findMinSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+(arr[i+1] * (n - i)) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,5,7,8} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMinSum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void sieve(boolean[] prime,int n){
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=n ; p++){
      if(prime[p]==true){
        for(int i=p*p ; i<=n ; i+=p)prime[i]=false ;
      }
    }
  }
  static int sumPrime(int d){
    int i ;
    int maxVal=(int)Math.pow(10,d)-1 ;
    boolean prime[]=new boolean[maxVal+1];
    for(i=0 ; i<maxVal+1 ; i++)prime[i]=true ;
    sieve(prime,maxVal);
    int sum=0 ;
    for(i=2 ; i<=maxVal ; i++){
      if(prime[i]){
        sum+=i ;
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int d=3 ;
    System.out.println(sumPrime(d));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sieve( prime : Sequence(boolean), n : int) : void
  pre: true
  post: true
  activity: (     prime[0+1] := false ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p <= n do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * p ; while i <= n do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation sumPrime( d : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
     var maxVal : int ; maxVal := 10->pow(d)->oclAsType(int) - 1 ;
    var prime : Sequence(boolean) ; prime := Integer.subrange(1,maxVal + 1)->collect(false) ;
        i := 0 ; while i < maxVal + 1 do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
    execute sieve(prime, maxVal) ; 
    var sum : int ; sum := 0 ;
        i := 2 ; while i <= maxVal do ( (     if (prime[i+1]) then (     sum := sum+(i) ) else skip )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : int ; d := 3 ;
     OclFile["System.out"].println(sumPrime(d)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int findMinSum(int arr[],int n){
    int occ=n-1,sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=arr[i]*(int)Math.pow(2,occ);
      occ--;
    }
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,4,5 };
      int n=arr.length ;
      System.out.println(findMinSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation findMinSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var occ : int ; occ := n - 1 ;
    var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(arr[i+1] * 2->pow(occ)->oclAsType(int)) ; 
     occ := occ - 1 )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,4,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMinSum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      int fin=scan.nextInt();
      if(fin<=0){
        break ;
      }
      int[] num=new int[fin];
      for(int i=0 ; i<fin ; i++){
        num[i]=scan.nextInt();
      }
      int max=Integer.MIN_VALUE ;
      for(int i=0 ; i<fin ; i++){
        int[] plus=new int[fin];
        for(int j=0 ; j<fin-i ; j++){
          if(j==0){
            plus[j]=num[i];
          }
          else {
            plus[j]=plus[j-1]+num[j+i];
          }
          if(plus[j]>max){
            max=plus[j];
          }
        }
      }
      System.out.println(max);
      continue ;
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var fin : int ; fin := scan.getCurrent()->toInteger() ;
     if (fin <= 0) then (     break ) else skip ; 
    var num : Sequence(int) ; num := Integer.subrange(1,fin)->collect(0) ;
        var i : int ; i := 0 ; while i < fin do ( (     num[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
        var i : int ; i := 0 ; while i < fin do ( (     var plus : Sequence(int) ; plus := Integer.subrange(1,fin)->collect(0) ;
         var j : int ; j := 0 ; while j < fin - i do ( (     if (j = 0) then (     plus[j+1] := num[i+1] ) else (     plus[j+1] := plus[j - 1+1] + num[j + i+1] ) ;  
     if (plus[j+1] > max) then (     max := plus[j+1] ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
    continue 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Integer.MIN_VALUE ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    while(input.ready()){
      int setCount=Integer.valueOf(input.readLine());
      if(setCount==0)break ;
      ArrayList<Integer>dataSet=new ArrayList<>();
      for(int i=0 ; i<setCount ; i++){
        dataSet.add(Integer.valueOf(input.readLine()));
      }
      int ans=MIN_VALUE ;
      for(int i=0 ; i<setCount ; i++){
        int tmp=0 ;
        for(int j=i ; j<setCount ; j++){
          tmp+=dataSet.get(j);
          if(tmp>ans)ans=tmp ;
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (input.canRead()) do (     var setCount : int ; setCount := (input.readLine())->toInteger() ;
     if (setCount = 0) then     break else skip ; 
    var dataSet : Sequence(int) ; dataSet := Sequence{} ;
        var i : int ; i := 0 ; while i < setCount do ( (     dataSet := dataSet->including((input.readLine())->toInteger()) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := MIN_VALUE ;
        var i : int ; i := 0 ; while i < setCount do ( (     var tmp : int ; tmp := 0 ;
         var j : int ; j := i ; while j < setCount do ( (     tmp := tmp+(dataSet->at(j+1)) ; 
     if (tmp > ans) then     ans := tmp ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      ArrayList<Integer>sumList ;
      int tmp ;
      while(true){
        int n=Integer.parseInt(br.readLine());
        if(n==0){
          System.exit(0);
        }
        tmp=0 ;
        sumList=new ArrayList<>();
        sumList.add(0);
        for(int i=0 ; i<n ; i++){
          tmp+=Integer.parseInt(br.readLine());
          sumList.add(tmp);
        }
        int sum ;
        int max=-100000*5000 ;
        for(int i=0 ; i<sumList.size()-1 ; i++){
          for(int j=i+1 ; j<sumList.size(); j++){
            sum=sumList.get(j)-sumList.get(i);
            max=sum>max ? sum : max ;
          }
        }
        System.out.println(max);
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var sumList : Sequence(int) ;
     var tmp : int ;
     while (true) do (     var n : int ; n := (br.readLine())->toInteger() ;
     if (n = 0) then ( OclProcess.exit(0) ) else skip ; 
    tmp := 0 ; 
    sumList := Sequence{} ; 
    sumList := sumList->including(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     tmp := tmp+((br.readLine())->toInteger()) ; 
     sumList := sumList->including(tmp) )  ;     i := i + 1 ) ; 
    var sum : int ;
    var max : int ; max := -100000 * 5000 ;
        var i : int ; i := 0 ; while i < sumList->size() - 1 do ( (         var j : int ; j := i + 1 ; while j < sumList->size() do ( (     sum := sumList->at(j+1) - sumList->at(i+1) ; 
     max := if sum > max then sum else max endif )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    int nNum=0 ;
    int nTmp=0 ;
    int nSum=0 ;
    int nMax=0 ;
    while((nNum=getNum())!=0){
      nSum=getNum();
      nMax=nSum ;
      for(int n=1 ; n<nNum ; n++){
        nTmp=getNum();
        nSum=Math.max(nSum+nTmp,nTmp);
        nMax=Math.max(nSum,nMax);
      }
      System.out.println(nMax);
    }
  }
  private static int getNum(){
    return Integer.parseInt(parseStdin());
  }
  private static String parseStdin(){
    String strNum=null ;
    try {
      String line=br.readLine();
      if(line!=null){
        if(! line.isEmpty()){
          strNum=line ;
        }
      }
    }
    catch(IOException e){
    }
    return strNum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var nNum : int ; nNum := 0 ;
     var nTmp : int ; nTmp := 0 ;
    var nSum : int ; nSum := 0 ;
    var nMax : int ; nMax := 0 ;
        nNum := getNum() ;
    while ((nNum) /= 0) do (    skip ; (     nSum := getNum() ; 
     nMax := nSum ; 
         var n : int ; n := 1 ; while n < nNum do ( (     nTmp := getNum() ; 
     nSum := Set{nSum + nTmp, nTmp}->max() ; 
     nMax := Set{nSum, nMax}->max() )  ;     n := n + 1 ) ; 
     OclFile["System.out"].println(nMax) ) ;     nNum := getNum() ;
 ) ;  
 );
  static   operation getNum() : int
  pre: true
  post: true
  activity: (     return (parseStdin())->toInteger() );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var strNum : String ; strNum := null ;
     try (     var line : String ; line := br.readLine() ;
     if (line /= null) then (     if (not(line->isEmpty())) then (     strNum := line ) else skip ) else skip )   catch (e : IOException) do skip
     return strNum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static void solve(int n,ArrayList<Integer>data){
    ArrayList<Integer>max=new ArrayList<Integer>();
    max.add(data.get(0));
    for(int i=1 ; i<n ; i++){
      if(max.get(i-1)>0)max.add(max.get(i-1)+data.get(i));
      else max.add(data.get(i));
    }
    System.out.println(Collections.max(max));
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      ArrayList<Integer>data=new ArrayList<Integer>();
      for(int i=0 ; i<n ; i++){
        data.add(sc.nextInt());
      }
      solve(n,data);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( n : int, data : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var max : Sequence(int) ; max := Sequence{} ;
     max := max->including(data->at(0+1)) ; 
         var i : int ; i := 1 ; while i < n do ( (     if (max->at(i - 1+1) > 0) then     max := max->including(max->at(i - 1+1) + data->at(i+1)) ; else     max := max->including(data->at(i+1)) ; )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println( max->max()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var data : Sequence(int) ; data := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     data := data->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    execute solve(n, data) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX_CHAR=26 ;
  static boolean check(int freq[],int k){
    for(int i=0 ; i<MAX_CHAR ; i++)if(freq[i]!=0 && freq[i]!=k)return false ;
    return true ;
  }
  static int substrings(String s,int k){
    int res=0 ;
    for(int i=0 ; i<s.length(); i++){
      int freq[]=new int[MAX_CHAR];
      for(int j=i ; j<s.length(); j++){
        int index=s.charAt(j)-'a' ;
        freq[index]++;
        if(freq[index]>k)break ;
        else if(freq[index]==k && check(freq,k)==true)res++;
      }
    }
    return res ;
  }
  public static void main(String[] args){
    String s="aabbcc" ;
    int k=2 ;
    System.out.println(substrings(s,k));
    s="aabbc" ;
    k=2 ;
    System.out.println(substrings(s,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX_CHAR : int := 26;
  static   operation check( freq : Sequence(int), k : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < MAX_CHAR do (     if (freq[i+1] /= 0 & freq[i+1] /= k) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation substrings( s : String, k : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     var freq : Sequence(int) ; freq := Integer.subrange(1,MAX_CHAR)->collect(0) ;
         var j : int ; j := i ; while j < s->size() do ( (     var index : int ; index := s->at(j+1) - ('a')->char2byte() ;
     freq[index+1] := freq[index+1] + 1 ; 
     if (freq[index+1] > k) then     break else     if (freq[index+1] = k & check(freq, k) = true) then     res := res + 1 ; else skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "aabbcc" ;
     var k : int ; k := 2 ;
    OclFile["System.out"].println(substrings(s, k)) ; 
    s := "aabbc" ; 
    k := 2 ; 
    OclFile["System.out"].println(substrings(s, k)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner cin=new Scanner(System.in);
    int count=cin.nextInt();
    long time=cin.nextLong();
    long sub ;
    long sum_sub=0L ;
    long last_one=0L ;
    long tmp ;
    for(int i=0 ; i<count ; i++){
      if(i==0){
        last_one=cin.nextLong();
      }
      else {
        tmp=cin.nextLong();
        sub=time+last_one-tmp ;
        if(sub>0){
          sum_sub+=sub ;
        }
        last_one=tmp ;
      }
    }
    long result=(long)count*time-sum_sub ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := cin.getCurrent()->toInteger() ;
    var time : long ; time := cin.getCurrent()->toLong() ;
    var sub : long ;
    var sum_sub : long ; sum_sub := 0L ;
    var last_one : long ; last_one := 0L ;
    var tmp : long ;
        var i : int ; i := 0 ; while i < count do ( (     if (i = 0) then (     last_one := cin.getCurrent()->toLong() ) else (     tmp := cin.getCurrent()->toLong() ; 
     sub := time + last_one - tmp ; 
     if (sub > 0) then (     sum_sub := sum_sub+(sub) ) else skip ; 
     last_one := tmp ) )  ;     i := i + 1 ) ; 
    var result : long ; result := count->oclAsType(long) * time - sum_sub ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isDivisible(long n){
    while(n/100>0){
      long d=n % 10 ;
      n/=10 ;
      n+=d*2 ;
    }
    return(n % 19==0);
  }
  public static void main(String[] args){
    long n=101156 ;
    if(isDivisible(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isDivisible( n : long) : boolean
  pre: true
  post: true
  activity: (     while (n / 100 > 0) do (     var d : long ; d := n mod 10 ;
     n := n/(10) ; 
     n := n+(d * 2) ) ; 
     return (n mod 19 = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 101156 ;
     if (isDivisible(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=null ;
    while((str=br.readLine())!=null){
      String input[]=str.split(" ");
      String input_array[]=br.readLine().split(" ");
      int n=Integer.parseInt(input[0]);
      int t=Integer.parseInt(input[1]);
      int sum=0 ;
      int mae=0 ;
      for(int i=0 ; i<n ; i++){
        int ima=Integer.parseInt(input_array[i]);
        int diff=ima-mae ;
        if(i!=0){
          if(diff>=t){
            sum+=t ;
          }
          else {
            sum+=diff ;
          }
        }
        mae=ima ;
        if(i==n-1){
          sum+=t ;
        }
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := null ;
         str := br.readLine() ;
    while ((str) /= null) do (    skip ; (     var input : Sequence(String) ; input := str->split(" ") ;
     var input_array : Sequence(String) ; input_array := br.readLine()->split(" ") ;
    var n : int ; n := (input[0+1])->toInteger() ;
    var t : int ; t := (input[1+1])->toInteger() ;
    var sum : int ; sum := 0 ;
    var mae : int ; mae := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var ima : int ; ima := (input_array[i+1])->toInteger() ;
     var diff : int ; diff := ima - mae ;
    if (i /= 0) then (     if (diff >= t) then (     sum := sum+(t) ) else (     sum := sum+(diff) ) ) else skip ; 
    mae := ima ; 
    if (i = (n)->char2byte() - 1) then (     sum := sum+(t) ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;     str := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void sieve(boolean prime[],int n){
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=n ; p++){
      if(prime[p]==true){
        for(int i=p*p ; i<=n ; i+=p)prime[i]=false ;
      }
    }
  }
  static int sumPrime(int d){
    int maxVal=(int)(Math.pow(2,d)-1);
    boolean[] prime=new boolean[maxVal+1];
    Arrays.fill(prime,true);
    sieve(prime,maxVal);
    int sum=0 ;
    for(int i=2 ; i<=maxVal ; i++){
      if(prime[i]){
        sum+=i ;
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int d=8 ;
    System.out.println(sumPrime(d));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sieve( prime : Sequence(boolean), n : int) : void
  pre: true
  post: true
  activity: (     prime[0+1] := false ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p <= n do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * p ; while i <= n do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation sumPrime( d : int) : int
  pre: true
  post: true
  activity: (     var maxVal : int ; maxVal := (2->pow(d) - 1)->oclAsType(int) ;
     var prime : Sequence(boolean) ; prime := Integer.subrange(1,maxVal + 1)->collect(false) ;
    prime := prime->collect(true) ; 
    execute sieve(prime, maxVal) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 2 ; while i <= maxVal do ( (     if (prime[i+1]) then (     sum := sum+(i) ) else skip )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : int ; d := 8 ;
     OclFile["System.out"].println(sumPrime(d)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Solver {
  void solve(Scanner in){
    final int N=in.nextInt();
    final int T=in.nextInt();
    int time=-T ;
    int sum=0 ;
    for(int i=0 ; i<N ; i++){
      int timing=in.nextInt();
      sum+=T-Math.max((time+T)-timing,0);
      time=timing ;
    }
    System.out.println(sum);
  }
}
class Main {
  public static void main(String...args){
    Scanner in=new Scanner(System.in);
    new Solver().solve(in);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solver {
   operation solve( in : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.nextInt() ;
     var T : int ; T := in.nextInt() ;
    var time : int ; time := -T ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var timing : int ; timing := in.nextInt() ;
     sum := sum+(T - Set{(time + T) - timing, 0}->max()) ; 
     time := timing )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Solver.newSolver().solve(in) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try {
      Scanner sc=new Scanner(System.in);
      int N=sc.nextInt();
      int T=sc.nextInt();
      int[] input=new int[N];
      long result=T ;
      input[0]=sc.nextInt();
      for(int i=1 ; i<N ; i++){
        input[i]=sc.nextInt();
        if(input[i]-input[i-1]<=T){
          result+=input[i]-input[i-1];
        }
        else {
          result+=T ;
        }
      }
      System.out.println(result);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
    var input : Sequence(int) ; input := Integer.subrange(1,N)->collect(0) ;
    var result : long ; result := T ;
    input[0+1] := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i < N do ( (     input[i+1] := sc.getCurrent()->toInteger() ; 
     if (input[i+1] - input[i - 1+1] <= T) then (     result := result+(input[i+1] - input[i - 1+1]) ) else (     result := result+(T) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    int[] times=new int[n];
    for(int i=0 ; i<n ; i++)times[i]=sc.nextInt();
    long total=0 ;
    int start=0 ;
    if(times[0]>t){
      start=times[0];
      total=t ;
    }
    for(int i=1 ; i<n ; i++){
      if(times[i]>times[i-1]+t){
        total+=times[i-1]-start+t ;
        start=times[i];
      }
    }
    total+=times[n-1]-start+t ;
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var times : Sequence(int) ; times := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     times[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var total : long ; total := 0 ;
    var start : int ; start := 0 ;
    if (times[0+1] > t) then (     start := times[0+1] ; 
     total := t ) else skip ; 
        var i : int ; i := 1 ; while i < n do ( (     if (times[i+1] > times[i - 1+1] + t) then (     total := total+(times[i - 1+1] - start + t) ; 
     start := times[i+1] ) else skip )  ;     i := i + 1 ) ; 
    total := total+(times[n - 1+1] - start + t) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int x=in.nextInt();
    while(n!=0 || x!=0){
      int cnt=0 ;
      for(int i=1 ; i<=n ; i++){
        for(int k=i+1 ; k<=n && i+k<x ; k++){
          for(int m=k+1 ; m<=n && i+k+m<=x ; m++){
            if(i+k+m==x){
              cnt++;
            }
          }
        }
      }
      System.out.println(cnt);
      n=in.nextInt();
      x=in.nextInt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
     var x : int ; x := in.getCurrent()->toInteger() ;
     while (n /= 0 or x /= 0) do (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (         var k : int ; k := i + 1 ; while k <= n & i + k < x do ( (         var m : int ; m := k + 1 ; while m <= n & i + k + m <= x do ( (     if (i + k + m = x) then (     cnt := cnt + 1 ) else skip )  ;     m := m + 1 ) )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
    n := in.getCurrent()->toInteger() ; 
    x := in.getCurrent()->toInteger() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public void start(){
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    try {
      while(true){
        String str=input.readLine();
        String array[]=str.split(" ");
        int n=Integer.parseInt(array[0]);
        int x=Integer.parseInt(array[1]);
        if(n+x==0){
          break ;
        }
        combo(n,x);
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  public void combo(int a,int b){
    int z=0 ;
    for(int i=1 ; i<=a-2 ; i++){
      for(int j=i+1 ; j<=a-1 ; j++){
        if(j==i){
          continue ;
        }
        for(int k=j+1 ; k<=a ; k++){
          if(k==i || k==j){
            continue ;
          }
          else if(i+j+k==b){
            z++;
          }
        }
      }
    }
    System.out.println(z);
  }
  public static void main(String[] args){
    Main main=new Main();
    main.start();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation start() : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     while (true) do (     var str : String ; str := input.readLine() ;
     var array : Sequence(String) ; array := str->split(" ") ;
    var n : int ; n := (array[0+1])->toInteger() ;
    var x : int ; x := (array[1+1])->toInteger() ;
    if (n + x = 0) then (     break ) else skip ; 
    execute combo(n, x) ; 
 ) )   catch (e : IOException) do (     e.printStackTrace() )
 );
   operation combo( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var z : int ; z := 0 ;
         var i : int ; i := 1 ; while i <= a - 2 do ( (         var j : int ; j := i + 1 ; while j <= a - 1 do ( (     if (j = i) then (     continue ) else skip ; 
         var k : int ; k := j + 1 ; while k <= a do ( (     if (k = i or k = j) then (     continue ) else     if (i + j + k = b) then (     z := z + 1 ) else skip ; )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(z) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.start() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  public void exe(int n,int x){
    int sum=0 ;
    for(int a=1 ; a<=x/3 ; a++){
      for(int b=a+1 ; b<=n ; b++){
        int c=x-b-a ;
        if(a<b && b<c && c<=n){
          sum=sum+1 ;
        }
        else if(c<b)break ;
      }
    }
    System.out.println(sum);
  }
  public void run(){
    sc=new Scanner(System.in);
    ArrayList<Integer>n=new ArrayList<Integer>();
    while(sc.hasNextInt()){
      int value=sc.nextInt();
      int value2=sc.nextInt();
      if(value==0 && value2==0){
        break ;
      }
      else {
        exe(value,value2);
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   operation exe( n : int, x : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var a : int ; a := 1 ; while a <= x / 3 do ( (         var b : int ; b := a + 1 ; while b <= n do ( (     var c : int ; c := x - b - a ;
     if (a < b & b < c & c <= n) then (     sum := sum + 1 ) else     if (c < b) then     break else skip ; )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
     OclFile["System.out"].println(sum) );
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : Sequence(int) ; n := Sequence{} ;
     while (sc.hasNextInt()) do (     var value : int ; value := sc.getCurrent()->toInteger() ;
     var value2 : int ; value2 := sc.getCurrent()->toInteger() ;
     if (value = 0 & value2 = 0) then (     break ) else (     execute exe(value, value2) ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    while(true){
      String line=input.readLine();
      String[] num=line.split(" ");
      int n=Integer.parseInt(num[0]);
      int x=Integer.parseInt(num[1]);
      int sum=0 ;
      if(n==0 && x==0)break ;
      for(int i=1 ; i<=(n-2); i++){
        for(int j=i+1 ; j<=(n-1); j++){
          for(int k=j+1 ; k<=n ; k++){
            if(i+j+k==x){
              sum++;
            }
          }
        }
      }
      sb.append(sum+"\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
     while (true) do (     var line : String ; line := input.readLine() ;
     var num : Sequence(String) ; num := line->split(" ") ;
    var n : int ; n := (num[0+1])->toInteger() ;
    var x : int ; x := (num[1+1])->toInteger() ;
    var sum : int ; sum := 0 ;
    if (n = 0 & x = 0) then     break else skip ; 
        var i : int ; i := 1 ; while i <= (n - 2) do ( (         var j : int ; j := i + 1 ; while j <= (n - 1) do ( (         var k : int ; k := j + 1 ; while k <= n do ( (     if (i + j + k = x) then (     sum := sum + 1 ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(sum + "\n") ; 
 ) ; 
     OclFile["System.out"].print(sb) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    for(; ; ){
      int n=in.nextInt();
      int x=in.nextInt();
      if(n==0 && x==0){
        break ;
      }
      int count=0 ;
      for(int i=1 ; i<=n ; i++){
        if(i>x){
          break ;
        }
        for(int j=i+1 ; j<=n ; j++){
          if(i+j>x){
            break ;
          }
          for(int k=j+1 ; k<=n ; k++){
            if(i+j+k==x){
              count++;
            }
            else if(i+j+k>x){
              break ;
            }
          }
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var x : int ; x := in.getCurrent()->toInteger() ;
    if (n = 0 & x = 0) then (     break ) else skip ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (i > x) then (     break ) else skip ; 
         var j : int ; j := i + 1 ; while j <= n do ( (     if (i + j > x) then (     break ) else skip ; 
         var k : int ; k := j + 1 ; while k <= n do ( (     if (i + j + k = x) then (     count := count + 1 ) else     if (i + j + k > x) then (     break ) else skip ; )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long computeXOR(int n){
    int x=n & 3 ;
    switch(x){
      case 0 : return n ;
      case 1 : return 1 ;
      case 2 : return n+1 ;
      case 3 : return 0 ;
    }
    return 0 ;
  }
  public static void main(String args[]){
    int l=1,r=4 ;
    System.out.println(computeXOR(r)^ computeXOR(l-1));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation computeXOR( n : int) : long
  pre: true
  post: true
  activity: (     var x : int ; x := MathLib.bitwiseAnd(n,3) ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (x) ; 
       if _switchval = 0 then
     return n 
   else skip ;
       if _switchval = 1 then
     return 1 
   else skip ;
       if _switchval = 2 then
     return n + 1 
   else skip ;
       if _switchval = 3 then
     return 0 
   else skip ;
 )
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 1 ;
    var r : int ; r := 4 ;
     OclFile["System.out"].println(computeXOR(r) xor computeXOR(l - 1)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t--!=0){
      int len=scanner.nextInt();
      String text=scanner.nextLine();
      text=scanner.nextLine();
      String temp="" ;
      int count=0 ;
      boolean visited[]=new boolean[26];
      for(int i=0 ; i<text.length(); i++){
        char ch=text.charAt(i);
        if(visited[ch-'A']){
          count++;
        }
        else {
          visited[ch-'A']=true ;
          count+=2 ;
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var len : int ; len := scanner.getCurrent()->toInteger() ;
     var text : String ; text := scanner.nextLine() ;
    text := scanner.nextLine() ; 
    var temp : String ; temp := "" ;
    var count : int ; count := 0 ;
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,26)->collect(false) ;
        var i : int ; i := 0 ; while i < text->size() do ( (     var ch : String ; ch := text->at(i+1) ;
     if (visited[(ch)->char2byte() - ('A')->char2byte()+1]) then (     count := count + 1 ) else (     visited[(ch)->char2byte() - ('A')->char2byte()+1] := true ; 
     count := count+(2) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main implements Runnable {
  private void solve()throws IOException {
    int N=nextInt();
    boolean isSet=false ;
    int prev=nextInt();
    int ret=1 ;
    boolean isBigger=false ;
    for(int i=1 ; i<N ; ++i){
      int next=nextInt();
      if(! isSet){
        if(next>prev){
          isBigger=true ;
          isSet=true ;
        }
        else if(next<prev){
          isBigger=false ;
          isSet=true ;
        }
        else isSet=false ;
      }
      else {
        if(isBigger){
          if(next<prev){
++ret ;
            isSet=false ;
          }
        }
        else {
          if(next>prev){
++ret ;
            isSet=false ;
          }
        }
      }
      prev=next ;
    }
    writer.println(ret);
  }
  public static void main(String[] args){
    new Main().run();
  }
  BufferedReader reader ;
  StringTokenizer tokenizer ;
  PrintWriter writer ;
  public void run(){
    try {
      reader=new BufferedReader(new InputStreamReader(System.in));
      tokenizer=null ;
      writer=new PrintWriter(System.out);
      solve();
      reader.close();
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  short nextShort()throws IOException {
    return Short.parseShort(nextToken());
  }
  String nextToken()throws IOException {
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : int ; N := nextInt() ;
     var isSet : boolean ; isSet := false ;
    var prev : int ; prev := nextInt() ;
    var ret : int ; ret := 1 ;
    var isBigger : boolean ; isBigger := false ;
        var i : int ; i := 1 ; while i < N do ( (     var next : int ; next := nextInt() ;
     if (not(isSet)) then (     if (next > prev) then (     isBigger := true ; 
     isSet := true ) else     if (next < prev) then (     isBigger := false ; 
     isSet := true ) else     isSet := false ; ;  ) else (     if (isBigger) then (     if (next < prev) then (     ret := ret + 1 ; 
     isSet := false ) else skip ) else (     if (next > prev) then (     ret := ret + 1 ; 
     isSet := false ) else skip ) ) ;  
     prev := next )  ;     i := i + 1 ) ; 
    writer.println(ret) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   attribute writer : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     try (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := null ; 
    writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int t=0 ; t<test ; t++){
      int n=in.nextInt(),k=in.nextInt();
      ArrayList<Integer>list=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        int v=in.nextInt();
        list.add(v);
      }
      Collections.sort(list);
      int div=1 ;
      int count=0 ;
      long sum=0 ;
      for(int i=n-1 ; i>=0 ; i--){
        sum+=list.get(i);
        if(sum/(div*1.0)>=k){
          count++;
          div++;
        }
        else {
          break ;
        }
      }
      pw.println(count);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < test do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
     var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := in.getCurrent()->toInteger() ;
     list := list->including(v) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var div : int ; div := 1 ;
    var count : int ; count := 0 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     sum := sum+(list->at(i+1)) ; 
     if (sum / (div * 1.0) >= k) then (     count := count + 1 ; 
     div := div + 1 ) else (     break ) )  ;     i := i - 1 ) ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Deque ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  @ SuppressWarnings("unchecked")private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    List<Integer>[] G=new ArrayList[n];
    for(int i=0 ; i<n ; i++)G[i]=new ArrayList<Integer>();
    int[] deg=new int[n];
    for(int i=0 ; i<m ; i++){
      int u=scanner.nextInt()-1 ;
      int v=scanner.nextInt()-1 ;
      G[u] .add(v);
      deg[v]++;
    }
    boolean ambig=false ;
    Deque<Integer>deque=new ArrayDeque<Integer>();
    for(int i=0 ; i<n ; i++){
      if(deg[i]==0)deque.push(i);
    }
    while(! deque.isEmpty()){
      if(deque.size()>=2)ambig=true ;
      int u=deque.poll();
      System.out.println(u+1);
      for(int v : G[u]){
        deg[v]--;
        if(deg[v]==0)deque.push(v);
      }
    }
    System.out.println(ambig ? 1 : 0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
      operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var G : Sequence(Sequence(int)) ; G := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     G[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
    var deg : Sequence(int) ; deg := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     var u : int ; u := scanner.getCurrent()->toInteger() - 1 ;
     var v : int ; v := scanner.getCurrent()->toInteger() - 1 ;
     G[u+1]->excludes(v) ; 
     deg[v+1] := deg[v+1] + 1 )  ;     i := i + 1 ) ; 
    var ambig : boolean ; ambig := false ;
    var deque : Sequence(int) ; deque := ArrayDeque<int>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < n do ( (     if (deg[i+1] = 0) then     deque := deque->append(i) ; else skip )  ;     i := i + 1 ) ; 
    while (not(deque->isEmpty())) do (     if (deque->size() >= 2) then     ambig := true ; else skip ; 
     var u : int ; u := deque->min() ;
     OclFile["System.out"].println(u + 1) ; 
     for (v : G[u+1]) do ( (     deg[v+1] := deg[v+1] - 1 ; 
     if (deg[v+1] = 0) then     deque := deque->append(v) ; else skip )  ) ) ; 
    OclFile["System.out"].println(if ambig then 1 else 0 endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Deque ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  @ SuppressWarnings("unchecked")private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    List<Integer>[] lists=new ArrayList[n];
    int[] deg=new int[n];
    for(int i=0 ; i<n ; i++)lists[i]=new ArrayList<Integer>();
    for(int i=0 ; i<m ; i++){
      int w=scanner.nextInt()-1 ;
      int l=scanner.nextInt()-1 ;
      lists[w] .add(l);
      deg[l]++;
    }
    Deque<Integer>deque=new ArrayDeque<Integer>();
    for(int i=0 ; i<n ; i++)if(deg[i]==0)deque.push(i);
    boolean flag=false ;
    while(! deque.isEmpty()){
      if(deque.size()>1)flag=true ;
      int a=deque.poll();
      System.out.println(a+1);
      for(int x : lists[a]){
        deg[x]--;
        if(deg[x]==0)deque.push(x);
      }
    }
    System.out.println(flag ? 1 : 0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
      operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var lists : Sequence(Sequence(int)) ; lists := Integer.subrange(1,n)->collect(null) ;
    var deg : Sequence(int) ; deg := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     lists[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var w : int ; w := scanner.getCurrent()->toInteger() - 1 ;
     var l : int ; l := scanner.getCurrent()->toInteger() - 1 ;
     lists[w+1]->excludes(l) ; 
     deg[l+1] := deg[l+1] + 1 )  ;     i := i + 1 ) ; 
    var deque : Sequence(int) ; deque := ArrayDeque<int>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < n do (     if (deg[i+1] = 0) then     deque := deque->append(i) ; else skip ;  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := false ;
    while (not(deque->isEmpty())) do (     if (deque->size() > 1) then     flag := true ; else skip ; 
     var a : int ; a := deque->min() ;
     OclFile["System.out"].println(a + 1) ; 
     for (x : lists[a+1]) do ( (     deg[x+1] := deg[x+1] - 1 ; 
     if (deg[x+1] = 0) then     deque := deque->append(x) ; else skip )  ) ) ; 
    OclFile["System.out"].println(if flag then 1 else 0 endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      int n=scan.nextInt();
      if(n==0)break ;
      int m=scan.nextInt();
      Match match=new Match(n);
      for(int i=0 ; i<m ; i++)match.add(scan.nextInt(),scan.nextInt());
      for(int i=0 ; i<n ; i++)System.out.println(match.getTopOrder());
      System.out.println(match.getDefined());
    }
    scan.close();
    System.exit(0);
  }
}
class Match {
  class Team {
    int loseCnt=0 ;
    List<Integer>winTo=new ArrayList<Integer>();
  }
  Team[] team ;
  boolean vague=false ;
  public Match(int n){
    team=new Team[n+1];
    for(int i=1 ; i<team.length ; i++)team[i]=new Team();
  }
  public int getDefined(){
    if(vague)return 1 ;
    else return 0 ;
  }
  public int getTopOrder(){
    int top=0 ;
    for(int i=1 ; i<team.length ; i++){
      if(team[i] .loseCnt==0){
        if(top!=0){
          vague=true ;
          break ;
        }
        top=i ;
        team[i] .loseCnt=-1 ;
        if(vague)break ;
      }
    }
    for(int i=0 ; i<team[top] .winTo.size(); i++)team[team[top] .winTo.get(i)] .loseCnt--;
    return top ;
  }
  public void add(int winner,int loser){
    team[loser] .loseCnt++;
    team[winner] .winTo.add(loser);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var n : int ; n := scan.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var match : Match ; match := Match.newMatch(n) ;
        var i : int ; i := 0 ; while i < m do (     match->excludes(scan.getCurrent()->toInteger(), scan.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].println(match.getTopOrder()) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(match.getDefined()) ; 
 ) ; 
     skip ; 
 OclProcess.exit(0) );
}
class Match {
 class Team {
   attribute loseCnt : int := 0;
   attribute winTo : Sequence(int) := Sequence{};
}
   attribute team : Sequence(Team);
   attribute vague : boolean := false;
   static operation newMatch( n : int) : Match
  pre: true
  post: true
  activity:
  ( var self : Match ;
    self := createMatch();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     team := Integer.subrange(1,n + 1)->collect(null) ; 
         var i : int ; i := 1 ; while i < team->size() do (     team[i+1] := Team.newTeam() ;  ;     i := i + 1 ) );
   operation getDefined() : int
  pre: true
  post: true
  activity: (     if (vague) then     return 1 else     return 0 );
   operation getTopOrder() : int
  pre: true
  post: true
  activity: (     var top : int ; top := 0 ;
         var i : int ; i := 1 ; while i < team->size() do ( (     if (team[i+1].loseCnt = 0) then (     if (top /= 0) then (     vague := true ; 
     break ) else skip ; 
     top := i ; 
     team[i+1].loseCnt := -1 ; 
     if (vague) then     break else skip ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < team[top+1].winTo->size() do (     team[team[top+1].winTo->at(i+1)+1].loseCnt := team[team[top+1].winTo->at(i+1)+1].loseCnt - 1 ;  ;     i := i + 1 ) ; 
     return top );
   operation add( winner : int, loser : int) : void
  pre: true
  post: true
  activity: (     team[loser+1].loseCnt := team[loser+1].loseCnt + 1 ; 
     team[winner+1].winTo->excludes(loser) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static int N,M ;
  @ SuppressWarnings("unchecked")public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    M=sc.nextInt();
    List<Integer>[] list=new List[N];
    for(int i=0 ; i<N ; i++){
      list[i]=new LinkedList<Integer>();
    }
    int[] iri=new int[N];
    for(int i=0 ; i<M ; i++){
      int a=sc.nextInt()-1 ;
      int b=sc.nextInt()-1 ;
      list[a] .add(b);
      iri[b]++;
    }
    List<Integer>ans=new LinkedList<Integer>();
    boolean f=false ;
    for(int t=0 ; t<N ; t++){
      for(int i=0 ; i<N ; i++){
        if(iri[i]==0){
          ans.add(i);
          iri[i]=-1 ;
          if(! f){
            for(int j=0 ; j<N ; j++){
              if(iri[j]==0){
                f=true ;
              }
            }
          }
          for(Integer j : list[i]){
            iri[j]--;
          }
          break ;
        }
      }
    }
    for(Integer a : ans){
      System.out.println(a+1);
    }
    System.out.printf("%d\n",f ? 1 : 0);
  }
  static HashMap<Integer,Integer>rank=new HashMap<Integer,Integer>();
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
    M := sc.getCurrent()->toInteger() ; 
    var list : Sequence(Sequence(int)) ; list := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     list[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
    var iri : Sequence(int) ; iri := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
     var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
     list[a+1]->excludes(b) ; 
     iri[b+1] := iri[b+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Sequence{} ;
    var f : boolean ; f := false ;
        var t : int ; t := 0 ; while t < N do ( (         var i : int ; i := 0 ; while i < N do ( (     if (iri[i+1] = 0) then (     ans := ans->including(i) ; 
     iri[i+1] := -1 ; 
    if (not(f)) then (         var j : int ; j := 0 ; while j < N do ( (     if (iri[j+1] = 0) then (     f := true ) else skip )  ;     j := j + 1 ) ) else skip ; 
    for (j : list[i+1]) do ( (     iri[j+1] := iri[j+1] - 1 )  ) ; 
    break 
 ) else skip )  ;     i := i + 1 ) )  ;     t := t + 1 ) ; 
    for (a : ans) do ( (     OclFile["System.out"].println(a + 1) )  ) ; 
    OclFile["System.out"].printf("%d\n", if f then 1 else 0 endif) ; 
 );
  static   attribute rank : Map(int,int) := Map{};
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      int n=in.nextInt();
      int m=in.nextInt();
      int ans=0 ;
      if((n | m)==0)return ;
      String a[][]=new String[n][2];
      String b[]=new String[m];
      for(int i=0 ; i<n ; i++){
        a[i][0]=in.next();
        a[i][1]=in.next();
      }
      for(int i=0 ; i<m ; i++)b[i]=in.next();
      for(int i=0 ; i<m ; i++){
        char ch[]=b[i] .toCharArray();
        int cnt=0 ;
        for(int j=0 ; j<n ; j++){
          char re[]=a[j][0] .toCharArray();
          boolean match=true ;
          for(int k=0 ; k<re.length ; k++){
            if(re[k]=='*')continue ;
            if(re[k]!=ch[k])match=false ;
          }
          if(match)cnt=Math.max(cnt,Integer.valueOf(a[j][1]));
        }
        ans+=cnt ;
      }
      System.out.println(ans);
    }
  }
  static public void debug(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    if ((MathLib.bitwiseOr(n,m)) = 0) then     return else skip ; 
    var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(null)) ;
    var b : Sequence(String) ; b := Integer.subrange(1,m)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1][0+1] := in.getCurrent() ; 
     a[i+1][1+1] := in.getCurrent() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     b[i+1] := in.getCurrent() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var ch : Sequence(String) ; ch := b[i+1]->characters() ;
     var cnt : int ; cnt := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     var re : Sequence(String) ; re := a[j+1][0+1]->characters() ;
     var match : boolean ; match := true ;
         var k : int ; k := 0 ; while k < re->size() do ( (     if (re[k+1] = '*') then     continue else skip ; 
     if (re[k+1] /= ch[k+1]) then     match := false ; else skip )  ;     k := k + 1 ) ; 
     if (match) then     cnt := Set{cnt, (a[j+1][1+1])->toInteger()}->max() ; else skip )  ;     j := j + 1 ) ; 
     ans := ans+(cnt) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ) );
  static    operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt(),m=sc.nextInt();
      if((n | m)==0)break ;
      String[] t=new String[n];
      int[] v=new int[n];
      String[] b=new String[m];
      for(int i=0 ; i<n ; i++){
        t[i]=sc.next();
        v[i]=sc.nextInt();
      }
      for(int i=0 ; i<m ; i++)b[i]=sc.next();
      int sum=0 ;
      for(int i=0 ; i<n ; i++)for(int h=0 ; h<m ; h++){
        boolean flg=true ;
        for(int j=0 ; j<8 ; j++)if(t[i] .charAt(j)!='*' && t[i] .charAt(j)!=b[h] .charAt(j))flg=false ;
        if(flg)sum+=v[i];
      }
      System.out.println(sum);
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseOr(n,m)) = 0) then     break else skip ; 
    var t : Sequence(String) ; t := Integer.subrange(1,n)->collect(null) ;
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(String) ; b := Integer.subrange(1,m)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     t[i+1] := sc.getCurrent() ; 
     v[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     b[i+1] := sc.getCurrent() ;  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (         var h : int ; h := 0 ; while h < m do ( (     var flg : boolean ; flg := true ;
         var j : int ; j := 0 ; while j < 8 do (     if (t[i+1]->at(j+1) /= '*' & t[i+1]->at(j+1) /= b[h+1]->at(j+1)) then     flg := false ; else skip ;  ;     j := j + 1 ) ; 
     if (flg) then     sum := sum+(v[i+1]) ; else skip )  ;     h := h + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n,m ;
      n=parseInt(line.substring(0,line.indexOf(' ')));
      m=parseInt(line.substring(line.indexOf(' ')+1));
      if((n | m)==0)break ;
      Map<String,Integer>hits=new HashMap<>();
      for(int i=0 ; i<n ; i++){
        words=br.readLine().split(" ");
        hits.put(words[0] .replace("*",""),parseInt(words[1]));
      }
      int sum=0 ;
      for(int i=0 ; i<m ; i++){
        String lott=br.readLine();
        int max=0 ;
        for(int j=0 ; j<=lott.length(); j++){
          String _lott=lott.substring(j,lott.length());
          if(hits.get(_lott)!=null){
            max=Math.max(max,hits.get(_lott));
          }
        }
        sum+=max ;
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ;
    var m : int ;
     n := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    m := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    if ((MathLib.bitwiseOr(n,m)) = 0) then     break else skip ; 
    var hits : Map(String,int) ; hits := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     words := br.readLine()->split(" ") ; 
     hits := hits->union(Map{words[0+1].replace("*", "") |-> (words[1+1] + "")->toInteger()}) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var lott : String ; lott := br.readLine() ;
     var max : int ; max := 0 ;
         var j : int ; j := 0 ; while j <= lott->size() do ( (     var _lott : String ; _lott := lott.subrange(j+1,lott->size()) ;
     if (hits->at(_lott) /= null) then (     max := Set{max, hits->at(_lott)}->max() ) else skip )  ;     j := j + 1 ) ; 
     sum := sum+(max) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  boolean check(char[] a,char[] b){
    for(int i=0 ; i<8 ; i++){
      if(a[i]!='*' && a[i]!=b[i]){
        return false ;
      }
    }
    return true ;
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if((n | m)==0){
        break ;
      }
      char[][] c=new char[n][];
      int[] d=new int[n];
      for(int i=0 ; i<n ; i++){
        c[i]=sc.next().toCharArray();
        d[i]=sc.nextInt();
      }
      char[][] e=new char[m][];
      for(int i=0 ; i<m ; i++){
        e[i]=sc.next().toCharArray();
      }
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<m ; j++){
          if(check(c[i],e[j])){
            sum+=d[i];
          }
        }
      }
      System.out.println(sum);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation check( a : Sequence(String), b : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 8 do ( (     if (a[i+1] /= '*' & a[i+1] /= b[i+1]) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,m)) = 0) then (     break ) else skip ; 
    var c : Sequence(Sequence(String)) ; c := Integer.subrange(1,n)->collect(Sequence{}) ;
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := sc.getCurrent()->characters() ; 
     d[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var e : Sequence(Sequence(String)) ; e := Integer.subrange(1,m)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < m do ( (     e[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (check(c[i+1], e[j+1])) then (     sum := sum+(d[i+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long a=in.nextLong(),b=in.nextLong(),c=in.nextLong();
    long min=Math.min(a,b);
    long max=min+1 ;
    if(a==b){
      pw.println(a+b+(c*2));
    }
    else {
      pw.println(max+min+(c*2));
    }
    pw.close();
  }
  public static boolean isPalindrome(String str){
    String rev="" ;
    boolean ans=false ;
    for(int i=str.length()-1 ; i>=0 ; i--){
      rev=rev+str.charAt(i);
    }
    if(str.equals(rev)){
      ans=true ;
    }
    return ans ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : long ; a := in.getCurrent()->toLong() ;
    var b : long ; b := in.getCurrent()->toLong() ;
    var c : long ; c := in.getCurrent()->toLong() ;
    var min : long ; min := Set{a, b}->min() ;
    var max : long ; max := min + 1 ;
    if (a = b) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static   operation isPalindrome( str : String) : boolean
  pre: true
  post: true
  activity: (     var rev : String ; rev := "" ;
     var ans : boolean ; ans := false ;
        var i : int ; i := str->size() - 1 ; while i >= 0 do ( (     rev := rev + str->at(i+1) )  ;     i := i - 1 ) ; 
    if (str = rev) then (     ans := true ) else skip ; 
    return ans 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF567_D2_A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int[] Ox_axis=new int[n];
    for(int i=0 ; i<n ; i++){
      Ox_axis[i]=scanner.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      if(i==0){
        int min=Math.abs(Ox_axis[i]-Ox_axis[i+1]);
        int max=Math.abs(Ox_axis[i]-Ox_axis[n-1]);
        System.out.println(min+" "+max);
        continue ;
      }
      if(i==n-1){
        int max=Math.abs(Ox_axis[i]-Ox_axis[0]);
        int min=Math.abs(Ox_axis[i]-Ox_axis[i-1]);
        System.out.println(min+" "+max);
        continue ;
      }
      int min=Math.min(Math.abs(Ox_axis[i]-Ox_axis[i-1]),Math.abs(Ox_axis[i]-Ox_axis[i+1]));
      int max=Math.max(Math.abs(Ox_axis[i]-Ox_axis[n-1]),Math.abs(Ox_axis[i]-Ox_axis[0]));
      System.out.println(min+" "+max);
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF567_D2_A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var Ox_axis : Sequence(int) ; Ox_axis := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     Ox_axis[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i = 0) then (     var min : int ; min := if Ox_axis[i+1] - Ox_axis[i + 1+1] < 0 then -(Ox_axis[i+1] - Ox_axis[i + 1+1]) else Ox_axis[i+1] - Ox_axis[i + 1+1] endif ;
     var max : int ; max := if Ox_axis[i+1] - Ox_axis[n - 1+1] < 0 then -(Ox_axis[i+1] - Ox_axis[n - 1+1]) else Ox_axis[i+1] - Ox_axis[n - 1+1] endif ;
     OclFile["System.out"].println(min + " " + max) ; 
     continue ) else skip ; 
     if (i = n - 1) then (     var max : int ; max := if Ox_axis[i+1] - Ox_axis[0+1] < 0 then -(Ox_axis[i+1] - Ox_axis[0+1]) else Ox_axis[i+1] - Ox_axis[0+1] endif ;
     var min : int ; min := if Ox_axis[i+1] - Ox_axis[i - 1+1] < 0 then -(Ox_axis[i+1] - Ox_axis[i - 1+1]) else Ox_axis[i+1] - Ox_axis[i - 1+1] endif ;
     OclFile["System.out"].println(min + " " + max) ; 
     continue ) else skip ; 
    var min : int ; min := Set{if Ox_axis[i+1] - Ox_axis[i - 1+1] < 0 then -(Ox_axis[i+1] - Ox_axis[i - 1+1]) else Ox_axis[i+1] - Ox_axis[i - 1+1] endif, if Ox_axis[i+1] - Ox_axis[i + 1+1] < 0 then -(Ox_axis[i+1] - Ox_axis[i + 1+1]) else Ox_axis[i+1] - Ox_axis[i + 1+1] endif}->min() ;
    var max : int ; max := Set{if Ox_axis[i+1] - Ox_axis[n - 1+1] < 0 then -(Ox_axis[i+1] - Ox_axis[n - 1+1]) else Ox_axis[i+1] - Ox_axis[n - 1+1] endif, if Ox_axis[i+1] - Ox_axis[0+1] < 0 then -(Ox_axis[i+1] - Ox_axis[0+1]) else Ox_axis[i+1] - Ox_axis[0+1] endif}->max() ;
    OclFile["System.out"].println(min + " " + max) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t--!=0){
      int len=scanner.nextInt();
      String text=scanner.nextLine();
      text=scanner.nextLine();
      String temp="" ;
      int count=0 ;
      for(int i=0 ; i<text.length(); i++){
        char ch=text.charAt(i);
        if(! temp.contains(ch+"")){
          temp+=ch ;
          count+=2 ;
        }
        else {
          count++;
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var len : int ; len := scanner.getCurrent()->toInteger() ;
     var text : String ; text := scanner.nextLine() ;
    text := scanner.nextLine() ; 
    var temp : String ; temp := "" ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < text->size() do ( (     var ch : String ; ch := text->at(i+1) ;
     if (not(temp->includes(ch + ""))) then (     temp := temp+(ch) ; 
     count := count+(2) ) else (     count := count + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class continu {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int a=input.nextInt();
    int b=input.nextInt();
    int ab=input.nextInt();
    a+=ab ;
    b+=ab ;
    long count=0 ;
    if(a==b)count=(long)a*2 ;
    else {
      if(a>b)count=(long)b*2+1 ;
      else count=(long)a*2+1 ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class continu {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := input.getCurrent()->toInteger() ;
    var b : int ; b := input.getCurrent()->toInteger() ;
    var ab : int ; ab := input.getCurrent()->toInteger() ;
    a := a+(ab) ; 
    b := b+(ab) ; 
    var count : long ; count := 0 ;
    if (a = b) then     count := a->oclAsType(long) * 2 else (     if (a > b) then     count := b->oclAsType(long) * 2 + 1 ; else     count := a->oclAsType(long) * 2 + 1 ; ) ;  
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int[] arr=new int[3];
    long a=0,b=0 ;
    for(int i=0 ; i<3 ; i++){
      arr[i]=scn.nextInt();
      if(i==0 || i==2)a+=arr[i];
      if(i==1 || i==2)b+=arr[i];
    }
    if(a>b)System.out.print(b*2+1);
    else if(a<b)System.out.print(a*2+1);
    else System.out.print(a+b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,3)->collect(0) ;
    var a : long ; a := 0 ;
    var b : long ; b := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     arr[i+1] := scn.getCurrent()->toInteger() ; 
     if (i = 0 or i = 2) then     a := a+(arr[i+1]) ; else skip ; 
     if (i = 1 or i = 2) then     b := b+(arr[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    if (a > b) then     OclFile["System.out"].print(b * 2 + 1) else     if (a < b) then     OclFile["System.out"].print(a * 2 + 1) else     OclFile["System.out"].print(a + b) ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1148A_AnotherOneBitesTheDust {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    long a=input.nextLong();
    long b=input.nextLong();
    long c=input.nextLong();
    long max=Math.max(a,b);
    long min=Math.min(a,b);
    long re=2*(c+min);
    if(max>min){
      re++;
    }
    System.out.println(re);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1148A_AnotherOneBitesTheDust {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := input.getCurrent()->toLong() ;
    var b : long ; b := input.getCurrent()->toLong() ;
    var c : long ; c := input.getCurrent()->toLong() ;
    var max : long ; max := Set{a, b}->max() ;
    var min : long ; min := Set{a, b}->min() ;
    var re : long ; re := 2 * (c + min) ;
    if (max > min) then (     re := re + 1 ) else skip ; 
    OclFile["System.out"].println(re) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void EvenOddAbsoluteDifference(int arr[],int n){
    int even=0 ;
    int odd=0 ;
    for(int i=0 ; i<n ; i++){
      if(i % 2==0)even=Math.abs(even-arr[i]);
      else odd=Math.abs(odd-arr[i]);
    }
    System.out.println("Even Index absolute difference : "+even);
    System.out.println("Odd Index absolute difference : "+odd);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,6 };
      int n=arr.length ;
      EvenOddAbsoluteDifference(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation EvenOddAbsoluteDifference( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var even : int ; even := 0 ;
     var odd : int ; odd := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then     even := if even - arr[i+1] < 0 then -(even - arr[i+1]) else even - arr[i+1] endif ; else     odd := if odd - arr[i+1] < 0 then -(odd - arr[i+1]) else odd - arr[i+1] endif ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Even Index absolute difference : " + even) ; 
    OclFile["System.out"].println("Odd Index absolute difference : " + odd) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6} ;
     var n : int ; n := arr->size() ;
     execute EvenOddAbsoluteDifference(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int max=10000 ;
  static int dp[]=new int[max];
  static void initDP(){
    for(int i=0 ; i<max ; i++)dp[i]=-1 ;
  }
  static int func(int x){
    if(x==0)return 0 ;
    if(dp[x]==-1)dp[x]=x+func(x/2);
    return dp[x];
  }
  static void printFloor(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(func(arr[i])+" ");
  }
  public static void main(String[] args){
    initDP();
    int arr[]={
      8,6 };
      int n=arr.length ;
      printFloor(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute max : int := 10000;
  static   attribute dp : int := Integer.subrange(1,max)->collect(0);
  static   operation initDP() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < max do (     dp[i+1] := -1 ;  ;     i := i + 1 ) );
  static   operation func( x : int) : int
  pre: true
  post: true
  activity: (     if (x = 0) then     return 0 else skip ; 
     if (dp[x+1] = -1) then     dp[x+1] := x + func(x / 2) ; else skip ; 
     return dp[x+1] );
  static   operation printFloor( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(func(arr[i+1]) + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute initDP() ; 
     var arr : Sequence(int) ; arr := Sequence{8,6} ;
     var n : int ; n := arr->size() ;
     execute printFloor(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      String s=sc.next();
      int l=s.length();
      if(l>10){
        System.out.print(s.charAt(0));
        System.out.print(l-2);
        System.out.println(s.charAt(l-1));
      }
      else {
        System.out.println(s);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
     var l : int ; l := s->size() ;
     if (l > 10) then (     OclFile["System.out"].print(s->at(0+1)) ; 
     OclFile["System.out"].print((l)->char2byte() - 2) ; 
     OclFile["System.out"].println(s->at((l)->char2byte() - 1+1)) ) else (     OclFile["System.out"].println(s) ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      String o=sc.next();
      int len=o.length();
      if(len>10){
        String str=""+o.charAt(0)+""+(len-2)+""+o.charAt(len-1);
        System.out.println(str);
      }
      else {
        System.out.println(o);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < q do ( (     var o : String ; o := sc.getCurrent() ;
     var len : int ; len := o->size() ;
     if (len > 10) then (     var str : String ; str := "" + o->at(0+1) + "" + ((len)->char2byte() - 2) + "" + o->at((len)->char2byte() - 1+1) ;
     OclFile["System.out"].println(str) ) else (     OclFile["System.out"].println(o) ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class tast {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int num=scan.nextInt();
    for(int i=0 ; i<num ; i++){
      String word=scan.next();
      String lower=word.toLowerCase();
      int length=lower.length();
      int num2=length-2 ;
      char first=lower.charAt(0);
      char last=lower.charAt(length-1);
      if(num>=1 && num<=100){
        if(length>10){
          System.out.print(first);
          System.out.print(num2);
          System.out.print(last);
          System.out.print("\n");
        }
        else System.out.println(lower);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class tast {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < num do ( (     var word : String ; word := scan.getCurrent() ;
     var lower : String ; lower := word->toLowerCase() ;
    var length : int ; length := lower->size() ;
    var num2 : int ; num2 := (length)->char2byte() - 2 ;
    var first : String ; first := lower->at(0+1) ;
    var last : String ; last := lower->at((length)->char2byte() - 1+1) ;
    if (num >= 1 & num <= 100) then (     if (length > 10) then (     OclFile["System.out"].print(first) ; 
     OclFile["System.out"].print(num2) ; 
     OclFile["System.out"].print(last) ; 
     OclFile["System.out"].print("\n") ) else     OclFile["System.out"].println(lower) ; ) else skip ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class451 {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int x=sc.nextInt();
      int c=0,i=0 ;
      long r=0 ;
      PriorityQueue<Integer>pq=new PriorityQueue<>(Collections.reverseOrder());
      for(i=0 ; i<n ; i++){
        pq.add(sc.nextInt());
      }
      while(pq.size()>0){
        long val=pq.poll();
        if(r+val<x)break ;
        c++;
        r=(r+val)-x ;
      }
      System.out.println(c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class451 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
    var i : int ; i := 0 ;
    var r : long ; r := 0 ;
    var pq : Sequence(int) ; pq := Sequence{}->union(reverseOrder()) ;
        i := 0 ; while i < n do ( (     pq := pq->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    while (pq->size() > 0) do (     var val : long ; val := pq->min() ;
     if (r + val < x) then     break else skip ; 
     c := c + 1 ; 
     r := (r + val) - x ) ; 
    OclFile["System.out"].println(c) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class WordLength {
  public static void Length(String n){
    int r=n.length();
    if(r>10){
      char first=n.charAt(0);
      char last=n.charAt(r-1);
      System.out.println(first+String.valueOf(r-2)+last);
    }
    else {
      System.out.println(n);
    }
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String[] string=new String[in.nextInt()];
    in.nextLine();
    for(int i=0 ; i<string.length ; i++){
      string[i]=in.nextLine();
    }
    for(String str : string){
      Length(str);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class WordLength {
  static   operation Length( n : String) : void
  pre: true
  post: true
  activity: (     var r : int ; r := n->size() ;
     if (r > 10) then (     var first : String ; first := n->at(0+1) ;
     var last : String ; last := n->at(r - 1+1) ;
     OclFile["System.out"].println(first + ((r - 2) + "") + last) ) else (     OclFile["System.out"].println(n) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var string : Sequence(String) ; string := Integer.subrange(1,in.getCurrent()->toInteger())->collect(null) ;
    skip ; 
        var i : int ; i := 0 ; while i < string->size() do ( (     string[i+1] := in.nextLine() )  ;     i := i + 1 ) ; 
    for (str : string) do ( (     execute Length(str) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static int N,ans ;
  static int[] num ;
  static long[][] dp ;
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    N=cin.nextInt();
    num=new int[N-1];
    ans=0 ;
    dp=new long[N-1][21];
    for(int i=0 ; i<N-1 ; i++){
      num[i]=cin.nextInt();
      Arrays.fill(dp[i],-1);
    }
    ans=cin.nextInt();
    System.out.println(search(0,0));
  }
  static long search(int a,int b){
    if(b>20 || b<0)return 0 ;
    if(a==N-1){
      if(b==ans){
        return 1 ;
      }
      return 0 ;
    }
    if(dp[a][b]!=-1)return dp[a][b];
    long res=0 ;
    if(a==0 && num[a]==0){
      res+=search(a+1,b+num[a]);
    }
    else {
      res+=search(a+1,b+num[a]);
      res+=search(a+1,b-num[a]);
    }
    return dp[a][b]=res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute num : Sequence(int);
  static   attribute dp : Sequence(Sequence(long));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := cin.getCurrent()->toInteger() ; 
    num := Integer.subrange(1,N - 1)->collect(0) ; 
    ans := 0 ; 
    dp := Integer.subrange(1,N - 1)->collect(Integer.subrange(1,21)->collect(0)) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     num[i+1] := cin.getCurrent()->toInteger() ; 
     dp[i+1] := dp[i+1]->collect(-1) )  ;     i := i + 1 ) ; 
    ans := cin.getCurrent()->toInteger() ; 
    OclFile["System.out"].println(search(0, 0)) ; 
 );
  static   operation search( a : int, b : int) : long
  pre: true
  post: true
  activity: (     if (b > 20 or b < 0) then     return 0 else skip ; 
     if (a = N - 1) then (     if (b = ans) then (     return 1 ) else skip ; 
     return 0 ) else skip ; 
    if (dp[a+1][b+1] /= -1) then     return dp[a+1][b+1] else skip ; 
    var res : long ; res := 0 ;
    if (a = 0 & num[a+1] = 0) then (     res := res+(search(a + 1, b + num[a+1])) ) else (     res := res+(search(a + 1, b + num[a+1])) ; 
     res := res+(search(a + 1, b - num[a+1])) ) ;  
    return dp[a+1][b+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class codeforces {
  public static void main(String[] args){
    Scanner ob=new Scanner(System.in);
    int t=ob.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=ob.nextInt();
      ob.nextLine();
      String s=ob.next();
      char c[]=s.toCharArray();
      int a[]=new int[27];
      for(int i=0 ; i<n ; i++){
        int temp=c[i];
        a[temp-64]++;
      }
      int ct=0 ;
      int ans=0 ;
      for(int i=1 ; i<=26 ; i++){
        if(a[i]>0){
          ct++;
          ans+=a[i]-1 ;
        }
      }
      ans+=2*ct ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ob : OclFile ; ob := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := ob.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := ob.getCurrent()->toInteger() ;
     skip ; 
    var s : String ; s := ob.getCurrent() ;
    var c : Sequence(String) ; c := s->characters() ;
    var a : Sequence(int) ; a := Integer.subrange(1,27)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : int ; temp := c[i+1] ;
     a[temp - 64+1] := a[temp - 64+1] + 1 )  ;     i := i + 1 ) ; 
    var ct : int ; ct := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= 26 do ( (     if (a[i+1] > 0) then (     ct := ct + 1 ; 
     ans := ans+(a[i+1] - 1) ) else skip )  ;     i := i + 1 ) ; 
    ans := ans+(2 * ct) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Cyclicsort {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    while(n-->0){
      String s=scn.next();
      int l=s.length();
      if(l<=10){
        System.out.println(s);
      }
      else if(l>10 && l<=100){
        System.out.println(s.charAt(0)+""+(l-2)+""+s.charAt(l-1));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cyclicsort {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var s : String ; s := scn.getCurrent() ;
     var l : int ; l := s->size() ;
     if (l <= 10) then (     OclFile["System.out"].println(s) ) else     if (l > 10 & l <= 100) then (     OclFile["System.out"].println(s->at(0+1) + "" + ((l)->char2byte() - 2) + "" + s->at((l)->char2byte() - 1+1)) ) else skip ; ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  private final static byte MASK_RIGHT=0x0F ;
  private final static int STRIP_LENGTH=10 ;
  private static int[] punchTape=new int[100];
  public static void main(String[] args)throws Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),512);
    String sLine ;
    while((sLine=reader.readLine())!=null){
      droppingInk(sLine.charAt(0)& MASK_RIGHT,sLine.charAt(2)& MASK_RIGHT,sLine.charAt(4)& MASK_RIGHT);
    }
    calcResult();
  }
  private static void droppingInk(int x,int y,int size){
    sinking(x,y-1);
    sinking(x-1,y);
    sinking(x,y);
    sinking(x+1,y);
    sinking(x,y+1);
    if(size==1){
      return ;
    }
    sinking(x-1,y-1);
    sinking(x+1,y-1);
    sinking(x-1,y+1);
    sinking(x+1,y+1);
    if(size==2){
      return ;
    }
    sinking(x,y-2);
    sinking(x-2,y);
    sinking(x+2,y);
    sinking(x,y+2);
  }
  private static void sinking(int x,int y){
    if(x>=0 && x<10 && y>=0 && y<10){
      punchTape[x*STRIP_LENGTH+y]++;
    }
  }
  private static void calcResult(){
    int white=0 ;
    int max=0 ;
    for(int cell : punchTape){
      if(cell==0){
        white++;
      }
      else if(cell>max){
        max=cell ;
      }
    }
    System.out.println(white);
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MASK_RIGHT : int := 0x0F;
  static   attribute STRIP_LENGTH : int := 10;
  static   attribute punchTape : Sequence(int) := Integer.subrange(1,100)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 512) ;
     var sLine : String ;
         sLine := reader.readLine() ;
    while ((sLine) /= null) do (    skip ; (     execute droppingInk(sLine->at(0+1) & MASK_RIGHT, sLine->at(2+1) & MASK_RIGHT, sLine->at(4+1) & MASK_RIGHT) ) ;     sLine := reader.readLine() ;
 ) ;  
     execute calcResult() );
  static   operation droppingInk( x : int, y : int, size : int) : void
  pre: true
  post: true
  activity: (     execute sinking(x, y - 1) ; 
     execute sinking(x - 1, y) ; 
    execute sinking(x, y) ; 
    execute sinking(x + 1, y) ; 
    execute sinking(x, y + 1) ; 
    if (size = 1) then (     return ) else skip ; 
    execute sinking(x - 1, y - 1) ; 
    execute sinking(x + 1, y - 1) ; 
    execute sinking(x - 1, y + 1) ; 
    execute sinking(x + 1, y + 1) ; 
    if (size = 2) then (     return ) else skip ; 
    execute sinking(x, y - 2) ; 
    execute sinking(x - 2, y) ; 
    execute sinking(x + 2, y) ; 
    execute sinking(x, y + 2) ; 
 );
  static   operation sinking( x : int, y : int) : void
  pre: true
  post: true
  activity: (     if (x >= 0 & x < 10 & y >= 0 & y < 10) then (     punchTape[x * STRIP_LENGTH + y+1] := punchTape[x * STRIP_LENGTH + y+1] + 1 ) else skip );
  static   operation calcResult() : void
  pre: true
  post: true
  activity: (     var white : int ; white := 0 ;
     var max : int ; max := 0 ;
    for (cell : punchTape) do ( (     if (cell = 0) then (     white := white + 1 ) else     if (cell > max) then (     max := cell ) else skip ; )  ) ; 
    OclFile["System.out"].println(white) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    scan.useDelimiter("[^-0-9.]+");
    while(scan.hasNext()){
      int x=scan.nextInt();
      int y=scan.nextInt();
      int s=scan.nextInt();
      switch(s){
        case 3 : color(x+2,y);
        color(x,y+2);
        color(x-2,y);
        color(x,y-2);
        case 2 : color(x+1,y+1);
        color(x+1,y-1);
        color(x-1,y+1);
        color(x-1,y-1);
        case 1 : color(x,y);
        color(x+1,y);
        color(x,y+1);
        color(x-1,y);
        color(x,y-1);
      }
    }
    int max=0 ;
    int count=0 ;
    for(int i=0 ; i<10 ; i++){
      for(int j=0 ; j<10 ; j++){
        if(a[i][j]==0)count++;
        max=Math.max(a[i][j],max);
      }
    }
    System.out.println(count);
    System.out.println(max);
  }
  static int[][] a=new int[10][10];
  static void color(int i,int j){
    if(i<0 || j<0){
      return ;
    }
    if(i>9 || j>9){
      return ;
    }
    a[i][j]++;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    while (scan.hasNext()) do (     var x : int ; x := scan.getCurrent()->toInteger() ;
     var y : int ; y := scan.getCurrent()->toInteger() ;
     var s : int ; s := scan.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (s) ; 
       if _switchval = 3 then
     execute color(x + 2, y) ; 
    execute color(x, y + 2) ; 
    execute color(x - 2, y) ; 
    execute color(x, y - 2) ; 
   else skip ;
       if _switchval = 2 then
     execute color(x + 1, y + 1) ; 
    execute color(x + 1, y - 1) ; 
    execute color(x - 1, y + 1) ; 
    execute color(x - 1, y - 1) ; 
   else skip ;
       if _switchval = 1 then
     execute color(x, y) ; 
    execute color(x + 1, y) ; 
    execute color(x, y + 1) ; 
    execute color(x - 1, y) ; 
    execute color(x, y - 1) ; 
   else skip ;
 )
 ) ; 
    var max : int ; max := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < 10 do ( (     if (a[i+1][j+1] = 0) then     count := count + 1 ; else skip ; 
     max := Set{a[i+1][j+1], max}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    OclFile["System.out"].println(max) ; 
 );
  static   attribute a : Sequence(Sequence(int)) := Integer.subrange(1,10)->collect(Integer.subrange(1,10)->collect(0));
  static   operation color( i : int, j : int) : void
  pre: true
  post: true
  activity: (     if (i < 0 or j < 0) then (     return ) else skip ; 
     if (i > 9 or j > 9) then (     return ) else skip ; 
     a[i+1][j+1] := a[i+1][j+1] + 1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static int[][] paper=new int[10][10];
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),128);
    String sLine ;
    while((sLine=reader.readLine())!=null){
      droppingInk(sLine.charAt(0)& 0x0F,sLine.charAt(2)& 0x0F,sLine.charAt(4)& 0x0F);
    }
    calcResult();
  }
  private static void droppingInk(int x,int y,int size){
    staining(x,y-1);
    staining(x-1,y);
    staining(x,y);
    staining(x+1,y);
    staining(x,y+1);
    if(size==1){
      return ;
    }
    staining(x-1,y-1);
    staining(x+1,y-1);
    staining(x-1,y+1);
    staining(x+1,y+1);
    if(size==2){
      return ;
    }
    staining(x,y-2);
    staining(x-2,y);
    staining(x+2,y);
    staining(x,y+2);
  }
  private static void staining(int x,int y){
    if(x>=0 && x<10 && y>=0 && y<10){
      paper[x][y]++;
    }
  }
  private static void calcResult(){
    int white=0 ;
    int maxnoud=0 ;
    for(int[] row : paper){
      for(int colum : row){
        if(colum==0){
          white++;
        }
        else if(colum>maxnoud){
          maxnoud=colum ;
        }
      }
    }
    System.out.println(white);
    System.out.println(maxnoud);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute paper : Sequence(Sequence(int)) := Integer.subrange(1,10)->collect(Integer.subrange(1,10)->collect(0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 128) ;
     var sLine : String ;
         sLine := reader.readLine() ;
    while ((sLine) /= null) do (    skip ; (     execute droppingInk(sLine->at(0+1) & 0x0F, sLine->at(2+1) & 0x0F, sLine->at(4+1) & 0x0F) ) ;     sLine := reader.readLine() ;
 ) ;  
     execute calcResult() );
  static   operation droppingInk( x : int, y : int, size : int) : void
  pre: true
  post: true
  activity: (     execute staining(x, y - 1) ; 
     execute staining(x - 1, y) ; 
    execute staining(x, y) ; 
    execute staining(x + 1, y) ; 
    execute staining(x, y + 1) ; 
    if (size = 1) then (     return ) else skip ; 
    execute staining(x - 1, y - 1) ; 
    execute staining(x + 1, y - 1) ; 
    execute staining(x - 1, y + 1) ; 
    execute staining(x + 1, y + 1) ; 
    if (size = 2) then (     return ) else skip ; 
    execute staining(x, y - 2) ; 
    execute staining(x - 2, y) ; 
    execute staining(x + 2, y) ; 
    execute staining(x, y + 2) ; 
 );
  static   operation staining( x : int, y : int) : void
  pre: true
  post: true
  activity: (     if (x >= 0 & x < 10 & y >= 0 & y < 10) then (     paper[x+1][y+1] := paper[x+1][y+1] + 1 ) else skip );
  static   operation calcResult() : void
  pre: true
  post: true
  activity: (     var white : int ; white := 0 ;
     var maxnoud : int ; maxnoud := 0 ;
    for (row : paper) do ( (     for (colum : row) do ( (     if (colum = 0) then (     white := white + 1 ) else     if (colum > maxnoud) then (     maxnoud := colum ) else skip ; )  ) )  ) ; 
    OclFile["System.out"].println(white) ; 
    OclFile["System.out"].println(maxnoud) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private final byte MASK_RIGHT=0x0F ;
  private int[][] paper=new int[10][10];
  public static void main(String[] args)throws NumberFormatException,IOException {
    new Main().execute();
  }
  private void execute()throws NumberFormatException,IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),128);
    String sLine ;
    while((sLine=reader.readLine())!=null){
      droppingInk(sLine.charAt(0)& MASK_RIGHT,sLine.charAt(2)& MASK_RIGHT,sLine.charAt(4)& MASK_RIGHT);
    }
    calcResult();
  }
  private void droppingInk(int x,int y,int size){
    sinking(x,y-1);
    sinking(x-1,y);
    sinking(x,y);
    sinking(x+1,y);
    sinking(x,y+1);
    if(size==1){
      return ;
    }
    sinking(x-1,y-1);
    sinking(x+1,y-1);
    sinking(x-1,y+1);
    sinking(x+1,y+1);
    if(size==2){
      return ;
    }
    sinking(x,y-2);
    sinking(x-2,y);
    sinking(x+2,y);
    sinking(x,y+2);
  }
  private void sinking(int x,int y){
    if(x>=0 && x<10 && y>=0 && y<10){
      paper[x][y]++;
    }
  }
  private void calcResult(){
    int white=0 ;
    int max=0 ;
    for(int[] row : paper){
      for(int colum : row){
        if(colum==0){
          white++;
        }
        else if(colum>max){
          max=colum ;
        }
      }
    }
    System.out.println(white);
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute MASK_RIGHT : int := 0x0F;
   attribute paper : Sequence(Sequence(int)) := Integer.subrange(1,10)->collect(Integer.subrange(1,10)->collect(0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().execute() );
   operation execute() : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 128) ;
     var sLine : String ;
         sLine := reader.readLine() ;
    while ((sLine) /= null) do (    skip ; (     execute droppingInk(sLine->at(0+1) & MASK_RIGHT, sLine->at(2+1) & MASK_RIGHT, sLine->at(4+1) & MASK_RIGHT) ) ;     sLine := reader.readLine() ;
 ) ;  
     execute calcResult() );
   operation droppingInk( x : int, y : int, size : int) : void
  pre: true
  post: true
  activity: (     execute sinking(x, y - 1) ; 
     execute sinking(x - 1, y) ; 
    execute sinking(x, y) ; 
    execute sinking(x + 1, y) ; 
    execute sinking(x, y + 1) ; 
    if (size = 1) then (     return ) else skip ; 
    execute sinking(x - 1, y - 1) ; 
    execute sinking(x + 1, y - 1) ; 
    execute sinking(x - 1, y + 1) ; 
    execute sinking(x + 1, y + 1) ; 
    if (size = 2) then (     return ) else skip ; 
    execute sinking(x, y - 2) ; 
    execute sinking(x - 2, y) ; 
    execute sinking(x + 2, y) ; 
    execute sinking(x, y + 2) ; 
 );
   operation sinking( x : int, y : int) : void
  pre: true
  post: true
  activity: (     if (x >= 0 & x < 10 & y >= 0 & y < 10) then (     paper[x+1][y+1] := paper[x+1][y+1] + 1 ) else skip );
   operation calcResult() : void
  pre: true
  post: true
  activity: (     var white : int ; white := 0 ;
     var max : int ; max := 0 ;
    for (row : paper) do ( (     for (colum : row) do ( (     if (colum = 0) then (     white := white + 1 ) else     if (colum > max) then (     max := colum ) else skip ; )  ) )  ) ; 
    OclFile["System.out"].println(white) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  private final static byte MASK_RIGHT=0x0F ;
  private final static int STRIP_LENGTH=10 ;
  private static int[] punchTape=new int[100];
  public static void main(String[] args)throws Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),256);
    String sLine ;
    while((sLine=reader.readLine())!=null){
      droppingInk(sLine.charAt(0)& MASK_RIGHT,sLine.charAt(2)& MASK_RIGHT,sLine.charAt(4)& MASK_RIGHT);
    }
    calcResult();
  }
  private static void droppingInk(int x,int y,int size){
    sinking(x,y-1);
    sinking(x-1,y);
    sinking(x,y);
    sinking(x+1,y);
    sinking(x,y+1);
    if(size==1){
      return ;
    }
    sinking(x-1,y-1);
    sinking(x+1,y-1);
    sinking(x-1,y+1);
    sinking(x+1,y+1);
    if(size==2){
      return ;
    }
    sinking(x,y-2);
    sinking(x-2,y);
    sinking(x+2,y);
    sinking(x,y+2);
  }
  private static void sinking(int x,int y){
    if(x>=0 && x<10 && y>=0 && y<10){
      punchTape[x*STRIP_LENGTH+y]++;
    }
  }
  private static void calcResult(){
    int white=0 ;
    int max=0 ;
    for(int cell : punchTape){
      if(cell==0){
        white++;
      }
      else if(cell>max){
        max=cell ;
      }
    }
    System.out.println(white);
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MASK_RIGHT : int := 0x0F;
  static   attribute STRIP_LENGTH : int := 10;
  static   attribute punchTape : Sequence(int) := Integer.subrange(1,100)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 256) ;
     var sLine : String ;
         sLine := reader.readLine() ;
    while ((sLine) /= null) do (    skip ; (     execute droppingInk(sLine->at(0+1) & MASK_RIGHT, sLine->at(2+1) & MASK_RIGHT, sLine->at(4+1) & MASK_RIGHT) ) ;     sLine := reader.readLine() ;
 ) ;  
     execute calcResult() );
  static   operation droppingInk( x : int, y : int, size : int) : void
  pre: true
  post: true
  activity: (     execute sinking(x, y - 1) ; 
     execute sinking(x - 1, y) ; 
    execute sinking(x, y) ; 
    execute sinking(x + 1, y) ; 
    execute sinking(x, y + 1) ; 
    if (size = 1) then (     return ) else skip ; 
    execute sinking(x - 1, y - 1) ; 
    execute sinking(x + 1, y - 1) ; 
    execute sinking(x - 1, y + 1) ; 
    execute sinking(x + 1, y + 1) ; 
    if (size = 2) then (     return ) else skip ; 
    execute sinking(x, y - 2) ; 
    execute sinking(x - 2, y) ; 
    execute sinking(x + 2, y) ; 
    execute sinking(x, y + 2) ; 
 );
  static   operation sinking( x : int, y : int) : void
  pre: true
  post: true
  activity: (     if (x >= 0 & x < 10 & y >= 0 & y < 10) then (     punchTape[x * STRIP_LENGTH + y+1] := punchTape[x * STRIP_LENGTH + y+1] + 1 ) else skip );
  static   operation calcResult() : void
  pre: true
  post: true
  activity: (     var white : int ; white := 0 ;
     var max : int ; max := 0 ;
    for (cell : punchTape) do ( (     if (cell = 0) then (     white := white + 1 ) else     if (cell > max) then (     max := cell ) else skip ; )  ) ; 
    OclFile["System.out"].println(white) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean checkPalin(String word){
    int n=word.length();
    word=word.toLowerCase();
    for(int i=0 ; i<n ; i++,n--)if(word.charAt(i)!=word.charAt(n-1))return false ;
    return true ;
  }
  static int countPalin(String str){
    str=str+" " ;
    String word="" ;
    int count=0 ;
    for(int i=0 ; i<str.length(); i++){
      char ch=str.charAt(i);
      if(ch!=' ')word=word+ch ;
      else {
        if(checkPalin(word))count++;
        word="" ;
      }
    }
    return count ;
  }
  public static void main(String args[]){
    System.out.println(countPalin("Madam "+"Arora teaches malayalam"));
    System.out.println(countPalin("Nitin "+"speaks malayalam"));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkPalin( word : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := word->size() ;
     word := word->toLowerCase() ; 
         var i : int ; i := 0 ; while i < n do (     if (word->at(i+1) /= word->at(n - 1+1)) then     return false else skip ;  ;     i := i + 1 ;     n := n - 1 ) ; 
     return true );
  static   operation countPalin( str : String) : int
  pre: true
  post: true
  activity: (     str := str + " " ; 
     var word : String ; word := "" ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     var ch : String ; ch := str->at(i+1) ;
     if (ch /= ' ') then     word := word + ch ; else (     if (checkPalin(word)) then     count := count + 1 ; else skip ; 
     word := "" ) )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(countPalin("Madam " + "Arora teaches malayalam")) ; 
     OclFile["System.out"].println(countPalin("Nitin " + "speaks malayalam")) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.time.LocalDate ;
import java.time.Period ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    age_difference();
  }
  private static void age_difference(){
    Scanner sc=new Scanner(System.in);
    int[] d=new int[6];
    for(int i=0 ; i<6 ; i++){
      d[i]=sc.nextInt();
    }
    LocalDate d1=LocalDate.of(d[0],d[1],d[2]);
    LocalDate d2=LocalDate.of(d[3],d[4],d[5]);
    int age_diff=Math.abs(Period.between(d1,d2).getYears());
    if(d[1]==d[4] && d[2]==d[5]){
      System.out.println(age_diff);
    }
    else {
      System.out.println(age_diff+1);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute age_difference() );
  static   operation age_difference() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : Sequence(int) ; d := Integer.subrange(1,6)->collect(0) ;
        var i : int ; i := 0 ; while i < 6 do ( (     d[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var d1 : LocalDate ; d1 := LocalDate.of(d[0+1], d[1+1], d[2+1]) ;
    var d2 : LocalDate ; d2 := LocalDate.of(d[3+1], d[4+1], d[5+1]) ;
    var age_diff : int ; age_diff := if Period.between(d1, d2).getYears() < 0 then -(Period.between(d1, d2).getYears()) else Period.between(d1, d2).getYears() endif ;
    if (d[1+1] = d[4+1] & d[2+1] = d[5+1]) then (     OclFile["System.out"].println(age_diff) ) else (     OclFile["System.out"].println(age_diff + 1) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sc.nextLine();
    String s=sc.nextLine().replace(" ","");
    s+=s ;
    int Lengmax=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='1'){
        int len=0 ;
        while(i<s.length()&& s.charAt(i)=='1'){
          len++;
          i++;
        }
        i-=1 ;
        Lengmax=Math.max(Lengmax,len);
      }
    }
    System.out.println(Lengmax);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var s : String ; s := sc.nextLine().replace(" ", "") ;
    s := s+(s) ; 
    var Lengmax : int ; Lengmax := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '1') then (     var len : int ; len := 0 ;
     while (i < s->size() & s->at(i+1) = '1') do (     len := len + 1 ; 
     i := i + 1 ) ; 
     i := i-(1) ; 
     Lengmax := Set{Lengmax, len}->max() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Lengmax) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class maxContiRest {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    int result=0 ;
    int len=0 ;
    for(int i=0 ; i<2*n ; i++){
      if(a[i % n]==1){
        len++;
        result=Integer.max(result,len);
      }
      else {
        len=0 ;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class maxContiRest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
    var len : int ; len := 0 ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     if (a[i mod n+1] = 1) then (     len := len + 1 ; 
     result := Set{result, len}->max() ) else (     len := 0 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class B_ICPC_Balloons {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int tc=sc.nextInt();
    while(tc-->0){
      int n=sc.nextInt();
      String str=sc.next();
      Set<Character>s=new HashSet<>();
      int ans=0 ;
      for(char c : str.toCharArray()){
        if(! s.contains(c))ans+=2 ;
        else ans+=1 ;
        s.add(c);
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_ICPC_Balloons {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := sc.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var str : String ; str := sc.getCurrent() ;
    var s : Set(String) ; s := Set{} ;
    var ans : int ; ans := 0 ;
    for (c : str->characters()) do ( (     if (not(s->includes(c))) then     ans := ans+(2) else     ans := ans+(1) ; ;  
     s := s->including(c) )  ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigDecimal ;
import java.math.MathContext ;
import java.util.*;
public class ProblemD {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    String line[]=br.readLine().split(" ");
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=Integer.parseInt(line[i]);
    int ans=0,count=0 ;
    boolean ok=true ;
    for(int i=0 ; i<n ; i++){
      if(i==n-1 && arr[i]==1 && ok){
        count++;
        i=0 ;
        ok=false ;
      }
      if(arr[i]==1)count++;
      else {
        ans=Math.max(count,ans);
        count=0 ;
      }
    }
    System.out.println(ans);
  }
  public static int gcd(int a,int b){
    return b==0 ? a : gcd(b,a % b);
  }
  public static int search(int l,int r,int target,int arr[]){
    int ans=0 ;
    while(l<=r){
      int mid=(l+r)/2 ;
      if(arr[mid]<=target){
        ans=mid ;
        l=mid+1 ;
      }
      else r=mid-1 ;
    }
    return ans ;
  }
  public static void sort(int arr[]){
    ArrayList<Integer>list=new ArrayList<>();
    for(int it : arr)list.add(it);
    Collections.sort(list);
    for(int i=0 ; i<list.size(); i++)arr[i]=list.get(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemD {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := (line[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var count : int ; count := 0 ;
    var ok : boolean ; ok := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (i = (n)->char2byte() - 1 & arr[i+1] = 1 & ok) then (     count := count + 1 ; 
     i := 0 ; 
     ok := false ) else skip ; 
     if (arr[i+1] = 1) then     count := count + 1 ; else (     ans := Set{count, ans}->max() ; 
     count := 0 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
  static   operation search( l : int, r : int, target : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     while (l <= r) do (     var mid : int ; mid := (l + r) / 2 ;
     if (arr[mid+1] <= target) then (     ans := mid ; 
     l := mid + 1 ) else     r := mid - 1 ; ) ; 
     return ans );
  static   operation sort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     for (it : arr) do (     list := list->including(it) ;  ) ; 
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < list->size() do (     arr[i+1] := list->at(i+1) ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder();
    int n=fs.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=fs.nextInt();
    }
    List<Integer>list=new ArrayList<>();
    int cnt=0,max=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      list.add(a[i]);
    }
    for(int i=0 ; i<n ; i++){
      list.add(a[i]);
    }
    for(int i : list){
      if(i==0)cnt=0 ;
      if(max<cnt)max=cnt ;
      cnt++;
    }
    out.print(max);
    out.close();
  }
  static int isPerfectSquare(int x){
    if(x>=0){
      int sr=(int)Math.sqrt(x);
      if((sr*sr)==x)return sr ;
      else return 0 ;
    }
    return 0 ;
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    Long[] readArray(int n){
      Long[] a=new Long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := fs.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := fs.nextInt() )  ;     i := i + 1 ) ; 
    var list : Sequence(int) ; list := Sequence{} ;
    var cnt : int ; cnt := 0 ;
    var max : int ; max := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(a[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(a[i+1]) )  ;     i := i + 1 ) ; 
    for (i : list) do ( (     if (i = 0) then     cnt := 0 ; else skip ; 
     if (max < cnt) then     max := cnt ; else skip ; 
     cnt := cnt + 1 )  ) ; 
    skip ; 
    skip ; 
 );
  static   operation isPerfectSquare( x : int) : int
  pre: true
  post: true
  activity: (     if (x >= 0) then (     var sr : int ; sr := (x)->sqrt()->oclAsType(int) ;
     if ((sr * sr) = x) then     return sr else     return 0 ) else skip ; 
     return 0 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int lcs(String X,String Y,int m,int n){
    if(m==0 || n==0){
      return 0 ;
    }
    if(X.charAt(m-1)==Y.charAt(n-1)){
      return 1+lcs(X,Y,m-1,n-1);
    }
    else {
      return Math.max(lcs(X,Y,m,n-1),lcs(X,Y,m-1,n));
    }
  }
  public static void main(String[] args){
    String X="AGGTAB" ;
    String Y="GXTXAYB" ;
    int m=X.length();
    int n=Y.length();
    System.out.println("Length of LCS: "+lcs(X,Y,m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation lcs( X : String, Y : String, m : int, n : int) : int
  pre: true
  post: true
  activity: (     if (m = 0 or n = 0) then (     return 0 ) else skip ; 
     if (X->at(m - 1+1) = Y->at(n - 1+1)) then (     return 1 + lcs(X, Y, m - 1, n - 1) ) else (     return Set{lcs(X, Y, m, n - 1), lcs(X, Y, m - 1, n)}->max() ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : String ; X := "AGGTAB" ;
     var Y : String ; Y := "GXTXAYB" ;
    var m : int ; m := X->size() ;
    var n : int ; n := Y->size() ;
    OclFile["System.out"].println("Length of LCS: " + lcs(X, Y, m, n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maxSelectionCount(int a[],int n){
    int res=0 ;
    Arrays.sort(a);
    int select=1 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]>=select){
        res++;
        select++;
      }
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      4,2,1,3,5,1,4 };
      int N=arr.length ;
      System.out.println(maxSelectionCount(arr,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSelectionCount( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     a := a->sort() ; 
    var select : int ; select := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] >= select) then (     res := res + 1 ; 
     select := select + 1 ) else skip )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,2,1,3,5,1,4} ;
     var N : int ; N := arr->size() ;
     OclFile["System.out"].println(maxSelectionCount(arr, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
class GFG {
  static int MAX_SIZE=10 ;
  static void sortByRow(Integer mat[][],int n,boolean ascending){
    for(int i=0 ; i<n ; i++){
      if(ascending)Arrays.sort(mat[i]);
      else Arrays.sort(mat[i],Collections.reverseOrder());
    }
  }
  static void transpose(Integer mat[][],int n){
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++){
      int temp=mat[i][j];
      mat[i][j]=mat[j][i];
      mat[j][i]=temp ;
    }
  }
  static void sortMatRowAndColWise(Integer mat[][],int n){
    sortByRow(mat,n,true);
    transpose(mat,n);
    sortByRow(mat,n,false);
    transpose(mat,n);
  }
  static void printMat(Integer mat[][],int n){
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++)System.out.print(mat[i][j]+" ");
      System.out.println();
    }
  }
  public static void main(String[] args){
    int n=3 ;
    Integer mat[][]={
      {
        3,2,1 },{
          9,8,7 },{
            6,5,4 }
          };
          System.out.print("Original Matrix:\n");
          printMat(mat,n);
          sortMatRowAndColWise(mat,n);
          System.out.print("\nMatrix After Sorting:\n");
          printMat(mat,n);
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX_SIZE : int := 10;
  static   operation sortByRow( mat : Sequence(Sequence(int)), n : int, ascending : boolean) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (ascending) then     mat[i+1] := mat[i+1]->sort() ; else     mat[i+1] := OclComparator.sortWith(mat[i+1], reverseOrder()) ; )  ;     i := i + 1 ) );
  static   operation transpose( mat : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do ( (     var temp : int ; temp := mat[i+1][j+1] ;
     mat[i+1][j+1] := mat[j+1][i+1] ; 
     mat[j+1][i+1] := temp )  ;     j := j + 1 ) ;  ;     i := i + 1 ) );
  static   operation sortMatRowAndColWise( mat : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (     execute sortByRow(mat, n, true) ; 
     execute transpose(mat, n) ; 
     execute sortByRow(mat, n, false) ; 
     execute transpose(mat, n) );
  static   operation printMat( mat : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do (     OclFile["System.out"].print(mat[i+1][j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{3,2,1},Sequence{9,8,7},Sequence{6,5,4}} ;
    OclFile["System.out"].print("Original Matrix:\n") ; 
    execute printMat(mat, n) ; 
    execute sortMatRowAndColWise(mat, n) ; 
    OclFile["System.out"].print("\nMatrix After Sorting:\n") ; 
    execute printMat(mat, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String ards[]){
    Scanner cin=new Scanner(System.in);
    while(cin.hasNext()){
      long n=cin.nextLong();
      long m=cin.nextLong();
      if(n>m){
        long x=n ;
        n=m ;
        m=x ;
      }
      if(n==1){
        if(m % 6==0)System.out.println(m);
        else if(m % 6<=3)System.out.println(m-(m % 6));
        else System.out.println(m-(6-m % 6));
      }
      else if(n==2 && m==2)System.out.println(0);
      else if(n==2 && m==3)System.out.println(4);
      else if(n==2 && m==7)System.out.println(12);
      else {
        if(n % 2==1 && m % 2==1)System.out.println(n*m-1);
        else System.out.println(n*m);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( ards : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (cin.hasNext()) do (     var n : long ; n := cin.getCurrent()->toLong() ;
     var m : long ; m := cin.getCurrent()->toLong() ;
     if (n > m) then (     var x : long ; x := n ;
     n := m ; 
     m := x ) else skip ; 
     if (n = 1) then (     if (m mod 6 = 0) then     OclFile["System.out"].println(m) ; else     if (m mod 6 <= 3) then     OclFile["System.out"].println(m - (m mod 6)) else     OclFile["System.out"].println(m - (6 - m mod 6)) ; ;  ) else     if (n = 2 & m = 2) then     OclFile["System.out"].println(0) else     if (n = 2 & m = 3) then     OclFile["System.out"].println(4) else     if (n = 2 & m = 7) then     OclFile["System.out"].println(12) else (     if (n mod 2 = 1 & m mod 2 = 1) then     OclFile["System.out"].println(n * m - 1) ; else     OclFile["System.out"].println(n * m) ; ) ;  ;  ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int[] p1=new int[3];
    int[] p2=new int[3];
    for(int i=0 ; i<3 ; ++i)p1[i]=sc.nextInt();
    for(int i=0 ; i<3 ; ++i)p2[i]=sc.nextInt();
    if(p1[0]>p2[0] ||(p1[0]==p2[0] &&(p1[1]>p2[1] ||(p1[1]==p2[1] && p1[2]>p2[2])))){
      int t=p1[0];
      p1[0]=p2[0];
      p2[0]=t ;
      t=p1[1];
      p1[1]=p2[1];
      p2[1]=t ;
      t=p1[2];
      p1[2]=p2[2];
      p2[2]=t ;
    }
    if(p1[1]<p2[1] ||(p1[1]==p2[1] && p1[2]<p2[2]))System.out.println(p2[0]-p1[0]+1);
    else System.out.println(p2[0]-p1[0]);
  }
  public static void main(String[] a){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p1 : Sequence(int) ; p1 := Integer.subrange(1,3)->collect(0) ;
    var p2 : Sequence(int) ; p2 := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do (     p1[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do (     p2[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    if (p1[0+1] > p2[0+1] or (p1[0+1] = p2[0+1] & (p1[1+1] > p2[1+1] or (p1[1+1] = p2[1+1] & p1[2+1] > p2[2+1])))) then (     var t : int ; t := p1[0+1] ;
     p1[0+1] := p2[0+1] ; 
    p2[0+1] := t ; 
    t := p1[1+1] ; 
    p1[1+1] := p2[1+1] ; 
    p2[1+1] := t ; 
    t := p1[2+1] ; 
    p1[2+1] := p2[2+1] ; 
    p2[2+1] := t ; 
 ) else skip ; 
    if (p1[1+1] < p2[1+1] or (p1[1+1] = p2[1+1] & p1[2+1] < p2[2+1])) then     OclFile["System.out"].println(p2[0+1] - p1[0+1] + 1) else     OclFile["System.out"].println(p2[0+1] - p1[0+1]) ; ;  
 );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String args[]){
    new Main().run();
  }
  FastReader in=new FastReader();
  PrintWriter out=new PrintWriter(System.out);
  void run(){
    work();
    out.flush();
  }
  long mod=1000000007 ;
  long gcd(long a,long b){
    return b==0 ? a : gcd(b,a % b);
  }
  void work(){
    long n=in.nextInt();
    long m=in.nextInt();
    if(n>m){
      long t=m ;
      m=n ;
      n=t ;
    }
    long v=0 ;
    if(n==1){
      v=m/6*6 ;
      if(m % 6==4)v+=2 ;
      if(m % 6==5)v+=4 ;
    }
    else if(n<=2 && m<=2){
      v=0 ;
    }
    else if(n==2 && m==3){
      v=4 ;
    }
    else if(n==2 && m==7){
      v=12 ;
    }
    else if(n % 2==0){
      v=n*m ;
    }
    else if(n % 2==1){
      v=n*m ;
      if(m % 2==1)v--;
    }
    out.println(v);
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public String next(){
    if(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 long nextLong(){
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute in : FastReader := FastReader.newFastReader();
   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   operation run() : void
  pre: true
  post: true
  activity: (     execute work() ; 
     skip );
   attribute mod : long := 1000000007;
   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
   operation work() : void
  pre: true
  post: true
  activity: (     var n : long ; n := in.nextInt() ;
     var m : long ; m := in.nextInt() ;
    if (n > m) then (     var t : long ; t := m ;
     m := n ; 
     n := t ) else skip ; 
    var v : long ; v := 0 ;
    if (n = 1) then (     v := m / 6 * 6 ; 
     if (m mod 6 = 4) then     v := v+(2) ; else skip ; 
     if (m mod 6 = 5) then     v := v+(4) ; else skip ) else     if (n <= 2 & m <= 2) then (     v := 0 ) else     if (n = 2 & m = 3) then (     v := 4 ) else     if (n = 2 & m = 7) then (     v := 12 ) else     if (n mod 2 = 0) then (     v := n * m ) else     if (n mod 2 = 1) then (     v := n * m ; 
     if (m mod 2 = 1) then     v := v - 1 ; else skip ) else skip ; ;  ;  ;  ;  ;  
    skip ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (st = null or not(st.hasNext())) then (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) else skip ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B1034 {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long n=sc.nextLong();
    long m=sc.nextLong();
    if(n>m){
      long temp=n ;
      n=m ;
      m=temp ;
    }
    if(n==1){
      pw.println(6*(m/6)+((m % 6)==4 ? 2 :(m % 6)==5 ? 4 : 0));
    }
    else if(n==2){
      if(m==2){
        pw.println(0);
      }
      else if(m==3){
        pw.println(4);
      }
      else if(m==7){
        pw.println(12);
      }
      else {
        pw.println(n*m);
      }
    }
    else if(n % 2==0 || m % 2==0){
      pw.println(n*m);
    }
    else {
      pw.println(n*m-1);
    }
    pw.close();
  }
  static class Scanner {
    BufferedReader br ;
    StringTokenizer st ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(FileReader f){
      br=new BufferedReader(f);
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public int[] nextIntArr(int n)throws IOException {
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=Integer.parseInt(next());
      }
      return arr ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1034 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := sc.getCurrent()->toLong() ;
    var m : long ; m := sc.getCurrent()->toLong() ;
    if (n > m) then (     var temp : long ; temp := n ;
     n := m ; 
     m := temp ) else skip ; 
    if (n = 1) then (     skip ) else     if (n = 2) then (     if (m = 2) then (     skip ) else     if (m = 3) then (     skip ) else     if (m = 7) then (     skip ) else (     skip ) ;  ;  ) else     if (n mod 2 = 0 or m mod 2 = 0) then (     skip ) else (     skip ) ;  ;  ;  
    skip ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( f : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(f) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArr( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (next())->toInteger() )  ;     i := i + 1 ) ; 
     return arr );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int p=700 ;
    String s=sc.next();
    for(int i=0 ; i<s.length(); ++i){
      if(s.charAt(i)=='o')p+=100 ;
    }
    System.out.println(p);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : int ; p := 700 ;
    var s : String ; s := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'o') then     p := p+(100) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(p) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.List ;
class Main {
  public static void main(String[] args)throws Exception {
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      List<String>toppingSheet=Arrays.asList(br.readLine().split(""));
      int ramenPrice=700 ;
      int toppingPrice=100 ;
      for(String topping : toppingSheet){
        if(topping.equals("o")){
          ramenPrice+=toppingPrice ;
        }
      }
      System.out.println(ramenPrice);
    }
    catch(IOException | NumberFormatException e){
      e.printStackTrace();
      System.exit(0);
    }
    catch(final Exception e){
      e.printStackTrace();
      System.exit(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var toppingSheet : Sequence(String) ; toppingSheet := br.readLine()->split("") ;
    var ramenPrice : int ; ramenPrice := 700 ;
    var toppingPrice : int ; toppingPrice := 100 ;
    for (topping : toppingSheet) do ( (     if (topping = "o") then (     ramenPrice := ramenPrice+(toppingPrice) ) else skip )  ) ; 
    OclFile["System.out"].println(ramenPrice) ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
 OclProcess.exit(0) )
   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(0) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class lab5oops {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      String str=sc.next();
      HashSet<Character>hs=new HashSet<>();
      int count=0 ;
      for(int i=0 ; i<str.length(); i++){
        if(hs.contains(str.charAt(i))){
          count++;
        }
        else {
          hs.add(str.charAt(i));
          count+=2 ;
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class lab5oops {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var str : String ; str := sc.getCurrent() ;
    var hs : Set(String) ; hs := Set{} ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (hs->includes(str->at(i+1))) then (     count := count + 1 ) else (     hs := hs->including(str->at(i+1)) ; 
     count := count+(2) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    HashMap<Character,Integer>hm=new HashMap<Character,Integer>();
    String a=sc.next();
    int sum=700 ;
    for(int i=0 ; i<a.length(); i++){
      int v ;
      char b=a.charAt(i);
      if(hm.containsKey(b)){
        v=hm.get(b)+1 ;
      }
      else {
        v=1 ;
      }
      hm.put(b,v);
    }
    int ans=hm.getOrDefault('o',0);
    sum=sum+ans*100 ;
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var hm : Map(String,int) ; hm := Map{} ;
    var a : String ; a := sc.getCurrent() ;
    var sum : int ; sum := 700 ;
        var i : int ; i := 0 ; while i < a->size() do ( (     var v : int ;
     var b : String ; b := a->at(i+1) ;
     if (hm->keys()->includes(b)) then (     v := hm->at(b) + 1 ) else (     v := 1 ) ;  
     hm := hm->union(Map{b |-> v}) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := (if hm->keys()->contains('o') then hm->at('o') else 0 endif) ;
    sum := sum + ans * 100 ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int x=700 ;
    if(s.substring(0,1).equals("o")){
      x+=100 ;
    }
    if(s.substring(1,2).equals("o")){
      x+=100 ;
    }
    if(s.substring(2,3).equals("o")){
      x+=100 ;
    }
    System.out.println(x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var x : int ; x := 700 ;
    if (s.subrange(0+1,1) = "o") then (     x := x+(100) ) else skip ; 
    if (s.subrange(1+1,2) = "o") then (     x := x+(100) ) else skip ; 
    if (s.subrange(2+1,3) = "o") then (     x := x+(100) ) else skip ; 
    OclFile["System.out"].println(x) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] s=sc.nextLine().toCharArray();
    int count=0 ;
    for(char c : s){
      if(c=='o'){
        count++;
      }
    }
    System.out.println(700+(count*100));
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc.nextLine()->characters() ;
    var count : int ; count := 0 ;
    for (c : s) do ( (     if (c = 'o') then (     count := count + 1 ) else skip )  ) ; 
    OclFile["System.out"].println(700 + (count * 100)) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean checkEvenParity(int x){
    int parity=0 ;
    while(x!=0){
      x=x &(x-1);
      parity++;
    }
    if(parity % 2==0)return true ;
    else return false ;
  }
  static long sumlist(int a[],int n){
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(checkEvenParity(a[i]))sum+=a[i];
    }
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      2,4,3,5,9 };
      int n=arr.length ;
      System.out.println(sumlist(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkEvenParity( x : int) : boolean
  pre: true
  post: true
  activity: (     var parity : int ; parity := 0 ;
     while (x /= 0) do (     x := x & (x - 1) ; 
     parity := parity + 1 ) ; 
     if (parity mod 2 = 0) then     return true else     return false );
  static   operation sumlist( a : Sequence(int), n : int) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (checkEvenParity(a[i+1])) then     sum := sum+(a[i+1]) ; else skip )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,3,5,9} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(sumlist(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long n=in.nextInt();
    int m=in.nextInt();
    int[] a=new int[m];
    int[] b=new int[m];
    int temp ;
    ArrayList<Integer>c=new ArrayList<Integer>();
    for(int i=0 ; i<m ; i++){
      a[i]=in.nextInt();
      b[i]=in.nextInt();
    }
    int count=0 ;
    for(int i=0 ; i<m ; i++){
      for(int j=0 ; j<m ; j++){
        if(i!=j && b[j]<b[i]){
          temp=b[j];
          b[j]=b[i];
          b[i]=temp ;
          temp=a[j];
          a[j]=a[i];
          a[i]=temp ;
        }
      }
    }
    for(int i=0 ; i<m ; i++){
      if(n>a[i]){
        count+=b[i]*a[i];
        n-=a[i];
      }
      else {
        count+=n*b[i];
        break ;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
    var temp : int ;
    var c : Sequence(int) ; c := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     b[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j < m do ( (     if (i /= j & b[j+1] < b[i+1]) then (     temp := b[j+1] ; 
     b[j+1] := b[i+1] ; 
    b[i+1] := temp ; 
    temp := a[j+1] ; 
    a[j+1] := a[i+1] ; 
    a[i+1] := temp ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     if (n > a[i+1]) then (     count := count+(b[i+1] * a[i+1]) ; 
     n := n-(a[i+1]) ) else (     count := count+(n * b[i+1]) ; 
     break ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int y1=sc.nextInt(),m1=sc.nextInt(),d1=sc.nextInt();
    int y2=sc.nextInt(),m2=sc.nextInt(),d2=sc.nextInt();
    boolean mdsame=m1==m2 && d1==d2 ;
    int diff=Math.abs(y1-y2)+1 ;
    if(mdsame){
      System.out.println(diff-1);
      return ;
    }
    if(y1<y2){
      if(dmcomp(m1,d1,m2,d2)){
      }
      else {
        diff-=1 ;
      }
    }
    else if(y1>y2){
      if(! dmcomp(m1,d1,m2,d2)){
      }
      else {
        diff-=1 ;
      }
    }
    else if(y1==y2){
      System.out.println(1);
      return ;
    }
    System.out.println(diff);
  }
  static boolean dmcomp(int m1,int d1,int m2,int d2){
    return 100*m1+d1<100*m2+d2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var y1 : int ; y1 := sc.getCurrent()->toInteger() ;
    var m1 : int ; m1 := sc.getCurrent()->toInteger() ;
    var d1 : int ; d1 := sc.getCurrent()->toInteger() ;
    var y2 : int ; y2 := sc.getCurrent()->toInteger() ;
    var m2 : int ; m2 := sc.getCurrent()->toInteger() ;
    var d2 : int ; d2 := sc.getCurrent()->toInteger() ;
    var mdsame : boolean ; mdsame := m1 = m2 & d1 = d2 ;
    var diff : int ; diff := if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif + 1 ;
    if (mdsame) then (     OclFile["System.out"].println(diff - 1) ; 
     return ) else skip ; 
    if (y1 < y2) then (     if (dmcomp(m1, d1, m2, d2)) then skip else (     diff := diff-(1) ) ) else     if (y1 > y2) then (     if (not(dmcomp(m1, d1, m2, d2))) then skip else (     diff := diff-(1) ) ) else     if (y1 = y2) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; ;  ;  
    OclFile["System.out"].println(diff) ; 
 );
  static   operation dmcomp( m1 : int, d1 : int, m2 : int, d2 : int) : boolean
  pre: true
  post: true
  activity: (     return 100 * m1 + d1 < 100 * m2 + d2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int limit=s.nextInt();
    int numC=s.nextInt();
    List<int[]>l=new ArrayList<>();
    while(numC-->0){
      l.add(new int[] {
        s.nextInt(),s.nextInt()}
);
      }
      Collections.sort(l,(a,b)->b[1]-a[1]);
      int res=0 ;
      for(int i=0 ; i<l.size(); i++){
        if(limit==0)break ;
        int[] p=l.get(i);
        res+=Math.min(limit,p[0])*p[1];
        limit-=Math.min(limit,p[0]);
      }
      System.out.println(res);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var limit : int ; limit := s.getCurrent()->toInteger() ;
    var numC : int ; numC := s.getCurrent()->toInteger() ;
    var l : Sequence(Sequence(int)) ; l := Sequence{} ;
        while (numC > 0) do (        numC := numC - 1 ;     skip ; (     l := l->including(Sequence{s.getCurrent()->toInteger(),s.getCurrent()->toInteger()}) ) ;  ) ;  
    l, lambda (a , b) : OclAny in b[1+1] - a[1+1] := l, lambda (a , b) : OclAny in b[1+1] - a[1+1]->sort() ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < l->size() do ( (     if (limit = 0) then     break else skip ; 
     var p : Sequence(int) ; p := l->at(i+1) ;
     res := res+(Set{limit, p[0+1]}->min() * p[1+1]) ; 
     limit := limit-(Set{limit, p[0+1]}->min()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    ArrayList<Pair>arr=new ArrayList<>();
    for(int i=0 ; i<m ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      arr.add(new Pair(a,b));
    }
    Collections.sort(arr,new Sort());
    long ans=0 ;
    int curr=0 ;
    for(Pair x : arr){
      if(x.a+curr>=n){
        ans+=x.b*(n-curr);
        break ;
      }
      else {
        curr+=x.a ;
        ans+=x.a*x.b ;
      }
    }
    System.out.println(ans);
  }
}
class Sort implements Comparator<Pair>{
  public int compare(Pair a,Pair b){
    return b.b-a.b ;
  }
}
class Pair {
  int a ;
  int b ;
  public Pair(int a,int b){
    this.a=a ;
    this.b=b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arr : Sequence(Map) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     arr := arr->including(Map(a, b)) )  ;     i := i + 1 ) ; 
    arr, Sort.newSort() := arr, Sort.newSort()->sort() ; 
    var ans : long ; ans := 0 ;
    var curr : int ; curr := 0 ;
    for (x : arr) do ( (     if (x.a + curr >= n) then (     ans := ans+(x.b * (n - curr)) ; 
     break ) else (     curr := curr+(x.a) ; 
     ans := ans+(x.a * x.b) ) )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}
class Sort implements Function(<Map>,(<Map>,boolean)) {
   operation compare( a : Map, b : Map) : int
  pre: true
  post: true
  activity: (     return b.b - a.b );
}
class Pair {
   attribute a : int;
   attribute b : int;
   static operation newPair( a : int, b : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int box[]=new int[m];
    int matches[]=new int[m];
    for(int i=0 ; i<m ; i++){
      box[i]=sc.nextInt();
      matches[i]=sc.nextInt();
    }
    for(int i=0 ; i<m ; i++){
      for(int j=i+1 ; j<m ; j++){
        if(matches[i]<matches[j]){
          int temp=matches[i];
          matches[i]=matches[j];
          matches[j]=temp ;
          temp=box[i];
          box[i]=box[j];
          box[j]=temp ;
        }
      }
    }
    int count=0 ;
    int ans=0 ;
    for(int i=0 ; i<m ; i++){
      if(count==n){
        break ;
      }
      if(count+box[i]<=n){
        count+=box[i];
        ans+=matches[i]*box[i];
      }
      else {
        int val=(count+box[i])-n ;
        count+=box[i]-val ;
        ans+=(box[i]-val)*matches[i];
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var box : Sequence(int) ; box := Integer.subrange(1,m)->collect(0) ;
    var matches : Sequence(int) ; matches := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     box[i+1] := sc.getCurrent()->toInteger() ; 
     matches[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := i + 1 ; while j < m do ( (     if (matches[i+1] < matches[j+1]) then (     var temp : int ; temp := matches[i+1] ;
     matches[i+1] := matches[j+1] ; 
    matches[j+1] := temp ; 
    temp := box[i+1] ; 
    box[i+1] := box[j+1] ; 
    box[j+1] := temp ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     if (count = n) then (     break ) else skip ; 
     if (count + box[i+1] <= n) then (     count := count+(box[i+1]) ; 
     ans := ans+(matches[i+1] * box[i+1]) ) else (     var val : int ; val := (count + box[i+1]) - n ;
     count := count+(box[i+1] - val) ; 
     ans := ans+((box[i+1] - val) * matches[i+1]) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=26 ;
  static int largestSubSeq(String arr[],int n){
    int[] count=new int[MAX];
    for(int i=0 ; i<n ; i++){
      String str=arr[i];
      boolean[] hash=new boolean[MAX];
      for(int j=0 ; j<str.length(); j++){
        hash[str.charAt(j)-'a']=true ;
      }
      for(int j=0 ; j<MAX ; j++){
        if(hash[j])count[j]++;
      }
    }
    int max=-1 ;
    for(int i=0 ; i<MAX ; i++){
      if(max<count[i])max=count[i];
    }
    return max ;
  }
  public static void main(String[] args){
    String arr[]={
      "ab","bc","de" };
      int n=arr.length ;
      System.out.println(largestSubSeq(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 26;
  static   operation largestSubSeq( arr : Sequence(String), n : int) : int
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,MAX)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := arr[i+1] ;
     var hash : Sequence(boolean) ; hash := Integer.subrange(1,MAX)->collect(false) ;
         var j : int ; j := 0 ; while j < str->size() do ( (     hash[str->at(j+1) - ('a')->char2byte()+1] := true )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < MAX do ( (     if (hash[j+1]) then     count[j+1] := count[j+1] + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := -1 ;
        var i : int ; i := 0 ; while i < MAX do ( (     if (max < count[i+1]) then     max := count[i+1] ; else skip )  ;     i := i + 1 ) ; 
    return max 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"ab","bc","de"} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(largestSubSeq(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class MaxSum {
  static int maxSumLCM(int n){
    int max_sum=0 ;
    for(int i=1 ; i*i<=n ; i++){
      if(n % i==0){
        max_sum+=i ;
        if(n/i!=i)max_sum+=(n/i);
      }
    }
    return max_sum ;
  }
  public static void main(String[] args){
    int n=2 ;
    System.out.println(maxSumLCM(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class MaxSum {
  static   operation maxSumLCM( n : int) : int
  pre: true
  post: true
  activity: (     var max_sum : int ; max_sum := 0 ;
         var i : int ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     max_sum := max_sum+(i) ; 
     if (n / i /= i) then     max_sum := max_sum+((n / i)) ; else skip ) else skip )  ;     i := i + 1 ) ; 
     return max_sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(maxSumLCM(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int gcd(int a,int b){
    if(b==0){
      return a ;
    }
    return gcd(b,a % b);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a,b,c,d ;
    a=sc.nextInt();
    b=sc.nextInt();
    c=sc.nextInt();
    if(a<b){
      d=gcd(b,a);
    }
    else {
      d=gcd(a,b);
    }
    if(c % d==0){
      int k=0 ;
      while(-1<c-a*k && c-a*k<10001){
        if((c-a*k)% b==0){
          System.out.println("Yes");
          return ;
        }
        k++;
      }
    }
    System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else skip ; 
     return gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ;
    var b : int ;
    var c : int ;
    var d : int ;
    a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    c := sc.getCurrent()->toInteger() ; 
    if (a < b) then (     d := gcd(b, a) ) else (     d := gcd(a, b) ) ;  
    if (c mod d = 0) then (     var k : int ; k := 0 ;
     while (-1 < c - a * k & c - a * k < 10001) do (     if ((c - a * k) mod b = 0) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
     k := k + 1 ) ) else skip ; 
    OclFile["System.out"].println("No") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    for(int i=0 ; i<s.length()-2 ; i++){
      if(s.charAt(i)==s.charAt(i+1)){
        System.out.println((i+1)+" "+(i+2));
        return ;
      }
      else if(s.charAt(i)==s.charAt(i+2)){
        System.out.println((i+1)+" "+(i+3));
        return ;
      }
    }
    if(s.charAt(s.length()-2)==s.charAt(s.length()-1)){
      System.out.println((s.length()-1)+" "+s.length());
      return ;
    }
    System.out.println("-1-1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < s->size() - 2 do ( (     if (s->at(i+1) = s->at(i + 1+1)) then (     OclFile["System.out"].println((i + 1) + " " + (i + 2)) ; 
     return ) else     if (s->at(i+1) = s->at(i + 2+1)) then (     OclFile["System.out"].println((i + 1) + " " + (i + 3)) ; 
     return ) else skip ; )  ;     i := i + 1 ) ; 
    if (s->at(s->size() - 2+1) = s->at(s->size() - 1+1)) then (     OclFile["System.out"].println((s->size() - 1) + " " + s->size()) ; 
     return ) else skip ; 
    OclFile["System.out"].println("-1-1") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    char[] c=sc.next().toCharArray();
    int n=c.length ;
    int size=0 ;
    int length=0 ;
    int s=0 ;
    int t=0 ;
    Map<Character,Integer>map=new HashMap<>();
    boolean f=false ;
    boolean flag=true ;
    while(s<=t){
      while(t<n){
        char key=c[t];
        length=t-s+1 ;
        size=length/2 ;
        if(map.containsKey(key)){
          int v=map.get(key);
          map.put(key,v+1);
        }
        else {
          map.put(key,1);
        }
        int v=map.get(key);
        if(v>size && size>=1){
          f=true ;
          break ;
        }
        if(length==3){
          break ;
        }
        t++;
      }
      if(f){
        break ;
      }
      char key=c[s];
      int v=map.get(key);
      map.put(key,v-1);
      s++;
      length=t-s+1 ;
      size=length/2 ;
      if(s==n){
        flag=false ;
        break ;
      }
      key=c[s];
      v=map.get(key);
      if(v>size){
        break ;
      }
      t++;
    }
    if(flag){
      if(t==n){
        System.out.println((s+1)+" "+t);
      }
      else {
        System.out.println((s+1)+" "+(t+1));
      }
    }
    else {
      System.out.println(-1+" "+-1);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : Sequence(String) ; c := sc.getCurrent()->characters() ;
    var n : int ; n := c->size() ;
    var size : int ; size := 0 ;
    var length : int ; length := 0 ;
    var s : int ; s := 0 ;
    var t : int ; t := 0 ;
    var map : Map(String,int) ; map := Map{} ;
    var f : boolean ; f := false ;
    var flag : boolean ; flag := true ;
    while (s <= t) do (     while (t < n) do (     var key : String ; key := c[t+1] ;
     length := t - s + 1 ; 
    size := length / 2 ; 
    if (map->keys()->includes(key)) then (     var v : int ; v := map->at(key) ;
     map := map->union(Map{key |-> v + 1}) ) else (     map := map->union(Map{key |-> 1}) ) ;  
    var v : int ; v := map->at(key) ;
    if (v > size & size >= 1) then (     f := true ; 
     break ) else skip ; 
    if (length = 3) then (     break ) else skip ; 
    t := t + 1 ; 
 ) ; 
     if (f) then (     break ) else skip ; 
    var key : String ; key := c[s+1] ;
    var v : int ; v := map->at(key) ;
    map := map->union(Map{key |-> (v)->char2byte() - 1}) ; 
    s := s + 1 ; 
    length := t - s + 1 ; 
    size := length / 2 ; 
    if (s = n) then (     flag := false ; 
     break ) else skip ; 
    key := c[s+1] ; 
    v := map->at(key) ; 
    if (v > size) then (     break ) else skip ; 
    t := t + 1 ; 
 ) ; 
    if (flag) then (     if (t = n) then (     OclFile["System.out"].println((s + 1) + " " + t) ) else (     OclFile["System.out"].println((s + 1) + " " + (t + 1)) ) ) else (     OclFile["System.out"].println(-1 + " " + -1) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    Solver s=new Solver();
    System.out.println(s.solve(br.readLine()));
  }
}
class Solver {
  String solve(String s){
    for(int length=2 ; length<=3 ; length++){
      for(int i=0 ; i<s.length()+1-length ; i++){
        if(s.charAt(i)==s.charAt(i+length-1)){
          return ""+(i+1)+" "+(i+length);
        }
      }
    }
    return "-1-1" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : Solver ; s := Solver.newSolver() ;
     OclFile["System.out"].println(s.solve(br.readLine())) );
}
class Solver {
   operation solve( s : String) : String
  pre: true
  post: true
  activity: (         var length : int ; length := 2 ; while length <= 3 do ( (         var i : int ; i := 0 ; while i < s->size() + 1 - length do ( (     if (s->at(i+1) = s->at(i + length - 1+1)) then (     return "" + (i + 1) + " " + (i + length) ) else skip )  ;     i := i + 1 ) )  ;     length := length + 1 ) ; 
     return "-1-1" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private void doit(){
    Scanner sc=new Scanner(System.in);
    long mod=1000000007 ;
    while(sc.hasNext()){
      char[] data=sc.next().toCharArray();
      int len=data.length ;
      boolean flg=false ;
      for(int i=0 ; i<len ; i++){
        int[] array=new int[26];
        for(int j=i ; j>=0 && i-j<3 ; j--){
          array[data[j]-'a']++;
          if(j==i)continue ;
          for(int k=0 ; k<array.length ; k++){
            if(array[k]>(i-j+1)/2){
              System.out.println(j+1+" "+(i+1));
              flg=true ;
              break ;
            }
          }
          if(flg)break ;
        }
        if(flg)break ;
      }
      if(! flg){
        System.out.println("-1-1");
      }
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var mod : long ; mod := 1000000007 ;
     while (sc.hasNext()) do (     var data : Sequence(String) ; data := sc.getCurrent()->characters() ;
     var len : int ; len := data->size() ;
    var flg : boolean ; flg := false ;
        var i : int ; i := 0 ; while i < len do ( (     var array : Sequence(int) ; array := Integer.subrange(1,26)->collect(0) ;
         var j : int ; j := i ; while j >= 0 & i - j < 3 do ( (     array[data[j+1] - ('a')->char2byte()+1] := array[data[j+1] - ('a')->char2byte()+1] + 1 ; 
     if (j = i) then     continue else skip ; 
         var k : int ; k := 0 ; while k < array->size() do ( (     if (array[k+1] > (i - j + 1) / 2) then (     OclFile["System.out"].println(j + 1 + " " + (i + 1)) ; 
     flg := true ; 
     break ) else skip )  ;     k := k + 1 ) ; 
     if (flg) then     break else skip )  ;     j := j - 1 ) ; 
     if (flg) then     break else skip )  ;     i := i + 1 ) ; 
    if (not(flg)) then (     OclFile["System.out"].println("-1-1") ) else skip ; 
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countMaxContiguous(int arr[],int n){
    int current_max=0,max_so_far=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] % 2!=0)current_max=0 ;
      else {
        current_max++;
        max_so_far=Math.max(current_max,max_so_far);
      }
    }
    return max_so_far ;
  }
  public static void main(String[] args){
    int arr[]={
      1,0,2,4,3,8,9 };
      int n=arr.length ;
      System.out.println(countMaxContiguous(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countMaxContiguous( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var current_max : int ; current_max := 0 ;
    var max_so_far : int ; max_so_far := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 /= 0) then     current_max := 0 ; else (     current_max := current_max + 1 ; 
     max_so_far := Set{current_max, max_so_far}->max() ) )  ;     i := i + 1 ) ; 
     return max_so_far );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,0,2,4,3,8,9} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countMaxContiguous(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  static String line ;
  static int N ;
  public static void main(String args[])throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    line=br.readLine();
    String text[]=line.split("");
    N=text.length ;
    method(text);
  }
  static void method(String text[]){
    for(int i=0 ; i<text.length-2 ; i++){
      if(text[i] .equals(text[i+2])){
        i++;
        System.out.println(i+" "+(i+2));
        return ;
      }
    }
    for(int i=0 ; i<text.length-1 ; i++){
      if(text[i] .equals(text[i+1])){
        i++;
        System.out.println(i+" "+(i+1));
        return ;
      }
    }
    System.out.println("-1-1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute line : String;
  static   attribute N : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     line := br.readLine() ; 
    var text : Sequence(String) ; text := line->split("") ;
    N := text->size() ; 
    execute method(text) ; 
 );
  static   operation method( text : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < text->size() - 2 do ( (     if (text[i+1] = text[i + 2+1]) then (     i := i + 1 ; 
     OclFile["System.out"].println(i + " " + (i + 2)) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < text->size() - 1 do ( (     if (text[i+1] = text[i + 1+1]) then (     i := i + 1 ; 
     OclFile["System.out"].println(i + " " + (i + 1)) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("-1-1") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Fingerprints {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] seq=new int[n];
    HashSet<Integer>set=new HashSet<>();
    for(int i=0 ; i<n ; i++)seq[i]=sc.nextInt();
    for(int i=0 ; i<m ; i++)set.add(sc.nextInt());
    for(int i=0 ; i<n ; i++)if(set.contains(seq[i]))System.out.print(seq[i]+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Fingerprints {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var seq : Sequence(int) ; seq := Integer.subrange(1,n)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do (     seq[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     set := set->including(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     if (set->includes(seq[i+1])) then     OclFile["System.out"].print(seq[i+1] + " ") ; else skip ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _994A_FingerPrints {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int k=input.nextInt();
    input.nextLine();
    List<Integer>nList=new ArrayList<>();
    List<Integer>kList=new ArrayList<>();
    List<Integer>result=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      nList.add(input.nextInt());
    }
    input.nextLine();
    for(int i=0 ; i<k ; i++){
      kList.add(input.nextInt());
    }
    input.nextLine();
    for(int number : nList){
      if(kList.contains(number)){
        result.add(number);
      }
    }
    System.out.println(result.toString().replaceAll("[\\[\\],] ",""));
  }
}
------------------------------------------------------------
OCL File:
---------
 class _994A_FingerPrints {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var k : int ; k := input.getCurrent()->toInteger() ;
    skip ; 
    var nList : Sequence(int) ; nList := Sequence{} ;
    var kList : Sequence(int) ; kList := Sequence{} ;
    var result : Sequence(int) ; result := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     nList := nList->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < k do ( (     kList := kList->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    skip ; 
    for (number : nList) do ( (     if (kList->includes(number)) then (     result := result->including(number) ) else skip )  ) ; 
    OclFile["System.out"].println(result+"".replaceAllMatches("[\\[\\],] ", "" )) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CheapTravel {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(m*a<=b)System.out.println(n*a);
    else System.out.println(b*(n/m)+Math.min(b,a*(n % m)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class CheapTravel {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    if (m * a <= b) then     OclFile["System.out"].println(n * a) else     OclFile["System.out"].println(b * (n / m) + Set{b, a * (n mod m)}->min()) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Float.min ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int ans=useMain(n,m,a,b);
    System.out.println(ans);
  }
  public static int useMain(int n,int m,int a,int b){
    if(b/m>a){
      return n*a ;
    }
    else {
      int cent=n/m ;
      float ans=min(min(cent*b+n % m*a,n*a),(cent+1)*b);
      return(int)(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := useMain(n, m, a, b) ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation useMain( n : int, m : int, a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b / m > a) then (     return n * a ) else (     var cent : int ; cent := n / m ;
     var ans : double ; ans := min(Set{cent * b + n mod m * a, n * a}->min(), (cent + 1) * b) ;
     return (ans)->oclAsType(int) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n,m,a,b ;
    double min ;
    n=in.nextInt();
    m=in.nextInt();
    a=in.nextInt();
    b=in.nextInt();
    int op1=(n*a);
    min=op1 ;
    double op2=((n/m))*b ;
    double temp=(double)n/m ;
    if(Math.ceil(temp)!=temp)op2+=b ;
    if(min>op2)min=op2 ;
    op1=0 ;
    op1+=((n/m)*b);
    op1+=(n % m)*a ;
    if(op1<min)min=op1 ;
    System.out.println((int)min);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var m : int ;
    var a : int ;
    var b : int ;
    var min : double ;
    n := in.getCurrent()->toInteger() ; 
    m := in.getCurrent()->toInteger() ; 
    a := in.getCurrent()->toInteger() ; 
    b := in.getCurrent()->toInteger() ; 
    var op1 : int ; op1 := (n * a) ;
    min := op1 ; 
    var op2 : double ; op2 := ((n / m)) * b ;
    var temp : double ; temp := n->oclAsType(double) / m ;
    if ((temp)->ceil() /= temp) then     op2 := op2+(b) ; else skip ; 
    if (min > op2) then     min := op2 ; else skip ; 
    op1 := 0 ; 
    op1 := op1+(((n / m) * b)) ; 
    op1 := op1+((n mod m) * a) ; 
    if (op1 < min) then     min := op1 ; else skip ; 
    OclFile["System.out"].println(min->oclAsType(int)) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st ;
    st=new StringTokenizer(br.readLine());
    int a=Integer.parseInt(st.nextToken());
    int b=Integer.parseInt(st.nextToken());
    int c=Integer.parseInt(st.nextToken());
    int k=0 ;
    while((c-(a*k))>-1 &&(c-(a*k))<10001){
      if(((c-(a*k)))% b==0){
        System.out.print("Yes");
        System.exit(0);
      }
      k++;
    }
    System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    var a : int ; a := (st.next())->toInteger() ;
    var b : int ; b := (st.next())->toInteger() ;
    var c : int ; c := (st.next())->toInteger() ;
    var k : int ; k := 0 ;
    while ((c - (a * k)) > -1 & (c - (a * k)) < 10001) do (     if (((c - (a * k))) mod b = 0) then (     OclFile["System.out"].print("Yes") ; 
 OclProcess.exit(0) ) else skip ; 
     k := k + 1 ) ; 
    OclFile["System.out"].print("No") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static int dp[];
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int res=0 ;
    if(m*a<=b)res=res+n*a ;
    else {
      res=res+(n/m)*b ;
      res=res+Math.min((n % m)*a,b);
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dp : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
    if (m * a <= b) then     res := res + n * a else (     res := res + (n / m) * b ; 
     res := res + Set{(n mod m) * a, b}->min() ) ;  
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  static int countBits(int n){
    if(n==0)return 0 ;
    else return((n & 1)==0 ? 1 : 0)+countBits(n>>1);
  }
  static int maxGcd(int n){
    if(countBits(n)==0){
      for(int i=2 ; i*i<=n ; i++){
        if(n % i==0){
          return n/i ;
        }
      }
    }
    else {
      int val=0 ;
      int power=1 ;
      int dupn=n ;
      while(n>0){
        if((n & 1)==0){
          val+=power ;
        }
        power=power*2 ;
        n=n>>1 ;
      }
      return __gcd(val ^ dupn,val & dupn);
    }
    return 1 ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(maxGcd(n));
    n=15 ;
    System.out.println(maxGcd(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation countBits( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else     return (if (n & 1) = 0 then 1 else 0 endif) + countBits((n/(2->pow(1)))->oclAsType(long)) );
  static   operation maxGcd( n : int) : int
  pre: true
  post: true
  activity: (     if (countBits(n) = 0) then (         var i : int ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     return n / i ) else skip )  ;     i := i + 1 ) ) else (     var val : int ; val := 0 ;
     var power : int ; power := 1 ;
    var dupn : int ; dupn := n ;
    while (n > 0) do (     if ((n & 1) = 0) then (     val := val+(power) ) else skip ; 
     power := power * 2 ; 
     n := (n/(2->pow(1)))->oclAsType(long) ) ; 
    return __gcd(MathLib.bitwiseXor(val,dupn), MathLib.bitwiseAnd(val,dupn)) 
 ) ;  
     return 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(maxGcd(n)) ; 
     n := 15 ; 
     OclFile["System.out"].println(maxGcd(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.List ;
import java.util.ListIterator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().mainrun();
  }
  Scanner scan ;
  int N,K ;
  private List<Integer>Digits ;
  private void mainrun(){
    scan=new Scanner(System.in);
    N=scan.nextInt();
    K=scan.nextInt();
    int max=-1 ;
    Digits=new LinkedList<>();
    for(int i=0 ; i<N ; i++){
      int num=scan.nextInt();
      Digits.add(num);
      max=Math.max(max,num);
    }
    ListIterator<Integer>li ;
    li=Digits.listIterator();
    if(N-K==1){
      System.out.println(max);
      return ;
    }
    while(K!=0){
      int num1=li.next();
      int num2=li.next();
      li.previous();
      if(num1<num2){
        li.previous();
        li.remove();
        if(li.nextIndex()>=1){
          li.previous();
        }
        K--;
      }
      if(li.nextIndex()==Digits.size()-1){
        while(K!=0){
          li.remove();
          li.previous();
          K--;
        }
      }
    }
    Digits.forEach(System.out :: print);
    System.out.println();
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().mainrun() );
   attribute scan : OclFile;
   attribute N : int;
   attribute Digits : Sequence(int);
   operation mainrun() : void
  pre: true
  post: true
  activity: (     scan := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     N := scan.getCurrent()->toInteger() ; 
    K := scan.getCurrent()->toInteger() ; 
    var max : int ; max := -1 ;
    Digits := Sequence{} ; 
        var i : int ; i := 0 ; while i < N do ( (     var num : int ; num := scan.getCurrent()->toInteger() ;
     Digits := Digits->including(num) ; 
     max := Set{max, num}->max() )  ;     i := i + 1 ) ; 
    var li : ListIterator<int> ;
    li := Digits->iterator() ; 
    if (N - K = 1) then (     OclFile["System.out"].println(max) ; 
     return ) else skip ; 
    while (K /= 0) do (     var num1 : int ; num1 := li.next() ;
     var num2 : int ; num2 := li.next() ;
    li.previous() ; 
    if (num1 < num2) then (     li.previous() ; 
     li := li.remove() ; 
     if (li.nextIndex() >= 1) then (     li.previous() ) else skip ; 
     K := K - 1 ) else skip ; 
    if (li.nextIndex() = Digits->size() - 1) then (     while (K /= 0) do (     li := li.remove() ; 
     li.previous() ; 
     K := K - 1 ) ) else skip ; 
 ) ; 
    for _forEach : Digits do
    (    skip ;) ; 
    OclFile["System.out"].println() ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maxPartitions(int arr[],int n){
    int ans=0,max_so_far=0 ;
    for(int i=0 ; i<n ; ++i){
      max_so_far=Math.max(max_so_far,arr[i]);
      if(max_so_far==i)ans++;
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      1,0,2,3,4 };
      int n=arr.length ;
      System.out.println(maxPartitions(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxPartitions( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
    var max_so_far : int ; max_so_far := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     max_so_far := Set{max_so_far, arr[i+1]}->max() ; 
     if (max_so_far = i) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,0,2,3,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxPartitions(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long productAscii(String str){
    long prod=1 ;
    for(int i=0 ; i<str.length(); i++){
      prod*=str.charAt(i);
    }
    return prod ;
  }
  public static void main(String[] args){
    String str="GfG" ;
    System.out.println(productAscii(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation productAscii( str : String) : long
  pre: true
  post: true
  activity: (     var prod : long ; prod := 1 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     prod := prod*(str->at(i+1)) )  ;     i := i + 1 ) ; 
     return prod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GfG" ;
     OclFile["System.out"].println(productAscii(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    System.out.println(n-a-b+c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(n - a - b + c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    System.out.println(n-(a+b-c));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(n - (a + b - c)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    int[] i=convStrToInt(s);
    System.out.println(TwoNorThree(i));
  }
  private static int[] convStrToInt(String s){
    String[] strs=s.split(" ");
    int[] ints=new int[strs.length];
    int i=0 ;
    for(String st : strs){
      ints[i]=Integer.parseInt(st);
      i++;
    }
    return ints ;
  }
  private static int TwoNorThree(int[] i){
    return i[0]-i[1]-i[2]+i[3];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
     var i : Sequence(int) ; i := convStrToInt(s) ;
     OclFile["System.out"].println(TwoNorThree(i)) );
  static   operation convStrToInt( s : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var strs : Sequence(String) ; strs := s->split(" ") ;
     var ints : Sequence(int) ; ints := Integer.subrange(1,strs->size())->collect(0) ;
    var i : int ; i := 0 ;
    for (st : strs) do ( (     ints[i+1] := (st)->toInteger() ; 
     i := i + 1 )  ) ; 
    return ints 
 );
  static   operation TwoNorThree( i : Sequence(int)) : int
  pre: true
  post: true
  activity: (     return i[0+1] - i[1+1] - i[2+1] + i[3+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ABC116_1 solver=new ABC116_1();
    solver.solve(1,in,out);
    out.close();
  }
  static class ABC116_1 {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int AB=in.nextInt();
      int BC=in.nextInt();
      int CA=in.nextInt();
      out.println((AB*BC)/2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ABC116solver ; solver := ABC116ABC116solver.newABC116solver().newABC116ABC116solver.newABC116solver()() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ABC116_1 {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var AB : int ; AB := in.getCurrent()->toInteger() ;
     var BC : int ; BC := in.getCurrent()->toInteger() ;
     var CA : int ; CA := in.getCurrent()->toInteger() ;
     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void doIt(){
    int a[]=new int[3];
    int max=0 ;
    for(int i=0 ; i<3 ; i++){
      a[i]=sc.nextInt();
      if(max<a[i])max=i ;
    }
    int ans=1 ;
    for(int i=0 ; i<3 ; i++){
      if(i!=max)ans*=a[i];
    }
    System.out.println(ans/2);
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation doIt() : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
     var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (max < a[i+1]) then     max := i ; else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (i /= max) then     ans := ans*(a[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans / 2) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  private static void solve(){
    int[] abc=na(3);
    Arrays.sort(abc);
    System.out.println(abc[0]*abc[1]/2);
  }
  private static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  public static void main(String[] args){
    String debugDataPath=System.getenv("DD_PATH");
    if(debugDataPath!=null){
      try {
        br=new BufferedReader(new InputStreamReader(new FileInputStream(new File(debugDataPath))));
      }
      catch(Exception e){
        throw new RuntimeException(e);
      }
    }
    solve();
  }
  private static StringTokenizer tokenizer=null ;
  public static String next(){
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        tokenizer=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }
  private static int ni(){
    return Integer.parseInt(next());
  }
  private static long nl(){
    return Long.parseLong(next());
  }
  private static double nd(){
    return Double.parseDouble(next());
  }
  private static int[] na(int n){
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=ni();
    return a ;
  }
  private static char[] ns(){
    return next().toCharArray();
  }
  private static long[] nal(int n){
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=nl();
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var abc : Sequence(int) ; abc := na(3) ;
     abc := abc->sort() ; 
     OclFile["System.out"].println(abc[0+1] * abc[1+1] / 2) );
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var debugDataPath : String ; debugDataPath := OclProcess.getEnvironmentProperty("DD_PATH") ;
     if (debugDataPath /= null) then (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(debugDataPath)))) )   catch (e : ProgramException) do (     error ProgramException(e) )
 ) else skip ; 
     execute solve() );
  static   attribute tokenizer : OclIterator := null;
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
  static   operation ni() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nl() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nd() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation na( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := ni() ;  ;     i := i + 1 ) ; 
     return a );
  static   operation ns() : Sequence(String)
  pre: true
  post: true
  activity: (     return next()->characters() );
  static   operation nal( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nl() ;  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class EbonyAndIvory {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int a=in.nextInt(),b=in.nextInt(),c=in.nextInt();
    for(int i=0 ; i<=c ; i++){
      int x=a*i ;
      x=c-x ;
      if(x<0)break ;
      if(x % b==0){
        pw.println("YES");
        pw.close();
        return ;
      }
    }
    pw.println("NO");
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class EbonyAndIvory {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i <= c do ( (     var x : int ; x := a * i ;
     x := c - x ; 
     if (x < 0) then     break else skip ; 
     if (x mod b = 0) then (     skip ; 
     skip ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ARightTriangle solver=new ARightTriangle();
    solver.solve(1,in,out);
    out.close();
  }
  static class ARightTriangle {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int[] x=new int[3];
      for(int i=0 ; i<3 ; i++){
        x[i]=in.nextInt();
      }
      Arrays.sort(x);
      out.println(x[0]*x[1]/2);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ARightTriangle ; solver := ARightTriangle.newARightTriangle() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ARightTriangle {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var x : Sequence(int) ; x := Integer.subrange(1,3)->collect(0) ;
         var i : int ; i := 0 ; while i < 3 do ( (     x[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
     x := x->sort() ; 
     skip );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    System.out.println(a*b/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(a * b / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float cube(float h,float r){
    if(h<0 && r<0)return-1 ;
    float a=(h*r*(float)Math.sqrt(2))/(h+(float)Math.sqrt(2)*r);
    return a ;
  }
  public static void main(String[] args){
    float h=5,r=6 ;
    System.out.println(cube(h,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation cube( h : double, r : double) : double
  pre: true
  post: true
  activity: (     if (h < 0 & r < 0) then     return -1 else skip ; 
     var a : double ; a := (h * r * (2)->sqrt()->oclAsType(double)) / (h + (2)->sqrt()->oclAsType(double) * r) ;
     return a );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var h : double ; h := 5 ;
    var r : double ; r := 6 ;
     OclFile["System.out"].println(cube(h, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void sieveOfEratosthenes(int N,int s[]){
    boolean[] prime=new boolean[N+1];
    for(int i=0 ; i<N+1 ; i++)prime[i]=false ;
    for(int i=2 ; i<=N ; i+=2)s[i]=2 ;
    for(int i=3 ; i<=N ; i+=2){
      if(prime[i]==false){
        s[i]=i ;
        for(int j=i ; j*i<=N ; j+=2){
          if(prime[i*j]==false){
            prime[i*j]=true ;
            s[i*j]=i ;
          }
        }
      }
    }
  }
  static int findSum(int N){
    int[] s=new int[N+1];
    int ans=1 ;
    sieveOfEratosthenes(N,s);
    int currFactor=s[N];
    int power=1 ;
    while(N>1){
      N/=s[N];
      if(currFactor==s[N]){
        power++;
        continue ;
      }
      int sum=0 ;
      for(int i=0 ; i<=power ; i++)sum+=Math.pow(currFactor,i);
      ans*=sum ;
      currFactor=s[N];
      power=1 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int n=12 ;
    System.out.print("Sum of the factors is : ");
    System.out.print(findSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sieveOfEratosthenes( N : int, s : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,N + 1)->collect(false) ;
         var i : int ; i := 0 ; while i < N + 1 do (     prime[i+1] := false ;  ;     i := i + 1 ) ; 
         var i : int ; i := 2 ; while i <= N do (     s[i+1] := 2 ;  ;     i := i+(2) ) ; 
         var i : int ; i := 3 ; while i <= N do ( (     if (prime[i+1] = false) then (     s[i+1] := i ; 
         var j : int ; j := i ; while j * i <= N do ( (     if (prime[i * j+1] = false) then (     prime[i * j+1] := true ; 
     s[i * j+1] := i ) else skip )  ;     j := j+(2) ) ) else skip )  ;     i := i+(2) ) );
  static   operation findSum( N : int) : int
  pre: true
  post: true
  activity: (     var s : Sequence(int) ; s := Integer.subrange(1,N + 1)->collect(0) ;
     var ans : int ; ans := 1 ;
    execute sieveOfEratosthenes(N, s) ; 
    var currFactor : int ; currFactor := s[N+1] ;
    var power : int ; power := 1 ;
    while (N > 1) do (     N := N/(s[N+1]) ; 
     if (currFactor = s[N+1]) then (     power := power + 1 ; 
     continue ) else skip ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i <= power do (     sum := sum+(currFactor->pow(i)) ;  ;     i := i + 1 ) ; 
    ans := ans*(sum) ; 
    currFactor := s[N+1] ; 
    power := 1 ; 
 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     OclFile["System.out"].print("Sum of the factors is : ") ; 
     OclFile["System.out"].print(findSum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int D=scanner.nextInt();
    int T=scanner.nextInt();
    int S=scanner.nextInt();
    scanner.close();
    if(S*T>=D){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var D : int ; D := scanner.getCurrent()->toInteger() ;
    var T : int ; T := scanner.getCurrent()->toInteger() ;
    var S : int ; S := scanner.getCurrent()->toInteger() ;
    skip ; 
    if (S * T >= D) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.function.IntToDoubleFunction ;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    double d=sc.nextDouble();
    double t=(double)sc.nextInt();
    double s=sc.nextDouble();
    double a=d/s ;
    if(a<t+0.001)out.println("Yes");
    else out.println("No");
    out.flush();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(String file)throws FileNotFoundException {
      br=new BufferedReader(new FileReader(file));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
    public int[] nextArr(int n)throws IOException {
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=nextInt();
      return arr ;
    }
    public BigInteger BigInteger(String s)throws IOException {
      BigInteger a=new BigInteger(s);
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var d : double ; d := sc.getCurrent()->toReal() ;
    var t : double ; t := sc.getCurrent()->toInteger()->oclAsType(double) ;
    var s : double ; s := sc.getCurrent()->toReal() ;
    var a : double ; a := d / s ;
    if (a < t + 0.001) then     skip else     skip ; ;  
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( file : String) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
   operation nextArr( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     arr[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return arr );
   operation BigInteger( s : String) : long
  pre: true
  post: true
  activity: (     var a : long ; a := long(s) ;
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  static long mod=998244353 ;
  static long power[]=new long[100005];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int d=sc.nextInt();
    int t=sc.nextInt();
    int s=sc.nextInt();
    if(s*t>=d){
      System.out.println("Yes");
    }
    else System.out.println("No");
  }
  static void sort(int[] a){
    ArrayList<Integer>l=new ArrayList<>();
    for(int i : a)l.add(i);
    Collections.sort(l);
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static void sortReverse(long[] a){
    ArrayList<Long>l=new ArrayList<>();
    for(long i : a)l.add(i);
    Collections.sort(l,Collections.reverseOrder());
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := 998244353;
  static   attribute power : long := Integer.subrange(1,100005)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    if (s * t >= d) then (     OclFile["System.out"].println("Yes") ) else     OclFile["System.out"].println("No") ; ;  
 );
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l := l->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static   operation sortReverse( a : Sequence(long)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(long) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l, reverseOrder() := l, reverseOrder()->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    int t=sc.nextInt();
    int s=sc.nextInt();
    int u=sc.nextInt();
    if(s*u<t){
      System.out.print("No");
    }
    else {
      System.out.print("Yes");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var s : int ; s := sc.getCurrent()->toInteger() ;
     var u : int ; u := sc.getCurrent()->toInteger() ;
     if (s * u < t) then (     OclFile["System.out"].print("No") ) else (     OclFile["System.out"].print("Yes") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.*;
import java.math.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] s1=br.readLine().split(" ");
    int D=Integer.parseInt(s1[0]);
    int T=Integer.parseInt(s1[1]);
    int S=Integer.parseInt(s1[2]);
    if(T*S>=D){
      System.out.print("Yes");
    }
    else {
      System.out.print("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s1 : Sequence(String) ; s1 := br.readLine()->split(" ") ;
    var D : int ; D := (s1[0+1])->toInteger() ;
    var T : int ; T := (s1[1+1])->toInteger() ;
    var S : int ; S := (s1[2+1])->toInteger() ;
    if (T * S >= D) then (     OclFile["System.out"].print("Yes") ) else (     OclFile["System.out"].print("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int nextPerfectCube(int N){
    int nextN=(int)Math.floor(Math.cbrt(N))+1 ;
    return nextN*nextN*nextN ;
  }
  public static void main(String args[]){
    int n=35 ;
    System.out.print(nextPerfectCube(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nextPerfectCube( N : int) : int
  pre: true
  post: true
  activity: (     var nextN : int ; nextN := ((N)->cbrt())->floor()->oclAsType(int) + 1 ;
     return nextN * nextN * nextN );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 35 ;
     OclFile["System.out"].print(nextPerfectCube(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void perfectCube(int N){
    int cube ;
    for(int i=0 ; i<=N ; i++){
      cube=i*i*i ;
      if(cube==N){
        System.out.println("Yes");
        return ;
      }
      else if(cube>N){
        System.out.println("NO");
        return ;
      }
    }
  }
  public static void main(String[] args){
    int N=216 ;
    perfectCube(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation perfectCube( N : int) : void
  pre: true
  post: true
  activity: (     var cube : int ;
         var i : int ; i := 0 ; while i <= N do ( (     cube := i * i * i ; 
     if (cube = N) then (     OclFile["System.out"].println("Yes") ; 
     return ) else     if (cube > N) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 216 ;
     execute perfectCube(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int mat[][]=new int[n][m];
    for(int i=0 ; i<n ; i++){
      String s=sc.next();
      for(int j=0 ; j<m ; j++){
        mat[i][j]=s.charAt(j);
      }
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(mat[i][j]=='W'){
          if(i-1>=0 && mat[i-1][j]=='P')count++;
          else if(i+1<=n-1 && mat[i+1][j]=='P')count++;
          else if(j-1>=0 && mat[i][j-1]=='P')count++;
          else {
            if(j+1<=m-1 && mat[i][j+1]=='P')count++;
          }
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var mat : Sequence(Sequence(int)) ; mat := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < m do ( (     mat[i+1][j+1] := s->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (mat[i+1][j+1] = 'W') then (     if (i - 1 >= 0 & mat[i - 1+1][j+1] = 'P') then     count := count + 1 ; else     if (i + 1 <= n - 1 & mat[i + 1+1][j+1] = 'P') then     count := count + 1 else     if ((j)->char2byte() - 1 >= 0 & mat[i+1][(j)->char2byte() - 1+1] = 'P') then     count := count + 1 else (     if (j + 1 <= m - 1 & mat[i+1][j + 1+1] = 'P') then     count := count + 1 ; else skip ) ;  ;  ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int doubleFactorial(int n){
    int fact=1 ;
    for(int i=1 ; i<=n ; i=i+2){
      fact=fact*i ;
    }
    return fact ;
  }
  static int hermiteNumber(int n){
    if(n % 2==1)return 0 ;
    else {
      int number=(int)(Math.pow(2,n/2))*doubleFactorial(n-1);
      if((n/2)% 2==1)number=number*-1 ;
      return number ;
    }
  }
  public static void main(String[] args){
    int n=6 ;
    System.out.println(hermiteNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation doubleFactorial( n : int) : int
  pre: true
  post: true
  activity: (     var fact : int ; fact := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (     fact := fact * i )  ;     i := i + 2 ) ; 
     return fact );
  static   operation hermiteNumber( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 = 1) then     return 0 else (     var number : int ; number := (2->pow(n / 2))->oclAsType(int) * doubleFactorial(n - 1) ;
     if ((n / 2) mod 2 = 1) then     number := number * -1 ; else skip ; 
     return number ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(hermiteNumber(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void pattern(int rows_no){
    int i,j,k ;
    for(i=1 ; i<=rows_no ; i++){
      for(k=1 ; k<i ; k++)System.out.print(" ");
      for(j=i ; j<=rows_no ; j++)System.out.print(j+" ");
      System.out.println();
    }
    for(i=rows_no-1 ; i>=1 ; i--){
      for(k=1 ; k<i ; k++)System.out.print(" ");
      for(j=i ; j<=rows_no ; j++)System.out.print(j+" ");
      System.out.println();
    }
  }
  public static void main(String[] args){
    int rows_no=7 ;
    pattern(rows_no);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pattern( rows_no : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var k : int ;
         i := 1 ; while i <= rows_no do ( (         k := 1 ; while k < i do (     OclFile["System.out"].print(" ") ;  ;     k := k + 1 ) ; 
         j := i ; while j <= rows_no do (     OclFile["System.out"].print(j + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
         i := rows_no - 1 ; while i >= 1 do ( (         k := 1 ; while k < i do (     OclFile["System.out"].print(" ") ;  ;     k := k + 1 ) ; 
         j := i ; while j <= rows_no do (     OclFile["System.out"].print(j + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var rows_no : int ; rows_no := 7 ;
     execute pattern(rows_no) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication65 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    ArrayList<Integer>arrayOdd=new ArrayList<>();
    ArrayList<Integer>arrayEven=new ArrayList<>();
    int all=0 ;
    for(int i=0 ; i<num ; i++){
      int s=sc.nextInt();
      all+=s ;
      if(s % 2==0){
        arrayEven.add(s);
      }
      else {
        arrayOdd.add(s);
      }
    }
    if(all % 2==0){
      System.out.println(arrayEven.size());
    }
    else {
      System.out.println(arrayOdd.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication65 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
    var arrayOdd : Sequence(int) ; arrayOdd := Sequence{} ;
    var arrayEven : Sequence(int) ; arrayEven := Sequence{} ;
    var all : int ; all := 0 ;
        var i : int ; i := 0 ; while i < num do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     all := all+(s) ; 
     if (s mod 2 = 0) then (     arrayEven := arrayEven->including(s) ) else (     arrayOdd := arrayOdd->including(s) ) )  ;     i := i + 1 ) ; 
    if (all mod 2 = 0) then (     OclFile["System.out"].println(arrayEven->size()) ) else (     OclFile["System.out"].println(arrayOdd->size()) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static int findWays(int ar[]){
    int left=0 ;
    int right=0 ;
    for(int i=0 ; i<ar.length ; i++){
      right+=ar[i];
    }
    int cnt=0 ;
    for(int i=0 ; i<ar.length ; i++){
      right-=ar[i];
      if((right+left)% 2==0){
        cnt++;
      }
      left+=ar[i];
    }
    return cnt ;
  }
  public static void main(String[] args){
    try {
      System.setIn(new FileInputStream("input.txt"));
      System.setOut(new PrintStream(new FileOutputStream("output.txt")));
    }
    catch(Exception e){
      System.err.println("Error");
    }
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int ar[]=new int[n];
    for(int i=0 ; i<n ; i++){
      ar[i]=sc.nextInt();
    }
    System.out.println(findWays(ar));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation findWays( ar : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var left : int ; left := 0 ;
     var right : int ; right := 0 ;
        var i : int ; i := 0 ; while i < ar->size() do ( (     right := right+(ar[i+1]) )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < ar->size() do ( (     right := right-(ar[i+1]) ; 
     if ((right + left) mod 2 = 0) then (     cnt := cnt + 1 ) else skip ; 
     left := left+(ar[i+1]) )  ;     i := i + 1 ) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) )   catch (e : ProgramException) do (     OclFile["System.err"].println("Error") )
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(findWays(ar)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    int sum=0 ;
    int ev=0 ;
    int od=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      sum+=arr[i];
      if(arr[i] % 2==0)ev++;
      else od++;
    }
    if(sum % 2==0)System.out.println(ev);
    else System.out.println(od);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
    var ev : int ; ev := 0 ;
    var od : int ; od := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(arr[i+1]) ; 
     if (arr[i+1] mod 2 = 0) then     ev := ev + 1 ; else     od := od + 1 ; )  ;     i := i + 1 ) ; 
    if (sum mod 2 = 0) then     OclFile["System.out"].println(ev) else     OclFile["System.out"].println(od) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test240 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    int b=in.nextInt();
    int c=in.nextInt();
    int d=in.nextInt();
    int sum=0 ;
    while(a>0 && c>0 && d>0){
      sum+=256 ;
      a--;
      c--;
      d--;
    }
    while(a>0 && b>0){
      sum+=32 ;
      a--;
      b--;
    }
    System.out.println(sum);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test240 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    while (a > 0 & c > 0 & d > 0) do (     sum := sum+(256) ; 
     a := a - 1 ; 
     c := c - 1 ; 
     d := d - 1 ) ; 
    while (a > 0 & b > 0) do (     sum := sum+(32) ; 
     a := a - 1 ; 
     b := b - 1 ) ; 
    OclFile["System.out"].println(sum) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _734B_AntonAndDigits {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int twos=input.nextInt();
    int threes=input.nextInt();
    int fives=input.nextInt();
    int sixes=input.nextInt();
    input.nextLine();
    int min=Math.min(Math.min(twos,fives),sixes);
    twos-=min ;
    int min2=Math.min(twos,threes);
    int result=min*256+min2*32 ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _734B_AntonAndDigits {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var twos : int ; twos := input.getCurrent()->toInteger() ;
    var threes : int ; threes := input.getCurrent()->toInteger() ;
    var fives : int ; fives := input.getCurrent()->toInteger() ;
    var sixes : int ; sixes := input.getCurrent()->toInteger() ;
    skip ; 
    var min : int ; min := Set{Set{twos, fives}->min(), sixes}->min() ;
    twos := twos-(min) ; 
    var min2 : int ; min2 := Set{twos, threes}->min() ;
    var result : int ; result := min * 256 + min2 * 32 ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int twos=in.nextInt(),threes=in.nextInt(),fives=in.nextInt(),sixes=in.nextInt();
    long first=min(twos,min(fives,sixes))*256L ;
    long sec=min(twos-(first/256),threes)*32L ;
    System.out.print(first+sec);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var twos : int ; twos := in.getCurrent()->toInteger() ;
    var threes : int ; threes := in.getCurrent()->toInteger() ;
    var fives : int ; fives := in.getCurrent()->toInteger() ;
    var sixes : int ; sixes := in.getCurrent()->toInteger() ;
    var first : long ; first := min(twos, Set{fives, sixes}->min()) * 256L ;
    var sec : long ; sec := min(twos - (first / 256), threes) * 32L ;
    OclFile["System.out"].print(first + sec) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
import java.util.*;
public class B_Anton_and_Digits {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int two=reader.nextInt();
    int three=reader.nextInt();
    int five=reader.nextInt();
    int six=reader.nextInt();
    long sum=0L ;
    int min=Math.min(two,Math.min(five,six));
    sum+=min*256 ;
    two=two-min ;
    int min2=Math.min(two,three);
    sum=sum+min2*32 ;
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Anton_and_Digits {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var two : int ; two := reader.nextInt() ;
    var three : int ; three := reader.nextInt() ;
    var five : int ; five := reader.nextInt() ;
    var six : int ; six := reader.nextInt() ;
    var sum : long ; sum := 0L ;
    var min : int ; min := Set{two, Set{five, six}->min()}->min() ;
    sum := sum+(min * 256) ; 
    two := two - min ; 
    var min2 : int ; min2 := Set{two, three}->min() ;
    sum := sum + min2 * 32 ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    long a=nextLong();
    long b=nextLong();
    long c=nextLong();
    long d=nextLong();
    long x=Math.min(a,Math.min(c,d));
    long ans=x*256 ;
    a-=x ;
    c-=x ;
    d-=x ;
    long y=Math.min(a,b);
    ans+=y*32 ;
    System.out.println(ans);
  }
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter out=new PrintWriter(System.out);
  static StringTokenizer in=new StringTokenizer("");
  public static String next()throws IOException {
    while(in==null || ! in.hasMoreTokens()){
      in=new StringTokenizer(br.readLine());
    }
    return in.nextToken();
  }
  public static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public static long nextLong()throws IOException {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ; a := nextLong() ;
     var b : long ; b := nextLong() ;
    var c : long ; c := nextLong() ;
    var d : long ; d := nextLong() ;
    var x : long ; x := Set{a, Set{c, d}->min()}->min() ;
    var ans : long ; ans := x * 256 ;
    a := a-(x) ; 
    c := c-(x) ; 
    d := d-(x) ; 
    var y : long ; y := Set{a, b}->min() ;
    ans := ans+(y * 32) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclIterator := OclIterator.newOclIterator_String("");
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (in = null or not(in.hasNext())) do (     in := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return in.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B507 {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long r=sc.nextLong();
    long x1=sc.nextLong();
    long y1=sc.nextLong();
    long x2=sc.nextLong();
    long y2=sc.nextLong();
    double dist=Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
    long ans=(long)(Math.ceil(dist/(2*r)));
    pw.println(ans);
    pw.close();
  }
  static class Scanner {
    BufferedReader br ;
    StringTokenizer st ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(FileReader f){
      br=new BufferedReader(f);
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public int[] nextIntArr(int n)throws IOException {
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=Integer.parseInt(next());
      }
      return arr ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B507 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var r : long ; r := sc.getCurrent()->toLong() ;
    var x1 : long ; x1 := sc.getCurrent()->toLong() ;
    var y1 : long ; y1 := sc.getCurrent()->toLong() ;
    var x2 : long ; x2 := sc.getCurrent()->toLong() ;
    var y2 : long ; y2 := sc.getCurrent()->toLong() ;
    var dist : double ; dist := ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))->sqrt() ;
    var ans : long ; ans := ((dist / (2 * r))->ceil())->oclAsType(long) ;
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( f : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(f) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArr( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (next())->toInteger() )  ;     i := i + 1 ) ; 
     return arr );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class solve {
  public static void main(String[] args){
    Scanner get=new Scanner(System.in);
    String temp[]=get.nextLine().split(" ");
    int n=Integer.parseInt(temp[0]);
    int m=Integer.parseInt(temp[1]);
    int cnt=0 ;
    char grid[][]=new char[n][m];
    for(int i=0 ; i<n ; i++){
      String t=get.nextLine();
      grid[i]=t.toCharArray();
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(grid[i][j]=='W'){
          if((i-1>=0 && grid[i-1][j]=='P')||(j-1>=0 && grid[i][j-1]=='P')||(i+1<n && grid[i+1][j]=='P')||(j+1<m && grid[i][j+1]=='P'))cnt++;
        }
      }
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solve {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var get : OclFile ; get := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var temp : Sequence(String) ; temp := get.nextLine()->split(" ") ;
    var n : int ; n := (temp[0+1])->toInteger() ;
    var m : int ; m := (temp[1+1])->toInteger() ;
    var cnt : int ; cnt := 0 ;
    var grid : Sequence(Sequence(String)) ; grid := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var t : String ; t := get.nextLine() ;
     grid[i+1] := t->characters() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (grid[i+1][j+1] = 'W') then (     if (((i)->char2byte() - 1 >= 0 & grid[(i)->char2byte() - 1+1][j+1] = 'P') or (j - 1 >= 0 & grid[i+1][j - 1+1] = 'P') or (i + 1 < n & grid[i + 1+1][j+1] = 'P') or (j + 1 < m & grid[i+1][j + 1+1] = 'P')) then     cnt := cnt + 1 ; else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=Long.parseLong(sc.next());
    List<Integer>L=new ArrayList<Integer>();
    final long m=n ;
    for(long i=2 ; i*i<=m ; i++){
      int cnt=0 ;
      while(n % i==0){
        n=n/i ;
        cnt++;
      }
      L.add(cnt);
      if(n==1){
        break ;
      }
    }
    long cnt=n==1 ? 0 : 1 ;
    for(long num : L){
      long sum=0L ;
      long id=0 ;
      for(long i=1 ; ; i++){
        sum+=i ;
        if(sum>num){
          break ;
        }
        id=i ;
      }
      cnt+=id ;
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := (sc.getCurrent())->toLong() ;
    var L : Sequence(int) ; L := Sequence{} ;
    var m : long ; m := n ;
        var i : long ; i := 2 ; while i * i <= m do ( (     var cnt : int ; cnt := 0 ;
     while (n mod i = 0) do (     n := n / i ; 
     cnt := cnt + 1 ) ; 
     L := L->including(cnt) ; 
     if (n = 1) then (     break ) else skip )  ;     i := i + 1 ) ; 
    var cnt : long ; cnt := if n = 1 then 0 else 1 endif ;
    for (num : L) do ( (     var sum : long ; sum := 0L ;
     var id : long ; id := 0 ;
         var i : long ; i := 1 ; while true do ( (     sum := sum+(i) ; 
     if (sum > num) then (     break ) else skip ; 
     id := i )  ;     i := i + 1 ) ; 
     cnt := cnt+(id) )  ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printArray(int N,int[] arr){
    for(int i=0 ; i<N ; i++)System.out.print(arr[i]+" ");
    System.out.println();
  }
  static void replacedArray(int N,int[] arr){
    int pos_sum,neg_sum,i,j,diff ;
    for(i=0 ; i<N ; i++){
      pos_sum=0 ;
      neg_sum=0 ;
      for(j=i+1 ; j<N ; j++){
        if(arr[j]>0)pos_sum+=arr[j];
        else neg_sum+=arr[j];
      }
      diff=Math.abs(pos_sum)-Math.abs(neg_sum);
      arr[i]=Math.abs(diff);
    }
  }
  public static void main(String args[]){
    int N=5 ;
    int[] arr={
      1,-1,2,3,-2 };
      replacedArray(N,arr);
      printArray(N,arr);
      N=6 ;
      int[] arr1={
-3,-4,-2,5,1,-2 };
        replacedArray(N,arr1);
        printArray(N,arr1);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printArray( N : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation replacedArray( N : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var pos_sum : int ;
    var neg_sum : int ;
    var i : int ;
    var j : int ;
    var diff : int ;
         i := 0 ; while i < N do ( (     pos_sum := 0 ; 
     neg_sum := 0 ; 
        j := i + 1 ; while j < N do ( (     if (arr[j+1] > 0) then     pos_sum := pos_sum+(arr[j+1]) ; else     neg_sum := neg_sum+(arr[j+1]) ; )  ;     j := j + 1 ) ; 
    diff := if pos_sum < 0 then -(pos_sum) else pos_sum endif - if neg_sum < 0 then -(neg_sum) else neg_sum endif ; 
    arr[i+1] := if diff < 0 then -(diff) else diff endif ; 
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     var arr : Sequence(int) ; arr := Sequence{1,-1,2,3,-2} ;
    execute replacedArray(N, arr) ; 
    execute printArray(N, arr) ; 
    N := 6 ; 
    var arr1 : Sequence(int) ; arr1 := Sequence{-3,-4,-2,5,1,-2} ;
    execute replacedArray(N, arr1) ; 
    execute printArray(N, arr1) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String n=in.nextLine();
    for(int i=1 ; i<n.length(); i++){
      if(n.charAt(i)!='0'){
        int sum=0 ;
        for(int j=0 ; j<n.length(); j++){
          sum+=n.charAt(j)-'0' ;
        }
        System.out.println(sum);
        return ;
      }
    }
    if(n.charAt(0)=='1'){
      System.out.println(10);
      return ;
    }
    System.out.println(n.charAt(0));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : String ; n := in.nextLine() ;
        var i : int ; i := 1 ; while i < n->size() do ( (     if (n->at(i+1) /= '0') then (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < n->size() do ( (     sum := sum+(n->at(j+1) - ('0')->char2byte()) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(sum) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    if (n->at(0+1) = '1') then (     OclFile["System.out"].println(10) ; 
     return ) else skip ; 
    OclFile["System.out"].println(n->at(0+1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BAmrAndPins solver=new BAmrAndPins();
    solver.solve(1,in,out);
    out.close();
  }
  static class BAmrAndPins {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      String input=in.nextLine();
      String[] token=input.split(" ");
      double epsilon=10e-3 ;
      int r=Integer.parseInt(token[0]);
      int x=Integer.parseInt(token[1]);
      int y=Integer.parseInt(token[2]);
      int x1=Integer.parseInt(token[3]);
      int y1=Integer.parseInt(token[4]);
      int d=r*2 ;
      int minStep=0 ;
      double dist=dist(x,y,x1,y1);
      if(dist<epsilon){
        ;
      }
      else {
        ;
        dist-=r ;
        dist=Math.abs(dist);
        if(dist % d>r)minStep++;
        if(dist % d>=0)minStep++;
        minStep+=(int)dist/d ;
      }
      out.println(minStep);
    }
    public double dist(int x,int y,int x1,int y1){
      return Math.sqrt(Math.pow(x1-x,2)+Math.pow(y1-y,2));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BAmrAndPins ; solver := BAmrAndPins.newBAmrAndPins() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BAmrAndPins {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var input : String ; input := in.nextLine() ;
     var token : Sequence(String) ; token := input->split(" ") ;
    var epsilon : double ; epsilon := 10e-3 ;
    var r : int ; r := (token[0+1])->toInteger() ;
    var x : int ; x := (token[1+1])->toInteger() ;
    var y : int ; y := (token[2+1])->toInteger() ;
    var x1 : int ; x1 := (token[3+1])->toInteger() ;
    var y1 : int ; y1 := (token[4+1])->toInteger() ;
    var d : int ; d := r * 2 ;
    var minStep : int ; minStep := 0 ;
    var dist : double ; dist := dist(x, y, x1, y1) ;
    if (dist < epsilon) then (  ) else (  
     dist := dist-(r) ; 
    dist := if dist < 0 then -(dist) else dist endif ; 
    if (dist mod d > r) then     minStep := minStep + 1 ; else skip ; 
    if (dist mod d >= 0) then     minStep := minStep + 1 ; else skip ; 
    minStep := minStep+(dist->oclAsType(int) / d) ; 
 ) ;  
    skip ; 
 );
   operation dist( x : int, y : int, x1 : int, y1 : int) : double
  pre: true
  post: true
  activity: (     return (x1 - x->pow(2) + y1 - y->pow(2))->sqrt() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CP_Solution {
  private static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    int t=1 ;
    while(t-->0){
      solve();
    }
  }
  private static void solve(){
    FastReader fr=new FastReader();
    double r=fr.nextDouble(),x=fr.nextDouble(),y=fr.nextDouble(),x1=fr.nextDouble(),y1=fr.nextDouble();
    double distance=Math.sqrt(Math.pow(x1-x,2)+Math.pow(y1-y,2));
    System.out.println((int)Math.ceil(distance/(2*r)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class CP_Solution {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var fr : FastReader ; fr := FastReader.newFastReader() ;
     var r : double ; r := fr.nextDouble() ;
    var x : double ; x := fr.nextDouble() ;
    var y : double ; y := fr.nextDouble() ;
    var x1 : double ; x1 := fr.nextDouble() ;
    var y1 : double ; y1 := fr.nextDouble() ;
     var distance : double ; distance := (x1 - x->pow(2) + y1 - y->pow(2))->sqrt() ;
     OclFile["System.out"].println((distance / (2 * r))->ceil()->oclAsType(int)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A114 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    int l=sc.nextInt();
    int count=0 ;
    while(l % k==0){
      l/=k ;
      count++;
    }
    System.out.println((l==1)? "YES\n"+(count-1): "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A114 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    while (l mod k = 0) do (     l := l/(k) ; 
     count := count + 1 ) ; 
    OclFile["System.out"].println(if (l = 1) then "YES\n" + (count - 1) else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Cifera {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int l=sc.nextInt();
    for(int i=1 ; ; i++){
      if(Math.pow(n,i)==l){
        System.out.println("YES");
        System.out.println(i-1);
        return ;
      }
      else if(Math.pow(n,i)>l){
        System.out.println("NO");
        return ;
      }
      else if(i<0){
        System.out.println("NO");
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cifera {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while true do ( (     if (n->pow(i) = l) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(i - 1) ; 
     return ) else     if (n->pow(i) > l) then (     OclFile["System.out"].println("NO") ; 
     return ) else     if (i < 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; ;  )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class _temp2 {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int a=Integer.parseInt(br.readLine());
    int b=Integer.parseInt(br.readLine());
    int count=0 ;
    while(b % a==0){
      b/=a ;
      count++;
    }
    System.out.println((b==1)? "YES\n"+(count-1): "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class _temp2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var a : int ; a := (br.readLine())->toInteger() ;
    var b : int ; b := (br.readLine())->toInteger() ;
    var count : int ; count := 0 ;
    while (b mod a = 0) do (     b := b/(a) ; 
     count := count + 1 ) ; 
    OclFile["System.out"].println(if (b = 1) then "YES\n" + (count - 1) else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findXOR(int n){
    int mod=n % 4 ;
    if(mod==0)return n ;
    else if(mod==1)return 1 ;
    else if(mod==2)return n+1 ;
    else if(mod==3)return 0 ;
    return 0 ;
  }
  static int findXOR(int l,int r){
    return(findXOR(l-1)^ findXOR(r));
  }
  public static void main(String[] args){
    int l=4,r=8 ;
    System.out.println(findXOR(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findXOR( n : int) : int
  pre: true
  post: true
  activity: (     var mod : int ; mod := n mod 4 ;
     if (mod = 0) then     return n else     if (mod = 1) then     return 1 else     if (mod = 2) then     return n + 1 else     if (mod = 3) then     return 0 else skip ; ;  ;  ;  
     return 0 );
  static   operation findXOR( l : int, r : int) : int
  pre: true
  post: true
  activity: (     return (findXOR(l - 1) xor findXOR(r)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 4 ;
    var r : int ; r := 8 ;
     OclFile["System.out"].println(findXOR(l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static boolean Arrive(int a,int b,int n){
    if(n>=Math.abs(a)+Math.abs(b)&&(n-(Math.abs(a)+Math.abs(b)))% 2==0)return true ;
    return false ;
  }
  int main(){
    return 0 ;
  }
  public static void main(String[] args){
    int a=5,b=5,n=11 ;
    if(Arrive(a,b,n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Arrive( a : int, b : int, n : int) : boolean
  pre: true
  post: true
  activity: (     if (n >= if a < 0 then -(a) else a endif + if b < 0 then -(b) else b endif & (n - (if a < 0 then -(a) else a endif + if b < 0 then -(b) else b endif)) mod 2 = 0) then     return true else skip ; 
     return false );
   operation main() : int
  pre: true
  post: true
  activity: (     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 5 ;
    var b : int ; b := 5 ;
    var n : int ; n := 11 ;
     if (Arrive(a, b, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF1188B {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    int p=Integer.parseInt(st.nextToken());
    int k=Integer.parseInt(st.nextToken());
    int[] a=new int[n];
    st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(st.nextToken());
    }
    long ans=0 ;
    long[] b=new long[n];
    for(int i=0 ; i<n ; i++){
      b[i]=(long)a[i]*a[i];
      b[i] %=p ;
      b[i]*=a[i];
      b[i] %=p ;
      b[i]*=a[i];
      b[i] %=p ;
      b[i]-=((long)k*a[i]);
      b[i] %=p ;
      if(b[i]<0){
        b[i]+=p ;
      }
    }
    Arrays.sort(b);
    int cnt=1 ;
    long prev=b[0];
    for(int i=1 ; i<n ; i++){
      if(b[i]!=prev){
        ans+=(long)(cnt)*(cnt-1)/2 ;
        cnt=1 ;
        prev=b[i];
      }
      else {
        cnt++;
      }
    }
    ans+=(long)(cnt)*(cnt-1)/2 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF1188B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var p : int ; p := (st.next())->toInteger() ;
    var k : int ; k := (st.next())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := a[i+1]->oclAsType(long) * a[i+1] ; 
     b[i+1] := b[i+1] mod p ; 
    b[i+1] := b[i+1]*(a[i+1]) ; 
    b[i+1] := b[i+1] mod p ; 
    b[i+1] := b[i+1]*(a[i+1]) ; 
    b[i+1] := b[i+1] mod p ; 
    b[i+1] := b[i+1]-((k->oclAsType(long) * a[i+1])) ; 
    b[i+1] := b[i+1] mod p ; 
    if (b[i+1] < 0) then (     b[i+1] := b[i+1]+(p) ) else skip ; 
 )  ;     i := i + 1 ) ; 
    b := b->sort() ; 
    var cnt : int ; cnt := 1 ;
    var prev : long ; prev := b[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     if (b[i+1] /= prev) then (     ans := ans+((cnt)->oclAsType(long) * (cnt - 1) / 2) ; 
     cnt := 1 ; 
     prev := b[i+1] ) else (     cnt := cnt + 1 ) )  ;     i := i + 1 ) ; 
    ans := ans+((cnt)->oclAsType(long) * (cnt - 1) / 2) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int n=5 ;
  static int largestSideLen(int matrix[][]){
    int result=1 ;
    for(int i=0 ; i<(n/2); i++){
      int element=matrix[i][i];
      int isSquare=1 ;
      for(int j=i ; j<n-i ; j++){
        if(matrix[i][j]!=element)isSquare=0 ;
        if(matrix[n-i-1][j]!=element)isSquare=0 ;
        if(matrix[j][i]!=element)isSquare=0 ;
        if(matrix[j][n-i-1]!=element)isSquare=0 ;
      }
      if(isSquare>0)return n-(2*i);
    }
    return result ;
  }
  public static void main(String[] args){
    int matrix[][]={
      {
        1,1,1,1,1 },{
          1,2,2,2,1 },{
            1,2,1,2,1 },{
              1,2,2,2,1 },{
                1,1,1,1,1 }
              };
              System.out.println(largestSideLen(matrix));
            }
          }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute n : int := 5;
  static   operation largestSideLen( matrix : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 1 ;
         var i : int ; i := 0 ; while i < (n / 2) do ( (     var element : int ; element := matrix[i+1][i+1] ;
     var isSquare : int ; isSquare := 1 ;
         var j : int ; j := i ; while j < n - i do ( (     if (matrix[i+1][j+1] /= element) then     isSquare := 0 ; else skip ; 
     if (matrix[n - i - 1+1][j+1] /= element) then     isSquare := 0 ; else skip ; 
     if (matrix[j+1][i+1] /= element) then     isSquare := 0 ; else skip ; 
     if (matrix[j+1][n - i - 1+1] /= element) then     isSquare := 0 ; else skip )  ;     j := j + 1 ) ; 
     if (isSquare > 0) then     return n - (2 * i) else skip )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var matrix : Sequence(Sequence(int)) ; matrix := Sequence{Sequence{1,1,1,1,1},Sequence{1,2,2,2,1},Sequence{1,2,1,2,1},Sequence{1,2,2,2,1},Sequence{1,1,1,1,1}} ;
     OclFile["System.out"].println(largestSideLen(matrix)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test262 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int e=0,o=0,s=0 ;
      for(int i=0 ; i<n ; i++){
        int x=in.nextInt();
        if(x % 2==0){
          e++;
          if(i % 2==1){
            s++;
          }
        }
        else {
          o++;
        }
      }
      if(e==o || e==o+1){
        System.out.println(s);
      }
      else {
        System.out.println(-1);
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test262 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var e : int ; e := 0 ;
    var o : int ; o := 0 ;
    var s : int ; s := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     if (x mod 2 = 0) then (     e := e + 1 ; 
     if (i mod 2 = 1) then (     s := s + 1 ) else skip ) else (     o := o + 1 ) )  ;     i := i + 1 ) ; 
     if (e = o or e = o + 1) then (     OclFile["System.out"].println(s) ) else (     OclFile["System.out"].println(-1) ) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
class Main {
  public static void main(String[] args){
    int A,B ;
    int N ;
    int[] sum ;
    int minVal ;
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    sum=new int[N-1];
    for(A=1 ; A<=N-1 ; A++){
      B=N-A ;
      sum[A-1]=sumOfEachDigit(A)+sumOfEachDigit(B);
    }
    minVal=sum[0];
    for(A=1 ; A<=N-1 ; A++){
      if(minVal>sum[A-1])minVal=sum[A-1];
    }
    System.out.println(minVal);
  }
  public static int sumOfEachDigit(int n){
    if(n/10000!=0){
      int n5,n4,n3,n2,n1 ;
      n5=n/10000 ;
      n4=(n-n5*10000)/1000 ;
      n3=(n-n5*10000-n4*1000)/100 ;
      n2=(n-n5*10000-n4*1000-n3*100)/10 ;
      n1=n-n5*10000-n4*1000-n3*100-n2*10 ;
      return n5+n4+n3+n2+n1 ;
    }
    else if(n/1000!=0){
      int n4,n3,n2,n1 ;
      n4=n/1000 ;
      n3=(n-n4*1000)/100 ;
      n2=(n-n4*1000-n3*100)/10 ;
      n1=n-n4*1000-n3*100-n2*10 ;
      return n4+n3+n2+n1 ;
    }
    else if(n/100!=0){
      int n3,n2,n1 ;
      n3=n/100 ;
      n2=(n-n3*100)/10 ;
      n1=n-n3*100-n2*10 ;
      return n3+n2+n1 ;
    }
    else if(n/10!=0){
      int n2,n1 ;
      n2=n/10 ;
      n1=n-n2*10 ;
      return n2+n1 ;
    }
    else {
      return n ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ;
    var B : int ;
     var N : int ;
    var sum : Sequence(int) ;
    var minVal : int ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    N := sc.getCurrent()->toInteger() ; 
    sum := Integer.subrange(1,N - 1)->collect(0) ; 
        A := 1 ; while A <= N - 1 do ( (     B := N - A ; 
     sum[A - 1+1] := sumOfEachDigit(A) + sumOfEachDigit(B) )  ;     A := A + 1 ) ; 
    minVal := sum[0+1] ; 
        A := 1 ; while A <= N - 1 do ( (     if (minVal > sum[A - 1+1]) then     minVal := sum[A - 1+1] ; else skip )  ;     A := A + 1 ) ; 
    OclFile["System.out"].println(minVal) ; 
 );
  static   operation sumOfEachDigit( n : int) : int
  pre: true
  post: true
  activity: (     if (n / 10000 /= 0) then (     var n5 : int ;
    var n4 : int ;
    var n3 : int ;
    var n2 : int ;
    var n1 : int ;
     n5 := n / 10000 ; 
    n4 := (n - n5 * 10000) / 1000 ; 
    n3 := (n - n5 * 10000 - n4 * 1000) / 100 ; 
    n2 := (n - n5 * 10000 - n4 * 1000 - n3 * 100) / 10 ; 
    n1 := n - n5 * 10000 - n4 * 1000 - n3 * 100 - n2 * 10 ; 
    return n5 + n4 + n3 + n2 + n1 
 ) else     if (n / 1000 /= 0) then (     var n4 : int ;
    var n3 : int ;
    var n2 : int ;
    var n1 : int ;
     n4 := n / 1000 ; 
    n3 := (n - n4 * 1000) / 100 ; 
    n2 := (n - n4 * 1000 - n3 * 100) / 10 ; 
    n1 := n - n4 * 1000 - n3 * 100 - n2 * 10 ; 
    return n4 + n3 + n2 + n1 
 ) else     if (n / 100 /= 0) then (     var n3 : int ;
    var n2 : int ;
    var n1 : int ;
     n3 := n / 100 ; 
    n2 := (n - n3 * 100) / 10 ; 
    n1 := n - n3 * 100 - n2 * 10 ; 
    return n3 + n2 + n1 
 ) else     if (n / 10 /= 0) then (     var n2 : int ;
    var n1 : int ;
     n2 := n / 10 ; 
     n1 := n - n2 * 10 ; 
     return n2 + n1 ) else (     return n ) ;  ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int indexOfFirstOne(int arr[],int low,int high){
    while(low<=high){
      int mid=(low+high)/2 ;
      if(arr[mid]==1 &&(mid==0 || arr[mid-1]==0))return mid ;
      else if(arr[mid]==1)high=mid-1 ;
      else low=mid+1 ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      0,0,0,0,0,0,1,1,1,1 };
      int n=arr.length ;
      System.out.println(indexOfFirstOne(arr,0,n-1));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation indexOfFirstOne( arr : Sequence(int), low : int, high : int) : int
  pre: true
  post: true
  activity: (     while (low <= high) do (     var mid : int ; mid := (low + high) / 2 ;
     if (arr[mid+1] = 1 & (mid = 0 or arr[mid - 1+1] = 0)) then     return mid else     if (arr[mid+1] = 1) then     high := mid - 1 else     low := mid + 1 ; ;  ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,0,0,0,0,0,1,1,1,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(indexOfFirstOne(arr, 0, n - 1)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class evenSwap {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int a=in.nextInt();
      int x[]=new int[a];
      for(int i=0 ; i<a ; i++){
        x[i]=in.nextInt();
      }
      int s=0 ;
      int ss=0 ;
      for(int i=0 ; i<a ; i+=2){
        if(x[i] % 2!=0){
          s++;
        }
      }
      for(int i=1 ; i<a ; i+=2){
        if(x[i] % 2==0){
          ss++;
        }
      }
      if(s!=ss){
        System.out.println("-1");
      }
      else System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class evenSwap {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := in.getCurrent()->toInteger() ;
     var x : Sequence(int) ; x := Integer.subrange(1,a)->collect(0) ;
        var i : int ; i := 0 ; while i < a do ( (     x[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var s : int ; s := 0 ;
    var ss : int ; ss := 0 ;
        var i : int ; i := 0 ; while i < a do ( (     if (x[i+1] mod 2 /= 0) then (     s := s + 1 ) else skip )  ;     i := i+(2) ) ; 
        var i : int ; i := 1 ; while i < a do ( (     if (x[i+1] mod 2 = 0) then (     ss := ss + 1 ) else skip )  ;     i := i+(2) ) ; 
    if (s /= ss) then (     OclFile["System.out"].println("-1") ) else     OclFile["System.out"].println(s) ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1367 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      int oddCount=0,evenCount=0 ;
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
        if(arr[i] % 2==0)evenCount++;
        else oddCount++;
      }
      if(arr.length==1 && arr[0] % 2!=0){
        System.out.println(-1);
      }
      else if(arr.length==1 && arr[0] % 2==0){
        System.out.println(0);
      }
      else {
        int oddWrong=0 ;
        for(int i=0 ; i<n ; i+=2){
          if(arr[i] % 2!=0)oddWrong++;
        }
        int evenWrong=0 ;
        for(int i=1 ; i<n ; i+=2){
          if(arr[i] % 2==0)evenWrong++;
        }
        if(evenWrong==oddWrong)System.out.println(evenWrong);
        else System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1367 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var oddCount : int ; oddCount := 0 ;
    var evenCount : int ; evenCount := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr[i+1] mod 2 = 0) then     evenCount := evenCount + 1 ; else     oddCount := oddCount + 1 ; )  ;     i := i + 1 ) ; 
    if (arr->size() = 1 & arr[0+1] mod 2 /= 0) then (     OclFile["System.out"].println(-1) ) else     if (arr->size() = 1 & arr[0+1] mod 2 = 0) then (     OclFile["System.out"].println(0) ) else (     var oddWrong : int ; oddWrong := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 /= 0) then     oddWrong := oddWrong + 1 ; else skip )  ;     i := i+(2) ) ; 
    var evenWrong : int ; evenWrong := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] mod 2 = 0) then     evenWrong := evenWrong + 1 ; else skip )  ;     i := i+(2) ) ; 
    if (evenWrong = oddWrong) then     OclFile["System.out"].println(evenWrong) else     OclFile["System.out"].println(-1) ; ;  
 ) ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class _1367B_EvenArray {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=Integer.parseInt(input.nextLine());
    while(test-->0){
      int amount=Integer.parseInt(input.nextLine());
      int even=0 ;
      int odd=0 ;
      for(int i=0 ; i<amount ; i++){
        int num=input.nextInt();
        if(i % 2==0 && num % 2!=0){
          even++;
        }
        else if(i % 2==1 && num % 2!=1){
          odd++;
        }
      }
      input.nextLine();
      if(even==odd){
        System.out.println(odd);
      }
      else {
        System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1367B_EvenArray {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := (input.nextLine())->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var amount : int ; amount := (input.nextLine())->toInteger() ;
     var even : int ; even := 0 ;
    var odd : int ; odd := 0 ;
        var i : int ; i := 0 ; while i < amount do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
     if (i mod 2 = 0 & num mod 2 /= 0) then (     even := even + 1 ) else     if (i mod 2 = 1 & num mod 2 /= 1) then (     odd := odd + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    skip ; 
    if (even = odd) then (     OclFile["System.out"].println(odd) ) else (     OclFile["System.out"].println(-1) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int fact(int n){
    int res=1 ;
    for(int i=2 ; i<=n ; i++)res=res*i ;
    return res ;
  }
  static int Count_number(int N){
    return(N*fact(N));
  }
  public static void main(String[] args){
    int N=2 ;
    System.out.print(Count_number(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fact( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
         var i : int ; i := 2 ; while i <= n do (     res := res * i ;  ;     i := i + 1 ) ; 
     return res );
  static   operation Count_number( N : int) : int
  pre: true
  post: true
  activity: (     return (N * fact(N)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 2 ;
     OclFile["System.out"].print(Count_number(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printOrder(int[] arr,int n){
    Arrays.sort(arr);
    for(int i=0 ; i<n/2 ; i++){
      System.out.print(arr[i]+" ");
    }
    for(int j=n-1 ; j>=n/2 ; j--){
      System.out.print(arr[j]+" ");
    }
  }
  public static void main(String[] args){
    int[] arr={
      5,4,6,2,1,3,8,-1 };
      int n=arr.length ;
      printOrder(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printOrder( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
         var i : int ; i := 0 ; while i < n / 2 do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
         var j : int ; j := n - 1 ; while j >= n / 2 do ( (     OclFile["System.out"].print(arr[j+1] + " ") )  ;     j := j - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,4,6,2,1,3,8,-1} ;
     var n : int ; n := arr->size() ;
     execute printOrder(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isOrthogonal(int[][] a,int m,int n){
    if(m!=n)return false ;
    int[][] trans=new int[n][n];
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)trans[i][j]=a[j][i];
    int[][] prod=new int[n][n];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        int sum=0 ;
        for(int k=0 ; k<n ; k++){
          sum=sum+(a[i][k]*a[j][k]);
        }
        prod[i][j]=sum ;
      }
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(i!=j && prod[i][j]!=0)return false ;
        if(i==j && prod[i][j]!=1)return false ;
      }
    }
    return true ;
  }
  static public void main(String[] args){
    int[][] a={
      {
        1,0,0 },{
          0,1,0 },{
            0,0,1 }
          };
          if(isOrthogonal(a,3,3))System.out.println("Yes");
          else System.out.println("No");
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isOrthogonal( a : Sequence(Sequence(int)), m : int, n : int) : boolean
  pre: true
  post: true
  activity: (     if (m /= n) then     return false else skip ; 
     var trans : Sequence(Sequence(int)) ; trans := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (     trans[i+1][j+1] := a[j+1][i+1] ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var prod : Sequence(Sequence(int)) ; prod := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     var sum : int ; sum := 0 ;
         var k : int ; k := 0 ; while k < n do ( (     sum := sum + (a[i+1][k+1] * a[j+1][k+1]) )  ;     k := k + 1 ) ; 
     prod[i+1][j+1] := sum )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (i /= j & prod[i+1][j+1] /= 0) then     return false else skip ; 
     if (i = j & prod[i+1][j+1] /= 1) then     return false else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return true 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(Sequence(int)) ; a := Sequence{Sequence{1,0,0},Sequence{0,1,0},Sequence{0,0,1}} ;
     if (isOrthogonal(a, 3, 3)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class GFG {
  static void removeElements(int arr[],int n,int l,int r){
    HashMap<Integer,Integer>mp=new HashMap<>();
    for(int i=0 ; i<n ; ++i){
      int val=0 ;
      if(mp.get(arr[i])==null){
        val=1 ;
      }
      else {
        val=mp.get(arr[i])+1 ;
      }
      mp.put(arr[i],val);
    }
    for(int i=0 ; i<n ; ++i){
      if(mp.get(arr[i])<l || mp.get(arr[i])>r){
        System.out.print(arr[i]+" ");
      }
    }
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3,3,2,2,5 };
      int n=arr.length ;
      int l=2,r=3 ;
      removeElements(arr,n,l,r);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation removeElements( arr : Sequence(int), n : int, l : int, r : int) : void
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     var val : int ; val := 0 ;
     if (mp->at(arr[i+1]) = null) then (     val := 1 ) else (     val := mp->at(arr[i+1]) + 1 ) ;  
     mp := mp->union(Map{arr[i+1] |-> val}) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (mp->at(arr[i+1]) < l or mp->at(arr[i+1]) > r) then (     OclFile["System.out"].print(arr[i+1] + " ") ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,3,2,2,5} ;
     var n : int ; n := arr->size() ;
     var l : int ; l := 2 ;
    var r : int ; r := 3 ;
     execute removeElements(arr, n, l, r) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    Map<String,Integer>dic=new HashMap<>();
    int count=stdIn.nextInt();
    for(int i=0 ; i<count ; i++){
      int command=stdIn.nextInt();
      switch(command){
        case 0 : dic.put(stdIn.next(),stdIn.nextInt());
        break ;
        case 1 : System.out.println(dic.get(stdIn.next()));
      }
    }
    stdIn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dic : Map(String,int) ; dic := Map{} ;
    var count : int ; count := stdIn.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < count do ( (     var command : int ; command := stdIn.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (command) ; 
       if _switchval = 0 then
     dic := dic->union(Map{stdIn.getCurrent() |-> stdIn.getCurrent()->toInteger()}) ; 
    break 
   else skip ;
       if _switchval = 1 then
     OclFile["System.out"].println(dic->at(stdIn.getCurrent())) ; 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.TreeMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Map<String,Long>map=new TreeMap<>();
    List<Long>out=new ArrayList<>();
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      switch(sc.nextByte()){
        case 0 : map.put(sc.next(),sc.nextLong());
        break ;
        case 1 : out.add(map.get(sc.next()));
        break ;
      }
    }
    for(long n : out){
      System.out.println(n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var map : Map(String,long) ; map := Map{} ;
    var out : Sequence(long) ; out := Sequence{} ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (sc.nextByte()) ; 
       if _switchval = 0 then
     map := map->union(Map{sc.getCurrent() |-> sc.getCurrent()->toLong()}) ; 
    break 
   else skip ;
       if _switchval = 1 then
     out := out->including(map->at(sc.getCurrent())) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    for (n : out) do ( (     OclFile["System.out"].println(n) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class MP3 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int diskSize=in.nextInt()*8 ;
    Integer[] sounds=new Integer[n];
    for(int i=0 ; i<n ; i++){
      sounds[i]=in.nextInt();
    }
    Arrays.sort(sounds);
    int[] distinctVals=new int[n];
    int[] distinctAmt=new int[n];
    int k=-1 ;
    for(int i=0 ; i<n ; i++){
      if(i==0 || sounds[i]>sounds[i-1]){
        distinctVals[++k]=sounds[i];
        distinctAmt[k]=1 ;
      }
      else {
        distinctAmt[k]++;
      }
    }
    k++;
    int answer=n ;
    int currAmt=distinctAmt[0];
    for(int i=0,j=0 ; i<k ; currAmt-=distinctAmt[i],i++){
      while(j<i ||(j<k-1 && n*lg(j+1-i+1)<=diskSize)){
        j++;
        currAmt+=distinctAmt[j];
      }
      answer=Math.min(answer,n-currAmt);
    }
    System.out.println(answer);
  }
  static int lg(int n){
    int res=0 ;
    while(n>(1<<res)){
      res++;
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class MP3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var diskSize : int ; diskSize := in.getCurrent()->toInteger() * 8 ;
    var sounds : Sequence(int) ; sounds := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     sounds[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    sounds := sounds->sort() ; 
    var distinctVals : Sequence(int) ; distinctVals := Integer.subrange(1,n)->collect(0) ;
    var distinctAmt : Sequence(int) ; distinctAmt := Integer.subrange(1,n)->collect(0) ;
    var k : int ; k := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i = 0 or sounds[i+1] > sounds[i - 1+1]) then (         k := k + 1 ;
 distinctVals[k+1] := sounds[i+1]  ; 
     distinctAmt[k+1] := 1 ) else (     distinctAmt[k+1] := distinctAmt[k+1] + 1 ) )  ;     i := i + 1 ) ; 
    k := k + 1 ; 
    var answer : int ; answer := n ;
    var currAmt : int ; currAmt := distinctAmt[0+1] ;
        var i : int ; i := 0 ;
    var j : int ; j := 0 ; while i < k do ( (     while (j < i or (j < k - 1 & n * lg(j + 1 - i + 1) <= diskSize)) do (     j := j + 1 ; 
     currAmt := currAmt+(distinctAmt[j+1]) ) ; 
     answer := Set{answer, n - currAmt}->min() )  ;     currAmt := currAmt-(distinctAmt[i+1]) ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
  static   operation lg( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     while (n > ((1*(2->pow(res)))->oclAsType(long))) do (     res := res + 1 ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner InData=new Scanner(System.in);
  static int qType,qVal ;
  static String qKey ;
  static Map<String,Integer>M=new HashMap<String,Integer>();
  public static void main(String[] args){
    getQuery();
  }
  private static void getQuery(){
    int qNum=InData.nextInt();
    for(int indexOfQuery=0 ; indexOfQuery<qNum ; indexOfQuery++){
      qType=InData.nextInt();
      qKey=InData.next();
      doQuery(qType,qKey);
    }
  }
  private static void doQuery(int type,String key){
    switch(type){
      case 0 : qVal=InData.nextInt();
      M.put(key,qVal);
      break ;
      case 1 : System.out.println(M.get(key));
      break ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute InData : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute qType : int;
  static   attribute qKey : String;
  static   attribute M : Map(String,int) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute getQuery() );
  static   operation getQuery() : void
  pre: true
  post: true
  activity: (     var qNum : int ; qNum := InData.getCurrent()->toInteger() ;
         var indexOfQuery : int ; indexOfQuery := 0 ; while indexOfQuery < qNum do ( (     qType := InData.getCurrent()->toInteger() ; 
     qKey := InData.getCurrent() ; 
     execute doQuery(qType, qKey) )  ;     indexOfQuery := indexOfQuery + 1 ) );
  static   operation doQuery( type : int, key : String) : void
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (type) ; 
       if _switchval = 0 then
     qVal := InData.getCurrent()->toInteger() ; 
    M := M->union(Map{key |-> qVal}) ; 
    break 
   else skip ;
       if _switchval = 1 then
     OclFile["System.out"].println(M->at(key)) ; 
    break 
   else skip ;
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class FindSmallestInteger {
  int findSmallest(int arr[],int n){
    int res=1 ;
    for(int i=0 ; i<n && arr[i]<=res ; i++)res=res+arr[i];
    return res ;
  }
  public static void main(String[] args){
    FindSmallestInteger small=new FindSmallestInteger();
    int arr1[]={
      1,3,4,5 };
      int n1=arr1.length ;
      System.out.println(small.findSmallest(arr1,n1));
      int arr2[]={
        1,2,6,10,11,15 };
        int n2=arr2.length ;
        System.out.println(small.findSmallest(arr2,n2));
        int arr3[]={
          1,1,1,1 };
          int n3=arr3.length ;
          System.out.println(small.findSmallest(arr3,n3));
          int arr4[]={
            1,1,3,4 };
            int n4=arr4.length ;
            System.out.println(small.findSmallest(arr4,n4));
          }
        }

------------------------------------------------------------
OCL File:
---------
class FindSmallestInteger {
   operation findSmallest( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
         var i : int ; i := 0 ; while i < n & arr[i+1] <= res do (     res := res + arr[i+1] ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var small : FindSmallestInteger ; small := FindSmallestInteger.newFindSmallestInteger() ;
     var arr1 : Sequence(int) ; arr1 := Sequence{1,3,4,5} ;
    var n1 : int ; n1 := arr1->size() ;
    OclFile["System.out"].println(small.findSmallest(arr1, n1)) ; 
    var arr2 : Sequence(int) ; arr2 := Sequence{1,2,6,10,11,15} ;
    var n2 : int ; n2 := arr2->size() ;
    OclFile["System.out"].println(small.findSmallest(arr2, n2)) ; 
    var arr3 : Sequence(int) ; arr3 := Sequence{1,1,1,1} ;
    var n3 : int ; n3 := arr3->size() ;
    OclFile["System.out"].println(small.findSmallest(arr3, n3)) ; 
    var arr4 : Sequence(int) ; arr4 := Sequence{1,1,3,4} ;
    var n4 : int ; n4 := arr4->size() ;
    OclFile["System.out"].println(small.findSmallest(arr4, n4)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int q=Integer.parseInt(str[0]);
    SortedMap<String,Integer>mpa=new TreeMap<String,Integer>();
    for(int i=0 ; i<q ; i++){
      str=br.readLine().split(" ");
      int op=Integer.parseInt(str[0]);
      if(op==0){
        String key=str[1];
        int x=Integer.parseInt(str[2]);
        mpa.put(key,x);
      }
      else {
        String key=str[1];
        System.out.println(mpa.get(key));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var q : int ; q := (str[0+1])->toInteger() ;
    var mpa : Map(String,int) ; mpa := Map{} ;
        var i : int ; i := 0 ; while i < q do ( (     str := br.readLine()->split(" ") ; 
     var op : int ; op := (str[0+1])->toInteger() ;
     if (op = 0) then (     var key : String ; key := str[1+1] ;
     var x : int ; x := (str[2+1])->toInteger() ;
     mpa := mpa->union(Map{key |-> x}) ) else (     var key : String ; key := str[1+1] ;
     OclFile["System.out"].println(mpa->at(key)) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    TreeMap<String,Integer>map=new TreeMap<>();
    int q=Integer.parseInt(in.next());
    for(int i=0 ; i<q ; i++){
      int odr=Integer.parseInt(in.next());
      switch(odr){
        case 0 : String key0=in.next();
        int x0=Integer.parseInt(in.next());
        map.put(key0,x0);
        break ;
        case 1 : String key1=in.next();
        out.println(map.get(key1));
        break ;
      }
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var map : Map(String,int) ; map := Map{} ;
    var q : int ; q := (in.getCurrent())->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var odr : int ; odr := (in.getCurrent())->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (odr) ; 
       if _switchval = 0 then
     var key0 : String ; key0 := in.getCurrent() ;
    var x0 : int ; x0 := (in.getCurrent())->toInteger() ;
    map := map->union(Map{key0 |-> x0}) ; 
    break 
   else skip ;
       if _switchval = 1 then
     var key1 : String ; key1 := in.getCurrent() ;
    skip ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Test {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String str1=sc.next();
      String str2=sc.next();
      String str3=sc.next();
      int[] arr=new int[26];
      String ans="" ;
      for(int i=0 ; i<str1.length(); i++){
        arr[Integer.valueOf(str1.charAt(i))-97]=i ;
      }
      for(int i=0 ; i<str3.length(); i++){
        try {
          int digit=Integer.valueOf(String.valueOf(str3.charAt(i)));
          ans+=digit+"" ;
        }
        catch(NumberFormatException ne){
          String temp=str3.substring(i,i+1).toLowerCase();
          int index=arr[Integer.valueOf(temp.charAt(0))-97];
          if(Integer.valueOf(str3.charAt(i))<97){
            ans+=str2.substring(index,index+1).toUpperCase()+"" ;
          }
          else ans+=str2.charAt(index)+"" ;
        }
      }
      System.out.println(ans);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var str1 : String ; str1 := sc.getCurrent() ;
     var str2 : String ; str2 := sc.getCurrent() ;
    var str3 : String ; str3 := sc.getCurrent() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,26)->collect(0) ;
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < str1->size() do ( (     arr[(str1->at(i+1))->toInteger() - 97+1] := i )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < str3->size() do ( (     try (     var digit : int ; digit := (((str3->at(i+1)) + ""))->toInteger() ;
     ans := ans+(digit + "") )   catch (ne : IncorrectElementException) do (     var temp : String ; temp := str3.subrange(i+1,i + 1)->toLowerCase() ;
     var index : int ; index := arr[(temp->at(0+1))->toInteger() - 97+1] ;
     if ((str3->at(i+1))->toInteger() < 97) then (     ans := ans+(str2.subrange(index+1,index + 1)->toUpperCase() + "") ) else     ans := ans+(str2->at(index+1) + "") ; )
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int calculatePower(int b,int e){
    int ans=1 ;
    while(e>0){
      if(e % 2==1)ans=ans*b ;
      e=e/2 ;
      b=b*b ;
    }
    return ans ;
  }
  static int CountSubSet(int arr[],int n,int X){
    int count=0,checkX=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==X){
        checkX=1 ;
        break ;
      }
    }
    if(checkX==1)count=calculatePower(2,n-1);
    else count=0 ;
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      4,5,6,7 };
      int X=5 ;
      int n=arr.length ;
      System.out.println(CountSubSet(arr,n,X));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation calculatePower( b : int, e : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
     while (e > 0) do (     if (e mod 2 = 1) then     ans := ans * b ; else skip ; 
     e := e / 2 ; 
     b := b * b ) ; 
     return ans );
  static   operation CountSubSet( arr : Sequence(int), n : int, X : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
    var checkX : int ; checkX := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = X) then (     checkX := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (checkX = 1) then     count := calculatePower(2, n - 1) else     count := 0 ; ;  
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,5,6,7} ;
     var X : int ; X := 5 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(CountSubSet(arr, n, X)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  public static int M=100 ;
  static int minAdjustmentCost(int A[],int n,int target){
    int[][] dp=new int[n][M+1];
    for(int j=0 ; j<=M ; j++)dp[0][j]=Math.abs(j-A[0]);
    for(int i=1 ; i<n ; i++){
      for(int j=0 ; j<=M ; j++){
        dp[i][j]=Integer.MAX_VALUE ;
        int k=Math.max(j-target,0);
        for(; k<=Math.min(M,j+target); k++)dp[i][j]=Math.min(dp[i][j],dp[i-1][k]+Math.abs(A[i]-j));
      }
    }
    int res=Integer.MAX_VALUE ;
    for(int j=0 ; j<=M ; j++)res=Math.min(res,dp[n-1][j]);
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      55,77,52,61,39,6,25,60,49,47 };
      int n=arr.length ;
      int target=10 ;
      System.out.println("Minimum adjustment cost is "+minAdjustmentCost(arr,n,target));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute M : int := 100;
  static   operation minAdjustmentCost( A : Sequence(int), n : int, target : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,M + 1)->collect(0)) ;
         var j : int ; j := 0 ; while j <= M do (     dp[0+1][j+1] := if j - A[0+1] < 0 then -(j - A[0+1]) else j - A[0+1] endif ;  ;     j := j + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 0 ; while j <= M do ( (     dp[i+1][j+1] := 2147483647 ; 
     var k : int ; k := Set{j - target, 0}->max() ;
       while k <= Set{M, j + target}->min() do (     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i - 1+1][k+1] + if A[i+1] - j < 0 then -(A[i+1] - j) else A[i+1] - j endif}->min() ;  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : int ; res := 2147483647 ;
        var j : int ; j := 0 ; while j <= M do (     res := Set{res, dp[n - 1+1][j+1]}->min() ;  ;     j := j + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{55,77,52,61,39,6,25,60,49,47} ;
     var n : int ; n := arr->size() ;
     var target : int ; target := 10 ;
     OclFile["System.out"].println("Minimum adjustment cost is " + minAdjustmentCost(arr, n, target)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
import java.io.PrintWriter ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    long N=scan.nextLong();
    long A=scan.nextLong();
    long B=scan.nextLong();
    if(A+B-1>N || A*B<N){
      System.out.println(-1);
      return ;
    }
    List<Long>ansList=new ArrayList<>();
    long n=0,m=0,l=0 ;
    for(int i=1 ; i<=N ; ++i){
      if(N-i*B<=(A-i-1)+B){
        n=i ;
        m=A-i-1 ;
        l=N-n*B-m ;
        break ;
      }
    }
    for(long i=0 ; i<n ; ++i){
      for(long j=B ; j>0 ; --j)ansList.add(i*B+j);
    }
    for(long i=n*B+l ; i>n*B ; --i)ansList.add(i);
    for(long i=n*B+l+1 ; i<=N ; ++i)ansList.add(i);
    PrintWriter pw=new PrintWriter(System.out);
    for(int i=0 ; i<N ; ++i)pw.print(ansList.get(i)+(i==N-1 ? "\n" : " "));
    pw.flush();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := scan.getCurrent()->toLong() ;
    var A : long ; A := scan.getCurrent()->toLong() ;
    var B : long ; B := scan.getCurrent()->toLong() ;
    if (A + B - 1 > N or A * B < N) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var ansList : Sequence(long) ; ansList := Sequence{} ;
    var n : long ; n := 0 ;
    var m : long ; m := 0 ;
    var l : long ; l := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     if (N - i * B <= (A - i - 1) + B) then (     n := i ; 
     m := A - i - 1 ; 
     l := N - n * B - m ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var i : long ; i := 0 ; while i < n do ( (         var j : long ; j := B ; while j > 0 do (     ansList := ansList->including(i * B + j) ;  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
        var i : long ; i := n * B + l ; while i > n * B do (     ansList := ansList->including(i) ;  ;     i := i - 1 ) ; 
        var i : long ; i := n * B + l + 1 ; while i <= N do (     ansList := ansList->including(i) ;  ;     i := i + 1 ) ; 
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
        var i : int ; i := 0 ; while i < N do (     skip ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    int n=Integer.parseInt(sa[0]);
    int a=Integer.parseInt(sa[1]);
    int b=Integer.parseInt(sa[2]);
    br.close();
    if(n<a+b-1 ||(long)a*b<n){
      System.out.println(-1);
      return ;
    }
    StringBuilder sb=new StringBuilder();
    int rem=b ;
    int start=0 ;
    int end=n ;
    while(rem>0){
      start=Math.max(end-a+1,rem);
      for(int i=start ; i<=end ; i++){
        sb.append(i).append(' ');
      }
      end=start-1 ;
      rem--;
    }
    sb.deleteCharAt(sb.length()-1);
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var n : int ; n := (sa[0+1])->toInteger() ;
    var a : int ; a := (sa[1+1])->toInteger() ;
    var b : int ; b := (sa[2+1])->toInteger() ;
    skip ; 
    if (n < a + b - 1 or a->oclAsType(long) * b < n) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var sb : String ; sb := StringLib.newString() ;
    var rem : int ; rem := b ;
    var start : int ; start := 0 ;
    var end : int ; end := n ;
    while (rem > 0) do (     start := Set{end - a + 1, rem}->max() ; 
         var i : int ; i := start ; while i <= end do ( (     sb := sb + StringLib.newString(i) + StringLib.newString(' ') )  ;     i := i + 1 ) ; 
     end := start - 1 ; 
     rem := rem - 1 ) ; 
    sb := sb->excludingAt(sb->size() - 1+1) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int sum(int a){
    int ans=0 ;
    while(a>=10){
      ans+=a % 10 ;
      a/=10 ;
    }
    ans+=a ;
    return ans ;
  }
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int N=stdIn.nextInt();
    int n=0 ;
    if(N % 2==0){
      n=N/2 ;
    }
    else {
      n=(N+1)/2 ;
    }
    int ans=sum(1)+sum(N-1);
    for(int A=1 ; A<=n ; A++){
      if(sum(A)+sum(N-A)<ans){
        ans=sum(A)+sum(N-A);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation sum( a : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     while (a >= 10) do (     ans := ans+(a mod 10) ; 
     a := a/(10) ) ; 
     ans := ans+(a) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := stdIn.getCurrent()->toInteger() ;
    var n : int ; n := 0 ;
    if (N mod 2 = 0) then (     n := N / 2 ) else (     n := (N + 1) / 2 ) ;  
    var ans : int ; ans := sum(1) + sum(N - 1) ;
        var A : int ; A := 1 ; while A <= n do ( (     if (sum(A) + sum(N - A) < ans) then (     ans := sum(A) + sum(N - A) ) else skip )  ;     A := A + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Iterator ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextInt(),a=sc.nextInt(),b=sc.nextInt();
    PrintWriter out=new PrintWriter(System.out);
    LinkedList<Long>ans=make(n,a,b);
    Iterator<Long>it=a<b ? ans.descendingIterator(): ans.iterator();
    it.hasNext();
    out.print(it.next());
    while(it.hasNext()){
      out.print(" "+it.next());
    }
    out.println();
    out.flush();
  }
  LinkedList<Long>make(long n,long a,long b){
    if(a<b)return make(n,b,a);
    LinkedList<Long>ans=new LinkedList<>();
    if(a*b>=n && n>=a+b-1){
      for(long i=1 ; i<=b ; i++){
        for(long j=Math.min(a,n-b+i)-1 ; j>=0 ; j--)ans.addLast(n-j);
        n-=Math.min(a,n+i-b);
      }
    }
    else {
      ans.add(-1L);
    }
    return ans ;
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toInteger() ;
    var a : long ; a := sc.getCurrent()->toInteger() ;
    var b : long ; b := sc.getCurrent()->toInteger() ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var ans : Sequence(long) ; ans := make(n, a, b) ;
    var it : OclIterator ; it := if a < b then ans.descendingIterator() else ans->iterator() endif ;
    it.hasNext() ; 
    skip ; 
    while (it.hasNext()) do (     skip ) ; 
    skip ; 
    skip ; 
 );
   operation make( n : long, a : long, b : long) : Sequence(long)
  pre: true
  post: true
  activity: (     if (a < b) then     return make(n, b, a) else skip ; 
     var ans : Sequence(long) ; ans := Sequence{} ;
     if (a * b >= n & n >= a + b - 1) then (         var i : long ; i := 1 ; while i <= b do ( (         var j : long ; j := Set{a, n - b + i}->min() - 1 ; while j >= 0 do (     ans := ans->append(n - j) ;  ;     j := j - 1 ) ; 
     n := n-(Set{a, n + i - b}->min()) )  ;     i := i + 1 ) ) else (     ans := ans->including(-1L) ) ;  
     return ans );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int noOfDeletions(String str,char k){
    int ans=0,cnt=0,pos=0 ;
    while(pos<str.length()&& str.charAt(pos)!=k){
      pos++;
    }
    int i=pos ;
    while(i<str.length()){
      while(i<str.length()&& str.charAt(i)==k){
        i=i+1 ;
      }
      ans=ans+cnt ;
      cnt=0 ;
      while(i<str.length()&& str.charAt(i)!=k){
        i=i+1 ;
        cnt=cnt+1 ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    String str1="ababababa" ;
    char k1='a' ;
    System.out.print(noOfDeletions(str1,k1)+"\n");
    String str2="kprkkoinkopt" ;
    char k2='k' ;
    System.out.print(noOfDeletions(str2,k2)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation noOfDeletions( str : String, k : String) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
    var cnt : int ; cnt := 0 ;
    var pos : int ; pos := 0 ;
     while (pos < str->size() & str->at(pos+1) /= k) do (     pos := pos + 1 ) ; 
    var i : int ; i := pos ;
    while (i < str->size()) do (     while (i < str->size() & str->at(i+1) = k) do (     i := i + 1 ) ; 
     ans := ans + cnt ; 
     cnt := 0 ; 
     while (i < str->size() & str->at(i+1) /= k) do (     i := i + 1 ; 
     cnt := cnt + 1 ) ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "ababababa" ;
     var k1 : String ; k1 := 'a' ;
    OclFile["System.out"].print(noOfDeletions(str1, k1) + "\n") ; 
    var str2 : String ; str2 := "kprkkoinkopt" ;
    var k2 : String ; k2 := 'k' ;
    OclFile["System.out"].print(noOfDeletions(str2, k2) + "\n") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int sumOfDigitsFrom1ToN(int n){
    int result=0 ;
    for(int x=1 ; x<=n ; x++)result+=sumOfDigits(x);
    return result ;
  }
  static int sumOfDigits(int x){
    int sum=0 ;
    while(x!=0){
      sum+=x % 10 ;
      x=x/10 ;
    }
    return sum ;
  }
  public static void main(String args[]){
    int n=328 ;
    System.out.println("Sum of digits in numbers"+" from 1 to "+n+" is "+sumOfDigitsFrom1ToN(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfDigitsFrom1ToN( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var x : int ; x := 1 ; while x <= n do (     result := result+(sumOfDigits(x)) ;  ;     x := x + 1 ) ; 
     return result );
  static   operation sumOfDigits( x : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (x /= 0) do (     sum := sum+(x mod 10) ; 
     x := x / 10 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 328 ;
     OclFile["System.out"].println("Sum of digits in numbers" + " from 1 to " + n + " is " + sumOfDigitsFrom1ToN(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int A=sc.nextInt();
    int B=sc.nextInt();
    int sq=(int)Math.sqrt((double)N);
    if((A+B>N+1)||(A<sq && B<sq))System.out.println(-1);
    else if(A+B==N+1){
      for(int i=B ; i<=N ; ++i)System.out.print(i+" ");
      for(int i=B-1 ; i>=1 ; --i)System.out.print(i+" ");
      System.out.println();
    }
    else {
      int tempA=(N/B)+(N % B!=0 ? 1 : 0);
      int hidari=0 ;
      while(tempA+hidari!=A){
        hidari++;
        if(hidari>N){
          System.out.println(-1);
          return ;
        }
        if((N-hidari)% B==0)tempA--;
      }
      int nowN=N-hidari ;
      for(int i=1 ; i<=hidari ; ++i)System.out.print(i+" ");
      for(int i=1 ; i<=nowN/B ; i++){
        for(int j=i*B ; j>(i-1)*B ; j--){
          System.out.print((j+hidari)+" ");
        }
      }
      for(int j=nowN ; j>B*(nowN/B); --j)System.out.print((j+hidari)+" ");
      System.out.println();
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var sq : int ; sq := (N->oclAsType(double))->sqrt()->oclAsType(int) ;
    if ((A + B > N + 1) or (A < sq & B < sq)) then     OclFile["System.out"].println(-1) else     if (A + B = N + 1) then (         var i : int ; i := B ; while i <= N do (     OclFile["System.out"].print(i + " ") ;  ;     i := i + 1 ) ; 
         var i : int ; i := B - 1 ; while i >= 1 do (     OclFile["System.out"].print(i + " ") ;  ;     i := i - 1 ) ; 
     OclFile["System.out"].println() ) else (     var tempA : int ; tempA := (N / B) + (if N mod B /= 0 then 1 else 0 endif) ;
     var hidari : int ; hidari := 0 ;
    while (tempA + hidari /= A) do (     hidari := hidari + 1 ; 
     if (hidari > N) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
     if ((N - hidari) mod B = 0) then     tempA := tempA - 1 ; else skip ) ; 
    var nowN : int ; nowN := N - hidari ;
        var i : int ; i := 1 ; while i <= hidari do (     OclFile["System.out"].print(i + " ") ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= nowN / B do ( (         var j : int ; j := i * B ; while j > (i - 1) * B do ( (     OclFile["System.out"].print((j + hidari) + " ") )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
        var j : int ; j := nowN ; while j > B * (nowN / B) do (     OclFile["System.out"].print((j + hidari) + " ") ;  ;     j := j - 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ;  
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int maxSum(int arr[],int n,int k){
    if(n<k){
      System.out.println("Invalid");
      return-1 ;
    }
    int res=0 ;
    for(int i=0 ; i<k ; i++)res+=arr[i];
    int curr_sum=res ;
    for(int i=k ; i<n ; i++){
      curr_sum+=arr[i]-arr[i-k];
      res=Math.max(res,curr_sum);
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      1,4,2,10,2,3,1,0,20 };
      int k=4 ;
      int n=arr.length ;
      System.out.println(maxSum(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSum( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     if (n < k) then (     OclFile["System.out"].println("Invalid") ; 
     return -1 ) else skip ; 
     var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < k do (     res := res+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    var curr_sum : int ; curr_sum := res ;
        var i : int ; i := k ; while i < n do ( (     curr_sum := curr_sum+(arr[i+1] - arr[i - k+1]) ; 
     res := Set{res, curr_sum}->max() )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,4,2,10,2,3,1,0,20} ;
     var k : int ; k := 4 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxSum(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MyClass {
  static Scanner in=new Scanner(System.in);
  static int testCases,n ;
  static int a[];
  static void solve(){
    int max=a[0];
    for(int i : a){
      if(i>=max){
        max=i ;
      }
    }
    int count[]=new int[max+1];
    for(int i : a){
      count[i]++;
    }
    int dup=0 ;
    for(int i : count){
      if(i>1){
        dup+=i-1 ;
      }
    }
    int have=0 ;
    for(int i=0 ; i<n ; ++i){
      if(dup==0){
        break ;
      }
++have ;
      if(count[a[i] ]>1){
--dup ;
--count[a[i] ];
      }
    }
    System.out.println(have);
  }
  public static void main(String args[]){
    testCases=in.nextInt();
    for(int t=0 ; t<testCases ; ++t){
      n=in.nextInt();
      a=new int[n];
      for(int i=0 ; i<n ; ++i){
        a[i]=in.nextInt();
      }
      solve();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute testCases : int;
  static   attribute a : Sequence(int);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var max : int ; max := a[0+1] ;
     for (i : a) do ( (     if (i >= max) then (     max := i ) else skip )  ) ; 
    var count : Sequence(int) ; count := Integer.subrange(1,max + 1)->collect(0) ;
    for (i : a) do ( (     count[i+1] := count[i+1] + 1 )  ) ; 
    var dup : int ; dup := 0 ;
    for (i : count) do ( (     if (i > 1) then (     dup := dup+(i - 1) ) else skip )  ) ; 
    var have : int ; have := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (dup = 0) then (     break ) else skip ; 
     have := have + 1 ; 
     if (count[a[i+1]+1] > 1) then (     dup := dup - 1 ; 
     count[a[i+1]+1] := count[a[i+1]+1] - 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(have) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     testCases := in.getCurrent()->toInteger() ; 
         var t : int ; t := 0 ; while t < testCases do ( (     n := in.getCurrent()->toInteger() ; 
     a := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     execute solve() )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      HashSet<Integer>set=new HashSet<>();
      int count=0 ;
      for(int i=n-1 ; i>=0 ; i--){
        if(set.contains(arr[i])){
          break ;
        }
        set.add(arr[i]);
        count++;
      }
      int ans=n-count ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
    var count : int ; count := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (set->includes(arr[i+1])) then (     break ) else skip ; 
     set := set->including(arr[i+1]) ; 
     count := count + 1 )  ;     i := i - 1 ) ; 
    var ans : int ; ans := n - count ;
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.HashSet ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=sc.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      int count=0 ;
      Set<Integer>set=new HashSet<>();
      for(int i=n-1 ; i>=0 ; i--){
        if(set.contains(arr[i])){
          break ;
        }
        set.add(arr[i]);
        count++;
      }
      System.out.println(n-count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (set->includes(arr[i+1])) then (     break ) else skip ; 
     set := set->including(arr[i+1]) ; 
     count := count + 1 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(n - count) ; 
 )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test287 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int c[]=new int[n];
      int a[]=new int[n];
      int last=0 ;
      for(int i=0 ; i<n ; i++){
        c[i]=in.nextInt();
        if(a[c[i]-1]!=0){
          if(a[c[i]-1]>last)last=a[c[i]-1];
        }
        a[c[i]-1]=i+1 ;
      }
      System.out.println(last);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test287 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var last : int ; last := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := in.getCurrent()->toInteger() ; 
     if (a[c[i+1] - 1+1] /= 0) then (     if (a[c[i+1] - 1+1] > last) then     last := a[c[i+1] - 1+1] ; else skip ) else skip ; 
     a[c[i+1] - 1+1] := i + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(last) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public static void main(String[] args){
    java.util.Scanner s=new java.util.Scanner(System.in);
    System.out.println(Main.calc(s.nextInt()));
  }
  public static int calc(int n){
    int res=n ;
    for(int a=1 ; a<n ; a++){
      int b=n-a ;
      int cal=Main.calcKeta(a)+Main.calcKeta(b);
      res=Math.min(cal,res);
    }
    return res ;
  }
  private static int calcKeta(int n){
    return(n==0)? 0 : n % 10+Main.calcKeta(n/10);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Scanner ; s := Scanner.newScanner(OclFile["System.in"]) ;
     OclFile["System.out"].println(Main.calc(s.nextInt())) );
  static   operation calc( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := n ;
         var a : int ; a := 1 ; while a < n do ( (     var b : int ; b := n - a ;
     var cal : int ; cal := Main.calcKeta(a) + Main.calcKeta(b) ;
     res := Set{cal, res}->min() )  ;     a := a + 1 ) ; 
     return res );
  static   operation calcKeta( n : int) : int
  pre: true
  post: true
  activity: (     return if (n = 0) then 0 else n mod 10 + Main.calcKeta(n / 10) endif );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static long MOD=(long)(1e9+7);
  static long powerLL(long x,long n){
    long result=1 ;
    while(n>0){
      if(n % 2==1){
        result=result*x % MOD ;
      }
      n=n/2 ;
      x=x*x % MOD ;
    }
    return result ;
  }
  static long powerStrings(String sa,String sb){
    long a=0,b=0 ;
    for(int i=0 ; i<sa.length(); i++){
      a=(a*10+(sa.charAt(i)-'0'))% MOD ;
    }
    for(int i=0 ; i<sb.length(); i++){
      b=(b*10+(sb.charAt(i)-'0'))%(MOD-1);
    }
    return powerLL(a,b);
  }
  public static void main(String[] args){
    String sa="2",sb="3" ;
    System.out.println(powerStrings(sa,sb));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MOD : long := (1e9 + 7)->oclAsType(long);
  static   operation powerLL( x : long, n : long) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 1 ;
     while (n > 0) do (     if (n mod 2 = 1) then (     result := result * x mod MOD ) else skip ; 
     n := n / 2 ; 
     x := x * x mod MOD ) ; 
     return result );
  static   operation powerStrings( sa : String, sb : String) : long
  pre: true
  post: true
  activity: (     var a : long ; a := 0 ;
    var b : long ; b := 0 ;
         var i : int ; i := 0 ; while i < sa->size() do ( (     a := (a * 10 + (sa->at(i+1) - ('0')->char2byte())) mod MOD )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < sb->size() do ( (     b := (b * 10 + (sb->at(i+1) - ('0')->char2byte())) mod (MOD - 1) )  ;     i := i + 1 ) ; 
     return powerLL(a, b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sa : String ; sa := "2" ;
    var sb : String ; sb := "3" ;
     OclFile["System.out"].println(powerStrings(sa, sb)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
class GFG {
  static int NO_OF_CHARS=256 ;
  static boolean canFormPalindrome(String str){
    int count[]=new int[NO_OF_CHARS];
    Arrays.fill(count,0);
    for(int i=0 ; i<str.length(); i++)count[(int)(str.charAt(i))]++;
    int odd=0 ;
    for(int i=0 ; i<NO_OF_CHARS ; i++){
      if((count[i] & 1)==1)odd++;
      if(odd>1)return false ;
    }
    return true ;
  }
  public static void main(String args[]){
    if(canFormPalindrome("geeksforgeeks"))System.out.println("Yes");
    else System.out.println("No");
    if(canFormPalindrome("geeksogeeks"))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute NO_OF_CHARS : int := 256;
  static   operation canFormPalindrome( str : String) : boolean
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,NO_OF_CHARS)->collect(0) ;
     count := count->collect(0) ; 
        var i : int ; i := 0 ; while i < str->size() do (     count[(str->at(i+1))->oclAsType(int)+1] := count[(str->at(i+1))->oclAsType(int)+1] + 1 ;  ;     i := i + 1 ) ; 
    var odd : int ; odd := 0 ;
        var i : int ; i := 0 ; while i < NO_OF_CHARS do ( (     if ((count[i+1] & 1) = 1) then     odd := odd + 1 ; else skip ; 
     if (odd > 1) then     return false else skip )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (canFormPalindrome("geeksforgeeks")) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
     if (canFormPalindrome("geeksogeeks")) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int people[]=new int[100005];
    int n=Integer.parseInt(br.readLine());
    for(int i=0 ; i<n ; i++){
      String str[]=br.readLine().split(" ");
      int a=Integer.parseInt(str[0]);
      int b=Integer.parseInt(str[1]);
      people[a]++;
      people[b+1]--;
    }
    int sum=1 ;
    int ans=0 ;
    for(int i=0 ; i<100005 ; i++){
      sum+=people[i];
      if(i<=sum){
        ans=i ;
      }
    }
    System.out.println(ans-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var people : Sequence(int) ; people := Integer.subrange(1,100005)->collect(0) ;
    var n : int ; n := (br.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     var a : int ; a := (str[0+1])->toInteger() ;
    var b : int ; b := (str[1+1])->toInteger() ;
    people[a+1] := people[a+1] + 1 ; 
    people[b + 1+1] := people[b + 1+1] - 1 ; 
 )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 1 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 100005 do ( (     sum := sum+(people[i+1]) ; 
     if (i <= sum) then (     ans := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class CodeForces {
  static long[] a ;
  static int n ;
  static long h ;
  public static void main(String[] args)throws FileNotFoundException {
    FastScanner fs=new FastScanner();
    boolean flag=true ;
    for(int i=0 ; i<8 ; i++){
      char[] a=fs.next().toCharArray();
      for(int j=0 ; j<8-1 ; j++){
        if(a[j]==a[j+1]){
          flag=false ;
          break ;
        }
      }
    }
    if(flag){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
  static void sort(int[] a){
    ArrayList<Integer>l=new ArrayList<>();
    for(int i : a)l.add(i);
    Collections.sort(l);
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   attribute a : Sequence(long);
  static   attribute n : int;
  static   attribute h : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var flag : boolean ; flag := true ;
         var i : int ; i := 0 ; while i < 8 do ( (     var a : Sequence(String) ; a := fs.next()->characters() ;
         var j : int ; j := 0 ; while j < 8 - 1 do ( (     if (a[j+1] = a[j + 1+1]) then (     flag := false ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (flag) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l := l->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static void solve(){
    int n=in.nextInt();
    int[] a=new int[100010];
    a[0]=1 ;
    for(int i=0 ; i<n ; i++){
      int s=in.nextInt();
      int t=in.nextInt();
      a[s]+=1 ;
      a[t+1]-=1 ;
    }
    int max=0 ;
    for(int i=1 ; i<a.length ; i++){
      a[i]+=a[i-1];
      if(i<=a[i])max=i ;
    }
    out.println(max-1);
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    solve();
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,100010)->collect(0) ;
    a[0+1] := 1 ; 
        var i : int ; i := 0 ; while i < n do ( (     var s : int ; s := in.getCurrent()->toInteger() ;
     var t : int ; t := in.getCurrent()->toInteger() ;
     a[s+1] := a[s+1]+(1) ; 
     a[t + 1+1] := a[t + 1+1]-(1) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i < a->size() do ( (     a[i+1] := a[i+1]+(a[i - 1+1]) ; 
     if (i <= a[i+1]) then     max := i ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    execute solve() ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    int n=ni();
    ArrayList<LinkedList<Integer>>list=new ArrayList<>();
    for(int i=0 ; i<=100001 ; ++i){
      list.add(new LinkedList<>());
    }
    for(int i=0 ; i<n ; ++i){
      int a=ni();
      int b=ni();
      list.get(a).add(b);
    }
    int max=0 ;
    PriorityQueue<Integer>kouho=new PriorityQueue<>(Comparator.reverseOrder());
    PriorityQueue<Integer>friends=new PriorityQueue<>();
    for(int i=2 ; i<=100001 ; ++i){
      kouho.addAll(list.get(i));
      while(friends.size()<i-1 && kouho.size()>0){
        int v=kouho.poll();
        if(v<i){
          break ;
        }
        friends.add(v);
      }
      if(friends.size()==i-1){
        max=Math.max(max,i-1);
      }
      while(friends.size()>0 && friends.peek()==i){
        int v=friends.poll();
      }
    }
    System.out.println(max);
  }
  int ni(){
    return Integer.parseInt(sc.next());
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := ni() ;
     var list : Sequence(Sequence(int)) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i <= 100001 do ( (     list := list->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := ni() ;
     var b : int ; b := ni() ;
     list->at(a+1)->excludes(b) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var kouho : Sequence(int) ; kouho := Sequence{}->union(Comparator.reverseOrder()) ;
    var friends : Sequence(int) ; friends := Sequence{} ;
        var i : int ; i := 2 ; while i <= 100001 do ( (     kouho := kouho->union(list->at(i+1)) ; 
     while (friends->size() < i - 1 & kouho->size() > 0) do (     var v : int ; v := kouho->min() ;
     if (v < i) then (     break ) else skip ; 
     friends := friends->including(v) ) ; 
     if (friends->size() = i - 1) then (     max := Set{max, i - 1}->max() ) else skip ; 
     while (friends->size() > 0 & friends->min() = i) do (     var v : int ; v := friends->min() ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (sc.getCurrent())->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  class R implements Comparable<R>{
    int x ;
    boolean f ;
    public R(int x,boolean f){
      this.x=x ;
      this.f=f ;
    }
    public int compareTo(R o){
      return x-o.x ;
    }
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    PriorityQueue<R>q=new PriorityQueue<R>();
    for(int i=0 ; i<n ; i++){
      q.add(new R(sc.nextInt(),true));
      q.add(new R(sc.nextInt()+1,false));
    }
    q.add(new R(n+3,true));
    int res=0,c=0,f=1 ;
    while(! q.isEmpty()){
      R r=q.poll();
      while(f!=r.x){
        if(f-1<=c)res=f-1 ;
        f++;
      }
      c+=r.f ? 1 :-1 ;
    }
    System.out.println(res);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class R implements Comparable<R> {
   attribute x : int;
   attribute f : boolean;
   static operation newR( x : int, f : boolean) : R
  pre: true
  post: true
  activity:
  ( var self : R ;
    self := createR();
    self.initialise(x, f);
    return self );
  operation initialise( x : int, f : boolean) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.f := f );
   operation compareTo( o : R) : int
  pre: true
  post: true
  activity: (     return x - o.x );
}
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : Sequence(R) ; q := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     q := q->including(R.newR(sc.getCurrent()->toInteger(), true)) ; 
     q := q->including(R.newR(sc.getCurrent()->toInteger() + 1, false)) )  ;     i := i + 1 ) ; 
    q := q->including(R.newR(n + 3, true)) ; 
    var res : int ; res := 0 ;
    var c : int ; c := 0 ;
    var f : int ; f := 1 ;
    while (not(q->isEmpty())) do (     var r : R ; r := q->min() ;
     while (f /= r.x) do (     if (f - 1 <= c) then     res := f - 1 ; else skip ; 
     f := f + 1 ) ; 
     c := c+(if r.f then 1 else -1 endif) ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int a,b ;
  static int ans ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      ans=0 ;
      int n=sc.nextInt();
      int[] friend=new int[100011];
      for(int i=0 ; i<100011 ; i++){
        friend[i]=0 ;
      }
      while(n-->0){
        a=sc.nextInt();
        b=sc.nextInt();
        for(int i=a-1 ; i<b ; i++){
          friend[i]++;
        }
      }
      for(int i=0 ; i<=100001 ; i++){
        if(i<=friend[i])ans=i ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a : int;
  static   attribute ans : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     ans := 0 ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var friend : Sequence(int) ; friend := Integer.subrange(1,100011)->collect(0) ;
        var i : int ; i := 0 ; while i < 100011 do ( (     friend[i+1] := 0 )  ;     i := i + 1 ) ; 
        while (n > 0) do (        n := n - 1 ;     skip ; (     a := sc.getCurrent()->toInteger() ; 
     b := sc.getCurrent()->toInteger() ; 
         var i : int ; i := a - 1 ; while i < b do ( (     friend[i+1] := friend[i+1] + 1 )  ;     i := i + 1 ) ) ;  ) ;  
        var i : int ; i := 0 ; while i <= 100001 do ( (     if (i <= friend[i+1]) then     ans := i ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static long solve(long l){
    long pre=2 ;
    long coff=3 ;
    while(coff<=l){
      if(l % coff==0)return l/coff ;
      pre=pre*2 ;
      coff+=pre ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      long l=sc.nextLong();
      System.out.println(solve(l));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation solve( l : long) : long
  pre: true
  post: true
  activity: (     var pre : long ; pre := 2 ;
     var coff : long ; coff := 3 ;
     while (coff <= l) do (     if (l mod coff = 0) then     return l / coff else skip ; 
     pre := pre * 2 ; 
     coff := coff+(pre) ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var l : long ; l := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println(solve(l)) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int givenNum=scanner.nextInt();
    int currentTarget=0 ;
    for(int i=1 ; i<givenNum ; i++){
      int target1=0 ;
      int target2=0 ;
      int num1=i ;
      int num2=givenNum-i ;
      while(num1>0){
        target1+=num1 % 10 ;
        num1/=10 ;
      }
      while(num2>0){
        target2+=num2 % 10 ;
        num2/=10 ;
      }
      if(i==1){
        currentTarget=target1+target2 ;
      }
      if(currentTarget>target1+target2){
        currentTarget=target1+target2 ;
      }
    }
    System.out.println(currentTarget);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var givenNum : int ; givenNum := scanner.getCurrent()->toInteger() ;
    var currentTarget : int ; currentTarget := 0 ;
        var i : int ; i := 1 ; while i < givenNum do ( (     var target1 : int ; target1 := 0 ;
     var target2 : int ; target2 := 0 ;
    var num1 : int ; num1 := i ;
    var num2 : int ; num2 := givenNum - i ;
    while (num1 > 0) do (     target1 := target1+(num1 mod 10) ; 
     num1 := num1/(10) ) ; 
    while (num2 > 0) do (     target2 := target2+(num2 mod 10) ; 
     num2 := num2/(10) ) ; 
    if (i = 1) then (     currentTarget := target1 + target2 ) else skip ; 
    if (currentTarget > target1 + target2) then (     currentTarget := target1 + target2 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(currentTarget) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solver {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int tt=0 ; tt<T ; tt++){
      long n=in.nextLong();
      int num=1 ;
      for(int pw=2 ; pw<30 ; pw++){
        int val=(1<<pw)-1 ;
        if(n % val==0){
          System.out.println(n/val);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solver {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var tt : int ; tt := 0 ; while tt < T do ( (     var n : long ; n := in.getCurrent()->toLong() ;
     var num : int ; num := 1 ;
         var pw : int ; pw := 2 ; while pw < 30 do ( (     var val : int ; val := ((1*(2->pow(pw)))->oclAsType(long)) - 1 ;
     if (n mod val = 0) then (     OclFile["System.out"].println(n / val) ; 
     break ) else skip )  ;     pw := pw + 1 ) )  ;     tt := tt + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Problem_1343A_Candies {
  public static FastScanner s=new FastScanner();
  public static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    int testCases=s.nextInt();
    for(int i=0 ; i<testCases ; i++){
      solve(s.nextInt());
    }
    out.close();
  }
  public static void solve(int n){
    for(int pw=2 ; pw<30 ; ++pw){
      int val=(1<<pw)-1 ;
      if(n % val==0){
        out.println(n/val);
        return ;
      }
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem_1343A_Candies {
  static   attribute s : FastScanner := FastScanner.newFastScanner();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var testCases : int ; testCases := s.nextInt() ;
         var i : int ; i := 0 ; while i < testCases do ( (     execute solve(s.nextInt()) )  ;     i := i + 1 ) ; 
     skip );
  static   operation solve( n : int) : void
  pre: true
  post: true
  activity: (         var pw : int ; pw := 2 ; while pw < 30 do ( (     var val : int ; val := ((1*(2->pow(pw)))->oclAsType(long)) - 1 ;
     if (n mod val = 0) then (     skip ; 
     return ) else skip )  ;     pw := pw + 1 ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class solve {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      sc.nextLine();
      int n=sc.nextInt();
      int k=2 ;
      while(Math.pow(2.0,k)<Integer.MAX_VALUE){
        if(n %(Math.pow(2.0,k)-1)==0){
          System.out.println((int)(n/(Math.pow(2.0,k)-1)));
          break ;
        }
        k++;
      }
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class solve {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     skip ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := 2 ;
     while (2.0->pow(k) < 2147483647) do (     if (n mod (2.0->pow(k) - 1) = 0) then (     OclFile["System.out"].println((n / (2.0->pow(k) - 1))->oclAsType(int)) ; 
     break ) else skip ; 
     k := k + 1 ) )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Mridul5 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int k=0 ;
    while(k!=t){
      k=k+1 ;
      int n=sc.nextInt();
      int i=1 ;
      int sum=0,v=0,u=0 ;
      while(1>0){
        i=i+1 ;
        u=(int)Math.pow(2,i);
        v=u-1 ;
        if(n % v==0){
          break ;
        }
      }
      int x=n/v ;
      System.out.println(x);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mridul5 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     var k : int ; k := 0 ;
     while (k /= t) do (     k := k + 1 ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var i : int ; i := 1 ;
    var sum : int ; sum := 0 ;
    var v : int ; v := 0 ;
    var u : int ; u := 0 ;
    while (1 > 0) do (     i := i + 1 ; 
     u := 2->pow(i)->oclAsType(int) ; 
     v := u - 1 ; 
     if (n mod v = 0) then (     break ) else skip ) ; 
    var x : int ; x := n / v ;
    OclFile["System.out"].println(x) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countPairs(int arr[],int k){
    Arrays.sort(arr);
    int pair=0 ;
    int index=0 ;
    while(index<arr.length-1){
      if(arr[index+1]-arr[index]<=k){
        pair+=1 ;
        index+=2 ;
      }
      else {
        index+=1 ;
      }
    }
    return pair ;
  }
  public static void main(String[] args){
    int arr[]={
      1,4,3,7,5 };
      int k=2 ;
      int count=countPairs(arr,k);
      System.out.println(count);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPairs( arr : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var pair : int ; pair := 0 ;
    var index : int ; index := 0 ;
    while (index < arr->size() - 1) do (     if (arr[index + 1+1] - arr[index+1] <= k) then (     pair := pair+(1) ; 
     index := index+(2) ) else (     index := index+(1) ) ) ; 
    return pair 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,4,3,7,5} ;
     var k : int ; k := 2 ;
     var count : int ; count := countPairs(arr, k) ;
     OclFile["System.out"].println(count) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Chess3 {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    boolean pos=true ;
    for(int i=0 ; i<8 && pos ; i++){
      String r=br.readLine();
      int w=0 ;
      int b=0 ;
      for(int j=0 ; j<8 ; j++){
        if(r.charAt(j)=='B')b++;
        else w++;
        if(j<7 && r.charAt(j)==r.charAt(j+1))pos=false ;
      }
      if(w!=b)pos=false ;
    }
    pw.println(pos ? "YES" : "NO");
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Chess3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var pos : boolean ; pos := true ;
        var i : int ; i := 0 ; while i < 8 & pos do ( (     var r : String ; r := br.readLine() ;
     var w : int ; w := 0 ;
    var b : int ; b := 0 ;
        var j : int ; j := 0 ; while j < 8 do ( (     if (r->at(j+1) = 'B') then     b := b + 1 else     w := w + 1 ; ;  
     if (j < 7 & r->at(j+1) = r->at(j + 1+1)) then     pos := false ; else skip )  ;     j := j + 1 ) ; 
    if (w /= b) then     pos := false ; else skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      String s=in.next();
      int alice=0,bob=0 ;
      for(int i=0 ; i<s.length(); i++){
        alice+=(int)s.charAt(i)-96 ;
      }
      if(s.length()% 2==0){
        System.out.println("Alice "+alice);
      }
      else {
        bob=(s.charAt(0)<s.charAt(s.length()-1))?(int)s.charAt(0):(int)s.charAt(s.length()-1);
        bob-=96 ;
        if(alice-bob>bob){
          System.out.println("Alice "+(alice-bob-bob));
        }
        else {
          System.out.println("Bob "+(bob-(alice-bob)));
        }
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : String ; s := in.getCurrent() ;
     var alice : int ; alice := 0 ;
    var bob : int ; bob := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     alice := alice+(s->at(i+1)->oclAsType(int) - 96) )  ;     i := i + 1 ) ; 
     if (s->size() mod 2 = 0) then (     OclFile["System.out"].println("Alice " + alice) ) else (     bob := if (s->at(0+1) < s->at(s->size() - 1+1)) then s->at(0+1)->oclAsType(int) else s->at(s->size() - 1+1)->oclAsType(int) endif ; 
     bob := bob-(96) ; 
     if ((alice)->char2byte() - (bob)->char2byte() > bob) then (     OclFile["System.out"].println("Alice " + ((alice)->char2byte() - (bob)->char2byte() - (bob)->char2byte())) ) else (     OclFile["System.out"].println("Bob " + ((bob)->char2byte() - ((alice)->char2byte() - (bob)->char2byte()))) ) ) ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      String s=sc.next();
      System.out.println(solve(s));
    }
    sc.close();
  }
  static String solve(String s){
    if(s.length()% 2==0){
      return compare(s,"");
    }
    return(s.charAt(0)<=s.charAt(s.length()-1))? compare(s.substring(1),String.valueOf(s.charAt(0))): compare(s.substring(0,s.length()-1),String.valueOf(s.charAt(s.length()-1)));
  }
  static String compare(String alice,String bob){
    int aliceScore=alice.chars().map(c->c-'a'+1).sum();
    int bobScore=bob.chars().map(c->c-'a'+1).sum();
    return(aliceScore>bobScore)? String.format("Alice %d",aliceScore-bobScore): String.format("Bob %d",bobScore-aliceScore);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var s : String ; s := sc.getCurrent() ;
     OclFile["System.out"].println(solve(s)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( s : String) : String
  pre: true
  post: true
  activity: (     if (s->size() mod 2 = 0) then (     return compare(s, "") ) else skip ; 
     return if (s->at(0+1) <= s->at(s->size() - 1+1)) then compare(s.subrange(1+1,1), ((s->at(0+1)) + "")) else compare(s.subrange(0+1,s->size() - 1), ((s->at(s->size() - 1+1)) + "")) endif );
  static   operation compare( alice : String, bob : String) : String
  pre: true
  post: true
  activity: (     var aliceScore : int ; aliceScore := alice.chars()->collect( _x1 | (lambda c : OclAny in c - ('a')->char2byte() + 1)->apply(_x1) )->sum() ;
     var bobScore : int ; bobScore := bob.chars()->collect( _x1 | (lambda c : OclAny in c - ('a')->char2byte() + 1)->apply(_x1) )->sum() ;
     return if (aliceScore > bobScore) then StringLib.format("Alice %d",Sequence{(aliceScore)->char2byte() - bobScore}) else StringLib.format("Bob %d",Sequence{bobScore - (aliceScore)->char2byte()}) endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1673 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      char[] S=in.next().toCharArray();
      int sum=S.length ;
      for(char c : S){
        sum+=c-'a' ;
      }
      int alice=sum ;
      int bob=0 ;
      if(S.length % 2==1){
        char rest=(char)Math.min(S[0],S[S.length-1]);
        int restValue=rest-'a'+1 ;
        alice-=restValue ;
        bob=restValue ;
      }
      if(alice>bob){
        System.out.println("Alice "+(alice-bob));
      }
      else {
        System.out.println("Bob "+(bob-alice));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1673 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var S : Sequence(String) ; S := in.getCurrent()->characters() ;
     var sum : int ; sum := S->size() ;
    for (c : S) do ( (     sum := sum+(c - ('a')->char2byte()) )  ) ; 
    var alice : int ; alice := sum ;
    var bob : int ; bob := 0 ;
    if (S->size() mod 2 = 1) then (     var rest : String ; rest := Set{S[0+1], S[S->size() - 1+1]}->min()->oclAsType(String) ;
     var restValue : int ; restValue := (rest)->char2byte() - ('a')->char2byte() + 1 ;
     alice := alice-(restValue) ; 
     bob := restValue ) else skip ; 
    if (alice > bob) then (     OclFile["System.out"].println("Alice " + (alice - bob)) ) else (     OclFile["System.out"].println("Bob " + (bob - alice)) ) ;  
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxSubarrayXOR(int arr[],int n){
    int ans=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      int curr_xor=0 ;
      for(int j=i ; j<n ; j++){
        curr_xor=curr_xor ^ arr[j];
        ans=Math.max(ans,curr_xor);
      }
    }
    return ans ;
  }
  public static void main(String args[]){
    int arr[]={
      8,1,2,12 };
      int n=arr.length ;
      System.out.println("Max subarray XOR is "+maxSubarrayXOR(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxSubarrayXOR( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := -2147483648 ;
         var i : int ; i := 0 ; while i < n do ( (     var curr_xor : int ; curr_xor := 0 ;
         var j : int ; j := i ; while j < n do ( (     curr_xor := MathLib.bitwiseXor(curr_xor,arr[j+1]) ; 
     ans := Set{ans, curr_xor}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,1,2,12} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Max subarray XOR is " + maxSubarrayXOR(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Geeks {
  static int check_digits(int n){
    while(n>0){
      if((n % 10)% 2==0)return 0 ;
      n/=10 ;
    }
    return 1 ;
  }
  static int smallest_number(int n){
    for(int i=n ; ; i++)if(check_digits(i)>0)return i ;
  }
  public static void main(String args[]){
    int N=2397 ;
    System.out.println(smallest_number(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class Geeks {
  static   operation check_digits( n : int) : int
  pre: true
  post: true
  activity: (     while (n > 0) do (     if ((n mod 10) mod 2 = 0) then     return 0 else skip ; 
     n := n/(10) ) ; 
     return 1 );
  static   operation smallest_number( n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := n ; while true do (     if (check_digits(i) > 0) then     return i else skip ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 2397 ;
     OclFile["System.out"].println(smallest_number(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
class GFG {
  public static int minProduct(int[] arr,int n,int k){
    PriorityQueue<Integer>pq=new PriorityQueue<>();
    for(int i=0 ; i<n ; i++)pq.add(arr[i]);
    int count=0,ans=1 ;
    while(pq.isEmpty()==false && count<k){
      ans=ans*pq.element();
      pq.remove();
      count++;
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      198,76,544,123,154,675 };
      int k=2 ;
      int n=arr.length ;
      System.out.print("Minimum product is "+minProduct(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minProduct( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var pq : Sequence(int) ; pq := Sequence{} ;
         var i : int ; i := 0 ; while i < n do (     pq := pq->including(arr[i+1]) ;  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var ans : int ; ans := 1 ;
    while (pq->isEmpty() = false & count < k) do (     ans := ans * pq.element() ; 
     pq := pq.remove() ; 
     count := count + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{198,76,544,123,154,675} ;
     var k : int ; k := 2 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print("Minimum product is " + minProduct(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder();
    int t=fs.nextInt();
    while(t-->0){
      int n=fs.nextInt();
      int[] a=new int[26];
      int j=0 ;
      while(j++<n){
        String s=fs.next();
        for(int i=0 ; i<s.length(); i++){
          a[s.charAt(i)-'a']++;
        }
      }
      boolean res=true ;
      for(int i=0 ; i<26 ; i++){
        if(a[i] % n!=0){
          res=false ;
          break ;
        }
      }
      sb.append(res ? "YES" : "NO").append("\n");
    }
    out.println(sb);
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    var t : int ; t := fs.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := fs.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,26)->collect(0) ;
    var j : int ; j := 0 ;
        while (j < n) do (        j := j + 1 ;     skip ; (     var s : String ; s := fs.next() ;
         var i : int ; i := 0 ; while i < s->size() do ( (     a[s->at(i+1) - ('a')->char2byte()+1] := a[s->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ) ;  ) ;  
    var res : boolean ; res := true ;
        var i : int ; i := 0 ; while i < 26 do ( (     if (a[i+1] mod n /= 0) then (     res := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(if res then "YES" else "NO" endif) + StringLib.newString("\n") ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Juggling_Letters {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testcase=sc.nextInt();
    while(testcase!=0){
      testcase--;
      int loop=sc.nextInt();
      int[] arr=new int[30];
      boolean okay=true ;
      for(int i=0 ; i<loop ; i++){
        String str=sc.next();
        char[] s=str.toCharArray();
        for(int j=0 ; j<str.length(); j++){
          int k=(int)s[j]-(int)'a' ;
          arr[k]++;
        }
      }
      for(int i=0 ; i<26 ; i++){
        if(arr[i]!=0 && arr[i] % loop!=0){
          okay=false ;
          break ;
        }
      }
      if(okay)System.out.print("YES");
      else System.out.print("NO");
      if(testcase>0)System.out.println();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Juggling_Letters {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testcase : int ; testcase := sc.getCurrent()->toInteger() ;
     while (testcase /= 0) do (     testcase := testcase - 1 ; 
     var loop : int ; loop := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,30)->collect(0) ;
    var okay : boolean ; okay := true ;
        var i : int ; i := 0 ; while i < loop do ( (     var str : String ; str := sc.getCurrent() ;
     var s : Sequence(String) ; s := str->characters() ;
         var j : int ; j := 0 ; while j < str->size() do ( (     var k : int ; k := s[j+1]->oclAsType(int) - ('a')->char2byte() ;
     arr[k+1] := arr[k+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 26 do ( (     if (arr[i+1] /= 0 & arr[i+1] mod loop /= 0) then (     okay := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (okay) then     OclFile["System.out"].print("YES") else     OclFile["System.out"].print("NO") ; ;  
    if (testcase > 0) then     OclFile["System.out"].println() ; else skip ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class JugglingLetters {
  static Scanner sc=new Scanner(System.in);
  public static void solve(){
    Map<Character,Integer>map=new HashMap<Character,Integer>();
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      String str=sc.next();
      for(int j=0 ; j<str.length(); j++){
        if(map.containsKey(str.charAt(j))){
          map.put(str.charAt(j),map.get(str.charAt(j))+1);
        }
        else {
          map.put(str.charAt(j),1);
        }
      }
    }
    for(Map.Entry<Character,Integer>entry : map.entrySet()){
      if(entry.getValue()% n!=0){
        System.out.println("NO");
        return ;
      }
    }
    System.out.println("YES");
  }
  public static void main(String[] args){
    int tc=sc.nextInt();
    for(int i=0 ; i<tc ; i++){
      solve();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JugglingLetters {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var map : Map(String,int) ; map := Map{} ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < str->size() do ( (     if (map->keys()->includes(str->at(j+1))) then (     map := map->union(Map{str->at(j+1) |-> map->at(str->at(j+1)) + 1}) ) else (     map := map->union(Map{str->at(j+1) |-> 1}) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    for (entry : map->asSet()) do ( (     if (entry.getValue() mod n /= 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ) ; 
    OclFile["System.out"].println("YES") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var tc : int ; tc := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < tc do ( (     execute solve() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test216 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int m=in.nextInt();
      int a[]=new int[26];
      for(int i=0 ; i<m ; i++){
        char[] s=in.next().toCharArray();
        for(int k=0 ; k<s.length ; k++){
          a[s[k]-97]++;
        }
      }
      boolean x=true ;
      for(int i=0 ; i<26 ; i++){
        if(a[i] % m!=0){
          x=false ;
          break ;
        }
      }
      if(x){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test216 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var m : int ; m := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     var s : Sequence(String) ; s := in.getCurrent()->characters() ;
         var k : int ; k := 0 ; while k < s->size() do ( (     a[s[k+1] - 97+1] := a[s[k+1] - 97+1] + 1 )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    var x : boolean ; x := true ;
        var i : int ; i := 0 ; while i < 26 do ( (     if (a[i+1] mod m /= 0) then (     x := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (x) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A_Letter {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    FastReader scan=new FastReader();
    int n=scan.nextInt();
    int m=scan.nextInt();
    StringBuilder[] mat=new StringBuilder[n];
    for(int i=0 ; i<n ; i++){
      mat[i]=new StringBuilder(scan.nextLine());
    }
    int first=Integer.MAX_VALUE ;
    int last=Integer.MIN_VALUE ;
    int firstRow=Integer.MAX_VALUE ;
    int lastRow=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      int tempFirst=mat[i] .indexOf("*");
      int tempLast=mat[i] .lastIndexOf("*");
      if(tempFirst!=-1){
        if(tempFirst<first){
          first=tempFirst ;
        }
        if(tempLast>last){
          last=tempLast ;
        }
        if(i<firstRow){
          firstRow=i ;
        }
        if(i>lastRow){
          lastRow=i ;
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      if(i>=firstRow && i<=lastRow){
        System.out.println(mat[i] .substring(first,last+1));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Letter {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : FastReader ; scan := FastReader.newFastReader() ;
     var n : int ; n := scan.nextInt() ;
    var m : int ; m := scan.nextInt() ;
    var mat : Sequence(String) ; mat := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     mat[i+1] := StringLib.newString(scan.nextLine()) )  ;     i := i + 1 ) ; 
    var first : int ; first := 2147483647 ;
    var last : int ; last := -2147483648 ;
    var firstRow : int ; firstRow := 2147483647 ;
    var lastRow : int ; lastRow := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     var tempFirst : int ; tempFirst := mat[i+1]->indexOf("*")-1 ;
     var tempLast : int ; tempLast := mat[i+1]->lastIndexOf("*")-1 ;
     if (tempFirst /= -1) then (     if (tempFirst < first) then (     first := tempFirst ) else skip ; 
     if (tempLast > last) then (     last := tempLast ) else skip ; 
     if (i < firstRow) then (     firstRow := i ) else skip ; 
     if (i > lastRow) then (     lastRow := i ) else skip ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i >= firstRow & i <= lastRow) then (     OclFile["System.out"].println(mat[i+1].subrange(first+1,last + 1)) ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Hackerrank {
  public static void main(String[] args){
    Scanner sc1=new Scanner(System.in);
    int n=8 ;
    boolean ans=true ;
    for(int i=0 ; i<n ; i++){
      String str=sc1.next();
      char arr[]=str.toCharArray();
      int W=0 ;
      int B=0 ;
      char prev='\0' ;
      for(char item : arr){
        if(item==prev){
          ans=false ;
        }
        if(item=='W'){
          W++;
        }
        else {
          B++;
        }
        prev=item ;
      }
      if(W!=4 || B!=4){
        ans=false ;
      }
    }
    if(ans){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hackerrank {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc1 : OclFile ; sc1 := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := 8 ;
    var ans : boolean ; ans := true ;
        var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := sc1.getCurrent() ;
     var arr : Sequence(String) ; arr := str->characters() ;
    var W : int ; W := 0 ;
    var B : int ; B := 0 ;
    var prev : String ; prev := '\0' ;
    for (item : arr) do ( (     if (item = prev) then (     ans := false ) else skip ; 
     if (item = 'W') then (     W := W + 1 ) else (     B := B + 1 ) ;  
     prev := item )  ) ; 
    if (W /= 4 or B /= 4) then (     ans := false ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (ans) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int sx=100,ex=-100,sy=100,ey=-100 ;
    String[] a=new String[n];
    for(int i=0 ; i<n ; i++)a[i]=in.next();
    for(int i=0 ; i<n ; i++){
      char[] b=a[i] .toCharArray();
      int c=m+1 ;
      for(int j=0 ; j<m ; j++){
        if(b[j]=='*'){
          sx=Math.min(sx,i);
          sy=Math.min(sy,j);
          ex=Math.max(ex,i);
          ey=Math.max(ey,j);
        }
      }
    }
    for(int i=sx ; i<=ex ; i++){
      char[] b=a[i] .toCharArray();
      for(int j=sy ; j<=ey+1 ; j++){
        System.out.printf("%c",j==ey+1 ? '\n' : b[j]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var sx : int ; sx := 100 ;
    var ex : int ; ex := -100 ;
    var sy : int ; sy := 100 ;
    var ey : int ; ey := -100 ;
    var a : Sequence(String) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var b : Sequence(String) ; b := a[i+1]->characters() ;
     var c : int ; c := m + 1 ;
         var j : int ; j := 0 ; while j < m do ( (     if (b[j+1] = '*') then (     sx := Set{sx, i}->min() ; 
     sy := Set{sy, j}->min() ; 
     ex := Set{ex, i}->max() ; 
     ey := Set{ey, j}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := sx ; while i <= ex do ( (     var b : Sequence(String) ; b := a[i+1]->characters() ;
         var j : int ; j := sy ; while j <= ey + 1 do ( (     OclFile["System.out"].printf("%c", if j = ey + 1 then '
' else b[j+1] endif) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  static Scanner sc=new Scanner(System.in);
  static void output(){
    int n=sc.nextInt();
    int m=sc.nextInt();
    String[] a=new String[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.next();
    int sr=0 ;
    int er=0 ;
    for(int i=0 ; i<n ; i++)if(a[i] .indexOf("*")>=0){
      sr=i ;
      break ;
    }
    for(int i=n-1 ; i>=0 ; i--)if(a[i] .indexOf("*")>=0){
      er=i ;
      break ;
    }
    int sc=m-1,ec=0 ;
    for(int i=sr ; i<er+1 ; i++){
      int f=a[i] .indexOf("*");
      int l=a[i] .lastIndexOf("*");
      if(f>=0)sc=Integer.min(f,sc);
      ec=Integer.max(l,ec);
    }
    for(int i=sr ; i<er+1 ; i++)System.out.println(a[i] .substring(sc,ec+1));
  }
  public static void main(String[] args){
    int t=1 ;
    for(int i=1 ; i<=t ; i++){
      output();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation output() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(String) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent() ;  ;     i := i + 1 ) ; 
    var sr : int ; sr := 0 ;
    var er : int ; er := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (a[i+1]->indexOf("*")-1 >= 0) then (     sr := i ; 
     break ) else skip ;  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do (     if (a[i+1]->indexOf("*")-1 >= 0) then (     er := i ; 
     break ) else skip ;  ;     i := i - 1 ) ; 
    var sc : int ; sc := m - 1 ;
    var ec : int ; ec := 0 ;
        var i : int ; i := sr ; while i < er + 1 do ( (     var f : int ; f := a[i+1]->indexOf("*")-1 ;
     var l : int ; l := a[i+1]->lastIndexOf("*")-1 ;
     if (f >= 0) then     sc := Set{f, sc}->min() ; else skip ; 
     ec := Set{l, ec}->max() )  ;     i := i + 1 ) ; 
        var i : int ; i := sr ; while i < er + 1 do (     OclFile["System.out"].println(a[i+1].subrange(sc+1,ec + 1)) ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
         var i : int ; i := 1 ; while i <= t do ( (     execute output() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Letter {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int M=scan.nextInt();
    scan.nextLine();
    char[][] A=new char[N][M];
    for(int i=0 ; i<N ; i++){
      String S=scan.nextLine();
      for(int j=0 ; j<M ; j++){
        A[i][j]=S.charAt(j);
      }
    }
    int x_min=N-1 ;
    int y_min=M-1 ;
    int x_max=0,y_max=0 ;
    for(int x=0 ; x<N ; x++){
      for(int y=0 ; y<M ; y++){
        if(A[x][y]=='*'){
          x_min=Math.min(x_min,x);
          if(y<y_min){
            y_min=y ;
          }
          x_max=Math.max(x_max,x);
          y_max=Math.max(y_max,y);
        }
      }
    }
    for(int i=x_min ; i<=x_max ; i++){
      for(int j=y_min ; j<=y_max ; j++){
        System.out.print(A[i][j]);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Letter {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var M : int ; M := scan.getCurrent()->toInteger() ;
    skip ; 
    var A : Sequence(Sequence(String)) ; A := Integer.subrange(1,N)->collect(Integer.subrange(1,M)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     var S : String ; S := scan.nextLine() ;
         var j : int ; j := 0 ; while j < M do ( (     A[i+1][j+1] := S->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var x_min : int ; x_min := N - 1 ;
    var y_min : int ; y_min := M - 1 ;
    var x_max : int ; x_max := 0 ;
    var y_max : int ; y_max := 0 ;
        var x : int ; x := 0 ; while x < N do ( (         var y : int ; y := 0 ; while y < M do ( (     if (A[x+1][y+1] = '*') then (     x_min := Set{x_min, x}->min() ; 
     if (y < y_min) then (     y_min := y ) else skip ; 
     x_max := Set{x_max, x}->max() ; 
     y_max := Set{y_max, y}->max() ) else skip )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
        var i : int ; i := x_min ; while i <= x_max do ( (         var j : int ; j := y_min ; while j <= y_max do ( (     OclFile["System.out"].print(A[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int check_digits(int n){
    while(n!=0){
      if((n % 10)% 2!=0)return 0 ;
      n/=10 ;
    }
    return 1 ;
  }
  static int smallest_number(int n){
    for(int i=n ; ; i++)if(check_digits(i)!=0)return i ;
  }
  public static void main(String[] args){
    int N=2397 ;
    System.out.println(smallest_number(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation check_digits( n : int) : int
  pre: true
  post: true
  activity: (     while (n /= 0) do (     if ((n mod 10) mod 2 /= 0) then     return 0 else skip ; 
     n := n/(10) ) ; 
     return 1 );
  static   operation smallest_number( n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := n ; while true do (     if (check_digits(i) /= 0) then     return i else skip ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 2397 ;
     OclFile["System.out"].println(smallest_number(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.Scanner ;
import static java.lang.Math.*;
import java.math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    String[] tmp=in.nextLine().split(" ");
    int n=Integer.parseInt(tmp[0]),m=Integer.parseInt(tmp[1]);
    char[][] map=new char[n][m];
    for(int i=0 ; i<n ; i++)map[i]=in.nextLine().toCharArray();
    int minX=1000,minY=1000,maxY=-1,maxX=-1 ;
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<m ; j++)if(map[i][j]=='*'){
      minX=min(minX,i);
      maxX=max(maxX,i);
      minY=min(minY,j);
      maxY=max(maxY,j);
    }
    for(int i=minX ; i<=maxX ; i++){
      for(int j=minY ; j<=maxY ; j++){
        System.out.print(map[i][j]);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tmp : Sequence(String) ; tmp := in.nextLine()->split(" ") ;
    var n : int ; n := (tmp[0+1])->toInteger() ;
    var m : int ; m := (tmp[1+1])->toInteger() ;
    var map : Sequence(Sequence(String)) ; map := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do (     map[i+1] := in.nextLine()->characters() ;  ;     i := i + 1 ) ; 
    var minX : int ; minX := 1000 ;
    var minY : int ; minY := 1000 ;
    var maxY : int ; maxY := -1 ;
    var maxX : int ; maxX := -1 ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < m do (     if (map[i+1][j+1] = '*') then (     minX := Set{minX, i}->min() ; 
     maxX := Set{maxX, i}->max() ; 
     minY := Set{minY, j}->min() ; 
     maxY := Set{maxY, j}->max() ) else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := minX ; while i <= maxX do ( (         var j : int ; j := minY ; while j <= maxY do ( (     OclFile["System.out"].print(map[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class p007 {
  public static void main(String args[])throws Exception {
    StringTokenizer stok=new StringTokenizer(new Scanner(System.in).useDelimiter("\\A").next());
    StringBuilder sb=new StringBuilder();
    char[] s=new char[(int)1e7];
    long mod=(long)1e9+7 ;
    int T=Integer.parseInt(stok.nextToken());
    while(T-->0){
      int x=Integer.parseInt(stok.nextToken());
      char[] ss=stok.nextToken().toCharArray();
      for(int i=0 ; i<ss.length ; i++)s[i]=ss[i];
      long n=ss.length ;
      boolean fl=true ;
      for(int i=0 ; i<x ; i++){
        int v=s[i]-49,cnt=0 ;
        long d=(n-i-1);
        long nn=(n+v*d)% mod ;
        while(++cnt<=v){
          if(n<=x && fl){
            for(int j=i+1 ; j<=n ; j++)s[j+(int)(cnt*d)]=s[j];
          }
          else fl=false ;
        }
        n=nn ;
      }
      sb.append((n+mod)% mod+"\n");
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p007 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stok : OclIterator ; stok := OclIterator.newOclIterator_String(OclFile.newOclFile_Read(OclFile["System.in"]).useDelimiter("\\A").next()) ;
     var sb : String ; sb := StringLib.newString() ;
    var s : Sequence(String) ; s := Integer.subrange(1,1e7->oclAsType(int))->collect(0) ;
    var mod : long ; mod := 1e9->oclAsType(long) + 7 ;
    var T : int ; T := (stok.next())->toInteger() ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     var x : int ; x := (stok.next())->toInteger() ;
     var ss : Sequence(String) ; ss := stok.next()->characters() ;
        var i : int ; i := 0 ; while i < ss->size() do (     s[i+1] := ss[i+1] ;  ;     i := i + 1 ) ; 
    var n : long ; n := ss->size() ;
    var fl : boolean ; fl := true ;
        var i : int ; i := 0 ; while i < x do ( (     var v : int ; v := s[i+1] - 49 ;
    var cnt : int ; cnt := 0 ;
     var d : long ; d := (n - i - 1) ;
    var nn : long ; nn := (n + v * d) mod mod ;
        cnt := cnt + 1 ;
    while ((cnt + 1) <= v) do (        cnt := cnt + 1 ;     skip ; (     if (n <= x & fl) then (         var j : int ; j := i + 1 ; while j <= n do (     s[j + (cnt * d)->oclAsType(int)+1] := s[j+1] ;  ;     j := j + 1 ) ) else     fl := false ; ) ;     cnt := cnt + 1 ;
 ) ;  
    n := nn ; 
 )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString((n + mod) mod mod + "\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static Scanner in ;
  static PrintWriter out ;
  public static void main(String[] args){
    in=new Scanner(System.in);
    out=new PrintWriter(System.out);
    int t=in.nextInt();
    while(t-->0){
      int x=in.nextInt();
      String s=in.next();
      List<Character>lsb=new ArrayList<>();
      for(Character ch : s.toCharArray()){
        lsb.add(ch);
      }
      long realLen=s.length();
      for(int i=0 ; i<x ; i++){
        long c=lsb.get(i)-'0' ;
        if(lsb.size()<x){
          int start=i+1 ;
          int end=lsb.size()-1 ;
          long add=c-1 ;
          while(lsb.size()<x && add>0){
            for(int j=start ; j<=end && lsb.size()<x ; j++){
              lsb.add(lsb.get(j));
            }
            add--;
          }
        }
        long dt=realLen-i-1 ;
        realLen+=((c-1)*dt);
        realLen %=1_000_000_007l ;
      }
      out.println((realLen+1_000_000_007l)% 1_000_000_007l);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    var t : int ; t := in.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var x : int ; x := in.getCurrent()->toInteger() ;
     var s : String ; s := in.getCurrent() ;
    var lsb : Sequence(String) ; lsb := Sequence{} ;
    for (ch : s->characters()) do ( (     lsb := lsb->including(ch) )  ) ; 
    var realLen : long ; realLen := s->size() ;
        var i : int ; i := 0 ; while i < x do ( (     var c : long ; c := lsb->at(i+1) - ('0')->char2byte() ;
     if (lsb->size() < x) then (     var start : int ; start := i + 1 ;
     var end : int ; end := lsb->size() - 1 ;
     var add : long ; add := c - 1 ;
     while (lsb->size() < x & add > 0) do (         var j : int ; j := start ; while j <= end & lsb->size() < x do ( (     lsb := lsb->including(lsb->at(j+1)) )  ;     j := j + 1 ) ; 
     add := add - 1 ) ) else skip ; 
    var dt : long ; dt := realLen - i - 1 ;
    realLen := realLen+(((c - 1) * dt)) ; 
    realLen := realLen mod 1_000_000_007l ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int w=scanner.nextInt();
      int q=scanner.nextInt();
      if((w | q)==0)break ;
      int[] map=new int[w];
      Arrays.fill(map,-1);
      loop : while(q-->0){
        char c=scanner.next().charAt(0);
        if(c=='s'){
          int id=scanner.nextInt();
          int n=scanner.nextInt();
          int cnt=0 ;
          for(int i=0 ; i<w ; i++){
            if(map[i]==-1){
              cnt++;
              if(cnt==n){
                for(int j=i-n+1 ; j<=i ; j++){
                  map[j]=id ;
                }
                System.out.println(i-cnt+1);
                continue loop ;
              }
            }
            else cnt=0 ;
          }
          System.out.println("impossible");
        }
        else {
          int id=scanner.nextInt();
          for(int i=0 ; i<w ; i++){
            if(map[i]==id)for(int j=i ;
            j<w ;
            j++){
              if(map[j]==id)map[j]=-1 ;
              else break ;
            }
          }
        }
      }
      System.out.println("END");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var w : int ; w := scanner.getCurrent()->toInteger() ;
     var q : int ; q := scanner.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(w,q)) = 0) then     break else skip ; 
    var map : Sequence(int) ; map := Integer.subrange(1,w)->collect(0) ;
    map := map->collect(-1) ; 
        while (q > 0) do (        q := q - 1 ;     skip ; (     var c : String ; c := scanner.getCurrent()->at(0+1) ;
     if (c = 's') then (     var id : int ; id := scanner.getCurrent()->toInteger() ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < w do ( (     if (map[i+1] = -1) then (     cnt := cnt + 1 ; 
     if (cnt = n) then (         var j : int ; j := i - n + 1 ; while j <= i do ( (     map[j+1] := id )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(i - cnt + 1) ; 
     continue ) else skip ) else     cnt := 0 ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("impossible") ; 
 ) else (     var id : int ; id := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < w do ( (     if (map[i+1] = id) then         var j : int ; j := i ; while j < w do ( (     if (map[j+1] = id) then     map[j+1] := -1 ; else     break )  ;     j := j + 1 ) ; else skip )  ;     i := i + 1 ) ) ) ;  ) ;  
    OclFile["System.out"].println("END") ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      while(true){
        String[] line=br.readLine().split(" ");
        int w=Integer.parseInt(line[0]),q=Integer.parseInt(line[1]);
        if(w==0 && q==0){
          br.close();
          break ;
        }
        int[] f=new int[w];
        for(int i=0 ; i<w ; i++){
          f[i]=w-i ;
        }
        for(int i=0 ; i<q ; i++){
          line=br.readLine().split(" ");
          char c=line[0] .charAt(0);
          switch(c){
            case 's' : {
              int id=Integer.parseInt(line[1]);
              int width=Integer.parseInt(line[2]);
              boolean ok=false ;
              for(int j=0 ; j<w ; j++){
                if(f[j]>=width){
                  for(int k=0 ; k<width ; k++){
                    f[j+k]=-id ;
                  }
                  ok=true ;
                  System.out.println(j);
                  break ;
                }
              }
              if(! ok)System.out.println("impossible");
              break ;
            }
            case 'w' : {
              int id=Integer.parseInt(line[1]);
              int p=w-1 ;
              while(f[p]!=-id)p--;
              if(p==w-1){
                f[p]=1 ;
                p--;
              }
              while(p>=0 &&(f[p]==-id || f[p]>0)){
                f[p]=(f[p+1]<0)? 1 : f[p+1]+1 ;
                p--;
              }
            }
          }
        }
        System.out.println("END");
      }
      br.close();
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
     var w : int ; w := (line[0+1])->toInteger() ;
    var q : int ; q := (line[1+1])->toInteger() ;
    if (w = 0 & q = 0) then (     skip ; 
     break ) else skip ; 
    var f : Sequence(int) ; f := Integer.subrange(1,w)->collect(0) ;
        var i : int ; i := 0 ; while i < w do ( (     f[i+1] := w - i )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     line := br.readLine()->split(" ") ; 
     var c : String ; c := line[0+1]->at(0+1) ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
       if _switchval = 's' then
 (     var id : int ; id := (line[1+1])->toInteger() ;
     var width : int ; width := (line[2+1])->toInteger() ;
    var ok : boolean ; ok := false ;
        var j : int ; j := 0 ; while j < w do ( (     if (f[j+1] >= width) then (         var k : int ; k := 0 ; while k < width do ( (     f[j + k+1] := -id )  ;     k := k + 1 ) ; 
     ok := true ; 
     OclFile["System.out"].println(j) ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (not(ok)) then     OclFile["System.out"].println("impossible") ; else skip ; 
    break 
 ) 
   else skip ;
       if _switchval = 'w' then
 (     var id : int ; id := (line[1+1])->toInteger() ;
     var p : int ; p := w - 1 ;
    while (f[p+1] /= -id) do     p := p - 1 ; ; 
    if (p = w - 1) then (     f[p+1] := 1 ; 
     p := p - 1 ) else skip ; 
    while (p >= 0 & (f[p+1] = -id or f[p+1] > 0)) do (     f[p+1] := if (f[p + 1+1] < 0) then 1 else f[p + 1+1] + 1 endif ; 
     p := p - 1 ) ; 
 ) 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("END") ; 
 ) ; 
     skip )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
class Main {
  static final int NONE=Integer.MIN_VALUE ;
  public static void main(final String[] args){
    final Scanner stdin=new Scanner(System.in);
    while(true){
      final int W=stdin.nextInt();
      final int Q=stdin.nextInt();
      if(W==0 && Q==0){
        break ;
      }
      final int[] ar=new int[W];
      Arrays.fill(ar,NONE);
      for(int i=0 ; i<Q ; i++){
        final String word=stdin.next();
        final int id=stdin.nextInt();
        if("s".equals(word)){
          final int w=stdin.nextInt();
          final int index=find(ar,id,w);
          if(index<0){
            System.out.println("impossible");
          }
          else {
            System.out.println(index);
          }
        }
        else {
          remove(ar,id);
        }
      }
      System.out.println("END");
    }
  }
  static int find(final int[] array,final int id,final int w){
    int count=0 ;
    for(int i=0 ; i<array.length ; i++){
      if(array[i]==NONE){
        count++;
        if(count==w){
          Arrays.fill(array,i-w+1,i+1,id);
          return i-w+1 ;
        }
      }
      else {
        count=0 ;
      }
    }
    return-1 ;
  }
  static void remove(final int[] array,final int id){
    for(int i=0 ; i<array.length ; i++){
      if(array[i]==id){
        array[i]=NONE ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute NONE : int := -2147483648;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var W : int ; W := stdin.getCurrent()->toInteger() ;
     var Q : int ; Q := stdin.getCurrent()->toInteger() ;
    if (W = 0 & Q = 0) then (     break ) else skip ; 
    var ar : Sequence(int) ; ar := Integer.subrange(1,W)->collect(0) ;
    ar := ar->collect(NONE) ; 
        var i : int ; i := 0 ; while i < Q do ( (     var word : String ; word := stdin.getCurrent() ;
     var id : int ; id := stdin.getCurrent()->toInteger() ;
     if ("s" = word) then (     var w : int ; w := stdin.getCurrent()->toInteger() ;
     var index : int ; index := find(ar, id, w) ;
     if (index < 0) then (     OclFile["System.out"].println("impossible") ) else (     OclFile["System.out"].println(index) ) ) else (     execute remove(ar, id) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("END") ; 
 ) );
  static   operation find( array : Sequence(int), id : int, w : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < array->size() do ( (     if (array[i+1] = NONE) then (     count := count + 1 ; 
     if (count = w) then (     array := array->collect(id) ; 
     return i - w + 1 ) else skip ) else (     count := 0 ) )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation remove( array : Sequence(int), id : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < array->size() do ( (     if (array[i+1] = id) then (     array[i+1] := NONE ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int w,q ;
    int a[];
    int sleepAt ;
    w=sc.nextInt();
    q=sc.nextInt();
    while(w+q!=0){
      a=new int[w];
      for(int i=0 ; i<w ; i++){
        a[i]=-1 ;
      }
      for(int i=0 ; i<q ; i++){
        int name,size ;
        char c=sc.next().charAt(0);
        if(c=='s'){
          name=sc.nextInt();
          size=sc.nextInt();
          sleepAt=sleep(a,w,name,size);
          if(sleepAt!=-1){
            System.out.println(sleepAt);
          }
          else {
            System.out.println("impossible");
          }
        }
        else if(c=='w'){
          name=sc.nextInt();
          wakeup(a,w,name);
        }
      }
      System.out.println("END");
      w=sc.nextInt();
      q=sc.nextInt();
    }
  }
  public static int sleep(int a[],int w,int name,int size){
    boolean flag=true ;
    ;
    for(int i=0 ; i<w-size+1 ; i++){
      flag=true ;
      for(int j=i ; j<i+size ; j++){
        if(a[j]!=-1){
          flag=false ;
          break ;
        }
      }
      if(flag){
        for(int j=i ; j<i+size ; j++){
          a[j]=name ;
        }
        return i ;
      }
    }
    return-1 ;
  }
  public static void wakeup(int a[],int w,int name){
    for(int i=0 ; i<w ; i++){
      if(a[i]==name){
        a[i]=-1 ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ;
    var q : int ;
    var a : Sequence(int) ;
    var sleepAt : int ;
    w := sc.getCurrent()->toInteger() ; 
    q := sc.getCurrent()->toInteger() ; 
    while (w + q /= 0) do (     a := Integer.subrange(1,w)->collect(0) ; 
         var i : int ; i := 0 ; while i < w do ( (     a[i+1] := -1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var name : int ;
    var size : int ;
     var c : String ; c := sc.getCurrent()->at(0+1) ;
     if (c = 's') then (     name := sc.getCurrent()->toInteger() ; 
     size := sc.getCurrent()->toInteger() ; 
     sleepAt := sleep(a, w, name, size) ; 
     if (sleepAt /= -1) then (     OclFile["System.out"].println(sleepAt) ) else (     OclFile["System.out"].println("impossible") ) ) else     if (c = 'w') then (     name := sc.getCurrent()->toInteger() ; 
     execute wakeup(a, w, name) ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("END") ; 
    w := sc.getCurrent()->toInteger() ; 
    q := sc.getCurrent()->toInteger() ; 
 ) ; 
 );
  static   operation sleep( a : Sequence(int), w : int, name : int, size : int) : int
  pre: true
  post: true
  activity: (     var flag : boolean ; flag := true ;
         var i : int ; i := 0 ; while i < w - size + 1 do ( (     flag := true ; 
         var j : int ; j := i ; while j < i + size do ( (     if (a[j+1] /= -1) then (     flag := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (flag) then (         var j : int ; j := i ; while j < i + size do ( (     a[j+1] := name )  ;     j := j + 1 ) ; 
     return i ) else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation wakeup( a : Sequence(int), w : int, name : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < w do ( (     if (a[i+1] = name) then (     a[i+1] := -1 ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class258 {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long a=sc.nextLong();
      long b=sc.nextLong();
      if(b>a){
        if(b % 2!=0){
          System.out.println(-1);
        }
        else {
          int flag=0 ;
          int c=0 ;
          while(true){
            c++;
            long rem=b-a ;
            a=a*2 ;
            if(a==b){
              break ;
            }
            if(a>b){
              flag=1 ;
              break ;
            }
          }
          if(flag==1){
            System.out.println(-1);
          }
          else {
            int r1=c/3 ;
            c=c-r1*3 ;
            int r2=c/2 ;
            c=c-r2*2 ;
            int ans=r1+r2+c ;
            System.out.println(ans);
          }
        }
      }
      else if(b<a){
        int flag=0 ;
        int c=0 ;
        if(a % 2==0){
          while(true){
            c++;
            if(a % 2!=0){
              flag=1 ;
              break ;
            }
            a=a/2 ;
            if(a==b){
              break ;
            }
            if(a<b){
              flag=1 ;
              break ;
            }
          }
          if(flag==1){
            System.out.println(-1);
          }
          else {
            int r1=c/3 ;
            c=c-r1*3 ;
            int r2=c/2 ;
            c=c-r2*2 ;
            int ans=r1+r2+c ;
            System.out.println(ans);
          }
        }
        else {
          System.out.println(-1);
        }
      }
      else {
        System.out.println(0);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class258 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
     if (b > a) then (     if (b mod 2 /= 0) then (     OclFile["System.out"].println(-1) ) else (     var flag : int ; flag := 0 ;
     var c : int ; c := 0 ;
     while (true) do (     c := c + 1 ; 
     var rem : long ; rem := b - a ;
    a := a * 2 ; 
    if (a = b) then (     break ) else skip ; 
    if (a > b) then (     flag := 1 ; 
     break ) else skip ; 
 ) ; 
     if (flag = 1) then (     OclFile["System.out"].println(-1) ) else (     var r1 : int ; r1 := c / 3 ;
     c := c - r1 * 3 ; 
    var r2 : int ; r2 := c / 2 ;
    c := c - r2 * 2 ; 
    var ans : int ; ans := r1 + r2 + c ;
    OclFile["System.out"].println(ans) ; 
 ) ) ) else     if (b < a) then (     var flag : int ; flag := 0 ;
     var c : int ; c := 0 ;
     if (a mod 2 = 0) then (     while (true) do (     c := c + 1 ; 
     if (a mod 2 /= 0) then (     flag := 1 ; 
     break ) else skip ; 
    a := a / 2 ; 
    if (a = b) then (     break ) else skip ; 
    if (a < b) then (     flag := 1 ; 
     break ) else skip ; 
 ) ; 
     if (flag = 1) then (     OclFile["System.out"].println(-1) ) else (     var r1 : int ; r1 := c / 3 ;
     c := c - r1 * 3 ; 
    var r2 : int ; r2 := c / 2 ;
    c := c - r2 * 2 ; 
    var ans : int ; ans := r1 + r2 + c ;
    OclFile["System.out"].println(ans) ; 
 ) ) else (     OclFile["System.out"].println(-1) ) ) else (     OclFile["System.out"].println(0) ) ;  ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args)throws Exception {
    while(true){
      int W=sc.nextInt();
      int Q=sc.nextInt();
      if(W==0 && Q==0)break ;
      int[] wall=new int[W];
      Arrays.fill(wall,-1);
      for(int i=0 ; i<Q ; ++i){
        String q=sc.next();
        int id=sc.nextInt();
        if(q.equals("s")){
          int width=sc.nextInt();
          int pos=-1 ;
          for(int j=0 ; j<=W-width ; ++j){
            boolean ok=true ;
            for(int k=0 ; k<width ; ++k){
              if(wall[j+k]!=-1){
                ok=false ;
                break ;
              }
            }
            if(ok){
              pos=j ;
              for(int k=0 ; k<width ; ++k){
                wall[j+k]=id ;
              }
              break ;
            }
          }
          System.out.println(pos==-1 ? "impossible" : pos);
        }
        else {
          for(int j=0 ; j<W ; ++j){
            if(wall[j]==id)wall[j]=-1 ;
          }
        }
      }
      System.out.println("END");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var W : int ; W := sc.getCurrent()->toInteger() ;
     var Q : int ; Q := sc.getCurrent()->toInteger() ;
    if (W = 0 & Q = 0) then     break else skip ; 
    var wall : Sequence(int) ; wall := Integer.subrange(1,W)->collect(0) ;
    wall := wall->collect(-1) ; 
        var i : int ; i := 0 ; while i < Q do ( (     var q : String ; q := sc.getCurrent() ;
     var id : int ; id := sc.getCurrent()->toInteger() ;
     if (q = "s") then (     var width : int ; width := sc.getCurrent()->toInteger() ;
     var pos : int ; pos := -1 ;
         var j : int ; j := 0 ; while j <= W - width do ( (     var ok : boolean ; ok := true ;
         var k : int ; k := 0 ; while k < width do ( (     if (wall[j + k+1] /= -1) then (     ok := false ; 
     break ) else skip )  ;     k := k + 1 ) ; 
     if (ok) then (     pos := j ; 
         var k : int ; k := 0 ; while k < width do ( (     wall[j + k+1] := id )  ;     k := k + 1 ) ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(if pos = -1 then "impossible" else pos endif) ) else (         var j : int ; j := 0 ; while j < W do ( (     if (wall[j+1] = id) then     wall[j+1] := -1 ; else skip )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("END") ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findMaxNum(int arr[],int n){
    int[] hash=new int[10];
    for(int i=0 ; i<n ; i++){
      hash[arr[i] ]++;
    }
    for(int i=9 ; i>=0 ; i--){
      for(int j=0 ; j<hash[i]; j++)System.out.print(i);
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,0 };
      int n=arr.length ;
      findMaxNum(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMaxNum( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var hash : Sequence(int) ; hash := Integer.subrange(1,10)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     hash[arr[i+1]+1] := hash[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
         var i : int ; i := 9 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < hash[i+1] do (     OclFile["System.out"].print(i) ;  ;     j := j + 1 ) )  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,0} ;
     var n : int ; n := arr->size() ;
     execute findMaxNum(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void triangular_series(int n){
    int i,j=1,k=1 ;
    for(i=1 ; i<=n ; i++){
      System.out.printf("%d ",k);
      j=j+1 ;
      k=k+j ;
    }
  }
  public static void main(String[] args){
    int n=5 ;
    triangular_series(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation triangular_series( n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ; j := 1 ;
    var k : int ; k := 1 ;
         i := 1 ; while i <= n do ( (     OclFile["System.out"].printf("%d ", k) ; 
     j := j + 1 ; 
     k := k + j )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute triangular_series(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int[][] graph ;
  int[][] weight ;
  int maxValue,maxCnt ;
  int N ;
  boolean[] visited ;
  static final int MOD=10007 ;
  void run(){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      N=in.nextInt();
      if(N==0)return ;
      graph=new int[N][2];
      weight=new int[N][2];
      visited=new boolean[N];
      for(int i=0 ; i<N ; i++){
        for(int j=0 ; j<2 ; j++){
          int x=Integer.parseInt(in.next()),fx=Integer.parseInt(in.next());
          graph[i][j]=x ;
          weight[i][j]=fx ;
        }
      }
      System.out.println(solve());
    }
  }
  int solve(){
    int ret=1 ;
    for(int i=0 ; i<N ; i++)if(! visited[i]){
      maxValue=weight[i][1];
      maxCnt=1 ;
      dfs(i);
      ret=(ret*(maxCnt % MOD))% MOD ;
    }
    return ret ;
  }
  void dfs(int v){
    for(; ; ){
      visited[v]=true ;
      boolean end=true ;
      for(int i=0 ; i<2 ; i++){
        if(! visited[graph[v][i] ]){
          if(maxValue<=weight[v][i]){
            if(maxValue==weight[v][i]){
              maxCnt++;
            }
            else {
              maxValue=weight[v][i];
              maxCnt=1 ;
            }
          }
          v=graph[v][i];
          end=false ;
          break ;
        }
      }
      if(end)return ;
    }
  }
  public static void main(String args[]){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute graph : Sequence(Sequence(int));
   attribute weight : Sequence(Sequence(int));
   attribute maxValue : int;
   attribute N : int;
   attribute visited : Sequence(boolean);
  static    attribute MOD : int := 10007;
   operation run() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     N := in.getCurrent()->toInteger() ; 
     if (N = 0) then     return else skip ; 
    graph := Integer.subrange(1,N)->collect(Integer.subrange(1,2)->collect(0)) ; 
    weight := Integer.subrange(1,N)->collect(Integer.subrange(1,2)->collect(0)) ; 
    visited := Integer.subrange(1,N)->collect(false) ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < 2 do ( (     var x : int ; x := (in.getCurrent())->toInteger() ;
    var fx : int ; fx := (in.getCurrent())->toInteger() ;
     graph[i+1][j+1] := x ; 
     weight[i+1][j+1] := fx )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve()) ; 
 )  ) );
   operation solve() : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 1 ;
         var i : int ; i := 0 ; while i < N do (     if (not(visited[i+1])) then (     maxValue := weight[i+1][1+1] ; 
     maxCnt := 1 ; 
     execute dfs(i) ; 
     ret := (ret * (maxCnt mod MOD)) mod MOD ) else skip ;  ;     i := i + 1 ) ; 
     return ret );
   operation dfs( v : int) : void
  pre: true
  post: true
  activity: (       while true do ( (     visited[v+1] := true ; 
     var end : boolean ; end := true ;
         var i : int ; i := 0 ; while i < 2 do ( (     if (not(visited[graph[v+1][i+1]+1])) then (     if (maxValue <= weight[v+1][i+1]) then (     if (maxValue = weight[v+1][i+1]) then (     maxCnt := maxCnt + 1 ) else (     maxValue := weight[v+1][i+1] ; 
     maxCnt := 1 ) ) else skip ; 
     v := graph[v+1][i+1] ; 
     end := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (end) then     return else skip )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  int n,MOD=10007 ;
  int[][] e,f ;
  boolean[] v ;
  int bfs(int s){
    v[s]=true ;
    int max=-1,c=0 ;
    Queue<Integer>q=new LinkedList<Integer>();
    q.add(s);
    while(! q.isEmpty()){
      int p=q.poll();
      for(int i=0 ; i<2 ; i++){
        if(max<f[p][i]){
          max=f[p][i];
          c=1 ;
        }
        else if(max==f[p][i])c++;
        if(! v[e[p][i] ]){
          v[e[p][i] ]=true ;
          q.add(e[p][i]);
        }
      }
    }
    return(c/2)% MOD ;
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      n=sc.nextInt();
      if(n==0)break ;
      e=new int[n][2];
      f=new int[n][2];
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<2 ; j++){
        e[i][j]=sc.nextInt();
        f[i][j]=sc.nextInt();
      }
      v=new boolean[n];
      int res=1 ;
      for(int i=0 ; i<n ; i++)if(! v[i])res=(res*bfs(i))% MOD ;
      System.out.println(res);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute e : Sequence(Sequence(int));
   attribute v : Sequence(boolean);
   operation bfs( s : int) : int
  pre: true
  post: true
  activity: (     v[s+1] := true ; 
     var max : int ; max := -1 ;
    var c : int ; c := 0 ;
    var q : Sequence(int) ; q := Sequence{} ;
    q := q->including(s) ; 
    while (not(q->isEmpty())) do (     var p : int ; p := q->min() ;
         var i : int ; i := 0 ; while i < 2 do ( (     if (max < f[p+1][i+1]) then (     max := f[p+1][i+1] ; 
     c := 1 ) else     if (max = f[p+1][i+1]) then     c := c + 1 ; else skip ; ;  
     if (not(v[e[p+1][i+1]+1])) then (     v[e[p+1][i+1]+1] := true ; 
     q := q->including(e[p+1][i+1]) ) else skip )  ;     i := i + 1 ) ) ; 
    return (c / 2) mod MOD 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
    e := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ; 
    f := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ; 
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < 2 do ( (     e[i+1][j+1] := sc.getCurrent()->toInteger() ; 
     f[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    v := Integer.subrange(1,n)->collect(false) ; 
    var res : int ; res := 1 ;
        var i : int ; i := 0 ; while i < n do (     if (not(v[i+1])) then     res := (res * bfs(i)) mod MOD ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static final int MOD=10007 ;
  public static void main(String[] args){
    while(true){
      int N=sc.nextInt();
      if(N==0)break ;
      Path[][] path=new Path[N][2];
      for(int i=0 ; i<N ; ++i){
        int p=sc.nextInt();
        int v=sc.nextInt();
        path[i][0]=new Path(i,p,v);
        p=sc.nextInt();
        v=sc.nextInt();
        path[i][1]=new Path(i,p,v);
      }
      boolean[] visited=new boolean[N];
      int ans=1 ;
      for(int i=0 ; i<N ; ++i){
        if(visited[i])continue ;
        Path cur=path[i][0];
        visited[i]=true ;
        int max=cur.val ;
        int maxC=1 ;
        int size=1 ;
        while(true){
          if(visited[cur.to])break ;
          visited[cur.to]=true ;
++size ;
          if(path[cur.to][0] .to==cur.from){
            cur=path[cur.to][1];
          }
          else {
            cur=path[cur.to][0];
          }
          if(cur.val>max){
            max=cur.val ;
            maxC=1 ;
          }
          else if(cur.val==max){
++maxC ;
          }
        }
        ans*=maxC ;
        ans %=MOD ;
      }
      System.out.println(ans);
    }
  }
  static class Path {
    int from ;
    int to ;
    int val ;
    Path(int from,int to,int val){
      this.from=from ;
      this.to=to ;
      this.val=val ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute MOD : int := 10007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then     break else skip ; 
    var path : Sequence(Sequence(String)) ; path := Integer.subrange(1,N)->collect(Integer.subrange(1,2)->collect(null)) ;
        var i : int ; i := 0 ; while i < N do ( (     var p : int ; p := sc.getCurrent()->toInteger() ;
     var v : int ; v := sc.getCurrent()->toInteger() ;
    path[i+1][0+1] := String(i, p, v) ; 
    p := sc.getCurrent()->toInteger() ; 
    v := sc.getCurrent()->toInteger() ; 
    path[i+1][1+1] := String(i, p, v) ; 
 )  ;     i := i + 1 ) ; 
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,N)->collect(false) ;
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < N do ( (     if (visited[i+1]) then     continue else skip ; 
     var cur : String ; cur := path[i+1][0+1] ;
    visited[i+1] := true ; 
    var max : int ; max := cur.val ;
    var maxC : int ; maxC := 1 ;
    var size : int ; size := 1 ;
    while (true) do (     if (visited[cur.to+1]) then     break else skip ; 
     visited[cur.to+1] := true ; 
    size := size + 1 ; 
    if (path[cur.to+1][0+1].to = cur.from) then (     cur := path[cur.to+1][1+1] ) else (     cur := path[cur.to+1][0+1] ) ;  
    if (cur.val > max) then (     max := cur.val ; 
     maxC := 1 ) else     if (cur.val = max) then (     maxC := maxC + 1 ) else skip ; ;  
 ) ; 
    ans := ans*(maxC) ; 
    ans := ans mod MOD ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
  static class Path {
   attribute from : int;
   attribute to : int;
   attribute val : int;
   static operation newPath( from : int, to : int, val : int) : Path
  pre: true
  post: true
  activity:
  ( var self : Path ;
    self := createPath();
    self.initialise(from, to,val);
    return self );
  operation initialise( from : int, to : int, val : int) : void
  pre: true  post: true
  activity: (     self.from := from ; 
     self.to := to ; 
     self.val := val );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedWriter ;
import java.io.File ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.util.Scanner ;
public class D {
  static final String FILENAME="D-large" ;
  static final String IN=FILENAME+".in" ;
  static final String OUT=FILENAME+".out" ;
  Scanner sc ;
  BufferedWriter out ;
  private void solve()throws IOException {
    int x=sc.nextInt();
    int r=sc.nextInt();
    int c=sc.nextInt();
    if(x>=7 || x>Math.max(r,c)||(x+1)/2>Math.min(r,c)||(r*c)% x!=0 ||((x+1)/2==Math.min(r,c)&&(x==4 ||(x==5 && Math.max(r,c)<6)|| x==6))){
      out.write("RICHARD");
    }
    else {
      out.write("GABRIEL");
    }
    out.newLine();
    out.flush();
  }
  private void run()throws IOException {
    sc=new Scanner(new File(IN));
    out=new BufferedWriter(new FileWriter(OUT));
    int t=sc.nextInt();
    for(int i=1 ; i<=t ; i++){
      out.write("Case #"+i+": ");
      solve();
    }
    sc.close();
    out.close();
  }
  public static void main(String args[])throws Exception {
    new D().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static    attribute FILENAME : String := "D-large";
  static    attribute IN : String := FILENAME + ".in";
  static    attribute OUT : String := FILENAME + ".out";
   attribute sc : OclFile;
   attribute out : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    if (x >= 7 or x > Set{r, c}->max() or (x + 1) / 2 > Set{r, c}->min() or (r * c) mod x /= 0 or ((x + 1) / 2 = Set{r, c}->min() & (x = 4 or (x = 5 & Set{r, c}->max() < 6) or x = 6))) then (     skip ) else (     skip ) ;  
    skip ; 
    skip ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile(IN)) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile(OUT))) ; 
    var t : int ; t := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= t do ( (     skip ; 
     execute solve() )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     D.newD().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class D_Large {
  static final Boolean SAMPLE=false ;
  static final String PROBLEM="D" ;
  static final String INPUT="large" ;
  static final String ID="0" ;
  static final String PATH="/Users/wangkai/Documents/codejam-commandline-1.2-beta1/source/" ;
  public static void main(String[] args)throws Throwable {
    Scanner in=SAMPLE ? new Scanner(System.in): new Scanner(new File(PATH+PROBLEM+"-"+INPUT+"-"+ID+".in"));
    PrintStream out=SAMPLE ? System.out : new PrintStream(PATH+PROBLEM+"-"+INPUT+"-"+ID+".out");
    int test=in.nextInt();
    for(int t=1 ; t<=test ; t++){
      out.print("Case #"+t+": ");
      int omino=in.nextInt();
      int row=in.nextInt();
      int col=in.nextInt();
      boolean firstPlayerWin ;
      if(row*col % omino!=0){
        firstPlayerWin=true ;
      }
      else {
        int minSide=Math.min(row,col);
        int maxSide=Math.max(row,col);
        if(omino==1){
          firstPlayerWin=false ;
        }
        else if(omino==2){
          firstPlayerWin=false ;
        }
        else if(omino==3){
          if(minSide==1){
            firstPlayerWin=true ;
          }
          else {
            firstPlayerWin=false ;
          }
        }
        else if(omino==4){
          if(minSide<=2){
            firstPlayerWin=true ;
          }
          else {
            firstPlayerWin=false ;
          }
        }
        else if(omino==5){
          if(minSide<=2){
            firstPlayerWin=true ;
          }
          else if(minSide==3){
            if(maxSide==5){
              firstPlayerWin=true ;
            }
            else {
              firstPlayerWin=false ;
            }
          }
          else {
            firstPlayerWin=false ;
          }
        }
        else if(omino==6){
          if(minSide<=2){
            firstPlayerWin=true ;
          }
          else if(minSide==3){
            firstPlayerWin=true ;
          }
          else {
            firstPlayerWin=false ;
          }
        }
        else {
          firstPlayerWin=true ;
        }
      }
      out.println(firstPlayerWin ? "RICHARD" : "GABRIEL");
    }
    out.close();
    in.close();
    System.out.println("finish!");
  }
}
------------------------------------------------------------
OCL File:
---------
 class D_Large {
  static    attribute SAMPLE : Boolean := false;
  static    attribute PROBLEM : String := "D";
  static    attribute INPUT : String := "large";
  static    attribute ID : String := "0";
  static    attribute PATH : String := "/Users/wangkai/Documents/codejam-commandline-1.2-beta1/source/";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := if SAMPLE then OclFile.newOclFile_Read(OclFile["System.in"]) else OclFile.newOclFile_Read(OclFile(PATH + PROBLEM + "-" + INPUT + "-" + ID + ".in")) endif ;
     var out : OclFile ; out := if SAMPLE then out else OclFile.newOclFile_Write(PATH + PROBLEM + "-" + INPUT + "-" + ID + ".out") endif ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= test do ( (     skip ; 
     var omino : int ; omino := in.getCurrent()->toInteger() ;
    var row : int ; row := in.getCurrent()->toInteger() ;
    var col : int ; col := in.getCurrent()->toInteger() ;
    var firstPlayerWin : boolean ;
    if (row * col mod omino /= 0) then (     firstPlayerWin := true ) else (     var minSide : int ; minSide := Set{row, col}->min() ;
     var maxSide : int ; maxSide := Set{row, col}->max() ;
     if (omino = 1) then (     firstPlayerWin := false ) else     if (omino = 2) then (     firstPlayerWin := false ) else     if (omino = 3) then (     if (minSide = 1) then (     firstPlayerWin := true ) else (     firstPlayerWin := false ) ) else     if (omino = 4) then (     if (minSide <= 2) then (     firstPlayerWin := true ) else (     firstPlayerWin := false ) ) else     if (omino = 5) then (     if (minSide <= 2) then (     firstPlayerWin := true ) else     if (minSide = 3) then (     if (maxSide = 5) then (     firstPlayerWin := true ) else (     firstPlayerWin := false ) ) else (     firstPlayerWin := false ) ;  ) else     if (omino = 6) then (     if (minSide <= 2) then (     firstPlayerWin := true ) else     if (minSide = 3) then (     firstPlayerWin := true ) else (     firstPlayerWin := false ) ;  ) else (     firstPlayerWin := true ) ;  ;  ;  ;  ;  ) ;  
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
    OclFile["System.out"].println("finish!") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package gcj2015.qualif ;
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.logging.Level ;
import java.util.logging.Logger ;
public class ExoD {
  public static void main(final String[] args){
    final String base="/home/jean/gcj2015/q/ExoD/" ;
    final String input=base+"b1.in" ;
    final String output=base+"b1.out" ;
    try {
      final Scanner sc=new Scanner(new FileReader(input));
      final PrintWriter pw=new PrintWriter(output);
      final int n=sc.nextInt();
      sc.nextLine();
      for(int c=0 ; c<n ; c++){
        System.out.println("Test case "+(c+1)+"...");
        pw.print("Case #"+(c+1)+": ");
        test(sc,pw);
        pw.println();
      }
      pw.println();
      pw.flush();
      pw.close();
      sc.close();
    }
    catch(final FileNotFoundException ex){
      Logger.getLogger(ExoD.class.getName()).log(Level.SEVERE,null,ex);
    }
  }
  private static void test(final Scanner sc,final PrintWriter pw){
    final int X=sc.nextInt();
    final int R=sc.nextInt();
    final int C=sc.nextInt();
    if(X>=7 ||(R*C)% X!=0){
      pw.print("RICHARD");
    }
    else {
      if(X==1 || X==2 ||(X==3 &&(R!=1 && C!=1))||(X==4 &&(R>=4 && C>2 || C>=4 && R>2))||(X==5 &&((R>=4 && C>=4)||(R==3 && C>=10 || R>=10 && C==3)))||(X==6 &&(R>=4 && C>=4 &&(R>=6 || C>=6)))){
        pw.print("GABRIEL");
      }
      else {
        pw.print("RICHARD");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ExoD {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var base : String ; base := "/home/jean/gcj2015/q/ExoD/" ;
     var input : String ; input := base + "b1.in" ;
     var output : String ; output := base + "b1.out" ;
     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(input))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile(output)) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
        var c : int ; c := 0 ; while c < n do ( (     OclFile["System.out"].println("Test case " + (c + 1) + "...") ; 
     skip ; 
     execute test(sc, pw) ; 
     skip )  ;     c := c + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 )   catch (ex : FileNotFoundException) do (     Logger.getLogger(OclType["ExoD"].getName()).log(Level.SEVERE, null, ex) )
 );
  static   operation test( sc : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var X : int ; X := sc.getCurrent()->toInteger() ;
     var R : int ; R := sc.getCurrent()->toInteger() ;
     var C : int ; C := sc.getCurrent()->toInteger() ;
     if (X >= 7 or (R * C) mod X /= 0) then (     skip ) else (     if (X = 1 or X = 2 or (X = 3 & (R /= 1 & C /= 1)) or (X = 4 & (R >= 4 & C > 2 or C >= 4 & R > 2)) or (X = 5 & ((R >= 4 & C >= 4) or (R = 3 & C >= 10 or R >= 10 & C = 3))) or (X = 6 & (R >= 4 & C >= 4 & (R >= 6 or C >= 6)))) then (     skip ) else (     skip ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.*;
import java.io.*;
import java.math.*;
import java.util.*;
import java.util.regex.*;
import static java.lang.Math.*;
import static java.lang.System.*;
public class D {
  boolean solve(int caseNum){
    int x=in.nextInt();
    int r=in.nextInt();
    int c=in.nextInt();
    int max=max(r,c);
    int min=min(r,c);
    if(x>=7)return false ;
    if(r*c % x!=0)return false ;
    if(x>max)return false ;
    if(x>min*2)return false ;
    if(x<min*2-1)return true ;
    if(x<=2)return true ;
    if(x==3){
      if(min!=2){
        debug("x==3 && min!=2");
      }
      return true ;
    }
    if(x==4){
      if(min!=2){
        debug("x==4 && min!=2");
      }
      return false ;
    }
    if(x==5){
      if(min!=3){
        debug("x==5 && min!=3");
      }
      return max>5 ;
    }
    if(x==6){
      if(min!=3){
        debug("x==6 && min!=3");
      }
      return false ;
    }
    debug("never reach");
    return true ;
  }
  Scanner in=new Scanner(System.in);
  public D()throws Exception {
    int caseCount=in.nextInt();
    for(int caseNum=1 ; caseNum<=caseCount ; caseNum++){
      out.printf("Case #%d: ",caseNum);
      if(solve(caseNum)){
        out.println("GABRIEL");
      }
      else {
        out.println("RICHARD");
      }
    }
  }
  public static void main(String[] args)throws Exception {
    new D();
  }
  public static void debug(Object...arr){
    System.err.println(Arrays.deepToString(arr));
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
   operation solve( caseNum : int) : boolean
  pre: true
  post: true
  activity: (     var x : int ; x := in.nextInt() ;
     var r : int ; r := in.nextInt() ;
    var c : int ; c := in.nextInt() ;
    var max : int ; max := max(r, c) ;
    var min : int ; min := min(r, c) ;
    if (x >= 7) then     return false else skip ; 
    if (r * c mod x /= 0) then     return false else skip ; 
    if (x > max) then     return false else skip ; 
    if (x > min * 2) then     return false else skip ; 
    if (x < min * 2 - 1) then     return true else skip ; 
    if (x <= 2) then     return true else skip ; 
    if (x = 3) then (     if (min /= 2) then (     execute debug("x==3 && min!=2") ) else skip ; 
     return true ) else skip ; 
    if (x = 4) then (     if (min /= 2) then (     execute debug("x==4 && min!=2") ) else skip ; 
     return false ) else skip ; 
    if (x = 5) then (     if (min /= 3) then (     execute debug("x==5 && min!=3") ) else skip ; 
     return max > 5 ) else skip ; 
    if (x = 6) then (     if (min /= 3) then (     execute debug("x==6 && min!=3") ) else skip ; 
     return false ) else skip ; 
    execute debug("never reach") ; 
    return true 
 );
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   static operation newD() : D
  pre: true
  post: true
  activity:
  ( var self : D ;
    self := createD();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var caseCount : int ; caseCount := in.getCurrent()->toInteger() ;
         var caseNum : int ; caseNum := 1 ; while caseNum <= caseCount do ( (     out.printf("Case #%d: ", caseNum) ; 
     if (solve(caseNum)) then (     out.println("GABRIEL") ) else (     out.println("RICHARD") ) )  ;     caseNum := caseNum + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( D.newD() );
  static   operation debug( arr : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((arr + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JhonnyAndAncientComputer {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long a=sc.nextLong(),b=sc.nextLong(),count=0,x=Math.min(a,b),y=Math.max(a,b);
      while(x<y){
        x*=8 ;
        count++;
      }
      System.out.println(x==y || x/2==y || x/4==y ? count :-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JhonnyAndAncientComputer {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var count : long ; count := 0 ;
    var x : long ; x := Set{a, b}->min() ;
    var y : long ; y := Set{a, b}->max() ;
     while (x < y) do (     x := x*(8) ; 
     count := count + 1 ) ; 
     OclFile["System.out"].println(if x = y or x / 2 = y or x / 4 = y then count else -1 endif) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAX=10000 ;
  static boolean prime[]=new boolean[MAX+1];
  static void SieveOfEratosthenes(){
    int i ;
    for(i=0 ; i<MAX+1 ; i++){
      prime[i]=true ;
    }
    prime[1]=false ;
    for(int p=2 ; p*p<=MAX ; p++){
      if(prime[p]==true){
        for(i=p*2 ; i<=MAX ; i+=p)prime[i]=false ;
      }
    }
  }
  static int xorFirstNPrime(int n){
    int count=0,num=1 ;
    int xorVal=0 ;
    while(count<n){
      if(prime[num]){
        xorVal ^=num ;
        count++;
      }
      num++;
    }
    return xorVal ;
  }
  public static void main(String[] args){
    SieveOfEratosthenes();
    int n=4 ;
    System.out.println(xorFirstNPrime(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 10000;
  static   attribute prime : boolean := Integer.subrange(1,MAX + 1)->collect(false);
  static   operation SieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (     var i : int ;
         i := 0 ; while i < MAX + 1 do ( (     prime[i+1] := true )  ;     i := i + 1 ) ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p <= MAX do ( (     if (prime[p+1] = true) then (         i := p * 2 ; while i <= MAX do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation xorFirstNPrime( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
    var num : int ; num := 1 ;
     var xorVal : int ; xorVal := 0 ;
     while (count < n) do (     if (prime[num+1]) then (     xorVal := MathLib.bitwiseXor(xorVal,num) ; 
     count := count + 1 ) else skip ; 
     num := num + 1 ) ; 
     return xorVal );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes() ; 
     var n : int ; n := 4 ;
     OclFile["System.out"].println(xorFirstNPrime(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class TheBestGift {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int m=Integer.parseInt(str[1]);
    int arr[]=new int[m];
    str=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      arr[Integer.parseInt(str[i])-1]++;
    }
    System.out.println(getNumberOfWays2(arr,n));
  }
  private static long getNumberOfWays1(int[] arr,int n){
    long count=0 ;
    for(int i=0 ; i<arr.length ; i++){
      count=count+(arr[i]*(n-arr[i]));
    }
    return count/2 ;
  }
  static long sumNatual(int n){
    return((long)n*(n+1l))/2 ;
  }
  private static long getNumberOfWays2(int[] arr,int n){
    long t=sumNatual(n);
    for(int x : arr){
      t-=sumNatual(x);
    }
    return t ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class TheBestGift {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var m : int ; m := (str[1+1])->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,m)->collect(0) ;
    str := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[(str[i+1])->toInteger() - 1+1] := arr[(str[i+1])->toInteger() - 1+1] + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(getNumberOfWays2(arr, n)) ; 
 );
  static   operation getNumberOfWays1( arr : Sequence(int), n : int) : long
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     count := count + (arr[i+1] * (n - arr[i+1])) )  ;     i := i + 1 ) ; 
     return count / 2 );
  static   operation sumNatual( n : int) : long
  pre: true
  post: true
  activity: (     return (n->oclAsType(long) * (n + 1l)) / 2 );
  static   operation getNumberOfWays2( arr : Sequence(int), n : int) : long
  pre: true
  post: true
  activity: (     var t : long ; t := sumNatual(n) ;
     for (x : arr) do ( (     t := t-(sumNatual(x)) )  ) ; 
     return t );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int numberOfPaths(int m,int n){
    if(m==1 || n==1)return 1 ;
    return numberOfPaths(m-1,n)+numberOfPaths(m,n-1);
  }
  public static void main(String args[]){
    System.out.println(numberOfPaths(3,3));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation numberOfPaths( m : int, n : int) : int
  pre: true
  post: true
  activity: (     if (m = 1 or n = 1) then     return 1 else skip ; 
     return numberOfPaths(m - 1, n) + numberOfPaths(m, n - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(numberOfPaths(3, 3)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] agrs){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    StringBuilder s=new StringBuilder(in.next());
    int max=0 ;
    for(int i=1 ; i<n ; i++){
      if(i*2-1<n){
        if(s.substring(0,i).equals(s.substring(i,i*2))){
          if(i>max)max=i ;
        }
      }
      else break ;
    }
    if(max>0)System.out.println(n-max+1);
    else System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : String ; s := StringLib.newString(in.getCurrent()) ;
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (i * 2 - 1 < n) then (     if (s.subrange(0+1,i) = s.subrange(i+1,i * 2)) then (     if (i > max) then     max := i ; else skip ) else skip ) else     break )  ;     i := i + 1 ) ; 
    if (max > 0) then     OclFile["System.out"].println(n - (max)->char2byte() + 1) else     OclFile["System.out"].println(n) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class road {
  static int row ;
  static int col ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String str=sc.next();
    int sum=1 ;
    int i=0 ;
    int l=n/2 ;
    for(i=l ; i>=0 ; i--){
      if((str.substring(0,i)).equals(str.substring(i,2*i))){
        sum=i ;
        break ;
      }
    }
    System.out.println(Math.min(n,n-sum+1));
  }
  public static void dfs(boolean b[],int i,ArrayList<ArrayList<Integer>>arr){
    b[i]=true ;
    for(int j : arr.get(i)){
      if(! b[j]){
        dfs(b,j,arr);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class road {
  static   attribute row : int;
  static   attribute col : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var str : String ; str := sc.getCurrent() ;
    var sum : int ; sum := 1 ;
    var i : int ; i := 0 ;
    var l : int ; l := n / 2 ;
        i := l ; while i >= 0 do ( (     if ((str.subrange(0+1,i)) = str.subrange(i+1,2 * i)) then (     sum := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(Set{n, n - (sum)->char2byte() + 1}->min()) ; 
 );
  static   operation dfs( b : Sequence(boolean), i : int, arr : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     b[i+1] := true ; 
     for (j : arr->at(i+1)) do ( (     if (not(b[j+1])) then (     execute dfs(b, j, arr) ) else skip )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class practice {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    int res=n ;
    for(int i=1 ; i<=n/2 ; i++){
      if(s.substring(0,i).equals(s.substring(i,2*i)))res=n-i+1 ;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var res : int ; res := n ;
        var i : int ; i := 1 ; while i <= n / 2 do ( (     if (s.subrange(0+1,i) = s.subrange(i+1,2 * i)) then     res := n - i + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
class GFG {
  static final int MAX_VAL=200000 ;
  static int countIntervals(int[][] arr,int V,int N){
    int min=Integer.MAX_VALUE,max=Integer.MIN_VALUE ;
    int li,ri ;
    int[] freq=new int[MAX_VAL];
    for(int i=0 ; i<N ; i++){
      li=arr[i][0];
      freq[li]=freq[li]+1 ;
      ri=arr[i][1];
      freq[ri+1]=freq[ri+1]-1 ;
      if(li<min)min=li ;
      if(ri>max)max=ri ;
    }
    for(int i=min ; i<=max ; i++)freq[i]=freq[i]+freq[i-1];
    return freq[V];
  }
  public static void main(String args[]){
    int[][] arr={
      {
        1,10 },{
          5,10 },{
            15,25 },{
              7,12 },{
                20,25 }
              };
              int V=7 ;
              int N=arr.length ;
              System.out.println(countIntervals(arr,V,N));
            }
          }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX_VAL : int := 200000;
  static   operation countIntervals( arr : Sequence(Sequence(int)), V : int, N : int) : int
  pre: true
  post: true
  activity: (     var min : int ; min := 2147483647 ;
    var max : int ; max := -2147483648 ;
     var li : int ;
    var ri : int ;
    var freq : Sequence(int) ; freq := Integer.subrange(1,MAX_VAL)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     li := arr[i+1][0+1] ; 
     freq[li+1] := freq[li+1] + 1 ; 
    ri := arr[i+1][1+1] ; 
    freq[ri + 1+1] := freq[ri + 1+1] - 1 ; 
    if (li < min) then     min := li ; else skip ; 
    if (ri > max) then     max := ri ; else skip ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := min ; while i <= max do (     freq[i+1] := freq[i+1] + freq[i - 1+1] ;  ;     i := i + 1 ) ; 
    return freq[V+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,10},Sequence{5,10},Sequence{15,25},Sequence{7,12},Sequence{20,25}} ;
     var V : int ; V := 7 ;
     var N : int ; N := arr->size() ;
     OclFile["System.out"].println(countIntervals(arr, V, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));
    int t=in.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      long a=in.nextLong();
      long b=in.nextLong();
      int res=0,temp=9 ;
      while(temp<=b){
        res++;
        temp=temp*10+9 ;
      }
      pw.println(a*res);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        var tt : int ; tt := 0 ; while tt < t do ( (     var a : long ; a := in.getCurrent()->toLong() ;
     var b : long ; b := in.getCurrent()->toLong() ;
    var res : int ; res := 0 ;
    var temp : int ; temp := 9 ;
    while (temp <= b) do (     res := res + 1 ; 
     temp := temp * 10 + 9 ) ; 
    skip ; 
 )  ;     tt := tt + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.System.out ;
public class pre108 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 boolean only9(String s){
    for(char i : s.toCharArray())if(i!='9')return false ;
    return true ;
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int tc=obj.nextInt();
    while(tc--!=0){
      long a=obj.nextLong(),c=obj.nextLong(),b=c ;
      int count=0 ;
      while(b>0){
        b/=10 ;
        count++;
      }
      if(only9(Long.toString(c)))out.println(a*count);
      else out.println(a*(count-1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre108 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation only9( s : String) : boolean
  pre: true
  post: true
  activity: (     for (i : s->characters()) do (     if (i /= '9') then     return false else skip ;  ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var tc : int ; tc := obj.nextInt() ;
         while (tc /= 0) do (    skip ; (     var a : long ; a := obj.nextLong() ;
    var c : long ; c := obj.nextLong() ;
    var b : long ; b := c ;
     var count : int ; count := 0 ;
     while (b > 0) do (     b := b/(10) ; 
     count := count + 1 ) ; 
     if (only9(((c) + ""))) then     out.println(a * count) ; else     out.println(a * (count - 1)) ; ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B_Yet_Another_Meme_Problem {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int A=sc.nextInt();
      int B=sc.nextInt();
      System.out.println(solve(A,B));
    }
    sc.close();
  }
  static long solve(int A,int B){
    int count=0 ;
    for(long b=9 ; b<=B ; b=b*10+9){
++count ;
    }
    return(long)A*count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Yet_Another_Meme_Problem {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(A, B)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( A : int, B : int) : long
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var b : long ; b := 9 ; while b <= B do ( (     count := count + 1 )  ;     b := b * 10 + 9 ) ; 
     return A->oclAsType(long) * count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int A=sc.nextInt();
      int B=sc.nextInt();
      System.out.println(solve(A,B));
    }
    sc.close();
  }
  static long solve(int A,int B){
    int count=0 ;
    for(long b=9 ; b<=B ; b=b*10+9){
++count ;
    }
    return(long)A*count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(A, B)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( A : int, B : int) : long
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var b : long ; b := 9 ; while b <= B do ( (     count := count + 1 )  ;     b := b * 10 + 9 ) ; 
     return A->oclAsType(long) * count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewClass38 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    int p=1 ;
    while(t-->0){
      int n=in.nextInt();
      int m=in.nextInt();
      if(n==1){
        System.out.println("0");
      }
      else {
        if(n==2){
          System.out.println(m);
        }
        else {
          System.out.println(m*2);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass38 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
     var p : int ; p := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
     if (n = 1) then (     OclFile["System.out"].println("0") ) else (     if (n = 2) then (     OclFile["System.out"].println(m) ) else (     OclFile["System.out"].println(m * 2) ) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  int n ;
  int[] a ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Main m=new Main(sc);
    m.solve();
    sc.close();
  }
  Main(Scanner sc){
    n=sc.nextInt();
    a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
  }
  void solve(){
    int ans=1 ;
    int sign=0 ;
    for(int i=0 ; i<n-1 ; i++){
      switch(sign){
        case 0 : if(a[i]<a[i+1]){
          sign=1 ;
        }
        else if(a[i]>a[i+1]){
          sign=-1 ;
        }
        break ;
        case 1 : if(a[i]>a[i+1]){
          sign=0 ;
          ans++;
        }
        break ;
        case-1 : if(a[i]<a[i+1]){
          sign=0 ;
          ans++;
        }
        break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute a : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : Main ; m := Main.newMain(sc) ;
     m.solve() ; 
     skip );
   static operation newMain( sc : OclFile) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(sc);
    return self );
  operation initialise( sc : OclFile) : void
  pre: true  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
     a := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
     var sign : int ; sign := 0 ;
         var i : int ; i := 0 ; while i < n - 1 do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (sign) ; 
       if _switchval = 0 then
     if (a[i+1] < a[i + 1+1]) then (     sign := 1 ) else     if (a[i+1] > a[i + 1+1]) then (     sign := -1 ) else skip ; ;  
    break 
   else skip ;
       if _switchval = 1 then
     if (a[i+1] > a[i + 1+1]) then (     sign := 0 ; 
     ans := ans + 1 ) else skip ; 
    break 
   else skip ;
       if _switchval = -1 then
     if (a[i+1] < a[i + 1+1]) then (     sign := 0 ; 
     ans := ans + 1 ) else skip ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class BestGift {
  public void bestGift(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] genres=new int[n];
    int[] counts=new int[m];
    for(int i=0 ; i<n ; ++i){
      genres[i]=sc.nextInt();
    }
    for(int j=0 ; j<n ; ++j){
      counts[genres[j]-1]++;
    }
    long res=0 ;
    for(int genreCount : counts){
      res+=(n-genreCount)*genreCount ;
    }
    System.out.println(res/2);
  }
  public static void main(String[] args){
    BestGift bestGift=new BestGift();
    bestGift.bestGift();
  }
}
------------------------------------------------------------
OCL File:
---------
 class BestGift {
   operation bestGift() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var genres : Sequence(int) ; genres := Integer.subrange(1,n)->collect(0) ;
    var counts : Sequence(int) ; counts := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     genres[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     counts[genres[j+1] - 1+1] := counts[genres[j+1] - 1+1] + 1 )  ;     j := j + 1 ) ; 
    var res : long ; res := 0 ;
    for (genreCount : counts) do ( (     res := res+((n - genreCount) * genreCount) )  ) ; 
    OclFile["System.out"].println(res / 2) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bestGift : BestGift ; bestGift := BestGift.newBestGift() ;
     bestGift.bestGift() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));
    int t=in.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      long a=in.nextLong();
      long b=in.nextLong();
      int res=0,temp=9 ;
      while(temp<=b){
        res++;
        temp=temp*10+9 ;
      }
      pw.println(a*res);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        var tt : int ; tt := 0 ; while tt < t do ( (     var a : long ; a := in.getCurrent()->toLong() ;
     var b : long ; b := in.getCurrent()->toLong() ;
    var res : int ; res := 0 ;
    var temp : int ; temp := 9 ;
    while (temp <= b) do (     res := res + 1 ; 
     temp := temp * 10 + 9 ) ; 
    skip ; 
 )  ;     tt := tt + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class sample {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      String s=in.next();
      String a="" ;
      char b=s.charAt(s.length()-1);
      for(int j=0 ; j<s.length(); j+=2){
        a+=s.charAt(j);
      }
      System.out.println(a+b);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class sample {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := in.getCurrent() ;
     var a : String ; a := "" ;
    var b : String ; b := s->at(s->size() - 1+1) ;
        var j : int ; j := 0 ; while j < s->size() do ( (     a := a+(s->at(j+1)) )  ;     j := j+(2) ) ; 
    OclFile["System.out"].println(a + b) ; 
 )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Objects ;
import java.util.Scanner ;
public class AShortSubstring {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    sc.nextLine();
    List<StringBuilder>ress=new ArrayList<>();
    for(int i=0 ; i<t ; i++){
      String[] chars=sc.nextLine().split("");
      StringBuilder res=new StringBuilder(chars[0]);
      for(int j=1 ; j<chars.length-1 ; j++){
        res.append(chars[j]);
        if(Objects.equals(chars[j],chars[j+1]))j++;
      }
      ress.add(res.append(chars[chars.length-1]));
    }
    ress.forEach(System.out :: println);
  }
}
------------------------------------------------------------
OCL File:
---------
 class AShortSubstring {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    skip ; 
    var ress : Sequence(String) ; ress := Sequence{} ;
        var i : int ; i := 0 ; while i < t do ( (     var chars : Sequence(String) ; chars := sc.nextLine()->split("") ;
     var res : String ; res := StringLib.newString(chars[0+1]) ;
         var j : int ; j := 1 ; while j < chars->size() - 1 do ( (     res := res + StringLib.newString(chars[j+1]) ; 
     if (Objects = chars[j+1], chars[j + 1+1]) then     j := j + 1 ; else skip )  ;     j := j + 1 ) ; 
     ress := ress->including(res + StringLib.newString(chars[chars->size() - 1+1])) )  ;     i := i + 1 ) ; 
    for _forEach : ress do
    (    skip ;) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt(),i ;
    for(i=0 ; i<t ; i++){
      String str=sc.next();
      ArrayList<Character>s=new ArrayList<>();
      if(str.length()==2){
        System.out.println(str);
        continue ;
      }
      s.add(str.charAt(0));
      for(int j=1 ; j<str.length(); j++){
        if(j<str.length()-1){
          if(str.charAt(j)==str.charAt(j+1)){
            s.add(str.charAt(j));
            j++;
          }
          else s.add(str.charAt(j));
        }
        else s.add(str.charAt(j));
      }
      for(int j=0 ; j<s.size(); j++){
        System.out.print(s.get(j));
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var i : int ;
         i := 0 ; while i < t do ( (     var str : String ; str := sc.getCurrent() ;
     var s : Sequence(String) ; s := Sequence{} ;
    if (str->size() = 2) then (     OclFile["System.out"].println(str) ; 
     continue ) else skip ; 
    s := s->including(str->at(0+1)) ; 
        var j : int ; j := 1 ; while j < str->size() do ( (     if (j < str->size() - 1) then (     if (str->at(j+1) = str->at(j + 1+1)) then (     s := s->including(str->at(j+1)) ; 
     j := j + 1 ) else     s := s->including(str->at(j+1)) ; ) else     s := s->including(str->at(j+1)) ; )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < s->size() do ( (     OclFile["System.out"].print(s->at(j+1)) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt(),i ;
    for(i=0 ; i<t ; i++){
      String str=sc.next();
      ArrayList<Character>s=new ArrayList<>();
      if(str.length()==2){
        System.out.println(str);
        continue ;
      }
      s.add(str.charAt(0));
      for(int j=1 ; j<str.length(); j++){
        if(j<str.length()-1){
          if(str.charAt(j)==str.charAt(j+1)){
            s.add(str.charAt(j));
            j++;
          }
          else s.add(str.charAt(j));
        }
        else s.add(str.charAt(j));
      }
      for(int j=0 ; j<s.size(); j++){
        System.out.print(s.get(j));
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var i : int ;
         i := 0 ; while i < t do ( (     var str : String ; str := sc.getCurrent() ;
     var s : Sequence(String) ; s := Sequence{} ;
    if (str->size() = 2) then (     OclFile["System.out"].println(str) ; 
     continue ) else skip ; 
    s := s->including(str->at(0+1)) ; 
        var j : int ; j := 1 ; while j < str->size() do ( (     if (j < str->size() - 1) then (     if (str->at(j+1) = str->at(j + 1+1)) then (     s := s->including(str->at(j+1)) ; 
     j := j + 1 ) else     s := s->including(str->at(j+1)) ; ) else     s := s->including(str->at(j+1)) ; )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < s->size() do ( (     OclFile["System.out"].print(s->at(j+1)) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    OutputStreamWriter osr=new OutputStreamWriter(System.out);
    PrintWriter out=new PrintWriter(osr);
    FastReader fr=new FastReader();
    int t=fr.nextInt();
    while(t--!=0){
      String s=fr.next();
      if(s.length()<=2)out.print(s);
      else {
        out.print(s.charAt(0)+""+s.charAt(1));
        for(int i=3 ; i<s.length(); i+=2)out.print(s.charAt(i));
      }
      out.println();
    }
    out.close();
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    InputStreamReader isr=new InputStreamReader(System.in);
    br=new BufferedReader(isr);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String nextLine()throws IOException {
    return br.readLine();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public int[] intArray(int size)throws IOException {
    int[] arr=new int[size];
    for(int i=0 ; i<size ; i++)arr[i]=nextInt();
    return arr ;
  }
  public char[] charArray()throws IOException {
    return nextLine().toCharArray();
  }
}
class Pair {
  int d ;
  int k ;
  public Pair(int d,int k){
    this.d=d ;
    this.k=k ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var osr : OclFile ; osr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(osr) ;
    var fr : FastReader ; fr := FastReader.newFastReader() ;
    var t : int ; t := fr.nextInt() ;
        while (t /= 0) do (    skip ; (     var s : String ; s := fr.next() ;
     if (s->size() <= 2) then     skip else (     skip ; 
         var i : int ; i := 3 ; while i < s->size() do (     skip ;  ;     i := i+(2) ) ) ;  
     skip ) ;  ) ;  
    skip ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     br := OclFile.newOclFile_Read(isr) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation intArray( size : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < size do (     arr[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return arr );
   operation charArray() : Sequence(String)
  pre: true
  post: true
  activity: (     return nextLine()->characters() );
}
class Pair {
   attribute d : int;
   attribute k : int;
   static operation newPair( d : int, k : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(d, k);
    return self );
  operation initialise( d : int, k : int) : void
  pre: true  post: true
  activity: (     self.d := d ; 
     self.k := k );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main1 {
  static void quicksort(String s[],int left,int right){
    if(left>right)return ;
    int l=left,r=right ;
    String t ;
    while(l<r){
      while(s[left] .length()<=s[r] .length()&& l<r)r--;
      while(s[left] .length()>=s[l] .length()&& l<r)l++;
      if(l<r){
        t=s[l];
        s[l]=s[r];
        s[r]=t ;
      }
    }
    t=s[left];
    s[left]=s[l];
    s[l]=t ;
    quicksort(s,left,l-1);
    quicksort(s,l+1,right);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s[]=new String[n];
    for(int i=0 ; i<n ; i++){
      s[i]=sc.next();
    }
    quicksort(s,0,n-1);
    boolean t=true ;
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        if(s[j] .indexOf(s[i])==-1){
          t=false ;
          break ;
        }
      }
    }
    if(t){
      System.out.println("YES");
      for(int i=0 ; i<n ; i++){
        System.out.println(s[i]);
      }
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation quicksort( s : Sequence(String), left : int, right : int) : void
  pre: true
  post: true
  activity: (     if (left > right) then     return else skip ; 
     var l : int ; l := left ;
    var r : int ; r := right ;
    var t : String ;
    while (l < r) do (     while (s[left+1]->size() <= s[r+1]->size() & l < r) do     r := r - 1 ; ; 
     while (s[left+1]->size() >= s[l+1]->size() & l < r) do     l := l + 1 ; ; 
     if (l < r) then (     t := s[l+1] ; 
     s[l+1] := s[r+1] ; 
     s[r+1] := t ) else skip ) ; 
    t := s[left+1] ; 
    s[left+1] := s[l+1] ; 
    s[l+1] := t ; 
    execute quicksort(s, left, l - 1) ; 
    execute quicksort(s, l + 1, right) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    execute quicksort(s, 0, n - 1) ; 
    var t : boolean ; t := true ;
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (s[j+1]->indexOf(s[i+1])-1 = -1) then (     t := false ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (t) then (     OclFile["System.out"].println("YES") ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(s[i+1]) )  ;     i := i + 1 ) ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main1 {
  static void quicksort(String s[],int left,int right){
    if(left>right)return ;
    int l=left,r=right ;
    String t ;
    while(l<r){
      while(s[left] .length()<=s[r] .length()&& l<r)r--;
      while(s[left] .length()>=s[l] .length()&& l<r)l++;
      if(l<r){
        t=s[l];
        s[l]=s[r];
        s[r]=t ;
      }
    }
    t=s[left];
    s[left]=s[l];
    s[l]=t ;
    quicksort(s,left,l-1);
    quicksort(s,l+1,right);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s[]=new String[n];
    for(int i=0 ; i<n ; i++){
      s[i]=sc.next();
    }
    quicksort(s,0,n-1);
    boolean t=true ;
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        if(s[j] .indexOf(s[i])==-1){
          t=false ;
          break ;
        }
      }
    }
    if(t){
      System.out.println("YES");
      for(int i=0 ; i<n ; i++){
        System.out.println(s[i]);
      }
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation quicksort( s : Sequence(String), left : int, right : int) : void
  pre: true
  post: true
  activity: (     if (left > right) then     return else skip ; 
     var l : int ; l := left ;
    var r : int ; r := right ;
    var t : String ;
    while (l < r) do (     while (s[left+1]->size() <= s[r+1]->size() & l < r) do     r := r - 1 ; ; 
     while (s[left+1]->size() >= s[l+1]->size() & l < r) do     l := l + 1 ; ; 
     if (l < r) then (     t := s[l+1] ; 
     s[l+1] := s[r+1] ; 
     s[r+1] := t ) else skip ) ; 
    t := s[left+1] ; 
    s[left+1] := s[l+1] ; 
    s[l+1] := t ; 
    execute quicksort(s, left, l - 1) ; 
    execute quicksort(s, l + 1, right) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    execute quicksort(s, 0, n - 1) ; 
    var t : boolean ; t := true ;
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (s[j+1]->indexOf(s[i+1])-1 = -1) then (     t := false ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (t) then (     OclFile["System.out"].println("YES") ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(s[i+1]) )  ;     i := i + 1 ) ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    String[] s=new String[n];
    for(int i=0 ; i<n ; i++){
      s[i]=input.next();
    }
    List<String>listTest=Arrays.asList(s);
    listTest.sort(new Comparator<String>(){
      public int compare(String o1,String o2){
        if(o1.length()>o2.length()){
          return 1 ;
        }
        else if(o1.length()==o2.length()){
          return 0 ;
        }
        else if(o1.length()<o2.length()){
          return-1 ;
        }
        return 0 ;
      }
    }
);
    String bi="" ;
    int a=0 ;
    for(int i=0 ; i<s.length-1 ; i++){
      bi=s[i+1];
      if(bi.indexOf(s[i])!=-1){
        a++;
      }
    }
    if(a==s.length-1){
      System.out.println("YES");
      for(int i=0 ; i<s.length ; i++){
        System.out.println(s[i]);
      }
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := input.getCurrent() )  ;     i := i + 1 ) ; 
    var listTest : Sequence(String) ; listTest := s ;
    listTest := listTest.sort(OclComparator<String>.newOclComparator()) ; 
    var bi : String ; bi := "" ;
    var a : int ; a := 0 ;
        var i : int ; i := 0 ; while i < s->size() - 1 do ( (     bi := s[i + 1+1] ; 
     if (bi->indexOf(s[i+1])-1 /= -1) then (     a := a + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (a = s->size() - 1) then (     OclFile["System.out"].println("YES") ; 
         var i : int ; i := 0 ; while i < s->size() do ( (     OclFile["System.out"].println(s[i+1]) )  ;     i := i + 1 ) ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    String str[]=new String[n];
    for(int i=0 ; i<n ; i++){
      str[i]=in.next();
    }
    Arrays.sort(str,Comparator.comparingInt(String :: length));
    boolean flag=true ;
    for(int i=1 ; i<n ; i++){
      if(str[i] .contains(str[i-1])){
        continue ;
      }
      else {
        flag=false ;
        break ;
      }
    }
    if(flag){
      pw.println("YES");
      for(String s : str){
        pw.println(s);
      }
    }
    else {
      pw.println("NO");
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var str : Sequence(String) ; str := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     str[i+1] := in.getCurrent() )  ;     i := i + 1 ) ; 
    str := OclComparator.sortWith(str, Comparator.comparingInt(lambda _pars : OclAny in String.newString().length(_pars))) ; 
    var flag : boolean ; flag := true ;
        var i : int ; i := 1 ; while i < n do ( (     if (str[i+1]->includes(str[(i)->char2byte() - 1+1])) then (     continue ) else (     flag := false ; 
     break ) )  ;     i := i + 1 ) ; 
    if (flag) then (     skip ; 
     for (s : str) do ( (     skip )  ) ) else (     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.NoSuchElementException ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
public class Algorithm {
  public static void main(String[] args){
    ArrayList<ArrayList<String>>input=getInputWords();
    HashMap<Integer,Integer>hm=new HashMap<>();
    int min_key=1 ;
    int max_key=Integer.parseInt(input.get(0).get(1));
    for(String x : input.get(1)){
      int key=Integer.parseInt(x);
      if(hm.containsKey(key)){
        hm.put(key,hm.get(key)+1);
      }
      else {
        hm.put(key,1);
      }
    }
    int result=0 ;
    for(int i=min_key ; i<max_key ; i++){
      for(int j=i+1 ; j<=max_key ; j++){
        result+=hm.get(i)*hm.get(j);
      }
    }
    System.out.println(result);
  }
  public static ArrayList<String>getInputLines(){
    ArrayList<String>input=new ArrayList<String>();
    Scanner scanner=new Scanner(System.in);
    String line ;
    while(true){
      try {
        line=scanner.nextLine();
      }
      catch(NoSuchElementException e){
        break ;
      }
      input.add(line);
    }
    return input ;
  }
  public static ArrayList<ArrayList<String>>getInputWords(){
    return getInputWords(getInputLines());
  }
  public static ArrayList<ArrayList<String>>getInputWords(ArrayList<String>input){
    ArrayList<ArrayList<String>>result=new ArrayList<ArrayList<String>>();
    ArrayList<String>splitted_line ;
    for(String line : input){
      splitted_line=new ArrayList<>(Arrays.asList(line.split(" ")));
      result.add(splitted_line);
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Algorithm {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : Sequence(Sequence(String)) ; input := getInputWords() ;
     var hm : Map(int,int) ; hm := Map{} ;
    var min_key : int ; min_key := 1 ;
    var max_key : int ; max_key := (input->at(0+1)->at(1+1))->toInteger() ;
    for (x : input->at(1+1)) do ( (     var key : int ; key := (x)->toInteger() ;
     if (hm->keys()->includes(key)) then (     hm := hm->union(Map{key |-> hm->at(key) + 1}) ) else (     hm := hm->union(Map{key |-> 1}) ) )  ) ; 
    var result : int ; result := 0 ;
        var i : int ; i := min_key ; while i < max_key do ( (         var j : int ; j := i + 1 ; while j <= max_key do ( (     result := result+(hm->at(i) * hm->at(j)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation getInputLines() : Sequence(String)
  pre: true
  post: true
  activity: (     var input : Sequence(String) ; input := Sequence{} ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var line : String ;
    while (true) do (     try (     line := scanner.nextLine() )   catch (e : IncorrectElementException) do (     break )
     input := input->including(line) ) ; 
    return input 
 );
  static   operation getInputWords() : Sequence(Sequence(String))
  pre: true
  post: true
  activity: (     return getInputWords(getInputLines()) );
  static   operation getInputWords( input : Sequence(String)) : Sequence(Sequence(String))
  pre: true
  post: true
  activity: (     var result : Sequence(Sequence(String)) ; result := Sequence{} ;
     var splitted_line : Sequence(String) ;
     for (line : input) do ( (     splitted_line := Sequence{}->union(line->split(" ")) ; 
     result := result->including(splitted_line) )  ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test152 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int x=in.nextInt();
      if(n==1){
        System.out.println(0);
      }
      else if(n==2){
        System.out.println(x);
      }
      else {
        System.out.println(x*2);
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test152 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var x : int ; x := in.getCurrent()->toInteger() ;
     if (n = 1) then (     OclFile["System.out"].println(0) ) else     if (n = 2) then (     OclFile["System.out"].println(x) ) else (     OclFile["System.out"].println(x * 2) ) ;  )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int n=input.nextInt();
    String s[]=new String[n];
    for(int i=0 ; i<n ; i++){
      s[i]=input.next();
    }
    Arrays.sort(s,new Comparator<String>(){
      @ Override public int compare(String t,String t1){
        return t.length()-t1.length();
      }
    }
);
    String prev=s[0];
    boolean check=true ;
    for(int i=1 ; i<n ; i++){
      if(s[i] .contains(prev)){
        prev=s[i];
      }
      else {
        check=false ;
        break ;
      }
    }
    if(! check){
      System.out.println("NO");
    }
    else {
      StringBuilder result=new StringBuilder();
      result.append("YES\n");
      for(String string : s){
        result.append(string+"\n");
      }
      System.out.println(result);
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var n : int ; n := input.nextInt() ;
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := input.next() )  ;     i := i + 1 ) ; 
    s := OclComparator.sortWith(s, OclComparator<String>.newOclComparator()) ; 
    var prev : String ; prev := s[0+1] ;
    var check : boolean ; check := true ;
        var i : int ; i := 1 ; while i < n do ( (     if (s[i+1]->includes(prev)) then (     prev := s[i+1] ) else (     check := false ; 
     break ) )  ;     i := i + 1 ) ; 
    if (not(check)) then (     OclFile["System.out"].println("NO") ) else (     var result : String ; result := StringLib.newString() ;
     result := result + StringLib.newString("YES\n") ; 
     for (string : s) do ( (     result := result + StringLib.newString(string + "\n") )  ) ; 
     OclFile["System.out"].println(result) ) ;  
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPrime(int n){
    for(int i=2 ; i*i<=n ; i++){
      if(n % i==0){
        return false ;
      }
    }
    return true ;
  }
  static void printMinCountPrime(int N){
    int minCount ;
    if(isPrime(N)){
      minCount=1 ;
    }
    else if(N % 2==0){
      minCount=2 ;
    }
    else {
      if(isPrime(N-2)){
        minCount=2 ;
      }
      else {
        minCount=3 ;
      }
    }
    System.out.print(minCount+"\n");
  }
  public static void main(String[] args){
    int N=100 ;
    printMinCountPrime(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation printMinCountPrime( N : int) : void
  pre: true
  post: true
  activity: (     var minCount : int ;
     if (isPrime(N)) then (     minCount := 1 ) else     if (N mod 2 = 0) then (     minCount := 2 ) else (     if (isPrime(N - 2)) then (     minCount := 2 ) else (     minCount := 3 ) ) ;  ;  
     OclFile["System.out"].print(minCount + "\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 100 ;
     execute printMinCountPrime(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void prefix(char[] str){
    int k=1,j ;
    int n=str.length ;
    Vector<Integer>g=new Vector<>();
    int flag=0 ;
    for(int i=1 ; i<n ; i++){
      if(str[i]==str[0]){
        g.add(i);
        flag=1 ;
      }
    }
    if(flag==0){
      System.out.println(String.valueOf(str));
    }
    else {
      int len=g.size();
      while(k<g.get(0)){
        int cnt=0 ;
        for(j=0 ; j<len ; j++){
          if((g.get(j)+k)<n && str[g.get(j)+k]==str[k]){
            cnt++;
          }
        }
        if(cnt==len){
          k++;
        }
        else {
          break ;
        }
      }
      for(int i=0 ; i<k ; i++){
        System.out.print(str[i]);
      }
      System.out.println();
    }
  }
  public static void main(String args[]){
    String str="abcab" ;
    prefix(str.toCharArray());
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation prefix( str : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 1 ;
    var j : int ;
     var n : int ; n := str->size() ;
    var g : Sequence(int) ; g := Sequence{} ;
    var flag : int ; flag := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (str[i+1] = str[0+1]) then (     g := g->including(i) ; 
     flag := 1 ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 0) then (     OclFile["System.out"].println(((str) + "")) ) else (     var len : int ; len := g->size() ;
     while (k < g->at(0+1)) do (     var cnt : int ; cnt := 0 ;
         j := 0 ; while j < len do ( (     if ((g->at(j+1) + k) < n & str[g->at(j+1) + k+1] = str[k+1]) then (     cnt := cnt + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (cnt = len) then (     k := k + 1 ) else (     break ) ) ; 
         var i : int ; i := 0 ; while i < k do ( (     OclFile["System.out"].print(str[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abcab" ;
     execute prefix(str->characters()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int q=sc.nextInt();
      int m=0 ;
      int arr[]=new int[n+1];
      for(int i=1 ; i<=n ; i++){
        arr[i]=sc.nextInt();
        if(arr[i]==1)m++;
      }
      while(q-->0){
        int t=sc.nextInt();
        int x=sc.nextInt();
        if(t==1){
          if(arr[x]==1){
            m--;
          }
          else {
            m++;
          }
          arr[x]=1-arr[x];
        }
        else {
          if(x<=m)System.out.println(1);
          else System.out.println(0);
        }
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var m : int ; m := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr[i+1] = 1) then     m := m + 1 ; else skip )  ;     i := i + 1 ) ; 
        while (q > 0) do (        q := q - 1 ;     skip ; (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (t = 1) then (     if (arr[x+1] = 1) then (     m := m - 1 ) else (     m := m + 1 ) ;  
     arr[x+1] := 1 - arr[x+1] ) else (     if (x <= m) then     OclFile["System.out"].println(1) ; else     OclFile["System.out"].println(0) ; ) ) ;  ) ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class KthLargestValue {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int q=scan.nextInt();
    int[] a=new int[n+1];
    int one=0 ;
    for(int i=1 ; i<=n ; i++){
      a[i]=scan.nextInt();
      if(a[i]==1){
++one ;
      }
    }
    while(q-->0){
      int x=scan.nextInt();
      int y=scan.nextInt();
      if(x==1){
        if(a[y]==0){
++one ;
          a[y]=1 ;
        }
        else {
--one ;
          a[y]=0 ;
        }
      }
      else {
        if(y<=one){
          System.out.println("1");
        }
        else {
          System.out.println("0");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class KthLargestValue {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var q : int ; q := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var one : int ; one := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := scan.getCurrent()->toInteger() ; 
     if (a[i+1] = 1) then (     one := one + 1 ) else skip )  ;     i := i + 1 ) ; 
        while (q > 0) do (        q := q - 1 ;     skip ; (     var x : int ; x := scan.getCurrent()->toInteger() ;
     var y : int ; y := scan.getCurrent()->toInteger() ;
     if (x = 1) then (     if (a[y+1] = 0) then (     one := one + 1 ; 
     a[y+1] := 1 ) else (     one := one - 1 ; 
     a[y+1] := 0 ) ) else (     if (y <= one) then (     OclFile["System.out"].println("1") ) else (     OclFile["System.out"].println("0") ) ) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1491 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int Q=in.nextInt();
    int[] A=new int[N];
    int ones=0 ;
    for(int n=0 ; n<N ; n++){
      int a=in.nextInt();
      A[n]=a ;
      if(a==1){
        ones++;
      }
    }
    StringBuilder output=new StringBuilder();
    for(int q=0 ; q<Q ; q++){
      int type=in.nextInt();
      if(type==1){
        int index=in.nextInt()-1 ;
        int a=A[index];
        if(a==1){
          ones--;
        }
        else {
          ones++;
        }
        A[index]=1-a ;
      }
      else {
        int K=in.nextInt();
        int answer=(K>ones)? 0 : 1 ;
        output.append(answer).append('\n');
      }
    }
    System.out.print(output);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1491 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var Q : int ; Q := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var ones : int ; ones := 0 ;
        var n : int ; n := 0 ; while n < N do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     A[n+1] := a ; 
     if (a = 1) then (     ones := ones + 1 ) else skip )  ;     n := n + 1 ) ; 
    var output : String ; output := StringLib.newString() ;
        var q : int ; q := 0 ; while q < Q do ( (     var type : int ; type := in.getCurrent()->toInteger() ;
     if (type = 1) then (     var index : int ; index := in.getCurrent()->toInteger() - 1 ;
     var a : int ; a := A[index+1] ;
     if (a = 1) then (     ones := ones - 1 ) else (     ones := ones + 1 ) ;  
     A[index+1] := 1 - a ) else (     var K : int ; K := in.getCurrent()->toInteger() ;
     var answer : int ; answer := if (K > ones) then 0 else 1 endif ;
     output := output + StringLib.newString(answer) + StringLib.newString('
') ) )  ;     q := q + 1 ) ; 
    OclFile["System.out"].print(output) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int q=sc.nextInt();
      int m=0 ;
      int arr[]=new int[n+1];
      for(int i=1 ; i<=n ; i++){
        arr[i]=sc.nextInt();
        if(arr[i]==1)m++;
      }
      while(q-->0){
        int t=sc.nextInt();
        int x=sc.nextInt();
        if(t==1){
          if(arr[x]==1){
            m--;
          }
          else {
            m++;
          }
          arr[x]=1-arr[x];
        }
        else {
          if(x<=m)System.out.println(1);
          else System.out.println(0);
        }
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var m : int ; m := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr[i+1] = 1) then     m := m + 1 ; else skip )  ;     i := i + 1 ) ; 
        while (q > 0) do (        q := q - 1 ;     skip ; (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (t = 1) then (     if (arr[x+1] = 1) then (     m := m - 1 ) else (     m := m + 1 ) ;  
     arr[x+1] := 1 - arr[x+1] ) else (     if (x <= m) then     OclFile["System.out"].println(1) ; else     OclFile["System.out"].println(0) ; ) ) ;  ) ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1550A_FindArray {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int num=parseInt(input.nextLine());
      int result=(int)Math.ceil(Math.sqrt(num));
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1550A_FindArray {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var num : int ; num := parseInt(input.nextLine()) ;
     var result : int ; result := ((num)->sqrt())->ceil()->oclAsType(int) ;
     OclFile["System.out"].println(result) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ques2 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int arr[]=new int[n];
    int gen[]=new int[11];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
      gen[arr[i] ]++;
    }
    long ans=0 ;
    for(int i=1 ; i<=m ; i++){
      for(int k=1 ; k<=m ; k++){
        if(i!=k){
          ans+=(long)gen[i]*gen[k];
        }
      }
    }
    System.out.println(ans/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ques2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var gen : Sequence(int) ; gen := Integer.subrange(1,11)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() ; 
     gen[arr[i+1]+1] := gen[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= m do ( (         var k : int ; k := 1 ; while k <= m do ( (     if (i /= k) then (     ans := ans+(gen[i+1]->oclAsType(long) * gen[k+1]) ) else skip )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.*;
public class ques {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      double n=sc.nextDouble();
      double root=Math.sqrt(n);
      double ans=(Math.ceil(root));
      int solution=(int)ans ;
      System.out.println(solution);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ques {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : double ; n := sc.getCurrent()->toReal() ;
     var root : double ; root := (n)->sqrt() ;
    var ans : double ; ans := ((root)->ceil()) ;
    var solution : int ; solution := ans->oclAsType(int) ;
    OclFile["System.out"].println(solution) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Exersise {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[][] array=new int[n][2];
    for(int i=0 ; i<array.length ; i++){
      for(int j=0 ; j<array[i] .length ; j++){
        array[i][j]=input.nextInt();
      }
    }
    for(int i=0 ; i<array.length ; i++){
      System.out.println(findInmer(array[i]));
    }
  }
  public static int findInmer(int[] array){
    if(array[0]==1){
      return 0 ;
    }
    else if(array[0]==2){
      return array[1];
    }
    else {
      return 2*array[1];
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Exersise {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var array : Sequence(Sequence(int)) ; array := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < array->size() do ( (         var j : int ; j := 0 ; while j < array[i+1]->size() do ( (     array[i+1][j+1] := input.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < array->size() do ( (     OclFile["System.out"].println(findInmer(array[i+1])) )  ;     i := i + 1 ) ; 
 );
  static   operation findInmer( array : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (array[0+1] = 1) then (     return 0 ) else     if (array[0+1] = 2) then (     return array[1+1] ) else (     return 2 * array[1+1] ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.nio.charset.MalformedInputException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
import java.util.HashSet ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter o=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int s=sc.nextInt();
      int u=0 ;
      int h=1 ;
      int v=0 ;
      while(true){
        if(u+h<s){
          u+=h ;
          h+=2 ;
          v++;
        }
        else {
          break ;
        }
      }
      if(u!=s){
        v++;
      }
      o.println(v);
    }
    o.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var o : OclFile ; o := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var u : int ; u := 0 ;
    var h : int ; h := 1 ;
    var v : int ; v := 0 ;
    while (true) do (     if (u + h < s) then (     u := u+(h) ; 
     h := h+(2) ; 
     v := v + 1 ) else (     break ) ) ; 
    if (u /= s) then (     v := v + 1 ) else skip ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int indx=0 ; indx<t ; indx++){
      int sum=sc.nextInt();
      System.out.println((int)Math.ceil(Math.sqrt(sum)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var indx : int ; indx := 0 ; while indx < t do ( (     var sum : int ; sum := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(((sum)->sqrt())->ceil()->oclAsType(int)) )  ;     indx := indx + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int bike=aaa();
    System.out.println(bike);
  }
  private static int aaa(){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int k=scanner.nextInt();
    int cur=scanner.nextInt();
    int bike=1 ;
    int step=0 ;
    int f=cur ;
    for(int i=1 ; i<n ; i++){
      int c=scanner.nextInt();
      if(c>cur+k){
        if(step==0){
          return-1 ;
        }
        cur=f ;
        if(c<=cur+k){
          f=c ;
          step=1 ;
        }
        else step=0 ;
++bike ;
      }
      else {
        f=c ;
++step ;
      }
    }
    return bike ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bike : int ; bike := aaa() ;
     OclFile["System.out"].println(bike) );
  static   operation aaa() : int
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
    var cur : int ; cur := scanner.getCurrent()->toInteger() ;
    var bike : int ; bike := 1 ;
    var step : int ; step := 0 ;
    var f : int ; f := cur ;
        var i : int ; i := 1 ; while i < n do ( (     var c : int ; c := scanner.getCurrent()->toInteger() ;
     if (c > cur + k) then (     if (step = 0) then (     return -1 ) else skip ; 
     cur := f ; 
     if (c <= cur + k) then (     f := c ; 
     step := 1 ) else     step := 0 ; ;  
     bike := bike + 1 ) else (     f := c ; 
     step := step + 1 ) )  ;     i := i + 1 ) ; 
    return bike 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class BicycleCounter {
  public int count(int k,int[] coord){
    int nowEl=0 ;
    int veliki=0 ;
    while(nowEl<coord.length-1){
      veliki++;
      int oldEl=nowEl ;
      while(coord[nowEl+1]<=coord[oldEl]+k){
        nowEl++;
        if(nowEl==coord.length-1){
          return veliki ;
        }
      }
      if(nowEl==oldEl){
        return-1 ;
      }
    }
    return veliki ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    if(in.hasNextLine()){
      String[] line1=in.nextLine().trim().split(" ");
      int k=Integer.parseInt(line1[1]);
      String[] line2=in.nextLine().trim().split(" ");
      int[] coords=Arrays.stream(line2).mapToInt(Integer :: parseInt).toArray();
      System.out.println(new BicycleCounter().count(k,coords));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BicycleCounter {
   operation count( k : int, coord : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var nowEl : int ; nowEl := 0 ;
     var veliki : int ; veliki := 0 ;
     while (nowEl < coord->size() - 1) do (     veliki := veliki + 1 ; 
     var oldEl : int ; oldEl := nowEl ;
     while (coord[nowEl + 1+1] <= coord[oldEl+1] + k) do (     nowEl := nowEl + 1 ; 
     if (nowEl = coord->size() - 1) then (     return veliki ) else skip ) ; 
     if (nowEl = oldEl) then (     return -1 ) else skip ) ; 
     return veliki );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     if (in.hasNextLine()) then (     var line1 : Sequence(String) ; line1 := in.nextLine()->trim()->split(" ") ;
     var k : int ; k := (line1[1+1])->toInteger() ;
    var line2 : Sequence(String) ; line2 := in.nextLine()->trim()->split(" ") ;
    var coords : Sequence(int) ; coords := stream(line2)->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    OclFile["System.out"].println(BicycleCounter.newBicycleCounter().count(k, coords)) ; 
 ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class New {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int k=scanner.nextInt();
    int[] a=new int[n];
    int maximum=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=scanner.nextInt();
      if(a[i]>maximum){
        maximum=a[i];
      }
    }
    int number=0 ;
    boolean flag=true ;
    int[] num=new int[maximum+1];
    for(int i=0 ; i<n ; i++){
      num[a[i] ]=1 ;
      if(i!=0){
        if(a[i]-a[i-1]>k){
          flag=false ;
          number=-1 ;
        }
      }
    }
    if(flag){
      int fin ;
      for(int i=0 ; i<n-1 ; i+=fin){
        int j=n-1-i ;
        fin=0 ;
        for(int t=1 ; t<=k ; t++){
          if(a[j]-t>=0){
            if(num[a[j]-t]==1){
              fin++;
            }
          }
        }
        number++;
      }
    }
    System.out.println(number);
  }
}
------------------------------------------------------------
OCL File:
---------
 class New {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var maximum : int ; maximum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() ; 
     if (a[i+1] > maximum) then (     maximum := a[i+1] ) else skip )  ;     i := i + 1 ) ; 
    var number : int ; number := 0 ;
    var flag : boolean ; flag := true ;
    var num : Sequence(int) ; num := Integer.subrange(1,maximum + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     num[a[i+1]+1] := 1 ; 
     if (i /= 0) then (     if (a[i+1] - a[i - 1+1] > k) then (     flag := false ; 
     number := -1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then (     var fin : int ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     var j : int ; j := n - 1 - i ;
     fin := 0 ; 
         var t : int ; t := 1 ; while t <= k do ( (     if (a[j+1] - t >= 0) then (     if (num[a[j+1] - t+1] = 1) then (     fin := fin + 1 ) else skip ) else skip )  ;     t := t + 1 ) ; 
     number := number + 1 )  ;     i := i+(fin) ) ) else skip ; 
    OclFile["System.out"].println(number) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Task1 {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int count=sc.nextInt();
    int max=sc.nextInt();
    int xNow=sc.nextInt();
    int xNext=0 ;
    int canRide=max ;
    int ans=1 ;
    for(int i=2 ; i<=count ; i++){
      xNext=sc.nextInt();
      if(xNext-xNow>max){
        System.out.println(-1);
        return ;
      }
      if(xNext-xNow>canRide){
        canRide=max-(xNext-xNow);
        ans++;
      }
      else {
        canRide-=(xNext-xNow);
      }
      xNow=xNext ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Task1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := sc.getCurrent()->toInteger() ;
    var max : int ; max := sc.getCurrent()->toInteger() ;
    var xNow : int ; xNow := sc.getCurrent()->toInteger() ;
    var xNext : int ; xNext := 0 ;
    var canRide : int ; canRide := max ;
    var ans : int ; ans := 1 ;
        var i : int ; i := 2 ; while i <= count do ( (     xNext := sc.getCurrent()->toInteger() ; 
     if (xNext - xNow > max) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
     if (xNext - xNow > canRide) then (     canRide := max - (xNext - xNow) ; 
     ans := ans + 1 ) else (     canRide := canRide-((xNext - xNow)) ) ;  
     xNow := xNext )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printCoins(int arr[],int n){
    int oddSum=0 ;
    for(int i=0 ; i<n ; i+=2)oddSum+=arr[i];
    int evenSum=0 ;
    for(int i=1 ; i<n ; i+=2)evenSum+=arr[i];
    int start=((oddSum>evenSum)? 0 : 1);
    for(int i=start ; i<n ; i+=2)System.out.print(arr[i]+" ");
  }
  public static void main(String[] args){
    int arr1[]={
      8,15,3,7 };
      int n=arr1.length ;
      printCoins(arr1,n);
      System.out.println();
      int arr2[]={
        2,2,2,2 };
        n=arr2.length ;
        printCoins(arr2,n);
        System.out.println();
        int arr3[]={
          20,30,2,2,2,10 };
          n=arr3.length ;
          printCoins(arr3,n);
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printCoins( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var oddSum : int ; oddSum := 0 ;
         var i : int ; i := 0 ; while i < n do (     oddSum := oddSum+(arr[i+1]) ;  ;     i := i+(2) ) ; 
    var evenSum : int ; evenSum := 0 ;
        var i : int ; i := 1 ; while i < n do (     evenSum := evenSum+(arr[i+1]) ;  ;     i := i+(2) ) ; 
    var start : int ; start := (if (oddSum > evenSum) then 0 else 1 endif) ;
        var i : int ; i := start ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i+(2) ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{8,15,3,7} ;
     var n : int ; n := arr1->size() ;
    execute printCoins(arr1, n) ; 
    OclFile["System.out"].println() ; 
    var arr2 : Sequence(int) ; arr2 := Sequence{2,2,2,2} ;
    n := arr2->size() ; 
    execute printCoins(arr2, n) ; 
    OclFile["System.out"].println() ; 
    var arr3 : Sequence(int) ; arr3 := Sequence{20,30,2,2,2,10} ;
    n := arr3->size() ; 
    execute printCoins(arr3, n) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int min_changes(int a[],int n){
    int ans_a=0,ans_b=0 ;
    for(int i=0 ; i<n ; i++){
      if(i % 2==0){
        if(a[i]==0)ans_a++;
        else ans_b++;
      }
      else {
        if(a[i]==0)ans_b++;
        else ans_a++;
      }
    }
    return Math.min(ans_a,ans_b);
  }
  public static void main(String[] args){
    int a[]={
      1,0,0,1,0,0,1,0 };
      int n=a.length ;
      System.out.println(min_changes(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation min_changes( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans_a : int ; ans_a := 0 ;
    var ans_b : int ; ans_b := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then (     if (a[i+1] = 0) then     ans_a := ans_a + 1 ; else     ans_b := ans_b + 1 ; ) else (     if (a[i+1] = 0) then     ans_b := ans_b + 1 ; else     ans_a := ans_a + 1 ; ) )  ;     i := i + 1 ) ; 
     return Set{ans_a, ans_b}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,0,0,1,0,0,1,0} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(min_changes(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.StreamTokenizer ;
import java.util.Arrays ;
public class Main {
  static StreamTokenizer st=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
  public static void main(String[] args){
    int n=nextInt();
    int I=nextInt();
    int k=8*I/n ;
    long K ;
    int a[]=new int[n+1];
    int num[]=new int[n+1];
    int cnt=0 ;
    for(int i=1 ; i<=n ; i++){
      a[n+1-i]=nextInt();
    }
    Arrays.sort(a,1,n+1);
    a[0]=-1 ;
    for(int i=1 ; i<=n ; i++){
      if(a[i]!=a[i-1])num[++cnt]=i ;
    }
    K=(int)(Math.log((double)(a[n]-a[1]))/Math.log(2.0));
    if(K<k){
      System.out.println(0);
    }
    else {
      int ans=n ;
      for(int i=1 ; i<cnt ; i++){
        int c=i+(1<<k)-1 ;
        if(c>cnt)break ;
        ans=Math.min(ans,n-num[c]+num[i-1]);
      }
      System.out.println(ans);
    }
  }
  static int nextInt(){
    try {
      st.nextToken();
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return(int)st.nval ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute st : StreamTokenizer := StreamTokenizer.newStreamTokenizer(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var I : int ; I := nextInt() ;
    var k : int ; k := 8 * I / n ;
    var K : long ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var num : Sequence(int) ; num := Integer.subrange(1,n + 1)->collect(0) ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     a[n + 1 - i+1] := nextInt() )  ;     i := i + 1 ) ; 
    a := a.subrange(1,1)^(a.subrange(1+1,n + 1)->sort())^a.subrange(n + 1+1,a.size) ; 
    a[0+1] := -1 ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (a[i+1] /= a[i - 1+1]) then         cnt := cnt + 1 ;
 num[cnt+1] := i  ; else skip )  ;     i := i + 1 ) ; 
    K := (((a[n+1] - a[1+1])->oclAsType(double))->log() / (2.0)->log())->oclAsType(int) ; 
    if (K < k) then (     OclFile["System.out"].println(0) ) else (     var ans : int ; ans := n ;
         var i : int ; i := 1 ; while i < cnt do ( (     var c : int ; c := i + ((1*(2->pow(k)))->oclAsType(long)) - 1 ;
     if (c > cnt) then     break else skip ; 
     ans := Set{ans, n - num[c+1] + num[i - 1+1]}->min() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) ) ;  
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     try (     st.next() )   catch (e : IOException) do (     e.printStackTrace() )
     return st.nval->oclAsType(int) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int target=240-scanner.nextInt();
    int lo=0,hi=Math.min(n,9);
    int[] times=new int[10];
    for(int i=1 ; i<=9 ; i++)times[i]=times[i-1]+5*i ;
    while(lo<=hi){
      int m=(lo+hi)/2 ;
      if(times[m]>target)hi=m-1 ;
      else lo=m+1 ;
    }
    System.out.println(lo-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var target : int ; target := 240 - scanner.getCurrent()->toInteger() ;
    var lo : int ; lo := 0 ;
    var hi : int ; hi := Set{n, 9}->min() ;
    var times : Sequence(int) ; times := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 1 ; while i <= 9 do (     times[i+1] := times[i - 1+1] + 5 * i ;  ;     i := i + 1 ) ; 
    while (lo <= hi) do (     var m : int ; m := (lo + hi) / 2 ;
     if (times[m+1] > target) then     hi := m - 1 ; else     lo := m + 1 ; ) ; 
    OclFile["System.out"].println(lo - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
public class Exercise5 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=240-b ;
    int d=0 ;
    int k=0 ;
    for(int i=1 ; i<=a ; i++){
      d=d+5*i ;
      if(d<=c){
        k=i ;
      }
    }
    System.out.println(k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Exercise5 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := 240 - b ;
    var d : int ; d := 0 ;
    var k : int ; k := 0 ;
        var i : int ; i := 1 ; while i <= a do ( (     d := d + 5 * i ; 
     if (d <= c) then (     k := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(k) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class AA {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      if(a==1)System.out.println(0);
      else if(a==2)System.out.println(b);
      else System.out.println(2*b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (a = 1) then     OclFile["System.out"].println(0) ; else     if (a = 2) then     OclFile["System.out"].println(b) else     OclFile["System.out"].println(2 * b) ; ;  )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class LimankParty {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int s=(int)n*(n+1)/2 ;
    int t=5*s ;
    while(240-t<k){
      t=t-n*5 ;
      n--;
    }
    System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class LimankParty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var s : int ; s := n->oclAsType(int) * (n + 1) / 2 ;
    var t : int ; t := 5 * s ;
    while (240 - t < k) do (     t := t - n * 5 ; 
     n := n - 1 ) ; 
    OclFile["System.out"].println(n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf750A {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int minutes=240-input.nextInt();
    int count=0 ;
    int sum=0 ;
    if(minutes>=5){
      for(int i=1 ; i<=n ; i++){
        sum+=5*i ;
        if(sum<=minutes)count++;
        else break ;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf750A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var minutes : int ; minutes := 240 - input.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var sum : int ; sum := 0 ;
    if (minutes >= 5) then (         var i : int ; i := 1 ; while i <= n do ( (     sum := sum+(5 * i) ; 
     if (sum <= minutes) then     count := count + 1 ; else     break )  ;     i := i + 1 ) ) else skip ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static int V ;
  static int E ;
  static ArrayList<Integer>[] g ;
  @ SuppressWarnings("unchecked")public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    V=sc.nextInt();
    E=sc.nextInt();
    g=new ArrayList[V];
    for(int i=0 ; i<V ; ++i)g[i]=new ArrayList<>();
    for(int i=0 ; i<E ; ++i){
      int s=sc.nextInt();
      int t=sc.nextInt();
      g[s] .add(t);
    }
    ord=new int[V];
    vis=new boolean[V];
    pending=new boolean[V];
    sort();
    for(int i=0 ; i<V ; ++i){
      System.out.println(ord[i]);
    }
  }
  static int[] ord ;
  static boolean[] vis ;
  static boolean[] pending ;
  static int now=0 ;
  static void sort(){
    for(int i=0 ; i<V ; ++i){
      if(! vis[i])dfs(i,-1);
    }
  }
  static void dfs(int cur,int pre){
    for(int to : g[cur]){
      if(to!=pre && ! vis[to]){
        if(pending[to])throw new AssertionError();
        dfs(to,cur);
      }
    }
    ord[V-now-1]=cur ;
    vis[cur]=true ;
++now ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute V : int;
  static   attribute E : int;
  static   attribute g : Sequence(Sequence(int));
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     V := sc.getCurrent()->toInteger() ; 
    E := sc.getCurrent()->toInteger() ; 
    g := Integer.subrange(1,V)->collect(null) ; 
        var i : int ; i := 0 ; while i < V do (     g[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < E do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     g[s+1]->excludes(t) )  ;     i := i + 1 ) ; 
    ord := Integer.subrange(1,V)->collect(0) ; 
    vis := Integer.subrange(1,V)->collect(false) ; 
    pending := Integer.subrange(1,V)->collect(false) ; 
    execute sort() ; 
        var i : int ; i := 0 ; while i < V do ( (     OclFile["System.out"].println(ord[i+1]) )  ;     i := i + 1 ) ; 
 );
  static   attribute ord : Sequence(int);
  static   attribute vis : Sequence(boolean);
  static   attribute pending : Sequence(boolean);
  static   attribute now : int := 0;
  static   operation sort() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < V do ( (     if (not(vis[i+1])) then     execute dfs(i, -1) ; else skip )  ;     i := i + 1 ) );
  static   operation dfs( cur : int, pre : int) : void
  pre: true
  post: true
  activity: (     for (to : g[cur+1]) do ( (     if (to /= pre & not(vis[to+1])) then (     if (pending[to+1]) then     error AssertionException() ; else skip ; 
     execute dfs(to, cur) ) else skip )  ) ; 
     ord[V - now - 1+1] := cur ; 
     vis[cur+1] := true ; 
     now := now + 1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.List ;
import java.util.ArrayList ;
import java.util.Set ;
import java.util.HashSet ;
import java.util.Map ;
import java.util.HashMap ;
import java.util.Queue ;
import java.util.ArrayDeque ;
import static java.lang.System.out ;
public class Main {
  public static void main(String[] args){
    try(Scanner in=new Scanner(System.in)){
      int n=in.nextInt();
      List<Set<Integer>>g=new ArrayList<>();
      for(int i=0 ; i<n ; i++)g.add(new HashSet<>());
      Queue<Integer>q=new ArrayDeque<>();
      Map<Integer,Integer>mm=new HashMap<>();
      for(int i=0 ; i<n ; i++)mm.put(i,0);
      int m=in.nextInt();
      for(int i=0 ; i<m ; i++){
        int f=in.nextInt();
        int t=in.nextInt();
        g.get(f).add(t);
        mm.replace(t,mm.get(t)+1);
      }
      for(Map.Entry<Integer,Integer>e : mm.entrySet()){
        if(e.getValue()==0)q.add(e.getKey());
      }
      while(! q.isEmpty()){
        int v=q.remove();
        out.printf("%d\n",v);
        for(int vv : g.get(v)){
          int d=mm.get(vv)-1 ;
          if(d==0)q.add(vv);
          mm.replace(vv,d);
        }
      }
    }
    catch(Exception ex){
      throw new RuntimeException(ex);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := in.getCurrent()->toInteger() ;
     var g : Sequence(Set(int)) ; g := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     g := g->including(Set{}) ;  ;     i := i + 1 ) ; 
    var q : Sequence(int) ; q := ArrayDeque<OclAny>.newArrayDeque() ;
    var mm : Map(int,int) ; mm := Map{} ;
        var i : int ; i := 0 ; while i < n do (     mm := mm->union(Map{i |-> 0}) ;  ;     i := i + 1 ) ; 
    var m : int ; m := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     var f : int ; f := in.getCurrent()->toInteger() ;
     var t : int ; t := in.getCurrent()->toInteger() ;
     g->at(f+1)->excludes(t) ; 
     mm := mm.replace(t, mm->at(t) + 1) )  ;     i := i + 1 ) ; 
    for (e : mm->asSet()) do ( (     if (e.getValue() = 0) then     q := q->including(e.getKey()) ; else skip )  ) ; 
    while (not(q->isEmpty())) do (     var v : int ; v := q.remove() ;
     out.printf("%d\n", v) ; 
     for (vv : g->at(v+1)) do ( (     var d : int ; d := mm->at(vv) - 1 ;
     if (d = 0) then     q := q->including(vv) ; else skip ; 
     mm := mm.replace(vv, d) )  ) ) ; 
 ))   catch (ex : ProgramException) do (     error ProgramException(ex) )
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Graph {
  ArrayList<Integer>adjArr[];
  @ SuppressWarnings("unchecked")Graph(int v){
    adjArr=new ArrayList[v];
    for(int i=0 ; i<v ; i++)adjArr[i]=new ArrayList<Integer>();
  }
  void addToGraph(int id,int neighbor){
    adjArr[id] .add(neighbor);
  }
  void topoSort(int v,boolean visited[],Stack<Integer>s){
    visited[v]=true ;
    int i ;
    Iterator<Integer>next=adjArr[v] .iterator();
    while(next.hasNext()){
      i=next.next();
      if(! visited[i])topoSort(i,visited,s);
    }
    s.push(v);
  }
}
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int totalVertex=sc.nextInt();
    Graph adj=new Graph(totalVertex);
    int total=sc.nextInt();
    int id ;
    int neighbor ;
    for(int j=0 ; j<total ; j++){
      id=sc.nextInt();
      neighbor=sc.nextInt();
      adj.addToGraph(id,neighbor);
    }
    Stack<Integer>stack=new Stack<Integer>();
    boolean[] visited=new boolean[totalVertex];
    for(int k=0 ; k<totalVertex ; k++){
      visited[k]=false ;
    }
    for(int l=0 ; l<totalVertex ; l++){
      if(! visited[l]){
        adj.topoSort(l,visited,stack);
      }
    }
    while(! stack.isEmpty()){
      System.out.println(stack.pop());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Graph {
   attribute adjArr : Sequence(Sequence(int));
     static operation newGraph( v : int) : Graph
  pre: true
  post: true
  activity:
  ( var self : Graph ;
    self := createGraph();
    self.initialise(v);
    return self );
  operation initialise( v : int) : void
  pre: true  post: true
  activity: (     adjArr := Integer.subrange(1,v)->collect(null) ; 
         var i : int ; i := 0 ; while i < v do (     adjArr[i+1] := Sequence{} ;  ;     i := i + 1 ) );
   operation addToGraph( id : int, neighbor : int) : void
  pre: true
  post: true
  activity: (     adjArr[id+1]->excludes(neighbor) );
   operation topoSort( v : int, visited : Sequence(boolean), s : Sequence(int)) : void
  pre: true
  post: true
  activity: (     visited[v+1] := true ; 
     var i : int ;
    var next : OclIterator ; next := adjArr[v+1]->iterator() ;
    while (next.hasNext()) do (     i := next.next() ; 
     if (not(visited[i+1])) then     execute topoSort(i, visited, s) ; else skip ) ; 
    s := s->append(v) ; 
 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var totalVertex : int ; totalVertex := sc.getCurrent()->toInteger() ;
    var adj : Graph ; adj := Graph.newGraph(totalVertex) ;
    var total : int ; total := sc.getCurrent()->toInteger() ;
    var id : int ;
    var neighbor : int ;
        var j : int ; j := 0 ; while j < total do ( (     id := sc.getCurrent()->toInteger() ; 
     neighbor := sc.getCurrent()->toInteger() ; 
     adj.addToGraph(id, neighbor) )  ;     j := j + 1 ) ; 
    var stack : Sequence(int) ; stack := Sequence{} ;
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,totalVertex)->collect(false) ;
        var k : int ; k := 0 ; while k < totalVertex do ( (     visited[k+1] := false )  ;     k := k + 1 ) ; 
        var l : int ; l := 0 ; while l < totalVertex do ( (     if (not(visited[l+1])) then (     adj.topoSort(l, visited, stack) ) else skip )  ;     l := l + 1 ) ; 
    while (not(stack->isEmpty())) do (     OclFile["System.out"].println(stack->last()) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static ArrayList<Integer>getTopologicalOrder(ArrayList<ArrayList<Integer>>es){
    int n=es.size();
    int[] deg=new int[n];
    ArrayList<Integer>ret=new ArrayList<>(n);
    Queue<Integer>q=new ArrayDeque<Integer>(n);
    for(int i=0 ; i<n ; i++){
      for(int to : es.get(i)){
        deg[to]++;
      }
    }
    for(int i=0 ; i<n ; i++){
      if(deg[i]==0)q.add(i);
    }
    int cnt=0 ;
    while(! q.isEmpty()){
      int from=q.poll();
      ret.add(from);
      for(int to : es.get(from)){
        deg[to]--;
        if(deg[to]==0){
          q.add(to);
        }
      }
      cnt++;
    }
    if(cnt!=n)return null ;
    return ret ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    ArrayList<ArrayList<Integer>>es=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      es.add(new ArrayList<Integer>());
    }
    for(int i=0 ; i<m ; i++){
      int s=sc.nextInt();
      int t=sc.nextInt();
      es.get(s).add(t);
    }
    ArrayList<Integer>tord=getTopologicalOrder(es);
    for(int i=0 ; i<n ; i++){
      System.out.println(tord.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation getTopologicalOrder( es : Sequence(Sequence(int))) : Sequence(int)
  pre: true
  post: true
  activity: (     var n : int ; n := es->size() ;
     var deg : Sequence(int) ; deg := Integer.subrange(1,n)->collect(0) ;
    var ret : Sequence(int) ; ret := Sequence{} ;
    var q : Sequence(int) ; q := ArrayDeque<int>.newArrayDeque(n) ;
        var i : int ; i := 0 ; while i < n do ( (     for (to : es->at(i+1)) do ( (     deg[to+1] := deg[to+1] + 1 )  ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (deg[i+1] = 0) then     q := q->including(i) ; else skip )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    while (not(q->isEmpty())) do (     var from : int ; from := q->min() ;
     ret := ret->including(from) ; 
     for (to : es->at(from+1)) do ( (     deg[to+1] := deg[to+1] - 1 ; 
     if (deg[to+1] = 0) then (     q := q->including(to) ) else skip )  ) ; 
     cnt := cnt + 1 ) ; 
    if (cnt /= n) then     return null else skip ; 
    return ret 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var es : Sequence(Sequence(int)) ; es := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     es := es->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     es->at(s+1)->excludes(t) )  ;     i := i + 1 ) ; 
    var tord : Sequence(int) ; tord := getTopologicalOrder(es) ;
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(tord->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int findPosition(int k,int n){
    long f1=0,f2=1,f3 ;
    int i=2 ;
    while(i!=0){
      f3=f1+f2 ;
      f1=f2 ;
      f2=f3 ;
      if(f2 % k==0){
        return n*i ;
      }
      i++;
    }
    return 0 ;
  }
  public static void main(String[] args){
    int n=5 ;
    int k=4 ;
    System.out.print("Position of n'th multiple"+" of k in Fibonacci Series is ");
    System.out.println(findPosition(k,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findPosition( k : int, n : int) : int
  pre: true
  post: true
  activity: (     var f1 : long ; f1 := 0 ;
    var f2 : long ; f2 := 1 ;
    var f3 : long ;
     var i : int ; i := 2 ;
     while (i /= 0) do (     f3 := f1 + f2 ; 
     f1 := f2 ; 
    f2 := f3 ; 
    if (f2 mod k = 0) then (     return n * i ) else skip ; 
    i := i + 1 ; 
 ) ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var k : int ; k := 4 ;
     OclFile["System.out"].print("Position of n'th multiple" + " of k in Fibonacci Series is ") ; 
     OclFile["System.out"].println(findPosition(k, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().solver();
  }
  void solver(){
    Scanner sc=new Scanner(System.in);
    int V=sc.nextInt();
    int E=sc.nextInt();
    @ SuppressWarnings("unchecked")ArrayList<Integer>[] e=new ArrayList[V];
    for(int i=0 ; i<V ; i++){
      e[i]=new ArrayList<Integer>();
    }
    for(int i=0 ; i<E ; i++){
      int s=sc.nextInt();
      int t=sc.nextInt();
      e[s] .add(t);
    }
    ArrayDeque<Integer>ans=topological_sort(e,0);
    while(! ans.isEmpty()){
      System.out.println(ans.poll());
    }
    sc.close();
  }
  ArrayDeque<Integer>topological_sort(ArrayList<Integer>[] edges,int s){
    ord=new ArrayDeque<Integer>();
    visit=new boolean[edges.length];
    for(int i=0 ; i<edges.length ; i++){
      if(! visit[i]){
        dfs(edges,i);
      }
    }
    return ord ;
  }
  boolean[] visit ;
  ArrayDeque<Integer>ord ;
  void dfs(ArrayList<Integer>[] edges,int i){
    visit[i]=true ;
    for(int j : edges[i]){
      if(! visit[j]){
        dfs(edges,j);
      }
    }
    ord.addFirst(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solver() );
   operation solver() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var V : int ; V := sc.getCurrent()->toInteger() ;
    var E : int ; E := sc.getCurrent()->toInteger() ;
    var e : Sequence(Sequence(int)) ; e := Integer.subrange(1,V)->collect(null) ;
        var i : int ; i := 0 ; while i < V do ( (     e[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < E do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     e[s+1]->excludes(t) )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := topological_sort(e, 0) ;
    while (not(ans->isEmpty())) do (     OclFile["System.out"].println(ans->min()) ) ; 
    skip ; 
 );
   operation topological_sort( edges : Sequence(Sequence(int)), s : int) : Sequence(int)
  pre: true
  post: true
  activity: (     ord := ArrayDeque<int>.newArrayDeque() ; 
     visit := Integer.subrange(1,edges->size())->collect(false) ; 
         var i : int ; i := 0 ; while i < edges->size() do ( (     if (not(visit[i+1])) then (     execute dfs(edges, i) ) else skip )  ;     i := i + 1 ) ; 
     return ord );
   attribute visit : Sequence(boolean);
   attribute ord : Sequence(int);
   operation dfs( edges : Sequence(Sequence(int)), i : int) : void
  pre: true
  post: true
  activity: (     visit[i+1] := true ; 
     for (j : edges[i+1]) do ( (     if (not(visit[j+1])) then (     execute dfs(edges, j) ) else skip )  ) ; 
     ord := ord->prepend(i) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void hut_pattern(int n){
    int i,j,t ;
    if(n % 2==0){
      n++;
    }
    for(i=0 ; i<=n-n/3 ; i++){
      for(j=0 ; j<n ; j++){
        t=2*n/5 ;
        if(t % 2!=0){
          t--;
        }
        if(i==n/5 || i==n-n/3 ||(j==n-1 && i>=n/5)||(j>=n/5 && j<n-n/5 && i==0)||(j==0 && i>=n/5)||(j==t && i>n/5)||(i<=n/5 &&(i+j==n/5 || j-i==n/5))||(j-i==n-n/5)){
          System.out.print("*");
        }
        else if(i==n/5+n/7 &&(j>=n/7 && j<=t-n/7)){
          System.out.print("_");
        }
        else if(i>=n/5+n/7 &&(j==n/7 || j==t-n/7)){
          System.out.print("|");
        }
        else {
          System.out.print(" ");
        }
      }
      System.out.print("\n");
    }
  }
  public static void main(String[] args){
    int n=15 ;
    hut_pattern(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation hut_pattern( n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var t : int ;
     if (n mod 2 = 0) then (     n := n + 1 ) else skip ; 
         i := 0 ; while i <= n - n / 3 do ( (         j := 0 ; while j < n do ( (     t := 2 * n / 5 ; 
     if (t mod 2 /= 0) then (     t := t - 1 ) else skip ; 
     if (i = n / 5 or i = n - n / 3 or (j = n - 1 & i >= n / 5) or (j >= n / 5 & j < n - n / 5 & i = 0) or (j = 0 & i >= n / 5) or (j = t & i > n / 5) or (i <= n / 5 & (i + j = n / 5 or j - i = n / 5)) or (j - i = n - n / 5)) then (     OclFile["System.out"].print("*") ) else     if (i = n / 5 + n / 7 & (j >= n / 7 & j <= t - n / 7)) then (     OclFile["System.out"].print("_") ) else     if (i >= n / 5 + n / 7 & (j = n / 7 or j = t - n / 7)) then (     OclFile["System.out"].print("|") ) else (     OclFile["System.out"].print(" ") ) ;  ;  )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     execute hut_pattern(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      int[] arr=new int[n+1];
      for(int i=1 ; i<=n ; i++){
        arr[i]=sc.nextInt();
      }
      int count=0 ;
      for(int i=1 ; i<=n ; i++){
        for(int j=arr[i]-i ; j<=n ; j+=arr[i]){
          if(j>=0 && arr[i]*arr[j]==i+j){
            if(i<j){
              count++;
            }
          }
        }
      }
      if(count>80100){
        System.out.println(count-1);
      }
      else {
        System.out.println(count);
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := arr[i+1] - i ; while j <= n do ( (     if (j >= 0 & arr[i+1] * arr[j+1] = i + j) then (     if (i < j) then (     count := count + 1 ) else skip ) else skip )  ;     j := j+(arr[i+1]) ) )  ;     i := i + 1 ) ; 
    if (count > 80100) then (     OclFile["System.out"].println(count - 1) ) else (     OclFile["System.out"].println(count) ) ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MochaAndRedAndBlue {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    while(test-->0){
      int n=sc.nextInt();
      String s=sc.next();
      System.out.println(findThePuzzle(s,n));
    }
  }
  public static String findThePuzzle(String s,int n){
    if(n==1 && s.equals("?")){
      return "B" ;
    }
    if(n==1){
      return s ;
    }
    int countOfAlphabets=0 ;
    char[] array=s.toCharArray();
    for(int i=0 ; i<n ; i++){
      char current=array[i];
      if(current!='?')countOfAlphabets+=1 ;
    }
    if(countOfAlphabets==0){
      array[0]='R' ;
    }
    for(int i=1 ; i<n ; i++){
      if(array[i]=='?' && array[i-1]!='?'){
        array[i]=(char)(array[i-1] ^('B' ^ 'R'));
      }
    }
    for(int i=n-2 ; i>=0 ; i--){
      if(array[i]=='?' && array[i+1]!='?'){
        array[i]=(char)(array[i+1] ^('B' ^ 'R'));
      }
    }
    return new String(array);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MochaAndRedAndBlue {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
     OclFile["System.out"].println(findThePuzzle(s, n)) ) ;  ) );
  static   operation findThePuzzle( s : String, n : int) : String
  pre: true
  post: true
  activity: (     if (n = 1 & s = "?") then (     return "B" ) else skip ; 
     if (n = 1) then (     return s ) else skip ; 
    var countOfAlphabets : int ; countOfAlphabets := 0 ;
    var array : Sequence(String) ; array := s->characters() ;
        var i : int ; i := 0 ; while i < n do ( (     var current : String ; current := array[i+1] ;
     if (current /= '?') then     countOfAlphabets := countOfAlphabets+(1) ; else skip )  ;     i := i + 1 ) ; 
    if (countOfAlphabets = 0) then (     array[0+1] := 'R' ) else skip ; 
        var i : int ; i := 1 ; while i < n do ( (     if (array[i+1] = '?' & array[(i)->char2byte() - 1+1] /= '?') then (     array[i+1] := (array[(i)->char2byte() - 1+1] xor ('B' xor 'R'))->oclAsType(String) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (array[i+1] = '?' & array[i + 1+1] /= '?') then (     array[i+1] := (array[i + 1+1] xor ('B' xor 'R'))->oclAsType(String) ) else skip )  ;     i := i - 1 ) ; 
    return StringLib.newString(array) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1353 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      int m=in.nextInt();
      if(n==1){
        System.out.println(0);
      }
      else if(n==2){
        System.out.println(m);
      }
      else {
        System.out.println(2*m);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1353 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
     if (n = 1) then (     OclFile["System.out"].println(0) ) else     if (n = 2) then (     OclFile["System.out"].println(m) ) else (     OclFile["System.out"].println(2 * m) ) ;  ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] b=new int[2*n+10];
      for(int i=0 ; i<n ; i++){
        int a=sc.nextInt();
        b[a]=i+1 ;
      }
      int m=n+n-1 ;
      int count=0 ;
      for(int i=1 ; i<b.length ; i++){
        for(int j=i+1 ; j<b.length ; j++){
          if((long)i*(long)j>(long)m)break ;
          if(b[i]==0 || b[j]==0)continue ;
          if(i*j==b[i]+b[j])count++;
        }
      }
      System.out.println(count);
    }
  }
  public static boolean isPowerOfTen(long input){
    if(input % 10!=0 || input==0){
      return false ;
    }
    if(input==10){
      return true ;
    }
    return isPowerOfTen(input/10);
  }
  static boolean isPrime(long n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static long gcd(long a,long b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static long lcm(long a,long b){
    return(a/gcd(a,b))*b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var b : Sequence(int) ; b := Integer.subrange(1,2 * n + 10)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     b[a+1] := i + 1 )  ;     i := i + 1 ) ; 
    var m : int ; m := n + n - 1 ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < b->size() do ( (         var j : int ; j := i + 1 ; while j < b->size() do ( (     if (i->oclAsType(long) * j->oclAsType(long) > m->oclAsType(long)) then     break else skip ; 
     if (b[i+1] = 0 or b[j+1] = 0) then     continue else skip ; 
     if (i * j = b[i+1] + b[j+1]) then     count := count + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;  ) );
  static   operation isPowerOfTen( input : long) : boolean
  pre: true
  post: true
  activity: (     if (input mod 10 /= 0 or input = 0) then (     return false ) else skip ; 
     if (input = 10) then (     return true ) else skip ; 
     return isPowerOfTen(input / 10) );
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a / gcd(a, b)) * b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String minWord="",maxWord="" ;
  static void minMaxLengthWords(String input){
    int len=input.length();
    int si=0,ei=0 ;
    int min_length=len,min_start_index=0,max_length=0,max_start_index=0 ;
    while(ei<=len){
      if(ei<len && input.charAt(ei)!=' '){
        ei++;
      }
      else {
        int curr_length=ei-si ;
        if(curr_length<min_length){
          min_length=curr_length ;
          min_start_index=si ;
        }
        if(curr_length>max_length){
          max_length=curr_length ;
          max_start_index=si ;
        }
        ei++;
        si=ei ;
      }
    }
    minWord=input.substring(min_start_index,min_start_index+min_length);
    maxWord=input.substring(max_start_index,max_length);
  }
  public static void main(String[] args){
    String a="GeeksforGeeks A Computer Science portal for Geeks" ;
    minMaxLengthWords(a);
    System.out.print("Minimum length word: "+minWord+"\nMaximum length word: "+maxWord);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute minWord : String := "";
  static   operation minMaxLengthWords( input : String) : void
  pre: true
  post: true
  activity: (     var len : int ; len := input->size() ;
     var si : int ; si := 0 ;
    var ei : int ; ei := 0 ;
    var min_length : int ; min_length := len ;
    var min_start_index : int ; min_start_index := 0 ;
    var max_length : int ; max_length := 0 ;
    var max_start_index : int ; max_start_index := 0 ;
    while (ei <= len) do (     if (ei < len & input->at(ei+1) /= ' ') then (     ei := ei + 1 ) else (     var curr_length : int ; curr_length := ei - si ;
     if (curr_length < min_length) then (     min_length := curr_length ; 
     min_start_index := si ) else skip ; 
    if (curr_length > max_length) then (     max_length := curr_length ; 
     max_start_index := si ) else skip ; 
    ei := ei + 1 ; 
    si := ei ; 
 ) ) ; 
    minWord := input.subrange(min_start_index+1,min_start_index + min_length) ; 
    maxWord := input.subrange(max_start_index+1,max_length) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ; a := "GeeksforGeeks A Computer Science portal for Geeks" ;
     execute minMaxLengthWords(a) ; 
     OclFile["System.out"].print("Minimum length word: " + minWord + "\nMaximum length word: " + maxWord) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int arr[]=new int[100005];
    boolean done[]=new boolean[100005];
    int n=sc.nextInt();
    for(int i=1 ; i<=n ; i++){
      arr[i]=sc.nextInt();
    }
    int cur=n ;
    for(int i=1 ; i<=n ; i++){
      int x=arr[i];
      done[x]=true ;
      if(x==cur){
        while(done[cur]){
          System.out.print(cur+" ");
          cur--;
        }
        System.out.println();
      }
      else {
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,100005)->collect(0) ;
    var done : Sequence(boolean) ; done := Integer.subrange(1,100005)->collect(false) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cur : int ; cur := n ;
        var i : int ; i := 1 ; while i <= n do ( (     var x : int ; x := arr[i+1] ;
     done[x+1] := true ; 
     if (x = cur) then (     while (done[cur+1]) do (     OclFile["System.out"].print(cur + " ") ; 
     cur := cur - 1 ) ; 
     OclFile["System.out"].println() ) else (     OclFile["System.out"].println() ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] snack=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      snack[i]=in.nextInt();
    }
    boolean[] vis=new boolean[n+1];
    int c=n ;
    for(int i=1 ; i<=n ; i++){
      vis[snack[i] ]=true ;
      while(vis[c] && c>0)System.out.print(c--+" ");
      System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var snack : Sequence(int) ; snack := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     snack[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var vis : Sequence(boolean) ; vis := Integer.subrange(1,n + 1)->collect(false) ;
    var c : int ; c := n ;
        var i : int ; i := 1 ; while i <= n do ( (     vis[snack[i+1]+1] := true ; 
     while (vis[c+1] & c > 0) do     OclFile["System.out"].print(c + " ") ; ; 
     OclFile["System.out"].println("") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] arr=new int[n+1];
    for(int i=1 ; i<=n ; i++)arr[i]=input.nextInt();
    boolean[] fail=new boolean[n+1];
    int number=n ;
    for(int i=1 ; i<=number ; i++){
      if(n==arr[i]){
        fail[arr[i] ]=true ;
        while(fail[n]){
          System.out.print(n--+" ");
        }
      }
      else {
        fail[arr[i] ]=true ;
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     arr[i+1] := input.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var fail : Sequence(boolean) ; fail := Integer.subrange(1,n + 1)->collect(false) ;
    var number : int ; number := n ;
        var i : int ; i := 1 ; while i <= number do ( (     if (n = arr[i+1]) then (     fail[arr[i+1]+1] := true ; 
     while (fail[n+1]) do (     OclFile["System.out"].print(n + " ") ) ) else (     fail[arr[i+1]+1] := true ) ;  
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int len=s.length();
    int n=0 ;
    int c ;
    String ans ;
    boolean[] e=new boolean[26];
    for(int i=0 ; i<len ; i++){
      if(e[(int)(s.charAt(i))-97]==false)n++;
      e[(int)(s.charAt(i))-97]=true ;
    }
    if(n==2){
      c=0 ;
    }
    else {
      c=len-2 ;
      if(s.charAt(0)==s.charAt(len-1))c--;
    }
    if(c % 2==0){
      ans="Second" ;
    }
    else {
      ans="First" ;
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var len : int ; len := s->size() ;
    var n : int ; n := 0 ;
    var c : int ;
    var ans : String ;
    var e : Sequence(boolean) ; e := Integer.subrange(1,26)->collect(false) ;
        var i : int ; i := 0 ; while i < len do ( (     if (e[(s->at(i+1))->oclAsType(int) - 97+1] = false) then     n := n + 1 ; else skip ; 
     e[(s->at(i+1))->oclAsType(int) - 97+1] := true )  ;     i := i + 1 ) ; 
    if (n = 2) then (     c := 0 ) else (     c := (len)->char2byte() - 2 ; 
     if (s->at(0+1) = s->at((len)->char2byte() - 1+1)) then     c := c - 1 ; else skip ) ;  
    if (c mod 2 = 0) then (     ans := "Second" ) else (     ans := "First" ) ;  
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] snack=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      snack[i]=sc.nextInt();
    }
    boolean[] vis=new boolean[n+1];
    int c=n ;
    for(int i=1 ; i<=n ; i++){
      vis[snack[i] ]=true ;
      while(vis[c] && c>0)System.out.print(c--+" ");
      System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var snack : Sequence(int) ; snack := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     snack[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var vis : Sequence(boolean) ; vis := Integer.subrange(1,n + 1)->collect(false) ;
    var c : int ; c := n ;
        var i : int ; i := 1 ; while i <= n do ( (     vis[snack[i+1]+1] := true ; 
     while (vis[c+1] & c > 0) do     OclFile["System.out"].print(c + " ") ; ; 
     OclFile["System.out"].println("") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
    }
    boolean[] visited=new boolean[n+1];
    for(int i=0 ; i<arr.length ; i++){
      visited[arr[i] ]=true ;
      while(visited[n]){
        out.print(n+" ");
        n--;
      }
      out.println();
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     visited[arr[i+1]+1] := true ; 
     while (visited[n+1]) do (     skip ; 
     n := n - 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class pre1 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int tc=obj.nextInt();
    while(tc--!=0){
      String y=(new StringBuilder(obj.next())).reverse().toString();
      String x=(new StringBuilder(obj.next())).reverse().toString();
      int posx=-1,posy=-1 ;
      for(int i=0 ; i<x.length(); i++){
        if(x.charAt(i)=='1'){
          posx=i ;
          break ;
        }
      }
      for(int i=(posx>=0)? posx : 0 ; i<y.length(); i++){
        if(y.charAt(i)=='1'){
          posy=i ;
          break ;
        }
      }
      if(posx==-1 || posy==-1)System.out.println(0);
      else System.out.println(posy-posx);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre1 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var tc : int ; tc := obj.nextInt() ;
         while (tc /= 0) do (    skip ; (     var y : String ; y := (StringLib.newString(obj.next()))->reverse()+"" ;
     var x : String ; x := (StringLib.newString(obj.next()))->reverse()+"" ;
    var posx : int ; posx := -1 ;
    var posy : int ; posy := -1 ;
        var i : int ; i := 0 ; while i < x->size() do ( (     if (x->at(i+1) = '1') then (     posx := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := if (posx >= 0) then posx else 0 endif ; while i < y->size() do ( (     if (y->at(i+1) = '1') then (     posy := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (posx = -1 or posy = -1) then     OclFile["System.out"].println(0) else     OclFile["System.out"].println((posy)->char2byte() - (posx)->char2byte()) ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int mod=1000000000+7 ;
    Scanner std=new Scanner(System.in);
    int n=std.nextInt();
    String s=std.next();
    long[] appearCounts=new long[26];
    int index=0 ;
    for(char c='a' ; c<='z' ; c++){
      for(int i=0 ; i<n ; i++){
        char t=s.charAt(i);
        if(c==t){
          appearCounts[index]++;
          appearCounts[index]=appearCounts[index] % mod ;
        }
      }
      index++;
    }
    long ans=1 ;
    for(long appearCount : appearCounts){
      ans=ans % mod*(appearCount+1);
    }
    ans=ans % mod-1 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mod : int ; mod := 1000000000 + 7 ;
     var std : OclFile ; std := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := std.getCurrent()->toInteger() ;
    var s : String ; s := std.getCurrent() ;
    var appearCounts : Sequence(long) ; appearCounts := Integer.subrange(1,26)->collect(0) ;
    var index : int ; index := 0 ;
        var c : String ; c := 'a' ; while c <= 'z' do ( (         var i : int ; i := 0 ; while i < n do ( (     var t : String ; t := s->at(i+1) ;
     if (c = t) then (     appearCounts[index+1] := appearCounts[index+1] + 1 ; 
     appearCounts[index+1] := appearCounts[index+1] mod mod ) else skip )  ;     i := i + 1 ) ; 
     index := index + 1 )  ;     c := c + 1 ) ; 
    var ans : long ; ans := 1 ;
    for (appearCount : appearCounts) do ( (     ans := ans mod mod * (appearCount + 1) )  ) ; 
    ans := ans mod mod - 1 ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.*;
import java.awt.geom.Point2D ;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] $){
    int n=sc.nextInt();
    long ans=1 ;
    long mod=1000000007 ;
    String s=sc.next();
    HashMap<Character,Long>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      char c=s.charAt(i);
      map.put(c,map.getOrDefault(c,0l)+1);
    }
    for(Long k : map.values())ans=(ans*(k+1))% mod ;
    out.println((ans-1+mod)% mod);
    out.close();
  }
  static PrintWriter out=new PrintWriter(System.out);
  static class sc {
    static Scanner s=new Scanner(System.in);
    static String next(){
      return s.next();
    }
    static int nextInt(){
      return Integer.parseInt(s.next());
    }
    static long nextLong(){
      return Long.parseLong(s.next());
    }
    static double nextDouble(){
      return Double.parseDouble(s.next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var ans : long ; ans := 1 ;
    var mod : long ; mod := 1000000007 ;
    var s : String ; s := sc.next() ;
    var map : Map(String,long) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var c : String ; c := s->at(i+1) ;
     map := map->union(Map{c |-> (if map->keys()->contains(c) then map->at(c) else 0l endif) + 1}) )  ;     i := i + 1 ) ; 
    for (k : map->values()) do (     ans := (ans * (k + 1)) mod mod ;  ) ; 
    out.println((ans - 1 + mod) mod mod) ; 
    out.close() ; 
 );
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static class sc {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation next() : String
  pre: true
  post: true
  activity: (     return s.getCurrent() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toLong() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Maximus {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    StringTokenizer st=new StringTokenizer(br.readLine());
    int fir[]=new int[n];
    for(int i=1 ; i<fir.length ; i++)fir[i]=Integer.parseInt(st.nextToken())+fir[i-1];
    int sec[]=new int[n];
    st=new StringTokenizer(br.readLine());
    for(int i=1 ; i<fir.length ; i++)sec[i]=Integer.parseInt(st.nextToken())+sec[i-1];
    st=new StringTokenizer(br.readLine());
    int b[]=new int[n];
    for(int i=0 ; i<n ; i++)b[i]=Integer.parseInt(st.nextToken());
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      int temp=sec[sec.length-1]-sec[i]+b[i]+fir[i];
      for(int j=0 ; j<n ; j++){
        if(j==i)continue ;
        min=Math.min(min,sec[sec.length-1]-sec[j]+b[j]+fir[j]+temp);
      }
    }
    System.out.print(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Maximus {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var fir : Sequence(int) ; fir := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 1 ; while i < fir->size() do (     fir[i+1] := (st.next())->toInteger() + fir[i - 1+1] ;  ;     i := i + 1 ) ; 
    var sec : Sequence(int) ; sec := Integer.subrange(1,n)->collect(0) ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 1 ; while i < fir->size() do (     sec[i+1] := (st.next())->toInteger() + sec[i - 1+1] ;  ;     i := i + 1 ) ; 
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     b[i+1] := (st.next())->toInteger() ;  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : int ; temp := sec[sec->size() - 1+1] - sec[i+1] + b[i+1] + fir[i+1] ;
         var j : int ; j := 0 ; while j < n do ( (     if (j = i) then     continue else skip ; 
     min := Set{min, sec[sec->size() - 1+1] - sec[j+1] + b[j+1] + fir[j+1] + temp}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  int MOD=(int)1e9+7 ;
  void solve(){
    int n=in.nextInt();
    char[] s=in.nextToken().toCharArray();
    int[] cnt=new int[26];
    for(int i=0 ; i<n ; i++){
      cnt[s[i]-'a']++;
    }
    long ans=1 ;
    for(int i=0 ; i<26 ; i++){
      ans=ans*(cnt[i]+1)% MOD ;
    }
    ans=(ans-1+MOD)% MOD ;
    out.println(ans);
  }
  public static void main(String[] args){
    in=new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
    out=new PrintWriter(System.out);
    new Main().solve();
    out.close();
  }
  static FastScanner in ;
  static PrintWriter out ;
  static class FastScanner {
    BufferedReader in ;
    StringTokenizer st ;
    public FastScanner(BufferedReader in){
      this.in=in ;
    }
    public String nextToken(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(in.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(nextToken());
    }
    public long nextLong(){
      return Long.parseLong(nextToken());
    }
    public double nextDouble(){
      return Double.parseDouble(nextToken());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute MOD : int := 1e9->oclAsType(int) + 7;
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var s : Sequence(String) ; s := in.next()->characters() ;
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     cnt[s[i+1] - ('a')->char2byte()+1] := cnt[s[i+1] - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 1 ;
        var i : int ; i := 0 ; while i < 26 do ( (     ans := ans * (cnt[i+1] + 1) mod MOD )  ;     i := i + 1 ) ; 
    ans := (ans - 1 + MOD) mod MOD ; 
    out.println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := FastScanner.newFastScanner(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     Main.newMain().solve() ; 
     out.close() );
  static   attribute in : FastScanner;
  static   attribute out : OclFile;
  static class FastScanner {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     self.in := in );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(in.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static class Task {
    private static int mod=1_000_000_007 ;
    public void solve(Scanner sc,PrintWriter pw)throws IOException {
      int n=sc.nextInt();
      char[] seq=sc.next().toCharArray();
      int[] count=new int[26];
      for(int i=0 ; i<n ; i++){
        count[seq[i]-'a']++;
      }
      long ret=1 ;
      for(int i=0 ; i<26 ; i++){
        ret=ret*(count[i]+1)% mod ;
      }
      pw.println((ret+mod-1)% mod);
    }
  }
  static long TIME_START,TIME_END ;
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(new BufferedOutputStream(System.out));
    Runtime runtime=Runtime.getRuntime();
    long usedMemoryBefore=runtime.totalMemory()-runtime.freeMemory();
    TIME_START=System.currentTimeMillis();
    Task t=new Task();
    t.solve(sc,pw);
    TIME_END=System.currentTimeMillis();
    long usedMemoryAfter=runtime.totalMemory()-runtime.freeMemory();
    pw.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(FileReader s)throws FileNotFoundException {
      br=new BufferedReader(s);
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Task {
  static   attribute mod : int := 1_000_000_007;
   operation solve( sc : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var seq : Sequence(String) ; seq := sc.next()->characters() ;
    var count : Sequence(int) ; count := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     count[seq[i+1] - ('a')->char2byte()+1] := count[seq[i+1] - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    var ret : long ; ret := 1 ;
        var i : int ; i := 0 ; while i < 26 do ( (     ret := ret * (count[i+1] + 1) mod mod )  ;     i := i + 1 ) ; 
    pw.println((ret + mod - 1) mod mod) ; 
 );
}
  static   attribute TIME_START : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var runtime : OclProcess ; runtime := Runtime.getRuntime() ;
    var usedMemoryBefore : long ; usedMemoryBefore := runtime.totalMemory() - runtime.freeMemory() ;
    TIME_START := OclDate.getSystemTime() ; 
    var t : Task ; t := Task.newTask() ;
    t.solve(sc, pw) ; 
    TIME_END := OclDate.getSystemTime() ; 
    var usedMemoryAfter : long ; usedMemoryAfter := runtime.totalMemory() - runtime.freeMemory() ;
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(s) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    String S=sc.next();
    HashMap<Character,Integer>map=new HashMap<Character,Integer>();
    int dupflag=0 ;
    for(int i=0 ; i<N ; i++){
      char c=S.charAt(i);
      if(map.containsKey(c)){
        map.put(c,map.get(c)+1);
        dupflag=1 ;
      }
      else map.put(c,1);
    }
    long M=(long)(Math.pow(10,9)+7);
    long a=1 ;
    long b=1 ;
    int sum=0 ;
    long mult=1 ;
    for(int i=0 ; i<N ; i++){
      a=(a*2)% M ;
    }
    if(dupflag==1){
      for(int x : map.values()){
        if(x==1)continue ;
        sum+=x ;
        mult=(mult*(x+1))% M ;
        for(int i=0 ; i<x ; i++){
          b=(b*2)% M ;
        }
      }
      if(b-mult<0)b=M+b-mult ;
      else b=b-mult ;
      for(int i=0 ; i<N-sum ; i++){
        b=(b*2)% M ;
      }
    }
    else b=0 ;
    if(a-1-b<0)System.out.println(M+a-1-b);
    else System.out.println(a-1-b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var S : String ; S := sc.getCurrent() ;
    var map : Map(String,int) ; map := Map{} ;
    var dupflag : int ; dupflag := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var c : String ; c := S->at(i+1) ;
     if (map->keys()->includes(c)) then (     map := map->union(Map{c |-> map->at(c) + 1}) ; 
     dupflag := 1 ) else     map := map->union(Map{c |-> 1}) ; )  ;     i := i + 1 ) ; 
    var M : long ; M := (10->pow(9) + 7)->oclAsType(long) ;
    var a : long ; a := 1 ;
    var b : long ; b := 1 ;
    var sum : int ; sum := 0 ;
    var mult : long ; mult := 1 ;
        var i : int ; i := 0 ; while i < N do ( (     a := (a * 2) mod M )  ;     i := i + 1 ) ; 
    if (dupflag = 1) then (     for (x : map->values()) do ( (     if (x = 1) then     continue else skip ; 
     sum := sum+(x) ; 
     mult := (mult * (x + 1)) mod M ; 
         var i : int ; i := 0 ; while i < x do ( (     b := (b * 2) mod M )  ;     i := i + 1 ) )  ) ; 
     if (b - mult < 0) then     b := M + b - mult else     b := b - mult ; ;  
         var i : int ; i := 0 ; while i < N - sum do ( (     b := (b * 2) mod M )  ;     i := i + 1 ) ) else     b := 0 ; ;  
    if (a - 1 - b < 0) then     OclFile["System.out"].println(M + a - 1 - b) else     OclFile["System.out"].println(a - 1 - b) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.Set ;
class GFG {
  int val ;
  int steps ;
  public GFG(int val,int steps){
    this.val=val ;
    this.steps=steps ;
  }
}
public class GeeksForGeeks {
  private static int minOperations(int src,int target){
    Set<GFG>visited=new HashSet<>(1000);
    LinkedList<GFG>queue=new LinkedList<GFG>();
    GFG node=new GFG(src,0);
    queue.offer(node);
    visited.add(node);
    while(! queue.isEmpty()){
      GFG temp=queue.poll();
      visited.add(temp);
      if(temp.val==target){
        return temp.steps ;
      }
      int mul=temp.val*2 ;
      int sub=temp.val-1 ;
      if(mul>0 && mul<1000){
        GFG nodeMul=new GFG(mul,temp.steps+1);
        queue.offer(nodeMul);
      }
      if(sub>0 && sub<1000){
        GFG nodeSub=new GFG(sub,temp.steps+1);
        queue.offer(nodeSub);
      }
    }
    return-1 ;
  }
  public static void main(String[] args){
    int x=4,y=7 ;
    GFG src=new GFG(x,y);
    System.out.println(minOperations(x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
   attribute val : int;
   attribute steps : int;
   static operation newGFG( val : int, steps : int) : GFG
  pre: true
  post: true
  activity:
  ( var self : GFG ;
    self := createGFG();
    self.initialise(val, steps);
    return self );
  operation initialise( val : int, steps : int) : void
  pre: true  post: true
  activity: (     self.val := val ; 
     self.steps := steps );
}
class GeeksForGeeks {
  static   operation minOperations( src : int, target : int) : int
  pre: true
  post: true
  activity: (     var visited : Set(GFG) ; visited := Set{} ;
     var queue : Sequence(GFG) ; queue := Sequence{} ;
    var node : GFG ; node := GFG.newGFG(src, 0) ;
    queue := queue->including(node) ; 
    visited := visited->including(node) ; 
    while (not(queue->isEmpty())) do (     var temp : GFG ; temp := queue->min() ;
     visited := visited->including(temp) ; 
    if (temp.val = target) then (     return temp.steps ) else skip ; 
    var mul : int ; mul := temp.val * 2 ;
    var sub : int ; sub := temp.val - 1 ;
    if (mul > 0 & mul < 1000) then (     var nodeMul : GFG ; nodeMul := GFG.newGFG(mul, temp.steps + 1) ;
     queue := queue->including(nodeMul) ) else skip ; 
    if (sub > 0 & sub < 1000) then (     var nodeSub : GFG ; nodeSub := GFG.newGFG(sub, temp.steps + 1) ;
     queue := queue->including(nodeSub) ) else skip ; 
 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 4 ;
    var y : int ; y := 7 ;
     var src : GFG ; src := GFG.newGFG(x, y) ;
     OclFile["System.out"].println(minOperations(x, y)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static FastScanner sc=new FastScanner(br);
  static PrintWriter out=new PrintWriter(System.out);
  static Random rnd=new Random();
  static char[] a ;
  public static void main(String args[])throws Exception {
    a=sc.next().toCharArray();
    int n=a.length ;
    if(a[0]==a[n-1] && n % 2==0){
      out.println("First");
    }
    else if(a[0]==a[n-1] && n % 2!=0){
      out.println("Second");
    }
    else if(a[0]!=a[n-1] && n % 2==0){
      out.println("Second");
    }
    else {
      out.println("First");
    }
    out.close();
  }
}
class FastScanner {
  BufferedReader in ;
  StringTokenizer st ;
  public FastScanner(BufferedReader in){
    this.in=in ;
  }
  public String nextToken()throws Exception {
    while(st==null || ! st.hasMoreTokens()){
      st=new StringTokenizer(in.readLine());
    }
    return st.nextToken();
  }
  public String next()throws Exception {
    return nextToken().toString();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(nextToken());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(nextToken());
  }
  public double nextDouble()throws Exception {
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute sc : FastScanner := FastScanner.newFastScanner(br);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute rnd : OclRandom := OclRandom.newOclRandom();
  static   attribute a : Sequence(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     a := sc.next()->characters() ; 
     var n : int ; n := a->size() ;
     if (a[0+1] = a[n - 1+1] & n mod 2 = 0) then (     skip ) else     if (a[0+1] = a[n - 1+1] & n mod 2 /= 0) then (     skip ) else     if (a[0+1] /= a[n - 1+1] & n mod 2 = 0) then (     skip ) else (     skip ) ;  ;  ;  
     skip );
}
class FastScanner {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     self.in := in );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return st.next() );
   operation next() : String
  pre: true
  post: true
  activity: (     return nextToken()+"" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    sc.close();
    String s="No" ;
    if(a==b && b!=c)s="Yes" ;
    if(a==c && b!=c)s="Yes" ;
    if(c==b && a!=c)s="Yes" ;
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    skip ; 
    var s : String ; s := "No" ;
    if (a = b & b /= c) then     s := "Yes" ; else skip ; 
    if (a = c & b /= c) then     s := "Yes" ; else skip ; 
    if (c = b & a /= c) then     s := "Yes" ; else skip ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
  public static long mod=(long)(1e9+7);
  public static long[] fac,inv ;
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int[] a=new int[3];
    for(int i=0 ; i<3 ; ++i)a[i]=sc.nextInt();
    Arrays.sort(a);
    if(a[0]==a[1] && a[1]!=a[2])out.print("Yes");
    else if(a[1]==a[2] && a[1]!=a[0])out.print("Yes");
    else out.print("No");
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute mod : long := (1e9 + 7)->oclAsType(long);
  static   attribute fac : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do (     a[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    if (a[0+1] = a[1+1] & a[1+1] /= a[2+1]) then     skip else     if (a[1+1] = a[2+1] & a[1+1] /= a[0+1]) then     skip else     skip ; ;  ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    int c=Integer.parseInt(sc.next());
    if(a==b){
      System.out.println((b!=c)? "Yes" : "No");
    }
    else if(b==c){
      System.out.println((c!=a)? "Yes" : "No");
    }
    else if(c==a){
      System.out.println((a!=b)? "Yes" : "No");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := (sc.getCurrent())->toInteger() ;
     var b : int ; b := (sc.getCurrent())->toInteger() ;
     var c : int ; c := (sc.getCurrent())->toInteger() ;
     if (a = b) then (     OclFile["System.out"].println(if (b /= c) then "Yes" else "No" endif) ) else     if (b = c) then (     OclFile["System.out"].println(if (c /= a) then "Yes" else "No" endif) ) else     if (c = a) then (     OclFile["System.out"].println(if (a /= b) then "Yes" else "No" endif) ) else (     OclFile["System.out"].println("No") ) ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int[] numArray=new int[10];
    String str="No" ;
    Map<Integer,Integer>numMap=new HashMap<>();
    while(sc.hasNext()){
      int N=Integer.parseInt(sc.next());
      numArray[N]++;
    }
    for(int i=1 ; i<10 ; i++){
      if(numArray[i]==2)str="Yes" ;
    }
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numArray : Sequence(int) ; numArray := Integer.subrange(1,10)->collect(0) ;
    var str : String ; str := "No" ;
    var numMap : Map(int,int) ; numMap := Map{} ;
    while (sc.hasNext()) do (     var N : int ; N := (sc.getCurrent())->toInteger() ;
     numArray[N+1] := numArray[N+1] + 1 ) ; 
        var i : int ; i := 1 ; while i < 10 do ( (     if (numArray[i+1] = 2) then     str := "Yes" ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    int c=Integer.parseInt(sc.next());
    HashSet<Integer>hs=new HashSet<>();
    hs.add(a);
    hs.add(b);
    hs.add(c);
    if(hs.size()==2){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := (sc.getCurrent())->toInteger() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    var c : int ; c := (sc.getCurrent())->toInteger() ;
    var hs : Set(int) ; hs := Set{} ;
    hs := hs->including(a) ; 
    hs := hs->including(b) ; 
    hs := hs->including(c) ; 
    if (hs->size() = 2) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class demo1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    int x=0 ;
    int l=n-1 ;
    int z=0 ;
    int y=0 ;
    int count1=0 ;
    int count2=0 ;
    for(int i=0 ; i<n ; i++){
      if(z++% 2==0){
        int max=Math.max(arr[x],arr[l]);
        if(max==arr[l]){
          l--;
        }
        else {
          x++;
        }
        count1+=max ;
      }
      else {
        int max=Math.max(arr[x],arr[l]);
        if(max==arr[l]){
          l--;
        }
        else {
          x++;
        }
        count2+=max ;
      }
    }
    System.out.println(count1+" "+count2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class demo1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var x : int ; x := 0 ;
    var l : int ; l := n - 1 ;
    var z : int ; z := 0 ;
    var y : int ; y := 0 ;
    var count1 : int ; count1 := 0 ;
    var count2 : int ; count2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (z mod 2 = 0) then (     var max : int ; max := Set{arr[x+1], arr[l+1]}->max() ;
     if (max = arr[l+1]) then (     l := l - 1 ) else (     x := x + 1 ) ;  
     count1 := count1+(max) ) else (     var max : int ; max := Set{arr[x+1], arr[l+1]}->max() ;
     if (max = arr[l+1]) then (     l := l - 1 ) else (     x := x + 1 ) ;  
     count2 := count2+(max) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count1 + " " + count2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.util.Scanner ;
public class CF586B {
  int n ;
  int[][] a ;
  int[] b ;
  int[] pre,suf ;
  CF586B(){
    Scanner in=new Scanner(new BufferedInputStream(System.in));
    n=in.nextInt();
    a=new int[2][n+10];
    b=new int[n+10];
    pre=new int[n+10];
    suf=new int[n+10];
    for(int i=0 ; i<2 ; i++){
      for(int j=0 ; j<n-1 ; j++){
        a[i][j]=in.nextInt();
      }
    }
    for(int i=0 ; i<n ; i++){
      b[i]=in.nextInt();
      if(i>0)pre[i]=pre[i-1]+a[0][i-1];
    }
    for(int i=n-2 ; i>=0 ; i--){
      suf[i]=suf[i+1]+a[1][i];
    }
    int ans=1000000000 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(i==j)continue ;
        int tmp=b[i]+b[j]+suf[i]+suf[j]+pre[i]+pre[j];
        ans=Math.min(ans,tmp);
      }
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    new CF586B();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF586B {
   attribute n : int;
   attribute a : Sequence(Sequence(int));
   attribute b : Sequence(int);
   attribute pre : Sequence(int);
   static operation newCF586B() : CF586B
  pre: true
  post: true
  activity:
  ( var self : CF586B ;
    self := createCF586B();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     n := in.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,2)->collect(Integer.subrange(1,n + 10)->collect(0)) ; 
    b := Integer.subrange(1,n + 10)->collect(0) ; 
    pre := Integer.subrange(1,n + 10)->collect(0) ; 
    suf := Integer.subrange(1,n + 10)->collect(0) ; 
        var i : int ; i := 0 ; while i < 2 do ( (         var j : int ; j := 0 ; while j < n - 1 do ( (     a[i+1][j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := in.getCurrent()->toInteger() ; 
     if (i > 0) then     pre[i+1] := pre[i - 1+1] + a[0+1][i - 1+1] ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     suf[i+1] := suf[i + 1+1] + a[1+1][i+1] )  ;     i := i - 1 ) ; 
    var ans : int ; ans := 1000000000 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (i = j) then     continue else skip ; 
     var tmp : int ; tmp := b[i+1] + b[j+1] + suf[i+1] + suf[j+1] + pre[i+1] + pre[j+1] ;
     ans := Set{ans, tmp}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( CF586B.newCF586B() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner();
    int n=in.nextInt();
    int[] arr=in.readArray(n);
    int sum1=0 ;
    int sum2=0 ;
    int l=0 ;
    int r=n-1 ;
    boolean order=true ;
    while(l<=r){
      if(arr[l]>arr[r]){
        if(order){
          sum1+=arr[l];
        }
        else {
          sum2+=arr[l];
        }
        l++;
        order=! order ;
      }
      else {
        if(order){
          sum1+=arr[r];
        }
        else {
          sum2+=arr[r];
        }
        r--;
        order=! order ;
      }
    }
    System.out.println(sum1+" "+sum2);
  }
  static final int mod=1_000_000_007 ;
  static class Scanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  static long add(long a,long b){
    return(a+b)% mod ;
  }
  static long sub(long a,long b){
    return((a-b)% mod+mod)% mod ;
  }
  static long mul(long a,long b){
    return(a*b)% mod ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := (arguments ( )) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := in.readArray(n) ;
    var sum1 : int ; sum1 := 0 ;
    var sum2 : int ; sum2 := 0 ;
    var l : int ; l := 0 ;
    var r : int ; r := n - 1 ;
    var order : boolean ; order := true ;
    while (l <= r) do (     if (arr[l+1] > arr[r+1]) then (     if (order) then (     sum1 := sum1+(arr[l+1]) ) else (     sum2 := sum2+(arr[l+1]) ) ;  
     l := l + 1 ; 
     order := not(order) ) else (     if (order) then (     sum1 := sum1+(arr[r+1]) ) else (     sum2 := sum2+(arr[r+1]) ) ;  
     r := r - 1 ; 
     order := not(order) ) ) ; 
    OclFile["System.out"].println(sum1 + " " + sum2) ; 
 );
  static    attribute mod : int := 1_000_000_007;
  static class Scanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   operation add( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a + b) mod mod );
  static   operation sub( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return ((a - b) mod mod + mod) mod mod );
  static   operation mul( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a * b) mod mod );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A381 {
  static Scanner sc=new Scanner();
  public static void main(String[] args){
    solve();
  }
  public static void solve(){
    int n=sc.nextInt();
    int[] arr=sc.readArray(n);
    int player1=0,player2=0 ;
    int count=0 ;
    int i=0,j=n-1 ;
    while(n-->0){
      if(arr[i]>arr[j]){
        if(count % 2==0){
          player1+=arr[i];
        }
        else {
          player2+=arr[i];
        }
        i++;
      }
      else {
        if(count % 2==0){
          player1+=arr[j];
        }
        else {
          player2+=arr[j];
        }
        j--;
      }
      count++;
    }
    System.out.print(player1+" "+player2);
  }
  static class Scanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A381 {
  static   attribute sc : OclFile := (arguments ( ));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := sc.readArray(n) ;
    var player1 : int ; player1 := 0 ;
    var player2 : int ; player2 := 0 ;
    var count : int ; count := 0 ;
    var i : int ; i := 0 ;
    var j : int ; j := n - 1 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     if (arr[i+1] > arr[j+1]) then (     if (count mod 2 = 0) then (     player1 := player1+(arr[i+1]) ) else (     player2 := player2+(arr[i+1]) ) ;  
     i := i + 1 ) else (     if (count mod 2 = 0) then (     player1 := player1+(arr[j+1]) ) else (     player2 := player2+(arr[j+1]) ) ;  
     j := j - 1 ) ;  
     count := count + 1 ) ;  ) ;  
    OclFile["System.out"].print(player1 + " " + player2) ; 
 );
  static class Scanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    DAnOrdinaryGame solver=new DAnOrdinaryGame();
    solver.solve(1,in,out);
    out.close();
  }
  static class DAnOrdinaryGame {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      String s=in.next();
      int l=s.length();
      if(l % 2==0 ^ s.charAt(0)==s.charAt(l-1)){
        out.println("Second");
      }
      else {
        out.println("First");
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : DAnOrdinaryGame ; solver := DAnOrdinaryGame.newDAnOrdinaryGame() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class DAnOrdinaryGame {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.next() ;
     var l : int ; l := s->size() ;
     if (l mod 2 = 0 xor s->at(0+1) = s->at((l)->char2byte() - 1+1)) then (     skip ) else (     skip ) );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class serejaAndDima {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int number=in.nextInt();
    int serj=0 ;
    int dim=0 ;
    int j=number-1 ;
    int c=0 ;
    int[] tos=new int[number];
    for(int i=0 ; i<number ; i++)tos[i]=in.nextInt();
    for(int i=0 ; i<number ; i++){
      if(i % 2==0){
        if(tos[c]>tos[j]){
          serj+=tos[c];
          c++;
        }
        else {
          serj+=tos[j];
          j--;
        }
      }
      else {
        if(tos[c]>tos[j]){
          dim+=tos[c];
          c++;
        }
        else {
          dim+=tos[j];
          j--;
        }
      }
    }
    System.out.println(serj+" "+dim);
  }
}
------------------------------------------------------------
OCL File:
---------
 class serejaAndDima {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := in.getCurrent()->toInteger() ;
    var serj : int ; serj := 0 ;
    var dim : int ; dim := 0 ;
    var j : int ; j := number - 1 ;
    var c : int ; c := 0 ;
    var tos : Sequence(int) ; tos := Integer.subrange(1,number)->collect(0) ;
        var i : int ; i := 0 ; while i < number do (     tos[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < number do ( (     if (i mod 2 = 0) then (     if (tos[c+1] > tos[j+1]) then (     serj := serj+(tos[c+1]) ; 
     c := c + 1 ) else (     serj := serj+(tos[j+1]) ; 
     j := j - 1 ) ) else (     if (tos[c+1] > tos[j+1]) then (     dim := dim+(tos[c+1]) ; 
     c := c + 1 ) else (     dim := dim+(tos[j+1]) ; 
     j := j - 1 ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(serj + " " + dim) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  public static int findLength(String str,int n){
    int current_sum=0 ;
    int max_sum=0 ;
    for(int i=0 ; i<n ; i++){
      current_sum+=(str.charAt(i)=='0' ? 1 :-1);
      if(current_sum<0)current_sum=0 ;
      max_sum=Math.max(current_sum,max_sum);
    }
    return max_sum==0 ?-1 : max_sum ;
  }
  public static void main(String[] args){
    String str="11000010001" ;
    int n=str.length();
    System.out.println(findLength(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findLength( str : String, n : int) : int
  pre: true
  post: true
  activity: (     var current_sum : int ; current_sum := 0 ;
     var max_sum : int ; max_sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     current_sum := current_sum+((if str->at(i+1) = '0' then 1 else -1 endif)) ; 
     if (current_sum < 0) then     current_sum := 0 ; else skip ; 
     max_sum := Set{current_sum, max_sum}->max() )  ;     i := i + 1 ) ; 
     return if max_sum = 0 then -1 else max_sum endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "11000010001" ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].println(findLength(str, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
public final class p169 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p169().run());
  }
  private static final BigInteger NUMBER=BigInteger.TEN.pow(25);
  public String run(){
    return countWays(NUMBER,NUMBER.bitLength()-1,2).toString();
  }
  private Map<List<BigInteger>,BigInteger>ways=new HashMap<>();
  private BigInteger countWays(BigInteger number,int exponent,int repetitions){
    List<BigInteger>key=Arrays.asList(number,BigInteger.valueOf(exponent),BigInteger.valueOf(repetitions));
    if(ways.containsKey(key))return ways.get(key);
    BigInteger result ;
    if(exponent<0)result=number.equals(BigInteger.ZERO)? BigInteger.ONE : BigInteger.ZERO ;
    else {
      result=countWays(number,exponent-1,2);
      BigInteger pow=BigInteger.ONE.shiftLeft(exponent);
      BigInteger upper=pow.multiply(BigInteger.valueOf(repetitions+2));
      if(repetitions>0 && pow.compareTo(number)<=0 && number.compareTo(upper)<0)result=result.add(countWays(number.subtract(pow),exponent,repetitions-1));
    }
    ways.put(key,result);
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class p169 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p169.newp169().run()) );
  static    attribute NUMBER : long := 10.pow(25);
   operation run() : String
  pre: true
  post: true
  activity: (     return countWays(NUMBER, NUMBER.bitLength() - 1, 2)+"" );
   attribute ways : Map(Sequence(long),long) := Map{};
   operation countWays( number : long, exponent : int, repetitions : int) : long
  pre: true
  post: true
  activity: (     var key : Sequence(long) ; key := Sequence{number,(exponent + "")->toLong(),(repetitions + "")->toLong()} ;
     if (ways->keys()->includes(key)) then     return ways->at(key) else skip ; 
    var result : long ;
    if (exponent < 0) then     result := if number = 0 then 1 else 0 endif else (     result := countWays(number, exponent - 1, 2) ; 
     var pow : long ; pow := 1.shiftLeft(exponent) ;
     var upper : long ; upper := pow.multiply((repetitions + 2 + "")->toLong()) ;
     if (repetitions > 0 & pow->compareTo(number) <= 0 & number->compareTo(upper) < 0) then     result := result->excludes(countWays(number.subtract(pow), exponent, repetitions - 1)) ; else skip ) ;  
    ways := ways->union(Map{key |-> result}) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long n=scanner.nextInt();
    for(int i=1 ; ; i++){
      if(fuckLuoGu(n*i+1)){
        System.out.println(i);
        return ;
      }
    }
  }
  private static boolean fuckLuoGu(long n){
    if(n==1)return true ;
    if(n==2)return false ;
    for(int i=2 ; i*i<=n ; i++)if(n % i==0)return true ;
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while true do ( (     if (fuckLuoGu(n * i + 1)) then (     OclFile["System.out"].println(i) ; 
     return ) else skip )  ;     i := i + 1 ) );
  static   operation fuckLuoGu( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n = 1) then     return true else skip ; 
     if (n = 2) then     return false else skip ; 
         var i : int ; i := 2 ; while i * i <= n do (     if (n mod i = 0) then     return true else skip ;  ;     i := i + 1 ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import javax.swing.text.DefaultStyledDocument.ElementSpec ;
public class A_PolandBall_and_Hypothesis {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int N=reader.nextInt();
    if(N<=3){
      System.out.println(N+2);
    }
    else {
      System.out.println(N-2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_PolandBall_and_Hypothesis {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var N : int ; N := reader.nextInt() ;
     if (N <= 3) then (     OclFile["System.out"].println(N + 2) ) else (     OclFile["System.out"].println(N - 2) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solu_33 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    System.out.println(n>2 ? n-2 : n+2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solu_33 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if n > 2 then n - 2 else n + 2 endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long n=scanner.nextInt();
    for(int i=1 ; ; i++){
      if(fuckLuoGu(n*i+1)){
        System.out.println(i);
        return ;
      }
    }
  }
  private static boolean fuckLuoGu(long n){
    if(n==1)return true ;
    if(n==2)return false ;
    for(int i=2 ; i*i<=n ; i++)if(n % i==0)return true ;
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while true do ( (     if (fuckLuoGu(n * i + 1)) then (     OclFile["System.out"].println(i) ; 
     return ) else skip )  ;     i := i + 1 ) );
  static   operation fuckLuoGu( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n = 1) then     return true else skip ; 
     if (n = 2) then     return false else skip ; 
         var i : int ; i := 2 ; while i * i <= n do (     if (n mod i = 0) then     return true else skip ;  ;     i := i + 1 ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B {
  private static Scanner sc ;
  public static void main(String[] args){
    sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[100];
    int b[]=new int[100];
    int c[]=new int[100];
    for(int i=1 ; i<n ; i++)a[i]=sc.nextInt();
    a[0]=0 ;
    for(int i=0 ; i<n-1 ; i++)b[i]=sc.nextInt();
    b[n-1]=0 ;
    for(int i=0 ; i<n ; i++)c[i]=sc.nextInt();
    int min1=100000 ;
    int vt1=0 ;
    for(int i=0 ; i<n ; i++){
      int s=c[i];
      for(int j=0 ; j<n ; j++){
        if(i>=j)s+=a[j];
        if(i<=j)s+=b[j];
      }
      if(min1>s){
        min1=s ;
        vt1=i ;
      }
    }
    int min2=100000 ;
    for(int i=0 ; i<n ; i++){
      int s=c[i];
      for(int j=0 ; j<n ; j++){
        if(j<=i)s+=a[j];
        if(j>=i)s+=b[j];
      }
      if(min2>s && i!=vt1)min2=s ;
    }
    System.out.println(min1+min2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,100)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,100)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,100)->collect(0) ;
        var i : int ; i := 1 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n - 1 do (     b[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    b[n - 1+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do (     c[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var min1 : int ; min1 := 100000 ;
    var vt1 : int ; vt1 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var s : int ; s := c[i+1] ;
         var j : int ; j := 0 ; while j < n do ( (     if (i >= j) then     s := s+(a[j+1]) ; else skip ; 
     if (i <= j) then     s := s+(b[j+1]) ; else skip )  ;     j := j + 1 ) ; 
     if (min1 > s) then (     min1 := s ; 
     vt1 := i ) else skip )  ;     i := i + 1 ) ; 
    var min2 : int ; min2 := 100000 ;
        var i : int ; i := 0 ; while i < n do ( (     var s : int ; s := c[i+1] ;
         var j : int ; j := 0 ; while j < n do ( (     if (j <= i) then     s := s+(a[j+1]) ; else skip ; 
     if (j >= i) then     s := s+(b[j+1]) ; else skip )  ;     j := j + 1 ) ; 
     if (min2 > s & i /= vt1) then     min2 := s ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min1 + min2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Mridul4 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] arr=new int[n];
    int i=-1 ;
    while(i!=n-1){
      i=i+1 ;
      arr[i]=sc.nextInt();
    }
    i=-1 ;
    int u=0 ;
    while(u!=k && i!=n-1){
      i=i+1 ;
      if(arr[i]<0){
        u=u+1 ;
        arr[i]=arr[i]*(-1);
      }
      else {
        break ;
      }
    }
    int min=arr[0],v=0 ;
    i=0 ;
    while(i!=n-1){
      i=i+1 ;
      if(arr[i]<min){
        min=arr[i];
        v=i ;
      }
    }
    if(u!=k){
      while(u!=k){
        u=u+1 ;
        arr[v]=arr[v]*(-1);
      }
    }
    int sum=0 ;
    i=-1 ;
    while(i!=n-1){
      i=i+1 ;
      sum=sum+arr[i];
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mridul4 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var i : int ; i := -1 ;
    while (i /= n - 1) do (     i := i + 1 ; 
     arr[i+1] := sc.getCurrent()->toInteger() ) ; 
    i := -1 ; 
    var u : int ; u := 0 ;
    while (u /= k & i /= n - 1) do (     i := i + 1 ; 
     if (arr[i+1] < 0) then (     u := u + 1 ; 
     arr[i+1] := arr[i+1] * (-1) ) else (     break ) ) ; 
    var min : int ; min := arr[0+1] ;
    var v : int ; v := 0 ;
    i := 0 ; 
    while (i /= n - 1) do (     i := i + 1 ; 
     if (arr[i+1] < min) then (     min := arr[i+1] ; 
     v := i ) else skip ) ; 
    if (u /= k) then (     while (u /= k) do (     u := u + 1 ; 
     arr[v+1] := arr[v+1] * (-1) ) ) else skip ; 
    var sum : int ; sum := 0 ;
    i := -1 ; 
    while (i /= n - 1) do (     i := i + 1 ; 
     sum := sum + arr[i+1] ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class App {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    int[] num=new int[n];
    for(int i=0 ; i<n ; i++){
      num[i]=in.nextInt();
    }
    int sum=0,minn=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(num[i]<0 && k>0){
        num[i]*=-1 ;
        k--;
      }
      sum+=num[i];
      minn=Math.min(minn,num[i]);
    }
    if(k % 2==0){
      System.out.println(sum);
    }
    else {
      System.out.println(sum-2*minn);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var num : Sequence(int) ; num := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     num[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var minn : int ; minn := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     if (num[i+1] < 0 & k > 0) then (     num[i+1] := num[i+1]*(-1) ; 
     k := k - 1 ) else skip ; 
     sum := sum+(num[i+1]) ; 
     minn := Set{minn, num[i+1]}->min() )  ;     i := i + 1 ) ; 
    if (k mod 2 = 0) then (     OclFile["System.out"].println(sum) ) else (     OclFile["System.out"].println(sum - 2 * minn) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static void solve(){
    Scanner sc=new Scanner(System.in);
    String t=sc.next();
    boolean isEven=(t.length()& 1)==0,areEqual=t.charAt(0)==t.charAt(t.length()-1);
    System.out.println(isEven ^ areEqual ? "Second" : "First");
    sc.close();
  }
  public static void main(String args[]){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : String ; t := sc.getCurrent() ;
    var isEven : boolean ; isEven := (MathLib.bitwiseAnd(t->size(),1)) = 0 ;
    var areEqual : boolean ; areEqual := t->at(0+1) = t->at(t->size() - 1+1) ;
    OclFile["System.out"].println(if isEven xor areEqual then "Second" else "First" endif) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int deleteFromStart(int num,int n){
    int d=(int)Math.log10(num)+1 ;
    int rev_new_num=0 ;
    for(int i=0 ; num!=0 ; i++){
      int digit=num % 10 ;
      num=num/10 ;
      if(i==(d-n)){
        continue ;
      }
      else {
        rev_new_num=(rev_new_num*10)+digit ;
      }
    }
    int new_num=0 ;
    for(int i=0 ; rev_new_num!=0 ; i++){
      new_num=(new_num*10)+(rev_new_num % 10);
      rev_new_num=rev_new_num/10 ;
    }
    return new_num ;
  }
  static int deleteFromEnd(int num,int n){
    int rev_new_num=0 ;
    for(int i=1 ; num!=0 ; i++){
      int digit=num % 10 ;
      num=num/10 ;
      if(i==n){
        continue ;
      }
      else {
        rev_new_num=(rev_new_num*10)+digit ;
      }
    }
    int new_num=0 ;
    for(int i=0 ; rev_new_num!=0 ; i++){
      new_num=(new_num*10)+(rev_new_num % 10);
      rev_new_num=rev_new_num/10 ;
    }
    return new_num ;
  }
  public static void main(String[] args){
    int num=1234 ;
    System.out.println("Number: "+num);
    int n=3 ;
    System.out.println("Digit to be deleted: "+n);
    System.out.println("Number after "+n+" digit deleted from starting: "+deleteFromStart(num,n));
    System.out.println("Number after "+n+" digit deleted from ending: "+deleteFromEnd(num,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation deleteFromStart( num : int, n : int) : int
  pre: true
  post: true
  activity: (     var d : int ; d := (num)->log10()->oclAsType(int) + 1 ;
     var rev_new_num : int ; rev_new_num := 0 ;
        var i : int ; i := 0 ; while num /= 0 do ( (     var digit : int ; digit := num mod 10 ;
     num := num / 10 ; 
     if (i = (d - n)) then (     continue ) else (     rev_new_num := (rev_new_num * 10) + digit ) )  ;     i := i + 1 ) ; 
    var new_num : int ; new_num := 0 ;
        var i : int ; i := 0 ; while rev_new_num /= 0 do ( (     new_num := (new_num * 10) + (rev_new_num mod 10) ; 
     rev_new_num := rev_new_num / 10 )  ;     i := i + 1 ) ; 
    return new_num 
 );
  static   operation deleteFromEnd( num : int, n : int) : int
  pre: true
  post: true
  activity: (     var rev_new_num : int ; rev_new_num := 0 ;
         var i : int ; i := 1 ; while num /= 0 do ( (     var digit : int ; digit := num mod 10 ;
     num := num / 10 ; 
     if (i = n) then (     continue ) else (     rev_new_num := (rev_new_num * 10) + digit ) )  ;     i := i + 1 ) ; 
    var new_num : int ; new_num := 0 ;
        var i : int ; i := 0 ; while rev_new_num /= 0 do ( (     new_num := (new_num * 10) + (rev_new_num mod 10) ; 
     rev_new_num := rev_new_num / 10 )  ;     i := i + 1 ) ; 
    return new_num 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 1234 ;
     OclFile["System.out"].println("Number: " + num) ; 
    var n : int ; n := 3 ;
    OclFile["System.out"].println("Digit to be deleted: " + n) ; 
    OclFile["System.out"].println("Number after " + n + " digit deleted from starting: " + deleteFromStart(num, n)) ; 
    OclFile["System.out"].println("Number after " + n + " digit deleted from ending: " + deleteFromEnd(num, n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countPairs(int[] arr1,int[] arr2,int m,int n,int x){
    int count=0 ;
    for(int i=0 ; i<m ; i++)for(int j=0 ; j<n ; j++)if((arr1[i]+arr2[j])==x)count++;
    return count ;
  }
  public static void main(String[] args){
    int arr1[]={
      1,3,5,7 };
      int arr2[]={
        2,3,5,8 };
        int m=arr1.length ;
        int n=arr2.length ;
        int x=10 ;
        System.out.println("Count="+countPairs(arr1,arr2,m,n,x));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPairs( arr1 : Sequence(int), arr2 : Sequence(int), m : int, n : int, x : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < m do (         var j : int ; j := 0 ; while j < n do (     if ((arr1[i+1] + arr2[j+1]) = x) then     count := count + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{1,3,5,7} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{2,3,5,8} ;
    var m : int ; m := arr1->size() ;
    var n : int ; n := arr2->size() ;
    var x : int ; x := 10 ;
    OclFile["System.out"].println("Count=" + countPairs(arr1, arr2, m, n, x)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int largestPower(int x,int P){
    int res=0 ;
    while(x!=0){
      x/=P ;
      res+=x ;
    }
    return res ;
  }
  static int sumOfDivisblePowers(int L,int R,int P){
    return largestPower(R,P)-largestPower(L-1,P);
  }
  public static void main(String[] args){
    int L=1,R=10,P=2 ;
    System.out.println(sumOfDivisblePowers(L,R,P));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation largestPower( x : int, P : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     while (x /= 0) do (     x := x/(P) ; 
     res := res+(x) ) ; 
     return res );
  static   operation sumOfDivisblePowers( L : int, R : int, P : int) : int
  pre: true
  post: true
  activity: (     return largestPower(R, P) - largestPower(L - 1, P) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 1 ;
    var R : int ; R := 10 ;
    var P : int ; P := 2 ;
     OclFile["System.out"].println(sumOfDivisblePowers(L, R, P)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sumOfDivisblePowers(int L,int R,int P){
    int res=0 ;
    for(int i=L ; i<=R ; i++){
      int x=i ;
      while(x % P==0){
        res++;
        x/=P ;
      }
    }
    return res ;
  }
  public static void main(String[] args){
    int L=1,R=10,P=2 ;
    System.out.println(sumOfDivisblePowers(L,R,P));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumOfDivisblePowers( L : int, R : int, P : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := L ; while i <= R do ( (     var x : int ; x := i ;
     while (x mod P = 0) do (     res := res + 1 ; 
     x := x/(P) ) )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 1 ;
    var R : int ; R := 10 ;
    var P : int ; P := 2 ;
     OclFile["System.out"].println(sumOfDivisblePowers(L, R, P)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] $){
    int n=new Scanner(System.in).nextInt();
    long sum=0 ;
    for(int i=5 ; n>0 ; i++){
      if(n==2){
        i=(i+60)/30*30 ;
        System.out.println(sum % 2+2);
        System.out.println(i-(sum+sum % 2+2)% 30);
        return ;
      }
      if(i % 2!=0 && i % 3!=0 && i % 5!=0){
        continue ;
      }
      System.out.println(i);
      sum+=i ;
      n--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := OclFile.newOclFile_Read(OclFile["System.in"]).nextInt() ;
     var sum : long ; sum := 0 ;
         var i : int ; i := 5 ; while n > 0 do ( (     if (n = 2) then (     i := (i + 60) / 30 * 30 ; 
     OclFile["System.out"].println(sum mod 2 + 2) ; 
     OclFile["System.out"].println(i - (sum + sum mod 2 + 2) mod 30) ; 
     return ) else skip ; 
     if (i mod 2 /= 0 & i mod 3 /= 0 & i mod 5 /= 0) then (     continue ) else skip ; 
    OclFile["System.out"].println(i) ; 
    sum := sum+(i) ; 
    n := n - 1 ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    if(N==3){
      System.out.println("2 5 63");
      System.exit(0);
    }
    System.out.print("2 3");
    int elmNum=2 ;
    int elm=4 ;
    int sum=5 ;
    while(elmNum<N-2){
      if(elm % 2==0 || elm % 3==0){
        System.out.print(" "+elm);
        elmNum++;
        sum+=elm ;
      }
      elm++;
    }
    switch(sum % 6){
      case 0 : System.out.println(" 29994 30000");
      break ;
      case 1 : System.out.println(" 29996 29997");
      break ;
      case 2 : System.out.println(" 29998 30000");
      break ;
      case 3 : System.out.println(" 29997 30000");
      break ;
      case 4 : System.out.println(" 29996 30000");
      break ;
      case 5 : System.out.println(" 29997 29998");
      break ;
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    if (N = 3) then (     OclFile["System.out"].println("2 5 63") ; 
 OclProcess.exit(0) ) else skip ; 
    OclFile["System.out"].print("2 3") ; 
    var elmNum : int ; elmNum := 2 ;
    var elm : int ; elm := 4 ;
    var sum : int ; sum := 5 ;
    while (elmNum < N - 2) do (     if (elm mod 2 = 0 or elm mod 3 = 0) then (     OclFile["System.out"].print(" " + elm) ; 
     elmNum := elmNum + 1 ; 
     sum := sum+(elm) ) else skip ; 
     elm := elm + 1 ) ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (sum mod 6) ; 
       if _switchval = 0 then
     OclFile["System.out"].println(" 29994 30000") ; 
    break 
   else skip ;
       if _switchval = 1 then
     OclFile["System.out"].println(" 29996 29997") ; 
    break 
   else skip ;
       if _switchval = 2 then
     OclFile["System.out"].println(" 29998 30000") ; 
    break 
   else skip ;
       if _switchval = 3 then
     OclFile["System.out"].println(" 29997 30000") ; 
    break 
   else skip ;
       if _switchval = 4 then
     OclFile["System.out"].println(" 29996 30000") ; 
    break 
   else skip ;
       if _switchval = 5 then
     OclFile["System.out"].println(" 29997 29998") ; 
    break 
   else skip ;
 )
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    List<Integer>ans=new ArrayList<>();
    if(N==3){
      ans.add(2);
      ans.add(5);
      ans.add(63);
    }
    else {
      ans.add(3);
      ans.add(29997);
      ans.add(2);
      ans.add(4);
      N-=4 ;
      int even=10 ;
      int oddup=6 ;
      int odddown=29994 ;
      while(N>0){
        if(N==1){
          ans.add(30000);
          break ;
        }
        if(even<30000){
          ans.add(even);
          ans.add(even-2);
          even+=6 ;
        }
        else {
          if(oddup==odddown){
            ans.add(oddup);
            ans.add(30000);
          }
          else {
            ans.add(oddup);
            ans.add(odddown);
            oddup+=3 ;
            odddown-=3 ;
          }
        }
        N-=2 ;
      }
    }
    for(int i : ans)System.out.print(i+" ");
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var ans : Sequence(int) ; ans := Sequence{} ;
    if (N = 3) then (     ans := ans->including(2) ; 
     ans := ans->including(5) ; 
     ans := ans->including(63) ) else (     ans := ans->including(3) ; 
     ans := ans->including(29997) ; 
    ans := ans->including(2) ; 
    ans := ans->including(4) ; 
    N := N-(4) ; 
    var even : int ; even := 10 ;
    var oddup : int ; oddup := 6 ;
    var odddown : int ; odddown := 29994 ;
    while (N > 0) do (     if (N = 1) then (     ans := ans->including(30000) ; 
     break ) else skip ; 
     if (even < 30000) then (     ans := ans->including(even) ; 
     ans := ans->including(even - 2) ; 
     even := even+(6) ) else (     if (oddup = odddown) then (     ans := ans->including(oddup) ; 
     ans := ans->including(30000) ) else (     ans := ans->including(oddup) ; 
     ans := ans->including(odddown) ; 
     oddup := oddup+(3) ; 
     odddown := odddown-(3) ) ) ;  
     N := N-(2) ) ; 
 ) ;  
    for (i : ans) do (     OclFile["System.out"].print(i + " ") ;  ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Solver {
  Scanner sc=new Scanner(System.in);
  void run(){
    int n=sc.nextInt();
    solve(n);
  }
  void solve(int n){
    int[] ans=new int[n];
    int count=64 ;
    ans[0]=2 ;
    ans[1]=5 ;
    ans[2]=63 ;
    int sum=70 ;
    if(n==3){
      System.out.println("2 5 63");
      return ;
    }
    if(n==4){
      System.out.println("2 5 63 80");
      return ;
    }
    if(n==5){
      System.out.println("2 5 63 64 76");
      return ;
    }
    for(int i=3 ; i<n-2 ; i++){
      for(; count % 2!=0 && count % 5!=0 && count % 3!=0 ; count++){
      }
      ans[i]=count ;
      sum+=count ;
      sum %=30 ;
      count++;
    }
    for(; count % 2!=sum % 2 || count % 5!=0 && count % 3!=0 ; count++){
    }
    ans[n-2]=count ;
    sum+=count ;
    sum %=30 ;
    count++;
    ans[n-1]=count+30-((count+sum)% 30);
    long mysum=0 ;
    for(int i=0 ; i<n-1 ; i++){
      System.out.print(ans[i]);
      System.out.print(" ");
      mysum+=ans[i];
    }
    System.out.println(ans[n-1]);
  }
}
public class Main {
  public static void main(String[] args){
    Solver s=new Solver();
    s.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solver {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     execute solve(n) );
   operation solve( n : int) : void
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
     var count : int ; count := 64 ;
    ans[0+1] := 2 ; 
    ans[1+1] := 5 ; 
    ans[2+1] := 63 ; 
    var sum : int ; sum := 70 ;
    if (n = 3) then (     OclFile["System.out"].println("2 5 63") ; 
     return ) else skip ; 
    if (n = 4) then (     OclFile["System.out"].println("2 5 63 80") ; 
     return ) else skip ; 
    if (n = 5) then (     OclFile["System.out"].println("2 5 63 64 76") ; 
     return ) else skip ; 
        var i : int ; i := 3 ; while i < n - 2 do ( (       while count mod 2 /= 0 & count mod 5 /= 0 & count mod 3 /= 0 do ( skip  ;     count := count + 1 ) ; 
     ans[i+1] := count ; 
    sum := sum+(count) ; 
    sum := sum mod 30 ; 
    count := count + 1 ; 
 )  ;     i := i + 1 ) ; 
      while count mod 2 /= sum mod 2 or count mod 5 /= 0 & count mod 3 /= 0 do ( skip  ;     count := count + 1 ) ; 
    ans[n - 2+1] := count ; 
    sum := sum+(count) ; 
    sum := sum mod 30 ; 
    count := count + 1 ; 
    ans[n - 1+1] := count + 30 - ((count + sum) mod 30) ; 
    var mysum : long ; mysum := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     OclFile["System.out"].print(ans[i+1]) ; 
     OclFile["System.out"].print(" ") ; 
     mysum := mysum+(ans[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans[n - 1+1]) ; 
 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Solver ; s := Solver.newSolver() ;
     s.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=100 ;
  static int[] store=new int[MAX];
  static int n ;
  static int[][] graph=new int[MAX][MAX];
  static int[] d=new int[MAX];
  static boolean is_clique(int b){
    for(int i=1 ; i<b ; i++){
      for(int j=i+1 ; j<b ; j++)if(graph[store[i] ][store[j] ]==0)return false ;
    }
    return true ;
  }
  static void print(int n){
    for(int i=1 ; i<n ; i++)System.out.print(store[i]+" ");
    System.out.print(",");
  }
  static void findCliques(int i,int l,int s){
    for(int j=i+1 ; j<=n-(s-l); j++)if(d[j]>=s-1){
      store[l]=j ;
      if(is_clique(l+1))if(l<s)findCliques(j,l+1,s);
      else print(l+1);
    }
  }
  public static void main(String[] args){
    int edges[][]={
      {
        1,2 },{
          2,3 },{
            3,1 },{
              4,3 },{
                4,5 },{
                  5,3 }
                },k=3 ;
                int size=edges.length ;
                n=5 ;
                for(int i=0 ; i<size ; i++){
                  graph[edges[i][0] ][edges[i][1] ]=1 ;
                  graph[edges[i][1] ][edges[i][0] ]=1 ;
                  d[edges[i][0] ]++;
                  d[edges[i][1] ]++;
                }
                findCliques(0,1,k);
              }
            }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100;
  static   attribute store : Sequence(int) := Integer.subrange(1,MAX)->collect(0);
  static   attribute n : int;
  static   attribute graph : Sequence(Sequence(int)) := Integer.subrange(1,MAX)->collect(Integer.subrange(1,MAX)->collect(0));
  static   attribute d : Sequence(int) := Integer.subrange(1,MAX)->collect(0);
  static   operation is_clique( b : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < b do ( (         var j : int ; j := i + 1 ; while j < b do (     if (graph[store[i+1]+1][store[j+1]+1] = 0) then     return false else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return true );
  static   operation print( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < n do (     OclFile["System.out"].print(store[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(",") );
  static   operation findCliques( i : int, l : int, s : int) : void
  pre: true
  post: true
  activity: (         var j : int ; j := i + 1 ; while j <= n - (s - l) do (     if (d[j+1] >= s - 1) then (     store[l+1] := j ; 
     if (is_clique(l + 1)) then     if (l < s) then     execute findCliques(j, l + 1, s) else     execute print(l + 1) ; ;  else skip ) else skip ;  ;     j := j + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var edges : Sequence(Sequence(int)) ; edges := Sequence{Sequence{1,2},Sequence{2,3},Sequence{3,1},Sequence{4,3},Sequence{4,5},Sequence{5,3}} ;
    var k : int ; k := 3 ;
     var size : int ; size := edges->size() ;
    n := 5 ; 
        var i : int ; i := 0 ; while i < size do ( (     graph[edges[i+1][0+1]+1][edges[i+1][1+1]+1] := 1 ; 
     graph[edges[i+1][1+1]+1][edges[i+1][0+1]+1] := 1 ; 
     d[edges[i+1][0+1]+1] := d[edges[i+1][0+1]+1] + 1 ; 
     d[edges[i+1][1+1]+1] := d[edges[i+1][1+1]+1] + 1 )  ;     i := i + 1 ) ; 
    execute findCliques(0, 1, k) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    sc.close();
    long sum=0 ;
    int tmp=2 ;
    StringBuilder sb=new StringBuilder();
    ArrayList al=new ArrayList<Integer>();
    if(n==3){
      System.out.println("2 5 63");
      return ;
    }
    if(n==4){
      System.out.println("2 5 20 63");
      return ;
    }
    if(n==5){
      System.out.println("2 5 30 50 63");
      return ;
    }
    for(int i=0 ; i<n ; i++){
      while(true){
        if(tmp % 2==0 || tmp % 3==0){
          al.add(tmp);
          sum+=tmp ;
          tmp++;
          break ;
        }
        tmp++;
      }
    }
    if(sum % 6==0){
    }
    else if(sum % 6==2){
      al.removeAll(Arrays.asList(new Integer[] {
        8 }
));
        al.add(30000);
      }
      else if(sum % 6==3){
        al.removeAll(Arrays.asList(new Integer[] {
          9 }
));
          al.add(30000);
        }
        else if(sum % 6==5){
          al.removeAll(Arrays.asList(new Integer[] {
            9 }
));
            al.add(29998);
          }
          for(int i=0 ; i<n ; i++){
            sb.append(al.get(i));
            sb.append(" ");
          }
          System.out.println(new String(sb));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
    var sum : long ; sum := 0 ;
    var tmp : int ; tmp := 2 ;
    var sb : String ; sb := StringLib.newString() ;
    var al : Sequence ; al := Sequence{} ;
    if (n = 3) then (     OclFile["System.out"].println("2 5 63") ; 
     return ) else skip ; 
    if (n = 4) then (     OclFile["System.out"].println("2 5 20 63") ; 
     return ) else skip ; 
    if (n = 5) then (     OclFile["System.out"].println("2 5 30 50 63") ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     while (true) do (     if (tmp mod 2 = 0 or tmp mod 3 = 0) then (     al := al->including(tmp) ; 
     sum := sum+(tmp) ; 
     tmp := tmp + 1 ; 
     break ) else skip ; 
     tmp := tmp + 1 ) )  ;     i := i + 1 ) ; 
    if (sum mod 6 = 0) then skip else     if (sum mod 6 = 2) then (     al := al - Sequence{8} ; 
     al := al->including(30000) ) else     if (sum mod 6 = 3) then (     al := al - Sequence{9} ; 
     al := al->including(30000) ) else     if (sum mod 6 = 5) then (     al := al - Sequence{9} ; 
     al := al->including(29998) ) else skip ; ;  ;  ;  
        var i : int ; i := 0 ; while i < n do ( (     sb := sb + StringLib.newString(al->at(i+1)) ; 
     sb := sb + StringLib.newString(" ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(StringLib.newString(sb)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.ListIterator ;
import java.util.stream.Collectors ;
public final class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String in=br.readLine();
    System.out.println(new Solver().solve(in));
  }
}
class Solver {
  String solve(String in){
    String turn="First" ;
    List<Character>l=in.chars().mapToObj(c->(char)c).collect(Collectors.toList());
    LinkedList<Character>ll=new LinkedList<Character>(l);
    ListIterator<Character>li=ll.listIterator(1);
    boolean yes=true ;
    while(ll.size()>2 && li.nextIndex()<ll.size()-1){
      char prev=(char)li.previous();
      li.next();
      li.next();
      char next=(char)li.next();
      li.previous();
      li.previous();
      if(prev==next){
        li.next();
      }
      else {
        li.remove();
        if(li.previousIndex()>0)li.previous();
        if(turn.equalsIgnoreCase("First")){
          turn="Second" ;
        }
        else turn="First" ;
      }
    }
    return turn.equalsIgnoreCase("First")? "Second" : "First" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var in : String ; in := br.readLine() ;
     OclFile["System.out"].println(Solver.newSolver().solve(in)) );
}
class Solver {
   operation solve( in : String) : String
  pre: true
  post: true
  activity: (     var turn : String ; turn := "First" ;
     var l : Sequence(String) ; l := in.chars().mapToObj(lambda c : OclAny in c->oclAsType(String)).collect(Collectors.toList()) ;
    var ll : Sequence(String) ; ll := Sequence{}->union(l) ;
    var li : ListIterator<String> ; li := ll.subrange(1+1)->iterator() ;
    var yes : boolean ; yes := true ;
    while (ll->size() > 2 & li.nextIndex() < ll->size() - 1) do (     var prev : String ; prev := li.previous()->oclAsType(String) ;
     li.next() ; 
    li.next() ; 
    var next : String ; next := li.next()->oclAsType(String) ;
    li.previous() ; 
    li.previous() ; 
    if (prev = next) then (     li.next() ) else (     li := li.remove() ; 
     if (li.previousIndex() > 0) then     li.previous() ; else skip ; 
     if (turn->equalsIgnoreCase("First")) then (     turn := "Second" ) else     turn := "First" ; ) ;  
 ) ; 
    return if turn->equalsIgnoreCase("First") then "Second" else "First" endif 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p106 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p106().run());
  }
  private static final int SET_SIZE=12 ;
  public String run(){
    BigInteger ans=BigInteger.ZERO ;
    for(int i=2 ; i*2<=SET_SIZE ; i++){
      BigInteger x=Library.binomial(SET_SIZE,i*2);
      BigInteger y=Library.binomial(i*2,i).shiftRight(1);
      BigInteger z=Library.binomial(i*2,i).divide(BigInteger.valueOf(i+1));
      ans=ans.add(x.multiply(y.subtract(z)));
    }
    return ans.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class p106 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p106.newp106().run()) );
  static    attribute SET_SIZE : int := 12;
   operation run() : String
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
         var i : int ; i := 2 ; while i * 2 <= SET_SIZE do ( (     var x : long ; x := Library.binomial(SET_SIZE, i * 2) ;
     var y : long ; y := Library.binomial(i * 2, i).shiftRight(1) ;
     var z : long ; z := Library.binomial(i * 2, i).divide((i + 1 + "")->toLong()) ;
     ans := ans->excludes(x.multiply(y.subtract(z))) )  ;     i := i + 1 ) ; 
     return ans+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class geeks {
  public static long countSubseq(int[] arr,int n){
    HashMap<Integer,Integer>um=new HashMap<>();
    long count=1 ;
    for(int i=0 ; i<n ; i++){
      if(um.get(arr[i])!=null){
        int a=um.get(arr[i]);
        um.put(arr[i],++a);
      }
      else um.put(arr[i],1);
    }
    for(HashMap.Entry<Integer,Integer>entry : um.entrySet()){
      count*=entry.getValue();
    }
    return count ;
  }
  public static void main(String[] args){
    int[] arr={
      4,7,6,7 };
      int n=arr.length ;
      System.out.println("Count="+countSubseq(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class geeks {
  static   operation countSubseq( arr : Sequence(int), n : int) : long
  pre: true
  post: true
  activity: (     var um : Map(int,int) ; um := Map{} ;
     var count : long ; count := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (um->at(arr[i+1]) /= null) then (     var a : int ; a := um->at(arr[i+1]) ;
     um := um->union(Map{arr[i+1] |-> (a + 1)}) ) else     um := um->union(Map{arr[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
    for (entry : um->asSet()) do ( (     count := count*(entry.getValue()) )  ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,7,6,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Count=" + countSubseq(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static int firstDigit(int n){
    while(n>=10)n/=10 ;
    return n ;
  }
  public static int lastDigit(int n){
    return(n % 10);
  }
  public static void main(String argc[]){
    int n=98562 ;
    System.out.println(firstDigit(n)+" "+lastDigit(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation firstDigit( n : int) : int
  pre: true
  post: true
  activity: (     while (n >= 10) do     n := n/(10) ; ; 
     return n );
  static   operation lastDigit( n : int) : int
  pre: true
  post: true
  activity: (     return (n mod 10) );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 98562 ;
     OclFile["System.out"].println(firstDigit(n) + " " + lastDigit(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int isPowerOfFour(int n){
    if(n==0)return 0 ;
    while(n!=1){
      if(n % 4!=0)return 0 ;
      n=n/4 ;
    }
    return 1 ;
  }
  public static void main(String[] args){
    int test_no=64 ;
    if(isPowerOfFour(test_no)==1)System.out.println(test_no+" is a power of 4");
    else System.out.println(test_no+"is not a power of 4");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPowerOfFour( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else skip ; 
     while (n /= 1) do (     if (n mod 4 /= 0) then     return 0 else skip ; 
     n := n / 4 ) ; 
     return 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var test_no : int ; test_no := 64 ;
     if (isPowerOfFour(test_no) = 1) then     OclFile["System.out"].println(test_no + " is a power of 4") ; else     OclFile["System.out"].println(test_no + "is not a power of 4") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int isPowerOfFour(int n){
    int count=0 ;
    int x=n &(n-1);
    if(n>0 && x==0){
      while(n>1){
        n>>=1 ;
        count+=1 ;
      }
      return(count % 2==0)? 1 : 0 ;
    }
    return 0 ;
  }
  public static void main(String[] args){
    int test_no=64 ;
    if(isPowerOfFour(test_no)>0)System.out.println(test_no+" is a power of 4");
    else System.out.println(test_no+" is not a power of 4");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPowerOfFour( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var x : int ; x := MathLib.bitwiseAnd(n,(n - 1)) ;
     if (n > 0 & x = 0) then (     while (n > 1) do (     n := n/(2->pow(1)) ; 
     count := count+(1) ) ; 
     return if (count mod 2 = 0) then 1 else 0 endif ) else skip ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var test_no : int ; test_no := 64 ;
     if (isPowerOfFour(test_no) > 0) then     OclFile["System.out"].println(test_no + " is a power of 4") ; else     OclFile["System.out"].println(test_no + " is not a power of 4") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isPowerOfFour(int n){
    return n!=0 &&((n &(n-1))==0)&&(n & 0xAAAAAAAA)==0 ;
  }
  public static void main(String[] args){
    int test_no=64 ;
    if(isPowerOfFour(test_no))System.out.println(test_no+" is a power of 4");
    else System.out.println(test_no+" is not a power of 4");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPowerOfFour( n : int) : boolean
  pre: true
  post: true
  activity: (     return n /= 0 & ((n & (n - 1)) = 0) & (n & 0xAAAAAAAA) = 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var test_no : int ; test_no := 64 ;
     if (isPowerOfFour(test_no)) then     OclFile["System.out"].println(test_no + " is a power of 4") ; else     OclFile["System.out"].println(test_no + " is not a power of 4") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String recursiveFun(int n){
    if(n==1)return "int" ;
    return "gcd(int,"+recursiveFun(n-1)+")" ;
  }
  public static void main(String[] arg){
    int n=5 ;
    System.out.println(recursiveFun(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation recursiveFun( n : int) : String
  pre: true
  post: true
  activity: (     if (n = 1) then     return "int" else skip ; 
     return "gcd(int," + recursiveFun(n - 1) + ")" );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(recursiveFun(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1000 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int[] A=new int[N+2];
    A[N+1]=in.nextInt();
    for(int n=1 ; n<=N ; n++){
      A[n]=in.nextInt();
    }
    int[] sumFrom=new int[N+1];
    sumFrom[N]=A[N+1]-A[N];
    sumFrom[N-1]=A[N]-A[N-1];
    for(int n=N-2 ; n>=0 ; n--){
      sumFrom[n]=sumFrom[n+2]+A[n+1]-A[n];
    }
    int max=sumFrom[0];
    for(int n=0 ; n<=N ; n++){
      int segment=A[n+1]-A[n];
      if(segment>1){
        int sum ;
        if(n % 2==0){
          sum=sumFrom[0]-sumFrom[n];
          sum+=segment-1 ;
          sum+=((n==N)? 0 : sumFrom[n+1]);
        }
        else {
          sum=sumFrom[0]-((n==N)? 0 : sumFrom[n+1]);
          sum+=sumFrom[n]-1 ;
        }
        max=Math.max(max,sum);
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1000 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N + 2)->collect(0) ;
    A[N + 1+1] := in.getCurrent()->toInteger() ; 
        var n : int ; n := 1 ; while n <= N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var sumFrom : Sequence(int) ; sumFrom := Integer.subrange(1,N + 1)->collect(0) ;
    sumFrom[N+1] := A[N + 1+1] - A[N+1] ; 
    sumFrom[N - 1+1] := A[N+1] - A[N - 1+1] ; 
        var n : int ; n := N - 2 ; while n >= 0 do ( (     sumFrom[n+1] := sumFrom[n + 2+1] + A[n + 1+1] - A[n+1] )  ;     n := n - 1 ) ; 
    var max : int ; max := sumFrom[0+1] ;
        var n : int ; n := 0 ; while n <= N do ( (     var segment : int ; segment := A[n + 1+1] - A[n+1] ;
     if (segment > 1) then (     var sum : int ;
     if (n mod 2 = 0) then (     sum := sumFrom[0+1] - sumFrom[n+1] ; 
     sum := sum+(segment - 1) ; 
     sum := sum+((if (n = N) then 0 else sumFrom[n + 1+1] endif)) ) else (     sum := sumFrom[0+1] - (if (n = N) then 0 else sumFrom[n + 1+1] endif) ; 
     sum := sum+(sumFrom[n+1] - 1) ) ;  
     max := Set{max, sum}->max() ) else skip )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TernaryLogic {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int a=scanner.nextInt();
    int b=scanner.nextInt();
    String sa=toMod3(a);
    String sc=toMod3(b);
    int n=Math.max(sa.length(),sc.length());
    sa=padZeros(sa,n);
    sc=padZeros(sc,n);
    StringBuilder result=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      int ca=Integer.parseInt(String.valueOf(sa.charAt(i)));
      int cc=Integer.parseInt(String.valueOf(sc.charAt(i)));
      int cb=cc-ca ;
      if(cb<0){
        cb+=3 ;
      }
      result.append(cb);
    }
    System.out.println(toMod10(result.toString()));
  }
  private static int toMod10(String a){
    int base=1 ;
    int result=0 ;
    for(int i=a.length()-1 ; i>=0 ; i--){
      int val=Integer.parseInt(String.valueOf(a.charAt(i)));
      result+=val*base ;
      base*=3 ;
    }
    return result ;
  }
  private static String padZeros(String sa,int length){
    String result=sa ;
    for(int i=0 ; i<length-sa.length(); i++){
      result="0"+result ;
    }
    return result ;
  }
  private static String toMod3(int a){
    StringBuilder sb=new StringBuilder();
    while(a>0){
      int remaining=a % 3 ;
      sb.append(remaining);
      a=a/3 ;
    }
    return sb.reverse().toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class TernaryLogic {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var sa : String ; sa := toMod3(a) ;
    var sc : String ; sc := toMod3(b) ;
    var n : int ; n := Set{sa->size(), sc->size()}->max() ;
    sa := padZeros(sa, n) ; 
    sc := padZeros(sc, n) ; 
    var result : String ; result := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     var ca : int ; ca := (((sa->at(i+1)) + ""))->toInteger() ;
     var cc : int ; cc := (((sc->at(i+1)) + ""))->toInteger() ;
    var cb : int ; cb := cc - ca ;
    if (cb < 0) then (     cb := cb+(3) ) else skip ; 
    result := result + StringLib.newString(cb) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(toMod10(result+"")) ; 
 );
  static   operation toMod10( a : String) : int
  pre: true
  post: true
  activity: (     var base : int ; base := 1 ;
     var result : int ; result := 0 ;
         var i : int ; i := a->size() - 1 ; while i >= 0 do ( (     var val : int ; val := (((a->at(i+1)) + ""))->toInteger() ;
     result := result+(val * base) ; 
     base := base*(3) )  ;     i := i - 1 ) ; 
     return result );
  static   operation padZeros( sa : String, length : int) : String
  pre: true
  post: true
  activity: (     var result : String ; result := sa ;
         var i : int ; i := 0 ; while i < length - sa->size() do ( (     result := "0" + result )  ;     i := i + 1 ) ; 
     return result );
  static   operation toMod3( a : int) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     while (a > 0) do (     var remaining : int ; remaining := a mod 3 ;
     sb := sb + StringLib.newString(remaining) ; 
     a := a / 3 ) ; 
     return sb->reverse()+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class MyClass {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int a[]=new int[100];
    int b[]=new int[100];
    String ho=br.readLine();
    String aw=br.readLine();
    String[] me=new String[91];
    int n=Integer.parseInt(br.readLine());
    for(int i=0 ; i<n ; i++){
      StringTokenizer st=new StringTokenizer(br.readLine());
      int min=Integer.parseInt(st.nextToken());
      char c=st.nextToken().charAt(0);
      int p=Integer.parseInt(st.nextToken());
      char c2=st.nextToken().charAt(0);
      if(c=='h'){
        if((a[p]>0 || c2=='r')&& a[p]<2){
          me[min]=ho+" "+p+" "+min ;
          a[p]+=10 ;
        }
        else a[p]++;
      }
      else {
        if((b[p]>0 || c2=='r')&& b[p]<2){
          me[min]=aw+" "+p+" "+min ;
          b[p]+=10 ;
        }
        else b[p]++;
      }
    }
    for(int i=0 ; i<me.length ; i++){
      if(me[i]!=null)System.out.println((me[i]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var a : Sequence(int) ; a := Integer.subrange(1,100)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,100)->collect(0) ;
    var ho : String ; ho := br.readLine() ;
    var aw : String ; aw := br.readLine() ;
    var me : Sequence(String) ; me := Integer.subrange(1,91)->collect(null) ;
    var n : int ; n := (br.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var min : int ; min := (st.next())->toInteger() ;
    var c : String ; c := st.next()->at(0+1) ;
    var p : int ; p := (st.next())->toInteger() ;
    var c2 : String ; c2 := st.next()->at(0+1) ;
    if (c = 'h') then (     if ((a[p+1] > 0 or c2 = 'r') & a[p+1] < 2) then (     me[min+1] := ho + " " + p + " " + min ; 
     a[p+1] := a[p+1]+(10) ) else     a[p+1] := a[p+1] + 1 ; ) else (     if ((b[p+1] > 0 or c2 = 'r') & b[p+1] < 2) then (     me[min+1] := aw + " " + p + " " + min ; 
     b[p+1] := b[p+1]+(10) ) else     b[p+1] := b[p+1] + 1 ; ) ;  
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < me->size() do ( (     if (me[i+1] /= null) then     OclFile["System.out"].println((me[i+1])) ; else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    int[] a=new int[100010];
    a[0]=sc.nextInt();
    int c=1 ;
    for(int i=1 ; i<n ; i++){
      int tmp=sc.nextInt();
      if(a[c-1]==tmp)continue ;
      a[c++]=tmp ;
    }
    List<Integer>l=new ArrayList<>();
    c=0 ;
    int ret=0 ;
    while(true){
      int tmp=a[c++];
      if(tmp==0){
        ret++;
        break ;
      }
      l.add(tmp);
      if(l.size()<=2)continue ;
      if(i(l)|| d(l)){
        l.remove(0);
        continue ;
      }
      else {
        l.clear();
        l.add(tmp);
        ret++;
      }
    }
    System.out.println(ret);
  }
  private static boolean i(List<Integer>l){
    for(int i=1 ; i<l.size(); i++){
      if(l.get(i-1)>l.get(i))return false ;
    }
    return true ;
  }
  private static boolean d(List<Integer>l){
    for(int i=1 ; i<l.size(); i++){
      if(l.get(i-1)<l.get(i))return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,100010)->collect(0) ;
    a[0+1] := sc.getCurrent()->toInteger() ; 
    var c : int ; c := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     var tmp : int ; tmp := sc.getCurrent()->toInteger() ;
     if (a[c - 1+1] = tmp) then     continue else skip ; 
      a[c+1] := tmp  ; c := c + 1 )  ;     i := i + 1 ) ; 
    var l : Sequence(int) ; l := Sequence{} ;
    c := 0 ; 
    var ret : int ; ret := 0 ;
    while (true) do (     var tmp : int ; tmp := a[c+1] ;
     if (tmp = 0) then (     ret := ret + 1 ; 
     break ) else skip ; 
    l := l->including(tmp) ; 
    if (l->size() <= 2) then     continue else skip ; 
    if (i(l) or d(l)) then (     l := l->excludingAt(0+1) ; 
     continue ) else (     l := l->intersection(Set{}) ; 
     l := l->including(tmp) ; 
     ret := ret + 1 ) ;  
 ) ; 
    OclFile["System.out"].println(ret) ; 
 );
  static   operation i( l : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < l->size() do ( (     if (l->at(i - 1+1) > l->at(i+1)) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation d( l : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < l->size() do ( (     if (l->at(i - 1+1) < l->at(i+1)) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countMinimumMoves(int arr[],int n,int k){
    int i ;
    for(i=k-1 ; i<n ; i++)if(arr[i]!=arr[k-1])return-1 ;
    for(i=k-1 ; i>=0 ; i--)if(arr[i]!=arr[k-1])return i+1 ;
    return 0 ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4 };
      int K=4 ;
      int n=arr.length ;
      System.out.print(countMinimumMoves(arr,n,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countMinimumMoves( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
         i := k - 1 ; while i < n do (     if (arr[i+1] /= arr[k - 1+1]) then     return -1 else skip ;  ;     i := i + 1 ) ; 
         i := k - 1 ; while i >= 0 do (     if (arr[i+1] /= arr[k - 1+1]) then     return i + 1 else skip ;  ;     i := i - 1 ) ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4} ;
     var K : int ; K := 4 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(countMinimumMoves(arr, n, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TernaryLogic {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int c=sc.nextInt();
    int b=0,multiple=1 ;
    while(a>0 || c>0){
      b+=((c % 3-a % 3+3)% 3)*multiple ;
      multiple*=3 ;
      a/=3 ;
      c/=3 ;
    }
    System.out.println(b);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class TernaryLogic {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var b : int ; b := 0 ;
    var multiple : int ; multiple := 1 ;
    while (a > 0 or c > 0) do (     b := b+(((c mod 3 - a mod 3 + 3) mod 3) * multiple) ; 
     multiple := multiple*(3) ; 
     a := a/(3) ; 
     c := c/(3) ) ; 
    OclFile["System.out"].println(b) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int NumberOfSolutions(int a,int b,int c,int d){
    int ans=0 ;
    for(int i=a ; i<=b ; i++)if(d>=Math.max(c,i+1))ans+=d-Math.max(c,i+1)+1 ;
    return ans ;
  }
  public static void main(String[] args){
    int a=2,b=3,c=3,d=4 ;
    System.out.println(NumberOfSolutions(a,b,c,d));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation NumberOfSolutions( a : int, b : int, c : int, d : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := a ; while i <= b do (     if (d >= Set{c, i + 1}->max()) then     ans := ans+(d - Set{c, i + 1}->max() + 1) ; else skip ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2 ;
    var b : int ; b := 3 ;
    var c : int ; c := 3 ;
    var d : int ; d := 4 ;
     OclFile["System.out"].println(NumberOfSolutions(a, b, c, d)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int LEN=41 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[] A=new long[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextLong();
    }
    long goal=0 ;
    for(int i=2 ; i<N ; i++)goal ^=A[i];
    System.out.println(solve(A[0],A[1],goal));
    sc.close();
  }
  static long solve(long a0,long a1,long goal){
    long sum=a0+a1 ;
    if(sum<goal ||((sum-goal)& 1)!=0)return-1 ;
    long and=(sum-goal)>>1 ;
    if((and & goal)!=0)return-1 ;
    if(and>a0)return-1 ;
    long after=and ;
    for(int i=LEN-1 ; i>=0 ; i--){
      if((goal &(1l<<i))!=0){
        if((after |(1l<<i))<=a0){
          after |=1l<<i ;
        }
      }
    }
    return after>0 ? a0-after :-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute LEN : int := 41;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var goal : long ; goal := 0 ;
        var i : int ; i := 2 ; while i < N do (     goal := MathLib.bitwiseXor(goal,A[i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(A[0+1], A[1+1], goal)) ; 
    skip ; 
 );
  static   operation solve( a0 : long, a1 : long, goal : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := a0 + a1 ;
     if (sum < goal or ((sum - goal) & 1) /= 0) then     return -1 else skip ; 
    var and : long ; and := ((sum - goal)/(2->pow(1)))->oclAsType(long) ;
    if ((MathLib.bitwiseAnd(and,goal)) /= 0) then     return -1 else skip ; 
    if (and > a0) then     return -1 else skip ; 
    var after : long ; after := and ;
        var i : int ; i := LEN - 1 ; while i >= 0 do ( (     if ((MathLib.bitwiseAnd(goal,((1l*(2->pow(i)))->oclAsType(long)))) /= 0) then (     if ((MathLib.bitwiseOr(after,((1l*(2->pow(i)))->oclAsType(long)))) <= a0) then (     after := MathLib.bitwiseOr(after, (1l*(2->pow(i)))->oclAsType(long)) ) else skip ) else skip )  ;     i := i - 1 ) ; 
    return if after > 0 then a0 - after else -1 endif 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      long a1=scanner.nextLong(),a2=scanner.nextLong();
      long s=a1+a2,x=0L ;
      for(int i=2 ; i<n ; i++){
        long ai=scanner.nextLong();
        x ^=ai ;
      }
      long d=(s-x);
      if((d & 1)>0){
        System.out.println(-1);
        return ;
      }
      d>>=1 ;
      if((d<0)||(0!=(d & x))||(d>a1)){
        System.out.println(-1);
        return ;
      }
      long y=0L ;
      for(int i=62 ; i>=0 ; i--){
        if((x &(1L<<i))>0){
          if((d ^(y |(1L<<i)))<=a1){
            y |=(1L<<i);
          }
        }
      }
      System.out.println((0==(d ^ y))?-1 :(a1-(d ^ y)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a1 : long ; a1 := scanner.getCurrent()->toLong() ;
    var a2 : long ; a2 := scanner.getCurrent()->toLong() ;
    var s : long ; s := a1 + a2 ;
    var x : long ; x := 0L ;
        var i : int ; i := 2 ; while i < n do ( (     var ai : long ; ai := scanner.getCurrent()->toLong() ;
     x := MathLib.bitwiseXor(x,ai) )  ;     i := i + 1 ) ; 
    var d : long ; d := (s - x) ;
    if ((MathLib.bitwiseAnd(d,1)) > 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    d := d/(2->pow(1)) ; 
    if ((d < 0) or (0 /= (MathLib.bitwiseAnd(d,x))) or (d > a1)) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var y : long ; y := 0L ;
        var i : int ; i := 62 ; while i >= 0 do ( (     if ((MathLib.bitwiseAnd(x,((1L*(2->pow(i)))->oclAsType(long)))) > 0) then (     if ((MathLib.bitwiseXor(d,(MathLib.bitwiseOr(y,((1L*(2->pow(i)))->oclAsType(long)))))) <= a1) then (     y := MathLib.bitwiseOr(y, ((1L*(2->pow(i)))->oclAsType(long))) ) else skip ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(if (0 = (MathLib.bitwiseXor(d,y))) then -1 else (a1 - (MathLib.bitwiseXor(d,y))) endif) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  void solve(Scanner sc,PrintWriter pw){
    int N=sc.nextInt();
    long A=sc.nextLong();
    long B=sc.nextLong();
    long C=0 ;
    for(int i=0 ; i+2<N ; i++){
      C ^=sc.nextLong();
    }
    pw.println(func(A,B,C));
  }
  private long func(long a,long b,long c){
    long delta=a+b-c ;
    if((delta % 2)>0){
      return-1 ;
    }
    long andResult=delta/2 ;
    if(andResult>a){
      return-1 ;
    }
    long remain=a+b-2L*andResult ;
    if((remain & andResult)>0){
      return-1 ;
    }
    long aResult=andResult ;
    for(int i=40 ; i>=0 ; i--){
      long bit=(1L<<i);
      if((remain & bit)>0){
        if((aResult | bit)<=a){
          aResult |=bit ;
        }
      }
    }
    return aResult==0 ?-1 : a-aResult ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    new Main().solve(sc,pw);
    pw.flush();
    pw.close();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve( sc : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.nextInt() ;
     var A : long ; A := sc.nextLong() ;
    var B : long ; B := sc.nextLong() ;
    var C : long ; C := 0 ;
        var i : int ; i := 0 ; while i + 2 < N do ( (     C := MathLib.bitwiseXor(C,sc.nextLong()) )  ;     i := i + 1 ) ; 
    pw.println(func(A, B, C)) ; 
 );
   operation func( a : long, b : long, c : long) : long
  pre: true
  post: true
  activity: (     var delta : long ; delta := a + b - c ;
     if ((delta mod 2) > 0) then (     return -1 ) else skip ; 
    var andResult : long ; andResult := delta / 2 ;
    if (andResult > a) then (     return -1 ) else skip ; 
    var remain : long ; remain := a + b - 2L * andResult ;
    if ((MathLib.bitwiseAnd(remain,andResult)) > 0) then (     return -1 ) else skip ; 
    var aResult : long ; aResult := andResult ;
        var i : int ; i := 40 ; while i >= 0 do ( (     var bit : long ; bit := ((1L*(2->pow(i)))->oclAsType(long)) ;
     if ((MathLib.bitwiseAnd(remain,bit)) > 0) then (     if ((MathLib.bitwiseOr(aResult,bit)) <= a) then (     aResult := MathLib.bitwiseOr(aResult, bit) ) else skip ) else skip )  ;     i := i - 1 ) ; 
    return if aResult = 0 then -1 else a - aResult endif 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    Main.newMain().solve(sc, pw) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String reverse(char[] str,int len,int l,int r){
    if(l<0 || r>=len || l>r)return "Invalid range!" ;
    while(l<r){
      char c=str[l];
      str[l]=str[r];
      str[r]=c ;
      l++;
      r--;
    }
    String string=new String(str);
    return string ;
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    int len=str.length();
    int l=5,r=7 ;
    System.out.println(reverse(str.toCharArray(),len,l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation reverse( str : Sequence(String), len : int, l : int, r : int) : String
  pre: true
  post: true
  activity: (     if (l < 0 or r >= len or l > r) then     return "Invalid range!" else skip ; 
     while (l < r) do (     var c : String ; c := str[l+1] ;
     str[l+1] := str[r+1] ; 
    str[r+1] := c ; 
    l := l + 1 ; 
    r := r - 1 ; 
 ) ; 
     var string : String ; string := StringLib.newString(str) ;
     return string );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var len : int ; len := str->size() ;
     var l : int ; l := 5 ;
    var r : int ; r := 7 ;
     OclFile["System.out"].println(reverse(str->characters(), len, l, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Collection ;
import java.util.Collections ;
import java.util.*;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class Solution {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    int m=sc.nextInt();
    int arr[]=new int[m];
    for(int i=0 ; i<arr.length ; i++)arr[i]=sc.nextInt();
    Arrays.sort(arr);
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<=m-n ; i++){
      min=Math.min(min,arr[i+n-1]-arr[i]);
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : int ; n := sc.nextInt() ;
    var m : int ; m := sc.nextInt() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do (     arr[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i <= m - n do ( (     min := Set{min, arr[i + n - 1+1] - arr[i+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Puzzles {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int array[]=new int[m];
    for(int i=0 ; i<m ; i++){
      array[i]=sc.nextInt();
    }
    for(int i=0 ; i<array.length ; i++){
      for(int j=i+1 ; j<array.length ; j++){
        if(array[i]>array[j]){
          int temp=array[i];
          array[i]=array[j];
          array[j]=temp ;
        }
      }
    }
    int temp=Integer.MAX_VALUE ;
    for(int i=0 ; i<m-n+1 ; i++){
      if(array[i+n-1]-array[i]<temp){
        temp=array[i+n-1]-array[i];
      }
    }
    System.out.println(temp);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Puzzles {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     array[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < array->size() do ( (         var j : int ; j := i + 1 ; while j < array->size() do ( (     if (array[i+1] > array[j+1]) then (     var temp : int ; temp := array[i+1] ;
     array[i+1] := array[j+1] ; 
     array[j+1] := temp ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var temp : int ; temp := 2147483647 ;
        var i : int ; i := 0 ; while i < m - n + 1 do ( (     if (array[i + n - 1+1] - array[i+1] < temp) then (     temp := array[i + n - 1+1] - array[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(temp) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class demo1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] arr=new int[m];
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr);
    int min=10000 ;
    for(int i=0 ; i<=m-n ; i++){
      int j=i+n-1 ;
      min=Math.min(min,arr[j]-arr[i]);
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class demo1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var min : int ; min := 10000 ;
        var i : int ; i := 0 ; while i <= m - n do ( (     var j : int ; j := i + n - 1 ;
     min := Set{min, arr[j+1] - arr[i+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int search(int arr[],int n,int x){
    int i=0 ;
    while(i<n){
      if(arr[i]==x)return i ;
      i=i+Math.abs(arr[i]-x);
    }
    System.out.println("number is not"+" present!");
    return-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      8,7,6,7,6,5,4,3,2,3,4,3 };
      int n=arr.length ;
      int x=3 ;
      System.out.println("Element "+x+" is present at index "+search(arr,n,3));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation search( arr : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     while (i < n) do (     if (arr[i+1] = x) then     return i else skip ; 
     i := i + if arr[i+1] - x < 0 then -(arr[i+1] - x) else arr[i+1] - x endif ) ; 
     OclFile["System.out"].println("number is not" + " present!") ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,7,6,7,6,5,4,3,2,3,4,3} ;
     var n : int ; n := arr->size() ;
     var x : int ; x := 3 ;
     OclFile["System.out"].println("Element " + x + " is present at index " + search(arr, n, 3)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Solution {
  static long power(long x,long y,long p){
    long res=1 ;
    x=x % p ;
    while(y>0){
      if((y & 1)!=0)res=(res*x)% p ;
      y=y>>1 ;
      x=(x*x)% p ;
    }
    return res ;
  }
  static long gcd(long a,long b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static long powerGCD(long a,long b,long n){
    long e=power(a,n,b);
    return gcd(e,b);
  }
  public static void main(String args[]){
    long a=5,b=4,n=2 ;
    System.out.print(powerGCD(a,b,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation power( x : long, y : long, p : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     if ((y & 1) /= 0) then     res := (res * x) mod p ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation powerGCD( a : long, b : long, n : long) : long
  pre: true
  post: true
  activity: (     var e : long ; e := power(a, n, b) ;
     return gcd(e, b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ; a := 5 ;
    var b : long ; b := 4 ;
    var n : long ; n := 2 ;
     OclFile["System.out"].print(powerGCD(a, b, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void half(int arr[],int n){
    int i ;
    int flag=0 ;
    for(i=0 ; i<n ; i++){
      if(arr[i] % 2==0)System.out.print(arr[i]/2+" ");
      else {
        if(flag==0){
          System.out.print(arr[i]/2-1+" ");
          flag=1 ;
        }
        else {
          int q=arr[i]/2 ;
          System.out.print(q+" ");
          flag=0 ;
        }
      }
    }
  }
  public static void main(String[] args){
    int arr[]={
-7,14,-7 };
      int len=arr.length ;
      half(arr,len);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation half( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
     var flag : int ; flag := 0 ;
         i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 = 0) then     OclFile["System.out"].print(arr[i+1] / 2 + " ") ; else (     if (flag = 0) then (     OclFile["System.out"].print(arr[i+1] / 2 - 1 + " ") ; 
     flag := 1 ) else (     var q : int ; q := arr[i+1] / 2 ;
     OclFile["System.out"].print(q + " ") ; 
     flag := 0 ) ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-7,14,-7} ;
     var len : int ; len := arr->size() ;
     execute half(arr, len) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int no_of_characters(int M){
    int k=1 ;
    while(true){
      if((int)Math.pow(2,k+1)-2<M)k++;
      else break ;
    }
    return k ;
  }
  static void print_string(int M){
    int k,num,N ;
    k=no_of_characters(M);
    N=M-((int)Math.pow(2,k)-2);
    while(k>0){
      num=(int)Math.pow(2,k-1);
      if(num>=N)System.out.print("A");
      else {
        System.out.print("B");
        N-=num ;
      }
      k--;
    }
    System.out.println();
  }
  public static void main(String args[]){
    int M ;
    M=30 ;
    print_string(M);
    M=55 ;
    print_string(M);
    M=100 ;
    print_string(M);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation no_of_characters( M : int) : int
  pre: true
  post: true
  activity: (     var k : int ; k := 1 ;
     while (true) do (     if (2->pow(k + 1)->oclAsType(int) - 2 < M) then     k := k + 1 ; else     break ) ; 
     return k );
  static   operation print_string( M : int) : void
  pre: true
  post: true
  activity: (     var k : int ;
    var num : int ;
    var N : int ;
     k := no_of_characters(M) ; 
    N := M - (2->pow(k)->oclAsType(int) - 2) ; 
    while (k > 0) do (     num := 2->pow(k - 1)->oclAsType(int) ; 
     if (num >= N) then     OclFile["System.out"].print("A") else (     OclFile["System.out"].print("B") ; 
     N := N-(num) ) ;  
     k := k - 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var M : int ;
     M := 30 ; 
    execute print_string(M) ; 
    M := 55 ; 
    execute print_string(M) ; 
    M := 100 ; 
    execute print_string(M) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class RepeatElement {
  void printRepeating(int arr[],int size){
    int i,j ;
    System.out.println("Repeated Elements are :");
    for(i=0 ; i<size ; i++){
      for(j=i+1 ; j<size ; j++){
        if(arr[i]==arr[j])System.out.print(arr[i]+" ");
      }
    }
  }
  public static void main(String[] args){
    RepeatElement repeat=new RepeatElement();
    int arr[]={
      4,2,4,5,2,3,1 };
      int arr_size=arr.length ;
      repeat.printRepeating(arr,arr_size);
    }
  }

------------------------------------------------------------
OCL File:
---------
class RepeatElement {
   operation printRepeating( arr : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     OclFile["System.out"].println("Repeated Elements are :") ; 
         i := 0 ; while i < size do ( (         j := i + 1 ; while j < size do ( (     if (arr[i+1] = arr[j+1]) then     OclFile["System.out"].print(arr[i+1] + " ") ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var repeat : RepeatElement ; repeat := RepeatElement.newRepeatElement() ;
     var arr : Sequence(int) ; arr := Sequence{4,2,4,5,2,3,1} ;
     var arr_size : int ; arr_size := arr->size() ;
     repeat.printRepeating(arr, arr_size) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class RepeatElement {
  void printRepeating(int arr[],int size){
    int count[]=new int[size];
    int i ;
    System.out.println("Repeated elements are : ");
    for(i=0 ; i<size ; i++){
      if(count[arr[i] ]==1)System.out.print(arr[i]+" ");
      else count[arr[i] ]++;
    }
  }
  public static void main(String[] args){
    RepeatElement repeat=new RepeatElement();
    int arr[]={
      4,2,4,5,2,3,1 };
      int arr_size=arr.length ;
      repeat.printRepeating(arr,arr_size);
    }
  }

------------------------------------------------------------
OCL File:
---------
class RepeatElement {
   operation printRepeating( arr : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,size)->collect(0) ;
     var i : int ;
     OclFile["System.out"].println("Repeated elements are : ") ; 
         i := 0 ; while i < size do ( (     if (count[arr[i+1]+1] = 1) then     OclFile["System.out"].print(arr[i+1] + " ") ; else     count[arr[i+1]+1] := count[arr[i+1]+1] + 1 ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var repeat : RepeatElement ; repeat := RepeatElement.newRepeatElement() ;
     var arr : Sequence(int) ; arr := Sequence{4,2,4,5,2,3,1} ;
     var arr_size : int ; arr_size := arr->size() ;
     repeat.printRepeating(arr, arr_size) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static Boolean areConsecutives(int arr[],int n){
    int first_term=Integer.MAX_VALUE ;
    for(int j=0 ; j<n ; j++){
      if(arr[j]<first_term)first_term=arr[j];
    }
    int ap_sum=(n*(2*first_term+(n-1)*1))/2 ;
    int arr_sum=0 ;
    for(int i=0 ; i<n ; i++)arr_sum+=arr[i];
    return ap_sum==arr_sum ;
  }
  public static void main(String[] args){
    int arr[]={
      2,1,0,-3,-1,-2 };
      int n=arr.length ;
      Boolean result=areConsecutives(arr,n);
      if(result==true)System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation areConsecutives( arr : Sequence(int), n : int) : Boolean
  pre: true
  post: true
  activity: (     var first_term : int ; first_term := 2147483647 ;
         var j : int ; j := 0 ; while j < n do ( (     if (arr[j+1] < first_term) then     first_term := arr[j+1] ; else skip )  ;     j := j + 1 ) ; 
    var ap_sum : int ; ap_sum := (n * (2 * first_term + (n - 1) * 1)) / 2 ;
    var arr_sum : int ; arr_sum := 0 ;
        var i : int ; i := 0 ; while i < n do (     arr_sum := arr_sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    return ap_sum = arr_sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,1,0,-3,-1,-2} ;
     var n : int ; n := arr->size() ;
     var result : Boolean ; result := areConsecutives(arr, n) ;
     if (result = true) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=100005 ;
  static int Min_Replace(int[] arr,int n,int k){
    Arrays.sort(arr);
    Integer[] freq=new Integer[MAX];
    Arrays.fill(freq,0);
    int p=0 ;
    freq[p]=1 ;
    for(int i=1 ; i<n ; i++){
      if(arr[i]==arr[i-1])++freq[p];
      else++freq[++p];
    }
    Arrays.sort(freq,Collections.reverseOrder());
    int ans=0 ;
    for(int i=k ; i<=p ; i++)ans+=freq[i];
    return ans ;
  }
  public static void main(String[] args){
    int[] arr={
      1,2,7,8,2,3,2,3 };
      int n=arr.length ;
      int k=2 ;
      System.out.println(Min_Replace(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100005;
  static   operation Min_Replace( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var freq : Sequence(int) ; freq := Integer.subrange(1,MAX)->collect(null) ;
    freq := freq->collect(0) ; 
    var p : int ; p := 0 ;
    freq[p+1] := 1 ; 
        var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] = arr[i - 1+1]) then     freq[p+1] := freq[p+1] + 1 ; else     freq[p+1] := freq[p+1] + 1 ; )  ;     i := i + 1 ) ; 
    freq := OclComparator.sortWith(freq, reverseOrder()) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := k ; while i <= p do (     ans := ans+(freq[i+1]) ;  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,7,8,2,3,2,3} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(Min_Replace(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      boolean flag=false ;
      int cnt=1 ;
      for(int i=0 ; i<n ; i++){
        if(arr[i]!=cnt){
          flag=true ;
          break ;
        }
        cnt++;
      }
      if(! flag){
        System.out.println(0);
      }
      else {
        if(arr[0]==n && arr[n-1]==1)System.out.println(3);
        else if(arr[0]==1){
          System.out.println(1);
        }
        else if(arr[n-1]==n){
          System.out.println(1);
        }
        else {
          System.out.println(2);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := false ;
    var cnt : int ; cnt := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] /= cnt) then (     flag := true ; 
     break ) else skip ; 
     cnt := cnt + 1 )  ;     i := i + 1 ) ; 
    if (not(flag)) then (     OclFile["System.out"].println(0) ) else (     if (arr[0+1] = n & arr[n - 1+1] = 1) then     OclFile["System.out"].println(3) ; else     if (arr[0+1] = 1) then (     OclFile["System.out"].println(1) ) else     if (arr[n - 1+1] = n) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(2) ) ;  ;  ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PermutationSort {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    for(int i1=0 ; i1<t ; i1++){
      int n=scan.nextInt();
      int[] perm=new int[n];
      for(int i=0 ; i<n ; i++){
        perm[i]=scan.nextInt();
      }
      boolean isSorted=true ;
      for(int i=0 ; i<n ; i++){
        if(i+1!=perm[i]){
          isSorted=false ;
          break ;
        }
      }
      if(isSorted){
        System.out.println(0);
      }
      else {
        if(perm[0]==1 || perm[n-1]==n){
          System.out.println(1);
        }
        else {
          if(perm[0]==n && perm[n-1]==1){
            System.out.println(3);
          }
          else {
            System.out.println(2);
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PermutationSort {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         var i1 : int ; i1 := 0 ; while i1 < t do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var perm : Sequence(int) ; perm := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     perm[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var isSorted : boolean ; isSorted := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (i + 1 /= perm[i+1]) then (     isSorted := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (isSorted) then (     OclFile["System.out"].println(0) ) else (     if (perm[0+1] = 1 or perm[n - 1+1] = n) then (     OclFile["System.out"].println(1) ) else (     if (perm[0+1] = n & perm[n - 1+1] = 1) then (     OclFile["System.out"].println(3) ) else (     OclFile["System.out"].println(2) ) ) ) ;  
 )  ;     i1 := i1 + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStreamReader ;
import java.io.BufferedReader ;
import java.io.IOException ;
public class PermutationSort {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int tests=Integer.parseInt(reader.readLine());
    int n,i,max=Integer.MIN_VALUE,min=Integer.MAX_VALUE ;
    String[] tokens ;
    int[] arr ;
    boolean isSorted=true ;
    while(tests-->0){
      max=Integer.MIN_VALUE ;
      min=Integer.MAX_VALUE ;
      n=Integer.parseInt(reader.readLine());
      tokens=reader.readLine().trim().split("+");
      arr=new int[n];
      isSorted=true ;
      for(i=0 ; i<n ; ++i){
        arr[i]=Integer.parseInt(tokens[i]);
        if(arr[i]>max)max=arr[i];
        if(arr[i]<min)min=arr[i];
        if(i!=0 && arr[i]<arr[i-1])isSorted=false ;
      }
      if(arr[0]==max && arr[n-1]==min)System.out.println("3");
      else if(! isSorted &&(arr[0]==min || arr[n-1]==max))System.out.println("1");
      else if(! isSorted)System.out.println("2");
      else System.out.println("0");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PermutationSort {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tests : int ; tests := (reader.readLine())->toInteger() ;
    var n : int ;
    var i : int ;
    var max : int ; max := -2147483648 ;
    var min : int ; min := 2147483647 ;
    var tokens : Sequence(String) ;
    var arr : Sequence(int) ;
    var isSorted : boolean ; isSorted := true ;
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     max := -2147483648 ; 
     min := 2147483647 ; 
    n := (reader.readLine())->toInteger() ; 
    tokens := reader.readLine()->trim()->split("+") ; 
    arr := Integer.subrange(1,n)->collect(0) ; 
    isSorted := true ; 
        i := 0 ; while i < n do ( (     arr[i+1] := (tokens[i+1])->toInteger() ; 
     if (arr[i+1] > max) then     max := arr[i+1] ; else skip ; 
     if (arr[i+1] < min) then     min := arr[i+1] ; else skip ; 
     if (i /= 0 & arr[i+1] < arr[i - 1+1]) then     isSorted := false ; else skip )  ;     i := i + 1 ) ; 
    if (arr[0+1] = max & arr[n - 1+1] = min) then     OclFile["System.out"].println("3") else     if (not(isSorted) & (arr[0+1] = min or arr[n - 1+1] = max)) then     OclFile["System.out"].println("1") else     if (not(isSorted)) then     OclFile["System.out"].println("2") else     OclFile["System.out"].println("0") ; ;  ;  ;  
 ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      int[] tempArr=arr.clone();
      Arrays.sort(tempArr);
      boolean isSorted=true ;
      for(int i=0 ; i<n ; i++){
        if(tempArr[i]!=arr[i]){
          isSorted=false ;
          break ;
        }
      }
      if(isSorted){
        System.out.println(0);
      }
      else {
        if(arr[0]==tempArr[0] || arr[n-1]==tempArr[n-1]){
          System.out.println(1);
        }
        else if(arr[0]==tempArr[n-1] && arr[n-1]==tempArr[0]){
          System.out.println(3);
        }
        else {
          System.out.println(2);
        }
      }
      t--;
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var tempArr : Sequence(int) ; tempArr := arr->copy() ;
    tempArr := tempArr->sort() ; 
    var isSorted : boolean ; isSorted := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (tempArr[i+1] /= arr[i+1]) then (     isSorted := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (isSorted) then (     OclFile["System.out"].println(0) ) else (     if (arr[0+1] = tempArr[0+1] or arr[n - 1+1] = tempArr[n - 1+1]) then (     OclFile["System.out"].println(1) ) else     if (arr[0+1] = tempArr[n - 1+1] & arr[n - 1+1] = tempArr[0+1]) then (     OclFile["System.out"].println(3) ) else (     OclFile["System.out"].println(2) ) ;  ) ;  
    t := t - 1 ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int t=in.nextInt();
      int s=in.nextInt();
      int q=in.nextInt();
      long sum=0 ;
      while(s<t){
        s=s*q ;
        sum++;
      }
      out.println(sum);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    boolean hasNext(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(Exception e){
          return false ;
        }
      }
      return true ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      String str=null ;
      try {
        str=reader.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public BigInteger nextBigInteger(){
      return new BigInteger(next());
    }
    public BigDecimal nextBigDecimal(){
      return new BigDecimal(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var t : int ; t := in.nextInt() ;
     var s : int ; s := in.nextInt() ;
    var q : int ; q := in.nextInt() ;
    var sum : long ; sum := 0 ;
    while (s < t) do (     s := s * q ; 
     sum := sum + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : ProgramException) do (     return false )
 ) ; 
     return true );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := null ;
     try (     str := reader.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextBigInteger() : long
  pre: true
  post: true
  activity: (     return long(next()) );
   operation nextBigDecimal() : double
  pre: true
  post: true
  activity: (     return double(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int a,b ;
  static int[][] field ;
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    while(true){
      a=s.nextInt();
      if(a==0)System.exit(0);
      int minN=0,maxN=0 ;
      int[][] map=new int[10][10];
      for(int i=0 ; i<10 ; i++){
        for(int j=0 ; j<10 ; j++){
          map[i][j]=1<<25 ;
          if(i==j)map[i][j]=0 ;
        }
      }
      for(int i=0 ; i<a ; i++){
        int p=s.nextInt();
        int q=s.nextInt();
        int w=s.nextInt();
        maxN=Math.max(maxN,Math.max(p,q));
        map[p][q]=Math.min(map[p][q],w);
        map[q][p]=map[p][q];
      }
      for(int k=0 ; k<10 ; k++){
        for(int i=0 ; i<10 ; i++){
          for(int j=0 ; j<10 ; j++){
            if(map[i][j]>map[i][k]+map[k][j]){
              map[i][j]=map[i][k]+map[k][j];
            }
          }
        }
      }
      int minSum=1<<25 ;
      for(int i=0 ; i<=maxN ; i++){
        int sum=0 ;
        for(int j=0 ; j<=maxN ; j++){
          sum+=map[i][j];
        }
        if(sum<minSum){
          minN=i ;
          minSum=sum ;
        }
      }
      System.out.println(minN+" "+minSum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a : int;
  static   attribute field : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     a := s.getCurrent()->toInteger() ; 
     if (a = 0) then OclProcess.exit(0) ; else skip ; 
    var minN : int ; minN := 0 ;
    var maxN : int ; maxN := 0 ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,10)->collect(Integer.subrange(1,10)->collect(0)) ;
        var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < 10 do ( (     map[i+1][j+1] := (1*(2->pow(25)))->oclAsType(long) ; 
     if (i = j) then     map[i+1][j+1] := 0 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a do ( (     var p : int ; p := s.getCurrent()->toInteger() ;
     var q : int ; q := s.getCurrent()->toInteger() ;
    var w : int ; w := s.getCurrent()->toInteger() ;
    maxN := Set{maxN, Set{p, q}->max()}->max() ; 
    map[p+1][q+1] := Set{map[p+1][q+1], w}->min() ; 
    map[q+1][p+1] := map[p+1][q+1] ; 
 )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < 10 do ( (         var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < 10 do ( (     if (map[i+1][j+1] > map[i+1][k+1] + map[k+1][j+1]) then (     map[i+1][j+1] := map[i+1][k+1] + map[k+1][j+1] ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    var minSum : int ; minSum := (1*(2->pow(25)))->oclAsType(long) ;
        var i : int ; i := 0 ; while i <= maxN do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j <= maxN do ( (     sum := sum+(map[i+1][j+1]) )  ;     j := j + 1 ) ; 
     if (sum < minSum) then (     minN := i ; 
     minSum := sum ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(minN + " " + minSum) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static ArrayList<Integer>primes=new ArrayList<Integer>();
  static void SieveofEratosthenes(int n){
    boolean[] visited=new boolean[n*n+2];
    for(int i=2 ; i<=n+1 ; i++)if(! visited[i]){
      for(int j=i*i ; j<=n+1 ; j+=i)visited[j]=true ;
      primes.add(i);
    }
  }
  static boolean specialPrimeNumbers(int n,int k){
    SieveofEratosthenes(n);
    int count=0 ;
    for(int i=0 ; i<primes.size(); i++){
      for(int j=0 ; j<i-1 ; j++){
        if(primes.get(j)+primes.get(j+1)+1==primes.get(i)){
          count++;
          break ;
        }
      }
      if(count==k)return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    int n=27,k=2 ;
    if(specialPrimeNumbers(n,k))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute primes : Sequence(int) := Sequence{};
  static   operation SieveofEratosthenes( n : int) : void
  pre: true
  post: true
  activity: (     var visited : Sequence(boolean) ; visited := Integer.subrange(1,n * n + 2)->collect(false) ;
         var i : int ; i := 2 ; while i <= n + 1 do (     if (not(visited[i+1])) then (         var j : int ; j := i * i ; while j <= n + 1 do (     visited[j+1] := true ;  ;     j := j+(i) ) ; 
     primes := primes->including(i) ) else skip ;  ;     i := i + 1 ) );
  static   operation specialPrimeNumbers( n : int, k : int) : boolean
  pre: true
  post: true
  activity: (     execute SieveofEratosthenes(n) ; 
     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < primes->size() do ( (         var j : int ; j := 0 ; while j < i - 1 do ( (     if (primes->at(j+1) + primes->at(j + 1+1) + 1 = primes->at(i+1)) then (     count := count + 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (count = k) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 27 ;
    var k : int ; k := 2 ;
     if (specialPrimeNumbers(n, k)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findTileCount(int x,int y,int l,int r){
    int lcm=(x*y)/__gcd(x,y);
    int countl=(l-1)/lcm ;
    int countr=r/lcm ;
    return countr-countl ;
  }
  static int __gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  public static void main(String[] args){
    int x=2,y=3,l=6,r=18 ;
    System.out.println(findTileCount(x,y,l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findTileCount( x : int, y : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     var lcm : int ; lcm := (x * y) / __gcd(x, y) ;
     var countl : int ; countl := (l - 1) / lcm ;
     var countr : int ; countr := r / lcm ;
     return countr - countl );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
    if (a = b) then     return a else skip ; 
    if (a > b) then     return __gcd(a - b, b) else skip ; 
    return __gcd(a, b - a) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 2 ;
    var y : int ; y := 3 ;
    var l : int ; l := 6 ;
    var r : int ; r := 18 ;
     OclFile["System.out"].println(findTileCount(x, y, l, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sum(int n){
    int sum=(n*(n+1))/2 ;
    return sum ;
  }
  static int repeatedSum(int n,int k){
    for(int i=0 ; i<k ; i++){
      n=sum(n);
    }
    return n ;
  }
  public static void main(String[] args){
    int n=2,k=2 ;
    System.out.println(repeatedSum(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := (n * (n + 1)) / 2 ;
     return sum );
  static   operation repeatedSum( n : int, k : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < k do ( (     n := sum(n) )  ;     i := i + 1 ) ; 
     return n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
    var k : int ; k := 2 ;
     OclFile["System.out"].println(repeatedSum(n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int t=in.nextInt();
      int s=in.nextInt();
      int q=in.nextInt();
      long sum=0 ;
      while(s<t){
        s*=q ;
        sum++;
      }
      out.println(sum);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    boolean hasNext(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(Exception e){
          return false ;
        }
      }
      return true ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      String str=null ;
      try {
        str=reader.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public BigInteger nextBigInteger(){
      return new BigInteger(next());
    }
    public BigDecimal nextBigDecimal(){
      return new BigDecimal(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var t : int ; t := in.nextInt() ;
     var s : int ; s := in.nextInt() ;
    var q : int ; q := in.nextInt() ;
    var sum : long ; sum := 0 ;
    while (s < t) do (     s := s*(q) ; 
     sum := sum + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : ProgramException) do (     return false )
 ) ; 
     return true );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := null ;
     try (     str := reader.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextBigInteger() : long
  pre: true
  post: true
  activity: (     return long(next()) );
   operation nextBigDecimal() : double
  pre: true
  post: true
  activity: (     return double(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    String s ;
    int one ;
    int five ;
    int ten ;
    int oturi ;
    int p ;
    int q ;
    try {
      while((s=reader.readLine())!=null){
        String[] t=s.split(" ");
        int x=Integer.parseInt(t[0]);
        int y=Integer.parseInt(t[1]);
        if(x==0 && y==0){
          break ;
        }
        oturi=y-x ;
        if(oturi/1000==0){
          if(oturi/500==0){
            one=oturi/100 ;
            five=0 ;
            ten=0 ;
          }
          else {
            five=oturi/500 ;
            q=oturi-five*500 ;
            one=q/100 ;
            ten=0 ;
          }
        }
        else {
          ten=oturi/1000 ;
          p=oturi-ten*1000 ;
          five=p/500 ;
          q=p-five*500 ;
          one=q/100 ;
        }
        System.out.print(one+" "+five+" "+ten);
        System.out.println("");
      }
    }
    catch(IOException e){
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ;
    var one : int ;
    var five : int ;
    var ten : int ;
    var oturi : int ;
    var p : int ;
    var q : int ;
    try (         s := reader.readLine() ;
    while ((s) /= null) do (    skip ; (     var t : Sequence(String) ; t := s->split(" ") ;
     var x : int ; x := (t[0+1])->toInteger() ;
    var y : int ; y := (t[1+1])->toInteger() ;
    if (x = 0 & y = 0) then (     break ) else skip ; 
    oturi := y - x ; 
    if (oturi / 1000 = 0) then (     if (oturi / 500 = 0) then (     one := oturi / 100 ; 
     five := 0 ; 
     ten := 0 ) else (     five := oturi / 500 ; 
     q := oturi - five * 500 ; 
     one := q / 100 ; 
     ten := 0 ) ) else (     ten := oturi / 1000 ; 
     p := oturi - ten * 1000 ; 
    five := p / 500 ; 
    q := p - five * 500 ; 
    one := q / 100 ; 
 ) ;  
    OclFile["System.out"].print(one + " " + five + " " + ten) ; 
    OclFile["System.out"].println("") ; 
 ) ;     s := reader.readLine() ;
 ) )   catch (e : IOException) do (     OclFile["System.out"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.util.Arrays.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    while(read()){
      solve();
    }
  }
  static Scanner sc=new Scanner(System.in);
  static int A,B ;
  static boolean read(){
    A=sc.nextInt();
    B=sc.nextInt();
    return(A!=0 && B!=0)? true : false ;
  }
  static int[] coin={
    1000,500,100 };
    static void solve(){
      int cur=B-A ;
      int[] ret=new int[3];
      for(int i=0 ; i<3 ; i++){
        ret[i]=cur/coin[i];
        cur-=ret[i]*coin[i];
      }
      System.out.println(ret[2]+" "+ret[1]+" "+ret[0]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (read()) do (     execute solve() ) );
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute A : int;
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     A := sc.getCurrent()->toInteger() ; 
     B := sc.getCurrent()->toInteger() ; 
     return if (A /= 0 & B /= 0) then true else false endif );
  static   attribute coin : Sequence(int) := Sequence{1000,500,100};
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var cur : int ; cur := B - A ;
     var ret : Sequence(int) ; ret := Integer.subrange(1,3)->collect(0) ;
         var i : int ; i := 0 ; while i < 3 do ( (     ret[i+1] := cur / coin[i+1] ; 
     cur := cur-(ret[i+1] * coin[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ret[2+1] + " " + ret[1+1] + " " + ret[0+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class code {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int countn=0,sum=0 ;
    int[] arr=new int[n];
    int[] neg=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      if(arr[i]<0){
        countn++;
      }
    }
    int[] arrn=new int[countn];
    int j=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]<0){
        arrn[j++]=arr[i];
      }
    }
    Arrays.sort(arrn);
    for(int i=0 ; i<m && i<countn ; i++){
      sum+=Math.abs(arrn[i]);
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var countn : int ; countn := 0 ;
    var sum : int ; sum := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var neg : Sequence(int) ; neg := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] < 0) then (     countn := countn + 1 ) else skip )  ;     i := i + 1 ) ; 
    var arrn : Sequence(int) ; arrn := Integer.subrange(1,countn)->collect(0) ;
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] < 0) then (      arrn[j+1] := arr[i+1]  ; j := j + 1 ) else skip )  ;     i := i + 1 ) ; 
    arrn := arrn->sort() ; 
        var i : int ; i := 0 ; while i < m & i < countn do ( (     sum := sum+(if arrn[i+1] < 0 then -(arrn[i+1]) else arrn[i+1] endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int a,d,i ;
    int[] b=new int[3];
    int[] c=new int[3];
    c[0]=1000 ;
    c[1]=500 ;
    c[2]=100 ;
    for(; ; ){
      a=sc.nextInt();
      d=sc.nextInt();
      if(a==0 && d==0)break ;
      a=d-a ;
      for(i=0 ; i<3 ; i++){
        b[i]=a/c[i];
        a-=b[i]*c[i];
      }
      out.printf("%d %d %d%n",b[2],b[1],b[0]);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var a : int ;
    var d : int ;
    var i : int ;
    var b : Sequence(int) ; b := Integer.subrange(1,3)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,3)->collect(0) ;
    c[0+1] := 1000 ; 
    c[1+1] := 500 ; 
    c[2+1] := 100 ; 
      while true do ( (     a := sc.nextInt() ; 
     d := sc.nextInt() ; 
    if (a = 0 & d = 0) then     break else skip ; 
    a := d - a ; 
        i := 0 ; while i < 3 do ( (     b[i+1] := a / c[i+1] ; 
     a := a-(b[i+1] * c[i+1]) )  ;     i := i + 1 ) ; 
    out.printf("%d %d %d%n", b[2+1], b[1+1], b[0+1]) ; 
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int A=sc.nextInt();
      int B=sc.nextInt();
      if(A==0 && B==0)break ;
      int remaining=B-A ;
      int m1000=0 ;
      int m500=0 ;
      int m100=0 ;
      while(remaining-1000>=0){
        m1000++;
        remaining-=1000 ;
      }
      while(remaining-500>=0){
        m500++;
        remaining-=500 ;
      }
      while(remaining-100>=0){
        m100++;
        remaining-=100 ;
      }
      System.out.printf("%d %d %d\n",m100,m500,m1000);
    }
  }
  public static void main(String args[]){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
    if (A = 0 & B = 0) then     break else skip ; 
    var remaining : int ; remaining := B - A ;
    var m1000 : int ; m1000 := 0 ;
    var m500 : int ; m500 := 0 ;
    var m100 : int ; m100 := 0 ;
    while (remaining - 1000 >= 0) do (     m1000 := m1000 + 1 ; 
     remaining := remaining-(1000) ) ; 
    while (remaining - 500 >= 0) do (     m500 := m500 + 1 ; 
     remaining := remaining-(500) ) ; 
    while (remaining - 100 >= 0) do (     m100 := m100 + 1 ; 
     remaining := remaining-(100) ) ; 
    OclFile["System.out"].printf("%d %d %d\n", m100, m500, m1000) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  public static int smallestX(int n){
    int[] temp=new int[10];
    for(int i=0 ; i<10 ; i++)temp[i]=0 ;
    if(n==0)return-1 ;
    int count=0,x=0 ;
    for(x=1 ; count<10 ; x++){
      int y=x*n ;
      while(y>0){
        if(temp[y % 10]==0){
          count++;
          temp[y % 10]=1 ;
        }
        y/=10 ;
      }
    }
    return x-1 ;
  }
  public static void main(String args[]){
    int n=5 ;
    System.out.print(smallestX(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation smallestX( n : int) : int
  pre: true
  post: true
  activity: (     var temp : Sequence(int) ; temp := Integer.subrange(1,10)->collect(0) ;
         var i : int ; i := 0 ; while i < 10 do (     temp[i+1] := 0 ;  ;     i := i + 1 ) ; 
    if (n = 0) then     return -1 else skip ; 
    var count : int ; count := 0 ;
    var x : int ; x := 0 ;
        x := 1 ; while count < 10 do ( (     var y : int ; y := x * n ;
     while (y > 0) do (     if (temp[y mod 10+1] = 0) then (     count := count + 1 ; 
     temp[y mod 10+1] := 1 ) else skip ; 
     y := y/(10) ) )  ;     x := x + 1 ) ; 
    return x - 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].print(smallestX(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  static long mod=1000003 ;
  static long pow(long a,long b){
    if(b==0)return 1 ;
    long ans=pow(a,b/2);
    if(b % 2==0)return ans*ans % mod ;
    return ans*ans % mod*a % mod ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    if(n<10)System.out.println(n);
    else {
      long curr=1 ;
      long dig=1 ;
      while(true){
        long tot=9*curr ;
        if(n>tot*dig)n-=tot*dig ;
        else break ;
        curr=curr*10 ;
        dig++;
      }
      long x=0 ;
      if(n % dig==0)x=curr+n/dig-1 ;
      else x=curr+n/dig ;
      n %=dig ;
      if(n==0)n=dig ;
      String s=x+"" ;
      System.out.println(s.charAt((int)(n-1)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute mod : long := 1000003;
  static   operation pow( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return 1 else skip ; 
     var ans : long ; ans := pow(a, b / 2) ;
     if (b mod 2 = 0) then     return ans * ans mod mod else skip ; 
     return ans * ans mod mod * a mod mod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
     if (n < 10) then     OclFile["System.out"].println(n) ; else (     var curr : long ; curr := 1 ;
     var dig : long ; dig := 1 ;
    while (true) do (     var tot : long ; tot := 9 * curr ;
     if (n > tot * dig) then     n := n-(tot * dig) else     break ;  
     curr := curr * 10 ; 
     dig := dig + 1 ) ; 
    var x : long ; x := 0 ;
    if (n mod dig = 0) then     x := curr + n / dig - 1 else     x := curr + n / dig ; ;  
    n := n mod dig ; 
    if (n = 0) then     n := dig ; else skip ; 
    var s : String ; s := x + "" ;
    OclFile["System.out"].println(s->at((n - 1)->oclAsType(int)+1)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static Character solve(long a,long b,long c){
    long min=a ;
    long max ;
    long xth=0 ;
    long index ;
    for(index=String.valueOf(a).length()-1 ; ; index++){
      long numOfDigits=0 ;
      max=(long)Math.pow(10,index+1)-1 ;
      long count=(max-min)/b+1 ;
      numOfDigits+=count*(index+1);
      if(c-numOfDigits<=0){
        break ;
      }
      c-=numOfDigits ;
      min=min+count*b ;
    }
    if(c %(index+1)==0){
      xth=c/(index+1);
    }
    else {
      xth=c/(index+1)+1 ;
    }
    long lastNum=min+b*(xth-1);
    int pos=(int)(c %(index+1));
    if(pos==0){
      return String.valueOf(lastNum).charAt((int)index);
    }
    else {
      return String.valueOf(lastNum).charAt(pos-1);
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long tc ;
    tc=sc.nextLong();
    System.out.println(solve(1,1,tc));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( a : long, b : long, c : long) : String
  pre: true
  post: true
  activity: (     var min : long ; min := a ;
     var max : long ;
    var xth : long ; xth := 0 ;
    var index : long ;
        index := ((a) + "")->size() - 1 ; while true do ( (     var numOfDigits : long ; numOfDigits := 0 ;
     max := 10->pow(index + 1)->oclAsType(long) - 1 ; 
    var count : long ; count := (max - min) / b + 1 ;
    numOfDigits := numOfDigits+(count * (index + 1)) ; 
    if (c - numOfDigits <= 0) then (     break ) else skip ; 
    c := c-(numOfDigits) ; 
    min := min + count * b ; 
 )  ;     index := index + 1 ) ; 
    if (c mod (index + 1) = 0) then (     xth := c / (index + 1) ) else (     xth := c / (index + 1) + 1 ) ;  
    var lastNum : long ; lastNum := min + b * (xth - 1) ;
    var pos : int ; pos := (c mod (index + 1))->oclAsType(int) ;
    if (pos = 0) then (     return ((lastNum) + "")->at(index->oclAsType(int)+1) ) else (     return ((lastNum) + "")->at(pos - 1+1) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : long ;
     tc := sc.getCurrent()->toLong() ; 
     OclFile["System.out"].println(solve(1, 1, tc)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[]){
    FastReader input=new FastReader();
    PrintWriter out=new PrintWriter(System.out);
    int T=1 ;
    while(T-->0){
      long k=input.nextLong();
      long v=9 ;
      long s=0 ;
      int x=1 ;
      while(true){
        if(s+v*x>k){
          break ;
        }
        s+=v*x ;
        v*=10 ;
        x++;
      }
      if(s==k){
        out.println(9);
      }
      else {
        long d=k-s ;
        long u=d/x ;
        long rem=d % x ;
        long nu=(long)Math.pow(10,x-1);
        nu+=u ;
        if(rem==0){
          nu--;
          out.println(nu % 10);
        }
        else {
          String str=String.valueOf(nu);
          out.println(str.charAt((int)(rem-1)));
        }
      }
    }
    out.close();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastReader ; input := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := 1 ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     var k : long ; k := input.nextLong() ;
     var v : long ; v := 9 ;
    var s : long ; s := 0 ;
    var x : int ; x := 1 ;
    while (true) do (     if (s + v * x > k) then (     break ) else skip ; 
     s := s+(v * x) ; 
     v := v*(10) ; 
     x := x + 1 ) ; 
    if (s = k) then (     skip ) else (     var d : long ; d := k - s ;
     var u : long ; u := d / x ;
    var rem : long ; rem := d mod x ;
    var nu : long ; nu := 10->pow(x - 1)->oclAsType(long) ;
    nu := nu+(u) ; 
    if (rem = 0) then (     nu := nu - 1 ; 
     skip ) else (     var str : String ; str := ((nu) + "") ;
     skip ) ;  
 ) ;  
 ) ;  ) ;  
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner s=new Scanner(System.in);
    long k=s.nextLong();
    long dp[]=new long[13];
    long x=9 ;
    int i=1 ;
    long ansx=0 ;
    int ansi=0 ;
    for(; i<13 ; i++){
      dp[i]=dp[i-1]+x*i ;
      x*=10 ;
      if(k<=dp[i]){
        ansx=x ;
        ansi=i ;
        break ;
      }
      if(dp[i]>1000000000000l)break ;
    }
    if(ansi<2){
      System.out.println(k);
      return ;
    }
    k-=dp[ansi-1];
    long st=(long)Math.pow(10,ansi-1);
    long div=(k/ansi);
    if(k % ansi==0)div--;
    k-=div*ansi ;
    System.out.println(findKthDigit(st+div,k));
  }
  private static Long findKthDigit(long xx,long k){
    int z=(int)k ;
    ArrayList<Long>arr=new ArrayList();
    while(xx>0){
      arr.add(xx % 10);
      xx/=10 ;
    }
    return arr.get(arr.size()-z);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : long ; k := s.getCurrent()->toLong() ;
    var dp : Sequence(long) ; dp := Integer.subrange(1,13)->collect(0) ;
    var x : long ; x := 9 ;
    var i : int ; i := 1 ;
    var ansx : long ; ansx := 0 ;
    var ansi : int ; ansi := 0 ;
      while i < 13 do ( (     dp[i+1] := dp[i - 1+1] + x * i ; 
     x := x*(10) ; 
     if (k <= dp[i+1]) then (     ansx := x ; 
     ansi := i ; 
     break ) else skip ; 
     if (dp[i+1] > 1000000000000l) then     break else skip )  ;     i := i + 1 ) ; 
    if (ansi < 2) then (     OclFile["System.out"].println(k) ; 
     return ) else skip ; 
    k := k-(dp[ansi - 1+1]) ; 
    var st : long ; st := 10->pow(ansi - 1)->oclAsType(long) ;
    var div : long ; div := (k / ansi) ;
    if (k mod ansi = 0) then     div := div - 1 ; else skip ; 
    k := k-(div * ansi) ; 
    OclFile["System.out"].println(findKthDigit(st + div, k)) ; 
 );
  static   operation findKthDigit( xx : long, k : long) : long
  pre: true
  post: true
  activity: (     var z : int ; z := k->oclAsType(int) ;
     var arr : Sequence(long) ; arr := Sequence{} ;
     while (xx > 0) do (     arr := arr->including(xx mod 10) ; 
     xx := xx/(10) ) ; 
     return arr->at(arr->size() - z+1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    StringTokenizer st=new StringTokenizer(f.readLine());
    int n=Integer.parseInt(st.nextToken());
    int I=Integer.parseInt(st.nextToken());
    st=new StringTokenizer(f.readLine());
    TreeMap<Integer,Integer>a=new TreeMap<>();
    for(int i=0 ; i<n ; i++){
      int ai=Integer.parseInt(st.nextToken());
      a.put(ai,a.getOrDefault(ai,0)+1);
    }
    ArrayList<int[]>arr=new ArrayList<>();
    for(int i : a.keySet()){
      arr.add(new int[] {
        i,a.get(i)}
);
      }
      int K=1<<Math.min(20,8*I/n);
      if(K>arr.size()){
        out.println(0);
      }
      else {
        int in=0 ;
        for(int i=0 ; i<K ; i++){
          in+=arr.get(i)[1];
        }
        int ans=in ;
        for(int i=K ; i<arr.size(); i++){
          in+=arr.get(i)[1];
          in-=arr.get(i-K)[1];
          ans=Math.max(ans,in);
        }
        out.println(n-ans);
      }
      f.close();
      out.close();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var I : int ; I := (st.next())->toInteger() ;
    st := OclIterator.newOclIterator_String(f.readLine()) ; 
    var a : Map(int,int) ; a := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var ai : int ; ai := (st.next())->toInteger() ;
     a := a->union(Map{ai |-> (if a->keys()->contains(ai) then a->at(ai) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var arr : Sequence(Sequence(int)) ; arr := Sequence{} ;
    for (i : a->keys()) do ( (     arr := arr->including(Sequence{i,a->at(i)}) )  ) ; 
    var K : int ; K := (1*(2->pow(Set{20, 8 * I / n}->min())))->oclAsType(long) ;
    if (K > arr->size()) then (     skip ) else (     var in : int ; in := 0 ;
         var i : int ; i := 0 ; while i < K do ( (     in := in+(arr->at(i+1)[1+1]) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := in ;
        var i : int ; i := K ; while i < arr->size() do ( (     in := in+(arr->at(i+1)[1+1]) ; 
     in := in-(arr->at(i - K+1)[1+1]) ; 
     ans := Set{ans, in}->max() )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Digits_Sequence {
  static Scanner sc=new Scanner(System.in);
  static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args){
    long k,c,n,d ;
    c=1 ;
    d=9 ;
    n=1 ;
    k=sc.nextLong();
    while(k>(c*d)){
      k-=(c*d);
      n*=10 ;
      d*=10 ;
      c++;
    }
    n+=(k-1)/c ;
    char[] num=String.valueOf(n).toCharArray();
    System.out.println(num[(int)((k-1)% c)]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Digits_Sequence {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : long ;
    var c : long ;
    var n : long ;
    var d : long ;
     c := 1 ; 
    d := 9 ; 
    n := 1 ; 
    k := sc.getCurrent()->toLong() ; 
    while (k > (c * d)) do (     k := k-((c * d)) ; 
     n := n*(10) ; 
     d := d*(10) ; 
     c := c + 1 ) ; 
    n := n+((k - 1) / c) ; 
    var num : Sequence(String) ; num := ((n) + "")->characters() ;
    OclFile["System.out"].println(num[((k - 1) mod c)->oclAsType(int)+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    Map<Integer,Set<Integer>>tree=new HashMap<>();
    for(int i : IntStream.range(0,N-1).toArray()){
      int a=Integer.parseInt(scan.next());
      int b=Integer.parseInt(scan.next());
      Set<Integer>map=tree.getOrDefault(a,new HashSet<>());
      map.add(b);
      tree.put(a,map);
      map=tree.getOrDefault(b,new HashSet<>());
      map.add(a);
      tree.put(b,map);
    }
    int blackCount=bfs(tree,N);
    if(blackCount>0){
      System.out.println("Fennec");
    }
    else {
      System.out.println("Snuke");
    }
  }
  static int bfs(Map<Integer,Set<Integer>>tree,int N){
    int[] nodes=new int[N+1];
    nodes[1]=1 ;
    nodes[N]=-1 ;
    LinkedList<List<Integer>>deque=new LinkedList<>();
    deque.addFirst(Arrays.asList(1,1));
    deque.addFirst(Arrays.asList(N,-1));
    while(! deque.isEmpty()){
      List<Integer>node=deque.removeLast();
      for(int next : tree.get(node.get(0))){
        if(nodes[next]!=0){
          continue ;
        }
        nodes[next]=node.get(1);
        deque.addFirst(Arrays.asList(next,node.get(1)));
      }
    }
    return Arrays.stream(nodes).sum();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var tree : Map(int,Set(int)) ; tree := Map{} ;
    for (i : Integer.subrange(0, N - 1-1)->asSequence()) do ( (     var a : int ; a := (scan.getCurrent())->toInteger() ;
     var b : int ; b := (scan.getCurrent())->toInteger() ;
    var map : Set(int) ; map := (if tree->keys()->contains(a) then tree->at(a) else Set{} endif) ;
    map := map->including(b) ; 
    tree := tree->union(Map{a |-> map}) ; 
    map := (if tree->keys()->contains(b) then tree->at(b) else Set{} endif) ; 
    map := map->including(a) ; 
    tree := tree->union(Map{b |-> map}) ; 
 )  ) ; 
    var blackCount : int ; blackCount := bfs(tree, N) ;
    if (blackCount > 0) then (     OclFile["System.out"].println("Fennec") ) else (     OclFile["System.out"].println("Snuke") ) ;  
 );
  static   operation bfs( tree : Map(int,Set(int)), N : int) : int
  pre: true
  post: true
  activity: (     var nodes : Sequence(int) ; nodes := Integer.subrange(1,N + 1)->collect(0) ;
     nodes[1+1] := 1 ; 
    nodes[N+1] := -1 ; 
    var deque : Sequence(Sequence(int)) ; deque := Sequence{} ;
    deque := deque->prepend(Sequence{1,1}) ; 
    deque := deque->prepend(Sequence{N,-1}) ; 
    while (not(deque->isEmpty())) do (     var node : Sequence(int) ; node := deque->last() ;
     for (next : tree->at(node->at(0+1))) do ( (     if (nodes[next+1] /= 0) then (     continue ) else skip ; 
     nodes[next+1] := node->at(1+1) ; 
     deque := deque->prepend(Sequence{next,node->at(1+1)}) )  ) ) ; 
    return stream(nodes)->sum() 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int N ;
  static List<ArrayList<Integer>>to ;
  static List<Integer>distList ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    to=new ArrayList<>();
    for(int i=0 ; i<N ; i++)to.add(new ArrayList<Integer>());
    for(int i=0 ; i<N-1 ; i++){
      int a=sc.nextInt()-1,b=sc.nextInt()-1 ;
      to.get(a).add(b);
      to.get(b).add(a);
    }
    sc.close();
    distList=new ArrayList<>();
    dfs(0,-1);
    int size=distList.size();
    int half=(size+1)/2 ;
    int fen_node=distList.get(size-half);
    int sun_node=distList.get(size-half-1);
    int fen=cntdfs(fen_node,-1,sun_node);
    int sun=cntdfs(sun_node,-1,fen_node);
    System.out.println(fen>sun ? "Fennec" : "Snuke");
  }
  static int cntdfs(int v,int parent,int opp){
    int res=1 ;
    for(int next : to.get(v)){
      if(next==parent || next==opp)continue ;
      res+=cntdfs(next,v,opp);
    }
    return res ;
  }
  static boolean dfs(int v,int parent){
    boolean pathToOpp=false ;
    if(v==N-1){
      distList.add(v);
      return true ;
    }
    for(int next : to.get(v)){
      if(next==parent)continue ;
      pathToOpp=dfs(next,v);
      if(pathToOpp){
        distList.add(v);
        break ;
      }
    }
    return pathToOpp ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute to : Sequence(Sequence(int));
  static   attribute distList : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
    to := Sequence{} ; 
        var i : int ; i := 0 ; while i < N do (     to := to->including(Sequence{}) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
    var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
     to->at(a+1)->excludes(b) ; 
     to->at(b+1)->excludes(a) )  ;     i := i + 1 ) ; 
    skip ; 
    distList := Sequence{} ; 
    execute dfs(0, -1) ; 
    var size : int ; size := distList->size() ;
    var half : int ; half := (size + 1) / 2 ;
    var fen_node : int ; fen_node := distList->at(size - half+1) ;
    var sun_node : int ; sun_node := distList->at(size - half - 1+1) ;
    var fen : int ; fen := cntdfs(fen_node, -1, sun_node) ;
    var sun : int ; sun := cntdfs(sun_node, -1, fen_node) ;
    OclFile["System.out"].println(if fen > sun then "Fennec" else "Snuke" endif) ; 
 );
  static   operation cntdfs( v : int, parent : int, opp : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     for (next : to->at(v+1)) do ( (     if (next = parent or next = opp) then     continue else skip ; 
     res := res+(cntdfs(next, v, opp)) )  ) ; 
     return res );
  static   operation dfs( v : int, parent : int) : boolean
  pre: true
  post: true
  activity: (     var pathToOpp : boolean ; pathToOpp := false ;
     if (v = N - 1) then (     distList := distList->including(v) ; 
     return true ) else skip ; 
     for (next : to->at(v+1)) do ( (     if (next = parent) then     continue else skip ; 
     pathToOpp := dfs(next, v) ; 
     if (pathToOpp) then (     distList := distList->including(v) ; 
     break ) else skip )  ) ; 
     return pathToOpp );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Sale {
  public static void main(String[] args){
    Scanner o=new Scanner(System.in);
    int n=o.nextInt(),m=o.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=o.nextInt();
    }
    Arrays.sort(arr);
    int tot=0 ;
    for(int i : arr){
      if(i<0 && m>0){
        tot+=i ;
        m--;
      }
      else break ;
    }
    System.out.println(-tot);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sale {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : OclFile ; o := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := o.getCurrent()->toInteger() ;
    var m : int ; m := o.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := o.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var tot : int ; tot := 0 ;
    for (i : arr) do ( (     if (i < 0 & m > 0) then (     tot := tot+(i) ; 
     m := m - 1 ) else     break )  ) ; 
    OclFile["System.out"].println(-tot) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.PrintWriter ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<Integer>[] map=new ArrayList[n];
    for(int i=0 ; i<n ; i++){
      map[i]=new ArrayList<>();
    }
    for(int i=0 ; i<n-1 ; i++){
      int a=sc.nextInt()-1 ;
      int b=sc.nextInt()-1 ;
      map[a] .add(b);
      map[b] .add(a);
    }
    ArrayDeque<Integer>q=new ArrayDeque<>();
    int[] disf=new int[n];
    Arrays.fill(disf,-1);
    disf[0]=0 ;
    q.add(0);
    while(! q.isEmpty()){
      int s=q.poll();
      for(int i : map[s]){
        if(disf[i]==-1){
          disf[i]=disf[s]+1 ;
          q.add(i);
        }
      }
    }
    int[] diss=new int[n];
    Arrays.fill(diss,-1);
    diss[n-1]=0 ;
    q.add(n-1);
    int fe=n-1 ;
    while(! q.isEmpty()){
      int s=q.poll();
      for(int i : map[s]){
        if(diss[i]==-1){
          diss[i]=diss[s]+1 ;
          if(diss[i]<disf[i]){
            fe--;
          }
          else {
            continue ;
          }
          q.add(i);
        }
      }
    }
    if(fe>n-fe){
      System.out.println("Fennec");
    }
    else {
      System.out.println("Snuke");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     map[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
     var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
     map[a+1]->excludes(b) ; 
     map[b+1]->excludes(a) )  ;     i := i + 1 ) ; 
    var q : Sequence(int) ; q := ArrayDeque<OclAny>.newArrayDeque() ;
    var disf : Sequence(int) ; disf := Integer.subrange(1,n)->collect(0) ;
    disf := disf->collect(-1) ; 
    disf[0+1] := 0 ; 
    q := q->including(0) ; 
    while (not(q->isEmpty())) do (     var s : int ; s := q->min() ;
     for (i : map[s+1]) do ( (     if (disf[i+1] = -1) then (     disf[i+1] := disf[s+1] + 1 ; 
     q := q->including(i) ) else skip )  ) ) ; 
    var diss : Sequence(int) ; diss := Integer.subrange(1,n)->collect(0) ;
    diss := diss->collect(-1) ; 
    diss[n - 1+1] := 0 ; 
    q := q->including(n - 1) ; 
    var fe : int ; fe := n - 1 ;
    while (not(q->isEmpty())) do (     var s : int ; s := q->min() ;
     for (i : map[s+1]) do ( (     if (diss[i+1] = -1) then (     diss[i+1] := diss[s+1] + 1 ; 
     if (diss[i+1] < disf[i+1]) then (     fe := fe - 1 ) else (     continue ) ;  
     q := q->including(i) ) else skip )  ) ) ; 
    if (fe > n - fe) then (     OclFile["System.out"].println("Fennec") ) else (     OclFile["System.out"].println("Snuke") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  static int betweenNum=0 ;
  static int onlyWhiteNum=0 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] a=new int[N-1];
    int[] b=new int[N-1];
    for(int i=0 ; i<N-1 ; ++i){
      a[i]=sc.nextInt()-1 ;
      b[i]=sc.nextInt()-1 ;
    }
    System.out.println(solve(a,b));
    sc.close();
  }
  static String solve(int[] a,int[] b){
    int N=a.length+1 ;
    @ SuppressWarnings("unchecked")List<Integer>[] adjLists=new List[N];
    for(int i=0 ; i<adjLists.length ; ++i){
      adjLists[i]=new ArrayList<>();
    }
    for(int i=0 ; i<a.length ; ++i){
      adjLists[a[i] ] .add(b[i]);
      adjLists[b[i] ] .add(a[i]);
    }
    Boolean[] colors=new Boolean[N];
    colors[0]=true ;
    colors[N-1]=false ;
    Queue<Integer>queue=new LinkedList<>();
    queue.offer(0);
    queue.offer(N-1);
    int blackCount=0 ;
    int whiteCount=0 ;
    while(! queue.isEmpty()){
      int head=queue.poll();
      if(colors[head]){
++blackCount ;
      }
      else {
++whiteCount ;
      }
      for(int adj : adjLists[head]){
        if(colors[adj]==null){
          colors[adj]=colors[head];
          queue.offer(adj);
        }
      }
    }
    return(blackCount>whiteCount)? "Fennec" : "Snuke" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute betweenNum : int := 0;
  static   attribute onlyWhiteNum : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N - 1)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,N - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     a[i+1] := sc.getCurrent()->toInteger() - 1 ; 
     b[i+1] := sc.getCurrent()->toInteger() - 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(a, b)) ; 
    skip ; 
 );
  static   operation solve( a : Sequence(int), b : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var N : int ; N := a->size() + 1 ;
     var adjLists : Sequence(Sequence(int)) ; adjLists := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < adjLists->size() do ( (     adjLists[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     adjLists[a[i+1]+1]->excludes(b[i+1]) ; 
     adjLists[b[i+1]+1]->excludes(a[i+1]) )  ;     i := i + 1 ) ; 
    var colors : Sequence(Boolean) ; colors := Integer.subrange(1,N)->collect(null) ;
    colors[0+1] := true ; 
    colors[N - 1+1] := false ; 
    var queue : Sequence(int) ; queue := Sequence{} ;
    queue := queue->including(0) ; 
    queue := queue->including(N - 1) ; 
    var blackCount : int ; blackCount := 0 ;
    var whiteCount : int ; whiteCount := 0 ;
    while (not(queue->isEmpty())) do (     var head : int ; head := queue->min() ;
     if (colors[head+1]) then (     blackCount := blackCount + 1 ) else (     whiteCount := whiteCount + 1 ) ;  
     for (adj : adjLists[head+1]) do ( (     if (colors[adj+1] = null) then (     colors[adj+1] := colors[head+1] ; 
     queue := queue->including(adj) ) else skip )  ) ) ; 
    return if (blackCount > whiteCount) then "Fennec" else "Snuke" endif 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static List<List<Integer>>list ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    list=new ArrayList<>();
    for(int i=0 ; i<=n ; i++){
      list.add(new ArrayList<>());
    }
    for(int i=0 ; i<n-1 ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      list.get(a).add(b);
      list.get(b).add(a);
    }
    int[] d1=bfs(1,0,new int[n+1]);
    int[] d2=bfs(n,0,new int[n+1]);
    int cnt1=0 ;
    int cnt2=0 ;
    for(int i=1 ; i<=n ; i++){
      if(d1[i]==0 || d2[i]==0){
        continue ;
      }
      if(d1[i]<=d2[i]){
        cnt1++;
        continue ;
      }
      cnt2++;
    }
    if(cnt1>cnt2){
      System.out.println("Fennec");
      return ;
    }
    System.out.println("Snuke");
  }
  public static int[] bfs(int s,int p,int[] ret){
    List<Integer>edge=list.get(s);
    for(int v : edge){
      if(p!=v){
        ret[v]+=ret[s]+1 ;
        bfs(v,s,ret);
      }
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute list : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    list := Sequence{} ; 
        var i : int ; i := 0 ; while i <= n do ( (     list := list->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     list->at(a+1)->excludes(b) ; 
     list->at(b+1)->excludes(a) )  ;     i := i + 1 ) ; 
    var d1 : Sequence(int) ; d1 := bfs(1, 0, Integer.subrange(1,n + 1)->collect(0)) ;
    var d2 : Sequence(int) ; d2 := bfs(n, 0, Integer.subrange(1,n + 1)->collect(0)) ;
    var cnt1 : int ; cnt1 := 0 ;
    var cnt2 : int ; cnt2 := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (d1[i+1] = 0 or d2[i+1] = 0) then (     continue ) else skip ; 
     if (d1[i+1] <= d2[i+1]) then (     cnt1 := cnt1 + 1 ; 
     continue ) else skip ; 
     cnt2 := cnt2 + 1 )  ;     i := i + 1 ) ; 
    if (cnt1 > cnt2) then (     OclFile["System.out"].println("Fennec") ; 
     return ) else skip ; 
    OclFile["System.out"].println("Snuke") ; 
 );
  static   operation bfs( s : int, p : int, ret : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var edge : Sequence(int) ; edge := list->at(s+1) ;
     for (v : edge) do ( (     if (p /= v) then (     ret[v+1] := ret[v+1]+(ret[s+1] + 1) ; 
     execute bfs(v, s, ret) ) else skip )  ) ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countMinSwaps(String st){
    int min_swaps=0 ;
    int odd_0=0,even_0=0 ;
    int odd_1=0,even_1=0 ;
    int n=st.length();
    for(int i=0 ; i<n ; i++){
      if(i % 2==0){
        if(st.charAt(i)=='1')even_1++;
        else even_0++;
      }
      else {
        if(st.charAt(i)=='1')odd_1++;
        else odd_0++;
      }
    }
    int cnt_swaps_1=Math.min(even_0,odd_1);
    int cnt_swaps_2=Math.min(even_1,odd_0);
    return Math.min(cnt_swaps_1,cnt_swaps_2);
  }
  public static void main(String[] args){
    String st="000111" ;
    System.out.println(countMinSwaps(st));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countMinSwaps( st : String) : int
  pre: true
  post: true
  activity: (     var min_swaps : int ; min_swaps := 0 ;
     var odd_0 : int ; odd_0 := 0 ;
    var even_0 : int ; even_0 := 0 ;
    var odd    var oddint : int ; oddint := 0 : int ; odd    var oddint : int ; oddint := 0 := 0 ;
    var even    var even    var oddint : int ; oddint := 0 : int ; even    var oddint : int ; oddint := 0 := 0 : int ; even    var even    var oddint : int ; oddint := 0 : int ; even    var oddint : int ; oddint := 0 := 0 := 0 ;
    var n : int ; n := st->size() ;
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then (     if (st->at(i+1) = '1') then     eveneveneven    if (st->at(i+1) = '1') then     eveneveneven(st->at(i+1) = '1') := eveneveneven(st->at(i+1) = '1') + 1 else     even_0 := even_0 + 1 ; ;  := eveneveneven    if (st->at(i+1) = '1') then     eveneveneven(st->at(i+1) = '1') := eveneveneven(st->at(i+1) = '1') + 1 else     even_0 := even_0 + 1 ; ;  + 1 ; else     even_0 := even_0 + 1 ; ) else (     if (st->at(i+1) = '1') then     oddoddodd    if (st->at(i+1) = '1') then     oddoddodd(st->at(i+1) = '1') := oddoddodd(st->at(i+1) = '1') + 1 else     odd_0 := odd_0 + 1 ; ;  := oddoddodd    if (st->at(i+1) = '1') then     oddoddodd(st->at(i+1) = '1') := oddoddodd(st->at(i+1) = '1') + 1 else     odd_0 := odd_0 + 1 ; ;  + 1 ; else     odd_0 := odd_0 + 1 ; ) )  ;     i := i + 1 ) ; 
    var cnt_swaps    var cnt_swapsint : int ; cnt_swapsint := Set{even_0, oddeven_0}->min() : int ; cnt_swaps    var cnt_swapsint : int ; cnt_swapsint := Set{even_0, oddeven_0}->min() := Set{even_0, oddeven_0}->min() ;
    var cnt_swapsSet{evenSet{even    var cnt_swapsSet{evenSet{evenint, odd_0}->min(), odd_0}->min() : int ; cnt_swapsSet{evenSet{evenint, odd_0}->min(), odd_0}->min() := Set{evenSet{evenSet{evenSet{evencnt_swapsSet{evenSet{evenint, odd_0}->min(), odd_0}->min(), odd_0}->min(), odd_0}->min(), odd_0}->min(), odd_0}->min(), odd_0}->min(), odd_0}->min() : int ; cnt_swapsSet{evenSet{even    var cnt_swapsSet{evenSet{evenint, odd_0}->min(), odd_0}->min() : int ; cnt_swapsSet{evenSet{evenint, odd_0}->min(), odd_0}->min() := Set{evenSet{evenSet{evenSet{evencnt_swapsSet{evenSet{evenint, odd_0}->min(), odd_0}->min(), odd_0}->min(), odd_0}->min(), odd_0}->min(), odd_0}->min(), odd_0}->min(), odd_0}->min() := Set{evenSet{evenSet{evenSet{evencnt_swapsSet{evenSet{even    var cnt_swapsSet{evenSet{evenint, odd_0}->min(), odd_0}->min() : int ; cnt_swapsSet{evenSet{evenint, odd_0}->min(), odd_0}->min() := Set{evenSet{evenSet{evenSet{evencnt_swapsSet{evenSet{evenint, odd_0}->min(), odd_0}->min(), odd_0}->min(), odd_0}->min(), odd_0}->min(), odd_0}->min(), odd_0}->min(), odd_0}->min(), odd_0}->min(), odd_0}->min(), odd_0}->min(), odd_0}->min() ;
    return Set{cnt_swapsSet{cnt_swaps_1, cnt_swaps_2}->min(), cnt_swaps_2}->min() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var st : String ; st := "000111" ;
     OclFile["System.out"].println(countMinSwaps(st)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int findAnswer(int X,int N){
    return(N-1)*9+X ;
  }
  public static void main(String[] args){
    int X=7,N=43 ;
    System.out.println(findAnswer(X,N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation findAnswer( X : int, N : int) : int
  pre: true
  post: true
  activity: (     return (N - 1) * 9 + X );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 7 ;
    var N : int ; N := 43 ;
     OclFile["System.out"].println(findAnswer(X, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static final long MOD=998_244_353 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int S=sc.nextInt();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
    }
    long ans=0 ;
    long[] dp=new long[S+1];
    for(int i=0 ; i<N ; i++){
      dp[0]+=1 ;
      for(int j=S ; j>=A[i]; j--){
        dp[j]+=dp[j-A[i] ];
        dp[j] %=MOD ;
      }
      ans+=dp[S];
      ans %=MOD ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 998    var MOD :  ; MOD := 998998_244_35344_35344_353;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var S : int ; S := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var dp : Sequence(long) ; dp := Integer.subrange(1,S + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     dp[0+1] := dp[0+1]+(1) ; 
         var j : int ; j := S ; while j >= A[i+1] do ( (     dp[j+1] := dp[j+1]+(dp[j - A[i+1]+1]) ; 
     dp[j+1] := dp[j+1] mod MOD )  ;     j := j - 1 ) ; 
     ans := ans+(dp[S+1]) ; 
     ans := ans mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A569 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    int S=in.nextInt();
    int q=in.nextInt();
    long previous=S ;
    int answer=0 ;
    while(previous<T){
      answer++;
      previous*=q ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A569 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
    var S : int ; S := in.getCurrent()->toInteger() ;
    var q : int ; q := in.getCurrent()->toInteger() ;
    var previous : long ; previous := S ;
    var answer : int ; answer := 0 ;
    while (previous < T) do (     answer := answer + 1 ; 
     previous := previous*(q) ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  private static final long MOD=998_244_353 ;
  public static void main(final String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int n=scanner.nextInt();
    final int s=scanner.nextInt();
    final int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scanner.nextInt();
    }
    final long[][] dpTable=new long[n][s];
    long count=0 ;
    if(a[0]<s){
      dpTable[0][a[0] ]=1 ;
    }
    else if(a[0]==s){
      count=n ;
    }
    for(int i=1 ; i<n ; i++){
      System.arraycopy(dpTable[i-1],0,dpTable[i],0,s);
      if(a[i]>s){
        continue ;
      }
      else if(a[i]==s){
        count=(count+(i+1)*(n-i))% MOD ;
        continue ;
      }
      if(dpTable[i-1][s-a[i] ]!=0){
        count=(count+dpTable[i-1][s-a[i] ]*(n-i))% MOD ;
      }
      for(int j=1 ; j<s-a[i]; j++){
        if(dpTable[i-1][j]==0){
          continue ;
        }
        dpTable[i][j+a[i] ]+=dpTable[i-1][j];
        dpTable[i][j+a[i] ] %=MOD ;
      }
      dpTable[i][a[i] ]+=i+1 ;
      dpTable[i][a[i] ] %=MOD ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 998    var MOD :  ; MOD := 998998_244_35344_35344_353;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var s : int ; s := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dpTable : Sequence(Sequence(long)) ; dpTable := Integer.subrange(1,n)->collect(Integer.subrange(1,s)->collect(0)) ;
    var count : long ; count := 0 ;
    if (a[0+1] < s) then (     dpTable[0+1][a[0+1]+1] := 1 ) else     if (a[0+1] = s) then (     count := n ) else skip ; ;  
        var i : int ; i := 1 ; while i < n do ( (     for _x : Integer.subrange(1,s) do dpTable[i+1][0 + _x] := dpTable[i - 1+1][0 + _x] ; 
     if (a[i+1] > s) then (     continue ) else     if (a[i+1] = s) then (     count := (count + (i + 1) * (n - i)) mod MOD ; 
     continue ) else skip ; ;  
    if (dpTable[i - 1+1][s - a[i+1]+1] /= 0) then (     count := (count + dpTable[i - 1+1][s - a[i+1]+1] * (n - i)) mod MOD ) else skip ; 
        var j : int ; j := 1 ; while j < s - a[i+1] do ( (     if (dpTable[i - 1+1][j+1] = 0) then (     continue ) else skip ; 
     dpTable[i+1][j + a[i+1]+1] := dpTable[i+1][j + a[i+1]+1]+(dpTable[i - 1+1][j+1]) ; 
     dpTable[i+1][j + a[i+1]+1] := dpTable[i+1][j + a[i+1]+1] mod MOD )  ;     j := j + 1 ) ; 
    dpTable[i+1][a[i+1]+1] := dpTable[i+1][a[i+1]+1]+(i + 1) ; 
    dpTable[i+1][a[i+1]+1] := dpTable[i+1][a[i+1]+1] mod MOD ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.PrintWriter ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int s=sc.nextInt();
    long mod=998244353 ;
    long[] dp=new long[s+1];
    dp[0]=1 ;
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      for(int j=s ; j>=a ; j--){
        dp[j]+=dp[j-a];
        dp[j] %=mod ;
      }
      dp[0]++;
      ans+=dp[s];
      ans %=mod ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var mod : long ; mod := 998244353 ;
    var dp : Sequence(long) ; dp := Integer.subrange(1,s + 1)->collect(0) ;
    dp[0+1] := 1 ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
         var j : int ; j := s ; while j >= a do ( (     dp[j+1] := dp[j+1]+(dp[j - a+1]) ; 
     dp[j+1] := dp[j+1] mod mod )  ;     j := j - 1 ) ; 
    dp[0+1] := dp[0+1] + 1 ; 
    ans := ans+(dp[s+1]) ; 
    ans := ans mod mod ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static final int mod=998244353 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int S=sc.nextInt();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
    }
    long res=0 ;
    long[] dp=new long[S+1];
    for(int i=0 ; i<N ; i++){
      dp[0]+=1 ;
      for(int j=S ; j>=0 ; j--){
        long c1=dp[j],c2=0 ;
        if(j>=A[i]){
          c2=dp[j-A[i] ];
        }
        dp[j]=c1+c2 ;
        dp[j] %=mod ;
      }
      res+=dp[S];
      res %=mod ;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute mod : int := 998244353;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var S : int ; S := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
    var dp : Sequence(long) ; dp := Integer.subrange(1,S + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     dp[0+1] := dp[0+1]+(1) ; 
         var j : int ; j := S ; while j >= 0 do ( (     var c1 : long ; c1 := dp[j+1] ;
    var c2 : long ; c2 := 0 ;
     if (j >= A[i+1]) then (     c2 := dp[j - A[i+1]+1] ) else skip ; 
     dp[j+1] := c1 + c2 ; 
     dp[j+1] := dp[j+1] mod mod )  ;     j := j - 1 ) ; 
     res := res+(dp[S+1]) ; 
     res := res mod mod )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int S=sc.nextInt();
    int A[]=new int[N];
    for(int i=0 ; i<A.length ; ++i){
      A[i]=sc.nextInt();
    }
    long MOD=998244353 ;
    long result=0 ;
    long memo[]=new long[S+1];
    memo[0]=1 ;
    long r2=0 ;
    for(int R=0 ; R<N ; ++R){
      int a=A[R];
      long next[]=new long[S+1];
      for(int i=0 ; i<=S ; ++i){
        if(i==a){
          next[i]=memo[i]+(R+1);
        }
        else if(i>a){
          next[i]=memo[i-a]+memo[i];
        }
        else {
          next[i]=memo[i];
        }
      }
      for(int i=0 ; i<=S ; ++i){
        next[i]=next[i] % MOD ;
      }
      memo=next ;
      r2=(r2+memo[S])% MOD ;
    }
    System.out.println(r2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var S : int ; S := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < A->size() do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var MOD : long ; MOD := 998244353 ;
    var result : long ; result := 0 ;
    var memo : Sequence(long) ; memo := Integer.subrange(1,S + 1)->collect(0) ;
    memo[0+1] := 1 ; 
    var r2 : long ; r2 := 0 ;
        var R : int ; R := 0 ; while R < N do ( (     var a : int ; a := A[R+1] ;
     var next : Sequence(long) ; next := Integer.subrange(1,S + 1)->collect(0) ;
        var i : int ; i := 0 ; while i <= S do ( (     if (i = a) then (     next[i+1] := memo[i+1] + (R + 1) ) else     if (i > a) then (     next[i+1] := memo[i - a+1] + memo[i+1] ) else (     next[i+1] := memo[i+1] ) ;  )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= S do ( (     next[i+1] := next[i+1] mod MOD )  ;     i := i + 1 ) ; 
    memo := next ; 
    r2 := (r2 + memo[S+1]) mod MOD ; 
 )  ;     R := R + 1 ) ; 
    OclFile["System.out"].println(r2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.lang.Math ;
import java.lang.String ;
import java.util.Arrays ;
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.Collections ;
import java.util.StringTokenizer ;
public class testfile {
  public static void main(String args[])throws java.io.IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    int tc=Integer.parseInt(br.readLine());
    while(tc-->0){
      int n=Integer.parseInt(br.readLine()),count=n ;
      char in='B' ;
      boolean t=true ;
      String s=br.readLine();
      String result="" ;
      int i=0 ;
      for(; i<n ; i++)if(s.charAt(i)!='?'){
        count=i ;
        result+=s.charAt(i);
        in=s.charAt(i);
        t=s.charAt(i)=='B' ? true : false ;
        i++;
        break ;
      }
      while(i<n){
        if(s.charAt(i)=='?'){
          result+=(t ? 'R' : 'B');
          t=! t ;
        }
        else {
          result+=s.charAt(i);
          t=s.charAt(i)=='R' ? false : true ;
        }
        i++;
      }
      t=in=='B' ? true : false ;
      for(int j=0 ; j<count ; j++){
        result=(t ? 'R' : 'B')+result ;
        t=! t ;
      }
      out.println(result);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class testfile {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var tc : int ; tc := (br.readLine())->toInteger() ;
        while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
    var count : int ; count := n ;
     var in : String ; in := 'B' ;
    var t : boolean ; t := true ;
    var s : String ; s := br.readLine() ;
    var result : String ; result := "" ;
    var i : int ; i := 0 ;
      while i < n do (     if (s->at(i+1) /= '?') then (     count := i ; 
     result := result+(s->at(i+1)) ; 
    in := s->at(i+1) ; 
    t := if s->at(i+1) = 'B' then true else false endif ; 
    i := i + 1 ; 
    break 
 ) else skip ;  ;     i := i + 1 ) ; 
    while (i < n) do (     if (s->at(i+1) = '?') then (     result := result+((if t then 'R' else 'B' endif)) ; 
     t := not(t) ) else (     result := result+(s->at(i+1)) ; 
     t := if s->at(i+1) = 'R' then false else true endif ) ;  
     i := i + 1 ) ; 
    t := if in = 'B' then true else false endif ; 
        var j : int ; j := 0 ; while j < count do ( (     result := (if t then 'R' else 'B' endif) + result ; 
     t := not(t) )  ;     j := j + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class lol {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    int b=in.nextInt();
    int[] arr=new int[a];
    for(int i=0 ; i<a ; i++){
      arr[i]=in.nextInt();
    }
    ArrayList<Integer>list=new ArrayList<>();
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]<0){
        list.add(arr[i]);
      }
    }
    int sum=0 ;
    Collections.sort(list);
    if(b<list.size()){
      for(int i=0 ; i<b ; i++){
        sum+=Math.abs(list.get(i));
      }
      System.out.println(sum);
    }
    else {
      for(int i=0 ; i<list.size(); i++){
        sum+=Math.abs(list.get(i));
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class lol {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,a)->collect(0) ;
        var i : int ; i := 0 ; while i < a do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] < 0) then (     list := list->including(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    list := list->sort() ; 
    if (b < list->size()) then (         var i : int ; i := 0 ; while i < b do ( (     sum := sum+(if list->at(i+1) < 0 then -(list->at(i+1)) else list->at(i+1) endif) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sum) ) else (         var i : int ; i := 0 ; while i < list->size() do ( (     sum := sum+(if list->at(i+1) < 0 then -(list->at(i+1)) else list->at(i+1) endif) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sum) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printNonConsecutive(int n){
    int p=(1<<n);
    for(int i=1 ; i<p ; i++)if((i &(i<<1))==0)System.out.print(i+" ");
  }
  public static void main(String[] args){
    int n=3 ;
    printNonConsecutive(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printNonConsecutive( n : int) : void
  pre: true
  post: true
  activity: (     var p : int ; p := ((1*(2->pow(n)))->oclAsType(long)) ;
         var i : int ; i := 1 ; while i < p do (     if ((MathLib.bitwiseAnd(i,((i*(2->pow(1)))->oclAsType(long)))) = 0) then     OclFile["System.out"].print(i + " ") ; else skip ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     execute printNonConsecutive(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countMaxSetBits(int left,int right){
    while((left |(left+1))<=right)left |=left+1 ;
    return left ;
  }
  public static void main(String[] args){
    int l=1 ;
    int r=5 ;
    System.out.println(countMaxSetBits(l,r));
    l=1 ;
    r=10 ;
    System.out.println(countMaxSetBits(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countMaxSetBits( left : int, right : int) : int
  pre: true
  post: true
  activity: (     while ((left or (left + 1)) <= right) do     left := MathLib.bitwiseOr(left, left + 1) ; ; 
     return left );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 1 ;
     var r : int ; r := 5 ;
    OclFile["System.out"].println(countMaxSetBits(l, r)) ; 
    l := 1 ; 
    r := 10 ; 
    OclFile["System.out"].println(countMaxSetBits(l, r)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxval(int[] a,int n){
    if(n<2){
      System.out.print("Invalid Input");
      return-9999 ;
    }
    int max1=0,max2=0 ;
    for(int i=0 ; i<n ; i++){
      int x=a[i]+i ;
      if(x>max1){
        max2=max1 ;
        max1=x ;
      }
      else if(x>max2 & x!=max1){
        max2=x ;
      }
    }
    return(max1*max2);
  }
  public static void main(String[] args){
    int arr[]={
      4,5,3,1,10 };
      int len=arr.length ;
      System.out.println(maxval(arr,len));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxval( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n < 2) then (     OclFile["System.out"].print("Invalid Input") ; 
     return -9999 ) else skip ; 
     var max1 : int ; max1 := 0 ;
    var max2 : int ; max2 := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := a[i+1] + i ;
     if (x > max1) then (     max2 := max1 ; 
     max1 := x ) else     if (x > max2 & x /= max1) then (     max2 := x ) else skip ; )  ;     i := i + 1 ) ; 
     return (max1 * max2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,5,3,1,10} ;
     var len : int ; len := arr->size() ;
     OclFile["System.out"].println(maxval(arr, len)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int k=sc.nextInt();
      boolean ok=false ;
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      Arrays.sort(arr);
      int i=0,j=1 ;
      while(i<n && j<n){
        if((arr[i]+Math.abs(k))==arr[j]){
          ok=true ;
          break ;
        }
        else if((arr[i]+Math.abs(k))<arr[j])i++;
        else j++;
      }
      if(ok)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var ok : boolean ; ok := false ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var i : int ; i := 0 ;
    var j : int ; j := 1 ;
    while (i < n & j < n) do (     if ((arr[i+1] + if k < 0 then -(k) else k endif) = arr[j+1]) then (     ok := true ; 
     break ) else     if ((arr[i+1] + if k < 0 then -(k) else k endif) < arr[j+1]) then     i := i + 1 else     j := j + 1 ; ;  ) ; 
    if (ok) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int t=in.nextInt();
      int s=in.nextInt();
      int q=in.nextInt();
      long sum=0 ;
      while(s<t){
        s=s*q ;
        sum++;
      }
      out.println(sum);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    boolean hasNext(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(Exception e){
          return false ;
        }
      }
      return true ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      String str=null ;
      try {
        str=reader.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public BigInteger nextBigInteger(){
      return new BigInteger(next());
    }
    public BigDecimal nextBigDecimal(){
      return new BigDecimal(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var t : int ; t := in.nextInt() ;
     var s : int ; s := in.nextInt() ;
    var q : int ; q := in.nextInt() ;
    var sum : long ; sum := 0 ;
    while (s < t) do (     s := s * q ; 
     sum := sum + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : ProgramException) do (     return false )
 ) ; 
     return true );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := null ;
     try (     str := reader.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextBigInteger() : long
  pre: true
  post: true
  activity: (     return long(next()) );
   operation nextBigDecimal() : double
  pre: true
  post: true
  activity: (     return double(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    while(t-->0){
      int n=scan.nextInt();
      int k=scan.nextInt();
      HashSet<Integer>set=new HashSet<>(n);
      for(int i=0 ; i<n ; i++)set.add(scan.nextInt());
      boolean flag=false ;
      for(Integer x : set){
        if(set.contains(x+k)|| set.contains(x-k)){
          flag=true ;
          break ;
        }
      }
      if(flag)System.out.println("yes");
      else System.out.println("no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var k : int ; k := scan.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do (     set := set->including(scan.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := false ;
    for (x : set) do ( (     if (set->includes(x + k) or set->includes(x - k)) then (     flag := true ; 
     break ) else skip )  ) ; 
    if (flag) then     OclFile["System.out"].println("yes") else     OclFile["System.out"].println("no") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static PrintWriter out=new PrintWriter(System.out);
  static Scanner in=new Scanner(System.in);
  static BufferedReader re=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter wr=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws IOException {
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int T=in.nextInt();
    while(T>0){
      int n=in.nextInt();
      int k=in.nextInt();
      int arr[]=new int[n];
      Set<Integer>set=new HashSet<>();
      for(int i=0 ; i<n ; i++){
        arr[i]=in.nextInt();
        set.add(arr[i]);
      }
      int t=0 ;
      for(int i=0 ; i<n ; i++){
        if(set.contains(arr[i]+k)|| set.contains(arr[i]-k)){
          t++;
        }
      }
      if(t>0)System.out.println("YES");
      else System.out.println("NO");
      T--;
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute re : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute wr : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
     while (T > 0) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() ; 
     set := set->including(arr[i+1]) )  ;     i := i + 1 ) ; 
    var t : int ; t := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (set->includes(arr[i+1] + k) or set->includes(arr[i+1] - k)) then (     t := t + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (t > 0) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
    T := T - 1 ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
import static java.lang.System.exit ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  static void solve()throws Exception {
    int n=scanInt();
    long a[]=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scanInt();
    }
    long min=2,max=2 ;
    for(int i=n-1 ; i>=0 ; i--){
      long cur=a[i];
      min=(min-1)/cur+1 ;
      max=max/cur ;
      if(max<min){
        out.print(-1);
        return ;
      }
      min*=cur ;
      max=max*cur+cur-1 ;
    }
    out.print(min+" "+max);
  }
  static int scanInt()throws IOException {
    return parseInt(scanString());
  }
  static long scanLong()throws IOException {
    return parseLong(scanString());
  }
  static String scanString()throws IOException {
    while(tok==null || ! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  public static void main(String[] args){
    try {
      in=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(System.out);
      solve();
      in.close();
      out.close();
    }
    catch(Throwable e){
      e.printStackTrace();
      exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanInt() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanInt() )  ;     i := i + 1 ) ; 
    var min : long ; min := 2 ;
    var max : long ; max := 2 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     var cur : long ; cur := a[i+1] ;
     min := (min - 1) / cur + 1 ; 
    max := max / cur ; 
    if (max < min) then (     out.print(-1) ; 
     return ) else skip ; 
    min := min*(cur) ; 
    max := max * cur + cur - 1 ; 
 )  ;     i := i - 1 ) ; 
    out.print(min + " " + max) ; 
 );
  static   operation scanInt() : int
  pre: true
  post: true
  activity: (     return (scanString() + "")->toInteger() );
  static   operation scanLong() : long
  pre: true
  post: true
  activity: (     return parseLong(scanString()) );
  static   operation scanString() : String
  pre: true
  post: true
  activity: (     while (tok = null or not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return tok.next() );
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
     execute exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  void submit(){
    int n=nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=nextInt();
    }
    long low=2 ;
    long high=2 ;
    for(int i=n-1 ; i>=0 ; i--){
      int x=a[i];
      if(low % x!=0){
        low+=x-low % x ;
      }
      high-=high % x ;
      if(low>high){
        out.println(-1);
        return ;
      }
      high+=x-1 ;
    }
    out.println(low+" "+high);
  }
  void preCalc(){
  }
  void stress(){
  }
  void test(){
  }
  Main()throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(System.out);
    preCalc();
    submit();
    out.close();
  }
  static final Random rng=new Random();
  static int rand(int l,int r){
    return l+rng.nextInt(r-l+1);
  }
  public static void main(String[] args)throws IOException {
    new Main();
  }
  BufferedReader br ;
  PrintWriter out ;
  StringTokenizer st ;
  String nextToken(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return st.nextToken();
  }
  String nextString(){
    try {
      return br.readLine();
    }
    catch(IOException e){
      throw new RuntimeException(e);
    }
  }
  int nextInt(){
    return Integer.parseInt(nextToken());
  }
  long nextLong(){
    return Long.parseLong(nextToken());
  }
  double nextDouble(){
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation submit() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := nextInt() )  ;     i := i + 1 ) ; 
    var low : long ; low := 2 ;
    var high : long ; high := 2 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     var x : int ; x := a[i+1] ;
     if (low mod x /= 0) then (     low := low+(x - low mod x) ) else skip ; 
    high := high-(high mod x) ; 
    if (low > high) then (     out.println(-1) ; 
     return ) else skip ; 
    high := high+(x - 1) ; 
 )  ;     i := i - 1 ) ; 
    out.println(low + " " + high) ; 
 );
   operation preCalc() : void
  pre: true
  post: true
  activity: skip;
   operation stress() : void
  pre: true
  post: true
  activity: skip;
   operation test() : void
  pre: true
  post: true
  activity: skip;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute preCalc() ; 
    execute submit() ; 
    out.close() ; 
 );
  static    attribute rng : OclRandom := OclRandom.newOclRandom();
  static   operation rand( l : int, r : int) : int
  pre: true
  post: true
  activity: (     return l + rng.nextInt(r - l + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   attribute br : OclFile;
   attribute out : OclFile;
   attribute st : OclIterator;
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextString() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    long a[]=new long[k+1];
    for(int i=1 ; i<=k ; i++){
      a[i]=sc.nextLong();
    }
    long n[]=new long[k+1];
    long N[]=new long[k+1];
    n[k]=2 ;
    N[k]=2 ;
    for(int i=k ; i>0 ; i--){
      n[i-1]=Math.max(n[i],(n[i]+a[i]-1)/a[i]*a[i]);
      N[i-1]=N[i]/a[i]*a[i]+a[i]-1 ;
    }
    if(N[0]<n[0])System.out.println(-1);
    else System.out.println(n[0]+" "+N[0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,k + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= k do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var n : Sequence(long) ; n := Integer.subrange(1,k + 1)->collect(0) ;
    var N : Sequence(long) ; N := Integer.subrange(1,k + 1)->collect(0) ;
    n[k+1] := 2 ; 
    N[k+1] := 2 ; 
        var i : int ; i := k ; while i > 0 do ( (     n[i - 1+1] := Set{n[i+1], (n[i+1] + a[i+1] - 1) / a[i+1] * a[i+1]}->max() ; 
     N[i - 1+1] := N[i+1] / a[i+1] * a[i+1] + a[i+1] - 1 )  ;     i := i - 1 ) ; 
    if (N[0+1] < n[0+1]) then     OclFile["System.out"].println(-1) else     OclFile["System.out"].println(n[0+1] + " " + N[0+1]) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    FastScanner in=new FastScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ProblemB solver=new ProblemB();
    solver.solve(1,in,out);
    out.close();
  }
  static class ProblemB {
    public void solve(int testNumber,FastScanner in,PrintWriter out){
      int k=in.nextInt();
      long[] a=new long[k];
      for(int i=0 ; i<k ; i++){
        a[i]=in.nextInt();
      }
      if(a[k-1]!=2){
        out.println(-1);
        return ;
      }
      long l=2 ;
      long r=3 ;
      for(int i=k-2 ; i>=0 ; i--){
        long min=(l+a[i]-1)/a[i]*a[i];
        long max=r/a[i]*a[i];
        l=min ;
        r=max+a[i]-1 ;
      }
      if(l>r){
        out.println(-1);
      }
      else {
        out.println(l+" "+r);
      }
    }
  }
  static class FastScanner {
    private BufferedReader in ;
    private StringTokenizer st ;
    public FastScanner(InputStream stream){
      in=new BufferedReader(new InputStreamReader(stream));
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          String rl=in.readLine();
          if(rl==null){
            return null ;
          }
          st=new StringTokenizer(rl);
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : FastScanner ; in := FastScanner.newFastScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ProblemB ; solver := ProblemB.newProblemB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ProblemB {
   operation solve( testNumber : int, in : FastScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var k : int ; k := in.nextInt() ;
     var a : Sequence(long) ; a := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     a[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    if (a[k - 1+1] /= 2) then (     skip ; 
     return ) else skip ; 
    var l : long ; l := 2 ;
    var r : long ; r := 3 ;
        var i : int ; i := k - 2 ; while i >= 0 do ( (     var min : long ; min := (l + a[i+1] - 1) / a[i+1] * a[i+1] ;
     var max : long ; max := r / a[i+1] * a[i+1] ;
     l := min ; 
     r := max + a[i+1] - 1 )  ;     i := i - 1 ) ; 
    if (l > r) then (     skip ) else (     skip ) ;  
 );
}
  static class FastScanner {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( stream : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     var rl : String ; rl := in.readLine() ;
     if (rl = null) then (     return null ) else skip ; 
     st := OclIterator.newOclIterator_String(rl) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    int[] arr=new int[x];
    int l=arr.length ;
    for(int i=0 ; i<l ; i++){
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr);
    int sum=0 ;
    for(int i=0 ; i<y ; i++){
      if(arr[i]<0){
        sum+=arr[i];
      }
    }
    System.out.println(Math.abs(sum));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,x)->collect(0) ;
    var l : int ; l := arr->size() ;
        var i : int ; i := 0 ; while i < l do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < y do ( (     if (arr[i+1] < 0) then (     sum := sum+(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if sum < 0 then -(sum) else sum endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static long execute(long[] s,long n){
    long m=n ;
    for(int i=0 ; i<s.length ; i++){
      m=m-(m % s[i]);
    }
    return m ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    int m=Integer.parseInt(in.readLine());
    String[] s=in.readLine().split("\\s++");
    long[] k=new long[s.length];
    for(int i=0 ; i<s.length ; i++){
      k[i]=Integer.parseInt(s[i]);
    }
    long hi=Long.MAX_VALUE ;
    long lo=2 ;
    long max=-1 ;
    long min=-1 ;
    long t ;
    if(execute(k,hi)==2)max=hi ;
    else {
      while(lo<hi){
        t=(hi/2)+(lo/2)+(((hi % 2)+(lo % 2))/2);
        if(execute(k,t)<=2)lo=t+1 ;
        else hi=t ;
      }
      max=hi-1 ;
      hi=Long.MAX_VALUE ;
      lo=2 ;
    }
    if(execute(k,lo)==2)min=lo ;
    else {
      while(lo<hi){
        t=(hi/2)+(lo/2)+((1+(hi % 2)+(lo % 2))/2);
        if(t<0){
          min=Long.MAX_VALUE ;
          break ;
        }
        if(execute(k,t)>=2)hi=t-1 ;
        else lo=t ;
      }
      min=lo+1 ;
    }
    if(min>max)System.out.println(-1);
    else System.out.println(min+" "+max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation execute( s : Sequence(long), n : long) : long
  pre: true
  post: true
  activity: (     var m : long ; m := n ;
         var i : int ; i := 0 ; while i < s->size() do ( (     m := m - (m mod s[i+1]) )  ;     i := i + 1 ) ; 
     return m );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var m : int ; m := (in.readLine())->toInteger() ;
    var s : Sequence(String) ; s := in.readLine()->split("\\s++") ;
    var k : Sequence(long) ; k := Integer.subrange(1,s->size())->collect(0) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     k[i+1] := (s[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var hi : long ; hi := "9223372036854775807"->toLong() ;
    var lo : long ; lo := 2 ;
    var max : long ; max := -1 ;
    var min : long ; min := -1 ;
    var t : long ;
    if (execute(k, hi) = 2) then     max := hi else (     while (lo < hi) do (     t := (hi / 2) + (lo / 2) + (((hi mod 2) + (lo mod 2)) / 2) ; 
     if (execute(k, t) <= 2) then     lo := t + 1 ; else     hi := t ; ) ; 
     max := hi - 1 ; 
     hi := "9223372036854775807"->toLong() ; 
     lo := 2 ) ;  
    if (execute(k, lo) = 2) then     min := lo else (     while (lo < hi) do (     t := (hi / 2) + (lo / 2) + ((1 + (hi mod 2) + (lo mod 2)) / 2) ; 
     if (t < 0) then (     min := "9223372036854775807"->toLong() ; 
     break ) else skip ; 
     if (execute(k, t) >= 2) then     hi := t - 1 ; else     lo := t ; ) ; 
     min := lo + 1 ) ;  
    if (min > max) then     OclFile["System.out"].println(-1) else     OclFile["System.out"].println(min + " " + max) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B332 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int K=in.nextInt();
    int[] A=new int[N];
    for(int n=0 ; n<N ; n++){
      A[n]=in.nextInt();
    }
    long[] sum=new long[N+1];
    for(int n=0 ; n<N ; n++){
      sum[n+1]=sum[n]+A[n];
    }
    long[] maxKSum=new long[N];
    int[] maxStart=new int[N];
    maxKSum[K-1]=sum[K];
    maxStart[K-1]=0 ;
    for(int n=K ; n<N ; n++){
      long candidate=sum[n+1]-sum[n+1-K];
      if(candidate>maxKSum[n-1]){
        maxKSum[n]=candidate ;
        maxStart[n]=n+1-K ;
      }
      else {
        maxKSum[n]=maxKSum[n-1];
        maxStart[n]=maxStart[n-1];
      }
    }
    long max=sum[2*K];
    int start1=0 ;
    int start2=K ;
    for(int n=2*K ; n<N ; n++){
      long candidate=sum[n+1]-sum[n+1-K]+maxKSum[n-K];
      if(candidate>max){
        max=candidate ;
        start2=n+1-K ;
        start1=maxStart[n-K];
      }
    }
    System.out.println((start1+1)+" "+(start2+1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B332 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var sum : Sequence(long) ; sum := Integer.subrange(1,N + 1)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     sum[n + 1+1] := sum[n+1] + A[n+1] )  ;     n := n + 1 ) ; 
    var maxKSum : Sequence(long) ; maxKSum := Integer.subrange(1,N)->collect(0) ;
    var maxStart : Sequence(int) ; maxStart := Integer.subrange(1,N)->collect(0) ;
    maxKSum[K - 1+1] := sum[K+1] ; 
    maxStart[K - 1+1] := 0 ; 
        var n : int ; n := K ; while n < N do ( (     var candidate : long ; candidate := sum[n + 1+1] - sum[n + 1 - K+1] ;
     if (candidate > maxKSum[n - 1+1]) then (     maxKSum[n+1] := candidate ; 
     maxStart[n+1] := n + 1 - K ) else (     maxKSum[n+1] := maxKSum[n - 1+1] ; 
     maxStart[n+1] := maxStart[n - 1+1] ) )  ;     n := n + 1 ) ; 
    var max : long ; max := sum[2 * K+1] ;
    var start1 : int ; start1 := 0 ;
    var start2 : int ; start2 := K ;
        var n : int ; n := 2 * K ; while n < N do ( (     var candidate : long ; candidate := sum[n + 1+1] - sum[n + 1 - K+1] + maxKSum[n - K+1] ;
     if (candidate > max) then (     max := candidate ; 
     start2 := n + 1 - K ; 
     start1 := maxStart[n - K+1] ) else skip )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println((start1 + 1) + " " + (start2 + 1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Ac {
  static Scanner sc=new Scanner(System.in);
  public static void main(String args[]){
    int t=1 ;
    while(t!=0){
      solve();
      t--;
    }
  }
  public static void solve(){
    int n=sc.nextInt();
    int k=sc.nextInt();
    long arr[]=new long[200001];
    long seg[]=new long[200001];
    int mxs[]=new int[200001];
    arr[0]=0 ;
    for(int i=1 ; i<=n ; i++)arr[i]=sc.nextInt();
    for(int i=1 ; i<=n ; i++)arr[i]=arr[i-1]+arr[i];
    for(int i=1 ; i<=n-k+1 ; i++)seg[i]=arr[i+k-1]-arr[i-1];
    mxs[n-k+1]=n-k+1 ;
    for(int i=n-k ; i>=0 ; i--){
      if(seg[mxs[i+1] ]>seg[i])mxs[i]=mxs[i+1];
      else mxs[i]=i ;
    }
    long ans=0,a=1,b=2 ;
    for(int i=1 ; i<n-k+1 ; i++){
      if(i+k>n-k+1)break ;
      long curans=seg[i]+seg[mxs[i+k] ];
      if(curans>ans){
        ans=curans ;
        a=i ;
        b=mxs[i+k];
      }
    }
    System.out.print(a+" "+b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ac {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
     while (t /= 0) do (     execute solve() ; 
     t := t - 1 ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,200001)->collect(0) ;
    var seg : Sequence(long) ; seg := Integer.subrange(1,200001)->collect(0) ;
    var mxs : Sequence(int) ; mxs := Integer.subrange(1,200001)->collect(0) ;
    arr[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (     arr[i+1] := arr[i - 1+1] + arr[i+1] ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n - k + 1 do (     seg[i+1] := arr[i + k - 1+1] - arr[i - 1+1] ;  ;     i := i + 1 ) ; 
    mxs[n - k + 1+1] := n - k + 1 ; 
        var i : int ; i := n - k ; while i >= 0 do ( (     if (seg[mxs[i + 1+1]+1] > seg[i+1]) then     mxs[i+1] := mxs[i + 1+1] ; else     mxs[i+1] := i ; )  ;     i := i - 1 ) ; 
    var ans : long ; ans := 0 ;
    var a : long ; a := 1 ;
    var b : long ; b := 2 ;
        var i : int ; i := 1 ; while i < n - k + 1 do ( (     if (i + k > n - k + 1) then     break else skip ; 
     var curans : long ; curans := seg[i+1] + seg[mxs[i + k+1]+1] ;
     if (curans > ans) then (     ans := curans ; 
     a := i ; 
     b := mxs[i + k+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(a + " " + b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long n=in.nextLong();
    long s=n-2 ;
    System.out.println(s*s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toLong() ;
     var s : long ; s := n - 2 ;
     OclFile["System.out"].println(s * s) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long x=sc.nextLong();
      long y=sc.nextLong();
      if(x % 2==0){
        if(x>3)System.out.println("YES");
        else if(y<=3)System.out.println("YES");
        else System.out.println("NO");
      }
      else {
        if((x==3 && y>x)||(x==1 && y>x))System.out.println("NO");
        else System.out.println("YES");
      }
    }
  }
  static boolean isPrime(long n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static long gcd(long a,long b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static long lcm(long a,long b){
    return(a/gcd(a,b))*b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x : long ; x := sc.getCurrent()->toLong() ;
     var y : long ; y := sc.getCurrent()->toLong() ;
     if (x mod 2 = 0) then (     if (x > 3) then     OclFile["System.out"].println("YES") ; else     if (y <= 3) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  ) else (     if ((x = 3 & y > x) or (x = 1 & y > x)) then     OclFile["System.out"].println("NO") ; else     OclFile["System.out"].println("YES") ; ) ) ;  ) );
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a / gcd(a, b)) * b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class AA {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int p=0 ; p<t ; p++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      if(x==1 && y>1)System.out.println("NO");
      else if(x<=3 && y>3)System.out.println("NO");
      else System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var p : int ; p := 0 ; while p < t do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     if (x = 1 & y > 1) then     OclFile["System.out"].println("NO") ; else     if (x <= 3 & y > 3) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  )  ;     p := p + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    for(int i=0 ; i<t ; i++){
      long x=scanner.nextLong();
      long y=scanner.nextLong();
      System.out.println(method(x,y));
    }
  }
  private static String method(long x,long y){
    if(x>=y){
      return "YES" ;
    }
    if(x==1 || x==3){
      return "NO" ;
    }
    if(x==2 && y>3){
      return "NO" ;
    }
    return "YES" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var x : long ; x := scanner.getCurrent()->toLong() ;
     var y : long ; y := scanner.getCurrent()->toLong() ;
     OclFile["System.out"].println(method(x, y)) )  ;     i := i + 1 ) );
  static   operation method( x : long, y : long) : String
  pre: true
  post: true
  activity: (     if (x >= y) then (     return "YES" ) else skip ; 
     if (x = 1 or x = 3) then (     return "NO" ) else skip ; 
     if (x = 2 & y > 3) then (     return "NO" ) else skip ; 
     return "YES" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF610A {
  public static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    long n=scanner.nextLong();
    if(n % 2!=0)System.out.println(0);
    else {
      long xy=n/2 ;
      if(xy % 2==0){
        long res=xy/2-1 ;
        System.out.println(Math.max(res,0));
      }
      else System.out.println(xy/2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF610A {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : long ; n := scanner.getCurrent()->toLong() ;
     if (n mod 2 /= 0) then     OclFile["System.out"].println(0) ; else (     var xy : long ; xy := n / 2 ;
     if (xy mod 2 = 0) then (     var res : long ; res := xy / 2 - 1 ;
     OclFile["System.out"].println(Set{res, 0}->max()) ) else     OclFile["System.out"].println(xy / 2) ; ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class PashaStick {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    int n=Integer.parseInt(br.readLine());
    int count=countNum(n);
    pr.println(count);
    pr.flush();
  }
  private static int countNum(int n){
    if(n % 2!=0)return 0 ;
    if(n % 4==0)return((n/4)-1);
    return n/4 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class PashaStick {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var count : int ; count := countNum(n) ;
    skip ; 
    skip ; 
 );
  static   operation countNum( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 /= 0) then     return 0 else skip ; 
     if (n mod 4 = 0) then     return ((n / 4) - 1) else skip ; 
     return n / 4 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class pasha_sticks {
  public static void main(String args[]){
    Long n ;
    Scanner in=new Scanner(System.in);
    n=in.nextLong();
    if(n % 2!=0)n=0L ;
    Long half=n/2 ;
    Long halfhalf=half/2 ;
    if(half % 2==0)halfhalf--;
    if(halfhalf<=0){
      halfhalf=0L ;
    }
    System.out.println(halfhalf);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pasha_sticks {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := in.getCurrent()->toLong() ; 
    if (n mod 2 /= 0) then     n := 0L ; else skip ; 
    var half : long ; half := n / 2 ;
    var halfhalf : long ; halfhalf := half / 2 ;
    if (half mod 2 = 0) then     halfhalf := halfhalf - 1 ; else skip ; 
    if (halfhalf <= 0) then (     halfhalf := 0L ) else skip ; 
    OclFile["System.out"].println(halfhalf) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=Integer.parseInt(scan.next());
    int k=Integer.parseInt(scan.next());
    int[] p=new int[n];
    int[] c=new int[n];
    for(int i=0 ; i<n ; i++){
      p[i]=Integer.parseInt(scan.next());
      p[i]--;
    }
    for(int i=0 ; i<n ; i++){
      c[i]=Integer.parseInt(scan.next());
    }
    scan.close();
    long ans=Long.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      int cur=i ;
      List<Integer>cList=new ArrayList<Integer>();
      long total=0 ;
      while(true){
        cur=p[cur];
        cList.add(c[cur]);
        total+=c[cur];
        if(cur==i){
          break ;
        }
      }
      if(k<=cList.size()){
        long sum=0 ;
        for(int j=0 ; j<k ; j++){
          sum+=cList.get(j);
          ans=Math.max(ans,sum);
        }
        continue ;
      }
      if(total<=0){
        long sum=0 ;
        for(int j : cList){
          sum+=j ;
          ans=Math.max(ans,sum);
        }
      }
      else {
        int loopCount=k/cList.size();
        int amari=k % cList.size();
        if(amari==0){
          loopCount--;
          amari=cList.size();
        }
        long sum=total*loopCount ;
        ans=Math.max(ans,sum);
        for(int j=0 ; j<amari ; j++){
          sum+=cList.get(j);
          ans=Math.max(ans,sum);
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (scan.getCurrent())->toInteger() ;
    var k : int ; k := (scan.getCurrent())->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := (scan.getCurrent())->toInteger() ; 
     p[i+1] := p[i+1] - 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := (scan.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : long ; ans := "-9223372036854775808"->toLong() ;
        var i : int ; i := 0 ; while i < n do ( (     var cur : int ; cur := i ;
     var cList : Sequence(int) ; cList := Sequence{} ;
    var total : long ; total := 0 ;
    while (true) do (     cur := p[cur+1] ; 
     cList := cList->including(c[cur+1]) ; 
     total := total+(c[cur+1]) ; 
     if (cur = i) then (     break ) else skip ) ; 
    if (k <= cList->size()) then (     var sum : long ; sum := 0 ;
         var j : int ; j := 0 ; while j < k do ( (     sum := sum+(cList->at(j+1)) ; 
     ans := Set{ans, sum}->max() )  ;     j := j + 1 ) ; 
     continue ) else skip ; 
    if (total <= 0) then (     var sum : long ; sum := 0 ;
     for (j : cList) do ( (     sum := sum+(j) ; 
     ans := Set{ans, sum}->max() )  ) ) else (     var loopCount : int ; loopCount := k / cList->size() ;
     var amari : int ; amari := k mod cList->size() ;
    if (amari = 0) then (     loopCount := loopCount - 1 ; 
     amari := cList->size() ) else skip ; 
    var sum : long ; sum := total * loopCount ;
    ans := Set{ans, sum}->max() ; 
        var j : int ; j := 0 ; while j < amari do ( (     sum := sum+(cList->at(j+1)) ; 
     ans := Set{ans, sum}->max() )  ;     j := j + 1 ) ; 
 ) ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int centereddecagonalnum(int n){
    return(5*n*n+5*n+1);
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.print(n+"th centered "+"decagonal number: ");
    System.out.println(centereddecagonalnum(n));
    n=9 ;
    System.out.print(n+"th centered "+"decagonal number: ");
    System.out.println(centereddecagonalnum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation centereddecagonalnum( n : int) : int
  pre: true
  post: true
  activity: (     return (5 * n * n + 5 * n + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].print(n + "th centered " + "decagonal number: ") ; 
    OclFile["System.out"].println(centereddecagonalnum(n)) ; 
    n := 9 ; 
    OclFile["System.out"].print(n + "th centered " + "decagonal number: ") ; 
    OclFile["System.out"].println(centereddecagonalnum(n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findEvenPair(int A[],int N){
    int count=0 ;
    for(int i=0 ; i<N ; i++)if((!((A[i] & 1)>0)))count++;
    return count*(count-1)/2 ;
  }
  public static void main(String[] args){
    int A[]={
      5,6,2,8 };
      int N=A.length ;
      System.out.println(findEvenPair(A,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findEvenPair( A : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < N do (     if ((not(((A[i+1] & 1) > 0)))) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return count * (count - 1) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{5,6,2,8} ;
     var N : int ; N := A->size() ;
     OclFile["System.out"].println(findEvenPair(A, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long n=in.nextLong();
    System.out.println((n-2)*(n-2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toLong() ;
     OclFile["System.out"].println((n - 2) * (n - 2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1382A_CommonSubsequence {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int n=input.nextInt();
      int m=input.nextInt();
      Set<Integer>nSet=new HashSet<>();
      for(int i=0 ; i<n ; i++){
        nSet.add(input.nextInt());
      }
      int result=-1 ;
      for(int i=0 ; i<m ; i++){
        int num=input.nextInt();
        if(result==-1 && nSet.contains(num)){
          result=num ;
        }
      }
      if(result==-1){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
        System.out.printf("1 %d\n",result);
      }
      input.nextLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1382A_CommonSubsequence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := input.getCurrent()->toInteger() ;
     var m : int ; m := input.getCurrent()->toInteger() ;
    var nSet : Set(int) ; nSet := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     nSet := nSet->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var result : int ; result := -1 ;
        var i : int ; i := 0 ; while i < m do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
     if (result = -1 & nSet->includes(num)) then (     result := num ) else skip )  ;     i := i + 1 ) ; 
    if (result = -1) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].printf("1 %d\n", result) ) ;  
    skip ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; ++i){
        a[i]=sc.nextInt();
      }
      int[] b=new int[m];
      for(int i=0 ; i<b.length ; ++i){
        b[i]=sc.nextInt();
      }
      System.out.println(solve(a,b));
    }
    sc.close();
  }
  static String solve(int[] a,int[] b){
    Set<Integer>setA=Arrays.stream(a).boxed().collect(Collectors.toSet());
    for(int bi : b){
      if(setA.contains(bi)){
        return String.format("YES\n1 %d",bi);
      }
    }
    return "NO" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < b->size() do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(a, b)) ; 
 )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : Sequence(int), b : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var setA : Set(int) ; setA := stream(a).collect(Collectors.toSet()) ;
     for (bi : b) do ( (     if (setA->includes(bi)) then (     return StringLib.format("YES\n1 %d",Sequence{bi}) ) else skip )  ) ; 
     return "NO" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Round658A {
  public static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t-->0){
      int[] arr=Arrays.stream(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
      int[] arr_one=Arrays.stream(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
      int[] arr_two=Arrays.stream(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
      HashMap<Integer,Integer>map=new HashMap<>();
      int ans=0 ;
      for(int i=0 ; i<arr_one.length ; i++){
        if(! map.containsKey(arr_one[i])){
          map.put(arr_one[i],1);
        }
      }
      for(int i=0 ; i<arr_two.length ; i++){
        if(map.containsKey(arr_two[i])){
          ans=arr_two[i];
        }
      }
      if(ans!=0){
        pw.println("YES");
        pw.println(1+" "+ans);
      }
      else {
        pw.println("NO");
      }
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Round658A {
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var arr : Sequence(int) ; arr := stream(br.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
     var arr_one : Sequence(int) ; arr_one := stream(br.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var arr_two : Sequence(int) ; arr_two := stream(br.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var map : Map(int,int) ; map := Map{} ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < arr_one->size() do ( (     if (not(map->keys()->includes(arr_one[i+1]))) then (     map := map->union(Map{arr_one[i+1] |-> 1}) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < arr_two->size() do ( (     if (map->keys()->includes(arr_two[i+1])) then (     ans := arr_two[i+1] ) else skip )  ;     i := i + 1 ) ; 
    if (ans /= 0) then (     skip ; 
     skip ) else (     skip ) ;  
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class test239 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int m=in.nextInt();
      ArrayList<Integer>a=new ArrayList<Integer>();
      for(int i=0 ; i<n ; i++){
        a.add(in.nextInt());
      }
      boolean x=true ;
      for(int i=0 ; i<m ; i++){
        int b=in.nextInt();
        if(a.contains(b)&& x){
          System.out.println("YES");
          System.out.println(1+" "+b);
          x=false ;
        }
      }
      if(x){
        System.out.println("NO");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test239 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     a := a->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var x : boolean ; x := true ;
        var i : int ; i := 0 ; while i < m do ( (     var b : int ; b := in.getCurrent()->toInteger() ;
     if (a->includes(b) & x) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(1 + " " + b) ; 
     x := false ) else skip )  ;     i := i + 1 ) ; 
    if (x) then (     OclFile["System.out"].println("NO") ) else skip ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void Find_Sequence(int[] arr,int n){
    Vector<Integer>inc_arr=new Vector<>(),dec_arr=new Vector<>();
    int flag=0 ;
    long inc=-1,dec=(long)1e7 ;
    for(int i=0 ; i<n ; i++){
      if(inc<arr[i] && arr[i]<dec){
        if(arr[i]<arr[i+1]){
          inc=arr[i];
          inc_arr.add(arr[i]);
        }
        else {
          dec=arr[i];
          dec_arr.add(arr[i]);
        }
      }
      else if(inc<arr[i]){
        inc=arr[i];
        inc_arr.add(arr[i]);
      }
      else if(dec>arr[i]){
        dec=arr[i];
        dec_arr.add(arr[i]);
      }
      else {
        System.out.println(-1);
        flag=1 ;
        break ;
      }
    }
    if(flag==0){
      for(int i : inc_arr)System.out.print(i+" ");
      System.out.println();
      for(int i : dec_arr)System.out.print(i+" ");
      System.out.println();
    }
  }
  public static void main(String[] args){
    int[] arr={
      5,1,3,6,8,2,9,0,10 };
      int n=arr.length ;
      Find_Sequence(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Find_Sequence( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var inc_arr : Sequence(int) ; inc_arr := Sequence{} ;
    var dec_arr : Sequence(int) ; dec_arr := Sequence{} ;
     var flag : int ; flag := 0 ;
    var inc : long ; inc := -1 ;
    var dec : long ; dec := 1e7->oclAsType(long) ;
        var i : int ; i := 0 ; while i < n do ( (     if (inc < arr[i+1] & arr[i+1] < dec) then (     if (arr[i+1] < arr[i + 1+1]) then (     inc := arr[i+1] ; 
     inc_arr := inc_arr->including(arr[i+1]) ) else (     dec := arr[i+1] ; 
     dec_arr->excludes(arr[i+1]) ) ) else     if (inc < arr[i+1]) then (     inc := arr[i+1] ; 
     inc_arr := inc_arr->including(arr[i+1]) ) else     if (dec > arr[i+1]) then (     dec := arr[i+1] ; 
     dec_arr->excludes(arr[i+1]) ) else (     OclFile["System.out"].println(-1) ; 
     flag := 1 ; 
     break ) ;  ;  )  ;     i := i + 1 ) ; 
    if (flag = 0) then (     for (i : inc_arr) do (     OclFile["System.out"].print(i + " ") ;  ) ; 
     OclFile["System.out"].println() ; 
     for (i : dec_arr) do (     OclFile["System.out"].print(i + " ") ;  ) ; 
     OclFile["System.out"].println() ) else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,1,3,6,8,2,9,0,10} ;
     var n : int ; n := arr->size() ;
     execute Find_Sequence(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int digitSum(int n){
    int ans=0 ;
    while(n!=0){
      ans+=n % 10 ;
      n/=10 ;
    }
    return ans ;
  }
  static int findInt(int n,int m){
    int minDigit=(int)Math.floor((double)(m/9));
    int start=(int)Math.pow(10,minDigit)-(int)Math.pow(10,minDigit)% n ;
    while(start<Integer.MAX_VALUE){
      if(digitSum(start)==m)return start ;
      else start+=n ;
    }
    return-1 ;
  }
  static public void main(String args[]){
    int n=13,m=32 ;
    System.out.print(findInt(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation digitSum( n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     while (n /= 0) do (     ans := ans+(n mod 10) ; 
     n := n/(10) ) ; 
     return ans );
  static   operation findInt( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var minDigit : int ; minDigit := ((m / 9)->oclAsType(double))->floor()->oclAsType(int) ;
     var start : int ; start := 10->pow(minDigit)->oclAsType(int) - 10->pow(minDigit)->oclAsType(int) mod n ;
     while (start < 2147483647) do (     if (digitSum(start) = m) then     return start else     start := start+(n) ; ) ; 
     return -1 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 13 ;
    var m : int ; m := 32 ;
     OclFile["System.out"].print(findInt(n, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication71 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num1=sc.nextInt();
    int count=num1+(int)(.5*num1);
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication71 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num1 : int ; num1 := sc.getCurrent()->toInteger() ;
     var count : int ; count := num1 + (.5 * num1)->oclAsType(int) ;
     OclFile["System.out"].println(count) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int a=sc.nextInt();
      int ans=(a/2)*3 ;
      System.out.println(ans);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var ans : int ; ans := (a / 2) * 3 ;
     OclFile["System.out"].println(ans) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int N=gi();
    long K=gl();
    long[] P=new long[N];
    long[] C=new long[N];
    for(int i=0 ; i<N ; i++){
      P[i]=gl()-1 ;
    }
    for(int i=0 ; i<N ; i++){
      C[i]=gl();
    }
    long ans=Long.MIN_VALUE ;
    for(int s=0 ; s<N ; s++){
      long pos=s ;
      long tmp=0 ;
      long roop=0 ;
      long max=C[(int)P[s] ];
      do {
        roop++;
        pos=P[(int)pos];
        tmp+=C[(int)pos];
        max=Math.max(max,tmp);
      }
      while(pos!=s && roop<K);
      if(tmp>0 && roop!=K){
        long r=Math.floorDiv(K,roop);
        long z=K % roop ;
        z+=roop ;
        long mm=tmp*(r-1);
        pos=s ;
        tmp=0 ;
        max=0 ;
        for(int i=0 ; i<z ; i++){
          pos=P[(int)pos];
          tmp+=C[(int)pos];
          max=Math.max(max,tmp);
        }
        max+=mm ;
      }
      ans=Math.max(ans,max);
    }
    System.out.println(ans);
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : int ; N := gi() ;
    var K : long ; K := gl() ;
    var P : Sequence(long) ; P := Integer.subrange(1,N)->collect(0) ;
    var C : Sequence(long) ; C := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     P[i+1] := gl() - 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     C[i+1] := gl() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := "-9223372036854775808"->toLong() ;
        var s : int ; s := 0 ; while s < N do ( (     var pos : long ; pos := s ;
     var tmp : long ; tmp := 0 ;
    var roop : long ; roop := 0 ;
    var max : long ; max := C[P[s+1]->oclAsType(int)+1] ;
  while true do ((     roop := roop + 1 ; 
     pos := P[pos->oclAsType(int)+1] ; 
     tmp := tmp+(C[pos->oclAsType(int)+1]) ; 
     max := Set{max, tmp}->max() ) ;
    if (pos /= s & roop < K) then skip else break) ; 
    if (tmp > 0 & roop /= K) then (     var r : long ; r := floorDiv(K, roop) ;
     var z : long ; z := K mod roop ;
    z := z+(roop) ; 
    var mm : long ; mm := tmp * (r - 1) ;
    pos := s ; 
    tmp := 0 ; 
    max := 0 ; 
        var i : int ; i := 0 ; while i < z do ( (     pos := P[pos->oclAsType(int)+1] ; 
     tmp := tmp+(C[pos->oclAsType(int)+1]) ; 
     max := Set{max, tmp}->max() )  ;     i := i + 1 ) ; 
    max := max+(mm) ; 
 ) else skip ; 
    ans := Set{ans, max}->max() ; 
 )  ;     s := s + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication49 {
  public static void main(String[] args){
    Scanner read=new Scanner(System.in);
    ArrayList<Long>list=new ArrayList();
    long n=read.nextLong(),sum=0 ;
    System.out.println(n*2-n/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication49 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : OclFile ; read := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(long) ; list := Sequence{} ;
     var n : long ; n := read.getCurrent()->toLong() ;
    var sum : long ; sum := 0 ;
     OclFile["System.out"].println(n * 2 - n / 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      long n=in.nextLong();
      n-=2 ;
      long res=n*n ;
      out.println(res);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    boolean hasNext(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(Exception e){
          return false ;
        }
      }
      return true ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      String str=null ;
      try {
        str=reader.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public BigInteger nextBigInteger(){
      return new BigInteger(next());
    }
    public BigDecimal nextBigDecimal(){
      return new BigDecimal(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : long ; n := in.nextLong() ;
     n := n-(2) ; 
     var res : long ; res := n * n ;
     skip );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : ProgramException) do (     return false )
 ) ; 
     return true );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := null ;
     try (     str := reader.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextBigInteger() : long
  pre: true
  post: true
  activity: (     return long(next()) );
   operation nextBigDecimal() : double
  pre: true
  post: true
  activity: (     return double(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int in=sc.nextInt();
    int r=(3*in)/2 ;
    System.out.println(r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var in : int ; in := sc.getCurrent()->toInteger() ;
     var r : int ; r := (3 * in) / 2 ;
     OclFile["System.out"].println(r) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int P=sc.nextInt();
    int Q=sc.nextInt();
    int R=sc.nextInt();
    int tmp=Math.min(P+Q,Q+R);
    int ans=Math.min(tmp,R+P);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var P : int ; P := sc.getCurrent()->toInteger() ;
    var Q : int ; Q := sc.getCurrent()->toInteger() ;
    var R : int ; R := sc.getCurrent()->toInteger() ;
    var tmp : int ; tmp := Set{P + Q, Q + R}->min() ;
    var ans : int ; ans := Set{tmp, R + P}->min() ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  static String br=System.getProperty("line.separator");
  static Scanner sc=new Scanner(System.in);
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    int P=nextInt();
    int Q=nextInt();
    int R=nextInt();
    int a=P+Q ;
    int b=Math.min(P+R,a);
    int c=Math.min(Q+R,b);
    println(c);
  }
  static long lcm(long a,long b){
    long temp ;
    long c=a ;
    c*=b ;
    while((temp=a % b)!=0){
      a=b ;
      b=temp ;
    }
    return(c/b);
  }
  static int nextInt(){
    return Integer.parseInt(next());
  }
  static Long nextLong(){
    return Long.parseLong(next());
  }
  static String next(){
    return sc.next();
  }
  static String nextLine(){
    return sc.nextLine();
  }
  static void println(Object o){
    out.println(o);
    out.flush();
  }
  static void print(Object o){
    PrintWriter out=new PrintWriter(System.out);
    out.print(o);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : String := OclProcess.getEnvironmentProperty("line.separator");
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var P : int ; P := nextInt() ;
     var Q : int ; Q := nextInt() ;
    var R : int ; R := nextInt() ;
    var a : int ; a := P + Q ;
    var b : int ; b := Set{P + R, a}->min() ;
    var c : int ; c := Set{Q + R, b}->min() ;
    execute println(c) ; 
 );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var temp : long ;
     var c : long ; c := a ;
    c := c*(b) ; 
        temp := a mod b ;
    while ((temp) /= 0) do (    skip ; (     a := b ; 
     b := temp ) ;     temp := a mod b ;
 ) ;  
    return (c / b) 
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation next() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     return sc.nextLine() );
  static   operation println( o : OclAny) : void
  pre: true
  post: true
  activity: (     skip ; 
     skip );
  static   operation print( o : OclAny) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     skip ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int[] arr=new int[3];
    for(int i=0 ; i<3 ; ++i)arr[i]=Integer.parseInt(st.nextToken());
    Arrays.sort(arr);
    bw.write((arr[0]+arr[1])+"");
    bw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do (     arr[i+1] := (st.next())->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String in=br.readLine();
      String chr[]=in.split(" ");
      int p=Integer.parseInt(chr[0]);
      int q=Integer.parseInt(chr[1]);
      int r=Integer.parseInt(chr[2]);
      System.out.println(p+q+r-Math.max(p,Math.max(q,r)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var in : String ; in := br.readLine() ;
     var chr : Sequence(String) ; chr := in->split(" ") ;
    var p : int ; p := (chr[0+1])->toInteger() ;
    var q : int ; q := (chr[1+1])->toInteger() ;
    var r : int ; r := (chr[2+1])->toInteger() ;
    OclFile["System.out"].println(p + q + r - Set{p, Set{q, r}->max()}->max()) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner entrada=new Scanner(System.in);
    int count=0 ;
    int x[]=new int[3];
    int x2[]=new int[3];
    for(int i=0 ; i<3 ; i++){
      x[i]=entrada.nextInt();
    }
    for(int i=0 ; i<2 ; i++){
      for(int j=i+1 ; j<3 ; j++){
        x2[count]=x[i]+x[j];
        count++;
      }
    }
    Arrays.sort(x2);
    System.out.println(x2[0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var entrada : OclFile ; entrada := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := 0 ;
    var x : Sequence(int) ; x := Integer.subrange(1,3)->collect(0) ;
    var x2 : Sequence(int) ; x2 := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     x[i+1] := entrada.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 2 do ( (         var j : int ; j := i + 1 ; while j < 3 do ( (     x2[count+1] := x[i+1] + x[j+1] ; 
     count := count + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    x2 := x2->sort() ; 
    OclFile["System.out"].println(x2[0+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Test {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      String str=sc.next();
      int totalStones=0 ;
      for(int i=0 ; i<str.length(); i++){
        if(str.charAt(i)=='+')totalStones+=1 ;
        else {
          if(totalStones>0)totalStones-=1 ;
        }
      }
      if(totalStones<0)totalStones=0 ;
      System.out.println(totalStones);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var str : String ; str := sc.getCurrent() ;
    var totalStones : int ; totalStones := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '+') then     totalStones := totalStones+(1) ; else (     if (totalStones > 0) then     totalStones := totalStones-(1) ; else skip ) )  ;     i := i + 1 ) ; 
    if (totalStones < 0) then     totalStones := 0 ; else skip ; 
    OclFile["System.out"].println(totalStones) ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testcases=1 ;
    for(int t=0 ; t<testcases ; ++t){
      int n=sc.nextInt();
      String s=sc.next();
      int ans=0 ;
      for(int i=0 ; i<n ; ++i){
        if(s.charAt(i)=='-'){
          ans=Math.max(0,ans-1);
        }
        else {
          ans++;
        }
      }
      System.out.println(ans);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testcases : int ; testcases := 1 ;
         var t : int ; t := 0 ; while t < testcases do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = '-') then (     ans := Set{0, (ans)->char2byte() - 1}->max() ) else (     ans := ans + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     t := t + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printFun(int test){
    if(test<1)return ;
    else {
      System.out.printf("%d ",test);
      printFun(test-1);
      System.out.printf("%d ",test);
      return ;
    }
  }
  public static void main(String[] args){
    int test=3 ;
    printFun(test);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printFun( test : int) : void
  pre: true
  post: true
  activity: (     if (test < 1) then     return else (     OclFile["System.out"].printf("%d ", test) ; 
     execute printFun(test - 1) ; 
     OclFile["System.out"].printf("%d ", test) ; 
     return ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var test : int ; test := 3 ;
     execute printFun(test) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] p=new int[n];
    for(int i=0 ; i<n ; i++){
      p[i]=sc.nextInt()-1 ;
    }
    int[] c=new int[n];
    for(int i=0 ; i<n ; i++){
      c[i]=sc.nextInt();
    }
    sc.close();
    long ans=Long.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      int idx=i ;
      long max=Long.MIN_VALUE ;
      long one=0 ;
      for(int j=1 ; j<=k ; j++){
        idx=p[idx];
        one+=c[idx];
        max=Math.max(max,one);
        if(idx==i){
          if(one>0){
            long x=k/j ;
            long val=one*(x-1);
            long r=k % j+j ;
            one=0 ;
            long max2=0 ;
            for(int j2=0 ; j2<r ; j2++){
              idx=p[idx];
              one+=c[idx];
              max2=Math.max(max2,one);
            }
            val+=max2 ;
            max=Math.max(max,val);
          }
          break ;
        }
      }
      ans=Math.max(ans,max);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := sc.getCurrent()->toInteger() - 1 )  ;     i := i + 1 ) ; 
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : long ; ans := "-9223372036854775808"->toLong() ;
        var i : int ; i := 0 ; while i < n do ( (     var idx : int ; idx := i ;
     var max : long ; max := "-9223372036854775808"->toLong() ;
    var one : long ; one := 0 ;
        var j : int ; j := 1 ; while j <= k do ( (     idx := p[idx+1] ; 
     one := one+(c[idx+1]) ; 
     max := Set{max, one}->max() ; 
     if (idx = i) then (     if (one > 0) then (     var x : long ; x := k / j ;
     var val : long ; val := one * (x - 1) ;
    var r : long ; r := k mod j + j ;
    one := 0 ; 
    var max2 : long ; max2 := 0 ;
        var j2 : int ; j2 := 0 ; while j2 < r do ( (     idx := p[idx+1] ; 
     one := one+(c[idx+1]) ; 
     max2 := Set{max2, one}->max() )  ;     j2 := j2 + 1 ) ; 
    val := val+(max2) ; 
    max := Set{max, val}->max() ; 
 ) else skip ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    ans := Set{ans, max}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    new Solver().run();
  }
}
class Solver {
  public void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
    }
    Boolean down=null ;
    boolean equa=false ;
    long cur=Long.MIN_VALUE ;
    int cnt=0 ;
    cur=A[0];
    for(int i=1 ; i<A.length ; i++){
      if(cur==A[i]){
        equa=true ;
        cur=A[i];
        continue ;
      }
      else {
        equa=false ;
      }
      if(cur>A[i]){
        if(down!=null && ! down){
          cnt++;
          down=null ;
        }
        else {
          down=true ;
        }
      }
      else {
        if(down!=null && down){
          cnt++;
          down=null ;
        }
        else {
          down=false ;
        }
      }
      cur=A[i];
    }
    System.out.println(cnt+1);
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Solver.newSolver().run() );
}
class Solver {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var down : Boolean ; down := null ;
    var equa : boolean ; equa := false ;
    var cur : long ; cur := "-9223372036854775808"->toLong() ;
    var cnt : int ; cnt := 0 ;
    cur := A[0+1] ; 
        var i : int ; i := 1 ; while i < A->size() do ( (     if (cur = A[i+1]) then (     equa := true ; 
     cur := A[i+1] ; 
     continue ) else (     equa := false ) ;  
     if (cur > A[i+1]) then (     if (down /= null & not(down)) then (     cnt := cnt + 1 ; 
     down := null ) else (     down := true ) ) else (     if (down /= null & down) then (     cnt := cnt + 1 ; 
     down := null ) else (     down := false ) ) ;  
     cur := A[i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt + 1) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      long n=in.nextLong();
      n-=2 ;
      long m=n*n ;
      out.println(m);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    boolean hasNext(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(Exception e){
          return false ;
        }
      }
      return true ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      String str=null ;
      try {
        str=reader.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public BigInteger nextBigInteger(){
      return new BigInteger(next());
    }
    public BigDecimal nextBigDecimal(){
      return new BigDecimal(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : long ; n := in.nextLong() ;
     n := n-(2) ; 
     var m : long ; m := n * n ;
     skip );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : ProgramException) do (     return false )
 ) ; 
     return true );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := null ;
     try (     str := reader.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextBigInteger() : long
  pre: true
  post: true
  activity: (     return long(next()) );
   operation nextBigDecimal() : double
  pre: true
  post: true
  activity: (     return double(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class gcdOfFibonacci {
  static final int MAX=1000 ;
  static int[] f ;
  gcdOfFibonacci(){
    f=new int[MAX];
  }
  private static int fib(int n){
    if(n==0)return 0 ;
    if(n==1 || n==2)return(f[n]=1);
    if(f[n]!=0)return f[n];
    int k=((n & 1)==1)?(n+1)/2 : n/2 ;
    f[n]=((n & 1)==1)?(fib(k)*fib(k)+fib(k-1)*fib(k-1)):(2*fib(k-1)+fib(k))*fib(k);
    return f[n];
  }
  private static int gcd(int M,int N){
    if(M==0)return N ;
    return gcd(N % M,M);
  }
  static int findGCDofFibMFibN(int M,int N){
    return fib(gcd(M,N));
  }
  public static void main(String[] args){
    gcdOfFibonacci obj=new gcdOfFibonacci();
    int M=3,N=12 ;
    System.out.println(findGCDofFibMFibN(M,N));
  }
}
------------------------------------------------------------
OCL File:
---------
class gcdOfFibonacci {
  static    attribute MAX : int := 1000;
  static   attribute f : Sequence(int);
   static operation newgcdOfFibonacci() : gcdOfFibonacci
  pre: true
  post: true
  activity:
  ( var self : gcdOfFibonacci ;
    self := creategcdOfFibonacci();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     f := Integer.subrange(1,MAX)->collect(0) );
  static   operation fib( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else skip ; 
     if (n = 1 or n = 2) then     return (f[n+1]) else skip ; 
    if (f[n+1] /= 0) then     return f[n+1] else skip ; 
    var k : int ; k := if ((MathLib.bitwiseAnd(n,1)) = 1) then (n + 1) / 2 else n / 2 endif ;
    f[n+1] := if ((n & 1) = 1) then (fib(k) * fib(k) + fib(k - 1) * fib(k - 1)) else (2 * fib(k - 1) + fib(k)) * fib(k) endif ; 
    return f[n+1] 
 );
  static   operation gcd( M : int, N : int) : int
  pre: true
  post: true
  activity: (     if (M = 0) then     return N else skip ; 
     return gcd(N mod M, M) );
  static   operation findGCDofFibMFibN( M : int, N : int) : int
  pre: true
  post: true
  activity: (     return fib(gcd(M, N)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : gcdOfFibonacci ; obj := gcdOfFibonacci.newgcdOfFibonacci() ;
     var M : int ; M := 3 ;
    var N : int ; N := 12 ;
     OclFile["System.out"].println(findGCDofFibMFibN(M, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static PrintWriter out=new PrintWriter(System.out);
  static Scanner in=new Scanner(System.in);
  static BufferedReader re=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter wr=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws IOException {
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int T=in.nextInt();
    while(T>0){
      int n=in.nextInt();
      long arr[]=new long[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=in.nextLong();
      }
      int t=0 ;
      int res=0 ;
      for(int i=n-2 ; i>=0 ; i--){
        while(arr[i]>=arr[i+1]){
          if(arr[i]==0)break ;
          arr[i]/=2 ;
          res++;
        }
        if(arr[i]==0 && i>0)t++;
      }
      int v=0 ;
      for(int i=0 ; i<n-1 ; i++){
        if(arr[i]>=arr[i+1])v++;
      }
      if(t>0 || v>0)out.println("-1");
      else out.println(res);
      T--;
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute re : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute wr : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
     while (T > 0) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var t : int ; t := 0 ;
    var res : int ; res := 0 ;
        var i : int ; i := n - 2 ; while i >= 0 do ( (     while (arr[i+1] >= arr[i + 1+1]) do (     if (arr[i+1] = 0) then     break else skip ; 
     arr[i+1] := arr[i+1]/(2) ; 
     res := res + 1 ) ; 
     if (arr[i+1] = 0 & i > 0) then     t := t + 1 ; else skip )  ;     i := i - 1 ) ; 
    var v : int ; v := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] >= arr[i + 1+1]) then     v := v + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (t > 0 or v > 0) then     skip else     skip ; ;  
    T := T - 1 ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class _1675B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
      int ans=0 ;
      boolean flag=true ;
      for(int i=n-2 ; i>=0 ; i--){
        while(arr[i]>=arr[i+1]){
          arr[i]/=2 ;
          if(arr[i]==0 && arr[i+1]==0){
            flag=false ;
            break ;
          }
          ans++;
        }
      }
      System.out.println(flag ? ans :-1);
    }
  }
  public static int gcd(int a,int b){
    return(a==0)? b : gcd(b % a,a);
  }
  static int power(int x,int y){
    int ans=1 ;
    while(y>0){
      if((y & 1)!=0)ans*=x ;
      y=y>>1 ;
      x*=x ;
    }
    return ans ;
  }
  public static List<Integer>sieve(int n){
    List<Integer>primes=new LinkedList<>();
    boolean[] composite=new boolean[n+1];
    for(int i=2 ; i*i<=n ; i++)for(int j=i*i ; j<=n && ! composite[i]; j+=i)composite[j]=true ;
    for(int j=2 ; j<composite.length ; j++)if(! composite[j])primes.add(j);
    return primes ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1675B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var flag : boolean ; flag := true ;
        var i : int ; i := n - 2 ; while i >= 0 do ( (     while (arr[i+1] >= arr[i + 1+1]) do (     arr[i+1] := arr[i+1]/(2) ; 
     if (arr[i+1] = 0 & arr[i + 1+1] = 0) then (     flag := false ; 
     break ) else skip ; 
     ans := ans + 1 ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(if flag then ans else -1 endif) ; 
 ) ;  ) );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if (a = 0) then b else gcd(b mod a, a) endif );
  static   operation power( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
     while (y > 0) do (     if ((y & 1) /= 0) then     ans := ans*(x) ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := x*(x) ) ; 
     return ans );
  static   operation sieve( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var primes : Sequence(int) ; primes := Sequence{} ;
     var composite : Sequence(boolean) ; composite := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 2 ; while i * i <= n do (         var j : int ; j := i * i ; while j <= n & not(composite[i+1]) do (     composite[j+1] := true ;  ;     j := j+(i) ) ;  ;     i := i + 1 ) ; 
        var j : int ; j := 2 ; while j < composite->size() do (     if (not(composite[j+1])) then     primes := primes->including(j) ; else skip ;  ;     j := j + 1 ) ; 
    return primes 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class ques {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int j=0 ; j<n ; j++){
        arr[j]=sc.nextInt();
      }
      int count=0 ;
      for(int j=n-1 ; j>=1 ; j--){
        while(arr[j]<=arr[j-1] && arr[j-1]>0){
          arr[j-1]=arr[j-1]/2 ;
          count++;
        }
      }
      for(int j=0 ; j<n-1 ; j++){
        if(arr[j]==arr[j+1]){
          count=-1 ;
          break ;
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ques {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     arr[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    var count : int ; count := 0 ;
        var j : int ; j := n - 1 ; while j >= 1 do ( (     while (arr[j+1] <= arr[j - 1+1] & arr[j - 1+1] > 0) do (     arr[j - 1+1] := arr[j - 1+1] / 2 ; 
     count := count + 1 ) )  ;     j := j - 1 ) ; 
        var j : int ; j := 0 ; while j < n - 1 do ( (     if (arr[j+1] = arr[j + 1+1]) then (     count := -1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      if(n<=1){
        System.out.println(0);
      }
      else {
        int cnt=0 ;
        boolean flag=false ;
        for(int i=n-2 ; i>=0 ; i--){
          int val=arr[i+1];
          if(val==0){
            flag=true ;
            break ;
          }
          else {
            while(arr[i]>=val){
              cnt++;
              arr[i]/=2 ;
            }
          }
        }
        if(! flag)System.out.println(cnt);
        else System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     if (n <= 1) then (     OclFile["System.out"].println(0) ) else (     var cnt : int ; cnt := 0 ;
     var flag : boolean ; flag := false ;
         var i : int ; i := n - 2 ; while i >= 0 do ( (     var val : int ; val := arr[i + 1+1] ;
     if (val = 0) then (     flag := true ; 
     break ) else (     while (arr[i+1] >= val) do (     cnt := cnt + 1 ; 
     arr[i+1] := arr[i+1]/(2) ) ) )  ;     i := i - 1 ) ; 
     if (not(flag)) then     OclFile["System.out"].println(cnt) ; else     OclFile["System.out"].println(-1) ; ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      int val=scan.nextInt();
      if(val==0){
        break ;
      }
      for(int i=0 ; i<9 ; i++){
        val-=scan.nextInt();
      }
      System.out.println(val);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var val : int ; val := scan.getCurrent()->toInteger() ;
     if (val = 0) then (     break ) else skip ; 
         var i : int ; i := 0 ; while i < 9 do ( (     val := val-(scan.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(val) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.lang.management.ManagementFactory ;
import java.lang.management.ThreadMXBean ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    ThreadMXBean threadMXBean=ManagementFactory.getThreadMXBean();
    long startCpuTime=threadMXBean.getCurrentThreadCpuTime(),stopCpuTime=0 ;
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      int t=scan.nextInt();
      if(t==0)break ;
      for(int f=0 ; f<9 ; f++){
        t-=scan.nextInt();
      }
      System.out.println(t);
    }
    scan.close();
    System.exit(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var threadMXBean : ThreadMXBean ; threadMXBean := ManagementFactory.getThreadMXBean() ;
     var startCpuTime : long ; startCpuTime := threadMXBean.getCurrentThreadCpuTime() ;
    var stopCpuTime : long ; stopCpuTime := 0 ;
    var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (scan.hasNext()) do (     var t : int ; t := scan.getCurrent()->toInteger() ;
     if (t = 0) then     break else skip ; 
         var f : int ; f := 0 ; while f < 9 do ( (     t := t-(scan.getCurrent()->toInteger()) )  ;     f := f + 1 ) ; 
     OclFile["System.out"].println(t) ) ; 
    skip ; 
OclProcess.exit(0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int res=sc.nextInt();
      if(res==0)break ;
      for(int i=0 ; i<9 ; i++){
        res-=sc.nextInt();
      }
      System.out.println(res);
    }
  }
  public static void main(String[] args){
    try {
      System.setIn(new FileInputStream("A.in"));
      System.setOut(new PrintStream(new FileOutputStream("A.out")));
    }
    catch(Exception e){
    }
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var res : int ; res := sc.getCurrent()->toInteger() ;
     if (res = 0) then     break else skip ; 
         var i : int ; i := 0 ; while i < 9 do ( (     res := res-(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(res) )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("A.in"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("A.out")))) )   catch (e : ProgramException) do skip
     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    StringBuilder sb=new StringBuilder();
    while(!(line=br.readLine()).equals("0")){
      int total=Integer.parseInt(line);
      for(int i=0 ; i<9 ; i++){
        total-=Integer.parseInt(br.readLine());
      }
      sb.append(total+"\n");
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
    var sb : String ; sb := StringLib.newString() ;
    while (not((line) = "0")) do (     var total : int ; total := (line)->toInteger() ;
         var i : int ; i := 0 ; while i < 9 do ( (     total := total-((br.readLine())->toInteger()) )  ;     i := i + 1 ) ; 
     sb := sb + StringLib.newString(total + "\n") ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.regex.Pattern ;
public class Main {
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int sum=sc.nextInt();
      if(sum==0)break ;
      int[] data=new int[9];
      data[0]=sc.nextInt();
      for(int i=1 ; i<9 ; i++){
        data[i]=data[i-1]+sc.nextInt();
      }
      System.out.println(sum-data[data.length-1]);
    }
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var sum : int ; sum := sc.getCurrent()->toInteger() ;
     if (sum = 0) then     break else skip ; 
    var data : Sequence(int) ; data := Integer.subrange(1,9)->collect(0) ;
    data[0+1] := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i < 9 do ( (     data[i+1] := data[i - 1+1] + sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum - data[data->size() - 1+1]) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
class GFG {
  public static int countIdenticalRows(int mat[][]){
    int count=0 ;
    for(int i=0 ; i<mat.length ; i++){
      HashSet<Integer>hs=new HashSet<>();
      for(int j=0 ; j<mat[i] .length ; j++){
        hs.add(mat[i][j]);
      }
      if(hs.size()==1)count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int mat[][]={
      {
        1,1,1 },{
          1,2,3 },{
            5,5,5 }
          };
          System.out.print(countIdenticalRows(mat));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countIdenticalRows( mat : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < mat->size() do ( (     var hs : Set(int) ; hs := Set{} ;
         var j : int ; j := 0 ; while j < mat[i+1]->size() do ( (     hs := hs->including(mat[i+1][j+1]) )  ;     j := j + 1 ) ; 
     if (hs->size() = 1) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,1,1},Sequence{1,2,3},Sequence{5,5,5}} ;
     OclFile["System.out"].print(countIdenticalRows(mat)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt(),k=scanner.nextInt();
      int[] p=new int[n];
      IntStream.range(0,n).forEach(i->p[i]=scanner.nextInt()-1);
      long[] c=new long[n],scores=new long[n+1];
      IntStream.range(0,n).forEach(i->c[i]=scanner.nextLong());
      long max=Long.MIN_VALUE ;
      for(int i=0 ; i<n ; i++){
        Set<Integer>set=new HashSet<>();
        Arrays.fill(scores,0L);
        long score=0L ;
        int count=0 ;
        int current=i ;
        while((! set.contains(current))&&(k>count)){
          set.add(current);
          score+=c[current];
          scores[++count]=score ;
          current=p[current];
        }
        if((score>0)&&(k>count)){
          max=Math.max(max,(k/count)*score+IntStream.rangeClosed(1,k % count).mapToLong(j->scores[j]).max().orElse(0L));
          max=Math.max(max,Math.max(0,(k/count)-1)*score+IntStream.rangeClosed(1,count).mapToLong(j->scores[j]).max().orElse(0L));
        }
        else {
          max=Math.max(max,IntStream.rangeClosed(1,count).mapToLong(j->scores[j]).max().getAsLong());
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
     var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    for i : Integer.subrange(0, n-1) do
    (    p[i+1] := scanner.getCurrent()->toInteger() - 1) ; 
    var c : Sequence(long) ; c := Integer.subrange(1,n)->collect(0) ;
    var scores : Sequence(long) ; scores := Integer.subrange(1,n + 1)->collect(0) ;
    for i : Integer.subrange(0, n-1) do
    (    c[i+1] := scanner.getCurrent()->toLong()) ; 
    var max : long ; max := "-9223372036854775808"->toLong() ;
        var i : int ; i := 0 ; while i < n do ( (     var set : Set(int) ; set := Set{} ;
     scores := scores->collect(0L) ; 
    var score : long ; score := 0L ;
    var count : int ; count := 0 ;
    var current : int ; current := i ;
    while ((not(set->includes(current))) & (k > count)) do (     set := set->including(current) ; 
     score := score+(c[current+1]) ; 
         count := count + 1 ;
 scores[count+1] := score  ; 
     current := p[current+1] ) ; 
    if ((score > 0) & (k > count)) then (     max := Set{max, (k / count) * score + Integer.subrange(1, k mod count)->collect( _x1 | (lambda j : OclAny in scores[j+1])->apply(_x1) ).max().orElse(0L)}->max() ; 
     max := Set{max, Set{0, (k / count) - 1}->max() * score + Integer.subrange(1, count)->collect( _x1 | (lambda j : OclAny in scores[j+1])->apply(_x1) ).max().orElse(0L)}->max() ) else (     max := Set{max, Integer.subrange(1, count)->collect( _x1 | (lambda j : OclAny in scores[j+1])->apply(_x1) ).max().getAsLong()}->max() ) ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void myCopy(char s1[],char s2[]){
    int i=0 ;
    for(i=0 ; i<s1.length ; i++)s2[i]=s1[i];
  }
  public static void main(String[] args){
    char s1[]="GEEKSFORGEEKS".toCharArray();
    char s2[]=new char[s1.length];
    myCopy(s1,s2);
    System.out.println(String.valueOf(s2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation myCopy( s1 : Sequence(String), s2 : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
         i := 0 ; while i < s1->size() do (     s2[i+1] := s1[i+1] ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : Sequence(String) ; s1 := "GEEKSFORGEEKS"->characters() ;
     var s2 : Sequence(String) ; s2 := Integer.subrange(1,s1->size())->collect(0) ;
     execute myCopy(s1, s2) ; 
     OclFile["System.out"].println(((s2) + "")) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test217 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      int a=in.nextInt();
      int b=in.nextInt();
      int c=in.nextInt();
      if(a==b){
        if(c % 2==0){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
      else if(a==c){
        if(b % 2==0){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
      else if(b==c){
        if(a % 2==0){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
      else {
        int sum=a+b+c ;
        int s=Math.max(a,Math.max(c,b));
        if(sum-s==s){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test217 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
     var c : int ; c := in.getCurrent()->toInteger() ;
     if (a = b) then (     if (c mod 2 = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else     if (a = c) then (     if (b mod 2 = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else     if (b = c) then (     if (a mod 2 = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else (     var sum : int ; sum := a + b + c ;
     var s : int ; s := Set{a, Set{c, b}->max()}->max() ;
     if (sum - s = s) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  ;  )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ConstructR {
  int number ;
  public ConstructR(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  public void input(int num1,int num2,int num3){
    if(num1+num2==num3 || num1+num3==num2 || num2+num3==num1){
      System.out.println("YES");
    }
    else if((num1==num2 && num3 % 2==0)||(num1==num3 && num2 % 2==0)||(num2==num3 && num1 % 2==0)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    ConstructR instance=new ConstructR(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      int n1=input.nextInt();
      int n2=input.nextInt();
      int n3=input.nextInt();
      instance.input(n1,n2,n3);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ConstructR {
   attribute number : int;
   static operation newConstructR( number : int) : ConstructR
  pre: true
  post: true
  activity:
  ( var self : ConstructR ;
    self := createConstructR();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
   operation input( num1 : int, num2 : int, num3 : int) : void
  pre: true
  post: true
  activity: (     if (num1 + num2 = num3 or num1 + num3 = num2 or num2 + num3 = num1) then (     OclFile["System.out"].println("YES") ) else     if ((num1 = num2 & num3 mod 2 = 0) or (num1 = num3 & num2 mod 2 = 0) or (num2 = num3 & num1 mod 2 = 0)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
     var instance : ConstructR ; instance := ConstructR.newConstructR(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var n1 : int ; n1 := input.getCurrent()->toInteger() ;
     var n2 : int ; n2 := input.getCurrent()->toInteger() ;
     var n3 : int ; n3 := input.getCurrent()->toInteger() ;
     instance.input(n1, n2, n3) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1622A_ConstructARectangle {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      List<Integer>list=new ArrayList<>();
      for(int i=0 ; i<3 ; i++){
        list.add(input.nextInt());
      }
      input.nextLine();
      Collections.sort(list);
      int first=list.get(0);
      int second=list.get(1);
      int third=list.get(2);
      if(first+second==third){
        System.out.println("YES");
      }
      else if(Collections.frequency(list,third)>=2 && first % 2==0){
        System.out.println("YES");
      }
      else if(Collections.frequency(list,first)>=2 && third % 2==0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1622A_ConstructARectangle {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var list : Sequence(int) ; list := Sequence{} ;
         var i : int ; i := 0 ; while i < 3 do ( (     list := list->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    skip ; 
    list := list->sort() ; 
    var first : int ; first := list->at(0+1) ;
    var second : int ; second := list->at(1+1) ;
    var third : int ; third := list->at(2+1) ;
    if (first + second = third) then (     OclFile["System.out"].println("YES") ) else     if (frequency(list, third) >= 2 & first mod 2 = 0) then (     OclFile["System.out"].println("YES") ) else     if (frequency(list, first) >= 2 & third mod 2 = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.cos ;
class GFG {
  static void cal_cos(float n){
    float accuracy=(float)0.0001,x1,denominator,cosx,cosval ;
    n=n*(float)(3.142/180.0);
    x1=1 ;
    cosx=x1 ;
    cosval=(float)cos(n);
    int i=1 ;
    do {
      denominator=2*i*(2*i-1);
      x1=-x1*n*n/denominator ;
      cosx=cosx+x1 ;
      i=i+1 ;
    }
    while(accuracy<=cosval-cosx);
    System.out.println(cosx);
  }
  public static void main(String[] args){
    float n=30 ;
    cal_cos(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation cal_cos( n : double) : void
  pre: true
  post: true
  activity: (     var accuracy : double ; accuracy := 0.0001->oclAsType(double) ;
    var x1 : double ;
    var denominator : double ;
    var cosx : double ;
    var cosval : double ;
     n := n * (3.142 / 180.0)->oclAsType(double) ; 
    x1 := 1 ; 
    cosx := x1 ; 
    cosval := cos(n)->oclAsType(double) ; 
    var i : int ; i := 1 ;
  while true do ((     denominator := 2 * i * (2 * i - 1) ; 
     x1 := -x1 * n * n / denominator ; 
     cosx := cosx + x1 ; 
     i := i + 1 ) ;
    if (accuracy <= cosval - cosx) then skip else break) ; 
    OclFile["System.out"].println(cosx) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 30 ;
     execute cal_cos(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class TheWayToHome {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    scan.nextLine();
    String S=scan.nextLine();
    int i=0 ;
    int res=0 ;
    while(i<n-1){
      int j=Math.min(i+k,n-1);
      while(j<=n-1 && j>i){
        if(j==i+1 && S.charAt(j)!='1'){
          System.out.println(-1);
          return ;
        }
        if(S.charAt(j)=='1'){
          i=j ;
          res++;
          break ;
        }
        j--;
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class TheWayToHome {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    skip ; 
    var S : String ; S := scan.nextLine() ;
    var i : int ; i := 0 ;
    var res : int ; res := 0 ;
    while (i < n - 1) do (     var j : int ; j := Set{i + k, n - 1}->min() ;
     while (j <= n - 1 & j > i) do (     if (j = i + 1 & S->at(j+1) /= '1') then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
     if (S->at(j+1) = '1') then (     i := j ; 
     res := res + 1 ; 
     break ) else skip ; 
     j := j - 1 ) ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class TheWayToHome {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    scan.nextLine();
    String S=scan.nextLine();
    int i=0 ;
    int res=0 ;
    while(i<n-1){
      for(int j=Math.min(i+k,n-1); j>i ; j--){
        if(j==i+1 && S.charAt(j)!='1'){
          System.out.println(-1);
          return ;
        }
        if(S.charAt(j)=='1'){
          i=j ;
          res++;
          break ;
        }
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class TheWayToHome {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    skip ; 
    var S : String ; S := scan.nextLine() ;
    var i : int ; i := 0 ;
    var res : int ; res := 0 ;
    while (i < n - 1) do (         var j : int ; j := Set{i + k, n - 1}->min() ; while j > i do ( (     if (j = i + 1 & S->at(j+1) /= '1') then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
     if (S->at(j+1) = '1') then (     i := j ; 
     res := res + 1 ; 
     break ) else skip )  ;     j := j - 1 ) ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long K=sc.nextLong();
    long max=Long.MIN_VALUE ;
    int A[]=new int[N];
    int C[]=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt()-1 ;
    }
    for(int i=0 ; i<N ; i++){
      C[i]=sc.nextInt();
    }
    for(int i=0 ; i<N ; i++){
      int count=0 ;
      long cost=0 ;
      int now=A[i];
      Set<Integer>set=new HashSet<Integer>();
      for(; count<N && count<K ; count++){
        if(set.contains(now)){
          break ;
        }
        set.add(now);
        cost+=C[now];
        now=A[now];
        if(cost>max){
          max=cost ;
        }
      }
      if(count<K){
        int roop=count ;
        if(cost>0){
          if(K % roop!=0){
            cost=cost*(K/roop);
            if(cost>max){
              max=cost ;
            }
            for(int j=0 ; j<K % roop ; j++){
              cost+=C[now];
              now=A[now];
              if(cost>max){
                max=cost ;
              }
            }
          }
          else {
            cost=cost*(K/roop-1);
            if(cost>max){
              max=cost ;
            }
            for(int j=0 ; j<roop ; j++){
              cost+=C[now];
              now=A[now];
              if(cost>max){
                max=cost ;
              }
            }
          }
        }
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : long ; K := sc.getCurrent()->toLong() ;
    var max : long ; max := "-9223372036854775808"->toLong() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var C : Sequence(int) ; C := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() - 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     C[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var count : int ; count := 0 ;
     var cost : long ; cost := 0 ;
    var now : int ; now := A[i+1] ;
    var set : Set(int) ; set := Set{} ;
      while count < N & count < K do ( (     if (set->includes(now)) then (     break ) else skip ; 
     set := set->including(now) ; 
    cost := cost+(C[now+1]) ; 
    now := A[now+1] ; 
    if (cost > max) then (     max := cost ) else skip ; 
 )  ;     count := count + 1 ) ; 
    if (count < K) then (     var roop : int ; roop := count ;
     if (cost > 0) then (     if (K mod roop /= 0) then (     cost := cost * (K / roop) ; 
     if (cost > max) then (     max := cost ) else skip ; 
         var j : int ; j := 0 ; while j < K mod roop do ( (     cost := cost+(C[now+1]) ; 
     now := A[now+1] ; 
     if (cost > max) then (     max := cost ) else skip )  ;     j := j + 1 ) ) else (     cost := cost * (K / roop - 1) ; 
     if (cost > max) then (     max := cost ) else skip ; 
         var j : int ; j := 0 ; while j < roop do ( (     cost := cost+(C[now+1]) ; 
     now := A[now+1] ; 
     if (cost > max) then (     max := cost ) else skip )  ;     j := j + 1 ) ) ) else skip ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem_910A {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int dest=s.nextInt();
    int jump=s.nextInt();
    String pads=s.next();
    boolean[] goodIdx=new boolean[dest];
    for(int i=0 ; i<dest ; i++){
      goodIdx[i]=pads.charAt(i)=='1' ;
    }
    int start=0 ;
    int count=0 ;
    while(start<dest-1){
      int maxAhead=start+jump ;
      while(maxAhead<dest && goodIdx[maxAhead]==false)maxAhead--;
      if(start==maxAhead){
        System.out.println("-1");
        return ;
      }
      start=maxAhead ;
      count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem_910A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dest : int ; dest := s.getCurrent()->toInteger() ;
    var jump : int ; jump := s.getCurrent()->toInteger() ;
    var pads : String ; pads := s.getCurrent() ;
    var goodIdx : Sequence(boolean) ; goodIdx := Integer.subrange(1,dest)->collect(false) ;
        var i : int ; i := 0 ; while i < dest do ( (     goodIdx[i+1] := pads->at(i+1) = '1' )  ;     i := i + 1 ) ; 
    var start : int ; start := 0 ;
    var count : int ; count := 0 ;
    while (start < dest - 1) do (     var maxAhead : int ; maxAhead := start + jump ;
     while (maxAhead < dest & goodIdx[maxAhead+1] = false) do     maxAhead := maxAhead - 1 ; ; 
    if (start = maxAhead) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
    start := maxAhead ; 
    count := count + 1 ; 
 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    int[] data=new int[101];
    data[1]=1 ;
    for(int i=2 ; i<=100 ; i++){
      data[i]=data[i-1]+4*(i-1);
    }
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int size=in.nextInt();
      int d=in.nextInt();
      String str=in.next();
      int jump=0 ;
      int curr=0 ;
      boolean printed=false ;
      while(curr<size){
        int next=curr+d ;
        if(next>=size-1){
          jump++;
          break ;
        }
        while(str.charAt(next)=='0')next--;
        if(next==curr){
          out.println(-1);
          printed=true ;
          break ;
        }
        curr=next ;
        jump++;
      }
      if(! printed){
        out.println(jump);
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var data : Sequence(int) ; data := Integer.subrange(1,101)->collect(0) ;
     data[1+1] := 1 ; 
        var i : int ; i := 2 ; while i <= 100 do ( (     data[i+1] := data[i - 1+1] + 4 * (i - 1) )  ;     i := i + 1 ) ; 
    var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
    var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var size : int ; size := in.nextInt() ;
     var d : int ; d := in.nextInt() ;
    var str : String ; str := in.next() ;
    var jump : int ; jump := 0 ;
    var curr : int ; curr := 0 ;
    var printed : boolean ; printed := false ;
    while (curr < size) do (     var next : int ; next := curr + d ;
     if (next >= size - 1) then (     jump := jump + 1 ; 
     break ) else skip ; 
    while (str->at(next+1) = '0') do     next := next - 1 ; ; 
    if (next = curr) then (     skip ; 
     printed := true ; 
     break ) else skip ; 
    curr := next ; 
    jump := jump + 1 ; 
 ) ; 
    if (not(printed)) then (     skip ) else skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean checkPandigital(int b,String n){
    if(n.length()<b)return false ;
    boolean hash[]=new boolean[b];
    Arrays.fill(hash,false);
    for(int i=0 ; i<n.length(); i++){
      if(n.charAt(i)>='0' && n.charAt(i)<='9')hash[n.charAt(i)-'0']=true ;
      else if(n.charAt(i)-'A'<=b-11)hash[n.charAt(i)-'A'+10]=true ;
    }
    for(int i=0 ; i<b ; i++)if(hash[i]==false)return false ;
    return true ;
  }
  public static void main(String[] args){
    int b=13 ;
    String n="1298450376ABC" ;
    if(checkPandigital(b,n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkPandigital( b : int, n : String) : boolean
  pre: true
  post: true
  activity: (     if (n->size() < b) then     return false else skip ; 
     var hash : Sequence(boolean) ; hash := Integer.subrange(1,b)->collect(false) ;
    hash := hash->collect(false) ; 
        var i : int ; i := 0 ; while i < n->size() do ( (     if (n->at(i+1) >= '0' & n->at(i+1) <= '9') then     hash[n->at(i+1) - ('0')->char2byte()+1] := true ; else     if (n->at(i+1) - ('A')->char2byte() <= b - 11) then     hash[n->at(i+1) - ('A')->char2byte() + 10+1] := true ; else skip ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < b do (     if (hash[i+1] = false) then     return false else skip ;  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var b : int ; b := 13 ;
     var n : String ; n := "1298450376ABC" ;
     if (checkPandigital(b, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean IsPossible(String s){
    int n=s.length();
    HashSet<Character>count=new HashSet<>();
    HashMap<Character,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      count.add(s.charAt(i));
      map.put(s.charAt(i),map.get(s.charAt(i))==null ? 1 : map.get(s.charAt(i))+1);
    }
    if(count.size()==1)return true ;
    if(count.size()>2)return false ;
    String newString=count.toArray().toString();
    int j=0 ;
    char it=newString.charAt(j);
    int x=0,y=0 ;
    x=map.get(it)==null ? 0 : map.get(it);
    j++;
    it=newString.charAt(j);
    y=map.get(it)==null ? 0 : map.get(it);
    if(Math.abs(x-y)<=1)return true ;
    return false ;
  }
  public static void main(String[] args){
    String s="aaaddad" ;
    if(IsPossible(s))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation IsPossible( s : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var count : Set(String) ; count := Set{} ;
    var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     count := count->including(s->at(i+1)) ; 
     map := map->union(Map{s->at(i+1) |-> if map->at(s->at(i+1)) = null then 1 else map->at(s->at(i+1)) + 1 endif}) )  ;     i := i + 1 ) ; 
    if (count->size() = 1) then     return true else skip ; 
    if (count->size() > 2) then     return false else skip ; 
    var newString : String ; newString := count->asSequence()+"" ;
    var j : int ; j := 0 ;
    var it : String ; it := newString->at(j+1) ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    x := if map->at(it) = null then 0 else map->at(it) endif ; 
    j := j + 1 ; 
    it := newString->at(j+1) ; 
    y := if map->at(it) = null then 0 else map->at(it) endif ; 
    if (if (x)->char2byte() - (y)->char2byte() < 0 then -((x)->char2byte() - (y)->char2byte()) else (x)->char2byte() - (y)->char2byte() endif <= 1) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "aaaddad" ;
     if (IsPossible(s)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int arraySum(int arr[],int n){
    int x=(n+1)/2 ;
    return(arr[0]-1)*n+x*x ;
  }
  public static void main(String[] args){
    int arr[]={
      10,11,12,13,12,11,10 };
      int n=arr.length ;
      System.out.print(arraySum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation arraySum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := (n + 1) / 2 ;
     return (arr[0+1] - 1) * n + x * x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,11,12,13,12,11,10} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(arraySum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class P632A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int p=scan.nextInt();
    scan.nextLine();
    long applesTimes2=1 ;
    boolean[] arr=new boolean[n];
    for(int i=0 ; i<n ; i++){
      if(scan.nextLine().equals("half"))arr[n-i-1]=false ;
      else arr[n-i-1]=true ;
    }
    applesTimes2=arr[0] ? 2 : 1 ;
    for(int i=1 ; i<n ; i++){
      if(arr[i]){
        applesTimes2+=1 ;
        applesTimes2*=2 ;
      }
      else applesTimes2*=2 ;
    }
    long received=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(! arr[i]){
        received+=applesTimes2/2*p ;
        applesTimes2/=2 ;
      }
      else {
        received+=applesTimes2/2*p ;
        applesTimes2-=2 ;
        applesTimes2/=2 ;
      }
    }
    System.out.println(received/2);
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class P632A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var p : int ; p := scan.getCurrent()->toInteger() ;
    skip ; 
    var applesTimes2 : long ; applesTimes2 := 1 ;
    var arr : Sequence(boolean) ; arr := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     if (scan.nextLine() = "half") then     arr[n - i - 1+1] := false ; else     arr[n - i - 1+1] := true ; )  ;     i := i + 1 ) ; 
    applesTimes2 := if arr[0+1] then 2 else 1 endif ; 
        var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1]) then (     applesTimes2 := applesTimes2+(1) ; 
     applesTimes2 := applesTimes2*(2) ) else     applesTimes2 := applesTimes2*(2) ; )  ;     i := i + 1 ) ; 
    var received : long ; received := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (not(arr[i+1])) then (     received := received+(applesTimes2 / 2 * p) ; 
     applesTimes2 := applesTimes2/(2) ) else (     received := received+(applesTimes2 / 2 * p) ; 
     applesTimes2 := applesTimes2-(2) ; 
     applesTimes2 := applesTimes2/(2) ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(received / 2) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ProblemA {
  enum AppleType {
    half,halfplus }
    public static void main(String[] args){
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int p=sc.nextInt();
      AppleType[] s=new AppleType[n];
      for(int i=0 ; i<n ; i++){
        if(sc.next().equals("half")){
          s[i]=AppleType.half ;
        }
        else {
          s[i]=AppleType.halfplus ;
        }
      }
      sc.close();
      long apples=0 ;
      long giftapples=0 ;
      for(int i=n-1 ; i>=0 ; i--){
        switch(s[i]){
          case half : apples*=2 ;
          break ;
          case halfplus : apples*=2 ;
          apples+=1 ;
          giftapples+=1 ;
          break ;
          default : break ;
        }
      }
      System.out.println(apples*p-giftapples*p/2);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class ProblemA {
   enumeration AppleType {  literal half;  literal halfplus }
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
    var s : Sequence(AppleType) ; s := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     if (sc.getCurrent() = "half") then (     s[i+1] := AppleType.half ) else (     s[i+1] := AppleType.halfplus ) )  ;     i := i + 1 ) ; 
    skip ; 
    var apples : long ; apples := 0 ;
    var giftapples : long ; giftapples := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (s[i+1]) ; 
       if _switchval = half then
     apples := apples*(2) ; 
    break 
   else skip ;
       if _switchval = halfplus then
     apples := apples*(2) ; 
    apples := apples+(1) ; 
    giftapples := giftapples+(1) ; 
    break 
   else skip ;
       if true then
     break 
   else skip ;
 )
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(apples * p - giftapples * p / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class GrandmaLaura {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int numPeople=scan.nextInt();
    int price=scan.nextInt();
    scan.nextLine();
    boolean[] halfPlus=new boolean[numPeople];
    for(int i=0 ; i<numPeople ; i++){
      if(scan.nextLine().equals("half")){
        halfPlus[i]=false ;
      }
      else halfPlus[i]=true ;
    }
    long currentApples=1 ;
    long total=price/2 ;
    for(int i=numPeople-2 ; i>=0 ; i--){
      if(! halfPlus[i]){
        total+=currentApples*price ;
        currentApples*=2 ;
      }
      else {
        total+=(currentApples*price)+(price/2);
        currentApples*=2 ;
        currentApples++;
      }
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GrandmaLaura {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numPeople : int ; numPeople := scan.getCurrent()->toInteger() ;
    var price : int ; price := scan.getCurrent()->toInteger() ;
    skip ; 
    var halfPlus : Sequence(boolean) ; halfPlus := Integer.subrange(1,numPeople)->collect(false) ;
        var i : int ; i := 0 ; while i < numPeople do ( (     if (scan.nextLine() = "half") then (     halfPlus[i+1] := false ) else     halfPlus[i+1] := true ; )  ;     i := i + 1 ) ; 
    var currentApples : long ; currentApples := 1 ;
    var total : long ; total := price / 2 ;
        var i : int ; i := numPeople - 2 ; while i >= 0 do ( (     if (not(halfPlus[i+1])) then (     total := total+(currentApples * price) ; 
     currentApples := currentApples*(2) ) else (     total := total+((currentApples * price) + (price / 2)) ; 
     currentApples := currentApples*(2) ; 
     currentApples := currentApples + 1 ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
class geeks {
  public static int countTotalDistinct(String str){
    int cnt=0 ;
    HashSet<String>items=new HashSet<>();
    for(int i=0 ; i<str.length(); ++i){
      String temp="" ;
      HashSet<Character>ans=new HashSet<>();
      for(int j=i ; j<str.length(); ++j){
        temp=temp+str.charAt(j);
        ans.add(str.charAt(j));
        if(! items.contains(temp)){
          items.add(temp);
          cnt+=ans.size();
        }
      }
    }
    return cnt ;
  }
  public static void main(String[] args){
    String str="ABCA" ;
    System.out.println(countTotalDistinct(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class geeks {
  static   operation countTotalDistinct( str : String) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var items : Set(String) ; items := Set{} ;
         var i : int ; i := 0 ; while i < str->size() do ( (     var temp : String ; temp := "" ;
     var ans : Set(String) ; ans := Set{} ;
         var j : int ; j := i ; while j < str->size() do ( (     temp := temp + str->at(j+1) ; 
     ans := ans->including(str->at(j+1)) ; 
     if (not(items->includes(temp))) then (     items := items->including(temp) ; 
     cnt := cnt+(ans->size()) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "ABCA" ;
     OclFile["System.out"].println(countTotalDistinct(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class halfplus {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int p=scan.nextInt();
    scan.nextLine();
    String[] s=new String[n];
    for(int i=0 ; i<n ; i++){
      s[i]=scan.nextLine();
    }
    long sum=0 ;
    long apples=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(s[i] .equals("half")){
        apples*=2 ;
      }
      else {
        apples*=2 ;
        apples++;
      }
      sum+=(p*(apples/2.0));
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class halfplus {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var p : int ; p := scan.getCurrent()->toInteger() ;
    skip ; 
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := scan.nextLine() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    var apples : long ; apples := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (s[i+1] = "half") then (     apples := apples*(2) ) else (     apples := apples*(2) ; 
     apples := apples + 1 ) ;  
     sum := sum+((p * (apples / 2.0))) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GrandMaLauraAndApples {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int people=sc.nextInt();
    int price=sc.nextInt();
    Stack<String>st=new Stack<String>();
    for(int i=0 ; i<people ; i++){
      st.push(sc.next());
    }
    double apple=0 ;
    double profit=0 ;
    while(! st.isEmpty()){
      String temp=st.pop();
      if(temp.equals("halfplus")){
        apple=(apple+.5)*2 ;
        profit+=(apple/2)*price ;
      }
      if(temp.equals("half")){
        apple*=2 ;
        profit+=(apple/2)*price ;
      }
    }
    System.out.printf("%.0f",(profit));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GrandMaLauraAndApples {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var people : int ; people := sc.getCurrent()->toInteger() ;
    var price : int ; price := sc.getCurrent()->toInteger() ;
    var st : Sequence(String) ; st := Sequence{} ;
        var i : int ; i := 0 ; while i < people do ( (     st := st->append(sc.getCurrent()) )  ;     i := i + 1 ) ; 
    var apple : double ; apple := 0 ;
    var profit : double ; profit := 0 ;
    while (not(st->isEmpty())) do (     var temp : String ; temp := st->last() ;
     if (temp = "halfplus") then (     apple := (apple + .5) * 2 ; 
     profit := profit+((apple / 2) * price) ) else skip ; 
     if (temp = "half") then (     apple := apple*(2) ; 
     profit := profit+((apple / 2) * price) ) else skip ) ; 
    OclFile["System.out"].printf("%.0f", (profit)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner input=new Scanner(System.in);
    int n,k ;
    n=input.nextInt();
    k=input.nextInt();
    if(k==1){
      for(int i=1 ; i<n ; i++)System.out.print(0);
      System.out.println(1);
    }
    else {
      int m=(n-k)/2 ;
      for(int i=0 ; i<n ; i++){
        if(i %(m+1)==0)System.out.print(1);
        else System.out.print(0);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var k : int ;
    n := input.getCurrent()->toInteger() ; 
    k := input.getCurrent()->toInteger() ; 
    if (k = 1) then (         var i : int ; i := 1 ; while i < n do (     OclFile["System.out"].print(0) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(1) ) else (     var m : int ; m := (n - k) / 2 ;
         var i : int ; i := 0 ; while i < n do ( (     if (i mod (m + 1) = 0) then     OclFile["System.out"].print(1) ; else     OclFile["System.out"].print(0) ; )  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  static int N=4 ;
  static void shiftMatrixByK(int[][] mat,int k){
    if(k>N){
      System.out.print("Shifting is"+" not possible");
      return ;
    }
    int j=0 ;
    while(j<N){
      for(int i=k ; i<N ; i++)System.out.print(mat[j][i]+" ");
      for(int i=0 ; i<k ; i++)System.out.print(mat[j][i]+" ");
      System.out.println();
      j++;
    }
  }
  public static void main(String args[]){
    int[][] mat=new int[][] {
      {
        1,2,3,4 },{
          5,6,7,8 },{
            9,10,11,12 },{
              13,14,15,16 }
            };
            int k=2 ;
            shiftMatrixByK(mat,k);
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 4;
  static   operation shiftMatrixByK( mat : Sequence(Sequence(int)), k : int) : void
  pre: true
  post: true
  activity: (     if (k > N) then (     OclFile["System.out"].print("Shifting is" + " not possible") ; 
     return ) else skip ; 
     var j : int ; j := 0 ;
     while (j < N) do (         var i : int ; i := k ; while i < N do (     OclFile["System.out"].print(mat[j+1][i+1] + " ") ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < k do (     OclFile["System.out"].print(mat[j+1][i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ; 
     j := j + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,2,3,4},Sequence{5,6,7,8},Sequence{9,10,11,12},Sequence{13,14,15,16}} ;
     var k : int ; k := 2 ;
     execute shiftMatrixByK(mat, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import java.util.*;
import java.io.*;
public class x1603B {
  public static void main(String omkar[])throws Exception {
    BufferedReader infile=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(infile.readLine());
    int T=Integer.parseInt(st.nextToken());
    StringBuilder sb=new StringBuilder();
    while(T-->0){
      st=new StringTokenizer(infile.readLine());
      long X=Integer.parseInt(st.nextToken());
      long Y=Integer.parseInt(st.nextToken());
      if(X>Y){
        long res=X+Y ;
        sb.append(res);
      }
      else if(X<Y){
        long res=(Y % X)/2 ;
        res=Y-res ;
        sb.append(res);
      }
      else sb.append(Y);
      sb.append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class x1603B {
  static   operation main( omkar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var infile : OclFile ; infile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(infile.readLine()) ;
    var T : int ; T := (st.next())->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     st := OclIterator.newOclIterator_String(infile.readLine()) ; 
     var X : long ; X := (st.next())->toInteger() ;
    var Y : long ; Y := (st.next())->toInteger() ;
    if (X > Y) then (     var res : long ; res := X + Y ;
     sb := sb + StringLib.newString(res) ) else     if (X < Y) then (     var res : long ; res := (Y mod X) / 2 ;
     res := Y - res ; 
     sb := sb + StringLib.newString(res) ) else     sb := sb + StringLib.newString(Y) ; ;  ;  
    sb := sb + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static final MyWriter writer=new MyWriter();
  private static final MyReader scan=new MyReader();
  public static void main(String[] args)throws Exception {
    Main main=new Main();
    int q=scan.nextInt();
    while(q-->0)main.solve();
    writer.close();
  }
  void solve()throws Exception {
    int x=scan.nextInt();
    int y=scan.nextInt();
    if(x<y){
      writer.println(y-(y % x/2));
    }
    else if(x>y){
      writer.println(x+y);
    }
    else {
      writer.println(x);
    }
  }
}
class MyWriter implements Closeable {
  private BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
  public void print(Object object)throws IOException {
    writer.write(object.toString());
  }
  public void println(Object object)throws IOException {
    writer.write(object.toString());
    writer.write(System.lineSeparator());
  }
  public void close()throws IOException {
    writer.close();
  }
}
class MyReader {
  private BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
  private StringTokenizer tokenizer=new StringTokenizer("");
  private String innerNextLine(){
    try {
      return reader.readLine();
    }
    catch(IOException ex){
      return null ;
    }
  }
  public boolean hasNext(){
    while(! tokenizer.hasMoreTokens()){
      String nextLine=innerNextLine();
      if(nextLine==null)return false ;
      tokenizer=new StringTokenizer(nextLine);
    }
    return true ;
  }
  public String nextLine(){
    tokenizer=new StringTokenizer("");
    return innerNextLine();
  }
  public String next(){
    hasNext();
    return tokenizer.nextToken();
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
  public double nextDouble(){
    return Double.parseDouble(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute writer : MyWriter := MyWriter.newMyWriter();
  static    attribute scan : MyReader := MyReader.newMyReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     var q : int ; q := scan.nextInt() ;
         while (q > 0) do (        q := q - 1 ;     skip ;     main.solve() ; ;  ) ;  
     writer.close() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var x : int ; x := scan.nextInt() ;
     var y : int ; y := scan.nextInt() ;
     if (x < y) then (     writer.println(y - (y mod x / 2)) ) else     if (x > y) then (     writer.println(x + y) ) else (     writer.println(x) ) ;  );
}
class MyWriter implements Closeable {
   attribute writer : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
   operation print( object : OclAny) : void
  pre: true
  post: true
  activity: (     skip );
   operation println( object : OclAny) : void
  pre: true
  post: true
  activity: (     skip ; 
     skip );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
class MyReader {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute tokenizer : OclIterator := OclIterator.newOclIterator_String("");
   operation innerNextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (ex : IOException) do (     return null )
 );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     var nextLine : String ; nextLine := innerNextLine() ;
     if (nextLine = null) then     return false else skip ; 
     tokenizer := OclIterator.newOclIterator_String(nextLine) ) ; 
     return true );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     tokenizer := OclIterator.newOclIterator_String("") ; 
     return innerNextLine() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute hasNext() ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int __gcd(int a,int b){
    if(a==0 || b==0)return 0 ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static int minValidNumber(int p,int q){
    if(q % p==0)return __gcd(p,q);
    else return-1 ;
  }
  public static void main(String[] args){
    int p=2,q=6 ;
    System.out.print(minValidNumber(p,q));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0 or b = 0) then     return 0 else skip ; 
     if (a = b) then     return a else skip ; 
     if (a > b) then     return __gcd(a - b, b) else skip ; 
     return __gcd(a, b - a) );
  static   operation minValidNumber( p : int, q : int) : int
  pre: true
  post: true
  activity: (     if (q mod p = 0) then     return __gcd(p, q) else     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : int ; p := 2 ;
    var q : int ; q := 6 ;
     OclFile["System.out"].print(minValidNumber(p, q)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String permutation(int arr[],int N){
    int[] hash=new int[N+1];
    for(int i=0 ; i<N ; i++){
      hash[arr[i] ]++;
    }
    for(int i=1 ; i<=N ; i++){
      if(hash[i]!=1)return "No" ;
    }
    return "Yes" ;
  }
  public static void main(String[] args){
    int arr[]={
      1,1,5,5,3 };
      int n=arr.length ;
      System.out.print(permutation(arr,n)+"\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation permutation( arr : Sequence(int), N : int) : String
  pre: true
  post: true
  activity: (     var hash : Sequence(int) ; hash := Integer.subrange(1,N + 1)->collect(0) ;
         var i : int ; i := 0 ; while i < N do ( (     hash[arr[i+1]+1] := hash[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i <= N do ( (     if (hash[i+1] /= 1) then     return "No" else skip )  ;     i := i + 1 ) ; 
     return "Yes" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,5,5,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(permutation(arr, n) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long ans=0 ;
    List<Long>l2=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      long d=sc.nextLong();
      l2.add(d);
    }
    Collections.sort(l2,Collections.reverseOrder());
    Long[] dp=new Long[N];
    for(int i=0 ; i<N ; i++){
      dp[i]=(long)0 ;
    }
    for(int i=0 ; i<l2.size(); i++){
      if(i==0)continue ;
      dp[i]=dp[i-1]+l2.get(i/2);
    }
    System.out.println(dp[N-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var ans : long ; ans := 0 ;
    var l2 : Sequence(long) ; l2 := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var d : long ; d := sc.getCurrent()->toLong() ;
     l2 := l2->including(d) )  ;     i := i + 1 ) ; 
    l2, reverseOrder() := l2, reverseOrder()->sort() ; 
    var dp : Sequence(long) ; dp := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     dp[i+1] := 0->oclAsType(long) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < l2->size() do ( (     if (i = 0) then     continue else skip ; 
     dp[i+1] := dp[i - 1+1] + l2->at(i / 2+1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[N - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long N=Long.parseLong(sc.next());
    List<Long>list=new ArrayList();
    long total=0L ;
    for(long i=1 ; i<=N ; i++){
      list.add(Long.parseLong(sc.next()));
    }
    Collections.sort(list);
    Collections.reverse(list);
    long aa=N/2 ;
    long aaa=N % 2 ;
    total=list.get(0);
    for(int i=1 ; i<=aa-1 ; i++){
      total+=list.get(i)*2 ;
    }
    if(aaa==1){
      total+=list.get((int)((N/2)));
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := (sc.getCurrent())->toLong() ;
    var list : Sequence(long) ; list := Sequence{} ;
    var total : long ; total := 0L ;
        var i : long ; i := 1 ; while i <= N do ( (     list := list->including((sc.getCurrent())->toLong()) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    list := list->reverse() ; 
    var aa : long ; aa := N / 2 ;
    var aaa : long ; aaa := N mod 2 ;
    total := list->at(0+1) ; 
        var i : int ; i := 1 ; while i <= aa - 1 do ( (     total := total+(list->at(i+1) * 2) )  ;     i := i + 1 ) ; 
    if (aaa = 1) then (     total := total+(list->at(((N / 2))->oclAsType(int)+1)) ) else skip ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
class GFG {
  static int firstDigit(int n){
    int digits=(int)(Math.log10(n));
    n=(int)(n/(int)(Math.pow(10,digits)));
    return n ;
  }
  static int lastDigit(int n){
    return(n % 10);
  }
  public static void main(String args[]){
    int n=98562 ;
    System.out.println(firstDigit(n)+" "+lastDigit(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation firstDigit( n : int) : int
  pre: true
  post: true
  activity: (     var digits : int ; digits := ((n)->log10())->oclAsType(int) ;
     n := (n / (10->pow(digits))->oclAsType(int))->oclAsType(int) ; 
     return n );
  static   operation lastDigit( n : int) : int
  pre: true
  post: true
  activity: (     return (n mod 10) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 98562 ;
     OclFile["System.out"].println(firstDigit(n) + " " + lastDigit(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    MyScanner in=new MyScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    D solver=new D();
    solver.solve(1,in,out);
    out.close();
  }
  static class D {
    public void solve(int testNumber,MyScanner in,PrintWriter out){
      int N=in.Int();
      int[] A=in.Int(N);
      Arrays.sort(A);
      long ans=A[N-1];
      for(int i=1 ; i<N/2 ; i++){
        ans+=A[N-1-i]*2 ;
      }
      if(N % 2==1)ans+=A[(N/2)];
      out.println(ans);
    }
  }
  static class MyScanner {
    private BufferedReader in ;
    private StringTokenizer st ;
    public MyScanner(InputStream stream){
      in=new BufferedReader(new InputStreamReader(stream));
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          String rl=in.readLine();
          if(rl==null){
            return null ;
          }
          st=new StringTokenizer(rl);
        }
        catch(IOException e){
          return null ;
        }
      }
      return st.nextToken();
    }
    public int Int(){
      return Integer.parseInt(next());
    }
    public int[] Int(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=Int();
      }
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : MyScanner ; in := MyScanner.newMyScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : D ; solver := D.newD() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class D {
   operation solve( testNumber : int, in : MyScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.Int() ;
     var A : Sequence(int) ; A := in.Int(N) ;
    A := A->sort() ; 
    var ans : long ; ans := A[N - 1+1] ;
        var i : int ; i := 1 ; while i < N / 2 do ( (     ans := ans+(A[N - 1 - i+1] * 2) )  ;     i := i + 1 ) ; 
    if (N mod 2 = 1) then     ans := ans+(A[(N / 2)+1]) ; else skip ; 
    skip ; 
 );
}
  static class MyScanner {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner( stream : OclFile) : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     var rl : String ; rl := in.readLine() ;
     if (rl = null) then (     return null ) else skip ; 
     st := OclIterator.newOclIterator_String(rl) )   catch (e : IOException) do (     return null )
 ) ; 
     return st.next() );
   operation Int() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation Int( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := Int() )  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.*;
public class Main {
  static int n ;
  static int k ;
  static int[] arr ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.valueOf(br.readLine());
    long[] arr=new long[n];
    String[] cmd=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      arr[i]=Long.valueOf(cmd[i]);
    }
    Arrays.sort(arr);
    long ans=arr[n-1];
    int k=n-2 ;
    for(int i=n-2 ; i>=0 ; i--){
      if(k==0)break ;
      if(k>=2){
        k=k-2 ;
        ans=ans+2*arr[i];
      }
      else {
        k--;
        ans=ans+arr[i];
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute k : int;
  static   attribute arr : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
    var cmd : Sequence(String) ; cmd := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (cmd[i+1])->toLong() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var ans : long ; ans := arr[n - 1+1] ;
    var k : int ; k := n - 2 ;
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (k = 0) then     break else skip ; 
     if (k >= 2) then (     k := k - 2 ; 
     ans := ans + 2 * arr[i+1] ) else (     k := k - 1 ; 
     ans := ans + arr[i+1] ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Main instance=new Main();
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    long[] S=new long[N];
    for(int i=0 ; i<N ; i++){
      S[i]=scan.nextLong();
    }
    sort(S,0,S.length-1);
    long[] newS=new long[N];
    for(int i=0 ; i<N ; i++){
      newS[i]=S[N-i-1];
    }
    long result=newS[0];
    if(N % 2==0){
      for(int i=1 ; i<=N/2-1 ; i++){
        result+=2L*newS[i];
      }
    }
    else {
      for(int i=1 ; i<(N-1)/2 ; i++){
        result+=2L*newS[i];
      }
      result+=newS[(N-1)/2];
    }
    System.out.println(result);
  }
  public static void sort(long[] array,int left,int right){
    if(left<=right){
      long p=array[(left+right)>>>1];
      int l=left ;
      int r=right ;
      while(l<=r){
        while(array[l]<p){
          l++;
        }
        while(array[r]>p){
          r--;
        }
        if(l<=r){
          long tmp=array[l];
          array[l]=array[r];
          array[r]=tmp ;
          l++;
          r--;
        }
      }
      sort(array,left,r);
      sort(array,l,right);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute instance : Main := Main.newMain();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var S : Sequence(long) ; S := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     S[i+1] := scan.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    execute sort(S, 0, S->size() - 1) ; 
    var newS : Sequence(long) ; newS := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     newS[i+1] := S[N - i - 1+1] )  ;     i := i + 1 ) ; 
    var result : long ; result := newS[0+1] ;
    if (N mod 2 = 0) then (         var i : int ; i := 1 ; while i <= N / 2 - 1 do ( (     result := result+(2L * newS[i+1]) )  ;     i := i + 1 ) ) else (         var i : int ; i := 1 ; while i < (N - 1) / 2 do ( (     result := result+(2L * newS[i+1]) )  ;     i := i + 1 ) ; 
     result := result+(newS[(N - 1) / 2+1]) ) ;  
    OclFile["System.out"].println(result) ; 
 );
  static   operation sort( array : Sequence(long), left : int, right : int) : void
  pre: true
  post: true
  activity: (     if (left <= right) then (     var p : long ; p := array[((left + right)/(2->pow(1)))->oclAsType(long)+1] ;
     var l : int ; l := left ;
    var r : int ; r := right ;
    while (l <= r) do (     while (array[l+1] < p) do (     l := l + 1 ) ; 
     while (array[r+1] > p) do (     r := r - 1 ) ; 
     if (l <= r) then (     var tmp : long ; tmp := array[l+1] ;
     array[l+1] := array[r+1] ; 
    array[r+1] := tmp ; 
    l := l + 1 ; 
    r := r - 1 ; 
 ) else skip ) ; 
    execute sort(array, left, r) ; 
    execute sort(array, l, right) ; 
 ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Arrays ;
public class Main {
  static int inf=1000000000 ;
  static int MOD=1000000007 ;
  public static void main(String ards[]){
    Scanner cin=new Scanner(System.in);
    int n=cin.nextInt();
    int k=cin.nextInt();
    int x=(n-k)/2 ;
    for(int i=1 ; i<=n ; i++){
      if(i %(x+1)==0)System.out.print(1);
      else System.out.print(0);
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute inf : int := 1000000000;
  static   attribute MOD : int := 1000000007;
  static   operation main( ards : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := cin.getCurrent()->toInteger() ;
    var k : int ; k := cin.getCurrent()->toInteger() ;
    var x : int ; x := (n - k) / 2 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (i mod (x + 1) = 0) then     OclFile["System.out"].print(1) ; else     OclFile["System.out"].print(0) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class B735 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int length=scanner.nextInt();
    int city1=scanner.nextInt();
    int city2=scanner.nextInt();
    int[] people=new int[length];
    for(int i=0 ; i<length ; i++)people[i]=scanner.nextInt();
    Arrays.sort(people);
    long sum1=0 ;
    long sum2=0 ;
    for(int i=length-1 ; i>=length-Math.min(city1,city2); i--)sum1+=people[i];
    for(int i=length-Math.min(city1,city2)-1 ; i>=length-city1-city2 ; i--)sum2+=people[i];
    double answer=1d*sum2/Math.max(city1,city2)+1d*sum1/Math.min(city1,city2);
    System.out.print(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B735 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var length : int ; length := scanner.getCurrent()->toInteger() ;
    var city1 : int ; city1 := scanner.getCurrent()->toInteger() ;
    var city2 : int ; city2 := scanner.getCurrent()->toInteger() ;
    var people : Sequence(int) ; people := Integer.subrange(1,length)->collect(0) ;
        var i : int ; i := 0 ; while i < length do (     people[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    people := people->sort() ; 
    var sum1 : long ; sum1 := 0 ;
    var sum2 : long ; sum2 := 0 ;
        var i : int ; i := length - 1 ; while i >= length - Set{city1, city2}->min() do (     sum1 := sum1+(people[i+1]) ;  ;     i := i - 1 ) ; 
        var i : int ; i := length - Set{city1, city2}->min() - 1 ; while i >= length - city1 - city2 do (     sum2 := sum2+(people[i+1]) ;  ;     i := i - 1 ) ; 
    var answer : double ; answer := 1d * sum2 / Set{city1, city2}->max() + 1d * sum1 / Set{city1, city2}->min() ;
    OclFile["System.out"].print(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Test {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int n1=sc.nextInt();
    int n2=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    sc.close();
    Arrays.sort(arr);
    double sum1=0,sum2=0 ;
    int j=n1>n2 ? n1 : n2 ;
    if(n1>=n2){
      for(int i=n-(n1+n2); i<n ; i++){
        if(j-->0){
          sum1+=arr[i];
        }
        else {
          sum2+=arr[i];
        }
      }
    }
    else {
      for(int i=n-(n1+n2); i<n ; i++){
        if(j-->0){
          sum2+=arr[i];
        }
        else {
          sum1+=arr[i];
        }
      }
    }
    double ans=sum1/n1+sum2/n2 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var n1 : int ; n1 := sc.getCurrent()->toInteger() ;
    var n2 : int ; n2 := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    arr := arr->sort() ; 
    var sum1 : double ; sum1 := 0 ;
    var sum2 : double ; sum2 := 0 ;
    var j : int ; j := if n1 > n2 then n1 else n2 endif ;
    if (n1 >= n2) then (         var i : int ; i := n - (n1 + n2) ; while i < n do ( (     if (j > 0) then (     sum1 := sum1+(arr[i+1]) ) else (     sum2 := sum2+(arr[i+1]) ) )  ;     i := i + 1 ) ) else (         var i : int ; i := n - (n1 + n2) ; while i < n do ( (     if (j > 0) then (     sum2 := sum2+(arr[i+1]) ) else (     sum1 := sum1+(arr[i+1]) ) )  ;     i := i + 1 ) ) ;  
    var ans : double ; ans := sum1 / n1 + sum2 / n2 ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  static int lcm(int x,int y){
    int temp=(x*y)/__gcd(x,y);
    return temp ;
  }
  static void findNumbers(int a[],int n,int b[],int m){
    int lcmA=1,gcdB=0 ;
    for(int i=0 ; i<n ; i++)lcmA=lcm(lcmA,a[i]);
    for(int i=0 ; i<m ; i++)gcdB=__gcd(gcdB,b[i]);
    if(gcdB % lcmA!=0){
      System.out.print("-1");
      return ;
    }
    int num=lcmA ;
    while(num<=gcdB){
      if(gcdB % num==0)System.out.print(num+" ");
      num+=lcmA ;
    }
  }
  public static void main(String[] args){
    int a[]={
      1,2,2,4 };
      int b[]={
        16,32,64 };
        int n=a.length ;
        int m=b.length ;
        findNumbers(a,n,b,m);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation lcm( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var temp : int ; temp := (x * y) / __gcd(x, y) ;
     return temp );
  static   operation findNumbers( a : Sequence(int), n : int, b : Sequence(int), m : int) : void
  pre: true
  post: true
  activity: (     var lcmA : int ; lcmA := 1 ;
    var gcdB : int ; gcdB := 0 ;
         var i : int ; i := 0 ; while i < n do (     lcmA := lcm(lcmA, a[i+1]) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     gcdB := __gcd(gcdB, b[i+1]) ;  ;     i := i + 1 ) ; 
    if (gcdB mod lcmA /= 0) then (     OclFile["System.out"].print("-1") ; 
     return ) else skip ; 
    var num : int ; num := lcmA ;
    while (num <= gcdB) do (     if (gcdB mod num = 0) then     OclFile["System.out"].print(num + " ") ; else skip ; 
     num := num+(lcmA) ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,2,4} ;
     var b : Sequence(int) ; b := Sequence{16,32,64} ;
    var n : int ; n := a->size() ;
    var m : int ; m := b->size() ;
    execute findNumbers(a, n, b, m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void print_result(int a[],int n,int k,int m){
    Vector<Vector<Integer>>v=new Vector<Vector<Integer>>(m);
    for(int i=0 ; i<m ; i++)v.add(new Vector<Integer>());
    for(int i=0 ; i<n ; i++){
      int rem=a[i] % m ;
      v.get(rem).add(a[i]);
      if(v.get(rem).size()==k){
        for(int j=0 ; j<k ; j++)System.out.print(v.get(rem).get(j)+" ");
        return ;
      }
    }
    System.out.print("-1");
  }
  public static void main(String[] args){
    int a[]={
      1,8,4 };
      int n=a.length ;
      print_result(a,n,2,3);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation print_result( a : Sequence(int), n : int, k : int, m : int) : void
  pre: true
  post: true
  activity: (     var v : Sequence(Sequence(int)) ; v := Sequence{}->union(m) ;
         var i : int ; i := 0 ; while i < m do (     v := v->including(Sequence{}) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     var rem : int ; rem := a[i+1] mod m ;
     v->at(rem+1)->excludes(a[i+1]) ; 
     if (v->at(rem+1)->size() = k) then (         var j : int ; j := 0 ; while j < k do (     OclFile["System.out"].print(v->at(rem+1)->at(j+1) + " ") ;  ;     j := j + 1 ) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("-1") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,8,4} ;
     var n : int ; n := a->size() ;
     execute print_result(a, n, 2, 3) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    if(a>=b){
      a=b ;
    }
    if(c>=d){
      c=d ;
    }
    System.out.println(a+c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    if (a >= b) then (     a := b ) else skip ; 
    if (c >= d) then (     c := d ) else skip ; 
    OclFile["System.out"].println(a + c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    int minT=0,minB=0 ;
    if(a>b){
      minT=b ;
    }
    else {
      minT=a ;
    }
    if(c>d){
      minB=d ;
    }
    else {
      minB=c ;
    }
    System.out.println((minT+minB));
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var minT : int ; minT := 0 ;
    var minB : int ; minB := 0 ;
    if (a > b) then (     minT := b ) else (     minT := a ) ;  
    if (c > d) then (     minB := d ) else (     minB := c ) ;  
    OclFile["System.out"].println((minT + minB)) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.List ;
import java.util.SortedMap ;
import java.util.StringTokenizer ;
import java.util.TreeMap ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args)throws Throwable {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    int I=Integer.parseInt(st.nextToken());
    st=new StringTokenizer(br.readLine());
    int[] a=new int[n];
    for(int i=0 ; i<a.length ; i++){
      a[i]=Integer.parseInt(st.nextToken());
    }
    System.out.println(solve(a,I));
  }
  static int solve(int[] a,int I){
    SortedMap<Integer,Integer>valueToCount=new TreeMap<>();
    for(int value : a){
      valueToCount.put(value,valueToCount.getOrDefault(value,0)+1);
    }
    List<Integer>counts=valueToCount.values().stream().collect(Collectors.toList());
    int bitNum=I*8/a.length ;
    int windowSize=1 ;
    for(int i=0 ; i<bitNum ; i++){
      windowSize*=2 ;
      if(windowSize>counts.size()){
        return 0 ;
      }
    }
    int sum=IntStream.range(0,windowSize).map(counts :: get).sum();
    int maxSum=sum ;
    for(int i=windowSize ; i<counts.size(); i++){
      sum+=counts.get(i)-counts.get(i-windowSize);
      maxSum=Math.max(maxSum,sum);
    }
    return a.length-maxSum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var I : int ; I := (st.next())->toInteger() ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(a, I)) ; 
 );
  static   operation solve( a : Sequence(int), I : int) : int
  pre: true
  post: true
  activity: (     var valueToCount : Map(int,int) ; valueToCount := Map{} ;
     for (value : a) do ( (     valueToCount := valueToCount->union(Map{value |-> (if valueToCount->keys()->contains(value) then valueToCount->at(value) else 0 endif) + 1}) )  ) ; 
    var counts : Sequence(int) ; counts := valueToCount->values().collect(Collectors.toList()) ;
    var bitNum : int ; bitNum := I * 8 / a->size() ;
    var windowSize : int ; windowSize := 1 ;
        var i : int ; i := 0 ; while i < bitNum do ( (     windowSize := windowSize*(2) ; 
     if (windowSize > counts->size()) then (     return 0 ) else skip )  ;     i := i + 1 ) ; 
    var sum : int ; sum := Integer.subrange(0, windowSize-1)->collect( _x1 | (lambda _pars : OclAny in counts.newcounts().get(_pars))->apply(_x1) )->sum() ;
    var maxSum : int ; maxSum := sum ;
        var i : int ; i := windowSize ; while i < counts->size() do ( (     sum := sum+(counts->at(i+1) - counts->at(i - windowSize+1)) ; 
     maxSum := Set{maxSum, sum}->max() )  ;     i := i + 1 ) ; 
    return a->size() - maxSum 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    System.out.println(Math.min(Integer.parseInt(sc.next()),Integer.parseInt(sc.next()))+Math.min(Integer.parseInt(sc.next()),Integer.parseInt(sc.next())));
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println(Set{(sc.getCurrent())->toInteger(), (sc.getCurrent())->toInteger()}->min() + Set{(sc.getCurrent())->toInteger(), (sc.getCurrent())->toInteger()}->min()) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    int D=sc.nextInt();
    int ans=Math.min(A,B)+Math.min(C,D);
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var D : int ; D := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := Set{A, B}->min() + Set{C, D}->min() ;
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] yen=new int[4];
    for(int i=0 ; i<4 ; i++){
      yen[i]=sc.nextInt();
    }
    sc.close();
    System.out.println(Math.min(yen[0],yen[1])+Math.min(yen[2],yen[3]));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var yen : Sequence(int) ; yen := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     yen[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(Set{yen[0+1], yen[1+1]}->min() + Set{yen[2+1], yen[3+1]}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static void findPair(int[] arr,int n){
    boolean found=false ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        for(int k=0 ; k<n ; k++){
          if(arr[i]+arr[j]==arr[k]){
            System.out.println(arr[i]+" "+arr[j]);
            found=true ;
          }
        }
      }
    }
    if(found==false)System.out.println("Not exist");
  }
  static public void main(String[] args){
    int[] arr={
      10,4,8,13,5 };
      int n=arr.length ;
      findPair(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findPair( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var found : boolean ; found := false ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (         var k : int ; k := 0 ; while k < n do ( (     if (arr[i+1] + arr[j+1] = arr[k+1]) then (     OclFile["System.out"].println(arr[i+1] + " " + arr[j+1]) ; 
     found := true ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (found = false) then     OclFile["System.out"].println("Not exist") ; else skip );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,4,8,13,5} ;
     var n : int ; n := arr->size() ;
     execute findPair(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=1000005 ;
  static boolean prime[]=new boolean[MAX];
  static void SieveOfEratosthenes(boolean[] prime){
    prime[1]=false ;
    prime[0]=false ;
    for(int p=2 ; p*p<MAX ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<MAX ; i+=p)prime[i]=false ;
      }
    }
  }
  static void prime_xor(int arr[],int n,int k){
    for(int i=0 ; i<MAX ; i++)prime[i]=true ;
    SieveOfEratosthenes(prime);
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(prime[arr[i] ]){
        if((i+1)% k==0){
          ans ^=arr[i];
        }
      }
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    int arr[]={
      2,3,5,7,11,8 };
      int n=arr.length ;
      int K=2 ;
      prime_xor(arr,n,K);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 1000005;
  static   attribute prime : boolean := Integer.subrange(1,MAX)->collect(false);
  static   operation SieveOfEratosthenes( prime : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (     prime[1+1] := false ; 
     prime[0+1] := false ; 
         var p : int ; p := 2 ; while p * p < MAX do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i < MAX do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation prime_xor( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < MAX do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
     execute SieveOfEratosthenes(prime) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (prime[arr[i+1]+1]) then (     if ((i + 1) mod k = 0) then (     ans := MathLib.bitwiseXor(ans,arr[i+1]) ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,5,7,11,8} ;
     var n : int ; n := arr->size() ;
     var K : int ; K := 2 ;
     execute prime_xor(arr, n, K) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class minFlips {
  static int findFlips(String str,int n){
    char last=' ' ;
    int res=0 ;
    for(int i=0 ; i<n ; i++){
      if(last!=str.charAt(i))res++;
      last=str.charAt(i);
    }
    return res/2 ;
  }
  public static void main(String[] args){
    String str="00011110001110" ;
    int n=str.length();
    System.out.println(findFlips(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class minFlips {
  static   operation findFlips( str : String, n : int) : int
  pre: true
  post: true
  activity: (     var last : String ; last := ' ' ;
     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (last /= str->at(i+1)) then     res := res + 1 ; else skip ; 
     last := str->at(i+1) )  ;     i := i + 1 ) ; 
     return res / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "00011110001110" ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].println(findFlips(str, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static final long mod=1000000007 ;
  static long dp[][]=new long[100010][2];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    dp[0][0]=1 ;
    for(int i=1 ; i<=n ; ++i){
      dp[i][0]+=dp[i-1][0]+dp[i-1][1];
      dp[i][0] %=mod ;
      dp[i][1]+=dp[i-1][0]+dp[i-1][1];
      dp[i][1] %=mod ;
      if(i-m>=0){
        dp[i][1]=(dp[i][1]-dp[i-m][0]+mod)% mod ;
      }
    }
    System.out.println((pow2(n)-(dp[n][0]+dp[n][1])+mod*mod)% mod);
  }
  static long pow2(int k){
    long v=1L ;
    for(int i=0 ; i<k ; i++){
      v*=2L ;
      v %=mod ;
    }
    return v ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute mod : long := 1000000007;
  static   attribute dp : long := Integer.subrange(1,100010)->collect(Integer.subrange(1,2)->collect(0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do ( (     dp[i+1][0+1] := dp[i+1][0+1]+(dp[i - 1+1][0+1] + dp[i - 1+1][1+1]) ; 
     dp[i+1][0+1] := dp[i+1][0+1] mod mod ; 
    dp[i+1][1+1] := dp[i+1][1+1]+(dp[i - 1+1][0+1] + dp[i - 1+1][1+1]) ; 
    dp[i+1][1+1] := dp[i+1][1+1] mod mod ; 
    if (i - m >= 0) then (     dp[i+1][1+1] := (dp[i+1][1+1] - dp[i - m+1][0+1] + mod) mod mod ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((pow2(n) - (dp[n+1][0+1] + dp[n+1][1+1]) + mod * mod) mod mod) ; 
 );
  static   operation pow2( k : int) : long
  pre: true
  post: true
  activity: (     var v : long ; v := 1L ;
         var i : int ; i := 0 ; while i < k do ( (     v := v*(2L) ; 
     v := v mod mod )  ;     i := i + 1 ) ; 
     return v );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findStartIndexOfArray(int arr[],int low,int high){
    if(low>high){
      return-1 ;
    }
    if(low==high){
      return low ;
    }
    int mid=low+(high-low)/2 ;
    if(arr[mid]>arr[mid+1]){
      return mid+1 ;
    }
    if(arr[mid-1]>arr[mid]){
      return mid ;
    }
    if(arr[low]>arr[mid]){
      return findStartIndexOfArray(arr,low,mid-1);
    }
    else {
      return findStartIndexOfArray(arr,mid+1,high);
    }
  }
  static void restoreSortedArray(int arr[],int n){
    if(arr[0]<arr[n-1]){
      return ;
    }
    int start=findStartIndexOfArray(arr,0,n-1);
    Arrays.sort(arr,0,start);
    Arrays.sort(arr,start,n);
    Arrays.sort(arr);
  }
  static void printArray(int arr[],int size){
    for(int i=0 ; i<size ; i++){
      System.out.print(arr[i]+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5 };
      int n=arr.length ;
      restoreSortedArray(arr,n);
      printArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findStartIndexOfArray( arr : Sequence(int), low : int, high : int) : int
  pre: true
  post: true
  activity: (     if (low > high) then (     return -1 ) else skip ; 
     if (low = high) then (     return low ) else skip ; 
    var mid : int ; mid := low + (high - low) / 2 ;
    if (arr[mid+1] > arr[mid + 1+1]) then (     return mid + 1 ) else skip ; 
    if (arr[mid - 1+1] > arr[mid+1]) then (     return mid ) else skip ; 
    if (arr[low+1] > arr[mid+1]) then (     return findStartIndexOfArray(arr, low, mid - 1) ) else (     return findStartIndexOfArray(arr, mid + 1, high) ) ;  
 );
  static   operation restoreSortedArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     if (arr[0+1] < arr[n - 1+1]) then (     return ) else skip ; 
     var start : int ; start := findStartIndexOfArray(arr, 0, n - 1) ;
    arr := arr.subrange(1,0)^(arr.subrange(0+1,start)->sort())^arr.subrange(start+1,arr.size) ; 
    arr := arr.subrange(1,start)^(arr.subrange(start+1,n)->sort())^arr.subrange(n+1,arr.size) ; 
    arr := arr->sort() ; 
 );
  static   operation printArray( arr : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < size do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var n : int ; n := arr->size() ;
     execute restoreSortedArray(arr, n) ; 
     execute printArray(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void candies(int n,int k){
    int count=0 ;
    int ind=1 ;
    int[] arr=new int[k];
    for(int i=0 ; i<k ; i++)arr[i]=0 ;
    int low=0,high=n ;
    while(low<=high){
      int mid=(low+high)>>1 ;
      int sum=(mid*(mid+1))>>1 ;
      if(sum<=n){
        count=mid/k ;
        low=mid+1 ;
      }
      else {
        high=mid-1 ;
      }
    }
    int last=(count*k);
    n-=(last*(last+1))/2 ;
    int j=0 ;
    int term=(count*k)+1 ;
    while(n>0){
      if(term<=n){
        arr[j++]=term ;
        n-=term ;
        term++;
      }
      else {
        arr[j]+=n ;
        n=0 ;
      }
    }
    for(int i=0 ; i<k ; i++)arr[i]+=(count*(i+1))+(k*(count*(count-1))/2);
    for(int i=0 ; i<k ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String[] args){
    int n=7,k=4 ;
    candies(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation candies( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var ind : int ; ind := 1 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do (     arr[i+1] := 0 ;  ;     i := i + 1 ) ; 
    var low : int ; low := 0 ;
    var high : int ; high := n ;
    while (low <= high) do (     var mid : int ; mid := ((low + high)/(2->pow(1)))->oclAsType(long) ;
     var sum : int ; sum := ((mid * (mid + 1))/(2->pow(1)))->oclAsType(long) ;
     if (sum <= n) then (     count := mid / k ; 
     low := mid + 1 ) else (     high := mid - 1 ) ) ; 
    var last : int ; last := (count * k) ;
    n := n-((last * (last + 1)) / 2) ; 
    var j : int ; j := 0 ;
    var term : int ; term := (count * k) + 1 ;
    while (n > 0) do (     if (term <= n) then (      arr[j+1] := term  ; j := j + 1 ; 
     n := n-(term) ; 
     term := term + 1 ) else (     arr[j+1] := arr[j+1]+(n) ; 
     n := 0 ) ) ; 
        var i : int ; i := 0 ; while i < k do (     arr[i+1] := arr[i+1]+((count * (i + 1)) + (k * (count * (count - 1)) / 2)) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
    var k : int ; k := 4 ;
     execute candies(n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Rewards {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    byte a1=s.nextByte();
    byte a2=s.nextByte();
    byte a3=s.nextByte();
    byte b1=s.nextByte();
    byte b2=s.nextByte();
    byte b3=s.nextByte();
    byte n=s.nextByte();
    short a=(short)(a1+a2+a3);
    short b=(short)(b1+b2+b3);
    int m=0 ;
    m+=Math.ceil(1.0*a/5);
    m+=Math.ceil(1.0*b/10);
    if(m<=n)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Rewards {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a1 : int ; a1 := s.nextByte() ;
    var a2 : int ; a2 := s.nextByte() ;
    var a3 : int ; a3 := s.nextByte() ;
    var b1 : int ; b1 := s.nextByte() ;
    var b2 : int ; b2 := s.nextByte() ;
    var b3 : int ; b3 := s.nextByte() ;
    var n : int ; n := s.nextByte() ;
    var a : int ; a := ((a1 + a2 + a3) mod 32768) ;
    var b : int ; b := ((b1 + b2 + b3) mod 32768) ;
    var m : int ; m := 0 ;
    m := m+((1.0 * a / 5)->ceil()) ; 
    m := m+((1.0 * b / 10)->ceil()) ; 
    if (m <= n) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static void removeZeros(int[] a,int n){
    int ind=-1 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]!=0){
        ind=i ;
        break ;
      }
    }
    if(ind==-1){
      System.out.print("Array has leading zeros only");
      return ;
    }
    int[] b=new int[n-ind];
    for(int i=0 ; i<n-ind ; i++)b[i]=a[ind+i];
    for(int i=0 ; i<n-ind ; i++)System.out.print(b[i]+" ");
  }
  public static void main(String args[]){
    int[] a={
      0,0,0,1,2,0,3 };
      int n=a.length ;
      removeZeros(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation removeZeros( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var ind : int ; ind := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] /= 0) then (     ind := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (ind = -1) then (     OclFile["System.out"].print("Array has leading zeros only") ; 
     return ) else skip ; 
    var b : Sequence(int) ; b := Integer.subrange(1,n - ind)->collect(0) ;
        var i : int ; i := 0 ; while i < n - ind do (     b[i+1] := a[ind + i+1] ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - ind do (     OclFile["System.out"].print(b[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{0,0,0,1,2,0,3} ;
     var n : int ; n := a->size() ;
     execute removeZeros(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Acmp {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a1=in.nextInt();
    int a2=in.nextInt();
    int a3=in.nextInt();
    int b1=in.nextInt();
    int b2=in.nextInt();
    int b3=in.nextInt();
    int n=in.nextInt();
    int res1=a1+a2+a3 ;
    int res2=b1+b2+b3 ;
    int count1=0 ;
    int count2=0 ;
    if(res1 % 5!=0 && res1/5>0)count1=res1/5+1 ;
    else if(res1 % 5==0 && res1/5>=0)count1=res1/5 ;
    else if(res1/5==0)count1=1 ;
    if(res2 % 10!=0 && res2/10>0)count2=res2/10+1 ;
    else if(res2 % 10==0 && res2/10>=0)count2=res2/10 ;
    else if(res2/10==0)count2=1 ;
    if(count1+count2<=n)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Acmp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a1 : int ; a1 := in.getCurrent()->toInteger() ;
    var a2 : int ; a2 := in.getCurrent()->toInteger() ;
    var a3 : int ; a3 := in.getCurrent()->toInteger() ;
    var b1 : int ; b1 := in.getCurrent()->toInteger() ;
    var b2 : int ; b2 := in.getCurrent()->toInteger() ;
    var b3 : int ; b3 := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var res1 : int ; res1 := a1 + a2 + a3 ;
    var res2 : int ; res2 := b1 + b2 + b3 ;
    var count1 : int ; count1 := 0 ;
    var count2 : int ; count2 := 0 ;
    if (res1 mod 5 /= 0 & res1 / 5 > 0) then     count1 := res1 / 5 + 1 else     if (res1 mod 5 = 0 & res1 / 5 >= 0) then     count1 := res1 / 5 else     if (res1 / 5 = 0) then     count1 := 1 ; else skip ; ;  ;  
    if (res2 mod 10 /= 0 & res2 / 10 > 0) then     count2 := res2 / 10 + 1 else     if (res2 mod 10 = 0 & res2 / 10 >= 0) then     count2 := res2 / 10 else     if (res2 / 10 = 0) then     count2 := 1 ; else skip ; ;  ;  
    if (count1 + count2 <= n) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static float y(float x){
    float num=1 ;
    float denom=(float)1.0+x*x ;
    return num/denom ;
  }
  static float WeedleRule(float a,float b){
    float h=(b-a)/6 ;
    float sum=0 ;
    sum=sum+(((3*h)/10)*(y(a)+y(a+2*h)+5*y(a+h)+6*y(a+3*h)+y(a+4*h)+5*y(a+5*h)+y(a+6*h)));
    return sum ;
  }
  public static void main(String args[]){
    float a=0,b=6 ;
    float num=WeedleRule(a,b);
    System.out.format("f(x)="+"%.6f",num);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation y( x : double) : double
  pre: true
  post: true
  activity: (     var num : double ; num := 1 ;
     var denom : double ; denom := 1.0->oclAsType(double) + x * x ;
     return num / denom );
  static   operation WeedleRule( a : double, b : double) : double
  pre: true
  post: true
  activity: (     var h : double ; h := (b - a) / 6 ;
     var sum : double ; sum := 0 ;
     sum := sum + (((3 * h) / 10) * (y(a) + y(a + 2 * h) + 5 * y(a + h) + 6 * y(a + 3 * h) + y(a + 4 * h) + 5 * y(a + 5 * h) + y(a + 6 * h))) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 0 ;
    var b : double ; b := 6 ;
     var num : double ; num := WeedleRule(a, b) ;
     OclFile["System.out"].format("f(x)=" + "%.6f", num) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] agrs){
    Scanner in=new Scanner(System.in);
    long n=in.nextLong();
    long m=in.nextLong();
    long k=in.nextLong();
    long x=1,y=1 ;
    if(k<=n-1){
      System.out.println(x+k+" "+y);
    }
    else {
      k-=n-1 ;
      if(((k/(m-1))& 1)==1){
        if(k %(m-1)==0){
          x=n+1-(k/(m-1));
          y=m ;
        }
        else {
          x=n-(k/(m-1));
          y=m+1-(k %(m-1));
        }
      }
      else {
        if(k %(m-1)==0){
          x=n+1-(k/(m-1));
          y=2 ;
        }
        else {
          x=n-(k/(m-1));
          y=1+(k %(m-1));
        }
      }
      System.out.println(x+" "+y);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toLong() ;
    var m : long ; m := in.getCurrent()->toLong() ;
    var k : long ; k := in.getCurrent()->toLong() ;
    var x : long ; x := 1 ;
    var y : long ; y := 1 ;
    if (k <= n - 1) then (     OclFile["System.out"].println(x + k + " " + y) ) else (     k := k-(n - 1) ; 
     if (((k / (m - 1)) & 1) = 1) then (     if (k mod (m - 1) = 0) then (     x := n + 1 - (k / (m - 1)) ; 
     y := m ) else (     x := n - (k / (m - 1)) ; 
     y := m + 1 - (k mod (m - 1)) ) ) else (     if (k mod (m - 1) = 0) then (     x := n + 1 - (k / (m - 1)) ; 
     y := 2 ) else (     x := n - (k / (m - 1)) ; 
     y := 1 + (k mod (m - 1)) ) ) ;  
     OclFile["System.out"].println(x + " " + y) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] agrs){
    Scanner in=new Scanner(System.in);
    long n=in.nextLong();
    long m=in.nextLong();
    long k=in.nextLong();
    long x=1,y=1 ;
    if(k<=n-1){
      System.out.println(x+k+" "+y);
    }
    else {
      k-=n-1 ;
      if(((k/(m-1))& 1)==1){
        if(k %(m-1)==0){
          x=n+1-(k/(m-1));
          y=m ;
        }
        else {
          x=n-(k/(m-1));
          y=m+1-(k %(m-1));
        }
      }
      else {
        if(k %(m-1)==0){
          x=n+1-(k/(m-1));
          y=2 ;
        }
        else {
          x=n-(k/(m-1));
          y=1+(k %(m-1));
        }
      }
      System.out.println(x+" "+y);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toLong() ;
    var m : long ; m := in.getCurrent()->toLong() ;
    var k : long ; k := in.getCurrent()->toLong() ;
    var x : long ; x := 1 ;
    var y : long ; y := 1 ;
    if (k <= n - 1) then (     OclFile["System.out"].println(x + k + " " + y) ) else (     k := k-(n - 1) ; 
     if (((k / (m - 1)) & 1) = 1) then (     if (k mod (m - 1) = 0) then (     x := n + 1 - (k / (m - 1)) ; 
     y := m ) else (     x := n - (k / (m - 1)) ; 
     y := m + 1 - (k mod (m - 1)) ) ) else (     if (k mod (m - 1) = 0) then (     x := n + 1 - (k / (m - 1)) ; 
     y := 2 ) else (     x := n - (k / (m - 1)) ; 
     y := 1 + (k mod (m - 1)) ) ) ;  
     OclFile["System.out"].println(x + " " + y) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1559 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      in.nextInt();
      char[] S=in.next().toCharArray();
      int idx=0 ;
      while(idx<S.length && S[idx]=='?'){
        idx++;
      }
      if(idx==S.length){
        for(int i=0 ; i<S.length ; i++){
          S[i]=(i % 2==0)? 'R' : 'B' ;
        }
      }
      else {
        char last=S[idx];
        for(int i=idx-1 ; i>=0 ; i--){
          last=(last=='R')? 'B' : 'R' ;
          S[i]=last ;
        }
        last=S[idx];
        for(int i=idx+1 ; i<S.length ; i++){
          if(S[i]=='?'){
            S[i]=(last=='R')? 'B' : 'R' ;
          }
          last=S[i];
        }
      }
      System.out.println(new String(S));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1559 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     skip ; 
     var S : Sequence(String) ; S := in.getCurrent()->characters() ;
    var idx : int ; idx := 0 ;
    while (idx < S->size() & S[idx+1] = '?') do (     idx := idx + 1 ) ; 
    if (idx = S->size()) then (         var i : int ; i := 0 ; while i < S->size() do ( (     S[i+1] := if (i mod 2 = 0) then 'R' else 'B' endif )  ;     i := i + 1 ) ) else (     var last : String ; last := S[idx+1] ;
         var i : int ; i := idx - 1 ; while i >= 0 do ( (     last := if (last = 'R') then 'B' else 'R' endif ; 
     S[i+1] := last )  ;     i := i - 1 ) ; 
     last := S[idx+1] ; 
         var i : int ; i := idx + 1 ; while i < S->size() do ( (     if (S[i+1] = '?') then (     S[i+1] := if (last = 'R') then 'B' else 'R' endif ) else skip ; 
     last := S[i+1] )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(StringLib.newString(S)) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long dig(long a){
    long count=0 ;
    while(a>0){
      a/=10 ;
      count++;
    }
    return count ;
  }
  static void required_number(long num,long n,long d){
    long i,j,power=1,a,flag=0 ;
    for(i=num ; i>=1 ; i--){
      power=(long)Math.pow(10,i);
      a=n % power ;
      if(d>a){
        flag=1 ;
        break ;
      }
    }
    if(flag>0){
      long t=0 ;
      for(j=0 ; j<i ; j++){
        t+=9*Math.pow(10,j);
      }
      if(n % power==t)System.out.print(n);
      else {
        System.out.print(n-(n % power)-1);
      }
    }
    else System.out.print(n);
  }
  public static void main(String[] args){
    long n=1029,d=102 ;
    long num=dig(n);
    required_number(num,n,d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation dig( a : long) : long
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
     while (a > 0) do (     a := a/(10) ; 
     count := count + 1 ) ; 
     return count );
  static   operation required_number( num : long, n : long, d : long) : void
  pre: true
  post: true
  activity: (     var i : long ;
    var j : long ;
    var power : long ; power := 1 ;
    var a : long ;
    var flag : long ; flag := 0 ;
         i := num ; while i >= 1 do ( (     power := 10->pow(i)->oclAsType(long) ; 
     a := n mod power ; 
     if (d > a) then (     flag := 1 ; 
     break ) else skip )  ;     i := i - 1 ) ; 
     if (flag > 0) then (     var t : long ; t := 0 ;
         j := 0 ; while j < i do ( (     t := t+(9 * 10->pow(j)) )  ;     j := j + 1 ) ; 
     if (n mod power = t) then     OclFile["System.out"].print(n) ; else (     OclFile["System.out"].print(n - (n mod power) - 1) ) ) else     OclFile["System.out"].print(n) ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 1029 ;
    var d : long ; d := 102 ;
     var num : long ; num := dig(n) ;
     execute required_number(num, n, d) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  class N {
    long d ;
    long r ;
    N(long d,long r){
      this.d=d ;
      this.r=r ;
    }
    @ Override public boolean equals(Object o){
      return((N)o).r==r ;
    }
  }
  void run(){
    sc=new Scanner(System.in);
    for(; sc.hasNext(); ){
      long p=sc.nextLong();
      long q=sc.nextLong();
      LinkedList<N>list=new LinkedList<N>();
      N n0=null ;
      for(int i=0 ; ; i++){
        long r=p % q ;
        p=(p*10)%(q*10);
        n0=new N(p/q,r);
        if(list.contains(n0))break ;
        list.add(n0);
      }
      if(n0.r==0){
        for(N n : list){
          if(n.r==0)break ;
          print(n.d+"");
        }
        println("");
      }
      else {
        for(N n : list)print(n.d+"");
        println("");
        boolean f=false ;
        for(N n : list){
          if(n.r==n0.r)f=true ;
          print(f ? "^" : " ");
        }
        println("");
      }
    }
    sc.close();
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
 class N {
   attribute d : long;
   attribute r : long;
   static operation newN( d : long, r : long) : N
  pre: true
  post: true
  activity:
  ( var self : N ;
    self := createN();
    self.initialise(d, r);
    return self );
  operation initialise( d : long, r : long) : void
  pre: true  post: true
  activity: (     self.d := d ; 
     self.r := r );
      operation equals( o : OclAny) : boolean
  pre: true
  post: true
  activity: (     return (o->oclAsType(N)).r = r );
}
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
       while sc.hasNext() do ( (     var p : long ; p := sc.getCurrent()->toLong() ;
     var q : long ; q := sc.getCurrent()->toLong() ;
    var list : Sequence(N) ; list := Sequence{} ;
    var n0 : N ; n0 := null ;
        var i : int ; i := 0 ; while true do ( (     var r : long ; r := p mod q ;
     p := (p * 10) mod (q * 10) ; 
    n0 := N.newN(p / q, r) ; 
    if (list->includes(n0)) then     break else skip ; 
    list := list->including(n0) ; 
 )  ;     i := i + 1 ) ; 
    if (n0.r = 0) then (     for (n : list) do ( (     if (n.r = 0) then     break else skip ; 
     execute print(n.d + "") )  ) ; 
     execute println("") ) else (     for (n : list) do (     execute print(n.d + "") ;  ) ; 
     execute println("") ; 
    var f : boolean ; f := false ;
    for (n : list) do ( (     if (n.r = n0.r) then     f := true ; else skip ; 
     execute print(if f then "^" else " " endif) )  ) ; 
    execute println("") ; 
 ) ;  
 )  ) ; 
     skip );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public String circulate(int n,int m){
    StringBuilder ans=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      ans.append(" ");
    }
    for(int i=n ; i<=m ; i++){
      ans.append("^");
    }
    return ans.toString();
  }
  public void solve()throws IOException {
    Scanner stdIn=null ;
    try {
      stdIn=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
      while(stdIn.hasNext()){
        int p=stdIn.nextInt();
        int q=stdIn.nextInt();
        Map<Integer,Integer>map=new HashMap<Integer,Integer>();
        StringBuilder ans=new StringBuilder();
        int index=0 ;
        int n=10*p/q ;
        int m=10*p % q ;
        outer : while(true){
          ans.append(n);
          if(m==0){
            System.out.println(ans);
            break ;
          }
          for(Integer x : map.keySet()){
            if(x==m){
              if(ans.charAt(map.get(x))-'0'==n){
                ans.deleteCharAt(ans.length()-1);
                System.out.println(ans);
                System.out.println(circulate(map.get(x),index-1));
              }
              else {
                System.out.println(ans);
                System.out.println(circulate(map.get(x)+1,index));
              }
              break outer ;
            }
          }
          if(m!=q){
            map.put(m,index);
          }
          n=10*m/q ;
          m=10*m % q ;
          index++;
        }
      }
    }
    finally {
      if(stdIn!=null){
        stdIn.close();
      }
    }
  }
  public static void main(String[] args)throws IOException {
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation circulate( n : int, m : int) : String
  pre: true
  post: true
  activity: (     var ans : String ; ans := StringLib.newString() ;
         var i : int ; i := 0 ; while i < n do ( (     ans := ans + StringLib.newString(" ") )  ;     i := i + 1 ) ; 
         var i : int ; i := n ; while i <= m do ( (     ans := ans + StringLib.newString("^") )  ;     i := i + 1 ) ; 
     return ans+"" );
   operation solve() : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := null ;
     try (     stdIn := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
     while (stdIn.hasNext()) do (     var p : int ; p := stdIn.getCurrent()->toInteger() ;
     var q : int ; q := stdIn.getCurrent()->toInteger() ;
    var map : Map(int,int) ; map := Map{} ;
    var ans : String ; ans := StringLib.newString() ;
    var index : int ; index := 0 ;
    var n : int ; n := 10 * p / q ;
    var m : int ; m := 10 * p mod q ;
    while (true) do (     ans := ans + StringLib.newString(n) ; 
     if (m = 0) then (     OclFile["System.out"].println(ans) ; 
     break ) else skip ; 
    for (x : map->keys()) do ( (     if (x = m) then (     if (ans->at(map->at(x)+1) - ('0')->char2byte() = n) then (     ans := ans->excludingAt(ans->size() - 1+1) ; 
     OclFile["System.out"].println(ans) ; 
     OclFile["System.out"].println(circulate(map->at(x), (index)->char2byte() - 1)) ) else (     OclFile["System.out"].println(ans) ; 
     OclFile["System.out"].println(circulate(map->at(x) + 1, index)) ) ;  
     break ) else skip )  ) ; 
    if (m /= q) then (     map := map->union(Map{m |-> index}) ) else skip ; 
    n := 10 * m / q ; 
    m := 10 * m mod q ; 
    index := index + 1 ; 
 ) ; 
 ) )   finally (     if (stdIn /= null) then (     skip ) else skip )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int find_maxm(int arr[],int n){
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      if(mp.containsKey(arr[i])){
        mp.put(arr[i],mp.get(arr[i])+1);
      }
      else {
        mp.put(arr[i],1);
      }
    }
    int ans=0 ;
    for(Map.Entry<Integer,Integer>x : mp.entrySet()){
      int value=x.getKey();
      int freq=x.getValue();
      if(value==freq){
        ans=Math.max(ans,value);
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      3,2,2,3,4,3 };
      int n=arr.length ;
      System.out.print(find_maxm(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation find_maxm( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (mp->keys()->includes(arr[i+1])) then (     mp := mp->union(Map{arr[i+1] |-> mp->at(arr[i+1]) + 1}) ) else (     mp := mp->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (x : mp->asSet()) do ( (     var value : int ; value := x.getKey() ;
     var freq : int ; freq := x.getValue() ;
     if (value = freq) then (     ans := Set{ans, value}->max() ) else skip )  ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,2,2,3,4,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(find_maxm(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    int[] data=null ;
    while((data=parseData())!=null){
      int p=data[0]/data[1];
      int q=data[0] % data[1];
      int e=0 ;
      int[] lf=new int[data[1] ];
      String out="" ;
      String lp="" ;
      Arrays.fill(lf,-1);
      while(true){
        if(q==0){
          lp="" ;
          break ;
        }
        else if(lf[q]!=-1){
          break ;
        }
        lf[q]=e++;
        p=(q*10)/data[1];
        q=(q*10)% data[1];
        out+=String.valueOf(p);
        lp+=" " ;
      }
      out=(out.isEmpty())? "0" : out ;
      System.out.println(out);
      if(! lp.isEmpty()){
        char[] tmp=lp.toCharArray();
        Arrays.fill(tmp,lf[q],e,'^');
        System.out.println(tmp);
      }
    }
  }
  private static int[] parseData(){
    int[] data=null ;
    String str=null ;
    if((str=parseStdin())!=null){
      String[] lines=str.split(" ");
      data=new int[2];
      data[0]=Integer.parseInt(lines[0]);
      data[1]=Integer.parseInt(lines[1]);
    }
    return data ;
  }
  private static String parseStdin(){
    String stdin=null ;
    try {
      String tmp=br.readLine();
      if(tmp!=null){
        if(! tmp.isEmpty()){
          stdin=tmp ;
        }
      }
    }
    catch(IOException e){
    }
    return stdin ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var data : Sequence(int) ; data := null ;
         data := parseData() ;
    while ((data) /= null) do (    skip ; (     var p : int ; p := data[0+1] / data[1+1] ;
     var q : int ; q := data[0+1] mod data[1+1] ;
    var e : int ; e := 0 ;
    var lf : Sequence(int) ; lf := Integer.subrange(1,data[1+1])->collect(0) ;
    var out : String ; out := "" ;
    var lp : String ; lp := "" ;
    lf := lf->collect(-1) ; 
    while (true) do (     if (q = 0) then (     lp := "" ; 
     break ) else     if (lf[q+1] /= -1) then (     break ) else skip ; ;  
      lf[q+1] := e  ; e := e + 1 ; 
    p := (q * 10) / data[1+1] ; 
    q := (q * 10) mod data[1+1] ; 
    out := out+(((p) + "")) ; 
    lp := lp+(" ") ; 
 ) ; 
    out := if (out->isEmpty()) then "0" else out endif ; 
    OclFile["System.out"].println(out) ; 
    if (not(lp->isEmpty())) then (     var tmp : Sequence(String) ; tmp := lp->characters() ;
     tmp := tmp->collect('^') ; 
     OclFile["System.out"].println(tmp) ) else skip ; 
 ) ;     data := parseData() ;
 ) );
  static   operation parseData() : Sequence(int)
  pre: true
  post: true
  activity: (     var data : Sequence(int) ; data := null ;
     var str : String ; str := null ;
     if ((str) /= null) then (     var lines : Sequence(String) ; lines := str->split(" ") ;
     data := Integer.subrange(1,2)->collect(0) ; 
     data[0+1] := (lines[0+1])->toInteger() ; 
     data[1+1] := (lines[1+1])->toInteger() ) else skip ; 
     return data );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var stdin : String ; stdin := null ;
     try (     var tmp : String ; tmp := br.readLine() ;
     if (tmp /= null) then (     if (not(tmp->isEmpty())) then (     stdin := tmp ) else skip ) else skip )   catch (e : IOException) do skip
     return stdin );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine())!=null){
      String[] input=line.split(" ");
      int p=Integer.parseInt(input[0]);
      int q=Integer.parseInt(input[1]);
      String qs="" ;
      int[] rs=new int[81];
      int pos=0 ;
      StringBuilder second=new StringBuilder();
      boolean isLoop=false ;
      p-=(p/q)*q ;
      rs[pos]=p ;
      wh : while(true){
        int sho=(10*p)/q ;
        p=(10*p)% q ;
        if(p==0){
          qs=qs+sho ;
          break ;
        }
        int i ;
        for(i=pos ; i>=0 ; i--){
          if(rs[i]==p){
            qs=qs+sho ;
            int marklength=qs.length()-i ;
            for(int j=0 ; j<i ; j++){
              second.append(" ");
            }
            for(int j=0 ; j<marklength ; j++){
              second.append("^");
            }
            isLoop=true ;
            break wh ;
          }
        }
        qs=qs+sho ;
        rs[++pos]=p ;
      }
      if(isLoop){
        System.out.println(qs);
        System.out.println(second.toString());
      }
      else {
        System.out.println(qs);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     var input : Sequence(String) ; input := line->split(" ") ;
     var p : int ; p := (input[0+1])->toInteger() ;
    var q : int ; q := (input[1+1])->toInteger() ;
    var qs : String ; qs := "" ;
    var rs : Sequence(int) ; rs := Integer.subrange(1,81)->collect(0) ;
    var pos : int ; pos := 0 ;
    var second : String ; second := StringLib.newString() ;
    var isLoop : boolean ; isLoop := false ;
    p := p-((p / q) * q) ; 
    rs[pos+1] := p ; 
    while (true) do (     var sho : int ; sho := (10 * p) / q ;
     p := (10 * p) mod q ; 
    if (p = 0) then (     qs := qs + sho ; 
     break ) else skip ; 
    var i : int ;
        i := pos ; while i >= 0 do ( (     if (rs[i+1] = p) then (     qs := qs + sho ; 
     var marklength : int ; marklength := qs->size() - i ;
        var j : int ; j := 0 ; while j < i do ( (     second := second + StringLib.newString(" ") )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < marklength do ( (     second := second + StringLib.newString("^") )  ;     j := j + 1 ) ; 
    isLoop := true ; 
    break 
 ) else skip )  ;     i := i - 1 ) ; 
    qs := qs + sho ; 
        pos := pos + 1 ;
 rs[pos+1] := p  ; 
 ) ; 
    if (isLoop) then (     OclFile["System.out"].println(qs) ; 
     OclFile["System.out"].println(second+"") ) else (     OclFile["System.out"].println(qs) ) ;  
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static void preCompute(int arr[],int n,int pre[]){
    pre[0]=arr[0];
    for(int i=1 ; i<n ; i++)pre[i]=arr[i]+pre[i-1];
  }
  public static int rangeSum(int i,int j,int pre[]){
    if(i==0)return pre[j];
    return pre[j]-pre[i-1];
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5 };
      int n=arr.length ;
      int pre[]=new int[n];
      preCompute(arr,n,pre);
      System.out.println(rangeSum(1,3,pre));
      System.out.println(rangeSum(2,4,pre));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation preCompute( arr : Sequence(int), n : int, pre : Sequence(int)) : void
  pre: true
  post: true
  activity: (     pre[0+1] := arr[0+1] ; 
         var i : int ; i := 1 ; while i < n do (     pre[i+1] := arr[i+1] + pre[i - 1+1] ;  ;     i := i + 1 ) );
  static   operation rangeSum( i : int, j : int, pre : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (i = 0) then     return pre[j+1] else skip ; 
     return pre[j+1] - pre[i - 1+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var n : int ; n := arr->size() ;
    var pre : Sequence(int) ; pre := Integer.subrange(1,n)->collect(0) ;
    execute preCompute(arr, n, pre) ; 
    OclFile["System.out"].println(rangeSum(1, 3, pre)) ; 
    OclFile["System.out"].println(rangeSum(2, 4, pre)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findFactors(int a,int b){
    int c ;
    c=a+b-1 ;
    System.out.print(c);
  }
  public static void main(String[] args){
    int a,b ;
    a=13 ;
    b=36 ;
    findFactors(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findFactors( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var c : int ;
     c := a + b - 1 ; 
     OclFile["System.out"].print(c) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ;
    var b : int ;
     a := 13 ; 
     b := 36 ; 
     execute findFactors(a, b) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int a[]=new int[n+1];
      boolean ans=false ;
      if(n % 2==0)ans=true ;
      for(int j=1 ; j<=n ; j++){
        a[j]=sc.nextInt();
        if(a[j]<=a[j-1])ans=true ;
      }
      if(ans)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var ans : boolean ; ans := false ;
    if (n mod 2 = 0) then     ans := true ; else skip ; 
        var j : int ; j := 1 ; while j <= n do ( (     a[j+1] := sc.getCurrent()->toInteger() ; 
     if (a[j+1] <= a[j - 1+1]) then     ans := true ; else skip )  ;     j := j + 1 ) ; 
    if (ans) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int a[]=new int[n+1];
      boolean ans=false ;
      if(n % 2==0)ans=true ;
      for(int j=1 ; j<=n ; j++){
        a[j]=sc.nextInt();
        if(a[j]<=a[j-1])ans=true ;
      }
      if(ans)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var ans : boolean ; ans := false ;
    if (n mod 2 = 0) then     ans := true ; else skip ; 
        var j : int ; j := 1 ; while j <= n do ( (     a[j+1] := sc.getCurrent()->toInteger() ; 
     if (a[j+1] <= a[j - 1+1]) then     ans := true ; else skip )  ;     j := j + 1 ) ; 
    if (ans) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      int m=in.nextInt();
      for(int i=1 ; i<=n ; i++){
        for(int j=1 ; j<=m ; j++){
          boolean e=(i % 4<=1)!=(j % 4<=1);
          if(e)System.out.print(0+" ");
          else System.out.print(1+" ");
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= m do ( (     var e : boolean ; e := (i mod 4 <= 1) /= (j mod 4 <= 1) ;
     if (e) then     OclFile["System.out"].print(0 + " ") ; else     OclFile["System.out"].print(1 + " ") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int GCD(int a,int b){
    if(b==0)return a ;
    return GCD(b,a % b);
  }
  static void makePairs(Vector<Integer>pairs,int a,int b){
    for(int i=a ; i<=b ; i++){
      int sumOfDigits=0,k=i ;
      while(k>0){
        sumOfDigits+=k % 10 ;
        k/=10 ;
      }
      if(sumOfDigits<=162)pairs.add(sumOfDigits);
    }
  }
  static int countCoPrime(int a,int b){
    Vector<Integer>pairs=new Vector<Integer>();
    makePairs(pairs,a,b);
    int count=0 ;
    for(int i=0 ; i<pairs.size(); i++)for(int j=i+1 ; j<pairs.size(); j++)if(GCD(pairs.get(i),pairs.get(j))==1)count++;
    return count ;
  }
  public static void main(String args[]){
    int a=12,b=15 ;
    System.out.println(countCoPrime(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation GCD( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return GCD(b, a mod b) );
  static   operation makePairs( pairs : Sequence(int), a : int, b : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := a ; while i <= b do ( (     var sumOfDigits : int ; sumOfDigits := 0 ;
    var k : int ; k := i ;
     while (k > 0) do (     sumOfDigits := sumOfDigits+(k mod 10) ; 
     k := k/(10) ) ; 
     if (sumOfDigits <= 162) then     pairs->excludes(sumOfDigits) ; else skip )  ;     i := i + 1 ) );
  static   operation countCoPrime( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var pairs : Sequence(int) ; pairs := Sequence{} ;
     execute makePairs(pairs, a, b) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < pairs->size() do (         var j : int ; j := i + 1 ; while j < pairs->size() do (     if (GCD(pairs->at(i+1), pairs->at(j+1)) = 1) then     count := count + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 12 ;
    var b : int ; b := 15 ;
     OclFile["System.out"].println(countCoPrime(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int m=s.nextInt();
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<m ; j++){
          if(i % 4==0 || i % 4==3){
            if(j % 4==0 || j % 4==3)System.out.print(1+" ");
            else System.out.print(0+" ");
          }
          else {
            if(j % 4==0 || j % 4==3)System.out.print(0+" ");
            else System.out.print(1+" ");
          }
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var m : int ; m := s.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (i mod 4 = 0 or i mod 4 = 3) then (     if (j mod 4 = 0 or j mod 4 = 3) then     OclFile["System.out"].print(1 + " ") ; else     OclFile["System.out"].print(0 + " ") ; ) else (     if (j mod 4 = 0 or j mod 4 = 3) then     OclFile["System.out"].print(0 + " ") ; else     OclFile["System.out"].print(1 + " ") ; ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Wifi {
  static void sort(long[] arr){
    ArrayList<Long>a=new ArrayList<>();
    for(long i : arr){
      a.add(i);
    }
    Collections.sort(a);
    for(int i=0 ; i<a.size(); i++){
      arr[i]=a.get(i);
    }
  }
  static int upper(long[] arr,long ele){
    int low=0,high=arr.length-1 ;
    int ind=-1 ;
    while(low<=high){
      int mid=(low+high)/2 ;
      if(arr[mid]<=ele){
        ind=mid ;
        low=mid+1 ;
      }
      else {
        high=mid-1 ;
      }
    }
    return ind ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int n2=sc.nextInt();
    long[] arr=new long[n];
    long[] brr=new long[n2];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextLong();
    }
    for(int i=0 ; i<n2 ; i++){
      brr[i]=sc.nextLong();
    }
    sort(arr);
    for(int i=0 ; i<n2 ; i++){
      int ele=upper(arr,brr[i]);
      if(ele>=0){
        System.out.print(ele+1+" ");
      }
      else {
        System.out.print("0 ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Wifi {
  static   operation sort( arr : Sequence(long)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Sequence{} ;
     for (i : arr) do ( (     a := a->including(i) )  ) ; 
     a := a->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do ( (     arr[i+1] := a->at(i+1) )  ;     i := i + 1 ) );
  static   operation upper( arr : Sequence(long), ele : long) : int
  pre: true
  post: true
  activity: (     var low : int ; low := 0 ;
    var high : int ; high := arr->size() - 1 ;
     var ind : int ; ind := -1 ;
     while (low <= high) do (     var mid : int ; mid := (low + high) / 2 ;
     if (arr[mid+1] <= ele) then (     ind := mid ; 
     low := mid + 1 ) else (     high := mid - 1 ) ) ; 
     return ind );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var n2 : int ; n2 := sc.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
    var brr : Sequence(long) ; brr := Integer.subrange(1,n2)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n2 do ( (     brr[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    execute sort(arr) ; 
        var i : int ; i := 0 ; while i < n2 do ( (     var ele : int ; ele := upper(arr, brr[i+1]) ;
     if (ele >= 0) then (     OclFile["System.out"].print(ele + 1 + " ") ) else (     OclFile["System.out"].print("0 ") ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(new BufferedInputStream(System.in));
    int N=scan.nextInt();
    int[] arr=new int[N];
    for(int i=0 ; i<N ; i++)arr[i]=scan.nextInt();
    Task tsk=new Task();
    System.out.println(tsk.solve(arr));
  }
  static class Task {
    public int solve(int[] arr){
      int n=arr.length ;
      int[] sorted=Arrays.copyOf(arr,n);
      Arrays.sort(sorted);
      long total=(long)n*(n+1)/2 ;
      int l=0,r=n-1 ;
      while(l<r){
        int mid=l+(r-l)/2 ;
        int target=sorted[mid];
        int cur=0 ;
        long cnt=0 ;
        long[] bit=new long[2*n+2];
        for(int x=n+1 ; x<bit.length ; x+=x &-x)bit[x]++;
        for(int i=0 ; i<n ; i++){
          cur+=arr[i]<=target ? 1 :-1 ;
          for(int x=cur+n+1 ; x<bit.length ; x+=x &-x)bit[x]++;
          for(int x=cur+n ; x>0 ; x-=x &-x)cnt+=bit[x];
        }
        if(cnt>=total/2+1)r=mid ;
        else l=mid+1 ;
      }
      return sorted[l];
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     arr[i+1] := scan.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var tsk : Task ; tsk := Task.newTask() ;
    OclFile["System.out"].println(tsk.solve(arr)) ; 
 );
  static class Task {
   operation solve( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
     var sorted : Sequence(int) ; sorted := arr.subrange(1,n) ;
    sorted := sorted->sort() ; 
    var total : long ; total := n->oclAsType(long) * (n + 1) / 2 ;
    var l : int ; l := 0 ;
    var r : int ; r := n - 1 ;
    while (l < r) do (     var mid : int ; mid := l + (r - l) / 2 ;
     var target : int ; target := sorted[mid+1] ;
    var cur : int ; cur := 0 ;
    var cnt : long ; cnt := 0 ;
    var bit : Sequence(long) ; bit := Integer.subrange(1,2 * n + 2)->collect(0) ;
        var x : int ; x := n + 1 ; while x < bit->size() do (     bit[x+1] := bit[x+1] + 1 ;  ;     x := x+(MathLib.bitwiseAnd(x,-x)) ) ; 
        var i : int ; i := 0 ; while i < n do ( (     cur := cur+(if arr[i+1] <= target then 1 else -1 endif) ; 
         var x : int ; x := cur + n + 1 ; while x < bit->size() do (     bit[x+1] := bit[x+1] + 1 ;  ;     x := x+(MathLib.bitwiseAnd(x,-x)) ) ; 
         var x : int ; x := cur + n ; while x > 0 do (     cnt := cnt+(bit[x+1]) ;  ;     x := x-(MathLib.bitwiseAnd(x,-x)) ) )  ;     i := i + 1 ) ; 
    if (cnt >= total / 2 + 1) then     r := mid else     l := mid + 1 ; ;  
 ) ; 
    return sorted[l+1] 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),n1=in.nextInt();
    Integer a[]=new Integer[n];
    Arrays.setAll(a,i->in.nextInt());
    Arrays.sort(a);
    for(int i=0 ; i<n1 ; i++){
      System.out.print(binarySearchCount(a,n,in.nextInt())+" ");
    }
  }
  static int binarySearchCount(Integer arr[],int n,int key){
    int left=0 ;
    int right=n-1 ;
    int count=0 ;
    while(left<=right){
      int mid=(right+left)/2 ;
      if(arr[mid]<=key){
        count=mid+1 ;
        left=mid+1 ;
      }
      else right=mid-1 ;
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var n1 : int ; n1 := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(null) ;
setAll(a, lambda i : OclAny in in.getCurrent()->toInteger()) ; 
    a := a->sort() ; 
        var i : int ; i := 0 ; while i < n1 do ( (     OclFile["System.out"].print(binarySearchCount(a, n, in.getCurrent()->toInteger()) + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation binarySearchCount( arr : Sequence(int), n : int, key : int) : int
  pre: true
  post: true
  activity: (     var left : int ; left := 0 ;
     var right : int ; right := n - 1 ;
    var count : int ; count := 0 ;
    while (left <= right) do (     var mid : int ; mid := (right + left) / 2 ;
     if (arr[mid+1] <= key) then (     count := mid + 1 ; 
     left := mid + 1 ) else     right := mid - 1 ; ) ; 
    return count 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),m=in.nextInt();
    ArrayList<Long>l=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      l.add(in.nextLong());
    }
    Collections.sort(l);
    for(int i=0 ; i<m ; i++){
      pw.print(UpperBound(l,in.nextLong())+" ");
    }
    pw.close();
  }
  public static int UpperBound(ArrayList<Long>a,long x){
    int l=-1,r=a.size();
    while(l+1<r){
      int m=(l+r)>>>1 ;
      if(a.get(m)<=x)l=m ;
      else r=m ;
    }
    return l+1 ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var l : Sequence(long) ; l := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     l := l->including(in.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    l := l->sort() ; 
        var i : int ; i := 0 ; while i < m do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation UpperBound( a : Sequence(long), x : long) : int
  pre: true
  post: true
  activity: (     var l : int ; l := -1 ;
    var r : int ; r := a->size() ;
     while (l + 1 < r) do (     var m : int ; m := ((l + r)/(2->pow(1)))->oclAsType(long) ;
     if (a->at(m+1) <= x) then     l := m ; else     r := m ; ) ; 
     return l + 1 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
class gfg {
  static float sph(float r,float R,float h){
    if(r<0 && R<0 && h<0)return-1 ;
    float x=r ;
    float V=(float)(4*3.14f*Math.pow(r,3))/3 ;
    return V ;
  }
  public static void main(String[] args){
    float r=5,R=8,h=11 ;
    System.out.println(sph(r,R,h));
  }
}
------------------------------------------------------------
OCL File:
---------
 class gfg {
  static   operation sph( r : double, R : double, h : double) : double
  pre: true
  post: true
  activity: (     if (r < 0 & R < 0 & h < 0) then     return -1 else skip ; 
     var x : double ; x := r ;
     var V : double ; V := (4 * 3.14f * r->pow(3))->oclAsType(double) / 3 ;
     return V );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : double ; r := 5 ;
    var R : double ; R := 8 ;
    var h : double ; h := 11 ;
     OclFile["System.out"].println(sph(r, R, h)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static boolean checkDuplicatesWithinK(int arr[],int k){
    HashSet<Integer>set=new HashSet<>();
    for(int i=0 ; i<arr.length ; i++){
      if(set.contains(arr[i]))return true ;
      set.add(arr[i]);
      if(i>=k)set.remove(arr[i-k]);
    }
    return false ;
  }
  public static void main(String[] args){
    int arr[]={
      10,5,3,4,3,5,6 };
      if(checkDuplicatesWithinK(arr,3))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation checkDuplicatesWithinK( arr : Sequence(int), k : int) : boolean
  pre: true
  post: true
  activity: (     var set : Set(int) ; set := Set{} ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     if (set->includes(arr[i+1])) then     return true else skip ; 
     set := set->including(arr[i+1]) ; 
     if (i >= k) then     set := set->excludingFirst(arr[i - k+1]) ; else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,5,3,4,3,5,6} ;
     if (checkDuplicatesWithinK(arr, 3)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static String leastLexiString(String s){
    if(s.length()==1)return s ;
    String x=leastLexiString(s.substring(0,s.length()/2));
    String y=leastLexiString(s.substring(s.length()/2));
    return String.valueOf((x+y).compareTo(y+x));
  }
  static boolean areEquivalent(String a,String b){
    return !(leastLexiString(a).equals(leastLexiString(b)));
  }
  public static void main(String[] args){
    String a="aaba" ;
    String b="abaa" ;
    if(areEquivalent(a,b))System.out.println("Yes");
    else System.out.println("No");
    a="aabb" ;
    b="abab" ;
    if(areEquivalent(a,b))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation leastLexiString( s : String) : String
  pre: true
  post: true
  activity: (     if (s->size() = 1) then     return s else skip ; 
     var x : String ; x := leastLexiString(s.subrange(0+1,s->size() / 2)) ;
     var y : String ; y := leastLexiString(s.subrange(s->size() / 2+1,s->size() / 2)) ;
     return (((x + y)->compareTo(y + x)) + "") );
  static   operation areEquivalent( a : String, b : String) : boolean
  pre: true
  post: true
  activity: (     return not((leastLexiString(a) = leastLexiString(b))) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ; a := "aaba" ;
     var b : String ; b := "abaa" ;
    if (areEquivalent(a, b)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
    a := "aabb" ; 
    b := "abab" ; 
    if (areEquivalent(a, b)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printMatrix(int n,int m){
    if(n<5 || m<5){
      System.out.print(-1);
      return ;
    }
    char[] s="aeiou".toCharArray();
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        System.out.print(s[j % 5]+" ");
      }
      System.out.println();
      char c=s[0];
      for(int k=0 ; k<4 ; k++){
        s[k]=s[k+1];
      }
      s[4]=c ;
    }
  }
  public static void main(String[] args){
    int n=5,m=5 ;
    printMatrix(n,m);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printMatrix( n : int, m : int) : void
  pre: true
  post: true
  activity: (     if (n < 5 or m < 5) then (     OclFile["System.out"].print(-1) ; 
     return ) else skip ; 
     var s : Sequence(String) ; s := "aeiou"->characters() ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     OclFile["System.out"].print(s[j mod 5+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() ; 
    var c : String ; c := s[0+1] ;
        var k : int ; k := 0 ; while k < 4 do ( (     s[k+1] := s[k + 1+1] )  ;     k := k + 1 ) ; 
    s[4+1] := c ; 
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var m : int ; m := 5 ;
     execute printMatrix(n, m) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  int ans ;
  public int diameterOfBinaryTree(TreeNode root){
    ans=1 ;
    depth(root);
    return ans-1 ;
  }
  public int depth(TreeNode node){
    if(node==null)return 0 ;
    int L=depth(node.left);
    int R=depth(node.right);
    ans=Math.max(ans,L+R+1);
    return Math.max(L,R)+1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   attribute ans : int;
   operation diameterOfBinaryTree( root : TreeNode) : int
  pre: true
  post: true
  activity: (     ans := 1 ; 
     execute depth(root) ; 
     return ans - 1 );
   operation depth( node : TreeNode) : int
  pre: true
  post: true
  activity: (     if (node = null) then     return 0 else skip ; 
     var L : int ; L := depth(node.left) ;
    var R : int ; R := depth(node.right) ;
    ans := Set{ans, L + R + 1}->max() ; 
    return Set{L, R}->max() + 1 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  static int findElement(int[] arr,int n){
    int[] leftMax=new int[n];
    leftMax[0]=Integer.MIN_VALUE ;
    for(int i=1 ; i<n ; i++)leftMax[i]=Math.max(leftMax[i-1],arr[i-1]);
    int rightMin=Integer.MAX_VALUE ;
    for(int i=n-1 ; i>=0 ; i--){
      if(leftMax[i]<arr[i] && rightMin>arr[i])return i ;
      rightMin=Math.min(rightMin,arr[i]);
    }
    return-1 ;
  }
  public static void main(String args[]){
    int[] arr={
      5,1,4,3,6,8,10,7,9 };
      int n=arr.length ;
      System.out.println("Index of the element is "+findElement(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findElement( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var leftMax : Sequence(int) ; leftMax := Integer.subrange(1,n)->collect(0) ;
     leftMax[0+1] := -2147483648 ; 
        var i : int ; i := 1 ; while i < n do (     leftMax[i+1] := Set{leftMax[i - 1+1], arr[i - 1+1]}->max() ;  ;     i := i + 1 ) ; 
    var rightMin : int ; rightMin := 2147483647 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (leftMax[i+1] < arr[i+1] & rightMin > arr[i+1]) then     return i else skip ; 
     rightMin := Set{rightMin, arr[i+1]}->min() )  ;     i := i - 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,1,4,3,6,8,10,7,9} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Index of the element is " + findElement(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int closetAND(int arr[],int n,int k){
    int ans=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      int X=arr[i];
      for(int j=i ; j<n ; j++){
        X &=arr[j];
        ans=Math.min(ans,Math.abs(k-X));
        if(X<=k)break ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      4,7,10 };
      int n=arr.length ;
      int k=2 ;
      System.out.println(closetAND(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation closetAND( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 2147483647 ;
         var i : int ; i := 0 ; while i < n do ( (     var X : int ; X := arr[i+1] ;
         var j : int ; j := i ; while j < n do ( (     X := MathLib.bitwiseAnd(X, arr[j+1]) ; 
     ans := Set{ans, if k - X < 0 then -(k - X) else k - X endif}->min() ; 
     if (X <= k) then     break else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,7,10} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(closetAND(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Codeforces {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    char[] a=new char[n];
    for(int i=0 ; i<n ; i++)a[i]=s.charAt(i);
    int w=0 ;
    int b=0 ;
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='B')b++;
      else w++;
    }
    if(w % 2==0 || b % 2==0){
      char eliminate=b % 2==0 ? 'B' : 'W' ;
      int elim=b % 2==0 ? b : w ;
      ArrayList<Integer>ops=new ArrayList<>();
      for(int i=0 ; i<n-1 && elim>0 ; i++){
        if(a[i]==eliminate){
          ops.add(i+1);
          if(a[i+1]==eliminate){
            elim-=2 ;
            if(eliminate=='B'){
              a[i]='W' ;
              a[i+1]='W' ;
            }
            else {
              a[i]='B' ;
              a[i+1]='B' ;
            }
          }
          else {
            a[i+1]=eliminate ;
            a[i]=eliminate=='B' ? 'W' : 'B' ;
          }
        }
      }
      System.out.println(ops.size());
      for(int i=0 ; i<ops.size(); i++)System.out.print(ops.get(i)+" ");
    }
    else {
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var a : Sequence(String) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := s->at(i+1) ;  ;     i := i + 1 ) ; 
    var w : int ; w := 0 ;
    var b : int ; b := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = 'B') then     b := b + 1 ; else     w := w + 1 ; )  ;     i := i + 1 ) ; 
    if (w mod 2 = 0 or b mod 2 = 0) then (     var eliminate : String ; eliminate := if b mod 2 = 0 then 'B' else 'W' endif ;
     var elim : int ; elim := if b mod 2 = 0 then b else w endif ;
    var ops : Sequence(int) ; ops := Sequence{} ;
        var i : int ; i := 0 ; while i < n - 1 & elim > 0 do ( (     if (a[i+1] = eliminate) then (     ops := ops->including(i + 1) ; 
     if (a[i + 1+1] = eliminate) then (     elim := elim-(2) ; 
     if (eliminate = 'B') then (     a[i+1] := 'W' ; 
     a[i + 1+1] := 'W' ) else (     a[i+1] := 'B' ; 
     a[i + 1+1] := 'B' ) ) else (     a[i + 1+1] := eliminate ; 
     a[i+1] := if eliminate = 'B' then 'W' else 'B' endif ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ops->size()) ; 
        var i : int ; i := 0 ; while i < ops->size() do (     OclFile["System.out"].print(ops->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 ) else (     OclFile["System.out"].println(-1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int sumOfDigitsSingle(int x){
    int ans=0 ;
    while(x!=0){
      ans+=x % 10 ;
      x/=10 ;
    }
    return ans ;
  }
  static int closest(int x){
    int ans=0 ;
    while(ans*10+9<=x)ans=ans*10+9 ;
    return ans ;
  }
  static int sumOfDigitsTwoParts(int N){
    int A=closest(N);
    return sumOfDigitsSingle(A)+sumOfDigitsSingle(N-A);
  }
  public static void main(String args[]){
    int N=35 ;
    System.out.print(sumOfDigitsTwoParts(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfDigitsSingle( x : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     while (x /= 0) do (     ans := ans+(x mod 10) ; 
     x := x/(10) ) ; 
     return ans );
  static   operation closest( x : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     while (ans * 10 + 9 <= x) do     ans := ans * 10 + 9 ; ; 
     return ans );
  static   operation sumOfDigitsTwoParts( N : int) : int
  pre: true
  post: true
  activity: (     var A : int ; A := closest(N) ;
     return sumOfDigitsSingle(A) + sumOfDigitsSingle(N - A) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 35 ;
     OclFile["System.out"].print(sumOfDigitsTwoParts(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findNthOddDigitNumber(int n){
    int count=0 ;
    for(int i=1 ; ; i++){
      int num=i ;
      boolean isMadeOfOdd=true ;
      while(num!=0){
        if(num % 10==0 || num % 10==2 || num % 10==4 || num % 10==6 || num % 10==8){
          isMadeOfOdd=false ;
          break ;
        }
        num=num/10 ;
      }
      if(isMadeOfOdd==true)count++;
      if(count==n)return i ;
    }
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(findNthOddDigitNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNthOddDigitNumber( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while true do ( (     var num : int ; num := i ;
     var isMadeOfOdd : boolean ; isMadeOfOdd := true ;
    while (num /= 0) do (     if (num mod 10 = 0 or num mod 10 = 2 or num mod 10 = 4 or num mod 10 = 6 or num mod 10 = 8) then (     isMadeOfOdd := false ; 
     break ) else skip ; 
     num := num / 10 ) ; 
    if (isMadeOfOdd = true) then     count := count + 1 ; else skip ; 
    if (count = n) then     return i else skip ; 
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(findNthOddDigitNumber(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int findMaximumPieces(int n){
    int x=n/2 ;
    return((x+1)*(n-x+1));
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.print("Max number of pieces for n="+n+" is "+findMaximumPieces(3));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMaximumPieces( n : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := n / 2 ;
     return ((x + 1) * (n - x + 1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].print("Max number of pieces for n=" + n + " is " + findMaximumPieces(3)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findCount(int d){
    return 9*((int)(Math.pow(10,d-1))-(int)(Math.pow(9,d-1)));
  }
  public static void main(String args[]){
    int d=1 ;
    System.out.println(findCount(d));
    d=2 ;
    System.out.println(findCount(d));
    d=4 ;
    System.out.println(findCount(d));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findCount( d : int) : int
  pre: true
  post: true
  activity: (     return 9 * ((10->pow(d - 1))->oclAsType(int) - (9->pow(d - 1))->oclAsType(int)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : int ; d := 1 ;
     OclFile["System.out"].println(findCount(d)) ; 
    d := 2 ; 
    OclFile["System.out"].println(findCount(d)) ; 
    d := 4 ; 
    OclFile["System.out"].println(findCount(d)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GenerateArrays {
  void generateUtil(int A[],int B[],int C[],int i,int j,int m,int n,int len,boolean flag){
    if(flag){
      if(len!=0)printArr(C,len+1);
      for(int k=i ; k<m ; k++){
        if(len==0){
          C[len]=A[k];
          generateUtil(A,B,C,k+1,j,m,n,len,! flag);
        }
        else if(A[k]>C[len]){
          C[len+1]=A[k];
          generateUtil(A,B,C,k+1,j,m,n,len+1,! flag);
        }
      }
    }
    else {
      for(int l=j ; l<n ; l++){
        if(B[l]>C[len]){
          C[len+1]=B[l];
          generateUtil(A,B,C,i,l+1,m,n,len+1,! flag);
        }
      }
    }
  }
  void generate(int A[],int B[],int m,int n){
    int C[]=new int[m+n];
    generateUtil(A,B,C,0,0,m,n,0,true);
  }
  void printArr(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    System.out.println("");
  }
  public static void main(String[] args){
    GenerateArrays generate=new GenerateArrays();
    int A[]={
      10,15,25 };
      int B[]={
        5,20,30 };
        int n=A.length ;
        int m=B.length ;
        generate.generate(A,B,n,m);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GenerateArrays {
   operation generateUtil( A : Sequence(int), B : Sequence(int), C : Sequence(int), i : int, j : int, m : int, n : int, len : int, flag : boolean) : void
  pre: true
  post: true
  activity: (     if (flag) then (     if (len /= 0) then     execute printArr(C, len + 1) ; else skip ; 
         var k : int ; k := i ; while k < m do ( (     if (len = 0) then (     C[len+1] := A[k+1] ; 
     execute generateUtil(A, B, C, k + 1, j, m, n, len, not(flag)) ) else     if (A[k+1] > C[len+1]) then (     C[len + 1+1] := A[k+1] ; 
     execute generateUtil(A, B, C, k + 1, j, m, n, len + 1, not(flag)) ) else skip ; )  ;     k := k + 1 ) ) else (         var l : int ; l := j ; while l < n do ( (     if (B[l+1] > C[len+1]) then (     C[len + 1+1] := B[l+1] ; 
     execute generateUtil(A, B, C, i, l + 1, m, n, len + 1, not(flag)) ) else skip )  ;     l := l + 1 ) ) );
   operation generate( A : Sequence(int), B : Sequence(int), m : int, n : int) : void
  pre: true
  post: true
  activity: (     var C : Sequence(int) ; C := Integer.subrange(1,m + n)->collect(0) ;
     execute generateUtil(A, B, C, 0, 0, m, n, 0, true) );
   operation printArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var generate : GenerateArrays ; generate := GenerateArrays.newGenerateArrays() ;
     var A : Sequence(int) ; A := Sequence{10,15,25} ;
    var B : Sequence(int) ; B := Sequence{5,20,30} ;
    var n : int ; n := A->size() ;
    var m : int ; m := B->size() ;
    generate.generate(A, B, n, m) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Set ;
public class GfG {
  static void findMissing(int a[],int b[],int n,int m){
    HashSet<Integer>s=new HashSet<>();
    for(int i=0 ; i<m ; i++)s.add(b[i]);
    for(int i=0 ; i<n ; i++)if(! s.contains(a[i]))System.out.print(a[i]+" ");
  }
  public static void main(String[] args){
    int a[]={
      1,2,6,3,4,5 };
      int b[]={
        2,4,3,1,0 };
        int n=a.length ;
        int m=b.length ;
        findMissing(a,b,n,m);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation findMissing( a : Sequence(int), b : Sequence(int), n : int, m : int) : void
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
         var i : int ; i := 0 ; while i < m do (     s := s->including(b[i+1]) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do (     if (not(s->includes(a[i+1]))) then     OclFile["System.out"].print(a[i+1] + " ") ; else skip ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,6,3,4,5} ;
     var b : Sequence(int) ; b := Sequence{2,4,3,1,0} ;
    var n : int ; n := a->size() ;
    var m : int ; m := b->size() ;
    execute findMissing(a, b, n, m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String findSum(String str1,String str2){
    if(str1.length()>str2.length()){
      String t=str1 ;
      str1=str2 ;
      str2=t ;
    }
    String str="" ;
    int n1=str1.length(),n2=str2.length();
    int diff=n2-n1 ;
    int carry=0 ;
    for(int i=n1-1 ; i>=0 ; i--){
      int sum=((int)(str1.charAt(i)-'0')+(int)(str2.charAt(i+diff)-'0')+carry);
      str+=(char)(sum % 10+'0');
      carry=sum/10 ;
    }
    for(int i=n2-n1-1 ; i>=0 ; i--){
      int sum=((int)(str2.charAt(i)-'0')+carry);
      str+=(char)(sum % 10+'0');
      carry=sum/10 ;
    }
    if(carry>0)str+=(char)(carry+'0');
    return new StringBuilder(str).reverse().toString();
  }
  public static void main(String[] args){
    String str1="12" ;
    String str2="198111" ;
    System.out.println(findSum(str1,str2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSum( str1 : String, str2 : String) : String
  pre: true
  post: true
  activity: (     if (str1->size() > str2->size()) then (     var t : String ; t := str1 ;
     str1 := str2 ; 
     str2 := t ) else skip ; 
     var str : String ; str := "" ;
    var n1 : int ; n1 := str1->size() ;
    var n2 : int ; n2 := str2->size() ;
    var diff : int ; diff := (n2)->char2byte() - (n1)->char2byte() ;
    var carry : int ; carry := 0 ;
        var i : int ; i := (n1)->char2byte() - 1 ; while i >= 0 do ( (     var sum : int ; sum := ((str1->at(i+1) - ('0')->char2byte())->oclAsType(int) + (str2->at(i + diff+1) - ('0')->char2byte())->oclAsType(int) + carry) ;
     str := str+((sum mod 10 + '0')->oclAsType(String)) ; 
     carry := sum / 10 )  ;     i := i - 1 ) ; 
        var i : int ; i := (n2)->char2byte() - (n1)->char2byte() - 1 ; while i >= 0 do ( (     var sum : int ; sum := ((str2->at(i+1) - ('0')->char2byte())->oclAsType(int) + carry) ;
     str := str+((sum mod 10 + '0')->oclAsType(String)) ; 
     carry := sum / 10 )  ;     i := i - 1 ) ; 
    if (carry > 0) then     str := str+((carry + '0')->oclAsType(String)) ; else skip ; 
    return StringLib.newString(str)->reverse()+"" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "12" ;
     var str2 : String ; str2 := "198111" ;
     OclFile["System.out"].println(findSum(str1, str2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String findSum(String str1,String str2){
    if(str1.length()>str2.length()){
      String t=str1 ;
      str1=str2 ;
      str2=t ;
    }
    String str="" ;
    int n1=str1.length(),n2=str2.length();
    str1=new StringBuilder(str1).reverse().toString();
    str2=new StringBuilder(str2).reverse().toString();
    int carry=0 ;
    for(int i=0 ; i<n1 ; i++){
      int sum=((int)(str1.charAt(i)-'0')+(int)(str2.charAt(i)-'0')+carry);
      str+=(char)(sum % 10+'0');
      carry=sum/10 ;
    }
    for(int i=n1 ; i<n2 ; i++){
      int sum=((int)(str2.charAt(i)-'0')+carry);
      str+=(char)(sum % 10+'0');
      carry=sum/10 ;
    }
    if(carry>0)str+=(char)(carry+'0');
    str=new StringBuilder(str).reverse().toString();
    return str ;
  }
  public static void main(String[] args){
    String str1="12" ;
    String str2="198111" ;
    System.out.println(findSum(str1,str2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSum( str1 : String, str2 : String) : String
  pre: true
  post: true
  activity: (     if (str1->size() > str2->size()) then (     var t : String ; t := str1 ;
     str1 := str2 ; 
     str2 := t ) else skip ; 
     var str : String ; str := "" ;
    var n1 : int ; n1 := str1->size() ;
    var n2 : int ; n2 := str2->size() ;
    str1 := StringLib.newString(str1)->reverse()+"" ; 
    str2 := StringLib.newString(str2)->reverse()+"" ; 
    var carry : int ; carry := 0 ;
        var i : int ; i := 0 ; while i < n1 do ( (     var sum : int ; sum := ((str1->at(i+1) - ('0')->char2byte())->oclAsType(int) + (str2->at(i+1) - ('0')->char2byte())->oclAsType(int) + carry) ;
     str := str+((sum mod 10 + '0')->oclAsType(String)) ; 
     carry := sum / 10 )  ;     i := i + 1 ) ; 
        var i : int ; i := n1 ; while i < n2 do ( (     var sum : int ; sum := ((str2->at(i+1) - ('0')->char2byte())->oclAsType(int) + carry) ;
     str := str+((sum mod 10 + '0')->oclAsType(String)) ; 
     carry := sum / 10 )  ;     i := i + 1 ) ; 
    if (carry > 0) then     str := str+((carry + '0')->oclAsType(String)) ; else skip ; 
    str := StringLib.newString(str)->reverse()+"" ; 
    return str 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "12" ;
     var str2 : String ; str2 := "198111" ;
     OclFile["System.out"].println(findSum(str1, str2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findPhoneNumber(int n){
    int temp=n ;
    int sum=0 ;
    while(temp!=0){
      sum+=temp % 10 ;
      temp=temp/10 ;
    }
    if(sum<10)System.out.print(n+"0"+sum);
    else System.out.print(n+""+sum);
  }
  public static void main(String[] args){
    int n=98765432 ;
    findPhoneNumber(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findPhoneNumber( n : int) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := n ;
     var sum : int ; sum := 0 ;
     while (temp /= 0) do (     sum := sum+(temp mod 10) ; 
     temp := temp / 10 ) ; 
     if (sum < 10) then     OclFile["System.out"].print(n + "0" + sum) ; else     OclFile["System.out"].print(n + "" + sum) ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 98765432 ;
     execute findPhoneNumber(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  void sum(int[] arr,int n){
    int i=n ;
    if(arr[i]<9){
      arr[i]=arr[i]+1 ;
      return ;
    }
    arr[i]=0 ;
    i--;
    sum(arr,i);
    if(arr[0]>0)System.out.print(arr[0]+",");
    for(i=1 ; i<=n ; i++){
      System.out.print(arr[i]);
      if(i<n)System.out.print(",");
    }
  }
  static public void main(String[] args){
    GFG obj=new GFG();
    int n=4 ;
    int[] arr={
      0,1,9,3,9 };
      obj.sum(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
   operation sum( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := n ;
     if (arr[i+1] < 9) then (     arr[i+1] := arr[i+1] + 1 ; 
     return ) else skip ; 
    arr[i+1] := 0 ; 
    i := i - 1 ; 
    execute sum(arr, i) ; 
    if (arr[0+1] > 0) then     OclFile["System.out"].print(arr[0+1] + ",") ; else skip ; 
        i := 1 ; while i <= n do ( (     OclFile["System.out"].print(arr[i+1]) ; 
     if (i < n) then     OclFile["System.out"].print(",") ; else skip )  ;     i := i + 1 ) ; 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : GFG ; obj := GFG.newGFG() ;
     var n : int ; n := 4 ;
     var arr : Sequence(int) ; arr := Sequence{0,1,9,3,9} ;
     obj.sum(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int X=sc.nextInt();
    int Y=sc.nextInt();
    int Z=sc.nextInt();
    System.out.println(Z+" "+X+" "+Y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : int ; X := sc.getCurrent()->toInteger() ;
    var Y : int ; Y := sc.getCurrent()->toInteger() ;
    var Z : int ; Z := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(Z + " " + X + " " + Y) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAX=256 ;
  static int countPairs(String s){
    int cnt[]=new int[MAX];
    for(int i=0 ; i<s.length(); i++)cnt[s.charAt(i)]++;
    int ans=0 ;
    for(int i=0 ; i<MAX ; i++)ans+=cnt[i]*cnt[i];
    return ans ;
  }
  public static void main(String[] args){
    String s="geeksforgeeks" ;
    System.out.println(countPairs(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 256;
  static   operation countPairs( s : String) : int
  pre: true
  post: true
  activity: (     var cnt : Sequence(int) ; cnt := Integer.subrange(1,MAX)->collect(0) ;
         var i : int ; i := 0 ; while i < s->size() do (     cnt[s->at(i+1)+1] := cnt[s->at(i+1)+1] + 1 ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < MAX do (     ans := ans+(cnt[i+1] * cnt[i+1]) ;  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     OclFile["System.out"].println(countPairs(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int length=100 ;
    StringBuilder sb=new StringBuilder();
    sb.append(length).append(" ").append(length).append("\n");
    for(int i=0 ; i<length/2 ; i++){
      char[] line=new char[length];
      Arrays.fill(line,'#');
      if(i % 2==0){
        for(int j=0 ; j<length && a>1 ; j++){
          if(j % 2==0){
            line[j]='.' ;
            a--;
          }
        }
      }
      sb.append(new String(line)).append("\n");
    }
    for(int i=length/2 ; i<length ; i++){
      char[] line=new char[length];
      Arrays.fill(line,'.');
      if(i % 2==1){
        for(int j=0 ; j<length && b>1 ; j++){
          if(j % 2==0){
            line[j]='#' ;
            b--;
          }
        }
      }
      sb.append(new String(line)).append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var length : int ; length := 100 ;
    var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString(length) + StringLib.newString(" ") + StringLib.newString(length) + StringLib.newString("\n") ; 
        var i : int ; i := 0 ; while i < length / 2 do ( (     var line : Sequence(String) ; line := Integer.subrange(1,length)->collect(0) ;
     line := line->collect('#') ; 
     if (i mod 2 = 0) then (         var j : int ; j := 0 ; while j < length & a > 1 do ( (     if (j mod 2 = 0) then (     line[j+1] := '.' ; 
     a := a - 1 ) else skip )  ;     j := j + 1 ) ) else skip ; 
     sb := sb + StringLib.newString(StringLib.newString(line)) + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
        var i : int ; i := length / 2 ; while i < length do ( (     var line : Sequence(String) ; line := Integer.subrange(1,length)->collect(0) ;
     line := line->collect('.') ; 
     if (i mod 2 = 1) then (         var j : int ; j := 0 ; while j < length & b > 1 do ( (     if (j mod 2 = 0) then (     line[j+1] := '#' ; 
     b := b - 1 ) else skip )  ;     j := j + 1 ) ) else skip ; 
     sb := sb + StringLib.newString(StringLib.newString(line)) + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
public class ProblemC extends CodeJammer {
  public void print(boolean[][] g,int l){
    for(int i=0 ; i<l ; i++){
      String s="" ;
      for(int j=0 ; j<l ; j++){
        if(g[i][j]){
          s+="1" ;
        }
        else {
          s+="0" ;
        }
      }
      System.out.println(s);
    }
  }
  @ Override public void process()throws IOException {
    int r=reader.readInt();
    boolean[][] g=new boolean[101][101];
    for(int i=0 ; i<101 ; i++){
      for(int j=0 ; j<101 ; j++){
        g[i][j]=false ;
      }
    }
    for(int n=0 ; n<r ; n++){
      int[] data=reader.readArray();
      for(int i=data[0]; i<=data[2]; i++){
        for(int j=data[1]; j<=data[3]; j++){
          g[i][j]=true ;
        }
      }
    }
    long alive=1 ;
    int turns=0 ;
    while(alive>0){
      alive=0 ;
      for(int s=200 ; s>=0 ; s--){
        for(int i=0 ; i<=s && i<=100 ; i++){
          int j=s-i ;
          if(j>=0 && j<=100){
            int neighs=0 ;
            if(i>0 && g[i-1][j])neighs++;
            if(j>0 && g[i][j-1])neighs++;
            if(neighs==0)g[i][j]=false ;
            if(neighs==2)g[i][j]=true ;
            if(g[i][j])alive++;
          }
        }
      }
      turns++;
    }
    output(turns);
  }
  public static void main(String[] args){
    ProblemC p=new ProblemC();
    p.run(args);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemC extends CodeJammer {
   operation print( g : Sequence(Sequence(boolean)), l : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < l do ( (     var s : String ; s := "" ;
         var j : int ; j := 0 ; while j < l do ( (     if (g[i+1][j+1]) then (     s := s+("1") ) else (     s := s+("0") ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(s) )  ;     i := i + 1 ) );
      operation process() : void
  pre: true
  post: true
  activity: (     var r : int ; r := reader.readInt() ;
     var g : Sequence(Sequence(boolean)) ; g := Integer.subrange(1,101)->collect(Integer.subrange(1,101)->collect(false)) ;
        var i : int ; i := 0 ; while i < 101 do ( (         var j : int ; j := 0 ; while j < 101 do ( (     g[i+1][j+1] := false )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var n : int ; n := 0 ; while n < r do ( (     var data : Sequence(int) ; data := reader.readArray() ;
         var i : int ; i := data[0+1] ; while i <= data[2+1] do ( (         var j : int ; j := data[1+1] ; while j <= data[3+1] do ( (     g[i+1][j+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     n := n + 1 ) ; 
    var alive : long ; alive := 1 ;
    var turns : int ; turns := 0 ;
    while (alive > 0) do (     alive := 0 ; 
         var s : int ; s := 200 ; while s >= 0 do ( (         var i : int ; i := 0 ; while i <= s & i <= 100 do ( (     var j : int ; j := (s)->char2byte() - i ;
     if (j >= 0 & j <= 100) then (     var neighs : int ; neighs := 0 ;
     if (i > 0 & g[i - 1+1][j+1]) then     neighs := neighs + 1 ; else skip ; 
    if (j > 0 & g[i+1][(j)->char2byte() - 1+1]) then     neighs := neighs + 1 ; else skip ; 
    if (neighs = 0) then     g[i+1][j+1] := false ; else skip ; 
    if (neighs = 2) then     g[i+1][j+1] := true ; else skip ; 
    if (g[i+1][j+1]) then     alive := alive + 1 ; else skip ; 
 ) else skip )  ;     i := i + 1 ) )  ;     s := s - 1 ) ; 
     turns := turns + 1 ) ; 
    execute output(turns) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : ProblemC ; p := ProblemC.newProblemC() ;
     p.run(args) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class x {
  public static void main(String args[])throws Exception {
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int tt=1 ; tt<=t ; tt++){
      boolean[][] z=new boolean[101][101];
      int r=in.nextInt(),cnt=0 ;
      for(int i=0 ; i<r ; i++){
        int x1=in.nextInt(),y1=in.nextInt(),x2=in.nextInt(),y2=in.nextInt();
        for(int a=x1 ; a<=x2 ; a++)for(int b=y1 ; b<=y2 ; b++){
          if(! z[a][b])++cnt ;
          z[a][b]=true ;
        }
      }
      int s ;
      for(s=1 ; ; s++){
        for(int i=100 ; i>=1 ; i--)for(int j=100 ; j>=1 ; j--){
          if(z[i-1][j] && z[i][j-1] && ! z[i][j]){
            z[i][j]=true ;
++cnt ;
          }
          if(! z[i-1][j] && ! z[i][j-1] && z[i][j]){
            z[i][j]=false ;
--cnt ;
          }
        }
        if(cnt==0)break ;
      }
      System.out.println("Case #"+tt+": "+s);
    };
  };
};
------------------------------------------------------------
OCL File:
---------
 class x {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var tt : int ; tt := 1 ; while tt <= t do ( (     var z : Sequence(Sequence(boolean)) ; z := Integer.subrange(1,101)->collect(Integer.subrange(1,101)->collect(false)) ;
     var r : int ; r := in.getCurrent()->toInteger() ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < r do ( (     var x1 : int ; x1 := in.getCurrent()->toInteger() ;
    var y1 : int ; y1 := in.getCurrent()->toInteger() ;
    var x2 : int ; x2 := in.getCurrent()->toInteger() ;
    var y2 : int ; y2 := in.getCurrent()->toInteger() ;
         var a : int ; a := x1 ; while a <= x2 do (         var b : int ; b := y1 ; while b <= y2 do ( (     if (not(z[a+1][b+1])) then     cnt := cnt + 1 ; else skip ; 
     z[a+1][b+1] := true )  ;     b := b + 1 ) ;  ;     a := a + 1 ) )  ;     i := i + 1 ) ; 
    var s : int ;
        s := 1 ; while true do ( (         var i : int ; i := 100 ; while i >= 1 do (         var j : int ; j := 100 ; while j >= 1 do ( (     if (z[i - 1+1][j+1] & z[i+1][j - 1+1] & not(z[i+1][j+1])) then (     z[i+1][j+1] := true ; 
     cnt := cnt + 1 ) else skip ; 
     if (not(z[i - 1+1][j+1]) & not(z[i+1][j - 1+1]) & z[i+1][j+1]) then (     z[i+1][j+1] := false ; 
     cnt := cnt - 1 ) else skip )  ;     j := j - 1 ) ;  ;     i := i - 1 ) ; 
     if (cnt = 0) then     break else skip )  ;     s := s + 1 ) ; 
    OclFile["System.out"].println("Case #" + tt + ": " + s) ; 
 )  ;     tt := tt + 1 ) ; 
  );
}
;

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Bacteria {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int T=sc.nextInt();
    for(int i=1 ; i<=T ; i++){
      System.out.println("Case #"+i+": "+solveCase());
    }
  }
  static int solveCase(){
    boolean[][] grid=new boolean[300][300];
    boolean[][] temp=new boolean[300][300];
    int R=sc.nextInt();
    for(int i=0 ; i<R ; i++){
      int x1=sc.nextInt(),y1=sc.nextInt();
      int x2=sc.nextInt(),y2=sc.nextInt();
      x1--;
      x2--;
      y1--;
      y2--;
      for(int x=x1 ; x<=x2 ; x++)for(int y=y1 ; y<=y2 ; y++)grid[y][x]=true ;
    }
    int res=0 ;
    while(true){
      boolean alive=false ;
      for(int i=0 ; i<grid.length ; i++)for(int j=0 ; j<grid[i] .length ; j++)alive |=grid[i][j];
      if(! alive)break ;
      for(boolean[] arr : temp)Arrays.fill(arr,false);
      for(int i=0 ; i<grid.length ; i++){
        for(int j=0 ; j<grid[i] .length ; j++){
          boolean north=i>0 && grid[i-1][j];
          boolean west=j>0 && grid[i][j-1];
          temp[i][j]=(grid[i][j] &&(north || west))||(north && west);
        }
      }
      boolean[][] t=temp ;
      temp=grid ;
      grid=t ;
      res++;
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Bacteria {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= T do ( (     OclFile["System.out"].println("Case #" + i + ": " + solveCase()) )  ;     i := i + 1 ) );
  static   operation solveCase() : int
  pre: true
  post: true
  activity: (     var grid : Sequence(Sequence(boolean)) ; grid := Integer.subrange(1,300)->collect(Integer.subrange(1,300)->collect(false)) ;
     var temp : Sequence(Sequence(boolean)) ; temp := Integer.subrange(1,300)->collect(Integer.subrange(1,300)->collect(false)) ;
    var R : int ; R := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < R do ( (     var x1 : int ; x1 := sc.getCurrent()->toInteger() ;
    var y1 : int ; y1 := sc.getCurrent()->toInteger() ;
     var x2 : int ; x2 := sc.getCurrent()->toInteger() ;
    var y2 : int ; y2 := sc.getCurrent()->toInteger() ;
    x1 := x1 - 1 ; 
    x2 := x2 - 1 ; 
    y1 := y1 - 1 ; 
    y2 := y2 - 1 ; 
        var x : int ; x := x1 ; while x <= x2 do (         var y : int ; y := y1 ; while y <= y2 do (     grid[y+1][x+1] := true ;  ;     y := y + 1 ) ;  ;     x := x + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    while (true) do (     var alive : boolean ; alive := false ;
         var i : int ; i := 0 ; while i < grid->size() do (         var j : int ; j := 0 ; while j < grid[i+1]->size() do (     alive := MathLib.bitwiseOr(alive, grid[i+1][j+1]) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    if (not(alive)) then     break else skip ; 
    for (arr : temp) do (     arr := arr->collect(false) ;  ) ; 
        var i : int ; i := 0 ; while i < grid->size() do ( (         var j : int ; j := 0 ; while j < grid[i+1]->size() do ( (     var north : boolean ; north := i > 0 & grid[i - 1+1][j+1] ;
     var west : boolean ; west := j > 0 & grid[i+1][j - 1+1] ;
     temp[i+1][j+1] := (grid[i+1][j+1] & (north or west)) or (north & west) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var t : Sequence(Sequence(boolean)) ; t := temp ;
    temp := grid ; 
    grid := t ; 
    res := res + 1 ; 
 ) ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Scanner ;
public class C {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(new File("C-small-attempt0.in"));
    PrintWriter out=new PrintWriter("c.out");
    int C=in.nextInt();
    for(int c=1 ; c<=C ; c++){
      int R=in.nextInt();
      boolean[][] gr=new boolean[110][110];
      int k=0 ;
      for(int i=0 ; i<R ; i++){
        int x1=in.nextInt();
        int y1=in.nextInt();
        int x2=in.nextInt();
        int y2=in.nextInt();
        for(int x=x1 ; x<=x2 ; x++){
          for(int y=y1 ; y<=y2 ; y++){
            if(! gr[x][y])k++;
            gr[x][y]=true ;
          }
        }
      }
      int t=0 ;
      boolean[][] gr2=new boolean[110][110],tt ;
      while(k>0){
        for(int x=0 ; x<gr.length ; x++){
          for(int y=0 ; y<gr[0] .length ; y++){
            if(x==0 || y==0)gr2[x][y]=false ;
            else {
              gr2[x][y]=gr[x][y] &&(gr[x-1][y] || gr[x][y-1])|| ! gr[x][y] && gr[x-1][y] && gr[x][y-1];
            }
            if(gr2[x][y] && ! gr[x][y])k++;
            if(! gr2[x][y] && gr[x][y])k--;
          }
        }
        tt=gr ;
        gr=gr2 ;
        gr2=tt ;
        t++;
      }
      out.println("Case #"+c+": "+t);
    }
    in.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("C-small-attempt0.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("c.out")) ;
    var C : int ; C := in.getCurrent()->toInteger() ;
        var c : int ; c := 1 ; while c <= C do ( (     var R : int ; R := in.getCurrent()->toInteger() ;
     var gr : Sequence(Sequence(boolean)) ; gr := Integer.subrange(1,110)->collect(Integer.subrange(1,110)->collect(false)) ;
    var k : int ; k := 0 ;
        var i : int ; i := 0 ; while i < R do ( (     var x1 : int ; x1 := in.getCurrent()->toInteger() ;
     var y1 : int ; y1 := in.getCurrent()->toInteger() ;
    var x2 : int ; x2 := in.getCurrent()->toInteger() ;
    var y2 : int ; y2 := in.getCurrent()->toInteger() ;
        var x : int ; x := x1 ; while x <= x2 do ( (         var y : int ; y := y1 ; while y <= y2 do ( (     if (not(gr[x+1][y+1])) then     k := k + 1 ; else skip ; 
     gr[x+1][y+1] := true )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    var t : int ; t := 0 ;
    var gr2 : Sequence(Sequence(boolean)) ; gr2 := Integer.subrange(1,110)->collect(Integer.subrange(1,110)->collect(false)) ;
    var tt : Sequence(Sequence(boolean)) ;
    while (k > 0) do (         var x : int ; x := 0 ; while x < gr->size() do ( (         var y : int ; y := 0 ; while y < gr[0+1]->size() do ( (     if (x = 0 or y = 0) then     gr2[x+1][y+1] := false else (     gr2[x+1][y+1] := gr[x+1][y+1] & (gr[x - 1+1][y+1] or gr[x+1][y - 1+1]) or not(gr[x+1][y+1]) & gr[x - 1+1][y+1] & gr[x+1][y - 1+1] ) ;  
     if (gr2[x+1][y+1] & not(gr[x+1][y+1])) then     k := k + 1 ; else skip ; 
     if (not(gr2[x+1][y+1]) & gr[x+1][y+1]) then     k := k - 1 ; else skip )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
     tt := gr ; 
    gr := gr2 ; 
    gr2 := tt ; 
    t := t + 1 ; 
 ) ; 
    skip ; 
 )  ;     c := c + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.HashSet ;
import java.util.Set ;
public class PhoenixAndBeauty {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t!=0){
      solve(br,pr);
      t--;
    }
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    String[] temp=br.readLine().split(" ");
    int n=Integer.parseInt(temp[0]);
    int k=Integer.parseInt(temp[1]);
    Set<Integer>set=new HashSet<>();
    temp=br.readLine().split(" ");
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=Integer.parseInt(temp[i]);
      set.add(nums[i]);
    }
    if(set.size()>k){
      pr.println(-1);
      return ;
    }
    int maxGroup=0 ;
    for(int i=1 ; i<=10000 ; i++){
      if(i*k<=10000){
        maxGroup=i ;
      }
      else {
        break ;
      }
    }
    int[] res=new int[maxGroup*k];
    int index=0 ;
    for(int i : set){
      res[index]=i ;
      index++;
    }
    while(index<k){
      res[index]=nums[0];
      index++;
    }
    for(int i=k ; i<res.length ; i++){
      res[i]=res[i-k];
    }
    pr.println(res.length);
    for(int i : res){
      pr.print(i+" ");
    }
    pr.print('\n');
  }
}
------------------------------------------------------------
OCL File:
---------
 class PhoenixAndBeauty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
    while (t /= 0) do (     execute solve(br, pr) ; 
     t := t - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
     var n : int ; n := (temp[0+1])->toInteger() ;
    var k : int ; k := (temp[1+1])->toInteger() ;
    var set : Set(int) ; set := Set{} ;
    temp := br.readLine()->split(" ") ; 
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := (temp[i+1])->toInteger() ; 
     set := set->including(nums[i+1]) )  ;     i := i + 1 ) ; 
    if (set->size() > k) then (     skip ; 
     return ) else skip ; 
    var maxGroup : int ; maxGroup := 0 ;
        var i : int ; i := 1 ; while i <= 10000 do ( (     if (i * k <= 10000) then (     maxGroup := i ) else (     break ) )  ;     i := i + 1 ) ; 
    var res : Sequence(int) ; res := Integer.subrange(1,maxGroup * k)->collect(0) ;
    var index : int ; index := 0 ;
    for (i : set) do ( (     res[index+1] := i ; 
     index := index + 1 )  ) ; 
    while (index < k) do (     res[index+1] := nums[0+1] ; 
     index := index + 1 ) ; 
        var i : int ; i := k ; while i < res->size() do ( (     res[i+1] := res[i - k+1] )  ;     i := i + 1 ) ; 
    skip ; 
    for (i : res) do ( (     skip )  ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int p=scan.nextInt();
    int[] e=new int[n];
    for(int i=0 ; i<n ; i++){
      e[i]=scan.nextInt();
    }
    double l=0 ;
    double h=1000 ;
    double t=1e-9 ;
    while(h-l>t){
      double mid=l+(h-l)/2 ;
      if(can(mid,e,p)){
        l=mid ;
      }
      else {
        h=mid ;
      }
    }
    System.out.println(h);
  }
  private static boolean can(double mid,int[] e,int p){
    double excess=0 ;
    double def=0 ;
    for(int i : e){
      excess+=Math.max(i-mid,0);
      def+=Math.max(mid-i,0);
    }
    double t=excess-((excess*p)/100);
    return t>=def ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var p : int ; p := scan.getCurrent()->toInteger() ;
    var e : Sequence(int) ; e := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     e[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var l : double ; l := 0 ;
    var h : double ; h := 1000 ;
    var t : double ; t := 1e-9 ;
    while (h - l > t) do (     var mid : double ; mid := l + (h - l) / 2 ;
     if (can(mid, e, p)) then (     l := mid ) else (     h := mid ) ) ; 
    OclFile["System.out"].println(h) ; 
 );
  static   operation can( mid : double, e : Sequence(int), p : int) : boolean
  pre: true
  post: true
  activity: (     var excess : double ; excess := 0 ;
     var def : double ; def := 0 ;
    for (i : e) do ( (     excess := excess+(Set{i - mid, 0}->max()) ; 
     def := def+(Set{mid - i, 0}->max()) )  ) ; 
    var t : double ; t := excess - ((excess * p) / 100) ;
    return t >= def 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static double getResidues(int[] energies,double sol,int k){
    double totalResidues=0 ;
    double actualUnits=0 ;
    for(int energy : energies){
      totalResidues+=(energy<sol ? sol-energy : 0);
      actualUnits+=(energy>sol ? energy-sol : 0);
    }
    return totalResidues/(1-k/100.0)-actualUnits ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] energies=new int[n];
    for(int i=0 ; i<n ; i++){
      energies[i]=sc.nextInt();
    }
    double l=0 ;
    double r=1000 ;
    double mid=0 ;
    double residues ;
    while(l<r){
      mid=(l+r)/2.0 ;
      residues=getResidues(energies,mid,k);
      if(Math.abs(residues)<1e-6){
        break ;
      }
      else if(residues>1e-6){
        r=mid ;
      }
      else {
        l=mid ;
      }
    }
    System.out.println(mid);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation getResidues( energies : Sequence(int), sol : double, k : int) : double
  pre: true
  post: true
  activity: (     var totalResidues : double ; totalResidues := 0 ;
     var actualUnits : double ; actualUnits := 0 ;
     for (energy : energies) do ( (     totalResidues := totalResidues+((if energy < sol then sol - energy else 0 endif)) ; 
     actualUnits := actualUnits+((if energy > sol then energy - sol else 0 endif)) )  ) ; 
     return totalResidues / (1 - k / 100.0) - actualUnits );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var energies : Sequence(int) ; energies := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     energies[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var l : double ; l := 0 ;
    var r : double ; r := 1000 ;
    var mid : double ; mid := 0 ;
    var residues : double ;
    while (l < r) do (     mid := (l + r) / 2.0 ; 
     residues := getResidues(energies, mid, k) ; 
     if (if residues < 0 then -(residues) else residues endif < 1e-6) then (     break ) else     if (residues > 1e-6) then (     r := mid ) else (     l := mid ) ;  ) ; 
    OclFile["System.out"].println(mid) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int modInverse(int a,int prime){
    a=a % prime ;
    for(int x=1 ; x<prime ; x++)if((a*x)% prime==1)return x ;
    return-1 ;
  }
  static void printModIverses(int n,int prime){
    for(int i=1 ; i<=n ; i++)System.out.print(modInverse(i,prime)+" ");
  }
  public static void main(String args[]){
    int n=10,prime=17 ;
    printModIverses(n,prime);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation modInverse( a : int, prime : int) : int
  pre: true
  post: true
  activity: (     a := a mod prime ; 
         var x : int ; x := 1 ; while x < prime do (     if ((a * x) mod prime = 1) then     return x else skip ;  ;     x := x + 1 ) ; 
     return -1 );
  static   operation printModIverses( n : int, prime : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= n do (     OclFile["System.out"].print(modInverse(i, prime) + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
    var prime : int ; prime := 17 ;
     execute printModIverses(n, prime) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static long kBitDifferencePairs(int arr[],int n,int k){
    int MAX=Arrays.stream(arr).max().getAsInt();
    long[] count=new long[MAX+1];
    Arrays.fill(count,0);
    for(int i=0 ; i<n ; ++i)++count[arr[i] ];
    long ans=0 ;
    if(k==0){
      for(int i=0 ; i<=MAX ; ++i)ans+=(count[i]*(count[i]-1))/2 ;
      return ans ;
    }
    for(int i=0 ; i<=MAX ; ++i){
      if(count[i]==0)continue ;
      for(int j=i+1 ; j<=MAX ; ++j){
        if(Integer.bitCount(i ^ j)==k)ans+=count[i]*count[j];
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int k=2 ;
    int arr[]={
      2,4,1,3,1 };
      int n=arr.length ;
      System.out.println("Total pairs for k="+k+" are="+kBitDifferencePairs(arr,n,k));
      k=3 ;
      System.out.println("Total pairs for k="+k+" are="+kBitDifferencePairs(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation kBitDifferencePairs( arr : Sequence(int), n : int, k : int) : long
  pre: true
  post: true
  activity: (     var MAX : int ; MAX := stream(arr).max().getAsInt() ;
     var count : Sequence(long) ; count := Integer.subrange(1,MAX + 1)->collect(0) ;
    count := count->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     count[arr[i+1]+1] := count[arr[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    if (k = 0) then (         var i : int ; i := 0 ; while i <= MAX do (     ans := ans+((count[i+1] * (count[i+1] - 1)) / 2) ;  ;     i := i + 1 ) ; 
     return ans ) else skip ; 
        var i : int ; i := 0 ; while i <= MAX do ( (     if (count[i+1] = 0) then     continue else skip ; 
         var j : int ; j := i + 1 ; while j <= MAX do ( (     if (bitCount(MathLib.bitwiseXor(i,j)) = k) then     ans := ans+(count[i+1] * count[j+1]) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 2 ;
     var arr : Sequence(int) ; arr := Sequence{2,4,1,3,1} ;
    var n : int ; n := arr->size() ;
    OclFile["System.out"].println("Total pairs for k=" + k + " are=" + kBitDifferencePairs(arr, n, k)) ; 
    k := 3 ; 
    OclFile["System.out"].println("Total pairs for k=" + k + " are=" + kBitDifferencePairs(arr, n, k)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static void calcFiboTerms(ArrayList<Integer>fiboterms,int k){
    int i=3,nextTerm=0 ;
    fiboterms.add(0);
    fiboterms.add(1);
    fiboterms.add(1);
    while(true){
      nextTerm=fiboterms.get(i-1)+fiboterms.get(i-2);
      if(nextTerm>k)return ;
      fiboterms.add(nextTerm);
      i++;
    }
  }
  public static int fibMinTerms(int k){
    ArrayList<Integer>fiboterms=new ArrayList<Integer>();
    calcFiboTerms(fiboterms,k);
    int count=0,j=fiboterms.size()-1 ;
    while(k>0){
      count+=(k/fiboterms.get(j));
      k %=(fiboterms.get(j));
      j--;
    }
    return count ;
  }
  public static void main(String[] args){
    int k=17 ;
    System.out.println(fibMinTerms(k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calcFiboTerms( fiboterms : Sequence(int), k : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 3 ;
    var nextTerm : int ; nextTerm := 0 ;
     fiboterms->excludes(0) ; 
    fiboterms->excludes(1) ; 
    fiboterms->excludes(1) ; 
    while (true) do (     nextTerm := fiboterms->at(i - 1+1) + fiboterms->at(i - 2+1) ; 
     if (nextTerm > k) then     return else skip ; 
     fiboterms->excludes(nextTerm) ; 
     i := i + 1 ) ; 
 );
  static   operation fibMinTerms( k : int) : int
  pre: true
  post: true
  activity: (     var fiboterms : Sequence(int) ; fiboterms := Sequence{} ;
     execute calcFiboTerms(fiboterms, k) ; 
    var count : int ; count := 0 ;
    var j : int ; j := fiboterms->size() - 1 ;
    while (k > 0) do (     count := count+((k / fiboterms->at(j+1))) ; 
     k := k mod (fiboterms->at(j+1)) ; 
     j := j - 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 17 ;
     OclFile["System.out"].println(fibMinTerms(k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    int b=in.nextInt();
    StringBuilder sb=new StringBuilder();
    String ls=System.lineSeparator();
    int numA=0 ;
    int numB=0 ;
    int h=0 ;
    int w=100 ;
    while(numA<a-50){
      sb.append(".#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#");
      sb.append(ls);
      sb.append("####################################################################################################");
      sb.append(ls);
      h+=2 ;
      numA+=50 ;
    }
    if((a-1)% 50!=0){
      while(numA<a-1){
        sb.append(".#");
        numA++;
      }
      while(numA % 50!=0){
        sb.append("##");
        numA++;
      }
      sb.append(ls);
      h++;
    }
    sb.append("####################################################################################################");
    sb.append(ls);
    sb.append("....................................................................................................");
    sb.append(ls);
    h+=2 ;
    while(numB<b-50){
      sb.append(".#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#");
      sb.append(ls);
      sb.append("....................................................................................................");
      sb.append(ls);
      h+=2 ;
      numB+=50 ;
    }
    if((b-1)% 50!=0){
      while(numB<b-1){
        sb.append(".#");
        numB++;
      }
      while(numB % 50!=0){
        sb.append("..");
        numB++;
      }
      sb.append(ls);
      h++;
    }
    System.out.println(h+" "+w);
    System.out.println(sb.toString());
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
    var ls : String ; ls := lineSeparator() ;
    var numA : int ; numA := 0 ;
    var numB : int ; numB := 0 ;
    var h : int ; h := 0 ;
    var w : int ; w := 100 ;
    while (numA < a - 50) do (     sb := sb + StringLib.newString(".#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#") ; 
     sb := sb + StringLib.newString(ls) ; 
    sb := sb + StringLib.newString("####################################################################################################") ; 
    sb := sb + StringLib.newString(ls) ; 
    h := h+(2) ; 
    numA := numA+(50) ; 
 ) ; 
    if ((a - 1) mod 50 /= 0) then (     while (numA < a - 1) do (     sb := sb + StringLib.newString(".#") ; 
     numA := numA + 1 ) ; 
     while (numA mod 50 /= 0) do (     sb := sb + StringLib.newString("##") ; 
     numA := numA + 1 ) ; 
     sb := sb + StringLib.newString(ls) ; 
     h := h + 1 ) else skip ; 
    sb := sb + StringLib.newString("####################################################################################################") ; 
    sb := sb + StringLib.newString(ls) ; 
    sb := sb + StringLib.newString("....................................................................................................") ; 
    sb := sb + StringLib.newString(ls) ; 
    h := h+(2) ; 
    while (numB < b - 50) do (     sb := sb + StringLib.newString(".#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#") ; 
     sb := sb + StringLib.newString(ls) ; 
    sb := sb + StringLib.newString("....................................................................................................") ; 
    sb := sb + StringLib.newString(ls) ; 
    h := h+(2) ; 
    numB := numB+(50) ; 
 ) ; 
    if ((b - 1) mod 50 /= 0) then (     while (numB < b - 1) do (     sb := sb + StringLib.newString(".#") ; 
     numB := numB + 1 ) ; 
     while (numB mod 50 /= 0) do (     sb := sb + StringLib.newString("..") ; 
     numB := numB + 1 ) ; 
     sb := sb + StringLib.newString(ls) ; 
     h := h + 1 ) else skip ; 
    OclFile["System.out"].println(h + " " + w) ; 
    OclFile["System.out"].println(sb+"") ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  static BufferedReader br ;
  static PrintWriter out ;
  static StringTokenizer st ;
  public static void main(String[] args)throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(new OutputStreamWriter(System.out));
    int a=nextInt();
    int b=nextInt();
    int c=nextInt();
    System.out.printf("%d %d %d\n",c,a,b);
    out.close();
  }
  static String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine().trim());
    return st.nextToken();
  }
  static long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  static char nextCharacter()throws IOException {
    return next().charAt(0);
  }
  static String nextLine()throws IOException {
    return br.readLine().trim();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile;
  static   attribute out : OclFile;
  static   attribute st : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var a : int ; a := nextInt() ;
    var b : int ; b := nextInt() ;
    var c : int ; c := nextInt() ;
    OclFile["System.out"].printf("%d %d %d\n", c, a, b) ; 
    skip ; 
 );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()->trim()) ; ; 
     return st.next() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextCharacter() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine()->trim() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isWordPresent(String sentence,String word){
    String[] s=sentence.split(" ");
    for(String temp : s){
      if(temp.compareTo(word)==0){
        return true ;
      }
    }
    return false ;
  }
  public static void main(String[] args){
    String s="Geeks for Geeks" ;
    String word="Geeks" ;
    if(isWordPresent(s,word))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isWordPresent( sentence : String, word : String) : boolean
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := sentence->split(" ") ;
     for (temp : s) do ( (     if (temp->compareTo(word) = 0) then (     return true ) else skip )  ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "Geeks for Geeks" ;
     var word : String ; word := "Geeks" ;
     if (isWordPresent(s, word)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int sumNatural(int n){
    int sum=(n*(n+1));
    return sum ;
  }
  static int sumEven(int l,int r){
    return sumNatural(r/2)-sumNatural((l-1)/2);
  }
  public static void main(String[] args){
    int l=2,r=5 ;
    System.out.println("Sum of Natural numbers from L to R is "+sumEven(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumNatural( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := (n * (n + 1)) ;
     return sum );
  static   operation sumEven( l : int, r : int) : int
  pre: true
  post: true
  activity: (     return sumNatural(r / 2) - sumNatural((l - 1) / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 2 ;
    var r : int ; r := 5 ;
     OclFile["System.out"].println("Sum of Natural numbers from L to R is " + sumEven(l, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sumNatural(int n){
    int sum=(n*(n+1))/2 ;
    return sum ;
  }
  static int suminRange(int l,int r){
    return sumNatural(r)-sumNatural(l-1);
  }
  public static void main(String[] args){
    int l=2,r=5 ;
    System.out.println("Sum of Natural numbers from L to R is "+suminRange(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumNatural( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := (n * (n + 1)) / 2 ;
     return sum );
  static   operation suminRange( l : int, r : int) : int
  pre: true
  post: true
  activity: (     return sumNatural(r) - sumNatural(l - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 2 ;
    var r : int ; r := 5 ;
     OclFile["System.out"].println("Sum of Natural numbers from L to R is " + suminRange(l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static boolean isPerfectSquare(int n){
    if(n<0)return false ;
    int root=Math.round((int)(Math.sqrt(n)));
    return n==root*root ;
  }
  static void printnonsquare(int n){
    int count=0 ;
    for(int i=1 ; count<n ; ++i){
      if(! isPerfectSquare(i)){
        System.out.print(i+" ");
        count++;
      }
    }
  }
  public static void main(String args[]){
    int n=10 ;
    printnonsquare(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPerfectSquare( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n < 0) then     return false else skip ; 
     var root : int ; root := (((n)->sqrt())->oclAsType(int))->round() ;
     return n = root * root );
  static   operation printnonsquare( n : int) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while count < n do ( (     if (not(isPerfectSquare(i))) then (     OclFile["System.out"].print(i + " ") ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     execute printnonsquare(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int Alcuin(int n){
    double _n=n,ans ;
    ans=Math.round((_n*_n)/12)-Math.floor(_n/4)*Math.floor((_n+2)/4);
    return(int)ans ;
  }
  static void solve(int n){
    int i=0 ;
    for(i=1 ; i<=n ; i++){
      System.out.print(Alcuin(i)+",");
    }
  }
  public static void main(String[] args){
    int n=15 ;
    solve(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Alcuin( n : int) : int
  pre: true
  post: true
  activity: (     var _n : double ; _n := n ;
    var ans : double ;
     ans := ((_n * _n) / 12)->round() - (_n / 4)->floor() * ((_n + 2) / 4)->floor() ; 
     return ans->oclAsType(int) );
  static   operation solve( n : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
         i := 1 ; while i <= n do ( (     OclFile["System.out"].print(Alcuin(i) + ",") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     execute solve(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int lds(int arr[],int n){
    int lds[]=new int[n];
    int i,j,max=0 ;
    for(i=0 ; i<n ; i++)lds[i]=1 ;
    for(i=1 ; i<n ; i++)for(j=0 ; j<i ; j++)if(arr[i]<arr[j] && lds[i]<lds[j]+1)lds[i]=lds[j]+1 ;
    for(i=0 ; i<n ; i++)if(max<lds[i])max=lds[i];
    return max ;
  }
  public static void main(String[] args){
    int arr[]={
      15,27,14,38,63,55,46,65,85 };
      int n=arr.length ;
      System.out.print("Length of LDS is "+lds(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation lds( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var lds : Sequence(int) ; lds := Integer.subrange(1,n)->collect(0) ;
     var i : int ;
    var j : int ;
    var max : int ; max := 0 ;
        i := 0 ; while i < n do (     lds[i+1] := 1 ;  ;     i := i + 1 ) ; 
        i := 1 ; while i < n do (         j := 0 ; while j < i do (     if (arr[i+1] < arr[j+1] & lds[i+1] < lds[j+1] + 1) then     lds[i+1] := lds[j+1] + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do (     if (max < lds[i+1]) then     max := lds[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    return max 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{15,27,14,38,63,55,46,65,85} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print("Length of LDS is " + lds(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.text.DecimalFormat ;
import java.util.ArrayList ;
class Main {
  public static void main(String[] args)throws IOException {
    DecimalFormat df1=new DecimalFormat("0.000000");
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    ArrayList<Integer>iL=new ArrayList<Integer>();
    while(true){
      String s1=new String(in.readLine());
      if(s1.equals("0")){
        break ;
      }
      int num=Integer.parseInt(s1);
      String s2=new String(in.readLine());
      String[] s2s=s2.split(" ");
      int sum=0 ;
      for(int i=0 ; i<s2s.length ; i++){
        sum=sum+Integer.parseInt(s2s[i]);
      }
      iL.add(sum/(num-1));
    }
    for(Integer i : iL){
      System.out.println(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var df1 : DecimalFormat ; df1 := DecimalFormat.newDecimalFormat("0.000000") ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var iL : Sequence(int) ; iL := Sequence{} ;
    while (true) do (     var s1 : String ; s1 := StringLib.newString(in.readLine()) ;
     if (s1 = "0") then (     break ) else skip ; 
    var num : int ; num := (s1)->toInteger() ;
    var s2 : String ; s2 := StringLib.newString(in.readLine()) ;
    var s2s : Sequence(String) ; s2s := s2->split(" ") ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < s2s->size() do ( (     sum := sum + (s2s[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    iL := iL->including(sum / ((num)->char2byte() - 1)) ; 
 ) ; 
    for (i : iL) do ( (     OclFile["System.out"].println(i) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
    try {
      while(true){
        int K=Integer.valueOf(sc.readLine());
        if(K==0)break ;
        String[] st=sc.readLine().split(" ");
        int sum=0 ;
        for(int i=0 ; i<K*(K-1)/2 ; i++)sum+=Integer.valueOf(st[i]);
        System.out.println(sum/(K-1));
      }
    }
    catch(Exception e){
      System.out.println("Error");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     while (true) do (     var K : int ; K := (sc.readLine())->toInteger() ;
     if (K = 0) then     break else skip ; 
    var st : Sequence(String) ; st := sc.readLine()->split(" ") ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < K * (K - 1) / 2 do (     sum := sum+((st[i+1])->toInteger()) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum / (K - 1)) ; 
 ) )   catch (e : ProgramException) do (     OclFile["System.out"].println("Error") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.ListIterator ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    while(true){
      final int k=sc.nextInt();
      if(k==0){
        break ;
      }
      int sum=0 ;
      for(int i=0 ; i<(k*(k-1))/2 ; i++){
        sum+=sc.nextInt();
      }
      System.out.println(k==1 ? sum : sum/(k-1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var k : int ; k := sc.getCurrent()->toInteger() ;
     if (k = 0) then (     break ) else skip ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < (k * (k - 1)) / 2 do ( (     sum := sum+(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if k = 1 then sum else sum / (k - 1) endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  private static final int K=50 ;
  private static final char WHITE='.' ;
  private static final char BLACK='#' ;
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      char[][] s=new char[2*K][2*K];
      IntStream.range(0,K).forEach(i->Arrays.fill(s[i],BLACK));
      IntStream.range(K,2*K).forEach(i->Arrays.fill(s[i],WHITE));
      fill(s,1,a-1,WHITE);
      fill(s,K+1,b-1,BLACK);
      System.out.println(2*K+" "+2*K);
      IntStream.range(0,2*K).forEach(i->System.out.println(s[i]));
    }
  }
  private static void fill(final char[][] s,int i,int count,final char koma){
    int j=1 ;
    while(count>0){
      s[i][j]=koma ;
      j+=2 ;
      count--;
      if(j>=2*K-1){
        i+=2 ;
        j=1 ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute K : int := 50;
  static    attribute WHITE : String := '.';
  static    attribute BLACK : String := '#';
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
    var s : Sequence(Sequence(String)) ; s := Integer.subrange(1,2 * K)->collect(Integer.subrange(1,2 * K)->collect(0)) ;
    for i : Integer.subrange(0, K-1) do
    (    s[i+1] := s[i+1]->collect(BLACK)) ; 
    for i : Integer.subrange(K, 2 * K-1) do
    (    s[i+1] := s[i+1]->collect(WHITE)) ; 
    execute fill(s, 1, a - 1, WHITE) ; 
    execute fill(s, K + 1, b - 1, BLACK) ; 
    OclFile["System.out"].println(2 * K + " " + 2 * K) ; 
    for i : Integer.subrange(0, 2 * K-1) do
    (    OclFile["System.out"].println(s[i+1])) ; 
 ))  );
  static   operation fill( s : Sequence(Sequence(String)), i : int, count : int, koma : String) : void
  pre: true
  post: true
  activity: (     var j : int ; j := 1 ;
     while (count > 0) do (     s[i+1][j+1] := koma ; 
     j := j+(2) ; 
     count := count - 1 ; 
     if (j >= 2 * K - 1) then (     i := i+(2) ; 
     j := 1 ) else skip ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.math.BigInteger.*;
import static java.lang.Character.*;
class AOJ1027 {
  public void run(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int K=sc.nextInt();
      if(K==0)return ;
      int sum=0 ;
      int N=K*(K-1)/2 ;
      for(int i=0 ; i<N ; i++)sum+=sc.nextInt();
      System.out.println(sum/(K-1));
    }
  }
}
public class Main {
  public static void main(String...args){
    new AOJ1027().run();
  }
  public static void debug(Object...os){
    System.err.println(java.util.Arrays.deepToString(os));
  }
}
class Scanner {
  final java.util.Scanner sc ;
  public double nextDouble(){
    return Double.parseDouble(sc.next());
  }
  public Scanner(java.io.InputStream is){
    this.sc=new java.util.Scanner(is);
  }
  public boolean hasNext(){
    return sc.hasNext();
  }
  public String next(){
    return sc.next();
  }
  public int nextInt(){
    return Integer.parseInt(sc.next());
  }
  public String nextLine(){
    return sc.nextLine();
  }
  public long nextLong(){
    return Long.parseLong(sc.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class AOJ1027 {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var K : int ; K := sc.getCurrent()->toInteger() ;
     if (K = 0) then     return else skip ; 
    var sum : int ; sum := 0 ;
    var N : int ; N := K * (K - 1) / 2 ;
        var i : int ; i := 0 ; while i < N do (     sum := sum+(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum / (K - 1)) ; 
 ) );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     AOJ1027.newAOJ1027().run() );
  static   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println(java.util.Arrays.deepToString(os)) );
}
class Scanner {
   attribute sc : Scanner;
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (sc.next())->toReal() );
   static operation newScanner( is : InputStream) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(is);
    return self );
  operation initialise( is : InputStream) : void
  pre: true  post: true
  activity: (     self.sc := Scanner.newScanner(is) );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return sc.hasNext() );
   operation next() : String
  pre: true
  post: true
  activity: (     return sc.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (sc.next())->toInteger() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return sc.nextLine() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (sc.next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long MOD=1000000007 ;
  static long dp[]=new long[1<<21];
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    out=new PrintWriter(new BufferedOutputStream(System.out));
    long MOD=1000000007 ;
    int t=1 ;
    while(t-->0){
      int a=sc.nextInt(),b=sc.nextInt(),c=sc.nextInt();
      out.println(c+" "+a+" "+b);
    }
    out.close();
  }
  public static int solve(int x,int[] a){
    int max=0,n=a.length-1 ;
    for(int i=1 ; i<=n ; i++)if(a[i]>max)max=a[i];
    return 0 ;
  }
  public static PrintWriter out ;
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : long := 1000000007;
  static   attribute dp : long := Integer.subrange(1,(1*(2->pow(21)))->oclAsType(long))->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var MOD : long ; MOD := 1000000007 ;
    var t : int ; t := 1 ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := sc.nextInt() ;
    var b : int ; b := sc.nextInt() ;
    var c : int ; c := sc.nextInt() ;
     out.println(c + " " + a + " " + b) ) ;  ) ;  
    out.close() ; 
 );
  static   operation solve( x : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var max : int ; max := 0 ;
    var n : int ; n := a->size() - 1 ;
         var i : int ; i := 1 ; while i <= n do (     if (a[i+1] > max) then     max := a[i+1] ; else skip ;  ;     i := i + 1 ) ; 
     return 0 );
  static   attribute out : OclFile;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      while(true){
        int n=Integer.parseInt(br.readLine());
        if(n==0)return ;
        String strs[]=br.readLine().split(" ");
        int num=(n*(n-1))/2 ;
        int sum=0 ;
        for(int i=0 ; i<num ; i++){
          sum+=Integer.parseInt(strs[i]);
        }
        sum=sum/(n-1);
        System.out.println(sum);
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     while (true) do (     var n : int ; n := (br.readLine())->toInteger() ;
     if (n = 0) then     return else skip ; 
    var strs : Sequence(String) ; strs := br.readLine()->split(" ") ;
    var num : int ; num := (n * (n - 1)) / 2 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < num do ( (     sum := sum+((strs[i+1])->toInteger()) )  ;     i := i + 1 ) ; 
    sum := sum / (n - 1) ; 
    OclFile["System.out"].println(sum) ; 
 ) )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Ex3 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int oo=0 ; oo<t ; oo++){
      ArrayList<Integer>arrL=new ArrayList<>();
      int x=in.nextInt();
      int arr[]=new int[x*2];
      for(int i=0 ; i<x*2 ; i++){
        arr[i]=in.nextInt();
        arrL.add(arr[i]);
      }
      int newArr[]=new int[x*2];
      for(int i=0 ; i<x*2 ; i++){
        for(int j=i+1 ; j<x*2 ; j++){
          if(arr[i]==arr[j]){
            newArr[i]=arr[j];
            break ;
          }
        }
      }
      for(int i=0 ; i<x*2 ; i++){
        if(newArr[i]!=0){
          System.out.print(newArr[i]+" ");
        }
      }
      System.out.println();
    }
  }
  public class ListNode<E>{
    private E value ;
    private ListNode next ;
    public ListNode(E newVal,ListNode<E>newNext){
      value=newVal ;
      next=newNext ;
    }
    public E getValue(){
      return value ;
    }
    public ListNode<E>getNext(){
      return next ;
    }
    public void setValue(E newValue){
      value=newValue ;
    }
    public void setNext(ListNode<E>newNext){
      next=newNext ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ex3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var oo : int ; oo := 0 ; while oo < t do ( (     var arrL : Sequence(int) ; arrL := Sequence{} ;
     var x : int ; x := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,x * 2)->collect(0) ;
        var i : int ; i := 0 ; while i < x * 2 do ( (     arr[i+1] := in.getCurrent()->toInteger() ; 
     arrL := arrL->including(arr[i+1]) )  ;     i := i + 1 ) ; 
    var newArr : Sequence(int) ; newArr := Integer.subrange(1,x * 2)->collect(0) ;
        var i : int ; i := 0 ; while i < x * 2 do ( (         var j : int ; j := i + 1 ; while j < x * 2 do ( (     if (arr[i+1] = arr[j+1]) then (     newArr[i+1] := arr[j+1] ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < x * 2 do ( (     if (newArr[i+1] /= 0) then (     OclFile["System.out"].print(newArr[i+1] + " ") ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     oo := oo + 1 ) );
 class ListNode<E> {
   attribute value : E;
   attribute next : ListNode;
   static operation newListNode( newVal : E, newNext : ListNode<E>) : ListNode
  pre: true
  post: true
  activity:
  ( var self : ListNode ;
    self := createListNode();
    self.initialise(newVal, newNext);
    return self );
  operation initialise( newVal : E, newNext : ListNode<E>) : void
  pre: true  post: true
  activity: (     value := newVal ; 
     next := newNext );
   operation getValue() : E
  pre: true
  post: true
  activity: (     return value );
   operation getNext() : ListNode<E>
  pre: true
  post: true
  activity: (     return next );
   operation setValue( newValue : E) : void
  pre: true
  post: true
  activity: (     value := newValue );
   operation setNext( newNext : ListNode<E>) : void
  pre: true
  post: true
  activity: (     next := newNext );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test160 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int a[]=new int[n];
      int l=0 ;
      for(int i=0 ; i<n*2 ; i++){
        int b=in.nextInt();
        boolean x=true ;
        for(int k=0 ; k<n ; k++){
          if(a[k]==b){
            x=false ;
            break ;
          }
        }
        if(x){
          a[l++]=b ;
        }
      }
      for(int i=0 ; i<n ; i++){
        System.out.print(a[i]+" ");
      }
      System.out.println();
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test160 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var l : int ; l := 0 ;
        var i : int ; i := 0 ; while i < n * 2 do ( (     var b : int ; b := in.getCurrent()->toInteger() ;
     var x : boolean ; x := true ;
         var k : int ; k := 0 ; while k < n do ( (     if (a[k+1] = b) then (     x := false ; 
     break ) else skip )  ;     k := k + 1 ) ; 
     if (x) then (      a[l+1] := b  ; l := l + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(a[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1385B_RestorethePermutationbyMerger {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int len=parseInt(input.nextLine());
      Set<Integer>set=new LinkedHashSet<>();
      for(int i=0 ; i<2*len ; i++){
        set.add(input.nextInt());
      }
      input.nextLine();
      System.out.println(set.toString().replaceAll("[\\[\\],] ",""));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1385B_RestorethePermutationbyMerger {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var len : int ; len := parseInt(input.nextLine()) ;
     var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < 2 * len do ( (     set := set->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(set+"".replaceAllMatches("[\\[\\],] ", "" )) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Scanner ;
public class Restore {
  int number ;
  public Restore(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  public boolean contain(int num,LinkedList<Integer>list){
    boolean b=false ;
    for(int n : list){
      if(num==n){
        b=true ;
        break ;
      }
    }
    return b ;
  }
  LinkedList<Integer>restore=new LinkedList<>();
  public void input(int num){
    if(restore.size()==0){
      restore.add(num);
    }
    else {
      if(contain(num,restore)==false){
        restore.add(num);
      }
    }
  }
  public void print(){
    for(int i=0 ; i<restore.size(); i++){
      if(i==0){
        System.out.print(restore.get(i));
      }
      else {
        System.out.print(" "+restore.get(i));
      }
    }
    System.out.println();
    restore.removeAll(restore);
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    Restore instance=new Restore(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      int num=input.nextInt();
      for(int j=0 ; j<num*2 ; j++){
        int numO=input.nextInt();
        instance.input(numO);
      }
      instance.print();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Restore {
   attribute number : int;
   static operation newRestore( number : int) : Restore
  pre: true
  post: true
  activity:
  ( var self : Restore ;
    self := createRestore();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
   operation contain( num : int, list : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var b : boolean ; b := false ;
     for (n : list) do ( (     if (num = n) then (     b := true ; 
     break ) else skip )  ) ; 
     return b );
   attribute restore : Sequence(int) := Sequence{};
   operation input( num : int) : void
  pre: true
  post: true
  activity: (     if (restore->size() = 0) then (     restore := restore->including(num) ) else (     if (contain(num, restore) = false) then (     restore := restore->including(num) ) else skip ) );
   operation print() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < restore->size() do ( (     if (i = 0) then (     OclFile["System.out"].print(restore->at(i+1)) ) else (     OclFile["System.out"].print(" " + restore->at(i+1)) ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ; 
     restore := restore - restore );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
     var instance : Restore ; instance := Restore.newRestore(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < num * 2 do ( (     var numO : int ; numO := input.getCurrent()->toInteger() ;
     instance.input(numO) )  ;     j := j + 1 ) ; 
     instance.print() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class notrepeayed {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int a=in.nextInt();
      int x[]=new int[a*2];
      for(int i=0 ; i<a*2 ; i++){
        x[i]=in.nextInt();
      }
      int r=0 ;
      for(int i=0 ; i<a*2 ; i++){
        for(int j=i+1 ; j<a*2 ; j++){
          if(x[i]==x[j]){
            x[j]=-1 ;
          }
        }
      }
      for(int i=0 ; i<a*2 ; i++){
        if(x[i]!=-1)System.out.print(x[i]+" ");
      }
      System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class notrepeayed {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := in.getCurrent()->toInteger() ;
     var x : Sequence(int) ; x := Integer.subrange(1,a * 2)->collect(0) ;
        var i : int ; i := 0 ; while i < a * 2 do ( (     x[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var r : int ; r := 0 ;
        var i : int ; i := 0 ; while i < a * 2 do ( (         var j : int ; j := i + 1 ; while j < a * 2 do ( (     if (x[i+1] = x[j+1]) then (     x[j+1] := -1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a * 2 do ( (     if (x[i+1] /= -1) then     OclFile["System.out"].print(x[i+1] + " ") ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    while(s.hasNext()){
      String str=s.nextLine();
      String[] arg=str.split(" ");
      int a=Integer.parseInt(arg[0]);
      int[] b=new int[arg.length-1];
      for(int i=0 ; i<arg.length-1 ; i++)b[i]=Integer.parseInt(arg[i+1]);
      double dp[][]=new double[4096][12];
      int n=arg.length-1 ;
      for(int i=0 ; i<4096 ; i++)for(int j=0 ; j<12 ; j++)dp[i][j]=999999999 ;
      for(int i=0 ; i<n ; i++){
        dp[1<<i][i]=b[i];
      }
      for(int i=0 ; i<(1<<n)-1 ; i++){
        for(int j=0 ; j<n ; j++){
          for(int k=0 ; k<n ; k++){
            if((i &(1<<k))==0){
              dp[i+(1<<k)][k]=Math.min(dp[i+(1<<k)][k],dp[i][j]+Math.sqrt((b[j]+b[k])*(b[j]+b[k])-(b[j]-b[k])*(b[j]-b[k])));
            }
          }
        }
      }
      boolean ok=false ;
      for(int i=0 ; i<n ; i++)if(dp[(1<<n)-1][i]+b[i]<(double)a+0.000001)ok=true ;
      if(ok)System.out.println("OK");
      else System.out.println("NA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (s.hasNext()) do (     var str : String ; str := s.nextLine() ;
     var arg : Sequence(String) ; arg := str->split(" ") ;
    var a : int ; a := (arg[0+1])->toInteger() ;
    var b : Sequence(int) ; b := Integer.subrange(1,arg->size() - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < arg->size() - 1 do (     b[i+1] := (arg[i + 1+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(double)) ; dp := Integer.subrange(1,4096)->collect(Integer.subrange(1,12)->collect(0.0)) ;
    var n : int ; n := arg->size() - 1 ;
        var i : int ; i := 0 ; while i < 4096 do (         var j : int ; j := 0 ; while j < 12 do (     dp[i+1][j+1] := 999999999 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     dp[(1*(2->pow(i)))->oclAsType(long)+1][i+1] := b[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < ((1*(2->pow(n)))->oclAsType(long)) - 1 do ( (         var j : int ; j := 0 ; while j < n do ( (         var k : int ; k := 0 ; while k < n do ( (     if ((MathLib.bitwiseAnd(i,((1*(2->pow(k)))->oclAsType(long)))) = 0) then (     dp[i + ((1*(2->pow(k)))->oclAsType(long))+1][k+1] := Set{dp[i + ((1*(2->pow(k)))->oclAsType(long))+1][k+1], dp[i+1][j+1] + ((b[j+1] + b[k+1]) * (b[j+1] + b[k+1]) - (b[j+1] - b[k+1]) * (b[j+1] - b[k+1]))->sqrt()}->min() ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ok : boolean ; ok := false ;
        var i : int ; i := 0 ; while i < n do (     if (dp[((1*(2->pow(n)))->oclAsType(long)) - 1+1][i+1] + b[i+1] < a->oclAsType(double) + 0.000001) then     ok := true ; else skip ;  ;     i := i + 1 ) ; 
    if (ok) then     OclFile["System.out"].println("OK") else     OclFile["System.out"].println("NA") ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  static double INF=10000000.0 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine())!=null){
      String[] temp=line.split(" ");
      int w=Integer.parseInt(temp[0]);
      int[] r=new int[temp.length-1];
      for(int i=0 ; i<r.length ; i++){
        r[i]=Integer.parseInt(temp[i+1]);
      }
      int n=r.length ;
      double[][] dp=new double[1<<n][n];
      for(int i=0 ; i<(1<<n); i++){
        for(int j=0 ; j<n ; j++){
          dp[i][j]=INF ;
        }
      }
      for(int i=0 ; i<n ; i++){
        dp[(1<<n)-1-(1<<i)][i]=r[i];
      }
      for(int s=(1<<n)-2 ; s>=0 ; s--){
        for(int i=0 ; i<n ; i++){
          if((s &(1<<i))!=0)continue ;
          for(int j=0 ; j<n ; j++){
            dp[s][i]=Math.min(dp[s][i],dp[s |(1<<i)][j]+2*Math.sqrt(r[i]*r[j]));
          }
        }
      }
      boolean flag=false ;
      for(int j=0 ; j<n ; j++){
        if(dp[0][j]+r[j]<=w){
          flag=true ;
        }
      }
      System.out.println((flag)? "OK" : "NA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute INF : double := 10000000.0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     var temp : Sequence(String) ; temp := line->split(" ") ;
     var w : int ; w := (temp[0+1])->toInteger() ;
    var r : Sequence(int) ; r := Integer.subrange(1,temp->size() - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < r->size() do ( (     r[i+1] := (temp[i + 1+1])->toInteger() )  ;     i := i + 1 ) ; 
    var n : int ; n := r->size() ;
    var dp : Sequence(Sequence(double)) ; dp := Integer.subrange(1,(1*(2->pow(n)))->oclAsType(long))->collect(Integer.subrange(1,n)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < ((1*(2->pow(n)))->oclAsType(long)) do ( (         var j : int ; j := 0 ; while j < n do ( (     dp[i+1][j+1] := INF )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     dp[((1*(2->pow(n)))->oclAsType(long)) - 1 - ((1*(2->pow(i)))->oclAsType(long))+1][i+1] := r[i+1] )  ;     i := i + 1 ) ; 
        var s : int ; s := ((1*(2->pow(n)))->oclAsType(long)) - 2 ; while s >= 0 do ( (         var i : int ; i := 0 ; while i < n do ( (     if ((MathLib.bitwiseAnd(s,((1*(2->pow(i)))->oclAsType(long)))) /= 0) then     continue else skip ; 
         var j : int ; j := 0 ; while j < n do ( (     dp[s+1][i+1] := Set{dp[s+1][i+1], dp[MathLib.bitwiseOr(s,((1*(2->pow(i)))->oclAsType(long)))+1][j+1] + 2 * (r[i+1] * r[j+1])->sqrt()}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     s := s - 1 ) ; 
    var flag : boolean ; flag := false ;
        var j : int ; j := 0 ; while j < n do ( (     if (dp[0+1][j+1] + r[j+1] <= w) then (     flag := true ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(if (flag) then "OK" else "NA" endif) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    DGridComponents solver=new DGridComponents();
    solver.solve(1,in,out);
    out.close();
  }
  static class DGridComponents {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int a=in.nextInt();
      int b=in.nextInt();
      char[][] c=new char[100][100];
      for(int i=0 ; i<100 ; i++){
        for(int j=0 ; j<100 ; j++){
          if(i<50){
            if(i % 2!=0 && j % 2!=0 && a>1){
              c[i][j]='.' ;
              a--;
            }
            else {
              c[i][j]='#' ;
            }
          }
          else {
            if(i % 2!=0 && j % 2!=0 && b>1){
              c[i][j]='#' ;
              b--;
            }
            else {
              c[i][j]='.' ;
            }
          }
        }
      }
      out.println("100 100");
      for(int i=0 ; i<100 ; i++){
        for(int j=0 ; j<100 ; j++){
          out.print(c[i][j]);
        }
        out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : DGridComponents ; solver := DGridComponents.newDGridComponents() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class DGridComponents {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    var c : Sequence(Sequence(String)) ; c := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(0)) ;
        var i : int ; i := 0 ; while i < 100 do ( (         var j : int ; j := 0 ; while j < 100 do ( (     if (i < 50) then (     if (i mod 2 /= 0 & j mod 2 /= 0 & a > 1) then (     c[i+1][j+1] := '.' ; 
     a := a - 1 ) else (     c[i+1][j+1] := '#' ) ) else (     if (i mod 2 /= 0 & j mod 2 /= 0 & b > 1) then (     c[i+1][j+1] := '#' ; 
     b := b - 1 ) else (     c[i+1][j+1] := '.' ) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < 100 do ( (         var j : int ; j := 0 ; while j < 100 do ( (     skip )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Arrays ;
import java.util.Deque ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    while(scanner.hasNext()){
      StringTokenizer tokenizer=new StringTokenizer(scanner.nextLine());
      int n=Integer.parseInt(tokenizer.nextToken());
      int s=tokenizer.countTokens();
      int[] num=new int[s];
      for(int i=0 ; i<s ; i++){
        num[i]=Integer.parseInt(tokenizer.nextToken());
      }
      Arrays.sort(num);
      Deque<Integer>que=new ArrayDeque<Integer>();
      for(int t : num){
        que.offer(t);
      }
      Deque<Integer>deque=new ArrayDeque<Integer>();
      boolean flag=true ;
      while(! que.isEmpty()){
        if(flag){
          deque.offer(que.pop());
          if(! que.isEmpty()){
            deque.offer(que.pollLast());
          }
          flag=false ;
        }
        else {
          deque.push(que.pollLast());
          if(! que.isEmpty()){
            deque.push(que.pop());
          }
          flag=true ;
        }
      }
      double sum=0 ;
      sum+=deque.getFirst();
      sum+=deque.getLast();
      int a=deque.pop();
      while(! deque.isEmpty()){
        int b=deque.pop();
        sum+=Math.sqrt(a*b)*2 ;
        a=b ;
      }
      System.out.println(sum<=n ? "OK" : "NA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scanner.hasNext()) do (     var tokenizer : OclIterator ; tokenizer := OclIterator.newOclIterator_String(scanner.nextLine()) ;
     var n : int ; n := (tokenizer.next())->toInteger() ;
    var s : int ; s := tokenizer.elements->size() ;
    var num : Sequence(int) ; num := Integer.subrange(1,s)->collect(0) ;
        var i : int ; i := 0 ; while i < s do ( (     num[i+1] := (tokenizer.next())->toInteger() )  ;     i := i + 1 ) ; 
    num := num->sort() ; 
    var que : Sequence(int) ; que := ArrayDeque<int>.newArrayDeque() ;
    for (t : num) do ( (     que := que->including(t) )  ) ; 
    var deque : Sequence(int) ; deque := ArrayDeque<int>.newArrayDeque() ;
    var flag : boolean ; flag := true ;
    while (not(que->isEmpty())) do (     if (flag) then (     deque := deque->including(que->last()) ; 
     if (not(que->isEmpty())) then (     deque := deque->including(que->last()) ) else skip ; 
     flag := false ) else (     deque := deque->append(que->last()) ; 
     if (not(que->isEmpty())) then (     deque := deque->append(que->last()) ) else skip ; 
     flag := true ) ) ; 
    var sum : double ; sum := 0 ;
    sum := sum+(deque->first()) ; 
    sum := sum+(deque->last()) ; 
    var a : int ; a := deque->last() ;
    while (not(deque->isEmpty())) do (     var b : int ; b := deque->last() ;
     sum := sum+((a * b)->sqrt() * 2) ; 
     a := b ) ; 
    OclFile["System.out"].println(if sum <= n then "OK" else "NA" endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextDouble()){
      String[] s=sc.nextLine().split(" ");
      double len=Double.parseDouble(s[0]);
      r=new double[s.length-1];
      for(int i=1 ; i<s.length ; i++){
        r[i-1]=Double.parseDouble(s[i]);
      }
      double min=Double.MAX_VALUE ;
      dp=new double[1<<12][12];
      for(int i=0 ; i<r.length ; i++){
        min=Math.min(min,r[i]+solve(r.length-1,1<<i,i));
      }
      System.out.println(min<=len ? "OK" : "NA");
    }
  }
  private static double[] r ;
  private static double[][] dp ;
  private static double solve(int rem,int flg,int last){
    if(dp[flg][last]>0)return dp[flg][last];
    if(rem==0)return dp[flg][last]=r[last];
    double res=Double.MAX_VALUE ;
    for(int i=0 ; i<r.length ; i++){
      if(((1<<i)& flg)>0)continue ;
      double tmp=Math.sqrt(Math.pow(r[last]+r[i],2)-Math.pow(r[last]-r[i],2));
      res=Math.min(res,tmp+solve(rem-1,flg |(1<<i),i));
    }
    return dp[flg][last]=res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextDouble()) do (     var s : Sequence(String) ; s := sc.nextLine()->split(" ") ;
     var len : double ; len := (s[0+1])->toReal() ;
    r := Integer.subrange(1,s->size() - 1)->collect(0.0) ; 
        var i : int ; i := 1 ; while i < s->size() do ( (     r[i - 1+1] := (s[i+1])->toReal() )  ;     i := i + 1 ) ; 
    var min : double ; min := (2 - 2->pow(-52))*(2->pow(1023)) ;
    dp := Integer.subrange(1,(1*(2->pow(12)))->oclAsType(long))->collect(Integer.subrange(1,12)->collect(0.0)) ; 
        var i : int ; i := 0 ; while i < r->size() do ( (     min := Set{min, r[i+1] + solve(r->size() - 1, (1*(2->pow(i)))->oclAsType(long), i)}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if min <= len then "OK" else "NA" endif) ; 
 ) );
  static   attribute r : Sequence(double);
  static   attribute dp : Sequence(Sequence(double));
  static   operation solve( rem : int, flg : int, last : int) : double
  pre: true
  post: true
  activity: (     if (dp[flg+1][last+1] > 0) then     return dp[flg+1][last+1] else skip ; 
     if (rem = 0) then     return dp[flg+1][last+1] else skip ; 
    var res : double ; res := (2 - 2->pow(-52))*(2->pow(1023)) ;
        var i : int ; i := 0 ; while i < r->size() do ( (     if ((((1*(2->pow(i)))->oclAsType(long)) & flg) > 0) then     continue else skip ; 
     var tmp : double ; tmp := (r[last+1] + r[i+1]->pow(2) - r[last+1] - r[i+1]->pow(2))->sqrt() ;
     res := Set{res, tmp + solve(rem - 1, flg or ((1*(2->pow(i)))->oclAsType(long)), i)}->min() )  ;     i := i + 1 ) ; 
    return dp[flg+1][last+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    abc161_a solver=new abc161_a();
    solver.solve(1,in,out);
    out.close();
  }
  static class abc161_a {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int A=in.nextInt();
      int B=in.nextInt();
      int C=in.nextInt();
      int Wk ;
      Wk=A ;
      A=B ;
      B=Wk ;
      Wk=C ;
      C=A ;
      A=Wk ;
      out.print(A);
      out.print(' ');
      out.print(B);
      out.print(' ');
      out.print(C);
      out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : abc161_a ; solver := abc161_a.newabc161_a() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class abc161_a {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var A : int ; A := in.getCurrent()->toInteger() ;
     var B : int ; B := in.getCurrent()->toInteger() ;
    var C : int ; C := in.getCurrent()->toInteger() ;
    var Wk : int ;
    Wk := A ; 
    A := B ; 
    B := Wk ; 
    Wk := C ; 
    C := A ; 
    A := Wk ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String str=sc.nextLine();
      String[] params=str.split(" ");
      final int box_length=Integer.parseInt(params[0]);
      final int cakes=params.length-1 ;
      int[] cake_len=new int[cakes];
      for(int i=0 ; i<cakes ; i++){
        cake_len[i]=Integer.parseInt(params[i+1]);
      }
      Arrays.sort(cake_len);
      List<Integer>list=new ArrayList<Integer>();
      boolean flag=true ;
      for(int i=0 ; i<cakes/2 ; i++){
        if(flag){
          list.add(0,cake_len[i]);
          list.add(cake_len[cakes-i-1]);
          flag=false ;
        }
        else {
          list.add(0,cake_len[cakes-i-1]);
          list.add(cake_len[i]);
          flag=true ;
        }
      }
      if(cakes==1){
        list.add(cake_len[0]);
      }
      else if(cakes % 2==1){
        if(list.get(0)>cake_len[cakes/2]){
          list.add(0,cake_len[cakes/2]);
        }
        else {
          list.add(cake_len[cakes/2]);
        }
      }
      double sum=list.get(0)+list.get(cakes-1);
      for(int i=0 ; i<cakes-1 ; i++){
        sum+=2*Math.sqrt(list.get(i)*list.get(i+1));
      }
      if(sum<=box_length){
        System.out.println("OK");
      }
      else {
        System.out.println("NA");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var str : String ; str := sc.nextLine() ;
     var params : Sequence(String) ; params := str->split(" ") ;
    var box_length : int ; box_length := (params[0+1])->toInteger() ;
    var cakes : int ; cakes := params->size() - 1 ;
    var cake_len : Sequence(int) ; cake_len := Integer.subrange(1,cakes)->collect(0) ;
        var i : int ; i := 0 ; while i < cakes do ( (     cake_len[i+1] := (params[i + 1+1])->toInteger() )  ;     i := i + 1 ) ; 
    cake_len := cake_len->sort() ; 
    var list : Sequence(int) ; list := Sequence{} ;
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < cakes / 2 do ( (     if (flag) then (     list := list.insertAt(0+1,cake_len[i+1]) ; 
     list := list->including(cake_len[cakes - i - 1+1]) ; 
     flag := false ) else (     list := list.insertAt(0+1,cake_len[cakes - i - 1+1]) ; 
     list := list->including(cake_len[i+1]) ; 
     flag := true ) )  ;     i := i + 1 ) ; 
    if (cakes = 1) then (     list := list->including(cake_len[0+1]) ) else     if (cakes mod 2 = 1) then (     if (list->at(0+1) > cake_len[cakes / 2+1]) then (     list := list.insertAt(0+1,cake_len[cakes / 2+1]) ) else (     list := list->including(cake_len[cakes / 2+1]) ) ) else skip ; ;  
    var sum : double ; sum := list->at(0+1) + list->at(cakes - 1+1) ;
        var i : int ; i := 0 ; while i < cakes - 1 do ( (     sum := sum+(2 * (list->at(i+1) * list->at(i + 1+1))->sqrt()) )  ;     i := i + 1 ) ; 
    if (sum <= box_length) then (     OclFile["System.out"].println("OK") ) else (     OclFile["System.out"].println("NA") ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.nextLine());
    long ans=0 ;
    boolean odd=false ;
    for(int i=0 ; i<N ; i++){
      int a=Integer.parseInt(sc.nextLine());
      if(a % 2==0){
        ans+=(a/2);
        if(! odd || a==0){
          odd=false ;
        }
      }
      else {
        if(odd){
          ans+=((a+1)/2);
          odd=false ;
        }
        else {
          ans+=(a/2);
          odd=true ;
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.nextLine())->toInteger() ;
    var ans : long ; ans := 0 ;
    var odd : boolean ; odd := false ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := (sc.nextLine())->toInteger() ;
     if (a mod 2 = 0) then (     ans := ans+((a / 2)) ; 
     if (not(odd) or a = 0) then (     odd := false ) else skip ) else (     if (odd) then (     ans := ans+(((a + 1) / 2)) ; 
     odd := false ) else (     ans := ans+((a / 2)) ; 
     odd := true ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private void solve()throws IOException {
    int n=nextInt();
    int a[]=new int[n+1];
    long ans=0 ;
    for(int i=1 ; i<=n ; i++)a[i]=nextInt();
    for(int i=1 ; i<=n ; i++){
      ans+=a[i]/2 ;
      a[i]=a[i] % 2 ;
      if(a[i]==1 && i!=n && a[i+1]>0){
        ans++;
        a[i]=0 ;
        a[i+1]--;
      }
    }
    out.println(ans);
  }
  public void run()throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    st=null ;
    out=new PrintWriter(System.out);
    solve();
    br.close();
    out.close();
  }
  public static void main(String args[])throws IOException {
    new Main().run();
  }
  BufferedReader br ;
  StringTokenizer st ;
  PrintWriter out ;
  String nextToken()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  String nextLine()throws IOException {
    return br.readLine();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     ans := ans+(a[i+1] / 2) ; 
     a[i+1] := a[i+1] mod 2 ; 
     if (a[i+1] = 1 & i /= n & a[i + 1+1] > 0) then (     ans := ans + 1 ; 
     a[i+1] := 0 ; 
     a[i + 1+1] := a[i + 1+1] - 1 ) else skip )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := null ; 
    out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    br.close() ; 
    out.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute br : OclFile;
   attribute st : OclIterator;
   attribute out : OclFile;
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.awt.geom.Point2D ;
import java.awt.geom.Point2D.Double ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
import java.util.TreeSet ;
import java.lang.Object ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new B().doIt();
  }
  class B {
    void doIt(){
      int n=sc.nextInt();
      long a[]=new long[n+1];
      long sum=0 ;
      long cnt=0 ;
      for(int i=1 ; i<n+1 ; i++){
        a[i]=sc.nextLong();
        sum=sum+((a[i]+cnt)/2);
        if(a[i]>0)cnt=(a[i]+cnt)% 2 ;
        else cnt=0 ;
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     B.newB().doIt() );
 class B {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var sum : long ; sum := 0 ;
    var cnt : long ; cnt := 0 ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     a[i+1] := sc.getCurrent()->toLong() ; 
     sum := sum + ((a[i+1] + cnt) / 2) ; 
     if (a[i+1] > 0) then     cnt := (a[i+1] + cnt) mod 2 ; else     cnt := 0 ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    int[] cards=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      int card=sc.nextInt();
      cards[i]+=card ;
    }
    long res=0 ;
    for(int i=1 ; i<=n ; i++){
      res+=cards[i]/2 ;
      cards[i]-=cards[i]/2*2 ;
      if(i<n && cards[i]>0 && cards[i+1]>0){
        int min=Math.min(cards[i],cards[i+1]);
        res+=min ;
        cards[i]-=min ;
        cards[i+1]-=min ;
      }
    }
    System.out.println(res);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : int ; n := sc.nextInt() ;
    var cards : Sequence(int) ; cards := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     var card : int ; card := sc.nextInt() ;
     cards[i+1] := cards[i+1]+(card) )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     res := res+(cards[i+1] / 2) ; 
     cards[i+1] := cards[i+1]-(cards[i+1] / 2 * 2) ; 
     if (i < n & cards[i+1] > 0 & cards[i + 1+1] > 0) then (     var min : int ; min := Set{cards[i+1], cards[i + 1+1]}->min() ;
     res := res+(min) ; 
     cards[i+1] := cards[i+1]-(min) ; 
     cards[i + 1+1] := cards[i + 1+1]-(min) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new PrintStream(System.out));
    int n=Integer.parseInt(f.readLine());
    long[] arr=new long[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=Long.parseLong(f.readLine());
    }
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(i!=0 && arr[i]!=0)arr[i]+=arr[i-1];
      ans+=arr[i]/2 ;
      arr[i] %=2 ;
    }
    System.out.print(ans);
    f.close();
    out.close();
  }
}
class pair implements Comparable<pair>{
  int num ;
  int idx ;
  public int compareTo(pair other){
    return num-other.num ;
  }
  pair(int a,int b){
    num=a ;
    idx=b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := (f.readLine())->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (f.readLine())->toLong() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i /= 0 & arr[i+1] /= 0) then     arr[i+1] := arr[i+1]+(arr[i - 1+1]) ; else skip ; 
     ans := ans+(arr[i+1] / 2) ; 
     arr[i+1] := arr[i+1] mod 2 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(ans) ; 
    skip ; 
    skip ; 
 );
}
class pair implements Comparable<pair> {
   attribute num : int;
   attribute idx : int;
   operation compareTo( other : pair) : int
  pre: true
  post: true
  activity: (     return num - other.num );
   static operation newpair( a : int, b : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     num := a ; 
     idx := b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void countPairs(int arr[],int N){
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(int i=0 ; i<N ; i++){
      if(mp.containsKey(arr[i])){
        mp.put(arr[i],mp.get(arr[i])+1);
      }
      else {
        mp.put(arr[i],1);
      }
    }
    int maxFreq=0 ;
    for(Map.Entry<Integer,Integer>it : mp.entrySet()){
      maxFreq=Math.max(maxFreq,it.getValue());
    }
    System.out.print(N-maxFreq+"\n");
  }
  public static void main(String[] args){
    int arr[]={
      1,8,5,9,8,8,7,7,5,7,7 };
      int N=arr.length ;
      countPairs(arr,N);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPairs( arr : Sequence(int), N : int) : void
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < N do ( (     if (mp->keys()->includes(arr[i+1])) then (     mp := mp->union(Map{arr[i+1] |-> mp->at(arr[i+1]) + 1}) ) else (     mp := mp->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var maxFreq : int ; maxFreq := 0 ;
    for (it : mp->asSet()) do ( (     maxFreq := Set{maxFreq, it.getValue()}->max() )  ) ; 
    OclFile["System.out"].print(N - maxFreq + "\n") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,8,5,9,8,8,7,7,5,7,7} ;
     var N : int ; N := arr->size() ;
     execute countPairs(arr, N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
import java.util.Scanner ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.stream.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    boolean map[]=new boolean[99*49];
    Arrays.fill(map,false);
    for(int i=99*25 ; i<99*49 ; i++){
      map[i]=true ;
    }
    for(int i=0 ; i<A-1 ; i++){
      map[i*2]=true ;
    }
    for(int i=0 ; i<B-1 ; i++){
      map[99*49-i*2-1]=false ;
    }
    String whiteLine="..................................................................................................." ;
    String blackLine="###################################################################################################" ;
    System.out.println("98 99");
    for(int i=0 ; i<49 ; i++){
      for(int j=0 ; j<99 ; j++){
        System.out.print(map[i*99+j] ? "." : "#");
      }
      System.out.println("");
      if(i<25){
        System.out.println(blackLine);
      }
      else {
        System.out.println(whiteLine);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var map : Sequence(boolean) ; map := Integer.subrange(1,99 * 49)->collect(false) ;
    map := map->collect(false) ; 
        var i : int ; i := 99 * 25 ; while i < 99 * 49 do ( (     map[i+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < A - 1 do ( (     map[i * 2+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < B - 1 do ( (     map[99 * 49 - i * 2 - 1+1] := false )  ;     i := i + 1 ) ; 
    var whiteLine : String ; whiteLine := "..................................................................................................." ;
    var blackLine : String ; blackLine := "###################################################################################################" ;
    OclFile["System.out"].println("98 99") ; 
        var i : int ; i := 0 ; while i < 49 do ( (         var j : int ; j := 0 ; while j < 99 do ( (     OclFile["System.out"].print(if map[i * 99 + j+1] then "." else "#" endif) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("") ; 
     if (i < 25) then (     OclFile["System.out"].println(blackLine) ) else (     OclFile["System.out"].println(whiteLine) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  long MOD=(long)(1e9+7);
  boolean ok(int p,int w){
    if((p & 1)==1)return false ;
    if(((p>>(w))& 1)==1)return false ;
    for(int b=0 ; b<=w ; b++){
      if(((p>>>b)& 3)==3){
        return false ;
      }
    }
    return true ;
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt(),W=sc.nextInt(),K=sc.nextInt();
    long[][] dp=new long[H+1][W+2];
    dp[0][1]=1 ;
    for(int h=1 ; h<=H ; h++){
      for(int i=0 ; i<(1<<W+1); i++){
        if(ok(i,W)){
          for(int j=1 ; j<=W ; j++){
            if(((i>>(j-1))& 1)==1)dp[h][j-1]=(dp[h][j-1]+dp[h-1][j])% MOD ;
            if(((i>>j)& 1)==1)dp[h][j+1]=(dp[h][j+1]+dp[h-1][j])% MOD ;
            if(((i>>(j-1))& 3)==0)dp[h][j]=(dp[h][j]+dp[h-1][j])% MOD ;
          }
        }
      }
    }
    System.out.println(dp[H][K]);
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute MOD : long := (1e9 + 7)->oclAsType(long);
   operation ok( p : int, w : int) : boolean
  pre: true
  post: true
  activity: (     if ((p & 1) = 1) then     return false else skip ; 
     if ((((p/(2->pow((w))))->oclAsType(long)) & 1) = 1) then     return false else skip ; 
         var b : int ; b := 0 ; while b <= w do ( (     if ((((p/(2->pow(b)))->oclAsType(long)) & 3) = 3) then (     return false ) else skip )  ;     b := b + 1 ) ; 
     return true );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,H + 1)->collect(Integer.subrange(1,W + 2)->collect(0)) ;
    dp[0+1][1+1] := 1 ; 
        var h : int ; h := 1 ; while h <= H do ( (         var i : int ; i := 0 ; while i < ((1*(2->pow(W + 1)))->oclAsType(long)) do ( (     if (ok(i, W)) then (         var j : int ; j := 1 ; while j <= W do ( (     if ((((i/(2->pow((j - 1))))->oclAsType(long)) & 1) = 1) then     dp[h+1][j - 1+1] := (dp[h+1][j - 1+1] + dp[h - 1+1][j+1]) mod MOD ; else skip ; 
     if ((((i/(2->pow(j)))->oclAsType(long)) & 1) = 1) then     dp[h+1][j + 1+1] := (dp[h+1][j + 1+1] + dp[h - 1+1][j+1]) mod MOD ; else skip ; 
     if ((((i/(2->pow((j - 1))))->oclAsType(long)) & 3) = 0) then     dp[h+1][j+1] := (dp[h+1][j+1] + dp[h - 1+1][j+1]) mod MOD ; else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) )  ;     h := h + 1 ) ; 
    OclFile["System.out"].println(dp[H+1][K+1]) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int fib(int n){
    int a=1 ;
    int b=1 ;
    for(int i=1 ; i<n ; i++){
      int tmp=b ;
      b=a+b ;
      a=tmp ;
    }
    return b ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int H=Integer.parseInt(sc.next());
    int W=Integer.parseInt(sc.next());
    int K=Integer.parseInt(sc.next());
    int mod=1_000_000_007 ;
    long[][] dp=new long[H+1][W+2];
    dp[0][1]=1 ;
    for(int i=1 ; i<H+1 ; i++){
      for(int j=1 ; j<W+1 ; j++){
        dp[i][j]=(dp[i][j]+dp[i-1][j-1]*fib(j-2)*fib(W-j))% mod ;
        dp[i][j]=(dp[i][j]+dp[i-1][j]*fib(j-1)*fib(W-j))% mod ;
        dp[i][j]=(dp[i][j]+dp[i-1][j+1]*fib(j-1)*fib(W-j-1))% mod ;
      }
    }
    System.out.println(dp[H][K]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation fib( n : int) : int
  pre: true
  post: true
  activity: (     var a : int ; a := 1 ;
     var b : int ; b := 1 ;
         var i : int ; i := 1 ; while i < n do ( (     var tmp : int ; tmp := b ;
     b := a + b ; 
     a := tmp )  ;     i := i + 1 ) ; 
     return b );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := (sc.getCurrent())->toInteger() ;
    var W : int ; W := (sc.getCurrent())->toInteger() ;
    var K : int ; K := (sc.getCurrent())->toInteger() ;
    var mod : int ; mod := 1_000_000_007 ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,H + 1)->collect(Integer.subrange(1,W + 2)->collect(0)) ;
    dp[0+1][1+1] := 1 ; 
        var i : int ; i := 1 ; while i < H + 1 do ( (         var j : int ; j := 1 ; while j < W + 1 do ( (     dp[i+1][j+1] := (dp[i+1][j+1] + dp[i - 1+1][j - 1+1] * fib(j - 2) * fib(W - j)) mod mod ; 
     dp[i+1][j+1] := (dp[i+1][j+1] + dp[i - 1+1][j+1] * fib(j - 1) * fib(W - j)) mod mod ; 
     dp[i+1][j+1] := (dp[i+1][j+1] + dp[i - 1+1][j + 1+1] * fib(j - 1) * fib(W - j - 1)) mod mod )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[H+1][K+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.run();
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    int a[]=new int[3];
    a[0]=sc.nextInt();
    a[1]=sc.nextInt();
    a[2]=sc.nextInt();
    swap(a,0,1);
    swap(a,0,2);
    System.out.println(a[0]+" "+a[1]+" "+a[2]);
    sc.close();
  }
  private void swap(int a[],int i,int j){
    int tmp=a[i];
    a[i]=a[j];
    a[j]=tmp ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
    a[0+1] := sc.getCurrent()->toInteger() ; 
    a[1+1] := sc.getCurrent()->toInteger() ; 
    a[2+1] := sc.getCurrent()->toInteger() ; 
    execute swap(a, 0, 1) ; 
    execute swap(a, 0, 2) ; 
    OclFile["System.out"].println(a[0+1] + " " + a[1+1] + " " + a[2+1]) ; 
    skip ; 
 );
   operation swap( a : Sequence(int), i : int, j : int) : void
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := a[i+1] ;
     a[i+1] := a[j+1] ; 
     a[j+1] := tmp );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static final long MOD=1_000_000_007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt(),w=sc.nextInt(),k=sc.nextInt();
    long[][] dp=new long[h+1][w+2];
    dp[0][1]=1 ;
    for(int i=0 ; i<h ; i++){
      for(int j=1 ; j<=w ; j++){
        long left=j-2 ;
        long right=w-j-1 ;
        long Straight=myPow(left)*myPow(right);
        long Left=myPow(left-1)*myPow(right);
        long Right=myPow(left)*myPow(right-1);
        dp[i+1][j]=dp[i][j]*Straight+dp[i][j-1]*Left+dp[i][j+1]*Right ;
        dp[i+1][j] %=MOD ;
      }
    }
    System.out.println(dp[h][k]);
  }
  static long myPow(long weight){
    if(weight<=0)return 1 ;
    long retV=0 ;
    loop : for(int j=0 ;
    j<(1L<<weight);
    j++){
      verify : for(int k=0 ;
      k<weight ;
      k++){
        if(k==0)continue verify ;
        if(((j>>k)& 1)==1 &&((j>>k-1)& 1)==1)continue loop ;
      }
      retV++;
    }
    return retV ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 2)->collect(0)) ;
    dp[0+1][1+1] := 1 ; 
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 1 ; while j <= w do ( (     var left : long ; left := j - 2 ;
     var right : long ; right := w - j - 1 ;
    var Straight : long ; Straight := myPow(left) * myPow(right) ;
    var Left : long ; Left := myPow(left - 1) * myPow(right) ;
    var Right : long ; Right := myPow(left) * myPow(right - 1) ;
    dp[i + 1+1][j+1] := dp[i+1][j+1] * Straight + dp[i+1][j - 1+1] * Left + dp[i+1][j + 1+1] * Right ; 
    dp[i + 1+1][j+1] := dp[i + 1+1][j+1] mod MOD ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[h+1][k+1]) ; 
 );
  static   operation myPow( weight : long) : long
  pre: true
  post: true
  activity: (     if (weight <= 0) then     return 1 else skip ; 
     var retV : long ; retV := 0 ;
         var j : int ; j := 0 ; while j < ((1L*(2->pow(weight)))->oclAsType(long)) do ( (         var k : int ; k := 0 ; while k < weight do ( (     if (k = 0) then     continue else skip ; 
     if ((((j/(2->pow(k)))->oclAsType(long)) & 1) = 1 & (((j/(2->pow(k - 1)))->oclAsType(long)) & 1) = 1) then     continue else skip )  ;     k := k + 1 ) ; 
     retV := retV + 1 )  ;     j := j + 1 ) ; 
     return retV );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  final int MOD=1000000007 ;
  void doIt(){
    int h=sc.nextInt();
    int w=sc.nextInt();
    int K=sc.nextInt();
    int dp[][]=new int[h+1][w];
    for(int i=0 ; i<=h ; i++)Arrays.fill(dp[i],0);
    dp[0][0]=1 ;
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        for(int k=0 ; k<1<<(w-1); k++){
          if(validate(k,w)){
            if(j>=1 &&((k>>(j-1))& 1)==1){
              dp[i+1][j-1]+=dp[i][j];
              dp[i+1][j-1] %=MOD ;
            }
            else if(j<w-1 &&(k>>j & 1)==1){
              dp[i+1][j+1]+=dp[i][j];
              dp[i+1][j+1] %=MOD ;
            }
            else {
              dp[i+1][j]+=dp[i][j];
              dp[i+1][j] %=MOD ;
            }
          }
        }
      }
    }
    System.out.println(dp[h][K-1]);
  }
  boolean validate(int num,int w){
    int n=num ;
    for(int i=0 ; i<(w-1); i++){
      if(((n>>i)& 1)==1 &&((n>>i)& 1)==((n>>(i+1))& 1)){
        return false ;
      }
    }
    return true ;
  }
  Main(){
    doIt();
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute MOD : int := 1000000007;
   operation doIt() : void
  pre: true
  post: true
  activity: (     var h : int ; h := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i <= h do (     dp[i+1] := dp[i+1]->collect(0) ;  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (         var k : int ; k := 0 ; while k < (1*(2->pow((w - 1))))->oclAsType(long) do ( (     if (validate(k, w)) then (     if (j >= 1 & (((k/(2->pow((j - 1))))->oclAsType(long)) & 1) = 1) then (     dp[i + 1+1][j - 1+1] := dp[i + 1+1][j - 1+1]+(dp[i+1][j+1]) ; 
     dp[i + 1+1][j - 1+1] := dp[i + 1+1][j - 1+1] mod MOD ) else     if (j < w - 1 & (MathLib.bitwiseAnd((k/(2->pow(j)))->oclAsType(long),1)) = 1) then (     dp[i + 1+1][j + 1+1] := dp[i + 1+1][j + 1+1]+(dp[i+1][j+1]) ; 
     dp[i + 1+1][j + 1+1] := dp[i + 1+1][j + 1+1] mod MOD ) else (     dp[i + 1+1][j+1] := dp[i + 1+1][j+1]+(dp[i+1][j+1]) ; 
     dp[i + 1+1][j+1] := dp[i + 1+1][j+1] mod MOD ) ;  ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[h+1][K - 1+1]) ; 
 );
   operation validate( num : int, w : int) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := num ;
         var i : int ; i := 0 ; while i < (w - 1) do ( (     if ((((n/(2->pow(i)))->oclAsType(long)) & 1) = 1 & (((n/(2->pow(i)))->oclAsType(long)) & 1) = (((n/(2->pow((i + 1))))->oclAsType(long)) & 1)) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute doIt() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  final static int N=3 ;
  static int findStepsForDDM(int arr[][]){
    int result=0 ;
    for(int i=0 ; i<N ; i++){
      int sum=0 ;
      for(int j=0 ; j<N ; j++)sum+=Math.abs(arr[i][j]);
      sum-=Math.abs(arr[i][i]);
      if(Math.abs(arr[i][i])<Math.abs(sum))result+=Math.abs(Math.abs(arr[i][i])-Math.abs(sum));
    }
    return result ;
  }
  public static void main(String[] args){
    int arr[][]={
      {
        3,-2,1 },{
          1,-3,2 },{
-1,2,4 }
          };
          System.out.println(findStepsForDDM(arr));
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 3;
  static   operation findStepsForDDM( arr : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < N do (     sum := sum+(if arr[i+1][j+1] < 0 then -(arr[i+1][j+1]) else arr[i+1][j+1] endif) ;  ;     j := j + 1 ) ; 
     sum := sum-(if arr[i+1][i+1] < 0 then -(arr[i+1][i+1]) else arr[i+1][i+1] endif) ; 
     if (if arr[i+1][i+1] < 0 then -(arr[i+1][i+1]) else arr[i+1][i+1] endif < if sum < 0 then -(sum) else sum endif) then     result := result+(if if arr[i+1][i+1] < 0 then -(arr[i+1][i+1]) else arr[i+1][i+1] endif - if sum < 0 then -(sum) else sum endif < 0 then -(if arr[i+1][i+1] < 0 then -(arr[i+1][i+1]) else arr[i+1][i+1] endif - if sum < 0 then -(sum) else sum endif) else if arr[i+1][i+1] < 0 then -(arr[i+1][i+1]) else arr[i+1][i+1] endif - if sum < 0 then -(sum) else sum endif endif) ; else skip )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{3,-2,1},Sequence{1,-3,2},Sequence{-1,2,4}} ;
     OclFile["System.out"].println(findStepsForDDM(arr)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static char[][] f=new char[4][];
  public static void main(String[] args){
    for(int i=0 ; i<4 ; i++){
      f[i]=sc.next().toCharArray();
    }
    for(int i=0 ; i<4 ; i++){
      for(int j=0 ; j<4 ; j++){
        if(f[i][j]=='.'){
          f[i][j]='x' ;
          if(win()){
            System.out.println("YES");
            return ;
          }
          f[i][j]='.' ;
        }
      }
    }
    System.out.println("NO");
  }
  static boolean win(){
    for(int i=0 ; i<4 ; i++){
      for(int j=0 ; j<4 ; j++){
        if(align(i,j,0,1))return true ;
        if(align(i,j,1,0))return true ;
        if(align(i,j,1,1))return true ;
        if(align(i,j,1,-1))return true ;
      }
    }
    System.out.println();
    return false ;
  }
  static boolean align(int r,int c,int dr,int dc){
    if(r+dr*2>=4 || c+dc*2>=4 || c+dc*2<0)return false ;
    return f[r][c]=='x' && f[r+dr][c+dc]=='x' && f[r+2*dr][c+2*dc]=='x' ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute f : Sequence(Sequence(String)) := Integer.subrange(1,4)->collect(Sequence{});
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 4 do ( (     f[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < 4 do ( (     if (f[i+1][j+1] = '.') then (     f[i+1][j+1] := 'x' ; 
     if (win()) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
     f[i+1][j+1] := '.' ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("NO") );
  static   operation win() : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < 4 do ( (     if (align(i, j, 0, 1)) then     return true else skip ; 
     if (align(i, j, 1, 0)) then     return true else skip ; 
     if (align(i, j, 1, 1)) then     return true else skip ; 
     if (align(i, j, 1, -1)) then     return true else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ; 
     return false );
  static   operation align( r : int, c : int, dr : int, dc : int) : boolean
  pre: true
  post: true
  activity: (     if (r + dr * 2 >= 4 or c + dc * 2 >= 4 or c + dc * 2 < 0) then     return false else skip ; 
     return f[r+1][c+1] = 'x' & f[r + dr+1][c + dc+1] = 'x' & f[r + 2 * dr+1][c + 2 * dc+1] = 'x' );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Solution {
  BufferedReader in ;
  PrintWriter out ;
  StringTokenizer st ;
  String nextToken()throws IOException {
    while(st==null || ! st.hasMoreTokens()){
      st=new StringTokenizer(in.readLine());
    }
    return st.nextToken();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  void solve()throws IOException {
    st=new StringTokenizer(in.readLine(),"/");
    long p=nextLong();
    long q=nextLong();
    long gcd=BigInteger.valueOf(p).gcd(BigInteger.valueOf(q)).longValue();
    long qq=q/gcd ;
    if((qq &(qq-1))==0){
      p/=gcd ;
      int ans=1 ;
      while(p<qq/2){
        ans++;
        qq/=2 ;
      }
      out.println(ans);
    }
    else {
      out.println("impossible");
    }
  }
  void run(){
    try {
      in=new BufferedReader(new FileReader("input.txt"));
      out=new PrintWriter("output.txt");
      Locale.setDefault(Locale.UK);
      int tt=nextInt();
      for(int t=1 ; t<=tt ; t++){
        out.print("Case #"+t+": ");
        solve();
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
    finally {
      out.close();
    }
  }
  public static void main(String Args[]){
    new Solution().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
   attribute in : OclFile;
   attribute out : OclFile;
   attribute st : OclIterator;
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
   operation solve() : void
  pre: true
  post: true
  activity: (     st := OclIterator.newOclIterator_String_String(in.readLine(), "/") ; 
     var p : long ; p := nextLong() ;
    var q : long ; q := nextLong() ;
    var gcd : long ; gcd := (p + "")->toLong().gcd((q + "")->toLong())->oclAsType(long) ;
    var qq : long ; qq := q / gcd ;
    if ((MathLib.bitwiseAnd(qq,(qq - 1))) = 0) then (     p := p/(gcd) ; 
     var ans : int ; ans := 1 ;
     while (p < qq / 2) do (     ans := ans + 1 ; 
     qq := qq/(2) ) ; 
     skip ) else (     skip ) ;  
 );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ; 
    Locale.setDefault(Locale.UK) ; 
    var tt : int ; tt := nextInt() ;
        var t : int ; t := 1 ; while t <= tt do ( (     skip ; 
     execute solve() )  ;     t := t + 1 ) ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
   finally (     skip )
 );
  static   operation main( Args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Solution.newSolution().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileReader ;
import java.io.PrintWriter ;
import java.math.BigInteger ;
import java.util.*;
public class A {
  private final Scanner in ;
  private final PrintWriter out ;
  public A(Scanner in,PrintWriter out){
    this.in=in ;
    this.out=out ;
  }
  public static void main(String[] args){
    try(Scanner in=new Scanner(new FileReader(new File("A-large.in")));
    PrintWriter out=new PrintWriter("A-large.out")){
      new A(in,out).solve();
    }
    catch(Throwable t){
      t.printStackTrace();
      System.exit(-1);
    }
  }
  private void solve(){
    int tests=in.nextInt();
    for(int test=1 ; test<=tests ; ++test){
      StringTokenizer st=new StringTokenizer(in.next(),"/");
      BigInteger P=new BigInteger(st.nextToken());
      BigInteger Q=new BigInteger(st.nextToken());
      BigInteger d=P.gcd(Q);
      P=P.divide(d);
      Q=Q.divide(d);
      long p=P.longValue();
      long q=Q.longValue();
      out.print("Case #"+test+": ");
      if(q!=Long.highestOneBit(q)){
        out.println("impossible");
      }
      else {
        int ans ;
        for(ans=0 ; p<q ; ++ans,q>>=1);
        out.println(ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   attribute in : OclFile;
   attribute out : OclFile;
   static operation newA( in : OclFile, out : OclFile) : A
  pre: true
  post: true
  activity:
  ( var self : A ;
    self := createA();
    self.initialise(in, out);
    return self );
  operation initialise( in : OclFile, out : OclFile) : void
  pre: true  post: true
  activity: (     self.in := in ; 
     self.out := out );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile("A-large.in"))) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile("A-large.out")) ;
 (     A.newA(in, out).solve() ))   catch (t : OclException) do (     t.printStackTrace() ; 
 OclProcess.exit(-1) )
  );
   operation solve() : void
  pre: true
  post: true
  activity: (     var tests : int ; tests := in.getCurrent()->toInteger() ;
         var test : int ; test := 1 ; while test <= tests do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String_String(in.getCurrent(), "/") ;
     var P : long ; P := long(st.next()) ;
    var Q : long ; Q := long(st.next()) ;
    var d : long ; d := P.gcd(Q) ;
    P := P.divide(d) ; 
    Q := Q.divide(d) ; 
    var p : long ; p := P->oclAsType(long) ;
    var q : long ; q := Q->oclAsType(long) ;
    skip ; 
    if (q /= highestOneBit(q)) then (     skip ) else (     var ans : int ;
         ans := 0 ; while p < q do (   ;     ans := ans + 1 ;     q := q/(2->pow(1)) ) ; 
     skip ) ;  
 )  ;     test := test + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    double[] ca=new double[] {
      35.5,37.5,40,43,50,55,70 };
      double[] cb=new double[] {
        71,77,83,89,105,116,148 };
        String[] c=new String[] {
          "AAA","AA","A","B","C","D","E","NA" };
          while(stdIn.hasNext()){
            double a=stdIn.nextDouble();
            double b=stdIn.nextDouble();
            int ar=100 ;
            int br=100 ;
            for(int i=0 ; i<ca.length ; i++){
              if(ca[i]>a){
                ar=i ;
                break ;
              }
            }
            for(int i=0 ; i<cb.length ; i++){
              if(cb[i]>b){
                br=i ;
                break ;
              }
            }
            int ans=Math.max(ar,br);
            if(ans==100){
              ans=c.length-1 ;
            }
            System.out.println(c[ans]);
          }
        }
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ca : Sequence(double) ; ca := Sequence{35.5,37.5,40,43,50,55,70} ;
    var cb : Sequence(double) ; cb := Sequence{71,77,83,89,105,116,148} ;
    var c : Sequence(String) ; c := Sequence{"AAA","AA","A","B","C","D","E","NA"} ;
    while (stdIn.hasNext()) do (     var a : double ; a := stdIn.getCurrent()->toReal() ;
     var b : double ; b := stdIn.getCurrent()->toReal() ;
    var ar : int ; ar := 100 ;
    var br : int ; br := 100 ;
        var i : int ; i := 0 ; while i < ca->size() do ( (     if (ca[i+1] > a) then (     ar := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < cb->size() do ( (     if (cb[i+1] > b) then (     br := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := Set{ar, br}->max() ;
    if (ans = 100) then (     ans := c->size() - 1 ) else skip ; 
    OclFile["System.out"].println(c[ans+1]) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package contest;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.util.Scanner;
public class PartElf {
    final static String PROBLEM_NAME = "PartElf";
    final static String WORK_DIR = "D:\\GCJ\\" + PROBLEM_NAME + "\\";
    long gcd(long P, long Q) {
        while (P > 0 && Q > 0) {
            if (P > Q) {
                P %= Q;
            } else {
                Q %= P;
            }
        }
        return P + Q;
    }
    void solve(Scanner sc, PrintWriter pw) {
        String s = sc.next();
        String[] items = s.split("/");
        long P = Long.parseLong(items[0]);
        long Q = Long.parseLong(items[1]);
        long G = gcd(P, Q);
        P /= G;
        Q /= G;
        if ((Q & (Q - 1)) != 0) {
            pw.println("impossible");
            return;
        }
        int ans = 0;
        while (P < Q) {
            P *= 2;
            ans++;
        }
        pw.println(ans);
    }
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(new FileReader(WORK_DIR + "input.txt"));
        PrintWriter pw = new PrintWriter(new FileWriter(WORK_DIR + "output.txt"));
        int caseCnt = sc.nextInt();
        for (int caseNum = 0; caseNum < caseCnt; caseNum++) {
            System.out.println("Processing test case " + (caseNum + 1));
            pw.print("Case #" + (caseNum + 1) + ": ");
            new PartElf().solve(sc, pw);
        }
        pw.flush();
        pw.close();
        sc.close();
    }
}

------------------------------------------------------------
OCL File:
---------
 class PartElf {
  static   attribute PROBLEM_NAME : String := "PartElf";
  static   attribute WORK_DIR : String := "D:\\GCJ\\" + PROBLEM_NAME + "\\";
   operation gcd( P : long, Q : long) : long
  pre: true
  post: true
  activity: (     while (P > 0 & Q > 0) do (     if (P > Q) then (     P := P mod Q ) else (     Q := Q mod P ) ) ; 
     return P + Q );
   operation solve( sc : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := sc.next() ;
     var items : Sequence(String) ; items := s->split("/") ;
    var P : long ; P := (items[0+1])->toLong() ;
    var Q : long ; Q := (items[1+1])->toLong() ;
    var G : long ; G := gcd(P, Q) ;
    P := P/(G) ; 
    Q := Q/(G) ; 
    if ((MathLib.bitwiseAnd(Q,(Q - 1))) /= 0) then (     pw.println("impossible") ; 
     return ) else skip ; 
    var ans : int ; ans := 0 ;
    while (P < Q) do (     P := P*(2) ; 
     ans := ans + 1 ) ; 
    pw.println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(WORK_DIR + "input.txt")) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(WORK_DIR + "output.txt")) ;
    var caseCnt : int ; caseCnt := sc.getCurrent()->toInteger() ;
        var caseNum : int ; caseNum := 0 ; while caseNum < caseCnt do ( (     OclFile["System.out"].println("Processing test case " + (caseNum + 1)) ; 
     skip ; 
     PartElf.newPartElf().solve(sc, pw) )  ;     caseNum := caseNum + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package at.jaki.round1C.A ;
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.PrintWriter ;
public class A {
  private static final String INPUT="A-small-attempt0.in" ;
  private static final String OUTPUT="A-small-attempt0.out" ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new FileReader(INPUT));
    PrintWriter pw=new PrintWriter(OUTPUT);
    int totalTests=Integer.parseInt(br.readLine());
    for(int testNo=1 ; testNo<=totalTests ; testNo++){
      String[] temp=br.readLine().split("/");
      long p=Long.parseLong(temp[0]);
      long q=Long.parseLong(temp[1]);
      System.out.println(p+"/"+q);
      while(p % 2==0 && q % 2==0){
        p/=2 ;
        q/=2 ;
      }
      for(long i=3 ; i<=Math.sqrt(p); i+=2){
        if(p % i==0 && q % i==0){
          p/=i ;
          q/=i ;
        }
      }
      if(q % p==0){
        q/=p ;
        p=1 ;
      }
      String result ;
      if(! is2Fac(q)){
        result="impossible" ;
      }
      else {
        while(p>1){
          q/=2 ;
          p/=2 ;
        }
        result=""+count(q);
      }
      System.out.println(p+"/"+q);
      pw.print("Case #"+testNo+": ");
      pw.println(result);
      System.out.println(result);
    }
    pw.flush();
    pw.close();
  }
  private static int count(long q){
    int total=0 ;
    while(q>1){
      q/=2 ;
      total++;
    }
    return total ;
  }
  private static boolean is2Fac(long q){
    while(q>1){
      if(q % 2==0){
        q/=2 ;
      }
      else {
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static    attribute INPUT : String := "A-small-attempt0.in";
  static    attribute OUTPUT : String := "A-small-attempt0.out";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(INPUT))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile(OUTPUT)) ;
    var totalTests : int ; totalTests := (br.readLine())->toInteger() ;
        var testNo : int ; testNo := 1 ; while testNo <= totalTests do ( (     var temp : Sequence(String) ; temp := br.readLine()->split("/") ;
     var p : long ; p := (temp[0+1])->toLong() ;
    var q : long ; q := (temp[1+1])->toLong() ;
    OclFile["System.out"].println(p + "/" + q) ; 
    while (p mod 2 = 0 & q mod 2 = 0) do (     p := p/(2) ; 
     q := q/(2) ) ; 
        var i : long ; i := 3 ; while i <= (p)->sqrt() do ( (     if (p mod i = 0 & q mod i = 0) then (     p := p/(i) ; 
     q := q/(i) ) else skip )  ;     i := i+(2) ) ; 
    if (q mod p = 0) then (     q := q/(p) ; 
     p := 1 ) else skip ; 
    var result : String ;
    if (not(is2Fac(q))) then (     result := "impossible" ) else (     while (p > 1) do (     q := q/(2) ; 
     p := p/(2) ) ; 
     result := "" + count(q) ) ;  
    OclFile["System.out"].println(p + "/" + q) ; 
    skip ; 
    skip ; 
    OclFile["System.out"].println(result) ; 
 )  ;     testNo := testNo + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation count( q : long) : int
  pre: true
  post: true
  activity: (     var total : int ; total := 0 ;
     while (q > 1) do (     q := q/(2) ; 
     total := total + 1 ) ; 
     return total );
  static   operation is2Fac( q : long) : boolean
  pre: true
  post: true
  activity: (     while (q > 1) do (     if (q mod 2 = 0) then (     q := q/(2) ) else (     return false ) ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.HashSet ;
import java.util.Set ;
public class CodeJam2014R1C1 {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("A-large.in")));
      PrintWriter pw=new PrintWriter(new FileOutputStream("A-large.out"));
      String line=br.readLine();
      int T=Integer.parseInt(line);
      for(int i=0 ; i<T ; i++){
        System.out.println((i+1)+"/"+T+"...");
        line=br.readLine();
        String[] values=line.split("/");
        long P=Long.parseLong(values[0]);
        long Q=Long.parseLong(values[1]);
        long cmmdc=cmmdc(P,Q);
        P/=cmmdc ;
        Q/=cmmdc ;
        System.out.println(cmmdc);
        int total=0 ;
        while(P<Q){
          P*=2 ;
          total++;
        }
        int result=total ;
        while(P % Q!=0 && result<40){
          P*=2 ;
          result++;
        }
        if(P % Q==0){
          pw.println("Case #"+(i+1)+": "+total);
        }
        else {
          pw.println("Case #"+(i+1)+": impossible");
        }
      }
      pw.close();
      System.out.println("DONE");
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  private static long cmmdc(long P,long Q){
    return Q==0 ? P : cmmdc(Q,P % Q);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeJam2014R1C1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("A-large.in")))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("A-large.out"))) ;
    var line : String ; line := br.readLine() ;
    var T : int ; T := (line)->toInteger() ;
        var i : int ; i := 0 ; while i < T do ( (     OclFile["System.out"].println((i + 1) + "/" + T + "...") ; 
     line := br.readLine() ; 
    var values : Sequence(String) ; values := line->split("/") ;
    var P : long ; P := (values[0+1])->toLong() ;
    var Q : long ; Q := (values[1+1])->toLong() ;
    var cmmdc : long ; cmmdc := cmmdc(P, Q) ;
    P := P/(cmmdc) ; 
    Q := Q/(cmmdc) ; 
    OclFile["System.out"].println(cmmdc) ; 
    var total : int ; total := 0 ;
    while (P < Q) do (     P := P*(2) ; 
     total := total + 1 ) ; 
    var result : int ; result := total ;
    while (P mod Q /= 0 & result < 40) do (     P := P*(2) ; 
     result := result + 1 ) ; 
    if (P mod Q = 0) then (     skip ) else (     skip ) ;  
 )  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.out"].println("DONE") ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
  static   operation cmmdc( P : long, Q : long) : long
  pre: true
  post: true
  activity: (     return if Q = 0 then P else cmmdc(Q, P mod Q) endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static double surface_area_octahedron(double side){
    return(2*(Math.sqrt(3))*(side*side));
  }
  public static void main(String[] args){
    double side=7 ;
    System.out.println("Surface area of octahedron="+surface_area_octahedron(side));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation surface_area_octahedron( side : double) : double
  pre: true
  post: true
  activity: (     return (2 * ((3)->sqrt()) * (side * side)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var side : double ; side := 7 ;
     OclFile["System.out"].println("Surface area of octahedron=" + surface_area_octahedron(side)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class Temp {
  static PrintWriter w=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    long n=sc.nextInt(),q=sc.nextInt();
    while(q-->0){
      long x=sc.nextInt(),y=sc.nextInt();
      long ans=((x-1)*n+y+1)/2 ;
      if((x+y)% 2==0)w.println(ans);
      else w.println(((n*n+1)/2)+ans);
    }
    w.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Temp {
  static   attribute w : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toInteger() ;
    var q : long ; q := sc.getCurrent()->toInteger() ;
         while (q > 0) do (        q := q - 1 ;     skip ; (     var x : long ; x := sc.getCurrent()->toInteger() ;
    var y : long ; y := sc.getCurrent()->toInteger() ;
     var ans : long ; ans := ((x - 1) * n + y + 1) / 2 ;
     if ((x + y) mod 2 = 0) then     skip ; else     skip ; ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int solve(String test,int MOD){
    int size=test.length();
    int total=0 ;
    for(int i=0 ; i<=8 ; i++){
      int x=i ;
      int y=i+1 ;
      String newtest="" ;
      for(int j=0 ; j<size ; j++){
        if(test.charAt(j)==x+48 || test.charAt(j)==y+48){
          newtest+=test.charAt(j);
        }
      }
      if(newtest.length()>0){
        int size1=newtest.length();
        int[] prefix=new int[size1];
        for(int j=0 ; j<size1 ; j++){
          prefix[j]=0 ;
          if(newtest.charAt(j)==y+48){
            prefix[j]++;
          }
        }
        for(int j=1 ; j<size1 ; j++){
          prefix[j]+=prefix[j-1];
        }
        int count=0 ;
        int firstcount=0 ;
        int ss=0 ;
        int prev=0 ;
        for(int j=0 ; j<size1 ; j++){
          if(newtest.charAt(j)==x+48){
            count++;
            firstcount++;
          }
          else {
            ss+=count*count ;
            int pairsum=(firstcount*firstcount-ss)/2 ;
            int temp=pairsum ;
            pairsum-=prev ;
            prev=temp ;
            int secondway=prefix[size1-1];
            if(j!=0)secondway-=prefix[j-1];
            int answer=count*(count-1)*secondway*(secondway-1);
            answer/=4 ;
            answer+=(pairsum*secondway*(secondway-1))/2 ;
            total+=answer ;
            count=0 ;
          }
        }
      }
    }
    return total ;
  }
  public static void main(String[] args){
    String test="13134422" ;
    int MOD=1000000007 ;
    System.out.println(solve(test,MOD));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( test : String, MOD : int) : int
  pre: true
  post: true
  activity: (     var size : int ; size := test->size() ;
     var total : int ; total := 0 ;
         var i : int ; i := 0 ; while i <= 8 do ( (     var x : int ; x := i ;
     var y : int ; y := i + 1 ;
    var newtest : String ; newtest := "" ;
        var j : int ; j := 0 ; while j < size do ( (     if (test->at(j+1) = x + 48 or test->at(j+1) = y + 48) then (     newtest := newtest+(test->at(j+1)) ) else skip )  ;     j := j + 1 ) ; 
    if (newtest->size() > 0) then (     var size1 : int ; size1 := newtest->size() ;
     var prefix : Sequence(int) ; prefix := Integer.subrange(1,size1)->collect(0) ;
        var j : int ; j := 0 ; while j < size1 do ( (     prefix[j+1] := 0 ; 
     if (newtest->at(j+1) = y + 48) then (     prefix[j+1] := prefix[j+1] + 1 ) else skip )  ;     j := j + 1 ) ; 
        var j : int ; j := 1 ; while j < size1 do ( (     prefix[j+1] := prefix[j+1]+(prefix[(j)->char2byte() - 1+1]) )  ;     j := j + 1 ) ; 
    var count : int ; count := 0 ;
    var firstcount : int ; firstcount := 0 ;
    var ss : int ; ss := 0 ;
    var prev : int ; prev := 0 ;
        var j : int ; j := 0 ; while j < size1 do ( (     if (newtest->at(j+1) = x + 48) then (     count := count + 1 ; 
     firstcount := firstcount + 1 ) else (     ss := ss+(count * count) ; 
     var pairsum : int ; pairsum := (firstcount * firstcount - ss) / 2 ;
    var temp : int ; temp := pairsum ;
    pairsum := pairsum-(prev) ; 
    prev := temp ; 
    var secondway : int ; secondway := prefix[size1 - 1+1] ;
    if (j /= 0) then     secondway := secondway-(prefix[(j)->char2byte() - 1+1]) ; else skip ; 
    var answer : int ; answer := count * (count - 1) * secondway * (secondway - 1) ;
    answer := answer/(4) ; 
    answer := answer+((pairsum * secondway * (secondway - 1)) / 2) ; 
    total := total+(answer) ; 
    count := 0 ; 
 ) )  ;     j := j + 1 ) ; 
 ) else skip ; 
 )  ;     i := i + 1 ) ; 
     return total );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var test : String ; test := "13134422" ;
     var MOD : int ; MOD := 1000000007 ;
     OclFile["System.out"].println(solve(test, MOD)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void checkEvenOdd(int[] arr,int n){
    for(int i=0 ; i<n ; i++){
      if(arr[i] % 2==0){
        System.out.print("Even");
        return ;
      }
    }
    System.out.println("Odd");
  }
  public static void main(String[] args){
    int[] arr={
      2,12,20,36,38 };
      int n=arr.length ;
      checkEvenOdd(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkEvenOdd( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 = 0) then (     OclFile["System.out"].print("Even") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Odd") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,12,20,36,38} ;
     var n : int ; n := arr->size() ;
     execute checkEvenOdd(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printGroups(int n,int a[]){
    int ct[]=new int[7],grps=n/3,i ;
    for(i=0 ; i<n ; i++){
      ct[a[i] ]++;
    }
    if(ct[1]!=grps ||(ct[4]+ct[6])!=grps ||(ct[2]+ct[3])!=grps || ct[4]>ct[2]){
      System.out.print(-1);
      return ;
    }
    for(i=0 ; i<ct[4]; i++){
      System.out.print("1 2 4\n");
    }
    for(i=0 ; i<ct[2]-ct[4]; i++){
      System.out.print("1 2 6\n");
    }
    for(i=0 ; i<ct[3]; i++){
      System.out.print("1 3 6\n");
    }
  }
  public static void main(String[] args){
    int n=6 ;
    int a[]={
      2,2,1,1,4,6 };
      printGroups(n,a);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printGroups( n : int, a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var ct : Sequence(void) ; ct := Integer.subrange(1,7)->collect(0) ;
    var grps : int ; grps := n / 3 ;
    var i : int ;
         i := 0 ; while i < n do ( (     ct[a[i+1]+1] := ct[a[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    if (ct[1+1] /= grps or (ct[4+1] + ct[6+1]) /= grps or (ct[2+1] + ct[3+1]) /= grps or ct[4+1] > ct[2+1]) then (     OclFile["System.out"].print(-1) ; 
     return ) else skip ; 
        i := 0 ; while i < ct[4+1] do ( (     OclFile["System.out"].print("1 2 4\n") )  ;     i := i + 1 ) ; 
        i := 0 ; while i < ct[2+1] - ct[4+1] do ( (     OclFile["System.out"].print("1 2 6\n") )  ;     i := i + 1 ) ; 
        i := 0 ; while i < ct[3+1] do ( (     OclFile["System.out"].print("1 3 6\n") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     var a : Sequence(int) ; a := Sequence{2,2,1,1,4,6} ;
     execute printGroups(n, a) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static int first(int a,int b,int c){
    a %=b ;
    for(int i=1 ; i<=b ; i++){
      a=a*10 ;
      if(a/b==c)return i ;
      a %=b ;
    }
    return-1 ;
  }
  public static void main(String argc[]){
    int a=1,b=4,c=5 ;
    System.out.println(first(a,b,c));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation first( a : int, b : int, c : int) : int
  pre: true
  post: true
  activity: (     a := a mod b ; 
         var i : int ; i := 1 ; while i <= b do ( (     a := a * 10 ; 
     if (a / b = c) then     return i else skip ; 
     a := a mod b )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 1 ;
    var b : int ; b := 4 ;
    var c : int ; c := 5 ;
     OclFile["System.out"].println(first(a, b, c)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.concurrent.ConcurrentHashMap ;
class GFG {
  static int getMinCost(int arr[],int n,int cost[]){
    Map<Integer,Integer>mp=new ConcurrentHashMap<Integer,Integer>();
    mp.clear();
    mp.put(0,0);
    for(int i=0 ; i<n ; i++){
      for(Map.Entry<Integer,Integer>it : mp.entrySet()){
        int gcd=__gcd(arr[i],it.getKey());
        if(mp.containsKey(gcd))mp.put(gcd,Math.min(mp.get(gcd),it.getValue()+cost[i]));
        else mp.put(gcd,it.getValue()+cost[i]);
      }
    }
    if(! mp.containsKey(1))return-1 ;
    else return mp.get(1);
  }
  static int __gcd(int a,int b){
    return b==0 ? a : __gcd(b,a % b);
  }
  public static void main(String[] args){
    int arr[]={
      5,10,12,1 };
      int cost[]={
        2,1,2,6 };
        int n=arr.length ;
        System.out.print(getMinCost(arr,n,cost));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getMinCost( arr : Sequence(int), n : int, cost : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := ConcurrentHashMap<int,int>.newConcurrentHashMap() ;
     mp := mp->intersection(Map{}) ; 
    mp := mp->union(Map{0 |-> 0}) ; 
        var i : int ; i := 0 ; while i < n do ( (     for (it : mp->asSet()) do ( (     var gcd : int ; gcd := __gcd(arr[i+1], it.getKey()) ;
     if (mp->keys()->includes(gcd)) then     mp := mp->union(Map{gcd |-> Set{mp->at(gcd), it.getValue() + cost[i+1]}->min()}) ; else     mp := mp->union(Map{gcd |-> it.getValue() + cost[i+1]}) ; )  ) )  ;     i := i + 1 ) ; 
    if (not(mp->keys()->includes(1))) then     return -1 else     return mp->at(1) ;  
 );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else __gcd(b, a mod b) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,10,12,1} ;
     var cost : Sequence(int) ; cost := Sequence{2,1,2,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(getMinCost(arr, n, cost)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void towerOfHanoi(int n,char from_rod,char to_rod,char aux_rod1,char aux_rod2){
    if(n==0)return ;
    if(n==1){
      System.out.println("Move disk "+n+" from rod "+from_rod+" to rod "+to_rod);
      return ;
    }
    towerOfHanoi(n-2,from_rod,aux_rod1,aux_rod2,to_rod);
    System.out.println("Move disk "+(n-1)+" from rod "+from_rod+" to rod "+aux_rod2);
    System.out.println("Move disk "+n+" from rod "+from_rod+" to rod "+to_rod);
    System.out.println("Move disk "+(n-1)+" from rod "+aux_rod2+" to rod "+to_rod);
    towerOfHanoi(n-2,aux_rod1,to_rod,from_rod,aux_rod2);
  }
  public static void main(String args[]){
    int n=4 ;
    towerOfHanoi(n,'A','D','B','C');
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation towerOfHanoi( n : int, from_rod : String, to_rod : String, aux_rod1 : String, aux_rod2 : String) : void
  pre: true
  post: true
  activity: (     if (n = 0) then     return else skip ; 
     if (n = 1) then (     OclFile["System.out"].println("Move disk " + n + " from rod " + from_rod + " to rod " + to_rod) ; 
     return ) else skip ; 
    execute towerOfHanoi(n - 2, from_rod, aux_rod1, aux_rod2, to_rod) ; 
    OclFile["System.out"].println("Move disk " + (n - 1) + " from rod " + from_rod + " to rod " + aux_rod2) ; 
    OclFile["System.out"].println("Move disk " + n + " from rod " + from_rod + " to rod " + to_rod) ; 
    OclFile["System.out"].println("Move disk " + (n - 1) + " from rod " + aux_rod2 + " to rod " + to_rod) ; 
    execute towerOfHanoi(n - 2, aux_rod1, to_rod, from_rod, aux_rod2) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     execute towerOfHanoi(n, 'A', 'D', 'B', 'C') );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int N=4 ;
  static boolean isDiagonalMatrix(int mat[][]){
    for(int i=0 ; i<N ; i++)for(int j=0 ; j<N ; j++)if((i!=j)&&(mat[i][j]!=0))return false ;
    return true ;
  }
  public static void main(String args[]){
    int mat[][]={
      {
        4,0,0,0 },{
          0,7,0,0 },{
            0,0,5,0 },{
              0,0,0,1 }
            };
            if(isDiagonalMatrix(mat))System.out.println("Yes");
            else System.out.println("No");
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 4;
  static   operation isDiagonalMatrix( mat : Sequence(Sequence(int))) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do (         var j : int ; j := 0 ; while j < N do (     if ((i /= j) & (mat[i+1][j+1] /= 0)) then     return false else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{4,0,0,0},Sequence{0,7,0,0},Sequence{0,0,5,0},Sequence{0,0,0,1}} ;
     if (isDiagonalMatrix(mat)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class gfg {
  public void decToBinary(int n){
    for(int i=31 ; i>=0 ; i--){
      int k=n>>i ;
      if((k & 1)>0)System.out.print("1");
      else System.out.print("0");
    }
  }
}
class geek {
  public static void main(String[] args){
    gfg g=new gfg();
    int n=32 ;
    g.decToBinary(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class gfg {
   operation decToBinary( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 31 ; while i >= 0 do ( (     var k : int ; k := (n/(2->pow(i)))->oclAsType(long) ;
     if ((MathLib.bitwiseAnd(k,1)) > 0) then     OclFile["System.out"].print("1") ; else     OclFile["System.out"].print("0") ; )  ;     i := i - 1 ) );
}
 class geek {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : gfg ; g := gfg.newgfg() ;
     var n : int ; n := 32 ;
     g.decToBinary(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int LongestSubarray(int a[],int n,int k){
    int[] pre=new int[n];
    for(int i=0 ; i<n ; i++){
      if(a[i]>k)pre[i]=1 ;
      else pre[i]=-1 ;
    }
    for(int i=1 ; i<n ; i++)pre[i]=pre[i-1]+pre[i];
    int len=0 ;
    int lo=1,hi=n ;
    while(lo<=hi){
      int mid=(lo+hi)/2 ;
      boolean ok=false ;
      for(int i=mid-1 ; i<n ; i++){
        int x=pre[i];
        if(i-mid>=0)x-=pre[i-mid];
        if(x>0){
          ok=true ;
          break ;
        }
      }
      if(ok==true){
        len=mid ;
        lo=mid+1 ;
      }
      else hi=mid-1 ;
    }
    return len ;
  }
  public static void main(String[] args){
    int a[]={
      2,3,4,5,3,7 };
      int k=3 ;
      int n=a.length ;
      System.out.println(LongestSubarray(a,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation LongestSubarray( a : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var pre : Sequence(int) ; pre := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] > k) then     pre[i+1] := 1 ; else     pre[i+1] := -1 ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do (     pre[i+1] := pre[i - 1+1] + pre[i+1] ;  ;     i := i + 1 ) ; 
    var len : int ; len := 0 ;
    var lo : int ; lo := 1 ;
    var hi : int ; hi := n ;
    while (lo <= hi) do (     var mid : int ; mid := (lo + hi) / 2 ;
     var ok : boolean ; ok := false ;
         var i : int ; i := mid - 1 ; while i < n do ( (     var x : int ; x := pre[i+1] ;
     if (i - mid >= 0) then     x := x-(pre[i - mid+1]) ; else skip ; 
     if (x > 0) then (     ok := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (ok = true) then (     len := mid ; 
     lo := mid + 1 ) else     hi := mid - 1 ; ) ; 
    return len 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,3,4,5,3,7} ;
     var k : int ; k := 3 ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(LongestSubarray(a, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeFortyNine {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int x1=input.nextInt();
    int y1=input.nextInt();
    int n=input.nextInt();
    double time=10000000 ;
    double[][] arrayOne=new double[n][3];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<3 ; j++){
        arrayOne[i][j]=input.nextDouble();
      }
    }
    for(int i=0 ; i<n ; i++){
      double k1=Math.abs((arrayOne[i][0]-x1));
      double k2=Math.abs((arrayOne[i][1])-y1);
      double distance=Math.pow(((k1*k1)+(k2*k2)),0.5);
      double p=(distance)/(arrayOne[i][2]);
      if(p<time){
        time=p ;
      }
    }
    System.out.println(time);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeFortyNine {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : int ; x1 := input.getCurrent()->toInteger() ;
    var y1 : int ; y1 := input.getCurrent()->toInteger() ;
    var n : int ; n := input.getCurrent()->toInteger() ;
    var time : double ; time := 10000000 ;
    var arrayOne : Sequence(Sequence(double)) ; arrayOne := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 3 do ( (     arrayOne[i+1][j+1] := input.getCurrent()->toReal() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var k1 : double ; k1 := if (arrayOne[i+1][0+1] - x1) < 0 then -((arrayOne[i+1][0+1] - x1)) else (arrayOne[i+1][0+1] - x1) endif ;
     var k2 : double ; k2 := if (arrayOne[i+1][1+1]) - y1 < 0 then -((arrayOne[i+1][1+1]) - y1) else (arrayOne[i+1][1+1]) - y1 endif ;
    var distance : double ; distance := ((k1 * k1) + (k2 * k2))->pow(0.5) ;
    var p : double ; p := (distance) / (arrayOne[i+1][2+1]) ;
    if (p < time) then (     time := p ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(time) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Beru_taxi {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    int n=sc.nextInt();
    double min=1000 ;
    for(int i=0 ; i<n ; i++){
      int x1=sc.nextInt();
      int y1=sc.nextInt();
      double v=sc.nextDouble();
      double t=Math.sqrt((Math.abs(x-x1)*Math.abs(x-x1))+(Math.abs(y-y1)*Math.abs(y-y1)));
      t=t/v ;
      if(t<min){
        min=t ;
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Beru_taxi {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var min : double ; min := 1000 ;
        var i : int ; i := 0 ; while i < n do ( (     var x1 : int ; x1 := sc.getCurrent()->toInteger() ;
     var y1 : int ; y1 := sc.getCurrent()->toInteger() ;
    var v : double ; v := sc.getCurrent()->toReal() ;
    var t : double ; t := ((if x - x1 < 0 then -(x - x1) else x - x1 endif * if x - x1 < 0 then -(x - x1) else x - x1 endif) + (if y - y1 < 0 then -(y - y1) else y - y1 endif * if y - y1 < 0 then -(y - y1) else y - y1 endif))->sqrt() ;
    t := t / v ; 
    if (t < min) then (     min := t ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B1027 {
  public static void main(String[] args){
    PrintWriter print=new PrintWriter(System.out);
    Scanner scan=new Scanner(System.in);
    long sq=scan.nextLong();
    int num=scan.nextInt();
    int a,b ;
    long add=(sq*sq+1)/2,res ;
    for(int i=0 ; i<num ; i++){
      a=scan.nextInt();
      b=scan.nextInt();
      res=((a-1)*sq+b+1)/2 ;
      if((a+b)% 2!=0)res+=add ;
      print.println(res);
    }
    print.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1027 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var print : OclFile ; print := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var sq : long ; sq := scan.getCurrent()->toLong() ;
    var num : int ; num := scan.getCurrent()->toInteger() ;
    var a : int ;
    var b : int ;
    var add : long ; add := (sq * sq + 1) / 2 ;
    var res : long ;
        var i : int ; i := 0 ; while i < num do ( (     a := scan.getCurrent()->toInteger() ; 
     b := scan.getCurrent()->toInteger() ; 
    res := ((a - 1) * sq + b + 1) / 2 ; 
    if ((a + b) mod 2 /= 0) then     res := res+(add) ; else skip ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.event.MouseAdapter ;
import java.lang.reflect.Array ;
import java.util.*;
import java.io.*;
public class Yahia {
  public static void main(String[] args)throws IOException,InterruptedException {
    Scanner sc=new Scanner(System.in);
    double x=sc.nextInt(),y=sc.nextDouble(),min=Double.MAX_VALUE,dx,dy,dt,t,v ;
    int n=sc.nextInt();
    while(n-->0){
      dx=(sc.nextDouble()-x);
      dy=sc.nextDouble()-y ;
      v=sc.nextDouble();
      dt=Math.sqrt(dx*dx+dy*dy);
      t=dt/v ;
      min=Math.min(min,t);
    }
    System.out.println(min);
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream system){
      br=new BufferedReader(new InputStreamReader(system));
    }
    public Scanner(String file)throws Exception {
      br=new BufferedReader(new FileReader(file));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public char nextChar()throws IOException {
      return next().charAt(0);
    }
    public Long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
    public void waitForInput()throws InterruptedException {
      Thread.sleep(3000);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Yahia {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : double ; x := sc.getCurrent()->toInteger() ;
    var y : double ; y := sc.getCurrent()->toReal() ;
    var min : double ; min := (2 - 2->pow(-52))*(2->pow(1023)) ;
    var dx : double ;
    var dy : double ;
    var dt : double ;
    var t : double ;
    var v : double ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     dx := (sc.getCurrent()->toReal() - x) ; 
     dy := sc.getCurrent()->toReal() - y ; 
    v := sc.getCurrent()->toReal() ; 
    dt := (dx * dx + dy * dy)->sqrt() ; 
    t := dt / v ; 
    min := Set{min, t}->min() ; 
 ) ;  ) ;  
    OclFile["System.out"].println(min) ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( system : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(system);
    return self );
  operation initialise( system : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(system)) );
   static operation newScanner( file : String) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
   operation waitForInput() : void
  pre: true
  post: true
  activity: (     OclProcess.sleep(3000) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class ladyChimp {
  static cord house ;
  public static class cord {
    int x,y ;
    cord(int x,int y){
      this.x=x ;
      this.y=y ;
    }
    public double getTime(int speed){
      return(Math.sqrt(Math.pow(house.x-this.x,2)+Math.pow(house.y-this.y,2)))/speed ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    house=new cord(sc.nextInt(),sc.nextInt());
    int n=sc.nextInt();
    double ans=Double.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      cord temp=new cord(sc.nextInt(),sc.nextInt());
      ans=Math.min(ans,temp.getTime(sc.nextInt()));
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ladyChimp {
  static   attribute house : cord;
  static class cord {
   attribute x : int;
   static operation newcord( x : int, y : int) : cord
  pre: true
  post: true
  activity:
  ( var self : cord ;
    self := createcord();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation getTime( speed : int) : double
  pre: true
  post: true
  activity: (     return ((house.x - self.x->pow(2) + house.y - self.y->pow(2))->sqrt()) / speed );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     house := cord.newcord(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : double ; ans := (2 - 2->pow(-52))*(2->pow(1023)) ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : cord ; temp := cord.newcord(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) ;
     ans := Set{ans, temp.getTime(sc.getCurrent()->toInteger())}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int a=sc.nextInt(),b=sc.nextInt();
    int n=sc.nextInt();
    double ans=Double.MAX_VALUE ;
    while(n-->0)ans=Math.min(ans,dist(a,sc.nextInt(),b,sc.nextInt())/sc.nextInt());
    out.println(ans);
    out.flush();
    out.close();
  }
  static double dist(int x1,int x2,int y1,int y2){
    return Math.sqrt(sq(x1-x2)+sq(y1-y2));
  }
  static int sq(int x){
    return x*x ;
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(FileReader r){
      br=new BufferedReader(r);
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : double ; ans := (2 - 2->pow(-52))*(2->pow(1023)) ;
        while (n > 0) do (        n := n - 1 ;     skip ;     ans := Set{ans, dist(a, sc.getCurrent()->toInteger(), b, sc.getCurrent()->toInteger()) / sc.getCurrent()->toInteger()}->min() ; ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation dist( x1 : int, x2 : int, y1 : int, y2 : int) : double
  pre: true
  post: true
  activity: (     return (sq(x1 - x2) + sq(y1 - y2))->sqrt() );
  static   operation sq( x : int) : int
  pre: true
  post: true
  activity: (     return x * x );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( r : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(r);
    return self );
  operation initialise( r : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(r) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Sample {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int cx=0,ct=0,dy=0,dt=0 ;
    while(n--!=0){
      int t=sc.nextInt();
      int x=sc.nextInt();
      int y=sc.nextInt();
      if(t==1){
        cx=cx+x ;
        ct=ct+x+y ;
      }
      else {
        dy=dy+x ;
        dt=dt+x+y ;
      }
    }
    if(cx>=ct/2){
      System.out.println("LIVE");
    }
    else {
      System.out.println("DEAD");
    }
    if(dy>=dt/2){
      System.out.println("LIVE");
    }
    else {
      System.out.println("DEAD");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sample {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var cx : int ; cx := 0 ;
    var ct : int ; ct := 0 ;
    var dy : int ; dy := 0 ;
    var dt : int ; dt := 0 ;
        while (n /= 0) do (    skip ; (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     if (t = 1) then (     cx := cx + x ; 
     ct := ct + x + y ) else (     dy := dy + x ; 
     dt := dt + x + y ) ) ;  ) ;  
    if (cx >= ct / 2) then (     OclFile["System.out"].println("LIVE") ) else (     OclFile["System.out"].println("DEAD") ) ;  
    if (dy >= dt / 2) then (     OclFile["System.out"].println("LIVE") ) else (     OclFile["System.out"].println("DEAD") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  static final String[] timeClass={
    "AAA","AA","A","B","C","D","E","NA" };
    static final double[][] timeTable={
      {
        35.5,71.0 },{
          37.5,77.0 },{
            40.0,83.0 },{
              43.0,89.0 },{
                50.0,105.0 },{
                  55.0,116.0 },{
                    70.0,148.0 }
                  };
                  public static void main(String[] args)throws IOException {
                    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
                    String buf=null ;
                    while((buf=br.readLine())!=null){
                      String[] time=buf.split(" ");
                      System.out.println(judgeClass(Double.parseDouble(time[0]),Double.parseDouble(time[1])));
                    }
                  }
                  public static String judgeClass(double timeOf500m,double timeOf1000m){
                    for(int timeClassOf500m=0 ; timeClassOf500m<timeTable.length ; timeClassOf500m++){
                      if(timeOf500m<timeTable[timeClassOf500m][0])for(int timeClassOf1000m=timeClassOf500m ;
                      timeClassOf1000m<timeTable.length ;
                      timeClassOf1000m++){
                        if(timeOf1000m<timeTable[timeClassOf1000m][1]){
                          return timeClass[timeClassOf1000m];
                        }
                      }
                    }
                    return timeClass[timeClass.length-1];
                  }
                }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute timeClass : Sequence(String) := Sequence{"AAA","AA","A","B","C","D","E","NA"};
  static    attribute timeTable : Sequence(Sequence(double)) := Sequence{Sequence{35.5,71.0},Sequence{37.5,77.0},Sequence{40.0,83.0},Sequence{43.0,89.0},Sequence{50.0,105.0},Sequence{55.0,116.0},Sequence{70.0,148.0}};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var buf : String ; buf := null ;
         buf := br.readLine() ;
    while ((buf) /= null) do (    skip ; (     var time : Sequence(String) ; time := buf->split(" ") ;
     OclFile["System.out"].println(judgeClass((time[0+1])->toReal(), (time[1+1])->toReal())) ) ;     buf := br.readLine() ;
 ) );
  static   operation judgeClass( timeOf500m : double, timeOf1000m : double) : String
  pre: true
  post: true
  activity: (         var timeClassOf500m : int ; timeClassOf500m := 0 ; while timeClassOf500m < timeTable->size() do ( (     if (timeOf500m < timeTable[timeClassOf500m+1][0+1]) then         var timeClassOf1000m : int ; timeClassOf1000m := timeClassOf500m ; while timeClassOf1000m < timeTable->size() do ( (     if (timeOf1000m < timeTable[timeClassOf1000m+1][1+1]) then (     return timeClass[timeClassOf1000m+1] ) else skip )  ;     timeClassOf1000m := timeClassOf1000m + 1 ) ; else skip )  ;     timeClassOf500m := timeClassOf500m + 1 ) ; 
     return timeClass[timeClass->size() - 1+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SystemAdministrator {
  public static void print(int pingX,int pingY){
    if(pingX>=pingY){
      System.out.println("LIVE");
    }
    else System.out.println("DEAD");
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int pingAx=0 ;
    int pingAy=0 ;
    int pingBx=0 ;
    int pingBy=0 ;
    for(int i=0 ; i<N ; i++){
      int ping=scanner.nextInt();
      if(ping==1){
        pingAx=pingAx+scanner.nextInt();
        pingAy=pingAy+scanner.nextInt();
      }
      else {
        pingBx=pingBx+scanner.nextInt();
        pingBy=pingBy+scanner.nextInt();
      }
    }
    print(pingAx,pingAy);
    print(pingBx,pingBy);
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class SystemAdministrator {
  static   operation print( pingX : int, pingY : int) : void
  pre: true
  post: true
  activity: (     if (pingX >= pingY) then (     OclFile["System.out"].println("LIVE") ) else     OclFile["System.out"].println("DEAD") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var pingAx : int ; pingAx := 0 ;
    var pingAy : int ; pingAy := 0 ;
    var pingBx : int ; pingBx := 0 ;
    var pingBy : int ; pingBy := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var ping : int ; ping := scanner.getCurrent()->toInteger() ;
     if (ping = 1) then (     pingAx := pingAx + scanner.getCurrent()->toInteger() ; 
     pingAy := pingAy + scanner.getCurrent()->toInteger() ) else (     pingBx := pingBx + scanner.getCurrent()->toInteger() ; 
     pingBy := pingBy + scanner.getCurrent()->toInteger() ) )  ;     i := i + 1 ) ; 
    execute print(pingAx, pingAy) ; 
    execute print(pingBx, pingBy) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner cv=new Scanner(System.in);
    int n=cv.nextInt();
    int sum1=0,sum2=0 ;
    int a,b,c ;
    for(int i=0 ; i<n ; i++){
      a=cv.nextInt();
      b=cv.nextInt();
      c=cv.nextInt();
      if(a==1)sum1+=b-c ;
      else sum2+=b-c ;
    }
    System.out.println(sum1>=0 ? "LIVE" : "DEAD");
    System.out.println(sum2>=0 ? "LIVE" : "DEAD");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cv : OclFile ; cv := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := cv.getCurrent()->toInteger() ;
    var sum1 : int ; sum1 := 0 ;
    var sum2 : int ; sum2 := 0 ;
    var a : int ;
    var b : int ;
    var c : int ;
        var i : int ; i := 0 ; while i < n do ( (     a := cv.getCurrent()->toInteger() ; 
     b := cv.getCurrent()->toInteger() ; 
     c := cv.getCurrent()->toInteger() ; 
     if (a = 1) then     sum1 := sum1+(b - c) ; else     sum2 := sum2+(b - c) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if sum1 >= 0 then "LIVE" else "DEAD" endif) ; 
    OclFile["System.out"].println(if sum2 >= 0 then "LIVE" else "DEAD" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SystemAdministrator {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[][] servers=new int[2][2];
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int server=sc.nextInt()-1 ;
      int alive=sc.nextInt();
      int lost=sc.nextInt();
      servers[server][0]+=alive ;
      servers[server][1]+=lost ;
    }
    for(int s=0 ; s<2 ; s++){
      System.out.println(servers[s][0]>=servers[s][1] ? "LIVE" : "DEAD");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SystemAdministrator {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var servers : Sequence(Sequence(int)) ; servers := Integer.subrange(1,2)->collect(Integer.subrange(1,2)->collect(0)) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var server : int ; server := sc.getCurrent()->toInteger() - 1 ;
     var alive : int ; alive := sc.getCurrent()->toInteger() ;
    var lost : int ; lost := sc.getCurrent()->toInteger() ;
    servers[server+1][0+1] := servers[server+1][0+1]+(alive) ; 
    servers[server+1][1+1] := servers[server+1][1+1]+(lost) ; 
 )  ;     i := i + 1 ) ; 
        var s : int ; s := 0 ; while s < 2 do ( (     OclFile["System.out"].println(if servers[s+1][0+1] >= servers[s+1][1+1] then "LIVE" else "DEAD" endif) )  ;     s := s + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] units ;
    int an,ad,bn,bd ;
    an=0 ;
    ad=1 ;
    bn=0 ;
    bd=1 ;
    line=br.readLine();
    units=line.split("[()] ");
    if(units.length==2){
      bn=parseInt(units[1]);
      bd=((int)Math.pow(10,units[1] .length()))-1 ;
    }
    units=units[0] .split("\\.");
    if(units.length==2){
      bd*=(int)Math.pow(10,units[1] .length());
      an=parseInt(units[0]+units[1]);
      ad=(int)Math.pow(10,units[1] .length());
    }
    else {
      an=parseInt(units[0]);
    }
    int n,d,g ;
    d=lcm(ad,bd);
    n=an*(d/ad)+bn*d/bd ;
    g=gcd(n,d);
    n/=g ;
    d/=g ;
    System.out.printf("%d/%d\n",n,d);
  }
  static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  static int lcm(int a,int b){
    return a*(b/gcd(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var units : Sequence(String) ;
    var an : int ;
    var ad : int ;
    var bn : int ;
    var bd : int ;
    an := 0 ; 
    ad := 1 ; 
    bn := 0 ; 
    bd := 1 ; 
    line := br.readLine() ; 
    units := line->split("[()] ") ; 
    if (units->size() = 2) then (     bn := (units[1+1] + "")->toInteger() ; 
     bd := (10->pow(units[1+1]->size())->oclAsType(int)) - 1 ) else skip ; 
    units := units[0+1]->split("\\.") ; 
    if (units->size() = 2) then (     bd := bd*(10->pow(units[1+1]->size())->oclAsType(int)) ; 
     an := (units[0+1] + units[1+1] + "")->toInteger() ; 
     ad := 10->pow(units[1+1]->size())->oclAsType(int) ) else (     an := (units[0+1] + "")->toInteger() ) ;  
    var n : int ;
    var d : int ;
    var g : int ;
    d := lcm(ad, bd) ; 
    n := an * (d / ad) + bn * d / bd ; 
    g := gcd(n, d) ; 
    n := n/(g) ; 
    d := d/(g) ; 
    OclFile["System.out"].printf("%d/%d\n", n, d) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return a * (b / gcd(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int ans=3 ;
    double d=Double.MAX_VALUE ;
    for(int i=3 ; i<=n ; i++){
      if(d>Math.abs((180.0*(i-2))/n-a)){
        d=Math.abs((180.0*(i-2))/n-a);
        ans=i ;
      }
    }
    System.out.println("2 1 "+ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 3 ;
    var d : double ; d := (2 - 2->pow(-52))*(2->pow(1023)) ;
        var i : int ; i := 3 ; while i <= n do ( (     if (d > if (180.0 * (i - 2)) / n - a < 0 then -((180.0 * (i - 2)) / n - a) else (180.0 * (i - 2)) / n - a endif) then (     d := if (180.0 * (i - 2)) / n - a < 0 then -((180.0 * (i - 2)) / n - a) else (180.0 * (i - 2)) / n - a endif ; 
     ans := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("2 1 " + ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
public class Main {
  static int countSubarrWithEqualZeroAndOne(int[] arr,int n){
    Map<Integer,Integer>myMap=new HashMap<>();
    int sum=0 ;
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==0)arr[i]=-1 ;
      sum+=arr[i];
      if(sum==0)count++;
      if(myMap.containsKey(sum))count+=myMap.get(sum);
      if(! myMap.containsKey(sum))myMap.put(sum,1);
      else myMap.put(sum,myMap.get(sum)+1);
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      1,0,0,1,0,1,1 };
      int n=arr.length ;
      System.out.println("Count="+countSubarrWithEqualZeroAndOne(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation countSubarrWithEqualZeroAndOne( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var myMap : Map(int,int) ; myMap := Map{} ;
     var sum : int ; sum := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 0) then     arr[i+1] := -1 ; else skip ; 
     sum := sum+(arr[i+1]) ; 
    if (sum = 0) then     count := count + 1 ; else skip ; 
    if (myMap->keys()->includes(sum)) then     count := count+(myMap->at(sum)) ; else skip ; 
    if (not(myMap->keys()->includes(sum))) then     myMap := myMap->union(Map{sum |-> 1}) else     myMap := myMap->union(Map{sum |-> myMap->at(sum) + 1}) ; ;  
 )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,0,0,1,0,1,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Count=" + countSubarrWithEqualZeroAndOne(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean checkPattern(String str,String pattern){
    int len=pattern.length();
    if(str.length()<len){
      return false ;
    }
    for(int i=0 ; i<len-1 ; i++){
      char x=pattern.charAt(i);
      char y=pattern.charAt(i+1);
      int last=str.lastIndexOf(x);
      int first=str.indexOf(y);
      if(last==-1 || first==-1 || last>first){
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    String str="engineers rock" ;
    String pattern="gsr" ;
    System.out.println(checkPattern(str,pattern));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkPattern( str : String, pattern : String) : boolean
  pre: true
  post: true
  activity: (     var len : int ; len := pattern->size() ;
     if (str->size() < len) then (     return false ) else skip ; 
         var i : int ; i := 0 ; while i < len - 1 do ( (     var x : String ; x := pattern->at(i+1) ;
     var y : String ; y := pattern->at(i + 1+1) ;
    var last : int ; last := str->lastIndexOf(x)-1 ;
    var first : int ; first := str->indexOf(y)-1 ;
    if (last = -1 or first = -1 or last > first) then (     return false ) else skip ; 
 )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "engineers rock" ;
     var pattern : String ; pattern := "gsr" ;
     OclFile["System.out"].println(checkPattern(str, pattern)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.*;
import javafx.util.Pair ;
public class Main {
  public static void main(String args[]){
    FastScanner input=new FastScanner();
    int n=input.nextInt();
    int angle=input.nextInt();
    int ans=3 ;
    double dif=Double.MAX_VALUE ;
    for(int i=3 ; i<=n ; i++){
      if(dif>Math.abs((180.0*(i-2))/n-angle)){
        dif=Math.abs((180.0*(i-2))/n-angle);
        ans=i ;
      }
    }
    System.out.println("2 1 "+ans);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var n : int ; n := input.nextInt() ;
    var angle : int ; angle := input.nextInt() ;
    var ans : int ; ans := 3 ;
    var dif : double ; dif := (2 - 2->pow(-52))*(2->pow(1023)) ;
        var i : int ; i := 3 ; while i <= n do ( (     if (dif > if (180.0 * (i - 2)) / n - angle < 0 then -((180.0 * (i - 2)) / n - angle) else (180.0 * (i - 2)) / n - angle endif) then (     dif := if (180.0 * (i - 2)) / n - angle < 0 then -((180.0 * (i - 2)) / n - angle) else (180.0 * (i - 2)) / n - angle endif ; 
     ans := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("2 1 " + ans) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import javafx.util.Pair ;
public class CodeForce {
  static int[] dp=new int[2048];
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    String[] sr=br.readLine().split(" ");
    float n=next(sr,0);
    float a=next(sr,1);
    if(n==3){
      System.out.println("1 2 3");
      return ;
    }
    float angle=((n-2)*180)/n ;
    if(a>angle){
      System.out.println("1 2 3");
      return ;
    }
    float per_n=angle/(n-2);
    double close=Math.floor(a/per_n);
    if(close==0){
      System.out.println("1 2 "+(int)n);
      return ;
    }
    if(Math.abs(close*per_n-a)<Math.abs((close+1)*per_n-a)){
      System.out.println("1 2 "+(int)(n-(int)close+1));
    }
    else System.out.println("1 2 "+(int)(n-(int)close));
  }
  static int next(String[] sr,int ind){
    return Integer.parseInt(sr[ind]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForce {
  static   attribute dp : Sequence(int) := Integer.subrange(1,2048)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var sr : Sequence(String) ; sr := br.readLine()->split(" ") ;
    var n : double ; n := next(sr, 0) ;
    var a : double ; a := next(sr, 1) ;
    if (n = 3) then (     OclFile["System.out"].println("1 2 3") ; 
     return ) else skip ; 
    var angle : double ; angle := ((n - 2) * 180) / n ;
    if (a > angle) then (     OclFile["System.out"].println("1 2 3") ; 
     return ) else skip ; 
    var per_n : double ; per_n := angle / (n - 2) ;
    var close : double ; close := (a / per_n)->floor() ;
    if (close = 0) then (     OclFile["System.out"].println("1 2 " + n->oclAsType(int)) ; 
     return ) else skip ; 
    if (if close * per_n - a < 0 then -(close * per_n - a) else close * per_n - a endif < if (close + 1) * per_n - a < 0 then -((close + 1) * per_n - a) else (close + 1) * per_n - a endif) then (     OclFile["System.out"].println("1 2 " + (n - close->oclAsType(int) + 1)->oclAsType(int)) ) else     OclFile["System.out"].println("1 2 " + (n - close->oclAsType(int))->oclAsType(int)) ; ;  
 );
  static   operation next( sr : Sequence(String), ind : int) : int
  pre: true
  post: true
  activity: (     return (sr[ind+1])->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static double time_of_500m,time_of_1000m ;
  public static void main(String[] args){
    while(sc.hasNextDouble()){
      read();
      slove();
    }
  }
  static boolean read(){
    time_of_500m=sc.nextDouble();
    time_of_1000m=sc.nextDouble();
    return true ;
  }
  static void slove(){
    if(time_of_500m<35.5 && time_of_1000m<71.0){
      System.out.println("AAA");
    }
    else if(time_of_500m<37.5 && time_of_1000m<77.0){
      System.out.println("AA");
    }
    else if(time_of_500m<40.0 && time_of_1000m<83.0){
      System.out.println("A");
    }
    else if(time_of_500m<43.0 && time_of_1000m<89.0){
      System.out.println("B");
    }
    else if(time_of_500m<50.0 && time_of_1000m<105.0){
      System.out.println("C");
    }
    else if(time_of_500m<55.0 && time_of_1000m<116.0){
      System.out.println("D");
    }
    else if(time_of_500m<70.0 && time_of_1000m<148.0){
      System.out.println("E");
    }
    else {
      System.out.println("NA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute time_of_500m : double;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (sc.hasNextDouble()) do (     execute read() ; 
     execute slove() ) );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     time_of_500m := sc.getCurrent()->toReal() ; 
     time_oftime_of_1000m000m := sc.getCurrent()->toReal() ; 
     return true );
  static   operation slove() : void
  pre: true
  post: true
  activity: (     if (time_of_500m < 35.5 & time_of    if (time_of_500m < 35.5 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ; 000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of    if (time_of_500m < 35.5 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ; 000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of    if (time_of_500m < 35.5 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ; 000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of    if (time_of_500m < 35.5 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ; 000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of    if (time_of_500m < 35.5 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ; 000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of    if (time_of_500m < 35.5 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ; 000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of    if (time_of_500m < 35.5 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of    if (time_of_500m < 35.5 & time_of_1000m < 71.0) then (     OclFile["System.out"].println("AAA") ) else     if (time_of_500m < 37.5 & time_of_1000m < 77.0) then (     OclFile["System.out"].println("AA") ) else     if (time_of_500m < 40.0 & time_of_1000m < 83.0) then (     OclFile["System.out"].println("A") ) else     if (time_of_500m < 43.0 & time_of_1000m < 89.0) then (     OclFile["System.out"].println("B") ) else     if (time_of_500m < 50.0 & time_of_1000m < 105.0) then (     OclFile["System.out"].println("C") ) else     if (time_of_500m < 55.0 & time_of_1000m < 116.0) then (     OclFile["System.out"].println("D") ) else     if (time_of_500m < 70.0 & time_of_1000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ;  
000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  ; 000m < 148.0) then (     OclFile["System.out"].println("E") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  ;  ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigDecimal ;
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Stack ;
public class Solution {
  static int[] nodeColors ;
  static boolean[] visited ;
  static String[][] neighborstring ;
  static List<Integer>[] startIndices ;
  static int[] edgesToPrint ;
  static int mod=998244353 ;
  static int[] parents ;
  static HashSet<Integer>cycleSet ;
  static PriorityQueue<Integer>[] neighborPriority ;
  static int[] minPointsToEnterRoom ;
  static int[] maxPointsToEnterRoom ;
  static int[] pointOfEachRoom ;
  static List<Integer>[] neighbors ;
  static int[][] memo ;
  public static void main(String[] args)throws IOException {
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    String[] s=bufferedReader.readLine().split(" ");
    int no=Integer.parseInt(s[0]);
    int x=Integer.parseInt(s[1]);
    double smallest=180.0/no ;
    double diff=x/smallest ;
    long a=Math.round(diff);
    System.out.println("2"+" "+"1"+" "+(Math.min(Math.max(2+a,3),no)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute nodeColors : Sequence(int);
  static   attribute visited : Sequence(boolean);
  static   attribute neighborstring : Sequence(Sequence(String));
  static   attribute startIndices : Sequence(Sequence(int));
  static   attribute edgesToPrint : Sequence(int);
  static   attribute mod : int := 998244353;
  static   attribute parents : Sequence(int);
  static   attribute cycleSet : Set(int);
  static   attribute neighborPriority : Sequence(Sequence(int));
  static   attribute minPointsToEnterRoom : Sequence(int);
  static   attribute maxPointsToEnterRoom : Sequence(int);
  static   attribute pointOfEachRoom : Sequence(int);
  static   attribute neighbors : Sequence(Sequence(int));
  static   attribute memo : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : Sequence(String) ; s := bufferedReader.readLine()->split(" ") ;
    var no : int ; no := (s[0+1])->toInteger() ;
    var x : int ; x := (s[1+1])->toInteger() ;
    var smallest : double ; smallest := 180.0 / no ;
    var diff : double ; diff := x / smallest ;
    var a : long ; a := (diff)->round() ;
    OclFile["System.out"].println("2" + " " + "1" + " " + (Set{Set{2 + a, 3}->max(), no}->min())) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigDecimal ;
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Stack ;
public class Solution {
  static int[] nodeColors ;
  static boolean[] visited ;
  static String[][] neighborstring ;
  static List<Integer>[] startIndices ;
  static int[] edgesToPrint ;
  static int mod=998244353 ;
  static int[] parents ;
  static HashSet<Integer>cycleSet ;
  static PriorityQueue<Integer>[] neighborPriority ;
  static int[] minPointsToEnterRoom ;
  static int[] maxPointsToEnterRoom ;
  static int[] pointOfEachRoom ;
  static List<Integer>[] neighbors ;
  static int[][] memo ;
  public static void main(String[] args)throws IOException {
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    int c=Integer.parseInt(bufferedReader.readLine());
    String[] s=bufferedReader.readLine().split(" ");
    long sum=0 ;
    long max=0 ;
    for(String str : s){
      int no=Integer.parseInt(str);
      sum+=no ;
      max=Math.max(max,no);
    }
    System.out.println(2*max-sum+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute nodeColors : Sequence(int);
  static   attribute visited : Sequence(boolean);
  static   attribute neighborstring : Sequence(Sequence(String));
  static   attribute startIndices : Sequence(Sequence(int));
  static   attribute edgesToPrint : Sequence(int);
  static   attribute mod : int := 998244353;
  static   attribute parents : Sequence(int);
  static   attribute cycleSet : Set(int);
  static   attribute neighborPriority : Sequence(Sequence(int));
  static   attribute minPointsToEnterRoom : Sequence(int);
  static   attribute maxPointsToEnterRoom : Sequence(int);
  static   attribute pointOfEachRoom : Sequence(int);
  static   attribute neighbors : Sequence(Sequence(int));
  static   attribute memo : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var c : int ; c := (bufferedReader.readLine())->toInteger() ;
    var s : Sequence(String) ; s := bufferedReader.readLine()->split(" ") ;
    var sum : long ; sum := 0 ;
    var max : long ; max := 0 ;
    for (str : s) do ( (     var no : int ; no := (str)->toInteger() ;
     sum := sum+(no) ; 
     max := Set{max, no}->max() )  ) ; 
    OclFile["System.out"].println(2 * max - sum + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class main {
  public static void main(String args[])throws Exception {
    Scanner in=new Scanner(System.in);
    int x=in.nextInt();
    int i=0 ;
    int sum=0 ;
    int max=0 ;
    for(i=0 ; i<x ; i++){
      int g=in.nextInt();
      sum=sum+g ;
      max=Math.max(g,max);
    }
    System.out.println(2*max-sum+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := in.getCurrent()->toInteger() ;
    var i : int ; i := 0 ;
    var sum : int ; sum := 0 ;
    var max : int ; max := 0 ;
        i := 0 ; while i < x do ( (     var g : int ; g := in.getCurrent()->toInteger() ;
     sum := sum + g ; 
     max := Set{g, max}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(2 * max - sum + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int count(String S,int X){
    int count=0 ;
    int N=S.length();
    for(int i=0 ; i<N ; ++i){
      if(S.charAt(i)!='0'){
        for(int len=1 ; (i+len)<=N ; ++len){
          int num=Integer.parseInt(S.substring(i,i+len));
          if(num>X)count++;
        }
      }
    }
    return count ;
  }
  public static void main(String[] args){
    String S="2222" ;
    int X=97 ;
    System.out.println(count(S,X));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count( S : String, X : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var N : int ; N := S->size() ;
         var i : int ; i := 0 ; while i < N do ( (     if (S->at(i+1) /= '0') then (         var len : int ; len := 1 ; while (i + len) <= N do ( (     var num : int ; num := (S.subrange(i+1,i + len))->toInteger() ;
     if (num > X) then     count := count + 1 ; else skip )  ;     len := len + 1 ) ) else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := "2222" ;
     var X : int ; X := 97 ;
     OclFile["System.out"].println(count(S, X)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int stringReduction(String str){
    int n=str.length();
    int count[]=new int[3];
    for(int i=0 ; i<n ; ++i){
      count[str.charAt(i)-'a']++;
    }
    if(count[0]==n || count[1]==n || count[2]==n){
      return n ;
    }
    if((count[0] % 2)==(count[1] % 2)&&(count[1] % 2)==(count[2] % 2)){
      return 2 ;
    }
    return 1 ;
  }
  public static void main(String[] args){
    String str="abcbbaacb" ;
    System.out.println(stringReduction(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation stringReduction( str : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var count : Sequence(int) ; count := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     count[str->at(i+1) - ('a')->char2byte()+1] := count[str->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    if (count[0+1] = n or count[1+1] = n or count[2+1] = n) then (     return n ) else skip ; 
    if ((count[0+1] mod 2) = (count[1+1] mod 2) & (count[1+1] mod 2) = (count[2+1] mod 2)) then (     return 2 ) else skip ; 
    return 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abcbbaacb" ;
     OclFile["System.out"].println(stringReduction(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double dydx(double x,double y){
    return(x+y-2);
  }
  static double rungeKutta(double x0,double y0,double x,double h){
    int n=(int)((x-x0)/h);
    double k1,k2 ;
    double y=y0 ;
    for(int i=1 ; i<=n ; i++){
      k1=h*dydx(x0,y);
      k2=h*dydx(x0+0.5*h,y+0.5*k1);
      y=y+(1.0/6.0)*(k1+2*k2);
      x0=x0+h ;
    }
    return y ;
  }
  public static void main(String[] args){
    double x0=0,y=1,x=2,h=0.2 ;
    System.out.println(rungeKutta(x0,y,x,h));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation dydx( x : double, y : double) : double
  pre: true
  post: true
  activity: (     return (x + y - 2) );
  static   operation rungeKutta( x0 : double, y0 : double, x : double, h : double) : double
  pre: true
  post: true
  activity: (     var n : int ; n := ((x - x0) / h)->oclAsType(int) ;
     var k1 : double ;
    var k2 : double ;
    var y : double ; y := y0 ;
        var i : int ; i := 1 ; while i <= n do ( (     k1 := h * dydx(x0, y) ; 
     k2 := h * dydx(x0 + 0.5 * h, y + 0.5 * k1) ; 
     y := y + (1.0 / 6.0) * (k1 + 2 * k2) ; 
     x0 := x0 + h )  ;     i := i + 1 ) ; 
    return y 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x0 : double ; x0 := 0 ;
    var y : double ; y := 1 ;
    var x : double ; x := 2 ;
    var h : double ; h := 0.2 ;
     OclFile["System.out"].println(rungeKutta(x0, y, x, h)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Comparator ;
import java.util.Map ;
import java.util.Map.Entry ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    Map<Integer,Integer>count=new TreeMap<>(Comparator.reverseOrder());
    int max=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      count.put(a[i],count.getOrDefault(a[i],0)+1);
      max=Math.max(a[i],max);
    }
    for(int i=0 ; i<n ; i++){
      if(a[i]==max){
        System.out.println(getNext(count));
      }
      else {
        System.out.println(max);
      }
    }
  }
  static int getNext(Map<Integer,Integer>count){
    int loop=1 ;
    for(Entry<Integer,Integer>e : count.entrySet()){
      if(e.getValue()>1){
        return e.getKey();
      }
      if(loop>1){
        return e.getKey();
      }
      loop++;
    }
    return 0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var count : Map(int,int) ; count := Map{}->union(Comparator.reverseOrder()) ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     count := count->union(Map{a[i+1] |-> (if count->keys()->contains(a[i+1]) then count->at(a[i+1]) else 0 endif) + 1}) ; 
     max := Set{a[i+1], max}->max() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = max) then (     OclFile["System.out"].println(getNext(count)) ) else (     OclFile["System.out"].println(max) ) )  ;     i := i + 1 ) ; 
 );
  static   operation getNext( count : Map(int,int)) : int
  pre: true
  post: true
  activity: (     var loop : int ; loop := 1 ;
     for (e : count->asSet()) do ( (     if (e.getValue() > 1) then (     return e.getKey() ) else skip ; 
     if (loop > 1) then (     return e.getKey() ) else skip ; 
     loop := loop + 1 )  ) ; 
     return 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.io.BufferedOutputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    try(BufferedInputStream in=new BufferedInputStream(System.in);
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out))){
      Scanner sc=new Scanner(in);
      int n=sc.nextInt();
      int[] vs=new int[n];
      for(int i=0 ; i<vs.length ; i++)vs[i]=sc.nextInt();
      int[] ml=new int[n];
      ml[0]=vs[0];
      for(int i=1 ; i<ml.length ; i++){
        ml[i]=Math.max(ml[i-1],vs[i]);
      }
      int[] mr=new int[n];
      mr[n-1]=vs[n-1];
      for(int i=mr.length-2 ; i>=0 ; i--){
        mr[i]=Math.max(mr[i+1],vs[i]);
      }
      for(int i=0 ; i<vs.length ; i++){
        if(i==0){
          out.println(mr[i+1]);
        }
        else if(i==n-1){
          out.println(ml[i-1]);
        }
        else {
          out.println(Math.max(ml[i-1],mr[i+1]));
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
 (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var vs : Sequence(int) ; vs := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < vs->size() do (     vs[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ml : Sequence(int) ; ml := Integer.subrange(1,n)->collect(0) ;
    ml[0+1] := vs[0+1] ; 
        var i : int ; i := 1 ; while i < ml->size() do ( (     ml[i+1] := Set{ml[i - 1+1], vs[i+1]}->max() )  ;     i := i + 1 ) ; 
    var mr : Sequence(int) ; mr := Integer.subrange(1,n)->collect(0) ;
    mr[n - 1+1] := vs[n - 1+1] ; 
        var i : int ; i := mr->size() - 2 ; while i >= 0 do ( (     mr[i+1] := Set{mr[i + 1+1], vs[i+1]}->max() )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < vs->size() do ( (     if (i = 0) then (     skip ) else     if (i = n - 1) then (     skip ) else (     skip ) ;  )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Sample {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int n=in.nextInt();
    int k=in.nextInt();
    int[] trees=new int[n];
    for(int i=0 ; i<n ; i++){
      trees[i]=in.nextInt();
    }
    int[] visited=new int[n];
    int pivot=0 ;
    int max=1 ;
    for(int i=0 ; i<n ; i++){
      if(visited[i]>0){
        continue ;
      }
      int tempPivot=i ;
      int pivotVal=trees[i];
      int count=1 ;
      int possibleStartHeight=pivotVal-k*i ;
      if(possibleStartHeight<=0){
        continue ;
      }
      for(int j=i+1 ; j<n ; j++){
        if(trees[j]==pivotVal+((j-i)*k)){
          count++;
          visited[j]=count ;
        }
      }
      visited[i]=count ;
      if(count>max){
        max=count ;
        pivot=tempPivot ;
      }
    }
    int startValue=trees[pivot]-k*pivot ;
    System.out.println(n-max);
    for(int i=0 ; i<n ; i++){
      int expectedVal=startValue+i*k ;
      if(trees[i]>expectedVal){
        System.out.println("-"+(i+1)+" "+(trees[i]-expectedVal));
      }
      else if(trees[i]<expectedVal){
        System.out.println("+"+(i+1)+" "+(expectedVal-trees[i]));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sample {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var trees : Sequence(int) ; trees := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     trees[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var visited : Sequence(int) ; visited := Integer.subrange(1,n)->collect(0) ;
    var pivot : int ; pivot := 0 ;
    var max : int ; max := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (visited[i+1] > 0) then (     continue ) else skip ; 
     var tempPivot : int ; tempPivot := i ;
    var pivotVal : int ; pivotVal := trees[i+1] ;
    var count : int ; count := 1 ;
    var possibleStartHeight : int ; possibleStartHeight := pivotVal - k * i ;
    if (possibleStartHeight <= 0) then (     continue ) else skip ; 
        var j : int ; j := i + 1 ; while j < n do ( (     if (trees[j+1] = pivotVal + ((j - i) * k)) then (     count := count + 1 ; 
     visited[j+1] := count ) else skip )  ;     j := j + 1 ) ; 
    visited[i+1] := count ; 
    if (count > max) then (     max := count ; 
     pivot := tempPivot ) else skip ; 
 )  ;     i := i + 1 ) ; 
    var startValue : int ; startValue := trees[pivot+1] - k * pivot ;
    OclFile["System.out"].println(n - max) ; 
        var i : int ; i := 0 ; while i < n do ( (     var expectedVal : int ; expectedVal := startValue + i * k ;
     if (trees[i+1] > expectedVal) then (     OclFile["System.out"].println("-" + (i + 1) + " " + (trees[i+1] - expectedVal)) ) else     if (trees[i+1] < expectedVal) then (     OclFile["System.out"].println("+" + (i + 1) + " " + (expectedVal - trees[i+1])) ) else skip ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.BufferedReader ;
public class Main {
  public static void main(String[] args)throws IOException,InterruptedException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    int max=0 ;
    int mi=0 ;
    int second=0 ;
    for(int i=0 ; i<n ; i++){
      int cur=sc.nextInt();
      if(cur>max){
        max=cur ;
        mi=i ;
      }
      else {
        if(cur>second){
          second=cur ;
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      if(i==mi){
        out.println(second);
      }
      else {
        out.println(max);
      }
    }
    out.flush();
  }
}
class Scanner {
  StringTokenizer st ;
  BufferedReader br ;
  public Scanner(InputStream system){
    br=new BufferedReader(new InputStreamReader(system));
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String nextLine()throws IOException {
    return br.readLine();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public char nextChar()throws IOException {
    return next().charAt(0);
  }
  public Long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
  public void waitForInput()throws InterruptedException {
    Thread.sleep(3000);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var max : int ; max := 0 ;
    var mi : int ; mi := 0 ;
    var second : int ; second := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var cur : int ; cur := sc.getCurrent()->toInteger() ;
     if (cur > max) then (     max := cur ; 
     mi := i ) else (     if (cur > second) then (     second := cur ) else skip ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i = mi) then (     skip ) else (     skip ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( system : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(system);
    return self );
  operation initialise( system : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(system)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
   operation waitForInput() : void
  pre: true
  post: true
  activity: (     OclProcess.sleep(3000) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  void run(){
    sc=new Scanner(System.in);
    for(; sc.hasNext(); ){
      double t1=sc.nextDouble();
      double t2=sc.nextDouble();
      double[] s1={
        70.0,55.0,50.0,43.0,40.0,37.5,35.5 };
        double[] s2={
          148.0,116.0,105.0,89.0,83.0,77.0,71.0 };
          String[] s={
            "E","D","C","B","A","AA","AAA" };
            String ans="NA" ;
            for(int i=0 ; i<7 ; i++){
              if(t1<s1[i] && t2<s2[i])ans=s[i];
              else break ;
            }
            println(ans);
          }
          sc.close();
        }
        void print(String s){
          System.out.print(s);
        }
        void println(String s){
          System.out.println(s);
        }
        public static void main(String[] args){
          new Main().run();
        }
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
       while sc.hasNext() do ( (     var t1 : double ; t1 := sc.getCurrent()->toReal() ;
     var t2 : double ; t2 := sc.getCurrent()->toReal() ;
    var s1 : Sequence(double) ; s1 := Sequence{70.0,55.0,50.0,43.0,40.0,37.5,35.5} ;
    var s2 : Sequence(double) ; s2 := Sequence{148.0,116.0,105.0,89.0,83.0,77.0,71.0} ;
    var s : Sequence(String) ; s := Sequence{"E","D","C","B","A","AA","AAA"} ;
    var ans : String ; ans := "NA" ;
        var i : int ; i := 0 ; while i < 7 do ( (     if (t1 < s1[i+1] & t2 < s2[i+1]) then     ans := s[i+1] ; else     break )  ;     i := i + 1 ) ; 
    execute println(ans) ; 
 )  ) ; 
     skip );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.nio.charset.StandardCharsets ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader reader=new InputStreamReader(System.in,StandardCharsets.UTF_8);
    BufferedReader in=new BufferedReader(reader);
    int N=Integer.parseInt(in.readLine());
    int[] A=new int[N];
    for(int i=0 ; i<N ; ++i){
      A[i]=Integer.parseInt(in.readLine());
    }
    Map<Integer,Set<Integer>>map=new HashMap<>();
    for(int i=0 ; i<N ; ++i){
      if(! map.containsKey(A[i])){
        map.put(A[i],new HashSet<>());
      }
      map.get(A[i]).add(i);
    }
    int max=Integer.MIN_VALUE ;
    int nextMax=Integer.MIN_VALUE ;
    for(int i=0 ; i<N ; ++i){
      int temp=-1 ;
      if(max<A[i]){
        temp=max ;
        max=A[i];
      }
      if(temp>=0){
        if(nextMax<temp){
          nextMax=temp ;
        }
      }
      else {
        if(max>A[i] && nextMax<A[i]){
          nextMax=A[i];
        }
      }
    }
    for(int i=0 ; i<N ; ++i){
      if(A[i]!=max){
        System.out.println(max);
      }
      else {
        if(map.get(A[i]).size()>=2){
          System.out.println(max);
        }
        else {
          System.out.println(nextMax);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"], StandardCharsets.UTF_8) ;
     var in : OclFile ; in := OclFile.newOclFile_Read(reader) ;
    var N : int ; N := (in.readLine())->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := (in.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    var map : Map(int,Set(int)) ; map := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     if (not(map->keys()->includes(A[i+1]))) then (     map := map->union(Map{A[i+1] |-> Set{}}) ) else skip ; 
     map->at(A[i+1])->excludes(i) )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
    var nextMax : int ; nextMax := -2147483648 ;
        var i : int ; i := 0 ; while i < N do ( (     var temp : int ; temp := -1 ;
     if (max < A[i+1]) then (     temp := max ; 
     max := A[i+1] ) else skip ; 
     if (temp >= 0) then (     if (nextMax < temp) then (     nextMax := temp ) else skip ) else (     if (max > A[i+1] & nextMax < A[i+1]) then (     nextMax := A[i+1] ) else skip ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (A[i+1] /= max) then (     OclFile["System.out"].println(max) ) else (     if (map->at(A[i+1])->size() >= 2) then (     OclFile["System.out"].println(max) ) else (     OclFile["System.out"].println(nextMax) ) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String W=in.readLine();
    int N=Integer.parseInt(W);
    int[] A=new int[N];
    int[] B=new int[N];
    for(int i=0 ; i<N ; i++){
      W=in.readLine();
      A[i]=Integer.parseInt(W);
      B[i]=Integer.parseInt(W);
    }
    Arrays.sort(B);
    for(int i=0 ; i<N ; i++){
      int indx=Arrays.binarySearch(B,A[i]);
      if(indx==N-1){
        System.out.println(B[indx-1]);
      }
      else {
        System.out.println(B[N-1]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var W : String ; W := in.readLine() ;
    var N : int ; N := (W)->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     W := in.readLine() ; 
     A[i+1] := (W)->toInteger() ; 
     B[i+1] := (W)->toInteger() )  ;     i := i + 1 ) ; 
    B := B->sort() ; 
        var i : int ; i := 0 ; while i < N do ( (     var indx : int ; indx := (B->indexOf(A[i+1]) - 1) ;
     if (indx = (N)->char2byte() - 1) then (     OclFile["System.out"].println(B[indx - 1+1]) ) else (     OclFile["System.out"].println(B[(N)->char2byte() - 1+1]) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class BearAndElections {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int a=in.nextInt();
    n-=1 ;
    int y=a ;
    int x[]=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=in.nextInt();
    }
    while(true){
      Arrays.sort(x);
      if(x[n-1]<a)break ;
      a++;
      x[n-1]--;
    }
    System.out.println(a-y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class BearAndElections {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    n := n-(1) ; 
    var y : int ; y := a ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    while (true) do (     x := x->sort() ; 
     if (x[n - 1+1] < a) then     break else skip ; 
     a := a + 1 ; 
     x[n - 1+1] := x[n - 1+1] - 1 ) ; 
    OclFile["System.out"].println(a - y) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int m=in.nextInt();
    int count=0 ;
    for(int i=1 ; i<Integer.MAX_VALUE ; i++){
      int x=i*5 ;
      while(x % 5==0){
        x/=5 ;
        count++;
      }
      if(count>m){
        System.out.println(0);
        return ;
      }
      if(count==m){
        System.out.println(5);
        int c=0 ;
        for(int l=0 ; l<5 ; l++){
          System.out.print(i*5+c+" ");
          c++;
        }
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := in.getCurrent()->toInteger() ;
     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i < 2147483647 do ( (     var x : int ; x := i * 5 ;
     while (x mod 5 = 0) do (     x := x/(5) ; 
     count := count + 1 ) ; 
     if (count > m) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
     if (count = m) then (     OclFile["System.out"].println(5) ; 
     var c : int ; c := 0 ;
         var l : int ; l := 0 ; while l < 5 do ( (     OclFile["System.out"].print(i * 5 + c + " ") ; 
     c := c + 1 )  ;     l := l + 1 ) ; 
     return ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Main ob=new Main();
    ob.run();
  }
  int getZeros(int x){
    int cnt=0 ;
    int p=5 ;
    while(x>0){
      cnt+=x/p ;
      x/=p ;
    }
    return cnt ;
  }
  private void run(){
    int n=nextInt();
    int l=0,rmin=100_000_000,rmax=100_000_000 ;
    while(l+1<rmin){
      int m=(l+rmin)/2 ;
      if(getZeros(m)>=n){
        rmin=m ;
      }
      else {
        l=m ;
      }
    }
    l=0 ;
    while(l+1<rmax){
      int m=(l+rmax)/2 ;
      if(getZeros(m)>n){
        rmax=m ;
      }
      else {
        l=m ;
      }
    }
    rmax--;
    if(getZeros(rmin)!=n){
      out.println(0);
    }
    else {
      out.println(rmax-rmin+1);
      for(int i=rmin ; i<=rmax ; i++){
        out.print(i+" ");
      }
    }
    out.close();
  }
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer st ;
  PrintWriter out=new PrintWriter(System.out);
  String nextLine(){
    try {
      return br.readLine();
    }
    catch(IOException ex){
      ex.printStackTrace();
    }
    return "" ;
  }
  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());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ob : Main ; ob := Main.newMain() ;
     ob.run() );
   operation getZeros( x : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var p : int ; p := 5 ;
     while (x > 0) do (     cnt := cnt+(x / p) ; 
     x := x/(p) ) ; 
     return cnt );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var l : int ; l := 0 ;
    var rmin : int ; rmin := 100_000_000 ;
    var rmax : int ; rmax := 100_000_000 ;
    while (l + 1 < rmin) do (     var m : int ; m := (l + rmin) / 2 ;
     if (getZeros(m) >= n) then (     rmin := m ) else (     l := m ) ) ; 
    l := 0 ; 
    while (l + 1 < rmax) do (     var m : int ; m := (l + rmax) / 2 ;
     if (getZeros(m) > n) then (     rmax := m ) else (     l := m ) ) ; 
    rmax := rmax - 1 ; 
    if (getZeros(rmin) /= n) then (     out.println(0) ) else (     out.println(rmax - rmin + 1) ; 
         var i : int ; i := rmin ; while i <= rmax do ( (     out.print(i + " ") )  ;     i := i + 1 ) ) ;  
    out.close() ; 
 );
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator;
   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (ex : IOException) do (     ex.printStackTrace() )
     return "" );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int m=in.nextInt();
    int count=0 ;
    for(int i=1 ; i<Integer.MAX_VALUE ; i++){
      int x=i*5 ;
      while(x % 5==0){
        x/=5 ;
        count++;
      }
      if(count>m){
        System.out.println(0);
        return ;
      }
      if(count==m){
        System.out.println(5);
        int c=0 ;
        for(int l=0 ; l<5 ; l++){
          System.out.print(i*5+c+" ");
          c++;
        }
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := in.getCurrent()->toInteger() ;
     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i < 2147483647 do ( (     var x : int ; x := i * 5 ;
     while (x mod 5 = 0) do (     x := x/(5) ; 
     count := count + 1 ) ; 
     if (count > m) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
     if (count = m) then (     OclFile["System.out"].println(5) ; 
     var c : int ; c := 0 ;
         var l : int ; l := 0 ; while l < 5 do ( (     OclFile["System.out"].print(i * 5 + c + " ") ; 
     c := c + 1 )  ;     l := l + 1 ) ; 
     return ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static int zeroes(int n){
    int count=0 ;
    while(n>0){
      n/=5 ;
      count+=n ;
    }
    return count ;
  }
  public static void binarySearch(int n){
    int low=0 ;
    int high=Integer.MAX_VALUE ;
    while(low<high){
      int middle=(low+high)/2 ;
      int count=zeroes(middle);
      if(count<n){
        low=middle+1 ;
      }
      else {
        high=middle ;
      }
    }
    int ans[]=new int[1000];
    int k=0 ;
    while(zeroes(low)==n){
      ans[k]=low ;
      k++;
      low++;
    }
    System.out.println(k);
    for(int i=0 ; i<k ; i++){
      System.out.print(ans[i]+" ");
    }
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    binarySearch(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation zeroes( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     n := n/(5) ; 
     count := count+(n) ) ; 
     return count );
  static   operation binarySearch( n : int) : void
  pre: true
  post: true
  activity: (     var low : int ; low := 0 ;
     var high : int ; high := 2147483647 ;
    while (low < high) do (     var middle : int ; middle := (low + high) / 2 ;
     var count : int ; count := zeroes(middle) ;
     if (count < n) then (     low := middle + 1 ) else (     high := middle ) ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,1000)->collect(0) ;
    var k : int ; k := 0 ;
    while (zeroes(low) = n) do (     ans[k+1] := low ; 
     k := k + 1 ; 
     low := low + 1 ) ; 
    OclFile["System.out"].println(k) ; 
        var i : int ; i := 0 ; while i < k do ( (     OclFile["System.out"].print(ans[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : int ; n := sc.nextInt() ;
     execute binarySearch(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long b=1 ;
    long a=0 ;
    for(int i=0 ; i<n ; i++){
      int q=sc.nextInt();
      int x=sc.nextInt();
      if(q==1){
        b*=x ;
        a*=x ;
      }
      else if(q==2){
        a-=x ;
      }
      else {
        a+=x ;
      }
    }
    System.out.println(a+" "+b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var b : long ; b := 1 ;
    var a : long ; a := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var q : int ; q := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (q = 1) then (     b := b*(x) ; 
     a := a*(x) ) else     if (q = 2) then (     a := a-(x) ) else (     a := a+(x) ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a + " " + b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int countPairs(int n){
    if(n==2)return 4 ;
    int num=((n/2)+1);
    int max=n % num ;
    int count=n-max ;
    return count ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(countPairs(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countPairs( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 2) then     return 4 else skip ; 
     var num : int ; num := ((n / 2) + 1) ;
    var max : int ; max := n mod num ;
    var count : int ; count := n - max ;
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(countPairs(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),m=in.nextInt();
    int min=in.nextInt(),max=in.nextInt();
    for(int i=1 ; i<n ; i++){
      int a=in.nextInt(),b=in.nextInt();
      if(a<=max && b>max){
        max=b ;
      }
    }
    if(min!=0 || m>max){
      pw.println("NO");
    }
    else {
      pw.println("YES");
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var min : int ; min := in.getCurrent()->toInteger() ;
    var max : int ; max := in.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i < n do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
     if (a <= max & b > max) then (     max := b ) else skip )  ;     i := i + 1 ) ; 
    if (min /= 0 or m > max) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static boolean prime[]=new boolean[100006];
  static void SieveOfEratosthenes(int n){
    for(int i=1 ; i<=n ; i++)prime[i]=true ;
    prime[1]=false ;
    for(int p=2 ; p*p<=n ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=n ; i+=p)prime[i]=false ;
      }
    }
  }
  static void sortedArray(int arr[],int n){
    SieveOfEratosthenes(100005);
    Vector<Integer>v=new Vector<Integer>();
    for(int i=0 ; i<n ; ++i){
      if(prime[arr[i] ]==false)v.add(arr[i]);
    }
    Collections.sort(v);
    int j=0 ;
    for(int i=0 ; i<n ; ++i){
      if(prime[arr[i] ]==true)System.out.print(arr[i]+" ");
      else {
        System.out.print(v.get(j)+" ");
        j++;
      }
    }
  }
  public static void main(String args[]){
    int n=6 ;
    int arr[]={
      100,11,500,2,17,1 };
      sortedArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution {
  static   attribute prime : boolean := Integer.subrange(1,100006)->collect(false);
  static   operation SieveOfEratosthenes( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= n do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p <= n do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= n do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation sortedArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes(100005) ; 
     var v : Sequence(int) ; v := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (prime[arr[i+1]+1] = false) then     v := v->including(arr[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    v := v->sort() ; 
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (prime[arr[i+1]+1] = true) then     OclFile["System.out"].print(arr[i+1] + " ") ; else (     OclFile["System.out"].print(v->at(j+1) + " ") ; 
     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     var arr : Sequence(int) ; arr := Sequence{100,11,500,2,17,1} ;
     execute sortedArray(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void split(int x,int n){
    if(x<n)System.out.print("-1 ");
    else if(x % n==0){
      for(int i=0 ; i<n ; i++)System.out.print((x/n)+" ");
    }
    else {
      int zp=n-(x % n);
      int pp=x/n ;
      for(int i=0 ; i<n ; i++){
        if(i>=zp)System.out.print((pp+1)+" ");
        else System.out.print(pp+" ");
      }
    }
  }
  public static void main(String[] args){
    int x=5 ;
    int n=3 ;
    split(x,n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation split( x : int, n : int) : void
  pre: true
  post: true
  activity: (     if (x < n) then     OclFile["System.out"].print("-1 ") ; else     if (x mod n = 0) then (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print((x / n) + " ") ;  ;     i := i + 1 ) ) else (     var zp : int ; zp := n - (x mod n) ;
     var pp : int ; pp := x / n ;
         var i : int ; i := 0 ; while i < n do ( (     if (i >= zp) then     OclFile["System.out"].print((pp + 1) + " ") ; else     OclFile["System.out"].print(pp + " ") ; )  ;     i := i + 1 ) ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 5 ;
     var n : int ; n := 3 ;
     execute split(x, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean checkDivisibility(int n,int digit){
    return(digit!=0 && n % digit==0);
  }
  static boolean allDigitsDivide(int n){
    int temp=n ;
    while(temp>0){
      int digit=n % 10 ;
      if((checkDivisibility(n,digit))==false)return false ;
      temp/=10 ;
    }
    return true ;
  }
  public static void main(String args[]){
    int n=128 ;
    if(allDigitsDivide(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkDivisibility( n : int, digit : int) : boolean
  pre: true
  post: true
  activity: (     return (digit /= 0 & n mod digit = 0) );
  static   operation allDigitsDivide( n : int) : boolean
  pre: true
  post: true
  activity: (     var temp : int ; temp := n ;
     while (temp > 0) do (     var digit : int ; digit := n mod 10 ;
     if ((checkDivisibility(n, digit)) = false) then     return false else skip ; 
     temp := temp/(10) ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 128 ;
     if (allDigitsDivide(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Kavya {
  public static void main(String[] args)throws IOException {
    int n,t ;
    InputStreamReader in=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(in);
    n=Integer.parseInt(br.readLine());
    for(int i=1 ; i<n ; i++){
      int z=i*(i+1);
      if(z>n)break ;
      t=(int)Math.sqrt(2*n-z);
      t=t*(t+1);
      if(t==2*n-z){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Kavya {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var t : int ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var br : OclFile ; br := OclFile.newOclFile_Read(in) ;
    n := (br.readLine())->toInteger() ; 
        var i : int ; i := 1 ; while i < n do ( (     var z : int ; z := i * (i + 1) ;
     if (z > n) then     break else skip ; 
    t := (2 * n - z)->sqrt()->oclAsType(int) ; 
    t := t * (t + 1) ; 
    if (t = 2 * n - z) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    HashSet<Integer>h=new HashSet<>();
    int sum=0 ;
    for(int i=1 ; i<=100000 ; i++){
      int f=i*(i+1);
      sum=f/2 ;
      if(sum>n || sum<0){
        break ;
      }
      int d=n-sum ;
      if(h.contains(d)|| d==sum){
        System.out.println("Yes");
        return ;
      }
      h.add(sum);
    }
    System.out.println("NO");
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var h : Set(int) ; h := Set{} ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 1 ; while i <= 100000 do ( (     var f : int ; f := i * (i + 1) ;
     sum := f / 2 ; 
    if (sum > n or sum < 0) then (     break ) else skip ; 
    var d : int ; d := n - sum ;
    if (h->includes(d) or d = sum) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
    h := h->including(sum) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long n=in.nextLong();
    boolean is=false ;
    for(long i=1 ; i<44722 ; i++){
      long a=i*(i+1)/2 ;
      if(a>=n){
        break ;
      }
      long b=n-a ;
      long c=(long)Math.sqrt(b*2);
      if(c*(c+1)/2==b){
        is=true ;
        break ;
      }
    }
    if(is){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toLong() ;
    var is : boolean ; is := false ;
        var i : long ; i := 1 ; while i < 44722 do ( (     var a : long ; a := i * (i + 1) / 2 ;
     if (a >= n) then (     break ) else skip ; 
    var b : long ; b := n - a ;
    var c : long ; c := (b * 2)->sqrt()->oclAsType(long) ;
    if (c * (c + 1) / 2 = b) then (     is := true ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (is) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long n=in.nextLong();
    boolean is=false ;
    for(long i=1 ; i<44722 ; i++){
      long a=i*(i+1)/2 ;
      if(a>=n){
        break ;
      }
      long b=n-a ;
      long c=(long)Math.sqrt(b*2);
      if(c*(c+1)/2==b){
        is=true ;
        break ;
      }
    }
    if(is){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toLong() ;
    var is : boolean ; is := false ;
        var i : long ; i := 1 ; while i < 44722 do ( (     var a : long ; a := i * (i + 1) / 2 ;
     if (a >= n) then (     break ) else skip ; 
    var b : long ; b := n - a ;
    var c : long ; c := (b * 2)->sqrt()->oclAsType(long) ;
    if (c * (c + 1) / 2 = b) then (     is := true ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (is) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    int x=10 ;
    int y=25 ;
    int z=x+y ;
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<Long>arr=new ArrayList<>();
    for(long i=1 ; i<=n/2 ; i++){
      if(i*(i+1)<=n)arr.add((i*(i+1))/2);
      else break ;
    }
    boolean possible=false ;
    for(long ele : arr){
      long val=2*(n-ele);
      long sq=(long)Math.sqrt(val);
      if(sq*(sq+1)==val){
        possible=true ;
        break ;
      }
    }
    if(possible==true)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 10 ;
     var y : int ; y := 25 ;
    var z : int ; z := x + y ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Sequence{} ;
        var i : long ; i := 1 ; while i <= n / 2 do ( (     if (i * (i + 1) <= n) then     arr := arr->including((i * (i + 1)) / 2) ; else     break )  ;     i := i + 1 ) ; 
    var possible : boolean ; possible := false ;
    for (ele : arr) do ( (     var val : long ; val := 2 * (n - ele) ;
     var sq : long ; sq := (val)->sqrt()->oclAsType(long) ;
     if (sq * (sq + 1) = val) then (     possible := true ; 
     break ) else skip )  ) ; 
    if (possible = true) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p231 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p231().run());
  }
  private static final int N=20000000 ;
  private static final int K=15000000 ;
  public String run(){
    smallestPrimeFactor=Library.listSmallestPrimeFactors(N);
    return Long.toString(factorialPrimeFactorSum(N)-factorialPrimeFactorSum(K)-factorialPrimeFactorSum(N-K));
  }
  private int[] smallestPrimeFactor ;
  private long factorialPrimeFactorSum(int n){
    long sum=0 ;
    for(int i=1 ; i<=n ; i++){
      int j=i ;
      while(j>1){
        int p=smallestPrimeFactor[j];
        sum+=p ;
        j/=p ;
      }
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p231 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p231.newp231().run()) );
  static    attribute N : int := 20000000;
  static    attribute K : int := 15000000;
   operation run() : String
  pre: true
  post: true
  activity: (     smallestPrimeFactor := Library.listSmallestPrimeFactors(N) ; 
     return ((factorialPrimeFactorSum(N) - factorialPrimeFactorSum(K) - factorialPrimeFactorSum(N - K)) + "") );
   attribute smallestPrimeFactor : Sequence(int);
   operation factorialPrimeFactorSum( n : int) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     var j : int ; j := i ;
     while (j > 1) do (     var p : int ; p := smallestPrimeFactor[j+1] ;
     sum := sum+(p) ; 
     j := j/(p) ) )  ;     i := i + 1 ) ; 
     return sum );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int singleNumber(int a[],int n){
    HashSet<Integer>s=new HashSet<Integer>();
    for(int i : a){
      s.add(i);
    }
    int arr_sum=0 ;
    for(int i : a){
      arr_sum+=i ;
    }
    int set_sum=0 ;
    for(int i : s){
      set_sum+=i ;
    }
    return(3*set_sum-arr_sum)/2 ;
  }
  public static void main(String[] args){
    int a[]={
      12,1,12,3,12,1,1,2,3,2,2,3,7 };
      int n=a.length ;
      System.out.println("The element with single "+"occurrence is "+singleNumber(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation singleNumber( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
     for (i : a) do ( (     s := s->including(i) )  ) ; 
    var arr_sum : int ; arr_sum := 0 ;
    for (i : a) do ( (     arr_sum := arr_sum+(i) )  ) ; 
    var set_sum : int ; set_sum := 0 ;
    for (i : s) do ( (     set_sum := set_sum+(i) )  ) ; 
    return (3 * set_sum - arr_sum) / 2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{12,1,12,3,12,1,1,2,3,2,2,3,7} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println("The element with single " + "occurrence is " + singleNumber(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Objects ;
import java.util.Scanner ;
public class Gcd {
  static String gcd(String s,String s1){
    if(Objects.equals(s,s1))return s ;
    return "1" ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next(),s1=sc.next();
    System.out.println(gcd(s,s1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Gcd {
  static   operation gcd( s : String, s1 : String) : String
  pre: true
  post: true
  activity: (     if (Objects = s, s1) then     return s else skip ; 
     return "1" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var s1 : String ; s1 := sc.getCurrent() ;
     OclFile["System.out"].println(gcd(s, s1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class q1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long a,b,c,d ;
      a=sc.nextLong();
      b=sc.nextLong();
      c=sc.nextLong();
      d=sc.nextLong();
      long res=Math.max(c-1,a-c)+Math.max(d-1,b-d);
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class q1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : long ;
    var b : long ;
    var c : long ;
    var d : long ;
     a := sc.getCurrent()->toLong() ; 
    b := sc.getCurrent()->toLong() ; 
    c := sc.getCurrent()->toLong() ; 
    d := sc.getCurrent()->toLong() ; 
    var res : long ; res := Set{c - 1, a - c}->max() + Set{d - 1, b - d}->max() ;
    OclFile["System.out"].println(res) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.io.InputStreamReader ;
public class TestClassFinal {
  public static void main(String args[])throws Exception {
    BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
    int n,m ;
    String[] arr=sc.readLine().split(" ");
    n=Integer.parseInt(arr[0]);
    m=Integer.parseInt(arr[1]);
    int pos=0 ;
    int a,b ;
    for(int i=0 ; i<n ; i++){
      String[] tab=sc.readLine().split(" ");
      a=Integer.parseInt(tab[0]);
      b=Integer.parseInt(tab[1]);
      if((pos>=a)&&(pos<=b))pos=b ;
    }
    if(pos>=m)System.out.println("YES");
    else System.out.println("NO");
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class TestClassFinal {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ;
    var m : int ;
    var arr : Sequence(String) ; arr := sc.readLine()->split(" ") ;
    n := (arr[0+1])->toInteger() ; 
    m := (arr[1+1])->toInteger() ; 
    var pos : int ; pos := 0 ;
    var a : int ;
    var b : int ;
        var i : int ; i := 0 ; while i < n do ( (     var tab : Sequence(String) ; tab := sc.readLine()->split(" ") ;
     a := (tab[0+1])->toInteger() ; 
     b := (tab[1+1])->toInteger() ; 
     if ((pos >= a) & (pos <= b)) then     pos := b ; else skip )  ;     i := i + 1 ) ; 
    if (pos >= m) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        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().trim();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  static class FastWriter {
    private final BufferedWriter bw ;
    public FastWriter(){
      this.bw=new BufferedWriter(new OutputStreamWriter(System.out));
    }
    public void print(Object object)throws IOException {
      bw.append(""+object);
    }
    public void println(Object object)throws IOException {
      print(object);
      bw.append("\n");
    }
    public void close()throws IOException {
      bw.close();
    }
  }
  public static void main(String[] args){
    try {
      FastReader sc=new FastReader();
      FastWriter sout=new FastWriter();
      String a=sc.next();
      String b=sc.next();
      if(a.equals(b))sout.println(a);
      else sout.println(1);
      sout.close();
    }
    catch(Exception e){
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine()->trim() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return str );
}
  static class FastWriter {
   attribute bw : OclFile;
   static operation newFastWriter() : FastWriter
  pre: true
  post: true
  activity:
  ( var self : FastWriter ;
    self := createFastWriter();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) );
   operation print( object : OclAny) : void
  pre: true
  post: true
  activity: (     skip );
   operation println( object : OclAny) : void
  pre: true
  post: true
  activity: (     execute print(object) ; 
     skip );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var sout : FastWriter ; sout := FastWriter.newFastWriter() ;
    var a : String ; a := sc.next() ;
    var b : String ; b := sc.next() ;
    if (a = b) then     sout.println(a) else     sout.println(1) ; ;  
    sout.close() ; 
 )   catch (e : ProgramException) do (     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class C {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int a=sc.nextInt()*2,b=sc.nextInt()*2,x1=sc.nextInt(),y1=sc.nextInt(),x2=sc.nextInt(),y2=sc.nextInt();
    int d1=Math.abs(Math.floorDiv(x1-y1,b)-Math.floorDiv(x2-y2,b));
    int d2=Math.abs(Math.floorDiv(x1+y1,a)-Math.floorDiv(x2+y2,a));
    out.println(Math.max(d1,d2));
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : int ; a := sc.getCurrent()->toInteger() * 2 ;
    var b : int ; b := sc.getCurrent()->toInteger() * 2 ;
    var x1 : int ; x1 := sc.getCurrent()->toInteger() ;
    var y1 : int ; y1 := sc.getCurrent()->toInteger() ;
    var x2 : int ; x2 := sc.getCurrent()->toInteger() ;
    var y2 : int ; y2 := sc.getCurrent()->toInteger() ;
    var d1 : int ; d1 := if floorDiv(x1 - y1, b) - floorDiv(x2 - y2, b) < 0 then -(floorDiv(x1 - y1, b) - floorDiv(x2 - y2, b)) else floorDiv(x1 - y1, b) - floorDiv(x2 - y2, b) endif ;
    var d2 : int ; d2 := if floorDiv(x1 + y1, a) - floorDiv(x2 + y2, a) < 0 then -(floorDiv(x1 + y1, a) - floorDiv(x2 + y2, a)) else floorDiv(x1 + y1, a) - floorDiv(x2 + y2, a) endif ;
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    int b=in.nextInt();
    int x1=in.nextInt();
    int y1=in.nextInt();
    int x2=in.nextInt();
    int y2=in.nextInt();
    int n1=Math.floorDiv(x1+y1,2*a);
    int m1=Math.floorDiv(x1-y1,2*b);
    int n2=Math.floorDiv(x2+y2,2*a);
    int m2=Math.floorDiv(x2-y2,2*b);
    int res=Math.max(Math.abs(n2-n1),Math.abs(m2-m1));
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var x1 : int ; x1 := in.getCurrent()->toInteger() ;
    var y1 : int ; y1 := in.getCurrent()->toInteger() ;
    var x2 : int ; x2 := in.getCurrent()->toInteger() ;
    var y2 : int ; y2 := in.getCurrent()->toInteger() ;
    var n1 : int ; n1 := floorDiv(x1 + y1, 2 * a) ;
    var m1 : int ; m1 := floorDiv(x1 - y1, 2 * b) ;
    var n2 : int ; n2 := floorDiv(x2 + y2, 2 * a) ;
    var m2 : int ; m2 := floorDiv(x2 - y2, 2 * b) ;
    var res : int ; res := Set{if n2 - n1 < 0 then -(n2 - n1) else n2 - n1 endif, if m2 - m1 < 0 then -(m2 - m1) else m2 - m1 endif}->max() ;
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  static int MaximumHeight(int a[],int n){
    return(int)Math.floor((-1+Math.sqrt(1+(8*n)))/2);
  }
  public static void main(String[] args){
    int arr[]=new int[] {
      40,100,20,30 };
      int n=arr.length ;
      System.out.println(MaximumHeight(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MaximumHeight( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     return ((-1 + (1 + (8 * n))->sqrt()) / 2)->floor()->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{40,100,20,30} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(MaximumHeight(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int sumOfDiv(int x){
    int sum=1 ;
    for(int i=2 ; i<=Math.sqrt(x); i++){
      if(x % i==0){
        sum+=i ;
        if(x/i!=i)sum+=x/i ;
      }
    }
    return sum ;
  }
  static boolean isAmicable(int a,int b){
    return(sumOfDiv(a)==b && sumOfDiv(b)==a);
  }
  static int countPairs(int arr[],int n){
    int count=0 ;
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++)if(isAmicable(arr[i],arr[j]))count++;
    return count ;
  }
  public static void main(String args[]){
    int arr1[]={
      220,284,1184,1210,2,5 };
      int n1=arr1.length ;
      System.out.println(countPairs(arr1,n1));
      int arr2[]={
        2620,2924,5020,5564,6232,6368 };
        int n2=arr2.length ;
        System.out.println(countPairs(arr2,n2));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfDiv( x : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 1 ;
         var i : int ; i := 2 ; while i <= (x)->sqrt() do ( (     if (x mod i = 0) then (     sum := sum+(i) ; 
     if (x / i /= i) then     sum := sum+(x / i) ; else skip ) else skip )  ;     i := i + 1 ) ; 
     return sum );
  static   operation isAmicable( a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     return (sumOfDiv(a) = b & sumOfDiv(b) = a) );
  static   operation countPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do (     if (isAmicable(arr[i+1], arr[j+1])) then     count := count + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{220,284,1184,1210,2,5} ;
     var n1 : int ; n1 := arr1->size() ;
    OclFile["System.out"].println(countPairs(arr1, n1)) ; 
    var arr2 : Sequence(int) ; arr2 := Sequence{2620,2924,5020,5564,6232,6368} ;
    var n2 : int ; n2 := arr2->size() ;
    OclFile["System.out"].println(countPairs(arr2, n2)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int bitCount(int n){
    int count=0 ;
    while(n>0){
      if((n & 1)>0)++count ;
      n>>=1 ;
    }
    return count ;
  }
  static long countPairsWithKDiff(int arr[],int n,int k){
    long ans=0 ;
    for(int i=0 ; i<n-1 ; ++i){
      for(int j=i+1 ; j<n ; ++j){
        int xoredNum=arr[i] ^ arr[j];
        if(k==bitCount(xoredNum))++ans ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int k=2 ;
    int arr[]={
      2,4,1,3,1 };
      int n=arr.length ;
      System.out.println("Total pairs for k="+k+" are "+countPairsWithKDiff(arr,n,k)+"\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation bitCount( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     if ((n & 1) > 0) then     count := count + 1 ; else skip ; 
     n := n/(2->pow(1)) ) ; 
     return count );
  static   operation countPairsWithKDiff( arr : Sequence(int), n : int, k : int) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
         var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var xoredNum : int ; xoredNum := MathLib.bitwiseXor(arr[i+1],arr[j+1]) ;
     if (k = bitCount(xoredNum)) then     ans := ans + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 2 ;
     var arr : Sequence(int) ; arr := Sequence{2,4,1,3,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Total pairs for k=" + k + " are " + countPairsWithKDiff(arr, n, k) + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.reflect.*;
public class Main {
  private static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  private static StringTokenizer st ;
  public static void main(String[] args)throws IOException {
    new Main().cal();
  }
  private void cal()throws IOException {
    while(true){
      st=new StringTokenizer(br.readLine());
      int n=Integer.parseInt(st.nextToken());
      int a=Integer.parseInt(st.nextToken());
      int b=Integer.parseInt(st.nextToken());
      if(n==0 && a==0 && b==0)break ;
      int out=0 ;
      int temp ;
      if(a>b){
        temp=a ;
        a=b ;
        b=temp ;
      }
      if(a==b || b % a==0){
        out=n/a ;
        System.out.println(n-out);
        continue ;
      }
      if(a>n){
        System.out.println(n);
        continue ;
      }
      out+=n/a ;
      int subs=n % a ;
      int til ;
      for(til=1 ; til<a ; til++){
        if((til*b)>n ||(til*b)% a==0)break ;
      }
      for(int i=1 ; i<til ; i++){
        out+=((n-b*i)/a+1);
      }
      System.out.println(n-out);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute st : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().cal() );
   operation cal() : void
  pre: true
  post: true
  activity: (     while (true) do (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var n : int ; n := (st.next())->toInteger() ;
    var a : int ; a := (st.next())->toInteger() ;
    var b : int ; b := (st.next())->toInteger() ;
    if (n = 0 & a = 0 & b = 0) then     break else skip ; 
    var out : int ; out := 0 ;
    var temp : int ;
    if (a > b) then (     temp := a ; 
     a := b ; 
     b := temp ) else skip ; 
    if (a = b or b mod a = 0) then (     out := n / a ; 
     OclFile["System.out"].println(n - out) ; 
     continue ) else skip ; 
    if (a > n) then (     OclFile["System.out"].println(n) ; 
     continue ) else skip ; 
    out := out+(n / a) ; 
    var subs : int ; subs := n mod a ;
    var til : int ;
        til := 1 ; while til < a do ( (     if ((til * b) > n or (til * b) mod a = 0) then     break else skip )  ;     til := til + 1 ) ; 
        var i : int ; i := 1 ; while i < til do ( (     out := out+(((n - b * i) / a + 1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n - out) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),m=in.nextInt();
    Pair[] arr=new Pair[n];
    for(int i=0 ; i<n ; i++){
      int x=in.nextInt(),y=in.nextInt();
      arr[i]=new Pair(x,y);
    }
    int itail=arr[0] .tail ;
    if(n==1){
      System.out.println(arr[0] .tail>=m && arr[0] .head==0 ? "YES" : "NO");
    }
    else {
      for(int i=0 ; i<n-1 ; i++){
        if(arr[i+1] .head<=itail && arr[i+1] .tail>itail){
          itail=arr[i+1] .tail ;
        }
      }
      System.out.println(itail==m ? "YES" : "NO");
    }
  }
}
class Pair {
  int head ;
  int tail ;
  public Pair(int h,int t){
    head=h ;
    tail=t ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var arr : Sequence(Map) ; arr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
    var y : int ; y := in.getCurrent()->toInteger() ;
     arr[i+1] := Map(x, y) )  ;     i := i + 1 ) ; 
    var itail : int ; itail := arr[0+1].tail ;
    if (n = 1) then (     OclFile["System.out"].println(if arr[0+1].tail >= m & arr[0+1].head = 0 then "YES" else "NO" endif) ) else (         var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i + 1+1].head <= itail & arr[i + 1+1].tail > itail) then (     itail := arr[i + 1+1].tail ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if itail = m then "YES" else "NO" endif) ) ;  
 );
}
class Pair {
   attribute head : int;
   attribute tail : int;
   static operation newPair( h : int, t : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(h, t);
    return self );
  operation initialise( h : int, t : int) : void
  pre: true  post: true
  activity: (     head := h ; 
     tail := t );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[])throws IOException {
    Scanner bf=new Scanner(System.in);
    while(true){
      int n=bf.nextInt();
      int a=bf.nextInt();
      int b=bf.nextInt();
      if(n==0 && a==0 && b==0)break ;
      int[] list=new int[n+1];
      for(int i=0 ; i<n+1 ; i++)list[i]=0 ;
      list[0]=1 ;
      int counter=0 ;
      for(int i=0 ; i<n+1 ; i++){
        if(list[i]==1){
          if(i+a<n+1)list[i+a]=1 ;
          if(i+b<n+1)list[i+b]=1 ;
        }
        else counter++;
      }
      System.out.println(counter);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := bf.getCurrent()->toInteger() ;
     var a : int ; a := bf.getCurrent()->toInteger() ;
    var b : int ; b := bf.getCurrent()->toInteger() ;
    if (n = 0 & a = 0 & b = 0) then     break else skip ; 
    var list : Sequence(int) ; list := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n + 1 do (     list[i+1] := 0 ;  ;     i := i + 1 ) ; 
    list[0+1] := 1 ; 
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < n + 1 do ( (     if (list[i+1] = 1) then (     if (i + a < n + 1) then     list[i + a+1] := 1 ; else skip ; 
     if (i + b < n + 1) then     list[i + b+1] := 1 ; else skip ) else     counter := counter + 1 ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[]){
    FastReader input=new FastReader();
    PrintWriter out=new PrintWriter(System.out);
    int T=1 ;
    while(T-->0){
      long n=input.nextLong();
      long m=input.nextLong();
      int k=input.nextInt();
      if((n+m)% 2==1 && k==-1){
        out.println(0);
      }
      else {
        long mod=1000000007l ;
        long val=power(2l,m-1,mod);
        val=power(val,n-1,mod);
        out.println(val);
      }
    }
    out.close();
  }
  public static long power(long a,long b,long m){
    long res=1l ;
    while(b>0l){
      if(b % 2l!=0l){
        res=(res % m*a % m)% m ;
      }
      b=b/2l ;
      a=(a % m*a % m)% m ;
    }
    return res ;
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastReader ; input := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := 1 ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     var n : long ; n := input.nextLong() ;
     var m : long ; m := input.nextLong() ;
     var k : int ; k := input.nextInt() ;
     if ((n + m) mod 2 = 1 & k = -1) then (     skip ) else (     var mod : long ; mod := 1000000007l ;
     var val : long ; val := power(2l, m - 1, mod) ;
     val := power(val, n - 1, mod) ; 
     skip ) ) ;  ) ;  
    skip ; 
 );
  static   operation power( a : long, b : long, m : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1l ;
     while (b > 0l) do (     if (b mod 2l /= 0l) then (     res := (res mod m * a mod m) mod m ) else skip ; 
     b := b / 2l ; 
     a := (a mod m * a mod m) mod m ) ; 
     return res );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[]){
    FastReader input=new FastReader();
    PrintWriter out=new PrintWriter(System.out);
    int T=1 ;
    while(T-->0){
      long n=input.nextLong();
      long m=input.nextLong();
      int k=input.nextInt();
      if((n+m)% 2==1 && k==-1){
        out.println(0);
      }
      else {
        long mod=1000000007l ;
        long val=power(2l,m-1,mod);
        val=power(val,n-1,mod);
        out.println(val);
      }
    }
    out.close();
  }
  public static long power(long a,long b,long m){
    long res=1l ;
    while(b>0l){
      if(b % 2l!=0l){
        res=(res % m*a % m)% m ;
      }
      b=b/2l ;
      a=(a % m*a % m)% m ;
    }
    return res ;
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastReader ; input := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := 1 ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     var n : long ; n := input.nextLong() ;
     var m : long ; m := input.nextLong() ;
     var k : int ; k := input.nextInt() ;
     if ((n + m) mod 2 = 1 & k = -1) then (     skip ) else (     var mod : long ; mod := 1000000007l ;
     var val : long ; val := power(2l, m - 1, mod) ;
     val := power(val, n - 1, mod) ; 
     skip ) ) ;  ) ;  
    skip ; 
 );
  static   operation power( a : long, b : long, m : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1l ;
     while (b > 0l) do (     if (b mod 2l /= 0l) then (     res := (res mod m * a mod m) mod m ) else skip ; 
     b := b / 2l ; 
     a := (a mod m * a mod m) mod m ) ; 
     return res );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CodeForces_691B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] s=sc.next().toCharArray();
    for(int i=0,j=s.length-1 ; i<=j ; i+=1,j-=1){
      if(s[i]=='b' && s[j]=='d' || s[i]=='d' && s[j]=='b' || s[i]=='p' && s[j]=='q' || s[i]=='q' && s[j]=='p' || s[i]=='O' && s[j]=='O' || s[i]=='o' && s[j]=='o' || s[i]=='M' && s[j]=='M' || s[i]=='W' && s[j]=='W' || s[i]=='w' && s[j]=='w' || s[i]=='T' && s[j]=='T' || s[i]=='I' && s[j]=='I' || s[i]=='X' && s[j]=='X' || s[i]=='x' && s[j]=='x' || s[i]=='Y' && s[j]=='Y' || s[i]=='H' && s[j]=='H' || s[i]=='V' && s[j]=='V' || s[i]=='v' && s[j]=='v' || s[i]=='U' && s[j]=='U' || s[i]=='H' && s[j]=='H' || s[i]=='H' && s[j]=='H' || s[i]=='A' && s[j]=='A' || s[i]=='d' && s[j]=='b'){
      }
      else {
        System.out.println("NIE");
        return ;
      }
    }
    System.out.println("TAK");
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces_691B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
         var i : int ; i := 0 ;
    var j : int ; j := s->size() - 1 ; while i <= j do ( (     if (s[i+1] = 'b' & s[j+1] = 'd' or s[i+1] = 'd' & s[j+1] = 'b' or s[i+1] = 'p' & s[j+1] = 'q' or s[i+1] = 'q' & s[j+1] = 'p' or s[i+1] = 'O' & s[j+1] = 'O' or s[i+1] = 'o' & s[j+1] = 'o' or s[i+1] = 'M' & s[j+1] = 'M' or s[i+1] = 'W' & s[j+1] = 'W' or s[i+1] = 'w' & s[j+1] = 'w' or s[i+1] = 'T' & s[j+1] = 'T' or s[i+1] = 'I' & s[j+1] = 'I' or s[i+1] = 'X' & s[j+1] = 'X' or s[i+1] = 'x' & s[j+1] = 'x' or s[i+1] = 'Y' & s[j+1] = 'Y' or s[i+1] = 'H' & s[j+1] = 'H' or s[i+1] = 'V' & s[j+1] = 'V' or s[i+1] = 'v' & s[j+1] = 'v' or s[i+1] = 'U' & s[j+1] = 'U' or s[i+1] = 'H' & s[j+1] = 'H' or s[i+1] = 'H' & s[j+1] = 'H' or s[i+1] = 'A' & s[j+1] = 'A' or s[i+1] = 'd' & s[j+1] = 'b') then skip else (     OclFile["System.out"].println("NIE") ; 
     return ) )  ;     i := i+(1) ;     j := j-(1) ) ; 
     OclFile["System.out"].println("TAK") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CandidateCode {
  public static String SPalindromeChecker(String input){
    String sameMirrorimage="AHIMOoTUVvWwXxY" ;
    Map<String,String>mirrorImage=new HashMap<String,String>();
    mirrorImage.put("p","q");
    mirrorImage.put("b","d");
    mirrorImage.put("q","p");
    mirrorImage.put("d","b");
    for(int i=0 ; i<input.length(); i++){
      if(sameMirrorimage.contains(String.valueOf(input.charAt(i)))){
        if(input.charAt(i)!=input.charAt(input.length()-i-1)){
          return "NIE" ;
        }
      }
      else if(mirrorImage.containsKey(String.valueOf(input.charAt(i)))){
        if(! mirrorImage.get(String.valueOf(input.charAt(i))).equals(String.valueOf(input.charAt(input.length()-i-1)))){
          return "NIE" ;
        }
      }
      else {
        return "NIE" ;
      }
    }
    return "TAK" ;
  }
  public static void main(String args[])throws Exception {
    Scanner s=new Scanner(System.in);
    String input=s.nextLine();
    System.out.println(SPalindromeChecker(input));
  }
}
------------------------------------------------------------
OCL File:
---------
 class CandidateCode {
  static   operation SPalindromeChecker( input : String) : String
  pre: true
  post: true
  activity: (     var sameMirrorimage : String ; sameMirrorimage := "AHIMOoTUVvWwXxY" ;
     var mirrorImage : Map(String,String) ; mirrorImage := Map{} ;
    mirrorImage := mirrorImage->union(Map{"p" |-> "q"}) ; 
    mirrorImage := mirrorImage->union(Map{"b" |-> "d"}) ; 
    mirrorImage := mirrorImage->union(Map{"q" |-> "p"}) ; 
    mirrorImage := mirrorImage->union(Map{"d" |-> "b"}) ; 
        var i : int ; i := 0 ; while i < input->size() do ( (     if (sameMirrorimage->includes(((input->at(i+1)) + ""))) then (     if (input->at(i+1) /= input->at(input->size() - i - 1+1)) then (     return "NIE" ) else skip ) else     if (mirrorImage->keys()->includes(((input->at(i+1)) + ""))) then (     if (not(mirrorImage->at(((input->at(i+1)) + "")) = ((input->at(input->size() - i - 1+1)) + ""))) then (     return "NIE" ) else skip ) else (     return "NIE" ) ;  )  ;     i := i + 1 ) ; 
    return "TAK" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : String ; input := s.nextLine() ;
     OclFile["System.out"].println(SPalindromeChecker(input)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedHashSet ;
class GFG {
  static int repeated_digit(int n){
    LinkedHashSet<Integer>s=new LinkedHashSet<>();
    while(n!=0){
      int d=n % 10 ;
      if(s.contains(d)){
        return 0 ;
      }
      s.add(d);
      n=n/10 ;
    }
    return 1 ;
  }
  static int calculate(int L,int R){
    int answer=0 ;
    for(int i=L ; i<R+1 ; ++i){
      answer=answer+repeated_digit(i);
    }
    return answer ;
  }
  public static void main(String[] args){
    int L=1,R=100 ;
    System.out.println(calculate(L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation repeated_digit( n : int) : int
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
     while (n /= 0) do (     var d : int ; d := n mod 10 ;
     if (s->includes(d)) then (     return 0 ) else skip ; 
     s := s->including(d) ; 
     n := n / 10 ) ; 
     return 1 );
  static   operation calculate( L : int, R : int) : int
  pre: true
  post: true
  activity: (     var answer : int ; answer := 0 ;
         var i : int ; i := L ; while i < R + 1 do ( (     answer := answer + repeated_digit(i) )  ;     i := i + 1 ) ; 
     return answer );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 1 ;
    var R : int ; R := 100 ;
     OclFile["System.out"].println(calculate(L, R)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Geeks {
  static int reverse(int num){
    int rev_num=0 ;
    while(num>0){
      rev_num=rev_num*10+num % 10 ;
      num=num/10 ;
    }
    return rev_num ;
  }
  static int countReverse(int arr[],int n){
    int res=0 ;
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++)if(reverse(arr[i])==arr[j]){
      res++;
    }
    return res ;
  }
  public static void main(String[] args){
    int a[]={
      16,61,12,21,25 };
      int n=a.length ;
      System.out.print(countReverse(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class Geeks {
  static   operation reverse( num : int) : int
  pre: true
  post: true
  activity: (     var rev_num : int ; rev_num := 0 ;
     while (num > 0) do (     rev_num := rev_num * 10 + num mod 10 ; 
     num := num / 10 ) ; 
     return rev_num );
  static   operation countReverse( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do (     if (reverse(arr[i+1]) = arr[j+1]) then (     res := res + 1 ) else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{16,61,12,21,25} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(countReverse(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class A_Remove_Smallest {
  public static void main(String[] args){
    Scanner sn=new Scanner(System.in);
    int t=sn.nextInt();
    while(t-->0){
      int n=sn.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=sn.nextInt();
      Arrays.sort(arr);
      int i ;
      for(i=0 ; i<n-1 ; i++){
        if((arr[i+1]-arr[i])<=1)continue ;
        else break ;
      }
      if(i==n-1)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Remove_Smallest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sn : OclFile ; sn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sn.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sn.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sn.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var i : int ;
        i := 0 ; while i < n - 1 do ( (     if ((arr[i + 1+1] - arr[i+1]) <= 1) then     continue else     break )  ;     i := i + 1 ) ; 
    if (i = n - 1) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class FactorsCombination {
  public static List<List<Integer>>factComb(int n){
    List<List<Integer>>result_list=new ArrayList<List<Integer>>();
    List<Integer>list=new ArrayList<Integer>();
    factorsListFunc(2,1,n,result_list,list);
    return result_list ;
  }
  public static void factorsListFunc(int first,int each_prod,int n,List<List<Integer>>result_list,List<Integer>single_result_list){
    if(first>n || each_prod>n)return ;
    if(each_prod==n){
      ArrayList<Integer>t=new ArrayList<Integer>(single_result_list);
      result_list.add(t);
      return ;
    }
    for(int i=first ; i<n ; i++){
      if(i*each_prod>n)break ;
      if(n % i==0){
        single_result_list.add(i);
        factorsListFunc(i,i*each_prod,n,result_list,single_result_list);
        single_result_list.remove(single_result_list.size()-1);
      }
    }
  }
  public static void main(String[] args){
    int n=16 ;
    List<List<Integer>>resultant=factComb(n);
    for(List<Integer>i : resultant){
      for(int j : i)System.out.print(j+" ");
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class FactorsCombination {
  static   operation factComb( n : int) : Sequence(Sequence(int))
  pre: true
  post: true
  activity: (     var result_list : Sequence(Sequence(int)) ; result_list := Sequence{} ;
     var list : Sequence(int) ; list := Sequence{} ;
     execute factorsListFunc(2, 1, n, result_list, list) ; 
     return result_list );
  static   operation factorsListFunc( first : int, each_prod : int, n : int, result_list : Sequence(Sequence(int)), single_result_list : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (first > n or each_prod > n) then     return else skip ; 
     if (each_prod = n) then (     var t : Sequence(int) ; t := Sequence{}->union(single_result_list) ;
     result_list := result_list->including(t) ; 
     return ) else skip ; 
         var i : int ; i := first ; while i < n do ( (     if (i * each_prod > n) then     break else skip ; 
     if (n mod i = 0) then (     single_result_list->excludes(i) ; 
     execute factorsListFunc(i, i * each_prod, n, result_list, single_result_list) ; 
     single_result_list := single_result_list->excludingFirst(single_result_list->size() - 1) ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 16 ;
     var resultant : Sequence(Sequence(int)) ; resultant := factComb(n) ;
     for (i : resultant) do ( (     for (j : i) do (     OclFile["System.out"].print(j + " ") ;  ) ; 
     OclFile["System.out"].println() )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int a=scanner.nextInt();
    int b=scanner.nextInt();
    int c=scanner.nextInt();
    int[] d=new int[n];
    for(int i=0 ; i<n ; i++)d[i]=scanner.nextInt();
    Arrays.sort(d);
    int ans=c/a ;
    for(int i=n-1 ; i>=0 ; i--){
      c+=d[i];
      a+=b ;
      ans=Math.max(ans,c/a);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     d[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    d := d->sort() ; 
    var ans : int ; ans := c / a ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     c := c+(d[i+1]) ; 
     a := a+(b) ; 
     ans := Set{ans, c / a}->max() )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int check(int n){
    int sum=0 ;
    while(n!=0){
      sum+=n % 10 ;
      n=n/10 ;
    }
    if(sum % 7==0)return 1 ;
    else return 0 ;
  }
  public static void main(String args[]){
    int n=25 ;
    String s=(check(n)==1)? "YES" : "NO" ;
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n /= 0) do (     sum := sum+(n mod 10) ; 
     n := n / 10 ) ; 
     if (sum mod 7 = 0) then     return 1 else     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 25 ;
     var s : String ; s := if (check(n) = 1) then "YES" else "NO" endif ;
     OclFile["System.out"].println(s) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Solve s=new Solve();
    s.solve();
  }
}
class Solve {
  Solve(){
  }
  Scanner in=new Scanner(System.in);
  void solve(){
    int n=in.nextInt();
    int a=in.nextInt(),b=in.nextInt();
    int c=in.nextInt();
    int[] d=new int[n];
    for(int i=0 ; i<n ; i++)d[i]=-in.nextInt();
    Arrays.sort(d);
    int ans=c,i=0 ;
    while(true){
      if((double)c/a<(double)(c-d[i])/(a+b)){
        c-=d[i];
        a+=b ;
        i++;
      }
      else break ;
    }
    System.out.println(c/a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Solve ; s := Solve.newSolve() ;
     s.solve() );
}
class Solve {
   static operation newSolve() : Solve
  pre: true
  post: true
  activity:
  ( var self : Solve ;
    self := createSolve();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     d[i+1] := -in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    d := d->sort() ; 
    var ans : int ; ans := c ;
    var i : int ; i := 0 ;
    while (true) do (     if (c->oclAsType(double) / a < (c - d[i+1])->oclAsType(double) / (a + b)) then (     c := c-(d[i+1]) ; 
     a := a+(b) ; 
     i := i + 1 ) else     break ) ; 
    OclFile["System.out"].println(c / a) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A,B,C ;
    int N=sc.nextInt();
    int[] topping=new int[N];
    A=sc.nextInt();
    B=sc.nextInt();
    C=sc.nextInt();
    for(int i=0 ; i<N ; i++){
      topping[i]=sc.nextInt();
    }
    sort_down00(topping,N);
    for(int i=0 ; i<N ; i++){
      if((C/A)<=((C+topping[i])/(A+B))){
        C+=topping[i];
        A+=B ;
      }
      else {
        break ;
      }
    }
    System.out.println((int)C/A);
  }
  static void sort_down00(int[] data,int n){
    int i ;
    int idx ;
    int work ;
    for(i=0 ; i<n ; i++){
      idx=max_idx00(data,i,n);
      work=data[i];
      data[i]=data[idx];
      data[idx]=work ;
    }
    return ;
  }
  static int max_idx00(int[] data,int from,int to){
    int i ;
    int idx=from ;
    for(i=from ; i<to ; i++){
      if(data[idx]<data[i]){
        idx=i ;
      }
    }
    return idx ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ;
    var B : int ;
    var C : int ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var topping : Sequence(int) ; topping := Integer.subrange(1,N)->collect(0) ;
    A := sc.getCurrent()->toInteger() ; 
    B := sc.getCurrent()->toInteger() ; 
    C := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < N do ( (     topping[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute sort_down00(topping, N) ; 
        var i : int ; i := 0 ; while i < N do ( (     if ((C / A) <= ((C + topping[i+1]) / (A + B))) then (     C := C+(topping[i+1]) ; 
     A := A+(B) ) else (     break ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(C->oclAsType(int) / A) ; 
 );
  static   operation sort_down00( data : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
     var idx : int ;
    var work : int ;
        i := 0 ; while i < n do ( (     idx := max_idx00(data, i, n) ; 
     work := data[i+1] ; 
     data[i+1] := data[idx+1] ; 
     data[idx+1] := work )  ;     i := i + 1 ) ; 
    return 
 );
  static   operation max_idx00( data : Sequence(int), from : int, to : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
     var idx : int ; idx := from ;
         i := from ; while i < to do ( (     if (data[idx+1] < data[i+1]) then (     idx := i ) else skip )  ;     i := i + 1 ) ; 
     return idx );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int topping_num=stdIn.nextInt();
    int material_value=stdIn.nextInt();
    int topping_value=stdIn.nextInt();
    int material_calorie=stdIn.nextInt();
    int[] data=new int[topping_num];
    int[] sum=new int[topping_num+1];
    for(int r=0 ; r<data.length ; r++)data[r]=stdIn.nextInt();
    Arrays.sort(data);
    for(int r=0 ; r<data.length ; r++){
      sum[r+1]=(sum[r]+data[r]);
    }
    int ans=-1 ;
    for(int r=sum.length-1 ; r>0 ; r--){
      for(int c=1 ; c<r ; c++){
        int psum=(sum[r]-sum[c]+material_calorie)/(material_value+topping_value*(r-c));
        if(psum>ans){
          ans=psum ;
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var topping_num : int ; topping_num := stdIn.getCurrent()->toInteger() ;
    var material_value : int ; material_value := stdIn.getCurrent()->toInteger() ;
    var topping_value : int ; topping_value := stdIn.getCurrent()->toInteger() ;
    var material_calorie : int ; material_calorie := stdIn.getCurrent()->toInteger() ;
    var data : Sequence(int) ; data := Integer.subrange(1,topping_num)->collect(0) ;
    var sum : Sequence(int) ; sum := Integer.subrange(1,topping_num + 1)->collect(0) ;
        var r : int ; r := 0 ; while r < data->size() do (     data[r+1] := stdIn.getCurrent()->toInteger() ;  ;     r := r + 1 ) ; 
    data := data->sort() ; 
        var r : int ; r := 0 ; while r < data->size() do ( (     sum[r + 1+1] := (sum[r+1] + data[r+1]) )  ;     r := r + 1 ) ; 
    var ans : int ; ans := -1 ;
        var r : int ; r := sum->size() - 1 ; while r > 0 do ( (         var c : int ; c := 1 ; while c < r do ( (     var psum : int ; psum := (sum[r+1] - sum[c+1] + material_calorie) / (material_value + topping_value * (r - c)) ;
     if (psum > ans) then (     ans := psum ) else skip )  ;     c := c + 1 ) )  ;     r := r - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int i,j,x,c ;
    double max=0.0 ;
    int tn=sc.nextInt();
    Integer[] tc=new Integer[tn];
    int pv=sc.nextInt();
    int tv=sc.nextInt();
    int pc=sc.nextInt();
    for(i=0 ; i<tn ; i++){
      tc[i]=sc.nextInt();
    }
    Arrays.sort(tc,Collections.reverseOrder());
    c=0 ;
    for(i=0 ; i<tn ; i++){
      if(i==0)max=pc ;
      if(max/(pv+c*tv)<((max+tc[i])/(pv+(c+1)*tv))){
        max=max+tc[i];
        c++;
      }
    }
    System.out.printf("%d\n",(int)max/(pv+c*tv));
    sc.close();
    System.exit(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ;
    var j : int ;
    var x : int ;
    var c : int ;
    var max : double ; max := 0.0 ;
    var tn : int ; tn := sc.getCurrent()->toInteger() ;
    var tc : Sequence(int) ; tc := Integer.subrange(1,tn)->collect(null) ;
    var pv : int ; pv := sc.getCurrent()->toInteger() ;
    var tv : int ; tv := sc.getCurrent()->toInteger() ;
    var pc : int ; pc := sc.getCurrent()->toInteger() ;
        i := 0 ; while i < tn do ( (     tc[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    tc := OclComparator.sortWith(tc, reverseOrder()) ; 
    c := 0 ; 
        i := 0 ; while i < tn do ( (     if (i = 0) then     max := pc ; else skip ; 
     if (max / (pv + c * tv) < ((max + tc[i+1]) / (pv + (c + 1) * tv))) then (     max := max + tc[i+1] ; 
     c := c + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%d\n", max->oclAsType(int) / (pv + c * tv)) ; 
    skip ; 
OclProcess.exit(0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int b=scanner.nextInt();
    int[] arr=new int[b];
    for(int i=0 ; i<b ; i++){
      arr[i]=scanner.nextInt();
    }
    int g=scanner.nextInt();
    int[] brr=new int[g];
    for(int i=0 ; i<g ; i++){
      brr[i]=scanner.nextInt();
    }
    Arrays.sort(arr);
    Arrays.sort(brr);
    int min=Math.min(g,b);
    int index=0 ;
    int index2=0 ;
    int count=0 ;
    for(int i=0 ; ; i++){
      if(index>=b || index2>=g){
        break ;
      }
      if(Math.abs(arr[index]-brr[index2])<2){
        count++;
        index++;
        index2++;
      }
      else {
        if(arr[index]>brr[index2]){
          index2++;
        }
        else if(arr[index]<brr[index2]){
          index++;
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,b)->collect(0) ;
        var i : int ; i := 0 ; while i < b do ( (     arr[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var g : int ; g := scanner.getCurrent()->toInteger() ;
    var brr : Sequence(int) ; brr := Integer.subrange(1,g)->collect(0) ;
        var i : int ; i := 0 ; while i < g do ( (     brr[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    brr := brr->sort() ; 
    var min : int ; min := Set{g, b}->min() ;
    var index : int ; index := 0 ;
    var index2 : int ; index2 := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while true do ( (     if (index >= b or index2 >= g) then (     break ) else skip ; 
     if (if arr[index+1] - brr[index2+1] < 0 then -(arr[index+1] - brr[index2+1]) else arr[index+1] - brr[index2+1] endif < 2) then (     count := count + 1 ; 
     index := index + 1 ; 
     index2 := index2 + 1 ) else (     if (arr[index+1] > brr[index2+1]) then (     index2 := index2 + 1 ) else     if (arr[index+1] < brr[index2+1]) then (     index := index + 1 ) else skip ; ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int b[]=new int[n];
    for(int i=0 ; i<n ; i++){
      b[i]=sc.nextInt();
    }
    int m=sc.nextInt();
    int g[]=new int[m];
    for(int i=0 ; i<m ; i++){
      g[i]=sc.nextInt();
    }
    int cnt=0 ;
    Arrays.sort(b);
    Arrays.sort(g);
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(Math.abs(b[i]-g[j])<=1 &&(b[i]!=0 && g[j]!=0)){
          cnt++;
          b[i]=0 ;
          g[j]=0 ;
        }
      }
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var g : Sequence(int) ; g := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     g[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    b := b->sort() ; 
    g := g->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (if b[i+1] - g[j+1] < 0 then -(b[i+1] - g[j+1]) else b[i+1] - g[j+1] endif <= 1 & (b[i+1] /= 0 & g[j+1] /= 0)) then (     cnt := cnt + 1 ; 
     b[i+1] := 0 ; 
     g[j+1] := 0 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    int m=sc.nextInt();
    int[] b=new int[m];
    for(int i=0 ; i<m ; i++){
      b[i]=sc.nextInt();
    }
    Arrays.sort(a);
    Arrays.sort(b);
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(Math.abs(a[i]-b[j])<=1 && b[j]!=-1){
          cnt++;
          b[j]=-1 ;
          break ;
        }
      }
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (if a[i+1] - b[j+1] < 0 then -(a[i+1] - b[j+1]) else a[i+1] - b[j+1] endif <= 1 & b[j+1] /= -1) then (     cnt := cnt + 1 ; 
     b[j+1] := -1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      int a=in.nextInt();
      int[] arr=new int[a];
      for(int j=0 ; j<a ; j++){
        arr[j]=in.nextInt();
      }
      Arrays.sort(arr);
      int count=0 ;
      for(int j=1 ; j<a ; j++){
        if(arr[j]-arr[j-1]<=1){
          count++;
        }
      }
      if(count==a-1)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,a)->collect(0) ;
        var j : int ; j := 0 ; while j < a do ( (     arr[j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    arr := arr->sort() ; 
    var count : int ; count := 0 ;
        var j : int ; j := 1 ; while j < a do ( (     if (arr[j+1] - arr[j - 1+1] <= 1) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
    if (count = a - 1) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.*;
import java.lang.Math ;
import java.util.Formatter ;
import java.util.Arrays ;
public class Esepka {
  public static void main(String[] args){
    Scanner reader=new Scanner(System.in);
    int n=reader.nextInt(),a[]=new int[n],au[]=new int[n],ans=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=reader.nextInt();
    }
    int m=reader.nextInt(),b[]=new int[m],bu[]=new int[m];
    for(int i=0 ; i<m ; i++){
      b[i]=reader.nextInt();
    }
    Arrays.sort(a);
    Arrays.sort(b);
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if((a[i]==b[j] || a[i]+1==b[j] || a[i]==b[j]+1)&& au[i]==0 && bu[j]==0 && a[i]>0 && b[j]>0){
          ans++;
          au[i]=1 ;
          bu[j]=1 ;
          break ;
        }
      }
    }
    System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Esepka {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := reader.getCurrent()->toInteger() ;
    var a : Sequence(void) ; a := Integer.subrange(1,n)->collect(0) ;
    var au : Sequence(void) ; au := Integer.subrange(1,n)->collect(0) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := reader.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := reader.getCurrent()->toInteger() ;
    var b : Sequence(void) ; b := Integer.subrange(1,m)->collect(0) ;
    var bu : Sequence(void) ; bu := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := reader.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if ((a[i+1] = b[j+1] or a[i+1] + 1 = b[j+1] or a[i+1] = b[j+1] + 1) & au[i+1] = 0 & bu[j+1] = 0 & a[i+1] > 0 & b[j+1] > 0) then (     ans := ans + 1 ; 
     au[i+1] := 1 ; 
     bu[j+1] := 1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  private static BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  private static Scanner sc=new Scanner(System.in);
  public static void main(String[] args)throws IOException {
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    int m=sc.nextInt();
    int[] b=new int[m];
    for(int i=0 ; i<m ; i++)b[i]=sc.nextInt();
    Arrays.sort(a);
    Arrays.sort(b);
    int p=0 ;
    int q=0 ;
    int cnt=0 ;
    while(p<n && q<m){
      if(Math.abs(a[p]-b[q])<=1){
        p++;
        q++;
        cnt++;
      }
      else {
        if(a[p]>b[q]){
          q++;
        }
        else {
          p++;
        }
      }
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     b[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    var p : int ; p := 0 ;
    var q : int ; q := 0 ;
    var cnt : int ; cnt := 0 ;
    while (p < n & q < m) do (     if (if a[p+1] - b[q+1] < 0 then -(a[p+1] - b[q+1]) else a[p+1] - b[q+1] endif <= 1) then (     p := p + 1 ; 
     q := q + 1 ; 
     cnt := cnt + 1 ) else (     if (a[p+1] > b[q+1]) then (     q := q + 1 ) else (     p := p + 1 ) ) ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class xr {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int res=a+b ;
    String sa=a+"",sb=b+"",sres=res+"" ;
    String sa1="",sb1="",sres1="" ;
    for(int i=0 ; i<sa.length(); i++){
      if(sa.charAt(i)!='0')sa1+=sa.charAt(i);
    }
    for(int i=0 ; i<sb.length(); i++){
      if(sb.charAt(i)!='0')sb1+=sb.charAt(i);
    }
    for(int i=0 ; i<sres.length(); i++){
      if(sres.charAt(i)!='0')sres1+=sres.charAt(i);
    }
    int f1=Integer.parseInt(sa1);
    int f2=Integer.parseInt(sb1);
    int f3=Integer.parseInt(sres1);
    if(f1+f2==f3)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class xr {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var res : int ; res := a + b ;
    var sa : String ; sa := a + "" ;
    var sb : String ; sb := b + "" ;
    var sres : String ; sres := res + "" ;
    var sa1 : String ; sa1 := "" ;
    var sb1 : String ; sb1 := "" ;
    var sres1 : String ; sres1 := "" ;
        var i : int ; i := 0 ; while i < sa->size() do ( (     if (sa->at(i+1) /= '0') then     sa1 := sa1+(sa->at(i+1)) ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < sb->size() do ( (     if (sb->at(i+1) /= '0') then     sb1 := sb1+(sb->at(i+1)) ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < sres->size() do ( (     if (sres->at(i+1) /= '0') then     sres1 := sres1+(sres->at(i+1)) ; else skip )  ;     i := i + 1 ) ; 
    var f1 : int ; f1 := (sa1)->toInteger() ;
    var f2 : int ; f2 := (sb1)->toInteger() ;
    var f3 : int ; f3 := (sres1)->toInteger() ;
    if (f1 + f2 = f3) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String constructPalin(char[] str,int len){
    int i=0,j=len-1 ;
    for(; i<j ; i++,j--){
      if(str[i]==str[j] && str[i]!='*')continue ;
      else if(str[i]==str[j] && str[i]=='*'){
        str[i]='a' ;
        str[j]='a' ;
        continue ;
      }
      else if(str[i]=='*'){
        str[i]=str[j];
        continue ;
      }
      else if(str[j]=='*'){
        str[j]=str[i];
        continue ;
      }
      System.out.println("Not Possible");
      return "" ;
    }
    return String.valueOf(str);
  }
  public static void main(String[] args){
    String str="bca*xc**b" ;
    int len=str.length();
    System.out.println(constructPalin(str.toCharArray(),len));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation constructPalin( str : Sequence(String), len : int) : String
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var j : int ; j := len - 1 ;
       while i < j do ( (     if (str[i+1] = str[j+1] & str[i+1] /= '*') then     continue else     if (str[i+1] = str[j+1] & str[i+1] = '*') then (     str[i+1] := 'a' ; 
     str[j+1] := 'a' ; 
     continue ) else     if (str[i+1] = '*') then (     str[i+1] := str[j+1] ; 
     continue ) else     if (str[j+1] = '*') then (     str[j+1] := str[i+1] ; 
     continue ) else skip ; ;  ;  ;  
     OclFile["System.out"].println("Not Possible") ; 
     return "" )  ;     i := i + 1 ;     j := j - 1 ) ; 
     return ((str) + "") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "bca*xc**b" ;
     var len : int ; len := str->size() ;
     OclFile["System.out"].println(constructPalin(str->characters(), len)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication31 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String word1=sc.next();
    String word2=sc.next();
    int num1=Integer.parseInt(word1)+Integer.parseInt(word2);
    String s=String.valueOf(num1);
    s=s.replaceAll("0","");
    num1=Integer.parseInt(s);
    word1=word1.replaceAll("0","");
    word2=word2.replaceAll("0","");
    int num2=Integer.parseInt(word1)+Integer.parseInt(word2);
    if(num1==num2){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication31 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var word1 : String ; word1 := sc.getCurrent() ;
    var word2 : String ; word2 := sc.getCurrent() ;
    var num1 : int ; num1 := (word1)->toInteger() + (word2)->toInteger() ;
    var s : String ; s := ((num1) + "") ;
    s := s.replaceAllMatches("0", "" ) ; 
    num1 := (s)->toInteger() ; 
    word1 := word1.replaceAllMatches("0", "" ) ; 
    word2 := word2.replaceAllMatches("0", "" ) ; 
    var num2 : int ; num2 := (word1)->toInteger() + (word2)->toInteger() ;
    if (num1 = num2) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.String ;
public class RemoveZeroProgram {
  public static int removeZero(int num){
    String s=String.valueOf(num);
    StringBuilder sb=new StringBuilder();
    int l=s.length();
    for(int i=0 ; i<l ; i++){
      if(s.charAt(i)!='0'){
        sb.append(s.charAt(i));
      }
    }
    return Integer.parseInt(sb.toString());
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int sum=a+b ;
    int a_new=removeZero(a);
    int b_new=removeZero(b);
    int sum_new=removeZero(sum);
    if(a_new+b_new==sum_new){
      System.out.print("YES");
    }
    else {
      System.out.print("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class RemoveZeroProgram {
  static   operation removeZero( num : int) : int
  pre: true
  post: true
  activity: (     var s : String ; s := ((num) + "") ;
     var sb : String ; sb := StringLib.newString() ;
    var l : int ; l := s->size() ;
        var i : int ; i := 0 ; while i < l do ( (     if (s->at(i+1) /= '0') then (     sb := sb + StringLib.newString(s->at(i+1)) ) else skip )  ;     i := i + 1 ) ; 
    return (sb+"")->toInteger() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := a + b ;
    var a_new : int ; a_new := removeZero(a) ;
    var b_new : int ; b_new := removeZero(b) ;
    var sum_new : int ; sum_new := removeZero(sum) ;
    if (a_new + b_new = sum_new) then (     OclFile["System.out"].print("YES") ) else (     OclFile["System.out"].print("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class CJ2 {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String inp[]=br.readLine().split(" ");
    int c=Integer.parseInt(inp[0]);
    int d=Integer.parseInt(inp[1]);
    inp=br.readLine().split(" ");
    int n=Integer.parseInt(inp[0]);
    int m=Integer.parseInt(inp[1]);
    int k=Integer.parseInt(br.readLine());
    int minfinalists=n*m-k ;
    int x=0 ;
    int y=0 ;
    int ymax=minfinalists ;
    int minscore=Integer.MAX_VALUE ;
    if(k>=n*m){
      minscore=0 ;
      minfinalists=0 ;
      ymax=-1 ;
    }
    for(int i=0 ; i<ymax+1 ; i++){
      y=i ;
      x=(int)Math.ceil((float)(minfinalists-y)/n);
      minscore=Math.min(x*c+y*d,minscore);
    }
    System.out.println(minscore);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CJ2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var inp : Sequence(String) ; inp := br.readLine()->split(" ") ;
    var c : int ; c := (inp[0+1])->toInteger() ;
    var d : int ; d := (inp[1+1])->toInteger() ;
    inp := br.readLine()->split(" ") ; 
    var n : int ; n := (inp[0+1])->toInteger() ;
    var m : int ; m := (inp[1+1])->toInteger() ;
    var k : int ; k := (br.readLine())->toInteger() ;
    var minfinalists : int ; minfinalists := n * m - k ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var ymax : int ; ymax := minfinalists ;
    var minscore : int ; minscore := 2147483647 ;
    if (k >= n * m) then (     minscore := 0 ; 
     minfinalists := 0 ; 
     ymax := -1 ) else skip ; 
        var i : int ; i := 0 ; while i < ymax + 1 do ( (     y := i ; 
     x := ((minfinalists - y)->oclAsType(double) / n)->ceil()->oclAsType(int) ; 
     minscore := Set{x * c + y * d, minscore}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(minscore) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int c=sc.nextInt();
    int d=sc.nextInt();
    int n=sc.nextInt();
    int m=sc.nextInt();
    int k=sc.nextInt();
    int req=(n*m)-k ;
    if(req<=0){
      System.out.println(0);
      return ;
    }
    int d1=req/n ;
    if(req % n!=0)d1++;
    int a1=d1*c ;
    int d2=req/n ;
    int a2=d2*c ;
    int r=req % n ;
    a2+=r*d ;
    int a3=d*req ;
    int min1=Math.min(a1,a2);
    min1=Math.min(min1,a3);
    System.out.println(min1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var req : int ; req := (n * m) - k ;
    if (req <= 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var d1 : int ; d1 := req / n ;
    if (req mod n /= 0) then     d1 := d1 + 1 ; else skip ; 
    var a1 : int ; a1 := d1 * c ;
    var d2 : int ; d2 := req / n ;
    var a2 : int ; a2 := d2 * c ;
    var r : int ; r := req mod n ;
    a2 := a2+(r * d) ; 
    var a3 : int ; a3 := d * req ;
    var min1 : int ; min1 := Set{a1, a2}->min() ;
    min1 := Set{min1, a3}->min() ; 
    OclFile["System.out"].println(min1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.text.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String st[]=br.readLine().split(" ");
    int c=Integer.parseInt(st[0]);
    int d=Integer.parseInt(st[1]);
    st=br.readLine().split(" ");
    int n=Integer.parseInt(st[0]);
    int m=Integer.parseInt(st[1]);
    st=br.readLine().split(" ");
    int k=Integer.parseInt(st[0]);
    int dp[][]=new int[2][1000000];
    for(int i=1 ; i<dp[0] .length ; i++){
      if(i-n>=0 && dp[0][i-n]!=Integer.MAX_VALUE){
        dp[0][i]+=dp[0][i-n]+c ;
      }
      else {
        dp[0][i]=Integer.MAX_VALUE ;
      }
    }
    int ans=Integer.MAX_VALUE ;
    for(int i=0 ; i<dp[0] .length ; i++){
      if(i-1>=0)dp[1][i]=Math.min(dp[1][i-1]+d,dp[0][i]);
      if(i>=n*m-k)ans=Math.min(ans,dp[1][i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : Sequence(String) ; st := br.readLine()->split(" ") ;
    var c : int ; c := (st[0+1])->toInteger() ;
    var d : int ; d := (st[1+1])->toInteger() ;
    st := br.readLine()->split(" ") ; 
    var n : int ; n := (st[0+1])->toInteger() ;
    var m : int ; m := (st[1+1])->toInteger() ;
    st := br.readLine()->split(" ") ; 
    var k : int ; k := (st[0+1])->toInteger() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,1000000)->collect(0)) ;
        var i : int ; i := 1 ; while i < dp[0+1]->size() do ( (     if (i - n >= 0 & dp[0+1][i - n+1] /= 2147483647) then (     dp[0+1][i+1] := dp[0+1][i+1]+(dp[0+1][i - n+1] + c) ) else (     dp[0+1][i+1] := 2147483647 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i < dp[0+1]->size() do ( (     if (i - 1 >= 0) then     dp[1+1][i+1] := Set{dp[1+1][i - 1+1] + d, dp[0+1][i+1]}->min() ; else skip ; 
     if (i >= n * m - k) then     ans := Set{ans, dp[1+1][i+1]}->min() ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int N=10,M=10010 ;
  static int[] v=new int[N];
  static int[] w=new int[N];
  static int[] f=new int[M];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=2 ;
    w[1]=sc.nextInt();
    w[2]=sc.nextInt();
    v[1]=sc.nextInt();
    v[2]=1 ;
    int m=sc.nextInt()*v[1];
    int k=sc.nextInt();
    m-=k ;
    if(m<0){
      System.out.println(0);
      return ;
    }
    Arrays.fill(f,0x3f3f3f3f);
    f[0]=0 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=0 ; j<=m ; j++){
        f[j]=Math.min(f[j],f[Math.max(0,j-v[i])]+w[i]);
      }
    }
    System.out.println(f[m]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int := 10;
  static   attribute v : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static   attribute w : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static   attribute f : Sequence(int) := Integer.subrange(1,M)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := 2 ;
    w[1+1] := sc.getCurrent()->toInteger() ; 
    w[2+1] := sc.getCurrent()->toInteger() ; 
    v[1+1] := sc.getCurrent()->toInteger() ; 
    v[2+1] := 1 ; 
    var m : int ; m := sc.getCurrent()->toInteger() * v[1+1] ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    m := m-(k) ; 
    if (m < 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    f := f->collect(0x3f3f3f3f) ; 
    f[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= m do ( (     f[j+1] := Set{f[j+1], f[Set{0, j - v[i+1]}->max()+1] + w[i+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(f[m+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Code_1399A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    boolean[] res=new boolean[t];
    Arrays.fill(res,true);
    for(int testcase=0 ; testcase<t ; testcase++){
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      Arrays.sort(arr);
      for(int i=arr.length-1 ; i>0 ; i--){
        if(arr[i]-arr[i-1]>1){
          res[testcase]=false ;
          break ;
        }
      }
    }
    for(boolean b : res){
      if(b)System.out.println("YES");
      else System.out.println("NO");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code_1399A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var res : Sequence(boolean) ; res := Integer.subrange(1,t)->collect(false) ;
    res := res->collect(true) ; 
        var testcase : int ; testcase := 0 ; while testcase < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := arr->size() - 1 ; while i > 0 do ( (     if (arr[i+1] - arr[i - 1+1] > 1) then (     res[testcase+1] := false ; 
     break ) else skip )  ;     i := i - 1 ) ; 
 )  ;     testcase := testcase + 1 ) ; 
    for (b : res) do ( (     if (b) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; )  ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findkth(int n,int k){
    Vector<Integer>v=new Vector<Integer>();
    for(int i=1 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        v.add(i);
        if(i!=Math.sqrt(n))v.add(n/i);
      }
    }
    Collections.sort(v);
    if(k>v.size())System.out.print("Doesn't Exist");
    else System.out.print(v.get(k-1));
  }
  public static void main(String[] args){
    int n=15,k=2 ;
    findkth(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findkth( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Sequence{} ;
         var i : int ; i := 1 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     v := v->including(i) ; 
     if (i /= (n)->sqrt()) then     v := v->including(n / i) ; else skip ) else skip )  ;     i := i + 1 ) ; 
     v := v->sort() ; 
     if (k > v->size()) then     OclFile["System.out"].print("Doesn't Exist") ; else     OclFile["System.out"].print(v->at(k - 1+1)) ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
    var k : int ; k := 2 ;
     execute findkth(n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
class Solution {
  public int numUniqueEmails(String[] emails){
    HashSet<String>emailSet=new HashSet<>();
    for(String email : emails){
      String firstSplit[]=email.split("@");
      String secondSplit[]=firstSplit[0] .replaceAll(".","").split("[+] ");
      emailSet.add(secondSplit[0]+firstSplit[1]);
    }
    return emailSet.size();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
   operation numUniqueEmails( emails : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var emailSet : Set(String) ; emailSet := Set{} ;
     for (email : emails) do ( (     var firstSplit : Sequence(String) ; firstSplit := email->split("@") ;
     var secondSplit : Sequence(String) ; secondSplit := firstSplit[0+1].replaceAllMatches(".", "" )->split("[+] ") ;
     emailSet := emailSet->including(secondSplit[0+1] + firstSplit[1+1]) )  ) ; 
     return emailSet->size() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double extrapolate(double[][] d,double x){
    double y=d[0][1]+(x-d[0][0])/(d[1][0]-d[0][0])*(d[1][1]-d[0][1]);
    return y ;
  }
  public static void main(String[] args){
    double[][] d={
      {
        1.2,2.7 },{
          1.4,3.1 }
        };
        double x=2.1 ;
        System.out.println("Value of y at x=2.1 : "+extrapolate(d,x));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation extrapolate( d : Sequence(Sequence(double)), x : double) : double
  pre: true
  post: true
  activity: (     var y : double ; y := d[0+1][1+1] + (x - d[0+1][0+1]) / (d[1+1][0+1] - d[0+1][0+1]) * (d[1+1][1+1] - d[0+1][1+1]) ;
     return y );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : Sequence(Sequence(double)) ; d := Sequence{Sequence{1.2,2.7},Sequence{1.4,3.1}} ;
     var x : double ; x := 2.1 ;
     OclFile["System.out"].println("Value of y at x=2.1 : " + extrapolate(d, x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class GFG {
  static int countPairsWithDiffK(int arr[],int n,int k){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++)if(arr[i]-arr[j]==k || arr[j]-arr[i]==k)count++;
    }
    return count ;
  }
  public static void main(String args[]){
    int arr[]={
      1,5,3,4,2 };
      int n=arr.length ;
      int k=3 ;
      System.out.println("Count of pairs with given diff is "+countPairsWithDiffK(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPairsWithDiffK( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do (     if (arr[i+1] - arr[j+1] = k or arr[j+1] - arr[i+1] = k) then     count := count + 1 ; else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,3,4,2} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println("Count of pairs with given diff is " + countPairsWithDiffK(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findNumbers(int n){
    int odd=(int)Math.pow(10,n)-1 ;
    int even=odd-1 ;
    System.out.println("Even="+even);
    System.out.print("Odd="+odd);
  }
  public static void main(String args[]){
    int n=4 ;
    findNumbers(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNumbers( n : int) : void
  pre: true
  post: true
  activity: (     var odd : int ; odd := 10->pow(n)->oclAsType(int) - 1 ;
     var even : int ; even := odd - 1 ;
     OclFile["System.out"].println("Even=" + even) ; 
     OclFile["System.out"].print("Odd=" + odd) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     execute findNumbers(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Berland_National_Library {
  static Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    int n=in.nextInt();
    boolean[] tab=new boolean[1000001];
    int min=0 ;
    int c=0 ;
    for(int i=0 ; i<n ; i++){
      String s=in.next();
      int k=in.nextInt();
      if(s.charAt(0)=='-'){
        if(! tab[k])min++;
        else c--;
      }
      else c++;
      tab[k]=true ;
      if(c>min)min=c ;
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Berland_National_Library {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var tab : Sequence(boolean) ; tab := Integer.subrange(1,1000001)->collect(false) ;
    var min : int ; min := 0 ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := in.getCurrent() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    if (s->at(0+1) = '-') then (     if (not(tab[k+1])) then     min := min + 1 ; else     c := c - 1 ; ) else     c := c + 1 ; ;  
    tab[k+1] := true ; 
    if (c > min) then     min := c ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ArrayList {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int min=0,c=0 ;
    boolean f[]=new boolean[10000001];
    for(int i=0 ; i<n ; i++){
      String s=sc.next();
      int r=sc.nextInt();
      if(s.charAt(0)=='-'){
        if(! f[r])min++;
        else c--;
      }
      else c++;
      f[r]=true ;
      if(c>min)min=c ;
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ArrayList {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var min : int ; min := 0 ;
    var c : int ; c := 0 ;
    var f : Sequence(boolean) ; f := Integer.subrange(1,10000001)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    if (s->at(0+1) = '-') then (     if (not(f[r+1])) then     min := min + 1 ; else     c := c - 1 ; ) else     c := c + 1 ; ;  
    f[r+1] := true ; 
    if (c > min) then     min := c ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.*;
public class WA {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String c ;
    int r ;
    boolean a[]=new boolean[1000001];
    int maxx=0 ;
    int k=0 ;
    for(int i=0 ; i<n ; i++){
      c=in.next();
      r=in.nextInt();
      if(c.equals("+")){
        k++;
        maxx=Math.max(maxx,k);
        a[r]=true ;
      }
      else {
        if(! a[r]){
          maxx++;
        }
        else {
          a[r]=false ;
          k--;
        }
      }
    }
    System.out.print(maxx);
  }
}
------------------------------------------------------------
OCL File:
---------
 class WA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var c : String ;
    var r : int ;
    var a : Sequence(boolean) ; a := Integer.subrange(1,1000001)->collect(false) ;
    var maxx : int ; maxx := 0 ;
    var k : int ; k := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     c := in.getCurrent() ; 
     r := in.getCurrent()->toInteger() ; 
     if (c = "+") then (     k := k + 1 ; 
     maxx := Set{maxx, k}->max() ; 
     a[r+1] := true ) else (     if (not(a[r+1])) then (     maxx := maxx + 1 ) else (     a[r+1] := false ; 
     k := k - 1 ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(maxx) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main implements Runnable {
  public Scanner in ;
  public PrintWriter out ;
  Main()throws IOException {
    in=new Scanner(new File("in"));
    out=new PrintWriter(new File("out"));
  }
  void close()throws IOException {
    out.close();
  }
  public void run(){
    int tn=in.nextInt();
    for(int test=1 ; test<=tn ; test++){
      int n=in.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        String s=in.next();
        a[i]=s.lastIndexOf("1");
      }
      int r=0 ;
      for(int i=0 ; i<n-1 ; i++){
        int j=i ;
        while(a[j]>i){
          j++;
        }
        r+=j-i ;
        int t=a[j];
        while(j>i){
          a[j]=a[j-1];
          j--;
        }
        a[i]=t ;
      }
      out.println("Case #"+test+": "+r);
    }
    try {
      close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  public static void main(String[] args)throws IOException {
    new Thread(new Main()).start();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
   attribute in : OclFile;
   attribute out : OclFile;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile("in")) ; 
     out := OclFile.newOclFile_Write(OclFile("out")) );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
   operation run() : void
  pre: true
  post: true
  activity: (     var tn : int ; tn := in.getCurrent()->toInteger() ;
         var test : int ; test := 1 ; while test <= tn do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := in.getCurrent() ;
     a[i+1] := s->lastIndexOf("1")-1 )  ;     i := i + 1 ) ; 
    var r : int ; r := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var j : int ; j := i ;
     while (a[j+1] > i) do (     j := j + 1 ) ; 
    r := r+(j - i) ; 
    var t : int ; t := a[j+1] ;
    while (j > i) do (     a[j+1] := a[j - 1+1] ; 
     j := j - 1 ) ; 
    a[i+1] := t ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     test := test + 1 ) ; 
     try (     execute close() )   catch (e : IOException) do (     e.printStackTrace() )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(Main.newMain()).start() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.PrintWriter ;
public class A implements Runnable {
  public static void main(String[] args){
    new Thread(new A()).start();
  }
  public void run(){
    try {
      solve();
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  private void solve()throws Exception {
    BufferedReader br=new BufferedReader(new FileReader("a.in"));
    PrintWriter pw=new PrintWriter("a.out");
    int tests=Integer.parseInt(br.readLine().trim());
    for(int test=1 ; test<=tests ; test++){
      int n=Integer.parseInt(br.readLine().trim());
      String[] s=new String[n];
      for(int i=0 ; i<n ; i++){
        s[i]=br.readLine().trim();
      }
      int result=0 ;
      for(int row=0 ; row<n ; row++){
        for(int i=row ; i<n ; i++){
          boolean can=true ;
          for(int k=row+1 ; k<n ; k++){
            if(s[i] .charAt(k)=='1'){
              can=false ;
              break ;
            }
          }
          if(can){
            for(int k=i-1 ; k>=row ; k--){
              String str=s[k+1];
              s[k+1]=s[k];
              s[k]=str ;
              result++;
            }
            break ;
          }
        }
      }
      pw.println("Case #"+test+": "+result);
    }
    br.close();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A implements Runnable {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(A.newA()).start() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     execute solve() )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("a.in"))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile("a.out")) ;
    var tests : int ; tests := (br.readLine()->trim())->toInteger() ;
        var test : int ; test := 1 ; while test <= tests do ( (     var n : int ; n := (br.readLine()->trim())->toInteger() ;
     var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := br.readLine()->trim() )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
        var row : int ; row := 0 ; while row < n do ( (         var i : int ; i := row ; while i < n do ( (     var can : boolean ; can := true ;
         var k : int ; k := row + 1 ; while k < n do ( (     if (s[i+1]->at(k+1) = '1') then (     can := false ; 
     break ) else skip )  ;     k := k + 1 ) ; 
     if (can) then (         var k : int ; k := i - 1 ; while k >= row do ( (     var str : String ; str := s[k + 1+1] ;
     s[k + 1+1] := s[k+1] ; 
     s[k+1] := str ; 
     result := result + 1 )  ;     k := k - 1 ) ; 
     break ) else skip )  ;     i := i + 1 ) )  ;     row := row + 1 ) ; 
    skip ; 
 )  ;     test := test + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    OutputStreamWriter osr=new OutputStreamWriter(System.out);
    PrintWriter out=new PrintWriter(osr);
    FastReader fr=new FastReader();
    int t=fr.nextInt();
    while(t--!=0){
      int n=fr.nextInt(),m=n ;
      int[] arr=fr.intArray(n);
      ;
      Arrays.sort(arr);
      for(int i=0 ; i<n-1 ; i++){
        if(abs(arr[i]-arr[i+1])<=1)m--;
      }
      out.println(m==1 ? "YES" : "NO");
    }
    out.close();
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    InputStreamReader isr=new InputStreamReader(System.in);
    br=new BufferedReader(isr);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String nextLine()throws IOException {
    return br.readLine();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public int[] intArray(int size)throws IOException {
    int[] arr=new int[size];
    for(int i=0 ; i<size ; i++)arr[i]=nextInt();
    return arr ;
  }
  public char[] charArray()throws IOException {
    return nextLine().toCharArray();
  }
}
class Pair {
  int d ;
  int k ;
  public Pair(int d,int k){
    this.d=d ;
    this.k=k ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var osr : OclFile ; osr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(osr) ;
    var fr : FastReader ; fr := FastReader.newFastReader() ;
    var t : int ; t := fr.nextInt() ;
        while (t /= 0) do (    skip ; (     var n : int ; n := fr.nextInt() ;
    var m : int ; m := n ;
     var arr : Sequence(int) ; arr := fr.intArray(n) ;
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (abs(arr[i+1] - arr[i + 1+1]) <= 1) then     m := m - 1 ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     br := OclFile.newOclFile_Read(isr) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation intArray( size : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < size do (     arr[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return arr );
   operation charArray() : Sequence(String)
  pre: true
  post: true
  activity: (     return nextLine()->characters() );
}
class Pair {
   attribute d : int;
   attribute k : int;
   static operation newPair( d : int, k : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(d, k);
    return self );
  operation initialise( d : int, k : int) : void
  pre: true  post: true
  activity: (     self.d := d ; 
     self.k := k );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileOutputStream ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.PrintStream ;
public class A {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new FileReader("A-large.in"));
    PrintStream ps=new PrintStream(new FileOutputStream("A-large.out"));
    int cases=Integer.parseInt(br.readLine());
    for(int itr=1 ; itr<=cases ; itr++){
      int size=Integer.parseInt(br.readLine());
      int[] board=new int[size];
      for(int i=0 ; i<size ; i++){
        String s=br.readLine();
        for(int j=0 ; j<size ; j++)if(s.charAt(j)=='1')board[i]=j ;
      }
      int out=0 ;
      boolean done=false ;
      while(! done){
        done=true ;
        for(int i=0 ; i<size ; i++){
          if(board[i]>i){
            done=false ;
            int s=0 ;
            for(int j=i+1 ; j<size ; j++)if(board[j]<=i){
              s=j ;
              break ;
            }
            for(int j=s ; j>i ; j--){
              int t=board[j];
              board[j]=board[j-1];
              board[j-1]=t ;
              out++;
            }
          }
        }
      }
      ps.println("Case #"+itr+": "+out);
    }
    br.close();
    ps.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("A-large.in"))) ;
     var ps : OclFile ; ps := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("A-large.out"))) ;
    var cases : int ; cases := (br.readLine())->toInteger() ;
        var itr : int ; itr := 1 ; while itr <= cases do ( (     var size : int ; size := (br.readLine())->toInteger() ;
     var board : Sequence(int) ; board := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < size do ( (     var s : String ; s := br.readLine() ;
         var j : int ; j := 0 ; while j < size do (     if (s->at(j+1) = '1') then     board[i+1] := j ; else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var out : int ; out := 0 ;
    var done : boolean ; done := false ;
    while (not(done)) do (     done := true ; 
         var i : int ; i := 0 ; while i < size do ( (     if (board[i+1] > i) then (     done := false ; 
     var s : int ; s := 0 ;
         var j : int ; j := i + 1 ; while j < size do (     if (board[j+1] <= i) then (     s := j ; 
     break ) else skip ;  ;     j := j + 1 ) ; 
         var j : int ; j := s ; while j > i do ( (     var t : int ; t := board[j+1] ;
     board[j+1] := board[(j)->char2byte() - 1+1] ; 
     board[(j)->char2byte() - 1+1] := t ; 
     out := out + 1 )  ;     j := j - 1 ) ) else skip )  ;     i := i + 1 ) ) ; 
    skip ; 
 )  ;     itr := itr + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A implements Runnable {
  private static String fileName=A.class.getSimpleName().replaceFirst("_.*","");
  private static String inputFileName=fileName+".in" ;
  private static String outputFileName=fileName+".out" ;
  private static Scanner in ;
  private static PrintWriter out ;
  private void solve(){
    int n=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      String s=in.next();
      for(int j=0 ; j<n ; j++){
        if(s.charAt(j)=='1'){
          a[i]=j ;
        }
      }
    }
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      int j ;
      for(j=i ; ; j++){
        if(a[j]<=i)break ;
      }
      for(int k=j ; k>i ; k--){
        ans++;
        int t=a[k];
        a[k]=a[k-1];
        a[k-1]=t ;
      }
    }
    out.println(ans);
  }
  public void run(){
    int tests=in.nextInt();
    in.nextLine();
    for(int t=1 ; t<=tests ; t++){
      out.print("Case #"+t+": ");
      solve();
    }
  }
  public static void main(String[] args)throws IOException,InterruptedException {
    Locale.setDefault(Locale.US);
    if(args.length>=2){
      inputFileName=args[0];
      outputFileName=args[1];
    }
    in=new Scanner(new FileReader(inputFileName));
    out=new PrintWriter(outputFileName);
    Thread thread=new Thread(new A());
    thread.start();
    thread.join();
    in.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A implements Runnable {
  static   attribute fileName : String := OclType["A"].getSimpleName().replaceFirstMatch("_.*", "");
  static   attribute inputFileName : String := fileName + ".in";
  static   attribute outputFileName : String := fileName + ".out";
  static   attribute in : OclFile;
  static   attribute out : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := in.getCurrent() ;
         var j : int ; j := 0 ; while j < n do ( (     if (s->at(j+1) = '1') then (     a[i+1] := j ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var j : int ;
         j := i ; while true do ( (     if (a[j+1] <= i) then     break else skip )  ;     j := j + 1 ) ; 
         var k : int ; k := j ; while k > i do ( (     ans := ans + 1 ; 
     var t : int ; t := a[k+1] ;
     a[k+1] := a[k - 1+1] ; 
     a[k - 1+1] := t )  ;     k := k - 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     var tests : int ; tests := in.getCurrent()->toInteger() ;
     skip ; 
         var t : int ; t := 1 ; while t <= tests do ( (     skip ; 
     execute solve() )  ;     t := t + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.US) ; 
     if (args->size() >= 2) then (     inputFileName := args[0+1] ; 
     outputFileName := args[1+1] ) else skip ; 
    in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(inputFileName))) ; 
    out := OclFile.newOclFile_Write(OclFile.newOclFile(outputFileName)) ; 
    var thread : OclProcess ; thread := OclProcess.newOclProcess(A.newA()) ;
    thread.start() ; 
    thread.join() ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.File ;
import java.io.PrintWriter ;
import java.io.FileNotFoundException ;
public class A {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner in=new Scanner(new File("A.in"));
    PrintWriter out=new PrintWriter("A.out");
    int t=in.nextInt();
    in.nextLine();
    for(int tn=0 ; tn<t ; tn++){
      out.println("Case #"+(tn+1)+": "+solve(in));
    }
    out.close();
  }
  private static String solve(Scanner in){
    int n=in.nextInt();
    in.nextLine();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      String s=in.nextLine();
      int j=n-1 ;
      while(s.charAt(j)=='0' && j>0)j--;
      a[i]=j ;
    }
    int res=0 ;
    for(int i=0 ; i<n ; i++){
      int j=i ;
      while(a[j]>i)j++;
      int t=a[j];
      for(int k=j ; k>i ; k--)a[k]=a[k-1];
      a[i]=t ;
      res+=(j-i);
    }
    return ""+res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("A.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("A.out")) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
    skip ; 
        var tn : int ; tn := 0 ; while tn < t do ( (     skip )  ;     tn := tn + 1 ) ; 
    skip ; 
 );
  static   operation solve( in : OclFile) : String
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := in.nextLine() ;
     var j : int ; j := n - 1 ;
     while (s->at(j+1) = '0' & j > 0) do     j := j - 1 ; ; 
     a[i+1] := j )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var j : int ; j := i ;
     while (a[j+1] > i) do     j := j + 1 ; ; 
    var t : int ; t := a[j+1] ;
        var k : int ; k := j ; while k > i do (     a[k+1] := a[k - 1+1] ;  ;     k := k - 1 ) ; 
    a[i+1] := t ; 
    res := res+(((j)->char2byte() - i)) ; 
 )  ;     i := i + 1 ) ; 
    return "" + res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
import java.awt.geom.*;
import java.io.*;
public class Main {
  static int INF=2<<27 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      Data[] data=new Data[n];
      int[] time=new int[31];
      for(int i=0 ; i<n ; i++){
        Data tmp=new Data();
        tmp.name=sc.next();
        tmp.m=sc.nextInt();
        tmp.d=new int[tmp.m];
        for(int j=0 ; j<tmp.m ; j++){
          tmp.d[j]=sc.nextInt();
          time[tmp.d[j] ]++;
        }
        data[i]=tmp ;
      }
      for(int i=0 ; i<n ; i++){
        Data tmp=data[i];
        for(int j=0 ; j<tmp.m ; j++){
          tmp.point+=Math.max(1,n-time[tmp.d[j] ]+1);
        }
      }
      Arrays.sort(data);
      System.out.println(data[data.length-1] .point+" "+data[data.length-1] .name);
    }
  }
  static class Data implements Comparable<Data>{
    String name ;
    int m ;
    int[] d=new int[m];
    int point ;
    @ Override public int compareTo(Data o){
      if(this.point==o.point)return o.name.compareTo(this.name);
      return o.point-this.point ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute INF : int := (2*(2->pow(27)))->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var data : Sequence(Data) ; data := Integer.subrange(1,n)->collect(null) ;
    var time : Sequence(int) ; time := Integer.subrange(1,31)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var tmp : Data ; tmp := Data.newData() ;
     tmp.name := sc.getCurrent() ; 
    tmp.m := sc.getCurrent()->toInteger() ; 
    tmp.d := Integer.subrange(1,tmp.m)->collect(0) ; 
        var j : int ; j := 0 ; while j < tmp.m do ( (     tmp.d[j+1] := sc.getCurrent()->toInteger() ; 
     time[tmp.d[j+1]+1] := time[tmp.d[j+1]+1] + 1 )  ;     j := j + 1 ) ; 
    data[i+1] := tmp ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var tmp : Data ; tmp := data[i+1] ;
         var j : int ; j := 0 ; while j < tmp.m do ( (     tmp.point := tmp.point+(Set{1, n - time[tmp.d[j+1]+1] + 1}->max()) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    data := data->sort() ; 
    OclFile["System.out"].println(data[data->size() - 1+1].point + " " + data[data->size() - 1+1].name) ; 
 ) );
  static class Data implements Comparable<Data> {
   attribute name : String;
   attribute m : int;
   attribute d : Sequence(int) := Integer.subrange(1,m)->collect(0);
   attribute point : int;
      operation compareTo( o : Data) : int
  pre: true
  post: true
  activity: (     if (self.point = o.point) then     return o.name->compareTo(self.name) else skip ; 
     return o.point - self.point );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  private static void solve(){
    final Scanner scanner=new Scanner(System.in);
    while(true){
      final int n=scanner.nextInt();
      if(n==0){
        break ;
      }
      final String[] names=new String[n];
      final boolean[][] table=new boolean[n][30];
      final int[] sum=new int[30];
      for(int i=0 ; i<n ; i++){
        names[i]=scanner.next();
        final int m=scanner.nextInt();
        for(int j=0 ; j<m ; j++){
          final int d=scanner.nextInt();
          table[i][d]=true ;
          sum[d]++;
        }
      }
      int minimum=Integer.MAX_VALUE ;
      int minIndex=-1 ;
      for(int i=0 ; i<n ; i++){
        int score=0 ;
        for(int j=0 ; j<table[i] .length ; j++){
          if(table[i][j]){
            score+=n-sum[j]+1 ;
          }
        }
        if(score<minimum){
          minimum=score ;
          minIndex=i ;
        }
        else if(score==minimum && names[i] .compareTo(names[minIndex])<0){
          minimum=score ;
          minIndex=i ;
        }
      }
      System.out.println(String.format("%d %s",minimum,names[minIndex]));
    }
  }
  public static void main(String...args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var names : Sequence(String) ; names := Integer.subrange(1,n)->collect(null) ;
    var table : Sequence(Sequence(boolean)) ; table := Integer.subrange(1,n)->collect(Integer.subrange(1,30)->collect(false)) ;
    var sum : Sequence(int) ; sum := Integer.subrange(1,30)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     names[i+1] := scanner.getCurrent() ; 
     var m : int ; m := scanner.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < m do ( (     var d : int ; d := scanner.getCurrent()->toInteger() ;
     table[i+1][d+1] := true ; 
     sum[d+1] := sum[d+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var minimum : int ; minimum := 2147483647 ;
    var minIndex : int ; minIndex := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var score : int ; score := 0 ;
         var j : int ; j := 0 ; while j < table[i+1]->size() do ( (     if (table[i+1][j+1]) then (     score := score+(n - sum[j+1] + 1) ) else skip )  ;     j := j + 1 ) ; 
     if (score < minimum) then (     minimum := score ; 
     minIndex := i ) else     if (score = minimum & names[i+1]->compareTo(names[minIndex+1]) < 0) then (     minimum := score ; 
     minIndex := i ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(StringLib.format("%d %s",Sequence{minimum,names[minIndex+1]})) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  @ SuppressWarnings("resource")public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    List<Integer>times=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      times.add(scanner.nextInt());
    }
    int m=scanner.nextInt();
    List<Integer>pList=new ArrayList<>();
    List<Integer>xList=new ArrayList<>();
    for(int i=0 ; i<m ; i++){
      pList.add(scanner.nextInt());
      xList.add(scanner.nextInt());
    }
    int index=0 ;
    for(int p : pList){
      List<Integer>t=new ArrayList<>(times);
      t.set(p-1,xList.get(index));
      int ans=0 ;
      for(int time : t){
        ans+=time ;
      }
      System.out.println(ans);
      index++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var times : Sequence(int) ; times := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     times := times->including(scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var pList : Sequence(int) ; pList := Sequence{} ;
    var xList : Sequence(int) ; xList := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     pList := pList->including(scanner.getCurrent()->toInteger()) ; 
     xList := xList->including(scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var index : int ; index := 0 ;
    for (p : pList) do ( (     var t : Sequence(int) ; t := Sequence{}->union(times) ;
     t := t.setAt(p - 1+1,xList->at(index+1)) ; 
    var ans : int ; ans := 0 ;
    for (time : t) do ( (     ans := ans+(time) )  ) ; 
    OclFile["System.out"].println(ans) ; 
    index := index + 1 ; 
 )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Chara {
  String name ;
  ArrayList<Integer>appear ;
  private int point ;
  Chara(String name,ArrayList<Integer>appear){
    this.name=name ;
    this.appear=appear ;
    this.point=0 ;
  }
  void addPoint(int pt){
    this.point+=pt ;
  }
  int getPoint(){
    return this.point ;
  }
}
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=Integer.parseInt(sc.nextLine());
      if(n==0)break ;
      Chara[] charas=new Chara[n];
      for(int i=0 ; i<n ; i++){
        String[] line=sc.nextLine().split(" ");
        ArrayList<Integer>appear=new ArrayList<Integer>();
        for(int j=2 ; j<line.length ; j++){
          appear.add(Integer.parseInt(line[j]));
        }
        charas[i]=new Chara(line[0],appear);
      }
      for(int t=0 ; t<30 ; t++){
        int point=n+1 ;
        for(Chara c : charas){
          if(c.appear.indexOf(t)!=-1){
            point-=1 ;
          }
        }
        for(Chara c : charas){
          if(c.appear.indexOf(t)!=-1){
            c.addPoint(point);
          }
        }
      }
      ArrayList<Integer>points=new ArrayList<Integer>();
      for(Chara c : charas){
        points.add(c.getPoint());
      }
      int min=Collections.min(points);
      ArrayList<String>minNames=new ArrayList<String>();
      for(Chara c : charas){
        if(c.getPoint()==min){
          minNames.add(c.name);
        }
      }
      Collections.sort(minNames);
      System.out.printf("%d %s\n",min,minNames.get(0));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Chara {
   attribute name : String;
   attribute appear : Sequence(int);
   attribute point : int;
   static operation newChara( name : String, appear : Sequence(int)) : Chara
  pre: true
  post: true
  activity:
  ( var self : Chara ;
    self := createChara();
    self.initialise(name, appear);
    return self );
  operation initialise( name : String, appear : Sequence(int)) : void
  pre: true  post: true
  activity: (     self.name := name ; 
     self.appear := appear ; 
     self.point := 0 );
   operation addPoint( pt : int) : void
  pre: true
  post: true
  activity: (     self.point := self.point+(pt) );
   operation getPoint() : int
  pre: true
  post: true
  activity: (     return self.point );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := (sc.nextLine())->toInteger() ;
     if (n = 0) then     break else skip ; 
    var charas : Sequence(Chara) ; charas := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var line : Sequence(String) ; line := sc.nextLine()->split(" ") ;
     var appear : Sequence(int) ; appear := Sequence{} ;
         var j : int ; j := 2 ; while j < line->size() do ( (     appear := appear->including((line[j+1])->toInteger()) )  ;     j := j + 1 ) ; 
     charas[i+1] := Chara.newChara(line[0+1], appear) )  ;     i := i + 1 ) ; 
        var t : int ; t := 0 ; while t < 30 do ( (     var point : int ; point := n + 1 ;
     for (c : charas) do ( (     if (c.appear->indexOf(t)-1 /= -1) then (     point := point-(1) ) else skip )  ) ; 
     for (c : charas) do ( (     if (c.appear->indexOf(t)-1 /= -1) then (     c.addPoint(point) ) else skip )  ) )  ;     t := t + 1 ) ; 
    var points : Sequence(int) ; points := Sequence{} ;
    for (c : charas) do ( (     points := points->including(c.getPoint()) )  ) ; 
    var min : int ; min := .min(points) ;
    var minNames : Sequence(String) ; minNames := Sequence{} ;
    for (c : charas) do ( (     if (c.getPoint() = min) then (     minNames := minNames->including(c.name) ) else skip )  ) ; 
    minNames := minNames->sort() ; 
    OclFile["System.out"].printf("%d %s\n", min, minNames->at(0+1)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      String[] names=new String[n];
      int[][] g=new int[30][n];
      for(int j=0 ; j<n ; j++){
        names[j]=sc.next();
        int m=sc.nextInt();
        for(int i=0 ; i<m ; i++){
          int d=sc.nextInt();
          g[d][j]=1 ;
        }
      }
      int[] ps=new int[n];
      for(int j=0 ; j<30 ; j++){
        int k=0 ;
        for(int i=0 ; i<n ; i++){
          k+=g[j][i];
        }
        for(int i=0 ; i<n ; i++){
          ps[i]+=g[j][i]*(n+1-k);
        }
      }
      String name="" ;
      int min=INF ;
      for(int i=0 ; i<n ; i++){
        if(ps[i]<min){
          name=names[i];
          min=ps[i];
        }
        else if(ps[i]==min){
          if(names[i] .compareTo(name)<0){
            name=names[i];
          }
        }
      }
      println(min+" "+name);
    }
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var names : Sequence(String) ; names := Integer.subrange(1,n)->collect(null) ;
    var g : Sequence(Sequence(int)) ; g := Integer.subrange(1,30)->collect(Integer.subrange(1,n)->collect(0)) ;
        var j : int ; j := 0 ; while j < n do ( (     names[j+1] := sc.getCurrent() ; 
     var m : int ; m := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < m do ( (     var d : int ; d := sc.getCurrent()->toInteger() ;
     g[d+1][j+1] := 1 )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    var ps : Sequence(int) ; ps := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < 30 do ( (     var k : int ; k := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     k := k+(g[j+1][i+1]) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     ps[i+1] := ps[i+1]+(g[j+1][i+1] * (n + 1 - k)) )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    var name : String ; name := "" ;
    var min : int ; min := INF ;
        var i : int ; i := 0 ; while i < n do ( (     if (ps[i+1] < min) then (     name := names[i+1] ; 
     min := ps[i+1] ) else     if (ps[i+1] = min) then (     if (names[i+1]->compareTo(name) < 0) then (     name := names[i+1] ) else skip ) else skip ; )  ;     i := i + 1 ) ; 
    execute println(min + " " + name) ; 
 )  ) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class P {
  String name ;
  int point ;
  P(String name,int point){
    this.name=name ;
    this.point=point ;
  }
}
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(stdIn.hasNext()){
      int n=stdIn.nextInt();
      if(n==0){
        break ;
      }
      List<P>data=new ArrayList<P>();
      boolean[][] point=new boolean[21][31];
      for(int i=0 ; i<n ; ++i){
        String name=stdIn.next();
        data.add(new P(name,0));
        int m=stdIn.nextInt();
        while(m--!=0){
          int d=stdIn.nextInt();
          point[i][d]=true ;
        }
      }
      for(int i=0 ; i<31 ; ++i){
        int count=0 ;
        for(int j=0 ; j<n ; ++j){
          if(point[j][i]){
++count ;
          }
        }
        for(int j=0 ; j<n ; ++j){
          if(point[j][i]){
            data.get(j).point+=n-count+1 ;
          }
        }
      }
      Collections.sort(data,new Comparator<P>(){
        public int compare(P obj0,P obj1){
          return obj0.name.compareTo(obj1.name);
        }
      }
);
      int minIndex=0 ;
      int min=999999999 ;
      for(int i=0 ; i<n ; ++i){
        if(min>data.get(i).point){
          min=data.get(i).point ;
          minIndex=i ;
        }
      }
      System.out.println(data.get(minIndex).point+" "+data.get(minIndex).name);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P {
   attribute name : String;
   attribute point : int;
   static operation newP( name : String, point : int) : P
  pre: true
  post: true
  activity:
  ( var self : P ;
    self := createP();
    self.initialise(name, point);
    return self );
  operation initialise( name : String, point : int) : void
  pre: true  post: true
  activity: (     self.name := name ; 
     self.point := point );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (stdIn.hasNext()) do (     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var data : Sequence(P) ; data := Sequence{} ;
    var point : Sequence(Sequence(boolean)) ; point := Integer.subrange(1,21)->collect(Integer.subrange(1,31)->collect(false)) ;
        var i : int ; i := 0 ; while i < n do ( (     var name : String ; name := stdIn.getCurrent() ;
     data := data->including(P.newP(name, 0)) ; 
     var m : int ; m := stdIn.getCurrent()->toInteger() ;
         while (m /= 0) do (    skip ; (     var d : int ; d := stdIn.getCurrent()->toInteger() ;
     point[i+1][d+1] := true ) ;  ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 31 do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (point[j+1][i+1]) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < n do ( (     if (point[j+1][i+1]) then (     data->at(j+1).point := data->at(j+1).point+(n - count + 1) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    data, OclComparator<P>.newOclComparator() := data, OclComparator<P>.newOclComparator()->sort() ; 
    var minIndex : int ; minIndex := 0 ;
    var min : int ; min := 999999999 ;
        var i : int ; i := 0 ; while i < n do ( (     if (min > data->at(i+1).point) then (     min := data->at(i+1).point ; 
     minIndex := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(data->at(minIndex+1).point + " " + data->at(minIndex+1).name) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAXN=256 ;
  static boolean checkHalfFrequency(String str){
    int L=str.length();
    int fre[]=new int[MAXN];
    for(int i=0 ; i<L ; i++){
      fre[str.charAt(i)]++;
    }
    for(int i=0 ; i<MAXN ; i++){
      if(fre[i]>L/2){
        return true ;
      }
    }
    return false ;
  }
  public static void main(String[] args){
    String str="GeeksforGeeks" ;
    if(checkHalfFrequency(str)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAXN : int := 256;
  static   operation checkHalfFrequency( str : String) : boolean
  pre: true
  post: true
  activity: (     var L : int ; L := str->size() ;
     var fre : Sequence(int) ; fre := Integer.subrange(1,MAXN)->collect(0) ;
        var i : int ; i := 0 ; while i < L do ( (     fre[str->at(i+1)+1] := fre[str->at(i+1)+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < MAXN do ( (     if (fre[i+1] > L / 2) then (     return true ) else skip )  ;     i := i + 1 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GeeksforGeeks" ;
     if (checkHalfFrequency(str)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=100 ;
  public static void main(String[] args){
    long[] arr=new long[MAX];
    arr[0]=0 ;
    arr[1]=1 ;
    for(int i=2 ; i<MAX ; i++)arr[i]=arr[i-1]+arr[i-2];
    System.out.print("Fibonacci numbers divisible by "+"their indexes are :\n");
    for(int i=1 ; i<MAX ; i++)if(arr[i] % i==0)System.out.print(i+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(long) ; arr := Integer.subrange(1,MAX)->collect(0) ;
     arr[0+1] := 0 ; 
    arr[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < MAX do (     arr[i+1] := arr[i - 1+1] + arr[i - 2+1] ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("Fibonacci numbers divisible by " + "their indexes are :\n") ; 
        var i : int ; i := 1 ; while i < MAX do (     if (arr[i+1] mod i = 0) then     OclFile["System.out"].print(i + " ") ; else skip ;  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class solution {
  static int countWords(String str){
    int count=1 ;
    for(int i=1 ; i<str.length()-1 ; i++){
      if(str.charAt(i)>=65 && str.charAt(i)<=90)count++;
    }
    return count ;
  }
  public static void main(String args[]){
    String str="geeksForGeeks" ;
    System.out.print(countWords(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class solution {
  static   operation countWords( str : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 1 ;
         var i : int ; i := 1 ; while i < str->size() - 1 do ( (     if (str->at(i+1) >= 65 & str->at(i+1) <= 90) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksForGeeks" ;
     OclFile["System.out"].print(countWords(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  static double Nth_Term(int n){
    return(2*Math.pow(n,3)-3*Math.pow(n,2)+n+6)/6 ;
  }
  static public void main(String args[]){
    int N=8 ;
    System.out.println(Nth_Term(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Nth_Term( n : int) : double
  pre: true
  post: true
  activity: (     return (2 * n->pow(3) - 3 * n->pow(2) + n + 6) / 6 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 8 ;
     OclFile["System.out"].println(Nth_Term(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int nthTerm(int n){
    return 2*(int)Math.pow(n,2)+3*n-5 ;
  }
  public static void main(String args[]){
    int N=4 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nthTerm( n : int) : int
  pre: true
  post: true
  activity: (     return 2 * n->pow(2)->oclAsType(int) + 3 * n - 5 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(nthTerm(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int nthTerm(int n){
    return 3*(int)Math.pow(n,2)+2*n-5 ;
  }
  public static void main(String[] args){
    int N=4 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nthTerm( n : int) : int
  pre: true
  post: true
  activity: (     return 3 * n->pow(2)->oclAsType(int) + 2 * n - 5 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int nthTerm(int n){
    return 3*(int)Math.pow(n,2)-4*n+2 ;
  }
  public static void main(String args[]){
    int N=4 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nthTerm( n : int) : int
  pre: true
  post: true
  activity: (     return 3 * n->pow(2)->oclAsType(int) - 4 * n + 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(nthTerm(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    b solver=new b();
    solver.solve(1,in,out);
    out.close();
  }
  static class b {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int N=in.nextInt();
      int[] T=new int[N];
      for(int i=0 ; i<N ; i++){
        T[i]=in.nextInt();
      }
      int M=in.nextInt();
      int[] P=new int[M];
      int[] X=new int[M];
      for(int i=0 ; i<M ; i++){
        P[i]=in.nextInt();
        X[i]=in.nextInt();
      }
      for(int i=0 ; i<M ; i++){
        int sum=0 ;
        for(int j=0 ; j<N ; j++){
          if(j+1==P[i]){
            sum+=X[i];
          }
          else {
            sum+=T[j];
          }
        }
        out.println(sum);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : b ; solver := b.newb() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class b {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
     var T : Sequence(int) ; T := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     T[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var M : int ; M := in.getCurrent()->toInteger() ;
    var P : Sequence(int) ; P := Integer.subrange(1,M)->collect(0) ;
    var X : Sequence(int) ; X := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     P[i+1] := in.getCurrent()->toInteger() ; 
     X[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < N do ( (     if (j + 1 = P[i+1]) then (     sum := sum+(X[i+1]) ) else (     sum := sum+(T[j+1]) ) )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int nthTerm(int n){
    return(int)Math.pow(n,2)+4*n ;
  }
  public static void main(String[] args){
    int N=4 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nthTerm( n : int) : int
  pre: true
  post: true
  activity: (     return n->pow(2)->oclAsType(int) + 4 * n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int nthTerm(int n){
    return 4*(int)Math.pow(n,2)-3*n+2 ;
  }
  public static void main(String args[]){
    int N=4 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nthTerm( n : int) : int
  pre: true
  post: true
  activity: (     return 4 * n->pow(2)->oclAsType(int) - 3 * n + 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(nthTerm(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int nthTerm(int n){
    return 2*(int)Math.pow(n,2)+n-3 ;
  }
  public static void main(String[] args){
    int N=4 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nthTerm( n : int) : int
  pre: true
  post: true
  activity: (     return 2 * n->pow(2)->oclAsType(int) + n - 3 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.sin ;
class GFG {
  static void cal_sin(float n){
    float accuracy=(float)0.0001,denominator,sinx,sinval ;
    n=n*(float)(3.142/180.0);
    float x1=n ;
    sinx=n ;
    sinval=(float)sin(n);
    int i=1 ;
    do {
      denominator=2*i*(2*i+1);
      x1=-x1*n*n/denominator ;
      sinx=sinx+x1 ;
      i=i+1 ;
    }
    while(accuracy<=sinval-sinx);
    System.out.println(sinx);
  }
  public static void main(String[] args){
    float n=90 ;
    cal_sin(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation cal_sin( n : double) : void
  pre: true
  post: true
  activity: (     var accuracy : double ; accuracy := 0.0001->oclAsType(double) ;
    var denominator : double ;
    var sinx : double ;
    var sinval : double ;
     n := n * (3.142 / 180.0)->oclAsType(double) ; 
    var x1 : double ; x1 := n ;
    sinx := n ; 
    sinval := sin(n)->oclAsType(double) ; 
    var i : int ; i := 1 ;
  while true do ((     denominator := 2 * i * (2 * i + 1) ; 
     x1 := -x1 * n * n / denominator ; 
     sinx := sinx + x1 ; 
     i := i + 1 ) ;
    if (accuracy <= sinval - sinx) then skip else break) ; 
    OclFile["System.out"].println(sinx) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 90 ;
     execute cal_sin(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int Nth_Term(int n){
    return(int)(3*Math.pow(n,2)-n+2)/(2);
  }
  public static void main(String[] args){
    int N=5 ;
    System.out.println(Nth_Term(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Nth_Term( n : int) : int
  pre: true
  post: true
  activity: (     return (3 * n->pow(2) - n + 2)->oclAsType(int) / (2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     OclFile["System.out"].println(Nth_Term(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static double[] XandYandZintercept(double A,double B,double C,double D){
    double[] rslt=new double[3];
    double x=-D/A ;
    double y=-D/B ;
    double z=-D/C ;
    rslt[0]=x ;
    rslt[1]=y ;
    rslt[2]=z ;
    return rslt ;
  }
  static void equation_plane(int[] p,int[] q,int[] r){
    int x1=p[0];
    int y1=p[1];
    int z1=p[2];
    int x2=q[0];
    int y2=q[1];
    int z2=q[2];
    int x3=r[0];
    int y3=r[1];
    int z3=r[2];
    int a1=x2-x1 ;
    int b1=y2-y1 ;
    int c1=z2-z1 ;
    int a2=x3-x1 ;
    int b2=y3-y1 ;
    int c2=z3-z1 ;
    int A=b1*c2-b2*c1 ;
    int B=a2*c1-a1*c2 ;
    int C=a1*b2-b1*a2 ;
    int D=(-A*x1-B*y1-C*z1);
    double[] rslt=XandYandZintercept(A,B,C,D);
    for(int i=0 ; i<3 ; i++){
      System.out.printf(rslt[i]+" ");
    }
  }
  public static void main(String args[]){
    int x1=-1 ;
    int y1=2 ;
    int z1=1 ;
    int x2=0 ;
    int y2=-3 ;
    int z2=2 ;
    int x3=1 ;
    int y3=1 ;
    int z3=-4 ;
    int[] p={
      x1,y1,z1 };
      int[] q={
        x2,y2,z2 };
        int[] r={
          x3,y3,z3 };
          equation_plane(p,q,r);
        }
      }

------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation XandYandZintercept( A : double, B : double, C : double, D : double) : Sequence(double)
  pre: true
  post: true
  activity: (     var rslt : Sequence(double) ; rslt := Integer.subrange(1,3)->collect(0.0) ;
     var x : double ; x := -D / A ;
    var y : double ; y := -D / B ;
    var z : double ; z := -D / C ;
    rslt[0+1] := x ; 
    rslt[1+1] := y ; 
    rslt[2+1] := z ; 
    return rslt 
 );
  static   operation equation_plane( p : Sequence(int), q : Sequence(int), r : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var x1 : int ; x1 := p[0+1] ;
     var y1 : int ; y1 := p[1+1] ;
    var z1 : int ; z1 := p[2+1] ;
    var x2 : int ; x2 := q[0+1] ;
    var y2 : int ; y2 := q[1+1] ;
    var z2 : int ; z2 := q[2+1] ;
    var x3 : int ; x3 := r[0+1] ;
    var y3 : int ; y3 := r[1+1] ;
    var z3 : int ; z3 := r[2+1] ;
    var a1 : int ; a1 := x2 - x1 ;
    var b1 : int ; b1 := y2 - y1 ;
    var c1 : int ; c1 := z2 - z1 ;
    var a2 : int ; a2 := x3 - x1 ;
    var b2 : int ; b2 := y3 - y1 ;
    var c2 : int ; c2 := z3 - z1 ;
    var A : int ; A := b1 * c2 - b2 * c1 ;
    var B : int ; B := a2 * c1 - a1 * c2 ;
    var C : int ; C := a1 * b2 - b1 * a2 ;
    var D : int ; D := (-A * x1 - B * y1 - C * z1) ;
    var rslt : Sequence(double) ; rslt := XandYandZintercept(A, B, C, D) ;
        var i : int ; i := 0 ; while i < 3 do ( (     OclFile["System.out"].printf(rslt[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x1 : int ; x1 := -1 ;
     var y1 : int ; y1 := 2 ;
    var z1 : int ; z1 := 1 ;
    var x2 : int ; x2 := 0 ;
    var y2 : int ; y2 := -3 ;
    var z2 : int ; z2 := 2 ;
    var x3 : int ; x3 := 1 ;
    var y3 : int ; y3 := 1 ;
    var z3 : int ; z3 := -4 ;
    var p : Sequence(int) ; p := Sequence{x1,y1,z1} ;
    var q : Sequence(int) ; q := Sequence{x2,y2,z2} ;
    var r : Sequence(int) ; r := Sequence{x3,y3,z3} ;
    execute equation_plane(p, q, r) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int findMinDifference(int arr[],int n){
    Arrays.sort(arr);
    int diff1=arr[n-1]-arr[1];
    int diff2=arr[n-2]-arr[0];
    return Math.min(diff1,diff2);
  }
  public static void main(String args[]){
    int arr[]={
      1,2,4,3,4 };
      int n=arr.length ;
      System.out.print(findMinDifference(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation findMinDifference( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var diff1 : int ; diff1 := arr[n - 1+1] - arr[1+1] ;
     var diff2 : int ; diff2 := arr[n - 2+1] - arr[0+1] ;
     return Set{diff1, diff2}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,4,3,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(findMinDifference(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeforces598B {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s=br.readLine();
    StringBuilder answer=new StringBuilder();
    answer.append(s);
    int numQueries=Integer.parseInt(br.readLine());
    for(int rep=0 ; rep<numQueries ; rep++){
      StringTokenizer st=new StringTokenizer(br.readLine());
      int l=Integer.parseInt(st.nextToken());
      int r=Integer.parseInt(st.nextToken());
      int k=Integer.parseInt(st.nextToken());
      k %=(r-l+1);
      StringBuilder e=new StringBuilder();
      e.append(answer.substring(r-k,r));
      e.append(answer.substring(l-1,r-k));
      answer.replace(l-1,r,e.toString());
    }
    System.out.print(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces598B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := br.readLine() ;
    var answer : String ; answer := StringLib.newString() ;
    answer := answer + StringLib.newString(s) ; 
    var numQueries : int ; numQueries := (br.readLine())->toInteger() ;
        var rep : int ; rep := 0 ; while rep < numQueries do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var l : int ; l := (st.next())->toInteger() ;
    var r : int ; r := (st.next())->toInteger() ;
    var k : int ; k := (st.next())->toInteger() ;
    k := k mod (r - l + 1) ; 
    var e : String ; e := StringLib.newString() ;
    e := e + StringLib.newString(answer.subrange(r - k+1,r)) ; 
    e := e + StringLib.newString(answer.subrange(l - 1+1,r - k)) ; 
    answer.replace(l - 1, r, e+"") ; 
 )  ;     rep := rep + 1 ) ; 
    OclFile["System.out"].print(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=1 ;
    while(t-->0){
      solve(sc);
    }
  }
  public static void solve(Scanner sc){
    String s=sc.nextLine();
    int queries=sc.nextInt();
    while(queries-->0){
      int l=sc.nextInt()-1 ;
      int r=sc.nextInt()-1 ;
      int count=sc.nextInt()%(r-l+1);
      String toShift=s.substring(l,r+1);
      StringBuilder sb=new StringBuilder("");
      for(int i=0 ; i<toShift.length(); i++){
        sb.append(toShift.charAt((toShift.length()-count+i)% toShift.length()));
      }
      String start=l==0 ? "" : s.substring(0,l);
      String end=r==s.length()-1 ? "" : s.substring(r+1,s.length());
      s=start+sb.toString()+end ;
    }
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve(sc) ) ;  ) );
  static   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := sc.nextLine() ;
     var queries : int ; queries := sc.getCurrent()->toInteger() ;
         while (queries > 0) do (        queries := queries - 1 ;     skip ; (     var l : int ; l := sc.getCurrent()->toInteger() - 1 ;
     var r : int ; r := sc.getCurrent()->toInteger() - 1 ;
    var count : int ; count := sc.getCurrent()->toInteger() mod (r - l + 1) ;
    var toShift : String ; toShift := s.subrange(l+1,r + 1) ;
    var sb : String ; sb := StringLib.newString("") ;
        var i : int ; i := 0 ; while i < toShift->size() do ( (     sb := sb + StringLib.newString(toShift->at((toShift->size() - count + i) mod toShift->size()+1)) )  ;     i := i + 1 ) ; 
    var start : String ; start := if l = 0 then "" else s.subrange(0+1,l) endif ;
    var end : String ; end := if r = s->size() - 1 then "" else s.subrange(r + 1+1,s->size()) endif ;
    s := start + sb+"" + end ; 
 ) ;  ) ;  
     OclFile["System.out"].println(s) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class QueriesOnAString {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String strA=br.readLine();
    int m=Integer.parseInt(br.readLine());
    ArrayList<Query>queries=new ArrayList<>();
    for(int i=0 ; i<m ; i++){
      String[] str=br.readLine().split(" ");
      queries.add(new Query(Integer.parseInt(str[0]),Integer.parseInt(str[1]),Integer.parseInt(str[2])));
    }
    for(int i=0 ; i<m ; i++){
      int l=queries.get(i).l ;
      int r=queries.get(i).r ;
      int k=queries.get(i).k ;
      String tempStrA1=strA.substring(0,l);
      String tempStrA2=strA.substring(l,r+1);
      String tempStrA3=strA.substring(r+1,strA.length());
      String tempStrA4=rotate(tempStrA2,k);
      strA=tempStrA1+tempStrA4+tempStrA3 ;
    }
    System.out.print(strA);
  }
  private static String rotate(String tempStrA2,int k){
    return tempStrA2.substring(tempStrA2.length()-k,tempStrA2.length())+tempStrA2.substring(0,tempStrA2.length()-k);
  }
}
class Query {
  int l ;
  int r ;
  int k ;
  public Query(int l,int r,int k){
    this.l=l-1 ;
    this.r=r-1 ;
    this.k=k ;
    this.k=this.k %(r-l+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class QueriesOnAString {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var strA : String ; strA := br.readLine() ;
    var m : int ; m := (br.readLine())->toInteger() ;
    var queries : Sequence(Query) ; queries := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     queries := queries->including(Query.newQuery((str[0+1])->toInteger(), (str[1+1])->toInteger(), (str[2+1])->toInteger())) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var l : int ; l := queries->at(i+1).l ;
     var r : int ; r := queries->at(i+1).r ;
    var k : int ; k := queries->at(i+1).k ;
    var tempStrA1 : String ; tempStrA1 := strA.subrange(0+1,l) ;
    var tempStrA2 : String ; tempStrA2 := strA.subrange(l+1,r + 1) ;
    var tempStrA3 : String ; tempStrA3 := strA.subrange(r + 1+1,strA->size()) ;
    var tempStrA4 : String ; tempStrA4 := rotate(tempStrA2, k) ;
    strA := tempStrA1 + tempStrA4 + tempStrA3 ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(strA) ; 
 );
  static   operation rotate( tempStrA2 : String, k : int) : String
  pre: true
  post: true
  activity: (     return tempStrA2.subrange(tempStrA2->size() - k+1,tempStrA2->size()) + tempStrA2.subrange(0+1,tempStrA2->size() - k) );
}
class Query {
   attribute l : int;
   attribute r : int;
   attribute k : int;
   static operation newQuery( l : int, r : int, k : int) : Query
  pre: true
  post: true
  activity:
  ( var self : Query ;
    self := createQuery();
    self.initialise(l, r,k);
    return self );
  operation initialise( l : int, r : int, k : int) : void
  pre: true  post: true
  activity: (     self.l := (l)->char2byte() - 1 ; 
     self.r := (r)->char2byte() - 1 ; 
     self.k := k ; 
     self.k := self.k mod ((r)->char2byte() - (l)->char2byte() + 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class AntonAndPolyhendrom {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String[][] poly={
      {
        "Tetrahedron","4" },{
          "Cube","6" },{
            "Octahedron","8" },{
              "Dodecahedron","12" },{
                "Icosahedron","20" }
              };
              int number=in.nextInt();
              int counter=0 ;
              for(int i=0 ; i<number ; i++){
                String str=in.next();
                for(int j=0 ; j<poly.length ; j++){
                  if(str.equals(poly[j][0])){
                    counter+=Integer.parseInt(poly[j][1]);
                  }
                }
              }
              System.out.println(counter);
            }
          }

------------------------------------------------------------
OCL File:
---------
 class AntonAndPolyhendrom {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var poly : Sequence(Sequence(String)) ; poly := Sequence{Sequence{"Tetrahedron","4"},Sequence{"Cube","6"},Sequence{"Octahedron","8"},Sequence{"Dodecahedron","12"},Sequence{"Icosahedron","20"}} ;
    var number : int ; number := in.getCurrent()->toInteger() ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < number do ( (     var str : String ; str := in.getCurrent() ;
         var j : int ; j := 0 ; while j < poly->size() do ( (     if (str = poly[j+1][0+1]) then (     counter := counter+((poly[j+1][1+1])->toInteger()) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static int phi(int n){
    int result=1 ;
    for(int i=2 ; i<n ; i++)if(gcd(i,n)==1)result++;
    return result ;
  }
  public static void main(String[] args){
    int n ;
    for(n=1 ; n<=10 ; n++)System.out.println("phi("+n+")="+phi(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation phi( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 1 ;
         var i : int ; i := 2 ; while i < n do (     if (gcd(i, n) = 1) then     result := result + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
         n := 1 ; while n <= 10 do (     OclFile["System.out"].println("phi(" + n + ")=" + phi(n)) ;  ;     n := n + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(in.readLine());
    int[] t=new int[n];
    String[] str=in.readLine().split(" ");
    int t_sum=0 ;
    for(int i=0 ; i<n ; i++){
      t[i]=Integer.parseInt(str[i]);
      t_sum+=t[i];
    }
    int m=Integer.parseInt(in.readLine());
    int[] p=new int[m];
    int[] x=new int[m];
    for(int i=0 ; i<m ; i++){
      str=in.readLine().split(" ");
      p[i]=Integer.parseInt(str[0]);
      x[i]=Integer.parseInt(str[1]);
      System.out.println(t_sum-(t[p[i]-1]-x[i]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (in.readLine())->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
    var str : Sequence(String) ; str := in.readLine()->split(" ") ;
    var t_sum : int ; t_sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     t[i+1] := (str[i+1])->toInteger() ; 
     t_sum := t_sum+(t[i+1]) )  ;     i := i + 1 ) ; 
    var m : int ; m := (in.readLine())->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,m)->collect(0) ;
    var x : Sequence(int) ; x := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     str := in.readLine()->split(" ") ; 
     p[i+1] := (str[0+1])->toInteger() ; 
     x[i+1] := (str[1+1])->toInteger() ; 
     OclFile["System.out"].println(t_sum - (t[p[i+1] - 1+1] - x[i+1])) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Dragons {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter p=new PrintWriter(System.out);
    HashMap<String,Integer>hm=new HashMap<>();
    hm.put("Tetrahedron",4);
    hm.put("Cube",6);
    hm.put("Octahedron",8);
    hm.put("Dodecahedron",12);
    hm.put("Icosahedron",20);
    int sum=0 ;
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      sum+=hm.get(in.next());
    }
    p.println(sum);
    p.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Dragons {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : OclFile ; p := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var hm : Map(String,int) ; hm := Map{} ;
    hm := hm->union(Map{"Tetrahedron" |-> 4}) ; 
    hm := hm->union(Map{"Cube" |-> 6}) ; 
    hm := hm->union(Map{"Octahedron" |-> 8}) ; 
    hm := hm->union(Map{"Dodecahedron" |-> 12}) ; 
    hm := hm->union(Map{"Icosahedron" |-> 20}) ; 
    var sum : int ; sum := 0 ;
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(hm->at(in.getCurrent())) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int arr[]={
    1,2,3,4,5,6 };
    static int multiply(){
      int pro=1 ;
      for(int i=0 ; i<arr.length ; i++)pro=pro*arr[i];
      return pro ;
    }
    public static void main(String[] args){
      System.out.println(multiply());
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute arr : int := Sequence{1,2,3,4,5,6};
  static   operation multiply() : int
  pre: true
  post: true
  activity: (     var pro : int ; pro := 1 ;
         var i : int ; i := 0 ; while i < arr->size() do (     pro := pro * arr[i+1] ;  ;     i := i + 1 ) ; 
     return pro );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(multiply()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class CP7 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n1=sc.nextInt(),total=0 ;
    String num[]=new String[n1+1];
    for(int i=0 ; i<num.length ; i++){
      num[i]=sc.nextLine();
    }
    for(int i=0 ; i<num.length ; i++){
      if(num[i] .equals("Icosahedron")){
        total=total+20 ;
      }
      else if(num[i] .equals("Dodecahedron")){
        total=total+12 ;
      }
      else if(num[i] .equals("Octahedron")){
        total=total+8 ;
      }
      else if(num[i] .equals("Cube")){
        total=total+6 ;
      }
      else if(num[i] .equals("Tetrahedron")){
        total=total+4 ;
      }
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CP7 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n1 : int ; n1 := sc.getCurrent()->toInteger() ;
    var total : int ; total := 0 ;
    var num : Sequence(String) ; num := Integer.subrange(1,n1 + 1)->collect(null) ;
        var i : int ; i := 0 ; while i < num->size() do ( (     num[i+1] := sc.nextLine() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < num->size() do ( (     if (num[i+1] = "Icosahedron") then (     total := total + 20 ) else     if (num[i+1] = "Dodecahedron") then (     total := total + 12 ) else     if (num[i+1] = "Octahedron") then (     total := total + 8 ) else     if (num[i+1] = "Cube") then (     total := total + 6 ) else     if (num[i+1] = "Tetrahedron") then (     total := total + 4 ) else skip ; ;  ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A785 {
  static FastScanner sc=new FastScanner();
  public static void main(String[] args){
    solve();
  }
  public static void solve(){
    char[] ch={
      'T','C','O','D','I' };
      int[] t={
        4,6,8,12,20 };
        int n=sc.nextInt();
        int result=0 ;
        String[] arr=new String[n];
        for(int i=0 ; i<n ; i++){
          arr[i]=sc.next();
          for(int k=0 ; k<5 ; k++){
            if(arr[i] .charAt(0)==ch[k])result+=t[k];
          }
        }
        System.out.print(result);
      }
      static class FastScanner {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st=new StringTokenizer("");
        String next(){
          while(! st.hasMoreTokens())try {
            st=new StringTokenizer(br.readLine());
          }
          catch(IOException e){
            e.printStackTrace();
          }
          return st.nextToken();
        }
        int nextInt(){
          return Integer.parseInt(next());
        }
        int[] readArray(int n){
          int[] a=new int[n];
          for(int i=0 ; i<n ; i++)a[i]=nextInt();
          return a ;
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class A785 {
  static   attribute sc : FastScanner := FastScanner.newFastScanner();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var ch : Sequence(String) ; ch := Sequence{'T','C','O','D','I'} ;
     var t : Sequence(int) ; t := Sequence{4,6,8,12,20} ;
    var n : int ; n := sc.nextInt() ;
    var result : int ; result := 0 ;
    var arr : Sequence(String) ; arr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.next() ; 
         var k : int ; k := 0 ; while k < 5 do ( (     if (arr[i+1]->at(0+1) = ch[k+1]) then     result := result+(t[k+1]) ; else skip )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(result) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.HashMap ;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    HashMap<String,Integer>map=new HashMap<>();
    map.put("Tetrahedron",4);
    map.put("Cube",6);
    map.put("Octahedron",8);
    map.put("Dodecahedron",12);
    map.put("Icosahedron",20);
    int n=sc.nextInt();
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      String s=sc.next();
      sum+=map.get(s);
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var map : Map(String,int) ; map := Map{} ;
    map := map->union(Map{"Tetrahedron" |-> 4}) ; 
    map := map->union(Map{"Cube" |-> 6}) ; 
    map := map->union(Map{"Octahedron" |-> 8}) ; 
    map := map->union(Map{"Dodecahedron" |-> 12}) ; 
    map := map->union(Map{"Icosahedron" |-> 20}) ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
     sum := sum+(map->at(s)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),a=sc.nextInt(),b=sc.nextInt();
    int ans=1 ;
    for(; ; ){
      if(a % 2==0)a/=2 ;
      else a=a/2+1 ;
      if(b % 2==0)b/=2 ;
      else b=b/2+1 ;
      if(a==b)break ;
      ans++;
    }
    if(ans==log2(n))System.out.println("Final!");
    else System.out.println(ans);
    sc.close();
  }
  private static int log2(int n){
    for(int i=1,ret=0 ; ; i*=2,ret++){
      if(i>=n)return ret ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 1 ;
      while true do ( (     if (a mod 2 = 0) then     a := a/(2) else     a := a / 2 + 1 ; ;  
     if (b mod 2 = 0) then     b := b/(2) else     b := b / 2 + 1 ; ;  
     if (a = b) then     break else skip ; 
     ans := ans + 1 )  ) ; 
    if (ans = log2(n)) then     OclFile["System.out"].println("Final!") else     OclFile["System.out"].println(ans) ; ;  
    skip ; 
 );
  static   operation log2( n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ;
    var ret : int ; ret := 0 ; while true do ( (     if (i >= n) then     return ret else skip )  ;     i := i*(2) ;     ret := ret + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class cfr468b {
  public static void main(String[] args){
    Scanner kb=new Scanner(System.in);
    int n=kb.nextInt();
    int a=kb.nextInt()-1 ;
    int b=kb.nextInt()-1 ;
    int count=0 ;
    while(a!=b){
      a/=2 ;
      b/=2 ;
      count++;
    }
    if(Math.pow(2,count)==n)System.out.println("Final!");
    else System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cfr468b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var kb : OclFile ; kb := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := kb.getCurrent()->toInteger() ;
    var a : int ; a := kb.getCurrent()->toInteger() - 1 ;
    var b : int ; b := kb.getCurrent()->toInteger() - 1 ;
    var count : int ; count := 0 ;
    while (a /= b) do (     a := a/(2) ; 
     b := b/(2) ; 
     count := count + 1 ) ; 
    if (2->pow(count) = n) then     OclFile["System.out"].println("Final!") else     OclFile["System.out"].println(count) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class WorldCup {
  public static void main(String[] args){
    FastReader in=new FastReader();
    int n=in.nextInt();
    int a=in.nextInt();
    int b=in.nextInt();
    int d=0 ;
    a--;
    b--;
    while(a!=b){
      a/=2 ;
      b/=2 ;
      n/=2 ;
      d++;
    }
    if(n==1)System.out.println("Final!");
    else System.out.println(d);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class WorldCup {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var n : int ; n := in.nextInt() ;
    var a : int ; a := in.nextInt() ;
    var b : int ; b := in.nextInt() ;
    var d : int ; d := 0 ;
    a := a - 1 ; 
    b := b - 1 ; 
    while (a /= b) do (     a := a/(2) ; 
     b := b/(2) ; 
     n := n/(2) ; 
     d := d + 1 ) ; 
    if (n = 1) then     OclFile["System.out"].println("Final!") else     OclFile["System.out"].println(d) ; ;  
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class B {
  public static void main(String[] args)throws IOException {
    int n=readInt();
    int a=readInt()-1 ;
    int b=readInt()-1 ;
    int x=Integer.toBinaryString(n).length()-2 ;
    for(int i=x ; i>=0 ; i--){
      if(((1<<i)& a)!=((1<<i)& b)){
        if(i==x)out.println("Final!");
        else out.println(i+1);
        break ;
      }
    }
    out.close();
  }
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
  static StringTokenizer st=new StringTokenizer("");
  static String read()throws IOException {
    while(! st.hasMoreElements())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public static int readInt()throws IOException {
    return Integer.parseInt(read());
  }
  public static long readLong()throws IOException {
    return Long.parseLong(read());
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := readInt() ;
     var a : int ; a := readInt() - 1 ;
    var b : int ; b := readInt() - 1 ;
    var x : int ; x := (MathLib.decimal2binary(n) + "")->size() - 2 ;
        var i : int ; i := x ; while i >= 0 do ( (     if ((((1*(2->pow(i)))->oclAsType(long)) & a) /= (((1*(2->pow(i)))->oclAsType(long)) & b)) then (     if (i = x) then     out.println("Final!") else     out.println(i + 1) ; ;  
     break ) else skip )  ;     i := i - 1 ) ; 
    out.close() ; 
 );
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute st : OclIterator := OclIterator.newOclIterator_String("");
  static   operation read() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
  static   operation readInt() : int
  pre: true
  post: true
  activity: (     return (read())->toInteger() );
  static   operation readLong() : long
  pre: true
  post: true
  activity: (     return (read())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.*;
public class Solution {
  static MyScanner str=new MyScanner();
  public static void main(String[] args)throws IOException {
    int T=1 ;
    while(T-->0){
      solve();
    }
  }
  static void solve()throws IOException {
    int n=i(),a=i(),b=i();
    int res=1 ;
    a--;
    b--;
    while(a/2!=b/2){
      a/=2 ;
      b/=2 ;
      res++;
    }
    if(Math.pow(2,res)==n){
      System.out.println("Final!");
    }
    else System.out.println(res);
  }
  public static int i()throws IOException {
    return str.nextInt();
  }
  public static long l()throws IOException {
    return str.nextLong();
  }
  public static double d()throws IOException {
    return str.nextDouble();
  }
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute str : MyScanner := MyScanner.newMyScanner();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := 1 ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := i() ;
    var a : int ; a := i() ;
    var b : int ; b := i() ;
     var res : int ; res := 1 ;
    a := a - 1 ; 
    b := b - 1 ; 
    while (a / 2 /= b / 2) do (     a := a/(2) ; 
     b := b/(2) ; 
     res := res + 1 ) ; 
    if (2->pow(res) = n) then (     OclFile["System.out"].println("Final!") ) else     OclFile["System.out"].println(res) ; ;  
 );
  static   operation i() : int
  pre: true
  post: true
  activity: (     return str.nextInt() );
  static   operation l() : long
  pre: true
  post: true
  activity: (     return str.nextLong() );
  static   operation d() : double
  pre: true
  post: true
  activity: (     return str.nextDouble() );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  boolean main()throws IOException {
    int[] a=readIntArray();
    int X=a[0];
    int A=a[1];
    int B=a[2];
    int N=readIntArray()[0];
    for(int i=0 ; i<N ; i++){
      String s=reader.readLine();
      if(s.equals("nobiro")){
        X+=A ;
      }
      else if(s.equals("tidime")){
        X+=B ;
      }
      else if(s.equals("karero")){
        X=0 ;
      }
      if(X<0)X=0 ;
    }
    System.out.printf("%d\n",X);
    return false ;
  }
  private final static boolean DEBUG=false ;
  public static void main(String[] args)throws IOException {
    if(DEBUG){
      log=System.out ;
      String inputStr="10 30 10\r\n"+"3\r\n"+"nobiro\r\n"+"nobiro\r\n"+"tidime\n" ;
      reader=new BufferedReader(new StringReader(inputStr));
    }
    else {
      log=new PrintStream(new OutputStream(){
        public void write(int b){
        }
      }
);
      reader=new BufferedReader(new InputStreamReader(System.in));
    }
    for(int loop=0 ; ; loop++){
      boolean b=new Main().main();
      if(! b)break ;
    }
    reader.close();
  }
  static PrintStream log ;
  static BufferedReader reader ;
  private int[] readIntArray()throws IOException {
    String s=reader.readLine();
    String[] sp=s.split(" ");
    int[] a=new int[sp.length];
    for(int i=0 ; i<sp.length ; i++){
      a[i]=Integer.parseInt(sp[i]);
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := readIntArray() ;
     var X : int ; X := a[0+1] ;
    var A : int ; A := a[1+1] ;
    var B : int ; B := a[2+1] ;
    var N : int ; N := readIntArray()[0+1] ;
        var i : int ; i := 0 ; while i < N do ( (     var s : String ; s := reader.readLine() ;
     if (s = "nobiro") then (     X := X+(A) ) else     if (s = "tidime") then (     X := X+(B) ) else     if (s = "karero") then (     X := 0 ) else skip ; ;  ;  
     if (X < 0) then     X := 0 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%d\n", X) ; 
    return false 
 );
  static   attribute DEBUG : boolean := false;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (DEBUG) then (     log := OclFile["System.out"] ; 
     var inputStr : String ; inputStr := "10 30 10\r\n" + "3\r\n" + "nobiro\r\n" + "nobiro\r\n" + "tidime\n" ;
     reader := OclFile.newOclFile_Read(StringReader.newStringReader(inputStr)) ) else (     log := OclFile.newOclFile_Write(OclFile()) ; 
     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ) ;  
         var loop : int ; loop := 0 ; while true do ( (     var b : boolean ; b := Main.newMain().main() ;
     if (not(b)) then     break else skip )  ;     loop := loop + 1 ) ; 
     reader.close() );
  static   attribute log : OclFile;
  static   attribute reader : OclFile;
   operation readIntArray() : Sequence(int)
  pre: true
  post: true
  activity: (     var s : String ; s := reader.readLine() ;
     var sp : Sequence(String) ; sp := s->split(" ") ;
    var a : Sequence(int) ; a := Integer.subrange(1,sp->size())->collect(0) ;
        var i : int ; i := 0 ; while i < sp->size() do ( (     a[i+1] := (sp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    return a 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] T=new int[N];
    for(int i=0 ; i<T.length ; ++i){
      T[i]=sc.nextInt();
    }
    int M=sc.nextInt();
    int[] P=new int[M];
    int[] X=new int[M];
    for(int i=0 ; i<M ; ++i){
      P[i]=sc.nextInt();
      X[i]=sc.nextInt();
    }
    System.out.println(solve(T,P,X));
    sc.close();
  }
  static String solve(int[] T,int[] P,int[] X){
    int total=Arrays.stream(T).sum();
    return IntStream.range(0,P.length).mapToObj(i->String.valueOf(total+X[i]-T[P[i]-1])).collect(Collectors.joining("\n"));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var T : Sequence(int) ; T := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < T->size() do ( (     T[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var P : Sequence(int) ; P := Integer.subrange(1,M)->collect(0) ;
    var X : Sequence(int) ; X := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     P[i+1] := sc.getCurrent()->toInteger() ; 
     X[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(T, P, X)) ; 
    skip ; 
 );
  static   operation solve( T : Sequence(int), P : Sequence(int), X : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var total : int ; total := stream(T)->sum() ;
     return Integer.subrange(0, P->size()-1).mapToObj(lambda i : OclAny in ((total + X[i+1] - T[P[i+1] - 1+1]) + "")).collect(Collectors.joining("\n")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void createHash(HashSet<Integer>hash,int maxElement){
    int prev=0,curr=1 ;
    hash.add(prev);
    hash.add(curr);
    while(curr<=maxElement){
      int temp=curr+prev ;
      hash.add(temp);
      prev=curr ;
      curr=temp ;
    }
  }
  static int gcdFibonacciFreq(int arr[],int n){
    HashSet<Integer>hash=new HashSet<Integer>();
    createHash(hash,Arrays.stream(arr).max().getAsInt());
    int i ;
    HashMap<Integer,Integer>m=new HashMap<Integer,Integer>();
    for(i=0 ; i<n ; i++){
      if(m.containsKey(arr[i])){
        m.put(arr[i],m.get(arr[i])+1);
      }
      else {
        m.put(arr[i],1);
      }
    }
    int gcd=0 ;
    for(Map.Entry<Integer,Integer>it : m.entrySet()){
      if(hash.contains(it.getValue())){
        gcd=__gcd(gcd,it.getKey());
      }
    }
    return gcd ;
  }
  static int __gcd(int a,int b){
    return b==0 ? a : __gcd(b,a % b);
  }
  public static void main(String[] args){
    int arr[]={
      5,3,6,5,6,6,5,5 };
      int n=arr.length ;
      System.out.print(gcdFibonacciFreq(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation createHash( hash : Set(int), maxElement : int) : void
  pre: true
  post: true
  activity: (     var prev : int ; prev := 0 ;
    var curr : int ; curr := 1 ;
     hash->excludes(prev) ; 
     hash->excludes(curr) ; 
     while (curr <= maxElement) do (     var temp : int ; temp := curr + prev ;
     hash->excludes(temp) ; 
     prev := curr ; 
     curr := temp ) );
  static   operation gcdFibonacciFreq( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var hash : Set(int) ; hash := Set{} ;
     execute createHash(hash, stream(arr).max().getAsInt()) ; 
    var i : int ;
    var m : Map(int,int) ; m := Map{} ;
        i := 0 ; while i < n do ( (     if (m->keys()->includes(arr[i+1])) then (     m := m->union(Map{arr[i+1] |-> m->at(arr[i+1]) + 1}) ) else (     m := m->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var gcd : int ; gcd := 0 ;
    for (it : m->asSet()) do ( (     if (hash->includes(it.getValue())) then (     gcd := __gcd(gcd, it.getKey()) ) else skip )  ) ; 
    return gcd 
 );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else __gcd(b, a mod b) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,3,6,5,6,6,5,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(gcdFibonacciFreq(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int q,order_num,i,j,n=0,counter ;
    boolean[] flag=new boolean[64];
    try(Scanner sc=new Scanner(System.in)){
      q=sc.nextInt();
      for(j=0 ; j<q ; j++){
        order_num=sc.nextInt();
        if(order_num<=3){
          n=sc.nextInt();
        }
        switch(order_num){
          case 0 : System.out.println(flag[n] ? "1" : "0");
          break ;
          case 1 : flag[n]=true ;
          break ;
          case 2 : flag[n]=false ;
          break ;
          case 3 : flag[n]=! flag[n];
          break ;
          case 4 : counter=1 ;
          for(i=0 ; i<64 ; i++){
            if(flag[i]!=true){
              counter=0 ;
              break ;
            }
          }
          System.out.println(counter);
          break ;
          case 5 : counter=0 ;
          for(i=0 ; i<64 ; i++){
            if(flag[i]!=false){
              counter=1 ;
              break ;
            }
          }
          System.out.println(counter);
          break ;
          case 6 : counter=1 ;
          for(i=0 ; i<64 ; i++){
            if(flag[i]==true){
              counter=0 ;
              break ;
            }
          }
          System.out.println(counter);
          break ;
          case 7 : counter=0 ;
          for(i=0 ; i<64 ; i++){
            if(flag[i]==true){
              counter++;
            }
          }
          System.out.println(counter);
          break ;
          case 8 : BigDecimal sum=new BigDecimal("0");
          BigDecimal big=new BigDecimal("2");
          for(i=0 ; i<64 ; i++){
            if(flag[i]){
              sum=sum.add(big.pow(i));
            }
          }
          System.out.println(sum);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var q : int ;
    var order_num : int ;
    var i : int ;
    var j : int ;
    var n : int ; n := 0 ;
    var counter : int ;
     var flag : Sequence(boolean) ; flag := Integer.subrange(1,64)->collect(false) ;
     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     q := sc.getCurrent()->toInteger() ; 
         j := 0 ; while j < q do ( (     order_num := sc.getCurrent()->toInteger() ; 
     if (order_num <= 3) then (     n := sc.getCurrent()->toInteger() ) else skip ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (order_num) ; 
       if _switchval = 0 then
     OclFile["System.out"].println(if flag[n+1] then "1" else "0" endif) ; 
    break 
   else skip ;
       if _switchval = 1 then
     flag[n+1] := true ; 
    break 
   else skip ;
       if _switchval = 2 then
     flag[n+1] := false ; 
    break 
   else skip ;
       if _switchval = 3 then
     flag[n+1] := not(flag[n+1]) ; 
    break 
   else skip ;
       if _switchval = 4 then
     counter := 1 ; 
        i := 0 ; while i < 64 do ( (     if (flag[i+1] /= true) then (     counter := 0 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
    break 
   else skip ;
       if _switchval = 5 then
     counter := 0 ; 
        i := 0 ; while i < 64 do ( (     if (flag[i+1] /= false) then (     counter := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
    break 
   else skip ;
       if _switchval = 6 then
     counter := 1 ; 
        i := 0 ; while i < 64 do ( (     if (flag[i+1] = true) then (     counter := 0 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
    break 
   else skip ;
       if _switchval = 7 then
     counter := 0 ; 
        i := 0 ; while i < 64 do ( (     if (flag[i+1] = true) then (     counter := counter + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
    break 
   else skip ;
       if _switchval = 8 then
     var sum : double ; sum := double("0") ;
    var big : double ; big := double("2") ;
        i := 0 ; while i < 64 do ( (     if (flag[i+1]) then (     sum := sum->excludes(big.pow(i)) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
   else skip ;
 )
 )  ;     j := j + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      String s=sc.next();
      if("nobiro".equals(s)){
        x=Math.max(0,x+a);
      }
      else if("tidime".equals(s)){
        x=Math.max(0,x+b);
      }
      else if("karero".equals(s)){
        x=0 ;
      }
    }
    System.out.println(x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
     if ("nobiro" = s) then (     x := Set{0, x + a}->max() ) else     if ("tidime" = s) then (     x := Set{0, x + b}->max() ) else     if ("karero" = s) then (     x := 0 ) else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(x) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Plant {
  private int length ;
  private int glowthOfNobiro ;
  private int glowthOfTidime ;
  public Plant(int length,int glowthOfNobiro,int glowthOfTidime){
    this.length=length ;
    this.glowthOfNobiro=glowthOfNobiro ;
    this.glowthOfTidime=glowthOfTidime ;
  }
  public void growPlant(String message){
    if(message.equals("nobiro")){
      this.length+=this.glowthOfNobiro ;
      if(this.length<0){
        this.length=0 ;
      }
    }
    else if(message.equals("tidime")){
      this.length+=this.glowthOfTidime ;
      if(this.length<0){
        this.length=0 ;
      }
    }
    else if(message.equals("karero")){
      this.length=0 ;
    }
  }
  public int getLength(){
    return this.length ;
  }
}
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int X=Integer.parseInt(sc.next());
    int A=Integer.parseInt(sc.next());
    int B=Integer.parseInt(sc.next());
    Plant plant=new Plant(X,A,B);
    int N=Integer.parseInt(sc.next());
    for(int i=0 ; i<N ; i++){
      String S=sc.next();
      plant.growPlant(S);
    }
    System.out.println(plant.getLength());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Plant {
   attribute length : int;
   attribute glowthOfNobiro : int;
   attribute glowthOfTidime : int;
   static operation newPlant( length : int, glowthOfNobiro : int, glowthOfTidime : int) : Plant
  pre: true
  post: true
  activity:
  ( var self : Plant ;
    self := createPlant();
    self.initialise(length, glowthOfNobiro,glowthOfTidime);
    return self );
  operation initialise( length : int, glowthOfNobiro : int, glowthOfTidime : int) : void
  pre: true  post: true
  activity: (     self->size() := length ; 
     self.glowthOfNobiro := glowthOfNobiro ; 
     self.glowthOfTidime := glowthOfTidime );
   operation growPlant( message : String) : void
  pre: true
  post: true
  activity: (     if (message = "nobiro") then (     self->size() := self->size()+(self.glowthOfNobiro) ; 
     if (self->size() < 0) then (     self->size() := 0 ) else skip ) else     if (message = "tidime") then (     self->size() := self->size()+(self.glowthOfTidime) ; 
     if (self->size() < 0) then (     self->size() := 0 ) else skip ) else     if (message = "karero") then (     self->size() := 0 ) else skip ; ;  );
   operation getLength() : int
  pre: true
  post: true
  activity: (     return self->size() );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : int ; X := (sc.getCurrent())->toInteger() ;
    var A : int ; A := (sc.getCurrent())->toInteger() ;
    var B : int ; B := (sc.getCurrent())->toInteger() ;
    var plant : Plant ; plant := Plant.newPlant(X, A, B) ;
    var N : int ; N := (sc.getCurrent())->toInteger() ;
        var i : int ; i := 0 ; while i < N do ( (     var S : String ; S := sc.getCurrent() ;
     plant.growPlant(S) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(plant.getLength()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Point2D ;
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new AOJ0515().doIt();
  }
  class AOJ0515 {
    void doIt(){
      while(true){
        int w=in.nextInt();
        int h=in.nextInt();
        if(w+h==0)break ;
        int n=in.nextInt();
        boolean[][] kouji=new boolean[h][w];
        for(int i=0 ; i<h ; i++)Arrays.fill(kouji[i],true);
        for(int i=0 ; i<n ; i++){
          int x=in.nextInt()-1 ;
          int y=in.nextInt()-1 ;
          kouji[y][x]=false ;
        }
        int[][] dp=new int[h][w];
        dp[0][0]=1 ;
        for(int i=0 ; i<h ; i++)for(int s=0 ; s<w ; s++)if(kouji[i][s]){
          for(int t=0 ; t<2 ; t++)for(int r=0 ; r<2 ; r++)if(t!=r){
            int nx=s+t ;
            int ny=i+r ;
            if(nx<0 || nx>=w || ny<0 || ny>=h)continue ;
            dp[ny][nx]+=dp[i][s];
          }
        }
        System.out.println(dp[h-1][w-1]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     AOJ0515.newAOJ0515().doIt() );
 class AOJ0515 {
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (true) do (     var w : int ; w := in.getCurrent()->toInteger() ;
     var h : int ; h := in.getCurrent()->toInteger() ;
    if (w + h = 0) then     break else skip ; 
    var n : int ; n := in.getCurrent()->toInteger() ;
    var kouji : Sequence(Sequence(boolean)) ; kouji := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(false)) ;
        var i : int ; i := 0 ; while i < h do (     kouji[i+1] := kouji[i+1]->collect(true) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() - 1 ;
     var y : int ; y := in.getCurrent()->toInteger() - 1 ;
     kouji[y+1][x+1] := false )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 0 ; while i < h do (         var s : int ; s := 0 ; while s < w do (     if (kouji[i+1][s+1]) then (         var t : int ; t := 0 ; while t < 2 do (         var r : int ; r := 0 ; while r < 2 do (     if (t /= r) then (     var nx : int ; nx := s + t ;
     var ny : int ; ny := i + r ;
     if (nx < 0 or nx >= w or ny < 0 or ny >= h) then     continue else skip ; 
     dp[ny+1][nx+1] := dp[ny+1][nx+1]+(dp[i+1][s+1]) ) else skip ;  ;     r := r + 1 ) ;  ;     t := t + 1 ) ) else skip ;  ;     s := s + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[h - 1+1][w - 1+1]) ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  static int[][] dp ;
  static boolean[][] isStop ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(true){
      int w=in.nextInt();
      int h=in.nextInt();
      if(w==0 && h==0){
        in.close();
        return ;
      }
      int n=in.nextInt();
      dp=new int[h+1][w+1];
      isStop=new boolean[h+1][w+1];
      for(int i=0 ; i<h+1 ; i++){
        for(int j=0 ; j<w+1 ; j++){
          isStop[i][j]=false ;
        }
      }
      for(int i=0 ; i<n ; i++){
        int a=in.nextInt();
        int b=in.nextInt();
        isStop[b][a]=true ;
      }
      System.out.println(solve(h,w));
    }
  }
  static int solve(int y,int x){
    if(dp[y][x]!=0)return dp[y][x];
    if(x==0 || y==0)return 0 ;
    if(x==1 && y==1)return 1 ;
    if(isStop[y][x]){
      return 0 ;
    }
    int ret=0 ;
    dp[y][x]=(solve(y-1,x)+solve(y,x-1));
    ret=dp[y][x];
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dp : Sequence(Sequence(int));
  static   attribute isStop : Sequence(Sequence(boolean));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var w : int ; w := in.getCurrent()->toInteger() ;
     var h : int ; h := in.getCurrent()->toInteger() ;
    if (w = 0 & h = 0) then (     skip ; 
     return ) else skip ; 
    var n : int ; n := in.getCurrent()->toInteger() ;
    dp := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(0)) ; 
    isStop := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(false)) ; 
        var i : int ; i := 0 ; while i < h + 1 do ( (         var j : int ; j := 0 ; while j < w + 1 do ( (     isStop[i+1][j+1] := false )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
     isStop[b+1][a+1] := true )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(h, w)) ; 
 ) );
  static   operation solve( y : int, x : int) : int
  pre: true
  post: true
  activity: (     if (dp[y+1][x+1] /= 0) then     return dp[y+1][x+1] else skip ; 
     if (x = 0 or y = 0) then     return 0 else skip ; 
    if (x = 1 & y = 1) then     return 1 else skip ; 
    if (isStop[y+1][x+1]) then (     return 0 ) else skip ; 
    var ret : int ; ret := 0 ;
    dp[y+1][x+1] := (solve(y - 1, x) + solve(y, x - 1)) ; 
    ret := dp[y+1][x+1] ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader reader=new BufferedReader(isr);
    String string ;
    int h,w,n,c,v ;
    while(!(string=reader.readLine()).equals("0 0")){
      h=Integer.parseInt(string.split(" ")[0]);
      w=Integer.parseInt(string.split(" ")[1]);
      int[][] array=new int[h+1][w+1];
      boolean[][] imp=new boolean[h+1][w+1];
      n=Integer.parseInt(reader.readLine());
      for(int i=0 ; i<n ; i++){
        string=reader.readLine();
        c=Integer.parseInt(string.split(" ")[0]);
        v=Integer.parseInt(string.split(" ")[1]);
        imp[c][v]=true ;
      }
      array[1][1]=1 ;
      for(int i=1 ; i<=h ; i++){
        for(int j=1 ; j<=w ; j++){
          if(! imp[i][j]){
            array[i][j]=array[i][j-1]+array[i-1][j];
            if(i==1 && j==1)array[i][j]=1 ;
          }
          else {
            array[i][j]=0 ;
          }
        }
      }
      System.out.println(array[h][w]);
    }
    reader.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(isr) ;
    var string : String ;
    var h : int ;
    var w : int ;
    var n : int ;
    var c : int ;
    var v : int ;
    while (not((string) = "0 0")) do (     h := (string->split(" ")[0+1])->toInteger() ; 
     w := (string->split(" ")[1+1])->toInteger() ; 
    var array : Sequence(Sequence(int)) ; array := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(0)) ;
    var imp : Sequence(Sequence(boolean)) ; imp := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(false)) ;
    n := (reader.readLine())->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     string := reader.readLine() ; 
     c := (string->split(" ")[0+1])->toInteger() ; 
     v := (string->split(" ")[1+1])->toInteger() ; 
     imp[c+1][v+1] := true )  ;     i := i + 1 ) ; 
    array[1+1][1+1] := 1 ; 
        var i : int ; i := 1 ; while i <= h do ( (         var j : int ; j := 1 ; while j <= w do ( (     if (not(imp[i+1][j+1])) then (     array[i+1][j+1] := array[i+1][j - 1+1] + array[i - 1+1][j+1] ; 
     if (i = 1 & j = 1) then     array[i+1][j+1] := 1 ; else skip ) else (     array[i+1][j+1] := 0 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(array[h+1][w+1]) ; 
 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    int x,y ;
    x=scanner.nextInt();
    y=scanner.nextInt();
    while(x+y!=0){
      int n=scanner.nextInt();
      int a[]=new int[n];
      int b[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=scanner.nextInt();
        b[i]=scanner.nextInt();
      }
      System.out.println(f(x,y,1,1,a,b));
      x=scanner.nextInt();
      y=scanner.nextInt();
    }
  }
  public static int f(int x,int y,int a,int b,int n[],int m[]){
    if((a==x-1 && b==y)||(a==x && b==y-1)){
      return 1 ;
    }
    int flag=1 ;
    int k1=0,k2=0 ;
    if(a<x){
      for(int i=0 ; i<n.length ; i++){
        if(a+1==n[i] && b==m[i]){
          flag=0 ;
          break ;
        }
      }
      if(flag==1){
        k1=f(x,y,a+1,b,n,m);
      }
    }
    flag=1 ;
    if(b<y){
      for(int i=0 ; i<n.length ; i++){
        if(a==n[i] && b+1==m[i]){
          flag=0 ;
          break ;
        }
      }
      if(flag==1){
        k2=f(x,y,a,b+1,n,m);
      }
    }
    return k1+k2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ;
    var y : int ;
    x := scanner.getCurrent()->toInteger() ; 
    y := scanner.getCurrent()->toInteger() ; 
    while (x + y /= 0) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() ; 
     b[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(f(x, y, 1, 1, a, b)) ; 
    x := scanner.getCurrent()->toInteger() ; 
    y := scanner.getCurrent()->toInteger() ; 
 ) ; 
 );
  static   operation f( x : int, y : int, a : int, b : int, n : Sequence(int), m : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if ((a = x - 1 & b = y) or (a = x & b = y - 1)) then (     return 1 ) else skip ; 
     var flag : int ; flag := 1 ;
    var k1 : int ; k1 := 0 ;
    var k2 : int ; k2 := 0 ;
    if (a < x) then (         var i : int ; i := 0 ; while i < n->size() do ( (     if (a + 1 = n[i+1] & b = m[i+1]) then (     flag := 0 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (flag = 1) then (     k1 := f(x, y, a + 1, b, n, m) ) else skip ) else skip ; 
    flag := 1 ; 
    if (b < y) then (         var i : int ; i := 0 ; while i < n->size() do ( (     if (a = n[i+1] & b + 1 = m[i+1]) then (     flag := 0 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (flag = 1) then (     k2 := f(x, y, a, b + 1, n, m) ) else skip ) else skip ; 
    return k1 + k2 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String line[]=br.readLine().split(" ");
      int a=Integer.parseInt(line[0]);
      int b=Integer.parseInt(line[1]);
      if(a==0){
        break ;
      }
      int road[][]=new int[a+1][b+1];
      road[1][1]=1 ;
      int n=Integer.parseInt(br.readLine());
      for(int i=0 ; i<n ; i++){
        String cons[]=br.readLine().split(" ");
        road[Integer.parseInt(cons[0])][Integer.parseInt(cons[1])]=-1 ;
      }
      for(int i=1 ; i<=a ; i++){
        for(int j=1 ; j<=b ; j++){
          if(road[i][j]!=-1 && i*j!=1){
            road[i][j]=Math.max(0,road[i-1][j])+Math.max(0,road[i][j-1]);
          }
        }
      }
      System.out.println(road[a][b]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
     var a : int ; a := (line[0+1])->toInteger() ;
    var b : int ; b := (line[1+1])->toInteger() ;
    if (a = 0) then (     break ) else skip ; 
    var road : Sequence(Sequence(int)) ; road := Integer.subrange(1,a + 1)->collect(Integer.subrange(1,b + 1)->collect(0)) ;
    road[1+1][1+1] := 1 ; 
    var n : int ; n := (br.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var cons : Sequence(String) ; cons := br.readLine()->split(" ") ;
     road[(cons[0+1])->toInteger()+1][(cons[1+1])->toInteger()+1] := -1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= a do ( (         var j : int ; j := 1 ; while j <= b do ( (     if (road[i+1][j+1] /= -1 & i * j /= 1) then (     road[i+1][j+1] := Set{0, road[(i)->char2byte() - 1+1][j+1]}->max() + Set{0, road[i+1][j - 1+1]}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(road[a+1][b+1]) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Vector<Integer>solve(int X,Vector<Integer>A){
    int min=Integer.MAX_VALUE ;
    int ind=-1 ;
    for(int i=0 ; i<A.size(); i++){
      if(A.get(i)<min){
        min=A.get(i);
        ind=i ;
      }
    }
    int maxIndChosen=X/min ;
    Vector<Integer>ans=new Vector<>();
    if(maxIndChosen==0){
      return ans ;
    }
    for(int i=0 ; i<maxIndChosen ; i++){
      ans.add(ind);
    }
    int temp=maxIndChosen ;
    int sum=maxIndChosen*A.get(ind);
    for(int i=0 ; i<ind ; i++){
      if(sum-X==0 || temp==0)break ;
      while((sum-A.get(ind)+A.get(i))<=X && temp!=0){
        ans.remove(0);
        ans.add(i);
        temp--;
        sum+=(A.get(i)-A.get(ind));
      }
    }
    Collections.sort(ans);
    return ans ;
  }
  public static void main(String args[]){
    Integer arr[]={
      5,6,4,8 };
      Vector<Integer>A=new Vector<Integer>(Arrays.asList(arr));
      int X=18 ;
      Vector<Integer>ans=solve(X,A);
      for(int i=0 ; i<ans.size(); i++)System.out.print(ans.get(i)+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( X : int, A : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var min : int ; min := 2147483647 ;
     var ind : int ; ind := -1 ;
        var i : int ; i := 0 ; while i < A->size() do ( (     if (A->at(i+1) < min) then (     min := A->at(i+1) ; 
     ind := i ) else skip )  ;     i := i + 1 ) ; 
    var maxIndChosen : int ; maxIndChosen := X / min ;
    var ans : Sequence(int) ; ans := Sequence{} ;
    if (maxIndChosen = 0) then (     return ans ) else skip ; 
        var i : int ; i := 0 ; while i < maxIndChosen do ( (     ans := ans->including(ind) )  ;     i := i + 1 ) ; 
    var temp : int ; temp := maxIndChosen ;
    var sum : int ; sum := maxIndChosen * A->at(ind+1) ;
        var i : int ; i := 0 ; while i < ind do ( (     if (sum - X = 0 or temp = 0) then     break else skip ; 
     while ((sum - A->at(ind+1) + A->at(i+1)) <= X & temp /= 0) do (     ans := ans->excludingAt(0+1) ; 
     ans := ans->including(i) ; 
     temp := temp - 1 ; 
     sum := sum+((A->at(i+1) - A->at(ind+1))) ) )  ;     i := i + 1 ) ; 
    ans := ans->sort() ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,6,4,8} ;
     var A : Sequence(int) ; A := Sequence{}->union(arr) ;
    var X : int ; X := 18 ;
    var ans : Sequence(int) ; ans := solve(X, A) ;
        var i : int ; i := 0 ; while i < ans->size() do (     OclFile["System.out"].print(ans->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static long fact(int n){
    long res=1 ;
    for(int i=2 ; i<=n ; i++)res=res*i ;
    return res ;
  }
  static long nCr(int n,int r){
    return fact(n)/(1*fact(r)*fact(n-r));
  }
  static long number_of_subsequences(int arr[],int k,int n){
    long s=0 ;
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      if(mp.containsKey(arr[i])){
        mp.put(arr[i],mp.get(arr[i])+1);
      }
      else {
        mp.put(arr[i],1);
      }
    }
    for(Map.Entry<Integer,Integer>j : mp.entrySet()){
      s=s+1*nCr(j.getValue(),k);
    }
    return s ;
  }
  static public void main(String[] arg){
    int arr[]={
      1,1,1,1,2,2,2 };
      int k=2 ;
      int n=arr.length ;
      System.out.println(number_of_subsequences(arr,k,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fact( n : int) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : int ; i := 2 ; while i <= n do (     res := res * i ;  ;     i := i + 1 ) ; 
     return res );
  static   operation nCr( n : int, r : int) : long
  pre: true
  post: true
  activity: (     return fact(n) / (1 * fact(r) * fact(n - r)) );
  static   operation number_of_subsequences( arr : Sequence(int), k : int, n : int) : long
  pre: true
  post: true
  activity: (     var s : long ; s := 0 ;
     var mp : Map(int,int) ; mp := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (mp->keys()->includes(arr[i+1])) then (     mp := mp->union(Map{arr[i+1] |-> mp->at(arr[i+1]) + 1}) ) else (     mp := mp->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    for (j : mp->asSet()) do ( (     s := s + 1 * nCr(j.getValue(), k) )  ) ; 
    return s 
 );
  static    operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,1,1,2,2,2} ;
     var k : int ; k := 2 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(number_of_subsequences(arr, k, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int q=sc.nextInt();
      long flags=0 ;
      for(int k=0 ; k<q ; k++){
        switch(sc.nextInt()){
          case 0 : {
            int i=sc.nextInt();
            System.out.println(flags>>i & 1);
            break ;
          }
          case 1 : {
            int i=sc.nextInt();
            if((flags>>i & 1)==0)flags+=1L<<i ;
            break ;
          }
          case 2 : {
            int i=sc.nextInt();
            if((flags>>i & 1)==1)flags-=1L<<i ;
            break ;
          }
          case 3 : {
            int i=sc.nextInt();
            if((flags>>i & 1)==1)flags-=1L<<i ;
            else flags+=1L<<i ;
            break ;
          }
          case 4 : System.out.println(flags==-1 ? 1 : 0);
          break ;
          case 5 : System.out.println(flags!=0 ? 1 : 0);
          break ;
          case 6 : System.out.println(flags==0 ? 1 : 0);
          break ;
          case 7 : {
            int cnt=0 ;
            for(int j=0 ; j<64 ; j++){
              if((flags>>j & 1)>0)cnt++;
            }
            System.out.println(cnt);
            break ;
          }
          case 8 : System.out.println(Long.toUnsignedString(flags));
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var q : int ; q := sc.getCurrent()->toInteger() ;
     var flags : long ; flags := 0 ;
         var k : int ; k := 0 ; while k < q do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (sc.getCurrent()->toInteger()) ; 
       if _switchval = 0 then
 (     var i : int ; i := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(MathLib.bitwiseAnd((flags/(2->pow(i)))->oclAsType(long),1)) ; 
     break ) 
   else skip ;
       if _switchval = 1 then
 (     var i : int ; i := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseAnd((flags/(2->pow(i)))->oclAsType(long),1)) = 0) then     flags := flags+((1L*(2->pow(i)))->oclAsType(long)) ; else skip ; 
     break ) 
   else skip ;
       if _switchval = 2 then
 (     var i : int ; i := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseAnd((flags/(2->pow(i)))->oclAsType(long),1)) = 1) then     flags := flags-((1L*(2->pow(i)))->oclAsType(long)) ; else skip ; 
     break ) 
   else skip ;
       if _switchval = 3 then
 (     var i : int ; i := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseAnd((flags/(2->pow(i)))->oclAsType(long),1)) = 1) then     flags := flags-((1L*(2->pow(i)))->oclAsType(long)) else     flags := flags+((1L*(2->pow(i)))->oclAsType(long)) ; ;  
     break ) 
   else skip ;
       if _switchval = 4 then
     OclFile["System.out"].println(if flags = -1 then 1 else 0 endif) ; 
    break 
   else skip ;
       if _switchval = 5 then
     OclFile["System.out"].println(if flags /= 0 then 1 else 0 endif) ; 
    break 
   else skip ;
       if _switchval = 6 then
     OclFile["System.out"].println(if flags = 0 then 1 else 0 endif) ; 
    break 
   else skip ;
       if _switchval = 7 then
 (     var cnt : int ; cnt := 0 ;
         var j : int ; j := 0 ; while j < 64 do ( (     if ((MathLib.bitwiseAnd((flags/(2->pow(j)))->oclAsType(long),1)) > 0) then     cnt := cnt + 1 ; else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(cnt) ; 
     break ) 
   else skip ;
       if _switchval = 8 then
     OclFile["System.out"].println(toUnsignedString(flags)) ; 
    break 
   else skip ;
 )
 )  ;     k := k + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    ArrayList<Integer>list=new ArrayList<Integer>();
    int in=0 ;
    int ans=0 ;
    for(int i=0 ; i<N ; i++){
      in=scan.nextInt();
      list.add(in);
      ans+=in ;
    }
    int M=scan.nextInt();
    ArrayList<Integer>ans_box=new ArrayList<Integer>();
    for(int i=0 ; i<M ; i++){
      in=scan.nextInt();
      ans_box.add(ans+(scan.nextInt()-list.get(in-1)));
    }
    for(int i=0 ; i<M ; i++){
      System.out.println(ans_box.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
    var in : int ; in := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     in := scan.getCurrent()->toInteger() ; 
     list := list->including(in) ; 
     ans := ans+(in) )  ;     i := i + 1 ) ; 
    var M : int ; M := scan.getCurrent()->toInteger() ;
    var ans_box : Sequence(int) ; ans_box := Sequence{} ;
        var i : int ; i := 0 ; while i < M do ( (     in := scan.getCurrent()->toInteger() ; 
     ans_box := ans_box->including(ans + (scan.getCurrent()->toInteger() - list->at(in - 1+1))) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     OclFile["System.out"].println(ans_box->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    final double x1=sc.nextDouble();
    final double y1=sc.nextDouble();
    final double x2=sc.nextDouble();
    final double y2=sc.nextDouble();
    System.out.printf("%.7f\n",Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : double ; x1 := sc.getCurrent()->toReal() ;
    var y1 : double ; y1 := sc.getCurrent()->toReal() ;
    var x2 : double ; x2 := sc.getCurrent()->toReal() ;
    var y2 : double ; y2 := sc.getCurrent()->toReal() ;
    OclFile["System.out"].printf("%.7f\n", ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))->sqrt()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    double[] lengthIndex=new double[4];
    for(int i=0 ; i<lengthIndex.length ; i++){
      lengthIndex[i]=sc.nextDouble();
    }
    Point pt1=new Point();
    pt1.setXPoint(lengthIndex[0]);
    pt1.setYPoint(lengthIndex[1]);
    double px1=pt1.getXPoint();
    double py1=pt1.getYPoint();
    Point pt2=new Point();
    pt2.setXPoint(lengthIndex[2]);
    pt2.setYPoint(lengthIndex[3]);
    double px2=pt2.getXPoint();
    double py2=pt2.getYPoint();
    double ans=Math.sqrt(Math.pow((px2-px1),2)+Math.pow((py2-py1),2));
    System.out.println(ans);
  }
}
class Point {
  private double x ;
  private double y ;
  public void setXPoint(double x){
    this.x=x ;
  }
  public double getXPoint(){
    return x ;
  }
  public void setYPoint(double y){
    this.y=y ;
  }
  public double getYPoint(){
    return y ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var lengthIndex : Sequence(double) ; lengthIndex := Integer.subrange(1,4)->collect(0.0) ;
        var i : int ; i := 0 ; while i < lengthIndex->size() do ( (     lengthIndex[i+1] := sc.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
    var pt1 : Point ; pt1 := Point.newPoint() ;
    pt1.setXPoint(lengthIndex[0+1]) ; 
    pt1.setYPoint(lengthIndex[1+1]) ; 
    var px1 : double ; px1 := pt1.getXPoint() ;
    var py1 : double ; py1 := pt1.getYPoint() ;
    var pt2 : Point ; pt2 := Point.newPoint() ;
    pt2.setXPoint(lengthIndex[2+1]) ; 
    pt2.setYPoint(lengthIndex[3+1]) ; 
    var px2 : double ; px2 := pt2.getXPoint() ;
    var py2 : double ; py2 := pt2.getYPoint() ;
    var ans : double ; ans := ((px2 - px1)->pow(2) + (py2 - py1)->pow(2))->sqrt() ;
    OclFile["System.out"].println(ans) ; 
 );
}
class Point {
   attribute x : double;
   attribute y : double;
   operation setXPoint( x : double) : void
  pre: true
  post: true
  activity: (     self.x := x );
   operation getXPoint() : double
  pre: true
  post: true
  activity: (     return x );
   operation setYPoint( y : double) : void
  pre: true
  post: true
  activity: (     self.y := y );
   operation getYPoint() : double
  pre: true
  post: true
  activity: (     return y );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    double x1,y1,x2,y2 ;
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String[] coor=in.readLine().split(" ");
    x1=Double.parseDouble(coor[0]);
    y1=Double.parseDouble(coor[1]);
    x2=Double.parseDouble(coor[2]);
    y2=Double.parseDouble(coor[3]);
    System.out.println(Math.sqrt(Math.pow(Math.abs(x2-x1),2)+Math.pow(Math.abs(y2-y1),2)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x1 : double ;
    var y1 : double ;
    var x2 : double ;
    var y2 : double ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var coor : Sequence(String) ; coor := in.readLine()->split(" ") ;
    x1 := (coor[0+1])->toReal() ; 
    y1 := (coor[1+1])->toReal() ; 
    x2 := (coor[2+1])->toReal() ; 
    y2 := (coor[3+1])->toReal() ; 
    OclFile["System.out"].println((if x2 - x1 < 0 then -(x2 - x1) else x2 - x1 endif->pow(2) + if y2 - y1 < 0 then -(y2 - y1) else y2 - y1 endif->pow(2))->sqrt()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    double x1,y1,x2,y2 ;
    x1=sc.nextDouble();
    y1=sc.nextDouble();
    x2=sc.nextDouble();
    y2=sc.nextDouble();
    System.out.println(Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)));
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var x1 : double ;
    var y1 : double ;
    var x2 : double ;
    var y2 : double ;
    x1 := sc.nextDouble() ; 
    y1 := sc.nextDouble() ; 
    x2 := sc.nextDouble() ; 
    y2 := sc.nextDouble() ; 
    OclFile["System.out"].println(((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))->sqrt()) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] arges){
    Scanner sc=new Scanner(System.in);
    String line=sc.nextLine();
    String[] k=line.split(" ");
    Double[] v=new Double[k.length];
    for(int i=0 ; i<v.length ; i++){
      v[i]=Double.parseDouble(k[i]);
    }
    Double a=Math.abs(v[2]-v[0]);
    Double b=Math.abs(v[3]-v[1]);
    Double val=Math.sqrt(Math.pow(a,2)+Math.pow(b,2));
    BigDecimal big=new BigDecimal(val);
    big.setScale(5,BigDecimal.ROUND_DOWN);
    System.out.println(big);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arges : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : String ; line := sc.nextLine() ;
    var k : Sequence(String) ; k := line->split(" ") ;
    var v : Sequence(double) ; v := Integer.subrange(1,k->size())->collect(null) ;
        var i : int ; i := 0 ; while i < v->size() do ( (     v[i+1] := (k[i+1])->toReal() )  ;     i := i + 1 ) ; 
    var a : double ; a := if v[2+1] - v[0+1] < 0 then -(v[2+1] - v[0+1]) else v[2+1] - v[0+1] endif ;
    var b : double ; b := if v[3+1] - v[1+1] < 0 then -(v[3+1] - v[1+1]) else v[3+1] - v[1+1] endif ;
    var val : double ; val := (a->pow(2) + b->pow(2))->sqrt() ;
    var big : double ; big := double(val) ;
    big.setScale(5, ROUND_DOWN) ; 
    OclFile["System.out"].println(big) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class BearandTwoPaths {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int k=input.nextInt();
    int a=input.nextInt();
    int b=input.nextInt();
    int c=input.nextInt();
    int d=input.nextInt();
    if(k<n+1 || n==4){
      System.out.println(-1);
      return ;
    }
    System.out.print(a+" "+c+" ");
    ArrayList<Integer>list=new ArrayList<Integer>();
    for(int i=1 ; i<=n ; i++){
      if(i!=a && i!=c && i!=d && i!=b){
        System.out.print(i+" ");
        list.add(i);
      }
    }
    System.out.println(d+" "+b);
    System.out.print(c+" "+a+" ");
    for(int i=0 ; i<list.size(); i++){
      System.out.print(list.get(i)+" ");
    }
    System.out.println(b+" "+d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class BearandTwoPaths {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var k : int ; k := input.getCurrent()->toInteger() ;
    var a : int ; a := input.getCurrent()->toInteger() ;
    var b : int ; b := input.getCurrent()->toInteger() ;
    var c : int ; c := input.getCurrent()->toInteger() ;
    var d : int ; d := input.getCurrent()->toInteger() ;
    if (k < n + 1 or n = 4) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    OclFile["System.out"].print(a + " " + c + " ") ; 
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 1 ; while i <= n do ( (     if (i /= a & i /= c & i /= d & i /= b) then (     OclFile["System.out"].print(i + " ") ; 
     list := list->including(i) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(d + " " + b) ; 
    OclFile["System.out"].print(c + " " + a + " ") ; 
        var i : int ; i := 0 ; while i < list->size() do ( (     OclFile["System.out"].print(list->at(i+1) + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(b + " " + d) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n,k ;
    n=scanner.nextInt();
    k=scanner.nextInt();
    int[] arr=new int[n];
    int[] vis=new int[n+1];
    for(int i=0 ; i<4 ; i++){
      arr[i]=scanner.nextInt();
      vis[arr[i] ]=1 ;
    }
    if(k<n+1 || n==4){
      System.out.println(-1);
      return ;
    }
    int indx=4,vrtx=1 ;
    while(indx<n){
      while(vis[vrtx]==1){
        vrtx++;
      }
      arr[indx++]=vrtx ;
      vis[vrtx]=1 ;
    }
    int[] path=new int[n];
    System.out.print(arr[0]+" "+arr[3]+" ");
    for(int i=4 ; i<n ; i++){
      System.out.print(arr[i]+" ");
    }
    System.out.println(arr[2]+" "+arr[1]);
    if(n % 2==1){
      System.out.print(arr[2]+" "+arr[1]+" ");
      for(int i=n-1 ; i>=4 ; i--){
        System.out.print(arr[i]+" ");
      }
      System.out.println(arr[0]+" "+arr[3]);
    }
    else {
      System.out.print(arr[2]+" "+arr[1]+" ");
      for(int i=4 ; i<n ; i++){
        System.out.print(arr[i]+" ");
      }
      System.out.println(arr[0]+" "+arr[3]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var k : int ;
    n := scanner.getCurrent()->toInteger() ; 
    k := scanner.getCurrent()->toInteger() ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var vis : Sequence(int) ; vis := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     arr[i+1] := scanner.getCurrent()->toInteger() ; 
     vis[arr[i+1]+1] := 1 )  ;     i := i + 1 ) ; 
    if (k < n + 1 or n = 4) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var indx : int ; indx := 4 ;
    var vrtx : int ; vrtx := 1 ;
    while (indx < n) do (     while (vis[vrtx+1] = 1) do (     vrtx := vrtx + 1 ) ; 
      arr[indx+1] := vrtx  ; indx := indx + 1 ; 
     vis[vrtx+1] := 1 ) ; 
    var path : Sequence(int) ; path := Integer.subrange(1,n)->collect(0) ;
    OclFile["System.out"].print(arr[0+1] + " " + arr[3+1] + " ") ; 
        var i : int ; i := 4 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(arr[2+1] + " " + arr[1+1]) ; 
    if (n mod 2 = 1) then (     OclFile["System.out"].print(arr[2+1] + " " + arr[1+1] + " ") ; 
         var i : int ; i := n - 1 ; while i >= 4 do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println(arr[0+1] + " " + arr[3+1]) ) else (     OclFile["System.out"].print(arr[2+1] + " " + arr[1+1] + " ") ; 
         var i : int ; i := 4 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(arr[0+1] + " " + arr[3+1]) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    int a=scan.nextInt();
    int b=scan.nextInt();
    int c=scan.nextInt();
    int d=scan.nextInt();
    printRoad(n,k,a,b,c,d);
  }
  public static void printRoad(int n,int k,int a,int b,int c,int d){
    if(n==4 || k<n+1){
      System.out.println(-1);
      return ;
    }
    StringBuilder sb=new StringBuilder();
    Set<Integer>set=new HashSet<>();
    set.add(a);
    set.add(b);
    set.add(c);
    set.add(d);
    int e=0 ;
    for(int i=1 ; i<=n ; i++){
      if(! set.contains(i)){
        e=i ;
        break ;
      }
    }
    set.add(e);
    sb.append(a).append(" ").append(c).append(" ").append(e).append(" ").append(d).append(" ");
    for(int i=1 ; i<=n ; i++){
      if(! set.contains(i)){
        sb.append(i).append(" ");
      }
    }
    sb.append(b).append("\n");
    sb.append(c).append(" ").append(a).append(" ").append(e).append(" ").append(b).append(" ");
    for(int i=n ; i>=1 ; i--){
      if(! set.contains(i)){
        sb.append(i).append(" ");
      }
    }
    sb.append(d);
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    var c : int ; c := scan.getCurrent()->toInteger() ;
    var d : int ; d := scan.getCurrent()->toInteger() ;
    execute printRoad(n, k, a, b, c, d) ; 
 );
  static   operation printRoad( n : int, k : int, a : int, b : int, c : int, d : int) : void
  pre: true
  post: true
  activity: (     if (n = 4 or k < n + 1) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
     var sb : String ; sb := StringLib.newString() ;
    var set : Set(int) ; set := Set{} ;
    set := set->including(a) ; 
    set := set->including(b) ; 
    set := set->including(c) ; 
    set := set->including(d) ; 
    var e : int ; e := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (not(set->includes(i))) then (     e := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    set := set->including(e) ; 
    sb := sb + StringLib.newString(a) + StringLib.newString(" ") + StringLib.newString(c) + StringLib.newString(" ") + StringLib.newString(e) + StringLib.newString(" ") + StringLib.newString(d) + StringLib.newString(" ") ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (not(set->includes(i))) then (     sb := sb + StringLib.newString(i) + StringLib.newString(" ") ) else skip )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(b) + StringLib.newString("\n") ; 
    sb := sb + StringLib.newString(c) + StringLib.newString(" ") + StringLib.newString(a) + StringLib.newString(" ") + StringLib.newString(e) + StringLib.newString(" ") + StringLib.newString(b) + StringLib.newString(" ") ; 
        var i : int ; i := n ; while i >= 1 do ( (     if (not(set->includes(i))) then (     sb := sb + StringLib.newString(i) + StringLib.newString(" ") ) else skip )  ;     i := i - 1 ) ; 
    sb := sb + StringLib.newString(d) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] arg){
    while(true){
      int N=sc.nextInt();
      if(N==0)break ;
      int K=sc.nextInt();
      int M=sc.nextInt();
      int[] next=new int[N];
      int[] prev=new int[N];
      for(int i=0 ; i<N ; ++i){
        next[i]=(i+1)% N ;
        prev[i]=(i+N-1)% N ;
      }
      int pos=M-1 ;
      next[prev[pos] ]=next[pos];
      prev[next[pos] ]=prev[pos];
      for(int i=0 ; i<N-2 ; ++i){
        for(int j=0 ; j<K ; ++j){
          pos=next[pos];
        }
        next[prev[pos] ]=next[pos];
        prev[next[pos] ]=prev[pos];
      }
      System.out.println(next[pos]+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then     break else skip ; 
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var next : Sequence(int) ; next := Integer.subrange(1,N)->collect(0) ;
    var prev : Sequence(int) ; prev := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     next[i+1] := (i + 1) mod N ; 
     prev[i+1] := (i + N - 1) mod N )  ;     i := i + 1 ) ; 
    var pos : int ; pos := M - 1 ;
    next[prev[pos+1]+1] := next[pos+1] ; 
    prev[next[pos+1]+1] := prev[pos+1] ; 
        var i : int ; i := 0 ; while i < N - 2 do ( (         var j : int ; j := 0 ; while j < K do ( (     pos := next[pos+1] )  ;     j := j + 1 ) ; 
     next[prev[pos+1]+1] := next[pos+1] ; 
     prev[next[pos+1]+1] := prev[pos+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(next[pos+1] + 1) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int bit(int n){
    int count=0 ;
    while(n>0){
      count++;
      n=n &(n-1);
    }
    return count ;
  }
  static int maxSumOfBits(int arr[],int n){
    for(int i=0 ; i<n ; i++){
      arr[i]=bit(arr[i]);
    }
    int incl=arr[0];
    int excl=0 ;
    int excl_new ;
    for(int i=1 ; i<n ; i++){
      excl_new=(incl>excl)? incl : excl ;
      incl=excl+arr[i];
      excl=excl_new ;
    }
    return((incl>excl)? incl : excl);
  }
  public static void main(String args[]){
    int arr[]={
      1,2,4,5,6,7,20,25 };
      int n=arr.length ;
      System.out.print(maxSumOfBits(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation bit( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     count := count + 1 ; 
     n := n & (n - 1) ) ; 
     return count );
  static   operation maxSumOfBits( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := bit(arr[i+1]) )  ;     i := i + 1 ) ; 
     var incl : int ; incl := arr[0+1] ;
    var excl : int ; excl := 0 ;
    var excl_new : int ;
        var i : int ; i := 1 ; while i < n do ( (     excl_new := if (incl > excl) then incl else excl endif ; 
     incl := excl + arr[i+1] ; 
     excl := excl_new )  ;     i := i + 1 ) ; 
    return (if (incl > excl) then incl else excl endif) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,4,5,6,7,20,25} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(maxSumOfBits(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  static int[] dp ;
  static int f(int n,int k){
    dp[1]=0 ;
    for(int i=2 ; i<dp.length ; i++){
      dp[i]=(dp[i-1]+k)% i ;
    }
    return dp[n-1];
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    if(true){
      while(true){
        int n=sc.nextInt();
        int k=sc.nextInt();
        int m=sc.nextInt()-1 ;
        if(n+k+m<=0)break ;
        dp=new int[n];
        Arrays.fill(dp,-1);
        int f=f(n,k);
        System.out.println(((f+m+1+n)% n+1));
      }
      return ;
    }
    while(true){
      int n=sc.nextInt();
      int k=sc.nextInt();
      int m=sc.nextInt()-1 ;
      if(n+k+m<=0)break ;
      List<Integer>list=new LinkedList<Integer>();
      for(int i=0 ; i<n ; i++){
        list.add(i);
      }
      int cur=m ;
      list.remove(cur);
      cur--;
      for(int j=0 ; j<n-2 ; j++){
        cur=(list.size()+cur+k % list.size())% list.size();
        list.remove(cur);
        cur--;
      }
      System.out.println(list.get(0)+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dp : Sequence(int);
  static   operation f( n : int, k : int) : int
  pre: true
  post: true
  activity: (     dp[1+1] := 0 ; 
         var i : int ; i := 2 ; while i < dp->size() do ( (     dp[i+1] := (dp[i - 1+1] + k) mod i )  ;     i := i + 1 ) ; 
     return dp[n - 1+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     if (true) then (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() - 1 ;
    if (n + k + m <= 0) then     break else skip ; 
    dp := Integer.subrange(1,n)->collect(0) ; 
    dp := dp->collect(-1) ; 
    var f : int ; f := f(n, k) ;
    OclFile["System.out"].println(((f + m + 1 + n) mod n + 1)) ; 
 ) ; 
     return ) else skip ; 
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() - 1 ;
    if (n + k + m <= 0) then     break else skip ; 
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(i) )  ;     i := i + 1 ) ; 
    var cur : int ; cur := m ;
    list := list->excludingAt(cur+1) ; 
    cur := cur - 1 ; 
        var j : int ; j := 0 ; while j < n - 2 do ( (     cur := (list->size() + cur + k mod list->size()) mod list->size() ; 
     list := list->excludingAt(cur+1) ; 
     cur := cur - 1 )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(list->at(0+1) + 1) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static boolean isNumber(String s){
    for(int i=0 ; i<s.length(); i++)if(Character.isDigit(s.charAt(i))==false)return false ;
    return true ;
  }
  static public void main(String[] args){
    String str="6790" ;
    if(isNumber(str))System.out.println("Integer");
    else System.out.println("String");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isNumber( s : String) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() do (     if ((s->at(i+1) + "")->isMatch("[0-9]") = false) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "6790" ;
     if (isNumber(str)) then     OclFile["System.out"].println("Integer") ; else     OclFile["System.out"].println("String") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    int[] a=new int[10000];
    int[] b=new int[10000];
    for(; ; ){
      int n=sc.nextInt();
      int k=sc.nextInt();
      int m=sc.nextInt()-1 ;
      if(n==0){
        break ;
      }
      Arrays.fill(a,-1);
      for(int i=0 ; i<n ; i++){
        a[i]=i+1 ;
      }
      int p=m ;
      for(int j=n-1 ; j>0 ; j--){
        System.arraycopy(a,0,b,0,a.length);
        System.arraycopy(b,p+1,a,p,n-(p+1));
        p=(p+k-1)% j ;
      }
      println(""+a[0]);
    }
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,10000)->collect(0) ;
     var b : Sequence(int) ; b := Integer.subrange(1,10000)->collect(0) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() - 1 ;
    if (n = 0) then (     break ) else skip ; 
    a := a->collect(-1) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := i + 1 )  ;     i := i + 1 ) ; 
    var p : int ; p := m ;
        var j : int ; j := n - 1 ; while j > 0 do ( (     for _x : Integer.subrange(1,a->size()) do b[0 + _x] := a[0 + _x] ; 
     for _x : Integer.subrange(1,n - (p + 1)) do a[p + _x] := b[p + 1 + _x] ; 
     p := (p + k - 1) mod j )  ;     j := j - 1 ) ; 
    execute println("" + a[0+1]) ; 
 )  ) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
class Main {
  public static Scanner sc=new Scanner(in);
  public static Random rand=new Random();
  public int josephus(int n,int k,int s){
    long x=k*s ;
    while(x>n)x=((x-n)*k-1)/(k-1);
    return(int)x ;
  }
  public void run(){
    while(true){
      int n=sc.nextInt(),k=sc.nextInt(),m=sc.nextInt();
      if(n==0)return ;
      int j=josephus(n,k,n)-k+m+n*k ;
      while(j<=0)j+=n ;
      while(j>n)j-=n ;
      ln(j);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  public int[] nextIntArray(int n){
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=sc.nextInt();
    }
    return res ;
  }
  public static void pr(Object o){
    out.print(o);
  }
  public static void ln(Object o){
    out.println(o);
  }
  public static void ln(){
    out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(in);
  static   attribute rand : OclRandom := OclRandom.newOclRandom();
   operation josephus( n : int, k : int, s : int) : int
  pre: true
  post: true
  activity: (     var x : long ; x := k * s ;
     while (x > n) do     x := ((x - n) * k - 1) / (k - 1) ; ; 
     return x->oclAsType(int) );
   operation run() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var j : int ; j := josephus(n, k, n) - k + m + n * k ;
    while (j <= 0) do     j := j+(n) ; ; 
    while (j > n) do     j := j-(n) ; ; 
    execute ln(j) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return res );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     out.println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    try {
      BufferedReader kb=new BufferedReader(new InputStreamReader(System.in));
      int n=Integer.parseInt(kb.readLine());
      String[] str=kb.readLine().split(" ");
      int[] S=new int[n];
      for(int i=0 ; i<n ; i++){
        S[i]=Integer.parseInt(str[i]);
      }
      int q=Integer.parseInt(kb.readLine());
      str=kb.readLine().split(" ");
      int[] T=new int[q];
      for(int i=0 ; i<q ; i++){
        T[i]=Integer.parseInt(str[i]);
      }
      int cnt=0 ;
      for(int i=0 ; i<q ; i++){
        for(int j=0 ; j<n ; j++){
          if(T[i]==S[j]){
            cnt++;
            break ;
          }
        }
      }
      System.out.println(cnt);
    }
    catch(IOException e){
      System.err.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var kb : OclFile ; kb := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (kb.readLine())->toInteger() ;
    var str : Sequence(String) ; str := kb.readLine()->split(" ") ;
    var S : Sequence(int) ; S := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     S[i+1] := (str[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var q : int ; q := (kb.readLine())->toInteger() ;
    str := kb.readLine()->split(" ") ; 
    var T : Sequence(int) ; T := Integer.subrange(1,q)->collect(0) ;
        var i : int ; i := 0 ; while i < q do ( (     T[i+1] := (str[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < q do ( (         var j : int ; j := 0 ; while j < n do ( (     if (T[i+1] = S[j+1]) then (     cnt := cnt + 1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 )   catch (e : IOException) do (     OclFile["System.err"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.io.IOException ;
import java.lang.management.ManagementFactory ;
import java.lang.management.ThreadMXBean ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    Slist s=new Slist(n);
    for(int i=0 ; i<n ; i++)s.add(scan.nextInt());
    int q=scan.nextInt();
    int cnt=0 ;
    for(int i=0 ; i<q ; i++)if(s.isExist(scan.nextInt()))cnt++;
    System.out.println(cnt);
    scan.close();
    System.exit(0);
  }
}
class Slist {
  List<Integer>list=new ArrayList<Integer>();
  boolean sorted=false ;
  public Slist(int n){
  }
  public boolean isExist(int e){
    if(! sorted){
      Collections.sort(list,null);
      sorted=true ;
    }
    return this.bsearch(e,0,list.size()-1);
  }
  private boolean bsearch(int e,int min,int max){
    if(min>max)return false ;
    int mid=(max+min)/2 ;
    if(list.get(mid)>e)return bsearch(e,min,mid-1);
    else if(list.get(mid)==e)return true ;
    else return bsearch(e,mid+1,max);
  }
  public void add(int e){
    list.add(e);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var s : Slist ; s := Slist.newSlist(n) ;
        var i : int ; i := 0 ; while i < n do (     s->excludes(scan.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    var q : int ; q := scan.getCurrent()->toInteger() ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < q do (     if (s.isExist(scan.getCurrent()->toInteger())) then     cnt := cnt + 1 ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
    skip ; 
OclProcess.exit(0) ; 
 );
}
class Slist {
   attribute list : Sequence(int) := Sequence{};
   attribute sorted : boolean := false;
   static operation newSlist( n : int) : Slist
  pre: true
  post: true
  activity:
  ( var self : Slist ;
    self := createSlist();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: skip;
   operation isExist( e : int) : boolean
  pre: true
  post: true
  activity: (     if (not(sorted)) then (     list, null := list, null->sort() ; 
     sorted := true ) else skip ; 
     return self.bsearch(e, 0, list->size() - 1) );
   operation bsearch( e : int, min : int, max : int) : boolean
  pre: true
  post: true
  activity: (     if (min > max) then     return false else skip ; 
     var mid : int ; mid := (max + min) / 2 ;
     if (list->at(mid+1) > e) then     return bsearch(e, min, mid - 1) else     if (list->at(mid+1) = e) then     return true else     return bsearch(e, mid + 1, max) ;  );
   operation add( e : int) : void
  pre: true
  post: true
  activity: (     list := list->including(e) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static boolean search(int[] A,int n,int key){
    A[n]=key ;
    int i=0 ;
    while(A[i]!=key)i++;
    return i!=n ;
  }
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int[] arrayS=new int[10001];
    int[] arrayT=new int[501];
    int count=0 ;
    int sNum=scan.nextInt();
    for(int i=0 ; i<sNum ; i++)arrayS[i]=scan.nextInt();
    int tNum=scan.nextInt();
    for(int j=0 ; j<tNum ; j++)arrayT[j]=scan.nextInt();
    for(int j=0 ; j<tNum ; j++)if(search(arrayS,sNum,arrayT[j]))count++;
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation search( A : Sequence(int), n : int, key : int) : boolean
  pre: true
  post: true
  activity: (     A[n+1] := key ; 
     var i : int ; i := 0 ;
     while (A[i+1] /= key) do     i := i + 1 ; ; 
     return i /= n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arrayS : Sequence(int) ; arrayS := Integer.subrange(1,10001)->collect(0) ;
    var arrayT : Sequence(int) ; arrayT := Integer.subrange(1,501)->collect(0) ;
    var count : int ; count := 0 ;
    var sNum : int ; sNum := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < sNum do (     arrayS[i+1] := scan.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var tNum : int ; tNum := scan.getCurrent()->toInteger() ;
        var j : int ; j := 0 ; while j < tNum do (     arrayT[j+1] := scan.getCurrent()->toInteger() ;  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < tNum do (     if (search(arrayS, sNum, arrayT[j+1])) then     count := count + 1 ; else skip ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.List ;
import java.util.stream.Collectors ;
public class Main {
  private static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  public static void main(String[] args)throws Exception {
    int sn=Integer.parseInt(br.readLine());
    List<Integer>slist=Arrays.stream(br.readLine().split(" ")).map(Integer :: parseInt).collect(Collectors.toList());
    int qn=Integer.parseInt(br.readLine());
    List<Integer>qlist=Arrays.stream(br.readLine().split(" ")).map(Integer :: parseInt).collect(Collectors.toList());
    int count=0 ;
    for(int q : qlist){
      for(int s : slist){
        if(q==s){
          count++;
          break ;
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sn : int ; sn := (br.readLine())->toInteger() ;
     var slist : Sequence(int) ; slist := stream(br.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) ).collect(Collectors.toList()) ;
    var qn : int ; qn := (br.readLine())->toInteger() ;
    var qlist : Sequence(int) ; qlist := stream(br.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) ).collect(Collectors.toList()) ;
    var count : int ; count := 0 ;
    for (q : qlist) do ( (     for (s : slist) do ( (     if (q = s) then (     count := count + 1 ; 
     break ) else skip )  ) )  ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      int n=Integer.parseInt(br.readLine());
      int[] seqS=new int[n];
      String[] line=br.readLine().split(" ");
      for(int i=0 ; i<n ; i++)seqS[i]=Integer.parseInt(line[i]);
      int q=Integer.parseInt(br.readLine());
      int[] seqT=new int[q];
      line=br.readLine().split(" ");
      for(int i=0 ; i<q ; i++)seqT[i]=Integer.parseInt(line[i]);
      int cnt=0 ;
      for(int ref : seqT){
        if(linearSeach(seqS,ref))cnt++;
      }
      System.out.println(cnt);
    }
  }
  static boolean linearSeach(int[] tar,int ref){
    for(int i : tar){
      if(i==ref)return true ;
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var n : int ; n := (br.readLine())->toInteger() ;
     var seqS : Sequence(int) ; seqS := Integer.subrange(1,n)->collect(0) ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < n do (     seqS[i+1] := (line[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var q : int ; q := (br.readLine())->toInteger() ;
    var seqT : Sequence(int) ; seqT := Integer.subrange(1,q)->collect(0) ;
    line := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < q do (     seqT[i+1] := (line[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    for (ref : seqT) do ( (     if (linearSeach(seqS, ref)) then     cnt := cnt + 1 ; else skip )  ) ; 
    OclFile["System.out"].println(cnt) ; 
 ))  );
  static   operation linearSeach( tar : Sequence(int), ref : int) : boolean
  pre: true
  post: true
  activity: (     for (i : tar) do ( (     if (i = ref) then     return true else skip )  ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication70 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    int counter=0 ;
    int fine=0 ;
    ArrayList<String>arr=new ArrayList<>();
    for(int i=0 ; i<num ; i++){
      String s=sc.next();
      arr.add(s);
    }
    for(int i=0 ; i<num ; i++){
      for(int k=0 ; k<num ; k++){
        if(arr.get(k).charAt(i)=='C'){
          counter++;
        }
      }
      fine+=(counter*(counter-1))/2 ;
      counter=0 ;
    }
    for(int i=0 ; i<num ; i++){
      for(int k=0 ; k<num ; k++){
        if(arr.get(i).charAt(k)=='C'){
          counter++;
        }
      }
      fine+=(counter*(counter-1))/2 ;
      counter=0 ;
    }
    System.out.println(fine);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication70 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
    var counter : int ; counter := 0 ;
    var fine : int ; fine := 0 ;
    var arr : Sequence(String) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < num do ( (     var s : String ; s := sc.getCurrent() ;
     arr := arr->including(s) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < num do ( (         var k : int ; k := 0 ; while k < num do ( (     if (arr->at(k+1)->at(i+1) = 'C') then (     counter := counter + 1 ) else skip )  ;     k := k + 1 ) ; 
     fine := fine+((counter * (counter - 1)) / 2) ; 
     counter := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < num do ( (         var k : int ; k := 0 ; while k < num do ( (     if (arr->at(i+1)->at(k+1) = 'C') then (     counter := counter + 1 ) else skip )  ;     k := k + 1 ) ; 
     fine := fine+((counter * (counter - 1)) / 2) ; 
     counter := 0 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(fine) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int pairAndSum(int arr[],int n){
    int ans=0 ;
    for(int i=0 ; i<32 ; i++){
      int k=0 ;
      for(int j=0 ; j<n ; j++){
        if((arr[j] &(1<<i))!=0)k++;
      }
      ans+=(1<<i)*(k*(k-1)/2);
    }
    return ans ;
  }
  public static void main(String args[]){
    int arr[]={
      5,10,15 };
      int n=arr.length ;
      System.out.println(pairAndSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pairAndSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < 32 do ( (     var k : int ; k := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if ((arr[j+1] & ((1*(2->pow(i)))->oclAsType(long))) /= 0) then     k := k + 1 ; else skip )  ;     j := j + 1 ) ; 
     ans := ans+(((1*(2->pow(i)))->oclAsType(long)) * (k * (k - 1) / 2)) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,10,15} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(pairAndSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countPairs(int arr[],int n){
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        if(arr[i]!=arr[j])cnt++;
      }
    }
    return cnt ;
  }
  public static void main(String[] args){
    int arr[]={
      1,1,2 };
      int n=arr.length ;
      System.out.println(countPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (arr[i+1] /= arr[j+1]) then     cnt := cnt + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countPairs(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int power(int x,int y,int p){
    int res=1 ;
    x=x % p ;
    while(y>0){
      if(y % 2==1){
        res=(res*x)% p ;
      }
      y=y>>1 ;
      x=(x*x)% p ;
    }
    return res ;
  }
  public static void main(String[] args){
    int L=2 ;
    int P=(int)Math.pow(10,9);
    int ans=power(325,L,P);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation power( x : int, y : int, p : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     if (y mod 2 = 1) then (     res := (res * x) mod p ) else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 2 ;
     var P : int ; P := 10->pow(9)->oclAsType(int) ;
     var ans : int ; ans := power(325, L, P) ;
     OclFile["System.out"].println(ans) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int pairORSum(int arr[],int n){
    int ans=0 ;
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++)ans+=arr[i] | arr[j];
    return ans ;
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3,4 };
      int n=arr.length ;
      System.out.println(pairORSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pairORSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do (     ans := ans+(arr[i+1] or arr[j+1]) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(pairORSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.*;
public class GFG {
  static int countPairs(int arr[],int n){
    int ans=0 ;
    for(int i=0 ; i<n ; i++)for(int j=i-1 ; j>=0 ; j--)if(arr[i]*arr[j]>arr[i]+arr[j])ans++;
    return ans ;
  }
  public static void main(String args[]){
    int arr[]={
      3,4,5 };
      int n=arr.length ;
      System.out.println(countPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i - 1 ; while j >= 0 do (     if (arr[i+1] * arr[j+1] > arr[i+1] + arr[j+1]) then     ans := ans + 1 ; else skip ;  ;     j := j - 1 ) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,4,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countPairs(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int pairAndSum(int arr[],int n){
    int ans=0 ;
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++)ans+=arr[i] & arr[j];
    return ans ;
  }
  public static void main(String args[]){
    int arr[]={
      5,10,15 };
      int n=arr.length ;
      System.out.println(pairAndSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pairAndSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do (     ans := ans+(arr[i+1] & arr[j+1]) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,10,15} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(pairAndSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countPairs(int arr[],int n){
    int cnt=0 ;
    for(int i=0 ; i<n-1 ; i++)for(int j=i+1 ; j<n ; j++)if((arr[i] | arr[j])<=Math.max(arr[i],arr[j]))cnt++;
    return cnt ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3 };
      int n=arr.length ;
      System.out.println(countPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < n - 1 do (         var j : int ; j := i + 1 ; while j < n do (     if ((arr[i+1] or arr[j+1]) <= Set{arr[i+1], arr[j+1]}->max()) then     cnt := cnt + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countPairs(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countPairs(int arr[],int n){
    int ans=0 ;
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++)if(arr[i]==arr[j])ans++;
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      1,1,2 };
      int n=arr.length ;
      System.out.println(countPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do (     if (arr[i+1] = arr[j+1]) then     ans := ans + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countPairs(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int CountPairs(int arr[],int n){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        if(arr[i]+arr[j]>0)count+=1 ;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int[] arr={
-7,-1,3,2 };
      int n=arr.length ;
      System.out.println(CountPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation CountPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (arr[i+1] + arr[j+1] > 0) then     count := count+(1) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-7,-1,3,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(CountPairs(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int pairORSum(int arr[],int n){
    int ans=0 ;
    for(int i=0 ; i<32 ; i++){
      int k1=0 ;
      int k0=0 ;
      for(int j=0 ; j<n ; j++){
        if((arr[j] &(1<<i))!=0)k1++;
        else k0++;
      }
      ans=ans+(1<<i)*(k1*(k1-1)/2)+(1<<i)*(k1*k0);
    }
    return ans ;
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3,4 };
      int n=arr.length ;
      System.out.println(pairORSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pairORSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < 32 do ( (     var k1 : int ; k1 := 0 ;
     var k0 : int ; k0 := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if ((arr[j+1] & ((1*(2->pow(i)))->oclAsType(long))) /= 0) then     k1 := k1 + 1 ; else     k0 := k0 + 1 ; )  ;     j := j + 1 ) ; 
     ans := ans + ((1*(2->pow(i)))->oclAsType(long)) * (k1 * (k1 - 1) / 2) + ((1*(2->pow(i)))->oclAsType(long)) * (k1 * k0) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(pairORSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=Integer.parseInt(s.nextLine());
    int t=n ;
    char[][] chars=new char[n][n];
    int z=0 ;
    while(t-->0){
      String str=s.nextLine();
      for(int i=0 ; i<n ; i++){
        chars[z][i]=str.charAt(i);
      }
      z++;
    }
    int c=0 ;
    for(int i=0 ; i<n ; i++){
      int a=0 ;
      for(int j=0 ; j<n ; j++){
        if(chars[i][j]=='C')a++;
      }
      c+=(a*(a-1))/2 ;
    }
    for(int i=0 ; i<n ; i++){
      int a=0 ;
      for(int j=0 ; j<n ; j++){
        if(chars[j][i]=='C')a++;
      }
      c+=(a*(a-1))/2 ;
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (s.nextLine())->toInteger() ;
    var t : int ; t := n ;
    var chars : Sequence(Sequence(String)) ; chars := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var z : int ; z := 0 ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var str : String ; str := s.nextLine() ;
         var i : int ; i := 0 ; while i < n do ( (     chars[z+1][i+1] := str->at(i+1) )  ;     i := i + 1 ) ; 
     z := z + 1 ) ;  ) ;  
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (chars[i+1][j+1] = 'C') then     a := a + 1 ; else skip )  ;     j := j + 1 ) ; 
     c := c+((a * (a - 1)) / 2) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (chars[j+1][i+1] = 'C') then     a := a + 1 ; else skip )  ;     j := j + 1 ) ; 
     c := c+((a * (a - 1)) / 2) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long countPairs(int arr[],int n){
    long count=0 ;
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        if(arr[i]*arr[j]==arr[i]+arr[j])count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      2,0,3,2,0 };
      int n=arr.length ;
      System.out.println(countPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countPairs( arr : Sequence(int), n : int) : long
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
         var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (arr[i+1] * arr[j+1] = arr[i+1] + arr[j+1]) then     count := count + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,0,3,2,0} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countPairs(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int pairORSum(int arr[],int n){
    int ans=0 ;
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++)ans+=arr[i] ^ arr[j];
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      5,9,7,6 };
      int n=arr.length ;
      System.out.println(pairORSum(arr,arr.length));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pairORSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do (     ans := ans+(arr[i+1] xor arr[j+1]) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,9,7,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(pairORSum(arr, arr->size())) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findString(String str,int n,int k){
    if(k==0){
      System.out.println(str);
      ;
      return ;
    }
    String str2=str ;
    int p=0 ;
    for(int i=0 ; i<n ; i++){
      if(str2.charAt(i)!='a'){
        str2=str2.substring(0,i)+'a'+str2.substring(i+1);
        p++;
        if(p==k)break ;
      }
    }
    if(p<k){
      for(int i=n-1 ; i>=0 ; i--)if(str.charAt(i)=='a'){
        str2=str2.substring(0,i)+'b'+str2.substring(i+1);
        p++;
        if(p==k)break ;
      }
    }
    System.out.println(str2);
  }
  public static void main(String[] args){
    String str="pqrs" ;
    int n=str.length();
    int k=2 ;
    findString(str,n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findString( str : String, n : int, k : int) : void
  pre: true
  post: true
  activity: (     if (k = 0) then (     OclFile["System.out"].println(str) ; 
     return ) else skip ; 
     var str2 : String ; str2 := str ;
    var p : int ; p := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (str2->at(i+1) /= 'a') then (     str2 := str2.subrange(0+1,i) + 'a' + str2.subrange(i + 1+1,i + 1) ; 
     p := p + 1 ; 
     if (p = k) then     break else skip ) else skip )  ;     i := i + 1 ) ; 
    if (p < k) then (         var i : int ; i := n - 1 ; while i >= 0 do (     if (str->at(i+1) = 'a') then (     str2 := str2.subrange(0+1,i) + 'b' + str2.subrange(i + 1+1,i + 1) ; 
     p := p + 1 ; 
     if (p = k) then     break else skip ) else skip ;  ;     i := i - 1 ) ) else skip ; 
    OclFile["System.out"].println(str2) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "pqrs" ;
     var n : int ; n := str->size() ;
     var k : int ; k := 2 ;
     execute findString(str, n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] agrs){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int[] k=new int[m];
    int[] f=new int[m];
    for(int i=0 ; i<m ; i++){
      k[i]=in.nextInt();
      f[i]=in.nextInt();
    }
    int ans=-1,ff=1 ;
    for(int i=1 ; i<=100 ; i++){
      int flag=1 ;
      for(int j=0 ; j<m ; j++){
        if((k[j]+i-1)/i!=f[j]){
          flag=0 ;
          break ;
        }
      }
      if(flag==1 && ans!=(n+i-1)/i){
        if(ans==-1)ans=(n+i-1)/i ;
        else {
          ff=0 ;
          break ;
        }
      }
    }
    if(ff==1)System.out.println(ans);
    else System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var k : Sequence(int) ; k := Integer.subrange(1,m)->collect(0) ;
    var f : Sequence(int) ; f := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     k[i+1] := in.getCurrent()->toInteger() ; 
     f[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -1 ;
    var ff : int ; ff := 1 ;
        var i : int ; i := 1 ; while i <= 100 do ( (     var flag : int ; flag := 1 ;
         var j : int ; j := 0 ; while j < m do ( (     if ((k[j+1] + i - 1) / i /= f[j+1]) then (     flag := 0 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (flag = 1 & ans /= (n + i - 1) / i) then (     if (ans = -1) then     ans := (n + i - 1) / i ; else (     ff := 0 ; 
     break ) ) else skip )  ;     i := i + 1 ) ; 
    if (ff = 1) then     OclFile["System.out"].println(ans) else     OclFile["System.out"].println(-1) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findSum(int[] arr,int n,int k){
    int ans=arr[n-k-1]-arr[0];
    for(int i=1 ; i<=k ; i++){
      ans=Math.min(arr[n-1-(k-i)]-arr[i],ans);
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,100,120,140 };
      int k=2 ;
      int n=arr.length ;
      System.out.println(findSum(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findSum( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := arr[n - k - 1+1] - arr[0+1] ;
         var i : int ; i := 1 ; while i <= k do ( (     ans := Set{arr[n - 1 - (k - i)+1] - arr[i+1], ans}->min() )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,100,120,140} ;
     var k : int ; k := 2 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findSum(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isReachable(int sx,int sy,int dx,int dy){
    if(sx>dx || sy>dy)return false ;
    if(sx==dx && sy==dy)return true ;
    return(isReachable(sx+sy,sy,dx,dy)|| isReachable(sx,sy+sx,dx,dy));
  }
  public static void main(String arg[]){
    int source_x=2,source_y=10 ;
    int dest_x=26,dest_y=12 ;
    if(isReachable(source_x,source_y,dest_x,dest_y))System.out.print("True\n");
    else System.out.print("False\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isReachable( sx : int, sy : int, dx : int, dy : int) : boolean
  pre: true
  post: true
  activity: (     if (sx > dx or sy > dy) then     return false else skip ; 
     if (sx = dx & sy = dy) then     return true else skip ; 
     return (isReachable(sx + sy, sy, dx, dy) or isReachable(sx, sy + sx, dx, dy)) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var source_x : int ; source_x := 2 ;
    var source_y : int ; source_y := 10 ;
     var dest_x : int ; dest_x := 26 ;
    var dest_y : int ; dest_y := 12 ;
     if (isReachable(source_x, source_y, dest_x, dest_y)) then     OclFile["System.out"].print("True\n") ; else     OclFile["System.out"].print("False\n") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
public class B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int numCases=sc.nextInt();
    for(int caseNum=1 ; caseNum<=numCases ; caseNum++){
      int N=sc.nextInt();
      Map<Integer,Integer>counts=new HashMap<>();
      for(int i=0 ; i<2*N-1 ; i++){
        for(int j=0 ; j<N ; j++){
          int height=sc.nextInt();
          if(counts.containsKey(height)){
            counts.put(height,counts.get(height)+1);
          }
          else {
            counts.put(height,1);
          }
        }
      }
      List<Integer>heights=new ArrayList<>();
      for(Map.Entry<Integer,Integer>entry : counts.entrySet()){
        if(entry.getValue()% 2!=0){
          heights.add(entry.getKey());
        }
      }
      Collections.sort(heights);
      System.out.print("Case #"+caseNum+":");
      for(int h : heights){
        System.out.print(" "+h);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numCases : int ; numCases := sc.getCurrent()->toInteger() ;
         var caseNum : int ; caseNum := 1 ; while caseNum <= numCases do ( (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var counts : Map(int,int) ; counts := Map{} ;
        var i : int ; i := 0 ; while i < 2 * N - 1 do ( (         var j : int ; j := 0 ; while j < N do ( (     var height : int ; height := sc.getCurrent()->toInteger() ;
     if (counts->keys()->includes(height)) then (     counts := counts->union(Map{height |-> counts->at(height) + 1}) ) else (     counts := counts->union(Map{height |-> 1}) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var heights : Sequence(int) ; heights := Sequence{} ;
    for (entry : counts->asSet()) do ( (     if (entry.getValue() mod 2 /= 0) then (     heights := heights->including(entry.getKey()) ) else skip )  ) ; 
    heights := heights->sort() ; 
    OclFile["System.out"].print("Case #" + caseNum + ":") ; 
    for (h : heights) do ( (     OclFile["System.out"].print(" " + h) )  ) ; 
    OclFile["System.out"].println() ; 
 )  ;     caseNum := caseNum + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  String solveOne(Scanner in){
    boolean odd[]=new boolean[2501];
    int n=in.nextInt();
    for(int i=0 ; i<2*n-1 ; i++){
      for(int j=0 ; j<n ; j++){
        int value=in.nextInt();
        odd[value]=! odd[value];
      }
    }
    String res="" ;
    for(int i=0 ; i<odd.length ; i++){
      if(odd[i]){
        res+=" "+i ;
      }
    }
    return res ;
  }
  void solve(Scanner in,PrintWriter out){
    int nTests=in.nextInt();
    for(int iTest=1 ; iTest<=nTests ; iTest++){
      out.printf("Case #%d:%s%n",iTest,solveOne(in));
    }
  }
  void run(){
    try(Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
){
      solve(in,out);
    }
  }
  public static void main(String args[]){
    new B().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
   operation solveOne( in : OclFile) : String
  pre: true
  post: true
  activity: (     var odd : Sequence(boolean) ; odd := Integer.subrange(1,2501)->collect(false) ;
     var n : int ; n := in.nextInt() ;
        var i : int ; i := 0 ; while i < 2 * n - 1 do ( (         var j : int ; j := 0 ; while j < n do ( (     var value : int ; value := in.nextInt() ;
     odd[value+1] := not(odd[value+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : String ; res := "" ;
        var i : int ; i := 0 ; while i < odd->size() do ( (     if (odd[i+1]) then (     res := res+(" " + i) ) else skip )  ;     i := i + 1 ) ; 
    return res 
 );
   operation solve( in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var nTests : int ; nTests := in.nextInt() ;
         var iTest : int ; iTest := 1 ; while iTest <= nTests do ( (     out.printf("Case #%d:%s%n", iTest, solveOne(in)) )  ;     iTest := iTest + 1 ) );
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]) ;
 (     execute solve(in, out) ))  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     B.newB().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package Round1A2016 ;
import java.util.Scanner ;
public class B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    for(int testCase=1 ; testCase<=T ; ++testCase){
      final int n=sc.nextInt();
      final int[] count=new int[2500+1];
      for(int i=0 ; i<n*(2*n-1); ++i)count[sc.nextInt()]++;
      int[] row=new int[n];
      int rowInd=0 ;
      for(int i=0 ; i<count.length ; ++i){
        if(count[i] % 2==1){
          row[rowInd++]=i ;
        }
      }
      System.out.printf("Case #%d: ",testCase);
      for(int x : row){
        System.out.print(x+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var testCase : int ; testCase := 1 ; while testCase <= T do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var count : Sequence(int) ; count := Integer.subrange(1,2500 + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n * (2 * n - 1) do (     count[sc.getCurrent()->toInteger()+1] := count[sc.getCurrent()->toInteger()+1] + 1 ;  ;     i := i + 1 ) ; 
    var row : Sequence(int) ; row := Integer.subrange(1,n)->collect(0) ;
    var rowInd : int ; rowInd := 0 ;
        var i : int ; i := 0 ; while i < count->size() do ( (     if (count[i+1] mod 2 = 1) then (      row[rowInd+1] := i  ; rowInd := rowInd + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("Case #%d: ", testCase) ; 
    for (x : row) do ( (     OclFile["System.out"].print(x + " ") )  ) ; 
    OclFile["System.out"].println() ; 
 )  ;     testCase := testCase + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.File ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class b {
  public static void main(String[] Args)throws Exception {
    FS sc=new FS(new File("B-large.in"));
    PrintWriter out=new PrintWriter(new BufferedWriter(new FileWriter(new File("b.out"))));
    int cc=0 ;
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      boolean[] con=new boolean[2501];
      for(int i=0 ; i<(n*2-1)*n ; i++){
        int k=sc.nextInt();
        con[k]=! con[k];
      }
      out.printf("Case #%d:",++cc);
      for(int i=0 ; i<2501 ; i++){
        if(con[i]){
          out.printf(" %d",i);
        }
      }
      out.println();
    }
    out.close();
  }
  public static class FS {
    BufferedReader br ;
    StringTokenizer st ;
    FS(InputStream in)throws Exception {
      br=new BufferedReader(new InputStreamReader(in));
      st=new StringTokenizer(br.readLine());
    }
    FS(File in)throws Exception {
      br=new BufferedReader(new FileReader(in));
      st=new StringTokenizer(br.readLine());
    }
    String next()throws Exception {
      if(st.hasMoreTokens())return st.nextToken();
      st=new StringTokenizer(br.readLine());
      return next();
    }
    int nextInt()throws Exception {
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class b {
  static   operation main( Args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FS ; sc := FS.newFS(OclFile("B-large.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile("b.out")))) ;
    var cc : int ; cc := 0 ;
    var t : int ; t := sc.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.nextInt() ;
     var con : Sequence(boolean) ; con := Integer.subrange(1,2501)->collect(false) ;
        var i : int ; i := 0 ; while i < (n * 2 - 1) * n do ( (     var k : int ; k := sc.nextInt() ;
     con[k+1] := not(con[k+1]) )  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < 2501 do ( (     if (con[i+1]) then (     skip ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static class FS {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFS( in : OclFile) : FS
  pre: true
  post: true
  activity:
  ( var self : FS ;
    self := createFS();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     st := OclIterator.newOclIterator_String(br.readLine()) );
   static operation newFS( in : OclFile) : FS
  pre: true
  post: true
  activity:
  ( var self : FS ;
    self := createFS();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     st := OclIterator.newOclIterator_String(br.readLine()) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (st.hasNext()) then     return st.next() else skip ; 
     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     return next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class P629A_FarRelativesBirthdayCake {
  public static void main(String[] subhani)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    long[] rows=new long[n],columns=new long[n];
    for(int i=0 ; i<n ; ++i){
      String s=br.readLine();
      int count=0 ;
      for(int j=0 ; j<n ; ++j){
        if(s.charAt(j)=='C'){
          columns[j]+=1 ;
          count++;
        }
        rows[i]=count ;
      }
    }
    solve(n,rows,columns);
  }
  public static void solve(int n,long[] rows,long[] columns){
    long sum=0 ;
    for(int i=0 ; i<n ; ++i){
      long val=(rows[i]*(rows[i]-1))/2 ;
      sum+=val ;
    }
    for(int i=0 ; i<n ; ++i){
      long val=(columns[i]*(columns[i]-1))/2 ;
      sum+=val ;
    }
    System.out.println(sum);
  }
  public static long fact(long n){
    long product=1 ;
    for(long i=2 ; i<=n ; ++i){
      product*=i ;
    }
    return product ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class P629A_FarRelativesBirthdayCake {
  static   operation main( subhani : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var rows : Sequence(long) ; rows := Integer.subrange(1,n)->collect(0) ;
    var columns : Sequence(long) ; columns := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := br.readLine() ;
     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (s->at(j+1) = 'C') then (     columns[j+1] := columns[j+1]+(1) ; 
     count := count + 1 ) else skip ; 
     rows[i+1] := count )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    execute solve(n, rows, columns) ; 
 );
  static   operation solve( n : int, rows : Sequence(long), columns : Sequence(long)) : void
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var val : long ; val := (rows[i+1] * (rows[i+1] - 1)) / 2 ;
     sum := sum+(val) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     var val : long ; val := (columns[i+1] * (columns[i+1] - 1)) / 2 ;
     sum := sum+(val) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sum) );
  static   operation fact( n : long) : long
  pre: true
  post: true
  activity: (     var product : long ; product := 1 ;
         var i : long ; i := 2 ; while i <= n do ( (     product := product*(i) )  ;     i := i + 1 ) ; 
     return product );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Rank {
  public static void main(String[] args)throws IOException {
    Scanner input=new Scanner(new File("input.txt"));
    PrintWriter out=new PrintWriter(new File("output.txt"));
    int cs=input.nextInt();
    for(int i=1 ; i<=cs ; i++){
      int[] arr=new int[2501];
      int sz=input.nextInt();
      for(int x=0 ; x<sz*(2*sz-1); x++){
        arr[input.nextInt()]++;
      }
      out.printf("Case #%d:",i);
      for(int j=0 ; j<arr.length ; j++)if(arr[j] % 2==1)out.print(" "+j);
      out.println();
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Rank {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile("input.txt")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("output.txt")) ;
    var cs : int ; cs := input.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= cs do ( (     var arr : Sequence(int) ; arr := Integer.subrange(1,2501)->collect(0) ;
     var sz : int ; sz := input.getCurrent()->toInteger() ;
        var x : int ; x := 0 ; while x < sz * (2 * sz - 1) do ( (     arr[input.getCurrent()->toInteger()+1] := arr[input.getCurrent()->toInteger()+1] + 1 )  ;     x := x + 1 ) ; 
    skip ; 
        var j : int ; j := 0 ; while j < arr->size() do (     if (arr[j+1] mod 2 = 1) then     skip ; else skip ;  ;     j := j + 1 ) ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int totalFruit(int[] tree){
    int ans=0,i=0 ;
    Counter count=new Counter();
    for(int j=0 ; j<tree.length ; ++j){
      count.add(tree[j],1);
      while(count.size()>=3){
        count.add(tree[i],-1);
        if(count.get(tree[i])==0)count.remove(tree[i]);
        i++;
      }
      ans=Math.max(ans,j-i+1);
    }
    return ans ;
  }
}
class Counter extends HashMap<Integer,Integer>{
  public int get(int k){
    return containsKey(k)? super.get(k): 0 ;
  }
  public void add(int k,int v){
    put(k,get(k)+v);
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation totalFruit( tree : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
    var i : int ; i := 0 ;
     var count : Counter ; count := Counter.newCounter() ;
         var j : int ; j := 0 ; while j < tree->size() do ( (     count->excludes(tree[j+1], 1) ; 
     while (count->size() >= 3) do (     count->excludes(tree[i+1], -1) ; 
     if (count->at(tree[i+1]+1) = 0) then     count := count->excludingFirst(tree[i+1]) ; else skip ; 
     i := i + 1 ) ; 
     ans := Set{ans, j - i + 1}->max() )  ;     j := j + 1 ) ; 
     return ans );
}
 class Counter extends Map(int,int) {
   operation get( k : int) : int
  pre: true
  post: true
  activity: (     return if containsKey(k) then super->at(k+1) else 0 endif );
   operation add( k : int, v : int) : void
  pre: true
  post: true
  activity: (     execute put(k, at(k+1) + v) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    DRemainderReminder solver=new DRemainderReminder();
    solver.solve(1,in,out);
    out.close();
  }
  static class DRemainderReminder {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      long n=in.nextInt();
      long k=in.nextInt();
      if(k==0){
        out.println(n*n);
        return ;
      }
      long answer=0 ;
      for(long b=1 ; b<=n ; b++){
        if(k>b-1)continue ;
        long intervals=n/b ;
        answer+=intervals*(b-k);
        answer+=Math.max(0,(n % b)-k+1);
      }
      out.println(answer);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : DRemainderReminder ; solver := DRemainderReminder.newDRemainderReminder() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class DRemainderReminder {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : long ; n := in.nextInt() ;
     var k : long ; k := in.nextInt() ;
    if (k = 0) then (     skip ; 
     return ) else skip ; 
    var answer : long ; answer := 0 ;
        var b : long ; b := 1 ; while b <= n do ( (     if (k > b - 1) then     continue else skip ; 
     var intervals : long ; intervals := n / b ;
     answer := answer+(intervals * (b - k)) ; 
     answer := answer+(Set{0, (n mod b) - k + 1}->max()) )  ;     b := b + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private long N ;
  private long K ;
  public void inputData(){
    Scanner sc=new Scanner(System.in);
    N=sc.nextLong();
    K=sc.nextLong();
  }
  public void printAnswer(){
    long count=0 ;
    for(long b=K+1 ; b<=N ; b++){
      long wide=b-K ;
      long pattern=N/b ;
      long remainder=N % b ;
      long ans=0 ;
      if(remainder>=K){
        ans=wide*pattern+remainder-K+1 ;
      }
      else {
        ans=wide*pattern ;
      }
      count+=ans ;
    }
    if(K==0){
      count-=N ;
    }
    System.out.println(count);
  }
  public void run(){
    inputData();
    printAnswer();
  }
  public static void main(String[] args){
(new Main()).run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute N : long;
   attribute K : long;
   operation inputData() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toLong() ; 
     K := sc.getCurrent()->toLong() );
   operation printAnswer() : void
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
         var b : long ; b := K + 1 ; while b <= N do ( (     var wide : long ; wide := b - K ;
     var pattern : long ; pattern := N / b ;
    var remainder : long ; remainder := N mod b ;
    var ans : long ; ans := 0 ;
    if (remainder >= K) then (     ans := wide * pattern + remainder - K + 1 ) else (     ans := wide * pattern ) ;  
    count := count+(ans) ; 
 )  ;     b := b + 1 ) ; 
     if (K = 0) then (     count := count-(N) ) else skip ; 
     OclFile["System.out"].println(count) );
   operation run() : void
  pre: true
  post: true
  activity: (     execute inputData() ; 
     execute printAnswer() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test21 {
  static class dui {
    int a,b ;
    dui(int aa,int bb){
      a=aa ;
      b=bb ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    dui[] arr=new dui[m];
    int max=0 ;
    if(m==0 && n!=1){
      System.out.println(-1);
      return ;
    }
    for(int i=0 ; i<m ; i++){
      arr[i]=new dui(sc.nextInt(),sc.nextInt());
      max=Math.max(max,arr[i] .a);
    }
    int ans=0 ;
    int res=0 ;
    int result=-1 ;
    for(int i=1 ; i<=100 ; i++){
      boolean b=true ;
      for(int j=0 ; j<m ; j++){
        int a=arr[j] .a/i ;
        if(arr[j] .a % i!=0)a++;
        if(a!=arr[j] .b){
          b=false ;
          break ;
        }
      }
      if(b){
        int x=n/i ;
        if(n % i!=0)x++;
        if(ans>0 && x!=result){
          System.out.println(-1);
          return ;
        }
        else {
          ans=1 ;
          res=i ;
          result=n/res ;
          if(n % res!=0)result++;
        }
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test21 {
  static class dui {
   attribute a : int;
   static operation newdui( aa : int, bb : int) : dui
  pre: true
  post: true
  activity:
  ( var self : dui ;
    self := createdui();
    self.initialise(aa, bb);
    return self );
  operation initialise( aa : int, bb : int) : void
  pre: true  post: true
  activity: (     a := aa ; 
     b := bb );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arr : Sequence(dui) ; arr := Integer.subrange(1,m)->collect(null) ;
    var max : int ; max := 0 ;
    if (m = 0 & n /= 1) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < m do ( (     arr[i+1] := dui.newdui(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) ; 
     max := Set{max, arr[i+1].a}->max() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var res : int ; res := 0 ;
    var result : int ; result := -1 ;
        var i : int ; i := 1 ; while i <= 100 do ( (     var b : boolean ; b := true ;
         var j : int ; j := 0 ; while j < m do ( (     var a : int ; a := arr[j+1].a / i ;
     if (arr[j+1].a mod i /= 0) then     a := a + 1 ; else skip ; 
     if (a /= arr[j+1].b) then (     b := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (b) then (     var x : int ; x := n / i ;
     if (n mod i /= 0) then     x := x + 1 ; else skip ; 
     if (ans > 0 & x /= result) then (     OclFile["System.out"].println(-1) ; 
     return ) else (     ans := 1 ; 
     res := i ; 
     result := n / res ; 
     if (n mod res /= 0) then     result := result + 1 ; else skip ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static long calculateNumA(long n,long k,long b){
    return(b-k)*(n/b)+Math.max(n+1-(((n/b))*b+k),0);
  }
  private static long solve(long n,long k){
    if(k==0){
      return n*n ;
    }
    long sum=0 ;
    for(long b=k+1 ; b<=n ; b++){
      long numA=calculateNumA(n,k,b);
      sum+=numA ;
    }
    return sum ;
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int k=s.nextInt();
    System.out.println(solve(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation calculateNumA( n : long, k : long, b : long) : long
  pre: true
  post: true
  activity: (     return (b - k) * (n / b) + Set{n + 1 - (((n / b)) * b + k), 0}->max() );
  static   operation solve( n : long, k : long) : long
  pre: true
  post: true
  activity: (     if (k = 0) then (     return n * n ) else skip ; 
     var sum : long ; sum := 0 ;
         var b : long ; b := k + 1 ; while b <= n do ( (     var numA : long ; numA := calculateNumA(n, k, b) ;
     sum := sum+(numA) )  ;     b := b + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
     var k : int ; k := s.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str[]=br.readLine().split(" ");
    long n=Long.parseLong(str[0]);
    long k=Long.parseLong(str[1]);
    if(k==0){
      System.out.println(n*n);
      return ;
    }
    long ans=0 ;
    for(int i=1 ; i<=n ; i++){
      ans+=(n/i)*Math.max(0,i-k);
      if(n % i!=0){
        ans+=Math.max(n % i-k+1,0);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : long ; n := (str[0+1])->toLong() ;
    var k : long ; k := (str[1+1])->toLong() ;
    if (k = 0) then (     OclFile["System.out"].println(n * n) ; 
     return ) else skip ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     ans := ans+((n / i) * Set{0, i - k}->max()) ; 
     if (n mod i /= 0) then (     ans := ans+(Set{n mod i - k + 1, 0}->max()) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public void main(Scanner sc){
    long n=sc.nextLong();
    long k=sc.nextLong();
    long sum=0 ;
    for(int b=1 ; b<=n ; b++){
      if(b<=k){
        continue ;
      }
      sum+=(b-k)*(n/b)+Math.max(n % b-Math.max(k-1,0),0);
    }
    System.out.println(sum);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    new Main().main(sc);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.nextLong() ;
     var k : long ; k := sc.nextLong() ;
    var sum : long ; sum := 0 ;
        var b : int ; b := 1 ; while b <= n do ( (     if (b <= k) then (     continue ) else skip ; 
     sum := sum+((b - k) * (n / b) + Set{n mod b - Set{k - 1, 0}->max(), 0}->max()) )  ;     b := b + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Main.newMain().main(sc) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double a=Double.parseDouble(sc.next());
    double b=Double.parseDouble(sc.next());
    double x=Double.parseDouble(sc.next());
    if(x<a*a*b/2){
      double c=(2*x)/(a*b);
      double d=b/c ;
      System.out.println(Math.toDegrees(Math.atan(d)));
    }
    else {
      double c=(2*(a*a*b-x))/(a*a);
      double d=c/a ;
      System.out.println(Math.toDegrees(Math.atan(d)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : double ; a := (sc.getCurrent())->toReal() ;
    var b : double ; b := (sc.getCurrent())->toReal() ;
    var x : double ; x := (sc.getCurrent())->toReal() ;
    if (x < a * a * b / 2) then (     var c : double ; c := (2 * x) / (a * b) ;
     var d : double ; d := b / c ;
     OclFile["System.out"].println((57.29577951308232*((d)->atan()))) ) else (     var c : double ; c := (2 * (a * a * b - x)) / (a * a) ;
     var d : double ; d := c / a ;
     OclFile["System.out"].println((57.29577951308232*((d)->atan()))) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    double a=sc.nextDouble();
    double b=sc.nextDouble();
    double x=sc.nextDouble();
    double theta ;
    final double PI=Math.PI ;
    if(x>a*a*b/2){
      theta=Math.atan(2*(a*a*b-x)/(a*a*a));
    }
    else {
      theta=Math.atan((a*b*b)/(2*x));
    }
    theta=theta*180/PI ;
    System.out.println(theta);
  }
  static class MyScanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),1<<15);
    StringTokenizer tokenizer ;
    String next(){
      try {
        while(tokenizer==null || ! tokenizer.hasMoreTokens()){
          tokenizer=new StringTokenizer(reader.readLine());
        }
      }
      catch(IOException ignored){
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    Double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var a : double ; a := sc.nextDouble() ;
    var b : double ; b := sc.nextDouble() ;
    var x : double ; x := sc.nextDouble() ;
    var theta : double ;
    var PI : double ; PI := 3.141592653589793 ;
    if (x > a * a * b / 2) then (     theta := (2 * (a * a * b - x) / (a * a * a))->atan() ) else (     theta := ((a * b * b) / (2 * x))->atan() ) ;  
    theta := theta * 180 / PI ; 
    OclFile["System.out"].println(theta) ; 
 );
  static class MyScanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (1*(2->pow(15)))->oclAsType(long));
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (ignored : IOException) do skip
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF629A {
  public static Scanner scanner ;
  public static int[] row,col ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    row=new int[n];
    col=new int[n];
    for(int i=0 ; i<n ; i++){
      char[] str=scanner.next().toCharArray();
      for(int j=0 ; j<str.length ; j++){
        if(str[j]=='C'){
          row[i]++;
          col[j]++;
        }
      }
    }
    long res=0 ;
    for(int i=0 ; i<row.length ; i++){
      if(row[i]>=2){
        res+=combination(row[i],2);
      }
      if(col[i]>=2){
        res+=combination(col[i],2);
      }
    }
    System.out.println(res);
  }
  public static long combination(int n,int r){
    long numerator=(long)n*(n-1);
    long denominator=2 ;
    return numerator/denominator ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF629A {
  static   attribute scanner : OclFile;
  static   attribute row : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    row := Integer.subrange(1,n)->collect(0) ; 
    col := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     var str : Sequence(String) ; str := scanner.getCurrent()->characters() ;
         var j : int ; j := 0 ; while j < str->size() do ( (     if (str[j+1] = 'C') then (     row[i+1] := row[i+1] + 1 ; 
     col[j+1] := col[j+1] + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < row->size() do ( (     if (row[i+1] >= 2) then (     res := res+(combination(row[i+1], 2)) ) else skip ; 
     if (col[i+1] >= 2) then (     res := res+(combination(col[i+1], 2)) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static   operation combination( n : int, r : int) : long
  pre: true
  post: true
  activity: (     var numerator : long ; numerator := n->oclAsType(long) * (n - 1) ;
     var denominator : long ; denominator := 2 ;
     return numerator / denominator );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    solve(System.in,System.out);
  }
  static void solve(InputStream is,PrintStream os){
    Scanner scan=new Scanner(is);
    double a=(double)scan.nextInt();
    double b=(double)scan.nextInt();
    double x=(double)scan.nextInt();
    double answer=0 ;
    if(x>=a*a*b/2){
      double tana=2*(a*a*b-x)/(a*a*a);
      double radian=Math.atan(tana);
      answer=Math.toDegrees(radian);
    }
    else {
      double tana=a*b*b/(2*x);
      double radian=Math.atan(tana);
      answer=Math.toDegrees(radian);
    }
    os.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation solve( is : OclFile, os : OclFile) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(is) ;
     var a : double ; a := scan.getCurrent()->toInteger()->oclAsType(double) ;
    var b : double ; b := scan.getCurrent()->toInteger()->oclAsType(double) ;
    var x : double ; x := scan.getCurrent()->toInteger()->oclAsType(double) ;
    var answer : double ; answer := 0 ;
    if (x >= a * a * b / 2) then (     var tana : double ; tana := 2 * (a * a * b - x) / (a * a * a) ;
     var radian : double ; radian := (tana)->atan() ;
     answer := (57.29577951308232*(radian)) ) else (     var tana : double ; tana := a * b * b / (2 * x) ;
     var radian : double ; radian := (tana)->atan() ;
     answer := (57.29577951308232*(radian)) ) ;  
    os.println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  @ SuppressWarnings("resource")public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int x=sc.nextInt();
    double ans=0 ;
    int max=a*a*b ;
    double high=0 ;
    if(x<=max/2){
      high=((2*(double)x)/(a*b))/b ;
      ans=90-Math.toDegrees(Math.atan(high));
    }
    else {
      x=max-x ;
      high=(a/((2*(double)x)/(a*a)));
      ans=90-Math.toDegrees(Math.atan(high));
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var ans : double ; ans := 0 ;
    var max : int ; max := a * a * b ;
    var high : double ; high := 0 ;
    if (x <= max / 2) then (     high := ((2 * x->oclAsType(double)) / (a * b)) / b ; 
     ans := 90 - (57.29577951308232*((high)->atan())) ) else (     x := max - x ; 
     high := (a / ((2 * x->oclAsType(double)) / (a * a))) ; 
     ans := 90 - (57.29577951308232*((high)->atan())) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  final static long mod=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double a=sc.nextDouble();
    double b=sc.nextDouble();
    double c=sc.nextDouble();
    double d=b-c/a/a ;
    if(2*d<=b){
      double ans=Math.atan(2*d/a)/Math.PI*180 ;
      System.out.println(ans);
    }
    else {
      double ans=90-Math.atan((c/(a*a*b/2)*a)/b)/Math.PI*180 ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : double ; a := sc.getCurrent()->toReal() ;
    var b : double ; b := sc.getCurrent()->toReal() ;
    var c : double ; c := sc.getCurrent()->toReal() ;
    var d : double ; d := b - c / a / a ;
    if (2 * d <= b) then (     var ans : double ; ans := (2 * d / a)->atan() / 3.141592653589793 * 180 ;
     OclFile["System.out"].println(ans) ) else (     var ans : double ; ans := 90 - ((c / (a * a * b / 2) * a) / b)->atan() / 3.141592653589793 * 180 ;
     OclFile["System.out"].println(ans) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findCount(String str){
    int result=0 ;
    for(int i=0 ; i<str.length(); i++){
      if(i==(str.charAt(i)-'a')|| i==(str.charAt(i)-'A')){
        result++;
      }
    }
    return result ;
  }
  public static void main(String[] args){
    String str="AbgdeF" ;
    System.out.print(findCount(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findCount( str : String) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (i = (str->at(i+1) - ('a')->char2byte()) or i = (str->at(i+1) - ('A')->char2byte())) then (     result := result + 1 ) else skip )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "AbgdeF" ;
     OclFile["System.out"].print(findCount(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int kN=1000000 ;
  static int maxPeople(int p){
    long[] sums=new long[kN];
    sums[0]=0 ;
    for(int i=1 ; i<kN ; i++)sums[i]=(long)(i*i)+sums[i-1];
    int it=lower_bound(sums,0,kN,p);
    if(it>p){
--it ;
    }
    return it ;
  }
  private static int lower_bound(long[] a,int low,int high,int element){
    while(low<high){
      int middle=low+(high-low)/2 ;
      if(element>a[middle])low=middle+1 ;
      else high=middle ;
    }
    return low ;
  }
  public static void main(String[] args){
    int p=14 ;
    System.out.println(maxPeople(p));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute kN : int := 1000000;
  static   operation maxPeople( p : int) : int
  pre: true
  post: true
  activity: (     var sums : Sequence(long) ; sums := Integer.subrange(1,kN)->collect(0) ;
     sums[0+1] := 0 ; 
        var i : int ; i := 1 ; while i < kN do (     sums[i+1] := (i * i)->oclAsType(long) + sums[i - 1+1] ;  ;     i := i + 1 ) ; 
    var it : int ; it := lower_bound(sums, 0, kN, p) ;
    if (it > p) then (     it := it - 1 ) else skip ; 
    return it 
 );
  static   operation lower_bound( a : Sequence(long), low : int, high : int, element : int) : int
  pre: true
  post: true
  activity: (     while (low < high) do (     var middle : int ; middle := low + (high - low) / 2 ;
     if (element > a[middle+1]) then     low := middle + 1 ; else     high := middle ; ) ; 
     return low );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : int ; p := 14 ;
     OclFile["System.out"].println(maxPeople(p)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class B858 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int M=in.nextInt();
    int[] K=new int[M];
    int[] F=new int[M];
    for(int m=0 ; m<M ; m++){
      K[m]=in.nextInt();
      F[m]=in.nextInt();
    }
    Set<Integer>set=new HashSet<>();
    for(int size=1 ; size<=100 ; size++){
      boolean possible=true ;
      for(int m=0 ; m<M ; m++){
        int expected=(K[m]-1)/size+1 ;
        if(expected!=F[m]){
          possible=false ;
          break ;
        }
      }
      if(possible){
        int floor=(N-1)/size+1 ;
        set.add(floor);
      }
    }
    if(set.size()==1){
      System.out.println(set.iterator().next());
    }
    else {
      System.out.println("-1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B858 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var M : int ; M := in.getCurrent()->toInteger() ;
    var K : Sequence(int) ; K := Integer.subrange(1,M)->collect(0) ;
    var F : Sequence(int) ; F := Integer.subrange(1,M)->collect(0) ;
        var m : int ; m := 0 ; while m < M do ( (     K[m+1] := in.getCurrent()->toInteger() ; 
     F[m+1] := in.getCurrent()->toInteger() )  ;     m := m + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
        var size : int ; size := 1 ; while size <= 100 do ( (     var possible : boolean ; possible := true ;
         var m : int ; m := 0 ; while m < M do ( (     var expected : int ; expected := (K[m+1] - 1) / size + 1 ;
     if (expected /= F[m+1]) then (     possible := false ; 
     break ) else skip )  ;     m := m + 1 ) ; 
     if (possible) then (     var floor : int ; floor := (N - 1) / size + 1 ;
     set := set->including(floor) ) else skip )  ;     size := size + 1 ) ; 
    if (set->size() = 1) then (     OclFile["System.out"].println(set->iterator().next()) ) else (     OclFile["System.out"].println("-1") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int powOfPositive(int n){
    int pos=(int)Math.floor((Math.log(n)/Math.log(2)));
    return(int)Math.pow(2,pos);
  }
  static int powOfNegative(int n){
    int pos=(int)Math.ceil((Math.log(n)/Math.log(2)));
    return(int)(-1*Math.pow(2,pos));
  }
  static void highestPowerOf2(int n){
    if(n>0){
      System.out.println(powOfPositive(n));
    }
    else {
      n=-n ;
      System.out.println(powOfNegative(n));
    }
  }
  public static void main(String[] args){
    int n=-24 ;
    highestPowerOf2(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation powOfPositive( n : int) : int
  pre: true
  post: true
  activity: (     var pos : int ; pos := (((n)->log() / (2)->log()))->floor()->oclAsType(int) ;
     return 2->pow(pos)->oclAsType(int) );
  static   operation powOfNegative( n : int) : int
  pre: true
  post: true
  activity: (     var pos : int ; pos := (((n)->log() / (2)->log()))->ceil()->oclAsType(int) ;
     return (-1 * 2->pow(pos))->oclAsType(int) );
  static   operation highestPowerOf2( n : int) : void
  pre: true
  post: true
  activity: (     if (n > 0) then (     OclFile["System.out"].println(powOfPositive(n)) ) else (     n := -n ; 
     OclFile["System.out"].println(powOfNegative(n)) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := -24 ;
     execute highestPowerOf2(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class TurnOff {
  static int turnOffK(int n,int k){
    if(k<=0)return n ;
    return(n & ~(1<<(k-1)));
  }
  public static void main(String[] args){
    int n=15 ;
    int k=4 ;
    System.out.println(turnOffK(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class TurnOff {
  static   operation turnOffK( n : int, k : int) : int
  pre: true
  post: true
  activity: (     if (k <= 0) then     return n else skip ; 
     return (n & -(((1*(2->pow((k - 1))))->oclAsType(long)) + 1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     var k : int ; k := 4 ;
     OclFile["System.out"].println(turnOffK(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int size=1000 ;
    int[][] imos=new int[size+1][size+1];
    for(int i=0 ; i<n ; i++){
      int x1=sc.nextInt();
      int y1=sc.nextInt();
      int x2=sc.nextInt();
      int y2=sc.nextInt();
      imos[x1][y1]++;
      imos[x2][y2]++;
      imos[x1][y2]--;
      imos[x2][y1]--;
    }
    int max=imos[0][0];
    for(int i=1 ; i<=size ; i++){
      imos[i][0]+=imos[i-1][0];
      max=Math.max(imos[i][0],max);
    }
    for(int i=1 ; i<=size ; i++){
      imos[0][i]+=imos[0][i-1];
      max=Math.max(imos[0][i],max);
      for(int j=1 ; j<=size ; j++){
        imos[j][i]+=imos[j-1][i]+imos[j][i-1]-imos[j-1][i-1];
        max=Math.max(imos[j][i],max);
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var size : int ; size := 1000 ;
    var imos : Sequence(Sequence(int)) ; imos := Integer.subrange(1,size + 1)->collect(Integer.subrange(1,size + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var x1 : int ; x1 := sc.getCurrent()->toInteger() ;
     var y1 : int ; y1 := sc.getCurrent()->toInteger() ;
    var x2 : int ; x2 := sc.getCurrent()->toInteger() ;
    var y2 : int ; y2 := sc.getCurrent()->toInteger() ;
    imos[x1+1][y1+1] := imos[x1+1][y1+1] + 1 ; 
    imos[x2+1][y2+1] := imos[x2+1][y2+1] + 1 ; 
    imos[x1+1][y2+1] := imos[x1+1][y2+1] - 1 ; 
    imos[x2+1][y1+1] := imos[x2+1][y1+1] - 1 ; 
 )  ;     i := i + 1 ) ; 
    var max : int ; max := imos[0+1][0+1] ;
        var i : int ; i := 1 ; while i <= size do ( (     imos[i+1][0+1] := imos[i+1][0+1]+(imos[i - 1+1][0+1]) ; 
     max := Set{imos[i+1][0+1], max}->max() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= size do ( (     imos[0+1][i+1] := imos[0+1][i+1]+(imos[0+1][i - 1+1]) ; 
     max := Set{imos[0+1][i+1], max}->max() ; 
         var j : int ; j := 1 ; while j <= size do ( (     imos[j+1][i+1] := imos[j+1][i+1]+(imos[j - 1+1][i+1] + imos[j+1][i - 1+1] - imos[j - 1+1][i - 1+1]) ; 
     max := Set{imos[j+1][i+1], max}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static final int MOD=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    sc.close();
    long[] factors=new long[N+1];
    List<Integer>primes=new ArrayList<>();
    for(int i=2 ; i<=N ; i++){
      if(isPrime(i))primes.add(i);
    }
    for(int n=2 ; n<=N ; n++){
      int a=n ;
      for(int p : primes){
        while(a % p==0 && a>1){
          factors[p]++;
          a=a/p ;
        }
      }
    }
    long ans=1 ;
    for(long f : factors){
      ans=(ans*(f+1))% MOD ;
    }
    System.out.println(ans);
  }
  static boolean isPrime(long num){
    if(num==2)return true ;
    if(num<2 || num % 2==0)return false ;
    for(int i=3 ; i*i<=num ; i+=2){
      if(num % i==0)return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    skip ; 
    var factors : Sequence(long) ; factors := Integer.subrange(1,N + 1)->collect(0) ;
    var primes : Sequence(int) ; primes := Sequence{} ;
        var i : int ; i := 2 ; while i <= N do ( (     if (isPrime(i)) then     primes := primes->including(i) ; else skip )  ;     i := i + 1 ) ; 
        var n : int ; n := 2 ; while n <= N do ( (     var a : int ; a := n ;
     for (p : primes) do ( (     while (a mod p = 0 & a > 1) do (     factors[p+1] := factors[p+1] + 1 ; 
     a := a / p ) )  ) )  ;     n := n + 1 ) ; 
    var ans : long ; ans := 1 ;
    for (f : factors) do ( (     ans := (ans * (f + 1)) mod MOD )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation isPrime( num : long) : boolean
  pre: true
  post: true
  activity: (     if (num = 2) then     return true else skip ; 
     if (num < 2 or num mod 2 = 0) then     return false else skip ; 
         var i : int ; i := 3 ; while i * i <= num do ( (     if (num mod i = 0) then     return false else skip )  ;     i := i+(2) ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMinIndex(int arr[],int low,int high){
    if(high<low)return 0 ;
    if(high==low)return low ;
    int mid=(low+high)/2 ;
    if(mid<high && arr[mid+1]<arr[mid])return(mid+1);
    if(mid>low && arr[mid]<arr[mid-1])return mid ;
    if(arr[high]>arr[mid])return findMinIndex(arr,low,mid-1);
    return findMinIndex(arr,mid+1,high);
  }
  static int binary_search(int arr[],int l,int h,int x){
    while(l<=h){
      int mid=(l+h)/2 ;
      if(arr[mid]<=x)l=mid+1 ;
      else h=mid-1 ;
    }
    return h ;
  }
  static int countEleLessThanOrEqual(int arr[],int n,int x){
    int min_index=findMinIndex(arr,0,n-1);
    if(x<=arr[n-1])return(binary_search(arr,min_index,n-1,x)+1-min_index);
    if((min_index-1)>=0 && x<=arr[min_index-1])return(n-min_index+binary_search(arr,0,min_index-1,x)+1);
    return n ;
  }
  public static void main(String[] args){
    int arr[]={
      6,10,12,15,2,4,5 };
      int n=arr.length ;
      int x=14 ;
      System.out.print("Count="+countEleLessThanOrEqual(arr,n,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMinIndex( arr : Sequence(int), low : int, high : int) : int
  pre: true
  post: true
  activity: (     if (high < low) then     return 0 else skip ; 
     if (high = low) then     return low else skip ; 
    var mid : int ; mid := (low + high) / 2 ;
    if (mid < high & arr[mid + 1+1] < arr[mid+1]) then     return (mid + 1) else skip ; 
    if (mid > low & arr[mid+1] < arr[mid - 1+1]) then     return mid else skip ; 
    if (arr[high+1] > arr[mid+1]) then     return findMinIndex(arr, low, mid - 1) else skip ; 
    return findMinIndex(arr, mid + 1, high) 
 );
  static   operation binary_search( arr : Sequence(int), l : int, h : int, x : int) : int
  pre: true
  post: true
  activity: (     while (l <= h) do (     var mid : int ; mid := (l + h) / 2 ;
     if (arr[mid+1] <= x) then     l := mid + 1 ; else     h := mid - 1 ; ) ; 
     return h );
  static   operation countEleLessThanOrEqual( arr : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var min_index : int ; min_index := findMinIndex(arr, 0, n - 1) ;
     if (x <= arr[n - 1+1]) then     return (binary_search(arr, min_index, n - 1, x) + 1 - min_index) else skip ; 
     if ((min_index - 1) >= 0 & x <= arr[min_index - 1+1]) then     return (n - min_index + binary_search(arr, 0, min_index - 1, x) + 1) else skip ; 
     return n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,10,12,15,2,4,5} ;
     var n : int ; n := arr->size() ;
     var x : int ; x := 14 ;
     OclFile["System.out"].print("Count=" + countEleLessThanOrEqual(arr, n, x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    String strn=input.readLine();
    int n=Integer.parseInt(strn);
    int[] list=new int[n+1];
    Arrays.fill(list,0);
    long answer=1 ;
    int x=0 ;
    for(int i=1 ; i<n+1 ; i++){
      x=i ;
      for(int j=1 ; j<i+1 ; j++){
        while((x)%(j)==0){
          list[j]=list[j]+1 ;
          x=x/(j);
          if(j==1){
            break ;
          }
        }
      }
    }
    for(int i=2 ; i<n+1 ; i++){
      answer=answer*(list[i]+1);
      answer=answer %(int)(Math.pow(10,9)+7);
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var strn : String ; strn := input.readLine() ;
    var n : int ; n := (strn)->toInteger() ;
    var list : Sequence(int) ; list := Integer.subrange(1,n + 1)->collect(0) ;
    list := list->collect(0) ; 
    var answer : long ; answer := 1 ;
    var x : int ; x := 0 ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     x := i ; 
         var j : int ; j := 1 ; while j < i + 1 do ( (     while ((x) mod (j) = 0) do (     list[j+1] := list[j+1] + 1 ; 
     x := x / (j) ; 
     if (j = 1) then (     break ) else skip ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i < n + 1 do ( (     answer := answer * (list[i+1] + 1) ; 
     answer := answer mod (10->pow(9) + 7)->oclAsType(int) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    long mod=1000000007 ;
    long count=1 ;
    boolean[] num=new boolean[n+1];
    Arrays.fill(num,true);
    num[0]=false ;
    num[1]=false ;
    double m=Math.sqrt(n);
    for(int i=2 ; i<=m ; i++){
      for(int j=i*2 ; j<=n ; j+=i){
        num[j]=false ;
      }
    }
    Map<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<=n ; i++){
      if(num[i]){
        map.put(i,0);
      }
    }
    for(int i=2 ; i<=n ; i++){
      int N=i ;
      for(Integer p : map.keySet()){
        while(N % p==0){
          map.put(p,map.get(p)+1);
          N/=p ;
        }
      }
    }
    for(Integer p : map.keySet()){
      count=(count*(map.get(p)+1))% mod ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var mod : long ; mod := 1000000007 ;
    var count : long ; count := 1 ;
    var num : Sequence(boolean) ; num := Integer.subrange(1,n + 1)->collect(false) ;
    num := num->collect(true) ; 
    num[0+1] := false ; 
    num[1+1] := false ; 
    var m : double ; m := (n)->sqrt() ;
        var i : int ; i := 2 ; while i <= m do ( (         var j : int ; j := i * 2 ; while j <= n do ( (     num[j+1] := false )  ;     j := j+(i) ) )  ;     i := i + 1 ) ; 
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i <= n do ( (     if (num[i+1]) then (     map := map->union(Map{i |-> 0}) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= n do ( (     var N : int ; N := i ;
     for (p : map->keys()) do ( (     while (N mod p = 0) do (     map := map->union(Map{p |-> map->at(p) + 1}) ; 
     N := N/(p) ) )  ) )  ;     i := i + 1 ) ; 
    for (p : map->keys()) do ( (     count := (count * (map->at(p) + 1)) mod mod )  ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n+1];
    for(int k=2 ; k<=n ; k++){
      int t=k ;
      while(1<t){
        for(int i=2 ; i<=t ; i++){
          if(t % i==0){
            a[i]++;
            t/=i ;
            break ;
          }
        }
      }
    }
    long count=1 ;
    long MOD=1_000_000_000+7 ;
    for(int i=0 ; i<n+1 ; i++){
      if(a[i]!=0){
        count*=(a[i]+1);
        count %=MOD ;
      }
    }
    System.out.println(count);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var k : int ; k := 2 ; while k <= n do ( (     var t : int ; t := k ;
     while (1 < t) do (         var i : int ; i := 2 ; while i <= t do ( (     if (t mod i = 0) then (     a[i+1] := a[i+1] + 1 ; 
     t := t/(i) ; 
     break ) else skip )  ;     i := i + 1 ) ) )  ;     k := k + 1 ) ; 
    var count : long ; count := 1 ;
    var MOD : long ; MOD := 1_000_000_000 + 7 ;
        var i : int ; i := 0 ; while i < n + 1 do ( (     if (a[i+1] /= 0) then (     count := count*((a[i+1] + 1)) ; 
     count := count mod MOD ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    long MOD=1000000007 ;
    Map<Integer,Integer>map=new HashMap<Integer,Integer>();
    int n=scan.nextInt();
    for(int i=1 ; i<=n ; i++){
      int value=i ;
      for(int j=2 ; j<=n ; j++){
        if(value % j==0){
          int cnt=0 ;
          while(value % j==0){
            value/=j ;
            cnt++;
          }
          if(! map.containsKey(j))map.put(j,0);
          map.put(j,map.get(j)+cnt);
        }
      }
    }
    long ans=1 ;
    for(int value : map.values())ans=(ans*(value+1))% MOD ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var MOD : long ; MOD := 1000000007 ;
    var map : Map(int,int) ; map := Map{} ;
    var n : int ; n := scan.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= n do ( (     var value : int ; value := i ;
         var j : int ; j := 2 ; while j <= n do ( (     if (value mod j = 0) then (     var cnt : int ; cnt := 0 ;
     while (value mod j = 0) do (     value := value/(j) ; 
     cnt := cnt + 1 ) ; 
     if (not(map->keys()->includes(j))) then     map := map->union(Map{j |-> 0}) ; else skip ; 
     map := map->union(Map{j |-> map->at(j) + cnt}) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 1 ;
    for (value : map->values()) do (     ans := (ans * (value + 1)) mod MOD ;  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int minMeetingRooms(Interval[] intervals){
    int ans=0,curr=0 ;
    List<TimePoint>timeline=new ArrayList<>();
    for(Interval interval : intervals){
      timeline.add(new TimePoint(interval.start,1));
      timeline.add(new TimePoint(interval.end,-1));
    }
    timeline.sort(new Comparator<TimePoint>(){
      public int compare(TimePoint a,TimePoint b){
        if(a.time!=b.time)return a.time-b.time ;
        else return a.room-b.room ;
      }
    }
);
    for(TimePoint t : timeline){
      curr+=t.room ;
      if(curr>=ans)ans=curr ;
    }
    return ans ;
  }
  private class TimePoint {
    int time ;
    int room ;
    TimePoint(int time,int room){
      this.time=time ;
      this.room=room ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation minMeetingRooms( intervals : Sequence(Interval)) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
    var curr : int ; curr := 0 ;
     var timeline : Sequence(TimePoint) ; timeline := Sequence{} ;
    for (interval : intervals) do ( (     timeline := timeline->including(TimePoint.newTimePoint(interval.start, 1)) ; 
     timeline := timeline->including(TimePoint.newTimePoint(interval.end, -1)) )  ) ; 
    timeline := timeline.sort(OclComparator<TimePoint>.newOclComparator()) ; 
    for (t : timeline) do ( (     curr := curr+(t.room) ; 
     if (curr >= ans) then     ans := curr ; else skip )  ) ; 
    return ans 
 );
 class TimePoint {
   attribute time : int;
   attribute room : int;
   static operation newTimePoint( time : int, room : int) : TimePoint
  pre: true
  post: true
  activity:
  ( var self : TimePoint ;
    self := createTimePoint();
    self.initialise(time, room);
    return self );
  operation initialise( time : int, room : int) : void
  pre: true  post: true
  activity: (     self.time := time ; 
     self.room := room );
}
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner scan=new Scanner(System.in);
    while(true){
      String g=scan.next();
      if(g.equals("#"))return ;
      int y=scan.nextInt();
      int m=scan.nextInt();
      int d=scan.nextInt();
      if(y<31)System.out.println(g+" "+y+" "+m+" "+d);
      else if(y==31 && m<5)System.out.println(g+" "+y+" "+m+" "+d);
      else System.out.println("? "+(y-30)+" "+m+" "+d);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var g : String ; g := scan.getCurrent() ;
     if (g = "#") then     return else skip ; 
    var y : int ; y := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var d : int ; d := scan.getCurrent()->toInteger() ;
    if (y < 31) then     OclFile["System.out"].println(g + " " + y + " " + m + " " + d) else     if (y = 31 & m < 5) then     OclFile["System.out"].println(g + " " + y + " " + m + " " + d) else     OclFile["System.out"].println("? " + ((y)->char2byte() - 30) + " " + m + " " + d) ; ;  ;  
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  static long mod=(long)(1e9+7);
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    String s=in.next();
    String s1=s.substring(0,n);
    String s2=s.substring(n);
    char c1[]=s1.toCharArray();
    char c2[]=s2.toCharArray();
    Arrays.sort(c1);
    Arrays.sort(c2);
    int count1=0,count2=0 ;
    for(int i=0 ; i<n ; i++){
      if(c1[i]<c2[i]){
        count1++;
      }
      else if(c1[i]>c2[i]){
        count2++;
      }
    }
    if(count1==n || count2==n){
      pw.println("YES");
    }
    else {
      pw.println("NO");
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := (1e9 + 7)->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var s1 : String ; s1 := s.subrange(0+1,n) ;
    var s2 : String ; s2 := s.subrange(n+1,n) ;
    var c1 : Sequence(String) ; c1 := s1->characters() ;
    var c2 : Sequence(String) ; c2 := s2->characters() ;
    c1 := c1->sort() ; 
    c2 := c2->sort() ; 
    var count1 : int ; count1 := 0 ;
    var count2 : int ; count2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (c1[i+1] < c2[i+1]) then (     count1 := count1 + 1 ) else     if (c1[i+1] > c2[i+1]) then (     count2 := count2 + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    if (count1 = n or count2 = n) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      ArrayList<Date>date=new ArrayList<>();
      while(true){
        String str=reader.readLine();
        if(str.equals("#")){
          break ;
        }
        String s[]=str.split(" ");
        String gen=s[0];
        int y=Integer.parseInt(s[1]);
        int m=Integer.parseInt(s[2]);
        int d=Integer.parseInt(s[3]);
        date.add(new Date(gen,y,m,d));
      }
      for(int i=0 ; i<date.size(); i++){
        System.out.println(date.get(i).gen+" "+date.get(i).y+" "+date.get(i).m+" "+date.get(i).d);
      }
      reader.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  static class Date {
    String gen ;
    int y ;
    int m ;
    int d ;
    public Date(String gen,int y,int m,int d){
      this.gen=gen ;
      this.y=y ;
      this.m=m ;
      this.d=d ;
      init();
    }
    void init(){
      if(y>31 ||(y==31 && m>4)){
        gen="?" ;
        y=y-30 ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var date : Sequence(OclDate) ; date := Sequence{} ;
     while (true) do (     var str : String ; str := reader.readLine() ;
     if (str = "#") then (     break ) else skip ; 
    var s : Sequence(String) ; s := str->split(" ") ;
    var gen : String ; gen := s[0+1] ;
    var y : int ; y := (s[1+1])->toInteger() ;
    var m : int ; m := (s[2+1])->toInteger() ;
    var d : int ; d := (s[3+1])->toInteger() ;
    date := date->including(OclDate.newOclDate(gen, y, m, d)) ; 
 ) ; 
         var i : int ; i := 0 ; while i < date->size() do ( (     OclFile["System.out"].println(date->at(i+1).gen + " " + date->at(i+1).y + " " + date->at(i+1).m + " " + date->at(i+1).d) )  ;     i := i + 1 ) ; 
     skip )   catch (e : IOException) do (     e.printStackTrace() )
 );
  static class Date {
   attribute gen : String;
   attribute y : int;
   attribute m : int;
   attribute d : int;
   static operation newDate( gen : String, y : int, m : int, d : int) : Date
  pre: true
  post: true
  activity:
  ( var self : Date ;
    self := createDate();
    self.initialise(gen, y,m,d);
    return self );
  operation initialise( gen : String, y : int, m : int, d : int) : void
  pre: true  post: true
  activity: (     self.gen := gen ; 
     self.y := y ; 
    self.m := m ; 
    self.d := d ; 
    execute init() ; 
 );
   operation init() : void
  pre: true
  post: true
  activity: (     if (y > 31 or (y = 31 & m > 4)) then (     gen := "?" ; 
     y := (y)->char2byte() - 30 ) else skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      if(line.equals("#"))break ;
      words=line.split(" ");
      int y,m ;
      y=parseInt(words[1]);
      m=parseInt(words[2]);
      if(y<31 ||(y<=31 && m<=4)){
        System.out.println(line);
      }
      else {
        y-=30 ;
        System.out.printf("%s %d %s %s%n","?",y,words[2],words[3]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     if (line = "#") then     break else skip ; 
     words := line->split(" ") ; 
    var y : int ;
    var m : int ;
    y := (words[1+1] + "")->toInteger() ; 
    m := (words[2+1] + "")->toInteger() ; 
    if (y < 31 or (y <= 31 & m <= 4)) then (     OclFile["System.out"].println(line) ) else (     y := y-(30) ; 
     OclFile["System.out"].printf("%s %d %s %s%n", "?", y, words[2+1], words[3+1]) ) ;  
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    String g=in.next();
    while(! "#".equals(g)){
      int y=in.nextInt(),m=in.nextInt(),d=in.nextInt();
      if(y<=30 ||(y==31 && m<=4)){
        out.print("HEISEI ");
      }
      else {
        out.print("? ");
        y-=30 ;
      }
      out.println(y+" "+m+" "+d);
      g=in.next();
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var g : String ; g := in.getCurrent() ;
    while (not("#" = g)) do (     var y : int ; y := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
     if (y <= 30 or (y = 31 & m <= 4)) then (     skip ) else (     skip ; 
     y := y-(30) ) ;  
     skip ; 
     g := in.getCurrent() ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import java.util.regex.Matcher ;
import java.util.Collections ;
import java.util.regex.Pattern ;
import java.util.Calendar ;
import java.text.SimpleDateFormat ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String s[]=br.readLine().split(" ");
      String gen=s[0];
      if(gen.equals("#")){
        break ;
      }
      int y=Integer.parseInt(s[1]);
      int m=Integer.parseInt(s[2]);
      int d=Integer.parseInt(s[3]);
      if((y>=31 && m>=5)||(y>31)){
        gen="?" ;
        y-=30 ;
      }
      System.out.println(gen+" "+y+" "+m+" "+d);
    }
    br.close();
  }
  static int gcd(int a,int b){
    return b>0 ? gcd(b,a % b): a ;
  }
  static int lcm(int a,int b){
    return a*b/gcd(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
     var gen : String ; gen := s[0+1] ;
    if (gen = "#") then (     break ) else skip ; 
    var y : int ; y := (s[1+1])->toInteger() ;
    var m : int ; m := (s[2+1])->toInteger() ;
    var d : int ; d := (s[3+1])->toInteger() ;
    if ((y >= 31 & m >= 5) or (y > 31)) then (     gen := "?" ; 
     y := y-(30) ) else skip ; 
    OclFile["System.out"].println(gen + " " + y + " " + m + " " + d) ; 
 ) ; 
     skip );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b > 0 then gcd(b, a mod b) else a endif );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return a * b / gcd(a, b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
public class Main {
  public static int solution(int n,int fingers){
    int count=0 ;
    for(int i=1 ; i<6 ; i++){
      int total=fingers+i ;
      if((total %(n+1))!=1)count++;
    }
    return count ;
  }
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int fingers=0 ;
    int n=input.nextInt();
    for(int i=0 ; i<n ; i++){
      fingers+=input.nextInt();
    }
    System.out.println(solution(n,fingers));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solution( n : int, fingers : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i < 6 do ( (     var total : int ; total := fingers + i ;
     if ((total mod (n + 1)) /= 1) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var fingers : int ; fingers := 0 ;
    var n : int ; n := input.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     fingers := fingers+(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solution(n, fingers)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class DimaFriends {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=sc.nextInt();
    }
    int count=0 ;
    for(int i=1 ; i<=5 ; i++){
      if((sum+i)%(n+1)!=1)count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class DimaFriends {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= 5 do ( (     if ((sum + i) mod (n + 1) /= 1) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication110 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num1=sc.nextInt();
    int counter=0 ;
    for(int i=0 ; i<num1 ; i++){
      counter+=sc.nextInt();
    }
    int ans=0 ;
    for(int i=1 ; i<=5 ; i++){
      if(((counter+i))%(num1+1)!=1){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication110 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num1 : int ; num1 := sc.getCurrent()->toInteger() ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < num1 do ( (     counter := counter+(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= 5 do ( (     if (((counter + i)) mod (num1 + 1) /= 1) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class DimaAndFriends {
  public static void main(String[] args)throws IOException {
    FastIO io=new FastIO();
    int n=io.nextInt();
    int sum=0 ;
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=io.nextInt();
    }
    for(int i=1 ; i<=5 ; i++){
      if((sum+i)%(n+1)!=1){
        count++;
      }
    }
    io.println(count);
    io.close();
  }
  static class FastIO extends PrintWriter {
    private BufferedReader br ;
    private StringTokenizer st ;
    public FastIO(){
      this(System.in,System.out);
    }
    public FastIO(InputStream in,OutputStream out){
      super(out);
      br=new BufferedReader(new InputStreamReader(in));
    }
    public FastIO(String problemName)throws IOException {
      super(new FileWriter(problemName+".out"));
      br=new BufferedReader(new FileReader(problemName+".in"));
    }
    public String next(){
      try {
        while(st==null || ! st.hasMoreTokens()){
          st=new StringTokenizer(br.readLine());
        }
        return st.nextToken();
      }
      catch(Exception e){
      }
      return null ;
    }
    public String nextLine(){
      try {
        return br.readLine();
      }
      catch(Exception e){
      }
      return null ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public boolean nextBoolean(){
      return Boolean.parseBoolean(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DimaAndFriends {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : FastIO ; io := FastIO.newFastIO() ;
     var n : int ; n := io.nextInt() ;
    var sum : int ; sum := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(io.nextInt()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 5 do ( (     if ((sum + i) mod (n + 1) /= 1) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    io.println(count) ; 
    io.close() ; 
 );
  static class FastIO extends OclFile {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastIO() : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile["System.in"], OclFile["System.out"]) );
   static operation newFastIO( in : OclFile, out : OclFile) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(in, out);
    return self );
  operation initialise( in : OclFile, out : OclFile) : void
  pre: true  post: true
  activity: (     execute super(out) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   static operation newFastIO( problemName : String) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(problemName);
    return self );
  operation initialise( problemName : String) : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Write(problemName + ".out")) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(problemName + ".in")) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() )   catch (e : ProgramException) do skip
     return null );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : ProgramException) do skip
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextBoolean() : boolean
  pre: true
  post: true
  activity: (     return parseBoolean(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.HashSet ;
import java.util.Set ;
import java.util.StringTokenizer ;
public class IsYourHorseshoeOnTheOtherHoof {
  public static void main(String[] args)throws IOException {
    FastIO io=new FastIO();
    Set<Integer>set=new HashSet<>();
    for(int i=0 ; i<4 ; i++){
      set.add(io.nextInt());
    }
    io.println(4-set.size());
    io.close();
  }
  static class FastIO extends PrintWriter {
    private BufferedReader br ;
    private StringTokenizer st ;
    public FastIO(){
      this(System.in,System.out);
    }
    public FastIO(InputStream in,OutputStream out){
      super(out);
      br=new BufferedReader(new InputStreamReader(in));
    }
    public FastIO(String problemName)throws IOException {
      super(new FileWriter(problemName+".out"));
      br=new BufferedReader(new FileReader(problemName+".in"));
    }
    public String next(){
      try {
        while(st==null || ! st.hasMoreTokens()){
          st=new StringTokenizer(br.readLine());
        }
        return st.nextToken();
      }
      catch(Exception e){
      }
      return null ;
    }
    public String nextLine(){
      try {
        return br.readLine();
      }
      catch(Exception e){
      }
      return null ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public boolean nextBoolean(){
      return Boolean.parseBoolean(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class IsYourHorseshoeOnTheOtherHoof {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : FastIO ; io := FastIO.newFastIO() ;
     var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < 4 do ( (     set := set->including(io.nextInt()) )  ;     i := i + 1 ) ; 
    io.println(4 - set->size()) ; 
    io.close() ; 
 );
  static class FastIO extends OclFile {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastIO() : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile["System.in"], OclFile["System.out"]) );
   static operation newFastIO( in : OclFile, out : OclFile) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(in, out);
    return self );
  operation initialise( in : OclFile, out : OclFile) : void
  pre: true  post: true
  activity: (     execute super(out) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   static operation newFastIO( problemName : String) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(problemName);
    return self );
  operation initialise( problemName : String) : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Write(problemName + ".out")) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(problemName + ".in")) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() )   catch (e : ProgramException) do skip
     return null );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : ProgramException) do skip
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextBoolean() : boolean
  pre: true
  post: true
  activity: (     return parseBoolean(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    TreeSet<Integer>set=new TreeSet<>();
    for(int i=0 ; i<4 ; i++){
      set.add(in.nextInt());
    }
    out.println(4-set.size());
    out.flush();
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new FileReader("sub.in"));
      }
      catch(FileNotFoundException ex){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException ex){
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException ex){
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < 4 do ( (     set := set->including(in.nextInt()) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("sub.in"))) )   catch (ex : FileNotFoundException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (ex : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (ex : IOException) do skip
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.*;
import java.util.Scanner ;
public class Arr {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String str=in.next();
    int[] arr1=new int[n],arr2=new int[n],arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr1[i]=str.charAt(i)-'0' ;
      arr2[i]=str.charAt(n+i)-'0' ;
    }
    Arrays.sort(arr1);
    Arrays.sort(arr2);
    boolean isNeg=(arr1[0]-arr2[0])<0 ? true : false ;
    String ans="YES" ;
    for(int i=0 ; i<n ; i++){
      if(isNeg && arr1[i]-arr2[i]>=0){
        ans="NO" ;
        break ;
      }
      else if(! isNeg && arr1[i]-arr2[i]<=0){
        ans="NO" ;
        break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Arr {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var str : String ; str := in.getCurrent() ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,n)->collect(0) ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr1[i+1] := str->at(i+1) - ('0')->char2byte() ; 
     arr2[i+1] := str->at(n + i+1) - ('0')->char2byte() )  ;     i := i + 1 ) ; 
    arr1 := arr1->sort() ; 
    arr2 := arr2->sort() ; 
    var isNeg : boolean ; isNeg := if (arr1[0+1] - arr2[0+1]) < 0 then true else false endif ;
    var ans : String ; ans := "YES" ;
        var i : int ; i := 0 ; while i < n do ( (     if (isNeg & arr1[i+1] - arr2[i+1] >= 0) then (     ans := "NO" ; 
     break ) else     if (not(isNeg) & arr1[i+1] - arr2[i+1] <= 0) then (     ans := "NO" ; 
     break ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    HashSet<Integer>set=new HashSet<>();
    for(int i=0 ; i<4 ; i++){
      set.add(in.nextInt());
    }
    out.println(4-set.size());
    out.flush();
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new FileReader("sub.in"));
      }
      catch(FileNotFoundException ex){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException ex){
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException ex){
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < 4 do ( (     set := set->including(in.nextInt()) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("sub.in"))) )   catch (ex : FileNotFoundException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (ex : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (ex : IOException) do skip
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class guy {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int a=scan.nextInt();
    int b=scan.nextInt();
    int c=scan.nextInt();
    int d=scan.nextInt();
    int sim=0 ;
    if(a==b || a==c || a==d){
      sim++;
    }
    if(b==c || b==d){
      sim++;
    }
    if(c==d){
      sim++;
    }
    System.out.println(sim);
  }
}
------------------------------------------------------------
OCL File:
---------
 class guy {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    var c : int ; c := scan.getCurrent()->toInteger() ;
    var d : int ; d := scan.getCurrent()->toInteger() ;
    var sim : int ; sim := 0 ;
    if (a = b or a = c or a = d) then (     sim := sim + 1 ) else skip ; 
    if (b = c or b = d) then (     sim := sim + 1 ) else skip ; 
    if (c = d) then (     sim := sim + 1 ) else skip ; 
    OclFile["System.out"].println(sim) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.text.*;
class GFG {
  static double f(double x,double y){
    double v=y-2*x*x+1 ;
    return v ;
  }
  static double predict(double x,double y,double h){
    double y1p=y+h*f(x,y);
    return y1p ;
  }
  static double correct(double x,double y,double x1,double y1,double h){
    double e=0.00001 ;
    double y1c=y1 ;
    do {
      y1=y1c ;
      y1c=y+0.5*h*(f(x,y)+f(x1,y1));
    }
    while(Math.abs(y1c-y1)>e);
    return y1c ;
  }
  static void printFinalValues(double x,double xn,double y,double h){
    while(x<xn){
      double x1=x+h ;
      double y1p=predict(x,y,h);
      double y1c=correct(x,y,x1,y1p,h);
      x=x1 ;
      y=y1c ;
    }
    DecimalFormat df=new DecimalFormat("#.#####");
    System.out.println("The final value of y at x="+x+" is : "+df.format(y));
  }
  public static void main(String[] args){
    double x=0,y=0.5 ;
    double xn=1 ;
    double h=0.2 ;
    printFinalValues(x,xn,y,h);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation f( x : double, y : double) : double
  pre: true
  post: true
  activity: (     var v : double ; v := y - 2 * x * x + 1 ;
     return v );
  static   operation predict( x : double, y : double, h : double) : double
  pre: true
  post: true
  activity: (     var y1p : double ; y1p := y + h * f(x, y) ;
     return y1p );
  static   operation correct( x : double, y : double, x1 : double, y1 : double, h : double) : double
  pre: true
  post: true
  activity: (     var e : double ; e := 0.00001 ;
     var y1c : double ; y1c := y1 ;
   while true do ((     y1 := y1c ; 
     y1c := y + 0.5 * h * (f(x, y) + f(x1, y1)) ) ;
    if (if y1c - y1 < 0 then -(y1c - y1) else y1c - y1 endif > e) then skip else break) ; 
     return y1c );
  static   operation printFinalValues( x : double, xn : double, y : double, h : double) : void
  pre: true
  post: true
  activity: (     while (x < xn) do (     var x1 : double ; x1 := x + h ;
     var y1p : double ; y1p := predict(x, y, h) ;
    var y1c : double ; y1c := correct(x, y, x1, y1p, h) ;
    x := x1 ; 
    y := y1c ; 
 ) ; 
     var df : DecimalFormat ; df := DecimalFormat.newDecimalFormat("#.#####") ;
     OclFile["System.out"].println("The final value of y at x=" + x + " is : " + df.format(y)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : double ; x := 0 ;
    var y : double ; y := 0.5 ;
     var xn : double ; xn := 1 ;
     var h : double ; h := 0.2 ;
     execute printFinalValues(x, xn, y, h) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Codesolver {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=4 ;
    HashSet<Long>av=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      av.add(sc.nextLong());
    }
    System.out.println(n-av.size());
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codesolver {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := 4 ;
    var av : Set(long) ; av := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     av := av->including(sc.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n - av->size()) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class PerfectPermutation {
  public static void main(String[] args)throws IOException {
    FastIO io=new FastIO();
    int n=io.nextInt();
    if(n % 2!=0){
      io.println(-1);
    }
    else {
      for(int i=0 ; i<n ; i++){
        io.print((n-i)+" ");
      }
      io.println();
    }
    io.close();
  }
  static class FastIO extends PrintWriter {
    private BufferedReader br ;
    private StringTokenizer st ;
    public FastIO(){
      this(System.in,System.out);
    }
    public FastIO(InputStream in,OutputStream out){
      super(out);
      br=new BufferedReader(new InputStreamReader(in));
    }
    public FastIO(String problemName)throws IOException {
      super(new FileWriter(problemName+".out"));
      br=new BufferedReader(new FileReader(problemName+".in"));
    }
    public String next(){
      try {
        while(st==null || ! st.hasMoreTokens()){
          st=new StringTokenizer(br.readLine());
        }
        return st.nextToken();
      }
      catch(Exception e){
      }
      return null ;
    }
    public String nextLine(){
      try {
        return br.readLine();
      }
      catch(Exception e){
      }
      return null ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public boolean nextBoolean(){
      return Boolean.parseBoolean(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PerfectPermutation {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : FastIO ; io := FastIO.newFastIO() ;
     var n : int ; n := io.nextInt() ;
     if (n mod 2 /= 0) then (     io.println(-1) ) else (         var i : int ; i := 0 ; while i < n do ( (     io.print((n - i) + " ") )  ;     i := i + 1 ) ; 
     io.println() ) ;  
     io.close() );
  static class FastIO extends OclFile {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastIO() : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile["System.in"], OclFile["System.out"]) );
   static operation newFastIO( in : OclFile, out : OclFile) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(in, out);
    return self );
  operation initialise( in : OclFile, out : OclFile) : void
  pre: true  post: true
  activity: (     execute super(out) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   static operation newFastIO( problemName : String) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(problemName);
    return self );
  operation initialise( problemName : String) : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Write(problemName + ".out")) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(problemName + ".in")) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() )   catch (e : ProgramException) do skip
     return null );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : ProgramException) do skip
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextBoolean() : boolean
  pre: true
  post: true
  activity: (     return parseBoolean(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewClass55 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    if(t % 2!=0){
      System.out.println("-1");
    }
    else if(t==2){
      System.out.println(2+" "+1);
    }
    else {
      for(int i=1 ; i<t ; i++){
        if(i<i+1){
          System.out.print(i+1+" ");
          System.out.print(i+" ");
          i++;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass55 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
     if (t mod 2 /= 0) then (     OclFile["System.out"].println("-1") ) else     if (t = 2) then (     OclFile["System.out"].println(2 + " " + 1) ) else (         var i : int ; i := 1 ; while i < t do ( (     if (i < i + 1) then (     OclFile["System.out"].print(i + 1 + " ") ; 
     OclFile["System.out"].print(i + " ") ; 
     i := i + 1 ) else skip )  ;     i := i + 1 ) ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class Team {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n % 2==1){
      System.out.print(-1);
      return ;
    }
    for(int i=1 ; i<=n ; i++){
      if(i % 2==1){
        System.out.print(i+1+" ");
      }
      else {
        System.out.print(i-1+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Team {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n mod 2 = 1) then (     OclFile["System.out"].print(-1) ; 
     return ) else skip ; 
         var i : int ; i := 1 ; while i <= n do ( (     if (i mod 2 = 1) then (     OclFile["System.out"].print(i + 1 + " ") ) else (     OclFile["System.out"].print(i - 1 + " ") ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PerfectPermutation {
  public static void main(String[] args){
    Scanner kb=new Scanner(System.in);
    int n=kb.nextInt();
    solve(n);
    kb.close();
  }
  public static void solve(int n){
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=i+1 ;
    }
    int[] brr=new int[n];
    StringBuilder sb=new StringBuilder();
    if((n & 1)==0){
      for(int i=0 ; i+1<n ; i+=2){
        brr[i]=arr[i+1];
        brr[i+1]=arr[i];
        sb.append(brr[i]+" "+brr[i+1]+" ");
      }
    }
    else {
      sb=new StringBuilder("-1");
    }
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class PerfectPermutation {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var kb : OclFile ; kb := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := kb.getCurrent()->toInteger() ;
     execute solve(n) ; 
     skip );
  static   operation solve( n : int) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := i + 1 )  ;     i := i + 1 ) ; 
    var brr : Sequence(int) ; brr := Integer.subrange(1,n)->collect(0) ;
    var sb : String ; sb := StringLib.newString() ;
    if ((MathLib.bitwiseAnd(n,1)) = 0) then (         var i : int ; i := 0 ; while i + 1 < n do ( (     brr[i+1] := arr[i + 1+1] ; 
     brr[i + 1+1] := arr[i+1] ; 
     sb := sb + StringLib.newString(brr[i+1] + " " + brr[i + 1+1] + " ") )  ;     i := i+(2) ) ) else (     sb := StringLib.newString("-1") ) ;  
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n % 2==1){
      System.out.println("-1");
    }
    else {
      int a[]=new int[101];
      int i ;
      for(i=1 ; i<=n ; i++){
        if(i % 2==1){
          a[i]=i+1 ;
        }
        else {
          a[i]=i-1 ;
        }
      }
      for(i=1 ; i<n ; i++){
        System.out.print(a[i]+" ");
      }
      System.out.print(a[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n mod 2 = 1) then (     OclFile["System.out"].println("-1") ) else (     var a : Sequence(int) ; a := Integer.subrange(1,101)->collect(0) ;
     var i : int ;
        i := 1 ; while i <= n do ( (     if (i mod 2 = 1) then (     a[i+1] := i + 1 ) else (     a[i+1] := i - 1 ) )  ;     i := i + 1 ) ; 
        i := 1 ; while i < n do ( (     OclFile["System.out"].print(a[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(a[i+1]) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class ILoveUsername {
  public static void main(String[] args)throws IOException {
    FastIO io=new FastIO();
    int n=io.nextInt();
    int min=Integer.MAX_VALUE ;
    int max=Integer.MIN_VALUE ;
    int amazing=-2 ;
    for(int i=0 ; i<n ; i++){
      int v=io.nextInt();
      if(v>max){
        amazing++;
        max=v ;
      }
      if(v<min){
        amazing++;
        min=v ;
      }
    }
    io.println(amazing);
    io.close();
  }
  static class FastIO extends PrintWriter {
    private BufferedReader br ;
    private StringTokenizer st ;
    public FastIO(){
      this(System.in,System.out);
    }
    public FastIO(InputStream in,OutputStream out){
      super(out);
      br=new BufferedReader(new InputStreamReader(in));
    }
    public FastIO(String problemName)throws IOException {
      super(new FileWriter(problemName+".out"));
      br=new BufferedReader(new FileReader(problemName+".in"));
    }
    public String next(){
      try {
        while(st==null || ! st.hasMoreTokens()){
          st=new StringTokenizer(br.readLine());
        }
        return st.nextToken();
      }
      catch(Exception e){
      }
      return null ;
    }
    public String nextLine(){
      try {
        return br.readLine();
      }
      catch(Exception e){
      }
      return null ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public boolean nextBoolean(){
      return Boolean.parseBoolean(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ILoveUsername {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : FastIO ; io := FastIO.newFastIO() ;
     var n : int ; n := io.nextInt() ;
    var min : int ; min := 2147483647 ;
    var max : int ; max := -2147483648 ;
    var amazing : int ; amazing := -2 ;
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := io.nextInt() ;
     if (v > max) then (     amazing := amazing + 1 ; 
     max := v ) else skip ; 
     if (v < min) then (     amazing := amazing + 1 ; 
     min := v ) else skip )  ;     i := i + 1 ) ; 
    io.println(amazing) ; 
    io.close() ; 
 );
  static class FastIO extends OclFile {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastIO() : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile["System.in"], OclFile["System.out"]) );
   static operation newFastIO( in : OclFile, out : OclFile) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(in, out);
    return self );
  operation initialise( in : OclFile, out : OclFile) : void
  pre: true  post: true
  activity: (     execute super(out) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   static operation newFastIO( problemName : String) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(problemName);
    return self );
  operation initialise( problemName : String) : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Write(problemName + ".out")) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(problemName + ".in")) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() )   catch (e : ProgramException) do skip
     return null );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : ProgramException) do skip
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextBoolean() : boolean
  pre: true
  post: true
  activity: (     return parseBoolean(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Reader {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int contests=input.nextInt();
    int[] points=new int[contests];
    int i ;
    for(i=0 ; i<contests ; i++){
      points[i]=input.nextInt();
    }
    int morePoints=points[0];
    int lessPoints=points[0];
    int ans=0 ;
    int a ;
    for(a=0 ; a<contests ; a++){
      if(points[a]>morePoints){
        morePoints=points[a];
        ans++;
      }
      if(points[a]<lessPoints){
        lessPoints=points[a];
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Reader {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var contests : int ; contests := input.getCurrent()->toInteger() ;
    var points : Sequence(int) ; points := Integer.subrange(1,contests)->collect(0) ;
    var i : int ;
        i := 0 ; while i < contests do ( (     points[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var morePoints : int ; morePoints := points[0+1] ;
    var lessPoints : int ; lessPoints := points[0+1] ;
    var ans : int ; ans := 0 ;
    var a : int ;
        a := 0 ; while a < contests do ( (     if (points[a+1] > morePoints) then (     morePoints := points[a+1] ; 
     ans := ans + 1 ) else skip ; 
     if (points[a+1] < lessPoints) then (     lessPoints := points[a+1] ; 
     ans := ans + 1 ) else skip )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args){
    int[] month=new int[12];
    int youbi=3 ;
    int nissuu=0 ;
    String str="" ;
    StringTokenizer stk ;
    int tsuki=0,nichi=0 ;
    int motomeru=0 ;
    month[0]=31 ;
    month[1]=29 ;
    month[2]=31 ;
    month[3]=30 ;
    month[4]=31 ;
    month[5]=30 ;
    month[6]=31 ;
    month[7]=31 ;
    month[8]=30 ;
    month[9]=31 ;
    month[10]=30 ;
    month[11]=31 ;
    BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      try {
        nissuu=0 ;
        str=bfr.readLine();
        stk=new StringTokenizer(str," ");
        tsuki=Integer.parseInt(stk.nextToken());
        nichi=Integer.parseInt(stk.nextToken());
        if(tsuki==0 && nichi==0){
          System.exit(0);
        }
        if(tsuki==1){
          nissuu=nichi ;
        }
        else {
          for(int i=0 ; i<=tsuki-2 ; i++){
            nissuu+=month[i];
          }
          nissuu+=nichi ;
        }
        motomeru=(youbi+nissuu)% 7 ;
        if(motomeru==0){
          System.out.println("Sunday");
        }
        else if(motomeru==1){
          System.out.println("Monday");
        }
        else if(motomeru==2){
          System.out.println("Tuesday");
        }
        else if(motomeru==3){
          System.out.println("Wednesday");
        }
        else if(motomeru==4){
          System.out.println("Thursday");
        }
        else if(motomeru==5){
          System.out.println("Friday");
        }
        else if(motomeru==6){
          System.out.println("Saturday");
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var month : Sequence(int) ; month := Integer.subrange(1,12)->collect(0) ;
     var youbi : int ; youbi := 3 ;
    var nissuu : int ; nissuu := 0 ;
    var str : String ; str := "" ;
    var stk : OclIterator ;
    var tsuki : int ; tsuki := 0 ;
    var nichi : int ; nichi := 0 ;
    var motomeru : int ; motomeru := 0 ;
    month[0+1] := 31 ; 
    month[1+1] := 29 ; 
    month[2+1] := 31 ; 
    month[3+1] := 30 ; 
    month[4+1] := 31 ; 
    month[5+1] := 30 ; 
    month[6+1] := 31 ; 
    month[7+1] := 31 ; 
    month[8+1] := 30 ; 
    month[9+1] := 31 ; 
    month[10+1] := 30 ; 
    month[11+1] := 31 ; 
    var bfr : OclFile ; bfr := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    while (true) do (     try (     nissuu := 0 ; 
     str := bfr.readLine() ; 
    stk := OclIterator.newOclIterator_String_String(str, " ") ; 
    tsuki := (stk.next())->toInteger() ; 
    nichi := (stk.next())->toInteger() ; 
    if (tsuki = 0 & nichi = 0) then ( OclProcess.exit(0) ) else skip ; 
    if (tsuki = 1) then (     nissuu := nichi ) else (         var i : int ; i := 0 ; while i <= tsuki - 2 do ( (     nissuu := nissuu+(month[i+1]) )  ;     i := i + 1 ) ; 
     nissuu := nissuu+(nichi) ) ;  
    motomeru := (youbi + nissuu) mod 7 ; 
    if (motomeru = 0) then (     OclFile["System.out"].println("Sunday") ) else     if (motomeru = 1) then (     OclFile["System.out"].println("Monday") ) else     if (motomeru = 2) then (     OclFile["System.out"].println("Tuesday") ) else     if (motomeru = 3) then (     OclFile["System.out"].println("Wednesday") ) else     if (motomeru = 4) then (     OclFile["System.out"].println("Thursday") ) else     if (motomeru = 5) then (     OclFile["System.out"].println("Friday") ) else     if (motomeru = 6) then (     OclFile["System.out"].println("Saturday") ) else skip ; ;  ;  ;  ;  ;  ;  
 )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int checkIfAllVowels(String str){
    int[] hash=new int[5];
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)=='A' || str.charAt(i)=='a')hash[0]=1 ;
      else if(str.charAt(i)=='E' || str.charAt(i)=='e')hash[1]=1 ;
      else if(str.charAt(i)=='I' || str.charAt(i)=='i')hash[2]=1 ;
      else if(str.charAt(i)=='O' || str.charAt(i)=='o')hash[3]=1 ;
      else if(str.charAt(i)=='U' || str.charAt(i)=='u')hash[4]=1 ;
    }
    for(int i=0 ; i<5 ; i++){
      if(hash[i]==0){
        return 1 ;
      }
    }
    return 0 ;
  }
  static void checkIfAllVowelsArePresent(String str){
    if(checkIfAllVowels(str)==1)System.out.print("Not Accepted\n");
    else System.out.print("Accepted\n");
  }
  public static void main(String[] args){
    String str="aeioubc" ;
    checkIfAllVowelsArePresent(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkIfAllVowels( str : String) : int
  pre: true
  post: true
  activity: (     var hash : Sequence(int) ; hash := Integer.subrange(1,5)->collect(0) ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = 'A' or str->at(i+1) = 'a') then     hash[0+1] := 1 ; else     if (str->at(i+1) = 'E' or str->at(i+1) = 'e') then     hash[1+1] := 1 else     if (str->at(i+1) = 'I' or str->at(i+1) = 'i') then     hash[2+1] := 1 else     if (str->at(i+1) = 'O' or str->at(i+1) = 'o') then     hash[3+1] := 1 else     if (str->at(i+1) = 'U' or str->at(i+1) = 'u') then     hash[4+1] := 1 ; else skip ; ;  ;  ;  )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < 5 do ( (     if (hash[i+1] = 0) then (     return 1 ) else skip )  ;     i := i + 1 ) ; 
     return 0 );
  static   operation checkIfAllVowelsArePresent( str : String) : void
  pre: true
  post: true
  activity: (     if (checkIfAllVowels(str) = 1) then     OclFile["System.out"].print("Not Accepted\n") ; else     OclFile["System.out"].print("Accepted\n") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "aeioubc" ;
     execute checkIfAllVowelsArePresent(str) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float find_Area(float a){
    float R=a*(float)(2.0-Math.sqrt(2));
    float area=(float)((3.14*R*R)/2.0);
    return area ;
  }
  public static void main(String[] args){
    float a=4 ;
    System.out.println(" Area of semicircle="+find_Area(a));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find_Area( a : double) : double
  pre: true
  post: true
  activity: (     var R : double ; R := a * (2.0 - (2)->sqrt())->oclAsType(double) ;
     var area : double ; area := ((3.14 * R * R) / 2.0)->oclAsType(double) ;
     return area );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 4 ;
     OclFile["System.out"].println(" Area of semicircle=" + find_Area(a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void D_Pattern(int n){
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<=n ; j++){
        if(j==1 ||((i==0 || i==n-1)&&(j>1 && j<n-2))||(j==n-2 && i!=0 && i!=n-1))System.out.print("*");
        else System.out.print(" ");
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    int n=9 ;
    D_Pattern(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation D_Pattern( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j <= n do ( (     if (j = 1 or ((i = 0 or i = n - 1) & (j > 1 & j < n - 2)) or (j = n - 2 & i /= 0 & i /= n - 1)) then     OclFile["System.out"].print("*") ; else     OclFile["System.out"].print(" ") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     execute D_Pattern(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.abs ;
import java.util.Scanner ;
public class Unlucky160B {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String s=in.next();
    int s1[]=new int[n];
    int s2[]=new int[n];
    for(int i=0 ; i<n ; i++){
      s1[i]=Integer.parseInt(s.valueOf(s.charAt(i)));
    }
    for(int i=n,j=0 ; i<2*n ; i++,j++){
      s2[j]=Integer.parseInt(s.valueOf(s.charAt(i)));
    }
    for(int i=0 ; i<n ; i++){
      for(int j=1 ; j<n ; j++){
        if(s1[j-1]>s1[j]){
          int tmp=s1[j-1];
          s1[j-1]=s1[j];
          s1[j]=tmp ;
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      for(int j=1 ; j<n ; j++){
        if(s2[j-1]>s2[j]){
          int tmp=s2[j-1];
          s2[j-1]=s2[j];
          s2[j]=tmp ;
        }
      }
    }
    int x=0 ;
    for(int i=0 ; i<n ; i++){
      if(s1[i]>s2[i])x++;
      else if(s1[i]<s2[i])x--;
    }
    if(abs(x)==n)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Unlucky160B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var s1 : Sequence(int) ; s1 := Integer.subrange(1,n)->collect(0) ;
    var s2 : Sequence(int) ; s2 := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s1[i+1] := (s.valueOf(s->at(i+1)))->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := n ;
    var j : int ; j := 0 ; while i < 2 * n do ( (     s2[j+1] := (s.valueOf(s->at(i+1)))->toInteger() )  ;     i := i + 1 ;     j := j + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 1 ; while j < n do ( (     if (s1[j - 1+1] > s1[j+1]) then (     var tmp : int ; tmp := s1[j - 1+1] ;
     s1[j - 1+1] := s1[j+1] ; 
     s1[j+1] := tmp ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 1 ; while j < n do ( (     if (s2[j - 1+1] > s2[j+1]) then (     var tmp : int ; tmp := s2[j - 1+1] ;
     s2[j - 1+1] := s2[j+1] ; 
     s2[j+1] := tmp ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s1[i+1] > s2[i+1]) then     x := x + 1 ; else     if (s1[i+1] < s2[i+1]) then     x := x - 1 ; else skip ; )  ;     i := i + 1 ) ; 
    if (abs(x) = n) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Ideone {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int count=0 ;
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    int max=a[0];
    int min=a[0];
    for(int i=0 ; i<n ; i++){
      if(max<a[i]){
        max=a[i];
        count++;
      }
      if(min>a[i]){
        min=a[i];
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ideone {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var max : int ; max := a[0+1] ;
    var min : int ; min := a[0+1] ;
        var i : int ; i := 0 ; while i < n do ( (     if (max < a[i+1]) then (     max := a[i+1] ; 
     count := count + 1 ) else skip ; 
     if (min > a[i+1]) then (     min := a[i+1] ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    OutputStreamWriter osr=new OutputStreamWriter(System.out);
    PrintWriter out=new PrintWriter(osr);
    FastReader fr=new FastReader();
    int n=fr.nextInt(),max=0,min=0,ans=0 ;
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=fr.nextInt();
      if(i==0){
        max=arr[0];
        min=arr[0];
      }
      else {
        if(arr[i]>max){
          max=arr[i];
          ans++;
        }
        if(arr[i]<min){
          min=arr[i];
          ans++;
        }
      }
    }
    out.print(ans);
    out.close();
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    InputStreamReader isr=new InputStreamReader(System.in);
    br=new BufferedReader(isr);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String nextLine()throws IOException {
    return br.readLine();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public int[] intArray(int size)throws IOException {
    int[] arr=new int[size];
    for(int i=0 ; i<size ; i++)arr[i]=nextInt();
    return arr ;
  }
  public char[] charArray()throws IOException {
    return nextLine().toCharArray();
  }
}
class Pair {
  int d ;
  int k ;
  public Pair(int d,int k){
    this.d=d ;
    this.k=k ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var osr : OclFile ; osr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(osr) ;
    var fr : FastReader ; fr := FastReader.newFastReader() ;
    var n : int ; n := fr.nextInt() ;
    var max : int ; max := 0 ;
    var min : int ; min := 0 ;
    var ans : int ; ans := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := fr.nextInt() ; 
     if (i = 0) then (     max := arr[0+1] ; 
     min := arr[0+1] ) else (     if (arr[i+1] > max) then (     max := arr[i+1] ; 
     ans := ans + 1 ) else skip ; 
     if (arr[i+1] < min) then (     min := arr[i+1] ; 
     ans := ans + 1 ) else skip ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     br := OclFile.newOclFile_Read(isr) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation intArray( size : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < size do (     arr[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return arr );
   operation charArray() : Sequence(String)
  pre: true
  post: true
  activity: (     return nextLine()->characters() );
}
class Pair {
   attribute d : int;
   attribute k : int;
   static operation newPair( d : int, k : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(d, k);
    return self );
  operation initialise( d : int, k : int) : void
  pre: true  post: true
  activity: (     self.d := d ; 
     self.k := k );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int b=sc.nextInt();
    int sum1=sc.nextInt();
    int sum2=sum1 ;
    int sum=0 ;
    for(int i=1 ; i<b ; i++){
      int a=sc.nextInt();
      if(a>sum1){
        sum1=a ;
        sum++;
      }
      if(a<sum2){
        sum2=a ;
        sum++;
      }
    }
    System.out.print(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var b : int ; b := sc.getCurrent()->toInteger() ;
     var sum1 : int ; sum1 := sc.getCurrent()->toInteger() ;
    var sum2 : int ; sum2 := sum1 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 1 ; while i < b do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (a > sum1) then (     sum1 := a ; 
     sum := sum + 1 ) else skip ; 
     if (a < sum2) then (     sum2 := a ; 
     sum := sum + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.String ;
import java.util.Arrays ;
public class BoyOrGirl {
  public static void main(String[] args){
    String s,a ;
    Scanner sc=new Scanner(System.in);
    s=sc.next();
    int i,count=1,len=s.length();
    char[] ch=s.toCharArray();
    Arrays.sort(ch);
    for(i=1 ; i<len ; i++){
      if(ch[i-1]!=ch[i])count++;
    }
    if((count)% 2==0)System.out.println("CHAT WITH HER!");
    else System.out.println("IGNORE HIM!");
  }
}
------------------------------------------------------------
OCL File:
---------
 class BoyOrGirl {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ;
    var a : String ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    s := sc.getCurrent() ; 
    var i : int ;
    var count : int ; count := 1 ;
    var len : int ; len := s->size() ;
    var ch : Sequence(String) ; ch := s->characters() ;
    ch := ch->sort() ; 
        i := 1 ; while i < len do ( (     if (ch[i - 1+1] /= ch[i+1]) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    if ((count) mod 2 = 0) then     OclFile["System.out"].println("CHAT WITH HER!") else     OclFile["System.out"].println("IGNORE HIM!") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cdfrc_14_BoyOrGirl {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    String user=scn.next();
    String[] arr=user.split("",-1);
    Arrays.sort(arr);
    int count=0 ;
    for(int x=0 ; x<user.length(); x++){
      if(arr[x] .equals(arr[x+1])){
        count++;
      }
    }
    int calculation=user.length()-count ;
    if(calculation % 2==0){
      System.out.println("CHAT WITH HER!");
    }
    else {
      System.out.println("IGNORE HIM!");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cdfrc_14_BoyOrGirl {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var user : String ; user := scn.getCurrent() ;
    var arr : Sequence(String) ; arr := user->split("") ;
    arr := arr->sort() ; 
    var count : int ; count := 0 ;
        var x : int ; x := 0 ; while x < user->size() do ( (     if (arr[x+1] = arr[x + 1+1]) then (     count := count + 1 ) else skip )  ;     x := x + 1 ) ; 
    var calculation : int ; calculation := user->size() - count ;
    if (calculation mod 2 = 0) then (     OclFile["System.out"].println("CHAT WITH HER!") ) else (     OclFile["System.out"].println("IGNORE HIM!") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.HashSet ;
import java.util.Set ;
import java.util.StringTokenizer ;
public class BoyOrGirl {
  public static void main(String[] args)throws IOException {
    Set<Character>set=new HashSet<>();
    FastIO io=new FastIO();
    String s=io.next();
    for(int i=0 ; i<s.length(); i++){
      set.add(s.charAt(i));
    }
    if(set.size()% 2==0){
      io.println("CHAT WITH HER!");
    }
    else {
      io.println("IGNORE HIM!");
    }
    io.close();
  }
  static class FastIO extends PrintWriter {
    private BufferedReader br ;
    private StringTokenizer st ;
    public FastIO(){
      this(System.in,System.out);
    }
    public FastIO(InputStream in,OutputStream out){
      super(out);
      br=new BufferedReader(new InputStreamReader(in));
    }
    public FastIO(String problemName)throws IOException {
      super(new FileWriter(problemName+".out"));
      br=new BufferedReader(new FileReader(problemName+".in"));
    }
    public String next(){
      try {
        while(st==null || ! st.hasMoreTokens()){
          st=new StringTokenizer(br.readLine());
        }
        return st.nextToken();
      }
      catch(Exception e){
      }
      return null ;
    }
    public String nextLine(){
      try {
        return br.readLine();
      }
      catch(Exception e){
      }
      return null ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public boolean nextBoolean(){
      return Boolean.parseBoolean(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BoyOrGirl {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var set : Set(String) ; set := Set{} ;
     var io : FastIO ; io := FastIO.newFastIO() ;
    var s : String ; s := io.next() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     set := set->including(s->at(i+1)) )  ;     i := i + 1 ) ; 
    if (set->size() mod 2 = 0) then (     io.println("CHAT WITH HER!") ) else (     io.println("IGNORE HIM!") ) ;  
    io.close() ; 
 );
  static class FastIO extends OclFile {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastIO() : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile["System.in"], OclFile["System.out"]) );
   static operation newFastIO( in : OclFile, out : OclFile) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(in, out);
    return self );
  operation initialise( in : OclFile, out : OclFile) : void
  pre: true  post: true
  activity: (     execute super(out) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   static operation newFastIO( problemName : String) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(problemName);
    return self );
  operation initialise( problemName : String) : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Write(problemName + ".out")) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(problemName + ".in")) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() )   catch (e : ProgramException) do skip
     return null );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : ProgramException) do skip
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextBoolean() : boolean
  pre: true
  post: true
  activity: (     return parseBoolean(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.ArrayList ;
public class CodeForces {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s=br.readLine();
    ArrayList<Character>a=new ArrayList<Character>();
    for(int i=0 ; i<s.length(); i++){
      if(! a.contains(s.charAt(i)))a.add(s.charAt(i));
    }
    if(a.size()% 2==0)System.out.println("CHAT WITH HER!");
    else System.out.println("IGNORE HIM!");
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := br.readLine() ;
    var a : Sequence(String) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (not(a->includes(s->at(i+1)))) then     a := a->including(s->at(i+1)) ; else skip )  ;     i := i + 1 ) ; 
    if (a->size() mod 2 = 0) then     OclFile["System.out"].println("CHAT WITH HER!") else     OclFile["System.out"].println("IGNORE HIM!") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class DkdlpdDffff {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    char[] arr=s.toCharArray();
    Arrays.sort(arr);
    int count=0 ;
    for(int i=0 ; i<arr.length-1 ; i++){
      if(arr[i]!=arr[i+1])count++;
    }
    count++;
    if(count % 2==0)System.out.println("CHAT WITH HER!");
    else System.out.println("IGNORE HIM!");
  }
}
------------------------------------------------------------
OCL File:
---------
 class DkdlpdDffff {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
    var arr : Sequence(String) ; arr := s->characters() ;
    arr := arr->sort() ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < arr->size() - 1 do ( (     if (arr[i+1] /= arr[i + 1+1]) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    count := count + 1 ; 
    if (count mod 2 = 0) then     OclFile["System.out"].println("CHAT WITH HER!") else     OclFile["System.out"].println("IGNORE HIM!") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static int find_value(int a[],int n,int k){
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=a[i];
    }
    return sum % k ;
  }
  public static void main(String[] args){
    int n=5,k=3 ;
    int a[]={
      12,4,13,0,5 };
      System.out.println(find_value(a,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find_value( a : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
     return sum mod k );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var k : int ; k := 3 ;
     var a : Sequence(int) ; a := Sequence{12,4,13,0,5} ;
     OclFile["System.out"].println(find_value(a, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void kthString(int n,int k){
    int total=0 ;
    int i=1 ;
    while(total<k){
      total=total+n-i ;
      i++;
    }
    int first_y_position=i-1 ;
    int second_y_position=k-(total-n+first_y_position);
    for(int j=1 ; j<first_y_position ; j++)System.out.print("x");
    System.out.print("y");
    int j=first_y_position+1 ;
    while(second_y_position>1){
      System.out.print("x");
      second_y_position--;
      j++;
    }
    System.out.print("y");
    while(j<n){
      System.out.print("x");
      j++;
    }
  }
  public static void main(String[] args){
    int n=5 ;
    int k=7 ;
    kthString(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation kthString( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var total : int ; total := 0 ;
     var i : int ; i := 1 ;
    while (total < k) do (     total := total + n - i ; 
     i := i + 1 ) ; 
    var first_y_position : int ; first_y_position := i - 1 ;
    var second_y_position : int ; second_y_position := k - (total - n + first_y_position) ;
        var j : int ; j := 1 ; while j < first_y_position do (     OclFile["System.out"].print("x") ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].print("y") ; 
    var j : int ; j := first_y_position + 1 ;
    while (second_y_position > 1) do (     OclFile["System.out"].print("x") ; 
     second_y_position := second_y_position - 1 ; 
     j := j + 1 ) ; 
    OclFile["System.out"].print("y") ; 
    while (j < n) do (     OclFile["System.out"].print("x") ; 
     j := j + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var k : int ; k := 7 ;
     execute kthString(n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void CountingEvenOdd(int arr[],int arr_size){
    int even_count=0 ;
    int odd_count=0 ;
    for(int i=0 ; i<arr_size ; i++){
      if((arr[i] & 1)==1)odd_count++;
      else even_count++;
    }
    System.out.println("Number of even"+" elements="+even_count+" Number of odd elements="+odd_count);
  }
  public static void main(String[] args){
    int arr[]={
      2,3,4,5,6 };
      int n=arr.length ;
      CountingEvenOdd(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation CountingEvenOdd( arr : Sequence(int), arr_size : int) : void
  pre: true
  post: true
  activity: (     var even_count : int ; even_count := 0 ;
     var odd_count : int ; odd_count := 0 ;
         var i : int ; i := 0 ; while i < arr_size do ( (     if ((arr[i+1] & 1) = 1) then     odd_count := odd_count + 1 ; else     even_count := even_count + 1 ; )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Number of even" + " elements=" + even_count + " Number of odd elements=" + odd_count) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4,5,6} ;
     var n : int ; n := arr->size() ;
     execute CountingEvenOdd(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sc.nextInt();
    String ticket=sc.next();
    System.out.println(solve(ticket)? "YES" : "NO");
    sc.close();
  }
  static boolean solve(String ticket){
    int[] sortedLeft=IntStream.range(0,ticket.length()/2).map(i->ticket.charAt(i)-'0').sorted().toArray();
    int[] sortedRight=IntStream.range(ticket.length()/2,ticket.length()).map(i->ticket.charAt(i)-'0').sorted().toArray();
    return IntStream.range(0,sortedLeft.length).allMatch(i->sortedLeft[i]<sortedRight[i])|| IntStream.range(0,sortedLeft.length).allMatch(i->sortedLeft[i]>sortedRight[i]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var ticket : String ; ticket := sc.getCurrent() ;
    OclFile["System.out"].println(if solve(ticket) then "YES" else "NO" endif) ; 
    skip ; 
 );
  static   operation solve( ticket : String) : boolean
  pre: true
  post: true
  activity: (     var sortedLeft : Sequence(int) ; sortedLeft := Integer.subrange(0, ticket->size() / 2-1)->collect( _x1 | (lambda i : OclAny in ticket->at(i+1) - ('0')->char2byte())->apply(_x1) )->sort()->asSequence() ;
     var sortedRight : Sequence(int) ; sortedRight := Integer.subrange(ticket->size() / 2, ticket->size()-1)->collect( _x1 | (lambda i : OclAny in ticket->at(i+1) - ('0')->char2byte())->apply(_x1) )->sort()->asSequence() ;
     return Integer.subrange(0, sortedLeft->size()-1)->forAll( _x2 | (lambda i : OclAny in sortedLeft[i+1] < sortedRight[i+1])->apply(_x2) ) or Integer.subrange(0, sortedLeft->size()-1)->forAll( _x2 | (lambda i : OclAny in sortedLeft[i+1] > sortedRight[i+1])->apply(_x2) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float harmonicMean(float arr[],int n){
    float sum=0 ;
    for(int i=0 ; i<n ; i++)sum=sum+(float)1/arr[i];
    return(float)n/sum ;
  }
  public static void main(String args[]){
    float arr[]={
      13.5f,14.5f,14.8f,15.2f,16.1f };
      int n=arr.length ;
      System.out.println(harmonicMean(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation harmonicMean( arr : Sequence(double), n : int) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum + 1->oclAsType(double) / arr[i+1] ;  ;     i := i + 1 ) ; 
     return n->oclAsType(double) / sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(double) ; arr := Sequence{13.5f,14.5f,14.8f,15.2f,16.1f} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(harmonicMean(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class YetAnotherCrossesPlatform {
  private static Scanner sc=new Scanner(System.in);
  private static void solve(){
    int n,m ;
    int[] rows,cols ;
    String[] arr ;
    String s ;
    n=sc.nextInt();
    m=sc.nextInt();
    rows=new int[n];
    cols=new int[m];
    arr=new String[n];
    for(int i=0 ; i<n ; i++){
      s=sc.next();
      arr[i]=s ;
      for(int j=0 ; j<m ; j++){
        if(s.charAt(j)=='*'){
          rows[i]++;
          cols[j]++;
        }
      }
    }
    int min=Integer.MAX_VALUE ;
    int res ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        res=n-rows[i]+m-cols[j];
        if(arr[i] .charAt(j)=='.')res--;
        if(res<min)min=res ;
      }
    }
    System.out.println(min);
  }
  public static void main(String[] args){
    int t=sc.nextInt();
    while(t-->0){
      solve();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class YetAnotherCrossesPlatform {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ;
    var m : int ;
     var rows : Sequence(int) ;
    var cols : Sequence(int) ;
    var arr : Sequence(String) ;
    var s : String ;
    n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
    rows := Integer.subrange(1,n)->collect(0) ; 
    cols := Integer.subrange(1,m)->collect(0) ; 
    arr := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do ( (     s := sc.getCurrent() ; 
     arr[i+1] := s ; 
         var j : int ; j := 0 ; while j < m do ( (     if (s->at(j+1) = '*') then (     rows[i+1] := rows[i+1] + 1 ; 
     cols[j+1] := cols[j+1] + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
    var res : int ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     res := n - rows[i+1] + m - cols[j+1] ; 
     if (arr[i+1]->at(j+1) = '.') then     res := res - 1 ; else skip ; 
     if (res < min) then     min := res ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void maxLengthSubSeq(int a[],int n){
    int temp[]=new int[n];
    int print[]=new int[n];
    int y=0 ;
    for(int i=0 ; i<n ; i++){
      int j=0 ;
      int x=0 ;
      temp[j++]=a[x];
      x=a[x]+x ;
      while(x<n){
        temp[j++]=a[x];
        x=a[x]+x ;
      }
      if(y<j){
        for(int k=0 ; k<j ; k++){
          print[k]=temp[k];
          y=j ;
        }
      }
    }
    for(int i=0 ; i<y ; i++)System.out.print(print[i]+" ");
  }
  public static void main(String[] args){
    int a[]={
      1,2,3,4,5 };
      int n=a.length ;
      maxLengthSubSeq(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxLengthSubSeq( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(int) ; temp := Integer.subrange(1,n)->collect(0) ;
     var print : Sequence(int) ; print := Integer.subrange(1,n)->collect(0) ;
    var y : int ; y := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var j : int ; j := 0 ;
     var x : int ; x := 0 ;
     temp[j+1] := a[x+1]  ; j := j + 1 ; 
    x := a[x+1] + x ; 
    while (x < n) do (      temp[j+1] := a[x+1]  ; j := j + 1 ; 
     x := a[x+1] + x ) ; 
    if (y < j) then (         var k : int ; k := 0 ; while k < j do ( (     print[k+1] := temp[k+1] ; 
     y := j )  ;     k := k + 1 ) ) else skip ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < y do (     OclFile["System.out"].print(print[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,4,5} ;
     var n : int ; n := a->size() ;
     execute maxLengthSubSeq(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class DisJoinSetUnion {
  public int[] upper ;
  public DisJoinSetUnion(int n){
    upper=new int[n];
    Arrays.fill(upper,-1);
  }
  public int root(int x){
    return upper[x]<0 ? x :(upper[x]=root(upper[x]));
  }
  public boolean equiv(int x,int y){
    return root(x)==root(y);
  }
  public boolean MergeGroup(int x,int y){
    x=root(x);
    y=root(y);
    if(x!=y){
      if(upper[y]<upper[x]){
        int d=x ;
        x=y ;
        y=d ;
      }
      upper[x]+=upper[y];
      upper[y]=x ;
    }
    return x==y ;
  }
  public int count(){
    int ct=0 ;
    for(int u : upper)if(u<0)ct++;
    return ct-1 ;
  }
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    try(PrintWriter or=new PrintWriter(System.out)){
      int n=in.nextInt();
      int m=in.nextInt();
      int q=in.nextInt();
      DisJoinSetUnion d=new DisJoinSetUnion(n+m);
      for(int i=0 ; i<q ; i++){
        d.MergeGroup(in.nextInt()-1,in.nextInt()+n-1);
      }
      or.print(d.count());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DisJoinSetUnion {
   attribute upper : Sequence(int);
   static operation newDisJoinSetUnion( n : int) : DisJoinSetUnion
  pre: true
  post: true
  activity:
  ( var self : DisJoinSetUnion ;
    self := createDisJoinSetUnion();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     upper := Integer.subrange(1,n)->collect(0) ; 
     upper := upper->collect(-1) );
   operation root( x : int) : int
  pre: true
  post: true
  activity: (     return if upper[x+1] < 0 then x else (upper[x+1]) endif );
   operation equiv( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return root(x) = root(y) );
   operation MergeGroup( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     x := root(x) ; 
     y := root(y) ; 
     if (x /= y) then (     if (upper[y+1] < upper[x+1]) then (     var d : int ; d := x ;
     x := y ; 
     y := d ) else skip ; 
     upper[x+1] := upper[x+1]+(upper[y+1]) ; 
     upper[y+1] := x ) else skip ; 
     return x = y );
   operation count() : int
  pre: true
  post: true
  activity: (     var ct : int ; ct := 0 ;
     for (u : upper) do (     if (u < 0) then     ct := ct + 1 ; else skip ;  ) ; 
     return ct - 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     try (    var or : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]) ;
 (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var q : int ; q := in.getCurrent()->toInteger() ;
    var d : DisJoinSetUnion ; d := DisJoinSetUnion.newDisJoinSetUnion(n + m) ;
        var i : int ; i := 0 ; while i < q do ( (     d.MergeGroup(in.getCurrent()->toInteger() - 1, in.getCurrent()->toInteger() + n - 1) )  ;     i := i + 1 ) ; 
    skip ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class ChemicalTable {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int[] params=Arrays.stream(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    int n=params[0];
    int m=params[1];
    int q=params[2];
    Node[] graph=new Node[n+m];
    for(int i=0 ; i<graph.length ; i++){
      graph[i]=new Node();
    }
    for(int i=0 ; i<q ; i++){
      String[] inds=br.readLine().split(" ");
      Node a=graph[Integer.parseInt(inds[0])-1];
      Node b=graph[n+Integer.parseInt(inds[1])-1];
      a.connected.add(b);
      b.connected.add(a);
    }
    int count=-1 ;
    for(int i=0 ; i<graph.length ; i++){
      if(! graph[i] .seen){
        count++;
        graph[i] .dfs();
      }
    }
    System.out.println(count);
  }
  public static class Node {
    ArrayList<Node>connected=new ArrayList<>();
    boolean seen=false ;
    void dfs(){
      seen=true ;
      for(Node c : connected){
        if(! c.seen){
          c.dfs();
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ChemicalTable {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var params : Sequence(int) ; params := stream(br.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var n : int ; n := params[0+1] ;
    var m : int ; m := params[1+1] ;
    var q : int ; q := params[2+1] ;
    var graph : Sequence(Node) ; graph := Integer.subrange(1,n + m)->collect(null) ;
        var i : int ; i := 0 ; while i < graph->size() do ( (     graph[i+1] := Node.newNode() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var inds : Sequence(String) ; inds := br.readLine()->split(" ") ;
     var a : Node ; a := graph[(inds[0+1])->toInteger() - 1+1] ;
    var b : Node ; b := graph[n + (inds[1+1])->toInteger() - 1+1] ;
    a.connected->excludes(b) ; 
    b.connected->excludes(a) ; 
 )  ;     i := i + 1 ) ; 
    var count : int ; count := -1 ;
        var i : int ; i := 0 ; while i < graph->size() do ( (     if (not(graph[i+1].seen)) then (     count := count + 1 ; 
     graph[i+1].dfs() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static class Node {
   attribute connected : Sequence(Node) := Sequence{};
   attribute seen : boolean := false;
   operation dfs() : void
  pre: true
  post: true
  activity: (     seen := true ; 
     for (c : connected) do ( (     if (not(c.seen)) then (     c.dfs() ) else skip )  ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.util.Date ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeSet ;
public class Problem_1013D {
  public static int find(int x,int[] arr){
    if(arr[x]==x)return x ;
    arr[x]=find(arr[x],arr);
    return arr[x];
  }
  public static void join(int x,int y,int[] arr){
    int a=find(x,arr);
    int b=find(y,arr);
    if(a!=b)arr[a]=b ;
  }
  public static int[] initDisjointSet(int size){
    int[] arr=new int[size];
    for(int i=0 ; i<arr.length ; i++)arr[i]=i ;
    return arr ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(new BufferedInputStream(System.in));
    while(in.hasNext()){
      int n=in.nextInt();
      int m=in.nextInt();
      int q=in.nextInt();
      int[] a=initDisjointSet(n+m+1);
      for(int i=0 ; i<q ; i++){
        int ri=in.nextInt();
        int ci=in.nextInt()+n ;
        join(ri,ci,a);
      }
      Set<Integer>set=new HashSet<>();
      for(int i=1 ; i<=n+m ; i++){
        set.add(find(a[i],a));
      }
      System.out.println(set.size()-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem_1013D {
  static   operation find( x : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (arr[x+1] = x) then     return x else skip ; 
     arr[x+1] := find(arr[x+1], arr) ; 
     return arr[x+1] );
  static   operation join( x : int, y : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := find(x, arr) ;
     var b : int ; b := find(y, arr) ;
     if (a /= b) then     arr[a+1] := b ; else skip );
  static   operation initDisjointSet( size : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < arr->size() do (     arr[i+1] := i ;  ;     i := i + 1 ) ; 
     return arr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (in.hasNext()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var q : int ; q := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := initDisjointSet(n + m + 1) ;
        var i : int ; i := 0 ; while i < q do ( (     var ri : int ; ri := in.getCurrent()->toInteger() ;
     var ci : int ; ci := in.getCurrent()->toInteger() + n ;
     execute join(ri, ci, a) )  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 1 ; while i <= n + m do ( (     set := set->including(find(a[i+1], a)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(set->size() - 1) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws java.io.IOException {
    Scanner sc=new Scanner(System.in);
    while(true){
      boolean map[][]=new boolean[21][21];
      int n=sc.nextInt();
      if(n==0)break ;
      for(int i=0 ; i<n ; i++){
        map[sc.nextInt()][sc.nextInt()]=true ;
      }
      int m=sc.nextInt();
      int x=10 ;
      int y=10 ;
      int ans=0 ;
      if(map[x][y])ans++;
      for(int i=0 ; i<m ; i++){
        char d=sc.next().charAt(0);
        int mov=sc.nextInt();
        switch(d){
          case 'N' : for(int j=0 ;
          j<mov ;
          j++){
            y++;
            if(map[x][y]){
              ans++;
              map[x][y]=false ;
            }
          }
          break ;
          case 'W' : for(int j=0 ;
          j<mov ;
          j++){
            x--;
            if(map[x][y]){
              ans++;
              map[x][y]=false ;
            }
          }
          break ;
          case 'E' : for(int j=0 ;
          j<mov ;
          j++){
            x++;
            if(map[x][y]){
              ans++;
              map[x][y]=false ;
            }
          }
          break ;
          case 'S' : for(int j=0 ;
          j<mov ;
          j++){
            y--;
            if(map[x][y]){
              ans++;
              map[x][y]=false ;
            }
          }
          break ;
        }
      }
      if(ans==n)System.out.println("Yes");
      else System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var map : Sequence(Sequence(boolean)) ; map := Integer.subrange(1,21)->collect(Integer.subrange(1,21)->collect(false)) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    if (n = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     map[sc.getCurrent()->toInteger()+1][sc.getCurrent()->toInteger()+1] := true )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : int ; x := 10 ;
    var y : int ; y := 10 ;
    var ans : int ; ans := 0 ;
    if (map[x+1][y+1]) then     ans := ans + 1 ; else skip ; 
        var i : int ; i := 0 ; while i < m do ( (     var d : String ; d := sc.getCurrent()->at(0+1) ;
     var mov : int ; mov := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (d) ; 
       if _switchval = 'N' then
         var j : int ; j := 0 ; while j < mov do ( (     y := y + 1 ; 
     if (map[x+1][y+1]) then (     ans := ans + 1 ; 
     map[x+1][y+1] := false ) else skip )  ;     j := j + 1 ) ; 
    break 
   else skip ;
       if _switchval = 'W' then
         var j : int ; j := 0 ; while j < mov do ( (     x := x - 1 ; 
     if (map[x+1][y+1]) then (     ans := ans + 1 ; 
     map[x+1][y+1] := false ) else skip )  ;     j := j + 1 ) ; 
    break 
   else skip ;
       if _switchval = 'E' then
         var j : int ; j := 0 ; while j < mov do ( (     x := x + 1 ; 
     if (map[x+1][y+1]) then (     ans := ans + 1 ; 
     map[x+1][y+1] := false ) else skip )  ;     j := j + 1 ) ; 
    break 
   else skip ;
       if _switchval = 'S' then
         var j : int ; j := 0 ; while j < mov do ( (     y := y - 1 ; 
     if (map[x+1][y+1]) then (     ans := ans + 1 ; 
     map[x+1][y+1] := false ) else skip )  ;     j := j + 1 ) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    if (ans = n) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int binomialCoeff(int n,int k){
    int[] C=new int[k+1];
    C[0]=1 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=Math.min(i,k); j>0 ; j--)C[j]=C[j]+C[j-1];
    }
    return C[k];
  }
  static int count_of_subarrays(int N){
    int count=binomialCoeff(2*N-1,N);
    return count ;
  }
  public static void main(String[] args){
    int N=3 ;
    System.out.print(count_of_subarrays(N)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation binomialCoeff( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var C : Sequence(int) ; C := Integer.subrange(1,k + 1)->collect(0) ;
     C[0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := Set{i, k}->min() ; while j > 0 do (     C[j+1] := C[j+1] + C[j - 1+1] ;  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
     return C[k+1] );
  static   operation count_of_subarrays( N : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := binomialCoeff(2 * N - 1, N) ;
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
     OclFile["System.out"].print(count_of_subarrays(N) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void print(int[][] a,int x,int y){
    for(int i=0 ; i<21 ; i++){
      for(int j=0 ; j<21 ; j++){
        if(i==y && j==x){
          System.out.print("@");
        }
        else {
          System.out.print(a[i][j]==0 ? "^" : "*");
        }
      }
      System.out.println();
    }
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int[] dx=new int['Z'];
    int[] dy=new int['Z'];
    dx['E']=1 ;
    dx['W']=-1 ;
    dy['N']=1 ;
    dy['S']=-1 ;
    while(true){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      int[][] a=new int[21][21];
      for(int i=0 ; i<n ; i++){
        int kx=sc.nextInt();
        int ky=sc.nextInt();
        a[ky][kx]=1 ;
      }
      int m=sc.nextInt();
      int x=10,y=10,sum=0 ;
      for(int i=0 ; i<m ; i++){
        char d=sc.next().toCharArray()[0];
        int l=sc.nextInt();
        for(int j=0 ; j<l ; j++){
          sum+=a[y][x];
          a[y][x]=0 ;
          x+=dx[d];
          y+=dy[d];
        }
        sum+=a[y][x];
        a[y][x]=0 ;
      }
      System.out.println(sum==n ? "Yes" : "No");
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation print( a : Sequence(Sequence(int)), x : int, y : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 21 do ( (         var j : int ; j := 0 ; while j < 21 do ( (     if (i = y & j = x) then (     OclFile["System.out"].print("@") ) else (     OclFile["System.out"].print(if a[i+1][j+1] = 0 then "^" else "*" endif) ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dx : Sequence(int) ; dx := Integer.subrange(1,'Z')->collect(0) ;
    var dy : Sequence(int) ; dy := Integer.subrange(1,'Z')->collect(0) ;
    dx['E'+1] := 1 ; 
    dx['W'+1] := -1 ; 
    dy['N'+1] := 1 ; 
    dy['S'+1] := -1 ; 
    while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,21)->collect(Integer.subrange(1,21)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var kx : int ; kx := sc.getCurrent()->toInteger() ;
     var ky : int ; ky := sc.getCurrent()->toInteger() ;
     a[ky+1][kx+1] := 1 )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : int ; x := 10 ;
    var y : int ; y := 10 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var d : String ; d := sc.getCurrent()->characters()[0+1] ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
        var j : int ; j := 0 ; while j < l do ( (     sum := sum+(a[y+1][x+1]) ; 
     a[y+1][x+1] := 0 ; 
     x := x+(dx[d+1]) ; 
     y := y+(dy[d+1]) )  ;     j := j + 1 ) ; 
    sum := sum+(a[y+1][x+1]) ; 
    a[y+1][x+1] := 0 ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if sum = n then "Yes" else "No" endif) ; 
 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    while(true){
      int[][] field=new int[21][21];
      int robotPositionYoko=10 ;
      int robotPositionTate=10 ;
      int jueleNumber=scan.nextInt();
      int juelePositionYoko ;
      int juelePositionTate ;
      if(jueleNumber==0)break ;
      for(int i=0 ; i<jueleNumber ; i++){
        juelePositionYoko=scan.nextInt();
        juelePositionTate=scan.nextInt();
        field[juelePositionYoko][juelePositionTate]=1 ;
      }
      int order=scan.nextInt();
      char direction ;
      int dirNumber ;
      for(int i=0 ; i<order ; i++){
        direction=scan.next().charAt(0);
        dirNumber=scan.nextInt();
        switch(direction){
          case 'N' : for(int j=0 ;
          j<dirNumber ;
          j++){
            robotPositionTate++;
            if(field[robotPositionYoko][robotPositionTate]==1)field[robotPositionYoko][robotPositionTate]=0 ;
          }
          break ;
          case 'E' : for(int j=0 ;
          j<dirNumber ;
          j++){
            robotPositionYoko++;
            if(field[robotPositionYoko][robotPositionTate]==1)field[robotPositionYoko][robotPositionTate]=0 ;
          }
          break ;
          case 'S' : for(int j=0 ;
          j<dirNumber ;
          j++){
            robotPositionTate--;
            if(field[robotPositionYoko][robotPositionTate]==1)field[robotPositionYoko][robotPositionTate]=0 ;
          }
          break ;
          case 'W' : for(int j=0 ;
          j<dirNumber ;
          j++){
            robotPositionYoko--;
            if(field[robotPositionYoko][robotPositionTate]==1)field[robotPositionYoko][robotPositionTate]=0 ;
          }
          break ;
        }
      }
      int flag=0 ;
      for(int i=0 ; i<21 ; i++){
        for(int j=0 ; j<21 ; j++){
          if(field[i][j]==1)flag=1 ;
        }
      }
      if(flag==0){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var field : Sequence(Sequence(int)) ; field := Integer.subrange(1,21)->collect(Integer.subrange(1,21)->collect(0)) ;
     var robotPositionYoko : int ; robotPositionYoko := 10 ;
    var robotPositionTate : int ; robotPositionTate := 10 ;
    var jueleNumber : int ; jueleNumber := scan.getCurrent()->toInteger() ;
    var juelePositionYoko : int ;
    var juelePositionTate : int ;
    if (jueleNumber = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < jueleNumber do ( (     juelePositionYoko := scan.getCurrent()->toInteger() ; 
     juelePositionTate := scan.getCurrent()->toInteger() ; 
     field[juelePositionYoko+1][juelePositionTate+1] := 1 )  ;     i := i + 1 ) ; 
    var order : int ; order := scan.getCurrent()->toInteger() ;
    var direction : String ;
    var dirNumber : int ;
        var i : int ; i := 0 ; while i < order do ( (     direction := scan.getCurrent()->at(0+1) ; 
     dirNumber := scan.getCurrent()->toInteger() ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (direction) ; 
       if _switchval = 'N' then
         var j : int ; j := 0 ; while j < dirNumber do ( (     robotPositionTate := robotPositionTate + 1 ; 
     if (field[robotPositionYoko+1][robotPositionTate+1] = 1) then     field[robotPositionYoko+1][robotPositionTate+1] := 0 ; else skip )  ;     j := j + 1 ) ; 
    break 
   else skip ;
       if _switchval = 'E' then
         var j : int ; j := 0 ; while j < dirNumber do ( (     robotPositionYoko := robotPositionYoko + 1 ; 
     if (field[robotPositionYoko+1][robotPositionTate+1] = 1) then     field[robotPositionYoko+1][robotPositionTate+1] := 0 ; else skip )  ;     j := j + 1 ) ; 
    break 
   else skip ;
       if _switchval = 'S' then
         var j : int ; j := 0 ; while j < dirNumber do ( (     robotPositionTate := robotPositionTate - 1 ; 
     if (field[robotPositionYoko+1][robotPositionTate+1] = 1) then     field[robotPositionYoko+1][robotPositionTate+1] := 0 ; else skip )  ;     j := j + 1 ) ; 
    break 
   else skip ;
       if _switchval = 'W' then
         var j : int ; j := 0 ; while j < dirNumber do ( (     robotPositionYoko := robotPositionYoko - 1 ; 
     if (field[robotPositionYoko+1][robotPositionTate+1] = 1) then     field[robotPositionYoko+1][robotPositionTate+1] := 0 ; else skip )  ;     j := j + 1 ) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < 21 do ( (         var j : int ; j := 0 ; while j < 21 do ( (     if (field[i+1][j+1] = 1) then     flag := 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (flag = 0) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class unluckyticket {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    int[] a=new int[2*n];
    char[] c=s.toCharArray();
    for(int i=0 ; i<2*n ; i++){
      a[i]=(int)(c[i]-'0');
    }
    Arrays.sort(a,0,n);
    Arrays.sort(a,n,2*n);
    if(isstrictlygreater(a,n)|| isstrictlysmaller(a,n))System.out.println("YES");
    else System.out.println("NO");
  }
  static boolean isstrictlygreater(int[] a,int n){
    for(int i=0 ; i<n ; i++){
      if(a[i]<=a[i+n])return false ;
    }
    return true ;
  }
  static boolean isstrictlysmaller(int[] a,int n){
    for(int i=0 ; i<n ; i++){
      if(a[i]>=a[i+n])return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class unluckyticket {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var a : Sequence(int) ; a := Integer.subrange(1,2 * n)->collect(0) ;
    var c : Sequence(String) ; c := s->characters() ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     a[i+1] := (c[i+1] - ('0')->char2byte())->oclAsType(int) )  ;     i := i + 1 ) ; 
    a := a.subrange(1,0)^(a.subrange(0+1,n)->sort())^a.subrange(n+1,a.size) ; 
    a := a.subrange(1,n)^(a.subrange(n+1,2 * n)->sort())^a.subrange(2 * n+1,a.size) ; 
    if (isstrictlygreater(a, n) or isstrictlysmaller(a, n)) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
  static   operation isstrictlygreater( a : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] <= a[i + n+1]) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation isstrictlysmaller( a : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] >= a[i + n+1]) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter pr=new PrintWriter(System.out);
    while(true){
      int X=10 ;
      int Y=10 ;
      int[][] map=new int[21][21];
      int N=sc.nextInt();
      if(N==0)break ;
      for(int s=0 ; s<N ; s++){
        map[sc.nextInt()][sc.nextInt()]=1 ;
        ;
      }
      int M=sc.nextInt();
      for(int s=0 ; s<M ; s++){
        String tmp=sc.next();
        int d=sc.nextInt();
        for(int k=1 ; k<=d ; k++){
          if(tmp.equals("N")){
            Y++;
          }
          else if(tmp.equals("E")){
            X++;
          }
          else if(tmp.equals("S")){
            Y--;
          }
          else if(tmp.equals("W")){
            X--;
          }
          map[X][Y]=0 ;
        }
      }
      boolean e=true ;
      for(int x=0 ; x<21 ; x++){
        for(int y=0 ; y<21 ; y++){
          if(map[x][y]!=0){
            e=false ;
          }
        }
      }
      if(e){
        pr.println("Yes");
      }
      else {
        pr.println("No");
      }
    }
    pr.flush();
    sc.close();
  }
  static class Point {
    int x,y ;
    public Point(int x,int y){
      this.x=x ;
      this.y=y ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    while (true) do (     var X : int ; X := 10 ;
     var Y : int ; Y := 10 ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,21)->collect(Integer.subrange(1,21)->collect(0)) ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    if (N = 0) then     break else skip ; 
        var s : int ; s := 0 ; while s < N do ( (     map[sc.getCurrent()->toInteger()+1][sc.getCurrent()->toInteger()+1] := 1 ; 
  )  ;     s := s + 1 ) ; 
    var M : int ; M := sc.getCurrent()->toInteger() ;
        var s : int ; s := 0 ; while s < M do ( (     var tmp : String ; tmp := sc.getCurrent() ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
         var k : int ; k := 1 ; while k <= d do ( (     if (tmp = "N") then (     Y := Y + 1 ) else     if (tmp = "E") then (     X := X + 1 ) else     if (tmp = "S") then (     Y := Y - 1 ) else     if (tmp = "W") then (     X := X - 1 ) else skip ; ;  ;  ;  
     map[X+1][Y+1] := 0 )  ;     k := k + 1 ) )  ;     s := s + 1 ) ; 
    var e : boolean ; e := true ;
        var x : int ; x := 0 ; while x < 21 do ( (         var y : int ; y := 0 ; while y < 21 do ( (     if (map[x+1][y+1] /= 0) then (     e := false ) else skip )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
    if (e) then (     skip ) else (     skip ) ;  
 ) ; 
    skip ; 
    skip ; 
 );
  static class Point {
   attribute x : int;
   static operation newPoint( x : int, y : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean checkPerfectcube(int n){
    int d=(int)Math.cbrt(n);
    if(d*d*d==n)return true ;
    return false ;
  }
  static int largestNonPerfectcubeNumber(int[] a,int n){
    int maxi=-1 ;
    for(int i=0 ; i<n ; i++){
      if(! checkPerfectcube(a[i]))maxi=Math.max(a[i],maxi);
    }
    return maxi ;
  }
  public static void main(String[] args){
    int a[]={
      16,64,25,2,3,10 };
      int n=a.length ;
      System.out.print(largestNonPerfectcubeNumber(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkPerfectcube( n : int) : boolean
  pre: true
  post: true
  activity: (     var d : int ; d := (n)->cbrt()->oclAsType(int) ;
     if (d * d * d = n) then     return true else skip ; 
     return false );
  static   operation largestNonPerfectcubeNumber( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var maxi : int ; maxi := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (not(checkPerfectcube(a[i+1]))) then     maxi := Set{a[i+1], maxi}->max() ; else skip )  ;     i := i + 1 ) ; 
     return maxi );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{16,64,25,2,3,10} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(largestNonPerfectcubeNumber(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().solver();
  }
  final long MOD=1_000_000_007L ;
  void solver(){
    Scanner sc=new Scanner(System.in);
    int d=sc.nextInt();
    int[] l=new int[d];
    for(int i=0 ; i<d ; i++){
      l[i]=sc.nextInt();
    }
    Arrays.sort(l);
    int s=sc.nextInt();
    long[] dp=new long[90010];
    dp[s]=1 ;
    for(int i=0 ; i<d ; i++){
      for(int j=0 ; j<=s ; j++){
        if(j-l[i]>0)dp[j-l[i] ]+=MOD-dp[j];
        dp[j] %=MOD ;
      }
    }
    long cut=0 ;
    for(int i=1 ; i<=s ; i++){
      long tmp=dp[i];
      for(int j=0 ; j<d ; j++){
        tmp=(tmp*i)% MOD ;
      }
      cut=(cut+tmp)% MOD ;
    }
    System.out.println(cut);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solver() );
   attribute MOD : long := 1_000_000_007L;
   operation solver() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Integer.subrange(1,d)->collect(0) ;
        var i : int ; i := 0 ; while i < d do ( (     l[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    l := l->sort() ; 
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var dp : Sequence(long) ; dp := Integer.subrange(1,90010)->collect(0) ;
    dp[s+1] := 1 ; 
        var i : int ; i := 0 ; while i < d do ( (         var j : int ; j := 0 ; while j <= s do ( (     if (j - l[i+1] > 0) then     dp[j - l[i+1]+1] := dp[j - l[i+1]+1]+(MOD - dp[j+1]) ; else skip ; 
     dp[j+1] := dp[j+1] mod MOD )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var cut : long ; cut := 0 ;
        var i : int ; i := 1 ; while i <= s do ( (     var tmp : long ; tmp := dp[i+1] ;
         var j : int ; j := 0 ; while j < d do ( (     tmp := (tmp * i) mod MOD )  ;     j := j + 1 ) ; 
     cut := (cut + tmp) mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cut) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().solver();
  }
  final long MOD=1_000_000_007L ;
  void solver(){
    Scanner sc=new Scanner(System.in);
    int d=sc.nextInt();
    int[] l=new int[d];
    for(int i=0 ; i<d ; i++){
      l[i]=sc.nextInt();
    }
    Arrays.sort(l);
    int s=sc.nextInt();
    long[] dp=new long[90010];
    dp[s]=1 ;
    for(int i=0 ; i<d ; i++){
      for(int j=0 ; j<=s ; j++){
        if(j-l[i]>0)dp[j-l[i] ]+=MOD-dp[j];
        dp[j] %=MOD ;
      }
    }
    long cut=0 ;
    for(int i=1 ; i<=s ; i++){
      long tmp=dp[i];
      for(int j=0 ; j<d ; j++){
        tmp=(tmp*i)% MOD ;
      }
      cut=(cut+tmp)% MOD ;
    }
    System.out.println(cut);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solver() );
   attribute MOD : long := 1_000_000_007L;
   operation solver() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Integer.subrange(1,d)->collect(0) ;
        var i : int ; i := 0 ; while i < d do ( (     l[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    l := l->sort() ; 
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var dp : Sequence(long) ; dp := Integer.subrange(1,90010)->collect(0) ;
    dp[s+1] := 1 ; 
        var i : int ; i := 0 ; while i < d do ( (         var j : int ; j := 0 ; while j <= s do ( (     if (j - l[i+1] > 0) then     dp[j - l[i+1]+1] := dp[j - l[i+1]+1]+(MOD - dp[j+1]) ; else skip ; 
     dp[j+1] := dp[j+1] mod MOD )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var cut : long ; cut := 0 ;
        var i : int ; i := 1 ; while i <= s do ( (     var tmp : long ; tmp := dp[i+1] ;
         var j : int ; j := 0 ; while j < d do ( (     tmp := (tmp * i) mod MOD )  ;     j := j + 1 ) ; 
     cut := (cut + tmp) mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cut) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class GFG {
  static void shufleArray(int a[],int f,int l){
    if(l>f)return ;
    if(l-f==1)return ;
    int mid=(f+l)/2 ;
    int temp=mid+1 ;
    int mmid=(f+mid)/2 ;
    for(int i=mmid+1 ; i<=mid ; i++){
      int temp1=a[i];
      a[i]=a[temp];
      a[temp++]=temp1 ;
    }
    shufleArray(a,f,mid);
    shufleArray(a,mid+1,l);
  }
  public static void main(String[] args){
    int a[]={
      1,3,5,7,2,4,6,8 };
      shufleArray(a,0,a.length-1);
      System.out.println(Arrays.toString(a));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation shufleArray( a : Sequence(int), f : int, l : int) : void
  pre: true
  post: true
  activity: (     if (l > f) then     return else skip ; 
     if (l - f = 1) then     return else skip ; 
    var mid : int ; mid := (f + l) / 2 ;
    var temp : int ; temp := mid + 1 ;
    var mmid : int ; mmid := (f + mid) / 2 ;
        var i : int ; i := mmid + 1 ; while i <= mid do ( (     var temp1 : int ; temp1 := a[i+1] ;
     a[i+1] := a[temp+1] ; 
      a[temp+1] := temp1  ; temp := temp + 1 )  ;     i := i + 1 ) ; 
    execute shufleArray(a, f, mid) ; 
    execute shufleArray(a, mid + 1, l) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,3,5,7,2,4,6,8} ;
     execute shufleArray(a, 0, a->size() - 1) ; 
     OclFile["System.out"].println((a + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int p=1000000007 ;
  static long power(long x,long y){
    long res=1 ;
    x=x % p ;
    while(y>0){
      if(y % 2==1)res=(res*x)% p ;
      y=y>>1 ;
      x=(x*x)% p ;
    }
    return res % p ;
  }
  public static void main(String[] args){
    long n=3 ;
    long x=(power(3,n)% p+1)% p ;
    x=(x-power(2,n+1)+p)% p ;
    x=(x*power(2,p-2))% p ;
    System.out.println(x);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute p : int := 1000000007;
  static   operation power( x : long, y : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     if (y mod 2 = 1) then     res := (res * x) mod p ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res mod p );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 3 ;
     var x : long ; x := (power(3, n) mod p + 1) mod p ;
    x := (x - power(2, n + 1) + p) mod p ; 
    x := (x * power(2, p - 2)) mod p ; 
    OclFile["System.out"].println(x) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean checkplusperfect(int x){
    int temp=x ;
    int n=0 ;
    while(x!=0){
      x/=10 ;
      n++;
    }
    x=temp ;
    int sum=0 ;
    while(x!=0){
      sum+=Math.pow(x % 10,n);
      x/=10 ;
    }
    return(sum==temp);
  }
  public static void main(String[] args){
    int x=9474 ;
    if(checkplusperfect(x))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkplusperfect( x : int) : boolean
  pre: true
  post: true
  activity: (     var temp : int ; temp := x ;
     var n : int ; n := 0 ;
    while (x /= 0) do (     x := x/(10) ; 
     n := n + 1 ) ; 
    x := temp ; 
    var sum : int ; sum := 0 ;
    while (x /= 0) do (     sum := sum+(x mod 10->pow(n)) ; 
     x := x/(10) ) ; 
    return (sum = temp) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 9474 ;
     if (checkplusperfect(x)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Solution {
  public int[] productExceptSelf(int[] nums){
    int n=nums.length ;
    int[] res=new int[n];
    res[0]=1 ;
    for(int i=1 ; i<n ; i++){
      res[i]=res[i-1]*nums[i-1];
    }
    int right=1 ;
    for(int i=n-1 ; i>=0 ; i--){
      res[i]*=right ;
      right*=nums[i];
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation productExceptSelf( nums : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var n : int ; n := nums->size() ;
     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
    res[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < n do ( (     res[i+1] := res[i - 1+1] * nums[i - 1+1] )  ;     i := i + 1 ) ; 
    var right : int ; right := 1 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     res[i+1] := res[i+1]*(right) ; 
     right := right*(nums[i+1]) )  ;     i := i - 1 ) ; 
    return res 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer to=new StringTokenizer(reader.readLine());
    int n=Integer.parseInt(to.nextToken());
    int m=Integer.parseInt(to.nextToken());
    int[][] dp=new int[n+1][n+1];
    while(m-->0){
      to=new StringTokenizer(reader.readLine());
      int a=Integer.parseInt(to.nextToken());
      int b=Integer.parseInt(to.nextToken());
      int x=Integer.parseInt(to.nextToken())+1 ;
      dp[a][b]=x ;
    }
    int ans=0 ;
    for(int i=1 ; i<=n ; i++)for(int j=1 ; j<=i ; j++){
      dp[i][j]=Math.max(dp[i][j],Math.max(dp[i-1][j],dp[i-1][j-1])-1);
      if(dp[i][j]>0)ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var to : OclIterator ; to := OclIterator.newOclIterator_String(reader.readLine()) ;
    var n : int ; n := (to.next())->toInteger() ;
    var m : int ; m := (to.next())->toInteger() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     to := OclIterator.newOclIterator_String(reader.readLine()) ; 
     var a : int ; a := (to.next())->toInteger() ;
    var b : int ; b := (to.next())->toInteger() ;
    var x : int ; x := (to.next())->toInteger() + 1 ;
    dp[a+1][b+1] := x ; 
 ) ;  ) ;  
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do (         var j : int ; j := 1 ; while j <= i do ( (     dp[i+1][j+1] := Set{dp[i+1][j+1], Set{dp[i - 1+1][j+1], dp[i - 1+1][j - 1+1]}->max() - 1}->max() ; 
     if (dp[i+1][j+1] > 0) then     ans := ans + 1 ; else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt(),M=sc.nextInt();
    int[][] g=new int[N+1][];
    for(int i=0 ; i<=N ; i++){
      g[i]=new int[i+2];
    }
    while(M--!=0){
      int a=Integer.parseInt(sc.next()),b=Integer.parseInt(sc.next()),x=Integer.parseInt(sc.next());
      g[a][b]=Math.max(g[a][b],x+1);
    }
    int count=0 ;
    for(int x=1 ; x<=N ; x++){
      for(int y=1 ; y<=x ; y++){
        g[x][y]=Math.max(g[x][y],Math.max(g[x-1][y]-1,g[x-1][y-1]-1));
        if(g[x][y]>0)count++;
      }
    }
    System.out.println(count);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var g : Sequence(Sequence(int)) ; g := Integer.subrange(1,N + 1)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i <= N do ( (     g[i+1] := Integer.subrange(1,i + 2)->collect(0) )  ;     i := i + 1 ) ; 
        while (M /= 0) do (    skip ; (     var a : int ; a := (sc.getCurrent())->toInteger() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    var x : int ; x := (sc.getCurrent())->toInteger() ;
     g[a+1][b+1] := Set{g[a+1][b+1], x + 1}->max() ) ;  ) ;  
    var count : int ; count := 0 ;
        var x : int ; x := 1 ; while x <= N do ( (         var y : int ; y := 1 ; while y <= x do ( (     g[x+1][y+1] := Set{g[x+1][y+1], Set{g[x - 1+1][y+1] - 1, g[x - 1+1][y - 1+1] - 1}->max()}->max() ; 
     if (g[x+1][y+1] > 0) then     count := count + 1 ; else skip )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static int nail[][];
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    nail=new int[n+1][];
    for(int i=1 ; i<=n ; i++){
      nail[i]=new int[i+1];
    }
    int ct=0 ;
    for(int i=0 ; i<m ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int x=sc.nextInt();
      ct+=count(a,b,x);
    }
    System.out.println(ct);
  }
  static int count(int a,int b,int x){
    if(x<0)return 0 ;
    int y=nail[a][b];
    if(y>x)return 0 ;
    int c=0 ;
    if(y==0)c++;
    nail[a][b]=x+1 ;
    c+=count(a+1,b,x-1);
    c+=count(a+1,b+1,x-1);
    return c ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute nail : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    nail := Integer.subrange(1,n + 1)->collect(Sequence{}) ; 
        var i : int ; i := 1 ; while i <= n do ( (     nail[i+1] := Integer.subrange(1,i + 1)->collect(0) )  ;     i := i + 1 ) ; 
    var ct : int ; ct := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     ct := ct+(count(a, b, x)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ct) ; 
 );
  static   operation count( a : int, b : int, x : int) : int
  pre: true
  post: true
  activity: (     if (x < 0) then     return 0 else skip ; 
     var y : int ; y := nail[a+1][b+1] ;
    if (y > x) then     return 0 else skip ; 
    var c : int ; c := 0 ;
    if (y = 0) then     c := c + 1 ; else skip ; 
    nail[a+1][b+1] := x + 1 ; 
    c := c+(count(a + 1, b, x - 1)) ; 
    c := c+(count(a + 1, b + 1, x - 1)) ; 
    return c 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test171 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int a=in.nextInt();
      System.out.println((a-1)+" "+1);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test171 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println((a - 1) + " " + 1) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[][] map=new int[n+1][n+1];
    for(int i=0 ; i<m ; i++){
      int a=Integer.parseInt(sc.next());
      int b=Integer.parseInt(sc.next());
      int x=Integer.parseInt(sc.next());
      map[a][b]=x+1 ;
    }
    int cnt=0 ;
    for(int i=1 ; i<=n ; i++)for(int j=1 ; j<=i ; j++){
      map[i][j]=max(map[i][j],max(map[i-1][j-1]-1,map[i-1][j]-1));
    }
    for(int i=1 ; i<=n ; i++)for(int j=1 ; j<=i ; j++)if(map[i][j]>0)cnt++;
    System.out.println(cnt);
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := (sc.getCurrent())->toInteger() ;
     var b : int ; b := (sc.getCurrent())->toInteger() ;
     var x : int ; x := (sc.getCurrent())->toInteger() ;
     map[a+1][b+1] := x + 1 )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 1 ; while i <= n do (         var j : int ; j := 1 ; while j <= i do ( (     map[i+1][j+1] := Set{map[i+1][j+1], Set{map[i - 1+1][j - 1+1] - 1, map[i - 1+1][j+1] - 1}->max()}->max() )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (         var j : int ; j := 1 ; while j <= i do (     if (map[i+1][j+1] > 0) then     cnt := cnt + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    int[][] t=new int[n+1][];
    for(int i=1 ; i<=n ; i++){
      t[i]=new int[i+1];
      Arrays.fill(t[i],-1);
    }
    while(m--!=0){
      int a=sc.nextInt(),b=sc.nextInt(),x=sc.nextInt();
      t[a][b]=Math.max(t[a][b],x);
    }
    int res=0 ;
    for(int i=1 ; i<=n ; i++)for(int j=1 ; j<=i ; j++){
      if(i>1){
        if(i!=j)t[i][j]=Math.max(t[i][j],t[i-1][j]-1);
        if(j!=1)t[i][j]=Math.max(t[i][j],t[i-1][j-1]-1);
      }
      res+=t[i][j]>=0 ? 1 : 0 ;
    }
    System.out.println(res);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var t : Sequence(Sequence(int)) ; t := Integer.subrange(1,n + 1)->collect(Sequence{}) ;
        var i : int ; i := 1 ; while i <= n do ( (     t[i+1] := Integer.subrange(1,i + 1)->collect(0) ; 
     t[i+1] := t[i+1]->collect(-1) )  ;     i := i + 1 ) ; 
        while (m /= 0) do (    skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
     t[a+1][b+1] := Set{t[a+1][b+1], x}->max() ) ;  ) ;  
    var res : int ; res := 0 ;
        var i : int ; i := 1 ; while i <= n do (         var j : int ; j := 1 ; while j <= i do ( (     if (i > 1) then (     if (i /= j) then     t[i+1][j+1] := Set{t[i+1][j+1], t[i - 1+1][j+1] - 1}->max() ; else skip ; 
     if (j /= 1) then     t[i+1][j+1] := Set{t[i+1][j+1], t[i - 1+1][j - 1+1] - 1}->max() ; else skip ) else skip ; 
     res := res+(if t[i+1][j+1] >= 0 then 1 else 0 endif) )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int properDivisorSum(int n){
    int sum=0 ;
    int i ;
    for(i=1 ; i<=n ; ++i)sum+=(n/i)*i ;
    return sum-n*(n+1)/2 ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(properDivisorSum(n));
    n=5 ;
    System.out.println(properDivisorSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation properDivisorSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var i : int ;
         i := 1 ; while i <= n do (     sum := sum+((n / i) * i) ;  ;     i := i + 1 ) ; 
     return sum - n * (n + 1) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(properDivisorSum(n)) ; 
     n := 5 ; 
     OclFile["System.out"].println(properDivisorSum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class prog1 {
  static String solve(String s){
    if(s.length()<5)return "NO" ;
    String str="hello" ;
    String word="" ;
    int j=0 ;
    for(int i=0 ; i<s.length(); i++){
      char ch1=s.charAt(i);
      char ch2=str.charAt(j);
      if(ch1==ch2){
        word=word+ch1 ;
        j++;
      }
      if(j==str.length()){
        return "YES" ;
      }
    }
    return "NO" ;
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String str=sc.nextLine();
    String ans=solve(str);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class prog1 {
  static   operation solve( s : String) : String
  pre: true
  post: true
  activity: (     if (s->size() < 5) then     return "NO" else skip ; 
     var str : String ; str := "hello" ;
    var word : String ; word := "" ;
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var ch1 : String ; ch1 := s->at(i+1) ;
     var ch2 : String ; ch2 := str->at(j+1) ;
     if (ch1 = ch2) then (     word := word + ch1 ; 
     j := j + 1 ) else skip ; 
     if (j = str->size()) then (     return "YES" ) else skip )  ;     i := i + 1 ) ; 
    return "NO" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.nextLine() ;
     var ans : String ; ans := solve(str) ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ChatRoom {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args)throws Exception {
    String s=sc.nextLine();
    String a="hello" ;
    int j=0 ;
    int i ;
    for(i=0 ; i<a.length(); i++){
      while(j<s.length()){
        if(s.charAt(j)==a.charAt(i)){
          if(i==4){
            System.out.println("YES");
            return ;
          }
          j++;
          break ;
        }
        j++;
      }
      if(j==s.length()){
        System.out.println("NO");
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ChatRoom {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := sc.nextLine() ;
     var a : String ; a := "hello" ;
    var j : int ; j := 0 ;
    var i : int ;
        i := 0 ; while i < a->size() do ( (     while (j < s->size()) do (     if (s->at(j+1) = a->at(i+1)) then (     if (i = 4) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
     j := j + 1 ; 
     break ) else skip ; 
     j := j + 1 ) ; 
     if (j = s->size()) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char[] s=in.nextLine().toCharArray();
    in.close();
    char[] chs={
      'h','e','l','l','o',};
      int si=0,chsi=0 ;
      while(si<s.length && chsi<chs.length){
        if(s[si]==chs[chsi])chsi++;
        si++;
      }
      if(chsi==chs.length)System.out.println("YES");
      else System.out.println("NO");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := in.nextLine()->characters() ;
    skip ; 
    var chs : Sequence(String) ; chs := Sequence{'h','e','l','l','o',} ;
    var si : int ; si := 0 ;
    var chsi : int ; chsi := 0 ;
    while (si < s->size() & chsi < chs->size()) do (     if (s[si+1] = chs[chsi+1]) then     chsi := chsi + 1 ; else skip ; 
     si := si + 1 ) ; 
    if (chsi = chs->size()) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static void getSmallestAndLargest(String s,int k){
    String currStr=s.substring(0,k);
    String lexMin=currStr ;
    String lexMax=currStr ;
    for(int i=k ; i<s.length(); i++){
      currStr=currStr.substring(1,k)+s.charAt(i);
      if(lexMax.compareTo(currStr)<0)lexMax=currStr ;
      if(lexMin.compareTo(currStr)>0)lexMin=currStr ;
    }
    System.out.println(lexMin);
    System.out.println(lexMax);
  }
  public static void main(String[] args){
    String str="GeeksForGeeks" ;
    int k=3 ;
    getSmallestAndLargest(str,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getSmallestAndLargest( s : String, k : int) : void
  pre: true
  post: true
  activity: (     var currStr : String ; currStr := s.subrange(0+1,k) ;
     var lexMin : String ; lexMin := currStr ;
    var lexMax : String ; lexMax := currStr ;
        var i : int ; i := k ; while i < s->size() do ( (     currStr := currStr.subrange(1+1,k) + s->at(i+1) ; 
     if (lexMax->compareTo(currStr) < 0) then     lexMax := currStr ; else skip ; 
     if (lexMin->compareTo(currStr) > 0) then     lexMin := currStr ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(lexMin) ; 
    OclFile["System.out"].println(lexMax) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GeeksForGeeks" ;
     var k : int ; k := 3 ;
     execute getSmallestAndLargest(str, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Codesolver {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String st,st1="" ;
    String h="hello" ;
    st=sc.nextLine();
    int k=0 ;
    int len=st.length();
    for(int i=0 ; i<len ; i++){
      if(h.charAt(k)==st.charAt(i)){
        if(st1.length()==h.length())break ;
        st1=st1+st.charAt(i);
        if(k<h.length()-1)k++;
      }
      else {
        continue ;
      }
    }
    if(h.equals(st1)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codesolver {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var st : String ;
    var st1 : String ; st1 := "" ;
    var h : String ; h := "hello" ;
    st := sc.nextLine() ; 
    var k : int ; k := 0 ;
    var len : int ; len := st->size() ;
        var i : int ; i := 0 ; while i < len do ( (     if (h->at(k+1) = st->at(i+1)) then (     if (st1->size() = h->size()) then     break else skip ; 
     st1 := st1 + st->at(i+1) ; 
     if (k < h->size() - 1) then     k := k + 1 ; else skip ) else (     continue ) )  ;     i := i + 1 ) ; 
    if (h = st1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int i=0 ;
      double var=0 ;
      double ave=0 ;
      int n=sc.nextInt();
      if(n==0)break ;
      int[] s=new int[n];
      while(true){
        if(i==n)break ;
        s[i]=sc.nextInt();
        i++;
      }
      for(i=0 ; i<s.length ; i++){
        ave+=s[i];
      }
      ave/=n ;
      for(i=0 ; i<s.length ; i++){
        var+=(s[i]-ave)*(s[i]-ave);
      }
      var/=n ;
      System.out.println(Math.sqrt(var));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var i : int ; i := 0 ;
     var var : double ; var := 0 ;
    var ave : double ; ave := 0 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    if (n = 0) then     break else skip ; 
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
    while (true) do (     if (i = n) then     break else skip ; 
     s[i+1] := sc.getCurrent()->toInteger() ; 
     i := i + 1 ) ; 
        i := 0 ; while i < s->size() do ( (     ave := ave+(s[i+1]) )  ;     i := i + 1 ) ; 
    ave := ave/(n) ; 
        i := 0 ; while i < s->size() do ( (     var := var+((s[i+1] - ave) * (s[i+1] - ave)) )  ;     i := i + 1 ) ; 
    var := var/(n) ; 
    OclFile["System.out"].println((var)->sqrt()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String args[])throws IOException {
    int n=0 ;
    double m=0 ;
    double sigma=0 ;
    double alpha=0 ;
    ArrayList<Double>s ;
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      m=0 ;
      sigma=0 ;
      alpha=0 ;
      n=Integer.parseInt(br.readLine());
      if(n==0){
        break ;
      }
      s=new ArrayList<Double>();
      String str[]=br.readLine().split(" ");
      for(int i=0 ; i<str.length ; i++){
        s.add(Double.parseDouble(str[i]));
      }
      m=ave(s);
      for(int i=0 ; i<s.size(); i++){
        sigma+=(s.get(i)-m)*(s.get(i)-m);
      }
      alpha=Math.sqrt(sigma/n);
      System.out.printf("%.5f\n",alpha);
    }
  }
  public static double ave(ArrayList<Double>s){
    double sum=0 ;
    for(int i=0 ; i<s.size(); i++){
      sum+=s.get(i);
    }
    return(sum/s.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 0 ;
     var m : double ; m := 0 ;
    var sigma : double ; sigma := 0 ;
    var alpha : double ; alpha := 0 ;
    var s : Sequence(double) ;
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    while (true) do (     m := 0 ; 
     sigma := 0 ; 
    alpha := 0 ; 
    n := (br.readLine())->toInteger() ; 
    if (n = 0) then (     break ) else skip ; 
    s := Sequence{} ; 
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < str->size() do ( (     s := s->including((str[i+1])->toReal()) )  ;     i := i + 1 ) ; 
    m := ave(s) ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     sigma := sigma+((s->at(i+1) - m) * (s->at(i+1) - m)) )  ;     i := i + 1 ) ; 
    alpha := (sigma / n)->sqrt() ; 
    OclFile["System.out"].printf("%.5f\n", alpha) ; 
 ) ; 
 );
  static   operation ave( s : Sequence(double)) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     sum := sum+(s->at(i+1)) )  ;     i := i + 1 ) ; 
     return (sum / s->size()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
class Main {
  static double average(ArrayList<Integer>ls){
    double average=0.0 ;
    for(Integer n : ls){
      average+=n ;
    }
    return average/ls.size();
  }
  static double variance(ArrayList<Integer>ls){
    double variance=0.0 ;
    double average=average(ls);
    for(Integer n : ls){
      variance+=Math.pow(n-average,2);
    }
    return variance/=ls.size();
  }
  static double standardDeviation(ArrayList<Integer>ls){
    return Math.sqrt(variance(ls));
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      int noItem=scan.nextInt();
      if(noItem==0)break ;
      ArrayList<Integer>ls=new ArrayList<Integer>();
      for(int i=0 ; i<noItem ; i++){
        ls.add(scan.nextInt());
      }
      System.out.printf("%.6f\n",standardDeviation(ls));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation average( ls : Sequence(int)) : double
  pre: true
  post: true
  activity: (     var average : double ; average := 0.0 ;
     for (n : ls) do ( (     average := average+(n) )  ) ; 
     return average / ls->size() );
  static   operation variance( ls : Sequence(int)) : double
  pre: true
  post: true
  activity: (     var variance : double ; variance := 0.0 ;
     var average : double ; average := average(ls) ;
     for (n : ls) do ( (     variance := variance+(n - average->pow(2)) )  ) ; 
     return variance );
  static   operation standardDeviation( ls : Sequence(int)) : double
  pre: true
  post: true
  activity: (     return (variance(ls))->sqrt() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var noItem : int ; noItem := scan.getCurrent()->toInteger() ;
     if (noItem = 0) then     break else skip ; 
    var ls : Sequence(int) ; ls := Sequence{} ;
        var i : int ; i := 0 ; while i < noItem do ( (     ls := ls->including(scan.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.6f\n", standardDeviation(ls)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1325A_EhAbAnDgCd {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int num=parseInt(input.nextLine());
      System.out.println(1+" "+(num-1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1325A_EhAbAnDgCd {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var num : int ; num := parseInt(input.nextLine()) ;
     OclFile["System.out"].println(1 + " " + (num - 1)) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    while(! in.readLine().equals("0")){
      String[] tmp=in.readLine().split(" ");
      int n=tmp.length ;
      double[] s=new double[n];
      for(int i=0 ; i<n ; i++){
        s[i]=Double.parseDouble(tmp[i]);
      }
      double m=mean(s);
      for(int i=0 ; i<n ; i++){
        s[i]=Math.pow(s[i]-m,2);
      }
      double a=Math.sqrt(sum(s)/n);
      System.out.printf("%.5f\n",a);
    }
  }
  public static double sum(double[] s){
    double sum=0 ;
    for(int i=0 ; i<s.length ; i++){
      sum+=s[i];
    }
    return sum ;
  }
  public static double mean(double[] s){
    return sum(s)/s.length ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (not(in.readLine() = "0")) do (     var tmp : Sequence(String) ; tmp := in.readLine()->split(" ") ;
     var n : int ; n := tmp->size() ;
    var s : Sequence(double) ; s := Integer.subrange(1,n)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := (tmp[i+1])->toReal() )  ;     i := i + 1 ) ; 
    var m : double ; m := mean(s) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := s[i+1] - m->pow(2) )  ;     i := i + 1 ) ; 
    var a : double ; a := (sum(s) / n)->sqrt() ;
    OclFile["System.out"].printf("%.5f\n", a) ; 
 ) );
  static   operation sum( s : Sequence(double)) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     sum := sum+(s[i+1]) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation mean( s : Sequence(double)) : double
  pre: true
  post: true
  activity: (     return sum(s) / s->size() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Map.*;
class Main {
  public static void main(String[] A){
    Scanner s=new Scanner(System.in);
    TreeMap<Integer,Integer>m=new TreeMap<>();
    while(true){
      int n=s.nextInt(),v=s.nextInt();
      if(n+v==0)return ;
      m.clear();
      for(int i=0 ; i<n ; ++i)m.merge(s.nextInt(),1,Integer :: sum);
      int r=-1 ;
      for(Entry<Integer,Integer>i : m.entrySet()){
        int k=i.getKey();
        Integer a=m.floorKey(v-k);
        if(a!=null && a==k && i.getValue()==1)a=m.floorKey(k-1);
        if(a!=null)r=Math.max(r,a+k);
      }
      System.out.println(r==-1 ? "NONE" : r);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( A : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : Map(int,int) ; m := Map{} ;
     while (true) do (     var n : int ; n := s.getCurrent()->toInteger() ;
    var v : int ; v := s.getCurrent()->toInteger() ;
     if (n + v = 0) then     return else skip ; 
    m := m->intersection(Map{}) ; 
        var i : int ; i := 0 ; while i < n do (     m := m.merge(s.getCurrent()->toInteger(), 1, lambda _pars : OclAny in Integer.newInteger().sum(_pars)) ;  ;     i := i + 1 ) ; 
    var r : int ; r := -1 ;
    for (i : m->asSet()) do ( (     var k : int ; k := i.getKey() ;
     var a : int ; a := m.floorKey(v - k) ;
     if (a /= null & a = k & i.getValue() = 1) then     a := m.floorKey(k - 1) ; else skip ; 
     if (a /= null) then     r := Set{r, a + k}->max() ; else skip )  ) ; 
    OclFile["System.out"].println(if r = -1 then "NONE" else r endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.List ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    boolean b=true ;
    final BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    while(b){
      b=runOnce(reader);
    }
    reader.close();
  }
  private boolean runOnce(final BufferedReader reader)throws IOException {
    final String[] params=reader.readLine().split(" ");
    final int count=Integer.parseInt(params[0]);
    final int max=Integer.parseInt(params[1]);
    if(count==0 && max==0)return false ;
    final List<Integer>prices=Arrays.stream(reader.readLine().split(" ")).map(Integer :: parseInt).sorted().collect(Collectors.toList());
    int nextLow=0 ;
    int maxSum=0 ;
    for(int i=prices.size()-1 ; i>=0 ; i--){
      int tmpNextLow=nextLow ;
      for(int j=nextLow ; j<i ; j++){
        if(prices.get(i)+prices.get(j)<=max){
          tmpNextLow++;
        }
        else {
          break ;
        }
      }
      if(tmpNextLow==nextLow)continue ;
      maxSum=Math.max(maxSum,prices.get(i)+prices.get(tmpNextLow-1));
      nextLow=tmpNextLow ;
    }
    System.out.println(maxSum==0 ? "NONE" : maxSum);
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var b : boolean ; b := true ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (b) do (     b := runOnce(reader) ) ; 
     skip );
   operation runOnce( reader : OclFile) : boolean
  pre: true
  post: true
  activity: (     var params : Sequence(String) ; params := reader.readLine()->split(" ") ;
     var count : int ; count := (params[0+1])->toInteger() ;
    var max : int ; max := (params[1+1])->toInteger() ;
    if (count = 0 & max = 0) then     return false else skip ; 
    var prices : Sequence(int) ; prices := stream(reader.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->sort().collect(Collectors.toList()) ;
    var nextLow : int ; nextLow := 0 ;
    var maxSum : int ; maxSum := 0 ;
        var i : int ; i := prices->size() - 1 ; while i >= 0 do ( (     var tmpNextLow : int ; tmpNextLow := nextLow ;
         var j : int ; j := nextLow ; while j < i do ( (     if (prices->at(i+1) + prices->at(j+1) <= max) then (     tmpNextLow := tmpNextLow + 1 ) else (     break ) )  ;     j := j + 1 ) ; 
    if (tmpNextLow = nextLow) then     continue else skip ; 
    maxSum := Set{maxSum, prices->at(i+1) + prices->at(tmpNextLow - 1+1)}->max() ; 
    nextLow := tmpNextLow ; 
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(if maxSum = 0 then "NONE" else maxSum endif) ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.*;
public class Main {
  public static void solution(int[] array,int n,int m){
    int i,j,max,temp ;
    max=0 ;
    for(i=0 ; i<n ; i++){
      for(j=i+1 ; j<n ; j++){
        temp=array[i]+array[j];
        if(temp>max && temp<=m)max=temp ;
      }
    }
    if(max==0){
      System.out.println("NONE");
    }
    else {
      System.out.println(max);
    }
  }
  public static void main(String[] args){
    BufferedReader br=null ;
    try {
      br=new BufferedReader(new InputStreamReader(System.in));
      String curr ;
      while(!(curr=br.readLine()).equals("0 0")){
        String[] nm=curr.split(" ");
        int n=Integer.parseInt(nm[0]);
        int m=Integer.parseInt(nm[1]);
        curr=br.readLine();
        String[] a=curr.split(" ");
        int[] array=new int[1024];
        for(int i=0 ; i<n ; i++){
          array[i]=Integer.parseInt(a[i]);
        }
        solution(array,n,m);
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solution( array : Sequence(int), n : int, m : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var max : int ;
    var temp : int ;
     max := 0 ; 
         i := 0 ; while i < n do ( (         j := i + 1 ; while j < n do ( (     temp := array[i+1] + array[j+1] ; 
     if (temp > max & temp <= m) then     max := temp ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (max = 0) then (     OclFile["System.out"].println("NONE") ) else (     OclFile["System.out"].println(max) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := null ;
     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     var curr : String ;
     while (not((curr) = "0 0")) do (     var nm : Sequence(String) ; nm := curr->split(" ") ;
     var n : int ; n := (nm[0+1])->toInteger() ;
    var m : int ; m := (nm[1+1])->toInteger() ;
    curr := br.readLine() ; 
    var a : Sequence(String) ; a := curr->split(" ") ;
    var array : Sequence(int) ; array := Integer.subrange(1,1024)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := (a[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    execute solution(array, n, m) ; 
 ) )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CF840A {
  public static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    List<Integer>a=new ArrayList<>();
    int[][] b=new int[n][2];
    for(int i=0 ; i<n ; i++){
      a.add(Integer.parseInt(scanner.next()));
    }
    for(int i=0 ; i<n ; i++){
      b[i][0]=Integer.parseInt(scanner.next());
      b[i][1]=i ;
    }
    a.sort(Comparator.reverseOrder());
    Arrays.sort(b,new Comparator<int[]>(){
      @ Override public int compare(int[] o1,int[] o2){
        int cmp=Integer.compare(o1[0],o2[0]);
        if(cmp==0)return Integer.compare(o1[1],o2[1]);
        else return cmp ;
      }
    }
);
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      int[] e=b[i];
      res[e[1] ]=a.get(i);
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(res[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF840A {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
    var b : Sequence(Sequence(int)) ; b := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     a := a->including((scanner.getCurrent())->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1][0+1] := (scanner.getCurrent())->toInteger() ; 
     b[i+1][1+1] := i )  ;     i := i + 1 ) ; 
    a := a.sort(Comparator.reverseOrder()) ; 
    b := OclComparator.sortWith(b, OclComparator<Sequence(int)>.newOclComparator()) ; 
    var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var e : Sequence(int) ; e := b[i+1] ;
     res[e[1+1]+1] := a->at(i+1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(res[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  private static Scanner in=new Scanner(System.in);
  private static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    solve();
    out.flush();
  }
  private static void solve(){
    while(true){
      int n=in.nextInt();
      int m=in.nextInt();
      if(n==0 && m==0)break ;
      in.nextLine();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      Arrays.sort(a);
      int ans=-1 ;
      for(int i=0 ; i<a.length ; i++){
        int item=a[i];
        if(m-item<=0)break ;
        int index=Arrays.binarySearch(a,m-item);
        if(index>=0 && index!=i){
          ans=m ;
          break ;
        }
        else {
          index=~ index-1 ;
          if(index<0 || index==i)continue ;
          ans=Math.max(ans,item+a[index]);
        }
      }
      out.println(ans==-1 ? "NONE" : ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() ; 
     skip );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    if (n = 0 & m = 0) then     break else skip ; 
    skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var ans : int ; ans := -1 ;
        var i : int ; i := 0 ; while i < a->size() do ( (     var item : int ; item := a[i+1] ;
     if (m - item <= 0) then     break else skip ; 
     var index : int ; index := (a->indexOf(m - item) - 1) ;
     if (index >= 0 & index /= i) then (     ans := m ; 
     break ) else (     index := -(index + 1) - 1 ; 
     if (index < 0 or index = i) then     continue else skip ; 
     ans := Set{ans, item + a[index+1]}->max() ) )  ;     i := i + 1 ) ; 
    skip ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  static long[] mono ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int kazu=sc.nextInt();
      long price=sc.nextLong();
      if(kazu==0 && price==0){
        System.exit(0);
      }
      mono=new long[kazu];
      for(int i=0 ; i<kazu ; i++){
        mono[i]=sc.nextInt();
      }
      long tmp=0 ;
      long kiroku=0 ;
      for(int i=0 ; i<kazu ; i++){
        tmp=mono[i];
        for(int j=i+1 ; j<kazu ; j++){
          if(tmp+mono[j]<=price && tmp+mono[j]>kiroku){
            kiroku=tmp+mono[j];
          }
        }
      }
      if(kiroku==0){
        System.out.println("NONE");
      }
      else {
        System.out.println(kiroku);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mono : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var kazu : int ; kazu := sc.getCurrent()->toInteger() ;
     var price : long ; price := sc.getCurrent()->toLong() ;
    if (kazu = 0 & price = 0) then ( OclProcess.exit(0) ) else skip ; 
    mono := Integer.subrange(1,kazu)->collect(0) ; 
        var i : int ; i := 0 ; while i < kazu do ( (     mono[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var tmp : long ; tmp := 0 ;
    var kiroku : long ; kiroku := 0 ;
        var i : int ; i := 0 ; while i < kazu do ( (     tmp := mono[i+1] ; 
         var j : int ; j := i + 1 ; while j < kazu do ( (     if (tmp + mono[j+1] <= price & tmp + mono[j+1] > kiroku) then (     kiroku := tmp + mono[j+1] ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (kiroku = 0) then (     OclFile["System.out"].println("NONE") ) else (     OclFile["System.out"].println(kiroku) ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class B_476 {
  public static void main(String args[])throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s1=br.readLine();
    String s2=br.readLine();
    int pos1=0 ;
    for(int i=0 ; i<s1.length(); i++){
      if(s1.charAt(i)=='+')pos1++;
    }
    int n=0,pos2=0,neg2=0 ;
    for(int i=0 ; i<s2.length(); i++){
      if(s2.charAt(i)=='+')pos2++;
      else if(s2.charAt(i)=='-')neg2++;
    }
    n=s2.length()-pos2-neg2 ;
    if(n==0){
      if(pos2==pos1)System.out.println(1);
      else System.out.println(0);
      return ;
    }
    double c=0 ;
    double pow=Math.pow(2,n);
    int t=(int)Math.pow(2,n);
    for(int i=0 ; i<t ; i++){
      String s=bin(i,n);
      int pos=0 ;
      for(int j=0 ; j<s.length(); j++){
        if(s.charAt(j)=='0')pos++;
      }
      if(pos+pos2==pos1)c++;
    }
    System.out.println(c/pow);
  }
  static String bin(int i,int len){
    String s="" ;
    while(i>0){
      s+=String.valueOf(i % 2);
      i/=2 ;
    }
    for(int j=s.length(); j<len ; j++)s+="0" ;
    StringBuilder sb=new StringBuilder(s);
    return String.valueOf(sb.reverse());
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_476 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s1 : String ; s1 := br.readLine() ;
    var s2 : String ; s2 := br.readLine() ;
    var pos1 : int ; pos1 := 0 ;
        var i : int ; i := 0 ; while i < s1->size() do ( (     if (s1->at(i+1) = '+') then     pos1 := pos1 + 1 ; else skip )  ;     i := i + 1 ) ; 
    var n : int ; n := 0 ;
    var pos2 : int ; pos2 := 0 ;
    var neg2 : int ; neg2 := 0 ;
        var i : int ; i := 0 ; while i < s2->size() do ( (     if (s2->at(i+1) = '+') then     pos2 := pos2 + 1 ; else     if (s2->at(i+1) = '-') then     neg2 := neg2 + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    n := s2->size() - pos2 - neg2 ; 
    if (n = 0) then (     if (pos2 = pos1) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println(0) ; ;  
     return ) else skip ; 
    var c : double ; c := 0 ;
    var pow : double ; pow := 2->pow(n) ;
    var t : int ; t := 2->pow(n)->oclAsType(int) ;
        var i : int ; i := 0 ; while i < t do ( (     var s : String ; s := bin(i, n) ;
     var pos : int ; pos := 0 ;
         var j : int ; j := 0 ; while j < s->size() do ( (     if (s->at(j+1) = '0') then     pos := pos + 1 ; else skip )  ;     j := j + 1 ) ; 
     if (pos + pos2 = pos1) then     c := c + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c / pow) ; 
 );
  static   operation bin( i : int, len : int) : String
  pre: true
  post: true
  activity: (     var s : String ; s := "" ;
     while (i > 0) do (     s := s+(((i mod 2) + "")) ; 
     i := i/(2) ) ; 
        var j : int ; j := s->size() ; while j < len do (     s := s+("0") ;  ;     j := j + 1 ) ; 
    var sb : String ; sb := StringLib.newString(s) ;
    return ((sb->reverse()) + "") 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF476B {
  public static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    String given=scanner.next();
    int p1=0,m1=0 ;
    for(int i=0 ; i<given.length(); i++){
      if(given.charAt(i)=='+')p1++;
      else m1++;
    }
    String received=scanner.next();
    int q=0 ;
    for(int i=0 ; i<received.length(); i++){
      if(received.charAt(i)=='+')p1--;
      else if(received.charAt(i)=='-')m1--;
      else q++;
    }
    if(p1<0 || m1<0){
      System.out.println("0.0");
    }
    else {
      double total=Math.pow(2,q);
      double winning=combination(q,p1)*combination((q-p1),m1);
      System.out.println(winning/total);
    }
  }
  public static long combination(int n,int r){
    long numerator=fact(n);
    long denominator=fact(n-r)*fact(r);
    return numerator/denominator ;
  }
  public static long fact(int n){
    if(n<=1)return 1 ;
    else return n*fact(n-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF476B {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var given : String ; given := scanner.getCurrent() ;
    var p1 : int ; p1 := 0 ;
    var m1 : int ; m1 := 0 ;
        var i : int ; i := 0 ; while i < given->size() do ( (     if (given->at(i+1) = '+') then     p1 := p1 + 1 ; else     m1 := m1 + 1 ; )  ;     i := i + 1 ) ; 
    var received : String ; received := scanner.getCurrent() ;
    var q : int ; q := 0 ;
        var i : int ; i := 0 ; while i < received->size() do ( (     if (received->at(i+1) = '+') then     p1 := p1 - 1 ; else     if (received->at(i+1) = '-') then     m1 := m1 - 1 else     q := q + 1 ; ;  )  ;     i := i + 1 ) ; 
    if (p1 < 0 or m1 < 0) then (     OclFile["System.out"].println("0.0") ) else (     var total : double ; total := 2->pow(q) ;
     var winning : double ; winning := combination(q, p1) * combination(((q)->char2byte() - (p1)->char2byte()), m1) ;
     OclFile["System.out"].println(winning / total) ) ;  
 );
  static   operation combination( n : int, r : int) : long
  pre: true
  post: true
  activity: (     var numerator : long ; numerator := fact(n) ;
     var denominator : long ; denominator := fact(n - r) * fact(r) ;
     return numerator / denominator );
  static   operation fact( n : int) : long
  pre: true
  post: true
  activity: (     if (n <= 1) then     return 1 else     return n * fact(n - 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Z_ccc_8_2 {
  static String s1 ;
  static String s2 ;
  static double all ;
  static double yes ;
  static double ans ;
  public static void main(String args[])throws IOException {
    InputStreamReader r=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(r);
    s1=br.readLine();
    s2=br.readLine();
    int p1=0 ;
    int p2=0 ;
    int n1=0 ;
    int n2=0 ;
    int q=0 ;
    for(int i=0 ; i<s1.length(); i++){
      if(s1.charAt(i)=='+'){
        p1++;
      }
      else if(s1.charAt(i)=='-'){
        n1++;
      }
      if(s2.charAt(i)=='+'){
        p2++;
      }
      else if(s2.charAt(i)=='-'){
        n2++;
      }
      else {
        q++;
      }
    }
    ans=1.0 ;
    if(p1==p2 && n1==n2 && q==0){
      System.out.println(ans);
    }
    else if(p2>p1 || n2>n1){
      System.out.println(0.0);
    }
    else {
      int remain_p=p1-p2 ;
      int remain_n=n1-n2 ;
      int count_p=0 ;
      int count_n=0 ;
      dp(count_p,count_n,remain_p,remain_n);
      System.out.println(yes/all);
    }
  }
  public static void dp(int count_p,int count_n,int remain_p,int remain_n){
    if(count_p+count_n==remain_p+remain_n){
      all++;
      if(count_p==remain_p && count_n==remain_n){
        yes++;
      }
    }
    else if(count_p+count_n<remain_p+remain_n){
      dp(count_p+1,count_n,remain_p,remain_n);
      dp(count_p,count_n+1,remain_p,remain_n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Z_ccc_8{
  static   attribute s1 : String;
  static   attribute s2 : String;
  static   attribute all : double;
  static   attribute yes : double;
  static   attribute ans : double;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(r) ;
    s1 := br.readLine() ; 
    s2 := br.readLine() ; 
    var p1 : int ; p1 := 0 ;
    var p2 : int ; p2 := 0 ;
    var n1 : int ; n1 := 0 ;
    var n2 : int ; n2 := 0 ;
    var q : int ; q := 0 ;
        var i : int ; i := 0 ; while i < s1->size() do ( (     if (s1->at(i+1) = '+') then (     p1 := p1 + 1 ) else     if (s1->at(i+1) = '-') then (     n1 := n1 + 1 ) else skip ; ;  
     if (s2->at(i+1) = '+') then (     p2 := p2 + 1 ) else     if (s2->at(i+1) = '-') then (     n2 := n2 + 1 ) else (     q := q + 1 ) ;  )  ;     i := i + 1 ) ; 
    ans := 1.0 ; 
    if (p1 = p2 & n1 = n2 & q = 0) then (     OclFile["System.out"].println(ans) ) else     if (p2 > p1 or n2 > n1) then (     OclFile["System.out"].println(0.0) ) else (     var remain_p : int ; remain_p := p1 - p2 ;
     var remain_n : int ; remain_n := n1 - n2 ;
    var count_p : int ; count_p := 0 ;
    var count_n : int ; count_n := 0 ;
    execute dp(count_p, count_n, remain_p, remain_n) ; 
    OclFile["System.out"].println(yes / all) ; 
 ) ;  ;  
 );
  static   operation dp( count_p : int, count_n : int, remain_p : int, remain_n : int) : void
  pre: true
  post: true
  activity: (     if (count_p + count_n = remain_p + remain_n) then (     all := all + 1 ; 
     if (count_p = remain_p & count_n = remain_n) then (     yes := yes + 1 ) else skip ) else     if (count_p + count_n < remain_p + remain_n) then (     execute dp(count_p + 1, count_n, remain_p, remain_n) ; 
     execute dp(count_p, count_n + 1, remain_p, remain_n) ) else skip ; );
}
 {
  static   attribute s1 : String;
  static   attribute s2 : String;
  static   attribute all : double;
  static   attribute yes : double;
  static   attribute ans : double;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(r) ;
    s1 := br.readLine() ; 
    s2 := br.readLine() ; 
    var p1 : int ; p1 := 0 ;
    var p2 : int ; p2 := 0 ;
    var n1 : int ; n1 := 0 ;
    var n2 : int ; n2 := 0 ;
    var q : int ; q := 0 ;
        var i : int ; i := 0 ; while i < s1->size() do ( (     if (s1->at(i+1) = '+') then (     p1 := p1 + 1 ) else     if (s1->at(i+1) = '-') then (     n1 := n1 + 1 ) else skip ; ;  
     if (s2->at(i+1) = '+') then (     p2 := p2 + 1 ) else     if (s2->at(i+1) = '-') then (     n2 := n2 + 1 ) else (     q := q + 1 ) ;  )  ;     i := i + 1 ) ; 
    ans := 1.0 ; 
    if (p1 = p2 & n1 = n2 & q = 0) then (     OclFile["System.out"].println(ans) ) else     if (p2 > p1 or n2 > n1) then (     OclFile["System.out"].println(0.0) ) else (     var remain_p : int ; remain_p := p1 - p2 ;
     var remain_n : int ; remain_n := n1 - n2 ;
    var count_p : int ; count_p := 0 ;
    var count_n : int ; count_n := 0 ;
    execute dp(count_p, count_n, remain_p, remain_n) ; 
    OclFile["System.out"].println(yes / all) ; 
 ) ;  ;  
 );
  static   operation dp( count_p : int, count_n : int, remain_p : int, remain_n : int) : void
  pre: true
  post: true
  activity: (     if (count_p + count_n = remain_p + remain_n) then (     all := all + 1 ; 
     if (count_p = remain_p & count_n = remain_n) then (     yes := yes + 1 ) else skip ) else     if (count_p + count_n < remain_p + remain_n) then (     execute dp(count_p + 1, count_n, remain_p, remain_n) ; 
     execute dp(count_p, count_n + 1, remain_p, remain_n) ) else skip ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class codefrce {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      System.out.print("1"+" "+(n-1));
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codefrce {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].print("1" + " " + (n - 1)) ; 
     OclFile["System.out"].println() ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findMaximumBefore(int arr[],int n){
    for(int i=0 ; i<n ; i++){
      int currAns=-1 ;
      for(int j=i-1 ; j>=0 ; j--){
        if(arr[j]>currAns && arr[j]<arr[i]){
          currAns=arr[j];
        }
      }
      System.out.print(currAns+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      4,7,6,8,5 };
      int n=arr.length ;
      findMaximumBefore(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMaximumBefore( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var currAns : int ; currAns := -1 ;
         var j : int ; j := i - 1 ; while j >= 0 do ( (     if (arr[j+1] > currAns & arr[j+1] < arr[i+1]) then (     currAns := arr[j+1] ) else skip )  ;     j := j - 1 ) ; 
     OclFile["System.out"].print(currAns + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,7,6,8,5} ;
     var n : int ; n := arr->size() ;
     execute findMaximumBefore(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void find(int a[],int n){
    int count_odd=0 ;
    for(int i=0 ; i<n ; i++){
      if(i % 2!=0){
        count_odd+=1 ;
      }
    }
    int result=(int)(Math.pow(2,n)-1);
    result-=(Math.pow(2,count_odd)-1);
    System.out.println(result);
  }
  public static void main(String[] args){
    int a[]={
      2,2,3 };
      int n=a.length ;
      find(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var count_odd : int ; count_odd := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 /= 0) then (     count_odd := count_odd+(1) ) else skip )  ;     i := i + 1 ) ; 
    var result : int ; result := (2->pow(n) - 1)->oclAsType(int) ;
    result := result-((2->pow(count_odd) - 1)) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,2,3} ;
     var n : int ; n := a->size() ;
     execute find(a, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GfG {
  public static int doMatch(String A,String B){
    for(int i=0 ; i<A.length(); i++){
      if(A.charAt(i)!='*' && B.charAt(i)!='*'){
        if(A.charAt(i)!=B.charAt(i))return 0 ;
      }
    }
    return 1 ;
  }
  public static void main(String[] args){
    String A="gee*sforgeeks" ;
    String B="geeksforgeeks" ;
    System.out.println(doMatch(A,B));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation doMatch( A : String, B : String) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < A->size() do ( (     if (A->at(i+1) /= '*' & B->at(i+1) /= '*') then (     if (A->at(i+1) /= B->at(i+1)) then     return 0 else skip ) else skip )  ;     i := i + 1 ) ; 
     return 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : String ; A := "gee*sforgeeks" ;
     var B : String ; B := "geeksforgeeks" ;
     OclFile["System.out"].println(doMatch(A, B)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void bonacciseries(int n,int m){
    int a[]=new int[m];
    for(int i=0 ; i<m ; i++)a[i]=0 ;
    a[n-1]=1 ;
    a[n]=1 ;
    for(int i=n+1 ; i<m ; i++)a[i]=2*a[i-1]-a[i-n-1];
    for(int i=0 ; i<m ; i++)System.out.print(a[i]+" ");
  }
  public static void main(String args[]){
    int N=5,M=15 ;
    bonacciseries(N,M);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation bonacciseries( n : int, m : int) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
         var i : int ; i := 0 ; while i < m do (     a[i+1] := 0 ;  ;     i := i + 1 ) ; 
    a[n - 1+1] := 1 ; 
    a[n+1] := 1 ; 
        var i : int ; i := n + 1 ; while i < m do (     a[i+1] := 2 * a[i - 1+1] - a[i - n - 1+1] ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
    var M : int ; M := 15 ;
     execute bonacciseries(N, M) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int INT_BITS=32 ;
  static int maxSubarrayXOR(int set[],int n){
    int index=0 ;
    for(int i=INT_BITS-1 ; i>=0 ; i--){
      int maxInd=index ;
      int maxEle=Integer.MIN_VALUE ;
      for(int j=index ; j<n ; j++){
        if((set[j] &(1<<i))!=0 && set[j]>maxEle){
          maxEle=set[j];
          maxInd=j ;
        }
      }
      if(maxEle==-2147483648)continue ;
      int temp=set[index];
      set[index]=set[maxInd];
      set[maxInd]=temp ;
      maxInd=index ;
      for(int j=0 ; j<n ; j++){
        if(j!=maxInd &&(set[j] &(1<<i))!=0)set[j]=set[j] ^ set[maxInd];
      }
      index++;
    }
    int res=0 ;
    for(int i=0 ; i<n ; i++)res ^=set[i];
    return res ;
  }
  public static void main(String arg[]){
    int set[]={
      9,8,5 };
      int n=set.length ;
      System.out.print("Max subset XOR is ");
      System.out.print(maxSubarrayXOR(set,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute INT_BITS : int := 32;
  static   operation maxSubarrayXOR( set : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var index : int ; index := 0 ;
         var i : int ; i := INT_BITS - 1 ; while i >= 0 do ( (     var maxInd : int ; maxInd := index ;
     var maxEle : int ; maxEle := -2147483648 ;
        var j : int ; j := index ; while j < n do ( (     if ((set[j+1] & ((1*(2->pow(i)))->oclAsType(long))) /= 0 & set[j+1] > maxEle) then (     maxEle := set[j+1] ; 
     maxInd := j ) else skip )  ;     j := j + 1 ) ; 
    if (maxEle = -2147483648) then     continue else skip ; 
    var temp : int ; temp := set[index+1] ;
    set[index+1] := set[maxInd+1] ; 
    set[maxInd+1] := temp ; 
    maxInd := index ; 
        var j : int ; j := 0 ; while j < n do ( (     if (j /= maxInd & (set[j+1] & ((1*(2->pow(i)))->oclAsType(long))) /= 0) then     set[j+1] := set[j+1] xor set[maxInd+1] ; else skip )  ;     j := j + 1 ) ; 
    index := index + 1 ; 
 )  ;     i := i - 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do (     res := MathLib.bitwiseXor(res,set[i+1]) ;  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var set : Sequence(int) ; set := Sequence{9,8,5} ;
     var n : int ; n := set->size() ;
     OclFile["System.out"].print("Max subset XOR is ") ; 
     OclFile["System.out"].print(maxSubarrayXOR(set, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void bonacciseries(int n,int m){
    int[] a=new int[m];
    a[n-1]=1 ;
    for(int i=n ; i<m ; i++)for(int j=i-n ; j<i ; j++)a[i]+=a[j];
    for(int i=0 ; i<m ; i++)System.out.print(a[i]+" ");
  }
  public static void main(String args[]){
    int N=5,M=15 ;
    bonacciseries(N,M);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation bonacciseries( n : int, m : int) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
     a[n - 1+1] := 1 ; 
         var i : int ; i := n ; while i < m do (         var j : int ; j := i - n ; while j < i do (     a[i+1] := a[i+1]+(a[j+1]) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < m do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
    var M : int ; M := 15 ;
     execute bonacciseries(N, M) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.PriorityQueue ;
public class OddSum {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    PriorityQueue<Integer>negative=new PriorityQueue<>((a,b)->(b-a));
    PriorityQueue<Integer>odd=new PriorityQueue<>();
    int sum=0 ;
    String[] temp=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      int num=Integer.parseInt(temp[i]);
      if(num>0){
        sum+=num ;
        if(num % 2==1){
          odd.add(num);
        }
      }
      else if(num<0){
        negative.add(num);
      }
    }
    if(sum % 2==1){
      pr.println(sum);
      return ;
    }
    if(odd.size()==0){
      while(negative.size()!=0){
        int current=negative.poll();
        if(current % 2!=0){
          pr.println(sum+current);
          return ;
        }
      }
    }
    else if(odd.size()!=0){
      int res1=sum-odd.peek();
      while(negative.size()!=0){
        int current=negative.poll();
        if(current % 2!=0){
          pr.println(Math.max(res1,sum+current));
          return ;
        }
      }
      pr.println(res1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class OddSum {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var negative : Sequence(int) ; negative := Sequence{}->union(lambda (a , b) : OclAny in (b - a)) ;
    var odd : Sequence(int) ; odd := Sequence{} ;
    var sum : int ; sum := 0 ;
    var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := (temp[i+1])->toInteger() ;
     if (num > 0) then (     sum := sum+(num) ; 
     if (num mod 2 = 1) then (     odd := odd->including(num) ) else skip ) else     if (num < 0) then (     negative := negative->including(num) ) else skip ; )  ;     i := i + 1 ) ; 
    if (sum mod 2 = 1) then (     skip ; 
     return ) else skip ; 
    if (odd->size() = 0) then (     while (negative->size() /= 0) do (     var current : int ; current := negative->min() ;
     if (current mod 2 /= 0) then (     skip ; 
     return ) else skip ) ) else     if (odd->size() /= 0) then (     var res1 : int ; res1 := sum - odd->min() ;
     while (negative->size() /= 0) do (     var current : int ; current := negative->min() ;
     if (current mod 2 /= 0) then (     skip ; 
     return ) else skip ) ; 
     skip ) else skip ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class calc {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),sum=0,max=Integer.MIN_VALUE,min=Integer.MAX_VALUE ;
    while(n-->0){
      int num=in.nextInt();
      if(num>=0){
        sum+=num ;
        if(num % 2==1)min=Math.min(min,num);
      }
      else {
        if(num % 2==-1)max=Math.max(max,num);
      }
    }
    if(sum % 2==1)System.out.println(sum);
    else System.out.println(Math.max(sum-min,sum+max));
  }
}
------------------------------------------------------------
OCL File:
---------
 class calc {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var max : int ; max := -2147483648 ;
    var min : int ; min := 2147483647 ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var num : int ; num := in.getCurrent()->toInteger() ;
     if (num >= 0) then (     sum := sum+(num) ; 
     if (num mod 2 = 1) then     min := Set{min, num}->min() ; else skip ) else (     if (num mod 2 = -1) then     max := Set{max, num}->max() ; else skip ) ) ;  ) ;  
     if (sum mod 2 = 1) then     OclFile["System.out"].println(sum) ; else     OclFile["System.out"].println(Set{sum - min, sum + max}->max()) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int n=3 ;
  static int m=4 ;
  static int maxMatrixScore(int A[][],int K){
    HashMap<Integer,Integer>update=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; ++i){
      if(A[i][0]==0){
        int ans=0 ;
        for(int j=1 ; j<m ; ++j)ans=(int)(ans+A[i][j]*Math.pow(2,m-j-1));
        update.put(ans,i);
      }
    }
    for(Map.Entry<Integer,Integer>it : update.entrySet())if(K>0){
      int idx=it.getValue();
      for(int j=0 ; j<m ; ++j)A[idx][j]=(A[idx][j]+1)% 2 ;
      K--;
    }
    int ans=0 ;
    for(int j=0 ; j<m ; ++j){
      int zero=0,one=0 ;
      for(int i=0 ; i<n ; ++i){
        if(A[i][j]==0)zero++;
        else one++;
      }
      if(K>0 && zero>one){
        ans+=zero*Math.pow(2,m-j-1);
        K--;
      }
      else ans+=one*Math.pow(2,m-j-1);
    }
    return ans ;
  }
  public static void main(String[] args){
    int A[][]={
      {
        0,0,1,1 },{
          1,0,1,0 },{
            1,1,0,0 }
          };
          int K=2 ;
          System.out.print(maxMatrixScore(A,K));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute n : int := 3;
  static   attribute m : int := 4;
  static   operation maxMatrixScore( A : Sequence(Sequence(int)), K : int) : int
  pre: true
  post: true
  activity: (     var update : Map(int,int) ; update := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (A[i+1][0+1] = 0) then (     var ans : int ; ans := 0 ;
         var j : int ; j := 1 ; while j < m do (     ans := (ans + A[i+1][j+1] * 2->pow(m - j - 1))->oclAsType(int) ;  ;     j := j + 1 ) ; 
     update := update->union(Map{ans |-> i}) ) else skip )  ;     i := i + 1 ) ; 
    for (it : update->asSet()) do (     if (K > 0) then (     var idx : int ; idx := it.getValue() ;
         var j : int ; j := 0 ; while j < m do (     A[idx+1][j+1] := (A[idx+1][j+1] + 1) mod 2 ;  ;     j := j + 1 ) ; 
     K := K - 1 ) else skip ;  ) ; 
    var ans : int ; ans := 0 ;
        var j : int ; j := 0 ; while j < m do ( (     var zero : int ; zero := 0 ;
    var one : int ; one := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (A[i+1][j+1] = 0) then     zero := zero + 1 ; else     one := one + 1 ; )  ;     i := i + 1 ) ; 
     if (K > 0 & zero > one) then (     ans := ans+(zero * 2->pow(m - j - 1)) ; 
     K := K - 1 ) else     ans := ans+(one * 2->pow(m - j - 1)) ; )  ;     j := j + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(Sequence(int)) ; A := Sequence{Sequence{0,0,1,1},Sequence{1,0,1,0},Sequence{1,1,0,0}} ;
     var K : int ; K := 2 ;
     OclFile["System.out"].print(maxMatrixScore(A, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] array=new int[n];
    for(int i=0 ; i<n ; i++){
      array[i]=sc.nextInt();
    }
    int min=1001001009 ;
    for(int i=-100 ; i<=100 ; i++){
      int tmp=0 ;
      for(int j=0 ; j<n ; j++){
        tmp+=(array[j]-i)*(array[j]-i);
      }
      min=Math.min(min,tmp);
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var min : int ; min := 1001001009 ;
        var i : int ; i := -100 ; while i <= 100 do ( (     var tmp : int ; tmp := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     tmp := tmp+((array[j+1] - i) * (array[j+1] - i)) )  ;     j := j + 1 ) ; 
     min := Set{min, tmp}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Queue ;
import java.util.Random ;
import java.util.Scanner ;
public class Main {
  private static Scanner sc=new Scanner(System.in);
  static long mod=1000000007 ;
  public static void main(String[] args){
    int N=sc.nextInt();
    int a[]=new int[N];
    int sum=0 ;
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextInt();
      sum+=a[i];
    }
    sum/=N ;
    int ans=10000009 ;
    for(int c=0 ; c<2 ; c++){
      int tmp=0 ;
      for(int i=0 ; i<N ; i++){
        tmp+=(sum-a[i])*(sum-a[i]);
      }
      ans=Math.min(ans,tmp);
      sum++;
    }
    p(ans);
  }
  public static long modPow(long g,long N){
    long T=1 ;
    for(int i=0 ; i<N ; i++){
      T*=g ;
      T %=mod ;
    }
    return T ;
  }
  public static long lcm(long a,long b){
    return a/gcd(a,b)*b ;
  }
  public static long gcd(long a,long b){
    return b==0 ? a : gcd(b,a % b);
  }
  static void p(String ans){
    System.out.println(ans);
  };
  static void p(int ans){
    System.out.println(ans);
  };
  static void p(){
    System.out.println();
  };
  static void p(long ans){
    System.out.println(ans);
  };
  static void p(double ans){
    System.out.println(ans);
  };
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute mod : long := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    sum := sum/(N) ; 
    var ans : int ; ans := 10000009 ;
        var c : int ; c := 0 ; while c < 2 do ( (     var tmp : int ; tmp := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     tmp := tmp+((sum - a[i+1]) * (sum - a[i+1])) )  ;     i := i + 1 ) ; 
     ans := Set{ans, tmp}->min() ; 
     sum := sum + 1 )  ;     c := c + 1 ) ; 
    execute p(ans) ; 
 );
  static   operation modPow( g : long, N : long) : long
  pre: true
  post: true
  activity: (     var T : long ; T := 1 ;
         var i : int ; i := 0 ; while i < N do ( (     T := T*(g) ; 
     T := T mod mod )  ;     i := i + 1 ) ; 
     return T );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return a / gcd(a, b) * b );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
  static   operation p( ans : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( ans : long) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : double) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    int[] arr=new int[t];
    for(int i=0 ; i!=t ; ++i)arr[i]=Integer.parseInt(br.readLine());
    for(int item : arr)out.println("1 "+(item-1));
    out.flush();
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,t)->collect(0) ;
        var i : int ; i := 0 ; while i /= t do (     arr[i+1] := (br.readLine())->toInteger() ;  ;     i := i + 1 ) ; 
    for (item : arr) do (     skip ;  ) ; 
    skip ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      int n=Integer.parseInt(br.readLine());
      String[] str=br.readLine().split(" ");
      int num[]=new int[n];
      int ave=0 ;
      for(int i=0 ; i<n ; i++){
        num[i]=Integer.parseInt(str[i]);
        ave+=num[i];
      }
      double ave2=(double)(ave)/n ;
      int ave3=(int)Math.round(ave2);
      int cost=0 ;
      for(int i=0 ; i<n ; i++){
        double buf=ave2-num[i];
        if(buf<=0.5 &&-0.5<=buf){
        }
        else {
          cost+=Math.pow((num[i]-ave3),2);
        }
      }
      System.out.println(cost);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var n : int ; n := (br.readLine())->toInteger() ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var num : Sequence(int) ; num := Integer.subrange(1,n)->collect(0) ;
    var ave : int ; ave := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     num[i+1] := (str[i+1])->toInteger() ; 
     ave := ave+(num[i+1]) )  ;     i := i + 1 ) ; 
    var ave2 : double ; ave2 := (ave)->oclAsType(double) / n ;
    var ave3 : int ; ave3 := (ave2)->round()->oclAsType(int) ;
    var cost : int ; cost := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var buf : double ; buf := ave2 - num[i+1] ;
     if (buf <= 0.5 & -0.5 <= buf) then skip else (     cost := cost+((num[i+1] - ave3)->pow(2)) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cost) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] $){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),sum=0,cmin=Integer.MAX_VALUE,min=Integer.MAX_VALUE,max=Integer.MIN_VALUE ;
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      max=Math.max(max,a[i]);
      min=Math.min(min,a[i]);
    }
    for(int i=min ; i<=max ; i++){
      for(int j=0 ; j<n ; j++){
        sum+=(a[j]-i)*(a[j]-i);
      }
      cmin=Math.min(sum,cmin);
      sum=0 ;
    }
    System.out.println(cmin);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var cmin : int ; cmin := 2147483647 ;
    var min : int ; min := 2147483647 ;
    var max : int ; max := -2147483648 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     max := Set{max, a[i+1]}->max() ; 
     min := Set{min, a[i+1]}->min() )  ;     i := i + 1 ) ; 
        var i : int ; i := min ; while i <= max do ( (         var j : int ; j := 0 ; while j < n do ( (     sum := sum+((a[j+1] - i) * (a[j+1] - i)) )  ;     j := j + 1 ) ; 
     cmin := Set{sum, cmin}->min() ; 
     sum := 0 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cmin) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int N=gi();
    double[] A=new double[N];
    double m=0 ;
    for(int i=0 ; i<N ; i++){
      A[i]=gi();
      m+=A[i];
    }
    m=Math.round(m/N);
    int s=0 ;
    for(int i=0 ; i<N ; i++){
      s+=(m-A[i])*(m-A[i]);
    }
    System.out.print(s);
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : int ; N := gi() ;
    var A : Sequence(double) ; A := Integer.subrange(1,N)->collect(0.0) ;
    var m : double ; m := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := gi() ; 
     m := m+(A[i+1]) )  ;     i := i + 1 ) ; 
    m := (m / N)->round() ; 
    var s : int ; s := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     s := s+((m - A[i+1]) * (m - A[i+1])) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(s) ; 
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int number=sc.nextInt();
    int[] wooden=new int[number];
    for(int i=0 ; i<wooden.length ; i++){
      int each=sc.nextInt();
      wooden[i]=each ;
    }
    int[] height=new int[wooden.length];
    int count ;
    for(int i=0 ; i<wooden.length ; i++){
      if(wooden[i]==0){
        continue ;
      }
      else {
        count=1 ;
        for(int j=i+1 ; j<wooden.length ; j++){
          if(wooden[i]==wooden[j]){
            wooden[j]=0 ;
            count++;
          }
        }
        height[i]=count ;
      }
    }
    int index=0 ;
    int max=height[0];
    for(int i=0 ; i<height.length ; i++){
      if(height[i]!=0){
        index++;
      }
      if(max<height[i]){
        max=height[i];
      }
    }
    System.out.println(max+" "+index);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := sc.getCurrent()->toInteger() ;
    var wooden : Sequence(int) ; wooden := Integer.subrange(1,number)->collect(0) ;
        var i : int ; i := 0 ; while i < wooden->size() do ( (     var each : int ; each := sc.getCurrent()->toInteger() ;
     wooden[i+1] := each )  ;     i := i + 1 ) ; 
    var height : Sequence(int) ; height := Integer.subrange(1,wooden->size())->collect(0) ;
    var count : int ;
        var i : int ; i := 0 ; while i < wooden->size() do ( (     if (wooden[i+1] = 0) then (     continue ) else (     count := 1 ; 
         var j : int ; j := i + 1 ; while j < wooden->size() do ( (     if (wooden[i+1] = wooden[j+1]) then (     wooden[j+1] := 0 ; 
     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
     height[i+1] := count ) )  ;     i := i + 1 ) ; 
    var index : int ; index := 0 ;
    var max : int ; max := height[0+1] ;
        var i : int ; i := 0 ; while i < height->size() do ( (     if (height[i+1] /= 0) then (     index := index + 1 ) else skip ; 
     if (max < height[i+1]) then (     max := height[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max + " " + index) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=10 ;
  static String getMaxEven(char[] str,int len){
    int[] freq=new int[MAX];
    int i,minEvenDigit=MAX,minDigit=MAX ;
    for(i=0 ; i<len ; i++){
      int digit=str[i]-'0' ;
      freq[digit]++;
      if(digit % 2==0)minEvenDigit=Math.min(digit,minEvenDigit);
      minDigit=Math.min(digit,minDigit);
    }
    if(minEvenDigit==MAX)return "-1" ;
    freq[minEvenDigit]--;
    freq[minDigit]--;
    i=0 ;
    for(int j=MAX-1 ; j>=0 ; j--){
      for(int k=0 ; k<freq[j]; k++)str[i++]=(char)(j+'0');
      if(j==minEvenDigit)str[i++]=(char)(minDigit+'0');
    }
    str[i-1]=(char)(minEvenDigit+'0');
    return String.valueOf(str);
  }
  public static void main(String[] args){
    char[] str="1023422".toCharArray();
    int len=str.length ;
    System.out.println(getMaxEven(str,len));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 10;
  static   operation getMaxEven( str : Sequence(String), len : int) : String
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,MAX)->collect(0) ;
     var i : int ;
    var minEvenDigit : int ; minEvenDigit := MAX ;
    var minDigit : int ; minDigit := MAX ;
        i := 0 ; while i < len do ( (     var digit : int ; digit := str[i+1] - ('0')->char2byte() ;
     freq[digit+1] := freq[digit+1] + 1 ; 
     if (digit mod 2 = 0) then     minEvenDigit := Set{digit, minEvenDigit}->min() ; else skip ; 
     minDigit := Set{digit, minDigit}->min() )  ;     i := i + 1 ) ; 
    if (minEvenDigit = MAX) then     return "-1" else skip ; 
    freq[minEvenDigit+1] := freq[minEvenDigit+1] - 1 ; 
    freq[minDigit+1] := freq[minDigit+1] - 1 ; 
    i := 0 ; 
        var j : int ; j := MAX - 1 ; while j >= 0 do ( (         var k : int ; k := 0 ; while k < freq[j+1] do (      str[i+1] := (j + '0')->oclAsType(String)  ; i := i + 1 ;  ;     k := k + 1 ) ; 
     if (j = minEvenDigit) then      str[i+1] := (minDigit + '0')->oclAsType(String)  ; i := i + 1 ; else skip )  ;     j := j - 1 ) ; 
    str[i - 1+1] := (minEvenDigit + '0')->oclAsType(String) ; 
    return ((str) + "") 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := "1023422"->characters() ;
     var len : int ; len := str->size() ;
     OclFile["System.out"].println(getMaxEven(str, len)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long count_of_ways(long n){
    long count=0 ;
    count=(n+1)*(n+2)/2 ;
    return count ;
  }
  public static void main(String[] args){
    long n=3 ;
    System.out.println(count_of_ways(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count_of_ways( n : long) : long
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
     count := (n + 1) * (n + 2) / 2 ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 3 ;
     OclFile["System.out"].println(count_of_ways(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int sumOdd(int n){
    int terms=(n+1)/2 ;
    int sum=terms*terms ;
    return sum ;
  }
  static int suminRange(int l,int r){
    return sumOdd(r)-sumOdd(l-1);
  }
  public static void main(String[] args){
    int l=2,r=5 ;
    System.out.print("Sum of odd natural numbers from L to R is "+suminRange(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOdd( n : int) : int
  pre: true
  post: true
  activity: (     var terms : int ; terms := (n + 1) / 2 ;
     var sum : int ; sum := terms * terms ;
     return sum );
  static   operation suminRange( l : int, r : int) : int
  pre: true
  post: true
  activity: (     return sumOdd(r) - sumOdd(l - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 2 ;
    var r : int ; r := 5 ;
     OclFile["System.out"].print("Sum of odd natural numbers from L to R is " + suminRange(l, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int __gcd(int a,int b){
    if(b==0){
      return a ;
    }
    else {
      return __gcd(b,a % b);
    }
  }
  static int power(int x,int y,int m){
    if(y==0)return 1 ;
    int p=power(x,y/2,m)% m ;
    p=(p*p)% m ;
    return(y % 2==0)? p :(x*p)% m ;
  }
  static void modInverse(int a,int m){
    if(__gcd(a,m)!=1)System.out.print("Inverse doesn't exist");
    else {
      System.out.print("Modular multiplicative inverse is "+power(a,m-2,m));
    }
  }
  public static void main(String[] args){
    int a=3,m=11 ;
    modInverse(a,m);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else (     return __gcd(b, a mod b) ) );
  static   operation power( x : int, y : int, m : int) : int
  pre: true
  post: true
  activity: (     if (y = 0) then     return 1 else skip ; 
     var p : int ; p := power(x, y / 2, m) mod m ;
     p := (p * p) mod m ; 
     return if (y mod 2 = 0) then p else (x * p) mod m endif );
  static   operation modInverse( a : int, m : int) : void
  pre: true
  post: true
  activity: (     if (__gcd(a, m) /= 1) then     OclFile["System.out"].print("Inverse doesn't exist") ; else (     OclFile["System.out"].print("Modular multiplicative inverse is " + power(a, m - 2, m)) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var m : int ; m := 11 ;
     execute modInverse(a, m) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int Count_subarray(int arr[],int n){
    int total_sum=0,subarray_sum,remaining_sum,count=0 ;
    for(int i=0 ; i<n ; i++){
      total_sum+=arr[i];
    }
    for(int i=0 ; i<n ; i++){
      subarray_sum=0 ;
      for(int j=i ; j<n ; j++){
        subarray_sum+=arr[j];
        remaining_sum=total_sum-subarray_sum ;
        if(subarray_sum>remaining_sum){
          count+=1 ;
        }
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      10,9,12,6 };
      int n=arr.length ;
      System.out.print(Count_subarray(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Count_subarray( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var total_sum : int ; total_sum := 0 ;
    var subarray_sum : int ;
    var remaining_sum : int ;
    var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     total_sum := total_sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     subarray_sum := 0 ; 
         var j : int ; j := i ; while j < n do ( (     subarray_sum := subarray_sum+(arr[j+1]) ; 
     remaining_sum := total_sum - subarray_sum ; 
     if (subarray_sum > remaining_sum) then (     count := count+(1) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,9,12,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(Count_subarray(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javax.swing.*;
import java.io.*;
import java.util.*;
import java.io.IOException ;
import java.io.InputStream ;
import java.util.jar.Attributes ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int m=in.nextInt();
      int[] x=new int[n];
      for(int i=0 ; i<m ; i++){
        int s=in.nextInt();
        x[s-1]++;
      }
      int min=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; i++){
        min=Math.min(min,x[i]);
      }
      out.println(min);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var m : int ; m := in.nextInt() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     var s : int ; s := in.nextInt() ;
     x[s - 1+1] := x[s - 1+1] + 1 )  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     min := Set{min, x[i+1]}->min() )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.System.*;
import static java.lang.Math.max ;
import static java.lang.Math.min ;
import static java.lang.Math.abs ;
public class pre1 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int m=obj.nextInt(),n=obj.nextInt();
    int arr[]=new int[m+1];
    for(int i=0 ; i<n ; i++){
      int l=obj.nextInt();
      arr[l]++;
    }
    int ans=Integer.MAX_VALUE ;
    for(int i=1 ; i<=m ; i++)ans=min(arr[i],ans);
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre1 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var m : int ; m := obj.nextInt() ;
    var n : int ; n := obj.nextInt() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,m + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var l : int ; l := obj.nextInt() ;
     arr[l+1] := arr[l+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 1 ; while i <= m do (     ans := Set{arr[i+1], ans}->min() ;  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1325 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int x=in.nextInt();
      System.out.println(1+" "+(x-1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1325 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x : int ; x := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println(1 + " " + (x - 1)) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int[] cnt=new int[n+1];
    for(int i=0 ; i<m ; ++i){
      int c=in.nextInt();
      cnt[c]++;
    }
    int ans=m ;
    for(int i=1 ; i<=n ; ++i){
      if(cnt[i]<ans){
        ans=cnt[i];
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     var c : int ; c := in.getCurrent()->toInteger() ;
     cnt[c+1] := cnt[c+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := m ;
        var i : int ; i := 1 ; while i <= n do ( (     if (cnt[i+1] < ans) then (     ans := cnt[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int[] x=new int[n+1];
    for(int i=0 ; i<m ; i++){
      int c=in.nextInt();
      x[c]++;
    }
    Arrays.sort(x,1,n+1);
    System.out.println(x[1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     var c : int ; c := in.getCurrent()->toInteger() ;
     x[c+1] := x[c+1] + 1 )  ;     i := i + 1 ) ; 
    x := x.subrange(1,1)^(x.subrange(1+1,n + 1)->sort())^x.subrange(n + 1+1,x.size) ; 
    OclFile["System.out"].println(x[1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class _0633Towers {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[1001];
    int max=0 ;
    int pos=0 ;
    for(int i=0 ; i<n ; i++){
      arr[sc.nextInt()]++;
    }
    int count=0 ;
    for(int i=1 ; i<arr.length ; i++){
      if(arr[i]!=0){
        count++;
      }
      max=Math.max(max,arr[i]);
    }
    System.out.println(max+" "+count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _0633Towers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,1001)->collect(0) ;
    var max : int ; max := 0 ;
    var pos : int ; pos := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[sc.getCurrent()->toInteger()+1] := arr[sc.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < arr->size() do ( (     if (arr[i+1] /= 0) then (     count := count + 1 ) else skip ; 
     max := Set{max, arr[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max + " " + count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findNumbers(String s){
    int n=s.length();
    int count=1 ;
    int result=0 ;
    int left=0 ;
    int right=1 ;
    while(right<n){
      if(s.charAt(left)==s.charAt(right)){
        count++;
      }
      else {
        result+=count*(count+1)/2 ;
        left=right ;
        count=1 ;
      }
      right++;
    }
    result+=count*(count+1)/2 ;
    System.out.println(result);
  }
  public static void main(String[] args){
    String s="bbbcbb" ;
    findNumbers(s);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNumbers( s : String) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var count : int ; count := 1 ;
    var result : int ; result := 0 ;
    var left : int ; left := 0 ;
    var right : int ; right := 1 ;
    while (right < n) do (     if (s->at(left+1) = s->at(right+1)) then (     count := count + 1 ) else (     result := result+(count * (count + 1) / 2) ; 
     left := right ; 
     count := 1 ) ;  
     right := right + 1 ) ; 
    result := result+(count * (count + 1) / 2) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "bbbcbb" ;
     execute findNumbers(s) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=10 ;
  static int findSubarray(int array[],int n){
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    mp.put(0,1);
    int answer=0 ;
    int preXor=0 ;
    for(int i=0 ; i<n ; i++){
      int value=1 ;
      preXor ^=array[i];
      for(int j=1 ; j<=MAX ; j++){
        int Y=value ^ preXor ;
        if(mp.containsKey(Y)){
          answer+=mp.get(Y);
        }
        value*=2 ;
      }
      if(mp.containsKey(preXor)){
        mp.put(preXor,mp.get(preXor)+1);
      }
      else {
        mp.put(preXor,1);
      }
    }
    return answer ;
  }
  public static void main(String[] args){
    int array[]={
      2,6,7,5,8 };
      int n=array.length ;
      System.out.println(findSubarray(array,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 10;
  static   operation findSubarray( array : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
     mp := mp->union(Map{0 |-> 1}) ; 
    var answer : int ; answer := 0 ;
    var preXor : int ; preXor := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var value : int ; value := 1 ;
     preXor := MathLib.bitwiseXor(preXor,array[i+1]) ; 
         var j : int ; j := 1 ; while j <= MAX do ( (     var Y : int ; Y := MathLib.bitwiseXor(value,preXor) ;
     if (mp->keys()->includes(Y)) then (     answer := answer+(mp->at(Y)) ) else skip ; 
     value := value*(2) )  ;     j := j + 1 ) ; 
     if (mp->keys()->includes(preXor)) then (     mp := mp->union(Map{preXor |-> mp->at(preXor) + 1}) ) else (     mp := mp->union(Map{preXor |-> 1}) ) )  ;     i := i + 1 ) ; 
    return answer 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Sequence{2,6,7,5,8} ;
     var n : int ; n := array->size() ;
     OclFile["System.out"].println(findSubarray(array, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long t=0 ;
    int time[]=new int[n];
    int f[]=new int[n];
    time[0]=sc.nextInt();
    f[0]=sc.nextInt();
    t+=f[0];
    int max=-1 ;
    max=(int)Math.max(t,max);
    for(int i=1 ; i<n ; i++){
      time[i]=sc.nextInt();
      t-=time[i]-time[i-1];
      if(t<0)t=0 ;
      f[i]=sc.nextInt();
      t+=f[i];
      max=(int)Math.max(t,max);
    }
    String s=(t+time[n-1])+" "+max ;
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : long ; t := 0 ;
    var time : Sequence(int) ; time := Integer.subrange(1,n)->collect(0) ;
    var f : Sequence(int) ; f := Integer.subrange(1,n)->collect(0) ;
    time[0+1] := sc.getCurrent()->toInteger() ; 
    f[0+1] := sc.getCurrent()->toInteger() ; 
    t := t+(f[0+1]) ; 
    var max : int ; max := -1 ;
    max := Set{t, max}->max()->oclAsType(int) ; 
        var i : int ; i := 1 ; while i < n do ( (     time[i+1] := sc.getCurrent()->toInteger() ; 
     t := t-(time[i+1] - time[i - 1+1]) ; 
    if (t < 0) then     t := 0 ; else skip ; 
    f[i+1] := sc.getCurrent()->toInteger() ; 
    t := t+(f[i+1]) ; 
    max := Set{t, max}->max()->oclAsType(int) ; 
 )  ;     i := i + 1 ) ; 
    var s : String ; s := (t + time[n - 1+1]) + " " + max ;
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int n=cin.nextInt();
    int m=cin.nextInt();
    int h=cin.nextInt();
    int x=h,max=x ;
    while(n-->1){
      int t=cin.nextInt();
      int c=cin.nextInt();
      x-=(t-m);
      if(x<0)x=0 ;
      x+=c ;
      max=Math.max(max,x);
      m=t ;
    }
    System.out.println((x+m)+" "+max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := cin.getCurrent()->toInteger() ;
    var m : int ; m := cin.getCurrent()->toInteger() ;
    var h : int ; h := cin.getCurrent()->toInteger() ;
    var x : int ; x := h ;
    var max : int ; max := x ;
        while (n > 1) do (        n := n - 1 ;     skip ; (     var t : int ; t := cin.getCurrent()->toInteger() ;
     var c : int ; c := cin.getCurrent()->toInteger() ;
    x := x-((t - m)) ; 
    if (x < 0) then     x := 0 ; else skip ; 
    x := x+(c) ; 
    max := Set{max, x}->max() ; 
    m := t ; 
 ) ;  ) ;  
    OclFile["System.out"].println((x + m) + " " + max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long t=0 ;
    int time[]=new int[n];
    int f[]=new int[n];
    time[0]=sc.nextInt();
    f[0]=sc.nextInt();
    t+=f[0];
    int max=-1 ;
    max=(int)Math.max(t,max);
    for(int i=1 ; i<n ; i++){
      time[i]=sc.nextInt();
      t-=time[i]-time[i-1];
      if(t<0)t=0 ;
      f[i]=sc.nextInt();
      t+=f[i];
      max=(int)Math.max(t,max);
    }
    String s=(t+time[n-1])+" "+max ;
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : long ; t := 0 ;
    var time : Sequence(int) ; time := Integer.subrange(1,n)->collect(0) ;
    var f : Sequence(int) ; f := Integer.subrange(1,n)->collect(0) ;
    time[0+1] := sc.getCurrent()->toInteger() ; 
    f[0+1] := sc.getCurrent()->toInteger() ; 
    t := t+(f[0+1]) ; 
    var max : int ; max := -1 ;
    max := Set{t, max}->max()->oclAsType(int) ; 
        var i : int ; i := 1 ; while i < n do ( (     time[i+1] := sc.getCurrent()->toInteger() ; 
     t := t-(time[i+1] - time[i - 1+1]) ; 
    if (t < 0) then     t := 0 ; else skip ; 
    f[i+1] := sc.getCurrent()->toInteger() ; 
    t := t+(f[i+1]) ; 
    max := Set{t, max}->max()->oclAsType(int) ; 
 )  ;     i := i + 1 ) ; 
    var s : String ; s := (t + time[n - 1+1]) + " " + max ;
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.System.in ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    s="*"+s ;
    char[] a=s.toCharArray();
    if(inValid(a)){
      System.out.println(-1);
      System.exit(0);
    }
    int n=a.length-1 ;
    ArrayList<Integer>[] map=new ArrayList[n+1];
    for(int i=0 ; i<=n ; i++)map[i]=new ArrayList<>();
    int root=n-1 ;
    map[n-1] .add(n);
    for(int cnt=2 ; cnt<n ; cnt++){
      if(a[cnt]=='0')map[root] .add(n-cnt);
      else {
        map[n-cnt] .add(root);
        root=n-cnt ;
      }
    }
    PrintWriter out=new PrintWriter(System.out);
    for(int i=1 ; i<=n ; i++){
      for(int w : map[i]){
        out.println(Integer.toString(i)+" "+Integer.toString(w));
      }
    }
    out.flush();
  }
  static boolean inValid(char[] a){
    int n=a.length-1 ;
    if(a[1]=='0' || a[n]=='1')return true ;
    for(int i=1 ; i<=n/2 ; i++){
      if(a[i]!=a[n-i])return true ;
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    s := "*" + s ; 
    var a : Sequence(String) ; a := s->characters() ;
    if (inValid(a)) then (     OclFile["System.out"].println(-1) ; 
 OclProcess.exit(0) ) else skip ; 
    var n : int ; n := a->size() - 1 ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,n + 1)->collect(null) ;
        var i : int ; i := 0 ; while i <= n do (     map[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
    var root : int ; root := n - 1 ;
    map[n - 1+1]->excludes(n) ; 
        var cnt : int ; cnt := 2 ; while cnt < n do ( (     if (a[cnt+1] = '0') then     map[root+1]->excludes(n - cnt) ; else (     map[n - cnt+1]->excludes(root) ; 
     root := n - cnt ) )  ;     cnt := cnt + 1 ) ; 
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
        var i : int ; i := 1 ; while i <= n do ( (     for (w : map[i+1]) do ( (     skip )  ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation inValid( a : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() - 1 ;
     if (a[1+1] = '0' or a[n+1] = '1') then     return true else skip ; 
         var i : int ; i := 1 ; while i <= n / 2 do ( (     if (a[i+1] /= a[n - i+1]) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(final String[] args){
    final Scanner scanner=new Scanner(System.in);
    final String input=scanner.next();
    if(input.charAt(0)!='1' || input.charAt(input.length()-1)!='0'){
      System.out.println(-1);
      return ;
    }
    for(int i=0,j=input.length()-2 ; i<j ; ++i,--j){
      if(input.charAt(i)!=input.charAt(j)){
        System.out.println(-1);
        return ;
      }
    }
    int currentEnd=1 ;
    for(int i=1 ; i<input.length(); ++i){
      if(input.charAt(i-1)=='1'){
        System.out.println(currentEnd+" "+(i+1));
        currentEnd=(i+1);
      }
      else {
        System.out.println(currentEnd+" "+(i+1));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : String ; input := scanner.getCurrent() ;
    if (input->at(0+1) /= '1' or input->at(input->size() - 1+1) /= '0') then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
        var i : int ; i := 0 ;
    var j : int ; j := input->size() - 2 ; while i < j do ( (     if (input->at(i+1) /= input->at(j+1)) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip )  ;     i := i + 1 ;     j := j - 1 ) ; 
    var currentEnd : int ; currentEnd := 1 ;
        var i : int ; i := 1 ; while i < input->size() do ( (     if (input->at((i)->char2byte() - 1+1) = '1') then (     OclFile["System.out"].println(currentEnd + " " + (i + 1)) ; 
     currentEnd := (i + 1) ) else (     OclFile["System.out"].println(currentEnd + " " + (i + 1)) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main extends PrintWriter {
  Main(){
    super(System.out);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    Main o=new Main();
    o.main();
    o.flush();
  }
  void main(){
    byte[] cc=(" "+sc.next()).getBytes();
    int n=cc.length-1 ;
    if(cc[n]!='0' || cc[1]!='1' || cc[n-1]!='1'){
      println(-1);
      return ;
    }
    for(int i=2,j=n-2 ; i<j ; i++,j--)if(cc[i]!=cc[j]){
      println(-1);
      return ;
    }
    int i=1 ;
    for(int j=2 ; j<=n/2 ; j++)if(cc[j]=='1' || j==n/2)while(i<j){
      println(i+" "+j);
      i++;
    }
    if(cc[i]=='1'){
      i++;
      println(i-1+" "+i);
    }
    for(int j=i+1 ; j<=n ; j++)println(i+" "+j);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends OclFile {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"]) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : Main ; o := Main.newMain() ;
     o.main() ; 
     o.flush() );
   operation main() : void
  pre: true
  post: true
  activity: (     var cc : Sequence(int) ; cc := (" " + sc.getCurrent())->characters()->collect( _c | _c->char2byte() ) ;
     var n : int ; n := cc->size() - 1 ;
    if (cc[n+1] /= '0' or cc[1+1] /= '1' or cc[n - 1+1] /= '1') then (     execute println(-1) ; 
     return ) else skip ; 
        var i : int ; i := 2 ;
    var j : int ; j := n - 2 ; while i < j do (     if (cc[i+1] /= cc[j+1]) then (     execute println(-1) ; 
     return ) else skip ;  ;     i := i + 1 ;     j := j - 1 ) ; 
    var i : int ; i := 1 ;
        var j : int ; j := 2 ; while j <= n / 2 do (     if (cc[j+1] = '1' or j = n / 2) then     while (i < j) do (     execute println(i + " " + j) ; 
     i := i + 1 ) ; else skip ;  ;     j := j + 1 ) ; 
    if (cc[i+1] = '1') then (     i := i + 1 ; 
     execute println(i - 1 + " " + i) ) else skip ; 
        var j : int ; j := i + 1 ; while j <= n do (     execute println(i + " " + j) ;  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Even_odd {
  public static String check_last(int arr[],int n,int p){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum=sum+arr[i];
    if(p==1){
      if(sum % 2==0)return "ODD" ;
      else return "EVEN" ;
    }
    return "EVEN" ;
  }
  public static void main(String[] args){
    int arr[]={
      5,7,10 },p=1 ;
      int n=3 ;
      System.out.print(check_last(arr,n,p));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Even_odd {
  static   operation check_last( arr : Sequence(int), n : int, p : int) : String
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum + arr[i+1] ;  ;     i := i + 1 ) ; 
     if (p = 1) then (     if (sum mod 2 = 0) then     return "ODD" else     return "EVEN" ) else skip ; 
     return "EVEN" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,7,10} ;
    var p : int ; p := 1 ;
     var n : int ; n := 3 ;
     OclFile["System.out"].print(check_last(arr, n, p)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int N=s.length();
    char[] c=s.toCharArray();
    if(c[0]=='0' || c[N-2]=='0' || c[N-1]=='1'){
      System.out.println(-1);
      return ;
    }
    int NN=N-1 ;
    for(int i=0 ; i<NN/2 ; i++){
      if(c[i]!=c[NN-1-i]){
        System.out.println(-1);
        return ;
      }
    }
    int parent=0 ;
    for(int i=0 ; i<N-1 ; i++){
      System.out.println((parent+1)+" "+(i+2));
      if(c[i]=='1'){
        parent=i+1 ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var N : int ; N := s->size() ;
    var c : Sequence(String) ; c := s->characters() ;
    if (c[0+1] = '0' or c[(N)->char2byte() - 2+1] = '0' or c[(N)->char2byte() - 1+1] = '1') then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var NN : int ; NN := (N)->char2byte() - 1 ;
        var i : int ; i := 0 ; while i < NN / 2 do ( (     if (c[i+1] /= c[NN - 1 - i+1]) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    var parent : int ; parent := 0 ;
        var i : int ; i := 0 ; while i < (N)->char2byte() - 1 do ( (     OclFile["System.out"].println((parent + 1) + " " + (i + 2)) ; 
     if (c[i+1] = '1') then (     parent := i + 1 ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import java.io.*;
public class SolutionB {
  public static final int MOD=1000003 ;
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    Map<Character,String>map=new HashMap<Character,String>();
    map.put('>',"1000");
    map.put('<',"1001");
    map.put('+',"1010");
    map.put('-',"1011");
    map.put('.',"1100");
    map.put(',',"1101");
    map.put('[',"1110");
    map.put(']',"1111");
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<s.length(); i++)sb.append(map.get(s.charAt(i)));
    String bin=sb.toString();
    long ans=0 ;
    long pos=0 ;
    for(int i=bin.length()-1 ; i>=0 ; i--){
      int curr=bin.charAt(i)-'0' ;
      if(curr==1){
        long add=1 ;
        for(int j=0 ; j<pos ; j++){
          add*=2 ;
          add %=MOD ;
        }
        ans+=add ;
        ans %=MOD ;
      }
      pos++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class SolutionB {
  static    attribute MOD : int := 1000003;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var map : Map(String,String) ; map := Map{} ;
    map := map->union(Map{'>' |-> "1000"}) ; 
    map := map->union(Map{'<' |-> "1001"}) ; 
    map := map->union(Map{'+' |-> "1010"}) ; 
    map := map->union(Map{'-' |-> "1011"}) ; 
    map := map->union(Map{'.' |-> "1100"}) ; 
    map := map->union(Map{',' |-> "1101"}) ; 
    map := map->union(Map{'[' |-> "1110"}) ; 
    map := map->union(Map{']' |-> "1111"}) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < s->size() do (     sb := sb + StringLib.newString(map->at(s->at(i+1))) ;  ;     i := i + 1 ) ; 
    var bin : String ; bin := sb+"" ;
    var ans : long ; ans := 0 ;
    var pos : long ; pos := 0 ;
        var i : int ; i := bin->size() - 1 ; while i >= 0 do ( (     var curr : int ; curr := bin->at(i+1) - ('0')->char2byte() ;
     if (curr = 1) then (     var add : long ; add := 1 ;
         var j : int ; j := 0 ; while j < pos do ( (     add := add*(2) ; 
     add := add mod MOD )  ;     j := j + 1 ) ; 
     ans := ans+(add) ; 
     ans := ans mod MOD ) else skip ; 
     pos := pos + 1 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printRLE(String s){
    for(int i=0 ; i<s.length(); i++){
      int count=1 ;
      while(i+1<s.length()&& s.charAt(i)==s.charAt(i+1)){
        i++;
        count++;
      }
      System.out.print(s.charAt(i)+""+count+" ");
    }
    System.out.println();
  }
  public static void main(String args[]){
    printRLE("GeeeEEKKKss");
    printRLE("ccccOddEEE");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printRLE( s : String) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() do ( (     var count : int ; count := 1 ;
     while (i + 1 < s->size() & s->at(i+1) = s->at(i + 1+1)) do (     i := i + 1 ; 
     count := count + 1 ) ; 
     OclFile["System.out"].print(s->at(i+1) + "" + count + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute printRLE("GeeeEEKKKss") ; 
     execute printRLE("ccccOddEEE") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class sol {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int i ;
    long arr[]=new long[n];
    for(i=0 ; i<n ; i++)arr[i]=sc.nextLong();
    long res=0,c=1000000001 ;
    for(i=n-1 ; i>=0 ; i--){
      c=Math.max(0,Math.min(c-1,arr[i]));
      res+=c ;
    }
    System.out.print(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class sol {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var i : int ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
    var c : long ; c := 1000000001 ;
        i := n - 1 ; while i >= 0 do ( (     c := Set{0, Set{c - 1, arr[i+1]}->min()}->max() ; 
     res := res+(c) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].print(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    long ans=arr[n-1];
    long prev=arr[n-1];
    for(int i=n-2 ; i>=0 ; i--){
      if(arr[i]>=prev){
        prev--;
      }
      else {
        prev=arr[i];
      }
      if(prev<=0)break ;
      ans+=prev ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := arr[n - 1+1] ;
    var prev : long ; prev := arr[n - 1+1] ;
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (arr[i+1] >= prev) then (     prev := prev - 1 ) else (     prev := arr[i+1] ) ;  
     if (prev <= 0) then     break else skip ; 
     ans := ans+(prev) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.max ;
import static java.lang.Math.min ;
public class Codeforces {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      this.br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(this.st==null || ! this.st.hasMoreElements()){
        try {
          this.st=new StringTokenizer(this.br.readLine());
        }
        catch(IOException var2){
          var2.printStackTrace();
        }
      }
      return this.st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(this.next());
    }
    long nextLong(){
      return Long.parseLong(this.next());
    }
    double nextDouble(){
      return Double.parseDouble(this.next());
    }
    String nextLine(){
      String var1="" ;
      try {
        if(this.st.hasMoreTokens()){
          var1=this.st.nextToken("\n");
        }
        else {
          var1=this.br.readLine();
        }
      }
      catch(IOException var3){
        var3.printStackTrace();
      }
      return var1 ;
    }
  }
  public static void main(String[] args)throws Exception {
    solve();
  }
  public static void solve(){
    FastReader in=new FastReader();
    int n=in.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
    }
    long mx=1000000001 ;
    long sum=0 ;
    for(int i=n-1 ; i>=0 ; --i){
      mx=max(0,min(mx-1,arr[i]));
      sum+=mx ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (self.st = null or not(self.st.hasNext())) do (     try (     self.st := OclIterator.newOclIterator_String(self.br.readLine()) )   catch (var2 : IOException) do (     var2.printStackTrace() )
 ) ; 
     return self.st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (self.next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (self.next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (self.next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var var1 : String ; var1 := "" ;
     try (     if (self.st.hasNext()) then (     var1 := self.st.nextToken("\n") ) else (     var1 := self.br.readLine() ) )   catch (var3 : IOException) do (     var3.printStackTrace() )
     return var1 );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var n : int ; n := in.nextInt() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    var mx : long ; mx := 1000000001 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     mx := Set{0, Set{mx - 1, arr[i+1]}->min()}->max() ; 
     sum := sum+(mx) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public final class cp {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    void close()throws IOException {
      br.close();
    }
  }
  public static void main(String[] args)throws IOException {
    FastReader r=new FastReader();
    PrintWriter w=new PrintWriter(System.out,true);
    int n=r.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=r.nextInt();
    long prev=arr[n-1],max=prev,res=prev ;
    for(int i=n-2 ; i>=0 ; i--){
      if(arr[i]<prev){
        res+=arr[i];
        prev=arr[i];
      }
      else res+=--prev ;
      max=Math.max(max,res);
      if(prev==0)break ;
    }
    w.println(max);
    r.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : FastReader ; r := FastReader.newFastReader() ;
     var w : OclFile ; w := OclFile.newOclFile_Write(OclFile["System.out"], true) ;
    var n : int ; n := r.nextInt() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := r.nextInt() ;  ;     i := i + 1 ) ; 
    var prev : long ; prev := arr[n - 1+1] ;
    var max : long ; max := prev ;
    var res : long ; res := prev ;
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (arr[i+1] < prev) then (     res := res+(arr[i+1]) ; 
     prev := arr[i+1] ) else         prev := prev - 1 ;
 res := res + prev  ; ;  
     max := Set{max, res}->max() ; 
     if (prev = 0) then     break else skip )  ;     i := i - 1 ) ; 
    skip ; 
    r.close() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class second {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=sc.nextInt();
    }
    long sum=(long)arr[arr.length-1];
    long ans=(long)sum ;
    long prev=(long)arr[arr.length-1];
    for(int i=arr.length-2 ; i>=0 ; i--){
      long p=(long)arr[i];
      if(p>=prev){
        p=prev-1 ;
      }
      if(p==0)break ;
      sum+=p ;
      ans=Math.max(ans,sum);
      prev=p ;
    }
    System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class second {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := arr[arr->size() - 1+1]->oclAsType(long) ;
    var ans : long ; ans := sum->oclAsType(long) ;
    var prev : long ; prev := arr[arr->size() - 1+1]->oclAsType(long) ;
        var i : int ; i := arr->size() - 2 ; while i >= 0 do ( (     var p : long ; p := arr[i+1]->oclAsType(long) ;
     if (p >= prev) then (     p := prev - 1 ) else skip ; 
    if (p = 0) then     break else skip ; 
    sum := sum+(p) ; 
    ans := Set{ans, sum}->max() ; 
    prev := p ; 
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].print(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long D=sc.nextInt();
    int result=0 ;
    long D2=D*D ;
    for(int i=0 ; i<N ; i++){
      long x=sc.nextInt();
      long y=sc.nextInt();
      if(x<=D && y<=D && x>=-D && y>=-D){
        if(x*x+y*y<=D2){
          result++;
        }
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var D : long ; D := sc.getCurrent()->toInteger() ;
    var result : int ; result := 0 ;
    var D2 : long ; D2 := D * D ;
        var i : int ; i := 0 ; while i < N do ( (     var x : long ; x := sc.getCurrent()->toInteger() ;
     var y : long ; y := sc.getCurrent()->toInteger() ;
     if (x <= D & y <= D & x >= -D & y >= -D) then (     if (x * x + y * y <= D2) then (     result := result + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    new Thread(null,new Runnable(){
      public void run(){
        solve();
      }
    },"1",1<<26).start();
  }
  static void solve(){
    FastReader fr=new FastReader();
    PrintWriter op=new PrintWriter(System.out);
    int n=fr.nextInt(),i,ans=0 ;
    long d=fr.nextLong(),x,y,j ;
    d*=d ;
    while(n-->0){
      x=fr.nextLong();
      y=fr.nextLong();
      x*=x ;
      y*=y ;
      j=x+y ;
      if(j<=d)++ans ;
    }
    op.println(ans);
    op.flush();
    op.close();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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();
    }
    String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(null, Runnable(), "1", (1*(2->pow(26)))->oclAsType(long)).start() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var fr : FastReader ; fr := FastReader.newFastReader() ;
     var op : OclFile ; op := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := fr.nextInt() ;
    var i : int ;
    var ans : int ; ans := 0 ;
    var d : long ; d := fr.nextLong() ;
    var x : long ;
    var y : long ;
    var j : long ;
    d := d*(d) ; 
        while (n > 0) do (        n := n - 1 ;     skip ; (     x := fr.nextLong() ; 
     y := fr.nextLong() ; 
    x := x*(x) ; 
    y := y*(y) ; 
    j := x + y ; 
    if (j <= d) then     ans := ans + 1 ; else skip ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or (not(st.hasNext()))) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public int count(int n,double d,int[][] coords){
    int count=0 ;
    for(int[] coord : coords){
      double x=coord[0];
      double y=coord[1];
      if(Math.abs(x)>d || Math.abs(y)>d){
        continue ;
      }
      else {
        double dist=Math.sqrt(x*x+y*y);
        if(dist<=d){
          count++;
        }
      }
    }
    return count ;
  }
  public static void main(String[] args)throws Exception {
    Main solution=new Main();
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int d=scanner.nextInt();
    int[][] coords=new int[n][2];
    for(int i=0 ; i<n ; i++){
      int x=scanner.nextInt();
      int y=scanner.nextInt();
      coords[i][0]=x ;
      coords[i][1]=y ;
    }
    int answer=solution.count(n,d,coords);
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation count( n : int, d : double, coords : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     for (coord : coords) do ( (     var x : double ; x := coord[0+1] ;
     var y : double ; y := coord[1+1] ;
     if (if x < 0 then -(x) else x endif > d or if y < 0 then -(y) else y endif > d) then (     continue ) else (     var dist : double ; dist := (x * x + y * y)->sqrt() ;
     if (dist <= d) then (     count := count + 1 ) else skip ) )  ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var solution : Main ; solution := Main.newMain() ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var d : int ; d := scanner.getCurrent()->toInteger() ;
    var coords : Sequence(Sequence(int)) ; coords := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := scanner.getCurrent()->toInteger() ;
     var y : int ; y := scanner.getCurrent()->toInteger() ;
     coords[i+1][0+1] := x ; 
     coords[i+1][1+1] := y )  ;     i := i + 1 ) ; 
    var answer : int ; answer := solution.count(n, d, coords) ;
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class ProblemSolving {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    int t=1 ;
    while(t-->0){
      solve();
    }
  }
  public static void solve(){
    int n=scanner.nextInt(),m=scanner.nextInt();
    int[][] grid=new int[n+1][m+1];
    for(int i=1 ; i<=n ; i++)for(int j=1 ; j<=m ; j++)grid[i][j]=scanner.nextInt();
    for(int i=1 ; i<=n ; i++)for(int j=1 ; j<=m ; j++)grid[i][j]=grid[i][j]+grid[i][j-1]+grid[i-1][j]-grid[i-1][j-1];
    int a=scanner.nextInt(),b=scanner.nextInt();
    int ans=50*50+1 ;
    for(int i=a ; i<=n ; i++)for(int j=b ; j<=m ; j++)ans=Math.min(ans,grid[i][j]-grid[i-a][j]-grid[i][j-b]+grid[i-a][j-b]);
    for(int i=b ; i<=n ; i++)for(int j=a ; j<=m ; j++)ans=Math.min(ans,grid[i][j]-grid[i-b][j]-grid[i][j-a]+grid[i-b][j-a]);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemSolving {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
     var grid : Sequence(Sequence(int)) ; grid := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do (         var j : int ; j := 1 ; while j <= m do (     grid[i+1][j+1] := scanner.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (         var j : int ; j := 1 ; while j <= m do (     grid[i+1][j+1] := grid[i+1][j+1] + grid[i+1][j - 1+1] + grid[i - 1+1][j+1] - grid[i - 1+1][j - 1+1] ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var ans : int ; ans := 50 * 50 + 1 ;
        var i : int ; i := a ; while i <= n do (         var j : int ; j := b ; while j <= m do (     ans := Set{ans, grid[i+1][j+1] - grid[i - a+1][j+1] - grid[i+1][j - b+1] + grid[i - a+1][j - b+1]}->min() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := b ; while i <= n do (         var j : int ; j := a ; while j <= m do (     ans := Set{ans, grid[i+1][j+1] - grid[i - b+1][j+1] - grid[i+1][j - a+1] + grid[i - b+1][j - a+1]}->min() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findQuadruples(int a[],int b[],int c[],int d[],int x,int n){
    int count=0 ;
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)for(int k=0 ; k<n ; k++)for(int l=0 ; l<n ; l++)if((a[i] ^ b[j] ^ c[k] ^ d[l])==x)count++;
    return count ;
  }
  public static void main(String[] args){
    int x=3 ;
    int a[]={
      0,1 };
      int b[]={
        2,0 };
        int c[]={
          0,1 };
          int d[]={
            0,1 };
            int n=a.length ;
            System.out.println(findQuadruples(a,b,c,d,x,n));
          }
        }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findQuadruples( a : Sequence(int), b : Sequence(int), c : Sequence(int), d : Sequence(int), x : int, n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (         var k : int ; k := 0 ; while k < n do (         var l : int ; l := 0 ; while l < n do (     if ((a[i+1] xor b[j+1] xor c[k+1] xor d[l+1]) = x) then     count := count + 1 ; else skip ;  ;     l := l + 1 ) ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 3 ;
     var a : Sequence(int) ; a := Sequence{0,1} ;
    var b : Sequence(int) ; b := Sequence{2,0} ;
    var c : Sequence(int) ; c := Sequence{0,1} ;
    var d : Sequence(int) ; d := Sequence{0,1} ;
    var n : int ; n := a->size() ;
    OclFile["System.out"].println(findQuadruples(a, b, c, d, x, n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int n=input.nextInt();
    HashMap<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int val=input.nextInt();
      map.put(val,map.getOrDefault(val,0)+1);
    }
    int max=Integer.MIN_VALUE ;
    for(Map.Entry<Integer,Integer>entry : map.entrySet()){
      Integer value=entry.getValue();
      max=Math.max(max,value);
    }
    System.out.println(max+" "+map.size());
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var n : int ; n := input.nextInt() ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var val : int ; val := input.nextInt() ;
     map := map->union(Map{val |-> (if map->keys()->contains(val) then map->at(val) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
    for (entry : map->asSet()) do ( (     var value : int ; value := entry.getValue() ;
     max := Set{max, value}->max() )  ) ; 
    OclFile["System.out"].println(max + " " + map.size()) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
    String line=stdin.readLine();
    String[] arg=line.split("\\s");
    int n=Integer.parseInt(arg[0]);
    int d=Integer.parseInt(arg[1]);
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      line=stdin.readLine();
      arg=line.split("\\s");
      long p=Integer.parseInt(arg[0]);
      long q=Integer.parseInt(arg[1]);
      double x=p*p+q*q ;
      if(Math.sqrt(x)<=d){
        cnt++;
      }
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := stdin.readLine() ;
    var arg : Sequence(String) ; arg := line->split("\\s") ;
    var n : int ; n := (arg[0+1])->toInteger() ;
    var d : int ; d := (arg[1+1])->toInteger() ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     line := stdin.readLine() ; 
     arg := line->split("\\s") ; 
    var p : long ; p := (arg[0+1])->toInteger() ;
    var q : long ; q := (arg[1+1])->toInteger() ;
    var x : double ; x := p * p + q * q ;
    if ((x)->sqrt() <= d) then (     cnt := cnt + 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastScanner sc=new FastScanner(System.in);
    long N=sc.nextLong();
    long D=sc.nextLong();
    long ans=0 ;
    for(long i=0 ; i<N ; i++){
      long x=sc.nextLong();
      long y=sc.nextLong();
      if(Math.sqrt((x*x)+(y*y))<=D){
        ans++;
      }
    }
    System.out.println(ans);
  }
  private static class FastScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public FastScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
      tokenizer=null ;
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var N : long ; N := sc.nextLong() ;
    var D : long ; D := sc.nextLong() ;
    var ans : long ; ans := 0 ;
        var i : long ; i := 0 ; while i < N do ( (     var x : long ; x := sc.nextLong() ;
     var y : long ; y := sc.nextLong() ;
     if (((x * x) + (y * y))->sqrt() <= D) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class FastScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a=sc.nextLong();
    long b=sc.nextLong();
    long result=a*b/gcd(a,b);
    System.out.println(result);
  }
  private static long gcd(long m,long n){
    if(m<n)return gcd(n,m);
    if(n==0)return m ;
    return gcd(n,m % n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var result : long ; result := a * b / gcd(a, b) ;
    OclFile["System.out"].println(result) ; 
 );
  static   operation gcd( m : long, n : long) : long
  pre: true
  post: true
  activity: (     if (m < n) then     return gcd(n, m) else skip ; 
     if (n = 0) then     return m else skip ; 
     return gcd(n, m mod n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner s=new Scanner(System.in);
    int a=s.nextInt(),b=s.nextInt();
    long mult=Math.max(a,b);
    for(int i=1 ; ; i++){
      if(mult*i % a==0 && mult*i % b==0){
        System.out.println(mult*i);
        break ;
      }
    }
  }
}
class Scanner {
  StringTokenizer st ;
  BufferedReader br ;
  public Scanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public String nextLine()throws IOException {
    return br.readLine();
  }
  public double nextDouble()throws IOException {
    String x=next();
    StringBuilder sb=new StringBuilder("0");
    double res=0,f=1 ;
    boolean dec=false,neg=false ;
    int start=0 ;
    if(x.charAt(0)=='-'){
      neg=true ;
      start++;
    }
    for(int i=start ; i<x.length(); i++)if(x.charAt(i)=='.'){
      res=Long.parseLong(sb.toString());
      sb=new StringBuilder("0");
      dec=true ;
    }
    else {
      sb.append(x.charAt(i));
      if(dec)f*=10 ;
    }
    res+=Long.parseLong(sb.toString())/f ;
    return res*(neg ?-1 : 1);
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := s.getCurrent()->toInteger() ;
    var b : int ; b := s.getCurrent()->toInteger() ;
     var mult : long ; mult := Set{a, b}->max() ;
         var i : int ; i := 1 ; while true do ( (     if (mult * i mod a = 0 & mult * i mod b = 0) then (     OclFile["System.out"].println(mult * i) ; 
     break ) else skip )  ;     i := i + 1 ) );
}
class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     var x : String ; x := next() ;
     var sb : String ; sb := StringLib.newString("0") ;
    var res : double ; res := 0 ;
    var f : double ; f := 1 ;
    var dec : boolean ; dec := false ;
    var neg : boolean ; neg := false ;
    var start : int ; start := 0 ;
    if (x->at(0+1) = '-') then (     neg := true ; 
     start := start + 1 ) else skip ; 
        var i : int ; i := start ; while i < x->size() do (     if (x->at(i+1) = '.') then (     res := (sb+"")->toLong() ; 
     sb := StringLib.newString("0") ; 
     dec := true ) else (     sb := sb + StringLib.newString(x->at(i+1)) ; 
     if (dec) then     f := f*(10) ; else skip ) ;   ;     i := i + 1 ) ; 
    res := res+((sb+"")->toLong() / f) ; 
    return res * (if neg then -1 else 1 endif) 
 );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.util.*;
import java.util.stream.Collectors ;
public class Main {
  static final int MAX=1_000_000_000 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(new BufferedInputStream(System.in));
    long a=sc.nextInt();
    long b=sc.nextInt();
    System.out.println(a*b/pgcd(a,b));
  }
  static long pgcd(long a,long b){
    if(b==0)return a ;
    return pgcd(b,a % b);
  }
  private static int nextInt(Scanner sc){
    return Integer.valueOf(sc.nextLine());
  }
  private static int[] toArray(String text){
    return Arrays.stream(text.split("")).mapToInt(Integer :: valueOf).toArray();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 1_000_000_000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var a : long ; a := sc.getCurrent()->toInteger() ;
     var b : long ; b := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(a * b / pgcd(a, b)) );
  static   operation pgcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return pgcd(b, a mod b) );
  static   operation nextInt( sc : OclFile) : int
  pre: true
  post: true
  activity: (     return (sc.nextLine())->toInteger() );
  static   operation toArray( text : String) : Sequence(int)
  pre: true
  post: true
  activity: (     return stream(text->split(""))->collect( _x1 | (lambda _pars : OclAny in Integer.newInteger().valueOf(_pars))->apply(_x1) )->asSequence() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  private static void solve(){
    long a=nl();
    long b=nl();
    System.out.println(lcm(a,b));
  }
  static long gcd(long a,long b){
    return b>0 ? gcd(b,a % b): a ;
  }
  static long lcm(long a,long b){
    return a*b/gcd(a,b);
  }
  private static Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    String debugDataPath=System.getenv("DD_PATH");
    if(debugDataPath!=null){
      try {
        scanner=new Scanner(new BufferedReader(new InputStreamReader(new FileInputStream(new File(debugDataPath)))));
      }
      catch(Exception e){
        throw new RuntimeException(e);
      }
    }
    solve();
  }
  private static StringTokenizer tokenizer=null ;
  public static String next(){
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        tokenizer=new StringTokenizer(scanner.nextLine());
      }
      catch(Exception e){
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }
  private static int ni(){
    return Integer.parseInt(next());
  }
  private static long nl(){
    return Long.parseLong(next());
  }
  private static double nd(){
    return Double.parseDouble(next());
  }
  private static int[] na(int n){
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=ni();
    return a ;
  }
  private static char[] ns(){
    return next().toCharArray();
  }
  private static long[] nal(int n){
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=nl();
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var a : long ; a := nl() ;
     var b : long ; b := nl() ;
     OclFile["System.out"].println(lcm(a, b)) );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return if b > 0 then gcd(b, a mod b) else a endif );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return a * b / gcd(a, b) );
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var debugDataPath : String ; debugDataPath := OclProcess.getEnvironmentProperty("DD_PATH") ;
     if (debugDataPath /= null) then (     try (     scanner := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(debugDataPath))))) )   catch (e : ProgramException) do (     error ProgramException(e) )
 ) else skip ; 
     execute solve() );
  static   attribute tokenizer : OclIterator := null;
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(scanner.nextLine()) )   catch (e : ProgramException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
  static   operation ni() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nl() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nd() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation na( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := ni() ;  ;     i := i + 1 ) ; 
     return a );
  static   operation ns() : Sequence(String)
  pre: true
  post: true
  activity: (     return next()->characters() );
  static   operation nal( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nl() ;  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int A=scanner.nextInt();
    int B=scanner.nextInt();
    Map<Integer,Integer>factorA=new HashMap<>();
    Map<Integer,Integer>factorB=new HashMap<>();
    long answer=1 ;
    int max=Math.max(A,B);
    boolean[] primes=new boolean[max+1];
    for(int i=2 ; i<=max ; i++){
      primes[i]=true ;
    }
    for(int i=2 ; i*i<=max ; i++){
      if(primes[i]){
        int p=i+i ;
        while(p<=max){
          primes[p]=false ;
          p+=i ;
        }
      }
    }
    List<Integer>plist=new ArrayList<>();
    for(int i=2 ; i<=max ; i++){
      if(primes[i])plist.add(i);
    }
    for(int p : plist){
      int countA=0 ;
      while(A % p==0){
        A=A/p ;
        countA++;
        factorA.put(p,factorA.getOrDefault(p,0)+1);
      }
      int countB=0 ;
      while(B % p==0){
        B=B/p ;
        countB++;
        factorB.put(p,factorB.getOrDefault(p,0)+1);
      }
      if(Math.max(countA,countB)!=0){
        for(int i=0 ; i<Math.max(countA,countB); i++){
          answer*=p ;
        }
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := scanner.getCurrent()->toInteger() ;
    var B : int ; B := scanner.getCurrent()->toInteger() ;
    var factorA : Map(int,int) ; factorA := Map{} ;
    var factorB : Map(int,int) ; factorB := Map{} ;
    var answer : long ; answer := 1 ;
    var max : int ; max := Set{A, B}->max() ;
    var primes : Sequence(boolean) ; primes := Integer.subrange(1,max + 1)->collect(false) ;
        var i : int ; i := 2 ; while i <= max do ( (     primes[i+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i * i <= max do ( (     if (primes[i+1]) then (     var p : int ; p := i + i ;
     while (p <= max) do (     primes[p+1] := false ; 
     p := p+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    var plist : Sequence(int) ; plist := Sequence{} ;
        var i : int ; i := 2 ; while i <= max do ( (     if (primes[i+1]) then     plist := plist->including(i) ; else skip )  ;     i := i + 1 ) ; 
    for (p : plist) do ( (     var countA : int ; countA := 0 ;
     while (A mod p = 0) do (     A := A / p ; 
     countA := countA + 1 ; 
     factorA := factorA->union(Map{p |-> (if factorA->keys()->contains(p) then factorA->at(p) else 0 endif) + 1}) ) ; 
    var countB : int ; countB := 0 ;
    while (B mod p = 0) do (     B := B / p ; 
     countB := countB + 1 ; 
     factorB := factorB->union(Map{p |-> (if factorB->keys()->contains(p) then factorB->at(p) else 0 endif) + 1}) ) ; 
    if (Set{countA, countB}->max() /= 0) then (         var i : int ; i := 0 ; while i < Set{countA, countB}->max() do ( (     answer := answer*(p) )  ;     i := i + 1 ) ) else skip ; 
 )  ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isPossibleToZero(int a[],int n){
    int num=0 ;
    for(int i=0 ; i<n ; i++)num=num*10+a[i];
    return(num % 11==0);
  }
  public static void main(String[] args){
    int arr[]={
      0,1,1,0 };
      int n=arr.length ;
      if(isPossibleToZero(arr,n))System.out.println("YES");
      else System.out.println("NO");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPossibleToZero( a : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var num : int ; num := 0 ;
         var i : int ; i := 0 ; while i < n do (     num := num * 10 + a[i+1] ;  ;     i := i + 1 ) ; 
     return (num mod 11 = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,1,1,0} ;
     var n : int ; n := arr->size() ;
     if (isPossibleToZero(arr, n)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void findNDigitNumsUtil(int n,char out[],int index,int evenSum,int oddSum){
    if(index>n)return ;
    if(index==n){
      if(Math.abs(evenSum-oddSum)==1){
        out[index]=' ';
        System.out.print(out);
        System.out.print(" ");
    }
    return;
    }
    if(index%2!=0)
    {
      for(inti=0;i<=9;i++){
         out[index]=(char)(i+'0');
         findNDigitNumsUtil(n,out,index+1,evenSum,oddSum+i);
         }
    }
    else
    {
      for(inti=0;i<=9;i++){
         out[index]=(char)(i+'0');
         findNDigitNumsUtil(n,out,index+1,evenSum+i,oddSum);
       }
      }
   }
   static void findNDigitNums(intn){
     char[] out=newchar[n+1];
     int index=0;
     int evenSum=0, oddSum=0;
     for(inti=1;i<=9;i++){
        out[index]=(char)(i+'0');
        findNDigitNumsUtil(n,out,index+1,evenSum+i,oddSum);
      }
    }
    public static void main(String[] args){
      int n=3 ;
      findNDigitNums(n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNDigitNumsUtil( n : int, out : Sequence(String), index : int, evenSum : int, oddSum : int) : void
  pre: true
  post: true
  activity: (     if (index > n) then     return else skip ; 
     if (index = n) then (     if (if evenSum - oddSum < 0 then -(evenSum - oddSum) else evenSum - oddSum endif = 1) then (     out[index+1] := ' ' ; 
     OclFile["System.out"].print(out) ; 
     OclFile["System.out"].print(" ") ) else skip ; 
     return ) else skip ; 
     if (index mod 2 /= 0) then (         inti := 0 ; while i <= 9 do ( (     out[index+1] := (i + '0')->oclAsType(String) ; 
     execute findNDigitNumsUtil(n, out, index + 1, evenSum, oddSum + i) )  ;     i := i + 1 ) ) else (         inti := 0 ; while i <= 9 do ( (     out[index+1] := (i + '0')->oclAsType(String) ; 
     execute findNDigitNumsUtil(n, out, index + 1, evenSum + i, oddSum) )  ;     i := i + 1 ) ) );
  static   operation findNDigitNums(formalParameters (formalParameterList intn)) : void
  pre: true
  post: true
  activity: (     var out : Sequence(String) ; out := newchar[n + 1+1] ;
     var index : int ; index := 0 ;
     var evenSum : int ; evenSum := 0 ;
    var oddSum : int ; oddSum := 0 ;
         inti := 1 ; while i <= 9 do ( (     out[index+1] := (i + '0')->oclAsType(String) ; 
     execute findNDigitNumsUtil(n, out, index + 1, evenSum + i, oddSum) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     execute findNDigitNums(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int center_nonadecagon_num(int n){
    return(19*n*n-19*n+2)/2 ;
  }
  public static void main(String[] args){
    int n=2 ;
    System.out.print(n+"th centered "+"nonadecagonal number : ");
    System.out.println(center_nonadecagon_num(n));
    n=7 ;
    System.out.print(n+"th centered "+"nonadecagonal number : ");
    System.out.println(center_nonadecagon_num(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation center_nonadecagon_num( n : int) : int
  pre: true
  post: true
  activity: (     return (19 * n * n - 19 * n + 2) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].print(n + "th centered " + "nonadecagonal number : ") ; 
    OclFile["System.out"].println(center_nonadecagon_num(n)) ; 
    n := 7 ; 
    OclFile["System.out"].print(n + "th centered " + "nonadecagonal number : ") ; 
    OclFile["System.out"].println(center_nonadecagon_num(n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class Main {
  static void minAbsSumPair(int arr[],int n){
    int sum,min_sum=999999 ;
    int l=0,r=n-1 ;
    int min_l=l,min_r=n-1 ;
    if(n<2){
      System.out.println("Invalid Input");
      return ;
    }
    sort(arr,l,r);
    while(l<r){
      sum=arr[l]+arr[r];
      if(Math.abs(sum)<Math.abs(min_sum)){
        min_sum=sum ;
        min_l=l ;
        min_r=r ;
      }
      if(sum<0)l++;
      else r--;
    }
    System.out.println(" The two elements whose "+"sum is minimum are "+arr[min_l]+" and "+arr[min_r]);
  }
  public static void main(String[] args){
    int arr[]={
      1,60,-10,70,-80,85 };
      int n=arr.length ;
      minAbsSumPair(arr,n);
    }
    static int partition(int arr[],int low,int high){
      int pivot=arr[high];
      int i=(low-1);
      for(int j=low ; j<high ; j++){
        if(arr[j]<=pivot){
          i++;
          int temp=arr[i];
          arr[i]=arr[j];
          arr[j]=temp ;
        }
      }
      int temp=arr[i+1];
      arr[i+1]=arr[high];
      arr[high]=temp ;
      return i+1 ;
    }
    static void sort(int arr[],int low,int high){
      if(low<high){
        int pi=partition(arr,low,high);
        sort(arr,low,pi-1);
        sort(arr,pi+1,high);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation minAbsSumPair( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var sum : int ;
    var min_sum : int ; min_sum := 999999 ;
     var l : int ; l := 0 ;
    var r : int ; r := n - 1 ;
    var min_l : int ; min_l := l ;
    var min_r : int ; min_r := n - 1 ;
    if (n < 2) then (     OclFile["System.out"].println("Invalid Input") ; 
     return ) else skip ; 
    execute sort(arr, l, r) ; 
    while (l < r) do (     sum := arr[l+1] + arr[r+1] ; 
     if (if sum < 0 then -(sum) else sum endif < if min_sum < 0 then -(min_sum) else min_sum endif) then (     min_sum := sum ; 
     min_l := l ; 
     min_r := r ) else skip ; 
     if (sum < 0) then     l := l + 1 ; else     r := r - 1 ; ) ; 
    OclFile["System.out"].println(" The two elements whose " + "sum is minimum are " + arr[min_l+1] + " and " + arr[min_r+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,60,-10,70,-80,85} ;
     var n : int ; n := arr->size() ;
     execute minAbsSumPair(arr, n) );
  static   operation partition( arr : Sequence(int), low : int, high : int) : int
  pre: true
  post: true
  activity: (     var pivot : int ; pivot := arr[high+1] ;
     var i : int ; i := (low - 1) ;
        var j : int ; j := low ; while j < high do ( (     if (arr[j+1] <= pivot) then (     i := i + 1 ; 
     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := arr[j+1] ; 
     arr[j+1] := temp ) else skip )  ;     j := j + 1 ) ; 
    var temp : int ; temp := arr[i + 1+1] ;
    arr[i + 1+1] := arr[high+1] ; 
    arr[high+1] := temp ; 
    return i + 1 
 );
  static   operation sort( arr : Sequence(int), low : int, high : int) : void
  pre: true
  post: true
  activity: (     if (low < high) then (     var pi : int ; pi := partition(arr, low, high) ;
     execute sort(arr, low, pi - 1) ; 
     execute sort(arr, pi + 1, high) ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class B {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new FileReader("B-large.in"));
    PrintWriter out=new PrintWriter("b.out");
    int C=Integer.parseInt(in.readLine());
    for(int i=1 ; i<=C ; i++){
      StringTokenizer tz=new StringTokenizer(in.readLine());
      int N=Integer.parseInt(tz.nextToken());
      int M=Integer.parseInt(tz.nextToken());
      int A=Integer.parseInt(tz.nextToken());
      String ans ;
      if(A>N*M){
        ans="IMPOSSIBLE" ;
      }
      else {
        int a=A/M ;
        int b,c=1,d=M ;
        if(a*M==A){
          b=0 ;
        }
        else {
          a++;
          b=a*d-A ;
        }
        ans="0 0 "+a+" "+b+" "+c+" "+d ;
      }
      out.println("Case #"+i+": "+ans);
    }
    in.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("B-large.in"))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("b.out")) ;
    var C : int ; C := (in.readLine())->toInteger() ;
        var i : int ; i := 1 ; while i <= C do ( (     var tz : OclIterator ; tz := OclIterator.newOclIterator_String(in.readLine()) ;
     var N : int ; N := (tz.next())->toInteger() ;
    var M : int ; M := (tz.next())->toInteger() ;
    var A : int ; A := (tz.next())->toInteger() ;
    var ans : String ;
    if (A > N * M) then (     ans := "IMPOSSIBLE" ) else (     var a : int ; a := A / M ;
     var b : int ;
    var c : int ; c := 1 ;
    var d : int ; d := M ;
     if (a * M = A) then (     b := 0 ) else (     a := a + 1 ; 
     b := a * d - A ) ;  
     ans := "0 0 " + a + " " + b + " " + c + " " + d ) ;  
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class codeforces {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int matrix[][]=new int[n][m];
    int i,j,k,l ;
    for(i=0 ; i<n ; i++){
      for(j=0 ; j<m ; j++){
        matrix[i][j]=sc.nextInt();
      }
    }
    int a=sc.nextInt();
    int b=sc.nextInt();
    int min=Integer.MAX_VALUE ;
    for(i=0 ; i<=n-a ; i++){
      for(j=0 ; j<=m-b ; j++){
        int c=0 ;
        for(k=i ; k<i+a ; k++){
          for(l=j ; l<j+b ; l++){
            if(matrix[k][l]==1)c++;
          }
        }
        if(min>c)min=c ;
      }
    }
    for(i=0 ; i<=n-b ; i++){
      for(j=0 ; j<=m-a ; j++){
        int c=0 ;
        for(k=i ; k<i+b ; k++){
          for(l=j ; l<j+a ; l++){
            if(matrix[k][l]==1)c++;
          }
        }
        if(min>c)min=c ;
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var matrix : Sequence(Sequence(int)) ; matrix := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var i : int ;
    var j : int ;
    var k : int ;
    var l : int ;
        i := 0 ; while i < n do ( (         j := 0 ; while j < m do ( (     matrix[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var min : int ; min := 2147483647 ;
        i := 0 ; while i <= n - a do ( (         j := 0 ; while j <= m - b do ( (     var c : int ; c := 0 ;
         k := i ; while k < i + a do ( (         l := j ; while l < j + b do ( (     if (matrix[k+1][l+1] = 1) then     c := c + 1 ; else skip )  ;     l := l + 1 ) )  ;     k := k + 1 ) ; 
     if (min > c) then     min := c ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        i := 0 ; while i <= n - b do ( (         j := 0 ; while j <= m - a do ( (     var c : int ; c := 0 ;
         k := i ; while k < i + b do ( (         l := j ; while l < j + a do ( (     if (matrix[k+1][l+1] = 1) then     c := c + 1 ; else skip )  ;     l := l + 1 ) )  ;     k := k + 1 ) ; 
     if (min > c) then     min := c ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      long i=1 ;
      long[][] gcdlcm=new long[2][2];
      gcdlcm[0][0]=scan.nextLong();
      gcdlcm[0][1]=scan.nextLong();
      gcdlcm[1][0]=gcdlcm[0][0];
      gcdlcm[1][1]=gcdlcm[0][1];
      while(i!=0){
        i=gcdlcm[0][0] % gcdlcm[0][1];
        gcdlcm[0][0]=gcdlcm[0][1];
        gcdlcm[0][1]=i ;
      }
      System.out.println(gcdlcm[0][0]+" "+(gcdlcm[1][0]*gcdlcm[1][1]/gcdlcm[0][0]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var i : long ; i := 1 ;
     var gcdlcm : Sequence(Sequence(long)) ; gcdlcm := Integer.subrange(1,2)->collect(Integer.subrange(1,2)->collect(0)) ;
    gcdlcm[0+1][0+1] := scan.getCurrent()->toLong() ; 
    gcdlcm[0+1][1+1] := scan.getCurrent()->toLong() ; 
    gcdlcm[1+1][0+1] := gcdlcm[0+1][0+1] ; 
    gcdlcm[1+1][1+1] := gcdlcm[0+1][1+1] ; 
    while (i /= 0) do (     i := gcdlcm[0+1][0+1] mod gcdlcm[0+1][1+1] ; 
     gcdlcm[0+1][0+1] := gcdlcm[0+1][1+1] ; 
     gcdlcm[0+1][1+1] := i ) ; 
    OclFile["System.out"].println(gcdlcm[0+1][0+1] + " " + (gcdlcm[1+1][0+1] * gcdlcm[1+1][1+1] / gcdlcm[0+1][0+1])) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.NoSuchElementException ;
import java.util.Scanner ;
public class Main {
  private static ArrayList<Long>gcd=new ArrayList<Long>();
  private static ArrayList<Long>lcm=new ArrayList<Long>();
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    try {
      while(sc.hasNextLong()){
        long a=sc.nextLong();
        long b=sc.nextLong();
        gcd.add(getGCD(a,b));
        lcm.add(getLCM(a,b));
      }
    }
    catch(NoSuchElementException e){
    }
    int sizeAnswerList=gcd.size();
    for(int i=0 ; i<sizeAnswerList ; i++){
      System.out.println(gcd.get(i)+" "+lcm.get(i));
    }
  }
  private static long getGCD(long a,long b){
    long numBigger ;
    long numSmaller ;
    if(a>b){
      numBigger=a ;
      numSmaller=b ;
    }
    else {
      numBigger=b ;
      numSmaller=a ;
    }
    long gcd ;
    while(true){
      if(numBigger==numSmaller){
        gcd=numBigger ;
        break ;
      }
      long tmp=numBigger ;
      numBigger=numSmaller ;
      numSmaller=tmp-numSmaller ;
      if(numBigger<numSmaller){
        tmp=numBigger ;
        numBigger=numSmaller ;
        numSmaller=tmp ;
      }
    }
    return gcd ;
  }
  private static long getLCM(long a,long b){
    long tmp=b/getGCD(a,b);
    return a*tmp ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute gcd : Sequence(long) := Sequence{};
  static   attribute lcm : Sequence(long) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     try (     while (sc.hasNextLong()) do (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
     gcd := gcd->including(getGCD(a, b)) ; 
     lcm := lcm->including(getLCM(a, b)) ) )   catch (e : IncorrectElementException) do skip
     var sizeAnswerList : int ; sizeAnswerList := gcd->size() ;
         var i : int ; i := 0 ; while i < sizeAnswerList do ( (     OclFile["System.out"].println(gcd->at(i+1) + " " + lcm->at(i+1)) )  ;     i := i + 1 ) );
  static   operation getGCD( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var numBigger : long ;
     var numSmaller : long ;
    if (a > b) then (     numBigger := a ; 
     numSmaller := b ) else (     numBigger := b ; 
     numSmaller := a ) ;  
    var gcd : long ;
    while (true) do (     if (numBigger = numSmaller) then (     gcd := numBigger ; 
     break ) else skip ; 
     var tmp : long ; tmp := numBigger ;
    numBigger := numSmaller ; 
    numSmaller := tmp - numSmaller ; 
    if (numBigger < numSmaller) then (     tmp := numBigger ; 
     numBigger := numSmaller ; 
     numSmaller := tmp ) else skip ; 
 ) ; 
    return gcd 
 );
  static   operation getLCM( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var tmp : long ; tmp := b / getGCD(a, b) ;
     return a * tmp );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static int gcd(int x,int y){
    if(0==y)return x ;
    return gcd(y,x % y);
  }
  private static int lcm(int x,int y){
    return x/gcd(x,y)*y ;
  }
  public static void main(String[] main){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int x=in.nextInt();
      int y=in.nextInt();
      System.out.print(gcd(x,y)+" "+lcm(x,y));
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (0 = y) then     return x else skip ; 
     return gcd(y, x mod y) );
  static   operation lcm( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return x / gcd(x, y) * y );
  static   operation main( main : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var x : int ; x := in.getCurrent()->toInteger() ;
     var y : int ; y := in.getCurrent()->toInteger() ;
     OclFile["System.out"].print(gcd(x, y) + " " + lcm(x, y)) ; 
     OclFile["System.out"].println() ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] a)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    ArrayList<String>al=new ArrayList<String>();
    String str ;
    while((str=br.readLine())!=null){
      if(str.length()==0){
        break ;
      }
      al.add(str);
    }
    int[][] gcdLcm=new int[al.size()][2];
    int len=al.size();
    for(int i=0 ; i<len ; i++){
      String[] buf=al.get(i).split(" ");
      int m=Integer.parseInt(buf[0]);
      int n=Integer.parseInt(buf[1]);
      gcdLcm[i][0]=gcd(m,n);
      gcdLcm[i][1]=lcm((long)m,(long)n,(long)gcdLcm[i][0]);
    }
    for(int i=0 ; i<gcdLcm.length ; i++){
      System.out.println(gcdLcm[i][0]+" "+gcdLcm[i][1]);
    }
  }
  private static int gcd(int m,int n){
    return n==0 ? m : gcd(n,m % n);
  }
  private static int lcm(long m,long n,long gcd){
    return(int)(m*n/gcd);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var al : Sequence(String) ; al := Sequence{} ;
    var str : String ;
        str := br.readLine() ;
    while ((str) /= null) do (    skip ; (     if (str->size() = 0) then (     break ) else skip ; 
     al := al->including(str) ) ;     str := br.readLine() ;
 ) ;  
    var gcdLcm : Sequence(Sequence(int)) ; gcdLcm := Integer.subrange(1,al->size())->collect(Integer.subrange(1,2)->collect(0)) ;
    var len : int ; len := al->size() ;
        var i : int ; i := 0 ; while i < len do ( (     var buf : Sequence(String) ; buf := al->at(i+1)->split(" ") ;
     var m : int ; m := (buf[0+1])->toInteger() ;
    var n : int ; n := (buf[1+1])->toInteger() ;
    gcdLcm[i+1][0+1] := gcd(m, n) ; 
    gcdLcm[i+1][1+1] := lcm(m->oclAsType(long), n->oclAsType(long), gcdLcm[i+1][0+1]->oclAsType(long)) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < gcdLcm->size() do ( (     OclFile["System.out"].println(gcdLcm[i+1][0+1] + " " + gcdLcm[i+1][1+1]) )  ;     i := i + 1 ) ; 
 );
  static   operation gcd( m : int, n : int) : int
  pre: true
  post: true
  activity: (     return if n = 0 then m else gcd(n, m mod n) endif );
  static   operation lcm( m : long, n : long, gcd : long) : int
  pre: true
  post: true
  activity: (     return (m * n / gcd)->oclAsType(int) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      if(! sc.hasNextInt()){
        break ;
      }
      int a=sc.nextInt();
      int b=sc.nextInt();
      int ta=a ;
      int tb=b ;
      for(; ; ){
        if(a==b)break ;
        if(a>b){
          a-=b ;
        }
        else {
          b-=a ;
        }
      }
      int gcd=a ;
      int lcm=ta/a*tb ;
      System.out.println(gcd+" "+lcm);
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     if (not(sc.hasNextInt())) then (     break ) else skip ; 
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var ta : int ; ta := a ;
    var tb : int ; tb := b ;
      while true do ( (     if (a = b) then     break else skip ; 
     if (a > b) then (     a := a-(b) ) else (     b := b-(a) ) )  ) ; 
    var gcd : int ; gcd := a ;
    var lcm : int ; lcm := ta / a * tb ;
    OclFile["System.out"].println(gcd + " " + lcm) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication {
  static Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    int n=in.nextInt();
    int h=in.nextInt();
    int roadWidth=0 ;
    for(int i=0 ; i<n ; i++){
      int x=in.nextInt();
      if(x<=h){
        roadWidth+=1 ;
      }
      else {
        roadWidth+=2 ;
      }
    }
    System.out.println(roadWidth);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var h : int ; h := in.getCurrent()->toInteger() ;
    var roadWidth : int ; roadWidth := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     if (x <= h) then (     roadWidth := roadWidth+(1) ) else (     roadWidth := roadWidth+(2) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(roadWidth) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class VanyaAndFence {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int h=in.nextInt();
    int[] friends=new int[n];
    int width=0 ;
    for(int i=0 ; i<friends.length ; ++i){
      friends[i]=in.nextInt();
      if(friends[i]>h)width+=2 ;
      else width+=1 ;
    }
    System.out.println(width);
  }
}
------------------------------------------------------------
OCL File:
---------
 class VanyaAndFence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var h : int ; h := in.getCurrent()->toInteger() ;
    var friends : Sequence(int) ; friends := Integer.subrange(1,n)->collect(0) ;
    var width : int ; width := 0 ;
        var i : int ; i := 0 ; while i < friends->size() do ( (     friends[i+1] := in.getCurrent()->toInteger() ; 
     if (friends[i+1] > h) then     width := width+(2) ; else     width := width+(1) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(width) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int w=0 ;
    for(int i=0 ; i<n ; i++){
      int h=sc.nextInt();
      if(h>k){
        w=w+2 ;
      }
      else {
        w=w+1 ;
      }
    }
    System.out.println(w);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var w : int ; w := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var h : int ; h := sc.getCurrent()->toInteger() ;
     if (h > k) then (     w := w + 2 ) else (     w := w + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(w) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int firstUniqChar(String s){
    int freq[]=new int[26];
    for(int i=0 ; i<s.length(); i++)freq[s.charAt(i)-'a']++;
    for(int i=0 ; i<s.length(); i++)if(freq[s.charAt(i)-'a']==1)return i ;
    return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation firstUniqChar( s : String) : int
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
         var i : int ; i := 0 ; while i < s->size() do (     freq[s->at(i+1) - ('a')->char2byte()+1] := freq[s->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < s->size() do (     if (freq[s->at(i+1) - ('a')->char2byte()+1] = 1) then     return i else skip ;  ;     i := i + 1 ) ; 
     return -1 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Hisoka {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int y=in.nextInt();
    int z=in.nextInt();
    int c=0 ;
    for(int i=0 ; i<y ; i++){
      int x=in.nextInt();
      if(x<=z)c++;
      else c+=2 ;
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hisoka {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var y : int ; y := in.getCurrent()->toInteger() ;
    var z : int ; z := in.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < y do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     if (x <= z) then     c := c + 1 ; else     c := c+(2) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int numPerson=in.nextInt();
    int fenceHeight=in.nextInt();
    int roadWidth=0 ;
    for(int i=0 ; i<numPerson ; i++){
      int personHeight=in.nextInt();
      if(personHeight>fenceHeight)roadWidth+=2 ;
      else roadWidth++;
    }
    out.println(roadWidth);
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new FileReader("sub.in"));
      }
      catch(FileNotFoundException ex){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException ex){
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException ex){
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var numPerson : int ; numPerson := in.nextInt() ;
    var fenceHeight : int ; fenceHeight := in.nextInt() ;
    var roadWidth : int ; roadWidth := 0 ;
        var i : int ; i := 0 ; while i < numPerson do ( (     var personHeight : int ; personHeight := in.nextInt() ;
     if (personHeight > fenceHeight) then     roadWidth := roadWidth+(2) ; else     roadWidth := roadWidth + 1 ; )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("sub.in"))) )   catch (ex : FileNotFoundException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (ex : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (ex : IOException) do skip
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class calc {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,m,i,j,k,l,a,b ;
    int sum=0,min=0,x=0 ;
    int[][] g=new int[50][50];
    n=sc.nextInt();
    m=sc.nextInt();
    for(i=0 ; i<n ; i++)for(j=0 ; j<m ; j++)g[i][j]=sc.nextInt();
    a=sc.nextInt();
    b=sc.nextInt();
    for(i=0 ; i+a-1<n ; ++i)for(j=0 ; j+b-1<m ; ++j){
      sum=0 ;
      for(l=i ; l<=i+a-1 ; ++l)for(k=j ; k<=j+b-1 ; ++k)if(g[l][k]==1)++sum ;
      if(x==0){
        min=sum ;
++x ;
      }
      else if(sum<min)min=sum ;
    }
    for(i=0 ; i+b-1<n ; ++i)for(j=0 ; j+a-1<m ; ++j){
      sum=0 ;
      for(l=i ; l<=i+b-1 ; ++l)for(k=j ; k<=j+a-1 ; ++k)if(g[l][k]==1)++sum ;
      if(x==0){
        min=sum ;
++x ;
      }
      else if(sum<min)min=sum ;
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class calc {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var m : int ;
    var i : int ;
    var j : int ;
    var k : int ;
    var l : int ;
    var a : int ;
    var b : int ;
    var sum : int ; sum := 0 ;
    var min : int ; min := 0 ;
    var x : int ; x := 0 ;
    var g : Sequence(Sequence(int)) ; g := Integer.subrange(1,50)->collect(Integer.subrange(1,50)->collect(0)) ;
    n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
        i := 0 ; while i < n do (         j := 0 ; while j < m do (     g[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
        i := 0 ; while i + a - 1 < n do (         j := 0 ; while j + b - 1 < m do ( (     sum := 0 ; 
         l := i ; while l <= i + a - 1 do (         k := j ; while k <= j + b - 1 do (     if (g[l+1][k+1] = 1) then     sum := sum + 1 ; else skip ;  ;     k := k + 1 ) ;  ;     l := l + 1 ) ; 
     if (x = 0) then (     min := sum ; 
     x := x + 1 ) else     if (sum < min) then     min := sum ; else skip ; )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        i := 0 ; while i + b - 1 < n do (         j := 0 ; while j + a - 1 < m do ( (     sum := 0 ; 
         l := i ; while l <= i + b - 1 do (         k := j ; while k <= j + a - 1 do (     if (g[l+1][k+1] = 1) then     sum := sum + 1 ; else skip ;  ;     k := k + 1 ) ;  ;     l := l + 1 ) ; 
     if (x = 0) then (     min := sum ; 
     x := x + 1 ) else     if (sum < min) then     min := sum ; else skip ; )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void findNextWord(char[] s,int m){
    m+=97 ;
    int n=s.length ;
    int i=s.length-1 ;
    s[i]++;
    while(i>=0 && i<=n-1){
      if(s[i]>=m){
        s[i]='a' ;
        s[--i]++;
      }
      else if(s[i]==s[i-1] || s[i]==s[i-2]){
        s[i]++;
      }
      else {
        i++;
      }
    }
    if(i<=-1){
      System.out.println("-1");
    }
    else {
      System.out.println(s);
    }
  }
  public static void main(String[] args){
    char[] str="abcd".toCharArray();
    int k=4 ;
    findNextWord(str,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNextWord( s : Sequence(String), m : int) : void
  pre: true
  post: true
  activity: (     m := m+(97) ; 
     var n : int ; n := s->size() ;
    var i : int ; i := s->size() - 1 ;
    s[i+1] := s[i+1] + 1 ; 
    while (i >= 0 & i <= n - 1) do (     if (s[i+1] >= m) then (     s[i+1] := 'a' ; 
     s[i+1] := s[i+1] + 1 ) else     if (s[i+1] = s[i - 1+1] or s[i+1] = s[i - 2+1]) then (     s[i+1] := s[i+1] + 1 ) else (     i := i + 1 ) ;  ) ; 
    if (i <= -1) then (     OclFile["System.out"].println("-1") ) else (     OclFile["System.out"].println(s) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := "abcd"->characters() ;
     var k : int ; k := 4 ;
     execute findNextWord(str, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p009 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p009().run());
  }
  private static final int PERIMETER=1000 ;
  public String run(){
    for(int a=1 ; a<PERIMETER ; a++){
      for(int b=a+1 ; b<PERIMETER ; b++){
        int c=PERIMETER-a-b ;
        if(a*a+b*b==c*c){
          return Integer.toString(a*b*c);
        }
      }
    }
    throw new AssertionError("Not found");
  }
}
------------------------------------------------------------
OCL File:
---------
class p009 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p009.newp009().run()) );
  static    attribute PERIMETER : int := 1000;
   operation run() : String
  pre: true
  post: true
  activity: (         var a : int ; a := 1 ; while a < PERIMETER do ( (         var b : int ; b := a + 1 ; while b < PERIMETER do ( (     var c : int ; c := PERIMETER - a - b ;
     if (a * a + b * b = c * c) then (     return ((a * b * c) + "") ) else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
     error AssertionException("Not found") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Karen {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int q=sc.nextInt();
    int[] sufCount=new int[200001];
    for(int i=0 ; i<n ; i++){
      int l=sc.nextInt();
      int r=sc.nextInt();
      if(l==1){
        sufCount[r]++;
      }
      else {
        sufCount[l-1]--;
        sufCount[r]++;
      }
    }
    for(int i=200000-1 ; i>=1 ; i--){
      sufCount[i]=sufCount[i]+sufCount[i+1];
    }
    for(int i=1 ; i<=200000 ; i++){
      if(sufCount[i]>=k){
        sufCount[i]=1 ;
      }
      else {
        sufCount[i]=0 ;
      }
    }
    for(int i=2 ; i<=200000 ; i++){
      sufCount[i]+=sufCount[i-1];
    }
    for(int i=0 ; i<q ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      if(a==1){
        System.out.println(sufCount[b]);
      }
      else {
        System.out.println(sufCount[b]-sufCount[a-1]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Karen {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var sufCount : Sequence(int) ; sufCount := Integer.subrange(1,200001)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
     if (l = 1) then (     sufCount[r+1] := sufCount[r+1] + 1 ) else (     sufCount[l - 1+1] := sufCount[l - 1+1] - 1 ; 
     sufCount[r+1] := sufCount[r+1] + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 200000 - 1 ; while i >= 1 do ( (     sufCount[i+1] := sufCount[i+1] + sufCount[i + 1+1] )  ;     i := i - 1 ) ; 
        var i : int ; i := 1 ; while i <= 200000 do ( (     if (sufCount[i+1] >= k) then (     sufCount[i+1] := 1 ) else (     sufCount[i+1] := 0 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= 200000 do ( (     sufCount[i+1] := sufCount[i+1]+(sufCount[i - 1+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (a = 1) then (     OclFile["System.out"].println(sufCount[b+1]) ) else (     OclFile["System.out"].println(sufCount[b+1] - sufCount[a - 1+1]) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class KarenAndCoffeeHW {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    int q=in.nextInt();
    int arr[]=new int[200005];
    for(int i=0 ; i<n ; i++){
      int l=in.nextInt();
      int r=in.nextInt();
      arr[r]++;
      if(l>0){
        arr[l-1]--;
      }
    }
    for(int i=200003 ; i>=1 ; i--){
      arr[i]=arr[i]+arr[i+1];
    }
    int count=0 ;
    int[] c=new int[200005];
    int x=0 ;
    if(arr[0]>=k){
      c[0]++;
    }
    for(int i=1 ; i<200003 ; i++){
      if(arr[i]>=k){
        c[i]++;
        c[i]+=c[i-1];
      }
      else {
        c[i]=c[i-1];
      }
    }
    while(q-->0){
      int a=in.nextInt();
      int b=in.nextInt();
      System.out.println(c[b]-c[a-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class KarenAndCoffeeHW {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var q : int ; q := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,200005)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var l : int ; l := in.getCurrent()->toInteger() ;
     var r : int ; r := in.getCurrent()->toInteger() ;
     arr[r+1] := arr[r+1] + 1 ; 
     if (l > 0) then (     arr[l - 1+1] := arr[l - 1+1] - 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 200003 ; while i >= 1 do ( (     arr[i+1] := arr[i+1] + arr[i + 1+1] )  ;     i := i - 1 ) ; 
    var count : int ; count := 0 ;
    var c : Sequence(int) ; c := Integer.subrange(1,200005)->collect(0) ;
    var x : int ; x := 0 ;
    if (arr[0+1] >= k) then (     c[0+1] := c[0+1] + 1 ) else skip ; 
        var i : int ; i := 1 ; while i < 200003 do ( (     if (arr[i+1] >= k) then (     c[i+1] := c[i+1] + 1 ; 
     c[i+1] := c[i+1]+(c[i - 1+1]) ) else (     c[i+1] := c[i - 1+1] ) )  ;     i := i + 1 ) ; 
        while (q > 0) do (        q := q - 1 ;     skip ; (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println(c[b+1] - c[a - 1+1]) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPossible(int a[],int n){
    int k=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]!=i+1)k++;
    }
    if(k<=2)return true ;
    return false ;
  }
  public static void main(String[] args){
    int a[]={
      5,2,3,4,1 };
      int n=a.length ;
      if(isPossible(a,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPossible( a : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var k : int ; k := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] /= i + 1) then     k := k + 1 ; else skip )  ;     i := i + 1 ) ; 
     if (k <= 2) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{5,2,3,4,1} ;
     var n : int ; n := a->size() ;
     if (isPossible(a, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int w=sc.nextInt();
      int d=sc.nextInt();
      if(w==0 && d==0)break ;
      int[] h1=new int[w];
      int[] h2=new int[d];
      int[] count1=new int[21];
      int ans=0 ;
      for(int i=0 ; i<h1.length ; ++i){
        h1[i]=sc.nextInt();
++count1[h1[i] ];
        ans+=h1[i];
      }
      for(int i=0 ; i<h2.length ; ++i){
        h2[i]=sc.nextInt();
        ans+=h2[i];
        if(count1[h2[i] ]>0){
          ans-=h2[i];
--count1[h2[i] ];
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var w : int ; w := sc.getCurrent()->toInteger() ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
    if (w = 0 & d = 0) then     break else skip ; 
    var h1 : Sequence(int) ; h1 := Integer.subrange(1,w)->collect(0) ;
    var h2 : Sequence(int) ; h2 := Integer.subrange(1,d)->collect(0) ;
    var count1 : Sequence(int) ; count1 := Integer.subrange(1,21)->collect(0) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < h1->size() do ( (     h1[i+1] := sc.getCurrent()->toInteger() ; 
     count1[h1[i+1]+1] := count1[h1[i+1]+1] + 1 ; 
     ans := ans+(h1[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < h2->size() do ( (     h2[i+1] := sc.getCurrent()->toInteger() ; 
     ans := ans+(h2[i+1]) ; 
     if (count1[h2[i+1]+1] > 0) then (     ans := ans-(h2[i+1]) ; 
     count1[h2[i+1]+1] := count1[h2[i+1]+1] - 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Queue ;
import java.util.Stack ;
class Gfg {
  static boolean checkStackPermutation(int ip[],int op[],int n){
    Queue<Integer>input=new LinkedList<>();
    for(int i=0 ; i<n ; i++){
      input.add(ip[i]);
    }
    Queue<Integer>output=new LinkedList<>();
    for(int i=0 ; i<n ; i++){
      output.add(op[i]);
    }
    Stack<Integer>tempStack=new Stack<>();
    while(! input.isEmpty()){
      int ele=input.poll();
      if(ele==output.peek()){
        output.poll();
        while(! tempStack.isEmpty()){
          if(tempStack.peek()==output.peek()){
            tempStack.pop();
            output.poll();
          }
          else break ;
        }
      }
      else {
        tempStack.push(ele);
      }
    }
    return(input.isEmpty()&& tempStack.isEmpty());
  }
  public static void main(String[] args){
    int input[]={
      1,2,3 };
      int output[]={
        2,1,3 };
        int n=3 ;
        if(checkStackPermutation(input,output,n))System.out.println("Yes");
        else System.out.println("Not Possible");
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Gfg {
  static   operation checkStackPermutation( ip : Sequence(int), op : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var input : Sequence(int) ; input := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     input := input->including(ip[i+1]) )  ;     i := i + 1 ) ; 
    var output : Sequence(int) ; output := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     output := output->including(op[i+1]) )  ;     i := i + 1 ) ; 
    var tempStack : Sequence(int) ; tempStack := Sequence{} ;
    while (not(input->isEmpty())) do (     var ele : int ; ele := input->min() ;
     if (ele = output->min()) then (     output := output->sort()->tail() ; 
     while (not(tempStack->isEmpty())) do (     if (tempStack->min() = output->min()) then (     tempStack := tempStack->front() ; 
     output := output->sort()->tail() ) else     break ) ) else (     tempStack := tempStack->append(ele) ) ) ; 
    return (input->isEmpty() & tempStack->isEmpty()) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : Sequence(int) ; input := Sequence{1,2,3} ;
     var output : Sequence(int) ; output := Sequence{2,1,3} ;
     var n : int ; n := 3 ;
     if (checkStackPermutation(input, output, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("Not Possible") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int w,d ;
      w=parseInt(line.substring(0,line.indexOf(' ')));
      d=parseInt(line.substring(line.indexOf(' ')+1));
      if((w | d)==0)break ;
      int[][] h=new int[21][2];
      StringTokenizer st ;
      st=new StringTokenizer(br.readLine());
      for(int i=0 ; i<w ; i++){
        h[parseInt(st.nextToken())][0]++;
      }
      st=new StringTokenizer(br.readLine());
      for(int i=0 ; i<d ; i++){
        h[parseInt(st.nextToken())][1]++;
      }
      int ans=0 ;
      for(int i=1 ; i<=20 ; i++){
        ans+=i*Math.max(h[i][0],h[i][1]);
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var w : int ;
    var d : int ;
     w := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    d := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    if ((MathLib.bitwiseOr(w,d)) = 0) then     break else skip ; 
    var h : Sequence(Sequence(int)) ; h := Integer.subrange(1,21)->collect(Integer.subrange(1,2)->collect(0)) ;
    var st : OclIterator ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < w do ( (     h[parseInt(st.next())+1][0+1] := h[parseInt(st.next())+1][0+1] + 1 )  ;     i := i + 1 ) ; 
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < d do ( (     h[parseInt(st.next())+1][1+1] := h[parseInt(st.next())+1][1+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= 20 do ( (     ans := ans+(i * Set{h[i+1][0+1], h[i+1][1+1]}->max()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    while(true){
      int frontNum=scanner.nextInt();
      int sideNum=scanner.nextInt();
      if(frontNum==0){
        scanner.close();
        break ;
      }
      PriorityQueue<Integer>front=new PriorityQueue<Integer>();
      PriorityQueue<Integer>side=new PriorityQueue<Integer>();
      for(int i=0 ; i<frontNum ; i++){
        front.add(scanner.nextInt());
      }
      for(int i=0 ; i<sideNum ; i++){
        side.add(scanner.nextInt());
      }
      int ans=0 ;
      while(! front.isEmpty()|| ! side.isEmpty()){
        if(front.peek()==side.peek()){
          ans+=front.poll();
          side.poll();
        }
        else if(side.isEmpty()||(! front.isEmpty()&& front.peek()<side.peek())){
          ans+=front.poll();
        }
        else if(front.isEmpty()|| front.peek()>side.peek()){
          ans+=side.poll();
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var frontNum : int ; frontNum := scanner.getCurrent()->toInteger() ;
     var sideNum : int ; sideNum := scanner.getCurrent()->toInteger() ;
    if (frontNum = 0) then (     skip ; 
     break ) else skip ; 
    var front : Sequence(int) ; front := Sequence{} ;
    var side : Sequence(int) ; side := Sequence{} ;
        var i : int ; i := 0 ; while i < frontNum do ( (     front := front->including(scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < sideNum do ( (     side := side->including(scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    while (not(front->isEmpty()) or not(side->isEmpty())) do (     if (front->min() = side->min()) then (     ans := ans + front->min() ;     front := front->sort()->tail() ; 
     side := side->sort()->tail() ) else     if (side->isEmpty() or (not(front->isEmpty()) & front->min() < side->min())) then (     ans := ans + front->min() ;     front := front->sort()->tail() ) else     if (front->isEmpty() or front->min() > side->min()) then (     ans := ans + side->min() ;     side := side->sort()->tail() ) else skip ; ;  ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int R=5 ;
  static int C=5 ;
  static int findMaxCock(int ar[][]){
    if(R<3 || C<3)return-1 ;
    int max_sum=Integer.MIN_VALUE ;
    for(int i=0 ; i<R-2 ; i++){
      for(int j=0 ; j<C-2 ; j++){
        int sum=(ar[i][j]+ar[i][j+2])+(ar[i+1][j+1])+(ar[i+2][j]+ar[i+2][j+1]+ar[i+2][j+2]);
        max_sum=Math.max(max_sum,sum);
      }
    }
    return max_sum ;
  }
  public static void main(String[] args){
    int ar[][]={
      {
        0,3,0,6,0 },{
          0,1,1,0,0 },{
            1,1,1,0,0 },{
              0,0,2,0,1 },{
                0,2,0,1,3 }
              };
              System.out.println(findMaxCock(ar));
            }
          }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute R : int := 5;
  static   attribute C : int := 5;
  static   operation findMaxCock( ar : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     if (R < 3 or C < 3) then     return -1 else skip ; 
     var max_sum : int ; max_sum := -2147483648 ;
         var i : int ; i := 0 ; while i < R - 2 do ( (         var j : int ; j := 0 ; while j < C - 2 do ( (     var sum : int ; sum := (ar[i+1][j+1] + ar[i+1][j + 2+1]) + (ar[i + 1+1][j + 1+1]) + (ar[i + 2+1][j+1] + ar[i + 2+1][j + 1+1] + ar[i + 2+1][j + 2+1]) ;
     max_sum := Set{max_sum, sum}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return max_sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ar : Sequence(Sequence(int)) ; ar := Sequence{Sequence{0,3,0,6,0},Sequence{0,1,1,0,0},Sequence{1,1,1,0,0},Sequence{0,0,2,0,1},Sequence{0,2,0,1,3}} ;
     OclFile["System.out"].println(findMaxCock(ar)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int[] swap(int[] arr,int i,int j){
    int temp=arr[i];
    arr[i]=arr[j];
    arr[j]=temp ;
    return arr ;
  }
  static void sort_shell_metzner(int arr[],int n){
    int i,j,k,l,m,temp ;
    m=n ;
    while(m>0){
      m/=2 ;
      k=n-m ;
      j=0 ;
      do {
        i=j ;
        do {
          l=i+m ;
          if(l<n && arr[i]>arr[l]){
            swap(arr,i,l);
            i-=m ;
          }
          else {
            break ;
          }
        }
        while(i>=0);
        j++;
      }
      while(j<=k);
    }
  }
  static void printArray(int arr[],int n){
    for(int i=0 ; i<n ; i++){
      System.out.print(arr[i]+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      0,-2,8,5,1 };
      int n=arr.length ;
      sort_shell_metzner(arr,n);
      printArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation swap( arr : Sequence(int), i : int, j : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := arr[j+1] ; 
     arr[j+1] := temp ; 
     return arr );
  static   operation sort_shell_metzner( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var k : int ;
    var l : int ;
    var m : int ;
    var temp : int ;
     m := n ; 
     while (m > 0) do (     m := m/(2) ; 
     k := n - m ; 
     j := 0 ; 
   while true do ((     i := j ; 
   while true do ((     l := i + m ; 
     if (l < n & arr[i+1] > arr[l+1]) then (     execute swap(arr, i, l) ; 
     i := i-(m) ) else (     break ) ) ;
    if (i >= 0) then skip else break) ; 
     j := j + 1 ) ;
    if (j <= k) then skip else break) ) );
  static   operation printArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,-2,8,5,1} ;
     var n : int ; n := arr->size() ;
     execute sort_shell_metzner(arr, n) ; 
     execute printArray(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] tmpArray=br.readLine().split(" ");
    int n=Integer.parseInt(tmpArray[0]);
    int q=Integer.parseInt(tmpArray[1]);
    SqrtDecomposition sq=new SqrtDecomposition(n);
    for(int i=0 ; i<q ; i++){
      tmpArray=br.readLine().split(" ");
      if(tmpArray[0] .equals("0")){
        sq.add(Integer.parseInt(tmpArray[1]),Integer.parseInt(tmpArray[2])+1,Integer.parseInt(tmpArray[3]));
      }
      else {
        System.out.println(sq.get(Integer.parseInt(tmpArray[1])));
      }
    }
  }
}
class SqrtDecomposition {
  int N,K ;
  long[] data ;
  long[] bucketAdd ;
  static final int sqrtN=512 ;
  public SqrtDecomposition(int n){
    N=n ;
    K=(N+sqrtN-1)/sqrtN ;
    data=new long[K*sqrtN];
    bucketAdd=new long[K];
  }
  void add(int s,int t,int x){
    for(int k=0 ; k<K ; ++k){
      int l=k*sqrtN,r=(k+1)*sqrtN ;
      if(r<=s || t<=l)continue ;
      if(s<=l && r<=t){
        bucketAdd[k]+=x ;
      }
      else {
        for(int i=Math.max(s,l); i<Math.min(t,r); ++i){
          data[i]+=x ;
        }
      }
    }
  }
  long get(int s){
    int k=s/sqrtN ;
    return data[s]+bucketAdd[k];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
    var n : int ; n := (tmpArray[0+1])->toInteger() ;
    var q : int ; q := (tmpArray[1+1])->toInteger() ;
    var sq : SqrtDecomposition ; sq := SqrtDecomposition.newSqrtDecomposition(n) ;
        var i : int ; i := 0 ; while i < q do ( (     tmpArray := br.readLine()->split(" ") ; 
     if (tmpArray[0+1] = "0") then (     sq->excludes((tmpArray[1+1])->toInteger(), (tmpArray[2+1])->toInteger() + 1, (tmpArray[3+1])->toInteger()) ) else (     OclFile["System.out"].println(sq->at((tmpArray[1+1])->toInteger()+1)) ) )  ;     i := i + 1 ) ; 
 );
}
class SqrtDecomposition {
   attribute N : int;
   attribute data : Sequence(long);
   attribute bucketAdd : Sequence(long);
  static    attribute sqrtN : int := 512;
   static operation newSqrtDecomposition( n : int) : SqrtDecomposition
  pre: true
  post: true
  activity:
  ( var self : SqrtDecomposition ;
    self := createSqrtDecomposition();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     N := n ; 
     K := (N + sqrtN - 1) / sqrtN ; 
     data := Integer.subrange(1,K * sqrtN)->collect(0) ; 
     bucketAdd := Integer.subrange(1,K)->collect(0) );
   operation add( s : int, t : int, x : int) : void
  pre: true
  post: true
  activity: (         var k : int ; k := 0 ; while k < K do ( (     var l : int ; l := k * sqrtN ;
    var r : int ; r := (k + 1) * sqrtN ;
     if (r <= s or t <= l) then     continue else skip ; 
     if (s <= l & r <= t) then (     bucketAdd[k+1] := bucketAdd[k+1]+(x) ) else (         var i : int ; i := Set{s, l}->max() ; while i < Set{t, r}->min() do ( (     data[i+1] := data[i+1]+(x) )  ;     i := i + 1 ) ) )  ;     k := k + 1 ) );
   operation get( s : int) : long
  pre: true
  post: true
  activity: (     var k : int ; k := s / sqrtN ;
     return data[s+1] + bucketAdd[k+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int q=sc.nextInt();
    RaddQ rq=new RaddQ(n);
    for(int i=0 ; i<q ; i++){
      int command=sc.nextInt();
      if(command==0){
        int s=sc.nextInt();
        int t=sc.nextInt();
        int x=sc.nextInt();
        rq.add(0,n,0,s-1,t,x);
      }
      else if(command==1){
        int t=sc.nextInt();
        System.out.println(rq.get(0,n,0,t-1));
      }
    }
  }
}
class RaddQ {
  int n,heap[];
  RaddQ(int n){
    this.n=n ;
    int len=1 ;
    while(len<n){
      len*=2 ;
    }
    len=2*len ;
    heap=new int[len];
  }
  void add(int l,int r,int ih,int s,int t,int x){
    if(s>=t){
      return ;
    }
    if(s==l && t==r){
      heap[ih]+=x ;
      return ;
    }
    int med=(l+r)/2 ;
    add(l,med,ih*2+1,Math.max(s,l),Math.min(t,med),x);
    add(med,r,ih*2+2,Math.max(s,med),Math.min(t,r),x);
  }
  int get(int l,int r,int ih,int t){
    if(r-l==1){
      return heap[ih];
    }
    int med=(l+r)/2 ;
    if(t<med){
      return heap[ih]+get(l,med,ih*2+1,t);
    }
    else {
      return heap[ih]+get(med,r,ih*2+2,t);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var rq : RaddQ ; rq := RaddQ.newRaddQ(n) ;
        var i : int ; i := 0 ; while i < q do ( (     var command : int ; command := sc.getCurrent()->toInteger() ;
     if (command = 0) then (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     rq->excludes(0, n, 0, s - 1, t, x) ) else     if (command = 1) then (     var t : int ; t := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(rq->at(0, n, 0, t - 1+1)) ) else skip ; )  ;     i := i + 1 ) ; 
 );
}
class RaddQ {
   attribute n : int;
   static operation newRaddQ( n : int) : RaddQ
  pre: true
  post: true
  activity:
  ( var self : RaddQ ;
    self := createRaddQ();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     self.n := n ; 
     var len : int ; len := 1 ;
    while (len < n) do (     len := len*(2) ) ; 
    len := 2 * len ; 
    heap := Integer.subrange(1,len)->collect(0) ; 
 );
   operation add( l : int, r : int, ih : int, s : int, t : int, x : int) : void
  pre: true
  post: true
  activity: (     if (s >= t) then (     return ) else skip ; 
     if (s = l & t = r) then (     heap[ih+1] := heap[ih+1]+(x) ; 
     return ) else skip ; 
    var med : int ; med := (l + r) / 2 ;
    execute add(l, med, ih * 2 + 1, Set{s, l}->max(), Set{t, med}->min(), x) ; 
    execute add(med, r, ih * 2 + 2, Set{s, med}->max(), Set{t, r}->min(), x) ; 
 );
   operation get( l : int, r : int, ih : int, t : int) : int
  pre: true
  post: true
  activity: (     if (r - l = 1) then (     return heap[ih+1] ) else skip ; 
     var med : int ; med := (l + r) / 2 ;
     if (t < med) then (     return heap[ih+1] + at(l, med, ih * 2 + 1, t+1) ) else (     return heap[ih+1] + at(med, r, ih * 2 + 2, t+1) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int q=sc.nextInt();
    RaddQ rq=new RaddQ(n);
    for(int i=0 ; i<q ; i++){
      int command=sc.nextInt();
      if(command==0){
        int s=sc.nextInt();
        int t=sc.nextInt();
        int x=sc.nextInt();
        rq.add(0,n,0,s-1,t,x);
      }
      else if(command==1){
        int t=sc.nextInt();
        System.out.println(rq.get(0,n,0,t-1));
      }
    }
  }
}
class RaddQ {
  int n,heap[];
  RaddQ(int n){
    this.n=n ;
    int len=1 ;
    while(len<n){
      len*=2 ;
    }
    len=2*len ;
    heap=new int[len];
  }
  void add(int l,int r,int ih,int s,int t,int x){
    if(s>=t){
      return ;
    }
    if(s==l && t==r){
      heap[ih]+=x ;
      return ;
    }
    int med=(l+r)/2 ;
    add(l,med,ih*2+1,Math.max(s,l),Math.min(t,med),x);
    add(med,r,ih*2+2,Math.max(s,med),Math.min(t,r),x);
  }
  int get(int l,int r,int ih,int t){
    if(r-l==1){
      return heap[ih];
    }
    int med=(l+r)/2 ;
    if(t<med){
      return heap[ih]+get(l,med,ih*2+1,t);
    }
    else {
      return heap[ih]+get(med,r,ih*2+2,t);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var rq : RaddQ ; rq := RaddQ.newRaddQ(n) ;
        var i : int ; i := 0 ; while i < q do ( (     var command : int ; command := sc.getCurrent()->toInteger() ;
     if (command = 0) then (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     rq->excludes(0, n, 0, s - 1, t, x) ) else     if (command = 1) then (     var t : int ; t := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(rq->at(0, n, 0, t - 1+1)) ) else skip ; )  ;     i := i + 1 ) ; 
 );
}
class RaddQ {
   attribute n : int;
   static operation newRaddQ( n : int) : RaddQ
  pre: true
  post: true
  activity:
  ( var self : RaddQ ;
    self := createRaddQ();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     self.n := n ; 
     var len : int ; len := 1 ;
    while (len < n) do (     len := len*(2) ) ; 
    len := 2 * len ; 
    heap := Integer.subrange(1,len)->collect(0) ; 
 );
   operation add( l : int, r : int, ih : int, s : int, t : int, x : int) : void
  pre: true
  post: true
  activity: (     if (s >= t) then (     return ) else skip ; 
     if (s = l & t = r) then (     heap[ih+1] := heap[ih+1]+(x) ; 
     return ) else skip ; 
    var med : int ; med := (l + r) / 2 ;
    execute add(l, med, ih * 2 + 1, Set{s, l}->max(), Set{t, med}->min(), x) ; 
    execute add(med, r, ih * 2 + 2, Set{s, med}->max(), Set{t, r}->min(), x) ; 
 );
   operation get( l : int, r : int, ih : int, t : int) : int
  pre: true
  post: true
  activity: (     if (r - l = 1) then (     return heap[ih+1] ) else skip ; 
     var med : int ; med := (l + r) / 2 ;
     if (t < med) then (     return heap[ih+1] + at(l, med, ih * 2 + 1, t+1) ) else (     return heap[ih+1] + at(med, r, ih * 2 + 2, t+1) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int getCount(String a,String b){
    if(b.length()% a.length()!=0)return-1 ;
    int count=b.length()/a.length();
    String str="" ;
    for(int i=0 ; i<count ; i++){
      str=str+a ;
    }
    if(str.equals(b))return count ;
    return-1 ;
  }
  public static void main(String[] args){
    String a="geeks" ;
    String b="geeksgeeks" ;
    System.out.println(getCount(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation getCount( a : String, b : String) : int
  pre: true
  post: true
  activity: (     if (b->size() mod a->size() /= 0) then     return -1 else skip ; 
     var count : int ; count := b->size() / a->size() ;
    var str : String ; str := "" ;
        var i : int ; i := 0 ; while i < count do ( (     str := str + a )  ;     i := i + 1 ) ; 
    if (str = b) then     return count else skip ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ; a := "geeks" ;
     var b : String ; b := "geeksgeeks" ;
     OclFile["System.out"].println(getCount(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String t=sc.next();
    int l=s.length();
    boolean ans=true ;
    for(int i=0 ; i<l ; i++){
      if(s.indexOf(s.charAt(i),i+1)!=t.indexOf(t.charAt(i),i+1)){
        ans=false ;
        break ;
      }
    }
    System.out.println(ans ? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var l : int ; l := s->size() ;
    var ans : boolean ; ans := true ;
        var i : int ; i := 0 ; while i < l do ( (     if (s.subrange(i + 1+1)->indexOf(s->at(i+1)+"") + i + 1 - 1  /= t.subrange(i + 1+1)->indexOf(t->at(i+1)+"") + i + 1 - 1 ) then (     ans := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if ans then "Yes" else "No" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    {
      int n=sc.nextInt();
      int m=sc.nextInt();
      int now=0 ;
      int x ;
      int ans=0 ;
      for(int i=1 ; i<=n ; i++){
        x=sc.nextInt();
        now+=x ;
        if(now>m){
          ans+=1 ;
          now=x ;
        }
      }
      if(now>0)ans++;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var now : int ; now := 0 ;
    var x : int ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     x := sc.getCurrent()->toInteger() ; 
     now := now+(x) ; 
     if (now > m) then (     ans := ans+(1) ; 
     now := x ) else skip )  ;     i := i + 1 ) ; 
    if (now > 0) then     ans := ans + 1 ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solve {
  static Scanner scan=new Scanner(System.in);
  public static void solve(int n,int[] a,int m){
    int sum=0,count=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if((sum+a[i])<=m){
        sum+=a[i];
      }
      if(sum==m ||(sum+a[i+1])>m){
        count++;
        sum=0 ;
      }
    }
    System.out.println(count+1);
  }
  public static void main(String[] args){
    int n=scan.nextInt();
    int[] a=new int[n];
    int m=scan.nextInt();
    for(int i=0 ; i<n ; i++){
      a[i]=scan.nextInt();
    }
    solve(n,a,m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solve {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation solve( n : int, a : Sequence(int), m : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
    var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     if ((sum + a[i+1]) <= m) then (     sum := sum+(a[i+1]) ) else skip ; 
     if (sum = m or (sum + a[i + 1+1]) > m) then (     count := count + 1 ; 
     sum := 0 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute solve(n, a, m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Queue_in_bus_stop {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int groupN=in.nextInt();
    int count=1 ;
    int j=m-groupN ;
    for(int i=1 ; i<n ; i++){
      groupN=in.nextInt();
      if(groupN>j){
        count++;
        j=m-groupN ;
      }
      else {
        j-=groupN ;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Queue_in_bus_stop {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var groupN : int ; groupN := in.getCurrent()->toInteger() ;
    var count : int ; count := 1 ;
    var j : int ; j := m - groupN ;
        var i : int ; i := 1 ; while i < n do ( (     groupN := in.getCurrent()->toInteger() ; 
     if (groupN > j) then (     count := count + 1 ; 
     j := m - groupN ) else (     j := j-(groupN) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.io.*;
class GFG {
  static int ksmallest(int arr[],int n,int k){
    Arrays.sort(arr);
    if(k<arr[0])return k ;
    if(k==arr[0])return arr[0]+1 ;
    if(k>arr[n-1])return k+n ;
    if(arr[0]==1)k--;
    else k-=(arr[0]-1);
    for(int i=1 ; i<n ; i++){
      int c=arr[i]-arr[i-1]-1 ;
      if(k<=c)return arr[i-1]+k ;
      else k-=c ;
    }
    return arr[n-1]+k ;
  }
  public static void main(String[] args){
    int k=1 ;
    int arr[]={
      1 };
      int n=arr.length ;
      System.out.println(ksmallest(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation ksmallest( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     if (k < arr[0+1]) then     return k else skip ; 
    if (k = arr[0+1]) then     return arr[0+1] + 1 else skip ; 
    if (k > arr[n - 1+1]) then     return k + n else skip ; 
    if (arr[0+1] = 1) then     k := k - 1 else     k := k-((arr[0+1] - 1)) ; ;  
        var i : int ; i := 1 ; while i < n do ( (     var c : int ; c := arr[i+1] - arr[i - 1+1] - 1 ;
     if (k <= c) then     return arr[i - 1+1] + k else     k := k-(c) ; )  ;     i := i + 1 ) ; 
    return arr[n - 1+1] + k 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 1 ;
     var arr : Sequence(int) ; arr := Sequence{1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(ksmallest(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printArray(int X,int d,int first_ele){
    while(X>0){
      int count_ele=0,pow_of_two=2 ;
      while(X-pow_of_two+1>=0){
        count_ele++;
        pow_of_two*=2 ;
      }
      X=X-(pow_of_two/2)+1 ;
      for(int j=0 ; j<count_ele ; j++)System.out.print(first_ele+" ");
      first_ele+=d ;
    }
  }
  public static void main(String[] args){
    int d=100,X=25 ;
    printArray(X,d,1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printArray( X : int, d : int, first_ele : int) : void
  pre: true
  post: true
  activity: (     while (X > 0) do (     var count_ele : int ; count_ele := 0 ;
    var pow_of_two : int ; pow_of_two := 2 ;
     while (X - pow_of_two + 1 >= 0) do (     count_ele := count_ele + 1 ; 
     pow_of_two := pow_of_two*(2) ) ; 
    X := X - (pow_of_two / 2) + 1 ; 
        var j : int ; j := 0 ; while j < count_ele do (     OclFile["System.out"].print(first_ele + " ") ;  ;     j := j + 1 ) ; 
    first_ele := first_ele+(d) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : int ; d := 100 ;
    var X : int ; X := 25 ;
     execute printArray(X, d, 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n-->0){
      String exp=sc.next();
      Parser parser=new Parser(exp);
      System.out.println(parser.expression());
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
class Parser {
  char[] exp ;
  int begin ;
  Parser(String str){
    this.exp=(str+"#").toCharArray();
  }
  int expression(){
    int ret=term();
    while(true){
      if(exp[begin]=='+'){
        begin++;
        ret+=term();
      }
      else if(exp[begin]=='-'){
        begin++;
        ret-=term();
      }
      else {
        break ;
      }
    }
    return ret ;
  }
  int term(){
    int ret=factor();
    while(true){
      if(exp[begin]=='*'){
        begin++;
        ret*=factor();
      }
      else if(exp[begin]=='/'){
        begin++;
        ret/=factor();
      }
      else {
        break ;
      }
    }
    return ret ;
  }
  int number(){
    int ret=0 ;
    while(Character.isDigit(exp[begin])){
      ret*=10 ;
      ret+=exp[begin]-'0' ;
      begin++;
    }
    return ret ;
  }
  int factor(){
    if(exp[begin]=='('){
      begin++;
      int ret=expression();
      begin++;
      return ret ;
    }
    else {
      return number();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var exp : String ; exp := sc.getCurrent() ;
     var parser : Parser ; parser := Parser.newParser(exp) ;
     OclFile["System.out"].println(parser.expression()) ) ;  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}
class Parser {
   attribute exp : Sequence(String);
   attribute begin : int;
   static operation newParser( str : String) : Parser
  pre: true
  post: true
  activity:
  ( var self : Parser ;
    self := createParser();
    self.initialise(str);
    return self );
  operation initialise( str : String) : void
  pre: true  post: true
  activity: (     self.exp := (str + "#")->characters() );
   operation expression() : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := term() ;
     while (true) do (     if (exp[begin+1] = '+') then (     begin := begin + 1 ; 
     ret := ret+(term()) ) else     if (exp[begin+1] = '-') then (     begin := begin + 1 ; 
     ret := ret-(term()) ) else (     break ) ;  ) ; 
     return ret );
   operation term() : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := factor() ;
     while (true) do (     if (exp[begin+1] = '*') then (     begin := begin + 1 ; 
     ret := ret*(factor()) ) else     if (exp[begin+1] = '/') then (     begin := begin + 1 ; 
     ret := ret/(factor()) ) else (     break ) ;  ) ; 
     return ret );
   operation number() : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
     while ((exp[begin+1] + "")->isMatch("[0-9]")) do (     ret := ret*(10) ; 
     ret := ret+(exp[begin+1] - ('0')->char2byte()) ; 
     begin := begin + 1 ) ; 
     return ret );
   operation factor() : int
  pre: true
  post: true
  activity: (     if (exp[begin+1] = '(') then (     begin := begin + 1 ; 
     var ret : int ; ret := expression() ;
     begin := begin + 1 ; 
     return ret ) else (     return number() ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
class Main {
  public static void main(final String[] args)throws IOException {
    final Scanner stdin=new Scanner(System.in);
    final int n=Integer.parseInt(stdin.nextLine());
    for(int i=0 ; i<n ; i++){
      final String input=stdin.nextLine();
      final StreamTokenizer tokenizer=new StreamTokenizer(new StringReader(input.substring(0,input.length()-1)));
      tokenizer.parseNumbers();
      tokenizer.ordinaryChar('+');
      tokenizer.ordinaryChar('-');
      tokenizer.ordinaryChar('/');
      tokenizer.ordinaryChar('*');
      tokenizer.ordinaryChar(')');
      tokenizer.ordinaryChar('(');
      tokenizer.nextToken();
      System.out.println(pm(tokenizer));
    }
  }
  static int pm(StreamTokenizer tokenizer)throws IOException {
    int ans=md(tokenizer);
    while(tokenizer.ttype!=StreamTokenizer.TT_EOF &&(tokenizer.ttype=='+' || tokenizer.ttype=='-')){
      boolean add=(tokenizer.ttype=='+');
      tokenizer.nextToken();
      final int val=md(tokenizer);
      if(add){
        ans+=val ;
      }
      else {
        ans-=val ;
      }
    }
    return ans ;
  }
  static int md(StreamTokenizer tokenizer)throws IOException {
    int ans=term(tokenizer);
    while(tokenizer.ttype!=StreamTokenizer.TT_EOF &&(tokenizer.ttype=='*' || tokenizer.ttype=='/')){
      boolean mul=(tokenizer.ttype=='*');
      tokenizer.nextToken();
      final int val=term(tokenizer);
      if(mul){
        ans*=val ;
      }
      else {
        ans/=val ;
      }
    }
    return ans ;
  }
  static int term(StreamTokenizer tokenizer)throws IOException {
    if(tokenizer.ttype==StreamTokenizer.TT_NUMBER){
      final int val=(int)tokenizer.nval ;
      tokenizer.nextToken();
      return val ;
    }
    else {
      tokenizer.nextToken();
      final int val=pm(tokenizer);
      tokenizer.nextToken();
      return val ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (stdin.nextLine())->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var input : String ; input := stdin.nextLine() ;
     var tokenizer : StreamTokenizer ; tokenizer := StreamTokenizer.newStreamTokenizer(StringReader.newStringReader(input.subrange(0+1,input->size() - 1))) ;
    tokenizer.parseNumbers() ; 
    tokenizer.ordinaryChar('+') ; 
    tokenizer.ordinaryChar('-') ; 
    tokenizer.ordinaryChar('/') ; 
    tokenizer.ordinaryChar('*') ; 
    tokenizer.ordinaryChar(')') ; 
    tokenizer.ordinaryChar('(') ; 
    tokenizer.next() ; 
    OclFile["System.out"].println(pm(tokenizer)) ; 
 )  ;     i := i + 1 ) );
  static   operation pm( tokenizer : StreamTokenizer) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := md(tokenizer) ;
     while (tokenizer.ttype /= StreamTokenizer.TT_EOF & (tokenizer.ttype = '+' or tokenizer.ttype = '-')) do (     var add : boolean ; add := (tokenizer.ttype = '+') ;
     tokenizer.next() ; 
     var val : int ; val := md(tokenizer) ;
     if (add) then (     ans := ans+(val) ) else (     ans := ans-(val) ) ) ; 
     return ans );
  static   operation md( tokenizer : StreamTokenizer) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := term(tokenizer) ;
     while (tokenizer.ttype /= StreamTokenizer.TT_EOF & (tokenizer.ttype = '*' or tokenizer.ttype = '/')) do (     var mul : boolean ; mul := (tokenizer.ttype = '*') ;
     tokenizer.next() ; 
     var val : int ; val := term(tokenizer) ;
     if (mul) then (     ans := ans*(val) ) else (     ans := ans/(val) ) ) ; 
     return ans );
  static   operation term( tokenizer : StreamTokenizer) : int
  pre: true
  post: true
  activity: (     if (tokenizer.ttype = StreamTokenizer.TT_NUMBER) then (     var val : int ; val := tokenizer.nval->oclAsType(int) ;
     tokenizer.next() ; 
     return val ) else (     tokenizer.next() ; 
     var val : int ; val := pm(tokenizer) ;
     tokenizer.next() ; 
     return val ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  String formulaStr="" ;
  int index=0 ;
  public static void main(String[] args){
    Main main=new Main();
    main.smartCalculator();
    return ;
  }
  private void smartCalculator(){
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    try {
      String inputNumStr=bufferedReader.readLine();
      int inputNum=Integer.parseInt(inputNumStr);
      for(int i=0 ; i<inputNum ; i++){
        formulaStr=bufferedReader.readLine();
        index=0 ;
        System.out.println(this.calculationFormula());
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  private Long calculationFormula(){
    long answer=0 ;
    answer=this.calculationAddSub();
    return answer ;
  }
  private Long calculationAddSub(){
    long answer=this.calculationMulDiv();
    while(true){
      switch(formulaStr.charAt(index)){
        case '+' : index++;
        answer+=this.calculationMulDiv();
        break ;
        case '-' : index++;
        answer-=this.calculationMulDiv();
        break ;
        default : return answer ;
      }
    }
  }
  private Long calculationMulDiv(){
    long answer=this.calculationTerm();
    while(true){
      switch(formulaStr.charAt(index)){
        case '*' : index++;
        answer*=this.calculationTerm();
        break ;
        case '/' : index++;
        answer/=this.calculationTerm();
        break ;
        default : return answer ;
      }
    }
  }
  private Long calculationTerm(){
    long answer=0 ;
    if(formulaStr.charAt(index)=='('){
      index++;
      answer=this.calculationAddSub();
      index++;
      return answer ;
    }
    if(Character.isDigit(formulaStr.charAt(index))){
      return this.calculationValue();
    }
    return(long)0 ;
  }
  private Long calculationValue(){
    String tmpStr=formulaStr.substring(index);
    String[] tmpStrs=tmpStr.split("[+-/\\*=)] ");
    index+=tmpStrs[0] .length();
    return Long.parseLong(tmpStrs[0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute formulaStr : String := "";
   attribute index : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.smartCalculator() ; 
     return );
   operation smartCalculator() : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var inputNumStr : String ; inputNumStr := bufferedReader.readLine() ;
     var inputNum : int ; inputNum := (inputNumStr)->toInteger() ;
         var i : int ; i := 0 ; while i < inputNum do ( (     formulaStr := bufferedReader.readLine() ; 
     index := 0 ; 
     OclFile["System.out"].println(self.calculationFormula()) )  ;     i := i + 1 ) )   catch (e : IOException) do (     e.printStackTrace() )
 );
   operation calculationFormula() : long
  pre: true
  post: true
  activity: (     var answer : long ; answer := 0 ;
     answer := self.calculationAddSub() ; 
     return answer );
   operation calculationAddSub() : long
  pre: true
  post: true
  activity: (     var answer : long ; answer := self.calculationMulDiv() ;
     while (true) do ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (formulaStr->at(index+1)) ; 
       if _switchval = '+' then
     index := index + 1 ; 
    answer := answer+(self.calculationMulDiv()) ; 
    break 
   else skip ;
       if _switchval = '-' then
     index := index + 1 ; 
    answer := answer-(self.calculationMulDiv()) ; 
    break 
   else skip ;
       if true then
     return answer 
   else skip ;
 )
 ) );
   operation calculationMulDiv() : long
  pre: true
  post: true
  activity: (     var answer : long ; answer := self.calculationTerm() ;
     while (true) do ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (formulaStr->at(index+1)) ; 
       if _switchval = '*' then
     index := index + 1 ; 
    answer := answer*(self.calculationTerm()) ; 
    break 
   else skip ;
       if _switchval = '/' then
     index := index + 1 ; 
    answer := answer/(self.calculationTerm()) ; 
    break 
   else skip ;
       if true then
     return answer 
   else skip ;
 )
 ) );
   operation calculationTerm() : long
  pre: true
  post: true
  activity: (     var answer : long ; answer := 0 ;
     if (formulaStr->at(index+1) = '(') then (     index := index + 1 ; 
     answer := self.calculationAddSub() ; 
     index := index + 1 ; 
     return answer ) else skip ; 
     if ((formulaStr->at(index+1) + "")->isMatch("[0-9]")) then (     return self.calculationValue() ) else skip ; 
     return 0->oclAsType(long) );
   operation calculationValue() : long
  pre: true
  post: true
  activity: (     var tmpStr : String ; tmpStr := formulaStr.subrange(index+1,index) ;
     var tmpStrs : Sequence(String) ; tmpStrs := tmpStr->split("[+-/\\*=)] ") ;
     index := index+(tmpStrs[0+1]->size()) ; 
     return (tmpStrs[0+1])->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.function.IntBinaryOperator ;
public class Main {
  static int lastIndexOf(String e,char ch,char ch2){
    int nest=0 ;
    for(int i=e.length()-1 ; i>0 ; i--){
      char c=e.charAt(i);
      if(c=='('){
        nest++;
      }
      if(c==')'){
        nest--;
      }
      if((ch==c || c==ch2)&& nest==0){
        return i ;
      }
    }
    return-1 ;
  }
  static int parse(String e){
    int loc=lastIndexOf(e,'-','+');
    if(loc!=-1){
      if(e.charAt(loc)=='+'){
        return parse(e.substring(0,loc))+parse(e.substring(loc+1));
      }
      return parse(e.substring(0,loc))-parse(e.substring(loc+1));
    }
    loc=lastIndexOf(e,'/','*');
    if(loc!=-1){
      if(e.charAt(loc)=='*'){
        return parse(e.substring(0,loc))*parse(e.substring(loc+1));
      }
      return parse(e.substring(0,loc))/parse(e.substring(loc+1));
    }
    if(e.startsWith("(")&& e.endsWith(")")){
      return parse(e.substring(1,e.length()-1));
    }
    return Integer.parseInt(e);
  }
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      for(int i=0 ; i<n ; i++){
        String e=sc.next().replace("=","");
        System.out.println(parse(e));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation lastIndexOf( e : String, ch : String, ch2 : String) : int
  pre: true
  post: true
  activity: (     var nest : int ; nest := 0 ;
         var i : int ; i := e->size() - 1 ; while i > 0 do ( (     var c : String ; c := e->at(i+1) ;
     if (c = '(') then (     nest := nest + 1 ) else skip ; 
     if (c = ')') then (     nest := nest - 1 ) else skip ; 
     if ((ch = c or c = ch2) & nest = 0) then (     return i ) else skip )  ;     i := i - 1 ) ; 
     return -1 );
  static   operation parse( e : String) : int
  pre: true
  post: true
  activity: (     var loc : int ; loc := lastIndexOf(e, '-', '+') ;
     if (loc /= -1) then (     if (e->at(loc+1) = '+') then (     return parse(e.subrange(0+1,loc)) + parse(e.subrange(loc + 1+1,loc + 1)) ) else skip ; 
     return parse(e.subrange(0+1,loc)) - parse(e.subrange(loc + 1+1,loc + 1)) ) else skip ; 
    loc := lastIndexOf(e, '/', '*') ; 
    if (loc /= -1) then (     if (e->at(loc+1) = '*') then (     return parse(e.subrange(0+1,loc)) * parse(e.subrange(loc + 1+1,loc + 1)) ) else skip ; 
     return parse(e.subrange(0+1,loc)) / parse(e.subrange(loc + 1+1,loc + 1)) ) else skip ; 
    if (e->hasPrefix("(") & e->hasSuffix(")")) then (     return parse(e.subrange(1+1,e->size() - 1)) ) else skip ; 
    return (e)->toInteger() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var e : String ; e := sc.getCurrent().replace("=", "") ;
     OclFile["System.out"].println(parse(e)) )  ;     i := i + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static void main(String[] args)throws Exception {
    try(Scanner sc=new Scanner(System.in)){
      String S=sc.next();
      String T=sc.next();
      HashMap<Character,Integer>hm=new HashMap<Character,Integer>();
      for(int i=0 ; i<S.length(); i++){
        if(hm.containsKey(S.charAt(i))){
          hm.put(S.charAt(i),hm.get(S.charAt(i))+1);
        }
        else {
          hm.put(S.charAt(i),1);
        }
      }
      HashMap<Character,Integer>hm2=new HashMap<Character,Integer>();
      for(int i=0 ; i<T.length(); i++){
        if(hm2.containsKey(T.charAt(i))){
          hm2.put(T.charAt(i),hm2.get(T.charAt(i))+1);
        }
        else {
          hm2.put(T.charAt(i),1);
        }
      }
      int[] arr1=new int[hm.size()];
      int[] arr2=new int[hm2.size()];
      int i=0 ;
      for(Integer var : hm.values()){
        arr1[i]=(int)var ;
        i++;
      }
      i=0 ;
      for(Integer var : hm2.values()){
        arr2[i]=(int)var ;
        i++;
      }
      Arrays.sort(arr1);
      Arrays.sort(arr2);
      if(arr1.length!=arr2.length){
        System.out.println("No");
        return ;
      }
      else {
        for(int j=0 ; j<arr1.length ; j++){
          if(arr1[j]!=arr2[j]){
            System.out.println("No");
            return ;
          }
        }
        System.out.println("Yes");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var S : String ; S := sc.getCurrent() ;
     var T : String ; T := sc.getCurrent() ;
    var hm : Map(String,int) ; hm := Map{} ;
        var i : int ; i := 0 ; while i < S->size() do ( (     if (hm->keys()->includes(S->at(i+1))) then (     hm := hm->union(Map{S->at(i+1) |-> hm->at(S->at(i+1)) + 1}) ) else (     hm := hm->union(Map{S->at(i+1) |-> 1}) ) )  ;     i := i + 1 ) ; 
    var hm2 : Map(String,int) ; hm2 := Map{} ;
        var i : int ; i := 0 ; while i < T->size() do ( (     if (hm2->keys()->includes(T->at(i+1))) then (     hm2 := hm2->union(Map{T->at(i+1) |-> hm2->at(T->at(i+1)) + 1}) ) else (     hm2 := hm2->union(Map{T->at(i+1) |-> 1}) ) )  ;     i := i + 1 ) ; 
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,hm.size())->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,hm2.size())->collect(0) ;
    var i : int ; i := 0 ;
    for (var : hm->values()) do ( (     arr1[i+1] := var->oclAsType(int) ; 
     i := i + 1 )  ) ; 
    i := 0 ; 
    for (var : hm2->values()) do ( (     arr2[i+1] := var->oclAsType(int) ; 
     i := i + 1 )  ) ; 
    arr1 := arr1->sort() ; 
    arr2 := arr2->sort() ; 
    if (arr1->size() /= arr2->size()) then (     OclFile["System.out"].println("No") ; 
     return ) else (         var j : int ; j := 0 ; while j < arr1->size() do ( (     if (arr1[j+1] /= arr2[j+1]) then (     OclFile["System.out"].println("No") ; 
     return ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("Yes") ) ;  
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int mod=(int)(1e9+7);
  static int ways(int arr[],int n){
    int dp[]=new int[n+1];
    dp[n-1]=1 ;
    for(int i=n-2 ; i>=0 ; i--){
      dp[i]=0 ;
      for(int j=1 ; ((j+i)<n && j<=arr[i]); j++){
        dp[i]+=dp[i+j];
        dp[i] %=mod ;
      }
    }
    return dp[0] % mod ;
  }
  public static void main(String[] args){
    int arr[]={
      5,3,1,4,3 };
      int n=arr.length ;
      System.out.println(ways(arr,n)% mod);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute mod : int := (1e9 + 7)->oclAsType(int);
  static   operation ways( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
     dp[n - 1+1] := 1 ; 
         var i : int ; i := n - 2 ; while i >= 0 do ( (     dp[i+1] := 0 ; 
         var j : int ; j := 1 ; while ((j + i) < n & j <= arr[i+1]) do ( (     dp[i+1] := dp[i+1]+(dp[i + j+1]) ; 
     dp[i+1] := dp[i+1] mod mod )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
     return dp[0+1] mod mod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,3,1,4,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(ways(arr, n) mod mod) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void lowerWythoff(int n){
    double phi=(1+Math.sqrt(5))/2.0 ;
    for(int i=1 ; i<=n ; i++){
      double ans=Math.floor(i*phi);
      System.out.print((int)ans);
      if(i!=n)System.out.print(",");
    }
  }
  public static void main(String[] args){
    int n=5 ;
    lowerWythoff(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation lowerWythoff( n : int) : void
  pre: true
  post: true
  activity: (     var phi : double ; phi := (1 + (5)->sqrt()) / 2.0 ;
         var i : int ; i := 1 ; while i <= n do ( (     var ans : double ; ans := (i * phi)->floor() ;
     OclFile["System.out"].print(ans->oclAsType(int)) ; 
     if (i /= n) then     OclFile["System.out"].print(",") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute lowerWythoff(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static class TNode {
    int data ;
    TNode left ;
    TNode right ;
  }
  static TNode sortedArrayToBST(int arr[],int start,int end){
    if(start>end)return null ;
    int mid=(start+end)/2 ;
    TNode root=newNode(arr[mid]);
    root.left=sortedArrayToBST(arr,start,mid-1);
    root.right=sortedArrayToBST(arr,mid+1,end);
    return root ;
  }
  static TNode newNode(int data){
    TNode node=new TNode();
    node.data=data ;
    node.left=null ;
    node.right=null ;
    return node ;
  }
  static void printLevelOrder(TNode root){
    if(root==null)return ;
    Queue<TNode>q=new LinkedList<TNode>();
    q.add(root);
    while(q.size()>0){
      TNode node=q.element();
      System.out.print(node.data+" ");
      q.remove();
      if(node.left!=null)q.add(node.left);
      if(node.right!=null)q.add(node.right);
    }
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3,4,5,6,7 };
      int n=arr.length ;
      TNode root=sortedArrayToBST(arr,0,n-1);
      printLevelOrder(root);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution {
  static class TNode {
   attribute data : int;
   attribute left : TNode;
   attribute right : TNode;
}
  static   operation sortedArrayToBST( arr : Sequence(int), start : int, end : int) : TNode
  pre: true
  post: true
  activity: (     if (start > end) then     return null else skip ; 
     var mid : int ; mid := (start + end) / 2 ;
    var root : TNode ; root := newNode(arr[mid+1]) ;
    root.left := sortedArrayToBST(arr, start, mid - 1) ; 
    root.right := sortedArrayToBST(arr, mid + 1, end) ; 
    return root 
 );
  static   operation newNode( data : int) : TNode
  pre: true
  post: true
  activity: (     var node : TNode ; node := TNode.newTNode() ;
     node.data := data ; 
    node.left := null ; 
    node.right := null ; 
    return node 
 );
  static   operation printLevelOrder( root : TNode) : void
  pre: true
  post: true
  activity: (     if (root = null) then     return else skip ; 
     var q : Sequence(TNode) ; q := Sequence{} ;
     q := q->including(root) ; 
     while (q->size() > 0) do (     var node : TNode ; node := q.element() ;
     OclFile["System.out"].print(node.data + " ") ; 
    q := q.remove() ; 
    if (node.left /= null) then     q := q->including(node.left) ; else skip ; 
    if (node.right /= null) then     q := q->including(node.right) ; else skip ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6,7} ;
     var n : int ; n := arr->size() ;
     var root : TNode ; root := sortedArrayToBST(arr, 0, n - 1) ;
     execute printLevelOrder(root) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MaximumNumbers(String s){
    int n=s.length();
    int[] remIndex={
-1,-1,-1 };
      remIndex[0]=0 ;
      int[] res=new int[n+1];
      int r=0 ;
      for(int i=1 ; i<=n ; i++){
        r=(r+s.charAt(i-1)-'0')% 3 ;
        res[i]=res[i-1];
        if(remIndex[r]!=-1)res[i]=Math.max(res[i],res[remIndex[r] ]+1);
        remIndex[r]=i+1 ;
      }
      return res[n];
    }
    public static void main(String[] args){
      String s="12345" ;
      System.out.println(MaximumNumbers(s));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MaximumNumbers( s : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var remIndex : Sequence(int) ; remIndex := Sequence{-1,-1,-1} ;
    remIndex[0+1] := 0 ; 
    var res : Sequence(int) ; res := Integer.subrange(1,n + 1)->collect(0) ;
    var r : int ; r := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     r := (r + s->at(i - 1+1) - ('0')->char2byte()) mod 3 ; 
     res[i+1] := res[i - 1+1] ; 
     if (remIndex[r+1] /= -1) then     res[i+1] := Set{res[i+1], res[remIndex[r+1]+1] + 1}->max() ; else skip ; 
     remIndex[r+1] := i + 1 )  ;     i := i + 1 ) ; 
    return res[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "12345" ;
     OclFile["System.out"].println(MaximumNumbers(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class gfg {
  public static double calculateSum(double n){
    return 2*(Math.pow(n,6)+15*Math.pow(n,4)+15*Math.pow(n,2)+1);
  }
  public static void main(String[] args){
    double n=1.4142 ;
    System.out.println((int)Math.ceil(calculateSum(n)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class gfg {
  static   operation calculateSum( n : double) : double
  pre: true
  post: true
  activity: (     return 2 * (n->pow(6) + 15 * n->pow(4) + 15 * n->pow(2) + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 1.4142 ;
     OclFile["System.out"].println((calculateSum(n))->ceil()->oclAsType(int)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean productSumDivisible(int n,int size){
    int sum=0,product=1 ;
    while(n>0){
      if(size % 2==0){
        product*=n % 10 ;
      }
      else {
        sum+=n % 10 ;
      }
      n=n/10 ;
      size--;
    }
    if(product % sum==0){
      return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    int n=1234 ;
    int len=4 ;
    if(productSumDivisible(n,len)){
      System.out.println("TRUE");
    }
    else {
      System.out.println("FALSE");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation productSumDivisible( n : int, size : int) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
    var product : int ; product := 1 ;
     while (n > 0) do (     if (size mod 2 = 0) then (     product := product*(n mod 10) ) else (     sum := sum+(n mod 10) ) ;  
     n := n / 10 ; 
     size := size - 1 ) ; 
     if (product mod sum = 0) then (     return true ) else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1234 ;
     var len : int ; len := 4 ;
     if (productSumDivisible(n, len)) then (     OclFile["System.out"].println("TRUE") ) else (     OclFile["System.out"].println("FALSE") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int maxLines(int n,int x1[],int y1[],int x2[],int y2[]){
    Set<Double>s=new HashSet<Double>();
    double slope ;
    for(int i=0 ; i<n ; ++i){
      if(x1[i]==x2[i])slope=Integer.MAX_VALUE ;
      else slope=(y2[i]-y1[i])*1.0/(x2[i]-x1[i])*1.0 ;
      s.add(slope);
    }
    return s.size();
  }
  public static void main(String args[]){
    int n=2,x1[]={
      1,2 },y1[]={
        1,2 },x2[]={
          2,4 },y2[]={
            2,10 };
            System.out.print(maxLines(n,x1,y1,x2,y2));
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxLines( n : int, x1 : Sequence(int), y1 : Sequence(int), x2 : Sequence(int), y2 : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var s : Set(double) ; s := Set{} ;
     var slope : double ;
         var i : int ; i := 0 ; while i < n do ( (     if (x1[i+1] = x2[i+1]) then     slope := 2147483647 else     slope := (y2[i+1] - y1[i+1]) * 1.0 / (x2[i+1] - x1[i+1]) * 1.0 ; ;  
     s := s->including(slope) )  ;     i := i + 1 ) ; 
     return s->size() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
    var x1 : Sequence(void) ; x1 := Sequence{1,2} ;
    var y1 : Sequence(void) ; y1 := Sequence{1,2} ;
    var x2 : Sequence(void) ; x2 := Sequence{2,4} ;
    var y2 : Sequence(void) ; y2 := Sequence{2,10} ;
     OclFile["System.out"].print(maxLines(n, x1, y1, x2, y2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countStr(int n,int bCount,int cCount){
    if(bCount<0 || cCount<0)return 0 ;
    if(n==0)return 1 ;
    if(bCount==0 && cCount==0)return 1 ;
    int res=countStr(n-1,bCount,cCount);
    res+=countStr(n-1,bCount-1,cCount);
    res+=countStr(n-1,bCount,cCount-1);
    return res ;
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(countStr(n,1,2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countStr( n : int, bCount : int, cCount : int) : int
  pre: true
  post: true
  activity: (     if (bCount < 0 or cCount < 0) then     return 0 else skip ; 
     if (n = 0) then     return 1 else skip ; 
    if (bCount = 0 & cCount = 0) then     return 1 else skip ; 
    var res : int ; res := countStr(n - 1, bCount, cCount) ;
    res := res+(countStr(n - 1, bCount - 1, cCount)) ; 
    res := res+(countStr(n - 1, bCount, cCount - 1)) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(countStr(n, 1, 2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findTwoThreePrime(int l,int r){
    if(l==1)l++;
    int count=0 ;
    for(int i=l ; i<=r ; i++){
      int num=i ;
      while(num % 2==0)num/=2 ;
      while(num % 3==0)num/=3 ;
      if(num==1)count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int l=1,r=10 ;
    System.out.println(findTwoThreePrime(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findTwoThreePrime( l : int, r : int) : int
  pre: true
  post: true
  activity: (     if (l = 1) then     l := l + 1 ; else skip ; 
     var count : int ; count := 0 ;
         var i : int ; i := l ; while i <= r do ( (     var num : int ; num := i ;
     while (num mod 2 = 0) do     num := num/(2) ; ; 
     while (num mod 3 = 0) do     num := num/(3) ; ; 
     if (num = 1) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 1 ;
    var r : int ; r := 10 ;
     OclFile["System.out"].println(findTwoThreePrime(l, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Checkpoints {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr);
    if(n==1){
      System.out.print(0);
    }
    else {
      int min1=Math.min(Math.abs(a-arr[0]),Math.abs(a-arr[n-2]))+(arr[n-2]-arr[0]);
      int min2=Math.min(Math.abs(arr[n-1]-a),Math.abs(arr[1]-a))+(arr[n-1]-arr[1]);
      System.out.print(Math.min(min1,min2));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Checkpoints {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    if (n = 1) then (     OclFile["System.out"].print(0) ) else (     var min1 : int ; min1 := Set{if a - arr[0+1] < 0 then -(a - arr[0+1]) else a - arr[0+1] endif, if a - arr[n - 2+1] < 0 then -(a - arr[n - 2+1]) else a - arr[n - 2+1] endif}->min() + (arr[n - 2+1] - arr[0+1]) ;
     var min2 : int ; min2 := Set{if arr[n - 1+1] - a < 0 then -(arr[n - 1+1] - a) else arr[n - 1+1] - a endif, if arr[1+1] - a < 0 then -(arr[1+1] - a) else arr[1+1] - a endif}->min() + (arr[n - 1+1] - arr[1+1]) ;
     OclFile["System.out"].print(Set{min1, min2}->min()) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.nextLine();
    String T=sc.nextLine();
    sc.close();
    String[] A={
      "a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z" };
      boolean res=true ;
      for(String s : A){
        int sIdx=S.indexOf(s);
        if(sIdx<0)continue ;
        String t=String.valueOf(T.charAt(sIdx));
        int idx=0 ;
        while(idx<S.length()){
          if(S.indexOf(s,idx)>=0){
            if(S.indexOf(s,idx)!=T.indexOf(t,idx)){
              res=false ;
              break ;
            }
            else {
              idx=S.indexOf(s,idx)+1 ;
            }
          }
          else if(T.indexOf(t,idx)>=0){
            res=false ;
            break ;
          }
          else break ;
        }
        if(! res)break ;
      }
      if(res)System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.nextLine() ;
    var T : String ; T := sc.nextLine() ;
    skip ; 
    var A : Sequence(String) ; A := Sequence{"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"} ;
    var res : boolean ; res := true ;
    for (s : A) do ( (     var sIdx : int ; sIdx := S->indexOf(s)-1 ;
     if (sIdx < 0) then     continue else skip ; 
    var t : String ; t := ((T->at(sIdx+1)) + "") ;
    var idx : int ; idx := 0 ;
    while (idx < S->size()) do (     if (S.subrange(idx+1)->indexOf(s+"") + idx - 1  >= 0) then (     if (S.subrange(idx+1)->indexOf(s+"") + idx - 1  /= T.subrange(idx+1)->indexOf(t+"") + idx - 1 ) then (     res := false ; 
     break ) else (     idx := S.subrange(idx+1)->indexOf(s+"") + idx - 1  + 1 ) ) else     if (T.subrange(idx+1)->indexOf(t+"") + idx - 1  >= 0) then (     res := false ; 
     break ) else     break ;  ) ; 
    if (not(res)) then     break else skip ; 
 )  ) ; 
    if (res) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.Scanner ;
public class DividingOrange {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] desired=new int[k];
    for(int i=0 ; i<k ; i++){
      desired[i]=sc.nextInt();
    }
    ArrayList<Integer>available=new ArrayList<>();
    for(int i=1 ; i<=n*k ; i++){
      available.add(i);
    }
    for(int toRemove : desired){
      available.remove((Object)toRemove);
    }
    for(int child=0 ; child<k ; child++){
      StringBuilder sb=new StringBuilder();
      sb.append(desired[child]);
      for(int i=1 ; i<n ; i++){
        sb.append(" ");
        sb.append(available.get(available.size()-1));
        available.remove(available.size()-1);
      }
      System.out.println(sb.toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DividingOrange {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var desired : Sequence(int) ; desired := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     desired[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var available : Sequence(int) ; available := Sequence{} ;
        var i : int ; i := 1 ; while i <= n * k do ( (     available := available->including(i) )  ;     i := i + 1 ) ; 
    for (toRemove : desired) do ( (     available := available->excludingFirst(toRemove->oclAsType(OclAny)) )  ) ; 
        var child : int ; child := 0 ; while child < k do ( (     var sb : String ; sb := StringLib.newString() ;
     sb := sb + StringLib.newString(desired[child+1]) ; 
         var i : int ; i := 1 ; while i < n do ( (     sb := sb + StringLib.newString(" ") ; 
     sb := sb + StringLib.newString(available->at(available->size() - 1+1)) ; 
     available := available->excludingFirst(available->size() - 1) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sb+"") )  ;     child := child + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.OutputStream ;
import java.io.PrintStream ;
import java.util.*;
public class P244A {
  public static void main(String[] args)throws Exception {
    new P244A().run();
  }
  void run()throws Exception {
    Scanner scanner=new Scanner(getInputStream());
    int n=scanner.nextInt();
    int k=scanner.nextInt();
    List<Integer>reserved=new ArrayList<>();
    for(int i=0 ; i<k ; i++){
      reserved.add(scanner.nextInt());
    }
    Set<Integer>reservedSet=new HashSet<>(reserved);
    int slice=0 ;
    for(int i=0 ; i<k ; i++){
      getOutputStream().print(reserved.get(i)+" ");
      int sliceToAdd=n-1 ;
      while(sliceToAdd>0){
        slice++;
        if(reservedSet.contains(slice)){
          continue ;
        }
        getOutputStream().print(slice+" ");
        sliceToAdd--;
      }
      getOutputStream().println();
    }
  }
  InputStream getInputStream(){
    return System.in ;
  }
  PrintStream getOutputStream(){
    return System.out ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class P244A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     P244A.newP244A().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(getInputStream()) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
    var reserved : Sequence(int) ; reserved := Sequence{} ;
        var i : int ; i := 0 ; while i < k do ( (     reserved := reserved->including(scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var reservedSet : Set(int) ; reservedSet := Set{}->union(reserved) ;
    var slice : int ; slice := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     getOutputStream().print(reserved->at(i+1) + " ") ; 
     var sliceToAdd : int ; sliceToAdd := n - 1 ;
     while (sliceToAdd > 0) do (     slice := slice + 1 ; 
     if (reservedSet->includes(slice)) then (     continue ) else skip ; 
     getOutputStream().print(slice + " ") ; 
     sliceToAdd := sliceToAdd - 1 ) ; 
     getOutputStream().println() )  ;     i := i + 1 ) ; 
 );
   operation getInputStream() : OclFile
  pre: true
  post: true
  activity: (     return OclFile["System.in"] );
   operation getOutputStream() : OclFile
  pre: true
  post: true
  activity: (     return OclFile["System.out"] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cses {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayList<ArrayList<Integer>>ans=new ArrayList<>();
    int n=sc.nextInt();
    int k=sc.nextInt();
    HashSet<Integer>a=new HashSet<>();
    for(int i=1 ; i<=n*k ; i++){
      a.add(i);
    }
    for(int i=0 ; i<k ; i++){
      ans.add(new ArrayList<>());
      int ai=sc.nextInt();
      ans.get(i).add(ai);
      a.remove(ai);
    }
    int temp=n-1 ;
    int j=0 ;
    for(int i : a){
      ans.get(j).add(i);
      temp--;
      if(temp==0){
        temp=n-1 ;
        j++;
      }
    }
    for(int i=0 ; i<k ; i++){
      for(int x : ans.get(i)){
        System.out.print(x+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cses {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ans : Sequence(Sequence(int)) ; ans := Sequence{} ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Set(int) ; a := Set{} ;
        var i : int ; i := 1 ; while i <= n * k do ( (     a := a->including(i) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do ( (     ans := ans->including(Sequence{}) ; 
     var ai : int ; ai := sc.getCurrent()->toInteger() ;
     ans->at(i+1)->excludes(ai) ; 
     a := a->excludingAt(ai+1) )  ;     i := i + 1 ) ; 
    var temp : int ; temp := n - 1 ;
    var j : int ; j := 0 ;
    for (i : a) do ( (     ans->at(j+1)->excludes(i) ; 
     temp := temp - 1 ; 
     if (temp = 0) then (     temp := n - 1 ; 
     j := j + 1 ) else skip )  ) ; 
        var i : int ; i := 0 ; while i < k do ( (     for (x : ans->at(i+1)) do ( (     OclFile["System.out"].print(x + " ") )  ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
public class DividingOrange {
  public void solve(){
    FastScanner in=new FastScanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    ArrayList<Integer>[] ans=new ArrayList[k];
    int[] x=new int[n*k];
    for(int i=0 ; i<n*k ; i++){
      x[i]=i ;
    }
    for(int i=0 ; i<k ; i++){
      int b=in.nextInt()-1 ;
      x[b]=-1 ;
      ans[i]=new ArrayList<>();
      ans[i] .add(b);
    }
    int cnt=0 ;
    for(int i=0 ; i<k ; i++){
      int j=1 ;
      while(j<n){
        if(x[cnt]!=-1){
          ans[i] .add(cnt);
          j++;
        }
        cnt++;
      }
    }
    for(int i=0 ; i<k ; i++){
      for(Integer b : ans[i]){
        System.out.print((b+1)+" ");
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    DividingOrange x=new DividingOrange();
    x.solve();
  }
  private class FastScanner {
    public BufferedReader r ;
    public StringTokenizer st=null ;
    public FastScanner(InputStream stream){
      r=new BufferedReader(new InputStreamReader(stream),32728);
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(r.readLine());
        }
        catch(IOException e){
          throw new RuntimeException();
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public Long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DividingOrange {
   operation solve() : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var n : int ; n := in.nextInt() ;
    var k : int ; k := in.nextInt() ;
    var ans : Sequence(Sequence(int)) ; ans := Integer.subrange(1,k)->collect(null) ;
    var x : Sequence(int) ; x := Integer.subrange(1,n * k)->collect(0) ;
        var i : int ; i := 0 ; while i < n * k do ( (     x[i+1] := i )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do ( (     var b : int ; b := in.nextInt() - 1 ;
     x[b+1] := -1 ; 
     ans[i+1] := Sequence{} ; 
     ans[i+1]->excludes(b) )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     var j : int ; j := 1 ;
     while (j < n) do (     if (x[cnt+1] /= -1) then (     ans[i+1]->excludes(cnt) ; 
     j := j + 1 ) else skip ; 
     cnt := cnt + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do ( (     for (b : ans[i+1]) do ( (     OclFile["System.out"].print((b + 1) + " ") )  ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : DividingOrange ; x := DividingOrange.newDividingOrange() ;
     x.solve() );
 class FastScanner {
   attribute r : OclFile;
   attribute st : OclIterator := null;
   static operation newFastScanner( stream : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32728) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(r.readLine()) )   catch (e : IOException) do (     error ProgramException() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _244A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),k=sc.nextInt();
    int[] arr=new int[k];
    HashMap<Integer,Boolean>m=new HashMap<>();
    for(int i=0 ; i<k ; i++){
      arr[i]=sc.nextInt();
      m.put(arr[i],true);
    }
    int num=1 ;
    for(int i=0 ; i<k ; i++){
      System.out.print(arr[i]+" ");
      for(int j=1 ; j<n ; j++){
        while(m.containsKey(num))num++;
        System.out.print(num+" ");
        num++;
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,k)->collect(0) ;
    var m : Map(int,Boolean) ; m := Map{} ;
        var i : int ; i := 0 ; while i < k do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     m := m->union(Map{arr[i+1] |-> true}) )  ;     i := i + 1 ) ; 
    var num : int ; num := 1 ;
        var i : int ; i := 0 ; while i < k do ( (     OclFile["System.out"].print(arr[i+1] + " ") ; 
         var j : int ; j := 1 ; while j < n do ( (     while (m->keys()->includes(num)) do     num := num + 1 ; ; 
     OclFile["System.out"].print(num + " ") ; 
     num := num + 1 )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}
44A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,k)->collect(0) ;
    var m : Map(int,Boolean) ; m := Map{} ;
        var i : int ; i := 0 ; while i < k do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     m := m->union(Map{arr[i+1] |-> true}) )  ;     i := i + 1 ) ; 
    var num : int ; num := 1 ;
        var i : int ; i := 0 ; while i < k do ( (     OclFile["System.out"].print(arr[i+1] + " ") ; 
         var j : int ; j := 1 ; while j < n do ( (     while (m->keys()->includes(num)) do     num := num + 1 ; ; 
     OclFile["System.out"].print(num + " ") ; 
     num := num + 1 )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test {
  static int cnt=0 ;
  static int[][] a=new int[6][6];
  static long maxe=0 ;
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    for(int i=1 ; i<=5 ; i++){
      for(int j=1 ; j<=5 ; j++){
        a[i][j]=cin.nextInt();
      }
    }
    int start[]={
      1,2,3,4,5 };
      while(cnt<=120){
        permute(start,0);
      }
      System.out.println(maxe);
    }
    static void permute(int a[],int start){
      for(int i=start ; i<a.length ; i++){
        int temp=a[start];
        a[start]=a[i];
        a[i]=temp ;
        permute(a,start+1);
        a[i]=a[start];
        a[start]=temp ;
      }
      if(start==a.length-1){
        cnt++;
        maxe=Math.max(summa(a[0],a[1],a[2],a[3],a[4]),maxe);
      }
    }
    private static long summa(int i,int i1,int i2,int i3,int i4){
      return(a[i][i1]+a[i1][i]+a[i2][i3]+a[i3][i2])+(a[i1][i2]+a[i2][i1]+a[i3][i4]+a[i4][i3])+(a[i2][i3]+a[i3][i2])+(a[i3][i4]+a[i4][i3]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Test {
  static   attribute cnt : int := 0;
  static   attribute a : Sequence(Sequence(int)) := Integer.subrange(1,6)->collect(Integer.subrange(1,6)->collect(0));
  static   attribute maxe : long := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var i : int ; i := 1 ; while i <= 5 do ( (         var j : int ; j := 1 ; while j <= 5 do ( (     a[i+1][j+1] := cin.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var start : Sequence(int) ; start := Sequence{1,2,3,4,5} ;
    while (cnt <= 120) do (     execute permute(start, 0) ) ; 
    OclFile["System.out"].println(maxe) ; 
 );
  static   operation permute( a : Sequence(int), start : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := start ; while i < a->size() do ( (     var temp : int ; temp := a[start+1] ;
     a[start+1] := a[i+1] ; 
    a[i+1] := temp ; 
    execute permute(a, start + 1) ; 
    a[i+1] := a[start+1] ; 
    a[start+1] := temp ; 
 )  ;     i := i + 1 ) ; 
     if (start = a->size() - 1) then (     cnt := cnt + 1 ; 
     maxe := Set{summa(a[0+1], a[1+1], a[2+1], a[3+1], a[4+1]), maxe}->max() ) else skip );
  static   operation summa( i : int, i1 : int, i2 : int, i3 : int, i4 : int) : long
  pre: true
  post: true
  activity: (     return (a[i+1][i1+1] + a[i1+1][i+1] + a[i2+1][i3+1] + a[i3+1][i2+1]) + (a[i1+1][i2+1] + a[i2+1][i1+1] + a[i3+1][i4+1] + a[i4+1][i3+1]) + (a[i2+1][i3+1] + a[i3+1][i2+1]) + (a[i3+1][i4+1] + a[i4+1][i3+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Arrays ;
public class Distracted {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    ArrayList<Integer>task=new ArrayList<Integer>();
    int test=in.nextInt();
    while(test-->0){
      int n=in.nextInt();
      String str=in.next();
      boolean[] isVist=new boolean[26];
      Arrays.fill(isVist,false);
      boolean flag=true ;
      for(int i=0 ; i<str.length(); i++){
        char ch=str.charAt(i);
        if(isVist[ch-'A']){
          if(str.charAt(i-1)!=ch){
            flag=false ;
            break ;
          }
        }
        else {
          isVist[ch-'A']=true ;
        }
      }
      if(flag){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Distracted {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var task : Sequence(int) ; task := Sequence{} ;
     var test : int ; test := in.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var str : String ; str := in.getCurrent() ;
    var isVist : Sequence(boolean) ; isVist := Integer.subrange(1,26)->collect(false) ;
    isVist := isVist->collect(false) ; 
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < str->size() do ( (     var ch : String ; ch := str->at(i+1) ;
     if (isVist[(ch)->char2byte() - ('A')->char2byte()+1]) then (     if (str->at(i - 1+1) /= ch) then (     flag := false ; 
     break ) else skip ) else (     isVist[(ch)->char2byte() - ('A')->char2byte()+1] := true ) )  ;     i := i + 1 ) ; 
    if (flag) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1520A_DoNotBeDistracted {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int days=parseInt(input.nextLine());
      String tasks=input.nextLine();
      boolean correct=true ;
      for(int i=1 ; i<tasks.length(); i++){
        char c=tasks.charAt(i);
        char before=tasks.charAt(i-1);
        if(c!=before && tasks.substring(0,i).contains(String.valueOf(c))){
          correct=false ;
          break ;
        }
      }
      System.out.println(correct ? "Yes" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1520A_DoNotBeDistracted {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var days : int ; days := parseInt(input.nextLine()) ;
     var tasks : String ; tasks := input.nextLine() ;
    var correct : boolean ; correct := true ;
        var i : int ; i := 1 ; while i < tasks->size() do ( (     var c : String ; c := tasks->at(i+1) ;
     var before : String ; before := tasks->at(i - 1+1) ;
     if (c /= before & tasks.subrange(0+1,i)->includes(((c) + ""))) then (     correct := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if correct then "Yes" else "NO" endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class test117 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      in.nextInt();
      char[] a=in.next().toCharArray();
      char[] b=new char[a.length];
      boolean t=true ;
      b[0]=a[0];
      int l=1 ;
      for(int j=1 ; j<a.length ; j++){
        if(a[j]!=a[j-1]){
          b[l++]=a[j];
        }
      }
      Arrays.sort(b);
      for(int j=b.length-2 ; j>=0 && b[j]!='\0' ; j--){
        if(b[j]==b[j+1]){
          t=false ;
          break ;
        }
      }
      if(t){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test117 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     skip ; 
     var a : Sequence(String) ; a := in.getCurrent()->characters() ;
    var b : Sequence(String) ; b := Integer.subrange(1,a->size())->collect(0) ;
    var t : boolean ; t := true ;
    b[0+1] := a[0+1] ; 
    var l : int ; l := 1 ;
        var j : int ; j := 1 ; while j < a->size() do ( (     if (a[j+1] /= a[j - 1+1]) then (      b[l+1] := a[j+1]  ; l := l + 1 ) else skip )  ;     j := j + 1 ) ; 
    b := b->sort() ; 
        var j : int ; j := b->size() - 2 ; while j >= 0 & b[j+1] /= '\0' do ( (     if (b[j+1] = b[j + 1+1]) then (     t := false ; 
     break ) else skip )  ;     j := j - 1 ) ; 
    if (t) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.HashMap ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String input1=scan.next();
    String input2=scan.next();
    char[] before=input1.toCharArray();
    char[] after=input2.toCharArray();
    HashMap<Character,Character>judge=new HashMap<>();
    String answer="Yes" ;
    for(int i=0 ; i<before.length ; i++){
      if(! judge.containsKey(before[i])){
        judge.put(before[i],after[i]);
      }
      else if(judge.get(before[i])!=after[i]){
        answer="No" ;
        break ;
      }
    }
    if(answer.equals("Yes")){
      judge.clear();
      for(int i=0 ; i<after.length ; i++){
        if(! judge.containsKey(after[i])){
          judge.put(after[i],before[i]);
        }
        else if(judge.get(after[i])!=before[i]){
          answer="No" ;
          break ;
        }
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input1 : String ; input1 := scan.getCurrent() ;
    var input2 : String ; input2 := scan.getCurrent() ;
    var before : Sequence(String) ; before := input1->characters() ;
    var after : Sequence(String) ; after := input2->characters() ;
    var judge : Map(String,String) ; judge := Map{} ;
    var answer : String ; answer := "Yes" ;
        var i : int ; i := 0 ; while i < before->size() do ( (     if (not(judge->keys()->includes(before[i+1]))) then (     judge := judge->union(Map{before[i+1] |-> after[i+1]}) ) else     if (judge->at(before[i+1]) /= after[i+1]) then (     answer := "No" ; 
     break ) else skip ; )  ;     i := i + 1 ) ; 
    if (answer = "Yes") then (     judge := judge->intersection(Map{}) ; 
         var i : int ; i := 0 ; while i < after->size() do ( (     if (not(judge->keys()->includes(after[i+1]))) then (     judge := judge->union(Map{after[i+1] |-> before[i+1]}) ) else     if (judge->at(after[i+1]) /= before[i+1]) then (     answer := "No" ; 
     break ) else skip ; )  ;     i := i + 1 ) ) else skip ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A1520 {
  static FastScanner sc=new FastScanner();
  public static void main(String[] args){
    int t=sc.nextInt();
    while(t-->0)solve();
  }
  public static void solve(){
    int n=sc.nextInt();
    String str=sc.next();
    StringBuilder result=new StringBuilder("");
    result.append(str.charAt(0));
    int count=0 ;
    for(int i=1 ; i<n ; i++){
      if(str.charAt(i)!=str.charAt(i-1))result.append(str.charAt(i));
    }
    for(int j=0 ; j<result.length(); j++){
      for(int k=j+1 ; k<result.length(); k++){
        if(result.charAt(j)==result.charAt(k))count++;
      }
    }
    if(count!=0)System.out.println("NO");
    else System.out.println("YES");
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1520 {
  static   attribute sc : FastScanner := FastScanner.newFastScanner();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ;     execute solve() ; ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var str : String ; str := sc.next() ;
    var result : String ; result := StringLib.newString("") ;
    result := result + StringLib.newString(str->at(0+1)) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (str->at(i+1) /= str->at(i - 1+1)) then     result := result + StringLib.newString(str->at(i+1)) ; else skip )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < result->size() do ( (         var k : int ; k := j + 1 ; while k < result->size() do ( (     if (result->at(j+1) = result->at(k+1)) then     count := count + 1 ; else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    if (count /= 0) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=100 ;
  static int check(int i,int sum,int n,int k,int a[],int dp[][]){
    if(sum<=0){
      return 0 ;
    }
    if(i>=n){
      if(sum==k){
        return 1 ;
      }
      return 0 ;
    }
    if(dp[i][sum]!=-1){
      return dp[i][sum];
    }
    dp[i][sum]=check(i+1,sum-2*a[i],n,k,a,dp)| check(i+1,sum,n,k,a,dp);
    dp[i][sum]=check(i+1,sum-(i+1),n,k,a,dp)| dp[i][sum];
    dp[i][sum]=check(i+1,sum+i+1,n,k,a,dp)| dp[i][sum];
    return dp[i][sum];
  }
  static int wrapper(int n,int k,int a[]){
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=a[i];
    }
    int[][] dp=new int[MAX][MAX];
    for(int i=0 ; i<MAX ; i++){
      for(int j=0 ; j<MAX ; j++){
        dp[i][j]=-1 ;
      }
    }
    return check(0,sum,n,k,a,dp);
  }
  public static void main(String[] args){
    int a[]={
      1,2,3,4 };
      int n=4,k=5 ;
      if(wrapper(n,k,a)==1){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100;
  static   operation check( i : int, sum : int, n : int, k : int, a : Sequence(int), dp : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     if (sum <= 0) then (     return 0 ) else skip ; 
     if (i >= n) then (     if (sum = k) then (     return 1 ) else skip ; 
     return 0 ) else skip ; 
    if (dp[i+1][sum+1] /= -1) then (     return dp[i+1][sum+1] ) else skip ; 
    dp[i+1][sum+1] := check(i + 1, sum - 2 * a[i+1], n, k, a, dp) or check(i + 1, sum, n, k, a, dp) ; 
    dp[i+1][sum+1] := check(i + 1, sum - (i + 1), n, k, a, dp) or dp[i+1][sum+1] ; 
    dp[i+1][sum+1] := check(i + 1, sum + i + 1, n, k, a, dp) or dp[i+1][sum+1] ; 
    return dp[i+1][sum+1] 
 );
  static   operation wrapper( n : int, k : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,MAX)->collect(Integer.subrange(1,MAX)->collect(0)) ;
        var i : int ; i := 0 ; while i < MAX do ( (         var j : int ; j := 0 ; while j < MAX do ( (     dp[i+1][j+1] := -1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return check(0, sum, n, k, a, dp) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,4} ;
     var n : int ; n := 4 ;
    var k : int ; k := 5 ;
     if (wrapper(n, k, a) = 1) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int odd=0 ;
    for(int i=0 ; i<3 ; i++){
      odd+=sc.nextInt()% 2 ;
    }
    System.out.println(odd>=2 ? "Hom" : "Tem");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var odd : int ; odd := 0 ;
         var i : int ; i := 0 ; while i < 3 do ( (     odd := odd+(sc.getCurrent()->toInteger() mod 2) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if odd >= 2 then "Hom" else "Tem" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    System.out.println(solve(n,k));
    sc.close();
  }
  static int solve(int n,int k){
    return IntStream.of(2,5,8).map(x->divideToCeil(x*n,k)).sum();
  }
  static int divideToCeil(int x,int y){
    return x/y+(x % y==0 ? 0 : 1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(solve(n, k)) ; 
    skip ; 
 );
  static   operation solve( n : int, k : int) : int
  pre: true
  post: true
  activity: (     return Sequence{2, 5, 8}->collect( _x1 | (lambda x : OclAny in divideToCeil(x * n, k))->apply(_x1) )->sum() );
  static   operation divideToCeil( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return x / y + (if x mod y = 0 then 0 else 1 endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int factorial(int start,int end){
    int res=1 ;
    for(int i=start ; i<=end ; i++)res*=i ;
    return res ;
  }
  static int sumofsquare(int n){
    return factorial(n+1,2*n)/factorial(1,n);
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(sumofsquare(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation factorial( start : int, end : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
         var i : int ; i := start ; while i <= end do (     res := res*(i) ;  ;     i := i + 1 ) ; 
     return res );
  static   operation sumofsquare( n : int) : int
  pre: true
  post: true
  activity: (     return factorial(n + 1, 2 * n) / factorial(1, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(sumofsquare(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Triangle {
  public static int numberOfTriangles(int n){
    int[] answer=new int[n+1];
    answer[0]=1 ;
    for(int i=1 ; i<=n ; i++)answer[i]=answer[i-1]*3+2 ;
    return answer[n];
  }
  public static void main(String[] args){
    int n=2 ;
    System.out.println(numberOfTriangles(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Triangle {
  static   operation numberOfTriangles( n : int) : int
  pre: true
  post: true
  activity: (     var answer : Sequence(int) ; answer := Integer.subrange(1,n + 1)->collect(0) ;
     answer[0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= n do (     answer[i+1] := answer[i - 1+1] * 3 + 2 ;  ;     i := i + 1 ) ; 
     return answer[n+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(numberOfTriangles(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class GFG {
  static String smallestFreq(String S1,String S2){
    HashMap<String,Integer>banned=new HashMap<>();
    for(int i=0 ; i<S2.length(); i++){
      String s="" ;
      while(i<S2.length()&& S2.charAt(i)!=' ')s+=S2.charAt(i++);
      banned.put(s,banned.get(s)==null ? 1 : banned.get(s)+1);
    }
    HashMap<String,Integer>result=new HashMap<>();
    String ans="" ;
    int freq=0 ;
    for(int i=0 ; i<S1.length(); i++){
      String s="" ;
      while(i<S1.length()&& S1.charAt(i)!=' ')s+=S1.charAt(i++);
      if(banned.get(s)==null){
        result.put(s,result.get(s)==null ? 1 : result.get(s)+1);
        if(result.get(s)>freq ||(result.get(s)==freq && s.compareTo(ans)<0)){
          ans=s ;
          freq=result.get(s);
        }
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    String S1="geeks for geeks is best place to learn" ;
    String S2="bad place" ;
    System.out.println(smallestFreq(S1,S2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation smallestFreq( S1 : String, S2 : String) : String
  pre: true
  post: true
  activity: (     var banned : Map(String,int) ; banned := Map{} ;
         var i : int ; i := 0 ; while i < S2->size() do ( (     var s : String ; s := "" ;
     while (i < S2->size() & S2->at(i+1) /= ' ') do     s := s+(S2->at(i+1)) ; ; 
     banned := banned->union(Map{s |-> if banned->at(s) = null then 1 else banned->at(s) + 1 endif}) )  ;     i := i + 1 ) ; 
    var result : Map(String,int) ; result := Map{} ;
    var ans : String ; ans := "" ;
    var freq : int ; freq := 0 ;
        var i : int ; i := 0 ; while i < S1->size() do ( (     var s : String ; s := "" ;
     while (i < S1->size() & S1->at(i+1) /= ' ') do     s := s+(S1->at(i+1)) ; ; 
     if (banned->at(s) = null) then (     result := result->union(Map{s |-> if result->at(s) = null then 1 else result->at(s) + 1 endif}) ; 
     if (result->at(s) > freq or (result->at(s) = freq & s->compareTo(ans) < 0)) then (     ans := s ; 
     freq := result->at(s) ) else skip ) else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S1 : String ; S1 := "geeks for geeks is best place to learn" ;
     var S2 : String ; S2 := "bad place" ;
     OclFile["System.out"].println(smallestFreq(S1, S2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[][] mat=new int[5][5];
    for(int i=0 ; i<5 ; i++){
      for(int j=0 ; j<5 ; j++){
        mat[i][j]=sc.nextInt();
      }
    }
    int[] ans=new int[1];
    int[] fill=new int[5];
    permute(mat,fill,0,ans,new HashSet<>());
    System.out.print(ans[0]);
  }
  public static void permute(int[][] mat,int[] fill,int idx,int[] ans,HashSet<Integer>hs){
    if(idx==5){
      int poss=2*(mat[fill[2] ][fill[3] ]+mat[fill[3] ][fill[2] ])+2*(mat[fill[3] ][fill[4] ]+mat[fill[4] ][fill[3] ])+(mat[fill[0] ][fill[1] ]+mat[fill[1] ][fill[0] ])+(mat[fill[1] ][fill[2] ]+mat[fill[2] ][fill[1] ]);
      ans[0]=Math.max(ans[0],poss);
      return ;
    }
    for(int i=0 ; i<5 ; i++){
      if(! hs.contains(i)){
        hs.add(i);
        fill[idx]=i ;
        permute(mat,fill,idx+1,ans,hs);
        hs.remove(i);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var mat : Sequence(Sequence(int)) ; mat := Integer.subrange(1,5)->collect(Integer.subrange(1,5)->collect(0)) ;
        var i : int ; i := 0 ; while i < 5 do ( (         var j : int ; j := 0 ; while j < 5 do ( (     mat[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,1)->collect(0) ;
    var fill : Sequence(int) ; fill := Integer.subrange(1,5)->collect(0) ;
    execute permute(mat, fill, 0, ans, Set{}) ; 
    OclFile["System.out"].print(ans[0+1]) ; 
 );
  static   operation permute( mat : Sequence(Sequence(int)), fill : Sequence(int), idx : int, ans : Sequence(int), hs : Set(int)) : void
  pre: true
  post: true
  activity: (     if (idx = 5) then (     var poss : int ; poss := 2 * (mat[fill[2+1]+1][fill[3+1]+1] + mat[fill[3+1]+1][fill[2+1]+1]) + 2 * (mat[fill[3+1]+1][fill[4+1]+1] + mat[fill[4+1]+1][fill[3+1]+1]) + (mat[fill[0+1]+1][fill[1+1]+1] + mat[fill[1+1]+1][fill[0+1]+1]) + (mat[fill[1+1]+1][fill[2+1]+1] + mat[fill[2+1]+1][fill[1+1]+1]) ;
     ans[0+1] := Set{ans[0+1], poss}->max() ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < 5 do ( (     if (not(hs->includes(i))) then (     hs->excludes(i) ; 
     fill[idx+1] := i ; 
     execute permute(mat, fill, idx + 1, ans, hs) ; 
     hs := hs->excludingAt(i+1) ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round1b ;
import java.io.BufferedOutputStream ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Kattio extends PrintWriter {
  public Kattio(InputStream i){
    super(new BufferedOutputStream(System.out));
    r=new BufferedReader(new InputStreamReader(i));
  }
  public Kattio(InputStream i,OutputStream o){
    super(new BufferedOutputStream(o));
    r=new BufferedReader(new InputStreamReader(i));
  }
  public boolean hasMoreTokens(){
    return peekToken()!=null ;
  }
  public int getInt(){
    return Integer.parseInt(nextToken());
  }
  public double getDouble(){
    return Double.parseDouble(nextToken());
  }
  public long getLong(){
    return Long.parseLong(nextToken());
  }
  public String getWord(){
    return nextToken();
  }
  private BufferedReader r ;
  private String line ;
  private StringTokenizer st ;
  private String token ;
  private String peekToken(){
    if(token==null)try {
      while(st==null || ! st.hasMoreTokens()){
        line=r.readLine();
        if(line==null)return null ;
        st=new StringTokenizer(line);
      }
      token=st.nextToken();
    }
    catch(IOException e){
    }
    return token ;
  }
  private String nextToken(){
    String ans=peekToken();
    token=null ;
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Kattio extends OclFile {
   static operation newKattio( i : OclFile) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(i);
    return self );
  operation initialise( i : OclFile) : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(i)) );
   static operation newKattio( i : OclFile, o : OclFile) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(i, o);
    return self );
  operation initialise( i : OclFile, o : OclFile) : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Write(o)) ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(i)) );
   operation hasMoreTokens() : boolean
  pre: true
  post: true
  activity: (     return peekToken() /= null );
   operation getInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation getDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
   operation getLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation getWord() : String
  pre: true
  post: true
  activity: (     return nextToken() );
   attribute r : OclFile;
   attribute line : String;
   attribute st : OclIterator;
   attribute token : String;
   operation peekToken() : String
  pre: true
  post: true
  activity: (     if (token = null) then     try (     while (st = null or not(st.hasNext())) do (     line := r.readLine() ; 
     if (line = null) then     return null else skip ; 
     st := OclIterator.newOclIterator_String(line) ) ; 
     token := st.next() )   catch (e : IOException) do skip
 else skip ; 
     return token );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     var ans : String ; ans := peekToken() ;
     token := null ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round1B ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.Locale ;
import java.util.Scanner ;
import round1B.PushRelabelNodeEdge.Node ;
public class ProblemC {
  public static void solve(Scanner sc){
    int n=sc.nextInt();
    HashMap<String,Node>map1=new HashMap<>();
    HashMap<String,Node>map2=new HashMap<>();
    Node start=new Node("start");
    Node end=new Node("end");
    for(int i=0 ; i<n ; i++){
      String firstWord=sc.next();
      String secondWord=sc.next();
      if(! map1.containsKey(firstWord)){
        Node node=new Node(firstWord);
        map1.put(firstWord,node);
        PushRelabelNodeEdge.addDirectedEdge(start,node,1);
      }
      if(! map2.containsKey(secondWord)){
        Node node=new Node(secondWord);
        map2.put(secondWord,node);
        PushRelabelNodeEdge.addDirectedEdge(node,end,1);
      }
      PushRelabelNodeEdge.addDirectedEdge(map1.get(firstWord),map2.get(secondWord),1);
    }
    ArrayList<Node>nodes=new ArrayList<>();
    nodes.add(start);
    nodes.add(end);
    nodes.addAll(map1.values());
    nodes.addAll(map2.values());
    int flow=PushRelabelNodeEdge.getMaxFlow(nodes,start,end);
    int greedy=nodes.size()-2-2*flow ;
    System.out.println(n-flow-greedy);
  }
  public static void main(String[] args)throws FileNotFoundException {
    Scanner sc=new Scanner(new File("C-large.in"));
    sc.useLocale(Locale.US);
    int cases=sc.nextInt();
    for(int i=1 ; i<=cases ; i++){
      System.out.format(Locale.US,"Case #%d: ",i);
      solve(sc);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemC {
  static   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var map1 : Map(String,Node) ; map1 := Map{} ;
    var map2 : Map(String,Node) ; map2 := Map{} ;
    var start : Node ; start := Node.newNode("start") ;
    var end : Node ; end := Node.newNode("end") ;
        var i : int ; i := 0 ; while i < n do ( (     var firstWord : String ; firstWord := sc.next() ;
     var secondWord : String ; secondWord := sc.next() ;
    if (not(map1->keys()->includes(firstWord))) then (     var node : Node ; node := Node.newNode(firstWord) ;
     map1 := map1->union(Map{firstWord |-> node}) ; 
     PushRelabelNodeEdge.addDirectedEdge(start, node, 1) ) else skip ; 
    if (not(map2->keys()->includes(secondWord))) then (     var node : Node ; node := Node.newNode(secondWord) ;
     map2 := map2->union(Map{secondWord |-> node}) ; 
     PushRelabelNodeEdge.addDirectedEdge(node, end, 1) ) else skip ; 
    PushRelabelNodeEdge.addDirectedEdge(map1->at(firstWord), map2->at(secondWord), 1) ; 
 )  ;     i := i + 1 ) ; 
    var nodes : Sequence(Node) ; nodes := Sequence{} ;
    nodes := nodes->including(start) ; 
    nodes := nodes->including(end) ; 
    nodes := nodes->union(map1->values()) ; 
    nodes := nodes->union(map2->values()) ; 
    var flow : int ; flow := PushRelabelNodeEdge.getMaxFlow(nodes, start, end) ;
    var greedy : int ; greedy := nodes->size() - 2 - 2 * flow ;
    OclFile["System.out"].println(n - flow - greedy) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile("C-large.in")) ;
     skip ; 
    var cases : int ; cases := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= cases do ( (     OclFile["System.out"].format(Locale.US, "Case #%d: ", i) ; 
     execute solve(sc) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String t=sc.next();
    String ans=helper(s,t);
    System.out.println(ans);
  }
  static String helper(String s,String t){
    ArrayList<Integer>[] S=new ArrayList[26];
    ArrayList<Integer>[] T=new ArrayList[26];
    for(int i=0 ; i<26 ; i++){
      S[i]=new ArrayList<>();
      T[i]=new ArrayList<>();
    }
    for(int i=0 ; i<s.length(); i++){
      S[s.charAt(i)-'a'] .add(i);
      T[t.charAt(i)-'a'] .add(i);
    }
    boolean[] used=new boolean[26];
    HashSet<Integer>check=new HashSet<>();
    for(int i=0 ; i<26 ; i++){
      for(int j=0 ; j<26 ; j++){
        if(used[j])continue ;
        if(solve(S[i],T[j])){
          check.add(i);
          used[j]=true ;
          break ;
        }
      }
    }
    if(check.size()==26)return "Yes" ;
    else return "No" ;
  }
  static boolean solve(ArrayList<Integer>a,ArrayList<Integer>b){
    if(a.size()!=b.size())return false ;
    for(int i=0 ; i<a.size(); i++){
      if((int)a.get(i)!=(int)b.get(i))return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var ans : String ; ans := helper(s, t) ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation helper( s : String, t : String) : String
  pre: true
  post: true
  activity: (     var S : Sequence(Sequence(int)) ; S := Integer.subrange(1,26)->collect(null) ;
     var T : Sequence(Sequence(int)) ; T := Integer.subrange(1,26)->collect(null) ;
        var i : int ; i := 0 ; while i < 26 do ( (     S[i+1] := Sequence{} ; 
     T[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     S[s->at(i+1) - ('a')->char2byte()+1]->excludes(i) ; 
     T[t->at(i+1) - ('a')->char2byte()+1]->excludes(i) )  ;     i := i + 1 ) ; 
    var used : Sequence(boolean) ; used := Integer.subrange(1,26)->collect(false) ;
    var check : Set(int) ; check := Set{} ;
        var i : int ; i := 0 ; while i < 26 do ( (         var j : int ; j := 0 ; while j < 26 do ( (     if (used[j+1]) then     continue else skip ; 
     if (solve(S[i+1], T[j+1])) then (     check := check->including(i) ; 
     used[j+1] := true ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (check->size() = 26) then     return "Yes" else     return "No" ;  
 );
  static   operation solve( a : Sequence(int), b : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     if (a->size() /= b->size()) then     return false else skip ; 
         var i : int ; i := 0 ; while i < a->size() do ( (     if (a->at(i+1)->oclAsType(int) /= b->at(i+1)->oclAsType(int)) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void minimumFlip(String s,int x,int y){
    s=s+s ;
    boolean isOpposite=false ;
    if(x>y){
      swap(x,y);
      isOpposite=true ;
    }
    int valClockwise=0 ;
    char cur=s.charAt(x);
    for(int i=x ; i<=y ; i++){
      if(s.charAt(i)!=cur){
        cur=s.charAt(i);
        valClockwise++;
      }
    }
    int valAnticlockwise=0 ;
    cur=s.charAt(y);
    x+=s.length();
    for(int i=y ; i<x ; i++){
      if(s.charAt(i)!=cur){
        cur=s.charAt(i);
        valAnticlockwise++;
      }
    }
    if(valClockwise<=valAnticlockwise){
      if(! isOpposite){
        System.out.println("Clockwise "+valClockwise);
      }
      else {
        System.out.println("Anti-clockwise "+valAnticlockwise);
      }
    }
    else if(! isOpposite){
      System.out.println("Anti-clockwise "+valAnticlockwise);
    }
    else {
      System.out.println("Clockwise "+valClockwise);
    }
  }
  static void swap(int a,int b){
    int c=a ;
    a=b ;
    b=c ;
  }
  public static void main(String[] args){
    int x=0,y=8 ;
    String s="000110" ;
    minimumFlip(s,x,y);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minimumFlip( s : String, x : int, y : int) : void
  pre: true
  post: true
  activity: (     s := s + s ; 
     var isOpposite : boolean ; isOpposite := false ;
    if (x > y) then (     execute swap(x, y) ; 
     isOpposite := true ) else skip ; 
    var valClockwise : int ; valClockwise := 0 ;
    var cur : String ; cur := s->at(x+1) ;
        var i : int ; i := x ; while i <= y do ( (     if (s->at(i+1) /= cur) then (     cur := s->at(i+1) ; 
     valClockwise := valClockwise + 1 ) else skip )  ;     i := i + 1 ) ; 
    var valAnticlockwise : int ; valAnticlockwise := 0 ;
    cur := s->at(y+1) ; 
    x := x+(s->size()) ; 
        var i : int ; i := y ; while i < x do ( (     if (s->at(i+1) /= cur) then (     cur := s->at(i+1) ; 
     valAnticlockwise := valAnticlockwise + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (valClockwise <= valAnticlockwise) then (     if (not(isOpposite)) then (     OclFile["System.out"].println("Clockwise " + valClockwise) ) else (     OclFile["System.out"].println("Anti-clockwise " + valAnticlockwise) ) ) else     if (not(isOpposite)) then (     OclFile["System.out"].println("Anti-clockwise " + valAnticlockwise) ) else (     OclFile["System.out"].println("Clockwise " + valClockwise) ) ;  ;  
 );
  static   operation swap( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var c : int ; c := a ;
     a := b ; 
     b := c );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 0 ;
    var y : int ; y := 8 ;
     var s : String ; s := "000110" ;
     execute minimumFlip(s, x, y) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class FindDuplicate {
  void printRepeating(int arr[],int size){
    int i ;
    System.out.println("The repeating elements are : ");
    for(i=0 ; i<size ; i++){
      if(arr[Math.abs(arr[i])]>=0)arr[Math.abs(arr[i])]=-arr[Math.abs(arr[i])];
      else System.out.print(Math.abs(arr[i])+" ");
    }
  }
  public static void main(String[] args){
    FindDuplicate duplicate=new FindDuplicate();
    int arr[]={
      1,2,3,1,3,6,6 };
      int arr_size=arr.length ;
      duplicate.printRepeating(arr,arr_size);
    }
  }

------------------------------------------------------------
OCL File:
---------
class FindDuplicate {
   operation printRepeating( arr : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
     OclFile["System.out"].println("The repeating elements are : ") ; 
         i := 0 ; while i < size do ( (     if (arr[if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif+1] >= 0) then     arr[if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif+1] := -arr[if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif+1] ; else     OclFile["System.out"].print(if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif + " ") ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var duplicate : FindDuplicate ; duplicate := FindDuplicate.newFindDuplicate() ;
     var arr : Sequence(int) ; arr := Sequence{1,2,3,1,3,6,6} ;
     var arr_size : int ; arr_size := arr->size() ;
     duplicate.printRepeating(arr, arr_size) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class RepeatElement {
  void printRepeating(int arr[],int size){
    int i ;
    System.out.println("The repeating elements are : ");
    for(i=0 ; i<size ; i++){
      if(arr[Math.abs(arr[i])]>0)arr[Math.abs(arr[i])]=-arr[Math.abs(arr[i])];
      else System.out.print(Math.abs(arr[i])+" ");
    }
  }
  public static void main(String[] args){
    RepeatElement repeat=new RepeatElement();
    int arr[]={
      4,2,4,5,2,3,1 };
      int arr_size=arr.length ;
      repeat.printRepeating(arr,arr_size);
    }
  }

------------------------------------------------------------
OCL File:
---------
class RepeatElement {
   operation printRepeating( arr : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
     OclFile["System.out"].println("The repeating elements are : ") ; 
         i := 0 ; while i < size do ( (     if (arr[if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif+1] > 0) then     arr[if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif+1] := -arr[if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif+1] ; else     OclFile["System.out"].print(if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif + " ") ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var repeat : RepeatElement ; repeat := RepeatElement.newRepeatElement() ;
     var arr : Sequence(int) ; arr := Sequence{4,2,4,5,2,3,1} ;
     var arr_size : int ; arr_size := arr->size() ;
     repeat.printRepeating(arr, arr_size) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class PracticeProblem {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static FastReader in=new FastReader();
  public static PrintWriter out=new PrintWriter(System.out);
  public static final int MOD=(int)1e9+7 ;
  public static void main(String[] args){
    solve();
    out.close();
  }
  private static void solve(){
    int k=in.nextInt(),b=in.nextInt(),n=in.nextInt(),t=in.nextInt();
    long cur=1 ;
    for(int i=0 ; i<n ; i++){
      cur=k*cur+b ;
      if(cur>t){
        out.println(n-i);
        return ;
      }
    }
    out.println(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class PracticeProblem {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   attribute in : FastReader := FastReader.newFastReader();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static    attribute MOD : int := 1e9->oclAsType(int) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() ; 
     skip );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var k : int ; k := in.nextInt() ;
    var b : int ; b := in.nextInt() ;
    var n : int ; n := in.nextInt() ;
    var t : int ; t := in.nextInt() ;
     var cur : long ; cur := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     cur := k * cur + b ; 
     if (cur > t) then (     skip ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args)throws Exception {
    FastReader sc=new FastReader();
    PrintWriter out=new PrintWriter(System.out);
    int t=1 ;
    while(t-->0){
      long k=sc.nextInt();
      long b=sc.nextInt();
      long n=sc.nextInt();
      long x=sc.nextInt();
      long z=1 ;
      while(k*z+b<=x){
        z=z*k+b ;
        n--;
      }
      if(n<0)n=0 ;
      out.write(n+"");
    }
    out.close();
  }
  private static long pow(long i,long x){
    long ans=1 ;
    while(x>0){
      if(x % 2==0){
        i=(i*i);
        x=x/2 ;
      }
      else {
        ans=(ans*i);
        x--;
      }
    }
    return ans ;
  }
}
class pair implements Comparable<pair>{
  int a ;
  int b ;
  pair(int a,int b){
    this.a=a ;
    this.b=b ;
  }
  @ Override public int compareTo(pair p){
    return this.b-p.b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := 1 ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var k : long ; k := sc.nextInt() ;
     var b : long ; b := sc.nextInt() ;
    var n : long ; n := sc.nextInt() ;
    var x : long ; x := sc.nextInt() ;
    var z : long ; z := 1 ;
    while (k * z + b <= x) do (     z := z * k + b ; 
     n := n - 1 ) ; 
    if (n < 0) then     n := 0 ; else skip ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static   operation pow( i : long, x : long) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
     while (x > 0) do (     if (x mod 2 = 0) then (     i := (i * i) ; 
     x := x / 2 ) else (     ans := (ans * i) ; 
     x := x - 1 ) ) ; 
     return ans );
}
class pair implements Comparable<pair> {
   attribute a : int;
   attribute b : int;
   static operation newpair( a : int, b : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
      operation compareTo( p : pair) : int
  pre: true
  post: true
  activity: (     return self.b - p.b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int arrSize=51 ;
  static int dp[]=new int[arrSize];
  static boolean v[]=new boolean[arrSize];
  static int sumMax(int i,int arr[],int n){
    if(i>=n-1)return 0 ;
    if(v[i])return dp[i];
    v[i]=true ;
    dp[i]=Math.max(arr[i]+arr[i+1]+sumMax(i+3,arr,n),sumMax(i+1,arr,n));
    return dp[i];
  }
  public static void main(String[] args){
    int arr[]={
      1,1,1,1 };
      int n=arr.length ;
      System.out.println(sumMax(0,arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute arrSize : int := 51;
  static   attribute dp : int := Integer.subrange(1,arrSize)->collect(0);
  static   attribute v : boolean := Integer.subrange(1,arrSize)->collect(false);
  static   operation sumMax( i : int, arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (i >= n - 1) then     return 0 else skip ; 
     if (v[i+1]) then     return dp[i+1] else skip ; 
    v[i+1] := true ; 
    dp[i+1] := Set{arr[i+1] + arr[i + 1+1] + sumMax(i + 3, arr, n), sumMax(i + 1, arr, n)}->max() ; 
    return dp[i+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,1,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(sumMax(0, arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class node {
    int data ;
    node left ;
    node right ;
  };
  static node newNode(int data){
    node temp=new node();
    temp.data=data ;
    temp.left=null ;
    temp.right=null ;
    return temp ;
  };
  static int sumOfNodesAtNthLevel(node root,int k){
    if(root==null)return 0 ;
    Queue<node>que=new LinkedList<>();
    que.add(root);
    int level=0 ;
    int sum=0 ;
    int flag=0 ;
    while(! que.isEmpty()){
      int size=que.size();
      while(size-->0){
        node ptr=que.peek();
        que.remove();
        if(level==k){
          flag=1 ;
          sum+=ptr.data ;
        }
        else {
          if(ptr.left!=null)que.add(ptr.left);
          if(ptr.right!=null)que.add(ptr.right);
        }
      }
      level++;
      if(flag==1)break ;
    }
    return sum ;
  }
  public static void main(String[] args){
    node root=new node();
    root=newNode(50);
    root.left=newNode(30);
    root.right=newNode(70);
    root.left.left=newNode(20);
    root.left.right=newNode(40);
    root.right.left=newNode(60);
    int level=2 ;
    int result=sumOfNodesAtNthLevel(root,level);
    System.out.print(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class node {
   attribute data : int;
   attribute left : node;
   attribute right : node;
}
  static   operation newNode( data : int) : node
  pre: true
  post: true
  activity: (     var temp : node ; temp := node.newnode() ;
     temp.data := data ; 
    temp.left := null ; 
    temp.right := null ; 
    return temp 
 );
  static   operation sumOfNodesAtNthLevel( root : node, k : int) : int
  pre: true
  post: true
  activity: (     if (root = null) then     return 0 else skip ; 
     var que : Sequence(node) ; que := Sequence{} ;
    que := que->including(root) ; 
    var level : int ; level := 0 ;
    var sum : int ; sum := 0 ;
    var flag : int ; flag := 0 ;
    while (not(que->isEmpty())) do (     var size : int ; size := que->size() ;
         while (size > 0) do (        size := size - 1 ;     skip ; (     var ptr : node ; ptr := que->min() ;
     que := que.remove() ; 
     if (level = k) then (     flag := 1 ; 
     sum := sum+(ptr.data) ) else (     if (ptr.left /= null) then     que := que->including(ptr.left) ; else skip ; 
     if (ptr.right /= null) then     que := que->including(ptr.right) ; else skip ) ) ;  ) ;  
     level := level + 1 ; 
     if (flag = 1) then     break else skip ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var root : node ; root := node.newnode() ;
     root := newNode(50) ; 
    root.left := newNode(30) ; 
    root.right := newNode(70) ; 
    root.left.left := newNode(20) ; 
    root.left.right := newNode(40) ; 
    root.right.left := newNode(60) ; 
    var level : int ; level := 2 ;
    var result : int ; result := sumOfNodesAtNthLevel(root, level) ;
    OclFile["System.out"].print(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class EndlessKnight {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int numCases=in.nextInt();
    for(int i=0 ; i<numCases ; i++)doCase(i+1,in);
  }
  private static void doCase(int caseNum,Scanner in){
    int H=in.nextInt();
    int W=in.nextInt();
    int R=in.nextInt();
    int[][] memoized=new int[W][H];
    for(int[] arr : memoized)for(int i=0 ; i<arr.length ; i++)arr[i]=-1 ;
    for(int i=0 ; i<R ; i++){
      int rockY=in.nextInt();
      int rockX=in.nextInt();
      memoized[W-rockX][H-rockY]=0 ;
    }
    int total=findMoves(W-1,H-1,memoized);
    System.out.println("Case #"+caseNum+": "+total);
  }
  private static int findMoves(int i,int j,int[][] memoized){
    if(i==0 && j==0)return 1 ;
    if(i<1 || j<1)return 0 ;
    if(memoized[i][j]!=-1)return memoized[i][j];
    memoized[i][j]=(findMoves(i-1,j-2,memoized)+findMoves(i-2,j-1,memoized))% 10007 ;
    return memoized[i][j];
  }
}
------------------------------------------------------------
OCL File:
---------
 class EndlessKnight {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numCases : int ; numCases := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < numCases do (     execute doCase(i + 1, in) ;  ;     i := i + 1 ) );
  static   operation doCase( caseNum : int, in : OclFile) : void
  pre: true
  post: true
  activity: (     var H : int ; H := in.getCurrent()->toInteger() ;
     var W : int ; W := in.getCurrent()->toInteger() ;
    var R : int ; R := in.getCurrent()->toInteger() ;
    var memoized : Sequence(Sequence(int)) ; memoized := Integer.subrange(1,W)->collect(Integer.subrange(1,H)->collect(0)) ;
    for (arr : memoized) do (         var i : int ; i := 0 ; while i < arr->size() do (     arr[i+1] := -1 ;  ;     i := i + 1 ) ;  ) ; 
        var i : int ; i := 0 ; while i < R do ( (     var rockY : int ; rockY := in.getCurrent()->toInteger() ;
     var rockX : int ; rockX := in.getCurrent()->toInteger() ;
     memoized[W - rockX+1][H - rockY+1] := 0 )  ;     i := i + 1 ) ; 
    var total : int ; total := findMoves(W - 1, H - 1, memoized) ;
    OclFile["System.out"].println("Case #" + caseNum + ": " + total) ; 
 );
  static   operation findMoves( i : int, j : int, memoized : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     if (i = 0 & j = 0) then     return 1 else skip ; 
     if (i < 1 or j < 1) then     return 0 else skip ; 
    if (memoized[i+1][j+1] /= -1) then     return memoized[i+1][j+1] else skip ; 
    memoized[i+1][j+1] := (findMoves(i - 1, j - 2, memoized) + findMoves(i - 2, j - 1, memoized)) mod 10007 ; 
    return memoized[i+1][j+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void min_visible_bottles(int[] arr,int n){
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(mp.containsKey(arr[i])){
        mp.put(arr[i],mp.get(arr[i])+1);
      }
      else {
        mp.put(arr[i],1);
      }
      ans=Math.max(ans,mp.get(arr[i]));
    }
    System.out.print("Minimum number of "+"Visible Bottles are: "+ans+"\n");
  }
  public static void main(String[] args){
    int n=8 ;
    int arr[]={
      1,1,2,3,4,5,5,4 };
      min_visible_bottles(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation min_visible_bottles( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (mp->keys()->includes(arr[i+1])) then (     mp := mp->union(Map{arr[i+1] |-> mp->at(arr[i+1]) + 1}) ) else (     mp := mp->union(Map{arr[i+1] |-> 1}) ) ;  
     ans := Set{ans, mp->at(arr[i+1])}->max() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("Minimum number of " + "Visible Bottles are: " + ans + "\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     var arr : Sequence(int) ; arr := Sequence{1,1,2,3,4,5,5,4} ;
     execute min_visible_bottles(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static long getSum(int n,int d){
    long sum=0 ;
    for(int i=1 ; i<=n ; i++){
      if(i % 10==d)sum+=i ;
    }
    return sum ;
  }
  public static void main(String args[]){
    int n=30,d=3 ;
    System.out.println(getSum(n,d));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation getSum( n : int, d : int) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     if (i mod 10 = d) then     sum := sum+(i) ; else skip )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 30 ;
    var d : int ; d := 3 ;
     OclFile["System.out"].println(getSum(n, d)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int findSubstrings(String s,int k){
    int ans=0 ;
    int cnt[]=new int[26];
    int i,j,n=s.length();
    for(i=0 ; i<n ; i++){
      Arrays.fill(cnt,0);
      for(j=i ; j<n ; j++){
        cnt[s.charAt(j)-'a']++;
        if(cnt[s.charAt(j)-'a']<=k){
          ans++;
        }
        else {
          break ;
        }
      }
    }
    return ans ;
  }
  static public void main(String[] args){
    String S="aaabb" ;
    int k=2 ;
    System.out.println(findSubstrings(S,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSubstrings( s : String, k : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var cnt : Sequence(int) ; cnt := Integer.subrange(1,26)->collect(0) ;
    var i : int ;
    var j : int ;
    var n : int ; n := s->size() ;
        i := 0 ; while i < n do ( (     cnt := cnt->collect(0) ; 
         j := i ; while j < n do ( (     cnt[s->at(j+1) - ('a')->char2byte()+1] := cnt[s->at(j+1) - ('a')->char2byte()+1] + 1 ; 
     if (cnt[s->at(j+1) - ('a')->char2byte()+1] <= k) then (     ans := ans + 1 ) else (     break ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := "aaabb" ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(findSubstrings(S, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int ___gcd(int a,int b){
    if(a==0 || b==0)return 0 ;
    if(a==b)return a ;
    if(a>b)return ___gcd(a-b,b);
    return ___gcd(a,b-a);
  }
  static int lcmOfArray(int arr[],int n){
    int ans=arr[0];
    for(int i=1 ; i<n ; i++)ans=(arr[i]*ans)/___gcd(arr[i],ans);
    return ans ;
  }
  static boolean checkArray(int arr[],int prime[],int n,int m){
    int lcm=lcmOfArray(arr,n);
    for(int i=0 ; i<n ; i++){
      int val=lcm/arr[i];
      for(int j=0 ; j<m && val!=1 ; j++)while(val % prime[j]==0)val=val/prime[j];
      if(val!=1)return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    int arr[]={
      50,200 };
      int prime[]={
        2,3 };
        int n=arr.length ;
        int m=prime.length ;
        if(checkArray(arr,prime,n,m))System.out.print("Yes");
        else System.out.print("No");
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation ___gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0 or b = 0) then     return 0 else skip ; 
     if (a = b) then     return a else skip ; 
     if (a > b) then     return ___gcd(a - b, b) else skip ; 
     return ___gcd(a, b - a) );
  static   operation lcmOfArray( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do (     ans := (arr[i+1] * ans) / ___gcd(arr[i+1], ans) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation checkArray( arr : Sequence(int), prime : Sequence(int), n : int, m : int) : boolean
  pre: true
  post: true
  activity: (     var lcm : int ; lcm := lcmOfArray(arr, n) ;
         var i : int ; i := 0 ; while i < n do ( (     var val : int ; val := lcm / arr[i+1] ;
         var j : int ; j := 0 ; while j < m & val /= 1 do (     while (val mod prime[j+1] = 0) do     val := val / prime[j+1] ; ;  ;     j := j + 1 ) ; 
     if (val /= 1) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{50,200} ;
     var prime : Sequence(int) ; prime := Sequence{2,3} ;
    var n : int ; n := arr->size() ;
    var m : int ; m := prime->size() ;
    if (checkArray(arr, prime, n, m)) then     OclFile["System.out"].print("Yes") else     OclFile["System.out"].print("No") ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAX=1000000 ;
  static boolean[] prime=new boolean[MAX+1];
  static int[] sum=new int[MAX+1];
  static void SieveOfEratosthenes(){
    for(int i=0 ; i<=MAX ; i++)prime[i]=true ;
    for(int i=0 ; i<=MAX ; i++)sum[i]=0 ;
    prime[1]=false ;
    for(int p=2 ; p*p<=MAX ; p++){
      if(prime[p]){
        for(int i=p*2 ; i<=MAX ; i+=p)prime[i]=false ;
      }
    }
    for(int i=1 ; i<=MAX ; i++){
      if(prime[i]==true)sum[i]=1 ;
      sum[i]+=sum[i-1];
    }
  }
  public static void main(String[] args){
    SieveOfEratosthenes();
    int l=3,r=9 ;
    int c=(sum[r]-sum[l-1]);
    System.out.println("Count: "+c);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 1000000;
  static   attribute prime : Sequence(boolean) := Integer.subrange(1,MAX + 1)->collect(false);
  static   attribute sum : Sequence(int) := Integer.subrange(1,MAX + 1)->collect(0);
  static   operation SieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= MAX do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i <= MAX do (     sum[i+1] := 0 ;  ;     i := i + 1 ) ; 
    prime[1+1] := false ; 
        var p : int ; p := 2 ; while p * p <= MAX do ( (     if (prime[p+1]) then (         var i : int ; i := p * 2 ; while i <= MAX do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
        var i : int ; i := 1 ; while i <= MAX do ( (     if (prime[i+1] = true) then     sum[i+1] := 1 ; else skip ; 
     sum[i+1] := sum[i+1]+(sum[i - 1+1]) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes() ; 
     var l : int ; l := 3 ;
    var r : int ; r := 9 ;
     var c : int ; c := (sum[r+1] - sum[l - 1+1]) ;
     OclFile["System.out"].println("Count: " + c) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class policeRecure {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int number=in.nextInt();
    int police=0 ;
    int uncheck=0 ;
    while(number-->0){
      int event=in.nextInt();
      if(event>0){
        police+=event ;
      }
      else {
        if(police>0){
          police--;
        }
        else {
          uncheck++;
        }
      }
    }
    System.out.println(uncheck);
  }
}
------------------------------------------------------------
OCL File:
---------
 class policeRecure {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := in.getCurrent()->toInteger() ;
    var police : int ; police := 0 ;
    var uncheck : int ; uncheck := 0 ;
        while (number > 0) do (        number := number - 1 ;     skip ; (     var event : int ; event := in.getCurrent()->toInteger() ;
     if (event > 0) then (     police := police+(event) ) else (     if (police > 0) then (     police := police - 1 ) else (     uncheck := uncheck + 1 ) ) ) ;  ) ;  
    OclFile["System.out"].println(uncheck) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.Console ;
import java.util.*;
public class compris {
  static Scanner read=new Scanner(System.in);
  public static void main(String[] args){
    int x=read.nextInt();
    int count=0,temp=0 ;
    int[] arr=new int[x];
    for(int i=0 ; i<x ; i++){
      arr[i]=read.nextInt();
      temp+=arr[i];
      if(temp<0){
        count++;
        temp=0 ;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class compris {
  static   attribute read : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := read.getCurrent()->toInteger() ;
     var count : int ; count := 0 ;
    var temp : int ; temp := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,x)->collect(0) ;
        var i : int ; i := 0 ; while i < x do ( (     arr[i+1] := read.getCurrent()->toInteger() ; 
     temp := temp+(arr[i+1]) ; 
     if (temp < 0) then (     count := count + 1 ; 
     temp := 0 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Beta {
  public static void main(String[] args)throws java.lang.Exception {
    int total=0,count=0 ;
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int temp=sc.nextInt();
      if(temp>0){
        total=total+temp ;
      }
      else if(temp<0 && total!=0){
        total=total-1 ;
      }
      else count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Beta {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var total : int ; total := 0 ;
    var count : int ; count := 0 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : int ; temp := sc.getCurrent()->toInteger() ;
     if (temp > 0) then (     total := total + temp ) else     if (temp < 0 & total /= 0) then (     total := total - 1 ) else     count := count + 1 ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication2 {
  static Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    int events=in.nextInt();
    int hired=0,untreated=0,a ;
    for(int i=0 ; i<events ; i++){
      a=in.nextInt();
      if(a==-1 && hired<1){
        untreated++;
      }
      else hired+=a ;
    }
    System.out.println(untreated);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication2 {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var events : int ; events := in.getCurrent()->toInteger() ;
     var hired : int ; hired := 0 ;
    var untreated : int ; untreated := 0 ;
    var a : int ;
         var i : int ; i := 0 ; while i < events do ( (     a := in.getCurrent()->toInteger() ; 
     if (a = -1 & hired < 1) then (     untreated := untreated + 1 ) else     hired := hired+(a) ; )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(untreated) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int numEvent=in.nextInt();
    int unTreated=0 ;
    int hired=0 ;
    for(int i=0 ; i<numEvent ; i++){
      int num=in.nextInt();
      if(num>0)hired+=num ;
      else if(hired!=0)hired--;
      else unTreated++;
    }
    out.println(unTreated);
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new FileReader("sub.in"));
      }
      catch(FileNotFoundException ex){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException ex){
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException ex){
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var numEvent : int ; numEvent := in.nextInt() ;
    var unTreated : int ; unTreated := 0 ;
    var hired : int ; hired := 0 ;
        var i : int ; i := 0 ; while i < numEvent do ( (     var num : int ; num := in.nextInt() ;
     if (num > 0) then     hired := hired+(num) ; else     if (hired /= 0) then     hired := hired - 1 else     unTreated := unTreated + 1 ; ;  )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("sub.in"))) )   catch (ex : FileNotFoundException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (ex : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (ex : IOException) do skip
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int printSum(int a,int b){
    int res=0 ;
    int temp1=0,temp2=0 ;
    while(a!=0){
      temp1=temp1*10+(a % 10);
      a/=10 ;
    }
    a=temp1 ;
    while(b!=0){
      temp2=temp2*10+(b % 10);
      b/=10 ;
    }
    b=temp2 ;
    while(a!=0){
      int sum=(a % 10+b % 10);
      if(sum/10==0){
        res=res*10+sum ;
      }
      else {
        temp1=0 ;
        while(sum!=0){
          temp1=temp1*10+(sum % 10);
          sum/=10 ;
        }
        sum=temp1 ;
        while(sum!=0){
          res=res*10+(sum % 10);
          sum/=10 ;
        }
      }
      a/=10 ;
      b/=10 ;
    }
    return res ;
  }
  public static void main(String[] args){
    int a=7752,b=8834 ;
    System.out.println(printSum(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printSum( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     var temp1 : int ; temp1 := 0 ;
    var temp2 : int ; temp2 := 0 ;
    while (a /= 0) do (     temp1 := temp1 * 10 + (a mod 10) ; 
     a := a/(10) ) ; 
    a := temp1 ; 
    while (b /= 0) do (     temp2 := temp2 * 10 + (b mod 10) ; 
     b := b/(10) ) ; 
    b := temp2 ; 
    while (a /= 0) do (     var sum : int ; sum := (a mod 10 + b mod 10) ;
     if (sum / 10 = 0) then (     res := res * 10 + sum ) else (     temp1 := 0 ; 
     while (sum /= 0) do (     temp1 := temp1 * 10 + (sum mod 10) ; 
     sum := sum/(10) ) ; 
     sum := temp1 ; 
     while (sum /= 0) do (     res := res * 10 + (sum mod 10) ; 
     sum := sum/(10) ) ) ;  
     a := a/(10) ; 
     b := b/(10) ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 7752 ;
    var b : int ; b := 8834 ;
     OclFile["System.out"].println(printSum(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class DSmall {
  static final int P=10007 ;
  public static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    for(int caseID=1 ; caseID<=N ; caseID++){
      int H=sc.nextInt();
      int W=sc.nextInt();
      int R=sc.nextInt();
      boolean[][] rock=new boolean[H][W];
      for(int i=0 ; i<R ; i++){
        int r=sc.nextInt()-1 ;
        int c=sc.nextInt()-1 ;
        rock[r][c]=true ;
      }
      int[][] count=new int[H+2][W+2];
      count[0][0]=1 ;
      for(int y=0 ; y<H ; y++){
        for(int x=0 ; x<W ; x++){
          if(rock[y][x])continue ;
          count[y+2][x+1]+=count[y][x];
          count[y+2][x+1] %=P ;
          count[y+1][x+2]+=count[y][x];
          count[y+1][x+2] %=P ;
        }
      }
      System.out.printf("Case #%d: %d%n",caseID,count[H-1][W-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DSmall {
  static    attribute P : int := 10007;
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
         var caseID : int ; caseID := 1 ; while caseID <= N do ( (     var H : int ; H := sc.getCurrent()->toInteger() ;
     var W : int ; W := sc.getCurrent()->toInteger() ;
    var R : int ; R := sc.getCurrent()->toInteger() ;
    var rock : Sequence(Sequence(boolean)) ; rock := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(false)) ;
        var i : int ; i := 0 ; while i < R do ( (     var r : int ; r := sc.getCurrent()->toInteger() - 1 ;
     var c : int ; c := sc.getCurrent()->toInteger() - 1 ;
     rock[r+1][c+1] := true )  ;     i := i + 1 ) ; 
    var count : Sequence(Sequence(int)) ; count := Integer.subrange(1,H + 2)->collect(Integer.subrange(1,W + 2)->collect(0)) ;
    count[0+1][0+1] := 1 ; 
        var y : int ; y := 0 ; while y < H do ( (         var x : int ; x := 0 ; while x < W do ( (     if (rock[y+1][x+1]) then     continue else skip ; 
     count[y + 2+1][x + 1+1] := count[y + 2+1][x + 1+1]+(count[y+1][x+1]) ; 
    count[y + 2+1][x + 1+1] := count[y + 2+1][x + 1+1] mod P ; 
    count[y + 1+1][x + 2+1] := count[y + 1+1][x + 2+1]+(count[y+1][x+1]) ; 
    count[y + 1+1][x + 2+1] := count[y + 1+1][x + 2+1] mod P ; 
 )  ;     x := x + 1 ) )  ;     y := y + 1 ) ; 
    OclFile["System.out"].printf("Case #%d: %d%n", caseID, count[H - 1+1][W - 1+1]) ; 
 )  ;     caseID := caseID + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import javax.xml.namespace.QName ;
public class Solution {
  static void printPath(int arr[],int idx){
    if(idx==1){
      System.out.print(idx+" ");
      return ;
    }
    printPath(arr,arr[idx-2]);
    System.out.print(idx+" ");
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),d=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; ++i)arr[i]=sc.nextInt();
    int moves=0 ;
    for(int i=1 ; i<n ; ++i){
      if(arr[i]<=arr[i-1]){
        int move=(arr[i-1]-arr[i]+d)/d ;
        arr[i]+=d*move ;
        moves+=move ;
      }
    }
    System.out.println(moves);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation printPath( arr : Sequence(int), idx : int) : void
  pre: true
  post: true
  activity: (     if (idx = 1) then (     OclFile["System.out"].print(idx + " ") ; 
     return ) else skip ; 
     execute printPath(arr, arr[idx - 2+1]) ; 
     OclFile["System.out"].print(idx + " ") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var moves : int ; moves := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] <= arr[i - 1+1]) then (     var move : int ; move := (arr[i - 1+1] - arr[i+1] + d) / d ;
     arr[i+1] := arr[i+1]+(d * move) ; 
     moves := moves+(move) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(moves) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maximumChars(String str){
    int n=str.length();
    int res=-1 ;
    for(int i=0 ; i<n-1 ; i++)for(int j=i+1 ; j<n ; j++)if(str.charAt(i)==str.charAt(j))res=Math.max(res,Math.abs(j-i-1));
    return res ;
  }
  public static void main(String[] args){
    String str="abba" ;
    System.out.println(maximumChars(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maximumChars( str : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var res : int ; res := -1 ;
         var i : int ; i := 0 ; while i < n - 1 do (         var j : int ; j := i + 1 ; while j < n do (     if (str->at(i+1) = str->at(j+1)) then     res := Set{res, if j - i - 1 < 0 then -(j - i - 1) else j - i - 1 endif}->max() ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abba" ;
     OclFile["System.out"].println(maximumChars(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int N=6 ;
  static int subsetGraph(int C[][]){
    HashSet<Integer>vertices=new HashSet<>();
    for(int i=0 ; i<N ; ++i){
      vertices.add(i);
    }
    while(! vertices.isEmpty()){
      if(vertices.size()==1){
        return 1 ;
      }
      boolean someone_removed=false ;
      for(int x : vertices){
        HashSet<Integer>values=new HashSet<>();
        for(int y : vertices){
          if(y!=x){
            values.add(C[x][y]);
          }
        }
        if(values.size()==1){
          vertices.remove(x);
          someone_removed=true ;
          break ;
        }
      }
      if(! someone_removed){
        break ;
      }
    }
    return(vertices.size());
  }
  public static void main(String[] args){
    int C[][]={
      {
        0,9,2,4,7,8 },{
          9,0,9,9,7,9 },{
            2,9,0,3,7,6 },{
              4,9,3,0,7,1 },{
                7,7,7,7,0,7 },{
                  8,9,6,1,7,0 }
                };
                System.out.println(subsetGraph(C));
              }
            }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 6;
  static   operation subsetGraph( C : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var vertices : Set(int) ; vertices := Set{} ;
         var i : int ; i := 0 ; while i < N do ( (     vertices := vertices->including(i) )  ;     i := i + 1 ) ; 
     while (not(vertices->isEmpty())) do (     if (vertices->size() = 1) then (     return 1 ) else skip ; 
     var someone_removed : boolean ; someone_removed := false ;
     for (x : vertices) do ( (     var values : Set(int) ; values := Set{} ;
     for (y : vertices) do ( (     if (y /= x) then (     values := values->including(C[x+1][y+1]) ) else skip )  ) ; 
     if (values->size() = 1) then (     vertices := vertices->excludingFirst(x) ; 
     someone_removed := true ; 
     break ) else skip )  ) ; 
     if (not(someone_removed)) then (     break ) else skip ) ; 
     return (vertices->size()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var C : Sequence(Sequence(int)) ; C := Sequence{Sequence{0,9,2,4,7,8},Sequence{9,0,9,9,7,9},Sequence{2,9,0,3,7,6},Sequence{4,9,3,0,7,1},Sequence{7,7,7,7,0,7},Sequence{8,9,6,1,7,0}} ;
     OclFile["System.out"].println(subsetGraph(C)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int merge(int arr[],int temp[],int left,int mid,int right){
    int inv_count=0 ;
    int i=left ;
    int j=mid ;
    int k=left ;
    while((i<=mid-1)&&(j<=right)){
      if(arr[i]<=arr[j])temp[k++]=arr[i++];
      else {
        temp[k++]=arr[j++];
        inv_count=inv_count+(mid-i);
      }
    }
    while(i<=mid-1)temp[k++]=arr[i++];
    while(j<=right)temp[k++]=arr[j++];
    for(i=left ; i<=right ; i++)arr[i]=temp[i];
    return inv_count ;
  }
  static int _mergeSort(int arr[],int temp[],int left,int right){
    int mid,inv_count=0 ;
    if(right>left){
      mid=(right+left)/2 ;
      inv_count=_mergeSort(arr,temp,left,mid);
      inv_count+=_mergeSort(arr,temp,mid+1,right);
      inv_count+=merge(arr,temp,left,mid+1,right);
    }
    return inv_count ;
  }
  static int countPairs(int arr[],int n){
    for(int i=0 ; i<n ; i++)arr[i]=i*arr[i];
    int temp[]=new int[n];
    return _mergeSort(arr,temp,0,n-1);
  }
  public static void main(String[] args){
    int arr[]={
      5,0,10,2,4,1,6 };
      int n=arr.length ;
      System.out.print("Count of Pairs : "+countPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation merge( arr : Sequence(int), temp : Sequence(int), left : int, mid : int, right : int) : int
  pre: true
  post: true
  activity: (     var inv_count : int ; inv_count := 0 ;
     var i : int ; i := left ;
    var j : int ; j := mid ;
    var k : int ; k := left ;
    while ((i <= mid - 1) & (j <= right)) do (     if (arr[i+1] <= arr[j+1]) then       temp[k+1] := arr[i+1]  ; k := k + 1  ; i := i + 1 ; else (       temp[k+1] := arr[j+1]  ; k := k + 1  ; j := j + 1 ; 
     inv_count := inv_count + (mid - i) ) ) ; 
    while (i <= mid - 1) do       temp[k+1] := arr[i+1]  ; k := k + 1  ; i := i + 1 ; ; 
    while (j <= right) do       temp[k+1] := arr[j+1]  ; k := k + 1  ; j := j + 1 ; ; 
        i := left ; while i <= right do (     arr[i+1] := temp[i+1] ;  ;     i := i + 1 ) ; 
    return inv_count 
 );
  static   operation _mergeSort( arr : Sequence(int), temp : Sequence(int), left : int, right : int) : int
  pre: true
  post: true
  activity: (     var mid : int ;
    var inv_count : int ; inv_count := 0 ;
     if (right > left) then (     mid := (right + left) / 2 ; 
     inv_count := _mergeSort(arr, temp, left, mid) ; 
     inv_count := inv_count+(_mergeSort(arr, temp, mid + 1, right)) ; 
     inv_count := inv_count+(merge(arr, temp, left, mid + 1, right)) ) else skip ; 
     return inv_count );
  static   operation countPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     arr[i+1] := i * arr[i+1] ;  ;     i := i + 1 ) ; 
     var temp : Sequence(int) ; temp := Integer.subrange(1,n)->collect(0) ;
     return _mergeSort(arr, temp, 0, n - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,0,10,2,4,1,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print("Count of Pairs : " + countPairs(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Prism {
  public static void Calculate_area(){
    double b=3,h=4,s1=3,s2=6 ;
    double s3=6,Ht=8,SA ;
    SA=b*h+(s1+s2+s3)*Ht ;
    System.out.printf("The area of triangular prism is : %f",SA);
  }
  public static void main(String[] args){
    Calculate_area();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Prism {
  static   operation Calculate_area() : void
  pre: true
  post: true
  activity: (     var b : double ; b := 3 ;
    var h : double ; h := 4 ;
    var s1 : double ; s1 := 3 ;
    var s2 : double ; s2 := 6 ;
     var s3 : double ; s3 := 6 ;
    var Ht : double ; Ht := 8 ;
    var SA : double ;
     SA := b * h + (s1 + s2 + s3) * Ht ; 
     OclFile["System.out"].printf("The area of triangular prism is : %f", SA) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute Calculate_area() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int max=0,min=1000000000 ;
    for(int i=0 ; i<n ; i++){
      int d=in.nextInt();
      max=Math.max(max,d);
      min=Math.min(min,d);
    }
    System.out.println(max-min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var max : int ; max := 0 ;
    var min : int ; min := 1000000000 ;
        var i : int ; i := 0 ; while i < n do ( (     var d : int ; d := in.getCurrent()->toInteger() ;
     max := Set{max, d}->max() ; 
     min := Set{min, d}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max - min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static void solve(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int max=Integer.MIN_VALUE ;
    int min=Integer.MAX_VALUE ;
    int[] array=new int[n];
    for(int i=0 ; i<n ; i++){
      array[i]=sc.nextInt();
    }
    sc.close();
    for(int i=0 ; i<n ; i++){
      if(array[i]<=min){
        min=array[i];
      }
      if(array[i]>=max){
        max=array[i];
      }
    }
    System.out.println(max-min);
  }
  public static void main(String[] args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var max : int ; max := -2147483648 ;
    var min : int ; min := 2147483647 ;
    var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < n do ( (     if (array[i+1] <= min) then (     min := array[i+1] ) else skip ; 
     if (array[i+1] >= max) then (     max := array[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max - min) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final int n=sc.nextInt();
    ArrayList<Integer>list=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      list.add(sc.nextInt());
    }
    Collections.sort(list);
    final int min=list.get(0);
    Collections.reverse(list);
    final int max=list.get(0);
    System.out.println(Math.abs(max-min));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var min : int ; min := list->at(0+1) ;
    list := list->reverse() ; 
    var max : int ; max := list->at(0+1) ;
    OclFile["System.out"].println(if max - min < 0 then -(max - min) else max - min endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    Scanner vd=new Scanner(System.in);
    int n=vd.nextInt();
    int[] l=new int[n];
    for(int i=0 ; i<n ; i++)l[i]=vd.nextInt();
    vd.close();
    int max=0 ;
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; ++i){
      if(max<l[i])max=l[i];
    }
    for(int i=0 ; i<n ; ++i){
      if(min>l[i])min=l[i];
    }
    System.out.println(max-min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var vd : OclFile ; vd := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := vd.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     l[i+1] := vd.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    skip ; 
    var max : int ; max := 0 ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     if (max < l[i+1]) then     max := l[i+1] ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (min > l[i+1]) then     min := l[i+1] ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max - min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int N ;
  static int wk ;
  static int Max=0 ;
  static int Min=1000000000 ;
  static int ans=0 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    for(int i=1 ; i<=N ; i++){
      wk=sc.nextInt();
      Max=Math.max(Max,wk);
      Min=Math.min(Min,wk);
    }
    ans=Max-Min ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute wk : int;
  static   attribute Max : int := 0;
  static   attribute Min : int := 1000000000;
  static   attribute ans : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i <= N do ( (     wk := sc.getCurrent()->toInteger() ; 
     Max := Set{Max, wk}->max() ; 
     Min := Set{Min, wk}->min() )  ;     i := i + 1 ) ; 
    ans := Max - Min ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long calculateSum(int n,int k){
    int res=1 ;
    int MOD=1000000007 ;
    while(k>0){
      if((k & 1)==1)res=(res*n)% MOD ;
      k=k/2 ;
      n=(n*n)% MOD ;
    }
    return res ;
  }
  public static void main(String[] args){
    int n=4,k=3 ;
    System.out.print(calculateSum(n,k));
  }
};
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation calculateSum( n : int, k : int) : long
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     var MOD : int ; MOD := 1000000007 ;
     while (k > 0) do (     if ((k & 1) = 1) then     res := (res * n) mod MOD ; else skip ; 
     k := k / 2 ; 
     n := (n * n) mod MOD ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
    var k : int ; k := 3 ;
     OclFile["System.out"].print(calculateSum(n, k)) );
}
 ;

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    Map<String,Integer>dic=new HashMap<>();
    int count=stdIn.nextInt();
    for(int i=0 ; i<count ; i++){
      int command=stdIn.nextInt();
      switch(command){
        case 0 : dic.put(stdIn.next(),stdIn.nextInt());
        break ;
        case 1 : String key=stdIn.next();
        if(dic.get(key)!=null){
          System.out.println(dic.get(key));
        }
        else {
          System.out.println(0);
        }
        break ;
        case 2 : dic.remove(stdIn.next());
        break ;
      }
    }
    stdIn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dic : Map(String,int) ; dic := Map{} ;
    var count : int ; count := stdIn.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < count do ( (     var command : int ; command := stdIn.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (command) ; 
       if _switchval = 0 then
     dic := dic->union(Map{stdIn.getCurrent() |-> stdIn.getCurrent()->toInteger()}) ; 
    break 
   else skip ;
       if _switchval = 1 then
     var key : String ; key := stdIn.getCurrent() ;
    if (dic->at(key) /= null) then (     OclFile["System.out"].println(dic->at(key)) ) else (     OclFile["System.out"].println(0) ) ;  
    break 
   else skip ;
       if _switchval = 2 then
     dic := dic->antirestrict(Set{stdIn.getCurrent()}) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.math.BigInteger.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import java.math.*;
import java.util.*;
public class D {
  public static void main(String[] args){
    new D().run();
  }
  long M=10007 ;
  static final int[] di={
    1,2 },dj={
      2,1 };
      void run(){
        Scanner sc=new Scanner(System.in);
        int on=sc.nextInt();
        for(int o=1 ; o<=on ; o++){
          System.out.printf("Case #%d: ",o);
          int h=sc.nextInt(),w=sc.nextInt(),r=sc.nextInt();
          boolean[][] bs=new boolean[h][w];
          for(int i=0 ; i<r ; i++)bs[sc.nextInt()-1][sc.nextInt()-1]=true ;
          long[][] dp=new long[h][w];
          dp[0][0]=1 ;
          for(int i=0 ; i<h ; i++){
            for(int j=0 ; j<w ; j++)if(! bs[i][j]){
              for(int k=0 ; k<2 ; k++){
                int ii=i+di[k],jj=j+dj[k];
                if(ii<h && jj<w)dp[ii][jj]=(dp[ii][jj]+dp[i][j])% M ;
              }
            }
          }
          System.out.println(dp[h-1][w-1]);
        }
      }
      void debug(Object...os){
        System.err.println(deepToString(os));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class D {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     D.newD().run() );
   attribute M : long := 10007;
  static    attribute di : Sequence(int) := Sequence{1,2};
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var on : int ; on := sc.getCurrent()->toInteger() ;
         var o : int ; o := 1 ; while o <= on do ( (     OclFile["System.out"].printf("Case #%d: ", o) ; 
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var bs : Sequence(Sequence(boolean)) ; bs := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(false)) ;
        var i : int ; i := 0 ; while i < r do (     bs[sc.getCurrent()->toInteger() - 1+1][sc.getCurrent()->toInteger() - 1+1] := true ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do (     if (not(bs[i+1][j+1])) then (         var k : int ; k := 0 ; while k < 2 do ( (     var ii : int ; ii := i + di[k+1] ;
    var jj : int ; jj := j + dj[k+1] ;
     if (ii < h & jj < w) then     dp[ii+1][jj+1] := (dp[ii+1][jj+1] + dp[i+1][j+1]) mod M ; else skip )  ;     k := k + 1 ) ) else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[h - 1+1][w - 1+1]) ; 
 )  ;     o := o + 1 ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    int testCount=Integer.parseInt(in.next());
    for(int i=1 ; i<=testCount ; i++)solver.solve(i,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      char[] s=in.next().toCharArray();
      int k=in.nextInt();
      int n=s.length ;
      int ret=0 ;
      for(int i=0 ; i+k<=n ; i++){
        if(s[i]=='-'){
++ret ;
          for(int j=0 ; j<k ; j++){
            s[i+j]=(char)('+'+'-'-s[i+j]);
          }
        }
      }
      out.printf("Case #%d: ",testNumber);
      for(int i=0 ; i<n ; i++){
        if(s[i]!='+'){
          out.println("IMPOSSIBLE");
          return ;
        }
      }
      out.println(ret);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    var testCount : int ; testCount := (in.next())->toInteger() ;
        var i : int ; i := 1 ; while i <= testCount do (     solver.solve(i, in, out) ;  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := in.next()->characters() ;
     var k : int ; k := in.nextInt() ;
    var n : int ; n := s->size() ;
    var ret : int ; ret := 0 ;
        var i : int ; i := 0 ; while i + k <= n do ( (     if (s[i+1] = '-') then (     ret := ret + 1 ; 
         var j : int ; j := 0 ; while j < k do ( (     s[i + j+1] := (('+' + '-')->char2byte() - s[i + j+1])->oclAsType(String) )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] /= '+') then (     skip ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class A {
  static int solve(){
    int[] str=in.next().chars().map((i)->i=='+' ? 0 : 1).toArray();
    int size=in.nextInt();
    int count=0 ;
    for(int i=0 ; i<str.length-size+1 ; ++i){
      if(str[i]!=0){
        count++;
        for(int j=i ; j<i+size ; ++j){
          str[j]=str[j]==1 ? 0 : 1 ;
        }
      }
    }
    for(int i=str.length-size+1 ; i<str.length ; ++i){
      if(str[i]!=0)return-1 ;
    }
    return count ;
  }
  static Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    int T=in.nextInt();
    for(int t=0 ; t<T ; ++t){
      int c=solve();
      System.out.printf("Case #%d: %s%n",t+1,c>=0 ? Integer.toString(c): "IMPOSSIBLE");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation solve() : int
  pre: true
  post: true
  activity: (     var str : Sequence(int) ; str := in.next().chars()->collect( _x1 | (lambda i : OclAny in if i = '+' then 0 else 1 endif)->apply(_x1) )->asSequence() ;
     var size : int ; size := in.nextInt() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < str->size() - size + 1 do ( (     if (str[i+1] /= 0) then (     count := count + 1 ; 
         var j : int ; j := i ; while j < i + size do ( (     str[j+1] := if str[j+1] = 1 then 0 else 1 endif )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := str->size() - size + 1 ; while i < str->size() do ( (     if (str[i+1] /= 0) then     return -1 else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var c : int ; c := solve() ;
     OclFile["System.out"].printf("Case #%d: %s%n", t + 1, if c >= 0 then ((c) + "") else "IMPOSSIBLE" endif) )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package com.company ;
import java.io.FileInputStream ;
import java.io.FileNotFoundException ;
import java.io.FileOutputStream ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  private static Scanner scanner=new Scanner(System.in);
  static private void reDirect(){
    try {
      FileInputStream fileInputStream=new FileInputStream("A-large.in");
      scanner=new Scanner(fileInputStream);
      PrintStream ps=new PrintStream(new FileOutputStream("a-out-large.txt"));
      System.setOut(ps);
    }
    catch(FileNotFoundException e){
      e.printStackTrace();
    }
  }
  public static void main(String[] args){
    reDirect();
    int T=scanner.nextInt();
    for(int cas=1 ; cas<=T ; cas++){
      int ans=run();
      System.out.println("Case #"+cas+": "+(ans<0 ? "IMPOSSIBLE" : ans));
    }
  }
  static private int run(){
    String s=scanner.next();
    int k=scanner.nextInt();
    char[] arr=s.toCharArray();
    int count=0 ;
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]=='-'){
        if(i+k>arr.length){
          return-1 ;
        }
        count++;
        for(int j=i ; j<i+k ; j++){
          arr[j]=(arr[j]=='+' ? '-' : '+');
        }
      }
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    operation reDirect() : void
  pre: true
  post: true
  activity: (     try (     var fileInputStream : OclFile ; fileInputStream := OclFile.newOclFile_Read(OclFile.newOclFile("A-large.in")) ;
     scanner := OclFile.newOclFile_Read(fileInputStream) ; 
     var ps : OclFile ; ps := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("a-out-large.txt"))) ;
 setOut(ps) )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute reDirect() ; 
     var T : int ; T := scanner.getCurrent()->toInteger() ;
         var cas : int ; cas := 1 ; while cas <= T do ( (     var ans : int ; ans := run() ;
     OclFile["System.out"].println("Case #" + cas + ": " + (if ans < 0 then "IMPOSSIBLE" else ans endif)) )  ;     cas := cas + 1 ) );
  static    operation run() : int
  pre: true
  post: true
  activity: (     var s : String ; s := scanner.getCurrent() ;
     var k : int ; k := scanner.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := s->characters() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = '-') then (     if (i + k > arr->size()) then (     return -1 ) else skip ; 
     count := count + 1 ; 
         var j : int ; j := i ; while j < i + k do ( (     arr[j+1] := (if arr[j+1] = '+' then '-' else '+' endif) )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    return count 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package qualifier ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
public class AOversizedPancakeFlipper {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in)))){
      int tests=sc.nextInt();
      outer : for(int t=1 ;
      t<=tests ;
      t++){
        char[] happyChars=sc.next().toCharArray();
        int spatWidth=sc.nextInt();
        boolean[] happy=new boolean[happyChars.length];
        for(int x=0 ; x<happy.length ; x++)happy[x]=happyChars[x]=='+' ;
        List<Integer>flipPoints=new LinkedList<Integer>();
        int flipCount=0 ;
        boolean flipped=false ;
        for(int x=0 ; x<=happy.length-spatWidth ; x++){
          if(! flipPoints.isEmpty()&& flipPoints.get(0)==x){
            flipPoints.remove(0);
            flipped=! flipped ;
          }
          boolean current=happy[x]!=flipped ;
          if(! current){
            flipped=! flipped ;
            flipCount++;
            flipPoints.add(x+spatWidth);
          }
        }
        for(int x=happy.length-spatWidth+1 ; x<happy.length ; x++){
          if(! flipPoints.isEmpty()&& flipPoints.get(0)==x){
            flipPoints.remove(0);
            flipped=! flipped ;
          }
          if(happy[x]==flipped){
            System.out.printf("Case #%d: IMPOSSIBLE%n",t);
            continue outer ;
          }
        }
        System.out.printf("Case #%d: %d%n",t,flipCount);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AOversizedPancakeFlipper {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
 (     var tests : int ; tests := sc.getCurrent()->toInteger() ;
         var t : int ; t := 1 ; while t <= tests do ( (     var happyChars : Sequence(String) ; happyChars := sc.getCurrent()->characters() ;
     var spatWidth : int ; spatWidth := sc.getCurrent()->toInteger() ;
    var happy : Sequence(boolean) ; happy := Integer.subrange(1,happyChars->size())->collect(false) ;
        var x : int ; x := 0 ; while x < happy->size() do (     happy[x+1] := happyChars[x+1] = '+' ;  ;     x := x + 1 ) ; 
    var flipPoints : Sequence(int) ; flipPoints := Sequence{} ;
    var flipCount : int ; flipCount := 0 ;
    var flipped : boolean ; flipped := false ;
        var x : int ; x := 0 ; while x <= happy->size() - spatWidth do ( (     if (not(flipPoints->isEmpty()) & flipPoints->at(0+1) = x) then (     flipPoints := flipPoints->excludingAt(0+1) ; 
     flipped := not(flipped) ) else skip ; 
     var current : boolean ; current := happy[x+1] /= flipped ;
     if (not(current)) then (     flipped := not(flipped) ; 
     flipCount := flipCount + 1 ; 
     flipPoints := flipPoints->including(x + spatWidth) ) else skip )  ;     x := x + 1 ) ; 
        var x : int ; x := happy->size() - spatWidth + 1 ; while x < happy->size() do ( (     if (not(flipPoints->isEmpty()) & flipPoints->at(0+1) = x) then (     flipPoints := flipPoints->excludingAt(0+1) ; 
     flipped := not(flipped) ) else skip ; 
     if (happy[x+1] = flipped) then (     OclFile["System.out"].printf("Case #%d: IMPOSSIBLE%n", t) ; 
     continue ) else skip )  ;     x := x + 1 ) ; 
    OclFile["System.out"].printf("Case #%d: %d%n", t, flipCount) ; 
 )  ;     t := t + 1 ) ; ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new FileReader("A-large.in"));
    BufferedWriter bw=new BufferedWriter(new FileWriter("solve.txt"));
    int T=Integer.parseInt(br.readLine().trim());
    StringTokenizer s ;
    for(int i=1 ; i<=T ; i++){
      s=new StringTokenizer(br.readLine().trim());
      String S=s.nextToken();
      int K=Integer.parseInt(s.nextToken());
      int len=S.length();
      int num=0 ;
      boolean ok=true ;
      int[] data=new int[len];
      for(int j=0 ; j<=len-K ; j++){
        if((S.charAt(j)=='-' && data[j] % 2==0)||(S.charAt(j)=='+' && data[j] % 2==1)){
          num++;
          for(int k=1 ; k<K ; k++){
            data[j+k]++;
          }
        }
      }
      for(int j=len-K+1 ; j<len ; j++){
        if((S.charAt(j)=='-' && data[j] % 2==0)||(S.charAt(j)=='+' && data[j] % 2==1)){
          ok=false ;
          break ;
        }
      }
      bw.write("Case #"+i+": ");
      if(ok){
        bw.write(num+"\n");
      }
      else {
        bw.write("IMPOSSIBLE\n");
      }
    }
    br.close();
    bw.close();
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("A-large.in"))) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("solve.txt"))) ;
    var T : int ; T := (br.readLine()->trim())->toInteger() ;
    var s : OclIterator ;
        var i : int ; i := 1 ; while i <= T do ( (     s := OclIterator.newOclIterator_String(br.readLine()->trim()) ; 
     var S : String ; S := s.next() ;
    var K : int ; K := (s.next())->toInteger() ;
    var len : int ; len := S->size() ;
    var num : int ; num := 0 ;
    var ok : boolean ; ok := true ;
    var data : Sequence(int) ; data := Integer.subrange(1,len)->collect(0) ;
        var j : int ; j := 0 ; while j <= len - (K)->char2byte() do ( (     if ((S->at(j+1) = '-' & data[j+1] mod 2 = 0) or (S->at(j+1) = '+' & data[j+1] mod 2 = 1)) then (     num := num + 1 ; 
         var k : int ; k := 1 ; while k < K do ( (     data[j + k+1] := data[j + k+1] + 1 )  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) ; 
        var j : int ; j := len - (K)->char2byte() + 1 ; while j < len do ( (     if ((S->at(j+1) = '-' & data[j+1] mod 2 = 0) or (S->at(j+1) = '+' & data[j+1] mod 2 = 1)) then (     ok := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    skip ; 
    if (ok) then (     skip ) else (     skip ) ;  
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str[]=br.readLine().split(" ");
    int a=Integer.parseInt(str[0]);
    int b=Integer.parseInt(str[1]);
    int c=Integer.parseInt(str[2]);
    int i ;
    int ans=0 ;
    ArrayList<Long>arr=new ArrayList<>();
    for(i=1 ; i<=81 ; i++){
      long r=b*(long)Math.pow(i,a)+c ;
      long v=r ;
      if(r<=(long)Math.pow(10,9)){
        int sum=0 ;
        while(r>0){
          sum+=r % 10 ;
          r=r/10 ;
        }
        if(sum==i){
          arr.add(v);
        }
      }
    }
    System.out.println(arr.size());
    for(long j : arr)System.out.print(j+" ");
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var a : int ; a := (str[0+1])->toInteger() ;
    var b : int ; b := (str[1+1])->toInteger() ;
    var c : int ; c := (str[2+1])->toInteger() ;
    var i : int ;
    var ans : int ; ans := 0 ;
    var arr : Sequence(long) ; arr := Sequence{} ;
        i := 1 ; while i <= 81 do ( (     var r : long ; r := b * i->pow(a)->oclAsType(long) + c ;
     var v : long ; v := r ;
     if (r <= 10->pow(9)->oclAsType(long)) then (     var sum : int ; sum := 0 ;
     while (r > 0) do (     sum := sum+(r mod 10) ; 
     r := r / 10 ) ; 
     if (sum = i) then (     arr := arr->including(v) ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(arr->size()) ; 
    for (j : arr) do (     OclFile["System.out"].print(j + " ") ;  ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner a=new Scanner(System.in);
    int n1=a.nextInt();
    int n2=a.nextInt();
    int n3=a.nextInt();
    List<Long>l=new ArrayList<>();
    for(int i=1 ; i<=81 ; i++){
      long power=(long)Math.pow(i,n1);
      long ans=(n2*power)+n3 ;
      long sum=0 ;
      long ans1=ans ;
      while(ans1>0){
        sum+=ans1 % 10 ;
        ans1/=10 ;
      }
      if(sum==i && ans<1000000000)l.add(ans);
      if(ans>1000000000)break ;
    }
    System.out.println(l.size());
    for(int i=0 ; i<l.size(); i++)System.out.print(l.get(i)+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : OclFile ; a := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n1 : int ; n1 := a.getCurrent()->toInteger() ;
    var n2 : int ; n2 := a.getCurrent()->toInteger() ;
    var n3 : int ; n3 := a.getCurrent()->toInteger() ;
    var l : Sequence(long) ; l := Sequence{} ;
        var i : int ; i := 1 ; while i <= 81 do ( (     var power : long ; power := i->pow(n1)->oclAsType(long) ;
     var ans : long ; ans := (n2 * power) + n3 ;
    var sum : long ; sum := 0 ;
    var ans1 : long ; ans1 := ans ;
    while (ans1 > 0) do (     sum := sum+(ans1 mod 10) ; 
     ans1 := ans1/(10) ) ; 
    if (sum = i & ans < 1000000000) then     l := l->including(ans) ; else skip ; 
    if (ans > 1000000000) then     break else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(l->size()) ; 
        var i : int ; i := 0 ; while i < l->size() do (     OclFile["System.out"].print(l->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class problem118B {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner in=new Scanner(System.in);
    List<Long>ans=new ArrayList<>();
    long a=in.nextLong();
    long b=in.nextLong();
    long c=in.nextLong();
    for(int i=1 ; i<=81 ; i++){
      long x=(long)(b*Math.pow(i,a)+c);
      if(check(x,i)&& x<1000000000)ans.add(x);
    }
    System.out.println(ans.size());
    for(int i=0 ; i<ans.size(); i++)System.out.print(ans.get(i)+" ");
  }
  public static boolean check(long a,long b){
    long temp=a ;
    long sum=0 ;
    while(a>0){
      long temp2=a % 10 ;
      sum+=temp2 ;
      a/=10 ;
    }
    return sum==b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class problem118B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ans : Sequence(long) ; ans := Sequence{} ;
    var a : long ; a := in.getCurrent()->toLong() ;
    var b : long ; b := in.getCurrent()->toLong() ;
    var c : long ; c := in.getCurrent()->toLong() ;
        var i : int ; i := 1 ; while i <= 81 do ( (     var x : long ; x := (b * i->pow(a) + c)->oclAsType(long) ;
     if (check(x, i) & x < 1000000000) then     ans := ans->including(x) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans->size()) ; 
        var i : int ; i := 0 ; while i < ans->size() do (     OclFile["System.out"].print(ans->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation check( a : long, b : long) : boolean
  pre: true
  post: true
  activity: (     var temp : long ; temp := a ;
     var sum : long ; sum := 0 ;
     while (a > 0) do (     var temp2 : long ; temp2 := a mod 10 ;
     sum := sum+(temp2) ; 
     a := a/(10) ) ; 
     return sum = b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public final class Codeforces {
  static int sumOfDigits(long x){
    int count=0 ;
    while(x>0){
      count=count+(int)x % 10 ;
      x=x/10 ;
    }
    return count ;
  }
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    long a=sc.nextLong(),b=sc.nextLong(),c=sc.nextLong();
    long arr[]=new long[82];
    int count=0 ;
    for(int i=1 ; i<=81 ; i++){
      long n=b*(long)Math.pow(i,a)+c ;
      int x=sumOfDigits(n);
      if(n>1000000000){
        break ;
      }
      if(x==i){
        arr[count]=n ;
        count++;
      }
    }
    System.out.println(count);
    for(int i=0 ; i<count ; i++){
      System.out.print(arr[i]+" ");
    }
  }
  public static String reverseString(String str){
    StringBuilder sb=new StringBuilder(str);
    sb.reverse();
    return sb.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation sumOfDigits( x : long) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (x > 0) do (     count := count + x->oclAsType(int) mod 10 ; 
     x := x / 10 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var c : long ; c := sc.getCurrent()->toLong() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,82)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= 81 do ( (     var n : long ; n := b * i->pow(a)->oclAsType(long) + c ;
     var x : int ; x := sumOfDigits(n) ;
     if (n > 1000000000) then (     break ) else skip ; 
     if (x = i) then (     arr[count+1] := n ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
        var i : int ; i := 0 ; while i < count do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation reverseString( str : String) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString(str) ;
     sb := sb->reverse() ; 
     return sb+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int st=in.nextInt();
      int end=in.nextInt();
      int n=in.nextInt();
      int m=in.nextInt();
      int sum=0 ;
      if(st>end){
        int temp=end ;
        end=st ;
        st=temp ;
      }
      if(n+m<=st){
        sum=end-st ;
      }
      else if(n+m>=st && n-m<st){
        sum=end-n-m ;
      }
      else if(n-m>=st && n<=end-m){
        sum=end-st-2*m ;
      }
      else if(n-m<end && n+m>=end){
        sum=n-m-st ;
      }
      else {
        sum=end-st ;
      }
      if(sum<0)sum=0 ;
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var st : int ; st := in.getCurrent()->toInteger() ;
     var end : int ; end := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    if (st > end) then (     var temp : int ; temp := end ;
     end := st ; 
     st := temp ) else skip ; 
    if (n + m <= st) then (     sum := end - st ) else     if (n + m >= st & n - m < st) then (     sum := end - n - m ) else     if (n - m >= st & n <= end - m) then (     sum := end - st - 2 * m ) else     if (n - m < end & n + m >= end) then (     sum := n - m - st ) else (     sum := end - st ) ;  ;  ;  ;  
    if (sum < 0) then     sum := 0 ; else skip ; 
    OclFile["System.out"].println(sum) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class Node {
    int data ;
    Node next ;
  }
  static void printList(Node node){
    while(node!=null){
      System.out.print(node.data+" ");
      node=node.next ;
    }
    System.out.println();
  }
  static Node newNode(int key){
    Node temp=new Node();
    temp.data=key ;
    temp.next=null ;
    return temp ;
  }
  static Node insertBeg(Node head,int val){
    Node temp=newNode(val);
    temp.next=head ;
    head=temp ;
    return head ;
  }
  static void rearrangeOddEven(Node head){
    Stack<Node>odd=new Stack<Node>();
    Stack<Node>even=new Stack<Node>();
    int i=1 ;
    while(head!=null){
      if(head.data % 2!=0 && i % 2==0){
        odd.push(head);
      }
      else if(head.data % 2==0 && i % 2!=0){
        even.push(head);
      }
      head=head.next ;
      i++;
    }
    while(odd.size()>0 && even.size()>0){
      int k=odd.peek().data ;
      odd.peek().data=even.peek().data ;
      even.peek().data=k ;
      odd.pop();
      even.pop();
    }
  }
  public static void main(String args[]){
    Node head=newNode(8);
    head=insertBeg(head,7);
    head=insertBeg(head,6);
    head=insertBeg(head,5);
    head=insertBeg(head,3);
    head=insertBeg(head,2);
    head=insertBeg(head,1);
    System.out.println("Linked List:");
    printList(head);
    rearrangeOddEven(head);
    System.out.println("Linked List after "+"Rearranging:");
    printList(head);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   operation printList( node : Node) : void
  pre: true
  post: true
  activity: (     while (node /= null) do (     OclFile["System.out"].print(node.data + " ") ; 
     node := node.next ) ; 
     OclFile["System.out"].println() );
  static   operation newNode( key : int) : Node
  pre: true
  post: true
  activity: (     var temp : Node ; temp := Node.newNode() ;
     temp.data := key ; 
     temp.next := null ; 
     return temp );
  static   operation insertBeg( head : Node, val : int) : Node
  pre: true
  post: true
  activity: (     var temp : Node ; temp := newNode(val) ;
     temp.next := head ; 
     head := temp ; 
     return head );
  static   operation rearrangeOddEven( head : Node) : void
  pre: true
  post: true
  activity: (     var odd : Sequence(Node) ; odd := Sequence{} ;
     var even : Sequence(Node) ; even := Sequence{} ;
    var i : int ; i := 1 ;
    while (head /= null) do (     if (head.data mod 2 /= 0 & i mod 2 = 0) then (     odd := odd->append(head) ) else     if (head.data mod 2 = 0 & i mod 2 /= 0) then (     even := even->append(head) ) else skip ; ;  
     head := head.next ; 
     i := i + 1 ) ; 
    while (odd->size() > 0 & even->size() > 0) do (     var k : int ; k := odd->min().data ;
     odd->min().data := even->min().data ; 
    even->min().data := k ; 
    odd := odd->front() ; 
    even := even->front() ; 
 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := newNode(8) ;
     head := insertBeg(head, 7) ; 
    head := insertBeg(head, 6) ; 
    head := insertBeg(head, 5) ; 
    head := insertBeg(head, 3) ; 
    head := insertBeg(head, 2) ; 
    head := insertBeg(head, 1) ; 
    OclFile["System.out"].println("Linked List:") ; 
    execute printList(head) ; 
    execute rearrangeOddEven(head) ; 
    OclFile["System.out"].println("Linked List after " + "Rearranging:") ; 
    execute printList(head) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.util.Locale ;
public class B implements Runnable {
  static final String NAME="b-large" ;
  public void solve()throws Exception {
    int ntest=Integer.parseInt(readWord());
    for(int test=1 ; test<=ntest ; test++){
      long n=Long.parseLong(readWord());
      long m=Long.parseLong(readWord());
      long a=Long.parseLong(readWord());
      if(a>n*m){
        stdout.write("Case #"+test+": "+"IMPOSSIBLE\n");
        continue ;
      }
      long s=a % n ;
      if(s==0){
        stdout.write("Case #"+test+": "+"0 0 "+n+" "+0+" "+n+" "+(a/n)+"\n");
      }
      else {
        stdout.write("Case #"+test+": "+"0 0 "+n+" "+1+" "+(n-s)+" "+(a/n+1)+"\n");
      }
    }
  }
  static BufferedReader stdin ;
  static BufferedWriter stdout ;
  String readWord()throws Exception {
    StringBuilder b=new StringBuilder();
    int c ;
    while(true){
      c=stdin.read();
      if(c<0){
        return "" ;
      }
      if(c>32){
        break ;
      }
    }
    while(true){
      b.append((char)c);
      c=stdin.read();
      if(c<=32){
        break ;
      }
    }
    return b.toString();
  }
  public void run(){
    try {
      stdin=new BufferedReader(new FileReader(NAME+".in"));
      stdout=new BufferedWriter(new FileWriter(NAME+".out"));
      solve();
      stdout.close();
      stdin.close();
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  public static void main(String[] args){
    try {
      Locale.setDefault(Locale.US);
    }
    catch(Throwable e){
    }
    new Thread(new B()).start();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B implements Runnable {
  static    attribute NAME : String := "b-large";
   operation solve() : void
  pre: true
  post: true
  activity: (     var ntest : int ; ntest := (readWord())->toInteger() ;
         var test : int ; test := 1 ; while test <= ntest do ( (     var n : long ; n := (readWord())->toLong() ;
     var m : long ; m := (readWord())->toLong() ;
    var a : long ; a := (readWord())->toLong() ;
    if (a > n * m) then (     stdout.write("Case #" + test + ": " + "IMPOSSIBLE\n") ; 
     continue ) else skip ; 
    var s : long ; s := a mod n ;
    if (s = 0) then (     stdout.write("Case #" + test + ": " + "0 0 " + n + " " + 0 + " " + n + " " + (a / n) + "\n") ) else (     stdout.write("Case #" + test + ": " + "0 0 " + n + " " + 1 + " " + (n - s) + " " + (a / n + 1) + "\n") ) ;  
 )  ;     test := test + 1 ) );
  static   attribute stdin : OclFile;
  static   attribute stdout : OclFile;
   operation readWord() : String
  pre: true
  post: true
  activity: (     var b : String ; b := StringLib.newString() ;
     var c : int ;
    while (true) do (     c := stdin.read() ; 
     if (c < 0) then (     return "" ) else skip ; 
     if (c > 32) then (     break ) else skip ) ; 
    while (true) do (     b := b + StringLib.newString(c->oclAsType(String)) ; 
     c := stdin.read() ; 
     if (c <= 32) then (     break ) else skip ) ; 
    return b+"" 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     stdin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(NAME + ".in")) ; 
     stdout := OclFile.newOclFile_Write(OclFile.newOclFile_Write(NAME + ".out")) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     Locale.setDefault(Locale.US) )   catch (e : OclException) do skip
     OclProcess.newOclProcess(B.newB()).start() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.util.Scanner ;
public class D {
  static Scanner in ;
  static PrintWriter out ;
  public static void main(String[] args)throws FileNotFoundException {
    in=new Scanner(new File("input.txt"));
    out=new PrintWriter("output.txt");
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      out.println("Case #"+(i+1)+": "+new D().solve());
    }
    out.close();
  }
  private Object solve(){
    int n=in.nextInt();
    int m=in.nextInt();
    int r=in.nextInt();
    boolean[][] a=new boolean[n][m];
    for(int i=0 ; i<r ; i++){
      a[in.nextInt()-1][in.nextInt()-1]=true ;
    }
    int[][] d=new int[n][m];
    d[0][0]=1 ;
    for(int i=1 ; i<n ; i++){
      for(int j=1 ; j<m ; j++)if(! a[i][j]){
        if(i>1){
          d[i][j]+=d[i-2][j-1];
        }
        if(j>1){
          d[i][j]+=d[i-1][j-2];
        }
        d[i][j] %=10007 ;
      }
    }
    return d[n-1][m-1];
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile("input.txt")) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ; 
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation solve() : OclAny
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var r : int ; r := in.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(boolean)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(false)) ;
        var i : int ; i := 0 ; while i < r do ( (     a[in.getCurrent()->toInteger() - 1+1][in.getCurrent()->toInteger() - 1+1] := true )  ;     i := i + 1 ) ; 
    var d : Sequence(Sequence(int)) ; d := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    d[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 1 ; while j < m do (     if (not(a[i+1][j+1])) then (     if (i > 1) then (     d[i+1][j+1] := d[i+1][j+1]+(d[i - 2+1][j - 1+1]) ) else skip ; 
     if (j > 1) then (     d[i+1][j+1] := d[i+1][j+1]+(d[i - 1+1][j - 2+1]) ) else skip ; 
     d[i+1][j+1] := d[i+1][j+1] mod 10007 ) else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return d[n - 1+1][m - 1+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class RecentCounter {
  Queue<Integer>q ;
  public RecentCounter(){
    q=new LinkedList();
  }
  public int ping(int t){
    q.add(t);
    while(q.peek()<t-3000)q.poll();
    return q.size();
  }
}
------------------------------------------------------------
OCL File:
---------
class RecentCounter {
   attribute q : Sequence(int);
   static operation newRecentCounter() : RecentCounter
  pre: true
  post: true
  activity:
  ( var self : RecentCounter ;
    self := createRecentCounter();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     q := Sequence{} );
   operation ping( t : int) : int
  pre: true
  post: true
  activity: (     q := q->including(t) ; 
     while (q->min() < t - 3000) do     q := q->sort()->tail() ; ; 
     return q->size() );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static int countDivisors(int n){
    int cnt=0 ;
    for(int i=1 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        if(n/i==i)cnt++;
        else cnt=cnt+2 ;
      }
    }
    return cnt ;
  }
  public static void main(String args[]){
    System.out.println("Total distinct "+"divisors of 100 are : "+countDivisors(100));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDivisors( n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 1 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     if (n / i = i) then     cnt := cnt + 1 ; else     cnt := cnt + 2 ; ) else skip )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Total distinct " + "divisors of 100 are : " + countDivisors(100)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class PrintMissing {
  static void printMissing(int ar[],int low,int high){
    Arrays.sort(ar);
    int index=ceilindex(ar,low,0,ar.length-1);
    int x=low ;
    while(index<ar.length && x<=high){
      if(ar[index]!=x){
        System.out.print(x+" ");
      }
      else index++;
      x++;
    }
    while(x<=high){
      System.out.print(x+" ");
      x++;
    }
  }
  static int ceilindex(int ar[],int val,int low,int high){
    if(val<ar[0])return 0 ;
    if(val>ar[ar.length-1])return ar.length ;
    int mid=(low+high)/2 ;
    if(ar[mid]==val)return mid ;
    if(ar[mid]<val){
      if(mid+1<high && ar[mid+1]>=val)return mid+1 ;
      return ceilindex(ar,val,mid+1,high);
    }
    else {
      if(mid-1>=low && ar[mid-1]<val)return mid ;
      return ceilindex(ar,val,low,mid-1);
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,3,5,4 };
      int low=1,high=10 ;
      printMissing(arr,low,high);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class PrintMissing {
  static   operation printMissing( ar : Sequence(int), low : int, high : int) : void
  pre: true
  post: true
  activity: (     ar := ar->sort() ; 
     var index : int ; index := ceilindex(ar, low, 0, ar->size() - 1) ;
    var x : int ; x := low ;
    while (index < ar->size() & x <= high) do (     if (ar[index+1] /= x) then (     OclFile["System.out"].print(x + " ") ) else     index := index + 1 ; ;  
     x := x + 1 ) ; 
    while (x <= high) do (     OclFile["System.out"].print(x + " ") ; 
     x := x + 1 ) ; 
 );
  static   operation ceilindex( ar : Sequence(int), val : int, low : int, high : int) : int
  pre: true
  post: true
  activity: (     if (val < ar[0+1]) then     return 0 else skip ; 
     if (val > ar[ar->size() - 1+1]) then     return ar->size() else skip ; 
    var mid : int ; mid := (low + high) / 2 ;
    if (ar[mid+1] = val) then     return mid else skip ; 
    if (ar[mid+1] < val) then (     if (mid + 1 < high & ar[mid + 1+1] >= val) then     return mid + 1 else skip ; 
     return ceilindex(ar, val, mid + 1, high) ) else (     if (mid - 1 >= low & ar[mid - 1+1] < val) then     return mid else skip ; 
     return ceilindex(ar, val, low, mid - 1) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,5,4} ;
     var low : int ; low := 1 ;
    var high : int ; high := 10 ;
     execute printMissing(arr, low, high) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void calcSum(int arr[],int n,int k){
    int sum=0 ;
    for(int i=0 ; i<k ; i++)sum+=arr[i];
    System.out.print(sum+" ");
    for(int i=k ; i<n ; i++){
      sum=(sum-arr[i-k])+arr[i];
      System.out.print(sum+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,6 };
      int n=arr.length ;
      int k=3 ;
      calcSum(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation calcSum( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < k do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(sum + " ") ; 
         var i : int ; i := k ; while i < n do ( (     sum := (sum - arr[i - k+1]) + arr[i+1] ; 
     OclFile["System.out"].print(sum + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     execute calcSum(arr, n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A588 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int tempMin=101 ;
    int total=0 ;
    for(int i=0 ; i<n ; i++){
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      tempMin=Math.min(tempMin,b);
      total+=a*tempMin ;
    }
    System.out.println(total);
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A588 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var tempMin : int ; tempMin := 101 ;
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
     tempMin := Set{tempMin, b}->min() ; 
     total := total+(a * tempMin) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A588 {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int min=200 ;
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      int a=in.nextInt();
      int p=in.nextInt();
      if(p<min)min=p ;
      sum+=a*min ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A588 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var min : int ; min := 200 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var p : int ; p := in.getCurrent()->toInteger() ;
     if (p < min) then     min := p ; else skip ; 
     sum := sum+(a * min) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int a,b ;
    int ans=0,p=100 ;
    for(int i=0 ; i<n ; i++){
      a=in.nextInt();
      b=in.nextInt();
      p=Math.min(p,b);
      ans+=p*a ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : int ;
    var b : int ;
    var ans : int ; ans := 0 ;
    var p : int ; p := 100 ;
        var i : int ; i := 0 ; while i < n do ( (     a := in.getCurrent()->toInteger() ; 
     b := in.getCurrent()->toInteger() ; 
     p := Set{p, b}->min() ; 
     ans := ans+(p * a) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int r=sc.nextInt();
      System.out.println(solve(a,b,c,r));
    }
    sc.close();
  }
  static int solve(int a,int b,int c,int r){
    return Math.abs(a-b)-Math.max(0,Math.min(Math.max(a,b),c+r)-Math.max(Math.min(a,b),c-r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(solve(a, b, c, r)) ; 
 )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : int, b : int, c : int, r : int) : int
  pre: true
  post: true
  activity: (     return if a - b < 0 then -(a - b) else a - b endif - Set{0, Set{Set{a, b}->max(), c + r}->min() - Set{Set{a, b}->min(), c - r}->max()}->max() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int n=in.nextInt();
      int[] a=new int[n];
      int[] b=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
        b[i]=in.nextInt();
      }
      int k=b[0],s=0 ;
      for(int i=0 ; i<n ; i++){
        if(k<=b[i])s=s+a[i]*k ;
        else {
          k=b[i];
          s=s+a[i]*k ;
        }
      }
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     b[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var k : int ; k := b[0+1] ;
    var s : int ; s := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (k <= b[i+1]) then     s := s + a[i+1] * k ; else (     k := b[i+1] ; 
     s := s + a[i+1] * k ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication102 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayList<Integer>arrNum=new ArrayList<>();
    ArrayList<Integer>arrPrice=new ArrayList<>();
    int num=sc.nextInt();
    int counter=0 ;
    for(int i=0 ; i<num ; i++){
      arrNum.add(sc.nextInt());
      arrPrice.add(sc.nextInt());
    }
    int old=arrPrice.get(0);
    for(int i=0 ; i<num ; i++){
      if(arrPrice.get(i)<old){
        old=arrPrice.get(i);
      }
      counter+=arrNum.get(i)*old ;
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication102 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arrNum : Sequence(int) ; arrNum := Sequence{} ;
    var arrPrice : Sequence(int) ; arrPrice := Sequence{} ;
    var num : int ; num := sc.getCurrent()->toInteger() ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < num do ( (     arrNum := arrNum->including(sc.getCurrent()->toInteger()) ; 
     arrPrice := arrPrice->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var old : int ; old := arrPrice->at(0+1) ;
        var i : int ; i := 0 ; while i < num do ( (     if (arrPrice->at(i+1) < old) then (     old := arrPrice->at(i+1) ) else skip ; 
     counter := counter+(arrNum->at(i+1) * old) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p085 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p085().run());
  }
  private static final int TARGET=2000000 ;
  public String run(){
    int bestDiff=Integer.MAX_VALUE ;
    int bestArea=-1 ;
    int sqrt=Library.sqrt(TARGET);
    for(int w=1 ; w<=sqrt ; w++){
      for(int h=1 ; h<=sqrt ; h++){
        int diff=Math.abs(numberOfRectangles(w,h)-TARGET);
        if(diff<bestDiff){
          bestDiff=diff ;
          bestArea=w*h ;
        }
      }
    }
    return Integer.toString(bestArea);
  }
  private static int numberOfRectangles(int m,int n){
    return(m+1)*m*(n+1)*n/4 ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p085 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p085.newp085().run()) );
  static    attribute TARGET : int := 2000000;
   operation run() : String
  pre: true
  post: true
  activity: (     var bestDiff : int ; bestDiff := 2147483647 ;
     var bestArea : int ; bestArea := -1 ;
    var sqrt : int ; sqrt := Library.sqrt(TARGET) ;
        var w : int ; w := 1 ; while w <= sqrt do ( (         var h : int ; h := 1 ; while h <= sqrt do ( (     var diff : int ; diff := if numberOfRectangles(w, h) - TARGET < 0 then -(numberOfRectangles(w, h) - TARGET) else numberOfRectangles(w, h) - TARGET endif ;
     if (diff < bestDiff) then (     bestDiff := diff ; 
     bestArea := w * h ) else skip )  ;     h := h + 1 ) )  ;     w := w + 1 ) ; 
    return ((bestArea) + "") 
 );
  static   operation numberOfRectangles( m : int, n : int) : int
  pre: true
  post: true
  activity: (     return (m + 1) * m * (n + 1) * n / 4 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class x {
  static int fla(int p,int q){
    int ti=2*q-p ;
    int tj=2*p-q ;
    if(ti % 3!=0 || tj % 3!=0)return 0 ;
    ti/=3 ;
    tj/=3 ;
    return 0 ;
  };
  public static void main(String args[])throws Exception {
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int tt=1 ; tt<=t ; tt++){
      int h=in.nextInt();
      int w=in.nextInt();
      int r=in.nextInt();
      int[] a=new int[r],b=new int[r];
      boolean[][] f=new boolean[h+1][w+1];
      for(int i=0 ; i<r ; i++){
        a[i]=in.nextInt();
        b[i]=in.nextInt();
        f[a[i] ][b[i] ]=true ;
      };
      int[][] D=new int[h+1][w+1];
      D[1][1]=1 ;
      for(int i=2 ; i<=h ; i++)for(int j=2 ; j<=w ; j++)if(! f[i][j])D[i][j]+=(D[i-2][j-1]+D[i-1][j-2])% 10007 ;
      System.out.println("Case #"+tt+": "+D[h][w]);
    };
  };
};
------------------------------------------------------------
OCL File:
---------
 class x {
  static   operation fla( p : int, q : int) : int
  pre: true
  post: true
  activity: (     var ti : int ; ti := 2 * q - p ;
     var tj : int ; tj := 2 * p - q ;
    if (ti mod 3 /= 0 or tj mod 3 /= 0) then     return 0 else skip ; 
    ti := ti/(3) ; 
    tj := tj/(3) ; 
    return 0 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var tt : int ; tt := 1 ; while tt <= t do ( (     var h : int ; h := in.getCurrent()->toInteger() ;
     var w : int ; w := in.getCurrent()->toInteger() ;
    var r : int ; r := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,r)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,r)->collect(0) ;
    var f : Sequence(Sequence(boolean)) ; f := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(false)) ;
        var i : int ; i := 0 ; while i < r do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     b[i+1] := in.getCurrent()->toInteger() ; 
     f[a[i+1]+1][b[i+1]+1] := true )  ;     i := i + 1 ) ; 
    var D : Sequence(Sequence(int)) ; D := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(0)) ;
    D[1+1][1+1] := 1 ; 
        var i : int ; i := 2 ; while i <= h do (         var j : int ; j := 2 ; while j <= w do (     if (not(f[i+1][j+1])) then     D[i+1][j+1] := D[i+1][j+1]+((D[i - 2+1][j - 1+1] + D[i - 1+1][j - 2+1]) mod 10007) ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Case #" + tt + ": " + D[h+1][w+1]) ; 
 )  ;     tt := tt + 1 ) ; 
  );
}
;

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static void isSubsetAndZero(int array[],int length,int N){
    int arrAnd=array[0];
    for(int i=1 ; i<length ; i++){
      arrAnd=arrAnd & array[i];
    }
    if((arrAnd & N)==0)System.out.println("YES");
    else System.out.println("NO");
  }
  public static void main(String[] args){
    int array[]={
      1,2,4 };
      int length=array.length ;
      int N=3 ;
      isSubsetAndZero(array,length,N);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isSubsetAndZero( array : Sequence(int), length : int, N : int) : void
  pre: true
  post: true
  activity: (     var arrAnd : int ; arrAnd := array[0+1] ;
         var i : int ; i := 1 ; while i < length do ( (     arrAnd := MathLib.bitwiseAnd(arrAnd,array[i+1]) )  ;     i := i + 1 ) ; 
     if ((MathLib.bitwiseAnd(arrAnd,N)) = 0) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Sequence{1,2,4} ;
     var length : int ; length := array->size() ;
     var N : int ; N := 3 ;
     execute isSubsetAndZero(array, length, N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    long A=scanner.nextLong();
    long B=scanner.nextLong();
    int[] X=new int[N];
    for(int i=0 ; i<N ; i++)X[i]=scanner.nextInt();
    long cost=0 ;
    for(int i=1 ; i<N ; i++)cost+=Math.min(A*(X[i]-X[i-1]),B);
    System.out.println(cost);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var A : long ; A := scanner.getCurrent()->toLong() ;
    var B : long ; B := scanner.getCurrent()->toLong() ;
    var X : Sequence(int) ; X := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     X[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var cost : long ; cost := 0 ;
        var i : int ; i := 1 ; while i < N do (     cost := cost+(Set{A * (X[i+1] - X[i - 1+1]), B}->min()) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cost) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=false ;
  private static PrintWriter _out=new PrintWriter(System.out);
  private static PrintWriter _err=new PrintWriter(System.err);
  private int n ;
  private long a ;
  private long b ;
  private long[] x ;
  private void solve(Scanner sc){
    n=sc.nextInt();
    a=sc.nextLong();
    b=sc.nextLong();
    x=new long[n];
    for(int i=0 ; i<n ; ++i){
      x[i]=sc.nextLong();
    }
    long cost=0 ;
    for(int i=0 ; i<n-1 ; ++i){
      if((x[i+1]-x[i])*a>b){
        cost+=b ;
      }
      else {
        cost+=(x[i+1]-x[i])*a ;
      }
    }
    _out.println(cost);
  }
  private long C(long n,long r){
    long res=1 ;
    for(long i=n ; i>n-r ; --i){
      res*=i ;
    }
    for(long i=r ; i>1 ; --i){
      res/=i ;
    }
    return res ;
  }
  private long P(long n,long r){
    long res=1 ;
    for(long i=n ; i>n-r ; --i){
      res*=i ;
    }
    return res ;
  }
  public static void main(String[] args){
    long S=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    new Main().solve(sc);
    _out.flush();
    long G=System.currentTimeMillis();
    if(elapsed){
      _err.println((G-S)+"ms");
    }
    _err.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := false;
  static   attribute _out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute _err : OclFile := OclFile.newOclFile_Write(OclFile["System.err"]);
   attribute n : int;
   attribute a : long;
   attribute b : long;
   attribute x : Sequence(long);
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     n := sc.nextInt() ; 
     a := sc.nextLong() ; 
    b := sc.nextLong() ; 
    x := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.nextLong() )  ;     i := i + 1 ) ; 
    var cost : long ; cost := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if ((x[i + 1+1] - x[i+1]) * a > b) then (     cost := cost+(b) ) else (     cost := cost+((x[i + 1+1] - x[i+1]) * a) ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation C( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res*(i) )  ;     i := i - 1 ) ; 
         var i : long ; i := r ; while i > 1 do ( (     res := res/(i) )  ;     i := i - 1 ) ; 
     return res );
   operation P( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res*(i) )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    Main.newMain().solve(sc) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static MyScanner scanner ;
  public static void main(String[] args){
    Main instance=new Main();
    scanner=instance.new MyScanner();
    instance.solve();
  }
  private void solve(){
    try {
      int N=scanner.nextInt();
      long[] x=new long[N];
      long A=scanner.nextLong();
      long B=scanner.nextLong();
      for(int i=0 ; i<N ; i++){
        x[i]=scanner.nextLong();
      }
      long tired=0l,now=x[0];
      for(int i=1 ; i<N ; i++){
        if((x[i]-now)*A<B){
          tired+=A*(x[i]-now);
        }
        else {
          tired+=B ;
        }
        now=x[i];
      }
      System.out.println(tired);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  private class MyScanner {
    String[] s ;
    int i ;
    BufferedReader br ;
    String reg=" " ;
    MyScanner(){
      s=new String[0];
      i=0 ;
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public String next()throws IOException {
      if(i<s.length)return s[i++];
      String line=br.readLine();
      while(line.equals("")){
        line=br.readLine();
      }
      s=line.split(reg,0);
      i=0 ;
      return s[i++];
    }
    public int nextInt()throws NumberFormatException,IOException {
      return Integer.parseInt(next());
    }
    public double nextDouble()throws NumberFormatException,IOException {
      return Double.parseDouble(next());
    }
    public long nextLong()throws NumberFormatException,IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : MyScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var instance : Main ; instance := Main.newMain() ;
     scanner := (instance).newMyScanner() ; 
     instance.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     try (     var N : int ; N := scanner.nextInt() ;
     var x : Sequence(long) ; x := Integer.subrange(1,N)->collect(0) ;
    var A : long ; A := scanner.nextLong() ;
    var B : long ; B := scanner.nextLong() ;
        var i : int ; i := 0 ; while i < N do ( (     x[i+1] := scanner.nextLong() )  ;     i := i + 1 ) ; 
    var tired : long ; tired := 0l ;
    var now : long ; now := x[0+1] ;
        var i : int ; i := 1 ; while i < N do ( (     if ((x[i+1] - now) * A < B) then (     tired := tired+(A * (x[i+1] - now)) ) else (     tired := tired+(B) ) ;  
     now := x[i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(tired) ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
 class MyScanner {
   attribute s : Sequence(String);
   attribute i : int;
   attribute br : OclFile;
   attribute reg : String := " ";
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     s := Integer.subrange(1,0)->collect(null) ; 
     i := 0 ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (i < s->size()) then     return s[i+1] else skip ; 
     var line : String ; line := br.readLine() ;
    while (line = "") do (     line := br.readLine() ) ; 
    s := line->split(reg) ; 
    i := 0 ; 
    return s[i+1] 
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    String str=input.readLine();
    String[] nab=str.split(" ");
    int n=Integer.parseInt(nab[0]);
    long a=Long.parseLong(nab[1]);
    long b=Long.parseLong(nab[2]);
    str=input.readLine();
    String[] strx=str.split(" ");
    long[] x=new long[n];
    for(int i=0 ; i<n ; i++){
      x[i]=Long.parseLong(strx[i]);
    }
    long answer=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if((x[i+1]-x[i])*a>b){
        answer=answer+b ;
      }
      else {
        answer=answer+(x[i+1]-x[i])*a ;
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := input.readLine() ;
    var nab : Sequence(String) ; nab := str->split(" ") ;
    var n : int ; n := (nab[0+1])->toInteger() ;
    var a : long ; a := (nab[1+1])->toLong() ;
    var b : long ; b := (nab[2+1])->toLong() ;
    str := input.readLine() ; 
    var strx : Sequence(String) ; strx := str->split(" ") ;
    var x : Sequence(long) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := (strx[i+1])->toLong() )  ;     i := i + 1 ) ; 
    var answer : long ; answer := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if ((x[i + 1+1] - x[i+1]) * a > b) then (     answer := answer + b ) else (     answer := answer + (x[i + 1+1] - x[i+1]) * a ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[])throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int cities[]=new int[n];
    for(int i=0 ; i<n ; i++)cities[i]=sc.nextInt();
    long minCost=0L ;
    for(int i=0 ; i<n-1 ; i++){
      int dist=cities[i+1]-cities[i];
      minCost+=Math.min((long)dist*a,(long)b);
    }
    System.out.print(minCost);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var cities : Sequence(int) ; cities := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     cities[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var minCost : long ; minCost := 0L ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var dist : int ; dist := cities[i + 1+1] - cities[i+1] ;
     minCost := minCost+(Set{dist->oclAsType(long) * a, b->oclAsType(long)}->min()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(minCost) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      while(n-->0){
        int e=sc.nextInt();
        int s=sc.nextInt();
        int t=sc.nextInt();
        int temp=Math.max(e-s,e-t);
        System.out.println(temp+1);
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var e : int ; e := sc.getCurrent()->toInteger() ;
     var s : int ; s := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var temp : int ; temp := Set{e - s, e - t}->max() ;
    OclFile["System.out"].println(temp + 1) ; 
 ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    int c=Integer.parseInt(sc.next());
    int k=Integer.parseInt(sc.next());
    out.println(Math.min(a,k)-Math.max(k-a-b,0));
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : int ; a := (sc.getCurrent())->toInteger() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    var c : int ; c := (sc.getCurrent())->toInteger() ;
    var k : int ; k := (sc.getCurrent())->toInteger() ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private void solve(){
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    int K=sc.nextInt();
    if(A+B>=K){
      out.println(Math.min(A,K));
    }
    else {
      out.println(A-(K-A-B));
    }
  }
  private static PrintWriter out ;
  private static MyScanner sc ;
  private static class MyScanner {
    BufferedReader br ;
    StringTokenizer st ;
    private 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());
    }
  }
  public static void main(String[] args){
    out=new PrintWriter(new BufferedOutputStream(System.out));
    sc=new MyScanner();
    new Main().solve();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var A : int ; A := sc.nextInt() ;
     var B : int ; B := sc.nextInt() ;
    var C : int ; C := sc.nextInt() ;
    var K : int ; K := sc.nextInt() ;
    if (A + B >= K) then (     out.println(Set{A, K}->min()) ) else (     out.println(A - (K - A - B)) ) ;  
 );
  static   attribute out : OclFile;
  static   attribute sc : MyScanner;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
     sc := MyScanner.newMyScanner() ; 
     Main.newMain().solve() ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    int K=sc.nextInt();
    int ans=0 ;
    int cntA=0 ;
    for(int i=0 ; i<A ; i++){
      if(cntA==K){
        break ;
      }
      ans+=1 ;
      cntA++;
    }
    int cntB=0 ;
    for(int i=0 ; i<B ; i++){
      if(cntB==K-cntA){
        break ;
      }
      ans+=0 ;
      cntB++;
    }
    int cntC=0 ;
    for(int i=0 ; i<C ; i++){
      if(cntC==K-cntA-cntB){
        break ;
      }
      ans-=1 ;
      cntC++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    var cntA : int ; cntA := 0 ;
        var i : int ; i := 0 ; while i < A do ( (     if (cntA = K) then (     break ) else skip ; 
     ans := ans+(1) ; 
     cntA := cntA + 1 )  ;     i := i + 1 ) ; 
    var cntB : int ; cntB := 0 ;
        var i : int ; i := 0 ; while i < B do ( (     if (cntB = K - cntA) then (     break ) else skip ; 
     ans := ans+(0) ; 
     cntB := cntB + 1 )  ;     i := i + 1 ) ; 
    var cntC : int ; cntC := 0 ;
        var i : int ; i := 0 ; while i < C do ( (     if (cntC = K - cntA - cntB) then (     break ) else skip ; 
     ans := ans-(1) ; 
     cntC := cntC + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String...args){
    Scanner input=new Scanner(System.in);
    long a=input.nextLong();
    long b=input.nextLong();
    long c=input.nextLong();
    long k=input.nextLong();
    int ans=0 ;
    if(k<=a){
      System.out.println(k);
      return ;
    }
    ans+=a ;
    k-=a ;
    if(k<=b){
      System.out.println(ans);
      return ;
    }
    k-=b ;
    ans-=k ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := input.getCurrent()->toLong() ;
    var b : long ; b := input.getCurrent()->toLong() ;
    var c : long ; c := input.getCurrent()->toLong() ;
    var k : long ; k := input.getCurrent()->toLong() ;
    var ans : int ; ans := 0 ;
    if (k <= a) then (     OclFile["System.out"].println(k) ; 
     return ) else skip ; 
    ans := ans+(a) ; 
    k := k-(a) ; 
    if (k <= b) then (     OclFile["System.out"].println(ans) ; 
     return ) else skip ; 
    k := k-(b) ; 
    ans := ans-(k) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int doublefactorial(int n){
    int res=1 ;
    for(int i=n ; i>=0 ; i=i-2){
      if(i==0 || i==1)return res ;
      else res*=i ;
    }
    return res ;
  }
  public static void main(String[] args){
    System.out.println("Double factorial"+" is "+doublefactorial(5));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation doublefactorial( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
         var i : int ; i := n ; while i >= 0 do ( (     if (i = 0 or i = 1) then     return res else     res := res*(i) ; )  ;     i := i - 2 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Double factorial" + " is " + doublefactorial(5)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    long A=scan.nextLong();
    long B=scan.nextLong();
    long C=scan.nextLong();
    long K=scan.nextLong();
    long N ;
    if(K<=A){
      N=K ;
    }
    else if(K<=A+B){
      N=A ;
    }
    else {
      N=A-K+A+B ;
    }
    System.out.println(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : long ; A := scan.getCurrent()->toLong() ;
    var B : long ; B := scan.getCurrent()->toLong() ;
    var C : long ; C := scan.getCurrent()->toLong() ;
    var K : long ; K := scan.getCurrent()->toLong() ;
    var N : long ;
    if (K <= A) then (     N := K ) else     if (K <= A + B) then (     N := A ) else (     N := A - K + A + B ) ;  ;  
    OclFile["System.out"].println(N) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int answerQuery(int a[],int n,int l,int r){
    int count=0 ;
    l=l-1 ;
    for(int i=l ; i<r ; i++){
      int element=a[i];
      int divisors=0 ;
      for(int j=l ; j<r ; j++){
        if(a[j] % a[i]==0)divisors++;
        else break ;
      }
      if(divisors==(r-l))count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int a[]={
      1,2,3,5 };
      int n=a.length ;
      int l=1,r=4 ;
      System.out.println(answerQuery(a,n,l,r));
      l=2 ;
      r=4 ;
      System.out.println(answerQuery(a,n,l,r));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation answerQuery( a : Sequence(int), n : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     l := l - 1 ; 
         var i : int ; i := l ; while i < r do ( (     var element : int ; element := a[i+1] ;
     var divisors : int ; divisors := 0 ;
         var j : int ; j := l ; while j < r do ( (     if (a[j+1] mod a[i+1] = 0) then     divisors := divisors + 1 ; else     break )  ;     j := j + 1 ) ; 
     if (divisors = (r - l)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,5} ;
     var n : int ; n := a->size() ;
    var l : int ; l := 1 ;
    var r : int ; r := 4 ;
    OclFile["System.out"].println(answerQuery(a, n, l, r)) ; 
    l := 2 ; 
    r := 4 ; 
    OclFile["System.out"].println(answerQuery(a, n, l, r)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printUncommon(int arr1[],int arr2[],int n1,int n2){
    int i=0,j=0,k=0 ;
    while(i<n1 && j<n2){
      if(arr1[i]<arr2[j]){
        System.out.print(arr1[i]+" ");
        i++;
        k++;
      }
      else if(arr2[j]<arr1[i]){
        System.out.print(arr2[j]+" ");
        k++;
        j++;
      }
      else {
        i++;
        j++;
      }
    }
    while(i<n1){
      System.out.print(arr1[i]+" ");
      i++;
      k++;
    }
    while(j<n2){
      System.out.print(arr2[j]+" ");
      j++;
      k++;
    }
  }
  public static void main(String[] args){
    int arr1[]={
      10,20,30 };
      int arr2[]={
        20,25,30,40,50 };
        int n1=arr1.length ;
        int n2=arr2.length ;
        printUncommon(arr1,arr2,n1,n2);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printUncommon( arr1 : Sequence(int), arr2 : Sequence(int), n1 : int, n2 : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    var k : int ; k := 0 ;
     while (i < n1 & j < n2) do (     if (arr1[i+1] < arr2[j+1]) then (     OclFile["System.out"].print(arr1[i+1] + " ") ; 
     i := i + 1 ; 
     k := k + 1 ) else     if (arr2[j+1] < arr1[i+1]) then (     OclFile["System.out"].print(arr2[j+1] + " ") ; 
     k := k + 1 ; 
     j := j + 1 ) else (     i := i + 1 ; 
     j := j + 1 ) ;  ) ; 
     while (i < n1) do (     OclFile["System.out"].print(arr1[i+1] + " ") ; 
     i := i + 1 ; 
     k := k + 1 ) ; 
     while (j < n2) do (     OclFile["System.out"].print(arr2[j+1] + " ") ; 
     j := j + 1 ; 
     k := k + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{10,20,30} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{20,25,30,40,50} ;
    var n1 : int ; n1 := arr1->size() ;
    var n2 : int ; n2 := arr2->size() ;
    execute printUncommon(arr1, arr2, n1, n2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TwoDots {
  static int dx[]={
    0,1,0,-1 };
    static int dy[]={
      1,0,-1,0 };
      public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int m=in.nextInt();
        char[][] grid=new char[n][m];
        for(int i=0 ; i<n ; i++){
          grid[i]=in.next().toCharArray();
        }
        boolean[][] visited=new boolean[n][m];
        for(int i=0 ; i<n ; i++){
          for(int j=0 ; j<m ; j++){
            if(! visited[i][j] && dfs(i,j,grid,visited,-1,-1,grid[i][j])){
              System.out.println("Yes");
              return ;
            }
          }
        }
        System.out.println("No");
      }
      public static boolean dfs(int r,int c,char[][] grid,boolean[][] visited,int prevR,int prevC,char color){
        visited[r][c]=true ;
        for(int i=0 ; i<4 ; i++){
          int x=r+dx[i];
          int y=c+dy[i];
          if(x<0 || x>=grid.length || y<0 || y>=grid[0] .length || grid[x][y]!=color){
            continue ;
          }
          if(x==prevR && y==prevC)continue ;
          if(visited[x][y])return true ;
          if(dfs(x,y,grid,visited,r,c,color))return true ;
        }
        return false ;
      }
    }

------------------------------------------------------------
OCL File:
---------
 class TwoDots {
  static   attribute dx : int := Sequence{0,1,0,-1};
  static   attribute dy : int := Sequence{1,0,-1,0};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var grid : Sequence(Sequence(String)) ; grid := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     grid[i+1] := in.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    var visited : Sequence(Sequence(boolean)) ; visited := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(false)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (not(visited[i+1][j+1]) & dfs(i, j, grid, visited, -1, -1, grid[i+1][j+1])) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("No") ; 
 );
  static   operation dfs( r : int, c : int, grid : Sequence(Sequence(String)), visited : Sequence(Sequence(boolean)), prevR : int, prevC : int, color : String) : boolean
  pre: true
  post: true
  activity: (     visited[r+1][c+1] := true ; 
         var i : int ; i := 0 ; while i < 4 do ( (     var x : int ; x := r + dx[i+1] ;
     var y : int ; y := c + dy[i+1] ;
    if (x < 0 or x >= grid->size() or y < 0 or y >= grid[0+1]->size() or grid[x+1][y+1] /= color) then (     continue ) else skip ; 
    if (x = prevR & y = prevC) then     continue else skip ; 
    if (visited[x+1][y+1]) then     return true else skip ; 
    if (dfs(x, y, grid, visited, r, c, color)) then     return true else skip ; 
 )  ;     i := i + 1 ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    sc.nextLine();
    char arr[][]=new char[n][m];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextLine().toCharArray();
    }
    boolean visited[][]=new boolean[n][m];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(visited[i][j]==false){
          if(solve(arr,i,j,visited,1,-1,-1)){
            System.out.println("Yes");
            return ;
          }
        }
      }
    }
    System.out.println("No");
  }
  static int dir[][]={
    {
      0,1 },{
        1,0 },{
-1,0 },{
            0,-1 }
          };
          public static boolean solve(char arr[][],int i,int j,boolean visited[][],int size,int parentI,int parentJ){
            visited[i][j]=true ;
            for(int a[] : dir){
              int idx=a[0]+i ;
              int jdx=a[1]+j ;
              if(idx>=0 && jdx>=0 && idx<arr.length && jdx<arr[idx] .length && arr[idx][jdx]==arr[i][j]){
                if(visited[idx][jdx]==false){
                  if(solve(arr,idx,jdx,visited,size+1,i,j)){
                    return true ;
                  }
                }
                else if((parentI!=idx || parentJ!=jdx)&& size>=4){
                  return true ;
                }
              }
            }
            return false ;
          }
        }

------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    skip ; 
    var arr : Sequence(Sequence(String)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.nextLine()->characters() )  ;     i := i + 1 ) ; 
    var visited : Sequence(Sequence(boolean)) ; visited := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(false)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (visited[i+1][j+1] = false) then (     if (solve(arr, i, j, visited, 1, -1, -1)) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("No") ; 
 );
  static   attribute dir : int := Sequence{Sequence{0,1},Sequence{1,0},Sequence{-1,0},Sequence{0,-1}};
  static   operation solve( arr : Sequence(Sequence(String)), i : int, j : int, visited : Sequence(Sequence(boolean)), size : int, parentI : int, parentJ : int) : boolean
  pre: true
  post: true
  activity: (     visited[i+1][j+1] := true ; 
     for (a : dir) do ( (     var idx : int ; idx := a[0+1] + i ;
     var jdx : int ; jdx := a[1+1] + j ;
     if (idx >= 0 & jdx >= 0 & idx < arr->size() & jdx < arr[idx+1]->size() & arr[idx+1][jdx+1] = arr[i+1][j+1]) then (     if (visited[idx+1][jdx+1] = false) then (     if (solve(arr, idx, jdx, visited, size + 1, i, j)) then (     return true ) else skip ) else     if ((parentI /= idx or parentJ /= jdx) & size >= 4) then (     return true ) else skip ; ) else skip )  ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class298 {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int p=sc.nextInt();
    while(p-->0){
      int n=sc.nextInt();
      int s=sc.nextInt();
      int t=sc.nextInt();
      System.out.println(Math.max(n-s,n-t)+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class298 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : int ; p := sc.getCurrent()->toInteger() ;
         while (p > 0) do (        p := p - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(Set{n - s, n - t}->max() + 1) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static boolean isPrime(int x){
    if(x==0 || x==1)return false ;
    for(int i=2 ; i*i<=x ; ++i)if(x % i==0)return false ;
    return true ;
  }
  public static void findPrimes(int n){
    if(isPrime(n))System.out.print(n);
    else if(isPrime(n-2))System.out.print(2+" "+(n-2));
    else {
      System.out.print(3+" ");
      n=n-3 ;
      for(int i=0 ; i<n ; i++){
        if(isPrime(i)&& isPrime(n-i)){
          System.out.print(i+" "+(n-i));
          break ;
        }
      }
    }
  }
  public static void main(String[] args){
    int n=27 ;
    findPrimes(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPrime( x : int) : boolean
  pre: true
  post: true
  activity: (     if (x = 0 or x = 1) then     return false else skip ; 
         var i : int ; i := 2 ; while i * i <= x do (     if (x mod i = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation findPrimes( n : int) : void
  pre: true
  post: true
  activity: (     if (isPrime(n)) then     OclFile["System.out"].print(n) ; else     if (isPrime(n - 2)) then     OclFile["System.out"].print(2 + " " + (n - 2)) else (     OclFile["System.out"].print(3 + " ") ; 
     n := n - 3 ; 
         var i : int ; i := 0 ; while i < n do ( (     if (isPrime(i) & isPrime(n - i)) then (     OclFile["System.out"].print(i + " " + (n - i)) ; 
     break ) else skip )  ;     i := i + 1 ) ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 27 ;
     execute findPrimes(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Pedestal {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      int a,b,c ;
      if(n % 3==0){
        int div=n/3 ;
        a=div+1 ;
        b=a-1 ;
        c=n-(a+b);
        if(b==c){
          b+=1 ;
          c-=1 ;
        }
      }
      else {
        int div=n/3 ;
        a=div+2 ;
        b=a-2 ;
        c=n-(a+b);
        if(b==c){
          b+=1 ;
          c-=1 ;
        }
      }
      System.out.println(b+" "+a+" "+c);
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Pedestal {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : int ;
    var b : int ;
    var c : int ;
    if (n mod 3 = 0) then (     var div : int ; div := n / 3 ;
     a := div + 1 ; 
    b := a - 1 ; 
    c := n - (a + b) ; 
    if (b = c) then (     b := b+(1) ; 
     c := c-(1) ) else skip ; 
 ) else (     var div : int ; div := n / 3 ;
     a := div + 2 ; 
    b := a - 2 ; 
    c := n - (a + b) ; 
    if (b = c) then (     b := b+(1) ; 
     c := c-(1) ) else skip ; 
 ) ;  
    OclFile["System.out"].println(b + " " + a + " " + c) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test196 {
  public static void main(String s[]){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      if(n % 3==0){
        System.out.println((n/3)+" "+(n/3+1)+" "+(n/3-1));
      }
      else if(n % 3==1){
        System.out.println((n/3)+" "+(n/3+2)+" "+(n/3-1));
      }
      else {
        System.out.println((n/3+1)+" "+(n/3+2)+" "+(n/3-1));
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test196 {
  static   operation main( s : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n mod 3 = 0) then (     OclFile["System.out"].println((n / 3) + " " + (n / 3 + 1) + " " + (n / 3 - 1)) ) else     if (n mod 3 = 1) then (     OclFile["System.out"].println((n / 3) + " " + (n / 3 + 2) + " " + (n / 3 - 1)) ) else (     OclFile["System.out"].println((n / 3 + 1) + " " + (n / 3 + 2) + " " + (n / 3 - 1)) ) ;  )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1690A_PrintPedestal {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int blocks=parseInt(input.nextLine());
      final int divide=blocks/3 ;
      int first=divide ;
      int second=divide ;
      int third=divide ;
      final int remained=blocks % 3 ;
      if(remained==0){
        second++;
      }
      else if(remained==1){
        second+=2 ;
      }
      else {
        first++;
        second+=2 ;
      }
      third--;
      System.out.printf("%d %d %d\n",first,second,third);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1690A_PrintPedestal {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var blocks : int ; blocks := parseInt(input.nextLine()) ;
     var divide : int ; divide := blocks / 3 ;
    var first : int ; first := divide ;
    var second : int ; second := divide ;
    var third : int ; third := divide ;
    var remained : int ; remained := blocks mod 3 ;
    if (remained = 0) then (     second := second + 1 ) else     if (remained = 1) then (     second := second+(2) ) else (     first := first + 1 ; 
     second := second+(2) ) ;  ;  
    third := third - 1 ; 
    OclFile["System.out"].printf("%d %d %d\n", first, second, third) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public Main(){
    int t=sc.nextInt();
    sc.nextLine();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      sc.nextLine();
      int fs=(n/3);
      int sc=(n/3);
      int th=(n/3)+(n % 3);
      while(!(fs>sc && sc>th)){
        th--;
        if(sc+1<fs)sc++;
        else fs++;
      }
      System.out.println(sc+" "+fs+" "+th);
    }
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
     skip ; 
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     skip ; 
    var fs : int ; fs := (n / 3) ;
    var sc : int ; sc := (n / 3) ;
    var th : int ; th := (n / 3) + (n mod 3) ;
    while (not((fs > sc & sc > th))) do (     th := th - 1 ; 
     if (sc + 1 < fs) then     sc := sc + 1 ; else     fs := fs + 1 ; ) ; 
    OclFile["System.out"].println(sc + " " + fs + " " + th) ; 
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static void main(String args[]){
    float x1=2,x2=1,x3=3 ;
    float y1=2,y2=1,y3=1 ;
    float a=2,b=1,c=1 ;
    float x=(a*x1+b*x2+c*x3)/(a+b+c);
    float y=(a*y1+b*y2+c*y3)/(a+b+c);
    System.out.println("Incenter="+"("+x+","+y+")");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x1 : double ; x1 := 2 ;
    var x2 : double ; x2 := 1 ;
    var x3 : double ; x3 := 3 ;
     var y1 : double ; y1 := 2 ;
    var y2 : double ; y2 := 1 ;
    var y3 : double ; y3 := 1 ;
    var a : double ; a := 2 ;
    var b : double ; b := 1 ;
    var c : double ; c := 1 ;
    var x : double ; x := (a * x1 + b * x2 + c * x3) / (a + b + c) ;
    var y : double ; y := (a * y1 + b * y2 + c * y3) / (a + b + c) ;
    OclFile["System.out"].println("Incenter=" + "(" + x + "," + y + ")") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class App {
  public class ListNode {
    int val ;
    ListNode next ;
    public ListNode(){
    }
    public ListNode(int val){
      this.val=val ;
    }
    ListNode(int val,ListNode next){
      this.val=val ;
      this.next=next ;
    }
  }
  public static int dist(int x1,int y1,int x2,int y2){
    return(x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
  }
  public static int check(int x,int y){
    for(int index=0 ; index<n ; index++){
      if(dist(x,y,xPos[index],yPos[index])<=raduis[index]*raduis[index]){
        return 0 ;
      }
    }
    return 1 ;
  }
  static int n ;
  static int[] xPos ;
  static int[] yPos ;
  static int[] raduis ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int xa=in.nextInt();
    int ya=in.nextInt();
    int xb=in.nextInt();
    int yb=in.nextInt();
    n=in.nextInt();
    xPos=new int[n];
    yPos=new int[n];
    raduis=new int[n];
    for(int index=0 ; index<n ; index++){
      xPos[index]=in.nextInt();
      yPos[index]=in.nextInt();
      raduis[index]=in.nextInt();
    }
    int ans=0 ;
    for(int index=Math.min(xa,xb); index<=Math.max(xa,xb); index++){
      ans+=check(index,ya)+check(index,yb);
    }
    for(int index=Math.min(ya,yb)+1 ; index<Math.max(ya,yb); index++){
      ans+=check(xa,index)+check(xb,index);
    }
    System.out.println(ans);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
 class ListNode {
   attribute val : int;
   attribute next : ListNode;
   static operation newListNode() : ListNode
  pre: true
  post: true
  activity:
  ( var self : ListNode ;
    self := createListNode();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   static operation newListNode( val : int) : ListNode
  pre: true
  post: true
  activity:
  ( var self : ListNode ;
    self := createListNode();
    self.initialise(val);
    return self );
  operation initialise( val : int) : void
  pre: true  post: true
  activity: (     self.val := val );
   static operation newListNode( val : int, next : ListNode) : ListNode
  pre: true
  post: true
  activity:
  ( var self : ListNode ;
    self := createListNode();
    self.initialise(val, next);
    return self );
  operation initialise( val : int, next : ListNode) : void
  pre: true  post: true
  activity: (     self.val := val ; 
     self.next := next );
}
  static   operation dist( x1 : int, y1 : int, x2 : int, y2 : int) : int
  pre: true
  post: true
  activity: (     return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) );
  static   operation check( x : int, y : int) : int
  pre: true
  post: true
  activity: (         var index : int ; index := 0 ; while index < n do ( (     if (dist(x, y, xPos[index+1], yPos[index+1]) <= raduis[index+1] * raduis[index+1]) then (     return 0 ) else skip )  ;     index := index + 1 ) ; 
     return 1 );
  static   attribute n : int;
  static   attribute xPos : Sequence(int);
  static   attribute yPos : Sequence(int);
  static   attribute raduis : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var xa : int ; xa := in.getCurrent()->toInteger() ;
    var ya : int ; ya := in.getCurrent()->toInteger() ;
    var xb : int ; xb := in.getCurrent()->toInteger() ;
    var yb : int ; yb := in.getCurrent()->toInteger() ;
    n := in.getCurrent()->toInteger() ; 
    xPos := Integer.subrange(1,n)->collect(0) ; 
    yPos := Integer.subrange(1,n)->collect(0) ; 
    raduis := Integer.subrange(1,n)->collect(0) ; 
        var index : int ; index := 0 ; while index < n do ( (     xPos[index+1] := in.getCurrent()->toInteger() ; 
     yPos[index+1] := in.getCurrent()->toInteger() ; 
     raduis[index+1] := in.getCurrent()->toInteger() )  ;     index := index + 1 ) ; 
    var ans : int ; ans := 0 ;
        var index : int ; index := Set{xa, xb}->min() ; while index <= Set{xa, xb}->max() do ( (     ans := ans+(check(index, ya) + check(index, yb)) )  ;     index := index + 1 ) ; 
        var index : int ; index := Set{ya, yb}->min() + 1 ; while index < Set{ya, yb}->max() do ( (     ans := ans+(check(xa, index) + check(xb, index)) )  ;     index := index + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class solve {
  public static void main(String[] args){
    Scanner abd=new Scanner(System.in);
    int x1=abd.nextInt();
    int y1=abd.nextInt(),s=0 ;
    int x2=abd.nextInt();
    int y2=abd.nextInt();
    int n=abd.nextInt();
    int[] x=new int[n];
    int[] y=new int[n];
    int[] r=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=abd.nextInt();
      y[i]=abd.nextInt();
      r[i]=abd.nextInt();
    }
    for(int i=Math.min(x1,x2); i<=Math.max(x1,x2); i++){
      s+=rad(i,y1,x,y,r)+rad(i,y2,x,y,r);
    }
    for(int i=(Math.min(y1,y2))+1 ; i<Math.max(y1,y2); i++){
      s+=rad(x1,i,x,y,r)+rad(x2,i,x,y,r);
    }
    System.out.println(s);
  }
  public static int dis(int x1,int y1,int x2,int y2){
    return(x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
  }
  public static int rad(int x1,int y1,int[] x,int[] y,int[] r){
    for(int i=0 ; i<x.length ; i++){
      if(dis(x1,y1,x[i],y[i])<=r[i]*r[i]){
        return 0 ;
      }
    }
    return 1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class solve {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var abd : OclFile ; abd := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : int ; x1 := abd.getCurrent()->toInteger() ;
    var y1 : int ; y1 := abd.getCurrent()->toInteger() ;
    var s : int ; s := 0 ;
    var x2 : int ; x2 := abd.getCurrent()->toInteger() ;
    var y2 : int ; y2 := abd.getCurrent()->toInteger() ;
    var n : int ; n := abd.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := abd.getCurrent()->toInteger() ; 
     y[i+1] := abd.getCurrent()->toInteger() ; 
     r[i+1] := abd.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := Set{x1, x2}->min() ; while i <= Set{x1, x2}->max() do ( (     s := s+(rad(i, y1, x, y, r) + rad(i, y2, x, y, r)) )  ;     i := i + 1 ) ; 
        var i : int ; i := (Set{y1, y2}->min()) + 1 ; while i < Set{y1, y2}->max() do ( (     s := s+(rad(x1, i, x, y, r) + rad(x2, i, x, y, r)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 );
  static   operation dis( x1 : int, y1 : int, x2 : int, y2 : int) : int
  pre: true
  post: true
  activity: (     return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) );
  static   operation rad( x1 : int, y1 : int, x : Sequence(int), y : Sequence(int), r : Sequence(int)) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < x->size() do ( (     if (dis(x1, y1, x[i+1], y[i+1]) <= r[i+1] * r[i+1]) then (     return 0 ) else skip )  ;     i := i + 1 ) ; 
     return 1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int countWays(String s){
    int count[]=new int[26];
    for(int i=0 ; i<s.length(); i++)count[s.charAt(i)-'a']++;
    count[s.charAt(0)-'a']=1 ;
    int ans=1 ;
    for(int i=0 ; i<26 ; ++i)if(count[i]!=0)ans*=count[i];
    return ans ;
  }
  public static void main(String ags[]){
    String s="acbbcc" ;
    System.out.println(countWays(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countWays( s : String) : int
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,26)->collect(0) ;
         var i : int ; i := 0 ; while i < s->size() do (     count[s->at(i+1) - ('a')->char2byte()+1] := count[s->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    count[s->at(0+1) - ('a')->char2byte()+1] := 1 ; 
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < 26 do (     if (count[i+1] /= 0) then     ans := ans*(count[i+1]) ; else skip ;  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( ags : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "acbbcc" ;
     OclFile["System.out"].println(countWays(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void sieve(int n,boolean prime[]){
    for(int p=2 ; p*p<=n ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=n ; i+=p)prime[i]=false ;
      }
    }
  }
  static void printPrimeTriplets(int n){
    boolean prime[]=new boolean[n+1];
    Arrays.fill(prime,true);
    sieve(n,prime);
    System.out.println("The prime triplets"+" from 1 to "+n+"are :");
    for(int i=2 ; i<=n-6 ; ++i){
      if(prime[i] && prime[i+2] && prime[i+6])System.out.println(i+" "+(i+2)+" "+(i+6));
      else if(prime[i] && prime[i+4] && prime[i+6])System.out.println(i+" "+(i+4)+" "+(i+6));
    }
  }
  public static void main(String args[]){
    int n=25 ;
    printPrimeTriplets(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sieve( n : int, prime : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (         var p : int ; p := 2 ; while p * p <= n do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= n do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation printPrimeTriplets( n : int) : void
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,n + 1)->collect(false) ;
     prime := prime->collect(true) ; 
    execute sieve(n, prime) ; 
    OclFile["System.out"].println("The prime triplets" + " from 1 to " + n + "are :") ; 
        var i : int ; i := 2 ; while i <= n - 6 do ( (     if (prime[i+1] & prime[i + 2+1] & prime[i + 6+1]) then     OclFile["System.out"].println(i + " " + (i + 2) + " " + (i + 6)) ; else     if (prime[i+1] & prime[i + 4+1] & prime[i + 6+1]) then     OclFile["System.out"].println(i + " " + (i + 4) + " " + (i + 6)) ; else skip ; )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 25 ;
     execute printPrimeTriplets(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class298 {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int p=sc.nextInt();
    while(p-->0){
      int n=sc.nextInt();
      int s=sc.nextInt();
      int t=sc.nextInt();
      System.out.println(Math.max(n-s,n-t)+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class298 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : int ; p := sc.getCurrent()->toInteger() ;
         while (p > 0) do (        p := p - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(Set{n - s, n - t}->max() + 1) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long countOfMultiples(long n){
    return(n/3+n/5-n/15);
  }
  static public void main(String[] args){
    System.out.println(countOfMultiples(6));
    System.out.println(countOfMultiples(16));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countOfMultiples( n : long) : long
  pre: true
  post: true
  activity: (     return (n / 3 + n / 5 - n / 15) );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(countOfMultiples(6)) ; 
     OclFile["System.out"].println(countOfMultiples(16)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isDvisibleBy12(String num){
    if(num.length()>=3){
      int d1=(int)num.charAt(num.length()-1);
      if(d1 % 2!=0)return false ;
      int d2=(int)num.charAt(num.length()-2);
      int sum=0 ;
      for(int i=0 ; i<num.length(); i++)sum+=num.charAt(i);
      return(sum % 3==0 &&(d2*10+d1)% 4==0);
    }
    else {
      int number=Integer.parseInt(num);
      return(number % 12==0);
    }
  }
  public static void main(String[] args){
    String num="12244824607284961224" ;
    if(isDvisibleBy12(num))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isDvisibleBy12( num : String) : boolean
  pre: true
  post: true
  activity: (     if (num->size() >= 3) then (     var d1 : int ; d1 := num->at(num->size() - 1+1)->oclAsType(int) ;
     if (d1 mod 2 /= 0) then     return false else skip ; 
    var d2 : int ; d2 := num->at(num->size() - 2+1)->oclAsType(int) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < num->size() do (     sum := sum+(num->at(i+1)) ;  ;     i := i + 1 ) ; 
    return (sum mod 3 = 0 & (d2 * 10 + d1) mod 4 = 0) 
 ) else (     var number : int ; number := (num)->toInteger() ;
     return (number mod 12 = 0) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : String ; num := "12244824607284961224" ;
     if (isDvisibleBy12(num)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long cal_minimum_time(long X){
    long t=0 ;
    long sum=0 ;
    while(sum<X){
      t++;
      sum=sum+t ;
    }
    return t ;
  }
  public static void main(String[] args){
    long n=6 ;
    long ans=cal_minimum_time(n);
    System.out.println("The minimum time required is : "+ans);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation cal_minimum_time( X : long) : long
  pre: true
  post: true
  activity: (     var t : long ; t := 0 ;
     var sum : long ; sum := 0 ;
     while (sum < X) do (     t := t + 1 ; 
     sum := sum + t ) ; 
     return t );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 6 ;
     var ans : long ; ans := cal_minimum_time(n) ;
     OclFile["System.out"].println("The minimum time required is : " + ans) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int solve(int a[],int b[],int n){
    int i ;
    int s=0 ;
    for(i=0 ; i<n ; i++)s+=(a[i]+b[i]);
    if(n==1)return a[0]+b[0];
    if(s % n!=0)return-1 ;
    int x=s/n ;
    for(i=0 ; i<n ; i++){
      if(a[i]>x)return-1 ;
      if(i>0){
        a[i]+=b[i-1];
        b[i-1]=0 ;
      }
      if(a[i]==x)continue ;
      int y=a[i]+b[i];
      if(i+1<n)y+=b[i+1];
      if(y==x){
        a[i]=y ;
        b[i]=0 ;
        continue ;
      }
      if(a[i]+b[i]==x){
        a[i]+=b[i];
        b[i]=0 ;
        continue ;
      }
      if(i+1<n && a[i]+b[i+1]==x){
        a[i]+=b[i+1];
        b[i+1]=0 ;
        continue ;
      }
      return-1 ;
    }
    for(i=0 ; i<n ; i++)if(b[i]!=0)return-1 ;
    return x ;
  }
  public static void main(String[] args){
    int a[]={
      6,14,21,1 };
      int b[]={
        15,7,10,10 };
        int n=a.length ;
        System.out.println(solve(a,b,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( a : Sequence(int), b : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
     var s : int ; s := 0 ;
        i := 0 ; while i < n do (     s := s+((a[i+1] + b[i+1])) ;  ;     i := i + 1 ) ; 
    if (n = 1) then     return a[0+1] + b[0+1] else skip ; 
    if (s mod n /= 0) then     return -1 else skip ; 
    var x : int ; x := s / n ;
        i := 0 ; while i < n do ( (     if (a[i+1] > x) then     return -1 else skip ; 
     if (i > 0) then (     a[i+1] := a[i+1]+(b[i - 1+1]) ; 
     b[i - 1+1] := 0 ) else skip ; 
    if (a[i+1] = x) then     continue else skip ; 
    var y : int ; y := a[i+1] + b[i+1] ;
    if (i + 1 < n) then     y := y+(b[i + 1+1]) ; else skip ; 
    if (y = x) then (     a[i+1] := y ; 
     b[i+1] := 0 ; 
     continue ) else skip ; 
    if (a[i+1] + b[i+1] = x) then (     a[i+1] := a[i+1]+(b[i+1]) ; 
     b[i+1] := 0 ; 
     continue ) else skip ; 
    if (i + 1 < n & a[i+1] + b[i + 1+1] = x) then (     a[i+1] := a[i+1]+(b[i + 1+1]) ; 
     b[i + 1+1] := 0 ; 
     continue ) else skip ; 
    return -1 
 )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do (     if (b[i+1] /= 0) then     return -1 else skip ;  ;     i := i + 1 ) ; 
    return x 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{6,14,21,1} ;
     var b : Sequence(int) ; b := Sequence{15,7,10,10} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(solve(a, b, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class c {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long x=scanner.nextLong();
    long y=scanner.nextLong();
    long m=scanner.nextLong();
    long count=0 ;
    long sum=0 ;
    long k ;
    if(x>=m || y>=m){
      System.out.println(0);
      count++;
    }
    if(x<=0 && y<=0 && count==0){
      if(m<=0){
        if(x>=m || y>=m){
          System.out.println(0);
          count++;
        }
        else {
          System.out.println(-1);
          count++;
        }
      }
      else {
        System.out.println(-1);
        count++;
      }
    }
    if(count==0){
      if((x<0 && y>0)){
        count=((-x)+y-1)/y ;
        if(count<10000){
          count=0 ;
        }
        else {
          x=x+(count*y);
        }
      }
      if(x>0 && y<0){
        long temp=x ;
        x=y ;
        y=temp ;
        count=((-x)+y-1)/y ;
        if(count<10000){
          count=0 ;
        }
        else {
          x=x+(count*y);
        }
      }
      while(sum<m){
        k=Math.min(x,y);
        sum=x+y ;
        if(k==x){
          x=x+y ;
        }
        else {
          y=x+y ;
        }
        count++;
      }
      if(count!=0){
        System.out.println(count);
      }
      else {
        System.out.println(-1);
      }
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class c {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := scanner.getCurrent()->toLong() ;
    var y : long ; y := scanner.getCurrent()->toLong() ;
    var m : long ; m := scanner.getCurrent()->toLong() ;
    var count : long ; count := 0 ;
    var sum : long ; sum := 0 ;
    var k : long ;
    if (x >= m or y >= m) then (     OclFile["System.out"].println(0) ; 
     count := count + 1 ) else skip ; 
    if (x <= 0 & y <= 0 & count = 0) then (     if (m <= 0) then (     if (x >= m or y >= m) then (     OclFile["System.out"].println(0) ; 
     count := count + 1 ) else (     OclFile["System.out"].println(-1) ; 
     count := count + 1 ) ) else (     OclFile["System.out"].println(-1) ; 
     count := count + 1 ) ) else skip ; 
    if (count = 0) then (     if ((x < 0 & y > 0)) then (     count := ((-x) + y - 1) / y ; 
     if (count < 10000) then (     count := 0 ) else (     x := x + (count * y) ) ) else skip ; 
     if (x > 0 & y < 0) then (     var temp : long ; temp := x ;
     x := y ; 
    y := temp ; 
    count := ((-x) + y - 1) / y ; 
    if (count < 10000) then (     count := 0 ) else (     x := x + (count * y) ) ;  
 ) else skip ; 
     while (sum < m) do (     k := Set{x, y}->min() ; 
     sum := x + y ; 
     if (k = x) then (     x := x + y ) else (     y := x + y ) ;  
     count := count + 1 ) ; 
     if (count /= 0) then (     OclFile["System.out"].println(count) ) else (     OclFile["System.out"].println(-1) ) ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  static int calSum(int n){
    int a=3,b=0,c=2 ;
    if(n==0)return 3 ;
    if(n==1)return 3 ;
    if(n==2)return 5 ;
    int sum=5 ;
    while(n>2){
      int d=a+b ;
      sum+=d ;
      a=b ;
      b=c ;
      c=d ;
      n--;
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=9 ;
    System.out.print(calSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calSum( n : int) : int
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var b : int ; b := 0 ;
    var c : int ; c := 2 ;
     if (n = 0) then     return 3 else skip ; 
    if (n = 1) then     return 3 else skip ; 
    if (n = 2) then     return 5 else skip ; 
    var sum : int ; sum := 5 ;
    while (n > 2) do (     var d : int ; d := a + b ;
     sum := sum+(d) ; 
    a := b ; 
    b := c ; 
    c := d ; 
    n := n - 1 ; 
 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     OclFile["System.out"].print(calSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
import java.util.ArrayList ;
public class Main {
  public static void main(String args[]){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      int n=Integer.parseInt(reader.readLine());
      int[] a=new int[n+1];
      StringTokenizer input=new StringTokenizer(reader.readLine());
      for(int i=0 ; i<n ; i++){
        a[i+1]=Integer.parseInt(input.nextToken());
      }
      int[] b=new int[n+1];
      input=new StringTokenizer(reader.readLine());
      for(int i=0 ; i<n ; i++){
        b[i+1]=Integer.parseInt(input.nextToken());
      }
      int step=n-a[n];
      int nStep=step ;
      int minM=n ;
      ArrayList<Integer>res=new ArrayList<>();
      for(int i=n-1 ; i>0 ; i--){
        if(i<step){
          if(i<nStep){
            break ;
          }
          step=nStep ;
          res.add(minM);
        }
        int curStep=i+b[i]-a[i+b[i] ];
        if(curStep<nStep){
          nStep=curStep ;
          minM=i ;
        }
        if(nStep<1){
          res.add(minM);
          break ;
        }
      }
      if(nStep>0){
        System.out.println(-1);
      }
      else {
        System.out.println(res.size()+1);
        for(int i=0 ; i<res.size(); i++){
          System.out.print(res.get(i)+" ");
        }
        System.out.print(0);
      }
    }
    catch(IOException e){
      System.err.println("Invalid input "+e.getMessage());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var n : int ; n := (reader.readLine())->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var input : OclIterator ; input := OclIterator.newOclIterator_String(reader.readLine()) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i + 1+1] := (input.next())->toInteger() )  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,n + 1)->collect(0) ;
    input := OclIterator.newOclIterator_String(reader.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i + 1+1] := (input.next())->toInteger() )  ;     i := i + 1 ) ; 
    var step : int ; step := n - a[n+1] ;
    var nStep : int ; nStep := step ;
    var minM : int ; minM := n ;
    var res : Sequence(int) ; res := Sequence{} ;
        var i : int ; i := n - 1 ; while i > 0 do ( (     if (i < step) then (     if (i < nStep) then (     break ) else skip ; 
     step := nStep ; 
     res := res->including(minM) ) else skip ; 
     var curStep : int ; curStep := i + b[i+1] - a[i + b[i+1]+1] ;
     if (curStep < nStep) then (     nStep := curStep ; 
     minM := i ) else skip ; 
     if (nStep < 1) then (     res := res->including(minM) ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    if (nStep > 0) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(res->size() + 1) ; 
         var i : int ; i := 0 ; while i < res->size() do ( (     OclFile["System.out"].print(res->at(i+1) + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(0) ) ;  
 )   catch (e : IOException) do (     OclFile["System.err"].println("Invalid input " + e.getMessage()) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
import java.util.ArrayList ;
public class Main {
  public static void main(String args[]){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      int n=Integer.parseInt(reader.readLine());
      int[] a=new int[n+1];
      StringTokenizer input=new StringTokenizer(reader.readLine());
      for(int i=0 ; i<n ; i++){
        a[i+1]=Integer.parseInt(input.nextToken());
      }
      int[] b=new int[n+1];
      input=new StringTokenizer(reader.readLine());
      for(int i=0 ; i<n ; i++){
        b[i+1]=Integer.parseInt(input.nextToken());
      }
      int achive=n-a[n];
      int nextachive=achive ;
      int minimum=n ;
      ArrayList<Integer>result=new ArrayList<>();
      for(int i=n-1 ; i>0 ; i--){
        if(i<achive){
          if(i<nextachive){
            break ;
          }
          achive=nextachive ;
          result.add(minimum);
        }
        int curachive=i+b[i]-a[i+b[i] ];
        if(curachive<nextachive){
          nextachive=curachive ;
          minimum=i ;
        }
        if(nextachive<1){
          result.add(minimum);
          break ;
        }
      }
      if(nextachive>0){
        System.out.println(-1);
      }
      else {
        System.out.println(result.size()+1);
        for(int i=0 ; i<result.size(); i++){
          System.out.print(result.get(i)+" ");
        }
        System.out.print(0);
      }
    }
    catch(IOException e){
      System.err.println("Invalid input "+e.getMessage());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var n : int ; n := (reader.readLine())->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var input : OclIterator ; input := OclIterator.newOclIterator_String(reader.readLine()) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i + 1+1] := (input.next())->toInteger() )  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,n + 1)->collect(0) ;
    input := OclIterator.newOclIterator_String(reader.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i + 1+1] := (input.next())->toInteger() )  ;     i := i + 1 ) ; 
    var achive : int ; achive := n - a[n+1] ;
    var nextachive : int ; nextachive := achive ;
    var minimum : int ; minimum := n ;
    var result : Sequence(int) ; result := Sequence{} ;
        var i : int ; i := n - 1 ; while i > 0 do ( (     if (i < achive) then (     if (i < nextachive) then (     break ) else skip ; 
     achive := nextachive ; 
     result := result->including(minimum) ) else skip ; 
     var curachive : int ; curachive := i + b[i+1] - a[i + b[i+1]+1] ;
     if (curachive < nextachive) then (     nextachive := curachive ; 
     minimum := i ) else skip ; 
     if (nextachive < 1) then (     result := result->including(minimum) ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    if (nextachive > 0) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(result->size() + 1) ; 
         var i : int ; i := 0 ; while i < result->size() do ( (     OclFile["System.out"].print(result->at(i+1) + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(0) ) ;  
 )   catch (e : IOException) do (     OclFile["System.err"].println("Invalid input " + e.getMessage()) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
import java.util.ArrayList ;
public class Main {
  public static void main(String args[]){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      int n=Integer.parseInt(reader.readLine());
      int[] a=new int[n+1];
      StringTokenizer input=new StringTokenizer(reader.readLine());
      for(int i=0 ; i<n ; i++){
        a[i+1]=Integer.parseInt(input.nextToken());
      }
      int[] b=new int[n+1];
      input=new StringTokenizer(reader.readLine());
      for(int i=0 ; i<n ; i++){
        b[i+1]=Integer.parseInt(input.nextToken());
      }
      int step=n-a[n];
      int nStep=step ;
      int minM=n ;
      ArrayList<Integer>res=new ArrayList<>();
      for(int i=n-1 ; i>0 ; i--){
        if(i<step){
          if(i<nStep){
            break ;
          }
          step=nStep ;
          res.add(minM);
        }
        int curStep=i+b[i]-a[i+b[i] ];
        if(curStep<nStep){
          minM=i ;
          nStep=curStep ;
        }
        if(nStep<1){
          res.add(minM);
          break ;
        }
      }
      if(nStep>0){
        System.out.println(-1);
      }
      else {
        System.out.println(res.size()+1);
        for(int i=0 ; i<res.size(); i++){
          System.out.print(res.get(i)+" ");
        }
        System.out.print(0);
      }
    }
    catch(IOException e){
      System.err.println("Invalid input "+e.getMessage());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var n : int ; n := (reader.readLine())->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var input : OclIterator ; input := OclIterator.newOclIterator_String(reader.readLine()) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i + 1+1] := (input.next())->toInteger() )  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,n + 1)->collect(0) ;
    input := OclIterator.newOclIterator_String(reader.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i + 1+1] := (input.next())->toInteger() )  ;     i := i + 1 ) ; 
    var step : int ; step := n - a[n+1] ;
    var nStep : int ; nStep := step ;
    var minM : int ; minM := n ;
    var res : Sequence(int) ; res := Sequence{} ;
        var i : int ; i := n - 1 ; while i > 0 do ( (     if (i < step) then (     if (i < nStep) then (     break ) else skip ; 
     step := nStep ; 
     res := res->including(minM) ) else skip ; 
     var curStep : int ; curStep := i + b[i+1] - a[i + b[i+1]+1] ;
     if (curStep < nStep) then (     minM := i ; 
     nStep := curStep ) else skip ; 
     if (nStep < 1) then (     res := res->including(minM) ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    if (nStep > 0) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(res->size() + 1) ; 
         var i : int ; i := 0 ; while i < res->size() do ( (     OclFile["System.out"].print(res->at(i+1) + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(0) ) ;  
 )   catch (e : IOException) do (     OclFile["System.err"].println("Invalid input " + e.getMessage()) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findSum(int N,int K){
    int ans=0 ;
    for(int i=1 ; i<=N ; i++)ans+=(i % K);
    return ans ;
  }
  static public void main(String[] args){
    int N=10,K=2 ;
    System.out.println(findSum(N,K));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSum( N : int, K : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i <= N do (     ans := ans+((i mod K)) ;  ;     i := i + 1 ) ; 
     return ans );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 10 ;
    var K : int ; K := 2 ;
     OclFile["System.out"].println(findSum(N, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSubString(String s,char c,int k){
    int leftCount=0,rightCount=0 ;
    int left=0,right=0 ;
    int freq=0 ;
    int result=0,len=s.length();
    while(s.charAt(left)!=c && left<len){
      left++;
      leftCount++;
    }
    right=left+1 ;
    while(freq!=(k-1)&&(right-1)<len){
      if(s.charAt(right)==c){
        freq++;
      }
      right++;
    }
    while(left<len &&(right-1)<len){
      while(s.charAt(left)!=c && left<len){
        left++;
        leftCount++;
      }
      while(right<len && s.charAt(right)!=c){
        if(s.charAt(right)==c){
          freq++;
        }
        right++;
        rightCount++;
      }
      result=result+(leftCount+1)*(rightCount+1);
      freq=k-1 ;
      leftCount=0 ;
      rightCount=0 ;
      left++;
      right++;
    }
    return result ;
  }
  public static void main(String args[]){
    String s="3123231" ;
    char c='3' ;
    int k=2 ;
    System.out.println(countSubString(s,c,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSubString( s : String, c : String, k : int) : int
  pre: true
  post: true
  activity: (     var leftCount : int ; leftCount := 0 ;
    var rightCount : int ; rightCount := 0 ;
     var left : int ; left := 0 ;
    var right : int ; right := 0 ;
    var freq : int ; freq := 0 ;
    var result : int ; result := 0 ;
    var len : int ; len := s->size() ;
    while (s->at(left+1) /= c & left < len) do (     left := left + 1 ; 
     leftCount := leftCount + 1 ) ; 
    right := left + 1 ; 
    while (freq /= (k - 1) & (right - 1) < len) do (     if (s->at(right+1) = c) then (     freq := freq + 1 ) else skip ; 
     right := right + 1 ) ; 
    while (left < len & (right - 1) < len) do (     while (s->at(left+1) /= c & left < len) do (     left := left + 1 ; 
     leftCount := leftCount + 1 ) ; 
     while (right < len & s->at(right+1) /= c) do (     if (s->at(right+1) = c) then (     freq := freq + 1 ) else skip ; 
     right := right + 1 ; 
     rightCount := rightCount + 1 ) ; 
    result := result + (leftCount + 1) * (rightCount + 1) ; 
    freq := k - 1 ; 
    leftCount := 0 ; 
    rightCount := 0 ; 
    left := left + 1 ; 
    right := right + 1 ; 
 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "3123231" ;
     var c : String ; c := '3' ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(countSubString(s, c, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static ArrayList<HashMap<Integer,Integer>>graph ;
  static int[] counts ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    counts=new int[n];
    for(int i=1 ; i<n ; i++){
      counts[i]=sc.nextInt();
    }
    graph=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      graph.add(new HashMap<>());
    }
    for(int i=0 ; i<n-1 ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      graph.get(a).put(b,c);
      graph.get(b).put(a,c);
    }
    System.out.println(getCost(0,0));
  }
  static int getCost(int from,int to){
    int sum=0 ;
    if(counts[to]!=0){
      return graph.get(from).get(to);
    }
    for(Map.Entry<Integer,Integer>entry : graph.get(to).entrySet()){
      if(entry.getKey()==from){
        continue ;
      }
      if(getCount(to,entry.getKey())==0){
        continue ;
      }
      sum+=Math.min(getCost(to,entry.getKey()),entry.getValue());
    }
    return sum ;
  }
  static int getCount(int from,int to){
    int sum=counts[to];
    for(int x : graph.get(to).keySet()){
      if(x==from){
        continue ;
      }
      sum+=getCount(to,x);
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute graph : Sequence(Map(int,int));
  static   attribute counts : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    counts := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 1 ; while i < n do ( (     counts[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    graph := Sequence{} ; 
        var i : int ; i := 0 ; while i < n do ( (     graph := graph->including(Map{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    graph := graph->at(a+1)->union(Map{b |-> c}) ; 
    graph := graph->at(b+1)->union(Map{a |-> c}) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(getCost(0, 0)) ; 
 );
  static   operation getCost( from : int, to : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     if (counts[to+1] /= 0) then (     return graph->at(from+1)->at(to+1) ) else skip ; 
     for (entry : graph->at(to+1)->asSet()) do ( (     if (entry.getKey() = from) then (     continue ) else skip ; 
     if (getCount(to, entry.getKey()) = 0) then (     continue ) else skip ; 
     sum := sum+(Set{getCost(to, entry.getKey()), entry.getValue()}->min()) )  ) ; 
     return sum );
  static   operation getCount( from : int, to : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := counts[to+1] ;
     for (x : graph->at(to+1).keySet()) do ( (     if (x = from) then (     continue ) else skip ; 
     sum := sum+(getCount(to, x)) )  ) ; 
     return sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  static FastScanner in=new FastScanner();
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    int n=in.nextInt(),k=in.nextInt();
    HashSet<Integer>set=new HashSet<>(200002);
    while(n--!=0){
      int l=in.nextInt();
      int r=in.nextInt();
      while(l<=r){
        set.add(l++);
      }
    }
    long mov=0,count=set.size();
    while(count % k!=0){
      count++;
      mov++;
    }
    out.println(mov);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   attribute in : FastScanner := FastScanner.newFastScanner();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
    var k : int ; k := in.nextInt() ;
     var set : Set(int) ; set := Set{} ;
        while (n /= 0) do (    skip ; (     var l : int ; l := in.nextInt() ;
     var r : int ; r := in.nextInt() ;
     while (l <= r) do (     set := set->including(l) ) ) ;  ) ;  
    var mov : long ; mov := 0 ;
    var count : long ; count := set->size() ;
    while (count mod k /= 0) do (     count := count + 1 ; 
     mov := mov + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int size=0 ;
    int counter=0 ;
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      size+=Math.abs(x-y)+1 ;
    }
    while(size % k!=0){
      size++;
      counter++;
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var size : int ; size := 0 ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     size := size+(if x - y < 0 then -(x - y) else x - y endif + 1) )  ;     i := i + 1 ) ; 
    while (size mod k /= 0) do (     size := size + 1 ; 
     counter := counter + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class App {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt(),segments=0 ;
    for(int index=0 ; index<n ; index++){
      int a=in.nextInt();
      int b=in.nextInt();
      segments+=(b-a+1);
    }
    segments %=k ;
    if(segments==0){
      System.out.println(0);
    }
    else {
      System.out.println(k-segments);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var segments : int ; segments := 0 ;
        var index : int ; index := 0 ; while index < n do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
     segments := segments+((b - a + 1)) )  ;     index := index + 1 ) ; 
    segments := segments mod k ; 
    if (segments = 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(k - segments) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    sc.nextLine();
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      count+=Math.abs(sc.nextInt()-sc.nextInt())+1 ;
      sc.nextLine();
    }
    System.out.println(count % k==0 ? 0 :(k-count % k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    skip ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     count := count+(if sc.getCurrent()->toInteger() - sc.getCurrent()->toInteger() < 0 then -(sc.getCurrent()->toInteger() - sc.getCurrent()->toInteger()) else sc.getCurrent()->toInteger() - sc.getCurrent()->toInteger() endif + 1) ; 
     skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if count mod k = 0 then 0 else (k - count mod k) endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  static FastScanner in=new FastScanner();
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    int n=in.nextInt(),k=in.nextInt();
    long count=0 ;
    while(n--!=0){
      int l=in.nextInt();
      int r=in.nextInt();
      count+=r-l+1 ;
    }
    out.println(count % k==0 ? 0 : k-(count % k));
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   attribute in : FastScanner := FastScanner.newFastScanner();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
    var k : int ; k := in.nextInt() ;
     var count : long ; count := 0 ;
        while (n /= 0) do (    skip ; (     var l : int ; l := in.nextInt() ;
     var r : int ; r := in.nextInt() ;
     count := count+(r - l + 1) ) ;  ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String reversingString(char[] str,int start,int end){
    while(start<end){
      str[start] ^=str[end];
      str[end] ^=str[start];
      str[start] ^=str[end];
++start ;
--end ;
    }
    return String.valueOf(str);
  }
  public static void main(String[] args){
    String s="GeeksforGeeks" ;
    System.out.println(reversingString(s.toCharArray(),0,12));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation reversingString( str : Sequence(String), start : int, end : int) : String
  pre: true
  post: true
  activity: (     while (start < end) do (     str[start+1] := MathLib.bitwiseXor(str[start+1],str[end+1]) ; 
     str[end+1] := MathLib.bitwiseXor(str[end+1],str[start+1]) ; 
    str[start+1] := MathLib.bitwiseXor(str[start+1],str[end+1]) ; 
    start := start + 1 ; 
    end := end - 1 ; 
 ) ; 
     return ((str) + "") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "GeeksforGeeks" ;
     OclFile["System.out"].println(reversingString(s->characters(), 0, 12)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int c=scanner.nextInt();
    int[] num=new int[n];
    if(c<0){
      if(n==1)System.out.println(11);
      else {
        for(int i=0 ; i<n*2 ; i++)System.out.print(9);
        System.out.println();
      }
    }
    else {
      int a=1 ;
      for(int i=0 ; i<n ; i++)a*=10 ;
      int b=a/10 ;
      a--;
      for(int i=a ; i>=b ; i--){
        if(check(i,c))return ;
      }
    }
  }
  private boolean check(int i,int c){
    StringBuilder builder=new StringBuilder(String.valueOf(i));
    StringBuilder builder2=new StringBuilder(String.valueOf(i)).reverse();
    builder.append(c).append(builder2);
    if(prime(Integer.valueOf(builder.toString()))){
      System.out.println(builder);
      return true ;
    }
    else return false ;
  }
  private boolean prime(int b){
    for(int i=2 ; i*i<=b ; i++)if(b % i==0)return false ;
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    var num : Sequence(int) ; num := Integer.subrange(1,n)->collect(0) ;
    if (c < 0) then (     if (n = 1) then     OclFile["System.out"].println(11) ; else (         var i : int ; i := 0 ; while i < n * 2 do (     OclFile["System.out"].print(9) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ) else (     var a : int ; a := 1 ;
         var i : int ; i := 0 ; while i < n do (     a := a*(10) ;  ;     i := i + 1 ) ; 
    var b : int ; b := a / 10 ;
    a := a - 1 ; 
        var i : int ; i := a ; while i >= b do ( (     if (check(i, c)) then     return else skip )  ;     i := i - 1 ) ; 
 ) ;  
 );
   operation check( i : int, c : int) : boolean
  pre: true
  post: true
  activity: (     var builder : String ; builder := StringLib.newString(((i) + "")) ;
     var builder2 : String ; builder2 := StringLib.newString(((i) + ""))->reverse() ;
     builder := builder + StringLib.newString(c) + StringLib.newString(builder2) ; 
     if (prime((builder+"")->toInteger())) then (     OclFile["System.out"].println(builder) ; 
     return true ) else     return false );
   operation prime( b : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= b do (     if (b mod i = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scan=new Scanner(new InputStreamReader(System.in))){
      String line=scan.nextLine();
      int n=0 ;
      int s=0 ;
      int w=0 ;
      int e=0 ;
      for(char c : line.toCharArray()){
        switch(c){
          case 'N' : n=1 ;
          break ;
          case 'S' : s=1 ;
          break ;
          case 'W' : w=1 ;
          break ;
          case 'E' : e=1 ;
          break ;
        }
      }
      if(n-s==0 && w-e==0){
        System.out.print("Yes");
      }
      else {
        System.out.print("No");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scan : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var line : String ; line := scan.nextLine() ;
     var n : int ; n := 0 ;
    var s : int ; s := 0 ;
    var w : int ; w := 0 ;
    var e : int ; e := 0 ;
    for (c : line->characters()) do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
       if _switchval = 'N' then
     n := 1 ; 
    break 
   else skip ;
       if _switchval = 'S' then
     s := 1 ; 
    break 
   else skip ;
       if _switchval = 'W' then
     w := 1 ; 
    break 
   else skip ;
       if _switchval = 'E' then
     e := 1 ; 
    break 
   else skip ;
 )
 )  ) ; 
    if ((n)->char2byte() - s = 0 & w - e = 0) then (     OclFile["System.out"].print("Yes") ) else (     OclFile["System.out"].print("No") ) ;  
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
public class a {
  public static void main(String[] args){
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    try {
      int cases=Integer.valueOf(input.readLine());
      for(int cas=1 ; cas<=cases ; cas++){
        String line=input.readLine();
        int digit[]=new int[256];
        int base=0,i ;
        BigInteger num=new BigInteger("0");
        for(i=0 ; i<256 ; i++)digit[i]=-1 ;
        for(i=0 ; i<line.length(); i++){
          if((line.charAt(i)<'0' || line.charAt(i)>'9')&&(line.charAt(i)<'a' || line.charAt(i)>'z'))continue ;
          if(digit[line.charAt(i)]==-1){
            if(base==0)digit[line.charAt(i)]=1 ;
            else if(base==1)digit[line.charAt(i)]=0 ;
            else digit[line.charAt(i)]=base ;
            base++;
          }
        }
        if(base<2)base=2 ;
        int cnt=0 ;
        for(i=0 ; i<line.length(); i++){
          if((line.charAt(i)<'0' || line.charAt(i)>'9')&&(line.charAt(i)<'a' || line.charAt(i)>'z'))continue ;
          num=num.multiply(BigInteger.valueOf(base));
          num=num.add(BigInteger.valueOf(digit[line.charAt(i)]));
        }
        System.out.printf("Case #%d: ",cas);
        System.out.println(num);
      }
    }
    catch(java.io.IOException e){
    }
  }
};
------------------------------------------------------------
OCL File:
---------
 class a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var cases : int ; cases := (input.readLine())->toInteger() ;
         var cas : int ; cas := 1 ; while cas <= cases do ( (     var line : String ; line := input.readLine() ;
     var digit : Sequence(int) ; digit := Integer.subrange(1,256)->collect(0) ;
    var base : int ; base := 0 ;
    var i : int ;
    var num : long ; num := long("0") ;
        i := 0 ; while i < 256 do (     digit[i+1] := -1 ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < line->size() do ( (     if ((line->at(i+1) < '0' or line->at(i+1) > '9') & (line->at(i+1) < 'a' or line->at(i+1) > 'z')) then     continue else skip ; 
     if (digit[line->at(i+1)+1] = -1) then (     if (base = 0) then     digit[line->at(i+1)+1] := 1 else     if (base = 1) then     digit[line->at(i+1)+1] := 0 else     digit[line->at(i+1)+1] := base ; ;  ;  
     base := base + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (base < 2) then     base := 2 ; else skip ; 
    var cnt : int ; cnt := 0 ;
        i := 0 ; while i < line->size() do ( (     if ((line->at(i+1) < '0' or line->at(i+1) > '9') & (line->at(i+1) < 'a' or line->at(i+1) > 'z')) then     continue else skip ; 
     num := num.multiply((base + "")->toLong()) ; 
     num := num->excludes((digit[line->at(i+1)+1] + "")->toLong()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("Case #%d: ", cas) ; 
    OclFile["System.out"].println(num) ; 
 )  ;     cas := cas + 1 ) )   catch (e : IOException) do skip
 );
}
;

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.HashSet ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    AWannaGoBackHome solver=new AWannaGoBackHome();
    solver.solve(1,in,out);
    out.close();
  }
  static class AWannaGoBackHome {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      char[] s=in.next().toCharArray();
      HashSet<Character>distinct=new HashSet<>();
      for(char c : s)distinct.add(c);
      boolean answer=true ;
      answer &=distinct.contains('N')==distinct.contains('S');
      answer &=distinct.contains('W')==distinct.contains('E');
      out.println(answer ? "Yes" : "No");
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : AWannaGoBackHome ; solver := AWannaGoBackHome.newAWannaGoBackHome() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class AWannaGoBackHome {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := in.next()->characters() ;
     var distinct : Set(String) ; distinct := Set{} ;
    for (c : s) do (     distinct := distinct->including(c) ;  ) ; 
    var answer : boolean ; answer := true ;
    answer := MathLib.bitwiseAnd(answer, distinct->includes('N') = distinct->includes('S')) ; 
    answer := MathLib.bitwiseAnd(answer, distinct->includes('W') = distinct->includes('E')) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.awt.geom.Point2D ;
import java.awt.geom.Point2D.Double ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
import java.util.TreeSet ;
import java.lang.Object ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new A().doIt();
  }
  class A {
    void doIt(){
      String str=sc.next();
      char ctr[]=str.toCharArray();
      int U=0,D=0,L=0,R=0 ;
      for(int i=0 ; i<str.length(); i++){
        if(ctr[i]=='S'){
          D=1 ;
        }
        else if(ctr[i]=='N'){
          U=1 ;
        }
        else if(ctr[i]=='W'){
          L=1 ;
        }
        else {
          R=1 ;
        }
      }
      boolean ok=true ;
      if((D+U)% 2==1)ok=false ;
      if((L+R)% 2==1)ok=false ;
      if(ok)System.out.println("Yes");
      else System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     A.newA().doIt() );
 class A {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var str : String ; str := sc.getCurrent() ;
     var ctr : Sequence(String) ; ctr := str->characters() ;
    var U : int ; U := 0 ;
    var D : int ; D := 0 ;
    var L : int ; L := 0 ;
    var R : int ; R := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (ctr[i+1] = 'S') then (     D := 1 ) else     if (ctr[i+1] = 'N') then (     U := 1 ) else     if (ctr[i+1] = 'W') then (     L := 1 ) else (     R := 1 ) ;  ;  )  ;     i := i + 1 ) ; 
    var ok : boolean ; ok := true ;
    if ((D + U) mod 2 = 1) then     ok := false ; else skip ; 
    if ((L + R) mod 2 = 1) then     ok := false ; else skip ; 
    if (ok) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=false ;
  private static PrintWriter _out=new PrintWriter(System.out);
  private static PrintWriter _err=new PrintWriter(System.err);
  private void solve(Scanner sc){
    String S=sc.nextLine();
    boolean n=false ;
    boolean s=false ;
    boolean w=false ;
    boolean e=false ;
    for(int i=0 ; i<S.length(); ++i){
      char ch=S.charAt(i);
      switch(ch){
        case 'N' : n=true ;
        break ;
        case 'S' : s=true ;
        break ;
        case 'W' : w=true ;
        break ;
        case 'E' : e=true ;
        break ;
      }
    }
    if(s && n && w && e || s && n && ! w && ! e || ! s && ! n && w && e){
      _out.println("Yes");
    }
    else {
      _out.println("No");
    }
  }
  private static BigInteger C(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    for(long i=r ; i>1 ; --i){
      res=res.divide(BigInteger.valueOf(i));
    }
    return res ;
  }
  private static BigInteger P(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    return res ;
  }
  public static void main(String[] args){
    long S=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    new Main().solve(sc);
    _out.flush();
    long G=System.currentTimeMillis();
    if(elapsed){
      _err.println((G-S)+"ms");
    }
    _err.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := false;
  static   attribute _out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute _err : OclFile := OclFile.newOclFile_Write(OclFile["System.err"]);
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var S : String ; S := sc.nextLine() ;
     var n : boolean ; n := false ;
    var s : boolean ; s := false ;
    var w : boolean ; w := false ;
    var e : boolean ; e := false ;
        var i : int ; i := 0 ; while i < S->size() do ( (     var ch : String ; ch := S->at(i+1) ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (ch) ; 
       if _switchval = 'N' then
     n := true ; 
    break 
   else skip ;
       if _switchval = 'S' then
     s := true ; 
    break 
   else skip ;
       if _switchval = 'W' then
     w := true ; 
    break 
   else skip ;
       if _switchval = 'E' then
     e := true ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    if (s & n & w & e or s & n & not(w) & not(e) or not(s) & not(n) & w & e) then (     skip ) else (     skip ) ;  
 );
  static   operation C( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > (n)->char2byte() - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
         var i : long ; i := r ; while i > 1 do ( (     res := res.divide((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation P( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > (n)->char2byte() - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    Main.newMain().solve(sc) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    String str=input.readLine();
    int nou=str.length()-str.replace("N","").length();
    int wes=str.length()-str.replace("W","").length();
    int sou=str.length()-str.replace("S","").length();
    int eas=str.length()-str.replace("E","").length();
    String answer="Yes" ;
    if((nou==0 && sou!=0)||(nou!=0 && sou==0)){
      answer="No" ;
    }
    else if((wes==0 && eas!=0)||(wes!=0 && eas==0)){
      answer="No" ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := input.readLine() ;
    var nou : int ; nou := str->size() - str.replace("N", "")->size() ;
    var wes : int ; wes := str->size() - str.replace("W", "")->size() ;
    var sou : int ; sou := str->size() - str.replace("S", "")->size() ;
    var eas : int ; eas := str->size() - str.replace("E", "")->size() ;
    var answer : String ; answer := "Yes" ;
    if ((nou = 0 & sou /= 0) or (nou /= 0 & sou = 0)) then (     answer := "No" ) else     if ((wes = 0 & eas /= 0) or (wes /= 0 & eas = 0)) then (     answer := "No" ) else skip ; ;  
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t--!=0){
      int n=scanner.nextInt();
      int m=scanner.nextInt();
      int r=scanner.nextInt();
      int c=scanner.nextInt();
      boolean hasblack=false ;
      char[][] map=new char[n][m];
      boolean rhasblack=false ;
      boolean chasblack=false ;
      for(int i=0 ; i<n ; i++){
        String s=scanner.next();
        for(int j=0 ; j<s.length(); j++){
          map[i][j]=s.charAt(j);
          if(map[i][j]=='B'){
            hasblack=true ;
          }
          if(j==c-1 && map[i][j]=='B'){
            chasblack=true ;
          }
          if(i==r-1 && map[i][j]=='B'){
            rhasblack=true ;
          }
        }
      }
      if(! hasblack){
        System.out.println(-1);
        continue ;
      }
      if(map[r-1][c-1]=='B'){
        System.out.println(0);
        continue ;
      }
      if(rhasblack || chasblack){
        System.out.println(1);
        continue ;
      }
      System.out.println(2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
    var r : int ; r := scanner.getCurrent()->toInteger() ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    var hasblack : boolean ; hasblack := false ;
    var map : Sequence(Sequence(String)) ; map := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var rhasblack : boolean ; rhasblack := false ;
    var chasblack : boolean ; chasblack := false ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := scanner.getCurrent() ;
         var j : int ; j := 0 ; while j < s->size() do ( (     map[i+1][j+1] := s->at(j+1) ; 
     if (map[i+1][j+1] = 'B') then (     hasblack := true ) else skip ; 
     if (j = c - 1 & map[i+1][j+1] = 'B') then (     chasblack := true ) else skip ; 
     if (i = r - 1 & map[i+1][j+1] = 'B') then (     rhasblack := true ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (not(hasblack)) then (     OclFile["System.out"].println(-1) ; 
     continue ) else skip ; 
    if (map[r - 1+1][c - 1+1] = 'B') then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
    if (rhasblack or chasblack) then (     OclFile["System.out"].println(1) ; 
     continue ) else skip ; 
    OclFile["System.out"].println(2) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B676 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int T=in.nextInt();
    int[][] glass=new int[N][N];
    int baseAmount=512 ;
    for(int t=0 ; t<T ; t++){
      glass[0][0]+=baseAmount ;
      for(int level=0 ; level<N-1 ; level++){
        for(int i=0 ; i<=level ; i++){
          int overflow=Math.max(0,glass[level][i]-baseAmount);
          glass[level][i]-=overflow ;
          glass[level+1][i]+=overflow/2 ;
          glass[level+1][i+1]+=overflow/2 ;
        }
      }
    }
    int answer=0 ;
    for(int level=0 ; level<N ; level++){
      for(int i=0 ; i<=level ; i++){
        if(glass[level][i]>=baseAmount){
          answer++;
        }
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B676 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var T : int ; T := in.getCurrent()->toInteger() ;
    var glass : Sequence(Sequence(int)) ; glass := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
    var baseAmount : int ; baseAmount := 512 ;
        var t : int ; t := 0 ; while t < T do ( (     glass[0+1][0+1] := glass[0+1][0+1]+(baseAmount) ; 
         var level : int ; level := 0 ; while level < N - 1 do ( (         var i : int ; i := 0 ; while i <= level do ( (     var overflow : int ; overflow := Set{0, glass[level+1][i+1] - baseAmount}->max() ;
     glass[level+1][i+1] := glass[level+1][i+1]-(overflow) ; 
     glass[level + 1+1][i+1] := glass[level + 1+1][i+1]+(overflow / 2) ; 
     glass[level + 1+1][i + 1+1] := glass[level + 1+1][i + 1+1]+(overflow / 2) )  ;     i := i + 1 ) )  ;     level := level + 1 ) )  ;     t := t + 1 ) ; 
    var answer : int ; answer := 0 ;
        var level : int ; level := 0 ; while level < N do ( (         var i : int ; i := 0 ; while i <= level do ( (     if (glass[level+1][i+1] >= baseAmount) then (     answer := answer + 1 ) else skip )  ;     i := i + 1 ) )  ;     level := level + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PyramidOfGlasses {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int t=in.nextInt();
    System.out.print(pyramidOfAllGlasses(n,t));
  }
  public static int pyramidOfAllGlasses(int n,int t){
    int ans=0 ;
    double arr[][]=new double[15][15];
    arr[1][1]=t ;
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=i ; j++){
        if(arr[i][j]>=1){
          arr[i+1][j]+=(arr[i][j]-1)/2 ;
          arr[i+1][j+1]+=(arr[i][j]-1)/2 ;
          ans++;
        }
      }
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class PyramidOfGlasses {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
     var t : int ; t := in.getCurrent()->toInteger() ;
     OclFile["System.out"].print(pyramidOfAllGlasses(n, t)) );
  static   operation pyramidOfAllGlasses( n : int, t : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var arr : Sequence(Sequence(double)) ; arr := Integer.subrange(1,15)->collect(Integer.subrange(1,15)->collect(0.0)) ;
    arr[1+1][1+1] := t ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= i do ( (     if (arr[i+1][j+1] >= 1) then (     arr[i + 1+1][j+1] := arr[i + 1+1][j+1]+((arr[i+1][j+1] - 1) / 2) ; 
     arr[i + 1+1][j + 1+1] := arr[i + 1+1][j + 1+1]+((arr[i+1][j+1] - 1) / 2) ; 
     ans := ans + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class PyramidofGlasses {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] in=br.readLine().trim().split(" ");
    int height=Integer.parseInt(in[0]);
    int t=Integer.parseInt(in[1]);
    int length=(height*(height+1))/2 ;
    float[] arr=new float[length];
    for(int i=0 ; i<t ; i++){
      fill(0,arr,1,1.0F);
    }
    int count=0 ;
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]==1)count++;
    }
    System.out.println(count);
  }
  private static void fill(int index,float[] arr,int level,float volume){
    if(index>=arr.length || volume==0)return ;
    arr[index]+=volume ;
    if(arr[index]<1){
      return ;
    }
    volume=arr[index]-1 ;
    arr[index]=1 ;
    int left=level+index ;
    int right=left+1 ;
    fill(left,arr,level+1,volume/2.0F);
    fill(right,arr,level+1,volume/2.0F);
  }
}
------------------------------------------------------------
OCL File:
---------
 class PyramidofGlasses {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var in : Sequence(String) ; in := br.readLine()->trim()->split(" ") ;
    var height : int ; height := (in[0+1])->toInteger() ;
    var t : int ; t := (in[1+1])->toInteger() ;
    var length : int ; length := (height * (height + 1)) / 2 ;
    var arr : Sequence(double) ; arr := Integer.subrange(1,length)->collect(0.0) ;
        var i : int ; i := 0 ; while i < t do ( (     execute fill(0, arr, 1, 1.0F) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = 1) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation fill( index : int, arr : Sequence(double), level : int, volume : double) : void
  pre: true
  post: true
  activity: (     if (index >= arr->size() or volume = 0) then     return else skip ; 
     arr[index+1] := arr[index+1]+(volume) ; 
    if (arr[index+1] < 1) then (     return ) else skip ; 
    volume := arr[index+1] - 1 ; 
    arr[index+1] := 1 ; 
    var left : int ; left := level + index ;
    var right : int ; right := left + 1 ;
    execute fill(left, arr, level + 1, volume / 2.0F) ; 
    execute fill(right, arr, level + 1, volume / 2.0F) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static void printDistinct(int arr[]){
    HashSet<Integer>set=new HashSet<>();
    for(int i=0 ; i<arr.length ; i++){
      if(! set.contains(arr[i])){
        set.add(arr[i]);
        System.out.print(arr[i]+" ");
      }
    }
  }
  public static void main(String[] args){
    int arr[]={
      10,5,3,4,3,5,6 };
      printDistinct(arr);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation printDistinct( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var set : Set(int) ; set := Set{} ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     if (not(set->includes(arr[i+1]))) then (     set := set->including(arr[i+1]) ; 
     OclFile["System.out"].print(arr[i+1] + " ") ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,5,3,4,3,5,6} ;
     execute printDistinct(arr) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Starter56 {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] in=br.readLine().trim().split(" ");
    int n=Integer.parseInt(in[0]);
    int t=Integer.parseInt(in[1]);
    double[][] glasses=new double[n][n];
    glasses[0][0]=t ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<=i ; j++){
        if(glasses[i][j]>=1.0){
          double rem=glasses[i][j]-1.0 ;
          glasses[i][j]=1.0 ;
          if(i+1<n){
            glasses[i+1][j]+=rem/2 ;
            glasses[i+1][j+1]+=rem/2 ;
          }
        }
      }
    }
    int gcount=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<=i ; j++){
        if(glasses[i][j]==1.0){
          gcount++;
        }
      }
    }
    System.out.println(gcount);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Starter56 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var in : Sequence(String) ; in := br.readLine()->trim()->split(" ") ;
    var n : int ; n := (in[0+1])->toInteger() ;
    var t : int ; t := (in[1+1])->toInteger() ;
    var glasses : Sequence(Sequence(double)) ; glasses := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0.0)) ;
    glasses[0+1][0+1] := t ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j <= i do ( (     if (glasses[i+1][j+1] >= 1.0) then (     var rem : double ; rem := glasses[i+1][j+1] - 1.0 ;
     glasses[i+1][j+1] := 1.0 ; 
     if (i + 1 < n) then (     glasses[i + 1+1][j+1] := glasses[i + 1+1][j+1]+(rem / 2) ; 
     glasses[i + 1+1][j + 1+1] := glasses[i + 1+1][j + 1+1]+(rem / 2) ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var gcount : int ; gcount := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j <= i do ( (     if (glasses[i+1][j+1] = 1.0) then (     gcount := gcount + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(gcount) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package allyourbase ;
import java.io.IOException ;
public class Main extends Base {
  String alien ;
  char app[];
  int apos ;
  public static void main(String[] args)throws IOException {
    Main m=new Main();
    m.run("A","large");
  }
  @ Override void init(){
  }
  @ Override void load(){
  }
  void insert(char ch){
    int i=0 ;
    while(i<apos && app[i]!=ch)i++;
    if(i<apos)return ;
    app[apos]=ch ;
    apos++;
  }
  @ Override void solve()throws IOException {
    System.out.println("Case "+caseId);
    alien=br.readLine();
    System.out.println(alien);
    app=new char[alien.length()];
    apos=0 ;
    for(int i=0 ; i<alien.length(); i++){
      insert(alien.charAt(i));
    }
    long base=apos ;
    if(base==1)base++;
    long res[]=new long[alien.length()];
    for(int i=0 ; i<apos ; i++){
      int digit=i ;
      if(digit==0)digit=1 ;
      else if(digit==1)digit=0 ;
      for(int j=0 ; j<alien.length(); j++){
        if(app[i]==alien.charAt(j)){
          res[j]=digit ;
        }
      }
    }
    for(int i=0 ; i<alien.length(); i++){
      System.out.print(res[i]+" ");
    }
    System.out.println();
    long result=0 ;
    long cur=1 ;
    for(int j=res.length-1 ; j>=0 ; j--){
      result=result+cur*res[j];
      cur=cur*base ;
    }
    printResult(""+result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends Base {
   attribute alien : String;
   attribute app : Sequence(String);
   attribute apos : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run("A", "large") );
     operation init() : void
  pre: true
  post: true
  activity: skip;
     operation load() : void
  pre: true
  post: true
  activity: skip;
   operation insert( ch : String) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     while (i < apos & app[i+1] /= ch) do     i := i + 1 ; ; 
    if (i < apos) then     return else skip ; 
    app[apos+1] := ch ; 
    apos := apos + 1 ; 
 );
     operation solve() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Case " + caseId) ; 
     alien := br.readLine() ; 
    OclFile["System.out"].println(alien) ; 
    app := Integer.subrange(1,alien->size())->collect(0) ; 
    apos := 0 ; 
        var i : int ; i := 0 ; while i < alien->size() do ( (     execute insert(alien->at(i+1)) )  ;     i := i + 1 ) ; 
    var base : long ; base := apos ;
    if (base = 1) then     base := base + 1 ; else skip ; 
    var res : Sequence(long) ; res := Integer.subrange(1,alien->size())->collect(0) ;
        var i : int ; i := 0 ; while i < apos do ( (     var digit : int ; digit := i ;
     if (digit = 0) then     digit := 1 else     if (digit = 1) then     digit := 0 ; else skip ; ;  
         var j : int ; j := 0 ; while j < alien->size() do ( (     if (app[i+1] = alien->at(j+1)) then (     res[j+1] := digit ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < alien->size() do ( (     OclFile["System.out"].print(res[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    var result : long ; result := 0 ;
    var cur : long ; cur := 1 ;
        var j : int ; j := res->size() - 1 ; while j >= 0 do ( (     result := result + cur * res[j+1] ; 
     cur := cur * base )  ;     j := j - 1 ) ; 
    execute printResult("" + result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    boolean[] b=new boolean[4];
    for(int i=0 ; i<n ; i++){
      char a=sc.next().charAt(0);
      switch(a){
        case 'P' : b[0]=true ;
        break ;
        case 'W' : b[1]=true ;
        break ;
        case 'G' : b[2]=true ;
        break ;
        case 'Y' : b[3]=true ;
        break ;
      }
    }
    int cnt=0 ;
    for(int i=0 ; i<4 ; i++){
      if(b[i]){
        cnt++;
      }
    }
    if(cnt==3){
      System.out.println("Three");
    }
    else {
      System.out.println("Four");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var b : Sequence(boolean) ; b := Integer.subrange(1,4)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     var a : String ; a := sc.getCurrent()->at(0+1) ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (a) ; 
       if _switchval = 'P' then
     b[0+1] := true ; 
    break 
   else skip ;
       if _switchval = 'W' then
     b[1+1] := true ; 
    break 
   else skip ;
       if _switchval = 'G' then
     b[2+1] := true ; 
    break 
   else skip ;
       if _switchval = 'Y' then
     b[3+1] := true ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     if (b[i+1]) then (     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (cnt = 3) then (     OclFile["System.out"].println("Three") ) else (     OclFile["System.out"].println("Four") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskB solver=new TaskB();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskB {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      final int n=in.nextInt();
      HashSet<String>a=new HashSet<>();
      for(int i=0 ; i<n ; i++)a.add(in.next());
      String ans=a.size()==3 ? "Three" : "Four" ;
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskB ; solver := TaskB.newTaskB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskB {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Set(String) ; a := Set{} ;
        var i : int ; i := 0 ; while i < n do (     a := a->including(in.getCurrent()) ;  ;     i := i + 1 ) ; 
    var ans : String ; ans := if a->size() = 3 then "Three" else "Four" endif ;
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(in.readLine());
    String[] s=in.readLine().split(" ");
    boolean yellow_flg=false ;
    for(int i=0 ; i<n ; i++){
      if(s[i] .charAt(0)=='Y')yellow_flg=true ;
    }
    System.out.println(yellow_flg==true ? "Four" : "Three");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (in.readLine())->toInteger() ;
    var s : Sequence(String) ; s := in.readLine()->split(" ") ;
    var yellow_flg : boolean ; yellow_flg := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (s[i+1]->at(0+1) = 'Y') then     yellow_flg := true ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if yellow_flg = true then "Four" else "Three" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static Scanner sc ;
  private static Printer pr ;
  private static void solve(){
    int n=sc.nextInt();
    Set<Character>hs=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      char a=sc.next().toCharArray()[0];
      hs.add(a);
    }
    if(hs.size()==3){
      pr.println("Three");
    }
    else if(hs.size()==4){
      pr.println("Four");
    }
  }
  public static void main(String[] args){
    sc=new Scanner(System.in);
    pr=new Printer(System.out);
    solve();
    pr.close();
    sc.close();
  }
  private static class Printer extends PrintWriter {
    Printer(PrintStream out){
      super(out);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile;
  static   attribute pr : Printer;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var hs : Set(String) ; hs := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     var a : String ; a := sc.getCurrent()->characters()[0+1] ;
     hs := hs->including(a) )  ;     i := i + 1 ) ; 
     if (hs->size() = 3) then (     pr.println("Three") ) else     if (hs->size() = 4) then (     pr.println("Four") ) else skip ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     pr := Printer.newPrinter(OclFile["System.out"]) ; 
    execute solve() ; 
    pr.close() ; 
    skip ; 
 );
  static class Printer extends OclFile {
   static operation newPrinter( out : OclFile) : Printer
  pre: true
  post: true
  activity:
  ( var self : Printer ;
    self := createPrinter();
    self.initialise(out);
    return self );
  operation initialise( out : OclFile) : void
  pre: true  post: true
  activity: (     execute super(out) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    sc.nextLine();
    int[] n=new int[4];
    n[0]=0 ;
    n[1]=0 ;
    n[2]=0 ;
    n[3]=0 ;
    String StringLine=sc.nextLine();
    StringLine=StringLine.replace(" ","");
    char[] array=StringLine.toCharArray();
    for(int i=0 ; i<num ; i++){
      switch(array[i]){
        case 'P' : n[0]++;
        break ;
        case 'W' : n[1]++;
        break ;
        case 'G' : n[2]++;
        break ;
        case 'Y' : n[3]++;
        break ;
      }
    }
    int rc=0 ;
    for(int i=0 ; i<4 ; i++){
      if(n[i]==0){
        rc++;
      }
    }
    switch(rc){
      case 0 : System.out.println("Four");
      break ;
      case 1 : System.out.println("Three");
      break ;
      case 2 : System.out.println("Two");
      break ;
      case 3 : System.out.println("One");
      break ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
    skip ; 
    var n : Sequence(int) ; n := Integer.subrange(1,4)->collect(0) ;
    n[0+1] := 0 ; 
    n[1+1] := 0 ; 
    n[2+1] := 0 ; 
    n[3+1] := 0 ; 
    var StringLine : String ; StringLine := sc.nextLine() ;
    StringLine := StringLine.replace(" ", "") ; 
    var array : Sequence(String) ; array := StringLine->characters() ;
        var i : int ; i := 0 ; while i < num do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (array[i+1]) ; 
       if _switchval = 'P' then
     n[0+1] := n[0+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 'W' then
     n[1+1] := n[1+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 'G' then
     n[2+1] := n[2+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 'Y' then
     n[3+1] := n[3+1] + 1 ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    var rc : int ; rc := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     if (n[i+1] = 0) then (     rc := rc + 1 ) else skip )  ;     i := i + 1 ) ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (rc) ; 
       if _switchval = 0 then
     OclFile["System.out"].println("Four") ; 
    break 
   else skip ;
       if _switchval = 1 then
     OclFile["System.out"].println("Three") ; 
    break 
   else skip ;
       if _switchval = 2 then
     OclFile["System.out"].println("Two") ; 
    break 
   else skip ;
       if _switchval = 3 then
     OclFile["System.out"].println("One") ; 
    break 
   else skip ;
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int factorial(int N){
    int fact=1 ;
    for(int i=1 ; i<=N ; i++)fact=fact*i ;
    return fact ;
  }
  static int nthTerm(int N){
    return(factorial(N)*(N+2)/2);
  }
  public static void main(String args[]){
    int N=6 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation factorial( N : int) : int
  pre: true
  post: true
  activity: (     var fact : int ; fact := 1 ;
         var i : int ; i := 1 ; while i <= N do (     fact := fact * i ;  ;     i := i + 1 ) ; 
     return fact );
  static   operation nthTerm( N : int) : int
  pre: true
  post: true
  activity: (     return (factorial(N) * (N + 2) / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 6 ;
     OclFile["System.out"].println(nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int factorial(int N){
    int fact=1 ;
    for(int i=1 ; i<=N ; i++)fact=fact*i ;
    return fact ;
  }
  static int nthTerm(int N){
    return(factorial(N+1)/2);
  }
  public static void main(String args[]){
    int N=6 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation factorial( N : int) : int
  pre: true
  post: true
  activity: (     var fact : int ; fact := 1 ;
         var i : int ; i := 1 ; while i <= N do (     fact := fact * i ;  ;     i := i + 1 ) ; 
     return fact );
  static   operation nthTerm( N : int) : int
  pre: true
  post: true
  activity: (     return (factorial(N + 1) / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 6 ;
     OclFile["System.out"].println(nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int longestPermutation(int arr[],int n){
    HashMap<Integer,Integer>freq=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      if(freq.containsKey(arr[i])){
        freq.put(arr[i],freq.get(arr[i])+1);
      }
      else {
        freq.put(arr[i],1);
      }
    }
    int len=0 ;
    for(int i=1 ; i<=n ; i++){
      if(! freq.containsKey(i)){
        break ;
      }
      len++;
    }
    return len ;
  }
  public static void main(String[] args){
    int arr[]={
      3,2,1,6,5 };
      int n=arr.length ;
      System.out.print(longestPermutation(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation longestPermutation( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var freq : Map(int,int) ; freq := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (freq->keys()->includes(arr[i+1])) then (     freq := freq->union(Map{arr[i+1] |-> freq->at(arr[i+1]) + 1}) ) else (     freq := freq->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var len : int ; len := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (not(freq->keys()->includes(i))) then (     break ) else skip ; 
     len := len + 1 )  ;     i := i + 1 ) ; 
    return len 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,2,1,6,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(longestPermutation(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Problem21B {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a1=sc.nextInt();
    int b1=sc.nextInt();
    int c1=sc.nextInt();
    int a2=sc.nextInt();
    int b2=sc.nextInt();
    int c2=sc.nextInt();
    if((a1==0 && b1==0 && c1!=0)||(a2==0 && b2==0 && c2!=0)){
      System.out.println(0);
    }
    else if((a1*b2!=a2*b1)){
      System.out.println(1);
    }
    else if((a1*b2==a2*b1)&&(a1*c2==a2*c1)&&(b1*c2==b2*c1)){
      System.out.println(-1);
    }
    else System.out.println(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem21B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a1 : int ; a1 := sc.getCurrent()->toInteger() ;
    var b1 : int ; b1 := sc.getCurrent()->toInteger() ;
    var c1 : int ; c1 := sc.getCurrent()->toInteger() ;
    var a2 : int ; a2 := sc.getCurrent()->toInteger() ;
    var b2 : int ; b2 := sc.getCurrent()->toInteger() ;
    var c2 : int ; c2 := sc.getCurrent()->toInteger() ;
    if ((a1 = 0 & b1 = 0 & c1 /= 0) or (a2 = 0 & b2 = 0 & c2 /= 0)) then (     OclFile["System.out"].println(0) ) else     if ((a1 * b2 /= a2 * b1)) then (     OclFile["System.out"].println(1) ) else     if ((a1 * b2 = a2 * b1) & (a1 * c2 = a2 * c1) & (b1 * c2 = b2 * c1)) then (     OclFile["System.out"].println(-1) ) else     OclFile["System.out"].println(0) ; ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void divisibilityCheck(List<Integer>arr,int n){
    List<Integer>s=new ArrayList<Integer>();
    int max_ele=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      s.add(arr.get(i));
      max_ele=Math.max(max_ele,arr.get(i));
    }
    LinkedHashSet<Integer>res=new LinkedHashSet<Integer>();
    for(int i=0 ; i<n ; i++){
      if(arr.get(i)!=0)for(int j=arr.get(i)*2 ;
      j<=max_ele ;
      j+=arr.get(i)){
        if(s.contains(j))res.add(j);
      }
    }
    List<Integer>list=new ArrayList<Integer>(res);
    Collections.reverse(list);
    for(Integer temp : list)System.out.print(temp+" ");
  }
  public static void main(String args[]){
    List<Integer>arr=Arrays.asList(2,3,8,6,9,10);
    int n=arr.size();
    divisibilityCheck(arr,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation divisibilityCheck( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var s : Sequence(int) ; s := Sequence{} ;
     var max_ele : int ; max_ele := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     s := s->including(arr->at(i+1)) ; 
     max_ele := Set{max_ele, arr->at(i+1)}->max() )  ;     i := i + 1 ) ; 
    var res : Set(int) ; res := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr->at(i+1) /= 0) then         var j : int ; j := arr->at(i+1) * 2 ; while j <= max_ele do ( (     if (s->includes(j)) then     res := res->including(j) ; else skip )  ;     j := j+(arr->at(i+1)) ) ; else skip )  ;     i := i + 1 ) ; 
    var list : Sequence(int) ; list := Sequence{}->union(res) ;
    list := list->reverse() ; 
    for (temp : list) do (     OclFile["System.out"].print(temp + " ") ;  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,8,6,9,10} ;
     var n : int ; n := arr->size() ;
     execute divisibilityCheck(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    solve(System.in,System.out);
  }
  static void solve(InputStream is,PrintStream os){
    Scanner sc=new Scanner(is);
    long N=sc.nextLong();
    int ans=0 ;
    long originN=N ;
    int sqrtN=(int)Math.sqrt(N);
    for(int i=2 ; i<sqrtN ; i+=2){
      int e=0 ;
      while(N % i==0){
        N/=i ;
        e++;
      }
      int t=1 ;
      while(e>=t){
        ans++;
        e-=t ;
        t++;
      }
      if(i==2)i=1 ;
    }
    if(N!=1 && originN % N==0)ans++;
    os.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation solve( is : OclFile, os : OclFile) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(is) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    var ans : int ; ans := 0 ;
    var originN : long ; originN := N ;
    var sqrtN : int ; sqrtN := (N)->sqrt()->oclAsType(int) ;
        var i : int ; i := 2 ; while i < sqrtN do ( (     var e : int ; e := 0 ;
     while (N mod i = 0) do (     N := N/(i) ; 
     e := e + 1 ) ; 
    var t : int ; t := 1 ;
    while (e >= t) do (     ans := ans + 1 ; 
     e := e-(t) ; 
     t := t + 1 ) ; 
    if (i = 2) then     i := 1 ; else skip ; 
 )  ;     i := i+(2) ) ; 
    if (N /= 1 & originN mod N = 0) then     ans := ans + 1 ; else skip ; 
    os.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.nio.Buffer ;
import java.util.*;
public class Main2 {
  public static void main(String[] args)throws IOException,InterruptedException {
    Scanner sc=new Scanner(System.in);
    int testCases=sc.nextInt();
    while(testCases-->0){
      int activating=sc.nextInt();
      int placing=sc.nextInt();
      String input=sc.next();
      long res=0 ;
      if(placing>=activating){
        for(int i=0 ; i<input.length(); i++){
          if(input.charAt(i)=='0')continue ;
          else {
            res+=activating ;
            while(i<input.length()&& input.charAt(i)=='1')i++;
          }
        }
        System.out.println(res);
      }
      else {
        int diff=activating/placing ;
        int firstOne=-1 ;
        for(int i=0 ; i<input.length(); i++){
          if(input.charAt(i)=='1'){
            firstOne=i ;
            break ;
          }
        }
        if(firstOne==-1)System.out.println(0);
        else {
          ArrayList<Integer>array=new ArrayList<>();
          int lastOne=firstOne ;
          for(int i=firstOne+1 ; i<input.length(); i++){
            if(input.charAt(i)=='1'){
              array.add(i-lastOne-1);
              lastOne=i ;
            }
          }
          long res1=0 ;
          for(int i=0 ; i<array.size(); i++){
            int first=array.get(i);
            if(first<=diff){
              res1+=(first)*placing ;
            }
            else {
              res1+=activating ;
            }
          }
          res1+=activating ;
          System.out.println(res1);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := sc.getCurrent()->toInteger() ;
         while (testCases > 0) do (        testCases := testCases - 1 ;     skip ; (     var activating : int ; activating := sc.getCurrent()->toInteger() ;
     var placing : int ; placing := sc.getCurrent()->toInteger() ;
    var input : String ; input := sc.getCurrent() ;
    var res : long ; res := 0 ;
    if (placing >= activating) then (         var i : int ; i := 0 ; while i < input->size() do ( (     if (input->at(i+1) = '0') then     continue else (     res := res+(activating) ; 
     while (i < input->size() & input->at(i+1) = '1') do     i := i + 1 ; ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(res) ) else (     var diff : int ; diff := activating / placing ;
     var firstOne : int ; firstOne := -1 ;
         var i : int ; i := 0 ; while i < input->size() do ( (     if (input->at(i+1) = '1') then (     firstOne := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (firstOne = -1) then     OclFile["System.out"].println(0) ; else (     var array : Sequence(int) ; array := Sequence{} ;
     var lastOne : int ; lastOne := firstOne ;
        var i : int ; i := firstOne + 1 ; while i < input->size() do ( (     if (input->at(i+1) = '1') then (     array := array->including(i - lastOne - 1) ; 
     lastOne := i ) else skip )  ;     i := i + 1 ) ; 
    var res1 : long ; res1 := 0 ;
        var i : int ; i := 0 ; while i < array->size() do ( (     var first : int ; first := array->at(i+1) ;
     if (first <= diff) then (     res1 := res1+((first) * placing) ) else (     res1 := res1+(activating) ) )  ;     i := i + 1 ) ; 
    res1 := res1+(activating) ; 
    OclFile["System.out"].println(res1) ; 
 ) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.math.BigInteger ;
import java.util.HashMap ;
import java.util.Scanner ;
public class AllYourBase {
  public static void main(String[] args){
    try {
      BufferedReader in=new BufferedReader(new FileReader("A-small.in"));
      BufferedWriter out=new BufferedWriter(new FileWriter("x.txt"));
      Scanner scan=new Scanner(in);
      int T=scan.nextInt();
      scan.nextLine();
      for(int ii=0 ; ii<T ; ii++){
        String str=scan.nextLine();
        HashMap<Character,Integer>hm=new HashMap<Character,Integer>();
        hm.put(str.charAt(0),1);
        int count=1 ;
        while(count<str.length()){
          char c=str.charAt(count);
          if(! hm.containsKey(c)){
            hm.put(c,0);
            break ;
          }
          count++;
        }
        count++;
        int val=2 ;
        while(count<str.length()){
          char c=str.charAt(count);
          if(! hm.containsKey(c)){
            hm.put(c,val++);
          }
          count++;
        }
        String tgt="" ;
        for(int i=0 ; i<str.length(); i++){
          tgt+=hm.get(str.charAt(i));
        }
        BigInteger x=new BigInteger(tgt,val);
        out.write("Case #"+(ii+1)+": "+x.toString()+"\n");
      }
      in.close();
      out.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AllYourBase {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("A-small.in"))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("x.txt"))) ;
    var scan : OclFile ; scan := OclFile.newOclFile_Read(in) ;
    var T : int ; T := scan.getCurrent()->toInteger() ;
    skip ; 
        var ii : int ; ii := 0 ; while ii < T do ( (     var str : String ; str := scan.nextLine() ;
     var hm : Map(String,int) ; hm := Map{} ;
    hm := hm->union(Map{str->at(0+1) |-> 1}) ; 
    var count : int ; count := 1 ;
    while (count < str->size()) do (     var c : String ; c := str->at(count+1) ;
     if (not(hm->keys()->includes(c))) then (     hm := hm->union(Map{c |-> 0}) ; 
     break ) else skip ; 
     count := count + 1 ) ; 
    count := count + 1 ; 
    var val : int ; val := 2 ;
    while (count < str->size()) do (     var c : String ; c := str->at(count+1) ;
     if (not(hm->keys()->includes(c))) then (     hm := hm->union(Map{c |-> val}) ) else skip ; 
     count := count + 1 ) ; 
    var tgt : String ; tgt := "" ;
        var i : int ; i := 0 ; while i < str->size() do ( (     tgt := tgt+(hm->at(str->at(i+1))) )  ;     i := i + 1 ) ; 
    var x : long ; x := long(tgt, val) ;
    skip ; 
 )  ;     ii := ii + 1 ) ; 
    skip ; 
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class solution {
  public static void main(String[] args){
    int A1,B1,C1,A2,B2,C2,i=0,j,k ;
    Scanner in=new Scanner(System.in);
    A1=in.nextInt();
    B1=in.nextInt();
    C1=in.nextInt();
    A2=in.nextInt();
    B2=in.nextInt();
    C2=in.nextInt();
    if((A1==0 && B1==0 && C1!=0)||(A2==0 && B2==0 && C2!=0))i=0 ;
    else if((A1*B2-B1*A2)!=0){
      i=1 ;
    }
    else if((A1*C2==C1*A2)&&(B1*C2==B2*C1))i=-1 ;
    else i=0 ;
    System.out.print(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A1 : int ;
    var B1 : int ;
    var C1 : int ;
    var A2 : int ;
    var B2 : int ;
    var C2 : int ;
    var i : int ; i := 0 ;
    var j : int ;
    var k : int ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    A1 := in.getCurrent()->toInteger() ; 
    B1 := in.getCurrent()->toInteger() ; 
    C1 := in.getCurrent()->toInteger() ; 
    A2 := in.getCurrent()->toInteger() ; 
    B2 := in.getCurrent()->toInteger() ; 
    C2 := in.getCurrent()->toInteger() ; 
    if ((A1 = 0 & B1 = 0 & C1 /= 0) or (A2 = 0 & B2 = 0 & C2 /= 0)) then     i := 0 else     if ((A1 * B2 - B1 * A2) /= 0) then (     i := 1 ) else     if ((A1 * C2 = C1 * A2) & (B1 * C2 = B2 * C1)) then     i := -1 else     i := 0 ; ;  ;  ;  
    OclFile["System.out"].print(i) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileNotFoundException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] L=new int[N];
    for(int i=0 ; i<N ; i++){
      L[i]=sc.nextInt();
    }
    int ans=0 ;
    if(N<=2){
      System.out.println(ans);
    }
    else {
      for(int i=0 ; i<N-2 ; i++){
        for(int j=i+1 ; j<N-1 ; j++){
          for(int k=j+1 ; k<N ; k++){
            if(L[i]<(L[j]+L[k])&& L[j]<(L[k]+L[i])&& L[k]<(L[i]+L[j])&&(L[i]!=L[j] &&(L[j]!=L[k])&&(L[k]!=L[i]))){
              ans++;
            }
          }
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var L : Sequence(int) ; L := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     L[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    if (N <= 2) then (     OclFile["System.out"].println(ans) ) else (         var i : int ; i := 0 ; while i < N - 2 do ( (         var j : int ; j := i + 1 ; while j < N - 1 do ( (         var k : int ; k := j + 1 ; while k < N do ( (     if (L[i+1] < (L[j+1] + L[k+1]) & L[j+1] < (L[k+1] + L[i+1]) & L[k+1] < (L[i+1] + L[j+1]) & (L[i+1] /= L[j+1] & (L[j+1] /= L[k+1]) & (L[k+1] /= L[i+1]))) then (     ans := ans + 1 ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static FastReader in=new FastReader();
  public static void main(String[] args){
    solve();
  }
  static void solve(){
    int n=in.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=in.nextInt();
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        for(int k=j+1 ; k<n ; k++){
          if(arr[i]==arr[j] || arr[j]==arr[k] || arr[i]==arr[k])continue ;
          int[] a=new int[] {
            arr[i],arr[j],arr[k] };
            Arrays.sort(a);
            if(a[0]+a[1]>a[2])count++;
          }
        }
      }
      System.out.println(count);
    }
    static class FastReader {
      BufferedReader br ;
      StringTokenizer st ;
      public FastReader(){
        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 ;
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : FastReader := FastReader.newFastReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := in.nextInt() ;  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (         var k : int ; k := j + 1 ; while k < n do ( (     if (arr[i+1] = arr[j+1] or arr[j+1] = arr[k+1] or arr[i+1] = arr[k+1]) then     continue else skip ; 
     var a : Sequence(int) ; a := Sequence{arr[i+1],arr[j+1],arr[k+1]} ;
     a := a->sort() ; 
     if (a[0+1] + a[1+1] > a[2+1]) then     count := count + 1 ; else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] strings=br.readLine().split(" ");
    int[] ls=new int[strings.length];
    for(int i=0 ; i<ls.length ; i++){
      ls[i]=Integer.parseInt(strings[i]);
    }
    System.out.println(problem175b(n,ls));
  }
  private static int problem175b(int n,int[] ls){
    int count=0 ;
    for(int i=0 ; i<ls.length-2 ; i++){
      int li=ls[i];
      for(int j=i+1 ; j<ls.length-1 ; j++){
        int lj=ls[j];
        for(int k=j+1 ; k<ls.length ; k++){
          int lk=ls[k];
          if(isDifference(li,lj,lk)&& isTriangle(li,lj,lk)){
            count++;
          }
        }
      }
    }
    return count ;
  }
  private static boolean isDifference(int a,int b,int c){
    return(a!=b && b!=c && a!=c);
  }
  private static boolean isTriangle(int a,int b,int c){
    return((a+b)>c)&&((b+c)>a)&&((c+a)>b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var strings : Sequence(String) ; strings := br.readLine()->split(" ") ;
    var ls : Sequence(int) ; ls := Integer.subrange(1,strings->size())->collect(0) ;
        var i : int ; i := 0 ; while i < ls->size() do ( (     ls[i+1] := (strings[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(problem175b(n, ls)) ; 
 );
  static   operation problem175b( n : int, ls : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < ls->size() - 2 do ( (     var li : int ; li := ls[i+1] ;
         var j : int ; j := i + 1 ; while j < ls->size() - 1 do ( (     var lj : int ; lj := ls[j+1] ;
         var k : int ; k := j + 1 ; while k < ls->size() do ( (     var lk : int ; lk := ls[k+1] ;
     if (isDifference(li, lj, lk) & isTriangle(li, lj, lk)) then (     count := count + 1 ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation isDifference( a : int, b : int, c : int) : boolean
  pre: true
  post: true
  activity: (     return (a /= b & b /= c & a /= c) );
  static   operation isTriangle( a : int, b : int, c : int) : boolean
  pre: true
  post: true
  activity: (     return ((a + b) > c) & ((b + c) > a) & ((c + a) > b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    var sc=new Scanner(System.in);
    var n=sc.nextInt();
    var l=IntStream.range(0,n).map(i->sc.nextInt()).toArray();
    sc.close();
    Arrays.sort(l);
    var count=0 ;
    for(var i=0 ; i<n ; i++){
      for(var j=i+1 ; j<n ; j++){
        for(var k=j+1 ; k<n ; k++){
          if(l[i]<l[j] && l[j]<l[k] && l[i]+l[j]>l[k]){
            count++;
          }
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : var ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : var ; n := sc.nextInt() ;
    var l : var ; l := Integer.subrange(0, n-1)->collect( _x1 | (lambda i : OclAny in sc.nextInt())->apply(_x1) )->asSequence() ;
    sc.close() ; 
    l := l->sort() ; 
    var count : var ; count := 0 ;
        var i : var ; i := 0 ; while i < n do ( (         var j : var ; j := i + 1 ; while j < n do ( (         var k : var ; k := j + 1 ; while k < n do ( (     if (l[i+1] < l[j+1] & l[j+1] < l[k+1] & l[i+1] + l[j+1] > l[k+1]) then (     count := count + 1 ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int N=sc.nextInt();
      int[] L=new int[N];
      for(int i=0 ; i<N ; i++){
        L[i]=sc.nextInt();
      }
      int count=0 ;
      for(int i=0 ; i<N ; i++){
        for(int j=i+1 ; j<N ; j++){
          if(L[j]==L[i]){
            continue ;
          }
          for(int k=j+1 ; k<N ; k++){
            if(L[k]==L[i] || L[k]==L[j]){
              continue ;
            }
            int max=Math.max(L[i],Math.max(L[j],L[k]));
            if(L[i]==max){
              if(L[j]+L[k]>max){
                count++;
              }
            }
            if(L[j]==max){
              if(L[i]+L[k]>max){
                count++;
              }
            }
            if(L[k]==max){
              if(L[i]+L[j]>max){
                count++;
              }
            }
          }
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var L : Sequence(int) ; L := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     L[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := i + 1 ; while j < N do ( (     if (L[j+1] = L[i+1]) then (     continue ) else skip ; 
         var k : int ; k := j + 1 ; while k < N do ( (     if (L[k+1] = L[i+1] or L[k+1] = L[j+1]) then (     continue ) else skip ; 
     var max : int ; max := Set{L[i+1], Set{L[j+1], L[k+1]}->max()}->max() ;
    if (L[i+1] = max) then (     if (L[j+1] + L[k+1] > max) then (     count := count + 1 ) else skip ) else skip ; 
    if (L[j+1] = max) then (     if (L[i+1] + L[k+1] > max) then (     count := count + 1 ) else skip ) else skip ; 
    if (L[k+1] = max) then (     if (L[i+1] + L[j+1] > max) then (     count := count + 1 ) else skip ) else skip ; 
 )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int elementCount(int arr1[],int n1,int arr2[],int n2){
    int count=0 ;
    HashSet<Integer>hash=new HashSet<>();
    for(int i=0 ; i<n2 ; i++){
      hash.add(arr2[i]);
    }
    for(int i=0 ; i<n1 ; i++){
      for(int j=1 ; j*j<=arr1[i]; j++){
        if(arr1[i] % j==0){
          if((hash.contains(j)&& j!=(int)hash.toArray()[hash.size()-1])||(hash.contains(arr1[i]/j)&&(arr1[i]/j)!=(int)hash.toArray()[hash.size()-1])){
            count++;
            break ;
          }
        }
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int arr1[]={
      10,2,13,4,15 };
      int arr2[]={
        2,4,5,6 };
        int n1=arr1.length ;
        int n2=arr2.length ;
        System.out.println(elementCount(arr1,n1,arr2,n2));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation elementCount( arr1 : Sequence(int), n1 : int, arr2 : Sequence(int), n2 : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var hash : Set(int) ; hash := Set{} ;
        var i : int ; i := 0 ; while i < n2 do ( (     hash := hash->including(arr2[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n1 do ( (         var j : int ; j := 1 ; while j * j <= arr1[i+1] do ( (     if (arr1[i+1] mod j = 0) then (     if ((hash->includes(j) & j /= hash->asSequence()[hash->size() - 1+1]->oclAsType(int)) or (hash->includes(arr1[i+1] / j) & (arr1[i+1] / j) /= hash->asSequence()[hash->size() - 1+1]->oclAsType(int))) then (     count := count + 1 ; 
     break ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{10,2,13,4,15} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{2,4,5,6} ;
    var n1 : int ; n1 := arr1->size() ;
    var n2 : int ; n2 := arr2->size() ;
    OclFile["System.out"].println(elementCount(arr1, n1, arr2, n2)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countDivisibles(int A,int B,int M){
    int counter=0 ;
    for(int i=A ; i<=B ; i++)if(i % M==0)counter++;
    return counter ;
  }
  public static void main(String[] args){
    int A=30,B=100,M=30 ;
    System.out.println(countDivisibles(A,B,M));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDivisibles( A : int, B : int, M : int) : int
  pre: true
  post: true
  activity: (     var counter : int ; counter := 0 ;
         var i : int ; i := A ; while i <= B do (     if (i mod M = 0) then     counter := counter + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return counter );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 30 ;
    var B : int ; B := 100 ;
    var M : int ; M := 30 ;
     OclFile["System.out"].println(countDivisibles(A, B, M)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class cfg {
  static float squareSide(float a){
    if(a<0)return-1 ;
    float x=(0.423f*a);
    return x ;
  }
  public static void main(String[] args){
    float a=8 ;
    System.out.println(squareSide(a));
  }
}
------------------------------------------------------------
OCL File:
---------
class cfg {
  static   operation squareSide( a : double) : double
  pre: true
  post: true
  activity: (     if (a < 0) then     return -1 else skip ; 
     var x : double ; x := (0.423f * a) ;
     return x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 8 ;
     OclFile["System.out"].println(squareSide(a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static float CPwithProfit(int sellingPrice,int profit){
    float costPrice ;
    costPrice=(sellingPrice*100)/(100+profit);
    return costPrice ;
  }
  static float CPwithLoss(int sellingPrice,int loss){
    float costPrice ;
    costPrice=(sellingPrice*100)/(100-loss);
    return costPrice ;
  }
  public static void main(String args[]){
    int SP,profit,loss ;
    SP=1020 ;
    profit=20 ;
    System.out.println("Cost Price="+CPwithProfit(SP,profit));
    SP=900 ;
    loss=10 ;
    System.out.println("Cost Price="+CPwithLoss(SP,loss));
    SP=42039 ;
    profit=8 ;
    System.out.println("Cost Price="+CPwithProfit(SP,profit));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation CPwithProfit( sellingPrice : int, profit : int) : double
  pre: true
  post: true
  activity: (     var costPrice : double ;
     costPrice := (sellingPrice * 100) / (100 + profit) ; 
     return costPrice );
  static   operation CPwithLoss( sellingPrice : int, loss : int) : double
  pre: true
  post: true
  activity: (     var costPrice : double ;
     costPrice := (sellingPrice * 100) / (100 - loss) ; 
     return costPrice );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var SP : int ;
    var profit : int ;
    var loss : int ;
     SP := 1020 ; 
    profit := 20 ; 
    OclFile["System.out"].println("Cost Price=" + CPwithProfit(SP, profit)) ; 
    SP := 900 ; 
    loss := 10 ; 
    OclFile["System.out"].println("Cost Price=" + CPwithLoss(SP, loss)) ; 
    SP := 42039 ; 
    profit := 8 ; 
    OclFile["System.out"].println("Cost Price=" + CPwithProfit(SP, profit)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  PrintWriter out ;
  Scanner in ;
  String testCase="a2" ;
  public static void main(String[] args)throws Exception {
    new A().solve();
  }
  void solve()throws Exception {
    Locale.setDefault(Locale.ENGLISH);
    out=new PrintWriter(new FileOutputStream(testCase+".out"));
    in=new Scanner(new BufferedReader(new InputStreamReader(new FileInputStream(testCase+".in"))));
    int N=in.nextInt();
    for(int t=1 ; t<=N ; ++t){
      out.print("Case #"+t+": ");
      String num=in.next();
      Map<Character,Integer>map=new HashMap<Character,Integer>();
      for(char c : num.toCharArray()){
        if(map.containsKey(c)){
          continue ;
        }
        if(map.size()==0){
          map.put(c,1);
        }
        else if(map.size()==1){
          map.put(c,0);
        }
        else {
          map.put(c,map.size());
        }
      }
      long result=0 ;
      int base=map.size();
      if(base==1){
        base=2 ;
      }
      for(char c : num.toCharArray()){
        result=result*base+map.get(c);
      }
      out.println(result);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   attribute out : OclFile;
   attribute in : OclFile;
   attribute testCase : String := "a2";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     A.newA().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.ENGLISH) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(testCase + ".out")) ; 
    in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(testCase + ".in")))) ; 
    var N : int ; N := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= N do ( (     skip ; 
     var num : String ; num := in.getCurrent() ;
    var map : Map(String,int) ; map := Map{} ;
    for (c : num->characters()) do ( (     if (map->keys()->includes(c)) then (     continue ) else skip ; 
     if (map.size() = 0) then (     map := map->union(Map{c |-> 1}) ) else     if (map.size() = 1) then (     map := map->union(Map{c |-> 0}) ) else (     map := map->union(Map{c |-> map.size()}) ) ;  )  ) ; 
    var result : long ; result := 0 ;
    var base : int ; base := map.size() ;
    if (base = 1) then (     base := 2 ) else skip ; 
    for (c : num->characters()) do ( (     result := result * base + map->at(c) )  ) ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void SieveOfEratosthenes(boolean prime[],int p_size){
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=p_size ; p++){
      if(prime[p]){
        for(int i=p*2 ; i<=p_size ; i+=p)prime[i]=false ;
      }
    }
  }
  static int gcdPrimeFreq(int arr[],int n){
    boolean[] prime=new boolean[n+1];
    for(int i=0 ; i<n+1 ; i++)prime[i]=true ;
    SieveOfEratosthenes(prime,n+1);
    int i,j ;
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(i=0 ; i<n ; i++){
      if(mp.containsKey(arr[i])){
        mp.put(arr[i],mp.get(arr[i])+1);
      }
      else {
        mp.put(arr[i],1);
      }
    }
    int gcd=0 ;
    for(Map.Entry<Integer,Integer>it : mp.entrySet()){
      if(prime[it.getValue()]){
        gcd=__gcd(gcd,it.getKey());
      }
    }
    return gcd ;
  }
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  static public void main(String[] arg){
    int arr[]={
      5,4,6,5,4,6 };
      int n=arr.length ;
      System.out.println(gcdPrimeFreq(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation SieveOfEratosthenes( prime : Sequence(boolean), p_size : int) : void
  pre: true
  post: true
  activity: (     prime[0+1] := false ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p <= p_size do ( (     if (prime[p+1]) then (         var i : int ; i := p * 2 ; while i <= p_size do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation gcdPrimeFreq( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,n + 1)->collect(false) ;
         var i : int ; i := 0 ; while i < n + 1 do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
    execute SieveOfEratosthenes(prime, n + 1) ; 
    var i : int ;
    var j : int ;
    var mp : Map(int,int) ; mp := Map{} ;
        i := 0 ; while i < n do ( (     if (mp->keys()->includes(arr[i+1])) then (     mp := mp->union(Map{arr[i+1] |-> mp->at(arr[i+1]) + 1}) ) else (     mp := mp->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var gcd : int ; gcd := 0 ;
    for (it : mp->asSet()) do ( (     if (prime[it.getValue()+1]) then (     gcd := __gcd(gcd, it.getKey()) ) else skip )  ) ; 
    return gcd 
 );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static    operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,4,6,5,4,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(gcdPrimeFreq(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
import java.util.Collections ;
public class Ejercicio6 {
  public static void main(String[] args){
    Scanner lt=new Scanner(System.in);
    int t=lt.nextInt();
    while(t>0){
      int n,k ;
      n=lt.nextInt();
      k=lt.nextInt();
      ArrayList<Long>water=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        water.add((long)lt.nextInt());
      }
      long sum=0 ;
      water.sort(Collections.reverseOrder());
      for(int i=0 ; i<=k ; i++){
        sum+=water.get(i);
        water.set(i,0L);
      }
      System.out.println(sum);
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ejercicio6 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var lt : OclFile ; lt := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := lt.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ;
    var k : int ;
     n := lt.getCurrent()->toInteger() ; 
    k := lt.getCurrent()->toInteger() ; 
    var water : Sequence(long) ; water := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     water := water->including(lt.getCurrent()->toInteger()->oclAsType(long)) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    water := water.sort(reverseOrder()) ; 
        var i : int ; i := 0 ; while i <= k do ( (     sum := sum+(water->at(i+1)) ; 
     water := water.setAt(i+1,0L) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Solution7 {
  public static void main(String[] args){
    Scanner lect=new Scanner(System.in);
    int testCases=lect.nextInt();
    for(int i=0 ; i<testCases ; i++){
      int numBarriles=lect.nextInt();
      int verterBarriles=lect.nextInt();
      ArrayList<Long>array=new ArrayList<>();
      for(int j=0 ; j<numBarriles ; j++){
        array.add((long)lect.nextInt());
      }
      long result=0 ;
      array.sort(Collections.reverseOrder());
      for(int j=0 ; j<=verterBarriles ; j++){
        result+=array.get(j);
        array.set(j,0L);
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution7 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var lect : OclFile ; lect := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := lect.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < testCases do ( (     var numBarriles : int ; numBarriles := lect.getCurrent()->toInteger() ;
     var verterBarriles : int ; verterBarriles := lect.getCurrent()->toInteger() ;
    var array : Sequence(long) ; array := Sequence{} ;
        var j : int ; j := 0 ; while j < numBarriles do ( (     array := array->including(lect.getCurrent()->toInteger()->oclAsType(long)) )  ;     j := j + 1 ) ; 
    var result : long ; result := 0 ;
    array := array.sort(reverseOrder()) ; 
        var j : int ; j := 0 ; while j <= verterBarriles do ( (     result := result+(array->at(j+1)) ; 
     array := array.setAt(j+1,0L) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class Solution7 {
  public static void main(String[] args){
    Scanner lect=new Scanner(System.in);
    int testCases=lect.nextInt();
    for(int i=0 ; i<testCases ; i++){
      int numBarriles=lect.nextInt();
      int verterBarriles=lect.nextInt();
      ArrayList<Long>array=new ArrayList<>();
      for(int j=0 ; j<numBarriles ; j++){
        array.add((long)lect.nextInt());
      }
      long result=0 ;
      array.sort(Collections.reverseOrder());
      for(int j=0 ; j<=verterBarriles ; j++){
        result+=array.get(j);
        array.set(j,0L);
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution7 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var lect : OclFile ; lect := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := lect.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < testCases do ( (     var numBarriles : int ; numBarriles := lect.getCurrent()->toInteger() ;
     var verterBarriles : int ; verterBarriles := lect.getCurrent()->toInteger() ;
    var array : Sequence(long) ; array := Sequence{} ;
        var j : int ; j := 0 ; while j < numBarriles do ( (     array := array->including(lect.getCurrent()->toInteger()->oclAsType(long)) )  ;     j := j + 1 ) ; 
    var result : long ; result := 0 ;
    array := array.sort(reverseOrder()) ; 
        var j : int ; j := 0 ; while j <= verterBarriles do ( (     result := result+(array->at(j+1)) ; 
     array := array.setAt(j+1,0L) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class Solution7 {
  public static void main(String[] args){
    Scanner lect=new Scanner(System.in);
    int testCases=lect.nextInt();
    while(testCases>0){
      int numBarriles=lect.nextInt();
      int verterBarriles=lect.nextInt();
      ArrayList<Long>array=new ArrayList<>();
      for(int j=0 ; j<numBarriles ; j++){
        array.add((long)lect.nextInt());
      }
      long result=0 ;
      array.sort(Collections.reverseOrder());
      for(int j=0 ; j<=verterBarriles ; j++){
        result+=array.get(j);
        array.set(j,0L);
      }
      System.out.println(result);
      testCases--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution7 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var lect : OclFile ; lect := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := lect.getCurrent()->toInteger() ;
     while (testCases > 0) do (     var numBarriles : int ; numBarriles := lect.getCurrent()->toInteger() ;
     var verterBarriles : int ; verterBarriles := lect.getCurrent()->toInteger() ;
    var array : Sequence(long) ; array := Sequence{} ;
        var j : int ; j := 0 ; while j < numBarriles do ( (     array := array->including(lect.getCurrent()->toInteger()->oclAsType(long)) )  ;     j := j + 1 ) ; 
    var result : long ; result := 0 ;
    array := array.sort(reverseOrder()) ; 
        var j : int ; j := 0 ; while j <= verterBarriles do ( (     result := result+(array->at(j+1)) ; 
     array := array.setAt(j+1,0L) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(result) ; 
    testCases := testCases - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.HashSet ;
import java.util.Set ;
public final class p346 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p346().run());
  }
  private static final long LIMIT=1_000_000_000_000L ;
  public String run(){
    Set<Long>strongRepunits=new HashSet<>();
    strongRepunits.add(1L);
    for(int length=3 ; length<=BigInteger.valueOf(LIMIT).bitLength(); length++){
      middle : for(int base=2 ;
      ;
      base++){
        long value=0 ;
        for(int i=0 ; i<length ; i++){
          if(Long.MAX_VALUE/base<value)break middle ;
          value*=base ;
          if(value+1<value)break middle ;
          value++;
        }
        if(value>=LIMIT)break ;
        strongRepunits.add(value);
      }
    }
    long sum=0 ;
    for(long x : strongRepunits){
      if(sum+x<sum)throw new ArithmeticException("Overflow");
      sum+=x ;
    }
    return Long.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p346 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p346.newp346().run()) );
  static    attribute LIMIT : long := 1_000_000_000_000L;
   operation run() : String
  pre: true
  post: true
  activity: (     var strongRepunits : Set(long) ; strongRepunits := Set{} ;
     strongRepunits := strongRepunits->including(1L) ; 
        var length : int ; length := 3 ; while length <= (LIMIT + "")->toLong().bitLength() do ( (         var base : int ; base := 2 ; while true do ( (     var value : long ; value := 0 ;
         var i : int ; i := 0 ; while i < length do ( (     if ("9223372036854775807"->toLong() / base < value) then     break else skip ; 
     value := value*(base) ; 
     if (value + 1 < value) then     break else skip ; 
     value := value + 1 )  ;     i := i + 1 ) ; 
     if (value >= LIMIT) then     break else skip ; 
     strongRepunits := strongRepunits->including(value) )  ;     base := base + 1 ) ; )  ;     length := length + 1 ) ; 
    var sum : long ; sum := 0 ;
    for (x : strongRepunits) do ( (     if (sum + x < sum) then     error ArithmeticException("Overflow") ; else skip ; 
     sum := sum+(x) )  ) ; 
    return ((sum) + "") 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    char[] ID=scanner.next().toCharArray();
    int m=scanner.nextInt();
    int[] a=new int[m];
    for(int i=0 ; i<m ; i++)a[i]=scanner.nextInt();
    int[][] dp=new int[10][n+1];
    dp[0][0]=1 ;
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<10 ; j++){
      if(ID[n-1-i]!='*')dp[(j+slove(i,ID[n-1-i]-'0'))% 10][i+1]+=dp[j][i];
      else for(int k=0 ;
      k<m ;
      k++)dp[(j+slove(i,a[k]))% 10][i+1]+=dp[j][i];
    }
    System.out.println(dp[0][n]);
  }
  private int slove(int p,int i){
    int j=i*2 ;
    return(p % 2==1)? j/10+j % 10 : i ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var ID : Sequence(String) ; ID := scanner.getCurrent()->characters() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     a[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,10)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < 10 do ( (     if (ID[n - 1 - i+1] /= '*') then     dp[(j + slove(i, ID[n - 1 - i+1] - ('0')->char2byte())) mod 10+1][i + 1+1] := dp[(j + slove(i, ID[n - 1 - i+1] - ('0')->char2byte())) mod 10+1][i + 1+1]+(dp[j+1][i+1]) ; else         var k : int ; k := 0 ; while k < m do (     dp[(j + slove(i, a[k+1])) mod 10+1][i + 1+1] := dp[(j + slove(i, a[k+1])) mod 10+1][i + 1+1]+(dp[j+1][i+1]) ;  ;     k := k + 1 ) ; )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[0+1][n+1]) ; 
 );
   operation slove( p : int, i : int) : int
  pre: true
  post: true
  activity: (     var j : int ; j := i * 2 ;
     return if (p mod 2 = 1) then j / 10 + j mod 10 else i endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Map<String,Long>map=new TreeMap<>();
    List<Long>out=new ArrayList<>();
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      switch(sc.nextByte()){
        case 0 : map.put(sc.next(),sc.nextLong());
        break ;
        case 1 : String str=sc.next();
        if(map.containsKey(str)){
          out.add(map.get(str));
        }
        else {
          out.add(0L);
        }
        break ;
        case 2 : map.remove(sc.next());
        break ;
      }
    }
    for(long n : out){
      System.out.println(n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var map : Map(String,long) ; map := Map{} ;
    var out : Sequence(long) ; out := Sequence{} ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (sc.nextByte()) ; 
       if _switchval = 0 then
     map := map->union(Map{sc.getCurrent() |-> sc.getCurrent()->toLong()}) ; 
    break 
   else skip ;
       if _switchval = 1 then
     var str : String ; str := sc.getCurrent() ;
    if (map->keys()->includes(str)) then (     out := out->including(map->at(str)) ) else (     out := out->including(0L) ) ;  
    break 
   else skip ;
       if _switchval = 2 then
     map := map->antirestrict(Set{sc.getCurrent()}) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    for (n : out) do ( (     OclFile["System.out"].println(n) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String id=sc.next();
    int m=sc.nextInt();
    HashSet<Integer>vs=new HashSet<Integer>();
    for(int i=0 ; i<m ; i++)vs.add(sc.nextInt());
    long[][] dp=new long[2][10];
    dp[0][0]=1 ;
    int p=1 ;
    for(int i=1 ; i<=n ; i++){
      fill(dp[p],0);
      for(int j=0 ; j<10 ; j++){
        if(id.charAt(n-i)!='*')dp[p][(j+v((id.charAt(n-i)-'0')*(i % 2==1 ? 1 : 2)))% 10]+=dp[1-p][j];
        else for(int k : vs)dp[p][(j+v(k*(i % 2==1 ? 1 : 2)))% 10]+=dp[1-p][j];
      }
      p=1-p ;
    }
    System.out.println(dp[1-p][0]);
  }
  int v(int v){
    return v/10+v % 10 ;
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var id : String ; id := sc.getCurrent() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var vs : Set(int) ; vs := Set{} ;
        var i : int ; i := 0 ; while i < m do (     vs := vs->including(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,10)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
    var p : int ; p := 1 ;
        var i : int ; i := 1 ; while i <= n do ( (     execute fill(dp[p+1], 0) ; 
         var j : int ; j := 0 ; while j < 10 do ( (     if (id->at(n - i+1) /= '*') then     dp[p+1][(j + v((id->at(n - i+1) - ('0')->char2byte()) * (if i mod 2 = 1 then 1 else 2 endif))) mod 10+1] := dp[p+1][(j + v((id->at(n - i+1) - ('0')->char2byte()) * (if i mod 2 = 1 then 1 else 2 endif))) mod 10+1]+(dp[1 - p+1][j+1]) ; else     for (k : vs) do (     dp[p+1][(j + v(k * (if i mod 2 = 1 then 1 else 2 endif))) mod 10+1] := dp[p+1][(j + v(k * (if i mod 2 = 1 then 1 else 2 endif))) mod 10+1]+(dp[1 - p+1][j+1]) ;  ) ; )  ;     j := j + 1 ) ; 
     p := 1 - p )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[1 - p+1][0+1]) ; 
 );
   operation v( v : int) : int
  pre: true
  post: true
  activity: (     return v / 10 + v mod 10 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MOD=1000000007 ;
  static void SieveOfEratosthenes(boolean prime[],int p_size){
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=p_size ; p++){
      if(prime[p]){
        for(int i=p*2 ; i<=p_size ; i+=p)prime[i]=false ;
      }
    }
  }
  static int productPrimeFreq(int arr[],int n){
    boolean[] prime=new boolean[n+1];
    for(int i=0 ; i<n ; i++)prime[i]=true ;
    SieveOfEratosthenes(prime,n+1);
    int i,j ;
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(i=0 ; i<n ; i++){
      if(mp.containsKey(arr[i])){
        mp.put(arr[i],mp.get(arr[i])+1);
      }
      else {
        mp.put(arr[i],1);
      }
    }
    long product=1 ;
    for(Map.Entry<Integer,Integer>it : mp.entrySet()){
      if(prime[it.getValue()]){
        product*=(it.getKey()% MOD);
        product %=MOD ;
      }
    }
    return(int)(product);
  }
  static public void main(String[] arg){
    int arr[]={
      5,4,6,5,4,6 };
      int n=arr.length ;
      System.out.println(productPrimeFreq(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MOD : int := 1000000007;
  static   operation SieveOfEratosthenes( prime : Sequence(boolean), p_size : int) : void
  pre: true
  post: true
  activity: (     prime[0+1] := false ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p <= p_size do ( (     if (prime[p+1]) then (         var i : int ; i := p * 2 ; while i <= p_size do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation productPrimeFreq( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,n + 1)->collect(false) ;
         var i : int ; i := 0 ; while i < n do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
    execute SieveOfEratosthenes(prime, n + 1) ; 
    var i : int ;
    var j : int ;
    var mp : Map(int,int) ; mp := Map{} ;
        i := 0 ; while i < n do ( (     if (mp->keys()->includes(arr[i+1])) then (     mp := mp->union(Map{arr[i+1] |-> mp->at(arr[i+1]) + 1}) ) else (     mp := mp->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var product : long ; product := 1 ;
    for (it : mp->asSet()) do ( (     if (prime[it.getValue()+1]) then (     product := product*((it.getKey() mod MOD)) ; 
     product := product mod MOD ) else skip )  ) ; 
    return (product)->oclAsType(int) 
 );
  static    operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,4,6,5,4,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(productPrimeFreq(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] s=sc.next().toCharArray();
    int m=sc.nextInt();
    Set<Integer>set=new HashSet<Integer>();
    for(int i=0 ; i<m ; i++)set.add(sc.nextInt());
    long[][] dp=new long[2][10];
    int X=1 ;
    dp[0][0]=1 ;
    for(int i=1 ; i<=n ; i++,X=1-X){
      Arrays.fill(dp[X],0);
      for(int j=0 ; j<10 ; j++){
        if(s[n-i]=='*'){
          for(int x : set){
            if(i % 2==0)x*=2 ;
            dp[X][(j+(x/10)+(x % 10))% 10]+=dp[1-X][j];
          }
        }
        else {
          int x=s[n-i]-'0' ;
          if(i % 2==0)x*=2 ;
          dp[X][(j+(x/10)+(x % 10))% 10]+=dp[1-X][j];
        }
      }
    }
    System.out.println(dp[1-X][0]);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < m do (     set := set->including(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,10)->collect(0)) ;
    var X : int ; X := 1 ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do ( (     dp[X+1] := dp[X+1]->collect(0) ; 
         var j : int ; j := 0 ; while j < 10 do ( (     if (s[n - i+1] = '*') then (     for (x : set) do ( (     if (i mod 2 = 0) then     x := x*(2) ; else skip ; 
     dp[X+1][(j + (x / 10) + (x mod 10)) mod 10+1] := dp[X+1][(j + (x / 10) + (x mod 10)) mod 10+1]+(dp[1 - X+1][j+1]) )  ) ) else (     var x : int ; x := s[n - i+1] - ('0')->char2byte() ;
     if (i mod 2 = 0) then     x := x*(2) ; else skip ; 
     dp[X+1][(j + (x / 10) + (x mod 10)) mod 10+1] := dp[X+1][(j + (x / 10) + (x mod 10)) mod 10+1]+(dp[1 - X+1][j+1]) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ;     X := 1 - X ) ; 
    OclFile["System.out"].println(dp[1 - X+1][0+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maxCountAB(String s[],int n){
    int A=0,B=0,BA=0,ans=0 ;
    for(int i=0 ; i<n ; i++){
      String S=s[i];
      int L=S.length();
      for(int j=0 ; j<L-1 ; j++){
        if(S.charAt(j)=='A' && S.charAt(j+1)=='B'){
          ans++;
        }
      }
      if(S.charAt(0)=='B' && S.charAt(L-1)=='A')BA++;
      else if(S.charAt(0)=='B')B++;
      else if(S.charAt(L-1)=='A')A++;
    }
    if(BA==0)ans+=Math.min(B,A);
    else if(A+B==0)ans+=BA-1 ;
    else ans+=BA+Math.min(B,A);
    return ans ;
  }
  public static void main(String[] args){
    String s[]={
      "ABCA","BOOK","BAND" };
      int n=s.length ;
      System.out.println(maxCountAB(s,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxCountAB( s : Sequence(String), n : int) : int
  pre: true
  post: true
  activity: (     var A : int ; A := 0 ;
    var B : int ; B := 0 ;
    var BA : int ; BA := 0 ;
    var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var S : String ; S := s[i+1] ;
     var L : int ; L := S->size() ;
         var j : int ; j := 0 ; while j < (L)->char2byte() - 1 do ( (     if (S->at(j+1) = 'A' & S->at(j + 1+1) = 'B') then (     ans := ans + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (S->at(0+1) = 'B' & S->at((L)->char2byte() - 1+1) = 'A') then     BA := BA + 1 ; else     if (S->at(0+1) = 'B') then     B := B + 1 else     if (S->at((L)->char2byte() - 1+1) = 'A') then     A := A + 1 ; else skip ; ;  )  ;     i := i + 1 ) ; 
     if (BA = 0) then     ans := ans+(Set{B, A}->min()) else     if (A + B = 0) then     ans := ans+(BA - 1) else     ans := ans+(BA + Set{B, A}->min()) ; ;  ;  
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := Sequence{"ABCA","BOOK","BAND"} ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].println(maxCountAB(s, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.util.Comparator ;
import java.util.NavigableSet ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class B960 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int K1=in.nextInt();
    int K2=in.nextInt();
    int K=K1+K2 ;
    int[] A=new int[N];
    for(int n=0 ; n<N ; n++){
      A[n]=in.nextInt();
    }
    int[] B=new int[N];
    for(int n=0 ; n<N ; n++){
      B[n]=in.nextInt();
    }
    NavigableSet<Point>set=new TreeSet<>(new Comparator<Point>(){
      @ Override public int compare(Point o1,Point o2){
        int diff=o2.x-o1.x ;
        return(diff==0)?(o1.y-o2.y): diff ;
      }
    }
);
    for(int n=0 ; n<N ; n++){
      set.add(new Point(Math.abs(A[n]-B[n]),n));
    }
    long answer=0 ;
    for(int k=0 ; k<K ; k++){
      Point p=set.pollFirst();
      if(p.x==0){
        answer+=(K-k)% 2 ;
        break ;
      }
      p.x--;
      set.add(p);
    }
    for(Point p : set){
      answer+=p.x*(long)p.x ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B960 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var K1 : int ; K1 := in.getCurrent()->toInteger() ;
    var K2 : int ; K2 := in.getCurrent()->toInteger() ;
    var K : int ; K := K1 + K2 ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var B : Sequence(int) ; B := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     B[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var set : NavigableSet<Point> ; set := Set{}->union(OclComparator<Point>.newOclComparator()) ;
        var n : int ; n := 0 ; while n < N do ( (     set->excludes(Point.newPoint(if A[n+1] - B[n+1] < 0 then -(A[n+1] - B[n+1]) else A[n+1] - B[n+1] endif, n)) )  ;     n := n + 1 ) ; 
    var answer : long ; answer := 0 ;
        var k : int ; k := 0 ; while k < K do ( (     var p : Point ; p := set->first() ;
     if (p.x = 0) then (     answer := answer+((K - k) mod 2) ; 
     break ) else skip ; 
     p.x := p.x - 1 ; 
     set->excludes(p) )  ;     k := k + 1 ) ; 
    for (p : set) do ( (     answer := answer+(p.x * p.x->oclAsType(long)) )  ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean isVowel(char ch){
    ch=Character.toUpperCase(ch);
    return(ch=='A' || ch=='E' || ch=='I' || ch=='O' || ch=='U');
  }
  static int countVowels(String str){
    int count=0 ;
    for(int i=0 ; i<str.length(); i++)if(isVowel(str.charAt(i)))++count ;
    return count ;
  }
  public static void main(String args[]){
    String str="abc de" ;
    System.out.println(countVowels(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isVowel( ch : String) : boolean
  pre: true
  post: true
  activity: (     ch := (ch + "")->toUpperCase() ; 
     return (ch = 'A' or ch = 'E' or ch = 'I' or ch = 'O' or ch = 'U') );
  static   operation countVowels( str : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < str->size() do (     if (isVowel(str->at(i+1))) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abc de" ;
     OclFile["System.out"].println(countVowels(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    HashSet<Integer>h=new HashSet<>();
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int x=s.nextInt();
      if(x>n){
        count++;
        continue ;
      }
      if(h.contains(x)){
        count++;
        continue ;
      }
      h.add(x);
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var h : Set(int) ; h := Set{} ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := s.getCurrent()->toInteger() ;
     if (x > n) then (     count := count + 1 ; 
     continue ) else skip ; 
     if (h->includes(x)) then (     count := count + 1 ; 
     continue ) else skip ; 
     h := h->including(x) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class cdf137b {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[] arr1=new int[n];
    int[] placebo=new int[n];
    int number=1 ;
    int counter=0 ;
    for(int i=0 ; i<n ; i++){
      arr1[i]=scan.nextInt();
    }
    Arrays.sort(arr1);
    for(int i=0 ; i<n ; i++){
      placebo[i]=number ;
      number++;
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(placebo[i]==arr1[j]){
          counter++;
          placebo[i]=-1 ;
        }
      }
    }
    System.out.println(n-counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cdf137b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n)->collect(0) ;
    var placebo : Sequence(int) ; placebo := Integer.subrange(1,n)->collect(0) ;
    var number : int ; number := 1 ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr1[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr1 := arr1->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     placebo[i+1] := number ; 
     number := number + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (placebo[i+1] = arr1[j+1]) then (     counter := counter + 1 ; 
     placebo[i+1] := -1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n - counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class cf137B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int arr[]=new int[n];
    int arr1[]=new int[n];
    int counter=0 ;
    int number=1 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=scan.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      arr1[i]=number ;
      number++;
    }
    Arrays.sort(arr);
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(arr[i]==arr1[j]){
          counter++;
          arr1[j]=-1 ;
        }
      }
    }
    System.out.println(n-counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf137B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n)->collect(0) ;
    var counter : int ; counter := 0 ;
    var number : int ; number := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr1[i+1] := number ; 
     number := number + 1 )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (arr[i+1] = arr1[j+1]) then (     counter := counter + 1 ; 
     arr1[j+1] := -1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n - counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution15 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    HashMap<Integer,Integer>h=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      h.put(x,1);
    }
    int c=0 ;
    for(int i=1 ; i<=n ; i++){
      if(! h.containsKey(i)){
        c++;
      }
    }
    System.out.println(c);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution15 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var h : Map(int,int) ; h := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     h := h->union(Map{x |-> 1}) )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (not(h->keys()->includes(i))) then (     c := c + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileInputStream ;
import java.io.FileNotFoundException ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
public class P1 {
  public static void main(String args[])throws FileNotFoundException {
    Scanner s=new Scanner(new FileInputStream("A-large.in"));
    int cnt=s.nextInt();
    for(int cases=0 ; cases<cnt ; cases++){
      String buf=s.next();
      long num=0 ;
      int bb=-1 ;
      int[] ar=new int[buf.length()];
      HashMap<String,Integer>set=new HashMap<String,Integer>();
      set.put(buf.substring(0,1),1);
      for(int i=0 ; i<buf.length(); i++){
        if(set.containsKey(buf.substring(i,i+1))){
          ar[i]=set.get(buf.substring(i,i+1));
        }
        else {
          bb++;
          if(bb==1){
            bb=2 ;
          }
          set.put(buf.substring(i,i+1),bb);
          ar[i]=bb ;
        }
      }
      bb++;
      if(bb<2){
        bb=2 ;
      }
      for(int i=0 ; i<buf.length(); i++){
        long temp=1 ;
        for(int j=0 ; j<buf.length()-i-1 ; j++){
          temp=temp*(long)bb ;
        }
        num+=(long)ar[i]*temp ;
      }
      System.out.println("Case #"+(cases+1)+": "+num);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("A-large.in"))) ;
     var cnt : int ; cnt := s.getCurrent()->toInteger() ;
         var cases : int ; cases := 0 ; while cases < cnt do ( (     var buf : String ; buf := s.getCurrent() ;
     var num : long ; num := 0 ;
    var bb : int ; bb := -1 ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,buf->size())->collect(0) ;
    var set : Map(String,int) ; set := Map{} ;
    set := set->union(Map{buf.subrange(0+1,1) |-> 1}) ; 
        var i : int ; i := 0 ; while i < buf->size() do ( (     if (set->keys()->includes(buf.subrange(i+1,i + 1))) then (     ar[i+1] := set->at(buf.subrange(i+1,i + 1)) ) else (     bb := bb + 1 ; 
     if (bb = 1) then (     bb := 2 ) else skip ; 
     set := set->union(Map{buf.subrange(i+1,i + 1) |-> bb}) ; 
     ar[i+1] := bb ) )  ;     i := i + 1 ) ; 
    bb := bb + 1 ; 
    if (bb < 2) then (     bb := 2 ) else skip ; 
        var i : int ; i := 0 ; while i < buf->size() do ( (     var temp : long ; temp := 1 ;
         var j : int ; j := 0 ; while j < buf->size() - i - 1 do ( (     temp := temp * bb->oclAsType(long) )  ;     j := j + 1 ) ; 
     num := num+(ar[i+1]->oclAsType(long) * temp) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Case #" + (cases + 1) + ": " + num) ; 
 )  ;     cases := cases + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printDiamond(int n){
    System.out.println();
    int i,j=0 ;
    for(i=0 ; i<n ; i++){
      for(j=i ; j<n ; j++)System.out.print("*");
      for(j=0 ; j<2*i+1 ; j++)System.out.print(" ");
      for(j=i ; j<n ; j++)System.out.print("*");
      System.out.println();
    }
    for(i=0 ; i<n-1 ; i++){
      for(j=0 ; j<i+2 ; j++)System.out.print("*");
      for(j=0 ; j<2*(n-1-i)-1 ; j++)System.out.print(" ");
      for(j=0 ; j<i+2 ; j++)System.out.print("*");
      System.out.println();
    }
    System.out.println();
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println("Inverse Diamond Pattern for n="+n);
    printDiamond(n);
    n=7 ;
    System.out.println("\nInverse Diamond Pattern for n="+n);
    printDiamond(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printDiamond( n : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() ; 
     var i : int ;
    var j : int ; j := 0 ;
        i := 0 ; while i < n do ( (         j := i ; while j < n do (     OclFile["System.out"].print("*") ;  ;     j := j + 1 ) ; 
         j := 0 ; while j < 2 * i + 1 do (     OclFile["System.out"].print(" ") ;  ;     j := j + 1 ) ; 
         j := i ; while j < n do (     OclFile["System.out"].print("*") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n - 1 do ( (         j := 0 ; while j < i + 2 do (     OclFile["System.out"].print("*") ;  ;     j := j + 1 ) ; 
         j := 0 ; while j < 2 * (n - 1 - i) - 1 do (     OclFile["System.out"].print(" ") ;  ;     j := j + 1 ) ; 
         j := 0 ; while j < i + 2 do (     OclFile["System.out"].print("*") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println("Inverse Diamond Pattern for n=" + n) ; 
    execute printDiamond(n) ; 
    n := 7 ; 
    OclFile["System.out"].println("\nInverse Diamond Pattern for n=" + n) ; 
    execute printDiamond(n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int Series(int Arr[],int N,int K){
    int count=0 ;
    for(int i=0 ; i<N ; i++)if(Arr[i]==1)count++;
    if(K>=(N-count))return 1 ;
    else return 0 ;
  }
  public static void main(String[] args){
    int Arr[]={
      5,1,2 };
      int N=Arr.length ;
      int K=2 ;
      int result=Series(Arr,N,K);
      if(result==1)System.out.println("Possible");
      else System.out.println("Not Possible");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Series( Arr : Sequence(int), N : int, K : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < N do (     if (Arr[i+1] = 1) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     if (K >= (N - count)) then     return 1 else     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Arr : Sequence(int) ; Arr := Sequence{5,1,2} ;
     var N : int ; N := Arr->size() ;
    var K : int ; K := 2 ;
    var result : int ; result := Series(Arr, N, K) ;
    if (result = 1) then     OclFile["System.out"].println("Possible") else     OclFile["System.out"].println("Not Possible") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.util.Scanner ;
public class B {
  static Scanner in ;
  static PrintWriter out ;
  public static void main(String[] args)throws FileNotFoundException {
    in=new Scanner(new File("input.txt"));
    out=new PrintWriter("output.txt");
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      out.println("Case #"+(i+1)+": "+new B().solve());
    }
    out.close();
  }
  private Object solve(){
    int n=in.nextInt();
    int m=in.nextInt();
    int a=in.nextInt();
    boolean[] q=new boolean[n*m+1];
    int[] xx=new int[n*m+1];
    int[] yy=new int[n*m+1];
    for(int x=0 ; x<=n ; x++){
      for(int y=0 ; y<=m ; y++){
        int z=(x*y);
        q[z]=true ;
        xx[z]=x ;
        yy[z]=y ;
      }
    }
    for(int i=0 ; i<=(n*m-a); i++){
      if(q[i] && q[i+a]){
        return "0 0 "+xx[i]+" "+yy[i+a]+" "+xx[i+a]+" "+yy[i];
      }
    }
    return "IMPOSSIBLE" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile("input.txt")) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ; 
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation solve() : OclAny
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var q : Sequence(boolean) ; q := Integer.subrange(1,n * m + 1)->collect(false) ;
    var xx : Sequence(int) ; xx := Integer.subrange(1,n * m + 1)->collect(0) ;
    var yy : Sequence(int) ; yy := Integer.subrange(1,n * m + 1)->collect(0) ;
        var x : int ; x := 0 ; while x <= n do ( (         var y : int ; y := 0 ; while y <= m do ( (     var z : int ; z := (x * y) ;
     q[z+1] := true ; 
     xx[z+1] := x ; 
     yy[z+1] := y )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
        var i : int ; i := 0 ; while i <= (n * m - a) do ( (     if (q[i+1] & q[i + a+1]) then (     return "0 0 " + xx[i+1] + " " + yy[i + a+1] + " " + xx[i + a+1] + " " + yy[i+1] ) else skip )  ;     i := i + 1 ) ; 
    return "IMPOSSIBLE" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final long MOD=998244353 ;
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] X=new int[N];
    int[] D=new int[N];
    TreeMap<Integer,Node>mp=new TreeMap<>();
    for(int i=0 ; i<N ; i++){
      X[i]=sc.nextInt();
      D[i]=sc.nextInt();
      mp.put(X[i],new Node(X[i]+D[i]));
    }
    PriorityQueue<Integer>pq=new PriorityQueue<>();
    for(Integer x : mp.descendingKeySet()){
      Node now=mp.get(x);
      while(! pq.isEmpty()){
        if(pq.peek()>=now.pos){
          break ;
        }
        else {
          now.children.add(mp.get(pq.poll()));
        }
      }
      pq.add(x);
    }
    long ans=1 ;
    while(! pq.isEmpty()){
      int target=pq.poll();
      ans*=mp.get(target).cnt();
      ans %=MOD ;
    }
    System.out.println(ans);
  }
  private static class Node {
    public List<Node>children=new ArrayList<>();
    public int pos ;
    Node(int p){
      pos=p ;
    }
    long cnt(){
      if(children.size()==0){
        return 2 ;
      }
      long ans=1 ;
      for(Node c : children){
        ans*=c.cnt();
        ans %=MOD ;
      }
      ans++;
      ans %=MOD ;
      return ans ;
    }
    @ Override public String toString(){
      return pos+children.toString();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 998244353;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var X : Sequence(int) ; X := Integer.subrange(1,N)->collect(0) ;
    var D : Sequence(int) ; D := Integer.subrange(1,N)->collect(0) ;
    var mp : Map(int,Node) ; mp := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     X[i+1] := sc.getCurrent()->toInteger() ; 
     D[i+1] := sc.getCurrent()->toInteger() ; 
     mp := mp->union(Map{X[i+1] |-> Node.newNode(X[i+1] + D[i+1])}) )  ;     i := i + 1 ) ; 
    var pq : Sequence(int) ; pq := Sequence{} ;
    for (x : mp.descendingKeySet()) do ( (     var now : Node ; now := mp->at(x) ;
     while (not(pq->isEmpty())) do (     if (pq->min() >= now.pos) then (     break ) else (     now.children->excludes(mp->at(pq->min())) ) ) ; 
     pq := pq->including(x) )  ) ; 
    var ans : long ; ans := 1 ;
    while (not(pq->isEmpty())) do (     var target : int ; target := pq->min() ;
     ans := ans*(mp->at(target).cnt()) ; 
     ans := ans mod MOD ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class Node {
   attribute children : Sequence(Node) := Sequence{};
   attribute pos : int;
   static operation newNode( p : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(p);
    return self );
  operation initialise( p : int) : void
  pre: true  post: true
  activity: (     pos := p );
   operation cnt() : long
  pre: true
  post: true
  activity: (     if (children->size() = 0) then (     return 2 ) else skip ; 
     var ans : long ; ans := 1 ;
    for (c : children) do ( (     ans := ans*(c.cnt()) ; 
     ans := ans mod MOD )  ) ; 
    ans := ans + 1 ; 
    ans := ans mod MOD ; 
    return ans 
 );
      operation toString() : String
  pre: true
  post: true
  activity: (     return pos + children+"" );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int usingBinarySearch(int start,int end,int N,int S){
    if(start>=end)return start ;
    int mid=start+(end-start)/2 ;
    int totalSum=(N*(N+1))/2 ;
    int midSum=(mid*(mid+1))/2 ;
    if((totalSum-midSum)<=S){
      return usingBinarySearch(start,mid,N,S);
    }
    return usingBinarySearch(mid+1,end,N,S);
  }
  public static void main(String[] args){
    int N,S ;
    N=5 ;
    S=11 ;
    System.out.println(N-usingBinarySearch(1,N,N,S)+1);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation usingBinarySearch( start : int, end : int, N : int, S : int) : int
  pre: true
  post: true
  activity: (     if (start >= end) then     return start else skip ; 
     var mid : int ; mid := start + (end - start) / 2 ;
    var totalSum : int ; totalSum := (N * (N + 1)) / 2 ;
    var midSum : int ; midSum := (mid * (mid + 1)) / 2 ;
    if ((totalSum - midSum) <= S) then (     return usingBinarySearch(start, mid, N, S) ) else skip ; 
    return usingBinarySearch(mid + 1, end, N, S) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ;
    var S : int ;
     N := 5 ; 
     S := 11 ; 
     OclFile["System.out"].println(N - usingBinarySearch(1, N, N, S) + 1) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.HashMap ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    DBannedK solver=new DBannedK();
    solver.solve(1,in,out);
    out.close();
  }
  static class DBannedK {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int[] a=new int[n];
      HashMap<Integer,Integer>map=new HashMap<>();
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
        if(map.containsKey(a[i])){
          map.put(a[i],map.get(a[i])+1);
        }
        else {
          map.put(a[i],1);
        }
      }
      long sum=0 ;
      for(int e : map.values()){
        sum+=(long)e*(e-1)/2 ;
      }
      long[] ans=new long[n];
      for(int i=0 ; i<n ; i++){
        int v=map.get(a[i]);
        out.println(sum-v+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : DBannedK ; solver := DBannedK.newDBannedK() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class DBannedK {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     if (map->keys()->includes(a[i+1])) then (     map := map->union(Map{a[i+1] |-> map->at(a[i+1]) + 1}) ) else (     map := map->union(Map{a[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    for (e : map->values()) do ( (     sum := sum+(e->oclAsType(long) * (e - 1) / 2) )  ) ; 
    var ans : Sequence(long) ; ans := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := map->at(a[i+1]) ;
     skip )  ;     i := i + 1 ) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int a[]=new int[N];
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextInt();
    }
    int b[]=new int[1000000];
    for(int i=0 ; i<N ; i++){
      b[a[i] ]++;
    }
    BigDecimal sum=new BigDecimal(0);
    for(int i=0 ; i<b.length ; i++){
      BigDecimal big=new BigDecimal(b[i]);
      BigDecimal minusone=big.add(new BigDecimal("-1"));
      big=big.multiply(minusone);
      big=big.divide(new BigDecimal(2));
      sum=sum.add(big);
    }
    for(int i=0 ; i<N ; i++){
      BigDecimal temp=sum ;
      BigDecimal big=new BigDecimal(b[a[i] ]);
      BigDecimal minusone=big.add(new BigDecimal("-1"));
      big=big.multiply(minusone);
      big=big.divide(new BigDecimal(2));
      temp=temp.add(big.multiply(new BigDecimal("-1")));
      big=new BigDecimal(b[a[i] ]);
      big=big.add(new BigDecimal("-2"));
      big=big.multiply(minusone);
      big=big.divide(new BigDecimal(2));
      temp=temp.add(big);
      System.out.println(temp);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,1000000)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     b[a[i+1]+1] := b[a[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var sum : double ; sum := double(0) ;
        var i : int ; i := 0 ; while i < b->size() do ( (     var big : double ; big := double(b[i+1]) ;
     var minusone : double ; minusone := big->excludes(double("-1")) ;
    big := big.multiply(minusone) ; 
    big := big.divide(double(2)) ; 
    sum := sum->excludes(big) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var temp : double ; temp := sum ;
     var big : double ; big := double(b[a[i+1]+1]) ;
    var minusone : double ; minusone := big->excludes(double("-1")) ;
    big := big.multiply(minusone) ; 
    big := big.divide(double(2)) ; 
    temp := temp->excludes(big.multiply(double("-1"))) ; 
    big := double(b[a[i+1]+1]) ; 
    big := big->excludes(double("-2")) ; 
    big := big.multiply(minusone) ; 
    big := big.divide(double(2)) ; 
    temp := temp->excludes(big) ; 
    OclFile["System.out"].println(temp) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static MyReader in=new MyReader();
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    int N=in.i();
    int[] A=in.ii();
    int[] count=new int[N+1];
    HashSet<Integer>idx=new HashSet<>(N);
    for(int i=0 ; i<N ; i++){
      count[A[i] ]++;
      idx.add(A[i]);
    }
    long sum=0 ;
    for(int i : idx){
      sum+=(long)count[i]*(count[i]-1)/2 ;
    }
    for(int i=0 ; i<N ; i++){
      out.println(sum-count[A[i] ]+1);
    }
    out.flush();
  }
  static class MyReader extends BufferedReader {
    MyReader(){
      super(new InputStreamReader(System.in));
    }
    String s(){
      try {
        return readLine();
      }
      catch(IOException e){
        return "" ;
      }
    }
    String[] ss(){
      return s().split(" ");
    }
    int i(){
      return Integer.parseInt(s());
    }
    int[] ii(){
      String[] ss=ss();
      int[] ii=new int[ss.length];
      for(int j=0 ; j<ss.length ; j++)ii[j]=Integer.parseInt(ss[j]);
      return ii ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : MyReader := MyReader.newMyReader();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.i() ;
     var A : Sequence(int) ; A := in.ii() ;
    var count : Sequence(int) ; count := Integer.subrange(1,N + 1)->collect(0) ;
    var idx : Set(int) ; idx := Set{} ;
        var i : int ; i := 0 ; while i < N do ( (     count[A[i+1]+1] := count[A[i+1]+1] + 1 ; 
     idx := idx->including(A[i+1]) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    for (i : idx) do ( (     sum := sum+(count[i+1]->oclAsType(long) * (count[i+1] - 1) / 2) )  ) ; 
        var i : int ; i := 0 ; while i < N do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class MyReader extends OclFile {
   static operation newMyReader() : MyReader
  pre: true
  post: true
  activity:
  ( var self : MyReader ;
    self := createMyReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation s() : String
  pre: true
  post: true
  activity: (     try (     return readLine() )   catch (e : IOException) do (     return "" )
 );
   operation ss() : Sequence(String)
  pre: true
  post: true
  activity: (     return s()->split(" ") );
   operation i() : int
  pre: true
  post: true
  activity: (     return (s())->toInteger() );
   operation ii() : Sequence(int)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var ii : Sequence(int) ; ii := Integer.subrange(1,ss->size())->collect(0) ;
         var j : int ; j := 0 ; while j < ss->size() do (     ii[j+1] := (ss[j+1])->toInteger() ;  ;     j := j + 1 ) ; 
     return ii );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private void solve()throws IOException {
    int n=nextInt();
    int hash[]=new int[n+1];
    int a[]=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      a[i]=nextInt();
      hash[a[i] ]++;
    }
    long ans=0 ;
    for(int i=1 ; i<=n ; i++)ans+=1l*hash[i]*(hash[i]-1)/2 ;
    for(int i=1 ; i<=n ; i++){
      out.println(ans-(1l*hash[a[i] ]*(hash[a[i] ]-1)/2)+(1l*(hash[a[i] ]-1)*(hash[a[i] ]-2)/2));
    }
  }
  public void run()throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    st=null ;
    out=new PrintWriter(System.out);
    solve();
    br.close();
    out.close();
  }
  public static void main(String args[])throws IOException {
    new Main().run();
  }
  BufferedReader br ;
  StringTokenizer st ;
  PrintWriter out ;
  String nextToken()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  String nextLine()throws IOException {
    return br.readLine();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var hash : Sequence(int) ; hash := Integer.subrange(1,n + 1)->collect(0) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := nextInt() ; 
     hash[a[i+1]+1] := hash[a[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do (     ans := ans+(1l * hash[i+1] * (hash[i+1] - 1) / 2) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     out.println(ans - (1l * hash[a[i+1]+1] * (hash[a[i+1]+1] - 1) / 2) + (1l * (hash[a[i+1]+1] - 1) * (hash[a[i+1]+1] - 2) / 2)) )  ;     i := i + 1 ) ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := null ; 
    out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    br.close() ; 
    out.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute br : OclFile;
   attribute st : OclIterator;
   attribute out : OclFile;
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    List<Integer>list=new ArrayList<Integer>();
    int[] array=new int[2000000];
    Long[] tori=new Long[2000000];
    int n=sc.nextInt();
    for(int i=0 ; 2000000>i ; i++){
      array[i]=0 ;
    }
    for(int i=0 ; n>i ; i++){
      int a=sc.nextInt();
      array[a]++;
      list.add(a);
    }
    for(int i=0 ; 2000000>i ; i++){
      tori[i]=(((long)array[i]*(long)(array[i]-1))/2);
    }
    long goukei=0 ;
    for(int i=0 ; 2000000>i ; i++){
      goukei=goukei+tori[i];
    }
    for(int i=0 ; n>i ; i++){
      int a=list.get(i);
      System.out.println(goukei-array[a]+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(int) ; list := Sequence{} ;
    var array : Sequence(int) ; array := Integer.subrange(1,2000000)->collect(0) ;
    var tori : Sequence(long) ; tori := Integer.subrange(1,2000000)->collect(null) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while 2000000 > i do ( (     array[i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while n > i do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     array[a+1] := array[a+1] + 1 ; 
     list := list->including(a) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while 2000000 > i do ( (     tori[i+1] := ((array[i+1]->oclAsType(long) * (array[i+1] - 1)->oclAsType(long)) / 2) )  ;     i := i + 1 ) ; 
    var goukei : long ; goukei := 0 ;
        var i : int ; i := 0 ; while 2000000 > i do ( (     goukei := goukei + tori[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while n > i do ( (     var a : int ; a := list->at(i+1) ;
     OclFile["System.out"].println(goukei - array[a+1] + 1) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Ishu {
  static long gcd(long a,long b){
    if(b==0)return a ;
    else return gcd(b,a % b);
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    long t ;
    long n,ans=1 ;
    t=scan.nextLong();
    while(t-->0){
      n=scan.nextLong();
      ans=1+((4*n)/gcd(4*n,n+1));
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ishu {
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else     return gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : long ;
    var n : long ;
    var ans : long ; ans := 1 ;
    t := scan.getCurrent()->toLong() ; 
        while (t > 0) do (        t := t - 1 ;     skip ; (     n := scan.getCurrent()->toLong() ; 
     ans := 1 + ((4 * n) / gcd(4 * n, n + 1)) ; 
     OclFile["System.out"].println(ans) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long powl(long a,int b){
    if(a==0)return 0 ;
    long ans=1 ;
    while(b>0){
      if((b & 1)>0)ans*=a ;
      a*=a ;
      b>>=1 ;
    }
    return ans ;
  }
  static PrintWriter out=new PrintWriter(System.out);
  static Scanner in=new Scanner(System.in);
  static BufferedReader re=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter wr=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws IOException {
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int T=in.nextInt();
    while(T>0){
      int n=in.nextInt();
      int arr[]=new int[n];
      long t=0 ;
      int v=0 ;
      for(int i=0 ; i<n ; i++){
        int x=in.nextInt();
        if(x==1)t++;
        if(x==0)v++;
      }
      long sum=powl(2,v);
      long res=sum*t ;
      out.println(res);
      T--;
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation powl( a : long, b : int) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return 0 else skip ; 
     var ans : long ; ans := 1 ;
     while (b > 0) do (     if ((b & 1) > 0) then     ans := ans*(a) ; else skip ; 
     a := a*(a) ; 
     b := b/(2->pow(1)) ) ; 
     return ans );
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute re : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute wr : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
     while (T > 0) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var t : long ; t := 0 ;
    var v : int ; v := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     if (x = 1) then     t := t + 1 ; else skip ; 
     if (x = 0) then     v := v + 1 ; else skip )  ;     i := i + 1 ) ; 
    var sum : long ; sum := powl(2, v) ;
    var res : long ; res := sum * t ;
    skip ; 
    T := T - 1 ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF750 {
  static Scanner sc=new Scanner(System.in);
  public static void solve1(){
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    a=a % 2 ;
    b=(b % 2)*2 ;
    c=(c % 2)*3 ;
    int sum=a+b+c ;
    switch(sum){
      case 0 : sum=0 ;
      break ;
      case 1 : sum=1 ;
      break ;
      case 2 : sum=2 ;
      break ;
      case 3 : if(c==0)sum=1 ;
      else sum=3 ;
      break ;
      case 4 : sum=2 ;
      break ;
      case 5 : sum=1 ;
      break ;
      case 6 : sum=0 ;
      break ;
      default : break ;
    }
    System.out.println(sum);
  }
  public static void solve2(){
    int n=sc.nextInt();
    int ones=0,zero=0 ;
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      if(x==1)ones++;
      if(x==0)zero++;
    }
    long ans=ones ;
    while(zero!=0){
      ans*=2 ;
      zero--;
    }
    System.out.println(ans);
  }
  public static void solve3(){
    System.out.println();
  }
  public static void solve4(){
    System.out.println();
  }
  public static void solve5(){
    System.out.println();
  }
  public static void solve6(){
    System.out.println();
  }
  public static void main(String[] args){
    int t=sc.nextInt();
    int testcase=1 ;
    while(testcase<=t){
      solve2();
      testcase++;
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF750 {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation solve1() : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    a := a mod 2 ; 
    b := (b mod 2) * 2 ; 
    c := (c mod 2) * 3 ; 
    var sum : int ; sum := a + b + c ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (sum) ; 
       if _switchval = 0 then
     sum := 0 ; 
    break 
   else skip ;
       if _switchval = 1 then
     sum := 1 ; 
    break 
   else skip ;
       if _switchval = 2 then
     sum := 2 ; 
    break 
   else skip ;
       if _switchval = 3 then
     if (c = 0) then     sum := 1 else     sum := 3 ; ;  
    break 
   else skip ;
       if _switchval = 4 then
     sum := 2 ; 
    break 
   else skip ;
       if _switchval = 5 then
     sum := 1 ; 
    break 
   else skip ;
       if _switchval = 6 then
     sum := 0 ; 
    break 
   else skip ;
       if true then
     break 
   else skip ;
 )
    OclFile["System.out"].println(sum) ; 
 );
  static   operation solve2() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ones : int ; ones := 0 ;
    var zero : int ; zero := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x = 1) then     ones := ones + 1 ; else skip ; 
     if (x = 0) then     zero := zero + 1 ; else skip )  ;     i := i + 1 ) ; 
    var ans : long ; ans := ones ;
    while (zero /= 0) do (     ans := ans*(2) ; 
     zero := zero - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation solve3() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation solve4() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation solve5() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation solve6() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var testcase : int ; testcase := 1 ;
     while (testcase <= t) do (     execute solve2() ; 
     testcase := testcase + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int N=100005 ;
  static Set<Integer>ABUNDANT(){
    Set<Integer>v=new HashSet<>();
    for(int i=1 ; i<N ; i++){
      int sum=1 ;
      for(int j=2 ; j*j<=i ; j++){
        if(i % j==0){
          sum+=j ;
          if(i/j!=j){
            sum+=i/j ;
          }
        }
      }
      if(sum>i){
        v.add(i);
      }
    }
    return v ;
  }
  static void SumOfAbundant(int n){
    Set<Integer>v=ABUNDANT();
    for(int i=1 ; i<=n ; i++){
      if(v.contains(i)& v.contains(n-i)){
        System.out.print(i+" "+(n-i));
        return ;
      }
    }
    System.out.print(-1);
  }
  public static void main(String[] args){
    int n=24 ;
    SumOfAbundant(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute N : int := 100005;
  static   operation ABUNDANT() : Set(int)
  pre: true
  post: true
  activity: (     var v : Set(int) ; v := Set{} ;
         var i : int ; i := 1 ; while i < N do ( (     var sum : int ; sum := 1 ;
         var j : int ; j := 2 ; while j * j <= i do ( (     if (i mod j = 0) then (     sum := sum+(j) ; 
     if (i / j /= j) then (     sum := sum+(i / j) ) else skip ) else skip )  ;     j := j + 1 ) ; 
     if (sum > i) then (     v := v->including(i) ) else skip )  ;     i := i + 1 ) ; 
     return v );
  static   operation SumOfAbundant( n : int) : void
  pre: true
  post: true
  activity: (     var v : Set(int) ; v := ABUNDANT() ;
         var i : int ; i := 1 ; while i <= n do ( (     if (v->includes(i) & v->includes(n - i)) then (     OclFile["System.out"].print(i + " " + (n - i)) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(-1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 24 ;
     execute SumOfAbundant(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int gcd(int a,int b){
    if(a==0 || b==0)return 0 ;
    if(a==b)return a ;
    if(a>b)return gcd(a-b,b);
    return gcd(a,b-a);
  }
  static boolean coprime(int a,int b){
    return(gcd(a,b)==1);
  }
  static int numOfPairs(int arr[],int n){
    int count=0 ;
    for(int i=0 ; i<n-1 ; i++)for(int j=i+1 ; j<n ; j++)if(coprime(arr[i],arr[j]))count++;
    return count ;
  }
  public static void main(String args[])throws IOException {
    int arr[]={
      1,2,5,4,8,3,9 };
      int n=arr.length ;
      System.out.println(numOfPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0 or b = 0) then     return 0 else skip ; 
     if (a = b) then     return a else skip ; 
     if (a > b) then     return gcd(a - b, b) else skip ; 
     return gcd(a, b - a) );
  static   operation coprime( a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     return (gcd(a, b) = 1) );
  static   operation numOfPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n - 1 do (         var j : int ; j := i + 1 ; while j < n do (     if (coprime(arr[i+1], arr[j+1])) then     count := count + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,5,4,8,3,9} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(numOfPairs(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int mod=998244353 ;
  static class Point {
    int x,d ;
    public Point(int x,int d){
      this.x=x ;
      this.d=d ;
    }
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Map<Integer,Integer>map=new TreeMap<Integer,Integer>();
    for(int i=0 ; i<n ; ++i){
      int x=sc.nextInt();
      int d=sc.nextInt();
      map.put(x,d);
    }
    sc.close();
    Point robot[]=new Point[n];
    int i=0 ;
    for(int key : map.keySet())robot[i++]=new Point(key,map.get(key));
    int r[]=new int[n];
    r[n-1]=n-1 ;
    for(i=n-2 ; i>=0 ; --i){
      int rr=i ;
      int x=robot[i] .x+robot[i] .d ;
      while(rr+1<n && x>robot[rr+1] .x){
        rr=r[rr+1];
      }
      r[i]=rr ;
    }
    int dp[]=new int[n+1];
    dp[n]=1 % mod ;
    for(i=n-1 ; i>=0 ; --i){
      int rr=r[i];
      int next=dp[i+1]+dp[rr+1];
      dp[i]=next % mod ;
    }
    int ans=dp[0];
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute mod : int := 998244353;
  static class Point {
   attribute x : int;
   static operation newPoint( x : int, d : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, d);
    return self );
  operation initialise( x : int, d : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.d := d );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
     map := map->union(Map{x |-> d}) )  ;     i := i + 1 ) ; 
    skip ; 
    var robot : Sequence(Point) ; robot := Integer.subrange(1,n)->collect(null) ;
    var i : int ; i := 0 ;
    for (key : map->keys()) do (      robot[i+1] := Point.newPoint(key, map->at(key))  ; i := i + 1 ;  ) ; 
    var r : Sequence(int) ; r := Integer.subrange(1,n)->collect(0) ;
    r[n - 1+1] := n - 1 ; 
        i := n - 2 ; while i >= 0 do ( (     var rr : int ; rr := i ;
     var x : int ; x := robot[i+1].x + robot[i+1].d ;
     while (rr + 1 < n & x > robot[rr + 1+1].x) do (     rr := r[rr + 1+1] ) ; 
     r[i+1] := rr )  ;     i := i - 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
    dp[n+1] := 1 mod mod ; 
        i := n - 1 ; while i >= 0 do ( (     var rr : int ; rr := r[i+1] ;
     var next : int ; next := dp[i + 1+1] + dp[rr + 1+1] ;
     dp[i+1] := next mod mod )  ;     i := i - 1 ) ; 
    var ans : int ; ans := dp[0+1] ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner in=new Scanner(System.in);
  public static void solve(){
    int n=in.nextInt();
    int[] a=new int[n];
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
      sum+=a[i];
    }
    double res=(double)sum/n ;
    if((res-(int)res)!=0){
      System.out.println(1);
    }
    else {
      System.out.println(0);
    }
  }
  public static void main(String[] args){
    int t=in.nextInt();
    while(t-->0){
      solve();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    var res : double ; res := sum->oclAsType(double) / n ;
    if ((res - res->oclAsType(int)) /= 0) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(0) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
import java.util.*;
import java.lang.Math ;
import java.util.StringTokenizer ;
public class five {
  public static void main(String[] args){
    int a[],b,t ;
    String str="" ;
    FastReader in=new FastReader();
    t=in.nextInt();
    while(t-->0){
      int sum=0 ;
      int n=in.nextInt();
      a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
        sum+=a[i];
      }
      if(sum % n==0){
        System.out.println(0);
      }
      else {
        System.out.println(1);
      }
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class five {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(void) ;
    var b : int ;
    var t : int ;
     var str : String ; str := "" ;
    var in : FastReader ; in := FastReader.newFastReader() ;
    t := in.nextInt() ; 
        while (t > 0) do (        t := t - 1 ;     skip ; (     var sum : int ; sum := 0 ;
     var n : int ; n := in.nextInt() ;
    a := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.nextInt() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    if (sum mod n = 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(1) ) ;  
 ) ;  ) ;  
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1615 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      long sum=0 ;
      for(int n=0 ; n<N ; n++){
        sum+=in.nextInt();
      }
      int answer=(sum % N==0)? 0 : 1 ;
      System.out.println(answer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1615 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var sum : long ; sum := 0 ;
        var n : int ; n := 0 ; while n < N do ( (     sum := sum+(in.getCurrent()->toInteger()) )  ;     n := n + 1 ) ; 
    var answer : int ; answer := if (sum mod N = 0) then 0 else 1 endif ;
    OclFile["System.out"].println(answer) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class LC {
  static class pair implements Comparable<pair>{
    int l,r ;
    public pair(int l,int r){
      this.l=l ;
      this.r=r ;
    }
    @ Override public int compareTo(pair o){
      if(o.r==this.r)return o.l-this.l ;
      else return o.r-this.r ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<pair>a=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      a.add(new pair(sc.nextInt(),sc.nextInt()));
    }
    Collections.sort(a);
    int moves=1 ;
    int max=0,sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=a.get(i).l ;
      moves--;
      moves+=a.get(i).r ;
      if(moves==0 || i+1>=n){
        max=Math.max(max,sum);
        moves++;
        sum=0 ;
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class LC {
  static class pair implements Comparable<pair> {
   attribute l : int;
   static operation newpair( l : int, r : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(l, r);
    return self );
  operation initialise( l : int, r : int) : void
  pre: true  post: true
  activity: (     self.l := l ; 
     self.r := r );
      operation compareTo( o : pair) : int
  pre: true
  post: true
  activity: (     if (o.r = self.r) then     return o.l - self.l else     return o.r - self.r );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(pair) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     a := a->including(pair.newpair(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var moves : int ; moves := 1 ;
    var max : int ; max := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(a->at(i+1).l) ; 
     moves := moves - 1 ; 
     moves := moves+(a->at(i+1).r) ; 
     if (moves = 0 or i + 1 >= n) then (     max := Set{max, sum}->max() ; 
     moves := moves + 1 ; 
     sum := 0 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayList<Cartas>carts=new ArrayList<>();
    int cases=sc.nextInt();
    sc.nextLine();
    for(int i=0 ; i<cases ; i++){
      String[] s=sc.nextLine().split(" ");
      carts.add(new Cartas(Integer.parseInt(s[0]),Integer.parseInt(s[1])));
    }
    Collections.sort(carts);
    int contador=1 ;
    int points=0 ;
    while(contador!=0 || carts.isEmpty()){
      if(carts.isEmpty()){
        break ;
      }
      points+=carts.get(0).frente ;
      contador+=carts.get(0).espalda ;
      carts.remove(0);
      contador--;
    }
    System.out.println(points);
  }
  public static class Cartas implements Comparable<Cartas>{
    private int frente ;
    private int espalda ;
    public Cartas(){
    }
    public Cartas(int frente,int espalda){
      this.frente=frente ;
      this.espalda=espalda ;
    }
    public int getFrente(){
      return frente ;
    }
    public void setFrente(int frente){
      this.frente=frente ;
    }
    public int getEspalda(){
      return espalda ;
    }
    public void setEspalda(int espalda){
      this.espalda=espalda ;
    }
    @ Override public String toString(){
      return "Cartas{"+"frente="+frente+",espalda="+espalda+'}' ;
    }
    @ Override public int compareTo(Cartas c){
      int res=(this.espalda-c.espalda)*-1 ;
      if(res==0){
        return(this.frente-c.frente)*-1 ;
      }
      return res ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var carts : Sequence(Cartas) ; carts := Sequence{} ;
    var cases : int ; cases := sc.getCurrent()->toInteger() ;
    skip ; 
        var i : int ; i := 0 ; while i < cases do ( (     var s : Sequence(String) ; s := sc.nextLine()->split(" ") ;
     carts := carts->including(Cartas.newCartas((s[0+1])->toInteger(), (s[1+1])->toInteger())) )  ;     i := i + 1 ) ; 
    carts := carts->sort() ; 
    var contador : int ; contador := 1 ;
    var points : int ; points := 0 ;
    while (contador /= 0 or carts->isEmpty()) do (     if (carts->isEmpty()) then (     break ) else skip ; 
     points := points+(carts->at(0+1).frente) ; 
    contador := contador+(carts->at(0+1).espalda) ; 
    carts := carts->excludingAt(0+1) ; 
    contador := contador - 1 ; 
 ) ; 
    OclFile["System.out"].println(points) ; 
 );
  static class Cartas implements Comparable<Cartas> {
   attribute frente : int;
   attribute espalda : int;
   static operation newCartas() : Cartas
  pre: true
  post: true
  activity:
  ( var self : Cartas ;
    self := createCartas();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   static operation newCartas( frente : int, espalda : int) : Cartas
  pre: true
  post: true
  activity:
  ( var self : Cartas ;
    self := createCartas();
    self.initialise(frente, espalda);
    return self );
  operation initialise( frente : int, espalda : int) : void
  pre: true  post: true
  activity: (     self.frente := frente ; 
     self.espalda := espalda );
   operation getFrente() : int
  pre: true
  post: true
  activity: (     return frente );
   operation setFrente( frente : int) : void
  pre: true
  post: true
  activity: (     self.frente := frente );
   operation getEspalda() : int
  pre: true
  post: true
  activity: (     return espalda );
   operation setEspalda( espalda : int) : void
  pre: true
  post: true
  activity: (     self.espalda := espalda );
      operation toString() : String
  pre: true
  post: true
  activity: (     return "Cartas{" + "frente=" + frente + ",espalda=" + espalda + '}' );
      operation compareTo( c : Cartas) : int
  pre: true
  post: true
  activity: (     var res : int ; res := (self.espalda - c.espalda) * -1 ;
     if (res = 0) then (     return (self.frente - c.frente) * -1 ) else skip ; 
     return res );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.util.StringTokenizer ;
public class LetsWatchFootball {
  static BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter out=new PrintWriter(System.out);
  static StringBuilder sb=new StringBuilder();
  public static void main(String[] args)throws IOException {
    int n=Integer.parseInt(in.readLine());
    StringTokenizer st=new StringTokenizer(in.readLine());
    long[] m={
      4,2,4,1 };
      for(int i=0 ; i<n ; i++){
        int a=Integer.parseInt(st.nextToken());
        int r=a % 4 ;
        long t=m[r]*a+1 ;
        out.println(t);
      }
      out.close();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class LetsWatchFootball {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute sb : String := StringLib.newString();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (in.readLine())->toInteger() ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(in.readLine()) ;
    var m : Sequence(long) ; m := Sequence{4,2,4,1} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := (st.next())->toInteger() ;
     var r : int ; r := a mod 4 ;
     var t : long ; t := m[r+1] * a + 1 ;
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Z_ccc_10_2 {
  static int[][] mat ;
  static int n ;
  public static void main(String args[])throws IOException {
    InputStreamReader r=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(r);
    int t=Integer.parseInt(br.readLine());
    for(int i=0 ; i<t ; i++){
      n=Integer.parseInt(br.readLine());
      mat=new int[2][n];
      for(int j=0 ; j<2 ; j++){
        String str=br.readLine();
        for(int k=0 ; k<n ; k++){
          mat[j][k]=Integer.parseInt(str.substring(k,k+1));
        }
      }
      boolean boo=true ;
      for(int j=0 ; j<n ; j++){
        if(mat[0][j]==1 && mat[1][j]==1){
          boo=false ;
          break ;
        }
      }
      if(boo){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Z_ccc_10{
  static   attribute mat : Sequence(Sequence(int));
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(r) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     n := (br.readLine())->toInteger() ; 
     mat := Integer.subrange(1,2)->collect(Integer.subrange(1,n)->collect(0)) ; 
        var j : int ; j := 0 ; while j < 2 do ( (     var str : String ; str := br.readLine() ;
         var k : int ; k := 0 ; while k < n do ( (     mat[j+1][k+1] := (str.subrange(k+1,k + 1))->toInteger() )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    var boo : boolean ; boo := true ;
        var j : int ; j := 0 ; while j < n do ( (     if (mat[0+1][j+1] = 1 & mat[1+1][j+1] = 1) then (     boo := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (boo) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     i := i + 1 ) );
}
 {
  static   attribute mat : Sequence(Sequence(int));
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(r) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     n := (br.readLine())->toInteger() ; 
     mat := Integer.subrange(1,2)->collect(Integer.subrange(1,n)->collect(0)) ; 
        var j : int ; j := 0 ; while j < 2 do ( (     var str : String ; str := br.readLine() ;
         var k : int ; k := 0 ; while k < n do ( (     mat[j+1][k+1] := (str.subrange(k+1,k + 1))->toInteger() )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    var boo : boolean ; boo := true ;
        var j : int ; j := 0 ; while j < n do ( (     if (mat[0+1][j+1] = 1 & mat[1+1][j+1] = 1) then (     boo := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (boo) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static boolean dfs(int i,int j,int arr[][]){
    if(i<0 || j<0 || i>=arr.length || j>=arr[0] .length || arr[i][j]!=0){
      return false ;
    }
    if(i==arr.length-1 && j==arr[0] .length-1){
      return true ;
    }
    arr[i][j]=-1 ;
    boolean s1=dfs(i+1,j,arr);
    boolean s2=dfs(i,j+1,arr);
    boolean s3=dfs(i-1,j,arr);
    boolean s4=dfs(i,j-1,arr);
    boolean s5=dfs(i+1,j+1,arr);
    boolean s6=dfs(i-1,j-1,arr);
    boolean s7=dfs(i-1,j+1,arr);
    boolean s8=dfs(i+1,j-1,arr);
    return s1 || s2 || s3 || s4 || s5 || s6 || s7 || s8 ;
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int c=sc.nextInt();
      int arr[][]=new int[2][c];
      String s1=sc.next();
      String s2=sc.next();
      for(int i=0 ; i<2 ; i++){
        for(int j=0 ; j<c ; j++){
          if(i==0){
            arr[i][j]=Integer.parseInt(s1.charAt(j)+"");
          }
          else {
            arr[i][j]=Integer.parseInt(s2.charAt(j)+"");
          }
        }
      }
      boolean ans=dfs(0,0,arr);
      if(ans==true){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation dfs( i : int, j : int, arr : Sequence(Sequence(int))) : boolean
  pre: true
  post: true
  activity: (     if (i < 0 or j < 0 or i >= arr->size() or j >= arr[0+1]->size() or arr[i+1][j+1] /= 0) then (     return false ) else skip ; 
     if (i = arr->size() - 1 & j = arr[0+1]->size() - 1) then (     return true ) else skip ; 
    arr[i+1][j+1] := -1 ; 
    var s1 : boolean ; s1 := dfs(i + 1, j, arr) ;
    var s2 : boolean ; s2 := dfs(i, j + 1, arr) ;
    var s3 : boolean ; s3 := dfs(i - 1, j, arr) ;
    var s4 : boolean ; s4 := dfs(i, j - 1, arr) ;
    var s5 : boolean ; s5 := dfs(i + 1, j + 1, arr) ;
    var s6 : boolean ; s6 := dfs(i - 1, j - 1, arr) ;
    var s7 : boolean ; s7 := dfs(i - 1, j + 1, arr) ;
    var s8 : boolean ; s8 := dfs(i + 1, j - 1, arr) ;
    return s1 or s2 or s3 or s4 or s5 or s6 or s7 or s8 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var c : int ; c := sc.getCurrent()->toInteger() ;
     var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,2)->collect(Integer.subrange(1,c)->collect(0)) ;
    var s1 : String ; s1 := sc.getCurrent() ;
    var s2 : String ; s2 := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < 2 do ( (         var j : int ; j := 0 ; while j < c do ( (     if (i = 0) then (     arr[i+1][j+1] := (s1->at(j+1) + "")->toInteger() ) else (     arr[i+1][j+1] := (s2->at(j+1) + "")->toInteger() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : boolean ; ans := dfs(0, 0, arr) ;
    if (ans = true) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ComputerGame {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    int n ;
    String r1,r2 ;
    boolean flag ;
    while(t-->0){
      n=s.nextInt();
      r1=s.next();
      r2=s.next();
      flag=true ;
      for(int i=0 ; i<n ; i++){
        if(r1.charAt(i)=='1' && r2.charAt(i)=='1'){
          flag=false ;
          break ;
        }
      }
      if(flag)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ComputerGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
    var n : int ;
    var r1 : String ;
    var r2 : String ;
    var flag : boolean ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     n := s.getCurrent()->toInteger() ; 
     r1 := s.getCurrent() ; 
    r2 := s.getCurrent() ; 
    flag := true ; 
        var i : int ; i := 0 ; while i < n do ( (     if (r1->at(i+1) = '1' & r2->at(i+1) = '1') then (     flag := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CheckPallindromNumberRecursion {
  public static int oneDigit(int num){
    if((num>=0)&&(num<10))return 1 ;
    else return 0 ;
  }
  public static int isPalUtil(int num,int dupNum)throws Exception {
    if(num==0){
      return dupNum ;
    }
    else {
      dupNum=isPalUtil(num/10,dupNum);
    }
    if(num % 10==dupNum % 10){
      return dupNum/10 ;
    }
    else {
      throw new Exception();
    }
  }
  public static int isPal(int num)throws Exception {
    if(num<0)num=(-num);
    int dupNum=(num);
    return isPalUtil(num,dupNum);
  }
  public static void main(String args[]){
    int n=1242 ;
    try {
      isPal(n);
      System.out.println("Yes");
    }
    catch(Exception e){
      System.out.println("No");
    }
    n=1231 ;
    try {
      isPal(n);
      System.out.println("Yes");
    }
    catch(Exception e){
      System.out.println("No");
    }
    n=12 ;
    try {
      isPal(n);
      System.out.println("Yes");
    }
    catch(Exception e){
      System.out.println("No");
    }
    n=88 ;
    try {
      isPal(n);
      System.out.println("Yes");
    }
    catch(Exception e){
      System.out.println("No");
    }
    n=8999 ;
    try {
      isPal(n);
      System.out.println("Yes");
    }
    catch(Exception e){
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CheckPallindromNumberRecursion {
  static   operation oneDigit( num : int) : int
  pre: true
  post: true
  activity: (     if ((num >= 0) & (num < 10)) then     return 1 else     return 0 );
  static   operation isPalUtil( num : int, dupNum : int) : int
  pre: true
  post: true
  activity: (     if (num = 0) then (     return dupNum ) else (     dupNum := isPalUtil(num / 10, dupNum) ) ;  
     if (num mod 10 = dupNum mod 10) then (     return dupNum / 10 ) else (     error ProgramException() ) );
  static   operation isPal( num : int) : int
  pre: true
  post: true
  activity: (     if (num < 0) then     num := (-num) ; else skip ; 
     var dupNum : int ; dupNum := (num) ;
     return isPalUtil(num, dupNum) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1242 ;
     try (     execute isPal(n) ; 
     OclFile["System.out"].println("Yes") )   catch (e : ProgramException) do (     OclFile["System.out"].println("No") )
    n := 1231 ; 
    try (     execute isPal(n) ; 
     OclFile["System.out"].println("Yes") )   catch (e : ProgramException) do (     OclFile["System.out"].println("No") )
    n := 12 ; 
    try (     execute isPal(n) ; 
     OclFile["System.out"].println("Yes") )   catch (e : ProgramException) do (     OclFile["System.out"].println("No") )
    n := 88 ; 
    try (     execute isPal(n) ; 
     OclFile["System.out"].println("Yes") )   catch (e : ProgramException) do (     OclFile["System.out"].println("No") )
    n := 8999 ; 
    try (     execute isPal(n) ; 
     OclFile["System.out"].println("Yes") )   catch (e : ProgramException) do (     OclFile["System.out"].println("No") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int c1x=sc.nextInt();
    int c1y=sc.nextInt();
    int c1r=sc.nextInt();
    int c2x=sc.nextInt();
    int c2y=sc.nextInt();
    int c2r=sc.nextInt();
    int dx=c1x-c2x ;
    int dy=c1y-c2y ;
    int sum=c1r+c2r ;
    int diff=c1r-c2r ;
    int sumR=sum*sum ;
    int diffR=diff*diff ;
    int distance=dx*dx+dy*dy ;
    if(distance==diffR){
      System.out.println(1);
    }
    else if(distance<diffR){
      System.out.println(0);
    }
    else if(distance==sumR){
      System.out.println(3);
    }
    else if(distance<sumR){
      System.out.println(2);
    }
    else {
      System.out.println(4);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c1x : int ; c1x := sc.getCurrent()->toInteger() ;
    var c1y : int ; c1y := sc.getCurrent()->toInteger() ;
    var c1r : int ; c1r := sc.getCurrent()->toInteger() ;
    var c2x : int ; c2x := sc.getCurrent()->toInteger() ;
    var c2y : int ; c2y := sc.getCurrent()->toInteger() ;
    var c2r : int ; c2r := sc.getCurrent()->toInteger() ;
    var dx : int ; dx := c1x - c2x ;
    var dy : int ; dy := c1y - c2y ;
    var sum : int ; sum := c1r + c2r ;
    var diff : int ; diff := c1r - c2r ;
    var sumR : int ; sumR := sum * sum ;
    var diffR : int ; diffR := diff * diff ;
    var distance : int ; distance := dx * dx + dy * dy ;
    if (distance = diffR) then (     OclFile["System.out"].println(1) ) else     if (distance < diffR) then (     OclFile["System.out"].println(0) ) else     if (distance = sumR) then (     OclFile["System.out"].println(3) ) else     if (distance < sumR) then (     OclFile["System.out"].println(2) ) else (     OclFile["System.out"].println(4) ) ;  ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  boolean[][][] statuesSet ;
  boolean dfs(int i,int j,int depth){
    if(depth>=8 ||(i==0 && j==7)){
      return true ;
    }
    if(statuesSet[depth][i][j]){
      return false ;
    }
    for(int di=-1 ; di<=1 ; ++di){
      for(int dj=1 ; dj>=-1 ; --dj){
        int i2=i+di,j2=j+dj ;
        if(i2<0 || i2>=8 || j2<0 || j2>=8 || statuesSet[depth][i+di][j+dj])continue ;
        if(dfs(i2,j2,depth+1)){
          return true ;
        }
      }
    }
    return false ;
  }
  boolean canWin(char[][] board){
    statuesSet=new boolean[8][8][8];
    for(int i=0 ; i<8 ; ++i){
      for(int j=0 ; j<8 ; ++j){
        statuesSet[0][i][j]=board[i][j]=='S' ;
      }
    }
    for(int k=1 ; k<8 ; ++k){
      System.arraycopy(statuesSet[k-1],0,statuesSet[k],1,7);
    }
    return dfs(7,0,0);
  }
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    char[][] board=new char[8][8];
    for(int i=0 ; i<8 ; ++i){
      String line=reader.readLine();
      for(int j=0 ; j<8 ; ++j){
        board[i][j]=line.charAt(j);
      }
    }
    boolean out=new Main().canWin(board);
    System.out.println(out ? "WIN" : "LOSE");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute statuesSet : Sequence(Sequence(Sequence(boolean)));
   operation dfs( i : int, j : int, depth : int) : boolean
  pre: true
  post: true
  activity: (     if (depth >= 8 or (i = 0 & j = 7)) then (     return true ) else skip ; 
     if (statuesSet[depth+1][i+1][j+1]) then (     return false ) else skip ; 
         var di : int ; di := -1 ; while di <= 1 do ( (         var dj : int ; dj := 1 ; while dj >= -1 do ( (     var i2 : int ; i2 := i + di ;
    var j2 : int ; j2 := j + dj ;
     if (i2 < 0 or i2 >= 8 or j2 < 0 or j2 >= 8 or statuesSet[depth+1][i + di+1][j + dj+1]) then     continue else skip ; 
     if (dfs(i2, j2, depth + 1)) then (     return true ) else skip )  ;     dj := dj - 1 ) )  ;     di := di + 1 ) ; 
     return false );
   operation canWin( board : Sequence(Sequence(String))) : boolean
  pre: true
  post: true
  activity: (     statuesSet := Integer.subrange(1,8)->collect(Integer.subrange(1,8)->collect(Integer.subrange(1,8)->collect(false))) ; 
         var i : int ; i := 0 ; while i < 8 do ( (         var j : int ; j := 0 ; while j < 8 do ( (     statuesSet[0+1][i+1][j+1] := board[i+1][j+1] = 'S' )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
         var k : int ; k := 1 ; while k < 8 do ( (     for _x : Integer.subrange(1,7) do statuesSet[k+1][1 + _x] := statuesSet[k - 1+1][0 + _x] )  ;     k := k + 1 ) ; 
     return dfs(7, 0, 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var board : Sequence(Sequence(String)) ; board := Integer.subrange(1,8)->collect(Integer.subrange(1,8)->collect(0)) ;
        var i : int ; i := 0 ; while i < 8 do ( (     var line : String ; line := reader.readLine() ;
         var j : int ; j := 0 ; while j < 8 do ( (     board[i+1][j+1] := line->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var out : boolean ; out := Main.newMain().canWin(board) ;
    OclFile["System.out"].println(if out then "WIN" else "LOSE" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class problemA {
  void solve(){
    int c1x=0,c1y=0,c1r=0 ;
    int c2x=0,c2y=0,c2r=0 ;
    int length=0 ;
    int large=0,small=0 ;
    Scanner scan=new Scanner(System.in);
    c1x=scan.nextInt();
    c1y=scan.nextInt();
    c1r=scan.nextInt();
    c2x=scan.nextInt();
    c2y=scan.nextInt();
    c2r=scan.nextInt();
    large=c1r ;
    small=c2r ;
    if(large<small){
      large=c2r ;
      small=c1r ;
    }
    length=(int)(Math.sqrt((c2x-c1x)*(c2x-c1x)+(c2y-c1y)*(c2y-c1y)));
    if(length>(c1r+c2r))System.out.println("4");
    else if(length<(c1r+c2r)){
      if(large==(length+small))System.out.println("1");
      else if(large>(length+small))System.out.println("0");
      else System.out.println("2");
    }
    else System.out.println("3");
  }
}
public class Main {
  public static void main(String[] args){
    new problemA().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class problemA {
   operation solve() : void
  pre: true
  post: true
  activity: (     var c1x : int ; c1x := 0 ;
    var c1y : int ; c1y := 0 ;
    var c1r : int ; c1r := 0 ;
     var c2x : int ; c2x := 0 ;
    var c2y : int ; c2y := 0 ;
    var c2r : int ; c2r := 0 ;
    var length : int ; length := 0 ;
    var large : int ; large := 0 ;
    var small : int ; small := 0 ;
    var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    c1x := scan.getCurrent()->toInteger() ; 
    c1y := scan.getCurrent()->toInteger() ; 
    c1r := scan.getCurrent()->toInteger() ; 
    c2x := scan.getCurrent()->toInteger() ; 
    c2y := scan.getCurrent()->toInteger() ; 
    c2r := scan.getCurrent()->toInteger() ; 
    large := c1r ; 
    small := c2r ; 
    if (large < small) then (     large := c2r ; 
     small := c1r ) else skip ; 
    length := (((c2x - c1x) * (c2x - c1x) + (c2y - c1y) * (c2y - c1y))->sqrt())->oclAsType(int) ; 
    if (length > (c1r + c2r)) then     OclFile["System.out"].println("4") else     if (length < (c1r + c2r)) then (     if (large = (length + small)) then     OclFile["System.out"].println("1") ; else     if (large > (length + small)) then     OclFile["System.out"].println("0") else     OclFile["System.out"].println("2") ; ;  ) else     OclFile["System.out"].println("3") ; ;  ;  
 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     problemA.newproblemA().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner input=new Scanner(System.in);
  static public void solve(){
    int c1x=input.nextInt();
    int c1y=input.nextInt();
    int c1r=input.nextInt();
    int c2x=input.nextInt();
    int c2y=input.nextInt();
    int c2r=input.nextInt();
    input.close();
    double x=(double)c1x-c2x ;
    double y=(double)c1y-c2y ;
    double l12=Math.sqrt(x*x+y*y);
    double plus=(double)c1r+c2r ;
    double minus=(double)c1r-c2r ;
    if(minus<0)minus=-minus ;
    if(l12>plus){
      System.out.println("4");
    }
    if(l12==plus){
      System.out.println("3");
    }
    if(l12<plus && l12>minus){
      System.out.println("2");
    }
    if(l12==minus){
      System.out.println("1");
    }
    if(l12<minus){
      System.out.println("0");
    }
  }
  public static void main(String[] args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute input : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    operation solve() : void
  pre: true
  post: true
  activity: (     var c1x : int ; c1x := input.getCurrent()->toInteger() ;
     var c1y : int ; c1y := input.getCurrent()->toInteger() ;
    var c1r : int ; c1r := input.getCurrent()->toInteger() ;
    var c2x : int ; c2x := input.getCurrent()->toInteger() ;
    var c2y : int ; c2y := input.getCurrent()->toInteger() ;
    var c2r : int ; c2r := input.getCurrent()->toInteger() ;
    skip ; 
    var x : double ; x := c1x->oclAsType(double) - c2x ;
    var y : double ; y := c1y->oclAsType(double) - c2y ;
    var l12 : double ; l12 := (x * x + y * y)->sqrt() ;
    var plus : double ; plus := c1r->oclAsType(double) + c2r ;
    var minus : double ; minus := c1r->oclAsType(double) - c2r ;
    if (minus < 0) then     minus := -minus ; else skip ; 
    if (l12 > plus) then (     OclFile["System.out"].println("4") ) else skip ; 
    if (l12 = plus) then (     OclFile["System.out"].println("3") ) else skip ; 
    if (l12 < plus & l12 > minus) then (     OclFile["System.out"].println("2") ) else skip ; 
    if (l12 = minus) then (     OclFile["System.out"].println("1") ) else skip ; 
    if (l12 < minus) then (     OclFile["System.out"].println("0") ) else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStreamReader ;
import java.util.Scanner ;
import static java.lang.Math.*;
public class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    Double x1=Double.parseDouble(scan.next());
    Double y1=Double.parseDouble(scan.next());
    Double r1=Double.parseDouble(scan.next());
    Double x2=Double.parseDouble(scan.next());
    Double y2=Double.parseDouble(scan.next());
    Double r2=Double.parseDouble(scan.next());
    if(r1+r2>sqrt(pow(x2-x1,2)+pow(y2-y1,2))&& max(r1,r2)-min(r1,r2)>sqrt(pow(x2-x1,2)+pow(y2-y1,2))){
      System.out.println(0);
    }
    else if(r1+r2>sqrt(pow(x2-x1,2)+pow(y2-y1,2))&& max(r1,r2)-min(r1,r2)==sqrt(pow(x2-x1,2)+pow(y2-y1,2))){
      System.out.println(1);
    }
    else if(r1+r2>sqrt(pow(x2-x1,2)+pow(y2-y1,2))){
      System.out.println(2);
    }
    else if(r1+r2==sqrt(pow(x2-x1,2)+pow(y2-y1,2))){
      System.out.println(3);
    }
    else if(r1+r2<sqrt(pow(x2-x1,2)+pow(y2-y1,2))){
      System.out.println(4);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : double ; x1 := (scan.getCurrent())->toReal() ;
    var y1 : double ; y1 := (scan.getCurrent())->toReal() ;
    var r1 : double ; r1 := (scan.getCurrent())->toReal() ;
    var x2 : double ; x2 := (scan.getCurrent())->toReal() ;
    var y2 : double ; y2 := (scan.getCurrent())->toReal() ;
    var r2 : double ; r2 := (scan.getCurrent())->toReal() ;
    if (r1 + r2 > sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2)) & max(r1, r2) - min(r1, r2) > sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2))) then (     OclFile["System.out"].println(0) ) else     if (r1 + r2 > sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2)) & max(r1, r2) - min(r1, r2) = sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2))) then (     OclFile["System.out"].println(1) ) else     if (r1 + r2 > sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2))) then (     OclFile["System.out"].println(2) ) else     if (r1 + r2 = sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2))) then (     OclFile["System.out"].println(3) ) else     if (r1 + r2 < sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2))) then (     OclFile["System.out"].println(4) ) else skip ; ;  ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static int intersection(Circle c1,Circle c2){
    double dis1=Math.pow(c2.x-c1.x,2)+Math.pow(c2.y-c1.y,2);
    double dis2=Math.pow(c1.r+c2.r,2);
    double dis3=Math.pow(c1.r-c2.r,2);
    if(dis1>dis2)return 4 ;
    else if(dis1==dis2)return 3 ;
    else if(dis1>dis3)return 2 ;
    else if(dis1==dis3)return 1 ;
    else return 0 ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Circle c1=new Circle(sc.nextLong(),sc.nextLong(),sc.nextLong());
    Circle c2=new Circle(sc.nextLong(),sc.nextLong(),sc.nextLong());
    System.out.println(intersection(c1,c2));
  }
}
class Circle {
  long x ;
  long y ;
  long r ;
  Circle(long x,long y,long r){
    this.x=x ;
    this.y=y ;
    this.r=r ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation intersection( c1 : Circle, c2 : Circle) : int
  pre: true
  post: true
  activity: (     var dis1 : double ; dis1 := c2.x - c1.x->pow(2) + c2.y - c1.y->pow(2) ;
     var dis2 : double ; dis2 := c1.r + c2.r->pow(2) ;
     var dis3 : double ; dis3 := c1.r - c2.r->pow(2) ;
     if (dis1 > dis2) then     return 4 else     if (dis1 = dis2) then     return 3 else     if (dis1 > dis3) then     return 2 else     if (dis1 = dis3) then     return 1 else     return 0 ;  ;  ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c1 : Circle ; c1 := Circle.newCircle(sc.getCurrent()->toLong(), sc.getCurrent()->toLong(), sc.getCurrent()->toLong()) ;
     var c2 : Circle ; c2 := Circle.newCircle(sc.getCurrent()->toLong(), sc.getCurrent()->toLong(), sc.getCurrent()->toLong()) ;
     OclFile["System.out"].println(intersection(c1, c2)) );
}
class Circle {
   attribute x : long;
   attribute y : long;
   attribute r : long;
   static operation newCircle( x : long, y : long, r : long) : Circle
  pre: true
  post: true
  activity:
  ( var self : Circle ;
    self := createCircle();
    self.initialise(x, y,r);
    return self );
  operation initialise( x : long, y : long, r : long) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y ; 
     self.r := r );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  public static void main(String[] args){
    for(int i=IO.scanner.nextInt(); i>0 ; i--){
      new SolB().solve();
    }
    IO.writer.close();
  }
}
class SolB {
  long n=IO.scanner.nextInt();
  public void solve(){
    long g=Math.gcd(4*n,n+1);
    long ans=4*n/g+1 ;
    IO.writer.println(ans);
  }
}
class Math {
  public static long gcd(long a,long b){
    if(b==0){
      return a ;
    }
    return gcd(b,a % b);
  }
}
class IO {
  public static final Scanner scanner=new Scanner(System.in);
  public static final PrintWriter writer=new PrintWriter(System.out);
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := IO.scanner.nextInt() ; while i > 0 do ( (     SolB.newSolB().solve() )  ;     i := i - 1 ) ; 
     IO.writer.close() );
}
class SolB {
   attribute n : long := IO.scanner.nextInt();
   operation solve() : void
  pre: true
  post: true
  activity: (     var g : long ; g := gcd(4 * n, n + 1) ;
     var ans : long ; ans := 4 * n / g + 1 ;
     IO.writer.println(ans) );
}
class Math {
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else skip ; 
     return gcd(b, a mod b) );
}
class IO {
  static    attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute writer : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countDivisibles(int A,int B,int M){
    if(A % M==0)return(B/M)-(A/M)+1 ;
    return(B/M)-(A/M);
  }
  public static void main(String[] args){
    int A=30,B=100,M=30 ;
    System.out.println(countDivisibles(A,B,M));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDivisibles( A : int, B : int, M : int) : int
  pre: true
  post: true
  activity: (     if (A mod M = 0) then     return (B / M) - (A / M) + 1 else skip ; 
     return (B / M) - (A / M) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 30 ;
    var B : int ; B := 100 ;
    var M : int ; M := 30 ;
     OclFile["System.out"].println(countDivisibles(A, B, M)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findSum(int arr[],int N){
    Map<Integer,Integer>mp=new HashMap<>();
    for(int i=0 ; i<N ; i++){
      if(mp.containsKey(arr[i])){
        mp.put(arr[i],mp.get(arr[i])+1);
      }
      else {
        mp.put(arr[i],1);
      }
    }
    int maxFreq=0 ;
    for(Map.Entry<Integer,Integer>entry : mp.entrySet()){
      if(entry.getValue()>maxFreq){
        maxFreq=entry.getValue();
      }
    }
    int sum=0 ;
    for(Map.Entry<Integer,Integer>entry : mp.entrySet()){
      if(entry.getValue()==maxFreq){
        sum+=entry.getKey()*entry.getValue();
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      1,1,2,2,2,2,3,3,3,3 };
      int N=arr.length ;
      System.out.println(findSum(arr,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSum( arr : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < N do ( (     if (mp->keys()->includes(arr[i+1])) then (     mp := mp->union(Map{arr[i+1] |-> mp->at(arr[i+1]) + 1}) ) else (     mp := mp->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var maxFreq : int ; maxFreq := 0 ;
    for (entry : mp->asSet()) do ( (     if (entry.getValue() > maxFreq) then (     maxFreq := entry.getValue() ) else skip )  ) ; 
    var sum : int ; sum := 0 ;
    for (entry : mp->asSet()) do ( (     if (entry.getValue() = maxFreq) then (     sum := sum+(entry.getKey() * entry.getValue()) ) else skip )  ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,2,2,2,2,3,3,3,3} ;
     var N : int ; N := arr->size() ;
     OclFile["System.out"].println(findSum(arr, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findSum(int arr[],int N){
    Map<Integer,Integer>mp=new HashMap<>();
    for(int i=0 ; i<N ; i++)mp.put(arr[i],mp.get(arr[i])==null ? 1 : mp.get(arr[i])+1);
    int sum=0 ;
    for(Map.Entry<Integer,Integer>entry : mp.entrySet()){
      if(entry.getValue()% 2!=0)sum+=(entry.getKey())*(entry.getValue());
    }
    return sum ;
  }
  public static void main(String args[]){
    int arr[]={
      10,20,20,10,40,40,10 };
      int N=arr.length ;
      System.out.println(findSum(arr,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSum( arr : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < N do (     mp := mp->union(Map{arr[i+1] |-> if mp->at(arr[i+1]) = null then 1 else mp->at(arr[i+1]) + 1 endif}) ;  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    for (entry : mp->asSet()) do ( (     if (entry.getValue() mod 2 /= 0) then     sum := sum+((entry.getKey()) * (entry.getValue())) ; else skip )  ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,20,20,10,40,40,10} ;
     var N : int ; N := arr->size() ;
     OclFile["System.out"].println(findSum(arr, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class B443B {
  static BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  static String s ;
  static boolean equ(char x,char y){
    if(y=='*' || x=='*')return true ;
    return x==y ;
  }
  static boolean istendam(String t){
    if((t.length()& 1)==1)return false ;
    int n=t.length()/2 ;
    for(int i=0 ; (i+n)<t.length(); i++)if(! equ(t.charAt(i),t.charAt(i+n)))return false ;
    return true ;
  }
  public static void main(String[] args)throws IOException {
    s=in.readLine();
    int k=Integer.parseInt(in.readLine());
    int step=k ;
    StringBuilder t=new StringBuilder(s);
    while(step--!=0)t.append('*');
    s=t.toString();
    t.delete(0,t.length());
    int ans=0 ;
    for(int i=0 ; i<s.length(); i++){
      for(int j=i ; j<s.length(); j++){
        t.append(s.charAt(j));
        if(istendam(t.toString()))ans=Math.max(ans,t.length());
      }
      t.delete(0,t.length());
    }
    System.out.println(Math.min(ans,(s.length()/2)*2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B443B {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute s : String;
  static   operation equ( x : String, y : String) : boolean
  pre: true
  post: true
  activity: (     if (y = '*' or x = '*') then     return true else skip ; 
     return x = y );
  static   operation istendam( t : String) : boolean
  pre: true
  post: true
  activity: (     if ((MathLib.bitwiseAnd(t->size(),1)) = 1) then     return false else skip ; 
     var n : int ; n := t->size() / 2 ;
         var i : int ; i := 0 ; while (i + n) < t->size() do (     if (not(equ(t->at(i+1), t->at(i + n+1)))) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     s := in.readLine() ; 
     var k : int ; k := (in.readLine())->toInteger() ;
    var step : int ; step := k ;
    var t : String ; t := StringLib.newString(s) ;
        while (step /= 0) do (    skip ;     t := t + StringLib.newString('*') ; ;  ) ;  
    s := t+"" ; 
    t := t->antirestrict( Integer.subrange(0+1,t->size()) ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (         var j : int ; j := i ; while j < s->size() do ( (     t := t + StringLib.newString(s->at(j+1)) ; 
     if (istendam(t+"")) then     ans := Set{ans, t->size()}->max() ; else skip )  ;     j := j + 1 ) ; 
     t := t->antirestrict( Integer.subrange(0+1,t->size()) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{ans, (s->size() / 2) * 2}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B443 {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    String st=in.next();
    String extra,test ;
    int k=in.nextInt();
    int res=0 ;
    if(st.length()<=k){
      System.out.println(((st.length()+k)-(st.length()+k)% 2));
      System.exit(0);
    }
    for(int j=(st.length()+k)-(st.length()+k)% 2 ; j>0 ; j-=2){
      for(int i=0 ; i<st.length()-k+1 ; i++){
        extra=st.substring(i,i+k);
        test=st.concat(extra);
        if(st.length()>=j){
          for(int c=0 ; c<st.length()-j+1 ; c++){
            if(isTandem(st.substring(c,c+j))){
              System.out.println(j);
              System.exit(0);
            }
          }
        }
        if(isTandem(test.substring(test.length()-j,test.length()))){
          System.out.println(j);
          System.exit(0);
        }
      }
    }
    System.out.println(res);
  }
  static boolean isTandem(String s){
    int i=0 ;
    while(i<s.length()/2 && s.charAt(i)==s.charAt(i+s.length()/2)){
      i++;
    }
    if(i==s.length()/2)return true ;
    else return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B443 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var st : String ; st := in.getCurrent() ;
    var extra : String ;
    var test : String ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
    if (st->size() <= k) then (     OclFile["System.out"].println(((st->size() + k) - (st->size() + k) mod 2)) ; 
 OclProcess.exit(0) ) else skip ; 
        var j : int ; j := (st->size() + k) - (st->size() + k) mod 2 ; while j > 0 do ( (         var i : int ; i := 0 ; while i < st->size() - (k)->char2byte() + 1 do ( (     extra := st.subrange(i+1,i + k) ; 
     test := st+extra ; 
     if (st->size() >= j) then (         var c : int ; c := 0 ; while c < st->size() - j + 1 do ( (     if (isTandem(st.subrange(c+1,c + j))) then (     OclFile["System.out"].println(j) ; 
 OclProcess.exit(0) ) else skip )  ;     c := c + 1 ) ) else skip ; 
     if (isTandem(test.subrange(test->size() - j+1,test->size()))) then (     OclFile["System.out"].println(j) ; 
 OclProcess.exit(0) ) else skip )  ;     i := i + 1 ) )  ;     j := j-(2) ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static   operation isTandem( s : String) : boolean
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     while (i < s->size() / 2 & s->at(i+1) = s->at(i + s->size() / 2+1)) do (     i := i + 1 ) ; 
     if (i = s->size() / 2) then     return true else     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static String str ;
  static int k ;
  static int len ;
  public static boolean judge(int mid){
    int i,j ;
    for(i=0 ; i<len ; i++){
      for(j=i ; j<len ; j++)if((j+mid<len)&&(str.charAt(j+mid)==' ' || str.charAt(j)==str.charAt(j+mid)))continue ;
      else break ;
      if(j==i+mid){
        System.out.println("ans="+mid+" Okay");
        return true ;
      }
    }
    return false ;
  }
  public static int bsearch(int low,int high){
    int ans=k ;
    while(low<=high){
      int mid=(low+high)/2 ;
      System.out.println("====mid="+mid);
      if(judge(mid)){
        low=mid+1 ;
        ans=mid ;
      }
      else high=mid-1 ;
    }
    return ans*2 ;
  }
  public static int deal(){
    int i,j,ans ;
    for(ans=len/2+1 ; ans>=0 ; ans--)for(i=0 ; i<len ; i++){
      for(j=i ; j<len ; j++){
        if((j+ans<len)&&(str.charAt(j+ans)==' ' || str.charAt(j)==str.charAt(j+ans)))continue ;
        else break ;
      }
      if(j==i+ans){
        return ans ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      str=in.next();
      k=in.nextInt();
      len=str.length()+k ;
      if(k>=str.length())System.out.println(len/2*2);
      else {
        for(int i=0 ; i<k ; i++)str+=" " ;
        System.out.println(deal()*2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute str : String;
  static   attribute k : int;
  static   attribute len : int;
  static   operation judge( mid : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := 0 ; while i < len do ( (         j := i ; while j < len do (     if ((j + mid < len) & (str->at(j + mid+1) = ' ' or str->at(j+1) = str->at(j + mid+1))) then     continue else     break ;   ;     j := j + 1 ) ; 
     if (j = i + mid) then (     OclFile["System.out"].println("ans=" + mid + " Okay") ; 
     return true ) else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation bsearch( low : int, high : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := k ;
     while (low <= high) do (     var mid : int ; mid := (low + high) / 2 ;
     OclFile["System.out"].println("====mid=" + mid) ; 
     if (judge(mid)) then (     low := mid + 1 ; 
     ans := mid ) else     high := mid - 1 ; ) ; 
     return ans * 2 );
  static   operation deal() : int
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var ans : int ;
         ans := len / 2 + 1 ; while ans >= 0 do (         i := 0 ; while i < len do ( (         j := i ; while j < len do ( (     if ((j + ans < len) & (str->at(j + ans+1) = ' ' or str->at(j+1) = str->at(j + ans+1))) then     continue else     break )  ;     j := j + 1 ) ; 
     if (j = i + ans) then (     return ans ) else skip )  ;     i := i + 1 ) ;  ;     ans := ans - 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     str := in.getCurrent() ; 
     k := in.getCurrent()->toInteger() ; 
     len := str->size() + k ; 
     if (k >= str->size()) then     OclFile["System.out"].println(len / 2 * 2) ; else (         var i : int ; i := 0 ; while i < k do (     str := str+(" ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(deal() * 2) ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A128 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char[][] A=new char[8][];
    for(int r=0 ; r<8 ; r++){
      A[r]=in.next().toCharArray();
    }
    boolean[][][] seen=new boolean[8][8][8];
    visit(A,seen,7,0,0);
    boolean win=false ;
    for(int r=0 ; r<8 ; r++){
      for(int c=0 ; c<8 ; c++){
        if(seen[r][c][7]){
          win=true ;
        }
      }
    }
    System.out.println(win ? "WIN" : "LOSE");
  }
  static void visit(char[][] A,boolean[][][] seen,int row,int column,int time){
    int sr=row-time ;
    if(sr>=0 && A[sr][column]=='S')return ;
    if(sr>=-1 && sr<7 && A[sr+1][column]=='S')return ;
    if(seen[row][column][time])return ;
    seen[row][column][time]=true ;
    if(time==7)return ;
    for(int dr=-1 ; dr<=1 ; dr++){
      for(int dc=-1 ; dc<=1 ; dc++){
        int r=row+dr ;
        int c=column+dc ;
        if(0<=r && r<8 && 0<=c && c<8){
          visit(A,seen,r,c,time+1);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A128 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : Sequence(Sequence(String)) ; A := Integer.subrange(1,8)->collect(Sequence{}) ;
        var r : int ; r := 0 ; while r < 8 do ( (     A[r+1] := in.getCurrent()->characters() )  ;     r := r + 1 ) ; 
    var seen : Sequence(Sequence(Sequence(boolean))) ; seen := Integer.subrange(1,8)->collect(Integer.subrange(1,8)->collect(Integer.subrange(1,8)->collect(false))) ;
    execute visit(A, seen, 7, 0, 0) ; 
    var win : boolean ; win := false ;
        var r : int ; r := 0 ; while r < 8 do ( (         var c : int ; c := 0 ; while c < 8 do ( (     if (seen[r+1][c+1][7+1]) then (     win := true ) else skip )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    OclFile["System.out"].println(if win then "WIN" else "LOSE" endif) ; 
 );
  static   operation visit( A : Sequence(Sequence(String)), seen : Sequence(Sequence(Sequence(boolean))), row : int, column : int, time : int) : void
  pre: true
  post: true
  activity: (     var sr : int ; sr := row - time ;
     if (sr >= 0 & A[sr+1][column+1] = 'S') then     return else skip ; 
    if (sr >= -1 & sr < 7 & A[sr + 1+1][column+1] = 'S') then     return else skip ; 
    if (seen[row+1][column+1][time+1]) then     return else skip ; 
    seen[row+1][column+1][time+1] := true ; 
    if (time = 7) then     return else skip ; 
        var dr : int ; dr := -1 ; while dr <= 1 do ( (         var dc : int ; dc := -1 ; while dc <= 1 do ( (     var r : int ; r := row + dr ;
     var c : int ; c := column + dc ;
     if (0 <= r & r < 8 & 0 <= c & c < 8) then (     execute visit(A, seen, r, c, time + 1) ) else skip )  ;     dc := dc + 1 ) )  ;     dr := dr + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      String s=sc.next();
      boolean pall=true ;
      for(int i=0 ; i<s.length()/2 ; i++){
        int v=Math.abs(s.charAt(i)-s.charAt(n-1-i));
        if(v==0 || v==2)continue ;
        else {
          pall=false ;
          break ;
        }
      }
      if(pall){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
    var pall : boolean ; pall := true ;
        var i : int ; i := 0 ; while i < s->size() / 2 do ( (     var v : int ; v := if s->at(i+1) - s->at(n - 1 - i+1) < 0 then -(s->at(i+1) - s->at(n - 1 - i+1)) else s->at(i+1) - s->at(n - 1 - i+1) endif ;
     if (v = 0 or v = 2) then     continue else (     pall := false ; 
     break ) )  ;     i := i + 1 ) ; 
    if (pall) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class PalindromeTwist {
  public static void main(String[] args){
    Scanner inp=new Scanner(System.in);
    int t=Integer.parseInt(inp.nextLine());
    while(t-->0){
      int n=Integer.parseInt(inp.nextLine());
      String s=inp.nextLine();
      int i=0 ;
      int j=n-1 ;
      boolean ans=true ;
      while(i<j){
        int k=Math.abs(s.charAt(i)-s.charAt(j));
        if(k!=2 && k!=0){
          ans=false ;
          break ;
        }
        i++;
        j--;
      }
      if(ans)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PalindromeTwist {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inp : OclFile ; inp := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := (inp.nextLine())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := (inp.nextLine())->toInteger() ;
     var s : String ; s := inp.nextLine() ;
    var i : int ; i := 0 ;
    var j : int ; j := n - 1 ;
    var ans : boolean ; ans := true ;
    while (i < j) do (     var k : int ; k := if s->at(i+1) - s->at(j+1) < 0 then -(s->at(i+1) - s->at(j+1)) else s->at(i+1) - s->at(j+1) endif ;
     if (k /= 2 & k /= 0) then (     ans := false ; 
     break ) else skip ; 
     i := i + 1 ; 
     j := j - 1 ) ; 
    if (ans) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public final class cp {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    void close()throws IOException {
      br.close();
    }
  }
  public static void main(String[] args)throws IOException {
    FastReader r=new FastReader();
    PrintWriter w=new PrintWriter(System.out,true);
    int tc=r.nextInt();
    while(tc--!=0){
      int len=r.nextInt();
      String str=r.next();
      int i=0,j=len-1 ;
      boolean flag=true ;
      while(i<j){
        int dist=Math.abs(str.charAt(i)-str.charAt(j));
        if(dist!=0 && dist!=2){
          flag=false ;
          break ;
        }
        i++;
        j--;
      }
      w.println((flag)? "YES" : "NO");
    }
    r.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : FastReader ; r := FastReader.newFastReader() ;
     var w : OclFile ; w := OclFile.newOclFile_Write(OclFile["System.out"], true) ;
    var tc : int ; tc := r.nextInt() ;
        while (tc /= 0) do (    skip ; (     var len : int ; len := r.nextInt() ;
     var str : String ; str := r.next() ;
    var i : int ; i := 0 ;
    var j : int ; j := len - 1 ;
    var flag : boolean ; flag := true ;
    while (i < j) do (     var dist : int ; dist := if str->at(i+1) - str->at(j+1) < 0 then -(str->at(i+1) - str->at(j+1)) else str->at(i+1) - str->at(j+1) endif ;
     if (dist /= 0 & dist /= 2) then (     flag := false ; 
     break ) else skip ; 
     i := i + 1 ; 
     j := j - 1 ) ; 
    skip ; 
 ) ;  ) ;  
    r.close() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double PI=3.14 ;
  static double find_area(int r,int d){
    double R=d/PI ;
    R+=Math.pow(r,2);
    R=Math.sqrt(R);
    double area=PI*Math.pow(R,2);
    return area ;
  }
  public static void main(String[] args){
    int r=4,d=5 ;
    System.out.println(find_area(r,d));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute PI : double := 3.14;
  static   operation find_area( r : int, d : int) : double
  pre: true
  post: true
  activity: (     var R : double ; R := d / PI ;
     R := R+(r->pow(2)) ; 
    R := (R)->sqrt() ; 
    var area : double ; area := PI * R->pow(2) ;
    return area 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : int ; r := 4 ;
    var d : int ; d := 5 ;
     OclFile["System.out"].println(find_area(r, d)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class second {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String p="abcdefghijklmnopqrstuvwxyz" ;
    for(int k=0 ; k<n ; k++){
      int even=sc.nextInt();
      String s=sc.next();
      int i=0 ;
      int j=s.length()-1 ;
      boolean flag=false ;
      while(i<j){
        int index1=p.indexOf(s.charAt(i));
        int index2=p.indexOf(s.charAt(j));
        int diff=Math.abs(index1-index2);
        if(diff==2 || diff==0){
          i++;
          j--;
        }
        else {
          flag=true ;
          break ;
        }
      }
      if(flag==true)System.out.println("NO");
      else {
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class second {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var p : String ; p := "abcdefghijklmnopqrstuvwxyz" ;
         var k : int ; k := 0 ; while k < n do ( (     var even : int ; even := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
    var i : int ; i := 0 ;
    var j : int ; j := s->size() - 1 ;
    var flag : boolean ; flag := false ;
    while (i < j) do (     var index1 : int ; index1 := p->indexOf(s->at(i+1))-1 ;
     var index2 : int ; index2 := p->indexOf(s->at(j+1))-1 ;
     var diff : int ; diff := if index1 - index2 < 0 then -(index1 - index2) else index1 - index2 endif ;
     if (diff = 2 or diff = 0) then (     i := i + 1 ; 
     j := j - 1 ) else (     flag := true ; 
     break ) ) ; 
    if (flag = true) then     OclFile["System.out"].println("NO") else (     OclFile["System.out"].println("YES") ) ;  
 )  ;     k := k + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static int MAX=50022 ;
  private static boolean[] prm=new boolean[MAX];
  public static void main(String[] args){
    int n,small=MAX,large=0 ;
    init();
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      n=sc.nextInt();
      for(int i=n-1 ; i>0 ; i--){
        if(prm[i]){
          small=i ;
          break ;
        }
      }
      for(int i=n+1 ; i<MAX ; i++){
        if(prm[i]){
          large=i ;
          break ;
        }
      }
      System.out.println(small+" "+large);
    }
  }
  private static void init(){
    for(int i=0 ; i<MAX ; i++){
      prm[i]=true ;
    }
    prm[0]=false ;
    prm[1]=false ;
    for(int i=4 ; i<MAX ; i+=2){
      prm[i]=false ;
    }
    for(int i=3 ; i<Math.sqrt(MAX); i+=2){
      if(! prm[i]){
        continue ;
      }
      for(int k=i*2 ; k<MAX ; k+=i){
        prm[k]=false ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MAX : int := 50022;
  static   attribute prm : Sequence(boolean) := Integer.subrange(1,MAX)->collect(false);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var small : int ; small := MAX ;
    var large : int ; large := 0 ;
     execute init() ; 
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     n := sc.getCurrent()->toInteger() ; 
         var i : int ; i := n - 1 ; while i > 0 do ( (     if (prm[i+1]) then (     small := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
         var i : int ; i := n + 1 ; while i < MAX do ( (     if (prm[i+1]) then (     large := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(small + " " + large) ) );
  static   operation init() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < MAX do ( (     prm[i+1] := true )  ;     i := i + 1 ) ; 
     prm[0+1] := false ; 
    prm[1+1] := false ; 
        var i : int ; i := 4 ; while i < MAX do ( (     prm[i+1] := false )  ;     i := i+(2) ) ; 
        var i : int ; i := 3 ; while i < (MAX)->sqrt() do ( (     if (not(prm[i+1])) then (     continue ) else skip ; 
         var k : int ; k := i * 2 ; while k < MAX do ( (     prm[k+1] := false )  ;     k := k+(i) ) )  ;     i := i+(2) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    int N=50000 ;
    int overN ;
    boolean[] prims ;
    for(int i=N+1 ; ; i++){
      int count=0 ;
      for(int j=2 ; j<i ; j++){
        if(i % j==0){
          count++;
          break ;
        }
      }
      if(count==0){
        overN=i ;
        break ;
      }
      else {
        continue ;
      }
    }
    prims=new boolean[overN+1];
    for(int i=2 ; i<overN/2+1 ; i++){
      if(! prims[i]){
        for(int j=2 ; j<overN/i+1 ; j++){
          prims[i*j]=true ;
        }
      }
    }
    int primU=0,primL=0 ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=Integer.parseInt(line);
      for(int i=n+1 ; ; i++){
        if(! prims[i]){
          primU=i ;
          break ;
        }
      }
      for(int i=n-1 ; ; i--){
        if(! prims[i]){
          primL=i ;
          break ;
        }
      }
      System.out.println(primL+" "+primU);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
    var N : int ; N := 50000 ;
    var overN : int ;
    var prims : Sequence(boolean) ;
        var i : int ; i := N + 1 ; while true do ( (     var count : int ; count := 0 ;
         var j : int ; j := 2 ; while j < i do ( (     if (i mod j = 0) then (     count := count + 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (count = 0) then (     overN := i ; 
     break ) else (     continue ) )  ;     i := i + 1 ) ; 
    prims := Integer.subrange(1,overN + 1)->collect(false) ; 
        var i : int ; i := 2 ; while i < overN / 2 + 1 do ( (     if (not(prims[i+1])) then (         var j : int ; j := 2 ; while j < overN / i + 1 do ( (     prims[i * j+1] := true )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    var primU : int ; primU := 0 ;
    var primL : int ; primL := 0 ;
        line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := (line)->toInteger() ;
         var i : int ; i := n + 1 ; while true do ( (     if (not(prims[i+1])) then (     primU := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := n - 1 ; while true do ( (     if (not(prims[i+1])) then (     primL := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println(primL + " " + primU) ) ;     line := br.readLine() ;
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static int[] solve(int n){
    int[] ans=new int[2];
    ans[0]=n ;
    ans[1]=n ;
    if(n % 2==0){
      ans[0]=n-1 ;
      ans[1]=n+1 ;
    }
    else if(n==3){
      ans[0]=2 ;
      ans[1]=5 ;
      return ans ;
    }
    else {
      ans[0]=n-2 ;
      ans[1]=n+2 ;
    }
    for(int i=3 ; i<=Math.sqrt(ans[0]); i+=2){
      if(ans[0] % i==0){
        ans[0]-=2 ;
        i=1 ;
      }
    }
    for(int i=3 ; i<=Math.sqrt(ans[1]); i+=2){
      if(ans[1] % i==0){
        ans[1]+=2 ;
        i=1 ;
      }
    }
    return ans ;
  }
  public static void main(String[] args)throws IOException {
    Scanner stdIn=null ;
    List<int[]>result=new ArrayList<int[]>();
    try {
      stdIn=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
      while(stdIn.hasNext()){
        int n=stdIn.nextInt();
        int[] ans=solve(n);
        result.add(ans);
      }
      for(int[] list : result){
        System.out.println(list[0]+" "+list[1]);
      }
    }
    finally {
      if(stdIn!=null){
        stdIn.close();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Integer.subrange(1,2)->collect(0) ;
     ans[0+1] := n ; 
    ans[1+1] := n ; 
    if (n mod 2 = 0) then (     ans[0+1] := n - 1 ; 
     ans[1+1] := n + 1 ) else     if (n = 3) then (     ans[0+1] := 2 ; 
     ans[1+1] := 5 ; 
     return ans ) else (     ans[0+1] := n - 2 ; 
     ans[1+1] := n + 2 ) ;  ;  
        var i : int ; i := 3 ; while i <= (ans[0+1])->sqrt() do ( (     if (ans[0+1] mod i = 0) then (     ans[0+1] := ans[0+1]-(2) ; 
     i := 1 ) else skip )  ;     i := i+(2) ) ; 
        var i : int ; i := 3 ; while i <= (ans[1+1])->sqrt() do ( (     if (ans[1+1] mod i = 0) then (     ans[1+1] := ans[1+1]+(2) ; 
     i := 1 ) else skip )  ;     i := i+(2) ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := null ;
     var result : Sequence(Sequence(int)) ; result := Sequence{} ;
     try (     stdIn := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
     while (stdIn.hasNext()) do (     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     var ans : Sequence(int) ; ans := solve(n) ;
     result := result->including(ans) ) ; 
     for (list : result) do ( (     OclFile["System.out"].println(list[0+1] + " " + list[1+1]) )  ) )   finally (     if (stdIn /= null) then (     skip ) else skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int result ;
    if(n % 2==0){
      result=(n*n/2);
    }
    else {
      result=((n/2)+1)*((n/2)+1)+(n/2)*(n/2);
    }
    System.out.println(result);
    StringBuilder table=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        table.append(((i+j)% 2==0)? "C" : ".");
      }
      table.append("\n");
    }
    System.out.print(table);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var result : int ;
    if (n mod 2 = 0) then (     result := (n * n / 2) ) else (     result := ((n / 2) + 1) * ((n / 2) + 1) + (n / 2) * (n / 2) ) ;  
    OclFile["System.out"].println(result) ; 
    var table : String ; table := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     table := table + StringLib.newString(if ((i + j) mod 2 = 0) then "C" else "." endif) )  ;     j := j + 1 ) ; 
     table := table + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(table) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=26 ;
  static void compressString(String s,int n){
    int freq[]=new int[MAX];
    for(int i=0 ; i<n ; i++){
      freq[s.charAt(i)-'a']++;
    }
    for(int i=0 ; i<MAX ; i++){
      if(freq[i]==0)continue ;
      System.out.print((char)(i+'a')+""+freq[i]);
    }
  }
  public static void main(String[] args){
    String s="geeksforgeeks" ;
    int n=s.length();
    compressString(s,n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 26;
  static   operation compressString( s : String, n : int) : void
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,MAX)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     freq[s->at(i+1) - ('a')->char2byte()+1] := freq[s->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < MAX do ( (     if (freq[i+1] = 0) then     continue else skip ; 
     OclFile["System.out"].print((i + 'a')->oclAsType(String) + "" + freq[i+1]) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     var n : int ; n := s->size() ;
     execute compressString(s, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    System.out.println((n*n+1)/2);
    StringBuilder sb=new StringBuilder(n);
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if((i+j)% 2==0)sb.append('C');
        else sb.append('.');
      }
      sb.append('\n');
    }
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    OclFile["System.out"].println((n * n + 1) / 2) ; 
    var sb : String ; sb := StringLib.newString(n) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if ((i + j) mod 2 = 0) then     sb := sb + StringLib.newString('C') ; else     sb := sb + StringLib.newString('.') ; )  ;     j := j + 1 ) ; 
     sb := sb + StringLib.newString('
') )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    StringBuilder sb=new StringBuilder();
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if((i+j)% 2==0){
          sb.append("C");
          cnt++;
        }
        else {
          sb.append(".");
        }
      }
      sb.append("\n");
    }
    System.out.println(cnt);
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if ((i + j) mod 2 = 0) then (     sb := sb + StringLib.newString("C") ; 
     cnt := cnt + 1 ) else (     sb := sb + StringLib.newString(".") ) )  ;     j := j + 1 ) ; 
     sb := sb + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int minimumNumbers(int n,int s){
    if((s % n)>0)return s/n+1 ;
    else return s/n ;
  }
  public static void main(String[] args){
    int n=5 ;
    int s=11 ;
    System.out.println(minimumNumbers(n,s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumNumbers( n : int, s : int) : int
  pre: true
  post: true
  activity: (     if ((s mod n) > 0) then     return s / n + 1 else     return s / n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var s : int ; s := 11 ;
     OclFile["System.out"].println(minimumNumbers(n, s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Random ;
import java.util.Scanner ;
public class re {
  public static void main(String[] args){
    long n ;
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    System.out.println(n*(n/2)+(n/2+1)*(n % 2));
    StringBuffer s=new StringBuffer();
    StringBuffer s2=new StringBuffer();
    for(int i=0 ; i<n ; i++)if(i % 2==0)s.append('C');
    else s.append('.');
    for(int i=0 ; i<n ; i++)if(i % 2==0)s2.append('.');
    else s2.append('C');
    for(int i=0 ; i<n ; i++){
      if(i % 2==0)System.out.println(s);
      else System.out.println(s2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class re {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := sc.getCurrent()->toInteger() ; 
    OclFile["System.out"].println(n * (n / 2) + (n / 2 + 1) * (n mod 2)) ; 
    var s : String ; s := StringLib.newString() ;
    var s2 : String ; s2 := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do (     if (i mod 2 = 0) then     s := s + StringLib.newString('C') else     s := s + StringLib.newString('.') ; ;   ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     if (i mod 2 = 0) then     s2 := s2 + StringLib.newString('.') else     s2 := s2 + StringLib.newString('C') ; ;   ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then     OclFile["System.out"].println(s) ; else     OclFile["System.out"].println(s2) ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int N=100000 ;
  static boolean prime[]=new boolean[N];
  static void SieveOfEratosthenes(){
    Arrays.fill(prime,true);
    for(int p=2 ; p*p<=N ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<N ; i+=p)prime[i]=false ;
      }
    }
  }
  static int longestPrimeSubarray(int arr[],int n){
    int[] left=new int[n];
    int[] right=new int[n];
    int primecount=0,res=0 ;
    for(int i=0 ; i<n ; i++){
      left[i]=primecount ;
      if(prime[arr[i] ]){
        primecount++;
      }
      else primecount=0 ;
    }
    primecount=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      right[i]=primecount ;
      if(prime[arr[i] ]){
        primecount++;
      }
      else primecount=0 ;
    }
    for(int i=0 ; i<n ; i++)res=Math.max(res,left[i]+right[i]);
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      2,8,5,7,9,5,7 };
      SieveOfEratosthenes();
      int n=arr.length ;
      System.out.println("largest length of PrimeSubarray "+longestPrimeSubarray(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 100000;
  static   attribute prime : boolean := Integer.subrange(1,N)->collect(false);
  static   operation SieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (     prime := prime->collect(true) ; 
         var p : int ; p := 2 ; while p * p <= N do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i < N do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation longestPrimeSubarray( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var left : Sequence(int) ; left := Integer.subrange(1,n)->collect(0) ;
     var right : Sequence(int) ; right := Integer.subrange(1,n)->collect(0) ;
    var primecount : int ; primecount := 0 ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     left[i+1] := primecount ; 
     if (prime[arr[i+1]+1]) then (     primecount := primecount + 1 ) else     primecount := 0 ; )  ;     i := i + 1 ) ; 
    primecount := 0 ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     right[i+1] := primecount ; 
     if (prime[arr[i+1]+1]) then (     primecount := primecount + 1 ) else     primecount := 0 ; )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     res := Set{res, left[i+1] + right[i+1]}->max() ;  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,8,5,7,9,5,7} ;
     execute SieveOfEratosthenes() ; 
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("largest length of PrimeSubarray " + longestPrimeSubarray(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.floor ;
public class Main {
  static int N=100010 ;
  static int n ;
  static long ans ;
  static int g[]=new int[N],d[]=new int[N];
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    n=in.nextInt();
    for(int i=1 ; i<=n ; i++)g[i]=in.nextInt();
    for(int i=1 ; i<n ; i++){
      if(g[i]>g[i+1]){
        int t=g[i]-g[i+1];
        if(d[i]>=t){
          d[i+1]=t ;
          g[i+1]=g[i];
        }
        else {
          d[i+1]=t ;
          ans+=t-d[i];
          g[i+1]=g[i];
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int := 100010;
  static   attribute n : int;
  static   attribute ans : long;
  static   attribute g : int := Integer.subrange(1,N)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := in.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i <= n do (     g[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (g[i+1] > g[i + 1+1]) then (     var t : int ; t := g[i+1] - g[i + 1+1] ;
     if (d[i+1] >= t) then (     d[i + 1+1] := t ; 
     g[i + 1+1] := g[i+1] ) else (     d[i + 1+1] := t ; 
     ans := ans+(t - d[i+1]) ; 
     g[i + 1+1] := g[i+1] ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=in.nextInt();
    long ans=0 ;
    for(int i=1 ; i<n ; i++){
      if(a[i-1]>a[i]){
        ans+=(a[i-1]-a[i]);
      }
    }
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i - 1+1] > a[i+1]) then (     ans := ans+((a[i - 1+1] - a[i+1])) ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Odd_Selection {
  public static void main(String[] args)throws Exception {
    InputStreamReader r=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(r);
    PrintWriter p=new PrintWriter(System.out);
    int test=1 ;
    while(test-->0){
      String str[]=br.readLine().trim().split(" ");
      int n=Integer.parseInt(str[0]);
      str=br.readLine().trim().split(" ");
      long a[]=new long[n];
      for(int i=0 ; i<n ; i++){
        a[i]=Integer.parseInt(str[i]);
      }
      long answer=0 ;
      long current=0 ;
      for(int i=1 ; i<n ; i++){
        if(a[i]>=a[i-1]){
          current=0 ;
        }
        else {
          if(a[i]+current<a[i-1]){
            long dif=a[i-1]-(a[i]+current);
            answer+=dif ;
            current+=dif ;
          }
          else {
            long dif=(a[i]+current)-a[i-1];
            current-=dif ;
          }
          a[i]=a[i-1];
        }
      }
      p.println(answer);
    }
    p.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Odd_Selection {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(r) ;
    var p : OclFile ; p := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := 1 ;
        while (test > 0) do (        test := test - 1 ;     skip ; (     var str : Sequence(String) ; str := br.readLine()->trim()->split(" ") ;
     var n : int ; n := (str[0+1])->toInteger() ;
    str := br.readLine()->trim()->split(" ") ; 
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (str[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var answer : long ; answer := 0 ;
    var current : long ; current := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] >= a[i - 1+1]) then (     current := 0 ) else (     if (a[i+1] + current < a[i - 1+1]) then (     var dif : long ; dif := a[i - 1+1] - (a[i+1] + current) ;
     answer := answer+(dif) ; 
     current := current+(dif) ) else (     var dif : long ; dif := (a[i+1] + current) - a[i - 1+1] ;
     current := current-(dif) ) ;  
     a[i+1] := a[i - 1+1] ) )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class LittleElephantAndSorting {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(reader.readLine());
    String input[]=reader.readLine().split(" ");
    n=input.length ;
    int i=0 ;
    int nums[]=new int[n];
    for(String str : input)nums[i++]=Integer.parseInt(str);
    long ans=0 ;
    int m=-1 ;
    int d=0 ;
    for(int j=0 ; j<n ; j++){
      if(m<nums[j]){
        m=nums[j];
        d=0 ;
        continue ;
      }
      nums[j]+=d ;
      if(nums[j]<=m){
        d+=m-nums[j];
        ans+=m-nums[j];
      }
      else {
        d-=nums[j]-m ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class LittleElephantAndSorting {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (reader.readLine())->toInteger() ;
    var input : Sequence(String) ; input := reader.readLine()->split(" ") ;
    n := input->size() ; 
    var i : int ; i := 0 ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
    for (str : input) do (      nums[i+1] := (str)->toInteger()  ; i := i + 1 ;  ) ; 
    var ans : long ; ans := 0 ;
    var m : int ; m := -1 ;
    var d : int ; d := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     if (m < nums[j+1]) then (     m := nums[j+1] ; 
     d := 0 ; 
     continue ) else skip ; 
     nums[j+1] := nums[j+1]+(d) ; 
     if (nums[j+1] <= m) then (     d := d+(m - nums[j+1]) ; 
     ans := ans+(m - nums[j+1]) ) else (     d := d-(nums[j+1] - m) ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void fib(int f[],int N){
    f[1]=1 ;
    f[2]=1 ;
    for(int i=3 ; i<=N ; i++)f[i]=f[i-1]+f[i-2];
  }
  static void fiboTriangle(int n){
    int N=n*(n+1)/2 ;
    int f[]=new int[N+1];
    fib(f,N);
    int fiboNum=1 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=i ; j++)System.out.print(f[fiboNum++]+" ");
      System.out.println();
    }
  }
  public static void main(String args[]){
    int n=5 ;
    fiboTriangle(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fib( f : Sequence(int), N : int) : void
  pre: true
  post: true
  activity: (     f[1+1] := 1 ; 
     f[2+1] := 1 ; 
         var i : int ; i := 3 ; while i <= N do (     f[i+1] := f[i - 1+1] + f[i - 2+1] ;  ;     i := i + 1 ) );
  static   operation fiboTriangle( n : int) : void
  pre: true
  post: true
  activity: (     var N : int ; N := n * (n + 1) / 2 ;
     var f : Sequence(int) ; f := Integer.subrange(1,N + 1)->collect(0) ;
    execute fib(f, N) ; 
    var fiboNum : int ; fiboNum := 1 ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= i do (     OclFile["System.out"].print(f[fiboNum+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute fiboTriangle(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class CthulhuCodeForces {
  static boolean cycle=false ;
  public static void DFS(int u,int p,int[] visited,List<List<Integer>>adjacency){
    visited[u]=1 ;
    for(int i=0 ; i<adjacency.get(u).size(); i++){
      int v=adjacency.get(u).get(i);
      if(visited[v]==0){
        DFS(v,u,visited,adjacency);
      }
      else if(v!=p){
        cycle=true ;
      }
    }
  }
  public static void main(String[] args){
    Scanner obj=new Scanner(System.in);
    int n=obj.nextInt();
    int m=obj.nextInt();
    List<List<Integer>>adjacency=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      adjacency.add(new ArrayList<>());
    }
    for(int i=0 ; i<m ; i++){
      int u=obj.nextInt();
      int v=obj.nextInt();
      u--;
      v--;
      adjacency.get(u).add(v);
      adjacency.get(v).add(u);
    }
    int[] visited=new int[n];
    int component=0 ;
    for(int i=0 ; i<n ; i++){
      if(visited[i]==0){
        DFS(i,-1,visited,adjacency);
        component++;
      }
    }
    if(cycle==true && component==1 && n==m){
      System.out.println("FHTAGN!");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CthulhuCodeForces {
  static   attribute cycle : boolean := false;
  static   operation DFS( u : int, p : int, visited : Sequence(int), adjacency : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     visited[u+1] := 1 ; 
         var i : int ; i := 0 ; while i < adjacency->at(u+1)->size() do ( (     var v : int ; v := adjacency->at(u+1)->at(i+1) ;
     if (visited[v+1] = 0) then (     execute DFS(v, u, visited, adjacency) ) else     if (v /= p) then (     cycle := true ) else skip ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : OclFile ; obj := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := obj.getCurrent()->toInteger() ;
    var m : int ; m := obj.getCurrent()->toInteger() ;
    var adjacency : Sequence(Sequence(int)) ; adjacency := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     adjacency := adjacency->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var u : int ; u := obj.getCurrent()->toInteger() ;
     var v : int ; v := obj.getCurrent()->toInteger() ;
    u := u - 1 ; 
    v := v - 1 ; 
    adjacency->at(u+1)->excludes(v) ; 
    adjacency->at(v+1)->excludes(u) ; 
 )  ;     i := i + 1 ) ; 
    var visited : Sequence(int) ; visited := Integer.subrange(1,n)->collect(0) ;
    var component : int ; component := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (visited[i+1] = 0) then (     execute DFS(i, -1, visited, adjacency) ; 
     component := component + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (cycle = true & component = 1 & n = m) then (     OclFile["System.out"].println("FHTAGN!") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findNthTerm(int N){
    int ans=0 ;
    for(int i=0 ; i<N ; i++){
      if(i % 2==0){
        ans=ans+6 ;
      }
      else {
        ans=ans+2 ;
      }
    }
    System.out.print(ans+"\n");
  }
  public static void main(String[] args){
    int N=3 ;
    findNthTerm(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNthTerm( N : int) : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     if (i mod 2 = 0) then (     ans := ans + 6 ) else (     ans := ans + 2 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(ans + "\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
     execute findNthTerm(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class CthulhuCodeForces {
  static boolean cycle=false ;
  public static void DFS(int u,int p,int[] visited,List<List<Integer>>adjacency){
    visited[u]=1 ;
    for(int i=0 ; i<adjacency.get(u).size(); i++){
      int v=adjacency.get(u).get(i);
      if(visited[v]==0){
        DFS(v,u,visited,adjacency);
      }
      else if(v!=p){
        cycle=true ;
      }
    }
  }
  public static void main(String[] args){
    Scanner obj=new Scanner(System.in);
    int n=obj.nextInt();
    int m=obj.nextInt();
    List<List<Integer>>adjacency=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      adjacency.add(new ArrayList<>());
    }
    for(int i=0 ; i<m ; i++){
      int u=obj.nextInt();
      int v=obj.nextInt();
      u--;
      v--;
      adjacency.get(u).add(v);
      adjacency.get(v).add(u);
    }
    int[] visited=new int[n];
    int component=0 ;
    for(int i=0 ; i<n ; i++){
      if(visited[i]==0){
        DFS(i,-1,visited,adjacency);
        component++;
      }
    }
    if(cycle==true && component==1 && n==m){
      System.out.println("FHTAGN!");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CthulhuCodeForces {
  static   attribute cycle : boolean := false;
  static   operation DFS( u : int, p : int, visited : Sequence(int), adjacency : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     visited[u+1] := 1 ; 
         var i : int ; i := 0 ; while i < adjacency->at(u+1)->size() do ( (     var v : int ; v := adjacency->at(u+1)->at(i+1) ;
     if (visited[v+1] = 0) then (     execute DFS(v, u, visited, adjacency) ) else     if (v /= p) then (     cycle := true ) else skip ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : OclFile ; obj := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := obj.getCurrent()->toInteger() ;
    var m : int ; m := obj.getCurrent()->toInteger() ;
    var adjacency : Sequence(Sequence(int)) ; adjacency := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     adjacency := adjacency->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var u : int ; u := obj.getCurrent()->toInteger() ;
     var v : int ; v := obj.getCurrent()->toInteger() ;
    u := u - 1 ; 
    v := v - 1 ; 
    adjacency->at(u+1)->excludes(v) ; 
    adjacency->at(v+1)->excludes(u) ; 
 )  ;     i := i + 1 ) ; 
    var visited : Sequence(int) ; visited := Integer.subrange(1,n)->collect(0) ;
    var component : int ; component := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (visited[i+1] = 0) then (     execute DFS(i, -1, visited, adjacency) ; 
     component := component + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (cycle = true & component = 1 & n = m) then (     OclFile["System.out"].println("FHTAGN!") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int countTriplets(int arr[],int n,int m){
    int count=0 ;
    Arrays.sort(arr);
    int end,start,mid ;
    for(end=n-1 ; end>=2 ; end--){
      start=0 ;
      mid=end-1 ;
      while(start<mid){
        long prod=arr[end]*arr[start]*arr[mid];
        if(prod>m)mid--;
        else if(prod<m)start++;
        else if(prod==m){
          count++;
          mid--;
          start++;
        }
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int[] arr={
      1,1,1,1,1,1 };
      int n=arr.length ;
      int m=1 ;
      System.out.println(countTriplets(arr,n,m));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countTriplets( arr : Sequence(int), n : int, m : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     arr := arr->sort() ; 
    var end : int ;
    var start : int ;
    var mid : int ;
        end := n - 1 ; while end >= 2 do ( (     start := 0 ; 
     mid := end - 1 ; 
     while (start < mid) do (     var prod : long ; prod := arr[end+1] * arr[start+1] * arr[mid+1] ;
     if (prod > m) then     mid := mid - 1 ; else     if (prod < m) then     start := start + 1 else     if (prod = m) then (     count := count + 1 ; 
     mid := mid - 1 ; 
     start := start + 1 ) else skip ; ;  ) )  ;     end := end - 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,1,1,1,1} ;
     var n : int ; n := arr->size() ;
     var m : int ; m := 1 ;
     OclFile["System.out"].println(countTriplets(arr, n, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class EggDrop {
  static int max(int a,int b){
    return(a>b)? a : b ;
  }
  static int eggDrop(int n,int k){
    int eggFloor[][]=new int[n+1][k+1];
    int res ;
    int i,j,x ;
    for(i=1 ; i<=n ; i++){
      eggFloor[i][1]=1 ;
      eggFloor[i][0]=0 ;
    }
    for(j=1 ; j<=k ; j++)eggFloor[1][j]=j ;
    for(i=2 ; i<=n ; i++){
      for(j=2 ; j<=k ; j++){
        eggFloor[i][j]=Integer.MAX_VALUE ;
        for(x=1 ; x<=j ; x++){
          res=1+max(eggFloor[i-1][x-1],eggFloor[i][j-x]);
          if(res<eggFloor[i][j])eggFloor[i][j]=res ;
        }
      }
    }
    return eggFloor[n][k];
  }
  public static void main(String args[]){
    int n=2,k=10 ;
    System.out.println("Minimum number of trials in worst case with "+n+"  eggs and "+k+" floors is "+eggDrop(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class EggDrop {
  static   operation max( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if (a > b) then a else b endif );
  static   operation eggDrop( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var eggFloor : Sequence(Sequence(int)) ; eggFloor := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,k + 1)->collect(0)) ;
     var res : int ;
    var i : int ;
    var j : int ;
    var x : int ;
        i := 1 ; while i <= n do ( (     eggFloor[i+1][1+1] := 1 ; 
     eggFloor[i+1][0+1] := 0 )  ;     i := i + 1 ) ; 
        j := 1 ; while j <= k do (     eggFloor[1+1][j+1] := j ;  ;     j := j + 1 ) ; 
        i := 2 ; while i <= n do ( (         j := 2 ; while j <= k do ( (     eggFloor[i+1][j+1] := 2147483647 ; 
         x := 1 ; while x <= j do ( (     res := 1 + Set{eggFloor[i - 1+1][x - 1+1], eggFloor[i+1][j - x+1]}->max() ; 
     if (res < eggFloor[i+1][j+1]) then     eggFloor[i+1][j+1] := res ; else skip )  ;     x := x + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return eggFloor[n+1][k+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
    var k : int ; k := 10 ;
     OclFile["System.out"].println("Minimum number of trials in worst case with " + n + "  eggs and " + k + " floors is " + eggDrop(n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    StringBuilder sb=new StringBuilder();
    while(t-->0){
      int n=in.nextInt();
      int[] a=new int[n];
      int max=Integer.MIN_VALUE,ind=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
        if(max<a[i]){
          max=a[i];
          ind=i ;
        }
      }
      int[] res=new int[3];
      int ans=0 ;
      for(int i=1 ; i<n-1 ; i++){
        ArrayList<Integer>bef=new ArrayList<>(),aft=new ArrayList<>();
        for(int j=i+1 ; j<n ; j++){
          if(a[i]>a[j])aft.add(j);
        }
        for(int j=0 ; j<i ; j++){
          if(a[i]>a[j])bef.add(j);
        }
        if(bef.size()!=0 && aft.size()!=0){
          res[0]=bef.get(0)+1 ;
          res[1]=i+1 ;
          res[2]=aft.get(0)+1 ;
          ans++;
          break ;
        }
      }
      sb.append(ans>0 ? "YES" : "NO").append("\n");
      if(ans>0){
        for(int i=0 ; i<3 ; i++){
          sb.append(res[i]).append(" ");
        }
        sb.append("\n");
      }
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := -2147483648 ;
    var ind : int ; ind := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     if (max < a[i+1]) then (     max := a[i+1] ; 
     ind := i ) else skip )  ;     i := i + 1 ) ; 
    var res : Sequence(int) ; res := Integer.subrange(1,3)->collect(0) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < (n)->char2byte() - 1 do ( (     var bef : Sequence(int) ; bef := Sequence{} ;
    var aft : Sequence(int) ; aft := Sequence{} ;
         var j : int ; j := i + 1 ; while j < n do ( (     if (a[i+1] > a[j+1]) then     aft->excludes(j) ; else skip )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < i do ( (     if (a[i+1] > a[j+1]) then     bef := bef->including(j) ; else skip )  ;     j := j + 1 ) ; 
     if (bef->size() /= 0 & aft->size() /= 0) then (     res[0+1] := bef->at(0+1) + 1 ; 
     res[1+1] := i + 1 ; 
    res[2+1] := aft->at(0+1) + 1 ; 
    ans := ans + 1 ; 
    break 
 ) else skip )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(if ans > 0 then "YES" else "NO" endif) + StringLib.newString("\n") ; 
    if (ans > 0) then (         var i : int ; i := 0 ; while i < 3 do ( (     sb := sb + StringLib.newString(res[i+1]) + StringLib.newString(" ") )  ;     i := i + 1 ) ; 
     sb := sb + StringLib.newString("\n") ) else skip ; 
 ) ;  ) ;  
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class p1380A {
  public static void main(String[] agrs){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      boolean b=false ;
      int n=sc.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      int i ;
      for(i=0 ; i<n-2 ; i++){
        if(a[i]<a[i+1] && a[i+1]>a[i+2]){
          b=true ;
          i++;
          break ;
        }
      }
      System.out.println(b ?("YES\n"+i+" "+(i+1)+" "+(i+2)): "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class p1380A {
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var b : boolean ; b := false ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var i : int ;
        i := 0 ; while i < n - 2 do ( (     if (a[i+1] < a[i + 1+1] & a[i + 1+1] > a[i + 2+1]) then (     b := true ; 
     i := i + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if b then ("YES\n" + i + " " + (i + 1) + " " + (i + 2)) else "NO" endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    MiddleoftheCOntest();
  }
  public static void MiddleoftheCOntest(){
    Scanner scan=new Scanner(System.in);
    String start=scan.next();
    String end=scan.next();
    int startMin=Integer.valueOf(start.substring(0,2))*60+Integer.valueOf(start.substring(3,5));
    int endMin=Integer.valueOf(end.substring(0,2))*60+Integer.valueOf(end.substring(3,5));
    int midMin=startMin+(endMin-startMin)/2 ;
    int midhr=midMin/60 ;
    int midmin=midMin % 60 ;
    System.out.format("%02d:%02d",midhr,midmin);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute MiddleoftheCOntest() );
  static   operation MiddleoftheCOntest() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var start : String ; start := scan.getCurrent() ;
    var end : String ; end := scan.getCurrent() ;
    var startMin : int ; startMin := (start.subrange(0+1,2))->toInteger() * 60 + (start.subrange(3+1,5))->toInteger() ;
    var endMin : int ; endMin := (end.subrange(0+1,2))->toInteger() * 60 + (end.subrange(3+1,5))->toInteger() ;
    var midMin : int ; midMin := startMin + (endMin - (startMin)->char2byte()) / 2 ;
    var midhr : int ; midhr := midMin / 60 ;
    var midmin : int ; midmin := midMin mod 60 ;
    OclFile["System.out"].format("%02d:%02d", midhr, midmin) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemB {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    String line[]=br.readLine().split(":");
    ArrayList<String>list=new ArrayList<>();
    int h=Integer.parseInt(line[0]);
    int m=Integer.parseInt(line[1]);
    line=br.readLine().split(":");
    int hh=Integer.parseInt(line[0]);
    int mm=Integer.parseInt(line[1]);
    for(int i=h ; i<=hh ; i++){
      int len=i==hh ? mm : 59 ;
      int st=i==h ? m : 0 ;
      for(int j=st ; j<=len ; j++){
        String time=(i<10 ? "0"+i : i)+":"+(j<10 ? "0"+j : j);
        list.add(time);
      }
    }
    System.out.println(list.get(list.size()/2));
  }
  public static void sort(int arr[]){
    ArrayList<Integer>list=new ArrayList<>();
    for(int it : arr)list.add(it);
    Collections.sort(list);
    for(int i=0 ; i<arr.length ; i++)arr[i]=list.get(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var line : Sequence(String) ; line := br.readLine()->split(":") ;
    var list : Sequence(String) ; list := Sequence{} ;
    var h : int ; h := (line[0+1])->toInteger() ;
    var m : int ; m := (line[1+1])->toInteger() ;
    line := br.readLine()->split(":") ; 
    var hh : int ; hh := (line[0+1])->toInteger() ;
    var mm : int ; mm := (line[1+1])->toInteger() ;
        var i : int ; i := h ; while i <= hh do ( (     var len : int ; len := if i = hh then mm else 59 endif ;
     var st : int ; st := if i = h then m else 0 endif ;
         var j : int ; j := st ; while j <= len do ( (     var time : String ; time := (if i < 10 then "0" + i else i endif) + ":" + (if j < 10 then "0" + j else j endif) ;
     list := list->including(time) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(list->at(list->size() / 2+1)) ; 
 );
  static   operation sort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     for (it : arr) do (     list := list->including(it) ;  ) ; 
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < arr->size() do (     arr[i+1] := list->at(i+1) ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class MyClass {
  static boolean check(int a[],int b[]){
    for(int i=0 ; i<26 ; i++){
      if(a[i]!=b[i])return false ;
    }
    return true ;
  }
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s=br.readLine();
    String t=br.readLine();
    int h1=Integer.parseInt(s.substring(0,2));
    int m1=Integer.parseInt(s.substring(3,5));
    int h2=Integer.parseInt(t.substring(0,2));
    int m2=Integer.parseInt(t.substring(3,5));
    int m=0 ;
    int h=0 ;
    if(m1>m2){
      m+=(60-m1+m2)/2 ;
      h1++;
    }
    else {
      m+=(m2-m1)/2 ;
    }
    h+=(h2-h1)/2 ;
    if((h2-h1)% 2==1){
      m+=30 ;
    }
    if(m1>m2)h1--;
    int M=m1+m ;
    int H=h1+h ;
    if(M>59){
      M=M % 60 ;
      H++;
    }
    H=H % 24 ;
    String ans="" ;
    if(H<10)ans+='0' ;
    ans+=H+":" ;
    if(M<10)ans+='0' ;
    ans+=M ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation check( a : Sequence(int), b : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 26 do ( (     if (a[i+1] /= b[i+1]) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := br.readLine() ;
    var t : String ; t := br.readLine() ;
    var h1 : int ; h1 := (s.subrange(0+1,2))->toInteger() ;
    var m1 : int ; m1 := (s.subrange(3+1,5))->toInteger() ;
    var h2 : int ; h2 := (t.subrange(0+1,2))->toInteger() ;
    var m2 : int ; m2 := (t.subrange(3+1,5))->toInteger() ;
    var m : int ; m := 0 ;
    var h : int ; h := 0 ;
    if (m1 > m2) then (     m := m+((60 - m1 + m2) / 2) ; 
     h1 := h1 + 1 ) else (     m := m+((m2 - m1) / 2) ) ;  
    h := h+((h2 - (h1)->char2byte()) / 2) ; 
    if ((h2 - (h1)->char2byte()) mod 2 = 1) then (     m := m+(30) ) else skip ; 
    if (m1 > m2) then     h1 := h1 - 1 ; else skip ; 
    var M : int ; M := m1 + m ;
    var H : int ; H := h1 + h ;
    if (M > 59) then (     M := M mod 60 ; 
     H := H + 1 ) else skip ; 
    H := H mod 24 ; 
    var ans : String ; ans := "" ;
    if (H < 10) then     ans := ans+('0') ; else skip ; 
    ans := ans+(H + ":") ; 
    if (M < 10) then     ans := ans+('0') ; else skip ; 
    ans := ans+(M) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void solve(String s1,String s2){
    String[] a1=s1.split(":");
    String[] a2=s2.split(":");
    int hr1=Integer.parseInt(a1[0]);
    int hr2=Integer.parseInt(a2[0]);
    int min1=Integer.parseInt(a1[1]);
    int min2=Integer.parseInt(a2[1]);
    int mins=(min1+min2)/2 ;
    int hrs=(hr1+hr2);
    int eMin=0 ;
    if(hrs % 2!=0)eMin=30 ;
    int ans_min=(mins % 60)+eMin ;
    int ans_hr=hrs/2 ;
    if(ans_min>=60){
      int x=ans_min ;
      ans_min=ans_min % 60 ;
      ans_hr=ans_hr+x/60 ;
    }
    String ans=(hrs/2)+":"+ans_min ;
    if(ans_hr<10){
      if(ans_min<10){
        ans="0"+ans_hr+":0"+ans_min ;
      }
      else {
        ans="0"+ans_hr+":"+ans_min ;
      }
    }
    else {
      if(ans_min<10){
        ans=""+ans_hr+":"+"0"+ans_min ;
      }
      else ans=""+ans_hr+":"+ans_min ;
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s1=sc.next();
    String s2=sc.next();
    solve(s1,s2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( s1 : String, s2 : String) : void
  pre: true
  post: true
  activity: (     var a1 : Sequence(String) ; a1 := s1->split(":") ;
     var a2 : Sequence(String) ; a2 := s2->split(":") ;
    var hr1 : int ; hr1 := (a1[0+1])->toInteger() ;
    var hr2 : int ; hr2 := (a2[0+1])->toInteger() ;
    var min1 : int ; min1 := (a1[1+1])->toInteger() ;
    var min2 : int ; min2 := (a2[1+1])->toInteger() ;
    var mins : int ; mins := (min1 + min2) / 2 ;
    var hrs : int ; hrs := (hr1 + hr2) ;
    var eMin : int ; eMin := 0 ;
    if (hrs mod 2 /= 0) then     eMin := 30 ; else skip ; 
    var ans_min : int ; ans_min := (mins mod 60) + eMin ;
    var ans_hr : int ; ans_hr := hrs / 2 ;
    if (ans_min >= 60) then (     var x : int ; x := ans_min ;
     ans_min := ans_min mod 60 ; 
     ans_hr := ans_hr + x / 60 ) else skip ; 
    var ans : String ; ans := (hrs / 2) + ":" + ans_min ;
    if (ans_hr < 10) then (     if (ans_min < 10) then (     ans := "0" + ans_hr + ":0" + ans_min ) else (     ans := "0" + ans_hr + ":" + ans_min ) ) else (     if (ans_min < 10) then (     ans := "" + ans_hr + ":" + "0" + ans_min ) else     ans := "" + ans_hr + ":" + ans_min ; ) ;  
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := sc.getCurrent() ;
     var s2 : String ; s2 := sc.getCurrent() ;
     execute solve(s1, s2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DecodeString {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int testCases=scanner.nextInt();
    for(int i=0 ; i<testCases ; i++){
      int encodedStringLength=scanner.nextInt();
      String encodedString=scanner.next();
      System.out.println(decodeString(encodedStringLength,encodedString));
    }
  }
  private static String decodeString(int encodedStringLength,String encodedString){
    StringBuilder decodedString=new StringBuilder();
    int smallAAscii=96 ;
    for(int i=0 ; i<encodedStringLength ; i++){
      int currentInt=Character.getNumericValue(encodedString.charAt(i));
      if(currentInt>=3){
        char asciiString=(char)(currentInt+smallAAscii);
        decodedString.append(asciiString);
      }
      else {
        if(i<=encodedStringLength-3 && Character.getNumericValue(encodedString.charAt(i+2))==0){
          if(i+2==encodedStringLength-1 || Character.getNumericValue(encodedString.charAt(i+3))!=0){
            int firstCharInt=Character.getNumericValue(encodedString.charAt(i));
            int secondCharInt=Character.getNumericValue(encodedString.charAt(i+1));
            String firstSecondString=String.valueOf(firstCharInt)+String.valueOf(secondCharInt);
            char asciiString=(char)(Integer.parseInt(firstSecondString)+smallAAscii);
            decodedString.append(asciiString);
            i+=2 ;
          }
          else {
            char asciiString=(char)(currentInt+smallAAscii);
            decodedString.append(asciiString);
          }
        }
        else {
          char asciiString=(char)(currentInt+smallAAscii);
          decodedString.append(asciiString);
        }
      }
    }
    return decodedString.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class DecodeString {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < testCases do ( (     var encodedStringLength : int ; encodedStringLength := scanner.getCurrent()->toInteger() ;
     var encodedString : String ; encodedString := scanner.getCurrent() ;
     OclFile["System.out"].println(decodeString(encodedStringLength, encodedString)) )  ;     i := i + 1 ) );
  static   operation decodeString( encodedStringLength : int, encodedString : String) : String
  pre: true
  post: true
  activity: (     var decodedString : String ; decodedString := StringLib.newString() ;
     var smallAAscii : int ; smallAAscii := 96 ;
         var i : int ; i := 0 ; while i < encodedStringLength do ( (     var currentInt : int ; currentInt := ("" + encodedString->at(i+1))->toInteger() ;
     if (currentInt >= 3) then (     var asciiString : String ; asciiString := (currentInt + smallAAscii)->oclAsType(String) ;
     decodedString := decodedString + StringLib.newString(asciiString) ) else (     if (i <= encodedStringLength - 3 & ("" + encodedString->at(i + 2+1))->toInteger() = 0) then (     if (i + 2 = encodedStringLength - 1 or ("" + encodedString->at(i + 3+1))->toInteger() /= 0) then (     var firstCharInt : int ; firstCharInt := ("" + encodedString->at(i+1))->toInteger() ;
     var secondCharInt : int ; secondCharInt := ("" + encodedString->at(i + 1+1))->toInteger() ;
    var firstSecondString : String ; firstSecondString := ((firstCharInt) + "") + ((secondCharInt) + "") ;
    var asciiString : String ; asciiString := ((firstSecondString)->toInteger() + smallAAscii)->oclAsType(String) ;
    decodedString := decodedString + StringLib.newString(asciiString) ; 
    i := i+(2) ; 
 ) else (     var asciiString : String ; asciiString := (currentInt + smallAAscii)->oclAsType(String) ;
     decodedString := decodedString + StringLib.newString(asciiString) ) ) else (     var asciiString : String ; asciiString := (currentInt + smallAAscii)->oclAsType(String) ;
     decodedString := decodedString + StringLib.newString(asciiString) ) ) )  ;     i := i + 1 ) ; 
     return decodedString+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A1729 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    for(int qq=0 ; qq<q ; qq++){
      String s="" ;
      int n=sc.nextInt();
      String t=sc.next();
      for(int i=0 ; i<n ; i++){
        char ch=t.charAt(i);
        if(i+2<n && t.charAt(i+2)=='0' && !(i+3<n && t.charAt(i+3)=='0')){
          int k=(int)ch-48 ;
          int k1=(int)(t.charAt(i+1))-48 ;
          int kk=10*k+k1 ;
          s+=(char)(96+kk);
          i+=2 ;
        }
        else {
          s+=(char)(96+((int)ch-48));
        }
      }
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1729 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
         var qq : int ; qq := 0 ; while qq < q do ( (     var s : String ; s := "" ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : String ; t := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < n do ( (     var ch : String ; ch := t->at(i+1) ;
     if (i + 2 < n & t->at(i + 2+1) = '0' & not((i + 3 < n & t->at(i + 3+1) = '0'))) then (     var k : int ; k := (ch)->char2byte() - 48 ;
     var k1 : int ; k1 := (t->at(i + 1+1))->oclAsType(int) - 48 ;
    var kk : int ; kk := 10 * k + k1 ;
    s := s+((96 + kk)->oclAsType(String)) ; 
    i := i+(2) ; 
 ) else (     s := s+((96 + ((ch)->char2byte() - 48))->oclAsType(String)) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 )  ;     qq := qq + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] tmpArray=br.readLine().split(" ");
    int n=Integer.parseInt(tmpArray[0]);
    int h=Integer.parseInt(tmpArray[1]);
    int w=Integer.parseInt(tmpArray[2]);
    int input[]=new int[n];
    tmpArray=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      input[i]=Integer.parseInt(tmpArray[i]);
    }
    int x[]=new int[n];
    for(int i=0 ; i<n ; i++){
      if(i % 2==0){
        x[i]=i*w+input[i];
      }
      else {
        x[i]=i*w-input[i];
      }
    }
    boolean closed[]=new boolean[n*w];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<w ; j++){
        closed[x[i]+j]=true ;
      }
    }
    int result=0 ;
    for(int i=0 ; i<closed.length ; i++){
      if(! closed[i]){
        result+=h ;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
    var n : int ; n := (tmpArray[0+1])->toInteger() ;
    var h : int ; h := (tmpArray[1+1])->toInteger() ;
    var w : int ; w := (tmpArray[2+1])->toInteger() ;
    var input : Sequence(int) ; input := Integer.subrange(1,n)->collect(0) ;
    tmpArray := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do ( (     input[i+1] := (tmpArray[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then (     x[i+1] := i * w + input[i+1] ) else (     x[i+1] := i * w - input[i+1] ) )  ;     i := i + 1 ) ; 
    var closed : Sequence(boolean) ; closed := Integer.subrange(1,n * w)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < w do ( (     closed[x[i+1] + j+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < closed->size() do ( (     if (not(closed[i+1])) then (     result := result+(h) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countDivisbleby4(String s){
    int n=s.length();
    int count=0 ;
    for(int i=0 ; i<n ; ++i)if(s.charAt(i)=='4' || s.charAt(i)=='8' || s.charAt(i)=='0')count++;
    for(int i=0 ; i<n-1 ; ++i){
      int h=(s.charAt(i)-'0')*10+(s.charAt(i+1)-'0');
      if(h % 4==0)count=count+i+1 ;
    }
    return count ;
  }
  public static void main(String[] args){
    String s="124" ;
    System.out.println(countDivisbleby4(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDivisbleby4( s : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (s->at(i+1) = '4' or s->at(i+1) = '8' or s->at(i+1) = '0') then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var h : int ; h := (s->at(i+1) - ('0')->char2byte()) * 10 + (s->at(i + 1+1) - ('0')->char2byte()) ;
     if (h mod 4 = 0) then     count := count + i + 1 ; else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "124" ;
     OclFile["System.out"].println(countDivisbleby4(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findIndex(int n){
    if(n<=1)return n ;
    int a=0,b=1,c=1 ;
    int res=1 ;
    while(c<n){
      c=a+b ;
      res++;
      a=b ;
      b=c ;
    }
    return res ;
  }
  public static void main(String[] args){
    int result=findIndex(21);
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findIndex( n : int) : int
  pre: true
  post: true
  activity: (     if (n <= 1) then     return n else skip ; 
     var a : int ; a := 0 ;
    var b : int ; b := 1 ;
    var c : int ; c := 1 ;
    var res : int ; res := 1 ;
    while (c < n) do (     c := a + b ; 
     res := res + 1 ; 
     a := b ; 
     b := c ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var result : int ; result := findIndex(21) ;
     OclFile["System.out"].println(result) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Skeleton {
  public Skeleton(){
  }
  static class FastReader {
    public BufferedReader br ;
    public StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
      st=null ;
    }
    public String next(){
      while(st==null || ! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
    String nextLine(){
      String str="" ;
      try {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader fr=new FastReader();
    int t=fr.nextInt();
    while(t-->0){
      int n=fr.nextInt();
      String s=fr.next();
      String res="" ;
      int i=n-1 ;
      while(i>=0){
        if(s.charAt(i)!='0'){
          char c=(char)('a'+Integer.parseInt(""+s.charAt(i))-1);
          res=c+res ;
          i--;
        }
        else {
          char c=(char)('a'+Integer.parseInt(s.substring(i-2,i))-1);
          res=c+res ;
          i-=3 ;
        }
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Skeleton {
   static operation newSkeleton() : Skeleton
  pre: true
  post: true
  activity:
  ( var self : Skeleton ;
    self := createSkeleton();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fr : FastReader ; fr := FastReader.newFastReader() ;
     var t : int ; t := fr.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := fr.nextInt() ;
     var s : String ; s := fr.next() ;
    var res : String ; res := "" ;
    var i : int ; i := n - 1 ;
    while (i >= 0) do (     if (s->at(i+1) /= '0') then (     var c : String ; c := ('a' + ("" + s->at(i+1))->toInteger() - 1)->oclAsType(String) ;
     res := c + res ; 
     i := i - 1 ) else (     var c : String ; c := ('a' + (s.subrange((i)->char2byte() - 2+1,i))->toInteger() - 1)->oclAsType(String) ;
     res := c + res ; 
     i := i-(3) ) ) ; 
    OclFile["System.out"].println(res) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test290 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      char[] a=in.next().toCharArray();
      String s="" ;
      for(int i=n-1 ; i>=0 ; i--){
        if(a[i]=='0'){
          s=(char)(a[i-1]+48+(a[i-2]-48)*10)+s ;
          i-=2 ;
        }
        else {
          s=(char)(a[i]+48)+s ;
        }
      }
      System.out.println(s);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test290 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(String) ; a := in.getCurrent()->characters() ;
    var s : String ; s := "" ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (a[i+1] = '0') then (     s := (a[(i)->char2byte() - 1+1] + 48 + (a[(i)->char2byte() - 2+1] - 48) * 10)->oclAsType(String) + s ; 
     i := i-(2) ) else (     s := (a[i+1] + 48)->oclAsType(String) + s ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(s) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a=sc.nextLong();
    long b=sc.nextLong();
    int n=sc.nextInt();
    long min=Long.MAX_VALUE ;
    for(int i=1 ; i<=n ; i++){
      if(b % i!=0){
        continue ;
      }
      long x=b/i ;
      long y=a/x ;
      if(y>n || y==0){
        min=Math.min(min,Math.abs(n*x-a));
      }
      else {
        min=Math.min(min,Math.abs(y*x-a));
      }
      if(y+1>n){
        min=Math.min(min,Math.abs(n*x-a));
      }
      else {
        min=Math.min(min,Math.abs((y+1)*x-a));
      }
      if(y-1==0 || y-1>n){
        min=Math.min(min,Math.abs(n*x-a));
      }
      else {
        min=Math.min(min,Math.abs((y-1)*x-a));
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var min : long ; min := "9223372036854775807"->toLong() ;
        var i : int ; i := 1 ; while i <= n do ( (     if (b mod i /= 0) then (     continue ) else skip ; 
     var x : long ; x := b / i ;
    var y : long ; y := a / x ;
    if (y > n or y = 0) then (     min := Set{min, if n * x - a < 0 then -(n * x - a) else n * x - a endif}->min() ) else (     min := Set{min, if y * x - a < 0 then -(y * x - a) else y * x - a endif}->min() ) ;  
    if (y + 1 > n) then (     min := Set{min, if n * x - a < 0 then -(n * x - a) else n * x - a endif}->min() ) else (     min := Set{min, if (y + 1) * x - a < 0 then -((y + 1) * x - a) else (y + 1) * x - a endif}->min() ) ;  
    if (y - 1 = 0 or y - 1 > n) then (     min := Set{min, if n * x - a < 0 then -(n * x - a) else n * x - a endif}->min() ) else (     min := Set{min, if (y - 1) * x - a < 0 then -((y - 1) * x - a) else (y - 1) * x - a endif}->min() ) ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public static void main(String[] args){
    var sc=new java.util.Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    sc.close();
    int p=998244353 ;
    var f=new long[k];
    f[0]=1 ;
    for(int i=1 ; i<k ; i++)f[i]=(f[i-1]*i)% p ;
    var fi=new long[k];
    fi[k-1]=inv(f[k-1],p);
    for(int i=k-1 ; i>0 ; i--)fi[i-1]=(fi[i]*i)% p ;
    long ans=1 ;
    for(int i=1 ; i<k ; i++)if((ans<<=1)>=p)ans-=p ;
    for(int i=0 ; i<Math.min(n-1,k); i++){
      ans-=(((f[k-1]*fi[i])% p)*fi[k-1-i])% p ;
    }
    System.out.println((ans %=p)<0 ? ans+p : ans);
  }
  public static long inv(long a,long p){
    long b=p ;
    long u=1,v=0 ;
    while(b>=1){
      long t=a/b ;
      a-=t*b ;
      long tmp ;
      tmp=a ;
      a=b ;
      b=tmp ;
      u-=t*v ;
      tmp=u ;
      u=v ;
      v=tmp ;
    }
    u %=p ;
    return u<0 ? u+p : u ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : var ; sc := Scanner.newScanner(OclFile["System.in"]) ;
     var n : int ; n := sc.nextInt() ;
    var k : int ; k := sc.nextInt() ;
    sc.close() ; 
    var p : int ; p := 998244353 ;
    var f : var ; f := Integer.subrange(1,k)->collect(0) ;
    f[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < k do (     f[i+1] := (f[i - 1+1] * i) mod p ;  ;     i := i + 1 ) ; 
    var fi : var ; fi := Integer.subrange(1,k)->collect(0) ;
    fi[k - 1+1] := inv(f[k - 1+1], p) ; 
        var i : int ; i := k - 1 ; while i > 0 do (     fi[i - 1+1] := (fi[i+1] * i) mod p ;  ;     i := i - 1 ) ; 
    var ans : long ; ans := 1 ;
        var i : int ; i := 1 ; while i < k do (     if ((ans) >= p) then     ans := ans-(p) ; else skip ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Set{n - 1, k}->min() do ( (     ans := ans-((((f[k - 1+1] * fi[i+1]) mod p) * fi[k - 1 - i+1]) mod p) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if (ans) < 0 then ans + p else ans endif) ; 
 );
  static   operation inv( a : long, p : long) : long
  pre: true
  post: true
  activity: (     var b : long ; b := p ;
     var u : long ; u := 1 ;
    var v : long ; v := 0 ;
    while (b >= 1) do (     var t : long ; t := a / b ;
     a := a-(t * b) ; 
    var tmp : long ;
    tmp := a ; 
    a := b ; 
    b := tmp ; 
    u := u-(t * v) ; 
    tmp := u ; 
    u := v ; 
    v := tmp ; 
 ) ; 
    u := u mod p ; 
    return if u < 0 then u + p else u endif 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new FileReader("input.txt"));
    BufferedWriter out=new BufferedWriter(new FileWriter("output.txt"));
    int n=Integer.parseInt(in.readLine());
    String[] data=in.readLine().split(" ");
    int[] c=new int[n];
    for(int i=0 ; i<n ; i++){
      c[i]=Integer.parseInt(data[i]);
    }
    Arrays.sort(c);
    int sol=n-1 ;
    for(int i=0 ; i<n ; i++){
      int q=c[i]*2 ;
      int inicio=i ;
      int fin=c.length-1 ;
      while(inicio<fin){
        int mid=(inicio+fin+1)/2 ;
        if(c[mid]>q){
          fin=mid-1 ;
        }
        else {
          inicio=mid ;
        }
      }
      int posSol=i+n-inicio-1 ;
      if(posSol<sol){
        sol=posSol ;
      }
    }
    out.write(sol+"\n");
    in.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt"))) ;
    var n : int ; n := (in.readLine())->toInteger() ;
    var data : Sequence(String) ; data := in.readLine()->split(" ") ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := (data[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    c := c->sort() ; 
    var sol : int ; sol := n - 1 ;
        var i : int ; i := 0 ; while i < n do ( (     var q : int ; q := c[i+1] * 2 ;
     var inicio : int ; inicio := i ;
    var fin : int ; fin := c->size() - 1 ;
    while (inicio < fin) do (     var mid : int ; mid := (inicio + fin + 1) / 2 ;
     if (c[mid+1] > q) then (     fin := mid - 1 ) else (     inicio := mid ) ) ; 
    var posSol : int ; posSol := i + n - inicio - 1 ;
    if (posSol < sol) then (     sol := posSol ) else skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new FileReader("input.txt"));
    BufferedWriter out=new BufferedWriter(new FileWriter("output.txt"));
    int n=Integer.parseInt(in.readLine());
    int[] c=new int[n];
    String[] data=in.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      c[i]=Integer.parseInt(data[i]);
    }
    Arrays.sort(c);
    int best=n ;
    for(int i=0 ; i<n ; i++){
      int ini=i ;
      int fin=n-1 ;
      int q=c[i]*2 ;
      while(ini<=fin){
        int mid=(ini+fin+1)/2 ;
        if(c[mid]>q){
          fin=mid-1 ;
        }
        else if(ini!=fin){
          ini=mid ;
        }
        else {
          break ;
        }
      }
      if(ini==fin && n-(ini-i+1)<best){
        best=n-(ini-i+1);
      }
    }
    out.write(best+"\n");
    out.close();
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt"))) ;
    var n : int ; n := (in.readLine())->toInteger() ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    var data : Sequence(String) ; data := in.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := (data[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    c := c->sort() ; 
    var best : int ; best := n ;
        var i : int ; i := 0 ; while i < n do ( (     var ini : int ; ini := i ;
     var fin : int ; fin := n - 1 ;
    var q : int ; q := c[i+1] * 2 ;
    while (ini <= fin) do (     var mid : int ; mid := (ini + fin + 1) / 2 ;
     if (c[mid+1] > q) then (     fin := mid - 1 ) else     if (ini /= fin) then (     ini := mid ) else (     break ) ;  ) ; 
    if (ini = fin & n - (ini - i + 1) < best) then (     best := n - (ini - i + 1) ) else skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void deleteElements(int arr[],int n,int k){
    Stack<Integer>s=new Stack<>();
    s.push(arr[0]);
    int count=0 ;
    for(int i=1 ; i<n ; i++){
      while(! s.empty()&& s.peek()<arr[i] && count<k){
        s.pop();
        count++;
      }
      s.push(arr[i]);
    }
    int m=s.size();
    Integer[] v=new Integer[m];
    while(! s.empty()){
      v[--m]=s.peek();
      s.pop();
    }
    for(Integer x : v){
      System.out.print(x+" ");
    };
    System.out.println("");
  }
  public static void main(String[] args){
    int n=5,k=2 ;
    int arr[]={
      20,10,25,30,40 };
      deleteElements(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation deleteElements( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var s : Sequence(int) ; s := Sequence{} ;
     s := s->append(arr[0+1]) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     while (not(s->isEmpty()) & s->min() < arr[i+1] & count < k) do (     s := s->front() ; 
     count := count + 1 ) ; 
     s := s->append(arr[i+1]) )  ;     i := i + 1 ) ; 
    var m : int ; m := s->size() ;
    var v : Sequence(int) ; v := Integer.subrange(1,m)->collect(null) ;
    while (not(s->isEmpty())) do (         m := m - 1 ;
 v[m+1] := s->min()  ; 
     s := s->front() ) ; 
    for (x : v) do ( (     OclFile["System.out"].print(x + " ") )  ) ; 
    OclFile["System.out"].println("") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var k : int ; k := 2 ;
     var arr : Sequence(int) ; arr := Sequence{20,10,25,30,40} ;
     execute deleteElements(arr, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int mod=1000000007 ;
  static long power(long a,long n){
    if(n==0){
      return 1 ;
    }
    long p=power(a,n/2)% mod ;
    p=(p*p)% mod ;
    if(n==1){
      p=(p*a)% mod ;
    }
    return p ;
  }
  static long computeSum(int[] arr,int n){
    Arrays.sort(arr);
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      long maxs=(power(2,i)-1+mod)% mod ;
      maxs=(maxs*arr[i])% mod ;
      long mins=(power(2,n-1-i)-1+mod)% mod ;
      mins=(mins*arr[i])% mod ;
      long V=(maxs-mins+mod)% mod ;
      sum=(sum+V)% mod ;
    }
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      4,3,1 };
      int n=arr.length ;
      System.out.println(computeSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute mod : int := 1000000007;
  static   operation power( a : long, n : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then (     return 1 ) else skip ; 
     var p : long ; p := power(a, n / 2) mod mod ;
    p := (p * p) mod mod ; 
    if (n = 1) then (     p := (p * a) mod mod ) else skip ; 
    return p 
 );
  static   operation computeSum( arr : Sequence(int), n : int) : long
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var sum : long ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var maxs : long ; maxs := (power(2, i) - 1 + mod) mod mod ;
     maxs := (maxs * arr[i+1]) mod mod ; 
    var mins : long ; mins := (power(2, n - 1 - i) - 1 + mod) mod mod ;
    mins := (mins * arr[i+1]) mod mod ; 
    var V : long ; V := (maxs - mins + mod) mod mod ;
    sum := (sum + V) mod mod ; 
 )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,3,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(computeSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  final static int MAX5=100 ;
  static int maximumZeros(int arr[],int n,int k){
    int subset[][]=new int[k+1][MAX5+5];
    for(int[] row : subset){
      Arrays.fill(row,-1);
    }
    subset[0][0]=0 ;
    for(int p=0 ; p<n ; p++){
      int pw2=0,pw5=0 ;
      while(arr[p] % 2==0){
        pw2++;
        arr[p]/=2 ;
      }
      while(arr[p] % 5==0){
        pw5++;
        arr[p]/=5 ;
      }
      for(int i=k-1 ; i>=0 ; i--){
        for(int j=0 ; j<MAX5 ; j++){
          if(subset[i][j]!=-1){
            subset[i+1][j+pw5]=Math.max(subset[i+1][j+pw5],subset[i][j]+pw2);
          }
        }
      }
    }
    int ans=0 ;
    for(int i=0 ; i<MAX5 ; i++){
      ans=Math.max(ans,Math.min(i,subset[k][i]));
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      50,4,20 };
      int k=2 ;
      int n=arr.length ;
      System.out.println(maximumZeros(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX5 : int := 100;
  static   operation maximumZeros( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var subset : Sequence(Sequence(int)) ; subset := Integer.subrange(1,k + 1)->collect(Integer.subrange(1,MAX5 + 5)->collect(0)) ;
     for (row : subset) do ( (     row := row->collect(-1) )  ) ; 
    subset[0+1][0+1] := 0 ; 
        var p : int ; p := 0 ; while p < n do ( (     var pw2 : int ; pw2 := 0 ;
    var pw5 : int ; pw5 := 0 ;
     while (arr[p+1] mod 2 = 0) do (     pw2 := pw2 + 1 ; 
     arr[p+1] := arr[p+1]/(2) ) ; 
     while (arr[p+1] mod 5 = 0) do (     pw5 := pw5 + 1 ; 
     arr[p+1] := arr[p+1]/(5) ) ; 
         var i : int ; i := k - 1 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < MAX5 do ( (     if (subset[i+1][j+1] /= -1) then (     subset[i + 1+1][j + pw5+1] := Set{subset[i + 1+1][j + pw5+1], subset[i+1][j+1] + pw2}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) )  ;     p := p + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < MAX5 do ( (     ans := Set{ans, Set{i, subset[k+1][i+1]}->min()}->max() )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{50,4,20} ;
     var k : int ; k := 2 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maximumZeros(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    sc.close();
    int ans=0 ;
    for(int i=a ; i<=b ; i++){
      int tmp=i ;
      int[] num=new int[5];
      int lCnt=0 ;
      while(true){
        if(tmp>0){
          num[lCnt]=tmp % 10 ;
          tmp/=10 ;
        }
        else {
          break ;
        }
        lCnt++;
      }
      if(num[0]==num[4] && num[1]==num[3]){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    skip ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := a ; while i <= b do ( (     var tmp : int ; tmp := i ;
     var num : Sequence(int) ; num := Integer.subrange(1,5)->collect(0) ;
    var lCnt : int ; lCnt := 0 ;
    while (true) do (     if (tmp > 0) then (     num[lCnt+1] := tmp mod 10 ; 
     tmp := tmp/(10) ) else (     break ) ;  
     lCnt := lCnt + 1 ) ; 
    if (num[0+1] = num[4+1] & num[1+1] = num[3+1]) then (     ans := ans + 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isVowel(char ch){
    switch(ch){
      case 'a' : case 'e' : case 'i' : case 'o' : case 'u' : return true ;
    }
    return false ;
  }
  static boolean isSatisfied(char[] str,int n){
    for(int i=1 ; i<n ; i++){
      if(! isVowel(str[i])&& ! isVowel(str[i-1])){
        return false ;
      }
    }
    for(int i=1 ; i<n-1 ; i++){
      if(isVowel(str[i])&& ! isVowel(str[i-1])&& ! isVowel(str[i+1])){
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    String str="acaba" ;
    int n=str.length();
    if(isSatisfied(str.toCharArray(),n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isVowel( ch : String) : boolean
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (ch) ; 
    if _switchval = 'a' or _switchval = 'e' or _switchval = 'i' or _switchval = 'o' or _switchval = 'u' then
    return true 
   else skip ;
      )
     return false );
  static   operation isSatisfied( str : Sequence(String), n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < n do ( (     if (not(isVowel(str[i+1])) & not(isVowel(str[i - 1+1]))) then (     return false ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i < n - 1 do ( (     if (isVowel(str[i+1]) & not(isVowel(str[i - 1+1])) & not(isVowel(str[i + 1+1]))) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "acaba" ;
     var n : int ; n := str->size() ;
     if (isSatisfied(str->characters(), n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class test178 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      HashMap<Character,Integer>a=new HashMap<Character,Integer>();
      char b[]=in.next().toCharArray();
      for(int i=0 ; i<b.length ; i++){
        a.put(b[i],i+1);
      }
      char c[]=in.next().toCharArray();
      int sum=0 ;
      char s=c[0];
      for(int i=1 ; i<c.length ; i++){
        sum+=(Math.abs(a.get(s)-a.get(c[i])));
        s=c[i];
      }
      System.out.println(sum);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test178 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var a : Map(String,int) ; a := Map{} ;
     var b : Sequence(String) ; b := in.getCurrent()->characters() ;
        var i : int ; i := 0 ; while i < b->size() do ( (     a := a->union(Map{b[i+1] |-> i + 1}) )  ;     i := i + 1 ) ; 
    var c : Sequence(String) ; c := in.getCurrent()->characters() ;
    var sum : int ; sum := 0 ;
    var s : String ; s := c[0+1] ;
        var i : int ; i := 1 ; while i < c->size() do ( (     sum := sum+((if a->at(s) - a->at(c[i+1]) < 0 then -(a->at(s) - a->at(c[i+1])) else a->at(s) - a->at(c[i+1]) endif)) ; 
     s := c[i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.out ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int count=0 ;
    for(int i=a ; i<=b ; i++){
      if(isKaibunNum(i)){
        count+=1 ;
      }
    }
    out.print(count);
  }
  private static boolean isKaibunNum(int n){
    CharSequence sb=new StringBuilder(String.valueOf(n));
    int l=sb.length();
    if(l==1){
      return true ;
    }
    int checkCount=l/2 ;
    for(int i=0 ; i<checkCount ; i++){
      char left=sb.charAt(i);
      char right=sb.charAt(l-1-i);
      if(left!=right){
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := a ; while i <= b do ( (     if (isKaibunNum(i)) then (     count := count+(1) ) else skip )  ;     i := i + 1 ) ; 
    out.print(count) ; 
 );
  static   operation isKaibunNum( n : int) : boolean
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString(((n) + "")) ;
     var l : int ; l := sb->size() ;
    if (l = 1) then (     return true ) else skip ; 
    var checkCount : int ; checkCount := l / 2 ;
        var i : int ; i := 0 ; while i < checkCount do ( (     var left : String ; left := sb->at(i+1) ;
     var right : String ; right := sb->at((l)->char2byte() - 1 - i+1) ;
     if (left /= right) then (     return false ) else skip )  ;     i := i + 1 ) ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ABC090B solver=new ABC090B();
    solver.solve(1,in,out);
    out.close();
  }
  static class ABC090B {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int A=in.nextInt();
      int B=in.nextInt();
      int ans=0 ;
      for(int i=A ; i<=B ; i++){
        String s=""+i ;
        if(s.charAt(0)==s.charAt(4)&& s.charAt(1)==s.charAt(3)){
          ans++;
        }
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ABC090B ; solver := ABC090B.newABC090B() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ABC090B {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var A : int ; A := in.getCurrent()->toInteger() ;
     var B : int ; B := in.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := A ; while i <= B do ( (     var s : String ; s := "" + i ;
     if (s->at(0+1) = s->at(4+1) & s->at(1+1) = s->at(3+1)) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in),1);
    String s=r.readLine();
    String[] sl=s.split("[\\s]+");
    int a=Integer.parseInt(sl[0]);
    int b=Integer.parseInt(sl[1]);
    int z=0 ;
    for(Integer i=a ; i<=b ; i++){
      String ss=i.toString();
      if(ss.charAt(0)==ss.charAt(4)&& ss.charAt(1)==ss.charAt(3)){
        z++;
      }
    }
    System.out.println(z);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 1) ;
     var s : String ; s := r.readLine() ;
    var sl : Sequence(String) ; sl := s->split("[\\s]+") ;
    var a : int ; a := (sl[0+1])->toInteger() ;
    var b : int ; b := (sl[1+1])->toInteger() ;
    var z : int ; z := 0 ;
        var i : int ; i := a ; while i <= b do ( (     var ss : String ; ss := i+"" ;
     if (ss->at(0+1) = ss->at(4+1) & ss->at(1+1) = ss->at(3+1)) then (     z := z + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(z) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String...args){
    Scanner scanner=new Scanner(System.in);
    int A=scanner.nextInt();
    int B=scanner.nextInt();
    int cnt=0 ;
    for(int i=0 ; i<10 ; i++){
      for(int j=0 ; j<10 ; j++){
        for(int k=1 ; k<10 ; k++){
          int i1=Integer.parseInt(""+k+j+i+j+k);
          if(A<=i1 && i1<=B)cnt++;
        }
      }
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := scanner.getCurrent()->toInteger() ;
    var B : int ; B := scanner.getCurrent()->toInteger() ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < 10 do ( (         var k : int ; k := 1 ; while k < 10 do ( (     var i1 : int ; i1 := ("" + k + j + i + j + k)->toInteger() ;
     if (A <= i1 & i1 <= B) then     cnt := cnt + 1 ; else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static long[] pwr ;
  static Boolean isMunchhausen(int n){
    long sum=0l ;
    int temp=n ;
    while(temp>0){
      int index=temp % 10 ;
      sum=sum+pwr[index];
      temp/=10 ;
    }
    return(sum==n);
  }
  static void printMunchhausenNumbers(int n){
    pwr=new long[10];
    for(int i=0 ; i<10 ; i++)pwr[i]=(long)Math.pow((float)i,(float)i);
    for(int i=1 ; i<=n ; i++)if(isMunchhausen(i)==true)System.out.println(i);
  }
  public static void main(String[] args){
    int n=10000 ;
    printMunchhausenNumbers(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute pwr : Sequence(long);
  static   operation isMunchhausen( n : int) : Boolean
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0l ;
     var temp : int ; temp := n ;
     while (temp > 0) do (     var index : int ; index := temp mod 10 ;
     sum := sum + pwr[index+1] ; 
     temp := temp/(10) ) ; 
     return (sum = n) );
  static   operation printMunchhausenNumbers( n : int) : void
  pre: true
  post: true
  activity: (     pwr := Integer.subrange(1,10)->collect(0) ; 
         var i : int ; i := 0 ; while i < 10 do (     pwr[i+1] := i->oclAsType(double)->pow(i->oclAsType(double))->oclAsType(long) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i <= n do (     if (isMunchhausen(i) = true) then     OclFile["System.out"].println(i) ; else skip ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10000 ;
     execute printMunchhausenNumbers(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t--!=0){
      int n=in.nextInt(),ans=1001 ;
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=in.nextInt();
      Arrays.sort(arr);
      for(int i=0 ; i<n ; i++){
        for(int j=i+1 ; j<n ; j++){
          ans=Math.min(ans,arr[j]-arr[i]);
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
    var ans : int ; ans := 1001 ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     ans := Set{ans, arr[j+1] - arr[i+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class test124 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int x=in.nextInt();
    for(int i=0 ; i<x ; i++){
      int n=in.nextInt();
      int a[]=new int[n];
      for(int j=0 ; j<n ; j++){
        a[j]=in.nextInt();
      }
      Arrays.sort(a);
      int min=a[1]-a[0];
      for(int j=1 ; j<n ; j++){
        if(a[j]-a[j-1]<min){
          min=a[j]-a[j-1];
        }
      }
      System.out.println(min);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test124 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < x do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     a[j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    a := a->sort() ; 
    var min : int ; min := a[1+1] - a[0+1] ;
        var j : int ; j := 1 ; while j < n do ( (     if (a[j+1] - a[j - 1+1] < min) then (     min := a[j+1] - a[j - 1+1] ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Codeforcess {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt(),i ;
    while(t-->0){
      int n=in.nextInt();
      int a[]=new int[n];
      for(i=0 ; i<n ; i++)a[i]=in.nextInt();
      Arrays.sort(a);
      la : {
        for(i=0 ; i<a[n-1]; i++)for(int j=n-1 ; j>0 ; j--){
          if(a[j]-a[j-1]==i)break la ;
        }
      }
      System.out.println(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforcess {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var i : int ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
(         i := 0 ; while i < a[n - 1+1] do (         var j : int ; j := n - 1 ; while j > 0 do ( (     if (a[j+1] - a[j - 1+1] = i) then     break else skip )  ;     j := j - 1 ) ;  ;     i := i + 1 ) ) 
    OclFile["System.out"].println(i) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int n ;
    int ints[];
    int raz=999 ;
    for(int i=0 ; i<t ; i++){
      n=sc.nextInt();
      ints=new int[n];
      raz=999 ;
      for(int s=0 ; s<n ; s++){
        ints[s]=sc.nextInt();
      }
      Arrays.sort(ints);
      for(int s=1 ; s<n ; s++){
        if(ints[s]-ints[s-1]<raz){
          raz=ints[s]-ints[s-1];
        }
        if(raz==0){
          System.out.println(0);
          break ;
        }
      }
      if(raz>0){
        System.out.println(raz);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var n : int ;
    var ints : Sequence(int) ;
    var raz : int ; raz := 999 ;
        var i : int ; i := 0 ; while i < t do ( (     n := sc.getCurrent()->toInteger() ; 
     ints := Integer.subrange(1,n)->collect(0) ; 
    raz := 999 ; 
        var s : int ; s := 0 ; while s < n do ( (     ints[s+1] := sc.getCurrent()->toInteger() )  ;     s := s + 1 ) ; 
    ints := ints->sort() ; 
        var s : int ; s := 1 ; while s < n do ( (     if (ints[s+1] - ints[s - 1+1] < raz) then (     raz := ints[s+1] - ints[s - 1+1] ) else skip ; 
     if (raz = 0) then (     OclFile["System.out"].println(0) ; 
     break ) else skip )  ;     s := s + 1 ) ; 
    if (raz > 0) then (     OclFile["System.out"].println(raz) ) else skip ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countWays(int n){
    int[] dp=new int[n+1];
    dp[0]=0 ;
    dp[1]=1 ;
    dp[2]=1 ;
    for(int i=3 ; i<=n ; i++){
      dp[i]=dp[i-1]+dp[i-3]+1 ;
    }
    return dp[n];
  }
  public static void main(String args[]){
    int n=6 ;
    System.out.println(countWays(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countWays( n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
     dp[0+1] := 0 ; 
    dp[1+1] := 1 ; 
    dp[2+1] := 1 ; 
        var i : int ; i := 3 ; while i <= n do ( (     dp[i+1] := dp[i - 1+1] + dp[i - 3+1] + 1 )  ;     i := i + 1 ) ; 
    return dp[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(countWays(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        int j=sc.nextInt();
        arr[i]=j ;
      }
      Arrays.sort(arr);
      ArrayList<Integer>stack=new ArrayList();
      for(int i=1 ; i<n ; i++){
        int j=arr[i]-arr[i-1];
        stack.add(j);
      }
      Collections.sort(stack);
      System.out.println(stack.get(0));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var j : int ; j := sc.getCurrent()->toInteger() ;
     arr[i+1] := j )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var stack : Sequence(int) ; stack := Sequence{} ;
        var i : int ; i := 1 ; while i < n do ( (     var j : int ; j := arr[i+1] - arr[i - 1+1] ;
     stack := stack->including(j) )  ;     i := i + 1 ) ; 
    stack := stack->sort() ; 
    OclFile["System.out"].println(stack->at(0+1)) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      String keyboard=sc.next();
      String word=sc.next();
      int distance=0 ;
      int ptr=keyboard.indexOf(word.charAt(0));
      for(int j=1 ; j<word.length(); j++){
        distance+=Math.abs(ptr-keyboard.indexOf(word.charAt(j)));
        ptr=keyboard.indexOf(word.charAt(j));
      }
      System.out.println(distance);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var keyboard : String ; keyboard := sc.getCurrent() ;
     var word : String ; word := sc.getCurrent() ;
    var distance : int ; distance := 0 ;
    var ptr : int ; ptr := keyboard->indexOf(word->at(0+1))-1 ;
        var j : int ; j := 1 ; while j < word->size() do ( (     distance := distance+(if ptr - keyboard->indexOf(word->at(j+1))-1 < 0 then -(ptr - keyboard->indexOf(word->at(j+1))-1) else ptr - keyboard->indexOf(word->at(j+1))-1 endif) ; 
     ptr := keyboard->indexOf(word->at(j+1))-1 )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(distance) ; 
 )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class fibonacci {
  static int fib(int n){
    if(n<=1)return n ;
    return fib(n-1)+fib(n-2);
  }
  public static void main(String args[]){
    int n=9 ;
    System.out.println(fib(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class fibonacci {
  static   operation fib( n : int) : int
  pre: true
  post: true
  activity: (     if (n <= 1) then     return n else skip ; 
     return fib(n - 1) + fib(n - 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     OclFile["System.out"].println(fib(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int power=0 ;
      while((int)Math.pow(2,power)<n){
        power++;
      }
      if((int)Math.pow(2,power)==n)System.out.println((int)Math.pow(2,power)-1);
      else {
        power--;
        System.out.println((int)Math.pow(2,power)-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var power : int ; power := 0 ;
     while (2->pow(power)->oclAsType(int) < n) do (     power := power + 1 ) ; 
     if (2->pow(power)->oclAsType(int) = n) then     OclFile["System.out"].println(2->pow(power)->oclAsType(int) - 1) ; else (     power := power - 1 ; 
     OclFile["System.out"].println(2->pow(power)->oclAsType(int) - 1) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test197 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int x=1 ;
      while(n/x!=1){
        x*=2 ;
      }
      System.out.println((x-1));
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test197 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var x : int ; x := 1 ;
     while (n / x /= 1) do (     x := x*(2) ) ; 
     OclFile["System.out"].println((x - 1)) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class andtherek {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      int count=0 ;
      while(n!=0){
        count++;
        n>>=1 ;
      }
      System.out.println((1<<(count-1))-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class andtherek {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var count : int ; count := 0 ;
     while (n /= 0) do (     count := count + 1 ; 
     n := n/(2->pow(1)) ) ; 
     OclFile["System.out"].println(((1*(2->pow((count - 1))))->oclAsType(long)) - 1) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int n ;
    int result=-1 ;
    for(int i=0 ; i<t ; i++){
      n=sc.nextInt();
      while(n>0){
        result++;
        n/=2 ;
      }
      int finalResult=(int)(Math.pow(2,result)-1);
      System.out.println(finalResult);
      result=-1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var n : int ;
    var result : int ; result := -1 ;
        var i : int ; i := 0 ; while i < t do ( (     n := sc.getCurrent()->toInteger() ; 
     while (n > 0) do (     result := result + 1 ; 
     n := n/(2) ) ; 
    var finalResult : int ; finalResult := (2->pow(result) - 1)->oclAsType(int) ;
    OclFile["System.out"].println(finalResult) ; 
    result := -1 ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  static char getWinner(int[] arr,int n){
    int gcd=arr[0];
    int maxEle=arr[0];
    for(int i=1 ; i<n ; i++){
      gcd=__gcd(gcd,arr[i]);
      maxEle=Math.max(maxEle,arr[i]);
    }
    int totalMoves=(maxEle/gcd)-n ;
    if(totalMoves % 2==1)return 'A' ;
    return 'B' ;
  }
  public static void main(String args[]){
    int[] arr={
      5,6,7 };
      int n=arr.length ;
      System.out.print(getWinner(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation getWinner( arr : Sequence(int), n : int) : String
  pre: true
  post: true
  activity: (     var gcd : int ; gcd := arr[0+1] ;
     var maxEle : int ; maxEle := arr[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     gcd := __gcd(gcd, arr[i+1]) ; 
     maxEle := Set{maxEle, arr[i+1]}->max() )  ;     i := i + 1 ) ; 
    var totalMoves : int ; totalMoves := (maxEle / gcd) - n ;
    if (totalMoves mod 2 = 1) then     return 'A' else skip ; 
    return 'B' 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,6,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(getWinner(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.HashSet ;
import java.util.Set ;
public final class p203 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p203().run());
  }
  public String run(){
    Set<Long>numbers=new HashSet<>();
    long max=0 ;
    for(int n=0 ; n<=50 ; n++){
      for(int k=0 ; k<=n ; k++){
        BigInteger x=Library.binomial(n,k);
        if(x.bitLength()>=64)throw new AssertionError("Number too large to handle");
        numbers.add(x.longValue());
        max=Math.max(x.longValue(),max);
      }
    }
    int[] primes=Library.listPrimes((int)Library.sqrt(max));
    primesSquared=new long[primes.length];
    for(int i=0 ; i<primes.length ; i++)primesSquared[i]=(long)primes[i]*primes[i];
    long sum=0 ;
    for(long n : numbers){
      if(isSquarefree(n))sum+=n ;
    }
    return Long.toString(sum);
  }
  private long[] primesSquared ;
  private boolean isSquarefree(long n){
    for(long p2 : primesSquared){
      if(p2>n)break ;
      if(n % p2==0)return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class p203 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p203.newp203().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var numbers : Set(long) ; numbers := Set{} ;
     var max : long ; max := 0 ;
        var n : int ; n := 0 ; while n <= 50 do ( (         var k : int ; k := 0 ; while k <= n do ( (     var x : long ; x := Library.binomial(n, k) ;
     if (x.bitLength() >= 64) then     error AssertionException("Number too large to handle") ; else skip ; 
     numbers := numbers->including(x->oclAsType(long)) ; 
     max := Set{x->oclAsType(long), max}->max() )  ;     k := k + 1 ) )  ;     n := n + 1 ) ; 
    var primes : Sequence(int) ; primes := Library.listPrimes(Library.sqrt(max)->oclAsType(int)) ;
    primesSquared := Integer.subrange(1,primes->size())->collect(0) ; 
        var i : int ; i := 0 ; while i < primes->size() do (     primesSquared[i+1] := primes[i+1]->oclAsType(long) * primes[i+1] ;  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    for (n : numbers) do ( (     if (isSquarefree(n)) then     sum := sum+(n) ; else skip )  ) ; 
    return ((sum) + "") 
 );
   attribute primesSquared : Sequence(long);
   operation isSquarefree( n : long) : boolean
  pre: true
  post: true
  activity: (     for (p2 : primesSquared) do ( (     if (p2 > n) then     break else skip ; 
     if (n mod p2 = 0) then     return false else skip )  ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int sumDigits(int no){
    return no==0 ? 0 : no % 10+sumDigits(no/10);
  }
  public static void main(String[] args){
    System.out.println(sumDigits(687));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumDigits( no : int) : int
  pre: true
  post: true
  activity: (     return if no = 0 then 0 else no mod 10 + sumDigits(no / 10) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(sumDigits(687)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int q=Integer.parseInt(str[0]);
    SortedMap<String,Integer>mpa=new TreeMap<String,Integer>();
    for(int i=0 ; i<q ; i++){
      str=br.readLine().split(" ");
      int op=Integer.parseInt(str[0]);
      if(op==0){
        String key=str[1];
        int x=Integer.parseInt(str[2]);
        mpa.put(key,x);
      }
      else if(op==1){
        String key=str[1];
        if(mpa.containsKey(key))System.out.println(mpa.get(key));
        else System.out.println(0);
      }
      else {
        String key=str[1];
        if(mpa.containsKey(key))mpa.remove(key);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var q : int ; q := (str[0+1])->toInteger() ;
    var mpa : Map(String,int) ; mpa := Map{} ;
        var i : int ; i := 0 ; while i < q do ( (     str := br.readLine()->split(" ") ; 
     var op : int ; op := (str[0+1])->toInteger() ;
     if (op = 0) then (     var key : String ; key := str[1+1] ;
     var x : int ; x := (str[2+1])->toInteger() ;
     mpa := mpa->union(Map{key |-> x}) ) else     if (op = 1) then (     var key : String ; key := str[1+1] ;
     if (mpa->keys()->includes(key)) then     OclFile["System.out"].println(mpa->at(key)) ; else     OclFile["System.out"].println(0) ; ) else (     var key : String ; key := str[1+1] ;
     if (mpa->keys()->includes(key)) then     mpa := mpa->antirestrict(Set{key}) ; else skip ) ;  )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int[] anagramMappings(int[] A,int[] B){
    int[] ans=new int[A.length];
    HashMap<Integer,Integer>valIndex=new HashMap<>();
    for(int i=0 ; i<B.length ; i++)valIndex.put(B[i],i);
    for(int i=0 ; i<A.length ; i++)ans[i]=valIndex.get(A[i]);
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation anagramMappings( A : Sequence(int), B : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Integer.subrange(1,A->size())->collect(0) ;
     var valIndex : Map(int,int) ; valIndex := Map{} ;
        var i : int ; i := 0 ; while i < B->size() do (     valIndex := valIndex->union(Map{B[i+1] |-> i}) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < A->size() do (     ans[i+1] := valIndex->at(A[i+1]) ;  ;     i := i + 1 ) ; 
    return ans 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean check(String s){
    int n=s.length();
    for(int i=2 ; i<n ; i++){
      if(s.charAt(i)=='1' && s.charAt(i-1)=='1' && s.charAt(i-2)=='1')return true ;
    }
    return false ;
  }
  static int countStr(int i,String s){
    if(i<0){
      if(check(s))return 1 ;
      return 0 ;
    }
    char[] myNameChars=s.toCharArray();
    myNameChars[i]='0' ;
    s=String.valueOf(myNameChars);
    int ans=countStr(i-1,s);
    char[] myChar=s.toCharArray();
    myChar[i]='1' ;
    s=String.valueOf(myChar);
    ans+=countStr(i-1,s);
    char[] myChar1=s.toCharArray();
    myChar1[i]='0' ;
    s=String.valueOf(myChar1);
    return ans ;
  }
  public static void main(String args[]){
    int N=4 ;
    String s="0000" ;
    System.out.println(countStr(N-1,s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( s : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
         var i : int ; i := 2 ; while i < n do ( (     if (s->at(i+1) = '1' & s->at(i - 1+1) = '1' & s->at(i - 2+1) = '1') then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation countStr( i : int, s : String) : int
  pre: true
  post: true
  activity: (     if (i < 0) then (     if (check(s)) then     return 1 else skip ; 
     return 0 ) else skip ; 
     var myNameChars : Sequence(String) ; myNameChars := s->characters() ;
    myNameChars[i+1] := '0' ; 
    s := (myNameChars)->sum()  ; 
    var ans : int ; ans := countStr(i - 1, s) ;
    var myChar : Sequence(String) ; myChar := s->characters() ;
    myChar[i+1] := '1' ; 
    s := (myChar)->sum()  ; 
    ans := ans+(countStr(i - 1, s)) ; 
    var myChar1 : Sequence(String) ; myChar1 := s->characters() ;
    myChar1[i+1] := '0' ; 
    s := (myChar1)->sum()  ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     var s : String ; s := "0000" ;
     OclFile["System.out"].println(countStr(N - 1, s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Keyboard {
  int number ;
  HashMap<Character,Integer>mapCharKeyboard=new HashMap<>();
  public Keyboard(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  public int positiveNumber(int number){
    if(number<0){
      number*=-1 ;
    }
    return number ;
  }
  public void inputInMap(String s){
    for(int i=0 ; i<s.length(); i++){
      mapCharKeyboard.put(s.charAt(i),i+1);
    }
  }
  public void inputAndResult(String s){
    int count=0 ;
    for(int i=0 ; i<s.length()-1 ; i++){
      count+=positiveNumber(mapCharKeyboard.get(s.charAt(i))-mapCharKeyboard.get(s.charAt(i+1)));
    }
    System.out.println(count);
    mapCharKeyboard.clear();
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    Keyboard instance=new Keyboard(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      String sKey=input.next();
      instance.inputInMap(sKey);
      String letter=input.next();
      instance.inputAndResult(letter);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Keyboard {
   attribute number : int;
   attribute mapCharKeyboard : Map(String,int) := Map{};
   static operation newKeyboard( number : int) : Keyboard
  pre: true
  post: true
  activity:
  ( var self : Keyboard ;
    self := createKeyboard();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
   operation positiveNumber( number : int) : int
  pre: true
  post: true
  activity: (     if (number < 0) then (     number := number*(-1) ) else skip ; 
     return number );
   operation inputInMap( s : String) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() do ( (     mapCharKeyboard := mapCharKeyboard->union(Map{s->at(i+1) |-> i + 1}) )  ;     i := i + 1 ) );
   operation inputAndResult( s : String) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < s->size() - 1 do ( (     count := count+(positiveNumber(mapCharKeyboard->at(s->at(i+1)) - mapCharKeyboard->at(s->at(i + 1+1)))) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) ; 
     mapCharKeyboard := mapCharKeyboard->intersection(Map{}) );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
     var instance : Keyboard ; instance := Keyboard.newKeyboard(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var sKey : String ; sKey := input.getCurrent() ;
     instance.inputInMap(sKey) ; 
     var letter : String ; letter := input.getCurrent() ;
     instance.inputAndResult(letter) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class base_power {
  static int calculate(int n,int power){
    int sum=0 ;
    int bp=(int)Math.pow(n,power);
    while(bp!=0){
      int d=bp % 10 ;
      sum+=d ;
      bp/=10 ;
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=5 ;
    int power=4 ;
    System.out.println(calculate(n,power));
  }
}
------------------------------------------------------------
OCL File:
---------
class base_power {
  static   operation calculate( n : int, power : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var bp : int ; bp := n->pow(power)->oclAsType(int) ;
     while (bp /= 0) do (     var d : int ; d := bp mod 10 ;
     sum := sum+(d) ; 
     bp := bp/(10) ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var power : int ; power := 4 ;
     OclFile["System.out"].println(calculate(n, power)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float altitude(float a,float b){
    return(float)(Math.sqrt(Math.pow(a,2)-(Math.pow(b,2)/4)));
  }
  static float area(float b,float h){
    return(1*b*h)/2 ;
  }
  public static void main(String[] args){
    float a=2,b=3 ;
    float h=altitude(a,b);
    System.out.print("Altitude="+h+",");
    System.out.print("Area="+area(b,h));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation altitude( a : double, b : double) : double
  pre: true
  post: true
  activity: (     return ((a->pow(2) - (b->pow(2) / 4))->sqrt())->oclAsType(double) );
  static   operation area( b : double, h : double) : double
  pre: true
  post: true
  activity: (     return (1 * b * h) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 2 ;
    var b : double ; b := 3 ;
     var h : double ; h := altitude(a, b) ;
     OclFile["System.out"].print("Altitude=" + h + ",") ; 
     OclFile["System.out"].print("Area=" + area(b, h)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPossible(int w,int h,int x,int y){
    if(x*2==w && y*2==h)return true ;
    return false ;
  }
  public static void main(String[] args){
    int w=1,h=2,x=1,y=2 ;
    if(isPossible(w,h,x,y))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPossible( w : int, h : int, x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     if (x * 2 = w & y * 2 = h) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var w : int ; w := 1 ;
    var h : int ; h := 2 ;
    var x : int ; x := 1 ;
    var y : int ; y := 2 ;
     if (isPossible(w, h, x, y)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int NthSmallest(int K){
    Queue<Integer>Q=new LinkedList<>();
    int x=0 ;
    for(int i=1 ; i<10 ; i++)Q.add(i);
    for(int i=1 ; i<=K ; i++){
      x=Q.peek();
      Q.remove();
      if(x % 10!=0){
        Q.add(x*10+x % 10-1);
      }
      Q.add(x*10+x % 10);
      if(x % 10!=9){
        Q.add(x*10+x % 10+1);
      }
    }
    return x ;
  }
  public static void main(String[] args){
    int N=16 ;
    System.out.print(NthSmallest(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation NthSmallest( K : int) : int
  pre: true
  post: true
  activity: (     var Q : Sequence(int) ; Q := Sequence{} ;
     var x : int ; x := 0 ;
        var i : int ; i := 1 ; while i < 10 do (     Q := Q->including(i) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= K do ( (     x := Q->min() ; 
     Q := Q.remove() ; 
    if (x mod 10 /= 0) then (     Q := Q->including(x * 10 + x mod 10 - 1) ) else skip ; 
    Q := Q->including(x * 10 + x mod 10) ; 
    if (x mod 10 /= 9) then (     Q := Q->including(x * 10 + x mod 10 + 1) ) else skip ; 
 )  ;     i := i + 1 ) ; 
    return x 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 16 ;
     OclFile["System.out"].print(NthSmallest(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] $){
    Scanner sc=new Scanner(System.in);
    long a=sc.nextInt(),b=sc.nextInt(),c=sc.nextInt(),x=sc.nextInt(),y=sc.nextInt();
    long res1=a*x+b*y,res2=Math.max(x,y)*c*2,res3=Long.MAX_VALUE ;
    if(x>y){
      res3=y*c*2+(x-y)*a ;
    }
    else if(x<y){
      res3=x*c*2+(y-x)*b ;
    }
    System.out.println((long)Math.min(res1,Math.min(res2,res3)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toInteger() ;
    var b : long ; b := sc.getCurrent()->toInteger() ;
    var c : long ; c := sc.getCurrent()->toInteger() ;
    var x : long ; x := sc.getCurrent()->toInteger() ;
    var y : long ; y := sc.getCurrent()->toInteger() ;
    var res1 : long ; res1 := a * x + b * y ;
    var res2 : long ; res2 := Set{x, y}->max() * c * 2 ;
    var res3 : long ; res3 := "9223372036854775807"->toLong() ;
    if (x > y) then (     res3 := y * c * 2 + (x - y) * a ) else     if (x < y) then (     res3 := x * c * 2 + (y - x) * b ) else skip ; ;  
    OclFile["System.out"].println(Set{res1, Set{res2, res3}->min()}->min()->oclAsType(long)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    C solver=new C();
    solver.solve(1,in,out);
    out.close();
  }
  static class C {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int a=Integer.parseInt(in.next());
      int b=Integer.parseInt(in.next());
      int c=Integer.parseInt(in.next());
      int x=Integer.parseInt(in.next());
      int y=Integer.parseInt(in.next());
      int ans=a*x+b*y ;
      ans=Math.min(ans,c*Math.max(x,y)*2);
      ans=Math.min(ans,c*x*2+b*Math.abs(y-x));
      ans=Math.min(ans,a*Math.abs(x-y)+c*y*2);
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : C ; solver := C.newC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class C {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := (in.getCurrent())->toInteger() ;
     var b : int ; b := (in.getCurrent())->toInteger() ;
    var c : int ; c := (in.getCurrent())->toInteger() ;
    var x : int ; x := (in.getCurrent())->toInteger() ;
    var y : int ; y := (in.getCurrent())->toInteger() ;
    var ans : int ; ans := a * x + b * y ;
    ans := Set{ans, c * Set{x, y}->max() * 2}->min() ; 
    ans := Set{ans, c * x * 2 + b * if y - x < 0 then -(y - x) else y - x endif}->min() ; 
    ans := Set{ans, a * if x - y < 0 then -(x - y) else x - y endif + c * y * 2}->min() ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int AB=sc.nextInt();
    int X=sc.nextInt();
    int Y=sc.nextInt();
    Long sum=(long)0 ;
    if(2*AB>=(A+B)){
      sum=(long)(A*X+B*Y);
      System.out.println(sum);
      return ;
    }
    int min=X ;
    int max=Y ;
    int addpizza=B ;
    if(Y<X){
      min=Y ;
      max=X ;
      addpizza=A ;
    }
    Long sum2=(long)(2*AB*max);
    sum=(long)(addpizza*(max-min)+2*(AB*min));
    if(sum<sum2){
      System.out.println(sum);
    }
    else {
      System.out.println(sum2);
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var AB : int ; AB := sc.getCurrent()->toInteger() ;
    var X : int ; X := sc.getCurrent()->toInteger() ;
    var Y : int ; Y := sc.getCurrent()->toInteger() ;
    var sum : long ; sum := 0->oclAsType(long) ;
    if (2 * AB >= (A + B)) then (     sum := (A * X + B * Y)->oclAsType(long) ; 
     OclFile["System.out"].println(sum) ; 
     return ) else skip ; 
    var min : int ; min := X ;
    var max : int ; max := Y ;
    var addpizza : int ; addpizza := B ;
    if (Y < X) then (     min := Y ; 
     max := X ; 
     addpizza := A ) else skip ; 
    var sum2 : long ; sum2 := (2 * AB * max)->oclAsType(long) ;
    sum := (addpizza * (max - min) + 2 * (AB * min))->oclAsType(long) ; 
    if (sum < sum2) then (     OclFile["System.out"].println(sum) ) else (     OclFile["System.out"].println(sum2) ) ;  
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double expect(double m,double n){
    double ans=0.0,i ;
    for(i=m ; i>0 ; i--)ans+=(Math.pow(i/m,n)-Math.pow((i-1)/m,n))*i ;
    return ans ;
  }
  public static void main(String[] args){
    double m=6,n=3 ;
    System.out.println(String.format("%.5f",expect(m,n)));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation expect( m : double, n : double) : double
  pre: true
  post: true
  activity: (     var ans : double ; ans := 0.0 ;
    var i : double ;
         i := m ; while i > 0 do (     ans := ans+((i / m->pow(n) - (i - 1) / m->pow(n)) * i) ;  ;     i := i - 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : double ; m := 6 ;
    var n : double ; n := 3 ;
     OclFile["System.out"].println(StringLib.format("%.5f",Sequence{expect(m, n)})) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A,B,C,X,Y,sum_price=0 ;
    ArrayList<Integer>price=new ArrayList<>();
    A=sc.nextInt();
    B=sc.nextInt();
    C=sc.nextInt();
    X=sc.nextInt();
    Y=sc.nextInt();
    int L ;
    if(X>Y)L=X ;
    else L=Y ;
    for(int a=0 ; a<=L ; a++){
      sum_price=0 ;
      sum_price+=C*2*a ;
      for(int b=0 ; b<X-a ; b++){
        sum_price+=A ;
      }
      for(int c=0 ; c<Y-a ; c++){
        sum_price+=B ;
      }
      price.add(sum_price);
    }
    System.out.println(Collections.min(price));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ;
    var B : int ;
    var C : int ;
    var X : int ;
    var Y : int ;
    var sum_price : int ; sum_price := 0 ;
    var price : Sequence(int) ; price := Sequence{} ;
    A := sc.getCurrent()->toInteger() ; 
    B := sc.getCurrent()->toInteger() ; 
    C := sc.getCurrent()->toInteger() ; 
    X := sc.getCurrent()->toInteger() ; 
    Y := sc.getCurrent()->toInteger() ; 
    var L : int ;
    if (X > Y) then     L := X else     L := Y ; ;  
        var a : int ; a := 0 ; while a <= L do ( (     sum_price := 0 ; 
     sum_price := sum_price+(C * 2 * a) ; 
        var b : int ; b := 0 ; while b < X - a do ( (     sum_price := sum_price+(A) )  ;     b := b + 1 ) ; 
        var c : int ; c := 0 ; while c < Y - a do ( (     sum_price := sum_price+(B) )  ;     c := c + 1 ) ; 
    price := price->including(sum_price) ; 
 )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(price->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner scn=new Scanner(System.in);
    int a=scn.nextInt();
    int b=scn.nextInt();
    int c=scn.nextInt();
    int x=scn.nextInt();
    int y=scn.nextInt();
    ArrayList<Long>arr=new ArrayList<>();
    arr.add((long)(a*x+b*y));
    long s=0 ;
    int q=Math.min(x,y);
    int dif=Math.abs(x-y);
    if(x>y){
      s=2*q*c+(x-y)*a ;
    }
    else {
      s=2*q*c+(y-x)*b ;
    }
    arr.add(s);
    arr.add((long)(Math.max(x,y)*c*2));
    Collections.sort(arr);
    System.out.println(arr.get(0));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scn.getCurrent()->toInteger() ;
    var b : int ; b := scn.getCurrent()->toInteger() ;
    var c : int ; c := scn.getCurrent()->toInteger() ;
    var x : int ; x := scn.getCurrent()->toInteger() ;
    var y : int ; y := scn.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Sequence{} ;
    arr := arr->including((a * x + b * y)->oclAsType(long)) ; 
    var s : long ; s := 0 ;
    var q : int ; q := Set{x, y}->min() ;
    var dif : int ; dif := if x - y < 0 then -(x - y) else x - y endif ;
    if (x > y) then (     s := 2 * q * c + (x - y) * a ) else (     s := 2 * q * c + (y - x) * b ) ;  
    arr := arr->including(s) ; 
    arr := arr->including((Set{x, y}->max() * c * 2)->oclAsType(long)) ; 
    arr := arr->sort() ; 
    OclFile["System.out"].println(arr->at(0+1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSetBits(int n){
    int count=0 ;
    while(n>0){
      n &=(n-1);
      count++;
    }
    return count ;
  }
  static int countUnsetBitsInGivenRange(int n,int l,int r){
    int num=((1<<r)-1)^((1<<(l-1))-1);
    return(r-l+1)-countSetBits(n & num);
  }
  public static void main(String[] args){
    int n=80 ;
    int l=1,r=4 ;
    System.out.print(countUnsetBitsInGivenRange(n,l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     n := MathLib.bitwiseAnd(n, (n - 1)) ; 
     count := count + 1 ) ; 
     return count );
  static   operation countUnsetBitsInGivenRange( n : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := MathLib.bitwiseXor((((1*(2->pow(r)))->oclAsType(long)) - 1),(((1*(2->pow((l - 1))))->oclAsType(long)) - 1)) ;
     return (r - l + 1) - countSetBits(n & num) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 80 ;
     var l : int ; l := 1 ;
    var r : int ; r := 4 ;
     OclFile["System.out"].print(countUnsetBitsInGivenRange(n, l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B implements Runnable {
  private Scanner in ;
  private PrintWriter out ;
  private void solve(int testCase){
    int n=in.nextInt();
    int m=in.nextInt();
    int a=in.nextInt();
    if(a>n*m){
      out.println("Case #"+testCase+": IMPOSSIBLE");
      return ;
    }
    int p=a-a % n ;
    if(p<a)p+=n ;
    int y3=p/n ;
    int x3=p-a ;
    out.println("Case #"+testCase+": 0 0 "+n+" 1 "+x3+" "+y3);
  }
  public static void main(String[] args)throws IOException {
    Locale.setDefault(Locale.US);
    new Thread(new B()).start();
  }
  public void run(){
    try {
      in=new Scanner(new FileReader("b.in"));
      out=new PrintWriter("b.out");
      int n=in.nextInt();
      for(int i=1 ; i<=n ; i++)solve(i);
      in.close();
      out.close();
    }
    catch(IOException e){
      e.printStackTrace();
      System.exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B implements Runnable {
   attribute in : OclFile;
   attribute out : OclFile;
   operation solve( testCase : int) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    if (a > n * m) then (     skip ; 
     return ) else skip ; 
    var p : int ; p := a - a mod n ;
    if (p < a) then     p := p+(n) ; else skip ; 
    var y3 : int ; y3 := p / n ;
    var x3 : int ; x3 := p - a ;
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.US) ; 
     OclProcess.newOclProcess(B.newB()).start() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("b.in"))) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile("b.out")) ; 
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= n do (     execute solve(i) ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    Hashtable<Character,Integer>map=new Hashtable<>();
    while(t-->0){
      String characters=sc.next();
      for(int i=0 ; i<26 ; i++){
        map.put(characters.charAt(i),i);
      }
      String word=sc.next();
      int sum=0 ;
      for(int i=0 ; i<word.length(); i++){
        if(i+1<word.length())sum+=Math.abs(map.get(word.charAt(i))-map.get(word.charAt(i+1)));
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     var map : Map(String,int) ; map := Map{} ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var characters : String ; characters := sc.getCurrent() ;
         var i : int ; i := 0 ; while i < 26 do ( (     map := map->union(Map{characters->at(i+1) |-> i}) )  ;     i := i + 1 ) ; 
    var word : String ; word := sc.getCurrent() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < word->size() do ( (     if (i + 1 < word->size()) then     sum := sum+(if map->at(word->at(i+1)) - map->at(word->at(i + 1+1)) < 0 then -(map->at(word->at(i+1)) - map->at(word->at(i + 1+1))) else map->at(word->at(i+1)) - map->at(word->at(i + 1+1)) endif) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSetBits(int n){
    int count=0 ;
    while(n>0){
      n &=(n-1);
      count++;
    }
    return count ;
  }
  static int countSetBitsInGivenRange(int n,int l,int r){
    int num=((1<<r)-1)^((1<<(l-1))-1);
    return countSetBits(n & num);
  }
  public static void main(String[] args){
    int n=42 ;
    int l=2,r=5 ;
    System.out.print(countSetBitsInGivenRange(n,l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     n := MathLib.bitwiseAnd(n, (n - 1)) ; 
     count := count + 1 ) ; 
     return count );
  static   operation countSetBitsInGivenRange( n : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := MathLib.bitwiseXor((((1*(2->pow(r)))->oclAsType(long)) - 1),(((1*(2->pow((l - 1))))->oclAsType(long)) - 1)) ;
     return countSetBits(n & num) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 42 ;
     var l : int ; l := 2 ;
    var r : int ; r := 5 ;
     OclFile["System.out"].print(countSetBitsInGivenRange(n, l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void ReplaceElements(int arr[],int n){
    HashMap<Integer,Integer>mp=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(! mp.containsKey(arr[i])){
        mp.put(arr[i],1);
      }
      else {
        mp.put(arr[i],mp.get(arr[i])+1);
      }
    }
    for(int i=0 ; i<n ; ++i){
      arr[i]=n-mp.get(arr[i]);
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,2,5,2,2,5,4 };
      int n=arr.length ;
      ReplaceElements(arr,n);
      for(int i=0 ; i<n ; ++i){
        System.out.print(arr[i]+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation ReplaceElements( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (not(mp->keys()->includes(arr[i+1]))) then (     mp := mp->union(Map{arr[i+1] |-> 1}) ) else (     mp := mp->union(Map{arr[i+1] |-> mp->at(arr[i+1]) + 1}) ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := n - mp->at(arr[i+1]) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,5,2,2,5,4} ;
     var n : int ; n := arr->size() ;
     execute ReplaceElements(arr, n) ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void remove(int arr[],int n){
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      if(mp.containsKey(arr[i])){
        mp.put(arr[i],mp.get(arr[i])+1);
      }
      else {
        mp.put(arr[i],1);
      }
    }
    for(int i=0 ; i<n ; i++){
      if((mp.containsKey(arr[i])&& mp.get(arr[i])% 2==1))continue ;
      System.out.print(arr[i]+",");
    }
  }
  public static void main(String[] args){
    int arr[]={
      3,3,3,2,2,4,7,7 };
      int n=arr.length ;
      remove(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation remove( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (mp->keys()->includes(arr[i+1])) then (     mp := mp->union(Map{arr[i+1] |-> mp->at(arr[i+1]) + 1}) ) else (     mp := mp->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if ((mp->keys()->includes(arr[i+1]) & mp->at(arr[i+1]) mod 2 = 1)) then     continue else skip ; 
     OclFile["System.out"].print(arr[i+1] + ",") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,3,3,2,2,4,7,7} ;
     var n : int ; n := arr->size() ;
     execute remove(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class GFG {
  static void ReplaceElementsByFrequency(int arr[],int n){
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; ++i){
      if(mp.get(arr[i])==null){
        mp.put(arr[i],1);
      }
      else {
        mp.put(arr[i],(mp.get(arr[i])+1));
      }
    }
    for(int i=0 ; i<n ; ++i){
      if(mp.get(arr[i])!=null){
        arr[i]=mp.get(arr[i]);
      }
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,2,5,2,2,5 };
      int n=arr.length ;
      ReplaceElementsByFrequency(arr,n);
      for(int i=0 ; i<n ; ++i){
        System.out.print(arr[i]+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation ReplaceElementsByFrequency( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (mp->at(arr[i+1]) = null) then (     mp := mp->union(Map{arr[i+1] |-> 1}) ) else (     mp := mp->union(Map{arr[i+1] |-> (mp->at(arr[i+1]) + 1)}) ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (mp->at(arr[i+1]) /= null) then (     arr[i+1] := mp->at(arr[i+1]) ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,5,2,2,5} ;
     var n : int ; n := arr->size() ;
     execute ReplaceElementsByFrequency(arr, n) ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int MAX=26 ;
  static int countPairs(char[] str,int k){
    int n=str.length ;
    int[] freq=new int[MAX];
    for(int i=0 ; i<n ; i++){
      freq[str[i]-'a']++;
    }
    int cnt=0 ;
    if(k==0){
      for(int i=0 ; i<MAX ; i++){
        if(freq[i]>1){
          cnt+=((freq[i]*(freq[i]-1))/2);
        }
      }
    }
    else {
      for(int i=0 ; i<MAX ; i++){
        if(freq[i]>0 && i+k<MAX && freq[i+k]>0){
          cnt+=(freq[i]*freq[i+k]);
        }
      };
    }
    return cnt ;
  }
  public static void main(String[] args){
    String str="abcdab" ;
    int k=0 ;
    System.out.println(countPairs(str.toCharArray(),k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 26;
  static   operation countPairs( str : Sequence(String), k : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var freq : Sequence(int) ; freq := Integer.subrange(1,MAX)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     freq[str[i+1] - ('a')->char2byte()+1] := freq[str[i+1] - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    if (k = 0) then (         var i : int ; i := 0 ; while i < MAX do ( (     if (freq[i+1] > 1) then (     cnt := cnt+(((freq[i+1] * (freq[i+1] - 1)) / 2)) ) else skip )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < MAX do ( (     if (freq[i+1] > 0 & i + k < MAX & freq[i + k+1] > 0) then (     cnt := cnt+((freq[i+1] * freq[i + k+1])) ) else skip )  ;     i := i + 1 ) ; 
  ) ;  
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abcdab" ;
     var k : int ; k := 0 ;
     OclFile["System.out"].println(countPairs(str->characters(), k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static long ProdOfPrimes(int n){
    boolean prime[]=new boolean[n+1];
    Arrays.fill(prime,true);
    for(int p=2 ; p*p<=n ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=n ; i+=p)prime[i]=false ;
      }
    }
    long prod=1 ;
    for(int i=2 ; i<=n ; i++)if(prime[i])prod*=i ;
    return prod ;
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.print(ProdOfPrimes(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation ProdOfPrimes( n : int) : long
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,n + 1)->collect(false) ;
     prime := prime->collect(true) ; 
        var p : int ; p := 2 ; while p * p <= n do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= n do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var prod : long ; prod := 1 ;
        var i : int ; i := 2 ; while i <= n do (     if (prime[i+1]) then     prod := prod*(i) ; else skip ;  ;     i := i + 1 ) ; 
    return prod 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].print(ProdOfPrimes(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSquares(int row,int column){
    int topLeft=Math.min(row,column)-1 ;
    int bottomRight=8-Math.max(row,column);
    int topRight=Math.min(row,9-column)-1 ;
    int bottomLeft=8-Math.max(row,9-column);
    return(topLeft+topRight+bottomRight+bottomLeft);
  }
  public static void main(String[] args){
    int row=4,column=4 ;
    System.out.println(countSquares(row,column));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSquares( row : int, column : int) : int
  pre: true
  post: true
  activity: (     var topLeft : int ; topLeft := Set{row, column}->min() - 1 ;
     var bottomRight : int ; bottomRight := 8 - Set{row, column}->max() ;
    var topRight : int ; topRight := Set{row, 9 - column}->min() - 1 ;
    var bottomLeft : int ; bottomLeft := 8 - Set{row, 9 - column}->max() ;
    return (topLeft + topRight + bottomRight + bottomLeft) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var row : int ; row := 4 ;
    var column : int ; column := 4 ;
     OclFile["System.out"].println(countSquares(row, column)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int pos=0 ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    long max=0 ;
    Stack<Rect>stk=new Stack<>();
    for(int i=0 ; i<N ; i++){
      long h=Long.parseLong(in.next());
      if(stk.isEmpty()|| h>stk.peek().h){
        stk.push(new Rect(h,i));
      }
      else if(h<stk.peek().h){
        max=Math.max(max,createRect(stk,h,i));
        stk.push(new Rect(h,pos));
      }
    }
    max=Math.max(max,createRect(stk,0,N));
    System.out.println(max);
  }
  static long createRect(Stack<Rect>stk,long h,int i){
    long max=0 ;
    while(! stk.isEmpty()){
      Rect crect=stk.peek();
      if(crect.h<h)break ;
      max=Math.max(max,crect.h*(i-crect.i));
      pos=crect.i ;
      stk.pop();
    }
    return max ;
  }
}
class Rect {
  long h ;
  int i ;
  Rect(long a,int b){
    h=a ;
    i=b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute pos : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var max : long ; max := 0 ;
    var stk : Sequence(Rect) ; stk := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var h : long ; h := (in.getCurrent())->toLong() ;
     if (stk->isEmpty() or h > stk->min().h) then (     stk := stk->append(Rect.newRect(h, i)) ) else     if (h < stk->min().h) then (     max := Set{max, createRect(stk, h, i)}->max() ; 
     stk := stk->append(Rect.newRect(h, pos)) ) else skip ; )  ;     i := i + 1 ) ; 
    max := Set{max, createRect(stk, 0, N)}->max() ; 
    OclFile["System.out"].println(max) ; 
 );
  static   operation createRect( stk : Sequence(Rect), h : long, i : int) : long
  pre: true
  post: true
  activity: (     var max : long ; max := 0 ;
     while (not(stk->isEmpty())) do (     var crect : Rect ; crect := stk->min() ;
     if (crect.h < h) then     break else skip ; 
    max := Set{max, crect.h * (i - crect.i)}->max() ; 
    pos := crect.i ; 
    stk := stk->front() ; 
 ) ; 
     return max );
}
class Rect {
   attribute h : long;
   attribute i : int;
   static operation newRect( a : long, b : int) : Rect
  pre: true
  post: true
  activity:
  ( var self : Rect ;
    self := createRect();
    self.initialise(a, b);
    return self );
  operation initialise( a : long, b : int) : void
  pre: true  post: true
  activity: (     h := a ; 
     i := b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[] stacks=new long[N+1];
    int counter=0 ;
    long mltp=100000000000L ;
    long now_h=0 ;
    long max=0 ;
    stacks[0]=0 ;
    counter++;
    for(int i=0 ; i<N ; i++){
      long h=sc.nextLong();
      if(i==0){
        stacks[counter]=((long)i)*mltp+h ;
        counter++;
      }
      else {
        if(now_h<h){
          stacks[counter]=((long)i)*mltp+h ;
          counter++;
        }
        else if(now_h==h){
        }
        else if(now_h>h){
          while(counter-1>=0 && stacks[counter-1] % mltp>=h){
            max=Math.max(max,(i-stacks[counter-1]/mltp)*(stacks[counter-1] % mltp));
            counter--;
          }
          stacks[counter]=(stacks[counter]/mltp)*mltp+h ;
          counter++;
        }
      }
      now_h=h ;
    }
    for(int i=counter-1 ; i>=0 ; i--){
      max=Math.max(max,(N-stacks[i]/mltp)*(stacks[i] % mltp));
    }
    pl(max);
    sc.close();
  }
  public static void pl(Object o){
    System.out.println(o);
  }
  public static void pl(){
    System.out.println();
  }
  public static void p(Object o){
    System.out.print(o);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var stacks : Sequence(long) ; stacks := Integer.subrange(1,N + 1)->collect(0) ;
    var counter : int ; counter := 0 ;
    var mltp : long ; mltp := 100000000000L ;
    var now_h : long ; now_h := 0 ;
    var max : long ; max := 0 ;
    stacks[0+1] := 0 ; 
    counter := counter + 1 ; 
        var i : int ; i := 0 ; while i < N do ( (     var h : long ; h := sc.getCurrent()->toLong() ;
     if (i = 0) then (     stacks[counter+1] := (i->oclAsType(long)) * mltp + h ; 
     counter := counter + 1 ) else (     if (now_h < h) then (     stacks[counter+1] := (i->oclAsType(long)) * mltp + h ; 
     counter := counter + 1 ) else     if (now_h = h) then skip else     if (now_h > h) then (     while (counter - 1 >= 0 & stacks[counter - 1+1] mod mltp >= h) do (     max := Set{max, (i - stacks[counter - 1+1] / mltp) * (stacks[counter - 1+1] mod mltp)}->max() ; 
     counter := counter - 1 ) ; 
     stacks[counter+1] := (stacks[counter+1] / mltp) * mltp + h ; 
     counter := counter + 1 ) else skip ; ;  ) ;  
     now_h := h )  ;     i := i + 1 ) ; 
        var i : int ; i := counter - 1 ; while i >= 0 do ( (     max := Set{max, (N - stacks[i+1] / mltp) * (stacks[i+1] mod mltp)}->max() )  ;     i := i - 1 ) ; 
    execute pl(max) ; 
    skip ; 
 );
  static   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation pl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class pair {
    int first,second ;
    pair(int a,int b){
      first=a ;
      second=b ;
    }
  }
  static void preCalculate(int binary[],int n,pair left[]){
    int count1=0,count0=0 ;
    for(int i=0 ; i<n ; i++){
      left[i] .first=count1 ;
      left[i] .second=count0 ;
      if(binary[i]!=0)count1++;
      else count0++;
    }
  }
  public static void main(String args[]){
    int binary[]={
      1,1,1,0,0,1,0,1,1 };
      int n=binary.length ;
      pair left[]=new pair[n];
      for(int i=0 ; i<n ; i++)left[i]=new pair(0,0);
      preCalculate(binary,n,left);
      int queries[]={
        0,1,2,4 };
        int q=queries.length ;
        for(int i=0 ; i<q ; i++)System.out.println(left[queries[i] ] .first+" ones "+left[queries[i] ] .second+" zeros\n");
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static class pair {
   attribute first : int;
   static operation newpair( a : int, b : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     first := a ; 
     second := b );
}
  static   operation preCalculate( binary : Sequence(int), n : int, left : Sequence(pair)) : void
  pre: true
  post: true
  activity: (     var count1 : int ; count1 := 0 ;
    var count0 : int ; count0 := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     left[i+1]->at("first") := count1 ; 
     left[i+1]->at("second") := count0 ; 
     if (binary[i+1] /= 0) then     count1 := count1 + 1 ; else     count0 := count0 + 1 ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var binary : Sequence(int) ; binary := Sequence{1,1,1,0,0,1,0,1,1} ;
     var n : int ; n := binary->size() ;
    var left : Sequence(pair) ; left := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     left[i+1] := pair.newpair(0, 0) ;  ;     i := i + 1 ) ; 
    execute preCalculate(binary, n, left) ; 
    var queries : Sequence(int) ; queries := Sequence{0,1,2,4} ;
    var q : int ; q := queries->size() ;
        var i : int ; i := 0 ; while i < q do (     OclFile["System.out"].println(left[queries[i+1]+1]->at("first") + " ones " + left[queries[i+1]+1]->at("second") + " zeros\n") ;  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class KthLargest {
  final PriorityQueue<Integer>q ;
  final int k ;
  public KthLargest(int k,int[] nums){
    this.k=k ;
    q=new PriorityQueue<>(k);
    for(int val : nums)add(val);
  }
  public int add(int val){
    if(q.size()<k)q.offer(val);
    else if(q.peek()<val){
      q.poll();
      q.offer(val);
    }
    return q.peek();
  }
}
------------------------------------------------------------
OCL File:
---------
class KthLargest {
   attribute q : Sequence(int);
   attribute k : int;
   static operation newKthLargest( k : int, nums : Sequence(int)) : KthLargest
  pre: true
  post: true
  activity:
  ( var self : KthLargest ;
    self := createKthLargest();
    self.initialise(k, nums);
    return self );
  operation initialise( k : int, nums : Sequence(int)) : void
  pre: true  post: true
  activity: (     self.k := k ; 
     q := Sequence{} ; 
     for (val : nums) do (     execute add(val) ;  ) );
   operation add( val : int) : int
  pre: true
  post: true
  activity: (     if (q->size() < k) then     q := q->including(val) else     if (q->min() < val) then (     q := q->sort()->tail() ; 
     q := q->including(val) ) else skip ; ;  
     return q->min() );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A1607 {
  static FastScanner sc=new FastScanner();
  public static void main(String[] args){
    int t=sc.nextInt();
    while(t-->0)solve();
  }
  public static void solve(){
    String s=sc.next(),word=sc.next();
    StringBuilder str=new StringBuilder(s);
    int time=0 ;
    for(int i=1 ; i<word.length(); i++){
      time+=Math.abs(str.indexOf(Character.toString(word.charAt(i)))-str.indexOf(Character.toString(word.charAt(i-1))));
    }
    System.out.println(time);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1607 {
  static   attribute sc : FastScanner := FastScanner.newFastScanner();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ;     execute solve() ; ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var s : String ; s := sc.next() ;
    var word : String ; word := sc.next() ;
     var str : String ; str := StringLib.newString(s) ;
    var time : int ; time := 0 ;
        var i : int ; i := 1 ; while i < word->size() do ( (     time := time+(if str->indexOf((word->at(i+1) + ""))-1 - str->indexOf((word->at(i - 1+1) + ""))-1 < 0 then -(str->indexOf((word->at(i+1) + ""))-1 - str->indexOf((word->at(i - 1+1) + ""))-1) else str->indexOf((word->at(i+1) + ""))-1 - str->indexOf((word->at(i - 1+1) + ""))-1 endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(time) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Calculatingfun {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long fn ;
    if(n % 2==0)fn=n/2 ;
    else fn=(-1)*(n/2+1);
    System.out.println(fn);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Calculatingfun {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var fn : long ;
    if (n mod 2 = 0) then     fn := n / 2 else     fn := (-1) * (n / 2 + 1) ; ;  
    OclFile["System.out"].println(fn) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    if(n % 2==0){
      System.out.println(n/2);
    }
    else {
      System.out.println(-(n/2+1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
     if (n mod 2 = 0) then (     OclFile["System.out"].println(n / 2) ) else (     OclFile["System.out"].println(-(n / 2 + 1)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long k=(n/2)*((n/2)+1);
    long p ;
    if(n % 2==0){
      p=n/2 ;
    }
    else p=n/2+1 ;
    long j=k-p*p ;
    System.out.println(j);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var k : long ; k := (n / 2) * ((n / 2) + 1) ;
    var p : long ;
    if (n mod 2 = 0) then (     p := n / 2 ) else     p := n / 2 + 1 ; ;  
    var j : long ; j := k - p * p ;
    OclFile["System.out"].println(j) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Long n=new Scanner(System.in).nextLong();
    if(n % 2==0){
      System.out.println(n/2);
    }
    else {
      System.out.println(-(n+1)/2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := OclFile.newOclFile_Read(OclFile["System.in"]).nextLong() ;
     if (n mod 2 = 0) then (     OclFile["System.out"].println(n / 2) ) else (     OclFile["System.out"].println(-(n + 1) / 2) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  void run(){
    HashSet<String>set=new HashSet<String>();
    char last='a' ;
    for(char a='a' ; a<='z' ; a++){
      for(char b='a' ; b<='z' ; b++){
        sysout.printf("?%c%c%ca\n",last,a,b);
        String w=read();
        if(set.contains(w)){
          sysout.println("!OUT");
          return ;
        }
        if(w.charAt(0)!='a'){
          sysout.println("!OUT");
          return ;
        }
        set.add(w);
        last=w.charAt(w.length()-1);
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  PrintWriter sysout=new PrintWriter(System.out,true);
  BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer buffer=new StringTokenizer("");
  String read(){
    if(! buffer.hasMoreTokens()){
      try {
        buffer=new StringTokenizer(in.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return buffer.nextToken();
  }
  int readInt(){
    return Integer.parseInt(read());
  }
  long readLong(){
    return Long.parseLong(read());
  }
  double readDouble(){
    return Double.parseDouble(read());
  }
  String readLine(){
    buffer=new StringTokenizer("");
    try {
      return in.readLine();
    }
    catch(IOException e){
      throw new RuntimeException(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var set : Set(String) ; set := Set{} ;
     var last : String ; last := 'a' ;
         var a : String ; a := 'a' ; while a <= 'z' do ( (         var b : String ; b := 'a' ; while b <= 'z' do ( (     sysout.printf("?%c%c%ca\n", last, a, b) ; 
     var w : String ; w := read() ;
    if (set->includes(w)) then (     sysout.println("!OUT") ; 
     return ) else skip ; 
    if (w->at(0+1) /= 'a') then (     sysout.println("!OUT") ; 
     return ) else skip ; 
    set := set->including(w) ; 
    last := w->at(w->size() - 1+1) ; 
 )  ;     b := b + 1 ) )  ;     a := a + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute sysout : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], true);
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute buffer : OclIterator := OclIterator.newOclIterator_String("");
   operation read() : String
  pre: true
  post: true
  activity: (     if (not(buffer.hasNext())) then (     try (     buffer := OclIterator.newOclIterator_String(in.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return buffer.next() );
   operation readInt() : int
  pre: true
  post: true
  activity: (     return (read())->toInteger() );
   operation readLong() : long
  pre: true
  post: true
  activity: (     return (read())->toLong() );
   operation readDouble() : double
  pre: true
  post: true
  activity: (     return (read())->toReal() );
   operation readLine() : String
  pre: true
  post: true
  activity: (     buffer := OclIterator.newOclIterator_String("") ; 
     try (     return in.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void farthest_min(int[] a,int n){
    int[] suffix_min=new int[n];
    suffix_min[n-1]=a[n-1];
    for(int i=n-2 ; i>=0 ; i--){
      suffix_min[i]=Math.min(suffix_min[i+1],a[i]);
    }
    for(int i=0 ; i<n ; i++){
      int low=i+1,high=n-1,ans=-1 ;
      while(low<=high){
        int mid=(low+high)/2 ;
        if(suffix_min[mid]<a[i]){
          ans=mid ;
          low=mid+1 ;
        }
        else high=mid-1 ;
      }
      System.out.print(ans+" ");
    }
  }
  public static void main(String[] args){
    int[] a={
      3,1,5,2,4 };
      int n=a.length ;
      farthest_min(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation farthest_min( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var suffix_min : Sequence(int) ; suffix_min := Integer.subrange(1,n)->collect(0) ;
     suffix_min[n - 1+1] := a[n - 1+1] ; 
         var i : int ; i := n - 2 ; while i >= 0 do ( (     suffix_min[i+1] := Set{suffix_min[i + 1+1], a[i+1]}->min() )  ;     i := i - 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     var low : int ; low := i + 1 ;
    var high : int ; high := n - 1 ;
    var ans : int ; ans := -1 ;
     while (low <= high) do (     var mid : int ; mid := (low + high) / 2 ;
     if (suffix_min[mid+1] < a[i+1]) then (     ans := mid ; 
     low := mid + 1 ) else     high := mid - 1 ; ) ; 
     OclFile["System.out"].print(ans + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{3,1,5,2,4} ;
     var n : int ; n := a->size() ;
     execute farthest_min(a, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.NavigableSet ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      NavigableSet<Integer>taro=new TreeSet<Integer>();
      NavigableSet<Integer>hana=new TreeSet<Integer>();
      for(int i=0 ; i<n ; i++)taro.add(scanner.nextInt());
      for(int i=1 ; i<=n*2 ; i++)hana.add(i);
      hana.removeAll(taro);
      NavigableSet<Integer>pc=taro ;
      Integer table=null ;
      while(! taro.isEmpty()&& ! hana.isEmpty()){
        if(table==null)table=pc.pollFirst();
        else {
          if((table=pc.higher(table))!=null)pc.remove(table);
        }
        pc=pc.equals(taro)? hana : taro ;
      }
      System.out.println(hana.size());
      System.out.println(taro.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var taro : NavigableSet<int> ; taro := Set{} ;
    var hana : NavigableSet<int> ; hana := Set{} ;
        var i : int ; i := 0 ; while i < n do (     taro->excludes(scanner.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n * 2 do (     hana->excludes(i) ;  ;     i := i + 1 ) ; 
    hana := hana - taro ; 
    var pc : NavigableSet<int> ; pc := taro ;
    var table : int ; table := null ;
    while (not(taro->isEmpty()) & not(hana->isEmpty())) do (     if (table = null) then     table := pc->first() ;     pc := pc->tail() else (     if ((table) /= null) then     pc := pc->excludingAt(table+1) ; else skip ) ;  
     pc := if pc = taro then hana else taro endif ) ; 
    OclFile["System.out"].println(hana->size()) ; 
    OclFile["System.out"].println(taro->size()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String arg[]){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int n=in.nextInt();
      if(n==0)return ;
      int ta[]=new int[(2*n)+1];
      int ha[]=new int[(2*n)+1];
      for(int i=0 ; i<n ; i++)ta[in.nextInt()]++;
      for(int i=1 ; i<=2*n ; i++)if(ta[i]==0)ha[i]++;
      int max=-1 ;
      for(int i=1 ; i<=2*n ; i++){
        if(ta[i]==1){
          ta[i]=0 ;
          max=i ;
          break ;
        }
      }
      int turn=1 ;
      int t=n-1 ;
      int h=n ;
      int reset=0 ;
      for(; ; ){
        if(turn==1){
          for(int i=1 ; i<=2*n ; i++){
            if(i>max && ha[i]==1){
              h--;
              max=i ;
              ha[i]=0 ;
              reset=1 ;
              break ;
            }
          }
          turn=0 ;
          if(reset==0)max=0 ;
        }
        else if(turn==0){
          for(int i=1 ; i<=2*n ; i++)if(i>max && ta[i]==1){
            t--;
            max=i ;
            ta[i]=0 ;
            reset=0 ;
            break ;
          }
          turn=1 ;
          if(reset==1)max=0 ;
        }
        if(h==0 || t==0)break ;
      }
      System.out.println(h);
      System.out.println(t);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var ta : Sequence(int) ; ta := Integer.subrange(1,(2 * n) + 1)->collect(0) ;
    var ha : Sequence(int) ; ha := Integer.subrange(1,(2 * n) + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     ta[in.getCurrent()->toInteger()+1] := ta[in.getCurrent()->toInteger()+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 2 * n do (     if (ta[i+1] = 0) then     ha[i+1] := ha[i+1] + 1 ; else skip ;  ;     i := i + 1 ) ; 
    var max : int ; max := -1 ;
        var i : int ; i := 1 ; while i <= 2 * n do ( (     if (ta[i+1] = 1) then (     ta[i+1] := 0 ; 
     max := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var turn : int ; turn := 1 ;
    var t : int ; t := n - 1 ;
    var h : int ; h := n ;
    var reset : int ; reset := 0 ;
      while true do ( (     if (turn = 1) then (         var i : int ; i := 1 ; while i <= 2 * n do ( (     if (i > max & ha[i+1] = 1) then (     h := h - 1 ; 
     max := i ; 
    ha[i+1] := 0 ; 
    reset := 1 ; 
    break 
 ) else skip )  ;     i := i + 1 ) ; 
     turn := 0 ; 
     if (reset = 0) then     max := 0 ; else skip ) else     if (turn = 0) then (         var i : int ; i := 1 ; while i <= 2 * n do (     if (i > max & ta[i+1] = 1) then (     t := t - 1 ; 
     max := i ; 
    ta[i+1] := 0 ; 
    reset := 0 ; 
    break 
 ) else skip ;  ;     i := i + 1 ) ; 
     turn := 1 ; 
     if (reset = 1) then     max := 0 ; else skip ) else skip ; ;  
     if (h = 0 or t = 0) then     break else skip )  ) ; 
    OclFile["System.out"].println(h) ; 
    OclFile["System.out"].println(t) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      boolean[] taro=new boolean[2*n+1],hanako=new boolean[2*n+1];
      fill(hanako,true);
      hanako[0]=false ;
      for(int i=0 ; i<n ; i++){
        int a=sc.nextInt();
        taro[a]=true ;
        hanako[a]=false ;
      }
      int t=n,h=n,v=0 ;
      int tp=0,hp=0 ;
      boolean isTaro=true ;
      for(; t>0 && h>0 ; ){
        int i=v+1 ;
        if(isTaro){
          for(; i<=2*n ; i++)if(taro[i]){
            taro[i]=false ;
            v=i ;
            isTaro ^=true ;
            t--;
            break ;
          }
        }
        else {
          for(; i<=2*n ; i++)if(hanako[i]){
            hanako[i]=false ;
            v=i ;
            isTaro ^=true ;
            h--;
            break ;
          }
        }
        if(i==2*n+1){
          isTaro ^=true ;
          v=0 ;
        }
      }
      System.out.println(h);
      System.out.println(t);
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var taro : Sequence(boolean) ; taro := Integer.subrange(1,2 * n + 1)->collect(false) ;
    var hanako : Sequence(boolean) ; hanako := Integer.subrange(1,2 * n + 1)->collect(false) ;
    execute fill(hanako, true) ; 
    hanako[0+1] := false ; 
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     taro[a+1] := true ; 
     hanako[a+1] := false )  ;     i := i + 1 ) ; 
    var t : int ; t := n ;
    var h : int ; h := n ;
    var v : int ; v := 0 ;
    var tp : int ; tp := 0 ;
    var hp : int ; hp := 0 ;
    var isTaro : boolean ; isTaro := true ;
      while t > 0 & h > 0 do ( (     var i : int ; i := v + 1 ;
     if (isTaro) then (       while i <= 2 * n do (     if (taro[i+1]) then (     taro[i+1] := false ; 
     v := i ; 
    isTaro := MathLib.bitwiseXor(isTaro,true) ; 
    t := t - 1 ; 
    break 
 ) else skip ;  ;     i := i + 1 ) ) else (       while i <= 2 * n do (     if (hanako[i+1]) then (     hanako[i+1] := false ; 
     v := i ; 
    isTaro := MathLib.bitwiseXor(isTaro,true) ; 
    h := h - 1 ; 
    break 
 ) else skip ;  ;     i := i + 1 ) ) ;  
     if (i = 2 * n + 1) then (     isTaro := MathLib.bitwiseXor(isTaro,true) ; 
     v := 0 ) else skip )  ) ; 
    OclFile["System.out"].println(h) ; 
    OclFile["System.out"].println(t) ; 
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    int n ;
    int taro[]=new int[200];
    int hanako[]=new int[200];
    int a ;
    int field ;
    int faze ;
    boolean flag ;
    int taroCount,hanakoCount ;
    n=scanner.nextInt();
    while(n!=0){
      for(int i=0 ; i<2*n ; i++){
        taro[i]=0 ;
        hanako[i]=1 ;
      }
      for(int i=0 ; i<n ; i++){
        a=scanner.nextInt();
        taro[a-1]=1 ;
        hanako[a-1]=0 ;
      }
      field=0 ;
      faze=1 ;
      flag=true ;
      taroCount=n ;
      hanakoCount=n ;
      while(flag){
        if(faze==1){
          for(; field<2*n ; field++){
            if(taro[field]==1){
              taro[field]=0 ;
              faze=0 ;
              taroCount--;
              break ;
            }
          }
          if(taroCount==0){
            flag=false ;
          }
          if(2*n<=field){
            faze=0 ;
            field=0 ;
          }
        }
        else {
          for(; field<2*n ; field++){
            if(hanako[field]==1){
              hanako[field]=0 ;
              faze=1 ;
              hanakoCount--;
              break ;
            }
          }
          if(hanakoCount==0){
            flag=false ;
          }
          if(2*n<=field){
            faze=1 ;
            field=0 ;
          }
        }
      }
      System.out.println(hanakoCount);
      System.out.println(taroCount);
      n=scanner.nextInt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var taro : Sequence(int) ; taro := Integer.subrange(1,200)->collect(0) ;
    var hanako : Sequence(int) ; hanako := Integer.subrange(1,200)->collect(0) ;
    var a : int ;
    var field : int ;
    var faze : int ;
    var flag : boolean ;
    var taroCount : int ;
    var hanakoCount : int ;
    n := scanner.getCurrent()->toInteger() ; 
    while (n /= 0) do (         var i : int ; i := 0 ; while i < 2 * n do ( (     taro[i+1] := 0 ; 
     hanako[i+1] := 1 )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     a := scanner.getCurrent()->toInteger() ; 
     taro[a - 1+1] := 1 ; 
     hanako[a - 1+1] := 0 )  ;     i := i + 1 ) ; 
    field := 0 ; 
    faze := 1 ; 
    flag := true ; 
    taroCount := n ; 
    hanakoCount := n ; 
    while (flag) do (     if (faze = 1) then (       while field < 2 * n do ( (     if (taro[field+1] = 1) then (     taro[field+1] := 0 ; 
     faze := 0 ; 
     taroCount := taroCount - 1 ; 
     break ) else skip )  ;     field := field + 1 ) ; 
     if (taroCount = 0) then (     flag := false ) else skip ; 
     if (2 * n <= field) then (     faze := 0 ; 
     field := 0 ) else skip ) else (       while field < 2 * n do ( (     if (hanako[field+1] = 1) then (     hanako[field+1] := 0 ; 
     faze := 1 ; 
     hanakoCount := hanakoCount - 1 ; 
     break ) else skip )  ;     field := field + 1 ) ; 
     if (hanakoCount = 0) then (     flag := false ) else skip ; 
     if (2 * n <= field) then (     faze := 1 ; 
     field := 0 ) else skip ) ) ; 
    OclFile["System.out"].println(hanakoCount) ; 
    OclFile["System.out"].println(taroCount) ; 
    n := scanner.getCurrent()->toInteger() ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.TreeSet ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=parseInt(line);
      if(n==0){
        break ;
      }
      boolean[] cards=new boolean[2*n+1];
      TreeSet<Integer>taro,hana,turn ;
      taro=new TreeSet<Integer>();
      hana=new TreeSet<Integer>();
      for(int i=0 ; i<n ; i++){
        cards[Integer.parseInt(br.readLine())]=true ;
      }
      for(int i=1 ; i<cards.length ; i++){
        if(cards[i]){
          taro.add(i);
        }
        else {
          hana.add(i);
        }
      }
      int deck=0 ;
      turn=taro ;
      while(true){
        if(turn.ceiling(deck)!=null){
          deck=turn.ceiling(deck);
          turn.remove(deck);
        }
        else {
          deck=0 ;
        }
        if(turn.size()==0){
          break ;
        }
        if(turn==taro){
          turn=hana ;
        }
        else {
          turn=taro ;
        }
      }
      System.out.println(hana.size()+"\n"+taro.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := parseInt(line) ;
     if (n = 0) then (     break ) else skip ; 
    var cards : Sequence(boolean) ; cards := Integer.subrange(1,2 * n + 1)->collect(false) ;
    var taro : Set(int) ;
    var hana : Set(int) ;
    var turn : Set(int) ;
    taro := Set{} ; 
    hana := Set{} ; 
        var i : int ; i := 0 ; while i < n do ( (     cards[(br.readLine())->toInteger()+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < cards->size() do ( (     if (cards[i+1]) then (     taro->excludes(i) ) else (     hana->excludes(i) ) )  ;     i := i + 1 ) ; 
    var deck : int ; deck := 0 ;
    turn := taro ; 
    while (true) do (     if (turn.ceiling(deck) /= null) then (     deck := turn.ceiling(deck) ; 
     turn := turn->excludingAt(deck+1) ) else (     deck := 0 ) ;  
     if (turn->size() = 0) then (     break ) else skip ; 
     if (turn = taro) then (     turn := hana ) else (     turn := taro ) ) ; 
    OclFile["System.out"].println(hana->size() + "\n" + taro->size()) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class WorkingWeek {
  public static void main(String[] args){
    Kattio io=new Kattio();
    int T=io.nextInt();
    for(int i=0 ; i<T ; i++){
      io.println((io.nextInt()-6)/3);
    }
    io.close();
  }
  static class Kattio extends PrintWriter {
    private BufferedReader r ;
    private StringTokenizer st ;
    public Kattio(){
      this(System.in,System.out);
    }
    public Kattio(InputStream i,OutputStream o){
      super(o);
      r=new BufferedReader(new InputStreamReader(i));
    }
    public Kattio(String problemName)throws IOException {
      super(problemName+".out");
      r=new BufferedReader(new FileReader(problemName+".in"));
    }
    public String next(){
      try {
        while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(r.readLine());
        return st.nextToken();
      }
      catch(Exception e){
      }
      return null ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class WorkingWeek {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : Kattio ; io := Kattio.newKattio() ;
     var T : int ; T := io.nextInt() ;
         var i : int ; i := 0 ; while i < T do ( (     io.println((io.nextInt() - 6) / 3) )  ;     i := i + 1 ) ; 
     io.close() );
  static class Kattio extends OclFile {
   attribute r : OclFile;
   attribute st : OclIterator;
   static operation newKattio() : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile["System.in"], OclFile["System.out"]) );
   static operation newKattio( i : OclFile, o : OclFile) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(i, o);
    return self );
  operation initialise( i : OclFile, o : OclFile) : void
  pre: true  post: true
  activity: (     execute super(o) ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(i)) );
   static operation newKattio( problemName : String) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(problemName);
    return self );
  operation initialise( problemName : String) : void
  pre: true  post: true
  activity: (     execute super(problemName + ".out") ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(problemName + ".in")) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(r.readLine()) ; ; 
     return st.next() )   catch (e : ProgramException) do skip
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] $){
    int n=scanner.nextInt();
    int m=n*3 ;
    long[] a=new long[m];
    for(int i=0 ; i<m ; i++){
      a[i]=scanner.nextInt();
    }
    PriorityQueue<Long>queue=new PriorityQueue<>();
    long[] max=new long[n+1];
    long sum=0 ;
    for(int i=0 ; i<m ; i++){
      queue.add(a[i]);
      if(i>=n && i<=n*2){
        max[i-n]=sum ;
        sum-=queue.poll();
      }
      sum+=a[i];
    }
    queue=new PriorityQueue<>(Comparator.reverseOrder());
    long[] min=new long[n+1];
    sum=0 ;
    for(int i=m ; i>0 ; i--){
      queue.add(a[i-1]);
      if(i>=n && i<=n*2){
        min[i-n]=sum ;
        sum-=queue.poll();
      }
      sum+=a[i-1];
    }
    long ans=Long.MIN_VALUE ;
    for(int i=0 ; i<=n ; i++){
      ans=Math.max(ans,max[i]-min[i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := n * 3 ;
    var a : Sequence(long) ; a := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var queue : Sequence(long) ; queue := Sequence{} ;
    var max : Sequence(long) ; max := Integer.subrange(1,n + 1)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     queue := queue->including(a[i+1]) ; 
     if (i >= n & i <= n * 2) then (     max[i - n+1] := sum ; 
     sum := sum - (queue->min()) ;     queue := queue->sort()->tail() ) else skip ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    queue := Sequence{}->union(Comparator.reverseOrder()) ; 
    var min : Sequence(long) ; min := Integer.subrange(1,n + 1)->collect(0) ;
    sum := 0 ; 
        var i : int ; i := m ; while i > 0 do ( (     queue := queue->including(a[i - 1+1]) ; 
     if (i >= n & i <= n * 2) then (     min[i - n+1] := sum ; 
     sum := sum - (queue->min()) ;     queue := queue->sort()->tail() ) else skip ; 
     sum := sum+(a[i - 1+1]) )  ;     i := i - 1 ) ; 
    var ans : long ; ans := "-9223372036854775808"->toLong() ;
        var i : int ; i := 0 ; while i <= n do ( (     ans := Set{ans, max[i+1] - min[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solveD();
  }
  private void solveD(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    List<Long>list=new ArrayList<>();
    for(int i=0 ; i<3*N ; i++){
      list.add(sc.nextLong());
    }
    List<Long>maxSumList=getSumList(list,new PriorityQueue<>(Comparator.naturalOrder()),N);
    Collections.reverse(list);
    List<Long>minSumList=getSumList(list,new PriorityQueue<>(Comparator.reverseOrder()),N);
    List<Long>scoreList=new ArrayList<>();
    for(int splitIndex=N ; splitIndex<=2*N ; splitIndex++){
      scoreList.add(maxSumList.get(splitIndex-1)-minSumList.get(3*N-1-splitIndex));
    }
    System.out.println(scoreList.stream().max(Comparator.naturalOrder()).get());
  }
  private List<Long>getSumList(List<Long>list,PriorityQueue<Long>queue,int limitSize){
    List<Long>sumList=new ArrayList<>();
    long sum=0L ;
    for(long value : list){
      queue.add(value);
      sum+=value ;
      if(queue.size()>limitSize){
        sum-=queue.remove();
      }
      sumList.add(sum);
    }
    return sumList ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solveD() );
   operation solveD() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var list : Sequence(long) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < 3 * N do ( (     list := list->including(sc.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    var maxSumList : Sequence(long) ; maxSumList := getSumList(list, Sequence{}->union(Comparator.naturalOrder()), N) ;
    list := list->reverse() ; 
    var minSumList : Sequence(long) ; minSumList := getSumList(list, Sequence{}->union(Comparator.reverseOrder()), N) ;
    var scoreList : Sequence(long) ; scoreList := Sequence{} ;
        var splitIndex : int ; splitIndex := N ; while splitIndex <= 2 * N do ( (     scoreList := scoreList->including(maxSumList->at(splitIndex - 1+1) - minSumList->at(3 * N - 1 - splitIndex+1)) )  ;     splitIndex := splitIndex + 1 ) ; 
    OclFile["System.out"].println(scoreList->max().get()) ; 
 );
   operation getSumList( list : Sequence(long), queue : Sequence(long), limitSize : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var sumList : Sequence(long) ; sumList := Sequence{} ;
     var sum : long ; sum := 0L ;
     for (value : list) do ( (     queue->excludes(value) ; 
     sum := sum+(value) ; 
     if (queue->size() > limitSize) then (     sum := sum - (queue.remove()) ;     queue := queue.remove() ) else skip ; 
     sumList := sumList->including(sum) )  ) ; 
     return sumList );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    PriorityQueue<Long>left=new PriorityQueue<>(n);
    long[] center=new long[n];
    PriorityQueue<Long>right=new PriorityQueue<>((l1,l2)->{
      return l2.compareTo(l1);
    }
);
    for(int i=0 ; i<n ; i++){
      left.add(sc.nextLong());
    }
    for(int i=0 ; i<n ; i++){
      center[i]=sc.nextLong();
    }
    for(int i=0 ; i<n ; i++){
      right.add(sc.nextLong());
    }
    long[] lmove=new long[n+1];
    lmove[0]=left.stream().mapToLong(i->i).sum();
    long[] rmove=new long[n+1];
    rmove[0]=right.stream().mapToLong(i->i).sum();
    for(int i=0 ; i<n ; i++){
      left.add(center[i]);
      lmove[i+1]=lmove[i]-left.poll()+center[i];
    }
    for(int i=0 ; i<n ; i++){
      right.add(center[n-1-i]);
      rmove[i+1]=rmove[i]-right.poll()+center[n-1-i];
    }
    long ans=Long.MIN_VALUE ;
    for(int i=0 ; i<=n ; i++){
      long temp=lmove[i]-rmove[n-i];
      ans=Math.max(temp,ans);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var left : Sequence(long) ; left := Sequence{} ;
    var center : Sequence(long) ; center := Integer.subrange(1,n)->collect(0) ;
    var right : Sequence(long) ; right := Sequence{}->union(lambda (l1 , l2) : OclAny in (     return l2->compareTo(l1) )) ;
        var i : int ; i := 0 ; while i < n do ( (     left := left->including(sc.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     center[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     right := right->including(sc.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    var lmove : Sequence(long) ; lmove := Integer.subrange(1,n + 1)->collect(0) ;
    lmove[0+1] := left->collect( _x1 | (lambda i : OclAny in i)->apply(_x1) )->sum() ; 
    var rmove : Sequence(long) ; rmove := Integer.subrange(1,n + 1)->collect(0) ;
    rmove[0+1] := right->collect( _x1 | (lambda i : OclAny in i)->apply(_x1) )->sum() ; 
        var i : int ; i := 0 ; while i < n do ( (     left := left->including(center[i+1]) ; 
     lmove[i + 1+1] := lmove[i+1] - left->min() + center[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     right := right->including(center[n - 1 - i+1]) ; 
     rmove[i + 1+1] := rmove[i+1] - right->min() + center[n - 1 - i+1] )  ;     i := i + 1 ) ; 
    var ans : long ; ans := "-9223372036854775808"->toLong() ;
        var i : int ; i := 0 ; while i <= n do ( (     var temp : long ; temp := lmove[i+1] - rmove[n - i+1] ;
     ans := Set{temp, ans}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  Set<String>words ;
  String make(char s,char t){
    String x=s+""+t ;
    if(! words.contains(x))return x ;
    for(int i=0 ; i<26 ; i++){
      String r=s+""+((char)(i+'a'))+t+"" ;
      if(! words.contains(r))return r ;
    }
    return s+"a"+t ;
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    words=new HashSet<String>();
    System.out.println("?a");
    System.out.flush();
    words.add("a");
    while(true){
      String res=sc.next();
      if(res.length()==1 || res.charAt(0)!='a' || words.contains(res)){
        System.out.println("!OUT");
        System.out.flush();
        break ;
      }
      words.add(res);
      char h=res.charAt(1);
      String n=make(h,'a');
      words.add(n);
      System.out.println("?"+n);
      System.out.flush();
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute words : Set(String);
   operation make( s : String, t : String) : String
  pre: true
  post: true
  activity: (     var x : String ; x := s + "" + t ;
     if (not(words->includes(x))) then     return x else skip ; 
         var i : int ; i := 0 ; while i < 26 do ( (     var r : String ; r := s + "" + ((i + 'a')->oclAsType(String)) + t + "" ;
     if (not(words->includes(r))) then     return r else skip )  ;     i := i + 1 ) ; 
     return s + "a" + t );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     words := Set{} ; 
    OclFile["System.out"].println("?a") ; 
    OclFile["System.out"].flush() ; 
    words := words->including("a") ; 
    while (true) do (     var res : String ; res := sc.getCurrent() ;
     if (res->size() = 1 or res->at(0+1) /= 'a' or words->includes(res)) then (     OclFile["System.out"].println("!OUT") ; 
     OclFile["System.out"].flush() ; 
     break ) else skip ; 
    words := words->including(res) ; 
    var h : String ; h := res->at(1+1) ;
    var n : String ; n := make(h, 'a') ;
    words := words->including(n) ; 
    OclFile["System.out"].println("?" + n) ; 
    OclFile["System.out"].flush() ; 
 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=scan.nextInt();
    long[] A=new long[3*N];
    for(int i=0 ; i<3*N ; i++){
      A[i]=scan.nextLong();
    }
    PriorityQueue<Long>red_queue=new PriorityQueue<>(Comparator.naturalOrder());
    long red_sum=0 ;
    for(int i=0 ; i<N ; i++){
      red_sum+=A[i];
      red_queue.add(A[i]);
    }
    PriorityQueue<Long>blue_queue=new PriorityQueue<>(Comparator.reverseOrder());
    long blue_sum=0 ;
    for(int i=2*N ; i<3*N ; i++){
      blue_sum+=A[i];
      blue_queue.add(A[i]);
    }
    long[] red_holder=new long[N+1];
    long[] blue_holder=new long[N+1];
    red_holder[0]=red_sum ;
    for(int i=1 ; i<=N ; i++){
      red_queue.add(A[N+i-1]);
      red_sum+=A[N+i-1];
      red_sum-=red_queue.poll();
      red_holder[i]=red_sum ;
    }
    blue_holder[0]=blue_sum ;
    for(int i=1 ; i<=N ; i++){
      blue_queue.add(A[N+N-i]);
      blue_sum+=A[N+N-i];
      blue_sum-=blue_queue.poll();
      blue_holder[i]=blue_sum ;
    }
    long ans=Long.MIN_VALUE ;
    for(int i=0 ; i<=N ; i++){
      ans=Math.max(ans,red_holder[i]-blue_holder[N-i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var A : Sequence(long) ; A := Integer.subrange(1,3 * N)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 * N do ( (     A[i+1] := scan.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var red_queue : Sequence(long) ; red_queue := Sequence{}->union(Comparator.naturalOrder()) ;
    var red_sum : long ; red_sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     red_sum := red_sum+(A[i+1]) ; 
     red_queue := red_queue->including(A[i+1]) )  ;     i := i + 1 ) ; 
    var blue_queue : Sequence(long) ; blue_queue := Sequence{}->union(Comparator.reverseOrder()) ;
    var blue_sum : long ; blue_sum := 0 ;
        var i : int ; i := 2 * N ; while i < 3 * N do ( (     blue_sum := blue_sum+(A[i+1]) ; 
     blue_queue := blue_queue->including(A[i+1]) )  ;     i := i + 1 ) ; 
    var red_holder : Sequence(long) ; red_holder := Integer.subrange(1,N + 1)->collect(0) ;
    var blue_holder : Sequence(long) ; blue_holder := Integer.subrange(1,N + 1)->collect(0) ;
    red_holder[0+1] := red_sum ; 
        var i : int ; i := 1 ; while i <= N do ( (     red_queue := red_queue->including(A[N + i - 1+1]) ; 
     red_sum := red_sum+(A[N + i - 1+1]) ; 
     red_sum := red_sum - (red_queue->min()) ;     red_queue := red_queue->sort()->tail() ; 
     red_holder[i+1] := red_sum )  ;     i := i + 1 ) ; 
    blue_holder[0+1] := blue_sum ; 
        var i : int ; i := 1 ; while i <= N do ( (     blue_queue := blue_queue->including(A[N + N - i+1]) ; 
     blue_sum := blue_sum+(A[N + N - i+1]) ; 
     blue_sum := blue_sum - (blue_queue->min()) ;     blue_queue := blue_queue->sort()->tail() ; 
     blue_holder[i+1] := blue_sum )  ;     i := i + 1 ) ; 
    var ans : long ; ans := "-9223372036854775808"->toLong() ;
        var i : int ; i := 0 ; while i <= N do ( (     ans := Set{ans, red_holder[i+1] - blue_holder[N - i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Comparator ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    long[] a=new long[n*3];
    for(int i=0 ; i<3*n ; ++i){
      a[i]=scanner.nextLong();
    }
    final PriorityQueue<Long>firstHalf=new PriorityQueue<>();
    final PriorityQueue<Long>secondHalf=new PriorityQueue<>(Comparator.reverseOrder());
    long[] leftSum=new long[n+1];
    long[] rightSum=new long[n+1];
    for(int i=0 ; i<n ; ++i){
      firstHalf.add(a[i]);
      leftSum[0]+=a[i];
    }
    for(int i=n ; i<2*n ; ++i){
      firstHalf.add(a[i]);
      long head=firstHalf.poll();
      leftSum[i-n+1]=leftSum[i-n]+a[i]-head ;
    }
    for(int i=3*n-1 ; i>=2*n ; --i){
      secondHalf.add(a[i]);
      rightSum[n]+=a[i];
    }
    for(int i=2*n-1 ; i>=n ; --i){
      secondHalf.add(a[i]);
      long head=secondHalf.poll();
      rightSum[i-n]=rightSum[i-n+1]+a[i]-head ;
    }
    long result=Long.MIN_VALUE ;
    for(int i=0 ; i<=n ; ++i){
      result=Math.max(result,leftSum[i]-rightSum[i]);
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n * 3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 * n do ( (     a[i+1] := scanner.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var firstHalf : Sequence(long) ; firstHalf := Sequence{} ;
    var secondHalf : Sequence(long) ; secondHalf := Sequence{}->union(Comparator.reverseOrder()) ;
    var leftSum : Sequence(long) ; leftSum := Integer.subrange(1,n + 1)->collect(0) ;
    var rightSum : Sequence(long) ; rightSum := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     firstHalf := firstHalf->including(a[i+1]) ; 
     leftSum[0+1] := leftSum[0+1]+(a[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := n ; while i < 2 * n do ( (     firstHalf := firstHalf->including(a[i+1]) ; 
     var head : long ; head := firstHalf->min() ;
     leftSum[i - n + 1+1] := leftSum[i - n+1] + a[i+1] - head )  ;     i := i + 1 ) ; 
        var i : int ; i := 3 * n - 1 ; while i >= 2 * n do ( (     secondHalf := secondHalf->including(a[i+1]) ; 
     rightSum[n+1] := rightSum[n+1]+(a[i+1]) )  ;     i := i - 1 ) ; 
        var i : int ; i := 2 * n - 1 ; while i >= n do ( (     secondHalf := secondHalf->including(a[i+1]) ; 
     var head : long ; head := secondHalf->min() ;
     rightSum[i - n+1] := rightSum[i - n + 1+1] + a[i+1] - head )  ;     i := i - 1 ) ; 
    var result : long ; result := "-9223372036854775808"->toLong() ;
        var i : int ; i := 0 ; while i <= n do ( (     result := Set{result, leftSum[i+1] - rightSum[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int n,q ;
  public static int[] S=new int[100001];
  public static int[] T=new int[50001];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      S[i]=sc.nextInt();
    }
    q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      T[i]=sc.nextInt();
    }
    int cnt=0 ;
    for(int i=0 ; i<q ; i++){
      if(binarySearch(T[i])){
        cnt++;
      }
    }
    System.out.println(cnt);
  }
  public static boolean binarySearch(int key){
    int left=0,right=n ;
    int mid ;
    while(left<right){
      mid=(left+right)/2 ;
      if(S[mid]==key){
        return true ;
      }
      else if(key<S[mid]){
        right=mid ;
      }
      else {
        left=mid+1 ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute S : Sequence(int) := Integer.subrange(1,100001)->collect(0);
  static   attribute T : Sequence(int) := Integer.subrange(1,50001)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     S[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    q := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < q do ( (     T[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < q do ( (     if (binarySearch(T[i+1])) then (     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
  static   operation binarySearch( key : int) : boolean
  pre: true
  post: true
  activity: (     var left : int ; left := 0 ;
    var right : int ; right := n ;
     var mid : int ;
     while (left < right) do (     mid := (left + right) / 2 ; 
     if (S[mid+1] = key) then (     return true ) else     if (key < S[mid+1]) then (     right := mid ) else (     left := mid + 1 ) ;  ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.stream.Stream ;
public class Main {
  public static boolean find(int[] ary,int searchNum){
    int start=0 ;
    int end=ary.length-1 ;
    while(start<=end){
      int pivot=start+(end-start)/2 ;
      if(ary[pivot]<searchNum){
        start=pivot+1 ;
      }
      else if(ary[pivot]>searchNum){
        end=pivot-1 ;
      }
      else {
        return true ;
      }
    }
    return false ;
  }
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int[] S=Stream.of(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    int q=Integer.parseInt(br.readLine());
    int[] T=Stream.of(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    int count=0 ;
    for(int i=0 ; i<q ; i++){
      if(find(S,T[i])){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation find( ary : Sequence(int), searchNum : int) : boolean
  pre: true
  post: true
  activity: (     var start : int ; start := 0 ;
     var end : int ; end := ary->size() - 1 ;
     while (start <= end) do (     var pivot : int ; pivot := start + (end - start) / 2 ;
     if (ary[pivot+1] < searchNum) then (     start := pivot + 1 ) else     if (ary[pivot+1] > searchNum) then (     end := pivot - 1 ) else (     return true ) ;  ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var S : Sequence(int) ; S := Sequence{br.readLine()->split(" ")}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var q : int ; q := (br.readLine())->toInteger() ;
    var T : Sequence(int) ; T := Sequence{br.readLine()->split(" ")}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < q do ( (     if (find(S, T[i+1])) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static boolean search(int[] A,int n,int key){
    A[n]=key ;
    int i=0 ;
    while(A[i]!=key)i++;
    return i!=n ;
  }
  public static boolean binarySearch(int[] A,int n,int key){
    int left=0 ;
    int right=n ;
    int mid=0 ;
    while(left<right){
      mid=(left+right)/2 ;
      if(key==A[mid])return true ;
      else if(key>A[mid])left=mid+1 ;
      else if(key<A[mid])right=mid ;
    }
    return false ;
  }
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int[] arrayS=new int[100000];
    int[] arrayT=new int[50000];
    int count=0 ;
    int sNum=scan.nextInt();
    for(int i=0 ; i<sNum ; i++)arrayS[i]=scan.nextInt();
    int tNum=scan.nextInt();
    for(int j=0 ; j<tNum ; j++)arrayT[j]=scan.nextInt();
    for(int j=0 ; j<tNum ; j++)if(binarySearch(arrayS,sNum,arrayT[j]))count++;
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation search( A : Sequence(int), n : int, key : int) : boolean
  pre: true
  post: true
  activity: (     A[n+1] := key ; 
     var i : int ; i := 0 ;
     while (A[i+1] /= key) do     i := i + 1 ; ; 
     return i /= n );
  static   operation binarySearch( A : Sequence(int), n : int, key : int) : boolean
  pre: true
  post: true
  activity: (     var left : int ; left := 0 ;
     var right : int ; right := n ;
    var mid : int ; mid := 0 ;
    while (left < right) do (     mid := (left + right) / 2 ; 
     if (key = A[mid+1]) then     return true else     if (key > A[mid+1]) then     left := mid + 1 else     if (key < A[mid+1]) then     right := mid ; else skip ; ;  ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arrayS : Sequence(int) ; arrayS := Integer.subrange(1,100000)->collect(0) ;
    var arrayT : Sequence(int) ; arrayT := Integer.subrange(1,50000)->collect(0) ;
    var count : int ; count := 0 ;
    var sNum : int ; sNum := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < sNum do (     arrayS[i+1] := scan.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var tNum : int ; tNum := scan.getCurrent()->toInteger() ;
        var j : int ; j := 0 ; while j < tNum do (     arrayT[j+1] := scan.getCurrent()->toInteger() ;  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < tNum do (     if (binarySearch(arrayS, sNum, arrayT[j+1])) then     count := count + 1 ; else skip ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      int[] S=new int[n];
      for(int i=0 ; i<n ; i++){
        S[i]=sc.nextInt();
      }
      int q=sc.nextInt();
      int[] T=new int[q];
      for(int i=0 ; i<q ; i++){
        T[i]=sc.nextInt();
      }
      Arrays.sort(T);
      int ans=0 ;
      for(int i=0,j=0 ; i<n && j<q ; i++){
        if(S[i]==T[j]){
          ans++;
          j++;
        }
        else if(S[i]>T[j]){
          i--;
          j++;
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var S : Sequence(int) ; S := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     S[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var T : Sequence(int) ; T := Integer.subrange(1,q)->collect(0) ;
        var i : int ; i := 0 ; while i < q do ( (     T[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    T := T->sort() ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ;
    var j : int ; j := 0 ; while i < n & j < q do ( (     if (S[i+1] = T[j+1]) then (     ans := ans + 1 ; 
     j := j + 1 ) else     if (S[i+1] > T[j+1]) then (     i := i - 1 ; 
     j := j + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public Main(){
  }
  public static void main(String[] args){
    Main main=new Main();
    main.exec();
  }
  public void exec(){
    BufferedReader bf=null ;
    try {
      bf=new BufferedReader(new InputStreamReader(System.in));
      exec_body(bf);
    }
    catch(IOException e){
      e.printStackTrace();
    }
    finally {
      if(bf!=null){
        try {
          bf.close();
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
    }
  }
  public void exec_body(BufferedReader bf)throws IOException {
    bf.readLine();
    int[] sAry=toList(bf.readLine(),false);
    bf.readLine();
    int[] tAry=toList(bf.readLine(),false);
    int cnt=0 ;
    for(int tVal : tAry){
      int left=0 ;
      int right=sAry.length-1 ;
      while(left<=right){
        int middle=(left+right)/2 ;
        int middleVal=sAry[middle];
        if(middleVal==tVal){
          cnt++;
          break ;
        }
        else if(middleVal>tVal){
          right=middle-1 ;
        }
        else if(middleVal<tVal){
          left=middle+1 ;
        }
      }
    }
    System.out.println(cnt);
  }
  public int[] toList(String str,boolean isBanhei){
    String[] elements=str.split(" ");
    int arysize=elements.length+((isBanhei)? 1 : 0);
    int[] ret=new int[arysize];
    for(int i=0 ; i<elements.length ; i++){
      ret[i]=Integer.valueOf(elements[i]);
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.exec() );
   operation exec() : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := null ;
     try (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     execute exec_body(bf) )   catch (e : IOException) do (     e.printStackTrace() )
   finally (     if (bf /= null) then (     try (     skip )   catch (e : IOException) do (     e.printStackTrace() )
 ) else skip )
 );
   operation exec_body( bf : OclFile) : void
  pre: true
  post: true
  activity: (     skip ; 
     var sAry : Sequence(int) ; sAry := toList(bf.readLine(), false) ;
    skip ; 
    var tAry : Sequence(int) ; tAry := toList(bf.readLine(), false) ;
    var cnt : int ; cnt := 0 ;
    for (tVal : tAry) do ( (     var left : int ; left := 0 ;
     var right : int ; right := sAry->size() - 1 ;
     while (left <= right) do (     var middle : int ; middle := (left + right) / 2 ;
     var middleVal : int ; middleVal := sAry[middle+1] ;
     if (middleVal = tVal) then (     cnt := cnt + 1 ; 
     break ) else     if (middleVal > tVal) then (     right := middle - 1 ) else     if (middleVal < tVal) then (     left := middle + 1 ) else skip ; ;  ) )  ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
   operation toList( str : String, isBanhei : boolean) : Sequence(int)
  pre: true
  post: true
  activity: (     var elements : Sequence(String) ; elements := str->split(" ") ;
     var arysize : int ; arysize := elements->size() + (if (isBanhei) then 1 else 0 endif) ;
    var ret : Sequence(int) ; ret := Integer.subrange(1,arysize)->collect(0) ;
        var i : int ; i := 0 ; while i < elements->size() do ( (     ret[i+1] := (elements[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class code {
  public static void main(String[] agr){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    while(t>0){
      t--;
      int n=input.nextInt();
      int ans ;
      ans=(n-3)/3-1 ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class code {
  static   operation main( agr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
     while (t > 0) do (     t := t - 1 ; 
     var n : int ; n := input.getCurrent()->toInteger() ;
    var ans : int ;
    ans := (n - 3) / 3 - 1 ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class VasyaAndBooks {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      long f=0,s=0 ;
      long n=in.nextLong();
      long x=in.nextLong();
      long y=in.nextLong();
      long d=in.nextLong();
      if(Math.abs(x-y)% d==0)System.out.println(Math.abs(x-y)/d);
      else {
        if((y-1)% d==0)f=(x+y+d-3)/d ;
        if((n-y)% d==0)s=(2*n-x-y+d-1)/d ;
        if(f>0 && s>0)f=Math.min(f,s);
        else f=Math.max(f,s);
        if(f>0)System.out.println(f);
        else System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class VasyaAndBooks {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var f : long ; f := 0 ;
    var s : long ; s := 0 ;
     var n : long ; n := in.getCurrent()->toLong() ;
    var x : long ; x := in.getCurrent()->toLong() ;
    var y : long ; y := in.getCurrent()->toLong() ;
    var d : long ; d := in.getCurrent()->toLong() ;
    if (if x - y < 0 then -(x - y) else x - y endif mod d = 0) then     OclFile["System.out"].println(if x - y < 0 then -(x - y) else x - y endif / d) else (     if ((y - 1) mod d = 0) then     f := (x + y + d - 3) / d ; else skip ; 
     if ((n - y) mod d = 0) then     s := (2 * n - x - y + d - 1) / d ; else skip ; 
     if (f > 0 & s > 0) then     f := Set{f, s}->min() else     f := Set{f, s}->max() ; ;  
     if (f > 0) then     OclFile["System.out"].println(f) ; else     OclFile["System.out"].println(-1) ; ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    System.out.println((a+b)/2);
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println((a + b) / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    System.out.println("?a");
    ArrayList<String>list=new ArrayList<String>();
    list.add("a");
    while(true){
      String s=sc.next();
      if(list.contains(s)==true || s.length()==1 || s.charAt(0)!='a'){
        System.out.println("!OUT");
        break ;
      }
      list.add(s);
      if(s.compareTo("aa")==0)System.out.println("?aaa");
      else System.out.println("?"+s.charAt(1)+"a");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println("?a") ; 
    var list : Sequence(String) ; list := Sequence{} ;
    list := list->including("a") ; 
    while (true) do (     var s : String ; s := sc.getCurrent() ;
     if (list->includes(s) = true or s->size() = 1 or s->at(0+1) /= 'a') then (     OclFile["System.out"].println("!OUT") ; 
     break ) else skip ; 
     list := list->including(s) ; 
     if (s->compareTo("aa") = 0) then     OclFile["System.out"].println("?aaa") ; else     OclFile["System.out"].println("?" + s->at(1+1) + "a") ; ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      String str=reader.readLine();
      String s[]=str.split(" ");
      int a=Integer.parseInt(s[0]);
      int b=Integer.parseInt(s[1]);
      int c=(a+b)/2 ;
      System.out.println(c);
      reader.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  static int gcd(int a,int b){
    return b>0 ? gcd(b,a % b): a ;
  }
  static int lcm(int a,int b){
    return a*b/gcd(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var str : String ; str := reader.readLine() ;
     var s : Sequence(String) ; s := str->split(" ") ;
    var a : int ; a := (s[0+1])->toInteger() ;
    var b : int ; b := (s[1+1])->toInteger() ;
    var c : int ; c := (a + b) / 2 ;
    OclFile["System.out"].println(c) ; 
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b > 0 then gcd(b, a mod b) else a endif );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return a * b / gcd(a, b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextInt()){
      int a=sc.nextInt();
      int b=sc.nextInt();
      System.out.println((a+b)/2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextInt()) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println((a + b) / 2) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    line=br.readLine();
    int a,b ;
    a=parseInt(line.substring(0,line.indexOf(' ')));
    b=parseInt(line.substring(line.indexOf(' ')+1));
    System.out.println((a+b)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    line := br.readLine() ; 
    var a : int ;
    var b : int ;
    a := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    b := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    OclFile["System.out"].println((a + b) / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String str=scan.next();
    String str2=scan.next();
    int num0=Integer.parseInt(str);
    int num1=Integer.parseInt(str2);
    System.out.println((num0+num1)/2);
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := scan.getCurrent() ;
    var str2 : String ; str2 := scan.getCurrent() ;
    var num0 : int ; num0 := (str)->toInteger() ;
    var num1 : int ; num1 := (str2)->toInteger() ;
    OclFile["System.out"].println((num0 + num1) / 2) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAX=100 ;
  static int summation(int n){
    return n<<(n-1);
  }
  public static void main(String[] args){
    int n=2 ;
    System.out.println(summation(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100;
  static   operation summation( n : int) : int
  pre: true
  post: true
  activity: (     return (n*(2->pow((n - 1))))->oclAsType(long) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(summation(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=false ;
  private static PrintWriter _err=new PrintWriter(System.err);
  private String[] keys={
    "dreameraser","dreamerase","dreamer","dream","eraser","erase" };
    private void solve(Scanner sc,PrintWriter out){
      String S=sc.nextLine();
      int i=0 ;
      while(i<S.length()){
        boolean found=false ;
        for(int j=0 ; j<keys.length ; ++j){
          int keylen=keys[j] .length();
          if(i+keylen<=S.length()){
            String s=S.substring(i,i+keylen);
            if(s.equals(keys[j])){
              i+=keylen ;
              found=true ;
              break ;
            }
          }
        }
        if(! found){
          break ;
        }
      }
      out.println((i==S.length()? "YES" : "NO"));
    }
    private long C(long n,long r){
      long res=1 ;
      for(long i=n ; i>n-r ; --i){
        res*=i ;
      }
      for(long i=r ; i>1 ; --i){
        res/=i ;
      }
      return res ;
    }
    private long P(long n,long r){
      long res=1 ;
      for(long i=n ; i>n-r ; --i){
        res*=i ;
      }
      return res ;
    }
    public static void main(String[] args){
      long S=System.currentTimeMillis();
      Scanner sc=new Scanner(System.in);
      PrintWriter out=new PrintWriter(System.out);
      new Main().solve(sc,out);
      out.flush();
      long G=System.currentTimeMillis();
      if(elapsed){
        _err.println((G-S)+"ms");
      }
      _err.flush();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := false;
  static   attribute _err : OclFile := OclFile.newOclFile_Write(OclFile["System.err"]);
   attribute keys : Sequence(String) := Sequence{"dreameraser","dreamerase","dreamer","dream","eraser","erase"};
   operation solve( sc : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var S : String ; S := sc.nextLine() ;
     var i : int ; i := 0 ;
     while (i < S->size()) do (     var found : boolean ; found := false ;
         var j : int ; j := 0 ; while j < keys->size() do ( (     var keylen : int ; keylen := keys[j+1]->size() ;
     if (i + keylen <= S->size()) then (     var s : String ; s := S.subrange(i+1,i + keylen) ;
     if (s = keys[j+1]) then (     i := i+(keylen) ; 
     found := true ; 
     break ) else skip ) else skip )  ;     j := j + 1 ) ; 
     if (not(found)) then (     break ) else skip ) ; 
     out.println((if i = S->size() then "YES" else "NO" endif)) );
   operation C( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res*(i) )  ;     i := i - 1 ) ; 
         var i : long ; i := r ; while i > 1 do ( (     res := res/(i) )  ;     i := i - 1 ) ; 
     return res );
   operation P( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res*(i) )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    Main.newMain().solve(sc, out) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String result="NO" ;
    int len=s.length();
    while(len>=0){
      if(len==0){
        result="YES" ;
        break ;
      }
      if(len>=5 && "dream".equals(s.substring(len-5,len))){
        len-=5 ;
        continue ;
      }
      if(len>=5 && "erase".equals(s.substring(len-5,len))){
        len-=5 ;
        continue ;
      }
      if(len>=6 && "eraser".equals(s.substring(len-6,len))){
        len-=6 ;
        continue ;
      }
      if(len>=7 && "dreamer".equals(s.substring(len-7,len))){
        len-=7 ;
        continue ;
      }
      len=-1 ;
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var result : String ; result := "NO" ;
    var len : int ; len := s->size() ;
    while (len >= 0) do (     if (len = 0) then (     result := "YES" ; 
     break ) else skip ; 
     if (len >= 5 & "dream" = s.subrange((len)->char2byte() - 5+1,len)) then (     len := len-(5) ; 
     continue ) else skip ; 
    if (len >= 5 & "erase" = s.subrange((len)->char2byte() - 5+1,len)) then (     len := len-(5) ; 
     continue ) else skip ; 
    if (len >= 6 & "eraser" = s.subrange((len)->char2byte() - 6+1,len)) then (     len := len-(6) ; 
     continue ) else skip ; 
    if (len >= 7 & "dreamer" = s.subrange((len)->char2byte() - 7+1,len)) then (     len := len-(7) ; 
     continue ) else skip ; 
    len := -1 ; 
 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  static final BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  public static void main(String[] args)throws IOException {
    String s=in.readLine();
    in.close();
    int to=s.length();
    String[] words={
      "dream","erase","eraser","dreamer" };
      label : while(to>0){
        for(String w : words){
          if(to>=w.length()&& w.equals(s.substring(to-w.length(),to))){
            to-=w.length();
            continue label ;
          }
        }
        System.out.println("NO");
        return ;
      }
      System.out.println((to==0)? "YES" : "NO");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.readLine() ;
     skip ; 
    var to : int ; to := s->size() ;
    var words : Sequence(String) ; words := Sequence{"dream","erase","eraser","dreamer"} ;
    while (to > 0) do (     for (w : words) do ( (     if (to >= w->size() & w = s.subrange((to)->char2byte() - w->size()+1,to)) then (     to := to-(w->size()) ; 
     continue ) else skip )  ) ; 
     OclFile["System.out"].println("NO") ; 
     return ) ; 
    OclFile["System.out"].println(if (to = 0) then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Link2 {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int m=input.nextInt();
    int n=input.nextInt();
    int pone=0 ;
    int none=0 ;
    int max=0 ;
    int[] arrayOne=new int[m];
    for(int i=0 ; i<m ; i++){
      arrayOne[i]=input.nextInt();
      if(arrayOne[i]==1){
        pone++;
      }
      else if(arrayOne[i]==-1){
        none++;
      }
    }
    for(int i=0 ; i<n ; i++){
      int pone1=0 ;
      int none1=0 ;
      for(int j=i ; j<m ; j+=n){
        if(arrayOne[j]==1){
          pone1+=1 ;
        }
        else if(arrayOne[j]==-1){
          none1+=1 ;
        }
      }
      int b=Math.abs((pone-pone1)-(none-none1));
      if(b>max){
        max=b ;
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Link2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := input.getCurrent()->toInteger() ;
    var n : int ; n := input.getCurrent()->toInteger() ;
    var pone : int ; pone := 0 ;
    var none : int ; none := 0 ;
    var max : int ; max := 0 ;
    var arrayOne : Sequence(int) ; arrayOne := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     arrayOne[i+1] := input.getCurrent()->toInteger() ; 
     if (arrayOne[i+1] = 1) then (     pone := pone + 1 ) else     if (arrayOne[i+1] = -1) then (     none := none + 1 ) else skip ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var pone1 : int ; pone1 := 0 ;
     var none1 : int ; none1 := 0 ;
        var j : int ; j := i ; while j < m do ( (     if (arrayOne[j+1] = 1) then (     pone1 := pone1+(1) ) else     if (arrayOne[j+1] = -1) then (     none1 := none1+(1) ) else skip ; )  ;     j := j+(n) ) ; 
    var b : int ; b := if (pone - pone1) - (none - none1) < 0 then -((pone - pone1) - (none - none1)) else (pone - pone1) - (none - none1) endif ;
    if (b > max) then (     max := b ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String scStr=scanner.nextLine();
    int count=scStr.length()/5 ;
    String dream="dream" ;
    String dreamer="dreamer" ;
    String erase="erase" ;
    String eraser="eraser" ;
    boolean result=false ;
    boolean isEnd=false ;
    for(int i=0 ; i<=count ; i++){
      if(isEnd==true)break ;
      if(scStr.endsWith(dreamer)){
        scStr=scStr.substring(0,scStr.length()-7);
      }
      else if(scStr.endsWith(dream)){
        scStr=scStr.substring(0,scStr.length()-5);
      }
      else if(scStr.endsWith(eraser)){
        scStr=scStr.substring(0,scStr.length()-6);
      }
      else if(scStr.endsWith(erase)){
        scStr=scStr.substring(0,scStr.length()-5);
      }
      else if(scStr.length()<=7){
        if(scStr.length()==0){
          result=true ;
        }
        else if(scStr.length()==7 &&(scStr.endsWith(dreamer))){
          result=true ;
          isEnd=true ;
        }
        else if(scStr.length()==6 &&(scStr.endsWith(eraser))){
          result=true ;
          isEnd=true ;
        }
        else if(scStr.length()==5 &&(scStr.endsWith(dream)|| scStr.endsWith(erase))){
          result=true ;
          isEnd=true ;
        }
        else {
          isEnd=true ;
        }
      }
    }
    if(result==true){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var scStr : String ; scStr := scanner.nextLine() ;
    var count : int ; count := scStr->size() / 5 ;
    var dream : String ; dream := "dream" ;
    var dreamer : String ; dreamer := "dreamer" ;
    var erase : String ; erase := "erase" ;
    var eraser : String ; eraser := "eraser" ;
    var result : boolean ; result := false ;
    var isEnd : boolean ; isEnd := false ;
        var i : int ; i := 0 ; while i <= count do ( (     if (isEnd = true) then     break else skip ; 
     if (scStr->hasSuffix(dreamer)) then (     scStr := scStr.subrange(0+1,scStr->size() - 7) ) else     if (scStr->hasSuffix(dream)) then (     scStr := scStr.subrange(0+1,scStr->size() - 5) ) else     if (scStr->hasSuffix(eraser)) then (     scStr := scStr.subrange(0+1,scStr->size() - 6) ) else     if (scStr->hasSuffix(erase)) then (     scStr := scStr.subrange(0+1,scStr->size() - 5) ) else     if (scStr->size() <= 7) then (     if (scStr->size() = 0) then (     result := true ) else     if (scStr->size() = 7 & (scStr->hasSuffix(dreamer))) then (     result := true ; 
     isEnd := true ) else     if (scStr->size() = 6 & (scStr->hasSuffix(eraser))) then (     result := true ; 
     isEnd := true ) else     if (scStr->size() = 5 & (scStr->hasSuffix(dream) or scStr->hasSuffix(erase))) then (     result := true ; 
     isEnd := true ) else (     isEnd := true ) ;  ;  ;  ) else skip ; ;  ;  ;  )  ;     i := i + 1 ) ; 
    if (result = true) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String inner="aa" ;
    char mySuffix='a' ;
    char aiSuffix='a' ;
    int iteration=50 ;
    Set<String>aiAnswers=new HashSet<String>();
    while(iteration-->0){
      System.out.println("?"+aiSuffix+inner+mySuffix);
      String aiAnswer=sc.next();
      if(aiAnswer.charAt(0)!=mySuffix || ! aiAnswers.add(aiAnswer)){
        System.out.println("!OUT");
        return ;
      }
      aiSuffix=aiAnswer.charAt(aiAnswer.length()-1);
      inner=new StringBuilder().append(inner.charAt(0)).append((char)(inner.charAt(1)+1)).toString();
      if(inner.charAt(1)=='z'+1)inner="ba" ;
    }
    throw new IllegalStateException();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inner : String ; inner := "aa" ;
    var mySuffix : String ; mySuffix := 'a' ;
    var aiSuffix : String ; aiSuffix := 'a' ;
    var iteration : int ; iteration := 50 ;
    var aiAnswers : Set(String) ; aiAnswers := Set{} ;
        while (iteration > 0) do (        iteration := iteration - 1 ;     skip ; (     OclFile["System.out"].println("?" + aiSuffix + inner + mySuffix) ; 
     var aiAnswer : String ; aiAnswer := sc.getCurrent() ;
    if (aiAnswer->at(0+1) /= mySuffix or not(aiAnswers->excludes(aiAnswer))) then (     OclFile["System.out"].println("!OUT") ; 
     return ) else skip ; 
    aiSuffix := aiAnswer->at(aiAnswer->size() - 1+1) ; 
    inner := StringLib.newString() + StringLib.newString(inner->at(0+1)) + StringLib.newString((inner->at(1+1) + 1)->oclAsType(String))+"" ; 
    if (inner->at(1+1) = 'z' + 1) then     inner := "ba" ; else skip ; 
 ) ;  ) ;  
    error IncorrectElementException() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Solver {
  private final String S ;
  Solver(Scanner in){
    S=in.next();
  }
  void solve(){
    System.out.println(S.matches("(dream(er)?|eraser?)+")? "YES" : "NO");
  }
}
class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    new Solver(in).solve();
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solver {
   attribute S : String;
   static operation newSolver( in : OclFile) : Solver
  pre: true
  post: true
  activity:
  ( var self : Solver ;
    self := createSolver();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     S := in.next() );
   operation solve() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if S->isMatch("(dream(er)?|eraser?)+") then "YES" else "NO" endif) );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Solver.newSolver(in).solve() ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p006 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p006().run());
  }
  private static final int N=100 ;
  public String run(){
    int sum=0 ;
    int sum2=0 ;
    for(int i=1 ; i<=N ; i++){
      sum+=i ;
      sum2+=i*i ;
    }
    return Integer.toString(sum*sum-sum2);
  }
}
------------------------------------------------------------
OCL File:
---------
class p006 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p006.newp006().run()) );
  static    attribute N : int := 100;
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var sum2 : int ; sum2 := 0 ;
         var i : int ; i := 1 ; while i <= N do ( (     sum := sum+(i) ; 
     sum2 := sum2+(i * i) )  ;     i := i + 1 ) ; 
     return ((sum * sum - sum2) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int a=scan.nextInt();
    int b=scan.nextInt();
    if(a==1 && b==2){
      System.out.println(3);
    }
    else if(a==1 && b==3){
      System.out.println(2);
    }
    else if(a==2 && b==3){
      System.out.println(1);
    }
    else if(a==3 && b==1){
      System.out.println(2);
    }
    else if(a==3 && b==2){
      System.out.println(1);
    }
    else if(a==2 && b==1){
      System.out.println(3);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
     var b : int ; b := scan.getCurrent()->toInteger() ;
     if (a = 1 & b = 2) then (     OclFile["System.out"].println(3) ) else     if (a = 1 & b = 3) then (     OclFile["System.out"].println(2) ) else     if (a = 2 & b = 3) then (     OclFile["System.out"].println(1) ) else     if (a = 3 & b = 1) then (     OclFile["System.out"].println(2) ) else     if (a = 3 & b = 2) then (     OclFile["System.out"].println(1) ) else     if (a = 2 & b = 1) then (     OclFile["System.out"].println(3) ) else skip ; ;  ;  ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner s=new Scanner(System.in);
    System.out.println(6-s.nextInt()-s.nextInt());
  }
}
class Scanner {
  StringTokenizer st ;
  BufferedReader br ;
  public Scanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public String nextLine()throws IOException {
    return br.readLine();
  }
  public double nextDouble()throws IOException {
    String x=next();
    StringBuilder sb=new StringBuilder("0");
    double res=0,f=1 ;
    boolean dec=false,neg=false ;
    int start=0 ;
    if(x.charAt(0)=='-'){
      neg=true ;
      start++;
    }
    for(int i=start ; i<x.length(); i++)if(x.charAt(i)=='.'){
      res=Long.parseLong(sb.toString());
      sb=new StringBuilder("0");
      dec=true ;
    }
    else {
      sb.append(x.charAt(i));
      if(dec)f*=10 ;
    }
    res+=Long.parseLong(sb.toString())/f ;
    return res*(neg ?-1 : 1);
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println(6 - s.getCurrent()->toInteger() - s.getCurrent()->toInteger()) );
}
class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     var x : String ; x := next() ;
     var sb : String ; sb := StringLib.newString("0") ;
    var res : double ; res := 0 ;
    var f : double ; f := 1 ;
    var dec : boolean ; dec := false ;
    var neg : boolean ; neg := false ;
    var start : int ; start := 0 ;
    if (x->at(0+1) = '-') then (     neg := true ; 
     start := start + 1 ) else skip ; 
        var i : int ; i := start ; while i < x->size() do (     if (x->at(i+1) = '.') then (     res := (sb+"")->toLong() ; 
     sb := StringLib.newString("0") ; 
     dec := true ) else (     sb := sb + StringLib.newString(x->at(i+1)) ; 
     if (dec) then     f := f*(10) ; else skip ) ;   ;     i := i + 1 ) ; 
    res := res+((sb+"")->toLong() / f) ; 
    return res * (if neg then -1 else 1 endif) 
 );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.*;
import java.io.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    System.out.println(6-(a+b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(6 - (a + b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.BufferedReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.io.IOException ;
import java.util.StringTokenizer ;
import java.util.Random ;
import java.util.Arrays ;
import java.util.ArrayList ;
import java.util.Collections ;
public class Main {
  static InputReader in=new InputReader(System.in);
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    int n=in.nextInt();
    int m=in.nextInt();
    for(int i=1 ; i<=3 ; i++){
      if(n!=i && m!=i){
        out.println(i);
      }
    }
    out.close();
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return null ;
    }
    public boolean hasNext(){
      String next=null ;
      try {
        next=reader.readLine();
      }
      catch(Exception e){
      }
      if(next==null){
        return false ;
      }
      tokenizer=new StringTokenizer(next);
      return true ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : InputReader := InputReader.newInputReader(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var m : int ; m := in.nextInt() ;
         var i : int ; i := 1 ; while i <= 3 do ( (     if (n /= i & m /= i) then (     skip ) else skip )  ;     i := i + 1 ) ; 
     skip );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return null );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     var next : String ; next := null ;
     try (     next := reader.readLine() )   catch (e : ProgramException) do skip
    if (next = null) then (     return false ) else skip ; 
    tokenizer := OclIterator.newOclIterator_String(next) ; 
    return true 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    input.nextLine();
    List<String>a=Arrays.asList(input.nextLine().split(" "));
    Collections.reverse(a);
    System.out.println(String.join(" ",a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var a : Sequence(String) ; a := input.nextLine()->split(" ") ;
    a := a->reverse() ; 
    OclFile["System.out"].println(join(" ", a)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    try {
      ArrayList<String>list=new ArrayList<String>();
      BufferedReader ds=new BufferedReader(new InputStreamReader(System.in));
      for(int kk=0 ; kk<2 ; kk++){
        String s=ds.readLine();
        if(s!=null && s!=""){
          list.add(s);
        }
        else {
          break ;
        }
      }
      int size=0 ;
      for(int i=0 ; i<list.size(); i++){
        if(i==0){
          size=Integer.valueOf(list.get(i));
        }
        else {
          ArrayList<String>list2=new ArrayList<String>();
          String base=list.get(i);
          StringTokenizer sz=new StringTokenizer(base);
          for(int j=0 ; sz.hasMoreTokens(); j++){
            list2.add(sz.nextToken());
          }
          String sk="" ;
          for(int j=0 ; j<size ; j++){
            sk+=list2.get(size-j-1);
            if(j<size-1){
              sk+=" " ;
            }
          }
          System.out.println(sk);
        }
      }
    }
    catch(Throwable e){
      e.printStackTrace();
      System.out.println("Input Error");
    }
  }
  private static void printline(int a,int b,String per){
    int res=0 ;
    if(per.equals("+"))res=a+b ;
    else if(per.equals("-"))res=a-b ;
    else if(per.equals("*"))res=a*b ;
    else if(per.equals("/"))res=a/b ;
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var list : Sequence(String) ; list := Sequence{} ;
     var ds : OclFile ; ds := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
        var kk : int ; kk := 0 ; while kk < 2 do ( (     var s : String ; s := ds.readLine() ;
     if (s /= null & s /= "") then (     list := list->including(s) ) else (     break ) )  ;     kk := kk + 1 ) ; 
    var size : int ; size := 0 ;
        var i : int ; i := 0 ; while i < list->size() do ( (     if (i = 0) then (     size := (list->at(i+1))->toInteger() ) else (     var list2 : Sequence(String) ; list2 := Sequence{} ;
     var base : String ; base := list->at(i+1) ;
    var sz : OclIterator ; sz := OclIterator.newOclIterator_String(base) ;
        var j : int ; j := 0 ; while sz.hasNext() do ( (     list2 := list2->including(sz.next()) )  ;     j := j + 1 ) ; 
    var sk : String ; sk := "" ;
        var j : int ; j := 0 ; while j < size do ( (     sk := sk+(list2->at((size)->char2byte() - (j)->char2byte() - 1+1)) ; 
     if (j < (size)->char2byte() - 1) then (     sk := sk+(" ") ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(sk) ; 
 ) )  ;     i := i + 1 ) ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
     OclFile["System.out"].println("Input Error") )
 );
  static   operation printline( a : int, b : int, per : String) : void
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     if (per = "+") then     res := a + b else     if (per = "-") then     res := a - b else     if (per = "*") then     res := a * b else     if (per = "/") then     res := a / b ; else skip ; ;  ;  ;  
     OclFile["System.out"].println(res) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class RomanAndBrowser {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    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 most=0 ;
    for(int b=0 ; b<n ; b++){
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        if(i % k!=b % k)sum+=arr[i];
      }
      most=Math.max(most,Math.abs(sum));
    }
    System.out.println(most);
  }
}
------------------------------------------------------------
OCL File:
---------
 class RomanAndBrowser {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var most : int ; most := 0 ;
        var b : int ; b := 0 ; while b < n do ( (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (i mod k /= b mod k) then     sum := sum+(arr[i+1]) ; else skip )  ;     i := i + 1 ) ; 
     most := Set{most, if sum < 0 then -(sum) else sum endif}->max() )  ;     b := b + 1 ) ; 
    OclFile["System.out"].println(most) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      show();
    }
  }
  private static void show(){
    int n=sc.nextInt();
    int m=sc.nextInt();
    int ans=n ;
    int x=-100000 ;
    char a[]=(sc.next()+"0").toCharArray();
    for(int i=0 ; i<a.length ; i++){
      if(a[i]=='1'){
        if(x>0)ans+=Math.min(n,x*m);
        x=0 ;
      }
      else {
        x++;
      }
    }
    System.out.println(x<0 ? 0 : ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     execute show() )  ;     i := i + 1 ) );
  static   operation show() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := n ;
    var x : int ; x := -100000 ;
    var a : Sequence(String) ; a := (sc.getCurrent() + "0")->characters() ;
        var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] = '1') then (     if (x > 0) then     ans := ans+(Set{n, x * m}->min()) ; else skip ; 
     x := 0 ) else (     x := x + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if x < 0 then 0 else ans endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  static int max ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int count=0 ;
    HashMap<String,Boolean>use=new HashMap<String,Boolean>();
    char pre='a' ;
    while(true){
      char say='a'-1 ;
      for(int i=0 ; i<26 ; i++){
        say=(char)(say+1);
        if(! use.containsKey(pre+""+say+""+'a'))break ;
      }
      char say2='a' ;
      boolean f=false ;
      if(use.containsKey(pre+""+say+""+'a')){
        f=true ;
        for(int i=0 ; i<26 ; i++){
          say2=(char)(say2+1);
          if(! use.containsKey(pre+""+say+""+say2+""+'a'))break ;
        }
      }
      String aa=pre+""+say+""+'a' ;
      if(f){
        aa=pre+""+say+""+say2+""+'a' ;
      }
      use.put(aa,true);
      System.out.println("?"+pre+""+say+""+"a");
      String get=sc.next();
      if(get.charAt(0)!='a' || use.containsKey(get)|| get.length()>=3){
        System.out.println("!OUT");
        return ;
      }
      pre=get.charAt(get.length()-1);
      use.put(get,true);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute max : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := 0 ;
    var use : Map(String,Boolean) ; use := Map{} ;
    var pre : String ; pre := 'a' ;
    while (true) do (     var say : String ; say := ('a')->char2byte() - 1 ;
         var i : int ; i := 0 ; while i < 26 do ( (     say := (say + 1)->oclAsType(String) ; 
     if (not(use->keys()->includes(pre + "" + say + "" + 'a'))) then     break else skip )  ;     i := i + 1 ) ; 
    var say2 : String ; say2 := 'a' ;
    var f : boolean ; f := false ;
    if (use->keys()->includes(pre + "" + say + "" + 'a')) then (     f := true ; 
         var i : int ; i := 0 ; while i < 26 do ( (     say2 := (say2 + 1)->oclAsType(String) ; 
     if (not(use->keys()->includes(pre + "" + say + "" + say2 + "" + 'a'))) then     break else skip )  ;     i := i + 1 ) ) else skip ; 
    var aa : String ; aa := pre + "" + say + "" + 'a' ;
    if (f) then (     aa := pre + "" + say + "" + say2 + "" + 'a' ) else skip ; 
    use := use->union(Map{aa |-> true}) ; 
    OclFile["System.out"].println("?" + pre + "" + say + "" + "a") ; 
    var get : String ; get := sc.getCurrent() ;
    if (get->at(0+1) /= 'a' or use->keys()->includes(get) or get->size() >= 3) then (     OclFile["System.out"].println("!OUT") ; 
     return ) else skip ; 
    pre := get->at(get->size() - 1+1) ; 
    use := use->union(Map{get |-> true}) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.text.DecimalFormat ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int numList[]=new int[n];
    for(int i=0 ; i<n ; i++){
      numList[i]=sc.nextInt();
    }
    for(int i=n-1 ; i>0 ; i--){
      System.out.print(numList[i]+" ");
    }
    System.out.println(numList[0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var numList : Sequence(int) ; numList := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     numList[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i > 0 do ( (     OclFile["System.out"].print(numList[i+1] + " ") )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(numList[0+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
class Main {
  private static String join(ArrayList<Integer>ls){
    StringBuilder sb=new StringBuilder();
    for(Integer n : ls){
      if(sb.length()>0){
        sb.append(" ");
      }
      sb.append(n);
    }
    return sb.toString();
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int noItems=scan.nextInt();
    ArrayList<Integer>ls=new ArrayList<Integer>();
    for(int i=0 ; i<noItems ; i++){
      ls.add(scan.nextInt());
    }
    Collections.reverse(ls);
    System.out.println(join(ls));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation join( ls : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     for (n : ls) do ( (     if (sb->size() > 0) then (     sb := sb + StringLib.newString(" ") ) else skip ; 
     sb := sb + StringLib.newString(n) )  ) ; 
     return sb+"" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var noItems : int ; noItems := scan.getCurrent()->toInteger() ;
    var ls : Sequence(int) ; ls := Sequence{} ;
        var i : int ; i := 0 ; while i < noItems do ( (     ls := ls->including(scan.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    ls := ls->reverse() ; 
    OclFile["System.out"].println(join(ls)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] in=br.readLine().split(" ");
    for(; n!=0 ; n--){
      System.out.print(in[n-1]);
      if(n==1)break ;
      System.out.print(" ");
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var in : Sequence(String) ; in := br.readLine()->split(" ") ;
      while n /= 0 do ( (     OclFile["System.out"].print(in[n - 1+1]) ; 
     if (n = 1) then     break else skip ; 
     OclFile["System.out"].print(" ") )  ;     n := n - 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  int MAX=100 ;
  static int countCommon(int mat[][],int n){
    int res=0 ;
    for(int i=0 ; i<n ; i++)if(mat[i][i]==mat[i][n-i-1])res++;
    return res ;
  }
  public static void main(String args[])throws IOException {
    int mat[][]={
      {
        1,2,3 },{
          4,5,6 },{
            7,8,9 }
          };
          System.out.println(countCommon(mat,3));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
   attribute MAX : int := 100;
  static   operation countCommon( mat : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < n do (     if (mat[i+1][i+1] = mat[i+1][n - i - 1+1]) then     res := res + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,2,3},Sequence{4,5,6},Sequence{7,8,9}} ;
     OclFile["System.out"].println(countCommon(mat, 3)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class ModularExponentiation {
  public static void main(String[] args)throws IOException {
    Reader in=new Reader();
    PrintWriter out=new PrintWriter(System.out);
    int M=in.nextInt(),N=in.nextInt();
    int pow=1 ;
    for(int i=0 ; i<M ; i++){
      pow<<=1 ;
      if(pow>N){
        break ;
      }
    }
    out.println(N % pow);
    out.close();
  }
  static class Reader {
    BufferedReader in ;
    StringTokenizer st ;
    public Reader(){
      in=new BufferedReader(new InputStreamReader(System.in));
      st=new StringTokenizer("");
    }
    public String nextLine()throws IOException {
      st=new StringTokenizer("");
      return in.readLine();
    }
    public String next()throws IOException {
      while(! st.hasMoreTokens()){
        st=new StringTokenizer(in.readLine());
      }
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
  public static void sort(int[] arr){
    List<Integer>list=new ArrayList<>();
    for(int i : arr){
      list.add(i);
    }
    Collections.sort(list);
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=list.get(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ModularExponentiation {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var M : int ; M := in.getCurrent()->toInteger() ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var pow : int ; pow := 1 ;
        var i : int ; i := 0 ; while i < M do ( (     pow := pow*(2->pow(1)) ; 
     if (pow > N) then (     break ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class Reader {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newReader() : Reader
  pre: true
  post: true
  activity:
  ( var self : Reader ;
    self := createReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := OclIterator.newOclIterator_String("") );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     st := OclIterator.newOclIterator_String("") ; 
     return in.readLine() );
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   operation sort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     for (i : arr) do ( (     list := list->including(i) )  ) ; 
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := list->at(i+1) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class prog {
  static long power(long a,long n,long m){
    a=m % a ;
    if(n==0)return 1 ;
    long result=power(a,n/2,m);
    if(n % 2!=0){
      return m %(result*result*a);
    }
    else {
      return m %(result*result);
    }
  }
  public static void main(String[] args){
    try {
      System.setIn(new FileInputStream("input.txt"));
      System.setOut(new PrintStream(new FileOutputStream("output.txt")));
    }
    catch(Exception e){
      System.err.println("Error");
    }
    Scanner s=new Scanner(System.in);
    long n=s.nextLong();
    long m=s.nextLong();
    long p=(long)Math.pow(2,n);
    System.out.println(m % p);
  }
}
------------------------------------------------------------
OCL File:
---------
 class prog {
  static   operation power( a : long, n : long, m : long) : long
  pre: true
  post: true
  activity: (     a := m mod a ; 
     if (n = 0) then     return 1 else skip ; 
     var result : long ; result := power(a, n / 2, m) ;
     if (n mod 2 /= 0) then (     return m mod (result * result * a) ) else (     return m mod (result * result) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) )   catch (e : ProgramException) do (     OclFile["System.err"].println("Error") )
     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : long ; n := s.getCurrent()->toLong() ;
    var m : long ; m := s.getCurrent()->toLong() ;
    var p : long ; p := 2->pow(n)->oclAsType(long) ;
    OclFile["System.out"].println(m mod p) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
import static java.lang.Double.parseDouble ;
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
public class Main {
  static BufferedWriter of=null ;
  static {
    try {
      of=new BufferedWriter(new FileWriter(new File("filee.txt")));
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  private static BufferedWriter ifile=null ;
  static {
    try {
      ifile=new BufferedWriter(new FileWriter(String.valueOf(System.in)));
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  private static final BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
  private static final Fast in=new Fast();
  public static void main(String[] args)throws IOException {
    int n=in.nextInt();
    int m=in.nextInt();
    long p=1 ;
    for(int i=1 ; i<=n ; i++){
      p*=2 ;
    }
    if(n>33)System.out.println(m);
    else System.out.println(m % p);
  }
  public static class Fast {
    BufferedReader br ;
    StringTokenizer st ;
    public Fast(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public Fast(FileReader f){
      br=new BufferedReader(f);
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return parseInt(next());
    }
    public long nextLong()throws IOException {
      return parseLong(next());
    }
    public double nextDouble()throws IOException {
      return parseDouble(next());
    }
    public float nextFloat()throws IOException {
      return Float.parseFloat(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute of : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     try (     of := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile("filee.txt"))) )   catch (e : IOException) do (     e.printStackTrace() )
;
  static   attribute ifile : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     try (     ifile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(((OclFile["System.in"]) + ""))) )   catch (e : IOException) do (     e.printStackTrace() )
;
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static    attribute in : Fast := Fast.newFast();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var m : int ; m := in.nextInt() ;
    var p : long ; p := 1 ;
        var i : int ; i := 1 ; while i <= n do ( (     p := p*(2) )  ;     i := i + 1 ) ; 
    if (n > 33) then     OclFile["System.out"].println(m) else     OclFile["System.out"].println(m mod p) ; ;  
 );
  static class Fast {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFast() : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   static operation newFast( f : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(f) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next() + "")->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return parseDouble(next()) );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[][] s=new char[8][8];
    for(int i=0 ; i<8 ; i++)s[i]=sc.next().toCharArray();
    for(int r=90 ; r<=270 ; r+=90){
      System.out.println(r);
      char[][] t=new char[8][8];
      for(int i=0 ; i<8 ; i++){
        for(int j=0 ; j<8 ; j++)t[i][j]=s[7-j][i];
        System.out.println(new String(t[i]));
      }
      s=t ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(Sequence(String)) ; s := Integer.subrange(1,8)->collect(Integer.subrange(1,8)->collect(0)) ;
         var i : int ; i := 0 ; while i < 8 do (     s[i+1] := sc.getCurrent()->characters() ;  ;     i := i + 1 ) ; 
         var r : int ; r := 90 ; while r <= 270 do ( (     OclFile["System.out"].println(r) ; 
     var t : Sequence(Sequence(String)) ; t := Integer.subrange(1,8)->collect(Integer.subrange(1,8)->collect(0)) ;
         var i : int ; i := 0 ; while i < 8 do ( (         var j : int ; j := 0 ; while j < 8 do (     t[i+1][j+1] := s[7 - j+1][i+1] ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(StringLib.newString(t[i+1])) )  ;     i := i + 1 ) ; 
     s := t )  ;     r := r+(90) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static BufferedReader br=null ;
  private static final int[] AI={
    0,90,180,270 };
    static {
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public static void main(String[] args){
      char[][] bd=parseBoard();
      showBoard(bd,1);
      showBoard(bd,2);
      showBoard(bd,3);
    }
    private static void showBoard(char[][] bd,int ai){
      System.out.println(AI[ai]);
      for(int i=0 ; i<8 ; i++){
        String out="" ;
        for(int j=0 ; j<8 ; j++){
          switch(ai){
            case 1 : out+=bd[7-j][i];
            break ;
            case 2 : out+=bd[7-i][7-j];
            break ;
            case 3 : out+=bd[j][7-i];
            break ;
            default : out+=bd[i][j];
            break ;
          }
        }
        System.out.println(out);
      }
    }
    private static char[][] parseBoard(){
      char[][] bd=new char[8][];
      for(int i=0 ; i<bd.length ; i++){
        bd[i]=parseStdin().toCharArray();
      }
      return bd ;
    }
    private static String parseStdin(){
      String stdin=null ;
      try {
        String tmp=br.readLine();
        if(! tmp.isEmpty())stdin=tmp ;
      }
      catch(IOException e){
      }
      return stdin ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static    attribute AI : Sequence(int) := Sequence{0,90,180,270};
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bd : Sequence(Sequence(String)) ; bd := parseBoard() ;
     execute showBoard(bd, 1) ; 
     execute showBoard(bd, 2) ; 
     execute showBoard(bd, 3) );
  static   operation showBoard( bd : Sequence(Sequence(String)), ai : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(AI[ai+1]) ; 
         var i : int ; i := 0 ; while i < 8 do ( (     var out : String ; out := "" ;
         var j : int ; j := 0 ; while j < 8 do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (ai) ; 
       if _switchval = 1 then
     out := out+(bd[7 - (j)->char2byte()+1][i+1]) ; 
    break 
   else skip ;
       if _switchval = 2 then
     out := out+(bd[7 - i+1][7 - (j)->char2byte()+1]) ; 
    break 
   else skip ;
       if _switchval = 3 then
     out := out+(bd[j+1][7 - i+1]) ; 
    break 
   else skip ;
       if true then
     out := out+(bd[i+1][j+1]) ; 
    break 
   else skip ;
 )
 )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(out) )  ;     i := i + 1 ) );
  static   operation parseBoard() : Sequence(Sequence(String))
  pre: true
  post: true
  activity: (     var bd : Sequence(Sequence(String)) ; bd := Integer.subrange(1,8)->collect(Sequence{}) ;
         var i : int ; i := 0 ; while i < bd->size() do ( (     bd[i+1] := parseStdin()->characters() )  ;     i := i + 1 ) ; 
     return bd );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var stdin : String ; stdin := null ;
     try (     var tmp : String ; tmp := br.readLine() ;
     if (not(tmp->isEmpty())) then     stdin := tmp ; else skip )   catch (e : IOException) do skip
     return stdin );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p019 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p019().run());
  }
  public String run(){
    int count=0 ;
    for(int y=1901 ; y<=2000 ; y++){
      for(int m=1 ; m<=12 ; m++){
        if(dayOfWeek(y,m,1)==0)count++;
      }
    }
    return Integer.toString(count);
  }
  private static int dayOfWeek(int year,int month,int day){
    if(year<0 || year>10000 || month<1 || month>12 || day<1 || day>31)throw new IllegalArgumentException();
    int m=(month-3+4800)% 4800 ;
    int y=(year+m/12)% 400 ;
    m %=12 ;
    return(y+y/4-y/100+(13*m+2)/5+day+2)% 7 ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p019 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p019.newp019().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var y : int ; y := 1901 ; while y <= 2000 do ( (         var m : int ; m := 1 ; while m <= 12 do ( (     if (dayOfWeek(y, m, 1) = 0) then     count := count + 1 ; else skip )  ;     m := m + 1 ) )  ;     y := y + 1 ) ; 
     return ((count) + "") );
  static   operation dayOfWeek( year : int, month : int, day : int) : int
  pre: true
  post: true
  activity: (     if (year < 0 or year > 10000 or month < 1 or month > 12 or day < 1 or day > 31) then     error IllegalArgumentException.newIllegalArgumentException() ; else skip ; 
     var m : int ; m := (month - 3 + 4800) mod 4800 ;
    var y : int ; y := (year + m / 12) mod 400 ;
    m := m mod 12 ; 
    return (y + y / 4 - y / 100 + (13 * m + 2) / 5 + day + 2) mod 7 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class RomanAndBrowser {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      try {
        br=new BufferedReader(new FileReader("input.txt"));
        PrintStream out=new PrintStream(new FileOutputStream("output.txt"));
        System.setOut(out);
      }
      catch(Exception e){
        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 ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int n=reader.nextInt();
    int k=reader.nextInt();
    int[] ais=new int[n];
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      ais[i]=reader.nextInt();
      sum+=ais[i];
    }
    int ans=Integer.MIN_VALUE ;
    for(int i=0 ; i<k ; i++){
      int new_sum=sum ;
      int j=i ;
      while(j<n){
        new_sum-=ais[j];
        j+=k ;
      }
      ans=Math.max(ans,Math.abs(new_sum));
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class RomanAndBrowser {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt"))) ;
 setOut(out) )   catch (e : ProgramException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var n : int ; n := reader.nextInt() ;
    var k : int ; k := reader.nextInt() ;
    var ais : Sequence(int) ; ais := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ais[i+1] := reader.nextInt() ; 
     sum := sum+(ais[i+1]) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -2147483648 ;
        var i : int ; i := 0 ; while i < k do ( (     var new_sum : int ; new_sum := sum ;
     var j : int ; j := i ;
     while (j < n) do (     new_sum := new_sum-(ais[j+1]) ; 
     j := j+(k) ) ; 
     ans := Set{ans, if new_sum < 0 then -(new_sum) else new_sum endif}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    int n=8 ;
    String[] ss=new String[n];
    for(int j=0 ; j<n ; j++){
      ss[j]=sc.next();
    }
    println("90");
    for(int i=0 ; i<n ; i++){
      for(int j=n-1 ; j>=0 ; j--){
        print(""+ss[j] .charAt(i));
      }
      println("");
    }
    println("180");
    for(int j=n-1 ; j>=0 ; j--){
      for(int i=n-1 ; i>=0 ; i--){
        print(""+ss[j] .charAt(i));
      }
      println("");
    }
    println("270");
    for(int i=n-1 ; i>=0 ; i--){
      for(int j=0 ; j<n ; j++){
        print(""+ss[j] .charAt(i));
      }
      println("");
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     var ss : Sequence(String) ; ss := Integer.subrange(1,n)->collect(null) ;
        var j : int ; j := 0 ; while j < n do ( (     ss[j+1] := sc.getCurrent() )  ;     j := j + 1 ) ; 
    execute println("90") ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := n - 1 ; while j >= 0 do ( (     execute print("" + ss[j+1]->at(i+1)) )  ;     j := j - 1 ) ; 
     execute println("") )  ;     i := i + 1 ) ; 
    execute println("180") ; 
        var j : int ; j := n - 1 ; while j >= 0 do ( (         var i : int ; i := n - 1 ; while i >= 0 do ( (     execute print("" + ss[j+1]->at(i+1)) )  ;     i := i - 1 ) ; 
     execute println("") )  ;     j := j - 1 ) ; 
    execute println("270") ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < n do ( (     execute print("" + ss[j+1]->at(i+1)) )  ;     j := j + 1 ) ; 
     execute println("") )  ;     i := i - 1 ) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String s="" ;
      String t="" ;
      String[][] map90=new String[8][8];
      String[][] map180=new String[8][8];
      String[][] map270=new String[8][8];
      for(int i=0 ; i<8 ; i++){
        s=sc.next();
        for(int j=0 ; j<8 ; j++){
          t=s.substring(j,j+1);
          map90[j][7-i]=t ;
          map180[7-i][7-j]=t ;
          map270[7-j][i]=t ;
        }
      }
      System.out.println("90");
      for(int i=0 ; i<8 ; i++){
        for(int j=0 ; j<8 ; j++){
          System.out.print(map90[i][j]);
        }
        System.out.println();
      }
      System.out.println("180");
      for(int i=0 ; i<8 ; i++){
        for(int j=0 ; j<8 ; j++){
          System.out.print(map180[i][j]);
        }
        System.out.println();
      }
      System.out.println("270");
      for(int i=0 ; i<8 ; i++){
        for(int j=0 ; j<8 ; j++){
          System.out.print(map270[i][j]);
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var s : String ; s := "" ;
     var t : String ; t := "" ;
    var map90 : Sequence(Sequence(String)) ; map90 := Integer.subrange(1,8)->collect(Integer.subrange(1,8)->collect(null)) ;
    var map180 : Sequence(Sequence(String)) ; map180 := Integer.subrange(1,8)->collect(Integer.subrange(1,8)->collect(null)) ;
    var map270 : Sequence(Sequence(String)) ; map270 := Integer.subrange(1,8)->collect(Integer.subrange(1,8)->collect(null)) ;
        var i : int ; i := 0 ; while i < 8 do ( (     s := sc.getCurrent() ; 
         var j : int ; j := 0 ; while j < 8 do ( (     t := s.subrange(j+1,j + 1) ; 
     map90[j+1][7 - i+1] := t ; 
     map180[7 - i+1][7 - j+1] := t ; 
     map270[7 - j+1][i+1] := t )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("90") ; 
        var i : int ; i := 0 ; while i < 8 do ( (         var j : int ; j := 0 ; while j < 8 do ( (     OclFile["System.out"].print(map90[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("180") ; 
        var i : int ; i := 0 ; while i < 8 do ( (         var j : int ; j := 0 ; while j < 8 do ( (     OclFile["System.out"].print(map180[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("270") ; 
        var i : int ; i := 0 ; while i < 8 do ( (         var j : int ; j := 0 ; while j < 8 do ( (     OclFile["System.out"].print(map270[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  static int minSwap(int arr[],int n,int k){
    int count=0 ;
    for(int i=0 ; i<n ; ++i)if(arr[i]<=k)++count ;
    int bad=0 ;
    for(int i=0 ; i<count ; ++i)if(arr[i]>k)++bad ;
    int ans=bad ;
    for(int i=0,j=count ; j<n ; ++i,++j){
      if(arr[i]>k)--bad ;
      if(arr[j]>k)++bad ;
      ans=Math.min(ans,bad);
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      2,1,5,6,3 };
      int n=arr.length ;
      int k=3 ;
      System.out.print(minSwap(arr,n,k)+"\n");
      int arr1[]={
        2,7,9,5,8,7,4 };
        n=arr1.length ;
        k=5 ;
        System.out.print(minSwap(arr1,n,k));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minSwap( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do (     if (arr[i+1] <= k) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
    var bad : int ; bad := 0 ;
        var i : int ; i := 0 ; while i < count do (     if (arr[i+1] > k) then     bad := bad + 1 ; else skip ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := bad ;
        var i : int ; i := 0 ;
    var j : int ; j := count ; while j < n do ( (     if (arr[i+1] > k) then     bad := bad - 1 ; else skip ; 
     if (arr[j+1] > k) then     bad := bad + 1 ; else skip ; 
     ans := Set{ans, bad}->min() )  ;     i := i + 1 ;     j := j + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,1,5,6,3} ;
     var n : int ; n := arr->size() ;
    var k : int ; k := 3 ;
    OclFile["System.out"].print(minSwap(arr, n, k) + "\n") ; 
    var arr1 : Sequence(int) ; arr1 := Sequence{2,7,9,5,8,7,4} ;
    n := arr1->size() ; 
    k := 5 ; 
    OclFile["System.out"].print(minSwap(arr1, n, k)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.regex.Pattern ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    char[] list=br.readLine().toCharArray();
    char a='A' ;
    int sum=0 ;
    for(int i=0 ; i<list.length ; i++){
      if(list[i]<=a){
        sum++;
      }
      a=list[i];
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var list : Sequence(String) ; list := br.readLine()->characters() ;
    var a : String ; a := 'A' ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < list->size() do ( (     if (list[i+1] <= a) then (     sum := sum + 1 ) else skip ; 
     a := list[i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S='A'+sc.next();
    int count=0 ;
    for(int i=1 ; i<S.length(); i++){
      if(S.charAt(i)<=S.charAt(i-1))count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := 'A' + sc.getCurrent() ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < S->size() do ( (     if (S->at(i+1) <= S->at(i - 1+1)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] arr=sc.next().toCharArray();
    char prev='A' ;
    int count=0 ;
    for(char c : arr){
      if(prev>=c){
        count++;
      }
      prev=c ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
    var prev : String ; prev := 'A' ;
    var count : int ; count := 0 ;
    for (c : arr) do ( (     if (prev >= c) then (     count := count + 1 ) else skip ; 
     prev := c )  ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String ins=sc.next();
    int length=ins.length();
    int pre_char='A' ;
    int cnt=0 ;
    for(int i=0 ; i<length ; i++){
      int c=ins.charAt(i);
      if(c>pre_char)cnt=cnt+(c-pre_char);
      else cnt=cnt+(c-pre_char)+26 ;
      pre_char=c ;
    }
    System.out.println(cnt/26);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ins : String ; ins := sc.getCurrent() ;
    var length : int ; length := ins->size() ;
    var pre_char : int ; pre_char := 'A' ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < length do ( (     var c : int ; c := ins->at(i+1) ;
     if (c > pre_char) then     cnt := cnt + (c - pre_char) else     cnt := cnt + (c - pre_char) + 26 ; ;  
     pre_char := c )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt / 26) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int xorOfSum(int a[],int n){
    int answer=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++)answer ^=(a[i]+a[j]);
    }
    return answer ;
  }
  public static void main(String[] args){
    int n=3 ;
    int A[]={
      1,2,3 };
      System.out.print(xorOfSum(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation xorOfSum( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var answer : int ; answer := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do (     answer := MathLib.bitwiseXor(answer,(a[i+1] + a[j+1])) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return answer );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var A : Sequence(int) ; A := Sequence{1,2,3} ;
     OclFile["System.out"].print(xorOfSum(A, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static void steps(String str,int n){
    boolean flag=false ;
    int x=0 ;
    for(int i=0 ; i<str.length(); i++){
      if(x==0)flag=true ;
      if(x==n-1)flag=false ;
      for(int j=0 ; j<x ; j++)System.out.print("*");
      System.out.print(str.charAt(i)+"\n");
      if(flag==true)x++;
      else x--;
    }
  }
  public static void main(String args[]){
    int n=4 ;
    String str="GeeksForGeeks" ;
    System.out.println("String: "+str);
    System.out.println("Max Length of Steps: "+n);
    steps(str,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation steps( str : String, n : int) : void
  pre: true
  post: true
  activity: (     var flag : boolean ; flag := false ;
     var x : int ; x := 0 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (x = 0) then     flag := true ; else skip ; 
     if (x = n - 1) then     flag := false ; else skip ; 
        var j : int ; j := 0 ; while j < x do (     OclFile["System.out"].print("*") ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].print(str->at(i+1) + "\n") ; 
    if (flag = true) then     x := x + 1 else     x := x - 1 ; ;  
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var str : String ; str := "GeeksForGeeks" ;
    OclFile["System.out"].println("String: " + str) ; 
    OclFile["System.out"].println("Max Length of Steps: " + n) ; 
    execute steps(str, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Solution2 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    int[] arr=new int[n];
    int po=0 ;
    int no=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
      if(arr[i]==1){
        po++;
      }
      else {
        no++;
      }
    }
    int ans=0 ;
    for(int j=0 ; j<k ; j++){
      int x=0,y=0 ;
      for(int i=j ; i<n ; i=i+k){
        if(arr[i]==1){
          x++;
        }
        else {
          y++;
        }
      }
      ans=Math.max(ans,Math.abs((po-x)-(no-y)));
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var po : int ; po := 0 ;
    var no : int ; no := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() ; 
     if (arr[i+1] = 1) then (     po := po + 1 ) else (     no := no + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var j : int ; j := 0 ; while j < k do ( (     var x : int ; x := 0 ;
    var y : int ; y := 0 ;
         var i : int ; i := j ; while i < n do ( (     if (arr[i+1] = 1) then (     x := x + 1 ) else (     y := y + 1 ) )  ;     i := i + k ) ; 
     ans := Set{ans, if (po - x) - (no - y) < 0 then -((po - x) - (no - y)) else (po - x) - (no - y) endif}->max() )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPrime(int n){
    if(n<=1)return false ;
    for(int i=2 ; i<n ; i++)if(n % i==0)return false ;
    return true ;
  }
  static void printPrime(int n){
    for(int i=2 ; i<=n ; i++){
      if(isPrime(i))System.out.print(i+" ");
    }
  }
  public static void main(String[] args){
    int n=7 ;
    printPrime(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
         var i : int ; i := 2 ; while i < n do (     if (n mod i = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation printPrime( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i <= n do ( (     if (isPrime(i)) then     OclFile["System.out"].print(i + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     execute printPrime(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isPrime(int n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static void printPrime(int n){
    for(int i=2 ; i<=n ; i++){
      if(isPrime(i))System.out.print(i+" ");
    }
  }
  public static void main(String[] args){
    int n=7 ;
    printPrime(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation printPrime( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i <= n do ( (     if (isPrime(i)) then     OclFile["System.out"].print(i + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     execute printPrime(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=1000000 ;
  static int[] Sieve=new int[MAX+1];
  static void constructSieve(){
    for(int i=2 ; i<=MAX ; i++){
      if(Sieve[i]==0){
        for(int j=2*i ; j<=MAX ; j+=i){
          int temp=j ;
          while(temp>1 && temp % i==0){
            Sieve[j]++;
            temp=temp/i ;
          }
        }
      }
    }
  }
  static void checkElements(int A[],int n,int k){
    for(int i=0 ; i<n ; i++){
      if(Sieve[A[i] ]==k){
        System.out.println("YES");
      }
      else {
        System.out.println("No");
      }
    }
  }
  public static void main(String[] args){
    constructSieve();
    int k=3 ;
    int A[]={
      12,36,42,72 };
      int n=A.length ;
      checkElements(A,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 1000000;
  static   attribute Sieve : Sequence(int) := Integer.subrange(1,MAX + 1)->collect(0);
  static   operation constructSieve() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i <= MAX do ( (     if (Sieve[i+1] = 0) then (         var j : int ; j := 2 * i ; while j <= MAX do ( (     var temp : int ; temp := j ;
     while (temp > 1 & temp mod i = 0) do (     Sieve[j+1] := Sieve[j+1] + 1 ; 
     temp := temp / i ) )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) );
  static   operation checkElements( A : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (Sieve[A[i+1]+1] = k) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("No") ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute constructSieve() ; 
     var k : int ; k := 3 ;
    var A : Sequence(int) ; A := Sequence{12,36,42,72} ;
    var n : int ; n := A->size() ;
    execute checkElements(A, n, k) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.regex.*;
class GFG {
  public static boolean isValidTime(String time){
    String regexPattern="(1[012] |[1-9]):"+"[0-5][0-9] (\\s)"+"?(?i)(am|pm)" ;
    Pattern compiledPattern=Pattern.compile(regexPattern);
    if(time==null){
      return false ;
    }
    Matcher m=compiledPattern.matcher(time);
    return m.matches();
  }
  public static void main(String args[]){
    String str1="12:15 AM" ;
    System.out.println(isValidTime(str1));
    String str2="9:45PM" ;
    System.out.println(isValidTime(str2));
    String str3="1:15" ;
    System.out.println(isValidTime(str3));
    String str4="17:30" ;
    System.out.println(isValidTime(str4));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isValidTime( time : String) : boolean
  pre: true
  post: true
  activity: (     var regexPattern : String ; regexPattern := "(1[012] |[1-9]):" + "[0-5][0-9] (\\s)" + "?(?i)(am|pm)" ;
     var compiledPattern : OclRegex ; compiledPattern := OclRegex.compile(regexPattern) ;
    if (time = null) then (     return false ) else skip ; 
    var m : OclRegex ; m := compiledPattern.matcher(time) ;
    return m.isMatch() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "12:15 AM" ;
     OclFile["System.out"].println(isValidTime(str1)) ; 
    var str2 : String ; str2 := "9:45PM" ;
    OclFile["System.out"].println(isValidTime(str2)) ; 
    var str3 : String ; str3 := "1:15" ;
    OclFile["System.out"].println(isValidTime(str3)) ; 
    var str4 : String ; str4 := "17:30" ;
    OclFile["System.out"].println(isValidTime(str4)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void bin(int n){
    if(n>1)bin(n/2);
    System.out.print(n % 2);
  }
  public static void main(String[] args){
    bin(7);
    System.out.println();
    bin(4);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation bin( n : int) : void
  pre: true
  post: true
  activity: (     if (n > 1) then     execute bin(n / 2) ; else skip ; 
     OclFile["System.out"].print(n mod 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute bin(7) ; 
     OclFile["System.out"].println() ; 
     execute bin(4) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.Math ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    int P1=Integer.parseInt(st.nextToken());
    int P2=Integer.parseInt(st.nextToken());
    int P3=Integer.parseInt(st.nextToken());
    int T1=Integer.parseInt(st.nextToken());
    int T2=Integer.parseInt(st.nextToken());
    int l[]=new int[n];
    int r[]=new int[n];
    for(int i=0 ; i<n ; i++){
      StringTokenizer st2=new StringTokenizer(br.readLine());
      l[i]=Integer.parseInt(st2.nextToken());
      r[i]=Integer.parseInt(st2.nextToken());
    }
    int answer=0 ;
    for(int i=0 ; i<n ; i++){
      int time=r[i]-l[i];
      answer+=time*P1 ;
    }
    for(int i=0 ; i<n-1 ; i++){
      int time=l[i+1]-r[i];
      if(time>=T1){
        time=time-T1 ;
        answer+=T1*P1 ;
        if(time>=T2){
          time=time-T2 ;
          answer+=T2*P2 ;
          if(time>=0){
            answer+=time*P3 ;
          }
        }
        else {
          answer+=time*P2 ;
        }
      }
      else {
        answer+=time*P1 ;
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var P1 : int ; P1 := (st.next())->toInteger() ;
    var P2 : int ; P2 := (st.next())->toInteger() ;
    var P3 : int ; P3 := (st.next())->toInteger() ;
    var T1 : int ; T1 := (st.next())->toInteger() ;
    var T2 : int ; T2 := (st.next())->toInteger() ;
    var l : Sequence(int) ; l := Integer.subrange(1,n)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var st2 : OclIterator ; st2 := OclIterator.newOclIterator_String(br.readLine()) ;
     l[i+1] := (st2.next())->toInteger() ; 
     r[i+1] := (st2.next())->toInteger() )  ;     i := i + 1 ) ; 
    var answer : int ; answer := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var time : int ; time := r[i+1] - l[i+1] ;
     answer := answer+(time * P1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var time : int ; time := l[i + 1+1] - r[i+1] ;
     if (time >= T1) then (     time := time - T1 ; 
     answer := answer+(T1 * P1) ; 
     if (time >= T2) then (     time := time - T2 ; 
     answer := answer+(T2 * P2) ; 
     if (time >= 0) then (     answer := answer+(time * P3) ) else skip ) else (     answer := answer+(time * P2) ) ) else (     answer := answer+(time * P1) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.util.Scanner ;
public class A10 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int P1=in.nextInt();
    int P2=in.nextInt();
    int P3=in.nextInt();
    int T1=in.nextInt();
    int T2=in.nextInt();
    Point[] P=new Point[N];
    for(int n=0 ; n<N ; n++){
      P[n]=new Point(in.nextInt(),in.nextInt());
    }
    int last=P[0] .x ;
    int total=0 ;
    for(Point p : P){
      int time=p.x-last ;
      total+=P1*Math.min(time,T1);
      total+=P2*Math.max(0,Math.min(time-T1,T2));
      total+=P3*Math.max(0,time-T1-T2);
      total+=P1*(p.y-p.x);
      last=p.y ;
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A10 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var P1 : int ; P1 := in.getCurrent()->toInteger() ;
    var P2 : int ; P2 := in.getCurrent()->toInteger() ;
    var P3 : int ; P3 := in.getCurrent()->toInteger() ;
    var T1 : int ; T1 := in.getCurrent()->toInteger() ;
    var T2 : int ; T2 := in.getCurrent()->toInteger() ;
    var P : Sequence(Point) ; P := Integer.subrange(1,N)->collect(null) ;
        var n : int ; n := 0 ; while n < N do ( (     P[n+1] := Point.newPoint(in.getCurrent()->toInteger(), in.getCurrent()->toInteger()) )  ;     n := n + 1 ) ; 
    var last : int ; last := P[0+1].x ;
    var total : int ; total := 0 ;
    for (p : P) do ( (     var time : int ; time := p.x - last ;
     total := total+(P1 * Set{time, T1}->min()) ; 
    total := total+(P2 * Set{0, Set{time - T1, T2}->min()}->max()) ; 
    total := total+(P3 * Set{0, time - T1 - T2}->max()) ; 
    total := total+(P1 * (p.y - p.x)) ; 
    last := p.y ; 
 )  ) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int findSecondMinimumValue(TreeNode root){
    if(root==null)return-1 ;
    Stack<TreeNode>stack=new Stack<TreeNode>();
    int min_val=root.val ;
    int ans=Integer.MAX_VALUE ;
    stack.push(root);
    while(! stack.empty()){
      TreeNode node=stack.pop();
      if(node==null)continue ;
      if(node.val<ans && node.val>min_val){
        ans=node.val ;
      }
      else if(node.val==min_val){
        stack.push(node.left);
        stack.push(node.right);
      }
    }
    return ans<Integer.MAX_VALUE ? ans :-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation findSecondMinimumValue( root : TreeNode) : int
  pre: true
  post: true
  activity: (     if (root = null) then     return -1 else skip ; 
     var stack : Sequence(TreeNode) ; stack := Sequence{} ;
    var min_val : int ; min_val := root.val ;
    var ans : int ; ans := 2147483647 ;
    stack := stack->append(root) ; 
    while (not(stack->isEmpty())) do (     var node : TreeNode ; node := stack->last() ;
     if (node = null) then     continue else skip ; 
     if (node.val < ans & node.val > min_val) then (     ans := node.val ) else     if (node.val = min_val) then (     stack := stack->append(node.left) ; 
     stack := stack->append(node.right) ) else skip ; ) ; 
    return if ans < 2147483647 then ans else -1 endif 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Set<Integer>st=new HashSet<Integer>();
  static void generateNumbers(int n,int num,int a,int b){
    if(num>0 && num<n)st.add(num);
    if(num>=n)return ;
    if(num*10+a>num)generateNumbers(n,num*10+a,a,b);
    generateNumbers(n,num*10+b,a,b);
  }
  static void printNumbers(int n){
    for(int i=0 ; i<=9 ; i++)for(int j=i+1 ; j<=9 ; j++)generateNumbers(n,0,i,j);
    System.out.print("The numbers are: ");
    System.out.print(st);
    st.clear();
  }
  public static void main(String args[]){
    int n=12 ;
    printNumbers(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute st : Set(int) := Set{};
  static   operation generateNumbers( n : int, num : int, a : int, b : int) : void
  pre: true
  post: true
  activity: (     if (num > 0 & num < n) then     st := st->including(num) ; else skip ; 
     if (num >= n) then     return else skip ; 
     if (num * 10 + a > num) then     execute generateNumbers(n, num * 10 + a, a, b) ; else skip ; 
     execute generateNumbers(n, num * 10 + b, a, b) );
  static   operation printNumbers( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= 9 do (         var j : int ; j := i + 1 ; while j <= 9 do (     execute generateNumbers(n, 0, i, j) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("The numbers are: ") ; 
     OclFile["System.out"].print(st) ; 
     st := st->intersection(Set{}) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     execute printNumbers(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] str=(" "+sc.next()).toCharArray();
    int ans=Integer.MAX_VALUE ;
    for(int i=4 ; i<=n ; i++)ans=Math.min(ans,cal(str[i-3],'A')+cal(str[i-2],'C')+cal(str[i-1],'T')+cal(str[i],'G'));
    System.out.println(ans);
    sc.close();
  }
  private static int cal(char s,char t){
    if(s>t)return Math.min(s-t,t-(s-26));
    else return Math.min(t-s,s-(t-26));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var str : Sequence(String) ; str := (" " + sc.getCurrent())->characters() ;
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 4 ; while i <= n do (     ans := Set{ans, cal(str[i - 3+1], 'A') + cal(str[i - 2+1], 'C') + cal(str[i - 1+1], 'T') + cal(str[i+1], 'G')}->min() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
  static   operation cal( s : String, t : String) : int
  pre: true
  post: true
  activity: (     if (s > t) then     return Set{s - t, t - (s - 26)}->min() else     return Set{t - s, s - (t - 26)}->min() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Template {
  private static StringTokenizer st ;
  private static BufferedReader br ;
  private static PrintWriter pw ;
  public static void main(String[] args)throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    int n=nextInt();
    String s=next();
    int ans=Integer.MAX_VALUE ;
    for(int i=0 ; i<s.length()-3 ; i++){
      ans=Math.min(ans,minValue(s.substring(i,i+4)));
    }
    System.out.println(ans);
  }
  public static int minValue(String s){
    int ans=0 ;
    char a[]={
      'A','C','T','G' };
      for(int i=0 ; i<s.length(); i++){
        int cnt1=0,cnt2=0 ;
        Character temp=s.charAt(i);
        while(temp!=a[i]){
          temp++;
          if(temp>'Z'){
            temp='A' ;
          }
          cnt1++;
        }
        temp=s.charAt(i);
        while(temp!=a[i]){
          temp--;
          if(temp<'A'){
            temp='Z' ;
          }
          cnt2++;
        }
        ans+=Math.min(cnt1,cnt2);
      }
      return ans ;
    }
    private static int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    private static long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    private static double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    private static String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Template {
  static   attribute st : OclIterator;
  static   attribute br : OclFile;
  static   attribute pw : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ; 
    var n : int ; n := nextInt() ;
    var s : String ; s := next() ;
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i < s->size() - 3 do ( (     ans := Set{ans, minValue(s.subrange(i+1,i + 4))}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation minValue( s : String) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var a : Sequence(String) ; a := Sequence{'A','C','T','G'} ;
         var i : int ; i := 0 ; while i < s->size() do ( (     var cnt1 : int ; cnt1 := 0 ;
    var cnt2 : int ; cnt2 := 0 ;
     var temp : String ; temp := s->at(i+1) ;
    while (temp /= a[i+1]) do (     temp := temp + 1 ; 
     if (temp > 'Z') then (     temp := 'A' ) else skip ; 
     cnt1 := cnt1 + 1 ) ; 
    temp := s->at(i+1) ; 
    while (temp /= a[i+1]) do (     temp := temp - 1 ; 
     if (temp < 'A') then (     temp := 'Z' ) else skip ; 
     cnt2 := cnt2 + 1 ) ; 
    ans := ans+(Set{cnt1, cnt2}->min()) ; 
 )  ;     i := i + 1 ) ; 
     return ans );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    for(int a=1 ; a<10 ; a++){
      for(int b=1 ; b<10 ; b++){
        if(N==a*b){
          System.out.println("Yes");
          System.exit(0);
        }
      }
    }
    System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
         var a : int ; a := 1 ; while a < 10 do ( (         var b : int ; b := 1 ; while b < 10 do ( (     if (N = a * b) then (     OclFile["System.out"].println("Yes") ; 
 OclProcess.exit(0) ) else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
     OclFile["System.out"].println("No") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static void record_sum(int record[],int l,int r,int n,int adder){
    for(int i=l ; i<=r ; i++){
      record[i]+=adder ;
    }
  }
  public static void main(String[] args){
    int n=5,m=5 ;
    int arr[]=new int[n];
    Arrays.fill(arr,0);
    int query[][]={
      {
        1,1,2 },{
          1,4,5 },{
            2,1,2 },{
              2,1,3 },{
                2,3,4 }
              };
              int record[]=new int[m];
              Arrays.fill(record,0);
              for(int i=m-1 ; i>=0 ; i--){
                if(query[i][0]==2){
                  record_sum(record,query[i][1]-1,query[i][2]-1,m,record[i]+1);
                }
                else {
                  record_sum(record,i,i,m,1);
                }
              }
              for(int i=0 ; i<m ; i++){
                if(query[i][0]==1){
                  record_sum(arr,query[i][1]-1,query[i][2]-1,n,record[i]);
                }
              }
              for(int i=0 ; i<n ; i++){
                System.out.print(arr[i]+" ");
              }
            }
          }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation record_sum( record : Sequence(int), l : int, r : int, n : int, adder : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := l ; while i <= r do ( (     record[i+1] := record[i+1]+(adder) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var m : int ; m := 5 ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    arr := arr->collect(0) ; 
    var query : Sequence(Sequence(int)) ; query := Sequence{Sequence{1,1,2},Sequence{1,4,5},Sequence{2,1,2},Sequence{2,1,3},Sequence{2,3,4}} ;
    var record : Sequence(int) ; record := Integer.subrange(1,m)->collect(0) ;
    record := record->collect(0) ; 
        var i : int ; i := m - 1 ; while i >= 0 do ( (     if (query[i+1][0+1] = 2) then (     execute record_sum(record, query[i+1][1+1] - 1, query[i+1][2+1] - 1, m, record[i+1] + 1) ) else (     execute record_sum(record, i, i, m, 1) ) )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     if (query[i+1][0+1] = 1) then (     execute record_sum(arr, query[i+1][1+1] - 1, query[i+1][2+1] - 1, n, record[i+1]) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    Scanner sc=new Scanner(systemin);
    int N=sc.nextInt();
    int Q=sc.nextInt();
    int[] a=new int[N];
    for(int n=0 ; n<N ; n++){
      a[n]=sc.nextInt()*2 ;
    }
    Arrays.sort(a);
    for(int i=0 ; i<Q ; i++){
      int l=sc.nextInt();
      int r=sc.nextInt();
      int lidx=Arrays.binarySearch(a,l*2-1);
      if(lidx<0){
        lidx=-lidx-1 ;
      }
      int ridx=Arrays.binarySearch(a,r*2+1);
      if(ridx<0){
        ridx=-ridx-1 ;
      }
      result.printf("%d\n",ridx-lidx);
    }
    sc.close();
    return false ;
  }
  PrintStream log ;
  PrintStream result=System.out ;
  BufferedReader systemin ;
  static Main instance=new Main();
  Main(){
    systemin=new BufferedReader(new InputStreamReader(System.in));
    log=new PrintStream(new OutputStream(){
      public void write(int b){
      }
    }
);
  }
  public static void main(String[] args)throws IOException {
    instance.main();
    instance.systemin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(systemin) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var Q : int ; Q := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     a[n+1] := sc.getCurrent()->toInteger() * 2 )  ;     n := n + 1 ) ; 
    a := a->sort() ; 
        var i : int ; i := 0 ; while i < Q do ( (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var lidx : int ; lidx := (a->indexOf(l * 2 - 1) - 1) ;
    if (lidx < 0) then (     lidx := -lidx - 1 ) else skip ; 
    var ridx : int ; ridx := (a->indexOf(r * 2 + 1) - 1) ;
    if (ridx < 0) then (     ridx := -ridx - 1 ) else skip ; 
    result.printf("%d\n", ridx - lidx) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    return false 
 );
   attribute log : OclFile;
   attribute result : OclFile := OclFile["System.out"];
   attribute systemin : OclFile;
  static   attribute instance : Main := Main.newMain();
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     systemin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     log := OclFile.newOclFile_Write(OclFile()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     instance.main() ; 
     instance.systemin.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int[] arr ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int q=sc.nextInt();
    arr=new int[n+2];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    arr[n]=Integer.MAX_VALUE ;
    arr[n+1]=Integer.MIN_VALUE ;
    Arrays.sort(arr);
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<q ; i++){
      int left=sc.nextInt();
      int right=sc.nextInt();
      sb.append(getRightIdx(right)-getLeftIdx(left)+1).append("\n");
    }
    System.out.print(sb);
  }
  static int getLeftIdx(int x){
    int left=0 ;
    int right=arr.length ;
    while(right-left>1){
      int m=(left+right)/2 ;
      if(arr[m]<x){
        left=m ;
      }
      else {
        right=m ;
      }
    }
    return right ;
  }
  static int getRightIdx(int x){
    int left=0 ;
    int right=arr.length ;
    while(right-left>1){
      int m=(left+right)/2 ;
      if(arr[m]<=x){
        left=m ;
      }
      else {
        right=m ;
      }
    }
    return left ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute arr : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    arr := Integer.subrange(1,n + 2)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr[n+1] := 2147483647 ; 
    arr[n + 1+1] := -2147483648 ; 
    arr := arr->sort() ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < q do ( (     var left : int ; left := sc.getCurrent()->toInteger() ;
     var right : int ; right := sc.getCurrent()->toInteger() ;
     sb := sb + StringLib.newString(getRightIdx(right) - getLeftIdx(left) + 1) + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
  static   operation getLeftIdx( x : int) : int
  pre: true
  post: true
  activity: (     var left : int ; left := 0 ;
     var right : int ; right := arr->size() ;
     while (right - left > 1) do (     var m : int ; m := (left + right) / 2 ;
     if (arr[m+1] < x) then (     left := m ) else (     right := m ) ) ; 
     return right );
  static   operation getRightIdx( x : int) : int
  pre: true
  post: true
  activity: (     var left : int ; left := 0 ;
     var right : int ; right := arr->size() ;
     while (right - left > 1) do (     var m : int ; m := (left + right) / 2 ;
     if (arr[m+1] <= x) then (     left := m ) else (     right := m ) ) ; 
     return left );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int[] nums ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int q=sc.nextInt();
    nums=new int[n+1];
    nums[n]=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      nums[i]=sc.nextInt();
    }
    Arrays.sort(nums);
    for(int i=0 ; i<q ; i++){
      System.out.println(-(nibul(sc.nextInt())-nibur(sc.nextInt())));
    }
  }
  static int nibul(int q){
    int ans=nums.length/2 ;
    int toadd=nums.length/2 ;
    while(true){
      if(ans<0 || ans>=nums.length){
        break ;
      }
      if(nums[ans]>=q){
        ans-=Math.max(toadd/=2,1);
      }
      else if(nums[ans+1]<q){
        ans+=Math.max(toadd/=2,1);
      }
      else {
        break ;
      }
    }
    return ans ;
  }
  static int nibur(int q){
    int ans=nums.length/2 ;
    int toadd=nums.length/2 ;
    while(true){
      if(ans<0 || ans>=nums.length){
        break ;
      }
      if(nums[ans]>q){
        ans-=Math.max(toadd/=2,1);
      }
      else if(nums[ans+1]<=q){
        ans+=Math.max(toadd/=2,1);
      }
      else {
        break ;
      }
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute nums : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    nums := Integer.subrange(1,n + 1)->collect(0) ; 
    nums[n+1] := 2147483647 ; 
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    nums := nums->sort() ; 
        var i : int ; i := 0 ; while i < q do ( (     OclFile["System.out"].println(-(nibul(sc.getCurrent()->toInteger()) - nibur(sc.getCurrent()->toInteger()))) )  ;     i := i + 1 ) ; 
 );
  static   operation nibul( q : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := nums->size() / 2 ;
     var toadd : int ; toadd := nums->size() / 2 ;
     while (true) do (     if (ans < 0 or ans >= nums->size()) then (     break ) else skip ; 
     if (nums[ans+1] >= q) then (     ans := ans-(Set{toadd, 1}->max()) ) else     if (nums[ans + 1+1] < q) then (     ans := ans+(Set{toadd, 1}->max()) ) else (     break ) ;  ) ; 
     return ans );
  static   operation nibur( q : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := nums->size() / 2 ;
     var toadd : int ; toadd := nums->size() / 2 ;
     while (true) do (     if (ans < 0 or ans >= nums->size()) then (     break ) else skip ; 
     if (nums[ans+1] > q) then (     ans := ans-(Set{toadd, 1}->max()) ) else     if (nums[ans + 1+1] <= q) then (     ans := ans+(Set{toadd, 1}->max()) ) else (     break ) ;  ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printbinomial(int max){
    for(int m=0 ; m<=max ; m++){
      System.out.print(m+" ");
      int binom=1 ;
      for(int x=0 ; x<=m ; x++){
        if(m!=0 && x!=0)binom=binom*(m-x+1)/x ;
        System.out.print(binom+" ");
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    int max=10 ;
    printbinomial(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printbinomial( max : int) : void
  pre: true
  post: true
  activity: (         var m : int ; m := 0 ; while m <= max do ( (     OclFile["System.out"].print(m + " ") ; 
     var binom : int ; binom := 1 ;
         var x : int ; x := 0 ; while x <= m do ( (     if (m /= 0 & x /= 0) then     binom := binom * (m - x + 1) / x ; else skip ; 
     OclFile["System.out"].print(binom + " ") )  ;     x := x + 1 ) ; 
     OclFile["System.out"].println() )  ;     m := m + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var max : int ; max := 10 ;
     execute printbinomial(max) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findMinCost(int arr[],int n,int choc_cost){
    int choc_buy=arr[0];
    int curr_choc=0 ;
    for(int i=0 ; i<n-1 ; i++){
      int choc=arr[i]-arr[i+1];
      curr_choc+=choc ;
      if(curr_choc<0){
        choc_buy+=Math.abs(curr_choc);
        curr_choc=0 ;
      }
    }
    return choc_buy*choc_cost ;
  }
  public static void main(String[] args){
    int arr[]={
      10,6,11,4,7,1 };
      int n=arr.length ;
      int p=5 ;
      System.out.println(findMinCost(arr,n,p));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMinCost( arr : Sequence(int), n : int, choc_cost : int) : int
  pre: true
  post: true
  activity: (     var choc_buy : int ; choc_buy := arr[0+1] ;
     var curr_choc : int ; curr_choc := 0 ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     var choc : int ; choc := arr[i+1] - arr[i + 1+1] ;
     curr_choc := curr_choc+(choc) ; 
     if (curr_choc < 0) then (     choc_buy := choc_buy+(if curr_choc < 0 then -(curr_choc) else curr_choc endif) ; 
     curr_choc := 0 ) else skip )  ;     i := i + 1 ) ; 
     return choc_buy * choc_cost );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,6,11,4,7,1} ;
     var n : int ; n := arr->size() ;
     var p : int ; p := 5 ;
     OclFile["System.out"].println(findMinCost(arr, n, p)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    int total=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      total+=arr[i];
    }
    if(total % 2==0){
      System.out.println(total/2);
      return ;
    }
    Arrays.sort(arr);
    for(int i=0 ; i<n ; i++){
      if(arr[i] % 2==1){
        System.out.println((total-arr[i])/2);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     total := total+(arr[i+1]) )  ;     i := i + 1 ) ; 
    if (total mod 2 = 0) then (     OclFile["System.out"].println(total / 2) ; 
     return ) else skip ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 = 1) then (     OclFile["System.out"].println((total - arr[i+1]) / 2) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  static Scanner InData=new Scanner(System.in);
  static int qType,qVal ;
  static String qKey ;
  static Map<String,Integer>M=new HashMap<String,Integer>();
  public static void main(String[] args){
    getQuery();
  }
  private static void getQuery(){
    int qNum=InData.nextInt();
    for(int indexOfQuery=0 ; indexOfQuery<qNum ; indexOfQuery++){
      qType=InData.nextInt();
      qKey=InData.next();
      doQuery(qType,qKey);
    }
  }
  private static void doQuery(int type,String key){
    switch(type){
      case 0 : qVal=InData.nextInt();
      M.put(key,qVal);
      break ;
      case 1 : if(M.containsKey(key))System.out.println(M.get(key));
      else System.out.println(0);
      break ;
      case 2 : M.remove(key);
      break ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute InData : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute qType : int;
  static   attribute qKey : String;
  static   attribute M : Map(String,int) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute getQuery() );
  static   operation getQuery() : void
  pre: true
  post: true
  activity: (     var qNum : int ; qNum := InData.getCurrent()->toInteger() ;
         var indexOfQuery : int ; indexOfQuery := 0 ; while indexOfQuery < qNum do ( (     qType := InData.getCurrent()->toInteger() ; 
     qKey := InData.getCurrent() ; 
     execute doQuery(qType, qKey) )  ;     indexOfQuery := indexOfQuery + 1 ) );
  static   operation doQuery( type : int, key : String) : void
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (type) ; 
       if _switchval = 0 then
     qVal := InData.getCurrent()->toInteger() ; 
    M := M->union(Map{key |-> qVal}) ; 
    break 
   else skip ;
       if _switchval = 1 then
     if (M->keys()->includes(key)) then     OclFile["System.out"].println(M->at(key)) else     OclFile["System.out"].println(0) ; ;  
    break 
   else skip ;
       if _switchval = 2 then
     M := M->antirestrict(Set{key}) ; 
    break 
   else skip ;
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countDigits(int n){
    int count=0 ;
    while(n>0){
      count++;
      n=n/10 ;
    }
    return count ;
  }
  static int checkPrime(int n){
    if(n<=1)return-1 ;
    if(n<=3)return 0 ;
    if(n % 2==0 || n % 3==0)return-1 ;
    for(int i=5 ; i*i<=n ; i=i+6)if(n % i==0 || n %(i+2)==0)return-1 ;
    return 0 ;
  }
  static void printPrimePoints(int n){
    int count=countDigits(n);
    if(count==1 || count==2){
      System.out.print("-1");
      return ;
    }
    boolean found=false ;
    for(int i=1 ; i<(count-1); i++){
      int left=n/((int)Math.pow(10,count-i));
      int right=n %((int)Math.pow(10,count-i-1));
      if(checkPrime(left)==0 && checkPrime(right)==0){
        System.out.print(i+" ");
        found=true ;
      }
    }
    if(found==false)System.out.print("-1");
  }
  public static void main(String[] args){
    int n=2317 ;
    printPrimePoints(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDigits( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     count := count + 1 ; 
     n := n / 10 ) ; 
     return count );
  static   operation checkPrime( n : int) : int
  pre: true
  post: true
  activity: (     if (n <= 1) then     return -1 else skip ; 
     if (n <= 3) then     return 0 else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return -1 else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return -1 else skip ;  ;     i := i + 6 ) ; 
    return 0 
 );
  static   operation printPrimePoints( n : int) : void
  pre: true
  post: true
  activity: (     var count : int ; count := countDigits(n) ;
     if (count = 1 or count = 2) then (     OclFile["System.out"].print("-1") ; 
     return ) else skip ; 
    var found : boolean ; found := false ;
        var i : int ; i := 1 ; while i < (count - 1) do ( (     var left : int ; left := n / (10->pow(count - i)->oclAsType(int)) ;
     var right : int ; right := n mod (10->pow(count - i - 1)->oclAsType(int)) ;
     if (checkPrime(left) = 0 & checkPrime(right) = 0) then (     OclFile["System.out"].print(i + " ") ; 
     found := true ) else skip )  ;     i := i + 1 ) ; 
    if (found = false) then     OclFile["System.out"].print("-1") ; else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2317 ;
     execute printPrimePoints(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void print_first_N_primes(int N){
    int i,j,flag ;
    System.out.println("Prime numbers between 1 and "+N+" are:");
    for(i=1 ; i<=N ; i++){
      if(i==1 || i==0)continue ;
      flag=1 ;
      for(j=2 ; j<=i/2 ; ++j){
        if(i % j==0){
          flag=0 ;
          break ;
        }
      }
      if(flag==1)System.out.print(i+" ");
    }
  }
  public static void main(String[] args){
    int N=100 ;
    print_first_N_primes(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation print_first_N_primes( N : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var flag : int ;
     OclFile["System.out"].println("Prime numbers between 1 and " + N + " are:") ; 
         i := 1 ; while i <= N do ( (     if (i = 1 or i = 0) then     continue else skip ; 
     flag := 1 ; 
         j := 2 ; while j <= i / 2 do ( (     if (i mod j = 0) then (     flag := 0 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (flag = 1) then     OclFile["System.out"].print(i + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 100 ;
     execute print_first_N_primes(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int divSum(int n){
    int result=0 ;
    for(int i=2 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        if(i==(n/i))result+=i ;
        else result+=(i+n/i);
      }
    }
    return(result+n+1);
  }
  public static void main(String[] args){
    int n=30 ;
    System.out.println(divSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation divSum( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 2 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     if (i = (n / i)) then     result := result+(i) ; else     result := result+((i + n / i)) ; ) else skip )  ;     i := i + 1 ) ; 
     return (result + n + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 30 ;
     OclFile["System.out"].println(divSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String W=in.readLine();
    int N=Integer.parseInt(W);
    String ans="No" ;
    if(N>81){
      ans="No" ;
    }
    else {
      for(int a=1 ; a<10 ; a++){
        for(int b=1 ; b<10 ; b++){
          if(a*b==N){
            ans="Yes" ;
            break ;
          }
          if(ans.equals("Yes")){
            break ;
          }
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var W : String ; W := in.readLine() ;
    var N : int ; N := (W)->toInteger() ;
    var ans : String ; ans := "No" ;
    if (N > 81) then (     ans := "No" ) else (         var a : int ; a := 1 ; while a < 10 do ( (         var b : int ; b := 1 ; while b < 10 do ( (     if (a * b = N) then (     ans := "Yes" ; 
     break ) else skip ; 
     if (ans = "Yes") then (     break ) else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeforces1707A {
  public static void main(String[] args)throws IOException {
    FastReader in=new FastReader();
    int numCases=in.nextInt();
    StringBuilder ans=new StringBuilder();
    while(numCases-->0){
      int n=in.nextInt();
      int q=in.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=in.nextInt();
      }
      StringBuilder curr=new StringBuilder();
      int a=0 ;
      int b=0 ;
      for(int i=n-1 ; i>=0 ; i--){
        if(arr[i]<=a){
          b++;
          curr.append(1);
        }
        else if(a<q){
          curr.append(1);
          a++;
          b++;
        }
        else {
          curr.append(0);
        }
      }
      curr.reverse();
      ans.append(curr);
      if(numCases>0)ans.append("\n");
    }
    System.out.println(ans);
  }
  static class FastReader {
    StringTokenizer st ;
    BufferedReader br ;
    public FastReader(){
      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 s="" ;
      while(st==null || st.hasMoreElements()){
        try {
          s=br.readLine();
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return s ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces1707A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var numCases : int ; numCases := in.nextInt() ;
    var ans : String ; ans := StringLib.newString() ;
        while (numCases > 0) do (        numCases := numCases - 1 ;     skip ; (     var n : int ; n := in.nextInt() ;
     var q : int ; q := in.nextInt() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    var curr : String ; curr := StringLib.newString() ;
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
        var i : int ; i := (n)->char2byte() - 1 ; while i >= 0 do ( (     if (arr[i+1] <= a) then (     b := b + 1 ; 
     curr := curr + StringLib.newString(1) ) else     if (a < q) then (     curr := curr + StringLib.newString(1) ; 
     a := a + 1 ; 
     b := b + 1 ) else (     curr := curr + StringLib.newString(0) ) ;  )  ;     i := i - 1 ) ; 
    curr := curr->reverse() ; 
    ans := ans + StringLib.newString(curr) ; 
    if (numCases > 0) then     ans := ans + StringLib.newString("\n") ; else skip ; 
 ) ;  ) ;  
    OclFile["System.out"].println(ans) ; 
 );
  static class FastReader {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var s : String ; s := "" ;
     while (st = null or st.hasNext()) do (     try (     s := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return s );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.StringTokenizer ;
public class DOREMYIQ {
  public static void main(String[] args){
    new Task(new InputReader());
  }
  static class Task {
    public Task(InputReader sc){
      PrintWriter out=new PrintWriter(System.out);
      for(short T=sc.nextShort(); T>0 ; T--){
        int n=sc.nextInt(),q=sc.nextInt();
        List<Integer>contest=new ArrayList<>();
        for(int i=0 ; i<n ; i++)contest.add(sc.nextInt());
        int low=0,high=n ;
        while(low<high){
          int mid=(low+high)>>1,now=q ;
          boolean ok=true ;
          for(int i=mid ; i<n ; i++){
            if(now==0){
              ok=false ;
              break ;
            }
            if(contest.get(i)>now)now-=1 ;
          }
          if(ok)high=mid ;
          else low=mid+1 ;
        }
        for(int i=0 ; i<low ; i++)out.print(contest.get(i)<=q ? 1 : 0);
        for(int i=low ; i<n ; i++)out.print(1);
        out.println();
      }
      out.close();
    }
  }
  static class InputReader {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tokenizer=null ;
    public InputReader(){
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreElements()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public short nextShort(){
      return Short.parseShort(next());
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DOREMYIQ {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Task.newTask(InputReader.newInputReader()) );
  static class Task {
   static operation newTask( sc : InputReader) : Task
  pre: true
  post: true
  activity:
  ( var self : Task ;
    self := createTask();
    self.initialise(sc);
    return self );
  operation initialise( sc : InputReader) : void
  pre: true  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
         var T : int ; T := sc.nextShort() ; while T > 0 do ( (     var n : int ; n := sc.nextInt() ;
    var q : int ; q := sc.nextInt() ;
     var contest : Sequence(int) ; contest := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     contest := contest->including(sc.nextInt()) ;  ;     i := i + 1 ) ; 
    var low : int ; low := 0 ;
    var high : int ; high := n ;
    while (low < high) do (     var mid : int ; mid := ((low + high)/(2->pow(1)))->oclAsType(long) ;
    var now : int ; now := q ;
     var ok : boolean ; ok := true ;
         var i : int ; i := mid ; while i < n do ( (     if (now = 0) then (     ok := false ; 
     break ) else skip ; 
     if (contest->at(i+1) > now) then     now := now-(1) ; else skip )  ;     i := i + 1 ) ; 
     if (ok) then     high := mid ; else     low := mid + 1 ; ) ; 
        var i : int ; i := 0 ; while i < low do (     skip ;  ;     i := i + 1 ) ; 
        var i : int ; i := low ; while i < n do (     skip ;  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     T := T - 1 ) ; 
     skip );
}
  static class InputReader {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute tokenizer : OclIterator := null;
   static operation newInputReader() : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean isPower(int a){
    if(a==1)return true ;
    for(int i=2 ; i*i<=a ; i++){
      double val=Math.log(a)/Math.log(i);
      if((val-(int)val)<0.00000001)return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    int n=16 ;
    System.out.println(isPower(n)? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPower( a : int) : boolean
  pre: true
  post: true
  activity: (     if (a = 1) then     return true else skip ; 
         var i : int ; i := 2 ; while i * i <= a do ( (     var val : double ; val := (a)->log() / (i)->log() ;
     if ((val - val->oclAsType(int)) < 0.00000001) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 16 ;
     OclFile["System.out"].println(if isPower(n) then "Yes" else "No" endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.BufferedReader ;
public class Main {
  static final int MAX_X=8 ;
  static final int MAX_Y=8 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s ;
    do {
      int[][] map=new int[MAX_Y+1][MAX_X+2];
      for(int i=0 ; i<MAX_Y ; i++){
        s=br.readLine();
        for(int j=1 ; j<MAX_X+1 ; j++)map[i][j]=Integer.parseInt(s.charAt(j-1)+"");
      }
      System.out.println(figure(map));
    }
    while((s=br.readLine())!=null && s.isEmpty());
  }
  private static char figure(int[][] map){
    for(int i=0 ; i<MAX_Y ; i++){
      for(int j=1 ; j<MAX_X+1 ; j++){
        if(map[i][j]==1){
          if(map[i+1][j]==1 && map[i][j+1]==1){
            if(map[i+1][j+1]==1)return 'A' ;
            else return 'G' ;
          }
          else if(map[i+1][j]==0 && map[i][j+1]==1){
            if(map[i+1][j+1]==1)return 'E' ;
            else return 'C' ;
          }
          else {
            if(map[i+1][j+1]==1)return 'F' ;
            else if(map[i+1][j-1]==1)return 'D' ;
            else return 'B' ;
          }
        }
      }
    }
    return '0' ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX_X : int := 8;
  static    attribute MAX_Y : int := 8;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ;
   while true do ((     var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,MAX_Y + 1)->collect(Integer.subrange(1,MAX_X + 2)->collect(0)) ;
         var i : int ; i := 0 ; while i < MAX_Y do ( (     s := br.readLine() ; 
         var j : int ; j := 1 ; while j < MAX_X + 1 do (     map[i+1][j+1] := (s->at(j - 1+1) + "")->toInteger() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(figure(map)) ) ;
    if ((s) /= null & s->isEmpty()) then
      skip else break) );
  static   operation figure( map : Sequence(Sequence(int))) : String
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < MAX_Y do ( (         var j : int ; j := 1 ; while j < MAX_X + 1 do ( (     if (map[i+1][j+1] = 1) then (     if (map[i + 1+1][j+1] = 1 & map[i+1][j + 1+1] = 1) then (     if (map[i + 1+1][j + 1+1] = 1) then     return 'A' else     return 'G' ) else     if (map[i + 1+1][j+1] = 0 & map[i+1][j + 1+1] = 1) then (     if (map[i + 1+1][j + 1+1] = 1) then     return 'E' else     return 'C' ) else (     if (map[i + 1+1][j + 1+1] = 1) then     return 'F' else     if (map[i + 1+1][j - 1+1] = 1) then     return 'D' else     return 'B' ;  ) ;  ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return '0' );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      while(true){
        String line[]=new String[8];
        char c='A' ;
        int mem[]=new int[2];
        for(int i=0 ; i<8 ; i++){
          line[i]=br.readLine();
        }
        for(int i=0 ; i<8 ; i++){
          if(line[i] .indexOf("1111")!=-1){
            c='C' ;
            break ;
          }
          else if((mem[0]=line[i] .indexOf("11"))!=-1){
            mem[1]=line[i+1] .indexOf("11");
            if(mem[0]==mem[1]){
              c='A' ;
              break ;
            }
            else if(mem[0]+1==mem[1]){
              c='E' ;
              break ;
            }
            else if(mem[0]-1==mem[1]){
              c='G' ;
              break ;
            }
          }
          else if((mem[0]=line[i] .indexOf("1"))!=-1){
            mem[1]=line[i+1] .indexOf("11");
            if(mem[0]==mem[1]){
              c='F' ;
              break ;
            }
            else if(mem[0]-1==mem[1] && mem[1]>=0){
              c='D' ;
              break ;
            }
            else {
              c='B' ;
              break ;
            }
          }
        }
        System.out.println(c);
        if(br.readLine()==null)break ;
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     while (true) do (     var line : Sequence(String) ; line := Integer.subrange(1,8)->collect(null) ;
     var c : String ; c := 'A' ;
    var mem : Sequence(int) ; mem := Integer.subrange(1,2)->collect(0) ;
        var i : int ; i := 0 ; while i < 8 do ( (     line[i+1] := br.readLine() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 8 do ( (     if (line[i+1]->indexOf("1111")-1 /= -1) then (     c := 'C' ; 
     break ) else     if ((mem[0+1]) /= -1) then (     mem[1+1] := line[i + 1+1]->indexOf("11")-1 ; 
     if (mem[0+1] = mem[1+1]) then (     c := 'A' ; 
     break ) else     if (mem[0+1] + 1 = mem[1+1]) then (     c := 'E' ; 
     break ) else     if (mem[0+1] - 1 = mem[1+1]) then (     c := 'G' ; 
     break ) else skip ; ;  ) else     if ((mem[0+1]) /= -1) then (     mem[1+1] := line[i + 1+1]->indexOf("11")-1 ; 
     if (mem[0+1] = mem[1+1]) then (     c := 'F' ; 
     break ) else     if (mem[0+1] - 1 = mem[1+1] & mem[1+1] >= 0) then (     c := 'D' ; 
     break ) else (     c := 'B' ; 
     break ) ;  ) else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
    if (br.readLine() = null) then     break else skip ; 
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  private static Map<Integer,String>map=new HashMap<Integer,String>();
  static {
    map.put(771,"A");
    map.put(16843009,"B");
    map.put(15,"C");
    map.put(33153,"D");
    map.put(1539,"E");
    map.put(131841,"F");
    map.put(387,"G");
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in).useRadix(2);
    int i=0 ;
    while(in.hasNext()){
      i<<=8 ;
      i |=in.nextInt();
      if(Integer.bitCount(i)==4){
        i>>>=Integer.numberOfTrailingZeros(i);
        System.out.println(map.get(i));
        i=0 ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute map : Map(int,String) := Map{};
  static operation initialiseClass()
  pre: true post: true
  activity:     map := map->union(Map{771 |-> "A"}) ; 
    map := map->union(Map{16843009 |-> "B"}) ; 
    map := map->union(Map{15 |-> "C"}) ; 
    map := map->union(Map{33153 |-> "D"}) ; 
    map := map->union(Map{1539 |-> "E"}) ; 
    map := map->union(Map{131841 |-> "F"}) ; 
    map := map->union(Map{387 |-> "G"}) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]).useRadix(2) ;
     var i : int ; i := 0 ;
     while (in.hasNext()) do (     i := i*(2->pow(8)) ; 
     i := MathLib.bitwiseOr(i, in.getCurrent()->toInteger()) ; 
     if (bitCount(i) = 4) then (     i := i/(2->pow(numberOfTrailingZeros(i))) ; 
     OclFile["System.out"].println(map->at(i)) ; 
     i := 0 ) else skip ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ProgressBar {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    int t=scan.nextInt();
    double temp=(t*k*n)/100.0 ;
    int x=0 ;
    while(temp-k>=0){
      temp-=k ;
      x++;
    }
    for(int i=0 ; i<x ; i++)System.out.print(k+" ");
    if(temp!=0){
      System.out.print((int)temp+" ");
      x++;
    }
    for(int i=x ; i<n ; i++)System.out.print(0+" ");
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProgressBar {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var t : int ; t := scan.getCurrent()->toInteger() ;
    var temp : double ; temp := (t * k * n) / 100.0 ;
    var x : int ; x := 0 ;
    while (temp - k >= 0) do (     temp := temp-(k) ; 
     x := x + 1 ) ; 
        var i : int ; i := 0 ; while i < x do (     OclFile["System.out"].print(k + " ") ;  ;     i := i + 1 ) ; 
    if (temp /= 0) then (     OclFile["System.out"].print(temp->oclAsType(int) + " ") ; 
     x := x + 1 ) else skip ; 
        var i : int ; i := x ; while i < n do (     OclFile["System.out"].print(0 + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    String A="1100000011" ;
    String B="1000000010000000100000001" ;
    String C="1111" ;
    String D="1000000110000001" ;
    String E="11000000011" ;
    String F="100000001100000001" ;
    String G="110000011" ;
    for(; sc.hasNext(); ){
      String buffer=sc.nextLine();
      if(buffer.length()<8){
        continue ;
      }
      for(int i=1 ; i<8 ; i++){
        buffer+=sc.nextLine();
      }
      if(buffer.indexOf(A)!=-1){
        System.out.println("A");
      }
      if(buffer.indexOf(B)!=-1){
        System.out.println("B");
      }
      if(buffer.indexOf(C)!=-1){
        System.out.println("C");
      }
      if(buffer.indexOf(D)!=-1){
        System.out.println("D");
      }
      if(buffer.indexOf(E)!=-1){
        System.out.println("E");
      }
      if(buffer.indexOf(F)!=-1){
        System.out.println("F");
      }
      if(buffer.indexOf(G)!=-1){
        System.out.println("G");
      }
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var A : String ; A := "1100000011" ;
     var B : String ; B := "1000000010000000100000001" ;
    var C : String ; C := "1111" ;
    var D : String ; D := "1000000110000001" ;
    var E : String ; E := "11000000011" ;
    var F : String ; F := "100000001100000001" ;
    var G : String ; G := "110000011" ;
      while sc.hasNext() do ( (     var buffer : String ; buffer := sc.nextLine() ;
     if (buffer->size() < 8) then (     continue ) else skip ; 
        var i : int ; i := 1 ; while i < 8 do ( (     buffer := buffer+(sc.nextLine()) )  ;     i := i + 1 ) ; 
    if (buffer->indexOf(A)-1 /= -1) then (     OclFile["System.out"].println("A") ) else skip ; 
    if (buffer->indexOf(B)-1 /= -1) then (     OclFile["System.out"].println("B") ) else skip ; 
    if (buffer->indexOf(C)-1 /= -1) then (     OclFile["System.out"].println("C") ) else skip ; 
    if (buffer->indexOf(D)-1 /= -1) then (     OclFile["System.out"].println("D") ) else skip ; 
    if (buffer->indexOf(E)-1 /= -1) then (     OclFile["System.out"].println("E") ) else skip ; 
    if (buffer->indexOf(F)-1 /= -1) then (     OclFile["System.out"].println("F") ) else skip ; 
    if (buffer->indexOf(G)-1 /= -1) then (     OclFile["System.out"].println("G") ) else skip ; 
 )  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
public class Main {
  public static void main(String[] args){
    try {
      final int SIZE=20+10*8*((8+4)*8);
      byte[] buf=new byte[SIZE];
      int count=0 ;
      int limit=System.in.read(buf,0,SIZE);
      while(count<limit){
        int box[]=new int[4];
        int i=0 ;
        int head=0 ;
        int[] x=new int[4];
        while(count<limit){
          if(buf[count]=='1'){
            box[i]=count ;
            x[i]=head ;
            i++;
          }
          if(buf[count]!='0' && buf[count]!='1')head=0 ;
          else head++;
          count++;
          if(i>3)break ;
        }
        if(i!=4)break ;
        if(box[0]==box[1]-1){
          switch(x[2]-x[0]){
            case-1 : System.out.println("G");
            break ;
            case 0 : System.out.println("A");
            break ;
            case 1 : System.out.println("E");
            break ;
            case 2 : System.out.println("C");
            break ;
          }
        }
        else {
          switch(x[3]-x[0]){
            case-1 : System.out.println("D");
            break ;
            case 0 : System.out.println("B");
            break ;
            case 1 : System.out.println("F");
            break ;
          }
        }
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var SIZE : int ; SIZE := 20 + 10 * 8 * ((8 + 4) * 8) ;
     var buf : Sequence(int) ; buf := Integer.subrange(1,SIZE)->collect(0) ;
    var count : int ; count := 0 ;
    var limit : int ; limit := OclFile["System.in"].read(buf, 0, SIZE) ;
    while (count < limit) do (     var box : Sequence(int) ; box := Integer.subrange(1,4)->collect(0) ;
     var i : int ; i := 0 ;
    var head : int ; head := 0 ;
    var x : Sequence(int) ; x := Integer.subrange(1,4)->collect(0) ;
    while (count < limit) do (     if (buf[count+1] = '1') then (     box[i+1] := count ; 
     x[i+1] := head ; 
     i := i + 1 ) else skip ; 
     if (buf[count+1] /= '0' & buf[count+1] /= '1') then     head := 0 else     head := head + 1 ; ;  
     count := count + 1 ; 
     if (i > 3) then     break else skip ) ; 
    if (i /= 4) then     break else skip ; 
    if (box[0+1] = box[1+1] - 1) then ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (x[2+1] - x[0+1]) ; 
       if _switchval = -1 then
     OclFile["System.out"].println("G") ; 
    break 
   else skip ;
       if _switchval = 0 then
     OclFile["System.out"].println("A") ; 
    break 
   else skip ;
       if _switchval = 1 then
     OclFile["System.out"].println("E") ; 
    break 
   else skip ;
       if _switchval = 2 then
     OclFile["System.out"].println("C") ; 
    break 
   else skip ;
 )
 ) else ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (x[3+1] - x[0+1]) ; 
       if _switchval = -1 then
     OclFile["System.out"].println("D") ; 
    break 
   else skip ;
       if _switchval = 0 then
     OclFile["System.out"].println("B") ; 
    break 
   else skip ;
       if _switchval = 1 then
     OclFile["System.out"].println("F") ; 
    break 
   else skip ;
 )
 ) ;  
 ) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static boolean checkYear(int year){
    if(year % 400==0)return true ;
    if(year % 100==0)return false ;
    if(year % 4==0)return true ;
    return false ;
  }
  public static void main(String[] args){
    int year=2000 ;
    System.out.println(checkYear(2000)? "Leap Year" : "Not a Leap Year");
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation checkYear( year : int) : boolean
  pre: true
  post: true
  activity: (     if (year mod 400 = 0) then     return true else skip ; 
     if (year mod 100 = 0) then     return false else skip ; 
     if (year mod 4 = 0) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var year : int ; year := 2000 ;
     OclFile["System.out"].println(if checkYear(2000) then "Leap Year" else "Not a Leap Year" endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static boolean checkYear(int year){
    return(((year % 4==0)&&(year % 100!=0))||(year % 400==0));
  }
  public static void main(String[] args){
    int year=2000 ;
    System.out.println(checkYear(2000)? "Leap Year" : "Not a Leap Year");
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation checkYear( year : int) : boolean
  pre: true
  post: true
  activity: (     return (((year mod 4 = 0) & (year mod 100 /= 0)) or (year mod 400 = 0)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var year : int ; year := 2000 ;
     OclFile["System.out"].println(if checkYear(2000) then "Leap Year" else "Not a Leap Year" endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.io.FileInputStream ;
import java.io.InputStream ;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.lang.Integer.*;
import static java.lang.Character.*;
public class B {
  Scanner scan ;
  InputStream in ;
  int intLine(){
    return parseInt(scan.nextLine());
  }
  String find(long A,long B,long area){
    for(long a=1 ; a<=A ; a++)for(long b=1 ; b<=B ; b++){
      for(long x=0 ; x<=b ; x++)for(long y=0 ; y<=a ; y++){
        long r=x*a+y*b-x*y ;
        if(r==area){
          return String.format("%d %d %d %d %d %d",0,x,y,0,a,b);
        }
      }
    }
    return null ;
  }
  String solve(){
    long res=0 ;
    int A=scan.nextInt();
    int B=scan.nextInt();
    long area=scan.nextLong();
    if(find(A,B,area)!=null)return find(A,B,area);
    return "IMPOSSIBLE" ;
  }
  void solveAll(){
    int N=parseInt(scan.nextLine());
    for(int i=0 ; i<N ; i++){
      String r=solve();
      System.out.format("Case #%d: %s\n",i+1,r);
    }
  }
  B()throws Exception {
    in=new BufferedInputStream(new FileInputStream("B-small-attempt0.in"));
    scan=new Scanner(in);
  }
  public static void main(String[] args)throws Exception {
    Locale.setDefault(Locale.US);
    new B().solveAll();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
   attribute scan : OclFile;
   attribute in : OclFile;
   operation intLine() : int
  pre: true
  post: true
  activity: (     return (scan.nextLine() + "")->toInteger() );
   operation find( A : long, B : long, area : long) : String
  pre: true
  post: true
  activity: (         var a : long ; a := 1 ; while a <= A do (         var b : long ; b := 1 ; while b <= B do ( (         var x : long ; x := 0 ; while x <= b do (         var y : long ; y := 0 ; while y <= a do ( (     var r : long ; r := x * a + y * b - x * y ;
     if (r = area) then (     return StringLib.format("%d %d %d %d %d %d",Sequence{0,x,y,0,a,b}) ) else skip )  ;     y := y + 1 ) ;  ;     x := x + 1 ) )  ;     b := b + 1 ) ;  ;     a := a + 1 ) ; 
     return null );
   operation solve() : String
  pre: true
  post: true
  activity: (     var res : long ; res := 0 ;
     var A : int ; A := scan.getCurrent()->toInteger() ;
    var B : int ; B := scan.getCurrent()->toInteger() ;
    var area : long ; area := scan.getCurrent()->toLong() ;
    if (find(A, B, area) /= null) then     return find(A, B, area) else skip ; 
    return "IMPOSSIBLE" 
 );
   operation solveAll() : void
  pre: true
  post: true
  activity: (     var N : int ; N := parseInt(scan.nextLine()) ;
         var i : int ; i := 0 ; while i < N do ( (     var r : String ; r := solve() ;
     OclFile["System.out"].format("Case #%d: %s\n", i + 1, r) )  ;     i := i + 1 ) );
   static operation newB() : B
  pre: true
  post: true
  activity:
  ( var self : B ;
    self := createB();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("B-small-attempt0.in"))) ; 
     scan := OclFile.newOclFile_Read(in) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.US) ; 
     B.newB().solveAll() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc ;
  public static void main(String[] args){
    sc=new Scanner(System.in);
    b();
  }
  public static void a(){
    int a=sc.nextInt();
    int b=sc.nextInt();
    System.out.println((a>9 || b>9)?-1 : a*b);
  }
  public static void b(){
    int n=sc.nextInt();
    int po[]=new int[81];
    boolean b=false ;
    for(int i=0 ; i<9 ; i++)for(int j=0 ; j<9 ; j++)if((i+1)*(j+1)==n)b=true ;
    System.out.println(b ? "Yes" : "No");
  }
  public static void c(){
    long n=sc.nextLong();
    long q=(long)Math.sqrt(n);
    long index=n ;
    for(int i=2 ; i<=q ; i++){
      if(n % i==0)index=i ;
    }
    System.out.println(index+(n/index)-2);
  }
  public static void d(){
    int a=sc.nextInt();
    int b=sc.nextInt();
    int x=sc.nextInt();
    if((double)2*x/(a*a)-b>=0){
      double bb=((double)2*x)/(a*a)-b ;
      System.out.println(Math.atan((-bb+b)/a)*180/Math.PI);
    }
    else {
      double aa=((double)2*x)/(a*b);
      System.out.println(Math.atan(((double)b)/aa)*180/Math.PI);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     execute b() );
  static   operation a() : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if (a > 9 or b > 9) then -1 else a * b endif) );
  static   operation b() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var po : Sequence(int) ; po := Integer.subrange(1,81)->collect(0) ;
    var b : boolean ; b := false ;
        var i : int ; i := 0 ; while i < 9 do (         var j : int ; j := 0 ; while j < 9 do (     if ((i + 1) * (j + 1) = n) then     b := true ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if b then "Yes" else "No" endif) ; 
 );
  static   operation c() : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.getCurrent()->toLong() ;
     var q : long ; q := (n)->sqrt()->oclAsType(long) ;
    var index : long ; index := n ;
        var i : int ; i := 2 ; while i <= q do ( (     if (n mod i = 0) then     index := i ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(index + (n / index) - 2) ; 
 );
  static   operation d() : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (2->oclAsType(double) * x / (a * a) - b >= 0) then (     var bb : double ; bb := (2->oclAsType(double) * x) / (a * a) - b ;
     OclFile["System.out"].println(((-bb + b) / a)->atan() * 180 / 3.141592653589793) ) else (     var aa : double ; aa := (2->oclAsType(double) * x) / (a * b) ;
     OclFile["System.out"].println(((b->oclAsType(double)) / aa)->atan() * 180 / 3.141592653589793) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findevenPair(int A[],int N){
    int count=0 ;
    for(int i=0 ; i<N ; i++)if(A[i] % 2!=0)count++;
    int oddCount=count*(count-1)/2 ;
    return(N*(N-1)/2)-oddCount ;
  }
  public static void main(String[] args){
    int a[]={
      5,1,3,2 };
      int n=a.length ;
      System.out.print(findevenPair(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findevenPair( A : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < N do (     if (A[i+1] mod 2 /= 0) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     var oddCount : int ; oddCount := count * (count - 1) / 2 ;
     return (N * (N - 1) / 2) - oddCount );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{5,1,3,2} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(findevenPair(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class detheap {
  static boolean isMinHeap(int[] level){
    int n=level.length-1 ;
    for(int i=(n/2-1); i>=0 ; i--){
      if(level[i]>level[2*i+1])return false ;
      if(2*i+2<n){
        if(level[i]>level[2*i+2])return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args)throws IOException {
    int[] level=new int[] {
      10,15,14,25,30 };
      if(isMinHeap(level))System.out.println("True");
      else System.out.println("False");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class detheap {
  static   operation isMinHeap( level : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := level->size() - 1 ;
         var i : int ; i := (n / 2 - 1) ; while i >= 0 do ( (     if (level[i+1] > level[2 * i + 1+1]) then     return false else skip ; 
     if (2 * i + 2 < n) then (     if (level[i+1] > level[2 * i + 2+1]) then     return false else skip ) else skip )  ;     i := i - 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var level : Sequence(int) ; level := Sequence{10,15,14,25,30} ;
     if (isMinHeap(level)) then     OclFile["System.out"].println("True") ; else     OclFile["System.out"].println("False") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countDecoding(char[] digits,int n){
    if(n==0 || n==1)return 1 ;
    if(digits[0]=='0')return 0 ;
    int count=0 ;
    if(digits[n-1]>'0')count=countDecoding(digits,n-1);
    if(digits[n-2]=='1' ||(digits[n-2]=='2' && digits[n-1]<'7'))count+=countDecoding(digits,n-2);
    return count ;
  }
  public static void main(String[] args){
    char digits[]={
      '1','2','3','4' };
      int n=digits.length ;
      System.out.printf("Count is %d",countDecoding(digits,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countDecoding( digits : Sequence(String), n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0 or n = 1) then     return 1 else skip ; 
     if (digits[0+1] = '0') then     return 0 else skip ; 
    var count : int ; count := 0 ;
    if (digits[n - 1+1] > '0') then     count := countDecoding(digits, n - 1) ; else skip ; 
    if (digits[n - 2+1] = '1' or (digits[n - 2+1] = '2' & digits[n - 1+1] < '7')) then     count := count+(countDecoding(digits, n - 2)) ; else skip ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var digits : Sequence(String) ; digits := Sequence{'1','2','3','4'} ;
     var n : int ; n := digits->size() ;
     OclFile["System.out"].printf("Count is %d", countDecoding(digits, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String month[]=new String[] {
      "January","February","March","April","May","June","July","August","September","October","November","December" };
      String n=sc.next();
      int sum=0 ;
      int k=sc.nextInt();
      for(int i=0 ; i<month.length ; i++){
        if(n.equals(month[i]))sum=i ;
      }
      sum=(sum+k)% 12 ;
      System.out.println(month[sum]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var month : Sequence(String) ; month := Sequence{"January","February","March","April","May","June","July","August","September","October","November","December"} ;
    var n : String ; n := sc.getCurrent() ;
    var sum : int ; sum := 0 ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < month->size() do ( (     if (n = month[i+1]) then     sum := i ; else skip )  ;     i := i + 1 ) ; 
    sum := (sum + k) mod 12 ; 
    OclFile["System.out"].println(month[sum+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import static java.lang.Double.parseDouble ;
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
public class Main {
  static BufferedWriter of=null ;
  static {
    try {
      of=new BufferedWriter(new FileWriter(new File("filee.txt")));
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  private static BufferedWriter ifile=null ;
  static {
    try {
      ifile=new BufferedWriter(new FileWriter(String.valueOf(System.in)));
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  private static final BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
  private static final Fast input=new Fast();
  public static void main(String[] args)throws IOException {
    String[] month={
      "January","February","March","April","May","June","July","August","September","October","November","December" };
      String s=input.next();
      int n=input.nextInt();
      for(int i=0 ; i<month.length ; i++){
        if(month[i] .equals(s)){
          n=(n+i)% 12 ;
          System.out.println(month[n]);
          break ;
        }
      }
    }
    public static class Fast {
      BufferedReader br ;
      StringTokenizer st ;
      public Fast(){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
      public Fast(FileReader f){
        br=new BufferedReader(f);
      }
      public String next()throws IOException {
        while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return st.nextToken();
      }
      public int nextInt()throws IOException {
        return parseInt(next());
      }
      public long nextLong()throws IOException {
        return parseLong(next());
      }
      public double nextDouble()throws IOException {
        return parseDouble(next());
      }
      public float nextFloat()throws IOException {
        return Float.parseFloat(next());
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute of : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     try (     of := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile("filee.txt"))) )   catch (e : IOException) do (     e.printStackTrace() )
;
  static   attribute ifile : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     try (     ifile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(((OclFile["System.in"]) + ""))) )   catch (e : IOException) do (     e.printStackTrace() )
;
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static    attribute input : Fast := Fast.newFast();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var month : Sequence(String) ; month := Sequence{"January","February","March","April","May","June","July","August","September","October","November","December"} ;
     var s : String ; s := input.next() ;
     var n : int ; n := input.nextInt() ;
         var i : int ; i := 0 ; while i < month->size() do ( (     if (month[i+1] = s) then (     n := (n + i) mod 12 ; 
     OclFile["System.out"].println(month[n+1]) ; 
     break ) else skip )  ;     i := i + 1 ) );
  static class Fast {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFast() : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   static operation newFast( f : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(f) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next() + "")->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return parseDouble(next()) );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
import static java.lang.Double.parseDouble ;
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
public class Main {
  static BufferedWriter of=null ;
  static {
    try {
      of=new BufferedWriter(new FileWriter(new File("filee.txt")));
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  private static BufferedWriter ifile=null ;
  static {
    try {
      ifile=new BufferedWriter(new FileWriter(String.valueOf(System.in)));
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  private static final BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
  private static final Fast in=new Fast();
  public static void main(String[] args)throws IOException {
    String[] month={
      "January","February","March","April","May","June","July","August","September","October","November","December" };
      String s=in.next();
      int n=in.nextInt();
      for(int i=0 ; i<month.length ; i++){
        if(month[i] .equals(s)){
          n=(n+i)% 12 ;
          System.out.println(month[n]);
          break ;
        }
      }
    }
    public static class Fast {
      BufferedReader br ;
      StringTokenizer st ;
      public Fast(){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
      public Fast(FileReader f){
        br=new BufferedReader(f);
      }
      public String next()throws IOException {
        while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
        return st.nextToken();
      }
      public int nextInt()throws IOException {
        return parseInt(next());
      }
      public long nextLong()throws IOException {
        return parseLong(next());
      }
      public double nextDouble()throws IOException {
        return parseDouble(next());
      }
      public float nextFloat()throws IOException {
        return Float.parseFloat(next());
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute of : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     try (     of := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile("filee.txt"))) )   catch (e : IOException) do (     e.printStackTrace() )
;
  static   attribute ifile : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     try (     ifile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(((OclFile["System.in"]) + ""))) )   catch (e : IOException) do (     e.printStackTrace() )
;
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static    attribute in : Fast := Fast.newFast();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var month : Sequence(String) ; month := Sequence{"January","February","March","April","May","June","July","August","September","October","November","December"} ;
     var s : String ; s := in.next() ;
     var n : int ; n := in.nextInt() ;
         var i : int ; i := 0 ; while i < month->size() do ( (     if (month[i+1] = s) then (     n := (n + i) mod 12 ; 
     OclFile["System.out"].println(month[n+1]) ; 
     break ) else skip )  ;     i := i + 1 ) );
  static class Fast {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFast() : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   static operation newFast( f : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(f) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next() + "")->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return parseDouble(next()) );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  private static final FastReader input=new FastReader();
  public static void main(String[] args){
    String s=input.next();
    int n=input.nextInt();
    String[] months={
      "January","February","March","April","May","June","July","August","September","October","November","December" };
      int from=0 ;
      for(int i=0 ; i<months.length ; i++){
        if(months[i] .equals(s)){
          from=i+1 ;
          break ;
        }
      }
      while(n!=0){
        if(from==months.length){
          from=1 ;
        }
        else {
          from++;
        }
        n--;
      }
      System.out.println(months[from-1]);
    }
  }
  class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(st==null || ! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
    float nextFloat(){
      return Float.parseFloat(next());
    }
    String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
      return str ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute input : FastReader := FastReader.newFastReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := input.next() ;
     var n : int ; n := input.nextInt() ;
    var months : Sequence(String) ; months := Sequence{"January","February","March","April","May","June","July","August","September","October","November","December"} ;
    var from : int ; from := 0 ;
        var i : int ; i := 0 ; while i < months->size() do ( (     if (months[i+1] = s) then (     from := i + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    while (n /= 0) do (     if (from = months->size()) then (     from := 1 ) else (     from := from + 1 ) ;  
     n := n - 1 ) ; 
    OclFile["System.out"].println(months[from - 1+1]) ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  static String[] month={
    "January","February","March","April","May","June","July","August","September","October","November","December",};
    static Scanner e=new Scanner(System.in);
    public static void main(String[] args){
      String mon=e.next();
      int n=e.nextInt();
      int i=1 ;
      for(; i<month.length ; i++){
        if(month[i] .equals(mon))break ;
      }
      n=(n+i)% 12 ;
      System.out.println(month[n]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute month : Sequence(String) := Sequence{"January","February","March","April","May","June","July","August","September","October","November","December",};
  static   attribute e : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mon : String ; mon := e.getCurrent() ;
     var n : int ; n := e.getCurrent()->toInteger() ;
    var i : int ; i := 1 ;
      while i < month->size() do ( (     if (month[i+1] = mon) then     break else skip )  ;     i := i + 1 ) ; 
    n := (n + i) mod 12 ; 
    OclFile["System.out"].println(month[n+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int slen=s.length();
    int ans=1000 ;
    for(int i=0 ; i<slen ; i++){
      char mark=s.charAt(i);
      int curlen=slen ;
      char[] curr=s.toCharArray();
      int locnt=0 ;
      while(curlen>0 && ! isSame(curlen,curr)){
        for(int j=0 ; j<curlen-1 ; j++){
          if(curr[j]==mark || curr[j+1]==mark)curr[j]=mark ;
        }
        locnt++;
        curlen--;
      }
      ans=Math.min(locnt,ans);
    }
    System.out.println(ans);
  }
  public static boolean isSame(int curlen,char[] curr){
    char mark=curr[0];
    for(int i=1 ; i<curlen ; i++)if(curr[i]!=mark)return false ;
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var slen : int ; slen := s->size() ;
    var ans : int ; ans := 1000 ;
        var i : int ; i := 0 ; while i < slen do ( (     var mark : String ; mark := s->at(i+1) ;
     var curlen : int ; curlen := slen ;
    var curr : Sequence(String) ; curr := s->characters() ;
    var locnt : int ; locnt := 0 ;
    while (curlen > 0 & not(isSame(curlen, curr))) do (         var j : int ; j := 0 ; while j < (curlen)->char2byte() - 1 do ( (     if (curr[j+1] = mark or curr[j + 1+1] = mark) then     curr[j+1] := mark ; else skip )  ;     j := j + 1 ) ; 
     locnt := locnt + 1 ; 
     curlen := curlen - 1 ) ; 
    ans := Set{locnt, ans}->min() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation isSame( curlen : int, curr : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     var mark : String ; mark := curr[0+1] ;
         var i : int ; i := 1 ; while i < curlen do (     if (curr[i+1] /= mark) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.util.InputMismatchException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      String s=in.nextString();
      int ans=s.length();
      for(int i=0 ; i<26 ; i++){
        char c=(char)('a'+i);
        String[] tmp=s.split(""+c);
        int max=0 ;
        if(tmp.length>0){
          for(String t : tmp){
            max=Math.max(max,t.length());
          }
        }
        ans=Math.min(ans,max);
      }
      out.println(ans);
    }
  }
  static class InputReader {
    BufferedReader in ;
    StringTokenizer tok ;
    public String nextString(){
      while(! tok.hasMoreTokens()){
        try {
          tok=new StringTokenizer(in.readLine()," ");
        }
        catch(IOException e){
          throw new InputMismatchException();
        }
      }
      return tok.nextToken();
    }
    public InputReader(InputStream inputStream){
      in=new BufferedReader(new InputStreamReader(inputStream));
      tok=new StringTokenizer("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.nextString() ;
     var ans : int ; ans := s->size() ;
         var i : int ; i := 0 ; while i < 26 do ( (     var c : String ; c := ('a' + i)->oclAsType(String) ;
     var tmp : Sequence(String) ; tmp := s->split("" + c) ;
    var max : int ; max := 0 ;
    if (tmp->size() > 0) then (     for (t : tmp) do ( (     max := Set{max, t->size()}->max() )  ) ) else skip ; 
    ans := Set{ans, max}->min() ; 
 )  ;     i := i + 1 ) ; 
     skip );
}
  static class InputReader {
   attribute in : OclFile;
   attribute tok : OclIterator;
   operation nextString() : String
  pre: true
  post: true
  activity: (     while (not(tok.hasNext())) do (     try (     tok := OclIterator.newOclIterator_String_String(in.readLine(), " ") )   catch (e : IOException) do (     error IncorrectElementException() )
 ) ; 
     return tok.next() );
   static operation newInputReader( inputStream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) ; 
     tok := OclIterator.newOclIterator_String("") );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  static boolean solve(int N){
    for(int a=1 ; a<10 ; a++)for(int b=1 ; b<10 ; b++){
      if(a*b==N){
        return true ;
      }
    }
    return false ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println(solve(N)? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( N : int) : boolean
  pre: true
  post: true
  activity: (         var a : int ; a := 1 ; while a < 10 do (         var b : int ; b := 1 ; while b < 10 do ( (     if (a * b = N) then (     return true ) else skip )  ;     b := b + 1 ) ;  ;     a := a + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if solve(N) then "Yes" else "No" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int[][] map ;
  static int[][] label ;
  static int M ;
  static int N ;
  static int T ;
  static int P ;
  static int MOD=1000000007 ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String s=scanner.nextLine();
    int ans=9999 ;
    for(int i=0 ; i<26 ; i++){
      String ss=s ;
      String temps="" ;
      int cnt=0 ;
      while(true){
        int ok=0 ;
        for(int j=0 ; j<ss.length(); j++){
          if(ss.charAt(j)!='a'+i)break ;
          ok++;
        }
        if(ok==ss.length())break ;
        cnt++;
        for(int j=0 ; j<ss.length()-1 ; j++){
          if(ss.charAt(j)=='a'+i || ss.charAt(j+1)=='a'+i){
            temps=temps+(char)('a'+i);
          }
          else {
            temps=temps+'0' ;
          }
        }
        ss=temps ;
        temps="" ;
      }
      ans=Math.min(ans,cnt);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute map : Sequence(Sequence(int));
  static   attribute label : Sequence(Sequence(int));
  static   attribute M : int;
  static   attribute N : int;
  static   attribute T : int;
  static   attribute P : int;
  static   attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scanner.nextLine() ;
    var ans : int ; ans := 9999 ;
        var i : int ; i := 0 ; while i < 26 do ( (     var ss : String ; ss := s ;
     var temps : String ; temps := "" ;
    var cnt : int ; cnt := 0 ;
    while (true) do (     var ok : int ; ok := 0 ;
         var j : int ; j := 0 ; while j < ss->size() do ( (     if (ss->at(j+1) /= 'a' + i) then     break else skip ; 
     ok := ok + 1 )  ;     j := j + 1 ) ; 
    if (ok = ss->size()) then     break else skip ; 
    cnt := cnt + 1 ; 
        var j : int ; j := 0 ; while j < ss->size() - 1 do ( (     if (ss->at(j+1) = 'a' + i or ss->at(j + 1+1) = 'a' + i) then (     temps := temps + ('a' + i)->oclAsType(String) ) else (     temps := temps + '0' ) )  ;     j := j + 1 ) ; 
    ss := temps ; 
    temps := "" ; 
 ) ; 
    ans := Set{ans, cnt}->min() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  void submit(){
    String s=nextToken();
    int ret=Integer.MAX_VALUE ;
    for(char c='a' ; c<='z' ; c++){
      ret=Math.min(ret,go(s,c));
    }
    out.println(ret);
  }
  int go(String s,char c){
    outer : for(int ans=0 ;
    ans<=s.length()-1 ;
    ans++){
      for(int j=0 ; j<s.length()-ans ; j++){
        boolean good=false ;
        for(int k=j ; k<=j+ans ; k++){
          good |=s.charAt(k)==c ;
        }
        if(! good){
          continue outer ;
        }
      }
      return ans ;
    }
    return Integer.MAX_VALUE ;
  }
  void preCalc(){
  }
  void stress(){
  }
  void test(){
  }
  Main()throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(System.out);
    preCalc();
    submit();
    out.close();
  }
  static final Random rng=new Random();
  static int rand(int l,int r){
    return l+rng.nextInt(r-l+1);
  }
  public static void main(String[] args)throws IOException {
    new Main();
  }
  BufferedReader br ;
  PrintWriter out ;
  StringTokenizer st ;
  String nextToken(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return st.nextToken();
  }
  String nextString(){
    try {
      return br.readLine();
    }
    catch(IOException e){
      throw new RuntimeException(e);
    }
  }
  int nextInt(){
    return Integer.parseInt(nextToken());
  }
  long nextLong(){
    return Long.parseLong(nextToken());
  }
  double nextDouble(){
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation submit() : void
  pre: true
  post: true
  activity: (     var s : String ; s := nextToken() ;
     var ret : int ; ret := 2147483647 ;
         var c : String ; c := 'a' ; while c <= 'z' do ( (     ret := Set{ret, go(s, c)}->min() )  ;     c := c + 1 ) ; 
     out.println(ret) );
   operation go( s : String, c : String) : int
  pre: true
  post: true
  activity: (         var ans : int ; ans := 0 ; while ans <= s->size() - 1 do ( (         var j : int ; j := 0 ; while j < s->size() - (ans)->char2byte() do ( (     var good : boolean ; good := false ;
         var k : int ; k := j ; while k <= j + ans do ( (     good := MathLib.bitwiseOr(good, s->at(k+1) = c) )  ;     k := k + 1 ) ; 
     if (not(good)) then (     continue ) else skip )  ;     j := j + 1 ) ; 
     return ans )  ;     ans := ans + 1 ) ; 
     return 2147483647 );
   operation preCalc() : void
  pre: true
  post: true
  activity: skip;
   operation stress() : void
  pre: true
  post: true
  activity: skip;
   operation test() : void
  pre: true
  post: true
  activity: skip;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute preCalc() ; 
    execute submit() ; 
    out.close() ; 
 );
  static    attribute rng : OclRandom := OclRandom.newOclRandom();
  static   operation rand( l : int, r : int) : int
  pre: true
  post: true
  activity: (     return l + rng.nextInt(r - l + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   attribute br : OclFile;
   attribute out : OclFile;
   attribute st : OclIterator;
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextString() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    Solver solver=new Solver();
    solver.init();
    solver.readHead(in.readLine());
  }
}
class Solver {
  int N ;
  int cnt ;
  public void init(){
    N=0 ;
    cnt=0 ;
  }
  public void readHead(String inStr){
    String str=inStr ;
    char[] cntChar=new char[26];
    for(char c : str.toCharArray()){
      cntChar[c-'a']++;
    }
    int ans=Integer.MAX_VALUE ;
    for(int i=0 ; i<cntChar.length ; i++){
      if(cntChar[i]>0){
        int cnt=0 ;
        for(str=inStr ; isMix(str); str=Shrinking(str,(char)(i+'a'))){
          cnt++;
        }
        if(cnt<ans)ans=cnt ;
      }
    }
    System.out.println(ans);
  }
  private boolean isMix(String str){
    char ctop=str.charAt(0);
    for(char c : str.toCharArray()){
      if(c!=ctop)return true ;
    }
    return false ;
  }
  private String Shrinking(String str,char pick){
    String ans="" ;
    for(int i=0 ; i<str.length()-1 ; i++){
      if(str.charAt(i+1)==pick)ans=ans+str.charAt(i+1);
      else ans=ans+str.charAt(i);
    }
    return ans ;
  }
  public boolean hasNext(){
    return cnt<N ;
  }
  public void readBody(String str){
    cnt++;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var solver : Solver ; solver := Solver.newSolver() ;
     solver.init() ; 
     solver.readHead(in.readLine()) );
}
class Solver {
   attribute N : int;
   attribute cnt : int;
   operation init() : void
  pre: true
  post: true
  activity: (     N := 0 ; 
     cnt := 0 );
   operation readHead( inStr : String) : void
  pre: true
  post: true
  activity: (     var str : String ; str := inStr ;
     var cntChar : Sequence(String) ; cntChar := Integer.subrange(1,26)->collect(0) ;
    for (c : str->characters()) do ( (     cntChar[c - ('a')->char2byte()+1] := cntChar[c - ('a')->char2byte()+1] + 1 )  ) ; 
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i < cntChar->size() do ( (     if (cntChar[i+1] > 0) then (     var cnt : int ; cnt := 0 ;
         str := inStr ; while isMix(str) do ( (     cnt := cnt + 1 )  ;     str := Shrinking(str, (i + 'a')->oclAsType(String)) ) ; 
     if (cnt < ans) then     ans := cnt ; else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation isMix( str : String) : boolean
  pre: true
  post: true
  activity: (     var ctop : String ; ctop := str->at(0+1) ;
     for (c : str->characters()) do ( (     if (c /= ctop) then     return true else skip )  ) ; 
     return false );
   operation Shrinking( str : String, pick : String) : String
  pre: true
  post: true
  activity: (     var ans : String ; ans := "" ;
         var i : int ; i := 0 ; while i < str->size() - 1 do ( (     if (str->at(i + 1+1) = pick) then     ans := ans + str->at(i + 1+1) ; else     ans := ans + str->at(i+1) ; )  ;     i := i + 1 ) ; 
     return ans );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return cnt < N );
   operation readBody( str : String) : void
  pre: true
  post: true
  activity: (     cnt := cnt + 1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class ProgressBar {
  public static void main(String[] args){
    PrintWriter pw=new PrintWriter(System.out);
    reader(System.in);
    int n=nextInt();
    int k=nextInt();
    int t=nextInt();
    double l=n*t*k/100 ;
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<(int)(l/k); i++)sb.append(k+" ");
    if(l/k<n){
      sb.append((t*n*k/100)% k+" ");
    }
    for(int i=(int)(l/k+1); i<n ; i++)sb.append(0+" ");
    pw.println(sb);
    pw.close();
  }
  private static BufferedReader br ;
  private static StringTokenizer st ;
  static void reader(InputStream stream){
    try {
      br=new BufferedReader(new InputStreamReader(stream));
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  static String next(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
    }
    return st.nextToken();
  }
  static int nextInt(){
    return Integer.parseInt(next());
  }
  static long nextLong(){
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProgressBar {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     execute reader(OclFile["System.in"]) ; 
    var n : int ; n := nextInt() ;
    var k : int ; k := nextInt() ;
    var t : int ; t := nextInt() ;
    var l : double ; l := n * t * k / 100 ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < (l / k)->oclAsType(int) do (     sb := sb + StringLib.newString(k + " ") ;  ;     i := i + 1 ) ; 
    if (l / k < n) then (     sb := sb + StringLib.newString((t * n * k / 100) mod k + " ") ) else skip ; 
        var i : int ; i := (l / k + 1)->oclAsType(int) ; while i < n do (     sb := sb + StringLib.newString(0 + " ") ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   attribute br : OclFile;
  static   attribute st : OclIterator;
  static   operation reader( stream : OclFile) : void
  pre: true
  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      int n=in.nextInt();
      if(n==0)return ;
      double en[][]=new double[n][3];
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<3 ; j++)en[i][j]=in.nextDouble();
      int m=in.nextInt();
      for(int i=0 ; i<m ; i++){
        double tx=in.nextDouble(),ty=in.nextDouble();
        double sx=in.nextDouble(),sy=in.nextDouble();
        boolean judge=false ;
        for(int j=0 ; j<n ; j++){
          double r=en[j][2];
          double dit=Math.hypot(tx-en[j][0],ty-en[j][1]);
          double dis=Math.hypot(sx-en[j][0],sy-en[j][1]);
          double d=lp_dis(en[j][0],en[j][1],tx,ty,sx,sy);
          if((dit>r || dis>r)&& d<=r)judge=true ;
        }
        System.out.println(judge ? "Safe" : "Danger");
      }
    }
  }
  static double lp_dis(double px,double py,double x1,double y1,double x2,double y2){
    double dx=x2-x1,dy=y2-y1 ;
    double a=dx*dx+dy*dy,b=dx*(x1-px)+dy*(y1-py);
    double t=-b/a ;
    if(t<0)t=0 ;
    if(t>1)t=1 ;
    double tx=x1+dx*t ;
    double ty=y1+dy*t ;
    return Math.hypot(px-tx,py-ty);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var en : Sequence(Sequence(double)) ; en := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < 3 do (     en[i+1][j+1] := in.getCurrent()->toReal() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var m : int ; m := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     var tx : double ; tx := in.getCurrent()->toReal() ;
    var ty : double ; ty := in.getCurrent()->toReal() ;
     var sx : double ; sx := in.getCurrent()->toReal() ;
    var sy : double ; sy := in.getCurrent()->toReal() ;
    var judge : boolean ; judge := false ;
        var j : int ; j := 0 ; while j < n do ( (     var r : double ; r := en[j+1][2+1] ;
     var dit : double ; dit := hypot(tx - en[j+1][0+1], ty - en[j+1][1+1]) ;
    var dis : double ; dis := hypot(sx - en[j+1][0+1], sy - en[j+1][1+1]) ;
    var d : double ; d := lp_dis(en[j+1][0+1], en[j+1][1+1], tx, ty, sx, sy) ;
    if ((dit > r or dis > r) & d <= r) then     judge := true ; else skip ; 
 )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(if judge then "Safe" else "Danger" endif) ; 
 )  ;     i := i + 1 ) ; 
 )  ) );
  static   operation lp_dis( px : double, py : double, x1 : double, y1 : double, x2 : double, y2 : double) : double
  pre: true
  post: true
  activity: (     var dx : double ; dx := x2 - x1 ;
    var dy : double ; dy := y2 - y1 ;
     var a : double ; a := dx * dx + dy * dy ;
    var b : double ; b := dx * (x1 - px) + dy * (y1 - py) ;
    var t : double ; t := -b / a ;
    if (t < 0) then     t := 0 ; else skip ; 
    if (t > 1) then     t := 1 ; else skip ; 
    var tx : double ; tx := x1 + dx * t ;
    var ty : double ; ty := y1 + dy * t ;
    return hypot(px - tx, py - ty) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.geom.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] r=new int[n];
      Point2D.Double[] p=new Point2D.Double[n];
      for(int i=0 ; i<n ; i++){
        p[i]=new Point2D.Double(sc.nextInt(),sc.nextInt());
        r[i]=sc.nextInt();
      }
      int m=sc.nextInt();
      Point2D.Double t,s ;
      Line2D.Double b ;
      boolean flag ;
      for(int i=0 ; i<m ; i++){
        t=new Point2D.Double(sc.nextInt(),sc.nextInt());
        s=new Point2D.Double(sc.nextInt(),sc.nextInt());
        b=new Line2D.Double(s,t);
        flag=false ;
        for(int j=0 ; j<n ; j++){
          if(s.distance(p[j])<r[j] && t.distance(p[j])<r[j]);
          else if(s.distance(p[j])>r[j] && s.distance(p[j])>r[j] && b.ptSegDist(p[j])>r[j]);
          else {
            flag=true ;
            break ;
          }
        }
        if(flag==false)System.out.println("Danger");
        else System.out.println("Safe");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var r : Sequence(int) ; r := Integer.subrange(1,n)->collect(0) ;
    var p : Sequence(Double) ; p := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := Double.newDouble(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) ; 
     r[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var t : Double ;
    var s : Double ;
    var b : Double ;
    var flag : boolean ;
        var i : int ; i := 0 ; while i < m do ( (     t := Double.newDouble(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) ; 
     s := Double.newDouble(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) ; 
    b := Double.newDouble(s, t) ; 
    flag := false ; 
        var j : int ; j := 0 ; while j < n do ( (     if (s.distance(p[j+1]) < r[j+1] & t.distance(p[j+1]) < r[j+1]) then  else     if (s.distance(p[j+1]) > r[j+1] & s.distance(p[j+1]) > r[j+1] & b.ptSegDist(p[j+1]) > r[j+1]) then  else (     flag := true ; 
     break ) ;  )  ;     j := j + 1 ) ; 
    if (flag = false) then     OclFile["System.out"].println("Danger") else     OclFile["System.out"].println("Safe") ; ;  
 )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.awt.geom.Point2D ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      Point2D.Double[] p=new Point2D.Double[n];
      int[] r=new int[n];
      for(int i=0 ; i<n ; i++){
        p[i]=new Point2D.Double(scanner.nextDouble(),scanner.nextDouble());
        r[i]=scanner.nextInt();
      }
      int m=scanner.nextInt();
      boolean flag ;
      for(int i=0 ; i<m ; i++){
        Point2D.Double t=new Point2D.Double(scanner.nextDouble(),scanner.nextDouble());
        Point2D.Double s=new Point2D.Double(scanner.nextDouble(),scanner.nextDouble());
        Line2D.Double b=new Line2D.Double(s,t);
        flag=false ;
        for(int j=0 ; j<n ; j++){
          double sk=s.distance(p[j]);
          double tk=t.distance(p[j]);
          if((sk>r[j] || tk>r[j])&& b.ptSegDist(p[j])<=r[j]){
            flag=true ;
            break ;
          }
        }
        System.out.println(flag ? "Safe" : "Danger");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var p : Sequence(Double) ; p := Integer.subrange(1,n)->collect(null) ;
    var r : Sequence(int) ; r := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := Double.newDouble(scanner.getCurrent()->toReal(), scanner.getCurrent()->toReal()) ; 
     r[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var flag : boolean ;
        var i : int ; i := 0 ; while i < m do ( (     var t : Double ; t := Double.newDouble(scanner.getCurrent()->toReal(), scanner.getCurrent()->toReal()) ;
     var s : Double ; s := Double.newDouble(scanner.getCurrent()->toReal(), scanner.getCurrent()->toReal()) ;
    var b : Double ; b := Double.newDouble(s, t) ;
    flag := false ; 
        var j : int ; j := 0 ; while j < n do ( (     var sk : double ; sk := s.distance(p[j+1]) ;
     var tk : double ; tk := t.distance(p[j+1]) ;
     if ((sk > r[j+1] or tk > r[j+1]) & b.ptSegDist(p[j+1]) <= r[j+1]) then (     flag := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(if flag then "Safe" else "Danger" endif) ; 
 )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.geom.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] r=new int[n];
      Point2D.Double[] p=new Point2D.Double[n];
      for(int i=0 ; i<n ; i++){
        p[i]=new Point2D.Double(sc.nextInt(),sc.nextInt());
        r[i]=sc.nextInt();
      }
      int m=sc.nextInt();
      Point2D.Double t,s ;
      Line2D.Double b ;
      boolean flag ;
      for(int i=0 ; i<m ; i++){
        t=new Point2D.Double(sc.nextInt(),sc.nextInt());
        s=new Point2D.Double(sc.nextInt(),sc.nextInt());
        b=new Line2D.Double(s,t);
        flag=false ;
        for(int j=0 ; j<n ; j++){
          if((s.distance(p[j])<r[j] && t.distance(p[j])<r[j])|| b.ptSegDist(p[j])>r[j]);
          else {
            flag=true ;
            break ;
          }
        }
        if(flag==false)System.out.println("Danger");
        else System.out.println("Safe");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var r : Sequence(int) ; r := Integer.subrange(1,n)->collect(0) ;
    var p : Sequence(Double) ; p := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := Double.newDouble(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) ; 
     r[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var t : Double ;
    var s : Double ;
    var b : Double ;
    var flag : boolean ;
        var i : int ; i := 0 ; while i < m do ( (     t := Double.newDouble(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) ; 
     s := Double.newDouble(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) ; 
    b := Double.newDouble(s, t) ; 
    flag := false ; 
        var j : int ; j := 0 ; while j < n do ( (     if ((s.distance(p[j+1]) < r[j+1] & t.distance(p[j+1]) < r[j+1]) or b.ptSegDist(p[j+1]) > r[j+1]) then  else (     flag := true ; 
     break ) )  ;     j := j + 1 ) ; 
    if (flag = false) then     OclFile["System.out"].println("Danger") else     OclFile["System.out"].println("Safe") ; ;  
 )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static int findCountUpto(int d){
    int GP1_Sum=9*((int)((Math.pow(10,d))-1)/9);
    int GP2_Sum=9*((int)((Math.pow(9,d))-1)/8);
    return GP1_Sum-GP2_Sum ;
  }
  public static void main(String args[]){
    int d=1 ;
    System.out.println(findCountUpto(d));
    d=2 ;
    System.out.println(findCountUpto(d));
    d=4 ;
    System.out.println(findCountUpto(d));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findCountUpto( d : int) : int
  pre: true
  post: true
  activity: (     var GP1_Sum : int ; GP1_Sum := 9 * (((10->pow(d)) - 1)->oclAsType(int) / 9) ;
     var GP2_Sum : int ; GP2_Sum := 9 * (((9->pow(d)) - 1)->oclAsType(int) / 8) ;
     return GP1_Sum - GP2_Sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : int ; d := 1 ;
     OclFile["System.out"].println(findCountUpto(d)) ; 
    d := 2 ; 
    OclFile["System.out"].println(findCountUpto(d)) ; 
    d := 4 ; 
    OclFile["System.out"].println(findCountUpto(d)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int digitSum(long n){
    int digSum=0 ;
    while(n>0){
      digSum+=n % 10 ;
      n/=10 ;
    }
    return digSum ;
  }
  public static long countInteger(long n,long s){
    if(n<s)return 0 ;
    for(long i=s ; i<=Math.min(n,s+163); i++)if((i-digitSum(i))>s)return(n-i+1);
    return 0 ;
  }
  public static void main(String args[]){
    long n=1000,s=100 ;
    System.out.println(countInteger(n,s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation digitSum( n : long) : int
  pre: true
  post: true
  activity: (     var digSum : int ; digSum := 0 ;
     while (n > 0) do (     digSum := digSum+(n mod 10) ; 
     n := n/(10) ) ; 
     return digSum );
  static   operation countInteger( n : long, s : long) : long
  pre: true
  post: true
  activity: (     if (n < s) then     return 0 else skip ; 
         var i : long ; i := s ; while i <= Set{n, s + 163}->min() do (     if ((i - digitSum(i)) > s) then     return (n - i + 1) else skip ;  ;     i := i + 1 ) ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 1000 ;
    var s : long ; s := 100 ;
     OclFile["System.out"].println(countInteger(n, s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scan=new Scanner(System.in)){
      int N=scan.nextInt();
      int ok=0 ;
      for(int i=1 ; i<=9 ; i++){
        if(N % i==0){
          String s=String.valueOf(N/i);
          if(s.length()==1){
            ok=1 ;
            break ;
          }
        }
      }
      System.out.println(ok==1 ? "Yes" : "No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := scan.getCurrent()->toInteger() ;
     var ok : int ; ok := 0 ;
         var i : int ; i := 1 ; while i <= 9 do ( (     if (N mod i = 0) then (     var s : String ; s := ((N / i) + "") ;
     if (s->size() = 1) then (     ok := 1 ; 
     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if ok = 1 then "Yes" else "No" endif) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Bakery {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt(),k=sc.nextInt();
    int[][] A=new int[m][3];
    HashSet<Integer>Storage=new HashSet<>();
    for(int i=0 ; i<m ; i++){
      A[i][0]=sc.nextInt();
      A[i][1]=sc.nextInt();
      A[i][2]=sc.nextInt();
    }
    for(int i=0 ; i<k ; i++)Storage.add(sc.nextInt());
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<m ; i++){
      if(! Storage.contains(A[i][0])&& Storage.contains(A[i][1])){
        min=Math.min(min,A[i][2]);
      }
      else if(Storage.contains(A[i][0])&& ! Storage.contains(A[i][1])){
        min=Math.min(min,A[i][2]);
      }
    }
    System.out.println(min==Integer.MAX_VALUE ?-1 : min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Bakery {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var A : Sequence(Sequence(int)) ; A := Integer.subrange(1,m)->collect(Integer.subrange(1,3)->collect(0)) ;
    var Storage : Set(int) ; Storage := Set{} ;
        var i : int ; i := 0 ; while i < m do ( (     A[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     A[i+1][1+1] := sc.getCurrent()->toInteger() ; 
     A[i+1][2+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do (     Storage := Storage->including(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < m do ( (     if (not(Storage->includes(A[i+1][0+1])) & Storage->includes(A[i+1][1+1])) then (     min := Set{min, A[i+1][2+1]}->min() ) else     if (Storage->includes(A[i+1][0+1]) & not(Storage->includes(A[i+1][1+1]))) then (     min := Set{min, A[i+1][2+1]}->min() ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if min = 2147483647 then -1 else min endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scan.nextInt();
    }
    double bunbo=0.0 ;
    for(int i=0 ; i<n ; i++){
      bunbo+=(double)1/a[i];
    }
    System.out.print(1/bunbo);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var bunbo : double ; bunbo := 0.0 ;
        var i : int ; i := 0 ; while i < n do ( (     bunbo := bunbo+(1->oclAsType(double) / a[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(1 / bunbo) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class codeforces {
  public static void main(String[] args)throws IOException {
    Reader.init(System.in);
    double n=Reader.nextDouble(),k=Reader.nextDouble(),t=Reader.nextDouble();
    int ar[]=new int[(int)n];
    double sum=0 ;
    int index=0,value=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=k/(n*k);
      if(sum>t/100+(i*.0000000000000004)){
        sum-=k/(n*k);
        index=i++;
        break ;
      }
      ar[i]=(int)k ;
    }
    for(int i=0 ; i<=k ; i++){
      sum+=i/(n*k);
      if(sum>t/100+(.0000000000000004*i)){
        value=--i ;
        break ;
      }
      else sum-=i/(n*k);
    }
    if(value>0)ar[index]=value ;
    for(int i=0 ; i<n ; i++){
      System.out.print(ar[i]+" ");
    }
  }
}
class Reader {
  static BufferedReader reader ;
  static StringTokenizer tokenizer ;
  static void init(InputStream input){
    reader=new BufferedReader(new InputStreamReader(input));
    tokenizer=new StringTokenizer("");
  }
  static String next()throws IOException {
    while(! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Reader.init(OclFile["System.in"]) ; 
     var n : double ; n := Reader.nextDouble() ;
    var k : double ; k := Reader.nextDouble() ;
    var t : double ; t := Reader.nextDouble() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,n->oclAsType(int))->collect(0) ;
    var sum : double ; sum := 0 ;
    var index : int ; index := 0 ;
    var value : int ; value := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(k / (n * k)) ; 
     if (sum > t / 100 + (i * .0000000000000004)) then (     sum := sum-(k / (n * k)) ; 
      index := i  ; i := i + 1 ; 
     break ) else skip ; 
     ar[i+1] := k->oclAsType(int) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= k do ( (     sum := sum+(i / (n * k)) ; 
     if (sum > t / 100 + (.0000000000000004 * i)) then (         i := i - 1 ;
 value := i  ; 
     break ) else     sum := sum-(i / (n * k)) ; )  ;     i := i + 1 ) ; 
    if (value > 0) then     ar[index+1] := value ; else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(ar[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}
class Reader {
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   operation init( input : OclFile) : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(input)) ; 
     tokenizer := OclIterator.newOclIterator_String("") );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Reader.init();
    int N=Reader.nextInt();
    int A[]=new int[N];
    read(A,N);
    double sum=0 ;
    for(int i : A){
      sum+=(double)1/i ;
    }
    print(1/sum);
  }
  static int mod=1000000007 ;
  public static void read(int arr[],int N)throws IOException {
    for(int i=0 ; i<N ; i++){
      arr[i]=Reader.nextInt();
    }
  }
  public static void read(String arr[],int N)throws IOException {
    for(int i=0 ; i<N ; i++){
      arr[i]=Reader.next();
    }
  }
  public static void print(Object O){
    System.out.println(O);
  }
  public static void display(int arr[]){
    System.out.println(Arrays.toString(arr));
  }
  public static void display(int arr[][],int N){
    for(int i=0 ; i<N ; i++){
      System.out.println(Arrays.toString(arr[i]));
    }
  }
}
class Reader {
  static BufferedReader reader ;
  static StringTokenizer tokenizer ;
  static void init(){
    reader=new BufferedReader(new InputStreamReader(System.in));
    tokenizer=new StringTokenizer("");
  }
  static String next()throws IOException {
    while(! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  static long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  static String nextLine()throws IOException {
    return reader.readLine();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Reader.init() ; 
     var N : int ; N := Reader.nextInt() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    execute read(A, N) ; 
    var sum : double ; sum := 0 ;
    for (i : A) do ( (     sum := sum+(1->oclAsType(double) / i) )  ) ; 
    execute print(1 / sum) ; 
 );
  static   attribute mod : int := 1000000007;
  static   operation read( arr : Sequence(int), N : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := Reader.nextInt() )  ;     i := i + 1 ) );
  static   operation read( arr : Sequence(String), N : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := Reader.next() )  ;     i := i + 1 ) );
  static   operation print( O : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(O) );
  static   operation display( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((arr + "")) );
  static   operation display( arr : Sequence(Sequence(int)), N : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].println((arr[i+1] + "")) )  ;     i := i + 1 ) );
}
class Reader {
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   operation init() : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := OclIterator.newOclIterator_String("") );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     return reader.readLine() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.Stream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.nextLine();
    String suuji=sc.nextLine();
    String[] astr=suuji.split(" ");
    Double tmp=0.0 ;
    double ans=0.0 ;
    Double hoge=0.0 ;
    int[] in_data=Stream.of(astr).mapToInt(x->{
      try {
        return Integer.parseInt(x);
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return 0 ;
    }
).toArray();
    sc.close();
    for(int i=0 ; i<in_data.length ; i++){
      hoge=(double)1/in_data[i];
      tmp=tmp+hoge ;
    }
    ans=1/tmp ;
    if(ans==(int)ans){
      System.out.println((int)ans);
    }
    else {
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.nextLine() ;
    var suuji : String ; suuji := sc.nextLine() ;
    var astr : Sequence(String) ; astr := suuji->split(" ") ;
    var tmp : double ; tmp := 0.0 ;
    var ans : double ; ans := 0.0 ;
    var hoge : double ; hoge := 0.0 ;
    var in_data : Sequence(int) ; in_data := Sequence{astr}->collect( _x1 | (lambda x : OclAny in (     try (     return (x)->toInteger() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return 0 ))->apply(_x1) )->asSequence() ;
    skip ; 
        var i : int ; i := 0 ; while i < in_data->size() do ( (     hoge := 1->oclAsType(double) / in_data[i+1] ; 
     tmp := tmp + hoge )  ;     i := i + 1 ) ; 
    ans := 1 / tmp ; 
    if (ans = ans->oclAsType(int)) then (     OclFile["System.out"].println(ans->oclAsType(int)) ) else (     OclFile["System.out"].println(ans) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    List<Double>list=new ArrayList<Double>();
    for(int i=0 ; i<N ; i++){
      list.add(Double.parseDouble(sc.next()));
    }
    double ans=list.stream().mapToDouble(s->1.0/s).sum();
    ans=1.0/ans ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var list : Sequence(double) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     list := list->including((sc.getCurrent())->toReal()) )  ;     i := i + 1 ) ; 
    var ans : double ; ans := list->collect( _x1 | (lambda s : OclAny in 1.0 / s)->apply(_x1) )->sum() ;
    ans := 1.0 / ans ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=null ;
    PrintStream out=null ;
    try {
      sc=new Scanner(System.in);
      out=System.out ;
      exec(sc,out);
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
    finally {
      if(out!=null){
        out.close();
      }
      if(sc!=null){
        sc.close();
      }
    }
    System.exit(0);
  }
  public static void exec(final Scanner sc,final PrintStream out)throws Exception {
    final int N=sc.nextInt();
    final int A[]=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
    }
    double sum=0 ;
    for(int i=0 ; i<N ; i++){
      sum+=1.0/A[i];
    }
    out.println(1.0/sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := null ;
     var out : OclFile ; out := null ;
     try (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     out := OclFile["System.out"] ; 
     execute exec(sc, out) )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
   finally (     if (out /= null) then (     skip ) else skip ; 
     if (sc /= null) then (     skip ) else skip )
 OclProcess.exit(0) );
  static   operation exec( sc : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum : double ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     sum := sum+(1.0 / A[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  final int MOD=1000000007 ;
  final int MAX=Integer.MAX_VALUE ;
  final long LMAX=Long.MAX_VALUE ;
  int LEN=0 ;
  void doIt(){
    int n=sc.nextInt();
    LEN=(1<<n+1);
    boolean notTrue[]=new boolean[n];
    Arrays.fill(notTrue,false);
    int says[][]=new int[n][n];
    for(int i=0 ; i<n ; i++)Arrays.fill(says[i],-1);
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      for(int j=0 ; j<a ; j++){
        int x=sc.nextInt()-1 ;
        int y=sc.nextInt();
        says[i][x]=y ;
      }
    }
    int ans=0 ;
    for(int i=0 ; i<(1<<n); i++){
      int num=Integer.bitCount(i);
      out : for(int j=0 ;
      j<n ;
      j++){
        if((i>>j & 1)==1){
          for(int k=0 ; k<n ; k++){
            if(says[j][k]!=(i>>k & 1)&& says[j][k]!=-1){
              num=0 ;
              break out ;
            }
          }
        }
      }
      ans=Math.max(ans,num);
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute MOD : int := 1000000007;
   attribute MAX : int := 2147483647;
   attribute LMAX : long := "9223372036854775807"->toLong();
   attribute LEN : int := 0;
   operation doIt() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     LEN := ((1*(2->pow(n + 1)))->oclAsType(long)) ; 
    var notTrue : Sequence(boolean) ; notTrue := Integer.subrange(1,n)->collect(false) ;
    notTrue := notTrue->collect(false) ; 
    var says : Sequence(Sequence(int)) ; says := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do (     says[i+1] := says[i+1]->collect(-1) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < a do ( (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     says[i+1][x+1] := y )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < ((1*(2->pow(n)))->oclAsType(long)) do ( (     var num : int ; num := bitCount(i) ;
         var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd((i/(2->pow(j)))->oclAsType(long),1)) = 1) then (         var k : int ; k := 0 ; while k < n do ( (     if (says[j+1][k+1] /= (MathLib.bitwiseAnd((i/(2->pow(k)))->oclAsType(long),1)) & says[j+1][k+1] /= -1) then (     num := 0 ; 
     break ) else skip )  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) ; 
     ans := Set{ans, num}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collection ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.Scanner ;
import java.util.AbstractMap.SimpleEntry ;
import java.util.HashSet ;
import java.util.Iterator ;
class Main {
  static final int MOD=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[][] map=new int[N][N];
    for(int i=0 ; i<N ; i++){
      int a=sc.nextInt();
      for(int k=0 ; k<a ; k++){
        int p=sc.nextInt()-1 ;
        int bool=(sc.nextInt()==1)? 1 :-1 ;
        map[i][p]=bool ;
      }
    }
    int ans=0 ;
    for(int mask=0 ; mask<(1<<N); mask++){
      int trs=Integer.bitCount(mask);
      int[] ck=new int[N];
      for(int i=0 ; i<N ; i++){
        ck[i]=(mask &(1<<i))!=0 ? 1 :-1 ;
      }
      int i ;
      turn : for(i=0 ;
      i<N ;
      i++){
        if(ck[i]==-1)continue ;
        for(int k=0 ; k<N ; k++){
          if(map[i][k]!=0){
            if(ck[k]!=map[i][k])break turn ;
          }
        }
      }
      if(i==N)ans=Math.max(ans,trs);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
         var k : int ; k := 0 ; while k < a do ( (     var p : int ; p := sc.getCurrent()->toInteger() - 1 ;
     var bool : int ; bool := if (sc.getCurrent()->toInteger() = 1) then 1 else -1 endif ;
     map[i+1][p+1] := bool )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var mask : int ; mask := 0 ; while mask < ((1*(2->pow(N)))->oclAsType(long)) do ( (     var trs : int ; trs := bitCount(mask) ;
     var ck : Sequence(int) ; ck := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     ck[i+1] := if (MathLib.bitwiseAnd(mask,((1*(2->pow(i)))->oclAsType(long)))) /= 0 then 1 else -1 endif )  ;     i := i + 1 ) ; 
    var i : int ;
        i := 0 ; while i < N do ( (     if (ck[i+1] = -1) then     continue else skip ; 
         var k : int ; k := 0 ; while k < N do ( (     if (map[i+1][k+1] /= 0) then (     if (ck[k+1] /= map[i+1][k+1]) then     break else skip ) else skip )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    if (i = N) then     ans := Set{ans, trs}->max() ; else skip ; 
 )  ;     mask := mask + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Set<Integer>[] positive=new HashSet[n];
    Set<Integer>[] negative=new HashSet[n];
    for(int i=0 ; i<n ; i++){
      positive[i]=new HashSet<>();
      negative[i]=new HashSet<>();
      int m=sc.nextInt();
      while(m-->0){
        int x=sc.nextInt()-1 ;
        if(sc.nextInt()==1){
          positive[i] .add(x);
        }
        else {
          negative[i] .add(x);
        }
      }
    }
    long answer=0 ;
    for(int i=(1<<n)-1 ; i>=0 ; i--){
      Set<Integer>p=new HashSet<>();
      int t=1 ;
      for(int j=0 ; j<n ; j++){
        if((t & i)>0)p.add(j);
        t<<=1 ;
      }
      boolean valid=true ;
      for(int j=0 ; j<n ; j++){
        if(! p.contains(j))continue ;
        for(int x : positive[j]){
          if(! p.contains(x)){
            valid=false ;
          }
        }
        for(int x : negative[j]){
          if(p.contains(x)){
            valid=false ;
          }
        }
      }
      if(valid)answer=Math.max(answer,p.size());
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var positive : Sequence(Set(int)) ; positive := Integer.subrange(1,n)->collect(null) ;
    var negative : Sequence(Set(int)) ; negative := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     positive[i+1] := Set{} ; 
     negative[i+1] := Set{} ; 
     var m : int ; m := sc.getCurrent()->toInteger() ;
         while (m > 0) do (        m := m - 1 ;     skip ; (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
     if (sc.getCurrent()->toInteger() = 1) then (     positive[i+1]->excludes(x) ) else (     negative[i+1]->excludes(x) ) ) ;  ) )  ;     i := i + 1 ) ; 
    var answer : long ; answer := 0 ;
        var i : int ; i := ((1*(2->pow(n)))->oclAsType(long)) - 1 ; while i >= 0 do ( (     var p : Set(int) ; p := Set{} ;
     var t : int ; t := 1 ;
        var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd(t,i)) > 0) then     p := p->including(j) ; else skip ; 
     t := t*(2->pow(1)) )  ;     j := j + 1 ) ; 
    var valid : boolean ; valid := true ;
        var j : int ; j := 0 ; while j < n do ( (     if (not(p->includes(j))) then     continue else skip ; 
     for (x : positive[j+1]) do ( (     if (not(p->includes(x))) then (     valid := false ) else skip )  ) ; 
     for (x : negative[j+1]) do ( (     if (p->includes(x)) then (     valid := false ) else skip )  ) )  ;     j := j + 1 ) ; 
    if (valid) then     answer := Set{answer, p->size()}->max() ; else skip ; 
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static List<List<Integer>>ptnList=new ArrayList<>();
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Person>personList=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      Person p=new Person();
      for(int j=0 ; j<a ; j++){
        int x=sc.nextInt();
        int y=sc.nextInt();
        p.evidenceList.add(new Evidence(x,y));
      }
      personList.add(p);
    }
    int max=0 ;
    countfor : for(int count=0 ;
    count<Math.pow(2,n);
    count++){
      String b=Integer.toBinaryString(count);
      String ptn="" ;
      for(int i=0 ; i<n-b.length(); i++){
        ptn+="0" ;
      }
      ptn+=b ;
      for(int i=0 ; i<personList.size(); i++){
        if(ptn.charAt(i)=='1'){
          for(Evidence e : personList.get(i).evidenceList){
            if(Integer.parseInt(ptn.substring(e.x-1,e.x))==e.y){
            }
            else {
              continue countfor ;
            }
          }
        }
      }
      int c=0 ;
      for(int i=0 ; i<ptn.length(); i++){
        if(ptn.charAt(i)=='1'){
          c++;
        }
      }
      if(c>max){
        max=c ;
      }
    }
    System.out.println(max);
    sc.close();
  }
  private static class Person {
    List<Evidence>evidenceList=new ArrayList<>();
  }
  private static class Evidence {
    int x ;
    int y ;
    public Evidence(int _x,int _y){
      this.x=_x ;
      this.y=_y ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ptnList : Sequence(Sequence(int)) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var personList : Sequence(Person) ; personList := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var p : Person ; p := Person.newPerson() ;
         var j : int ; j := 0 ; while j < a do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     p.evidenceList->excludes(Evidence.newEvidence(x, y)) )  ;     j := j + 1 ) ; 
     personList := personList->including(p) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var count : int ; count := 0 ; while count < 2->pow(n) do ( (     var b : String ; b := (MathLib.decimal2binary(count) + "") ;
     var ptn : String ; ptn := "" ;
        var i : int ; i := 0 ; while i < n - b->size() do ( (     ptn := ptn+("0") )  ;     i := i + 1 ) ; 
    ptn := ptn+(b) ; 
        var i : int ; i := 0 ; while i < personList->size() do ( (     if (ptn->at(i+1) = '1') then (     for (e : personList->at(i+1).evidenceList) do ( (     if ((ptn.subrange(e.x - 1+1,e.x))->toInteger() = e.y) then skip else (     continue ) )  ) ) else skip )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < ptn->size() do ( (     if (ptn->at(i+1) = '1') then (     c := c + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (c > max) then (     max := c ) else skip ; 
 )  ;     count := count + 1 ) ; 
    OclFile["System.out"].println(max) ; 
    skip ; 
 );
  static class Person {
   attribute evidenceList : Sequence(Evidence) := Sequence{};
}
  static class Evidence {
   attribute x : int;
   attribute y : int;
   static operation newEvidence( _x : int, _y : int) : Evidence
  pre: true
  post: true
  activity:
  ( var self : Evidence ;
    self := createEvidence();
    self.initialise(_x, _y);
    return self );
  operation initialise( _x : int, _y : int) : void
  pre: true  post: true
  activity: (     self.x := _x ; 
     self.y := _y );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void pairwiseDifference(int arr[],int n){
    int diff ;
    for(int i=0 ; i<n-1 ; i++){
      diff=Math.abs(arr[i]-arr[i+1]);
      System.out.print(diff+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      4,10,15,5,6 };
      int n=arr.length ;
      pairwiseDifference(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation pairwiseDifference( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var diff : int ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     diff := if arr[i+1] - arr[i + 1+1] < 0 then -(arr[i+1] - arr[i + 1+1]) else arr[i+1] - arr[i + 1+1] endif ; 
     OclFile["System.out"].print(diff + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,10,15,5,6} ;
     var n : int ; n := arr->size() ;
     execute pairwiseDifference(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  int n ;
  int[][] as ;
  void run(){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    as=new int[n][2];
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      as[i][1] |=1<<i ;
      for(int j=0 ; j<a ; j++){
        int x=sc.nextInt()-1,y=sc.nextInt();
        as[i][y] |=1<<x ;
      }
    }
    debug(as);
    int ans=0 ;
    for(int i=0 ; i<(1<<n); i++){
      if(ok(i))ans=Math.max(ans,Integer.bitCount(i));
    }
    System.out.println(ans);
  }
  boolean ok(int x){
    int a=0,b=0 ;
    for(int i=0 ; i<n ; i++){
      if(((x>>i)& 1)==1){
        a |=as[i][1];
        b |=as[i][0];
      }
    }
    debug(Integer.toBinaryString(x),Integer.toBinaryString(a),Integer.toBinaryString(b));
    debug(a ^ x,b & x);
    if((a ^ x)>0)return false ;
    if((b & x)>0)return false ;
    return true ;
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute as : Sequence(Sequence(int));
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    as := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ; 
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     as[i+1][1+1] := MathLib.bitwiseOr(as[i+1][1+1], (1*(2->pow(i)))->oclAsType(long)) ; 
         var j : int ; j := 0 ; while j < a do ( (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
     as[i+1][y+1] := MathLib.bitwiseOr(as[i+1][y+1], (1*(2->pow(x)))->oclAsType(long)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    execute debug(as) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < ((1*(2->pow(n)))->oclAsType(long)) do ( (     if (ok(i)) then     ans := Set{ans, bitCount(i)}->max() ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation ok( x : int) : boolean
  pre: true
  post: true
  activity: (     var a : int ; a := 0 ;
    var b : int ; b := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if ((((x/(2->pow(i)))->oclAsType(long)) & 1) = 1) then (     a := MathLib.bitwiseOr(a, as[i+1][1+1]) ; 
     b := MathLib.bitwiseOr(b, as[i+1][0+1]) ) else skip )  ;     i := i + 1 ) ; 
    execute debug((MathLib.decimal2binary(x) + ""), (MathLib.decimal2binary(a) + ""), (MathLib.decimal2binary(b) + "")) ; 
    execute debug(MathLib.bitwiseXor(a,x), MathLib.bitwiseAnd(b,x)) ; 
    if ((MathLib.bitwiseXor(a,x)) > 0) then     return false else skip ; 
    if ((MathLib.bitwiseAnd(b,x)) > 0) then     return false else skip ; 
    return true 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  void run(){
    for(; ; ){
      int N=ni();
      int Q=ni();
      if((N | Q)==0){
        break ;
      }
      int[][] list=new int[N][];
      Map<Integer,Integer>map=new HashMap<Integer,Integer>();
      for(int i=1 ; i<100 ; ++i){
        map.put(i,0);
      }
      for(int i=0 ; i<N ; ++i){
        int M=ni();
        list[i]=new int[M];
        for(int j=0 ; j<M ; ++j){
          int d=ni();
          list[i][j]=d ;
          map.put(d,map.get(d)+1);
        }
      }
      int max=0 ;
      int idx=0 ;
      for(Integer key : map.keySet()){
        int n=map.get(key);
        if(n>=Q){
          if(max<n){
            idx=key ;
            max=n ;
          }
        }
      }
      System.out.println(idx);
    }
  }
  Main(){
    sc=new Scanner(System.in);
  }
  int ni(){
    return sc.nextInt();
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var N : int ; N := ni() ;
     var Q : int ; Q := ni() ;
    if ((MathLib.bitwiseOr(N,Q)) = 0) then (     break ) else skip ; 
    var list : Sequence(Sequence(int)) ; list := Integer.subrange(1,N)->collect(Sequence{}) ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 1 ; while i < 100 do ( (     map := map->union(Map{i |-> 0}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var M : int ; M := ni() ;
     list[i+1] := Integer.subrange(1,M)->collect(0) ; 
         var j : int ; j := 0 ; while j < M do ( (     var d : int ; d := ni() ;
     list[i+1][j+1] := d ; 
     map := map->union(Map{d |-> map->at(d) + 1}) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var idx : int ; idx := 0 ;
    for (key : map->keys()) do ( (     var n : int ; n := map->at(key) ;
     if (n >= Q) then (     if (max < n) then (     idx := key ; 
     max := n ) else skip ) else skip )  ) ; 
    OclFile["System.out"].println(idx) ; 
 )  ) );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int printPermutation(int n){
    if(n % 2!=0){
      System.out.println("-1");
    }
    else for(int i=1 ;
    i<=n/2 ;
    i++){
      System.out.print(2*i+" "+((2*i)-1)+" ");
    }
    return n ;
  }
  public static void main(String[] args){
    int n=4 ;
    printPermutation(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printPermutation( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 /= 0) then (     OclFile["System.out"].println("-1") ) else         var i : int ; i := 1 ; while i <= n / 2 do ( (     OclFile["System.out"].print(2 * i + " " + ((2 * i) - 1) + " ") )  ;     i := i + 1 ) ; ;  
     return n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     execute printPermutation(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public String mostCommonWord(String paragraph,String[] banned){
    paragraph+="." ;
    Set<String>banset=new HashSet();
    for(String word : banned)banset.add(word);
    Map<String,Integer>count=new HashMap();
    String ans="" ;
    int ansfreq=0 ;
    StringBuilder word=new StringBuilder();
    for(char c : paragraph.toCharArray()){
      if(Character.isLetter(c)){
        word.append(Character.toLowerCase(c));
      }
      else if(word.length()>0){
        String finalword=word.toString();
        if(! banset.contains(finalword)){
          count.put(finalword,count.getOrDefault(finalword,0)+1);
          if(count.get(finalword)>ansfreq){
            ans=finalword ;
            ansfreq=count.get(finalword);
          }
        }
        word=new StringBuilder();
      }
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation mostCommonWord( paragraph : String, banned : Sequence(String)) : String
  pre: true
  post: true
  activity: (     paragraph := paragraph+(".") ; 
     var banset : Set(String) ; banset := Set{} ;
    for (word : banned) do (     banset := banset->including(word) ;  ) ; 
    var count : Map(String,int) ; count := Map{} ;
    var ans : String ; ans := "" ;
    var ansfreq : int ; ansfreq := 0 ;
    var word : String ; word := StringLib.newString() ;
    for (c : paragraph->characters()) do ( (     if ((c + "")->isMatch("[a-zA-Z]")) then (     word := word + StringLib.newString((c + "")->toLowerCase()) ) else     if (word->size() > 0) then (     var finalword : String ; finalword := word+"" ;
     if (not(banset->includes(finalword))) then (     count := count->union(Map{finalword |-> (if count->keys()->contains(finalword) then count->at(finalword) else 0 endif) + 1}) ; 
     if (count->at(finalword) > ansfreq) then (     ans := finalword ; 
     ansfreq := count->at(finalword) ) else skip ) else skip ; 
     word := StringLib.newString() ) else skip ; )  ) ; 
    return ans 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void doIt(){
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      String str[]=new String[n];
      int a[]=new int[n];
      int b[]=new int[n];
      int max=0 ;
      for(int i=0 ; i<n ; i++){
        str[i]=sc.next();
        a[i]=sc.nextInt();
        b[i]=sc.nextInt();
        max=max+a[i];
      }
      for(int i=0 ; i<n ; i++){
        int k=0 ;
        int l=0 ;
        for(int j=0 ; j<n ; j++){
          if(max-a[j]<=b[j]){
            if(a[j]>k){
              k=a[j];
              l=j ;
            }
          }
        }
        max=max-a[l];
        a[l]=0 ;
        b[l]=-10 ;
        System.out.println(str[l]);
      }
    }
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var str : Sequence(String) ; str := Integer.subrange(1,n)->collect(null) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     str[i+1] := sc.getCurrent() ; 
     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() ; 
     max := max + a[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var k : int ; k := 0 ;
     var l : int ; l := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     if (max - a[j+1] <= b[j+1]) then (     if (a[j+1] > k) then (     k := a[j+1] ; 
     l := j ) else skip ) else skip )  ;     j := j + 1 ) ; 
    max := max - a[l+1] ; 
    a[l+1] := 0 ; 
    b[l+1] := -10 ; 
    OclFile["System.out"].println(str[l+1]) ; 
 )  ;     i := i + 1 ) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Food implements Comparable<Food>{
  String f ;
  int w ;
  int s ;
  Food(String f,int w,int s){
    this.f=f ;
    this.w=w ;
    this.s=s ;
  }
  @ Override public int compareTo(Food o){
    if(this.w<w){
      return 1 ;
    }
    else if(this.w>w){
      return-1 ;
    }
    else {
      return 0 ;
    }
  }
}
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int sum=0 ;
      Food food[]=new Food[n];
      for(int i=0 ; i<n ; i++){
        food[i]=new Food(sc.next(),sc.nextInt(),sc.nextInt());
        sum+=food[i] .w ;
      }
      int max=-1 ;
      for(int j=0 ; j<n ; j++){
        int k=j ;
        max=-1 ;
        for(int i=j ; i<n ; i++){
          if((sum-food[i] .w<=food[i] .s)&&(max<food[i] .w)){
            max=food[i] .w ;
            k=i ;
          }
        }
        sum-=food[k] .w ;
        Food temp=food[j];
        food[j]=food[k];
        food[k]=temp ;
      }
      Arrays.sort(food);
      for(int i=0 ; i<n ; i++){
        System.out.println(food[i] .f);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Food implements Comparable<Food> {
   attribute f : String;
   attribute w : int;
   attribute s : int;
   static operation newFood( f : String, w : int, s : int) : Food
  pre: true
  post: true
  activity:
  ( var self : Food ;
    self := createFood();
    self.initialise(f, w,s);
    return self );
  operation initialise( f : String, w : int, s : int) : void
  pre: true  post: true
  activity: (     self.f := f ; 
     self.w := w ; 
     self.s := s );
      operation compareTo( o : Food) : int
  pre: true
  post: true
  activity: (     if (self.w < w) then (     return 1 ) else     if (self.w > w) then (     return -1 ) else (     return 0 ) ;  );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var sum : int ; sum := 0 ;
    var food : Sequence(Food) ; food := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     food[i+1] := Food.newFood(sc.getCurrent(), sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) ; 
     sum := sum+(food[i+1].w) )  ;     i := i + 1 ) ; 
    var max : int ; max := -1 ;
        var j : int ; j := 0 ; while j < n do ( (     var k : int ; k := j ;
     max := -1 ; 
        var i : int ; i := j ; while i < n do ( (     if ((sum - food[i+1].w <= food[i+1].s) & (max < food[i+1].w)) then (     max := food[i+1].w ; 
     k := i ) else skip )  ;     i := i + 1 ) ; 
    sum := sum-(food[k+1].w) ; 
    var temp : Food ; temp := food[j+1] ;
    food[j+1] := food[k+1] ; 
    food[k+1] := temp ; 
 )  ;     j := j + 1 ) ; 
    food := food->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(food[i+1].f) )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      int n=sc.nextInt();
      if(n==0)break ;
      items=new Item[n];
      for(int i=0 ; i<n ; i++){
        items[i]=new Item();
        items[i] .name=sc.next();
        items[i] .w=sc.nextInt();
        items[i] .s=sc.nextInt();
      }
      int totalWeight=0 ;
      for(Item item : items)totalWeight+=item.w ;
      bestG=Integer.MAX_VALUE ;
      bestSeq=new Item[n];
      seq=new Item[n];
      dfs(0,0,totalWeight);
      for(Item item : bestSeq){
        System.out.println(item.name);
      }
    }
  }
  void dfs(int depth,int curG,int remainWeight){
    if(depth==items.length){
      if(bestG>curG){
        bestG=curG ;
        bestSeq=seq.clone();
      }
      return ;
    }
    for(Item item : items){
      if(! item.used && remainWeight-item.w<=item.s){
        item.used=true ;
        seq[depth]=item ;
        dfs(depth+1,curG+item.w*(depth+1),remainWeight-item.w);
        item.used=false ;
        seq[depth]=null ;
      }
    }
  }
  Item[] items ;
  int bestG ;
  Item[] bestSeq ;
  Item[] seq ;
  class Item {
    String name ;
    int w ;
    int s ;
    boolean used ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    items := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do ( (     items[i+1] := Item.newItem() ; 
     items[i+1].name := sc.getCurrent() ; 
     items[i+1].w := sc.getCurrent()->toInteger() ; 
     items[i+1].s := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var totalWeight : int ; totalWeight := 0 ;
    for (item : items) do (     totalWeight := totalWeight+(item.w) ;  ) ; 
    bestG := 2147483647 ; 
    bestSeq := Integer.subrange(1,n)->collect(null) ; 
    seq := Integer.subrange(1,n)->collect(null) ; 
    execute dfs(0, 0, totalWeight) ; 
    for (item : bestSeq) do ( (     OclFile["System.out"].println(item.name) )  ) ; 
 )  ) );
   operation dfs( depth : int, curG : int, remainWeight : int) : void
  pre: true
  post: true
  activity: (     if (depth = items->size()) then (     if (bestG > curG) then (     bestG := curG ; 
     bestSeq := seq->copy() ) else skip ; 
     return ) else skip ; 
     for (item : items) do ( (     if (not(item.used) & remainWeight - item.w <= item.s) then (     item.used := true ; 
     seq[depth+1] := item ; 
    execute dfs(depth + 1, curG + item.w * (depth + 1), remainWeight - item.w) ; 
    item.used := false ; 
    seq[depth+1] := null ; 
 ) else skip )  ) );
   attribute items : Sequence(Item);
   attribute bestG : int;
   attribute bestSeq : Sequence(Item);
   attribute seq : Sequence(Item);
 class Item {
   attribute name : String;
   attribute w : int;
   attribute s : int;
   attribute used : boolean;
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  class t {
    double v=0 ;
    String a="" ;
  }
  int w[];
  int s[];
  String f[];
  t g(boolean[] reaming,double rw,int depth){
    if(depth==w.length){
      return new t();
    }
    double res=Double.MAX_VALUE ;
    int dv=0 ;
    String ans="" ;
    for(int i=0 ; i<reaming.length ; i++){
      if(reaming[i]){
        if(rw-w[i]<=s[i]){
          reaming[i]=false ;
          t gz=g(reaming,rw-w[i],depth+1);
          gz.v+=rw ;
          reaming[i]=true ;
          if(res>gz.v){
            res=gz.v ;
            ans=gz.a ;
            dv=i ;
          }
        }
      }
    }
    ans=f[dv]+"\n"+ans ;
    t ret=new t();
    ret.v=res ;
    ret.a=ans ;
    return ret ;
  }
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      f=new String[n];
      w=new int[n];
      s=new int[n];
      double rw=0 ;
      for(int i=0 ; i<n ; i++){
        f[i]=sc.next();
        w[i]=sc.nextInt();
        s[i]=sc.nextInt();
        rw+=w[i];
      }
      boolean reaming[]=new boolean[n];
      Arrays.fill(reaming,true);
      t ans=g(reaming,rw,0);
      System.out.print(ans.a);
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
 class t {
   attribute v : double := 0;
   attribute a : String := "";
}
   attribute w : Sequence(int);
   attribute s : Sequence(int);
   attribute f : Sequence(String);
   operation g( reaming : Sequence(boolean), rw : double, depth : int) : t
  pre: true
  post: true
  activity: (     if (depth = w->size()) then (     return t.newt() ) else skip ; 
     var res : double ; res := (2 - 2->pow(-52))*(2->pow(1023)) ;
    var dv : int ; dv := 0 ;
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < reaming->size() do ( (     if (reaming[i+1]) then (     if (rw - w[i+1] <= s[i+1]) then (     reaming[i+1] := false ; 
     var gz : t ; gz := g(reaming, rw - w[i+1], depth + 1) ;
    gz.v := gz.v+(rw) ; 
    reaming[i+1] := true ; 
    if (res > gz.v) then (     res := gz.v ; 
     ans := gz.a ; 
     dv := i ) else skip ; 
 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    ans := f[dv+1] + "\n" + ans ; 
    var ret : t ; ret := t.newt() ;
    ret.v := res ; 
    ret.a := ans ; 
    return ret 
 );
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    f := Integer.subrange(1,n)->collect(null) ; 
    w := Integer.subrange(1,n)->collect(0) ; 
    s := Integer.subrange(1,n)->collect(0) ; 
    var rw : double ; rw := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     f[i+1] := sc.getCurrent() ; 
     w[i+1] := sc.getCurrent()->toInteger() ; 
     s[i+1] := sc.getCurrent()->toInteger() ; 
     rw := rw+(w[i+1]) )  ;     i := i + 1 ) ; 
    var reaming : Sequence(boolean) ; reaming := Integer.subrange(1,n)->collect(false) ;
    reaming := reaming->collect(true) ; 
    var ans : t ; ans := g(reaming, rw, 0) ;
    OclFile["System.out"].print(ans.a) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    boolean startsFromA=(S.charAt(0)=='A');
    String seekC=S.substring(2,S.length()-1);
    int indexOfC=seekC.indexOf('C');
    boolean containsSingleC=(indexOfC!=-1 && seekC.indexOf('C',indexOfC+1)==-1);
    boolean lowersOtherThanAC=isLowersOtherThanAC(S,indexOfC+2);
    System.out.println((startsFromA && containsSingleC && lowersOtherThanAC)? "AC" : "WA");
  }
  private static boolean isLowersOtherThanAC(String S,int indexOfC){
    char[] array=S.toCharArray();
    int length=array.length ;
    for(int i=1 ; i<length ; i++){
      if(i!=indexOfC && Character.isUpperCase(array[i])){
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    var startsFromA : boolean ; startsFromA := (S->at(0+1) = 'A') ;
    var seekC : String ; seekC := S.subrange(2+1,S->size() - 1) ;
    var indexOfC : int ; indexOfC := seekC->indexOf('C')-1 ;
    var containsSingleC : boolean ; containsSingleC := (indexOfC /= -1 & seekC.subrange(indexOfC + 1+1)->indexOf('C'+"") + indexOfC + 1 - 1  = -1) ;
    var lowersOtherThanAC : boolean ; lowersOtherThanAC := isLowersOtherThanAC(S, indexOfC + 2) ;
    OclFile["System.out"].println(if (startsFromA & containsSingleC & lowersOtherThanAC) then "AC" else "WA" endif) ; 
 );
  static   operation isLowersOtherThanAC( S : String, indexOfC : int) : boolean
  pre: true
  post: true
  activity: (     var array : Sequence(String) ; array := S->characters() ;
     var length : int ; length := array->size() ;
         var i : int ; i := 1 ; while i < length do ( (     if (i /= indexOfC & (array[i+1]->toUpperCase() = array[i+1])) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math ;
public class test {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),s=sc.nextInt();
    int[] a=new int[n],b=new int[n];
    for(int i=0 ; i<n ; ++i){
      a[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; ++i){
      b[i]=sc.nextInt();
    }
    if(a[0]==1){
      if(a[s-1]==1){
        System.out.println("YES");
      }
      else {
        if(b[s-1]==0){
          System.out.println("NO");
        }
        else {
          boolean check=false ;
          for(int i=s ; i<n ; ++i){
            if(a[i]==1 && b[i]==1){
              System.out.println("YES");
              check=true ;
              break ;
            }
          }
          if(! check){
            System.out.println("NO");
          }
        }
      }
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (a[0+1] = 1) then (     if (a[s - 1+1] = 1) then (     OclFile["System.out"].println("YES") ) else (     if (b[s - 1+1] = 0) then (     OclFile["System.out"].println("NO") ) else (     var check : boolean ; check := false ;
         var i : int ; i := s ; while i < n do ( (     if (a[i+1] = 1 & b[i+1] = 1) then (     OclFile["System.out"].println("YES") ; 
     check := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (not(check)) then (     OclFile["System.out"].println("NO") ) else skip ) ) ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test223 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int x=in.nextInt();
      if(x==1){
        System.out.println("2");
      }
      else if(x==2){
        System.out.println("1");
      }
      else if(x % 3==0){
        System.out.println(x/3);
      }
      else {
        System.out.println(x/3+1);
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test223 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     if (x = 1) then (     OclFile["System.out"].println("2") ) else     if (x = 2) then (     OclFile["System.out"].println("1") ) else     if (x mod 3 = 0) then (     OclFile["System.out"].println(x / 3) ) else (     OclFile["System.out"].println(x / 3 + 1) ) ;  ;  )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader reader=new BufferedReader(isr);
    String str,s[];
    int n,q,date[];
    x : while(!(str=reader.readLine()).equals("0 0")){
      s=str.split(" ");
      n=Integer.valueOf(s[0]);
      q=Integer.valueOf(s[1]);
      date=new int[110];
      for(int i=0 ; i<n ; i++){
        s=reader.readLine().split(" ");
        for(int j=1 ; j<=Integer.valueOf(s[0]); j++){
          date[Integer.valueOf(s[j])]++;
        }
      }
      for(int i=n ; i>=q ; i--)for(int j=1 ; j<date.length ; j++){
        if(date[j]==i){
          System.out.println(j);
          continue x ;
        }
      }
      System.out.println(0);
    }
    reader.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(isr) ;
    var str : String ;
    var s : Sequence(void) ;
    var n : int ;
    var q : int ;
    var date : Sequence(void) ;
    while (not((str) = "0 0")) do (     s := str->split(" ") ; 
     n := (s[0+1])->toInteger() ; 
    q := (s[1+1])->toInteger() ; 
    date := Integer.subrange(1,110)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     s := reader.readLine()->split(" ") ; 
         var j : int ; j := 1 ; while j <= (s[0+1])->toInteger() do ( (     date[(s[j+1])->toInteger()+1] := date[(s[j+1])->toInteger()+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := n ; while i >= q do (         var j : int ; j := 1 ; while j < date->size() do ( (     if (date[j+1] = i) then (     OclFile["System.out"].println(j) ; 
     continue ) else skip )  ;     j := j + 1 ) ;  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(0) ; 
 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.stream.IntStream ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    MyScanner in=new MyScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    B solver=new B();
    solver.solve(1,in,out);
    out.close();
  }
  static class B {
    public void solve(int testNumber,MyScanner in,PrintWriter out){
      String S=in.next();
      boolean ok ;
      ok=S.charAt(0)=='A' ;
      String substring=S.substring(2,S.length()-1);
      ok=ok && substring.chars().filter(c->c=='C').count()==1 ;
      String substring1=S.substring(0,2);
      ok=ok && substring1.indexOf('C')==-1 ;
      String substring2=S.substring(S.length()-1);
      ok=ok && substring2.indexOf('C')==-1 ;
      ok=ok && S.substring(1).chars().filter(c->c!='C').filter(c->'A'<=c && c<='Z').count()==0 ;
      out.println(ok ? "AC" : "WA");
    }
  }
  static class MyScanner {
    private BufferedReader in ;
    private StringTokenizer st ;
    public MyScanner(InputStream stream){
      in=new BufferedReader(new InputStreamReader(stream));
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          String rl=in.readLine();
          if(rl==null){
            return null ;
          }
          st=new StringTokenizer(rl);
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : MyScanner ; in := MyScanner.newMyScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : B ; solver := B.newB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class B {
   operation solve( testNumber : int, in : MyScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var S : String ; S := in.next() ;
     var ok : boolean ;
    ok := S->at(0+1) = 'A' ; 
    var substring : String ; substring := S.subrange(2+1,S->size() - 1) ;
    ok := ok & substring.chars()->select( _x1 | (lambda c : OclAny in c = 'C')->apply(_x1) )->size() = 1 ; 
    var substring1 : String ; substring1 := S.subrange(0+1,2) ;
    ok := ok & substring1->indexOf('C')-1 = -1 ; 
    var substring2 : String ; substring2 := S.subrange(S->size() - 1+1,S->size() - 1) ;
    ok := ok & substring2->indexOf('C')-1 = -1 ; 
    ok := ok & S.subrange(1+1,1).chars()->select( _x1 | (lambda c : OclAny in c /= 'C')->apply(_x1) )->select( _x1 | (lambda c : OclAny in 'A' <= c & c <= 'Z')->apply(_x1) )->size() = 0 ; 
    skip ; 
 );
}
  static class MyScanner {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner( stream : OclFile) : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     var rl : String ; rl := in.readLine() ;
     if (rl = null) then (     return null ) else skip ; 
     st := OclIterator.newOclIterator_String(rl) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static boolean test(String test){
    int c=0 ;
    for(int i=0 ; i<test.length(); i++){
      if(i==0){
        if(test.charAt(i)=='A'){
          continue ;
        }
        else {
          return false ;
        }
      }
      if(i>=2 && i<=test.length()-2){
        if(test.charAt(i)=='C'){
          c++;
          if(c>1){
            return false ;
          }
          continue ;
        }
      }
      if(Character.isUpperCase(test.charAt(i))){
        return false ;
      }
    }
    if(c==0){
      return false ;
    }
    return true ;
  }
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    String a=scan.next();
    if(test(a)){
      System.out.println("AC");
    }
    else {
      System.out.println("WA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation test( test : String) : boolean
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
         var i : int ; i := 0 ; while i < test->size() do ( (     if (i = 0) then (     if (test->at(i+1) = 'A') then (     continue ) else (     return false ) ) else skip ; 
     if (i >= 2 & i <= test->size() - 2) then (     if (test->at(i+1) = 'C') then (     c := c + 1 ; 
     if (c > 1) then (     return false ) else skip ; 
     continue ) else skip ) else skip ; 
     if ((test->at(i+1)->toUpperCase() = test->at(i+1))) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     if (c = 0) then (     return false ) else skip ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := scan.getCurrent() ;
     if (test(a)) then (     OclFile["System.out"].println("AC") ) else (     OclFile["System.out"].println("WA") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc1=new Scanner(System.in);
    String str1=sc1.next();
    StringBuilder sb1=new StringBuilder();
    StringBuilder sb2=new StringBuilder();
    sb1.append(str1);
    sb2.append(str1.toLowerCase());
    String str2=sb2.toString();
    boolean flg=true ;
    if(str1.charAt(0)!='A'){
      flg=false ;
    }
    sb1.deleteCharAt(0);
    sb1.insert(0,"a");
    int tmp=str1.indexOf('C');
    if(tmp<2 | tmp>str1.length()-2){
      flg=false ;
    }
    else {
      sb1.deleteCharAt(tmp);
      sb1.insert(tmp,"c");
      tmp=str1.indexOf('C',tmp+1);
      if(tmp>0){
        flg=false ;
      }
    }
    str1=sb1.toString();
    if(!(str1.equals(str2))){
      flg=false ;
    }
    if(flg){
      System.out.println("AC");
    }
    else {
      System.out.println("WA");
    }
    sc1.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc1 : OclFile ; sc1 := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str1 : String ; str1 := sc1.getCurrent() ;
    var sb1 : String ; sb1 := StringLib.newString() ;
    var sb2 : String ; sb2 := StringLib.newString() ;
    sb1 := sb1 + StringLib.newString(str1) ; 
    sb2 := sb2 + StringLib.newString(str1->toLowerCase()) ; 
    var str2 : String ; str2 := sb2+"" ;
    var flg : boolean ; flg := true ;
    if (str1->at(0+1) /= 'A') then (     flg := false ) else skip ; 
    sb1 := sb1->excludingAt(0+1) ; 
    sb1 := sb1.insertAt(0+1, StringLib.newString("a")) ; 
    var tmp : int ; tmp := str1->indexOf('C')-1 ;
    if (tmp < 2 or tmp > str1->size() - 2) then (     flg := false ) else (     sb1 := sb1->excludingAt(tmp+1) ; 
     sb1 := sb1.insertAt(tmp+1, StringLib.newString("c")) ; 
     tmp := str1.subrange(tmp + 1+1)->indexOf('C'+"") + tmp + 1 - 1  ; 
     if (tmp > 0) then (     flg := false ) else skip ) ;  
    str1 := sb1+"" ; 
    if (not((str1 = str2))) then (     flg := false ) else skip ; 
    if (flg) then (     OclFile["System.out"].println("AC") ) else (     OclFile["System.out"].println("WA") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.stream.IntStream ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BAcCepted solver=new BAcCepted();
    solver.solve(1,in,out);
    out.close();
  }
  static class BAcCepted {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      String s=in.next();
      out.println(s.chars().filter(Character :: isUpperCase).count()==2 && s.substring(2,s.length()-1).chars().anyMatch(c->c=='C')&& s.charAt(0)=='A' ? "AC" : "WA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BAcCepted ; solver := BAcCepted.newBAcCepted() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BAcCepted {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.getCurrent() ;
     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int k=s.nextInt();
    boolean[] not_replay=new boolean[n];
    boolean[] is_replayed=new boolean[n];
    boolean[] visible=new boolean[n];
    int[] parent=new int[n];
    int[] height=new int[n];
    for(int i=0 ; i<n ; i++){
      int a=s.nextInt();
      if(a==0){
        not_replay[i]=true ;
        parent[i]=-1 ;
      }
      else {
        is_replayed[a-1]=true ;
        parent[i]=a-1 ;
      }
    }
    Deque<Integer>que=new ArrayDeque<Integer>();
    boolean[] checked=new boolean[n];
    for(int i=0 ; i<n ; i++){
      check(i,not_replay,is_replayed,visible,que,height,checked);
    }
    while(! que.isEmpty()){
      int x=que.poll();
      if(height[x]<k){
        visible[x]=true ;
        int p=parent[x];
        if(p!=-1 && ! checked[p]){
          height[p]=height[x]+1 ;
          checked[p]=true ;
          que.add(p);
        }
      }
    }
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(visible[i])ans++;
    }
    System.out.println(ans);
  }
  static void check(int x,boolean[] not_replay,boolean[] is_replayed,boolean[] visible,Deque<Integer>que,int[] height,boolean[] checked){
    if(not_replay[x]){
      visible[x]=true ;
    }
    if(! is_replayed[x]){
      height[x]=0 ;
      checked[x]=true ;
      que.push(x);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var k : int ; k := s.getCurrent()->toInteger() ;
    var not_replay : Sequence(boolean) ; not_replay := Integer.subrange(1,n)->collect(false) ;
    var is_replayed : Sequence(boolean) ; is_replayed := Integer.subrange(1,n)->collect(false) ;
    var visible : Sequence(boolean) ; visible := Integer.subrange(1,n)->collect(false) ;
    var parent : Sequence(int) ; parent := Integer.subrange(1,n)->collect(0) ;
    var height : Sequence(int) ; height := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := s.getCurrent()->toInteger() ;
     if (a = 0) then (     not_replay[i+1] := true ; 
     parent[i+1] := -1 ) else (     is_replayed[a - 1+1] := true ; 
     parent[i+1] := a - 1 ) )  ;     i := i + 1 ) ; 
    var que : Sequence(int) ; que := ArrayDeque<int>.newArrayDeque() ;
    var checked : Sequence(boolean) ; checked := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     execute check(i, not_replay, is_replayed, visible, que, height, checked) )  ;     i := i + 1 ) ; 
    while (not(que->isEmpty())) do (     var x : int ; x := que->min() ;
     if (height[x+1] < k) then (     visible[x+1] := true ; 
     var p : int ; p := parent[x+1] ;
     if (p /= -1 & not(checked[p+1])) then (     height[p+1] := height[x+1] + 1 ; 
     checked[p+1] := true ; 
     que := que->including(p) ) else skip ) else skip ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (visible[i+1]) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation check( x : int, not_replay : Sequence(boolean), is_replayed : Sequence(boolean), visible : Sequence(boolean), que : Sequence(int), height : Sequence(int), checked : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (     if (not_replay[x+1]) then (     visible[x+1] := true ) else skip ; 
     if (not(is_replayed[x+1])) then (     height[x+1] := 0 ; 
     checked[x+1] := true ; 
     que := que->append(x) ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Map.Entry ;
import java.util.*;
import java.math.*;
import org.w3c.dom.css.Counter ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int H=Integer.valueOf(s.next());
    int N=Integer.valueOf(s.next());
    int[] HPdown=new int[N+1];
    int[] MPcost=new int[N+1];
    int error=9999999 ;
    for(int i=0 ; i<N ; i++){
      HPdown[i]=Integer.valueOf(s.next());
      MPcost[i]=Integer.valueOf(s.next());
    }
    long[] dp=new long[20000];
    Arrays.fill(dp,Integer.MAX_VALUE);
    dp[0]=0 ;
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<10000 ; j++){
        dp[j+HPdown[i] ]=Long.min(dp[j+HPdown[i] ],dp[j]+MPcost[i]);
      }
    }
    for(int i=10001 ; i>=0 ; i--){
      dp[i]=Long.min(dp[i],dp[i+1]);
    }
    System.out.println(dp[H]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := (s.getCurrent())->toInteger() ;
    var N : int ; N := (s.getCurrent())->toInteger() ;
    var HPdown : Sequence(int) ; HPdown := Integer.subrange(1,N + 1)->collect(0) ;
    var MPcost : Sequence(int) ; MPcost := Integer.subrange(1,N + 1)->collect(0) ;
    var error : int ; error := 9999999 ;
        var i : int ; i := 0 ; while i < N do ( (     HPdown[i+1] := (s.getCurrent())->toInteger() ; 
     MPcost[i+1] := (s.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(long) ; dp := Integer.subrange(1,20000)->collect(0) ;
    dp := dp->collect(2147483647) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < 10000 do ( (     dp[j + HPdown[i+1]+1] := Set{dp[j + HPdown[i+1]+1], dp[j+1] + MPcost[i+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 10001 ; while i >= 0 do ( (     dp[i+1] := Set{dp[i+1], dp[i + 1+1]}->min() )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(dp[H+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int MAX=(int)1e9+7 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=Integer.parseInt(sc.next());
    int n=Integer.parseInt(sc.next());
    int[] a=new int[n];
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(sc.next());
      b[i]=Integer.parseInt(sc.next());
    }
    int[] dp=new int[h+1];
    Arrays.fill(dp,MAX);
    dp[0]=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<h ; j++){
        int idx=Math.min(h,j+a[i]);
        dp[idx]=Math.min(dp[idx],dp[j]+b[i]);
      }
    }
    System.out.println(dp[h]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 1e9->oclAsType(int) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := (sc.getCurrent())->toInteger() ;
    var n : int ; n := (sc.getCurrent())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sc.getCurrent())->toInteger() ; 
     b[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,h + 1)->collect(0) ;
    dp := dp->collect(MAX) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < h do ( (     var idx : int ; idx := Set{h, j + a[i+1]}->min() ;
     dp[idx+1] := Set{dp[idx+1], dp[j+1] + b[i+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[h+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int hp=scanner.nextInt();
    int n=scanner.nextInt();
    List<Integer>damages=new ArrayList<>(n);
    List<Integer>costs=new ArrayList<>(n);
    for(int i=0 ; i<n ; i++){
      int d=scanner.nextInt();
      int c=scanner.nextInt();
      damages.add(d);
      costs.add(c);
    }
    int[] damage2cost=new int[hp+1];
    for(int less_hp=1 ; less_hp<=hp ; less_hp++){
      int minimam_cost=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; i++){
        int last_damage=damages.get(i);
        int last_cost=costs.get(i);
        int rest_hp=less_hp-last_damage ;
        int cost ;
        if(rest_hp<0){
          cost=last_cost ;
        }
        else {
          cost=last_cost+damage2cost[rest_hp];
        }
        if(cost<minimam_cost){
          minimam_cost=cost ;
        }
      }
      damage2cost[less_hp]=minimam_cost ;
    }
    System.out.println(damage2cost[hp]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var hp : int ; hp := scanner.getCurrent()->toInteger() ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var damages : Sequence(int) ; damages := Sequence{} ;
    var costs : Sequence(int) ; costs := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var d : int ; d := scanner.getCurrent()->toInteger() ;
     var c : int ; c := scanner.getCurrent()->toInteger() ;
     damages := damages->including(d) ; 
     costs := costs->including(c) )  ;     i := i + 1 ) ; 
    var damage2cost : Sequence(int) ; damage2cost := Integer.subrange(1,hp + 1)->collect(0) ;
        var less_hp : int ; less_hp := 1 ; while less_hp <= hp do ( (     var minimam_cost : int ; minimam_cost := 2147483647 ;
         var i : int ; i := 0 ; while i < n do ( (     var last_damage : int ; last_damage := damages->at(i+1) ;
     var last_cost : int ; last_cost := costs->at(i+1) ;
    var rest_hp : int ; rest_hp := less_hp - last_damage ;
    var cost : int ;
    if (rest_hp < 0) then (     cost := last_cost ) else (     cost := last_cost + damage2cost[rest_hp+1] ) ;  
    if (cost < minimam_cost) then (     minimam_cost := cost ) else skip ; 
 )  ;     i := i + 1 ) ; 
     damage2cost[less_hp+1] := minimam_cost )  ;     less_hp := less_hp + 1 ) ; 
    OclFile["System.out"].println(damage2cost[hp+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.min ;
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    resolve(System.in,System.out);
  }
  static void resolve(InputStream is,PrintStream pw){
    Scanner sc=new Scanner(is);
    int h=Integer.parseInt(sc.next());
    int n=Integer.parseInt(sc.next());
    long dp[]=new long[h+1];
    for(int i=0 ; i<dp.length ; i++){
      dp[i]=Integer.MAX_VALUE ;
    }
    dp[0]=0 ;
    for(int i=0 ; i<n ; i++){
      int a=Integer.parseInt(sc.next());
      int b=Integer.parseInt(sc.next());
      for(int j=0 ; j<h ; j++){
        int nj=min(j+a,h);
        dp[nj]=min(dp[nj],dp[j]+b);
      }
    }
    pw.println(dp[h]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute resolve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation resolve( is : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(is) ;
     var h : int ; h := (sc.getCurrent())->toInteger() ;
    var n : int ; n := (sc.getCurrent())->toInteger() ;
    var dp : Sequence(long) ; dp := Integer.subrange(1,h + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < dp->size() do ( (     dp[i+1] := 2147483647 )  ;     i := i + 1 ) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := (sc.getCurrent())->toInteger() ;
     var b : int ; b := (sc.getCurrent())->toInteger() ;
         var j : int ; j := 0 ; while j < h do ( (     var nj : int ; nj := min(j + a, h) ;
     dp[nj+1] := Set{dp[nj+1], dp[j+1] + b}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    pw.println(dp[h+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.HashMap ;
import java.util.Map ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner scan=new Scanner(System.in);
    int input1=scan.nextInt();
    int input2=scan.nextInt();
    while(!(input1==0 && input2==0)){
      HashMap<Integer,Integer>map=new HashMap<>();
      for(int members=0 ; members<input1 ; members++){
        int input3=scan.nextInt();
        for(int dates=0 ; dates<input3 ; dates++){
          int input4=scan.nextInt();
          if(map.containsKey(input4)){
            int number=map.get(input4);
            map.remove(input4);
            map.put(input4,number+1);
          }
          else {
            map.put(input4,1);
          }
        }
      }
      int answerDate=-1 ;
      int count=-1 ;
      for(Map.Entry entry : map.entrySet()){
        int dummyKey=(int)entry.getKey();
        int dummyCount=(int)entry.getValue();
        if(dummyCount>count){
          answerDate=dummyKey ;
          count=dummyCount ;
        }
        else if(dummyCount==count){
          if(answerDate>dummyKey){
            answerDate=dummyKey ;
          }
        }
      }
      if(count<input2)answerDate=0 ;
      System.out.println(answerDate);
      input1=scan.nextInt();
      input2=scan.nextInt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input1 : int ; input1 := scan.getCurrent()->toInteger() ;
     var input2 : int ; input2 := scan.getCurrent()->toInteger() ;
     while (not((input1 = 0 & input2 = 0))) do (     var map : Map(int,int) ; map := Map{} ;
         var members : int ; members := 0 ; while members < input1 do ( (     var input3 : int ; input3 := scan.getCurrent()->toInteger() ;
         var dates : int ; dates := 0 ; while dates < input3 do ( (     var input4 : int ; input4 := scan.getCurrent()->toInteger() ;
     if (map->keys()->includes(input4)) then (     var number : int ; number := map->at(input4) ;
     map := map->antirestrict(Set{input4}) ; 
     map := map->union(Map{input4 |-> number + 1}) ) else (     map := map->union(Map{input4 |-> 1}) ) )  ;     dates := dates + 1 ) )  ;     members := members + 1 ) ; 
    var answerDate : int ; answerDate := -1 ;
    var count : int ; count := -1 ;
    for (entry : map->asSet()) do ( (     var dummyKey : int ; dummyKey := entry.getKey()->oclAsType(int) ;
     var dummyCount : int ; dummyCount := entry.getValue()->oclAsType(int) ;
     if (dummyCount > count) then (     answerDate := dummyKey ; 
     count := dummyCount ) else     if (dummyCount = count) then (     if (answerDate > dummyKey) then (     answerDate := dummyKey ) else skip ) else skip ; )  ) ; 
    if (count < input2) then     answerDate := 0 ; else skip ; 
    OclFile["System.out"].println(answerDate) ; 
    input1 := scan.getCurrent()->toInteger() ; 
    input2 := scan.getCurrent()->toInteger() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int s=sc.nextInt();
      int[] t1=new int[n];
      int[] t2=new int[n];
      boolean flag=false ;
      for(int i=0 ; i<n ; i++){
        t1[i]=sc.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        t2[i]=sc.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        if(i+1>=s){
          if(t1[i]==t2[i] && t1[i]==1){
            flag=true ;
            break ;
          }
        }
      }
      if(t1[0]==0)System.out.println("NO");
      else if(t1[0]==1 && t1[s-1]==1)System.out.println("YES");
      else if(t1[0]==1 && t1[s-1]==0 && t2[s-1]==1 && flag==true)System.out.println("YES");
      else if(t1[0]==1 && t1[s-1]==0 && t2[s-1]==1 && flag==false)System.out.println("NO");
      else System.out.println("NO");
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var t1 : Sequence(int) ; t1 := Integer.subrange(1,n)->collect(0) ;
    var t2 : Sequence(int) ; t2 := Integer.subrange(1,n)->collect(0) ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < n do ( (     t1[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     t2[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i + 1 >= s) then (     if (t1[i+1] = t2[i+1] & t1[i+1] = 1) then (     flag := true ; 
     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (t1[0+1] = 0) then     OclFile["System.out"].println("NO") else     if (t1[0+1] = 1 & t1[s - 1+1] = 1) then     OclFile["System.out"].println("YES") else     if (t1[0+1] = 1 & t1[s - 1+1] = 0 & t2[s - 1+1] = 1 & flag = true) then     OclFile["System.out"].println("YES") else     if (t1[0+1] = 1 & t1[s - 1+1] = 0 & t2[s - 1+1] = 1 & flag = false) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("NO") ; ;  ;  ;  ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner sc=new FastScanner();
    int h=sc.nextInt();
    int n=sc.nextInt();
    int[] arr=new int[n];
    long[] brr=new long[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      brr[i]=sc.nextInt();
    }
    long[] val=new long[h+1];
    Arrays.fill(val,Integer.MAX_VALUE);
    val[0]=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=1 ; j<=Math.min(arr[i],h); j++){
        val[j]=Math.min(val[j],brr[i]);
      }
      for(int j=0 ; j+arr[i]<=h ; j++){
        val[j+(int)arr[i] ]=Math.min(val[j+(int)arr[i] ],val[j]+brr[i]);
      }
    }
    System.out.println(val[h]);
  }
  static class FastScanner {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public FastScanner(){
      reader=new BufferedReader(new InputStreamReader(System.in),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner() ;
     var h : int ; h := sc.nextInt() ;
    var n : int ; n := sc.nextInt() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var brr : Sequence(long) ; brr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.nextInt() ; 
     brr[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    var val : Sequence(long) ; val := Integer.subrange(1,h + 1)->collect(0) ;
    val := val->collect(2147483647) ; 
    val[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 1 ; while j <= Set{arr[i+1], h}->min() do ( (     val[j+1] := Set{val[j+1], brr[i+1]}->min() )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j + arr[i+1] <= h do ( (     val[j + arr[i+1]->oclAsType(int)+1] := Set{val[j + arr[i+1]->oclAsType(int)+1], val[j+1] + brr[i+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(val[h+1]) ; 
 );
  static class FastScanner {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static int sumofseries(int n){
    return(n*(n+1)*(n+2)*(n+3)/4);
  }
  public static void main(String[] args){
    System.out.println(sumofseries(3));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumofseries( n : int) : int
  pre: true
  post: true
  activity: (     return (n * (n + 1) * (n + 2) * (n + 3) / 4) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(sumofseries(3)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Vector<String>preProcess(int n){
    Vector<String>preProcessedCubes=new Vector<>();
    for(int i=1 ; i*i*i<=n ; i++){
      int iThCube=i*i*i ;
      String cubeString=String.valueOf(iThCube);
      preProcessedCubes.add(cubeString);
    }
    return preProcessedCubes ;
  }
  static String findLargestCubeUtil(String num,Vector<String>preProcessedCubes){
    Collections.reverse(preProcessedCubes);
    int totalCubes=preProcessedCubes.size();
    for(int i=0 ; i<totalCubes ; i++){
      String currCube=preProcessedCubes.get(i);
      int digitsInCube=currCube.length();
      int index=0 ;
      int digitsInNumber=num.length();
      for(int j=0 ; j<digitsInNumber ; j++){
        if(num.charAt(j)==currCube.charAt(index)){
          index++;
        }
        if(digitsInCube==index){
          return currCube ;
        }
      }
    }
    return "Not Possible" ;
  }
  static void findLargestCube(int n){
    Vector<String>preProcessedCubes=preProcess(n);
    String num=String.valueOf(n);
    String ans=findLargestCubeUtil(num,preProcessedCubes);
    System.out.println("Largest Cube that can be formed from "+n+" is "+ans);
  }
  public static void main(String[] args){
    int n ;
    n=4125 ;
    findLargestCube(n);
    n=876 ;
    findLargestCube(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation preProcess( n : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var preProcessedCubes : Sequence(String) ; preProcessedCubes := Sequence{} ;
         var i : int ; i := 1 ; while i * i * i <= n do ( (     var iThCube : int ; iThCube := i * i * i ;
     var cubeString : String ; cubeString := ((iThCube) + "") ;
     preProcessedCubes := preProcessedCubes->including(cubeString) )  ;     i := i + 1 ) ; 
     return preProcessedCubes );
  static   operation findLargestCubeUtil( num : String, preProcessedCubes : Sequence(String)) : String
  pre: true
  post: true
  activity: (     preProcessedCubes := preProcessedCubes->reverse() ; 
     var totalCubes : int ; totalCubes := preProcessedCubes->size() ;
         var i : int ; i := 0 ; while i < totalCubes do ( (     var currCube : String ; currCube := preProcessedCubes->at(i+1) ;
     var digitsInCube : int ; digitsInCube := currCube->size() ;
    var index : int ; index := 0 ;
    var digitsInNumber : int ; digitsInNumber := num->size() ;
        var j : int ; j := 0 ; while j < digitsInNumber do ( (     if (num->at(j+1) = currCube->at(index+1)) then (     index := index + 1 ) else skip ; 
     if (digitsInCube = index) then (     return currCube ) else skip )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
     return "Not Possible" );
  static   operation findLargestCube( n : int) : void
  pre: true
  post: true
  activity: (     var preProcessedCubes : Sequence(String) ; preProcessedCubes := preProcess(n) ;
     var num : String ; num := ((n) + "") ;
     var ans : String ; ans := findLargestCubeUtil(num, preProcessedCubes) ;
     OclFile["System.out"].println("Largest Cube that can be formed from " + n + " is " + ans) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     n := 4125 ; 
    execute findLargestCube(n) ; 
    n := 876 ; 
    execute findLargestCube(n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int n=sc.nextInt();
    boolean poss=false ;
    for(int i=0 ; i<10 ; i++){
      if((a*10+i)% b==0){
        poss=true ;
        System.out.print(a*10+i);
        n--;
        break ;
      }
    }
    if(! poss)System.out.println(-1);
    else while(n-->0)System.out.print(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var poss : boolean ; poss := false ;
        var i : int ; i := 0 ; while i < 10 do ( (     if ((a * 10 + i) mod b = 0) then (     poss := true ; 
     OclFile["System.out"].print(a * 10 + i) ; 
     n := n - 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (not(poss)) then     OclFile["System.out"].println(-1) else         while (n > 0) do (        n := n - 1 ;     skip ;     OclFile["System.out"].print(0) ; ;  ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class AAddingdigits {
  public static void main(String[] args)throws IOException {
    BufferedReader buf=new BufferedReader(new InputStreamReader(System.in));
    String[] inp=buf.readLine().split(" ");
    int a=Integer.parseInt(inp[0]);
    int b=Integer.parseInt(inp[1]);
    int n=Integer.parseInt(inp[2]);
    boolean flag=false ;
    StringBuilder str=new StringBuilder(inp[0]);
    for(int i=0 ; i<=9 ; i++){
      str.append(i);
      if(Integer.parseInt(str.toString())% b==0){
        flag=true ;
        break ;
      }
      else str.deleteCharAt(str.length()-1);
    }
    if(flag){
      for(int i=1 ; i<n ; i++)str.append(0);
      System.out.println(str);
    }
    else {
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AAddingdigits {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var buf : OclFile ; buf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var inp : Sequence(String) ; inp := buf.readLine()->split(" ") ;
    var a : int ; a := (inp[0+1])->toInteger() ;
    var b : int ; b := (inp[1+1])->toInteger() ;
    var n : int ; n := (inp[2+1])->toInteger() ;
    var flag : boolean ; flag := false ;
    var str : String ; str := StringLib.newString(inp[0+1]) ;
        var i : int ; i := 0 ; while i <= 9 do ( (     str := str + StringLib.newString(i) ; 
     if ((str+"")->toInteger() mod b = 0) then (     flag := true ; 
     break ) else     str := str->excludingAt(str->size() - 1+1) ; )  ;     i := i + 1 ) ; 
    if (flag) then (         var i : int ; i := 1 ; while i < n do (     str := str + StringLib.newString(0) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(str) ) else (     OclFile["System.out"].println(-1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  double dot(double[] a,double[] b){
    return a[0]*b[0]+a[1]*b[1]+a[2]*b[2];
  }
  double norm(double[] a){
    return Math.sqrt(a[0]*a[0]+a[1]*a[1]+a[2]*a[2]);
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      double[][] p=new double[n][3];
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<3 ; j++)p[i][j]=sc.nextDouble();
      int m=sc.nextInt();
      boolean[] u=new boolean[n];
      while(m--!=0){
        double[] t=new double[3];
        for(int i=0 ; i<3 ; i++)t[i]=sc.nextDouble();
        double phi=sc.nextDouble();
        for(int i=0 ; i<n ; i++){
          if(u[i])continue ;
          double w=Math.acos(dot(p[i],t)/norm(p[i])/norm(t));
          if(w<phi+1e-8)u[i]=true ;
        }
      }
      int res=0 ;
      for(boolean f : u)if(f)res++;
      System.out.println(res);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation dot( a : Sequence(double), b : Sequence(double)) : double
  pre: true
  post: true
  activity: (     return a[0+1] * b[0+1] + a[1+1] * b[1+1] + a[2+1] * b[2+1] );
   operation norm( a : Sequence(double)) : double
  pre: true
  post: true
  activity: (     return (a[0+1] * a[0+1] + a[1+1] * a[1+1] + a[2+1] * a[2+1])->sqrt() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var p : Sequence(Sequence(double)) ; p := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < 3 do (     p[i+1][j+1] := sc.getCurrent()->toReal() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var u : Sequence(boolean) ; u := Integer.subrange(1,n)->collect(false) ;
        while (m /= 0) do (    skip ; (     var t : Sequence(double) ; t := Integer.subrange(1,3)->collect(0.0) ;
         var i : int ; i := 0 ; while i < 3 do (     t[i+1] := sc.getCurrent()->toReal() ;  ;     i := i + 1 ) ; 
     var phi : double ; phi := sc.getCurrent()->toReal() ;
         var i : int ; i := 0 ; while i < n do ( (     if (u[i+1]) then     continue else skip ; 
     var w : double ; w := (dot(p[i+1], t) / norm(p[i+1]) / norm(t))->acos() ;
     if (w < phi + 1e-8) then     u[i+1] := true ; else skip )  ;     i := i + 1 ) ) ;  ) ;  
    var res : int ; res := 0 ;
    for (f : u) do (     if (f) then     res := res + 1 ; else skip ;  ) ; 
    OclFile["System.out"].println(res) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static void decToOctal(int n){
    int octalNum[]=new int[100];
    int i=0 ;
    while(n!=0){
      octalNum[i]=n % 8 ;
      n=n/8 ;
      i++;
    }
    for(int j=i-1 ; j>=0 ; j--)System.out.print(octalNum[j]);
    System.out.println("\n");
  }
  static void nDigitPerfectSquares(int n){
    int decimal=(int)Math.pow(Math.ceil(Math.sqrt(Math.pow(8,n)))-1,2);
    decToOctal(decimal);
  }
  public static void main(String[] args){
    int n=2 ;
    nDigitPerfectSquares(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation decToOctal( n : int) : void
  pre: true
  post: true
  activity: (     var octalNum : Sequence(int) ; octalNum := Integer.subrange(1,100)->collect(0) ;
     var i : int ; i := 0 ;
    while (n /= 0) do (     octalNum[i+1] := n mod 8 ; 
     n := n / 8 ; 
     i := i + 1 ) ; 
        var j : int ; j := i - 1 ; while j >= 0 do (     OclFile["System.out"].print(octalNum[j+1]) ;  ;     j := j - 1 ) ; 
    OclFile["System.out"].println("\n") ; 
 );
  static   operation nDigitPerfectSquares( n : int) : void
  pre: true
  post: true
  activity: (     var decimal : int ; decimal := ((8->pow(n))->sqrt())->ceil() - 1->pow(2)->oclAsType(int) ;
     execute decToOctal(decimal) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     execute nDigitPerfectSquares(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static void main(String[] args){
    int ax=5,ay=0 ;
    int bx=1,by=1 ;
    int cx=2,cy=5 ;
    System.out.println(ax+(cx-bx)+","+ay+(cy-by));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ax : int ; ax := 5 ;
    var ay : int ; ay := 0 ;
     var bx : int ; bx := 1 ;
    var by : int ; by := 1 ;
     var cx : int ; cx := 2 ;
    var cy : int ; cy := 5 ;
     OclFile["System.out"].println(ax + (cx - bx) + "," + ay + (cy - by)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeHundredSixtyTwo {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int m=input.nextInt();
    int p=input.nextInt();
    int[] arrayOne=new int[3];
    for(int i=0 ; i<3 ; i++){
      arrayOne[i]=input.nextInt();
    }
    int stair=((Math.abs(n-m))*arrayOne[0]);
    int elev=((Math.abs(n-m))*arrayOne[1]+Math.abs(p-n)*arrayOne[1]+3*arrayOne[2]);
    if(stair<elev){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixtyTwo {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var m : int ; m := input.getCurrent()->toInteger() ;
    var p : int ; p := input.getCurrent()->toInteger() ;
    var arrayOne : Sequence(int) ; arrayOne := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     arrayOne[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var stair : int ; stair := ((if n - m < 0 then -(n - m) else n - m endif) * arrayOne[0+1]) ;
    var elev : int ; elev := ((if n - m < 0 then -(n - m) else n - m endif) * arrayOne[1+1] + if p - n < 0 then -(p - n) else p - n endif * arrayOne[1+1] + 3 * arrayOne[2+1]) ;
    if (stair < elev) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int x=sc.nextInt();
      int y=sc.nextInt();
      int z=sc.nextInt();
      int t1=sc.nextInt();
      int t2=sc.nextInt();
      int t3=sc.nextInt();
      int s=t1*(Math.abs(x-y));
      int comeToSrc=(Math.abs(z-x))*t2 ;
      int goToDest=((Math.abs(x-y))*t2)+t3*3 ;
      int e=comeToSrc+goToDest ;
      if(e<=s)System.out.println("YES");
      else System.out.println("NO");
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var z : int ; z := sc.getCurrent()->toInteger() ;
    var t1 : int ; t1 := sc.getCurrent()->toInteger() ;
    var t2 : int ; t2 := sc.getCurrent()->toInteger() ;
    var t3 : int ; t3 := sc.getCurrent()->toInteger() ;
    var s : int ; s := t1 * (if x - y < 0 then -(x - y) else x - y endif) ;
    var comeToSrc : int ; comeToSrc := (if z - x < 0 then -(z - x) else z - x endif) * t2 ;
    var goToDest : int ; goToDest := ((if x - y < 0 then -(x - y) else x - y endif) * t2) + t3 * 3 ;
    var e : int ; e := comeToSrc + goToDest ;
    if (e <= s) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int right[]=new int[n];
    int left[]=new int[n];
    for(int i=0 ; i<n ; i++){
      right[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      left[i]=sc.nextInt();
    }
    if(right[0]!=1){
      System.out.println("NO");
      System.exit(0);
    }
    else {
      if(right[m-1]==1){
        System.out.println("YES");
        System.exit(0);
      }
      else {
        for(int i=m ; i<n ; i++){
          if(right[i]==1 && left[i]==1 && left[m-1]==1){
            System.out.println("YES");
            System.exit(0);
          }
        }
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var right : Sequence(int) ; right := Integer.subrange(1,n)->collect(0) ;
    var left : Sequence(int) ; left := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     right[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     left[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (right[0+1] /= 1) then (     OclFile["System.out"].println("NO") ; 
 OclProcess.exit(0) ) else (     if (right[m - 1+1] = 1) then (     OclFile["System.out"].println("YES") ; 
 OclProcess.exit(0) ) else (         var i : int ; i := m ; while i < n do ( (     if (right[i+1] = 1 & left[i+1] = 1 & left[m - 1+1] = 1) then (     OclFile["System.out"].println("YES") ; 
 OclProcess.exit(0) ) else skip )  ;     i := i + 1 ) ) ) ;  
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Main(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      boolean[] a=new boolean[10000];
      for(int i=0 ; i<10000 ; i++){
        a[i]=false ;
      }
      for(int i=0 ; i<n ; i++){
        int t=sc.nextInt();
        a[t]=true ;
      }
      String[] str=new String[1000];
      int t=0 ;
      for(int i=0 ; i<10000 ; i++){
        if(a[i]){
          int c=0 ;
          String st="" ;
          st+=Integer.toString(i);
          i++;
          for(; i<10000 ; i++){
            if(a[i]){
              c++;
            }
            else {
              break ;
            }
          }
          if(c>0){
            st+="-" ;
            st+=Integer.toString(i-1);
          }
          str[t++]=st ;
        }
      }
      System.out.print(str[0]);
      for(int i=1 ; i<t ; i++){
        System.out.print(" "+str[i]);
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var a : Sequence(boolean) ; a := Integer.subrange(1,10000)->collect(false) ;
        var i : int ; i := 0 ; while i < 10000 do ( (     a[i+1] := false )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var t : int ; t := sc.getCurrent()->toInteger() ;
     a[t+1] := true )  ;     i := i + 1 ) ; 
    var str : Sequence(String) ; str := Integer.subrange(1,1000)->collect(null) ;
    var t : int ; t := 0 ;
        var i : int ; i := 0 ; while i < 10000 do ( (     if (a[i+1]) then (     var c : int ; c := 0 ;
     var st : String ; st := "" ;
    st := st+(((i) + "")) ; 
    i := i + 1 ; 
      while i < 10000 do ( (     if (a[i+1]) then (     c := c + 1 ) else (     break ) )  ;     i := i + 1 ) ; 
    if (c > 0) then (     st := st+("-") ; 
     st := st+(((i - 1) + "")) ) else skip ; 
     str[t+1] := st  ; t := t + 1 ; 
 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(str[0+1]) ; 
        var i : int ; i := 1 ; while i < t do ( (     OclFile["System.out"].print(" " + str[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n ;
    int i,j ;
    int[] a ;
    for(; ; ){
      n=sc.nextInt();
      if(n==0)break ;
      a=new int[n];
      for(i=0 ; i<n ; i++)a[i]=sc.nextInt();
      i=0 ;
      if(i>=n-1 || a[i]!=a[i+1]-1)out.print(a[i++]);
      else {
        for(j=i+1 ; j<n ; j++)if(j>=n-1 || a[j]!=a[j+1]-1){
          out.print(a[i]+"-"+a[j]);
          i=j+1 ;
          break ;
        }
      }
      for(; i<n ; ){
        if(i>=n-1 || a[i]!=a[i+1]-1)out.print(" "+a[i++]);
        else {
          for(j=i+1 ; j<n ; j++)if(j>=n-1 || a[j]!=a[j+1]-1){
            out.print(" "+a[i]+"-"+a[j]);
            i=j+1 ;
            break ;
          }
        }
      }
      out.println();
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var i : int ;
    var j : int ;
    var a : Sequence(int) ;
      while true do ( (     n := sc.nextInt() ; 
     if (n = 0) then     break else skip ; 
    a := Integer.subrange(1,n)->collect(0) ; 
        i := 0 ; while i < n do (     a[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
    i := 0 ; 
    if (i >= n - 1 or a[i+1] /= a[i + 1+1] - 1) then     out.print(a[i+1]) else (         j := i + 1 ; while j < n do (     if (j >= n - 1 or a[j+1] /= a[j + 1+1] - 1) then (     out.print(a[i+1] + "-" + a[j+1]) ; 
     i := j + 1 ; 
     break ) else skip ;  ;     j := j + 1 ) ) ;  
      while i < n do ( (     if (i >= n - 1 or a[i+1] /= a[i + 1+1] - 1) then     out.print(" " + a[i+1]) ; else (         j := i + 1 ; while j < n do (     if (j >= n - 1 or a[j+1] /= a[j + 1+1] - 1) then (     out.print(" " + a[i+1] + "-" + a[j+1]) ; 
     i := j + 1 ; 
     break ) else skip ;  ;     j := j + 1 ) ) )  ) ; 
    out.println() ; 
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=Integer.parseInt(line);
      if(n==0)break ;
      words=br.readLine().split(" ");
      Deque<Integer>queue=new ArrayDeque<>();
      for(int i=0 ; i<n ; i++){
        int next=parseInt(words[i]);
        if(i==0){
          queue.add(next);
        }
        else if(i==1){
          if(queue.peekLast()+1==next){
            queue.add(-1);
            queue.add(next);
          }
          else {
            queue.add(0);
            queue.add(next);
          }
        }
        else {
          if(queue.peekLast()+1==next){
            int prev=queue.removeLast();
            if(queue.peekLast()==-1){
              queue.add(next);
            }
            else {
              queue.add(prev);
              queue.add(-1);
              queue.add(next);
            }
          }
          else {
            queue.add(0);
            queue.add(next);
          }
        }
      }
      StringBuilder sb=new StringBuilder();
      for(int i : queue){
        if(i==0){
          sb.append(" ");
        }
        else if(i==-1){
          sb.append("-");
        }
        else {
          sb.append(i);
        }
      }
      System.out.println(sb.toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := (line)->toInteger() ;
     if (n = 0) then     break else skip ; 
    words := br.readLine()->split(" ") ; 
    var queue : Sequence(int) ; queue := ArrayDeque<OclAny>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < n do ( (     var next : int ; next := parseInt(words[i+1]) ;
     if (i = 0) then (     queue := queue->including(next) ) else     if (i = 1) then (     if (queue.peekLast() + 1 = next) then (     queue := queue->including(-1) ; 
     queue := queue->including(next) ) else (     queue := queue->including(0) ; 
     queue := queue->including(next) ) ) else (     if (queue.peekLast() + 1 = next) then (     var prev : int ; prev := queue->last() ;
     if (queue.peekLast() = -1) then (     queue := queue->including(next) ) else (     queue := queue->including(prev) ; 
     queue := queue->including(-1) ; 
     queue := queue->including(next) ) ) else (     queue := queue->including(0) ; 
     queue := queue->including(next) ) ) ;  )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    for (i : queue) do ( (     if (i = 0) then (     sb := sb + StringLib.newString(" ") ) else     if (i = -1) then (     sb := sb + StringLib.newString("-") ) else (     sb := sb + StringLib.newString(i) ) ;  )  ) ; 
    OclFile["System.out"].println(sb+"") ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      int a[];
      a=new int[50];
      while(true){
        String str[];
        str=new String[50];
        str=br.readLine().split(" ");
        int n=Integer.parseInt(str[0]);
        if(n==0)break ;
        str=br.readLine().split(" ");
        for(int i=0 ; i<n ; i++)a[i]=Integer.parseInt(str[i]);
        int idx=0,cnt=0,f=0 ;
        for(int i=1 ; i<n ; i++){
          if(a[i-1]==a[i]-1)cnt++;
          else {
            if(f!=0)System.out.print(" ");
            f=1 ;
            if(cnt==0){
              System.out.print(a[i-1]);
              idx++;
            }
            else {
              System.out.print(a[idx]);
              System.out.print("-");
              System.out.print(a[i-1]);
              idx=i ;
            }
            cnt=0 ;
          }
        }
        if(cnt!=0){
          if(f==1)System.out.print(" ");
          System.out.print(a[idx]);
          System.out.print("-");
        }
        if(cnt==0 && f==1)System.out.print(" ");
        System.out.print(a[n-1]);
        System.out.print("\n");
      }
    }
    catch(Exception e){
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var a : Sequence(int) ;
     a := Integer.subrange(1,50)->collect(0) ; 
     while (true) do (     var str : Sequence(String) ;
     str := Integer.subrange(1,50)->collect(null) ; 
    str := br.readLine()->split(" ") ; 
    var n : int ; n := (str[0+1])->toInteger() ;
    if (n = 0) then     break else skip ; 
    str := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (str[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var idx : int ; idx := 0 ;
    var cnt : int ; cnt := 0 ;
    var f : int ; f := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i - 1+1] = a[i+1] - 1) then     cnt := cnt + 1 ; else (     if (f /= 0) then     OclFile["System.out"].print(" ") ; else skip ; 
     f := 1 ; 
     if (cnt = 0) then (     OclFile["System.out"].print(a[i - 1+1]) ; 
     idx := idx + 1 ) else (     OclFile["System.out"].print(a[idx+1]) ; 
     OclFile["System.out"].print("-") ; 
     OclFile["System.out"].print(a[i - 1+1]) ; 
     idx := i ) ;  
     cnt := 0 ) )  ;     i := i + 1 ) ; 
    if (cnt /= 0) then (     if (f = 1) then     OclFile["System.out"].print(" ") ; else skip ; 
     OclFile["System.out"].print(a[idx+1]) ; 
     OclFile["System.out"].print("-") ) else skip ; 
    if (cnt = 0 & f = 1) then     OclFile["System.out"].print(" ") ; else skip ; 
    OclFile["System.out"].print(a[(n)->char2byte() - 1+1]) ; 
    OclFile["System.out"].print("\n") ; 
 ) )   catch (e : ProgramException) do (     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args)throws Exception {
    while(true){
      int N=sc.nextInt();
      if(N==0)break ;
      int[] page=new int[N];
      for(int i=0 ; i<N ; ++i){
        page[i]=sc.nextInt();
      }
      int start=0 ;
      for(int i=1 ; i<N ; ++i){
        if(page[i]==page[i-1]+1){
          continue ;
        }
        if(i==start+1){
          System.out.print(page[start]+" ");
        }
        else {
          System.out.print(page[start]+"-"+page[i-1]+" ");
        }
        start=i ;
      }
      if(start==N-1){
        System.out.println(page[start]);
      }
      else {
        System.out.println(page[start]+"-"+page[N-1]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then     break else skip ; 
    var page : Sequence(int) ; page := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     page[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var start : int ; start := 0 ;
        var i : int ; i := 1 ; while i < N do ( (     if (page[i+1] = page[i - 1+1] + 1) then (     continue ) else skip ; 
     if (i = start + 1) then (     OclFile["System.out"].print(page[start+1] + " ") ) else (     OclFile["System.out"].print(page[start+1] + "-" + page[i - 1+1] + " ") ) ;  
     start := i )  ;     i := i + 1 ) ; 
    if (start = N - 1) then (     OclFile["System.out"].println(page[start+1]) ) else (     OclFile["System.out"].println(page[start+1] + "-" + page[N - 1+1]) ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void find_array(int[] a,int n){
    int x=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]+=x ;
      System.out.print(a[i]+" ");
      x=Math.max(x,a[i]);
    }
  }
  public static void main(String[] args){
    int[] a={
      40,12,62 };
      int n=a.length ;
      find_array(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find_array( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := a[i+1]+(x) ; 
     OclFile["System.out"].print(a[i+1] + " ") ; 
     x := Set{x, a[i+1]}->max() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{40,12,62} ;
     var n : int ; n := a->size() ;
     execute find_array(a, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=1001 ;
  static int prefix[][]=new int[MAX][MAX];
  static int ar[]=new int[MAX];
  static void cal_prefix(int n,int arr[]){
    int i,j ;
    for(i=0 ; i<n ; i++)ar[i+1]=arr[i];
    for(i=1 ; i<=1000 ; i++){
      for(j=0 ; j<=n ; j++)prefix[i][j]=0 ;
      for(j=1 ; j<=n ; j++){
        prefix[i][j]=prefix[i][j-1]+(int)(ar[j]<=i ? 1 : 0);
      }
    }
  }
  static int ksub(int l,int r,int n,int k){
    int lo,hi,mid ;
    lo=1 ;
    hi=1000 ;
    while(lo+1<hi){
      mid=(lo+hi)/2 ;
      if(prefix[mid][r]-prefix[mid][l-1]>=k)hi=mid ;
      else lo=mid+1 ;
    }
    if(prefix[lo][r]-prefix[lo][l-1]>=k)hi=lo ;
    return hi ;
  }
  public static void main(String args[]){
    int arr[]={
      1,4,2,3,5,7,6 };
      int n=arr.length ;
      int k=4 ;
      cal_prefix(n,arr);
      int queries[][]={
        {
          1,n,1 },{
            2,n-2,2 },{
              3,n-1,3 }
            };
            int q=queries.length ;
            for(int i=0 ; i<q ; i++)System.out.println(ksub(queries[i][0],queries[i][1],n,queries[i][2]));
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 1001;
  static   attribute prefix : int := Integer.subrange(1,MAX)->collect(Integer.subrange(1,MAX)->collect(0));
  static   attribute ar : int := Integer.subrange(1,MAX)->collect(0);
  static   operation cal_prefix( n : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := 0 ; while i < n do (     ar[i + 1+1] := arr[i+1] ;  ;     i := i + 1 ) ; 
         i := 1 ; while i <= 1000 do ( (         j := 0 ; while j <= n do (     prefix[i+1][j+1] := 0 ;  ;     j := j + 1 ) ; 
         j := 1 ; while j <= n do ( (     prefix[i+1][j+1] := prefix[i+1][j - 1+1] + (if ar[j+1] <= i then 1 else 0 endif)->oclAsType(int) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation ksub( l : int, r : int, n : int, k : int) : int
  pre: true
  post: true
  activity: (     var lo : int ;
    var hi : int ;
    var mid : int ;
     lo := 1 ; 
    hi := 1000 ; 
    while (lo + 1 < hi) do (     mid := (lo + hi) / 2 ; 
     if (prefix[mid+1][r+1] - prefix[mid+1][l - 1+1] >= k) then     hi := mid ; else     lo := mid + 1 ; ) ; 
    if (prefix[lo+1][r+1] - prefix[lo+1][l - 1+1] >= k) then     hi := lo ; else skip ; 
    return hi 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,4,2,3,5,7,6} ;
     var n : int ; n := arr->size() ;
    var k : int ; k := 4 ;
    execute cal_prefix(n, arr) ; 
    var queries : Sequence(Sequence(int)) ; queries := Sequence{Sequence{1,n,1},Sequence{2,n - 2,2},Sequence{3,n - 1,3}} ;
    var q : int ; q := queries->size() ;
        var i : int ; i := 0 ; while i < q do (     OclFile["System.out"].println(ksub(queries[i+1][0+1], queries[i+1][1+1], n, queries[i+1][2+1])) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void find(int n){
    int b=n ;
    int a=b*(n-1);
    if(a*b>n && a/b<n){
      System.out.print("a="+a+",b="+b);
    }
    else System.out.println(-1);
  }
  public static void main(String[] args){
    int n=10 ;
    find(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find( n : int) : void
  pre: true
  post: true
  activity: (     var b : int ; b := n ;
     var a : int ; a := b * (n - 1) ;
     if (a * b > n & a / b < n) then (     OclFile["System.out"].print("a=" + a + ",b=" + b) ) else     OclFile["System.out"].println(-1) ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     execute find(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
class Main {
  public static Scanner sc=new Scanner(in);
  public static Random rand=new Random();
  public void run(){
    TCase : while(true){
      int n=sc.nextInt(),q=sc.nextInt();
      if(n==0)return ;
      int[][] ds=new int[n][];
      for(int i=0 ; i<n ; i++){
        int k=sc.nextInt();
        ds[i]=new int[k];
        for(int j=0 ; j<k ; j++)ds[i][j]=sc.nextInt();
      }
      int max=0,ind=-1 ;
      for(int d=1 ; d<=100 ; d++){
        int num=0 ;
        for(int j=0 ; j<n ; j++){
          if(Arrays.binarySearch(ds[j],d)>=0)num++;
        }
        if(num>max && num>=q){
          max=num ;
          ind=d ;
        }
      }
      if(ind>=0)ln(ind);
      else ln(0);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  public int[] nextIntArray(int n){
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=sc.nextInt();
    }
    return res ;
  }
  public static void pr(Object o){
    out.print(o);
  }
  public static void ln(Object o){
    out.println(o);
  }
  public static void ln(){
    out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(in);
  static   attribute rand : OclRandom := OclRandom.newOclRandom();
   operation run() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var ds : Sequence(Sequence(int)) ; ds := Integer.subrange(1,n)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < n do ( (     var k : int ; k := sc.getCurrent()->toInteger() ;
     ds[i+1] := Integer.subrange(1,k)->collect(0) ; 
         var j : int ; j := 0 ; while j < k do (     ds[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var ind : int ; ind := -1 ;
        var d : int ; d := 1 ; while d <= 100 do ( (     var num : int ; num := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if ((ds[j+1]->indexOf(d) - 1) >= 0) then     num := num + 1 ; else skip )  ;     j := j + 1 ) ; 
     if (num > max & num >= q) then (     max := num ; 
     ind := d ) else skip )  ;     d := d + 1 ) ; 
    if (ind >= 0) then     execute ln(ind) else     execute ln(0) ; ;  
 ) ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return res );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     out.println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Fibonacci {
  public static int min(int x,int y){
    return(x<=y)? x : y ;
  }
  public static int fibMonaccianSearch(int arr[],int x,int n){
    int fibMMm2=0 ;
    int fibMMm1=1 ;
    int fibM=fibMMm2+fibMMm1 ;
    while(fibM<n){
      fibMMm2=fibMMm1 ;
      fibMMm1=fibM ;
      fibM=fibMMm2+fibMMm1 ;
    }
    int offset=-1 ;
    while(fibM>1){
      int i=min(offset+fibMMm2,n-1);
      if(arr[i]<x){
        fibM=fibMMm1 ;
        fibMMm1=fibMMm2 ;
        fibMMm2=fibM-fibMMm1 ;
        offset=i ;
      }
      else if(arr[i]>x){
        fibM=fibMMm2 ;
        fibMMm1=fibMMm1-fibMMm2 ;
        fibMMm2=fibM-fibMMm1 ;
      }
      else return i ;
    }
    if(fibMMm1==1 && arr[offset+1]==x)return offset+1 ;
    return-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      10,22,35,40,45,50,80,82,85,90,100 };
      int n=11 ;
      int x=85 ;
      System.out.print("Found at index: "+fibMonaccianSearch(arr,x,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Fibonacci {
  static   operation min( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return if (x <= y) then x else y endif );
  static   operation fibMonaccianSearch( arr : Sequence(int), x : int, n : int) : int
  pre: true
  post: true
  activity: (     var fibMMm2 : int ; fibMMm2 := 0 ;
     var fibMMm1 : int ; fibMMm1 := 1 ;
    var fibM : int ; fibM := fibMMm2 + fibMMm1 ;
    while (fibM < n) do (     fibMMm2 := fibMMm1 ; 
     fibMMm1 := fibM ; 
     fibM := fibMMm2 + fibMMm1 ) ; 
    var offset : int ; offset := -1 ;
    while (fibM > 1) do (     var i : int ; i := min(offset + fibMMm2, n - 1) ;
     if (arr[i+1] < x) then (     fibM := fibMMm1 ; 
     fibMMm1 := fibMMm2 ; 
     fibMMm2 := fibM - fibMMm1 ; 
     offset := i ) else     if (arr[i+1] > x) then (     fibM := fibMMm2 ; 
     fibMMm1 := fibMMm1 - fibMMm2 ; 
     fibMMm2 := fibM - fibMMm1 ) else     return i ;  ) ; 
    if (fibMMm1 = 1 & arr[offset + 1+1] = x) then     return offset + 1 else skip ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,22,35,40,45,50,80,82,85,90,100} ;
     var n : int ; n := 11 ;
     var x : int ; x := 85 ;
     OclFile["System.out"].print("Found at index: " + fibMonaccianSearch(arr, x, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class B175 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    Map<String,Integer>map=new HashMap<>();
    for(int n=0 ; n<N ; n++){
      String name=in.next();
      int score=in.nextInt();
      int max=map.getOrDefault(name,-1);
      if(max<score){
        map.put(name,score);
      }
    }
    int total=map.size();
    System.out.println(total);
    for(Map.Entry<String,Integer>entry : map.entrySet()){
      String name=entry.getKey();
      int score=entry.getValue();
      int better=0 ;
      for(int otherScore : map.values()){
        if(otherScore>score){
          better++;
        }
      }
      String category ;
      if(2*better>total){
        category="noob" ;
      }
      else if(5*better>total){
        category="random" ;
      }
      else if(10*better>total){
        category="average" ;
      }
      else if(100*better>total){
        category="hardcore" ;
      }
      else {
        category="pro" ;
      }
      System.out.println(name+" "+category);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B175 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var map : Map(String,int) ; map := Map{} ;
        var n : int ; n := 0 ; while n < N do ( (     var name : String ; name := in.getCurrent() ;
     var score : int ; score := in.getCurrent()->toInteger() ;
     var max : int ; max := (if map->keys()->contains(name) then map->at(name) else -1 endif) ;
     if (max < score) then (     map := map->union(Map{name |-> score}) ) else skip )  ;     n := n + 1 ) ; 
    var total : int ; total := map.size() ;
    OclFile["System.out"].println(total) ; 
    for (entry : map->asSet()) do ( (     var name : String ; name := entry.getKey() ;
     var score : int ; score := entry.getValue() ;
    var better : int ; better := 0 ;
    for (otherScore : map->values()) do ( (     if (otherScore > score) then (     better := better + 1 ) else skip )  ) ; 
    var category : String ;
    if (2 * better > total) then (     category := "noob" ) else     if (5 * better > total) then (     category := "random" ) else     if (10 * better > total) then (     category := "average" ) else     if (100 * better > total) then (     category := "hardcore" ) else (     category := "pro" ) ;  ;  ;  ;  
    OclFile["System.out"].println(name + " " + category) ; 
 )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class298 {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int n,s ;
    n=sc.nextInt();
    s=sc.nextInt();
    int a[]=new int[n+1];
    int b[]=new int[n+1];
    int f1=0,f2=0,f3=0,i,ind=0 ;
    for(i=1 ; i<=n ; i++){
      a[i]=sc.nextInt();
      if(i==s && a[i]==1){
        f1=1 ;
      }
    }
    for(i=1 ; i<=n ; i++){
      b[i]=sc.nextInt();
      if(i==s && b[i]==1){
        f3=1 ;
      }
      if(a[i]==b[i] && a[i]==1){
        f2=1 ;
        ind=i ;
      }
    }
    if(a[1]==0){
      System.out.println("NO");
    }
    else {
      if(f1==1){
        System.out.println("YES");
      }
      else {
        if(f2==0 || ind<s){
          System.out.println("NO");
        }
        else {
          if(f3==1){
            System.out.println("YES");
          }
          else {
            System.out.println("NO");
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class298 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var s : int ;
    n := sc.getCurrent()->toInteger() ; 
    s := sc.getCurrent()->toInteger() ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n + 1)->collect(0) ;
    var f1 : int ; f1 := 0 ;
    var f2 : int ; f2 := 0 ;
    var f3 : int ; f3 := 0 ;
    var i : int ;
    var ind : int ; ind := 0 ;
        i := 1 ; while i <= n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (i = s & a[i+1] = 1) then (     f1 := 1 ) else skip )  ;     i := i + 1 ) ; 
        i := 1 ; while i <= n do ( (     b[i+1] := sc.getCurrent()->toInteger() ; 
     if (i = s & b[i+1] = 1) then (     f3 := 1 ) else skip ; 
     if (a[i+1] = b[i+1] & a[i+1] = 1) then (     f2 := 1 ; 
     ind := i ) else skip )  ;     i := i + 1 ) ; 
    if (a[1+1] = 0) then (     OclFile["System.out"].println("NO") ) else (     if (f1 = 1) then (     OclFile["System.out"].println("YES") ) else (     if (f2 = 0 or ind < s) then (     OclFile["System.out"].println("NO") ) else (     if (f3 = 1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void maxPerimeter(int arr[],int n){
    int maxi=0 ;
    for(int i=0 ; i<n-2 ; i++){
      for(int j=i+1 ; j<n-1 ; j++){
        for(int k=j+1 ; k<n ; k++){
          int a=arr[i];
          int b=arr[j];
          int c=arr[k];
          if(a<b+c && b<c+a && c<a+b){
            maxi=Math.max(maxi,a+b+c);
          }
        }
      }
    }
    if(maxi>0)System.out.println("Maximum Perimeter is: "+maxi);
    else System.out.println("Triangle formation "+"is not possible.");
  }
  public static void main(String[] args){
    int arr1[]={
      6,1,6,5,8,4 };
      maxPerimeter(arr1,6);
      int arr2[]={
        2,20,7,55,1,33,12,4 };
        maxPerimeter(arr2,8);
        int arr3[]={
          33,6,20,1,8,12,5,55,4,9 };
          maxPerimeter(arr3,10);
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxPerimeter( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var maxi : int ; maxi := 0 ;
         var i : int ; i := 0 ; while i < n - 2 do ( (         var j : int ; j := i + 1 ; while j < n - 1 do ( (         var k : int ; k := j + 1 ; while k < n do ( (     var a : int ; a := arr[i+1] ;
     var b : int ; b := arr[j+1] ;
     var c : int ; c := arr[k+1] ;
     if (a < b + c & b < c + a & c < a + b) then (     maxi := Set{maxi, a + b + c}->max() ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (maxi > 0) then     OclFile["System.out"].println("Maximum Perimeter is: " + maxi) ; else     OclFile["System.out"].println("Triangle formation " + "is not possible.") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{6,1,6,5,8,4} ;
     execute maxPerimeter(arr1, 6) ; 
    var arr2 : Sequence(int) ; arr2 := Sequence{2,20,7,55,1,33,12,4} ;
    execute maxPerimeter(arr2, 8) ; 
    var arr3 : Sequence(int) ; arr3 := Sequence{33,6,20,1,8,12,5,55,4,9} ;
    execute maxPerimeter(arr3, 10) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    int[] a=new int[n];
    int ct=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt()% 2 ;
      if(a[i]==0){
        ct++;
      }
    }
    if(ct==0 || ct==n){
      out.println(0);
    }
    else if((n-ct)% 2==0){
      out.println(n-2);
    }
    else {
      out.println(n-1);
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var ct : int ; ct := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() mod 2 ; 
     if (a[i+1] = 0) then (     ct := ct + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (ct = 0 or ct = n) then (     skip ) else     if ((n - ct) mod 2 = 0) then (     skip ) else (     skip ) ;  ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
class GFG {
  static int findNum(int N,int K){
    int rem=N % K ;
    if(rem==0)return N ;
    else return N-rem ;
  }
  public static void main(String args[]){
    int N=45,K=6 ;
    System.out.print("Largest number smaller "+"than or equal to "+N+"\nthat is divisible by "+K+" is "+findNum(N,K));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNum( N : int, K : int) : int
  pre: true
  post: true
  activity: (     var rem : int ; rem := N mod K ;
     if (rem = 0) then     return N else     return N - rem );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 45 ;
    var K : int ; K := 6 ;
     OclFile["System.out"].print("Largest number smaller " + "than or equal to " + N + "\nthat is divisible by " + K + " is " + findNum(N, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math ;
class GfG {
  static void powerfulIntegers(int x,int y,int bound){
    Set<Integer>s=new HashSet<>();
    ArrayList<Integer>powersOfY=new ArrayList<>();
    int i ;
    powersOfY.add(1);
    for(i=y ; i<bound ; i=i*y)powersOfY.add(i);
    i=0 ;
    while(true){
      int xPowI=(int)Math.pow((double)x,(double)i);
      if(xPowI>=bound)break ;
      for(int j=0 ; j<powersOfY.size(); ++j){
        int num=xPowI+powersOfY.get(j);
        if(num<=bound)s.add(num);
        else break ;
      }
      i++;
    }
    Iterator itr=s.iterator();
    while(itr.hasNext()){
      System.out.print(itr.next()+" ");
    }
  }
  public static void main(String[] args){
    int x=2,y=3,bound=10 ;
    powerfulIntegers(x,y,bound);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation powerfulIntegers( x : int, y : int, bound : int) : void
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
     var powersOfY : Sequence(int) ; powersOfY := Sequence{} ;
    var i : int ;
    powersOfY := powersOfY->including(1) ; 
        i := y ; while i < bound do (     powersOfY := powersOfY->including(i) ;  ;     i := i * y ) ; 
    i := 0 ; 
    while (true) do (     var xPowI : int ; xPowI := x->oclAsType(double)->pow(i->oclAsType(double))->oclAsType(int) ;
     if (xPowI >= bound) then     break else skip ; 
         var j : int ; j := 0 ; while j < powersOfY->size() do ( (     var num : int ; num := xPowI + powersOfY->at(j+1) ;
     if (num <= bound) then     s := s->including(num) ; else     break )  ;     j := j + 1 ) ; 
     i := i + 1 ) ; 
    var itr : OclIterator ; itr := s->iterator() ;
    while (itr.hasNext()) do (     OclFile["System.out"].print(itr.next() + " ") ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 2 ;
    var y : int ; y := 3 ;
    var bound : int ; bound := 10 ;
     execute powerfulIntegers(x, y, bound) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static long gcd(long a,long b){
    if(a==0 || b==0)return 0 ;
    if(a==b)return a ;
    if(a>b)return gcd(a-b,b);
    return gcd(a,b-a);
  }
  public static long getRounding(long n,long k){
    long rounding=(long)Math.pow(10,k);
    long result=gcd(rounding,n);
    return((rounding*n)/result);
  }
  public static void main(String[] args){
    long n=375,k=4 ;
    System.out.println(getRounding(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0 or b = 0) then     return 0 else skip ; 
     if (a = b) then     return a else skip ; 
     if (a > b) then     return gcd(a - b, b) else skip ; 
     return gcd(a, b - a) );
  static   operation getRounding( n : long, k : long) : long
  pre: true
  post: true
  activity: (     var rounding : long ; rounding := 10->pow(k)->oclAsType(long) ;
     var result : long ; result := gcd(rounding, n) ;
     return ((rounding * n) / result) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 375 ;
    var k : long ; k := 4 ;
     OclFile["System.out"].println(getRounding(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    double r=scanner.nextDouble();
    double area=Math.PI*r*r ;
    double around=2*Math.PI*r ;
    System.out.println(""+String.format("%f",area)+" "+around);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : double ; r := scanner.getCurrent()->toReal() ;
    var area : double ; area := 3.141592653589793 * r * r ;
    var around : double ; around := 2 * 3.141592653589793 * r ;
    OclFile["System.out"].println("" + StringLib.format("%f",Sequence{area}) + " " + around) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.text.DecimalFormat ;
class Main {
  private static final BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  private static final DecimalFormat df=new DecimalFormat("0.########");
  public static void main(String[] Args)throws IOException {
    double r=Double.parseDouble(br.readLine());
    System.out.println(df.format(Math.PI*r*r)+" "+df.format(2.0*Math.PI*r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static    attribute df : DecimalFormat := DecimalFormat.newDecimalFormat("0.########");
  static   operation main( Args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : double ; r := (br.readLine())->toReal() ;
     OclFile["System.out"].println(df.format(3.141592653589793 * r * r) + " " + df.format(2.0 * 3.141592653589793 * r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class OddOccurance {
  int getOddOccurrence(int ar[],int ar_size){
    int i ;
    int res=0 ;
    for(i=0 ; i<ar_size ; i++){
      res=res ^ ar[i];
    }
    return res ;
  }
  public static void main(String[] args){
    OddOccurance occur=new OddOccurance();
    int ar[]=new int[] {
      2,3,5,4,5,2,4,3,5,2,4,4,2 };
      int n=ar.length ;
      System.out.println(occur.getOddOccurrence(ar,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class OddOccurance {
   operation getOddOccurrence( ar : Sequence(int), ar_size : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
     var res : int ; res := 0 ;
         i := 0 ; while i < ar_size do ( (     res := MathLib.bitwiseXor(res,ar[i+1]) )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var occur : OddOccurance ; occur := OddOccurance.newOddOccurance() ;
     var ar : Sequence(int) ; ar := Sequence{2,3,5,4,5,2,4,3,5,2,4,4,2} ;
     var n : int ; n := ar->size() ;
     OclFile["System.out"].println(occur.getOddOccurrence(ar, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.*;
import java.awt.geom.*;
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double r=sc.nextDouble();
    System.out.printf("%.6f %.6f",r*r*Math.PI,2*Math.PI*r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : double ; r := sc.getCurrent()->toReal() ;
     OclFile["System.out"].printf("%.6f %.6f", r * r * 3.141592653589793, 2 * 3.141592653589793 * r) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    double ce,cf ;
    Scanner sc=new Scanner(System.in);
    String a=sc.next();
    double r=Double.parseDouble(a);
    ce=Math.pow(r,2)*Math.PI ;
    cf=2*r*Math.PI ;
    System.out.printf("%f %f",ce,cf);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ce : double ;
    var cf : double ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var a : String ; a := sc.getCurrent() ;
    var r : double ; r := (a)->toReal() ;
    ce := r->pow(2) * 3.141592653589793 ; 
    cf := 2 * r * 3.141592653589793 ; 
    OclFile["System.out"].printf("%f %f", ce, cf) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.text.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    double r=in.nextDouble();
    double s=r*r*Math.PI ;
    double l=r*2*Math.PI ;
    DecimalFormat fm=new DecimalFormat("#.######");
    System.out.println(fm.format(s)+" "+fm.format(l));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : double ; r := in.getCurrent()->toReal() ;
    var s : double ; s := r * r * 3.141592653589793 ;
    var l : double ; l := r * 2 * 3.141592653589793 ;
    var fm : DecimalFormat ; fm := DecimalFormat.newDecimalFormat("#.######") ;
    OclFile["System.out"].println(fm.format(s) + " " + fm.format(l)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long ans=1L<<60 ;
    for(long i=1 ; i*i<=n ; i++){
      if(n % i==0){
        int f=Math.max((""+i).length(),(""+(n/i)).length());
        ans=Math.min(ans,f);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var ans : long ; ans := (1L*(2->pow(60)))->oclAsType(long) ;
        var i : long ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     var f : int ; f := Set{("" + i)->size(), ("" + (n / i))->size()}->max() ;
     ans := Set{ans, f}->min() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String arg[]){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      String str=in.nextLine();
      if(str.equals("END OF INPUT"))return ;
      char ch[]=str.toCharArray();
      int c=0 ;
      for(int i=0 ; i<ch.length ; i++){
        if(ch[i]!=' ')c++;
        if(ch[i]==' ' || i==ch.length-1){
          if(i+1<ch.length && ch[i+1]==' '){
            System.out.print(c);
            while(i+1<ch.length && ch[i+1]==' '){
              System.out.print(0);
              i++;
            }
            c=0 ;
            continue ;
          }
          System.out.print(c);
          c=0 ;
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var str : String ; str := in.nextLine() ;
     if (str = "END OF INPUT") then     return else skip ; 
    var ch : Sequence(String) ; ch := str->characters() ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < ch->size() do ( (     if (ch[i+1] /= ' ') then     c := c + 1 ; else skip ; 
     if (ch[i+1] = ' ' or i = ch->size() - 1) then (     if (i + 1 < ch->size() & ch[i + 1+1] = ' ') then (     OclFile["System.out"].print(c) ; 
     while (i + 1 < ch->size() & ch[i + 1+1] = ' ') do (     OclFile["System.out"].print(0) ; 
     i := i + 1 ) ; 
     c := 0 ; 
     continue ) else skip ; 
     OclFile["System.out"].print(c) ; 
     c := 0 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    Main myMain=new Main();
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    String str ;
    try {
      while(!((str=reader.readLine()).equals("END OF INPUT"))){
        String[] st=str.split(" ",0);
        System.out.println(myMain.Length(st));
      }
      reader.close();
    }
    catch(IOException e){
    }
  }
  public String Length(String[] str){
    String length="" ;
    for(int i=0 ; i<str.length ; i++){
      length+=String.valueOf(str[i] .length());
    }
    return length ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var myMain : Main ; myMain := Main.newMain() ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ;
     try (     while (not(((str) = "END OF INPUT"))) do (     var st : Sequence(String) ; st := str->split(" ") ;
     OclFile["System.out"].println(myMain.Length(st)) ) ; 
     skip )   catch (e : IOException) do skip
 );
   operation Length( str : Sequence(String)) : String
  pre: true
  post: true
  activity: (     var length : String ; length := "" ;
         var i : int ; i := 0 ; while i < str->size() do ( (     length := length+(((str[i+1]->size()) + "")) )  ;     i := i + 1 ) ; 
     return length );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static String[] input ;
  public static void main(String[] args){
    while(read()){
      solve();
    }
  }
  static boolean read(){
    input=sc.nextLine().split(" ");
    if(input.length>=3){
      if(input[0] .equals("END")&& input[1] .equals("OF")&& input[2] .equals("INPUT"))return false ;
    }
    return true ;
  }
  static void solve(){
    for(int i=0 ; i<input.length ; i++){
      System.out.print(input[i] .length());
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute input : Sequence(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (read()) do (     execute solve() ) );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     input := sc.nextLine()->split(" ") ; 
     if (input->size() >= 3) then (     if (input[0+1] = "END" & input[1+1] = "OF" & input[2+1] = "INPUT") then     return false else skip ) else skip ; 
     return true );
  static   operation solve() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < input->size() do ( (     OclFile["System.out"].print(input[i+1]->size()) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(is);
    String text ;
    String endText="END OF INPUT" ;
    while(!(text=br.readLine()).equals(endText)){
      String[] word=text.split(" ",0);
      for(int i=0 ; i<word.length ; i++){
        System.out.print(word[i] .length());
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(is) ;
    var text : String ;
    var endText : String ; endText := "END OF INPUT" ;
    while (not((text) = endText)) do (     var word : Sequence(String) ; word := text->split(" ") ;
         var i : int ; i := 0 ; while i < word->size() do ( (     OclFile["System.out"].print(word[i+1]->size()) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    while(true){
      String s=sc.nextLine();
      if(s.equals("END OF INPUT")){
        break ;
      }
      for(String x : s.split(" ")){
        sb.append(x.length());
      }
      sb.append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
     while (true) do (     var s : String ; s := sc.nextLine() ;
     if (s = "END OF INPUT") then (     break ) else skip ; 
     for (x : s->split(" ")) do ( (     sb := sb + StringLib.newString(x->size()) )  ) ; 
     sb := sb + StringLib.newString("\n") ) ; 
     OclFile["System.out"].print(sb) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int a=in.nextInt()-1 ;
    int[] x=new int[n];
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      x[i]=in.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      if(x[i]==1){
        if(i-a==0){
          count++;
        }
        else {
          if(a-Math.abs(a-i)<0){
            count++;
          }
          else if(a+Math.abs(a-i)>=n){
            count++;
          }
          else if(x[a-Math.abs(a-i)]==1 && x[a+Math.abs(a-i)]==1){
            count++;
          }
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() - 1 ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (x[i+1] = 1) then (     if (i - a = 0) then (     count := count + 1 ) else (     if (a - if a - i < 0 then -(a - i) else a - i endif < 0) then (     count := count + 1 ) else     if (a + if a - i < 0 then -(a - i) else a - i endif >= n) then (     count := count + 1 ) else     if (x[a - if a - i < 0 then -(a - i) else a - i endif+1] = 1 & x[a + if a - i < 0 then -(a - i) else a - i endif+1] = 1) then (     count := count + 1 ) else skip ; ;  ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    TreeMap<String,Integer>map=new TreeMap<>();
    int q=Integer.parseInt(in.next());
    for(int i=0 ; i<q ; i++){
      int odr=Integer.parseInt(in.next());
      switch(odr){
        case 0 : String key0=in.next();
        int x0=Integer.parseInt(in.next());
        map.put(key0,x0);
        break ;
        case 1 : String key1=in.next();
        Integer num1=map.get(key1);
        out.println((num1!=null)? num1 : 0);
        break ;
        case 2 : String key2=in.next();
        map.remove(key2);
        break ;
      }
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var map : Map(String,int) ; map := Map{} ;
    var q : int ; q := (in.getCurrent())->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var odr : int ; odr := (in.getCurrent())->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (odr) ; 
       if _switchval = 0 then
     var key0 : String ; key0 := in.getCurrent() ;
    var x0 : int ; x0 := (in.getCurrent())->toInteger() ;
    map := map->union(Map{key0 |-> x0}) ; 
    break 
   else skip ;
       if _switchval = 1 then
     var key1 : String ; key1 := in.getCurrent() ;
    var num1 : int ; num1 := map->at(key1) ;
    skip ; 
    break 
   else skip ;
       if _switchval = 2 then
     var key2 : String ; key2 := in.getCurrent() ;
    map := map->antirestrict(Set{key2}) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int c=sc.nextInt();
    int start=sc.nextInt();
    int[] arr=new int[c];
    int i=0 ;
    while(i<c){
      arr[i]=sc.nextInt();
      i++;
    }
    System.out.println(numCriminals(arr,start));
  }
  public static int numCriminals(int[] arr,int start){
    int res=0 ;
    if(arr[start-1]==1)res++;
    int l=start-2,r=start ;
    while(l>=0 || r<arr.length){
      if(l<0)res+=arr[r];
      else if(r>=arr.length)res+=arr[l];
      else if(arr[l]==1 && arr[r]==1)res+=2 ;
      l--;
      r++;
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
    var start : int ; start := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,c)->collect(0) ;
    var i : int ; i := 0 ;
    while (i < c) do (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println(numCriminals(arr, start)) ; 
 );
  static   operation numCriminals( arr : Sequence(int), start : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     if (arr[start - 1+1] = 1) then     res := res + 1 ; else skip ; 
    var l : int ; l := start - 2 ;
    var r : int ; r := start ;
    while (l >= 0 or r < arr->size()) do (     if (l < 0) then     res := res+(arr[r+1]) else     if (r >= arr->size()) then     res := res+(arr[l+1]) else     if (arr[l+1] = 1 & arr[r+1] = 1) then     res := res+(2) ; else skip ; ;  ;  
     l := l - 1 ; 
     r := r + 1 ) ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.IOException ;
public class BearFindingCriminals {
  public static void main(String args[])throws IOException {
    try {
      Scanner in=new Scanner(System.in);
      int n=in.nextInt();
      int a=in.nextInt();
      a=a-1 ;
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=in.nextInt();
      }
      int ans=arr[a]==1 ? 1 : 0 ;
      int left=a-1 ;
      int right=a+1 ;
      while(left>=0 && right<n){
        if(arr[left]==arr[right] && arr[left]==1){
          ans+=2 ;
        }
        left--;
        right++;
      }
      while(left>=0){
        ans+=arr[left]==1 ? 1 : 0 ;
        left--;
      }
      while(right<n){
        ans+=arr[right]==1 ? 1 : 0 ;
        right++;
      }
      System.out.println(ans);
    }
    catch(Exception e){
      e.printStackTrace();
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BearFindingCriminals {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    a := a - 1 ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := if arr[a+1] = 1 then 1 else 0 endif ;
    var left : int ; left := a - 1 ;
    var right : int ; right := a + 1 ;
    while (left >= 0 & right < n) do (     if (arr[left+1] = arr[right+1] & arr[left+1] = 1) then (     ans := ans+(2) ) else skip ; 
     left := left - 1 ; 
     right := right + 1 ) ; 
    while (left >= 0) do (     ans := ans+(if arr[left+1] = 1 then 1 else 0 endif) ; 
     left := left - 1 ) ; 
    while (right < n) do (     ans := ans+(if arr[right+1] = 1 then 1 else 0 endif) ; 
     right := right + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int index=sc.nextInt();
    int arr[]=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      arr[i]=sc.nextInt();
    }
    int ans=0 ;
    if(arr[index]==1){
      ans++;
    }
    for(int i=1 ; i<n ; i++){
      if((index-i)>=1 &&(index+i)<=n){
        if(arr[index-i]==1 && arr[index+i]==1){
          ans+=2 ;
        }
        else {
          continue ;
        }
      }
      else if((index-i)>=1 &&(index+i)>n){
        if(arr[index-i]==1){
          ans++;
        }
        else {
          continue ;
        }
      }
      else if((index-i)<1 &&(index+i)<=n){
        if(arr[index+i]==1){
          ans++;
        }
        else {
          continue ;
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var index : int ; index := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    if (arr[index+1] = 1) then (     ans := ans + 1 ) else skip ; 
        var i : int ; i := 1 ; while i < n do ( (     if ((index - i) >= 1 & (index + i) <= n) then (     if (arr[index - i+1] = 1 & arr[index + i+1] = 1) then (     ans := ans+(2) ) else (     continue ) ) else     if ((index - i) >= 1 & (index + i) > n) then (     if (arr[index - i+1] = 1) then (     ans := ans + 1 ) else (     continue ) ) else     if ((index - i) < 1 & (index + i) <= n) then (     if (arr[index + i+1] = 1) then (     ans := ans + 1 ) else (     continue ) ) else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int INF=99999 ;
  static int size=10 ;
  static int getSetBitsFromOneToN(int N){
    int two=2,ans=0 ;
    int n=N ;
    while(n!=0){
      ans+=(N/two)*(two>>1);
      if((N &(two-1))>(two>>1)-1)ans+=(N &(two-1))-(two>>1)+1 ;
      two<<=1 ;
      n>>=1 ;
    }
    return ans ;
  }
  static int findMinimum(int x){
    int low=0,high=100000 ;
    int ans=high ;
    while(low<=high){
      int mid=(low+high)>>1 ;
      if(getSetBitsFromOneToN(mid)>=x){
        ans=Math.min(ans,mid);
        high=mid-1 ;
      }
      else low=mid+1 ;
    }
    return ans ;
  }
  public static void main(String args[]){
    int x=20 ;
    System.out.println(findMinimum(x));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   attribute INF : int := 99999;
  static   attribute size : int := 10;
  static   operation getSetBitsFromOneToN( N : int) : int
  pre: true
  post: true
  activity: (     var two : int ; two := 2 ;
    var ans : int ; ans := 0 ;
     var n : int ; n := N ;
     while (n /= 0) do (     ans := ans+((N / two) * ((two/(2->pow(1)))->oclAsType(long))) ; 
     if ((N & (two - 1)) > ((two/(2->pow(1)))->oclAsType(long)) - 1) then     ans := ans+((MathLib.bitwiseAnd(N,(two - 1))) - ((two/(2->pow(1)))->oclAsType(long)) + 1) ; else skip ; 
     two := two*(2->pow(1)) ; 
     n := n/(2->pow(1)) ) ; 
     return ans );
  static   operation findMinimum( x : int) : int
  pre: true
  post: true
  activity: (     var low : int ; low := 0 ;
    var high : int ; high := 100000 ;
     var ans : int ; ans := high ;
     while (low <= high) do (     var mid : int ; mid := ((low + high)/(2->pow(1)))->oclAsType(long) ;
     if (getSetBitsFromOneToN(mid) >= x) then (     ans := Set{ans, mid}->min() ; 
     high := mid - 1 ) else     low := mid + 1 ; ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 20 ;
     OclFile["System.out"].println(findMinimum(x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
class Main {
  static ArrayList<Integer>one ;
  static ArrayList<Integer>two ;
  static ArrayList<Integer>three ;
  static ArrayList<Integer>four ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long ans=n ;
    for(long i=1 ; i*i<=n ; i++){
      if(n % i==0){
        long mm=Math.max(i,n/i);
        long keta=String.valueOf(mm).length();
        ans=Math.min(ans,keta);
      }
    }
    System.out.println(ans);
  }
}
class Pair implements Comparable {
  Character from ;
  int end ;
  @ Override public int compareTo(Object other){
    Pair otherpair=(Pair)other ;
    return end-otherpair.end ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute one : Sequence(int);
  static   attribute two : Sequence(int);
  static   attribute three : Sequence(int);
  static   attribute four : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var ans : long ; ans := n ;
        var i : long ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     var mm : long ; mm := Set{i, n / i}->max() ;
     var keta : long ; keta := ((mm) + "")->size() ;
     ans := Set{ans, keta}->min() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}
class Pair implements OclAny {
   attribute from : String;
   attribute end : int;
      operation compareTo( other : OclAny) : int
  pre: true
  post: true
  activity: (     var otherpair : Map ; otherpair := other->oclAsType(Map) ;
     return end - otherpair.end );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
import java.io.*;
class GFG {
  static double calculateSide(double n,double r){
    double theta,theta_in_radians ;
    theta=360/n ;
    theta_in_radians=theta*3.14/180 ;
    return 2*r*Math.sin(theta_in_radians/2);
  }
  public static void main(String[] args){
    double n=3 ;
    double r=5 ;
    System.out.println(calculateSide(n,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculateSide( n : double, r : double) : double
  pre: true
  post: true
  activity: (     var theta : double ;
    var theta_in_radians : double ;
     theta := 360 / n ; 
     theta_in_radians := theta * 3.14 / 180 ; 
     return 2 * r * (theta_in_radians / 2)->sin() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 3 ;
     var r : double ; r := 5 ;
     OclFile["System.out"].println(calculateSide(n, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
class CP {
  public static void main(String[] args){
    int[] A={
      11,15,7,19 };
      int N=A.length ;
      HashSet<Integer>set=new HashSet<>();
      int i,j,res ;
      for(i=0 ; i<N ; ++i)for(j=i,res=Integer.MAX_VALUE ; j<N ; ++j){
        res &=A[j];
        set.add(res);
      }
      System.out.println(set);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class CP {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{11,15,7,19} ;
     var N : int ; N := A->size() ;
    var set : Set(int) ; set := Set{} ;
    var i : int ;
    var j : int ;
    var res : int ;
        i := 0 ; while i < N do (         j := i ;     res := 2147483647 ; while j < N do ( (     res := MathLib.bitwiseAnd(res, A[j+1]) ; 
     set := set->including(res) )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(set) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class T7A {
  public static void main(String[] args){
    way2();
  }
  public static void way1(){
    Scanner in=new Scanner(System.in);
    StringBuilder board=new StringBuilder();
    for(int i=0 ; i<8 ; i++){
      String line=in.nextLine();
      board.append(line);
    }
    int blacks=(int)board.chars().filter(ch->ch=='B').count();
    System.out.println(blacks);
    System.out.println((int)(blacks/8));
  }
  public static void way2(){
    Scanner in=new Scanner(System.in);
    int rows[]=new int[8];
    int columns[]=new int[8];
    for(int i=0 ; i<8 ; i++){
      String line=in.nextLine();
      if(line.equals("BBBBBBBB")){
        rows[i]=1 ;
      }
      else {
        for(int j=0 ; j<8 ; j++){
          if(line.charAt(j)=='B'){
            columns[j]=1 ;
          }
        }
      }
    }
    int size=0 ;
    for(int i=0 ; i<8 ; i++){
      size+=columns[i];
      size+=rows[i];
    }
    System.out.println(size);
  }
}
------------------------------------------------------------
OCL File:
---------
 class T7A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute way2() );
  static   operation way1() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var board : String ; board := StringLib.newString() ;
        var i : int ; i := 0 ; while i < 8 do ( (     var line : String ; line := in.nextLine() ;
     board := board + StringLib.newString(line) )  ;     i := i + 1 ) ; 
    var blacks : int ; blacks := board.chars()->select( _x1 | (lambda ch : OclAny in ch = 'B')->apply(_x1) )->size()->oclAsType(int) ;
    OclFile["System.out"].println(blacks) ; 
    OclFile["System.out"].println((blacks / 8)->oclAsType(int)) ; 
 );
  static   operation way2() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var rows : Sequence(int) ; rows := Integer.subrange(1,8)->collect(0) ;
    var columns : Sequence(int) ; columns := Integer.subrange(1,8)->collect(0) ;
        var i : int ; i := 0 ; while i < 8 do ( (     var line : String ; line := in.nextLine() ;
     if (line = "BBBBBBBB") then (     rows[i+1] := 1 ) else (         var j : int ; j := 0 ; while j < 8 do ( (     if (line->at(j+1) = 'B') then (     columns[j+1] := 1 ) else skip )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
    var size : int ; size := 0 ;
        var i : int ; i := 0 ; while i < 8 do ( (     size := size+(columns[i+1]) ; 
     size := size+(rows[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(size) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class KalevitchChess {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    List<String>rows=new ArrayList<>();
    while(s.hasNext()){
      rows.add(s.nextLine());
    }
    char[][] a=new char[rows.size()][rows.get(0).length()];
    for(int i=0 ; i<a.length ; i++){
      String row=rows.get(i);
      for(int j=0 ; j<a[0] .length ; j++){
        a[i][j]=row.charAt(j);
      }
    }
    System.out.println(new KalevitchChess().minNumberOfStrokes(a));
  }
  private int minNumberOfStrokes(char[][] a){
    int filled=0 ;
    if(a.length<a[0] .length){
      for(char[] row : a){
        if(rowFilled(row)){
          filled++;
        }
      }
      if(filled<a.length){
        for(int j=0 ; j<a[0] .length ; j++){
          if(colFilled(a,j)){
            filled++;
          }
        }
      }
    }
    else {
      for(int j=0 ; j<a[0] .length ; j++){
        if(colFilled(a,j)){
          filled++;
        }
      }
      if(filled<a.length){
        for(char[] row : a){
          if(rowFilled(row)){
            filled++;
          }
        }
      }
    }
    return filled ;
  }
  private boolean rowFilled(char[] a){
    for(char c : a){
      if(c=='W'){
        return false ;
      }
    }
    return true ;
  }
  private boolean colFilled(char[][] a,int colIndex){
    for(char[] row : a){
      char c=row[colIndex];
      if(c=='W'){
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class KalevitchChess {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var rows : Sequence(String) ; rows := Sequence{} ;
    while (s.hasNext()) do (     rows := rows->including(s.nextLine()) ) ; 
    var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,rows->size())->collect(Integer.subrange(1,rows->at(0+1)->size())->collect(0)) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     var row : String ; row := rows->at(i+1) ;
         var j : int ; j := 0 ; while j < a[0+1]->size() do ( (     a[i+1][j+1] := row->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(KalevitchChess.newKalevitchChess().minNumberOfStrokes(a)) ; 
 );
   operation minNumberOfStrokes( a : Sequence(Sequence(String))) : int
  pre: true
  post: true
  activity: (     var filled : int ; filled := 0 ;
     if (a->size() < a[0+1]->size()) then (     for (row : a) do ( (     if (rowFilled(row)) then (     filled := filled + 1 ) else skip )  ) ; 
     if (filled < a->size()) then (         var j : int ; j := 0 ; while j < a[0+1]->size() do ( (     if (colFilled(a, j)) then (     filled := filled + 1 ) else skip )  ;     j := j + 1 ) ) else skip ) else (         var j : int ; j := 0 ; while j < a[0+1]->size() do ( (     if (colFilled(a, j)) then (     filled := filled + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (filled < a->size()) then (     for (row : a) do ( (     if (rowFilled(row)) then (     filled := filled + 1 ) else skip )  ) ) else skip ) ;  
     return filled );
   operation rowFilled( a : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     for (c : a) do ( (     if (c = 'W') then (     return false ) else skip )  ) ; 
     return true );
   operation colFilled( a : Sequence(Sequence(String)), colIndex : int) : boolean
  pre: true
  post: true
  activity: (     for (row : a) do ( (     var c : String ; c := row[colIndex+1] ;
     if (c = 'W') then (     return false ) else skip )  ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Board {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    char[][] board=new char[10][10];
    for(int i=0 ; i<8 ; i++){
      board[i]=s.next().toCharArray();
    }
    int ans=0 ;
    for(int i=0 ; i<8 ; i++){
      int f=0 ;
      for(int j=0 ; j<8 ; j++){
        if(board[i][j]=='W'){
          f=1 ;
          break ;
        }
      }
      if(f==0)ans++;
    }
    for(int i=0 ; i<8 ; i++){
      int f=0 ;
      for(int j=0 ; j<8 ; j++){
        if(board[j][i]=='W'){
          f=2 ;
          break ;
        }
      }
      if(f==0)ans++;
    }
    if(ans==16)ans/=2 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Board {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var board : Sequence(Sequence(String)) ; board := Integer.subrange(1,10)->collect(Integer.subrange(1,10)->collect(0)) ;
        var i : int ; i := 0 ; while i < 8 do ( (     board[i+1] := s.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 8 do ( (     var f : int ; f := 0 ;
         var j : int ; j := 0 ; while j < 8 do ( (     if (board[i+1][j+1] = 'W') then (     f := 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (f = 0) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 8 do ( (     var f : int ; f := 0 ;
         var j : int ; j := 0 ; while j < 8 do ( (     if (board[j+1][i+1] = 'W') then (     f := 2 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (f = 0) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (ans = 16) then     ans := ans/(2) ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int isKthBitSet(long x,long k){
    int rslt=((x &(1<<(k-1)))!=0)? 1 : 0 ;
    return rslt ;
  }
  static int isPalindrome(long x){
    long l=1 ;
    long r=(Integer.SIZE/8)*8 ;
    while(l<r){
      if(isKthBitSet(x,l)!=isKthBitSet(x,r)){
        return 0 ;
      }
      l++;
      r--;
    }
    return 1 ;
  }
  public static void main(String[] args){
    long x=1<<15+1<<16 ;
    System.out.println(isPalindrome(x));
    x=(1<<31)+1 ;
    System.out.println(isPalindrome(x));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isKthBitSet( x : long, k : long) : int
  pre: true
  post: true
  activity: (     var rslt : int ; rslt := if ((MathLib.bitwiseAnd(x,((1*(2->pow((k - 1))))->oclAsType(long)))) /= 0) then 1 else 0 endif ;
     return rslt );
  static   operation isPalindrome( x : long) : int
  pre: true
  post: true
  activity: (     var l : long ; l := 1 ;
     var r : long ; r := (32 / 8) * 8 ;
     while (l < r) do (     if (isKthBitSet(x, l) /= isKthBitSet(x, r)) then (     return 0 ) else skip ; 
     l := l + 1 ; 
     r := r - 1 ) ; 
     return 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : long ; x := ((1*(2->pow(15 + 1)))->oclAsType(long)*(2->pow(16)))->oclAsType(long) ;
     OclFile["System.out"].println(isPalindrome(x)) ; 
     x := ((1*(2->pow(31)))->oclAsType(long)) + 1 ; 
     OclFile["System.out"].println(isPalindrome(x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Life {
  public static void main(String[] args){
    Scanner n=new Scanner(System.in);
    int h=0,f=0 ;
    for(int i=0 ; i<8 ; i++){
      String m=n.next();
      if(m.contains("W")){
        m=m.replaceAll("B","");
        h=8-m.length();
      }
      else f++;
    }
    System.out.println(f+h);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Life {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : OclFile ; n := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := 0 ;
    var f : int ; f := 0 ;
         var i : int ; i := 0 ; while i < 8 do ( (     var m : String ; m := n.getCurrent() ;
     if (m->includes("W")) then (     m := m.replaceAllMatches("B", "" ) ; 
     h := 8 - m->size() ) else     f := f + 1 ; )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(f + h) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class KalevitchChess {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=8 ;
      char[][] map=new char[n][n];
      for(int i=0 ; i<n ; i++){
        char[] val=sc.nextLine().toCharArray();
        for(int j=0 ; j<val.length ; j++){
          map[i][j]=val[j];
          if(val[j]=='W'){
          }
        }
      }
      int countRows=0 ;
      for(int i=0 ; i<map.length ; i++){
        int val=0 ;
        for(int j=0 ; j<map.length ; j++){
          if(map[i][j]=='B'){
            val++;
          }
          if(val==8){
            countRows++;
          }
        }
      }
      int countCols=0 ;
      for(int j=0 ; j<map.length ; j++){
        int val=0 ;
        for(int i=0 ; i<map.length ; i++){
          if(map[i][j]=='B'){
            val++;
          }
          if(val==8){
            countCols++;
          }
        }
      }
      if(countRows==8 || countCols==8){
        System.out.println(8);
      }
      else {
        System.out.println(countCols+countRows);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class KalevitchChess {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := 8 ;
     var map : Sequence(Sequence(String)) ; map := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var val : Sequence(String) ; val := sc.nextLine()->characters() ;
         var j : int ; j := 0 ; while j < val->size() do ( (     map[i+1][j+1] := val[j+1] ; 
     if (val[j+1] = 'W') then skip else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var countRows : int ; countRows := 0 ;
        var i : int ; i := 0 ; while i < map->size() do ( (     var val : int ; val := 0 ;
         var j : int ; j := 0 ; while j < map->size() do ( (     if (map[i+1][j+1] = 'B') then (     val := val + 1 ) else skip ; 
     if (val = 8) then (     countRows := countRows + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var countCols : int ; countCols := 0 ;
        var j : int ; j := 0 ; while j < map->size() do ( (     var val : int ; val := 0 ;
         var i : int ; i := 0 ; while i < map->size() do ( (     if (map[i+1][j+1] = 'B') then (     val := val + 1 ) else skip ; 
     if (val = 8) then (     countCols := countCols + 1 ) else skip )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    if (countRows = 8 or countCols = 8) then (     OclFile["System.out"].println(8) ) else (     OclFile["System.out"].println(countCols + countRows) ) ;  
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Map<String,Integer>dp=new HashMap<>();
  static Integer solve(char[] s,char c){
    if(s.length==1)return 0 ;
    if(s.length==2){
      if(s[0]==s[1] && s[0]==c)return 1 ;
      else return 0 ;
    }
    if(dp.containsKey(String.valueOf(s)+" "+c))return dp.get(String.valueOf(s)+" "+c);
    Integer ans=0 ;
    if(s[0]==s[s.length-1] && s[0]==c){
      for(char c1='a' ; c1<='z' ; c1++)if(c1!=c)ans=Math.max(ans,1+solve(Arrays.copyOfRange(s,1,s.length-1),c1));
    }
    else {
      for(Integer i=0 ; i<s.length ; i++){
        if(s[i]==c){
          for(Integer j=s.length-1 ; j>i ; j--)if(s[j]==c){
            if(j==i)break ;
            ans=solve(Arrays.copyOfRange(s,i,j+1),c);
            break ;
          }
          break ;
        }
      }
    }
    dp.put(String.valueOf(s)+" "+c,ans);
    return dp.get(String.valueOf(s)+" "+c);
  }
  public static void main(String[] args){
    String s="abscrcdba" ;
    Integer ma=0 ;
    for(char c1='a' ; c1<='z' ; c1++)ma=Math.max(ma,solve(s.toCharArray(),c1)*2);
    System.out.print(ma+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute dp : Map(String,int) := Map{};
  static   operation solve( s : Sequence(String), c : String) : int
  pre: true
  post: true
  activity: (     if (s->size() = 1) then     return 0 else skip ; 
     if (s->size() = 2) then (     if (s[0+1] = s[1+1] & s[0+1] = c) then     return 1 else     return 0 ) else skip ; 
    if (dp->keys()->includes(((s) + "") + " " + c)) then     return dp->at(((s) + "") + " " + c) else skip ; 
    var ans : int ; ans := 0 ;
    if (s[0+1] = s[s->size() - 1+1] & s[0+1] = c) then (         var c1 : String ; c1 := 'a' ; while c1 <= 'z' do (     if (c1 /= c) then     ans := Set{ans, 1 + solve(s.subrange(1+1,s->size() - 1), c1)}->max() ; else skip ;  ;     c1 := c1 + 1 ) ) else (         var i : int ; i := 0 ; while i < s->size() do ( (     if (s[i+1] = c) then (         var j : int ; j := s->size() - 1 ; while j > i do (     if (s[j+1] = c) then (     if (j = i) then     break else skip ; 
     ans := solve(s.subrange(i+1,j + 1), c) ; 
     break ) else skip ;  ;     j := j - 1 ) ; 
     break ) else skip )  ;     i := i + 1 ) ) ;  
    dp := dp->union(Map{((s) + "") + " " + c |-> ans}) ; 
    return dp->at(((s) + "") + " " + c) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abscrcdba" ;
     var ma : int ; ma := 0 ;
         var c1 : String ; c1 := 'a' ; while c1 <= 'z' do (     ma := Set{ma, solve(s->characters(), c1) * 2}->max() ;  ;     c1 := c1 + 1 ) ; 
     OclFile["System.out"].print(ma + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.*;
public class MainClass {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int l=sc.nextInt();
    int r=sc.nextInt();
    int value=1 ;
    int summin=0,summax=0 ;
    for(int i=0 ; i<l ; i++){
      summin+=value ;
      value*=2 ;
    }
    summax=summin ;
    summin+=(n-l);
    for(int i=l ; i<r ; i++){
      summax+=value ;
      value*=2 ;
    }
    value/=2 ;
    summax+=(n-r)*value ;
    System.out.println(summin+" "+summax);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var value : int ; value := 1 ;
    var summin : int ; summin := 0 ;
    var summax : int ; summax := 0 ;
        var i : int ; i := 0 ; while i < l do ( (     summin := summin+(value) ; 
     value := value*(2) )  ;     i := i + 1 ) ; 
    summax := summin ; 
    summin := summin+((n - l)) ; 
        var i : int ; i := l ; while i < r do ( (     summax := summax+(value) ; 
     value := value*(2) )  ;     i := i + 1 ) ; 
    value := value/(2) ; 
    summax := summax+((n - r) * value) ; 
    OclFile["System.out"].println(summin + " " + summax) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int l=sc.nextInt();
    int r=sc.nextInt();
    int minsum=0 ;
    int[] minarr=new int[n];
    for(int i=0 ; i<n-l ; i++)minarr[i]=1 ;
    int pow1=0 ;
    for(int i=n-l ; i<n ; i++){
      if(pow1<=l-1){
        minarr[i]=(int)Math.pow(2,pow1);
        pow1++;
      }
      else break ;
    }
    for(int i : minarr)minsum+=i ;
    int maxsum=0 ;
    int[] maxarr=new int[n];
    for(int i=0 ; i<n-r ; i++)maxarr[i]=(int)Math.pow(2,r-1);
    int pow2=0 ;
    for(int i=n-r ; i<n ; i++){
      if(pow2<=r-1){
        maxarr[i]=(int)Math.pow(2,pow2);
        pow2++;
      }
      else break ;
    }
    for(int i : maxarr)maxsum+=i ;
    System.out.println(minsum+" "+maxsum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var minsum : int ; minsum := 0 ;
    var minarr : Sequence(int) ; minarr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n - l do (     minarr[i+1] := 1 ;  ;     i := i + 1 ) ; 
    var pow1 : int ; pow1 := 0 ;
        var i : int ; i := n - l ; while i < n do ( (     if (pow1 <= l - 1) then (     minarr[i+1] := 2->pow(pow1)->oclAsType(int) ; 
     pow1 := pow1 + 1 ) else     break )  ;     i := i + 1 ) ; 
    for (i : minarr) do (     minsum := minsum+(i) ;  ) ; 
    var maxsum : int ; maxsum := 0 ;
    var maxarr : Sequence(int) ; maxarr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n - r do (     maxarr[i+1] := 2->pow(r - 1)->oclAsType(int) ;  ;     i := i + 1 ) ; 
    var pow2 : int ; pow2 := 0 ;
        var i : int ; i := n - r ; while i < n do ( (     if (pow2 <= r - 1) then (     maxarr[i+1] := 2->pow(pow2)->oclAsType(int) ; 
     pow2 := pow2 + 1 ) else     break )  ;     i := i + 1 ) ; 
    for (i : maxarr) do (     maxsum := maxsum+(i) ;  ) ; 
    OclFile["System.out"].println(minsum + " " + maxsum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int a=in.nextInt();
      int b=in.nextInt();
      int c=in.nextInt();
      int d=in.nextInt();
      int e=in.nextInt();
      int f=in.nextInt();
      System.out.println((e+d+c)*(a+b+c)-a*a-e*e-c*c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var e : int ; e := in.getCurrent()->toInteger() ;
    var f : int ; f := in.getCurrent()->toInteger() ;
    OclFile["System.out"].println((e + d + c) * (a + b + c) - a * a - e * e - c * c) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    int result=Integer.MAX_VALUE ;
    for(int i=1 ; i<=sqrt(n); i++){
      if(n % i!=0)continue ;
      long m=n/i ;
      result=min(result,Long.toString(m).length());
    }
    System.out.println(result);
  }
  public static class Scanner {
    private BufferedReader br ;
    private StringTokenizer tok ;
    public Scanner(InputStream is)throws IOException {
      br=new BufferedReader(new InputStreamReader(is));
    }
    private void getLine()throws IOException {
      while(! hasNext())tok=new StringTokenizer(br.readLine());
    }
    private boolean hasNext(){
      return tok!=null && tok.hasMoreTokens();
    }
    public String next()throws IOException {
      getLine();
      return tok.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var result : int ; result := 2147483647 ;
        var i : int ; i := 1 ; while i <= sqrt(n) do ( (     if (n mod i /= 0) then     continue else skip ; 
     var m : long ; m := n / i ;
     result := Set{result, ((m) + "")->size()}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute tok : OclIterator;
   static operation newScanner( is : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
   operation getLine() : void
  pre: true
  post: true
  activity: (     while (not(hasNext())) do     tok := OclIterator.newOclIterator_String(br.readLine()) ; );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return tok /= null & tok.hasNext() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute getLine() ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int L=sc.nextInt();
    int R=sc.nextInt();
    int l=L,r=R ;
    int nums[]=new int[n];
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      nums[i]=1 ;
    }
    if(l==1){
      System.out.println(n);
    }
    else {
      for(int i=1 ; i<n ; i++){
        if(l>1){
          nums[i]=2*nums[i-1];
          l--;
        }
      }
      for(int x : nums){
        sum+=x ;
      }
      System.out.println(sum);
    }
    l=L ;
    int i=1 ;
    sum=0 ;
    for(; i<n ; i++){
      if(r>l && nums[i]==1){
        nums[i]=2*nums[i-1];
        r--;
      }
      else if(nums[i]==1)nums[i]=nums[i-1];
    }
    for(int x : nums){
      sum+=x ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var L : int ; L := sc.getCurrent()->toInteger() ;
    var R : int ; R := sc.getCurrent()->toInteger() ;
    var l : int ; l := L ;
    var r : int ; r := R ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := 1 )  ;     i := i + 1 ) ; 
    if (l = 1) then (     OclFile["System.out"].println(n) ) else (         var i : int ; i := 1 ; while i < n do ( (     if (l > 1) then (     nums[i+1] := 2 * nums[i - 1+1] ; 
     l := l - 1 ) else skip )  ;     i := i + 1 ) ; 
     for (x : nums) do ( (     sum := sum+(x) )  ) ; 
     OclFile["System.out"].println(sum) ) ;  
    l := L ; 
    var i : int ; i := 1 ;
    sum := 0 ; 
      while i < n do ( (     if (r > l & nums[i+1] = 1) then (     nums[i+1] := 2 * nums[i - 1+1] ; 
     r := r - 1 ) else     if (nums[i+1] = 1) then     nums[i+1] := nums[i - 1+1] ; else skip ; )  ;     i := i + 1 ) ; 
    for (x : nums) do ( (     sum := sum+(x) )  ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int l=sc.nextInt();
    int n=1,m=0 ;
    StringBuilder sb=new StringBuilder();
    while((1<<n-1)-1<l)n++;
    n--;
    for(int i=1 ; i<n ; i++){
      sb.append(Convert(i,i+1,0));
      sb.append(Convert(i,i+1,1<<i-1));
      m+=2 ;
    }
    int max=(1<<n-1)-1 ;
    while(l-max>1){
      int k=1 ;
      while((1<<k-1)<l-max)k++;
      k--;
      sb.append(Convert(k,n,max+1));
      m++;
      max+=(1<<k-1);
    }
    System.out.printf("%d %d\n",n,m);
    System.out.println(new String(sb));
    sc.close();
  }
  public static String Convert(int a,int b,int c){
    return String.valueOf(a)+' '+String.valueOf(b)+' '+String.valueOf(c)+"\n" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var n : int ; n := 1 ;
    var m : int ; m := 0 ;
    var sb : String ; sb := StringLib.newString() ;
    while (((1*(2->pow(n - 1)))->oclAsType(long)) - 1 < l) do     n := n + 1 ; ; 
    n := n - 1 ; 
        var i : int ; i := 1 ; while i < n do ( (     sb := sb + StringLib.newString(Convert(i, i + 1, 0)) ; 
     sb := sb + StringLib.newString(Convert(i, i + 1, (1*(2->pow((i)->char2byte() - 1)))->oclAsType(long))) ; 
     m := m+(2) )  ;     i := i + 1 ) ; 
    var max : int ; max := ((1*(2->pow(n - 1)))->oclAsType(long)) - 1 ;
    while (l - max > 1) do (     var k : int ; k := 1 ;
     while (((1*(2->pow(k - 1)))->oclAsType(long)) < l - max) do     k := k + 1 ; ; 
    k := k - 1 ; 
    sb := sb + StringLib.newString(Convert(k, n, max + 1)) ; 
    m := m + 1 ; 
    max := max+(((1*(2->pow(k - 1)))->oclAsType(long))) ; 
 ) ; 
    OclFile["System.out"].printf("%d %d\n", n, m) ; 
    OclFile["System.out"].println(StringLib.newString(sb)) ; 
    skip ; 
 );
  static   operation Convert( a : int, b : int, c : int) : String
  pre: true
  post: true
  activity: (     return ((a) + "") + ' ' + ((b) + "") + ' ' + ((c) + "") + "\n" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.List ;
class Main {
  static Scanner scanner=new Scanner();
  public static void main(String[] $)throws IOException {
    int l=scanner.nextInt();
    int r=Integer.toBinaryString(l).length()-1 ;
    System.out.println(r+1);
    List<Edge>edges=new ArrayList<>();
    for(int i=0 ; i<r ; i++){
      edges.add(new Edge(i+1,i+2,0));
      edges.add(new Edge(i+1,i+2,1<<i));
    }
    for(int i=r ; i>0 ; i--){
      int j=l-(1<<i-1);
      if(j>=1<<r){
        edges.add(new Edge(i,r+1,j));
        l=j ;
      }
    }
    System.out.println(edges.size());
    for(Edge edge : edges){
      System.out.println(edge);
    }
  }
  static class Edge {
    int to ;
    int from ;
    int cost ;
    Edge(int to,int from,int cost){
      this.to=to ;
      this.from=from ;
      this.cost=cost ;
    }
    @ Override public String toString(){
      return String.format("%s %s %s",to,from,cost);
    }
  }
  static class Scanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),1<<15);
    StringTokenizer tokenizer ;
    String next()throws IOException {
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        tokenizer=new StringTokenizer(reader.readLine());
      }
      return tokenizer.nextToken();
    }
    int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := (arguments ( ));
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := scanner.getCurrent()->toInteger() ;
     var r : int ; r := (MathLib.decimal2binary(l) + "")->size() - 1 ;
    OclFile["System.out"].println(r + 1) ; 
    var edges : Sequence(Edge) ; edges := Sequence{} ;
        var i : int ; i := 0 ; while i < r do ( (     edges := edges->including(Edge.newEdge(i + 1, i + 2, 0)) ; 
     edges := edges->including(Edge.newEdge(i + 1, i + 2, (1*(2->pow(i)))->oclAsType(long))) )  ;     i := i + 1 ) ; 
        var i : int ; i := r ; while i > 0 do ( (     var j : int ; j := l - ((1*(2->pow(i - 1)))->oclAsType(long)) ;
     if (j >= (1*(2->pow(r)))->oclAsType(long)) then (     edges := edges->including(Edge.newEdge(i, r + 1, j)) ; 
     l := j ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(edges->size()) ; 
    for (edge : edges) do ( (     OclFile["System.out"].println(edge) )  ) ; 
 );
  static class Edge {
   attribute to : int;
   attribute from : int;
   attribute cost : int;
   static operation newEdge( to : int, from : int, cost : int) : Edge
  pre: true
  post: true
  activity:
  ( var self : Edge ;
    self := createEdge();
    self.initialise(to, from,cost);
    return self );
  operation initialise( to : int, from : int, cost : int) : void
  pre: true  post: true
  activity: (     self.to := to ; 
     self.from := from ; 
     self.cost := cost );
      operation toString() : String
  pre: true
  post: true
  activity: (     return StringLib.format("%s %s %s",Sequence{to,from,cost}) );
}
  static class Scanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (1*(2->pow(15)))->oclAsType(long));
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static void main(String...args){
    int L=IN.nextInt();
    List<Integer>nums=new ArrayList<>();
    int i=18 ;
    int a=L ;
    while(a>0){
      int b=(int)Math.pow(2,i);
      if(b<=a){
        nums.add(i+1);
        a-=b ;
      }
      else {
        i-=1 ;
      }
    }
    int N=nums.get(0)+1 ;
    List<int[]>G=new ArrayList<>();
    for(int n=1 ; n<=N-2 ; n++){
      G.add(new int[] {
        n,n+1,0 }
);
        G.add(new int[] {
          n,n+1,(int)Math.pow(2,n-1)}
);
        }
        int base=0 ;
        Collections.reverse(nums);
        for(int j : nums){
          G.add(new int[] {
            j,N,base }
);
            base+=(int)Math.pow(2,j-1);
          }
          puts(N+" "+G.size());
          for(int[] x : G){
            puts(x[0]+" "+x[1]+" "+x[2]);
          }
          flush();
        }
        static final Scanner IN=new Scanner(System.in);
        static final PrintWriter OUT=new PrintWriter(System.out);
        static<T>void puts(T arg){
          OUT.println(arg);
        }
        static void flush(){
          OUT.flush();
        }
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := IN.nextInt() ;
     var nums : Sequence(int) ; nums := Sequence{} ;
    var i : int ; i := 18 ;
    var a : int ; a := L ;
    while (a > 0) do (     var b : int ; b := 2->pow(i)->oclAsType(int) ;
     if (b <= a) then (     nums := nums->including(i + 1) ; 
     a := a-(b) ) else (     i := i-(1) ) ) ; 
    var N : int ; N := nums->at(0+1) + 1 ;
    var G : Sequence(Sequence(int)) ; G := Sequence{} ;
        var n : int ; n := 1 ; while n <= N - 2 do ( (     G := G->including(Sequence{n,n + 1,0}) ; 
     G := G->including(Sequence{n,n + 1,2->pow(n - 1)->oclAsType(int)}) )  ;     n := n + 1 ) ; 
    var base : int ; base := 0 ;
    nums := nums->reverse() ; 
    for (j : nums) do ( (     G := G->including(Sequence{j,N,base}) ; 
     base := base+(2->pow(j - 1)->oclAsType(int)) )  ) ; 
    execute puts(N + " " + G->size()) ; 
    for (x : G) do ( (     execute puts(x[0+1] + " " + x[1+1] + " " + x[2+1]) )  ) ; 
    execute flush() ; 
 );
  static    attribute IN : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute OUT : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation puts<T>( arg : T) : void
  pre: true
  post: true
  activity: (     skip );
  static   operation flush() : void
  pre: true
  post: true
  activity: (     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int l=scanner.nextInt();
      int r=0 ;
      while((1<<(r+1))<=l){
        r++;
      }
      int n=r+1 ;
      int count=2*r ;
      StringBuilder sb=new StringBuilder();
      for(int i=r ; i>=1 ; i--){
        if((l-(1<<(i-1)))>=(1<<r)){
          l-=1<<(i-1);
          sb.append(i+" "+n+" "+l).append("\n");
          count++;
        }
      }
      System.out.println(n+" "+count);
      IntStream.rangeClosed(1,r).forEach(i->{
        System.out.println(i+" "+(i+1)+" 0");
        System.out.println(i+" "+(i+1)+" "+(1<<(i-1)));
      }
);
      System.out.print(sb.toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var l : int ; l := scanner.getCurrent()->toInteger() ;
     var r : int ; r := 0 ;
    while (((1*(2->pow((r + 1))))->oclAsType(long)) <= l) do (     r := r + 1 ) ; 
    var n : int ; n := r + 1 ;
    var count : int ; count := 2 * r ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := r ; while i >= 1 do ( (     if ((l - ((1*(2->pow(((i)->char2byte() - 1))))->oclAsType(long))) >= ((1*(2->pow(r)))->oclAsType(long))) then (     l := l-((1*(2->pow(((i)->char2byte() - 1))))->oclAsType(long)) ; 
     sb := sb + StringLib.newString(i + " " + n + " " + l) + StringLib.newString("\n") ; 
     count := count + 1 ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(n + " " + count) ; 
    for i : Integer.subrange(1, r) do
    (    skip) ; 
    OclFile["System.out"].print(sb+"") ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    List<int[]>edges=new ArrayList<>();
    int L=scanner.nextInt();
    int r=findR(L);
    int N=r+1 ;
    for(int i=N-1 ; i>=1 ; i--){
      edges.add(new int[] {
        i,i+1,0 }
);
        edges.add(new int[] {
          i,i+1,1<<(N-i-1)}
);
        }
        int k=L-(1<<r);
        for(int i=r-1 ; i>=0 ; i--){
          int d=1<<i ;
          if(k>=d){
            edges.add(new int[] {
              1,N-i,L-k }
);
              k-=d ;
            }
          }
          System.out.printf("%d %d\n",N,edges.size());
          for(int[] edge : edges){
            System.out.printf("%d %d %d\n",edge[0],edge[1],edge[2]);
          }
        }
        private static int findR(int L){
          int left=0 ;
          int right=(int)Math.floor(Math.log(L)/Math.log(2))+1 ;
          while(right-left>1){
            int mid=(left+right)/2 ;
            if(1L<<mid>L){
              right=mid ;
            }
            else {
              left=mid ;
            }
          }
          return left ;
        }
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var edges : Sequence(Sequence(int)) ; edges := Sequence{} ;
    var L : int ; L := scanner.getCurrent()->toInteger() ;
    var r : int ; r := findR(L) ;
    var N : int ; N := r + 1 ;
        var i : int ; i := N - 1 ; while i >= 1 do ( (     edges := edges->including(Sequence{i,i + 1,0}) ; 
     edges := edges->including(Sequence{i,i + 1,(1*(2->pow((N - i - 1))))->oclAsType(long)}) )  ;     i := i - 1 ) ; 
    var k : int ; k := L - ((1*(2->pow(r)))->oclAsType(long)) ;
        var i : int ; i := r - 1 ; while i >= 0 do ( (     var d : int ; d := (1*(2->pow(i)))->oclAsType(long) ;
     if (k >= d) then (     edges := edges->including(Sequence{1,N - i,L - k}) ; 
     k := k-(d) ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].printf("%d %d\n", N, edges->size()) ; 
    for (edge : edges) do ( (     OclFile["System.out"].printf("%d %d %d\n", edge[0+1], edge[1+1], edge[2+1]) )  ) ; 
 );
  static   operation findR( L : int) : int
  pre: true
  post: true
  activity: (     var left : int ; left := 0 ;
     var right : int ; right := ((L)->log() / (2)->log())->floor()->oclAsType(int) + 1 ;
     while (right - left > 1) do (     var mid : int ; mid := (left + right) / 2 ;
     if ((1L*(2->pow(mid)))->oclAsType(long) > L) then (     right := mid ) else (     left := mid ) ) ; 
     return left );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int Sum(int N){
    int SumOfPrimeDivisors[]=new int[N+1];
    for(int i=2 ; i<=N ; ++i){
      if(SumOfPrimeDivisors[i]==0){
        for(int j=i ; j<=N ; j+=i){
          SumOfPrimeDivisors[j]+=i ;
        }
      }
    }
    return SumOfPrimeDivisors[N];
  }
  public static void main(String args[]){
    int N=60 ;
    System.out.print("Sum of prime "+"divisors of 60 is "+Sum(N)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Sum( N : int) : int
  pre: true
  post: true
  activity: (     var SumOfPrimeDivisors : Sequence(int) ; SumOfPrimeDivisors := Integer.subrange(1,N + 1)->collect(0) ;
         var i : int ; i := 2 ; while i <= N do ( (     if (SumOfPrimeDivisors[i+1] = 0) then (         var j : int ; j := i ; while j <= N do ( (     SumOfPrimeDivisors[j+1] := SumOfPrimeDivisors[j+1]+(i) )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
     return SumOfPrimeDivisors[N+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 60 ;
     OclFile["System.out"].print("Sum of prime " + "divisors of 60 is " + Sum(N) + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test230 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int x=in.nextInt();
      char[] s=in.next().toCharArray();
      if(x>=3){
        System.out.println("NO");
      }
      else {
        if(x>1 && s[0]==s[1]){
          System.out.println("NO");
        }
        else {
          System.out.println("YES");
        }
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test230 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var s : Sequence(String) ; s := in.getCurrent()->characters() ;
     if (x >= 3) then (     OclFile["System.out"].println("NO") ) else (     if (x > 1 & s[0+1] = s[1+1]) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  public static void main(String args[]){
    FastReader sc=new FastReader();
    PrintWriter out=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      String s=sc.nextLine();
      if(n>=3)out.println("NO");
      else if(n==2){
        if(s.charAt(0)==s.charAt(1))out.println("NO");
        else out.println("YES");
      }
      else out.println("YES");
    }
    out.close();
  }
  static void sort(int[] a){
    ArrayList<Integer>l=new ArrayList<>();
    for(int i : a)l.add(i);
    Collections.sort(l);
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.nextInt() ;
     var s : String ; s := sc.nextLine() ;
     if (n >= 3) then     skip ; else     if (n = 2) then (     if (s->at(0+1) = s->at(1+1)) then     skip ; else     skip ; ) else     skip ; ;  ) ;  ) ;  
    skip ; 
 );
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l := l->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class TaskA {
  static final int SIZE=(int)2e5+5 ;
  static final String s1="10" ;
  static final String s2="01" ;
  public static void solve(InputReader in,PrintWriter out){
    int n=in.nextInt();
    String s=in.next();
    String res="NO" ;
    if(n==1)res="YES" ;
    if(n==2){
      if(s.equals(s1)|| s.equals(s2))res="YES" ;
    }
    out.println(res);
  }
  static void clear(){
  }
  public static void main(String[] args)throws FileNotFoundException {
    InputReader in=new InputReader(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int T=1 ;
    T=in.nextInt();
    for(int i=1 ; i<=T ; ++i){
      solve(in,out);
    }
    out.close();
  }
  private static class InputReader {
    private BufferedReader reader ;
    private StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=reader.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TaskA {
  static    attribute SIZE : int := 2e5->oclAsType(int) + 5;
  static    attribute s1 : String := "10";
  static    attribute s2 : String := "01";
  static   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var s : String ; s := in.next() ;
    var res : String ; res := "NO" ;
    if (n = 1) then     res := "YES" ; else skip ; 
    if (n = 2) then (     if (s = s1 or s = s2) then     res := "YES" ; else skip ) else skip ; 
    out.println(res) ; 
 );
  static   operation clear() : void
  pre: true
  post: true
  activity: skip;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : InputReader ; in := InputReader.newInputReader(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := 1 ;
    T := in.nextInt() ; 
        var i : int ; i := 1 ; while i <= T do ( (     execute solve(in, out) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := reader.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.stream.LongStream ;
public class Main {
  public static void main(String[] args){
    java.util.Scanner s=new java.util.Scanner(System.in);
    System.out.println(Main.calc(s.nextLong()));
  }
  public static long calc(long n){
    return LongStream.rangeClosed(1,(int)Math.sqrt(n)).filter(a->n % a==0).map(a->Main.calcF(a,n/a)).min().getAsLong();
  }
  public static int calcF(long a,long b){
    return Math.max((int)(Math.log10(a)+1),(int)(Math.log10(b)+1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Scanner ; s := Scanner.newScanner(OclFile["System.in"]) ;
     OclFile["System.out"].println(Main.calc(s.nextLong())) );
  static   operation calc( n : long) : long
  pre: true
  post: true
  activity: (     return Integer.subrange(1, (n)->sqrt()->oclAsType(int))->select( _x1 | (lambda a : OclAny in n mod a = 0)->apply(_x1) )->collect( _x1 | (lambda a : OclAny in Main.calcF(a, n / a))->apply(_x1) ).min().getAsLong() );
  static   operation calcF( a : long, b : long) : int
  pre: true
  post: true
  activity: (     return Set{((a)->log10() + 1)->oclAsType(int), ((b)->log10() + 1)->oclAsType(int)}->max() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class acmp {
  public static void main(String[] args){
    Scanner css=new Scanner(System.in);
    int t=css.nextInt();
    while(t-->0){
      int n=css.nextInt();
      String str=css.next();
      if(str.equals("01")|| str.equals("10")){
        System.out.println("YES");
      }
      else if(str.equals("1")|| str.equals("0")){
        System.out.println("YES");
      }
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class acmp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var css : OclFile ; css := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := css.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := css.getCurrent()->toInteger() ;
     var str : String ; str := css.getCurrent() ;
     if (str = "01" or str = "10") then (     OclFile["System.out"].println("YES") ) else     if (str = "1" or str = "0") then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class IsDivisible {
  static boolean divisibleBy36(String num){
    int l=num.length();
    if(l==0)return false ;
    if(l==1 && num.charAt(0)!='0')return false ;
    int two_digit_num=(num.charAt(l-2)-'0')*10+(num.charAt(l-1)-'0');
    if(two_digit_num % 4!=0)return false ;
    int sum=0 ;
    for(int i=0 ; i<l ; i++)sum+=(num.charAt(i)-'0');
    if(sum % 9!=0)return false ;
    return true ;
  }
  public static void main(String[] args){
    String num="92567812197966231384" ;
    if(divisibleBy36(num))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class IsDivisible {
  static   operation divisibleBy36( num : String) : boolean
  pre: true
  post: true
  activity: (     var l : int ; l := num->size() ;
     if (l = 0) then     return false else skip ; 
    if (l = 1 & num->at(0+1) /= '0') then     return false else skip ; 
    var two_digit_num : int ; two_digit_num := (num->at(l - 2+1) - ('0')->char2byte()) * 10 + (num->at(l - 1+1) - ('0')->char2byte()) ;
    if (two_digit_num mod 4 /= 0) then     return false else skip ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < l do (     sum := sum+((num->at(i+1) - ('0')->char2byte())) ;  ;     i := i + 1 ) ; 
    if (sum mod 9 /= 0) then     return false else skip ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : String ; num := "92567812197966231384" ;
     if (divisibleBy36(num)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  public static void main(String[] args){
    int a=10,b=15,g ;
    g=gcd(a,b);
    System.out.println("GCD("+a+","+b+")="+g);
    a=35 ;
    b=10 ;
    g=gcd(a,b);
    System.out.println("GCD("+a+","+b+")="+g);
    a=31 ;
    b=2 ;
    g=gcd(a,b);
    System.out.println("GCD("+a+","+b+")="+g);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 10 ;
    var b : int ; b := 15 ;
    var g : int ;
     g := gcd(a, b) ; 
    OclFile["System.out"].println("GCD(" + a + "," + b + ")=" + g) ; 
    a := 35 ; 
    b := 10 ; 
    g := gcd(a, b) ; 
    OclFile["System.out"].println("GCD(" + a + "," + b + ")=" + g) ; 
    a := 31 ; 
    b := 2 ; 
    g := gcd(a, b) ; 
    OclFile["System.out"].println("GCD(" + a + "," + b + ")=" + g) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Megacity {
  static Scanner in=new Scanner(System.in);
  static final int MEGACITY=1000000 ;
  public static void main(String[] args){
    int n=in.nextInt();
    int s=in.nextInt();
    Map<Integer,Integer>map=new TreeMap<>();
    while(n-->0){
      int x=in.nextInt();
      int y=in.nextInt();
      int k=in.nextInt();
      int rad=x*x+y*y ;
      if(! map.containsKey(rad))map.put(rad,k);
      else map.put(rad,map.get(rad)+k);
    }
    int minRad=Integer.MAX_VALUE ;
    for(Map.Entry<Integer,Integer>entry : map.entrySet()){
      Integer key=entry.getKey();
      Integer value=entry.getValue();
      s+=value ;
      if(s>=MEGACITY){
        minRad=key ;
        break ;
      }
    }
    if(minRad==Integer.MAX_VALUE)System.out.println(-1);
    else System.out.format("%.6f\n",Math.sqrt(minRad));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Megacity {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute MEGACITY : int := 1000000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var s : int ; s := in.getCurrent()->toInteger() ;
    var map : Map(int,int) ; map := Map{} ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var x : int ; x := in.getCurrent()->toInteger() ;
     var y : int ; y := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var rad : int ; rad := x * x + y * y ;
    if (not(map->keys()->includes(rad))) then     map := map->union(Map{rad |-> k}) else     map := map->union(Map{rad |-> map->at(rad) + k}) ; ;  
 ) ;  ) ;  
    var minRad : int ; minRad := 2147483647 ;
    for (entry : map->asSet()) do ( (     var key : int ; key := entry.getKey() ;
     var value : int ; value := entry.getValue() ;
     s := s+(value) ; 
     if (s >= MEGACITY) then (     minRad := key ; 
     break ) else skip )  ) ; 
    if (minRad = 2147483647) then     OclFile["System.out"].println(-1) else     OclFile["System.out"].format("%.6f\n", (minRad)->sqrt()) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SolutionG {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int s=in.nextInt();
    int[] x=new int[n],y=new int[n],k=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=in.nextInt();
      y[i]=in.nextInt();
      k[i]=in.nextInt();
    }
    for(int i=0 ; i<n-1 ; i++)for(int j=i+1 ; j<n ; j++){
      int first=x[i]*x[i]+y[i]*y[i],second=x[j]*x[j]+y[j]*y[j];
      if(first>second){
        swap(x,i,j);
        swap(y,i,j);
        swap(k,i,j);
      }
    }
    for(int i=0 ; i<n ; i++){
      s+=k[i];
      if(s>=1_000_000){
        System.out.println(Math.sqrt(x[i]*x[i]+y[i]*y[i]));
        return ;
      }
    }
    System.out.println(-1);
  }
  static void swap(int[] array,int i,int j){
    int tmp=array[i];
    array[i]=array[j];
    array[j]=tmp ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class SolutionG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : int ; s := in.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
    var k : Sequence(int) ; k := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := in.getCurrent()->toInteger() ; 
     y[i+1] := in.getCurrent()->toInteger() ; 
     k[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do (         var j : int ; j := i + 1 ; while j < n do ( (     var first : int ; first := x[i+1] * x[i+1] + y[i+1] * y[i+1] ;
    var second : int ; second := x[j+1] * x[j+1] + y[j+1] * y[j+1] ;
     if (first > second) then (     execute swap(x, i, j) ; 
     execute swap(y, i, j) ; 
     execute swap(k, i, j) ) else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     s := s+(k[i+1]) ; 
     if (s >= 1_000_000) then (     OclFile["System.out"].println((x[i+1] * x[i+1] + y[i+1] * y[i+1])->sqrt()) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
 );
  static   operation swap( array : Sequence(int), i : int, j : int) : void
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := array[i+1] ;
     array[i+1] := array[j+1] ; 
     array[j+1] := tmp );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void MaximumProduct(int a[],int n){
    int cntneg=0 ;
    int cntzero=0 ;
    int used[]=new int[n];
    int pos=-1 ;
    for(int i=0 ; i<n ; ++i){
      if(a[i]==0){
        used[i]=1 ;
        cntzero++;
      }
      if(a[i]<0){
        cntneg++;
        if(pos==-1 || Math.abs(a[pos])>Math.abs(a[i])){
          pos=i ;
        }
      }
    }
    if(cntneg % 2==1){
      used[pos]=1 ;
    }
    if(cntzero==n ||(cntzero==n-1 && cntneg==1)){
      for(int i=0 ; i<n-1 ; ++i){
        System.out.println(1+" "+(i+1)+" "+(i+2));
      }
      return ;
    }
    int lst=-1 ;
    for(int i=0 ; i<n ; ++i){
      if(used[i]==1){
        if(lst!=-1){
          System.out.println(1+" "+(lst+1)+" "+(i+1));
        }
        lst=i ;
      }
    }
    if(lst!=-1){
      System.out.println(2+" "+(lst+1));
    }
    lst=-1 ;
    for(int i=0 ; i<n ; ++i){
      if(used[i]!=1){
        if(lst!=-1){
          System.out.println(1+" "+(lst+1)+" "+(i+1));
        }
        lst=i ;
      }
    }
  }
  public static void main(String[] args){
    int a[]={
      5,-2,0,1,-3 };
      int n=a.length ;
      MaximumProduct(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation MaximumProduct( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var cntneg : int ; cntneg := 0 ;
     var cntzero : int ; cntzero := 0 ;
    var used : Sequence(int) ; used := Integer.subrange(1,n)->collect(0) ;
    var pos : int ; pos := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = 0) then (     used[i+1] := 1 ; 
     cntzero := cntzero + 1 ) else skip ; 
     if (a[i+1] < 0) then (     cntneg := cntneg + 1 ; 
     if (pos = -1 or if a[pos+1] < 0 then -(a[pos+1]) else a[pos+1] endif > if a[i+1] < 0 then -(a[i+1]) else a[i+1] endif) then (     pos := i ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (cntneg mod 2 = 1) then (     used[pos+1] := 1 ) else skip ; 
    if (cntzero = n or (cntzero = n - 1 & cntneg = 1)) then (         var i : int ; i := 0 ; while i < n - 1 do ( (     OclFile["System.out"].println(1 + " " + (i + 1) + " " + (i + 2)) )  ;     i := i + 1 ) ; 
     return ) else skip ; 
    var lst : int ; lst := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (used[i+1] = 1) then (     if (lst /= -1) then (     OclFile["System.out"].println(1 + " " + (lst + 1) + " " + (i + 1)) ) else skip ; 
     lst := i ) else skip )  ;     i := i + 1 ) ; 
    if (lst /= -1) then (     OclFile["System.out"].println(2 + " " + (lst + 1)) ) else skip ; 
    lst := -1 ; 
        var i : int ; i := 0 ; while i < n do ( (     if (used[i+1] /= 1) then (     if (lst /= -1) then (     OclFile["System.out"].println(1 + " " + (lst + 1) + " " + (i + 1)) ) else skip ; 
     lst := i ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{5,-2,0,1,-3} ;
     var n : int ; n := a->size() ;
     execute MaximumProduct(a, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int equalize(int arr[],int n,int k){
    int min_ele=Arrays.stream(arr).min().getAsInt();
    boolean flag=true ;
    for(int i=0 ; i<n ; i++){
      if(!((arr[i]+k)>=min_ele+k && min_ele+k>=(arr[i]-k))){
        flag=false ;
        break ;
      }
    }
    if(flag){
      return min_ele+k ;
    }
    else return-1 ;
  }
  public static void main(String[] args){
    int K=2 ;
    int arr[]={
      1,2,3,4,5 };
      int N=arr.length ;
      System.out.print(equalize(arr,N,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation equalize( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var min_ele : int ; min_ele := stream(arr).min().getAsInt() ;
     var flag : boolean ; flag := true ;
         var i : int ; i := 0 ; while i < n do ( (     if (not(((arr[i+1] + k) >= min_ele + k & min_ele + k >= (arr[i+1] - k)))) then (     flag := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (flag) then (     return min_ele + k ) else     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var K : int ; K := 2 ;
     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var N : int ; N := arr->size() ;
     OclFile["System.out"].print(equalize(arr, N, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class MochaMath {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  public static void main(String[] args)throws IOException {
    int t=Integer.parseInt(br.readLine());
    while(t-->0){
      int size=Integer.parseInt(br.readLine());
      int arr[]=new int[size];
      String[] str_arr=br.readLine().split("\\s");
      for(int i=0 ; i<size ; i++){
        arr[i]=Integer.parseInt(str_arr[i]);
      }
      int result=helper(arr,size);
      System.out.println(result);
    }
  }
  private static int helper(int[] arr,int n){
    int ans=arr[0];
    for(int i=1 ; i<arr.length ; i++){
      ans &=arr[i];
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class MochaMath {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := (br.readLine())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var size : int ; size := (br.readLine())->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
    var str_arr : Sequence(String) ; str_arr := br.readLine()->split("\\s") ;
        var i : int ; i := 0 ; while i < size do ( (     arr[i+1] := (str_arr[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var result : int ; result := helper(arr, size) ;
    OclFile["System.out"].println(result) ; 
 ) ;  ) );
  static   operation helper( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := arr[0+1] ;
         var i : int ; i := 1 ; while i < arr->size() do ( (     ans := MathLib.bitwiseAnd(ans, arr[i+1]) )  ;     i := i + 1 ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class A1559 {
  static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
  static int fasterScanner(){
    try {
      boolean in=false ;
      int res=0 ;
      for(; ; ){
        int b=System.in.read()-'0' ;
        if(b>=0){
          in=true ;
          res=10*res+b ;
        }
        else if(in){
          return res ;
        }
      }
    }
    catch(IOException e){
      throw new Error(e);
    }
  }
  public static void main(String[] args){
    FastScanner sc=new FastScanner();
    int t=fasterScanner();
    while(t-->0){
      int n=sc.nextInt();
      int ans=sc.nextInt();
      for(int i=1 ; i<n ; i++){
        ans &=sc.nextInt();
      }
      out.println(ans);
    }
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
        }
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    char nextChar(){
      return next().charAt(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1559 {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation fasterScanner() : int
  pre: true
  post: true
  activity: (     try (     var in : boolean ; in := false ;
     var res : int ; res := 0 ;
       while true do ( (     var b : int ; b := OclFile["System.in"].read() - ('0')->char2byte() ;
     if (b >= 0) then (     in := true ; 
     res := 10 * res + b ) else     if (in) then (     return res ) else skip ; )  ) )   catch (e : IOException) do (     error SystemException(e) )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner() ;
     var t : int ; t := fasterScanner() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.nextInt() ;
     var ans : int ; ans := sc.nextInt() ;
         var i : int ; i := 1 ; while i < n do ( (     ans := MathLib.bitwiseAnd(ans, sc.nextInt()) )  ;     i := i + 1 ) ; 
     skip ) ;  ) ;  
     skip );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.lang.reflect.Array ;
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class pre5 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int tc=obj.nextInt();
    while(tc--!=0){
      int n=obj.nextInt(),arr[]=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=obj.nextInt();
      int ans=arr[0];
      for(int i=1 ; i<n ; i++)ans &=arr[i];
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre5 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var tc : int ; tc := obj.nextInt() ;
         while (tc /= 0) do (    skip ; (     var n : int ; n := obj.nextInt() ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     arr[i+1] := obj.nextInt() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := arr[0+1] ;
        var i : int ; i := 1 ; while i < n do (     ans := MathLib.bitwiseAnd(ans, arr[i+1]) ;  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class GFG {
  static class pair {
    int first,second ;
    public pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static void findFourElements(int arr[],int n,int X){
    HashMap<Integer,pair>mp=new HashMap<Integer,pair>();
    for(int i=0 ; i<n-1 ; i++)for(int j=i+1 ; j<n ; j++)mp.put(arr[i]+arr[j],new pair(i,j));
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        int sum=arr[i]+arr[j];
        if(mp.containsKey(X-sum)){
          pair p=mp.get(X-sum);
          if(p.first!=i && p.first!=j && p.second!=i && p.second!=j){
            System.out.print(arr[i]+","+arr[j]+","+arr[p.first]+","+arr[p.second]);
            return ;
          }
        }
      }
    }
  }
  public static void main(String[] args){
    int arr[]={
      10,20,30,40,1,2 };
      int n=arr.length ;
      int X=91 ;
      findFourElements(arr,n,X);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class pair {
   attribute first : int;
   static operation newpair( first : int, second : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation findFourElements( arr : Sequence(int), n : int, X : int) : void
  pre: true
  post: true
  activity: (     var mp : Map(int,pair) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n - 1 do (         var j : int ; j := i + 1 ; while j < n do (     mp := mp->union(Map{arr[i+1] + arr[j+1] |-> pair.newpair(i, j)}) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var sum : int ; sum := arr[i+1] + arr[j+1] ;
     if (mp->keys()->includes(X - sum)) then (     var p : pair ; p := mp->at(X - sum) ;
     if (p->at("first") /= i & p->at("first") /= j & p->at("second") /= i & p->at("second") /= j) then (     OclFile["System.out"].print(arr[i+1] + "," + arr[j+1] + "," + arr[p->at("first")+1] + "," + arr[p->at("second")+1]) ; 
     return ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,20,30,40,1,2} ;
     var n : int ; n := arr->size() ;
     var X : int ; X := 91 ;
     execute findFourElements(arr, n, X) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    long n=Long.parseLong(input.readLine());
    long a=1 ;
    long b=1 ;
    long answer=String.valueOf(n).length();
    while(a<Math.sqrt(n)+1){
      if(n % a==0){
        b=n/a ;
        if(answer>String.valueOf(b).length()&& String.valueOf(b).length()>=String.valueOf(a).length()){
          answer=String.valueOf(b).length();
        }
      }
      a++;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : long ; n := (input.readLine())->toLong() ;
    var a : long ; a := 1 ;
    var b : long ; b := 1 ;
    var answer : long ; answer := ((n) + "")->size() ;
    while (a < (n)->sqrt() + 1) do (     if (n mod a = 0) then (     b := n / a ; 
     if (answer > ((b) + "")->size() & ((b) + "")->size() >= ((a) + "")->size()) then (     answer := ((b) + "")->size() ) else skip ) else skip ; 
     a := a + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class b {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new FileReader(args[0]));
    String str ;
    int numCases=Integer.parseInt(br.readLine());
    for(int nCase=1 ; nCase<=numCases ; nCase++){
      String[] sa=br.readLine().split(" ");
      int L=Integer.parseInt(sa[0]);
      int P=Integer.parseInt(sa[1]);
      int C=Integer.parseInt(sa[2]);
      double R=(double)P/L ;
      int count=0 ;
      while(R>C){
        R=Math.sqrt(R);
        count++;
      }
      System.out.println("Case #"+nCase+": "+count);
    }
    br.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(args[0+1])) ;
     var str : String ;
    var numCases : int ; numCases := (br.readLine())->toInteger() ;
        var nCase : int ; nCase := 1 ; while nCase <= numCases do ( (     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
     var L : int ; L := (sa[0+1])->toInteger() ;
    var P : int ; P := (sa[1+1])->toInteger() ;
    var C : int ; C := (sa[2+1])->toInteger() ;
    var R : double ; R := P->oclAsType(double) / L ;
    var count : int ; count := 0 ;
    while (R > C) do (     R := (R)->sqrt() ; 
     count := count + 1 ) ; 
    OclFile["System.out"].println("Case #" + nCase + ": " + count) ; 
 )  ;     nCase := nCase + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  public static void main(String[] args){
    int a=10,b=15,g ;
    g=gcd(a,b);
    System.out.println("GCD("+a+","+b+")="+g);
    a=35 ;
    b=10 ;
    g=gcd(a,b);
    System.out.println("GCD("+a+","+b+")="+g);
    a=31 ;
    b=2 ;
    g=gcd(a,b);
    System.out.println("GCD("+a+","+b+")="+g);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 10 ;
    var b : int ; b := 15 ;
    var g : int ;
     g := gcd(a, b) ; 
    OclFile["System.out"].println("GCD(" + a + "," + b + ")=" + g) ; 
    a := 35 ; 
    b := 10 ; 
    g := gcd(a, b) ; 
    OclFile["System.out"].println("GCD(" + a + "," + b + ")=" + g) ; 
    a := 31 ; 
    b := 2 ; 
    g := gcd(a, b) ; 
    OclFile["System.out"].println("GCD(" + a + "," + b + ")=" + g) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round_1B_2010 ;
import java.io.File ;
import java.io.FileWriter ;
import java.util.Scanner ;
public class LoadTestingR {
  public static void main(String[] args){
    Scanner reader=new Scanner(System.in);
    try {
      FileWriter writer=new FileWriter(new File("D:/ltrout_large.txt"));
      int t=reader.nextInt();
      for(int cc=1 ; cc<=t ; ++cc){
        long l=reader.nextInt();
        long p=reader.nextInt();
        int c=reader.nextInt();
        int sum=0 ;
        long now=p ;
        if(l*c>=p){
          writer.write("Case #"+cc+": 0\r\n");
        }
        else {
          while(true){
            sum++;
            now=(now+c-1)/c ;
            if(l*c>=now)break ;
          }
          int result=(int)Math.ceil(Math.log(sum+1)/Math.log(2));
          writer.write("Case #"+cc+": "+result+"\r\n");
        }
        writer.flush();
      }
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class LoadTestingR {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     try (     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile("D:/ltrout_large.txt")) ;
     var t : int ; t := reader.getCurrent()->toInteger() ;
         var cc : int ; cc := 1 ; while cc <= t do ( (     var l : long ; l := reader.getCurrent()->toInteger() ;
     var p : long ; p := reader.getCurrent()->toInteger() ;
    var c : int ; c := reader.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var now : long ; now := p ;
    if (l * c >= p) then (     skip ) else (     while (true) do (     sum := sum + 1 ; 
     now := (now + c - 1) / c ; 
     if (l * c >= now) then     break else skip ) ; 
     var result : int ; result := ((sum + 1)->log() / (2)->log())->ceil()->oclAsType(int) ;
     skip ) ;  
    skip ; 
 )  ;     cc := cc + 1 ) ; 
     skip )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileNotFoundException ;
import java.io.IOException ;
import java.io.RandomAccessFile ;
import java.util.LinkedList ;
import java.util.List ;
public class LoadTesting {
  public static List<Integer>ans=new LinkedList<Integer>();
  public static void main(String[] args)throws IOException {
    ans.clear();
    for(int i=0 ; i<40 ; i++){
      ans.add(pToTestCount(i));
      System.out.println(i+":"+pToTestCount(i));
    }
    RandomAccessFile in=new RandomAccessFile(args[0],"r");
    RandomAccessFile out=new RandomAccessFile(args[1],"rw");
    int caseCount=Integer.parseInt(in.readLine());
    for(int i=1 ; i<=caseCount ; i++){
      long L,P,C ;
      String temp[]=in.readLine().trim().split(" ");
      L=Integer.parseInt(temp[0]);
      P=Integer.parseInt(temp[1]);
      C=Integer.parseInt(temp[2]);
      int p=0 ;
      while(L<P){
        p++;
        L=L*C ;
      }
      p--;
      String result="Case #" ;
      int retCode=ans.get(p);
      result=result+i+": "+retCode+"\n" ;
      out.writeBytes(result);
    }
  }
  public static int pToTestCount(int p){
    if(p==0)return 0 ;
    int ret=1 ;
    return ret+pToTestCount(p/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class LoadTesting {
  static   attribute ans : Sequence(int) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     ans := ans->intersection(Set{}) ; 
         var i : int ; i := 0 ; while i < 40 do ( (     ans := ans->including(pToTestCount(i)) ; 
     OclFile["System.out"].println(i + ":" + pToTestCount(i)) )  ;     i := i + 1 ) ; 
    var in : OclFile ; in := OclFile.newOclFile(args[0+1], "r") ;
    var out : OclFile ; out := OclFile.newOclFile(args[1+1], "rw") ;
    var caseCount : int ; caseCount := (in.readLine())->toInteger() ;
        var i : int ; i := 1 ; while i <= caseCount do ( (     var L : long ;
    var P : long ;
    var C : long ;
     var temp : Sequence(String) ; temp := in.readLine()->trim()->split(" ") ;
    L := (temp[0+1])->toInteger() ; 
    P := (temp[1+1])->toInteger() ; 
    C := (temp[2+1])->toInteger() ; 
    var p : int ; p := 0 ;
    while (L < P) do (     p := p + 1 ; 
     L := L * C ) ; 
    p := p - 1 ; 
    var result : String ; result := "Case #" ;
    var retCode : int ; retCode := ans->at(p+1) ;
    result := result + i + ": " + retCode + "\n" ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
 );
  static   operation pToTestCount( p : int) : int
  pre: true
  post: true
  activity: (     if (p = 0) then     return 0 else skip ; 
     var ret : int ; ret := 1 ;
     return ret + pToTestCount(p / 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Locale ;
import java.util.Arrays ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
public class Load implements Runnable {
  private final Scanner scanner ;
  private final PrintWriter printer ;
  private String solveSingle(){
    int l=scanner.nextInt();
    int p=scanner.nextInt();
    int c=scanner.nextInt();
    int mults=0 ;
    long ll=l ;
    while(ll*c<p){
      ll*=c ;
      mults++;
    }
    int naive=0 ;
    while((1<<naive)<=mults){
      naive++;
    }
    return String.valueOf(naive);
  }
  private void solve()throws Exception {
    int cases=scanner.nextInt();
    for(int test=1 ; test<=cases ; test++){
      printer.println("Case #"+test+": "+solveSingle());
    }
  }
  private Load()throws FileNotFoundException {
    scanner=new Scanner(new File("b-large.in"));
    printer=new PrintWriter(new File("b-large.out"));
  }
  public void run(){
    try {
      solve();
    }
    catch(Exception e){
      e.printStackTrace();
      throw new RuntimeException(e);
    }
    finally {
      printer.close();
    }
  }
  public static void main(String[] args)throws FileNotFoundException {
    Locale.setDefault(Locale.US);
    new Thread(new Load()).start();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Load implements Runnable {
   attribute scanner : OclFile;
   attribute printer : OclFile;
   operation solveSingle() : String
  pre: true
  post: true
  activity: (     var l : int ; l := scanner.getCurrent()->toInteger() ;
     var p : int ; p := scanner.getCurrent()->toInteger() ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    var mults : int ; mults := 0 ;
    var ll : long ; ll := l ;
    while (ll * c < p) do (     ll := ll*(c) ; 
     mults := mults + 1 ) ; 
    var naive : int ; naive := 0 ;
    while (((1*(2->pow(naive)))->oclAsType(long)) <= mults) do (     naive := naive + 1 ) ; 
    return ((naive) + "") 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var cases : int ; cases := scanner.getCurrent()->toInteger() ;
         var test : int ; test := 1 ; while test <= cases do ( (     skip )  ;     test := test + 1 ) );
   static operation newLoad() : Load
  pre: true
  post: true
  activity:
  ( var self : Load ;
    self := createLoad();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile("b-large.in")) ; 
     printer := OclFile.newOclFile_Write(OclFile("b-large.out")) );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     execute solve() )   catch (e : ProgramException) do (     e.printStackTrace() ; 
     error ProgramException(e) )
   finally (     skip )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.US) ; 
     OclProcess.newOclProcess(Load.newLoad()).start() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.util.StringTokenizer ;
public class ab {
  public static void main(String args[])throws Exception {
    BufferedReader f=new BufferedReader(new FileReader("A.in"));
    BufferedWriter w=new BufferedWriter(new FileWriter("A.txt"));
    int t=Integer.parseInt(f.readLine());
    StringTokenizer g ;
    int l,p,c ;
    for(int d=1 ; d<=t ; d++){
      g=new StringTokenizer(f.readLine());
      l=Integer.parseInt(g.nextToken());
      p=Integer.parseInt(g.nextToken());
      c=Integer.parseInt(g.nextToken());
      int ans=(int)((Math.ceil(Math.log(Math.ceil(Math.log(p/(double)l)/Math.log(c))))/Math.log(2)));
      w.write("Case #"+d+": "+""+ans+"\n");
    }
    w.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ab {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("A.in"))) ;
     var w : OclFile ; w := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("A.txt"))) ;
    var t : int ; t := (f.readLine())->toInteger() ;
    var g : OclIterator ;
    var l : int ;
    var p : int ;
    var c : int ;
        var d : int ; d := 1 ; while d <= t do ( (     g := OclIterator.newOclIterator_String(f.readLine()) ; 
     l := (g.next())->toInteger() ; 
    p := (g.next())->toInteger() ; 
    c := (g.next())->toInteger() ; 
    var ans : int ; ans := ((((((p / l->oclAsType(double))->log() / (c)->log())->ceil())->log())->ceil() / (2)->log()))->oclAsType(int) ;
    skip ; 
 )  ;     d := d + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p004 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p004().run());
  }
  public String run(){
    int maxPalin=-1 ;
    for(int i=100 ; i<1000 ; i++){
      for(int j=100 ; j<1000 ; j++){
        int prod=i*j ;
        if(Library.isPalindrome(prod)&& prod>maxPalin)maxPalin=prod ;
      }
    }
    return Integer.toString(maxPalin);
  }
}
------------------------------------------------------------
OCL File:
---------
class p004 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p004.newp004().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var maxPalin : int ; maxPalin := -1 ;
         var i : int ; i := 100 ; while i < 1000 do ( (         var j : int ; j := 100 ; while j < 1000 do ( (     var prod : int ; prod := i * j ;
     if (Library.isPalindrome(prod) & prod > maxPalin) then     maxPalin := prod ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ((maxPalin) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Longest {
  public static void longestAlternating(int arr[],int n){
    int[] count=new int[n];
    count[n-1]=1 ;
    for(int i=n-2 ; i>=0 ; i--){
      if(arr[i]*arr[i+1]<0)count[i]=count[i+1]+1 ;
      else count[i]=1 ;
    }
    for(int i=0 ; i<n ; i++)System.out.print(count[i]+" ");
  }
  public static void main(String[] args){
    int a[]={
-5,-1,-1,2,-2,-3 };
      int n=6 ;
      longestAlternating(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Longest {
  static   operation longestAlternating( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,n)->collect(0) ;
     count[n - 1+1] := 1 ; 
         var i : int ; i := n - 2 ; while i >= 0 do ( (     if (arr[i+1] * arr[i + 1+1] < 0) then     count[i+1] := count[i + 1+1] + 1 ; else     count[i+1] := 1 ; )  ;     i := i - 1 ) ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(count[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{-5,-1,-1,2,-2,-3} ;
     var n : int ; n := 6 ;
     execute longestAlternating(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int N=1000001 ;
  static int visited[]=new int[N];
  static int goesTo[]=new int[N];
  static int dfs(int i){
    if(visited[i]==1)return 0 ;
    visited[i]=1 ;
    int x=dfs(goesTo[i]);
    return(x+1);
  }
  static int noOfTranspositions(int P[],int n){
    for(int i=1 ; i<=n ; i++)visited[i]=0 ;
    for(int i=0 ; i<n ; i++)goesTo[P[i] ]=i+1 ;
    int transpositions=0 ;
    for(int i=1 ; i<=n ; i++){
      if(visited[i]==0){
        int ans=dfs(i);
        transpositions+=ans-1 ;
      }
    }
    return transpositions ;
  }
  public static void main(String[] args){
    int permutation[]={
      5,1,4,3,2 };
      int n=permutation.length ;
      System.out.println(noOfTranspositions(permutation,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 1000001;
  static   attribute visited : int := Integer.subrange(1,N)->collect(0);
  static   attribute goesTo : int := Integer.subrange(1,N)->collect(0);
  static   operation dfs( i : int) : int
  pre: true
  post: true
  activity: (     if (visited[i+1] = 1) then     return 0 else skip ; 
     visited[i+1] := 1 ; 
     var x : int ; x := dfs(goesTo[i+1]) ;
     return (x + 1) );
  static   operation noOfTranspositions( P : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= n do (     visited[i+1] := 0 ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do (     goesTo[P[i+1]+1] := i + 1 ;  ;     i := i + 1 ) ; 
    var transpositions : int ; transpositions := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (visited[i+1] = 0) then (     var ans : int ; ans := dfs(i) ;
     transpositions := transpositions+(ans - 1) ) else skip )  ;     i := i + 1 ) ; 
    return transpositions 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var permutation : Sequence(int) ; permutation := Sequence{5,1,4,3,2} ;
     var n : int ; n := permutation->size() ;
     OclFile["System.out"].println(noOfTranspositions(permutation, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int d=sc.nextInt();
    System.out.print("Christmas ");
    while(d<25){
      System.out.print("Eve ");
      d++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].print("Christmas ") ; 
     while (d < 25) do (     OclFile["System.out"].print("Eve ") ; 
     d := d + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      String line=reader.readLine();
      int day=Integer.parseInt(line);
      String strs="Christmas" ;
      String eves=" Eve" ;
      for(int i=0 ; i<25-day ; i++){
        strs=strs+eves ;
      }
      System.out.println(strs);
    }
    catch(IOException e){
      System.out.println(e);
    }
    catch(NumberFormatException e){
      System.out.println("wrong");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var line : String ; line := reader.readLine() ;
     var day : int ; day := (line)->toInteger() ;
    var strs : String ; strs := "Christmas" ;
    var eves : String ; eves := " Eve" ;
        var i : int ; i := 0 ; while i < 25 - (day)->char2byte() do ( (     strs := strs + eves )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(strs) ; 
 )   catch (e : IOException) do (     OclFile["System.out"].println(e) )
   catch (e : IncorrectElementException) do (     OclFile["System.out"].println("wrong") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  static int n ;
  static int[] start ;
  static int[] end ;
  static BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  static StringTokenizer tok ;
  static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
  static boolean hasNext(){
    while(tok==null || ! tok.hasMoreTokens()){
      try {
        tok=new StringTokenizer(in.readLine());
      }
      catch(Exception e){
        return false ;
      }
    }
    return true ;
  }
  static String next(){
    hasNext();
    return tok.nextToken();
  }
  static Long nextLong(){
    return Long.parseLong(next());
  }
  static int nextInt(){
    return Integer.parseInt(next());
  }
  public static void main(String[] args){
    n=nextInt();
    start=new int[n];
    end=new int[n];
    boolean is_=true ;
    for(int t=0 ; t<n ; t++){
      start[t]=nextInt();
    }
    for(int t=0 ; t<n ; t++){
      end[t]=nextInt();
    }
    int point=0,st=0 ;
    if(start[st]==0)st++;
    while(end[point]!=start[st])point++;
    while(st<n-1){
      if(end[point]==0)point++;
      if(start[st]==0)st++;
      if(st==n)break ;
      if(point==n)point=0 ;
      if(start[st]!=end[point]){
        is_=false ;
        break ;
      }
      else {
        point++;
        st++;
      }
      if(point==n)point=0 ;
    }
    if(is_)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute start : Sequence(int);
  static   attribute end : Sequence(int);
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute tok : OclIterator;
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (tok = null or not(tok.hasNext())) do (     try (     tok := OclIterator.newOclIterator_String(in.readLine()) )   catch (e : ProgramException) do (     return false )
 ) ; 
     return true );
  static   operation next() : String
  pre: true
  post: true
  activity: (     execute hasNext() ; 
     return tok.next() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := nextInt() ; 
     start := Integer.subrange(1,n)->collect(0) ; 
    end := Integer.subrange(1,n)->collect(0) ; 
    var is_ : boolean ; is_ := true ;
        var t : int ; t := 0 ; while t < n do ( (     start[t+1] := nextInt() )  ;     t := t + 1 ) ; 
        var t : int ; t := 0 ; while t < n do ( (     end[t+1] := nextInt() )  ;     t := t + 1 ) ; 
    var point : int ; point := 0 ;
    var st : int ; st := 0 ;
    if (start[st+1] = 0) then     st := st + 1 ; else skip ; 
    while (end[point+1] /= start[st+1]) do     point := point + 1 ; ; 
    while (st < n - 1) do (     if (end[point+1] = 0) then     point := point + 1 ; else skip ; 
     if (start[st+1] = 0) then     st := st + 1 ; else skip ; 
    if (st = n) then     break else skip ; 
    if (point = n) then     point := 0 ; else skip ; 
    if (start[st+1] /= end[point+1]) then (     is_ := false ; 
     break ) else (     point := point + 1 ; 
     st := st + 1 ) ;  
    if (point = n) then     point := 0 ; else skip ; 
 ) ; 
    if (is_) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int k ;
    k=sc.nextInt();
    for(int j=0 ; j<k ; j++){
      int n=sc.nextInt();
      if(n==1){
        System.out.println(2);
        continue ;
      }
      int ans=0 ;
      if(n % 3==1){
        System.out.println(n/3+1);
      }
      else if(n % 3==0){
        System.out.println(n/3);
      }
      else if(n % 3==2){
        System.out.println(n/3+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ;
     k := sc.getCurrent()->toInteger() ; 
         var j : int ; j := 0 ; while j < k do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 1) then (     OclFile["System.out"].println(2) ; 
     continue ) else skip ; 
     var ans : int ; ans := 0 ;
     if (n mod 3 = 1) then (     OclFile["System.out"].println(n / 3 + 1) ) else     if (n mod 3 = 0) then (     OclFile["System.out"].println(n / 3) ) else     if (n mod 3 = 2) then (     OclFile["System.out"].println(n / 3 + 1) ) else skip ; ;  )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p174 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p174().run());
  }
  private static final int SIZE_LIMIT=1000000 ;
  private static final int TYPE_LIMIT=10 ;
  public String run(){
    int[] type=new int[SIZE_LIMIT+1];
    for(int n=3 ; (n-1)*4<=SIZE_LIMIT ; n++){
      for(int m=n-2 ; m>=1 ; m-=2){
        int tiles=n*n-m*m ;
        if(tiles>SIZE_LIMIT)break ;
        type[tiles]++;
      }
    }
    int count=0 ;
    for(int t : type){
      if(1<=t && t<=TYPE_LIMIT)count++;
    }
    return Integer.toString(count);
  }
}
------------------------------------------------------------
OCL File:
---------
class p174 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p174.newp174().run()) );
  static    attribute SIZE_LIMIT : int := 1000000;
  static    attribute TYPE_LIMIT : int := 10;
   operation run() : String
  pre: true
  post: true
  activity: (     var type : Sequence(int) ; type := Integer.subrange(1,SIZE_LIMIT + 1)->collect(0) ;
         var n : int ; n := 3 ; while (n - 1) * 4 <= SIZE_LIMIT do ( (         var m : int ; m := n - 2 ; while m >= 1 do ( (     var tiles : int ; tiles := n * n - m * m ;
     if (tiles > SIZE_LIMIT) then     break else skip ; 
     type[tiles+1] := type[tiles+1] + 1 )  ;     m := m-(2) ) )  ;     n := n + 1 ) ; 
    var count : int ; count := 0 ;
    for (t : type) do ( (     if (1 <= t & t <= TYPE_LIMIT) then     count := count + 1 ; else skip )  ) ; 
    return ((count) + "") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int d=sc.nextInt();
    if(d==25)System.out.println("Christmas");
    else if(d==24)System.out.println("Christmas Eve");
    else if(d==23)System.out.println("Christmas Eve Eve");
    else System.out.println("Christmas Eve Eve Eve");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
     if (d = 25) then     OclFile["System.out"].println("Christmas") ; else     if (d = 24) then     OclFile["System.out"].println("Christmas Eve") else     if (d = 23) then     OclFile["System.out"].println("Christmas Eve Eve") else     OclFile["System.out"].println("Christmas Eve Eve Eve") ; ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int day=scan.nextInt();
    System.out.print("Christmas");
    for(int i=0 ; i<25-day ; i++){
      System.out.print(" Eve");
    }
    System.out.println("");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var day : int ; day := scan.getCurrent()->toInteger() ;
    OclFile["System.out"].print("Christmas") ; 
        var i : int ; i := 0 ; while i < 25 - day do ( (     OclFile["System.out"].print(" Eve") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int a=Integer.parseInt(sc.next());
    String message="" ;
    for(int i=0 ; i<25-a ; i++){
      message+=" Eve" ;
    }
    System.out.println("Christmas"+message);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := (sc.getCurrent())->toInteger() ;
    var message : String ; message := "" ;
        var i : int ; i := 0 ; while i < 25 - a do ( (     message := message+(" Eve") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Christmas" + message) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Kayaking {
  public static void main(String[] args)throws FileNotFoundException {
    File f=new File("Kayaking.in");
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] weights=new int[2*n];
    for(int x=0 ; x<2*n ; x++){
      weights[x]=sc.nextInt();
    }
    Arrays.sort(weights);
    int first=-1 ;
    int sum=0 ;
    int last=weights[2*n-1];
    for(int x=0 ; x<2*n ; x++){
      for(int y=x+1 ; y<2*n ; y++){
        first=-1 ;
        sum=0 ;
        for(int z=0 ; z<2*n ; z++){
          if(z==x || z==y){
            continue ;
          }
          if(first==-1){
            first=weights[z];
          }
          else {
            sum=sum+(weights[z]-first);
            first=-1 ;
          }
        }
        last=Math.min(sum,last);
      }
    }
    System.out.println(last);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Kayaking {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile("Kayaking.in") ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var weights : Sequence(int) ; weights := Integer.subrange(1,2 * n)->collect(0) ;
        var x : int ; x := 0 ; while x < 2 * n do ( (     weights[x+1] := sc.getCurrent()->toInteger() )  ;     x := x + 1 ) ; 
    weights := weights->sort() ; 
    var first : int ; first := -1 ;
    var sum : int ; sum := 0 ;
    var last : int ; last := weights[2 * n - 1+1] ;
        var x : int ; x := 0 ; while x < 2 * n do ( (         var y : int ; y := x + 1 ; while y < 2 * n do ( (     first := -1 ; 
     sum := 0 ; 
         var z : int ; z := 0 ; while z < 2 * n do ( (     if (z = x or z = y) then (     continue ) else skip ; 
     if (first = -1) then (     first := weights[z+1] ) else (     sum := sum + (weights[z+1] - first) ; 
     first := -1 ) )  ;     z := z + 1 ) ; 
     last := Set{sum, last}->min() )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println(last) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class B863 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=2*in.nextInt();
    int[] W=new int[N];
    for(int n=0 ; n<N ; n++){
      W[n]=in.nextInt();
    }
    Arrays.sort(W);
    int min=Integer.MAX_VALUE ;
    for(int x=0 ; x<N ; x++){
      for(int y=x+1 ; y<N ; y++){
        int pos=0 ;
        int sum=0 ;
        for(int n=1 ; n<N/2 ; n++){
          if(pos==x)pos++;
          if(pos==y)pos++;
          int light=W[pos++];
          if(pos==x)pos++;
          if(pos==y)pos++;
          int heavy=W[pos++];
          sum+=heavy-light ;
        }
        min=Math.min(min,sum);
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B863 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := 2 * in.getCurrent()->toInteger() ;
    var W : Sequence(int) ; W := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     W[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    W := W->sort() ; 
    var min : int ; min := 2147483647 ;
        var x : int ; x := 0 ; while x < N do ( (         var y : int ; y := x + 1 ; while y < N do ( (     var pos : int ; pos := 0 ;
     var sum : int ; sum := 0 ;
         var n : int ; n := 1 ; while n < N / 2 do ( (     if (pos = x) then     pos := pos + 1 ; else skip ; 
     if (pos = y) then     pos := pos + 1 ; else skip ; 
    var light : int ; light := W[pos+1] ;
    if (pos = x) then     pos := pos + 1 ; else skip ; 
    if (pos = y) then     pos := pos + 1 ; else skip ; 
    var heavy : int ; heavy := W[pos+1] ;
    sum := sum+(heavy - light) ; 
 )  ;     n := n + 1 ) ; 
     min := Set{min, sum}->min() )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF_Kayaking {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
    int n=Integer.parseInt(in.readLine());
    int[] w=new int[2*n];
    String[] data=in.readLine().split(" ");
    for(int i=0 ; i<2*n ; ++i)w[i]=Integer.parseInt(data[i]);
    Arrays.sort(w);
    int diff=0 ;
    int res=Integer.MAX_VALUE ;
    boolean[] blocked=new boolean[2*n];
    int a=-1,b=-1 ;
    for(int A=0 ; A<2*n ; ++A){
      for(int B=A+1 ; B<2*n ; ++B){
        diff=0 ;
        blocked[A]=true ;
        blocked[B]=true ;
        for(int j=0,k=0 ; j<2*n ; ++j){
          if(blocked[j])continue ;
          if(k % 2==0){
            a=w[j];
          }
          else {
            b=w[j];
            diff+=(b-a);
          }
++k ;
        }
        res=Math.min(res,diff);
        blocked[A]=false ;
        blocked[B]=false ;
      }
    }
    out.write(res+"");
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF_Kayaking {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := (in.readLine())->toInteger() ;
    var w : Sequence(int) ; w := Integer.subrange(1,2 * n)->collect(0) ;
    var data : Sequence(String) ; data := in.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < 2 * n do (     w[i+1] := (data[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    w := w->sort() ; 
    var diff : int ; diff := 0 ;
    var res : int ; res := 2147483647 ;
    var blocked : Sequence(boolean) ; blocked := Integer.subrange(1,2 * n)->collect(false) ;
    var a : int ; a := -1 ;
    var b : int ; b := -1 ;
        var A : int ; A := 0 ; while A < 2 * n do ( (         var B : int ; B := A + 1 ; while B < 2 * n do ( (     diff := 0 ; 
     blocked[A+1] := true ; 
    blocked[B+1] := true ; 
        var j : int ; j := 0 ;
    var k : int ; k := 0 ; while j < 2 * n do ( (     if (blocked[j+1]) then     continue else skip ; 
     if (k mod 2 = 0) then (     a := w[j+1] ) else (     b := w[j+1] ; 
     diff := diff+((b - a)) ) ;  
     k := k + 1 )  ;     j := j + 1 ) ; 
    res := Set{res, diff}->min() ; 
    blocked[A+1] := false ; 
    blocked[B+1] := false ; 
 )  ;     B := B + 1 ) )  ;     A := A + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void knowPair(int a,int b,int n,int s,int m){
    int i=0,rem=0 ;
    int count_b=0,flag=0 ;
    while(i<=a){
      rem=s-(n*i);
      count_b=rem/m ;
      if(rem % m==0 && count_b<=b){
        flag=1 ;
      }
      i++;
    }
    if(flag==1){
      System.out.print("YES"+"\n");
    }
    else {
      System.out.print("NO"+"\n");
    }
  }
  public static void main(String[] args){
    int A=1 ;
    int B=2 ;
    int n=3 ;
    int S=4 ;
    int m=2 ;
    knowPair(A,B,n,S,m);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation knowPair( a : int, b : int, n : int, s : int, m : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var rem : int ; rem := 0 ;
     var count_b : int ; count_b := 0 ;
    var flag : int ; flag := 0 ;
     while (i <= a) do (     rem := s - (n * i) ; 
     count_b := rem / m ; 
     if (rem mod m = 0 & count_b <= b) then (     flag := 1 ) else skip ; 
     i := i + 1 ) ; 
     if (flag = 1) then (     OclFile["System.out"].print("YES" + "\n") ) else (     OclFile["System.out"].print("NO" + "\n") ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 1 ;
     var B : int ; B := 2 ;
    var n : int ; n := 3 ;
    var S : int ; S := 4 ;
    var m : int ; m := 2 ;
    execute knowPair(A, B, n, S, m) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  static boolean mark[];
  static int a[];
  static int n ;
  public static void main(String[] args){
    n=scanner.nextInt();
    a=new int[n];
    int b[]=new int[n];
    mark=new boolean[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scanner.nextInt()-1 ;
    }
    int sum=0 ;
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      b[i]=scanner.nextInt();
      sum+=b[i];
    }
    if(sum % 2==0){
      ans=1 ;
    }
    int low=sDFS();
    if(low==1){
      System.out.println(ans);
      return ;
    }
    System.out.println(low+ans);
  }
  private static int sDFS(){
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(! mark[i]){
        sum++;
        DFS(i);
      }
    }
    return sum ;
  }
  private static void DFS(int x){
    mark[x]=true ;
    if(! mark[a[x] ]){
      DFS(a[x]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute mark : Sequence(boolean);
  static   attribute a : Sequence(int);
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := scanner.getCurrent()->toInteger() ; 
     a := Integer.subrange(1,n)->collect(0) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    mark := Integer.subrange(1,n)->collect(false) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() - 1 )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := scanner.getCurrent()->toInteger() ; 
     sum := sum+(b[i+1]) )  ;     i := i + 1 ) ; 
    if (sum mod 2 = 0) then (     ans := 1 ) else skip ; 
    var low : int ; low := sDFS() ;
    if (low = 1) then (     OclFile["System.out"].println(ans) ; 
     return ) else skip ; 
    OclFile["System.out"].println(low + ans) ; 
 );
  static   operation sDFS() : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (not(mark[i+1])) then (     sum := sum + 1 ; 
     execute DFS(i) ) else skip )  ;     i := i + 1 ) ; 
     return sum );
  static   operation DFS( x : int) : void
  pre: true
  post: true
  activity: (     mark[x+1] := true ; 
     if (not(mark[a[x+1]+1])) then (     execute DFS(a[x+1]) ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class PavelAndBarbeque {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sc.nextLine();
    int[] perm=Arrays.stream(sc.nextLine().split(" ")).mapToInt(x->Integer.parseInt(x)).toArray();
    int bCount=Arrays.stream(sc.nextLine().split(" ")).mapToInt(x->Integer.parseInt(x)).sum();
    sc.close();
    int changesNeeded=(bCount+1)% 2 ;
    int[] loop=new int[perm.length];
    int loopsFound=0 ;
    for(int i=0 ; i<loop.length ; i++){
      if(loop[i]==0){
        loopsFound++;
        loop[i]=loopsFound ;
        int nextEl=perm[i]-1 ;
        while(nextEl!=i){
          loop[nextEl]=loopsFound ;
          nextEl=perm[nextEl]-1 ;
        }
      }
    }
    if(loopsFound!=1){
      changesNeeded+=loopsFound ;
    }
    System.out.println(changesNeeded);
  }
}
------------------------------------------------------------
OCL File:
---------
 class PavelAndBarbeque {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var perm : Sequence(int) ; perm := stream(sc.nextLine()->split(" "))->collect( _x1 | (lambda x : OclAny in (x)->toInteger())->apply(_x1) )->asSequence() ;
    var bCount : int ; bCount := stream(sc.nextLine()->split(" "))->collect( _x1 | (lambda x : OclAny in (x)->toInteger())->apply(_x1) )->sum() ;
    skip ; 
    var changesNeeded : int ; changesNeeded := (bCount + 1) mod 2 ;
    var loop : Sequence(int) ; loop := Integer.subrange(1,perm->size())->collect(0) ;
    var loopsFound : int ; loopsFound := 0 ;
        var i : int ; i := 0 ; while i < loop->size() do ( (     if (loop[i+1] = 0) then (     loopsFound := loopsFound + 1 ; 
     loop[i+1] := loopsFound ; 
     var nextEl : int ; nextEl := perm[i+1] - 1 ;
     while (nextEl /= i) do (     loop[nextEl+1] := loopsFound ; 
     nextEl := perm[nextEl+1] - 1 ) ) else skip )  ;     i := i + 1 ) ; 
    if (loopsFound /= 1) then (     changesNeeded := changesNeeded+(loopsFound) ) else skip ; 
    OclFile["System.out"].println(changesNeeded) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedWriter ;
import java.io.File ;
import java.io.FileWriter ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class c {
  public static void main(String[] Args)throws Exception {
    Scanner sc=new Scanner(new File("C-large.in"));
    PrintWriter out=new PrintWriter(new BufferedWriter(new FileWriter(new File("c.out"))));
    int cc=0 ;
    int t=sc.nextInt();
    while(t-->0){
      long n=sc.nextLong();
      long pos=sc.nextLong();
      int dep=0 ;
      long v=0 ;
      while(pos>((v<<1)| 1)){
        v=((v<<1)| 1);
        dep++;
      }
      n-=v ;
      pos-=v+1 ;
      v++;
      if(n % v>pos)n=n/v+1 ;
      else n=n/v ;
      out.printf("Case #%d: %d %d%n",++cc,n>>1,(n-1)>>1);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class c {
  static   operation main( Args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile("C-large.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile("c.out")))) ;
    var cc : int ; cc := 0 ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := sc.getCurrent()->toLong() ;
     var pos : long ; pos := sc.getCurrent()->toLong() ;
    var dep : int ; dep := 0 ;
    var v : long ; v := 0 ;
    while (pos > (((v*(2->pow(1)))->oclAsType(long)) or 1)) do (     v := (((v*(2->pow(1)))->oclAsType(long)) or 1) ; 
     dep := dep + 1 ) ; 
    n := n-(v) ; 
    pos := pos-(v + 1) ; 
    v := v + 1 ; 
    if (n mod v > pos) then     n := n / v + 1 else     n := n / v ; ;  
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class binary_removal {
  static void remove(String s){
    int one=0 ;
    int zero=0 ;
    for(int i=1 ; i<s.length(); i++){
      if(s.charAt(i)=='1'){
        if(s.charAt(i-1)=='1')one++;
      }
      else {
        if(s.charAt(i-1)=='0' && one>0){
          System.out.println("No");
          return ;
        }
      }
    }
    System.out.println("YES");
  }
  public static void main(String[] args){
    FastReader in=new FastReader();
    FastWriter out=new FastWriter();
    int test=in.nextInt();
    while(test-->0){
      String s=in.nextLine();
      remove(s);
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        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().trim();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  static class FastWriter {
    private final BufferedWriter bw ;
    public FastWriter(){
      this.bw=new BufferedWriter(new OutputStreamWriter(System.out));
    }
    public void print(Object object)throws IOException {
      bw.append(""+object);
    }
    public void println(Object object)throws IOException {
      print(object);
      bw.append("\n");
    }
    public void close()throws IOException {
      bw.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class binary_removal {
  static   operation remove( s : String) : void
  pre: true
  post: true
  activity: (     var one : int ; one := 0 ;
     var zero : int ; zero := 0 ;
         var i : int ; i := 1 ; while i < s->size() do ( (     if (s->at(i+1) = '1') then (     if (s->at(i - 1+1) = '1') then     one := one + 1 ; else skip ) else (     if (s->at(i - 1+1) = '0' & one > 0) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("YES") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : FastWriter ; out := FastWriter.newFastWriter() ;
     var test : int ; test := in.nextInt() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var s : String ; s := in.nextLine() ;
     execute remove(s) ) ;  ) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine()->trim() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return str );
}
  static class FastWriter {
   attribute bw : OclFile;
   static operation newFastWriter() : FastWriter
  pre: true
  post: true
  activity:
  ( var self : FastWriter ;
    self := createFastWriter();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) );
   operation print( object : OclAny) : void
  pre: true
  post: true
  activity: (     skip );
   operation println( object : OclAny) : void
  pre: true
  post: true
  activity: (     execute print(object) ; 
     skip );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int i,j=0 ;
    int falg=1 ;
    int b[]=new int[n-1];
    int a[]=new int[n-1];
    for(i=0 ; i<n ; i++){
      int x ;
      x=in.nextInt();
      if(x==0){
        continue ;
      }
      a[j++]=x ;
    }
    int pos=0 ;
    j=0 ;
    for(i=0 ; i<n ; i++){
      int x ;
      x=in.nextInt();
      if(x==0)continue ;
      b[j++]=x ;
      if(x==a[0]){
        pos=j-1 ;
      }
    }
    for(i=0 ; i<n-1 ; i++){
      if(a[i]!=b[(i+pos)%(n-1)])falg=0 ;
    }
    if(falg==1)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var i : int ;
    var j : int ; j := 0 ;
    var falg : int ; falg := 1 ;
    var b : Sequence(int) ; b := Integer.subrange(1,n - 1)->collect(0) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n - 1)->collect(0) ;
        i := 0 ; while i < n do ( (     var x : int ;
     x := in.getCurrent()->toInteger() ; 
     if (x = 0) then (     continue ) else skip ; 
      a[j+1] := x  ; j := j + 1 )  ;     i := i + 1 ) ; 
    var pos : int ; pos := 0 ;
    j := 0 ; 
        i := 0 ; while i < n do ( (     var x : int ;
     x := in.getCurrent()->toInteger() ; 
    if (x = 0) then     continue else skip ; 
     b[j+1] := x  ; j := j + 1 ; 
    if (x = a[0+1]) then (     pos := j - 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n - 1 do ( (     if (a[i+1] /= b[(i + pos) mod (n - 1)+1]) then     falg := 0 ; else skip )  ;     i := i + 1 ) ; 
    if (falg = 1) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package zhang00000 ;
import com.sun.tools.javac.jvm.Code ;
import org.apache.commons.math3.complex.Complex ;
import java.io.*;
import java.util.*;
import java.util.stream.*;
import static java.util.stream.Collectors.*;
public class App {
  final int di[]={
    1,-1,0,0,1,-1,1,-1 };
    final int dj[]={
      0,0,1,-1,1,-1,-1,1 };
      final int diK[]={
-2,-2,-1,1,2,2,1,-1 };
        final int djK[]={
-1,1,2,2,1,-1,-2,-2 };
          public static void main(String[] args){
            if(args.length==1){
              String filename="src/main/java/zhang00000/"+args[0]+".in" ;
              if(! filename.isEmpty())try {
                System.setIn(new FileInputStream(filename));
              }
              catch(FileNotFoundException e){
                System.out.println(e.getMessage());
                System.exit(1);
              }
            }
            Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
            int t=Integer.valueOf(in.nextLine());
            for(int number=1 ; number<=t ; number++){
              long n=in.nextLong();
              long k=in.nextLong();
              int d=Long.toBinaryString(k).length()-1 ;
              long prev=(n-k+Long.highestOneBit(k))>>d ;
              long max=prev/2 ;
              long min=(prev-1)/2 ;
              System.out.println("Case #"+number+": "+max+" "+min);
            }
          }
        }

------------------------------------------------------------
OCL File:
---------
 class App {
   attribute di : int := Sequence{1,-1,0,0,1,-1,1,-1};
   attribute dj : int := Sequence{0,0,1,-1,1,-1,-1,1};
   attribute diK : int := Sequence{-2,-2,-1,1,2,2,1,-1};
   attribute djK : int := Sequence{-1,1,2,2,1,-1,-2,-2};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (args->size() = 1) then (     var filename : String ; filename := "src/main/java/zhang00000/" + args[0+1] + ".in" ;
     if (not(filename->isEmpty())) then     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile(filename))) )   catch (e : FileNotFoundException) do (     OclFile["System.out"].println(e.getMessage()) ; 
 OclProcess.exit(1) )
 else skip ) else skip ; 
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var t : int ; t := (in.nextLine())->toInteger() ;
         var number : int ; number := 1 ; while number <= t do ( (     var n : long ; n := in.getCurrent()->toLong() ;
     var k : long ; k := in.getCurrent()->toLong() ;
    var d : int ; d := (MathLib.decimal2binary(k) + "")->size() - 1 ;
    var prev : long ; prev := ((n - k + highestOneBit(k))/(2->pow(d)))->oclAsType(long) ;
    var max : long ; max := prev / 2 ;
    var min : long ; min := (prev - 1) / 2 ;
    OclFile["System.out"].println("Case #" + number + ": " + max + " " + min) ; 
 )  ;     number := number + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static long[] solve(long N,long K){
    if(K==1){
      long[] arr=new long[2];
      arr[0]=N/2 ;
      arr[1]=(N-1)/2 ;
      return arr ;
    }
    if(K % 2==0){
      return solve(N/2,K/2);
    }
    return solve((N-1)/2,K/2);
  }
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new FileReader("C-large.in"));
    BufferedWriter bw=new BufferedWriter(new FileWriter("solve.txt"));
    int T=Integer.parseInt(br.readLine().trim());
    StringTokenizer s ;
    for(int i=1 ; i<=T ; i++){
      bw.write("Case #"+i+": ");
      s=new StringTokenizer(br.readLine().trim());
      long N=Long.parseLong(s.nextToken());
      long K=Long.parseLong(s.nextToken());
      long[] arr=solve(N,K);
      bw.write(arr[0]+" "+arr[1]+"\n");
    }
    br.close();
    bw.close();
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( N : long, K : long) : Sequence(long)
  pre: true
  post: true
  activity: (     if (K = 1) then (     var arr : Sequence(long) ; arr := Integer.subrange(1,2)->collect(0) ;
     arr[0+1] := N / 2 ; 
     arr[1+1] := (N - 1) / 2 ; 
     return arr ) else skip ; 
     if (K mod 2 = 0) then (     return solve(N / 2, K / 2) ) else skip ; 
     return solve((N - 1) / 2, K / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("C-large.in"))) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("solve.txt"))) ;
    var T : int ; T := (br.readLine()->trim())->toInteger() ;
    var s : OclIterator ;
        var i : int ; i := 1 ; while i <= T do ( (     skip ; 
     s := OclIterator.newOclIterator_String(br.readLine()->trim()) ; 
    var N : long ; N := (s.next())->toLong() ;
    var K : long ; K := (s.next())->toLong() ;
    var arr : Sequence(long) ; arr := solve(N, K) ;
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Map ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int testCount=in.nextInt();
    for(int testNo=1 ; testNo<=testCount ; testNo++){
      solve(testNo,in);
    }
  }
  private static void solve(int testNo,Scanner in){
    long n=in.nextLong();
    long k=in.nextLong();
    System.out.println("Case #"+testNo+": "+calc(n,k));
  }
  private static String calc(long n,long k){
    TreeMap<Long,Long>treeMap=new TreeMap<>();
    treeMap.put(n,1L);
    while(k>0){
      Map.Entry<Long,Long>entry=treeMap.lastEntry();
      treeMap.remove(entry.getKey());
      if(k<=entry.getValue()){
        return entry.getKey()/2+" "+(entry.getKey()-1)/2 ;
      }
      else {
        k-=entry.getValue();
        if(entry.getKey()/2>0){
          long key=entry.getKey()/2 ;
          treeMap.put(key,treeMap.getOrDefault(key,0L)+entry.getValue());
        }
        if((entry.getKey()-1)/2>0){
          long key=(entry.getKey()-1)/2 ;
          treeMap.put(key,treeMap.getOrDefault(key,0L)+entry.getValue());
        }
      }
    }
    throw new RuntimeException();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCount : int ; testCount := in.getCurrent()->toInteger() ;
         var testNo : int ; testNo := 1 ; while testNo <= testCount do ( (     execute solve(testNo, in) )  ;     testNo := testNo + 1 ) );
  static   operation solve( testNo : int, in : OclFile) : void
  pre: true
  post: true
  activity: (     var n : long ; n := in.getCurrent()->toLong() ;
     var k : long ; k := in.getCurrent()->toLong() ;
     OclFile["System.out"].println("Case #" + testNo + ": " + calc(n, k)) );
  static   operation calc( n : long, k : long) : String
  pre: true
  post: true
  activity: (     var treeMap : Map(long,long) ; treeMap := Map{} ;
     treeMap := treeMap->union(Map{n |-> 1L}) ; 
     while (k > 0) do (     var entry : Map(long,long) ; entry := treeMap.lastEntry() ;
     treeMap := treeMap->antirestrict(Set{entry->keys()->any()}) ; 
     if (k <= entry->values->any()) then (     return entry->keys()->any() / 2 + " " + (entry->keys()->any() - 1) / 2 ) else (     k := k-(entry->values->any()) ; 
     if (entry->keys()->any() / 2 > 0) then (     var key : long ; key := entry->keys()->any() / 2 ;
     treeMap := treeMap->union(Map{key |-> (if treeMap->keys()->contains(key) then treeMap->at(key) else 0L endif) + entry->values->any()}) ) else skip ; 
     if ((entry->keys()->any() - 1) / 2 > 0) then (     var key : long ; key := (entry->keys()->any() - 1) / 2 ;
     treeMap := treeMap->union(Map{key |-> (if treeMap->keys()->contains(key) then treeMap->at(key) else 0L endif) + entry->values->any()}) ) else skip ) ) ; 
     error ProgramException() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String reverseWord(String str){
    int len=str.length();
    int i=1 ;
    int j=str.length()-2 ;
    char[] strchar=str.toCharArray();
    while(i<j){
      char temp=strchar[i];
      strchar[i]=strchar[j];
      strchar[j]=temp ;
      i++;
      j--;
    }
    str=new String(strchar);
    return str ;
  }
  static void reverseWords(String str){
    String[] tok=str.split("\\s");
    for(String w : tok){
      System.out.print(reverseWord(w)+" ");
    }
  }
  public static void main(String[] args){
    String str="geeks for geeks" ;
    reverseWords(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation reverseWord( str : String) : String
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     var i : int ; i := 1 ;
    var j : int ; j := str->size() - 2 ;
    var strchar : Sequence(String) ; strchar := str->characters() ;
    while (i < j) do (     var temp : String ; temp := strchar[i+1] ;
     strchar[i+1] := strchar[j+1] ; 
    strchar[j+1] := temp ; 
    i := i + 1 ; 
    j := j - 1 ; 
 ) ; 
    str := StringLib.newString(strchar) ; 
    return str 
 );
  static   operation reverseWords( str : String) : void
  pre: true
  post: true
  activity: (     var tok : Sequence(String) ; tok := str->split("\\s") ;
     for (w : tok) do ( (     OclFile["System.out"].print(reverseWord(w) + " ") )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeks for geeks" ;
     execute reverseWords(str) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int xorLessK(int arr[],int n,int k){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int tempXor=0 ;
      for(int j=i ; j<n ; j++){
        tempXor ^=arr[j];
        if(tempXor<k)count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int k=3 ;
    int arr[]=new int[] {
      8,9,10,11,12 };
      int n=arr.length ;
      System.out.println(xorLessK(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation xorLessK( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var tempXor : int ; tempXor := 0 ;
         var j : int ; j := i ; while j < n do ( (     tempXor := MathLib.bitwiseXor(tempXor,arr[j+1]) ; 
     if (tempXor < k) then     count := count + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 3 ;
     var arr : Sequence(int) ; arr := Sequence{8,9,10,11,12} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(xorLessK(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printOrder(int[] arr,int n,int k){
    int len1=k,len2=n-k ;
    int[] arr1=new int[k];
    int[] arr2=new int[n-k];
    for(int i=0 ; i<k ; i++)arr1[i]=arr[i];
    for(int i=k ; i<n ; i++)arr2[i-k]=arr[i];
    Arrays.sort(arr1,0,k);
    Arrays.sort(arr2,k,n-k);
    for(int i=0 ; i<n ; i++){
      if(i<k)arr[i]=arr1[i];
      else {
        arr[i]=arr2[len2-1];
        len2--;
      }
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(arr[i]+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      5,4,6,2,1,3,8,9,-1 };
      int k=4 ;
      int n=arr.length ;
      printOrder(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printOrder( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var len1 : int ; len1 := k ;
    var len2 : int ; len2 := n - k ;
     var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,k)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,n - k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do (     arr1[i+1] := arr[i+1] ;  ;     i := i + 1 ) ; 
        var i : int ; i := k ; while i < n do (     arr2[i - k+1] := arr[i+1] ;  ;     i := i + 1 ) ; 
    arr1 := arr1.subrange(1,0)^(arr1.subrange(0+1,k)->sort())^arr1.subrange(k+1,arr1.size) ; 
    arr2 := arr2.subrange(1,k)^(arr2.subrange(k+1,n - k)->sort())^arr2.subrange(n - k+1,arr2.size) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i < k) then     arr[i+1] := arr1[i+1] ; else (     arr[i+1] := arr2[len2 - 1+1] ; 
     len2 := len2 - 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,4,6,2,1,3,8,9,-1} ;
     var k : int ; k := 4 ;
     var n : int ; n := arr->size() ;
     execute printOrder(arr, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
import java.time.ZonedDateTime ;
import java.time.format.DateTimeFormatter ;
import java.time.format.DateTimeFormatterBuilder ;
import java.time.temporal.ChronoUnit ;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static long mod ;
  static long d ;
  static long mod_mul(long a,long b){
    a=a % mod ;
    b=b % mod ;
    return(((a*b)% mod)+mod)% mod ;
  }
  static long mod_add(long a,long b){
    a=a % mod ;
    b=b % mod ;
    return(((a+b)% mod)+mod)% mod ;
  }
  static void solve(){
    int k=(int)(Math.log(d)/Math.log(2));
    int cnt=0 ;
    long ans=1 ;
    int i=0 ;
    while(i<k){
      long cur=(1<<i)+1 ;
      ans=mod_mul(ans,cur);
      i++;
    }
    long cur=d-(1<<k)+1 ;
    ans=mod_mul(ans,cur+1);
    str.append((ans-1+mod)% mod).append("\n");
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    int q=Integer.parseInt(bf.readLine().trim());
    while(q-->0){
      String s[]=bf.readLine().trim().split("\\s+");
      d=Long.parseLong(s[0]);
      mod=Long.parseLong(s[1]);
      solve();
    }
    pw.println(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute mod : long;
  static   attribute d : long;
  static   operation mod_mul( a : long, b : long) : long
  pre: true
  post: true
  activity: (     a := a mod mod ; 
     b := b mod mod ; 
     return (((a * b) mod mod) + mod) mod mod );
  static   operation mod_add( a : long, b : long) : long
  pre: true
  post: true
  activity: (     a := a mod mod ; 
     b := b mod mod ; 
     return (((a + b) mod mod) + mod) mod mod );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var k : int ; k := ((d)->log() / (2)->log())->oclAsType(int) ;
     var cnt : int ; cnt := 0 ;
    var ans : long ; ans := 1 ;
    var i : int ; i := 0 ;
    while (i < k) do (     var cur : long ; cur := ((1*(2->pow(i)))->oclAsType(long)) + 1 ;
     ans := mod_mul(ans, cur) ; 
     i := i + 1 ) ; 
    var cur : long ; cur := d - ((1*(2->pow(k)))->oclAsType(long)) + 1 ;
    ans := mod_mul(ans, cur + 1) ; 
    str := str + StringLib.newString((ans - 1 + mod) mod mod) + StringLib.newString("\n") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var q : int ; q := (bf.readLine()->trim())->toInteger() ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     var s : Sequence(String) ; s := bf.readLine()->trim()->split("\\s+") ;
     d := (s[0+1])->toLong() ; 
     mod := (s[1+1])->toLong() ; 
     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class AQRQ {
  static int minSum(int a[],int n){
    Arrays.sort(a);
    int num1=0 ;
    int num2=0 ;
    for(int i=0 ; i<n ; i++){
      if(i % 2==0)num1=num1*10+a[i];
      else num2=num2*10+a[i];
    }
    return num2+num1 ;
  }
  public static void main(String[] args){
    int arr[]={
      5,3,0,7,4 };
      int n=arr.length ;
      System.out.println("The required sum is  "+minSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class AQRQ {
  static   operation minSum( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var num1 : int ; num1 := 0 ;
    var num2 : int ; num2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then     num1 := num1 * 10 + a[i+1] ; else     num2 := num2 * 10 + a[i+1] ; )  ;     i := i + 1 ) ; 
    return num2 + num1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,3,0,7,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("The required sum is  " + minSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int maxZeros(int N){
    int maxm=-1 ;
    int cnt=0 ;
    while(N!=0){
      if((N & 1)==0){
        cnt++;
        N>>=1 ;
        maxm=Math.max(maxm,cnt);
      }
      else {
        maxm=Math.max(maxm,cnt);
        cnt=0 ;
        N>>=1 ;
      }
    }
    return maxm ;
  }
  public static void main(String args[]){
    int N=14 ;
    System.out.println(maxZeros(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxZeros( N : int) : int
  pre: true
  post: true
  activity: (     var maxm : int ; maxm := -1 ;
     var cnt : int ; cnt := 0 ;
     while (N /= 0) do (     if ((N & 1) = 0) then (     cnt := cnt + 1 ; 
     N := N/(2->pow(1)) ; 
     maxm := Set{maxm, cnt}->max() ) else (     maxm := Set{maxm, cnt}->max() ; 
     cnt := 0 ; 
     N := N/(2->pow(1)) ) ) ; 
     return maxm );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 14 ;
     OclFile["System.out"].println(maxZeros(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    double W=0 ;
    double H=0 ;
    double x=0 ;
    double y=0 ;
    Scanner sc=new Scanner(System.in);
    W=Integer.parseInt(sc.next());
    H=Integer.parseInt(sc.next());
    x=Integer.parseInt(sc.next());
    y=Integer.parseInt(sc.next());
    int flag=0 ;
    if(W/2==x && H/2==y)flag=1 ;
    System.out.println(W*H/2+" "+flag);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var W : double ; W := 0 ;
     var H : double ; H := 0 ;
    var x : double ; x := 0 ;
    var y : double ; y := 0 ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    W := (sc.getCurrent())->toInteger() ; 
    H := (sc.getCurrent())->toInteger() ; 
    x := (sc.getCurrent())->toInteger() ; 
    y := (sc.getCurrent())->toInteger() ; 
    var flag : int ; flag := 0 ;
    if (W / 2 = x & H / 2 = y) then     flag := 1 ; else skip ; 
    OclFile["System.out"].println(W * H / 2 + " " + flag) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    boolean ju=true ;
    long[] c=new long[n];
    long[] r=new long[n];
    for(int i=0 ; i<n ; i++){
      c[i]=scan.nextLong();
    }
    for(int i=0 ; i<n ; i++){
      r[i]=scan.nextLong();
    }
    int cs=0,rs=0 ;
    if(r[rs]==0){
      rs=1 ;
    }
    for(int i=0 ; i<n ; i++){
      if(c[i]==r[rs])cs=i ;
    }
    block : for(int i=0 ;
    i<n+2 ;
    i++){
      cs=(cs+1)% n ;
      rs=(rs+1)% n ;
      if(c[cs]==0){
        rs--;
        continue block ;
      }
      if(r[rs]==0){
        cs--;
        continue block ;
      }
      if(c[cs]!=r[rs]){
        ju=false ;
        break block ;
      }
    }
    if(ju)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var ju : boolean ; ju := true ;
    var c : Sequence(long) ; c := Integer.subrange(1,n)->collect(0) ;
    var r : Sequence(long) ; r := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := scan.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     r[i+1] := scan.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var cs : int ; cs := 0 ;
    var rs : int ; rs := 0 ;
    if (r[rs+1] = 0) then (     rs := 1 ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     if (c[i+1] = r[rs+1]) then     cs := i ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n + 2 do ( (     cs := (cs + 1) mod n ; 
     rs := (rs + 1) mod n ; 
    if (c[cs+1] = 0) then (     rs := rs - 1 ; 
     continue ) else skip ; 
    if (r[rs+1] = 0) then (     cs := cs - 1 ; 
     continue ) else skip ; 
    if (c[cs+1] /= r[rs+1]) then (     ju := false ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (ju) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CRectangleCutting solver=new CRectangleCutting();
    solver.solve(1,in,out);
    out.close();
  }
  static class CRectangleCutting {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      long w=in.nextLong(),h=in.nextLong();
      long x=in.nextLong(),y=in.nextLong();
      double answer=((double)(w*h))/2 ;
      boolean ways=2*x==w && 2*y==h ;
      out.format("%f %d%n",answer,ways ? 1 : 0);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CRectangleCutting ; solver := CRectangleCutting.newCRectangleCutting() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CRectangleCutting {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var w : long ; w := in.nextLong() ;
    var h : long ; h := in.nextLong() ;
     var x : long ; x := in.nextLong() ;
    var y : long ; y := in.nextLong() ;
    var answer : double ; answer := ((w * h)->oclAsType(double)) / 2 ;
    var ways : boolean ; ways := 2 * x = w & 2 * y = h ;
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  static final Scanner sc=new Scanner(System.in);
  static final PrintStream so=System.out ;
  public static void main(String[] args){
    long W=nl();
    long H=nl();
    long x=nl();
    long y=nl();
    so.print((double)(W*H)/2);
    so.print(" ");
    so.println(x*2==W && y*2==H ? 1 : 0);
  }
  private static int ni(){
    return sc.nextInt();
  }
  private static long nl(){
    return sc.nextLong();
  }
  private static String ns(){
    return sc.next();
  }
  private static char[] nsToChars(){
    return sc.next().toCharArray();
  }
  private static long[] nlongs(int n){
    return nlongs(n,0);
  }
  private static long[] nlongs(int n,int padding){
    long[] a=new long[padding+n];
    for(int i=0 ; i<n ; i++)a[padding+i]=ni();
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute so : OclFile := OclFile["System.out"];
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var W : long ; W := nl() ;
     var H : long ; H := nl() ;
    var x : long ; x := nl() ;
    var y : long ; y := nl() ;
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
  static   operation nl() : long
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toLong() );
  static   operation ns() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
  static   operation nsToChars() : Sequence(String)
  pre: true
  post: true
  activity: (     return sc.getCurrent()->characters() );
  static   operation nlongs( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     return nlongs(n, 0) );
  static   operation nlongs( n : int, padding : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,padding + n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[padding + i+1] := ni() ;  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.math.BigDecimal ;
import java.math.RoundingMode ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int w=in.nextInt();
    int h=in.nextInt();
    int x=in.nextInt();
    int y=in.nextInt();
    System.out.print(new BigDecimal(Integer.valueOf(w)).multiply(new BigDecimal(Integer.valueOf(h)).divide(new BigDecimal("2"),6,RoundingMode.CEILING)));
    System.out.print(" ");
    if(x*2==w && y*2==h){
      System.out.print(1);
    }
    else {
      System.out.print(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var w : int ; w := in.getCurrent()->toInteger() ;
    var h : int ; h := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
    var y : int ; y := in.getCurrent()->toInteger() ;
    OclFile["System.out"].print(double((w)->toInteger()).multiply(double((h)->toInteger()).divide(double("2"), 6, RoundingMode.CEILING))) ; 
    OclFile["System.out"].print(" ") ; 
    if (x * 2 = w & y * 2 = h) then (     OclFile["System.out"].print(1) ) else (     OclFile["System.out"].print(0) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    double W=input.nextDouble();
    double H=input.nextDouble();
    double x=input.nextDouble();
    double y=input.nextDouble();
    double A=W*H ;
    A/=2 ;
    int ways=0 ;
    if(x==W/2 && y==H/2)ways++;
    System.out.println(A+" "+ways);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var W : double ; W := input.getCurrent()->toReal() ;
    var H : double ; H := input.getCurrent()->toReal() ;
    var x : double ; x := input.getCurrent()->toReal() ;
    var y : double ; y := input.getCurrent()->toReal() ;
    var A : double ; A := W * H ;
    A := A/(2) ; 
    var ways : int ; ways := 0 ;
    if (x = W / 2 & y = H / 2) then     ways := ways + 1 ; else skip ; 
    OclFile["System.out"].println(A + " " + ways) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean check(String str){
    int n=str.length();
    if(n==0 && n==1)return false ;
    if(n==2)return(((str.charAt(n-2)-'0')*10+(str.charAt(n-1)-'0'))% 16==0);
    if(n==3)return(((str.charAt(n-3)-'0')*100+(str.charAt(n-2)-'0')*10+(str.charAt(n-1)-'0'))% 16==0);
    int last=str.charAt(n-1)-'0' ;
    int second_last=str.charAt(n-2)-'0' ;
    int third_last=str.charAt(n-3)-'0' ;
    int fourth_last=str.charAt(n-4)-'0' ;
    return((fourth_last*1000+third_last*100+second_last*10+last)% 16==0);
  }
  public static void main(String args[]){
    String str="769528" ;
    if(check(str))System.out.println("Yes");
    else System.out.println("No ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( str : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     if (n = 0 & n = 1) then     return false else skip ; 
    if (n = 2) then     return (((str->at(n - 2+1) - ('0')->char2byte()) * 10 + (str->at(n - 1+1) - ('0')->char2byte())) mod 16 = 0) else skip ; 
    if (n = 3) then     return (((str->at(n - 3+1) - ('0')->char2byte()) * 100 + (str->at(n - 2+1) - ('0')->char2byte()) * 10 + (str->at(n - 1+1) - ('0')->char2byte())) mod 16 = 0) else skip ; 
    var last : int ; last := str->at(n - 1+1) - ('0')->char2byte() ;
    var second_last : int ; second_last := str->at(n - 2+1) - ('0')->char2byte() ;
    var third_last : int ; third_last := str->at(n - 3+1) - ('0')->char2byte() ;
    var fourth_last : int ; fourth_last := str->at(n - 4+1) - ('0')->char2byte() ;
    return ((fourth_last * 1000 + third_last * 100 + second_last * 10 + last) mod 16 = 0) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "769528" ;
     if (check(str)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No ") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class AnastasiaAndPebbles {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long k=sc.nextLong();
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      long w=sc.nextLong();
      if(w % k!=0)ans++;
      ans+=w/k ;
    }
    if(ans % 2!=0)System.out.println(ans/2+1);
    else System.out.println(ans/2);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class AnastasiaAndPebbles {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var w : long ; w := sc.getCurrent()->toLong() ;
     if (w mod k /= 0) then     ans := ans + 1 ; else skip ; 
     ans := ans+(w / k) )  ;     i := i + 1 ) ; 
    if (ans mod 2 /= 0) then     OclFile["System.out"].println(ans / 2 + 1) else     OclFile["System.out"].println(ans / 2) ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class AnastasiaAndpebbles {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    long k=in.nextLong();
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      long x=in.nextLong();
      if(x<k)x=k ;
      long val=(x/k);
      if(x % k!=0)val++;
      val*=k ;
      sum+=val ;
    }
    long ans=(sum/(2*k));
    if(sum %(2*k)!=0)ans++;
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class AnastasiaAndpebbles {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var k : long ; k := in.getCurrent()->toLong() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : long ; x := in.getCurrent()->toLong() ;
     if (x < k) then     x := k ; else skip ; 
    var val : long ; val := (x / k) ;
    if (x mod k /= 0) then     val := val + 1 ; else skip ; 
    val := val*(k) ; 
    sum := sum+(val) ; 
 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := (sum / (2 * k)) ;
    if (sum mod (2 * k) /= 0) then     ans := ans + 1 ; else skip ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float circumferenceparallelogram(float a,float b){
    return((2*a)+(2*b));
  }
  public static void main(String arg[]){
    float a=10,b=8 ;
    System.out.print("Circumference of a given Parallelogram is :");
    System.out.println(circumferenceparallelogram(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation circumferenceparallelogram( a : double, b : double) : double
  pre: true
  post: true
  activity: (     return ((2 * a) + (2 * b)) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 10 ;
    var b : double ; b := 8 ;
     OclFile["System.out"].print("Circumference of a given Parallelogram is :") ; 
     OclFile["System.out"].println(circumferenceparallelogram(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void getLongestSeq(int a[],int n){
    int maxIdx=0,maxLen=0,currLen=0,currIdx=0 ;
    for(int k=0 ; k<n ; k++){
      if(a[k]>0){
        currLen++;
        if(currLen==1)currIdx=k ;
      }
      else {
        if(currLen>maxLen){
          maxLen=currLen ;
          maxIdx=currIdx ;
        }
        currLen=0 ;
      }
    }
    if(maxLen>0){
      System.out.print("Length "+maxLen);
      System.out.print(",starting index "+maxIdx);
    }
    else System.out.println("No positive sequence detected.");
    return ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,-3,2,3,4,-6,1,2,3,4,5,-8,5,6 };
      int n=arr.length ;
      getLongestSeq(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getLongestSeq( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var maxIdx : int ; maxIdx := 0 ;
    var maxLen : int ; maxLen := 0 ;
    var currLen : int ; currLen := 0 ;
    var currIdx : int ; currIdx := 0 ;
         var k : int ; k := 0 ; while k < n do ( (     if (a[k+1] > 0) then (     currLen := currLen + 1 ; 
     if (currLen = 1) then     currIdx := k ; else skip ) else (     if (currLen > maxLen) then (     maxLen := currLen ; 
     maxIdx := currIdx ) else skip ; 
     currLen := 0 ) )  ;     k := k + 1 ) ; 
     if (maxLen > 0) then (     OclFile["System.out"].print("Length " + maxLen) ; 
     OclFile["System.out"].print(",starting index " + maxIdx) ) else     OclFile["System.out"].println("No positive sequence detected.") ; ;  
     return );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,-3,2,3,4,-6,1,2,3,4,5,-8,5,6} ;
     var n : int ; n := arr->size() ;
     execute getLongestSeq(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maximumNumberDistinctPrimeRange(int m,int n){
    long factorCount[]=new long[n+1];
    boolean prime[]=new boolean[n+1];
    for(int i=0 ; i<=n ; i++){
      factorCount[i]=0 ;
      prime[i]=true ;
    }
    for(int i=2 ; i<=n ; i++){
      if(prime[i]==true){
        factorCount[i]=1 ;
        for(int j=i*2 ; j<=n ; j+=i){
          factorCount[j]++;
          prime[j]=false ;
        }
      }
    }
    int max=(int)factorCount[m];
    int num=m ;
    for(int i=m ; i<=n ; i++){
      if(factorCount[i]>max){
        max=(int)factorCount[i];
        num=i ;
      }
    }
    return num ;
  }
  public static void main(String[] args){
    int m=4,n=6 ;
    System.out.println(maximumNumberDistinctPrimeRange(m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maximumNumberDistinctPrimeRange( m : int, n : int) : int
  pre: true
  post: true
  activity: (     var factorCount : Sequence(long) ; factorCount := Integer.subrange(1,n + 1)->collect(0) ;
     var prime : Sequence(boolean) ; prime := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 0 ; while i <= n do ( (     factorCount[i+1] := 0 ; 
     prime[i+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= n do ( (     if (prime[i+1] = true) then (     factorCount[i+1] := 1 ; 
         var j : int ; j := i * 2 ; while j <= n do ( (     factorCount[j+1] := factorCount[j+1] + 1 ; 
     prime[j+1] := false )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    var max : int ; max := factorCount[m+1]->oclAsType(int) ;
    var num : int ; num := m ;
        var i : int ; i := m ; while i <= n do ( (     if (factorCount[i+1] > max) then (     max := factorCount[i+1]->oclAsType(int) ; 
     num := i ) else skip )  ;     i := i + 1 ) ; 
    return num 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 4 ;
    var n : int ; n := 6 ;
     OclFile["System.out"].println(maximumNumberDistinctPrimeRange(m, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static final int INF=1<<29 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] a=new int[n];
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    int swaps=INF ;
    int i_=0 ;
    for(int i=0 ; i<m ; i++){
      int x=sc.nextInt();
      for(int j=0 ; j<x ; j++){
        b[i_]=i % 2 ;
        i_++;
      }
    }
    swaps=Math.min(swaps,swaps(a,b));
    for(int i=0 ; i<n ; i++){
      b[i]=1-b[i];
    }
    swaps=Math.min(swaps,swaps(a,b));
    System.out.println(swaps);
  }
  public static int swaps(int[] a,int[] b){
    int n=a.length ;
    int[] ca=Arrays.copyOf(a,n);
    int[] cb=Arrays.copyOf(b,n);
    int suma=0,sumb=0 ;
    for(int i=0 ; i<n ; i++){
      suma+=ca[i];
      sumb+=cb[i];
    }
    if(suma!=sumb){
      return INF ;
    }
    int swaps=0 ;
    for(int i=0 ; i<n ; i++){
      if(ca[i]==cb[i]){
        continue ;
      }
      for(int j=i+1 ; j<n ; j++){
        if(ca[i]==cb[j]){
          cb[j]=cb[i];
          cb[i]=ca[i];
          swaps+=(j-i);
          break ;
        }
      }
    }
    return swaps ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := (1*(2->pow(29)))->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var swaps : int ; swaps := INF ;
    var i_ : int ; i_ := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < x do ( (     b[i_+1] := i mod 2 ; 
     i_ := i_ + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    swaps := Set{swaps, swaps(a, b)}->min() ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := 1 - b[i+1] )  ;     i := i + 1 ) ; 
    swaps := Set{swaps, swaps(a, b)}->min() ; 
    OclFile["System.out"].println(swaps) ; 
 );
  static   operation swaps( a : Sequence(int), b : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() ;
     var ca : Sequence(int) ; ca := a.subrange(1,n) ;
    var cb : Sequence(int) ; cb := b.subrange(1,n) ;
    var suma : int ; suma := 0 ;
    var sumb : int ; sumb := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     suma := suma+(ca[i+1]) ; 
     sumb := sumb+(cb[i+1]) )  ;     i := i + 1 ) ; 
    if (suma /= sumb) then (     return INF ) else skip ; 
    var swaps : int ; swaps := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (ca[i+1] = cb[i+1]) then (     continue ) else skip ; 
         var j : int ; j := i + 1 ; while j < n do ( (     if (ca[i+1] = cb[j+1]) then (     cb[j+1] := cb[i+1] ; 
     cb[i+1] := ca[i+1] ; 
     swaps := swaps+((j - i)) ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return swaps 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Stack ;
public class GFG {
  static long smallestNumber(int n){
    if(n>=0 && n<=9){
      return n ;
    }
    Stack<Integer>digits=new Stack<>();
    for(int i=9 ; i>=2 && n>1 ; i--){
      while(n % i==0){
        digits.push(i);
        n=n/i ;
      }
    }
    if(n!=1){
      return-1 ;
    }
    long k=0 ;
    while(! digits.empty()){
      k=k*10+digits.peek();
      digits.pop();
    }
    return k ;
  }
  static public void main(String[] args){
    int n=100 ;
    System.out.println(smallestNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation smallestNumber( n : int) : long
  pre: true
  post: true
  activity: (     if (n >= 0 & n <= 9) then (     return n ) else skip ; 
     var digits : Sequence(int) ; digits := Sequence{} ;
        var i : int ; i := 9 ; while i >= 2 & n > 1 do ( (     while (n mod i = 0) do (     digits := digits->append(i) ; 
     n := n / i ) )  ;     i := i - 1 ) ; 
    if (n /= 1) then (     return -1 ) else skip ; 
    var k : long ; k := 0 ;
    while (not(digits->isEmpty())) do (     k := k * 10 + digits->min() ; 
     digits := digits->front() ) ; 
    return k 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 100 ;
     OclFile["System.out"].println(smallestNumber(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[] seq=new int[N];
    int[] run=new int[M];
    for(int i=0 ; i<seq.length ; i++){
      seq[i]=sc.nextInt();
    }
    for(int i=0 ; i<run.length ; i++){
      run[i]=sc.nextInt();
    }
    sc.close();
    int zero=swap(seq.clone(),run,0);
    int one=swap(seq.clone(),run,1);
    System.out.println(Math.min(zero,one));
  }
  static int swap(int[] clone,int[] run,int now){
    int swapNum=0 ;
    int k=0 ;
    for(int i=0 ; i<run.length ; i++){
      for(int j=0 ; j<run[i]; j++){
        if(clone[k]!=now){
          if(k==clone.length-1){
            return Integer.MAX_VALUE ;
          }
          for(int l=k+1 ; l<clone.length ; l++){
            if(clone[l]==now){
              int tmp=clone[l];
              clone[l]=clone[k];
              clone[k]=tmp ;
              swapNum+=l-k ;
              break ;
            }
            if(l==clone.length-1){
              return Integer.MAX_VALUE ;
            }
          }
        }
        k++;
      }
      now=(now+1)% 2 ;
    }
    return swapNum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var seq : Sequence(int) ; seq := Integer.subrange(1,N)->collect(0) ;
    var run : Sequence(int) ; run := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < seq->size() do ( (     seq[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < run->size() do ( (     run[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var zero : int ; zero := swap(seq->copy(), run, 0) ;
    var one : int ; one := swap(seq->copy(), run, 1) ;
    OclFile["System.out"].println(Set{zero, one}->min()) ; 
 );
  static   operation swap( clone : Sequence(int), run : Sequence(int), now : int) : int
  pre: true
  post: true
  activity: (     var swapNum : int ; swapNum := 0 ;
     var k : int ; k := 0 ;
         var i : int ; i := 0 ; while i < run->size() do ( (         var j : int ; j := 0 ; while j < run[i+1] do ( (     if (clone[k+1] /= now) then (     if (k = clone->size() - 1) then (     return 2147483647 ) else skip ; 
         var l : int ; l := k + 1 ; while l < clone->size() do ( (     if (clone[l+1] = now) then (     var tmp : int ; tmp := clone[l+1] ;
     clone[l+1] := clone[k+1] ; 
    clone[k+1] := tmp ; 
    swapNum := swapNum+(l - k) ; 
    break 
 ) else skip ; 
     if (l = clone->size() - 1) then (     return 2147483647 ) else skip )  ;     l := l + 1 ) ) else skip ; 
     k := k + 1 )  ;     j := j + 1 ) ; 
     now := (now + 1) mod 2 )  ;     i := i + 1 ) ; 
     return swapNum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int[] B ;
  public static void main(String[] args){
    int N=sc.nextInt();
    int M=sc.nextInt();
    B=new int[N];
    for(int i=0 ; i<N ; ++i){
      B[i]=sc.nextInt();
    }
    int[] target=new int[N];
    int pos=0 ;
    int val=0 ;
    for(int i=0 ; i<M ; ++i){
      int P=sc.nextInt();
      for(int j=0 ; j<P ; ++j){
        target[pos++]=val ;
      }
      val ^=1 ;
    }
    int ans=solve(target);
    for(int i=0 ; i<N ; ++i){
      target[i] ^=1 ;
    }
    ans=Math.min(ans,solve(target));
    System.out.println(ans);
  }
  static int solve(int[] target){
    int sum=0 ;
    for(int i=0 ; i<B.length ; ++i){
      sum+=B[i];
      sum-=target[i];
    }
    if(sum!=0)return 999 ;
    ArrayList<Integer>pos1=new ArrayList<Integer>();
    ArrayList<Integer>pos2=new ArrayList<Integer>();
    for(int i=0 ; i<B.length ; ++i){
      if(B[i]==0)pos1.add(i);
      if(target[i]==0)pos2.add(i);
    }
    int ret=0 ;
    for(int i=0 ; i<pos1.size(); ++i){
      ret+=Math.abs(pos1.get(i)-pos2.get(i));
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute B : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var M : int ; M := sc.getCurrent()->toInteger() ;
    B := Integer.subrange(1,N)->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     B[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var target : Sequence(int) ; target := Integer.subrange(1,N)->collect(0) ;
    var pos : int ; pos := 0 ;
    var val : int ; val := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     var P : int ; P := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < P do ( (      target[pos+1] := val  ; pos := pos + 1 )  ;     j := j + 1 ) ; 
     val := MathLib.bitwiseXor(val,1) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := solve(target) ;
        var i : int ; i := 0 ; while i < N do ( (     target[i+1] := MathLib.bitwiseXor(target[i+1],1) )  ;     i := i + 1 ) ; 
    ans := Set{ans, solve(target)}->min() ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation solve( target : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < B->size() do ( (     sum := sum+(B[i+1]) ; 
     sum := sum-(target[i+1]) )  ;     i := i + 1 ) ; 
    if (sum /= 0) then     return 999 else skip ; 
    var pos1 : Sequence(int) ; pos1 := Sequence{} ;
    var pos2 : Sequence(int) ; pos2 := Sequence{} ;
        var i : int ; i := 0 ; while i < B->size() do ( (     if (B[i+1] = 0) then     pos1 := pos1->including(i) ; else skip ; 
     if (target[i+1] = 0) then     pos2 := pos2->including(i) ; else skip )  ;     i := i + 1 ) ; 
    var ret : int ; ret := 0 ;
        var i : int ; i := 0 ; while i < pos1->size() do ( (     ret := ret+(if pos1->at(i+1) - pos2->at(i+1) < 0 then -(pos1->at(i+1) - pos2->at(i+1)) else pos1->at(i+1) - pos2->at(i+1) endif) )  ;     i := i + 1 ) ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Vector ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int inputBinary[]=new int[n];
    int numZero=0 ;
    for(int i=0 ; i<n ; i++){
      inputBinary[i]=sc.nextInt();
      if(inputBinary[i]==0){
        numZero++;
      }
    }
    int inputSegment[]=new int[m];
    for(int i=0 ; i<m ; i++){
      inputSegment[i]=sc.nextInt();
    }
    boolean isZero=true ;
    Vector<Integer>vec1=new Vector<Integer>();
    Vector<Integer>vec2=new Vector<Integer>();
    int index=0 ;
    for(int i=0 ; i<m ; i++){
      for(int j=0 ; j<inputSegment[i]; j++){
        if(isZero){
          vec1.add(index);
        }
        else {
          vec2.add(index);
        }
        index++;
      }
      isZero=! isZero ;
    }
    int vecIndex=0 ;
    int result1=Integer.MAX_VALUE ;
    if(numZero==vec1.size()){
      result1=0 ;
      for(int i=0 ; i<n ; i++){
        if(inputBinary[i]==0){
          result1+=Math.abs(i-vec1.get(vecIndex));
          vecIndex++;
        }
      }
    }
    vecIndex=0 ;
    int result2=Integer.MAX_VALUE ;
    if(numZero==vec2.size()){
      result2=0 ;
      for(int i=0 ; i<n ; i++){
        if(inputBinary[i]==0){
          result2+=Math.abs(i-vec2.get(vecIndex));
          vecIndex++;
        }
      }
    }
    System.out.println(Math.min(result1,result2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var inputBinary : Sequence(int) ; inputBinary := Integer.subrange(1,n)->collect(0) ;
    var numZero : int ; numZero := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     inputBinary[i+1] := sc.getCurrent()->toInteger() ; 
     if (inputBinary[i+1] = 0) then (     numZero := numZero + 1 ) else skip )  ;     i := i + 1 ) ; 
    var inputSegment : Sequence(int) ; inputSegment := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     inputSegment[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var isZero : boolean ; isZero := true ;
    var vec1 : Sequence(int) ; vec1 := Sequence{} ;
    var vec2 : Sequence(int) ; vec2 := Sequence{} ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j < inputSegment[i+1] do ( (     if (isZero) then (     vec1 := vec1->including(index) ) else (     vec2 := vec2->including(index) ) ;  
     index := index + 1 )  ;     j := j + 1 ) ; 
     isZero := not(isZero) )  ;     i := i + 1 ) ; 
    var vecIndex : int ; vecIndex := 0 ;
    var result1 : int ; result1 := 2147483647 ;
    if (numZero = vec1->size()) then (     result1 := 0 ; 
         var i : int ; i := 0 ; while i < n do ( (     if (inputBinary[i+1] = 0) then (     result1 := result1+(if i - vec1->at(vecIndex+1) < 0 then -(i - vec1->at(vecIndex+1)) else i - vec1->at(vecIndex+1) endif) ; 
     vecIndex := vecIndex + 1 ) else skip )  ;     i := i + 1 ) ) else skip ; 
    vecIndex := 0 ; 
    var result2 : int ; result2 := 2147483647 ;
    if (numZero = vec2->size()) then (     result2 := 0 ; 
         var i : int ; i := 0 ; while i < n do ( (     if (inputBinary[i+1] = 0) then (     result2 := result2+(if i - vec2->at(vecIndex+1) < 0 then -(i - vec2->at(vecIndex+1)) else i - vec2->at(vecIndex+1) endif) ; 
     vecIndex := vecIndex + 1 ) else skip )  ;     i := i + 1 ) ) else skip ; 
    OclFile["System.out"].println(Set{result1, result2}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Node nodes[]=new Node[n];
    for(int i=0 ; i<n ; i++)nodes[i]=new Node(i);
    for(int i=0 ; i<n ; i++){
      int index=sc.nextInt();
      int k=sc.nextInt();
      for(int j=0 ; j<k ; j++)nodes[index] .children.add(sc.nextInt());
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<nodes[i] .children.size(); j++)nodes[nodes[i] .children.get(j)] .parent=nodes[i];
    }
    for(int i=0 ; i<n ; i++)System.out.println("node "+nodes[i] .index+": parent="+nodes[i] .get_parent()+",depth="+nodes[i] .depth()+","+nodes[i] .type()+","+nodes[i] .children);
  }
}
class Node {
  int index ;
  Node parent=null ;
  List<Integer>children ;
  int get_parent(){
    if(parent==null)return-1 ;
    else return parent.index ;
  }
  int depth(){
    if(parent==null)return 0 ;
    else return parent.depth()+1 ;
  }
  String type(){
    if(parent==null)return "root" ;
    else if(children.size()==0)return "leaf" ;
    else return "internal node" ;
  }
  Node(int index){
    this.index=index ;
    children=new ArrayList<Integer>();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var nodes : Sequence(Node) ; nodes := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     nodes[i+1] := Node.newNode(i) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var index : int ; index := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < k do (     nodes[index+1].children->excludes(sc.getCurrent()->toInteger()) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < nodes[i+1].children->size() do (     nodes[nodes[i+1].children->at(j+1)+1].parent := nodes[i+1] ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].println("node " + nodes[i+1].index + ": parent=" + nodes[i+1].get_parent() + ",depth=" + nodes[i+1].depth() + "," + nodes[i+1].type() + "," + nodes[i+1].children) ;  ;     i := i + 1 ) ; 
 );
}
class Node {
   attribute index : int;
   attribute parent : Node := null;
   attribute children : Sequence(int);
   operation get_parent() : int
  pre: true
  post: true
  activity: (     if (parent = null) then     return -1 else     return parent.index );
   operation depth() : int
  pre: true
  post: true
  activity: (     if (parent = null) then     return 0 else     return parent.depth() + 1 );
   operation type() : String
  pre: true
  post: true
  activity: (     if (parent = null) then     return "root" else     if (children->size() = 0) then     return "leaf" else     return "internal node" ;  );
   static operation newNode( index : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(index);
    return self );
  operation initialise( index : int) : void
  pre: true  post: true
  activity: (     self.index := index ; 
     children := Sequence{} );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  final boolean DEBUG=false ;
  class Node {
    Node p ;
    int[] child ;
    int id ;
    Node(int id){
      this.id=id ;
    }
    void print(){
      System.out.print("node "+this.id+": ");
      System.out.print("parent="+(this.p==null ?-1 : this.p.id)+",");
      int d=0 ;
      Node p=this.p ;
      while(p!=null){
        d++;
        p=p.p ;
      }
      System.out.print("depth="+d+",");
      System.out.print((this.p==null ? "root" : this.child.length!=0 ? "internal node" : "leaf")+",");
      System.out.print("[");
      for(int i=0 ; i<this.child.length ; i++)System.out.print(this.child[i]+(i!=this.child.length-1 ? "," : ""));
      System.out.println("] ");
    }
  }
  void run(){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    Node[] nodes=new Node[n];
    for(int i=0 ; i<n ; i++)nodes[i]=new Node(i);
    for(int i=0 ; i<n ; i++){
      int id=scan.nextInt();
      int k=scan.nextInt();
      nodes[id] .child=new int[k];
      for(int j=0 ; j<k ; j++){
        int c=scan.nextInt();
        nodes[id] .child[j]=nodes[c] .id ;
        nodes[c] .p=nodes[id];
      }
    }
    for(int i=0 ; i<n ; i++)nodes[i] .print();
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute DEBUG : boolean := false;
 class Node {
   attribute p : Node;
   attribute child : Sequence(int);
   attribute id : int;
   static operation newNode( id : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(id);
    return self );
  operation initialise( id : int) : void
  pre: true  post: true
  activity: (     self.id := id );
   operation print() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("node " + self.id + ": ") ; 
     OclFile["System.out"].print("parent=" + (if self.p = null then -1 else self.p.id endif) + ",") ; 
    var d : int ; d := 0 ;
    var p : Node ; p := self.p ;
    while (p /= null) do (     d := d + 1 ; 
     p := p.p ) ; 
    OclFile["System.out"].print("depth=" + d + ",") ; 
    OclFile["System.out"].print((if self.p = null then "root" else if self.child->size() /= 0 then "internal node" else "leaf" endif endif) + ",") ; 
    OclFile["System.out"].print("[") ; 
        var i : int ; i := 0 ; while i < self.child->size() do (     OclFile["System.out"].print(self.child[i+1] + (if i /= self.child->size() - 1 then "," else "" endif)) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("] ") ; 
 );
}
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var nodes : Sequence(Node) ; nodes := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     nodes[i+1] := Node.newNode(i) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var id : int ; id := scan.getCurrent()->toInteger() ;
     var k : int ; k := scan.getCurrent()->toInteger() ;
     nodes[id+1].child := Integer.subrange(1,k)->collect(0) ; 
         var j : int ; j := 0 ; while j < k do ( (     var c : int ; c := scan.getCurrent()->toInteger() ;
     nodes[id+1].child[j+1] := nodes[c+1].id ; 
     nodes[c+1].p := nodes[id+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     nodes[i+1].print() ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static List<Integer>link[];
  public static int[] d ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    link=new ArrayList[N];
    for(int i=0 ; i<N ; i++){
      link[i]=new ArrayList<Integer>();
    }
    for(int i=0 ; i<N-1 ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      link[a-1] .add(b-1);
      link[b-1] .add(a-1);
    }
    d=new int[N];
    for(int i=0 ; i<N ; i++)d[i]=-1 ;
    dfs(0,0);
    int maxD=-1 ;
    int maxI=-1 ;
    for(int i=0 ; i<N ; i++){
      if(maxD<d[i]){
        maxD=d[i];
        maxI=i ;
      }
    }
    for(int i=0 ; i<N ; i++)d[i]=-1 ;
    dfs(maxI,0);
    for(int i=0 ; i<N ; i++){
      if(maxD<d[i]){
        maxD=d[i];
      }
    }
    int longest=maxD+1 ;
    if(longest % 3==2){
      System.out.println("Second");
    }
    else {
      System.out.println("First");
    }
  }
  public static void dfs(int s,int value){
    d[s]=value ;
    for(Integer w : link[s]){
      if(d[w]!=-1)continue ;
      dfs(w,value+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute link : Sequence(Sequence(int));
  static   attribute d : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    link := Integer.subrange(1,N)->collect(null) ; 
        var i : int ; i := 0 ; while i < N do ( (     link[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     link[a - 1+1]->excludes(b - 1) ; 
     link[b - 1+1]->excludes(a - 1) )  ;     i := i + 1 ) ; 
    d := Integer.subrange(1,N)->collect(0) ; 
        var i : int ; i := 0 ; while i < N do (     d[i+1] := -1 ;  ;     i := i + 1 ) ; 
    execute dfs(0, 0) ; 
    var maxD : int ; maxD := -1 ;
    var maxI : int ; maxI := -1 ;
        var i : int ; i := 0 ; while i < N do ( (     if (maxD < d[i+1]) then (     maxD := d[i+1] ; 
     maxI := i ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do (     d[i+1] := -1 ;  ;     i := i + 1 ) ; 
    execute dfs(maxI, 0) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (maxD < d[i+1]) then (     maxD := d[i+1] ) else skip )  ;     i := i + 1 ) ; 
    var longest : int ; longest := maxD + 1 ;
    if (longest mod 3 = 2) then (     OclFile["System.out"].println("Second") ) else (     OclFile["System.out"].println("First") ) ;  
 );
  static   operation dfs( s : int, value : int) : void
  pre: true
  post: true
  activity: (     d[s+1] := value ; 
     for (w : link[s+1]) do ( (     if (d[w+1] /= -1) then     continue else skip ; 
     execute dfs(w, value + 1) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.System.in ;
public class Main {
  static List<Integer>[] g ;
  static int n ;
  static int[] dep ;
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    dep=new int[n+1];
    g=new LinkedList[n+1];
    for(int i=0 ; i<=n ; i++)g[i]=new LinkedList<>();
    for(int i=1 ; i<n ; i++){
      int a=sc.nextInt(),b=sc.nextInt();
      g[a] .add(b);
      g[b] .add(a);
    }
    dfs(1,1,0);
    int maxi=0,idx=1 ;
    for(int i=2 ; i<=n ; i++){
      if(dep[i]>maxi)idx=i ;
      maxi=Math.max(maxi,dep[i]);
    }
    Arrays.fill(dep,0);
    dfs(idx,idx,0);
    int dia=0 ;
    for(int i=1 ; i<=n ; i++)dia=Math.max(dia,dep[i]);
    String ans=dia % 3==1 ? "Second" : "First" ;
    System.out.println(ans);
  }
  static void dfs(int root,int from,int level){
    dep[root]=level ;
    for(int to : g[root]){
      if(to==from)continue ;
      dfs(to,root,level+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute g : Sequence(Sequence(int));
  static   attribute n : int;
  static   attribute dep : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    dep := Integer.subrange(1,n + 1)->collect(0) ; 
    g := Integer.subrange(1,n + 1)->collect(null) ; 
        var i : int ; i := 0 ; while i <= n do (     g[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
     g[a+1]->excludes(b) ; 
     g[b+1]->excludes(a) )  ;     i := i + 1 ) ; 
    execute dfs(1, 1, 0) ; 
    var maxi : int ; maxi := 0 ;
    var idx : int ; idx := 1 ;
        var i : int ; i := 2 ; while i <= n do ( (     if (dep[i+1] > maxi) then     idx := i ; else skip ; 
     maxi := Set{maxi, dep[i+1]}->max() )  ;     i := i + 1 ) ; 
    dep := dep->collect(0) ; 
    execute dfs(idx, idx, 0) ; 
    var dia : int ; dia := 0 ;
        var i : int ; i := 1 ; while i <= n do (     dia := Set{dia, dep[i+1]}->max() ;  ;     i := i + 1 ) ; 
    var ans : String ; ans := if dia mod 3 = 1 then "Second" else "First" endif ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation dfs( root : int, from : int, level : int) : void
  pre: true
  post: true
  activity: (     dep[root+1] := level ; 
     for (to : g[root+1]) do ( (     if (to = from) then     continue else skip ; 
     execute dfs(to, root, level + 1) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Linked_list_2D_Matrix {
  static class Node {
    int data ;
    Node right ;
    Node down ;
  };
  static Node construct(int arr[][],int i,int j,int m,int n){
    if(i>n-1 || j>m-1)return null ;
    Node temp=new Node();
    temp.data=arr[i][j];
    temp.right=construct(arr,i,j+1,m,n);
    temp.down=construct(arr,i+1,j,m,n);
    return temp ;
  }
  static void display(Node head){
    Node Rp ;
    Node Dp=head ;
    while(Dp!=null){
      Rp=Dp ;
      while(Rp!=null){
        System.out.print(Rp.data+" ");
        Rp=Rp.right ;
      }
      System.out.println();
      Dp=Dp.down ;
    }
  }
  public static void main(String args[]){
    int arr[][]={
      {
        1,2,3 },{
          4,5,6 },{
            7,8,9 }
          };
          int m=3,n=3 ;
          Node head=construct(arr,0,0,m,n);
          display(head);
        }
      }

------------------------------------------------------------
OCL File:
---------
class Linked_list{
  static class Node {
   attribute data : int;
   attribute right : Node;
   attribute down : Node;
}
  static   operation construct( arr : Sequence(Sequence(int)), i : int, j : int, m : int, n : int) : Node
  pre: true
  post: true
  activity: (     if (i > n - 1 or j > m - 1) then     return null else skip ; 
     var temp : Node ; temp := Node.newNode() ;
    temp.data := arr[i+1][j+1] ; 
    temp.right := construct(arr, i, j + 1, m, n) ; 
    temp.down := construct(arr, i + 1, j, m, n) ; 
    return temp 
 );
  static   operation display( head : Node) : void
  pre: true
  post: true
  activity: (     var Rp : Node ;
     var Dp : Node ; Dp := head ;
     while (Dp /= null) do (     Rp := Dp ; 
     while (Rp /= null) do (     OclFile["System.out"].print(Rp.data + " ") ; 
     Rp := Rp.right ) ; 
     OclFile["System.out"].println() ; 
     Dp := Dp.down ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,2,3},Sequence{4,5,6},Sequence{7,8,9}} ;
     var m : int ; m := 3 ;
    var n : int ; n := 3 ;
     var head : Node ; head := construct(arr, 0, 0, m, n) ;
     execute display(head) );
}
D_Matrix {
  static class Node {
   attribute data : int;
   attribute right : Node;
   attribute down : Node;
}
  static   operation construct( arr : Sequence(Sequence(int)), i : int, j : int, m : int, n : int) : Node
  pre: true
  post: true
  activity: (     if (i > n - 1 or j > m - 1) then     return null else skip ; 
     var temp : Node ; temp := Node.newNode() ;
    temp.data := arr[i+1][j+1] ; 
    temp.right := construct(arr, i, j + 1, m, n) ; 
    temp.down := construct(arr, i + 1, j, m, n) ; 
    return temp 
 );
  static   operation display( head : Node) : void
  pre: true
  post: true
  activity: (     var Rp : Node ;
     var Dp : Node ; Dp := head ;
     while (Dp /= null) do (     Rp := Dp ; 
     while (Rp /= null) do (     OclFile["System.out"].print(Rp.data + " ") ; 
     Rp := Rp.right ) ; 
     OclFile["System.out"].println() ; 
     Dp := Dp.down ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,2,3},Sequence{4,5,6},Sequence{7,8,9}} ;
     var m : int ; m := 3 ;
    var n : int ; n := 3 ;
     var head : Node ; head := construct(arr, 0, 0, m, n) ;
     execute display(head) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    Scanner scanner=new Scanner(System.in);
    int N=1000000 ;
    boolean[] primes=new boolean[N+1];
    primes[0]=true ;
    primes[1]=true ;
    for(int i=2 ; i<=Math.sqrt(N); i++){
      if(! primes[i]){
        for(int j=i*2 ; j<=N ; j+=i){
          primes[j]=true ;
        }
      }
    }
    while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      int count=0 ;
      for(int i=n-1 ; i>=n/2 ; i-=2){
        if(! primes[i] && ! primes[n-i]){
          count++;
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := 1000000 ;
    var primes : Sequence(boolean) ; primes := Integer.subrange(1,N + 1)->collect(false) ;
    primes[0+1] := true ; 
    primes[1+1] := true ; 
        var i : int ; i := 2 ; while i <= (N)->sqrt() do ( (     if (not(primes[i+1])) then (         var j : int ; j := i * 2 ; while j <= N do ( (     primes[j+1] := true )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var count : int ; count := 0 ;
        var i : int ; i := n - 1 ; while i >= n / 2 do ( (     if (not(primes[i+1]) & not(primes[n - i+1])) then (     count := count + 1 ) else skip )  ;     i := i-(2) ) ; 
    OclFile["System.out"].println(count) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static boolean BinarySearch(ArrayList<Integer>list,int p){
    int low=0 ;
    int high=list.size()-1 ;
    int middle=(low+high)/2 ;
    while(low<=high){
      if(list.get(middle)==p){
        return true ;
      }
      else if(list.get(middle)<p){
        low=middle+1 ;
      }
      else {
        high=middle-1 ;
      }
      middle=(low+high)/2 ;
    }
    return false ;
  }
  public static ArrayList<Integer>sieve(int n){
    ArrayList<Integer>ret=new ArrayList<Integer>();
    boolean[] isPrime=new boolean[n+1];
    Arrays.fill(isPrime,true);
    for(int i=4 ; i<n ; i+=2)isPrime[i]=false ;
    for(int i=3 ; i*i<=n ; i+=2){
      for(int j=3 ; i*j<n ; j+=2)isPrime[i*j]=false ;
    }
    for(int i=2 ; i<n ; i++){
      if(isPrime[i])ret.add(i);
    }
    return ret ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int num=sc.nextInt();
      if(num==0)break ;
      ArrayList<Integer>primes=sieve(num);
      int cnt=0 ;
      for(int p : primes)if(BinarySearch(primes,num-p)){
        cnt++;
      }
      cnt/=2 ;
      if(BinarySearch(primes,num/2))cnt++;
      System.out.println(cnt);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation BinarySearch( list : Sequence(int), p : int) : boolean
  pre: true
  post: true
  activity: (     var low : int ; low := 0 ;
     var high : int ; high := list->size() - 1 ;
    var middle : int ; middle := (low + high) / 2 ;
    while (low <= high) do (     if (list->at(middle+1) = p) then (     return true ) else     if (list->at(middle+1) < p) then (     low := middle + 1 ) else (     high := middle - 1 ) ;  ;  
     middle := (low + high) / 2 ) ; 
    return false 
 );
  static   operation sieve( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ret : Sequence(int) ; ret := Sequence{} ;
     var isPrime : Sequence(boolean) ; isPrime := Integer.subrange(1,n + 1)->collect(false) ;
    isPrime := isPrime->collect(true) ; 
        var i : int ; i := 4 ; while i < n do (     isPrime[i+1] := false ;  ;     i := i+(2) ) ; 
        var i : int ; i := 3 ; while i * i <= n do ( (         var j : int ; j := 3 ; while i * j < n do (     isPrime[i * j+1] := false ;  ;     j := j+(2) ) )  ;     i := i+(2) ) ; 
        var i : int ; i := 2 ; while i < n do ( (     if (isPrime[i+1]) then     ret := ret->including(i) ; else skip )  ;     i := i + 1 ) ; 
    return ret 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var num : int ; num := sc.getCurrent()->toInteger() ;
     if (num = 0) then     break else skip ; 
    var primes : Sequence(int) ; primes := sieve(num) ;
    var cnt : int ; cnt := 0 ;
    for (p : primes) do (     if (BinarySearch(primes, num - p)) then (     cnt := cnt + 1 ) else skip ;  ) ; 
    cnt := cnt/(2) ; 
    if (BinarySearch(primes, num / 2)) then     cnt := cnt + 1 ; else skip ; 
    OclFile["System.out"].println(cnt) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    try(Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out)){
      int r=in.nextInt(),s=in.nextInt(),p=in.nextInt();
      int[] d=new int[p];
      for(int i=0 ; i<p ; i++){
        int y=in.nextInt(),x=in.nextInt();
        d[i]=(r-y+1)+(x<=s ? s-x+1 : x-s);
      }
      Arrays.sort(d);
      for(int i=1 ; i<p ; i++){
        d[i]=Math.max(d[i],d[i-1]+1);
      }
      out.println(d[p-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]) ;
 (     var r : int ; r := in.getCurrent()->toInteger() ;
    var s : int ; s := in.getCurrent()->toInteger() ;
    var p : int ; p := in.getCurrent()->toInteger() ;
     var d : Sequence(int) ; d := Integer.subrange(1,p)->collect(0) ;
        var i : int ; i := 0 ; while i < p do ( (     var y : int ; y := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
     d[i+1] := (r - y + 1) + (if x <= s then s - x + 1 else x - s endif) )  ;     i := i + 1 ) ; 
    d := d->sort() ; 
        var i : int ; i := 1 ; while i < p do ( (     d[i+1] := Set{d[i+1], d[i - 1+1] + 1}->max() )  ;     i := i + 1 ) ; 
    skip ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static boolean prime[]=new boolean[1000001];
  static List<Integer>hyou=new ArrayList<Integer>();
  static int sum[]=new int[1000001];
  static int doIt(int n){
    int cnt=0 ;
    boolean[] a=new boolean[sum.length];
    for(int s=0 ; s<a.length ; s++)a[s]=true ;
    for(int s=n-1 ; s>0 ; s--){
      if(prime[s] && prime[n-s] && a[s]){
        cnt++;
        a[n-s]=false ;
        a[s]=false ;
      }
    }
    return cnt ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    for(int i=0 ; i<prime.length ; i++)prime[i]=true ;
    prime[0]=false ;
    prime[1]=false ;
    for(int s=0 ; s<prime.length ; s++){
      if(prime[s]){
        for(int i=s+s ; i<prime.length ; i+=s)prime[i]=false ;
        hyou.add(s);
      }
    }
    for(int i=0 ; i<sum.length ; i++){
      if(prime[i])sum[i]=1 ;
      else sum[i]=0 ;
    }
    while(in.hasNext()){
      int n=in.nextInt();
      if(n==0)break ;
      System.out.println(doIt(n));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute prime : boolean := Integer.subrange(1,1000001)->collect(false);
  static   attribute hyou : Sequence(int) := Sequence{};
  static   attribute sum : int := Integer.subrange(1,1000001)->collect(0);
  static   operation doIt( n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var a : Sequence(boolean) ; a := Integer.subrange(1,sum->size())->collect(false) ;
        var s : int ; s := 0 ; while s < a->size() do (     a[s+1] := true ;  ;     s := s + 1 ) ; 
        var s : int ; s := n - 1 ; while s > 0 do ( (     if (prime[s+1] & prime[n - s+1] & a[s+1]) then (     cnt := cnt + 1 ; 
     a[n - s+1] := false ; 
     a[s+1] := false ) else skip )  ;     s := s - 1 ) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var i : int ; i := 0 ; while i < prime->size() do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
    prime[0+1] := false ; 
    prime[1+1] := false ; 
        var s : int ; s := 0 ; while s < prime->size() do ( (     if (prime[s+1]) then (         var i : int ; i := s + s ; while i < prime->size() do (     prime[i+1] := false ;  ;     i := i+(s) ) ; 
     hyou := hyou->including(s) ) else skip )  ;     s := s + 1 ) ; 
        var i : int ; i := 0 ; while i < sum->size() do ( (     if (prime[i+1]) then     sum[i+1] := 1 ; else     sum[i+1] := 0 ; )  ;     i := i + 1 ) ; 
    while (in.hasNext()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
     OclFile["System.out"].println(doIt(n)) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1581 {
  public static void main(String[] args){
    long mod=1000000007 ;
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      long answer=1 ;
      for(int n=3 ; n<=2*N ; n++){
        answer*=n ;
        answer %=mod ;
      }
      System.out.println(answer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1581 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mod : long ; mod := 1000000007 ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var answer : long ; answer := 1 ;
         var n : int ; n := 3 ; while n <= 2 * N do ( (     answer := answer*(n) ; 
     answer := answer mod mod )  ;     n := n + 1 ) ; 
     OclFile["System.out"].println(answer) )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CQXYMCountPermutations {
  static int mod=1000000007 ;
  public static void Factorial(int n){
    long fact=1 ;
    for(int i=1 ; i<=n ; i++){
      fact=(fact % mod)*i ;
    }
    System.out.println((fact/2)% mod);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int k=2*n ;
      Factorial(k);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CQXYMCountPermutations {
  static   attribute mod : int := 1000000007;
  static   operation Factorial( n : int) : void
  pre: true
  post: true
  activity: (     var fact : long ; fact := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (     fact := (fact mod mod) * i )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println((fact / 2) mod mod) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := 2 * n ;
     execute Factorial(k) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class AA {
  @ SuppressWarnings("resource")public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int m=1000000007 ;
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int k=sc.nextInt();
      long l=1 ;
      long sum=0 ;
      while(k>0){
        if((k & 1)==1){
          sum=(sum+l)% m ;
        }
        k=k>>1 ;
        l=(l*n)% m ;
      }
      System.out.println(sum);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class AA {
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := 1000000007 ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var l : long ; l := 1 ;
    var sum : long ; sum := 0 ;
    while (k > 0) do (     if ((MathLib.bitwiseAnd(k,1)) = 1) then (     sum := (sum + l) mod m ) else skip ; 
     k := (k/(2->pow(1)))->oclAsType(long) ; 
     l := (l * n) mod m ) ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  static long mod=(long)(1e9+7);
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int t=in.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      long n=in.nextLong();
      long k=in.nextLong();
      long c=0 ;
      long num=1 ;
      long sum=0 ;
      long n1=1 ;
      while(k>0){
        long d=k % 2 ;
        sum=(sum+(d*n1)% mod)% mod ;
        n1=(n1*n)% mod ;
        k/=2 ;
      }
      pw.println(sum);
    }
    pw.close();
  }
  static long Power(long base,long power){
    if(power==0)return 1 ;
    long temp=Power(base,power/2);
    long result=temp*temp ;
    if(power % 2==1){
      result=(result*base)% mod ;
    }
    return result % mod ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := (1e9 + 7)->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        var tt : int ; tt := 0 ; while tt < t do ( (     var n : long ; n := in.getCurrent()->toLong() ;
     var k : long ; k := in.getCurrent()->toLong() ;
    var c : long ; c := 0 ;
    var num : long ; num := 1 ;
    var sum : long ; sum := 0 ;
    var n1 : long ; n1 := 1 ;
    while (k > 0) do (     var d : long ; d := k mod 2 ;
     sum := (sum + (d * n1) mod mod) mod mod ; 
     n1 := (n1 * n) mod mod ; 
     k := k/(2) ) ; 
    skip ; 
 )  ;     tt := tt + 1 ) ; 
    skip ; 
 );
  static   operation Power( base : long, power : long) : long
  pre: true
  post: true
  activity: (     if (power = 0) then     return 1 else skip ; 
     var temp : long ; temp := Power(base, power / 2) ;
    var result : long ; result := temp * temp ;
    if (power mod 2 = 1) then (     result := (result * base) mod mod ) else skip ; 
    return result mod mod 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    final BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    final int n=Integer.parseInt(br.readLine());
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(isPrime(Integer.parseInt(br.readLine())))ans++;
    }
    System.out.println(ans);
  }
  private static boolean isPrime(int x){
    if(x<2)return false ;
    if(x<=3)return true ;
    if(x % 2==0 || x % 3==0)return false ;
    for(int i=5 ; i*i<=x ; i+=6){
      if(x % i==0 || x %(i+2)==0)return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (isPrime((br.readLine())->toInteger())) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation isPrime( x : int) : boolean
  pre: true
  post: true
  activity: (     if (x < 2) then     return false else skip ; 
     if (x <= 3) then     return true else skip ; 
    if (x mod 2 = 0 or x mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= x do ( (     if (x mod i = 0 or x mod (i + 2) = 0) then     return false else skip )  ;     i := i+(6) ) ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MyClass {
  static int mod=1000000007 ;
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    while(t-->0){
      String s[]=br.readLine().split(" ");
      long n=Long.parseLong(s[0]);
      long k=Long.parseLong(s[1]);
      long ans=0,cur=1 ;
      while(k>0){
        long rem=k % 2 ;
        if(rem==1){
          ans+=cur ;
          ans=ans % mod ;
        }
        cur*=n ;
        cur=cur % mod ;
        k=k/2 ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   attribute mod : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
     var n : long ; n := (s[0+1])->toLong() ;
    var k : long ; k := (s[1+1])->toLong() ;
    var ans : long ; ans := 0 ;
    var cur : long ; cur := 1 ;
    while (k > 0) do (     var rem : long ; rem := k mod 2 ;
     if (rem = 1) then (     ans := ans+(cur) ; 
     ans := ans mod mod ) else skip ; 
    cur := cur*(n) ; 
    cur := cur mod mod ; 
    k := k / 2 ; 
 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      int[] arr=new int[3];
      for(int j=0 ; j<3 ; j++){
        arr[j]=in.nextInt();
      }
      Arrays.sort(arr);
      System.out.println(arr[0]+Math.min((arr[1]+arr[2]-arr[0])/2,arr[1]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var arr : Sequence(int) ; arr := Integer.subrange(1,3)->collect(0) ;
         var j : int ; j := 0 ; while j < 3 do ( (     arr[j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
     arr := arr->sort() ; 
     OclFile["System.out"].println(arr[0+1] + Set{(arr[1+1] + arr[2+1] - arr[0+1]) / 2, arr[1+1]}->min()) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    int[] arr=new int[3];
    int day=0 ;
    for(int i=0 ; i<t ; i++){
      arr[0]=s.nextInt();
      arr[1]=s.nextInt();
      arr[2]=s.nextInt();
      Arrays.sort(arr);
      if(arr[2]>=arr[0]+arr[1]){
        day=arr[0]+arr[1];
      }
      else {
        day=(arr[0]+arr[1]+arr[2])/2 ;
      }
      System.out.println(day);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,3)->collect(0) ;
    var day : int ; day := 0 ;
        var i : int ; i := 0 ; while i < t do ( (     arr[0+1] := s.getCurrent()->toInteger() ; 
     arr[1+1] := s.getCurrent()->toInteger() ; 
    arr[2+1] := s.getCurrent()->toInteger() ; 
    arr := arr->sort() ; 
    if (arr[2+1] >= arr[0+1] + arr[1+1]) then (     day := arr[0+1] + arr[1+1] ) else (     day := (arr[0+1] + arr[1+1] + arr[2+1]) / 2 ) ;  
    OclFile["System.out"].println(day) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(InputStream in){
      br=new BufferedReader(new InputStreamReader(in),16384);
      eat("");
    }
    public void eat(String s){
      st=new StringTokenizer(s);
    }
    public String nextLine(){
      try {
        return br.readLine();
      }
      catch(IOException e){
        return null ;
      }
    }
    public boolean hasNext(){
      while(! st.hasMoreTokens()){
        String s=nextLine();
        if(s==null)return false ;
        eat(s);
      }
      return true ;
    }
    public String next(){
      hasNext();
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
  static FastScanner s=new FastScanner(System.in);
  static PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  public static void main(String[] args){
    int t=s.nextInt();
    while(t-->0){
      int[] a={
        s.nextInt(),s.nextInt(),s.nextInt()};
        Arrays.sort(a);
        int sum=0 ;
        int b=a[2]-a[1];
        if(b==0){
          sum=sum+a[1]+a[0]/2 ;
        }
        else {
          if(a[0]>b){
            a[0]=a[0]-b ;
            sum=sum+b ;
            sum=sum+a[1]+a[0]/2 ;
          }
          else {
            sum+=a[0]+a[1];
            a[0]=0 ;
          }
        }
        System.out.println(sum);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in), 16384) ; 
     execute eat("") );
   operation eat( s : String) : void
  pre: true
  post: true
  activity: (     st := OclIterator.newOclIterator_String(s) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do (     return null )
 );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     var s : String ; s := nextLine() ;
     if (s = null) then     return false else skip ; 
     execute eat(s) ) ; 
     return true );
   operation next() : String
  pre: true
  post: true
  activity: (     execute hasNext() ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
  static   attribute s : FastScanner := FastScanner.newFastScanner(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := s.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : Sequence(int) ; a := Sequence{s.nextInt(),s.nextInt(),s.nextInt()} ;
     a := a->sort() ; 
    var sum : int ; sum := 0 ;
    var b : int ; b := a[2+1] - a[1+1] ;
    if (b = 0) then (     sum := sum + a[1+1] + a[0+1] / 2 ) else (     if (a[0+1] > b) then (     a[0+1] := a[0+1] - b ; 
     sum := sum + b ; 
     sum := sum + a[1+1] + a[0+1] / 2 ) else (     sum := sum+(a[0+1] + a[1+1]) ; 
     a[0+1] := 0 ) ) ;  
    OclFile["System.out"].println(sum) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int y=scan.nextInt();
    int x=scan.nextInt();
    int[] ignorey=new int[y];
    int[] ignorex=new int[x];
    char[][] board=new char[y][x];
    String a="takagi" ;
    for(int i=0 ; i<y ; i++){
      a=scan.next();
      for(int j=0 ; j<x ; j++){
        board[i][j]=a.charAt(j);
      }
    }
    for(int i=0 ; i<y ; i++){
      for(int j=0 ; j<x ; j++){
        if(!(board[i][j]=='.')){
          break ;
        }
        if(j==x-1){
          ignorey[i]=1 ;
        }
      }
    }
    for(int i=0 ; i<x ; i++){
      for(int j=0 ; j<y ; j++){
        if(!(board[j][i]=='.')){
          break ;
        }
        if(j==y-1){
          ignorex[i]=1 ;
        }
      }
    }
    for(int i=0 ; i<y ; i++){
      if(ignorey[i]==1){
        continue ;
      }
      for(int j=0 ; j<x ; j++){
        if(ignorex[j]==1){
          continue ;
        }
        System.out.print(board[i][j]);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var y : int ; y := scan.getCurrent()->toInteger() ;
    var x : int ; x := scan.getCurrent()->toInteger() ;
    var ignorey : Sequence(int) ; ignorey := Integer.subrange(1,y)->collect(0) ;
    var ignorex : Sequence(int) ; ignorex := Integer.subrange(1,x)->collect(0) ;
    var board : Sequence(Sequence(String)) ; board := Integer.subrange(1,y)->collect(Integer.subrange(1,x)->collect(0)) ;
    var a : String ; a := "takagi" ;
        var i : int ; i := 0 ; while i < y do ( (     a := scan.getCurrent() ; 
         var j : int ; j := 0 ; while j < x do ( (     board[i+1][j+1] := a->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < y do ( (         var j : int ; j := 0 ; while j < x do ( (     if (not((board[i+1][j+1] = '.'))) then (     break ) else skip ; 
     if (j = x - 1) then (     ignorey[i+1] := 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < x do ( (         var j : int ; j := 0 ; while j < y do ( (     if (not((board[j+1][i+1] = '.'))) then (     break ) else skip ; 
     if (j = y - 1) then (     ignorex[i+1] := 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < y do ( (     if (ignorey[i+1] = 1) then (     continue ) else skip ; 
         var j : int ; j := 0 ; while j < x do ( (     if (ignorex[j+1] = 1) then (     continue ) else skip ; 
     OclFile["System.out"].print(board[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.*;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.jar.Attributes ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(in,out);
    out.close();
  }
  static class TaskA {
    public void solve(InputReader in,PrintWriter out){
      int t=in.nextInt();
      while(t-->0){
        int[] a=new int[3];
        for(int i=0 ; i<3 ; i++)a[i]=in.nextInt();
        Arrays.sort(a,0,3);
        int ans=0 ;
        if(a[2]-a[1]>=a[0])ans=a[0]+a[1];
        else ans=(a[0]+a[1]+a[2])/2 ;
        out.println(ans);
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var t : int ; t := in.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
         var i : int ; i := 0 ; while i < 3 do (     a[i+1] := in.nextInt() ;  ;     i := i + 1 ) ; 
    a := a.subrange(1,0)^(a.subrange(0+1,3)->sort())^a.subrange(3+1,a.size) ; 
    var ans : int ; ans := 0 ;
    if (a[2+1] - a[1+1] >= a[0+1]) then     ans := a[0+1] + a[1+1] else     ans := (a[0+1] + a[1+1] + a[2+1]) / 2 ; ;  
    skip ; 
 ) ;  ) );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int[] a={
        s.nextInt(),s.nextInt(),s.nextInt()};
        Arrays.sort(a);
        int sum=0 ;
        int b=a[2]-a[1];
        if(b==0){
          sum=sum+a[1]+a[0]/2 ;
        }
        else {
          if(a[0]>b){
            a[0]=a[0]-b ;
            sum=sum+b ;
            sum=sum+a[1]+a[0]/2 ;
          }
          else {
            sum+=a[0]+a[1];
            a[0]=0 ;
          }
        }
        System.out.println(sum);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : Sequence(int) ; a := Sequence{s.getCurrent()->toInteger(),s.getCurrent()->toInteger(),s.getCurrent()->toInteger()} ;
     a := a->sort() ; 
    var sum : int ; sum := 0 ;
    var b : int ; b := a[2+1] - a[1+1] ;
    if (b = 0) then (     sum := sum + a[1+1] + a[0+1] / 2 ) else (     if (a[0+1] > b) then (     a[0+1] := a[0+1] - b ; 
     sum := sum + b ; 
     sum := sum + a[1+1] + a[0+1] / 2 ) else (     sum := sum+(a[0+1] + a[1+1]) ; 
     a[0+1] := 0 ) ) ;  
    OclFile["System.out"].println(sum) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws java.io.IOException {
    Scanner scan=new Scanner(System.in);
    while(true){
      int s1=scan.nextInt();
      int s2=scan.nextInt();
      if((s1 | s2)==0)break ;
      int c=0 ;
      int max=s1+s2 ;
      for(int i=1 ; i<5 ; i++){
        s1=scan.nextInt();
        s2=scan.nextInt();
        if(Math.max(max,s1+s2)>max){
          max=s1+s2 ;
          c=i ;
        }
      }
      System.out.println((char)('A'+c)+" "+max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var s1 : int ; s1 := scan.getCurrent()->toInteger() ;
     var s2 : int ; s2 := scan.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(s1,s2)) = 0) then     break else skip ; 
    var c : int ; c := 0 ;
    var max : int ; max := s1 + s2 ;
        var i : int ; i := 1 ; while i < 5 do ( (     s1 := scan.getCurrent()->toInteger() ; 
     s2 := scan.getCurrent()->toInteger() ; 
     if (Set{max, s1 + s2}->max() > max) then (     max := s1 + s2 ; 
     c := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(('A' + c)->oclAsType(String) + " " + max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int a,p,i,max ;
    int[] x ;
    x=new int[5];
    for(; ; ){
      a=sc.nextInt();
      p=sc.nextInt();
      if(a==0 && p==0)break ;
      x[0]=a+p ;
      max=0 ;
      for(i=1 ; i<5 ; i++){
        a=sc.nextInt();
        p=sc.nextInt();
        x[i]=a+p ;
        if(x[max]<x[i])max=i ;
      }
      if(max==0)out.println("A "+x[max]);
      else if(max==1)out.println("B "+x[max]);
      else if(max==2)out.println("C "+x[max]);
      else if(max==3)out.println("D "+x[max]);
      else out.println("E "+x[max]);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var a : int ;
    var p : int ;
    var i : int ;
    var max : int ;
    var x : Sequence(int) ;
    x := Integer.subrange(1,5)->collect(0) ; 
      while true do ( (     a := sc.nextInt() ; 
     p := sc.nextInt() ; 
    if (a = 0 & p = 0) then     break else skip ; 
    x[0+1] := a + p ; 
    max := 0 ; 
        i := 1 ; while i < 5 do ( (     a := sc.nextInt() ; 
     p := sc.nextInt() ; 
     x[i+1] := a + p ; 
     if (x[max+1] < x[i+1]) then     max := i ; else skip )  ;     i := i + 1 ) ; 
    if (max = 0) then     out.println("A " + x[max+1]) else     if (max = 1) then     out.println("B " + x[max+1]) else     if (max = 2) then     out.println("C " + x[max+1]) else     if (max = 3) then     out.println("D " + x[max+1]) else     out.println("E " + x[max+1]) ; ;  ;  ;  ;  
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.*;
import java.io.*;
import java.util.*;
public class Main {
  int[] dp ;
  int max=1000 ;
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int[] data=new int[5];
      int a=sc.nextInt();
      int b=sc.nextInt();
      if((a | b)==0)break ;
      data[0]=a+b ;
      for(int i=1 ; i<5 ; i++){
        data[i]=sc.nextInt()+sc.nextInt();
      }
      int max=0 ;
      int ind=-1 ;
      for(int i=0 ; i<5 ; i++){
        if(max<data[i]){
          max=data[i];
          ind=i ;
        }
      }
      System.out.println((char)(ind+'A')+" "+max);
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute dp : Sequence(int);
   attribute max : int := 1000;
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var data : Sequence(int) ; data := Integer.subrange(1,5)->collect(0) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(a,b)) = 0) then     break else skip ; 
    data[0+1] := a + b ; 
        var i : int ; i := 1 ; while i < 5 do ( (     data[i+1] := sc.getCurrent()->toInteger() + sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var ind : int ; ind := -1 ;
        var i : int ; i := 0 ; while i < 5 do ( (     if (max < data[i+1]) then (     max := data[i+1] ; 
     ind := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((ind + 'A')->oclAsType(String) + " " + max) ; 
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int minSum(int arr[],int n){
    int sum=arr[0],prev=arr[0];
    for(int i=1 ; i<n ; i++){
      if(arr[i]<=prev){
        prev=prev+1 ;
        sum=sum+prev ;
      }
      else {
        sum=sum+arr[i];
        prev=arr[i];
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      2,2,3,5,6 };
      int n=arr.length ;
      System.out.println(minSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := arr[0+1] ;
    var prev : int ; prev := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] <= prev) then (     prev := prev + 1 ; 
     sum := sum + prev ) else (     sum := sum + arr[i+1] ; 
     prev := arr[i+1] ) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,2,3,5,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    for(; ; ){
      int n=5 ;
      int max=0 ;
      char c='A' ;
      for(int i=0 ; i<n ; i++){
        int a=sc.nextInt()+sc.nextInt();
        if(a==0){
          return ;
        }
        if(a>max){
          c=(char)('A'+i);
          max=a ;
        }
      }
      println(c+" "+max);
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := 5 ;
     var max : int ; max := 0 ;
    var c : String ; c := 'A' ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() + sc.getCurrent()->toInteger() ;
     if (a = 0) then (     return ) else skip ; 
     if (a > max) then (     c := ('A' + i)->oclAsType(String) ; 
     max := a ) else skip )  ;     i := i + 1 ) ; 
    execute println(c + " " + max) ; 
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  static char[] names={
    'A','B','C','D','E' };
    public static void main(String[] args)throws IOException {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String line="" ;
      short[] sales=null ;
      short sale,idx,max ;
      while(!(line=br.readLine()).equals("0 0")){
        sales=new short[5];
        sale=Short.parseShort(line.substring(0,line.indexOf(' ')));
        sale+=Short.parseShort(line.substring(line.indexOf(' ')+1));
        sales[0]=sale ;
        idx=0 ;
        max=sales[0];
        for(short i=1 ; i<5 ; i++){
          line=br.readLine();
          sale=Short.parseShort(line.substring(0,line.indexOf(' ')));
          sale+=Short.parseShort(line.substring(line.indexOf(' ')+1));
          sales[i]=sale ;
          if(sale>max){
            max=sale ;
            idx=i ;
          }
        }
        System.out.println(names[idx]+" "+sales[idx]);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute names : Sequence(String) := Sequence{'A','B','C','D','E'};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
    var sales : Sequence(int) ; sales := null ;
    var sale : int ;
    var idx : int ;
    var max : int ;
    while (not((line) = "0 0")) do (     sales := Integer.subrange(1,5)->collect(0) ; 
     sale := (line.subrange(0+1,line->indexOf(' ')-1))->toInteger() ; 
    sale := sale+((line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1))->toInteger()) ; 
    sales[0+1] := sale ; 
    idx := 0 ; 
    max := sales[0+1] ; 
        var i : int ; i := 1 ; while i < 5 do ( (     line := br.readLine() ; 
     sale := (line.subrange(0+1,line->indexOf(' ')-1))->toInteger() ; 
    sale := sale+((line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1))->toInteger()) ; 
    sales[i+1] := sale ; 
    if (sale > max) then (     max := sale ; 
     idx := i ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(names[idx+1] + " " + sales[idx+1]) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isprime(int n){
    for(int i=2 ; i*i<=n ; i++)if(n % i==0)return false ;
    return true ;
  }
  static void LegendreConjecture(int n){
    System.out.println("Primes in the range "+n*n+" and "+(n+1)*(n+1)+" are:");
    for(int i=n*n ; i<=((n+1)*(n+1)); i++){
      if(isprime(i))System.out.println(i);
    }
  }
  public static void main(String[] args){
    int n=50 ;
    LegendreConjecture(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isprime( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= n do (     if (n mod i = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation LegendreConjecture( n : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Primes in the range " + n * n + " and " + (n + 1) * (n + 1) + " are:") ; 
         var i : int ; i := n * n ; while i <= ((n + 1) * (n + 1)) do ( (     if (isprime(i)) then     OclFile["System.out"].println(i) ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 50 ;
     execute LegendreConjecture(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countRotations(String n){
    int len=n.length();
    if(len==1){
      int oneDigit=n.charAt(0)-'0' ;
      if(oneDigit % 4==0)return 1 ;
      return 0 ;
    }
    int twoDigit,count=0 ;
    for(int i=0 ; i<(len-1); i++){
      twoDigit=(n.charAt(i)-'0')*10+(n.charAt(i+1)-'0');
      if(twoDigit % 4==0)count++;
    }
    twoDigit=(n.charAt(len-1)-'0')*10+(n.charAt(0)-'0');
    if(twoDigit % 4==0)count++;
    return count ;
  }
  public static void main(String args[]){
    String n="4834" ;
    System.out.println("Rotations: "+countRotations(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countRotations( n : String) : int
  pre: true
  post: true
  activity: (     var len : int ; len := n->size() ;
     if (len = 1) then (     var oneDigit : int ; oneDigit := n->at(0+1) - ('0')->char2byte() ;
     if (oneDigit mod 4 = 0) then     return 1 else skip ; 
     return 0 ) else skip ; 
    var twoDigit : int ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < (len - 1) do ( (     twoDigit := (n->at(i+1) - ('0')->char2byte()) * 10 + (n->at(i + 1+1) - ('0')->char2byte()) ; 
     if (twoDigit mod 4 = 0) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    twoDigit := (n->at(len - 1+1) - ('0')->char2byte()) * 10 + (n->at(0+1) - ('0')->char2byte()) ; 
    if (twoDigit mod 4 = 0) then     count := count + 1 ; else skip ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : String ; n := "4834" ;
     OclFile["System.out"].println("Rotations: " + countRotations(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Scanner ;
public class kFactorization {
  static Scanner sc=new Scanner(System.in);
  static PrintWriter pw=new PrintWriter(System.out);
  static int count=0 ;
  static ArrayList<Integer>c ;
  public static void factoriseopt(int n){
    for(int i=2 ; i*i<=n ; i++){
      if(n % i==0){
        int cnt=0 ;
        while(n % i==0){
          cnt++;
          n=n/i ;
        }
        count+=cnt ;
        while(cnt-->0){
          c.add(i);
        }
      }
    }
    if(n!=1){
      count+=1 ;
      c.add(n);
    }
  }
  public static void main(String[] args){
    c=new ArrayList<>();
    int n=sc.nextInt();
    int k=sc.nextInt();
    factoriseopt(n);
    if(count<k)System.out.println(-1);
    else {
      while(k!=c.size()){
        if(c.size()==2){
          System.out.println(c.remove(0)*c.remove(0));
          return ;
        }
        else c.add(c.remove(0)*c.remove(1));
      }
      for(Integer i : c){
        System.out.print(i+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class kFactorization {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute count : int := 0;
  static   attribute c : Sequence(int);
  static   operation factoriseopt( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     var cnt : int ; cnt := 0 ;
     while (n mod i = 0) do (     cnt := cnt + 1 ; 
     n := n / i ) ; 
     count := count+(cnt) ; 
         while (cnt > 0) do (        cnt := cnt - 1 ;     skip ; (     c := c->including(i) ) ;  ) ) else skip )  ;     i := i + 1 ) ; 
     if (n /= 1) then (     count := count+(1) ; 
     c := c->including(n) ) else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     c := Sequence{} ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    execute factoriseopt(n) ; 
    if (count < k) then     OclFile["System.out"].println(-1) else (     while (k /= c->size()) do (     if (c->size() = 2) then (     OclFile["System.out"].println(c->at(0+1) * c->at(0+1)) ; 
     return ) else     c := c->including(c->at(0+1) * c->at(1+1)) ; ) ; 
     for (i : c) do ( (     OclFile["System.out"].print(i + " ") )  ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static Scanner scan=new Scanner(System.in);
  public static void train(){
    int N=scan.nextInt(),i=scan.nextInt();
    System.out.println(N-i+1);
  }
  public static void gritCompression(){
    int H=scan.nextInt(),W=scan.nextInt();
    char[][] array=new char[H][W];
    for(int i=0 ; i<H ; i++){
      array[i]=scan.next().toCharArray();
    }
    System.out.println();
    ArrayList<Integer>line=new ArrayList<>();
    ArrayList<Integer>row=new ArrayList<>();
    for(int i=0 ; i<H ; i++){
      boolean flag=false ;
      for(int j=0 ; j<W ; j++){
        if(array[i][j]=='#'){
          flag=true ;
          break ;
        }
      }
      if(flag){
        row.add(i);
      }
    }
    for(int j=0 ; j<W ; j++){
      boolean flag=false ;
      for(int i=0 ; i<H ; i++){
        if(array[i][j]=='#'){
          flag=true ;
          break ;
        }
      }
      if(flag){
        line.add(j);
      }
    }
    for(int i=0 ; i<H ; i++){
      if(row.contains(i)){
        for(int j=0 ; j<W ; j++){
          if(line.contains(j)){
            System.out.print(array[i][j]);
          }
        }
        System.out.println();
      }
    }
  }
  public static void main(String[] argv){
    gritCompression();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation train() : void
  pre: true
  post: true
  activity: (     var N : int ; N := scan.getCurrent()->toInteger() ;
    var i : int ; i := scan.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N - i + 1) );
  static   operation gritCompression() : void
  pre: true
  post: true
  activity: (     var H : int ; H := scan.getCurrent()->toInteger() ;
    var W : int ; W := scan.getCurrent()->toInteger() ;
     var array : Sequence(Sequence(String)) ; array := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var i : int ; i := 0 ; while i < H do ( (     array[i+1] := scan.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    var line : Sequence(int) ; line := Sequence{} ;
    var row : Sequence(int) ; row := Sequence{} ;
        var i : int ; i := 0 ; while i < H do ( (     var flag : boolean ; flag := false ;
         var j : int ; j := 0 ; while j < W do ( (     if (array[i+1][j+1] = '#') then (     flag := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (flag) then (     row := row->including(i) ) else skip )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < W do ( (     var flag : boolean ; flag := false ;
         var i : int ; i := 0 ; while i < H do ( (     if (array[i+1][j+1] = '#') then (     flag := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (flag) then (     line := line->including(j) ) else skip )  ;     j := j + 1 ) ; 
        var i : int ; i := 0 ; while i < H do ( (     if (row->includes(i)) then (         var j : int ; j := 0 ; while j < W do ( (     if (line->includes(j)) then (     OclFile["System.out"].print(array[i+1][j+1]) ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation main( argv : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute gritCompression() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class A_k_Factorization {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int N=reader.nextInt();
    int k=reader.nextInt();
    int count=k-1 ;
    List<Integer>list=new ArrayList<>();
    int i=2 ;
    while(N!=1){
      while(N % i==0 && count!=0){
        list.add(i);
        N=N/i ;
        count--;
      }
      i++;
      if(i>N){
        break ;
      }
    }
    if(count==0 && N!=1){
      list.add(N);
      for(i=0 ; i<list.size(); i++){
        System.out.print(list.get(i)+" ");
      }
    }
    else {
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_k_Factorization {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var N : int ; N := reader.nextInt() ;
    var k : int ; k := reader.nextInt() ;
    var count : int ; count := k - 1 ;
    var list : Sequence(int) ; list := Sequence{} ;
    var i : int ; i := 2 ;
    while (N /= 1) do (     while (N mod i = 0 & count /= 0) do (     list := list->including(i) ; 
     N := N / i ; 
     count := count - 1 ) ; 
     i := i + 1 ; 
     if (i > N) then (     break ) else skip ) ; 
    if (count = 0 & N /= 1) then (     list := list->including(N) ; 
         i := 0 ; while i < list->size() do ( (     OclFile["System.out"].print(list->at(i+1) + " ") )  ;     i := i + 1 ) ) else (     OclFile["System.out"].println(-1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));
    int n=in.nextInt();
    int k=in.nextInt();
    ArrayList<Integer>lst=divs(n);
    if(lst.size()<k)pw.println(-1);
    else {
      while(lst.size()>k){
        int x=lst.get(lst.size()-1);
        lst.remove(lst.size()-1);
        int y=lst.get(lst.size()-1);
        lst.remove(lst.size()-1);
        lst.add(x*y);
      }
      for(Integer i : lst)pw.print(i+" ");
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
  static ArrayList<Integer>divs(int n){
    ArrayList<Integer>lst=new ArrayList<>();
    for(int i=2 ; i<=n ; i++){
      if(n % i==0){
        while(n % i==0){
          lst.add(i);
          n/=i ;
        }
      }
    }
    return lst ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var lst : Sequence(int) ; lst := divs(n) ;
    if (lst->size() < k) then     skip else (     while (lst->size() > k) do (     var x : int ; x := lst->at(lst->size() - 1+1) ;
     lst := lst->excludingFirst(lst->size() - 1) ; 
    var y : int ; y := lst->at(lst->size() - 1+1) ;
    lst := lst->excludingFirst(lst->size() - 1) ; 
    lst := lst->including(x * y) ; 
 ) ; 
     for (i : lst) do (     skip ;  ) ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
  static   operation divs( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var lst : Sequence(int) ; lst := Sequence{} ;
         var i : int ; i := 2 ; while i <= n do ( (     if (n mod i = 0) then (     while (n mod i = 0) do (     lst := lst->including(i) ; 
     n := n/(i) ) ) else skip )  ;     i := i + 1 ) ; 
     return lst );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAXN=30 ;
  static int countMaxLength(int N){
    int res ;
    int pre[]=new int[MAXN];
    int p=1 ;
    pre[0]=0 ;
    for(int i=1 ; i<MAXN ; i++){
      p*=2 ;
      pre[i]=pre[i-1]+i*p ;
    }
    int ind=0 ;
    for(int i=1 ; i<MAXN ; i++){
      if(pre[i]>=N){
        ind=i ;
        break ;
      }
    }
    int x=N-pre[ind-1];
    int y=2*ind-1 ;
    if(x>=y)res=Math.min(x,y);
    else res=Math.max(x,2*(ind-2)+1);
    return res ;
  }
  public static void main(String[] args){
    int N=25 ;
    System.out.println(countMaxLength(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAXN : int := 30;
  static   operation countMaxLength( N : int) : int
  pre: true
  post: true
  activity: (     var res : int ;
     var pre : Sequence(int) ; pre := Integer.subrange(1,MAXN)->collect(0) ;
    var p : int ; p := 1 ;
    pre[0+1] := 0 ; 
        var i : int ; i := 1 ; while i < MAXN do ( (     p := p*(2) ; 
     pre[i+1] := pre[i - 1+1] + i * p )  ;     i := i + 1 ) ; 
    var ind : int ; ind := 0 ;
        var i : int ; i := 1 ; while i < MAXN do ( (     if (pre[i+1] >= N) then (     ind := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var x : int ; x := N - pre[ind - 1+1] ;
    var y : int ; y := 2 * ind - 1 ;
    if (x >= y) then     res := Set{x, y}->min() else     res := Set{x, 2 * (ind - 2) + 1}->max() ; ;  
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 25 ;
     OclFile["System.out"].println(countMaxLength(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class test224 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      char a[]=in.next().toCharArray();
      Arrays.sort(a);
      for(int i=0 ; i<a.length ; i++){
        System.out.print(a[i]);
      }
      System.out.println();
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test224 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var a : Sequence(String) ; a := in.getCurrent()->characters() ;
     a := a->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do ( (     OclFile["System.out"].print(a[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int ans=0 ;
    int n=sc.nextInt();
    int[] in=new int[n];
    for(int i=0 ; i<n ; i++)in[i]=sc.nextInt();
    for(int t=0 ; t<n ; t++){
      int num=in[t];
      if(num==1)continue ;
      boolean f=true ;
      for(int i=2 ; i*i<=num ; i++){
        if(num % i==0){
          f=false ;
          break ;
        }
      }
      if(f)ans++;
    }
    cout(ans);
  }
  public static boolean isPrime(int n){
    for(int i=2 ; i<=n*n ; i++){
      if(n % i==0)return true ;
    }
    return false ;
  }
  public static int gcd(int a,int b){
    if(a % b==0)return b ;
    else return gcd(b,a % b);
  }
  public static void showary(int[] ary){
    for(int i=0 ; i<ary.length-1 ; i++){
      System.out.print(ary[i]+" ");
    }
    cout(ary[ary.length-1]);
  }
  public static void cout(String n){
    System.out.println(n);
  }
  public static void cout(int n){
    System.out.println(n);
  }
  public static void cout(boolean n){
    if(n==true){
      cout("true");
    }
    else {
      cout("false");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ans : int ; ans := 0 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var in : Sequence(int) ; in := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     in[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var t : int ; t := 0 ; while t < n do ( (     var num : int ; num := in[t+1] ;
     if (num = 1) then     continue else skip ; 
    var f : boolean ; f := true ;
        var i : int ; i := 2 ; while i * i <= num do ( (     if (num mod i = 0) then (     f := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (f) then     ans := ans + 1 ; else skip ; 
 )  ;     t := t + 1 ) ; 
    execute cout(ans) ; 
 );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i <= n * n do ( (     if (n mod i = 0) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a mod b = 0) then     return b else     return gcd(b, a mod b) );
  static   operation showary( ary : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < ary->size() - 1 do ( (     OclFile["System.out"].print(ary[i+1] + " ") )  ;     i := i + 1 ) ; 
     execute cout(ary[ary->size() - 1+1]) );
  static   operation cout( n : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(n) );
  static   operation cout( n : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(n) );
  static   operation cout( n : boolean) : void
  pre: true
  post: true
  activity: (     if (n = true) then (     execute cout("true") ) else (     execute cout("false") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class E121A {
  public static void main(String[] args){
    int[] cot=new int[26];
    Scanner in=new Scanner(System.in);
    int round=in.nextInt();
    for(int z=0 ; z<round ; z++){
      for(int i=0 ; i<26 ; i++)cot[i]=0 ;
      String str=in.next();
      for(int i=0 ; i<str.length(); i++)cot[str.charAt(i)-'a']++;
      for(int i=0 ; i<26 ; i++)for(int j=0 ; j<cot[i]; j++)System.out.print((char)('a'+i));
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class E121A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cot : Sequence(int) ; cot := Integer.subrange(1,26)->collect(0) ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var round : int ; round := in.getCurrent()->toInteger() ;
         var z : int ; z := 0 ; while z < round do ( (         var i : int ; i := 0 ; while i < 26 do (     cot[i+1] := 0 ;  ;     i := i + 1 ) ; 
     var str : String ; str := in.getCurrent() ;
        var i : int ; i := 0 ; while i < str->size() do (     cot[str->at(i+1) - ('a')->char2byte()+1] := cot[str->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 26 do (         var j : int ; j := 0 ; while j < cot[i+1] do (     OclFile["System.out"].print(('a' + i)->oclAsType(String)) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     z := z + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int reverse(int x){
    int rev=0 ;
    while(x>0){
      rev=(rev*10)+x % 10 ;
      x=x/10 ;
    }
    return rev ;
  }
  static void printEmirp(int n){
    boolean prime[]=new boolean[n+1];
    Arrays.fill(prime,true);
    for(int p=2 ; p*p<=n ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=n ; i+=p)prime[i]=false ;
      }
    }
    for(int p=2 ; p<=n ; p++){
      if(prime[p]){
        int rev=reverse(p);
        if(p!=rev && rev<=n && prime[rev]){
          System.out.print(p+" "+rev+" ");
          prime[rev]=false ;
        }
      }
    }
  }
  public static void main(String[] args){
    int n=100 ;
    printEmirp(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation reverse( x : int) : int
  pre: true
  post: true
  activity: (     var rev : int ; rev := 0 ;
     while (x > 0) do (     rev := (rev * 10) + x mod 10 ; 
     x := x / 10 ) ; 
     return rev );
  static   operation printEmirp( n : int) : void
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,n + 1)->collect(false) ;
     prime := prime->collect(true) ; 
         var p : int ; p := 2 ; while p * p <= n do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= n do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
         var p : int ; p := 2 ; while p <= n do ( (     if (prime[p+1]) then (     var rev : int ; rev := reverse(p) ;
     if (p /= rev & rev <= n & prime[rev+1]) then (     OclFile["System.out"].print(p + " " + rev + " ") ; 
     prime[rev+1] := false ) else skip ) else skip )  ;     p := p + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 100 ;
     execute printEmirp(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  private static final int mod=(int)1e9+7 ;
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    String s=sc.next();
    if(s.charAt(s.length()-1)!='s'){
      System.out.println(s+"s");
    }
    else if(s.charAt(s.length()-1)=='s')System.out.println(s+"es");
  }
  static long nCr(int n,int r,int p){
    if(r==0)return 1 ;
    int[] fac=new int[n+1];
    fac[0]=1 ;
    for(int i=1 ; i<=n ; i++)fac[i]=fac[i-1]*i % p ;
    return(fac[n]*modInverse(fac[r],p)% p*modInverse(fac[n-r],p)% p)% p ;
  }
  static long modInverse(int n,int p){
    return pow(n,p-2)% mod ;
  }
  static long pow(long x,long y){
    long res=1l ;
    while(y!=0){
      if(y % 2==1){
        res=x*res % mod ;
      }
      y/=2 ;
      x=x*x % mod ;
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute mod : int := 1e9->oclAsType(int) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var s : String ; s := sc.getCurrent() ;
     if (s->at(s->size() - 1+1) /= 's') then (     OclFile["System.out"].println(s + "s") ) else     if (s->at(s->size() - 1+1) = 's') then     OclFile["System.out"].println(s + "es") ; else skip ; );
  static   operation nCr( n : int, r : int, p : int) : long
  pre: true
  post: true
  activity: (     if (r = 0) then     return 1 else skip ; 
     var fac : Sequence(int) ; fac := Integer.subrange(1,n + 1)->collect(0) ;
    fac[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do (     fac[i+1] := fac[i - 1+1] * i mod p ;  ;     i := i + 1 ) ; 
    return (fac[n+1] * modInverse(fac[r+1], p) mod p * modInverse(fac[n - r+1], p) mod p) mod p 
 );
  static   operation modInverse( n : int, p : int) : long
  pre: true
  post: true
  activity: (     return pow(n, p - 2) mod mod );
  static   operation pow( x : long, y : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1l ;
     while (y /= 0) do (     if (y mod 2 = 1) then (     res := x * res mod mod ) else skip ; 
     y := y/(2) ; 
     x := x * x mod mod ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public final class Main {
  public static void main(String[] args){
    final FastScanner fs=new FastScanner();
    final String s=fs.next();
    if(s.endsWith("s")){
      System.out.print(s+"es");
    }
    else {
      System.out.print(s+"s");
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      final int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=nextInt();
      }
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var s : String ; s := fs.next() ;
     if (s->hasSuffix("s")) then (     OclFile["System.out"].print(s + "es") ) else (     OclFile["System.out"].print(s + "s") ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.InputStream ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    APluralForm solver=new APluralForm();
    solver.solve(1,in,out);
    out.close();
  }
  static class APluralForm {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      String s=in.readString();
      int n=s.length();
      System.out.println(s.charAt(n-1)=='s' ? s+"es" : s+"s");
    }
  }
  static class InputReader {
    private InputStream stream ;
    private byte[] buf=new byte[1024];
    private int curChar ;
    private int numChars ;
    public InputReader(InputStream stream){
      this.stream=stream ;
    }
    public int read(){
      if(numChars==-1)throw new RuntimeException();
      if(curChar>=numChars){
        curChar=0 ;
        try {
          numChars=stream.read(buf);
        }
        catch(IOException e){
          throw new RuntimeException();
        }
        if(numChars<=0)return-1 ;
      }
      return buf[curChar++];
    }
    public String readString(){
      final StringBuilder stringBuilder=new StringBuilder();
      int c=read();
      while(isSpaceChar(c))c=read();
      do {
        stringBuilder.append((char)c);
        c=read();
      }
      while(! isSpaceChar(c));
      return stringBuilder.toString();
    }
    public boolean isSpaceChar(int c){
      return c==' ' || c=='\n' || c=='\r' || c=='\t' || c==-1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : APluralForm ; solver := APluralForm.newAPluralForm() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class APluralForm {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.readString() ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].println(if s->at((n)->char2byte() - 1+1) = 's' then s + "es" else s + "s" endif) );
}
  static class InputReader {
   attribute stream : OclFile;
   attribute buf : Sequence(int) := Integer.subrange(1,1024)->collect(0);
   attribute curChar : int;
   attribute numChars : int;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     self.stream := stream );
   operation read() : int
  pre: true
  post: true
  activity: (     if (numChars = -1) then     error ProgramException() ; else skip ; 
     if (curChar >= numChars) then (     curChar := 0 ; 
     try (     numChars := stream.read(buf) )   catch (e : IOException) do (     error ProgramException() )
     if (numChars <= 0) then     return -1 else skip ) else skip ; 
     return buf[curChar+1] );
   operation readString() : String
  pre: true
  post: true
  activity: (     var stringBuilder : String ; stringBuilder := StringLib.newString() ;
     var c : int ; c := read() ;
    while (isSpaceChar(c)) do     c := read() ; ; 
  while true do ((     stringBuilder := stringBuilder + StringLib.newString(c->oclAsType(String)) ; 
     c := read() ) ;
    if (not(isSpaceChar(c))) then skip else break) ; 
    return stringBuilder+"" 
 );
   operation isSpaceChar( c : int) : boolean
  pre: true
  post: true
  activity: (     return c = ' ' or c = '
' or c = '\r' or c = '\t' or c = -1 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class hexagon {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int a1=Integer.parseInt(st.nextToken());
    int a2=Integer.parseInt(st.nextToken());
    int a3=Integer.parseInt(st.nextToken());
    int a4=Integer.parseInt(st.nextToken());
    int a5=Integer.parseInt(st.nextToken());
    int a6=Integer.parseInt(st.nextToken());
    br.close();
    int res=s(a1+a2+a3)-s(a1)-s(a3)-s(a5);
    System.out.println(res);
  }
  static int s(int k){
    return k*k ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class hexagon {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var a1 : int ; a1 := (st.next())->toInteger() ;
    var a2 : int ; a2 := (st.next())->toInteger() ;
    var a3 : int ; a3 := (st.next())->toInteger() ;
    var a4 : int ; a4 := (st.next())->toInteger() ;
    var a5 : int ; a5 := (st.next())->toInteger() ;
    var a6 : int ; a6 := (st.next())->toInteger() ;
    skip ; 
    var res : int ; res := s(a1 + a2 + a3) - s(a1) - s(a3) - s(a5) ;
    OclFile["System.out"].println(res) ; 
 );
  static   operation s( k : int) : int
  pre: true
  post: true
  activity: (     return k * k );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int height=sc.nextInt();
    int width=sc.nextInt();
    List<List<Integer>>listHeight=new ArrayList<>();
    for(int cntHeight=0 ; cntHeight<height ; cntHeight++){
      String str=sc.next();
      List<Integer>listWidth=new ArrayList<>();
      for(int cntWidth=0 ; cntWidth<width ; cntWidth++){
        listWidth.add((str.charAt(cntWidth)=='#')? 1 : 0);
      }
      listHeight.add(listWidth);
    }
    sc.close();
    for(int cntHeight=height-1 ; cntHeight>-1 ; cntHeight--){
      int sum=0 ;
      for(int cntWidth=0 ; cntWidth<width ; cntWidth++){
        sum=sum+listHeight.get(cntHeight).get(cntWidth);
      }
      if(sum==0){
        listHeight.remove(cntHeight);
        height--;
      }
    }
    for(int cntWidth=width-1 ; cntWidth>-1 ; cntWidth--){
      int sum=0 ;
      for(List<Integer>list : listHeight){
        sum=sum+list.get(cntWidth);
      }
      if(sum==0){
        for(List<Integer>list : listHeight){
          list.remove(cntWidth);
        }
        width--;
      }
    }
    for(List<Integer>list : listHeight){
      for(int cntWidth=0 ; cntWidth<width ; cntWidth++){
        System.out.print(list.get(cntWidth)==1 ? "#" : ".");
      }
      System.out.println("\n");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var height : int ; height := sc.getCurrent()->toInteger() ;
    var width : int ; width := sc.getCurrent()->toInteger() ;
    var listHeight : Sequence(Sequence(int)) ; listHeight := Sequence{} ;
        var cntHeight : int ; cntHeight := 0 ; while cntHeight < height do ( (     var str : String ; str := sc.getCurrent() ;
     var listWidth : Sequence(int) ; listWidth := Sequence{} ;
         var cntWidth : int ; cntWidth := 0 ; while cntWidth < width do ( (     listWidth := listWidth->including(if (str->at(cntWidth+1) = '#') then 1 else 0 endif) )  ;     cntWidth := cntWidth + 1 ) ; 
     listHeight := listHeight->including(listWidth) )  ;     cntHeight := cntHeight + 1 ) ; 
    skip ; 
        var cntHeight : int ; cntHeight := height - 1 ; while cntHeight > -1 do ( (     var sum : int ; sum := 0 ;
         var cntWidth : int ; cntWidth := 0 ; while cntWidth < width do ( (     sum := sum + listHeight->at(cntHeight+1)->at(cntWidth+1) )  ;     cntWidth := cntWidth + 1 ) ; 
     if (sum = 0) then (     listHeight := listHeight->excludingAt(cntHeight+1) ; 
     height := height - 1 ) else skip )  ;     cntHeight := cntHeight - 1 ) ; 
        var cntWidth : int ; cntWidth := width - 1 ; while cntWidth > -1 do ( (     var sum : int ; sum := 0 ;
     for (list : listHeight) do ( (     sum := sum + list->at(cntWidth+1) )  ) ; 
     if (sum = 0) then (     for (list : listHeight) do ( (     list := list->excludingAt(cntWidth+1) )  ) ; 
     width := width - 1 ) else skip )  ;     cntWidth := cntWidth - 1 ) ; 
    for (list : listHeight) do ( (         var cntWidth : int ; cntWidth := 0 ; while cntWidth < width do ( (     OclFile["System.out"].print(if list->at(cntWidth+1) = 1 then "#" else "." endif) )  ;     cntWidth := cntWidth + 1 ) ; 
     OclFile["System.out"].println("\n") )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    if(s.charAt(s.length()-1)=='s'){
      s+="es" ;
    }
    else {
      s+="s" ;
    }
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
     if (s->at(s->size() - 1+1) = 's') then (     s := s+("es") ) else (     s := s+("s") ) ;  
     OclFile["System.out"].println(s) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
class GFG {
  static int maxIndexDiff(int arr[],int n){
    int maxDiff ;
    int i,j ;
    int LMin[],RMax[];
    LMin=new int[n];
    RMax=new int[n];
    LMin[0]=arr[0];
    for(i=1 ; i<n ; ++i)LMin[i]=Math.min(arr[i],LMin[i-1]);
    RMax[n-1]=arr[n-1];
    for(j=n-2 ; j>=0 ; --j)RMax[j]=Math.max(arr[j],RMax[j+1]);
    i=0 ;
    j=0 ;
    maxDiff=-1 ;
    while(j<n && i<n){
      if(LMin[i]<RMax[j]){
        maxDiff=Math.max(maxDiff,j-i);
        j=j+1 ;
      }
      else i=i+1 ;
    }
    return(maxDiff+1);
  }
  static void modifyarr(int arr[],int n,int x){
    for(int i=0 ; i<n ; i++)arr[i]=arr[i]-x ;
  }
  static void calcprefix(int arr[],int n){
    int s=0 ;
    for(int i=0 ; i<n ; i++){
      s+=arr[i];
      arr[i]=s ;
    }
  }
  static int longestsubarray(int arr[],int n,int x){
    modifyarr(arr,n,x);
    calcprefix(arr,n);
    return maxIndexDiff(arr,n);
  }
  public static void main(String args[]){
    int[] arr={
      1,1,2,-1,-1,1 };
      int x=1 ;
      int n=arr.length ;
      System.out.println(longestsubarray(arr,n,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxIndexDiff( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var maxDiff : int ;
     var i : int ;
    var j : int ;
    var LMin : Sequence(int) ;
    var RMax : Sequence(void) ;
    LMin := Integer.subrange(1,n)->collect(0) ; 
    RMax := Integer.subrange(1,n)->collect(0) ; 
    LMin[0+1] := arr[0+1] ; 
        i := 1 ; while i < n do (     LMin[i+1] := Set{arr[i+1], LMin[i - 1+1]}->min() ;  ;     i := i + 1 ) ; 
    RMax[n - 1+1] := arr[n - 1+1] ; 
        j := n - 2 ; while j >= 0 do (     RMax[j+1] := Set{arr[j+1], RMax[j + 1+1]}->max() ;  ;     j := j - 1 ) ; 
    i := 0 ; 
    j := 0 ; 
    maxDiff := -1 ; 
    while (j < n & i < n) do (     if (LMin[i+1] < RMax[j+1]) then (     maxDiff := Set{maxDiff, j - i}->max() ; 
     j := j + 1 ) else     i := i + 1 ; ) ; 
    return (maxDiff + 1) 
 );
  static   operation modifyarr( arr : Sequence(int), n : int, x : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     arr[i+1] := arr[i+1] - x ;  ;     i := i + 1 ) );
  static   operation calcprefix( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var s : int ; s := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     s := s+(arr[i+1]) ; 
     arr[i+1] := s )  ;     i := i + 1 ) );
  static   operation longestsubarray( arr : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     execute modifyarr(arr, n, x) ; 
     execute calcprefix(arr, n) ; 
     return maxIndexDiff(arr, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,2,-1,-1,1} ;
     var x : int ; x := 1 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(longestsubarray(arr, n, x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.Math ;
class Judge {
  boolean isPrime(int p){
    if(p==2){
      return true ;
    }
    if(p<2 ||(p % 2)==0){
      return false ;
    }
    for(int i=3 ; i<=Math.sqrt(p); i+=2){
      if(p % i==0){
        return false ;
      }
    }
    return true ;
  }
}
class Main {
  public static void main(String[] args){
    int num ;
    int input ;
    int cnt=0 ;
    Scanner sc=new Scanner(System.in);
    Judge j=new Judge();
    num=sc.nextInt();
    for(int i=0 ; i<num ; i++){
      input=sc.nextInt();
      if(j.isPrime(input))cnt++;
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Judge {
   operation isPrime( p : int) : boolean
  pre: true
  post: true
  activity: (     if (p = 2) then (     return true ) else skip ; 
     if (p < 2 or (p mod 2) = 0) then (     return false ) else skip ; 
         var i : int ; i := 3 ; while i <= (p)->sqrt() do ( (     if (p mod i = 0) then (     return false ) else skip )  ;     i := i+(2) ) ; 
     return true );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ;
     var input : int ;
    var cnt : int ; cnt := 0 ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var j : Judge ; j := Judge.newJudge() ;
    num := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < num do ( (     input := sc.getCurrent()->toInteger() ; 
     if (j.isPrime(input)) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void solve(String[] str){
    int n=str.length ;
    int ans=0x7f7f7f7f ;
    for(int i=0 ; i<n ; ++i){
      int res=0 ;
      for(int j=0 ; j<n ; ++j){
        char[] t=str[j] .toCharArray();
        if(i==j){
          continue ;
        }
        int cnt=0 ;
        while(! str[i] .equals(String.valueOf(t))){
          rotate(t);
          res++;
          cnt++;
          if(cnt>t.length){
            ans=-1 ;
            break ;
          }
        }
      }
      ans=Math.min(ans,res);
    }
    System.out.println(ans);
  }
  public static void rotate(char[] str){
    char f=str[0];
    for(int i=0 ; i<str.length-1 ; ++i){
      str[i]=str[i+1];
    }
    str[str.length-1]=f ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n ;
    n=in.nextInt();
    String[] str=new String[n];
    for(int i=0 ; i<n ; i++){
      str[i]=in.next();
    }
    solve(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( str : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var ans : int ; ans := 0x7f7f7f7f ;
         var i : int ; i := 0 ; while i < n do ( (     var res : int ; res := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     var t : Sequence(String) ; t := str[j+1]->characters() ;
     if (i = j) then (     continue ) else skip ; 
     var cnt : int ; cnt := 0 ;
     while (not(str[i+1] = (t)->sum() )) do (     execute rotate(t) ; 
     res := res + 1 ; 
     cnt := cnt + 1 ; 
     if (cnt > t->size()) then (     ans := -1 ; 
     break ) else skip ) )  ;     j := j + 1 ) ; 
     ans := Set{ans, res}->min() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) );
  static   operation rotate( str : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : String ; f := str[0+1] ;
         var i : int ; i := 0 ; while i < str->size() - 1 do ( (     str[i+1] := str[i + 1+1] )  ;     i := i + 1 ) ; 
     str[str->size() - 1+1] := f );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    n := in.getCurrent()->toInteger() ; 
    var str : Sequence(String) ; str := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     str[i+1] := in.getCurrent() )  ;     i := i + 1 ) ; 
    execute solve(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Mike_and_Strings {
  public static void main(String args[])throws Exception {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    int runs=Integer.parseInt(f.readLine());
    String[] arr=new String[runs];
    for(int x=0 ; x<runs ; x++)arr[x]=f.readLine();
    int min=Integer.MAX_VALUE ;
    boolean flag=true ;
    loop : for(int x=0 ;
    x<runs ;
    x++){
      String temp=arr[x];
      int num=0 ;
      for(int y=0 ; y<runs ; y++)if(! temp.equals(arr[y])){
        int counter=-1 ;
        for(int z=1 ; z<arr[y] .length(); z++)if(temp.equals(arr[y] .substring(z)+arr[y] .substring(0,z))){
          counter=z ;
          break ;
        }
        if(counter==-1){
          flag=false ;
          break loop ;
        }
        else num+=counter ;
      }
      min=Math.min(min,num);
    }
    System.out.println(flag ? min :-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mike_and_Strings {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var runs : int ; runs := (f.readLine())->toInteger() ;
    var arr : Sequence(String) ; arr := Integer.subrange(1,runs)->collect(null) ;
        var x : int ; x := 0 ; while x < runs do (     arr[x+1] := f.readLine() ;  ;     x := x + 1 ) ; 
    var min : int ; min := 2147483647 ;
    var flag : boolean ; flag := true ;
        var x : int ; x := 0 ; while x < runs do ( (     var temp : String ; temp := arr[x+1] ;
     var num : int ; num := 0 ;
         var y : int ; y := 0 ; while y < runs do (     if (not(temp = arr[y+1])) then (     var counter : int ; counter := -1 ;
         var z : int ; z := 1 ; while z < arr[y+1]->size() do (     if (temp = arr[y+1].subrange(z+1,z) + arr[y+1].subrange(0+1,z)) then (     counter := z ; 
     break ) else skip ;  ;     z := z + 1 ) ; 
     if (counter = -1) then (     flag := false ; 
     break ) else     num := num+(counter) ; ) else skip ;  ;     y := y + 1 ) ; 
     min := Set{min, num}->min() )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println(if flag then min else -1 endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class solution {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static StringTokenizer st=new StringTokenizer("");
  static public String next(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return st.nextToken();
  }
  static int min(int a,int b){
    return a>=b ? b : a ;
  }
  public static void main(String[] args)throws IOException {
    PrintWriter op=new PrintWriter(System.out);
    int n=Integer.parseInt(next());
    String[] sar=new String[n];
    String[] sar1=new String[n];
    for(int i=0 ; i<n ; i++){
      sar[i]=next();
      sar1[i]=sar[i]+sar[i];
    }
    int ans=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      int count=0 ;
      for(int j=0 ; j<n ; j++){
        if(sar1[j] .contains(sar[i])){
          if(i!=j){
            count+=sar1[j] .indexOf(sar[i]);
          }
        }
        else {
          op.println("-1");
          op.close();
          return ;
        }
      }
      ans=min(ans,count);
    }
    op.println(ans);
    op.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute st : OclIterator := OclIterator.newOclIterator_String("");
  static    operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
  static   operation min( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if a >= b then b else a endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var op : OclFile ; op := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var n : int ; n := (next())->toInteger() ;
    var sar : Sequence(String) ; sar := Integer.subrange(1,n)->collect(null) ;
    var sar1 : Sequence(String) ; sar1 := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     sar[i+1] := next() ; 
     sar1[i+1] := sar[i+1] + sar[i+1] )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (sar1[j+1]->includes(sar[i+1])) then (     if (i /= j) then (     count := count+(sar1[j+1]->indexOf(sar[i+1])-1) ) else skip ) else (     skip ; 
     skip ; 
     return ) )  ;     j := j + 1 ) ; 
     ans := Set{ans, count}->min() )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MikeandStrings {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    String[] s=new String[n];
    for(int i=0 ; i<n ; i++){
      s[i]=input.next();
      s[i]+=s[i];
    }
    int answer=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      String temp=s[i] .substring(0,s[i] .length()/2);
      int counter=0 ;
      for(int j=0 ; j<n ; j++){
        int t=s[j] .indexOf(temp);
        if(t==-1)answer=-1 ;
        else counter+=t ;
      }
      answer=Math.min(answer,counter);
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MikeandStrings {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := input.getCurrent() ; 
     s[i+1] := s[i+1]+(s[i+1]) )  ;     i := i + 1 ) ; 
    var answer : int ; answer := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : String ; temp := s[i+1].subrange(0+1,s[i+1]->size() / 2) ;
     var counter : int ; counter := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     var t : int ; t := s[j+1]->indexOf(temp)-1 ;
     if (t = -1) then     answer := -1 ; else     counter := counter+(t) ; )  ;     j := j + 1 ) ; 
     answer := Set{answer, counter}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double area_of_circle(int m,int n){
    int square_of_radius=(m*n)/4 ;
    double area=(3.141*square_of_radius);
    return area ;
  }
  public static void main(String[] args){
    int n=10 ;
    int m=30 ;
    System.out.println(area_of_circle(m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation area_of_circle( m : int, n : int) : double
  pre: true
  post: true
  activity: (     var square_of_radius : int ; square_of_radius := (m * n) / 4 ;
     var area : double ; area := (3.141 * square_of_radius) ;
     return area );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     var m : int ; m := 30 ;
     OclFile["System.out"].println(area_of_circle(m, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
public class Main {
  public static final int BIG_NUM=2000000000 ;
  public static final int MOD=1000000007 ;
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String input[]=br.readLine().split("\\s+");
      String str_A=input[0],str_B=input[1];
      BigInteger A=new BigInteger(input[0]);
      if(str_B.charAt(0)=='-'){
        str_B=str_B.substring(1);
      }
      else {
        str_B="-"+str_B ;
      }
      BigInteger B=new BigInteger(str_B);
      BigInteger ans ;
      ans=A.add(B);
      System.out.println(ans);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BIG_NUM : int := 2000000000;
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var input : Sequence(String) ; input := br.readLine()->split("\\s+") ;
     var str_A : String ; str_A := input[0+1] ;
    var str_B : String ; str_B := input[1+1] ;
    var A : long ; A := long(input[0+1]) ;
    if (str_B->at(0+1) = '-') then (     str_B := str_B.subrange(1+1,1) ) else (     str_B := "-" + str_B ) ;  
    var B : long ; B := long(str_B) ;
    var ans : long ;
    ans := A->excludes(B) ; 
    OclFile["System.out"].println(ans) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    BigInteger a,b ;
    Scanner cin=new Scanner(System.in);
    a=cin.nextBigInteger();
    b=cin.nextBigInteger();
    System.out.println(a.subtract(b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ;
    var b : long ;
     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    a := cin.nextBigInteger() ; 
    b := cin.nextBigInteger() ; 
    OclFile["System.out"].println(a.subtract(b)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(new BufferedInputStream(System.in));
    while(in.hasNext()){
      BigInteger a=in.nextBigInteger(),b=in.nextBigInteger();
      System.out.println(a.subtract(b));
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (in.hasNext()) do (     var a : long ; a := in.nextBigInteger() ;
    var b : long ; b := in.nextBigInteger() ;
     OclFile["System.out"].println(a.subtract(b)) ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    String HArray[][];
    HArray=new String[H][W];
    int flagArray[][];
    flagArray=new int[H][W];
    sc.nextLine();
    for(int i=0 ; i<H ; i++){
      String line=sc.nextLine();
      String[] array=line.split("");
      for(int j=0 ; j<array.length ; j++){
        HArray[i][j]=array[j];
        flagArray[i][j]=0 ;
      }
    }
    boolean flag=false ;
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        String a=HArray[i][j];
        if(a.equals("#")){
          flag=true ;
        }
      }
      if(flag==false){
        for(int j=0 ; j<W ; j++){
          flagArray[i][j]=-1 ;
        }
      }
      flag=false ;
    }
    for(int i=0 ; i<W ; i++){
      for(int j=0 ; j<H ; j++){
        String a=HArray[j][i];
        if(a.equals("#")){
          flag=true ;
        }
      }
      if(flag==false){
        for(int j=0 ; j<H ; j++){
          flagArray[j][i]=-1 ;
        }
      }
      flag=false ;
    }
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        if(flagArray[i][j]==0){
          System.out.print(HArray[i][j]);
          flag=true ;
        }
      }
      if(flag==true){
        System.out.println();
      }
      flag=false ;
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var HArray : Sequence(Sequence(String)) ;
    HArray := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(null)) ; 
    var flagArray : Sequence(Sequence(int)) ;
    flagArray := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ; 
    skip ; 
        var i : int ; i := 0 ; while i < H do ( (     var line : String ; line := sc.nextLine() ;
     var array : Sequence(String) ; array := line->split("") ;
         var j : int ; j := 0 ; while j < array->size() do ( (     HArray[i+1][j+1] := array[j+1] ; 
     flagArray[i+1][j+1] := 0 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     var a : String ; a := HArray[i+1][j+1] ;
     if (a = "#") then (     flag := true ) else skip )  ;     j := j + 1 ) ; 
     if (flag = false) then (         var j : int ; j := 0 ; while j < W do ( (     flagArray[i+1][j+1] := -1 )  ;     j := j + 1 ) ) else skip ; 
     flag := false )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < W do ( (         var j : int ; j := 0 ; while j < H do ( (     var a : String ; a := HArray[j+1][i+1] ;
     if (a = "#") then (     flag := true ) else skip )  ;     j := j + 1 ) ; 
     if (flag = false) then (         var j : int ; j := 0 ; while j < H do ( (     flagArray[j+1][i+1] := -1 )  ;     j := j + 1 ) ) else skip ; 
     flag := false )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (flagArray[i+1][j+1] = 0) then (     OclFile["System.out"].print(HArray[i+1][j+1]) ; 
     flag := true ) else skip )  ;     j := j + 1 ) ; 
     if (flag = true) then (     OclFile["System.out"].println() ) else skip ; 
     flag := false )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    BigInteger a=new BigInteger(str);
    str=sc.next();
    BigInteger b=new BigInteger(str);
    System.out.println(a.subtract(b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var a : long ; a := long(str) ;
    str := sc.getCurrent() ; 
    var b : long ; b := long(str) ;
    OclFile["System.out"].println(a.subtract(b)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int Pm(int[] A){
    int count=0 ;
    for(int i=0 ; i<A.length ; i++){
      boolean NumberF=true ;
      for(int j=2 ; j<=Math.sqrt(A[i]); j++){
        if(A[i]<2){
          NumberF=false ;
          break ;
        }
        else if(A[i]==2){
          break ;
        }
        else if(A[i] % 2==0){
          NumberF=false ;
          break ;
        }
        if(A[i] % j==0){
          NumberF=false ;
          break ;
        }
      }
      if(NumberF)count++;
    }
    return count ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] box=new int[n];
    for(int i=0 ; i<n ; i++){
      box[i]=sc.nextInt();
    }
    System.out.println(Pm(box));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation Pm( A : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < A->size() do ( (     var NumberF : boolean ; NumberF := true ;
         var j : int ; j := 2 ; while j <= (A[i+1])->sqrt() do ( (     if (A[i+1] < 2) then (     NumberF := false ; 
     break ) else     if (A[i+1] = 2) then (     break ) else     if (A[i+1] mod 2 = 0) then (     NumberF := false ; 
     break ) else skip ; ;  ;  
     if (A[i+1] mod j = 0) then (     NumberF := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (NumberF) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var box : Sequence(int) ; box := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     box[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Pm(box)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    String s ;
    Scanner reader=new Scanner(System.in);
    s=reader.nextLine();
    String[] str ;
    str=s.split(" ");
    BigInteger a=new BigInteger(str[0]);
    BigInteger b=new BigInteger(str[1]);
    BigInteger c=a.subtract(b);
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    s := reader.nextLine() ; 
    var str : Sequence(String) ;
    str := s->split(" ") ; 
    var a : long ; a := long(str[0+1]) ;
    var b : long ; b := long(str[1+1]) ;
    var c : long ; c := a.subtract(b) ;
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static long powerNumbers(int n){
    HashSet<Long>v=new HashSet<Long>();
    for(long i=2 ; i*i*i<=n ; i++){
      long j=i*i ;
      while(j*i<=n){
        j*=i ;
        long s=(long)Math.sqrt(j);
        if(s*s!=j)v.add(j);
      }
    }
    return v.size()+(long)Math.sqrt(n);
  }
  public static void main(String args[]){
    System.out.print(powerNumbers(50));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation powerNumbers( n : int) : long
  pre: true
  post: true
  activity: (     var v : Set(long) ; v := Set{} ;
         var i : long ; i := 2 ; while i * i * i <= n do ( (     var j : long ; j := i * i ;
     while (j * i <= n) do (     j := j*(i) ; 
     var s : long ; s := (j)->sqrt()->oclAsType(long) ;
     if (s * s /= j) then     v := v->including(j) ; else skip ) )  ;     i := i + 1 ) ; 
     return v->size() + (n)->sqrt()->oclAsType(long) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(powerNumbers(50)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int n=3 ;
  static int dotProduct(int vect_A[],int vect_B[]){
    int product=0 ;
    for(int i=0 ; i<n ; i++)product=product+vect_A[i]*vect_B[i];
    return product ;
  }
  static void crossProduct(int vect_A[],int vect_B[],int cross_P[]){
    cross_P[0]=vect_A[1]*vect_B[2]-vect_A[2]*vect_B[1];
    cross_P[1]=vect_A[2]*vect_B[0]-vect_A[0]*vect_B[2];
    cross_P[2]=vect_A[0]*vect_B[1]-vect_A[1]*vect_B[0];
  }
  public static void main(String[] args){
    int vect_A[]={
      3,-5,4 };
      int vect_B[]={
        2,6,5 };
        int cross_P[]=new int[n];
        System.out.print("Dot product:");
        System.out.println(dotProduct(vect_A,vect_B));
        System.out.print("Cross product:");
        crossProduct(vect_A,vect_B,cross_P);
        for(int i=0 ; i<n ; i++)System.out.print(cross_P[i]+" ");
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute n : int := 3;
  static   operation dotProduct( vect_A : Sequence(int), vect_B : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var product : int ; product := 0 ;
         var i : int ; i := 0 ; while i < n do (     product := product + vect_A[i+1] * vect_B[i+1] ;  ;     i := i + 1 ) ; 
     return product );
  static   operation crossProduct( vect_A : Sequence(int), vect_B : Sequence(int), cross_P : Sequence(int)) : void
  pre: true
  post: true
  activity: (     cross_P[0+1] := vect_A[1+1] * vect_B[2+1] - vect_A[2+1] * vect_B[1+1] ; 
     cross_P[1+1] := vect_A[2+1] * vect_B[0+1] - vect_A[0+1] * vect_B[2+1] ; 
     cross_P[2+1] := vect_A[0+1] * vect_B[1+1] - vect_A[1+1] * vect_B[0+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var vect_A : Sequence(int) ; vect_A := Sequence{3,-5,4} ;
     var vect_B : Sequence(int) ; vect_B := Sequence{2,6,5} ;
    var cross_P : Sequence(int) ; cross_P := Integer.subrange(1,n)->collect(0) ;
    OclFile["System.out"].print("Dot product:") ; 
    OclFile["System.out"].println(dotProduct(vect_A, vect_B)) ; 
    OclFile["System.out"].print("Cross product:") ; 
    execute crossProduct(vect_A, vect_B, cross_P) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(cross_P[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
class GFG {
  public static double answer(double X,double K){
    double i=10 ;
    double MIN=Math.pow(i,K-1);
    if(MIN % X==0)return(MIN);
    else return((MIN+X)-((MIN+X)% X));
  }
  public static void main(String[] args){
    double X=83 ;
    double K=5 ;
    System.out.println((int)answer(X,K));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation answer( X : double, K : double) : double
  pre: true
  post: true
  activity: (     var i : double ; i := 10 ;
     var MIN : double ; MIN := i->pow(K - 1) ;
     if (MIN mod X = 0) then     return (MIN) else     return ((MIN + X) - ((MIN + X) mod X)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : double ; X := 83 ;
     var K : double ; K := 5 ;
     OclFile["System.out"].println(answer(X, K)->oclAsType(int)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Example {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      String no=sc.next();
      int prev=-1 ;
      int res=0 ;
      for(int i=0 ; i<no.length(); i++){
        if(no.charAt(i)=='1'){
          if(prev!=-1)res+=(i-prev-1);
          prev=i ;
        }
      }
      System.out.println(res);
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Example {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var no : String ; no := sc.getCurrent() ;
     var prev : int ; prev := -1 ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < no->size() do ( (     if (no->at(i+1) = '1') then (     if (prev /= -1) then     res := res+((i - (prev)->char2byte() - 1)) ; else skip ; 
     prev := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class erasingZeroes800 {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int inp=sc.nextInt();
    while(inp-->0){
      String num=sc.next();
      int nOne=0 ;
      int indexOfFirstOne=-1 ;
      for(int i=0 ; i<num.length(); i++){
        if(num.charAt(i)=='1'){
          if(indexOfFirstOne==-1)indexOfFirstOne=i ;
          nOne++;
        }
      }
      int eraseZero=0 ;
      for(int i=indexOfFirstOne ; i<num.length(); i++){
        if(nOne==0)break ;
        if(num.charAt(i)=='1'){
          nOne--;
        }
        else {
          eraseZero++;
        }
      }
      System.out.println(eraseZero);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class erasingZeroes800 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inp : int ; inp := sc.getCurrent()->toInteger() ;
         while (inp > 0) do (        inp := inp - 1 ;     skip ; (     var num : String ; num := sc.getCurrent() ;
     var nOne : int ; nOne := 0 ;
    var indexOfFirstOne : int ; indexOfFirstOne := -1 ;
        var i : int ; i := 0 ; while i < num->size() do ( (     if (num->at(i+1) = '1') then (     if (indexOfFirstOne = -1) then     indexOfFirstOne := i ; else skip ; 
     nOne := nOne + 1 ) else skip )  ;     i := i + 1 ) ; 
    var eraseZero : int ; eraseZero := 0 ;
        var i : int ; i := indexOfFirstOne ; while i < num->size() do ( (     if (nOne = 0) then     break else skip ; 
     if (num->at(i+1) = '1') then (     nOne := nOne - 1 ) else (     eraseZero := eraseZero + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(eraseZero) ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Sol {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int j=0 ; j<n ; j++){
      String s=sc.next();
      if(s.length()==1){
        System.out.println("0");
        continue ;
      }
      int index=s.indexOf('1');
      if(index==-1){
        System.out.println("0");
        continue ;
      }
      int end=s.length()-1 ;
      for(int i=s.length()-1 ; i>=index ; i--){
        if(s.charAt(i)=='1'){
          end=i ;
          break ;
        }
      }
      int count=0 ;
      for(int i=index ; i<=end ; i++){
        if(s.charAt(i)=='0'){
          count++;
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sol {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < n do ( (     var s : String ; s := sc.getCurrent() ;
     if (s->size() = 1) then (     OclFile["System.out"].println("0") ; 
     continue ) else skip ; 
    var index : int ; index := s->indexOf('1')-1 ;
    if (index = -1) then (     OclFile["System.out"].println("0") ; 
     continue ) else skip ; 
    var end : int ; end := s->size() - 1 ;
        var i : int ; i := s->size() - 1 ; while i >= index do ( (     if (s->at(i+1) = '1') then (     end := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := index ; while i <= end do ( (     if (s->at(i+1) = '0') then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test248 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      char a[]=in.next().toCharArray();
      boolean f=false ;
      int x=0,sum=0 ;
      for(int i=0 ; i<a.length ; i++){
        if(a[i]=='1' && f){
          sum+=x ;
        }
        if(a[i]=='1'){
          f=true ;
          x=0 ;
        }
        else {
          x++;
        }
      }
      System.out.println(sum);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test248 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var a : Sequence(String) ; a := in.getCurrent()->characters() ;
     var f : boolean ; f := false ;
    var x : int ; x := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] = '1' & f) then (     sum := sum+(x) ) else skip ; 
     if (a[i+1] = '1') then (     f := true ; 
     x := 0 ) else (     x := x + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MainClass {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int t=Integer.parseInt(st.nextToken());
    while(t-->0){
      st=new StringTokenizer(br.readLine());
      String s=st.nextToken();
      int cnt=0 ;
      int i=0 ;
      while(i<s.length()){
        char ch=s.charAt(i);
        if(ch=='0'){
          i++;
        }
        else {
          int j=i+1 ;
          while(j<s.length()&& s.charAt(j)=='0'){
            j++;
          }
          if(j!=s.length()){
            cnt+=j-i-1 ;
          }
          i=j ;
        }
      }
      System.out.println(cnt);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var t : int ; t := (st.next())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var s : String ; s := st.next() ;
    var cnt : int ; cnt := 0 ;
    var i : int ; i := 0 ;
    while (i < s->size()) do (     var ch : String ; ch := s->at(i+1) ;
     if (ch = '0') then (     i := i + 1 ) else (     var j : int ; j := i + 1 ;
     while (j < s->size() & s->at(j+1) = '0') do (     j := j + 1 ) ; 
     if (j /= s->size()) then (     cnt := cnt+((j)->char2byte() - i - 1) ) else skip ; 
     i := j ) ) ; 
    OclFile["System.out"].println(cnt) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int h=Integer.parseInt(sc.next());
    int w=Integer.parseInt(sc.next());
    char[][] a=new char[h][w];
    for(int i=0 ; i<h ; i++){
      a[i]=sc.next().toCharArray();
    }
    sc.close();
    List<char[]>list=new ArrayList<>();
    for(int i=0 ; i<h ; i++){
      if(new String(a[i]).replace(".","").length()!=0){
        list.add(a[i]);
      }
    }
    List<Integer>deleteIndexList=new ArrayList<>();
    for(int i=0 ; i<w ; i++){
      boolean isDelete=true ;
      for(int j=0 ; j<list.size(); j++){
        if(list.get(j)[i]=='#'){
          isDelete=false ;
          break ;
        }
      }
      if(isDelete){
        deleteIndexList.add(i);
      }
    }
    String result="" ;
    if(deleteIndexList.size()<w){
      for(int i=0 ; i<list.size(); i++){
        String line="" ;
        for(int j=0 ; j<w ; j++){
          if(! deleteIndexList.contains(j)){
            line+=list.get(i)[j];
          }
        }
        result+=line+"\n" ;
      }
    }
    else {
      result="\n" ;
    }
    System.out.print(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := (sc.getCurrent())->toInteger() ;
    var w : int ; w := (sc.getCurrent())->toInteger() ;
    var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (     a[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    skip ; 
    var list : Sequence(Sequence(String)) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < h do ( (     if (StringLib.newString(a[i+1]).replace(".", "")->size() /= 0) then (     list := list->including(a[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    var deleteIndexList : Sequence(int) ; deleteIndexList := Sequence{} ;
        var i : int ; i := 0 ; while i < w do ( (     var isDelete : boolean ; isDelete := true ;
         var j : int ; j := 0 ; while j < list->size() do ( (     if (list->at(j+1)[i+1] = '#') then (     isDelete := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (isDelete) then (     deleteIndexList := deleteIndexList->including(i) ) else skip )  ;     i := i + 1 ) ; 
    var result : String ; result := "" ;
    if (deleteIndexList->size() < w) then (         var i : int ; i := 0 ; while i < list->size() do ( (     var line : String ; line := "" ;
         var j : int ; j := 0 ; while j < w do ( (     if (not(deleteIndexList->includes(j))) then (     line := line+(list->at(i+1)[j+1]) ) else skip )  ;     j := j + 1 ) ; 
     result := result+(line + "\n") )  ;     i := i + 1 ) ) else (     result := "\n" ) ;  
    OclFile["System.out"].print(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1716A_Two_ThreeMoves {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int num=parseInt(input.nextLine());
      int reminder=num % 3 ;
      int firstPart=num/3 ;
      if(num==1){
        System.out.println(2);
      }
      else if(reminder==0){
        System.out.println(firstPart);
      }
      else {
        System.out.println(firstPart+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1716A_Two_ThreeMoves {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var num : int ; num := parseInt(input.nextLine()) ;
     var reminder : int ; reminder := num mod 3 ;
     var firstPart : int ; firstPart := num / 3 ;
     if (num = 1) then (     OclFile["System.out"].println(2) ) else     if (reminder = 0) then (     OclFile["System.out"].println(firstPart) ) else (     OclFile["System.out"].println(firstPart + 1) ) ;  ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    StringBuilder sb=new StringBuilder();
    Scanner as=new Scanner(System.in);
    int n=0 ;
    int i=0 ;
    int j=0 ;
    int count=0 ;
    int gre[];
    int pnum[];
    n=Integer.parseInt(as.next());
    pnum=new int[n];
    gre=new int[n];
    for(i=0 ; i<n ; i++){
      pnum[i]=Integer.parseInt(as.next());
      gre[i]=(int)Math.sqrt(pnum[i]);
    }
    for(i=0 ; i<n ; i++){
      for(j=2 ; j<=gre[i]+1 ; j++){
        if(j==gre[i]+1 && pnum[i]!=1){
          count++;
        }
        if(pnum[i] % j==0){
          break ;
        }
      }
    }
    sb.append(count);
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     var as : OclFile ; as := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := 0 ;
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    var count : int ; count := 0 ;
    var gre : Sequence(int) ;
    var pnum : Sequence(int) ;
    n := (as.getCurrent())->toInteger() ; 
    pnum := Integer.subrange(1,n)->collect(0) ; 
    gre := Integer.subrange(1,n)->collect(0) ; 
        i := 0 ; while i < n do ( (     pnum[i+1] := (as.getCurrent())->toInteger() ; 
     gre[i+1] := (pnum[i+1])->sqrt()->oclAsType(int) )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (         j := 2 ; while j <= gre[i+1] + 1 do ( (     if (j = gre[i+1] + 1 & pnum[i+1] /= 1) then (     count := count + 1 ) else skip ; 
     if (pnum[i+1] mod j = 0) then (     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(count) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double maxDistance(int n,int fuel){
    double dist_covered=0 ;
    while(n>0){
      dist_covered+=(double)fuel/n ;
      n-=1 ;
    }
    return dist_covered ;
  }
  public static void main(String[] args){
    int n=3 ;
    int fuel=100 ;
    System.out.println("Maximum distance possible with "+n+" bikes is "+maxDistance(n,fuel));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxDistance( n : int, fuel : int) : double
  pre: true
  post: true
  activity: (     var dist_covered : double ; dist_covered := 0 ;
     while (n > 0) do (     dist_covered := dist_covered+(fuel->oclAsType(double) / n) ; 
     n := n-(1) ) ; 
     return dist_covered );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var fuel : int ; fuel := 100 ;
     OclFile["System.out"].println("Maximum distance possible with " + n + " bikes is " + maxDistance(n, fuel)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class B_Binary_Palindromes {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int Q=sc.nextInt();
    for(int tc=0 ; tc<Q ; tc++){
      int n=sc.nextInt();
      String[] s=new String[n];
      for(int i=0 ; i<s.length ; i++){
        s[i]=sc.next();
      }
      System.out.println(solve(s));
    }
    sc.close();
  }
  static int solve(String[] s){
    int count0=0 ;
    int count1=0 ;
    for(char ch : String.join("",s).toCharArray()){
      if(ch=='0'){
        count0++;
      }
      else {
        count1++;
      }
    }
    if(count0 % 2!=0 && count1 % 2!=0 && Arrays.stream(s).allMatch(si->si.length()% 2==0)){
      return s.length-1 ;
    }
    else {
      return s.length ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Binary_Palindromes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var Q : int ; Q := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < Q do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < s->size() do ( (     s[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(solve(s)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( s : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var count0 : int ; count0 := 0 ;
     var count1 : int ; count1 := 0 ;
     for (ch : join("", s)->characters()) do ( (     if (ch = '0') then (     count0 := count0 + 1 ) else (     count1 := count1 + 1 ) )  ) ; 
     if (count0 mod 2 /= 0 & count1 mod 2 /= 0 & stream(s)->forAll( _x2 | (lambda si : OclAny in si->size() mod 2 = 0)->apply(_x2) )) then (     return s->size() - 1 ) else (     return s->size() ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayDeque ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int x=Integer.parseInt(br.readLine());
    ArrayDeque<Integer>list=new ArrayDeque<Integer>();
    for(int i=0 ; i<x ; i++){
      String s=br.readLine();
      if(s.charAt(0)=='i'){
        list.addFirst(Integer.parseInt(s.substring(7)));
      }
      else if(s.charAt(6)==' '){
        list.remove(Integer.parseInt(s.substring(7)));
      }
      else if(s.charAt(6)=='F'){
        list.removeFirst();
      }
      else {
        list.removeLast();
      }
    }
    StringBuffer sb=new StringBuffer();
    sb.append(list.poll());
    for(Integer integer : list){
      sb.append(" "+integer);
    }
    pw.println(sb);
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var x : int ; x := (br.readLine())->toInteger() ;
    var list : Sequence(int) ; list := ArrayDeque<int>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < x do ( (     var s : String ; s := br.readLine() ;
     if (s->at(0+1) = 'i') then (     list := list->prepend((s.subrange(7+1,7))->toInteger()) ) else     if (s->at(6+1) = ' ') then (     list := list->excludingFirst((s.subrange(7+1,7))->toInteger()) ) else     if (s->at(6+1) = 'F') then (     list := list->tail() ) else (     list := list->front() ) ;  ;  )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString(list->min()) ; 
    for (integer : list) do ( (     sb := sb + StringLib.newString(" " + integer) )  ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      int i ;
      int n=Integer.parseInt(br.readLine());
      ArrayDeque<String>list=new ArrayDeque<String>();
      String[] num=new String[2];
      String command ;
      char c ;
      for(i=0 ; i<n ; i++){
        command=br.readLine();
        c=command.charAt(0);
        if(c=='d'){
          c=command.charAt(6);
          if(c=='F'){
            list.pollFirst();
          }
          else if(c=='L'){
            list.pollLast();
          }
          else {
            num=command.split(" ",0);
            list.remove(num[1]);
          }
        }
        else {
          num=command.split(" ",0);
          list.offerFirst(num[1]);
        }
      }
      StringBuilder s=new StringBuilder();
      s.append(list.poll());
      while(list.size()>0){
        s.append(" ").append(list.poll());
      }
      System.out.println(s);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var i : int ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var list : Sequence(String) ; list := ArrayDeque<String>.newArrayDeque() ;
    var num : Sequence(String) ; num := Integer.subrange(1,2)->collect(null) ;
    var command : String ;
    var c : String ;
        i := 0 ; while i < n do ( (     command := br.readLine() ; 
     c := command->at(0+1) ; 
     if (c = 'd') then (     c := command->at(6+1) ; 
     if (c = 'F') then (     list := list->tail() ) else     if (c = 'L') then (     list := list->front() ) else (     num := command->split(" ") ; 
     list := list->excludingFirst(num[1+1]) ) ;  ) else (     num := command->split(" ") ; 
     list := list->prepend(num[1+1]) ) )  ;     i := i + 1 ) ; 
    var s : String ; s := StringLib.newString() ;
    s := s + StringLib.newString(list->min()) ; 
    while (list->size() > 0) do (     s := s + StringLib.newString(" ") + StringLib.newString(list->min()) ) ; 
    OclFile["System.out"].println(s) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Deque ;
import java.util.Scanner ;
public class Main {
  private static Scanner scan=new Scanner(System.in);
  private static StringBuilder stringBuilder=new StringBuilder();
  public static void main(String[] args){
    int size=Integer.parseInt(scan.next());
    Deque<String>deque=new ArrayDeque<>();
    for(int i=0 ; i<size ; i++){
      String command=scan.next();
      if(command.equals("insert")){
        deque.push(scan.next());
      }
      else if(command.equals("delete")){
        deque.remove(scan.next());
      }
      else if(command.equals("deleteFirst")){
        deque.pollFirst();
      }
      else {
        deque.pollLast();
      }
    }
    scan.close();
    scan=null ;
    for(int i=deque.size()-1 ; i>=0 ; i--){
      stringBuilder.append(deque.pollFirst());
      if(i>0){
        stringBuilder.append(" ");
      }
    }
    System.out.println(stringBuilder.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute stringBuilder : String := StringLib.newString();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var size : int ; size := (scan.getCurrent())->toInteger() ;
     var deque : Sequence(String) ; deque := ArrayDeque<OclAny>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < size do ( (     var command : String ; command := scan.getCurrent() ;
     if (command = "insert") then (     deque := deque->append(scan.getCurrent()) ) else     if (command = "delete") then (     deque := deque->excludingFirst(scan.getCurrent()) ) else     if (command = "deleteFirst") then (     deque := deque->tail() ) else (     deque := deque->front() ) ;  ;  )  ;     i := i + 1 ) ; 
    skip ; 
    scan := null ; 
        var i : int ; i := deque->size() - 1 ; while i >= 0 do ( (     stringBuilder := stringBuilder + StringLib.newString(deque->first()) ; 
     if (i > 0) then (     stringBuilder := stringBuilder + StringLib.newString(" ") ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(stringBuilder+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.LinkedList ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] commands ;
    int num ;
    LinkedList<Integer>list=new LinkedList<Integer>();
    for(int i=0 ; i<n ; i++){
      commands=br.readLine().split(" ");
      if(commands[0] .endsWith("First")){
        list.removeFirst();
        continue ;
      }
      else if(commands[0] .endsWith("Last")){
        list.removeLast();
        continue ;
      }
      num=Integer.parseInt(commands[1]);
      if(commands[0] .startsWith("i")){
        list.addFirst(num);
      }
      else {
        list.remove(new Integer(num));
      }
    }
    Object[] output=list.toArray();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<output.length ; i++){
      if(i>0){
        sb.append(" ");
      }
      sb.append(output[i]);
    }
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var commands : Sequence(String) ;
    var num : int ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     commands := br.readLine()->split(" ") ; 
     if (commands[0+1]->hasSuffix("First")) then (     list := list->tail() ; 
     continue ) else     if (commands[0+1]->hasSuffix("Last")) then (     list := list->front() ; 
     continue ) else skip ; ;  
     num := (commands[1+1])->toInteger() ; 
     if (commands[0+1]->hasPrefix("i")) then (     list := list->prepend(num) ) else (     list := list->excludingFirst(("" + (num))->toInteger()) ) )  ;     i := i + 1 ) ; 
    var output : Sequence(OclAny) ; output := list->asSequence() ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < output->size() do ( (     if (i > 0) then (     sb := sb + StringLib.newString(" ") ) else skip ; 
     sb := sb + StringLib.newString(output[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
import java.util.LinkedList ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int n=Integer.parseInt(sc.readLine());
    LinkedList<Integer>ll=new LinkedList<Integer>();
    for(int i=0 ; i<n ; i++){
      String[] str=sc.readLine().split(" ");
      if(str[0] .equals("insert")){
        ll.addFirst(Integer.parseInt(str[1]));
      }
      if(str[0] .equals("delete")){
        int index=ll.indexOf(Integer.parseInt(str[1]));
        if(index!=-1)ll.remove(index);
      }
      if(str[0] .equals("deleteFirst")){
        ll.pollFirst();
      }
      if(str[0] .equals("deleteLast")){
        ll.pollLast();
      }
    }
    StringBuilder sb=new StringBuilder();
    sb.append(ll.poll());
    for(Integer s : ll){
      sb.append(" ");
      sb.append(s);
    }
    out.write(sb.toString());
    out.println();
    sc.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := (sc.readLine())->toInteger() ;
    var ll : Sequence(int) ; ll := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var str : Sequence(String) ; str := sc.readLine()->split(" ") ;
     if (str[0+1] = "insert") then (     ll := ll->prepend((str[1+1])->toInteger()) ) else skip ; 
    if (str[0+1] = "delete") then (     var index : int ; index := ll->indexOf((str[1+1])->toInteger())-1 ;
     if (index /= -1) then     ll := ll->excludingAt(index+1) ; else skip ) else skip ; 
    if (str[0+1] = "deleteFirst") then (     ll := ll->tail() ) else skip ; 
    if (str[0+1] = "deleteLast") then (     ll := ll->front() ) else skip ; 
 )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString(ll->min()) ; 
    for (s : ll) do ( (     sb := sb + StringLib.newString(" ") ; 
     sb := sb + StringLib.newString(s) )  ) ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++)a[i]=sc.nextInt();
    if(firstWin(N,a))System.out.println("First");
    else System.out.println("Second");
    sc.close();
  }
  static boolean firstWin(int N,int[] a){
    Arrays.sort(a);
    for(int i=0 ; i<N ; i++){
      if(N-i<=a[i]){
        boolean win=(a[i]-(N-i))% 2==1 ;
        int sameSize=0 ;
        for(int j=i-1 ; j>=0 && a[j]==N-i ; j--)sameSize++;
        win |=sameSize % 2==1 ;
        return win ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    if (firstWin(N, a)) then     OclFile["System.out"].println("First") else     OclFile["System.out"].println("Second") ; ;  
    skip ; 
 );
  static   operation firstWin( N : int, a : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     a := a->sort() ; 
         var i : int ; i := 0 ; while i < N do ( (     if (N - i <= a[i+1]) then (     var win : boolean ; win := (a[i+1] - (N - i)) mod 2 = 1 ;
     var sameSize : int ; sameSize := 0 ;
        var j : int ; j := i - 1 ; while j >= 0 & a[j+1] = N - i do (     sameSize := sameSize + 1 ;  ;     j := j - 1 ) ; 
    win := MathLib.bitwiseOr(win, sameSize mod 2 = 1) ; 
    return win 
 ) else skip )  ;     i := i + 1 ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Geeks {
  static int distribution(int arr[],int n){
    Arrays.sort(arr);
    int count=1 ;
    for(int i=1 ; i<n ; i++)if(arr[i]>arr[i-1])count++;
    return Math.min(count,n/2);
  }
  public static void main(String args[]){
    int arr[]={
      1,1,2,1,3,4 };
      int n=arr.length ;
      System.out.println(distribution(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Geeks {
  static   operation distribution( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var count : int ; count := 1 ;
         var i : int ; i := 1 ; while i < n do (     if (arr[i+1] > arr[i - 1+1]) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return Set{count, n / 2}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,2,1,3,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(distribution(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findNthTerm(int N){
    int ans ;
    if(N % 2==0){
      ans=(N/2)*6+(N/2)*2 ;
    }
    else {
      ans=(N/2+1)*6+(N/2)*2 ;
    }
    System.out.print(ans+"\n");
  }
  public static void main(String[] args){
    int N=3 ;
    findNthTerm(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNthTerm( N : int) : void
  pre: true
  post: true
  activity: (     var ans : int ;
     if (N mod 2 = 0) then (     ans := (N / 2) * 6 + (N / 2) * 2 ) else (     ans := (N / 2 + 1) * 6 + (N / 2) * 2 ) ;  
     OclFile["System.out"].print(ans + "\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
     execute findNthTerm(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JeffDigits {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int count5=0 ;
    for(int i=0 ; i<n ; i++){
      int k=sc.nextInt();
      if(k==5)count5++;
    }
    String s="" ;
    if(count5!=n){
      if(count5>=9){
        for(int i=0 ; i<9*(count5/9); i++){
          s+="5" ;
        }
        for(int i=0 ; i<n-count5 ; i++){
          s+="0" ;
        }
        System.out.println(s);
      }
      else System.out.println(0);
    }
    else System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JeffDigits {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var count5 : int ; count5 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var k : int ; k := sc.getCurrent()->toInteger() ;
     if (k = 5) then     count5 := count5 + 1 ; else skip )  ;     i := i + 1 ) ; 
    var s : String ; s := "" ;
    if (count5 /= n) then (     if (count5 >= 9) then (         var i : int ; i := 0 ; while i < 9 * (count5 / 9) do ( (     s := s+("5") )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n - count5 do ( (     s := s+("0") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(s) ) else     OclFile["System.out"].println(0) ; ) else     OclFile["System.out"].println(-1) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      int[] arr=new int[t];
      Set<Integer>set=new HashSet<>();
      for(int i=0 ; i<t ; i++){
        arr[i]=sc.nextInt();
        set.add(arr[i]);
      }
      if(set.size()!=2)System.out.println("NO");
      else {
        int chk=arr[0],ans=0,c0=1,c1=0 ;
        for(int i=1 ; i<t ; i++){
          if(arr[i]==chk)c0++;
          else {
            ans=arr[i];
            c1++;
          }
        }
        if(c0==c1){
          System.out.println("YES");
          System.out.println(chk+" "+ans);
        }
        else System.out.println("NO");
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,t)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < t do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     set := set->including(arr[i+1]) )  ;     i := i + 1 ) ; 
    if (set->size() /= 2) then     OclFile["System.out"].println("NO") else (     var chk : int ; chk := arr[0+1] ;
    var ans : int ; ans := 0 ;
    var c0 : int ; c0 := 1 ;
    var c1 : int ; c1 := 0 ;
         var i : int ; i := 1 ; while i < t do ( (     if (arr[i+1] = chk) then     c0 := c0 + 1 ; else (     ans := arr[i+1] ; 
     c1 := c1 + 1 ) )  ;     i := i + 1 ) ; 
     if (c0 = c1) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(chk + " " + ans) ) else     OclFile["System.out"].println("NO") ; ) ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.time.chrono.MinguoChronology ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Hashtable ;
import java.util.Stack ;
import java.util.StringTokenizer ;
import java.util.TreeMap ;
public class A {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    int t=sc.nextInt();
    HashMap<Integer,Integer>nums=new HashMap<Integer,Integer>();
    for(int i=0 ; i<t ; i++){
      int temp=sc.nextInt();
      nums.put(temp,nums.getOrDefault(temp,0)+1);
    }
    ArrayList<Integer>list=new ArrayList<Integer>(nums.values());
    ArrayList<Integer>list2=new ArrayList<Integer>(nums.keySet());
    if(nums.size()==2 && list.get(0)==list.get(1)){
      System.out.println("YES");
      System.out.println(list2.get(0)+" "+list2.get(1));
    }
    else {
      System.out.println("NO");
    }
  }
}
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 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var t : int ; t := sc.nextInt() ;
    var nums : Map(int,int) ; nums := Map{} ;
        var i : int ; i := 0 ; while i < t do ( (     var temp : int ; temp := sc.nextInt() ;
     nums := nums->union(Map{temp |-> (if nums->keys()->contains(temp) then nums->at(temp) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var list : Sequence(int) ; list := Sequence{}->union(nums->values()) ;
    var list2 : Sequence(int) ; list2 := Sequence{}->union(nums->keys()) ;
    if (nums.size() = 2 & list->at(0+1) = list->at(1+1)) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(list2->at(0+1) + " " + list2->at(1+1)) ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}
class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class FairGame {
  public static void main(String[] args)throws Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int[] freq=new int[101];
    int max1=0,max2=0,index1=-1,index2=-1 ;
    int cards=Integer.parseInt(reader.readLine());
    for(int i=0 ; i<cards ; i++){
      int num=Integer.parseInt(reader.readLine());
      freq[num]++;
      if(freq[num]>=max1){
        max2=max1 ;
        index2=index1 ;
        max1=freq[num];
        index1=num ;
      }
      else if(freq[num]>=max2){
        max2=freq[num];
        index2=num ;
      }
    }
    if(max1+max2==cards){
      System.out.printf("YES\n%d %d",index1,index2);
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class FairGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var freq : Sequence(int) ; freq := Integer.subrange(1,101)->collect(0) ;
    var max1 : int ; max1 := 0 ;
    var max2 : int ; max2 := 0 ;
    var index1 : int ; index1 := -1 ;
    var index2 : int ; index2 := -1 ;
    var cards : int ; cards := (reader.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < cards do ( (     var num : int ; num := (reader.readLine())->toInteger() ;
     freq[num+1] := freq[num+1] + 1 ; 
     if (freq[num+1] >= max1) then (     max2 := max1 ; 
     index2 := index1 ; 
     max1 := freq[num+1] ; 
     index1 := num ) else     if (freq[num+1] >= max2) then (     max2 := freq[num+1] ; 
     index2 := num ) else skip ; )  ;     i := i + 1 ) ; 
    if (max1 + max2 = cards) then (     OclFile["System.out"].printf("YES\n%d %d", index1, index2) ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      int[] arr=new int[t];
      Set<Integer>set=new HashSet<>();
      for(int i=0 ; i<t ; i++){
        arr[i]=sc.nextInt();
        set.add(arr[i]);
      }
      if(set.size()!=2)System.out.println("NO");
      else {
        int chk=arr[0],ans=0,c0=1,c1=0 ;
        for(int i=1 ; i<t ; i++){
          if(arr[i]==chk)c0++;
          else c1++;
        }
        Arrays.sort(arr);
        if(c0==c1){
          System.out.println("YES");
          if(chk!=arr[t-1])System.out.println(chk+" "+arr[t-1]);
          else System.out.println(chk+" "+arr[0]);
        }
        else System.out.println("NO");
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,t)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < t do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     set := set->including(arr[i+1]) )  ;     i := i + 1 ) ; 
    if (set->size() /= 2) then     OclFile["System.out"].println("NO") else (     var chk : int ; chk := arr[0+1] ;
    var ans : int ; ans := 0 ;
    var c0 : int ; c0 := 1 ;
    var c1 : int ; c1 := 0 ;
         var i : int ; i := 1 ; while i < t do ( (     if (arr[i+1] = chk) then     c0 := c0 + 1 ; else     c1 := c1 + 1 ; )  ;     i := i + 1 ) ; 
     arr := arr->sort() ; 
     if (c0 = c1) then (     OclFile["System.out"].println("YES") ; 
     if (chk /= arr[t - 1+1]) then     OclFile["System.out"].println(chk + " " + arr[t - 1+1]) ; else     OclFile["System.out"].println(chk + " " + arr[0+1]) ; ) else     OclFile["System.out"].println("NO") ; ) ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void findSurpasser(int arr[],int n){
    for(int i=0 ; i<n ; i++){
      int count=0 ;
      for(int j=i+1 ; j<n ; j++)if(arr[j]>arr[i])count++;
      System.out.print(count+" ");
    }
  }
  static void printArray(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    System.out.println();
  }
  public static void main(String[] args){
    int arr[]={
      2,7,5,3,0,8,1 };
      int n=arr.length ;
      System.out.println("Given array is ");
      printArray(arr,n);
      System.out.println("Surpasser Count of"+" array is ");
      findSurpasser(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSurpasser( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var count : int ; count := 0 ;
         var j : int ; j := i + 1 ; while j < n do (     if (arr[j+1] > arr[i+1]) then     count := count + 1 ; else skip ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].print(count + " ") )  ;     i := i + 1 ) );
  static   operation printArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,7,5,3,0,8,1} ;
     var n : int ; n := arr->size() ;
    OclFile["System.out"].println("Given array is ") ; 
    execute printArray(arr, n) ; 
    OclFile["System.out"].println("Surpasser Count of" + " array is ") ; 
    execute findSurpasser(arr, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void firstNonRepeating(int arr[],int n){
    Map<Integer,Integer>m=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(m.containsKey(arr[i])){
        m.put(arr[i],m.get(arr[i])+1);
      }
      else {
        m.put(arr[i],1);
      }
    }
    for(Map.Entry<Integer,Integer>x : m.entrySet())if(x.getValue()==1)System.out.print(x.getKey()+" ");
  }
  public static void main(String[] args){
    int arr[]={
      9,4,9,6,7,4 };
      int n=arr.length ;
      firstNonRepeating(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation firstNonRepeating( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var m : Map(int,int) ; m := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (m->keys()->includes(arr[i+1])) then (     m := m->union(Map{arr[i+1] |-> m->at(arr[i+1]) + 1}) ) else (     m := m->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
     for (x : m->asSet()) do (     if (x.getValue() = 1) then     OclFile["System.out"].print(x.getKey() + " ") ; else skip ;  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{9,4,9,6,7,4} ;
     var n : int ; n := arr->size() ;
     execute firstNonRepeating(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int[] computeLPSArray(String str){
    int n=str.length();
    int lps[]=new int[n];
    int i=1,len=0 ;
    lps[0]=0 ;
    while(i<n){
      if(str.charAt(i)==str.charAt(len)){
        len++;
        lps[i]=len ;
        i++;
      }
      else {
        if(len!=0){
          len=lps[len-1];
        }
        else {
          lps[i]=0 ;
          i++;
        }
      }
    }
    return lps ;
  }
  static int getMinCharToAddedToMakeStringPalin(String str){
    StringBuilder s=new StringBuilder();
    s.append(str);
    String rev=s.reverse().toString();
    s.reverse().append("$").append(rev);
    int lps[]=computeLPSArray(s.toString());
    return str.length()-lps[s.length()-1];
  }
  public static void main(String args[]){
    String str="AACECAAAA" ;
    System.out.println(getMinCharToAddedToMakeStringPalin(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation computeLPSArray( str : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var lps : Sequence(int) ; lps := Integer.subrange(1,n)->collect(0) ;
    var i : int ; i := 1 ;
    var len : int ; len := 0 ;
    lps[0+1] := 0 ; 
    while (i < n) do (     if (str->at(i+1) = str->at(len+1)) then (     len := len + 1 ; 
     lps[i+1] := len ; 
     i := i + 1 ) else (     if (len /= 0) then (     len := lps[len - 1+1] ) else (     lps[i+1] := 0 ; 
     i := i + 1 ) ) ) ; 
    return lps 
 );
  static   operation getMinCharToAddedToMakeStringPalin( str : String) : int
  pre: true
  post: true
  activity: (     var s : String ; s := StringLib.newString() ;
     s := s + StringLib.newString(str) ; 
    var rev : String ; rev := s->reverse()+"" ;
    s := s->reverse() + StringLib.newString("$") + StringLib.newString(rev) ; 
    var lps : Sequence(int) ; lps := computeLPSArray(s+"") ;
    return str->size() - lps[s->size() - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "AACECAAAA" ;
     OclFile["System.out"].println(getMinCharToAddedToMakeStringPalin(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    TreeSet<Integer>set=new TreeSet<>();
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      set.add(in.nextInt());
    }
    int m=in.nextInt();
    PrintWriter out=new PrintWriter(System.out);
    for(int i=0 ; i<m ; i++){
      int obj=in.nextInt();
      if(set.contains(obj))out.println(obj);
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var set : Set(int) ; set := Set{} ;
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     set := set->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var m : int ; m := in.getCurrent()->toInteger() ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
        var i : int ; i := 0 ; while i < m do ( (     var obj : int ; obj := in.getCurrent()->toInteger() ;
     if (set->includes(obj)) then     skip ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeSet ;
class Main {
  public static void main(String[] args){
    Set<Long>set=new TreeSet<Long>();
    Set<Long>ans=new TreeSet<Long>();
    try(Scanner sc=new Scanner(System.in)){
      int times=sc.nextInt();
      for(int i=0 ; i<times ; i++){
        Long l=sc.nextLong();
        boolean check=set.add(l);
        if(! check)ans.add(l);
      }
      times=sc.nextInt();
      for(int i=0 ; i<times ; i++){
        Long l=sc.nextLong();
        boolean check=set.add(l);
        if(! check)ans.add(l);
      }
      ArrayList<Long>a=new ArrayList<Long>(ans);
      for(int i=0 ; i<a.size(); i++)System.out.println(a.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var set : Set(long) ; set := Set{} ;
     var ans : Set(long) ; ans := Set{} ;
     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var times : int ; times := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < times do ( (     var l : long ; l := sc.getCurrent()->toLong() ;
     var check : boolean ; check := set->excludes(l) ;
     if (not(check)) then     ans := ans->including(l) ; else skip )  ;     i := i + 1 ) ; 
    times := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < times do ( (     var l : long ; l := sc.getCurrent()->toLong() ;
     var check : boolean ; check := set->excludes(l) ;
     if (not(check)) then     ans := ans->including(l) ; else skip )  ;     i := i + 1 ) ; 
    var a : Sequence(long) ; a := Sequence{}->union(ans) ;
        var i : int ; i := 0 ; while i < a->size() do (     OclFile["System.out"].println(a->at(i+1)) ;  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isRectangle(int a,int b,int c,int d){
    if(a==b && a==c && a==d && c==d && b==c && b==d)return true ;
    else if(a==b && c==d)return true ;
    else if(a==d && c==b)return true ;
    else if(a==c && d==b)return true ;
    else return false ;
  }
  public static void main(String[] args){
    int a=1,b=2,c=3,d=4 ;
    if(isRectangle(a,b,c,d))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isRectangle( a : int, b : int, c : int, d : int) : boolean
  pre: true
  post: true
  activity: (     if (a = b & a = c & a = d & c = d & b = c & b = d) then     return true else     if (a = b & c = d) then     return true else     if (a = d & c = b) then     return true else     if (a = c & d = b) then     return true else     return false ;  ;  ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 1 ;
    var b : int ; b := 2 ;
    var c : int ; c := 3 ;
    var d : int ; d := 4 ;
     if (isRectangle(a, b, c, d)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] str=br.readLine().split(" ");
    Set<Integer>S=new TreeSet<Integer>();
    for(int i=0 ; i<n ; i++){
      S.add(Integer.parseInt(str[i]));
    }
    int m=Integer.parseInt(br.readLine());
    str=br.readLine().split(" ");
    Set<Integer>S2=new TreeSet<Integer>();
    for(int i=0 ; i<m ; i++){
      if(S.contains(Integer.parseInt(str[i])))S2.add(Integer.parseInt(str[i]));
    }
    for(Integer num : S2)System.out.println(num);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var S : Set(int) ; S := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     S := S->including((str[i+1])->toInteger()) )  ;     i := i + 1 ) ; 
    var m : int ; m := (br.readLine())->toInteger() ;
    str := br.readLine()->split(" ") ; 
    var S2 : Set(int) ; S2 := Set{} ;
        var i : int ; i := 0 ; while i < m do ( (     if (S->includes((str[i+1])->toInteger())) then     S2 := S2->including((str[i+1])->toInteger()) ; else skip )  ;     i := i + 1 ) ; 
    for (num : S2) do (     OclFile["System.out"].println(num) ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JeffAndNum {
  public static void main(String[] args){
    Scanner ac=new Scanner(System.in);
    int n=ac.nextInt();
    int count=0 ;
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=ac.nextInt();
      if(arr[i]==5)count++;
    }
    if(count==0)System.out.println(0);
    else if(count==n)System.out.println(-1);
    else if(count<9)System.out.println(0);
    else {
      int c=count-(count % 9);
      for(int i=0 ; i<c ; i++)System.out.print(5);
      for(int i=0 ; i<n-count ; i++)System.out.print(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JeffAndNum {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ac : OclFile ; ac := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := ac.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := ac.getCurrent()->toInteger() ; 
     if (arr[i+1] = 5) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (count = 0) then     OclFile["System.out"].println(0) else     if (count = n) then     OclFile["System.out"].println(-1) else     if (count < 9) then     OclFile["System.out"].println(0) else (     var c : int ; c := count - (count mod 9) ;
         var i : int ; i := 0 ; while i < c do (     OclFile["System.out"].print(5) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n - count do (     OclFile["System.out"].print(0) ;  ;     i := i + 1 ) ) ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static StringBuilder sb ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sb=new StringBuilder();
    int n=sc.nextInt();
    List<Integer>a=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      a.add(Integer.parseInt(sc.next()));
    }
    int m=sc.nextInt();
    List<Integer>ans=new ArrayList<>();
    int index=0 ;
    for(int i=0 ; i<m ; i++){
      int tmp=Integer.parseInt(sc.next());
      while(index<a.size()&& a.get(index)<tmp){
        index++;
      }
      if(index==a.size())break ;
      if(a.get(index)==tmp)ans.add(tmp);
    }
    for(int i=0 ; i<ans.size(); i++){
      sb.append(ans.get(i)).append("\n");
    }
    PrintWriter out=new PrintWriter(System.out);
    out.print(sb);
    out.flush();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sb : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     sb := StringLib.newString() ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     a := a->including((sc.getCurrent())->toInteger()) )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var ans : Sequence(int) ; ans := Sequence{} ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var tmp : int ; tmp := (sc.getCurrent())->toInteger() ;
     while (index < a->size() & a->at(index+1) < tmp) do (     index := index + 1 ) ; 
     if (index = a->size()) then     break else skip ; 
     if (a->at(index+1) = tmp) then     ans := ans->including(tmp) ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < ans->size() do ( (     sb := sb + StringLib.newString(ans->at(i+1)) + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float calcAngle(int hh,int mm){
    float hour_angle=0.5f*(hh*60+mm);
    float minute_angle=6*mm ;
    float angle=Math.abs(hour_angle-minute_angle);
    angle=Math.min(360-angle,angle);
    return angle ;
  }
  static void printTime(float theta){
    for(int hh=0 ; hh<12 ; hh++){
      for(int mm=0 ; mm<60 ; mm++){
        if(calcAngle(hh,mm)==theta){
          System.out.println(hh+":"+mm);
          return ;
        }
      }
    }
    System.out.println("Input angle not valid.");
    return ;
  }
  public static void main(String[] args){
    float theta=90.0f ;
    printTime(theta);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation calcAngle( hh : int, mm : int) : double
  pre: true
  post: true
  activity: (     var hour_angle : double ; hour_angle := 0.5f * (hh * 60 + mm) ;
     var minute_angle : double ; minute_angle := 6 * mm ;
    var angle : double ; angle := if hour_angle - minute_angle < 0 then -(hour_angle - minute_angle) else hour_angle - minute_angle endif ;
    angle := Set{360 - angle, angle}->min() ; 
    return angle 
 );
  static   operation printTime( theta : double) : void
  pre: true
  post: true
  activity: (         var hh : int ; hh := 0 ; while hh < 12 do ( (         var mm : int ; mm := 0 ; while mm < 60 do ( (     if (calcAngle(hh, mm) = theta) then (     OclFile["System.out"].println(hh + ":" + mm) ; 
     return ) else skip )  ;     mm := mm + 1 ) )  ;     hh := hh + 1 ) ; 
     OclFile["System.out"].println("Input angle not valid.") ; 
     return );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var theta : double ; theta := 90.0f ;
     execute printTime(theta) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    int[][] kui=new int[2][n];
    Group[] groups=new Group[n];
    for(int i=0 ; i<n ; i++){
      kui[0][i]=scan.nextInt();
      kui[1][i]=scan.nextInt();
      groups[i]=new Group();
    }
    double allLen=0.0 ;
    Queue<Branch>q=new PriorityQueue<>();
    for(int i=0 ; i<m ; i++){
      int e1=scan.nextInt()-1 ;
      int e2=scan.nextInt()-1 ;
      int _w=kui[0][e1]-kui[0][e2];
      int _h=kui[1][e1]-kui[1][e2];
      double len=Math.sqrt(_w*_w+_h*_h);
      q.add(new Branch(e1,e2,len));
      allLen+=len ;
    }
    double resultLen=0.0 ;
    while(! q.isEmpty()){
      Branch _b=q.poll();
      Group g1=groups[_b.e1] .getGroup();
      Group g2=groups[_b.e2] .getGroup();
      if(g1==g2)continue ;
      Group ng=new Group();
      g1.parent=ng ;
      g2.parent=ng ;
      resultLen+=_b.len ;
    }
    System.out.println(allLen-resultLen);
  }
}
class Group {
  Group parent ;
  Group(){
  }
  Group getGroup(){
    return(parent==null)? this : parent.getGroup();
  }
}
class Branch implements Comparable<Branch>{
  int e1,e2 ;
  double len ;
  Branch(int _e1,int _e2,double _len){
    e1=_e1 ;
    e2=_e2 ;
    len=_len ;
  }
  @ Override public int compareTo(Branch _b){
    return(_b.len-this.len>0.0)? 1 :-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var kui : Sequence(Sequence(int)) ; kui := Integer.subrange(1,2)->collect(Integer.subrange(1,n)->collect(0)) ;
    var groups : Sequence(Group) ; groups := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     kui[0+1][i+1] := scan.getCurrent()->toInteger() ; 
     kui[1+1][i+1] := scan.getCurrent()->toInteger() ; 
     groups[i+1] := Group.newGroup() )  ;     i := i + 1 ) ; 
    var allLen : double ; allLen := 0.0 ;
    var q : Sequence(Branch) ; q := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     var e1 : int ; e1 := scan.getCurrent()->toInteger() - 1 ;
     var e2 : int ; e2 := scan.getCurrent()->toInteger() - 1 ;
    var _w : int ; _w := kui[0+1][e1+1] - kui[0+1][e2+1] ;
    var _h : int ; _h := kui[1+1][e1+1] - kui[1+1][e2+1] ;
    var len : double ; len := (_w * _w + _h * _h)->sqrt() ;
    q := q->including(Branch.newBranch(e1, e2, len)) ; 
    allLen := allLen+(len) ; 
 )  ;     i := i + 1 ) ; 
    var resultLen : double ; resultLen := 0.0 ;
    while (not(q->isEmpty())) do (     var _b : Branch ; _b := q->min() ;
     var g1 : Group ; g1 := groups[_b.e1+1].getGroup() ;
    var g2 : Group ; g2 := groups[_b.e2+1].getGroup() ;
    if (g1 = g2) then     continue else skip ; 
    var ng : Group ; ng := Group.newGroup() ;
    g1.parent := ng ; 
    g2.parent := ng ; 
    resultLen := resultLen+(_b.len) ; 
 ) ; 
    OclFile["System.out"].println(allLen - resultLen) ; 
 );
}
class Group {
   attribute parent : Group;
   static operation newGroup() : Group
  pre: true
  post: true
  activity:
  ( var self : Group ;
    self := createGroup();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   operation getGroup() : Group
  pre: true
  post: true
  activity: (     return if (parent = null) then self else parent.getGroup() endif );
}
class Branch implements Comparable<Branch> {
   attribute e1 : int;
   attribute len : double;
   static operation newBranch( _e1 : int, _e2 : int, _len : double) : Branch
  pre: true
  post: true
  activity:
  ( var self : Branch ;
    self := createBranch();
    self.initialise(_e1, _e2,_len);
    return self );
  operation initialise( _e1 : int, _e2 : int, _len : double) : void
  pre: true  post: true
  activity: (     e1 := _e1 ; 
     e2 := _e2 ; 
     len := _len );
      operation compareTo( _b : Branch) : int
  pre: true
  post: true
  activity: (     return if (_b.len - self.len > 0.0) then 1 else -1 endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int swapBits(int x){
    int even_bits=x & 0xAAAAAAAA ;
    int odd_bits=x & 0x55555555 ;
    even_bits>>=1 ;
    odd_bits<<=1 ;
    return(even_bits | odd_bits);
  }
  public static void main(String[] args){
    int x=23 ;
    System.out.println(swapBits(x));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation swapBits( x : int) : int
  pre: true
  post: true
  activity: (     var even_bits : int ; even_bits := MathLib.bitwiseAnd(x,0xAAAAAAAA) ;
     var odd_bits : int ; odd_bits := MathLib.bitwiseAnd(x,0x55555555) ;
    even_bits := even_bits/(2->pow(1)) ; 
    odd_bits := odd_bits*(2->pow(1)) ; 
    return (MathLib.bitwiseOr(even_bits,odd_bits)) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 23 ;
     OclFile["System.out"].println(swapBits(x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int N=3 ;
  static boolean checkCentrosymmetricted(int n,int m[][]){
    int mid_row ;
    if((n & 1)>0)mid_row=n/2+1 ;
    else mid_row=n/2 ;
    for(int i=0 ; i<mid_row ; i++){
      for(int j=0 ; j<n ; j++){
        if(m[i][j]!=m[n-i-1][n-j-1])return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    int n=3 ;
    int m[][]={
      {
        1,3,5 },{
          6,8,6 },{
            5,3,1 }
          };
          if(checkCentrosymmetricted(n,m))System.out.println("Yes");
          else System.out.println("No");
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 3;
  static   operation checkCentrosymmetricted( n : int, m : Sequence(Sequence(int))) : boolean
  pre: true
  post: true
  activity: (     var mid_row : int ;
     if ((n & 1) > 0) then     mid_row := n / 2 + 1 else     mid_row := n / 2 ; ;  
         var i : int ; i := 0 ; while i < mid_row do ( (         var j : int ; j := 0 ; while j < n do ( (     if (m[i+1][j+1] /= m[n - i - 1+1][n - j - 1+1]) then     return false else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var m : Sequence(Sequence(int)) ; m := Sequence{Sequence{1,3,5},Sequence{6,8,6},Sequence{5,3,1}} ;
     if (checkCentrosymmetricted(n, m)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void replaceOriginal(String s,int n){
    char r[]=new char[n];
    for(int i=0 ; i<n ; i++){
      r[i]=s.charAt(n-1-i);
      if(s.charAt(i)!='a' && s.charAt(i)!='e' && s.charAt(i)!='i' && s.charAt(i)!='o' && s.charAt(i)!='u'){
        System.out.print(r[i]);
      }
    }
    System.out.println("");
  }
  public static void main(String[] args){
    String s="geeksforgeeks" ;
    int n=s.length();
    replaceOriginal(s,n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation replaceOriginal( s : String, n : int) : void
  pre: true
  post: true
  activity: (     var r : Sequence(String) ; r := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     r[i+1] := s->at(n - 1 - (i)->char2byte()+1) ; 
     if (s->at(i+1) /= 'a' & s->at(i+1) /= 'e' & s->at(i+1) /= 'i' & s->at(i+1) /= 'o' & s->at(i+1) /= 'u') then (     OclFile["System.out"].print(r[i+1]) ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     var n : int ; n := s->size() ;
     execute replaceOriginal(s, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int factorial(int a,int b){
    int res=1 ;
    for(int i=1 ; i<=(a+b); i++)res=res*i ;
    for(int i=1 ; i<=a ; i++)res=res/i ;
    for(int i=1 ; i<=b ; i++)res=res/i ;
    return res ;
  }
  static void Ksmallest(int x,int y,int k){
    if(x==0 && y==0)return ;
    else if(x==0){
      y--;
      System.out.print("V");
      Ksmallest(x,y,k);
    }
    else if(y==0){
      x--;
      System.out.print("H");
      Ksmallest(x,y,k);
    }
    else {
      if(factorial(x-1,y)>k){
        System.out.print("H");
        Ksmallest(x-1,y,k);
      }
      else {
        System.out.print("V");
        Ksmallest(x,y-1,k-factorial(x-1,y));
      }
    }
  }
  public static void main(String[] args){
    int x=2,y=2,k=2 ;
    Ksmallest(x,y,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation factorial( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
         var i : int ; i := 1 ; while i <= (a + b) do (     res := res * i ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= a do (     res := res / i ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= b do (     res := res / i ;  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation Ksmallest( x : int, y : int, k : int) : void
  pre: true
  post: true
  activity: (     if (x = 0 & y = 0) then     return else     if (x = 0) then (     y := y - 1 ; 
     OclFile["System.out"].print("V") ; 
     execute Ksmallest(x, y, k) ) else     if (y = 0) then (     x := x - 1 ; 
     OclFile["System.out"].print("H") ; 
     execute Ksmallest(x, y, k) ) else (     if (factorial(x - 1, y) > k) then (     OclFile["System.out"].print("H") ; 
     execute Ksmallest(x - 1, y, k) ) else (     OclFile["System.out"].print("V") ; 
     execute Ksmallest(x, y - 1, k - factorial(x - 1, y)) ) ) ;  ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 2 ;
    var y : int ; y := 2 ;
    var k : int ; k := 2 ;
     execute Ksmallest(x, y, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int discreteLogarithm(int a,int b,int m){
    int n=(int)(Math.sqrt(m)+1);
    int an=1 ;
    for(int i=0 ; i<n ; ++i)an=(an*a)% m ;
    int[] value=new int[m];
    for(int i=1,cur=an ; i<=n ; ++i){
      if(value[cur]==0)value[cur]=i ;
      cur=(cur*an)% m ;
    }
    for(int i=0,cur=b ; i<=n ; ++i){
      if(value[cur]>0){
        int ans=value[cur]*n-i ;
        if(ans<m)return ans ;
      }
      cur=(cur*a)% m ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    int a=2,b=3,m=5 ;
    System.out.println(discreteLogarithm(a,b,m));
    a=3 ;
    b=7 ;
    m=11 ;
    System.out.println(discreteLogarithm(a,b,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation discreteLogarithm( a : int, b : int, m : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := ((m)->sqrt() + 1)->oclAsType(int) ;
     var an : int ; an := 1 ;
        var i : int ; i := 0 ; while i < n do (     an := (an * a) mod m ;  ;     i := i + 1 ) ; 
    var value : Sequence(int) ; value := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 1 ;
    var cur : int ; cur := an ; while i <= n do ( (     if (value[cur+1] = 0) then     value[cur+1] := i ; else skip ; 
     cur := (cur * an) mod m )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ;
    var cur : int ; cur := b ; while i <= n do ( (     if (value[cur+1] > 0) then (     var ans : int ; ans := value[cur+1] * n - i ;
     if (ans < m) then     return ans else skip ) else skip ; 
     cur := (cur * a) mod m )  ;     i := i + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2 ;
    var b : int ; b := 3 ;
    var m : int ; m := 5 ;
     OclFile["System.out"].println(discreteLogarithm(a, b, m)) ; 
    a := 3 ; 
    b := 7 ; 
    m := 11 ; 
    OclFile["System.out"].println(discreteLogarithm(a, b, m)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int numofstring(int n,int m){
    if(n==1)return m ;
    if(n==2)return m*(m-1);
    return m*(m-1)*(int)Math.pow(m-2,n-2);
  }
  public static void main(String[] args){
    int n=2,m=3 ;
    System.out.println(numofstring(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation numofstring( n : int, m : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return m else skip ; 
     if (n = 2) then     return m * (m - 1) else skip ; 
     return m * (m - 1) * m - 2->pow(n - 2)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
    var m : int ; m := 3 ;
     OclFile["System.out"].println(numofstring(n, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  static Scanner in ;
  public static void main(String[] args){
    long MOD=998244353L ;
    in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int n=in.nextInt();
    int[] dp=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      for(int j=i ; j<=n ; j+=i){
        dp[j]++;
      }
    }
    long[] arr=new long[n+1];
    arr[1]=1L ;
    long sum=1L ;
    for(int i=2 ; i<=n ; i++){
      arr[i]=(sum+(long)(dp[i]))% MOD ;
      sum=(sum+arr[i])% MOD ;
    }
    System.out.println(arr[n]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute in : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var MOD : long ; MOD := 998244353L ;
     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
    var n : int ; n := in.getCurrent()->toInteger() ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i ; while j <= n do ( (     dp[j+1] := dp[j+1] + 1 )  ;     j := j+(i) ) )  ;     i := i + 1 ) ; 
    var arr : Sequence(long) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
    arr[1+1] := 1L ; 
    var sum : long ; sum := 1L ;
        var i : int ; i := 2 ; while i <= n do ( (     arr[i+1] := (sum + (dp[i+1])->oclAsType(long)) mod MOD ; 
     sum := (sum + arr[i+1]) mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(arr[n+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class x {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    int x=0,y=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      if(a[i]==5)x++;
      else y++;
    }
    if(y==0)System.out.println(-1);
    else if(x<9)System.out.print(0);
    else {
      int b=(x/9);
      String s=new String();
      for(int i=0 ; i<(b*9); i++)s+="5" ;
      for(int i=0 ; i<y ; i++)s+="0" ;
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class x {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (a[i+1] = 5) then     x := x + 1 ; else     y := y + 1 ; )  ;     i := i + 1 ) ; 
    if (y = 0) then     OclFile["System.out"].println(-1) else     if (x < 9) then     OclFile["System.out"].print(0) else (     var b : int ; b := (x / 9) ;
     var s : String ; s := StringLib.newString() ;
        var i : int ; i := 0 ; while i < (b * 9) do (     s := s+("5") ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < y do (     s := s+("0") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPowerOfTwo(int x){
    if(x==0)return false ;
    if((x &(x-1))==0)return true ;
    else return false ;
  }
  static int countNum(int a[],int n){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(isPowerOfTwo(a[i])|| isPowerOfTwo(a[i]+1))count++;
    }
    return count ;
  }
  public static void main(String args[]){
    int arr[]={
      5,6,9,3,1 };
      int n=arr.length ;
      System.out.println(countNum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPowerOfTwo( x : int) : boolean
  pre: true
  post: true
  activity: (     if (x = 0) then     return false else skip ; 
     if ((x & (x - 1)) = 0) then     return true else     return false );
  static   operation countNum( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (isPowerOfTwo(a[i+1]) or isPowerOfTwo(a[i+1] + 1)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,6,9,3,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countNum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int firstDigit(int x){
    while(x>=10)x=x/10 ;
    return x ;
  }
  public static void main(String args[]){
    System.out.println(firstDigit(12345));
    System.out.println(firstDigit(5432));
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation firstDigit( x : int) : int
  pre: true
  post: true
  activity: (     while (x >= 10) do     x := x / 10 ; ; 
     return x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(firstDigit(12345)) ; 
     OclFile["System.out"].println(firstDigit(5432)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  static int ceilSearch(int arr[],int low,int high,int x){
    int i ;
    if(x<=arr[low])return low ;
    for(i=low ; i<high ; i++){
      if(arr[i]==x)return i ;
      if(arr[i]<x && arr[i+1]>=x)return i+1 ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,8,10,10,12,19 };
      int n=arr.length ;
      int x=3 ;
      int index=ceilSearch(arr,0,n-1,x);
      if(index==-1)System.out.println("Ceiling of "+x+" doesn't exist in array");
      else System.out.println("ceiling of "+x+" is "+arr[index]);
    }
  }

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation ceilSearch( arr : Sequence(int), low : int, high : int, x : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
     if (x <= arr[low+1]) then     return low else skip ; 
         i := low ; while i < high do ( (     if (arr[i+1] = x) then     return i else skip ; 
     if (arr[i+1] < x & arr[i + 1+1] >= x) then     return i + 1 else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,8,10,10,12,19} ;
     var n : int ; n := arr->size() ;
    var x : int ; x := 3 ;
    var index : int ; index := ceilSearch(arr, 0, n - 1, x) ;
    if (index = -1) then     OclFile["System.out"].println("Ceiling of " + x + " doesn't exist in array") else     OclFile["System.out"].println("ceiling of " + x + " is " + arr[index+1]) ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findNums(int arr[],int n){
    int S=0,X=0 ;
    for(int i=0 ; i<n ; i++){
      S+=arr[i];
      X ^=arr[i];
    }
    System.out.println(X+" "+(X+S));
  }
  public static void main(String[] args){
    int arr[]={
      1,7 };
      int n=arr.length ;
      findNums(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNums( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var S : int ; S := 0 ;
    var X : int ; X := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     S := S+(arr[i+1]) ; 
     X := MathLib.bitwiseXor(X,arr[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(X + " " + (X + S)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,7} ;
     var n : int ; n := arr->size() ;
     execute findNums(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p166 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p166().run());
  }
  public String run(){
    int count=0 ;
    int[] num=new int[8];
    do {
      int a=num[0],b=num[1],c=num[2],d=num[3];
      int e=num[4],g=num[5],i=num[6],k=num[7];
      int m=b+c+d-e-i ;
      if(m<0 || m>9)continue ;
      int o=a+b+d-g-k ;
      if(o<0 || o>9)continue ;
      int j=a+b+c-g-m ;
      if(j<0 || j>9)continue ;
      int l=a+b+c+d-i-j-k ;
      if(l<0 || l>9)continue ;
      int f=b+c+d*2-e-i-k ;
      if(f<0 || f>9)continue ;
      int h=a+b+c+d-e-f-g ;
      if(h<0 || h>9)continue ;
      int n=a+c+d-f-j ;
      if(n<0 || n>9)continue ;
      int p=a+b+c-h-l ;
      if(p<0 || p>9)continue ;
      count++;
    }
    while(increment(num));
    return Integer.toString(count);
  }
  private static boolean increment(int[] num){
    int i=0 ;
    while(num[i]==9){
      num[i]=0 ;
      i++;
      if(i==num.length)return false ;
    }
    num[i]++;
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p166 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p166.newp166().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var num : Sequence(int) ; num := Integer.subrange(1,8)->collect(0) ;
   while true do ((     var a : int ; a := num[0+1] ;
    var b : int ; b := num[1+1] ;
    var c : int ; c := num[2+1] ;
    var d : int ; d := num[3+1] ;
     var e : int ; e := num[4+1] ;
    var g : int ; g := num[5+1] ;
    var i : int ; i := num[6+1] ;
    var k : int ; k := num[7+1] ;
    var m : int ; m := b + c + d - e - i ;
    if (m < 0 or m > 9) then     continue else skip ; 
    var o : int ; o := a + b + d - g - k ;
    if (o < 0 or o > 9) then     continue else skip ; 
    var j : int ; j := a + b + c - g - m ;
    if (j < 0 or j > 9) then     continue else skip ; 
    var l : int ; l := a + b + c + d - i - j - k ;
    if (l < 0 or l > 9) then     continue else skip ; 
    var f : int ; f := b + c + d * 2 - e - i - k ;
    if (f < 0 or f > 9) then     continue else skip ; 
    var h : int ; h := a + b + c + d - e - f - g ;
    if (h < 0 or h > 9) then     continue else skip ; 
    var n : int ; n := a + c + d - f - j ;
    if (n < 0 or n > 9) then     continue else skip ; 
    var p : int ; p := a + b + c - h - l ;
    if (p < 0 or p > 9) then     continue else skip ; 
    count := count + 1 ; 
 ) ;
    if (increment(num)) then skip else break) ; 
     return ((count) + "") );
  static   operation increment( num : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     while (num[i+1] = 9) do (     num[i+1] := 0 ; 
     i := i + 1 ; 
     if (i = num->size()) then     return false else skip ) ; 
     num[i+1] := num[i+1] + 1 ; 
     return true );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] z){
    String r="" ;
    for(Scanner s=new Scanner(System.in); s.hasNext(); System.out.print(r+(s.hasNext()? "\n" : "")),r="")for(int n=s.nextInt(),k=0,i,x ; k++<8 ; r+="\n")for(i=10000 ; i>0 ; r+=k<3 ? x/5<1 ? k<2 ? "*" : " " : k<2 ? " " : "*" : k>3 ? x % 5==k-4 ? " " : "*" : "=",i/=10)x=n/i % 10 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : String ; r := "" ;
         var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ; while s.hasNext() do (         var n : int ; n := s.getCurrent()->toInteger() ;
    var k : int ; k := 0 ;
    var i : int ;
    var x : int ; while k < 8 do (         i := 10000 ; while i > 0 do (     x := n / i mod 10 ;  ;     r := r+(if k < 3 then if x / 5 < 1 then if k < 2 then "*" else " " endif else if k < 2 then " " else "*" endif endif else if k > 3 then if x mod 5 = k - 4 then " " else "*" endif else "=" endif endif) ;     i := i/(10) ) ;  ;     r := r+("\n") ) ;  ;     OclFile["System.out"].print(r + (if s.hasNext() then "\n" else "" endif)) ;     r := "" ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static int FindMinimumCost(int ind,int a[],int n,int k,int dp[]){
    if(ind==(n-1))return 0 ;
    else if(dp[ind]!=-1)return dp[ind];
    else {
      int ans=Integer.MAX_VALUE ;
      for(int i=1 ; i<=k ; i++){
        if(ind+i<n)ans=Math.min(ans,Math.abs(a[ind+i]-a[ind])+FindMinimumCost(ind+i,a,n,k,dp));
        else break ;
      }
      return dp[ind]=ans ;
    }
  }
  public static void main(String[] args){
    int a[]={
      10,30,40,50,20 };
      int k=3 ;
      int n=a.length ;
      int dp[]=new int[n];
      Arrays.fill(dp,-1);
      System.out.println(FindMinimumCost(0,a,n,k,dp));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation FindMinimumCost( ind : int, a : Sequence(int), n : int, k : int, dp : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (ind = (n - 1)) then     return 0 else     if (dp[ind+1] /= -1) then     return dp[ind+1] else (     var ans : int ; ans := 2147483647 ;
         var i : int ; i := 1 ; while i <= k do ( (     if (ind + i < n) then     ans := Set{ans, if a[ind + i+1] - a[ind+1] < 0 then -(a[ind + i+1] - a[ind+1]) else a[ind + i+1] - a[ind+1] endif + FindMinimumCost(ind + i, a, n, k, dp)}->min() ; else     break )  ;     i := i + 1 ) ; 
     return dp[ind+1] ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{10,30,40,50,20} ;
     var k : int ; k := 3 ;
    var n : int ; n := a->size() ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
    dp := dp->collect(-1) ; 
    OclFile["System.out"].println(FindMinimumCost(0, a, n, k, dp)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public void solve()throws IOException {
    boolean flag=false ;
    while(stdIn.hasNext()){
      if(flag){
        writer.println();
      }
      flag=true ;
      String str=stdIn.next();
      char[][] result=new char[5][8];
      for(int i=0 ; i<5 ; i++){
        result[i][0]=' ' ;
        result[i][1]=' ' ;
        result[i][2]='=' ;
        result[i][3]='*' ;
        result[i][4]='*' ;
        result[i][5]='*' ;
        result[i][6]='*' ;
        result[i][7]='*' ;
      }
      int n=5-str.length();
      int temp=n ;
      while(n-->0){
        result[n][0]='*' ;
        result[n][3]=' ' ;
      }
      for(int i=0 ; i<str.length(); i++){
        int x=str.charAt(i)-'0' ;
        int a=x/5 ;
        result[i+temp][a]='*' ;
        int b=x % 5+3 ;
        result[i+temp][b]=' ' ;
      }
      for(int i=0 ; i<8 ; i++){
        for(int j=0 ; j<5 ; j++){
          writer.print(result[j][i]);
        }
        writer.println();
      }
    }
    writer.flush();
  }
  public static void main(String args[])throws IOException {
    new Main().run();
  }
  Scanner stdIn ;
  PrintWriter writer ;
  public void run()throws IOException {
    stdIn=null ;
    try {
      stdIn=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
      writer=new PrintWriter(System.out);
      solve();
      stdIn.close();
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var flag : boolean ; flag := false ;
     while (stdIn.hasNext()) do (     if (flag) then (     writer.println() ) else skip ; 
     flag := true ; 
    var str : String ; str := stdIn.next() ;
    var result : Sequence(Sequence(String)) ; result := Integer.subrange(1,5)->collect(Integer.subrange(1,8)->collect(0)) ;
        var i : int ; i := 0 ; while i < 5 do ( (     result[i+1][0+1] := ' ' ; 
     result[i+1][1+1] := ' ' ; 
    result[i+1][2+1] := '=' ; 
    result[i+1][3+1] := '*' ; 
    result[i+1][4+1] := '*' ; 
    result[i+1][5+1] := '*' ; 
    result[i+1][6+1] := '*' ; 
    result[i+1][7+1] := '*' ; 
 )  ;     i := i + 1 ) ; 
    var n : int ; n := 5 - str->size() ;
    var temp : int ; temp := n ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     result[n+1][0+1] := '*' ; 
     result[n+1][3+1] := ' ' ) ;  ) ;  
        var i : int ; i := 0 ; while i < str->size() do ( (     var x : int ; x := str->at(i+1) - ('0')->char2byte() ;
     var a : int ; a := x / 5 ;
    result[i + temp+1][a+1] := '*' ; 
    var b : int ; b := x mod 5 + 3 ;
    result[i + temp+1][b+1] := ' ' ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 8 do ( (         var j : int ; j := 0 ; while j < 5 do ( (     writer.print(result[j+1][i+1]) )  ;     j := j + 1 ) ; 
     writer.println() )  ;     i := i + 1 ) ; 
 ) ; 
     writer.flush() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute stdIn : OclFile;
   attribute writer : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     stdIn := null ; 
     try (     stdIn := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
     writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static char[][] soroban ;
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    boolean first=true ;
    while(cin.hasNext()){
      if(first){
        first=false ;
      }
      else {
        System.out.println();
      }
      soroban=new char[9][6];
      make();
      String str=cin.next();
      for(int i=str.length(); i<=5 ; i++){
        str="0"+str ;
      }
      for(int i=1 ; i<=str.length(); i++){
        int keta=str.length()-i ;
        int value=str.charAt(keta)-'0' ;
        if(value/5+1==2){
          soroban[1][6-i]=' ' ;
        }
        else {
          soroban[2][6-i]=' ' ;
        }
        soroban[value % 5+4][6-i]=' ' ;
      }
      output();
    }
  }
  static void output(){
    for(int i=1 ; i<9 ; i++){
      for(int j=1 ; j<6 ; j++){
        System.out.print(soroban[i][j]);
      }
      System.out.println();
    }
  }
  static void make(){
    for(int i=1 ; i<9 ; i++){
      for(int j=1 ; j<6 ; j++){
        soroban[i][j]='*' ;
      }
    }
    for(int i=1 ; i<6 ; i++){
      soroban[3][i]='=' ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute soroban : Sequence(Sequence(String));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var first : boolean ; first := true ;
     while (cin.hasNext()) do (     if (first) then (     first := false ) else (     OclFile["System.out"].println() ) ;  
     soroban := Integer.subrange(1,9)->collect(Integer.subrange(1,6)->collect(0)) ; 
    execute make() ; 
    var str : String ; str := cin.getCurrent() ;
        var i : int ; i := str->size() ; while i <= 5 do ( (     str := "0" + str )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= str->size() do ( (     var keta : int ; keta := str->size() - (i)->char2byte() ;
     var value : int ; value := str->at(keta+1) - ('0')->char2byte() ;
     if (value / 5 + 1 = 2) then (     soroban[1+1][6 - (i)->char2byte()+1] := ' ' ) else (     soroban[2+1][6 - (i)->char2byte()+1] := ' ' ) ;  
     soroban[value mod 5 + 4+1][6 - (i)->char2byte()+1] := ' ' )  ;     i := i + 1 ) ; 
    execute output() ; 
 ) );
  static   operation output() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < 9 do ( (         var j : int ; j := 1 ; while j < 6 do ( (     OclFile["System.out"].print(soroban[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation make() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < 9 do ( (         var j : int ; j := 1 ; while j < 6 do ( (     soroban[i+1][j+1] := '*' )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i < 6 do ( (     soroban[3+1][i+1] := '=' )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  void run(){
    sc=new Scanner(System.in);
    for(; sc.hasNext(); ){
      int n=sc.nextInt();
      int d=10000 ;
      String[] ans=new String[5];
      String[] table={
        "*=****","*=****","*=****","*=****","*=****","*=****","*=****","*=****","*=****","*=****",};
        for(int i=0 ; i<5 ; i++){
          int m=(n/d)% 10 ;
          ans[i]=table[m];
          d/=10 ;
        }
        for(int j=0 ; j<8 ; j++){
          for(int i=0 ; i<5 ; i++){
            print(ans[i] .charAt(j)+"");
          }
          println("");
        }
        if(sc.hasNext())println("");
      }
      sc.close();
    }
    void print(String s){
      System.out.print(s);
    }
    void println(String s){
      System.out.println(s);
    }
    public static void main(String[] args){
      new Main().run();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
       while sc.hasNext() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var d : int ; d := 10000 ;
    var ans : Sequence(String) ; ans := Integer.subrange(1,5)->collect(null) ;
    var table : Sequence(String) ; table := Sequence{"*=****","*=****","*=****","*=****","*=****","*=****","*=****","*=****","*=****","*=****",} ;
        var i : int ; i := 0 ; while i < 5 do ( (     var m : int ; m := (n / d) mod 10 ;
     ans[i+1] := table[m+1] ; 
     d := d/(10) )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < 8 do ( (         var i : int ; i := 0 ; while i < 5 do ( (     execute print(ans[i+1]->at(j+1) + "") )  ;     i := i + 1 ) ; 
     execute println("") )  ;     j := j + 1 ) ; 
    if (sc.hasNext()) then     execute println("") ; else skip ; 
 )  ) ; 
     skip );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int fives=0 ;
    int zeroes=0 ;
    for(int i=0 ; i<n ; i++){
      int c=sc.nextInt();
      if(c==0){
        zeroes++;
      }
      else {
        fives++;
      }
    }
    if(zeroes==0){
      System.out.println(-1);
    }
    else if(fives<9){
      System.out.println(0);
    }
    else {
      int mul=fives/9 ;
      for(int i=1 ; i<=(9*mul); i++){
        System.out.print(5);
      }
      for(int i=1 ; i<=zeroes ; i++){
        System.out.print(0);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var fives : int ; fives := 0 ;
    var zeroes : int ; zeroes := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var c : int ; c := sc.getCurrent()->toInteger() ;
     if (c = 0) then (     zeroes := zeroes + 1 ) else (     fives := fives + 1 ) )  ;     i := i + 1 ) ; 
    if (zeroes = 0) then (     OclFile["System.out"].println(-1) ) else     if (fives < 9) then (     OclFile["System.out"].println(0) ) else (     var mul : int ; mul := fives / 9 ;
         var i : int ; i := 1 ; while i <= (9 * mul) do ( (     OclFile["System.out"].print(5) )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i <= zeroes do ( (     OclFile["System.out"].print(0) )  ;     i := i + 1 ) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    String stdin=null ;
    boolean first=true ;
    char[][] map=new char[8][5];
    Arrays.fill(map[2],'=');
    while((stdin=parseStdin())!=null){
      int l=stdin.length();
      int d=5-l ;
      Arrays.fill(map[0],'*');
      Arrays.fill(map[1],'*');
      Arrays.fill(map[3],'*');
      Arrays.fill(map[4],'*');
      Arrays.fill(map[5],'*');
      Arrays.fill(map[6],'*');
      Arrays.fill(map[7],'*');
      for(int i=0 ; i<5 ; i++){
        int cn=(i-d>=0)? stdin.codePointAt(i-d)-'0' : 0 ;
        map[1-cn/5][i]=' ' ;
        map[3+cn % 5][i]=' ' ;
      }
      if(! first){
        System.out.println("");
      }
      else {
        first=false ;
      }
      for(int i=0 ; i<map.length ; i++){
        System.out.println(map[i]);
      }
    }
  }
  private static String parseStdin(){
    String stdin=null ;
    try {
      String tmp=br.readLine();
      if(tmp!=null){
        if(! tmp.isEmpty())stdin=tmp ;
      }
    }
    catch(IOException e){
    }
    return stdin ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : String ; stdin := null ;
     var first : boolean ; first := true ;
    var map : Sequence(Sequence(String)) ; map := Integer.subrange(1,8)->collect(Integer.subrange(1,5)->collect(0)) ;
    map[2+1] := map[2+1]->collect('=') ; 
        stdin := parseStdin() ;
    while ((stdin) /= null) do (    skip ; (     var l : int ; l := stdin->size() ;
     var d : int ; d := 5 - l ;
    map[0+1] := map[0+1]->collect('*') ; 
    map[1+1] := map[1+1]->collect('*') ; 
    map[3+1] := map[3+1]->collect('*') ; 
    map[4+1] := map[4+1]->collect('*') ; 
    map[5+1] := map[5+1]->collect('*') ; 
    map[6+1] := map[6+1]->collect('*') ; 
    map[7+1] := map[7+1]->collect('*') ; 
        var i : int ; i := 0 ; while i < 5 do ( (     var cn : int ; cn := if (i - d >= 0) then stdin.codePointAt(i - d) - ('0')->char2byte() else 0 endif ;
     map[1 - cn / 5+1][i+1] := ' ' ; 
     map[3 + cn mod 5+1][i+1] := ' ' )  ;     i := i + 1 ) ; 
    if (not(first)) then (     OclFile["System.out"].println("") ) else (     first := false ) ;  
        var i : int ; i := 0 ; while i < map->size() do ( (     OclFile["System.out"].println(map[i+1]) )  ;     i := i + 1 ) ; 
 ) ;     stdin := parseStdin() ;
 ) ;  
 );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var stdin : String ; stdin := null ;
     try (     var tmp : String ; tmp := br.readLine() ;
     if (tmp /= null) then (     if (not(tmp->isEmpty())) then     stdin := tmp ; else skip ) else skip )   catch (e : IOException) do skip
     return stdin );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int xorGivenSetBits(int arr[],int n,int k){
    Vector<Integer>v=new Vector<>();
    for(int i=0 ; i<n ; i++){
      if(Integer.bitCount(arr[i])==k){
        v.add(arr[i]);
      }
    }
    int result=v.get(0);
    for(int i=1 ; i<v.size(); i++){
      result=result ^ v.get(i);
    }
    return result ;
  }
  public static void main(String[] args){
    int arr[]={
      2,13,1,19,7 };
      int n=arr.length ;
      int k=3 ;
      System.out.println(xorGivenSetBits(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation xorGivenSetBits( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (bitCount(arr[i+1]) = k) then (     v := v->including(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    var result : int ; result := v->at(0+1) ;
        var i : int ; i := 1 ; while i < v->size() do ( (     result := MathLib.bitwiseXor(result,v->at(i+1)) )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,13,1,19,7} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println(xorGivenSetBits(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class A01 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    int n=sc.nextInt();
    int s=sc.nextInt();
    int p=sc.nextInt();
    int x=(((n/s+((n % s==0)? 0 : 1))*k)/p)+((((n/s+((n % s==0)? 0 : 1))*k)% p)==0 ? 0 : 1);
    System.out.println(x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A01 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
    var x : int ; x := (((n / s + (if (n mod s = 0) then 0 else 1 endif)) * k) / p) + (if (((n / s + (if (n mod s = 0) then 0 else 1 endif)) * k) mod p) = 0 then 0 else 1 endif) ;
    OclFile["System.out"].println(x) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int k=sc.nextInt(),n=sc.nextInt(),s=sc.nextInt(),p=sc.nextInt();
    out.println((((n+s-1)/s)*k+p-1)/p);
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class codeforces {
  public static void main(String[] args){
    Scanner ob=new Scanner(System.in);
    int k=ob.nextInt();
    int n=ob.nextInt();
    int s=ob.nextInt();
    int p=ob.nextInt();
    int temp=0 ;
    if(n % s==0)temp=(n/s);
    else temp=(n/s)+1 ;
    int temp2=temp*k ;
    int ans=1 ;
    if(temp2 % p!=0)ans=(temp2/p)+1 ;
    else ans=temp2/p ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ob : OclFile ; ob := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := ob.getCurrent()->toInteger() ;
    var n : int ; n := ob.getCurrent()->toInteger() ;
    var s : int ; s := ob.getCurrent()->toInteger() ;
    var p : int ; p := ob.getCurrent()->toInteger() ;
    var temp : int ; temp := 0 ;
    if (n mod s = 0) then     temp := (n / s) else     temp := (n / s) + 1 ; ;  
    var temp2 : int ; temp2 := temp * k ;
    var ans : int ; ans := 1 ;
    if (temp2 mod p /= 0) then     ans := (temp2 / p) + 1 else     ans := temp2 / p ; ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isSquare(int num){
    int root=(int)Math.sqrt(num);
    return(root*root)==num ;
  }
  static boolean isCube(int num){
    int root=(int)Math.cbrt(num);
    return(root*root*root)==num ;
  }
  static int countSC(int N){
    int count=0 ;
    for(int i=1 ; i<=N ; i++){
      if(isSquare(i))count++;
      else if(isCube(i))count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int N=20 ;
    System.out.println("Number of squares "+"and cubes is "+countSC(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isSquare( num : int) : boolean
  pre: true
  post: true
  activity: (     var root : int ; root := (num)->sqrt()->oclAsType(int) ;
     return (root * root) = num );
  static   operation isCube( num : int) : boolean
  pre: true
  post: true
  activity: (     var root : int ; root := (num)->cbrt()->oclAsType(int) ;
     return (root * root * root) = num );
  static   operation countSC( N : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i <= N do ( (     if (isSquare(i)) then     count := count + 1 ; else     if (isCube(i)) then     count := count + 1 ; else skip ; )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 20 ;
     OclFile["System.out"].println("Number of squares " + "and cubes is " + countSC(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int __gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static long Probability(int sum,int times){
    float favorable=0,total=36 ;
    long probability=0 ;
    for(int i=1 ; i<=6 ; i++){
      for(int j=1 ; j<=6 ; j++){
        if((i+j)==sum)favorable++;
      }
    }
    int gcd1=__gcd((int)favorable,(int)total);
    favorable=favorable/(float)gcd1 ;
    total=total/(float)gcd1 ;
    probability=(long)Math.pow(total,times);
    return probability ;
  }
  public static void main(String[] args){
    int sum=7,times=7 ;
    System.out.println("1"+"/"+Probability(sum,times));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
    if (a = b) then     return a else skip ; 
    if (a > b) then     return __gcd(a - b, b) else skip ; 
    return __gcd(a, b - a) 
 );
  static   operation Probability( sum : int, times : int) : long
  pre: true
  post: true
  activity: (     var favorable : double ; favorable := 0 ;
    var total : double ; total := 36 ;
     var probability : long ; probability := 0 ;
        var i : int ; i := 1 ; while i <= 6 do ( (         var j : int ; j := 1 ; while j <= 6 do ( (     if ((i + j) = sum) then     favorable := favorable + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var gcd1 : int ; gcd1 := __gcd(favorable->oclAsType(int), total->oclAsType(int)) ;
    favorable := favorable / gcd1->oclAsType(double) ; 
    total := total / gcd1->oclAsType(double) ; 
    probability := total->pow(times)->oclAsType(long) ; 
    return probability 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 7 ;
    var times : int ; times := 7 ;
     OclFile["System.out"].println("1" + "/" + Probability(sum, times)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<Obj>listA=new ArrayList<>();
    ArrayList<Obj>listB=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      String s=sc.next();
      int left=0 ;
      int right=0 ;
      for(int j=0 ; j<s.length(); j++){
        if(s.charAt(j)=='('){
          left++;
        }
        else if(s.charAt(j)==')'){
          if(left>0){
            left--;
          }
          else {
            right++;
          }
        }
      }
      Obj obj=new Obj(left,right);
      if(obj.left>obj.right){
        listA.add(obj);
      }
      else {
        listB.add(obj);
      }
    }
    if(solve(listA,listB)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
  static boolean solve(ArrayList<Obj>listA,ArrayList<Obj>listB){
    listA.sort((o1,o2)->o1.right-o2.right);
    listB.sort((o1,o2)->o2.left-o1.left);
    int temp=0 ;
    for(Obj a : listA){
      temp-=a.right ;
      if(temp<0)return false ;
      temp+=a.left ;
    }
    for(Obj a : listB){
      temp-=a.right ;
      if(temp<0)return false ;
      temp+=a.left ;
    }
    if(temp!=0)return false ;
    return true ;
  }
  static class Obj {
    int left ;
    int right ;
    public Obj(int left,int right){
      this.left=left ;
      this.right=right ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var listA : Sequence(Obj) ; listA := Sequence{} ;
    var listB : Sequence(Obj) ; listB := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
     var left : int ; left := 0 ;
    var right : int ; right := 0 ;
        var j : int ; j := 0 ; while j < s->size() do ( (     if (s->at(j+1) = '(') then (     left := left + 1 ) else     if (s->at(j+1) = ')') then (     if (left > 0) then (     left := left - 1 ) else (     right := right + 1 ) ) else skip ; )  ;     j := j + 1 ) ; 
    var obj : Obj ; obj := Obj.newObj(left, right) ;
    if (obj.left > obj.right) then (     listA := listA->including(obj) ) else (     listB := listB->including(obj) ) ;  
 )  ;     i := i + 1 ) ; 
    if (solve(listA, listB)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
  static   operation solve( listA : Sequence(Obj), listB : Sequence(Obj)) : boolean
  pre: true
  post: true
  activity: (     listA := listA.sort(lambda (o1 , o2) : OclAny in o1.right - o2.right) ; 
     listB := listB.sort(lambda (o1 , o2) : OclAny in o2.left - o1.left) ; 
    var temp : int ; temp := 0 ;
    for (a : listA) do ( (     temp := temp-(a.right) ; 
     if (temp < 0) then     return false else skip ; 
     temp := temp+(a.left) )  ) ; 
    for (a : listB) do ( (     temp := temp-(a.right) ; 
     if (temp < 0) then     return false else skip ; 
     temp := temp+(a.left) )  ) ; 
    if (temp /= 0) then     return false else skip ; 
    return true 
 );
  static class Obj {
   attribute left : int;
   attribute right : int;
   static operation newObj( left : int, right : int) : Obj
  pre: true
  post: true
  activity:
  ( var self : Obj ;
    self := createObj();
    self.initialise(left, right);
    return self );
  operation initialise( left : int, right : int) : void
  pre: true  post: true
  activity: (     self.left := left ; 
     self.right := right );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.util.Arrays ;
public class GeeksforGeeks {
  public static int countDe(int arr[],int n){
    int v[]=new int[n];
    for(int i=0 ; i<n ; i++)v[i]=arr[i];
    Arrays.sort(arr);
    int count1=0 ;
    for(int i=0 ; i<n ; i++)if(arr[i]!=v[i])count1++;
    Collections.reverse(Arrays.asList(arr));
    int count2=0 ;
    for(int i=0 ; i<n ; i++)if(arr[i]!=v[i])count2++;
    return(Math.min(count1,count2));
  }
  public static void main(String argc[]){
    int arr[]={
      5,9,21,17,13 };
      int n=5 ;
      System.out.println("Minimum Dearrangement="+countDe(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GeeksforGeeks {
  static   operation countDe( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     v[i+1] := arr[i+1] ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var count1 : int ; count1 := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (arr[i+1] /= v[i+1]) then     count1 := count1 + 1 ; else skip ;  ;     i := i + 1 ) ; 
    arr := arr->reverse() ; 
    var count2 : int ; count2 := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (arr[i+1] /= v[i+1]) then     count2 := count2 + 1 ; else skip ;  ;     i := i + 1 ) ; 
    return (Set{count1, count2}->min()) 
 );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,9,21,17,13} ;
     var n : int ; n := 5 ;
     OclFile["System.out"].println("Minimum Dearrangement=" + countDe(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int[] A=new int[N+2];
    int sum=0 ;
    for(int i=1 ; i<=N ; i++){
      A[i]=scanner.nextInt();
      sum+=Math.abs(A[i]-A[i-1]);
    }
    sum+=Math.abs(A[N]);
    StringBuilder sb=new StringBuilder();
    for(int i=1 ; i<=N ; i++){
      sb.append(sum-Math.abs(A[i]-A[i-1])-Math.abs(A[i]-A[i+1])+Math.abs(A[i+1]-A[i-1])).append('\n');
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N + 2)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     A[i+1] := scanner.getCurrent()->toInteger() ; 
     sum := sum+(if A[i+1] - A[i - 1+1] < 0 then -(A[i+1] - A[i - 1+1]) else A[i+1] - A[i - 1+1] endif) )  ;     i := i + 1 ) ; 
    sum := sum+(if A[N+1] < 0 then -(A[N+1]) else A[N+1] endif) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 1 ; while i <= N do ( (     sb := sb + StringLib.newString(sum - if A[i+1] - A[(i)->char2byte() - 1+1] < 0 then -(A[i+1] - A[(i)->char2byte() - 1+1]) else A[i+1] - A[(i)->char2byte() - 1+1] endif - if A[i+1] - A[i + 1+1] < 0 then -(A[i+1] - A[i + 1+1]) else A[i+1] - A[i + 1+1] endif + if A[i + 1+1] - A[(i)->char2byte() - 1+1] < 0 then -(A[i + 1+1] - A[(i)->char2byte() - 1+1]) else A[i + 1+1] - A[(i)->char2byte() - 1+1] endif) + StringLib.newString('
') )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    TreeMap<Long,Integer>map=new TreeMap<Long,Integer>(Comparator.reverseOrder());
    int n=sc.nextInt();
    long[] al=new long[n+2];
    long[] ans=new long[n+1];
    long max=0 ;
    for(int i=1 ; i<=n+1 ; i++){
      if(i!=n+1)al[i]=sc.nextLong();
      max+=Math.abs(al[i]-al[i-1]);
    }
    for(int i=1 ; i<=n ; i++){
      System.out.println(max-Math.abs(al[i]-al[i-1])-Math.abs(al[i+1]-al[i])+Math.abs(al[i+1]-al[i-1]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var map : Map(long,int) ; map := Map{}->union(Comparator.reverseOrder()) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var al : Sequence(long) ; al := Integer.subrange(1,n + 2)->collect(0) ;
    var ans : Sequence(long) ; ans := Integer.subrange(1,n + 1)->collect(0) ;
    var max : long ; max := 0 ;
        var i : int ; i := 1 ; while i <= n + 1 do ( (     if (i /= n + 1) then     al[i+1] := sc.getCurrent()->toLong() ; else skip ; 
     max := max+(if al[i+1] - al[i - 1+1] < 0 then -(al[i+1] - al[i - 1+1]) else al[i+1] - al[i - 1+1] endif) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].println(max - if al[i+1] - al[i - 1+1] < 0 then -(al[i+1] - al[i - 1+1]) else al[i+1] - al[i - 1+1] endif - if al[i + 1+1] - al[i+1] < 0 then -(al[i + 1+1] - al[i+1]) else al[i + 1+1] - al[i+1] endif + if al[i + 1+1] - al[i - 1+1] < 0 then -(al[i + 1+1] - al[i - 1+1]) else al[i + 1+1] - al[i - 1+1] endif) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    solve(s);
  }
  public static void solve(Scanner s){
    int n=s.nextInt();
    int[] arr=new int[n];
    int sum=0 ;
    int zero=0 ;
    int five=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=s.nextInt();
      if(arr[i]==0){
        zero++;
      }
      else {
        five++;
      }
    }
    if(zero==0){
      System.out.println(-1);
      return ;
    }
    if(five<9){
      System.out.println(0);
      return ;
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<five/9 ; i++){
      sb.append("555555555");
    }
    for(int i=0 ; i<zero ; i++){
      sb.append("0");
    }
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute solve(s) );
  static   operation solve( s : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
    var zero : int ; zero := 0 ;
    var five : int ; five := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() ; 
     if (arr[i+1] = 0) then (     zero := zero + 1 ) else (     five := five + 1 ) )  ;     i := i + 1 ) ; 
    if (zero = 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    if (five < 9) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < five / 9 do ( (     sb := sb + StringLib.newString("555555555") )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < zero do ( (     sb := sb + StringLib.newString("0") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int sum=0 ;
    int[] a=new int[n+2];
    int[] b=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      a[i]=Integer.parseInt(sc.next());
      sum+=Math.abs(a[i-1]-a[i]);
    }
    sum+=Math.abs(a[n]);
    for(int i=1 ; i<=n ; i++){
      if(a[i-1]<a[i]){
        if(a[i+1]<a[i]){
          if(a[i-1]<a[i+1]){
            b[i]=Math.abs(a[i]-a[i+1])*2 ;
          }
          else {
            b[i]=Math.abs(a[i-1]-a[i])*2 ;
          }
        }
      }
      else if(a[i]<a[i-1]){
        if(a[i]<a[i+1]){
          if(a[i+1]<a[i-1]){
            b[i]=Math.abs(a[i]-a[i+1])*2 ;
          }
          else {
            b[i]=Math.abs(a[i-1]-a[i])*2 ;
          }
        }
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int i=1 ; i<=n ; i++){
      sb.append(sum-b[i]).append(System.lineSeparator());
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var sum : int ; sum := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 2)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := (sc.getCurrent())->toInteger() ; 
     sum := sum+(if a[i - 1+1] - a[i+1] < 0 then -(a[i - 1+1] - a[i+1]) else a[i - 1+1] - a[i+1] endif) )  ;     i := i + 1 ) ; 
    sum := sum+(if a[n+1] < 0 then -(a[n+1]) else a[n+1] endif) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (a[i - 1+1] < a[i+1]) then (     if (a[i + 1+1] < a[i+1]) then (     if (a[i - 1+1] < a[i + 1+1]) then (     b[i+1] := if a[i+1] - a[i + 1+1] < 0 then -(a[i+1] - a[i + 1+1]) else a[i+1] - a[i + 1+1] endif * 2 ) else (     b[i+1] := if a[i - 1+1] - a[i+1] < 0 then -(a[i - 1+1] - a[i+1]) else a[i - 1+1] - a[i+1] endif * 2 ) ) else skip ) else     if (a[i+1] < a[i - 1+1]) then (     if (a[i+1] < a[i + 1+1]) then (     if (a[i + 1+1] < a[i - 1+1]) then (     b[i+1] := if a[i+1] - a[i + 1+1] < 0 then -(a[i+1] - a[i + 1+1]) else a[i+1] - a[i + 1+1] endif * 2 ) else (     b[i+1] := if a[i - 1+1] - a[i+1] < 0 then -(a[i - 1+1] - a[i+1]) else a[i - 1+1] - a[i+1] endif * 2 ) ) else skip ) else skip ; )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 1 ; while i <= n do ( (     sb := sb + StringLib.newString(sum - b[i+1]) + StringLib.newString(lineSeparator()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int as[]=new int[n+2];
    int acs[]=new int[n];
    int ap=0 ;
    int in,out ;
    as[0]=0 ;
    as[1]=sc.nextInt();
    ap+=Math.abs(as[1]);
    in=as[1];
    for(int i=2 ; i<=n ; i++){
      as[i]=sc.nextInt();
      out=as[i]-as[i-1];
      ap+=Math.abs(out);
      if(in*out<0)acs[i-2]=Math.abs(in)+Math.abs(out)-Math.abs(as[i]-as[i-2]);
      else acs[i-1]=0 ;
      in=out ;
    }
    as[n+1]=0 ;
    out=as[n+1]-as[n];
    ap+=Math.abs(out);
    if(in*out<0)acs[n-1]=Math.abs(in)+Math.abs(out)-Math.abs(as[n+1]-as[n-1]);
    else acs[n-1]=0 ;
    for(int i=0 ; i<n ; i++){
      System.out.println(ap-acs[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var as : Sequence(int) ; as := Integer.subrange(1,n + 2)->collect(0) ;
    var acs : Sequence(int) ; acs := Integer.subrange(1,n)->collect(0) ;
    var ap : int ; ap := 0 ;
    var in : int ;
    var out : int ;
    as[0+1] := 0 ; 
    as[1+1] := sc.getCurrent()->toInteger() ; 
    ap := ap+(if as[1+1] < 0 then -(as[1+1]) else as[1+1] endif) ; 
    in := as[1+1] ; 
        var i : int ; i := 2 ; while i <= n do ( (     as[i+1] := sc.getCurrent()->toInteger() ; 
     out := as[i+1] - as[i - 1+1] ; 
    ap := ap+(if out < 0 then -(out) else out endif) ; 
    if (in * out < 0) then     acs[i - 2+1] := if in < 0 then -(in) else in endif + if out < 0 then -(out) else out endif - if as[i+1] - as[i - 2+1] < 0 then -(as[i+1] - as[i - 2+1]) else as[i+1] - as[i - 2+1] endif else     acs[i - 1+1] := 0 ; ;  
    in := out ; 
 )  ;     i := i + 1 ) ; 
    as[n + 1+1] := 0 ; 
    out := as[n + 1+1] - as[n+1] ; 
    ap := ap+(if out < 0 then -(out) else out endif) ; 
    if (in * out < 0) then     acs[n - 1+1] := if in < 0 then -(in) else in endif + if out < 0 then -(out) else out endif - if as[n + 1+1] - as[n - 1+1] < 0 then -(as[n + 1+1] - as[n - 1+1]) else as[n + 1+1] - as[n - 1+1] endif else     acs[n - 1+1] := 0 ; ;  
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(ap - acs[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int[] orgazineInOrder(int[] vec,int[] op,int n){
    int[] result=new int[n];
    Arrays.sort(vec);
    int i=0,j=n-1,k=0 ;
    while(i<=j && k<=n-2){
      if(op[k]=='<'){
        result[k]=vec[i++];
      }
      else {
        result[k]=vec[j--];
      }
      k++;
    }
    result[n-1]=vec[i];
    return result ;
  }
  public static void main(String[] args){
    int[] vec={
      8,2,7,1,5,9 };
      int[] op={
        '>','>','<','>','<' };
        int[] result=orgazineInOrder(vec,op,vec.length);
        for(int i=0 ; i<result.length ; i++){
          System.out.print(result[i]+" ");
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation orgazineInOrder( vec : Sequence(int), op : Sequence(int), n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var result : Sequence(int) ; result := Integer.subrange(1,n)->collect(0) ;
     vec := vec->sort() ; 
    var i : int ; i := 0 ;
    var j : int ; j := n - 1 ;
    var k : int ; k := 0 ;
    while (i <= j & k <= n - 2) do (     if (op[k+1] = '<') then (      result[k+1] := vec[i+1]  ; i := i + 1 ) else (      result[k+1] := vec[j+1]  ; j := j - 1 ) ;  
     k := k + 1 ) ; 
    result[n - 1+1] := vec[i+1] ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var vec : Sequence(int) ; vec := Sequence{8,2,7,1,5,9} ;
     var op : Sequence(int) ; op := Sequence{'>','>','<','>','<'} ;
     var result : Sequence(int) ; result := orgazineInOrder(vec, op, vec->size()) ;
         var i : int ; i := 0 ; while i < result->size() do ( (     OclFile["System.out"].print(result[i+1] + " ") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPossible(int arr[],int n,int dist,int k){
    int req=0 ;
    int curr=0 ;
    int prev=0 ;
    for(int i=0 ; i<n ; i++){
      while(curr!=n && arr[curr]-arr[prev]<=dist){
        curr++;
      }
      req++;
      if(curr==n){
        break ;
      }
      prev=curr-1 ;
    }
    if(curr!=n){
      return false ;
    }
    if(req<=k){
      return true ;
    }
    return false ;
  }
  static int minDistance(int arr[],int n,int k){
    int l=0 ;
    int h=arr[n-1];
    int ans=0 ;
    while(l<=h){
      int m=(l+h)/2 ;
      if(isPossible(arr,n,m,k)){
        ans=m ;
        h=m-1 ;
      }
      else {
        l=m+1 ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      2,15,36,43 };
      int n=arr.length ;
      int k=2 ;
      System.out.println(minDistance(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPossible( arr : Sequence(int), n : int, dist : int, k : int) : boolean
  pre: true
  post: true
  activity: (     var req : int ; req := 0 ;
     var curr : int ; curr := 0 ;
    var prev : int ; prev := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     while (curr /= n & arr[curr+1] - arr[prev+1] <= dist) do (     curr := curr + 1 ) ; 
     req := req + 1 ; 
     if (curr = n) then (     break ) else skip ; 
     prev := curr - 1 )  ;     i := i + 1 ) ; 
    if (curr /= n) then (     return false ) else skip ; 
    if (req <= k) then (     return true ) else skip ; 
    return false 
 );
  static   operation minDistance( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
     var h : int ; h := arr[n - 1+1] ;
    var ans : int ; ans := 0 ;
    while (l <= h) do (     var m : int ; m := (l + h) / 2 ;
     if (isPossible(arr, n, m, k)) then (     ans := m ; 
     h := m - 1 ) else (     l := m + 1 ) ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,15,36,43} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(minDistance(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt(),b=sc.nextInt(),c=sc.nextInt(),d=sc.nextInt();
    int ac=Math.abs(a-c);
    int ab=Math.abs(a-b);
    int bc=Math.abs(b-c);
    if(ac<=d || ab<=d && bc<=d){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var ac : int ; ac := if a - c < 0 then -(a - c) else a - c endif ;
    var ab : int ; ab := if a - b < 0 then -(a - b) else a - b endif ;
    var bc : int ; bc := if b - c < 0 then -(b - c) else b - c endif ;
    if (ac <= d or ab <= d & bc <= d) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String...args){
    System.out.println(canTalk(scanInt(),scanInt(),scanInt(),scanInt())? "Yes" : "No");
  }
  private static boolean canTalk(int a,int b,int c,int d){
    if(Math.abs(c-a)<=d){
      return true ;
    }
    if(Math.abs(b-a)<=d && Math.abs(c-b)<=d){
      return true ;
    }
    return false ;
  }
  private static final Scanner SC=new Scanner(System.in);
  private static int scanInt(){
    return SC.nextInt();
  }
  private static String scanString(){
    return SC.next();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if canTalk(scanInt(), scanInt(), scanInt(), scanInt()) then "Yes" else "No" endif) );
  static   operation canTalk( a : int, b : int, c : int, d : int) : boolean
  pre: true
  post: true
  activity: (     if (if c - a < 0 then -(c - a) else c - a endif <= d) then (     return true ) else skip ; 
     if (if b - a < 0 then -(b - a) else b - a endif <= d & if c - b < 0 then -(c - b) else c - b endif <= d) then (     return true ) else skip ; 
     return false );
  static    attribute SC : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation scanInt() : int
  pre: true
  post: true
  activity: (     return SC.getCurrent()->toInteger() );
  static   operation scanString() : String
  pre: true
  post: true
  activity: (     return SC.getCurrent() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner scanner=new Scanner(System.in);
    int a=scanner.nextInt();
    int b=scanner.nextInt();
    int c=scanner.nextInt();
    int d=scanner.nextInt();
    scanner.close();
    int ac=Math.abs(a-c);
    if(ac<=d){
      System.out.println("Yes");
      return ;
    }
    int ab=Math.abs(a-b);
    int bc=Math.abs(b-c);
    if(ab<=d && bc<=d){
      System.out.println("Yes");
      return ;
    }
    System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    var d : int ; d := scanner.getCurrent()->toInteger() ;
    skip ; 
    var ac : int ; ac := if a - c < 0 then -(a - c) else a - c endif ;
    if (ac <= d) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
    var ab : int ; ab := if a - b < 0 then -(a - b) else a - b endif ;
    var bc : int ; bc := if b - c < 0 then -(b - c) else b - c endif ;
    if (ab <= d & bc <= d) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
    OclFile["System.out"].println("No") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    if(Math.abs(c-a)<=d)System.out.print("Yes");
    else if(Math.abs(b-a)<=d && Math.abs(c-b)<=d)System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    if (if c - a < 0 then -(c - a) else c - a endif <= d) then     OclFile["System.out"].print("Yes") else     if (if b - a < 0 then -(b - a) else b - a endif <= d & if c - b < 0 then -(c - b) else c - b endif <= d) then     OclFile["System.out"].print("Yes") else     OclFile["System.out"].print("No") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    int D=sc.nextInt();
    if(Math.abs(A-C)<=D){
      System.out.println("Yes");
    }
    else if((Math.abs(A-B)<=D)&&(Math.abs(B-C)<=D)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var D : int ; D := sc.getCurrent()->toInteger() ;
    if (if A - C < 0 then -(A - C) else A - C endif <= D) then (     OclFile["System.out"].println("Yes") ) else     if ((if A - B < 0 then -(A - B) else A - B endif <= D) & (if B - C < 0 then -(B - C) else B - C endif <= D)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ComparingStrings {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    char[] s=in.next().toCharArray();
    char[] ss=in.next().toCharArray();
    if(s.length!=ss.length){
      pw.println("NO");
      pw.close();
      return ;
    }
    ArrayList<Character>ls=new ArrayList<>();
    ArrayList<Integer>ls2=new ArrayList<>();
    for(int i=0 ; i<s.length ; i++)if(s[i]!=ss[i]){
      ls.add(s[i]);
      ls2.add(i);
    }
    boolean ok=true ;
    if(ls2.size()==2){
      char temp=s[ls2.get(0)];
      s[ls2.get(0)]=s[ls2.get(1)];
      s[ls2.get(1)]=temp ;
      for(int i=0 ; i<s.length ; i++)if(s[i]!=ss[i])ok=false ;
    }
    else ok=false ;
    if(ok)pw.println("YES");
    else pw.println("NO");
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class ComparingStrings {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : Sequence(String) ; s := in.getCurrent()->characters() ;
    var ss : Sequence(String) ; ss := in.getCurrent()->characters() ;
    if (s->size() /= ss->size()) then (     skip ; 
     skip ; 
     return ) else skip ; 
    var ls : Sequence(String) ; ls := Sequence{} ;
    var ls2 : Sequence(int) ; ls2 := Sequence{} ;
        var i : int ; i := 0 ; while i < s->size() do (     if (s[i+1] /= ss[i+1]) then (     ls := ls->including(s[i+1]) ; 
     ls2 := ls2->including(i) ) else skip ;  ;     i := i + 1 ) ; 
    var ok : boolean ; ok := true ;
    if (ls2->size() = 2) then (     var temp : String ; temp := s[ls2->at(0+1)+1] ;
     s[ls2->at(0+1)+1] := s[ls2->at(1+1)+1] ; 
     s[ls2->at(1+1)+1] := temp ; 
         var i : int ; i := 0 ; while i < s->size() do (     if (s[i+1] /= ss[i+1]) then     ok := false ; else skip ;  ;     i := i + 1 ) ) else     ok := false ; ;  
    if (ok) then     skip else     skip ; ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean solve(){
    int n=in.nextInt();
    if(n==0)return false ;
    int[][] table=new int[n][n];
    int cx=n/2,cy=n/2+1 ;
    int cnt=0 ;
    while(cnt<n*n){
      if(table[cy][cx]==0){
        table[cy][cx]=++cnt ;
        cx=(cx+1)% n ;
        cy=(cy+1)% n ;
      }
      else {
        cx=(cx+n-1)% n ;
        cy=(cy+1)% n ;
      }
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        out.printf("%4d",table[i][j]);
      }
      out.println();
    }
    return true ;
  }
  public static void main(String[] args){
    long start=System.currentTimeMillis();
    while(solve());
    out.flush();
    long end=System.currentTimeMillis();
    in.close();
    out.close();
  }
  static void trace(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   operation solve() : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return false else skip ; 
    var table : Sequence(Sequence(int)) ; table := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var cx : int ; cx := n / 2 ;
    var cy : int ; cy := n / 2 + 1 ;
    var cnt : int ; cnt := 0 ;
    while (cnt < n * n) do (     if (table[cy+1][cx+1] = 0) then (         cnt := cnt + 1 ;
 table[cy+1][cx+1] := cnt  ; 
     cx := (cx + 1) mod n ; 
     cy := (cy + 1) mod n ) else (     cx := (cx + n - 1) mod n ; 
     cy := (cy + 1) mod n ) ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     skip )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : long ; start := OclDate.getSystemTime() ;
     while (solve()) do  ; 
    skip ; 
    var end : long ; end := OclDate.getSystemTime() ;
    skip ; 
    skip ; 
 );
  static   operation trace( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  static int[][] getMagicSquare(int n){
    int[][] result=new int[n][n];
    int x=n/2 ;
    int y=n/2+1 ;
    result[y][x]=1 ;
    for(int i=1 ; i<n*n ; i++){
      x++;
      y++;
      while(true){
        if(x==-1)x=n-1 ;
        if(x==n)x=0 ;
        if(y==n)y=0 ;
        if(result[y][x]==0){
          break ;
        }
        else {
          x--;
          y++;
        }
      }
      result[y][x]=i+1 ;
    }
    return result ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while(!(line=br.readLine()).equals("0")){
      int n=Integer.parseInt(line);
      int[][] answer=getMagicSquare(n);
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          System.out.print(String.format("%4d",answer[i][j]));
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation getMagicSquare( n : int) : Sequence(Sequence(int))
  pre: true
  post: true
  activity: (     var result : Sequence(Sequence(int)) ; result := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
     var x : int ; x := n / 2 ;
    var y : int ; y := n / 2 + 1 ;
    result[y+1][x+1] := 1 ; 
        var i : int ; i := 1 ; while i < n * n do ( (     x := x + 1 ; 
     y := y + 1 ; 
     while (true) do (     if (x = -1) then     x := n - 1 ; else skip ; 
     if (x = n) then     x := 0 ; else skip ; 
     if (y = n) then     y := 0 ; else skip ; 
     if (result[y+1][x+1] = 0) then (     break ) else (     x := x - 1 ; 
     y := y + 1 ) ) ; 
     result[y+1][x+1] := i + 1 )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     while (not((line) = "0")) do (     var n : int ; n := (line)->toInteger() ;
     var answer : Sequence(Sequence(int)) ; answer := getMagicSquare(n) ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     OclFile["System.out"].print(StringLib.format("%4d",Sequence{answer[i+1][j+1]})) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.atan2 ;
import static java.lang.Math.sqrt ;
import static java.util.Arrays.deepToString ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    while(sc.hasNext()){
      int n=sc.nextInt();
      int[][] a=new int[n][n];
      int r=n/2+1 ;
      int c=n/2 ;
      for(int k=1 ; k<=n*n ; k++){
        for(; ; ){
          if(c>=n){
            c=0 ;
          }
          else if(c<0){
            c=n-1 ;
          }
          else if(r>=n){
            r=0 ;
          }
          else if(a[r][c]!=0){
            r++;
            c--;
          }
          else break ;
        }
        a[r][c]=k ;
        r++;
        c++;
      }
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          System.out.printf("%4d",a[i][j]);
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var r : int ; r := n / 2 + 1 ;
    var c : int ; c := n / 2 ;
        var k : int ; k := 1 ; while k <= n * n do ( (       while true do ( (     if (c >= n) then (     c := 0 ) else     if (c < 0) then (     c := n - 1 ) else     if (r >= n) then (     r := 0 ) else     if (a[r+1][c+1] /= 0) then (     r := r + 1 ; 
     c := c - 1 ) else     break ;  ;  ;  )  ) ; 
     a[r+1][c+1] := k ; 
     r := r + 1 ; 
     c := c + 1 )  ;     k := k + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     OclFile["System.out"].printf("%4d", a[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  void run(){
    sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      int[][] a=new int[n][n];
      int x=n/2 ;
      int y=n/2+1 ;
      for(int m=1 ; m<=n*n ; m++){
        while(a[y][x]!=0){
          x=(x+n-1)% n ;
          y=(y+1)% n ;
        }
        a[y][x]=m ;
        x=(x+1)% n ;
        y=(y+1)% n ;
      }
      for(int j=0 ; j<n ; j++){
        for(int i=0 ; i<n ; i++){
          print(String.format("%4d",a[j][i]));
        }
        println("");
      }
    }
    sc.close();
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var x : int ; x := n / 2 ;
    var y : int ; y := n / 2 + 1 ;
        var m : int ; m := 1 ; while m <= n * n do ( (     while (a[y+1][x+1] /= 0) do (     x := (x + n - 1) mod n ; 
     y := (y + 1) mod n ) ; 
     a[y+1][x+1] := m ; 
     x := (x + 1) mod n ; 
     y := (y + 1) mod n )  ;     m := m + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (         var i : int ; i := 0 ; while i < n do ( (     execute print(StringLib.format("%4d",Sequence{a[j+1][i+1]})) )  ;     i := i + 1 ) ; 
     execute println("") )  ;     j := j + 1 ) ; 
 )  ) ; 
     skip );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findN(int k){
    int ans ;
    if(k==0)ans=3 ;
    if(k==1)ans=1 ;
    else if(k % 4==0)ans=k ;
    else if(k % 4==3)ans=k-1 ;
    else ans=-1 ;
    return ans ;
  }
  public static void main(String[] args){
    int k=7 ;
    int res=findN(k);
    if(res==-1)System.out.println("Not possible");
    else System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findN( k : int) : int
  pre: true
  post: true
  activity: (     var ans : int ;
     if (k = 0) then     ans := 3 ; else skip ; 
     if (k = 1) then     ans := 1 else     if (k mod 4 = 0) then     ans := k else     if (k mod 4 = 3) then     ans := k - 1 else     ans := -1 ; ;  ;  ;  
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 7 ;
     var res : int ; res := findN(k) ;
     if (res = -1) then     OclFile["System.out"].println("Not possible") ; else     OclFile["System.out"].println(res) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner kbd=new Scanner(System.in);
  public static void main(String[] args){
    while(kbd.hasNext()){
      int n=kbd.nextInt();
      if(n!=0)solve(n);
    }
  }
  static void solve(int n){
    int[][] f=new int[n][n];
    int x,y ;
    x=n/2+1 ;
    y=n/2 ;
    f[x][y]=1 ;
    x=x+1 ;
    y=y+1 ;
    int i=2 ;
    while(i<=n*n){
      if(check(x,y,n)&& empty(x,y,f)){
        f[x][y]=i ;
        i++;
        x+=1 ;
        y+=1 ;
      }
      else {
        if(x<0)x=n-1 ;
        else if(x>=n)x=0 ;
        if(y>=n)y=0 ;
        else if(y<0)y=n-1 ;
        if(! empty(x,y,f)){
          x+=1 ;
          y-=1 ;
        }
      }
    }
    int a,b ;
    for(a=0 ; a<n ; a++){
      for(b=0 ; b<n ; b++){
        System.out.printf("%4d",f[a][b]);
      }
      System.out.println();
    }
  }
  static boolean check(int x,int y,int n){
    boolean a=x<n && x>=0 ;
    boolean b=y<n && y>=0 ;
    return a && b ;
  }
  static boolean empty(int x,int y,int[][] f){
    return f[x][y]==0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute kbd : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (kbd.hasNext()) do (     var n : int ; n := kbd.getCurrent()->toInteger() ;
     if (n /= 0) then     execute solve(n) ; else skip ) );
  static   operation solve( n : int) : void
  pre: true
  post: true
  activity: (     var f : Sequence(Sequence(int)) ; f := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
     var x : int ;
    var y : int ;
    x := n / 2 + 1 ; 
    y := n / 2 ; 
    f[x+1][y+1] := 1 ; 
    x := x + 1 ; 
    y := y + 1 ; 
    var i : int ; i := 2 ;
    while (i <= n * n) do (     if (check(x, y, n) & empty(x, y, f)) then (     f[x+1][y+1] := i ; 
     i := i + 1 ; 
     x := x+(1) ; 
     y := y+(1) ) else (     if (x < 0) then     x := n - 1 else     if (x >= n) then     x := 0 ; else skip ; ;  
     if (y >= n) then     y := 0 else     if (y < 0) then     y := n - 1 ; else skip ; ;  
     if (not(empty(x, y, f))) then (     x := x+(1) ; 
     y := y-(1) ) else skip ) ) ; 
    var a : int ;
    var b : int ;
        a := 0 ; while a < n do ( (         b := 0 ; while b < n do ( (     OclFile["System.out"].printf("%4d", f[a+1][b+1]) )  ;     b := b + 1 ) ; 
     OclFile["System.out"].println() )  ;     a := a + 1 ) ; 
 );
  static   operation check( x : int, y : int, n : int) : boolean
  pre: true
  post: true
  activity: (     var a : boolean ; a := x < n & x >= 0 ;
     var b : boolean ; b := y < n & y >= 0 ;
     return a & b );
  static   operation empty( x : int, y : int, f : Sequence(Sequence(int))) : boolean
  pre: true
  post: true
  activity: (     return f[x+1][y+1] = 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class Main {
  static void func(int n,int k,int[] xa){
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<=n-k ; i++){
      min=Math.min(min,Math.min(Math.abs(xa[i]),Math.abs(xa[i+k-1]))+xa[i+k-1]-xa[i]);
    }
    System.out.println(min);
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    int[] xa=new int[n];
    for(int i=0 ; i<n ; i++){
      xa[i]=in.nextInt();
    }
    func(n,k,xa);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation func( n : int, k : int, xa : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var min : int ; min := 2147483647 ;
         var i : int ; i := 0 ; while i <= n - k do ( (     min := Set{min, Set{if xa[i+1] < 0 then -(xa[i+1]) else xa[i+1] endif, if xa[i + k - 1+1] < 0 then -(xa[i + k - 1+1]) else xa[i + k - 1+1] endif}->min() + xa[i + k - 1+1] - xa[i+1]}->min() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(min) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var xa : Sequence(int) ; xa := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     xa[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute func(n, k, xa) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int K=in.nextInt();
    ArrayList<Long>left=new ArrayList<Long>();
    ArrayList<Long>right=new ArrayList<Long>();
    for(int i=0 ; i<N ; i++){
      long temp=in.nextLong();
      if(temp<=0){
        left.add(temp);
      }
      else {
        right.add(temp);
      }
    }
    long temp=0 ;
    long answer=Long.MAX_VALUE ;
    for(int i=left.size()-1 ; i>=0 ; i--){
      int count=left.size()-i ;
      temp=Math.abs(left.get(i));
      if(count<K && count+right.size()>=K){
        int rightIndex=K-count-1 ;
        temp*=2 ;
        temp+=right.get(rightIndex);
        answer=Math.min(answer,temp);
      }
      else if(count==K){
        answer=Math.min(answer,temp);
      }
    }
    for(int i=0 ; i<right.size(); i++){
      int count=i+1 ;
      temp=right.get(i);
      if(count<K && count+left.size()>=K){
        int leftIndex=left.size()-(K-count);
        temp*=2 ;
        temp+=Math.abs(left.get(leftIndex));
        answer=Math.min(answer,temp);
      }
      else if(count==K){
        answer=Math.min(answer,temp);
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    var left : Sequence(long) ; left := Sequence{} ;
    var right : Sequence(long) ; right := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var temp : long ; temp := in.getCurrent()->toLong() ;
     if (temp <= 0) then (     left := left->including(temp) ) else (     right := right->including(temp) ) )  ;     i := i + 1 ) ; 
    var temp : long ; temp := 0 ;
    var answer : long ; answer := "9223372036854775807"->toLong() ;
        var i : int ; i := left->size() - 1 ; while i >= 0 do ( (     var count : int ; count := left->size() - i ;
     temp := if left->at(i+1) < 0 then -(left->at(i+1)) else left->at(i+1) endif ; 
     if (count < K & count + right->size() >= K) then (     var rightIndex : int ; rightIndex := K - count - 1 ;
     temp := temp*(2) ; 
     temp := temp+(right->at(rightIndex+1)) ; 
     answer := Set{answer, temp}->min() ) else     if (count = K) then (     answer := Set{answer, temp}->min() ) else skip ; )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < right->size() do ( (     var count : int ; count := i + 1 ;
     temp := right->at(i+1) ; 
     if (count < K & count + left->size() >= K) then (     var leftIndex : int ; leftIndex := left->size() - (K - count) ;
     temp := temp*(2) ; 
     temp := temp+(if left->at(leftIndex+1) < 0 then -(left->at(leftIndex+1)) else left->at(leftIndex+1) endif) ; 
     answer := Set{answer, temp}->min() ) else     if (count = K) then (     answer := Set{answer, temp}->min() ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CCandles solver=new CCandles();
    solver.solve(1,in,out);
    out.close();
  }
  static class CCandles {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt(),k=in.nextInt();
      int[] x=new int[n];
      int[] y=new int[n];
      for(int i=0 ; i<n ; i++){
        x[i]=in.nextInt();
        y[n-i-1]=-x[i];
      }
      int ans=Integer.MAX_VALUE ;
      for(int i=0 ; i<n-k+1 ; i++){
        ans=Math.min(ans,x[i+k-1]-x[i]+Math.abs(x[i]));
        ans=Math.min(ans,y[i+k-1]-y[i]+Math.abs(y[i]));
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CCandles ; solver := CCandles.newCCandles() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CCandles {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
     var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := in.getCurrent()->toInteger() ; 
     y[n - i - 1+1] := -x[i+1] )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i < n - k + 1 do ( (     ans := Set{ans, x[i + k - 1+1] - x[i+1] + if x[i+1] < 0 then -(x[i+1]) else x[i+1] endif}->min() ; 
     ans := Set{ans, y[i + k - 1+1] - y[i+1] + if y[i+1] < 0 then -(y[i+1]) else y[i+1] endif}->min() )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long ans=Long.MAX_VALUE ;
    long n,k ;
    long[] x=new long[100005];
    n=sc.nextLong();
    k=sc.nextLong();
    for(int i=0 ; i<n ; i++){
      x[i]=sc.nextLong();
    }
    for(int i=0 ; i<n-k+1 ; i++){
      int l=i ;
      int r=i+(int)k-1 ;
      long tmp=x[r]-x[l];
      if(x[l]<0 && x[r]>0){
        tmp+=Math.min(x[r],Math.abs(x[l]));
      }
      else if(x[l]>0){
        tmp+=x[l];
      }
      else if(x[r]<0){
        tmp+=Math.abs(x[r]);
      }
      ans=Math.min(ans,tmp);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ans : long ; ans := "9223372036854775807"->toLong() ;
    var n : long ;
    var k : long ;
    var x : Sequence(long) ; x := Integer.subrange(1,100005)->collect(0) ;
    n := sc.getCurrent()->toLong() ; 
    k := sc.getCurrent()->toLong() ; 
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - k + 1 do ( (     var l : int ; l := i ;
     var r : int ; r := i + k->oclAsType(int) - 1 ;
    var tmp : long ; tmp := x[r+1] - x[l+1] ;
    if (x[l+1] < 0 & x[r+1] > 0) then (     tmp := tmp+(Set{x[r+1], if x[l+1] < 0 then -(x[l+1]) else x[l+1] endif}->min()) ) else     if (x[l+1] > 0) then (     tmp := tmp+(x[l+1]) ) else     if (x[r+1] < 0) then (     tmp := tmp+(if x[r+1] < 0 then -(x[r+1]) else x[r+1] endif) ) else skip ; ;  ;  
    ans := Set{ans, tmp}->min() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int k=scanner.nextInt();
    int lastMinus=-1 ;
    int[] candles=new int[n];
    for(int i=0 ; i<n ; i++){
      candles[i]=scanner.nextInt();
      if(candles[i]<0)lastMinus++;
    }
    int ans=Integer.MAX_VALUE ;
    int minI ;
    int maxI=Math.min(n-1,lastMinus+k);
    if(lastMinus<n-1 && candles[lastMinus+1]==0){
      minI=Math.max(0,lastMinus-k+2);
    }
    else {
      minI=Math.max(0,lastMinus-k+1);
    }
    for(int i=minI ; i<=maxI-k+1 ; i++){
      int left=candles[i];
      int right=candles[i+k-1];
      if(left<0 && right<=0)ans=Math.min(ans,-left);
      else if(0<=left && 0<right)ans=Math.min(ans,right);
      else ans=Math.min(ans,right-left+Math.min(-left,right));
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
    var lastMinus : int ; lastMinus := -1 ;
    var candles : Sequence(int) ; candles := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     candles[i+1] := scanner.getCurrent()->toInteger() ; 
     if (candles[i+1] < 0) then     lastMinus := lastMinus + 1 ; else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
    var minI : int ;
    var maxI : int ; maxI := Set{n - 1, lastMinus + k}->min() ;
    if (lastMinus < n - 1 & candles[lastMinus + 1+1] = 0) then (     minI := Set{0, lastMinus - k + 2}->max() ) else (     minI := Set{0, lastMinus - k + 1}->max() ) ;  
        var i : int ; i := minI ; while i <= maxI - k + 1 do ( (     var left : int ; left := candles[i+1] ;
     var right : int ; right := candles[i + k - 1+1] ;
     if (left < 0 & right <= 0) then     ans := Set{ans, -left}->min() ; else     if (0 <= left & 0 < right) then     ans := Set{ans, right}->min() else     ans := Set{ans, right - left + Set{-left, right}->min()}->min() ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String f=sc.next();
    String s=sc.next();
    if(s.length()!=f.length()){
      System.out.println("NO");
      return ;
    }
    int fi=-1 ;
    int si=-1 ;
    int di=0 ;
    for(int i=0 ; i<f.length(); i++){
      if(f.charAt(i)!=s.charAt(i)){
        if(fi==-1){
          fi=i ;
        }
        else {
          si=i ;
        }
        di++;
      }
    }
    if(di!=2){
      System.out.println("NO");
    }
    else {
      if(s.charAt(fi)==f.charAt(si)&& f.charAt(fi)==s.charAt(si)){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var f : String ; f := sc.getCurrent() ;
    var s : String ; s := sc.getCurrent() ;
    if (s->size() /= f->size()) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    var fi : int ; fi := -1 ;
    var si : int ; si := -1 ;
    var di : int ; di := 0 ;
        var i : int ; i := 0 ; while i < f->size() do ( (     if (f->at(i+1) /= s->at(i+1)) then (     if (fi = -1) then (     fi := i ) else (     si := i ) ;  
     di := di + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (di /= 2) then (     OclFile["System.out"].println("NO") ) else (     if (s->at(fi+1) = f->at(si+1) & f->at(fi+1) = s->at(si+1)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class problemB {
  public static int n,k ;
  public static int power(int a,int b){
    if(b==0)return 1 ;
    if(b==1)return a ;
    int tg=power(a,b/2);
    if(b % 2==1)return tg*tg*a ;
    return tg*tg ;
  }
  public static boolean isSatisfied(int v){
    int dem=0 ;
    while(v>0){
      dem+=v ;
      v/=k ;
    }
    if(dem>=n)return true ;
    return false ;
  }
  public static int binarySearch(int d,int c,int index){
    if(d>c)return index ;
    int mid=(d+c)/2 ;
    if(isSatisfied(mid)){
      index=mid ;
      return binarySearch(d,mid-1,index);
    }
    else return binarySearch(mid+1,c,index);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    k=sc.nextInt();
    System.out.println(binarySearch(1,n,-1));
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class problemB {
  static   attribute n : int;
  static   operation power( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return 1 else skip ; 
     if (b = 1) then     return a else skip ; 
    var tg : int ; tg := power(a, b / 2) ;
    if (b mod 2 = 1) then     return tg * tg * a else skip ; 
    return tg * tg 
 );
  static   operation isSatisfied( v : int) : boolean
  pre: true
  post: true
  activity: (     var dem : int ; dem := 0 ;
     while (v > 0) do (     dem := dem+(v) ; 
     v := v/(k) ) ; 
     if (dem >= n) then     return true else skip ; 
     return false );
  static   operation binarySearch( d : int, c : int, index : int) : int
  pre: true
  post: true
  activity: (     if (d > c) then     return index else skip ; 
     var mid : int ; mid := (d + c) / 2 ;
     if (isSatisfied(mid)) then (     index := mid ; 
     return binarySearch(d, mid - 1, index) ) else     return binarySearch(mid + 1, c, index) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    k := sc.getCurrent()->toInteger() ; 
    OclFile["System.out"].println(binarySearch(1, n, -1)) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeforces165B {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    long meet=Long.parseLong(st.nextToken());
    long factor=Long.parseLong(st.nextToken());
    long answer=1 ;
    long low=1 ;
    long high=1000000000 ;
    while(low<=high){
      long mid=(low+high)/2 ;
      if(calc(mid,factor)>=meet){
        high=mid-1 ;
      }
      else {
        answer=mid+1 ;
        low=mid+1 ;
      }
    }
    System.out.println(answer);
  }
  static long calc(long n,long factor){
    long answer=n ;
    while(n/factor>0){
      answer+=n/factor ;
      n/=factor ;
    }
    return answer ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces165B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var meet : long ; meet := (st.next())->toLong() ;
    var factor : long ; factor := (st.next())->toLong() ;
    var answer : long ; answer := 1 ;
    var low : long ; low := 1 ;
    var high : long ; high := 1000000000 ;
    while (low <= high) do (     var mid : long ; mid := (low + high) / 2 ;
     if (calc(mid, factor) >= meet) then (     high := mid - 1 ) else (     answer := mid + 1 ; 
     low := mid + 1 ) ) ; 
    OclFile["System.out"].println(answer) ; 
 );
  static   operation calc( n : long, factor : long) : long
  pre: true
  post: true
  activity: (     var answer : long ; answer := n ;
     while (n / factor > 0) do (     answer := answer+(n / factor) ; 
     n := n/(factor) ) ; 
     return answer );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.*;
public class App {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  static int[] f=new int[100001];
  static {
    f[1]=1 ;
    for(int i=2 ; i<f.length ; ++i){
      f[i]=(int)(((i<<1)-1L)*f[i-1] % 1000000007*(i<<1)% 1000000007);
    }
  }
  public static void main(String[] args)throws Exception {
    if(System.getProperty("ONLINE_JUDGE")==null){
      File inputFile=new File("/Users/vipinjain/self/cp/input.txt");
      File outputFile=new File("/Users/vipinjain/self/cp/output.txt");
      br=new BufferedReader(new FileReader(inputFile));
      bw=new BufferedWriter(new FileWriter(outputFile));
    }
    int tests ;
    tests=1 ;
    while(tests-->0){
      solve();
    }
    bw.flush();
    bw.close();
    br.close();
  }
  static boolean isVowel(char c){
    return c=='a' || c=='e' || c=='i' || c=='o' || c=='u' || c=='y' ;
  }
  static void solve()throws Exception {
    int n=Integer.parseInt(br.readLine());
    String str=br.readLine();
    int zeros=0,ones=0 ;
    for(int i=0 ; i<n ; ++i){
      if(str.charAt(i)=='0'){
        zeros++;
      }
      else {
        ones++;
      }
    }
    StringBuilder sb=new StringBuilder(1+zeros);
    if(ones>0){
      sb.append("1");
    }
    for(int i=0 ; i<zeros ; ++i){
      sb.append("0");
    }
    bw.write(sb.toString());
    bw.write("\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute f : Sequence(int) := Integer.subrange(1,100001)->collect(0);
  static operation initialiseClass()
  pre: true post: true
  activity:     f[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < f->size() do ( (     f[i+1] := ((((i*(2->pow(1)))->oclAsType(long)) - 1L) * f[i - 1+1] mod 1000000007 * ((i*(2->pow(1)))->oclAsType(long)) mod 1000000007)->oclAsType(int) )  ;     i := i + 1 ) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null) then (     var inputFile : OclFile ; inputFile := OclFile("/Users/vipinjain/self/cp/input.txt") ;
     var outputFile : OclFile ; outputFile := OclFile("/Users/vipinjain/self/cp/output.txt") ;
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputFile)) ; 
     bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputFile)) ) else skip ; 
     var tests : int ;
    tests := 1 ; 
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation isVowel( c : String) : boolean
  pre: true
  post: true
  activity: (     return c = 'a' or c = 'e' or c = 'i' or c = 'o' or c = 'u' or c = 'y' );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var str : String ; str := br.readLine() ;
    var zeros : int ; zeros := 0 ;
    var ones : int ; ones := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (str->at(i+1) = '0') then (     zeros := zeros + 1 ) else (     ones := ones + 1 ) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString(1 + zeros) ;
    if (ones > 0) then (     sb := sb + StringLib.newString("1") ) else skip ; 
        var i : int ; i := 0 ; while i < zeros do ( (     sb := sb + StringLib.newString("0") )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minOperations(int n,String a,String b,String c){
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      char x=a.charAt(i);
      char y=b.charAt(i);
      char z=c.charAt(i);
      if(x==y && y==z);
      else if(x==y || y==z || x==z){
        ans++;
      }
      else {
        ans+=2 ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    String a="place" ;
    String b="abcde" ;
    String c="plybe" ;
    int n=a.length();
    System.out.print(minOperations(n,a,b,c));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minOperations( n : int, a : String, b : String, c : String) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var x : String ; x := a->at(i+1) ;
     var y : String ; y := b->at(i+1) ;
     var z : String ; z := c->at(i+1) ;
     if (x = y & y = z) then  else     if (x = y or y = z or x = z) then (     ans := ans + 1 ) else (     ans := ans+(2) ) ;  )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ; a := "place" ;
     var b : String ; b := "abcde" ;
    var c : String ; c := "plybe" ;
    var n : int ; n := a->size() ;
    OclFile["System.out"].print(minOperations(n, a, b, c)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int number=sc.nextInt();
    int sum=number ;
    for(int i=0 ; i<number ; i++){
      int temp=sc.nextInt();
      sum-=temp ;
    }
    if(number==1){
      if(sum==1){
        System.out.print("NO");
      }
      else {
        System.out.print("YES");
      }
    }
    else if(sum==1){
      System.out.print("YES");
    }
    else {
      System.out.print("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := number ;
        var i : int ; i := 0 ; while i < number do ( (     var temp : int ; temp := sc.getCurrent()->toInteger() ;
     sum := sum-(temp) )  ;     i := i + 1 ) ; 
    if (number = 1) then (     if (sum = 1) then (     OclFile["System.out"].print("NO") ) else (     OclFile["System.out"].print("YES") ) ) else     if (sum = 1) then (     OclFile["System.out"].print("YES") ) else (     OclFile["System.out"].print("NO") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class FashionInBerland {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int sum=0 ;
    for(int i=0 ; i<n ; ++i){
      sum+=sc.nextInt();
    }
    if((n>1 && n-sum==1)||(n==1 && sum==1)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class FashionInBerland {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    if ((n > 1 & n - sum = 1) or (n = 1 & sum = 1)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    int x=0,y=0 ;
    for(int i=1 ; i<=n ; i++){
      x=sc.nextInt();
      y+=x ;
    }
    if(n==1){
      if(y==1)System.out.println("YES");
      else System.out.println("NO");
    }
    else if(y==n-1){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := 0 ;
    var y : int ; y := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     x := sc.getCurrent()->toInteger() ; 
     y := y+(x) )  ;     i := i + 1 ) ; 
     if (n = 1) then (     if (y = 1) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) else     if (y = n - 1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class FashionInBerland {
  static String myFunction(){
    Scanner obj=new Scanner(System.in);
    int number=obj.nextInt();
    int i=0 ;
    int ZeroFlg=0 ;
    if(number==1){
      if(0==obj.nextInt()){
        ZeroFlg+=1 ;
      }
      if(ZeroFlg==1)return "NO" ;
      return "YES" ;
    }
    while(i<number){
      if(0==obj.nextInt()){
        ZeroFlg+=1 ;
      }
      if(ZeroFlg>1){
        return "NO" ;
      }
      i++;
    }
    if(ZeroFlg==0)return "NO" ;
    return "YES" ;
  }
  public static void main(String argr[]){
    System.out.println(myFunction());
  }
}
------------------------------------------------------------
OCL File:
---------
 class FashionInBerland {
  static   operation myFunction() : String
  pre: true
  post: true
  activity: (     var obj : OclFile ; obj := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := obj.getCurrent()->toInteger() ;
    var i : int ; i := 0 ;
    var ZeroFlg : int ; ZeroFlg := 0 ;
    if (number = 1) then (     if (0 = obj.getCurrent()->toInteger()) then (     ZeroFlg := ZeroFlg+(1) ) else skip ; 
     if (ZeroFlg = 1) then     return "NO" else skip ; 
     return "YES" ) else skip ; 
    while (i < number) do (     if (0 = obj.getCurrent()->toInteger()) then (     ZeroFlg := ZeroFlg+(1) ) else skip ; 
     if (ZeroFlg > 1) then (     return "NO" ) else skip ; 
     i := i + 1 ) ; 
    if (ZeroFlg = 0) then     return "NO" else skip ; 
    return "YES" 
 );
  static   operation main( argr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(myFunction()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    solution(n,arr);
  }
  public static void solution(int n,int[] arr){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==0){
        count++;
      }
    }
    if((count==1 && n>1)||(count==0 && n==1)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute solution(n, arr) ; 
 );
  static   operation solution( n : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 0) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     if ((count = 1 & n > 1) or (count = 0 & n = 1)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int R=3 ;
  static final int C=3 ;
  static int pathCountRec(int mat[][],int m,int n,int k){
    if(m<0 || n<0){
      return 0 ;
    }
    if(m==0 && n==0 &&(k==mat[m][n])){
      return 1 ;
    }
    return pathCountRec(mat,m-1,n,k-mat[m][n])+pathCountRec(mat,m,n-1,k-mat[m][n]);
  }
  static int pathCount(int mat[][],int k){
    return pathCountRec(mat,R-1,C-1,k);
  }
  public static void main(String[] args){
    int k=12 ;
    int mat[][]={
      {
        1,2,3 },{
          4,6,5 },{
            3,2,1 }
          };
          System.out.println(pathCount(mat,k));
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute R : int := 3;
  static    attribute C : int := 3;
  static   operation pathCountRec( mat : Sequence(Sequence(int)), m : int, n : int, k : int) : int
  pre: true
  post: true
  activity: (     if (m < 0 or n < 0) then (     return 0 ) else skip ; 
     if (m = 0 & n = 0 & (k = mat[m+1][n+1])) then (     return 1 ) else skip ; 
     return pathCountRec(mat, m - 1, n, k - mat[m+1][n+1]) + pathCountRec(mat, m, n - 1, k - mat[m+1][n+1]) );
  static   operation pathCount( mat : Sequence(Sequence(int)), k : int) : int
  pre: true
  post: true
  activity: (     return pathCountRec(mat, R - 1, C - 1, k) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 12 ;
     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,2,3},Sequence{4,6,5},Sequence{3,2,1}} ;
     OclFile["System.out"].println(pathCount(mat, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printMultiples(int n){
    int unit_digit=n % 10 ;
    if(unit_digit==0)unit_digit=10 ;
    for(int i=unit_digit ; i<=n ; i+=unit_digit)System.out.print(i+" ");
  }
  public static void main(String[] args){
    int n=39 ;
    printMultiples(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printMultiples( n : int) : void
  pre: true
  post: true
  activity: (     var unit_digit : int ; unit_digit := n mod 10 ;
     if (unit_digit = 0) then     unit_digit := 10 ; else skip ; 
         var i : int ; i := unit_digit ; while i <= n do (     OclFile["System.out"].print(i + " ") ;  ;     i := i+(unit_digit) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 39 ;
     execute printMultiples(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class AComparingStrings {
  public static void main(String[] args)throws IOException {
    BufferedReader buf=new BufferedReader(new InputStreamReader(System.in));
    String a=buf.readLine();
    String b=buf.readLine();
    if(a.length()!=b.length()){
      System.out.println("NO");
      return ;
    }
    ArrayList<Integer>al=new ArrayList<>();
    for(int i=0 ; i<a.length(); i++){
      if(a.charAt(i)!=b.charAt(i))al.add(i);
      if(al.size()>2){
        System.out.println("NO");
        return ;
      }
    }
    if(al.size()!=2){
      System.out.println("NO");
      return ;
    }
    int r=al.get(0);
    int s=al.get(1);
    if(a.charAt(r)==b.charAt(s)&& a.charAt(s)==b.charAt(r))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class AComparingStrings {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var buf : OclFile ; buf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var a : String ; a := buf.readLine() ;
    var b : String ; b := buf.readLine() ;
    if (a->size() /= b->size()) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    var al : Sequence(int) ; al := Sequence{} ;
        var i : int ; i := 0 ; while i < a->size() do ( (     if (a->at(i+1) /= b->at(i+1)) then     al := al->including(i) ; else skip ; 
     if (al->size() > 2) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    if (al->size() /= 2) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    var r : int ; r := al->at(0+1) ;
    var s : int ; s := al->at(1+1) ;
    if (a->at(r+1) = b->at(s+1) & a->at(s+1) = b->at(r+1)) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int evenDecimalValue(String str,int n){
    int result=0 ;
    for(int i=0 ; i<n ; i++){
      if(str.charAt(i)=='0'){
        result+=(n-i);
      }
    }
    return result ;
  }
  public static void main(String[] args){
    String str="10010" ;
    int n=5 ;
    System.out.println(evenDecimalValue(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation evenDecimalValue( str : String, n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (str->at(i+1) = '0') then (     result := result+((n - i)) ) else skip )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "10010" ;
     var n : int ; n := 5 ;
     OclFile["System.out"].println(evenDecimalValue(str, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Math.*;
public class x976A implements Runnable {
  public void run(){
    InputStreamReader reader=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(reader);
    StringTokenizer token=new StringTokenizer("");
    InputReader scan=new InputReader(br,token);
    int T=scan.nextInt();
    int zeros=0 ;
    char[] item=scan.next().toCharArray();
    StringBuilder sb=new StringBuilder();
    if(T==1){
      if(item[0]=='1')sb.append('1');
      else sb.append('0');
    }
    else {
      for(int i=0 ; i<item.length ; i++)if(item[i]=='0')zeros++;
      sb.append('1');
      for(int i=0 ; i<zeros ; i++)sb.append('0');
    }
    System.out.println(sb);
  }
  static class InputReader {
    private BufferedReader readfile ;
    private StringTokenizer token ;
    InputReader(BufferedReader br,StringTokenizer st){
      this.readfile=br ;
      this.token=st ;
    }
    String next(){
      while(! this.token.hasMoreTokens()){
        try {
          token=new StringTokenizer(readfile.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return this.token.nextToken();
    }
    String nextLine()throws IOException {
      return readfile.readLine();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  public static void main(String[] args){
    new Thread(null,new x976A(),"Imtiaz_Adar",1<<26).start();
  }
}
------------------------------------------------------------
OCL File:
---------
 class x976A implements Runnable {
   operation run() : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(reader) ;
    var token : OclIterator ; token := OclIterator.newOclIterator_String("") ;
    var scan : InputReader ; scan := InputReader.newInputReader(br, token) ;
    var T : int ; T := scan.nextInt() ;
    var zeros : int ; zeros := 0 ;
    var item : Sequence(String) ; item := scan.next()->characters() ;
    var sb : String ; sb := StringLib.newString() ;
    if (T = 1) then (     if (item[0+1] = '1') then     sb := sb + StringLib.newString('1') ; else     sb := sb + StringLib.newString('0') ; ) else (         var i : int ; i := 0 ; while i < item->size() do (     if (item[i+1] = '0') then     zeros := zeros + 1 ; else skip ;  ;     i := i + 1 ) ; 
     sb := sb + StringLib.newString('1') ; 
         var i : int ; i := 0 ; while i < zeros do (     sb := sb + StringLib.newString('0') ;  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(sb) ; 
 );
  static class InputReader {
   attribute readfile : OclFile;
   attribute token : OclIterator;
   static operation newInputReader( br : OclFile, st : OclIterator) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(br, st);
    return self );
  operation initialise( br : OclFile, st : OclIterator) : void
  pre: true  post: true
  activity: (     self.readfile := br ; 
     self.token := st );
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(self.token.hasNext())) do (     try (     token := OclIterator.newOclIterator_String(readfile.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return self.token.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return readfile.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(null, x976A.newx976A(), "Imtiaz_Adar", (1*(2->pow(26)))->oclAsType(long)).start() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class iCode2012OutofGas {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int index=1 ; index<=T ; index++){
      System.out.println("Case #"+index+":");
      double D=in.nextDouble();
      int N=in.nextInt();
      int A=in.nextInt();
      double[] time=new double[N+1];
      double[] pos=new double[N+1];
      for(int i=1 ; i<=N ; i++){
        time[i]=in.nextDouble();
        pos[i]=in.nextDouble();
      }
      for(int acc=0 ; acc<A ; acc++){
        double a=in.nextDouble();
        double startmovingat=0 ;
        for(int i=1 ; i<N ; i++){
          startmovingat=Math.max(startmovingat,time[i]-Math.sqrt(2*pos[i]/a));
        }
        double effectivetime=time[N-1]+(time[N]-time[N-1])/(pos[N]-pos[N-1])*(D-pos[N-1]);
        startmovingat=Math.max(startmovingat,effectivetime-Math.sqrt(2*D/a));
        System.out.println(Math.max(effectivetime,startmovingat+Math.sqrt(2*D/a)));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class iCode2012OutofGas {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var index : int ; index := 1 ; while index <= T do ( (     OclFile["System.out"].println("Case #" + index + ":") ; 
     var D : double ; D := in.getCurrent()->toReal() ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var A : int ; A := in.getCurrent()->toInteger() ;
    var time : Sequence(double) ; time := Integer.subrange(1,N + 1)->collect(0.0) ;
    var pos : Sequence(double) ; pos := Integer.subrange(1,N + 1)->collect(0.0) ;
        var i : int ; i := 1 ; while i <= N do ( (     time[i+1] := in.getCurrent()->toReal() ; 
     pos[i+1] := in.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
        var acc : int ; acc := 0 ; while acc < A do ( (     var a : double ; a := in.getCurrent()->toReal() ;
     var startmovingat : double ; startmovingat := 0 ;
        var i : int ; i := 1 ; while i < N do ( (     startmovingat := Set{startmovingat, time[i+1] - (2 * pos[i+1] / a)->sqrt()}->max() )  ;     i := i + 1 ) ; 
    var effectivetime : double ; effectivetime := time[N - 1+1] + (time[N+1] - time[N - 1+1]) / (pos[N+1] - pos[N - 1+1]) * (D - pos[N - 1+1]) ;
    startmovingat := Set{startmovingat, effectivetime - (2 * D / a)->sqrt()}->max() ; 
    OclFile["System.out"].println(Set{effectivetime, startmovingat + (2 * D / a)->sqrt()}->max()) ; 
 )  ;     acc := acc + 1 ) ; 
 )  ;     index := index + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Gas {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    for(int C=1 ; C<=T ; C++){
      System.out.printf("Case #%d:\n",C);
      double D=sc.nextDouble();
      int N=sc.nextInt();
      int A=sc.nextInt();
      if(N==1){
        sc.nextDouble();
        sc.nextDouble();
        for(int i=0 ; i<A ; i++){
          double a=sc.nextDouble();
          System.out.println(Math.sqrt(2*D/a));
        }
        continue ;
      }
      double t1=sc.nextDouble();
      double d1=sc.nextDouble();
      double t2=sc.nextDouble();
      double d2=sc.nextDouble();
      double v=(d2-d1)/t2 ;
      for(int i=0 ; i<A ; i++){
        double a=sc.nextDouble();
        double t_meet=(v+Math.sqrt(v*v+2*a*d1))/a ;
        double d_meet=d1+v*t_meet ;
        if(d_meet>=D){
          System.out.println(Math.sqrt(2*D/a));
        }
        else {
          System.out.println(t_meet+(D-d_meet)/v);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Gas {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var C : int ; C := 1 ; while C <= T do ( (     OclFile["System.out"].printf("Case #%d:\n", C) ; 
     var D : double ; D := sc.getCurrent()->toReal() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    if (N = 1) then (     skip ; 
     skip ; 
         var i : int ; i := 0 ; while i < A do ( (     var a : double ; a := sc.getCurrent()->toReal() ;
     OclFile["System.out"].println((2 * D / a)->sqrt()) )  ;     i := i + 1 ) ; 
     continue ) else skip ; 
    var t1 : double ; t1 := sc.getCurrent()->toReal() ;
    var d1 : double ; d1 := sc.getCurrent()->toReal() ;
    var t2 : double ; t2 := sc.getCurrent()->toReal() ;
    var d2 : double ; d2 := sc.getCurrent()->toReal() ;
    var v : double ; v := (d2 - d1) / t2 ;
        var i : int ; i := 0 ; while i < A do ( (     var a : double ; a := sc.getCurrent()->toReal() ;
     var t_meet : double ; t_meet := (v + (v * v + 2 * a * d1)->sqrt()) / a ;
     var d_meet : double ; d_meet := d1 + v * t_meet ;
     if (d_meet >= D) then (     OclFile["System.out"].println((2 * D / a)->sqrt()) ) else (     OclFile["System.out"].println(t_meet + (D - d_meet) / v) ) )  ;     i := i + 1 ) ; 
 )  ;     C := C + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round1c ;
import java.util.Locale ;
import java.util.Scanner ;
public class B {
  public static void main(String[] args){
    Locale.setDefault(Locale.ENGLISH);
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      double d=sc.nextDouble();
      int n=sc.nextInt();
      int a=sc.nextInt();
      double times[]=new double[n];
      double positions[]=new double[n];
      for(int j=0 ; j<n ; j++){
        times[j]=sc.nextDouble();
        positions[j]=sc.nextDouble();
      }
      System.out.println("Case #"+(i+1)+":");
      for(int j=0 ; j<a ; j++){
        double acc=sc.nextDouble();
        double otherTime=n==1 ? 0 :(d-positions[0])/(positions[1]-positions[0])*(times[1]-times[0])+times[0];
        double myTime=Math.sqrt(d*2/acc);
        System.out.println(""+Math.max(otherTime,myTime));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.ENGLISH) ; 
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var d : double ; d := sc.getCurrent()->toReal() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var times : Sequence(double) ; times := Integer.subrange(1,n)->collect(0.0) ;
    var positions : Sequence(double) ; positions := Integer.subrange(1,n)->collect(0.0) ;
        var j : int ; j := 0 ; while j < n do ( (     times[j+1] := sc.getCurrent()->toReal() ; 
     positions[j+1] := sc.getCurrent()->toReal() )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println("Case #" + (i + 1) + ":") ; 
        var j : int ; j := 0 ; while j < a do ( (     var acc : double ; acc := sc.getCurrent()->toReal() ;
     var otherTime : double ; otherTime := if n = 1 then 0 else (d - positions[0+1]) / (positions[1+1] - positions[0+1]) * (times[1+1] - times[0+1]) + times[0+1] endif ;
     var myTime : double ; myTime := (d * 2 / acc)->sqrt() ;
     OclFile["System.out"].println("" + Set{otherTime, myTime}->max()) )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    double D ;
    int N,A ;
    for(int caseNo=1 ; caseNo<=T ; caseNo++){
      D=in.nextDouble();
      N=in.nextInt();
      A=in.nextInt();
      double anotherVelocity ;
      double[] t=new double[N];
      double[] x=new double[N];
      double minTime=0 ;
      for(int i=0 ; i<N ; i++){
        t[i]=in.nextDouble();
        x[i]=in.nextDouble();
      }
      if(N==2){
        anotherVelocity=(x[1]-x[0])/(t[1]-t[0]);
        minTime=(D-x[0])/anotherVelocity+t[0];
      }
      System.out.println("Case #"+caseNo+":");
      for(int i=0 ; i<A ; i++){
        double a=in.nextDouble();
        if(N==1){
          System.out.printf("%.7f\n",Math.sqrt(2*D/a));
        }
        else {
          System.out.printf("%.7f\n",Math.max(Math.sqrt(2*D/a),minTime));
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
    var D : double ;
    var N : int ;
    var A : int ;
        var caseNo : int ; caseNo := 1 ; while caseNo <= T do ( (     D := in.getCurrent()->toReal() ; 
     N := in.getCurrent()->toInteger() ; 
    A := in.getCurrent()->toInteger() ; 
    var anotherVelocity : double ;
    var t : Sequence(double) ; t := Integer.subrange(1,N)->collect(0.0) ;
    var x : Sequence(double) ; x := Integer.subrange(1,N)->collect(0.0) ;
    var minTime : double ; minTime := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     t[i+1] := in.getCurrent()->toReal() ; 
     x[i+1] := in.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
    if (N = 2) then (     anotherVelocity := (x[1+1] - x[0+1]) / (t[1+1] - t[0+1]) ; 
     minTime := (D - x[0+1]) / anotherVelocity + t[0+1] ) else skip ; 
    OclFile["System.out"].println("Case #" + caseNo + ":") ; 
        var i : int ; i := 0 ; while i < A do ( (     var a : double ; a := in.getCurrent()->toReal() ;
     if (N = 1) then (     OclFile["System.out"].printf("%.7f\n", (2 * D / a)->sqrt()) ) else (     OclFile["System.out"].printf("%.7f\n", Set{(2 * D / a)->sqrt(), minTime}->max()) ) )  ;     i := i + 1 ) ; 
 )  ;     caseNo := caseNo + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
final public class A {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    StringTokenizer st=new StringTokenizer(br.readLine());
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(st.nextToken());
    }
    if(arr.length==1){
      System.out.println(arr[0]);
      System.exit(0);
    }
    int[] pref=new int[n];
    pref[0]=(~ arr[0]);
    for(int i=1 ; i<n ; i++){
      pref[i]=(pref[i-1] &(~ arr[i]));
    }
    int[] suf=new int[n];
    suf[n-1]=(~ arr[n-1]);
    for(int i=n-2 ; i>=0 ; i--){
      suf[i]=(suf[i+1] &(~ arr[i]));
    }
    int max=(arr[0] & suf[1]),ndx=0 ;
    for(int i=1 ; i<n-1 ; i++){
      int val=(arr[i] & pref[i-1] & suf[i+1]);
      if(val>max){
        ndx=i ;
        max=val ;
      }
    }
    if((arr[n-1] &(pref[n-2]))>max){
      ndx=n-1 ;
    }
    sb.append(arr[ndx]+" ");
    for(int i=0 ; i<n ; i++){
      if(i!=ndx)sb.append(arr[i]+" ");
    }
    sb.append('\n');
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    if (arr->size() = 1) then (     OclFile["System.out"].println(arr[0+1]) ; 
 OclProcess.exit(0) ) else skip ; 
    var pref : Sequence(int) ; pref := Integer.subrange(1,n)->collect(0) ;
    pref[0+1] := (-(arr[0+1] + 1)) ; 
        var i : int ; i := 1 ; while i < n do ( (     pref[i+1] := (pref[i - 1+1] & (-(arr[i+1] + 1))) )  ;     i := i + 1 ) ; 
    var suf : Sequence(int) ; suf := Integer.subrange(1,n)->collect(0) ;
    suf[(n)->char2byte() - 1+1] := (-(arr[(n)->char2byte() - 1+1] + 1)) ; 
        var i : int ; i := (n)->char2byte() - 2 ; while i >= 0 do ( (     suf[i+1] := (suf[i + 1+1] & (-(arr[i+1] + 1))) )  ;     i := i - 1 ) ; 
    var max : int ; max := (MathLib.bitwiseAnd(arr[0+1],suf[1+1])) ;
    var ndx : int ; ndx := 0 ;
        var i : int ; i := 1 ; while i < (n)->char2byte() - 1 do ( (     var val : int ; val := (MathLib.bitwiseAnd(MathLib.bitwiseAnd(arr[i+1],pref[i - 1+1]),suf[i + 1+1])) ;
     if (val > max) then (     ndx := i ; 
     max := val ) else skip )  ;     i := i + 1 ) ; 
    if ((arr[(n)->char2byte() - 1+1] & (pref[(n)->char2byte() - 2+1])) > max) then (     ndx := (n)->char2byte() - 1 ) else skip ; 
    sb := sb + StringLib.newString(arr[ndx+1] + " ") ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i /= ndx) then     sb := sb + StringLib.newString(arr[i+1] + " ") ; else skip )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString('
') ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class A {
  public static void main(String[] omkar)throws Exception {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(in.readLine());
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(st.nextToken());
    int[] arr=readArr(n,in,st);
    int maxDig=1 ;
    for(int i=0 ; i<n ; i++){
      maxDig=Math.max((int)(Math.log(arr[i])/Math.log(2)+1),maxDig);
    }
    int temp,temp2 ;
    for(int i=maxDig ; i>=0 ; i--){
      temp=testDig(arr,i);
      if(temp!=-1){
        temp2=arr[0];
        arr[0]=arr[temp];
        arr[temp]=temp2 ;
        print(arr,sb);
        return ;
      }
    }
    print(arr,sb);
  }
  public static int[] readArr(int N,BufferedReader in,StringTokenizer st)throws Exception {
    int[] arr=new int[N];
    st=new StringTokenizer(in.readLine());
    for(int i=0 ; i<N ; i++)arr[i]=Integer.parseInt(st.nextToken());
    return arr ;
  }
  public static int testDig(int[] arr,int d){
    boolean bool=false ;
    int ind=-1 ;
    for(int i=0 ; i<arr.length ; i++){
      if((arr[i]>>d)% 2==1){
        if(bool){
          return-1 ;
        }
        bool=true ;
        ind=i ;
      }
    }
    return ind ;
  }
  public static void print(int[] arr,StringBuilder sb){
    for(int i=0 ; i<arr.length ; i++){
      sb.append(arr[i]+" ");
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( omkar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(in.readLine()) ;
    var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (st.next())->toInteger() ;
    var arr : Sequence(int) ; arr := readArr(n, in, st) ;
    var maxDig : int ; maxDig := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     maxDig := Set{((arr[i+1])->log() / (2)->log() + 1)->oclAsType(int), maxDig}->max() )  ;     i := i + 1 ) ; 
    var temp : int ;
    var temp2 : int ;
        var i : int ; i := maxDig ; while i >= 0 do ( (     temp := testDig(arr, i) ; 
     if (temp /= -1) then (     temp2 := arr[0+1] ; 
     arr[0+1] := arr[temp+1] ; 
    arr[temp+1] := temp2 ; 
    execute print(arr, sb) ; 
    return 
 ) else skip )  ;     i := i - 1 ) ; 
    execute print(arr, sb) ; 
 );
  static   operation readArr( N : int, in : OclFile, st : OclIterator) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
     st := OclIterator.newOclIterator_String(in.readLine()) ; 
         var i : int ; i := 0 ; while i < N do (     arr[i+1] := (st.next())->toInteger() ;  ;     i := i + 1 ) ; 
     return arr );
  static   operation testDig( arr : Sequence(int), d : int) : int
  pre: true
  post: true
  activity: (     var bool : boolean ; bool := false ;
     var ind : int ; ind := -1 ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     if (((arr[i+1]/(2->pow(d)))->oclAsType(long)) mod 2 = 1) then (     if (bool) then (     return -1 ) else skip ; 
     bool := true ; 
     ind := i ) else skip )  ;     i := i + 1 ) ; 
     return ind );
  static   operation print( arr : Sequence(int), sb : String) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < arr->size() do ( (     sb := sb + StringLib.newString(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sb) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_New_Year_and_Naming {
  static Scanner in=new Scanner(System.in);
  public static void main(String[] amit){
    int n=in.nextInt();
    int m=in.nextInt();
    String s[]=new String[n];
    String t[]=new String[m];
    for(int i=0 ; i<n ; i++){
      s[i]=in.next();
    }
    for(int i=0 ; i<m ; i++){
      t[i]=in.next();
    }
    int q=in.nextInt();
    for(int i=0 ; i<q ; i++){
      int x=in.nextInt()-1 ;
      String ans=s[x % n]+t[x % m];
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_New_Year_and_Naming {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( amit : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
    var t : Sequence(String) ; t := Integer.subrange(1,m)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := in.getCurrent() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     t[i+1] := in.getCurrent() )  ;     i := i + 1 ) ; 
    var q : int ; q := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var x : int ; x := in.getCurrent()->toInteger() - 1 ;
     var ans : String ; ans := s[x mod n+1] + t[x mod m+1] ;
     OclFile["System.out"].println(ans) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    sc.nextLine();
    String s=sc.nextLine();
    String t=sc.nextLine();
    String[] dArray=s.split("\\s");
    String[] eArray=t.split("\\s");
    int c=sc.nextInt();
    while(c--!=0){
      int index=sc.nextInt();
      index-=1 ;
      System.out.println(dArray[index % a]+eArray[index % b]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    skip ; 
    var s : String ; s := sc.nextLine() ;
    var t : String ; t := sc.nextLine() ;
    var dArray : Sequence(String) ; dArray := s->split("\\s") ;
    var eArray : Sequence(String) ; eArray := t->split("\\s") ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
        while (c /= 0) do (    skip ; (     var index : int ; index := sc.getCurrent()->toInteger() ;
     index := index-(1) ; 
     OclFile["System.out"].println(dArray[index mod a+1] + eArray[index mod b+1]) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    sc.nextLine();
    String s=sc.nextLine();
    String t=sc.nextLine();
    String[] dArray=s.split("\\s");
    String[] eArray=t.split("\\s");
    int c=sc.nextInt();
    while(c--!=0){
      int index=sc.nextInt();
      index-=1 ;
      System.out.println(dArray[index % a]+eArray[index % b]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    skip ; 
    var s : String ; s := sc.nextLine() ;
    var t : String ; t := sc.nextLine() ;
    var dArray : Sequence(String) ; dArray := s->split("\\s") ;
    var eArray : Sequence(String) ; eArray := t->split("\\s") ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
        while (c /= 0) do (    skip ; (     var index : int ; index := sc.getCurrent()->toInteger() ;
     index := index-(1) ; 
     OclFile["System.out"].println(dArray[index mod a+1] + eArray[index mod b+1]) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    String str1=s.next();
    String str2=s.next();
    if(str1.length()!=str2.length()){
      System.out.println("NO");
      return ;
    }
    int i=0 ;
    int ctr=0 ;
    char x=' ' ;
    char y=' ' ;
    boolean found=false ;
    while(i<str1.length()){
      if(str1.charAt(i)!=str2.charAt(i)){
        ctr++;
        if(ctr==1){
          x=str1.charAt(i);
          y=str2.charAt(i);
        }
        else if(ctr==2){
          if(str1.charAt(i)==y && str2.charAt(i)==x){
            found=true ;
          }
        }
      }
      i++;
    }
    if(ctr==2 && found){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str1 : String ; str1 := s.getCurrent() ;
    var str2 : String ; str2 := s.getCurrent() ;
    if (str1->size() /= str2->size()) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    var i : int ; i := 0 ;
    var ctr : int ; ctr := 0 ;
    var x : String ; x := ' ' ;
    var y : String ; y := ' ' ;
    var found : boolean ; found := false ;
    while (i < str1->size()) do (     if (str1->at(i+1) /= str2->at(i+1)) then (     ctr := ctr + 1 ; 
     if (ctr = 1) then (     x := str1->at(i+1) ; 
     y := str2->at(i+1) ) else     if (ctr = 2) then (     if (str1->at(i+1) = y & str2->at(i+1) = x) then (     found := true ) else skip ) else skip ; ) else skip ; 
     i := i + 1 ) ; 
    if (ctr = 2 & found) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Moves {
  int number ;
  public Moves(int number){
    this.number=number ;
  }
  public int posNumber(int number){
    if(number<0){
      number*=-1 ;
    }
    return number ;
  }
  public void input(int number){
    int num=posNumber(number);
    if(num==1){
      num=4 ;
    }
    if(num % 3==0){
      System.out.println(num/3);
    }
    else {
      System.out.println(num/3+1);
    }
  }
  public int getNumber(){
    return number ;
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    Moves instance=new Moves(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      int num=input.nextInt();
      instance.input(num);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Moves {
   attribute number : int;
   static operation newMoves( number : int) : Moves
  pre: true
  post: true
  activity:
  ( var self : Moves ;
    self := createMoves();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation posNumber( number : int) : int
  pre: true
  post: true
  activity: (     if (number < 0) then (     number := number*(-1) ) else skip ; 
     return number );
   operation input( number : int) : void
  pre: true
  post: true
  activity: (     var num : int ; num := posNumber(number) ;
     if (num = 1) then (     num := 4 ) else skip ; 
     if (num mod 3 = 0) then (     OclFile["System.out"].println(num / 3) ) else (     OclFile["System.out"].println(num / 3 + 1) ) );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
     var instance : Moves ; instance := Moves.newMoves(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
     instance.input(num) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MinimumBinaryNumber {
  public static void main(String[] args){
    Scanner sn=new Scanner(System.in);
    int n=sn.nextInt();
    sn.nextLine();
    String bin_string=sn.nextLine();
    int zero_count=0 ;
    int one_count=0 ;
    for(int i=0 ; i<n ; i++){
      char ch=bin_string.charAt(i);
      if(ch=='1'){
        one_count++;
      }
      else {
        zero_count++;
      }
    }
    StringBuffer sb=new StringBuffer();
    if(one_count>0){
      sb.append("1");
    }
    for(int i=0 ; i<zero_count ; i++){
      sb.append("0");
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MinimumBinaryNumber {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sn : OclFile ; sn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sn.getCurrent()->toInteger() ;
    skip ; 
    var bin_string : String ; bin_string := sn.nextLine() ;
    var zero_count : int ; zero_count := 0 ;
    var one_count : int ; one_count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var ch : String ; ch := bin_string->at(i+1) ;
     if (ch = '1') then (     one_count := one_count + 1 ) else (     zero_count := zero_count + 1 ) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    if (one_count > 0) then (     sb := sb + StringLib.newString("1") ) else skip ; 
        var i : int ; i := 0 ; while i < zero_count do ( (     sb := sb + StringLib.newString("0") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class P1284A {
  public static void main(String[] args)throws IOException {
    BufferedReader io=new BufferedReader(new InputStreamReader(System.in));
    String[] nm=io.readLine().split(" ");
    Integer n=Integer.valueOf(nm[0]);
    Integer m=Integer.valueOf(nm[1]);
    String[] s=io.readLine().split(" ");
    String[] t=io.readLine().split(" ");
    Integer cnt=Integer.valueOf(io.readLine());
    List<String>rs=new ArrayList<String>();
    while(cnt>0){
      cnt--;
      Integer i=Integer.valueOf(io.readLine());
      Integer idxS=i % s.length ;
      Integer idxT=i % t.length ;
      if(idxS==0){
        idxS=s.length ;
      }
      if(idxT==0){
        idxT=t.length ;
      }
      rs.add(s[idxS-1]+t[idxT-1]);
    }
    for(String string : rs){
      System.out.println(string);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P1284A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var nm : Sequence(String) ; nm := io.readLine()->split(" ") ;
    var n : int ; n := (nm[0+1])->toInteger() ;
    var m : int ; m := (nm[1+1])->toInteger() ;
    var s : Sequence(String) ; s := io.readLine()->split(" ") ;
    var t : Sequence(String) ; t := io.readLine()->split(" ") ;
    var cnt : int ; cnt := (io.readLine())->toInteger() ;
    var rs : Sequence(String) ; rs := Sequence{} ;
    while (cnt > 0) do (     cnt := cnt - 1 ; 
     var i : int ; i := (io.readLine())->toInteger() ;
    var idxS : int ; idxS := i mod s->size() ;
    var idxT : int ; idxT := i mod t->size() ;
    if (idxS = 0) then (     idxS := s->size() ) else skip ; 
    if (idxT = 0) then (     idxT := t->size() ) else skip ; 
    rs := rs->including(s[idxS - 1+1] + t[idxT - 1+1]) ; 
 ) ; 
    for (string : rs) do ( (     OclFile["System.out"].println(string) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int win=0 ;
    int lose=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(i % 2==0 && s.charAt(i)=='p'){
        lose++;
      }
      else if(i % 2==1 && s.charAt(i)=='g'){
        win++;
      }
    }
    System.out.println(win-lose);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var win : int ; win := 0 ;
    var lose : int ; lose := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (i mod 2 = 0 & s->at(i+1) = 'p') then (     lose := lose + 1 ) else     if (i mod 2 = 1 & s->at(i+1) = 'g') then (     win := win + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((win)->char2byte() - lose) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s=br.readLine();
    long p=0,g=0,score=0 ;
    char turn ;
    for(int i=0 ; i<s.length(); i++){
      if(p<g){
        turn='p' ;
        p++;
      }
      else {
        turn='g' ;
        g++;
      }
      if(s.charAt(i)=='g'){
        if(turn=='p')score++;
      }
      else {
        if(turn=='g')score--;
      }
    }
    System.out.println(score);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := br.readLine() ;
    var p : long ; p := 0 ;
    var g : long ; g := 0 ;
    var score : long ; score := 0 ;
    var turn : String ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (p < g) then (     turn := 'p' ; 
     p := p + 1 ) else (     turn := 'g' ; 
     g := g + 1 ) ;  
     if (s->at(i+1) = 'g') then (     if (turn = 'p') then     score := score + 1 ; else skip ) else (     if (turn = 'g') then     score := score - 1 ; else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(score) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.String ;
public class Main {
  public static void main(String[] arg){
    Scanner sc=new Scanner(System.in);
    solve(sc);
    sc.close();
  }
  private static void solve(Scanner sc){
    String topCoStr=sc.next();
    char[] atCoStr=new char[topCoStr.length()];
    for(int i=0 ; i<atCoStr.length ; i++){
      if(i % 2==0){
        atCoStr[i]='g' ;
      }
      else {
        atCoStr[i]='p' ;
      }
    }
    int atCoPoint=0 ;
    for(int k=0 ; k<topCoStr.length(); k++){
      if((topCoStr.charAt(k)=='g')&&(atCoStr[k]=='p')){
        atCoPoint++;
      }
      else if((topCoStr.charAt(k)=='p')&&(atCoStr[k]=='g')){
        atCoPoint--;
      }
    }
    System.out.println(atCoPoint);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute solve(sc) ; 
     skip );
  static   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var topCoStr : String ; topCoStr := sc.getCurrent() ;
     var atCoStr : Sequence(String) ; atCoStr := Integer.subrange(1,topCoStr->size())->collect(0) ;
        var i : int ; i := 0 ; while i < atCoStr->size() do ( (     if (i mod 2 = 0) then (     atCoStr[i+1] := 'g' ) else (     atCoStr[i+1] := 'p' ) )  ;     i := i + 1 ) ; 
    var atCoPoint : int ; atCoPoint := 0 ;
        var k : int ; k := 0 ; while k < topCoStr->size() do ( (     if ((topCoStr->at(k+1) = 'g') & (atCoStr[k+1] = 'p')) then (     atCoPoint := atCoPoint + 1 ) else     if ((topCoStr->at(k+1) = 'p') & (atCoStr[k+1] = 'g')) then (     atCoPoint := atCoPoint - 1 ) else skip ; )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(atCoPoint) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    try(Scanner sc=new Scanner(System.in)){
      String S=sc.next();
      int g=0,c=0,p=0 ;
      int ans=0 ;
      for(int i=0 ; i<S.length(); i++){
        switch(S.charAt(i)){
          case 'g' : {
            if(p<g){
              p++;
              ans++;
            }
            else {
              g++;
            }
            break ;
          }
          case 'p' : {
            if(p<g){
              p++;
            }
            else {
              g++;
              ans--;
            }
            break ;
          }
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var S : String ; S := sc.getCurrent() ;
     var g : int ; g := 0 ;
    var c : int ; c := 0 ;
    var p : int ; p := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < S->size() do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (S->at(i+1)) ; 
       if _switchval = 'g' then
 (     if (p < g) then (     p := p + 1 ; 
     ans := ans + 1 ) else (     g := g + 1 ) ;  
     break ) 
   else skip ;
       if _switchval = 'p' then
 (     if (p < g) then (     p := p + 1 ) else (     g := g + 1 ; 
     ans := ans - 1 ) ;  
     break ) 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String g=sc.next();
    System.out.println(cal(g));
  }
  private static int cal(final String g){
    char[] ch=g.toCharArray();
    int n=0 ;
    for(char c : ch){
      if(c=='g'){
        n++;
      }
      else {
        n--;
      }
    }
    return n<=0 ? 0 : n/2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var g : String ; g := sc.getCurrent() ;
     OclFile["System.out"].println(cal(g)) );
  static   operation cal( g : String) : int
  pre: true
  post: true
  activity: (     var ch : Sequence(String) ; ch := g->characters() ;
     var n : int ; n := 0 ;
     for (c : ch) do ( (     if (c = 'g') then (     n := n + 1 ) else (     n := n - 1 ) )  ) ; 
     return if n <= 0 then 0 else n / 2 endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewClass15 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      long x[]=new long[n];
      long min=Long.MAX_VALUE ;
      long max=Long.MIN_VALUE ;
      for(int i=0 ; i<n ; i++){
        x[i]=in.nextInt();
        min=Math.min(min,x[i]);
        max=Math.max(max,x[i]);
      }
      long y[]=new long[n];
      long minb=Long.MAX_VALUE ;
      long maxb=Long.MIN_VALUE ;
      for(int i=0 ; i<n ; i++){
        y[i]=in.nextInt();
        minb=Math.min(minb,y[i]);
        maxb=Math.max(maxb,y[i]);
      }
      if(min==maxb && max==minb){
        System.out.println("0");
      }
      else System.out.println(solve(x,y,n,min,minb));
    }
  }
  private static long solve(long[] x,long[] y,int n,long min,long b){
    int i=0 ;
    long movee=0 ;
    while(i<n){
      long d1=x[i]-min ;
      long d2=y[i]-b ;
      movee+=d1>d2 ? d1 : d2 ;
      i++;
    }
    return movee ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass15 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var x : Sequence(long) ; x := Integer.subrange(1,n)->collect(0) ;
    var min : long ; min := "9223372036854775807"->toLong() ;
    var max : long ; max := "-9223372036854775808"->toLong() ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := in.getCurrent()->toInteger() ; 
     min := Set{min, x[i+1]}->min() ; 
     max := Set{max, x[i+1]}->max() )  ;     i := i + 1 ) ; 
    var y : Sequence(long) ; y := Integer.subrange(1,n)->collect(0) ;
    var minb : long ; minb := "9223372036854775807"->toLong() ;
    var maxb : long ; maxb := "-9223372036854775808"->toLong() ;
        var i : int ; i := 0 ; while i < n do ( (     y[i+1] := in.getCurrent()->toInteger() ; 
     minb := Set{minb, y[i+1]}->min() ; 
     maxb := Set{maxb, y[i+1]}->max() )  ;     i := i + 1 ) ; 
    if (min = maxb & max = minb) then (     OclFile["System.out"].println("0") ) else     OclFile["System.out"].println(solve(x, y, n, min, minb)) ; ;  
 ) ;  ) );
  static   operation solve( x : Sequence(long), y : Sequence(long), n : int, min : long, b : long) : long
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var movee : long ; movee := 0 ;
     while (i < n) do (     var d1 : long ; d1 := x[i+1] - min ;
     var d2 : long ; d2 := y[i+1] - b ;
     movee := movee+(if d1 > d2 then d1 else d2 endif) ; 
     i := i + 1 ) ; 
     return movee );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test128 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    for(int j=0 ; j<n ; j++){
      int x=in.nextInt();
      int a[]=new int[x];
      int b[]=new int[x];
      a[0]=in.nextInt();
      long sum=0 ;
      int mina=a[0];
      for(int i=1 ; i<x ; i++){
        a[i]=in.nextInt();
        if(a[i]<mina){
          mina=a[i];
        }
      }
      b[0]=in.nextInt();
      int minb=b[0];
      for(int i=1 ; i<x ; i++){
        b[i]=in.nextInt();
        if(b[i]<minb){
          minb=b[i];
        }
      }
      for(int i=0 ; i<x ; i++){
        if(a[i]>mina && b[i]>minb){
          if(a[i]-mina<b[i]-minb){
            sum+=a[i]-mina ;
            b[i]-=a[i]-mina ;
            a[i]-=a[i]-mina ;
          }
          else {
            sum+=b[i]-minb ;
            a[i]-=b[i]-minb ;
            b[i]-=b[i]-minb ;
          }
        }
        sum+=a[i]-mina ;
        sum+=b[i]-minb ;
      }
      System.out.println(sum);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test128 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,x)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,x)->collect(0) ;
    a[0+1] := in.getCurrent()->toInteger() ; 
    var sum : long ; sum := 0 ;
    var mina : int ; mina := a[0+1] ;
        var i : int ; i := 1 ; while i < x do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     if (a[i+1] < mina) then (     mina := a[i+1] ) else skip )  ;     i := i + 1 ) ; 
    b[0+1] := in.getCurrent()->toInteger() ; 
    var minb : int ; minb := b[0+1] ;
        var i : int ; i := 1 ; while i < x do ( (     b[i+1] := in.getCurrent()->toInteger() ; 
     if (b[i+1] < minb) then (     minb := b[i+1] ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < x do ( (     if (a[i+1] > mina & b[i+1] > minb) then (     if (a[i+1] - mina < b[i+1] - minb) then (     sum := sum+(a[i+1] - mina) ; 
     b[i+1] := b[i+1]-(a[i+1] - mina) ; 
     a[i+1] := a[i+1]-(a[i+1] - mina) ) else (     sum := sum+(b[i+1] - minb) ; 
     a[i+1] := a[i+1]-(b[i+1] - minb) ; 
     b[i+1] := b[i+1]-(b[i+1] - minb) ) ) else skip ; 
     sum := sum+(a[i+1] - mina) ; 
     sum := sum+(b[i+1] - minb) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1399B_GiftsFixing {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int amount=parseInt(input.nextLine());
      int minA=Integer.MAX_VALUE ;
      int minB=Integer.MAX_VALUE ;
      int[] candies=new int[amount];
      int[] oranges=new int[amount];
      for(int i=0 ; i<amount ; i++){
        int num=input.nextInt();
        candies[i]=num ;
        minA=Math.min(minA,num);
      }
      input.nextLine();
      for(int i=0 ; i<amount ; i++){
        int num=input.nextInt();
        oranges[i]=num ;
        minB=Math.min(minB,num);
      }
      input.nextLine();
      long result=0 ;
      for(int i=0 ; i<amount ; i++){
        int aMoves=candies[i]-minA ;
        int bMoves=oranges[i]-minB ;
        int max=Math.max(aMoves,bMoves);
        int min=Math.min(aMoves,bMoves);
        result+=min ;
        result+=max-min ;
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1399B_GiftsFixing {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var amount : int ; amount := parseInt(input.nextLine()) ;
     var minA : int ; minA := 2147483647 ;
    var minB : int ; minB := 2147483647 ;
    var candies : Sequence(int) ; candies := Integer.subrange(1,amount)->collect(0) ;
    var oranges : Sequence(int) ; oranges := Integer.subrange(1,amount)->collect(0) ;
        var i : int ; i := 0 ; while i < amount do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
     candies[i+1] := num ; 
     minA := Set{minA, num}->min() )  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < amount do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
     oranges[i+1] := num ; 
     minB := Set{minB, num}->min() )  ;     i := i + 1 ) ; 
    skip ; 
    var result : long ; result := 0 ;
        var i : int ; i := 0 ; while i < amount do ( (     var aMoves : int ; aMoves := candies[i+1] - minA ;
     var bMoves : int ; bMoves := oranges[i+1] - minB ;
    var max : int ; max := Set{aMoves, bMoves}->max() ;
    var min : int ; min := Set{aMoves, bMoves}->min() ;
    result := result+(min) ; 
    result := result+(max - min) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      long[] a=new long[n];
      long[] b=new long[n];
      long mina=Integer.MAX_VALUE,minb=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; i++){
        a[i]=s.nextInt();
        mina=Math.min(mina,a[i]);
      }
      for(int i=0 ; i<n ; i++){
        b[i]=s.nextInt();
        minb=Math.min(minb,b[i]);
      }
      fun(a,b,mina,minb,n);
    }
  }
  static void fun(long[] a,long[] b,long mina,long minb,int n){
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=Math.max((a[i]-mina),(b[i]-minb));
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
    var mina : long ; mina := 2147483647 ;
    var minb : long ; minb := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := s.getCurrent()->toInteger() ; 
     mina := Set{mina, a[i+1]}->min() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := s.getCurrent()->toInteger() ; 
     minb := Set{minb, b[i+1]}->min() )  ;     i := i + 1 ) ; 
    execute fun(a, b, mina, minb, n) ; 
 ) ;  ) );
  static   operation fun( a : Sequence(long), b : Sequence(long), mina : long, minb : long, n : int) : void
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(Set{(a[i+1] - mina), (b[i+1] - minb)}->max()) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sum) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MinimumBinaryNumber {
  public static int ones(String st){
    int sum=0 ;
    for(int i=0 ; i<st.length(); i++){
      if(st.charAt(i)=='0')sum++;
    }
    return sum ;
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int x=scanner.nextInt();
    String st=scanner.next();
    String st1="1" ;
    if(ones(st)==st.length()){
      pw.print(st);
    }
    else {
      for(int i=0 ; i<ones(st); i++)st1+="0" ;
      pw.print(st1);
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class MinimumBinaryNumber {
  static   operation ones( st : String) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < st->size() do ( (     if (st->at(i+1) = '0') then     sum := sum + 1 ; else skip )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var x : int ; x := scanner.getCurrent()->toInteger() ;
    var st : String ; st := scanner.getCurrent() ;
    var st1 : String ; st1 := "1" ;
    if (ones(st) = st->size()) then (     skip ) else (         var i : int ; i := 0 ; while i < ones(st) do (     st1 := st1+("0") ;  ;     i := i + 1 ) ; 
     skip ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countDecreasing(int A[],int n){
    int cnt=0 ;
    int len=1 ;
    for(int i=0 ; i<n-1 ; ++i){
      if(A[i+1]<A[i])len++;
      else {
        cnt+=(((len-1)*len)/2);
        len=1 ;
      }
    }
    if(len>1)cnt+=(((len-1)*len)/2);
    return cnt ;
  }
  public static void main(String[] args){
    int A[]={
      100,3,1,13 };
      int n=A.length ;
      System.out.println(countDecreasing(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDecreasing( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var len : int ; len := 1 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (A[i + 1+1] < A[i+1]) then     len := len + 1 ; else (     cnt := cnt+((((len - 1) * len) / 2)) ; 
     len := 1 ) )  ;     i := i + 1 ) ; 
    if (len > 1) then     cnt := cnt+((((len - 1) * len) / 2)) ; else skip ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{100,3,1,13} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].println(countDecreasing(A, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution14 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    StringBuilder str=new StringBuilder();
    for(int z=0 ; z<t ; z++){
      int n=sc.nextInt();
      long[] a=new long[n];
      long[] b=new long[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextLong();
      }
      for(int i=0 ; i<n ; i++){
        b[i]=sc.nextLong();
      }
      long minA=Long.MAX_VALUE ;
      long minB=Long.MAX_VALUE ;
      long c=0 ;
      for(int i=0 ; i<n ; i++){
        minA=Math.min(minA,a[i]);
        minB=Math.min(minB,b[i]);
      }
      for(int i=0 ; i<n ; i++){
        if(a[i]==minA){
          c=c+b[i]-minB ;
          b[i]=minB ;
        }
        else if(b[i]==minB){
          c=c+a[i]-minA ;
          a[i]=minA ;
        }
        else {
          if(a[i]-minA<b[i]-minB){
            c=c+a[i]-minA ;
            b[i]=b[i]-(a[i]-minA);
            a[i]=minA ;
          }
          else {
            c=c+b[i]-minB ;
            a[i]=a[i]-(b[i]-minB);
            b[i]=minB ;
          }
        }
      }
      for(int i=0 ; i<n ; i++){
        c+=a[i]-minA ;
        c+=b[i]-minB ;
      }
      str.append(c);
      str.append("\n");
    }
    sc.close();
    System.out.println(str.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution14 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var str : String ; str := StringLib.newString() ;
        var z : int ; z := 0 ; while z < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var minA : long ; minA := "9223372036854775807"->toLong() ;
    var minB : long ; minB := "9223372036854775807"->toLong() ;
    var c : long ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     minA := Set{minA, a[i+1]}->min() ; 
     minB := Set{minB, b[i+1]}->min() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = minA) then (     c := c + b[i+1] - minB ; 
     b[i+1] := minB ) else     if (b[i+1] = minB) then (     c := c + a[i+1] - minA ; 
     a[i+1] := minA ) else (     if (a[i+1] - minA < b[i+1] - minB) then (     c := c + a[i+1] - minA ; 
     b[i+1] := b[i+1] - (a[i+1] - minA) ; 
     a[i+1] := minA ) else (     c := c + b[i+1] - minB ; 
     a[i+1] := a[i+1] - (b[i+1] - minB) ; 
     b[i+1] := minB ) ) ;  )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     c := c+(a[i+1] - minA) ; 
     c := c+(b[i+1] - minB) )  ;     i := i + 1 ) ; 
    str := str + StringLib.newString(c) ; 
    str := str + StringLib.newString("\n") ; 
 )  ;     z := z + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(str+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int count_odd_pair(int n,int a[]){
    int odd=0,even=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i] % 2==0)even++;
      else odd++;
    }
    int ans=odd*even*2 ;
    return ans ;
  }
  static int count_even_pair(int odd_sum_pairs,int n){
    int total_pairs=(n*(n-1));
    int ans=total_pairs-odd_sum_pairs ;
    return ans ;
  }
  public static void main(String[] args){
    int n=6 ;
    int[] a={
      2,4,5,9,1,8 };
      int odd_sum_pairs=count_odd_pair(n,a);
      int even_sum_pairs=count_even_pair(odd_sum_pairs,n);
      System.out.println("Even Sum Pairs="+even_sum_pairs);
      System.out.println("Odd Sum Pairs="+odd_sum_pairs);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation count_odd_pair( n : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var odd : int ; odd := 0 ;
    var even : int ; even := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] mod 2 = 0) then     even := even + 1 ; else     odd := odd + 1 ; )  ;     i := i + 1 ) ; 
     var ans : int ; ans := odd * even * 2 ;
     return ans );
  static   operation count_even_pair( odd_sum_pairs : int, n : int) : int
  pre: true
  post: true
  activity: (     var total_pairs : int ; total_pairs := (n * (n - 1)) ;
     var ans : int ; ans := total_pairs - odd_sum_pairs ;
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     var a : Sequence(int) ; a := Sequence{2,4,5,9,1,8} ;
    var odd_sum_pairs : int ; odd_sum_pairs := count_odd_pair(n, a) ;
    var even_sum_pairs : int ; even_sum_pairs := count_even_pair(odd_sum_pairs, n) ;
    OclFile["System.out"].println("Even Sum Pairs=" + even_sum_pairs) ; 
    OclFile["System.out"].println("Odd Sum Pairs=" + odd_sum_pairs) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int squares(int l,int b,int a){
    return(int)(Math.ceil(l/(double)a)*Math.ceil(b/(double)a));
  }
  public static void main(String[] args){
    int l=11,b=23,a=14 ;
    System.out.println(squares(l,b,a));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation squares( l : int, b : int, a : int) : int
  pre: true
  post: true
  activity: (     return ((l / a->oclAsType(double))->ceil() * (b / a->oclAsType(double))->ceil())->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 11 ;
    var b : int ; b := 23 ;
    var a : int ; a := 14 ;
     OclFile["System.out"].println(squares(l, b, a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1180 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    StringBuilder out=new StringBuilder();
    int N=in.nextInt();
    int[] A=new int[N];
    int minIdx=-1 ;
    int min=Integer.MAX_VALUE ;
    for(int n=0 ; n<N ; n++){
      int a=in.nextInt();
      if(a>=0){
        a=-a-1 ;
      }
      if(a<min){
        min=a ;
        minIdx=n ;
      }
      A[n]=a ;
    }
    if(N % 2==1){
      A[minIdx]=-A[minIdx]-1 ;
    }
    for(int a : A){
      out.append(a).append(' ');
    }
    System.out.println(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1180 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : String ; out := StringLib.newString() ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var minIdx : int ; minIdx := -1 ;
    var min : int ; min := 2147483647 ;
        var n : int ; n := 0 ; while n < N do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     if (a >= 0) then (     a := -a - 1 ) else skip ; 
     if (a < min) then (     min := a ; 
     minIdx := n ) else skip ; 
     A[n+1] := a )  ;     n := n + 1 ) ; 
    if (N mod 2 = 1) then (     A[minIdx+1] := -A[minIdx+1] - 1 ) else skip ; 
    for (a : A) do ( (     out := out + StringLib.newString(a) + StringLib.newString(' ') )  ) ; 
    OclFile["System.out"].println(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxIncSubarr(int a[],int n){
    int pre[]=new int[n];
    int pos[]=new int[n];
    pre[0]=1 ;
    pos[n-1]=1 ;
    int l=0 ;
    for(int i=1 ; i<n ; i++){
      if(a[i]>a[i-1])pre[i]=pre[i-1]+1 ;
      else pre[i]=1 ;
    }
    l=1 ;
    for(int i=n-2 ; i>=0 ; i--){
      if(a[i]<a[i+1])pos[i]=pos[i+1]+1 ;
      else pos[i]=1 ;
    }
    int ans=0 ;
    l=1 ;
    for(int i=1 ; i<n ; i++){
      if(a[i]>a[i-1])l++;
      else l=1 ;
      ans=Math.max(ans,l);
    }
    for(int i=1 ; i<=n-2 ; i++){
      if(a[i-1]<a[i+1])ans=Math.max(pre[i-1]+pos[i+1],ans);
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2 };
      int n=arr.length ;
      System.out.println(maxIncSubarr(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxIncSubarr( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var pre : Sequence(int) ; pre := Integer.subrange(1,n)->collect(0) ;
     var pos : Sequence(int) ; pos := Integer.subrange(1,n)->collect(0) ;
    pre[0+1] := 1 ; 
    pos[n - 1+1] := 1 ; 
    var l : int ; l := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] > a[i - 1+1]) then     pre[i+1] := pre[i - 1+1] + 1 ; else     pre[i+1] := 1 ; )  ;     i := i + 1 ) ; 
    l := 1 ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (a[i+1] < a[i + 1+1]) then     pos[i+1] := pos[i + 1+1] + 1 ; else     pos[i+1] := 1 ; )  ;     i := i - 1 ) ; 
    var ans : int ; ans := 0 ;
    l := 1 ; 
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] > a[i - 1+1]) then     l := l + 1 else     l := 1 ; ;  
     ans := Set{ans, l}->max() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n - 2 do ( (     if (a[i - 1+1] < a[i + 1+1]) then     ans := Set{pre[i - 1+1] + pos[i + 1+1], ans}->max() ; else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxIncSubarr(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector ;
class GFG {
  static Vector<Integer>solve(int v[]){
    Vector<Integer>res=new Vector<Integer>();
    int all3=v[0]+v[1]+v[2];
    res.add(all3-v[1]*2);
    res.add(all3-v[2]*2);
    res.add(all3-v[0]*2);
    return res ;
  }
  static void findVertex(int xmid[],int ymid[]){
    Vector<Integer>V1=solve(xmid);
    Vector<Integer>V2=solve(ymid);
    for(int i=0 ; i<3 ; i++){
      System.out.println(V1.get(i)+" "+V2.get(i));
    }
  }
  public static void main(String[] args){
    int xmid[]={
      5,4,5 };
      int ymid[]={
        3,4,5 };
        findVertex(xmid,ymid);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( v : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Sequence{} ;
     var all3 : int ; all3 := v[0+1] + v[1+1] + v[2+1] ;
    res := res->including(all3 - v[1+1] * 2) ; 
    res := res->including(all3 - v[2+1] * 2) ; 
    res := res->including(all3 - v[0+1] * 2) ; 
    return res 
 );
  static   operation findVertex( xmid : Sequence(int), ymid : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var V1 : Sequence(int) ; V1 := solve(xmid) ;
     var V2 : Sequence(int) ; V2 := solve(ymid) ;
         var i : int ; i := 0 ; while i < 3 do ( (     OclFile["System.out"].println(V1->at(i+1) + " " + V2->at(i+1)) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var xmid : Sequence(int) ; xmid := Sequence{5,4,5} ;
     var ymid : Sequence(int) ; ymid := Sequence{3,4,5} ;
     execute findVertex(xmid, ymid) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt(),b=sc.nextInt(),x=sc.nextInt();
    String s="10" ;
    int step=1 ;
    a--;
    b--;
    x--;
    while(x>0){
      if(step==1){
        if(b<=0)break ;
        s+="1" ;
        step=2 ;
        b--;
      }
      else if(step==2){
        if(a<=0)break ;
        s+="0" ;
        step=1 ;
        a--;
      }
      x--;
    }
    String ans="" ;
    for(int i=0 ; i<b ; i++){
      ans+="1" ;
    }
    if(x==1){
      ans+="0" ;
      a--;
    }
    if(s.charAt(s.length()-1)=='1'){
      String temp="" ;
      for(int i=0 ; i<s.length()-1 ; i++){
        temp+=s.charAt(i);
      }
      for(int i=0 ; i<a ; i++){
        temp+="0" ;
      }
      temp+="1" ;
      s=temp ;
    }
    else {
      for(int i=0 ; i<a ; i++){
        s+="0" ;
      }
    }
    System.out.println(ans+s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var s : String ; s := "10" ;
    var step : int ; step := 1 ;
    a := a - 1 ; 
    b := b - 1 ; 
    x := x - 1 ; 
    while (x > 0) do (     if (step = 1) then (     if (b <= 0) then     break else skip ; 
     s := s+("1") ; 
     step := 2 ; 
     b := b - 1 ) else     if (step = 2) then (     if (a <= 0) then     break else skip ; 
     s := s+("0") ; 
     step := 1 ; 
     a := a - 1 ) else skip ; ;  
     x := x - 1 ) ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < b do ( (     ans := ans+("1") )  ;     i := i + 1 ) ; 
    if (x = 1) then (     ans := ans+("0") ; 
     a := a - 1 ) else skip ; 
    if (s->at(s->size() - 1+1) = '1') then (     var temp : String ; temp := "" ;
         var i : int ; i := 0 ; while i < s->size() - 1 do ( (     temp := temp+(s->at(i+1)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a do ( (     temp := temp+("0") )  ;     i := i + 1 ) ; 
    temp := temp+("1") ; 
    s := temp ; 
 ) else (         var i : int ; i := 0 ; while i < a do ( (     s := s+("0") )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(ans + s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=Integer.parseInt(s.nextLine());
    String c=s.nextLine();
    String b="" ;
    for(int i=0 ; i<n ; i++){
      if(i==0)b+=c.charAt(i);
      else if(c.charAt(i)=='0')b+=c.charAt(i);
    }
    System.out.println(b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (s.nextLine())->toInteger() ;
    var c : String ; c := s.nextLine() ;
    var b : String ; b := "" ;
        var i : int ; i := 0 ; while i < n do ( (     if (i = 0) then     b := b+(c->at(i+1)) ; else     if (c->at(i+1) = '0') then     b := b+(c->at(i+1)) ; else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt(),b=sc.nextInt(),x=sc.nextInt();
    String s="10" ;
    int step=1 ;
    a--;
    b--;
    x--;
    while(x>0){
      if(step==1){
        if(b<=0)break ;
        s+="1" ;
        step=2 ;
        b--;
      }
      else if(step==2){
        if(a<=0)break ;
        s+="0" ;
        step=1 ;
        a--;
      }
      x--;
    }
    String ans="" ;
    for(int i=0 ; i<b ; i++){
      ans+="1" ;
    }
    if(x==1){
      ans+="0" ;
      a--;
    }
    if(s.charAt(s.length()-1)=='1'){
      String temp="" ;
      for(int i=0 ; i<s.length()-1 ; i++){
        temp+=s.charAt(i);
      }
      for(int i=0 ; i<a ; i++){
        temp+="0" ;
      }
      temp+="1" ;
      s=temp ;
    }
    else {
      for(int i=0 ; i<a ; i++){
        s+="0" ;
      }
    }
    System.out.println(ans+s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var s : String ; s := "10" ;
    var step : int ; step := 1 ;
    a := a - 1 ; 
    b := b - 1 ; 
    x := x - 1 ; 
    while (x > 0) do (     if (step = 1) then (     if (b <= 0) then     break else skip ; 
     s := s+("1") ; 
     step := 2 ; 
     b := b - 1 ) else     if (step = 2) then (     if (a <= 0) then     break else skip ; 
     s := s+("0") ; 
     step := 1 ; 
     a := a - 1 ) else skip ; ;  
     x := x - 1 ) ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < b do ( (     ans := ans+("1") )  ;     i := i + 1 ) ; 
    if (x = 1) then (     ans := ans+("0") ; 
     a := a - 1 ) else skip ; 
    if (s->at(s->size() - 1+1) = '1') then (     var temp : String ; temp := "" ;
         var i : int ; i := 0 ; while i < s->size() - 1 do ( (     temp := temp+(s->at(i+1)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a do ( (     temp := temp+("0") )  ;     i := i + 1 ) ; 
    temp := temp+("1") ; 
    s := temp ; 
 ) else (         var i : int ; i := 0 ; while i < a do ( (     s := s+("0") )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(ans + s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    OutputStreamWriter osr=new OutputStreamWriter(System.out);
    PrintWriter o=new PrintWriter(osr);
    FastReader fr=new FastReader();
    int t=fr.nextInt();
    while(t--!=0){
      int x=fr.nextInt(),y=fr.nextInt(),n=fr.nextInt();
      o.println((((n-y)/x)*x)+y);
    }
    o.close();
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    InputStreamReader isr=new InputStreamReader(System.in);
    br=new BufferedReader(isr);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String nextLine()throws IOException {
    return br.readLine();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public int[] intArray(int size)throws IOException {
    int[] arr=new int[size];
    for(int i=0 ; i<size ; i++)arr[i]=nextInt();
    return arr ;
  }
  public char[] charArray()throws IOException {
    return nextLine().toCharArray();
  }
}
class Pair {
  int x ;
  int y ;
  public Pair(int x,int y){
    this.x=x ;
    this.y=y ;
  }
  static class Compare implements Comparator<Pair>{
    @ Override public int compare(Pair o1,Pair o2){
      return(o1.y-o2.y);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var osr : OclFile ; osr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var o : OclFile ; o := OclFile.newOclFile_Write(osr) ;
    var fr : FastReader ; fr := FastReader.newFastReader() ;
    var t : int ; t := fr.nextInt() ;
        while (t /= 0) do (    skip ; (     var x : int ; x := fr.nextInt() ;
    var y : int ; y := fr.nextInt() ;
    var n : int ; n := fr.nextInt() ;
     skip ) ;  ) ;  
    skip ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     br := OclFile.newOclFile_Read(isr) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation intArray( size : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < size do (     arr[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return arr );
   operation charArray() : Sequence(String)
  pre: true
  post: true
  activity: (     return nextLine()->characters() );
}
class Pair {
   attribute x : int;
   attribute y : int;
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
  static class Compare implements Function(<Map>,(<Map>,boolean)) {
      operation compare( o1 : Map, o2 : Map) : int
  pre: true
  post: true
  activity: (     return (o1.y - o2.y) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt(),b=sc.nextInt(),x=sc.nextInt();
    String s="10" ;
    int step=1 ;
    a--;
    b--;
    x--;
    while(x>0){
      if(step==1){
        if(b<=0)break ;
        s+="1" ;
        step=2 ;
        b--;
      }
      else if(step==2){
        if(a<=0)break ;
        s+="0" ;
        step=1 ;
        a--;
      }
      x--;
    }
    String ans="" ;
    for(int i=0 ; i<b ; i++){
      ans+="1" ;
    }
    if(x==1){
      ans+="0" ;
      a--;
    }
    if(s.charAt(s.length()-1)=='1'){
      String temp="" ;
      for(int i=0 ; i<s.length()-1 ; i++){
        temp+=s.charAt(i);
      }
      for(int i=0 ; i<a ; i++){
        temp+="0" ;
      }
      temp+="1" ;
      s=temp ;
    }
    else {
      for(int i=0 ; i<a ; i++){
        s+="0" ;
      }
    }
    System.out.println(ans+s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var s : String ; s := "10" ;
    var step : int ; step := 1 ;
    a := a - 1 ; 
    b := b - 1 ; 
    x := x - 1 ; 
    while (x > 0) do (     if (step = 1) then (     if (b <= 0) then     break else skip ; 
     s := s+("1") ; 
     step := 2 ; 
     b := b - 1 ) else     if (step = 2) then (     if (a <= 0) then     break else skip ; 
     s := s+("0") ; 
     step := 1 ; 
     a := a - 1 ) else skip ; ;  
     x := x - 1 ) ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < b do ( (     ans := ans+("1") )  ;     i := i + 1 ) ; 
    if (x = 1) then (     ans := ans+("0") ; 
     a := a - 1 ) else skip ; 
    if (s->at(s->size() - 1+1) = '1') then (     var temp : String ; temp := "" ;
         var i : int ; i := 0 ; while i < s->size() - 1 do ( (     temp := temp+(s->at(i+1)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a do ( (     temp := temp+("0") )  ;     i := i + 1 ) ; 
    temp := temp+("1") ; 
    s := temp ; 
 ) else (         var i : int ; i := 0 ; while i < a do ( (     s := s+("0") )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(ans + s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt(),b=sc.nextInt(),x=sc.nextInt();
    String s="10" ;
    int step=1 ;
    a--;
    b--;
    x--;
    while(x>0){
      if(step==1){
        if(b<=0)break ;
        s+="1" ;
        step=2 ;
        b--;
      }
      else if(step==2){
        if(a<=0)break ;
        s+="0" ;
        step=1 ;
        a--;
      }
      x--;
    }
    String ans="" ;
    for(int i=0 ; i<b ; i++){
      ans+="1" ;
    }
    if(x==1){
      ans+="0" ;
      a--;
    }
    if(s.charAt(s.length()-1)=='1'){
      String temp="" ;
      for(int i=0 ; i<s.length()-1 ; i++){
        temp+=s.charAt(i);
      }
      for(int i=0 ; i<a ; i++){
        temp+="0" ;
      }
      temp+="1" ;
      s=temp ;
    }
    else {
      for(int i=0 ; i<a ; i++){
        s+="0" ;
      }
    }
    System.out.println(ans+s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var s : String ; s := "10" ;
    var step : int ; step := 1 ;
    a := a - 1 ; 
    b := b - 1 ; 
    x := x - 1 ; 
    while (x > 0) do (     if (step = 1) then (     if (b <= 0) then     break else skip ; 
     s := s+("1") ; 
     step := 2 ; 
     b := b - 1 ) else     if (step = 2) then (     if (a <= 0) then     break else skip ; 
     s := s+("0") ; 
     step := 1 ; 
     a := a - 1 ) else skip ; ;  
     x := x - 1 ) ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < b do ( (     ans := ans+("1") )  ;     i := i + 1 ) ; 
    if (x = 1) then (     ans := ans+("0") ; 
     a := a - 1 ) else skip ; 
    if (s->at(s->size() - 1+1) = '1') then (     var temp : String ; temp := "" ;
         var i : int ; i := 0 ; while i < s->size() - 1 do ( (     temp := temp+(s->at(i+1)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a do ( (     temp := temp+("0") )  ;     i := i + 1 ) ; 
    temp := temp+("1") ; 
    s := temp ; 
 ) else (         var i : int ; i := 0 ; while i < a do ( (     s := s+("0") )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(ans + s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void countWays(int a[],int n){
    int i,j ;
    long suff[]=new long[n];
    if(a[n-1]==2)suff[n-1]=1 ;
    for(i=n-2 ; i>=0 ; i--){
      if(a[i]==2)suff[i]=suff[i+1]+1 ;
      else suff[i]=suff[i+1];
    }
    long ss=0 ;
    for(i=0 ; i<n ; i++){
      if(a[i]==1)ss+=suff[i];
    }
    for(i=0 ; i<n ; i++){
      for(j=i+1 ; j<n ; j++){
        if(a[i]==1 && a[j]==1 && suff[j]>=2){
          ss+=(suff[j])*(suff[j]-1)/2 ;
        }
      }
    }
    for(i=0 ; i<n ; i++){
      for(j=i+1 ; j<n ; j++){
        if(a[i]==1 && a[j]==1 &&(suff[i]-suff[j])>=1 && suff[j]>=1){
          ss+=(suff[i]-suff[j])*suff[j];
        }
      }
    }
    System.out.println(ss);
  }
  public static void main(String[] args){
    int a[]={
      1,2,1,1,2,2 };
      int n=6 ;
      countWays(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countWays( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var suff : Sequence(long) ; suff := Integer.subrange(1,n)->collect(0) ;
    if (a[n - 1+1] = 2) then     suff[n - 1+1] := 1 ; else skip ; 
        i := n - 2 ; while i >= 0 do ( (     if (a[i+1] = 2) then     suff[i+1] := suff[i + 1+1] + 1 ; else     suff[i+1] := suff[i + 1+1] ; )  ;     i := i - 1 ) ; 
    var ss : long ; ss := 0 ;
        i := 0 ; while i < n do ( (     if (a[i+1] = 1) then     ss := ss+(suff[i+1]) ; else skip )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (         j := i + 1 ; while j < n do ( (     if (a[i+1] = 1 & a[j+1] = 1 & suff[j+1] >= 2) then (     ss := ss+((suff[j+1]) * (suff[j+1] - 1) / 2) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (         j := i + 1 ; while j < n do ( (     if (a[i+1] = 1 & a[j+1] = 1 & (suff[i+1] - suff[j+1]) >= 1 & suff[j+1] >= 1) then (     ss := ss+((suff[i+1] - suff[j+1]) * suff[j+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ss) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,1,1,2,2} ;
     var n : int ; n := 6 ;
     execute countWays(a, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class sol {
  static class Node {
    int data ;
    Node next ;
  };
  static Node newNode(int key){
    Node temp=new Node();
    temp.data=key ;
    temp.next=null ;
    return temp ;
  }
  static Node rearrangeEvenOdd(Node head){
    if(head==null)return null ;
    Node odd=head ;
    Node even=head.next ;
    Node evenFirst=even ;
    while(true){
      if(odd==null || even==null ||(even.next)==null){
        break ;
      }
      odd.next=even.next ;
      odd=even.next ;
      if(odd.next==null){
        even.next=null ;
        break ;
      }
      even.next=odd.next ;
      even=odd.next ;
    }
    Node current=evenFirst ;
    Node prev=null ;
    Node front=null ;
    while(current!=null){
      front=current.next ;
      current.next=prev ;
      prev=current ;
      current=front ;
    }
    evenFirst=prev ;
    odd.next=evenFirst ;
    return head ;
  }
  static void printlist(Node node){
    while(node!=null){
      System.out.print(node.data+"->");
      node=node.next ;
    }
    System.out.println("null");
  }
  public static void main(String args[]){
    Node head=newNode(1);
    head.next=newNode(2);
    head.next.next=newNode(3);
    head.next.next.next=newNode(4);
    head.next.next.next.next=newNode(5);
    head.next.next.next.next.next=newNode(6);
    head=rearrangeEvenOdd(head);
    printlist(head);
  }
}
------------------------------------------------------------
OCL File:
---------
class sol {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   operation newNode( key : int) : Node
  pre: true
  post: true
  activity: (     var temp : Node ; temp := Node.newNode() ;
     temp.data := key ; 
     temp.next := null ; 
     return temp );
  static   operation rearrangeEvenOdd( head : Node) : Node
  pre: true
  post: true
  activity: (     if (head = null) then     return null else skip ; 
     var odd : Node ; odd := head ;
    var even : Node ; even := head.next ;
    var evenFirst : Node ; evenFirst := even ;
    while (true) do (     if (odd = null or even = null or (even.next) = null) then (     break ) else skip ; 
     odd.next := even.next ; 
    odd := even.next ; 
    if (odd.next = null) then (     even.next := null ; 
     break ) else skip ; 
    even.next := odd.next ; 
    even := odd.next ; 
 ) ; 
    var current : Node ; current := evenFirst ;
    var prev : Node ; prev := null ;
    var front : Node ; front := null ;
    while (current /= null) do (     front := current.next ; 
     current.next := prev ; 
     prev := current ; 
     current := front ) ; 
    evenFirst := prev ; 
    odd.next := evenFirst ; 
    return head 
 );
  static   operation printlist( node : Node) : void
  pre: true
  post: true
  activity: (     while (node /= null) do (     OclFile["System.out"].print(node.data + "->") ; 
     node := node.next ) ; 
     OclFile["System.out"].println("null") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := newNode(1) ;
     head.next := newNode(2) ; 
    head.next.next := newNode(3) ; 
    head.next.next.next := newNode(4) ; 
    head.next.next.next.next := newNode(5) ; 
    head.next.next.next.next.next := newNode(6) ; 
    head := rearrangeEvenOdd(head) ; 
    execute printlist(head) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskC solver=new TaskC();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskC {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int a=in.nextInt(),b=in.nextInt(),c=in.nextInt(),d=in.nextInt(),e=in.nextInt(),f=in.nextInt();
      int[] ok=new int[50];
      ok[0]=1 ;
      for(int i=1 ; i<50 ; i++){
        if(i-a>=0)ok[i] |=ok[i-a];
        if(i-b>=0)ok[i] |=ok[i-b];
      }
      int[] ok2=new int[4000];
      ok2[0]=1 ;
      for(int i=1 ; i<4000 ; i++){
        if(i-c>=0)ok2[i] |=ok2[i-c];
        if(i-d>=0)ok2[i] |=ok2[i-d];
      }
      long mw=1,ms=-1 ;
      for(int i=1 ; 100*i<=f && i<50 ; i++){
        for(int j=0 ; 100*i+j<=f && j<4000 ; j++){
          if(j>i*e)continue ;
          if(ok[i]==0)continue ;
          if(ok2[j]==0)continue ;
          if(ms*(100*i+j)<(100*mw+ms)*j){
            mw=i ;
            ms=j ;
          }
        }
      }
      out.println(mw*100+ms+" "+ms);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskC ; solver := TaskC.newTaskC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskC {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var e : int ; e := in.getCurrent()->toInteger() ;
    var f : int ; f := in.getCurrent()->toInteger() ;
     var ok : Sequence(int) ; ok := Integer.subrange(1,50)->collect(0) ;
    ok[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < 50 do ( (     if (i - a >= 0) then     ok[i+1] := MathLib.bitwiseOr(ok[i+1], ok[i - a+1]) ; else skip ; 
     if (i - b >= 0) then     ok[i+1] := MathLib.bitwiseOr(ok[i+1], ok[i - b+1]) ; else skip )  ;     i := i + 1 ) ; 
    var ok2 : Sequence(int) ; ok2 := Integer.subrange(1,4000)->collect(0) ;
    ok2[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < 4000 do ( (     if (i - c >= 0) then     ok2[i+1] := MathLib.bitwiseOr(ok2[i+1], ok2[i - c+1]) ; else skip ; 
     if (i - d >= 0) then     ok2[i+1] := MathLib.bitwiseOr(ok2[i+1], ok2[i - d+1]) ; else skip )  ;     i := i + 1 ) ; 
    var mw : long ; mw := 1 ;
    var ms : long ; ms := -1 ;
        var i : int ; i := 1 ; while 100 * i <= f & i < 50 do ( (         var j : int ; j := 0 ; while 100 * i + j <= f & j < 4000 do ( (     if (j > i * e) then     continue else skip ; 
     if (ok[i+1] = 0) then     continue else skip ; 
     if (ok2[j+1] = 0) then     continue else skip ; 
     if (ms * (100 * i + j) < (100 * mw + ms) * j) then (     mw := i ; 
     ms := j ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    int c=Integer.parseInt(sc.next());
    int d=Integer.parseInt(sc.next());
    int e=Integer.parseInt(sc.next());
    int f=Integer.parseInt(sc.next());
    int water=0 ;
    int sugar=0 ;
    for(int i=0 ; i<=f ; i+=100*a){
      for(int j=0 ; i+j<=f ; j+=100*b){
        for(int k=0 ; i+j+k<=f ; k+=c){
          for(int l=0 ; i+j+k+l<=f ; l+=d){
            if((k+l)*100<=e*(i+j)){
              if((water==0 && sugar==0)|| sugar*(i+j+k+l)<(k+l)*water){
                water=i+j+k+l ;
                sugar=k+l ;
              }
            }
          }
        }
      }
    }
    System.out.println(water+" "+sugar);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := (sc.getCurrent())->toInteger() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    var c : int ; c := (sc.getCurrent())->toInteger() ;
    var d : int ; d := (sc.getCurrent())->toInteger() ;
    var e : int ; e := (sc.getCurrent())->toInteger() ;
    var f : int ; f := (sc.getCurrent())->toInteger() ;
    var water : int ; water := 0 ;
    var sugar : int ; sugar := 0 ;
        var i : int ; i := 0 ; while i <= f do ( (         var j : int ; j := 0 ; while i + j <= f do ( (         var k : int ; k := 0 ; while i + j + k <= f do ( (         var l : int ; l := 0 ; while i + j + k + l <= f do ( (     if ((k + l) * 100 <= e * (i + j)) then (     if ((water = 0 & sugar = 0) or sugar * (i + j + k + l) < (k + l) * water) then (     water := i + j + k + l ; 
     sugar := k + l ) else skip ) else skip )  ;     l := l+(d) ) )  ;     k := k+(c) ) )  ;     j := j+(100 * b) ) )  ;     i := i+(100 * a) ) ; 
    OclFile["System.out"].println(water + " " + sugar) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  static IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static IntStream REPS(int l,int r){
    return IntStream.rangeClosed(l,r);
  }
  static IntStream INS(int n){
    return REPS(n).map(i->getInt());
  }
  static Scanner s=new Scanner(System.in);
  static int getInt(){
    return Integer.parseInt(s.next());
  }
  public static void main(String[] $){
    int a=getInt(),b=getInt(),c=getInt(),d=getInt(),e=getInt(),f=getInt();
    int rw=100*a,rs=0 ;
    double max=0 ;
    for(int i=0 ; true ; ++i){
      int va=100*a*i ;
      if(va>f)break ;
      for(int j=0 ; true ; ++j){
        int vb=100*b*j ;
        if(va+vb>f)break ;
        for(int k=0 ; true ; ++k){
          int vc=c*k ;
          if(va+vb+vc>f)break ;
          for(int l=0 ; true ; ++l){
            int vd=d*l ;
            if(va+vb+vc+vd>f)break ;
            if(max<calc(va+vb,vc+vd,e)){
              max=calc(va+vb,vc+vd,e);
              rw=va+vb ;
              rs=vc+vd ;
            }
          }
        }
      }
    }
    System.out.println(rw+rs+" "+rs);
  }
  private static double calc(int w,int s,int e){
    double r=w==0 ? 0 : 100.0*s/(w+s);
    return w/100*e<s ? 0 : r ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static   operation REPS( l : int, r : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(l, r) );
  static   operation INS( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return REPS(n)->collect( _x1 | (lambda i : OclAny in getInt())->apply(_x1) ) );
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := getInt() ;
    var b : int ; b := getInt() ;
    var c : int ; c := getInt() ;
    var d : int ; d := getInt() ;
    var e : int ; e := getInt() ;
    var f : int ; f := getInt() ;
     var rw : int ; rw := 100 * a ;
    var rs : int ; rs := 0 ;
    var max : double ; max := 0 ;
        var i : int ; i := 0 ; while true do ( (     var va : int ; va := 100 * a * i ;
     if (va > f) then     break else skip ; 
         var j : int ; j := 0 ; while true do ( (     var vb : int ; vb := 100 * b * j ;
     if (va + vb > f) then     break else skip ; 
         var k : int ; k := 0 ; while true do ( (     var vc : int ; vc := c * k ;
     if (va + vb + vc > f) then     break else skip ; 
         var l : int ; l := 0 ; while true do ( (     var vd : int ; vd := d * l ;
     if (va + vb + vc + vd > f) then     break else skip ; 
     if (max < calc(va + vb, vc + vd, e)) then (     max := calc(va + vb, vc + vd, e) ; 
     rw := va + vb ; 
     rs := vc + vd ) else skip )  ;     l := l + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(rw + rs + " " + rs) ; 
 );
  static   operation calc( w : int, s : int, e : int) : double
  pre: true
  post: true
  activity: (     var r : double ; r := if w = 0 then 0 else 100.0 * s / (w + s) endif ;
     return if w / 100 * e < s then 0 else r endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    while(input.hasNext()){
      int A=input.nextInt();
      int B=input.nextInt();
      int C=input.nextInt();
      int D=input.nextInt();
      int E=input.nextInt();
      int F=input.nextInt();
      int maxA=F/(A*100);
      int maxB=F/(B*100);
      int maxC=F/C ;
      int maxD=F/D ;
      int sugarWater=100 ;
      int sugar=0 ;
      double maxDensity=0 ;
      for(int a=0 ; a<=maxA ; ++a){
        for(int b=0 ; b<=maxB ; ++b){
          for(int c=0 ; c<=maxC ; ++c){
            for(int d=0 ; d<=maxD ; ++d){
              int currentWater=(a*A+b*B)*100 ;
              int currentSugar=c*C+d*D ;
              if(currentWater+currentSugar<=F){
                if(currentWater/100*E>=currentSugar){
                  double currentDensity=currentSugar==0 ? 0 : currentSugar/(double)(currentSugar+currentWater);
                  if(currentDensity>=maxDensity){
                    sugar=currentSugar ;
                    sugarWater=sugar+currentWater ;
                    maxDensity=currentDensity ;
                  }
                }
              }
            }
          }
        }
      }
      System.out.println(sugarWater+" "+sugar);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (input.hasNext()) do (     var A : int ; A := input.getCurrent()->toInteger() ;
     var B : int ; B := input.getCurrent()->toInteger() ;
    var C : int ; C := input.getCurrent()->toInteger() ;
    var D : int ; D := input.getCurrent()->toInteger() ;
    var E : int ; E := input.getCurrent()->toInteger() ;
    var F : int ; F := input.getCurrent()->toInteger() ;
    var maxA : int ; maxA := F / (A * 100) ;
    var maxB : int ; maxB := F / (B * 100) ;
    var maxC : int ; maxC := F / C ;
    var maxD : int ; maxD := F / D ;
    var sugarWater : int ; sugarWater := 100 ;
    var sugar : int ; sugar := 0 ;
    var maxDensity : double ; maxDensity := 0 ;
        var a : int ; a := 0 ; while a <= maxA do ( (         var b : int ; b := 0 ; while b <= maxB do ( (         var c : int ; c := 0 ; while c <= maxC do ( (         var d : int ; d := 0 ; while d <= maxD do ( (     var currentWater : int ; currentWater := (a * A + b * B) * 100 ;
     var currentSugar : int ; currentSugar := c * C + d * D ;
     if (currentWater + currentSugar <= F) then (     if (currentWater / 100 * E >= currentSugar) then (     var currentDensity : double ; currentDensity := if currentSugar = 0 then 0 else currentSugar / (currentSugar + currentWater)->oclAsType(double) endif ;
     if (currentDensity >= maxDensity) then (     sugar := currentSugar ; 
     sugarWater := sugar + currentWater ; 
     maxDensity := currentDensity ) else skip ) else skip ) else skip )  ;     d := d + 1 ) )  ;     c := c + 1 ) )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(sugarWater + " " + sugar) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Collections ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    double total=0 ;
    for(int i=0 ; i<N ; i++){
      double money=sc.nextDouble();
      String A=sc.next();
      String B="JPY" ;
      if(A.equals(B)){
        total+=money ;
      }
      else {
        total+=money*380000 ;
      }
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var total : double ; total := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var money : double ; money := sc.getCurrent()->toReal() ;
     var A : String ; A := sc.getCurrent() ;
     var B : String ; B := "JPY" ;
     if (A = B) then (     total := total+(money) ) else (     total := total+(money * 380000) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in);
){
      new Main().solve(sc);
    }
  }
  void solve(Scanner sc){
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    int e=sc.nextInt();
    int f=sc.nextInt();
    int waterX=0 ;
    int ansWater=100 ;
    int ansSugar=0 ;
    while(100*a*waterX<=f){
      int waterY=0 ;
      while(100*a*waterX+100*b*waterY<=f){
        int water=100*a*waterX+100*b*waterY ;
        int sugarX=0 ;
        while(water+c*sugarX<=f){
          int sugarY=0 ;
          while(water+c*sugarX+d*sugarY<=f){
            int sugar=c*sugarX+d*sugarY ;
            if(sugar*(100+e)<=e*(water+sugar)){
              if(sugar*(ansWater+ansSugar)>=ansSugar*(water+sugar)){
                ansWater=water ;
                ansSugar=sugar ;
              }
            }
            sugarY++;
          }
          sugarX++;
        }
        waterY++;
      }
      waterX++;
    }
    System.out.println(ansWater+ansSugar+" "+ansSugar);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     Main.newMain().solve(sc) ))  );
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var e : int ; e := sc.getCurrent()->toInteger() ;
    var f : int ; f := sc.getCurrent()->toInteger() ;
    var waterX : int ; waterX := 0 ;
    var ansWater : int ; ansWater := 100 ;
    var ansSugar : int ; ansSugar := 0 ;
    while (100 * a * waterX <= f) do (     var waterY : int ; waterY := 0 ;
     while (100 * a * waterX + 100 * b * waterY <= f) do (     var water : int ; water := 100 * a * waterX + 100 * b * waterY ;
     var sugarX : int ; sugarX := 0 ;
     while (water + c * sugarX <= f) do (     var sugarY : int ; sugarY := 0 ;
     while (water + c * sugarX + d * sugarY <= f) do (     var sugar : int ; sugar := c * sugarX + d * sugarY ;
     if (sugar * (100 + e) <= e * (water + sugar)) then (     if (sugar * (ansWater + ansSugar) >= ansSugar * (water + sugar)) then (     ansWater := water ; 
     ansSugar := sugar ) else skip ) else skip ; 
     sugarY := sugarY + 1 ) ; 
     sugarX := sugarX + 1 ) ; 
     waterY := waterY + 1 ) ; 
     waterX := waterX + 1 ) ; 
    OclFile["System.out"].println(ansWater + ansSugar + " " + ansSugar) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int a=scan.nextInt();
    int b=scan.nextInt();
    int c=scan.nextInt();
    if((b-a)==(c-b)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    var c : int ; c := scan.getCurrent()->toInteger() ;
    if ((b - a) = (c - b)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_Required_Remainder {
  public static void main(String[] args){
    Scanner sn=new Scanner(System.in);
    int t=sn.nextInt();
    while(t-->0){
      int x=sn.nextInt();
      int y=sn.nextInt();
      int n=sn.nextInt();
      if(n-n % x+y<=n){
        System.out.println(n-n % x+y);
      }
      else {
        System.out.println(n-n % x-(x-y));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Required_Remainder {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sn : OclFile ; sn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sn.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x : int ; x := sn.getCurrent()->toInteger() ;
     var y : int ; y := sn.getCurrent()->toInteger() ;
     var n : int ; n := sn.getCurrent()->toInteger() ;
     if (n - n mod x + y <= n) then (     OclFile["System.out"].println(n - n mod x + y) ) else (     OclFile["System.out"].println(n - n mod x - (x - y)) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    MyScanner in=new MyScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ABC058A solver=new ABC058A();
    solver.solve(1,in,out);
    out.close();
  }
  static class ABC058A {
    public void solve(int testNumber,MyScanner in,PrintWriter out){
      int a=in.Int();
      int b=in.Int();
      int c=in.Int();
      out.println(b-a==c-b ? "YES" : "NO");
    }
  }
  static class MyScanner {
    private BufferedReader in ;
    private StringTokenizer st ;
    public MyScanner(InputStream stream){
      in=new BufferedReader(new InputStreamReader(stream));
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          String rl=in.readLine();
          if(rl==null){
            return null ;
          }
          st=new StringTokenizer(rl);
        }
        catch(IOException e){
          return null ;
        }
      }
      return st.nextToken();
    }
    public int Int(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : MyScanner ; in := MyScanner.newMyScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ABC058A ; solver := ABC058A.newABC058A() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ABC058A {
   operation solve( testNumber : int, in : MyScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.Int() ;
     var b : int ; b := in.Int() ;
     var c : int ; c := in.Int() ;
     skip );
}
  static class MyScanner {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner( stream : OclFile) : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     var rl : String ; rl := in.readLine() ;
     if (rl = null) then (     return null ) else skip ; 
     st := OclIterator.newOclIterator_String(rl) )   catch (e : IOException) do (     return null )
 ) ; 
     return st.next() );
   operation Int() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  void solve(){
    int a=inint(),b=inint(),c=inint();
    if(c-b==b-a || a-b==b-c)out.println("YES");
    else out.println("NO");
  }
  public static Scanner in=new Scanner(System.in);
  public static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    new Main().solve();
    out.flush();
  }
  public int inint(){
    return in.nextInt();
  }
  public long inlong(){
    return in.nextLong();
  }
  public String instr(){
    return in.next();
  }
  public char inchar(){
    return in.next().charAt(0);
  }
  public int[] inintar(int num){
    int[] a=new int[num];
    for(int i=0 ; i<num ; i++){
      a[i]=in.nextInt();
    }
    return a ;
  }
  public char[] incharar(){
    return in.next().toCharArray();
  }
  public char[][] incharmap(int h,int w){
    char[][] a=new char[h][w];
    for(int i=0 ; i<h ; i++){
      String temp=in.next();
      for(int j=0 ; j<w ; j++){
        a[i][j]=temp.charAt(j);
      }
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ; a := inint() ;
    var b : int ; b := inint() ;
    var c : int ; c := inint() ;
     if (c - b = b - a or a - b = b - c) then     out.println("YES") ; else     out.println("NO") ; );
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() ; 
     skip );
   operation inint() : int
  pre: true
  post: true
  activity: (     return in.getCurrent()->toInteger() );
   operation inlong() : long
  pre: true
  post: true
  activity: (     return in.getCurrent()->toLong() );
   operation instr() : String
  pre: true
  post: true
  activity: (     return in.getCurrent() );
   operation inchar() : String
  pre: true
  post: true
  activity: (     return in.getCurrent()->at(0+1) );
   operation inintar( num : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,num)->collect(0) ;
         var i : int ; i := 0 ; while i < num do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return a );
   operation incharar() : Sequence(String)
  pre: true
  post: true
  activity: (     return in.getCurrent()->characters() );
   operation incharmap( h : int, w : int) : Sequence(Sequence(String))
  pre: true
  post: true
  activity: (     var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
         var i : int ; i := 0 ; while i < h do ( (     var temp : String ; temp := in.getCurrent() ;
         var j : int ; j := 0 ; while j < w do ( (     a[i+1][j+1] := temp->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String[] str=in.readLine().split(" ");
    int a=Integer.parseInt(str[0]);
    int b=Integer.parseInt(str[1]);
    int c=Integer.parseInt(str[2]);
    System.out.println(b-a==c-b ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := in.readLine()->split(" ") ;
    var a : int ; a := (str[0+1])->toInteger() ;
    var b : int ; b := (str[1+1])->toInteger() ;
    var c : int ; c := (str[2+1])->toInteger() ;
    OclFile["System.out"].println(if b - a = c - b then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  static String getEra(int ymd){
    if(ymd<18680908){
      return "pre-meiji" ;
    }
    else if(ymd<19120730){
      return "meiji" ;
    }
    else if(ymd<19261225){
      return "taisho" ;
    }
    else if(ymd<19890108){
      return "showa" ;
    }
    else {
      return "heisei" ;
    }
  }
  static int getYear(String s,int y){
    int base=0 ;
    if(s.equals("meiji")){
      base=1868 ;
    }
    else if(s.equals("taisho")){
      base=1912 ;
    }
    else if(s.equals("showa")){
      base=1926 ;
    }
    else if(s.equals("heisei")){
      base=1989 ;
    }
    return y-base+1 ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine())!=null){
      String[] input=line.split(" ");
      int year=Integer.parseInt(input[0]);
      int month=Integer.parseInt(input[1]);
      int day=Integer.parseInt(input[2]);
      StringBuilder value=new StringBuilder();
      value.append(year);
      if(month<10)value.append(0);
      value.append(month);
      if(day<10)value.append(0);
      value.append(day);
      String eraName=getEra(Integer.parseInt(value.toString()));
      if(eraName.equals("pre-meiji")){
        System.out.println(eraName);
      }
      else {
        int yearX=getYear(eraName,year);
        System.out.printf("%s %d %d %d%n",eraName,yearX,month,day);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation getEra( ymd : int) : String
  pre: true
  post: true
  activity: (     if (ymd < 18680908) then (     return "pre-meiji" ) else     if (ymd < 19120730) then (     return "meiji" ) else     if (ymd < 19261225) then (     return "taisho" ) else     if (ymd < 19890108) then (     return "showa" ) else (     return "heisei" ) ;  ;  ;  );
  static   operation getYear( s : String, y : int) : int
  pre: true
  post: true
  activity: (     var base : int ; base := 0 ;
     if (s = "meiji") then (     base := 1868 ) else     if (s = "taisho") then (     base := 1912 ) else     if (s = "showa") then (     base := 1926 ) else     if (s = "heisei") then (     base := 1989 ) else skip ; ;  ;  ;  
     return y - base + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     var input : Sequence(String) ; input := line->split(" ") ;
     var year : int ; year := (input[0+1])->toInteger() ;
    var month : int ; month := (input[1+1])->toInteger() ;
    var day : int ; day := (input[2+1])->toInteger() ;
    var value : String ; value := StringLib.newString() ;
    value := value + StringLib.newString(year) ; 
    if (month < 10) then     value := value + StringLib.newString(0) ; else skip ; 
    value := value + StringLib.newString(month) ; 
    if (day < 10) then     value := value + StringLib.newString(0) ; else skip ; 
    value := value + StringLib.newString(day) ; 
    var eraName : String ; eraName := getEra((value+"")->toInteger()) ;
    if (eraName = "pre-meiji") then (     OclFile["System.out"].println(eraName) ) else (     var yearX : int ; yearX := getYear(eraName, year) ;
     OclFile["System.out"].printf("%s %d %d %d%n", eraName, yearX, month, day) ) ;  
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int y,m,d ;
    while(sc.hasNext()){
      y=sc.nextInt();
      m=sc.nextInt();
      d=sc.nextInt();
      if(1990<y)System.out.printf("heisei %d %d %d\n",y-1988,m,d);
      else if(y==1989 && 1<m)System.out.printf("heisei 1 %d %d\n",m,d);
      else if(y==1989 && m==1 && 7<d)System.out.printf("heisei 1 %d %d\n",m,d);
      else if(1927<y)System.out.printf("showa %d %d %d\n",y-1925,m,d);
      else if(y==1926 && m==12 && 24<d)System.out.printf("showa 1 %d %d\n",m,d);
      else if(1913<y)System.out.printf("taisho %d %d %d\n",y-1911,m,d);
      else if(y==1912 && 7<m)System.out.printf("taisho 1 %d %d\n",m,d);
      else if(y==1912 && m==7 && 29<d)System.out.printf("taisho 1 %d %d\n",m,d);
      else if(1869<y)System.out.printf("meiji %d %d %d\n",y-1867,m,d);
      else if(y==1868 && 9<m)System.out.printf("meiji 1 %d %d\n",m,d);
      else if(y==1868 && m==9 && 7<d)System.out.printf("meiji 1 %d %d\n",m,d);
      else System.out.printf("pre-meiji\n");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var y : int ;
    var m : int ;
    var d : int ;
     while (sc.hasNext()) do (     y := sc.getCurrent()->toInteger() ; 
     m := sc.getCurrent()->toInteger() ; 
     d := sc.getCurrent()->toInteger() ; 
     if (1990 < y) then     OclFile["System.out"].printf("heisei %d %d %d\n", y - 1988, m, d) ; else     if (y = 1989 & 1 < m) then     OclFile["System.out"].printf("heisei 1 %d %d\n", m, d) else     if (y = 1989 & m = 1 & 7 < d) then     OclFile["System.out"].printf("heisei 1 %d %d\n", m, d) else     if (1927 < y) then     OclFile["System.out"].printf("showa %d %d %d\n", y - 1925, m, d) else     if (y = 1926 & m = 12 & 24 < d) then     OclFile["System.out"].printf("showa 1 %d %d\n", m, d) else     if (1913 < y) then     OclFile["System.out"].printf("taisho %d %d %d\n", y - 1911, m, d) else     if (y = 1912 & 7 < m) then     OclFile["System.out"].printf("taisho 1 %d %d\n", m, d) else     if (y = 1912 & m = 7 & 29 < d) then     OclFile["System.out"].printf("taisho 1 %d %d\n", m, d) else     if (1869 < y) then     OclFile["System.out"].printf("meiji %d %d %d\n", y - 1867, m, d) else     if (y = 1868 & 9 < m) then     OclFile["System.out"].printf("meiji 1 %d %d\n", m, d) else     if (y = 1868 & m = 9 & 7 < d) then     OclFile["System.out"].printf("meiji 1 %d %d\n", m, d) else     OclFile["System.out"].printf("pre-meiji\n") ; ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Date implements Comparable<Date>{
  final int year ;
  final int month ;
  final int day ;
  Date(final int year,final int month,final int day){
    this.year=year ;
    this.month=month ;
    this.day=day ;
  }
  public int compareTo(Date d){
    if(year!=d.year){
      return Double.compare(year,d.year);
    }
    else if(month!=d.month){
      return Double.compare(month,d.month);
    }
    else {
      return Double.compare(day,d.day);
    }
  }
}
class Main {
  public static void main(String[] args){
    final Scanner stdin=new Scanner(System.in);
    final Date[] change={
      new Date(1868,9,8),new Date(1912,7,30),new Date(1926,12,25),new Date(1989,1,8)};
      final String[] name={
        "pre-meiji","meiji","taisho","showa","heisei" };
        while(stdin.hasNextInt()){
          final int year=stdin.nextInt();
          final int month=stdin.nextInt();
          final int day=stdin.nextInt();
          final Date date=new Date(year,month,day);
          int index=0 ;
          while(index<change.length && date.compareTo(change[index])>=0){
            index++;
          }
          if(index==0){
            System.out.println("pre-meiji");
          }
          else {
            final int yearNengo=date.year-change[index-1] .year+1 ;
            System.out.printf("%s %d %d %d\n",name[index],yearNengo,month,day);
          }
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Date implements Comparable<OclDate> {
   attribute year : int;
   attribute month : int;
   attribute day : int;
   static operation newDate( year : int, month : int, day : int) : Date
  pre: true
  post: true
  activity:
  ( var self : Date ;
    self := createDate();
    self.initialise(year, month,day);
    return self );
  operation initialise( year : int, month : int, day : int) : void
  pre: true  post: true
  activity: (     self.year := year ; 
     self.month := month ; 
     self.day := day );
   operation compareTo( d : OclDate) : int
  pre: true
  post: true
  activity: (     if (year /= d.year) then (     return (year)->compareTo(d.year) ) else     if (month /= d.month) then (     return (month)->compareTo(d.month) ) else (     return (day)->compareTo(d.day) ) ;  );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var change : Sequence(OclDate) ; change := Sequence{OclDate.newOclDate(1868, 9, 8),OclDate.newOclDate(1912, 7, 30),OclDate.newOclDate(1926, 12, 25),OclDate.newOclDate(1989, 1, 8)} ;
     var name : Sequence(String) ; name := Sequence{"pre-meiji","meiji","taisho","showa","heisei"} ;
     while (stdin.hasNextInt()) do (     var year : int ; year := stdin.getCurrent()->toInteger() ;
     var month : int ; month := stdin.getCurrent()->toInteger() ;
    var day : int ; day := stdin.getCurrent()->toInteger() ;
    var date : OclDate ; date := OclDate.newOclDate(year, month, day) ;
    var index : int ; index := 0 ;
    while (index < change->size() & date.compareTo(change[index+1]) >= 0) do (     index := index + 1 ) ; 
    if (index = 0) then (     OclFile["System.out"].println("pre-meiji") ) else (     var yearNengo : int ; yearNengo := date.year - change[index - 1+1].year + 1 ;
     OclFile["System.out"].printf("%s %d %d %d\n", name[index+1], yearNengo, month, day) ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  private static final String JPY="JPY" ;
  private static final BigDecimal RATE=BigDecimal.valueOf(380000L);
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      System.out.println(IntStream.range(0,n).mapToObj(i->{
        String x=scanner.next(),u=scanner.next();
        return(JPY.equals(u))? new BigDecimal(x):(new BigDecimal(x)).multiply(RATE);
      }
).reduce(BigDecimal.ZERO,BigDecimal :: add));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute JPY : String := "JPY";
  static    attribute RATE : double := (380000L + "")->toReal();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(Integer.subrange(0, n-1).mapToObj(lambda i : OclAny in (     var x : String ; x := scanner.getCurrent() ;
    var u : String ; u := scanner.getCurrent() ;
     return if (JPY = u) then double(x) else (double(x)).multiply(RATE) endif ))->iterate( _var; _acc : OclAny | 0.0, lambda _pars : OclAny in BigDecimal.newBigDecimal().add(_pars)->apply((_acc,_var)) )) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int y,m,d ;
    for(; sc.hasNext(); ){
      y=sc.nextInt();
      m=sc.nextInt();
      d=sc.nextInt();
      if(y<1868)out.println("pre-meiji");
      else if(y==1868 && m<9)out.println("pre-meiji");
      else if(y==1868 && m==9 && d<8)out.println("pre-meiji");
      else if(y<1912)out.printf("meiji %d %d %d%n",y-1867,m,d);
      else if(y==1912 && m<7)out.printf("meiji %d %d %d%n",y-1867,m,d);
      else if(y==1912 && m==7 && d<30)out.printf("meiji %d %d %d%n",y-1867,m,d);
      else if(y<1926)out.printf("taisho %d %d %d%n",y-1911,m,d);
      else if(y==1926 && m<12)out.printf("taisho %d %d %d%n",y-1911,m,d);
      else if(y==1926 && m==12 && d<25)out.printf("taisho %d %d %d%n",y-1911,m,d);
      else if(y<1989)out.printf("showa %d %d %d%n",y-1925,m,d);
      else if(y==1989 && m<1)out.printf("showa %d %d %d%n",y-1925,m,d);
      else if(y==1989 && m==1 && d<8)out.printf("showa %d %d %d%n",y-1925,m,d);
      else out.printf("heisei %d %d %d%n",y-1988,m,d);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var y : int ;
    var m : int ;
    var d : int ;
       while sc.hasNext() do ( (     y := sc.nextInt() ; 
     m := sc.nextInt() ; 
     d := sc.nextInt() ; 
     if (y < 1868) then     out.println("pre-meiji") ; else     if (y = 1868 & m < 9) then     out.println("pre-meiji") else     if (y = 1868 & m = 9 & d < 8) then     out.println("pre-meiji") else     if (y < 1912) then     out.printf("meiji %d %d %d%n", y - 1867, m, d) else     if (y = 1912 & m < 7) then     out.printf("meiji %d %d %d%n", y - 1867, m, d) else     if (y = 1912 & m = 7 & d < 30) then     out.printf("meiji %d %d %d%n", y - 1867, m, d) else     if (y < 1926) then     out.printf("taisho %d %d %d%n", y - 1911, m, d) else     if (y = 1926 & m < 12) then     out.printf("taisho %d %d %d%n", y - 1911, m, d) else     if (y = 1926 & m = 12 & d < 25) then     out.printf("taisho %d %d %d%n", y - 1911, m, d) else     if (y < 1989) then     out.printf("showa %d %d %d%n", y - 1925, m, d) else     if (y = 1989 & m < 1) then     out.printf("showa %d %d %d%n", y - 1925, m, d) else     if (y = 1989 & m = 1 & d < 8) then     out.printf("showa %d %d %d%n", y - 1925, m, d) else     out.printf("heisei %d %d %d%n", y - 1988, m, d) ; ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  ;  )  ) ; 
     sc.close() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.text.Format ;
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    String meiji="1868.09.08" ;
    String taisho="1912.07.30" ;
    String showa="1926.12.25" ;
    String heisei="1989.01.08" ;
    for(; sc.hasNextInt(); ){
      int y=sc.nextInt();
      int m=sc.nextInt();
      int d=sc.nextInt();
      if(y<1000){
        System.out.println("pre-meiji");
        continue ;
      }
      String f=y+"."+(m<10 ? "0" : "")+m+"."+(d<10 ? "0" : "")+d ;
      String nengo="" ;
      int year=0 ;
      if(y>=10000 || f.compareTo(heisei)>=0){
        nengo="heisei" ;
        year=1+y-Integer.valueOf(heisei.substring(0,4));
      }
      else if(f.compareTo(showa)>=0){
        nengo="showa" ;
        year=1+y-Integer.valueOf(showa.substring(0,4));
      }
      else if(f.compareTo(taisho)>=0){
        nengo="taisho" ;
        year=1+y-Integer.valueOf(taisho.substring(0,4));
      }
      else if(f.compareTo(meiji)>=0){
        nengo="meiji" ;
        year=1+y-Integer.valueOf(meiji.substring(0,4));
      }
      else {
        System.out.println("pre-meiji");
        continue ;
      }
      System.out.println(nengo+" "+year+" "+m+" "+d);
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var meiji : String ; meiji := "1868.09.08" ;
     var taisho : String ; taisho := "1912.07.30" ;
    var showa : String ; showa := "1926.12.25" ;
    var heisei : String ; heisei := "1989.01.08" ;
      while sc.hasNextInt() do ( (     var y : int ; y := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    if (y < 1000) then (     OclFile["System.out"].println("pre-meiji") ; 
     continue ) else skip ; 
    var f : String ; f := y + "." + (if m < 10 then "0" else "" endif) + m + "." + (if d < 10 then "0" else "" endif) + d ;
    var nengo : String ; nengo := "" ;
    var year : int ; year := 0 ;
    if (y >= 10000 or f->compareTo(heisei) >= 0) then (     nengo := "heisei" ; 
     year := 1 + y - (heisei.subrange(0+1,4))->toInteger() ) else     if (f->compareTo(showa) >= 0) then (     nengo := "showa" ; 
     year := 1 + y - (showa.subrange(0+1,4))->toInteger() ) else     if (f->compareTo(taisho) >= 0) then (     nengo := "taisho" ; 
     year := 1 + y - (taisho.subrange(0+1,4))->toInteger() ) else     if (f->compareTo(meiji) >= 0) then (     nengo := "meiji" ; 
     year := 1 + y - (meiji.subrange(0+1,4))->toInteger() ) else (     OclFile["System.out"].println("pre-meiji") ; 
     continue ) ;  ;  ;  ;  
    OclFile["System.out"].println(nengo + " " + year + " " + m + " " + d) ; 
 )  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int M=100 ;
  static int memo[][]=new int[M][M];
  static int numberOfPermWithKInversion(int N,int K){
    if(N==0)return 0 ;
    if(K==0)return 1 ;
    if(memo[N][K]!=0)return memo[N][K];
    int sum=0 ;
    for(int i=0 ; i<=K ; i++){
      if(i<=N-1)sum+=numberOfPermWithKInversion(N-1,K-i);
    }
    memo[N][K]=sum ;
    return sum ;
  }
  public static void main(String[] args){
    int N=4 ;
    int K=2 ;
    System.out.println(numberOfPermWithKInversion(N,K));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute M : int := 100;
  static   attribute memo : int := Integer.subrange(1,M)->collect(Integer.subrange(1,M)->collect(0));
  static   operation numberOfPermWithKInversion( N : int, K : int) : int
  pre: true
  post: true
  activity: (     if (N = 0) then     return 0 else skip ; 
     if (K = 0) then     return 1 else skip ; 
    if (memo[N+1][K+1] /= 0) then     return memo[N+1][K+1] else skip ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i <= K do ( (     if (i <= N - 1) then     sum := sum+(numberOfPermWithKInversion(N - 1, K - i)) ; else skip )  ;     i := i + 1 ) ; 
    memo[N+1][K+1] := sum ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     var K : int ; K := 2 ;
     OclFile["System.out"].println(numberOfPermWithKInversion(N, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewClass3 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int a=in.nextInt();
      int b=in.nextInt();
      int c=in.nextInt();
      int r=c/a ;
      int e=c % a ;
      if(e>=b){
        System.out.println(r*a+b);
      }
      else System.out.println((r-1)*a+b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var r : int ; r := c / a ;
    var e : int ; e := c mod a ;
    if (e >= b) then (     OclFile["System.out"].println(r * a + b) ) else     OclFile["System.out"].println((r - 1) * a + b) ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Arraysum {
  static void pairwiseSum(int arr[],int n){
    int sum=0 ;
    for(int i=0 ; i+1<n ; i++){
      sum=arr[i]+arr[i+1];
      System.out.print(sum+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      4,10,15,5,6 };
      int n=arr.length ;
      pairwiseSum(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class Arraysum {
  static   operation pairwiseSum( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i + 1 < n do ( (     sum := arr[i+1] + arr[i + 1+1] ; 
     OclFile["System.out"].print(sum + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,10,15,5,6} ;
     var n : int ; n := arr->size() ;
     execute pairwiseSum(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Lawnmower {
  public static void main(String...args){
    Scanner sc=new Scanner(System.in);
    int tests=sc.nextInt();
    for(int test=1 ; test<=tests ; ++test){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int[][] lawn=new int[n][m];
      int[] rowMaxes=new int[n];
      int[] colMaxes=new int[m];
      boolean possible=true ;
      for(int i=0 ; i<n ; ++i){
        for(int j=0 ; j<m ; ++j){
          int a=sc.nextInt();
          lawn[i][j]=a ;
          rowMaxes[i]=Math.max(a,rowMaxes[i]);
          colMaxes[j]=Math.max(a,colMaxes[j]);
          if(a>100){
            possible=false ;
          }
        }
      }
      for(int i=0 ; i<n & possible ; ++i){
        for(int j=0 ; j<m & possible ; ++j){
          if(lawn[i][j]<rowMaxes[i] && lawn[i][j]<colMaxes[j]){
            possible=false ;
          }
        }
      }
      System.out.println("Case #"+test+": "+(possible ? "YES" : "NO"));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Lawnmower {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tests : int ; tests := sc.getCurrent()->toInteger() ;
         var test : int ; test := 1 ; while test <= tests do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var lawn : Sequence(Sequence(int)) ; lawn := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var rowMaxes : Sequence(int) ; rowMaxes := Integer.subrange(1,n)->collect(0) ;
    var colMaxes : Sequence(int) ; colMaxes := Integer.subrange(1,m)->collect(0) ;
    var possible : boolean ; possible := true ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     lawn[i+1][j+1] := a ; 
    rowMaxes[i+1] := Set{a, rowMaxes[i+1]}->max() ; 
    colMaxes[j+1] := Set{a, colMaxes[j+1]}->max() ; 
    if (a > 100) then (     possible := false ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n & possible do ( (         var j : int ; j := 0 ; while j < m & possible do ( (     if (lawn[i+1][j+1] < rowMaxes[i+1] & lawn[i+1][j+1] < colMaxes[j+1]) then (     possible := false ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Case #" + test + ": " + (if possible then "YES" else "NO" endif)) ; 
 )  ;     test := test + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileInputStream ;
import java.io.FileOutputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Lawnmower {
  public static boolean check(int[][] map,int N,int M){
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<M ; j++){
        boolean flag=true,flag2=true ;
        for(int k=0 ; k<N ; k++){
          if(map[k][j]>map[i][j]){
            flag=false ;
            break ;
          }
        }
        for(int k=0 ; k<M ; k++){
          if(map[i][k]>map[i][j]){
            flag2=false ;
            break ;
          }
        }
        if(! flag && ! flag2)return false ;
      }
    }
    return true ;
  }
  public static void main(String args[])throws Exception {
    Scanner in=new Scanner(new FileInputStream("B-large.in"));
    PrintWriter writer=new PrintWriter(new FileOutputStream("B-large.out"));
    int T=in.nextInt();
    for(int i=0 ; i<T ; i++){
      int N=in.nextInt();
      int M=in.nextInt();
      int[][] map=new int[N][M];
      for(int j=0 ; j<N ; j++){
        for(int k=0 ; k<M ; k++){
          map[j][k]=in.nextInt();
        }
      }
      boolean result=check(map,N,M);
      writer.write("Case #"+(i+1)+": ");
      writer.println(result ? "YES" : "NO");
    }
    in.close();
    writer.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Lawnmower {
  static   operation check( map : Sequence(Sequence(int)), N : int, M : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < M do ( (     var flag : boolean ; flag := true ;
    var flag2 : boolean ; flag2 := true ;
         var k : int ; k := 0 ; while k < N do ( (     if (map[k+1][j+1] > map[i+1][j+1]) then (     flag := false ; 
     break ) else skip )  ;     k := k + 1 ) ; 
         var k : int ; k := 0 ; while k < M do ( (     if (map[i+1][k+1] > map[i+1][j+1]) then (     flag2 := false ; 
     break ) else skip )  ;     k := k + 1 ) ; 
     if (not(flag) & not(flag2)) then     return false else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("B-large.in"))) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("B-large.out"))) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var M : int ; M := in.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,N)->collect(Integer.subrange(1,M)->collect(0)) ;
        var j : int ; j := 0 ; while j < N do ( (         var k : int ; k := 0 ; while k < M do ( (     map[j+1][k+1] := in.getCurrent()->toInteger() )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    var result : boolean ; result := check(map, N, M) ;
    skip ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class ProblemB {
  static final String YES="YES" ;
  static final String NO="NO" ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int T=in.nextInt();
    for(int cn=1 ; cn<=T ; cn++){
      int N=in.nextInt();
      int M=in.nextInt();
      int[][] a=new int[N][M];
      for(int i=0 ; i<N ; i++){
        for(int j=0 ; j<M ; j++){
          a[i][j]=in.nextInt();
        }
      }
      out.println(String.format("Case #%d: %s",cn,(solve(a)? YES : NO)));
    }
    out.flush();
  }
  private static boolean solve(int[][] board){
    int N=board.length ;
    int M=board[0] .length ;
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<M ; j++){
        int a=board[i][j];
        int rmax=0,cmax=0 ;
        for(int x=0 ; x<M ; x++){
          if(x!=j){
            rmax=Math.max(rmax,board[i][x]);
          }
        }
        for(int y=0 ; y<N ; y++){
          if(y!=i){
            cmax=Math.max(cmax,board[y][j]);
          }
        }
        if(rmax>a && cmax>a){
          return false ;
        }
      }
    }
    return true ;
  }
  public static void debug(Object...o){
    System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static    attribute YES : String := "YES";
  static    attribute NO : String := "NO";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var cn : int ; cn := 1 ; while cn <= T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var M : int ; M := in.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,N)->collect(Integer.subrange(1,M)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < M do ( (     a[i+1][j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     cn := cn + 1 ) ; 
    skip ; 
 );
  static   operation solve( board : Sequence(Sequence(int))) : boolean
  pre: true
  post: true
  activity: (     var N : int ; N := board->size() ;
     var M : int ; M := board[0+1]->size() ;
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < M do ( (     var a : int ; a := board[i+1][j+1] ;
     var rmax : int ; rmax := 0 ;
    var cmax : int ; cmax := 0 ;
        var x : int ; x := 0 ; while x < M do ( (     if (x /= j) then (     rmax := Set{rmax, board[i+1][x+1]}->max() ) else skip )  ;     x := x + 1 ) ; 
        var y : int ; y := 0 ; while y < N do ( (     if (y /= i) then (     cmax := Set{cmax, board[y+1][j+1]}->max() ) else skip )  ;     y := y + 1 ) ; 
    if (rmax > a & cmax > a) then (     return false ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return true );
  static   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner();
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    double ans=0 ;
    while(n-->0){
      double x=sc.nextDouble();
      ans+=sc.next().equals("BTC")? x*380000.0 : x ;
    }
    out.println(ans);
    out.close();
  }
  static class Scanner {
    BufferedReader br ;
    StringTokenizer st ;
    Scanner(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    Scanner(String fileName)throws FileNotFoundException {
      br=new BufferedReader(new FileReader(fileName));
    }
    String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    String nextLine()throws IOException {
      return br.readLine();
    }
    int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    long nextLong()throws NumberFormatException,IOException {
      return Long.parseLong(next());
    }
    double nextDouble()throws NumberFormatException,IOException {
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := (arguments ( )) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : double ; ans := 0 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var x : double ; x := sc.getCurrent()->toReal() ;
     ans := ans+(if sc.getCurrent() = "BTC" then x * 380000.0 else x endif) ) ;  ) ;  
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newScanner() : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   static operation newScanner( fileName : String) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(fileName);
    return self );
  operation initialise( fileName : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(fileName)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.File ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.util.StringTokenizer ;
public class Lawnmower {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new FileReader(new File("in")));
    BufferedWriter bw=new BufferedWriter(new FileWriter(new File("out")));
    StringTokenizer st ;
    int T=Integer.parseInt(br.readLine());
    for(int cn=1 ; cn<=T ; cn++){
      st=new StringTokenizer(br.readLine());
      int N=Integer.parseInt(st.nextToken());
      int M=Integer.parseInt(st.nextToken());
      int arr[][]=new int[N][M];
      for(int i=0 ; i<N ; i++){
        st=new StringTokenizer(br.readLine());
        for(int j=0 ; j<M ; j++){
          arr[i][j]=Integer.parseInt(st.nextToken());
        }
      }
      boolean okay=true ;
      for(int i=0 ; i<N ; i++){
        for(int j=0 ; j<M ; j++){
          int h=arr[i][j];
          boolean ok1=true ;
          for(int k=0 ; k<N ; k++)ok1 &=arr[k][j]<=h ;
          boolean ok2=true ;
          for(int k=0 ; k<M ; k++)ok2 &=arr[i][k]<=h ;
          if(!(ok1 || ok2))okay=false ;
        }
      }
      if(okay)bw.append("Case #"+cn+": YES\n");
      else bw.append("Case #"+cn+": NO\n");
    }
    bw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Lawnmower {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile("in"))) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile("out"))) ;
    var st : OclIterator ;
    var T : int ; T := (br.readLine())->toInteger() ;
        var cn : int ; cn := 1 ; while cn <= T do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var N : int ; N := (st.next())->toInteger() ;
    var M : int ; M := (st.next())->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,N)->collect(Integer.subrange(1,M)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
         var j : int ; j := 0 ; while j < M do ( (     arr[i+1][j+1] := (st.next())->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var okay : boolean ; okay := true ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < M do ( (     var h : int ; h := arr[i+1][j+1] ;
     var ok1 : boolean ; ok1 := true ;
        var k : int ; k := 0 ; while k < N do (     ok1 := MathLib.bitwiseAnd(ok1, arr[k+1][j+1] <= h) ;  ;     k := k + 1 ) ; 
    var ok2 : boolean ; ok2 := true ;
        var k : int ; k := 0 ; while k < M do (     ok2 := MathLib.bitwiseAnd(ok2, arr[i+1][k+1] <= h) ;  ;     k := k + 1 ) ; 
    if (not((ok1 or ok2))) then     okay := false ; else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (okay) then     skip else     skip ; ;  
 )  ;     cn := cn + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    int N=sc.nextInt();
    String S=sc.next();
    for(int i=0 ; i<S.length(); i++){
      if((int)S.charAt(i)+N<91){
        sb.append((char)(S.charAt(i)+N));
      }
      else {
        sb.append((char)((S.charAt(i)+N)% 90+64));
      }
    }
    System.out.println(sb.toString());
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var S : String ; S := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < S->size() do ( (     if (S->at(i+1)->oclAsType(int) + N < 91) then (     sb := sb + StringLib.newString((S->at(i+1) + N)->oclAsType(String)) ) else (     sb := sb + StringLib.newString(((S->at(i+1) + N) mod 90 + 64)->oclAsType(String)) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    final Map<String,Integer>cnt=new HashMap<>();
    {
      cnt.put("SUN",7);
      cnt.put("MON",6);
      cnt.put("TUE",5);
      cnt.put("WED",4);
      cnt.put("THU",3);
      cnt.put("FRI",2);
      cnt.put("SAT",1);
    };
    int shift=in.nextInt();
    StringBuilder s=new StringBuilder(in.next());
    for(int i=0 ; i<s.length(); ++i){
      char newChar=(char)(s.charAt(i)+shift);
      if(newChar>'Z'){
        newChar-='Z' ;
        newChar+=('A'-1);
      }
      s.setCharAt(i,newChar);
    }
    out.println(s.toString());
    in.close();
    out.close();
  }
  static class Pair {
    public long first ;
    public long second ;
    public Pair(){
      this(0,0);
    }
    public Pair(final long first,final long second){
      this.first=first ;
      this.second=second ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var cnt : Map(String,int) ; cnt := Map{} ;
(     cnt := cnt->union(Map{"SUN" |-> 7}) ; 
     cnt := cnt->union(Map{"MON" |-> 6}) ; 
    cnt := cnt->union(Map{"TUE" |-> 5}) ; 
    cnt := cnt->union(Map{"WED" |-> 4}) ; 
    cnt := cnt->union(Map{"THU" |-> 3}) ; 
    cnt := cnt->union(Map{"FRI" |-> 2}) ; 
    cnt := cnt->union(Map{"SAT" |-> 1}) ; 
 ) 
    var shift : int ; shift := in.getCurrent()->toInteger() ;
    var s : String ; s := StringLib.newString(in.getCurrent()) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var newChar : String ; newChar := (s->at(i+1) + shift)->oclAsType(String) ;
     if (newChar > 'Z') then (     newChar := newChar-('Z') ; 
     newChar := newChar+((('A')->char2byte() - 1)) ) else skip ; 
     s := s.setAt(i+1, newChar) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static class Pair {
   attribute first : long;
   attribute second : long;
   static operation newPair() : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(0, 0) );
   static operation newPair( first : long, second : long) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(first, second);
    return self );
  operation initialise( first : long, second : long) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=scan.nextInt();
    String s=scan.next();
    char[] data=s.toCharArray();
    StringBuffer sb=new StringBuffer();
    for(int i=0 ; i<s.length(); i++){
      char x=data[i];
      int org=x-'A' ;
      int next=(org+N)% 26 ;
      char n=(char)((int)next+'A');
      sb.append(n);
    }
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var s : String ; s := scan.getCurrent() ;
    var data : Sequence(String) ; data := s->characters() ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var x : String ; x := data[i+1] ;
     var org : int ; org := (x)->char2byte() - ('A')->char2byte() ;
    var next : int ; next := (org + N) mod 26 ;
    var n : String ; n := (next->oclAsType(int) + 'A')->oclAsType(String) ;
    sb := sb + StringLib.newString(n) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Code {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    while(a-->0){
      int x=sc.nextInt();
      int y=sc.nextInt();
      int n=sc.nextInt();
      int p=(n-y)/x ;
      int k=p*x+y ;
      System.out.println(k);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
         while (a > 0) do (        a := a - 1 ;     skip ; (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var p : int ; p := (n - y) / x ;
    var k : int ; k := p * x + y ;
    OclFile["System.out"].println(k) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.*;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    List<String>alph=Arrays.asList("A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z");
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    String str=sc.next();
    for(int i=0 ; i<str.length(); i++){
      String str2=String.valueOf(str.charAt(i));
      int num=alph.indexOf(str2);
      String newWord=alph.get((num+N)% 26);
      System.out.print(newWord);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var alph : Sequence(String) ; alph := Sequence{"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"} ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var str : String ; str := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < str->size() do ( (     var str2 : String ; str2 := ((str->at(i+1)) + "") ;
     var num : int ; num := alph->indexOf(str2)-1 ;
     var newWord : String ; newWord := alph->at((num + N) mod 26+1) ;
     OclFile["System.out"].print(newWord) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    char[] a={
      'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z' };
      StringBuilder sb=new StringBuilder();
      for(int i=0 ; i<s.length(); i++){
        sb.append(a[(re(s.charAt(i))+n)% 26]);
      }
      System.out.print(sb.toString());
    }
    static int re(char is){
      int r=0 ;
      switch(is){
        case 'A' : r=0 ;
        break ;
        case 'B' : r=1 ;
        break ;
        case 'C' : r=2 ;
        break ;
        case 'D' : r=3 ;
        break ;
        case 'E' : r=4 ;
        break ;
        case 'F' : r=5 ;
        break ;
        case 'G' : r=6 ;
        break ;
        case 'H' : r=7 ;
        break ;
        case 'I' : r=8 ;
        break ;
        case 'J' : r=9 ;
        break ;
        case 'K' : r=10 ;
        break ;
        case 'L' : r=11 ;
        break ;
        case 'M' : r=12 ;
        break ;
        case 'N' : r=13 ;
        break ;
        case 'O' : r=14 ;
        break ;
        case 'P' : r=15 ;
        break ;
        case 'Q' : r=16 ;
        break ;
        case 'R' : r=17 ;
        break ;
        case 'S' : r=18 ;
        break ;
        case 'T' : r=19 ;
        break ;
        case 'U' : r=20 ;
        break ;
        case 'V' : r=21 ;
        break ;
        case 'W' : r=22 ;
        break ;
        case 'X' : r=23 ;
        break ;
        case 'Y' : r=24 ;
        break ;
        case 'Z' : r=25 ;
        break ;
      }
      return r ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var a : Sequence(String) ; a := Sequence{'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'} ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     sb := sb + StringLib.newString(a[(re(s->at(i+1)) + n) mod 26+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
  static   operation re( is : String) : int
  pre: true
  post: true
  activity: (     var r : int ; r := 0 ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (is) ; 
       if _switchval = 'A' then
     r := 0 ; 
    break 
   else skip ;
       if _switchval = 'B' then
     r := 1 ; 
    break 
   else skip ;
       if _switchval = 'C' then
     r := 2 ; 
    break 
   else skip ;
       if _switchval = 'D' then
     r := 3 ; 
    break 
   else skip ;
       if _switchval = 'E' then
     r := 4 ; 
    break 
   else skip ;
       if _switchval = 'F' then
     r := 5 ; 
    break 
   else skip ;
       if _switchval = 'G' then
     r := 6 ; 
    break 
   else skip ;
       if _switchval = 'H' then
     r := 7 ; 
    break 
   else skip ;
       if _switchval = 'I' then
     r := 8 ; 
    break 
   else skip ;
       if _switchval = 'J' then
     r := 9 ; 
    break 
   else skip ;
       if _switchval = 'K' then
     r := 10 ; 
    break 
   else skip ;
       if _switchval = 'L' then
     r := 11 ; 
    break 
   else skip ;
       if _switchval = 'M' then
     r := 12 ; 
    break 
   else skip ;
       if _switchval = 'N' then
     r := 13 ; 
    break 
   else skip ;
       if _switchval = 'O' then
     r := 14 ; 
    break 
   else skip ;
       if _switchval = 'P' then
     r := 15 ; 
    break 
   else skip ;
       if _switchval = 'Q' then
     r := 16 ; 
    break 
   else skip ;
       if _switchval = 'R' then
     r := 17 ; 
    break 
   else skip ;
       if _switchval = 'S' then
     r := 18 ; 
    break 
   else skip ;
       if _switchval = 'T' then
     r := 19 ; 
    break 
   else skip ;
       if _switchval = 'U' then
     r := 20 ; 
    break 
   else skip ;
       if _switchval = 'V' then
     r := 21 ; 
    break 
   else skip ;
       if _switchval = 'W' then
     r := 22 ; 
    break 
   else skip ;
       if _switchval = 'X' then
     r := 23 ; 
    break 
   else skip ;
       if _switchval = 'Y' then
     r := 24 ; 
    break 
   else skip ;
       if _switchval = 'Z' then
     r := 25 ; 
    break 
   else skip ;
 )
     return r );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int[][] map={
      {
        0,300,500,600,700,1350,1650 },{
          6,0,350,450,600,1150,1500 },{
            13,7,0,250,400,1000,1350 },{
              18,12,5,0,250,850,1300 },{
                23,17,10,5,0,600,1150 },{
                  43,37,30,25,20,0,500 },{
                    58,52,45,40,35,15,0 }
                  };
                  while(true){
                    int n=scanner.nextInt()-1 ;
                    if(n==-1)break ;
                    int a=scanner.nextInt()*100+scanner.nextInt();
                    int m=scanner.nextInt()-1 ;
                    int b=scanner.nextInt()*100+scanner.nextInt();
                    int ans=map[n][m];
                    if(map[m][n]<=40){
                      if((1730<=a && a<=1930)||(1730<=b && b<=1930)){
                        if(map[n][m] % 20==0){
                          ans=map[n][m]/2 ;
                        }
                        else {
                          ans=(map[n][m]-50)/2+50 ;
                        }
                      }
                    }
                    System.out.println(ans);
                  }
                }
              }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var map : Sequence(Sequence(int)) ; map := Sequence{Sequence{0,300,500,600,700,1350,1650},Sequence{6,0,350,450,600,1150,1500},Sequence{13,7,0,250,400,1000,1350},Sequence{18,12,5,0,250,850,1300},Sequence{23,17,10,5,0,600,1150},Sequence{43,37,30,25,20,0,500},Sequence{58,52,45,40,35,15,0}} ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() - 1 ;
     if (n = -1) then     break else skip ; 
    var a : int ; a := scanner.getCurrent()->toInteger() * 100 + scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() - 1 ;
    var b : int ; b := scanner.getCurrent()->toInteger() * 100 + scanner.getCurrent()->toInteger() ;
    var ans : int ; ans := map[n+1][m+1] ;
    if (map[m+1][n+1] <= 40) then (     if ((1730 <= a & a <= 1930) or (1730 <= b & b <= 1930)) then (     if (map[n+1][m+1] mod 20 = 0) then (     ans := map[n+1][m+1] / 2 ) else (     ans := (map[n+1][m+1] - 50) / 2 + 50 ) ) else skip ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int[][] data={
    {
      0,300,500,600,700,1350,1650 },{
        6,0,350,450,600,1150,1500 },{
          13,7,0,250,400,1000,1350 },{
            18,12,5,0,250,850,1300 },{
              23,17,10,5,0,600,1150 },{
                43,37,30,25,20,0,500 },{
                  58,52,45,40,35,15,0 },};
                  private void doit(){
                    while(true){
                      int a=sc.nextInt()-1 ;
                      if(a==-1)break ;
                      int timeA=sc.nextInt()*100+sc.nextInt();
                      int b=sc.nextInt()-1 ;
                      int timeB=sc.nextInt()*100+sc.nextInt();
                      boolean ishalf=isOK(timeA)|| isOK(timeB);
                      int min=Math.min(a,b);
                      int max=Math.max(a,b);
                      if(data[max][min]>40){
                        ishalf=false ;
                      }
                      if(ishalf){
                        int res=data[min][max];
                        if(data[min][max] % 100!=0){
                          res+=50 ;
                        }
                        System.out.println(res/2);
                      }
                      else {
                        System.out.println(data[min][max]);
                      }
                    }
                  }
                  private boolean isOK(int timeA){
                    if(1730<=timeA && timeA<=1930){
                      return true ;
                    }
                    return false ;
                  }
                  private void debug(Object...o){
                    System.out.println("debug="+Arrays.deepToString(o));
                  }
                  public static void main(String[] args){
                    new Main().doit();
                  }
                }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute data : Sequence(Sequence(int)) := Sequence{Sequence{0,300,500,600,700,1350,1650},Sequence{6,0,350,450,600,1150,1500},Sequence{13,7,0,250,400,1000,1350},Sequence{18,12,5,0,250,850,1300},Sequence{23,17,10,5,0,600,1150},Sequence{43,37,30,25,20,0,500},Sequence{58,52,45,40,35,15,0},};
   operation doit() : void
  pre: true
  post: true
  activity: (     while (true) do (     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
     if (a = -1) then     break else skip ; 
    var timeA : int ; timeA := sc.getCurrent()->toInteger() * 100 + sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
    var timeB : int ; timeB := sc.getCurrent()->toInteger() * 100 + sc.getCurrent()->toInteger() ;
    var ishalf : boolean ; ishalf := isOK(timeA) or isOK(timeB) ;
    var min : int ; min := Set{a, b}->min() ;
    var max : int ; max := Set{a, b}->max() ;
    if (data[max+1][min+1] > 40) then (     ishalf := false ) else skip ; 
    if (ishalf) then (     var res : int ; res := data[min+1][max+1] ;
     if (data[min+1][max+1] mod 100 /= 0) then (     res := res+(50) ) else skip ; 
     OclFile["System.out"].println(res / 2) ) else (     OclFile["System.out"].println(data[min+1][max+1]) ) ;  
 ) );
   operation isOK( timeA : int) : boolean
  pre: true
  post: true
  activity: (     if (1730 <= timeA & timeA <= 1930) then (     return true ) else skip ; 
     return false );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int cost[][]={
      {
        0,300,500,600,700,1350,1650 },{
          300,0,350,450,600,1150,1500 },{
            500,350,0,250,400,1000,1350 },{
              600,450,250,0,250,850,1300 },{
                700,600,400,250,0,600,1150 },{
                  1350,1150,1000,850,600,0,500 },{
                    1650,1500,1350,1300,1150,500,0 }
                  };
                  int km[][]={
                    {
                      0,6,13,18,23,43,58 },{
                        6,0,7,12,17,37,52 },{
                          13,7,0,5,10,30,45 },{
                            18,12,5,0,5,25,40 },{
                              23,17,10,5,0,20,35 },{
                                43,37,30,25,20,0,15 },{
                                  58,52,45,40,35,15,0 }
                                };
                                Scanner in=new Scanner(System.in);
                                for(; ; ){
                                  int s=in.nextInt();
                                  if(s==0)return ;
                                  int sh=in.nextInt(),sm=in.nextInt();
                                  int t=in.nextInt();
                                  int th=in.nextInt(),tm=in.nextInt();
                                  int ans=cost[s-1][t-1];
                                  int t1=sh*60+sm ;
                                  int t2=th*60+tm ;
                                  if(km[s-1][t-1]<=40 &&(17*60+30<=t1 && t1<=19*60+30 || 17*60+30<=t2 && t2<=19*60+30))ans=ans/2+ans/2 % 50 ;
                                  System.out.println(ans);
                                }
                              }
                            }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cost : Sequence(Sequence(int)) ; cost := Sequence{Sequence{0,300,500,600,700,1350,1650},Sequence{300,0,350,450,600,1150,1500},Sequence{500,350,0,250,400,1000,1350},Sequence{600,450,250,0,250,850,1300},Sequence{700,600,400,250,0,600,1150},Sequence{1350,1150,1000,850,600,0,500},Sequence{1650,1500,1350,1300,1150,500,0}} ;
     var km : Sequence(Sequence(int)) ; km := Sequence{Sequence{0,6,13,18,23,43,58},Sequence{6,0,7,12,17,37,52},Sequence{13,7,0,5,10,30,45},Sequence{18,12,5,0,5,25,40},Sequence{23,17,10,5,0,20,35},Sequence{43,37,30,25,20,0,15},Sequence{58,52,45,40,35,15,0}} ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var s : int ; s := in.getCurrent()->toInteger() ;
     if (s = 0) then     return else skip ; 
    var sh : int ; sh := in.getCurrent()->toInteger() ;
    var sm : int ; sm := in.getCurrent()->toInteger() ;
    var t : int ; t := in.getCurrent()->toInteger() ;
    var th : int ; th := in.getCurrent()->toInteger() ;
    var tm : int ; tm := in.getCurrent()->toInteger() ;
    var ans : int ; ans := cost[s - 1+1][t - 1+1] ;
    var t1 : int ; t1 := sh * 60 + sm ;
    var t2 : int ; t2 := th * 60 + tm ;
    if (km[s - 1+1][t - 1+1] <= 40 & (17 * 60 + 30 <= t1 & t1 <= 19 * 60 + 30 or 17 * 60 + 30 <= t2 & t2 <= 19 * 60 + 30)) then     ans := ans / 2 + ans / 2 mod 50 ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    double[] x=new double[N];
    String[] u=new String[N];
    for(int i=0 ; i<N ; ++i){
      x[i]=sc.nextDouble();
      u[i]=sc.next();
    }
    System.out.println(solve(x,u));
    sc.close();
  }
  static double solve(double[] x,String[] u){
    return IntStream.range(0,x.length).mapToDouble(i->x[i]*(u[i] .equals("JPY")? 1 : 380000)).sum();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var x : Sequence(double) ; x := Integer.subrange(1,N)->collect(0.0) ;
    var u : Sequence(String) ; u := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     x[i+1] := sc.getCurrent()->toReal() ; 
     u[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(x, u)) ; 
    skip ; 
 );
  static   operation solve( x : Sequence(double), u : Sequence(String)) : double
  pre: true
  post: true
  activity: (     return Integer.subrange(0, x->size()-1)->collect( _x1 | (lambda i : OclAny in x[i+1] * (if u[i+1] = "JPY" then 1 else 380000 endif))->apply(_x1) )->sum() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] dist=new int[] {
      0,6,7,5,5,20,15 };
      int[][] toll=new int[][] {
        {
        },{
        6 },{
          10,7 },{
            12,9,5 },{
              14,12,8,5 },{
                27,23,20,17,12 },{
                  33,30,27,26,23,10 }
                };
                while(true){
                  int[] a=new int[6];
                  a[0]=sc.nextInt();
                  if(a[0]==0)break ;
                  for(int i=1 ; i<6 ; i++)a[i]=sc.nextInt();
                  int t ;
                  if(a[0]>a[3]){
                    t=a[0];
                    a[0]=a[3];
                    a[3]=t ;
                  }
                  int sumd=0 ;
                  for(int i=a[0]; i<a[3]; i++)sumd+=dist[i];
                  boolean flag=false ;
                  if(sumd<=40){
                    for(int i=0 ; i<2 ; i++){
                      if(a[1+3*i]==18 ||(a[1+3*i]==17 && a[2+3*i]>=30)||(a[1+3*i]==19 && a[2+3*i]<=30)){
                        flag=true ;
                        break ;
                      }
                    }
                  }
                  t=toll[a[3]-1][a[0]-1];
                  if(flag==true)t=(t+1)/2 ;
                  System.out.println(t*50);
                }
              }
            }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dist : Sequence(int) ; dist := Sequence{0,6,7,5,5,20,15} ;
     var toll : Sequence(Sequence(int)) ; toll := Sequence{Sequence{},Sequence{6},Sequence{10,7},Sequence{12,9,5},Sequence{14,12,8,5},Sequence{27,23,20,17,12},Sequence{33,30,27,26,23,10}} ;
     while (true) do (     var a : Sequence(int) ; a := Integer.subrange(1,6)->collect(0) ;
     a[0+1] := sc.getCurrent()->toInteger() ; 
    if (a[0+1] = 0) then     break else skip ; 
        var i : int ; i := 1 ; while i < 6 do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var t : int ;
    if (a[0+1] > a[3+1]) then (     t := a[0+1] ; 
     a[0+1] := a[3+1] ; 
     a[3+1] := t ) else skip ; 
    var sumd : int ; sumd := 0 ;
        var i : int ; i := a[0+1] ; while i < a[3+1] do (     sumd := sumd+(dist[i+1]) ;  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := false ;
    if (sumd <= 40) then (         var i : int ; i := 0 ; while i < 2 do ( (     if (a[1 + 3 * i+1] = 18 or (a[1 + 3 * i+1] = 17 & a[2 + 3 * i+1] >= 30) or (a[1 + 3 * i+1] = 19 & a[2 + 3 * i+1] <= 30)) then (     flag := true ; 
     break ) else skip )  ;     i := i + 1 ) ) else skip ; 
    t := toll[a[3+1] - 1+1][a[0+1] - 1+1] ; 
    if (flag = true) then     t := (t + 1) / 2 ; else skip ; 
    OclFile["System.out"].println(t * 50) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int[][] m=new int[][] {
    {
      0,300,500,600,700,1350,1650 },{
        0,0,350,450,600,1150,1500 },{
          0,0,0,250,400,1000,1350 },{
            0,0,0,0,250,850,1300 },{
              0,0,0,0,0,600,1150 },{
                0,0,0,0,0,0,500 },{
                  0,0,0,0,0,0,0 }
                };
                static int[][] l=new int[][] {
                  {
                    0,6,13,18,23,43,58 },{
                      0,0,7,12,17,37,52 },{
                        0,0,0,5,10,30,45 },{
                          0,0,0,0,5,25,40 },{
                            0,0,0,0,0,20,35 },{
                              0,0,0,0,0,0,15 },{
                                0,0,0,0,0,0,0 }
                              };
                              public static void main(String[] agrs){
                                Scanner sc=new Scanner(System.in);
                                while(true){
                                  int s=sc.nextInt();
                                  if(s==0)break ;
                                  int h1=sc.nextInt();
                                  int m1=sc.nextInt();
                                  int g=sc.nextInt();
                                  int h2=sc.nextInt();
                                  int m2=sc.nextInt();
                                  int len=l[s-1][g-1];
                                  int mon=m[s-1][g-1];
                                  if(len<=40 &&((h1*60+m1)>=(17*60+30)||(h2*60+m2)<=(19*60+30))){
                                    mon/=2 ;
                                  }
                                  if(mon % 50!=0){
                                    mon+=50-(mon % 50);
                                  }
                                  System.out.println(mon);
                                }
                              }
                            }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute m : Sequence(Sequence(int)) := Sequence{Sequence{0,300,500,600,700,1350,1650},Sequence{0,0,350,450,600,1150,1500},Sequence{0,0,0,250,400,1000,1350},Sequence{0,0,0,0,250,850,1300},Sequence{0,0,0,0,0,600,1150},Sequence{0,0,0,0,0,0,500},Sequence{0,0,0,0,0,0,0}};
  static   attribute l : Sequence(Sequence(int)) := Sequence{Sequence{0,6,13,18,23,43,58},Sequence{0,0,7,12,17,37,52},Sequence{0,0,0,5,10,30,45},Sequence{0,0,0,0,5,25,40},Sequence{0,0,0,0,0,20,35},Sequence{0,0,0,0,0,0,15},Sequence{0,0,0,0,0,0,0}};
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var s : int ; s := sc.getCurrent()->toInteger() ;
     if (s = 0) then     break else skip ; 
    var h1 : int ; h1 := sc.getCurrent()->toInteger() ;
    var m1 : int ; m1 := sc.getCurrent()->toInteger() ;
    var g : int ; g := sc.getCurrent()->toInteger() ;
    var h2 : int ; h2 := sc.getCurrent()->toInteger() ;
    var m2 : int ; m2 := sc.getCurrent()->toInteger() ;
    var len : int ; len := l[s - 1+1][g - 1+1] ;
    var mon : int ; mon := m[s - 1+1][g - 1+1] ;
    if (len <= 40 & ((h1 * 60 + m1) >= (17 * 60 + 30) or (h2 * 60 + m2) <= (19 * 60 + 30))) then (     mon := mon/(2) ) else skip ; 
    if (mon mod 50 /= 0) then (     mon := mon+(50 - (mon mod 50)) ) else skip ; 
    OclFile["System.out"].println(mon) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Watchmen {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    HashMap<Integer,Integer>X=new HashMap<>();
    HashMap<Integer,Integer>Y=new HashMap<>();
    HashMap<String,Integer>map=new HashMap<>();
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      int x=in.nextInt(),y=in.nextInt();
      String xy=x+"#"+y ;
      if(X.containsKey(x)){
        ans+=X.get(x);
        X.put(x,X.get(x)+1);
      }
      else X.put(x,1);
      if(Y.containsKey(y)){
        ans+=Y.get(y);
        Y.put(y,Y.get(y)+1);
      }
      else Y.put(y,1);
      if(map.containsKey(xy)){
        ans-=map.get(xy);
        map.put(xy,map.get(xy)+1);
      }
      else map.put(xy,1);
    }
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Watchmen {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var X : Map(int,int) ; X := Map{} ;
    var Y : Map(int,int) ; Y := Map{} ;
    var map : Map(String,int) ; map := Map{} ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
    var y : int ; y := in.getCurrent()->toInteger() ;
     var xy : String ; xy := x + "#" + y ;
    if (X->keys()->includes(x)) then (     ans := ans+(X->at(x)) ; 
     X := X->union(Map{x |-> X->at(x) + 1}) ) else     X := X->union(Map{x |-> 1}) ; ;  
    if (Y->keys()->includes(y)) then (     ans := ans+(Y->at(y)) ; 
     Y := Y->union(Map{y |-> Y->at(y) + 1}) ) else     Y := Y->union(Map{y |-> 1}) ; ;  
    if (map->keys()->includes(xy)) then (     ans := ans-(map->at(xy)) ; 
     map := map->union(Map{xy |-> map->at(xy) + 1}) ) else     map := map->union(Map{xy |-> 1}) ; ;  
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javafx.util.Pair ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.HashMap ;
import java.util.Map ;
public class Watchmen {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    Map<Integer,Integer>xMap=new HashMap<>();
    Map<Integer,Integer>yMap=new HashMap<>();
    Map<Integer,Map<Integer,Integer>>map=new HashMap<>();
    long res=0 ;
    for(int i=0 ; i<n ; i++){
      String[] temp=br.readLine().split(" ");
      int x=Integer.parseInt(temp[0]);
      int y=Integer.parseInt(temp[1]);
      res+=xMap.getOrDefault(x,0);
      res+=yMap.getOrDefault(y,0);
      if(map.containsKey(x)){
        res-=map.get(x).getOrDefault(y,0);
      }
      xMap.put(x,xMap.getOrDefault(x,0)+1);
      yMap.put(y,yMap.getOrDefault(y,0)+1);
      if(map.containsKey(x)==false){
        map.put(x,new HashMap<>());
      }
      map.get(x).put(y,map.get(x).getOrDefault(y,0)+1);
    }
    pr.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Watchmen {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var xMap : Map(int,int) ; xMap := Map{} ;
    var yMap : Map(int,int) ; yMap := Map{} ;
    var map : Map(int,Map(int,int)) ; map := Map{} ;
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
     var x : int ; x := (temp[0+1])->toInteger() ;
    var y : int ; y := (temp[1+1])->toInteger() ;
    res := res+((if xMap->keys()->contains(x) then xMap->at(x) else 0 endif)) ; 
    res := res+((if yMap->keys()->contains(y) then yMap->at(y) else 0 endif)) ; 
    if (map->keys()->includes(x)) then (     res := res-(map->at(x)->at(y, 0+1)) ) else skip ; 
    xMap := xMap->union(Map{x |-> (if xMap->keys()->contains(x) then xMap->at(x) else 0 endif) + 1}) ; 
    yMap := yMap->union(Map{y |-> (if yMap->keys()->contains(y) then yMap->at(y) else 0 endif) + 1}) ; 
    if (map->keys()->includes(x) = false) then (     map := map->union(Map{x |-> Map{}}) ) else skip ; 
    map := map->at(x)->union(Map{y |-> map->at(x)->at(y, 0+1) + 1}) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
public class test {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int x=in.nextInt();
      int y=in.nextInt();
      int n=in.nextInt();
      int ans=y+(x*((n-y)/x));
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x : int ; x := in.getCurrent()->toInteger() ;
     var y : int ; y := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var ans : int ; ans := y + (x * ((n - y) / x)) ;
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MyClass {
  public static void main(String[] args){
    int c=0 ;
    Scanner sc=new Scanner(System.in);
    int[][] arr=new int[5][5];
    for(int i=0 ; i<5 ; i++){
      for(int j=0 ; j<5 ; j++){
        arr[i][j]=sc.nextInt();
      }
    }
    for(int i=0 ; i<5 ; i++){
      for(int j=0 ; j<5 ; j++){
        if(arr[i][j]==1){
          c+=Math.abs(i-2)+Math.abs(j-2);
          break ;
        }
      }
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,5)->collect(Integer.subrange(1,5)->collect(0)) ;
        var i : int ; i := 0 ; while i < 5 do ( (         var j : int ; j := 0 ; while j < 5 do ( (     arr[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 5 do ( (         var j : int ; j := 0 ; while j < 5 do ( (     if (arr[i+1][j+1] = 1) then (     c := c+(if i - 2 < 0 then -(i - 2) else i - 2 endif + if j - 2 < 0 then -(j - 2) else j - 2 endif) ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BeautifulMatrix {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int arr[][]=new int[5][5];
    boolean flag=false ;
    for(int i=0 ; i<5 ; i++){
      for(int j=0 ; j<5 ; j++){
        arr[i][j]=sc.nextInt();
      }
    }
    for(int i=0 ; i<5 ; i++){
      for(int j=0 ; j<5 ; j++){
        if(arr[i][j]==1){
          System.out.println(Math.abs(2-j)+Math.abs(2-i));
          break ;
        }
      }
      if(flag){
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BeautifulMatrix {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,5)->collect(Integer.subrange(1,5)->collect(0)) ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < 5 do ( (         var j : int ; j := 0 ; while j < 5 do ( (     arr[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 5 do ( (         var j : int ; j := 0 ; while j < 5 do ( (     if (arr[i+1][j+1] = 1) then (     OclFile["System.out"].println(if 2 - j < 0 then -(2 - j) else 2 - j endif + if 2 - i < 0 then -(2 - i) else 2 - i endif) ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (flag) then (     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CodeForces {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int count=0 ;
    for(int i=1 ; i<=5 ; i++){
      for(int j=1 ; j<=5 ; j++){
        if(sc.nextInt()==1)count=Math.abs(i-3)+Math.abs(j-3);
      }
    }
    System.out.println(count);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= 5 do ( (         var j : int ; j := 1 ; while j <= 5 do ( (     if (sc.getCurrent()->toInteger() = 1) then     count := if i - 3 < 0 then -(i - 3) else i - 3 endif + if j - 3 < 0 then -(j - 3) else j - 3 endif ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication71 {
  public static void main(String[] args){
    int matrix[][]=new int[5][5];
    int Transformer=0 ;
    Scanner sca=new Scanner(System.in);
    for(int i=0 ; i<5 ; i++){
      for(int j=0 ; j<5 ; j++){
        matrix[i][j]=sca.nextInt();
        if(matrix[i][j]==1){
          Transformer=Math.abs(2-i)+Math.abs(2-j);
          System.out.println(Transformer);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication71 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var matrix : Sequence(Sequence(int)) ; matrix := Integer.subrange(1,5)->collect(Integer.subrange(1,5)->collect(0)) ;
     var Transformer : int ; Transformer := 0 ;
     var sca : OclFile ; sca := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var i : int ; i := 0 ; while i < 5 do ( (         var j : int ; j := 0 ; while j < 5 do ( (     matrix[i+1][j+1] := sca.getCurrent()->toInteger() ; 
     if (matrix[i+1][j+1] = 1) then (     Transformer := if 2 - i < 0 then -(2 - i) else 2 - i endif + if 2 - j < 0 then -(2 - j) else 2 - j endif ; 
     OclFile["System.out"].println(Transformer) ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javax.swing.plaf.synth.SynthTextAreaUI ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    double ans=0 ;
    for(int i=0 ; i<n ; i++){
      double x=sc.nextDouble();
      String u=sc.next();
      if(u.equals("BTC")){
        x*=380000 ;
      }
      ans+=x ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : double ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : double ; x := sc.getCurrent()->toReal() ;
     var u : String ; u := sc.getCurrent() ;
     if (u = "BTC") then (     x := x*(380000) ) else skip ; 
     ans := ans+(x) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int row=0 ;
    int col=0 ;
    for(int i=0 ; i<5 ; i++){
      for(int j=0 ; j<5 ; j++){
        int temp=in.nextInt();
        if(temp==1){
          row=i+1 ;
          col=j+1 ;
        }
      }
    }
    int ans=Math.abs(3-row);
    ans+=Math.abs(3-col);
    out.println(ans);
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new FileReader("sub.in"));
      }
      catch(FileNotFoundException ex){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException ex){
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException ex){
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var row : int ; row := 0 ;
    var col : int ; col := 0 ;
        var i : int ; i := 0 ; while i < 5 do ( (         var j : int ; j := 0 ; while j < 5 do ( (     var temp : int ; temp := in.nextInt() ;
     if (temp = 1) then (     row := i + 1 ; 
     col := j + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := if 3 - row < 0 then -(3 - row) else 3 - row endif ;
    ans := ans+(if 3 - col < 0 then -(3 - col) else 3 - col endif) ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("sub.in"))) )   catch (ex : FileNotFoundException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (ex : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (ex : IOException) do skip
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSetBits(int n){
    int count=0 ;
    while(n>0){
      count+=n & 1 ;
      n>>=1 ;
    }
    return count ;
  }
  static int minVal(int a,int b){
    int setBits=countSetBits(b);
    int ans=0 ;
    for(int i=30 ; i>=0 ; i--){
      int mask=1<<i ;
      if((a & mask)>0 && setBits>0){
        ans |=(1<<i);
        setBits--;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int a=3,b=5 ;
    System.out.println(minVal(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     count := count+(n & 1) ; 
     n := n/(2->pow(1)) ) ; 
     return count );
  static   operation minVal( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var setBits : int ; setBits := countSetBits(b) ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 30 ; while i >= 0 do ( (     var mask : int ; mask := (1*(2->pow(i)))->oclAsType(long) ;
     if ((a & mask) > 0 & setBits > 0) then (     ans := MathLib.bitwiseOr(ans, ((1*(2->pow(i)))->oclAsType(long))) ; 
     setBits := setBits - 1 ) else skip )  ;     i := i - 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var b : int ; b := 5 ;
     OclFile["System.out"].println(minVal(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int NumberofTimes(String str){
    int temporary_sum=0,count=0 ;
    while(str.length()>1){
      temporary_sum=0 ;
      for(int i=0 ; i<str.length(); i++)temporary_sum+=(str.charAt(i)-'0');
      str=temporary_sum+"" ;
      count++;
    }
    return count ;
  }
  public static void main(String[] args){
    String s="991" ;
    System.out.println(NumberofTimes(s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation NumberofTimes( str : String) : int
  pre: true
  post: true
  activity: (     var temporary_sum : int ; temporary_sum := 0 ;
    var count : int ; count := 0 ;
     while (str->size() > 1) do (     temporary_sum := 0 ; 
         var i : int ; i := 0 ; while i < str->size() do (     temporary_sum := temporary_sum+((str->at(i+1) - ('0')->char2byte())) ;  ;     i := i + 1 ) ; 
     str := temporary_sum + "" ; 
     count := count + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "991" ;
     OclFile["System.out"].println(NumberofTimes(s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int smallestSumSubarr(int arr[],int n){
    for(int i=0 ; i<n ; i++)arr[i]=-arr[i];
    int sum_here=arr[0],max_sum=arr[0];
    for(int i=1 ; i<n ; i++){
      sum_here=Math.max(sum_here+arr[i],arr[i]);
      max_sum=Math.max(max_sum,sum_here);
    }
    return(-1)*max_sum ;
  }
  public static void main(String[] args){
    int arr[]={
      3,-4,2,-3,-1,7,-5 };
      int n=arr.length ;
      System.out.print("Smallest sum: "+smallestSumSubarr(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation smallestSumSubarr( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     arr[i+1] := -arr[i+1] ;  ;     i := i + 1 ) ; 
     var sum_here : int ; sum_here := arr[0+1] ;
    var max_sum : int ; max_sum := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do ( (     sum_here := Set{sum_here + arr[i+1], arr[i+1]}->max() ; 
     max_sum := Set{max_sum, sum_here}->max() )  ;     i := i + 1 ) ; 
     return (-1) * max_sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,-4,2,-3,-1,7,-5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print("Smallest sum: " + smallestSumSubarr(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class MatrixTraversal {
  private static void printMatrix(int mat[][],int m,int n,int i,int j,int path[],int idx){
    path[idx]=mat[i][j];
    if(i==m-1){
      for(int k=j+1 ; k<n ; k++){
        path[idx+k-j]=mat[i][k];
      }
      for(int l=0 ; l<idx+n-j ; l++){
        System.out.print(path[l]+" ");
      }
      System.out.println();
      return ;
    }
    if(j==n-1){
      for(int k=i+1 ; k<m ; k++){
        path[idx+k-i]=mat[k][j];
      }
      for(int l=0 ; l<idx+m-i ; l++){
        System.out.print(path[l]+" ");
      }
      System.out.println();
      return ;
    }
    printMatrix(mat,m,n,i+1,j,path,idx+1);
    printMatrix(mat,m,n,i,j+1,path,idx+1);
  }
  public static void main(String[] args){
    int m=2 ;
    int n=3 ;
    int mat[][]={
      {
        1,2,3 },{
          4,5,6 }
        };
        int maxLengthOfPath=m+n-1 ;
        printMatrix(mat,m,n,0,0,new int[maxLengthOfPath],0);
      }
    }

------------------------------------------------------------
OCL File:
---------
class MatrixTraversal {
  static   operation printMatrix( mat : Sequence(Sequence(int)), m : int, n : int, i : int, j : int, path : Sequence(int), idx : int) : void
  pre: true
  post: true
  activity: (     path[idx+1] := mat[i+1][j+1] ; 
     if (i = m - 1) then (         var k : int ; k := j + 1 ; while k < n do ( (     path[idx + k - j+1] := mat[i+1][k+1] )  ;     k := k + 1 ) ; 
         var l : int ; l := 0 ; while l < idx + n - j do ( (     OclFile["System.out"].print(path[l+1] + " ") )  ;     l := l + 1 ) ; 
     OclFile["System.out"].println() ; 
     return ) else skip ; 
    if (j = n - 1) then (         var k : int ; k := i + 1 ; while k < m do ( (     path[idx + k - i+1] := mat[k+1][j+1] )  ;     k := k + 1 ) ; 
         var l : int ; l := 0 ; while l < idx + m - i do ( (     OclFile["System.out"].print(path[l+1] + " ") )  ;     l := l + 1 ) ; 
     OclFile["System.out"].println() ; 
     return ) else skip ; 
    execute printMatrix(mat, m, n, i + 1, j, path, idx + 1) ; 
    execute printMatrix(mat, m, n, i, j + 1, path, idx + 1) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 2 ;
     var n : int ; n := 3 ;
    var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,2,3},Sequence{4,5,6}} ;
    var maxLengthOfPath : int ; maxLengthOfPath := m + n - 1 ;
    execute printMatrix(mat, m, n, 0, 0, Integer.subrange(1,maxLengthOfPath)->collect(0), 0) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String a1=in.next();
    String a2=in.next();
    String a3=in.next();
    char big1=0 ;
    char smal1=0 ;
    char big2=0 ;
    char smal2=0 ;
    char big3=0 ;
    char smal3=0 ;
    String v="" ;
    if(a1.charAt(1)=='>'){
      big1=a1.charAt(0);
      smal1=a1.charAt(2);
    }
    else if(a1.charAt(1)=='<'){
      big1=a1.charAt(2);
      smal1=a1.charAt(0);
    }
    if(a2.charAt(1)=='>'){
      big2=a2.charAt(0);
      smal2=a2.charAt(2);
    }
    else if(a2.charAt(1)=='<'){
      big2=a2.charAt(2);
      smal2=a2.charAt(0);
    }
    if(a3.charAt(1)=='>'){
      big3=a3.charAt(0);
      smal3=a3.charAt(2);
    }
    else if(a3.charAt(1)=='<'){
      big3=a3.charAt(2);
      smal3=a3.charAt(0);
    }
    if(smal1==smal2 || smal1==smal3){
      v+=smal1 ;
      if(smal1==smal2){
        v+=smal3 ;
      }
      else {
        v+=smal2 ;
      }
    }
    else if(smal2==smal3){
      v+=smal2 ;
      v+=smal1 ;
    }
    if(big1==big2 || big1==big3){
      v+=big1 ;
    }
    else if(big2==big3){
      v+=big2 ;
    }
    else v="Impossible" ;
    System.out.println(v);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a1 : String ; a1 := in.getCurrent() ;
    var a2 : String ; a2 := in.getCurrent() ;
    var a3 : String ; a3 := in.getCurrent() ;
    var big1 : String ; big1 := 0 ;
    var smal1 : String ; smal1 := 0 ;
    var big2 : String ; big2 := 0 ;
    var smal2 : String ; smal2 := 0 ;
    var big3 : String ; big3 := 0 ;
    var smal3 : String ; smal3 := 0 ;
    var v : String ; v := "" ;
    if (a1->at(1+1) = '>') then (     big1 := a1->at(0+1) ; 
     smal1 := a1->at(2+1) ) else     if (a1->at(1+1) = '<') then (     big1 := a1->at(2+1) ; 
     smal1 := a1->at(0+1) ) else skip ; ;  
    if (a2->at(1+1) = '>') then (     big2 := a2->at(0+1) ; 
     smal2 := a2->at(2+1) ) else     if (a2->at(1+1) = '<') then (     big2 := a2->at(2+1) ; 
     smal2 := a2->at(0+1) ) else skip ; ;  
    if (a3->at(1+1) = '>') then (     big3 := a3->at(0+1) ; 
     smal3 := a3->at(2+1) ) else     if (a3->at(1+1) = '<') then (     big3 := a3->at(2+1) ; 
     smal3 := a3->at(0+1) ) else skip ; ;  
    if (smal1 = smal2 or smal1 = smal3) then (     v := v+(smal1) ; 
     if (smal1 = smal2) then (     v := v+(smal3) ) else (     v := v+(smal2) ) ) else     if (smal2 = smal3) then (     v := v+(smal2) ; 
     v := v+(smal1) ) else skip ; ;  
    if (big1 = big2 or big1 = big3) then (     v := v+(big1) ) else     if (big2 = big3) then (     v := v+(big2) ) else     v := "Impossible" ; ;  ;  
    OclFile["System.out"].println(v) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int foo(){
    return 0 ;
  }
  public static int my_rand(){
    int i ;
    i=5*foo()+foo()-5 ;
    if(i<22)return i % 7+1 ;
    return my_rand();
  }
  public static void main(String[] args){
    System.out.println(my_rand());
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation foo() : int
  pre: true
  post: true
  activity: (     return 0 );
  static   operation my_rand() : int
  pre: true
  post: true
  activity: (     var i : int ;
     i := 5 * foo() + foo() - 5 ; 
     if (i < 22) then     return i mod 7 + 1 else skip ; 
     return my_rand() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(my_rand()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=0,B=0,C=0 ;
    for(int i=0 ; i<3 ; i++){
      String s=sc.next();
      if(s.charAt(1)=='>'){
        if(s.charAt(0)=='A')A++;
        if(s.charAt(0)=='B')B++;
        if(s.charAt(0)=='C')C++;
      }
      else {
        if(s.charAt(2)=='A')A++;
        if(s.charAt(2)=='B')B++;
        if(s.charAt(2)=='C')C++;
      }
    }
    if(A==2 || B==2 || C==2){
      if(A==0)System.out.print("A");
      if(B==0)System.out.print("B");
      if(C==0)System.out.print("C");
      if(A==1)System.out.print("A");
      if(B==1)System.out.print("B");
      if(C==1)System.out.print("C");
      if(A==2)System.out.print("A");
      if(B==2)System.out.print("B");
      if(C==2)System.out.print("C");
    }
    else System.out.println("Impossible");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := 0 ;
    var B : int ; B := 0 ;
    var C : int ; C := 0 ;
         var i : int ; i := 0 ; while i < 3 do ( (     var s : String ; s := sc.getCurrent() ;
     if (s->at(1+1) = '>') then (     if (s->at(0+1) = 'A') then     A := A + 1 ; else skip ; 
     if (s->at(0+1) = 'B') then     B := B + 1 ; else skip ; 
     if (s->at(0+1) = 'C') then     C := C + 1 ; else skip ) else (     if (s->at(2+1) = 'A') then     A := A + 1 ; else skip ; 
     if (s->at(2+1) = 'B') then     B := B + 1 ; else skip ; 
     if (s->at(2+1) = 'C') then     C := C + 1 ; else skip ) )  ;     i := i + 1 ) ; 
     if (A = 2 or B = 2 or C = 2) then (     if (A = 0) then     OclFile["System.out"].print("A") ; else skip ; 
     if (B = 0) then     OclFile["System.out"].print("B") ; else skip ; 
    if (C = 0) then     OclFile["System.out"].print("C") ; else skip ; 
    if (A = 1) then     OclFile["System.out"].print("A") ; else skip ; 
    if (B = 1) then     OclFile["System.out"].print("B") ; else skip ; 
    if (C = 1) then     OclFile["System.out"].print("C") ; else skip ; 
    if (A = 2) then     OclFile["System.out"].print("A") ; else skip ; 
    if (B = 2) then     OclFile["System.out"].print("B") ; else skip ; 
    if (C = 2) then     OclFile["System.out"].print("C") ; else skip ; 
 ) else     OclFile["System.out"].println("Impossible") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findNumOfPair(int a[],int n){
    Arrays.sort(a);
    int ans=0 ;
    for(int i=0 ; i<n ; ++i){
      if(a[i]<=0)continue ;
      int len=a.length ;
      int j=0 ;
      while(j<len){
        if(a[j]==n){
          return j ;
        }
        else {
          j=j+1 ;
        }
      }
      ans+=i-j ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int a[]={
      3,-2,1 };
      int n=a.length ;
      int ans=findNumOfPair(a,n);
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNumOfPair( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] <= 0) then     continue else skip ; 
     var len : int ; len := a->size() ;
    var j : int ; j := 0 ;
    while (j < len) do (     if (a[j+1] = n) then (     return j ) else (     j := j + 1 ) ) ; 
    ans := ans+(i - j) ; 
 )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{3,-2,1} ;
     var n : int ; n := a->size() ;
     var ans : int ; ans := findNumOfPair(a, n) ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int subsetXOR(int arr[],int n,int K){
    int max_ele=arr[0];
    for(int i=1 ; i<n ; i++)if(arr[i]>max_ele)max_ele=arr[i];
    int m=(1<<(int)(Math.log(max_ele)/Math.log(2)+1))-1 ;
    int[][][] dp=new int[n+1][m+1][n+1];
    for(int i=0 ; i<=n ; i++)for(int j=0 ; j<=m ; j++)for(int k=0 ; k<=n ; k++)dp[i][j][k]=0 ;
    for(int i=0 ; i<=n ; i++)dp[i][0][0]=1 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=0 ; j<=m ; j++){
        for(int k=0 ; k<=n ; k++){
          dp[i][j][k]=dp[i-1][j][k];
          if(k!=0){
            dp[i][j][k]+=k*dp[i-1][j ^ arr[i-1] ][k-1];
          }
        }
      }
    }
    int ans=0 ;
    for(int i=1 ; i<=n ; i++){
      ans+=dp[n][K][i];
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3 };
      int k=1 ;
      int n=arr.length ;
      System.out.println(subsetXOR(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation subsetXOR( arr : Sequence(int), n : int, K : int) : int
  pre: true
  post: true
  activity: (     var max_ele : int ; max_ele := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do (     if (arr[i+1] > max_ele) then     max_ele := arr[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    var m : int ; m := ((1*(2->pow(((max_ele)->log() / (2)->log() + 1)->oclAsType(int))))->oclAsType(long)) - 1 ;
    var dp : Sequence(Sequence(Sequence(int))) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(Integer.subrange(1,n + 1)->collect(0))) ;
        var i : int ; i := 0 ; while i <= n do (         var j : int ; j := 0 ; while j <= m do (         var k : int ; k := 0 ; while k <= n do (     dp[i+1][j+1][k+1] := 0 ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= n do (     dp[i+1][0+1][0+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= m do ( (         var k : int ; k := 0 ; while k <= n do ( (     dp[i+1][j+1][k+1] := dp[i - 1+1][j+1][k+1] ; 
     if (k /= 0) then (     dp[i+1][j+1][k+1] := dp[i+1][j+1][k+1]+(k * dp[i - 1+1][MathLib.bitwiseXor(j,arr[i - 1+1])+1][k - 1+1]) ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     ans := ans+(dp[n+1][K+1][i+1]) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3} ;
     var k : int ; k := 1 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(subsetXOR(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printSquares(int n){
    int square=0,prev_x=0 ;
    for(int x=0 ; x<n ; x++){
      square=(square+x+prev_x);
      System.out.print(square+" ");
      prev_x=x ;
    }
  }
  public static void main(String[] args){
    int n=5 ;
    printSquares(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printSquares( n : int) : void
  pre: true
  post: true
  activity: (     var square : int ; square := 0 ;
    var prev_x : int ; prev_x := 0 ;
         var x : int ; x := 0 ; while x < n do ( (     square := (square + x + prev_x) ; 
     OclFile["System.out"].print(square + " ") ; 
     prev_x := x )  ;     x := x + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute printSquares(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printSquares(int n){
    int square=0,odd=1 ;
    for(int x=0 ; x<n ; x++){
      System.out.print(square+" ");
      square=square+odd ;
      odd=odd+2 ;
    }
  }
  public static void main(String[] args){
    int n=5 ;
    printSquares(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printSquares( n : int) : void
  pre: true
  post: true
  activity: (     var square : int ; square := 0 ;
    var odd : int ; odd := 1 ;
         var x : int ; x := 0 ; while x < n do ( (     OclFile["System.out"].print(square + " ") ; 
     square := square + odd ; 
     odd := odd + 2 )  ;     x := x + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute printSquares(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxOR(int L,int R){
    int maximum=Integer.MIN_VALUE ;
    for(int i=L ; i<R ; i++)for(int j=i+1 ; j<=R ; j++)maximum=Math.max(maximum,(i | j));
    return maximum ;
  }
  public static void main(String[] args){
    int L=4,R=5 ;
    System.out.println(maxOR(L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxOR( L : int, R : int) : int
  pre: true
  post: true
  activity: (     var maximum : int ; maximum := -2147483648 ;
         var i : int ; i := L ; while i < R do (         var j : int ; j := i + 1 ; while j <= R do (     maximum := Set{maximum, (MathLib.bitwiseOr(i,j))}->max() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return maximum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 4 ;
    var R : int ; R := 5 ;
     OclFile["System.out"].println(maxOR(L, R)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findCount(String s,int n,int a,int b){
    int res=0 ;
    char[] s1=s.toCharArray();
    for(int i=0 ; i<b ; i++){
      if(i==a){
        if(s1[n-i-1]!='1')res+=1 ;
      }
      else {
        if(s1[n-i-1]!='0')res+=1 ;
      }
    }
    return res ;
  }
  static public void main(String[] args){
    String str="1001011001" ;
    int N=str.length();
    int A=3,B=6 ;
    System.out.println(findCount(str,N,A,B));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findCount( s : String, n : int, a : int, b : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     var s1 : Sequence(String) ; s1 := s->characters() ;
         var i : int ; i := 0 ; while i < b do ( (     if (i = a) then (     if (s1[n - i - 1+1] /= '1') then     res := res+(1) ; else skip ) else (     if (s1[n - i - 1+1] /= '0') then     res := res+(1) ; else skip ) )  ;     i := i + 1 ) ; 
     return res );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "1001011001" ;
     var N : int ; N := str->size() ;
     var A : int ; A := 3 ;
    var B : int ; B := 6 ;
     OclFile["System.out"].println(findCount(str, N, A, B)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int size=10001 ;
  static long[] fib=new long[100010];
  static int[] freq=new int[100010];
  static boolean isPerfectSquare(int x){
    int s=(int)Math.sqrt(x);
    return(s*s==x);
  }
  static int isFibonacci(int n){
    if(isPerfectSquare(5*n*n+4)|| isPerfectSquare(5*n*n-4))return 1 ;
    return 0 ;
  }
  static void compute(int a,int b){
    for(int i=1 ; i<100010 ; i++){
      fib[i]=isFibonacci(i);
    }
    for(int x=1 ; x<100010 ; x++){
      for(int y=1 ; y<size ; y++){
        if(fib[x]==1 && fib[y]==1 && a*x+b*y<100010){
          freq[a*x+b*y]++;
        }
      }
    }
  }
  public static void main(String[] args){
    int Q=2,A=5,B=10 ;
    compute(A,B);
    int arr[]={
      50,150 };
      for(int i=0 ; i<Q ; i++){
        System.out.print(freq[arr[i] ]+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute size : int := 10001;
  static   attribute fib : Sequence(long) := Integer.subrange(1,100010)->collect(0);
  static   attribute freq : Sequence(int) := Integer.subrange(1,100010)->collect(0);
  static   operation isPerfectSquare( x : int) : boolean
  pre: true
  post: true
  activity: (     var s : int ; s := (x)->sqrt()->oclAsType(int) ;
     return (s * s = x) );
  static   operation isFibonacci( n : int) : int
  pre: true
  post: true
  activity: (     if (isPerfectSquare(5 * n * n + 4) or isPerfectSquare(5 * n * n - 4)) then     return 1 else skip ; 
     return 0 );
  static   operation compute( a : int, b : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < 100010 do ( (     fib[i+1] := isFibonacci(i) )  ;     i := i + 1 ) ; 
         var x : int ; x := 1 ; while x < 100010 do ( (         var y : int ; y := 1 ; while y < size do ( (     if (fib[x+1] = 1 & fib[y+1] = 1 & a * x + b * y < 100010) then (     freq[a * x + b * y+1] := freq[a * x + b * y+1] + 1 ) else skip )  ;     y := y + 1 ) )  ;     x := x + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Q : int ; Q := 2 ;
    var A : int ; A := 5 ;
    var B : int ; B := 10 ;
     execute compute(A, B) ; 
     var arr : Sequence(int) ; arr := Sequence{50,150} ;
         var i : int ; i := 0 ; while i < Q do ( (     OclFile["System.out"].print(freq[arr[i+1]+1] + " ") )  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1621 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    StringBuilder out=new StringBuilder();
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      int minL=Integer.MAX_VALUE ;
      int maxR=Integer.MIN_VALUE ;
      int minLCost=Integer.MAX_VALUE ;
      int maxRCost=Integer.MAX_VALUE ;
      int bothCost=Integer.MAX_VALUE ;
      for(int n=0 ; n<N ; n++){
        int L=in.nextInt();
        int R=in.nextInt();
        int C=in.nextInt();
        if(L<minL){
          minL=L ;
          minLCost=Integer.MAX_VALUE ;
          bothCost=Integer.MAX_VALUE ;
        }
        if(maxR<R){
          maxR=R ;
          maxRCost=Integer.MAX_VALUE ;
          bothCost=Integer.MAX_VALUE ;
        }
        if(L==minL){
          minLCost=Math.min(minLCost,C);
        }
        if(R==maxR){
          maxRCost=Math.min(maxRCost,C);
        }
        if(L==minL && R==maxR){
          bothCost=Math.min(bothCost,C);
        }
        int answer=Math.min(bothCost,minLCost+maxRCost);
        out.append(answer).append('\n');
      }
    }
    System.out.print(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1621 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : String ; out := StringLib.newString() ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var minL : int ; minL := 2147483647 ;
    var maxR : int ; maxR := -2147483648 ;
    var minLCost : int ; minLCost := 2147483647 ;
    var maxRCost : int ; maxRCost := 2147483647 ;
    var bothCost : int ; bothCost := 2147483647 ;
        var n : int ; n := 0 ; while n < N do ( (     var L : int ; L := in.getCurrent()->toInteger() ;
     var R : int ; R := in.getCurrent()->toInteger() ;
    var C : int ; C := in.getCurrent()->toInteger() ;
    if (L < minL) then (     minL := L ; 
     minLCost := 2147483647 ; 
     bothCost := 2147483647 ) else skip ; 
    if (maxR < R) then (     maxR := R ; 
     maxRCost := 2147483647 ; 
     bothCost := 2147483647 ) else skip ; 
    if (L = minL) then (     minLCost := Set{minLCost, C}->min() ) else skip ; 
    if (R = maxR) then (     maxRCost := Set{maxRCost, C}->min() ) else skip ; 
    if (L = minL & R = maxR) then (     bothCost := Set{bothCost, C}->min() ) else skip ; 
    var answer : int ; answer := Set{bothCost, minLCost + maxRCost}->min() ;
    out := out + StringLib.newString(answer) + StringLib.newString('
') ; 
 )  ;     n := n + 1 ) ; 
 )  ;     t := t + 1 ) ; 
    OclFile["System.out"].print(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    if(N % 2!=0){
      System.out.println("NA");
      return ;
    }
    int[] X=new int[N];
    int[] Y=new int[N];
    int sx=0 ;
    int sy=0 ;
    for(int i=0 ; i<N ; ++i){
      X[i]=sc.nextInt()*N ;
      Y[i]=sc.nextInt()*N ;
      sx+=X[i];
      sy+=Y[i];
    }
    sx/=N ;
    sy/=N ;
    for(int i=0 ; i<N ; ++i){
      int dx=X[i]-sx ;
      int dy=Y[i]-sy ;
      if(X[(i+N/2)% N]!=sx-dx || Y[(i+N/2)% N]!=sy-dy){
        System.out.println("NA");
        return ;
      }
    }
    System.out.println((1.0*sx/N)+" "+(1.0*sy/N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N mod 2 /= 0) then (     OclFile["System.out"].println("NA") ; 
     return ) else skip ; 
    var X : Sequence(int) ; X := Integer.subrange(1,N)->collect(0) ;
    var Y : Sequence(int) ; Y := Integer.subrange(1,N)->collect(0) ;
    var sx : int ; sx := 0 ;
    var sy : int ; sy := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     X[i+1] := sc.getCurrent()->toInteger() * N ; 
     Y[i+1] := sc.getCurrent()->toInteger() * N ; 
     sx := sx+(X[i+1]) ; 
     sy := sy+(Y[i+1]) )  ;     i := i + 1 ) ; 
    sx := sx/(N) ; 
    sy := sy/(N) ; 
        var i : int ; i := 0 ; while i < N do ( (     var dx : int ; dx := X[i+1] - sx ;
     var dy : int ; dy := Y[i+1] - sy ;
     if (X[(i + N / 2) mod N+1] /= sx - dx or Y[(i + N / 2) mod N+1] /= sy - dy) then (     OclFile["System.out"].println("NA") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((1.0 * sx / N) + " " + (1.0 * sy / N)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeforces1621B {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int numCases=Integer.parseInt(br.readLine());
    StringBuilder answer=new StringBuilder();
    for(int rep=0 ; rep<numCases ; rep++){
      int numSegments=Integer.parseInt(br.readLine());
      int currL=Integer.MAX_VALUE ;
      int currR=0 ;
      int cost1=Integer.MAX_VALUE ;
      int cost2=Integer.MAX_VALUE ;
      int totalCost=Integer.MAX_VALUE ;
      for(int i=0 ; i<numSegments ; i++){
        StringTokenizer st=new StringTokenizer(br.readLine());
        int l=Integer.parseInt(st.nextToken());
        int r=Integer.parseInt(st.nextToken());
        int cost=Integer.parseInt(st.nextToken());
        if(l<currL){
          totalCost=Integer.MAX_VALUE ;
          currL=l ;
          cost1=cost ;
        }
        else if(l==currL){
          cost1=Math.min(cost,cost1);
        }
        if(r>currR){
          totalCost=Integer.MAX_VALUE ;
          cost2=cost ;
          currR=r ;
        }
        else if(r==currR){
          cost2=Math.min(cost,cost2);
        }
        if(currL==l && currR==r && cost<totalCost){
          totalCost=cost ;
        }
        answer.append(Math.min(cost1+cost2,totalCost));
        answer.append("\n");
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces1621B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var numCases : int ; numCases := (br.readLine())->toInteger() ;
    var answer : String ; answer := StringLib.newString() ;
        var rep : int ; rep := 0 ; while rep < numCases do ( (     var numSegments : int ; numSegments := (br.readLine())->toInteger() ;
     var currL : int ; currL := 2147483647 ;
    var currR : int ; currR := 0 ;
    var cost1 : int ; cost1 := 2147483647 ;
    var cost2 : int ; cost2 := 2147483647 ;
    var totalCost : int ; totalCost := 2147483647 ;
        var i : int ; i := 0 ; while i < numSegments do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var l : int ; l := (st.next())->toInteger() ;
    var r : int ; r := (st.next())->toInteger() ;
    var cost : int ; cost := (st.next())->toInteger() ;
    if (l < currL) then (     totalCost := 2147483647 ; 
     currL := l ; 
     cost1 := cost ) else     if (l = currL) then (     cost1 := Set{cost, cost1}->min() ) else skip ; ;  
    if (r > currR) then (     totalCost := 2147483647 ; 
     cost2 := cost ; 
     currR := r ) else     if (r = currR) then (     cost2 := Set{cost, cost2}->min() ) else skip ; ;  
    if (currL = l & currR = r & cost < totalCost) then (     totalCost := cost ) else skip ; 
    answer := answer + StringLib.newString(Set{cost1 + cost2, totalCost}->min()) ; 
    answer := answer + StringLib.newString("\n") ; 
 )  ;     i := i + 1 ) ; 
 )  ;     rep := rep + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF0629 {
  public static void main(String[] args)throws IOException {
    StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    while(in.nextToken()!=StreamTokenizer.TT_EOF){
      String s1=in.sval ;
      in.nextToken();
      String s2=in.sval ;
      if(s1.compareTo(s2)>=0){
        System.out.println("No such string");
      }
      else {
        int last=0 ;
        StringBuilder sb=new StringBuilder();
        for(int i=s1.length()-1 ; i>=0 ; i--){
          char x=s1.charAt(i);
          int cur=x-'a' ;
          cur+=(i==s1.length()-1 ? 1 : 0)+last ;
          if(cur>=26){
            cur %=26 ;
            last=1 ;
          }
          else {
            last=0 ;
          }
          sb.insert(0,(char)('a'+cur));
        }
        if(sb.toString().compareTo(s2)>=0){
          System.out.println("No such string");
        }
        else {
          System.out.println(sb);
        }
      }
    }
  }
  public static int gcd(int a,int b){
    return b==0 ? a : gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF0629 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : StreamTokenizer ; in := StreamTokenizer.newStreamTokenizer(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     while (in.next() /= StreamTokenizer.TT_EOF) do (     var s1 : String ; s1 := in.sval ;
     in.next() ; 
     var s2 : String ; s2 := in.sval ;
     if (s1->compareTo(s2) >= 0) then (     OclFile["System.out"].println("No such string") ) else (     var last : int ; last := 0 ;
     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := s1->size() - 1 ; while i >= 0 do ( (     var x : String ; x := s1->at(i+1) ;
     var cur : int ; cur := (x)->char2byte() - ('a')->char2byte() ;
    cur := cur+((if i = s1->size() - 1 then 1 else 0 endif) + last) ; 
    if (cur >= 26) then (     cur := cur mod 26 ; 
     last := 1 ) else (     last := 0 ) ;  
    sb := sb.insertAt(0+1, StringLib.newString(('a' + cur)->oclAsType(String))) ; 
 )  ;     i := i - 1 ) ; 
     if (sb+""->compareTo(s2) >= 0) then (     OclFile["System.out"].println("No such string") ) else (     OclFile["System.out"].println(sb) ) ) ) );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int getCount(int arr[],int n,int num1,int num2){
    int i=0 ;
    for(i=0 ; i<n ; i++)if(arr[i]==num1)break ;
    if(i>=n-1)return 0 ;
    int j ;
    for(j=n-1 ; j>=i+1 ; j--)if(arr[j]==num2)break ;
    if(j==i)return 0 ;
    return(j-i-1);
  }
  public static void main(String[] args){
    int arr[]={
      3,5,7,6,4,9,12,4,8 };
      int n=arr.length ;
      int num1=5,num2=4 ;
      System.out.println(getCount(arr,n,num1,num2));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getCount( arr : Sequence(int), n : int, num1 : int, num2 : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
         i := 0 ; while i < n do (     if (arr[i+1] = num1) then     break else skip ;  ;     i := i + 1 ) ; 
    if (i >= n - 1) then     return 0 else skip ; 
    var j : int ;
        j := n - 1 ; while j >= i + 1 do (     if (arr[j+1] = num2) then     break else skip ;  ;     j := j - 1 ) ; 
    if (j = i) then     return 0 else skip ; 
    return (j - i - 1) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,5,7,6,4,9,12,4,8} ;
     var n : int ; n := arr->size() ;
     var num1 : int ; num1 := 5 ;
    var num2 : int ; num2 := 4 ;
     OclFile["System.out"].println(getCount(arr, n, num1, num2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  private void solve()throws IOException {
    int n=nextInt();
    int k=nextInt();
    int g=0 ;
    int max=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      int x=nextInt();
      g=gcd(g,x);
      max=Math.max(max,x);
    }
    if(k % g==0 && k<=max){
      out.println("POSSIBLE");
    }
    else {
      out.println("IMPOSSIBLE");
    }
  }
  private int gcd(int a,int b){
    while(b>0){
      int c=a % b ;
      a=b ;
      b=c ;
    }
    return a ;
  }
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer st ;
  PrintWriter out=new PrintWriter(System.out);
  String next()throws IOException {
    while(st==null || ! st.hasMoreTokens()){
      st=new StringTokenizer(br.readLine());
    }
    return st.nextToken();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    solve();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var k : int ; k := nextInt() ;
    var g : int ; g := 0 ;
    var max : int ; max := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := nextInt() ;
     g := gcd(g, x) ; 
     max := Set{max, x}->max() )  ;     i := i + 1 ) ; 
    if (k mod g = 0 & k <= max) then (     out.println("POSSIBLE") ) else (     out.println("IMPOSSIBLE") ) ;  
 );
   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     while (b > 0) do (     var c : int ; c := a mod b ;
     a := b ; 
     b := c ) ; 
     return a );
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator;
   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     execute solve() ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long k=sc.nextLong();
    int a[]=new int[n];
    String pos="POSSIBLE ",imp="IMPOSSIBLE " ;
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    sc.close();
    Arrays.sort(a);
    int min=a[0],max=a[n-1];
    List<Integer>ls=new ArrayList<>();
    for(int i=2 ; i*i<=max ; i++){
      if(max % i==0){
        ls.add(i);
        if(i*i!=max){
          ls.add(max/i);
        }
      }
    }
    Collections.sort(ls);
    int div=1 ;
    for(int i=0 ; i<ls.size(); i++){
      int now=ls.get(i);
      boolean ok=true ;
      for(int j=0 ; j<n ; j++){
        if(a[j] % now==0)continue ;
        ok=false ;
        break ;
      }
      if(ok)div=now ;
    }
    if(k>max){
      System.out.println(imp);
      return ;
    }
    if(n==1){
      if(min==k)System.out.println(pos);
      else System.out.println(imp);
      return ;
    }
    if(div==1){
      System.out.println(pos);
      return ;
    }
    if(k % div==0)System.out.println(pos);
    else System.out.println(imp);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var pos : String ; pos := "POSSIBLE " ;
    var imp : String ; imp := "IMPOSSIBLE " ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    skip ; 
    a := a->sort() ; 
    var min : int ; min := a[0+1] ;
    var max : int ; max := a[n - 1+1] ;
    var ls : Sequence(int) ; ls := Sequence{} ;
        var i : int ; i := 2 ; while i * i <= max do ( (     if (max mod i = 0) then (     ls := ls->including(i) ; 
     if (i * i /= max) then (     ls := ls->including(max / i) ) else skip ) else skip )  ;     i := i + 1 ) ; 
    ls := ls->sort() ; 
    var div : int ; div := 1 ;
        var i : int ; i := 0 ; while i < ls->size() do ( (     var now : int ; now := ls->at(i+1) ;
     var ok : boolean ; ok := true ;
         var j : int ; j := 0 ; while j < n do ( (     if (a[j+1] mod now = 0) then     continue else skip ; 
     ok := false ; 
     break )  ;     j := j + 1 ) ; 
     if (ok) then     div := now ; else skip )  ;     i := i + 1 ) ; 
    if (k > max) then (     OclFile["System.out"].println(imp) ; 
     return ) else skip ; 
    if (n = 1) then (     if (min = k) then     OclFile["System.out"].println(pos) else     OclFile["System.out"].println(imp) ; ;  
     return ) else skip ; 
    if (div = 1) then (     OclFile["System.out"].println(pos) ; 
     return ) else skip ; 
    if (k mod div = 0) then     OclFile["System.out"].println(pos) else     OclFile["System.out"].println(imp) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int n ;
  long k ;
  long[] as ;
  public static void main(String[] args){
    Main m=new Main();
    m.read();
    m.solve();
  }
  private void read(){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    k=sc.nextLong();
    as=new long[n];
    for(int i=0 ; i<n ; i++)as[i]=sc.nextLong();
  }
  private void solve(){
    long gcd=as[0];
    long max=as[0];
    for(int i=1 ; i<n ; i++){
      gcd=gcd(as[i],gcd);
      max=Math.max(max,as[i]);
    }
    if(k<=max && k % gcd==0)System.out.println("POSSIBLE");
    else System.out.println("IMPOSSIBLE");
  }
  private long gcd(long x,long y){
    if(y==0)return x ;
    return gcd(y,x % y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute k : long;
   attribute as : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.read() ; 
     m.solve() );
   operation read() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    k := sc.getCurrent()->toLong() ; 
    as := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     as[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var gcd : long ; gcd := as[0+1] ;
     var max : long ; max := as[0+1] ;
         var i : int ; i := 1 ; while i < n do ( (     gcd := gcd(as[i+1], gcd) ; 
     max := Set{max, as[i+1]}->max() )  ;     i := i + 1 ) ; 
     if (k <= max & k mod gcd = 0) then     OclFile["System.out"].println("POSSIBLE") ; else     OclFile["System.out"].println("IMPOSSIBLE") ; );
   operation gcd( x : long, y : long) : long
  pre: true
  post: true
  activity: (     if (y = 0) then     return x else skip ; 
     return gcd(y, x mod y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  static long gcd(long x,long y){
    while(y!=0){
      long r=x % y ;
      x=y ;
      y=r ;
    }
    return x ;
  }
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    out=new PrintWriter(new BufferedOutputStream(System.out));
    int n=sc.nextInt();
    long k=sc.nextInt();
    long[] a=new long[n];
    long g=0 ;
    long max=0 ;
    for(int i=0 ; i<n ; ++i){
      a[i]=sc.nextInt();
      g=gcd(g,a[i]);
      max=Math.max(max,a[i]);
    }
    out.println(k % g==0 && k<=max ? "POSSIBLE" : "IMPOSSIBLE");
    out.close();
  }
  public static PrintWriter out ;
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( x : long, y : long) : long
  pre: true
  post: true
  activity: (     while (y /= 0) do (     var r : long ; r := x mod y ;
     x := y ; 
     y := r ) ; 
     return x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var n : int ; n := sc.nextInt() ;
    var k : long ; k := sc.nextInt() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var g : long ; g := 0 ;
    var max : long ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.nextInt() ; 
     g := gcd(g, a[i+1]) ; 
     max := Set{max, a[i+1]}->max() )  ;     i := i + 1 ) ; 
    out.println(if k mod g = 0 & k <= max then "POSSIBLE" else "IMPOSSIBLE" endif) ; 
    out.close() ; 
 );
  static   attribute out : OclFile;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int N=in.nextInt();
      int K=in.nextInt();
      int max=0 ;
      int gcd=0 ;
      for(int i=0 ; i<N ; i++){
        int a=in.nextInt();
        max=Math.max(max,a);
        gcd=findGCD(gcd,a);
      }
      if(K<=max && K % gcd==0){
        out.println("POSSIBLE");
      }
      else {
        out.println("IMPOSSIBLE");
      }
    }
    private int findGCD(int a,int b){
      while(b>0){
        int t=a % b ;
        a=b ;
        b=t ;
      }
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
     var K : int ; K := in.getCurrent()->toInteger() ;
    var max : int ; max := 0 ;
    var gcd : int ; gcd := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     max := Set{max, a}->max() ; 
     gcd := findGCD(gcd, a) )  ;     i := i + 1 ) ; 
    if (K <= max & K mod gcd = 0) then (     skip ) else (     skip ) ;  
 );
   operation findGCD( a : int, b : int) : int
  pre: true
  post: true
  activity: (     while (b > 0) do (     var t : int ; t := a mod b ;
     a := b ; 
     b := t ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int repUnitValue(int n){
    if(n % 2==0 || n % 5==0)return 0 ;
    int rem=1 ;
    int power=1 ;
    int k=1 ;
    while(rem % n!=0){
      k++;
      power=power*10 % n ;
      rem=(rem+power)% n ;
    }
    return k ;
  }
  public static void main(String[] args){
    int n=13 ;
    System.out.println(repUnitValue(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation repUnitValue( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 = 0 or n mod 5 = 0) then     return 0 else skip ; 
     var rem : int ; rem := 1 ;
    var power : int ; power := 1 ;
    var k : int ; k := 1 ;
    while (rem mod n /= 0) do (     k := k + 1 ; 
     power := power * 10 mod n ; 
     rem := (rem + power) mod n ) ; 
    return k 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 13 ;
     OclFile["System.out"].println(repUnitValue(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication37 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    ArrayList<Integer>arr=new ArrayList<>();
    int s1=0 ;
    int count=0 ;
    int counter=0 ;
    for(int i=0 ; i<num ; i++){
      int h=sc.nextInt();
      arr.add(h);
    }
    int least=sc.nextInt();
    int most=sc.nextInt();
    int k=0 ;
    for(int i=0 ; i<num ; i++){
      if(count<=most && arr.get(i)<=(most-count)){
        count+=arr.get(i);
        s1=i ;
        k=i ;
      }
      else {
        break ;
      }
    }
    for(int i=k+1 ; i<num ; i++){
      counter+=arr.get(i);
    }
    while(counter<least && count>least){
      counter+=arr.get(s1);
      count-=arr.get(s1);
      s1-=1 ;
    }
    if(count>=least && count<=most && counter>=least && counter<=most){
      System.out.println(s1+2);
    }
    else {
      System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication37 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Sequence{} ;
    var s1 : int ; s1 := 0 ;
    var count : int ; count := 0 ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < num do ( (     var h : int ; h := sc.getCurrent()->toInteger() ;
     arr := arr->including(h) )  ;     i := i + 1 ) ; 
    var least : int ; least := sc.getCurrent()->toInteger() ;
    var most : int ; most := sc.getCurrent()->toInteger() ;
    var k : int ; k := 0 ;
        var i : int ; i := 0 ; while i < num do ( (     if (count <= most & arr->at(i+1) <= (most - count)) then (     count := count+(arr->at(i+1)) ; 
     s1 := i ; 
     k := i ) else (     break ) )  ;     i := i + 1 ) ; 
        var i : int ; i := k + 1 ; while i < num do ( (     counter := counter+(arr->at(i+1)) )  ;     i := i + 1 ) ; 
    while (counter < least & count > least) do (     counter := counter+(arr->at(s1+1)) ; 
     count := count-(arr->at(s1+1)) ; 
     s1 := s1-(1) ) ; 
    if (count >= least & count <= most & counter >= least & counter <= most) then (     OclFile["System.out"].println(s1 + 2) ) else (     OclFile["System.out"].println(0) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n+1];
    int[] px=new int[n+1];
    px[0]=0 ;
    for(int i=1 ; i<=n ; i++){
      a[i]=sc.nextInt();
    }
    for(int i=1 ; i<=n ; i++)px[i]=px[i-1]+a[i];
    int x=sc.nextInt(),y=sc.nextInt();
    int ans=0 ;
    for(int i=1 ; i<=n ; i++){
      if(px[i-1]>=x && px[i-1]<=y && px[n]-px[i-1]>=x && px[n]-px[i-1]<=y)ans=i ;
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var px : Sequence(int) ; px := Integer.subrange(1,n + 1)->collect(0) ;
    px[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (     px[i+1] := px[i - 1+1] + a[i+1] ;  ;     i := i + 1 ) ; 
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (px[i - 1+1] >= x & px[i - 1+1] <= y & px[n+1] - px[i - 1+1] >= x & px[n+1] - px[i - 1+1] <= y) then     ans := i ; else skip )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPalindrome(int num){
    int reverse_num=0,remainder,temp ;
    temp=num ;
    while(temp!=0){
      remainder=temp % 10 ;
      reverse_num=reverse_num*10+remainder ;
      temp/=10 ;
    }
    if(reverse_num==num){
      return true ;
    }
    return false ;
  }
  static boolean isOddLength(int num){
    int count=0 ;
    while(num>0){
      num/=10 ;
      count++;
    }
    if(count % 2!=0){
      return true ;
    }
    return false ;
  }
  static long sumOfAllPalindrome(int L,int R){
    long sum=0 ;
    if(L<=R)for(int i=L ;
    i<=R ;
    i++){
      if(isPalindrome(i)&& isOddLength(i)){
        sum+=i ;
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int L=110,R=1130 ;
    System.out.println(sumOfAllPalindrome(L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPalindrome( num : int) : boolean
  pre: true
  post: true
  activity: (     var reverse_num : int ; reverse_num := 0 ;
    var remainder : int ;
    var temp : int ;
     temp := num ; 
    while (temp /= 0) do (     remainder := temp mod 10 ; 
     reverse_num := reverse_num * 10 + remainder ; 
     temp := temp/(10) ) ; 
    if (reverse_num = num) then (     return true ) else skip ; 
    return false 
 );
  static   operation isOddLength( num : int) : boolean
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (num > 0) do (     num := num/(10) ; 
     count := count + 1 ) ; 
     if (count mod 2 /= 0) then (     return true ) else skip ; 
     return false );
  static   operation sumOfAllPalindrome( L : int, R : int) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     if (L <= R) then         var i : int ; i := L ; while i <= R do ( (     if (isPalindrome(i) & isOddLength(i)) then (     sum := sum+(i) ) else skip )  ;     i := i + 1 ) ; else skip ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 110 ;
    var R : int ; R := 1130 ;
     OclFile["System.out"].println(sumOfAllPalindrome(L, R)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n % 2==1){
      System.out.println("NA");
      return ;
    }
    int[] x=new int[n];
    int[] y=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=sc.nextInt();
      y[i]=sc.nextInt();
    }
    int cx2=x[0]+x[n/2];
    int cy2=y[0]+y[n/2];
    for(int i=1 ; i<n/2 ; i++){
      int cx=x[i]+x[n/2+i];
      int cy=y[i]+y[n/2+i];
      if(!(cx2==cx && cy2==cy)){
        System.out.println("NA");
        return ;
      }
    }
    System.out.println((double)cx2/2+" "+(double)cy2/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    if (n mod 2 = 1) then (     OclFile["System.out"].println("NA") ; 
     return ) else skip ; 
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     y[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cx2 : int ; cx2 := x[0+1] + x[n / 2+1] ;
    var cy2 : int ; cy2 := y[0+1] + y[n / 2+1] ;
        var i : int ; i := 1 ; while i < n / 2 do ( (     var cx : int ; cx := x[i+1] + x[n / 2 + i+1] ;
     var cy : int ; cy := y[i+1] + y[n / 2 + i+1] ;
     if (not((cx2 = cx & cy2 = cy))) then (     OclFile["System.out"].println("NA") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cx2->oclAsType(double) / 2 + " " + cy2->oclAsType(double) / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B999 {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    String str=br.readLine();
    for(int i=1 ; i<=t ; i++){
      if(t % i==0){
        str=reverse(str,i-1);
      }
    }
    System.out.println(str);
  }
  public static String reverse(String str,int last){
    ArrayList<Character>arr=new ArrayList<Character>();
    for(int i=0 ; i<str.length(); i++){
      arr.add(str.charAt(i));
    }
    int counterUp=0,counterDown=last ;
    for(int i=0 ; i<=last/2 ; i++){
      Collections.swap(arr,counterUp,counterDown);
      counterUp++;
      counterDown--;
    }
    String result="" ;
    for(int i=0 ; i<str.length(); i++){
      result+=arr.get(i);
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B999 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
    var str : String ; str := br.readLine() ;
        var i : int ; i := 1 ; while i <= t do ( (     if (t mod i = 0) then (     str := reverse(str, (i)->char2byte() - 1) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(str) ; 
 );
  static   operation reverse( str : String, last : int) : String
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{} ;
         var i : int ; i := 0 ; while i < str->size() do ( (     arr := arr->including(str->at(i+1)) )  ;     i := i + 1 ) ; 
    var counterUp : int ; counterUp := 0 ;
    var counterDown : int ; counterDown := last ;
        var i : int ; i := 0 ; while i <= last / 2 do ( (     arr := Integer.subrange(1,arr.size)->collect( _x | if _x = counterUp+1 then arr->at(counterDown+1) else if _x = counterDown+1 then arr->at(counterUp+1) else arr->at(_x) endif endif ) ; 
     counterUp := counterUp + 1 ; 
     counterDown := counterDown - 1 )  ;     i := i + 1 ) ; 
    var result : String ; result := "" ;
        var i : int ; i := 0 ; while i < str->size() do ( (     result := result+(arr->at(i+1)) )  ;     i := i + 1 ) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    while(true){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      Arrays.sort(arr);
      int min=Integer.MAX_VALUE ;
      for(int i=1 ; i<n ; i++){
        min=Math.min(min,arr[i]-arr[i-1]);
      }
      sb.append(min).append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var min : int ; min := 2147483647 ;
        var i : int ; i := 1 ; while i < n do ( (     min := Set{min, arr[i+1] - arr[i - 1+1]}->min() )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(min) + StringLib.newString("\n") ; 
 ) ; 
     OclFile["System.out"].print(sb) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.math.BigDecimal ;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    InputReader in=new InputReader();
    PrintWriter out=new PrintWriter(System.out);
    solve(in,out);
    out.close();
  }
  public static void solve(InputReader in,PrintWriter out){
    int n=in.nextInt();
    int[] a=new int[n];
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
      sum+=a[i];
    }
    int x=in.nextInt(),y=in.nextInt();
    int res=0,p=0 ;
    for(int i=0 ; i<n ; i++){
      if(p>=x && p<=y && sum-p>=x && sum-p<=y){
        res=i+1 ;
        break ;
      }
      p+=a[i];
    }
    out.println(res);
  }
}
class InputReader {
  BufferedReader buf ;
  StringTokenizer tok ;
  InputReader(){
    buf=new BufferedReader(new InputStreamReader(System.in));
  }
  boolean hasNext(){
    while(tok==null || ! tok.hasMoreElements()){
      try {
        tok=new StringTokenizer(buf.readLine());
      }
      catch(Exception e){
        return false ;
      }
    }
    return true ;
  }
  String next(){
    if(hasNext())return tok.nextToken();
    return null ;
  }
  char[] nextChars(){
    if(hasNext())return tok.nextToken().toCharArray();
    return null ;
  }
  int nextInt(){
    return Integer.parseInt(next());
  }
  long nextLong(){
    return Long.parseLong(next());
  }
  double nextDouble(){
    return Double.parseDouble(next());
  }
  BigInteger nextBigInteger(){
    return new BigInteger(next());
  }
  BigDecimal nextBigDecimal(){
    return new BigDecimal(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : InputReader ; in := InputReader.newInputReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     execute solve(in, out) ; 
     skip );
  static   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.nextInt() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    var x : int ; x := in.nextInt() ;
    var y : int ; y := in.nextInt() ;
    var res : int ; res := 0 ;
    var p : int ; p := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (p >= x & p <= y & sum - p >= x & sum - p <= y) then (     res := i + 1 ; 
     break ) else skip ; 
     p := p+(a[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
class InputReader {
   attribute buf : OclFile;
   attribute tok : OclIterator;
   static operation newInputReader() : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     buf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (tok = null or not(tok.hasNext())) do (     try (     tok := OclIterator.newOclIterator_String(buf.readLine()) )   catch (e : ProgramException) do (     return false )
 ) ; 
     return true );
   operation next() : String
  pre: true
  post: true
  activity: (     if (hasNext()) then     return tok.next() else skip ; 
     return null );
   operation nextChars() : Sequence(String)
  pre: true
  post: true
  activity: (     if (hasNext()) then     return tok.next()->characters() else skip ; 
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextBigInteger() : long
  pre: true
  post: true
  activity: (     return long(next()) );
   operation nextBigDecimal() : double
  pre: true
  post: true
  activity: (     return double(next()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static void floorAndCeil(int arr[],int x){
    int n=arr.length ;
    int fInd=-1,cInd=-1 ;
    int fDist=Integer.MAX_VALUE,cDist=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]>=x && cDist>(arr[i]-x)){
        cInd=i ;
        cDist=arr[i]-x ;
      }
      if(arr[i]<=x && fDist>(x-arr[i])){
        fInd=i ;
        fDist=x-arr[i];
      }
    }
    if(fDist==Integer.MAX_VALUE)System.out.println("Floor doesn't exist ");
    else System.out.println("Floor is "+arr[fInd]);
    if(cDist==Integer.MAX_VALUE)System.out.println("Ceil doesn't exist ");
    else System.out.println("Ceil is  "+arr[cInd]);
  }
  public static void main(String[] args){
    int arr[]={
      5,6,8,9,6,5,5,6 };
      int x=7 ;
      floorAndCeil(arr,x);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation floorAndCeil( arr : Sequence(int), x : int) : void
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
     var fInd : int ; fInd := -1 ;
    var cInd : int ; cInd := -1 ;
    var fDist : int ; fDist := 2147483647 ;
    var cDist : int ; cDist := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] >= x & cDist > (arr[i+1] - x)) then (     cInd := i ; 
     cDist := arr[i+1] - x ) else skip ; 
     if (arr[i+1] <= x & fDist > (x - arr[i+1])) then (     fInd := i ; 
     fDist := x - arr[i+1] ) else skip )  ;     i := i + 1 ) ; 
    if (fDist = 2147483647) then     OclFile["System.out"].println("Floor doesn't exist ") else     OclFile["System.out"].println("Floor is " + arr[fInd+1]) ; ;  
    if (cDist = 2147483647) then     OclFile["System.out"].println("Ceil doesn't exist ") else     OclFile["System.out"].println("Ceil is  " + arr[cInd+1]) ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,6,8,9,6,5,5,6} ;
     var x : int ; x := 7 ;
     execute floorAndCeil(arr, x) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long mod_power(long a,long b,long mod){
    long result=1l ;
    while(b>0){
      if((b & 1)==0){
        result=a*a ;
        a %=mod ;
        b/=2 ;
      }
      else {
        result=result*a ;
        result %=mod ;
      }
    }
    return result ;
  }
  static long nCr_RangeSum(long n,long r1,long r2,long p){
    long num=1,den=1 ;
    long sum=0l ;
    if(r1==0)sum+=1l ;
    for(int i=0 ; i<r2 ; i++){
      num=(num*(n-i))% p ;
      den=(den*(i+1))% p ;
      if(i-r1>=-1 &&(i-r1+1)% 2==0){
        sum+=(num*mod_power(den,p-2,p))% p ;
        sum %=p ;
      }
    }
    return sum ;
  }
  static long compute(String A,String B,int N){
    int c0A=0,c1A=0,c0B=0,c1B=0 ;
    for(char c : A.toCharArray()){
      if(c=='1')c1A+=1 ;
      else if(c=='0')c0A+=1 ;
    }
    for(char c : B.toCharArray()){
      if(c=='1')c1B+=1 ;
      else if(c=='0')c0B+=1 ;
    }
    int max1xor=Math.min(c0A,c1B)+Math.min(c1A,c0B);
    int min1xor=N-Math.min(c0B,c0A)-Math.min(c1A,c1B);
    long ans=nCr_RangeSum(N,min1xor,max1xor,1000000000+7);
    return ans ;
  }
  public static void main(String[] args){
    int N=3 ;
    String A="010" ;
    String B="100" ;
    System.out.print(compute(A,B,N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation mod_power( a : long, b : long, mod : long) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 1l ;
     while (b > 0) do (     if ((b & 1) = 0) then (     result := a * a ; 
     a := a mod mod ; 
     b := b/(2) ) else (     result := result * a ; 
     result := result mod mod ) ) ; 
     return result );
  static   operation nCr_RangeSum( n : long, r1 : long, r2 : long, p : long) : long
  pre: true
  post: true
  activity: (     var num : long ; num := 1 ;
    var den : long ; den := 1 ;
     var sum : long ; sum := 0l ;
    if (r1 = 0) then     sum := sum+(1l) ; else skip ; 
        var i : int ; i := 0 ; while i < r2 do ( (     num := (num * (n - i)) mod p ; 
     den := (den * (i + 1)) mod p ; 
     if (i - r1 >= -1 & (i - r1 + 1) mod 2 = 0) then (     sum := sum+((num * mod_power(den, p - 2, p)) mod p) ; 
     sum := sum mod p ) else skip )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation compute( A : String, B : String, N : int) : long
  pre: true
  post: true
  activity: (     var c0A : int ; c0A := 0 ;
    var c1A : int ; c1A := 0 ;
    var c0B : int ; c0B := 0 ;
    var c1B : int ; c1B := 0 ;
     for (c : A->characters()) do ( (     if (c = '1') then     c1A := c1A+(1) ; else     if (c = '0') then     c0A := c0A+(1) ; else skip ; )  ) ; 
    for (c : B->characters()) do ( (     if (c = '1') then     c1B := c1B+(1) ; else     if (c = '0') then     c0B := c0B+(1) ; else skip ; )  ) ; 
    var max1xor : int ; max1xor := Set{c0A, c1B}->min() + Set{c1A, c0B}->min() ;
    var min1xor : int ; min1xor := N - Set{c0B, c0A}->min() - Set{c1A, c1B}->min() ;
    var ans : long ; ans := nCr_RangeSum(N, min1xor, max1xor, 1000000000 + 7) ;
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
     var A : String ; A := "010" ;
     var B : String ; B := "100" ;
     OclFile["System.out"].print(compute(A, B, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static class Node {
    int data ;
    Node left=null ;
    Node right=null ;
  }
  static Node newNode(int val){
    Node temp=new Node();
    temp.data=val ;
    temp.left=null ;
    temp.right=null ;
    return temp ;
  }
  static void largestValueInEachLevel(Node root){
    if(root==null)return ;
    Queue<Node>q=new LinkedList<Node>();
    int nc,max ;
    q.add(root);
    while(true){
      nc=q.size();
      if(nc==0)break ;
      max=Integer.MIN_VALUE ;
      while(nc!=0){
        Node front=q.peek();
        q.remove();
        if(max<front.data)max=front.data ;
        if(front.left!=null)q.add(front.left);
        if(front.right!=null)q.add(front.right);
        nc--;
      }
      System.out.println(max+" ");
    }
  }
  public static void main(String[] args){
    Node root=null ;
    root=newNode(4);
    root.left=newNode(9);
    root.right=newNode(2);
    root.left.left=newNode(3);
    root.left.right=newNode(5);
    root.right.right=newNode(7);
    largestValueInEachLevel(root);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static class Node {
   attribute data : int;
   attribute left : Node := null;
   attribute right : Node := null;
}
  static   operation newNode( val : int) : Node
  pre: true
  post: true
  activity: (     var temp : Node ; temp := Node.newNode() ;
     temp.data := val ; 
    temp.left := null ; 
    temp.right := null ; 
    return temp 
 );
  static   operation largestValueInEachLevel( root : Node) : void
  pre: true
  post: true
  activity: (     if (root = null) then     return else skip ; 
     var q : Sequence(Node) ; q := Sequence{} ;
    var nc : int ;
    var max : int ;
    q := q->including(root) ; 
    while (true) do (     nc := q->size() ; 
     if (nc = 0) then     break else skip ; 
    max := -2147483648 ; 
    while (nc /= 0) do (     var front : Node ; front := q->min() ;
     q := q.remove() ; 
    if (max < front.data) then     max := front.data ; else skip ; 
    if (front.left /= null) then     q := q->including(front.left) ; else skip ; 
    if (front.right /= null) then     q := q->including(front.right) ; else skip ; 
    nc := nc - 1 ; 
 ) ; 
    OclFile["System.out"].println(max + " ") ; 
 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var root : Node ; root := null ;
     root := newNode(4) ; 
    root.left := newNode(9) ; 
    root.right := newNode(2) ; 
    root.left.left := newNode(3) ; 
    root.left.right := newNode(5) ; 
    root.right.right := newNode(7) ; 
    execute largestValueInEachLevel(root) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAX=100 ;
  static void middleProduct(int mat[][],int n){
    int row_prod=1,col_prod=1 ;
    for(int i=0 ; i<n ; i++){
      row_prod*=mat[n/2][i];
      col_prod*=mat[i][n/2];
    }
    System.out.print("Product of middle row="+row_prod);
    System.out.print("Product of middle column="+col_prod);
  }
  public static void main(String[] args){
    int mat[][]={
      {
        2,1,7 },{
          3,7,2 },{
            5,4,9 }
          };
          middleProduct(mat,3);
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100;
  static   operation middleProduct( mat : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (     var row_prod : int ; row_prod := 1 ;
    var col_prod : int ; col_prod := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     row_prod := row_prod*(mat[n / 2+1][i+1]) ; 
     col_prod := col_prod*(mat[i+1][n / 2+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("Product of middle row=" + row_prod) ; 
     OclFile["System.out"].print("Product of middle column=" + col_prod) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{2,1,7},Sequence{3,7,2},Sequence{5,4,9}} ;
     execute middleProduct(mat, 3) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static List<int[]>[] to ;
  static long[] dist ;
  static int n ;
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    to=new List[n];
    for(int i=0 ; i<n ; i++){
      to[i]=new ArrayList<int[]>();
    }
    for(int i=0 ; i<n-1 ; i++){
      int p=sc.nextInt()-1 ;
      int q=sc.nextInt()-1 ;
      int dis=sc.nextInt();
      to[p] .add(new int[] {
        q,dis }
);
        to[q] .add(new int[] {
          p,dis }
);
        }
        int query=sc.nextInt();
        int k=sc.nextInt()-1 ;
        long[] distK=calcDist(k);
        while(query-->0){
          int p=sc.nextInt()-1 ;
          int q=sc.nextInt()-1 ;
          System.out.println(distK[p]+distK[q]);
        }
      }
      public static long[] calcDist(int p){
        dist=new long[n];
        dfs(p,0,-1);
        return dist ;
      }
      public static void dfs(int p,long d,int par){
        dist[p]=d ;
        for(int[] q : to[p]){
          if(q[0]==par)continue ;
          dfs(q[0],d+q[1],p);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute to : Sequence(Sequence(Sequence(int)));
  static   attribute dist : Sequence(long);
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    to := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do ( (     to[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var p : int ; p := sc.getCurrent()->toInteger() - 1 ;
     var q : int ; q := sc.getCurrent()->toInteger() - 1 ;
    var dis : int ; dis := sc.getCurrent()->toInteger() ;
    to[p+1]->excludes(Sequence{q,dis}) ; 
    to[q+1]->excludes(Sequence{p,dis}) ; 
 )  ;     i := i + 1 ) ; 
    var query : int ; query := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() - 1 ;
    var distK : Sequence(long) ; distK := calcDist(k) ;
        while (query > 0) do (        query := query - 1 ;     skip ; (     var p : int ; p := sc.getCurrent()->toInteger() - 1 ;
     var q : int ; q := sc.getCurrent()->toInteger() - 1 ;
     OclFile["System.out"].println(distK[p+1] + distK[q+1]) ) ;  ) ;  
 );
  static   operation calcDist( p : int) : Sequence(long)
  pre: true
  post: true
  activity: (     dist := Integer.subrange(1,n)->collect(0) ; 
     execute dfs(p, 0, -1) ; 
     return dist );
  static   operation dfs( p : int, d : long, par : int) : void
  pre: true
  post: true
  activity: (     dist[p+1] := d ; 
     for (q : to[p+1]) do ( (     if (q[0+1] = par) then     continue else skip ; 
     execute dfs(q[0+1], d + q[1+1], p) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(final String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int n=scanner.nextInt();
    final Map<Integer,List<Node>>tree=new HashMap<>();
    for(int i=0 ; i<n-1 ; i++){
      final int a=scanner.nextInt();
      final int b=scanner.nextInt();
      final int c=scanner.nextInt();
      tree.computeIfAbsent(a,v->new ArrayList<>()).add(new Node(b,c));
      tree.computeIfAbsent(b,v->new ArrayList<>()).add(new Node(a,c));
    }
    final int q=scanner.nextInt();
    final int k=scanner.nextInt();
    final long[] distances=new long[n+1];
    distances[k]=Long.MAX_VALUE ;
    recursive(distances,tree,k,0);
    for(int i=0 ; i<q ; i++){
      final int x=scanner.nextInt();
      final int y=scanner.nextInt();
      System.out.println(distances[x]+distances[y]);
    }
  }
  private static void recursive(final long[] distances,final Map<Integer,List<Node>>tree,final int currentNode,final long sumDistance){
    final List<Node>destinations=tree.get(currentNode);
    for(final Node destination : destinations){
      if(distances[destination.label]!=0){
        continue ;
      }
      distances[destination.label]=sumDistance+destination.distance ;
      recursive(distances,tree,destination.label,sumDistance+destination.distance);
    }
  }
  static class Node {
    int label ;
    long distance ;
    Node(final int label,final int distance){
      this.label=label ;
      this.distance=distance ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var tree : Map(int,Sequence(Node)) ; tree := Map{} ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    tree.computeIfAbsent(a, lambda v : OclAny in Sequence{})->excludes(Node.newNode(b, c)) ; 
    tree.computeIfAbsent(b, lambda v : OclAny in Sequence{})->excludes(Node.newNode(a, c)) ; 
 )  ;     i := i + 1 ) ; 
    var q : int ; q := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
    var distances : Sequence(long) ; distances := Integer.subrange(1,n + 1)->collect(0) ;
    distances[k+1] := "9223372036854775807"->toLong() ; 
    execute recursive(distances, tree, k, 0) ; 
        var i : int ; i := 0 ; while i < q do ( (     var x : int ; x := scanner.getCurrent()->toInteger() ;
     var y : int ; y := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(distances[x+1] + distances[y+1]) )  ;     i := i + 1 ) ; 
 );
  static   operation recursive( distances : Sequence(long), tree : Map(int,Sequence(Node)), currentNode : int, sumDistance : long) : void
  pre: true
  post: true
  activity: (     var destinations : Sequence(Node) ; destinations := tree->at(currentNode) ;
     for (destination : destinations) do ( (     if (distances[destination.label+1] /= 0) then (     continue ) else skip ; 
     distances[destination.label+1] := sumDistance + destination.distance ; 
     execute recursive(distances, tree, destination.label, sumDistance + destination.distance) )  ) );
  static class Node {
   attribute label : int;
   attribute distance : long;
   static operation newNode( label : int, distance : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(label, distance);
    return self );
  operation initialise( label : int, distance : int) : void
  pre: true  post: true
  activity: (     self.label := label ; 
     self.distance := distance );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static List<int[]>[] to ;
  static long[] dist ;
  static int n ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    n=scanner.nextInt();
    to=new List[n];
    for(int i=0 ; i<n ; i++){
      to[i]=new ArrayList<int[]>();
    }
    for(int i=0 ; i<n-1 ; i++){
      int a=scanner.nextInt()-1 ;
      int b=scanner.nextInt()-1 ;
      int d=scanner.nextInt();
      to[a] .add(new int[] {
        b,d }
);
        to[b] .add(new int[] {
          a,d }
);
        }
        int query=scanner.nextInt();
        int k=scanner.nextInt()-1 ;
        long[] distK=calcDist(k);
        while(query-->0){
          int p=scanner.nextInt()-1 ;
          int q=scanner.nextInt()-1 ;
          System.out.println(distK[p]+distK[q]);
        }
      }
      public static long[] calcDist(int p){
        dist=new long[n];
        dfs(p,0,-1);
        return dist ;
      }
      public static void dfs(int p,long d,int par){
        for(int[] qData : to[p]){
          int q=qData[0];
          int PtoQ=qData[1];
          if(q==par){
            continue ;
          }
          dist[q]=d+PtoQ ;
          dfs(q,d+PtoQ,p);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute to : Sequence(Sequence(Sequence(int)));
  static   attribute dist : Sequence(long);
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := scanner.getCurrent()->toInteger() ; 
    to := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do ( (     to[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var a : int ; a := scanner.getCurrent()->toInteger() - 1 ;
     var b : int ; b := scanner.getCurrent()->toInteger() - 1 ;
    var d : int ; d := scanner.getCurrent()->toInteger() ;
    to[a+1]->excludes(Sequence{b,d}) ; 
    to[b+1]->excludes(Sequence{a,d}) ; 
 )  ;     i := i + 1 ) ; 
    var query : int ; query := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() - 1 ;
    var distK : Sequence(long) ; distK := calcDist(k) ;
        while (query > 0) do (        query := query - 1 ;     skip ; (     var p : int ; p := scanner.getCurrent()->toInteger() - 1 ;
     var q : int ; q := scanner.getCurrent()->toInteger() - 1 ;
     OclFile["System.out"].println(distK[p+1] + distK[q+1]) ) ;  ) ;  
 );
  static   operation calcDist( p : int) : Sequence(long)
  pre: true
  post: true
  activity: (     dist := Integer.subrange(1,n)->collect(0) ; 
     execute dfs(p, 0, -1) ; 
     return dist );
  static   operation dfs( p : int, d : long, par : int) : void
  pre: true
  post: true
  activity: (     for (qData : to[p+1]) do ( (     var q : int ; q := qData[0+1] ;
     var PtoQ : int ; PtoQ := qData[1+1] ;
    if (q = par) then (     continue ) else skip ; 
    dist[q+1] := d + PtoQ ; 
    execute dfs(q, d + PtoQ, p) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Scanner ;
import static java.lang.System.out ;
import static java.lang.Integer.parseInt ;
public class Main {
  static class Element {
    long t,c ;
    Element(long t,long c){
      this.t=t ;
      this.c=c ;
    }
  }
  static int NN=100007 ;
  static ArrayList<Element>[] G=new ArrayList[NN];
  static long z[]=new long[NN];
  static void dfs(int x,int p){
    for(Element e : G[x]){
      if((e.t-p)!=0){
        z[(int)e.t]=z[x]+e.c ;
        dfs((int)e.t,x);
      }
    }
  }
  public static void main(String[] args)throws IOException {
    for(int i=0 ; i<NN ; i++)G[i]=new ArrayList<Element>();
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n-1 ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      G[a] .add(new Element(b,c));
      G[b] .add(new Element(a,c));
    }
    int q=sc.nextInt();
    n=sc.nextInt();
    dfs(n,0);
    for(int j=0 ; j<q ; j++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      out.println(z[a]+z[b]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Element {
   attribute t : long;
   static operation newElement( t : long, c : long) : Element
  pre: true
  post: true
  activity:
  ( var self : Element ;
    self := createElement();
    self.initialise(t, c);
    return self );
  operation initialise( t : long, c : long) : void
  pre: true  post: true
  activity: (     self.t := t ; 
     self.c := c );
}
  static   attribute NN : int := 100007;
  static   attribute G : Sequence(Sequence(Element)) := Integer.subrange(1,NN)->collect(null);
  static   attribute z : long := Integer.subrange(1,NN)->collect(0);
  static   operation dfs( x : int, p : int) : void
  pre: true
  post: true
  activity: (     for (e : G[x+1]) do ( (     if ((e.t - p) /= 0) then (     z[e.t->oclAsType(int)+1] := z[x+1] + e.c ; 
     execute dfs(e.t->oclAsType(int), x) ) else skip )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < NN do (     G[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    G[a+1]->excludes(Element.newElement(b, c)) ; 
    G[b+1]->excludes(Element.newElement(a, c)) ; 
 )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
    n := sc.getCurrent()->toInteger() ; 
    execute dfs(n, 0) ; 
        var j : int ; j := 0 ; while j < q do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     out.println(z[a+1] + z[b+1]) )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.NoSuchElementException ;
import java.io.BufferedReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in))){
      final String s=reader.readLine();
      int N=Integer.parseInt(s);
      System.out.println(checkHarshad(s,N)? "Yes" : "No");
    }
  }
  static boolean checkHarshad(String s,int n){
    int x=0 ;
    for(int i=0 ; i<s.length(); i++)x+=Character.getNumericValue(s.charAt(i));
    return n % x==0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var s : String ; s := reader.readLine() ;
     var N : int ; N := (s)->toInteger() ;
     OclFile["System.out"].println(if checkHarshad(s, N) then "Yes" else "No" endif) ))  );
  static   operation checkHarshad( s : String, n : int) : boolean
  pre: true
  post: true
  activity: (     var x : int ; x := 0 ;
         var i : int ; i := 0 ; while i < s->size() do (     x := x+(("" + s->at(i+1))->toInteger()) ;  ;     i := i + 1 ) ; 
     return n mod x = 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.Spliterator ;
import java.util.Spliterators ;
import java.util.concurrent.ThreadLocalRandom ;
import java.util.concurrent.atomic.AtomicInteger ;
import java.util.stream.IntStream ;
import java.util.stream.Stream ;
import java.util.stream.StreamSupport ;
public class Main {
  static final Scanner s=new Scanner(System.in);
  static final long[] fal_rnd(int size){
    AtomicInteger l=new AtomicInteger(-1),r=new AtomicInteger(size);
    long[] res=new long[size];
    INS(size).unordered().parallel().mapToLong(Long :: parseLong).forEach(v->res[ThreadLocalRandom.current().nextBoolean()? l.incrementAndGet(): r.decrementAndGet()]=v);
    return res ;
  }
  static final IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static final Stream<String>INS(long size){
    return StreamSupport.stream(Spliterators.spliterator(s,size,Spliterator.NONNULL & Spliterator.IMMUTABLE),false).limit(size);
  }
  public static void main(String __[]){
    int d ;
    while(true){
      d=s.nextInt();
      if(d==0)return ;
      long[] in=fal_rnd(d);
      Arrays.parallelSort(in);
      System.out.println(REPS(d-1).mapToLong(i->in[i+1]-in[i]).min().getAsLong());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    operation fal_rnd( size : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var l : int ; l := (-1) ;
    var r : int ; r := (size) ;
     var res : Sequence(long) ; res := Integer.subrange(1,size)->collect(0) ;
     for v : INS(size)->collect( _x1 | (lambda _s : String in _s->toLong())->apply(_x1) ) do
    (    res[if MathLib.nextBoolean() then l+1 else r-1 endif+1] := v) ; 
     return res );
  static    operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static    operation INS( size : long) : Stream<String>
  pre: true
  post: true
  activity: (     return (OclIterator.newOclIterator_Sequence(s)).elements.subrange(1,size) );
  static   operation main( __ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : int ;
     while (true) do (     d := s.getCurrent()->toInteger() ; 
     if (d = 0) then     return else skip ; 
    var in : Sequence(long) ; in := fal_rnd(d) ;
    in := in->sort() ; 
    OclFile["System.out"].println(REPS(d - 1)->collect( _x1 | (lambda i : OclAny in in[i + 1+1] - in[i+1])->apply(_x1) ).min().getAsLong()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  static boolean EQ(double x,double y){
    return Math.abs(x-y)<1.0e-9 ;
  }
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      double[] xs=new double[n],ys=new double[n];
      for(int i=0 ; i<n ; i++){
        xs[i]=sc.nextInt();
        ys[i]=sc.nextInt();
      }
      if(n % 2==0){
        int c=n/2 ;
        double x0=(xs[0]+xs[c])/2 ;
        double y0=(ys[0]+ys[c])/2 ;
        for(int i=1 ; i<c ; i++){
          double x=(xs[i]+xs[c+i])/2 ;
          double y=(ys[i]+ys[c+i])/2 ;
          if(! EQ(x0,x)|| ! EQ(y0,y)){
            System.out.println("NA");
            return ;
          }
        }
        System.out.printf("%.6f %.6f",x0,y0);
      }
      else {
        System.out.println("NA");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation EQ( x : double, y : double) : boolean
  pre: true
  post: true
  activity: (     return if x - y < 0 then -(x - y) else x - y endif < 1.0e-9 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var xs : Sequence(double) ; xs := Integer.subrange(1,n)->collect(0.0) ;
    var ys : Sequence(double) ; ys := Integer.subrange(1,n)->collect(0.0) ;
         var i : int ; i := 0 ; while i < n do ( (     xs[i+1] := sc.getCurrent()->toInteger() ; 
     ys[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     if (n mod 2 = 0) then (     var c : int ; c := n / 2 ;
     var x0 : double ; x0 := (xs[0+1] + xs[c+1]) / 2 ;
    var y0 : double ; y0 := (ys[0+1] + ys[c+1]) / 2 ;
        var i : int ; i := 1 ; while i < c do ( (     var x : double ; x := (xs[i+1] + xs[c + i+1]) / 2 ;
     var y : double ; y := (ys[i+1] + ys[c + i+1]) / 2 ;
     if (not(EQ(x0, x)) or not(EQ(y0, y))) then (     OclFile["System.out"].println("NA") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.6f %.6f", x0, y0) ; 
 ) else (     OclFile["System.out"].println("NA") ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().solveB();
  }
  private void solveA(){
    Scanner scanner=null ;
    int numN=0 ;
    int numA=0 ;
    int numB=0 ;
    try {
      scanner=new Scanner(System.in);
      numN=scanner.nextInt();
      numA=scanner.nextInt();
      numB=scanner.nextInt();
      System.out.println(Math.min(numA*numN,numB));
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
  private void solveB(){
    Scanner scanner=null ;
    int numN=0 ;
    try {
      scanner=new Scanner(System.in);
      numN=scanner.nextInt();
      int digit=0 ;
      int wkNum=numN ;
      while(wkNum>0){
        wkNum/=10 ;
        digit++;
      }
      int res=0 ;
      wkNum=numN ;
      for(int i=0 ; i<digit ; i++){
        res+=wkNum % 10 ;
        wkNum/=10 ;
      }
      if(numN % res==0){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
  private void solveC(){
    Scanner scanner=null ;
    int lineAB=0 ;
    int lineBC=0 ;
    int lineCA=0 ;
    try {
      scanner=new Scanner(System.in);
      lineAB=scanner.nextInt();
      System.out.println("");
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
  private void solveD(){
    Scanner scanner=null ;
    int lineAB=0 ;
    int lineBC=0 ;
    int lineCA=0 ;
    try {
      scanner=new Scanner(System.in);
      lineAB=scanner.nextInt();
      System.out.println("");
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solveB() );
   operation solveA() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var numN : int ; numN := 0 ;
    var numA : int ; numA := 0 ;
    var numB : int ; numB := 0 ;
    try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     numN := scanner.getCurrent()->toInteger() ; 
    numA := scanner.getCurrent()->toInteger() ; 
    numB := scanner.getCurrent()->toInteger() ; 
    OclFile["System.out"].println(Set{numA * numN, numB}->min()) ; 
 )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
   operation solveB() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var numN : int ; numN := 0 ;
     try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     numN := scanner.getCurrent()->toInteger() ; 
    var digit : int ; digit := 0 ;
    var wkNum : int ; wkNum := numN ;
    while (wkNum > 0) do (     wkNum := wkNum/(10) ; 
     digit := digit + 1 ) ; 
    var res : int ; res := 0 ;
    wkNum := numN ; 
        var i : int ; i := 0 ; while i < digit do ( (     res := res+(wkNum mod 10) ; 
     wkNum := wkNum/(10) )  ;     i := i + 1 ) ; 
    if (numN mod res = 0) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
   operation solveC() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var lineAB : int ; lineAB := 0 ;
    var lineBC : int ; lineBC := 0 ;
    var lineCA : int ; lineCA := 0 ;
    try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     lineAB := scanner.getCurrent()->toInteger() ; 
     OclFile["System.out"].println("") )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
   operation solveD() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var lineAB : int ; lineAB := 0 ;
    var lineBC : int ; lineBC := 0 ;
    var lineCA : int ; lineCA := 0 ;
    try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     lineAB := scanner.getCurrent()->toInteger() ; 
     OclFile["System.out"].println("") )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskB solver=new TaskB();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskB {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int sum=0 ;
      int m=n ;
      while(m>0){
        sum+=m % 10 ;
        m/=10 ;
      }
      out.println(n % sum==0 ? "Yes" : "No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskB ; solver := TaskB.newTaskB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskB {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var sum : int ; sum := 0 ;
    var m : int ; m := n ;
    while (m > 0) do (     sum := sum+(m mod 10) ; 
     m := m/(10) ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    char[] c=str.toCharArray();
    int sum=0 ;
    for(int i=0 ; i<c.length ; i++){
      sum+=Integer.parseInt(String.valueOf(c[i]));
    }
    if(Integer.parseInt(str)% sum==0){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var c : Sequence(String) ; c := str->characters() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < c->size() do ( (     sum := sum+((((c[i+1]) + ""))->toInteger()) )  ;     i := i + 1 ) ; 
    if ((str)->toInteger() mod sum = 0) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int sum(int a){
    int ans=0 ;
    while(a>=10){
      ans+=a % 10 ;
      a/=10 ;
    }
    ans+=a ;
    return ans ;
  }
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int N=stdIn.nextInt();
    if(N % sum(N)==0){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation sum( a : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     while (a >= 10) do (     ans := ans+(a mod 10) ; 
     a := a/(10) ) ; 
     ans := ans+(a) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := stdIn.getCurrent()->toInteger() ;
     if (N mod sum(N) = 0) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countNumbers(int n){
    return n-n/2-n/3-n/5-n/7+n/6+n/10+n/14+n/15+n/21+n/35-n/30-n/42-n/70-n/105+n/210 ;
  }
  public static void main(String[] args){
    int n=20 ;
    System.out.println(countNumbers(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countNumbers( n : int) : int
  pre: true
  post: true
  activity: (     return n - n / 2 - n / 3 - n / 5 - n / 7 + n / 6 + n / 10 + n / 14 + n / 15 + n / 21 + n / 35 - n / 30 - n / 42 - n / 70 - n / 105 + n / 210 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 20 ;
     OclFile["System.out"].println(countNumbers(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    sc.close();
    int[] count=new int[4];
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='n')count[0]++;
      if(s.charAt(i)=='i')count[1]++;
      if(s.charAt(i)=='e')count[2]++;
      if(s.charAt(i)=='t')count[3]++;
    }
    count[2]=count[2]/3 ;
    int temp=count[1]<=count[3] ? count[1] : count[3];
    int smallest=temp<=count[2] ? temp : count[2];
    if((count[0]/3)>=smallest)System.out.println(smallest);
    else {
      int ans=0 ;
      if(count[0]>=3){
        ans=((count[0]-3)/2)+1 ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    skip ; 
    var count : Sequence(int) ; count := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'n') then     count[0+1] := count[0+1] + 1 ; else skip ; 
     if (s->at(i+1) = 'i') then     count[1+1] := count[1+1] + 1 ; else skip ; 
     if (s->at(i+1) = 'e') then     count[2+1] := count[2+1] + 1 ; else skip ; 
     if (s->at(i+1) = 't') then     count[3+1] := count[3+1] + 1 ; else skip )  ;     i := i + 1 ) ; 
    count[2+1] := count[2+1] / 3 ; 
    var temp : int ; temp := if count[1+1] <= count[3+1] then count[1+1] else count[3+1] endif ;
    var smallest : int ; smallest := if temp <= count[2+1] then temp else count[2+1] endif ;
    if ((count[0+1] / 3) >= smallest) then     OclFile["System.out"].println(smallest) else (     var ans : int ; ans := 0 ;
     if (count[0+1] >= 3) then (     ans := ((count[0+1] - 3) / 2) + 1 ) else skip ; 
     OclFile["System.out"].println(ans) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    HashMap<String,Integer>map=new HashMap<String,Integer>();
    map.put("N",0);
    map.put("I",0);
    map.put("E",0);
    map.put("T",0);
    String s=sc.next();
    s=s.toUpperCase();
    for(int i=0 ; i<s.length(); i++){
      if(map.containsKey(s.charAt(i)+"")){
        map.put(s.charAt(i)+"",map.get(s.charAt(i)+"")+1);
      }
      else map.put(s.charAt(i)+"",1);
    }
    int no=map.get("N");
    int io=map.get("I");
    int eo=map.get("E");
    int to=map.get("T");
    int min=Integer.MAX_VALUE ;
    if(no>=3){
      if(no>3){
        no--;
        min=no/2 ;
      }
      else {
        min=no/3 ;
      }
      min=Math.min(min,io);
      min=Math.min(min,eo/3);
      min=Math.min(min,to);
    }
    if(min!=Integer.MAX_VALUE)System.out.println(min);
    else System.out.println(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var map : Map(String,int) ; map := Map{} ;
    map := map->union(Map{"N" |-> 0}) ; 
    map := map->union(Map{"I" |-> 0}) ; 
    map := map->union(Map{"E" |-> 0}) ; 
    map := map->union(Map{"T" |-> 0}) ; 
    var s : String ; s := sc.getCurrent() ;
    s := s->toUpperCase() ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     if (map->keys()->includes(s->at(i+1) + "")) then (     map := map->union(Map{s->at(i+1) + "" |-> map->at(s->at(i+1) + "") + 1}) ) else     map := map->union(Map{s->at(i+1) + "" |-> 1}) ; )  ;     i := i + 1 ) ; 
    var no : int ; no := map->at("N") ;
    var io : int ; io := map->at("I") ;
    var eo : int ; eo := map->at("E") ;
    var to : int ; to := map->at("T") ;
    var min : int ; min := 2147483647 ;
    if (no >= 3) then (     if (no > 3) then (     no := no - 1 ; 
     min := no / 2 ) else (     min := no / 3 ) ;  
     min := Set{min, io}->min() ; 
     min := Set{min, eo / 3}->min() ; 
     min := Set{min, to}->min() ) else skip ; 
    if (min /= 2147483647) then     OclFile["System.out"].println(min) else     OclFile["System.out"].println(0) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    HashMap<Character,Integer>hmap=new HashMap<>();
    for(int i=0 ; i<str.length(); i++){
      if(hmap.containsKey(str.charAt(i))){
        hmap.put(str.charAt(i),hmap.get(str.charAt(i))+1);
      }
      else {
        hmap.put(str.charAt(i),1);
      }
    }
    int result=0 ;
    if(hmap.containsKey('n')&& hmap.containsKey('e')&& hmap.containsKey('i')&& hmap.containsKey('t')){
      for(int i=0 ; hmap.get('n')>2 && hmap.get('e')>2 && hmap.get('i')>0 && hmap.get('t')>0 ; i++){
        if(hmap.get('n')>4){
          hmap.put('n',hmap.get('n')-2);
        }
        else {
          hmap.put('n',hmap.get('n')-3);
        }
        hmap.put('e',hmap.get('e')-3);
        hmap.put('i',hmap.get('i')-1);
        hmap.put('t',hmap.get('t')-1);
        result++;
      }
    }
    System.out.print(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var hmap : Map(String,int) ; hmap := Map{} ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (hmap->keys()->includes(str->at(i+1))) then (     hmap := hmap->union(Map{str->at(i+1) |-> hmap->at(str->at(i+1)) + 1}) ) else (     hmap := hmap->union(Map{str->at(i+1) |-> 1}) ) )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
    if (hmap->keys()->includes('n') & hmap->keys()->includes('e') & hmap->keys()->includes('i') & hmap->keys()->includes('t')) then (         var i : int ; i := 0 ; while hmap->at('n') > 2 & hmap->at('e') > 2 & hmap->at('i') > 0 & hmap->at('t') > 0 do ( (     if (hmap->at('n') > 4) then (     hmap := hmap->union(Map{'n' |-> hmap->at('n') - 2}) ) else (     hmap := hmap->union(Map{'n' |-> hmap->at('n') - 3}) ) ;  
     hmap := hmap->union(Map{'e' |-> hmap->at('e') - 3}) ; 
    hmap := hmap->union(Map{'i' |-> hmap->at('i') - 1}) ; 
    hmap := hmap->union(Map{'t' |-> hmap->at('t') - 1}) ; 
    result := result + 1 ; 
 )  ;     i := i + 1 ) ) else skip ; 
    OclFile["System.out"].print(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class nineteen {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int n=0 ;
    int t=0 ;
    int e=0 ;
    int i=0 ;
    for(int k=0 ; k<s.length(); k++){
      if(s.charAt(k)=='n')n++;
      else if(s.charAt(k)=='i')i++;
      else if(s.charAt(k)=='t')t++;
      else if(s.charAt(k)=='e')e++;
    }
    n=(n-1)/2 ;
    e/=3 ;
    t/=1 ;
    i/=1 ;
    int ans=Math.min(n,Math.min(e,Math.min(t,i)));
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class nineteen {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var n : int ; n := 0 ;
    var t : int ; t := 0 ;
    var e : int ; e := 0 ;
    var i : int ; i := 0 ;
        var k : int ; k := 0 ; while k < s->size() do ( (     if (s->at(k+1) = 'n') then     n := n + 1 ; else     if (s->at(k+1) = 'i') then     i := i + 1 else     if (s->at(k+1) = 't') then     t := t + 1 else     if (s->at(k+1) = 'e') then     e := e + 1 ; else skip ; ;  ;  )  ;     k := k + 1 ) ; 
    n := ((n)->char2byte() - 1) / 2 ; 
    e := e/(3) ; 
    t := t/(1) ; 
    i := i/(1) ; 
    var ans : int ; ans := Set{n, Set{e, Set{t, i}->min()}->min()}->min() ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  private java.util.Scanner sc ;
  private java.io.PrintStream out ;
  public Main(java.io.InputStream in,java.io.PrintStream out){
    this.sc=new java.util.Scanner(in);
    this.out=out ;
  }
  public void run(){
    for(; ; ){
      final int n=sc.nextInt();
      if(n==0)break ;
      final int[] d=new int[n];
      for(int i=0 ; i<n ; ++i)d[i]=sc.nextInt();
      int rval=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; ++i)for(int j=i+1 ; j<n ; ++j){
        rval=Math.min(rval,Math.abs(d[i]-d[j]));
      }
      out.println(rval);
    }
  }
  public static void main(String[] args){
(new Main(System.in,System.out)).run();
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   attribute sc : Scanner;
   attribute out : PrintStream;
   static operation newMain( in : InputStream, out : PrintStream) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(in, out);
    return self );
  operation initialise( in : InputStream, out : PrintStream) : void
  pre: true  post: true
  activity: (     self.sc := Scanner.newScanner(in) ; 
     self.out := out );
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.nextInt() ;
     if (n = 0) then     break else skip ; 
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     d[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
    var rval : int ; rval := 2147483647 ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do ( (     rval := Set{rval, if d[i+1] - d[j+1] < 0 then -(d[i+1] - d[j+1]) else d[i+1] - d[j+1] endif}->min() )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    out.println(rval) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain(OclFile["System.in"], OclFile["System.out"])).run() );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Map<Character,Integer>mp=new HashMap<>();
    mp.put('n',0);
    mp.put('i',0);
    mp.put('e',0);
    mp.put('t',0);
    Scanner scanner=new Scanner(System.in);
    String txt=scanner.next();
    for(int i=0 ; i<txt.length(); i++)if(mp.containsKey(txt.charAt(i)))mp.put(txt.charAt(i),mp.get(txt.charAt(i))+1);
    if(mp.get('i')==0 || mp.get('n')<=2 || mp.get('e')<=2 || mp.get('t')==0)System.out.println(0);
    else {
      int min=Math.min(mp.get('i'),mp.get('t'));
      min=Math.min(min,mp.get('e')/3);
      min=(int)Math.min(min,Math.ceil((double)mp.get('n')/2)-1);
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mp : Map(String,int) ; mp := Map{} ;
     mp := mp->union(Map{'n' |-> 0}) ; 
    mp := mp->union(Map{'i' |-> 0}) ; 
    mp := mp->union(Map{'e' |-> 0}) ; 
    mp := mp->union(Map{'t' |-> 0}) ; 
    var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var txt : String ; txt := scanner.getCurrent() ;
        var i : int ; i := 0 ; while i < txt->size() do (     if (mp->keys()->includes(txt->at(i+1))) then     mp := mp->union(Map{txt->at(i+1) |-> mp->at(txt->at(i+1)) + 1}) ; else skip ;  ;     i := i + 1 ) ; 
    if (mp->at('i') = 0 or mp->at('n') <= 2 or mp->at('e') <= 2 or mp->at('t') = 0) then     OclFile["System.out"].println(0) else (     var min : int ; min := Set{mp->at('i'), mp->at('t')}->min() ;
     min := Set{min, mp->at('e') / 3}->min() ; 
     min := Set{min, (mp->at('n')->oclAsType(double) / 2)->ceil() - 1}->min()->oclAsType(int) ; 
     OclFile["System.out"].println(min) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    double[] A=new double[N];
    for(int i=0 ; i<N ; ++i){
      A[i]=sc.nextDouble();
    }
    final int MAX=300001 ;
    double[][] dp=new double[2][MAX];
    for(int i=1 ; i<MAX ; ++i){
      dp[0][i]=Math.abs(A[0]-i)/A[0];
    }
    for(int i=1 ; i<N ; ++i){
      int t=i & 1 ;
      Arrays.fill(dp[t],1e9);
      for(int j=1 ; j<MAX ; ++j){
        for(int k=j ; k<MAX ; k+=j){
          dp[t][k]=Math.min(dp[t][k],Math.max(dp[1-t][j],Math.abs(A[i]-k)/A[i]));
        }
      }
    }
    double ans=1e9 ;
    for(int i=1 ; i<MAX ; ++i){
      ans=Math.min(ans,dp[1-N & 1][i]);
    }
    System.out.printf("%.9f\n",ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var A : Sequence(double) ; A := Integer.subrange(1,N)->collect(0.0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
    var MAX : int ; MAX := 300001 ;
    var dp : Sequence(Sequence(double)) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,MAX)->collect(0.0)) ;
        var i : int ; i := 1 ; while i < MAX do ( (     dp[0+1][i+1] := if A[0+1] - i < 0 then -(A[0+1] - i) else A[0+1] - i endif / A[0+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < N do ( (     var t : int ; t := MathLib.bitwiseAnd(i,1) ;
     dp[t+1] := dp[t+1]->collect(1e9) ; 
         var j : int ; j := 1 ; while j < MAX do ( (         var k : int ; k := j ; while k < MAX do ( (     dp[t+1][k+1] := Set{dp[t+1][k+1], Set{dp[1 - t+1][j+1], if A[i+1] - k < 0 then -(A[i+1] - k) else A[i+1] - k endif / A[i+1]}->max()}->min() )  ;     k := k+(j) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : double ; ans := 1e9 ;
        var i : int ; i := 1 ; while i < MAX do ( (     ans := Set{ans, dp[MathLib.bitwiseAnd(1 - N,1)+1][i+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.9f\n", ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static void sumSubsets(int set[],int n,int target){
    int x[]=new int[set.length];
    int j=set.length-1 ;
    while(n>0){
      x[j]=n % 2 ;
      n=n/2 ;
      j--;
    }
    int sum=0 ;
    for(int i=0 ; i<set.length ; i++)if(x[i]==1)sum=sum+set[i];
    if(sum==target){
      System.out.print("{");
      for(int i=0 ; i<set.length ; i++)if(x[i]==1)System.out.print(set[i]+",");
      System.out.print("},");
    }
  }
  public static void findSubsets(int[] arr,int K){
    int x=(int)Math.pow(2,arr.length);
    for(int i=1 ; i<x ; i++)sumSubsets(arr,i,K);
  }
  public static void main(String args[]){
    int arr[]={
      5,10,12,13,15,18 };
      int K=30 ;
      findSubsets(arr,K);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumSubsets( set : Sequence(int), n : int, target : int) : void
  pre: true
  post: true
  activity: (     var x : Sequence(int) ; x := Integer.subrange(1,set->size())->collect(0) ;
     var j : int ; j := set->size() - 1 ;
    while (n > 0) do (     x[j+1] := n mod 2 ; 
     n := n / 2 ; 
     j := j - 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < set->size() do (     if (x[i+1] = 1) then     sum := sum + set[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    if (sum = target) then (     OclFile["System.out"].print("{") ; 
         var i : int ; i := 0 ; while i < set->size() do (     if (x[i+1] = 1) then     OclFile["System.out"].print(set[i+1] + ",") ; else skip ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("},") ) else skip ; 
 );
  static   operation findSubsets( arr : Sequence(int), K : int) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 2->pow(arr->size())->oclAsType(int) ;
         var i : int ; i := 1 ; while i < x do (     execute sumSubsets(arr, i, K) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,10,12,13,15,18} ;
     var K : int ; K := 30 ;
     execute findSubsets(arr, K) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder();
    long n=fs.nextLong(),m=fs.nextLong(),a=fs.nextLong();
    out.print(((n+a-1)/a)*((m+a-1)/a));
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    Long[] readArray(int n){
      Long[] a=new Long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    var n : long ; n := fs.nextLong() ;
    var m : long ; m := fs.nextLong() ;
    var a : long ; a := fs.nextLong() ;
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int m=s.nextInt();
    int a=s.nextInt();
    int na=n/a ;
    if(n % a!=0)na++;
    int ma=m/a ;
    if(m % a!=0)ma++;
    System.out.println((long)na*ma);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var m : int ; m := s.getCurrent()->toInteger() ;
    var a : int ; a := s.getCurrent()->toInteger() ;
    var na : int ; na := n / a ;
    if (n mod a /= 0) then     na := na + 1 ; else skip ; 
    var ma : int ; ma := m / a ;
    if (m mod a /= 0) then     ma := ma + 1 ; else skip ; 
    OclFile["System.out"].println(na->oclAsType(long) * ma) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TheatreSquare {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int a=sc.nextInt();
    long x=n/a,y=m/a ;
    if(n % a!=0)x+=1 ;
    if(m % a!=0)y+=1 ;
    System.out.println(x*y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class TheatreSquare {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var x : long ; x := n / a ;
    var y : long ; y := m / a ;
    if (n mod a /= 0) then     x := x+(1) ; else skip ; 
    if (m mod a /= 0) then     y := y+(1) ; else skip ; 
    OclFile["System.out"].println(x * y) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Theatre_Square {
  public static void main(String[] args){
    Scanner entrada=new Scanner(System.in);
    int n=entrada.nextInt();
    int m=entrada.nextInt();
    int a=entrada.nextInt();
    long l=(n+a-1)/a ;
    long r=(m+a-1)/a ;
    System.out.println(l*r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Theatre_Square {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var entrada : OclFile ; entrada := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := entrada.getCurrent()->toInteger() ;
    var m : int ; m := entrada.getCurrent()->toInteger() ;
    var a : int ; a := entrada.getCurrent()->toInteger() ;
    var l : long ; l := (n + a - 1) / a ;
    var r : long ; r := (m + a - 1) / a ;
    OclFile["System.out"].println(l * r) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int a=sc.nextInt();
    long l=(long)Math.ceil(1.0*n/a);
    long b=(long)Math.ceil(1.0*m/a);
    System.out.println(l*b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var l : long ; l := (1.0 * n / a)->ceil()->oclAsType(long) ;
    var b : long ; b := (1.0 * m / a)->ceil()->oclAsType(long) ;
    OclFile["System.out"].println(l * b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPower(int x,int y){
    int res1=(int)(Math.log(y)/Math.log(x));
    double res2=Math.log(y)/Math.log(x);
    return(res1==res2);
  }
  static int countPower(int arr[],int n){
    int res=0 ;
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++)if(isPower(arr[i],arr[j])|| isPower(arr[j],arr[i]))res++;
    return res ;
  }
  public static void main(String[] args){
    int a[]={
      16,2,3,9 };
      int n=a.length ;
      System.out.println(countPower(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPower( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     var res1 : int ; res1 := ((y)->log() / (x)->log())->oclAsType(int) ;
     var res2 : double ; res2 := (y)->log() / (x)->log() ;
     return (res1 = res2) );
  static   operation countPower( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do (     if (isPower(arr[i+1], arr[j+1]) or isPower(arr[j+1], arr[i+1])) then     res := res + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{16,2,3,9} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(countPower(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findNumberOfDigits(long n,int base){
    int dig=(int)(Math.floor(Math.log(n)/Math.log(base))+1);
    System.out.println("The Number of digits of Number "+n+" in base "+base+" is "+dig);
  }
  public static void main(String[] args){
    long n=1446 ;
    int base=7 ;
    findNumberOfDigits(n,base);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNumberOfDigits( n : long, base : int) : void
  pre: true
  post: true
  activity: (     var dig : int ; dig := (((n)->log() / (base)->log())->floor() + 1)->oclAsType(int) ;
     OclFile["System.out"].println("The Number of digits of Number " + n + " in base " + base + " is " + dig) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 1446 ;
     var base : int ; base := 7 ;
     execute findNumberOfDigits(n, base) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner inp=new Scanner(System.in);
  static int a[]=new int[100000];
  public static void sort(int x,int y){
    int l=x ;
    int r=y ;
    int m=a[(l+r)/2];
    while(l<r){
      while(a[l]<m)l++;
      while(a[r]>m)r--;
      if(l<=r){
        int z=a[l];
        a[l]=a[r];
        a[r]=z ;
        l++;
        r--;
      }
    }
    if(l<y)sort(l,y);
    if(r>x)sort(x,r);
  }
  public static void main(String args[]){
    int n=inp.nextInt();
    while(n>0){
      for(int i=1 ; i<=n ; i++)a[i]=inp.nextInt();
      sort(1,n);
      int ans=100000000 ;
      for(int i=2 ; i<=n ; i++)if(a[i]-a[i-1]<ans)ans=a[i]-a[i-1];
      n=inp.nextInt();
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute inp : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute a : int := Integer.subrange(1,100000)->collect(0);
  static   operation sort( x : int, y : int) : void
  pre: true
  post: true
  activity: (     var l : int ; l := x ;
     var r : int ; r := y ;
    var m : int ; m := a[(l + r) / 2+1] ;
    while (l < r) do (     while (a[l+1] < m) do     l := l + 1 ; ; 
     while (a[r+1] > m) do     r := r - 1 ; ; 
     if (l <= r) then (     var z : int ; z := a[l+1] ;
     a[l+1] := a[r+1] ; 
    a[r+1] := z ; 
    l := l + 1 ; 
    r := r - 1 ; 
 ) else skip ) ; 
    if (l < y) then     execute sort(l, y) ; else skip ; 
    if (r > x) then     execute sort(x, r) ; else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := inp.getCurrent()->toInteger() ;
     while (n > 0) do (         var i : int ; i := 1 ; while i <= n do (     a[i+1] := inp.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
     execute sort(1, n) ; 
    var ans : int ; ans := 100000000 ;
        var i : int ; i := 2 ; while i <= n do (     if (a[i+1] - a[i - 1+1] < ans) then     ans := a[i+1] - a[i - 1+1] ; else skip ;  ;     i := i + 1 ) ; 
    n := inp.getCurrent()->toInteger() ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  public static void PrintNumber(int N,int Original,int K,boolean flag){
    System.out.print(N+" ");
    if(N<=0)flag=! flag ;
    if(N==Original && ! flag)return ;
    if(flag==true){
      PrintNumber(N-K,Original,K,flag);
      return ;
    }
    if(! flag){
      PrintNumber(N+K,Original,K,flag);
      return ;
    }
  }
  public static void main(String[] args){
    int N=20,K=6 ;
    PrintNumber(N,N,K,true);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation PrintNumber( N : int, Original : int, K : int, flag : boolean) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(N + " ") ; 
     if (N <= 0) then     flag := not(flag) ; else skip ; 
    if (N = Original & not(flag)) then     return else skip ; 
    if (flag = true) then (     execute PrintNumber(N - K, Original, K, flag) ; 
     return ) else skip ; 
    if (not(flag)) then (     execute PrintNumber(N + K, Original, K, flag) ; 
     return ) else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 20 ;
    var K : int ; K := 6 ;
     execute PrintNumber(N, N, K, true) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void twistedTOH(int n,char first,char middle,char last){
    if(n==1){
      System.out.println("Move disk "+n+" from rod "+first+" to "+middle+" and then to "+last);
      return ;
    }
    twistedTOH(n-1,first,middle,last);
    System.out.println("Move disk "+n+" from rod "+first+" to "+middle);
    twistedTOH(n-1,last,middle,first);
    System.out.println("Move disk "+n+" from rod "+middle+" to "+last);
    twistedTOH(n-1,first,middle,last);
  }
  public static void main(String[] args){
    int n=2 ;
    twistedTOH(n,'A','B','C');
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation twistedTOH( n : int, first : String, middle : String, last : String) : void
  pre: true
  post: true
  activity: (     if (n = 1) then (     OclFile["System.out"].println("Move disk " + n + " from rod " + first + " to " + middle + " and then to " + last) ; 
     return ) else skip ; 
     execute twistedTOH(n - 1, first, middle, last) ; 
    OclFile["System.out"].println("Move disk " + n + " from rod " + first + " to " + middle) ; 
    execute twistedTOH(n - 1, last, middle, first) ; 
    OclFile["System.out"].println("Move disk " + n + " from rod " + middle + " to " + last) ; 
    execute twistedTOH(n - 1, first, middle, last) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     execute twistedTOH(n, 'A', 'B', 'C') );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static int AMAX=200000 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    double[][] dp=new double[n+1][AMAX+1];
    for(int i=0 ; i<=n ; i++){
      Arrays.fill(dp[i],Double.POSITIVE_INFINITY);
    }
    dp[0][1]=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=1 ; j<=AMAX ; j++){
        if(dp[i][j]>=Double.POSITIVE_INFINITY){
          continue ;
        }
        for(int k=j ; k<=AMAX ; k+=j){
          dp[i+1][k]=Math.min(dp[i+1][k],Math.max(dp[i][j],(double)Math.abs(a[i]-k)/a[i]));
        }
      }
    }
    double ans=Double.POSITIVE_INFINITY ;
    for(int i=1 ; i<=AMAX ; i++){
      ans=Math.min(ans,dp[n][i]);
    }
    System.out.println(String.format("%.9f",ans));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute AMAX : int := 200000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(double)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,AMAX + 1)->collect(0.0)) ;
        var i : int ; i := 0 ; while i <= n do ( (     dp[i+1] := dp[i+1]->collect(Math_PINFINITY) )  ;     i := i + 1 ) ; 
    dp[0+1][1+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 1 ; while j <= AMAX do ( (     if (dp[i+1][j+1] >= Math_PINFINITY) then (     continue ) else skip ; 
         var k : int ; k := j ; while k <= AMAX do ( (     dp[i + 1+1][k+1] := Set{dp[i + 1+1][k+1], Set{dp[i+1][j+1], if a[i+1] - k < 0 then -(a[i+1] - k) else a[i+1] - k endif->oclAsType(double) / a[i+1]}->max()}->min() )  ;     k := k+(j) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : double ; ans := Math_PINFINITY ;
        var i : int ; i := 1 ; while i <= AMAX do ( (     ans := Set{ans, dp[n+1][i+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(StringLib.format("%.9f",Sequence{ans})) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static char[] stack ;
  static int top=-1 ;
  static void push(char ele){
    stack[++top]=ele ;
  }
  static char pop(){
    return stack[top--];
  }
  static int isPalindrome(char str[]){
    int length=str.length ;
    stack=new char[length*4];
    int i,mid=length/2 ;
    for(i=0 ; i<mid ; i++){
      push(str[i]);
    }
    if(length % 2!=0){
      i++;
    }
    while(i<length){
      char ele=pop();
      if(ele!=str[i])return 0 ;
      i++;
    }
    return 1 ;
  }
  public static void main(String[] args){
    char str[]="madam".toCharArray();
    if(isPalindrome(str)==1){
      System.out.printf("Yes");
    }
    else {
      System.out.printf("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute stack : Sequence(String);
  static   attribute top : int := -1;
  static   operation push( ele : String) : void
  pre: true
  post: true
  activity: (         top := top + 1 ;
 stack[top+1] := ele  );
  static   operation pop() : String
  pre: true
  post: true
  activity: (     return stack[top+1] );
  static   operation isPalindrome( str : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var length : int ; length := str->size() ;
     stack := Integer.subrange(1,length * 4)->collect(0) ; 
    var i : int ;
    var mid : int ; mid := length / 2 ;
        i := 0 ; while i < mid do ( (     execute push(str[i+1]) )  ;     i := i + 1 ) ; 
    if (length mod 2 /= 0) then (     i := i + 1 ) else skip ; 
    while (i < length) do (     var ele : String ; ele := pop() ;
     if (ele /= str[i+1]) then     return 0 else skip ; 
     i := i + 1 ) ; 
    return 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := "madam"->characters() ;
     if (isPalindrome(str) = 1) then (     OclFile["System.out"].printf("Yes") ) else (     OclFile["System.out"].printf("No") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long k=sc.nextLong();
    long count=0 ;
    int ans=0 ;
    long[] in=new long[100000];
    int a ;
    long b ;
    for(int i=0 ; i<n ; i++){
      a=sc.nextInt();
      b=sc.nextLong();
      in[a-1]+=b ;
    }
    for(int i=0 ; i<100000 ; i++){
      count+=in[i];
      if(count>=k){
        ans=i+1 ;
        break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var count : long ; count := 0 ;
    var ans : int ; ans := 0 ;
    var in : Sequence(long) ; in := Integer.subrange(1,100000)->collect(0) ;
    var a : int ;
    var b : long ;
        var i : int ; i := 0 ; while i < n do ( (     a := sc.getCurrent()->toInteger() ; 
     b := sc.getCurrent()->toLong() ; 
     in[a - 1+1] := in[a - 1+1]+(b) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 100000 do ( (     count := count+(in[i+1]) ; 
     if (count >= k) then (     ans := i + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  int n ;
  long k ;
  SortedSet<Integer>set ;
  Map<Integer,Long>map ;
  public static void main(String args[]){
    new Main().run();
  }
  void run(){
    FastReader sc=new FastReader();
    n=sc.nextInt();
    k=sc.nextLong();
    set=new TreeSet<>();
    map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      long b=sc.nextInt();
      set.add(a);
      if(map.containsKey(a)){
        map.put(a,map.get(a)+b);
      }
      else {
        map.put(a,b);
      }
    }
    solve();
  }
  void solve(){
    long count=0 ;
    Iterator<Integer>it=set.iterator();
    while(it.hasNext()){
      int key=it.next();
      long value=map.get(key);
      long newCount=count+value ;
      if(k<=newCount){
        System.out.println(key);
        return ;
      }
      else {
        count=newCount ;
      }
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute k : long;
   attribute set : Set(int);
   attribute map : Map(int,long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     n := sc.nextInt() ; 
    k := sc.nextLong() ; 
    set := Set{} ; 
    map := Map{} ; 
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.nextInt() ;
     var b : long ; b := sc.nextInt() ;
     set := set->including(a) ; 
     if (map->keys()->includes(a)) then (     map := map->union(Map{a |-> map->at(a) + b}) ) else (     map := map->union(Map{a |-> b}) ) )  ;     i := i + 1 ) ; 
    execute solve() ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
     var it : OclIterator ; it := set->iterator() ;
     while (it.hasNext()) do (     var key : int ; key := it.next() ;
     var value : long ; value := map->at(key) ;
     var newCount : long ; newCount := count + value ;
     if (k <= newCount) then (     OclFile["System.out"].println(key) ; 
     return ) else (     count := newCount ) ) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.net.StandardSocketOptions ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
import java.util.TreeSet ;
import org.omg.Messaging.SyncScopeHelper ;
import org.omg.PortableInterceptor.SYSTEM_EXCEPTION ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new Test_300().doIt();
  }
  class Test_300 {
    void doIt(){
      int N=sc.nextInt();
      long K=sc.nextLong();
      long A[]=new long[100002];
      for(int i=0 ; i<N ; i++){
        int a=sc.nextInt();
        long b=sc.nextLong();
        A[a]=A[a]+b ;
      }
      long cnt=0 ;
      for(int i=0 ; i<100002 ; i++){
        cnt=cnt+A[i];
        if(cnt>=K){
          System.out.println(i);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     Test_300.newTest_300().doIt() );
 class Test_300 {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var K : long ; K := sc.getCurrent()->toLong() ;
    var A : Sequence(long) ; A := Integer.subrange(1,100002)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
     A[a+1] := A[a+1] + b )  ;     i := i + 1 ) ; 
    var cnt : long ; cnt := 0 ;
        var i : int ; i := 0 ; while i < 100002 do ( (     cnt := cnt + A[i+1] ; 
     if (cnt >= K) then (     OclFile["System.out"].println(i) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String[] param=scan.nextLine().split(" ");
    long n=Long.parseLong(param[0]);
    long k=Long.parseLong(param[1]);
    ArrayList<Element>e=new ArrayList<Element>();
    for(int i=0 ; i<n ; i++){
      String[] elem=scan.nextLine().split(" ");
      e.add(new Element(Long.parseLong(elem[0]),Long.parseLong(elem[1])));
    }
    Collections.sort(e);
    long minNum=0 ;
    long m=0 ;
    for(Element el : e){
      if(m<k && m+el.b>=k){
        minNum=el.a ;
      }
      m+=el.b ;
    }
    System.out.println(minNum);
  }
}
class Element implements Comparable<Element>{
  public long a ;
  public long b ;
  public Element(long a,long b){
    this.a=a ;
    this.b=b ;
  }
  public int compareTo(Element e){
    return this.a>e.a ?+1 : this.a<e.a ?-1 : 0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var param : Sequence(String) ; param := scan.nextLine()->split(" ") ;
    var n : long ; n := (param[0+1])->toLong() ;
    var k : long ; k := (param[1+1])->toLong() ;
    var e : Sequence(Element) ; e := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var elem : Sequence(String) ; elem := scan.nextLine()->split(" ") ;
     e := e->including(Element.newElement((elem[0+1])->toLong(), (elem[1+1])->toLong())) )  ;     i := i + 1 ) ; 
    e := e->sort() ; 
    var minNum : long ; minNum := 0 ;
    var m : long ; m := 0 ;
    for (el : e) do ( (     if (m < k & m + el.b >= k) then (     minNum := el.a ) else skip ; 
     m := m+(el.b) )  ) ; 
    OclFile["System.out"].println(minNum) ; 
 );
}
class Element implements Comparable<Element> {
   attribute a : long;
   attribute b : long;
   static operation newElement( a : long, b : long) : Element
  pre: true
  post: true
  activity:
  ( var self : Element ;
    self := createElement();
    self.initialise(a, b);
    return self );
  operation initialise( a : long, b : long) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
   operation compareTo( e : Element) : int
  pre: true
  post: true
  activity: (     return if self.a > e.a then 1 else if self.a < e.a then -1 else 0 endif endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Map ;
import java.util.Map.Entry ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long k=sc.nextLong();
    Map<Integer,Long>map=new TreeMap<>();
    for(int i=0 ; i<n ; i++){
      int key=sc.nextInt();
      long value=sc.nextInt();
      if(map.containsKey(key)){
        map.put(key,map.get(key)+value);
      }
      else {
        map.put(key,value);
      }
    }
    long sum=k ;
    for(Entry<Integer,Long>entry : map.entrySet()){
      long tmp=entry.getValue();
      if(sum>tmp){
        sum-=tmp ;
      }
      else {
        System.out.println(entry.getKey());
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var map : Map(int,long) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var key : int ; key := sc.getCurrent()->toInteger() ;
     var value : long ; value := sc.getCurrent()->toInteger() ;
     if (map->keys()->includes(key)) then (     map := map->union(Map{key |-> map->at(key) + value}) ) else (     map := map->union(Map{key |-> value}) ) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := k ;
    for (entry : map->asSet()) do ( (     var tmp : long ; tmp := entry.getValue() ;
     if (sum > tmp) then (     sum := sum-(tmp) ) else (     OclFile["System.out"].println(entry.getKey()) ; 
     return ) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean prime[]=new boolean[100005];
  static void SieveOfEratosthenes(int n){
    Arrays.fill(prime,true);
    prime[1]=false ;
    for(int p=2 ; p*p<=n ; p++){
      if(prime[p]){
        for(int i=p*2 ; i<n ; i+=p){
          prime[i]=false ;
        }
      }
    }
  }
  static void sortPrimes(int arr[],int n){
    SieveOfEratosthenes(100005);
    Vector<Integer>v=new Vector<Integer>();
    for(int i=0 ; i<n ; i++){
      if(prime[arr[i] ]){
        v.add(arr[i]);
      }
    }
    Comparator comparator=Collections.reverseOrder();
    Collections.sort(v,comparator);
    int j=0 ;
    for(int i=0 ; i<n ; i++){
      if(prime[arr[i] ]){
        arr[i]=v.get(j++);
      }
    }
  }
  public static void main(String[] args){
    int arr[]={
      4,3,2,6,100,17 };
      int n=arr.length ;
      sortPrimes(arr,n);
      for(int i=0 ; i<n ; i++){
        System.out.print(arr[i]+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute prime : boolean := Integer.subrange(1,100005)->collect(false);
  static   operation SieveOfEratosthenes( n : int) : void
  pre: true
  post: true
  activity: (     prime := prime->collect(true) ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p <= n do ( (     if (prime[p+1]) then (         var i : int ; i := p * 2 ; while i < n do ( (     prime[i+1] := false )  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation sortPrimes( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes(100005) ; 
     var v : Sequence(int) ; v := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (prime[arr[i+1]+1]) then (     v := v->including(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    var comparator : Comparator ; comparator := .reverseOrder() ;
    v, comparator := v, comparator->sort() ; 
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (prime[arr[i+1]+1]) then (     arr[i+1] := v->at(j+1) ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,3,2,6,100,17} ;
     var n : int ; n := arr->size() ;
     execute sortPrimes(arr, n) ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      while(true){
        int parson=Integer.parseInt(reader.readLine());
        if(parson==0)break ;
        String str=reader.readLine();
        String s[]=str.split(" ");
        int seiseki[]=new int[parson];
        ArrayList<Integer>list=new ArrayList<>();
        for(int i=0 ; i<parson ; i++){
          seiseki[i]=Integer.parseInt(s[i]);
        }
        for(int i=0 ; i<parson ; i++){
          for(int j=0 ; j<parson ; j++){
            if(i!=j){
              list.add(Math.abs(seiseki[i]-seiseki[j]));
            }
          }
        }
        System.out.println(Collections.min(list));
      }
      reader.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  static int gcd(int a,int b){
    return b>0 ? gcd(b,a % b): a ;
  }
  static int lcm(int a,int b){
    return a*b/gcd(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     while (true) do (     var parson : int ; parson := (reader.readLine())->toInteger() ;
     if (parson = 0) then     break else skip ; 
    var str : String ; str := reader.readLine() ;
    var s : Sequence(String) ; s := str->split(" ") ;
    var seiseki : Sequence(int) ; seiseki := Integer.subrange(1,parson)->collect(0) ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < parson do ( (     seiseki[i+1] := (s[i+1])->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < parson do ( (         var j : int ; j := 0 ; while j < parson do ( (     if (i /= j) then (     list := list->including(if seiseki[i+1] - seiseki[j+1] < 0 then -(seiseki[i+1] - seiseki[j+1]) else seiseki[i+1] - seiseki[j+1] endif) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(list->min()) ; 
 ) ; 
     skip )   catch (e : IOException) do (     e.printStackTrace() )
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b > 0 then gcd(b, a mod b) else a endif );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return a * b / gcd(a, b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int INT_SIZE=32 ;
  static int getSingle(int arr[],int n){
    int result=0 ;
    int x,sum ;
    for(int i=0 ; i<INT_SIZE ; i++){
      sum=0 ;
      x=(1<<i);
      for(int j=0 ; j<n ; j++){
        if((arr[j] & x)==0)sum++;
      }
      if((sum % 3)==0)result |=x ;
    }
    return result ;
  }
  public static void main(String args[]){
    int arr[]={
      12,1,12,3,12,1,1,2,3,2,2,3,7 };
      int n=arr.length ;
      System.out.println("The element with single occurrence is "+getSingle(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute INT_SIZE : int := 32;
  static   operation getSingle( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var x : int ;
    var sum : int ;
         var i : int ; i := 0 ; while i < INT_SIZE do ( (     sum := 0 ; 
     x := ((1*(2->pow(i)))->oclAsType(long)) ; 
         var j : int ; j := 0 ; while j < n do ( (     if ((arr[j+1] & x) = 0) then     sum := sum + 1 ; else skip )  ;     j := j + 1 ) ; 
     if ((sum mod 3) = 0) then     result := MathLib.bitwiseOr(result, x) ; else skip )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,1,12,3,12,1,1,2,3,2,2,3,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("The element with single occurrence is " + getSingle(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  class R implements Comparable<R>{
    int a,b ;
    public R(int a,int b){
      this.a=a ;
      this.b=b ;
    }
    public int compareTo(R o){
      return b-o.b ;
    }
  }
  int n ;
  void run(){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    R[] r=new R[n];
    for(int i=0 ; i<n ; i++)r[i]=new R(sc.nextInt(),sc.nextInt());
    Arrays.sort(r);
    int[][] dp=new int[n][n+1];
    for(int[] a : dp)Arrays.fill(a,1<<30);
    dp[0][1]=r[0] .a<=r[0] .b ? r[0] .a :(1<<30);
    for(int i=0 ; i<n ; i++)dp[i][0]=0 ;
    for(int i=1 ; i<n ; i++){
      for(int j=1 ; j<=i+1 ; j++){
        if(dp[i-1][j-1]+r[i] .a<=r[i] .b)dp[i][j]=Math.min(Math.min(dp[i][j],dp[i-1][j]),dp[i-1][j-1]+r[i] .a);
        else dp[i][j]=dp[i-1][j];
      }
    }
    for(int j=n ; j>=0 ; j--){
      if(dp[n-1][j]!=1<<30){
        System.out.println(j);
        break ;
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class R implements Comparable<R> {
   attribute a : int;
   static operation newR( a : int, b : int) : R
  pre: true
  post: true
  activity:
  ( var self : R ;
    self := createR();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
   operation compareTo( o : R) : int
  pre: true
  post: true
  activity: (     return b - o.b );
}
   attribute n : int;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    var r : Sequence(R) ; r := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     r[i+1] := R.newR(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    r := r->sort() ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
    for (a : dp) do (     a := a->collect((1*(2->pow(30)))->oclAsType(long)) ;  ) ; 
    dp[0+1][1+1] := if r[0+1].a <= r[0+1].b then r[0+1].a else ((1*(2->pow(30)))->oclAsType(long)) endif ; 
        var i : int ; i := 0 ; while i < n do (     dp[i+1][0+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 1 ; while j <= i + 1 do ( (     if (dp[i - 1+1][j - 1+1] + r[i+1].a <= r[i+1].b) then     dp[i+1][j+1] := Set{Set{dp[i+1][j+1], dp[i - 1+1][j+1]}->min(), dp[i - 1+1][j - 1+1] + r[i+1].a}->min() ; else     dp[i+1][j+1] := dp[i - 1+1][j+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var j : int ; j := n ; while j >= 0 do ( (     if (dp[n - 1+1][j+1] /= (1*(2->pow(30)))->oclAsType(long)) then (     OclFile["System.out"].println(j) ; 
     break ) else skip )  ;     j := j - 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int INF=Integer.MAX_VALUE/2 ;
    int n=sc.nextInt();
    int[] A=new int[n+1];
    int[] B=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      A[i]=sc.nextInt();
      B[i]=sc.nextInt();
    }
    for(int i=1 ; i<=n ; i++){
      int minIdx=i ;
      for(int j=i ; j<=n ; j++){
        if(B[j]<B[minIdx]){
          minIdx=j ;
        }
      }
      int tmp=A[i];
      A[i]=A[minIdx];
      A[minIdx]=tmp ;
      tmp=B[i];
      B[i]=B[minIdx];
      B[minIdx]=tmp ;
    }
    int[][] dp=new int[n+1][n+1];
    for(int i=0 ; i<=n ; i++)Arrays.fill(dp[i],INF);
    dp[0][0]=0 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=0 ; j<=n ; j++){
        int sum=A[i];
        if(j!=0)sum+=dp[i-1][j-1];
        if(sum<=B[i])dp[i][j]=Math.min(dp[i][j],sum);
        dp[i][j]=Math.min(dp[i][j],dp[i-1][j]);
      }
    }
    int max=0 ;
    for(int i=0 ; i<=n ; i++){
      if(dp[n][i]!=INF)max=i ;
    }
    System.out.println(max);
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var INF : int ; INF := 2147483647 / 2 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,n + 1)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     A[i+1] := sc.getCurrent()->toInteger() ; 
     B[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     var minIdx : int ; minIdx := i ;
         var j : int ; j := i ; while j <= n do ( (     if (B[j+1] < B[minIdx+1]) then (     minIdx := j ) else skip )  ;     j := j + 1 ) ; 
    var tmp : int ; tmp := A[i+1] ;
    A[i+1] := A[minIdx+1] ; 
    A[minIdx+1] := tmp ; 
    tmp := B[i+1] ; 
    B[i+1] := B[minIdx+1] ; 
    B[minIdx+1] := tmp ; 
 )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i <= n do (     dp[i+1] := dp[i+1]->collect(INF) ;  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= n do ( (     var sum : int ; sum := A[i+1] ;
     if (j /= 0) then     sum := sum+(dp[i - 1+1][j - 1+1]) ; else skip ; 
     if (sum <= B[i+1]) then     dp[i+1][j+1] := Set{dp[i+1][j+1], sum}->min() ; else skip ; 
     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i - 1+1][j+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i <= n do ( (     if (dp[n+1][i+1] /= INF) then     max := i ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  final double MAX=Double.MAX_VALUE/4 ;
  final double EPS=1e-8 ;
  double[] in ;
  void run(){
    int n=sc.nextInt();
    in=new double[n];
    for(int i=0 ; i<n ; i++){
      in[i]=sc.nextInt();
    }
    n++;
    double dp[][]=new double[123456][n];
    for(int i=0 ; i<123455 ; i++){
      Arrays.fill(dp[i],-MAX);
    }
    dp[1][0]=0 ;
    for(int i=1 ; i<n ; i++){
      for(int j=0 ; j<123400 ; j++){
        if(dp[j][i-1]>=0){
          for(int jj=j ; jj<123400 ; jj+=j){
            double temp=Math.max(dp[j][i-1],Math.abs(jj-in[i-1])/in[i-1]);
            if(dp[jj][i]<0){
              dp[jj][i]=temp ;
            }
            dp[jj][i]=Math.min(dp[jj][i],temp);
          }
        }
      }
    }
    double ans=MAX ;
    for(int i=0 ; i<123450 ; i++){
      if(dp[i][n-1]>=0){
        ans=Math.min(dp[i][n-1],ans);
      }
    }
    System.out.printf("%.9f\n",ans);
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute MAX : double := (2 - 2->pow(-52))*(2->pow(1023)) / 4;
   attribute EPS : double := 1e-8;
   attribute in : Sequence(double);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     in := Integer.subrange(1,n)->collect(0.0) ; 
        var i : int ; i := 0 ; while i < n do ( (     in[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    n := n + 1 ; 
    var dp : Sequence(Sequence(double)) ; dp := Integer.subrange(1,123456)->collect(Integer.subrange(1,n)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < 123455 do ( (     dp[i+1] := dp[i+1]->collect(-MAX) )  ;     i := i + 1 ) ; 
    dp[1+1][0+1] := 0 ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 0 ; while j < 123400 do ( (     if (dp[j+1][i - 1+1] >= 0) then (         var jj : int ; jj := j ; while jj < 123400 do ( (     var temp : double ; temp := Set{dp[j+1][i - 1+1], if jj - in[i - 1+1] < 0 then -(jj - in[i - 1+1]) else jj - in[i - 1+1] endif / in[i - 1+1]}->max() ;
     if (dp[jj+1][i+1] < 0) then (     dp[jj+1][i+1] := temp ) else skip ; 
     dp[jj+1][i+1] := Set{dp[jj+1][i+1], temp}->min() )  ;     jj := jj+(j) ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : double ; ans := MAX ;
        var i : int ; i := 0 ; while i < 123450 do ( (     if (dp[i+1][n - 1+1] >= 0) then (     ans := Set{dp[i+1][n - 1+1], ans}->min() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.9f\n", ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int n ;
  int[][] ab ;
  void solve(){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    ab=new int[n][2];
    for(int i=0 ; i<n ; i++){
      ab[i][0]=sc.nextInt();
      ab[i][1]=sc.nextInt();
    }
    Arrays.sort(ab,new Comparator<int[]>(){
      public int compare(int[] a,int[] b){
        return a[1]-b[1];
      }
    }
);
    PriorityQueue<Integer>q=new PriorityQueue<Integer>(n,new Comparator<Integer>(){
      public int compare(Integer a,Integer b){
        return b-a ;
      }
    }
);
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      q.add(ab[i][0]);
      sum+=ab[i][0];
      if(sum>ab[i][1])sum-=q.poll();
    }
    System.out.println(q.size());
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute ab : Sequence(Sequence(int));
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    ab := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ; 
        var i : int ; i := 0 ; while i < n do ( (     ab[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     ab[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    ab := OclComparator.sortWith(ab, OclComparator<Sequence(int)>.newOclComparator()) ; 
    var q : Sequence(int) ; q := Sequence{} ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     q := q->including(ab[i+1][0+1]) ; 
     sum := sum+(ab[i+1][0+1]) ; 
     if (sum > ab[i+1][1+1]) then     sum := sum - (q->min()) ;     q := q->sort()->tail() ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(q->size()) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    P[] p=new P[N];
    for(int i=0 ; i<N ; ++i){
      int a=sc.nextInt();
      int b=sc.nextInt();
      p[i]=new P(a,b);
    }
    Arrays.sort(p);
    int[][] dp=new int[N+1][N+1];
    final int INF=1<<30 ;
    for(int[] a : dp){
      Arrays.fill(a,INF);
    }
    dp[0][0]=0 ;
    for(int i=0 ; i<N ; ++i){
      for(int j=0 ; j<N ; ++j){
        if(dp[i][j]!=INF){
          dp[i+1][j]=Math.min(dp[i+1][j],dp[i][j]);
          if(dp[i][j]+p[i] .a<=p[i] .b){
            dp[i+1][j+1]=Math.min(dp[i+1][j+1],dp[i][j]+p[i] .a);
          }
        }
      }
    }
    int ans=0 ;
    for(int i=0 ; i<=N ; ++i){
      for(int j=0 ; j<=N ; ++j){
        if(dp[i][j]!=INF){
          ans=Math.max(ans,j);
        }
      }
    }
    System.out.println(ans);
  }
  static class P implements Comparable<P>{
    int a,b ;
    P(int a,int b){
      this.a=a ;
      this.b=b ;
    }
    public int compareTo(P o){
      return this.b-o.b ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var p : Sequence(P) ; p := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     p[i+1] := P.newP(a, b) )  ;     i := i + 1 ) ; 
    p := p->sort() ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
    var INF : int ; INF := (1*(2->pow(30)))->oclAsType(long) ;
    for (a : dp) do ( (     a := a->collect(INF) )  ) ; 
    dp[0+1][0+1] := 0 ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     if (dp[i+1][j+1] /= INF) then (     dp[i + 1+1][j+1] := Set{dp[i + 1+1][j+1], dp[i+1][j+1]}->min() ; 
     if (dp[i+1][j+1] + p[i+1].a <= p[i+1].b) then (     dp[i + 1+1][j + 1+1] := Set{dp[i + 1+1][j + 1+1], dp[i+1][j+1] + p[i+1].a}->min() ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i <= N do ( (         var j : int ; j := 0 ; while j <= N do ( (     if (dp[i+1][j+1] /= INF) then (     ans := Set{ans, j}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class P implements Comparable<P> {
   attribute a : int;
   static operation newP( a : int, b : int) : P
  pre: true
  post: true
  activity:
  ( var self : P ;
    self := createP();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
   operation compareTo( o : P) : int
  pre: true
  post: true
  activity: (     return self.b - o.b );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Question[] questions=new Question[n];
    for(int i=0 ; i<n ; i++){
      questions[i]=new Question(sc.nextInt(),sc.nextInt());
    }
    Arrays.sort(questions);
    int max=0 ;
    int[] dp=new int[n+1];
    Arrays.fill(dp,Integer.MAX_VALUE);
    dp[0]=0 ;
    for(Question q : questions){
      for(int i=max ; i>=0 ; i--){
        if(dp[i]+q.mine<=q.other){
          dp[i+1]=Math.min(dp[i+1],dp[i]+q.mine);
          max=Math.max(max,i+1);
        }
      }
    }
    System.out.println(max);
  }
  static class Question implements Comparable<Question>{
    int mine ;
    int other ;
    public Question(int mine,int other){
      this.mine=mine ;
      this.other=other ;
    }
    public int compareTo(Question another){
      return other-another.other ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var questions : Sequence(Question) ; questions := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     questions[i+1] := Question.newQuestion(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    questions := questions->sort() ; 
    var max : int ; max := 0 ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
    dp := dp->collect(2147483647) ; 
    dp[0+1] := 0 ; 
    for (q : questions) do ( (         var i : int ; i := max ; while i >= 0 do ( (     if (dp[i+1] + q.mine <= q.other) then (     dp[i + 1+1] := Set{dp[i + 1+1], dp[i+1] + q.mine}->min() ; 
     max := Set{max, i + 1}->max() ) else skip )  ;     i := i - 1 ) )  ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static class Question implements Comparable<Question> {
   attribute mine : int;
   attribute other : int;
   static operation newQuestion( mine : int, other : int) : Question
  pre: true
  post: true
  activity:
  ( var self : Question ;
    self := createQuestion();
    self.initialise(mine, other);
    return self );
  operation initialise( mine : int, other : int) : void
  pre: true  post: true
  activity: (     self.mine := mine ; 
     self.other := other );
   operation compareTo( another : Question) : int
  pre: true
  post: true
  activity: (     return other - another.other );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int stringToInt(String str){
    if(str.length()==1)return(str.charAt(0)-'0');
    double y=stringToInt(str.substring(1));
    double x=str.charAt(0)-'0' ;
    x=x*Math.pow(10,str.length()-1)+y ;
    return(int)(x);
  }
  public static void main(String[] args){
    String str="1235" ;
    System.out.print(stringToInt(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation stringToInt( str : String) : int
  pre: true
  post: true
  activity: (     if (str->size() = 1) then     return (str->at(0+1) - ('0')->char2byte()) else skip ; 
     var y : double ; y := stringToInt(str.subrange(1+1,1)) ;
    var x : double ; x := str->at(0+1) - ('0')->char2byte() ;
    x := x * 10->pow(str->size() - 1) + y ; 
    return (x)->oclAsType(int) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "1235" ;
     OclFile["System.out"].print(stringToInt(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p118 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p118().run());
  }
  public String run(){
    isPrime=Library.listPrimality(10000);
    count=0 ;
    int[] digits={
      1,2,3,4,5,6,7,8,9 };
      do countPrimeSets(digits,0,0);
      while(Library.nextPermutation(digits));
      return Integer.toString(count);
    }
    private boolean[] isPrime ;
    private int count ;
    private void countPrimeSets(int[] digits,int startIndex,int prevNum){
      if(startIndex==digits.length)count++;
      else {
        for(int split=startIndex+1 ; split<=digits.length ; split++){
          int num=toInteger(digits,startIndex,split);
          if(num>prevNum && isPrime(num))countPrimeSets(digits,split,num);
        }
      }
    }
    private boolean isPrime(int n){
      if(n<isPrime.length)return isPrime[n];
      else return Library.isPrime(n);
    }
    private static int toInteger(int[] digits,int start,int end){
      int result=0 ;
      for(int i=start ; i<end ; i++)result=result*10+digits[i];
      return result ;
    }
  }

------------------------------------------------------------
OCL File:
---------
class p118 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p118.newp118().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     isPrime := Library.listPrimality(10000) ; 
     count := 0 ; 
    var digits : Sequence(int) ; digits := Sequence{1,2,3,4,5,6,7,8,9} ;
  while true do (    execute countPrimeSets(digits, 0, 0) ; ;
    if (Library.nextPermutation(digits)) then skip else break) ; 
    return ((count) + "") 
 );
   attribute isPrime : Sequence(boolean);
   attribute count : int;
   operation countPrimeSets( digits : Sequence(int), startIndex : int, prevNum : int) : void
  pre: true
  post: true
  activity: (     if (startIndex = digits->size()) then     count := count + 1 ; else (         var split : int ; split := startIndex + 1 ; while split <= digits->size() do ( (     var num : int ; num := toInteger(digits, startIndex, split) ;
     if (num > prevNum & isPrime(num)) then     execute countPrimeSets(digits, split, num) ; else skip )  ;     split := split + 1 ) ) );
   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n < isPrime->size()) then     return isPrime[n+1] else     return Library.isPrime(n) );
  static   operation toInteger( digits : Sequence(int), start : int, end : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := start ; while i < end do (     result := result * 10 + digits[i+1] ;  ;     i := i + 1 ) ; 
     return result );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class8 {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long min=Integer.MAX_VALUE,smin=Integer.MAX_VALUE ;
    long i,c=0,f=0 ;
    for(i=2 ; i*i<=n ; i++){
      if(n % i==0){
        c++;
        if(i<min){
          min=i ;
        }
      }
    }
    if(c==0)System.out.println(n);
    else {
      long num=1,flag=0 ;
      while(num<n){
        num*=min ;
        if(num==n){
          flag=1 ;
          break ;
        }
      }
      if(flag==1)System.out.println(min);
      else System.out.println(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class8 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var min : long ; min := 2147483647 ;
    var smin : long ; smin := 2147483647 ;
    var i : long ;
    var c : long ; c := 0 ;
    var f : long ; f := 0 ;
        i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     c := c + 1 ; 
     if (i < min) then (     min := i ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (c = 0) then     OclFile["System.out"].println(n) else (     var num : long ; num := 1 ;
    var flag : long ; flag := 0 ;
     while (num < n) do (     num := num*(min) ; 
     if (num = n) then (     flag := 1 ; 
     break ) else skip ) ; 
     if (flag = 1) then     OclFile["System.out"].println(min) ; else     OclFile["System.out"].println(1) ; ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countSetBits(int n){
    int cnt=0 ;
    int[] setBits=new int[n+1];
    setBits[0]=0 ;
    setBits[1]=1 ;
    for(int i=2 ; i<=n ; i++){
      if(i % 2==0){
        setBits[i]=setBits[i/2];
      }
      else {
        setBits[i]=setBits[i-1]+1 ;
      }
    }
    for(int i=0 ; i<=n ; i++){
      cnt=cnt+setBits[i];
    }
    return cnt ;
  }
  public static void main(String[] args){
    int n=6 ;
    System.out.println(countSetBits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var setBits : Sequence(int) ; setBits := Integer.subrange(1,n + 1)->collect(0) ;
    setBits[0+1] := 0 ; 
    setBits[1+1] := 1 ; 
        var i : int ; i := 2 ; while i <= n do ( (     if (i mod 2 = 0) then (     setBits[i+1] := setBits[i / 2+1] ) else (     setBits[i+1] := setBits[i - 1+1] + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= n do ( (     cnt := cnt + setBits[i+1] )  ;     i := i + 1 ) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(countSetBits(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class8 {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long min=Integer.MAX_VALUE,smin=Integer.MAX_VALUE ;
    long i,c=0,f=0 ;
    for(i=2 ; i*i<=n ; i++){
      if(n % i==0){
        c++;
        if(i<min){
          min=i ;
        }
      }
    }
    if(c==0)System.out.println(n);
    else {
      long num=1,flag=0 ;
      while(num<n){
        num*=min ;
        if(num==n){
          flag=1 ;
          break ;
        }
      }
      if(flag==1)System.out.println(min);
      else System.out.println(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class8 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var min : long ; min := 2147483647 ;
    var smin : long ; smin := 2147483647 ;
    var i : long ;
    var c : long ; c := 0 ;
    var f : long ; f := 0 ;
        i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     c := c + 1 ; 
     if (i < min) then (     min := i ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (c = 0) then     OclFile["System.out"].println(n) else (     var num : long ; num := 1 ;
    var flag : long ; flag := 0 ;
     while (num < n) do (     num := num*(min) ; 
     if (num = n) then (     flag := 1 ; 
     break ) else skip ) ; 
     if (flag = 1) then     OclFile["System.out"].println(min) ; else     OclFile["System.out"].println(1) ; ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class ColorTheFence {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int v=sc.nextInt();
    int a[]=new int[10];
    for(int i=1 ; i<10 ; i++)a[i]=sc.nextInt();
    int amin=Integer.MAX_VALUE,imin=0 ;
    for(int i=1 ; i<10 ; i++){
      if(a[i]<amin){
        amin=a[i];
        imin=i ;
      }
    }
    if(v<amin){
      System.out.println(-1);
      return ;
    }
    int n=v/amin ;
    v=v-n*amin ;
    StringBuilder sb=new StringBuilder();
    for(int j=1 ; j<=n ; j++){
      int k=imin ;
      for(int i=9 ; i>=1 ; i--){
        if(v>=a[i]-amin){
          k=i ;
          v-=a[i]-amin ;
          break ;
        }
      }
      sb.append(k);
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ColorTheFence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var v : int ; v := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 1 ; while i < 10 do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var amin : int ; amin := 2147483647 ;
    var imin : int ; imin := 0 ;
        var i : int ; i := 1 ; while i < 10 do ( (     if (a[i+1] < amin) then (     amin := a[i+1] ; 
     imin := i ) else skip )  ;     i := i + 1 ) ; 
    if (v < amin) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var n : int ; n := v / amin ;
    v := v - n * amin ; 
    var sb : String ; sb := StringLib.newString() ;
        var j : int ; j := 1 ; while j <= n do ( (     var k : int ; k := imin ;
         var i : int ; i := 9 ; while i >= 1 do ( (     if (v >= a[i+1] - amin) then (     k := i ; 
     v := v-(a[i+1] - amin) ; 
     break ) else skip )  ;     i := i - 1 ) ; 
     sb := sb + StringLib.newString(k) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class ColorTheFence {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int v=sc.nextInt();
    int a[]=new int[10];
    for(int i=1 ; i<10 ; i++)a[i]=sc.nextInt();
    int amin=Integer.MAX_VALUE,imin=0 ;
    for(int i=1 ; i<10 ; i++){
      if(a[i]<amin){
        amin=a[i];
        imin=i ;
      }
    }
    if(v<amin){
      System.out.println(-1);
      return ;
    }
    int n=v/amin ;
    v=v-n*amin ;
    StringBuilder sb=new StringBuilder();
    for(int j=0 ; j<n ; j++){
      int k=imin ;
      for(int i=9 ; i>=1 ; i--){
        if(v>=a[i]-amin){
          k=i ;
          v-=a[i]-amin ;
          break ;
        }
      }
      sb.append(k);
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ColorTheFence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var v : int ; v := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 1 ; while i < 10 do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var amin : int ; amin := 2147483647 ;
    var imin : int ; imin := 0 ;
        var i : int ; i := 1 ; while i < 10 do ( (     if (a[i+1] < amin) then (     amin := a[i+1] ; 
     imin := i ) else skip )  ;     i := i + 1 ) ; 
    if (v < amin) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var n : int ; n := v / amin ;
    v := v - n * amin ; 
    var sb : String ; sb := StringLib.newString() ;
        var j : int ; j := 0 ; while j < n do ( (     var k : int ; k := imin ;
         var i : int ; i := 9 ; while i >= 1 do ( (     if (v >= a[i+1] - amin) then (     k := i ; 
     v := v-(a[i+1] - amin) ; 
     break ) else skip )  ;     i := i - 1 ) ; 
     sb := sb + StringLib.newString(k) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class ProblemB {
  static int n,m ;
  public static void main(String[] args)throws Exception {
    StringBuilder sb=new StringBuilder();
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line[]=br.readLine().split(" ");
    n=Integer.parseInt(line[0]);
    m=Integer.parseInt(line[1]);
    int x=Integer.parseInt(line[2]);
    int y=Integer.parseInt(line[3]);
    for(int i=y ; i<=m ; i++){
      sb.append(x+" "+i);
      sb.append("\n");
    }
    boolean ok=true ;
    while(true){
      boolean exec=false ;
      if(ok){
        for(int i=n ; i>=1 && m>=1 ; i--){
          if(i==x && m>=y)continue ;
          exec=true ;
          sb.append(i+" "+m);
          sb.append("\n");
        }
      }
      else {
        for(int i=1 ; i<=n && m>=1 ; i++){
          if(i==x && m>=y)continue ;
          exec=true ;
          sb.append(i+" "+m);
          sb.append("\n");
        }
      }
      ok=! ok ;
      if(! exec)break ;
      m--;
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    n := (line[0+1])->toInteger() ; 
    m := (line[1+1])->toInteger() ; 
    var x : int ; x := (line[2+1])->toInteger() ;
    var y : int ; y := (line[3+1])->toInteger() ;
        var i : int ; i := y ; while i <= m do ( (     sb := sb + StringLib.newString(x + " " + i) ; 
     sb := sb + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    var ok : boolean ; ok := true ;
    while (true) do (     var exec : boolean ; exec := false ;
     if (ok) then (         var i : int ; i := n ; while i >= 1 & m >= 1 do ( (     if (i = x & m >= y) then     continue else skip ; 
     exec := true ; 
     sb := sb + StringLib.newString(i + " " + m) ; 
     sb := sb + StringLib.newString("\n") )  ;     i := i - 1 ) ) else (         var i : int ; i := 1 ; while i <= n & m >= 1 do ( (     if (i = x & m >= y) then     continue else skip ; 
     exec := true ; 
     sb := sb + StringLib.newString(i + " " + m) ; 
     sb := sb + StringLib.newString("\n") )  ;     i := i + 1 ) ) ;  
    ok := not(ok) ; 
    if (not(exec)) then     break else skip ; 
    m := m - 1 ; 
 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int N=200000 ;
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    double[][] dp=new double[n][N];
    for(int i=0 ; i<n ; i++)Arrays.fill(dp[i],1<<29);
    for(int i=1 ; i<N ; i++)dp[0][i]=Math.abs(a[0]-i)*1.0/a[0];
    for(int i=0 ; i<n-1 ; i++){
      for(int j=1 ; j<N ; j++){
        for(int k=j ; k<N ; k+=j){
          dp[i+1][k]=Math.min(dp[i+1][k],Math.max(dp[i][j],Math.abs(a[i+1]-k)*1.0/a[i+1]));
        }
      }
    }
    double min=1<<29 ;
    for(int j=1 ; j<N ; j++){
      min=Math.min(min,dp[n-1][j]);
    }
    System.out.printf("%.9f\n",min);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := 200000 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(double)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,N)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < n do (     dp[i+1] := dp[i+1]->collect((1*(2->pow(29)))->oclAsType(long)) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < N do (     dp[0+1][i+1] := if a[0+1] - i < 0 then -(a[0+1] - i) else a[0+1] - i endif * 1.0 / a[0+1] ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := 1 ; while j < N do ( (         var k : int ; k := j ; while k < N do ( (     dp[i + 1+1][k+1] := Set{dp[i + 1+1][k+1], Set{dp[i+1][j+1], if a[i + 1+1] - k < 0 then -(a[i + 1+1] - k) else a[i + 1+1] - k endif * 1.0 / a[i + 1+1]}->max()}->min() )  ;     k := k+(j) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var min : double ; min := (1*(2->pow(29)))->oclAsType(long) ;
        var j : int ; j := 1 ; while j < N do ( (     min := Set{min, dp[n - 1+1][j+1]}->min() )  ;     j := j + 1 ) ; 
    OclFile["System.out"].printf("%.9f\n", min) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class ProblemB {
  static int n,m ;
  public static void main(String[] args)throws Exception {
    StringBuilder sb=new StringBuilder();
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line[]=br.readLine().split(" ");
    n=Integer.parseInt(line[0]);
    m=Integer.parseInt(line[1]);
    int x=Integer.parseInt(line[2]);
    int y=Integer.parseInt(line[3]);
    boolean vis[][]=new boolean[n+1][m+1];
    for(int i=y ; i<=m ; i++){
      sb.append(x+" "+i);
      sb.append("\n");
      vis[x][i]=true ;
    }
    boolean ok=true ;
    while(true){
      boolean exec=false ;
      if(ok){
        for(int i=n ; i>=1 && m>=1 ; i--){
          if(vis[i][m])continue ;
          exec=true ;
          vis[i][m]=true ;
          sb.append(i+" "+m);
          sb.append("\n");
        }
      }
      else {
        for(int i=1 ; i<=n && m>=1 ; i++){
          if(vis[i][m])continue ;
          exec=true ;
          vis[i][m]=true ;
          sb.append(i+" "+m);
          sb.append("\n");
        }
      }
      ok=! ok ;
      if(! exec)break ;
      m--;
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    n := (line[0+1])->toInteger() ; 
    m := (line[1+1])->toInteger() ; 
    var x : int ; x := (line[2+1])->toInteger() ;
    var y : int ; y := (line[3+1])->toInteger() ;
    var vis : Sequence(Sequence(boolean)) ; vis := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(false)) ;
        var i : int ; i := y ; while i <= m do ( (     sb := sb + StringLib.newString(x + " " + i) ; 
     sb := sb + StringLib.newString("\n") ; 
     vis[x+1][i+1] := true )  ;     i := i + 1 ) ; 
    var ok : boolean ; ok := true ;
    while (true) do (     var exec : boolean ; exec := false ;
     if (ok) then (         var i : int ; i := n ; while i >= 1 & m >= 1 do ( (     if (vis[i+1][m+1]) then     continue else skip ; 
     exec := true ; 
    vis[i+1][m+1] := true ; 
    sb := sb + StringLib.newString(i + " " + m) ; 
    sb := sb + StringLib.newString("\n") ; 
 )  ;     i := i - 1 ) ) else (         var i : int ; i := 1 ; while i <= n & m >= 1 do ( (     if (vis[i+1][m+1]) then     continue else skip ; 
     exec := true ; 
    vis[i+1][m+1] := true ; 
    sb := sb + StringLib.newString(i + " " + m) ; 
    sb := sb + StringLib.newString("\n") ; 
 )  ;     i := i + 1 ) ) ;  
    ok := not(ok) ; 
    if (not(exec)) then     break else skip ; 
    m := m - 1 ; 
 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class ProblemB {
  static int n,m ;
  public static void main(String[] args)throws Exception {
    StringBuilder sb=new StringBuilder();
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line[]=br.readLine().split(" ");
    n=Integer.parseInt(line[0]);
    m=Integer.parseInt(line[1]);
    int x=Integer.parseInt(line[2]);
    int y=Integer.parseInt(line[3]);
    boolean vis[][]=new boolean[n+1][m+1];
    for(int i=y ; i<=m ; i++){
      sb.append(x+" "+i);
      sb.append("\n");
      vis[x][i]=true ;
    }
    y=m ;
    boolean ok=true ;
    while(true){
      boolean exec=false ;
      if(ok){
        for(int i=n ; i>=1 && y>=1 ; i--){
          if(vis[i][y])continue ;
          exec=true ;
          vis[i][y]=true ;
          sb.append(i+" "+y);
          sb.append("\n");
        }
      }
      else {
        for(int i=1 ; i<=n && y>=1 ; i++){
          if(vis[i][y])continue ;
          exec=true ;
          vis[i][y]=true ;
          sb.append(i+" "+y);
          sb.append("\n");
        }
      }
      ok=! ok ;
      if(! exec)break ;
      y--;
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    n := (line[0+1])->toInteger() ; 
    m := (line[1+1])->toInteger() ; 
    var x : int ; x := (line[2+1])->toInteger() ;
    var y : int ; y := (line[3+1])->toInteger() ;
    var vis : Sequence(Sequence(boolean)) ; vis := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(false)) ;
        var i : int ; i := y ; while i <= m do ( (     sb := sb + StringLib.newString(x + " " + i) ; 
     sb := sb + StringLib.newString("\n") ; 
     vis[x+1][i+1] := true )  ;     i := i + 1 ) ; 
    y := m ; 
    var ok : boolean ; ok := true ;
    while (true) do (     var exec : boolean ; exec := false ;
     if (ok) then (         var i : int ; i := n ; while i >= 1 & y >= 1 do ( (     if (vis[i+1][y+1]) then     continue else skip ; 
     exec := true ; 
    vis[i+1][y+1] := true ; 
    sb := sb + StringLib.newString(i + " " + y) ; 
    sb := sb + StringLib.newString("\n") ; 
 )  ;     i := i - 1 ) ) else (         var i : int ; i := 1 ; while i <= n & y >= 1 do ( (     if (vis[i+1][y+1]) then     continue else skip ; 
     exec := true ; 
    vis[i+1][y+1] := true ; 
    sb := sb + StringLib.newString(i + " " + y) ; 
    sb := sb + StringLib.newString("\n") ; 
 )  ;     i := i + 1 ) ) ;  
    ok := not(ok) ; 
    if (not(exec)) then     break else skip ; 
    y := y - 1 ; 
 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1395 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int R=in.nextInt();
    int C=in.nextInt();
    int SR=in.nextInt();
    int SC=in.nextInt();
    StringBuilder output=new StringBuilder();
    output.append(SR).append(' ').append(SC).append('\n');
    for(int c=1 ; c<=C ; c++){
      if(c!=SC){
        output.append(SR).append(' ').append(c).append('\n');
      }
    }
    int lastC=C ;
    for(int r=1 ; r<=R ; r++){
      if(r!=SR){
        if(lastC==1){
          for(int c=1 ; c<=C ; c++){
            output.append(r).append(' ').append(c).append('\n');
          }
          lastC=C ;
        }
        else {
          for(int c=C ; c>=1 ; c--){
            output.append(r).append(' ').append(c).append('\n');
          }
          lastC=1 ;
        }
      }
    }
    System.out.print(output);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1395 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var R : int ; R := in.getCurrent()->toInteger() ;
    var C : int ; C := in.getCurrent()->toInteger() ;
    var SR : int ; SR := in.getCurrent()->toInteger() ;
    var SC : int ; SC := in.getCurrent()->toInteger() ;
    var output : String ; output := StringLib.newString() ;
    output := output + StringLib.newString(SR) + StringLib.newString(' ') + StringLib.newString(SC) + StringLib.newString('
') ; 
        var c : int ; c := 1 ; while c <= C do ( (     if (c /= SC) then (     output := output + StringLib.newString(SR) + StringLib.newString(' ') + StringLib.newString(c) + StringLib.newString('
') ) else skip )  ;     c := c + 1 ) ; 
    var lastC : int ; lastC := C ;
        var r : int ; r := 1 ; while r <= R do ( (     if (r /= SR) then (     if (lastC = 1) then (         var c : int ; c := 1 ; while c <= C do ( (     output := output + StringLib.newString(r) + StringLib.newString(' ') + StringLib.newString(c) + StringLib.newString('
') )  ;     c := c + 1 ) ; 
     lastC := C ) else (         var c : int ; c := C ; while c >= 1 do ( (     output := output + StringLib.newString(r) + StringLib.newString(' ') + StringLib.newString(c) + StringLib.newString('
') )  ;     c := c - 1 ) ; 
     lastC := 1 ) ) else skip )  ;     r := r + 1 ) ; 
    OclFile["System.out"].print(output) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf1619A {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    String s ;
    for(int i=1 ; i<=t ; i++){
      s=input.next();
      if(s.length()% 2!=0)System.out.println("NO");
      else System.out.println(s.substring(0,s.length()/2).equals(s.substring(s.length()/2))? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1619A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
     var s : String ;
         var i : int ; i := 1 ; while i <= t do ( (     s := input.getCurrent() ; 
     if (s->size() mod 2 /= 0) then     OclFile["System.out"].println("NO") ; else     OclFile["System.out"].println(if s.subrange(0+1,s->size() / 2) = s.subrange(s->size() / 2+1,s->size() / 2) then "YES" else "NO" endif) ; )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewClass34 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      String a=in.next();
      if(a.length()% 2!=0){
        System.out.println("NO");
      }
      else {
        int lim=a.length()/2 ;
        String str1=a.substring(0,lim);
        String str2=a.substring(lim);
        if(str1.equals(str2)){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass34 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : String ; a := in.getCurrent() ;
     if (a->size() mod 2 /= 0) then (     OclFile["System.out"].println("NO") ) else (     var lim : int ; lim := a->size() / 2 ;
     var str1 : String ; str1 := a.subrange(0+1,lim) ;
     var str2 : String ; str2 := a.subrange(lim+1,lim) ;
     if (str1 = str2) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.*;
class GFG {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static int largestGCD1Subset(int A[],int n){
    int currentGCD=A[0];
    for(int i=1 ; i<n ; i++){
      currentGCD=gcd(currentGCD,A[i]);
      if(currentGCD==1)return n ;
    }
    return 0 ;
  }
  public static void main(String[] args){
    int A[]={
      2,18,6,3 };
      int n=A.length ;
      System.out.println(largestGCD1Subset(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation largestGCD1Subset( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var currentGCD : int ; currentGCD := A[0+1] ;
         var i : int ; i := 1 ; while i < n do ( (     currentGCD := gcd(currentGCD, A[i+1]) ; 
     if (currentGCD = 1) then     return n else skip )  ;     i := i + 1 ) ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{2,18,6,3} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].println(largestGCD1Subset(A, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Fast f=new Fast(System.in);
    int t=f.nextInt();
    while(t--!=0){
      String s=f.next(),s1=s.substring(0,s.length()/2),s2=s.substring(s.length()/2);
      System.out.println(s1.equals(s2)? "YES" : "NO");
    }
    System.out.flush();
    System.out.close();
  }
}
class Fast {
  StringTokenizer st ;
  BufferedReader br ;
  public Fast(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public Fast(String file)throws IOException {
    br=new BufferedReader(new FileReader(file));
  }
  public Fast(FileReader r){
    br=new BufferedReader(r);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String readAllLines(BufferedReader reader)throws IOException {
    StringBuilder content=new StringBuilder();
    String line ;
    while((line=reader.readLine())!=null){
      content.append(line);
      content.append(System.lineSeparator());
    }
    return content.toString();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public int[] nextIntArray(int n)throws IOException {
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : Fast ; f := Fast.newFast(OclFile["System.in"]) ;
     var t : int ; t := f.nextInt() ;
        while (t /= 0) do (    skip ; (     var s : String ; s := f.next() ;
    var s1 : String ; s1 := s.subrange(0+1,s->size() / 2) ;
    var s2 : String ; s2 := s.subrange(s->size() / 2+1,s->size() / 2) ;
     OclFile["System.out"].println(if s1 = s2 then "YES" else "NO" endif) ) ;  ) ;  
    OclFile["System.out"].flush() ; 
    OclFile["System.out"].close() ; 
 );
}
class Fast {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newFast( s : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(s))) );
   static operation newFast( file : String) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   static operation newFast( r : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(r);
    return self );
  operation initialise( r : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(r) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation readAllLines( reader : OclFile) : String
  pre: true
  post: true
  activity: (     var content : String ; content := StringLib.newString() ;
     var line : String ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     content := content + StringLib.newString(line) ; 
     content := content + StringLib.newString(lineSeparator()) ) ;     line := reader.readLine() ;
 ) ;  
     return content+"" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.StringTokenizer ;
import java.io.*;
import java.util.*;
import java.util.List ;
import java.util.stream.Collectors ;
import java.util.stream.Stream ;
import java.math.*;
public class Main {
  public static void main(String[] args){
    FastScanner sc=new FastScanner();
    int t=sc.nextInt();
    while(t-->0){
      String s=sc.next();
      if(s.length()% 2!=0){
        System.out.println("NO");
      }
      else {
        int n=s.length();
        String com1=s.substring(0,n/2);
        String com2=s.substring(n/2);
        if(com1.equals(com2)){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
    }
  }
  static void sort(int[] a){
    ArrayList<Integer>l=new ArrayList<>();
    for(int i : a)l.add(i);
    Collections.sort(l);
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())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());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner() ;
     var t : int ; t := sc.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : String ; s := sc.next() ;
     if (s->size() mod 2 /= 0) then (     OclFile["System.out"].println("NO") ) else (     var n : int ; n := s->size() ;
     var com1 : String ; com1 := s.subrange(0+1,n / 2) ;
     var com2 : String ; com2 := s.subrange(n / 2+1,n / 2) ;
     if (com1 = com2) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ) ;  ) );
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l := l->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int countIdenticalRows(int mat[][]){
    int count=0 ;
    for(int i=0 ; i<mat.length ; i++){
      int first=mat[i][0];
      boolean allSame=true ;
      for(int j=1 ; j<mat[i] .length ; j++){
        if(mat[i][j]!=first){
          allSame=false ;
          break ;
        }
      }
      if(allSame)count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int mat[][]={
      {
        1,1,2 },{
          2,2,2 },{
            5,5,2 }
          };
          System.out.print(countIdenticalRows(mat));
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countIdenticalRows( mat : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < mat->size() do ( (     var first : int ; first := mat[i+1][0+1] ;
     var allSame : boolean ; allSame := true ;
         var j : int ; j := 1 ; while j < mat[i+1]->size() do ( (     if (mat[i+1][j+1] /= first) then (     allSame := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (allSame) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,1,2},Sequence{2,2,2},Sequence{5,5,2}} ;
     OclFile["System.out"].print(countIdenticalRows(mat)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    if(a==b)return a ;
    if(a>b)return gcd(a-b,b);
    return gcd(a,b-a);
  }
  static int LCM(int num[],int N){
    int ans=num[0];
    for(int i=1 ; i<N ; i++)ans=(((num[i]*ans))/(gcd(num[i],ans)));
    return ans ;
  }
  static int HCF(int den[],int N){
    int ans=den[0];
    for(int i=1 ; i<N ; i++)ans=gcd(den[i],ans);
    return ans ;
  }
  static int LCMOfFractions(int num[],int den[],int N){
    int Numerator=LCM(num,N);
    int Denominator=HCF(den,N);
    int gcd1=gcd(Numerator,Denominator);
    Numerator=Numerator/gcd1 ;
    Denominator=Denominator/gcd1 ;
    System.out.println("LCM is="+Numerator+"/"+Denominator);
    return 0 ;
  }
  public static void main(String args[]){
    int num[]={
      1,7,4 },den[]={
        2,3,6 };
        int N=num.length ;
        LCMOfFractions(num,den,N);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
    if (a = b) then     return a else skip ; 
    if (a > b) then     return gcd(a - b, b) else skip ; 
    return gcd(a, b - a) 
 );
  static   operation LCM( num : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := num[0+1] ;
         var i : int ; i := 1 ; while i < N do (     ans := (((num[i+1] * ans)) / (gcd(num[i+1], ans))) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation HCF( den : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := den[0+1] ;
         var i : int ; i := 1 ; while i < N do (     ans := gcd(den[i+1], ans) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation LCMOfFractions( num : Sequence(int), den : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var Numerator : int ; Numerator := LCM(num, N) ;
     var Denominator : int ; Denominator := HCF(den, N) ;
    var gcd1 : int ; gcd1 := gcd(Numerator, Denominator) ;
    Numerator := Numerator / gcd1 ; 
    Denominator := Denominator / gcd1 ; 
    OclFile["System.out"].println("LCM is=" + Numerator + "/" + Denominator) ; 
    return 0 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : Sequence(int) ; num := Sequence{1,7,4} ;
    var den : Sequence(void) ; den := Sequence{2,3,6} ;
     var N : int ; N := num->size() ;
     execute LCMOfFractions(num, den, N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static int j ;
  public static int y ;
  public static ArrayList<Long>list=new ArrayList<Long>();
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(stdIn.hasNext()){
      String tmp=stdIn.nextLine();
      stdIn.useDelimiter(".");
      solv(tmp);
    }
  }
  public static void solv(String tmp){
    String tmpX="" ;
    for(int i=0 ; i<tmp.length(); i++){
      tmpX+=String.valueOf(tmp.charAt(i));
    }
    while(true){
      String tmpCX="" ;
      for(int i=0 ; i<tmpX.length(); i++){
        if(tmpX.charAt(i)==' '){
          tmpCX+=" " ;
        }
        else if(tmpX.charAt(i)=='.'){
          tmpCX+="." ;
        }
        else if(tmpX.charAt(i)=='z'){
          tmpCX+="a" ;
        }
        else {
          char tmpC=tmpX.charAt(i);
          tmpC++;
          tmpCX+=String.valueOf(tmpC);
        }
      }
      if(tmpCX.contains("the")|| tmpCX.contains("that")|| tmpCX.contains("this")){
        System.out.println(tmpCX);
        break ;
      }
      tmpX=tmpCX ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute j : int;
  static   attribute y : int;
  static   attribute list : Sequence(long) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (stdIn.hasNext()) do (     var tmp : String ; tmp := stdIn.nextLine() ;
     skip ; 
     execute solv(tmp) ) );
  static   operation solv( tmp : String) : void
  pre: true
  post: true
  activity: (     var tmpX : String ; tmpX := "" ;
         var i : int ; i := 0 ; while i < tmp->size() do ( (     tmpX := tmpX+(((tmp->at(i+1)) + "")) )  ;     i := i + 1 ) ; 
     while (true) do (     var tmpCX : String ; tmpCX := "" ;
         var i : int ; i := 0 ; while i < tmpX->size() do ( (     if (tmpX->at(i+1) = ' ') then (     tmpCX := tmpCX+(" ") ) else     if (tmpX->at(i+1) = '.') then (     tmpCX := tmpCX+(".") ) else     if (tmpX->at(i+1) = 'z') then (     tmpCX := tmpCX+("a") ) else (     var tmpC : String ; tmpC := tmpX->at(i+1) ;
     tmpC := tmpC + 1 ; 
     tmpCX := tmpCX+(((tmpC) + "")) ) ;  ;  )  ;     i := i + 1 ) ; 
     if (tmpCX->includes("the") or tmpCX->includes("that") or tmpCX->includes("this")) then (     OclFile["System.out"].println(tmpCX) ; 
     break ) else skip ; 
     tmpX := tmpCX ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().solver();
  }
  void solver(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    double[] a=new double[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextDouble();
    }
    final int max=200001 ;
    double[][] dp=new double[2][max];
    double div=1.0/a[0];
    for(int i=0 ; i<max ; i++){
      dp[0][i]=Math.abs(a[0]-i)*div ;
    }
    for(int i=1 ; i<n ; i++){
      int t=i & 1 ;
      Arrays.fill(dp[t],1e9);
      div=1.0/a[i];
      for(int j=1 ; j<max ; j++){
        for(int k=j ; k<max ; k+=j){
          dp[t][k]=Math.min(dp[t][k],Math.max(dp[1-t][j],Math.abs(a[i]-k)*div));
        }
      }
    }
    double ans=1e9 ;
    for(int i=1 ; i<max ; i++){
      ans=Math.min(ans,dp[(n-1)& 1][i]);
    }
    System.out.printf("%.9f\n",ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solver() );
   operation solver() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(double) ; a := Integer.subrange(1,n)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
    var max : int ; max := 200001 ;
    var dp : Sequence(Sequence(double)) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,max)->collect(0.0)) ;
    var div : double ; div := 1.0 / a[0+1] ;
        var i : int ; i := 0 ; while i < max do ( (     dp[0+1][i+1] := if a[0+1] - i < 0 then -(a[0+1] - i) else a[0+1] - i endif * div )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     var t : int ; t := MathLib.bitwiseAnd(i,1) ;
     dp[t+1] := dp[t+1]->collect(1e9) ; 
     div := 1.0 / a[i+1] ; 
         var j : int ; j := 1 ; while j < max do ( (         var k : int ; k := j ; while k < max do ( (     dp[t+1][k+1] := Set{dp[t+1][k+1], Set{dp[1 - t+1][j+1], if a[i+1] - k < 0 then -(a[i+1] - k) else a[i+1] - k endif * div}->max()}->min() )  ;     k := k+(j) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : double ; ans := 1e9 ;
        var i : int ; i := 1 ; while i < max do ( (     ans := Set{ans, dp[(n - 1) & 1+1][i+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.9f\n", ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String tes=null ;
    char c=0 ;
    ArrayList<String>al=new ArrayList<String>();
    while(true){
      try {
        tes=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      if(tes==null){
        break ;
      }
      if(tes.equals("")){
        break ;
      }
      al.add(tes);
    }
    for(int u=0 ; u<al.size(); u++){
      tes=al.get(u);
      int eee=0 ;
      String[] fruit=tes.split(" ",0);
      for(int k=0 ; k<26 ; k++){
        StringBuffer t=new StringBuffer();
        for(int i=0 ; i<fruit.length ; i++){
          for(int j=0 ; j<fruit[i] .length(); j++){
            c=fruit[i] .charAt(j);
            if(String.valueOf(fruit[i] .charAt(j)).matches("[a-z] ")){
              c=(char)(fruit[i] .charAt(j)+k);
              if(c>122){
                c=(char)(96+c-122);
              }
            }
            t.append(c);
          }
          t.append(' ');
        }
        String sss=new String(t.substring(0,t.length()-1));
        String[] fruit2=sss.split(" ",0);
        for(int i=0 ; i<fruit2.length ; i++){
          if(fruit2[i] .equals("the")|| fruit2[i] .equals("this")|| fruit2[i] .equals("that")){
            eee=1 ;
            break ;
          }
        }
        if(eee==1){
          tes=sss ;
          break ;
        }
      }
      System.out.println(tes);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tes : String ; tes := null ;
    var c : String ; c := 0 ;
    var al : Sequence(String) ; al := Sequence{} ;
    while (true) do (     try (     tes := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     if (tes = null) then (     break ) else skip ; 
     if (tes = "") then (     break ) else skip ; 
     al := al->including(tes) ) ; 
        var u : int ; u := 0 ; while u < al->size() do ( (     tes := al->at(u+1) ; 
     var eee : int ; eee := 0 ;
    var fruit : Sequence(String) ; fruit := tes->split(" ") ;
        var k : int ; k := 0 ; while k < 26 do ( (     var t : String ; t := StringLib.newString() ;
         var i : int ; i := 0 ; while i < fruit->size() do ( (         var j : int ; j := 0 ; while j < fruit[i+1]->size() do ( (     c := fruit[i+1]->at(j+1) ; 
     if (((fruit[i+1]->at(j+1)) + "")->isMatch("[a-z] ")) then (     c := (fruit[i+1]->at(j+1) + k)->oclAsType(String) ; 
     if (c > 122) then (     c := (96 + c - 122)->oclAsType(String) ) else skip ) else skip ; 
     t := t + StringLib.newString(c) )  ;     j := j + 1 ) ; 
     t := t + StringLib.newString(' ') )  ;     i := i + 1 ) ; 
    var sss : String ; sss := StringLib.newString(t.subrange(0+1,t->size() - 1)) ;
    var fruit2 : Sequence(String) ; fruit2 := sss->split(" ") ;
        var i : int ; i := 0 ; while i < fruit2->size() do ( (     if (fruit2[i+1] = "the" or fruit2[i+1] = "this" or fruit2[i+1] = "that") then (     eee := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (eee = 1) then (     tes := sss ; 
     break ) else skip ; 
 )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(tes) ; 
 )  ;     u := u + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
class CaesarCipher {
  String s ;
  String alph="abcdefghijklmnopqrstuvwxyz" ;
  CaesarCipher(String s){
    this.s=s ;
  }
  boolean NotFound(){
    if(this.s.indexOf("the")==-1 && this.s.indexOf("that")==-1 && this.s.indexOf("this")==-1)return true ;
    else return false ;
  }
  String FindWord(){
    while(NotFound()){
      String t="" ;
      for(int i=0 ; i<this.s.length(); i++){
        if(alph.indexOf(this.s.charAt(i))!=-1)t=t+alph.charAt((alph.indexOf(this.s.charAt(i))+1)% 26);
        else t=t+this.s.charAt(i);
      }
      this.s=t.toString();
    }
    return this.s ;
  }
}
class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String buf ;
    try {
      while((buf=br.readLine())!=null){
        CaesarCipher cc=new CaesarCipher(buf);
        System.out.println(cc.FindWord());
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CaesarCipher {
   attribute s : String;
   attribute alph : String := "abcdefghijklmnopqrstuvwxyz";
   static operation newCaesarCipher( s : String) : CaesarCipher
  pre: true
  post: true
  activity:
  ( var self : CaesarCipher ;
    self := createCaesarCipher();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     self.s := s );
   operation NotFound() : boolean
  pre: true
  post: true
  activity: (     if (self.s->indexOf("the")-1 = -1 & self.s->indexOf("that")-1 = -1 & self.s->indexOf("this")-1 = -1) then     return true else     return false );
   operation FindWord() : String
  pre: true
  post: true
  activity: (     while (NotFound()) do (     var t : String ; t := "" ;
         var i : int ; i := 0 ; while i < self.s->size() do ( (     if (alph->indexOf(self.s->at(i+1))-1 /= -1) then     t := t + alph->at((alph->indexOf(self.s->at(i+1))-1 + 1) mod 26+1) ; else     t := t + self.s->at(i+1) ; )  ;     i := i + 1 ) ; 
     self.s := t+"" ) ; 
     return self.s );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var buf : String ;
     try (         buf := br.readLine() ;
    while ((buf) /= null) do (    skip ; (     var cc : CaesarCipher ; cc := CaesarCipher.newCaesarCipher(buf) ;
     OclFile["System.out"].println(cc.FindWord()) ) ;     buf := br.readLine() ;
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final char[] THE={
      't','h','e' };
      final char[] THIS={
        't','h','i','s' };
        final char[] THAT={
          't','h','a','t' };
          while(sc.hasNext()){
            char[] charset=sc.nextLine().toCharArray();
            for(int i=0 ; i<=(int)('z'-'a'); i++){
              if(isMatch(charset,THE)|| isMatch(charset,THIS)|| isMatch(charset,THAT)){
                System.out.println(charset);
                break ;
              }
              charset=charshift(charset,'a','z');
            }
          }
          sc.close();
        }
        private static boolean isMatch(char[] c,char[] pattern){
          boolean res=false ;
          for(int i=0 ; i<c.length-pattern.length+1 ; i++){
            boolean flag=true ;
            for(int j=0 ; j<pattern.length ; j++){
              flag=flag &&(c[i+j]==pattern[j]);
            }
            if(flag){
              res=flag ;
              break ;
            }
          }
          return res ;
        }
        private static char[] charshift(char[] c,char start,char end){
          char[] res=new char[c.length];
          for(int i=0 ; i<c.length ; i++){
            if(c[i]>=start && c[i]<end){
              res[i]=(char)((int)c[i]+1);
            }
            else if(c[i]==end){
              res[i]=start ;
            }
            else {
              res[i]=c[i];
            }
          }
          return res ;
        }
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var THE : Sequence(String) ; THE := Sequence{'t','h','e'} ;
    var THIS : Sequence(String) ; THIS := Sequence{'t','h','i','s'} ;
    var THAT : Sequence(String) ; THAT := Sequence{'t','h','a','t'} ;
    while (sc.hasNext()) do (     var charset : Sequence(String) ; charset := sc.nextLine()->characters() ;
         var i : int ; i := 0 ; while i <= (('z')->char2byte() - ('a')->char2byte())->oclAsType(int) do ( (     if (isMatch(charset, THE) or isMatch(charset, THIS) or isMatch(charset, THAT)) then (     OclFile["System.out"].println(charset) ; 
     break ) else skip ; 
     charset := charshift(charset, 'a', 'z') )  ;     i := i + 1 ) ) ; 
    skip ; 
 );
  static   operation isMatch( c : Sequence(String), pattern : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     var res : boolean ; res := false ;
         var i : int ; i := 0 ; while i < c->size() - pattern->size() + 1 do ( (     var flag : boolean ; flag := true ;
         var j : int ; j := 0 ; while j < pattern->size() do ( (     flag := flag & (c[i + j+1] = pattern[j+1]) )  ;     j := j + 1 ) ; 
     if (flag) then (     res := flag ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     return res );
  static   operation charshift( c : Sequence(String), start : String, end : String) : Sequence(String)
  pre: true
  post: true
  activity: (     var res : Sequence(String) ; res := Integer.subrange(1,c->size())->collect(0) ;
         var i : int ; i := 0 ; while i < c->size() do ( (     if (c[i+1] >= start & c[i+1] < end) then (     res[i+1] := (c[i+1]->oclAsType(int) + 1)->oclAsType(String) ) else     if (c[i+1] = end) then (     res[i+1] := start ) else (     res[i+1] := c[i+1] ) ;  )  ;     i := i + 1 ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public final class p179 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p179().run());
  }
  private static final int LIMIT=Library.pow(10,7);
  public String run(){
    int[] numDivisors=new int[LIMIT+1];
    Arrays.fill(numDivisors,2);
    for(int i=2 ; i<numDivisors.length ; i++){
      for(int j=i*2 ; j<numDivisors.length ; j+=i)numDivisors[j]++;
    }
    int count=0 ;
    for(int i=2 ; i<numDivisors.length-1 ; i++){
      if(numDivisors[i]==numDivisors[i+1])count++;
    }
    return Integer.toString(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p179 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p179.newp179().run()) );
  static    attribute LIMIT : int := Library.pow(10, 7);
   operation run() : String
  pre: true
  post: true
  activity: (     var numDivisors : Sequence(int) ; numDivisors := Integer.subrange(1,LIMIT + 1)->collect(0) ;
     numDivisors := numDivisors->collect(2) ; 
        var i : int ; i := 2 ; while i < numDivisors->size() do ( (         var j : int ; j := i * 2 ; while j < numDivisors->size() do (     numDivisors[j+1] := numDivisors[j+1] + 1 ;  ;     j := j+(i) ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 2 ; while i < numDivisors->size() - 1 do ( (     if (numDivisors[i+1] = numDivisors[i + 1+1]) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    return ((count) + "") 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    int input=in.nextInt();
    for(int i=0 ; i<input ; i++){
      int len=in.nextInt();
      for(int j=2 ; j<=len+1 ; j++){
        System.out.print(j);
        System.out.print(" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : int ; input := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < input do ( (     var len : int ; len := in.getCurrent()->toInteger() ;
         var j : int ; j := 2 ; while j <= len + 1 do ( (     OclFile["System.out"].print(j) ; 
     OclFile["System.out"].print(" ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
public class Sequence {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    scan.nextLine();
    StringBuilder result=new StringBuilder();
    for(int i=0 ; i<t ; i++){
      int n=scan.nextInt();
      StringBuilder res=new StringBuilder();
      if(n==1){
        res.append("1");
      }
      else {
        res.append("2 3 ");
        for(int j=3 ; j<=n ; j++){
          res.append((j+2)+" ");
        }
      }
      result.append(res+"\n");
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sequence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
    skip ; 
    var result : String ; result := StringLib.newString() ;
        var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var res : String ; res := StringLib.newString() ;
     if (n = 1) then (     res := res + StringLib.newString("1") ) else (     res := res + StringLib.newString("2 3 ") ; 
         var j : int ; j := 3 ; while j <= n do ( (     res := res + StringLib.newString((j + 2) + " ") )  ;     j := j + 1 ) ) ;  
     result := result + StringLib.newString(res + "\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int[] arr=new int[1000];
      arr[0]=2 ;
      arr[1]=3 ;
      int x=4 ;
      int j=2 ;
      while(j<arr.length){
        while(! isprime(x)){
          x++;
        }
        arr[j]=x ;
        j++;
        x++;
      }
      for(int k=0 ; k<n ; k++){
        System.out.print(arr[k]+" ");
      }
      System.out.println();
    }
  }
  public static boolean isprime(int n){
    for(int i=2 ; i*i<=n ; i++){
      if(n % i==0){
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,1000)->collect(0) ;
    arr[0+1] := 2 ; 
    arr[1+1] := 3 ; 
    var x : int ; x := 4 ;
    var j : int ; j := 2 ;
    while (j < arr->size()) do (     while (not(isprime(x))) do (     x := x + 1 ) ; 
     arr[j+1] := x ; 
     j := j + 1 ; 
     x := x + 1 ) ; 
        var k : int ; k := 0 ; while k < n do ( (     OclFile["System.out"].print(arr[k+1] + " ") )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) );
  static   operation isprime( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int digSum(int n){
    if(n==0)return 0 ;
    return(n % 9==0)? 9 :(n % 9);
  }
  static int repeatedNumberSum(int n,int x){
    int sum=x*digSum(n);
    return digSum(sum);
  }
  public static void main(String[] args){
    int n=24,x=3 ;
    System.out.println(repeatedNumberSum(n,x));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation digSum( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else skip ; 
     return if (n mod 9 = 0) then 9 else (n mod 9) endif );
  static   operation repeatedNumberSum( n : int, x : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := x * digSum(n) ;
     return digSum(sum) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 24 ;
    var x : int ; x := 3 ;
     OclFile["System.out"].println(repeatedNumberSum(n, x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class trailzero {
  public static void main(String[] args)throws Throwable {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[12];
    int p[]=new int[Math.min(12,n)];
    a[0]=31 ;
    a[1]=29 ;
    a[2]=31 ;
    a[3]=30 ;
    a[4]=31 ;
    a[5]=30 ;
    a[6]=31 ;
    a[7]=31 ;
    a[8]=30 ;
    a[9]=31 ;
    a[10]=30 ;
    a[11]=31 ;
    int temp=0 ;
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      if(i>11 && temp==29 && x==29){
        System.out.println("No");
        return ;
      }
      if(i<12 &&(x==28 || x==29)){
        temp=x ;
      }
      if(x==28){
        x=29 ;
      }
      if(i<12){
        p[i]=x ;
      }
      else {
        if(p[i % 12]!=x){
          System.out.println("No");
          return ;
        }
      }
    }
    boolean flag=true ;
    for(int i=0 ; i<12 ; i++){
      flag=true ;
      for(int j=0 ; j<Math.min(n,12); j++){
        if(a[(i+j)% 12]!=p[j]){
          flag=false ;
          break ;
        }
      }
      if(flag){
        break ;
      }
    }
    if(flag){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class trailzero {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,12)->collect(0) ;
    var p : Sequence(int) ; p := Integer.subrange(1,Set{12, n}->min())->collect(0) ;
    a[0+1] := 31 ; 
    a[1+1] := 29 ; 
    a[2+1] := 31 ; 
    a[3+1] := 30 ; 
    a[4+1] := 31 ; 
    a[5+1] := 30 ; 
    a[6+1] := 31 ; 
    a[7+1] := 31 ; 
    a[8+1] := 30 ; 
    a[9+1] := 31 ; 
    a[10+1] := 30 ; 
    a[11+1] := 31 ; 
    var temp : int ; temp := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (i > 11 & temp = 29 & x = 29) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
    if (i < 12 & (x = 28 or x = 29)) then (     temp := x ) else skip ; 
    if (x = 28) then (     x := 29 ) else skip ; 
    if (i < 12) then (     p[i+1] := x ) else (     if (p[i mod 12+1] /= x) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ) ;  
 )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < 12 do ( (     flag := true ; 
         var j : int ; j := 0 ; while j < Set{n, 12}->min() do ( (     if (a[(i + j) mod 12+1] /= p[j+1]) then (     flag := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (flag) then (     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CodeForces899C {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] a=new int[n];
    int[] day={
      31,28,31,30,31,30,31,31,30,31,30,31 };
      for(int i=0 ; i<n ; i++){
        a[i]=input.nextInt();
      }
      for(int i=0 ; i<12 ; i++){
        boolean bool=true ;
        boolean year=true ;
        for(int j=0 ; j<n ; j++){
          if(a[j]!=day[(i+j)% 12]){
            if(a[j]==29 && year && day[(i+j)% 12]==28){
              year=false ;
              continue ;
            }
            bool=false ;
            break ;
          }
        }
        if(bool){
          System.out.println("Yes");
          return ;
        }
      }
      System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class CodeForces899C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var day : Sequence(int) ; day := Sequence{31,28,31,30,31,30,31,31,30,31,30,31} ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 12 do ( (     var bool : boolean ; bool := true ;
     var year : boolean ; year := true ;
         var j : int ; j := 0 ; while j < n do ( (     if (a[j+1] /= day[(i + j) mod 12+1]) then (     if (a[j+1] = 29 & year & day[(i + j) mod 12+1] = 28) then (     year := false ; 
     continue ) else skip ; 
     bool := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (bool) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("No") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int[] arr=new int[3];
    for(int i=0 ; i<n ; i++){
      int num=scanner.nextInt();
      arr[num-1]=arr[num-1]+1 ;
    }
    int max=Math.max(arr[0],arr[1]);
    max=Math.max(max,arr[2]);
    System.out.println(n-max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := scanner.getCurrent()->toInteger() ;
     arr[num - 1+1] := arr[num - 1+1] + 1 )  ;     i := i + 1 ) ; 
    var max : int ; max := Set{arr[0+1], arr[1+1]}->max() ;
    max := Set{max, arr[2+1]}->max() ; 
    OclFile["System.out"].println(n - max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B899 {
  public static void main(String[] args){
    int[] history=new int[] {
      31,28,31,30,31,30,31,31,30,31,30,31,31,28,31,30,31,30,31,31,30,31,30,31,31,28,31,30,31,30,31,31,30,31,30,31,31,29,31,30,31,30,31,31,30,31,30,31,31,28,31,30,31,30,31,31,30,31,30,31,31,28,31,30,31,30,31,31,30,31,30,31,31,28,31,30,31,30,31,31,30,31,30,31 };
      Scanner in=new Scanner(System.in);
      int N=in.nextInt();
      int[] data=new int[N];
      for(int n=0 ; n<N ; n++){
        data[n]=in.nextInt();
      }
      boolean found=false ;
      for(int start=0 ; start<=history.length-data.length ; start++){
        boolean ok=true ;
        for(int i=0 ; i<data.length ; i++){
          if(history[start+i]!=data[i]){
            ok=false ;
            break ;
          }
        }
        if(ok){
          found=true ;
          break ;
        }
      }
      System.out.println(found ? "YES" : "NO");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class B899 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var history : Sequence(int) ; history := Sequence{31,28,31,30,31,30,31,31,30,31,30,31,31,28,31,30,31,30,31,31,30,31,30,31,31,28,31,30,31,30,31,31,30,31,30,31,31,29,31,30,31,30,31,31,30,31,30,31,31,28,31,30,31,30,31,31,30,31,30,31,31,28,31,30,31,30,31,31,30,31,30,31,31,28,31,30,31,30,31,31,30,31,30,31} ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var data : Sequence(int) ; data := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     data[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var found : boolean ; found := false ;
        var start : int ; start := 0 ; while start <= history->size() - data->size() do ( (     var ok : boolean ; ok := true ;
         var i : int ; i := 0 ; while i < data->size() do ( (     if (history[start + i+1] /= data[i+1]) then (     ok := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (ok) then (     found := true ; 
     break ) else skip )  ;     start := start + 1 ) ; 
    OclFile["System.out"].println(if found then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Partition {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    input.nextLine();
    String a=input.nextLine();
    String x="31 28 31 30 31 30 31 31 30 31 30 31 " ;
    String x1="31 29 31 30 31 30 31 31 30 31 30 31 " ;
    String x3=x+x1+x+x+x+x1+x+x ;
    if(x3.contains(a)){
      System.out.println("yes");
    }
    else {
      System.out.println("no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Partition {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    skip ; 
    var a : String ; a := input.nextLine() ;
    var x : String ; x := "31 28 31 30 31 30 31 31 30 31 30 31 " ;
    var x1 : String ; x1 := "31 29 31 30 31 30 31 31 30 31 30 31 " ;
    var x3 : String ; x3 := x + x1 + x + x + x + x1 + x + x ;
    if (x3->includes(a)) then (     OclFile["System.out"].println("yes") ) else (     OclFile["System.out"].println("no") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static void print_gcd_online(int n,int m,int[][] query,int[] arr){
    int max_gcd=0 ;
    int i=0 ;
    for(i=0 ; i<n ; i++)max_gcd=gcd(max_gcd,arr[i]);
    for(i=0 ; i<m ; i++){
      query[i][0]--;
      arr[query[i][0] ]/=query[i][1];
      max_gcd=gcd(arr[query[i][0] ],max_gcd);
      System.out.println(max_gcd);
    }
  }
  public static void main(String[] args){
    int n=3 ;
    int m=3 ;
    int[][] query=new int[m][2];
    int[] arr=new int[] {
      36,24,72 };
      query[0][0]=1 ;
      query[0][1]=3 ;
      query[1][0]=3 ;
      query[1][1]=12 ;
      query[2][0]=2 ;
      query[2][1]=4 ;
      print_gcd_online(n,m,query,arr);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation print_gcd_online( n : int, m : int, query : Sequence(Sequence(int)), arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var max_gcd : int ; max_gcd := 0 ;
     var i : int ; i := 0 ;
         i := 0 ; while i < n do (     max_gcd := gcd(max_gcd, arr[i+1]) ;  ;     i := i + 1 ) ; 
         i := 0 ; while i < m do ( (     query[i+1][0+1] := query[i+1][0+1] - 1 ; 
     arr[query[i+1][0+1]+1] := arr[query[i+1][0+1]+1]/(query[i+1][1+1]) ; 
     max_gcd := gcd(arr[query[i+1][0+1]+1], max_gcd) ; 
     OclFile["System.out"].println(max_gcd) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var m : int ; m := 3 ;
    var query : Sequence(Sequence(int)) ; query := Integer.subrange(1,m)->collect(Integer.subrange(1,2)->collect(0)) ;
    var arr : Sequence(int) ; arr := Sequence{36,24,72} ;
    query[0+1][0+1] := 1 ; 
    query[0+1][1+1] := 3 ; 
    query[1+1][0+1] := 3 ; 
    query[1+1][1+1] := 12 ; 
    query[2+1][0+1] := 2 ; 
    query[2+1][1+1] := 4 ; 
    execute print_gcd_online(n, m, query, arr) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findEncryptedArray(int arr[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=arr[i];
    for(int i=0 ; i<n ; i++)System.out.print(sum-arr[i]+" ");
  }
  public static void main(String[] args){
    int arr[]={
      5,1,3,2,4 };
      int N=arr.length ;
      findEncryptedArray(arr,N);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findEncryptedArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(sum - arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,1,3,2,4} ;
     var N : int ; N := arr->size() ;
     execute findEncryptedArray(arr, N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void compareVal(int x,int y){
    double a=y*Math.log(x);
    double b=x*Math.log(y);
    if(a>b)System.out.print(x+"^"+y+">"+y+"^"+x);
    else if(a<b)System.out.print(x+"^"+y+"<"+y+"^"+x);
    else if(a==b)System.out.print(x+"^"+y+"="+y+"^"+x);
  }
  public static void main(String[] args){
    int x=4,y=5 ;
    compareVal(x,y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation compareVal( x : int, y : int) : void
  pre: true
  post: true
  activity: (     var a : double ; a := y * (x)->log() ;
     var b : double ; b := x * (y)->log() ;
     if (a > b) then     OclFile["System.out"].print(x + "^" + y + ">" + y + "^" + x) ; else     if (a < b) then     OclFile["System.out"].print(x + "^" + y + "<" + y + "^" + x) else     if (a = b) then     OclFile["System.out"].print(x + "^" + y + "=" + y + "^" + x) ; else skip ; ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 4 ;
    var y : int ; y := 5 ;
     execute compareVal(x, y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
class GFG {
  static int findProduct(int arr[],int n){
    int prod=1 ;
    HashSet<Integer>s=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      if(! s.contains(arr[i])){
        prod*=arr[i];
        s.add(arr[i]);
      }
    }
    return prod ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,1,1,4,5,6 };
      int n=arr.length ;
      System.out.println(findProduct(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findProduct( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var prod : int ; prod := 1 ;
     var s : Set(int) ; s := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (not(s->includes(arr[i+1]))) then (     prod := prod*(arr[i+1]) ; 
     s := s->including(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
     return prod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,1,1,4,5,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findProduct(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findSum(int arr[],int n){
    int sum=0 ;
    HashSet<Integer>s=new HashSet<Integer>();
    for(int i=0 ; i<n ; i++){
      if(! s.contains(arr[i])){
        sum+=arr[i];
        s.add(arr[i]);
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,1,1,4,5,6 };
      int n=arr.length ;
      System.out.println(findSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var s : Set(int) ; s := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (not(s->includes(arr[i+1]))) then (     sum := sum+(arr[i+1]) ; 
     s := s->including(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,1,1,4,5,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int evenFibSum(int limit){
    if(limit<2)return 0 ;
    long ef1=0,ef2=2 ;
    long sum=ef1+ef2 ;
    while(ef2<=limit){
      long ef3=4*ef2+ef1 ;
      if(ef3>limit)break ;
      ef1=ef2 ;
      ef2=ef3 ;
      sum+=ef2 ;
    }
    return(int)sum ;
  }
  public static void main(String[] args){
    int limit=400 ;
    System.out.println(evenFibSum(limit));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation evenFibSum( limit : int) : int
  pre: true
  post: true
  activity: (     if (limit < 2) then     return 0 else skip ; 
     var ef1 : long ; ef1 := 0 ;
    var ef2 : long ; ef2 := 2 ;
    var sum : long ; sum := ef1 + ef2 ;
    while (ef2 <= limit) do (     var ef3 : long ; ef3 := 4 * ef2 + ef1 ;
     if (ef3 > limit) then     break else skip ; 
    ef1 := ef2 ; 
    ef2 := ef3 ; 
    sum := sum+(ef2) ; 
 ) ; 
    return sum->oclAsType(int) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var limit : int ; limit := 400 ;
     OclFile["System.out"].println(evenFibSum(limit)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int contiguousPerfectSquare(int[] arr,int n){
    int a ;
    float b ;
    int current_length=0 ;
    int max_length=0 ;
    for(int i=0 ; i<n ; i++){
      b=(float)Math.sqrt(arr[i]);
      a=(int)b ;
      if(a==b)current_length++;
      else current_length=0 ;
      max_length=Math.max(max_length,current_length);
    }
    return max_length ;
  }
  public static void main(String[] args){
    int arr[]={
      9,75,4,64,121,25 };
      int n=arr.length ;
      System.out.print(contiguousPerfectSquare(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation contiguousPerfectSquare( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var a : int ;
     var b : double ;
    var current_length : int ; current_length := 0 ;
    var max_length : int ; max_length := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     b := (arr[i+1])->sqrt()->oclAsType(double) ; 
     a := b->oclAsType(int) ; 
     if (a = b) then     current_length := current_length + 1 else     current_length := 0 ; ;  
     max_length := Set{max_length, current_length}->max() )  ;     i := i + 1 ) ; 
    return max_length 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{9,75,4,64,121,25} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(contiguousPerfectSquare(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] $){
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    long X=sc.nextLong();
    long M=sc.nextLong();
    long ans=0 ;
    int[] vis=new int[(int)M];
    long[] pre=new long[(int)M];
    Arrays.fill(vis,-1);
    int p=0 ;
    while(N-->0){
      vis[(int)X]=p++;
      pre[(int)X]=ans ;
      ans+=X ;
      X=X*X % M ;
      if(vis[(int)X]!=-1){
        int T=p-vis[(int)X];
        ans+=N/T*(ans-pre[(int)X]);
        N %=T ;
      }
    }
    System.out.println(ans);
  }
  void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    var X : long ; X := sc.getCurrent()->toLong() ;
    var M : long ; M := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
    var vis : Sequence(int) ; vis := Integer.subrange(1,M->oclAsType(int))->collect(0) ;
    var pre : Sequence(long) ; pre := Integer.subrange(1,M->oclAsType(int))->collect(0) ;
    vis := vis->collect(-1) ; 
    var p : int ; p := 0 ;
        while (N > 0) do (        N := N - 1 ;     skip ; (      vis[X->oclAsType(int)+1] := p  ; p := p + 1 ; 
     pre[X->oclAsType(int)+1] := ans ; 
    ans := ans+(X) ; 
    X := X * X mod M ; 
    if (vis[X->oclAsType(int)+1] /= -1) then (     var T : int ; T := p - vis[X->oclAsType(int)+1] ;
     ans := ans+(N / T * (ans - pre[X->oclAsType(int)+1])) ; 
     N := N mod T ) else skip ; 
 ) ;  ) ;  
    OclFile["System.out"].println(ans) ; 
 );
   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final long N=sc.nextLong();
    final int X=sc.nextInt();
    final int M=sc.nextInt();
    if(X==0){
      System.out.println(0);
      return ;
    }
    int A=X ;
    long[] sum=new long[M+1];
    sum[0]=A ;
    int[] idx=new int[M+1];
    idx[A]=0 ;
    int i=1 ;
    for(; i<N ; i++){
      long B=A ;
      A=(int)(B*B % M);
      if(A==X || 0<idx[A]){
        break ;
      }
      else {
        sum[i]=sum[i-1]+A ;
        idx[A]=i ;
      }
    }
    if(i==N){
      System.out.println(sum[i-1]);
      return ;
    }
    int idxRepeatStart=idx[A];
    int lenPrefix=idxRepeatStart ;
    int lenRepeat=i-idxRepeatStart ;
    long numRepeats=(N-lenPrefix)/lenRepeat ;
    int lenSuffix=(int)(N-lenPrefix-lenRepeat*numRepeats);
    long sumPrefix=0<idxRepeatStart ? sum[idxRepeatStart-1] : 0 ;
    long sumRepeat=sum[i-1]-sumPrefix ;
    long sumSuffix=0<lenSuffix ? sum[idxRepeatStart+lenSuffix-1]-sumPrefix : 0 ;
    long answer=sumPrefix+sumRepeat*numRepeats+sumSuffix ;
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    var X : int ; X := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    if (X = 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var A : int ; A := X ;
    var sum : Sequence(long) ; sum := Integer.subrange(1,M + 1)->collect(0) ;
    sum[0+1] := A ; 
    var idx : Sequence(int) ; idx := Integer.subrange(1,M + 1)->collect(0) ;
    idx[A+1] := 0 ; 
    var i : int ; i := 1 ;
      while i < N do ( (     var B : long ; B := A ;
     A := (B * B mod M)->oclAsType(int) ; 
     if (A = X or 0 < idx[A+1]) then (     break ) else (     sum[i+1] := sum[i - 1+1] + A ; 
     idx[A+1] := i ) )  ;     i := i + 1 ) ; 
    if (i = N) then (     OclFile["System.out"].println(sum[i - 1+1]) ; 
     return ) else skip ; 
    var idxRepeatStart : int ; idxRepeatStart := idx[A+1] ;
    var lenPrefix : int ; lenPrefix := idxRepeatStart ;
    var lenRepeat : int ; lenRepeat := i - idxRepeatStart ;
    var numRepeats : long ; numRepeats := (N - lenPrefix) / lenRepeat ;
    var lenSuffix : int ; lenSuffix := (N - lenPrefix - lenRepeat * numRepeats)->oclAsType(int) ;
    var sumPrefix : long ; sumPrefix := if 0 < idxRepeatStart then sum[idxRepeatStart - 1+1] else 0 endif ;
    var sumRepeat : long ; sumRepeat := sum[i - 1+1] - sumPrefix ;
    var sumSuffix : long ; sumSuffix := if 0 < lenSuffix then sum[idxRepeatStart + lenSuffix - 1+1] - sumPrefix else 0 endif ;
    var answer : long ; answer := sumPrefix + sumRepeat * numRepeats + sumSuffix ;
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int[] arr=new int[3];
    for(int i=0 ; i<n ; i++){
      int num=scanner.nextInt();
      arr[num-1]=arr[num-1]+1 ;
    }
    int max=Math.max(arr[0],arr[1]);
    max=Math.max(max,arr[2]);
    if(max==arr[0]){
      System.out.println(arr[1]+arr[2]);
    }
    else if(max==arr[1]){
      System.out.println(arr[0]+arr[2]);
    }
    else {
      System.out.println(arr[0]+arr[1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := scanner.getCurrent()->toInteger() ;
     arr[num - 1+1] := arr[num - 1+1] + 1 )  ;     i := i + 1 ) ; 
    var max : int ; max := Set{arr[0+1], arr[1+1]}->max() ;
    max := Set{max, arr[2+1]}->max() ; 
    if (max = arr[0+1]) then (     OclFile["System.out"].println(arr[1+1] + arr[2+1]) ) else     if (max = arr[1+1]) then (     OclFile["System.out"].println(arr[0+1] + arr[2+1]) ) else (     OclFile["System.out"].println(arr[0+1] + arr[1+1]) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
import java.util.Set ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    long n=Long.parseLong(sa[0]);
    int x=Integer.parseInt(sa[1]);
    int m=Integer.parseInt(sa[2]);
    br.close();
    Set<Long>set=new HashSet<>();
    long ans=x ;
    long now=x ;
    int i=1 ;
    set.add(now);
    for(; i<n ; i++){
      now=now*now % m ;
      ans+=now ;
      if(! set.add(now)){
        i++;
        break ;
      }
    }
    long sum=0 ;
    int d=0 ;
    set.clear();
    for(; i<n ; i++){
      now=now*now % m ;
      ans+=now ;
      if(! set.add(now)){
        i++;
        break ;
      }
      sum+=now ;
      d++;
    }
    if(i==n){
      System.out.println(ans);
      return ;
    }
    long r=n-i ;
    ans+=sum*(r/d);
    r %=d ;
    for(int j=0 ; j<r ; j++){
      now=now*now % m ;
      ans+=now ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var n : long ; n := (sa[0+1])->toLong() ;
    var x : int ; x := (sa[1+1])->toInteger() ;
    var m : int ; m := (sa[2+1])->toInteger() ;
    skip ; 
    var set : Set(long) ; set := Set{} ;
    var ans : long ; ans := x ;
    var now : long ; now := x ;
    var i : int ; i := 1 ;
    set := set->including(now) ; 
      while i < n do ( (     now := now * now mod m ; 
     ans := ans+(now) ; 
     if (not(set->excludes(now))) then (     i := i + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    var d : int ; d := 0 ;
    set := set->intersection(Set{}) ; 
      while i < n do ( (     now := now * now mod m ; 
     ans := ans+(now) ; 
    if (not(set->excludes(now))) then (     i := i + 1 ; 
     break ) else skip ; 
    sum := sum+(now) ; 
    d := d + 1 ; 
 )  ;     i := i + 1 ) ; 
    if (i = n) then (     OclFile["System.out"].println(ans) ; 
     return ) else skip ; 
    var r : long ; r := n - i ;
    ans := ans+(sum * (r / d)) ; 
    r := r mod d ; 
        var j : int ; j := 0 ; while j < r do ( (     now := now * now mod m ; 
     ans := ans+(now) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  static public void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    int X=sc.nextInt();
    int M=sc.nextInt();
    Set<Integer>used=new HashSet<>();
    ArrayList<Integer>A=new ArrayList<>();
    A.add(X);
    used.add(X);
    long K=0 ;
    long L=0 ;
    long ans=0 ;
    boolean breakflag=false ;
    for(int i=0 ; i<M-1 && i<N-1 ; i++){
      long prev=(long)A.get(i);
      int now=(int)((prev*prev)% M);
      if(now==0){
        for(int j=0 ; j<=i ; j++){
          ans+=A.get(j);
        }
        breakflag=true ;
        break ;
      }
      else if(used.contains(now)){
        L=i+1 ;
        for(int j=0 ; j<=i ; j++){
          if(A.get(j)==now){
            K=j ;
            break ;
          }
          ans+=A.get(j);
        }
        long sub=0 ;
        for(int j=(int)K ; j<L ; j++){
          sub+=A.get(j);
        }
        long m=(N-K)%(L-K);
        long left=0 ;
        for(int j=0 ; j<m ; j++){
          left+=A.get((int)K+j);
        }
        ans+=((N-K)/(L-K))*sub+left ;
        breakflag=true ;
        break ;
      }
      else {
        used.add(now);
        A.add(now);
      }
    }
    if(! breakflag){
      ans=0 ;
      for(int a : A){
        ans+=a ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    var X : int ; X := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var used : Set(int) ; used := Set{} ;
    var A : Sequence(int) ; A := Sequence{} ;
    A := A->including(X) ; 
    used := used->including(X) ; 
    var K : long ; K := 0 ;
    var L : long ; L := 0 ;
    var ans : long ; ans := 0 ;
    var breakflag : boolean ; breakflag := false ;
        var i : int ; i := 0 ; while i < M - 1 & i < N - 1 do ( (     var prev : long ; prev := A->at(i+1)->oclAsType(long) ;
     var now : int ; now := ((prev * prev) mod M)->oclAsType(int) ;
     if (now = 0) then (         var j : int ; j := 0 ; while j <= i do ( (     ans := ans+(A->at(j+1)) )  ;     j := j + 1 ) ; 
     breakflag := true ; 
     break ) else     if (used->includes(now)) then (     L := i + 1 ; 
         var j : int ; j := 0 ; while j <= i do ( (     if (A->at(j+1) = now) then (     K := j ; 
     break ) else skip ; 
     ans := ans+(A->at(j+1)) )  ;     j := j + 1 ) ; 
    var sub : long ; sub := 0 ;
        var j : int ; j := K->oclAsType(int) ; while j < L do ( (     sub := sub+(A->at(j+1)) )  ;     j := j + 1 ) ; 
    var m : long ; m := (N - K) mod (L - K) ;
    var left : long ; left := 0 ;
        var j : int ; j := 0 ; while j < m do ( (     left := left+(A->at(K->oclAsType(int) + j+1)) )  ;     j := j + 1 ) ; 
    ans := ans+(((N - K) / (L - K)) * sub + left) ; 
    breakflag := true ; 
    break 
 ) else (     used := used->including(now) ; 
     A := A->including(now) ) ;  )  ;     i := i + 1 ) ; 
    if (not(breakflag)) then (     ans := 0 ; 
     for (a : A) do ( (     ans := ans+(a) )  ) ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int D=sc.nextInt();
    int G=sc.nextInt();
    int[] p=new int[D];
    int[] c=new int[D];
    for(int i=0 ; i<D ; i++){
      p[i]=sc.nextInt();
      c[i]=sc.nextInt();
    }
    int min=1001 ;
    int count=0 ;
    int ans=0 ;
    int a=4 ;
    for(int i=0 ; i<Math.pow(2,D); i++){
      String bit=String.format("%"+D+"s",Integer.toBinaryString(i)).replace(' ','0');
      int N=bit.length();
      for(int j=0 ; j<N ; j++){
        if(bit.charAt(j)=='1'){
          count+=p[j]*(j+1)*100+c[j];
          ans+=p[j];
        }
      }
      if(count<G){
        for(int j=N-1 ; j>=0 ; j--){
          if(bit.charAt(j)=='0'){
            int l=p[j];
            while(count<G && l>0){
              count+=(j+1)*100 ;
              ans++;
              l--;
            }
          }
        }
      }
      if(count>=G){
        min=Math.min(ans,min);
      }
      count=0 ;
      ans=0 ;
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var D : int ; D := sc.getCurrent()->toInteger() ;
    var G : int ; G := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,D)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,D)->collect(0) ;
        var i : int ; i := 0 ; while i < D do ( (     p[i+1] := sc.getCurrent()->toInteger() ; 
     c[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var min : int ; min := 1001 ;
    var count : int ; count := 0 ;
    var ans : int ; ans := 0 ;
    var a : int ; a := 4 ;
        var i : int ; i := 0 ; while i < 2->pow(D) do ( (     var bit : String ; bit := StringLib.format("%" + D + "s",Sequence{(MathLib.decimal2binary(i) + "")}).replace(' ', '0') ;
     var N : int ; N := bit->size() ;
        var j : int ; j := 0 ; while j < N do ( (     if (bit->at(j+1) = '1') then (     count := count+(p[j+1] * (j + 1) * 100 + c[j+1]) ; 
     ans := ans+(p[j+1]) ) else skip )  ;     j := j + 1 ) ; 
    if (count < G) then (         var j : int ; j := (N)->char2byte() - 1 ; while j >= 0 do ( (     if (bit->at(j+1) = '0') then (     var l : int ; l := p[j+1] ;
     while (count < G & l > 0) do (     count := count+((j + 1) * 100) ; 
     ans := ans + 1 ; 
     l := l - 1 ) ) else skip )  ;     j := j - 1 ) ) else skip ; 
    if (count >= G) then (     min := Set{ans, min}->min() ) else skip ; 
    count := 0 ; 
    ans := 0 ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      long n=scanner.nextLong();
      int x=scanner.nextInt(),m=scanner.nextInt();
      List<Long>list=new ArrayList<>();
      Set<Long>set=new HashSet<>();
      long next=x % m ;
      list.add(next);
      set.add(next);
      while(list.size()<n){
        next=next*next % m ;
        if(set.contains(next)){
          break ;
        }
        set.add(next);
        list.add(next);
      }
      if(list.size()==n){
        System.out.println(list.stream().mapToLong(i->i).sum());
      }
      else {
        int start=list.indexOf(next);
        long loop=list.stream().skip(start).mapToLong(i->i).sum();
        long startSum=list.stream().mapToLong(i->i).limit(start).sum();
        long bai=(n-start)/(list.size()-start);
        long remain=(n-start)%(list.size()-start);
        System.out.println(startSum+bai*loop+list.stream().mapToLong(i->i).skip(start).limit(remain).sum());
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : long ; n := scanner.getCurrent()->toLong() ;
     var x : int ; x := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var list : Sequence(long) ; list := Sequence{} ;
    var set : Set(long) ; set := Set{} ;
    var next : long ; next := x mod m ;
    list := list->including(next) ; 
    set := set->including(next) ; 
    while (list->size() < n) do (     next := next * next mod m ; 
     if (set->includes(next)) then (     break ) else skip ; 
     set := set->including(next) ; 
     list := list->including(next) ) ; 
    if (list->size() = n) then (     OclFile["System.out"].println(list->collect( _x1 | (lambda i : OclAny in i)->apply(_x1) )->sum()) ) else (     var start : int ; start := list->indexOf(next)-1 ;
     var loop : long ; loop := list.subrange(start+1)->collect( _x1 | (lambda i : OclAny in i)->apply(_x1) )->sum() ;
    var startSum : long ; startSum := list->collect( _x1 | (lambda i : OclAny in i)->apply(_x1) ).subrange(1,start)->sum() ;
    var bai : long ; bai := (n - start) / (list->size() - start) ;
    var remain : long ; remain := (n - start) mod (list->size() - start) ;
    OclFile["System.out"].println(startSum + bai * loop + list->collect( _x1 | (lambda i : OclAny in i)->apply(_x1) ).subrange(start+1).subrange(1,remain)->sum()) ; 
 ) ;  
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    C solver=new C();
    solver.solve(1,in,out);
    out.close();
  }
  static class C {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int a=Integer.parseInt(in.next());
      int b=Integer.parseInt(in.next());
      int c=Integer.parseInt(in.next());
      int ans=0 ;
      int mx=Math.max(a,Math.max(b,c));
      int sum=a+b+c ;
      if((3*mx-sum)% 2==0){
        ans=(3*mx-sum)/2 ;
      }
      else {
        ans=(3*(mx+1)-sum)/2 ;
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : C ; solver := C.newC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class C {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := (in.getCurrent())->toInteger() ;
     var b : int ; b := (in.getCurrent())->toInteger() ;
    var c : int ; c := (in.getCurrent())->toInteger() ;
    var ans : int ; ans := 0 ;
    var mx : int ; mx := Set{a, Set{b, c}->max()}->max() ;
    var sum : int ; sum := a + b + c ;
    if ((3 * mx - sum) mod 2 = 0) then (     ans := (3 * mx - sum) / 2 ) else (     ans := (3 * (mx + 1) - sum) / 2 ) ;  
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String[] s=sc.nextLine().split(" ");
    int A=getInt(s[0]);
    int B=getInt(s[1]);
    int C=getInt(s[2]);
    int max=Math.max(A,B);
    max=Math.max(max,C);
    int remA=(max-A)% 2 ;
    int remB=(max-B)% 2 ;
    int remC=(max-C)% 2 ;
    int result=0 ;
    result+=(max-A-remA)!=0 ?(max-A-remA)/2 : 0 ;
    result+=(max-B-remB)!=0 ?(max-B-remB)/2 : 0 ;
    result+=(max-C-remC)!=0 ?(max-C-remC)/2 : 0 ;
    if(remA!=0 || remB!=0 || remC!=0)result++;
    if((remA+remB+remC)% 2!=0)result++;
    System.out.println(result);
    sc.close();
  }
  static int getInt(String val){
    return Integer.parseInt(val);
  }
  static long getLong(String val){
    return Long.parseLong(val);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc.nextLine()->split(" ") ;
    var A : int ; A := getInt(s[0+1]) ;
    var B : int ; B := getInt(s[1+1]) ;
    var C : int ; C := getInt(s[2+1]) ;
    var max : int ; max := Set{A, B}->max() ;
    max := Set{max, C}->max() ; 
    var remA : int ; remA := (max - A) mod 2 ;
    var remB : int ; remB := (max - B) mod 2 ;
    var remC : int ; remC := (max - C) mod 2 ;
    var result : int ; result := 0 ;
    result := result+(if (max - A - remA) /= 0 then (max - A - remA) / 2 else 0 endif) ; 
    result := result+(if (max - B - remB) /= 0 then (max - B - remB) / 2 else 0 endif) ; 
    result := result+(if (max - C - remC) /= 0 then (max - C - remC) / 2 else 0 endif) ; 
    if (remA /= 0 or remB /= 0 or remC /= 0) then     result := result + 1 ; else skip ; 
    if ((remA + remB + remC) mod 2 /= 0) then     result := result + 1 ; else skip ; 
    OclFile["System.out"].println(result) ; 
    skip ; 
 );
  static   operation getInt( val : String) : int
  pre: true
  post: true
  activity: (     return (val)->toInteger() );
  static   operation getLong( val : String) : long
  pre: true
  post: true
  activity: (     return (val)->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static public void main(String[] args){
    int[] intArray=new int[3];
    Scanner scan=new Scanner(System.in);
    for(int i=0 ; i<3 ; i++){
      intArray[i]=scan.nextInt();
    }
    scan.close();
    int max=0 ;
    for(int i=0 ; i<3 ; i++){
      if(max<intArray[i]){
        max=intArray[i];
      }
    }
    int count=0 ;
    while(intArray[0]!=max || intArray[1]!=max || intArray[2]!=max){
      count++;
      int maxCount=0 ;
      for(int i=0 ; i<3 ; i++){
        if(max==intArray[i]){
          maxCount++;
        }
      }
      if(maxCount==1){
        for(int i=0 ; i<3 ; i++){
          int target=intArray[i];
          if(target!=max){
            intArray[i]=++target ;
          }
        }
      }
      else {
        for(int i=0 ; i<3 ; i++){
          int target=intArray[i];
          if(target!=max){
            intArray[i]=target+2 ;
            if(max<target+2){
              max=target+2 ;
            }
            break ;
          }
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var intArray : Sequence(int) ; intArray := Integer.subrange(1,3)->collect(0) ;
     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
        var i : int ; i := 0 ; while i < 3 do ( (     intArray[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (max < intArray[i+1]) then (     max := intArray[i+1] ) else skip )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    while (intArray[0+1] /= max or intArray[1+1] /= max or intArray[2+1] /= max) do (     count := count + 1 ; 
     var maxCount : int ; maxCount := 0 ;
         var i : int ; i := 0 ; while i < 3 do ( (     if (max = intArray[i+1]) then (     maxCount := maxCount + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (maxCount = 1) then (         var i : int ; i := 0 ; while i < 3 do ( (     var target : int ; target := intArray[i+1] ;
     if (target /= max) then (         target := target + 1 ;
 intArray[i+1] := target  ) else skip )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < 3 do ( (     var target : int ; target := intArray[i+1] ;
     if (target /= max) then (     intArray[i+1] := target + 2 ; 
     if (max < target + 2) then (     max := target + 2 ) else skip ; 
     break ) else skip )  ;     i := i + 1 ) ) ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    new Main().solve();
  }
  void solve(){
    Scanner sc=new Scanner(System.in);
    int[] n=new int[3];
    int ans=0 ;
    int k=0,g=0 ;
    for(int i=0 ; i<3 ; i++){
      n[i]=sc.nextInt();
      if(n[i] % 2==0){
        k++;
      }
      else {
        g++;
      }
    }
    if(k>0 && k<3){
      ans++;
      if(k<g){
        for(int i=0 ; i<3 ; i++){
          if(n[i] % 2==0){
            continue ;
          }
          n[i]++;
        }
      }
      else {
        for(int i=0 ; i<3 ; i++){
          if(n[i] % 2==0){
            n[i]++;
          }
        }
      }
    }
    Arrays.sort(n);
    System.out.println(ans+(n[2]-n[1])+(n[1]-n[0])/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : Sequence(int) ; n := Integer.subrange(1,3)->collect(0) ;
    var ans : int ; ans := 0 ;
    var k : int ; k := 0 ;
    var g : int ; g := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     n[i+1] := sc.getCurrent()->toInteger() ; 
     if (n[i+1] mod 2 = 0) then (     k := k + 1 ) else (     g := g + 1 ) )  ;     i := i + 1 ) ; 
    if (k > 0 & k < 3) then (     ans := ans + 1 ; 
     if (k < g) then (         var i : int ; i := 0 ; while i < 3 do ( (     if (n[i+1] mod 2 = 0) then (     continue ) else skip ; 
     n[i+1] := n[i+1] + 1 )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < 3 do ( (     if (n[i+1] mod 2 = 0) then (     n[i+1] := n[i+1] + 1 ) else skip )  ;     i := i + 1 ) ) ) else skip ; 
    n := n->sort() ; 
    OclFile["System.out"].println(ans + (n[2+1] - n[1+1]) + (n[1+1] - n[0+1]) / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] abc=br.readLine().split(" ");
    int a=Integer.parseInt(abc[0]);
    int b=Integer.parseInt(abc[1]);
    int c=Integer.parseInt(abc[2]);
    int max=Math.max(Math.max(a,b),c);
    a=max-a ;
    b=max-b ;
    c=max-c ;
    int ans=0 ;
    int res=a % 2+b % 2+c % 2 ;
    ans+=a/2+b/2+c/2 ;
    if(res==0)System.out.println(ans);
    else if(res==1)System.out.println(ans+2);
    else System.out.println(ans+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var abc : Sequence(String) ; abc := br.readLine()->split(" ") ;
    var a : int ; a := (abc[0+1])->toInteger() ;
    var b : int ; b := (abc[1+1])->toInteger() ;
    var c : int ; c := (abc[2+1])->toInteger() ;
    var max : int ; max := Set{Set{a, b}->max(), c}->max() ;
    a := max - a ; 
    b := max - b ; 
    c := max - c ; 
    var ans : int ; ans := 0 ;
    var res : int ; res := a mod 2 + b mod 2 + c mod 2 ;
    ans := ans+(a / 2 + b / 2 + c / 2) ; 
    if (res = 0) then     OclFile["System.out"].println(ans) else     if (res = 1) then     OclFile["System.out"].println(ans + 2) else     OclFile["System.out"].println(ans + 1) ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class GFG {
  static int printSmallest(int a[]){
    int sum,sum1 ;
    Arrays.sort(a);
    int i,j,k,num ;
    for(i=0 ; i<3 ; i++){
      if(a[i] % 3==0){
        return a[i];
      }
    }
    for(i=0 ; i<3 ; i++){
      for(j=0 ; j<3 ; j++){
        num=(a[i]*10)+a[j];
        if(num % 3==0){
          return num ;
        }
      }
    }
    return a[0]*100+a[0]*10+a[0];
  }
  public static void main(String[] args){
    int arr[]={
      7,7,1 };
      System.out.println(printSmallest(arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printSmallest( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var sum : int ;
    var sum1 : int ;
     a := a->sort() ; 
    var i : int ;
    var j : int ;
    var k : int ;
    var num : int ;
        i := 0 ; while i < 3 do ( (     if (a[i+1] mod 3 = 0) then (     return a[i+1] ) else skip )  ;     i := i + 1 ) ; 
        i := 0 ; while i < 3 do ( (         j := 0 ; while j < 3 do ( (     num := (a[i+1] * 10) + a[j+1] ; 
     if (num mod 3 = 0) then (     return num ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return a[0+1] * 100 + a[0+1] * 10 + a[0+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{7,7,1} ;
     OclFile["System.out"].println(printSmallest(arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(a<=5){
      System.out.println(0);
    }
    else if(a<=12){
      System.out.println(b/2);
    }
    else {
      System.out.println(b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (a <= 5) then (     OclFile["System.out"].println(0) ) else     if (a <= 12) then (     OclFile["System.out"].println(b / 2) ) else (     OclFile["System.out"].println(b) ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] Arr=new int[n];
    for(int i=0 ; i<Arr.length ; i++){
      Arr[i]=input.nextInt();
    }
    Arrays.sort(Arr);
    int c1=0 ;
    int c2=0 ;
    int c3=0 ;
    for(int i=0 ; i<Arr.length ; i++){
      if(Arr[i]==1)c1++;
      else if(Arr[i]==2)c2++;
      else c3++;
    }
    int max=c1 ;
    if(c2>max)max=c2 ;
    if(c3>max)max=c3 ;
    System.out.println(n-max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var Arr : Sequence(int) ; Arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < Arr->size() do ( (     Arr[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    Arr := Arr->sort() ; 
    var c1 : int ; c1 := 0 ;
    var c2 : int ; c2 := 0 ;
    var c3 : int ; c3 := 0 ;
        var i : int ; i := 0 ; while i < Arr->size() do ( (     if (Arr[i+1] = 1) then     c1 := c1 + 1 ; else     if (Arr[i+1] = 2) then     c2 := c2 + 1 else     c3 := c3 + 1 ; ;  )  ;     i := i + 1 ) ; 
    var max : int ; max := c1 ;
    if (c2 > max) then     max := c2 ; else skip ; 
    if (c3 > max) then     max := c3 ; else skip ; 
    OclFile["System.out"].println(n - max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String in=br.readLine();
      String chr[]=in.split(" ");
      int a=Integer.parseInt(chr[0]);
      int b=Integer.parseInt(chr[1]);
      System.out.println(a>=13 ? b : a>=6 ? b/2 : 0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var in : String ; in := br.readLine() ;
     var chr : Sequence(String) ; chr := in->split(" ") ;
    var a : int ; a := (chr[0+1])->toInteger() ;
    var b : int ; b := (chr[1+1])->toInteger() ;
    OclFile["System.out"].println(if a >= 13 then b else if a >= 6 then b / 2 else 0 endif endif) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ReversingEncryption {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String str=br.readLine();
    char[] arr=new char[n];
    ArrayList<Integer>divisors=new ArrayList<Integer>();
    for(int i=2 ; i<n ; i++){
      if(n % i==0)divisors.add(i);
    }
    for(int i=0 ; i<n ; i++)arr[i]=str.charAt(i);
    for(int i=0 ; i<divisors.size(); i++){
      String temp=str.substring(0,divisors.get(i));
      str=reverse(temp)+str.substring(divisors.get(i),str.length());
    }
    System.out.println(reverse(str));
  }
  public static String reverse(String str){
    String temp="" ;
    for(int i=str.length()-1 ; i>=0 ; i--){
      temp+=str.charAt(i);
    }
    return temp ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ReversingEncryption {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var str : String ; str := br.readLine() ;
    var arr : Sequence(String) ; arr := Integer.subrange(1,n)->collect(0) ;
    var divisors : Sequence(int) ; divisors := Sequence{} ;
        var i : int ; i := 2 ; while i < n do ( (     if (n mod i = 0) then     divisors := divisors->including(i) ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := str->at(i+1) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < divisors->size() do ( (     var temp : String ; temp := str.subrange(0+1,divisors->at(i+1)) ;
     str := reverse(temp) + str.subrange(divisors->at(i+1)+1,str->size()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(reverse(str)) ; 
 );
  static   operation reverse( str : String) : String
  pre: true
  post: true
  activity: (     var temp : String ; temp := "" ;
         var i : int ; i := str->size() - 1 ; while i >= 0 do ( (     temp := temp+(str->at(i+1)) )  ;     i := i - 1 ) ; 
     return temp );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void updateArray(int arr[],int n){
    for(int i=n-1 ; i>0 ; i--)arr[i]=arr[i-1];
    arr[0]=-1 ;
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String[] args){
    int arr[]={
      5,1,3,2,4 };
      int N=arr.length ;
      updateArray(arr,N);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation updateArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := n - 1 ; while i > 0 do (     arr[i+1] := arr[i - 1+1] ;  ;     i := i - 1 ) ; 
     arr[0+1] := -1 ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,1,3,2,4} ;
     var N : int ; N := arr->size() ;
     execute updateArray(arr, N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static ArrayList<Integer>[] graph ;
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt(),b=sc.nextInt();
    int ans=0 ;
    if(a>=6 && a<=12)b/=2 ;
    else if(a<=5)b=0 ;
    ans=b ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute graph : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    if (a >= 6 & a <= 12) then     b := b/(2) else     if (a <= 5) then     b := 0 ; else skip ; ;  
    ans := b ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    final Scanner lineScanner=new Scanner(System.in);
    final int A=lineScanner.nextInt();
    final int B=lineScanner.nextInt();
    int cost=0 ;
    if(A>=13){
      cost=B ;
    }
    else if(A>=6 && A<=12){
      cost=B/2 ;
    }
    else {
      cost=0 ;
    }
    System.out.println(cost);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var lineScanner : OclFile ; lineScanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := lineScanner.getCurrent()->toInteger() ;
    var B : int ; B := lineScanner.getCurrent()->toInteger() ;
    var cost : int ; cost := 0 ;
    if (A >= 13) then (     cost := B ) else     if (A >= 6 & A <= 12) then (     cost := B / 2 ) else (     cost := 0 ) ;  ;  
    OclFile["System.out"].println(cost) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] in=br.readLine().split(" ");
    int a=Integer.parseInt(in[0]);
    int b=Integer.parseInt(in[1]);
    if(a>=13)System.out.println(b);
    else if(a>=6)System.out.println(b/2);
    else System.out.println(0);
    br.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var in : Sequence(String) ; in := br.readLine()->split(" ") ;
    var a : int ; a := (in[0+1])->toInteger() ;
    var b : int ; b := (in[1+1])->toInteger() ;
    if (a >= 13) then     OclFile["System.out"].println(b) else     if (a >= 6) then     OclFile["System.out"].println(b / 2) else     OclFile["System.out"].println(0) ; ;  ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    String op=sc.next();
    int B=sc.nextInt();
    int ans=0 ;
    if(op.equals("+")){
      ans=A+B ;
    }
    else if(op.equals("-")){
      ans=A-B ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var op : String ; op := sc.getCurrent() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    if (op = "+") then (     ans := A + B ) else     if (op = "-") then (     ans := A - (B)->char2byte() ) else skip ; ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int a=in.nextInt();
      char op=in.nextChar();
      int b=in.nextInt();
      out.println(op=='-' ? a-b : a+b);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public char nextChar(){
      return next().charAt(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.nextInt() ;
     var op : String ; op := in.nextChar() ;
     var b : int ; b := in.nextInt() ;
     skip );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String x=br.readLine();
    String[] cut=x.split(" ");
    int a=Integer.parseInt(cut[0]);
    int b=Integer.parseInt(cut[2]);
    System.out.println(cut[1] .equals("+")? a+b : a-b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var x : String ; x := br.readLine() ;
    var cut : Sequence(String) ; cut := x->split(" ") ;
    var a : int ; a := (cut[0+1])->toInteger() ;
    var b : int ; b := (cut[2+1])->toInteger() ;
    OclFile["System.out"].println(if cut[1+1] = "+" then a + b else a - b endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Stack ;
class Main {
  public static void main(String[] args){
    new Main().compute();
  }
  void compute(){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    String op=sc.next();
    int B=sc.nextInt();
    System.out.println(op.equals("+")? A+B : A-B);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().compute() );
   operation compute() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var op : String ; op := sc.getCurrent() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(if op = "+" then A + B else A - (B)->char2byte() endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.run();
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    String op=sc.next();
    int B=sc.nextInt();
    if(op.equals("+")){
      System.out.println(A+B);
    }
    else if(op.equals("-")){
      System.out.println(A-B);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var op : String ; op := sc.getCurrent() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    if (op = "+") then (     OclFile["System.out"].println(A + B) ) else     if (op = "-") then (     OclFile["System.out"].println(A - (B)->char2byte()) ) else skip ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class _temp2 {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] st=br.readLine().split("");
    int[] arr=new int[st.length];
    for(int i=0 ; i<st.length ; i++){
      arr[i]=Integer.parseInt(st[i]);
    }
    int idx=0 ;
    if(arr[arr.length-1] % 2==0){
      idx=-1 ;
      for(int i=0 ; i<arr.length-1 ; i++){
        if(arr[i] % 2==0 && arr[i]<arr[arr.length-1]){
          if(idx==-1){
            idx=i ;
          }
          else {
            if(arr[i]>arr[idx]){
              idx=i ;
            }
          }
        }
      }
    }
    else {
      idx=-2 ;
      for(int i=0 ; i<arr.length-1 ; i++){
        if(arr[i] % 2==0 && arr[i]<arr[arr.length-1]){
          idx=i ;
          break ;
        }
      }
      if(idx==-2){
        for(int i=arr.length-2 ; i>=0 ; i--){
          if(arr[i] % 2==0){
            idx=i ;
            break ;
          }
        }
      }
    }
    boolean print=false ;
    if(idx==-1){
      print=true ;
    }
    else if(idx==-2){
      System.out.println("-1");
    }
    else {
      int temp=arr[idx];
      arr[idx]=arr[arr.length-1];
      arr[arr.length-1]=temp ;
      print=true ;
    }
    if(print){
      for(int i=0 ; i<arr.length ; i++){
        System.out.print(arr[i]);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _temp2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : Sequence(String) ; st := br.readLine()->split("") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,st->size())->collect(0) ;
        var i : int ; i := 0 ; while i < st->size() do ( (     arr[i+1] := (st[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var idx : int ; idx := 0 ;
    if (arr[arr->size() - 1+1] mod 2 = 0) then (     idx := -1 ; 
         var i : int ; i := 0 ; while i < arr->size() - 1 do ( (     if (arr[i+1] mod 2 = 0 & arr[i+1] < arr[arr->size() - 1+1]) then (     if (idx = -1) then (     idx := i ) else (     if (arr[i+1] > arr[idx+1]) then (     idx := i ) else skip ) ) else skip )  ;     i := i + 1 ) ) else (     idx := -2 ; 
         var i : int ; i := 0 ; while i < arr->size() - 1 do ( (     if (arr[i+1] mod 2 = 0 & arr[i+1] < arr[arr->size() - 1+1]) then (     idx := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (idx = -2) then (         var i : int ; i := arr->size() - 2 ; while i >= 0 do ( (     if (arr[i+1] mod 2 = 0) then (     idx := i ; 
     break ) else skip )  ;     i := i - 1 ) ) else skip ) ;  
    var print : boolean ; print := false ;
    if (idx = -1) then (     print := true ) else     if (idx = -2) then (     OclFile["System.out"].println("-1") ) else (     var temp : int ; temp := arr[idx+1] ;
     arr[idx+1] := arr[arr->size() - 1+1] ; 
     arr[arr->size() - 1+1] := temp ; 
     print := true ) ;  ;  
    if (print) then (         var i : int ; i := 0 ; while i < arr->size() do ( (     OclFile["System.out"].print(arr[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  void run(){
    sc=new Scanner(System.in);
    for(; ; ){
      int m=sc.nextInt();
      int d=sc.nextInt();
      if(m==0 && d==0)break ;
      Calendar cal=Calendar.getInstance();
      cal.set(2004,m-1,d);
      switch(cal.get(Calendar.DAY_OF_WEEK)){
        case Calendar.MONDAY : println("Monday");
        break ;
        case Calendar.TUESDAY : println("Tuesday");
        break ;
        case Calendar.WEDNESDAY : println("Wednesday");
        break ;
        case Calendar.THURSDAY : println("Thursday");
        break ;
        case Calendar.FRIDAY : println("Friday");
        break ;
        case Calendar.SATURDAY : println("Saturday");
        break ;
        case Calendar.SUNDAY : println("Sunday");
        break ;
      }
    }
    sc.close();
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
       while true do ( (     var m : int ; m := sc.getCurrent()->toInteger() ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
    if (m = 0 & d = 0) then     break else skip ; 
    var cal : OclDate ; cal := OclDate.newOclDate() ;
    cal := cal.setAt(2004+1, d) ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (cal.get(DAY_OF_WEEK)) ; 
       if _switchval = MONDAY then
     execute println("Monday") ; 
    break 
   else skip ;
       if _switchval = TUESDAY then
     execute println("Tuesday") ; 
    break 
   else skip ;
       if _switchval = WEDNESDAY then
     execute println("Wednesday") ; 
    break 
   else skip ;
       if _switchval = THURSDAY then
     execute println("Thursday") ; 
    break 
   else skip ;
       if _switchval = FRIDAY then
     execute println("Friday") ; 
    break 
   else skip ;
       if _switchval = SATURDAY then
     execute println("Saturday") ; 
    break 
   else skip ;
       if _switchval = SUNDAY then
     execute println("Sunday") ; 
    break 
   else skip ;
 )
 )  ) ; 
     skip );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void updateArray(int arr[],int n){
    for(int i=0 ; i<=n-2 ; i++)arr[i]=arr[i+1];
    arr[n-1]=-1 ;
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String[] args){
    int arr[]={
      5,1,3,2,4 };
      int N=arr.length ;
      updateArray(arr,N);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation updateArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= n - 2 do (     arr[i+1] := arr[i + 1+1] ;  ;     i := i + 1 ) ; 
     arr[n - 1+1] := -1 ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,1,3,2,4} ;
     var N : int ; N := arr->size() ;
     execute updateArray(arr, N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class minOeration {
  static void printMinOp(int arr[]){
    int arraySum,smallest,arr_size=arr.length ;
    arraySum=0 ;
    smallest=arr[0];
    for(int i=0 ; i<arr_size ; i++){
      if(arr[i]<smallest)smallest=arr[i];
      arraySum+=arr[i];
    }
    int minOperation=arraySum-arr_size*smallest ;
    System.out.println("Minimum Operation="+minOperation);
  }
  public static void main(String[] args){
    int arr[]={
      5,6,2,4,3 };
      printMinOp(arr);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class minOeration {
  static   operation printMinOp( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var arraySum : int ;
    var smallest : int ;
    var arr_size : int ; arr_size := arr->size() ;
     arraySum := 0 ; 
    smallest := arr[0+1] ; 
        var i : int ; i := 0 ; while i < arr_size do ( (     if (arr[i+1] < smallest) then     smallest := arr[i+1] ; else skip ; 
     arraySum := arraySum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    var minOperation : int ; minOperation := arraySum - arr_size * smallest ;
    OclFile["System.out"].println("Minimum Operation=" + minOperation) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,6,2,4,3} ;
     execute printMinOp(arr) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Problem2 {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int no=s.nextInt();
    int r=no ;
    Integer[] nos=new Integer[] {
      0,0,0 };
      while(no-->0){
        int n=s.nextInt();
        if(n==1)nos[0]=nos[0]+1 ;
        else if(n==2)nos[1]=nos[1]+1 ;
        else if(n==3)nos[2]=nos[2]+1 ;
      }
      int max=Collections.max(Arrays.asList(nos));
      System.out.println(r-max);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Problem2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var no : int ; no := s.getCurrent()->toInteger() ;
    var r : int ; r := no ;
    var nos : Sequence(int) ; nos := Sequence{0,0,0} ;
        while (no > 0) do (        no := no - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     if (n = 1) then     nos[0+1] := nos[0+1] + 1 ; else     if (n = 2) then     nos[1+1] := nos[1+1] + 1 else     if (n = 3) then     nos[2+1] := nos[2+1] + 1 ; else skip ; ;  ) ;  ) ;  
    var max : int ; max := .max(nos) ;
    OclFile["System.out"].println(r - max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class main {
  class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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());
    }
    String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastScanner scan=new main().new FastScanner();
    char ch[]=scan.next().toCharArray();
    int temp=0 ;
    int index=-1 ;
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<ch.length ; ++i){
      if((ch[i]-48)% 2==0){
        if(ch[i]-48>ch[ch.length-1]-48){
          index=i ;
        }
        else {
          index=i ;
          break ;
        }
      }
    }
    if(index==-1){
      System.out.println(-1);
    }
    else {
      char temp1=ch[ch.length-1];
      ch[ch.length-1]=ch[index];
      ch[index]=temp1 ;
      for(int i=0 ; i<ch.length ; ++i){
        System.out.print(ch[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
 class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : FastScanner ; scan := (main.newmain()).newFastScanner() ;
     var ch : Sequence(String) ; ch := scan.next()->characters() ;
    var temp : int ; temp := 0 ;
    var index : int ; index := -1 ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < ch->size() do ( (     if ((ch[i+1] - 48) mod 2 = 0) then (     if (ch[i+1] - 48 > ch[ch->size() - 1+1] - 48) then (     index := i ) else (     index := i ; 
     break ) ) else skip )  ;     i := i + 1 ) ; 
    if (index = -1) then (     OclFile["System.out"].println(-1) ) else (     var temp1 : String ; temp1 := ch[ch->size() - 1+1] ;
     ch[ch->size() - 1+1] := ch[index+1] ; 
     ch[index+1] := temp1 ; 
         var i : int ; i := 0 ; while i < ch->size() do ( (     OclFile["System.out"].print(ch[i+1]) )  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isDigitPresent(int m,boolean hash[]){
    while(m>0){
      if(hash[m % 10])return true ;
      m=m/10 ;
    }
    return false ;
  }
  static int countDivisibles(int n){
    boolean hash[]=new boolean[10];
    int m=n ;
    while(m>0){
      hash[m % 10]=true ;
      m=m/10 ;
    }
    int ans=0 ;
    for(int i=1 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        if(isDigitPresent(i,hash))ans++;
        if(n/i!=i){
          if(isDigitPresent(n/i,hash))ans++;
        }
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int n=15 ;
    System.out.print(countDivisibles(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isDigitPresent( m : int, hash : Sequence(boolean)) : boolean
  pre: true
  post: true
  activity: (     while (m > 0) do (     if (hash[m mod 10+1]) then     return true else skip ; 
     m := m / 10 ) ; 
     return false );
  static   operation countDivisibles( n : int) : int
  pre: true
  post: true
  activity: (     var hash : Sequence(boolean) ; hash := Integer.subrange(1,10)->collect(false) ;
     var m : int ; m := n ;
    while (m > 0) do (     hash[m mod 10+1] := true ; 
     m := m / 10 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     if (isDigitPresent(i, hash)) then     ans := ans + 1 ; else skip ; 
     if (n / i /= i) then (     if (isDigitPresent(n / i, hash)) then     ans := ans + 1 ; else skip ) else skip ) else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     OclFile["System.out"].print(countDivisibles(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int getMinDiff(int arr[],int n,int k){
    if(n==1)return 0 ;
    Arrays.sort(arr);
    int ans=arr[n-1]-arr[0];
    int small=arr[0]+k ;
    int big=arr[n-1]-k ;
    int temp=0 ;
    if(small>big){
      temp=small ;
      small=big ;
      big=temp ;
    }
    for(int i=1 ; i<n-1 ; i++){
      int subtract=arr[i]-k ;
      int add=arr[i]+k ;
      if(subtract>=small || add<=big)continue ;
      if(big-subtract<=add-small)small=subtract ;
      else big=add ;
    }
    return Math.min(ans,big-small);
  }
  public static void main(String[] args){
    int arr[]={
      4,6 };
      int n=arr.length ;
      int k=10 ;
      System.out.println("Maximum difference is "+getMinDiff(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getMinDiff( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 0 else skip ; 
     arr := arr->sort() ; 
    var ans : int ; ans := arr[n - 1+1] - arr[0+1] ;
    var small : int ; small := arr[0+1] + k ;
    var big : int ; big := arr[n - 1+1] - k ;
    var temp : int ; temp := 0 ;
    if (small > big) then (     temp := small ; 
     small := big ; 
     big := temp ) else skip ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     var subtract : int ; subtract := arr[i+1] - k ;
     var add : int ; add := arr[i+1] + k ;
     if (subtract >= small or add <= big) then     continue else skip ; 
     if (big - subtract <= add - small) then     small := subtract ; else     big := add ; )  ;     i := i + 1 ) ; 
    return Set{ans, big - small}->min() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,6} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 10 ;
     OclFile["System.out"].println("Maximum difference is " + getMinDiff(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF_MemSql2_0_B {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    if(n==0){
      print(0,1);
      print(0,m);
      print(0,0);
      print(0,m-1);
    }
    else if(m==0){
      print(1,0);
      print(n,0);
      print(0,0);
      print(n-1,0);
    }
    else {
      if(n>m){
        double d0=2*Math.hypot(n,m-1);
        double d1=Math.hypot(n,m)+n ;
        if(d0>d1){
          print(0,1);
          print(n,m);
          print(0,0);
          print(n,m-1);
        }
        else {
          print(0,m);
          print(n,0);
          print(0,0);
          print(n,m);
        }
      }
      else {
        double d0=2*Math.hypot(n-1,m);
        double d1=Math.hypot(n,m)+m ;
        if(d0>d1){
          print(1,0);
          print(n,m);
          print(0,0);
          print(n-1,m);
        }
        else {
          print(n,0);
          print(0,m);
          print(0,0);
          print(n,m);
        }
      }
    }
  }
  public static void print(int x,int y){
    System.out.println(x+" "+y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF_MemSql2_0_B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
     if (n = 0) then (     execute print(0, 1) ; 
     execute print(0, m) ; 
     execute print(0, 0) ; 
     execute print(0, m - 1) ) else     if (m = 0) then (     execute print(1, 0) ; 
     execute print(n, 0) ; 
     execute print(0, 0) ; 
     execute print(n - 1, 0) ) else (     if (n > m) then (     var d0 : double ; d0 := 2 * hypot(n, m - 1) ;
     var d1 : double ; d1 := hypot(n, m) + n ;
     if (d0 > d1) then (     execute print(0, 1) ; 
     execute print(n, m) ; 
     execute print(0, 0) ; 
     execute print(n, m - 1) ) else (     execute print(0, m) ; 
     execute print(n, 0) ; 
     execute print(0, 0) ; 
     execute print(n, m) ) ) else (     var d0 : double ; d0 := 2 * hypot(n - 1, m) ;
     var d1 : double ; d1 := hypot(n, m) + m ;
     if (d0 > d1) then (     execute print(1, 0) ; 
     execute print(n, m) ; 
     execute print(0, 0) ; 
     execute print(n - 1, m) ) else (     execute print(n, 0) ; 
     execute print(0, m) ; 
     execute print(0, 0) ; 
     execute print(n, m) ) ) ) ;  );
  static   operation print( x : int, y : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(x + " " + y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public TreeNode searchBST(TreeNode root,int val){
    while(root!=null && root.val!=val){
      root=val<root.val ? root.left : root.right ;
    }
    return root ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation searchBST( root : TreeNode, val : int) : TreeNode
  pre: true
  post: true
  activity: (     while (root /= null & root.val /= val) do (     root := if val < root.val then root.left else root.right endif ) ; 
     return root );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean pointsAreOnSameSideOfLine(int a,int b,int c,int x1,int y1,int x2,int y2){
    int fx1 ;
    int fx2 ;
    fx1=a*x1+b*y1-c ;
    fx2=a*x2+b*y2-c ;
    if((fx1*fx2)>0)return true ;
    return false ;
  }
  public static void main(String[] args){
    int a=1,b=1,c=1 ;
    int x1=1,y1=1 ;
    int x2=2,y2=1 ;
    if(pointsAreOnSameSideOfLine(a,b,c,x1,y1,x2,y2))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pointsAreOnSameSideOfLine( a : int, b : int, c : int, x1 : int, y1 : int, x2 : int, y2 : int) : boolean
  pre: true
  post: true
  activity: (     var fx1 : int ;
     var fx2 : int ;
    fx1 := a * x1 + b * y1 - c ; 
    fx2 := a * x2 + b * y2 - c ; 
    if ((fx1 * fx2) > 0) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 1 ;
    var b : int ; b := 1 ;
    var c : int ; c := 1 ;
     var x1 : int ; x1 := 1 ;
    var y1 : int ; y1 := 1 ;
     var x2 : int ; x2 := 2 ;
    var y2 : int ; y2 := 1 ;
     if (pointsAreOnSameSideOfLine(a, b, c, x1, y1, x2, y2)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void sortedAdjacentDifferences(int arr[],int n){
    int[] ans=new int[n];
    Arrays.sort(arr);
    int l=0,r=n-1 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(i % 2==1){
        ans[i]=arr[l];
        l++;
      }
      else {
        ans[i]=arr[r];
        r--;
      }
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(ans[i]+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      5,-2,4,8,6,4,5 };
      int n=arr.length ;
      sortedAdjacentDifferences(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sortedAdjacentDifferences( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
     arr := arr->sort() ; 
    var l : int ; l := 0 ;
    var r : int ; r := n - 1 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (i mod 2 = 1) then (     ans[i+1] := arr[l+1] ; 
     l := l + 1 ) else (     ans[i+1] := arr[r+1] ; 
     r := r - 1 ) )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(ans[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,-2,4,8,6,4,5} ;
     var n : int ; n := arr->size() ;
     execute sortedAdjacentDifferences(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static int minSteps(int arr[],int n){
    int min_Steps=0 ;
    for(int i=0 ; i<n ; i++){
      if(i>0)min_Steps+=Math.abs(arr[i]-arr[i-1]);
      else min_Steps+=Math.abs(arr[i]);
    }
    return min_Steps ;
  }
  public static void main(String argc[]){
    int[] arr=new int[] {
      1,2,2,1 };
      int n=4 ;
      System.out.println(minSteps(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation minSteps( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var min_Steps : int ; min_Steps := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (i > 0) then     min_Steps := min_Steps+(if arr[i+1] - arr[i - 1+1] < 0 then -(arr[i+1] - arr[i - 1+1]) else arr[i+1] - arr[i - 1+1] endif) ; else     min_Steps := min_Steps+(if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif) ; )  ;     i := i + 1 ) ; 
     return min_Steps );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,2,1} ;
     var n : int ; n := 4 ;
     OclFile["System.out"].println(minSteps(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  public static int partition(int[] arr,int low,int high){
    int pivot=arr[high],pivotloc=low ;
    for(int i=low ; i<=high ; i++){
      if(arr[i]<pivot){
        int temp=arr[i];
        arr[i]=arr[pivotloc];
        arr[pivotloc]=temp ;
        pivotloc++;
      }
    }
    int temp=arr[high];
    arr[high]=arr[pivotloc];
    arr[pivotloc]=temp ;
    return pivotloc ;
  }
  public static int kthSmallest(int[] arr,int low,int high,int k){
    int partition=partition(arr,low,high);
    if(partition==k)return arr[partition];
    else if(partition<k)return kthSmallest(arr,partition+1,high,k);
    else return kthSmallest(arr,low,partition-1,k);
  }
  public static void main(String[] args){
    int[] array=new int[] {
      10,4,5,8,6,11,26 };
      int[] arraycopy=new int[] {
        10,4,5,8,6,11,26 };
        int kPosition=3 ;
        int length=array.length ;
        if(kPosition>length){
          System.out.println("Index out of bound");
        }
        else {
          System.out.println("K-th smallest element in array : "+kthSmallest(arraycopy,0,length-1,kPosition-1));
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation partition( arr : Sequence(int), low : int, high : int) : int
  pre: true
  post: true
  activity: (     var pivot : int ; pivot := arr[high+1] ;
    var pivotloc : int ; pivotloc := low ;
         var i : int ; i := low ; while i <= high do ( (     if (arr[i+1] < pivot) then (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := arr[pivotloc+1] ; 
     arr[pivotloc+1] := temp ; 
     pivotloc := pivotloc + 1 ) else skip )  ;     i := i + 1 ) ; 
    var temp : int ; temp := arr[high+1] ;
    arr[high+1] := arr[pivotloc+1] ; 
    arr[pivotloc+1] := temp ; 
    return pivotloc 
 );
  static   operation kthSmallest( arr : Sequence(int), low : int, high : int, k : int) : int
  pre: true
  post: true
  activity: (     var partition : int ; partition := partition(arr, low, high) ;
     if (partition = k) then     return arr[partition+1] else     if (partition < k) then     return kthSmallest(arr, partition + 1, high, k) else     return kthSmallest(arr, low, partition - 1, k) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Sequence{10,4,5,8,6,11,26} ;
     var arraycopy : Sequence(int) ; arraycopy := Sequence{10,4,5,8,6,11,26} ;
    var kPosition : int ; kPosition := 3 ;
    var length : int ; length := array->size() ;
    if (kPosition > length) then (     OclFile["System.out"].println("Index out of bound") ) else (     OclFile["System.out"].println("K-th smallest element in array : " + kthSmallest(arraycopy, 0, length - 1, kPosition - 1)) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MaxNumbers(int a[],int n){
    int[] fre={
      0,0,0 };
      for(int i=0 ; i<n ; i++){
        a[i] %=3 ;
        fre[a[i] ]++;
      }
      int ans=fre[0];
      int k=Math.min(fre[1],fre[2]);
      ans+=k ;
      fre[1]-=k ;
      fre[2]-=k ;
      ans+=fre[1]/3+fre[2]/3 ;
      return ans ;
    }
    public static void main(String[] args){
      int a[]={
        1,4,10,7,11,2,8,5,9 };
        int n=a.length ;
        System.out.println(MaxNumbers(a,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MaxNumbers( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var fre : Sequence(int) ; fre := Sequence{0,0,0} ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := a[i+1] mod 3 ; 
     fre[a[i+1]+1] := fre[a[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := fre[0+1] ;
    var k : int ; k := Set{fre[1+1], fre[2+1]}->min() ;
    ans := ans+(k) ; 
    fre[1+1] := fre[1+1]-(k) ; 
    fre[2+1] := fre[2+1]-(k) ; 
    ans := ans+(fre[1+1] / 3 + fre[2+1] / 3) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,4,10,7,11,2,8,5,9} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(MaxNumbers(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findModulo(String s){
    int l=s.length();
    int i,modulus=0 ;
    if(s.contains("+")){
      i=s.indexOf("+");
    }
    else {
      i=s.indexOf("-");
    }
    String real=s.substring(0,i);
    String imaginary=s.substring(i+1,l-1);
    int x=Integer.parseInt(real);
    int y=Integer.parseInt(imaginary);
    System.out.print(Math.sqrt(x*x+y*y)+"\n");
  }
  public static void main(String[] args){
    String s="3+4i" ;
    findModulo(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findModulo( s : String) : void
  pre: true
  post: true
  activity: (     var l : int ; l := s->size() ;
     var i : int ;
    var modulus : int ; modulus := 0 ;
    if (s->includes("+")) then (     i := s->indexOf("+")-1 ) else (     i := s->indexOf("-")-1 ) ;  
    var real : String ; real := s.subrange(0+1,i) ;
    var imaginary : String ; imaginary := s.subrange(i + 1+1,l - 1) ;
    var x : int ; x := (real)->toInteger() ;
    var y : int ; y := (imaginary)->toInteger() ;
    OclFile["System.out"].print((x * x + y * y)->sqrt() + "\n") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "3+4i" ;
     execute findModulo(s) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static long fun(int marks[],int n){
    long dp[]=new long[n];
    int temp ;
    for(int i=0 ; i<n ; i++)dp[i]=1 ;
    for(int i=0 ; i<n-1 ; i++){
      if(marks[i]>marks[i+1]){
        temp=i ;
        while(true){
          if((marks[temp]>marks[temp+1])&& temp>=0){
            if(dp[temp]>dp[temp+1]){
              temp-=1 ;
              continue ;
            }
            else {
              dp[temp]=dp[temp+1]+1 ;
              temp-=1 ;
            }
          }
          else break ;
        }
      }
      else if(marks[i]<marks[i+1])dp[i+1]=dp[i]+1 ;
    }
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=dp[i];
    return sum ;
  }
  public static void main(String args[]){
    int n=6 ;
    int marks[]={
      1,4,5,2,2,1 };
      System.out.println(fun(marks,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation fun( marks : Sequence(int), n : int) : long
  pre: true
  post: true
  activity: (     var dp : Sequence(long) ; dp := Integer.subrange(1,n)->collect(0) ;
     var temp : int ;
        var i : int ; i := 0 ; while i < n do (     dp[i+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (marks[i+1] > marks[i + 1+1]) then (     temp := i ; 
     while (true) do (     if ((marks[temp+1] > marks[temp + 1+1]) & temp >= 0) then (     if (dp[temp+1] > dp[temp + 1+1]) then (     temp := temp-(1) ; 
     continue ) else (     dp[temp+1] := dp[temp + 1+1] + 1 ; 
     temp := temp-(1) ) ) else     break ) ) else     if (marks[i+1] < marks[i + 1+1]) then     dp[i + 1+1] := dp[i+1] + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (     sum := sum+(dp[i+1]) ;  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     var marks : Sequence(int) ; marks := Sequence{1,4,5,2,2,1} ;
     OclFile["System.out"].println(fun(marks, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      int arr1[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr1[i]=arr[i];
      }
      Arrays.sort(arr);
      int ele=0 ;
      if(arr[0]!=arr[1]){
        ele=arr[0];
        for(int i=0 ; i<n ; i++){
          if(arr1[i]==ele){
            System.out.println(i+1);
            break ;
          }
        }
      }
      else {
        for(int i=0 ; i<n-1 ; i++){
          if(arr[i]!=arr[i+1]){
            ele=arr[i+1];
            break ;
          }
        }
        for(int i=0 ; i<n ; i++){
          if(arr1[i]==ele){
            System.out.println(i+1);
            break ;
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr1[i+1] := arr[i+1] )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var ele : int ; ele := 0 ;
    if (arr[0+1] /= arr[1+1]) then (     ele := arr[0+1] ; 
         var i : int ; i := 0 ; while i < n do ( (     if (arr1[i+1] = ele) then (     OclFile["System.out"].println(i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] /= arr[i + 1+1]) then (     ele := arr[i + 1+1] ; 
     break ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (arr1[i+1] = ele) then (     OclFile["System.out"].println(i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class cf1512a {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=scan.nextInt();
      int[] a1=new int[n];
      for(int j=0 ; j<n ; j++){
        a1[j]=scan.nextInt();
      }
      int[] a2=Arrays.copyOf(a1,n);
      Arrays.sort(a2);
      for(int j=0 ; j<n ; j++){
        if(a1[j]!=a2[1]){
          System.out.println(j+1);
        }
      }
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1512a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var a1 : Sequence(int) ; a1 := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     a1[j+1] := scan.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    var a2 : Sequence(int) ; a2 := a1.subrange(1,n) ;
    a2 := a2->sort() ; 
        var j : int ; j := 0 ; while j < n do ( (     if (a1[j+1] /= a2[1+1]) then (     OclFile["System.out"].println(j + 1) ) else skip )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf1512A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=scan.nextInt();
      int[] a=new int[n];
      for(int x=0 ; x<n ; x++){
        a[x]=scan.nextInt();
      }
      int posoffirstnum=0 ;
      int posofsecnum=0 ;
      int countoffirstnum=0 ;
      int countofsecondnum=0 ;
      for(int y=0 ; y<n ; y++){
        if(a[0]!=a[y]){
          posofsecnum=y ;
          countofsecondnum+=1 ;
        }
        else {
          countoffirstnum+=1 ;
        }
      }
      if(countofsecondnum==1){
        System.out.println(posofsecnum+1);
      }
      else if(countoffirstnum==1){
        System.out.println(posoffirstnum+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1512A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var x : int ; x := 0 ; while x < n do ( (     a[x+1] := scan.getCurrent()->toInteger() )  ;     x := x + 1 ) ; 
    var posoffirstnum : int ; posoffirstnum := 0 ;
    var posofsecnum : int ; posofsecnum := 0 ;
    var countoffirstnum : int ; countoffirstnum := 0 ;
    var countofsecondnum : int ; countofsecondnum := 0 ;
        var y : int ; y := 0 ; while y < n do ( (     if (a[0+1] /= a[y+1]) then (     posofsecnum := y ; 
     countofsecondnum := countofsecondnum+(1) ) else (     countoffirstnum := countoffirstnum+(1) ) )  ;     y := y + 1 ) ; 
    if (countofsecondnum = 1) then (     OclFile["System.out"].println(posofsecnum + 1) ) else     if (countoffirstnum = 1) then (     OclFile["System.out"].println(posoffirstnum + 1) ) else skip ; ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class A_Spy_Detected {
  public static void main(String[] args){
    Scanner sn=new Scanner(System.in);
    int t=sn.nextInt();
    while(t-->0){
      int n=sn.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=sn.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=arr[i];
      Arrays.sort(a);
      int ans=0 ;
      for(int i=0 ; i<n ; i++){
        if(arr[i]!=a[1])ans=i+1 ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Spy_Detected {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sn : OclFile ; sn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sn.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sn.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sn.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := arr[i+1] ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] /= a[1+1]) then     ans := i + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countPairs(int arr[],int n){
    int forward[]=new int[n];
    Stack<Integer>sForward=new Stack<Integer>();
    for(int i=0 ; i<n ; i++){
      while(! sForward.empty()&& arr[i]>arr[(Integer)sForward.peek()]){
        forward[(Integer)sForward.peek()]=1 ;
        sForward.pop();
      }
      sForward.push(i);
    }
    int backward[]=new int[n];
    Stack<Integer>sBackward=new Stack<Integer>();
    for(int i=n-1 ; i>=0 ; i--){
      while(! sBackward.empty()&& arr[i]>arr[(Integer)sBackward.peek()]){
        backward[(Integer)sBackward.peek()]=1 ;
        sBackward.pop();
      }
      sBackward.push(i);
    }
    int res=0 ;
    for(int i=0 ; i<n ; i++){
      res+=forward[i]+backward[i];
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5 };
      int n=arr.length ;
      System.out.println(countPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var forward : Sequence(int) ; forward := Integer.subrange(1,n)->collect(0) ;
     var sForward : Sequence(int) ; sForward := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     while (not(sForward->isEmpty()) & arr[i+1] > arr[sForward->min()->oclAsType(int)+1]) do (     forward[sForward->min()->oclAsType(int)+1] := 1 ; 
     sForward := sForward->front() ) ; 
     sForward := sForward->append(i) )  ;     i := i + 1 ) ; 
    var backward : Sequence(int) ; backward := Integer.subrange(1,n)->collect(0) ;
    var sBackward : Sequence(int) ; sBackward := Sequence{} ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     while (not(sBackward->isEmpty()) & arr[i+1] > arr[sBackward->min()->oclAsType(int)+1]) do (     backward[sBackward->min()->oclAsType(int)+1] := 1 ; 
     sBackward := sBackward->front() ) ; 
     sBackward := sBackward->append(i) )  ;     i := i - 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     res := res+(forward[i+1] + backward[i+1]) )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countPairs(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B_A_Tide_of_Riverscape {
  static Scanner in=new Scanner(System.in);
  static int n,p ;
  public static void main(String[] amit){
    n=in.nextInt();
    p=in.nextInt();
    char a[]=in.next().toCharArray();
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]=='0'){
        for(int j=i+p ; j<n ; j+=p){
          if(a[j]=='.'){
            ans=1 ;
            a[j]='1' ;
          }
          else if(a[j]=='1'){
            ans=1 ;
          }
        }
      }
      else if(a[i]=='1'){
        for(int j=i+p ; j<n ; j+=p){
          if(a[j]=='.'){
            ans=1 ;
            a[j]='0' ;
          }
          else if(a[j]=='0'){
            ans=1 ;
          }
        }
      }
      else {
        a[i]='1' ;
        for(int j=i+p ; j<n ; j+=p){
          if(a[j]=='.'){
            ans=1 ;
            a[i]='1' ;
            a[j]='0' ;
          }
          else if(a[j]=='1'){
            ans=1 ;
            a[i]='0' ;
          }
          else {
            ans=1 ;
            a[i]='1' ;
          }
        }
      }
    }
    if(ans==1){
      for(char i : a){
        System.out.print(i);
      }
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_A_Tide_of_Riverscape {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   operation main( amit : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := in.getCurrent()->toInteger() ; 
     p := in.getCurrent()->toInteger() ; 
    var a : Sequence(String) ; a := in.getCurrent()->characters() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = '0') then (         var j : int ; j := i + p ; while j < n do ( (     if (a[j+1] = '.') then (     ans := 1 ; 
     a[j+1] := '1' ) else     if (a[j+1] = '1') then (     ans := 1 ) else skip ; )  ;     j := j+(p) ) ) else     if (a[i+1] = '1') then (         var j : int ; j := i + p ; while j < n do ( (     if (a[j+1] = '.') then (     ans := 1 ; 
     a[j+1] := '0' ) else     if (a[j+1] = '0') then (     ans := 1 ) else skip ; )  ;     j := j+(p) ) ) else (     a[i+1] := '1' ; 
         var j : int ; j := i + p ; while j < n do ( (     if (a[j+1] = '.') then (     ans := 1 ; 
     a[i+1] := '1' ; 
     a[j+1] := '0' ) else     if (a[j+1] = '1') then (     ans := 1 ; 
     a[i+1] := '0' ) else (     ans := 1 ; 
     a[i+1] := '1' ) ;  )  ;     j := j+(p) ) ) ;  )  ;     i := i + 1 ) ; 
    if (ans = 1) then (     for (i : a) do ( (     OclFile["System.out"].print(i) )  ) ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int num=scanner.nextInt();
    long[][] pairs=new long[num][2];
    for(int i=0 ; i<num ; i++){
      pairs[i][0]=scanner.nextLong();
      pairs[i][1]=scanner.nextLong();
    }
    HashSet<Long>commonFactors=new HashSet<>();
    for(int i=0 ; i<2 ; i++){
      long X=pairs[0][i];
      for(long k=2 ; k<=(long)Math.ceil(Math.sqrt(X)); k++){
        if(X % k==0){
          while(X % k==0){
            X/=k ;
          }
          commonFactors.add(k);
        }
      }
      if(X!=1){
        commonFactors.add(X);
      }
    }
    for(long val : commonFactors){
      boolean works=true ;
      for(int i=0 ; i<pairs.length ; i++){
        if(pairs[i][0] % val>0 && pairs[i][1] % val>0){
          works=false ;
          break ;
        }
      }
      if(works){
        System.out.println(val);
        return ;
      }
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := scanner.getCurrent()->toInteger() ;
    var pairs : Sequence(Sequence(long)) ; pairs := Integer.subrange(1,num)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < num do ( (     pairs[i+1][0+1] := scanner.getCurrent()->toLong() ; 
     pairs[i+1][1+1] := scanner.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var commonFactors : Set(long) ; commonFactors := Set{} ;
        var i : int ; i := 0 ; while i < 2 do ( (     var X : long ; X := pairs[0+1][i+1] ;
         var k : long ; k := 2 ; while k <= ((X)->sqrt())->ceil()->oclAsType(long) do ( (     if (X mod k = 0) then (     while (X mod k = 0) do (     X := X/(k) ) ; 
     commonFactors := commonFactors->including(k) ) else skip )  ;     k := k + 1 ) ; 
     if (X /= 1) then (     commonFactors := commonFactors->including(X) ) else skip )  ;     i := i + 1 ) ; 
    for (val : commonFactors) do ( (     var works : boolean ; works := true ;
         var i : int ; i := 0 ; while i < pairs->size() do ( (     if (pairs[i+1][0+1] mod val > 0 & pairs[i+1][1+1] mod val > 0) then (     works := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (works) then (     OclFile["System.out"].println(val) ; 
     return ) else skip )  ) ; 
    OclFile["System.out"].println(-1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _989b {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int p=sc.nextInt();
    char[] ch=sc.next().toCharArray();
    boolean period=true,done=false ;
    for(int i=0 ; i<n ; i++){
      if(i+p<n && ch[i]=='.' && ch[i+p]=='.'){
        ch[i]='0' ;
        ch[i+p]='1' ;
        done=true ;
      }
      else if(i+p<n && ch[i]=='.'){
        ch[i]=ch[i+p]=='1' ? '0' : '1' ;
        done=true ;
      }
      else if(i+p<n && ch[i+p]=='.'){
        ch[i+p]=ch[i]=='0' ? '1' : '0' ;
        done=true ;
      }
      if(done)break ;
    }
    for(int i=0 ; i<n ; i++){
      if(ch[i]=='.')ch[i]='1' ;
    }
    for(int i=0 ; i<n-p ; i++){
      if(ch[i]!=ch[i+p]){
        period=false ;
        break ;
      }
    }
    if(period)System.out.println("NO");
    else {
      for(char i : ch)System.out.print(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _989b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
    var ch : Sequence(String) ; ch := sc.getCurrent()->characters() ;
    var period : boolean ; period := true ;
    var done : boolean ; done := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (i + p < n & ch[i+1] = '.' & ch[i + p+1] = '.') then (     ch[i+1] := '0' ; 
     ch[i + p+1] := '1' ; 
     done := true ) else     if (i + p < n & ch[i+1] = '.') then (     ch[i+1] := if ch[i + p+1] = '1' then '0' else '1' endif ; 
     done := true ) else     if (i + p < n & ch[i + p+1] = '.') then (     ch[i + p+1] := if ch[i+1] = '0' then '1' else '0' endif ; 
     done := true ) else skip ; ;  ;  
     if (done) then     break else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (ch[i+1] = '.') then     ch[i+1] := '1' ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - p do ( (     if (ch[i+1] /= ch[i + p+1]) then (     period := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (period) then     OclFile["System.out"].println("NO") else (     for (i : ch) do (     OclFile["System.out"].print(i) ;  ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CodeForces989B {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int m=input.nextInt();
    input.nextLine();
    char[] s=input.nextLine().toCharArray();
    boolean b=false ;
    for(int i=0 ; i<n-m ; i++){
      if(s[i]=='.' && s[i+m]=='.'){
        s[i]='0' ;
        s[i+m]='1' ;
        b=true ;
      }
      else if(s[i]=='.'){
        s[i]=s[i+m]=='0' ? '1' : '0' ;
        b=true ;
      }
      else if(s[i+m]=='.'){
        s[i+m]=s[i]=='0' ? '1' : '0' ;
        b=true ;
      }
      else if(s[i]!=s[i+m]){
        b=true ;
      }
    }
    if(b){
      for(Character c : s){
        System.out.print(c!='.' ? c : '0');
      }
      System.out.println();
    }
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces989B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var m : int ; m := input.getCurrent()->toInteger() ;
    skip ; 
    var s : Sequence(String) ; s := input.nextLine()->characters() ;
    var b : boolean ; b := false ;
        var i : int ; i := 0 ; while i < n - m do ( (     if (s[i+1] = '.' & s[i + m+1] = '.') then (     s[i+1] := '0' ; 
     s[i + m+1] := '1' ; 
     b := true ) else     if (s[i+1] = '.') then (     s[i+1] := if s[i + m+1] = '0' then '1' else '0' endif ; 
     b := true ) else     if (s[i + m+1] = '.') then (     s[i + m+1] := if s[i+1] = '0' then '1' else '0' endif ; 
     b := true ) else     if (s[i+1] /= s[i + m+1]) then (     b := true ) else skip ; ;  ;  )  ;     i := i + 1 ) ; 
    if (b) then (     for (c : s) do ( (     OclFile["System.out"].print(if c /= '.' then c else '0' endif) )  ) ; 
     OclFile["System.out"].println() ) else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner in=new Scanner(System.in);
  static int n,p ;
  public static void main(String[] amit){
    n=in.nextInt();
    p=in.nextInt();
    char a[]=in.next().toCharArray();
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]=='0'){
        for(int j=i+p ; j<n ; j+=p){
          if(a[j]=='.'){
            ans=1 ;
            a[j]='1' ;
          }
          else if(a[j]=='1'){
            ans=1 ;
          }
        }
      }
      else if(a[i]=='1'){
        for(int j=i+p ; j<n ; j+=p){
          if(a[j]=='.'){
            ans=1 ;
            a[j]='0' ;
          }
          else if(a[j]=='0'){
            ans=1 ;
          }
        }
      }
      else {
        a[i]='1' ;
        for(int j=i+p ; j<n ; j+=p){
          if(a[j]=='.'){
            ans=1 ;
            a[i]='1' ;
            a[j]='0' ;
          }
          else if(a[j]=='1'){
            ans=1 ;
            a[i]='0' ;
          }
          else {
            ans=1 ;
            a[i]='1' ;
          }
        }
      }
    }
    if(ans==1){
      for(char i : a){
        System.out.print(i);
      }
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   operation main( amit : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := in.getCurrent()->toInteger() ; 
     p := in.getCurrent()->toInteger() ; 
    var a : Sequence(String) ; a := in.getCurrent()->characters() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = '0') then (         var j : int ; j := i + p ; while j < n do ( (     if (a[j+1] = '.') then (     ans := 1 ; 
     a[j+1] := '1' ) else     if (a[j+1] = '1') then (     ans := 1 ) else skip ; )  ;     j := j+(p) ) ) else     if (a[i+1] = '1') then (         var j : int ; j := i + p ; while j < n do ( (     if (a[j+1] = '.') then (     ans := 1 ; 
     a[j+1] := '0' ) else     if (a[j+1] = '0') then (     ans := 1 ) else skip ; )  ;     j := j+(p) ) ) else (     a[i+1] := '1' ; 
         var j : int ; j := i + p ; while j < n do ( (     if (a[j+1] = '.') then (     ans := 1 ; 
     a[i+1] := '1' ; 
     a[j+1] := '0' ) else     if (a[j+1] = '1') then (     ans := 1 ; 
     a[i+1] := '0' ) else (     ans := 1 ; 
     a[i+1] := '1' ) ;  )  ;     j := j+(p) ) ) ;  )  ;     i := i + 1 ) ; 
    if (ans = 1) then (     for (i : a) do ( (     OclFile["System.out"].print(i) )  ) ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A930 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int[] dist=new int[N];
    int[] distStat=new int[N];
    distStat[0]=1 ;
    for(int n=1 ; n<N ; n++){
      int parent=in.nextInt()-1 ;
      dist[n]=dist[parent]+1 ;
      distStat[dist[n] ]++;
    }
    int answer=0 ;
    for(int stat : distStat){
      answer+=stat % 2 ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A930 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var dist : Sequence(int) ; dist := Integer.subrange(1,N)->collect(0) ;
    var distStat : Sequence(int) ; distStat := Integer.subrange(1,N)->collect(0) ;
    distStat[0+1] := 1 ; 
        var n : int ; n := 1 ; while n < N do ( (     var parent : int ; parent := in.getCurrent()->toInteger() - 1 ;
     dist[n+1] := dist[parent+1] + 1 ; 
     distStat[dist[n+1]+1] := distStat[dist[n+1]+1] + 1 )  ;     n := n + 1 ) ; 
    var answer : int ; answer := 0 ;
    for (stat : distStat) do ( (     answer := answer+(stat mod 2) )  ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int mod(String num,int a){
    int res=0 ;
    for(int i=0 ; i<num.length(); i++)res=(res*10+(int)num.charAt(i)-'0')% a ;
    return res ;
  }
  public static void main(String[] args){
    String num="12316767678678" ;
    System.out.println(mod(num,10));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation mod( num : String, a : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < num->size() do (     res := (res * 10 + num->at(i+1)->oclAsType(int) - ('0')->char2byte()) mod a ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : String ; num := "12316767678678" ;
     OclFile["System.out"].println(mod(num, 10)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String s=scanner.next();
    List<Integer>list=new ArrayList<Integer>();
    for(int k=0 ; k<s.length(); k++){
      list.add(0);
    }
    boolean inR=true ;
    int hotR=-1 ;
    int hotL=-1 ;
    int leftRange=0 ;
    for(int k=0 ; k<s.length(); k++){
      char cha=s.charAt(k);
      if(inR){
        if(cha=='L'){
          inR=false ;
          hotL=k ;
          hotR=k-1 ;
        }
      }
      else {
        if(cha=='R'){
          resolve(list,hotR,hotL,leftRange,k-1);
          leftRange=k ;
          inR=true ;
        }
      }
    }
    resolve(list,hotL,hotR,leftRange,s.length()-1);
    String str=list.stream().map(i->i.toString()).collect(Collectors.joining(" "));
    System.out.println(str);
  }
  private static void resolve(List<Integer>list,int hotL,int hotR,int leftRange,int rightRange){
    int value=(rightRange-leftRange+1)/2 ;
    if((rightRange-leftRange+1)% 2==0){
      list.set(hotL,value);
      list.set(hotR,value);
    }
    else {
      if((hotR-leftRange)% 2==0){
        list.set(hotL,value);
        list.set(hotR,value+1);
      }
      else {
        list.set(hotL,value+1);
        list.set(hotR,value);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scanner.getCurrent() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var k : int ; k := 0 ; while k < s->size() do ( (     list := list->including(0) )  ;     k := k + 1 ) ; 
    var inR : boolean ; inR := true ;
    var hotR : int ; hotR := -1 ;
    var hotL : int ; hotL := -1 ;
    var leftRange : int ; leftRange := 0 ;
        var k : int ; k := 0 ; while k < s->size() do ( (     var cha : String ; cha := s->at(k+1) ;
     if (inR) then (     if (cha = 'L') then (     inR := false ; 
     hotL := k ; 
     hotR := k - 1 ) else skip ) else (     if (cha = 'R') then (     execute resolve(list, hotR, hotL, leftRange, k - 1) ; 
     leftRange := k ; 
     inR := true ) else skip ) )  ;     k := k + 1 ) ; 
    execute resolve(list, hotL, hotR, leftRange, s->size() - 1) ; 
    var str : String ; str := list->collect( _x1 | (lambda i : OclAny in i+"")->apply(_x1) ).collect(Collectors.joining(" ")) ;
    OclFile["System.out"].println(str) ; 
 );
  static   operation resolve( list : Sequence(int), hotL : int, hotR : int, leftRange : int, rightRange : int) : void
  pre: true
  post: true
  activity: (     var value : int ; value := (rightRange - leftRange + 1) / 2 ;
     if ((rightRange - leftRange + 1) mod 2 = 0) then (     list := list.setAt(hotL+1,value) ; 
     list := list.setAt(hotR+1,value) ) else (     if ((hotR - leftRange) mod 2 = 0) then (     list := list.setAt(hotL+1,value) ; 
     list := list.setAt(hotR+1,value + 1) ) else (     list := list.setAt(hotL+1,value + 1) ; 
     list := list.setAt(hotR+1,value) ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    sc.close();
    int f=0,c=0 ;
    Queue<Integer>que=new ArrayDeque<>();
    for(int i=0 ; i<s.length(); i++){
      if(s.substring(i,i+1).equals("R")){
        if(f==1){
          f=0 ;
          que.add(c);
          c=0 ;
        }
        c++;
      }
      else {
        if(f==0){
          f=1 ;
          que.add(c);
          c=0 ;
        }
        c++;
        if(i==s.length()-1){
          que.add(c);
        }
      }
    }
    int ans[]=new int[s.length()];
    int pos=0 ;
    while(que.size()>0){
      int x=que.poll();
      int y=que.poll();
      if((x+y)% 2==0){
        pos+=x ;
        ans[pos-1]=(x+y)/2 ;
        ans[pos]=(x+y)/2 ;
        pos+=y ;
      }
      else if(x % 2==0){
        pos+=x ;
        ans[pos-1]=(x+y)/2 ;
        ans[pos]=(x+y)/2+1 ;
        pos+=y ;
      }
      else {
        pos+=x ;
        ans[pos-1]=(x+y)/2+1 ;
        ans[pos]=(x+y)/2 ;
        pos+=y ;
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<(s.length()*2-1); i++){
      if(i % 2==0){
        sb.append(ans[i/2]);
      }
      else {
        sb.append(" ");
      }
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    skip ; 
    var f : int ; f := 0 ;
    var c : int ; c := 0 ;
    var que : Sequence(int) ; que := ArrayDeque<OclAny>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s.subrange(i+1,i + 1) = "R") then (     if (f = 1) then (     f := 0 ; 
     que := que->including(c) ; 
     c := 0 ) else skip ; 
     c := c + 1 ) else (     if (f = 0) then (     f := 1 ; 
     que := que->including(c) ; 
     c := 0 ) else skip ; 
     c := c + 1 ; 
     if (i = s->size() - 1) then (     que := que->including(c) ) else skip ) )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,s->size())->collect(0) ;
    var pos : int ; pos := 0 ;
    while (que->size() > 0) do (     var x : int ; x := que->min() ;
     var y : int ; y := que->min() ;
     if ((x + y) mod 2 = 0) then (     pos := pos+(x) ; 
     ans[pos - 1+1] := (x + y) / 2 ; 
     ans[pos+1] := (x + y) / 2 ; 
     pos := pos+(y) ) else     if (x mod 2 = 0) then (     pos := pos+(x) ; 
     ans[pos - 1+1] := (x + y) / 2 ; 
     ans[pos+1] := (x + y) / 2 + 1 ; 
     pos := pos+(y) ) else (     pos := pos+(x) ; 
     ans[pos - 1+1] := (x + y) / 2 + 1 ; 
     ans[pos+1] := (x + y) / 2 ; 
     pos := pos+(y) ) ;  ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < (s->size() * 2 - 1) do ( (     if (i mod 2 = 0) then (     sb := sb + StringLib.newString(ans[i / 2+1]) ) else (     sb := sb + StringLib.newString(" ") ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    int length=S.length();
    int g1=0 ;
    int g2=0 ;
    int gcnt=0 ;
    char now='L' ;
    int rInd=0 ;
    int V[]=new int[length];
    for(int i=0 ; i<length ; i++){
      V[i]=0 ;
    }
    for(int i=0 ; i<length ; i++){
      char c=S.charAt(i);
      if(now!=c){
        if(c=='L'){
          rInd=i-1 ;
          if(gcnt % 2==0){
            V[i]=g1 ;
            V[i-1]=g2 ;
          }
          else {
            V[i]=g2 ;
            V[i-1]=g1 ;
          }
        }
        now=c ;
        g1=0 ;
        g2=0 ;
        gcnt=0 ;
      }
      gcnt++;
      if(c=='R'){
        if(gcnt % 2!=0){
          g1++;
        }
        else {
          g2++;
        }
      }
      else {
        if(gcnt % 2!=0){
          V[rInd+1]++;
        }
        else {
          V[rInd]++;
        }
      }
    }
    for(int i=0 ; i<length ; i++){
      System.out.print(V[i]+" ");
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    var length : int ; length := S->size() ;
    var g1 : int ; g1 := 0 ;
    var g2 : int ; g2 := 0 ;
    var gcnt : int ; gcnt := 0 ;
    var now : String ; now := 'L' ;
    var rInd : int ; rInd := 0 ;
    var V : Sequence(int) ; V := Integer.subrange(1,length)->collect(0) ;
        var i : int ; i := 0 ; while i < length do ( (     V[i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < length do ( (     var c : String ; c := S->at(i+1) ;
     if (now /= c) then (     if (c = 'L') then (     rInd := i - 1 ; 
     if (gcnt mod 2 = 0) then (     V[i+1] := g1 ; 
     V[i - 1+1] := g2 ) else (     V[i+1] := g2 ; 
     V[i - 1+1] := g1 ) ) else skip ; 
     now := c ; 
    g1 := 0 ; 
    g2 := 0 ; 
    gcnt := 0 ; 
 ) else skip ; 
     gcnt := gcnt + 1 ; 
     if (c = 'R') then (     if (gcnt mod 2 /= 0) then (     g1 := g1 + 1 ) else (     g2 := g2 + 1 ) ) else (     if (gcnt mod 2 /= 0) then (     V[rInd + 1+1] := V[rInd + 1+1] + 1 ) else (     V[rInd+1] := V[rInd+1] + 1 ) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < length do ( (     OclFile["System.out"].print(V[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    int[] res=new int[S.length()];
    char target='L' ;
    int pos=0 ;
    int counter=0 ;
    for(int i=0 ; i<S.length(); i++){
      if(target!=S.charAt(i)){
        counter++;
        continue ;
      }
      if(target=='L'){
        counter++;
        target='R' ;
        pos=i ;
        int tmp=counter/2 ;
        res[pos-1]+=tmp ;
        res[pos]+=counter-tmp ;
        counter=0 ;
      }
      else {
        target='L' ;
        int tmp=counter/2 ;
        res[pos]+=tmp ;
        res[pos-1]+=counter-tmp ;
        counter=1 ;
      }
    }
    int tmp=counter/2 ;
    res[pos]+=tmp ;
    res[pos-1]+=counter-tmp ;
    System.out.println(Arrays.stream(res).mapToObj(String :: valueOf).collect(Collectors.joining(" ")));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    var res : Sequence(int) ; res := Integer.subrange(1,S->size())->collect(0) ;
    var target : String ; target := 'L' ;
    var pos : int ; pos := 0 ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < S->size() do ( (     if (target /= S->at(i+1)) then (     counter := counter + 1 ; 
     continue ) else skip ; 
     if (target = 'L') then (     counter := counter + 1 ; 
     target := 'R' ; 
    pos := i ; 
    var tmp : int ; tmp := counter / 2 ;
    res[(pos)->char2byte() - 1+1] := res[(pos)->char2byte() - 1+1]+(tmp) ; 
    res[pos+1] := res[pos+1]+(counter - tmp) ; 
    counter := 0 ; 
 ) else (     target := 'L' ; 
     var tmp : int ; tmp := counter / 2 ;
    res[pos+1] := res[pos+1]+(tmp) ; 
    res[(pos)->char2byte() - 1+1] := res[(pos)->char2byte() - 1+1]+(counter - tmp) ; 
    counter := 1 ; 
 ) )  ;     i := i + 1 ) ; 
    var tmp : int ; tmp := counter / 2 ;
    res[pos+1] := res[pos+1]+(tmp) ; 
    res[(pos)->char2byte() - 1+1] := res[(pos)->char2byte() - 1+1]+(counter - tmp) ; 
    OclFile["System.out"].println(stream(res).mapToObj(lambda _pars : OclAny in String.newString().valueOf(_pars)).collect(Collectors.joining(" "))) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findpos(String n){
    int k=0,pos=0,i=0 ;
    while(k!=n.length()){
      switch(n.charAt(i)){
        case '4' : pos=pos*2+1 ;
        break ;
        case '7' : pos=pos*2+2 ;
        break ;
      }
      i++;
      k++;
    }
    return pos ;
  }
  public static void main(String[] args){
    String n="774" ;
    System.out.println(findpos(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findpos( n : String) : int
  pre: true
  post: true
  activity: (     var k : int ; k := 0 ;
    var pos : int ; pos := 0 ;
    var i : int ; i := 0 ;
     while (k /= n->size()) do ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (n->at(i+1)) ; 
       if _switchval = '4' then
     pos := pos * 2 + 1 ; 
    break 
   else skip ;
       if _switchval = '7' then
     pos := pos * 2 + 2 ; 
    break 
   else skip ;
 )
     i := i + 1 ; 
     k := k + 1 ) ; 
     return pos );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : String ; n := "774" ;
     OclFile["System.out"].println(findpos(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX_CHAR=26 ;
  static void sortString(String str){
    int charCount[]=new int[MAX_CHAR];
    for(int i=0 ; i<str.length(); i++){
      charCount[str.charAt(i)-'a']++;
    }
    for(int i=MAX_CHAR-1 ; i>=0 ; i--){
      for(int j=0 ; j<charCount[i]; j++){
        System.out.print((char)('a'+i));
      }
    }
  }
  public static void main(String[] args){
    String s="alkasingh" ;
    sortString(s);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX_CHAR : int := 26;
  static   operation sortString( str : String) : void
  pre: true
  post: true
  activity: (     var charCount : Sequence(int) ; charCount := Integer.subrange(1,MAX_CHAR)->collect(0) ;
         var i : int ; i := 0 ; while i < str->size() do ( (     charCount[str->at(i+1) - ('a')->char2byte()+1] := charCount[str->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
         var i : int ; i := MAX_CHAR - 1 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < charCount[i+1] do ( (     OclFile["System.out"].print(('a' + i)->oclAsType(String)) )  ;     j := j + 1 ) )  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "alkasingh" ;
     execute sortString(s) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Map<Integer,Integer>cost=new HashMap<Integer,Integer>();
    cost.put(0,0);
    PriorityQueue<int[]>pq=new PriorityQueue<int[]>(new Comparator<int[]>(){
      public int compare(int[] v1,int[] v2){
        return Integer.compare(v1[1],v2[1]);
      }
    }
);
    ArrayList<ArrayList<int[]>>adj=new ArrayList<ArrayList<int[]>>();
    for(int i=0 ; i<n ; ++i){
      adj.add(new ArrayList<int[]>());
      sc.nextInt();
      int n_nbrs=sc.nextInt();
      for(int j=0 ; j<n_nbrs ; ++j){
        int destination=sc.nextInt();
        int edge_cost=sc.nextInt();
        adj.get(i).add(new int[] {
          i,destination,edge_cost }
);
        }
      }
      for(int[] e : adj.get(0)){
        pq.add(new int[] {
          e[1],e[2] }
);
        }
        while(cost.size()<n){
          int[] v=pq.remove();
          if(! cost.containsKey(v[0])){
            cost.put(v[0],v[1]);
            for(int[] e : adj.get(v[0])){
              pq.add(new int[] {
                e[1],v[1]+e[2] }
);
              }
            }
          }
          for(int i=0 ; i<n ; ++i){
            System.out.printf("%d %d\n",i,cost.get(i));
          }
        }
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var cost : Map(int,int) ; cost := Map{} ;
    cost := cost->union(Map{0 |-> 0}) ; 
    var pq : Sequence(Sequence(int)) ; pq := Sequence{}->union(OclComparator<Sequence(int)>.newOclComparator()) ;
    var adj : Sequence(Sequence(Sequence(int))) ; adj := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     adj := adj->including(Sequence{}) ; 
     skip ; 
     var n_nbrs : int ; n_nbrs := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < n_nbrs do ( (     var destination : int ; destination := sc.getCurrent()->toInteger() ;
     var edge_cost : int ; edge_cost := sc.getCurrent()->toInteger() ;
     adj->at(i+1)->excludes(Sequence{i,destination,edge_cost}) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    for (e : adj->at(0+1)) do ( (     pq := pq->including(Sequence{e[1+1],e[2+1]}) )  ) ; 
    while (cost.size() < n) do (     var v : Sequence(int) ; v := pq.remove() ;
     if (not(cost->keys()->includes(v[0+1]))) then (     cost := cost->union(Map{v[0+1] |-> v[1+1]}) ; 
     for (e : adj->at(v[0+1]+1)) do ( (     pq := pq->including(Sequence{e[1+1],v[1+1] + e[2+1]}) )  ) ) else skip ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].printf("%d %d\n", i, cost->at(i)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static Scanner s=new Scanner(System.in);
  public static void main(String[] args){
    int n=s.nextInt();
    int u,k,v=0 ;
    int min ;
    int[] d=new int[n];
    int[][] T=new int[n][n];
    int[] times=new int[n];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        T[i][j]=-1 ;
      }
      d[i]=Integer.MAX_VALUE ;
    }
    for(int i=0 ; i<n ; i++){
      u=s.nextInt();
      k=s.nextInt();
      for(int j=0 ; j<k ; j++){
        v=s.nextInt();
        T[u][v]=s.nextInt();
      }
    }
    d[0]=0 ;
    times[0]=1 ;
    while(true){
      min=Integer.MAX_VALUE ;
      int hantei=-1 ;
      for(int i=0 ; i<n ; i++){
        if(min>d[i] && times[i]!=2){
          hantei=i ;
          min=d[i];
        }
      }
      if(hantei==-1)break ;
      times[hantei]=2 ;
      for(int i=0 ; i<n ; i++){
        if(times[i]!=2 && T[hantei][i]!=-1){
          if(d[i]>d[hantei]+T[hantei][i]){
            d[i]=d[hantei]+T[hantei][i];
            times[i]=1 ;
          }
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      if(d[i]==Integer.MAX_VALUE){
        System.out.println(i+" "+-1);
      }
      else {
        System.out.println(i+" "+d[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s.getCurrent()->toInteger() ;
     var u : int ;
    var k : int ;
    var v : int ; v := 0 ;
    var min : int ;
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
    var T : Sequence(Sequence(int)) ; T := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var times : Sequence(int) ; times := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     T[i+1][j+1] := -1 )  ;     j := j + 1 ) ; 
     d[i+1] := 2147483647 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     u := s.getCurrent()->toInteger() ; 
     k := s.getCurrent()->toInteger() ; 
         var j : int ; j := 0 ; while j < k do ( (     v := s.getCurrent()->toInteger() ; 
     T[u+1][v+1] := s.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    d[0+1] := 0 ; 
    times[0+1] := 1 ; 
    while (true) do (     min := 2147483647 ; 
     var hantei : int ; hantei := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (min > d[i+1] & times[i+1] /= 2) then (     hantei := i ; 
     min := d[i+1] ) else skip )  ;     i := i + 1 ) ; 
    if (hantei = -1) then     break else skip ; 
    times[hantei+1] := 2 ; 
        var i : int ; i := 0 ; while i < n do ( (     if (times[i+1] /= 2 & T[hantei+1][i+1] /= -1) then (     if (d[i+1] > d[hantei+1] + T[hantei+1][i+1]) then (     d[i+1] := d[hantei+1] + T[hantei+1][i+1] ; 
     times[i+1] := 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (d[i+1] = 2147483647) then (     OclFile["System.out"].println(i + " " + -1) ) else (     OclFile["System.out"].println(i + " " + d[i+1]) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  final static int LEN=105 ;
  public static void main(String args[]){
    int[][] graph=new int[LEN][LEN];
    int[] minCost=new int[LEN];
    int count=0 ;
    int v ;
    boolean[] used=new boolean[LEN];
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int nodeNumber ;
    int k ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        graph[i][j]=2000000 ;
      }
    }
    for(int i=0 ; i<n ; i++){
      nodeNumber=in.nextInt();
      k=in.nextInt();
      for(int j=0 ; j<k ; j++){
        graph[nodeNumber][in.nextInt()]=in.nextInt();
      }
    }
    for(int i=0 ; i<n ; i++){
      minCost[i]=999999 ;
      used[i]=false ;
    }
    minCost[0]=0 ;
    while(true){
      v=-1 ;
      for(int i=0 ; i<n ; i++){
        if(! used[i] &&(v==-1 || minCost[i]<minCost[v]))v=i ;
      }
      if(v==-1)break ;
      used[v]=true ;
      count+=minCost[v];
      for(int i=0 ; i<n ; i++){
        minCost[i]=Math.min(minCost[i],graph[v][i]+minCost[v]);
      }
    }
    for(int i=0 ; i<n ; i++)System.out.println(i+" "+minCost[i]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute LEN : int := 105;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var graph : Sequence(Sequence(int)) ; graph := Integer.subrange(1,LEN)->collect(Integer.subrange(1,LEN)->collect(0)) ;
     var minCost : Sequence(int) ; minCost := Integer.subrange(1,LEN)->collect(0) ;
    var count : int ; count := 0 ;
    var v : int ;
    var used : Sequence(boolean) ; used := Integer.subrange(1,LEN)->collect(false) ;
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var nodeNumber : int ;
    var k : int ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     graph[i+1][j+1] := 2000000 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     nodeNumber := in.getCurrent()->toInteger() ; 
     k := in.getCurrent()->toInteger() ; 
         var j : int ; j := 0 ; while j < k do ( (     graph[nodeNumber+1][in.getCurrent()->toInteger()+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     minCost[i+1] := 999999 ; 
     used[i+1] := false )  ;     i := i + 1 ) ; 
    minCost[0+1] := 0 ; 
    while (true) do (     v := -1 ; 
         var i : int ; i := 0 ; while i < n do ( (     if (not(used[i+1]) & (v = -1 or minCost[i+1] < minCost[v+1])) then     v := i ; else skip )  ;     i := i + 1 ) ; 
    if (v = -1) then     break else skip ; 
    used[v+1] := true ; 
    count := count+(minCost[v+1]) ; 
        var i : int ; i := 0 ; while i < n do ( (     minCost[i+1] := Set{minCost[i+1], graph[v+1][i+1] + minCost[v+1]}->min() )  ;     i := i + 1 ) ; 
 ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].println(i + " " + minCost[i+1]) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int input1=scan.nextInt();
    int[][] map=new int[input1][input1];
    for(int[] _arr : map)Arrays.fill(_arr,-1);
    for(int i=0 ; i<input1 ; i++){
      int point=scan.nextInt();
      int input2=scan.nextInt();
      for(int j=0 ; j<input2 ; j++){
        int aite=scan.nextInt();
        int omomi=scan.nextInt();
        map[point][aite]=omomi ;
      }
    }
    boolean[] moved=new boolean[input1];
    int[] maxInterval=new int[input1];
    Arrays.fill(maxInterval,1<<30);
    maxInterval[0]=0 ;
    moved[0]=true ;
    check(0,moved,maxInterval,map);
    for(int i=0 ; i<maxInterval.length ; i++){
      System.out.println(i+" "+maxInterval[i]);
    }
  }
  static void check(int nowPos,boolean[] moved,int[] maxInterval,int[][] map){
    for(int i=0 ; i<map[nowPos] .length ; i++){
      if(map[nowPos][i]>=0){
        if(maxInterval[i]>maxInterval[nowPos]+map[nowPos][i]){
          maxInterval[i]=maxInterval[nowPos]+map[nowPos][i];
        }
      }
    }
    int nextIndex=-1 ;
    int min=1<<30 ;
    for(int i=0 ; i<moved.length ; i++){
      if(! moved[i]){
        if(maxInterval[i]<=min){
          nextIndex=i ;
          min=maxInterval[i];
        }
      }
    }
    if(nextIndex>0){
      moved[nextIndex]=true ;
      check(nextIndex,moved,maxInterval,map);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input1 : int ; input1 := scan.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,input1)->collect(Integer.subrange(1,input1)->collect(0)) ;
    for (_arr : map) do (     _arr := _arr->collect(-1) ;  ) ; 
        var i : int ; i := 0 ; while i < input1 do ( (     var point : int ; point := scan.getCurrent()->toInteger() ;
     var input2 : int ; input2 := scan.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < input2 do ( (     var aite : int ; aite := scan.getCurrent()->toInteger() ;
     var omomi : int ; omomi := scan.getCurrent()->toInteger() ;
     map[point+1][aite+1] := omomi )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var moved : Sequence(boolean) ; moved := Integer.subrange(1,input1)->collect(false) ;
    var maxInterval : Sequence(int) ; maxInterval := Integer.subrange(1,input1)->collect(0) ;
    maxInterval := maxInterval->collect((1*(2->pow(30)))->oclAsType(long)) ; 
    maxInterval[0+1] := 0 ; 
    moved[0+1] := true ; 
    execute check(0, moved, maxInterval, map) ; 
        var i : int ; i := 0 ; while i < maxInterval->size() do ( (     OclFile["System.out"].println(i + " " + maxInterval[i+1]) )  ;     i := i + 1 ) ; 
 );
  static   operation check( nowPos : int, moved : Sequence(boolean), maxInterval : Sequence(int), map : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < map[nowPos+1]->size() do ( (     if (map[nowPos+1][i+1] >= 0) then (     if (maxInterval[i+1] > maxInterval[nowPos+1] + map[nowPos+1][i+1]) then (     maxInterval[i+1] := maxInterval[nowPos+1] + map[nowPos+1][i+1] ) else skip ) else skip )  ;     i := i + 1 ) ; 
     var nextIndex : int ; nextIndex := -1 ;
    var min : int ; min := (1*(2->pow(30)))->oclAsType(long) ;
        var i : int ; i := 0 ; while i < moved->size() do ( (     if (not(moved[i+1])) then (     if (maxInterval[i+1] <= min) then (     nextIndex := i ; 
     min := maxInterval[i+1] ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (nextIndex > 0) then (     moved[nextIndex+1] := true ; 
     execute check(nextIndex, moved, maxInterval, map) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxPrimes(int n){
    return n/2 ;
  }
  public static void main(String[] args){
    int n=17 ;
    System.out.println(maxPrimes(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxPrimes( n : int) : int
  pre: true
  post: true
  activity: (     return n / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 17 ;
     OclFile["System.out"].println(maxPrimes(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      if(n==1){
        System.out.println(sc.next());
        continue ;
      }
      Map<String,Integer>hash=new HashMap<String,Integer>();
      String ans="NO COLOR" ;
      for(int i=0 ; i<n ; i++){
        String k=sc.next();
        if(hash.containsKey(k)){
          hash.put(k,hash.get(k)+1);
          if(hash.get(k)>n/2){
            ans=k ;
            for(int j=i+1 ; j<n ; j++){
              sc.next();
            }
            break ;
          }
        }
        else hash.put(k,1);
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    if (n = 1) then (     OclFile["System.out"].println(sc.getCurrent()) ; 
     continue ) else skip ; 
    var hash : Map(String,int) ; hash := Map{} ;
    var ans : String ; ans := "NO COLOR" ;
        var i : int ; i := 0 ; while i < n do ( (     var k : String ; k := sc.getCurrent() ;
     if (hash->keys()->includes(k)) then (     hash := hash->union(Map{k |-> hash->at(k) + 1}) ; 
     if (hash->at(k) > n / 2) then (     ans := k ; 
         var j : int ; j := i + 1 ; while j < n do ( (     skip )  ;     j := j + 1 ) ; 
     break ) else skip ) else     hash := hash->union(Map{k |-> 1}) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int nthOdd(int n){
    return(2*n-1);
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(nthOdd(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nthOdd( n : int) : int
  pre: true
  post: true
  activity: (     return (2 * n - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(nthOdd(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countNumbers(int n){
    return(n/2520);
  }
  public static void main(String args[]){
    int n=3000 ;
    System.out.println(countNumbers(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countNumbers( n : int) : int
  pre: true
  post: true
  activity: (     return (n / 2520) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3000 ;
     OclFile["System.out"].println(countNumbers(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int cntSquares(int n){
    return n*(n+1)*(2*n+1)/6 ;
  }
  public static void main(String args[]){
    System.out.println(cntSquares(4));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation cntSquares( n : int) : int
  pre: true
  post: true
  activity: (     return n * (n + 1) * (2 * n + 1) / 6 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(cntSquares(4)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float Conversion(float n){
    return(n-32.0f)*5.0f/9.0f ;
  }
  public static void main(String[] args){
    float n=40 ;
    System.out.println(Conversion(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Conversion( n : double) : double
  pre: true
  post: true
  activity: (     return (n - 32.0f) * 5.0f / 9.0f );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 40 ;
     OclFile["System.out"].println(Conversion(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float Cel_To_Fah(float n){
    return((n*9.0f/5.0f)+32.0f);
  }
  public static void main(String[] args){
    float n=20.0f ;
    System.out.println(Cel_To_Fah(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Cel_To_Fah( n : double) : double
  pre: true
  post: true
  activity: (     return ((n * 9.0f / 5.0f) + 32.0f) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 20.0f ;
     OclFile["System.out"].println(Cel_To_Fah(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  static int evenSum(int n){
    return(n*(n+1));
  }
  public static void main(String argc[]){
    int n=20 ;
    System.out.println("Sum of first "+n+" Even numbers is: "+evenSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation evenSum( n : int) : int
  pre: true
  post: true
  activity: (     return (n * (n + 1)) );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 20 ;
     OclFile["System.out"].println("Sum of first " + n + " Even numbers is: " + evenSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int nthEven(int n){
    return(2*n);
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(nthEven(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nthEven( n : int) : int
  pre: true
  post: true
  activity: (     return (2 * n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(nthEven(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int ways(int n){
    return n/2 ;
  }
  public static void main(String args[]){
    int n=2 ;
    System.out.println(ways(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation ways( n : int) : int
  pre: true
  post: true
  activity: (     return n / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(ways(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countReduce(String str){
    int n=str.length();
    int res=0 ;
    for(int i=0 ; i<n/2 ; i++)res+=Math.abs(str.charAt(i)-str.charAt(n-i-1));
    return res ;
  }
  public static void main(String[] args){
    String str="abcd" ;
    System.out.println(countReduce(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countReduce( str : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < n / 2 do (     res := res+(if str->at(i+1) - str->at(n - i - 1+1) < 0 then -(str->at(i+1) - str->at(n - i - 1+1)) else str->at(i+1) - str->at(n - i - 1+1) endif) ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abcd" ;
     OclFile["System.out"].println(countReduce(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MatrixGame {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int t=scn.nextInt();
    while(t-->0){
      int n=scn.nextInt();
      int m=scn.nextInt();
      Set<Integer>setrow=new HashSet<>();
      Set<Integer>setcol=new HashSet<>();
      int[][] arr=new int[n][m];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<m ; j++){
          arr[i][j]=scn.nextInt();
          if(arr[i][j]==1){
            setrow.add(i+1);
            setcol.add(j+1);
          }
        }
      }
      int x=n-setrow.size();
      int y=m-setcol.size();
      int min=Math.min(x,y);
      if(min % 2==0){
        System.out.println("Vivek");
      }
      else {
        System.out.println("Ashish");
      }
    }
    scn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class MatrixGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scn.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scn.getCurrent()->toInteger() ;
     var m : int ; m := scn.getCurrent()->toInteger() ;
    var setrow : Set(int) ; setrow := Set{} ;
    var setcol : Set(int) ; setcol := Set{} ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     arr[i+1][j+1] := scn.getCurrent()->toInteger() ; 
     if (arr[i+1][j+1] = 1) then (     setrow := setrow->including(i + 1) ; 
     setcol := setcol->including(j + 1) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var x : int ; x := n - setrow->size() ;
    var y : int ; y := m - setcol->size() ;
    var min : int ; min := Set{x, y}->min() ;
    if (min mod 2 = 0) then (     OclFile["System.out"].println("Vivek") ) else (     OclFile["System.out"].println("Ashish") ) ;  
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.regex.Pattern ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String color="" ;
      int n=ip(br);
      if(n==0){
        break ;
      }
      Map<String,Integer>colorMap=new HashMap<>();
      String[] list=br.readLine().split(" ");
      if(n==1){
        color=list[0];
        System.out.println(color);
        continue ;
      }
      for(String i : list){
        if(colorMap.containsKey(i)){
          int count=colorMap.get(i)+1 ;
          if(count>n/2){
            color=i ;
            break ;
          }
          colorMap.put(i,count);
        }
        else {
          colorMap.put(i,1);
        }
      }
      System.out.println(color.equals("")? "NO COLOR" : color);
    }
  }
  static boolean isNumber(String num){
    return Pattern.compile("^\\-?[0-9]*\\.?[0-9]+$").matcher(num).find();
  }
  static int[] createListInt(BufferedReader br)throws IOException {
    String[] lines=br.readLine().split(" ");
    int n=lines.length ;
    int[] list=new int[n];
    while(n-->0){
      list[n]=Integer.parseInt(lines[n]);
    }
    return list ;
  }
  static int ip(BufferedReader s)throws IOException {
    return Integer.parseInt(s.readLine());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var color : String ; color := "" ;
     var n : int ; n := ip(br) ;
    if (n = 0) then (     break ) else skip ; 
    var colorMap : Map(String,int) ; colorMap := Map{} ;
    var list : Sequence(String) ; list := br.readLine()->split(" ") ;
    if (n = 1) then (     color := list[0+1] ; 
     OclFile["System.out"].println(color) ; 
     continue ) else skip ; 
    for (i : list) do ( (     if (colorMap->keys()->includes(i)) then (     var count : int ; count := colorMap->at(i) + 1 ;
     if (count > n / 2) then (     color := i ; 
     break ) else skip ; 
     colorMap := colorMap->union(Map{i |-> count}) ) else (     colorMap := colorMap->union(Map{i |-> 1}) ) )  ) ; 
    OclFile["System.out"].println(if color = "" then "NO COLOR" else color endif) ; 
 ) );
  static   operation isNumber( num : String) : boolean
  pre: true
  post: true
  activity: (     return OclRegex.compile("^\\-?[0-9]*\\.?[0-9]+$").matcher(num).nextMatch() );
  static   operation createListInt( br : OclFile) : Sequence(int)
  pre: true
  post: true
  activity: (     var lines : Sequence(String) ; lines := br.readLine()->split(" ") ;
     var n : int ; n := lines->size() ;
    var list : Sequence(int) ; list := Integer.subrange(1,n)->collect(0) ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     list[n+1] := (lines[n+1])->toInteger() ) ;  ) ;  
    return list 
 );
  static   operation ip( s : OclFile) : int
  pre: true
  post: true
  activity: (     return (s.readLine())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int t=0 ; t<test ; t++){
      int n=in.nextInt(),m=in.nextInt();
      int a[][]=new int[n][m];
      boolean row[]=new boolean[n],col[]=new boolean[m];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<m ; j++){
          int x=in.nextInt();
          if(x==1){
            row[i]=true ;
            col[j]=true ;
          }
        }
      }
      int r=0,c=0 ;
      for(int i=0 ; i<n ; i++){
        if(! row[i]){
          r++;
        }
      }
      for(int i=0 ; i<m ; i++){
        if(! col[i]){
          c++;
        }
      }
      int min=Math.min(r,c);
      if(min % 2==1){
        pw.println("Ashish");
      }
      else {
        pw.println("Vivek");
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < test do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
     var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var row : Sequence(boolean) ; row := Integer.subrange(1,n)->collect(false) ;
    var col : Sequence(void) ; col := Integer.subrange(1,m)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     if (x = 1) then (     row[i+1] := true ; 
     col[j+1] := true ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var r : int ; r := 0 ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (not(row[i+1])) then (     r := r + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     if (not(col[i+1])) then (     c := c + 1 ) else skip )  ;     i := i + 1 ) ; 
    var min : int ; min := Set{r, c}->min() ;
    if (min mod 2 = 1) then (     skip ) else (     skip ) ;  
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class submitfinal {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t!=0){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int a[][]=new int[n][m];
      TreeSet<Integer>x=new TreeSet<>();
      TreeSet<Integer>y=new TreeSet<>();
      for(int i=0 ; i<n ; ++i){
        for(int j=0 ; j<m ; ++j){
          a[i][j]=sc.nextInt();
          if(a[i][j]==1){
            x.add(i);
            y.add(j);
          }
        }
      }
      int h=Math.min(n-x.size(),m-y.size());
      if(h % 2==0)System.out.println("Vivek");
      else {
        System.out.println("Ashish");
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class submitfinal {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t /= 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var x : Set(int) ; x := Set{} ;
    var y : Set(int) ; y := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     a[i+1][j+1] := sc.getCurrent()->toInteger() ; 
     if (a[i+1][j+1] = 1) then (     x := x->including(i) ; 
     y := y->including(j) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var h : int ; h := Set{n - x->size(), m - y->size()}->min() ;
    if (h mod 2 = 0) then     OclFile["System.out"].println("Vivek") else (     OclFile["System.out"].println("Ashish") ) ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MatrixGame {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q=Integer.parseInt(sc.nextLine());
    while(q-->0){
      String s=sc.nextLine();
      String[] cs=s.split(" ");
      int n=Integer.parseInt(cs[0]),m=Integer.parseInt(cs[1]);
      int[][] arr=new int[n][m];
      int gN=0,bN=0 ;
      int[] r=new int[n],c=new int[m];
      for(int i=0 ; i<n ; i++){
        String line=sc.nextLine();
        String[] ll=line.split(" ");
        for(int j=0 ; j<m ; j++){
          arr[i][j]=Integer.parseInt(ll[j]);
          if(arr[i][j]==1){
            r[i]=1 ;
            c[j]=1 ;
          }
        }
      }
      solve(arr,r,c,n,m);
    }
  }
  private static void solve(int[][] arr,int[] r,int[] c,int n,int m){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(r[i]==0 && c[j]==0){
          count++;
          r[i]=1 ;
          c[j]=1 ;
        }
      }
    }
    System.out.println(count % 2==0 ? "Vivek" : "Ashish");
  }
}
------------------------------------------------------------
OCL File:
---------
 class MatrixGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := (sc.nextLine())->toInteger() ;
         while (q > 0) do (        q := q - 1 ;     skip ; (     var s : String ; s := sc.nextLine() ;
     var cs : Sequence(String) ; cs := s->split(" ") ;
    var n : int ; n := (cs[0+1])->toInteger() ;
    var m : int ; m := (cs[1+1])->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var gN : int ; gN := 0 ;
    var bN : int ; bN := 0 ;
    var r : Sequence(int) ; r := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var line : String ; line := sc.nextLine() ;
     var ll : Sequence(String) ; ll := line->split(" ") ;
         var j : int ; j := 0 ; while j < m do ( (     arr[i+1][j+1] := (ll[j+1])->toInteger() ; 
     if (arr[i+1][j+1] = 1) then (     r[i+1] := 1 ; 
     c[j+1] := 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    execute solve(arr, r, c, n, m) ; 
 ) ;  ) );
  static   operation solve( arr : Sequence(Sequence(int)), r : Sequence(int), c : Sequence(int), n : int, m : int) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (r[i+1] = 0 & c[j+1] = 0) then (     count := count + 1 ; 
     r[i+1] := 1 ; 
     c[j+1] := 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if count mod 2 = 0 then "Vivek" else "Ashish" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static boolean check(char s[]){
    int l=s.length ;
    Arrays.sort(s);
    for(int i=1 ; i<l ; i++){
      if(s[i]-s[i-1]!=1)return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    String str="dcef" ;
    if(check(str.toCharArray())==true)System.out.println("Yes");
    else System.out.println("No");
    String str1="xyza" ;
    if(check(str1.toCharArray())==true)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation check( s : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     var l : int ; l := s->size() ;
     s := s->sort() ; 
         var i : int ; i := 1 ; while i < l do ( (     if (s[i+1] - s[i - 1+1] /= 1) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "dcef" ;
     if (check(str->characters()) = true) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
     var str1 : String ; str1 := "xyza" ;
     if (check(str1->characters()) = true) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findNthEvenDigitNumber(int n){
    int count=0 ;
    for(int i=0 ; ; i++){
      int curr=i ;
      boolean isCurrEvenDigit=true ;
      while(curr!=0){
        if(curr % 10==1 || curr % 10==3 || curr % 10==5 || curr % 10==7 || curr % 10==9)isCurrEvenDigit=false ;
        curr=curr/10 ;
      }
      if(isCurrEvenDigit==true)count++;
      if(count==n)return i ;
    }
  }
  public static void main(String[] args){
    System.out.println(findNthEvenDigitNumber(2));
    System.out.println(findNthEvenDigitNumber(10));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNthEvenDigitNumber( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while true do ( (     var curr : int ; curr := i ;
     var isCurrEvenDigit : boolean ; isCurrEvenDigit := true ;
    while (curr /= 0) do (     if (curr mod 10 = 1 or curr mod 10 = 3 or curr mod 10 = 5 or curr mod 10 = 7 or curr mod 10 = 9) then     isCurrEvenDigit := false ; else skip ; 
     curr := curr / 10 ) ; 
    if (isCurrEvenDigit = true) then     count := count + 1 ; else skip ; 
    if (count = n) then     return i else skip ; 
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(findNthEvenDigitNumber(2)) ; 
     OclFile["System.out"].println(findNthEvenDigitNumber(10)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long n=sc.nextLong();
      while(true){
        long n1=n ;
        while(n1>0){
          long r=n1 % 10 ;
          if(r!=0 && n % r!=0)break ;
          n1=n1/10 ;
        }
        if(n1==0){
          System.out.println(n);
          break ;
        }
        n++;
      }
    }
  }
  static boolean isPrime(long n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static long gcd(long a,long b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static long lcm(long a,long b){
    return(a/gcd(a,b))*b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := sc.getCurrent()->toLong() ;
     while (true) do (     var n1 : long ; n1 := n ;
     while (n1 > 0) do (     var r : long ; r := n1 mod 10 ;
     if (r /= 0 & n mod r /= 0) then     break else skip ; 
     n1 := n1 / 10 ) ; 
     if (n1 = 0) then (     OclFile["System.out"].println(n) ; 
     break ) else skip ; 
     n := n + 1 ) ) ;  ) );
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a / gcd(a, b)) * b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  static int evenSum(int n){
    int curr=2,sum=0 ;
    for(int i=1 ; i<=n ; i++){
      sum+=curr ;
      curr+=2 ;
    }
    return sum ;
  }
  public static void main(String argc[]){
    int n=20 ;
    System.out.println("Sum of first "+n+" Even numbers is: "+evenSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation evenSum( n : int) : int
  pre: true
  post: true
  activity: (     var curr : int ; curr := 2 ;
    var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     sum := sum+(curr) ; 
     curr := curr+(2) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 20 ;
     OclFile["System.out"].println("Sum of first " + n + " Even numbers is: " + evenSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=s.nextInt();
      }
      solve(n,arr);
    }
  }
  public static void solve(int n,int[] arr){
    boolean zero=false ;
    for(int i : arr){
      if(i==0){
        zero=true ;
        break ;
      }
    }
    if(! zero){
      System.out.println(0);
    }
    else {
      int l=0 ;
      while(l<n-1 && arr[l+1]!=0){
        l++;
      }
      int r=n-1 ;
      while(r>=1 && arr[r-1]!=0){
        r--;
      }
      System.out.println(r-l);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 ;class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     execute solve(n, arr) ) ;  ) );
  static   operation solve( n : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var zero : boolean ; zero := false ;
     for (i : arr) do ( (     if (i = 0) then (     zero := true ; 
     break ) else skip )  ) ; 
     if (not(zero)) then (     OclFile["System.out"].println(0) ) else (     var l : int ; l := 0 ;
     while (l < n - 1 & arr[l + 1+1] /= 0) do (     l := l + 1 ) ; 
    var r : int ; r := n - 1 ;
    while (r >= 1 & arr[r - 1+1] /= 0) do (     r := r - 1 ) ; 
    OclFile["System.out"].println(r - l) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class AACFCC {
  public static long mod=(long)Math.pow(10,9)+7 ;
  public static long mod2=998244353 ;
  public static int oo=0 ;
  public static ArrayList<Integer>prime ;
  public static int zz=-1 ;
  public static int ttt=0 ;
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    ArrayList<Integer>list=new ArrayList<>();
    int t=Integer.parseInt(br.readLine());
    while(t-->0){
      String[] str=br.readLine().split(" ");
      int n=(int)Long.parseLong(str[0]);
      int[] arr=new int[n];
      String[] s1=br.readLine().split(" ");
      int f=-1,l=-1 ;
      for(int i=0 ; i<n ; i++){
        if(Integer.valueOf(s1[i])==0){
          if(f==-1){
            f=i ;
            l=i ;
          }
          else {
            l=i ;
          }
        }
      }
      if(f==-1){
        pw.println(0);
      }
      else {
        pw.println(l-f+2);
      }
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class AACFCC {
  static   attribute mod : long := 10->pow(9)->oclAsType(long) + 7;
  static   attribute mod2 : long := 998244353;
  static   attribute oo : int := 0;
  static   attribute prime : Sequence(int);
  static   attribute zz : int := -1;
  static   attribute ttt : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var list : Sequence(int) ; list := Sequence{} ;
    var t : int ; t := (br.readLine())->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     var n : int ; n := (str[0+1])->toLong()->oclAsType(int) ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var s1 : Sequence(String) ; s1 := br.readLine()->split(" ") ;
    var f : int ; f := -1 ;
    var l : int ; l := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if ((s1[i+1])->toInteger() = 0) then (     if (f = -1) then (     f := i ; 
     l := i ) else (     l := i ) ) else skip )  ;     i := i + 1 ) ; 
    if (f = -1) then (     skip ) else (     skip ) ;  
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeHundredSixtyTwo {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=input.nextInt();
      int[] arrayOne=new int[n];
      for(int i=0 ; i<n ; i++){
        arrayOne[i]=input.nextInt();
      }
      int tim1=0 ;
      int tim2=0 ;
      for(int i=1 ; i<n ; i++){
        if(arrayOne[i]==0){
          tim1=i-1 ;
          break ;
        }
        else {
          continue ;
        }
      }
      for(int i=n-1 ; i>0 ; i--){
        if(arrayOne[i]==0){
          tim2=i+1 ;
          break ;
        }
      }
      System.out.println(tim2-tim1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixtyTwo {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var arrayOne : Sequence(int) ; arrayOne := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arrayOne[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var tim1 : int ; tim1 := 0 ;
    var tim2 : int ; tim2 := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (arrayOne[i+1] = 0) then (     tim1 := i - 1 ; 
     break ) else (     continue ) )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i > 0 do ( (     if (arrayOne[i+1] = 0) then (     tim2 := i + 1 ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(tim2 - tim1) ; 
 )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  private static void solve(){
    final Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      if(n==0){
        break ;
      }
      int[] colors=new int[n];
      for(int i=0 ; i<colors.length ; i++){
        colors[i]=scanner.nextInt();
      }
      Arrays.sort(colors);
      int maximum=0 ;
      int maximumColor=-1 ;
      int index=0 ;
      while(index<colors.length){
        int color=colors[index];
        int counter=1 ;
        while(++index<colors.length && colors[index]==color){
          counter++;
        }
        if(counter>maximum){
          maximum=counter ;
          maximumColor=color ;
        }
      }
      if(maximum>colors.length/2){
        System.out.println(maximumColor);
      }
      else {
        System.out.println("NO COLOR");
      }
    }
  }
  public static void main(String...args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var colors : Sequence(int) ; colors := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < colors->size() do ( (     colors[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    colors := colors->sort() ; 
    var maximum : int ; maximum := 0 ;
    var maximumColor : int ; maximumColor := -1 ;
    var index : int ; index := 0 ;
    while (index < colors->size()) do (     var color : int ; color := colors[index+1] ;
     var counter : int ; counter := 1 ;
         index := index + 1 ;
    while ((index + 1) < colors->size() & colors[index+1] = color) do (    skip ; (     counter := counter + 1 ) ;     index := index + 1 ;
 ) ;  
     if (counter > maximum) then (     maximum := counter ; 
     maximumColor := color ) else skip ) ; 
    if (maximum > colors->size() / 2) then (     OclFile["System.out"].println(maximumColor) ) else (     OclFile["System.out"].println("NO COLOR") ) ;  
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static void printSubSets(int numOfBits,int num){
    if(num>=0){
      System.out.print("{ ");
      subset(numOfBits-1,num,numOfBits);
      System.out.println("}");
      printSubSets(numOfBits,num-1);
    }
    else return ;
  }
  static void subset(int nthBit,int num,int numOfBits){
    if(nthBit>=0){
      if((num &(1<<nthBit))!=0){
        System.out.print(numOfBits-nthBit+" ");
      }
      subset(nthBit-1,num,numOfBits);
    }
    else return ;
  }
  public static void main(String[] args){
    int n=4 ;
    printSubSets(n,(int)(Math.pow(2,n))-1);
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation printSubSets( numOfBits : int, num : int) : void
  pre: true
  post: true
  activity: (     if (num >= 0) then (     OclFile["System.out"].print("{ ") ; 
     execute subset(numOfBits - 1, num, numOfBits) ; 
     OclFile["System.out"].println("}") ; 
     execute printSubSets(numOfBits, num - 1) ) else     return );
  static   operation subset( nthBit : int, num : int, numOfBits : int) : void
  pre: true
  post: true
  activity: (     if (nthBit >= 0) then (     if ((num & ((1*(2->pow(nthBit)))->oclAsType(long))) /= 0) then (     OclFile["System.out"].print(numOfBits - nthBit + " ") ) else skip ; 
     execute subset(nthBit - 1, num, numOfBits) ) else     return );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     execute printSubSets(n, (2->pow(n))->oclAsType(int) - 1) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void reverseColumns(int arr[][]){
    for(int i=0 ; i<arr[0] .length ; i++)for(int j=0,k=arr[0] .length-1 ; j<k ; j++,k--){
      int temp=arr[j][i];
      arr[j][i]=arr[k][i];
      arr[k][i]=temp ;
    }
  }
  static void transpose(int arr[][]){
    for(int i=0 ; i<arr.length ; i++)for(int j=i ; j<arr[0] .length ; j++){
      int temp=arr[j][i];
      arr[j][i]=arr[i][j];
      arr[i][j]=temp ;
    }
  }
  static void printMatrix(int arr[][]){
    for(int i=0 ; i<arr.length ; i++){
      for(int j=0 ; j<arr[0] .length ; j++)System.out.print(arr[i][j]+" ");
      System.out.println("");
    }
  }
  static void rotate90(int arr[][]){
    transpose(arr);
    reverseColumns(arr);
  }
  public static void main(String[] args){
    int arr[][]={
      {
        1,2,3,4 },{
          5,6,7,8 },{
            9,10,11,12 },{
              13,14,15,16 }
            };
            rotate90(arr);
            printMatrix(arr);
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation reverseColumns( arr : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < arr[0+1]->size() do (         var j : int ; j := 0 ;
    var k : int ; k := arr[0+1]->size() - 1 ; while j < k do ( (     var temp : int ; temp := arr[j+1][i+1] ;
     arr[j+1][i+1] := arr[k+1][i+1] ; 
     arr[k+1][i+1] := temp )  ;     j := j + 1 ;     k := k - 1 ) ;  ;     i := i + 1 ) );
  static   operation transpose( arr : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < arr->size() do (         var j : int ; j := i ; while j < arr[0+1]->size() do ( (     var temp : int ; temp := arr[j+1][i+1] ;
     arr[j+1][i+1] := arr[i+1][j+1] ; 
     arr[i+1][j+1] := temp )  ;     j := j + 1 ) ;  ;     i := i + 1 ) );
  static   operation printMatrix( arr : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < arr->size() do ( (         var j : int ; j := 0 ; while j < arr[0+1]->size() do (     OclFile["System.out"].print(arr[i+1][j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("") )  ;     i := i + 1 ) );
  static   operation rotate90( arr : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     execute transpose(arr) ; 
     execute reverseColumns(arr) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,2,3,4},Sequence{5,6,7,8},Sequence{9,10,11,12},Sequence{13,14,15,16}} ;
     execute rotate90(arr) ; 
     execute printMatrix(arr) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    String str=input.readLine();
    String[] strlist=str.split(" ");
    int a=Integer.parseInt(strlist[0]);
    int b=Integer.parseInt(strlist[1]);
    int c=Integer.parseInt(strlist[2]);
    String answer="NO" ;
    for(int i=0 ; i<b ; i++){
      if((i*b+c)% a==0){
        answer="YES" ;
        break ;
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := input.readLine() ;
    var strlist : Sequence(String) ; strlist := str->split(" ") ;
    var a : int ; a := (strlist[0+1])->toInteger() ;
    var b : int ; b := (strlist[1+1])->toInteger() ;
    var c : int ; c := (strlist[2+1])->toInteger() ;
    var answer : String ; answer := "NO" ;
        var i : int ; i := 0 ; while i < b do ( (     if ((i * b + c) mod a = 0) then (     answer := "YES" ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    LightScanner in=new LightScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BChooseIntegers solver=new BChooseIntegers();
    solver.solve(1,in,out);
    out.close();
  }
  static class BChooseIntegers {
    private static final String YES="YES" ;
    private static final String NO="NO" ;
    public void solve(int testNumber,LightScanner in,PrintWriter out){
      int a=in.ints(),b=in.ints(),c=in.ints();
      int gcd=gcd(a,b);
      out.println(c % gcd==0 ? YES : NO);
    }
    private static int gcd(int a,int b){
      int t ;
      while(a % b>0){
        t=b ;
        b=a % b ;
        a=t ;
      }
      return b ;
    }
  }
  static class LightScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public LightScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String string(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int ints(){
      return Integer.parseInt(string());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : LightScanner ; in := LightScanner.newLightScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BChooseIntegers ; solver := BChooseIntegers.newBChooseIntegers() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BChooseIntegers {
  static    attribute YES : String := "YES";
  static    attribute NO : String := "NO";
   operation solve( testNumber : int, in : LightScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.ints() ;
    var b : int ; b := in.ints() ;
    var c : int ; c := in.ints() ;
     var gcd : int ; gcd := gcd(a, b) ;
     skip );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var t : int ;
     while (a mod b > 0) do (     t := b ; 
     b := a mod b ; 
     a := t ) ; 
     return b );
}
  static class LightScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newLightScanner( in : OclFile) : LightScanner
  pre: true
  post: true
  activity:
  ( var self : LightScanner ;
    self := createLightScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation string() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation ints() : int
  pre: true
  post: true
  activity: (     return (string())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Comparator ;
import java.util.Scanner ;
class Main {
  static int[][] map ;
  static long INF=Long.MAX_VALUE/2 ;
  static int n,m ;
  static long[] dis ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    for(int i=0 ; i<10000 ; i++){
      int x=a*i ;
      if(x % b==c){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
}
class MyComparator implements Comparator {
  public int compare(Object obj1,Object obj2){
    int num1=(int)obj1 ;
    int num2=(int)obj2 ;
    if(num1<num2){
      return 1 ;
    }
    else if(num1>num2){
      return-1 ;
    }
    else {
      return 0 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute map : Sequence(Sequence(int));
  static   attribute INF : long := "9223372036854775807"->toLong() / 2;
  static   attribute n : int;
  static   attribute dis : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < 10000 do ( (     var x : int ; x := a * i ;
     if (x mod b = c) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}
class MyComparator implements Comparator {
   operation compare( obj1 : OclAny, obj2 : OclAny) : int
  pre: true
  post: true
  activity: (     var num1 : int ; num1 := obj1->oclAsType(int) ;
     var num2 : int ; num2 := obj2->oclAsType(int) ;
     if (num1 < num2) then (     return 1 ) else     if (num1 > num2) then (     return -1 ) else (     return 0 ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
import java.io.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    boolean f=false ;
    for(int i=0 ; i<a ; i++){
      if(c % a==0){
        f=true ;
        break ;
      }
      else {
        c+=b ;
      }
    }
    io.YESNO(f);
    sc.close();
  }
}
class io {
  public static void br(){
    System.out.println("");
  }
  public static void yesno(boolean f){
    System.out.println(f ? "yes" : "no");
  }
  public static void YesNo(boolean f){
    System.out.println(f ? "Yes" : "No");
  }
  public static void YESNO(boolean f){
    System.out.println(f ? "YES" : "NO");
  }
}
class Algo {
  public static int nibutan(int target,int[] ar){
    int res ;
    int high=ar.length ;
    int low=0 ;
    while(high>low){
      res=(high+low)/2 ;
      if(ar[res]<target){
        low=res+1 ;
      }
      else {
        high=res ;
      }
    }
    return low ;
  }
  public static boolean isOdd(int n){
    return n % 2==1 ;
  }
  public static boolean isEven(int n){
    return n % 2==0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var f : boolean ; f := false ;
        var i : int ; i := 0 ; while i < a do ( (     if (c mod a = 0) then (     f := true ; 
     break ) else (     c := c+(b) ) )  ;     i := i + 1 ) ; 
    io.YESNO(f) ; 
    skip ; 
 );
}
class io {
  static   operation br() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("") );
  static   operation yesno( f : boolean) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if f then "yes" else "no" endif) );
  static   operation YesNo( f : boolean) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if f then "Yes" else "No" endif) );
  static   operation YESNO( f : boolean) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if f then "YES" else "NO" endif) );
}
class Algo {
  static   operation nibutan( target : int, ar : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var res : int ;
     var high : int ; high := ar->size() ;
    var low : int ; low := 0 ;
    while (high > low) do (     res := (high + low) / 2 ; 
     if (ar[res+1] < target) then (     low := res + 1 ) else (     high := res ) ) ; 
    return low 
 );
  static   operation isOdd( n : int) : boolean
  pre: true
  post: true
  activity: (     return n mod 2 = 1 );
  static   operation isEven( n : int) : boolean
  pre: true
  post: true
  activity: (     return n mod 2 = 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.*;
import java.util.*;
import java.util.ArrayList ;
import java.util.Iterator ;
import java.util.List ;
import java.util.Collections ;
import java.util.Arrays ;
public class Main {
  public static void main(final String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int sum=0 ;
    int count=0 ;
    for(int i=0 ; i<100000 ; i++){
      sum+=a % b ;
      sum=sum % b ;
      if(sum==c){
        count++;
      }
    }
    if(count==0){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < 100000 do ( (     sum := sum+(a mod b) ; 
     sum := sum mod b ; 
     if (sum = c) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (count = 0) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt(),q=sc.nextInt();
    int d[]=new int[k];
    for(int i=0 ; i<k ; ++i){
      d[i]=sc.nextInt();
    }
    for(int i=0 ; i<q ; ++i){
      int n=sc.nextInt();
      int x=sc.nextInt();
      int m=sc.nextInt();
      long tmp=0 ;
      long a=(long)x ;
      for(int j=0 ; j<k ; ++j){
        int num=(n-j+k-2)/k ;
        int tmpd=d[j] % m ;
        if(tmpd==0)tmp+=(long)num ;
        a+=((long)tmpd*(long)num);
      }
      long ans=(long)n-1-((a/(long)m)-((long)x/(long)m))-tmp ;
      System.out.println(ans);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var d : Sequence(int) ; d := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     d[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var tmp : long ; tmp := 0 ;
    var a : long ; a := x->oclAsType(long) ;
        var j : int ; j := 0 ; while j < k do ( (     var num : int ; num := (n - j + k - 2) / k ;
     var tmpd : int ; tmpd := d[j+1] mod m ;
     if (tmpd = 0) then     tmp := tmp+(num->oclAsType(long)) ; else skip ; 
     a := a+((tmpd->oclAsType(long) * num->oclAsType(long))) )  ;     j := j + 1 ) ; 
    var ans : long ; ans := n->oclAsType(long) - 1 - ((a / m->oclAsType(long)) - (x->oclAsType(long) / m->oclAsType(long))) - tmp ;
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static double findMean(int a[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=a[i];
    return(double)sum/(double)n ;
  }
  public static double findMedian(int a[],int n){
    Arrays.sort(a);
    if(n % 2!=0)return(double)a[n/2];
    return(double)(a[(n-1)/2]+a[n/2])/2.0 ;
  }
  public static void main(String args[]){
    int a[]={
      1,3,4,2,7,5,8,6 };
      int n=a.length ;
      System.out.println("Mean="+findMean(a,n));
      System.out.println("Median="+findMedian(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMean( a : Sequence(int), n : int) : double
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+(a[i+1]) ;  ;     i := i + 1 ) ; 
     return sum->oclAsType(double) / n->oclAsType(double) );
  static   operation findMedian( a : Sequence(int), n : int) : double
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     if (n mod 2 /= 0) then     return a[n / 2+1]->oclAsType(double) else skip ; 
     return (a[(n - 1) / 2+1] + a[n / 2+1])->oclAsType(double) / 2.0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,3,4,2,7,5,8,6} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println("Mean=" + findMean(a, n)) ; 
     OclFile["System.out"].println("Median=" + findMedian(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Vector ;
class GFG {
  static String isFibonacci(String s){
    HashMap<Character,Integer>m=new HashMap<>();
    for(int i=0 ; i<s.length(); i++)m.put(s.charAt(i),m.get(s.charAt(i))==null ? 1 : m.get(s.charAt(i))+1);
    Vector<Integer>v=new Vector<>();
    int n=m.size();
    int a=1,b=1 ;
    int c ;
    v.add(a);
    v.add(b);
    for(int i=0 ; i<n-2 ; i++){
      v.add(a+b);
      c=a+b ;
      a=b ;
      b=c ;
    }
    int flag=1 ;
    int i=0 ;
    for(HashMap.Entry<Character,Integer>entry : m.entrySet()){
      if(entry.getValue()!=v.elementAt(i)){
        flag=1 ;
        break ;
      }
      i++;
    }
    if(flag==1)return "YES" ;
    else return "NO" ;
  }
  public static void main(String[] args){
    String s="abeeedd" ;
    System.out.println(isFibonacci(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isFibonacci( s : String) : String
  pre: true
  post: true
  activity: (     var m : Map(String,int) ; m := Map{} ;
         var i : int ; i := 0 ; while i < s->size() do (     m := m->union(Map{s->at(i+1) |-> if m->at(s->at(i+1)) = null then 1 else m->at(s->at(i+1)) + 1 endif}) ;  ;     i := i + 1 ) ; 
    var v : Sequence(int) ; v := Sequence{} ;
    var n : int ; n := m.size() ;
    var a : int ; a := 1 ;
    var b : int ; b := 1 ;
    var c : int ;
    v := v->including(a) ; 
    v := v->including(b) ; 
        var i : int ; i := 0 ; while i < n - 2 do ( (     v := v->including(a + b) ; 
     c := a + b ; 
     a := b ; 
     b := c )  ;     i := i + 1 ) ; 
    var flag : int ; flag := 1 ;
    var i : int ; i := 0 ;
    for (entry : m->asSet()) do ( (     if (entry.getValue() /= v->at(i+1)) then (     flag := 1 ; 
     break ) else skip ; 
     i := i + 1 )  ) ; 
    if (flag = 1) then     return "YES" else     return "NO" ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abeeedd" ;
     OclFile["System.out"].println(isFibonacci(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
class Main {
  static Scanner scanner=new Scanner(System.in);
  static HashMap<Integer,Integer>map ;
  public static void main(String args[]){
    while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      map=new HashMap<Integer,Integer>();
      System.out.println(solve(n));
    }
  }
  static String solve(int n){
    int i=0 ;
    Integer m ;
    Integer num ;
    String result="NO COLOR" ;
    for(i=0 ; i<n ; i++){
      m=scanner.nextInt();
      num=map.get(m);
      if(num!=null){
        num++;
        map.put(m,num);
        if(num>n/2)result=m+"" ;
      }
      else {
        map.put(m,1);
        num=1 ;
        if(num>n/2)result=m+"" ;
      }
      if(i % 100000==0)System.gc();
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute map : Map(int,int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
     map := Map{} ; 
     OclFile["System.out"].println(solve(n)) ) );
  static   operation solve( n : int) : String
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var m : int ;
    var num : int ;
    var result : String ; result := "NO COLOR" ;
        i := 0 ; while i < n do ( (     m := scanner.getCurrent()->toInteger() ; 
     num := map->at(m) ; 
     if (num /= null) then (     num := num + 1 ; 
     map := map->union(Map{m |-> num}) ; 
     if (num > n / 2) then     result := m + "" ; else skip ) else (     map := map->union(Map{m |-> 1}) ; 
     num := 1 ; 
     if (num > n / 2) then     result := m + "" ; else skip ) ;  
     if (i mod 100000 = 0) then gc() ; else skip )  ;     i := i + 1 ) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    String nextLine()throws IOException {
      return br.readLine();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  static FastScanner in=new FastScanner();
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException {
    int n=in.nextInt();
    String str=in.next();
    if(str.indexOf('R')==-1){
      int s=str.indexOf('L')+1 ;
      s-=s==1 ? 0 : 1 ;
      out.println((str.lastIndexOf('L')+1)+" "+s);
    }
    else if(str.indexOf('L')==-1){
      int t=(str.lastIndexOf('R')+2);
      t=Math.min(t,n);
      out.println((str.indexOf('R')+1)+" "+t);
    }
    else out.println((str.lastIndexOf('L')+1)+" "+(Math.min(str.lastIndexOf('R')+2,n)));
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   attribute in : FastScanner := FastScanner.newFastScanner();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var str : String ; str := in.next() ;
     if (str->indexOf('R')-1 = -1) then (     var s : int ; s := str->indexOf('L')-1 + 1 ;
     s := s-(if s = 1 then 0 else 1 endif) ; 
     skip ) else     if (str->indexOf('L')-1 = -1) then (     var t : int ; t := (str->lastIndexOf('R')-1 + 2) ;
     t := Set{t, n}->min() ; 
     skip ) else     skip ; ;  ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.IllegalFormatCodePointException ;
import java.util.Scanner ;
public class Main {
  static ArrayList md=new ArrayList();
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String x=in.next();
    int s=0 ;
    int t=0 ;
    for(int i=0 ; i<x.length(); i++){
      if(x.charAt(i)=='R'){
        if(x.charAt(i-1)=='.'){
          s=i+1 ;
        }
        if(x.charAt(i+1)=='L'){
          t=i+1 ;
          break ;
        }
        else if(x.charAt(i+1)=='.'){
          t=i+2 ;
          break ;
        }
        continue ;
      }
      if(x.charAt(i)=='L'){
        if(x.charAt(i-1)=='.'){
          t=i ;
        }
        if(x.charAt(i+1)=='.'){
          s=i+1 ;
        }
        continue ;
      }
    }
    System.out.println(s+" "+t);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute md : Sequence := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var x : String ; x := in.getCurrent() ;
    var s : int ; s := 0 ;
    var t : int ; t := 0 ;
        var i : int ; i := 0 ; while i < x->size() do ( (     if (x->at(i+1) = 'R') then (     if (x->at(i - 1+1) = '.') then (     s := i + 1 ) else skip ; 
     if (x->at(i + 1+1) = 'L') then (     t := i + 1 ; 
     break ) else     if (x->at(i + 1+1) = '.') then (     t := i + 2 ; 
     break ) else skip ; ;  
     continue ) else skip ; 
     if (x->at(i+1) = 'L') then (     if (x->at(i - 1+1) = '.') then (     t := i ) else skip ; 
     if (x->at(i + 1+1) = '.') then (     s := i + 1 ) else skip ; 
     continue ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s + " " + t) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.text.DecimalFormat ;
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.regex.Matcher ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String s=in.next();
    char[] c=s.toCharArray();
    int f=0 ;
    int l=0 ;
    for(int i=0 ; i<n ; i++){
      if(c[i]!='.'){
        f=i ;
        break ;
      }
    }
    for(int i=n-1 ; i>=0 ; --i){
      if(c[i]!='.'){
        l=i ;
        break ;
      }
    }
    if(c[f]=='R' && c[l]=='R'){
      System.out.print(++f+" "+(l+2));
    }
    else if(c[f]=='L' && c[l]=='L'){
      System.out.print((l+1)+" "+(f-1+1));
    }
    else if(c[f]=='R' && c[l]=='L'){
      for(int i=0 ; i<n ; i++){
        l=i ;
        if(c[i]=='L'){
          break ;
        }
      }
      System.out.print((f+1)+" "+(l-1+1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var c : Sequence(String) ; c := s->characters() ;
    var f : int ; f := 0 ;
    var l : int ; l := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (c[i+1] /= '.') then (     f := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (c[i+1] /= '.') then (     l := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    if (c[f+1] = 'R' & c[l+1] = 'R') then (     OclFile["System.out"].print((f + 1) + " " + (l + 2)) ) else     if (c[f+1] = 'L' & c[l+1] = 'L') then (     OclFile["System.out"].print((l + 1) + " " + (f - 1 + 1)) ) else     if (c[f+1] = 'R' & c[l+1] = 'L') then (         var i : int ; i := 0 ; while i < n do ( (     l := i ; 
     if (c[i+1] = 'L') then (     break ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print((f + 1) + " " + (l - 1 + 1)) ) else skip ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Snow {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String limak=sc.next();
    sc.close();
    int R=limak.indexOf('R');
    int L=limak.indexOf('L');
    int start=0,end=0 ;
    if(R!=-1 && L==-1){
      start=R ;
      end=limak.lastIndexOf("R")+1 ;
    }
    else if(R==-1 && L!=-1){
      start=limak.lastIndexOf("L");
      end=L-1 ;
    }
    else if(R!=-1 && L!=-1){
      start=R ;
      end=L-1 ;
    }
    System.out.println((start+1)+" "+(end+1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Snow {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var limak : String ; limak := sc.getCurrent() ;
    skip ; 
    var R : int ; R := limak->indexOf('R')-1 ;
    var L : int ; L := limak->indexOf('L')-1 ;
    var start : int ; start := 0 ;
    var end : int ; end := 0 ;
    if (R /= -1 & L = -1) then (     start := R ; 
     end := limak->lastIndexOf("R")-1 + 1 ) else     if (R = -1 & L /= -1) then (     start := limak->lastIndexOf("L")-1 ; 
     end := L - 1 ) else     if (R /= -1 & L /= -1) then (     start := R ; 
     end := L - 1 ) else skip ; ;  ;  
    OclFile["System.out"].println((start + 1) + " " + (end + 1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int num=in.nextInt();
    String str=in.next();
    int countR=0 ;
    int countL=0 ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)=='R')countR++;
      else if(str.charAt(i)=='L'){
        countL++;
      }
    }
    int end=0 ;
    int start=0 ;
    if(countR==0){
      end=str.indexOf("L");
      start=str.lastIndexOf("L")+1 ;
    }
    else if(countL==0){
      end=str.lastIndexOf("R")+2 ;
      start=str.indexOf("R")+1 ;
    }
    else {
      end=str.lastIndexOf("R")+1 ;
      start=str.indexOf("R")+1 ;
    }
    out.println(start+" "+end);
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new FileReader("sub.in"));
      }
      catch(FileNotFoundException ex){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException ex){
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException ex){
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var num : int ; num := in.nextInt() ;
    var str : String ; str := in.next() ;
    var countR : int ; countR := 0 ;
    var countL : int ; countL := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = 'R') then     countR := countR + 1 ; else     if (str->at(i+1) = 'L') then (     countL := countL + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    var end : int ; end := 0 ;
    var start : int ; start := 0 ;
    if (countR = 0) then (     end := str->indexOf("L")-1 ; 
     start := str->lastIndexOf("L")-1 + 1 ) else     if (countL = 0) then (     end := str->lastIndexOf("R")-1 + 2 ; 
     start := str->indexOf("R")-1 + 1 ) else (     end := str->lastIndexOf("R")-1 + 1 ; 
     start := str->indexOf("R")-1 + 1 ) ;  ;  
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("sub.in"))) )   catch (ex : FileNotFoundException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (ex : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (ex : IOException) do skip
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findCount(int n){
    long a=1,b=0,c=0 ;
    int x=n/60 ;
    a=(long)Math.pow(32,x);
    x=60*x ;
    for(int i=x+1 ; i<=n ; i++){
      if(i % 2==0){
        b+=a ;
        a=0 ;
      }
      if(i % 5==0){
        c+=b ;
        b=0 ;
      }
      if(i % 12==0){
        a+=(2*c);
        c=0 ;
      }
    }
    System.out.println("a="+a+",b="+b+",c="+c);
  }
  public static void main(String[] args){
    int n=72 ;
    findCount(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findCount( n : int) : void
  pre: true
  post: true
  activity: (     var a : long ; a := 1 ;
    var b : long ; b := 0 ;
    var c : long ; c := 0 ;
     var x : int ; x := n / 60 ;
    a := 32->pow(x)->oclAsType(long) ; 
    x := 60 * x ; 
        var i : int ; i := x + 1 ; while i <= n do ( (     if (i mod 2 = 0) then (     b := b+(a) ; 
     a := 0 ) else skip ; 
     if (i mod 5 = 0) then (     c := c+(b) ; 
     b := 0 ) else skip ; 
     if (i mod 12 = 0) then (     a := a+((2 * c)) ; 
     c := 0 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("a=" + a + ",b=" + b + ",c=" + c) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 72 ;
     execute findCount(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.StreamTokenizer ;
public class Main {
  static class input {
    static BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    static StreamTokenizer in=new StreamTokenizer(bf);
    static int nextInt()throws IOException {
      in.nextToken();
      return(int)in.nval ;
    }
  }
  public static void main(String[] args)throws IOException {
    int n=input.nextInt();
    long c=0 ;
    long ans=0 ;
    int t ;
    for(int i=1 ; i<=n ; i++){
      t=input.nextInt();
      if(t==1)c++;
      else ans+=c ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class input {
  static   attribute bf : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute in : StreamTokenizer := StreamTokenizer.newStreamTokenizer(bf);
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     in.next() ; 
     return in.nval->oclAsType(int) );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := input.nextInt() ;
     var c : long ; c := 0 ;
    var ans : long ; ans := 0 ;
    var t : int ;
        var i : int ; i := 1 ; while i <= n do ( (     t := input.nextInt() ; 
     if (t = 1) then     c := c + 1 ; else     ans := ans+(c) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static StreamTokenizer st=new StreamTokenizer(br);
  static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
  public static void main(String[] args)throws IOException {
    int n=nextInt();
    long milk=0,sum=0 ;
    for(int i=0 ; i<n ; i++){
      int t=nextInt();
      if(t==1)milk++;
      else sum+=milk ;
    }
    out.println(sum);
    out.flush();
  }
  public static int nextInt()throws IOException {
    st.nextToken();
    return(int)st.nval ;
  }
  public static double nextDouble()throws IOException {
    st.nextToken();
    return st.nval ;
  }
  public static String nextString()throws IOException {
    st.nextToken();
    return st.sval ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute st : StreamTokenizer := StreamTokenizer.newStreamTokenizer(br);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var milk : long ; milk := 0 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var t : int ; t := nextInt() ;
     if (t = 1) then     milk := milk + 1 ; else     sum := sum+(milk) ; )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     st.next() ; 
     return st.nval->oclAsType(int) );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     st.next() ; 
     return st.nval );
  static   operation nextString() : String
  pre: true
  post: true
  activity: (     st.next() ; 
     return st.sval );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static PrintWriter out=new PrintWriter(System.out);
  static Scanner sc=new Scanner(System.in);
  static BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
  int k ;
  long[] d ;
  public static void main(String[] args)throws IOException {
    Main main=new Main();
    main.solve();
  }
  void solve()throws IOException {
    k=sc.nextInt();
    int q=sc.nextInt();
    d=new long[k];
    for(int i=0 ; i<k ; i++)d[i]=sc.nextInt();
    while(q-->0){
      int n=sc.nextInt(),x=sc.nextInt(),m=sc.nextInt();
      long ans=helper(n,x,m);
      out.println(ans);
    }
    out.flush();
  }
  long helper(long n,long x,long m){
    long[] tempD=new long[k];
    for(int i=0 ; i<k ; i++)tempD[i]=d[i] % m ;
    long res=0 ;
    for(int j=0 ; j<k ; j++){
      if(tempD[j]!=0)continue ;
      long cur=(n-1)/k ;
      cur+=(n-1)% k>j ? 1 : 0 ;
      res+=cur ;
    }
    long time=(n-1)/k,r=(n-1)% k ;
    long sumD=0 ;
    for(long num : tempD)sumD+=num ;
    long end=x+time*sumD ;
    for(int i=0 ; i<r ; i++)end+=tempD[i];
    long diff=end/m-x/m ;
    res+=diff ;
    return n-1-res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute k : int;
   attribute d : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     k := sc.getCurrent()->toInteger() ; 
     var q : int ; q := sc.getCurrent()->toInteger() ;
    d := Integer.subrange(1,k)->collect(0) ; 
        var i : int ; i := 0 ; while i < k do (     d[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        while (q > 0) do (        q := q - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
     var ans : long ; ans := helper(n, x, m) ;
     skip ) ;  ) ;  
    skip ; 
 );
   operation helper( n : long, x : long, m : long) : long
  pre: true
  post: true
  activity: (     var tempD : Sequence(long) ; tempD := Integer.subrange(1,k)->collect(0) ;
         var i : int ; i := 0 ; while i < k do (     tempD[i+1] := d[i+1] mod m ;  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
        var j : int ; j := 0 ; while j < k do ( (     if (tempD[j+1] /= 0) then     continue else skip ; 
     var cur : long ; cur := (n - 1) / k ;
     cur := cur+(if (n - 1) mod k > j then 1 else 0 endif) ; 
     res := res+(cur) )  ;     j := j + 1 ) ; 
    var time : long ; time := (n - 1) / k ;
    var r : long ; r := (n - 1) mod k ;
    var sumD : long ; sumD := 0 ;
    for (num : tempD) do (     sumD := sumD+(num) ;  ) ; 
    var end : long ; end := x + time * sumD ;
        var i : int ; i := 0 ; while i < r do (     end := end+(tempD[i+1]) ;  ;     i := i + 1 ) ; 
    var diff : long ; diff := end / m - x / m ;
    res := res+(diff) ; 
    return n - 1 - res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    int n=nextInt();
    long[] a=new long[n+1];
    long cnt=0,ans=0 ;
    for(int i=1 ; i<=n ; i++){
      a[i]=nextLong();
      if(a[i]==1){
        cnt++;
      }
      else {
        ans+=cnt ;
      }
    }
    System.out.println(ans);
  }
  static StreamTokenizer st=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
  static int nextInt()throws IOException {
    st.nextToken();
    return(int)st.nval ;
  }
  static long nextLong()throws IOException {
    st.nextToken();
    return(long)st.nval ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var cnt : long ; cnt := 0 ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := nextLong() ; 
     if (a[i+1] = 1) then (     cnt := cnt + 1 ) else (     ans := ans+(cnt) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   attribute st : StreamTokenizer := StreamTokenizer.newStreamTokenizer(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])));
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     st.next() ; 
     return st.nval->oclAsType(int) );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     st.next() ; 
     return st.nval->oclAsType(long) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Factorial {
  int factorial(int n){
    return(n==1 || n==0)? 1 : n*factorial(n-1);
  }
  public static void main(String args[]){
    Factorial obj=new Factorial();
    int num=5 ;
    System.out.println("Factorial of "+num+" is "+obj.factorial(num));
  }
}
------------------------------------------------------------
OCL File:
---------
class Factorial {
   operation factorial( n : int) : int
  pre: true
  post: true
  activity: (     return if (n = 1 or n = 0) then 1 else n * factorial(n - 1) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Factorial ; obj := Factorial.newFactorial() ;
     var num : int ; num := 5 ;
     OclFile["System.out"].println("Factorial of " + num + " is " + obj.factorial(num)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.StreamTokenizer ;
public class Main {
  static int n,t ;
  static long cnt=0l,sum=0l ;
  public static void main(String[] args)throws IOException {
    n=nextInt();
    for(int i=0 ; i<n ; i++){
      t=nextInt();
      if(t==1)cnt++;
      else sum+=cnt ;
    }
    System.out.println(sum);
  }
  static StreamTokenizer st=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
  static int nextInt()throws IOException {
    st.nextToken();
    return(int)st.nval ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute cnt : long := 0l;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := nextInt() ; 
         var i : int ; i := 0 ; while i < n do ( (     t := nextInt() ; 
     if (t = 1) then     cnt := cnt + 1 ; else     sum := sum+(cnt) ; )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sum) );
  static   attribute st : StreamTokenizer := StreamTokenizer.newStreamTokenizer(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])));
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     st.next() ; 
     return st.nval->oclAsType(int) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long n,d ;
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int count_odd=0 ;
    for(int i=0 ; i<n ; i++){
      if(in.nextInt()% 2==1){
        count_odd++;
      }
    }
    if(count_odd!=0){
      pw.println("First");
    }
    else {
      pw.println("Second");
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var count_odd : int ; count_odd := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (in.getCurrent()->toInteger() mod 2 = 1) then (     count_odd := count_odd + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (count_odd /= 0) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int i,j,k ;
    int n,m ;
    int od=0,ev=0 ;
    n=sc.nextInt();
    int a[]=new int[n];
    for(i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      if(a[i] % 2==0)ev++;
      else od++;
    }
    if(ev==n){
      System.out.println("Second");
    }
    else System.out.println("First");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ;
    var j : int ;
    var k : int ;
    var n : int ;
    var m : int ;
    var od : int ; od := 0 ;
    var ev : int ; ev := 0 ;
    n := sc.getCurrent()->toInteger() ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (a[i+1] mod 2 = 0) then     ev := ev + 1 ; else     od := od + 1 ; )  ;     i := i + 1 ) ; 
    if (ev = n) then (     OclFile["System.out"].println("Second") ) else     OclFile["System.out"].println("First") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Godsend841B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int arr[]=new int[n];
    int sum=0,count=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
      sum+=arr[i];
      if(arr[i] % 2!=0)count++;
    }
    if(sum % 2!=0 || count>0){
      System.out.println("First");
      return ;
    }
    if(count==0){
      System.out.println("Second");
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Godsend841B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() ; 
     sum := sum+(arr[i+1]) ; 
     if (arr[i+1] mod 2 /= 0) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (sum mod 2 /= 0 or count > 0) then (     OclFile["System.out"].println("First") ; 
     return ) else skip ; 
    if (count = 0) then (     OclFile["System.out"].println("Second") ; 
     return ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class problemB {
  public static int n ;
  public static int s=0 ;
  public static int a[];
  public static int rightMostIndex(){
    for(int i=n ; i>=1 ; i--){
      if(a[i] % 2==1)return i ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    a=new int[n+5];
    s=0 ;
    for(int i=1 ; i<=n ; i++){
      a[i]=sc.nextInt();
      s+=a[i];
    }
    if(s % 2==1)System.out.println("First");
    else {
      int index=rightMostIndex();
      if(index==-1)System.out.println("Second");
      else System.out.println("First");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class problemB {
  static   attribute n : int;
  static   attribute s : int := 0;
  static   attribute a : Sequence(int);
  static   operation rightMostIndex() : int
  pre: true
  post: true
  activity: (         var i : int ; i := n ; while i >= 1 do ( (     if (a[i+1] mod 2 = 1) then     return i else skip )  ;     i := i - 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,n + 5)->collect(0) ; 
    s := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     s := s+(a[i+1]) )  ;     i := i + 1 ) ; 
    if (s mod 2 = 1) then     OclFile["System.out"].println("First") else (     var index : int ; index := rightMostIndex() ;
     if (index = -1) then     OclFile["System.out"].println("Second") ; else     OclFile["System.out"].println("First") ; ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class AlenaSchedule {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int pairs[]=new int[n];
    int cntr=0 ;
    for(int i=0 ; i<n ; i++)pairs[i]=in.nextInt();
    for(int i=0 ; i<n ; i++){
      if(pairs[i]==1)cntr++;
      else {
        if((i>0 && i<n-1)&&(pairs[i-1]==1 && pairs[i+1]==1))cntr++;
      }
    }
    System.out.println(cntr);
  }
}
------------------------------------------------------------
OCL File:
---------
 class AlenaSchedule {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var pairs : Sequence(int) ; pairs := Integer.subrange(1,n)->collect(0) ;
    var cntr : int ; cntr := 0 ;
        var i : int ; i := 0 ; while i < n do (     pairs[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (pairs[i+1] = 1) then     cntr := cntr + 1 ; else (     if ((i > 0 & i < n - 1) & (pairs[i - 1+1] = 1 & pairs[i + 1+1] = 1)) then     cntr := cntr + 1 ; else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cntr) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] arr=new int[n+5];
    int count=0 ;
    for(int i=1 ; i<n+1 ; i++)arr[i]=input.nextInt();
    for(int i=1 ; i<n+1 ; i++){
      if(arr[i]==1)count++;
      if((arr[i]==0 && arr[i+1]==1 && arr[i-1]==1))count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 5)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < n + 1 do (     arr[i+1] := input.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n + 1 do ( (     if (arr[i+1] = 1) then     count := count + 1 ; else skip ; 
     if ((arr[i+1] = 0 & arr[i + 1+1] = 1 & arr[i - 1+1] = 1)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class AlenaSchedule {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),i,a[]=new int[n],o=0 ;
    for(i=0 ; i<n ; i++){
      a[i]=in.nextInt();
      if(a[i]==1)o++;
    }
    in.close();
    for(i=1 ; i<n-1 ; i++){
      if(a[i]==0 && a[i-1]==1 && a[i+1]==1)o++;
    }
    System.out.println(o);
  }
}
------------------------------------------------------------
OCL File:
---------
 class AlenaSchedule {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var i : int ;
    var a : Sequence(void) ; a := Integer.subrange(1,n)->collect(0) ;
    var o : int ; o := 0 ;
        i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     if (a[i+1] = 1) then     o := o + 1 ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
        i := 1 ; while i < n - 1 do ( (     if (a[i+1] = 0 & a[i - 1+1] = 1 & a[i + 1+1] = 1) then     o := o + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(o) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int pred1=1 ;
    int pred2=1 ;
    int res=0 ;
    int next=0 ;
    for(int i=0 ; i<n ; i++){
      if(i>1){
        pred2=pred1 ;
      }
      if(i>0){
        pred1=next ;
      }
      next=scan.nextInt();
      if(next==1){
        res++;
        if(pred1==0 && pred2==1 && i>1){
          res++;
        }
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var pred1 : int ; pred1 := 1 ;
    var pred2 : int ; pred2 := 1 ;
    var res : int ; res := 0 ;
    var next : int ; next := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i > 1) then (     pred2 := pred1 ) else skip ; 
     if (i > 0) then (     pred1 := next ) else skip ; 
     next := scan.getCurrent()->toInteger() ; 
     if (next = 1) then (     res := res + 1 ; 
     if (pred1 = 0 & pred2 = 1 & i > 1) then (     res := res + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args)throws Exception {
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int K=sc.nextInt();
    int Q=sc.nextInt();
    long[] d=new long[K];
    long[] n=new long[Q];
    long[] x=new long[Q];
    long[] m=new long[Q];
    for(int i=0 ; i<K ; ++i){
      d[i]=sc.nextLong();
    }
    for(int i=0 ; i<Q ; ++i){
      n[i]=sc.nextLong();
      x[i]=sc.nextLong();
      m[i]=sc.nextLong();
    }
    PrintWriter pw=new PrintWriter(System.out);
    for(int q=0 ; q<Q ; ++q){
      long[] sum=new long[K];
      for(int i=0 ; i<K ; ++i){
        long add=d[i] % m[q];
        if(add==0)add=m[q];
        sum[i]=(i>0 ? sum[i-1] : 0)+add ;
      }
      long all=sum[K-1];
      long first=x[q];
      long last=x[q]+sum[(int)((n[q]-2)% K)]+all*((n[q]-2)/K);
      long ans=(last/m[q]*m[q]-first/m[q]*m[q])/m[q];
      pw.println(n[q]-1-ans);
    }
    pw.close();
  }
  static void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    var Q : int ; Q := sc.getCurrent()->toInteger() ;
    var d : Sequence(long) ; d := Integer.subrange(1,K)->collect(0) ;
    var n : Sequence(long) ; n := Integer.subrange(1,Q)->collect(0) ;
    var x : Sequence(long) ; x := Integer.subrange(1,Q)->collect(0) ;
    var m : Sequence(long) ; m := Integer.subrange(1,Q)->collect(0) ;
        var i : int ; i := 0 ; while i < K do ( (     d[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Q do ( (     n[i+1] := sc.getCurrent()->toLong() ; 
     x[i+1] := sc.getCurrent()->toLong() ; 
     m[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
        var q : int ; q := 0 ; while q < Q do ( (     var sum : Sequence(long) ; sum := Integer.subrange(1,K)->collect(0) ;
         var i : int ; i := 0 ; while i < K do ( (     var add : long ; add := d[i+1] mod m[q+1] ;
     if (add = 0) then     add := m[q+1] ; else skip ; 
     sum[i+1] := (if i > 0 then sum[i - 1+1] else 0 endif) + add )  ;     i := i + 1 ) ; 
    var all : long ; all := sum[K - 1+1] ;
    var first : long ; first := x[q+1] ;
    var last : long ; last := x[q+1] + sum[((n[q+1] - 2) mod K)->oclAsType(int)+1] + all * ((n[q+1] - 2) / K) ;
    var ans : long ; ans := (last / m[q+1] * m[q+1] - first / m[q+1] * m[q+1]) / m[q+1] ;
    skip ; 
 )  ;     q := q + 1 ) ; 
    skip ; 
 );
  static   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static Scanner sc=new Scanner(System.in);
  public static void main(String args[]){
    int n=sc.nextInt();
    String s=sc.next();
    char arr[]=new char[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=s.charAt(i);
    }
    for(int i=1 ; i<=n ; i++){
      if(n % i==0){
        for(int j=0 ; j<i/2 ; j++){
          char tmp=arr[j];
          arr[j]=arr[i-j-1];
          arr[i-j-1]=tmp ;
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(arr[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
    var arr : Sequence(String) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s->at(i+1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (n mod i = 0) then (         var j : int ; j := 0 ; while j < i / 2 do ( (     var tmp : String ; tmp := arr[j+1] ;
     arr[j+1] := arr[(i)->char2byte() - j - 1+1] ; 
     arr[(i)->char2byte() - j - 1+1] := tmp )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int d=sc.nextInt();
    int g=sc.nextInt();
    int[] pronums=new int[d+1];
    int[] bons=new int[d+1];
    for(int i=d ; i>=1 ; i--){
      pronums[i]=sc.nextInt();
      bons[i]=sc.nextInt();
    }
    int min=1000 ;
    int sum ;
    int num ;
    for(int i=0 ; i<(1<<d); i++){
      sum=0 ;
      num=0 ;
      for(int j=0 ; j<d ; j++){
        if((i>>j & 1)==1){
          sum+=100*(d-j)*pronums[j+1]+bons[j+1];
          num+=pronums[j+1];
        }
      }
      if(sum>=g){
        min=Math.min(min,num);
        continue ;
      }
      for(int j=0 ; j<d ; j++){
        if((i>>j & 1)==0){
          if((double)(g-sum)/((d-j)*100)>pronums[j+1]-1){
            break ;
          }
          else {
            num+=((g-sum)+((d-j)*100)-1)/((d-j)*100);
            min=Math.min(min,num);
          }
        }
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
    var g : int ; g := sc.getCurrent()->toInteger() ;
    var pronums : Sequence(int) ; pronums := Integer.subrange(1,d + 1)->collect(0) ;
    var bons : Sequence(int) ; bons := Integer.subrange(1,d + 1)->collect(0) ;
        var i : int ; i := d ; while i >= 1 do ( (     pronums[i+1] := sc.getCurrent()->toInteger() ; 
     bons[i+1] := sc.getCurrent()->toInteger() )  ;     i := i - 1 ) ; 
    var min : int ; min := 1000 ;
    var sum : int ;
    var num : int ;
        var i : int ; i := 0 ; while i < ((1*(2->pow(d)))->oclAsType(long)) do ( (     sum := 0 ; 
     num := 0 ; 
        var j : int ; j := 0 ; while j < d do ( (     if ((MathLib.bitwiseAnd((i/(2->pow(j)))->oclAsType(long),1)) = 1) then (     sum := sum+(100 * (d - j) * pronums[j + 1+1] + bons[j + 1+1]) ; 
     num := num+(pronums[j + 1+1]) ) else skip )  ;     j := j + 1 ) ; 
    if (sum >= g) then (     min := Set{min, num}->min() ; 
     continue ) else skip ; 
        var j : int ; j := 0 ; while j < d do ( (     if ((MathLib.bitwiseAnd((i/(2->pow(j)))->oclAsType(long),1)) = 0) then (     if ((g - sum)->oclAsType(double) / ((d - j) * 100) > pronums[j + 1+1] - 1) then (     break ) else (     num := num+(((g - sum) + ((d - j) * 100) - 1) / ((d - j) * 100)) ; 
     min := Set{min, num}->min() ) ) else skip )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] AStr=br.readLine().split(" ");
    int[] Aint=new int[n];
    for(int i=0 ; i<n ; i++){
      Aint[i]=Integer.parseInt(AStr[i]);
    }
    int j=partation(Aint,0,n);
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      if(i==j){
        sb.append("[");
        sb.append(String.valueOf(Aint[i]));
        sb.append("] ");
        sb.append(" ");
      }
      else {
        sb.append(String.valueOf(Aint[i]));
        sb.append(" ");
      }
    }
    System.out.println(sb.toString().trim());
  }
  private static int partation(int[] A,int p,int r){
    int x=A[r-1];
    int j=-1 ;
    int tmp ;
    for(int i=0 ; i<r-1 ; i++){
      if(x>=A[i]){
        j++;
        tmp=A[i];
        A[i]=A[j];
        A[j]=tmp ;
      }
    }
    j++;
    tmp=A[r-1];
    A[r-1]=A[j];
    A[j]=tmp ;
    return j ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var AStr : Sequence(String) ; AStr := br.readLine()->split(" ") ;
    var Aint : Sequence(int) ; Aint := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     Aint[i+1] := (AStr[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var j : int ; j := partation(Aint, 0, n) ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     if (i = j) then (     sb := sb + StringLib.newString("[") ; 
     sb := sb + StringLib.newString(((Aint[i+1]) + "")) ; 
     sb := sb + StringLib.newString("] ") ; 
     sb := sb + StringLib.newString(" ") ) else (     sb := sb + StringLib.newString(((Aint[i+1]) + "")) ; 
     sb := sb + StringLib.newString(" ") ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+""->trim()) ; 
 );
  static   operation partation( A : Sequence(int), p : int, r : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := A[r - 1+1] ;
     var j : int ; j := -1 ;
    var tmp : int ;
        var i : int ; i := 0 ; while i < r - 1 do ( (     if (x >= A[i+1]) then (     j := j + 1 ; 
     tmp := A[i+1] ; 
     A[i+1] := A[j+1] ; 
     A[j+1] := tmp ) else skip )  ;     i := i + 1 ) ; 
    j := j + 1 ; 
    tmp := A[r - 1+1] ; 
    A[r - 1+1] := A[j+1] ; 
    A[j+1] := tmp ; 
    return j 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int partition(int[] arr,int p,int r){
    int x=arr[r];
    int i=p-1 ;
    for(int j=p ; j<r ; j++){
      if(arr[j]<=x){
        int a=arr[++i];
        arr[i]=arr[j];
        arr[j]=a ;
      }
    }
    int a=arr[i+1];
    arr[i+1]=arr[r];
    arr[r]=a ;
    return i+1 ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    int index=partition(arr,0,n-1);
    for(int i=0 ; i<n ; i++){
      if(i==index){
        System.out.print("["+arr[i]+"] ");
      }
      else if(i==n-1){
        System.out.println(arr[i]);
      }
      else {
        System.out.print(arr[i]+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation partition( arr : Sequence(int), p : int, r : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := arr[r+1] ;
     var i : int ; i := p - 1 ;
        var j : int ; j := p ; while j < r do ( (     if (arr[j+1] <= x) then (     var a : int ;     i := i + 1 ;
a := arr[i+1] ;
     arr[i+1] := arr[j+1] ; 
     arr[j+1] := a ) else skip )  ;     j := j + 1 ) ; 
    var a : int ; a := arr[i + 1+1] ;
    arr[i + 1+1] := arr[r+1] ; 
    arr[r+1] := a ; 
    return i + 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var index : int ; index := partition(arr, 0, n - 1) ;
        var i : int ; i := 0 ; while i < n do ( (     if (i = index) then (     OclFile["System.out"].print("[" + arr[i+1] + "] ") ) else     if (i = n - 1) then (     OclFile["System.out"].println(arr[i+1]) ) else (     OclFile["System.out"].print(arr[i+1] + " ") ) ;  )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class Main {
  static int count=0 ;
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(bf.readLine());
    ArrayList<Integer>array=new ArrayList<Integer>();
    String[] list=bf.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      array.add(Integer.parseInt(list[i]));
    }
    int q=partition(array,0,array.size()-1);
    for(int i=0 ; i<array.size(); i++){
      if(i!=0){
        System.out.printf(" ");
      }
      if(i==q){
        System.out.printf("[");
      }
      System.out.printf("%d",array.get(i));
      if(i==q){
        System.out.printf("] ");
      }
    }
    System.out.println("");
  }
  public static int partition(ArrayList<Integer>array,int p,int r){
    int x=array.get(r);
    int i=p-1 ;
    for(int j=p ; j<r ; j++){
      if(array.get(j)<=x){
        i++;
        int tmp=array.get(i);
        array.set(i,array.get(j));
        array.set(j,tmp);
      }
    }
    int tmp=array.get(i+1);
    array.set(i+1,array.get(r));
    array.set(r,tmp);
    return i+1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute count : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (bf.readLine())->toInteger() ;
    var array : Sequence(int) ; array := Sequence{} ;
    var list : Sequence(String) ; list := bf.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < n do ( (     array := array->including((list[i+1])->toInteger()) )  ;     i := i + 1 ) ; 
    var q : int ; q := partition(array, 0, array->size() - 1) ;
        var i : int ; i := 0 ; while i < array->size() do ( (     if (i /= 0) then (     OclFile["System.out"].printf(" ") ) else skip ; 
     if (i = q) then (     OclFile["System.out"].printf("[") ) else skip ; 
     OclFile["System.out"].printf("%d", array->at(i+1)) ; 
     if (i = q) then (     OclFile["System.out"].printf("] ") ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
 );
  static   operation partition( array : Sequence(int), p : int, r : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := array->at(r+1) ;
     var i : int ; i := p - 1 ;
        var j : int ; j := p ; while j < r do ( (     if (array->at(j+1) <= x) then (     i := i + 1 ; 
     var tmp : int ; tmp := array->at(i+1) ;
     array := array.setAt(i+1,array->at(j+1)) ; 
     array := array.setAt(j+1,tmp) ) else skip )  ;     j := j + 1 ) ; 
    var tmp : int ; tmp := array->at(i + 1+1) ;
    array := array.setAt(i + 1+1,array->at(r+1)) ; 
    array := array.setAt(r+1,tmp) ; 
    return i + 1 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static int partition(int[] array,int p,int r){
    int pivot=array[r];
    int i=p-1 ;
    int j=p ;
    while(j<r){
      if(array[j]<=pivot){
        i++;
        swap(array,i,j);
      }
      j++;
    }
    swap(array,i+1,r);
    return i+1 ;
  }
  private static void swap(int[] array,int i,int j){
    int tmp=array[j];
    array[j]=array[i];
    array[i]=tmp ;
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String str=scan.next();
    int N=Integer.valueOf(str);
    int[] array=new int[N];
    for(int i=0 ; i<N ; i++){
      array[i]=scan.nextInt();
    }
    int part=partition(array,0,array.length-1);
    StringBuilder builder=new StringBuilder();
    for(int i=0 ; i<N ; i++){
      if(i==part){
        builder.append("["+array[i]+"] ");
      }
      else {
        builder.append(array[i]);
      }
      builder.append(" ");
    }
    System.out.println(builder.toString().trim());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation partition( array : Sequence(int), p : int, r : int) : int
  pre: true
  post: true
  activity: (     var pivot : int ; pivot := array[r+1] ;
     var i : int ; i := p - 1 ;
    var j : int ; j := p ;
    while (j < r) do (     if (array[j+1] <= pivot) then (     i := i + 1 ; 
     execute swap(array, i, j) ) else skip ; 
     j := j + 1 ) ; 
    execute swap(array, i + 1, r) ; 
    return i + 1 
 );
  static   operation swap( array : Sequence(int), i : int, j : int) : void
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := array[j+1] ;
     array[j+1] := array[i+1] ; 
     array[i+1] := tmp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := scan.getCurrent() ;
    var N : int ; N := (str)->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     array[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var part : int ; part := partition(array, 0, array->size() - 1) ;
    var builder : String ; builder := StringLib.newString() ;
        var i : int ; i := 0 ; while i < N do ( (     if (i = part) then (     builder := builder + StringLib.newString("[" + array[i+1] + "] ") ) else (     builder := builder + StringLib.newString(array[i+1]) ) ;  
     builder := builder + StringLib.newString(" ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(builder+""->trim()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.regex.Pattern ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  public void run(){
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      int n=Integer.parseInt(br.readLine());
      final Pattern delim=Pattern.compile(" ");
      int[] seq=delim.splitAsStream(br.readLine()).mapToInt(Integer :: parseInt).toArray();
      int q=partition(seq,0,n-1);
      dispIntArrayPartition(seq,q);
    }
    catch(IOException e){
      System.out.println("IOException!");
    }
  }
  public int partition(int[] seq,int p,int r){
    int x=seq[r];
    int i=p-1 ;
    int t ;
    for(int j=p ; j<r ; j++){
      if(seq[j]<=x){
        t=seq[++i];
        seq[i]=seq[j];
        seq[j]=t ;
      }
    }
    t=seq[i+1];
    seq[i+1]=seq[r];
    seq[r]=t ;
    return i+1 ;
  }
  public void dispIntArrayPartition(int[] target,int q){
    StringBuilder s=new StringBuilder();
    int l=target.length-1 ;
    for(int i=0 ; i<q ; i++){
      s.append(target[i]).append(" ");
    }
    s.append("[").append(target[q]).append("] ");
    for(int i=q+1 ; i<l ; i++){
      s.append(target[i]).append(" ");
    }
    s.append(target[l]);
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var n : int ; n := (br.readLine())->toInteger() ;
     var delim : OclRegex ; delim := OclRegex.compile(" ") ;
    var seq : Sequence(int) ; seq := delim.splitAsStream(br.readLine())->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var q : int ; q := partition(seq, 0, n - 1) ;
    execute dispIntArrayPartition(seq, q) ; 
 ))   catch (e : IOException) do (     OclFile["System.out"].println("IOException!") )
  );
   operation partition( seq : Sequence(int), p : int, r : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := seq[r+1] ;
     var i : int ; i := p - 1 ;
    var t : int ;
        var j : int ; j := p ; while j < r do ( (     if (seq[j+1] <= x) then (         i := i + 1 ;
 t := seq[i+1]  ; 
     seq[i+1] := seq[j+1] ; 
     seq[j+1] := t ) else skip )  ;     j := j + 1 ) ; 
    t := seq[i + 1+1] ; 
    seq[i + 1+1] := seq[r+1] ; 
    seq[r+1] := t ; 
    return i + 1 
 );
   operation dispIntArrayPartition( target : Sequence(int), q : int) : void
  pre: true
  post: true
  activity: (     var s : String ; s := StringLib.newString() ;
     var l : int ; l := target->size() - 1 ;
        var i : int ; i := 0 ; while i < q do ( (     s := s + StringLib.newString(target[i+1]) + StringLib.newString(" ") )  ;     i := i + 1 ) ; 
    s := s + StringLib.newString("[") + StringLib.newString(target[q+1]) + StringLib.newString("] ") ; 
        var i : int ; i := q + 1 ; while i < l do ( (     s := s + StringLib.newString(target[i+1]) + StringLib.newString(" ") )  ;     i := i + 1 ) ; 
    s := s + StringLib.newString(target[l+1]) ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    long[][][] dp=new long[100+2][10][1000+2];
    dp[0][0][0]=1 ;
    for(int i=0 ; i<=100 ; i++)for(int j=0 ; j<10 ; j++)for(int k=0 ; k<=1000 ; k++){
      dp[i+1][j][k]+=dp[i][j][k];
      if(j==9)continue ;
      if(i+k<=1000)dp[i+1][j+1][k+i]+=dp[i][j][k];
    }
    for(; ; ){
      int n=sc.nextInt(),s=sc.nextInt();
      if((n | s)==0)break ;
      System.out.println(dp[101][n][s]);
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dp : Sequence(Sequence(Sequence(long))) ; dp := Integer.subrange(1,100 + 2)->collect(Integer.subrange(1,10)->collect(Integer.subrange(1,1000 + 2)->collect(0))) ;
    dp[0+1][0+1][0+1] := 1 ; 
        var i : int ; i := 0 ; while i <= 100 do (         var j : int ; j := 0 ; while j < 10 do (         var k : int ; k := 0 ; while k <= 1000 do ( (     dp[i + 1+1][j+1][k+1] := dp[i + 1+1][j+1][k+1]+(dp[i+1][j+1][k+1]) ; 
     if (j = 9) then     continue else skip ; 
     if (i + k <= 1000) then     dp[i + 1+1][j + 1+1][k + i+1] := dp[i + 1+1][j + 1+1][k + i+1]+(dp[i+1][j+1][k+1]) ; else skip )  ;     k := k + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
      while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseOr(n,s)) = 0) then     break else skip ; 
     OclFile["System.out"].println(dp[101+1][n+1][s+1]) )  ) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n,s ;
      n=parseInt(line.substring(0,line.indexOf(' ')));
      s=parseInt(line.substring(line.indexOf(' ')+1));
      if((n | s)==0)return ;
      long[][][] dp=new long[101][n+1][s+1];
      dp[0][0][0]=1 ;
      dp[0][1][0]=1 ;
      for(int i=1 ; i<=100 ; i++){
        for(int j=1 ; j<=n ; j++){
          for(int k=i ; k<=s ; k++){
            for(int l=0 ; l<i ; l++){
              dp[i][j][k]+=dp[l][j-1][k-i];
            }
          }
        }
      }
      long ans=0 ;
      for(int i=0 ; i<=100 ; i++){
        ans+=dp[i][n][s];
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ;
    var s : int ;
     n := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    s := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    if ((MathLib.bitwiseOr(n,s)) = 0) then     return else skip ; 
    var dp : Sequence(Sequence(Sequence(long))) ; dp := Integer.subrange(1,101)->collect(Integer.subrange(1,n + 1)->collect(Integer.subrange(1,s + 1)->collect(0))) ;
    dp[0+1][0+1][0+1] := 1 ; 
    dp[0+1][1+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= 100 do ( (         var j : int ; j := 1 ; while j <= n do ( (         var k : int ; k := i ; while k <= s do ( (         var l : int ; l := 0 ; while l < i do ( (     dp[i+1][j+1][k+1] := dp[i+1][j+1][k+1]+(dp[l+1][j - 1+1][k - i+1]) )  ;     l := l + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i <= 100 do ( (     ans := ans+(dp[i+1][n+1][s+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean solve(){
    int n=in.nextInt();
    int s=in.nextInt();
    if(n+s==0)return false ;
    out.println(rec(n,-1,s));
    return true ;
  }
  static long[][][] dp=new long[10][101][1001];
  static long rec(int n,int x,int s){
    if(n==0 && s==0)return 1 ;
    if(n==0)return 0 ;
    if(x!=-1 && dp[n][x][s]!=-1)return dp[n][x][s];
    long res=0 ;
    for(int i=x+1 ; i<=100 ; i++){
      if(s-i>=0){
        res+=rec(n-1,i,s-i);
      }
    }
    if(x==-1)return res ;
    return dp[n][x][s]=res ;
  }
  public static void main(String[] args){
    long start=System.currentTimeMillis();
    for(int i=0 ; i<10 ; i++){
      for(int j=0 ; j<101 ; j++){
        Arrays.fill(dp[i][j],-1);
      }
    }
    while(solve());
    out.flush();
    long end=System.currentTimeMillis();
    in.close();
    out.close();
  }
  static void trace(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   operation solve() : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var s : int ; s := in.getCurrent()->toInteger() ;
    if (n + s = 0) then     return false else skip ; 
    skip ; 
    return true 
 );
  static   attribute dp : Sequence(Sequence(Sequence(long))) := Integer.subrange(1,10)->collect(Integer.subrange(1,101)->collect(Integer.subrange(1,1001)->collect(0)));
  static   operation rec( n : int, x : int, s : int) : long
  pre: true
  post: true
  activity: (     if (n = 0 & s = 0) then     return 1 else skip ; 
     if (n = 0) then     return 0 else skip ; 
    if (x /= -1 & dp[n+1][x+1][s+1] /= -1) then     return dp[n+1][x+1][s+1] else skip ; 
    var res : long ; res := 0 ;
        var i : int ; i := x + 1 ; while i <= 100 do ( (     if (s - i >= 0) then (     res := res+(rec(n - 1, i, s - i)) ) else skip )  ;     i := i + 1 ) ; 
    if (x = -1) then     return res else skip ; 
    return dp[n+1][x+1][s+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : long ; start := OclDate.getSystemTime() ;
         var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < 101 do ( (     dp[i+1][j+1] := dp[i+1][j+1]->collect(-1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    while (solve()) do  ; 
    skip ; 
    var end : long ; end := OclDate.getSystemTime() ;
    skip ; 
    skip ; 
 );
  static   operation trace( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    long[][] allData=new long[10][1001];
    allData[0][0]=1 ;
    for(int iRang=0 ; iRang<=100 ; iRang++){
      for(int iSum=1000 ; iSum>=0 ; iSum--){
        for(int item=9 ; item>=1 ; item--){
          if(iSum-iRang>=0)allData[item][iSum]+=allData[item-1][iSum-iRang];
        }
      }
    }
    Scanner input=new Scanner(System.in);
    while(input.hasNext()){
      String[] nAnds=input.nextLine().split(" ");
      int valueN=Integer.parseInt(nAnds[0]);
      int valueS=Integer.parseInt(nAnds[1]);
      if(valueN!=0 || valueS!=0){
        System.out.printf("%d\n",allData[valueN][valueS]);
      }
      else {
        break ;
      }
    }
    input.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var allData : Sequence(Sequence(long)) ; allData := Integer.subrange(1,10)->collect(Integer.subrange(1,1001)->collect(0)) ;
     allData[0+1][0+1] := 1 ; 
        var iRang : int ; iRang := 0 ; while iRang <= 100 do ( (         var iSum : int ; iSum := 1000 ; while iSum >= 0 do ( (         var item : int ; item := 9 ; while item >= 1 do ( (     if (iSum - iRang >= 0) then     allData[item+1][iSum+1] := allData[item+1][iSum+1]+(allData[item - 1+1][iSum - iRang+1]) ; else skip )  ;     item := item - 1 ) )  ;     iSum := iSum - 1 ) )  ;     iRang := iRang + 1 ) ; 
    var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (input.hasNext()) do (     var nAnds : Sequence(String) ; nAnds := input.nextLine()->split(" ") ;
     var valueN : int ; valueN := (nAnds[0+1])->toInteger() ;
     var valueS : int ; valueS := (nAnds[1+1])->toInteger() ;
     if (valueN /= 0 or valueS /= 0) then (     OclFile["System.out"].printf("%d\n", allData[valueN+1][valueS+1]) ) else (     break ) ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    StringTokenizer st ;
    st=new StringTokenizer(br.readLine());
    int n,d,x ;
    n=parseInt(st.nextToken());
    d=parseInt(st.nextToken());
    x=parseInt(st.nextToken());
    int[][] price=new int[d][n];
    for(int i=0 ; i<d ; i++){
      st=new StringTokenizer(br.readLine());
      for(int j=0 ; j<n ; j++){
        price[i][j]=parseInt(st.nextToken());
      }
    }
    for(int i=0 ; i<d-1 ; i++){
      int[] dp=new int[x+1];
      for(int j=0 ; j<=x ; j++){
        dp[j]=j ;
      }
      for(int j=0 ; j<n ; j++){
        for(int k=0 ; k<=x ; k++){
          if(k>=price[i][j]){
            dp[k]=Math.max(dp[k],dp[k-price[i][j] ]+price[i+1][j]);
          }
        }
      }
      x=dp[x];
    }
    System.out.println(x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var st : OclIterator ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    var n : int ;
    var d : int ;
    var x : int ;
    n := (st.next() + "")->toInteger() ; 
    d := (st.next() + "")->toInteger() ; 
    x := (st.next() + "")->toInteger() ; 
    var price : Sequence(Sequence(int)) ; price := Integer.subrange(1,d)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < d do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
         var j : int ; j := 0 ; while j < n do ( (     price[i+1][j+1] := (st.next() + "")->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < d - 1 do ( (     var dp : Sequence(int) ; dp := Integer.subrange(1,x + 1)->collect(0) ;
         var j : int ; j := 0 ; while j <= x do ( (     dp[j+1] := j )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < n do ( (         var k : int ; k := 0 ; while k <= x do ( (     if (k >= price[i+1][j+1]) then (     dp[k+1] := Set{dp[k+1], dp[k - price[i+1][j+1]+1] + price[i + 1+1][j+1]}->max() ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
     x := dp[x+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(x) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  Scanner sc ;
  int k,q ;
  int[] d,dm ;
  long[] e ;
  void calc(){
    sc=new Scanner(System.in);
    k=sc.nextInt();
    q=sc.nextInt();
    d=new int[k];
    dm=new int[k];
    e=new long[k];
    for(int i=0 ; i<k ; i++){
      d[i]=sc.nextInt();
    }
    for(int i=0 ; i<q ; i++){
      int n=sc.nextInt();
      int x=sc.nextInt();
      int m=sc.nextInt();
      dm[0]=d[0] % m ;
      e[0]=dm[0]+((dm[0]==0)? m : 0);
      for(int j=1 ; j<k ; j++){
        dm[j]=d[j] % m ;
        e[j]=e[j-1]+dm[j];
        if(e[j]==e[j-1])e[j]+=m ;
      }
      long sum=(x % m)+e[k-1]*((n-2)/k)+e[(n-2)% k];
      long c=sum/m ;
      System.out.println(n-1-c);
    }
  }
  public static void main(String[] args){
    new Main().calc();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute k : int;
   attribute d : Sequence(int);
   attribute e : Sequence(long);
   operation calc() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     k := sc.getCurrent()->toInteger() ; 
    q := sc.getCurrent()->toInteger() ; 
    d := Integer.subrange(1,k)->collect(0) ; 
    dm := Integer.subrange(1,k)->collect(0) ; 
    e := Integer.subrange(1,k)->collect(0) ; 
        var i : int ; i := 0 ; while i < k do ( (     d[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    dm[0+1] := d[0+1] mod m ; 
    e[0+1] := dm[0+1] + (if (dm[0+1] = 0) then m else 0 endif) ; 
        var j : int ; j := 1 ; while j < k do ( (     dm[j+1] := d[j+1] mod m ; 
     e[j+1] := e[j - 1+1] + dm[j+1] ; 
     if (e[j+1] = e[j - 1+1]) then     e[j+1] := e[j+1]+(m) ; else skip )  ;     j := j + 1 ) ; 
    var sum : long ; sum := (x mod m) + e[k - 1+1] * ((n - 2) / k) + e[(n - 2) mod k+1] ;
    var c : long ; c := sum / m ;
    OclFile["System.out"].println(n - 1 - c) ; 
 )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().calc() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  private static void solve(){
    final Scanner scanner=new Scanner(System.in);
    final int t=scanner.nextInt();
    for(int i=0 ; i<t ; i++){
      final int n=scanner.nextInt();
      final int k=scanner.nextInt();
      final int[] distances=new int[n-1];
      int previous=scanner.nextInt();
      for(int j=0 ; j<n-1 ; j++){
        final int current=scanner.nextInt();
        distances[j]=current-previous ;
        previous=current ;
      }
      Arrays.sort(distances);
      int total=0 ;
      for(int j=0 ; j<n-k ; j++){
        total+=distances[j];
      }
      System.out.println(total);
    }
  }
  public static void main(String...args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var k : int ; k := scanner.getCurrent()->toInteger() ;
    var distances : Sequence(int) ; distances := Integer.subrange(1,n - 1)->collect(0) ;
    var previous : int ; previous := scanner.getCurrent()->toInteger() ;
        var j : int ; j := 0 ; while j < n - 1 do ( (     var current : int ; current := scanner.getCurrent()->toInteger() ;
     distances[j+1] := current - previous ; 
     previous := current )  ;     j := j + 1 ) ; 
    distances := distances->sort() ; 
    var total : int ; total := 0 ;
        var j : int ; j := 0 ; while j < n - k do ( (     total := total+(distances[j+1]) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    try {
      System.setIn(new FileInputStream("src/aoj2104/input.txt"));
    }
    catch(FileNotFoundException e){
    }
    new Main().run();
  }
  Scanner sc ;
  void run(){
    sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0){
      long ans=solve();
      System.out.println(ans);
    }
  }
  long solve(){
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] x=new int[n];
    for(int i=0 ; i<n ; i++)x[i]=sc.nextInt();
    if(n==1){
      return 0 ;
    }
    int[] d=new int[n-1];
    for(int i=1 ; i<n ; i++)d[i-1]=x[i]-x[i-1];
    Arrays.sort(d);
    long res=0 ;
    for(int i=0 ; i+k-1<d.length ; i++){
      res+=d[i];
    }
    return res ;
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("src/aoj2104/input.txt"))) )   catch (e : FileNotFoundException) do skip
     Main.newMain().run() );
   attribute sc : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var T : int ; T := sc.getCurrent()->toInteger() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     var ans : long ; ans := solve() ;
     OclFile["System.out"].println(ans) ) ;  ) );
   operation solve() : long
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     x[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    if (n = 1) then (     return 0 ) else skip ; 
    var d : Sequence(int) ; d := Integer.subrange(1,n - 1)->collect(0) ;
        var i : int ; i := 1 ; while i < n do (     d[i - 1+1] := x[i+1] - x[i - 1+1] ;  ;     i := i + 1 ) ; 
    d := d->sort() ; 
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i + k - 1 < d->size() do ( (     res := res+(d[i+1]) )  ;     i := i + 1 ) ; 
    return res 
 );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    for(int i=0 ; i<t ; i++){
      String[] tmpArray=br.readLine().split(" ");
      int n=Integer.parseInt(tmpArray[0]);
      int k=Integer.parseInt(tmpArray[1]);
      int pos[]=new int[n];
      tmpArray=br.readLine().split(" ");
      for(int j=0 ; j<n ; j++){
        pos[j]=Integer.parseInt(tmpArray[j]);
      }
      System.out.println(solve(pos,k));
    }
  }
  static int solve(int[] pos,int k){
    int n=pos.length ;
    House[] houses=new House[n];
    for(int i=0 ; i<n ; i++){
      houses[i]=new House(i,pos[i]);
      if(i!=0){
        houses[i] .dist=houses[i] .x-houses[i-1] .x ;
      }
    }
    Arrays.sort(houses);
    int result=pos[n-1]-pos[0];
    int tmp=0 ;
    for(int i=n-1 ; i>0 && tmp<k-1 ; i--){
      result-=houses[i] .dist ;
      tmp++;
    }
    return result ;
  }
}
class House implements Comparable<House>{
  int x ;
  int id ;
  int dist ;
  public House(int id,int x){
    this.id=id ;
    this.x=x ;
    this.dist=0 ;
  }
  @ Override public int compareTo(House h){
    return(this.dist-h.dist);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
     var n : int ; n := (tmpArray[0+1])->toInteger() ;
    var k : int ; k := (tmpArray[1+1])->toInteger() ;
    var pos : Sequence(int) ; pos := Integer.subrange(1,n)->collect(0) ;
    tmpArray := br.readLine()->split(" ") ; 
        var j : int ; j := 0 ; while j < n do ( (     pos[j+1] := (tmpArray[j+1])->toInteger() )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(solve(pos, k)) ; 
 )  ;     i := i + 1 ) );
  static   operation solve( pos : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := pos->size() ;
     var houses : Sequence(House) ; houses := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     houses[i+1] := House.newHouse(i, pos[i+1]) ; 
     if (i /= 0) then (     houses[i+1].dist := houses[i+1].x - houses[i - 1+1].x ) else skip )  ;     i := i + 1 ) ; 
    houses := houses->sort() ; 
    var result : int ; result := pos[n - 1+1] - pos[0+1] ;
    var tmp : int ; tmp := 0 ;
        var i : int ; i := n - 1 ; while i > 0 & tmp < k - 1 do ( (     result := result-(houses[i+1].dist) ; 
     tmp := tmp + 1 )  ;     i := i - 1 ) ; 
    return result 
 );
}
class House implements Comparable<House> {
   attribute x : int;
   attribute id : int;
   attribute dist : int;
   static operation newHouse( id : int, x : int) : House
  pre: true
  post: true
  activity:
  ( var self : House ;
    self := createHouse();
    self.initialise(id, x);
    return self );
  operation initialise( id : int, x : int) : void
  pre: true  post: true
  activity: (     self.id := id ; 
     self.x := x ; 
     self.dist := 0 );
      operation compareTo( h : House) : int
  pre: true
  post: true
  activity: (     return (self.dist - h.dist) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import org.omg.PortableInterceptor.SYSTEM_EXCEPTION ;
import java.io.*;
import java.util.*;
public class Main {
  void run(){
    int T=readInt();
    for(int t=0 ; t<T ; t++){
      int N=readInt();
      int K=readInt();
      int[] X=new int[N];
      for(int i=0 ; i<N ; i++){
        X[i]=readInt();
      }
      int sum=0 ;
      int[] Y=new int[N-1];
      for(int i=0 ; i<N-1 ; i++){
        Y[i]=X[i+1]-X[i];
        sum+=Y[i];
      }
      Arrays.sort(Y);
      for(int i=0 ; i<Math.min(N,K)-1 ; i++){
        sum-=Y[Y.length-1-i];
      }
      sysout.println(sum);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  PrintWriter sysout=new PrintWriter(System.out,true);
  BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer buffer=new StringTokenizer("");
  String read(){
    if(! buffer.hasMoreTokens()){
      try {
        buffer=new StringTokenizer(in.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return buffer.nextToken();
  }
  int readInt(){
    return Integer.parseInt(read());
  }
  long readLong(){
    return Long.parseLong(read());
  }
  double readDouble(){
    return Double.parseDouble(read());
  }
  String readLine(){
    buffer=new StringTokenizer("");
    try {
      return in.readLine();
    }
    catch(IOException e){
      throw new RuntimeException(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var T : int ; T := readInt() ;
         var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := readInt() ;
     var K : int ; K := readInt() ;
    var X : Sequence(int) ; X := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     X[i+1] := readInt() )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var Y : Sequence(int) ; Y := Integer.subrange(1,N - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     Y[i+1] := X[i + 1+1] - X[i+1] ; 
     sum := sum+(Y[i+1]) )  ;     i := i + 1 ) ; 
    Y := Y->sort() ; 
        var i : int ; i := 0 ; while i < Set{N, K}->min() - 1 do ( (     sum := sum-(Y[Y->size() - 1 - i+1]) )  ;     i := i + 1 ) ; 
    sysout.println(sum) ; 
 )  ;     t := t + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute sysout : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], true);
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute buffer : OclIterator := OclIterator.newOclIterator_String("");
   operation read() : String
  pre: true
  post: true
  activity: (     if (not(buffer.hasNext())) then (     try (     buffer := OclIterator.newOclIterator_String(in.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return buffer.next() );
   operation readInt() : int
  pre: true
  post: true
  activity: (     return (read())->toInteger() );
   operation readLong() : long
  pre: true
  post: true
  activity: (     return (read())->toLong() );
   operation readDouble() : double
  pre: true
  post: true
  activity: (     return (read())->toReal() );
   operation readLine() : String
  pre: true
  post: true
  activity: (     buffer := OclIterator.newOclIterator_String("") ; 
     try (     return in.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    int d=parseInt(br.readLine());
    for(int i=0 ; i<d ; i++){
      line=br.readLine();
      int n=parseInt(line.substring(0,line.indexOf(' ')));
      int k=parseInt(line.substring(line.indexOf(' ')+1));
      line=br.readLine();
      StringTokenizer st=new StringTokenizer(line);
      int max=parseInt(line.substring(line.lastIndexOf(' ')+1));
      int min=parseInt(st.nextToken());
      int maxLength=max-min ;
      int[] count=new int[max+1];
      int[] distance=new int[n-1];
      int next ;
      while(st.hasMoreTokens()){
        next=parseInt(st.nextToken());
        count[next-min]++;
        min=next ;
      }
      for(int j=count.length-1,l=distance.length-1 ; l>=0 ; j--){
        if(count[j]>0){
          distance[l]=j ;
          count[j]--;
          j++;
          l--;
        }
      }
      for(int j=distance.length-1 ; k>1 && j>=0 ; j--){
        maxLength-=distance[j];
        k--;
      }
      System.out.println(maxLength);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var d : int ; d := parseInt(br.readLine()) ;
         var i : int ; i := 0 ; while i < d do ( (     line := br.readLine() ; 
     var n : int ; n := parseInt(line.subrange(0+1,line->indexOf(' ')-1)) ;
    var k : int ; k := parseInt(line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1)) ;
    line := br.readLine() ; 
    var st : OclIterator ; st := OclIterator.newOclIterator_String(line) ;
    var max : int ; max := parseInt(line.subrange(line->lastIndexOf(' ')-1 + 1+1,line->lastIndexOf(' ')-1 + 1)) ;
    var min : int ; min := parseInt(st.next()) ;
    var maxLength : int ; maxLength := max - min ;
    var count : Sequence(int) ; count := Integer.subrange(1,max + 1)->collect(0) ;
    var distance : Sequence(int) ; distance := Integer.subrange(1,n - 1)->collect(0) ;
    var next : int ;
    while (st.hasNext()) do (     next := (st.next() + "")->toInteger() ; 
     count[next - min+1] := count[next - min+1] + 1 ; 
     min := next ) ; 
        var j : int ; j := count->size() - 1 ;
    var l : int ; l := distance->size() - 1 ; while l >= 0 do ( (     if (count[j+1] > 0) then (     distance[l+1] := j ; 
     count[j+1] := count[j+1] - 1 ; 
     j := j + 1 ; 
     l := l - 1 ) else skip )  ;     j := j - 1 ) ; 
        var j : int ; j := distance->size() - 1 ; while k > 1 & j >= 0 do ( (     maxLength := maxLength-(distance[j+1]) ; 
     k := k - 1 )  ;     j := j - 1 ) ; 
    OclFile["System.out"].println(maxLength) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Sequences {
  static int getTotalNumberOfSequences(int m,int n){
    int T[][]=new int[m+1][n+1];
    for(int i=0 ; i<m+1 ; i++){
      for(int j=0 ; j<n+1 ; j++){
        if(i==0 || j==0)T[i][j]=0 ;
        else if(i<j)T[i][j]=0 ;
        else if(j==1)T[i][j]=i ;
        else T[i][j]=T[i-1][j]+T[i/2][j-1];
      }
    }
    return T[m][n];
  }
  public static void main(String[] args){
    int m=10 ;
    int n=4 ;
    System.out.println("Total number of possible sequences "+getTotalNumberOfSequences(m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class Sequences {
  static   operation getTotalNumberOfSequences( m : int, n : int) : int
  pre: true
  post: true
  activity: (     var T : Sequence(Sequence(int)) ; T := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i < m + 1 do ( (         var j : int ; j := 0 ; while j < n + 1 do ( (     if (i = 0 or j = 0) then     T[i+1][j+1] := 0 ; else     if (i < j) then     T[i+1][j+1] := 0 else     if (j = 1) then     T[i+1][j+1] := i else     T[i+1][j+1] := T[i - 1+1][j+1] + T[i / 2+1][j - 1+1] ; ;  ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return T[m+1][n+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 10 ;
     var n : int ; n := 4 ;
     OclFile["System.out"].println("Total number of possible sequences " + getTotalNumberOfSequences(m, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF37B extends PrintWriter {
  CF37B(){
    super(System.out);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    CF37B o=new CF37B();
    o.main();
    o.flush();
  }
  void main(){
    int n=sc.nextInt();
    int max=sc.nextInt();
    int reg=sc.nextInt();
    int[] pow=new int[n];
    int[] dmg=new int[n];
    int damage=0 ;
    for(int i=0 ; i<n ; i++){
      pow[i]=sc.nextInt();
      dmg[i]=sc.nextInt();
      if(pow[i]==100)damage+=dmg[i];
    }
    if(damage<=reg){
      println("NO");
      return ;
    }
    boolean[] used=new boolean[n];
    int[] tt=new int[n];
    int[] ii=new int[n];
    int t=0,k=0 ;
    int health=max ;
    damage=0 ;
    while(health>0){
      int i_=-1 ;
      for(int i=0 ; i<n ; i++)if(! used[i] && pow[i]*max>=health*100 &&(i_==-1 || dmg[i_]<dmg[i]))i_=i ;
      if(i_!=-1){
        used[i_]=true ;
        damage+=dmg[i_];
        tt[k]=t ;
        ii[k]=i_ ;
        k++;
      }
      t++;
      health-=damage ;
      health+=reg ;
      if(health>max)health=max ;
    }
    println("YES");
    println(t+" "+k);
    for(int h=0 ; h<k ; h++)println(tt[h]+" "+(ii[h]+1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF37B extends OclFile {
   static operation newCF37B() : CF37B
  pre: true
  post: true
  activity:
  ( var self : CF37B ;
    self := createCF37B();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"]) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : CF37B ; o := CF37B.newCF37B() ;
     o.main() ; 
     o.flush() );
   operation main() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var max : int ; max := sc.getCurrent()->toInteger() ;
    var reg : int ; reg := sc.getCurrent()->toInteger() ;
    var pow : Sequence(int) ; pow := Integer.subrange(1,n)->collect(0) ;
    var dmg : Sequence(int) ; dmg := Integer.subrange(1,n)->collect(0) ;
    var damage : int ; damage := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     pow[i+1] := sc.getCurrent()->toInteger() ; 
     dmg[i+1] := sc.getCurrent()->toInteger() ; 
     if (pow[i+1] = 100) then     damage := damage+(dmg[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    if (damage <= reg) then (     execute println("NO") ; 
     return ) else skip ; 
    var used : Sequence(boolean) ; used := Integer.subrange(1,n)->collect(false) ;
    var tt : Sequence(int) ; tt := Integer.subrange(1,n)->collect(0) ;
    var ii : Sequence(int) ; ii := Integer.subrange(1,n)->collect(0) ;
    var t : int ; t := 0 ;
    var k : int ; k := 0 ;
    var health : int ; health := max ;
    damage := 0 ; 
    while (health > 0) do (     var i_ : int ; i_ := -1 ;
         var i : int ; i := 0 ; while i < n do (     if (not(used[i+1]) & pow[i+1] * max >= health * 100 & (i_ = -1 or dmg[i_+1] < dmg[i+1])) then     i_ := i ; else skip ;  ;     i := i + 1 ) ; 
    if (i_ /= -1) then (     used[i_+1] := true ; 
     damage := damage+(dmg[i_+1]) ; 
    tt[k+1] := t ; 
    ii[k+1] := i_ ; 
    k := k + 1 ; 
 ) else skip ; 
    t := t + 1 ; 
    health := health-(damage) ; 
    health := health+(reg) ; 
    if (health > max) then     health := max ; else skip ; 
 ) ; 
    execute println("YES") ; 
    execute println(t + " " + k) ; 
        var h : int ; h := 0 ; while h < k do (     execute println(tt[h+1] + " " + (ii[h+1] + 1)) ;  ;     h := h + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void series(int A,int X,int n){
    int term=(int)Math.pow(A,n);
    System.out.print(term+" ");
    for(int i=1 ; i<=n ; i++){
      term=term*X*(n-i+1)/(i*A);
      System.out.print(term+" ");
    }
  }
  public static void main(String[] args){
    int A=3,X=4,n=5 ;
    series(A,X,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation series( A : int, X : int, n : int) : void
  pre: true
  post: true
  activity: (     var term : int ; term := A->pow(n)->oclAsType(int) ;
     OclFile["System.out"].print(term + " ") ; 
         var i : int ; i := 1 ; while i <= n do ( (     term := term * X * (n - i + 1) / (i * A) ; 
     OclFile["System.out"].print(term + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 3 ;
    var X : int ; X := 4 ;
    var n : int ; n := 5 ;
     execute series(A, X, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int factorial(int n){
    int fact=1 ;
    for(int i=2 ; i<=n ; i++)fact=fact*i ;
    return(fact);
  }
  static int result(int n,int m){
    return(factorial(n)-factorial(n-m+1)*factorial(m));
  }
  public static void main(String args[]){
    System.out.println(result(5,3));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation factorial( n : int) : int
  pre: true
  post: true
  activity: (     var fact : int ; fact := 1 ;
         var i : int ; i := 2 ; while i <= n do (     fact := fact * i ;  ;     i := i + 1 ) ; 
     return (fact) );
  static   operation result( n : int, m : int) : int
  pre: true
  post: true
  activity: (     return (factorial(n) - factorial(n - m + 1) * factorial(m)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(result(5, 3)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    InvestMaster solver=new InvestMaster();
    solver.solve(1,in,out);
    out.close();
  }
  static class InvestMaster {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      final int MAX=(int)1e5+10 ;
      int n=in.nextInt();
      int d=in.nextInt();
      int x=in.nextInt();
      int[][] p=new int[d][n];
      for(int i=0 ; i<d ; i++){
        for(int j=0 ; j<n ; j++){
          p[i][j]=in.nextInt();
        }
      }
      int[] dp=new int[MAX];
      for(int i=0 ; i<d-1 ; i++){
        Arrays.fill(dp,0);
        for(int j=0 ; j<x+1 ; j++){
          dp[j]=j ;
        }
        for(int j=0 ; j<n ; j++){
          for(int k=0 ; k<x+1 ; k++){
            if(k-p[i][j]>=0){
              dp[k]=Math.max(dp[k],dp[k-p[i][j] ]+p[i+1][j]);
            }
          }
        }
        int buf=0 ;
        for(int j=0 ; j<x+1 ; j++){
          buf=Math.max(buf,dp[j]);
        }
        x=buf ;
      }
      out.println(x);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : InvestMaster ; solver := InvestMaster.newInvestMaster() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class InvestMaster {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var MAX : int ; MAX := 1e5->oclAsType(int) + 10 ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
    var p : Sequence(Sequence(int)) ; p := Integer.subrange(1,d)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < d do ( (         var j : int ; j := 0 ; while j < n do ( (     p[i+1][j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,MAX)->collect(0) ;
        var i : int ; i := 0 ; while i < d - 1 do ( (     dp := dp->collect(0) ; 
         var j : int ; j := 0 ; while j < x + 1 do ( (     dp[j+1] := j )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (         var k : int ; k := 0 ; while k < x + 1 do ( (     if (k - p[i+1][j+1] >= 0) then (     dp[k+1] := Set{dp[k+1], dp[k - p[i+1][j+1]+1] + p[i + 1+1][j+1]}->max() ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    var buf : int ; buf := 0 ;
        var j : int ; j := 0 ; while j < x + 1 do ( (     buf := Set{buf, dp[j+1]}->max() )  ;     j := j + 1 ) ; 
    x := buf ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Vector<Integer>primeFactors(int n){
    int i,j ;
    Vector<Integer>Prime=new Vector<Integer>();
    if(n % 2==0){
      Prime.add(2);
    }
    while(n % 2==0){
      n=n/2 ;
    }
    for(i=3 ; i<=Math.sqrt(n); i=i+2){
      if(n % i==0){
        Prime.add(i);
      }
      while(n % i==0){
        n=n/i ;
      }
    }
    if(n>2){
      Prime.add(n);
    }
    return Prime ;
  }
  static void checkDistinctPrime(int n){
    Vector<Integer>Prime=primeFactors(n);
    int product=1 ;
    for(int i : Prime){
      product*=i ;
    }
    if(product==n)System.out.print("YES");
    else System.out.print("NO");
  }
  public static void main(String[] args){
    int N=30 ;
    checkDistinctPrime(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation primeFactors( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var Prime : Sequence(int) ; Prime := Sequence{} ;
    if (n mod 2 = 0) then (     Prime := Prime->including(2) ) else skip ; 
    while (n mod 2 = 0) do (     n := n / 2 ) ; 
        i := 3 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     Prime := Prime->including(i) ) else skip ; 
     while (n mod i = 0) do (     n := n / i ) )  ;     i := i + 2 ) ; 
    if (n > 2) then (     Prime := Prime->including(n) ) else skip ; 
    return Prime 
 );
  static   operation checkDistinctPrime( n : int) : void
  pre: true
  post: true
  activity: (     var Prime : Sequence(int) ; Prime := primeFactors(n) ;
     var product : int ; product := 1 ;
     for (i : Prime) do ( (     product := product*(i) )  ) ; 
     if (product = n) then     OclFile["System.out"].print("YES") ; else     OclFile["System.out"].print("NO") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 30 ;
     execute checkDistinctPrime(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class ProblemA {
  static HashSet<Character>set[];
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    String line[]=br.readLine().split(" ");
    int n=Integer.parseInt(line[0]);
    int x=Integer.parseInt(line[1]);
    int y=Integer.parseInt(line[2]);
    String s=br.readLine();
    int st=n-y ;
    int count=s.charAt(st-1)=='0' ? 1 : 0 ;
    for(int i=st ; i<n ; i++)count+=(s.charAt(i)-'0');
    for(int i=n-x ; i<st-1 ; i++)count+=(s.charAt(i)-'0');
    System.out.println(count);
  }
}
class Pair {
  int x,y ;
  public Pair(int x,int y){
    this.x=x ;
    this.y=y ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
  static   attribute set : Sequence(Set(String));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var n : int ; n := (line[0+1])->toInteger() ;
    var x : int ; x := (line[1+1])->toInteger() ;
    var y : int ; y := (line[2+1])->toInteger() ;
    var s : String ; s := br.readLine() ;
    var st : int ; st := (n)->char2byte() - y ;
    var count : int ; count := if s->at((st)->char2byte() - 1+1) = '0' then 1 else 0 endif ;
        var i : int ; i := st ; while i < n do (     count := count+((s->at(i+1) - ('0')->char2byte())) ;  ;     i := i + 1 ) ; 
        var i : int ; i := (n)->char2byte() - x ; while i < (st)->char2byte() - 1 do (     count := count+((s->at(i+1) - ('0')->char2byte())) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}
class Pair {
   attribute x : int;
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  static long MOD=1000000007 ;
  static BigInteger BMOD=new BigInteger(Long.toString(MOD));
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    int q=sc.nextInt();
    long[] d=new long[k];
    for(int i=0 ; i<k ; i++){
      d[i]=sc.nextLong();
    }
    long[] n=new long[q];
    long[] x=new long[q];
    long[] m=new long[q];
    for(int j=0 ; j<q ; j++){
      n[j]=sc.nextLong();
      x[j]=sc.nextLong();
      m[j]=sc.nextLong();
    }
    for(int j=0 ; j<q ; j++){
      long[] pcnt=new long[k+1];
      long[] psum=new long[k+1];
      psum[0]=0 ;
      pcnt[0]=0 ;
      for(int i=0 ; i<k ; i++){
        long dd=d[i] % m[j];
        psum[i+1]=psum[i]+dd ;
        if(dd>0){
          pcnt[i+1]=pcnt[i]+1 ;
        }
        else {
          pcnt[i+1]=pcnt[i];
        }
      }
      long goal=(x[j] % m[j])+psum[k]*((n[j]-1)/k)+psum[(int)((n[j]-1)% k)];
      System.out.println(pcnt[k]*((n[j]-1)/k)+pcnt[(int)((n[j]-1)% k)]-goal/m[j]+(x[j] % m[j])/m[j]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : long := 1000000007;
  static   attribute BMOD : long := long(((MOD) + ""));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var d : Sequence(long) ; d := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     d[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var n : Sequence(long) ; n := Integer.subrange(1,q)->collect(0) ;
    var x : Sequence(long) ; x := Integer.subrange(1,q)->collect(0) ;
    var m : Sequence(long) ; m := Integer.subrange(1,q)->collect(0) ;
        var j : int ; j := 0 ; while j < q do ( (     n[j+1] := sc.getCurrent()->toLong() ; 
     x[j+1] := sc.getCurrent()->toLong() ; 
     m[j+1] := sc.getCurrent()->toLong() )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < q do ( (     var pcnt : Sequence(long) ; pcnt := Integer.subrange(1,k + 1)->collect(0) ;
     var psum : Sequence(long) ; psum := Integer.subrange(1,k + 1)->collect(0) ;
    psum[0+1] := 0 ; 
    pcnt[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < k do ( (     var dd : long ; dd := d[i+1] mod m[j+1] ;
     psum[i + 1+1] := psum[i+1] + dd ; 
     if (dd > 0) then (     pcnt[i + 1+1] := pcnt[i+1] + 1 ) else (     pcnt[i + 1+1] := pcnt[i+1] ) )  ;     i := i + 1 ) ; 
    var goal : long ; goal := (x[j+1] mod m[j+1]) + psum[k+1] * ((n[j+1] - 1) / k) + psum[((n[j+1] - 1) mod k)->oclAsType(int)+1] ;
    OclFile["System.out"].println(pcnt[k+1] * ((n[j+1] - 1) / k) + pcnt[((n[j+1] - 1) mod k)->oclAsType(int)+1] - goal / m[j+1] + (x[j+1] mod m[j+1]) / m[j+1]) ; 
 )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double minRevolutions(double r,int x1,int y1,int x2,int y2){
    double d=Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
    return Math.ceil(d/(2*r));
  }
  public static void main(String arg[]){
    int r=2,x1=0,y1=0 ;
    int x2=0,y2=4 ;
    System.out.print((int)minRevolutions(r,x1,y1,x2,y2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minRevolutions( r : double, x1 : int, y1 : int, x2 : int, y2 : int) : double
  pre: true
  post: true
  activity: (     var d : double ; d := ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))->sqrt() ;
     return (d / (2 * r))->ceil() );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : int ; r := 2 ;
    var x1 : int ; x1 := 0 ;
    var y1 : int ; y1 := 0 ;
     var x2 : int ; x2 := 0 ;
    var y2 : int ; y2 := 4 ;
     OclFile["System.out"].print(minRevolutions(r, x1, y1, x2, y2)->oclAsType(int)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int isVowel(char ch){
    ch=Character.toUpperCase(ch);
    if(ch=='A' || ch=='E' || ch=='I' || ch=='O' || ch=='U')return 1 ;
    else return 0 ;
  }
  static int countVowels(String str,int n){
    if(n==1)return isVowel(str.charAt(n-1));
    return countVowels(str,n-1)+isVowel(str.charAt(n-1));
  }
  public static void main(String args[]){
    String str="abc de" ;
    System.out.println(countVowels(str,str.length()));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isVowel( ch : String) : int
  pre: true
  post: true
  activity: (     ch := (ch + "")->toUpperCase() ; 
     if (ch = 'A' or ch = 'E' or ch = 'I' or ch = 'O' or ch = 'U') then     return 1 else     return 0 );
  static   operation countVowels( str : String, n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return isVowel(str->at(n - 1+1)) else skip ; 
     return countVowels(str, n - 1) + isVowel(str->at(n - 1+1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abc de" ;
     OclFile["System.out"].println(countVowels(str, str->size())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class A {
  private void solve()throws IOException {
    String s=next();
    int b=0 ;
    int c=0 ;
    int lb=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='('){
        b++;
      }
      else if(s.charAt(i)==')'){
        b--;
      }
      else {
        b--;
        c++;
        lb=b ;
      }
      lb=Math.min(b,lb);
      if(b<0){
        out.println(-1);
        return ;
      }
    }
    if(lb-b<0){
      out.println(-1);
      return ;
    }
    for(int i=0 ; i<c-1 ; i++){
      out.println(1);
    }
    out.println(1+b);
  }
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer st ;
  PrintWriter out=new PrintWriter(System.out);
  String next()throws IOException {
    while(st==null || ! st.hasMoreTokens()){
      st=new StringTokenizer(br.readLine());
    }
    return st.nextToken();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public static void main(String[] args)throws IOException {
    new A().run();
  }
  private void run()throws IOException {
    solve();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   operation solve() : void
  pre: true
  post: true
  activity: (     var s : String ; s := next() ;
     var b : int ; b := 0 ;
    var c : int ; c := 0 ;
    var lb : int ; lb := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '(') then (     b := b + 1 ) else     if (s->at(i+1) = ')') then (     b := b - 1 ) else (     b := b - 1 ; 
     c := c + 1 ; 
     lb := b ) ;  ;  
     lb := Set{b, lb}->min() ; 
     if (b < 0) then (     out.println(-1) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    if (lb - (b)->char2byte() < 0) then (     out.println(-1) ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < c - 1 do ( (     out.println(1) )  ;     i := i + 1 ) ; 
    out.println(1 + b) ; 
 );
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator;
   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     A.newA().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     execute solve() ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class A {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter writer=new PrintWriter(new OutputStreamWriter(System.out));
    char[] str=reader.readLine().toCharArray();
    int n=str.length ;
    int[] cnt=new int[n];
    if(str[0]=='(')cnt[0]=1 ;
    else cnt[0]=-1 ;
    for(int i=1 ; i<n ; i++){
      cnt[i]=cnt[i-1];
      if(str[i]=='(')cnt[i]++;
      else cnt[i]--;
    }
    boolean ok=true ;
    for(int i=0 ; i<n ; i++)if(cnt[i]<0){
      ok=false ;
      break ;
    }
    int extra=cnt[n-1];
    if(! ok){
      writer.println(-1);
    }
    else {
      int lastIDX=n ;
      for(int i=n-1 ; i>=0 ; i--){
        if(str[i]=='#'){
          lastIDX=i ;
          cnt[i]-=extra ;
          for(int j=i+1 ; j<n ; j++){
            cnt[j]=cnt[j-1];
            if(str[j]=='(')cnt[j]++;
            else cnt[j]--;
          }
          break ;
        }
      }
      for(int i=0 ; i<n ; i++)if(cnt[i]<0){
        ok=false ;
        break ;
      }
      if(! ok){
        writer.println(-1);
      }
      else {
        for(int i=0 ; i<n ; i++)if(str[i]=='#'){
          if(i==lastIDX)writer.println(1+extra);
          else writer.println(1);
        }
      }
    }
    writer.flush();
    writer.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var str : Sequence(String) ; str := reader.readLine()->characters() ;
    var n : int ; n := str->size() ;
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,n)->collect(0) ;
    if (str[0+1] = '(') then     cnt[0+1] := 1 else     cnt[0+1] := -1 ; ;  
        var i : int ; i := 1 ; while i < n do ( (     cnt[i+1] := cnt[i - 1+1] ; 
     if (str[i+1] = '(') then     cnt[i+1] := cnt[i+1] + 1 ; else     cnt[i+1] := cnt[i+1] - 1 ; )  ;     i := i + 1 ) ; 
    var ok : boolean ; ok := true ;
        var i : int ; i := 0 ; while i < n do (     if (cnt[i+1] < 0) then (     ok := false ; 
     break ) else skip ;  ;     i := i + 1 ) ; 
    var extra : int ; extra := cnt[n - 1+1] ;
    if (not(ok)) then (     skip ) else (     var lastIDX : int ; lastIDX := n ;
         var i : int ; i := n - 1 ; while i >= 0 do ( (     if (str[i+1] = '#') then (     lastIDX := i ; 
     cnt[i+1] := cnt[i+1]-(extra) ; 
         var j : int ; j := i + 1 ; while j < n do ( (     cnt[j+1] := cnt[j - 1+1] ; 
     if (str[j+1] = '(') then     cnt[j+1] := cnt[j+1] + 1 ; else     cnt[j+1] := cnt[j+1] - 1 ; )  ;     j := j + 1 ) ; 
     break ) else skip )  ;     i := i - 1 ) ; 
         var i : int ; i := 0 ; while i < n do (     if (cnt[i+1] < 0) then (     ok := false ; 
     break ) else skip ;  ;     i := i + 1 ) ; 
     if (not(ok)) then (     skip ) else (         var i : int ; i := 0 ; while i < n do (     if (str[i+1] = '#') then (     if (i = lastIDX) then     skip ; else     skip ; ) else skip ;  ;     i := i + 1 ) ) ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int d=0,minD=0x3f3f3f3f,cnt=0 ;
    for(char ch : s.toCharArray()){
      if(ch=='('){
        d++;
        continue ;
      }
      d--;
      if(d<0){
        System.out.println(-1);
        return ;
      }
      if(ch=='#'){
        cnt++;
        minD=d ;
      }
      else if(d<minD){
        minD=d ;
      }
    }
    if(minD<d){
      System.out.println(-1);
    }
    else {
      for(int i=0 ; i<cnt-1 ; i++){
        System.out.println(1);
      }
      System.out.println(d+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var d : int ; d := 0 ;
    var minD : int ; minD := 0x3f3f3f3f ;
    var cnt : int ; cnt := 0 ;
    for (ch : s->characters()) do ( (     if (ch = '(') then (     d := d + 1 ; 
     continue ) else skip ; 
     d := d - 1 ; 
     if (d < 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
     if (ch = '#') then (     cnt := cnt + 1 ; 
     minD := d ) else     if (d < minD) then (     minD := d ) else skip ; )  ) ; 
    if (minD < d) then (     OclFile["System.out"].println(-1) ) else (         var i : int ; i := 0 ; while i < (cnt)->char2byte() - 1 do ( (     OclFile["System.out"].println(1) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(d + 1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Java {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int radiusOfPizza=sc.nextInt();
    int sizeOfCrust=sc.nextInt();
    int noOfSausages=sc.nextInt();
    int counter=0 ;
    for(int i=0 ; i<noOfSausages ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      int r=sc.nextInt();
      double distance=Math.sqrt((x*x)+(y*y));
      double totalDistance1=(distance-r);
      double totalDistance2=(distance+r);
      if(totalDistance1>=radiusOfPizza-sizeOfCrust){
        if(totalDistance2<=radiusOfPizza){
          counter++;
        }
      }
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Java {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var radiusOfPizza : int ; radiusOfPizza := sc.getCurrent()->toInteger() ;
    var sizeOfCrust : int ; sizeOfCrust := sc.getCurrent()->toInteger() ;
    var noOfSausages : int ; noOfSausages := sc.getCurrent()->toInteger() ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < noOfSausages do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var distance : double ; distance := ((x * x) + (y * y))->sqrt() ;
    var totalDistance1 : double ; totalDistance1 := (distance - r) ;
    var totalDistance2 : double ; totalDistance2 := (distance + r) ;
    if (totalDistance1 >= radiusOfPizza - sizeOfCrust) then (     if (totalDistance2 <= radiusOfPizza) then (     counter := counter + 1 ) else skip ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Gleb {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int r=sc.nextInt();
    int d=sc.nextInt();
    int n=sc.nextInt();
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int xi=sc.nextInt();
      int yi=sc.nextInt();
      int ri=sc.nextInt();
      double xx=Math.sqrt(xi*xi+yi*yi);
      if(xx+ri<=r){
        if(xx-ri>=r-d)count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Gleb {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var xi : int ; xi := sc.getCurrent()->toInteger() ;
     var yi : int ; yi := sc.getCurrent()->toInteger() ;
    var ri : int ; ri := sc.getCurrent()->toInteger() ;
    var xx : double ; xx := (xi * xi + yi * yi)->sqrt() ;
    if (xx + ri <= r) then (     if (xx - ri >= r - d) then     count := count + 1 ; else skip ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int d=sc.nextInt();
    int x=sc.nextInt();
    int dp[][];
    int[][] p=new int[d+1][n+1];
    for(int day=1 ; day<=d ; day++){
      for(int stockNum=1 ; stockNum<=n ; stockNum++){
        p[day][stockNum]=sc.nextInt();
      }
    }
    for(int day=1 ; day<=d-1 ; day++){
      dp=new int[n+1][x+1];
      for(int i=1 ; i<=n ; i++){
        for(int j=1 ; j<=x ; j++){
          if(j<p[day][i]){
            dp[i][j]=dp[i-1][j];
          }
          else {
            dp[i][j]=Math.max(dp[i-1][j],dp[i][j-p[day][i] ]+p[day+1][i]-p[day][i]);
          }
        }
      }
      x+=dp[n][x];
    }
    System.out.println(x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var dp : Sequence(Sequence(int)) ;
    var p : Sequence(Sequence(int)) ; p := Integer.subrange(1,d + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var day : int ; day := 1 ; while day <= d do ( (         var stockNum : int ; stockNum := 1 ; while stockNum <= n do ( (     p[day+1][stockNum+1] := sc.getCurrent()->toInteger() )  ;     stockNum := stockNum + 1 ) )  ;     day := day + 1 ) ; 
        var day : int ; day := 1 ; while day <= d - 1 do ( (     dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,x + 1)->collect(0)) ; 
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= x do ( (     if (j < p[day+1][i+1]) then (     dp[i+1][j+1] := dp[i - 1+1][j+1] ) else (     dp[i+1][j+1] := Set{dp[i - 1+1][j+1], dp[i+1][j - p[day+1][i+1]+1] + p[day + 1+1][i+1] - p[day+1][i+1]}->max() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     x := x+(dp[n+1][x+1]) )  ;     day := day + 1 ) ; 
    OclFile["System.out"].println(x) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static BufferedReader br ;
  static PrintWriter out ;
  static StringTokenizer st=new StringTokenizer("");
  static int T=1 ;
  public static void main(String[] args)throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    for(int tt=1 ; tt<=T ; tt++){
      int r=nexti(),d=nexti(),n=nexti();
      int ans=0 ;
      for(int i=0 ; i<n ; i++){
        int x=nexti(),y=nexti(),sr=nexti();
        boolean b=Math.pow(x,2)+Math.pow(y,2)<=Math.pow(r-sr,2);
        boolean bb=Math.pow(x,2)+Math.pow(y,2)>=Math.pow(r-d+sr,2);
        if(b && bb && 2*sr<=d)++ans ;
      }
      out.println(ans);
    }
    br.close();
    out.close();
  }
  static String next()throws IOException {
    while(! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  static int nexti()throws IOException {
    return Integer.parseInt(next());
  }
  static long nextl()throws IOException {
    return Long.parseLong(next());
  }
  static double nextd()throws IOException {
    return Double.parseDouble(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile;
  static   attribute out : OclFile;
  static   attribute st : OclIterator := OclIterator.newOclIterator_String("");
  static   attribute T : int := 1;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ; 
        var tt : int ; tt := 1 ; while tt <= T do ( (     var r : int ; r := nexti() ;
    var d : int ; d := nexti() ;
    var n : int ; n := nexti() ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := nexti() ;
    var y : int ; y := nexti() ;
    var sr : int ; sr := nexti() ;
     var b : boolean ; b := x->pow(2) + y->pow(2) <= r - sr->pow(2) ;
     var bb : boolean ; bb := x->pow(2) + y->pow(2) >= r - d + sr->pow(2) ;
     if (b & bb & 2 * sr <= d) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
     skip )  ;     tt := tt + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
  static   operation nexti() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextl() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nextd() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import java.io.*;
public class Hello {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int r=in.nextInt();
    int d=in.nextInt();
    int n=in.nextInt();
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int x=in.nextInt();
      int y=in.nextInt();
      int tempR=in.nextInt();
      double dist=Math.sqrt(x*x+y*y);
      if(r-d<=dist-tempR && dist+tempR<=r)count++;
    }
    pw.println(count);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hello {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var r : int ; r := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var y : int ; y := in.getCurrent()->toInteger() ;
    var tempR : int ; tempR := in.getCurrent()->toInteger() ;
    var dist : double ; dist := (x * x + y * y)->sqrt() ;
    if (r - d <= dist - tempR & dist + tempR <= r) then     count := count + 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double distance(int x1,int y1,int x2,int y2){
    return Math.sqrt(Math.pow(x2-x1,2)+Math.pow(y2-y1,2)*1.0);
  }
  public static void main(String[] args){
    System.out.println(Math.round(distance(3,4,4,3)*100000.0)/100000.0);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation distance( x1 : int, y1 : int, x2 : int, y2 : int) : double
  pre: true
  post: true
  activity: (     return (x2 - x1->pow(2) + y2 - y1->pow(2) * 1.0)->sqrt() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((distance(3, 4, 4, 3) * 100000.0)->round() / 100000.0) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class PermuteString {
  final static int MAX_CHAR=26 ;
  final static int MAX_FACT=20 ;
  static long fact[]=new long[MAX_FACT];
  static void precomputeFactorirals(){
    fact[0]=1 ;
    for(int i=1 ; i<MAX_FACT ; i++)fact[i]=fact[i-1]*i ;
  }
  static void nPermute(String str,int n){
    precomputeFactorirals();
    int len=str.length();
    int freq[]=new int[MAX_CHAR];
    for(int i=0 ; i<len ; i++)freq[str.charAt(i)-'a']++;
    String out="" ;
    int sum=10 ;
    int k=0 ;
    while(sum>=n){
      for(int i=0 ; i<MAX_CHAR ; i++){
        if(freq[i]==0)continue ;
        freq[i]--;
        sum=0 ;
        int xsum=(int)fact[len-1-k];
        for(int j=0 ; j<MAX_CHAR ; j++)xsum/=fact[freq[j] ];
        sum+=xsum ;
        if(sum>=n){
          out+=(char)(i+'a');
          k++;
          n-=(sum-xsum);
          break ;
        }
        if(sum<n)freq[i]++;
      }
    }
    for(int i=MAX_CHAR-1 ; k<len && i>=0 ; i--)if(freq[i]!=0){
      out+=(char)(i+'a');
      freq[i++]--;
    }
    System.out.println(out);
  }
  public static void main(String[] args){
    int n=2 ;
    String str="geeksquiz" ;
    nPermute(str,n);
  }
}
------------------------------------------------------------
OCL File:
---------
class PermuteString {
  static   attribute MAX_CHAR : int := 26;
  static   attribute MAX_FACT : int := 20;
  static   attribute fact : long := Integer.subrange(1,MAX_FACT)->collect(0);
  static   operation precomputeFactorirals() : void
  pre: true
  post: true
  activity: (     fact[0+1] := 1 ; 
         var i : int ; i := 1 ; while i < MAX_FACT do (     fact[i+1] := fact[i - 1+1] * i ;  ;     i := i + 1 ) );
  static   operation nPermute( str : String, n : int) : void
  pre: true
  post: true
  activity: (     execute precomputeFactorirals() ; 
     var len : int ; len := str->size() ;
    var freq : Sequence(int) ; freq := Integer.subrange(1,MAX_CHAR)->collect(0) ;
        var i : int ; i := 0 ; while i < len do (     freq[str->at(i+1) - ('a')->char2byte()+1] := freq[str->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    var out : String ; out := "" ;
    var sum : int ; sum := 10 ;
    var k : int ; k := 0 ;
    while (sum >= n) do (         var i : int ; i := 0 ; while i < MAX_CHAR do ( (     if (freq[i+1] = 0) then     continue else skip ; 
     freq[i+1] := freq[i+1] - 1 ; 
    sum := 0 ; 
    var xsum : int ; xsum := fact[len - 1 - k+1]->oclAsType(int) ;
        var j : int ; j := 0 ; while j < MAX_CHAR do (     xsum := xsum/(fact[freq[j+1]+1]) ;  ;     j := j + 1 ) ; 
    sum := sum+(xsum) ; 
    if (sum >= n) then (     out := out+((i + 'a')->oclAsType(String)) ; 
     k := k + 1 ; 
     n := n-(((sum)->char2byte() - xsum)) ; 
     break ) else skip ; 
    if (sum < n) then     freq[i+1] := freq[i+1] + 1 ; else skip ; 
 )  ;     i := i + 1 ) ) ; 
        var i : int ; i := MAX_CHAR - 1 ; while k < len & i >= 0 do (     if (freq[i+1] /= 0) then (     out := out+((i + 'a')->oclAsType(String)) ; 
     freq[i+1] := freq[i+1] - 1 ) else skip ;  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(out) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     var str : String ; str := "geeksquiz" ;
     execute nPermute(str, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      int r=scan.nextInt();
      int c=scan.nextInt();
      if(r==0)break ;
      Senb s=new Senb(r,c);
      for(int i=0 ; i<r ; i++)for(int j=0 ; j<c ; j++)s.add(i,j,scan.nextInt());
      System.out.println(s.answer());
    }
    scan.close();
    System.exit(0);
  }
}
class Senb {
  private int[] senb ;
  private int R,C ;
  public Senb(int r,int c){
    R=r ;
    C=c ;
    senb=new int[C];
  }
  public int answer(){
    int to=(1<<R);
    int max=0 ;
    for(int i=0 ; i<to ; i++){
      max=Math.max(this.testR(i),max);
    }
    return max ;
  }
  private int testR(int pat){
    int tot=0 ;
    for(int i=0 ; i<C ; i++){
      int n=Integer.bitCount(senb[i] ^ pat);
      tot+=Math.max(n,R-n);
    }
    return tot ;
  }
  public void add(int r,int c,int f){
    if(f==1)senb[c] |=(1<<r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var r : int ; r := scan.getCurrent()->toInteger() ;
     var c : int ; c := scan.getCurrent()->toInteger() ;
    if (r = 0) then     break else skip ; 
    var s : Senb ; s := Senb.newSenb(r, c) ;
        var i : int ; i := 0 ; while i < r do (         var j : int ; j := 0 ; while j < c do (     s->excludes(i, j, scan.getCurrent()->toInteger()) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s.answer()) ; 
 ) ; 
     skip ; 
 OclProcess.exit(0) );
}
class Senb {
   attribute senb : Sequence(int);
   attribute R : int;
   static operation newSenb( r : int, c : int) : Senb
  pre: true
  post: true
  activity:
  ( var self : Senb ;
    self := createSenb();
    self.initialise(r, c);
    return self );
  operation initialise( r : int, c : int) : void
  pre: true  post: true
  activity: (     R := r ; 
     C := c ; 
     senb := Integer.subrange(1,C)->collect(0) );
   operation answer() : int
  pre: true
  post: true
  activity: (     var to : int ; to := ((1*(2->pow(R)))->oclAsType(long)) ;
     var max : int ; max := 0 ;
         var i : int ; i := 0 ; while i < to do ( (     max := Set{self.testR(i), max}->max() )  ;     i := i + 1 ) ; 
     return max );
   operation testR( pat : int) : int
  pre: true
  post: true
  activity: (     var tot : int ; tot := 0 ;
         var i : int ; i := 0 ; while i < C do ( (     var n : int ; n := bitCount(MathLib.bitwiseXor(senb[i+1],pat)) ;
     tot := tot+(Set{n, R - n}->max()) )  ;     i := i + 1 ) ; 
     return tot );
   operation add( r : int, c : int, f : int) : void
  pre: true
  post: true
  activity: (     if (f = 1) then     senb[c+1] := MathLib.bitwiseOr(senb[c+1], ((1*(2->pow(r)))->oclAsType(long))) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  int r,c ;
  boolean[][] map ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      r=sc.nextInt();
      c=sc.nextInt();
      if((r | c)==0)break ;
      map=new boolean[r][c];
      for(int i=0 ; i<r ; i++)for(int j=0 ; j<c ; j++){
        map[i][j]=sc.nextInt()==1 ;
      }
      int max=0 ;
      for(int i=1 ; i<1<<r ; i++){
        boolean[][] tmp=new boolean[r][c];
        for(int j=0 ; j<r ; j++)for(int k=0 ; k<c ; k++)tmp[j][k]=map[j][k];
        for(int j=0 ; j<r ; j++)if(((i>>j)& 1)==1){
          for(int k=0 ; k<c ; k++)tmp[j][k] ^=true ;
        }
        int sum=0 ;
        for(int j=0 ; j<c ; j++){
          int cnt=0 ;
          for(int k=0 ; k<r ; k++)if(tmp[k][j])cnt++;
          sum+=max(cnt,r-cnt);
        }
        max=max(max,sum);
      }
      System.out.println(max);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute r : int;
   attribute map : Sequence(Sequence(boolean));
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     r := sc.getCurrent()->toInteger() ; 
     c := sc.getCurrent()->toInteger() ; 
    if ((MathLib.bitwiseOr(r,c)) = 0) then     break else skip ; 
    map := Integer.subrange(1,r)->collect(Integer.subrange(1,c)->collect(false)) ; 
        var i : int ; i := 0 ; while i < r do (         var j : int ; j := 0 ; while j < c do ( (     map[i+1][j+1] := sc.getCurrent()->toInteger() = 1 )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i < (1*(2->pow(r)))->oclAsType(long) do ( (     var tmp : Sequence(Sequence(boolean)) ; tmp := Integer.subrange(1,r)->collect(Integer.subrange(1,c)->collect(false)) ;
         var j : int ; j := 0 ; while j < r do (         var k : int ; k := 0 ; while k < c do (     tmp[j+1][k+1] := map[j+1][k+1] ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < r do (     if ((((i/(2->pow(j)))->oclAsType(long)) & 1) = 1) then (         var k : int ; k := 0 ; while k < c do (     tmp[j+1][k+1] := MathLib.bitwiseXor(tmp[j+1][k+1],true) ;  ;     k := k + 1 ) ) else skip ;  ;     j := j + 1 ) ; 
    var sum : int ; sum := 0 ;
        var j : int ; j := 0 ; while j < c do ( (     var cnt : int ; cnt := 0 ;
         var k : int ; k := 0 ; while k < r do (     if (tmp[k+1][j+1]) then     cnt := cnt + 1 ; else skip ;  ;     k := k + 1 ) ; 
     sum := sum+(Set{cnt, r - cnt}->max()) )  ;     j := j + 1 ) ; 
    max := Set{max, sum}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static boolean debug=false ;
  private static int r ;
  private static int c ;
  private static int[][] senbeis ;
  private static int URA=0,OMOTE=1 ;
  @ SuppressWarnings("unused")private static void debug(String format,Object...objects){
    if(! debug)return ;
    System.out.format(format,objects);
  }
  public static int solve(){
    int ans=0 ;
    for(int trial=0 ; trial<(2<<r); trial++){
      int canSell=0 ;
      for(int x=0 ; x<c ; x++){
        int ura=0 ;
        for(int y=0 ; y<r ; y++){
          boolean reverses=((trial>>y)& 1)==0 ;
          int target=reverses ? URA : OMOTE ;
          ura+=(senbeis[y][x]==target)? 1 : 0 ;
        }
        canSell+=Math.max(ura,r-ura);
      }
      ans=Math.max(ans,canSell);
    }
    return ans ;
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    while(true){
      r=scanner.nextInt();
      c=scanner.nextInt();
      if(r==0 && c==0){
        break ;
      }
      senbeis=new int[r][c];
      for(int i=0 ; i<r ; i++){
        for(int j=0 ; j<c ; j++){
          senbeis[i][j]=scanner.nextInt();
        }
      }
      debug("===\n");
      debug("%d %d\n",r,c);
      for(int i=0 ; i<r ; i++){
        for(int j=0 ; j<c ; j++){
          debug("%d ",senbeis[i][j]);
        }
        debug("\n");
      }
      debug("===\n");
      System.out.format("%d\n",solve());
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute r : int;
  static   attribute c : int;
  static   attribute senbeis : Sequence(Sequence(int));
  static   attribute URA : int := 0;
   static   operation debug( format : String, objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (not(debug)) then     return else skip ; 
     OclFile["System.out"].format(format, objects) );
  static   operation solve() : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var trial : int ; trial := 0 ; while trial < ((2*(2->pow(r)))->oclAsType(long)) do ( (     var canSell : int ; canSell := 0 ;
         var x : int ; x := 0 ; while x < c do ( (     var ura : int ; ura := 0 ;
         var y : int ; y := 0 ; while y < r do ( (     var reverses : boolean ; reverses := (MathLib.bitwiseAnd(((trial/(2->pow(y)))->oclAsType(long)),1)) = 0 ;
     var target : int ; target := if reverses then URA else OMOTE endif ;
     ura := ura+(if (senbeis[y+1][x+1] = target) then 1 else 0 endif) )  ;     y := y + 1 ) ; 
     canSell := canSell+(Set{ura, r - ura}->max()) )  ;     x := x + 1 ) ; 
     ans := Set{ans, canSell}->max() )  ;     trial := trial + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     r := scanner.getCurrent()->toInteger() ; 
     c := scanner.getCurrent()->toInteger() ; 
    if (r = 0 & c = 0) then (     break ) else skip ; 
    senbeis := Integer.subrange(1,r)->collect(Integer.subrange(1,c)->collect(0)) ; 
        var i : int ; i := 0 ; while i < r do ( (         var j : int ; j := 0 ; while j < c do ( (     senbeis[i+1][j+1] := scanner.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    execute debug("===\n") ; 
    execute debug("%d %d\n", r, c) ; 
        var i : int ; i := 0 ; while i < r do ( (         var j : int ; j := 0 ; while j < c do ( (     execute debug("%d ", senbeis[i+1][j+1]) )  ;     j := j + 1 ) ; 
     execute debug("\n") )  ;     i := i + 1 ) ; 
    execute debug("===\n") ; 
    OclFile["System.out"].format("%d\n", solve()) ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      StringTokenizer st=new StringTokenizer(line);
      int R,C ;
      R=parseInt(st.nextToken());
      C=parseInt(st.nextToken());
      if((R | C)==0)break ;
      int[] CR=new int[C];
      for(int i=0 ; i<R ; i++){
        st=new StringTokenizer(br.readLine());
        for(int j=0 ; j<C ; j++){
          if(st.nextToken().equals("1"))CR[j] |=1<<i ;
        }
      }
      int max=0 ;
      for(int i=0 ; i<1<<R ; i++){
        int[] _CR=new int[C];
        for(int j=0 ; j<C ; j++){
          _CR[j]=CR[j];
        }
        int flip=0 ;
        for(int j=0 ; j<R ; j++){
          if((i>>j & 1)==1)flip |=1<<j ;
        }
        int count=0 ;
        for(int j=0 ; j<C ; j++){
          int bits=bits(_CR[j] ^ flip,R);
          count+=(bits>R-bits ? bits : R-bits);
        }
        max=Math.max(max,count);
      }
      System.out.println(max);
    }
  }
  static int bits(int b,int size){
    int ret=0 ;
    for(int i=0 ; i<size ; i++){
      if((b>>i & 1)==1)ret++;
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var st : OclIterator ; st := OclIterator.newOclIterator_String(line) ;
     var R : int ;
    var C : int ;
    R := (st.next() + "")->toInteger() ; 
    C := (st.next() + "")->toInteger() ; 
    if ((MathLib.bitwiseOr(R,C)) = 0) then     break else skip ; 
    var CR : Sequence(int) ; CR := Integer.subrange(1,C)->collect(0) ;
        var i : int ; i := 0 ; while i < R do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
         var j : int ; j := 0 ; while j < C do ( (     if (st.next() = "1") then     CR[j+1] := MathLib.bitwiseOr(CR[j+1], (1*(2->pow(i)))->oclAsType(long)) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < (1*(2->pow(R)))->oclAsType(long) do ( (     var _CR : Sequence(int) ; _CR := Integer.subrange(1,C)->collect(0) ;
         var j : int ; j := 0 ; while j < C do ( (     _CR[j+1] := CR[j+1] )  ;     j := j + 1 ) ; 
    var flip : int ; flip := 0 ;
        var j : int ; j := 0 ; while j < R do ( (     if ((MathLib.bitwiseAnd((i/(2->pow(j)))->oclAsType(long),1)) = 1) then     flip := MathLib.bitwiseOr(flip, (1*(2->pow(j)))->oclAsType(long)) ; else skip )  ;     j := j + 1 ) ; 
    var count : int ; count := 0 ;
        var j : int ; j := 0 ; while j < C do ( (     var bits : int ; bits := bits(_CR[j+1] xor flip, R) ;
     count := count+((if bits > R - bits then bits else R - bits endif)) )  ;     j := j + 1 ) ; 
    max := Set{max, count}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) ;     line := br.readLine() ;
 ) );
  static   operation bits( b : int, size : int) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
         var i : int ; i := 0 ; while i < size do ( (     if ((MathLib.bitwiseAnd((b/(2->pow(i)))->oclAsType(long),1)) = 1) then     ret := ret + 1 ; else skip )  ;     i := i + 1 ) ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int width,length ;
    int a[][];
    length=sc.nextInt();
    width=sc.nextInt();
    while(width+length!=0){
      a=new int[length][width];
      for(int i=0 ; i<length ; i++){
        for(int j=0 ; j<width ; j++){
          a[i][j]=sc.nextInt();
        }
      }
      System.out.println(f(a,width,length,0));
      length=sc.nextInt();
      width=sc.nextInt();
    }
  }
  public static int f(int a[][],int width,int length,int k){
    int line,sum=0 ;
    int max=0 ;
    int change ;
    if(length<=k){
      for(int i=0 ; i<width ; i++){
        line=0 ;
        for(int j=0 ; j<length ; j++){
          line+=a[j][i];
        }
        sum+=Math.max(line,length-line);
      }
      return sum ;
    }
    for(int i=0 ; i<width ; i++){
      a[k][i]=(a[k][i]+1)% 2 ;
    }
    change=f(a,width,length,k+1);
    for(int i=0 ; i<width ; i++){
      a[k][i]=(a[k][i]+1)% 2 ;
    }
    max=Math.max(change,f(a,width,length,k+1));
    return max ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var width : int ;
    var length : int ;
    var a : Sequence(Sequence(int)) ;
    length := sc.getCurrent()->toInteger() ; 
    width := sc.getCurrent()->toInteger() ; 
    while (width + length /= 0) do (     a := Integer.subrange(1,length)->collect(Integer.subrange(1,width)->collect(0)) ; 
         var i : int ; i := 0 ; while i < length do ( (         var j : int ; j := 0 ; while j < width do ( (     a[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(f(a, width, length, 0)) ; 
    length := sc.getCurrent()->toInteger() ; 
    width := sc.getCurrent()->toInteger() ; 
 ) ; 
 );
  static   operation f( a : Sequence(Sequence(int)), width : int, length : int, k : int) : int
  pre: true
  post: true
  activity: (     var line : int ;
    var sum : int ; sum := 0 ;
     var max : int ; max := 0 ;
    var change : int ;
    if (length <= k) then (         var i : int ; i := 0 ; while i < width do ( (     line := 0 ; 
         var j : int ; j := 0 ; while j < length do ( (     line := line+(a[j+1][i+1]) )  ;     j := j + 1 ) ; 
     sum := sum+(Set{line, length - line}->max()) )  ;     i := i + 1 ) ; 
     return sum ) else skip ; 
        var i : int ; i := 0 ; while i < width do ( (     a[k+1][i+1] := (a[k+1][i+1] + 1) mod 2 )  ;     i := i + 1 ) ; 
    change := f(a, width, length, k + 1) ; 
        var i : int ; i := 0 ; while i < width do ( (     a[k+1][i+1] := (a[k+1][i+1] + 1) mod 2 )  ;     i := i + 1 ) ; 
    max := Set{change, f(a, width, length, k + 1)}->max() ; 
    return max 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxSubArraySum(int a[],int size){
    int max_so_far=Integer.MIN_VALUE,max_ending_here=0 ;
    for(int i=0 ; i<size ; i++){
      max_ending_here=max_ending_here+a[i];
      if(max_so_far<max_ending_here)max_so_far=max_ending_here ;
      if(max_ending_here<0)max_ending_here=0 ;
    }
    return max_so_far ;
  }
  static int maximizeSum(int a[],int n){
    int cnt=0 ;
    int mini=Integer.MAX_VALUE ;
    int minSubarray=Integer.MAX_VALUE ;
    int sum=maxSubArraySum(a,n);
    int max_so_far=Integer.MIN_VALUE,max_ending_here=0 ;
    for(int i=0 ; i<n ; i++){
      max_ending_here=max_ending_here+a[i];
      cnt++;
      minSubarray=Math.min(a[i],minSubarray);
      if(sum==max_ending_here){
        if(cnt==1)mini=Math.min(mini,0);
        else mini=Math.min(mini,minSubarray);
      }
      if(max_ending_here<0){
        max_ending_here=0 ;
        cnt=0 ;
        minSubarray=Integer.MAX_VALUE ;
      }
    }
    return sum-mini ;
  }
  public static void main(String[] args){
    int a[]={
      1,2,3,-2,3 };
      int n=a.length ;
      System.out.println(maximizeSum(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxSubArraySum( a : Sequence(int), size : int) : int
  pre: true
  post: true
  activity: (     var max_so_far : int ; max_so_far := -2147483648 ;
    var max_ending_here : int ; max_ending_here := 0 ;
         var i : int ; i := 0 ; while i < size do ( (     max_ending_here := max_ending_here + a[i+1] ; 
     if (max_so_far < max_ending_here) then     max_so_far := max_ending_here ; else skip ; 
     if (max_ending_here < 0) then     max_ending_here := 0 ; else skip )  ;     i := i + 1 ) ; 
     return max_so_far );
  static   operation maximizeSum( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var mini : int ; mini := 2147483647 ;
    var minSubarray : int ; minSubarray := 2147483647 ;
    var sum : int ; sum := maxSubArraySum(a, n) ;
    var max_so_far : int ; max_so_far := -2147483648 ;
    var max_ending_here : int ; max_ending_here := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     max_ending_here := max_ending_here + a[i+1] ; 
     cnt := cnt + 1 ; 
    minSubarray := Set{a[i+1], minSubarray}->min() ; 
    if (sum = max_ending_here) then (     if (cnt = 1) then     mini := Set{mini, 0}->min() ; else     mini := Set{mini, minSubarray}->min() ; ) else skip ; 
    if (max_ending_here < 0) then (     max_ending_here := 0 ; 
     cnt := 0 ; 
     minSubarray := 2147483647 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    return sum - mini 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,-2,3} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(maximizeSum(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] $){
    long x=scanner.nextLong();
    long y=scanner.nextLong();
    System.out.println(Math.abs(x-y)>1 ? "Alice" : "Brown");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : long ; x := scanner.getCurrent()->toLong() ;
     var y : long ; y := scanner.getCurrent()->toLong() ;
     OclFile["System.out"].println(if if x - y < 0 then -(x - y) else x - y endif > 1 then "Alice" else "Brown" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    FastScanner in=new FastScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskD solver=new TaskD();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskD {
    public void solve(int testNumber,FastScanner in,PrintWriter out){
      long x=in.nextLong();
      long y=in.nextLong();
      out.println(Math.abs(x-y)>1 ? "Alice" : "Brown");
    }
  }
  static class FastScanner {
    private BufferedReader in ;
    private StringTokenizer st ;
    public FastScanner(InputStream stream){
      in=new BufferedReader(new InputStreamReader(stream));
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          String rl=in.readLine();
          if(rl==null){
            return null ;
          }
          st=new StringTokenizer(rl);
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : FastScanner ; in := FastScanner.newFastScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskD ; solver := TaskD.newTaskD() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskD {
   operation solve( testNumber : int, in : FastScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var x : long ; x := in.nextLong() ;
     var y : long ; y := in.nextLong() ;
     skip );
}
  static class FastScanner {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( stream : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     var rl : String ; rl := in.readLine() ;
     if (rl = null) then (     return null ) else skip ; 
     st := OclIterator.newOclIterator_String(rl) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=false ;
  private static PrintWriter _out=new PrintWriter(System.out);
  private static PrintWriter _err=new PrintWriter(System.err);
  private void solve(Scanner sc){
    long X=sc.nextLong();
    long Y=sc.nextLong();
    if(Math.abs(X-Y)<=1){
      _out.println("Brown");
    }
    else {
      _out.println("Alice");
    }
  }
  private static BigInteger C(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    for(long i=r ; i>1 ; --i){
      res=res.divide(BigInteger.valueOf(i));
    }
    return res ;
  }
  private static BigInteger P(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    return res ;
  }
  public static void main(String[] args){
    long S=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    new Main().solve(sc);
    _out.flush();
    long G=System.currentTimeMillis();
    if(elapsed){
      _err.println((G-S)+"ms");
    }
    _err.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := false;
  static   attribute _out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute _err : OclFile := OclFile.newOclFile_Write(OclFile["System.err"]);
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var X : long ; X := sc.nextLong() ;
     var Y : long ; Y := sc.nextLong() ;
     if (if X - Y < 0 then -(X - Y) else X - Y endif <= 1) then (     skip ) else (     skip ) );
  static   operation C( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
         var i : long ; i := r ; while i > 1 do ( (     res := res.divide((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation P( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    Main.newMain().solve(sc) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int minIncrementForUnique(int[] A){
    if(A.length==0)return 0 ;
    HashSet<Integer>numSet=new HashSet<>();
    List<Integer>duplicated=new ArrayList<>();
    int res=0 ;
    Arrays.sort(A);
    int left=A[0];
    int right=A[A.length-1];
    int holes=right-left+1 ;
    for(int v : A){
      if(numSet.contains(v))duplicated.add(v);
      else numSet.add(v);
    }
    holes-=numSet.size();
    for(int i=left+1 ; i<right ; i++){
      if(holes==0 || duplicated.size()==0)break ;
      if(! numSet.contains(i)&& i>duplicated.get(0)){
        res+=i-duplicated.get(0);
        holes--;
        duplicated.remove(0);
      }
    }
    if(duplicated.size()==0)return res ;
    while(duplicated.size()!=0){
      right+=1 ;
      res+=right-duplicated.get(0);
      duplicated.remove(0);
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation minIncrementForUnique( A : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (A->size() = 0) then     return 0 else skip ; 
     var numSet : Set(int) ; numSet := Set{} ;
    var duplicated : Sequence(int) ; duplicated := Sequence{} ;
    var res : int ; res := 0 ;
    A := A->sort() ; 
    var left : int ; left := A[0+1] ;
    var right : int ; right := A[A->size() - 1+1] ;
    var holes : int ; holes := right - left + 1 ;
    for (v : A) do ( (     if (numSet->includes(v)) then     duplicated := duplicated->including(v) ; else     numSet := numSet->including(v) ; )  ) ; 
    holes := holes-(numSet->size()) ; 
        var i : int ; i := left + 1 ; while i < right do ( (     if (holes = 0 or duplicated->size() = 0) then     break else skip ; 
     if (not(numSet->includes(i)) & i > duplicated->at(0+1)) then (     res := res+(i - duplicated->at(0+1)) ; 
     holes := holes - 1 ; 
     duplicated := duplicated->excludingAt(0+1) ) else skip )  ;     i := i + 1 ) ; 
    if (duplicated->size() = 0) then     return res else skip ; 
    while (duplicated->size() /= 0) do (     right := right+(1) ; 
     res := res+(right - duplicated->at(0+1)) ; 
     duplicated := duplicated->excludingAt(0+1) ) ; 
    return res 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    long x=sc.nextLong();
    long y=sc.nextLong();
    if(Math.max(x,y)-Math.min(x,y)<=1){
      out.println("Brown");
    }
    else {
      out.println("Alice");
    }
    out.close();
  }
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var x : long ; x := sc.nextLong() ;
    var y : long ; y := sc.nextLong() ;
    if (Set{x, y}->max() - Set{x, y}->min() <= 1) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int ni(){
    return cin.nextInt();
  }
  long nl(){
    return cin.nextLong();
  }
  String line(){
    return cin.nextLine();
  }
  void println(String str){
    System.out.println(str);
  }
  void print(String str){
    System.out.print(str);
  }
  static final int MOD=1000000007 ;
  Scanner cin=new Scanner(System.in);
  String output ;
  public static void main(String[] args){
    new Main().run();
  }
  public void run(){
    input();
    solve();
    println(output);
  }
  long X,Y ;
  void input(){
    X=nl();
    Y=nl();
  }
  void solve(){
    if(Math.abs(X-Y)<=1){
      output="Brown" ;
    }
    else {
      output="Alice" ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation ni() : int
  pre: true
  post: true
  activity: (     return cin.nextInt() );
   operation nl() : long
  pre: true
  post: true
  activity: (     return cin.nextLong() );
   operation line() : String
  pre: true
  post: true
  activity: (     return cin.nextLine() );
   operation println( str : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(str) );
   operation print( str : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(str) );
  static    attribute MOD : int := 1000000007;
   attribute cin : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute output : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     execute input() ; 
     execute solve() ; 
     execute println(output) );
   attribute X : long;
   operation input() : void
  pre: true
  post: true
  activity: (     X := nl() ; 
     Y := nl() );
   operation solve() : void
  pre: true
  post: true
  activity: (     if (if X - Y < 0 then -(X - Y) else X - Y endif <= 1) then (     output := "Brown" ) else (     output := "Alice" ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    while(true){
      int h=scan.nextInt();
      int w=scan.nextInt();
      if(h==0 && w==0){
        break ;
      }
      else if(3<=h && h<=300 && 3<=w && w<=300){
        for(int i=0 ; i<w ; i++){
          System.out.print("#");
        }
        System.out.println("");
        for(int j=0 ; j<h-2 ; j++){
          System.out.print("#");
          for(int k=0 ; k<w-2 ; k++){
            System.out.print(".");
          }
          System.out.println("#");
        }
        for(int l=0 ; l<w ; l++){
          System.out.print("#");
        }
        System.out.println("");
      }
      System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var h : int ; h := scan.getCurrent()->toInteger() ;
     var w : int ; w := scan.getCurrent()->toInteger() ;
     if (h = 0 & w = 0) then (     break ) else     if (3 <= h & h <= 300 & 3 <= w & w <= 300) then (         var i : int ; i := 0 ; while i < w do ( (     OclFile["System.out"].print("#") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("") ; 
        var j : int ; j := 0 ; while j < h - 2 do ( (     OclFile["System.out"].print("#") ; 
         var k : int ; k := 0 ; while k < w - 2 do ( (     OclFile["System.out"].print(".") )  ;     k := k + 1 ) ; 
     OclFile["System.out"].println("#") )  ;     j := j + 1 ) ; 
        var l : int ; l := 0 ; while l < w do ( (     OclFile["System.out"].print("#") )  ;     l := l + 1 ) ; 
    OclFile["System.out"].println("") ; 
 ) else skip ; ;  
     OclFile["System.out"].println("") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class Main {
  public static void main(String[] args)throws java.lang.Exception {
    String nl=System.getProperty("line.separator");
    StringBuilder p=new StringBuilder(500);
    StringBuilder d=new StringBuilder(".");
    StringBuilder s=new StringBuilder("#");
    Scanner r=new Scanner(System.in);
    int h,w,i,j,ww ;
    String t ;
    for(i=0 ; i<4 ; ++i){
      d.append(d);
      s.append(s);
    }
    ww=d.length();
    while((h=r.nextInt())+(w=r.nextInt())>0){
      while(w>ww){
        d.append(d);
        s.append(s);
        ww+=ww ;
      }
      p.append(s.substring(0,w));
      p.append(nl);
      t=d.substring(0,w-2);
      for(i=2 ; i<h ; ++i){
        p.append('#');
        p.append(t);
        p.append('#');
        p.append(nl);
      }
      p.append(s.substring(0,w));
      p.append(nl);
      p.append(nl);
    }
    System.out.print(p);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var nl : String ; nl := OclProcess.getEnvironmentProperty("line.separator") ;
     var p : String ; p := StringLib.newString(500) ;
    var d : String ; d := StringLib.newString(".") ;
    var s : String ; s := StringLib.newString("#") ;
    var r : OclFile ; r := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var h : int ;
    var w : int ;
    var i : int ;
    var j : int ;
    var ww : int ;
    var t : String ;
        i := 0 ; while i < 4 do ( (     d := d + StringLib.newString(d) ; 
     s := s + StringLib.newString(s) )  ;     i := i + 1 ) ; 
    ww := d->size() ; 
        h := r.getCurrent()->toInteger() ;
    w := r.getCurrent()->toInteger() ;
    while ((h) + (w) > 0) do (        skip ;     skip ; (     while (w > ww) do (     d := d + StringLib.newString(d) ; 
     s := s + StringLib.newString(s) ; 
     ww := ww+(ww) ) ; 
     p := p + StringLib.newString(s.subrange(0+1,w)) ; 
    p := p + StringLib.newString(nl) ; 
    t := d.subrange(0+1,w - 2) ; 
        i := 2 ; while i < h do ( (     p := p + StringLib.newString('#') ; 
     p := p + StringLib.newString(t) ; 
     p := p + StringLib.newString('#') ; 
     p := p + StringLib.newString(nl) )  ;     i := i + 1 ) ; 
    p := p + StringLib.newString(s.subrange(0+1,w)) ; 
    p := p + StringLib.newString(nl) ; 
    p := p + StringLib.newString(nl) ; 
 ) ;     h := r.getCurrent()->toInteger() ;
    w := r.getCurrent()->toInteger() ;
 ) ;  
    OclFile["System.out"].print(p) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer str ;
    int n=Integer.parseInt(br.readLine());
    Integer[] a=new Integer[n];
    long[] b=new long[n+1];
    b[0]=0 ;
    long[] c=new long[n+1];
    c[0]=0 ;
    str=new StringTokenizer(br.readLine());
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(str.nextToken());
      b[i+1]=a[i]+b[i];
    }
    Arrays.sort(a);
    for(int i=0 ; i<n ; i++){
      c[i+1]=a[i]+c[i];
    }
    int l,r ;
    int m=Integer.parseInt(br.readLine());
    while(m-->0){
      str=new StringTokenizer(br.readLine());
      int t=Integer.parseInt(str.nextToken());
      if(t==1){
        l=Integer.parseInt(str.nextToken());
        r=Integer.parseInt(str.nextToken());
        System.out.println(b[r]-b[l-1]);
      }
      else {
        l=Integer.parseInt(str.nextToken());
        r=Integer.parseInt(str.nextToken());
        System.out.println(c[r]-c[l-1]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : OclIterator ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(null) ;
    var b : Sequence(long) ; b := Integer.subrange(1,n + 1)->collect(0) ;
    b[0+1] := 0 ; 
    var c : Sequence(long) ; c := Integer.subrange(1,n + 1)->collect(0) ;
    c[0+1] := 0 ; 
    str := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (str.next())->toInteger() ; 
     b[i + 1+1] := a[i+1] + b[i+1] )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     c[i + 1+1] := a[i+1] + c[i+1] )  ;     i := i + 1 ) ; 
    var l : int ;
    var r : int ;
    var m : int ; m := (br.readLine())->toInteger() ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     str := OclIterator.newOclIterator_String(br.readLine()) ; 
     var t : int ; t := (str.next())->toInteger() ;
     if (t = 1) then (     l := (str.next())->toInteger() ; 
     r := (str.next())->toInteger() ; 
     OclFile["System.out"].println(b[r+1] - b[l - 1+1]) ) else (     l := (str.next())->toInteger() ; 
     r := (str.next())->toInteger() ; 
     OclFile["System.out"].println(c[r+1] - c[l - 1+1]) ) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(isr);
    while(true){
      String[] list=br.readLine().split(" ");
      int x=Integer.parseInt(list[1]);
      int y=Integer.parseInt(list[0]);
      if(x==0 && y==0)break ;
      for(int i=0 ; i<y ; i++){
        for(int j=0 ; j<x ; j++){
          if(i==0 || i==y-1 || j==0 || j==x-1)System.out.print("#");
          else System.out.print(".");
        }
        System.out.println("");
      }
      System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
     while (true) do (     var list : Sequence(String) ; list := br.readLine()->split(" ") ;
     var x : int ; x := (list[1+1])->toInteger() ;
    var y : int ; y := (list[0+1])->toInteger() ;
    if (x = 0 & y = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < y do ( (         var j : int ; j := 0 ; while j < x do ( (     if (i = 0 or i = y - 1 or j = 0 or j = x - 1) then     OclFile["System.out"].print("#") ; else     OclFile["System.out"].print(".") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayList<Integer>h=new ArrayList<Integer>();
    ArrayList<Integer>w=new ArrayList<Integer>();
    int H,W ;
    int count ;
    for(count=0 ; true ; count++){
      H=sc.nextInt();
      W=sc.nextInt();
      if(H==0 && W==0){
        break ;
      }
      h.add(H);
      w.add(W);
    }
    for(int i=0 ; i<count ; i++){
      for(int j=0 ; j<h.get(i); j++){
        for(int k=0 ; k<w.get(i); k++){
          if(j==0 || j+1==h.get(i)){
            System.out.print("#");
          }
          else if(k==0 || k+1==w.get(i)){
            System.out.print("#");
          }
          else {
            System.out.print(".");
          }
        }
        System.out.println();
      }
      System.out.println();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : Sequence(int) ; h := Sequence{} ;
    var w : Sequence(int) ; w := Sequence{} ;
    var H : int ;
    var W : int ;
    var count : int ;
        count := 0 ; while true do ( (     H := sc.getCurrent()->toInteger() ; 
     W := sc.getCurrent()->toInteger() ; 
    if (H = 0 & W = 0) then (     break ) else skip ; 
    h := h->including(H) ; 
    w := w->including(W) ; 
 )  ;     count := count + 1 ) ; 
        var i : int ; i := 0 ; while i < count do ( (         var j : int ; j := 0 ; while j < h->at(i+1) do ( (         var k : int ; k := 0 ; while k < w->at(i+1) do ( (     if (j = 0 or j + 1 = h->at(i+1)) then (     OclFile["System.out"].print("#") ) else     if (k = 0 or k + 1 = w->at(i+1)) then (     OclFile["System.out"].print("#") ) else (     OclFile["System.out"].print(".") ) ;  )  ;     k := k + 1 ) ; 
     OclFile["System.out"].println() )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    BufferedReader insBR=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      try {
        String[] strA=insBR.readLine().split(" ");
        int[] intA=new int[strA.length];
        for(int i=0 ; i<strA.length ; i++){
          intA[i]=Integer.parseInt(strA[i]);
        }
        if(intA[0]==0 && intA[1]==0){
          break ;
        }
        else {
          for(int j=0 ; j<intA[1]; j++){
            System.out.print("#");
          }
          System.out.println();
          for(int i=0 ; i<intA[0]-2 ; i++){
            System.out.print("#");
            for(int j=0 ; j<intA[1]-2 ; j++){
              System.out.print(".");
            }
            System.out.println("#");
          }
          for(int j=0 ; j<intA[1]; j++){
            System.out.print("#");
          }
          System.out.println();
          System.out.println();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      catch(NumberFormatException e){
        e.printStackTrace();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var insBR : OclFile ; insBR := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     try (     var strA : Sequence(String) ; strA := insBR.readLine()->split(" ") ;
     var intA : Sequence(int) ; intA := Integer.subrange(1,strA->size())->collect(0) ;
         var i : int ; i := 0 ; while i < strA->size() do ( (     intA[i+1] := (strA[i+1])->toInteger() )  ;     i := i + 1 ) ; 
     if (intA[0+1] = 0 & intA[1+1] = 0) then (     break ) else (         var j : int ; j := 0 ; while j < intA[1+1] do ( (     OclFile["System.out"].print("#") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() ; 
        var i : int ; i := 0 ; while i < intA[0+1] - 2 do ( (     OclFile["System.out"].print("#") ; 
         var j : int ; j := 0 ; while j < intA[1+1] - 2 do ( (     OclFile["System.out"].print(".") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("#") )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < intA[1+1] do ( (     OclFile["System.out"].print("#") )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println() ; 
    OclFile["System.out"].println() ; 
 ) )   catch (e : IOException) do (     e.printStackTrace() )
   catch (e : IncorrectElementException) do (     e.printStackTrace() )
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class ZmodXC {
  public static void main(String args[]){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    for(int i=0 ; i<n ; i++){
      int a=scn.nextInt();
      int b=scn.nextInt();
      int c=scn.nextInt();
      System.out.println(a+b+c);
      System.out.println(b+c);
      System.out.println(c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ZmodXC {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scn.getCurrent()->toInteger() ;
     var b : int ; b := scn.getCurrent()->toInteger() ;
    var c : int ; c := scn.getCurrent()->toInteger() ;
    OclFile["System.out"].println(a + b + c) ; 
    OclFile["System.out"].println(b + c) ; 
    OclFile["System.out"].println(c) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    while(t--!=0){
      String ele[]=br.readLine().split("\\s");
      int a[]=new int[3];
      for(int i=0 ; i<3 ; i++){
        a[i]=Integer.parseInt(ele[i]);
      }
      int sum=a[0]+a[1]+a[2];
      System.out.println(sum+" "+(sum-a[0])+" "+a[2]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         while (t /= 0) do (    skip ; (     var ele : Sequence(String) ; ele := br.readLine()->split("\\s") ;
     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     a[i+1] := (ele[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var sum : int ; sum := a[0+1] + a[1+1] + a[2+1] ;
    OclFile["System.out"].println(sum + " " + (sum - a[0+1]) + " " + a[2+1]) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int N=sc.nextInt(),M=sc.nextInt();
      if(N==0 && M==0)break ;
      int[] c=new int[M];
      int[][] dp=new int[N+1][256];
      for(int i=0 ; i<M ; i++)c[i]=sc.nextInt();
      for(int[] tmp : dp)Arrays.fill(tmp,Integer.MAX_VALUE);
      dp[0][128]=0 ;
      for(int n=1 ; n<=N ; n++){
        int x=sc.nextInt();
        for(int y=0 ; y<256 ; y++){
          for(int k=0 ; k<M ; k++){
            int ny=y+c[k];
            if(255<ny)ny=255 ;
            else if(ny<0)ny=0 ;
            int cost=(ny-x)*(ny-x);
            int sum=dp[n-1][y]==Integer.MAX_VALUE ? Integer.MAX_VALUE : dp[n-1][y]+cost ;
            dp[n][ny]=Math.min(dp[n][ny],sum);
          }
        }
      }
      int ans=Integer.MAX_VALUE ;
      for(int tmp : dp[N])ans=Math.min(ans,tmp);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
     if (N = 0 & M = 0) then     break else skip ; 
    var c : Sequence(int) ; c := Integer.subrange(1,M)->collect(0) ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,256)->collect(0)) ;
        var i : int ; i := 0 ; while i < M do (     c[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    for (tmp : dp) do (     tmp := tmp->collect(2147483647) ;  ) ; 
    dp[0+1][128+1] := 0 ; 
        var n : int ; n := 1 ; while n <= N do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
         var y : int ; y := 0 ; while y < 256 do ( (         var k : int ; k := 0 ; while k < M do ( (     var ny : int ; ny := y + c[k+1] ;
     if (255 < ny) then     ny := 255 else     if (ny < 0) then     ny := 0 ; else skip ; ;  
    var cost : int ; cost := (ny - x) * (ny - x) ;
    var sum : int ; sum := if dp[n - 1+1][y+1] = 2147483647 then 2147483647 else dp[n - 1+1][y+1] + cost endif ;
    dp[n+1][ny+1] := Set{dp[n+1][ny+1], sum}->min() ; 
 )  ;     k := k + 1 ) )  ;     y := y + 1 ) )  ;     n := n + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
    for (tmp : dp[N+1]) do (     ans := Set{ans, tmp}->min() ;  ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Z_Mod_X_is_C {
  public static void main(String[] args)throws IOException {
    BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(sc.readLine());
    for(int ii=1 ; ii<=t ; ii++){
      String s=sc.readLine();
      String[] ss=s.split(" ",3);
      int a=Integer.parseInt(ss[0]);
      int b=Integer.parseInt(ss[1]);
      int c=Integer.parseInt(ss[2]);
      System.out.println((a+b+c)+" "+(b+c)+" "+(c));
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Z_Mod_X_is_C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (sc.readLine())->toInteger() ;
         var ii : int ; ii := 1 ; while ii <= t do ( (     var s : String ; s := sc.readLine() ;
     var ss : Sequence(String) ; ss := s->split(" ") ;
    var a : int ; a := (ss[0+1])->toInteger() ;
    var b : int ; b := (ss[1+1])->toInteger() ;
    var c : int ; c := (ss[2+1])->toInteger() ;
    OclFile["System.out"].println((a + b + c) + " " + (b + c) + " " + (c)) ; 
 )  ;     ii := ii + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void main(String[] args){
    StringBuilder str=new StringBuilder("geeksforgeeks");
    str.reverse();
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := StringLib.newString("geeksforgeeks") ;
     str := str->reverse() ; 
     OclFile["System.out"].println(str) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    boolean[][] card=new boolean[5][14];
    int n=Integer.parseInt(scan.next());
    char picture ;
    int number ;
    for(int i=0 ; i<5 ; i++){
      for(int j=0 ; j<14 ; j++){
        card[i][j]=false ;
      }
    }
    for(int i=0 ; i<n ; i++){
      card[CheckCtoI((scan.next()).charAt(0))][Integer.parseInt(scan.next())]=true ;
    }
    for(int i=1 ; i<=4 ; i++){
      for(int j=1 ; j<=13 ; j++){
        if(card[i][j]==false){
          System.out.println(CheckItoC(i)+" "+j);
        }
      }
    }
    return ;
  }
  public static int CheckCtoI(char c){
    if(c=='S'){
      return 1 ;
    }
    else if(c=='H'){
      return 2 ;
    }
    else if(c=='C'){
      return 3 ;
    }
    else if(c=='D'){
      return 4 ;
    }
    return 0 ;
  }
  public static char CheckItoC(int n){
    if(n==1){
      return 'S' ;
    }
    else if(n==2){
      return 'H' ;
    }
    else if(n==3){
      return 'C' ;
    }
    else if(n==4){
      return 'D' ;
    }
    return 'X' ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var card : Sequence(Sequence(boolean)) ; card := Integer.subrange(1,5)->collect(Integer.subrange(1,14)->collect(false)) ;
    var n : int ; n := (scan.getCurrent())->toInteger() ;
    var picture : String ;
    var number : int ;
        var i : int ; i := 0 ; while i < 5 do ( (         var j : int ; j := 0 ; while j < 14 do ( (     card[i+1][j+1] := false )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     card[CheckCtoI((scan.getCurrent())->at(0+1))+1][(scan.getCurrent())->toInteger()+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 4 do ( (         var j : int ; j := 1 ; while j <= 13 do ( (     if (card[i+1][j+1] = false) then (     OclFile["System.out"].println(CheckItoC(i) + " " + j) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return 
 );
  static   operation CheckCtoI( c : String) : int
  pre: true
  post: true
  activity: (     if (c = 'S') then (     return 1 ) else     if (c = 'H') then (     return 2 ) else     if (c = 'C') then (     return 3 ) else     if (c = 'D') then (     return 4 ) else skip ; ;  ;  ;  
     return 0 );
  static   operation CheckItoC( n : int) : String
  pre: true
  post: true
  activity: (     if (n = 1) then (     return 'S' ) else     if (n = 2) then (     return 'H' ) else     if (n = 3) then (     return 'C' ) else     if (n = 4) then (     return 'D' ) else skip ; ;  ;  ;  
     return 'X' );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Iterator ;
import java.util.List ;
public class Main {
  public static void main(String[] args)throws IOException {
    char[] marks={
      'S','H','C','D' };
      for(char mark : marks){
        for(int i=1 ; i<=13 ; i++){
          Card.allCards.add(new Card(mark,i));
        }
      }
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      int n=Integer.parseInt(br.readLine());
      for(int i=0 ; i<n ; i++){
        String[] str=br.readLine().split(" ");
        Iterator<Card>itr=Card.allCards.iterator();
        while(itr.hasNext()){
          Card tmp=itr.next();
          if(tmp.mark!=str[0] .charAt(0)){
            continue ;
          }
          if(tmp.rank==Integer.parseInt(str[1])){
            itr.remove();
          }
        }
      }
      for(Card card : Card.allCards){
        System.out.println(card.mark+" "+card.rank);
      }
    }
  }
  class Card {
    char mark ;
    int rank ;
    static List<Card>allCards=new ArrayList<Card>();
    Card(char mark,int rank){
      this.mark=mark ;
      this.rank=rank ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var marks : Sequence(String) ; marks := Sequence{'S','H','C','D'} ;
     for (mark : marks) do ( (         var i : int ; i := 1 ; while i <= 13 do ( (     Card.allCards->excludes(Card.newCard(mark, i)) )  ;     i := i + 1 ) )  ) ; 
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var n : int ; n := (br.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     var itr : OclIterator ; itr := Card.allCards->iterator() ;
     while (itr.hasNext()) do (     var tmp : Card ; tmp := itr.next() ;
     if (tmp.mark /= str[0+1]->at(0+1)) then (     continue ) else skip ; 
     if (tmp.rank = (str[1+1])->toInteger()) then (     itr := itr.remove() ) else skip ) )  ;     i := i + 1 ) ; 
    for (card : Card.allCards) do ( (     OclFile["System.out"].println(card.mark + " " + card.rank) )  ) ; 
 );
}
class Card {
   attribute mark : String;
   attribute rank : int;
  static   attribute allCards : Sequence(Card) := Sequence{};
   static operation newCard( mark : String, rank : int) : Card
  pre: true
  post: true
  activity:
  ( var self : Card ;
    self := createCard();
    self.initialise(mark, rank);
    return self );
  operation initialise( mark : String, rank : int) : void
  pre: true  post: true
  activity: (     self.mark := mark ; 
     self.rank := rank );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Iterator ;
import java.util.Set ;
class GFG {
  static int findMinimumX(int a[],int n){
    Set<Integer>st=new HashSet<>();
    for(int i=0 ; i<n ; i++)st.add(a[i]);
    if(st.size()==1)return 0 ;
    if(st.size()==2){
      Iterator<Integer>it=st.iterator();
      int el1=it.next();
      int el2=it.next();
      if((el2-el1)% 2==0)return(el2-el1)/2 ;
      else return(el2-el1);
    }
    if(st.size()==3){
      Iterator<Integer>it=st.iterator();
      int el1=it.next();
      int el2=it.next();
      int el3=it.next();
      if((el2-el1)==(el3-el2))return el2-el1 ;
      else return-1 ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    int a[]={
      1,4,4,7,4,1 };
      int n=a.length ;
      System.out.println(findMinimumX(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMinimumX( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var st : Set(int) ; st := Set{} ;
         var i : int ; i := 0 ; while i < n do (     st := st->including(a[i+1]) ;  ;     i := i + 1 ) ; 
    if (st->size() = 1) then     return 0 else skip ; 
    if (st->size() = 2) then (     var it : OclIterator ; it := st->iterator() ;
     var el1 : int ; el1 := it.next() ;
     var el2 : int ; el2 := it.next() ;
     if ((el2 - el1) mod 2 = 0) then     return (el2 - el1) / 2 else     return (el2 - el1) ) else skip ; 
    if (st->size() = 3) then (     var it : OclIterator ; it := st->iterator() ;
     var el1 : int ; el1 := it.next() ;
    var el2 : int ; el2 := it.next() ;
    var el3 : int ; el3 := it.next() ;
    if ((el2 - el1) = (el3 - el2)) then     return el2 - el1 else     return -1 ;  
 ) else skip ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,4,4,7,4,1} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(findMinimumX(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  boolean[][] map=new boolean[4][13];
  public void execution(String illust,int level){
    int i ;
    if(illust.equals("S"))i=0 ;
    else if(illust.equals("H"))i=1 ;
    else if(illust.equals("C"))i=2 ;
    else i=3 ;
    map[i][level-1]=true ;
  }
  public void print(){
    for(int i=0 ; i<4 ; i++){
      for(int j=0 ; j<13 ; j++){
        if(! map[i][j]){
          if(i==0)System.out.println("S "+(j+1));
          else if(i==1)System.out.println("H "+(j+1));
          else if(i==2)System.out.println("C "+(j+1));
          else System.out.println("D "+(j+1));
        }
      }
    }
  }
  public void run(){
    sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<4 ; i++){
      for(int j=0 ; j<13 ; j++){
        map[i][j]=false ;
      }
    }
    for(int i=0 ; i<n ; i++){
      String illust=sc.next();
      int level=sc.nextInt();
      execution(illust,level);
    }
    print();
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute map : Sequence(Sequence(boolean)) := Integer.subrange(1,4)->collect(Integer.subrange(1,13)->collect(false));
   operation execution( illust : String, level : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
     if (illust = "S") then     i := 0 else     if (illust = "H") then     i := 1 else     if (illust = "C") then     i := 2 else     i := 3 ; ;  ;  ;  
     map[i+1][level - 1+1] := true );
   operation print() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < 13 do ( (     if (not(map[i+1][j+1])) then (     if (i = 0) then     OclFile["System.out"].println("S " + (j + 1)) ; else     if (i = 1) then     OclFile["System.out"].println("H " + (j + 1)) else     if (i = 2) then     OclFile["System.out"].println("C " + (j + 1)) else     OclFile["System.out"].println("D " + (j + 1)) ; ;  ;  ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < 13 do ( (     map[i+1][j+1] := false )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var illust : String ; illust := sc.getCurrent() ;
     var level : int ; level := sc.getCurrent()->toInteger() ;
     execute execution(illust, level) )  ;     i := i + 1 ) ; 
    execute print() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(isr);
    int n=0 ;
    boolean[][] cards=new boolean[4][14];
    for(int i=0 ; ; i++){
      if(i==n+1){
        break ;
      }
      String str=br.readLine();
      if(i==0){
        n=Integer.parseInt(str);
        if(n==0){
          break ;
        }
        continue ;
      }
      String[] ss=str.split(" ");
      String s=ss[0];
      int num=Integer.parseInt(ss[1]);
      if(s.equals("S")){
        cards[0][num]=true ;
      }
      else if(s.equals("H")){
        cards[1][num]=true ;
      }
      else if(s.equals("C")){
        cards[2][num]=true ;
      }
      else if(s.equals("D")==true){
        cards[3][num]=true ;
      }
    }
    for(int i=0 ; i<4 ; i++){
      for(int j=1 ; j<14 ; j++){
        if(cards[i][j]){
          continue ;
        }
        String s="" ;
        if(i==0){
          s="S" ;
        }
        else if(i==1){
          s="H" ;
        }
        else if(i==2){
          s="C" ;
        }
        else if(i==3){
          s="D" ;
        }
        System.out.println(s+" "+j);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
    var n : int ; n := 0 ;
    var cards : Sequence(Sequence(boolean)) ; cards := Integer.subrange(1,4)->collect(Integer.subrange(1,14)->collect(false)) ;
        var i : int ; i := 0 ; while true do ( (     if (i = n + 1) then (     break ) else skip ; 
     var str : String ; str := br.readLine() ;
    if (i = 0) then (     n := (str)->toInteger() ; 
     if (n = 0) then (     break ) else skip ; 
     continue ) else skip ; 
    var ss : Sequence(String) ; ss := str->split(" ") ;
    var s : String ; s := ss[0+1] ;
    var num : int ; num := (ss[1+1])->toInteger() ;
    if (s = "S") then (     cards[0+1][num+1] := true ) else     if (s = "H") then (     cards[1+1][num+1] := true ) else     if (s = "C") then (     cards[2+1][num+1] := true ) else     if (s = "D" = true) then (     cards[3+1][num+1] := true ) else skip ; ;  ;  ;  
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 1 ; while j < 14 do ( (     if (cards[i+1][j+1]) then (     continue ) else skip ; 
     var s : String ; s := "" ;
     if (i = 0) then (     s := "S" ) else     if (i = 1) then (     s := "H" ) else     if (i = 2) then (     s := "C" ) else     if (i = 3) then (     s := "D" ) else skip ; ;  ;  ;  
     OclFile["System.out"].println(s + " " + j) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String args[]){
    HashMap<Integer,Camel>zoo=new HashMap<Integer,Camel>();
    boolean hasSpittedEachOther=false ;
    Scanner scanner=new Scanner(System.in);
    int numberOfCamels=scanner.nextInt();
    for(int i=0 ; i<numberOfCamels ; i++){
      String position=scanner.next();
      String spit=scanner.next();
      scanner.nextLine();
      Camel camel=new Camel(Integer.parseInt(position),Integer.parseInt(spit));
      zoo.put(Integer.parseInt(position),camel);
    }
    Set<Integer>positions=zoo.keySet();
    for(Integer position : positions){
      Camel camel=zoo.get(position);
      if(camel!=null){
        camel.spitCamel(zoo.get(position+camel.getSpit()));
      }
      if(camel.spitedCamel!=null && camel.spitedCamel.spitedCamel!=null){
        Camel originalCamel=camel ;
        Camel spitedCamel=camel.spitedCamel ;
        if(spitedCamel.spitedCamel.equals(originalCamel)){
          hasSpittedEachOther=true ;
          break ;
        }
      }
    }
    if(hasSpittedEachOther){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
class Camel {
  Camel spitedCamel ;
  int spit ;
  int position ;
  public Camel(int position,int spit){
    this.spit=spit ;
    this.position=position ;
  }
  int getSpit(){
    return spit ;
  }
  void spitCamel(Camel camel){
    this.spitedCamel=camel ;
  }
  @ Override public boolean equals(Object o){
    if(this==o)return true ;
    if(o==null || getClass()!=o.getClass())return false ;
    Camel camel=(Camel)o ;
    return position==camel.position ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var zoo : Map(int,Camel) ; zoo := Map{} ;
     var hasSpittedEachOther : boolean ; hasSpittedEachOther := false ;
    var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var numberOfCamels : int ; numberOfCamels := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < numberOfCamels do ( (     var position : String ; position := scanner.getCurrent() ;
     var spit : String ; spit := scanner.getCurrent() ;
    skip ; 
    var camel : Camel ; camel := Camel.newCamel((position)->toInteger(), (spit)->toInteger()) ;
    zoo := zoo->union(Map{(position)->toInteger() |-> camel}) ; 
 )  ;     i := i + 1 ) ; 
    var positions : Set(int) ; positions := zoo->keys() ;
    for (position : positions) do ( (     var camel : Camel ; camel := zoo->at(position) ;
     if (camel /= null) then (     camel.spitCamel(zoo->at(position + camel.getSpit())) ) else skip ; 
     if (camel.spitedCamel /= null & camel.spitedCamel.spitedCamel /= null) then (     var originalCamel : Camel ; originalCamel := camel ;
     var spitedCamel : Camel ; spitedCamel := camel.spitedCamel ;
     if (spitedCamel.spitedCamel = originalCamel) then (     hasSpittedEachOther := true ; 
     break ) else skip ) else skip )  ) ; 
    if (hasSpittedEachOther) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}
class Camel {
   attribute spitedCamel : Camel;
   attribute spit : int;
   attribute position : int;
   static operation newCamel( position : int, spit : int) : Camel
  pre: true
  post: true
  activity:
  ( var self : Camel ;
    self := createCamel();
    self.initialise(position, spit);
    return self );
  operation initialise( position : int, spit : int) : void
  pre: true  post: true
  activity: (     self.spit := spit ; 
     self.position := position );
   operation getSpit() : int
  pre: true
  post: true
  activity: (     return spit );
   operation spitCamel( camel : Camel) : void
  pre: true
  post: true
  activity: (     self.spitedCamel := camel );
      operation equals( o : OclAny) : boolean
  pre: true
  post: true
  activity: (     if (self = o) then     return true else skip ; 
     if (o = null or getClass() /= o->oclType()) then     return false else skip ; 
     var camel : Camel ; camel := o->oclAsType(Camel) ;
     return position = camel.position );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    input.nextLine();
    ArrayList<Integer>x=new ArrayList<>();
    ArrayList<Integer>d=new ArrayList<>();
    for(int c=0 ; c<n ; c++){
      int _x=input.nextInt();
      int _d=input.nextInt();
      input.nextLine();
      x.add(_x);
      d.add(_d);
      for(int j=0 ; j<c ; j++){
        if(x.get(c)+d.get(c)==x.get(j)&& x.get(j)+d.get(j)==x.get(c)){
          System.out.println("YES");
          return ;
        }
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    skip ; 
    var x : Sequence(int) ; x := Sequence{} ;
    var d : Sequence(int) ; d := Sequence{} ;
        var c : int ; c := 0 ; while c < n do ( (     var _x : int ; _x := input.getCurrent()->toInteger() ;
     var _d : int ; _d := input.getCurrent()->toInteger() ;
    skip ; 
    x := x->including(_x) ; 
    d := d->including(_d) ; 
        var j : int ; j := 0 ; while j < c do ( (     if (x->at(c+1) + d->at(c+1) = x->at(j+1) & x->at(j+1) + d->at(j+1) = x->at(c+1)) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     j := j + 1 ) ; 
 )  ;     c := c + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void SieveOfEratosthenes(boolean prime[],int p_size){
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=p_size ; p++){
      if(prime[p]){
        for(int i=p*2 ; i<=p_size ; i+=p)prime[i]=false ;
      }
    }
  }
  static int xorOfPrime(char[] s){
    boolean[] prime=new boolean[100005];
    for(int i=0 ; i<100005 ; i++)prime[i]=true ;
    SieveOfEratosthenes(prime,10005);
    int i,j ;
    Map<Character,Integer>m=new HashMap<>();
    for(i=0 ; i<s.length ; i++){
      if(m.containsKey(s[i])){
        m.put(s[i],m.get(s[i])+1);
      }
      else {
        m.put(s[i],1);
      }
    }
    int result=0 ;
    int flag=0 ;
    for(Map.Entry<Character,Integer>entry : m.entrySet()){
      if(prime[entry.getValue()]){
        result ^=entry.getValue();
        flag=1 ;
      }
    }
    if(flag!=1)return-1 ;
    return result ;
  }
  public static void main(String[] args){
    char[] s="gggggeeekkkks".toCharArray();
    System.out.println(xorOfPrime(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation SieveOfEratosthenes( prime : Sequence(boolean), p_size : int) : void
  pre: true
  post: true
  activity: (     prime[0+1] := false ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p <= p_size do ( (     if (prime[p+1]) then (         var i : int ; i := p * 2 ; while i <= p_size do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation xorOfPrime( s : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,100005)->collect(false) ;
         var i : int ; i := 0 ; while i < 100005 do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
    execute SieveOfEratosthenes(prime, 10005) ; 
    var i : int ;
    var j : int ;
    var m : Map(String,int) ; m := Map{} ;
        i := 0 ; while i < s->size() do ( (     if (m->keys()->includes(s[i+1])) then (     m := m->union(Map{s[i+1] |-> m->at(s[i+1]) + 1}) ) else (     m := m->union(Map{s[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
    var flag : int ; flag := 0 ;
    for (entry : m->asSet()) do ( (     if (prime[entry.getValue()+1]) then (     result := MathLib.bitwiseXor(result,entry.getValue()) ; 
     flag := 1 ) else skip )  ) ; 
    if (flag /= 1) then     return -1 else skip ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := "gggggeeekkkks"->characters() ;
     OclFile["System.out"].println(xorOfPrime(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int INF=255*255*20000 ;
    for(; ; ){
      int n=sc.nextInt(),m=sc.nextInt();
      if((n | m)==0)break ;
      int[] x=new int[n],c=new int[m];
      for(int i=0 ; i<m ; i++)c[i]=sc.nextInt();
      for(int i=0 ; i<n ; i++)x[i]=sc.nextInt();
      int[] dp=new int[256];
      Arrays.fill(dp,INF);
      dp[128]=0 ;
      for(int i=0 ; i<n ; i++){
        int[] next=new int[256];
        Arrays.fill(next,INF);
        for(int y=0 ; y<256 ; y++){
          if(dp[y]==INF)continue ;
          for(int j=0 ; j<m ; j++){
            int nx=y+c[j];
            if(nx<0)nx=0 ;
            if(255<nx)nx=255 ;
            int v=dp[y]+(x[i]-nx)*(x[i]-nx);
            next[nx]=Math.min(next[nx],v);
          }
        }
        dp=next ;
      }
      int res=INF ;
      for(int i=0 ; i<256 ; i++)res=Math.min(res,dp[i]);
      System.out.println(res);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var INF : int ; INF := 255 * 255 * 20000 ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseOr(n,m)) = 0) then     break else skip ; 
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     c[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     x[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,256)->collect(0) ;
    dp := dp->collect(INF) ; 
    dp[128+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     var next : Sequence(int) ; next := Integer.subrange(1,256)->collect(0) ;
     next := next->collect(INF) ; 
         var y : int ; y := 0 ; while y < 256 do ( (     if (dp[y+1] = INF) then     continue else skip ; 
         var j : int ; j := 0 ; while j < m do ( (     var nx : int ; nx := y + c[j+1] ;
     if (nx < 0) then     nx := 0 ; else skip ; 
    if (255 < nx) then     nx := 255 ; else skip ; 
    var v : int ; v := dp[y+1] + (x[i+1] - nx) * (x[i+1] - nx) ;
    next[nx+1] := Set{next[nx+1], v}->min() ; 
 )  ;     j := j + 1 ) )  ;     y := y + 1 ) ; 
     dp := next )  ;     i := i + 1 ) ; 
    var res : int ; res := INF ;
        var i : int ; i := 0 ; while i < 256 do (     res := Set{res, dp[i+1]}->min() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static void printPascal(int n){
    for(int line=1 ; line<=n ; line++){
      int C=1 ;
      for(int i=1 ; i<=line ; i++){
        System.out.print(C+" ");
        C=C*(line-i)/i ;
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    int n=5 ;
    printPascal(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printPascal( n : int) : void
  pre: true
  post: true
  activity: (         var line : int ; line := 1 ; while line <= n do ( (     var C : int ; C := 1 ;
         var i : int ; i := 1 ; while i <= line do ( (     OclFile["System.out"].print(C + " ") ; 
     C := C * (line - i) / i )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() )  ;     line := line + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute printPascal(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSetBits(int n){
    int count=0 ;
    while(n!=0){
      count+=n & 1 ;
      n>>=1 ;
    }
    return count ;
  }
  public static void main(String[] args){
    int i=3 ;
    System.out.print(countSetBits(i));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n /= 0) do (     count := count+(n & 1) ; 
     n := n/(2->pow(1)) ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 3 ;
     OclFile["System.out"].print(countSetBits(i)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maxLength(String s,int n){
    int dp[][]=new int[n][n];
    for(int i=0 ; i<n-1 ; i++)if(s.charAt(i)=='(' && s.charAt(i+1)==')')dp[i][i+1]=2 ;
    for(int l=2 ; l<n ; l++){
      for(int i=0,j=l ; j<n ; i++,j++){
        if(s.charAt(i)=='(' && s.charAt(j)==')')dp[i][j]=2+dp[i+1][j-1];
        for(int k=i ; k<j ; k++)dp[i][j]=Math.max(dp[i][j],dp[i][k]+dp[k+1][j]);
      }
    }
    return dp[0][n-1];
  }
  public static void main(String[] args){
    String s="()(((((()" ;
    int n=s.length();
    System.out.println(maxLength(s,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxLength( s : String, n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
         var i : int ; i := 0 ; while i < n - 1 do (     if (s->at(i+1) = '(' & s->at(i + 1+1) = ')') then     dp[i+1][i + 1+1] := 2 ; else skip ;  ;     i := i + 1 ) ; 
         var l : int ; l := 2 ; while l < n do ( (         var i : int ; i := 0 ;
    var j : int ; j := l ; while j < n do ( (     if (s->at(i+1) = '(' & s->at(j+1) = ')') then     dp[i+1][j+1] := 2 + dp[i + 1+1][j - 1+1] ; else skip ; 
         var k : int ; k := i ; while k < j do (     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i+1][k+1] + dp[k + 1+1][j+1]}->max() ;  ;     k := k + 1 ) )  ;     i := i + 1 ;     j := j + 1 ) )  ;     l := l + 1 ) ; 
     return dp[0+1][n - 1+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "()(((((()" ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].println(maxLength(s, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int computeLastDigit(long A,long B){
    int variable=1 ;
    if(A==B)return 1 ;
    else if((B-A)>=5)return 0 ;
    else {
      for(long i=A+1 ; i<=B ; i++)variable=(int)(variable*(i % 10))% 10 ;
      return variable % 10 ;
    }
  }
  public static void main(String[] args){
    System.out.println(computeLastDigit(2632,2634));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation computeLastDigit( A : long, B : long) : int
  pre: true
  post: true
  activity: (     var variable : int ; variable := 1 ;
     if (A = B) then     return 1 else     if ((B - A) >= 5) then     return 0 else (         var i : long ; i := A + 1 ; while i <= B do (     variable := (variable * (i mod 10))->oclAsType(int) mod 10 ;  ;     i := i + 1 ) ; 
     return variable mod 10 ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(computeLastDigit(2632, 2634)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public String reverseStr(String s,int k){
    char[] a=s.toCharArray();
    for(int start=0 ; start<a.length ; start+=2*k){
      int i=start,j=Math.min(start+k-1,a.length-1);
      while(i<j){
        char tmp=a[i];
        a[i++]=a[j];
        a[j--]=tmp ;
      }
    }
    return new String(a);
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation reverseStr( s : String, k : int) : String
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := s->characters() ;
         var start : int ; start := 0 ; while start < a->size() do ( (     var i : int ; i := start ;
    var j : int ; j := Set{start + k - 1, a->size() - 1}->min() ;
     while (i < j) do (     var tmp : String ; tmp := a[i+1] ;
      a[i+1] := a[j+1]  ; i := i + 1 ; 
      a[j+1] := tmp  ; j := j - 1 ) )  ;     start := start+(2 * k) ) ; 
     return StringLib.newString(a) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
class GFG {
  static int minFn(int arr[]){
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<arr.length ; i++)if(min>arr[i])min=arr[i];
    return min ;
  }
  static void minimizeGraph(int arr[][]){
    int min ;
    for(int i=0 ; i<arr.length ; i++)for(int j=0 ; j<arr.length ; j++)if(arr[i][j]==0)arr[i][j]=Integer.MAX_VALUE ;
    for(int i=0 ; i<arr.length ; i++){
      min=minFn(arr[i]);
      for(int j=0 ; j<arr.length ; j++){
        if((arr[i][j]!=min)||(arr[i][j]==Integer.MAX_VALUE))arr[i][j]=0 ;
        else min=0 ;
      }
    }
    for(int i=0 ; i<arr.length ; i++){
      for(int j=0 ; j<arr.length ; j++)System.out.print(arr[i][j]+" ");
      System.out.print("\n");
    }
  }
  public static void main(String[] args){
    int arr[][]={
      {
        1,2,4,0 },{
          0,0,0,5 },{
            0,2,0,3 },{
              0,0,0,0 }
            };
            minimizeGraph(arr);
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minFn( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var min : int ; min := 2147483647 ;
         var i : int ; i := 0 ; while i < arr->size() do (     if (min > arr[i+1]) then     min := arr[i+1] ; else skip ;  ;     i := i + 1 ) ; 
     return min );
  static   operation minimizeGraph( arr : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var min : int ;
         var i : int ; i := 0 ; while i < arr->size() do (         var j : int ; j := 0 ; while j < arr->size() do (     if (arr[i+1][j+1] = 0) then     arr[i+1][j+1] := 2147483647 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < arr->size() do ( (     min := minFn(arr[i+1]) ; 
         var j : int ; j := 0 ; while j < arr->size() do ( (     if ((arr[i+1][j+1] /= min) or (arr[i+1][j+1] = 2147483647)) then     arr[i+1][j+1] := 0 ; else     min := 0 ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < arr->size() do ( (         var j : int ; j := 0 ; while j < arr->size() do (     OclFile["System.out"].print(arr[i+1][j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,2,4,0},Sequence{0,0,0,5},Sequence{0,2,0,3},Sequence{0,0,0,0}} ;
     execute minimizeGraph(arr) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A997 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    in.next();
    long reverseCost=in.nextLong();
    long inverseCost=in.nextLong();
    char[] S=in.next().toCharArray();
    char last='1' ;
    long zeroSegments=0 ;
    for(char c : S){
      if(c=='0' && last=='1'){
        zeroSegments++;
      }
      last=c ;
    }
    long answer ;
    if(inverseCost<=reverseCost){
      answer=zeroSegments*inverseCost ;
    }
    else if(zeroSegments==0){
      answer=0 ;
    }
    else {
      answer=(zeroSegments-1)*reverseCost+inverseCost ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A997 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var reverseCost : long ; reverseCost := in.getCurrent()->toLong() ;
    var inverseCost : long ; inverseCost := in.getCurrent()->toLong() ;
    var S : Sequence(String) ; S := in.getCurrent()->characters() ;
    var last : String ; last := '1' ;
    var zeroSegments : long ; zeroSegments := 0 ;
    for (c : S) do ( (     if (c = '0' & last = '1') then (     zeroSegments := zeroSegments + 1 ) else skip ; 
     last := c )  ) ; 
    var answer : long ;
    if (inverseCost <= reverseCost) then (     answer := zeroSegments * inverseCost ) else     if (zeroSegments = 0) then (     answer := 0 ) else (     answer := ((zeroSegments)->char2byte() - 1) * reverseCost + inverseCost ) ;  ;  
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  private int dist(int[] point){
    return point[0]*point[0]+point[1]*point[1];
  }
  public int[][] kClosest(int[][] points,int K){
    PriorityQueue<int[]>pq=new PriorityQueue<int[]>((p1,p2)->dist(p2)-dist(p1));
    for(int[] p : points){
      pq.offer(p);
      if(pq.size()>K){
        pq.poll();
      }
    }
    int[][] res=new int[K][2];
    while(K>0){
      res[--K]=pq.poll();
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation dist( point : Sequence(int)) : int
  pre: true
  post: true
  activity: (     return point[0+1] * point[0+1] + point[1+1] * point[1+1] );
   operation kClosest( points : Sequence(Sequence(int)), K : int) : Sequence(Sequence(int))
  pre: true
  post: true
  activity: (     var pq : Sequence(Sequence(int)) ; pq := Sequence{}->union(lambda (p1 , p2) : OclAny in dist(p2) - dist(p1)) ;
     for (p : points) do ( (     pq := pq->including(p) ; 
     if (pq->size() > K) then (     pq := pq->sort()->tail() ) else skip )  ) ; 
    var res : Sequence(Sequence(int)) ; res := Integer.subrange(1,K)->collect(Integer.subrange(1,2)->collect(0)) ;
    while (K > 0) do (     res[(K - 1)+1] := pq->min() ;     pq := pq->sort()->tail() ) ; 
    return res 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findNumber(int n){
    n--;
    int i=1 ;
    while(n>=0){
      n-=i ;
++i ;
    }
    return(n+i);
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(findNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNumber( n : int) : int
  pre: true
  post: true
  activity: (     n := n - 1 ; 
     var i : int ; i := 1 ;
     while (n >= 0) do (     n := n-(i) ; 
     i := i + 1 ) ; 
     return (n + i) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(findNumber(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int sumOfDigits(int n){
    int res=0 ;
    while(n>0){
      res+=n % 10 ;
      n/=10 ;
    }
    return res ;
  }
  static int findNumber(int n){
    int i=n-1 ;
    while(i>0){
      if(sumOfDigits(i)>sumOfDigits(n))return i ;
      i--;
    }
    return-1 ;
  }
  public static void main(String[] args){
    int n=824 ;
    System.out.println(findNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfDigits( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     while (n > 0) do (     res := res+(n mod 10) ; 
     n := n/(10) ) ; 
     return res );
  static   operation findNumber( n : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := n - 1 ;
     while (i > 0) do (     if (sumOfDigits(i) > sumOfDigits(n)) then     return i else skip ; 
     i := i - 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 824 ;
     OclFile["System.out"].println(findNumber(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static final int MAX=Integer.MAX_VALUE-90000 ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(true){
      int N=in.nextInt();
      int M=in.nextInt();
      if(N==0 && M==0)break ;
      int[] C=new int[M];
      for(int i=0 ; i<M ; i++){
        C[i]=in.nextInt();
      }
      int[] x=new int[N+1];
      for(int i=1 ; i<N+1 ; i++){
        x[i]=in.nextInt();
      }
      int[][] dp=new int[N+1][256];
      for(int i=0 ; i<N+1 ; i++){
        for(int j=0 ; j<256 ; j++){
          dp[i][j]=MAX ;
        }
      }
      dp[0][128]=0 ;
      for(int i=0 ; i<N ; i++){
        for(int j=0 ; j<256 ; j++){
          for(int k=0 ; k<C.length ; k++){
            int trg=Math.min(255,Math.max(0,j+C[k]));
            dp[i+1][trg]=(int)Math.min(dp[i+1][trg],dp[i][j]+Math.pow(x[i+1]-trg,2));
          }
        }
      }
      int ans=MAX ;
      for(int i=0 ; i<256 ; i++){
        ans=Math.min(ans,dp[N][i]);
      }
      System.out.println(ans);
      System.gc();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 2147483647 - 90000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var N : int ; N := in.getCurrent()->toInteger() ;
     var M : int ; M := in.getCurrent()->toInteger() ;
    if (N = 0 & M = 0) then     break else skip ; 
    var C : Sequence(int) ; C := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     C[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var x : Sequence(int) ; x := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i < N + 1 do ( (     x[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,256)->collect(0)) ;
        var i : int ; i := 0 ; while i < N + 1 do ( (         var j : int ; j := 0 ; while j < 256 do ( (     dp[i+1][j+1] := MAX )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    dp[0+1][128+1] := 0 ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < 256 do ( (         var k : int ; k := 0 ; while k < C->size() do ( (     var trg : int ; trg := Set{255, Set{0, j + C[k+1]}->max()}->min() ;
     dp[i + 1+1][trg+1] := Set{dp[i + 1+1][trg+1], dp[i+1][j+1] + x[i + 1+1] - trg->pow(2)}->min()->oclAsType(int) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := MAX ;
        var i : int ; i := 0 ; while i < 256 do ( (     ans := Set{ans, dp[N+1][i+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
gc() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int smallestDivisor(int n){
    if(n % 2==0)return 2 ;
    for(int i=3 ; i*i<=n ; i+=2){
      if(n % i==0)return i ;
    }
    return n ;
  }
  public static void main(String[] args){
    int n=31 ;
    System.out.println(smallestDivisor(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation smallestDivisor( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 = 0) then     return 2 else skip ; 
         var i : int ; i := 3 ; while i * i <= n do ( (     if (n mod i = 0) then     return i else skip )  ;     i := i+(2) ) ; 
     return n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 31 ;
     OclFile["System.out"].println(smallestDivisor(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Stack ;
import java.lang.Math ;
public class Main {
  public static Stack<Long>stack=new Stack<Long>();
  public static boolean overFlow=false ;
  public static void main(String[] args){
    try {
      BufferedReader bufferReader=new BufferedReader(new InputStreamReader(System.in));
      long answer=0 ;
      stack.add(1L);
      long limit=(long)(Math.pow(2,32));
      int size=Integer.valueOf(bufferReader.readLine());
      for(int i=0 ; i<size ; i++){
        String command=bufferReader.readLine();
        if(command.equals("add")){
          answer+=stack.peek();
          if(answer>=limit){
            break ;
          }
        }
        else if(command.equals("end")){
          stack.pop();
        }
        else {
          String[] x=command.split(" ");
          stack.push(Math.min(stack.peek()*Long.valueOf(x[1]),limit));
        }
      }
      if(answer<limit){
        System.out.println(answer);
      }
      else {
        System.out.println("OVERFLOW!!!");
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute stack : Sequence(long) := Sequence{};
  static   attribute overFlow : boolean := false;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var bufferReader : OclFile ; bufferReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var answer : long ; answer := 0 ;
    stack := stack->including(1L) ; 
    var limit : long ; limit := (2->pow(32))->oclAsType(long) ;
    var size : int ; size := (bufferReader.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < size do ( (     var command : String ; command := bufferReader.readLine() ;
     if (command = "add") then (     answer := answer+(stack->min()) ; 
     if (answer >= limit) then (     break ) else skip ) else     if (command = "end") then (     stack := stack->front() ) else (     var x : Sequence(String) ; x := command->split(" ") ;
     stack := stack->append(Set{stack->min() * (x[1+1])->toLong(), limit}->min()) ) ;  )  ;     i := i + 1 ) ; 
    if (answer < limit) then (     OclFile["System.out"].println(answer) ) else (     OclFile["System.out"].println("OVERFLOW!!!") ) ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static int[] a=null ;
  static int[] b=null ;
  static int[] c=null ;
  static int[] d=null ;
  static int n=0 ;
  static int m=0 ;
  static int q=0 ;
  static long ans=-100L ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    m=sc.nextInt();
    q=sc.nextInt();
    a=new int[q];
    b=new int[q];
    c=new int[q];
    d=new int[q];
    for(int i=0 ; i<q ; ++i){
      a[i]=sc.nextInt()-1 ;
      b[i]=sc.nextInt()-1 ;
      c[i]=sc.nextInt();
      d[i]=sc.nextInt();
    }
    dfs(new ArrayList<Integer>());
    System.out.println(ans);
  }
  public static void dfs(ArrayList<Integer>list){
    if(list.size()==n){
      long score=0L ;
      for(int i=0 ; i<q ; ++i){
        score+=(list.get(b[i])-list.get(a[i])==c[i])? d[i] : 0L ;
      }
      ans=Math.max(ans,score);
      return ;
    }
    if(! list.isEmpty()){
      for(int num=list.get(list.size()-1); num<=m ; ++num){
        list.add(num);
        dfs(list);
        list.remove(list.size()-1);
      }
    }
    else {
      for(int num=1 ; num<=m ; ++num){
        list.add(num);
        dfs(list);
        list.remove(list.size()-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a : Sequence(int) := null;
  static   attribute b : Sequence(int) := null;
  static   attribute c : Sequence(int) := null;
  static   attribute d : Sequence(int) := null;
  static   attribute n : int := 0;
  static   attribute m : int := 0;
  static   attribute q : int := 0;
  static   attribute ans : long := -100L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
    q := sc.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,q)->collect(0) ; 
    b := Integer.subrange(1,q)->collect(0) ; 
    c := Integer.subrange(1,q)->collect(0) ; 
    d := Integer.subrange(1,q)->collect(0) ; 
        var i : int ; i := 0 ; while i < q do ( (     a[i+1] := sc.getCurrent()->toInteger() - 1 ; 
     b[i+1] := sc.getCurrent()->toInteger() - 1 ; 
     c[i+1] := sc.getCurrent()->toInteger() ; 
     d[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute dfs(Sequence{}) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation dfs( list : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (list->size() = n) then (     var score : long ; score := 0L ;
         var i : int ; i := 0 ; while i < q do ( (     score := score+(if (list->at(b[i+1]+1) - list->at(a[i+1]+1) = c[i+1]) then d[i+1] else 0L endif) )  ;     i := i + 1 ) ; 
     ans := Set{ans, score}->max() ; 
     return ) else skip ; 
     if (not(list->isEmpty())) then (         var num : int ; num := list->at(list->size() - 1+1) ; while num <= m do ( (     list->excludes(num) ; 
     execute dfs(list) ; 
     list := list->excludingFirst(list->size() - 1) )  ;     num := num + 1 ) ) else (         var num : int ; num := 1 ; while num <= m do ( (     list->excludes(num) ; 
     execute dfs(list) ; 
     list := list->excludingFirst(list->size() - 1) )  ;     num := num + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Solution {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    StringTokenizer st=new StringTokenizer(br.readLine());
    int l=Integer.parseInt(st.nextToken());
    long x=0 ;
    long max=(long)Math.pow(2,29);
    max*=8 ;
    max--;
    long[] tab=new long[100000];
    tab[0]=1 ;
    int n=1 ;
    long[] sum=new long[100000];
    sum[0]=1 ;
    boolean ok=false ;
    for(int i=0 ; i<l ; i++){
      st=new StringTokenizer(br.readLine());
      char[] c=st.nextToken().toCharArray();
      if(c[0]=='a'){
        if(ok)continue ;
        if(sum[n-1]==0)ok=true ;
        x+=sum[n-1];
        if(x>max){
          ok=true ;
        }
      }
      else if(c[0]=='e'){
        if(ok)continue ;
        n--;
      }
      else {
        long k=Long.parseLong(st.nextToken());
        if(ok)continue ;
        tab[n]=k ;
        if(sum[n-1]<=max)sum[n]=sum[n-1]*k ;
        else sum[n]=0 ;
        n++;
      }
    }
    if(ok)out.println("OVERFLOW!!!");
    else out.println(x);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var l : int ; l := (st.next())->toInteger() ;
    var x : long ; x := 0 ;
    var max : long ; max := 2->pow(29)->oclAsType(long) ;
    max := max*(8) ; 
    max := max - 1 ; 
    var tab : Sequence(long) ; tab := Integer.subrange(1,100000)->collect(0) ;
    tab[0+1] := 1 ; 
    var n : int ; n := 1 ;
    var sum : Sequence(long) ; sum := Integer.subrange(1,100000)->collect(0) ;
    sum[0+1] := 1 ; 
    var ok : boolean ; ok := false ;
        var i : int ; i := 0 ; while i < l do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var c : Sequence(String) ; c := st.next()->characters() ;
     if (c[0+1] = 'a') then (     if (ok) then     continue else skip ; 
     if (sum[n - 1+1] = 0) then     ok := true ; else skip ; 
     x := x+(sum[n - 1+1]) ; 
     if (x > max) then (     ok := true ) else skip ) else     if (c[0+1] = 'e') then (     if (ok) then     continue else skip ; 
     n := n - 1 ) else (     var k : long ; k := (st.next())->toLong() ;
     if (ok) then     continue else skip ; 
    tab[n+1] := k ; 
    if (sum[n - 1+1] <= max) then     sum[n+1] := sum[n - 1+1] * k else     sum[n+1] := 0 ; ;  
    n := n + 1 ; 
 ) ;  )  ;     i := i + 1 ) ; 
    if (ok) then     skip else     skip ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new aoj1210().doIt();
  }
  class aoj1210 {
    int dice[]={
      1,5,4,3,2,6 };
      void turn(char c){
        switch(c){
          case 'n' : swap(0,4,5,1);
          break ;
          case 's' : swap(0,1,5,4);
          break ;
          case 'w' : swap(0,3,5,2);
          break ;
          case 'e' : swap(0,2,5,3);
          break ;
        }
      }
      void swap(int i,int j,int k,int l){
        int temp=dice[l];
        dice[l]=dice[k];
        dice[k]=dice[j];
        dice[j]=dice[i];
        dice[i]=temp ;
      }
      void doIt(){
        while(true){
          int n=sc.nextInt();
          for(int i=0 ; i<6 ; i++){
            if(i==0 || i==5)dice[i]=i+1 ;
            else dice[i]=6-i ;
          }
          if(n==0)break ;
          for(int i=0 ; i<n ; i++){
            String str=sc.next();
            turn(str.charAt(0));
          }
          System.out.println(dice[0]);
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     aoj1210.newaoj1210().doIt() );
 class aoj1210 {
   attribute dice : int := Sequence{1,5,4,3,2,6};
   operation turn( c : String) : void
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
       if _switchval = 'n' then
     execute swap(0, 4, 5, 1) ; 
    break 
   else skip ;
       if _switchval = 's' then
     execute swap(0, 1, 5, 4) ; 
    break 
   else skip ;
       if _switchval = 'w' then
     execute swap(0, 3, 5, 2) ; 
    break 
   else skip ;
       if _switchval = 'e' then
     execute swap(0, 2, 5, 3) ; 
    break 
   else skip ;
 )
 );
   operation swap( i : int, j : int, k : int, l : int) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := dice[l+1] ;
     dice[l+1] := dice[k+1] ; 
    dice[k+1] := dice[j+1] ; 
    dice[j+1] := dice[i+1] ; 
    dice[i+1] := temp ; 
 );
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < 6 do ( (     if (i = 0 or i = 5) then     dice[i+1] := i + 1 ; else     dice[i+1] := 6 - i ; )  ;     i := i + 1 ) ; 
    if (n = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := sc.getCurrent() ;
     execute turn(str->at(0+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dice[0+1]) ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner kbd=new Scanner(System.in);
  public static void main(String[] args){
    while(kbd.hasNext()){
      int n=kbd.nextInt();
      if(n!=0)solve(n);
    }
  }
  static void solve(int n){
    DiceR dice=new DiceR();
    while(n>0){
      String order=kbd.next();
      dice.rollO(order);
      n--;
    }
    System.out.println(dice.getTop());
  }
}
class DiceR {
  int[] dice ;
  public DiceR(){
    dice=new int[] {
      1,2,3,6,5,4 };
    }
    public void rollO(String order){
      if(order.equals("north")){
        roll(dice,1,0,4,3);
      }
      else if(order.equals("south")){
        roll(dice,4,0,1,3);
      }
      else if(order.equals("east")){
        roll(dice,5,0,2,3);
      }
      else if(order.equals("west")){
        roll(dice,2,0,5,3);
      }
    }
    private void roll(int[] dice,int a,int b,int c,int d){
      int p=dice[a];
      dice[a]=dice[b];
      dice[b]=dice[c];
      dice[c]=dice[d];
      dice[d]=p ;
    }
    public int getTop(){
      return dice[0];
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute kbd : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (kbd.hasNext()) do (     var n : int ; n := kbd.getCurrent()->toInteger() ;
     if (n /= 0) then     execute solve(n) ; else skip ) );
  static   operation solve( n : int) : void
  pre: true
  post: true
  activity: (     var dice : DiceR ; dice := DiceR.newDiceR() ;
     while (n > 0) do (     var order : String ; order := kbd.getCurrent() ;
     dice.rollO(order) ; 
     n := n - 1 ) ; 
     OclFile["System.out"].println(dice.getTop()) );
}
class DiceR {
   attribute dice : Sequence(int);
   static operation newDiceR() : DiceR
  pre: true
  post: true
  activity:
  ( var self : DiceR ;
    self := createDiceR();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     dice := Sequence{1,2,3,6,5,4} );
   operation rollO( order : String) : void
  pre: true
  post: true
  activity: (     if (order = "north") then (     execute roll(dice, 1, 0, 4, 3) ) else     if (order = "south") then (     execute roll(dice, 4, 0, 1, 3) ) else     if (order = "east") then (     execute roll(dice, 5, 0, 2, 3) ) else     if (order = "west") then (     execute roll(dice, 2, 0, 5, 3) ) else skip ; ;  ;  );
   operation roll( dice : Sequence(int), a : int, b : int, c : int, d : int) : void
  pre: true
  post: true
  activity: (     var p : int ; p := dice[a+1] ;
     dice[a+1] := dice[b+1] ; 
    dice[b+1] := dice[c+1] ; 
    dice[c+1] := dice[d+1] ; 
    dice[d+1] := p ; 
 );
   operation getTop() : int
  pre: true
  post: true
  activity: (     return dice[0+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    while(true){
      int N=sc.nextInt();
      if(N==0)break ;
      Die d=new Die();
      while(N-->0){
        String str=sc.next();
        switch(str.charAt(0)){
          case 'n' : d.north();
          break ;
          case 'e' : d.east();
          break ;
          case 'w' : d.west();
          break ;
          case 's' : d.south();
          break ;
          default : break ;
        }
      }
      System.out.println(d.top);
    }
  }
  public static class Die {
    int top ;
    int bottom ;
    int north ;
    int south ;
    int east ;
    int west ;
    public Die(){
      top=1 ;
      north=2 ;
      west=3 ;
      bottom=6 ;
      south=5 ;
      east=4 ;
    }
    public void north(){
      int tmp=north ;
      north=top ;
      top=south ;
      south=bottom ;
      bottom=tmp ;
    }
    public void south(){
      int tmp=south ;
      south=top ;
      top=north ;
      north=bottom ;
      bottom=tmp ;
    }
    public void east(){
      int tmp=east ;
      east=top ;
      top=west ;
      west=bottom ;
      bottom=tmp ;
    }
    public void west(){
      int tmp=west ;
      west=top ;
      top=east ;
      east=bottom ;
      bottom=tmp ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then     break else skip ; 
    var d : Die ; d := Die.newDie() ;
        while (N > 0) do (        N := N - 1 ;     skip ; (     var str : String ; str := sc.getCurrent() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (str->at(0+1)) ; 
       if _switchval = 'n' then
     d.north() ; 
    break 
   else skip ;
       if _switchval = 'e' then
     d.east() ; 
    break 
   else skip ;
       if _switchval = 'w' then
     d.west() ; 
    break 
   else skip ;
       if _switchval = 's' then
     d.south() ; 
    break 
   else skip ;
       if true then
     break 
   else skip ;
 )
 ) ;  ) ;  
    OclFile["System.out"].println(d.top) ; 
 ) );
  static class Die {
   attribute top : int;
   attribute bottom : int;
   attribute north : int;
   attribute south : int;
   attribute east : int;
   attribute west : int;
   static operation newDie() : Die
  pre: true
  post: true
  activity:
  ( var self : Die ;
    self := createDie();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     top := 1 ; 
     north := 2 ; 
    west := 3 ; 
    bottom := 6 ; 
    south := 5 ; 
    east := 4 ; 
 );
   operation north() : void
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := north ;
     north := top ; 
    top := south ; 
    south := bottom ; 
    bottom := tmp ; 
 );
   operation south() : void
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := south ;
     south := top ; 
    top := north ; 
    north := bottom ; 
    bottom := tmp ; 
 );
   operation east() : void
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := east ;
     east := top ; 
    top := west ; 
    west := bottom ; 
    bottom := tmp ; 
 );
   operation west() : void
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := west ;
     west := top ; 
    top := east ; 
    east := bottom ; 
    bottom := tmp ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.ListIterator ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    while(true){
      final int n=sc.nextInt();
      if(n==0){
        break ;
      }
      int top=1 ;
      int north=2 ;
      int west=3 ;
      for(int i=0 ; i<n ; i++){
        String input=sc.next();
        if("north".equals(input)){
          int next_top=7-north ;
          int next_north=top ;
          top=next_top ;
          north=next_north ;
        }
        else if("south".equals(input)){
          int next_top=north ;
          int next_north=7-top ;
          top=next_top ;
          north=next_north ;
        }
        else if("east".equals(input)){
          int next_top=west ;
          int next_west=7-top ;
          top=next_top ;
          west=next_west ;
        }
        else if("west".equals(input)){
          int next_top=7-west ;
          int next_west=top ;
          top=next_top ;
          west=next_west ;
        }
      }
      System.out.println(top);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var top : int ; top := 1 ;
    var north : int ; north := 2 ;
    var west : int ; west := 3 ;
        var i : int ; i := 0 ; while i < n do ( (     var input : String ; input := sc.getCurrent() ;
     if ("north" = input) then (     var next_top : int ; next_top := 7 - north ;
     var next_north : int ; next_north := top ;
     top := next_top ; 
     north := next_north ) else     if ("south" = input) then (     var next_top : int ; next_top := north ;
     var next_north : int ; next_north := 7 - top ;
     top := next_top ; 
     north := next_north ) else     if ("east" = input) then (     var next_top : int ; next_top := west ;
     var next_west : int ; next_west := 7 - top ;
     top := next_top ; 
     west := next_west ) else     if ("west" = input) then (     var next_top : int ; next_top := 7 - west ;
     var next_west : int ; next_west := top ;
     top := next_top ; 
     west := next_west ) else skip ; ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(top) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class deviation {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        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().trim();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  static class FastWriter {
    private final BufferedWriter bw ;
    public FastWriter(){
      this.bw=new BufferedWriter(new OutputStreamWriter(System.out));
    }
    public void print(Object object)throws IOException {
      bw.append(""+object);
    }
    public void println(Object object)throws IOException {
      print(object);
      bw.append("\n");
    }
    public void close()throws IOException {
      bw.close();
    }
  }
  public static void main(String[] args){
    try {
      FastReader in=new FastReader();
      FastWriter out=new FastWriter();
      int t=in.nextInt();
      while(t-->0){
        int a1=in.nextInt();
        int a2=in.nextInt();
        int a3=in.nextInt();
        System.out.println((a1+a3-2*a2)% 3==0 ? 0 : 1);
      }
      out.close();
    }
    catch(Exception e){
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class deviation {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine()->trim() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return str );
}
  static class FastWriter {
   attribute bw : OclFile;
   static operation newFastWriter() : FastWriter
  pre: true
  post: true
  activity:
  ( var self : FastWriter ;
    self := createFastWriter();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) );
   operation print( object : OclAny) : void
  pre: true
  post: true
  activity: (     skip );
   operation println( object : OclAny) : void
  pre: true
  post: true
  activity: (     execute print(object) ; 
     skip );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : FastWriter ; out := FastWriter.newFastWriter() ;
    var t : int ; t := in.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var a1 : int ; a1 := in.nextInt() ;
     var a2 : int ; a2 := in.nextInt() ;
     var a3 : int ; a3 := in.nextInt() ;
     OclFile["System.out"].println(if (a1 + a3 - 2 * a2) mod 3 = 0 then 0 else 1 endif) ) ;  ) ;  
    out.close() ; 
 )   catch (e : ProgramException) do (     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String[] tmpArray=br.readLine().split(" ");
      int n=Integer.parseInt(tmpArray[0]);
      int m=Integer.parseInt(tmpArray[1]);
      if(n==0 && m==0){
        break ;
      }
      int[] code=new int[m];
      for(int i=0 ; i<m ; i++){
        code[i]=Integer.parseInt(br.readLine());
      }
      int[] signal=new int[n];
      for(int i=0 ; i<n ; i++){
        signal[i]=Integer.parseInt(br.readLine());
      }
      int[][] dp=new int[256][n+1];
      for(int i=0 ; i<=255 ; i++){
        Arrays.fill(dp[i],Integer.MAX_VALUE);
      }
      dp[128][0]=0 ;
      for(int i=1 ; i<=n ; i++){
        for(int j=0 ; j<=255 ; j++){
          if(dp[j][i-1]==Integer.MAX_VALUE){
            continue ;
          }
          for(int k=0 ; k<m ; k++){
            int tmpValue=Math.min(255,Math.max(0,j+code[k]));
            dp[tmpValue][i]=Math.min(dp[tmpValue][i],dp[j][i-1]+(int)Math.pow((tmpValue-signal[i-1]),2));
          }
        }
      }
      int result=Integer.MAX_VALUE ;
      for(int i=0 ; i<=255 ; i++){
        result=Math.min(result,dp[i][n]);
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
     var n : int ; n := (tmpArray[0+1])->toInteger() ;
    var m : int ; m := (tmpArray[1+1])->toInteger() ;
    if (n = 0 & m = 0) then (     break ) else skip ; 
    var code : Sequence(int) ; code := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     code[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    var signal : Sequence(int) ; signal := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     signal[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,256)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i <= 255 do ( (     dp[i+1] := dp[i+1]->collect(2147483647) )  ;     i := i + 1 ) ; 
    dp[128+1][0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= 255 do ( (     if (dp[j+1][i - 1+1] = 2147483647) then (     continue ) else skip ; 
         var k : int ; k := 0 ; while k < m do ( (     var tmpValue : int ; tmpValue := Set{255, Set{0, j + code[k+1]}->max()}->min() ;
     dp[tmpValue+1][i+1] := Set{dp[tmpValue+1][i+1], dp[j+1][i - 1+1] + (tmpValue - signal[i - 1+1])->pow(2)->oclAsType(int)}->min() )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var result : int ; result := 2147483647 ;
        var i : int ; i := 0 ; while i <= 255 do ( (     result := Set{result, dp[i+1][n+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        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().trim();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  static class FastWriter {
    private final BufferedWriter bw ;
    public FastWriter(){
      this.bw=new BufferedWriter(new OutputStreamWriter(System.out));
    }
    public void print(Object object)throws IOException {
      bw.append(""+object);
    }
    public void println(Object object)throws IOException {
      print(object);
      bw.append("\n");
    }
    public void close()throws IOException {
      bw.close();
    }
  }
  public static void main(String[] args){
    try {
      FastReader sc=new FastReader();
      FastWriter sout=new FastWriter();
      int testCases=sc.nextInt();
      while(testCases-->0){
        int a=sc.nextInt();
        int b=sc.nextInt();
        int c=sc.nextInt();
        int am=a+c-(2*b);
        if(am % 3==0)sout.println(0);
        else sout.println(1);
      }
      sout.close();
    }
    catch(Exception e){
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine()->trim() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return str );
}
  static class FastWriter {
   attribute bw : OclFile;
   static operation newFastWriter() : FastWriter
  pre: true
  post: true
  activity:
  ( var self : FastWriter ;
    self := createFastWriter();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) );
   operation print( object : OclAny) : void
  pre: true
  post: true
  activity: (     skip );
   operation println( object : OclAny) : void
  pre: true
  post: true
  activity: (     execute print(object) ; 
     skip );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var sout : FastWriter ; sout := FastWriter.newFastWriter() ;
    var testCases : int ; testCases := sc.nextInt() ;
        while (testCases > 0) do (        testCases := testCases - 1 ;     skip ; (     var a : int ; a := sc.nextInt() ;
     var b : int ; b := sc.nextInt() ;
    var c : int ; c := sc.nextInt() ;
    var am : int ; am := a + c - (2 * b) ;
    if (am mod 3 = 0) then     sout.println(0) else     sout.println(1) ; ;  
 ) ;  ) ;  
    sout.close() ; 
 )   catch (e : ProgramException) do (     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String s[]=sc.nextLine().split(" ");
    int n=Integer.parseInt(s[0]);
    int m=Integer.parseInt(s[1]);
    int q=Integer.parseInt(s[2]);
    ArrayList<Pair>ch=new ArrayList<>();
    for(int i=0 ; i<q ; i++){
      String h[]=sc.nextLine().split(" ");
      ch.add(new Pair(Integer.parseInt(h[0]),Integer.parseInt(h[1]),Integer.parseInt(h[2]),Integer.parseInt(h[3])));
    }
    System.out.println(get(new int[n],1,0,ch,m));
  }
  static int get(int[] arr,int k,int i,ArrayList<Pair>ch,int m){
    if(i==arr.length){
      int sum=0 ;
      for(int u=0 ; u<ch.size(); u++){
        if(arr[ch.get(u).b-1]-arr[ch.get(u).a-1]==ch.get(u).c){
          sum+=ch.get(u).d ;
        }
      }
      return sum ;
    }
    int max=0 ;
    for(int u=k ; u<=m ; u++){
      arr[i]=u ;
      max=Math.max(max,get(arr,u,i+1,ch,m));
    }
    return max ;
  }
}
class Pair {
  int a ;
  int b ;
  int c ;
  int d ;
  Pair(int e,int f,int g,int h){
    a=e ;
    b=f ;
    c=g ;
    d=h ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc.nextLine()->split(" ") ;
    var n : int ; n := (s[0+1])->toInteger() ;
    var m : int ; m := (s[1+1])->toInteger() ;
    var q : int ; q := (s[2+1])->toInteger() ;
    var ch : Sequence(Map) ; ch := Sequence{} ;
        var i : int ; i := 0 ; while i < q do ( (     var h : Sequence(String) ; h := sc.nextLine()->split(" ") ;
     ch := ch->including(Map((h[0+1])->toInteger(), (h[1+1])->toInteger(), (h[2+1])->toInteger(), (h[3+1])->toInteger())) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(at(Integer.subrange(1,n)->collect(0), 1, 0, ch, m+1)) ; 
 );
  static   operation get( arr : Sequence(int), k : int, i : int, ch : Sequence(Map), m : int) : int
  pre: true
  post: true
  activity: (     if (i = arr->size()) then (     var sum : int ; sum := 0 ;
         var u : int ; u := 0 ; while u < ch->size() do ( (     if (arr[ch->at(u+1).b - 1+1] - arr[ch->at(u+1).a - 1+1] = ch->at(u+1).c) then (     sum := sum+(ch->at(u+1).d) ) else skip )  ;     u := u + 1 ) ; 
     return sum ) else skip ; 
     var max : int ; max := 0 ;
         var u : int ; u := k ; while u <= m do ( (     arr[i+1] := u ; 
     max := Set{max, at(arr, u, i + 1, ch, m+1)}->max() )  ;     u := u + 1 ) ; 
     return max );
}
class Pair {
   attribute a : int;
   attribute b : int;
   attribute c : int;
   attribute d : int;
   static operation newPair( e : int, f : int, g : int, h : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(e, f,g,h);
    return self );
  operation initialise( e : int, f : int, g : int, h : int) : void
  pre: true  post: true
  activity: (     a := e ; 
     b := f ; 
     c := g ; 
     d := h );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.util.Arrays ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner scan=new Scanner(System.in);
    int T=scan.nextInt();
    for(int i=0 ; i<T ; i++){
      long a=scan.nextLong();
      long b=scan.nextLong();
      long c=scan.nextLong();
      long sum=a+c ;
      long mul=2*b ;
      long ans=Math.abs((int)sum-(int)mul);
      if(ans % 3==0){
        System.out.println(0);
      }
      else {
        System.out.println(1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < T do ( (     var a : long ; a := scan.getCurrent()->toLong() ;
     var b : long ; b := scan.getCurrent()->toLong() ;
    var c : long ; c := scan.getCurrent()->toLong() ;
    var sum : long ; sum := a + c ;
    var mul : long ; mul := 2 * b ;
    var ans : long ; ans := if sum->oclAsType(int) - mul->oclAsType(int) < 0 then -(sum->oclAsType(int) - mul->oclAsType(int)) else sum->oclAsType(int) - mul->oclAsType(int) endif ;
    if (ans mod 3 = 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(1) ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void finalString(String str){
    int x=0,y=0 ;
    int left ;
    int n=str.length();
    for(int i=0 ; i<n ; i++){
      if(str.charAt(i)=='1')x++;
      else y++;
    }
    if(x>y)left=1 ;
    else left=0 ;
    int length=n-2*Math.min(x,y);
    for(int i=0 ; i<length ; i++){
      System.out.print(left);
    }
  }
  public static void main(String[] args){
    String str="010110100100000" ;
    finalString(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation finalString( str : String) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 0 ;
    var y : int ; y := 0 ;
     var left : int ;
    var n : int ; n := str->size() ;
        var i : int ; i := 0 ; while i < n do ( (     if (str->at(i+1) = '1') then     x := x + 1 ; else     y := y + 1 ; )  ;     i := i + 1 ) ; 
    if (x > y) then     left := 1 else     left := 0 ; ;  
    var length : int ; length := n - 2 * Set{x, y}->min() ;
        var i : int ; i := 0 ; while i < length do ( (     OclFile["System.out"].print(left) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "010110100100000" ;
     execute finalString(str) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    if(s.equals("ani")){
      System.out.println("square1001");
    }
    else {
      System.out.println("e869120");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
     if (s = "ani") then (     OclFile["System.out"].println("square1001") ) else (     OclFile["System.out"].println("e869120") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.nio.charset.MalformedInputException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    if(n % 2==0){
      out.println(n/2-1);
    }
    else {
      out.println(n/2);
    }
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    if (n mod 2 = 0) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int ans=0 ;
    if(n % 2==0){
      ans=n/2-1 ;
    }
    else {
      ans=n/2 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    if (n mod 2 = 0) then (     ans := n / 2 - 1 ) else (     ans := n / 2 ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedOutputStream ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class FindAmir {
  public static BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  public static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
  public static StringTokenizer st ;
  public static void main(String[] args)throws IOException {
    int n=nextInt();
    System.out.println((n-1)/2);
  }
  public static String nextLine()throws IOException {
    return in.readLine();
  }
  public static String nextString()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(in.readLine());
    return st.nextToken();
  }
  public static int nextInt()throws IOException {
    return Integer.parseInt(nextString());
  }
  public static long nextLong()throws IOException {
    return Long.parseLong(nextString());
  }
  public static int[] intArray(int n)throws IOException {
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public static int[][] intArray(int n,int m)throws IOException {
    int[][] a=new int[n][m];
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<m ; j++)a[i][j]=nextInt();
    return a ;
  }
  public static long[] longArray(int n)throws IOException {
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=nextLong();
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class FindAmir {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute st : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     OclFile["System.out"].println((n - 1) / 2) );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     return in.readLine() );
  static   operation nextString() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(in.readLine()) ; ; 
     return st.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextString())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextString())->toLong() );
  static   operation intArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
  static   operation intArray( n : int, m : int) : Sequence(Sequence(int))
  pre: true
  post: true
  activity: (     var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < m do (     a[i+1][j+1] := nextInt() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return a );
  static   operation longArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class Rextester {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=new Integer(br.readLine());
    if(n % 2==0){
      System.out.println((n/2)-1);
    }
    else {
      System.out.println(n/2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Rextester {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := ("" + (br.readLine()))->toInteger() ;
     if (n mod 2 = 0) then (     OclFile["System.out"].println((n / 2) - 1) ) else (     OclFile["System.out"].println(n / 2) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    if(t % 2==1)System.out.println(t/2);
    else System.out.println(t/2-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     if (t mod 2 = 1) then     OclFile["System.out"].println(t / 2) ; else     OclFile["System.out"].println(t / 2 - 1) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static long getClosest(int a,int b,int x){
    long num=(long)Math.pow(a,b);
    int floor=(int)(num/x);
    long numOnLeft=x*floor ;
    long numOnRight=x*(floor+1);
    if((num-numOnLeft)<(numOnRight-num)){
      return numOnLeft ;
    }
    else {
      return numOnRight ;
    }
  }
  public static void main(String[] args){
    int a=349,b=1,x=4 ;
    System.out.println(getClosest(a,b,x));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getClosest( a : int, b : int, x : int) : long
  pre: true
  post: true
  activity: (     var num : long ; num := a->pow(b)->oclAsType(long) ;
     var floor : int ; floor := (num / x)->oclAsType(int) ;
    var numOnLeft : long ; numOnLeft := x * floor ;
    var numOnRight : long ; numOnRight := x * (floor + 1) ;
    if ((num - numOnLeft) < (numOnRight - num)) then (     return numOnLeft ) else (     return numOnRight ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 349 ;
    var b : int ; b := 1 ;
    var x : int ; x := 4 ;
     OclFile["System.out"].println(getClosest(a, b, x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    while(true){
      int N=sc.nextInt();
      if(N==0)break ;
      int M=sc.nextInt();
      int[] C=new int[M];
      for(int i=0 ; i<M ; ++i){
        C[i]=sc.nextInt();
      }
      int[] X=new int[N];
      for(int i=0 ; i<N ; ++i){
        X[i]=sc.nextInt();
      }
      int[][] dp=new int[2][256];
      Arrays.fill(dp[0],1<<30);
      dp[0][128]=0 ;
      int t=0 ;
      for(int i=0 ; i<N ; ++i){
        Arrays.fill(dp[1-t],1<<30);
        for(int j=0 ; j<256 ; ++j){
          for(int k=0 ; k<M ; ++k){
            int next=j+C[k];
            if(next<0)next=0 ;
            if(next>255)next=255 ;
            dp[1-t][next]=Math.min(dp[1-t][next],dp[t][j]+(X[i]-next)*(X[i]-next));
          }
        }
        t=1-t ;
      }
      int ans=Integer.MAX_VALUE ;
      for(int i=0 ; i<256 ; ++i){
        ans=Math.min(ans,dp[t][i]);
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then     break else skip ; 
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var C : Sequence(int) ; C := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     C[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var X : Sequence(int) ; X := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     X[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,256)->collect(0)) ;
    dp[0+1] := dp[0+1]->collect((1*(2->pow(30)))->oclAsType(long)) ; 
    dp[0+1][128+1] := 0 ; 
    var t : int ; t := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     dp[1 - t+1] := dp[1 - t+1]->collect((1*(2->pow(30)))->oclAsType(long)) ; 
         var j : int ; j := 0 ; while j < 256 do ( (         var k : int ; k := 0 ; while k < M do ( (     var next : int ; next := j + C[k+1] ;
     if (next < 0) then     next := 0 ; else skip ; 
     if (next > 255) then     next := 255 ; else skip ; 
     dp[1 - t+1][next+1] := Set{dp[1 - t+1][next+1], dp[t+1][j+1] + (X[i+1] - next) * (X[i+1] - next)}->min() )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
     t := 1 - t )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i < 256 do ( (     ans := Set{ans, dp[t+1][i+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int fastPow(int N,int K){
    if(K==0)return 1 ;
    int temp=fastPow(N,K/2);
    if(K % 2==0)return temp*temp ;
    else return N*temp*temp ;
  }
  static int countWays(int N,int K){
    return K*fastPow(K-1,N-1);
  }
  public static void main(String[] args){
    int N=3,K=3 ;
    System.out.println(countWays(N,K));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fastPow( N : int, K : int) : int
  pre: true
  post: true
  activity: (     if (K = 0) then     return 1 else skip ; 
     var temp : int ; temp := fastPow(N, K / 2) ;
     if (K mod 2 = 0) then     return temp * temp else     return N * temp * temp );
  static   operation countWays( N : int, K : int) : int
  pre: true
  post: true
  activity: (     return K * fastPow(K - 1, N - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
    var K : int ; K := 3 ;
     OclFile["System.out"].println(countWays(N, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
public class Main {
  static final Map<Long,Integer>primes=new HashMap<>();
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    while(N>1){
      if(N % 2L!=0L)break ;
      add(2L);
      N/=2L ;
      continue ;
    }
    long div=3L ;
    while(N>1 && div*div<=N){
      if(N % div!=0L){
        div+=2L ;
        continue ;
      }
      add(div);
      N/=div ;
    }
    if(N>1){
      add(N);
    }
    int count=0 ;
    for(long key : primes.keySet()){
      int c=primes.get(key);
      int t=1 ;
      while(c>=t){
        count++;
        c-=t ;
        t++;
      }
    }
    System.out.println(count);
  }
  static void add(long t){
    if(primes.containsKey(t)){
      int pow=primes.get(t);
      primes.put(t,pow+1);
    }
    else {
      primes.put(t,1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute primes : Map(long,int) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    while (N > 1) do (     if (N mod 2L /= 0L) then     break else skip ; 
     execute add(2L) ; 
     N := N/(2L) ; 
     continue ) ; 
    var div : long ; div := 3L ;
    while (N > 1 & div * div <= N) do (     if (N mod div /= 0L) then (     div := div+(2L) ; 
     continue ) else skip ; 
     execute add(div) ; 
     N := N/(div) ) ; 
    if (N > 1) then (     execute add(N) ) else skip ; 
    var count : int ; count := 0 ;
    for (key : primes->keys()) do ( (     var c : int ; c := primes->at(key) ;
     var t : int ; t := 1 ;
     while (c >= t) do (     count := count + 1 ; 
     c := c-(t) ; 
     t := t + 1 ) )  ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation add( t : long) : void
  pre: true
  post: true
  activity: (     if (primes->keys()->includes(t)) then (     var pow : int ; pow := primes->at(t) ;
     primes := primes->union(Map{t |-> pow + 1}) ) else (     primes := primes->union(Map{t |-> 1}) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int n=input.nextInt();
    String s=input.next();
    TreeSet<Integer>set=new TreeSet<>();
    for(int i=1 ; i*i<=n ; i++){
      if(n % i==0){
        set.add(i);
        if(n/i!=i){
          set.add(n/i);
        }
      }
    }
    while(! set.isEmpty()){
      int now=set.pollFirst();
      String left=s.substring(0,now);
      String right=s.substring(now);
      StringBuilder result=new StringBuilder(left);
      left=result.reverse().toString();
      s=left+""+right ;
    }
    System.out.println(s);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var n : int ; n := input.nextInt() ;
    var s : String ; s := input.next() ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     set := set->including(i) ; 
     if (n / i /= i) then (     set := set->including(n / i) ) else skip ) else skip )  ;     i := i + 1 ) ; 
    while (not(set->isEmpty())) do (     var now : int ; now := set->first() ;
     var left : String ; left := s.subrange(0+1,now) ;
    var right : String ; right := s.subrange(now+1,now) ;
    var result : String ; result := StringLib.newString(left) ;
    left := result->reverse()+"" ; 
    s := left + "" + right ; 
 ) ; 
    OclFile["System.out"].println(s) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static long goukei=0 ;
  static long MAX=0 ;
  static Scanner scan=new Scanner(System.in);
  static int N=scan.nextInt();
  static int[] A=new int[N];
  static int M=scan.nextInt();
  static int Q=scan.nextInt();
  static int[] g=new int[Q];
  static int[] b=new int[Q];
  static int[] c=new int[Q];
  static int[] d=new int[Q];
  public static void main(String[] args){
    for(int i=0 ; i<Q ; i++){
      g[i]=scan.nextInt();
      b[i]=scan.nextInt();
      c[i]=scan.nextInt();
      d[i]=scan.nextInt();
    }
    ho(A,0);
    System.out.println(MAX);
  }
  private static void ho(int[] a,int N){
    if(N==a.length){
      for(int i=0 ; i<N ; i++){
      }
      goukei=0 ;
      for(int i=0 ; i<Q ; i++){
        if(a[b[i]-1]-a[g[i]-1]==c[i]){
          goukei+=(long)d[i];
        }
      }
      if(MAX<goukei)MAX=goukei ;
    }
    else if(N==0){
      for(int i=1 ; i<=M ; i++){
        a[N]=i ;
        ho(a,N+1);
      }
    }
    else {
      for(int i=a[N-1]; i<=M ; i++){
        a[N]=i ;
        ho(a,N+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute goukei : long := 0;
  static   attribute MAX : long := 0;
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int := scan.getCurrent()->toInteger();
  static   attribute A : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static   attribute M : int := scan.getCurrent()->toInteger();
  static   attribute Q : int := scan.getCurrent()->toInteger();
  static   attribute g : Sequence(int) := Integer.subrange(1,Q)->collect(0);
  static   attribute b : Sequence(int) := Integer.subrange(1,Q)->collect(0);
  static   attribute c : Sequence(int) := Integer.subrange(1,Q)->collect(0);
  static   attribute d : Sequence(int) := Integer.subrange(1,Q)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < Q do ( (     g[i+1] := scan.getCurrent()->toInteger() ; 
     b[i+1] := scan.getCurrent()->toInteger() ; 
     c[i+1] := scan.getCurrent()->toInteger() ; 
     d[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     execute ho(A, 0) ; 
     OclFile["System.out"].println(MAX) );
  static   operation ho( a : Sequence(int), N : int) : void
  pre: true
  post: true
  activity: (     if (N = a->size()) then (         var i : int ; i := 0 ; while i < N do ( skip  ;     i := i + 1 ) ; 
     goukei := 0 ; 
         var i : int ; i := 0 ; while i < Q do ( (     if (a[b[i+1] - 1+1] - a[g[i+1] - 1+1] = c[i+1]) then (     goukei := goukei+(d[i+1]->oclAsType(long)) ) else skip )  ;     i := i + 1 ) ; 
     if (MAX < goukei) then     MAX := goukei ; else skip ) else     if (N = 0) then (         var i : int ; i := 1 ; while i <= M do ( (     a[N+1] := i ; 
     execute ho(a, N + 1) )  ;     i := i + 1 ) ) else (         var i : int ; i := a[N - 1+1] ; while i <= M do ( (     a[N+1] := i ; 
     execute ho(a, N + 1) )  ;     i := i + 1 ) ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int[] merry={
      4,1,4,1,2,1,2,1 };
      String line ;
      String[] input ;
      int[] customer=new int[8];
      while((line=br.readLine())!=null){
        input=line.split(" ");
        for(int i=0 ; i<8 ; i++){
          customer[i]=Integer.parseInt(input[i]);
        }
        int answer=-1 ;
        int V=0 ;
        int min=Integer.MAX_VALUE ;
        int tens ;
        for(int i=0 ; i<8 ; i++){
          tens=10000000 ;
          int score=0 ;
          int tmpv=0 ;
          for(int j=0 ; j<8 ; j++){
            score+=Math.max(0,merry[(i+j)% 8]-customer[j]);
            tmpv+=tens*merry[(i+j)% 8];
            tens/=10 ;
          }
          if(min==score && tmpv<V){
            answer=i ;
            V=tmpv ;
            min=score ;
          }
          else if(score<min){
            answer=i ;
            V=tmpv ;
            min=score ;
          }
        }
        for(int i=0 ; i<8 ; i++){
          if(i==0)System.out.print(merry[answer]);
          else System.out.print(" "+merry[(answer+i)% 8]);
        }
        System.out.println();
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var merry : Sequence(int) ; merry := Sequence{4,1,4,1,2,1,2,1} ;
    var line : String ;
    var input : Sequence(String) ;
    var customer : Sequence(int) ; customer := Integer.subrange(1,8)->collect(0) ;
        line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     input := line->split(" ") ; 
         var i : int ; i := 0 ; while i < 8 do ( (     customer[i+1] := (input[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var answer : int ; answer := -1 ;
    var V : int ; V := 0 ;
    var min : int ; min := 2147483647 ;
    var tens : int ;
        var i : int ; i := 0 ; while i < 8 do ( (     tens := 10000000 ; 
     var score : int ; score := 0 ;
    var tmpv : int ; tmpv := 0 ;
        var j : int ; j := 0 ; while j < 8 do ( (     score := score+(Set{0, merry[(i + j) mod 8+1] - customer[j+1]}->max()) ; 
     tmpv := tmpv+(tens * merry[(i + j) mod 8+1]) ; 
     tens := tens/(10) )  ;     j := j + 1 ) ; 
    if (min = score & tmpv < V) then (     answer := i ; 
     V := tmpv ; 
     min := score ) else     if (score < min) then (     answer := i ; 
     V := tmpv ; 
     min := score ) else skip ; ;  
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 8 do ( (     if (i = 0) then     OclFile["System.out"].print(merry[answer+1]) ; else     OclFile["System.out"].print(" " + merry[(answer + i) mod 8+1]) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;     line := br.readLine() ;
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=null ;
    int[] num={
      1,4,1,4,1,2,1,2,1,4,1,4,1,2,1 };
      try {
        stdIn=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
        while(stdIn.hasNext()){
          int[] data=new int[8];
          for(int i=0 ; i<8 ; i++){
            data[i]=stdIn.nextInt();
          }
          int min=-1 ;
          String key=new String();
          for(int i=0 ; i<8 ; i++){
            int sum=0 ;
            for(int j=0 ; j<8 ; j++){
              sum+=(data[j]>num[i+j])?(data[j]-num[i+j]): 0 ;
            }
            if(min<0 || sum<=min){
              StringBuilder key2=new StringBuilder();
              for(int j=0 ; j<8 ; j++){
                key2.append(Integer.toString(num[i+j]));
              }
              if(sum<min){
                key=new String(key2.toString());
              }
              else if(key.equals("")|| Integer.parseInt(key2.toString())<Integer.parseInt(key)){
                key=new String(key2.toString());
              }
              min=sum ;
            }
          }
          for(int i=0 ; i<7 ; i++){
            System.out.print(key.charAt(i)+" ");
          }
          System.out.println(key.charAt(7));
        }
      }
      finally {
        if(stdIn!=null){
          stdIn.close();
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := null ;
     var num : Sequence(int) ; num := Sequence{1,4,1,4,1,2,1,2,1,4,1,4,1,2,1} ;
     try (     stdIn := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
     while (stdIn.hasNext()) do (     var data : Sequence(int) ; data := Integer.subrange(1,8)->collect(0) ;
         var i : int ; i := 0 ; while i < 8 do ( (     data[i+1] := stdIn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var min : int ; min := -1 ;
    var key : String ; key := StringLib.newString() ;
        var i : int ; i := 0 ; while i < 8 do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < 8 do ( (     sum := sum+(if (data[j+1] > num[i + j+1]) then (data[j+1] - num[i + j+1]) else 0 endif) )  ;     j := j + 1 ) ; 
     if (min < 0 or sum <= min) then (     var key2 : String ; key2 := StringLib.newString() ;
         var j : int ; j := 0 ; while j < 8 do ( (     key2 := key2 + StringLib.newString(((num[i + j+1]) + "")) )  ;     j := j + 1 ) ; 
     if (sum < min) then (     key := StringLib.newString(key2+"") ) else     if (key = "" or (key2+"")->toInteger() < (key)->toInteger()) then (     key := StringLib.newString(key2+"") ) else skip ; ;  
     min := sum ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 7 do ( (     OclFile["System.out"].print(key->at(i+1) + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(key->at(7+1)) ; 
 ) )   finally (     if (stdIn /= null) then (     skip ) else skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  void run(){
    sc=new Scanner(System.in);
    for(; sc.hasNext(); ){
      int[] c={
        4,1,4,1,2,1,2,1 };
        int[] p=new int[8];
        for(int i=0 ; i<8 ; i++)p[i]=sc.nextInt();
        int min=Integer.MAX_VALUE ;
        LinkedList<String>list=new LinkedList<String>();
        for(int j=0 ; j<8 ; j++){
          int sum=0 ;
          for(int i=0 ; i<8 ; i++)sum+=max(c[(i+j)% 8]-p[i],0);
          if(sum<=min){
            if(sum<min)list.clear();
            String s="" ;
            for(int i=0 ; i<7 ; i++)s+=c[(i+j)% 8]+" " ;
            s+=c[(7+j)% 8];
            list.add(s);
            min=sum ;
          }
        }
        String[] ss=list.toArray(new String[0]);
        sort(ss);
        println(ss[0]);
      }
      sc.close();
    }
    void print(String s){
      System.out.print(s);
    }
    void println(String s){
      System.out.println(s);
    }
    public static void main(String[] args){
      new Main().run();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
       while sc.hasNext() do ( (     var c : Sequence(int) ; c := Sequence{4,1,4,1,2,1,2,1} ;
     var p : Sequence(int) ; p := Integer.subrange(1,8)->collect(0) ;
        var i : int ; i := 0 ; while i < 8 do (     p[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
    var list : Sequence(String) ; list := Sequence{} ;
        var j : int ; j := 0 ; while j < 8 do ( (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < 8 do (     sum := sum+(Set{c[(i + j) mod 8+1] - p[i+1], 0}->max()) ;  ;     i := i + 1 ) ; 
     if (sum <= min) then (     if (sum < min) then     list := list->intersection(Set{}) ; else skip ; 
     var s : String ; s := "" ;
        var i : int ; i := 0 ; while i < 7 do (     s := s+(c[(i + j) mod 8+1] + " ") ;  ;     i := i + 1 ) ; 
    s := s+(c[(7 + j) mod 8+1]) ; 
    list := list->including(s) ; 
    min := sum ; 
 ) else skip )  ;     j := j + 1 ) ; 
    var ss : Sequence(String) ; ss := list->asSequence() ;
    execute sort(ss) ; 
    execute println(ss[0+1]) ; 
 )  ) ; 
     skip );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int[][] array={
    {
      1,2,1,2,1,4,1,4 },{
        1,2,1,4,1,4,1,2 },{
          1,4,1,2,1,2,1,4 },{
            1,4,1,4,1,2,1,2 },{
              2,1,2,1,4,1,4,1 },{
                2,1,4,1,4,1,2,1 },{
                  4,1,2,1,2,1,4,1 },{
                    4,1,4,1,2,1,2,1 }
                  };
                  public static void main(String[] args){
                    Scanner sc=new Scanner(System.in);
                    while(sc.hasNext()){
                      int[] input=new int[8];
                      String[] str=sc.nextLine().split(" ");
                      for(int i=0 ; i<8 ; i++){
                        input[i]=Integer.parseInt(str[i]);
                      }
                      int[] edit=new int[8];
                      int min=Integer.MAX_VALUE ;
                      int min_num=-1 ;
                      for(int i=0 ; i<8 ; i++){
                        for(int j=0 ; j<8 ; j++){
                          edit[j]=input[j]-array[i][j];
                          if(edit[j]<0){
                            edit[j]=0 ;
                          }
                        }
                        int sum=0 ;
                        for(int j=0 ; j<8 ; j++){
                          sum+=edit[j];
                        }
                        if(min>sum){
                          min=sum ;
                          min_num=i ;
                        }
                      }
                      boolean first=true ;
                      for(int i=0 ; i<8 ; i++){
                        System.out.print(first ? array[min_num][i] : " "+array[min_num][i]);
                        if(first==true){
                          first=false ;
                        }
                      }
                      System.out.println();
                    }
                  }
                }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute array : Sequence(Sequence(int)) := Sequence{Sequence{1,2,1,2,1,4,1,4},Sequence{1,2,1,4,1,4,1,2},Sequence{1,4,1,2,1,2,1,4},Sequence{1,4,1,4,1,2,1,2},Sequence{2,1,2,1,4,1,4,1},Sequence{2,1,4,1,4,1,2,1},Sequence{4,1,2,1,2,1,4,1},Sequence{4,1,4,1,2,1,2,1}};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var input : Sequence(int) ; input := Integer.subrange(1,8)->collect(0) ;
     var str : Sequence(String) ; str := sc.nextLine()->split(" ") ;
        var i : int ; i := 0 ; while i < 8 do ( (     input[i+1] := (str[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var edit : Sequence(int) ; edit := Integer.subrange(1,8)->collect(0) ;
    var min : int ; min := 2147483647 ;
    var min_num : int ; min_num := -1 ;
        var i : int ; i := 0 ; while i < 8 do ( (         var j : int ; j := 0 ; while j < 8 do ( (     edit[j+1] := input[j+1] - array[i+1][j+1] ; 
     if (edit[j+1] < 0) then (     edit[j+1] := 0 ) else skip )  ;     j := j + 1 ) ; 
     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < 8 do ( (     sum := sum+(edit[j+1]) )  ;     j := j + 1 ) ; 
     if (min > sum) then (     min := sum ; 
     min_num := i ) else skip )  ;     i := i + 1 ) ; 
    var first : boolean ; first := true ;
        var i : int ; i := 0 ; while i < 8 do ( (     OclFile["System.out"].print(if first then array[min_num+1][i+1] else " " + array[min_num+1][i+1] endif) ; 
     if (first = true) then (     first := false ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int ans=0 ;
  static Vector<Vector<Integer>>gr=new Vector<Vector<Integer>>();
  static void Add_Edge(int u,int v){
    gr.get(u).add(v);
    gr.get(v).add(u);
  }
  static void dfs(int child,int par,int color[]){
    if(color[child]!=color[par])ans++;
    for(int i=0 ; i<gr.get(child).size(); i++){
      if(gr.get(child).get(i)==par)continue ;
      dfs(gr.get(child).get(i),child,color);
    }
  }
  public static void main(String args[]){
    for(int i=0 ; i<=10 ; i++)gr.add(new Vector<Integer>());
    int color[]={
      0,1,2,3,2,2,3 };
      Add_Edge(1,2);
      Add_Edge(1,3);
      Add_Edge(2,4);
      Add_Edge(2,5);
      Add_Edge(3,6);
      dfs(1,0,color);
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute ans : int := 0;
  static   attribute gr : Sequence(Sequence(int)) := Sequence{};
  static   operation Add_Edge( u : int, v : int) : void
  pre: true
  post: true
  activity: (     gr->at(u+1)->excludes(v) ; 
     gr->at(v+1)->excludes(u) );
  static   operation dfs( child : int, par : int, color : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (color[child+1] /= color[par+1]) then     ans := ans + 1 ; else skip ; 
         var i : int ; i := 0 ; while i < gr->at(child+1)->size() do ( (     if (gr->at(child+1)->at(i+1) = par) then     continue else skip ; 
     execute dfs(gr->at(child+1)->at(i+1), child, color) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= 10 do (     gr := gr->including(Sequence{}) ;  ;     i := i + 1 ) ; 
     var color : Sequence(int) ; color := Sequence{0,1,2,3,2,2,3} ;
    execute Add_Edge(1, 2) ; 
    execute Add_Edge(1, 3) ; 
    execute Add_Edge(2, 4) ; 
    execute Add_Edge(2, 5) ; 
    execute Add_Edge(3, 6) ; 
    execute dfs(1, 0, color) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static class Pair {
    int i ;
    int v ;
    Pair(int i,int v){
      this.i=i ;
      this.v=v ;
    }
  }
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    ArrayList<Pair>ll=new ArrayList<>();
    for(int a=0 ; a<n ; a++){
      int v=scn.nextInt();
      ll.add(new Pair(a+1,v));
    }
    Collections.sort(ll,(a,b)->a.v-b.v);
    int lo=0 ;
    int hi=n-1 ;
    while(lo<=hi){
      System.out.println(ll.get(lo).i+" "+ll.get(hi).i);
      lo++;
      hi--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Pair {
   attribute i : int;
   attribute v : int;
   static operation newPair( i : int, v : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(i, v);
    return self );
  operation initialise( i : int, v : int) : void
  pre: true  post: true
  activity: (     self.i := i ; 
     self.v := v );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var ll : Sequence(Map) ; ll := Sequence{} ;
        var a : int ; a := 0 ; while a < n do ( (     var v : int ; v := scn.getCurrent()->toInteger() ;
     ll := ll->including(Map(a + 1, v)) )  ;     a := a + 1 ) ; 
    ll, lambda (a , b) : OclAny in a.v - b.v := ll, lambda (a , b) : OclAny in a.v - b.v->sort() ; 
    var lo : int ; lo := 0 ;
    var hi : int ; hi := n - 1 ;
    while (lo <= hi) do (     OclFile["System.out"].println(ll->at(lo+1).i + " " + ll->at(hi+1).i) ; 
     lo := lo + 1 ; 
     hi := hi - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _701A_Cards {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    final int LEN=input.nextInt();
    LinkedList<Integer>list=new LinkedList<>();
    int sum=0 ;
    for(int i=1 ; i<=LEN ; i++){
      int value=input.nextInt();
      sum+=value ;
      list.add(value);
    }
    int n2=LEN/2 ;
    sum/=n2 ;
    List<Integer>result=new ArrayList<>();
    for(int i=0 ; i<LEN ; i++){
      Integer num=list.get(i);
      if(num!=null){
        result.add(i+1);
        list.set(i,null);
        int targetNum=sum-num ;
        int index=list.indexOf(targetNum);
        list.set(index,null);
        result.add(index+1);
      }
    }
    for(int i=0 ; i<result.size(); i+=2){
      System.out.println(String.format("%d %d",result.get(i),result.get(i+1)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _701A_Cards {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var LEN : int ; LEN := input.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 1 ; while i <= LEN do ( (     var value : int ; value := input.getCurrent()->toInteger() ;
     sum := sum+(value) ; 
     list := list->including(value) )  ;     i := i + 1 ) ; 
    var n2 : int ; n2 := LEN / 2 ;
    sum := sum/(n2) ; 
    var result : Sequence(int) ; result := Sequence{} ;
        var i : int ; i := 0 ; while i < LEN do ( (     var num : int ; num := list->at(i+1) ;
     if (num /= null) then (     result := result->including(i + 1) ; 
     list := list.setAt(i+1,null) ; 
    var targetNum : int ; targetNum := sum - num ;
    var index : int ; index := list->indexOf(targetNum)-1 ;
    list := list.setAt(index+1,null) ; 
    result := result->including(index + 1) ; 
 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < result->size() do ( (     OclFile["System.out"].println(StringLib.format("%d %d",Sequence{result->at(i+1),result->at(i + 1+1)})) )  ;     i := i+(2) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private Scanner sc ;
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    sc=new Scanner(System.in);
    String line=sc.nextLine();
    while(line.equals("0 0 0 0 0 0")==false){
      String[] nico=line.split(" ");
      int[] a=new int[3];
      int[] m=new int[3];
      int[] xyz=new int[3];
      int[] r=new int[3];
      for(int i=0 ; i<a.length ; i++){
        a[i]=Integer.parseInt(nico[i*2]);
        m[i]=Integer.parseInt(nico[i*2+1]);
        xyz[i]=1 ;
        r[i]=0 ;
      }
      int count=0 ;
      boolean flag=false ;
      while(flag==false){
        flag=true ;
        count++;
        for(int i=0 ; i<xyz.length ; i++){
          if(r[i]==0)xyz[i]=(a[i]*xyz[i])% m[i];
          if(xyz[i]==1){
            if(r[i]==0){
              r[i]=count ;
            }
          }
          else {
            flag=false ;
          }
        }
      }
      count=1 ;
      flag=false ;
      long p=r[0];
      long q=r[1];
      for(int i=0 ; i<2 ; i++){
        if(p<q){
          long tmp=p ;
          p=q ;
          q=tmp ;
        }
        long np=p ;
        long nq=q ;
        while(nq!=0){
          long tmp=np % nq ;
          np=nq ;
          nq=tmp ;
        }
        p=p*q/np ;
        q=r[2];
      }
      System.out.println(p);
      line=sc.nextLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var line : String ; line := sc.nextLine() ;
     while (line = "0 0 0 0 0 0" = false) do (     var nico : Sequence(String) ; nico := line->split(" ") ;
     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
    var m : Sequence(int) ; m := Integer.subrange(1,3)->collect(0) ;
    var xyz : Sequence(int) ; xyz := Integer.subrange(1,3)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := (nico[i * 2+1])->toInteger() ; 
     m[i+1] := (nico[i * 2 + 1+1])->toInteger() ; 
     xyz[i+1] := 1 ; 
     r[i+1] := 0 )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var flag : boolean ; flag := false ;
    while (flag = false) do (     flag := true ; 
     count := count + 1 ; 
         var i : int ; i := 0 ; while i < xyz->size() do ( (     if (r[i+1] = 0) then     xyz[i+1] := (a[i+1] * xyz[i+1]) mod m[i+1] ; else skip ; 
     if (xyz[i+1] = 1) then (     if (r[i+1] = 0) then (     r[i+1] := count ) else skip ) else (     flag := false ) )  ;     i := i + 1 ) ) ; 
    count := 1 ; 
    flag := false ; 
    var p : long ; p := r[0+1] ;
    var q : long ; q := r[1+1] ;
        var i : int ; i := 0 ; while i < 2 do ( (     if (p < q) then (     var tmp : long ; tmp := p ;
     p := q ; 
     q := tmp ) else skip ; 
     var np : long ; np := p ;
    var nq : long ; nq := q ;
    while (nq /= 0) do (     var tmp : long ; tmp := np mod nq ;
     np := nq ; 
     nq := tmp ) ; 
    p := p * q / np ; 
    q := r[2+1] ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(p) ; 
    line := sc.nextLine() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public long GCD(long x,long y){
    long max=Math.max(x,y);
    long min=Math.min(x,y);
    if(min==0){
      return max ;
    }
    return GCD(max % min,min);
  }
  public long LCM(long x,long y){
    long g=GCD(x,y);
    return x*y/g ;
  }
  public long counter(int x,int y){
    long key=x ;
    long count=1 ;
    while(key!=1){
      key=(key*x)% y ;
      count++;
    }
    return count ;
  }
  public void solve()throws IOException {
    int a1,a2,a3,m1,m2,m3 ;
    while((a1=nextInt())!=0 |(m1=nextInt())!=0 |(a2=nextInt())!=0 |(m2=nextInt())!=0 |(a3=nextInt())!=0 |(m3=nextInt())!=0){
      long x=counter(a1,m1);
      long y=counter(a2,m2);
      long z=counter(a3,m3);
      long ans=LCM(LCM(x,y),z);
      System.out.println(ans);
    }
  }
  public static void main(String args[])throws IOException {
    new Main().run();
  }
  BufferedReader reader ;
  StringTokenizer tokenizer ;
  PrintWriter writer ;
  public void run()throws IOException {
    try {
      reader=new BufferedReader(new InputStreamReader(System.in));
      tokenizer=null ;
      writer=new PrintWriter(System.out);
      solve();
      reader.close();
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public String nextToken()throws IOException {
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation GCD( x : long, y : long) : long
  pre: true
  post: true
  activity: (     var max : long ; max := Set{x, y}->max() ;
     var min : long ; min := Set{x, y}->min() ;
     if (min = 0) then (     return max ) else skip ; 
     return GCD(max mod min, min) );
   operation LCM( x : long, y : long) : long
  pre: true
  post: true
  activity: (     var g : long ; g := GCD(x, y) ;
     return x * y / g );
   operation counter( x : int, y : int) : long
  pre: true
  post: true
  activity: (     var key : long ; key := x ;
     var count : long ; count := 1 ;
     while (key /= 1) do (     key := (key * x) mod y ; 
     count := count + 1 ) ; 
     return count );
   operation solve() : void
  pre: true
  post: true
  activity: (     var a1 : int ;
    var a2 : int ;
    var a3 : int ;
    var m1 : int ;
    var m2 : int ;
    var m3 : int ;
         a1 := nextInt() ;
    m1 := nextInt() ;
    a2 := nextInt() ;
    m2 := nextInt() ;
    a3 := nextInt() ;
    m3 := nextInt() ;
    while ((a1) /= 0 or (m1) /= 0 or (a2) /= 0 or (m2) /= 0 or (a3) /= 0 or (m3) /= 0) do (    skip ; (     var x : long ; x := counter(a1, m1) ;
     var y : long ; y := counter(a2, m2) ;
    var z : long ; z := counter(a3, m3) ;
    var ans : long ; ans := LCM(LCM(x, y), z) ;
    OclFile["System.out"].println(ans) ; 
 ) ;     a1 := nextInt() ;
    m1 := nextInt() ;
    a2 := nextInt() ;
    m2 := nextInt() ;
    a3 := nextInt() ;
    m3 := nextInt() ;
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   attribute writer : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     try (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := null ; 
    writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void checkIfPowerIsolated(int num){
    int input=num ;
    int count=0 ;
    int[] factor=new int[num+1];
    if(num % 2==0){
      while(num % 2==0){
++count ;
        num/=2 ;
      }
      factor[2]=count ;
    }
    for(int i=3 ; i*i<=num ; i+=2){
      count=0 ;
      while(num % i==0){
++count ;
        num/=i ;
      }
      if(count>0)factor[i]=count ;
    }
    if(num>1)factor[num]=1 ;
    int product=1 ;
    for(int i=0 ; i<num+1 ; i++){
      if(factor[i]>0)product=product*factor[i]*i ;
    }
    if(product==input)System.out.print("Power-isolated Integer\n");
    else System.out.print("Not a Power-isolated Integer\n");
  }
  public static void main(String[] args){
    checkIfPowerIsolated(12);
    checkIfPowerIsolated(18);
    checkIfPowerIsolated(35);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkIfPowerIsolated( num : int) : void
  pre: true
  post: true
  activity: (     var input : int ; input := num ;
     var count : int ; count := 0 ;
    var factor : Sequence(int) ; factor := Integer.subrange(1,num + 1)->collect(0) ;
    if (num mod 2 = 0) then (     while (num mod 2 = 0) do (     count := count + 1 ; 
     num := num/(2) ) ; 
     factor[2+1] := count ) else skip ; 
        var i : int ; i := 3 ; while i * i <= num do ( (     count := 0 ; 
     while (num mod i = 0) do (     count := count + 1 ; 
     num := num/(i) ) ; 
     if (count > 0) then     factor[i+1] := count ; else skip )  ;     i := i+(2) ) ; 
    if (num > 1) then     factor[num+1] := 1 ; else skip ; 
    var product : int ; product := 1 ;
        var i : int ; i := 0 ; while i < num + 1 do ( (     if (factor[i+1] > 0) then     product := product * factor[i+1] * i ; else skip )  ;     i := i + 1 ) ; 
    if (product = input) then     OclFile["System.out"].print("Power-isolated Integer\n") else     OclFile["System.out"].print("Not a Power-isolated Integer\n") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute checkIfPowerIsolated(12) ; 
     execute checkIfPowerIsolated(18) ; 
     execute checkIfPowerIsolated(35) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAX=1000 ;
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static int func(int ind,int g,int dp[][],int n,int a[]){
    if(ind==n){
      if(g==1)return 1 ;
      else return 0 ;
    }
    if(dp[ind][g]!=-1)return dp[ind][g];
    int ans=func(ind+1,g,dp,n,a)+func(ind+1,gcd(a[ind],g),dp,n,a);
    return dp[ind][g]=ans ;
  }
  static int countSubsequences(int a[],int n){
    int dp[][]=new int[n][MAX];
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<MAX ; j++)dp[i][j]=-1 ;
    int count=0 ;
    for(int i=0 ; i<n ; i++)count+=func(i+1,a[i],dp,n,a);
    return count ;
  }
  public static void main(String args[]){
    int a[]={
      3,4,8,16 };
      int n=a.length ;
      System.out.println(countSubsequences(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 1000;
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation func( ind : int, g : int, dp : Sequence(Sequence(int)), n : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (ind = n) then (     if (g = 1) then     return 1 else     return 0 ) else skip ; 
     if (dp[ind+1][g+1] /= -1) then     return dp[ind+1][g+1] else skip ; 
     var ans : int ; ans := func(ind + 1, g, dp, n, a) + func(ind + 1, gcd(a[ind+1], g), dp, n, a) ;
     return dp[ind+1][g+1] );
  static   operation countSubsequences( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,MAX)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < MAX do (     dp[i+1][j+1] := -1 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do (     count := count+(func(i + 1, a[i+1], dp, n, a)) ;  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{3,4,8,16} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(countSubsequences(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    try {
      System.setIn(new FileInputStream("src/aoj0114/input.txt"));
      System.setOut(new PrintStream(new FileOutputStream("src/aojxxxx/result.txt")));
    }
    catch(FileNotFoundException e){
    }
    new Main().run();
  }
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; sc.hasNext(); ){
      long v[]=new long[3];
      for(int i=0 ; i<3 ; i++){
        int a=sc.nextInt();
        int m=sc.nextInt();
        if(a==0)return ;
        v[i]=move(a,m);
      }
      long ans=lcm(v[0],lcm(v[1],v[2]));
      System.out.println(ans);
    }
  }
  long move(long a,long m){
    long x=1 ;
    int cnt=0 ;
    do {
      cnt++;
      x=(x*a)% m ;
    }
    while(x!=1);
    return cnt ;
  }
  long gcd(long a,long b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  long lcm(long a,long b){
    return a/gcd(a,b)*b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("src/aoj0114/input.txt"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("src/aojxxxx/result.txt")))) )   catch (e : FileNotFoundException) do skip
     Main.newMain().run() );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var v : Sequence(long) ; v := Integer.subrange(1,3)->collect(0) ;
         var i : int ; i := 0 ; while i < 3 do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     if (a = 0) then     return else skip ; 
     v[i+1] := move(a, m) )  ;     i := i + 1 ) ; 
     var ans : long ; ans := lcm(v[0+1], lcm(v[1+1], v[2+1])) ;
     OclFile["System.out"].println(ans) )  ) );
   operation move( a : long, m : long) : long
  pre: true
  post: true
  activity: (     var x : long ; x := 1 ;
     var cnt : int ; cnt := 0 ;
   while true do ((     cnt := cnt + 1 ; 
     x := (x * a) mod m ) ;
    if (x /= 1) then skip else break) ; 
     return cnt );
   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return a / gcd(a, b) * b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  static long backToOne(int a,int m){
    int no=1 ;
    boolean[] visited=new boolean[m];
    long count=0 ;
    while(true){
      visited[no]=true ;
      no=(no*a)% m ;
      count++;
      if(visited[no]){
        if(no==1){
          return count ;
        }
        else {
          return-1L ;
        }
      }
    }
  }
  static long gcd(long a,long b){
    if(a<b){
      return gcd(b,a);
    }
    while(b!=0){
      final long tmp=a ;
      a=b ;
      b=tmp % a ;
    }
    return a ;
  }
  static long lcm(long a,long b){
    return a*b/gcd(a,b);
  }
  public static void main(String[] args){
    final Scanner stdin=new Scanner(System.in);
    while(true){
      final int a1=stdin.nextInt();
      final int m1=stdin.nextInt();
      final int a2=stdin.nextInt();
      final int m2=stdin.nextInt();
      final int a3=stdin.nextInt();
      final int m3=stdin.nextInt();
      if(a1==0 && a2==0 && a3==0 && m1==0 && m2==0 && m3==0){
        break ;
      }
      long a=backToOne(a1,m1);
      long b=backToOne(a2,m2);
      long c=backToOne(a3,m3);
      System.out.println(lcm(lcm(a,b),c));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation backToOne( a : int, m : int) : long
  pre: true
  post: true
  activity: (     var no : int ; no := 1 ;
     var visited : Sequence(boolean) ; visited := Integer.subrange(1,m)->collect(false) ;
     var count : long ; count := 0 ;
     while (true) do (     visited[no+1] := true ; 
     no := (no * a) mod m ; 
     count := count + 1 ; 
     if (visited[no+1]) then (     if (no = 1) then (     return count ) else (     return -1L ) ) else skip ) );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a < b) then (     return gcd(b, a) ) else skip ; 
     while (b /= 0) do (     var tmp : long ; tmp := a ;
     a := b ; 
     b := tmp mod a ) ; 
     return a );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return a * b / gcd(a, b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var a1 : int ; a1 := stdin.getCurrent()->toInteger() ;
     var m1 : int ; m1 := stdin.getCurrent()->toInteger() ;
    var a2 : int ; a2 := stdin.getCurrent()->toInteger() ;
    var m2 : int ; m2 := stdin.getCurrent()->toInteger() ;
    var a3 : int ; a3 := stdin.getCurrent()->toInteger() ;
    var m3 : int ; m3 := stdin.getCurrent()->toInteger() ;
    if (a1 = 0 & a2 = 0 & a3 = 0 & m1 = 0 & m2 = 0 & m3 = 0) then (     break ) else skip ; 
    var a : long ; a := backToOne(a1, m1) ;
    var b : long ; b := backToOne(a2, m2) ;
    var c : long ; c := backToOne(a3, m3) ;
    OclFile["System.out"].println(lcm(lcm(a, b), c)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] argv){
    Scanner sc=new Scanner(System.in);
    long[] num=new long[6];
    loop : while(true){
      for(int i=0 ; i<num.length ; ++i){
        num[i]=Integer.parseInt(sc.next());
      }
      if(max(num)!=0){
        System.out.println(lcm(calc(num)));
      }
      else {
        break loop ;
      }
    }
  }
  private static long[] calc(long...num){
    long[] no=new long[(int)num.length/2];
    for(int i=0 ; i<num.length ; i+=2){
      long val=1 ;
      int a=i,m=i+1,count=0 ;
      do {
        val=(num[a]*val)% num[m];
++count ;
      }
      while(val!=1);
      no[i/2]=count ;
    }
    return no ;
  }
  private static long lcm(long...num){
    long max=max(num);
    for(long i=2 ; i<=max ; ++i){
      long[] no=mod0(i,num.clone());
      if(no!=null){
        return i*lcm(no);
      }
    }
    long sum=1 ;
    for(long n : num){
      sum*=n ;
    }
    return sum ;
  }
  private static long[] mod0(long n,long...num){
    long flag=0 ;
    for(int i=0 ; i<num.length ; ++i){
      if(num[i] % n==0){
        num[i]/=n ;
++flag ;
      }
    }
    if(1<flag){
      return num ;
    }
    else {
      return null ;
    }
  }
  private static long max(long...num){
    long max=0 ;
    for(long n : num){
      if(max<n){
        max=n ;
      }
    }
    return max ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( argv : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : Sequence(long) ; num := Integer.subrange(1,6)->collect(0) ;
     while (true) do (         var i : int ; i := 0 ; while i < num->size() do ( (     num[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
     if (Set{num}->max() /= 0) then (     OclFile["System.out"].println(lcm(calc(num))) ) else (     break ) ) ; );
  static   operation calc( num : Sequence(long)) : Sequence(long)
  pre: true
  post: true
  activity: (     var no : Sequence(long) ; no := Integer.subrange(1,num->size()->oclAsType(int) / 2)->collect(0) ;
         var i : int ; i := 0 ; while i < num->size() do ( (     var val : long ; val := 1 ;
     var a : int ; a := i ;
    var m : int ; m := i + 1 ;
    var count : int ; count := 0 ;
   while true do ((     val := (num[a+1] * val) mod num[m+1] ; 
     count := count + 1 ) ;
    if (val /= 1) then skip else break) ; 
     no[i / 2+1] := count )  ;     i := i+(2) ) ; 
     return no );
  static   operation lcm( num : Sequence(long)) : long
  pre: true
  post: true
  activity: (     var max : long ; max := max(num) ;
         var i : long ; i := 2 ; while i <= max do ( (     var no : Sequence(long) ; no := mod0(i, num->copy()) ;
     if (no /= null) then (     return i * lcm(no) ) else skip )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 1 ;
    for (n : num) do ( (     sum := sum*(n) )  ) ; 
    return sum 
 );
  static   operation mod0( n : long, num : Sequence(long)) : Sequence(long)
  pre: true
  post: true
  activity: (     var flag : long ; flag := 0 ;
         var i : int ; i := 0 ; while i < num->size() do ( (     if (num[i+1] mod n = 0) then (     num[i+1] := num[i+1]/(n) ; 
     flag := flag + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (1 < flag) then (     return num ) else (     return null ) );
  static   operation max( num : Sequence(long)) : long
  pre: true
  post: true
  activity: (     var max : long ; max := 0 ;
     for (n : num) do ( (     if (max < n) then (     max := n ) else skip )  ) ; 
     return max );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Fibonacci {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int max=-1 ;
      for(int i=0 ; i<n ; i++){
        int inp=sc.nextInt();
        if(inp!=i){
          if(max==-1)max=i ;
          max &=i ;
        }
      }
      pw.println(max);
    }
    pw.flush();
  }
  static class Scanner {
    BufferedReader br ;
    StringTokenizer st ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(FileReader f){
      br=new BufferedReader(f);
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public int[] nextIntArr(int n)throws IOException {
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=Integer.parseInt(next());
      }
      return arr ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Fibonacci {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var max : int ; max := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     var inp : int ; inp := sc.getCurrent()->toInteger() ;
     if (inp /= i) then (     if (max = -1) then     max := i ; else skip ; 
     max := MathLib.bitwiseAnd(max, i) ) else skip )  ;     i := i + 1 ) ; 
     skip ) ;  ) ;  
    skip ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( f : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(f) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArr( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (next())->toInteger() )  ;     i := i + 1 ) ; 
     return arr );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      int a[]=new int[n];
      int now=-1 ;
      for(int i=0 ; i<n ; i++){
        a[i]=input.nextInt();
        if(a[i]!=i && now==-1){
          now=a[i];
        }
        else if(a[i]!=i){
          now &=a[i];
        }
      }
      System.out.println(now);
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var tc : int ; tc := input.nextInt() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var now : int ; now := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.nextInt() ; 
     if (a[i+1] /= i & now = -1) then (     now := a[i+1] ) else     if (a[i+1] /= i) then (     now := MathLib.bitwiseAnd(now, a[i+1]) ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(now) ; 
 ) ;  ) ;  );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int findMinRec(int A[],int n){
    if(n==1)return A[0];
    return Math.min(A[n-1],findMinRec(A,n-1));
  }
  public static void main(String args[]){
    int A[]={
      1,4,45,6,-50,10,2 };
      int n=A.length ;
      System.out.println(findMinRec(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMinRec( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return A[0+1] else skip ; 
     return Set{A[n - 1+1], findMinRec(A, n - 1)}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{1,4,45,6,-50,10,2} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].println(findMinRec(A, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    int b=in.nextInt();
    if(a==b){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
     if (a = b) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.List ;
class Main {
  public static void main(String[] args)throws Exception {
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      List<String>input=Arrays.asList(br.readLine().split(" "));
      String result="No" ;
      if(input.get(0).equals(input.get(1))){
        result="Yes" ;
      }
      System.out.println(result);
    }
    catch(IOException | NumberFormatException e){
      e.printStackTrace();
      System.exit(0);
    }
    catch(final Exception e){
      e.printStackTrace();
      System.exit(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : Sequence(String) ; input := br.readLine()->split(" ") ;
    var result : String ; result := "No" ;
    if (input->at(0+1) = input->at(1+1)) then (     result := "Yes" ) else skip ; 
    OclFile["System.out"].println(result) ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
 OclProcess.exit(0) )
   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(0) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int count=0 ;
    boolean sw=false ;
    int max=Integer.MIN_VALUE ;
    int min=Integer.MAX_VALUE ;
    double dMax=Double.MIN_VALUE ;
    double dMin=Double.MAX_VALUE ;
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    if(n==m)System.out.println("Yes");
    else System.out.println("No");
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var sw : boolean ; sw := false ;
    var max : int ; max := -2147483648 ;
    var min : int ; min := 2147483647 ;
    var dMax : double ; dMax := 2->pow(-1074) ;
    var dMin : double ; dMin := (2 - 2->pow(-52))*(2->pow(1023)) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    if (n = m) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static int N ;
  private static int M ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    M=sc.nextInt();
    System.out.println(N==M ? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute M : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
     M := sc.getCurrent()->toInteger() ; 
     OclFile["System.out"].println(if N = M then "Yes" else "No" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean checkPairs(int l,int r){
    if((l-r)% 2==0)return false ;
    return true ;
  }
  public static void main(String[] args){
    int l=1,r=8 ;
    if(checkPairs(l,r))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkPairs( l : int, r : int) : boolean
  pre: true
  post: true
  activity: (     if ((l - r) mod 2 = 0) then     return false else skip ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 1 ;
    var r : int ; r := 8 ;
     if (checkPairs(l, r)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int M=scanner.nextInt();
    if(N==M){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
     var M : int ; M := scanner.getCurrent()->toInteger() ;
     if (N = M) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class Node {
    Node left ;
    Node right ;
    int data ;
  };
  static Node newNode(int data){
    Node temp=new Node();
    temp.data=data ;
    temp.left=null ;
    temp.right=null ;
    return temp ;
  }
  static void PrintLeafLeftToRight(Node root){
    Stack<Node>s1=new Stack<>();
    Stack<Node>s2=new Stack<>();
    ;
    s1.push(root);
    while(! s1.empty()){
      Node curr=s1.peek();
      s1.pop();
      if(curr.left!=null)s1.push(curr.left);
      if(curr.right!=null)s1.push(curr.right);
      else if(curr.left==null && curr.right==null)s2.push(curr);
    }
    while(! s2.empty()){
      System.out.print(s2.peek().data+" ");
      s2.pop();
    }
  }
  public static void main(String[] args){
    Node root=newNode(1);
    root.left=newNode(2);
    root.right=newNode(3);
    root.left.left=newNode(4);
    root.right.left=newNode(5);
    root.right.right=newNode(7);
    root.left.left.left=newNode(10);
    root.left.left.right=newNode(11);
    root.right.right.left=newNode(8);
    PrintLeafLeftToRight(root);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Node {
   attribute left : Node;
   attribute right : Node;
   attribute data : int;
}
  static   operation newNode( data : int) : Node
  pre: true
  post: true
  activity: (     var temp : Node ; temp := Node.newNode() ;
     temp.data := data ; 
    temp.left := null ; 
    temp.right := null ; 
    return temp 
 );
  static   operation PrintLeafLeftToRight( root : Node) : void
  pre: true
  post: true
  activity: (     var s1 : Sequence(Node) ; s1 := Sequence{} ;
     var s2 : Sequence(Node) ; s2 := Sequence{} ;
    s1 := s1->append(root) ; 
    while (not(s1->isEmpty())) do (     var curr : Node ; curr := s1->min() ;
     s1 := s1->front() ; 
     if (curr.left /= null) then     s1 := s1->append(curr.left) ; else skip ; 
     if (curr.right /= null) then     s1 := s1->append(curr.right) ; else     if (curr.left = null & curr.right = null) then     s2 := s2->append(curr) ; else skip ; ) ; 
    while (not(s2->isEmpty())) do (     OclFile["System.out"].print(s2->min().data + " ") ; 
     s2 := s2->front() ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var root : Node ; root := newNode(1) ;
     root.left := newNode(2) ; 
    root.right := newNode(3) ; 
    root.left.left := newNode(4) ; 
    root.right.left := newNode(5) ; 
    root.right.right := newNode(7) ; 
    root.left.left.left := newNode(10) ; 
    root.left.left.right := newNode(11) ; 
    root.right.right.left := newNode(8) ; 
    execute PrintLeafLeftToRight(root) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float kPresentProbability(int a[],int n,int k){
    float count=0 ;
    for(int i=0 ; i<n ; i++)if(a[i]==k)count++;
    return count/n ;
  }
  public static void main(String[] args){
    int A[]={
      4,7,2,0,8,7,5 };
      int K=2 ;
      int N=A.length ;
      double n=kPresentProbability(A,N,K);
      double p=(double)Math.round(n*100)/100 ;
      System.out.println(p);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation kPresentProbability( a : Sequence(int), n : int, k : int) : double
  pre: true
  post: true
  activity: (     var count : double ; count := 0 ;
         var i : int ; i := 0 ; while i < n do (     if (a[i+1] = k) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return count / n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{4,7,2,0,8,7,5} ;
     var K : int ; K := 2 ;
    var N : int ; N := A->size() ;
    var n : double ; n := kPresentProbability(A, N, K) ;
    var p : double ; p := (n * 100)->round()->oclAsType(double) / 100 ;
    OclFile["System.out"].println(p) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Welcome {
  public static void main(String[] args)throws Exception {
    int i,j,k,p ;
    char c ;
    int res ;
    String score ;
    String line ;
    String sentence ;
    String original="welcome to code jam" ;
    int N,M ;
    BufferedReader br=new BufferedReader(new FileReader("C-large.in"));
    PrintWriter out=new PrintWriter(new BufferedWriter(new FileWriter("C-large.out")));
    StringTokenizer st ;
    line=br.readLine();
    N=Integer.parseInt(line);
    for(k=1 ; k<=N ; k++){
      sentence=br.readLine();
      M=sentence.length();
      int opt[][]=new int[M][19];
      for(i=0 ; i<M ; i++){
        c=sentence.charAt(i);
        if(c=='w'){
          opt[i][0]=1 ;
        }
        for(j=1 ; j<19 ; j++){
          if(c==original.charAt(j)){
            for(p=0 ; p<i ; p++){
              opt[i][j]=(opt[i][j]+opt[p][j-1])% 10000 ;
            }
          }
        }
      }
      res=0 ;
      for(i=0 ; i<M ; i++){
        res=(res+opt[i][18])% 10000 ;
      }
      score=Integer.toString(res);
      while(score.length()<4){
        score='0'+score ;
      }
      out.println("Case #"+k+": "+score);
    }
    out.close();
    System.exit(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Welcome {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var k : int ;
    var p : int ;
     var c : String ;
    var res : int ;
    var score : String ;
    var line : String ;
    var sentence : String ;
    var original : String ; original := "welcome to code jam" ;
    var N : int ;
    var M : int ;
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("C-large.in"))) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("C-large.out")))) ;
    var st : OclIterator ;
    line := br.readLine() ; 
    N := (line)->toInteger() ; 
        k := 1 ; while k <= N do ( (     sentence := br.readLine() ; 
     M := sentence->size() ; 
    var opt : Sequence(Sequence(int)) ; opt := Integer.subrange(1,M)->collect(Integer.subrange(1,19)->collect(0)) ;
        i := 0 ; while i < M do ( (     c := sentence->at(i+1) ; 
     if (c = 'w') then (     opt[i+1][0+1] := 1 ) else skip ; 
         j := 1 ; while j < 19 do ( (     if (c = original->at(j+1)) then (         p := 0 ; while p < i do ( (     opt[i+1][j+1] := (opt[i+1][j+1] + opt[p+1][j - 1+1]) mod 10000 )  ;     p := p + 1 ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    res := 0 ; 
        i := 0 ; while i < M do ( (     res := (res + opt[i+1][18+1]) mod 10000 )  ;     i := i + 1 ) ; 
    score := ((res) + "") ; 
    while (score->size() < 4) do (     score := '0' + score ) ; 
    skip ; 
 )  ;     k := k + 1 ) ; 
    skip ; 
OclProcess.exit(0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package gcj2009.qual ;
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class C {
  static final int INF=1<<20 ;
  static final int[] di={
-1,0,0,1 };
    static final int[] dj={
      0,-1,1,0 };
      static final char[] key="welcome to code jam".toCharArray();
      static final int mod=10000 ;
      public void run(){
        char[] input=sc.nextLine().toCharArray();
        int[] dp=new int[key.length+1];
        dp[0]=1 ;
        for(char c : input)for(int i=key.length-1 ; i>=0 ; i--)if(key[i]==c)dp[i+1]=(dp[i+1]+dp[i])% mod ;
        System.out.printf("%04d%n",dp[key.length]);
      }
      public static void main(String...args){
        try {
          System.setIn(new FileInputStream("C-large.in"));
          System.setOut(new PrintStream("C-large.out"));
        }
        catch(Exception e){
        }
        sc=new Scanner(System.in);
        int T=sc.nextInt();
        sc.nextLine();
        for(int t=1 ; t<=T ; t++){
          System.out.printf("Case #%d: ",t);
          new C().run();
        }
      }
      static Scanner sc ;
    }

------------------------------------------------------------
OCL File:
---------
 class C {
  static    attribute INF : int := (1*(2->pow(20)))->oclAsType(long);
  static    attribute di : Sequence(int) := Sequence{-1,0,0,1};
  static    attribute dj : Sequence(int) := Sequence{0,-1,1,0};
  static    attribute key : Sequence(String) := "welcome to code jam"->characters();
  static    attribute mod : int := 10000;
   operation run() : void
  pre: true
  post: true
  activity: (     var input : Sequence(String) ; input := sc.nextLine()->characters() ;
     var dp : Sequence(int) ; dp := Integer.subrange(1,key->size() + 1)->collect(0) ;
    dp[0+1] := 1 ; 
    for (c : input) do (         var i : int ; i := key->size() - 1 ; while i >= 0 do (     if (key[i+1] = c) then     dp[i + 1+1] := (dp[i + 1+1] + dp[i+1]) mod mod ; else skip ;  ;     i := i - 1 ) ;  ) ; 
    OclFile["System.out"].printf("%04d%n", dp[key->size()+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("C-large.in"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile("C-large.out"))) )   catch (e : ProgramException) do skip
     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
    var T : int ; T := sc.nextInt() ;
    sc.nextLine() ; 
        var t : int ; t := 1 ; while t <= T do ( (     OclFile["System.out"].printf("Case #%d: ", t) ; 
     C.newC().run() )  ;     t := t + 1 ) ; 
 );
  static   attribute sc : OclFile;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package qualifiers ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
public class WelcomeToCodeJam {
  private char[] input ;
  private char[] target ;
  private BigInteger[][] memo ;
  private BigInteger solve(int inputIdx,int targetIdx){
    if(memo[inputIdx][targetIdx]!=null)return memo[inputIdx][targetIdx];
    else {
      BigInteger ret=BigInteger.ZERO ;
      if(inputIdx>=input.length){
        if(targetIdx>=target.length){
          ret=BigInteger.ONE ;
        }
        else ret=BigInteger.ZERO ;
      }
      else {
        if(targetIdx<target.length){
          char c1=target[targetIdx];
          char c2=input[inputIdx];
          if(c1==c2)ret=ret.add(solve(inputIdx+1,targetIdx+1));
        }
        ret=ret.add(solve(inputIdx+1,targetIdx));
      }
      memo[inputIdx][targetIdx]=ret ;
      return ret ;
    }
  }
  public String getWelcome(String inp,String target){
    this.input=inp.toCharArray();
    this.target=target.toCharArray();
    this.memo=new BigInteger[input.length+1][this.target.length+1];
    BigInteger val=solve(0,0);
    String ret=val.toString();
    if(ret.length()<4){
      for(int i=ret.length(); i<4 ; ++i)ret="0"+ret ;
    }
    else ret=ret.substring(ret.length()-4);
    return ret ;
  }
  public static void main(String[] args)throws NumberFormatException,IOException {
    WelcomeToCodeJam obj=new WelcomeToCodeJam();
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int N=Integer.valueOf(br.readLine());
    String target="welcome to code jam" ;
    for(int i=1 ; i<=N ; ++i){
      String inp=br.readLine();
      String ret=obj.getWelcome(inp,target);
      System.out.println("Case #"+i+": "+ret);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class WelcomeToCodeJam {
   attribute input : Sequence(String);
   attribute target : Sequence(String);
   attribute memo : Sequence(Sequence(long));
   operation solve( inputIdx : int, targetIdx : int) : long
  pre: true
  post: true
  activity: (     if (memo[inputIdx+1][targetIdx+1] /= null) then     return memo[inputIdx+1][targetIdx+1] else (     var ret : long ; ret := 0 ;
     if (inputIdx >= input->size()) then (     if (targetIdx >= target->size()) then (     ret := 1 ) else     ret := 0 ; ) else (     if (targetIdx < target->size()) then (     var c1 : String ; c1 := target[targetIdx+1] ;
     var c2 : String ; c2 := input[inputIdx+1] ;
     if (c1 = c2) then     ret := ret->excludes(solve(inputIdx + 1, targetIdx + 1)) ; else skip ) else skip ; 
     ret := ret->excludes(solve(inputIdx + 1, targetIdx)) ) ;  
     memo[inputIdx+1][targetIdx+1] := ret ; 
     return ret ) );
   operation getWelcome( inp : String, target : String) : String
  pre: true
  post: true
  activity: (     self.input := inp->characters() ; 
     self.target := target->characters() ; 
    self.memo := Integer.subrange(1,input->size() + 1)->collect(Integer.subrange(1,self.target->size() + 1)->collect(null)) ; 
    var val : long ; val := solve(0, 0) ;
    var ret : String ; ret := val+"" ;
    if (ret->size() < 4) then (         var i : int ; i := ret->size() ; while i < 4 do (     ret := "0" + ret ;  ;     i := i + 1 ) ) else     ret := ret.subrange(ret->size() - 4+1,ret->size() - 4) ; ;  
    return ret 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : WelcomeToCodeJam ; obj := WelcomeToCodeJam.newWelcomeToCodeJam() ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var N : int ; N := (br.readLine())->toInteger() ;
    var target : String ; target := "welcome to code jam" ;
        var i : int ; i := 1 ; while i <= N do ( (     var inp : String ; inp := br.readLine() ;
     var ret : String ; ret := obj.getWelcome(inp, target) ;
     OclFile["System.out"].println("Case #" + i + ": " + ret) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Welcome {
  static int current[];
  static void inc(int index){
    current[index]=(current[index]+1)% 10000 ;
  }
  static void move(int index){
    current[index+1]=(current[index]+current[index+1])% 10000 ;
  }
  private static int solve(String line){
    String wel="welcome to code jam" ;
    int length=wel.length();
    current=new int[length];
    int i,j ;
    for(i=0 ; i<line.length(); i++){
      char c=line.charAt(i);
      for(j=0 ; j<length ; j++){
        if(c==wel.charAt(j)){
          if(j>0){
            move(j-1);
          }
          else {
            inc(j);
          }
        }
      }
    }
    return current[length-1];
  }
  public static void main(String args[]){
    try {
      BufferedReader reader=new BufferedReader(new FileReader("src/C-large.in"));
      BufferedWriter writer=new BufferedWriter(new FileWriter("output"));
      int n=Integer.parseInt(reader.readLine());
      int i ;
      for(i=0 ; i<n ; i++){
        String line=reader.readLine();
        int result=solve(line);
        writer.write("Case #"+(i+1)+": ");
        if(result<1000){
          writer.write("0");
        }
        if(result<100){
          writer.write("0");
        }
        if(result<10){
          writer.write("0");
        }
        writer.write(result+"");
        writer.newLine();
      }
      reader.close();
      writer.close();
    }
    catch(Exception ex){
      ex.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Welcome {
  static   attribute current : Sequence(int);
  static   operation inc( index : int) : void
  pre: true
  post: true
  activity: (     current[index+1] := (current[index+1] + 1) mod 10000 );
  static   operation move( index : int) : void
  pre: true
  post: true
  activity: (     current[index + 1+1] := (current[index+1] + current[index + 1+1]) mod 10000 );
  static   operation solve( line : String) : int
  pre: true
  post: true
  activity: (     var wel : String ; wel := "welcome to code jam" ;
     var length : int ; length := wel->size() ;
    current := Integer.subrange(1,length)->collect(0) ; 
    var i : int ;
    var j : int ;
        i := 0 ; while i < line->size() do ( (     var c : String ; c := line->at(i+1) ;
         j := 0 ; while j < length do ( (     if (c = wel->at(j+1)) then (     if (j > 0) then (     execute move(j - 1) ) else (     execute inc(j) ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return current[(length)->char2byte() - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("src/C-large.in"))) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output"))) ;
    var n : int ; n := (reader.readLine())->toInteger() ;
    var i : int ;
        i := 0 ; while i < n do ( (     var line : String ; line := reader.readLine() ;
     var result : int ; result := solve(line) ;
    skip ; 
    if (result < 1000) then (     skip ) else skip ; 
    if (result < 100) then (     skip ) else skip ; 
    if (result < 10) then (     skip ) else skip ; 
    skip ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 )   catch (ex : ProgramException) do (     ex.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package gcj ;
import java.io.BufferedReader ;
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
import java.util.regex.Pattern ;
public class QR_Q3 {
  public static void main(String[] args)throws Exception {
    new QR_Q3().run();
  }
  int N ;
  int[] map=new int[256];
  int mod=10000 ;
  void run()throws Exception {
    BufferedReader br=new BufferedReader(new FileReader("C-large.in"));
    PrintWriter pw=new PrintWriter("QR_Q3.out");
    N=Integer.parseInt(br.readLine());
    String ph="welcome to code jam" ;
    int l=ph.length();
    digest(ph);
    for(int n_case=1 ; n_case<=N ; n_case++){
      String line=br.readLine();
      int[] result=new int[l+1];
      result[0]=1 ;
      for(int i=0 ; i<line.length(); i++){
        char c=line.charAt(i);
        int amap=map[c];
        for(int i_p=0 ; i_p<l ; i_p++){
          if((amap & 1<<i_p)==0){
          }
          else {
            result[i_p+1]=(result[i_p]+result[i_p+1])% mod ;
          }
        }
      }
      pw.printf("Case #%d: %04d",n_case,result[l]);
      pw.println();
    }
    pw.close();
  }
  private void digest(String ph){
    for(int i=0 ; i<ph.length(); i++){
      char c=ph.charAt(i);
      map[c] |=1<<i ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class QR_Q3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     QR_Q3.newQR_Q3().run() );
   attribute N : int;
   attribute map : Sequence(int) := Integer.subrange(1,256)->collect(0);
   attribute mod : int := 10000;
   operation run() : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("C-large.in"))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile("QR_Q3.out")) ;
    N := (br.readLine())->toInteger() ; 
    var ph : String ; ph := "welcome to code jam" ;
    var l : int ; l := ph->size() ;
    execute digest(ph) ; 
        var n_case : int ; n_case := 1 ; while n_case <= N do ( (     var line : String ; line := br.readLine() ;
     var result : Sequence(int) ; result := Integer.subrange(1,l + 1)->collect(0) ;
    result[0+1] := 1 ; 
        var i : int ; i := 0 ; while i < line->size() do ( (     var c : String ; c := line->at(i+1) ;
     var amap : int ; amap := map[c+1] ;
         var i_p : int ; i_p := 0 ; while i_p < l do ( (     if ((MathLib.bitwiseAnd(amap,(1*(2->pow(i_p)))->oclAsType(long))) = 0) then skip else (     result[i_p + 1+1] := (result[i_p+1] + result[i_p + 1+1]) mod mod ) )  ;     i_p := i_p + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 )  ;     n_case := n_case + 1 ) ; 
    skip ; 
 );
   operation digest( ph : String) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < ph->size() do ( (     var c : String ; c := ph->at(i+1) ;
     map[c+1] := MathLib.bitwiseOr(map[c+1], (1*(2->pow(i)))->oclAsType(long)) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  static int max ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int N=Integer.parseInt(st.nextToken());
    int M=Integer.parseInt(st.nextToken());
    int Q=Integer.parseInt(st.nextToken());
    int[][] arr=new int[Q][4];
    for(int i=0 ; i<Q ; i++){
      st=new StringTokenizer(br.readLine());
      arr[i][0]=Integer.parseInt(st.nextToken())-1 ;
      arr[i][1]=Integer.parseInt(st.nextToken())-1 ;
      arr[i][2]=Integer.parseInt(st.nextToken());
      arr[i][3]=Integer.parseInt(st.nextToken());
    }
    max=0 ;
    dfs(N,M,Q,arr,1,new ArrayList());
    System.out.println(max);
  }
  public static void dfs(int N,int M,int Q,int[][] arr,int cur,ArrayList<Integer>curlist){
    if(curlist.size()==N){
      int score=0 ;
      for(int i=0 ; i<Q ; i++){
        if(curlist.get(arr[i][1])-curlist.get(arr[i][0])==arr[i][2]){
          score+=arr[i][3];
        }
      }
      max=Math.max(max,score);
      return ;
    }
    for(int i=cur ; i<=M ; i++){
      curlist.add(i);
      dfs(N,M,Q,arr,i,curlist);
      curlist.remove(curlist.size()-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute max : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var N : int ; N := (st.next())->toInteger() ;
    var M : int ; M := (st.next())->toInteger() ;
    var Q : int ; Q := (st.next())->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,Q)->collect(Integer.subrange(1,4)->collect(0)) ;
        var i : int ; i := 0 ; while i < Q do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     arr[i+1][0+1] := (st.next())->toInteger() - 1 ; 
    arr[i+1][1+1] := (st.next())->toInteger() - 1 ; 
    arr[i+1][2+1] := (st.next())->toInteger() ; 
    arr[i+1][3+1] := (st.next())->toInteger() ; 
 )  ;     i := i + 1 ) ; 
    max := 0 ; 
    execute dfs(N, M, Q, arr, 1, Sequence{}) ; 
    OclFile["System.out"].println(max) ; 
 );
  static   operation dfs( N : int, M : int, Q : int, arr : Sequence(Sequence(int)), cur : int, curlist : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (curlist->size() = N) then (     var score : int ; score := 0 ;
         var i : int ; i := 0 ; while i < Q do ( (     if (curlist->at(arr[i+1][1+1]+1) - curlist->at(arr[i+1][0+1]+1) = arr[i+1][2+1]) then (     score := score+(arr[i+1][3+1]) ) else skip )  ;     i := i + 1 ) ; 
     max := Set{max, score}->max() ; 
     return ) else skip ; 
         var i : int ; i := cur ; while i <= M do ( (     curlist->excludes(i) ; 
     execute dfs(N, M, Q, arr, i, curlist) ; 
     curlist := curlist->excludingFirst(curlist->size() - 1) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=1000 ;
  static boolean isPermutedMatrix(int mat[][],int n){
    String str_cat="" ;
    for(int i=0 ; i<n ; i++){
      str_cat=str_cat+"-"+String.valueOf(mat[0][i]);
    }
    str_cat=str_cat+str_cat ;
    for(int i=1 ; i<n ; i++){
      String curr_str="" ;
      for(int j=0 ; j<n ; j++){
        curr_str=curr_str+"-"+String.valueOf(mat[i][j]);
      }
      if(str_cat.contentEquals(curr_str)){
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    int n=4 ;
    int mat[][]={
      {
        1,2,3,4 },{
          4,1,2,3 },{
            3,4,1,2 },{
              2,3,4,1 }
            };
            if(isPermutedMatrix(mat,n)){
              System.out.println("Yes");
            }
            else {
              System.out.println("No");
            }
          }
        }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 1000;
  static   operation isPermutedMatrix( mat : Sequence(Sequence(int)), n : int) : boolean
  pre: true
  post: true
  activity: (     var str_cat : String ; str_cat := "" ;
         var i : int ; i := 0 ; while i < n do ( (     str_cat := str_cat + "-" + ((mat[0+1][i+1]) + "") )  ;     i := i + 1 ) ; 
    str_cat := str_cat + str_cat ; 
        var i : int ; i := 1 ; while i < n do ( (     var curr_str : String ; curr_str := "" ;
         var j : int ; j := 0 ; while j < n do ( (     curr_str := curr_str + "-" + ((mat[i+1][j+1]) + "") )  ;     j := j + 1 ) ; 
     if (str_cat = (curr_str + "")) then (     return false ) else skip )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,2,3,4},Sequence{4,1,2,3},Sequence{3,4,1,2},Sequence{2,3,4,1}} ;
     if (isPermutedMatrix(mat, n)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class fiftyone {
  public static void main(String args[])throws Exception {
    BufferedReader inp=new BufferedReader(new InputStreamReader(System.in));
    int[] arr=Arrays.stream(inp.readLine().split("\\s+")).mapToInt(Integer :: parseInt).toArray();
    int n=arr[0],a=arr[1],b=arr[2],count=0 ;
    for(int i=1 ; i<=n ; i++){
      if(i-1>=a && n-i<=b){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class fiftyone {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inp : OclFile ; inp := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var arr : Sequence(int) ; arr := stream(inp.readLine()->split("\\s+"))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var n : int ; n := arr[0+1] ;
    var a : int ; a := arr[1+1] ;
    var b : int ; b := arr[2+1] ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (i - 1 >= a & n - i <= b) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
import static java.lang.System.out ;
public class pre130 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int n=obj.nextInt(),x=obj.nextInt(),y=obj.nextInt();
    char str[]=obj.next().toCharArray();
    int ans=0 ;
    char copy[]=new char[x+1];
    Arrays.fill(copy,'0');
    copy[0]='0' ;
    copy[x-y]='1' ;
    for(int i=n-1,j=copy.length-1 ; i>=0 && j>=1 ; i--,j--){
      if(copy[j]!=str[i])ans++;
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre130 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var n : int ; n := obj.nextInt() ;
    var x : int ; x := obj.nextInt() ;
    var y : int ; y := obj.nextInt() ;
    var str : Sequence(String) ; str := obj.next()->characters() ;
    var ans : int ; ans := 0 ;
    var copy : Sequence(String) ; copy := Integer.subrange(1,x + 1)->collect(0) ;
    copy := copy->collect('0') ; 
    copy[0+1] := '0' ; 
    copy[x - y+1] := '1' ; 
        var i : int ; i := n - 1 ;
    var j : int ; j := copy->size() - 1 ; while i >= 0 & j >= 1 do ( (     if (copy[j+1] /= str[i+1]) then     ans := ans + 1 ; else skip )  ;     i := i - 1 ;     j := j - 1 ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n<4){
      System.out.println("NO");
      return ;
    }
    System.out.println("YES");
    if(n % 2==0){
      System.out.println("1*2=2");
      System.out.println("2*3=6");
      System.out.println("6*4=24");
      for(int i=5 ; i<n ; i+=2){
        System.out.println((i+1)+"-"+i+"="+1);
        System.out.println("24*1=24");
      }
    }
    else {
      System.out.println("3+4=7");
      System.out.println("7+5=12");
      System.out.println("12*2=24");
      System.out.println("24*1=24");
      for(int i=6 ; i<n ; i+=2){
        System.out.println((i+1)+"-"+i+"="+1);
        System.out.println("24*1=24");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    if (n < 4) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    OclFile["System.out"].println("YES") ; 
    if (n mod 2 = 0) then (     OclFile["System.out"].println("1*2=2") ; 
     OclFile["System.out"].println("2*3=6") ; 
     OclFile["System.out"].println("6*4=24") ; 
         var i : int ; i := 5 ; while i < n do ( (     OclFile["System.out"].println((i + 1) + "-" + i + "=" + 1) ; 
     OclFile["System.out"].println("24*1=24") )  ;     i := i+(2) ) ) else (     OclFile["System.out"].println("3+4=7") ; 
     OclFile["System.out"].println("7+5=12") ; 
    OclFile["System.out"].println("12*2=24") ; 
    OclFile["System.out"].println("24*1=24") ; 
        var i : int ; i := 6 ; while i < n do ( (     OclFile["System.out"].println((i + 1) + "-" + i + "=" + 1) ; 
     OclFile["System.out"].println("24*1=24") )  ;     i := i+(2) ) ; 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    System.out.println(n-Math.max(a+1,n-b)+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(n - Set{a + 1, n - b}->max() + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    for(int i=1 ; i<=n ; i++){
      if(i-1>=a && n-i<=b){
        System.out.print(n-i+1);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= n do ( (     if (i - 1 >= a & n - i <= b) then (     OclFile["System.out"].print(n - i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void Sum_upto_nth_Term(int n){
    int r=n*(n+1)*(2*n+7)/3 ;
    System.out.println(r);
  }
  public static void main(String[] args){
    int N=5 ;
    Sum_upto_nth_Term(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Sum_upto_nth_Term( n : int) : void
  pre: true
  post: true
  activity: (     var r : int ; r := n * (n + 1) * (2 * n + 7) / 3 ;
     OclFile["System.out"].println(r) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     execute Sum_upto_nth_Term(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javax.swing.plaf.basic.BasicInternalFrameTitlePane ;
import java.io.*;
import java.math.*;
import java.nio.Buffer ;
import java.sql.SQLSyntaxErrorException ;
import java.util.*;
import java.text.*;
import java.util.regex.Pattern ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int n=cin.nextInt();
    int x=cin.nextInt();
    int y=cin.nextInt();
    int sum[]=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      for(int j=i ; j<=n ; j++){
        if(i==x && j==y){
          sum[1]++;
        }
        else {
          if(j>=y){
            int ant=Math.min(Math.abs(Math.abs(x-i)+1+j-y),j-i);
            sum[ant]++;
          }
          else {
            int cnt=Math.min(Math.abs(Math.abs(x-i)+1+Math.abs(j-y)),j-i);
            sum[cnt]++;
          }
        }
      }
    }
    for(int i=1 ; i<n ; i++){
      System.out.println(sum[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := cin.getCurrent()->toInteger() ;
    var x : int ; x := cin.getCurrent()->toInteger() ;
    var y : int ; y := cin.getCurrent()->toInteger() ;
    var sum : Sequence(int) ; sum := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i ; while j <= n do ( (     if (i = x & j = y) then (     sum[1+1] := sum[1+1] + 1 ) else (     if (j >= y) then (     var ant : int ; ant := Set{if if x - i < 0 then -(x - i) else x - i endif + 1 + j - y < 0 then -(if x - i < 0 then -(x - i) else x - i endif + 1 + j - y) else if x - i < 0 then -(x - i) else x - i endif + 1 + j - y endif, j - i}->min() ;
     sum[ant+1] := sum[ant+1] + 1 ) else (     var cnt : int ; cnt := Set{if if x - i < 0 then -(x - i) else x - i endif + 1 + if j - y < 0 then -(j - y) else j - y endif < 0 then -(if x - i < 0 then -(x - i) else x - i endif + 1 + if j - y < 0 then -(j - y) else j - y endif) else if x - i < 0 then -(x - i) else x - i endif + 1 + if j - y < 0 then -(j - y) else j - y endif endif, j - i}->min() ;
     sum[cnt+1] := sum[cnt+1] + 1 ) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     OclFile["System.out"].println(sum[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  @ SuppressWarnings("resource")public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int X=(sc.nextInt())-1 ;
    int Y=(sc.nextInt())-1 ;
    int ans[]=new int[N-1];
    for(int start=0 ; start<N-1 ; start++){
      for(int goal=start+1 ; goal<N ; goal++){
        if(start<=X){
          if(goal<=X){
            ans[goal-start-1]++;
          }
          else {
            if((X+Y+1)/2>=goal){
              ans[goal-start-1]++;
            }
            else {
              ans[X-start+Math.abs(goal-Y)]++;
            }
          }
        }
        else {
          if(start-X+Math.abs(goal-Y)+1<=goal-start){
            ans[start-X+Math.abs(goal-Y)]++;
          }
          else {
            ans[goal-start-1]++;
          }
        }
      }
    }
    for(int i=0 ; i<N-1 ; i++){
      System.out.println(ans[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var X : int ; X := (sc.getCurrent()->toInteger()) - 1 ;
    var Y : int ; Y := (sc.getCurrent()->toInteger()) - 1 ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,N - 1)->collect(0) ;
        var start : int ; start := 0 ; while start < N - 1 do ( (         var goal : int ; goal := start + 1 ; while goal < N do ( (     if (start <= X) then (     if (goal <= X) then (     ans[goal - start - 1+1] := ans[goal - start - 1+1] + 1 ) else (     if ((X + Y + 1) / 2 >= goal) then (     ans[goal - start - 1+1] := ans[goal - start - 1+1] + 1 ) else (     ans[X - start + if goal - Y < 0 then -(goal - Y) else goal - Y endif+1] := ans[X - start + if goal - Y < 0 then -(goal - Y) else goal - Y endif+1] + 1 ) ) ) else (     if (start - X + if goal - Y < 0 then -(goal - Y) else goal - Y endif + 1 <= goal - start) then (     ans[start - X + if goal - Y < 0 then -(goal - Y) else goal - Y endif+1] := ans[start - X + if goal - Y < 0 then -(goal - Y) else goal - Y endif+1] + 1 ) else (     ans[goal - start - 1+1] := ans[goal - start - 1+1] + 1 ) ) )  ;     goal := goal + 1 ) )  ;     start := start + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     OclFile["System.out"].println(ans[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static Scanner sc=new Scanner(System.in);
  static void p(String ans){
    System.out.println(ans);
  };
  static void p(int ans){
    System.out.println(ans);
  };
  static void p(long ans){
    System.out.println(ans);
  };
  public static void main(String[] args){
    int n=sc.nextInt();
    int x=sc.nextInt();
    int y=sc.nextInt();
    int ans[]=new int[n+1];
    int max=0 ;
    int k1 ;
    int k2 ;
    for(int i=1 ; i!=n ; i++){
      for(int j=i+1 ; j<n+1 ; j++){
        k1=j-i ;
        k2=Math.abs(x-i)+1+Math.abs(y-j);
        if(k1>k2){
          max=k2 ;
        }
        else if(k1<k2){
          max=k1 ;
        }
        else if(k1==k2){
          max=k1 ;
        }
        ans[max]++;
      }
    }
    for(int i=1 ; i!=n ; i++){
      p(ans[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation p( ans : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : long) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,n + 1)->collect(0) ;
    var max : int ; max := 0 ;
    var k1 : int ;
    var k2 : int ;
        var i : int ; i := 1 ; while i /= n do ( (         var j : int ; j := i + 1 ; while j < n + 1 do ( (     k1 := j - i ; 
     k2 := if x - i < 0 then -(x - i) else x - i endif + 1 + if y - j < 0 then -(y - j) else y - j endif ; 
     if (k1 > k2) then (     max := k2 ) else     if (k1 < k2) then (     max := k1 ) else     if (k1 = k2) then (     max := k1 ) else skip ; ;  ;  
     ans[max+1] := ans[max+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i /= n do ( (     execute p(ans[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayDeque ;
import java.util.Arrays ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x=sc.nextInt();
    int y=sc.nextInt();
    sc.close();
    int[] ans=new int[n];
    for(int i=1 ; i<n ; i++){
      Queue<Integer>que=new ArrayDeque<>();
      que.add(i);
      int[] d=new int[n+1];
      Arrays.fill(d,10000);
      d[i]=0 ;
      while(! que.isEmpty()){
        int cur=que.poll();
        if(cur<n){
          int next=cur+1 ;
          if(d[cur]+1<d[next]){
            d[next]=d[cur]+1 ;
            que.add(next);
          }
        }
        if(cur>x){
          int next=cur-1 ;
          if(d[cur]+1<d[next]){
            d[next]=d[cur]+1 ;
            que.add(next);
          }
        }
        if(cur==x){
          int next=y ;
          if(d[cur]+1<d[next]){
            d[next]=d[cur]+1 ;
            que.add(next);
          }
        }
      }
      for(int j=i+1 ; j<=n ; j++){
        ans[d[j] ]++;
      }
    }
    PrintWriter pw=new PrintWriter(System.out);
    for(int i=1 ; i<n ; i++){
      pw.println(ans[i]);
    }
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    skip ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 1 ; while i < n do ( (     var que : Sequence(int) ; que := ArrayDeque<OclAny>.newArrayDeque() ;
     que := que->including(i) ; 
    var d : Sequence(int) ; d := Integer.subrange(1,n + 1)->collect(0) ;
    d := d->collect(10000) ; 
    d[i+1] := 0 ; 
    while (not(que->isEmpty())) do (     var cur : int ; cur := que->min() ;
     if (cur < n) then (     var next : int ; next := cur + 1 ;
     if (d[cur+1] + 1 < d[next+1]) then (     d[next+1] := d[cur+1] + 1 ; 
     que := que->including(next) ) else skip ) else skip ; 
     if (cur > x) then (     var next : int ; next := cur - 1 ;
     if (d[cur+1] + 1 < d[next+1]) then (     d[next+1] := d[cur+1] + 1 ; 
     que := que->including(next) ) else skip ) else skip ; 
     if (cur = x) then (     var next : int ; next := y ;
     if (d[cur+1] + 1 < d[next+1]) then (     d[next+1] := d[cur+1] + 1 ; 
     que := que->including(next) ) else skip ) else skip ) ; 
        var j : int ; j := i + 1 ; while j <= n do ( (     ans[d[j+1]+1] := ans[d[j+1]+1] + 1 )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
        var i : int ; i := 1 ; while i < n do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x=sc.nextInt()-1 ;
    int y=sc.nextInt()-1 ;
    int jump=1 ;
    int[] arr=new int[n-1];
    Start start ;
    End end ;
    for(int i=0 ; i<n ; i++){
      if(i<x)start=Start.LEFT ;
      else if(i>=x && i<=y)start=Start.INSIDE ;
      else start=Start.RIGHT ;
      for(int j=i+1 ; j<n ; j++){
        if(j<x)end=End.LEFT ;
        else if(j>=x && j<=y)end=End.INSIDE ;
        else end=End.RIGHT ;
        if(start==Start.LEFT){
          if(end==End.LEFT)arr[j-i-1]++;
          else if(end==End.INSIDE){
            int distance=Math.min(j-i,x-i+jump+y-j);
            arr[distance-1]++;
          }
          else if(end==End.RIGHT){
            arr[x-i+jump+j-y-1]++;
          }
        }
        else if(start==Start.INSIDE){
          if(end==End.INSIDE){
            int distance=Math.min(j-i,i-x+jump+y-j);
            arr[distance-1]++;
          }
          else if(end==End.RIGHT){
            int distance=Math.min(j-i,i-x+jump+j-y);
            arr[distance-1]++;
          }
        }
        else if(start==Start.RIGHT){
          arr[j-i-1]++;
        }
      }
    }
    for(int a : arr)System.out.println(a);
  }
  enum Start {
    LEFT,INSIDE,RIGHT }
    enum End {
      LEFT,INSIDE,RIGHT }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
    var y : int ; y := sc.getCurrent()->toInteger() - 1 ;
    var jump : int ; jump := 1 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n - 1)->collect(0) ;
    var start : Start ;
    var end : End ;
        var i : int ; i := 0 ; while i < n do ( (     if (i < x) then     start := Start.LEFT else     if (i >= x & i <= y) then     start := Start.INSIDE else     start := Start.RIGHT ; ;  ;  
         var j : int ; j := i + 1 ; while j < n do ( (     if (j < x) then     end := End.LEFT else     if (j >= x & j <= y) then     end := End.INSIDE else     end := End.RIGHT ; ;  ;  
     if (start = Start.LEFT) then (     if (end = End.LEFT) then     arr[j - i - 1+1] := arr[j - i - 1+1] + 1 ; else     if (end = End.INSIDE) then (     var distance : int ; distance := Set{j - i, x - i + jump + y - j}->min() ;
     arr[distance - 1+1] := arr[distance - 1+1] + 1 ) else     if (end = End.RIGHT) then (     arr[x - i + jump + j - y - 1+1] := arr[x - i + jump + j - y - 1+1] + 1 ) else skip ; ;  ) else     if (start = Start.INSIDE) then (     if (end = End.INSIDE) then (     var distance : int ; distance := Set{j - i, i - x + jump + y - j}->min() ;
     arr[distance - 1+1] := arr[distance - 1+1] + 1 ) else     if (end = End.RIGHT) then (     var distance : int ; distance := Set{j - i, i - x + jump + j - y}->min() ;
     arr[distance - 1+1] := arr[distance - 1+1] + 1 ) else skip ; ) else     if (start = Start.RIGHT) then (     arr[j - i - 1+1] := arr[j - i - 1+1] + 1 ) else skip ; ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    for (a : arr) do (     OclFile["System.out"].println(a) ;  ) ; 
 );
   enumeration Start {  literal LEFT;  literal INSIDE;  literal RIGHT }
   enumeration End {  literal LEFT;  literal INSIDE;  literal RIGHT }
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  private static final FastReader fr=new FastReader();
  public static void main(String[] args)throws IOException {
    BufferedWriter output=new BufferedWriter(new OutputStreamWriter(System.out));
    StringBuilder sb=new StringBuilder();
    int testCases=fr.nextInt();
    for(int testCase=0 ; testCase<testCases ; testCase++){
      int n=fr.nextInt();
      long x=fr.nextLong();
      long y=fr.nextLong();
      long sum=0L ;
      for(int i=0 ; i<n ; i++)sum+=fr.nextLong();
      if(sum % 2==0){
        if(y % 2==x % 2)sb.append("Alice\n");
        else sb.append("Bob\n");
      }
      else {
        if(y % 2==x % 2)sb.append("Bob\n");
        else sb.append("Alice\n");
      }
    }
    output.write(sb.toString());
    output.flush();
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    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 {
      if(st.hasMoreTokens()){
        str=st.nextToken("\n");
      }
      else {
        str=br.readLine();
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return str ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static    attribute fr : FastReader := FastReader.newFastReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var output : OclFile ; output := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var testCases : int ; testCases := fr.nextInt() ;
        var testCase : int ; testCase := 0 ; while testCase < testCases do ( (     var n : int ; n := fr.nextInt() ;
     var x : long ; x := fr.nextLong() ;
    var y : long ; y := fr.nextLong() ;
    var sum : long ; sum := 0L ;
        var i : int ; i := 0 ; while i < n do (     sum := sum+(fr.nextLong()) ;  ;     i := i + 1 ) ; 
    if (sum mod 2 = 0) then (     if (y mod 2 = x mod 2) then     sb := sb + StringLib.newString("Alice\n") ; else     sb := sb + StringLib.newString("Bob\n") ; ) else (     if (y mod 2 = x mod 2) then     sb := sb + StringLib.newString("Bob\n") ; else     sb := sb + StringLib.newString("Alice\n") ; ) ;  
 )  ;     testCase := testCase + 1 ) ; 
    skip ; 
    skip ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class FortuneTelling {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int testCases=Integer.parseInt(scanner.nextLine());
    for(int i=0 ; i<testCases ; i++){
      long[] nxy=readLongArray(scanner," ");
      long[] array=readLongArray(scanner," ");
      test(nxy,array);
    }
  }
  private static void test(long[] nxy,long[] array){
    long xor=nxy[1] ^ nxy[2];
    for(long n : array){
      xor ^=n ;
    }
    System.out.println((0==(xor & 1))? "Alice" : "Bob");
  }
  public static long[] readLongArray(Scanner scanner,String delimiter){
    String[] split=scanner.nextLine().split(delimiter);
    long[] array=new long[split.length];
    for(int i=0 ; i<split.length ; i++){
      array[i]=Long.parseLong(split[i]);
    }
    return array ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class FortuneTelling {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := (scanner.nextLine())->toInteger() ;
         var i : int ; i := 0 ; while i < testCases do ( (     var nxy : Sequence(long) ; nxy := readLongArray(scanner, " ") ;
     var array : Sequence(long) ; array := readLongArray(scanner, " ") ;
     execute test(nxy, array) )  ;     i := i + 1 ) );
  static   operation test( nxy : Sequence(long), array : Sequence(long)) : void
  pre: true
  post: true
  activity: (     var xor : long ; xor := MathLib.bitwiseXor(nxy[1+1],nxy[2+1]) ;
     for (n : array) do ( (     xor := MathLib.bitwiseXor(xor,n) )  ) ; 
     OclFile["System.out"].println(if (0 = (MathLib.bitwiseAnd(xor,1))) then "Alice" else "Bob" endif) );
  static   operation readLongArray( scanner : OclFile, delimiter : String) : Sequence(long)
  pre: true
  post: true
  activity: (     var split : Sequence(String) ; split := scanner.nextLine()->split(delimiter) ;
     var array : Sequence(long) ; array := Integer.subrange(1,split->size())->collect(0) ;
         var i : int ; i := 0 ; while i < split->size() do ( (     array[i+1] := (split[i+1])->toLong() )  ;     i := i + 1 ) ; 
     return array );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Random ;
public class Main {
  private void solve()throws IOException {
    new Main().solve();
  }
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    Random r=new Random();
    int n=Integer.parseInt(f.readLine());
    long[] nums=new long[n];
    for(int i=0 ; i<n ; i++){
      char[] seq=f.readLine().toCharArray();
      long firstMultiply=1000000000 ;
      boolean passedDot=false ;
      for(int j=0 ; j<seq.length ; j++){
        if(passedDot)firstMultiply/=10 ;
        if(seq[j]=='.')passedDot=true ;
      }
      long value=0 ;
      for(int j=seq.length-1 ; j>=0 ; j--){
        if(seq[j]=='.')continue ;
        value+=(seq[j]-'0')*firstMultiply ;
        firstMultiply*=10 ;
      }
      nums[i]=value ;
    }
    int[][] atLeast=new int[50][50];
    long pairs=0 ;
    for(int i=0 ; i<n ; i++){
      int diviedByTwo=0 ;
      int dividedByFive=0 ;
      while(nums[i] % 2==0){
        diviedByTwo++;
        nums[i]/=2 ;
      }
      while(nums[i] % 5==0){
        dividedByFive++;
        nums[i]/=5 ;
      }
      for(int j=Math.max(18-diviedByTwo,0); j<50 ; j++){
        for(int k=Math.max(18-dividedByFive,0); k<50 ; k++){
          pairs+=atLeast[j][k];
        }
      }
      atLeast[diviedByTwo][dividedByFive]++;
    }
    out.println(pairs);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var r : OclRandom ; r := OclRandom.newOclRandom() ;
    var n : int ; n := (f.readLine())->toInteger() ;
    var nums : Sequence(long) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var seq : Sequence(String) ; seq := f.readLine()->characters() ;
     var firstMultiply : long ; firstMultiply := 1000000000 ;
    var passedDot : boolean ; passedDot := false ;
        var j : int ; j := 0 ; while j < seq->size() do ( (     if (passedDot) then     firstMultiply := firstMultiply/(10) ; else skip ; 
     if (seq[j+1] = '.') then     passedDot := true ; else skip )  ;     j := j + 1 ) ; 
    var value : long ; value := 0 ;
        var j : int ; j := seq->size() - 1 ; while j >= 0 do ( (     if (seq[j+1] = '.') then     continue else skip ; 
     value := value+((seq[j+1] - ('0')->char2byte()) * firstMultiply) ; 
     firstMultiply := firstMultiply*(10) )  ;     j := j - 1 ) ; 
    nums[i+1] := value ; 
 )  ;     i := i + 1 ) ; 
    var atLeast : Sequence(Sequence(int)) ; atLeast := Integer.subrange(1,50)->collect(Integer.subrange(1,50)->collect(0)) ;
    var pairs : long ; pairs := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var diviedByTwo : int ; diviedByTwo := 0 ;
     var dividedByFive : int ; dividedByFive := 0 ;
    while (nums[i+1] mod 2 = 0) do (     diviedByTwo := diviedByTwo + 1 ; 
     nums[i+1] := nums[i+1]/(2) ) ; 
    while (nums[i+1] mod 5 = 0) do (     dividedByFive := dividedByFive + 1 ; 
     nums[i+1] := nums[i+1]/(5) ) ; 
        var j : int ; j := Set{18 - diviedByTwo, 0}->max() ; while j < 50 do ( (         var k : int ; k := Set{18 - dividedByFive, 0}->max() ; while k < 50 do ( (     pairs := pairs+(atLeast[j+1][k+1]) )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    atLeast[diviedByTwo+1][dividedByFive+1] := atLeast[diviedByTwo+1][dividedByFive+1] + 1 ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solve {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader read=new FastReader();
    int t=read.nextInt();
    while(t>0){
      int length=read.nextInt();
      long alice=read.nextLong();
      long value=read.nextLong();
      long sum=0 ;
      for(int i=0 ; i<length ; i++)sum+=read.nextInt();
      if((sum+alice+value)% 2==0)System.out.println("Alice");
      else System.out.println("Bob");
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solve {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : FastReader ; read := FastReader.newFastReader() ;
     var t : int ; t := read.nextInt() ;
     while (t > 0) do (     var length : int ; length := read.nextInt() ;
     var alice : long ; alice := read.nextLong() ;
    var value : long ; value := read.nextLong() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < length do (     sum := sum+(read.nextInt()) ;  ;     i := i + 1 ) ; 
    if ((sum + alice + value) mod 2 = 0) then     OclFile["System.out"].println("Alice") else     OclFile["System.out"].println("Bob") ; ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class FortuneTelling {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t!=0){
      solve(br,pr);
      t--;
    }
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    String[] temp=br.readLine().split(" ");
    long n=Long.parseLong(temp[0]);
    long x=Long.parseLong(temp[1]);
    long y=Long.parseLong(temp[2]);
    long sum=0 ;
    temp=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      sum+=Long.parseLong(temp[i]);
    }
    if(sum % 2==1){
      pr.println(x % 2==y % 2 ? "Bob" : "Alice");
    }
    else {
      pr.println(x % 2==y % 2 ? "Alice" : "Bob");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class FortuneTelling {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
    while (t /= 0) do (     execute solve(br, pr) ; 
     t := t - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
     var n : long ; n := (temp[0+1])->toLong() ;
    var x : long ; x := (temp[1+1])->toLong() ;
    var y : long ; y := (temp[2+1])->toLong() ;
    var sum : long ; sum := 0 ;
    temp := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+((temp[i+1])->toLong()) )  ;     i := i + 1 ) ; 
    if (sum mod 2 = 1) then (     skip ) else (     skip ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1634 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      int X=in.nextInt();
      long Y=in.nextLong();
      long sum=X ;
      for(int n=0 ; n<N ; n++){
        sum+=in.nextInt();
      }
      boolean alice=(Y % 2)==(sum % 2);
      System.out.println(alice ? "Alice" : "Bob");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1634 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var X : int ; X := in.getCurrent()->toInteger() ;
    var Y : long ; Y := in.getCurrent()->toLong() ;
    var sum : long ; sum := X ;
        var n : int ; n := 0 ; while n < N do ( (     sum := sum+(in.getCurrent()->toInteger()) )  ;     n := n + 1 ) ; 
    var alice : boolean ; alice := (Y mod 2) = (sum mod 2) ;
    OclFile["System.out"].println(if alice then "Alice" else "Bob" endif) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class code1 {
  static class pair {
    long idx,value ;
    public pair(long x,long y){
      this.idx=x ;
      this.value=y ;
    }
  }
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int t=sc.nextInt();
    while(t-->0){
      solve();
    }
  }
  static void solve(){
    int n=sc.nextInt();
    long[] a=new long[n];
    long sum=0 ;
    long mx=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      mx=Math.max(mx,a[i]);
      sum+=a[i];
    }
    if(sum==0){
      System.out.println(0);
      return ;
    }
    sum-=mx ;
    if(sum>=mx-1){
      System.out.println(1);
      return ;
    }
    System.out.println(1+mx-sum-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class code1 {
  static class pair {
   attribute idx : long;
   static operation newpair( x : long, y : long) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(x, y);
    return self );
  operation initialise( x : long, y : long) : void
  pre: true  post: true
  activity: (     self.idx := x ; 
     self.value := y );
}
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
    var mx : long ; mx := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     mx := Set{mx, a[i+1]}->max() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    if (sum = 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    sum := sum-(mx) ; 
    if (sum >= mx - 1) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    OclFile["System.out"].println(1 + mx - sum - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      int con=0 ;
      long[] arr=new long[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextLong();
        if(arr[i]!=0){
          con=1 ;
        }
      }
      long max=-1 ;
      for(int i=0 ; i<n ; i++){
        if(arr[i]>max){
          max=arr[i];
        }
      }
      long sum=Arrays.stream(arr).sum();
      if(con==0){
        System.out.println(0);
      }
      else if(2*max>sum){
        System.out.println(2*max-sum);
      }
      else {
        System.out.println(1);
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var con : int ; con := 0 ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toLong() ; 
     if (arr[i+1] /= 0) then (     con := 1 ) else skip )  ;     i := i + 1 ) ; 
    var max : long ; max := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] > max) then (     max := arr[i+1] ) else skip )  ;     i := i + 1 ) ; 
    var sum : long ; sum := stream(arr)->sum() ;
    if (con = 0) then (     OclFile["System.out"].println(0) ) else     if (2 * max > sum) then (     OclFile["System.out"].println(2 * max - sum) ) else (     OclFile["System.out"].println(1) ) ;  ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Main ak=new Main();
    ak.solve(sc);
  }
  void solve(Scanner in){
    int n=in.nextInt();
    int m=in.nextInt();
    int[][] arr=new int[m][2];
    for(int i=0 ; i<m ; i++){
      arr[i]=new int[] {
        in.nextInt(),in.nextInt()};
      }
      int[] par=new int[n+1];
      Arrays.fill(par,-1);
      for(int i=0 ; i<m ; i++){
        union(par,arr[i][0],arr[i][1]);
      }
      int cnt=0 ;
      for(int i=1 ; i<=n ; i++){
        if(par[i]<0)cnt++;
      }
      System.out.println(cnt-1);
    }
    int find(int[] par,int i){
      if(par[i]<0)return i ;
      return par[i]=find(par,par[i]);
    }
    void union(int[] par,int i,int j){
      int pi=find(par,i);
      int pj=find(par,j);
      if(pi==pj)return ;
      if(par[pi]<par[pj]){
        par[pi]+=par[pj];
        par[pj]=pi ;
      }
      else {
        par[pj]+=par[pi];
        par[pi]=pj ;
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ak : Main ; ak := Main.newMain() ;
     ak.solve(sc) );
   operation solve( in : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var m : int ; m := in.nextInt() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,m)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (     arr[i+1] := Sequence{in.nextInt(),in.nextInt()} )  ;     i := i + 1 ) ; 
    var par : Sequence(int) ; par := Integer.subrange(1,n + 1)->collect(0) ;
    par := par->collect(-1) ; 
        var i : int ; i := 0 ; while i < m do ( (     execute union(par, arr[i+1][0+1], arr[i+1][1+1]) )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (par[i+1] < 0) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt - 1) ; 
 );
   operation find( par : Sequence(int), i : int) : int
  pre: true
  post: true
  activity: (     if (par[i+1] < 0) then     return i else skip ; 
     return par[i+1] );
   operation union( par : Sequence(int), i : int, j : int) : void
  pre: true
  post: true
  activity: (     var pi : int ; pi := find(par, i) ;
     var pj : int ; pj := find(par, j) ;
     if (pi = pj) then     return else skip ; 
     if (par[pi+1] < par[pj+1]) then (     par[pi+1] := par[pi+1]+(par[pj+1]) ; 
     par[pj+1] := pi ) else (     par[pj+1] := par[pj+1]+(par[pi+1]) ; 
     par[pi+1] := pj ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solve {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader read=new FastReader();
    int testCases=read.nextInt();
    while(testCases>0){
      int length=read.nextInt();
      long max=0 ;
      long sum=0 ;
      for(int i=0 ; i<length ; i++){
        long cur=read.nextLong();
        sum+=cur ;
        max=Math.max(max,cur);
      }
      if(max*2<sum ||(max*2==sum && sum!=0))System.out.println(1);
      else System.out.println(max*2-sum);
      testCases--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solve {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : FastReader ; read := FastReader.newFastReader() ;
     var testCases : int ; testCases := read.nextInt() ;
     while (testCases > 0) do (     var length : int ; length := read.nextInt() ;
     var max : long ; max := 0 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < length do ( (     var cur : long ; cur := read.nextLong() ;
     sum := sum+(cur) ; 
     max := Set{max, cur}->max() )  ;     i := i + 1 ) ; 
    if (max * 2 < sum or (max * 2 = sum & sum /= 0)) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println(max * 2 - sum) ; ;  
    testCases := testCases - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B1649 {
  public static void main(String ar[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      int n=sc.nextInt();
      int a[]=new int[n];
      long sum=0 ;
      int max=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
        if(a[i]>max){
          max=a[i];
        }
        sum+=a[i];
      }
      if(max==0 && sum==0){
        System.out.println("0");
      }
      else if(sum-max>=max-1){
        System.out.println("1");
      }
      else {
        System.out.println(2*max-sum);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1649 {
  static   operation main( ar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tt : int ; tt := 0 ; while tt < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (a[i+1] > max) then (     max := a[i+1] ) else skip ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    if (max = 0 & sum = 0) then (     OclFile["System.out"].println("0") ) else     if (sum - max >= max - 1) then (     OclFile["System.out"].println("1") ) else (     OclFile["System.out"].println(2 * max - sum) ) ;  ;  
 )  ;     tt := tt + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    int N=sc.nextInt();
    String[] in1=new String[N];
    String[] in2=new String[N];
    for(int i=0 ; i<N ; i++){
      String s=sc.next();
      in1[i]=s ;
      in2[i]=s ;
    }
    for(int i=1 ; i<N ; i++){
      for(int j=N-1 ; j>=i ; j--){
        if(in1[j] .charAt(1)<in1[j-1] .charAt(1)){
          String tmp=in1[j];
          in1[j]=in1[j-1];
          in1[j-1]=tmp ;
        }
      }
    }
    for(int i=0 ; i<N ; i++){
      int min=i ;
      for(int j=i+1 ; j<N ; j++){
        if(in2[min] .charAt(1)>in2[j] .charAt(1)){
          min=j ;
        }
      }
      String tmp=in2[i];
      in2[i]=in2[min];
      in2[min]=tmp ;
    }
    print(in1);
    System.out.println("Stable");
    print(in2);
    System.out.println(match(in1,in2)? "Stable" : "Not stable");
  }
  void print(String[] s){
    for(int i=0 ; i<s.length ; i++){
      System.out.print((i==0 ? "" : " ")+s[i]);
    }
    System.out.println();
  }
  boolean match(String[] s1,String[] s2){
    for(int i=0 ; i<s1.length ; i++){
      if(! s1[i] .equals(s2[i])){
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var in1 : Sequence(String) ; in1 := Integer.subrange(1,N)->collect(null) ;
    var in2 : Sequence(String) ; in2 := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     var s : String ; s := sc.getCurrent() ;
     in1[i+1] := s ; 
     in2[i+1] := s )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < N do ( (         var j : int ; j := N - 1 ; while j >= i do ( (     if (in1[j+1]->at(1+1) < in1[j - 1+1]->at(1+1)) then (     var tmp : String ; tmp := in1[j+1] ;
     in1[j+1] := in1[j - 1+1] ; 
     in1[j - 1+1] := tmp ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var min : int ; min := i ;
         var j : int ; j := i + 1 ; while j < N do ( (     if (in2[min+1]->at(1+1) > in2[j+1]->at(1+1)) then (     min := j ) else skip )  ;     j := j + 1 ) ; 
    var tmp : String ; tmp := in2[i+1] ;
    in2[i+1] := in2[min+1] ; 
    in2[min+1] := tmp ; 
 )  ;     i := i + 1 ) ; 
    execute print(in1) ; 
    OclFile["System.out"].println("Stable") ; 
    execute print(in2) ; 
    OclFile["System.out"].println(if match(in1, in2) then "Stable" else "Not stable" endif) ; 
 );
   operation print( s : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() do ( (     OclFile["System.out"].print((if i = 0 then "" else " " endif) + s[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
   operation match( s1 : Sequence(String), s2 : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s1->size() do ( (     if (not(s1[i+1] = s2[i+1])) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sc.nextLine();
    String str=sc.nextLine(),temp ;
    int mini ;
    boolean sStable=true ;
    String[] A=str.split(" "),B=str.split(" ");
    for(int i=0 ; i<=A.length-1 ; i++){
      for(int j=A.length-1 ; j>=i+1 ; j--){
        if(Integer.parseInt(A[j] .replaceAll("[\\D] ",""))<Integer.parseInt(A[j-1] .replaceAll("[\\D] ",""))){
          temp=A[j];
          A[j]=A[j-1];
          A[j-1]=temp ;
        }
      }
    }
    for(int i=0 ; i<A.length-1 ; i++){
      System.out.print(A[i]+" ");
    }
    System.out.println(A[A.length-1]+"\nStable");
    for(int i=0 ; i<=B.length-1 ; i++){
      mini=i ;
      for(int j=i ; j<=B.length-1 ; j++){
        if(Integer.parseInt(B[j] .replaceAll("[\\D] ",""))<Integer.parseInt(B[mini] .replaceAll("[\\D] ",""))){
          mini=j ;
        }
      }
      temp=B[i];
      B[i]=B[mini];
      B[mini]=temp ;
    }
    for(int i=0 ; i<B.length ; i++){
      sStable &=A[i] .equals(B[i]);
    }
    for(int i=0 ; i<B.length-1 ; i++){
      System.out.print(B[i]+" ");
    }
    System.out.println(B[B.length-1]);
    if(sStable){
      System.out.println("Stable");
    }
    else {
      System.out.println("Not stable");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var str : String ; str := sc.nextLine() ;
    var temp : String ;
    var mini : int ;
    var sStable : boolean ; sStable := true ;
    var A : Sequence(String) ; A := str->split(" ") ;
    var B : Sequence(String) ; B := str->split(" ") ;
        var i : int ; i := 0 ; while i <= A->size() - 1 do ( (         var j : int ; j := A->size() - 1 ; while j >= i + 1 do ( (     if ((A[j+1].replaceAllMatches("[\\D] ", "" ))->toInteger() < (A[j - 1+1].replaceAllMatches("[\\D] ", "" ))->toInteger()) then (     temp := A[j+1] ; 
     A[j+1] := A[j - 1+1] ; 
     A[j - 1+1] := temp ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < A->size() - 1 do ( (     OclFile["System.out"].print(A[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(A[A->size() - 1+1] + "\nStable") ; 
        var i : int ; i := 0 ; while i <= B->size() - 1 do ( (     mini := i ; 
         var j : int ; j := i ; while j <= B->size() - 1 do ( (     if ((B[j+1].replaceAllMatches("[\\D] ", "" ))->toInteger() < (B[mini+1].replaceAllMatches("[\\D] ", "" ))->toInteger()) then (     mini := j ) else skip )  ;     j := j + 1 ) ; 
    temp := B[i+1] ; 
    B[i+1] := B[mini+1] ; 
    B[mini+1] := temp ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < B->size() do ( (     sStable := MathLib.bitwiseAnd(sStable, A[i+1] = B[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < B->size() - 1 do ( (     OclFile["System.out"].print(B[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(B[B->size() - 1+1]) ; 
    if (sStable) then (     OclFile["System.out"].println("Stable") ) else (     OclFile["System.out"].println("Not stable") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  static void print(String[] s){
    for(int i=0 ; i<s.length-1 ; i++){
      System.out.print(s[i]+" ");
    }
    System.out.println(s[s.length-1]);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    String[] a=new String[n];
    String[] b=new String[n];
    for(int i=0 ; i<n ; i++){
      String s=sc.next();
      a[i]=s ;
      b[i]=s ;
    }
    for(int i=0 ; i<n ; i++){
      for(int j=n-1 ; j>=i+1 ; j--){
        if(a[j] .charAt(1)<a[j-1] .charAt(1)){
          String tmp=a[j];
          a[j]=a[j-1];
          a[j-1]=tmp ;
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      int minj=i ;
      for(int j=i+1 ; j<n ; j++){
        if(b[j] .charAt(1)<b[minj] .charAt(1))minj=j ;
      }
      String tmp=b[minj];
      b[minj]=b[i];
      b[i]=tmp ;
    }
    print(a);
    System.out.println("Stable");
    print(b);
    boolean isStable=true ;
    for(int i=0 ; i<n ; i++){
      if(! a[i] .equals(b[i]))isStable=false ;
    }
    if(isStable){
      System.out.println("Stable");
    }
    else {
      System.out.println("Not stable");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation print( s : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() - 1 do ( (     OclFile["System.out"].print(s[i+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(s[s->size() - 1+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var a : Sequence(String) ; a := Integer.subrange(1,n)->collect(null) ;
    var b : Sequence(String) ; b := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
     a[i+1] := s ; 
     b[i+1] := s )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := n - 1 ; while j >= i + 1 do ( (     if (a[j+1]->at(1+1) < a[j - 1+1]->at(1+1)) then (     var tmp : String ; tmp := a[j+1] ;
     a[j+1] := a[j - 1+1] ; 
     a[j - 1+1] := tmp ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var minj : int ; minj := i ;
         var j : int ; j := i + 1 ; while j < n do ( (     if (b[j+1]->at(1+1) < b[minj+1]->at(1+1)) then     minj := j ; else skip )  ;     j := j + 1 ) ; 
    var tmp : String ; tmp := b[minj+1] ;
    b[minj+1] := b[i+1] ; 
    b[i+1] := tmp ; 
 )  ;     i := i + 1 ) ; 
    execute print(a) ; 
    OclFile["System.out"].println("Stable") ; 
    execute print(b) ; 
    var isStable : boolean ; isStable := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (not(a[i+1] = b[i+1])) then     isStable := false ; else skip )  ;     i := i + 1 ) ; 
    if (isStable) then (     OclFile["System.out"].println("Stable") ) else (     OclFile["System.out"].println("Not stable") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[][] cnt=new long[20][20];
    long ans=0 ;
    for(int i=0 ; i<N ; ++i){
      double A=sc.nextDouble();
      int c5=-9,c2=-9 ;
      long a=(long)(A*1e9+.1);
      while(c5<9 && a % 5==0){
++c5 ;
        a/=5 ;
      }
      while(c2<9 && a % 2==0){
++c2 ;
        a/=2 ;
      }
      for(int u=-10 ; u<10 ; ++u){
        for(int v=-10 ; v<10 ; ++v){
          if(u+c2>=0 && v+c5>=0)ans+=cnt[u+9][v+9];
        }
      }
      cnt[c2+9][c5+9]++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var cnt : Sequence(Sequence(long)) ; cnt := Integer.subrange(1,20)->collect(Integer.subrange(1,20)->collect(0)) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var A : double ; A := sc.getCurrent()->toReal() ;
     var c5 : int ; c5 := -9 ;
    var c2 : int ; c2 := -9 ;
    var a : long ; a := (A * 1e9 + .1)->oclAsType(long) ;
    while (c5 < 9 & a mod 5 = 0) do (     c5 := c5 + 1 ; 
     a := a/(5) ) ; 
    while (c2 < 9 & a mod 2 = 0) do (     c2 := c2 + 1 ; 
     a := a/(2) ) ; 
        var u : int ; u := -10 ; while u < 10 do ( (         var v : int ; v := -10 ; while v < 10 do ( (     if (u + c2 >= 0 & v + c5 >= 0) then     ans := ans+(cnt[u + 9+1][v + 9+1]) ; else skip )  ;     v := v + 1 ) )  ;     u := u + 1 ) ; 
    cnt[c2 + 9+1][c5 + 9+1] := cnt[c2 + 9+1][c5 + 9+1] + 1 ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void farey(int n){
    double x1=0,y1=1,x2=1,y2=n ;
    System.out.printf("%.0f/%.0f %.0f/%.0f",x1,y1,x2,y2);
    double x,y=0 ;
    while(y!=1.0){
      x=Math.floor((y1+n)/y2)*x2-x1 ;
      y=Math.floor((y1+n)/y2)*y2-y1 ;
      System.out.printf(" %.0f/%.0f",x,y);
      x1=x2 ;
      x2=x ;
      y1=y2 ;
      y2=y ;
    }
  }
  public static void main(String[] args){
    int n=7 ;
    System.out.print("Farey Sequence of order "+n+" is\n");
    farey(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation farey( n : int) : void
  pre: true
  post: true
  activity: (     var x1 : double ; x1 := 0 ;
    var y1 : double ; y1 := 1 ;
    var x2 : double ; x2 := 1 ;
    var y2 : double ; y2 := n ;
     OclFile["System.out"].printf("%.0f/%.0f %.0f/%.0f", x1, y1, x2, y2) ; 
     var x : double ;
    var y : double ; y := 0 ;
     while (y /= 1.0) do (     x := ((y1 + n) / y2)->floor() * x2 - x1 ; 
     y := ((y1 + n) / y2)->floor() * y2 - y1 ; 
    OclFile["System.out"].printf(" %.0f/%.0f", x, y) ; 
    x1 := x2 ; 
    x2 := x ; 
    y1 := y2 ; 
    y2 := y ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     OclFile["System.out"].print("Farey Sequence of order " + n + " is\n") ; 
     execute farey(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Throwable {
    MyScanner sc=new MyScanner();
    PrintWriter pw=new PrintWriter(System.out);
    String s=sc.next();
    int n=s.length();
    int[] c=new int[26];
    for(int i=0 ; i<n ; i++)c[s.charAt(i)-'a']++;
    long ans=1 ;
    for(int i=0 ; i<n ; i++){
      c[s.charAt(i)-'a']--;
      int t=0 ;
      for(int j=0 ; j<26 ; j++)if(j!=s.charAt(i)-'a')t+=c[j];
      ans+=t ;
    }
    pw.println(ans);
    pw.flush();
    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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : String ; s := sc.next() ;
    var n : int ; n := s->size() ;
    var c : Sequence(int) ; c := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     c[s->at(i+1) - ('a')->char2byte()+1] := c[s->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     c[s->at(i+1) - ('a')->char2byte()+1] := c[s->at(i+1) - ('a')->char2byte()+1] - 1 ; 
     var t : int ; t := 0 ;
         var j : int ; j := 0 ; while j < 26 do (     if (j /= s->at(i+1) - ('a')->char2byte()) then     t := t+(c[j+1]) ; else skip ;  ;     j := j + 1 ) ; 
     ans := ans+(t) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String A=sc.nextLine();
    char b[]=A.toCharArray();
    long N=b.length ;
    Arrays.sort(b);
    int i=0 ;
    char x='a' ;
    long c=0 ;
    long ans=N*(N-1)/2+1 ;
    while(i<N){
      while(i<N && x==b[i]){
        c++;
        i++;
      }
      ans=ans-c*(c-1)/2 ;
      x++;
      c=0 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : String ; A := sc.nextLine() ;
    var b : Sequence(String) ; b := A->characters() ;
    var N : long ; N := b->size() ;
    b := b->sort() ; 
    var i : int ; i := 0 ;
    var x : String ; x := 'a' ;
    var c : long ; c := 0 ;
    var ans : long ; ans := N * ((N)->char2byte() - 1) / 2 + 1 ;
    while (i < N) do (     while (i < N & x = b[i+1]) do (     c := c + 1 ; 
     i := i + 1 ) ; 
     ans := ans - c * ((c)->char2byte() - 1) / 2 ; 
     x := x + 1 ; 
     c := 0 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String input=br.readLine();
    long[] charCount=new long[26];
    long n=input.length();
    for(int i=0 ; i<input.length(); i++){
      charCount[input.charAt(i)-'a']++;
    }
    long result=0 ;
    result=n*(n-1)/2 ;
    for(int i=0 ; i<charCount.length ; i++){
      if(charCount[i]>=2){
        result-=charCount[i]*(charCount[i]-1)/2 ;
      }
    }
    result++;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : String ; input := br.readLine() ;
    var charCount : Sequence(long) ; charCount := Integer.subrange(1,26)->collect(0) ;
    var n : long ; n := input->size() ;
        var i : int ; i := 0 ; while i < input->size() do ( (     charCount[input->at(i+1) - ('a')->char2byte()+1] := charCount[input->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    var result : long ; result := 0 ;
    result := n * (n - 1) / 2 ; 
        var i : int ; i := 0 ; while i < charCount->size() do ( (     if (charCount[i+1] >= 2) then (     result := result-(charCount[i+1] * (charCount[i+1] - 1) / 2) ) else skip )  ;     i := i + 1 ) ; 
    result := result + 1 ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  static Scanner sc ;
  static PrintWriter out ;
  public static void main(String[] args){
    sc=new Scanner(System.in);
    out=new PrintWriter(System.out);
    new Main().solve();
    out.flush();
  }
  public void solve(){
    int n=sc.nextInt();
    int m=sc.nextInt();
    UF uf=new UF(n);
    for(int i=0 ; i<m ; i++){
      uf.join(sc.nextInt()-1,sc.nextInt()-1);
    }
    Set<Integer>set=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      set.add(uf.root(i));
    }
    out.println(set.size()-1);
  }
  static class UF {
    int[] p ;
    int n ;
    UF(int n){
      this.n=n ;
      p=new int[n];
      for(int i=0 ; i<n ; i++){
        p[i]=i ;
      }
    }
    int root(int a){
      if(p[a]==a){
        return a ;
      }
      int res=root(p[a]);
      p[a]=res ;
      return res ;
    }
    void join(int a,int b){
      p[root(a)]=p[root(b)];
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile;
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     Main.newMain().solve() ; 
     skip );
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var uf : UF ; uf := UF.newUF(n) ;
        var i : int ; i := 0 ; while i < m do ( (     uf.join(sc.getCurrent()->toInteger() - 1, sc.getCurrent()->toInteger() - 1) )  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     set := set->including(uf.root(i)) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class UF {
   attribute p : Sequence(int);
   attribute n : int;
   static operation newUF( n : int) : UF
  pre: true
  post: true
  activity:
  ( var self : UF ;
    self := createUF();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     self.n := n ; 
     p := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do ( (     p[i+1] := i )  ;     i := i + 1 ) );
   operation root( a : int) : int
  pre: true
  post: true
  activity: (     if (p[a+1] = a) then (     return a ) else skip ; 
     var res : int ; res := root(p[a+1]) ;
     p[a+1] := res ; 
     return res );
   operation join( a : int, b : int) : void
  pre: true
  post: true
  activity: (     p[root(a)+1] := p[root(b)+1] );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main implements Runnable {
  private static BufferedReader in ;
  private static PrintWriter out ;
  private static StringTokenizer st ;
  private static Random rnd ;
  private void solve()throws IOException {
    String initialString=nextToken();
    char[] letters=initialString.toCharArray();
    long result=1 ;
    int length=letters.length ;
    long[] count=new long[26];
    for(int i=0 ; i<length ; i++){
      int k=letters[i]-'a' ;
      for(int j=0 ; j<count.length ; j++){
        if(j!=k){
          result+=count[j];
        }
      }
      count[k]+=1 ;
    }
    out.println(result);
  }
  private void reverse(char[] copy,int i,int j){
    while(i<j){
      char t=copy[i];
      copy[i]=copy[j];
      copy[j]=t ;
++i ;
--j ;
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  public void run(){
    try {
      in=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(System.out);
      rnd=new Random();
      solve();
      out.close();
    }
    catch(IOException e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  private String nextToken()throws IOException {
    while(st==null || ! st.hasMoreTokens()){
      String line=in.readLine();
      if(line==null)return null ;
      st=new StringTokenizer(line);
    }
    return st.nextToken();
  }
  private int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  private long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  private double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute st : OclIterator;
  static   attribute rnd : OclRandom;
   operation solve() : void
  pre: true
  post: true
  activity: (     var initialString : String ; initialString := nextToken() ;
     var letters : Sequence(String) ; letters := initialString->characters() ;
    var result : long ; result := 1 ;
    var length : int ; length := letters->size() ;
    var count : Sequence(long) ; count := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < length do ( (     var k : int ; k := letters[i+1] - ('a')->char2byte() ;
         var j : int ; j := 0 ; while j < count->size() do ( (     if (j /= k) then (     result := result+(count[j+1]) ) else skip )  ;     j := j + 1 ) ; 
     count[k+1] := count[k+1]+(1) )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation reverse( copy : Sequence(String), i : int, j : int) : void
  pre: true
  post: true
  activity: (     while (i < j) do (     var t : String ; t := copy[i+1] ;
     copy[i+1] := copy[j+1] ; 
    copy[j+1] := t ; 
    i := i + 1 ; 
    j := j - 1 ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    rnd := OclRandom.newOclRandom() ; 
    execute solve() ; 
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     var line : String ; line := in.readLine() ;
     if (line = null) then     return null else skip ; 
     st := OclIterator.newOclIterator_String(line) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    FastScanner in=new FastScanner();
    String s=in.nextLine();
    long[] num=new long[26];
    for(int i=0 ; i<s.length(); i++){
      num[s.charAt(i)-97]++;
    }
    long l=s.length();
    long result=l*(l-1)/2+1 ;
    for(int i=0 ; i<26 ; i++){
      result-=num[i]*(num[i]-1)/2 ;
    }
    System.out.println(result);
  }
  public static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(String s){
      try {
        br=new BufferedReader(new FileReader(s));
      }
      catch(FileNotFoundException e){
        e.printStackTrace();
      }
    }
    public FastScanner(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String nextToken(){
      while(st==null || ! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    String nextLine(){
      st=null ;
      try {
        return br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return null ;
    }
    int nextInt(){
      return Integer.parseInt(nextToken());
    }
    long nextLong(){
      return Long.parseLong(nextToken());
    }
    double nextDouble(){
      return Double.parseDouble(nextToken());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var s : String ; s := in.nextLine() ;
    var num : Sequence(long) ; num := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     num[s->at(i+1) - 97+1] := num[s->at(i+1) - 97+1] + 1 )  ;     i := i + 1 ) ; 
    var l : long ; l := s->size() ;
    var result : long ; result := l * (l - 1) / 2 + 1 ;
        var i : int ; i := 0 ; while i < 26 do ( (     result := result-(num[i+1] * (num[i+1] - 1) / 2) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(s))) )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
 );
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     st := null ; 
     try (     return br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static int countDivisors(int N,int a,int b){
    int count1=N/a ;
    int count2=N/b ;
    int count3=(N/(a*b));
    return count1+count2-count3 ;
  }
  public static void main(String[] args){
    int N=1000,a=3,b=4 ;
    System.out.println(countDivisors(N,a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDivisors( N : int, a : int, b : int) : int
  pre: true
  post: true
  activity: (     var count1 : int ; count1 := N / a ;
     var count2 : int ; count2 := N / b ;
     var count3 : int ; count3 := (N / (a * b)) ;
     return count1 + count2 - count3 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 1000 ;
    var a : int ; a := 3 ;
    var b : int ; b := 4 ;
     OclFile["System.out"].println(countDivisors(N, a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
public class StadiumAndGames {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    long n=Long.parseLong(br.readLine());
    List<Long>res=new ArrayList<Long>();
    for(int k=0 ; k<=64-Long.numberOfLeadingZeros(n-1)+1 ; k++){
      long a=0 ;
      long b=2000000002 ;
      for(long m=(a+b)/2 ; a+1<b ; m=(a+b)/2){
        if((2L<<k)-3L+m<=2L*n/m){
          a=m ;
        }
        else {
          b=m ;
        }
      }
      if(a % 2L==0L)continue ;
      if(a*((1L<<k)-1L)+a*(a-1L)/2L==n){
        res.add(a*(1L<<k));
      }
    }
    if(res.size()==0){
      System.out.println(-1);
      return ;
    }
    Collections.sort(res);
    for(Long r : res){
      System.out.println(r);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class StadiumAndGames {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : long ; n := (br.readLine())->toLong() ;
    var res : Sequence(long) ; res := Sequence{} ;
        var k : int ; k := 0 ; while k <= 64 - numberOfLeadingZeros(n - 1) + 1 do ( (     var a : long ; a := 0 ;
     var b : long ; b := 2000000002 ;
        var m : long ; m := (a + b) / 2 ; while a + 1 < b do ( (     if (((2L*(2->pow(k)))->oclAsType(long)) - 3L + m <= 2L * n / m) then (     a := m ) else (     b := m ) )  ;     m := (a + b) / 2 ) ; 
    if (a mod 2L = 0L) then     continue else skip ; 
    if (a * (((1L*(2->pow(k)))->oclAsType(long)) - 1L) + a * (a - 1L) / 2L = n) then (     res := res->including(a * ((1L*(2->pow(k)))->oclAsType(long))) ) else skip ; 
 )  ;     k := k + 1 ) ; 
    if (res->size() = 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    res := res->sort() ; 
    for (r : res) do ( (     OclFile["System.out"].println(r) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static int summation(int n){
    return(n*(n+1)*(2*n+1))/6 ;
  }
  public static void main(String args[]){
    int n=10 ;
    System.out.println(summation(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation summation( n : int) : int
  pre: true
  post: true
  activity: (     return (n * (n + 1) * (2 * n + 1)) / 6 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(summation(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String[] lst={
      "zero","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen","twenty","thirty","forty","fifty","sixty","seventy","eighty","ninety" };
      if(n<=20){
        System.out.println(lst[n]);
      }
      else {
        System.out.print(lst[20+n/10-2]);
        if((n/10)*10!=n){
          System.out.println("-"+lst[n % 10]);
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var lst : Sequence(String) ; lst := Sequence{"zero","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen","twenty","thirty","forty","fifty","sixty","seventy","eighty","ninety"} ;
     if (n <= 20) then (     OclFile["System.out"].println(lst[n+1]) ) else (     OclFile["System.out"].print(lst[20 + n / 10 - 2+1]) ; 
     if ((n / 10) * 10 /= n) then (     OclFile["System.out"].println("-" + lst[n mod 10+1]) ) else skip ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[][] ko=new long[19][19];
    long t=0 ;
    for(int i=0 ; i<n ; i++){
      double A=sc.nextDouble();
      A=(double)Math.pow(10,9)*A ;
      long c=(long)(A+0.01);
      int x=0 ;
      int y=0 ;
      while((c % 2)==0){
        x++;
        c/=(long)2 ;
      }
      while((c % 5)==0){
        y++;
        c/=(long)5 ;
      }
      if(x>18)x=18 ;
      if(y>18)y=18 ;
      ko[x][y]++;
      if((x>=9)&&(y>=9))t++;
    }
    long ans=0 ;
    for(int i=0 ; i<19 ; i++){
      for(int j=0 ; j<19 ; j++){
        for(int a=0 ; a<19 ; a++){
          for(int b=0 ; b<19 ; b++){
            if(((i+a)>=18)&&((j+b)>=18)){
              ans+=(ko[i][j]*ko[a][b]);
            }
          }
        }
      }
    }
    ans-=t ;
    ans/=(long)2 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ko : Sequence(Sequence(long)) ; ko := Integer.subrange(1,19)->collect(Integer.subrange(1,19)->collect(0)) ;
    var t : long ; t := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var A : double ; A := sc.getCurrent()->toReal() ;
     A := 10->pow(9)->oclAsType(double) * A ; 
    var c : long ; c := (A + 0.01)->oclAsType(long) ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    while ((c mod 2) = 0) do (     x := x + 1 ; 
     c := c/(2->oclAsType(long)) ) ; 
    while ((c mod 5) = 0) do (     y := y + 1 ; 
     c := c/(5->oclAsType(long)) ) ; 
    if (x > 18) then     x := 18 ; else skip ; 
    if (y > 18) then     y := 18 ; else skip ; 
    ko[x+1][y+1] := ko[x+1][y+1] + 1 ; 
    if ((x >= 9) & (y >= 9)) then     t := t + 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < 19 do ( (         var j : int ; j := 0 ; while j < 19 do ( (         var a : int ; a := 0 ; while a < 19 do ( (         var b : int ; b := 0 ; while b < 19 do ( (     if (((i + a) >= 18) & ((j + b) >= 18)) then (     ans := ans+((ko[i+1][j+1] * ko[a+1][b+1])) ) else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    ans := ans-(t) ; 
    ans := ans/(2->oclAsType(long)) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class TafasAndNafas {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    Map<Integer,String>map=new HashMap<>();
    map.put(10,"ten");
    map.put(1,"one");
    map.put(2,"two");
    map.put(3,"three");
    map.put(4,"four");
    map.put(5,"five");
    map.put(6,"six");
    map.put(7,"seven");
    map.put(8,"eight");
    map.put(9,"nine");
    map.put(0,"zero");
    map.put(11,"eleven");
    map.put(12,"twelve");
    map.put(13,"thirteen");
    map.put(14,"fourteen");
    map.put(15,"fifteen");
    map.put(16,"sixteen");
    map.put(17,"seventeen");
    map.put(18,"eighteen");
    map.put(19,"nineteen");
    map.put(20,"twenty");
    map.put(30,"thirty");
    map.put(40,"forty");
    map.put(50,"fifty");
    map.put(60,"sixty");
    map.put(70,"seventy");
    map.put(80,"eighty");
    map.put(90,"ninety");
    if(scanner.hasNext()){
      int n=scanner.nextInt();
      if(n<=20){
        System.out.println(map.get(n));
      }
      else {
        if(map.containsKey(n))System.out.println(map.get(n));
        else {
          int x=n % 10 ;
          System.out.println(map.get(n/10*10)+"-"+map.get(x));
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TafasAndNafas {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var map : Map(int,String) ; map := Map{} ;
    map := map->union(Map{10 |-> "ten"}) ; 
    map := map->union(Map{1 |-> "one"}) ; 
    map := map->union(Map{2 |-> "two"}) ; 
    map := map->union(Map{3 |-> "three"}) ; 
    map := map->union(Map{4 |-> "four"}) ; 
    map := map->union(Map{5 |-> "five"}) ; 
    map := map->union(Map{6 |-> "six"}) ; 
    map := map->union(Map{7 |-> "seven"}) ; 
    map := map->union(Map{8 |-> "eight"}) ; 
    map := map->union(Map{9 |-> "nine"}) ; 
    map := map->union(Map{0 |-> "zero"}) ; 
    map := map->union(Map{11 |-> "eleven"}) ; 
    map := map->union(Map{12 |-> "twelve"}) ; 
    map := map->union(Map{13 |-> "thirteen"}) ; 
    map := map->union(Map{14 |-> "fourteen"}) ; 
    map := map->union(Map{15 |-> "fifteen"}) ; 
    map := map->union(Map{16 |-> "sixteen"}) ; 
    map := map->union(Map{17 |-> "seventeen"}) ; 
    map := map->union(Map{18 |-> "eighteen"}) ; 
    map := map->union(Map{19 |-> "nineteen"}) ; 
    map := map->union(Map{20 |-> "twenty"}) ; 
    map := map->union(Map{30 |-> "thirty"}) ; 
    map := map->union(Map{40 |-> "forty"}) ; 
    map := map->union(Map{50 |-> "fifty"}) ; 
    map := map->union(Map{60 |-> "sixty"}) ; 
    map := map->union(Map{70 |-> "seventy"}) ; 
    map := map->union(Map{80 |-> "eighty"}) ; 
    map := map->union(Map{90 |-> "ninety"}) ; 
    if (scanner.hasNext()) then (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n <= 20) then (     OclFile["System.out"].println(map->at(n)) ) else (     if (map->keys()->includes(n)) then     OclFile["System.out"].println(map->at(n)) ; else (     var x : int ; x := n mod 10 ;
     OclFile["System.out"].println(map->at(n / 10 * 10) + "-" + map->at(x)) ) ) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A535 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int s=sc.nextInt();
    String[] nums={
      "zero","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen" };
      String[] tens={
        "ten","twenty","thirty","forty","fifty","sixty","seventy","eighty","ninety" };
        if(s>=0 && s<20)System.out.println(nums[s]);
        else if(s % 10==0)System.out.println(tens[s/10-1]);
        else {
          int onesPlace=s % 10 ;
          int tensPlace=(s/10)% 10 ;
          System.out.println(tens[tensPlace-1]+"-"+nums[onesPlace]);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class A535 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : int ; s := sc.getCurrent()->toInteger() ;
    var nums : Sequence(String) ; nums := Sequence{"zero","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen"} ;
    var tens : Sequence(String) ; tens := Sequence{"ten","twenty","thirty","forty","fifty","sixty","seventy","eighty","ninety"} ;
    if (s >= 0 & s < 20) then     OclFile["System.out"].println(nums[s+1]) else     if (s mod 10 = 0) then     OclFile["System.out"].println(tens[s / 10 - 1+1]) else (     var onesPlace : int ; onesPlace := s mod 10 ;
     var tensPlace : int ; tensPlace := (s / 10) mod 10 ;
     OclFile["System.out"].println(tens[tensPlace - 1+1] + "-" + nums[onesPlace+1]) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication103 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int s=sc.nextInt();
    String[] arr=new String[] {
      "zero","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen" };
      String[] arra=new String[] {
        "twenty","thirty","forty","fifty","sixty","seventy","eighty","ninety" };
        if(s<20){
          System.out.println(arr[s]);
        }
        else {
          int a=(int)(s/10)-2 ;
          int b=s % 10 ;
          if(b==0){
            System.out.println(arra[a]);
          }
          else {
            System.out.println(arra[a]+"-"+arr[b]);
          }
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class JavaApplication103 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : int ; s := sc.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := Sequence{"zero","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen"} ;
    var arra : Sequence(String) ; arra := Sequence{"twenty","thirty","forty","fifty","sixty","seventy","eighty","ninety"} ;
    if (s < 20) then (     OclFile["System.out"].println(arr[s+1]) ) else (     var a : int ; a := (s / 10)->oclAsType(int) - 2 ;
     var b : int ; b := s mod 10 ;
     if (b = 0) then (     OclFile["System.out"].println(arra[a+1]) ) else (     OclFile["System.out"].println(arra[a+1] + "-" + arr[b+1]) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.nio.charset.StandardCharsets ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader reader=new InputStreamReader(System.in,StandardCharsets.UTF_8);
    BufferedReader in=new BufferedReader(reader);
    Main ins=new Main(in);
    ins.calc();
    ins.showResult();
  }
  static class Node {
    int id ;
    int group ;
    Set<Integer>conns ;
    Node(int id){
      this.id=id ;
      this.group=-1 ;
      this.conns=new HashSet<>();
    }
  }
  int N,M ;
  Node[] nodes ;
  Main(BufferedReader in)throws IOException {
    String[] tokens=in.readLine().split(" ");
    N=Integer.parseInt(tokens[0]);
    M=Integer.parseInt(tokens[1]);
    nodes=new Node[N];
    for(int i=0 ; i<N ; ++i){
      nodes[i]=new Node(i);
    }
    for(int i=0 ; i<M ; ++i){
      tokens=in.readLine().split(" ");
      int A=Integer.parseInt(tokens[0])-1 ;
      int B=Integer.parseInt(tokens[1])-1 ;
      nodes[A] .conns.add(B);
      nodes[B] .conns.add(A);
    }
  }
  void mark(int current,int group,int parent){
    if(nodes[current] .group>=0){
      return ;
    }
    nodes[current] .group=group ;
    for(Integer next : nodes[current] .conns){
      if(! next.equals(parent)){
        mark(next,group,current);
      }
    }
  }
  void calc(){
    int group=0 ;
    for(int i=0 ; i<N ; ++i){
      if(nodes[i] .group<0){
        mark(i,group,-1);
++group ;
      }
    }
    System.out.println((group-1));
  }
  void showResult(){
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"], StandardCharsets.UTF_8) ;
     var in : OclFile ; in := OclFile.newOclFile_Read(reader) ;
    var ins : Main ; ins := Main.newMain(in) ;
    ins.calc() ; 
    ins.showResult() ; 
 );
  static class Node {
   attribute id : int;
   attribute group : int;
   attribute conns : Set(int);
   static operation newNode( id : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(id);
    return self );
  operation initialise( id : int) : void
  pre: true  post: true
  activity: (     self.id := id ; 
     self.group := -1 ; 
     self.conns := Set{} );
}
   attribute N : int;
   attribute nodes : Sequence(Node);
   static operation newMain( in : OclFile) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     var tokens : Sequence(String) ; tokens := in.readLine()->split(" ") ;
     N := (tokens[0+1])->toInteger() ; 
    M := (tokens[1+1])->toInteger() ; 
    nodes := Integer.subrange(1,N)->collect(null) ; 
        var i : int ; i := 0 ; while i < N do ( (     nodes[i+1] := Node.newNode(i) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     tokens := in.readLine()->split(" ") ; 
     var A : int ; A := (tokens[0+1])->toInteger() - 1 ;
    var B : int ; B := (tokens[1+1])->toInteger() - 1 ;
    nodes[A+1].conns->excludes(B) ; 
    nodes[B+1].conns->excludes(A) ; 
 )  ;     i := i + 1 ) ; 
 );
   operation mark( current : int, group : int, parent : int) : void
  pre: true
  post: true
  activity: (     if (nodes[current+1].group >= 0) then (     return ) else skip ; 
     nodes[current+1].group := group ; 
     for (next : nodes[current+1].conns) do ( (     if (not(next = parent)) then (     execute mark(next, group, current) ) else skip )  ) );
   operation calc() : void
  pre: true
  post: true
  activity: (     var group : int ; group := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     if (nodes[i+1].group < 0) then (     execute mark(i, group, -1) ; 
     group := group + 1 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println((group - 1)) );
   operation showResult() : void
  pre: true
  post: true
  activity: skip;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAX=100 ;
  static boolean search(int mat[][],int m,int n,int x){
    int i=m-1,j=0 ;
    while(i>=0 && j<n){
      if(mat[i][j]==x)return true ;
      if(mat[i][j]>x)i--;
      else j++;
    }
    return false ;
  }
  public static void main(String args[]){
    int mat[][]={
      {
        10,20,30,40 },{
          15,25,35,45 },{
            27,29,37,48 },{
              32,33,39,50 },{
                50,60,70,80 }
              };
              if(search(mat,5,4,29))System.out.println("Yes");
              else System.out.println("No");
            }
          }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 100;
  static   operation search( mat : Sequence(Sequence(int)), m : int, n : int, x : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ; i := m - 1 ;
    var j : int ; j := 0 ;
     while (i >= 0 & j < n) do (     if (mat[i+1][j+1] = x) then     return true else skip ; 
     if (mat[i+1][j+1] > x) then     i := i - 1 ; else     j := j + 1 ; ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{10,20,30,40},Sequence{15,25,35,45},Sequence{27,29,37,48},Sequence{32,33,39,50},Sequence{50,60,70,80}} ;
     if (search(mat, 5, 4, 29)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p057 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p057().run());
  }
  private static final int LIMIT=1000 ;
  public String run(){
    BigInteger n=BigInteger.ZERO ;
    BigInteger d=BigInteger.ONE ;
    int count=0 ;
    for(int i=0 ; i<LIMIT ; i++){
      BigInteger temp=d.multiply(BigInteger.valueOf(2)).add(n);
      n=d ;
      d=temp ;
      if(n.add(d).toString().length()>d.toString().length())count++;
    }
    return Integer.toString(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p057 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p057.newp057().run()) );
  static    attribute LIMIT : int := 1000;
   operation run() : String
  pre: true
  post: true
  activity: (     var n : long ; n := 0 ;
     var d : long ; d := 1 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < LIMIT do ( (     var temp : long ; temp := d.multiply((2 + "")->toLong())->excludes(n) ;
     n := d ; 
     d := temp ; 
     if (n->excludes(d)+""->size() > d+""->size()) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    return ((count) + "") 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static float discountPercentage(float S,float M){
    float discount=M-S ;
    float disPercent=(discount/M)*100 ;
    return disPercent ;
  }
  public static void main(String args[]){
    int M,S ;
    M=120 ;
    S=100 ;
    System.out.printf("%.2f",discountPercentage(S,M));
    System.out.println("%");
    M=1000 ;
    S=500 ;
    System.out.printf("%.2f",discountPercentage(S,M));
    System.out.println("%");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation discountPercentage( S : double, M : double) : double
  pre: true
  post: true
  activity: (     var discount : double ; discount := M - S ;
     var disPercent : double ; disPercent := (discount / M) * 100 ;
     return disPercent );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var M : int ;
    var S : int ;
     M := 120 ; 
    S := 100 ; 
    OclFile["System.out"].printf("%.2f", discountPercentage(S, M)) ; 
    OclFile["System.out"].println("%") ; 
    M := 1000 ; 
    S := 500 ; 
    OclFile["System.out"].printf("%.2f", discountPercentage(S, M)) ; 
    OclFile["System.out"].println("%") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1551A_PolycarpandCoins {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int number=parseInt(input.nextLine());
      int first,second ;
      switch(number % 3){
        case 0 : first=number/3 ;
        second=number/3 ;
        break ;
        case 1 : first=number/3+1 ;
        second=number/3 ;
        break ;
        default : first=number/3 ;
        second=number/3+1 ;
        break ;
      }
      System.out.println(first+" "+second);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1551A_PolycarpandCoins {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var number : int ; number := parseInt(input.nextLine()) ;
     var first : int ;
    var second : int ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (number mod 3) ; 
       if _switchval = 0 then
     first := number / 3 ; 
    second := number / 3 ; 
    break 
   else skip ;
       if _switchval = 1 then
     first := number / 3 + 1 ; 
    second := number / 3 ; 
    break 
   else skip ;
       if true then
     first := number / 3 ; 
    second := number / 3 + 1 ; 
    break 
   else skip ;
 )
     OclFile["System.out"].println(first + " " + second) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Exersise {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] array=new int[n];
    for(int i=0 ; i<array.length ; i++){
      array[i]=input.nextInt();
    }
    for(int i=0 ; i<array.length ; i++){
      double y=array[i]/3.0 ;
      int is=array[i]/3 ;
      if(y>is+.5){
++is ;
        int x=array[i]-2*is ;
        System.out.println(x+" "+is);
      }
      else {
        int x=array[i]-2*is ;
        System.out.println(x+" "+is);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Exersise {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < array->size() do ( (     array[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < array->size() do ( (     var y : double ; y := array[i+1] / 3.0 ;
     var is : int ; is := array[i+1] / 3 ;
     if (y > is + .5) then (     is := is + 1 ; 
     var x : int ; x := array[i+1] - 2 * is ;
     OclFile["System.out"].println(x + " " + is) ) else (     var x : int ; x := array[i+1] - 2 * is ;
     OclFile["System.out"].println(x + " " + is) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Polycarp {
  int number ;
  public Polycarp(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  public void input(long number){
    long coinOne=number/3 ;
    long coinTwo=number/3 ;
    if(number-(coinOne+coinTwo*2)==1){
      System.out.println(++coinOne+" "+coinTwo);
    }
    else if(number-(coinOne+coinTwo*2)==2){
      System.out.println(coinOne+" "+(++coinTwo));
    }
    else {
      System.out.println(coinOne+" "+coinTwo);
    }
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int number=s.nextInt();
    Polycarp instance=new Polycarp(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      long num=s.nextLong();
      instance.input(num);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Polycarp {
   attribute number : int;
   static operation newPolycarp( number : int) : Polycarp
  pre: true
  post: true
  activity:
  ( var self : Polycarp ;
    self := createPolycarp();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
   operation input( number : long) : void
  pre: true
  post: true
  activity: (     var coinOne : long ; coinOne := number / 3 ;
     var coinTwo : long ; coinTwo := number / 3 ;
     if (number - (coinOne + coinTwo * 2) = 1) then (     OclFile["System.out"].println((coinOne + 1) + " " + coinTwo) ) else     if (number - (coinOne + coinTwo * 2) = 2) then (     OclFile["System.out"].println(coinOne + " " + ((coinTwo + 1))) ) else (     OclFile["System.out"].println(coinOne + " " + coinTwo) ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := s.getCurrent()->toInteger() ;
     var instance : Polycarp ; instance := Polycarp.newPolycarp(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var num : long ; num := s.getCurrent()->toLong() ;
     instance.input(num) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class PolycarpAndCoins1551A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt(),c1,c2 ;
    for(int i=0 ; i<t ; i++){
      int n=in.nextInt();
      if(n % 3==0){
        c1=n/3 ;
        c2=n/3 ;
        System.out.println(c1+" "+c2);
      }
      else {
        c1=n/3 ;
        if((n-c1)% 2==0){
          c2=(n-c1)/2 ;
        }
        else {
          c2=n/3 ;
          c1=n-(2*c2);
        }
        System.out.println(c1+" "+c2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PolycarpAndCoins1551A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var c1 : int ;
    var c2 : int ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n mod 3 = 0) then (     c1 := n / 3 ; 
     c2 := n / 3 ; 
     OclFile["System.out"].println(c1 + " " + c2) ) else (     c1 := n / 3 ; 
     if ((n - c1) mod 2 = 0) then (     c2 := (n - c1) / 2 ) else (     c2 := n / 3 ; 
     c1 := n - (2 * c2) ) ;  
     OclFile["System.out"].println(c1 + " " + c2) ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Objects ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=Integer.parseInt(scanner.nextLine());
    HashMap<Pair,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      long d=Math.round(Double.parseDouble(scanner.nextLine())*1e9);
      int two=0,five=0 ;
      while(d % 2==0){
        two++;
        d/=2 ;
      }
      while(d % 5==0){
        five++;
        d/=5 ;
      }
      Pair pair=new Pair(two,five);
      map.compute(pair,(key,val)->val==null ? 1 : val+1);
    }
    long ans=0 ;
    for(Map.Entry<Pair,Integer>p1 : map.entrySet()){
      for(Map.Entry<Pair,Integer>p2 : map.entrySet()){
        if(p1.getKey().two+p2.getKey().two>=18 && p1.getKey().five+p2.getKey().five>=18){
          if(p1==p2)ans+=(long)p1.getValue()*(p1.getValue()-1);
          else ans+=(long)p1.getValue()*p2.getValue();
        }
      }
    }
    System.out.println(ans/2);
  }
  private static class Pair {
    private final int two,five ;
    private Pair(int two,int five){
      this.two=two ;
      this.five=five ;
    }
    @ Override public boolean equals(Object o){
      if(this==o)return true ;
      if(o==null || getClass()!=o.getClass())return false ;
      Pair pair=(Pair)o ;
      return two==pair.two && five==pair.five ;
    }
    @ Override public int hashCode(){
      return Objects.hash(two,five);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (scanner.nextLine())->toInteger() ;
    var map : Map(Map,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var d : long ; d := ((scanner.nextLine())->toReal() * 1e9)->round() ;
     var two : int ; two := 0 ;
    var five : int ; five := 0 ;
    while (d mod 2 = 0) do (     two := two + 1 ; 
     d := d/(2) ) ; 
    while (d mod 5 = 0) do (     five := five + 1 ; 
     d := d/(5) ) ; 
    var pair : Map ; pair := Map(two, five) ;
    map := map.compute(pair, lambda (key , val) : OclAny in if val = null then 1 else val + 1 endif) ; 
 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    for (p1 : map->asSet()) do ( (     for (p2 : map->asSet()) do ( (     if (p1.getKey().two + p2.getKey().two >= 18 & p1.getKey().five + p2.getKey().five >= 18) then (     if (p1 = p2) then     ans := ans+(p1.getValue()->oclAsType(long) * (p1.getValue() - 1)) ; else     ans := ans+(p1.getValue()->oclAsType(long) * p2.getValue()) ; ) else skip )  ) )  ) ; 
    OclFile["System.out"].println(ans / 2) ; 
 );
  static class Pair {
   attribute two : int;
   static operation newPair( two : int, five : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(two, five);
    return self );
  operation initialise( two : int, five : int) : void
  pre: true  post: true
  activity: (     self.two := two ; 
     self.five := five );
      operation equals( o : OclAny) : boolean
  pre: true
  post: true
  activity: (     if (self = o) then     return true else skip ; 
     if (o = null or getClass() /= o->oclType()) then     return false else skip ; 
     var pair : Map ; pair := o->oclAsType(Map) ;
     return two = pair.two & five = pair.five );
      operation hashCode() : int
  pre: true
  post: true
  activity: (     return Objects.hash(two, five) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test130 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      int x=in.nextInt();
      if(x % 3==0){
        System.out.println(x/3+" "+x/3);
      }
      else if(x % 3==1){
        System.out.println((x/3+1)+" "+x/3);
      }
      else {
        System.out.println(x/3+" "+(x/3+1));
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test130 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     if (x mod 3 = 0) then (     OclFile["System.out"].println(x / 3 + " " + x / 3) ) else     if (x mod 3 = 1) then (     OclFile["System.out"].println((x / 3 + 1) + " " + x / 3) ) else (     OclFile["System.out"].println(x / 3 + " " + (x / 3 + 1)) ) ;  )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
import java.util.Stack ;
class Main {
  public static void main(String[] args){
    Solve s=new Solve();
    s.solve();
  }
}
class Solve {
  Solve(){
  }
  Scanner in=new Scanner(System.in);
  void solve(){
    while(in.hasNext()){
      int n=in.nextInt();
      if(n==0)return ;
      int ap=0,ad=0 ;
      for(int i=0 ; i<n ; i++){
        int p=in.nextInt(),d=in.nextInt()+in.nextInt();
        if(d>ad){
          ap=p ;
          ad=d ;
        }
      }
      System.out.print(ap);
      System.out.print(" ");
      System.out.println(ad);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Solve ; s := Solve.newSolve() ;
     s.solve() );
}
class Solve {
   static operation newSolve() : Solve
  pre: true
  post: true
  activity:
  ( var self : Solve ;
    self := createSolve();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation solve() : void
  pre: true
  post: true
  activity: (     while (in.hasNext()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var ap : int ; ap := 0 ;
    var ad : int ; ad := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var p : int ; p := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() + in.getCurrent()->toInteger() ;
     if (d > ad) then (     ap := p ; 
     ad := d ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(ap) ; 
    OclFile["System.out"].print(" ") ; 
    OclFile["System.out"].println(ad) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean LiesInsieRectangle(int a,int b,int x,int y){
    if(x-y-b<=0 && x-y+b>=0 && x+y-2*a+b<=0 && x+y-b>=0)return true ;
    return false ;
  }
  public static void main(String[] args){
    int a=7,b=2,x=4,y=5 ;
    if(LiesInsieRectangle(a,b,x,y))System.out.println("Given point lies "+"inside the rectangle");
    else System.out.println("Given point does not "+"lie on the rectangle");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation LiesInsieRectangle( a : int, b : int, x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     if (x - y - b <= 0 & x - y + b >= 0 & x + y - 2 * a + b <= 0 & x + y - b >= 0) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 7 ;
    var b : int ; b := 2 ;
    var x : int ; x := 4 ;
    var y : int ; y := 5 ;
     if (LiesInsieRectangle(a, b, x, y)) then     OclFile["System.out"].println("Given point lies " + "inside the rectangle") ; else     OclFile["System.out"].println("Given point does not " + "lie on the rectangle") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,i,p,d,maxd,maxp ;
    for(; ; out.println(maxp+" "+maxd)){
      n=sc.nextInt();
      if(n==0)break ;
      maxd=-1 ;
      maxp=-1 ;
      for(; n-->0 ; ){
        p=sc.nextInt();
        d=sc.nextInt()+sc.nextInt();
        if(d>maxd){
          maxd=d ;
          maxp=p ;
        }
      }
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var i : int ;
    var p : int ;
    var d : int ;
    var maxd : int ;
    var maxp : int ;
       while true do ( (     n := sc.nextInt() ; 
     if (n = 0) then     break else skip ; 
    maxd := -1 ; 
    maxp := -1 ; 
      while n > 0 do ( (     p := sc.nextInt() ; 
     d := sc.nextInt() + sc.nextInt() ; 
     if (d > maxd) then (     maxd := d ; 
     maxp := p ) else skip )  ) ; 
 )  ;     out.println(maxp + " " + maxd) ) ; 
     sc.close() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigDecimal ;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    int n=1 ;
    int[] ir=null ;
    ir=readIntArray();
    if(ir==null || ir.length==0)return false ;
    n=ir[0];
    if(n==0)return false ;
    int maxNo=0 ;
    int max=0 ;
    for(int i=0 ; i<n ; i++){
      ir=readIntArray();
      int no=0 ;
      int kyori=0 ;
      no=ir[0];
      kyori=ir[1]+ir[2];
      if(kyori>max){
        maxNo=no ;
        max=kyori ;
      }
    }
    System.out.printf("%d %d\n",maxNo,max);
    return true ;
  }
  private final static boolean DEBUG=false ;
  public static void main(String[] args)throws IOException {
    if(DEBUG){
      log=System.out ;
      String inputStr="29:0:" ;
      inputStr=inputStr.replace(":","\n");
      reader=new BufferedReader(new StringReader(inputStr));
    }
    else {
      log=new PrintStream(new OutputStream(){
        public void write(int b){
        }
      }
);
      reader=new BufferedReader(new InputStreamReader(System.in));
    }
    for(int i=0 ; ; i++){
      boolean b=new Main().main();
      if(! b)break ;
    }
    reader.close();
  }
  static PrintStream log ;
  static BufferedReader reader ;
  private static int[] readIntArray()throws IOException {
    String s=reader.readLine();
    if(s.length()==0)s=reader.readLine();
    if(s==null)return null ;
    s=s.trim();
    String[] sp=s.split(" ");
    int[] a=new int[sp.length];
    for(int i=0 ; i<sp.length ; i++){
      a[i]=Integer.parseInt(sp[i]);
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := 1 ;
     var ir : Sequence(int) ; ir := null ;
    ir := readIntArray() ; 
    if (ir = null or ir->size() = 0) then     return false else skip ; 
    n := ir[0+1] ; 
    if (n = 0) then     return false else skip ; 
    var maxNo : int ; maxNo := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ir := readIntArray() ; 
     var no : int ; no := 0 ;
    var kyori : int ; kyori := 0 ;
    no := ir[0+1] ; 
    kyori := ir[1+1] + ir[2+1] ; 
    if (kyori > max) then (     maxNo := no ; 
     max := kyori ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%d %d\n", maxNo, max) ; 
    return true 
 );
  static   attribute DEBUG : boolean := false;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (DEBUG) then (     log := OclFile["System.out"] ; 
     var inputStr : String ; inputStr := "29:0:" ;
     inputStr := inputStr.replace(":", "\n") ; 
     reader := OclFile.newOclFile_Read(StringReader.newStringReader(inputStr)) ) else (     log := OclFile.newOclFile_Write(OclFile()) ; 
     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ) ;  
         var i : int ; i := 0 ; while true do ( (     var b : boolean ; b := Main.newMain().main() ;
     if (not(b)) then     break else skip )  ;     i := i + 1 ) ; 
     reader.close() );
  static   attribute log : OclFile;
  static   attribute reader : OclFile;
  static   operation readIntArray() : Sequence(int)
  pre: true
  post: true
  activity: (     var s : String ; s := reader.readLine() ;
     if (s->size() = 0) then     s := reader.readLine() ; else skip ; 
    if (s = null) then     return null else skip ; 
    s := s->trim() ; 
    var sp : Sequence(String) ; sp := s->split(" ") ;
    var a : Sequence(int) ; a := Integer.subrange(1,sp->size())->collect(0) ;
        var i : int ; i := 0 ; while i < sp->size() do ( (     a[i+1] := (sp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    return a 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.Map ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.peopleWalkedTheLongestDistanceSearch();
    return ;
  }
  private void peopleWalkedTheLongestDistanceSearch(){
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      try {
        String inputStr=bufferedReader.readLine();
        int patientsNum=Integer.parseInt(inputStr);
        if(patientsNum==0){
          break ;
        }
        HashMap<Integer,Integer>patientsMap=new HashMap<Integer,Integer>();
        for(int i=0 ; i<patientsNum ; i++){
          String inputStr2=bufferedReader.readLine();
          String[] patientsInformation=inputStr2.split(" ");
          int patientNum=Integer.parseInt(patientsInformation[0]);
          int d1=Integer.parseInt(patientsInformation[1]);
          int d2=Integer.parseInt(patientsInformation[2]);
          patientsMap.put(patientNum,d1+d2);
        }
        int patientsLongestNum=0 ;
        int theLongestTotalDistanceNum=0 ;
        for(Map.Entry<Integer,Integer>e : patientsMap.entrySet()){
          int tmp=e.getValue();
          if(tmp>theLongestTotalDistanceNum){
            patientsLongestNum=e.getKey();
            theLongestTotalDistanceNum=e.getValue();
          }
        }
        System.out.printf("%d %d\n",patientsLongestNum,theLongestTotalDistanceNum);
      }
      catch(IOException e){
        e.printStackTrace();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.peopleWalkedTheLongestDistanceSearch() ; 
     return );
   operation peopleWalkedTheLongestDistanceSearch() : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     try (     var inputStr : String ; inputStr := bufferedReader.readLine() ;
     var patientsNum : int ; patientsNum := (inputStr)->toInteger() ;
    if (patientsNum = 0) then (     break ) else skip ; 
    var patientsMap : Map(int,int) ; patientsMap := Map{} ;
        var i : int ; i := 0 ; while i < patientsNum do ( (     var inputStr2 : String ; inputStr2 := bufferedReader.readLine() ;
     var patientsInformation : Sequence(String) ; patientsInformation := inputStr2->split(" ") ;
    var patientNum : int ; patientNum := (patientsInformation[0+1])->toInteger() ;
    var d1 : int ; d1 := (patientsInformation[1+1])->toInteger() ;
    var d2 : int ; d2 := (patientsInformation[2+1])->toInteger() ;
    patientsMap := patientsMap->union(Map{patientNum |-> d1 + d2}) ; 
 )  ;     i := i + 1 ) ; 
    var patientsLongestNum : int ; patientsLongestNum := 0 ;
    var theLongestTotalDistanceNum : int ; theLongestTotalDistanceNum := 0 ;
    for (e : patientsMap->asSet()) do ( (     var tmp : int ; tmp := e.getValue() ;
     if (tmp > theLongestTotalDistanceNum) then (     patientsLongestNum := e.getKey() ; 
     theLongestTotalDistanceNum := e.getValue() ) else skip )  ) ; 
    OclFile["System.out"].printf("%d %d\n", patientsLongestNum, theLongestTotalDistanceNum) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int max=0 ;
      Map<Integer,Integer>map=new HashMap<Integer,Integer>();
      for(int i=0 ; i<n ; i++){
        int num=sc.nextInt();
        int d=sc.nextInt()+sc.nextInt();
        map.put(d,num);
        max=Math.max(max,d);
      }
      System.out.println(map.get(max)+" "+max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var max : int ; max := 0 ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := sc.getCurrent()->toInteger() ;
     var d : int ; d := sc.getCurrent()->toInteger() + sc.getCurrent()->toInteger() ;
     map := map->union(Map{d |-> num}) ; 
     max := Set{max, d}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(map->at(max) + " " + max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countChars(String str,int n){
    int i=0,cnt=0 ;
    while(i<n){
      if(str.charAt(i)=='0')i+=1 ;
      else i+=2 ;
      cnt+=1 ;
    }
    return cnt ;
  }
  public static void main(String[] args){
    String str="11010" ;
    int n=str.length();
    System.out.println(countChars(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countChars( str : String, n : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var cnt : int ; cnt := 0 ;
     while (i < n) do (     if (str->at(i+1) = '0') then     i := i+(1) else     i := i+(2) ; ;  
     cnt := cnt+(1) ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "11010" ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].println(countChars(str, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double sumTillX(double x,double n){
    double odd=Math.ceil(n/2.0);
    if(x<=odd)return x*x ;
    double even=x-odd ;
    return((odd*odd)+(even*even)+even);
  }
  static double rangeSum(double N,double L,double R){
    return sumTillX(R,N)-sumTillX(L-1,N);
  }
  public static void main(String args[]){
    long N=10,L=1,R=6 ;
    int n=101 ;
    System.out.println((int)rangeSum(N,L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumTillX( x : double, n : double) : double
  pre: true
  post: true
  activity: (     var odd : double ; odd := (n / 2.0)->ceil() ;
     if (x <= odd) then     return x * x else skip ; 
     var even : double ; even := x - odd ;
     return ((odd * odd) + (even * even) + even) );
  static   operation rangeSum( N : double, L : double, R : double) : double
  pre: true
  post: true
  activity: (     return sumTillX(R, N) - sumTillX(L - 1, N) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := 10 ;
    var L : long ; L := 1 ;
    var R : long ; R := 6 ;
     var n : int ; n := 101 ;
     OclFile["System.out"].println(rangeSum(N, L, R)->oclAsType(int)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int sortByFreq(Integer[] arr,int n){
    int maxE=-1 ;
    for(int i=0 ; i<n ; i++){
      maxE=Math.max(maxE,arr[i]);
    }
    int freq[]=new int[maxE+1];
    for(int i=0 ; i<n ; i++){
      freq[arr[i] ]++;
    }
    int cnt=0 ;
    for(int i=0 ; i<=maxE ; i++){
      if(freq[i]>0){
        int value=100000-i ;
        arr[cnt]=100000*freq[i]+value ;
        cnt++;
      }
    }
    return cnt ;
  }
  static void printSortedArray(Integer[] arr,int cnt){
    for(int i=0 ; i<cnt ; i++){
      int frequency=arr[i]/100000 ;
      int value=100000-(arr[i] % 100000);
      for(int j=0 ; j<frequency ; j++){
        System.out.print(value+" ");
      }
    }
  }
  public static void main(String[] args){
    Integer arr[]={
      4,4,5,6,4,2,2,8,5 };
      int n=arr.length ;
      int cnt=sortByFreq(arr,n);
      Arrays.sort(arr,Collections.reverseOrder());
      printSortedArray(arr,cnt);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sortByFreq( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var maxE : int ; maxE := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     maxE := Set{maxE, arr[i+1]}->max() )  ;     i := i + 1 ) ; 
    var freq : Sequence(int) ; freq := Integer.subrange(1,maxE + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     freq[arr[i+1]+1] := freq[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i <= maxE do ( (     if (freq[i+1] > 0) then (     var value : int ; value := 100000 - i ;
     arr[cnt+1] := 100000 * freq[i+1] + value ; 
     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    return cnt 
 );
  static   operation printSortedArray( arr : Sequence(int), cnt : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < cnt do ( (     var frequency : int ; frequency := arr[i+1] / 100000 ;
     var value : int ; value := 100000 - (arr[i+1] mod 100000) ;
         var j : int ; j := 0 ; while j < frequency do ( (     OclFile["System.out"].print(value + " ") )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,4,5,6,4,2,2,8,5} ;
     var n : int ; n := arr->size() ;
    var cnt : int ; cnt := sortByFreq(arr, n) ;
    arr := OclComparator.sortWith(arr, reverseOrder()) ; 
    execute printSortedArray(arr, cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countDigit(int n){
    int temp=n,count=0 ;
    while(temp!=0){
      int d=temp % 10 ;
      temp/=10 ;
      if(d==2 || d==3 || d==5 || d==7)count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int n=1234567890 ;
    System.out.println(countDigit(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countDigit( n : int) : int
  pre: true
  post: true
  activity: (     var temp : int ; temp := n ;
    var count : int ; count := 0 ;
     while (temp /= 0) do (     var d : int ; d := temp mod 10 ;
     temp := temp/(10) ; 
     if (d = 2 or d = 3 or d = 5 or d = 7) then     count := count + 1 ; else skip ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1234567890 ;
     OclFile["System.out"].println(countDigit(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAX=100 ;
  static int maxRowDiff(int mat[][],int m,int n){
    int rowSum[]=new int[m];
    for(int i=0 ; i<m ; i++){
      int sum=0 ;
      for(int j=0 ; j<n ; j++)sum+=mat[i][j];
      rowSum[i]=sum ;
    }
    int max_diff=rowSum[1]-rowSum[0];
    int min_element=rowSum[0];
    for(int i=1 ; i<m ; i++){
      if(rowSum[i]-min_element>max_diff)max_diff=rowSum[i]-min_element ;
      if(rowSum[i]<min_element)min_element=rowSum[i];
    }
    return max_diff ;
  }
  public static void main(String[] args){
    int m=5,n=4 ;
    int mat[][]={
      {
-1,2,3,4 },{
          5,3,-2,1 },{
            6,7,2,-3 },{
              2,9,1,4 },{
                2,1,-2,0 }
              };
              System.out.print(maxRowDiff(mat,m,n));
            }
          }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 100;
  static   operation maxRowDiff( mat : Sequence(Sequence(int)), m : int, n : int) : int
  pre: true
  post: true
  activity: (     var rowSum : Sequence(int) ; rowSum := Integer.subrange(1,m)->collect(0) ;
         var i : int ; i := 0 ; while i < m do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < n do (     sum := sum+(mat[i+1][j+1]) ;  ;     j := j + 1 ) ; 
     rowSum[i+1] := sum )  ;     i := i + 1 ) ; 
    var max_diff : int ; max_diff := rowSum[1+1] - rowSum[0+1] ;
    var min_element : int ; min_element := rowSum[0+1] ;
        var i : int ; i := 1 ; while i < m do ( (     if (rowSum[i+1] - min_element > max_diff) then     max_diff := rowSum[i+1] - min_element ; else skip ; 
     if (rowSum[i+1] < min_element) then     min_element := rowSum[i+1] ; else skip )  ;     i := i + 1 ) ; 
    return max_diff 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 5 ;
    var n : int ; n := 4 ;
     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{-1,2,3,4},Sequence{5,3,-2,1},Sequence{6,7,2,-3},Sequence{2,9,1,4},Sequence{2,1,-2,0}} ;
     OclFile["System.out"].print(maxRowDiff(mat, m, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int countDigit(int n){
    int temp=n,count=0 ;
    while(temp!=0){
      int d=temp % 10 ;
      temp/=10 ;
      if(d>0 && n % d==0)count++;
    }
    return count ;
  }
  public static void main(String args[]){
    int n=1012 ;
    System.out.println(countDigit(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation countDigit( n : int) : int
  pre: true
  post: true
  activity: (     var temp : int ; temp := n ;
    var count : int ; count := 0 ;
     while (temp /= 0) do (     var d : int ; d := temp mod 10 ;
     temp := temp/(10) ; 
     if (d > 0 & n mod d = 0) then     count := count + 1 ; else skip ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1012 ;
     OclFile["System.out"].println(countDigit(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int N=1000 ;
  static int countPairs(int arr[],int n){
    int size=(2*N)+1 ;
    int freq[]=new int[size];
    for(int i=0 ; i<n ; i++){
      int x=arr[i];
      freq[x+N]++;
    }
    int ans=0 ;
    for(int i=0 ; i<size ; i++){
      if(freq[i]>0){
        ans+=((freq[i])*(freq[i]-1))/2 ;
        for(int j=i+2 ; j<2001 ; j+=2){
          if(freq[j]>0 &&(freq[(i+j)/2]>0)){
            ans+=(freq[i]*freq[j]);
          }
        }
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      4,2,5,1,3,5 };
      int n=arr.length ;
      System.out.println(countPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 1000;
  static   operation countPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var size : int ; size := (2 * N) + 1 ;
     var freq : Sequence(int) ; freq := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := arr[i+1] ;
     freq[x + N+1] := freq[x + N+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < size do ( (     if (freq[i+1] > 0) then (     ans := ans+(((freq[i+1]) * (freq[i+1] - 1)) / 2) ; 
         var j : int ; j := i + 2 ; while j < 2001 do ( (     if (freq[j+1] > 0 & (freq[(i + j) / 2+1] > 0)) then (     ans := ans+((freq[i+1] * freq[j+1])) ) else skip )  ;     j := j+(2) ) ) else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,2,5,1,3,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countPairs(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    StringTokenizer st=new StringTokenizer(in.readLine());
    int n=Integer.parseInt(st.nextToken());
    int p=Integer.parseInt(st.nextToken());
    int k=Integer.parseInt(st.nextToken());
    String r="" ;
    if(p-k>1){
      r+="<<" ;
    }
    for(int i=Math.max(1,p-k); i<=Math.min(p+k,n); i++){
      if(i==p){
        r+="("+i+")" ;
      }
      else r+=i+" " ;
    }
    if(p+k<n)r+=">>" ;
    out.println(r.trim());
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(in.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var p : int ; p := (st.next())->toInteger() ;
    var k : int ; k := (st.next())->toInteger() ;
    var r : String ; r := "" ;
    if (p - k > 1) then (     r := r+("<<") ) else skip ; 
        var i : int ; i := Set{1, p - k}->max() ; while i <= Set{p + k, n}->min() do ( (     if (i = p) then (     r := r+("(" + i + ")") ) else     r := r+(i + " ") ; )  ;     i := i + 1 ) ; 
    if (p + k < n) then     r := r+(">>") ; else skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int p=scan.nextInt();
    int k=scan.nextInt();
    int from=Math.max(p-k,1);
    int to=Math.min(p+k,n);
    if(from>1){
      System.out.print("<<");
    }
    for(int i=from ; i<=to ; i++){
      if(i==p){
        System.out.print("("+i+")");
      }
      else {
        System.out.print(i+" ");
      }
    }
    if(to<n){
      System.out.print(">>");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var p : int ; p := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var from : int ; from := Set{p - k, 1}->max() ;
    var to : int ; to := Set{p + k, n}->min() ;
    if (from > 1) then (     OclFile["System.out"].print("<<") ) else skip ; 
        var i : int ; i := from ; while i <= to do ( (     if (i = p) then (     OclFile["System.out"].print("(" + i + ")") ) else (     OclFile["System.out"].print(i + " ") ) )  ;     i := i + 1 ) ; 
    if (to < n) then (     OclFile["System.out"].print(">>") ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int p=sc.nextInt();
    int k=sc.nextInt();
    List<Integer>list=new ArrayList<>();
    for(int i=p-k ; i<=p+k ; i++){
      if(i>=1 && i<=n){
        list.add(i);
      }
    }
    StringBuilder sb=new StringBuilder();
    if(list.get(0)!=1){
      sb.append("<<");
    }
    for(Integer num : list){
      if(num==p){
        sb.append("(").append(num).append(")");
      }
      else {
        sb.append(" ").append(num);
      }
    }
    if(list.get(list.size()-1)!=n){
      sb.append(">>");
    }
    System.out.println(sb.substring(1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := p - k ; while i <= p + k do ( (     if (i >= 1 & i <= n) then (     list := list->including(i) ) else skip )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    if (list->at(0+1) /= 1) then (     sb := sb + StringLib.newString("<<") ) else skip ; 
    for (num : list) do ( (     if (num = p) then (     sb := sb + StringLib.newString("(") + StringLib.newString(num) + StringLib.newString(")") ) else (     sb := sb + StringLib.newString(" ") + StringLib.newString(num) ) )  ) ; 
    if (list->at(list->size() - 1+1) /= n) then (     sb := sb + StringLib.newString(">>") ) else skip ; 
    OclFile["System.out"].println(sb.subrange(1+1,1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int p=s.nextInt();
    int k=s.nextInt();
    int minPage=Math.max(1,p-k);
    int maxPage=Math.min(n,p+k);
    String index="" ;
    if(p-k>1)index+="<<" ;
    for(int i=minPage ; i<=maxPage ; i++){
      if(i==p)index+="("+i+")" ;
      else index+=i+" " ;
    }
    if(p+k<n)index+=">>" ;
    System.out.println(index);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var p : int ; p := s.getCurrent()->toInteger() ;
    var k : int ; k := s.getCurrent()->toInteger() ;
    var minPage : int ; minPage := Set{1, p - k}->max() ;
    var maxPage : int ; maxPage := Set{n, p + k}->min() ;
    var index : String ; index := "" ;
    if (p - k > 1) then     index := index+("<<") ; else skip ; 
        var i : int ; i := minPage ; while i <= maxPage do ( (     if (i = p) then     index := index+("(" + i + ")") ; else     index := index+(i + " ") ; )  ;     i := i + 1 ) ; 
    if (p + k < n) then     index := index+(">>") ; else skip ; 
    OclFile["System.out"].println(index) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_pages {
  public static void main(String[] args){
    Scanner LOL=new Scanner(System.in);
    int n=LOL.nextInt();
    int p=LOL.nextInt();
    int k=LOL.nextInt();
    LOL1(n,p,k);
    LOL2(n,p,k);
  }
  public static void LOL1(int n,int p,int k){
    boolean b=false ;
    for(int i=p-k ; i<p ; i++){
      if(i>1 && ! b){
        System.out.print("<<");
        b=true ;
      }
      if(i>0){
        System.out.print(i+" ");
        b=true ;
      }
    }
  }
  public static void LOL2(int n,int p,int k){
    if(p<=n)System.out.print("("+p+")");
    for(int i=p ; i+1<=p+k && i+1<=n ; i++){
      System.out.print(i+1+" ");
      if(i+1==p+k && i+1<n)System.out.print(">>");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_pages {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var LOL : OclFile ; LOL := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := LOL.getCurrent()->toInteger() ;
    var p : int ; p := LOL.getCurrent()->toInteger() ;
    var k : int ; k := LOL.getCurrent()->toInteger() ;
    execute LOL1(n, p, k) ; 
    execute LOL2(n, p, k) ; 
 );
  static   operation LOL1( n : int, p : int, k : int) : void
  pre: true
  post: true
  activity: (     var b : boolean ; b := false ;
         var i : int ; i := p - k ; while i < p do ( (     if (i > 1 & not(b)) then (     OclFile["System.out"].print("<<") ; 
     b := true ) else skip ; 
     if (i > 0) then (     OclFile["System.out"].print(i + " ") ; 
     b := true ) else skip )  ;     i := i + 1 ) );
  static   operation LOL2( n : int, p : int, k : int) : void
  pre: true
  post: true
  activity: (     if (p <= n) then     OclFile["System.out"].print("(" + p + ")") ; else skip ; 
         var i : int ; i := p ; while i + 1 <= p + k & i + 1 <= n do ( (     OclFile["System.out"].print(i + 1 + " ") ; 
     if (i + 1 = p + k & i + 1 < n) then     OclFile["System.out"].print(">>") ; else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CodeForces {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextInt();
    String s1=sc.next();
    String s2=sc.next();
    long oo=0 ;
    long ol=0 ;
    long lo=0 ;
    long ll=0 ;
    for(int i=0 ; i<n ; i++){
      if(s1.charAt(i)=='0'){
        if(s2.charAt(i)=='0'){
          oo++;
        }
        else {
          ol++;
        }
      }
      else {
        if(s2.charAt(i)=='0'){
          lo++;
        }
        else {
          ll++;
        }
      }
    }
    long ans=oo*lo+oo*ll+ol*lo ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toInteger() ;
    var s1 : String ; s1 := sc.getCurrent() ;
    var s2 : String ; s2 := sc.getCurrent() ;
    var oo : long ; oo := 0 ;
    var ol : long ; ol := 0 ;
    var lo : long ; lo := 0 ;
    var ll : long ; ll := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s1->at(i+1) = '0') then (     if (s2->at(i+1) = '0') then (     oo := oo + 1 ) else (     ol := ol + 1 ) ) else (     if (s2->at(i+1) = '0') then (     lo := lo + 1 ) else (     ll := ll + 1 ) ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := oo * lo + oo * ll + ol * lo ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  private static Scanner scan=new Scanner(System.in);
  public static void main(String args[]){
    long n=scan.nextLong();
    char[] a=scan.next().toCharArray();
    char[] b=scan.next().toCharArray();
    long zero=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]=='0'){
        zero++;
      }
    }
    long oneZero=0,oneOne=0,zeroZero=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]=='0' && b[i]=='0'){
        zeroZero++;
      }
      else if(a[i]=='1' && b[i]=='1'){
        oneOne++;
      }
      else if(a[i]=='1' && b[i]=='0'){
        oneZero++;
      }
    }
    System.out.println((zero*oneZero)+(zeroZero*oneOne));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := scan.getCurrent()->toLong() ;
     var a : Sequence(String) ; a := scan.getCurrent()->characters() ;
    var b : Sequence(String) ; b := scan.getCurrent()->characters() ;
    var zero : long ; zero := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = '0') then (     zero := zero + 1 ) else skip )  ;     i := i + 1 ) ; 
    var oneZero : long ; oneZero := 0 ;
    var oneOne : long ; oneOne := 0 ;
    var zeroZero : long ; zeroZero := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = '0' & b[i+1] = '0') then (     zeroZero := zeroZero + 1 ) else     if (a[i+1] = '1' & b[i+1] = '1') then (     oneOne := oneOne + 1 ) else     if (a[i+1] = '1' & b[i+1] = '0') then (     oneZero := oneZero + 1 ) else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((zero * oneZero) + (zeroZero * oneOne)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TheBits {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),i ;
    String a=in.next(),b=in.next();
    in.close();
    long z=0,oz=0,oo=0,zz=0 ;
    for(i=0 ; i<n ; i++){
      if(a.charAt(i)=='0')z++;
      if(a.charAt(i)=='1' && b.charAt(i)=='0')oz++;
      if(a.charAt(i)=='1' && b.charAt(i)=='1')oo++;
      if(a.charAt(i)=='0' && b.charAt(i)=='0')zz++;
    }
    System.out.println(oo*zz+oz*z);
  }
}
------------------------------------------------------------
OCL File:
---------
 class TheBits {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var i : int ;
    var a : String ; a := in.getCurrent() ;
    var b : String ; b := in.getCurrent() ;
    skip ; 
    var z : long ; z := 0 ;
    var oz : long ; oz := 0 ;
    var oo : long ; oo := 0 ;
    var zz : long ; zz := 0 ;
        i := 0 ; while i < n do ( (     if (a->at(i+1) = '0') then     z := z + 1 ; else skip ; 
     if (a->at(i+1) = '1' & b->at(i+1) = '0') then     oz := oz + 1 ; else skip ; 
     if (a->at(i+1) = '1' & b->at(i+1) = '1') then     oo := oo + 1 ; else skip ; 
     if (a->at(i+1) = '0' & b->at(i+1) = '0') then     zz := zz + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(oo * zz + oz * z) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int getDistinctPoints(int current_pos,String path){
    int len=path.length();
    int points[]=new int[len+1];
    points[0]=current_pos ;
    for(int i=0 ; i<len ; i++){
      char ch=path.charAt(i);
      if(ch=='0'){
        current_pos--;
        points[i+1]=current_pos ;
      }
      else {
        current_pos++;
        points[i+1]=current_pos ;
      }
    }
    return countDistinct(points,len+1);
  }
  public static int countDistinct(int arr[],int len){
    HashSet<Integer>hs=new HashSet<Integer>();
    for(int i=0 ; i<len ; i++){
      hs.add(arr[i]);
    }
    return hs.size();
  }
  public static void main(String[] args){
    int current_pos=5 ;
    String path="011101" ;
    System.out.print(getDistinctPoints(current_pos,path));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getDistinctPoints( current_pos : int, path : String) : int
  pre: true
  post: true
  activity: (     var len : int ; len := path->size() ;
     var points : Sequence(int) ; points := Integer.subrange(1,len + 1)->collect(0) ;
    points[0+1] := current_pos ; 
        var i : int ; i := 0 ; while i < len do ( (     var ch : String ; ch := path->at(i+1) ;
     if (ch = '0') then (     current_pos := current_pos - 1 ; 
     points[i + 1+1] := current_pos ) else (     current_pos := current_pos + 1 ; 
     points[i + 1+1] := current_pos ) )  ;     i := i + 1 ) ; 
    return countDistinct(points, len + 1) 
 );
  static   operation countDistinct( arr : Sequence(int), len : int) : int
  pre: true
  post: true
  activity: (     var hs : Set(int) ; hs := Set{} ;
         var i : int ; i := 0 ; while i < len do ( (     hs := hs->including(arr[i+1]) )  ;     i := i + 1 ) ; 
     return hs->size() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var current_pos : int ; current_pos := 5 ;
     var path : String ; path := "011101" ;
     OclFile["System.out"].print(getDistinctPoints(current_pos, path)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int w=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int min=0 ;
    while(true){
      if(Math.abs(a-b)<=w){
        System.out.println(min);
        break ;
      }
      else {
        min+=1 ;
        w++;
      }
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var min : int ; min := 0 ;
    while (true) do (     if (if a - b < 0 then -(a - b) else a - b endif <= w) then (     OclFile["System.out"].println(min) ; 
     break ) else (     min := min+(1) ; 
     w := w + 1 ) ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Map.*;
public class Main {
  private static int[] colors ;
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=n-1 ;
    colors=new int[n];
    Arrays.fill(colors,-1);
    Point[] points=new Point[n];
    for(int i=0 ; i<n ; i++){
      points[i]=new Point(i);
    }
    while(m-->0){
      int me=sc.nextInt()-1 ;
      int you=sc.nextInt()-1 ;
      int length=sc.nextInt();
      points[me] .becomeFriend(points[you],length);
      points[you] .becomeFriend(points[me],length);
    }
    dfs(points[0],0);
    for(int c : colors){
      System.out.println(c);
    }
  }
  public static void dfs(Point p,int length){
    boolean alreadyKnown=colors[p.name]!=-1 ;
    if(alreadyKnown)return ;
    if(length % 2==0){
      colors[p.name]=0 ;
    }
    else {
      colors[p.name]=1 ;
    }
    for(Entry<Point,Integer>entry : p.friends.entrySet()){
      Point friend=entry.getKey();
      int length2=entry.getValue();
      dfs(friend,length+length2);
    }
  }
  public static class Point {
    int name ;
    Map<Point,Integer>friends ;
    Point(int name){
      this.name=name ;
      this.friends=new HashMap<Point,Integer>();
    }
    void becomeFriend(Point p,int length){
      this.friends.put(p,length);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute colors : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := n - 1 ;
    colors := Integer.subrange(1,n)->collect(0) ; 
    colors := colors->collect(-1) ; 
    var points : Sequence(Point) ; points := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     points[i+1] := Point.newPoint(i) )  ;     i := i + 1 ) ; 
        while (m > 0) do (        m := m - 1 ;     skip ; (     var me : int ; me := sc.getCurrent()->toInteger() - 1 ;
     var you : int ; you := sc.getCurrent()->toInteger() - 1 ;
    var length : int ; length := sc.getCurrent()->toInteger() ;
    points[me+1].becomeFriend(points[you+1], length) ; 
    points[you+1].becomeFriend(points[me+1], length) ; 
 ) ;  ) ;  
    execute dfs(points[0+1], 0) ; 
    for (c : colors) do ( (     OclFile["System.out"].println(c) )  ) ; 
 );
  static   operation dfs( p : Point, length : int) : void
  pre: true
  post: true
  activity: (     var alreadyKnown : boolean ; alreadyKnown := colors[p.name+1] /= -1 ;
     if (alreadyKnown) then     return else skip ; 
     if (length mod 2 = 0) then (     colors[p.name+1] := 0 ) else (     colors[p.name+1] := 1 ) ;  
     for (entry : p.friends->asSet()) do ( (     var friend : Point ; friend := entry.getKey() ;
     var length2 : int ; length2 := entry.getValue() ;
     execute dfs(friend, length + length2) )  ) );
  static class Point {
   attribute name : int;
   attribute friends : Map(Point,int);
   static operation newPoint( name : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(name);
    return self );
  operation initialise( name : int) : void
  pre: true  post: true
  activity: (     self.name := name ; 
     self.friends := Map{} );
   operation becomeFriend( p : Point, length : int) : void
  pre: true
  post: true
  activity: (     self := self.friends->union(Map{p |-> length}) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sum,n ;
  static float getAvg(int x){
    sum+=x ;
    return(((float)sum)/++n);
  }
  static void streamAvg(float[] arr,int n){
    float avg=0 ;
    for(int i=0 ; i<n ; i++){
      avg=getAvg((int)arr[i]);
      System.out.println("Average of "+(i+1)+" numbers is "+avg);
    }
    return ;
  }
  public static void main(String[] args){
    float[] arr=new float[] {
      10,20,30,40,50,60 };
      int n=arr.length ;
      streamAvg(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute sum : int;
  static   operation getAvg( x : int) : double
  pre: true
  post: true
  activity: (     sum := sum+(x) ; 
     return ((sum->oclAsType(double)) / (n + 1)) );
  static   operation streamAvg( arr : Sequence(double), n : int) : void
  pre: true
  post: true
  activity: (     var avg : double ; avg := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     avg := getAvg(arr[i+1]->oclAsType(int)) ; 
     OclFile["System.out"].println("Average of " + (i + 1) + " numbers is " + avg) )  ;     i := i + 1 ) ; 
     return );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(double) ; arr := Sequence{10,20,30,40,50,60} ;
     var n : int ; n := arr->size() ;
     execute streamAvg(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAX=100000 ;
  static void countEleLessThanOrEqual(int arr1[],int m,int arr2[],int n){
    int hash[]=new int[MAX];
    for(int i=0 ; i<n ; i++)hash[arr2[i] ]++;
    for(int i=1 ; i<MAX ; i++){
      hash[i]=hash[i]+hash[i-1];
    }
    for(int i=0 ; i<m ; i++){
      System.out.print(hash[arr1[i] ]+" ");
    }
  }
  public static void main(String[] args){
    int arr1[]={
      1,2,3,4,7,9 };
      int arr2[]={
        0,1,2,1,1,4 };
        int m,n ;
        m=arr1.length ;
        n=arr2.length ;
        countEleLessThanOrEqual(arr1,m,arr2,n);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100000;
  static   operation countEleLessThanOrEqual( arr1 : Sequence(int), m : int, arr2 : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var hash : Sequence(int) ; hash := Integer.subrange(1,MAX)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     hash[arr2[i+1]+1] := hash[arr2[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i < MAX do ( (     hash[i+1] := hash[i+1] + hash[i - 1+1] )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < m do ( (     OclFile["System.out"].print(hash[arr1[i+1]+1] + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{1,2,3,4,7,9} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{0,1,2,1,1,4} ;
    var m : int ;
    var n : int ;
    m := arr1->size() ; 
    n := arr2->size() ; 
    execute countEleLessThanOrEqual(arr1, m, arr2, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findNumbers(int n){
    String ans=string(n-1,'F');
    String even=ans+'E' ;
    String odd=ans+'F' ;
    System.out.print("Even: "+even+"\n");
    System.out.print("Odd: "+odd+"\n");
  }
  private static String string(int n,char c){
    String str="" ;
    for(int i=0 ; i<n ; i++)str+=c ;
    return str ;
  }
  public static void main(String[] args){
    int n=2 ;
    findNumbers(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNumbers( n : int) : void
  pre: true
  post: true
  activity: (     var ans : String ; ans := string(n - 1, 'F') ;
     var even : String ; even := ans + 'E' ;
    var odd : String ; odd := ans + 'F' ;
    OclFile["System.out"].print("Even: " + even + "\n") ; 
    OclFile["System.out"].print("Odd: " + odd + "\n") ; 
 );
  static   operation string( n : int, c : String) : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
         var i : int ; i := 0 ; while i < n do (     str := str+(c) ;  ;     i := i + 1 ) ; 
     return str );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     execute findNumbers(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class MaximumAbsoluteDifference {
  private static int calculateDiff(int i,int j,int[] array){
    return Math.abs(array[i]-array[j])+Math.abs(i-j);
  }
  private static int maxDistance(int[] array){
    int result=0 ;
    for(int i=0 ; i<array.length ; i++){
      for(int j=i ; j<array.length ; j++){
        result=Math.max(result,calculateDiff(i,j,array));
      }
    }
    return result ;
  }
  public static void main(String[] args){
    int[] array={
-70,-64,-6,-56,64,61,-57,16,48,-98 };
      System.out.println(maxDistance(array));
    }
  }

------------------------------------------------------------
OCL File:
---------
class MaximumAbsoluteDifference {
  static   operation calculateDiff( i : int, j : int, array : Sequence(int)) : int
  pre: true
  post: true
  activity: (     return if array[i+1] - array[j+1] < 0 then -(array[i+1] - array[j+1]) else array[i+1] - array[j+1] endif + if i - j < 0 then -(i - j) else i - j endif );
  static   operation maxDistance( array : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < array->size() do ( (         var j : int ; j := i ; while j < array->size() do ( (     result := Set{result, calculateDiff(i, j, array)}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Sequence{-70,-64,-6,-56,64,61,-57,16,48,-98} ;
     OclFile["System.out"].println(maxDistance(array)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      int num ;
      while((num=Integer.parseInt(br.readLine()))!=0){
        int total=0 ;
        for(int i=0 ; i<num ; i=i+4){
          int hit=Integer.parseInt(br.readLine());
          total+=hit ;
        }
        System.out.println(total);
      }
    }
    catch(Exception e){
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var num : int ;
         num := (br.readLine())->toInteger() ;
    while ((num) /= 0) do (    skip ; (     var total : int ; total := 0 ;
         var i : int ; i := 0 ; while i < num do ( (     var hit : int ; hit := (br.readLine())->toInteger() ;
     total := total+(hit) )  ;     i := i + 4 ) ; 
     OclFile["System.out"].println(total) ) ;     num := (br.readLine())->toInteger() ;
 ) )   catch (e : ProgramException) do (     OclFile["System.out"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      int ans=0 ;
      for(int i=0 ; i<n/4 ; i++)ans+=scanner.nextInt();
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n / 4 do (     ans := ans+(scanner.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int j,k,i,b,c,W,N,S ;
    for(i=0 ; ; i++){
      S=0 ;
      String str1=br.readLine();
      int n=Integer.parseInt(str1);
      if(n==0)break ;
      for(j=0 ; j<n/4 ; j++){
        String str2=br.readLine();
        int a=Integer.parseInt(str2);
        S=S+a ;
      }
      System.out.println(S);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var j : int ;
    var k : int ;
    var i : int ;
    var b : int ;
    var c : int ;
    var W : int ;
    var N : int ;
    var S : int ;
         i := 0 ; while true do ( (     S := 0 ; 
     var str1 : String ; str1 := br.readLine() ;
    var n : int ; n := (str1)->toInteger() ;
    if (n = 0) then     break else skip ; 
        j := 0 ; while j < n / 4 do ( (     var str2 : String ; str2 := br.readLine() ;
     var a : int ; a := (str2)->toInteger() ;
     S := S + a )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(S) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  PrintStream log=new PrintStream(new OutputStream(){
    public void write(int b){
    }
  }
);
  PrintStream result=System.out ;
  Scanner sc=new Scanner(System.in);
  void main()throws IOException {
    for(; ; ){
      int N=sc.nextInt();
      if(N==0)break ;
      int sum=0 ;
      for(int i=0 ; i<N/4 ; i++){
        sum+=sc.nextInt();
      }
      result.println(sum);
    }
  }
  public static void main(String[] args)throws IOException {
    new Main().main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute log : OclFile := OclFile.newOclFile_Write(OclFile());
   attribute result : OclFile := OclFile["System.out"];
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation main() : void
  pre: true
  post: true
  activity: (       while true do ( (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then     break else skip ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < N / 4 do ( (     sum := sum+(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().main() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPalindrome(int N){
    String str=""+N ;
    int len=str.length();
    for(int i=0 ; i<len/2 ; i++){
      if(str.charAt(i)!=str.charAt(len-1-i))return false ;
    }
    return true ;
  }
  static boolean isPalinArray(int[] arr,int n){
    for(int i=0 ; i<n ; i++){
      boolean ans=isPalindrome(arr[i]);
      if(ans==false)return false ;
    }
    return true ;
  }
  public static void main(String args[]){
    int[] arr={
      121,131,20 };
      int n=arr.length ;
      boolean res=isPalinArray(arr,n);
      if(res==true)System.out.println("Array is a PalinArray");
      else System.out.println("Array is not a PalinArray");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPalindrome( N : int) : boolean
  pre: true
  post: true
  activity: (     var str : String ; str := "" + N ;
     var len : int ; len := str->size() ;
         var i : int ; i := 0 ; while i < len / 2 do ( (     if (str->at(i+1) /= str->at((len)->char2byte() - 1 - i+1)) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation isPalinArray( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var ans : boolean ; ans := isPalindrome(arr[i+1]) ;
     if (ans = false) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{121,131,20} ;
     var n : int ; n := arr->size() ;
     var res : boolean ; res := isPalinArray(arr, n) ;
     if (res = true) then     OclFile["System.out"].println("Array is a PalinArray") ; else     OclFile["System.out"].println("Array is not a PalinArray") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int power(int x,int y,int p){
    int res=1 ;
    x=x % p ;
    while(y>0){
      if((y & 1)==0)res=(res*x)% p ;
      y=y>>1 ;
      x=(x*x)% p ;
    }
    return res ;
  }
  static boolean squareRootExists(int n,int p){
    if(power(n,(p-1)/2,p)==1)return true ;
    return false ;
  }
  public static void main(String[] args){
    int p=7 ;
    int n=2 ;
    if(squareRootExists(n,p))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation power( x : int, y : int, p : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     if ((y & 1) = 0) then     res := (res * x) mod p ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res );
  static   operation squareRootExists( n : int, p : int) : boolean
  pre: true
  post: true
  activity: (     if (power(n, (p - 1) / 2, p) = 1) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : int ; p := 7 ;
     var n : int ; n := 2 ;
     if (squareRootExists(n, p)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    long constant=0 ;
    TreeMap<Integer,Integer>map=new TreeMap<>();
    int ptr=-1 ;
    int idx=-1 ;
    int total=0 ;
    long val=0 ;
    for(int i=0 ; i<q ; i++){
      if(sc.nextInt()==1){
        int a=sc.nextInt();
        int b=sc.nextInt();
        constant+=b ;
        map.put(a,map.getOrDefault(a,0)+1);
        if(ptr==-1){
          ptr=a ;
          idx=1 ;
        }
        else if(a<ptr){
          val+=Math.abs(a-ptr);
          if(total % 2==1){
            idx--;
            if(idx==0){
              ptr=map.lowerKey(ptr);
              idx=map.get(ptr);
            }
          }
        }
        else if(a>ptr){
          val+=Math.abs(a-ptr);
          if(total % 2==0){
            idx++;
            if(idx>map.get(ptr)){
              int newPtr=map.higherKey(ptr);
              val-=(newPtr-ptr);
              ptr=newPtr ;
              idx=1 ;
            }
          }
        }
        else {
          if(total % 2==0){
            idx++;
          }
          val+=Math.abs(ptr-a);
        }
        total++;
      }
      else {
        System.out.println(ptr+" "+(val+constant));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
    var constant : long ; constant := 0 ;
    var map : Map(int,int) ; map := Map{} ;
    var ptr : int ; ptr := -1 ;
    var idx : int ; idx := -1 ;
    var total : int ; total := 0 ;
    var val : long ; val := 0 ;
        var i : int ; i := 0 ; while i < q do ( (     if (sc.getCurrent()->toInteger() = 1) then (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    constant := constant+(b) ; 
    map := map->union(Map{a |-> (if map->keys()->contains(a) then map->at(a) else 0 endif) + 1}) ; 
    if (ptr = -1) then (     ptr := a ; 
     idx := 1 ) else     if (a < ptr) then (     val := val+(if a - ptr < 0 then -(a - ptr) else a - ptr endif) ; 
     if (total mod 2 = 1) then (     idx := idx - 1 ; 
     if (idx = 0) then (     ptr := map.lowerKey(ptr) ; 
     idx := map->at(ptr) ) else skip ) else skip ) else     if (a > ptr) then (     val := val+(if a - ptr < 0 then -(a - ptr) else a - ptr endif) ; 
     if (total mod 2 = 0) then (     idx := idx + 1 ; 
     if (idx > map->at(ptr)) then (     var newPtr : int ; newPtr := map.higherKey(ptr) ;
     val := val-((newPtr - ptr)) ; 
     ptr := newPtr ; 
     idx := 1 ) else skip ) else skip ) else (     if (total mod 2 = 0) then (     idx := idx + 1 ) else skip ; 
     val := val+(if ptr - a < 0 then -(ptr - a) else ptr - a endif) ) ;  ;  ;  
    total := total + 1 ; 
 ) else (     OclFile["System.out"].println(ptr + " " + (val + constant)) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public void main(){
    Scanner sc=new Scanner(new InputStreamReader(System.in));
    int w=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(a>b){
      int tmp=a ;
      a=b ;
      b=tmp ;
    }
    println(Math.max(b-(a+w),0));
  }
  public void print(Object o){
    System.out.print(o);
  }
  public void println(Object o){
    System.out.println(o);
  }
  public static void main(String[] args){
    new Main().main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    if (a > b) then (     var tmp : int ; tmp := a ;
     a := b ; 
     b := tmp ) else skip ; 
    execute println(Set{b - (a + w), 0}->max()) ; 
 );
   operation print( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
   operation println( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().main() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Point implements Comparable<Point>{
  int a,b ;
  Point(int a,int b){
    this.a=a ;
    this.b=b ;
  }
  public int hashCode(){
    return((a & 0xFFFF0000)|(b>>16))^((b & 0xFFFF0000)|(a>>16));
  }
  public boolean equals(Object object){
    Point point=(Point)object ;
    return this.a==point.a && this.b==point.b ;
  }
  public int compareTo(Point p){
    if(this.a!=p.a){
      return this.a-p.a ;
    }
    return this.b-p.b ;
  }
}
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int h=s.nextInt();
    int w=s.nextInt();
    int n=s.nextInt();
    HashMap<Point,Integer>map=new HashMap<Point,Integer>();
    for(int i=0 ; i<n ; i++){
      int a=s.nextInt()-1 ;
      int b=s.nextInt()-1 ;
      for(int da=Math.max(0,a-2); da<=Math.min(h-3,a); da++){
        for(int db=Math.max(0,b-2); db<=Math.min(w-3,b); db++){
          Point p=new Point(da,db);
          if(map.get(p)==null){
            map.put(p,1);
          }
          else {
            map.put(p,map.get(p)+1);
          }
        }
      }
    }
    long[] output=new long[10];
    output[0]=(long)(h-2)*(long)(w-2);
    for(int value : map.values()){
      output[0]--;
      output[value]++;
    }
    for(long value : output){
      System.out.println(value);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Point implements Comparable<Point> {
   attribute a : int;
   static operation newPoint( a : int, b : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
   operation hashCode() : int
  pre: true
  post: true
  activity: (     return ((MathLib.bitwiseAnd(a,0xFFFF0000)) or ((b/(2->pow(16)))->oclAsType(long))) xor ((b & 0xFFFF0000) or ((a/(2->pow(16)))->oclAsType(long))) );
   operation equals( object : OclAny) : boolean
  pre: true
  post: true
  activity: (     var point : Point ; point := object->oclAsType(Point) ;
     return self.a = point.a & self.b = point.b );
   operation compareTo( p : Point) : int
  pre: true
  post: true
  activity: (     if (self.a /= p.a) then (     return self.a - p.a ) else skip ; 
     return self.b - p.b );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := s.getCurrent()->toInteger() ;
    var w : int ; w := s.getCurrent()->toInteger() ;
    var n : int ; n := s.getCurrent()->toInteger() ;
    var map : Map(Point,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := s.getCurrent()->toInteger() - 1 ;
     var b : int ; b := s.getCurrent()->toInteger() - 1 ;
         var da : int ; da := Set{0, a - 2}->max() ; while da <= Set{h - 3, a}->min() do ( (         var db : int ; db := Set{0, b - 2}->max() ; while db <= Set{w - 3, b}->min() do ( (     var p : Point ; p := Point.newPoint(da, db) ;
     if (map->at(p) = null) then (     map := map->union(Map{p |-> 1}) ) else (     map := map->union(Map{p |-> map->at(p) + 1}) ) )  ;     db := db + 1 ) )  ;     da := da + 1 ) )  ;     i := i + 1 ) ; 
    var output : Sequence(long) ; output := Integer.subrange(1,10)->collect(0) ;
    output[0+1] := (h - 2)->oclAsType(long) * (w - 2)->oclAsType(long) ; 
    for (value : map->values()) do ( (     output[0+1] := output[0+1] - 1 ; 
     output[value+1] := output[value+1] + 1 )  ) ; 
    for (value : output) do ( (     OclFile["System.out"].println(value) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] $){
    long h=scanner.nextInt();
    long w=scanner.nextInt();
    int n=scanner.nextInt();
    Map<Long,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      long a=scanner.nextInt();
      long b=scanner.nextInt();
      for(int dx=-1 ; dx<=1 ; dx++){
        for(int dy=-1 ; dy<=1 ; dy++){
          if((b+dx)>1 &&(b+dx)<w &&(a+dy)>1 &&(a+dy)<h){
            map.compute((b+dx)*h+(a+dy),(key,value)->value==null ? 0 : value+1);
          }
        }
      }
    }
    long sum=0 ;
    int[] count=new int[9];
    for(int i : map.values()){
      count[i]++;
      sum++;
    }
    System.out.println((h-2)*(w-2)-sum);
    Arrays.stream(count).forEach(System.out :: println);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var h : long ; h := scanner.getCurrent()->toInteger() ;
     var w : long ; w := scanner.getCurrent()->toInteger() ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var map : Map(long,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : long ; a := scanner.getCurrent()->toInteger() ;
     var b : long ; b := scanner.getCurrent()->toInteger() ;
         var dx : int ; dx := -1 ; while dx <= 1 do ( (         var dy : int ; dy := -1 ; while dy <= 1 do ( (     if ((b + dx) > 1 & (b + dx) < w & (a + dy) > 1 & (a + dy) < h) then (     map := map.compute((b + dx) * h + (a + dy), lambda (key , value) : OclAny in if value = null then 0 else value + 1 endif) ) else skip )  ;     dy := dy + 1 ) )  ;     dx := dx + 1 ) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    var count : Sequence(int) ; count := Integer.subrange(1,9)->collect(0) ;
    for (i : map->values()) do ( (     count[i+1] := count[i+1] + 1 ; 
     sum := sum + 1 )  ) ; 
    OclFile["System.out"].println((h - 2) * (w - 2) - sum) ; 
    for _forEach : stream(count) do
    (    skip ;) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.Point ;
public class Main {
  public static void main(String[] args){
    new Main().solve();
  }
  public void solve(){
    Scanner scanner=new Scanner(System.in);
    long H=scanner.nextLong();
    long W=scanner.nextLong();
    int N=scanner.nextInt();
    Point[] point=new Point[N];
    for(int i=0 ; i<N ; i++){
      int row=scanner.nextInt();
      int col=scanner.nextInt();
      point[i]=new Point(col,row);
    }
    HashMap<Point,Integer>hashmap=new HashMap<Point,Integer>();
    for(int i=0 ; i<N ; i++){
      for(int y=-1 ; y<2 ; y++){
        for(int x=-1 ; x<2 ; x++){
          Point p=new Point(point[i] .x+x,point[i] .y+y);
          if(hashmap.get(p)==null){
            hashmap.put(p,1);
          }
          else {
            hashmap.put(p,hashmap.get(p)+1);
          }
        }
      }
    }
    long[] counter=new long[10];
    for(int i=0 ; i<counter.length ; i++){
      counter[i]=0 ;
    }
    long sum=(H-2)*(W-2);
    for(HashMap.Entry<Point,Integer>map : hashmap.entrySet()){
      if(1<map.getKey().x && map.getKey().x<W && 1<map.getKey().y && map.getKey().y<H){
        counter[map.getValue()]++;
        sum--;
      }
    }
    counter[0]=sum ;
    for(int i=0 ; i<counter.length ; i++){
      System.out.println(counter[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : long ; H := scanner.getCurrent()->toLong() ;
    var W : long ; W := scanner.getCurrent()->toLong() ;
    var N : int ; N := scanner.getCurrent()->toInteger() ;
    var point : Sequence(Point) ; point := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     var row : int ; row := scanner.getCurrent()->toInteger() ;
     var col : int ; col := scanner.getCurrent()->toInteger() ;
     point[i+1] := Point.newPoint(col, row) )  ;     i := i + 1 ) ; 
    var hashmap : Map(Point,int) ; hashmap := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (         var y : int ; y := -1 ; while y < 2 do ( (         var x : int ; x := -1 ; while x < 2 do ( (     var p : Point ; p := Point.newPoint(point[i+1].x + x, point[i+1].y + y) ;
     if (hashmap->at(p) = null) then (     hashmap := hashmap->union(Map{p |-> 1}) ) else (     hashmap := hashmap->union(Map{p |-> hashmap->at(p) + 1}) ) )  ;     x := x + 1 ) )  ;     y := y + 1 ) )  ;     i := i + 1 ) ; 
    var counter : Sequence(long) ; counter := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < counter->size() do ( (     counter[i+1] := 0 )  ;     i := i + 1 ) ; 
    var sum : long ; sum := (H - 2) * (W - 2) ;
    for (map : hashmap->asSet()) do ( (     if (1 < map.getKey().x & map.getKey().x < W & 1 < map.getKey().y & map.getKey().y < H) then (     counter[map.getValue()+1] := counter[map.getValue()+1] + 1 ; 
     sum := sum - 1 ) else skip )  ) ; 
    counter[0+1] := sum ; 
        var i : int ; i := 0 ; while i < counter->size() do ( (     OclFile["System.out"].println(counter[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Point implements Comparable<Point>{
  int a,b ;
  Point(int a,int b){
    this.a=a ;
    this.b=b ;
  }
  public int hashCode(){
    return a ^ b ;
  }
  public boolean equals(Object object){
    Point point=(Point)object ;
    return this.a==point.a && this.b==point.b ;
  }
  public int compareTo(Point p){
    if(this.a!=p.a){
      return this.a-p.a ;
    }
    return this.b-p.b ;
  }
}
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int h=s.nextInt();
    int w=s.nextInt();
    int n=s.nextInt();
    TreeMap<Point,Integer>map=new TreeMap<Point,Integer>();
    for(int i=0 ; i<n ; i++){
      int a=s.nextInt()-1 ;
      int b=s.nextInt()-1 ;
      for(int da=Math.max(0,a-2); da<=Math.min(h-3,a); da++){
        for(int db=Math.max(0,b-2); db<=Math.min(w-3,b); db++){
          Point p=new Point(da,db);
          if(map.get(p)==null){
            map.put(p,1);
          }
          else {
            map.put(p,map.get(p)+1);
          }
        }
      }
    }
    long[] output=new long[10];
    output[0]=(long)(h-2)*(long)(w-2);
    for(int value : map.values()){
      output[0]--;
      output[value]++;
    }
    for(long value : output){
      System.out.println(value);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Point implements Comparable<Point> {
   attribute a : int;
   static operation newPoint( a : int, b : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
   operation hashCode() : int
  pre: true
  post: true
  activity: (     return MathLib.bitwiseXor(a,b) );
   operation equals( object : OclAny) : boolean
  pre: true
  post: true
  activity: (     var point : Point ; point := object->oclAsType(Point) ;
     return self.a = point.a & self.b = point.b );
   operation compareTo( p : Point) : int
  pre: true
  post: true
  activity: (     if (self.a /= p.a) then (     return self.a - p.a ) else skip ; 
     return self.b - p.b );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := s.getCurrent()->toInteger() ;
    var w : int ; w := s.getCurrent()->toInteger() ;
    var n : int ; n := s.getCurrent()->toInteger() ;
    var map : Map(Point,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := s.getCurrent()->toInteger() - 1 ;
     var b : int ; b := s.getCurrent()->toInteger() - 1 ;
         var da : int ; da := Set{0, a - 2}->max() ; while da <= Set{h - 3, a}->min() do ( (         var db : int ; db := Set{0, b - 2}->max() ; while db <= Set{w - 3, b}->min() do ( (     var p : Point ; p := Point.newPoint(da, db) ;
     if (map->at(p) = null) then (     map := map->union(Map{p |-> 1}) ) else (     map := map->union(Map{p |-> map->at(p) + 1}) ) )  ;     db := db + 1 ) )  ;     da := da + 1 ) )  ;     i := i + 1 ) ; 
    var output : Sequence(long) ; output := Integer.subrange(1,10)->collect(0) ;
    output[0+1] := (h - 2)->oclAsType(long) * (w - 2)->oclAsType(long) ; 
    for (value : map->values()) do ( (     output[0+1] := output[0+1] - 1 ; 
     output[value+1] := output[value+1] + 1 )  ) ; 
    for (value : output) do ( (     OclFile["System.out"].println(value) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long n=in.nextLong(),m=in.nextLong(),k=in.nextLong();
    HashMap<pointt,Long>map=new HashMap<pointt,Long>();
    for(int i=1 ; i<=k ; i++){
      int a=in.nextInt();
      int b=in.nextInt();
      for(int x=Math.max(1,a-2); x<=Math.min(n-2,a); x++)for(int y=Math.max(1,b-2); y<=Math.min(m-2,b); y++){
        pointt p=new pointt(x,y);
        Long v=map.get(p);
        if(v==null){
          v=(long)1 ;
        }
        else v++;
        map.put(p,v);
      }
    }
    long[] ans=new long[15];
    ans[0]=(n-2)*(m-2);
    for(long value : map.values()){
      ans[(int)value]++;
      ans[0]--;
    }
    for(int i=0 ; i<=9 ; i++){
      System.out.println(ans[i]);
    }
  }
}
class pointt {
  int x,y ;
  public pointt(int x,int y){
    super();
    this.x=x ;
    this.y=y ;
  }
  @ Override public int hashCode(){
    final int prime=31 ;
    int result=1 ;
    result=prime*result+x ;
    result=prime*result+y ;
    return result ;
  }
  @ Override public boolean equals(Object obj){
    if(this==obj)return true ;
    if(obj==null)return false ;
    if(getClass()!=obj.getClass())return false ;
    pointt other=(pointt)obj ;
    if(x!=other.x)return false ;
    if(y!=other.y)return false ;
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toLong() ;
    var m : long ; m := in.getCurrent()->toLong() ;
    var k : long ; k := in.getCurrent()->toLong() ;
    var map : Map(pointt,long) ; map := Map{} ;
        var i : int ; i := 1 ; while i <= k do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
         var x : int ; x := Set{1, a - 2}->max() ; while x <= Set{n - 2, a}->min() do (         var y : int ; y := Set{1, b - 2}->max() ; while y <= Set{m - 2, b}->min() do ( (     var p : pointt ; p := pointt.newpointt(x, y) ;
     var v : long ; v := map->at(p) ;
     if (v = null) then (     v := 1->oclAsType(long) ) else     v := v + 1 ; ;  
     map := map->union(Map{p |-> v}) )  ;     y := y + 1 ) ;  ;     x := x + 1 ) )  ;     i := i + 1 ) ; 
    var ans : Sequence(long) ; ans := Integer.subrange(1,15)->collect(0) ;
    ans[0+1] := (n - 2) * (m - 2) ; 
    for (value : map->values()) do ( (     ans[value->oclAsType(int)+1] := ans[value->oclAsType(int)+1] + 1 ; 
     ans[0+1] := ans[0+1] - 1 )  ) ; 
        var i : int ; i := 0 ; while i <= 9 do ( (     OclFile["System.out"].println(ans[i+1]) )  ;     i := i + 1 ) ; 
 );
}
class pointt {
   attribute x : int;
   static operation newpointt( x : int, y : int) : pointt
  pre: true
  post: true
  activity:
  ( var self : pointt ;
    self := createpointt();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     execute super() ; 
     self.x := x ; 
     self.y := y );
      operation hashCode() : int
  pre: true
  post: true
  activity: (     var prime : int ; prime := 31 ;
     var result : int ; result := 1 ;
    result := prime * result + x ; 
    result := prime * result + y ; 
    return result 
 );
      operation equals( obj : OclAny) : boolean
  pre: true
  post: true
  activity: (     if (self = obj) then     return true else skip ; 
     if (obj = null) then     return false else skip ; 
    if (getClass() /= obj->oclType()) then     return false else skip ; 
    var other : pointt ; other := obj->oclAsType(pointt) ;
    if (x /= other.x) then     return false else skip ; 
    if (y /= other.y) then     return false else skip ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class GFG {
  static int minJumps(int arr[],int l,int h){
    if(h==l)return 0 ;
    if(arr[l]==0)return Integer.MAX_VALUE ;
    int min=Integer.MAX_VALUE ;
    for(int i=l+1 ; i<=h && i<=l+arr[l]; i++){
      int jumps=minJumps(arr,i,h);
      if(jumps!=Integer.MAX_VALUE && jumps+1<min)min=jumps+1 ;
    }
    return min ;
  }
  public static void main(String args[]){
    int arr[]={
      1,3,6,3,2,3,6,8,9,5 };
      int n=arr.length ;
      System.out.print("Minimum number of jumps to reach end is "+minJumps(arr,0,n-1));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minJumps( arr : Sequence(int), l : int, h : int) : int
  pre: true
  post: true
  activity: (     if (h = l) then     return 0 else skip ; 
     if (arr[l+1] = 0) then     return 2147483647 else skip ; 
    var min : int ; min := 2147483647 ;
        var i : int ; i := l + 1 ; while i <= h & i <= l + arr[l+1] do ( (     var jumps : int ; jumps := minJumps(arr, i, h) ;
     if (jumps /= 2147483647 & jumps + 1 < min) then     min := jumps + 1 ; else skip )  ;     i := i + 1 ) ; 
    return min 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,6,3,2,3,6,8,9,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print("Minimum number of jumps to reach end is " + minJumps(arr, 0, n - 1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class codeforce {
  public static void main(String[] args){
    Scanner css=new Scanner(System.in);
    int t=css.nextInt();
    while(t-->0){
      int n=css.nextInt();
      int arr[]=new int[n];
      int ans=0 ;
      for(int i=0 ; i<n ; i++){
        arr[i]=css.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        ans+=(i+1)*(n-i);
        if(arr[i]==0){
          ans+=(i+1)*(n-i);
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforce {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var css : OclFile ; css := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := css.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := css.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := css.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     ans := ans+((i + 1) * (n - i)) ; 
     if (arr[i+1] = 0) then (     ans := ans+((i + 1) * (n - i)) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int[] arr=new int[n];
      int ans=(n*(n+1)*(n+2))/6 ;
      for(int i=0 ; i<n ; i++){
        int x=in.nextInt();
        if(x==0){
          ans+=(i+1)*(n-i);
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var ans : int ; ans := (n * (n + 1) * (n + 2)) / 6 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     if (x = 0) then (     ans := ans+((i + 1) * (n - i)) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double PI=3.14 ;
  static double areaOfInscribedCircle(float a){
    return(PI/4)*a*a ;
  }
  public static void main(String[] args){
    float a=8 ;
    System.out.println("Area of an inscribed"+" circle: "+areaOfInscribedCircle(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute PI : double := 3.14;
  static   operation areaOfInscribedCircle( a : double) : double
  pre: true
  post: true
  activity: (     return (PI / 4) * a * a );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 8 ;
     OclFile["System.out"].println("Area of an inscribed" + " circle: " + areaOfInscribedCircle(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static OutputStream outputStream=System.out ;
  static PrintWriter out=new PrintWriter(outputStream);
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    String[] s ;
    PriorityQueue<Integer>pqmax=new PriorityQueue<Integer>();
    PriorityQueue<Integer>pqmin=new PriorityQueue<Integer>(new Comparator<Integer>(){
      public int compare(Integer x,Integer y){
        return y-x ;
      }
    }
);
    long sumMin=0,sumMax=0,sumb=0 ;
    int min=0 ;
    while(t-->0){
      s=br.readLine().split(" ");
      if(s[0] .charAt(0)=='2'){
        long ans=min ;
        ans*=pqmin.size();
        ans-=sumMin ;
        long ans1=min ;
        ans1*=pqmax.size();
        ans1=sumMax-ans1 ;
        out.println(min+" "+(ans+ans1+sumb));
      }
      else {
        int in=Integer.parseInt(s[1]);
        sumb+=Long.parseLong(s[2]);
        if(in>min){
          pqmax.add(in);
          sumMax+=in ;
        }
        else {
          pqmin.add(in);
          sumMin+=in ;
        }
        if(pqmin.size()>pqmax.size()){
          sumMax+=pqmin.peek();
          sumMin-=pqmin.peek();
          pqmax.add(pqmin.poll());
        }
        if(pqmin.size()<pqmax.size()){
          sumMax-=pqmax.peek();
          sumMin+=pqmax.peek();
          pqmin.add(pqmax.poll());
        }
        min=pqmin.peek();
      }
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute outputStream : OclFile := OclFile["System.out"];
  static   attribute out : OclFile := OclFile.newOclFile_Write(outputStream);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
    var s : Sequence(String) ;
    var pqmax : Sequence(int) ; pqmax := Sequence{} ;
    var pqmin : Sequence(int) ; pqmin := Sequence{}->union(OclComparator<int>.newOclComparator()) ;
    var sumMin : long ; sumMin := 0 ;
    var sumMax : long ; sumMax := 0 ;
    var sumb : long ; sumb := 0 ;
    var min : int ; min := 0 ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     s := br.readLine()->split(" ") ; 
     if (s[0+1]->at(0+1) = '2') then (     var ans : long ; ans := min ;
     ans := ans*(pqmin->size()) ; 
    ans := ans-(sumMin) ; 
    var ans1 : long ; ans1 := min ;
    ans1 := ans1*(pqmax->size()) ; 
    ans1 := sumMax - ans1 ; 
    skip ; 
 ) else (     var in : int ; in := (s[1+1])->toInteger() ;
     sumb := sumb+((s[2+1])->toLong()) ; 
    if (in > min) then (     pqmax := pqmax->including(in) ; 
     sumMax := sumMax+(in) ) else (     pqmin := pqmin->including(in) ; 
     sumMin := sumMin+(in) ) ;  
    if (pqmin->size() > pqmax->size()) then (     sumMax := sumMax+(pqmin->min()) ; 
     sumMin := sumMin-(pqmin->min()) ; 
     pqmax := pqmax->including(pqmin->min()) ) else skip ; 
    if (pqmin->size() < pqmax->size()) then (     sumMax := sumMax-(pqmax->min()) ; 
     sumMin := sumMin+(pqmax->min()) ; 
     pqmin := pqmin->including(pqmax->min()) ) else skip ; 
    min := pqmin->min() ; 
 ) ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void print(int n,int k){
    int rem=1 ;
    for(int i=0 ; i<k ; i++){
      System.out.print((10*rem)/n);
      rem=(10*rem)% n ;
    }
  }
  public static void main(String[] args){
    int n=7,k=3 ;
    print(n,k);
    System.out.println();
    n=21 ;
    k=4 ;
    print(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation print( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var rem : int ; rem := 1 ;
         var i : int ; i := 0 ; while i < k do ( (     OclFile["System.out"].print((10 * rem) / n) ; 
     rem := (10 * rem) mod n )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
    var k : int ; k := 3 ;
     execute print(n, k) ; 
    OclFile["System.out"].println() ; 
    n := 21 ; 
    k := 4 ; 
    execute print(n, k) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    int w=in.nextInt();
    int a=in.nextInt();
    int b=in.nextInt();
    int answer=0 ;
    if(a<b){
      if(a+w<b){
        answer=b-a-w ;
      }
    }
    else if(b<a){
      if(b+w<a){
        answer=a-b-w ;
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var answer : int ; answer := 0 ;
    if (a < b) then (     if (a + w < b) then (     answer := b - a - w ) else skip ) else     if (b < a) then (     if (b + w < a) then (     answer := a - b - w ) else skip ) else skip ; ;  
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int[] dp=new int[n+1];
      int[] c=new int[m];
      for(int i=0 ; i<m ; i++){
        c[i]=sc.nextInt();
      }
      for(int i=0 ; i<n+1 ; i++){
        dp[i]=Integer.MAX_VALUE ;
      }
      dp[0]=0 ;
      for(int i=0 ; i<=n ; i++){
        for(int j=0 ; j<m ; j++){
          if(c[j]<=i){
            dp[i]=Math.min(dp[i],dp[i-c[j] ]+1);
          }
        }
      }
      System.out.println(dp[n]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     c[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n + 1 do ( (     dp[i+1] := 2147483647 )  ;     i := i + 1 ) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i <= n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (c[j+1] <= i) then (     dp[i+1] := Set{dp[i+1], dp[i - c[j+1]+1] + 1}->min() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[n+1]) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Arrays ;
import java.util.StringTokenizer ;
class Main {
  static final PrintWriter out=new PrintWriter(System.out);
  static final int INF=Integer.MAX_VALUE/2 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=Integer.parseInt(line.split(" ")[0]);
      int m=Integer.parseInt(line.split(" ")[1]);
      int[] v=new int[m];
      StringTokenizer st=new StringTokenizer(br.readLine());
      for(int i=0 ; i<m ; i++)v[i]=Integer.parseInt(st.nextToken());
      int[][] dp=new int[m+1][n+1];
      Arrays.fill(dp[m],INF);
      dp[m][0]=0 ;
      for(int j=m-1 ; j>=0 ; j--){
        for(int i=0 ; i<=n ; i++){
          if(i<v[j])dp[j][i]=dp[j+1][i];
          else dp[j][i]=Math.min(dp[j+1][i],dp[j][i-v[j] ]+1);
        }
      }
      out.println(dp[0][n]);
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static    attribute INF : int := 2147483647 / 2;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := (line->split(" ")[0+1])->toInteger() ;
     var m : int ; m := (line->split(" ")[1+1])->toInteger() ;
    var v : Sequence(int) ; v := Integer.subrange(1,m)->collect(0) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < m do (     v[i+1] := (st.next())->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
    dp[m+1] := dp[m+1]->collect(INF) ; 
    dp[m+1][0+1] := 0 ; 
        var j : int ; j := m - 1 ; while j >= 0 do ( (         var i : int ; i := 0 ; while i <= n do ( (     if (i < v[j+1]) then     dp[j+1][i+1] := dp[j + 1+1][i+1] ; else     dp[j+1][i+1] := Set{dp[j + 1+1][i+1], dp[j+1][i - v[j+1]+1] + 1}->min() ; )  ;     i := i + 1 ) )  ;     j := j - 1 ) ; 
    skip ; 
 ) ;     line := br.readLine() ;
 ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int[] c ;
  static int n,m ;
  static final int MAX=50000 ;
  static final int INF=(1<<21);
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    n=scan.nextInt();
    m=scan.nextInt();
    c=new int[m+1];
    for(int i=0 ; i<m ; i++){
      c[i+1]=scan.nextInt();
    }
    scan.close();
    solve();
  }
  static void solve(){
    int[] T=new int[n+1];
    for(int i=0 ; i<=n ; i++){
      T[i]=INF ;
    }
    T[0]=0 ;
    for(int i=1 ; i<=m ; i++){
      for(int j=0 ; j+c[i]<=n ; j++){
        T[j+c[i] ]=Math.min(T[j+c[i] ],T[j]+1);
      }
    }
    System.out.println(T[n]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute c : Sequence(int);
  static   attribute n : int;
  static    attribute MAX : int := 50000;
  static    attribute INF : int := ((1*(2->pow(21)))->oclAsType(long));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := scan.getCurrent()->toInteger() ; 
    m := scan.getCurrent()->toInteger() ; 
    c := Integer.subrange(1,m + 1)->collect(0) ; 
        var i : int ; i := 0 ; while i < m do ( (     c[i + 1+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    execute solve() ; 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var T : Sequence(int) ; T := Integer.subrange(1,n + 1)->collect(0) ;
         var i : int ; i := 0 ; while i <= n do ( (     T[i+1] := INF )  ;     i := i + 1 ) ; 
    T[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= m do ( (         var j : int ; j := 0 ; while j + c[i+1] <= n do ( (     T[j + c[i+1]+1] := Set{T[j + c[i+1]+1], T[j+1] + 1}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(T[n+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,m,i,j ;
    int[] c,dp ;
    n=sc.nextInt();
    m=sc.nextInt();
    dp=new int[n+1];
    c=new int[m];
    for(i=0 ; i<m ; i++)c[i]=sc.nextInt();
    for(i=0 ; i<n+1 ; i++)dp[i]=n*2 ;
    dp[0]=0 ;
    for(i=0 ; i<n+1 ; i++)if(dp[i]!=n*2)for(j=0 ; j<m ; j++)if(i+c[j]<=n && dp[i]+1<dp[i+c[j] ])dp[i+c[j] ]=dp[i]+1 ;
    out.println(dp[n]);
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var m : int ;
    var i : int ;
    var j : int ;
    var c : Sequence(int) ;
    var dp : Sequence(int) ;
    n := sc.nextInt() ; 
    m := sc.nextInt() ; 
    dp := Integer.subrange(1,n + 1)->collect(0) ; 
    c := Integer.subrange(1,m)->collect(0) ; 
        i := 0 ; while i < m do (     c[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n + 1 do (     dp[i+1] := n * 2 ;  ;     i := i + 1 ) ; 
    dp[0+1] := 0 ; 
        i := 0 ; while i < n + 1 do (     if (dp[i+1] /= n * 2) then         j := 0 ; while j < m do (     if (i + c[j+1] <= n & dp[i+1] + 1 < dp[i + c[j+1]+1]) then     dp[i + c[j+1]+1] := dp[i+1] + 1 ; else skip ;  ;     j := j + 1 ) ; else skip ;  ;     i := i + 1 ) ; 
    out.println(dp[n+1]) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import static java.lang.Math.*;
import java.io.PrintWriter ;
class Main {
  static Scanner sc=new Scanner(System.in);
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    while(sc.hasNext()){
      int n=sc.nextInt(),m=sc.nextInt();
      int[] money=new int[m];
      int[] dp=new int[n+1];
      for(int i=0 ; i<m ; i++){
        money[i]=sc.nextInt();
      }
      for(int i=0 ; i<n+1 ; i++){
        dp[i]=100000 ;
      }
      dp[0]=0 ;
      for(int i=0 ; i<m ; i++){
        for(int j=money[i]; j<n+1 ; j++){
          dp[j]=Math.min(dp[j],dp[j-money[i] ]+1);
        }
      }
      System.out.println(dp[n]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
     var money : Sequence(int) ; money := Integer.subrange(1,m)->collect(0) ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     money[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n + 1 do ( (     dp[i+1] := 100000 )  ;     i := i + 1 ) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := money[i+1] ; while j < n + 1 do ( (     dp[j+1] := Set{dp[j+1], dp[j - money[i+1]+1] + 1}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[n+1]) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double getProbability(double p,double q){
    p/=100 ;
    q/=100 ;
    double probability=(p*p+q*q)/(p+q);
    return probability ;
  }
  public static void main(String[] args){
    double p,q ;
    p=80 ;
    q=40 ;
    System.out.println(getProbability(p,q));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getProbability( p : double, q : double) : double
  pre: true
  post: true
  activity: (     p := p/(100) ; 
     q := q/(100) ; 
     var probability : double ; probability := (p * p + q * q) / (p + q) ;
     return probability );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : double ;
    var q : double ;
     p := 80 ; 
     q := 40 ; 
     OclFile["System.out"].println(getProbability(p, q)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int mod=998244353 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int k=sc.nextInt();
    long[] a=new long[n+1];
    a[1]=m ;
    for(int i=2 ; i<=n ; i++){
      a[i]=(a[i-1]*(m-1))% mod ;
    }
    Combination com=new Combination(n-1,mod);
    long ans=0 ;
    for(int i=n-k ; i<=n ; i++){
      int tk=n-i ;
      long tmp=(a[i]*com.comb(n-1,tk))% mod ;
      ans=(ans+tmp)% mod ;
    }
    System.out.println(ans);
    sc.close();
  }
}
class Combination {
  private long fac[];
  private long inv[];
  private int mod ;
  public Combination(int size,int mod){
    this.fac=new long[size+1];
    this.inv=new long[size+1];
    this.mod=mod ;
    this.fac[0]=1 ;
    this.inv[0]=1 ;
    for(int i=1 ; i<=size ; i++){
      fac[i]=(fac[i-1]*i)% mod ;
      inv[i]=modPow(fac[i],(int)mod-2)% mod ;
    }
  }
  public long comb(int n,int r){
    return fac[n]*inv[r] % mod*inv[n-r] % mod ;
  }
  private long modPow(long base,int exp){
    long ret=1 ;
    while(exp>0){
      if((exp & 1)==1){
        ret=ret*base % mod ;
      }
      base=base*base % mod ;
      exp>>=1 ;
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := 998244353;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    a[1+1] := m ; 
        var i : int ; i := 2 ; while i <= n do ( (     a[i+1] := (a[i - 1+1] * (m - 1)) mod mod )  ;     i := i + 1 ) ; 
    var com : Combination ; com := Combination.newCombination(n - 1, mod) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := n - k ; while i <= n do ( (     var tk : int ; tk := n - i ;
     var tmp : long ; tmp := (a[i+1] * com.comb(n - 1, tk)) mod mod ;
     ans := (ans + tmp) mod mod )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}
class Combination {
   attribute fac : Sequence(long);
   attribute inv : Sequence(long);
   attribute mod : int;
   static operation newCombination( size : int, mod : int) : Combination
  pre: true
  post: true
  activity:
  ( var self : Combination ;
    self := createCombination();
    self.initialise(size, mod);
    return self );
  operation initialise( size : int, mod : int) : void
  pre: true  post: true
  activity: (     self.fac := Integer.subrange(1,size + 1)->collect(0) ; 
     self.inv := Integer.subrange(1,size + 1)->collect(0) ; 
    self.mod := mod ; 
    self.fac[0+1] := 1 ; 
    self.inv[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= size do ( (     fac[i+1] := (fac[i - 1+1] * i) mod mod ; 
     inv[i+1] := modPow(fac[i+1], mod->oclAsType(int) - 2) mod mod )  ;     i := i + 1 ) ; 
 );
   operation comb( n : int, r : int) : long
  pre: true
  post: true
  activity: (     return fac[n+1] * inv[r+1] mod mod * inv[n - r+1] mod mod );
   operation modPow( base : long, exp : int) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := 1 ;
     while (exp > 0) do (     if ((exp & 1) = 1) then (     ret := ret * base mod mod ) else skip ; 
     base := base * base mod mod ; 
     exp := exp/(2->pow(1)) ) ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int mod=998244353 ;
  static int max=4*100000+2 ;
  static long[] fact=new long[max];
  static long[] modinv=new long[max];
  static long[] factinv=new long[max];
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=Integer.parseInt(scan.next());
    int m=Integer.parseInt(scan.next());
    int k=Integer.parseInt(scan.next());
    scan.close();
    initCombi();
    long ans=0 ;
    for(int i=0 ; i<=k ; i++){
      ans+=(m*combi(n-1,i)% mod)*modPow(m-1,n-1-i)% mod ;
      ans %=mod ;
    }
    System.out.println(ans);
  }
  private static void initCombi(){
    fact[0]=1 ;
    fact[1]=1 ;
    modinv[1]=1 ;
    factinv[0]=1 ;
    factinv[1]=1 ;
    for(int i=2 ; i<max ; i++){
      fact[i]=fact[i-1]*i % mod ;
      modinv[i]=mod-modinv[mod % i]*(mod/i)% mod ;
      factinv[i]=factinv[i-1]*modinv[i] % mod ;
    }
  }
  private static long combi(int n,int k){
    return fact[n]*(factinv[k]*factinv[n-k] % mod)% mod ;
  }
  private static long modPow(long a,long b){
    if(b==0){
      return 1 ;
    }
    if(b % 2==0){
      return modPow(a*a % mod,b/2);
    }
    else {
      return modPow(a*a % mod,(b-1)/2)*a % mod ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := 998244353;
  static   attribute max : int := 4 * 100000 + 2;
  static   attribute fact : Sequence(long) := Integer.subrange(1,max)->collect(0);
  static   attribute modinv : Sequence(long) := Integer.subrange(1,max)->collect(0);
  static   attribute factinv : Sequence(long) := Integer.subrange(1,max)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (scan.getCurrent())->toInteger() ;
    var m : int ; m := (scan.getCurrent())->toInteger() ;
    var k : int ; k := (scan.getCurrent())->toInteger() ;
    skip ; 
    execute initCombi() ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i <= k do ( (     ans := ans+((m * combi(n - 1, i) mod mod) * modPow(m - 1, n - 1 - i) mod mod) ; 
     ans := ans mod mod )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation initCombi() : void
  pre: true
  post: true
  activity: (     fact[0+1] := 1 ; 
     fact[1+1] := 1 ; 
    modinv[1+1] := 1 ; 
    factinv[0+1] := 1 ; 
    factinv[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < max do ( (     fact[i+1] := fact[i - 1+1] * i mod mod ; 
     modinv[i+1] := mod - modinv[mod mod i+1] * (mod / i) mod mod ; 
     factinv[i+1] := factinv[i - 1+1] * modinv[i+1] mod mod )  ;     i := i + 1 ) ; 
 );
  static   operation combi( n : int, k : int) : long
  pre: true
  post: true
  activity: (     return fact[n+1] * (factinv[k+1] * factinv[n - k+1] mod mod) mod mod );
  static   operation modPow( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return 1 ) else skip ; 
     if (b mod 2 = 0) then (     return modPow(a * a mod mod, b / 2) ) else (     return modPow(a * a mod mod, (b - 1) / 2) * a mod mod ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    new Main().execute();
  }
  public void execute(){
    Scanner sc=new Scanner(System.in);
    final int D=sc.nextInt();
    final int G=sc.nextInt()/100 ;
    int[] score=new int[D];
    int[] p=new int[D];
    int[] c=new int[D];
    for(int i=0 ; i<D ; i++){
      score[i]=i+1 ;
      p[i]=sc.nextInt();
      c[i]=sc.nextInt()/100 ;
    }
    int minTurns=Integer.MAX_VALUE ;
    for(int mask=0,bound=(1<<D); mask<bound ; mask++){
      int s=0 ;
      int turns=0 ;
      boolean[] ptn=getPatterns(D,mask);
      for(int i=0 ; i<D ; i++){
        if(ptn[i]){
          s+=p[i]*score[i]+c[i];
          turns+=p[i];
        }
      }
      if(s>=G){
        minTurns=Math.min(minTurns,turns);
        continue ;
      }
      for(int i=(D-1); i>=0 ; i--){
        if(ptn[i]){
          continue ;
        }
        for(int j=0 ; j<p[i]-1 ; j++){
          s+=score[i];
          turns++;
          if(s>=G){
            minTurns=Math.min(minTurns,turns);
            break ;
          }
        }
      }
    }
    System.out.println(minTurns);
    sc.close();
  }
  private boolean[] getPatterns(int d,int mask){
    boolean[] patterns=new boolean[d];
    for(int i=0 ; i<d ; i++){
      if((mask &(1<<i))>0){
        patterns[i]=true ;
      }
    }
    return patterns ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().execute() );
   operation execute() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var D : int ; D := sc.getCurrent()->toInteger() ;
    var G : int ; G := sc.getCurrent()->toInteger() / 100 ;
    var score : Sequence(int) ; score := Integer.subrange(1,D)->collect(0) ;
    var p : Sequence(int) ; p := Integer.subrange(1,D)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,D)->collect(0) ;
        var i : int ; i := 0 ; while i < D do ( (     score[i+1] := i + 1 ; 
     p[i+1] := sc.getCurrent()->toInteger() ; 
     c[i+1] := sc.getCurrent()->toInteger() / 100 )  ;     i := i + 1 ) ; 
    var minTurns : int ; minTurns := 2147483647 ;
        var mask : int ; mask := 0 ;
    var bound : int ; bound := ((1*(2->pow(D)))->oclAsType(long)) ; while mask < bound do ( (     var s : int ; s := 0 ;
     var turns : int ; turns := 0 ;
    var ptn : Sequence(boolean) ; ptn := getPatterns(D, mask) ;
        var i : int ; i := 0 ; while i < D do ( (     if (ptn[i+1]) then (     s := s+(p[i+1] * score[i+1] + c[i+1]) ; 
     turns := turns+(p[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    if (s >= G) then (     minTurns := Set{minTurns, turns}->min() ; 
     continue ) else skip ; 
        var i : int ; i := (D - 1) ; while i >= 0 do ( (     if (ptn[i+1]) then (     continue ) else skip ; 
         var j : int ; j := 0 ; while j < p[i+1] - 1 do ( (     s := s+(score[i+1]) ; 
     turns := turns + 1 ; 
     if (s >= G) then (     minTurns := Set{minTurns, turns}->min() ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
 )  ;     mask := mask + 1 ) ; 
    OclFile["System.out"].println(minTurns) ; 
    skip ; 
 );
   operation getPatterns( d : int, mask : int) : Sequence(boolean)
  pre: true
  post: true
  activity: (     var patterns : Sequence(boolean) ; patterns := Integer.subrange(1,d)->collect(false) ;
         var i : int ; i := 0 ; while i < d do ( (     if ((MathLib.bitwiseAnd(mask,((1*(2->pow(i)))->oclAsType(long)))) > 0) then (     patterns[i+1] := true ) else skip )  ;     i := i + 1 ) ; 
     return patterns );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int MOD=998244353 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int k=sc.nextInt();
    Combination cmb=new Combination(n+1);
    long ans=0 ;
    for(int i=0 ; i<=k ; i++){
      ans+=m*pow(m-1,n-i-1)% MOD*cmb.getComb(n-1,i)% MOD ;
      ans %=MOD ;
    }
    System.out.println(ans);
  }
  static long pow(long base,int p){
    if(p==0){
      return 1 ;
    }
    else if(p % 2==0){
      return pow(base*base % MOD,p/2);
    }
    else {
      return pow(base,p-1)*base % MOD ;
    }
  }
}
class Combination {
  static final int MOD=998244353 ;
  long[] fac ;
  long[] finv ;
  long[] inv ;
  public Combination(int size){
    fac=new long[size];
    finv=new long[size];
    inv=new long[size];
    fac[0]=1 ;
    fac[1]=1 ;
    finv[0]=1 ;
    finv[1]=1 ;
    inv[1]=1 ;
    for(int i=2 ; i<size ; i++){
      fac[i]=fac[i-1]*i % MOD ;
      inv[i]=MOD-inv[MOD % i]*(MOD/i)% MOD ;
      finv[i]=finv[i-1]*inv[i] % MOD ;
    }
  }
  public long getComb(int n,int k){
    if(n<k || n<0 || k<0){
      return 0 ;
    }
    return fac[n]*(finv[k]*finv[n-k] % MOD)% MOD ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 998244353;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var cmb : Combination ; cmb := Combination.newCombination(n + 1) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i <= k do ( (     ans := ans+(m * pow(m - 1, n - i - 1) mod MOD * cmb.getComb(n - 1, i) mod MOD) ; 
     ans := ans mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation pow( base : long, p : int) : long
  pre: true
  post: true
  activity: (     if (p = 0) then (     return 1 ) else     if (p mod 2 = 0) then (     return pow(base * base mod MOD, p / 2) ) else (     return pow(base, p - 1) * base mod MOD ) ;  );
}
class Combination {
  static    attribute MOD : int := 998244353;
   attribute fac : Sequence(long);
   attribute finv : Sequence(long);
   attribute inv : Sequence(long);
   static operation newCombination( size : int) : Combination
  pre: true
  post: true
  activity:
  ( var self : Combination ;
    self := createCombination();
    self.initialise(size);
    return self );
  operation initialise( size : int) : void
  pre: true  post: true
  activity: (     fac := Integer.subrange(1,size)->collect(0) ; 
     finv := Integer.subrange(1,size)->collect(0) ; 
    inv := Integer.subrange(1,size)->collect(0) ; 
    fac[0+1] := 1 ; 
    fac[1+1] := 1 ; 
    finv[0+1] := 1 ; 
    finv[1+1] := 1 ; 
    inv[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < size do ( (     fac[i+1] := fac[i - 1+1] * i mod MOD ; 
     inv[i+1] := MOD - inv[MOD mod i+1] * (MOD / i) mod MOD ; 
     finv[i+1] := finv[i - 1+1] * inv[i+1] mod MOD )  ;     i := i + 1 ) ; 
 );
   operation getComb( n : int, k : int) : long
  pre: true
  post: true
  activity: (     if (n < k or n < 0 or k < 0) then (     return 0 ) else skip ; 
     return fac[n+1] * (finv[k+1] * finv[n - k+1] mod MOD) mod MOD );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    Scanner sc=new Scanner(System.in);
    int w=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int x=0 ;
    if(b<=(a+w)&& b>=a){
    }
    else if(a+w<b){
      x=b-(a+w);
    }
    else if(b+w<a){
      x=(b+w)-a ;
    }
    System.out.println(Math.abs(x));
    bw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var x : int ; x := 0 ;
    if (b <= (a + w) & b >= a) then skip else     if (a + w < b) then (     x := b - (a + w) ) else     if (b + w < a) then (     x := (b + w) - a ) else skip ; ;  ;  
    OclFile["System.out"].println(if x < 0 then -(x) else x endif) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAX=1000 ;
  static int max_prime[]=new int[MAX];
  static int min_prime[]=new int[MAX];
  static void sieve(int n){
    for(int i=2 ; i<n ; ++i){
      if(min_prime[i]>0){
        continue ;
      }
      min_prime[i]=i ;
      max_prime[i]=i ;
      int j=i+i ;
      while(j<n){
        if(min_prime[j]==0){
          min_prime[j]=i ;
        }
        max_prime[j]=i ;
        j+=i ;
      }
    }
  }
  static int findCost(int A,int B,int C,int X){
    sieve(MAX);
    int N,M ;
    if(X==1){
      return-1 ;
    }
    int min_cost=C+X ;
    int cost_for_prime=A ;
    N=max_prime[X];
    if(N!=X){
      M=X/N ;
      cost_for_prime+=M ;
      min_cost=Math.min(min_cost,cost_for_prime);
    }
    M=min_prime[X];
    N=X/M ;
    if(N!=min_prime[N]){
      int cost_for_comp=B+M ;
      min_cost=Math.min(min_cost,cost_for_comp);
    }
    return min_cost ;
  }
  public static void main(String[] args){
    int A=7,B=11,C=2,X=20 ;
    System.out.println(findCost(A,B,C,X));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 1000;
  static   attribute max_prime : int := Integer.subrange(1,MAX)->collect(0);
  static   attribute min_prime : int := Integer.subrange(1,MAX)->collect(0);
  static   operation sieve( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i < n do ( (     if (min_prime[i+1] > 0) then (     continue ) else skip ; 
     min_prime[i+1] := i ; 
    max_prime[i+1] := i ; 
    var j : int ; j := i + i ;
    while (j < n) do (     if (min_prime[j+1] = 0) then (     min_prime[j+1] := i ) else skip ; 
     max_prime[j+1] := i ; 
     j := j+(i) ) ; 
 )  ;     i := i + 1 ) );
  static   operation findCost( A : int, B : int, C : int, X : int) : int
  pre: true
  post: true
  activity: (     execute sieve(MAX) ; 
     var N : int ;
    var M : int ;
    if (X = 1) then (     return -1 ) else skip ; 
    var min_cost : int ; min_cost := C + X ;
    var cost_for_prime : int ; cost_for_prime := A ;
    N := max_prime[X+1] ; 
    if (N /= X) then (     M := X / N ; 
     cost_for_prime := cost_for_prime+(M) ; 
     min_cost := Set{min_cost, cost_for_prime}->min() ) else skip ; 
    M := min_prime[X+1] ; 
    N := X / M ; 
    if (N /= min_prime[N+1]) then (     var cost_for_comp : int ; cost_for_comp := B + M ;
     min_cost := Set{min_cost, cost_for_comp}->min() ) else skip ; 
    return min_cost 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 7 ;
    var B : int ; B := 11 ;
    var C : int ; C := 2 ;
    var X : int ; X := 20 ;
     OclFile["System.out"].println(findCost(A, B, C, X)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.*;
public class App {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  static int[] f=new int[100001];
  static {
    f[1]=1 ;
    for(int i=2 ; i<f.length ; ++i){
      f[i]=(int)(((i<<1)-1L)*f[i-1] % 1000000007*(i<<1)% 1000000007);
    }
  }
  public static void main(String[] args)throws Exception {
    if(System.getProperty("ONLINE_JUDGE")==null){
      File inputFile=new File("/Users/vipinjain/self/cp/input.txt");
      File outputFile=new File("/Users/vipinjain/self/cp/output.txt");
      br=new BufferedReader(new FileReader(inputFile));
      bw=new BufferedWriter(new FileWriter(outputFile));
    }
    int tests ;
    tests=1 ;
    while(tests-->0){
      solve();
    }
    bw.flush();
    bw.close();
    br.close();
  }
  static boolean isVowel(char c){
    c=Character.toLowerCase(c);
    return c=='a' || c=='e' || c=='i' || c=='o' || c=='u' || c=='y' ;
  }
  static void solve()throws Exception {
    String[] tmp=br.readLine().split(" ");
    int d=Integer.parseInt(tmp[0]);
    int l=Integer.parseInt(tmp[1]);
    int v1=Integer.parseInt(tmp[2]);
    int v2=Integer.parseInt(tmp[3]);
    double time=(l-d)/(double)(v1+v2);
    bw.write(time+"");
    bw.write("\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute f : Sequence(int) := Integer.subrange(1,100001)->collect(0);
  static operation initialiseClass()
  pre: true post: true
  activity:     f[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < f->size() do ( (     f[i+1] := ((((i*(2->pow(1)))->oclAsType(long)) - 1L) * f[i - 1+1] mod 1000000007 * ((i*(2->pow(1)))->oclAsType(long)) mod 1000000007)->oclAsType(int) )  ;     i := i + 1 ) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null) then (     var inputFile : OclFile ; inputFile := OclFile("/Users/vipinjain/self/cp/input.txt") ;
     var outputFile : OclFile ; outputFile := OclFile("/Users/vipinjain/self/cp/output.txt") ;
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputFile)) ; 
     bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputFile)) ) else skip ; 
     var tests : int ;
    tests := 1 ; 
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation isVowel( c : String) : boolean
  pre: true
  post: true
  activity: (     c := (c + "")->toLowerCase() ; 
     return c = 'a' or c = 'e' or c = 'i' or c = 'o' or c = 'u' or c = 'y' );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var tmp : Sequence(String) ; tmp := br.readLine()->split(" ") ;
     var d : int ; d := (tmp[0+1])->toInteger() ;
    var l : int ; l := (tmp[1+1])->toInteger() ;
    var v1 : int ; v1 := (tmp[2+1])->toInteger() ;
    var v2 : int ; v2 := (tmp[3+1])->toInteger() ;
    var time : double ; time := (l - d) / (v1 + v2)->oclAsType(double) ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class UTC_Begginer {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int d=sc.nextInt();
    int L=sc.nextInt();
    int v1=sc.nextInt();
    int v2=sc.nextInt();
    double x=((((double)(v1))/((double)(v1+v2))))*((double)(L-d));
    double t=x/((double)v1);
    System.out.println(t);
  }
}
------------------------------------------------------------
OCL File:
---------
 class UTC_Begginer {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
    var L : int ; L := sc.getCurrent()->toInteger() ;
    var v1 : int ; v1 := sc.getCurrent()->toInteger() ;
    var v2 : int ; v2 := sc.getCurrent()->toInteger() ;
    var x : double ; x := ((((v1)->oclAsType(double)) / ((v1 + v2)->oclAsType(double)))) * ((L - d)->oclAsType(double)) ;
    var t : double ; t := x / (v1->oclAsType(double)) ;
    OclFile["System.out"].println(t) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SaveLuke {
  public static void main(String[] args){
    Scanner sn=new Scanner(System.in);
    int d=sn.nextInt();
    int t=sn.nextInt();
    int a=sn.nextInt();
    int b=sn.nextInt();
    int c=a+b ;
    System.out.println((t-d)/(c*1.0));
  }
}
------------------------------------------------------------
OCL File:
---------
 class SaveLuke {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sn : OclFile ; sn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : int ; d := sn.getCurrent()->toInteger() ;
    var t : int ; t := sn.getCurrent()->toInteger() ;
    var a : int ; a := sn.getCurrent()->toInteger() ;
    var b : int ; b := sn.getCurrent()->toInteger() ;
    var c : int ; c := a + b ;
    OclFile["System.out"].println((t - d) / (c * 1.0)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      double d=sc.nextInt();
      double L=sc.nextInt();
      double v1=sc.nextInt();
      double v2=sc.nextInt();
      double ans=(L-d)/(v1+v2);
      System.out.println(ans);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : double ; d := sc.getCurrent()->toInteger() ;
    var L : double ; L := sc.getCurrent()->toInteger() ;
    var v1 : double ; v1 := sc.getCurrent()->toInteger() ;
    var v2 : double ; v2 := sc.getCurrent()->toInteger() ;
    var ans : double ; ans := (L - d) / (v1 + v2) ;
    OclFile["System.out"].println(ans) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void solve(int n,int k){
    int mini=0 ;
    int x1=1 ;
    int[] a=new int[k];
    for(int i=1 ; i<=k ; i++){
      mini+=x1 ;
      a[i-1]=x1 ;
      x1+=1 ;
    }
    if(n<mini){
      System.out.print("-1");
      return ;
    }
    int rem=n-mini ;
    int cnt=rem/k ;
    rem=rem % k ;
    for(int i=0 ; i<k ; i++)a[i]+=cnt ;
    for(int i=k-1 ; i>0 && rem>0 ; i--){
      int xx=a[i-1]*2 ;
      int left=xx-a[i];
      if(rem>=left){
        a[i]=xx ;
        rem-=left ;
      }
      else {
        a[i]+=rem ;
        rem=0 ;
      }
    }
    int sum=a[0];
    for(int i=1 ; i<k ; i++){
      if(a[i]>2*a[i-1]){
        System.out.print("-1");
        return ;
      }
      sum+=a[i];
    }
    if(sum!=n){
      System.out.print("-1");
      return ;
    }
    for(int i=0 ; i<k ; i++)System.out.print(a[i]+" ");
  }
  public static void main(String[] args){
    int n=26,k=6 ;
    solve(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var mini : int ; mini := 0 ;
     var x1 : int ; x1 := 1 ;
    var a : Sequence(int) ; a := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 1 ; while i <= k do ( (     mini := mini+(x1) ; 
     a[i - 1+1] := x1 ; 
     x1 := x1+(1) )  ;     i := i + 1 ) ; 
    if (n < mini) then (     OclFile["System.out"].print("-1") ; 
     return ) else skip ; 
    var rem : int ; rem := n - mini ;
    var cnt : int ; cnt := rem / k ;
    rem := rem mod k ; 
        var i : int ; i := 0 ; while i < k do (     a[i+1] := a[i+1]+(cnt) ;  ;     i := i + 1 ) ; 
        var i : int ; i := k - 1 ; while i > 0 & rem > 0 do ( (     var xx : int ; xx := a[i - 1+1] * 2 ;
     var left : int ; left := xx - a[i+1] ;
     if (rem >= left) then (     a[i+1] := xx ; 
     rem := rem-(left) ) else (     a[i+1] := a[i+1]+(rem) ; 
     rem := 0 ) )  ;     i := i - 1 ) ; 
    var sum : int ; sum := a[0+1] ;
        var i : int ; i := 1 ; while i < k do ( (     if (a[i+1] > 2 * a[i - 1+1]) then (     OclFile["System.out"].print("-1") ; 
     return ) else skip ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    if (sum /= n) then (     OclFile["System.out"].print("-1") ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < k do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 26 ;
    var k : int ; k := 6 ;
     execute solve(n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.TreeSet ;
public final class Main {
  private static final Scanner sc=new Scanner(System.in);
  static PrintWriter writer=new PrintWriter(System.out);
  public static void main(String[] args){
    int Q=sc.nextInt();
    TreeSet<Long>set=new TreeSet<>();
    sc.next();
    long minima=sc.nextLong()<<32 ;
    set.add(minima);
    long upperSum=0 ;
    long lowerSum=0 ;
    long sumB=sc.nextInt();
    for(int i=1 ; i<Q ; i++){
      int type=sc.nextInt();
      if(type==1){
        long a=(sc.nextLong()<<32)+i ;
        sumB+=sc.nextInt();
        set.add(a);
        if(a<minima){
          lowerSum+=a>>32 ;
          if(set.size()% 2==0){
            upperSum+=minima>>32 ;
            minima=set.lower(minima);
            lowerSum-=minima>>32 ;
          }
        }
        else {
          upperSum+=a>>32 ;
          if(set.size()% 2!=0){
            lowerSum+=minima>>32 ;
            minima=set.higher(minima);
            upperSum-=minima>>32 ;
          }
        }
      }
      else {
        int countU=set.size()/2 ;
        int countL=(set.size()-1)-countU ;
        long ans=minima>>32 ;
        long v=upperSum-ans*countU ;
        v+=ans*countL-lowerSum ;
        v+=sumB ;
        writer.println(ans+" "+v);
      }
    }
    writer.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute writer : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Q : int ; Q := sc.getCurrent()->toInteger() ;
     var set : Set(long) ; set := Set{} ;
    skip ; 
    var minima : long ; minima := (sc.getCurrent()->toLong()*(2->pow(32)))->oclAsType(long) ;
    set := set->including(minima) ; 
    var upperSum : long ; upperSum := 0 ;
    var lowerSum : long ; lowerSum := 0 ;
    var sumB : long ; sumB := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i < Q do ( (     var type : int ; type := sc.getCurrent()->toInteger() ;
     if (type = 1) then (     var a : long ; a := ((sc.getCurrent()->toLong()*(2->pow(32)))->oclAsType(long)) + i ;
     sumB := sumB+(sc.getCurrent()->toInteger()) ; 
     set := set->including(a) ; 
     if (a < minima) then (     lowerSum := lowerSum+((a/(2->pow(32)))->oclAsType(long)) ; 
     if (set->size() mod 2 = 0) then (     upperSum := upperSum+((minima/(2->pow(32)))->oclAsType(long)) ; 
     minima := set.lower(minima) ; 
     lowerSum := lowerSum-((minima/(2->pow(32)))->oclAsType(long)) ) else skip ) else (     upperSum := upperSum+((a/(2->pow(32)))->oclAsType(long)) ; 
     if (set->size() mod 2 /= 0) then (     lowerSum := lowerSum+((minima/(2->pow(32)))->oclAsType(long)) ; 
     minima := set.higher(minima) ; 
     upperSum := upperSum-((minima/(2->pow(32)))->oclAsType(long)) ) else skip ) ) else (     var countU : int ; countU := set->size() / 2 ;
     var countL : int ; countL := (set->size() - 1) - countU ;
    var ans : long ; ans := (minima/(2->pow(32)))->oclAsType(long) ;
    var v : long ; v := upperSum - ans * countU ;
    v := v+(ans * countL - lowerSum) ; 
    v := v+(sumB) ; 
    skip ; 
 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String getWinner(String str,int len){
    int total=0 ;
    for(int i=0 ; i<len ; i++){
      if(str.charAt(i)=='S'){
        total++;
      }
    }
    if((total % 2)==1)return "First" ;
    return "Second" ;
  }
  public static void main(String[] args){
    String str="GSSS" ;
    int len=str.length();
    System.out.println(getWinner(str,len));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getWinner( str : String, len : int) : String
  pre: true
  post: true
  activity: (     var total : int ; total := 0 ;
         var i : int ; i := 0 ; while i < len do ( (     if (str->at(i+1) = 'S') then (     total := total + 1 ) else skip )  ;     i := i + 1 ) ; 
     if ((total mod 2) = 1) then     return "First" else skip ; 
     return "Second" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GSSS" ;
     var len : int ; len := str->size() ;
     OclFile["System.out"].println(getWinner(str, len)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findNumbers(int n){
    int i=1 ;
    while(i<=n){
      System.out.print(((2*i)-1)+" ");
      i++;
    }
  }
  public static void main(String args[]){
    int n=3 ;
    findNumbers(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNumbers( n : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 1 ;
     while (i <= n) do (     OclFile["System.out"].print(((2 * i) - 1) + " ") ; 
     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     execute findNumbers(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findNumbers(int n){
    int i=1 ;
    while(i<=n){
      System.out.print((3*i*(i-1)+1)+" ");
      i++;
    }
  }
  public static void main(String[] args){
    int n=4 ;
    findNumbers(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNumbers( n : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 1 ;
     while (i <= n) do (     OclFile["System.out"].print((3 * i * (i - 1) + 1) + " ") ; 
     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     execute findNumbers(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long mod=(long)(1e9+7);
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),x=in.nextInt(),c=0,y=in.nextInt();
    String s=in.next();
    if(s.charAt(n-y-1)=='0')c++;
    for(int i=0 ; i<=x-1 ; i++){
      if(i!=y){
        if(s.charAt(n-i-1)=='1')c++;
      }
    }
    pw.println(c);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := (1e9 + 7)->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
    var y : int ; y := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    if (s->at(n - y - 1+1) = '0') then     c := c + 1 ; else skip ; 
        var i : int ; i := 0 ; while i <= x - 1 do ( (     if (i /= y) then (     if (s->at(n - (i)->char2byte() - 1+1) = '1') then     c := c + 1 ; else skip ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    int w=Integer.parseInt(sc.next());
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    if(a>b+w || b>a+w){
      out.println(min(abs(a+w-b),abs(b+w-a)));
    }
    else {
      out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var w : int ; w := (sc.getCurrent())->toInteger() ;
    var a : int ; a := (sc.getCurrent())->toInteger() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    if (a > b + w or b > a + w) then (     out.println(Set{abs(a + w - b), abs(b + w - a)}->min()) ) else (     out.println(0) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Composite {
  static boolean isComposite(int n){
    if(n<=1)System.out.println("False");
    if(n<=3)System.out.println("False");
    if(n % 2==0 || n % 3==0)return true ;
    for(int i=5 ; i*i<=n ; i=i+6)if(n % i==0 || n %(i+2)==0)return true ;
    return false ;
  }
  public static void main(String args[]){
    System.out.println(isComposite(11)? "true" : "false");
    System.out.println(isComposite(15)? "true" : "false");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Composite {
  static   operation isComposite( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     OclFile["System.out"].println("False") ; else skip ; 
     if (n <= 3) then     OclFile["System.out"].println("False") ; else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return true else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return true else skip ;  ;     i := i + 6 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if isComposite(11) then "true" else "false" endif) ; 
     OclFile["System.out"].println(if isComposite(15) then "true" else "false" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class GFG {
  public static boolean multipleOrFactor(String s1,String s2){
    HashMap<Character,Integer>m1=new HashMap<>();
    HashMap<Character,Integer>m2=new HashMap<>();
    for(int i=0 ; i<s1.length(); i++){
      if(m1.containsKey(s1.charAt(i))){
        int x=m1.get(s1.charAt(i));
        m1.put(s1.charAt(i),++x);
      }
      else m1.put(s1.charAt(i),1);
    }
    for(int i=0 ; i<s2.length(); i++){
      if(m2.containsKey(s2.charAt(i))){
        int x=m2.get(s2.charAt(i));
        m2.put(s2.charAt(i),++x);
      }
      else m2.put(s2.charAt(i),1);
    }
    for(HashMap.Entry<Character,Integer>entry : m1.entrySet()){
      if(! m2.containsKey(entry.getKey()))continue ;
      if(m2.get(entry.getKey())!=null &&(m2.get(entry.getKey())% entry.getValue()==0 || entry.getValue()% m2.get(entry.getKey())==0))continue ;
      else return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    String s1="geeksforgeeks",s2="geeks" ;
    if(multipleOrFactor(s1,s2))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation multipleOrFactor( s1 : String, s2 : String) : boolean
  pre: true
  post: true
  activity: (     var m1 : Map(String,int) ; m1 := Map{} ;
     var m2 : Map(String,int) ; m2 := Map{} ;
        var i : int ; i := 0 ; while i < s1->size() do ( (     if (m1->keys()->includes(s1->at(i+1))) then (     var x : int ; x := m1->at(s1->at(i+1)) ;
     m1 := m1->union(Map{s1->at(i+1) |-> (x + 1)}) ) else     m1 := m1->union(Map{s1->at(i+1) |-> 1}) ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < s2->size() do ( (     if (m2->keys()->includes(s2->at(i+1))) then (     var x : int ; x := m2->at(s2->at(i+1)) ;
     m2 := m2->union(Map{s2->at(i+1) |-> (x + 1)}) ) else     m2 := m2->union(Map{s2->at(i+1) |-> 1}) ; )  ;     i := i + 1 ) ; 
    for (entry : m1->asSet()) do ( (     if (not(m2->keys()->includes(entry.getKey()))) then     continue else skip ; 
     if (m2->at(entry.getKey()) /= null & (m2->at(entry.getKey()) mod entry.getValue() = 0 or entry.getValue() mod m2->at(entry.getKey()) = 0)) then     continue else     return false )  ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "geeksforgeeks" ;
    var s2 : String ; s2 := "geeks" ;
     if (multipleOrFactor(s1, s2)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.math.*;
public class Main {
  static long mul[]=new long[100010];
  static long res=0 ;
  static long ans=0 ;
  static void dfs(long x,int len,long s){
    if(x<=7){
      if(res<len+x){
        res=len+x ;
        ans=s+x ;
      }
      else if(res==len+x && ans<s+x)ans=s+x ;
      return ;
    }
    int lb=1,ub=100000 ;
    int ans=1 ;
    while(ub>=lb){
      int mid=ub+lb>>1 ;
      if(mul[mid]>x){
        ub=mid-1 ;
      }
      else {
        lb=mid+1 ;
        ans=mid ;
      }
    }
    dfs(x-mul[ans],len+1,s+mul[ans]);
    dfs(mul[ans]-mul[ans-1]-1,len+1,s+mul[ans-1]);
  }
  public static void main(String args[]){
    Scanner cin=new Scanner(System.in);
    for(int i=1 ; i<=100000 ; i++)mul[i]=(long)i*i*i ;
    long m=cin.nextLong();
    dfs(m,0,0);
    System.out.println(res+" "+ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mul : long := Integer.subrange(1,100010)->collect(0);
  static   attribute res : long := 0;
  static   attribute ans : long := 0;
  static   operation dfs( x : long, len : int, s : long) : void
  pre: true
  post: true
  activity: (     if (x <= 7) then (     if (res < len + x) then (     res := len + x ; 
     ans := s + x ) else     if (res = len + x & ans < s + x) then     ans := s + x ; else skip ; ;  
     return ) else skip ; 
     var lb : int ; lb := 1 ;
    var ub : int ; ub := 100000 ;
    var ans : int ; ans := 1 ;
    while (ub >= lb) do (     var mid : int ; mid := (ub + lb/(2->pow(1)))->oclAsType(long) ;
     if (mul[mid+1] > x) then (     ub := mid - 1 ) else (     lb := mid + 1 ; 
     ans := mid ) ) ; 
    execute dfs(x - mul[ans+1], len + 1, s + mul[ans+1]) ; 
    execute dfs(mul[ans+1] - mul[ans - 1+1] - 1, len + 1, s + mul[ans - 1+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var i : int ; i := 1 ; while i <= 100000 do (     mul[i+1] := i->oclAsType(long) * i * i ;  ;     i := i + 1 ) ; 
    var m : long ; m := cin.getCurrent()->toLong() ;
    execute dfs(m, 0, 0) ; 
    OclFile["System.out"].println(res + " " + ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  @ SuppressWarnings("unchecked")private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      lists=new ArrayList[101];
      for(int i=0 ; i<101 ; i++)lists[i]=new ArrayList<Integer>();
      while(n-->0){
        int from=scanner.nextInt();
        int to=scanner.nextInt();
        lists[from] .add(to);
        lists[to] .add(from);
      }
      ans=0 ;
      for(int i=0 ; i<101 ; i++){
        if(lists[i] .isEmpty())continue ;
        b=new boolean[101];
        b[i]=true ;
        slove(i,1);
      }
      System.out.println(ans);
    }
  }
  private void slove(int from,int step){
    ans=Math.max(ans,step);
    for(int to : lists[from]){
      if(b[to])continue ;
      b[to]=true ;
      slove(to,step+1);
      b[to]=false ;
    }
  }
  int ans ;
  boolean[] b ;
  List<Integer>[] lists ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
      operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    lists := Integer.subrange(1,101)->collect(null) ; 
        var i : int ; i := 0 ; while i < 101 do (     lists[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        while (n > 0) do (        n := n - 1 ;     skip ; (     var from : int ; from := scanner.getCurrent()->toInteger() ;
     var to : int ; to := scanner.getCurrent()->toInteger() ;
     lists[from+1]->excludes(to) ; 
     lists[to+1]->excludes(from) ) ;  ) ;  
    ans := 0 ; 
        var i : int ; i := 0 ; while i < 101 do ( (     if (lists[i+1]->isEmpty()) then     continue else skip ; 
     b := Integer.subrange(1,101)->collect(false) ; 
     b[i+1] := true ; 
     execute slove(i, 1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
   operation slove( from : int, step : int) : void
  pre: true
  post: true
  activity: (     ans := Set{ans, step}->max() ; 
     for (to : lists[from+1]) do ( (     if (b[to+1]) then     continue else skip ; 
     b[to+1] := true ; 
     execute slove(to, step + 1) ; 
     b[to+1] := false )  ) );
   attribute ans : int;
   attribute b : Sequence(boolean);
   attribute lists : Sequence(Sequence(int));
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  @ SuppressWarnings("unchecked")private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    b=new boolean[101];
    while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      lists=new ArrayList[101];
      for(int i=0 ; i<101 ; i++)lists[i]=new ArrayList<Integer>();
      while(n-->0){
        int from=scanner.nextInt();
        int to=scanner.nextInt();
        lists[from] .add(to);
        lists[to] .add(from);
      }
      ans=0 ;
      for(int i=0 ; i<101 ; i++){
        if(lists[i] .isEmpty())continue ;
        b[i]=true ;
        slove(i,1);
        b[i]=false ;
      }
      System.out.println(ans);
    }
  }
  private void slove(int from,int step){
    ans=Math.max(ans,step);
    for(int to : lists[from]){
      if(b[to])continue ;
      b[to]=true ;
      slove(to,step+1);
      b[to]=false ;
    }
  }
  int ans ;
  boolean[] b ;
  List<Integer>[] lists ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
      operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     b := Integer.subrange(1,101)->collect(false) ; 
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    lists := Integer.subrange(1,101)->collect(null) ; 
        var i : int ; i := 0 ; while i < 101 do (     lists[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        while (n > 0) do (        n := n - 1 ;     skip ; (     var from : int ; from := scanner.getCurrent()->toInteger() ;
     var to : int ; to := scanner.getCurrent()->toInteger() ;
     lists[from+1]->excludes(to) ; 
     lists[to+1]->excludes(from) ) ;  ) ;  
    ans := 0 ; 
        var i : int ; i := 0 ; while i < 101 do ( (     if (lists[i+1]->isEmpty()) then     continue else skip ; 
     b[i+1] := true ; 
     execute slove(i, 1) ; 
     b[i+1] := false )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
   operation slove( from : int, step : int) : void
  pre: true
  post: true
  activity: (     ans := Set{ans, step}->max() ; 
     for (to : lists[from+1]) do ( (     if (b[to+1]) then     continue else skip ; 
     b[to+1] := true ; 
     execute slove(to, step + 1) ; 
     b[to+1] := false )  ) );
   attribute ans : int;
   attribute b : Sequence(boolean);
   attribute lists : Sequence(Sequence(int));
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Comparator ;
import java.util.PriorityQueue ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int Q=Integer.parseInt(br.readLine());
    PriorityQueue<Integer>left=new PriorityQueue<>(Comparator.comparingInt(a->-a));
    PriorityQueue<Integer>right=new PriorityQueue<>();
    long bsum=0 ;
    long ymin=0 ;
    StringBuffer sb=new StringBuffer();
    for(int i=0 ; i<Q ; i++){
      String line=br.readLine();
      if(line.charAt(0)=='1'){
        String[] nums=line.split(" ");
        int a=Integer.parseInt(nums[1]);
        int b=Integer.parseInt(nums[2]);
        bsum+=b ;
        if(left.isEmpty())left.add(a);
        else if(a<left.peek()){
          left.add(a);
          ymin+=left.peek()-a ;
        }
        else {
          right.add(a);
          ymin+=a-left.peek();
        }
        if(left.size()-right.size()>1){
          right.add(left.poll());
          int o=right.peek();
          int n=left.peek();
          ymin+=(o-n)*(right.size()-left.size());
        }
        else if(right.size()>left.size()){
          int o=left.peek();
          int n=right.peek();
          ymin+=(n-o)*(left.size()-right.size());
          left.add(right.poll());
        }
      }
      else {
        sb.append(String.format("%d %d\n",left.peek(),bsum+ymin));
      }
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var Q : int ; Q := (br.readLine())->toInteger() ;
    var left : Sequence(int) ; left := Sequence{}->union(Comparator.comparingInt(lambda a : OclAny in -a)) ;
    var right : Sequence(int) ; right := Sequence{} ;
    var bsum : long ; bsum := 0 ;
    var ymin : long ; ymin := 0 ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < Q do ( (     var line : String ; line := br.readLine() ;
     if (line->at(0+1) = '1') then (     var nums : Sequence(String) ; nums := line->split(" ") ;
     var a : int ; a := (nums[1+1])->toInteger() ;
    var b : int ; b := (nums[2+1])->toInteger() ;
    bsum := bsum+(b) ; 
    if (left->isEmpty()) then     left := left->including(a) else     if (a < left->min()) then (     left := left->including(a) ; 
     ymin := ymin+(left->min() - a) ) else (     right := right->including(a) ; 
     ymin := ymin+(a - left->min()) ) ;  ;  
    if (left->size() - right->size() > 1) then (     right := right->including(left->min()) ; 
     var o : int ; o := right->min() ;
     var n : int ; n := left->min() ;
     ymin := ymin+((o - n) * (right->size() - left->size())) ) else     if (right->size() > left->size()) then (     var o : int ; o := left->min() ;
     var n : int ; n := right->min() ;
     ymin := ymin+((n - o) * (left->size() - right->size())) ; 
     left := left->including(right->min()) ) else skip ; ;  
 ) else (     sb := sb + StringLib.newString(StringLib.format("%d %d\n",Sequence{left->min(),bsum + ymin})) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static PrintWriter out=new PrintWriter(System.out);
  static Scanner sc=new Scanner(System.in);
  static int INF=2<<20 ;
  static Node[] node ;
  public static void main(String[] args){
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      node=new Node[101];
      for(int i=0 ; i<101 ; i++){
        node[i]=new Node(i);
      }
      for(int i=0 ; i<n ; i++){
        int a=sc.nextInt();
        int b=sc.nextInt();
        node[a] .to.add(node[b]);
        node[b] .to.add(node[a]);
      }
      int ans=0 ;
      for(int i=1 ; i<101 ; i++){
        if(node[i] .to.size()==0)continue ;
        boolean[] tmp=new boolean[101];
        tmp[i]=true ;
        ans=Math.max(ans,dfs(i,tmp,1));
      }
      System.out.println(ans);
    }
  }
  static int dfs(int now,boolean[] use,int count){
    int ret=count ;
    for(int i=0 ; i<node[now] .to.size(); i++){
      int tmp=node[now] .to.get(i).id ;
      if(use[tmp])continue ;
      use[tmp]=true ;
      ret=Math.max(ret,dfs(tmp,use,count+1));
      use[tmp]=false ;
    }
    return ret ;
  }
  static class Node {
    int id ;
    ArrayList<Node>to=new ArrayList<Node>();
    Node(int a){
      id=a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute INF : int := (2*(2->pow(20)))->oclAsType(long);
  static   attribute node : Sequence(Node);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    node := Integer.subrange(1,101)->collect(null) ; 
        var i : int ; i := 0 ; while i < 101 do ( (     node[i+1] := Node.newNode(i) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     node[a+1].to->excludes(node[b+1]) ; 
     node[b+1].to->excludes(node[a+1]) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < 101 do ( (     if (node[i+1].to->size() = 0) then     continue else skip ; 
     var tmp : Sequence(boolean) ; tmp := Integer.subrange(1,101)->collect(false) ;
     tmp[i+1] := true ; 
     ans := Set{ans, dfs(i, tmp, 1)}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation dfs( now : int, use : Sequence(boolean), count : int) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := count ;
         var i : int ; i := 0 ; while i < node[now+1].to->size() do ( (     var tmp : int ; tmp := node[now+1].to->at(i+1).id ;
     if (use[tmp+1]) then     continue else skip ; 
    use[tmp+1] := true ; 
    ret := Set{ret, dfs(tmp, use, count + 1)}->max() ; 
    use[tmp+1] := false ; 
 )  ;     i := i + 1 ) ; 
     return ret );
  static class Node {
   attribute id : int;
   attribute to : Sequence(Node) := Sequence{};
   static operation newNode( a : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(a);
    return self );
  operation initialise( a : int) : void
  pre: true  post: true
  activity: (     id := a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static PrintWriter out=new PrintWriter(System.out);
  static Scanner sc=new Scanner(System.in);
  static int INF=2<<20 ;
  static Node[] node ;
  public static void main(String[] args){
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      node=new Node[101];
      for(int i=0 ; i<101 ; i++){
        node[i]=new Node(i);
      }
      for(int i=0 ; i<n ; i++){
        int a=sc.nextInt();
        int b=sc.nextInt();
        node[a] .to.add(node[b]);
        node[b] .to.add(node[a]);
      }
      int ans=0 ;
      boolean[] tmp=new boolean[101];
      for(int i=1 ; i<101 ; i++){
        if(node[i] .to.size()==0)continue ;
        tmp[i]=true ;
        ans=Math.max(ans,dfs(i,tmp,1));
        tmp[i]=false ;
      }
      System.out.println(ans);
    }
  }
  static int dfs(int now,boolean[] use,int count){
    int ret=count ;
    for(int i=0 ; i<node[now] .to.size(); i++){
      int tmp=node[now] .to.get(i).id ;
      if(use[tmp])continue ;
      use[tmp]=true ;
      ret=Math.max(ret,dfs(tmp,use,count+1));
      use[tmp]=false ;
    }
    return ret ;
  }
  static class Node {
    int id ;
    ArrayList<Node>to=new ArrayList<Node>();
    Node(int a){
      id=a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute INF : int := (2*(2->pow(20)))->oclAsType(long);
  static   attribute node : Sequence(Node);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    node := Integer.subrange(1,101)->collect(null) ; 
        var i : int ; i := 0 ; while i < 101 do ( (     node[i+1] := Node.newNode(i) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     node[a+1].to->excludes(node[b+1]) ; 
     node[b+1].to->excludes(node[a+1]) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var tmp : Sequence(boolean) ; tmp := Integer.subrange(1,101)->collect(false) ;
        var i : int ; i := 1 ; while i < 101 do ( (     if (node[i+1].to->size() = 0) then     continue else skip ; 
     tmp[i+1] := true ; 
     ans := Set{ans, dfs(i, tmp, 1)}->max() ; 
     tmp[i+1] := false )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation dfs( now : int, use : Sequence(boolean), count : int) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := count ;
         var i : int ; i := 0 ; while i < node[now+1].to->size() do ( (     var tmp : int ; tmp := node[now+1].to->at(i+1).id ;
     if (use[tmp+1]) then     continue else skip ; 
    use[tmp+1] := true ; 
    ret := Set{ret, dfs(tmp, use, count + 1)}->max() ; 
    use[tmp+1] := false ; 
 )  ;     i := i + 1 ) ; 
     return ret );
  static class Node {
   attribute id : int;
   attribute to : Sequence(Node) := Sequence{};
   static operation newNode( a : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(a);
    return self );
  operation initialise( a : int) : void
  pre: true  post: true
  activity: (     id := a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solveD();
  }
  private void solveD(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long A=sc.nextLong();
    long B=sc.nextLong();
    List<Integer>list=new ArrayList<Integer>();
    int max=0 ;
    for(int i=0 ; i<N ; i++){
      int val=sc.nextInt();
      list.add(val);
      if(max<val){
        max=val ;
      }
    }
    long minNum=(max+A-1)/A ;
    long maxNum=(max+B-1)/B ;
    do {
      long count=(minNum+maxNum)/2 ;
      if(isWin(count,A,B,list)){
        maxNum=count ;
      }
      else {
        minNum=count+1 ;
      }
    }
    while(minNum<maxNum);
    System.out.println(maxNum);
  }
  private boolean isWin(long count,long A,long B,List<Integer>hps){
    long sum=0 ;
    for(int hp : hps){
      long num=(hp-count*B+A-B-1)/(A-B);
      if(num>0){
        sum+=num ;
      }
    }
    return sum<=count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solveD() );
   operation solveD() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : long ; A := sc.getCurrent()->toLong() ;
    var B : long ; B := sc.getCurrent()->toLong() ;
    var list : Sequence(int) ; list := Sequence{} ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var val : int ; val := sc.getCurrent()->toInteger() ;
     list := list->including(val) ; 
     if (max < val) then (     max := val ) else skip )  ;     i := i + 1 ) ; 
    var minNum : long ; minNum := (max + A - 1) / A ;
    var maxNum : long ; maxNum := (max + B - 1) / B ;
  while true do ((     var count : long ; count := (minNum + maxNum) / 2 ;
     if (isWin(count, A, B, list)) then (     maxNum := count ) else (     minNum := count + 1 ) ) ;
    if (minNum < maxNum) then skip else break) ; 
    OclFile["System.out"].println(maxNum) ; 
 );
   operation isWin( count : long, A : long, B : long, hps : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     for (hp : hps) do ( (     var num : long ; num := (hp - count * B + A - B - 1) / (A - B) ;
     if (num > 0) then (     sum := sum+(num) ) else skip )  ) ; 
     return sum <= count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static int N ;
  static long A,B ;
  static long[] HP ;
  public static long binary(int low,int high){
    if(low>=high)return low ;
    int center=low+(high-low)/2 ;
    long need=0 ;
    for(int n=0 ; n<N ; n++){
      need+=Math.max(0,((HP[n]-B*center)+A-B-1)/(A-B));
    }
    if(need<=center){
      return binary(low,center);
    }
    else {
      return binary(center+1,high);
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    A=sc.nextLong();
    B=sc.nextLong();
    HP=new long[N];
    for(int n=0 ; n<N ; n++){
      HP[n]=sc.nextLong();
    }
    System.out.println(binary(1,1_000_000_000));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute A : long;
  static   attribute HP : Sequence(long);
  static   operation binary( low : int, high : int) : long
  pre: true
  post: true
  activity: (     if (low >= high) then     return low else skip ; 
     var center : int ; center := low + (high - low) / 2 ;
    var need : long ; need := 0 ;
        var n : int ; n := 0 ; while n < N do ( (     need := need+(Set{0, ((HP[n+1] - B * center) + A - B - 1) / (A - B)}->max()) )  ;     n := n + 1 ) ; 
    if (need <= center) then (     return binary(low, center) ) else (     return binary(center + 1, high) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
    A := sc.getCurrent()->toLong() ; 
    B := sc.getCurrent()->toLong() ; 
    HP := Integer.subrange(1,N)->collect(0) ; 
        var n : int ; n := 0 ; while n < N do ( (     HP[n+1] := sc.getCurrent()->toLong() )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(binary(1, 1_000_000_000)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.beans.Visibility ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String s1=sc.nextLine();
      String s2=sc.nextLine();
      System.out.println(leastNumOfHeadings(s1,s2));
    }
  }
  public static int leastNumOfHeadings(String s1,String s2){
    if(s2.length()==0)return 0 ;
    int[][] letters=new int[26][s1.length()];
    for(int i=0 ; i<26 ; i++){
      letters[i][s1.length()-1]=-1 ;
    }
    for(int i=s1.length()-1 ; i>=0 ; i--){
      for(int j=0 ; j<26 && i!=s1.length()-1 ; j++)letters[j][i]=letters[j][i+1];
      letters[s1.charAt(i)-'a'][i]=i ;
    }
    int count=0 ;
    int index=0 ;
    for(int i=0 ; i<s2.length(); i++){
      char targetChar=s2.charAt(i);
      count=index==0 ? count+1 : count ;
      if(letters[targetChar-'a'][0]==-1){
        return-1 ;
      }
      int pos=letters[targetChar-'a'][index];
      if(pos!=-1)index=(pos+1)% s1.length();
      else {
        count+=1 ;
        index=(letters[targetChar-'a'][0]+1)% s1.length();
      }
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var s1 : String ; s1 := sc.nextLine() ;
     var s2 : String ; s2 := sc.nextLine() ;
     OclFile["System.out"].println(leastNumOfHeadings(s1, s2)) ) );
  static   operation leastNumOfHeadings( s1 : String, s2 : String) : int
  pre: true
  post: true
  activity: (     if (s2->size() = 0) then     return 0 else skip ; 
     var letters : Sequence(Sequence(int)) ; letters := Integer.subrange(1,26)->collect(Integer.subrange(1,s1->size())->collect(0)) ;
        var i : int ; i := 0 ; while i < 26 do ( (     letters[i+1][s1->size() - 1+1] := -1 )  ;     i := i + 1 ) ; 
        var i : int ; i := s1->size() - 1 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < 26 & i /= s1->size() - 1 do (     letters[j+1][i+1] := letters[j+1][i + 1+1] ;  ;     j := j + 1 ) ; 
     letters[s1->at(i+1) - ('a')->char2byte()+1][i+1] := i )  ;     i := i - 1 ) ; 
    var count : int ; count := 0 ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < s2->size() do ( (     var targetChar : String ; targetChar := s2->at(i+1) ;
     count := if index = 0 then count + 1 else count endif ; 
    if (letters[(targetChar)->char2byte() - ('a')->char2byte()+1][0+1] = -1) then (     return -1 ) else skip ; 
    var pos : int ; pos := letters[(targetChar)->char2byte() - ('a')->char2byte()+1][index+1] ;
    if (pos /= -1) then     index := (pos + 1) mod s1->size() else (     count := count+(1) ; 
     index := (letters[(targetChar)->char2byte() - ('a')->char2byte()+1][0+1] + 1) mod s1->size() ) ;  
 )  ;     i := i + 1 ) ; 
    return count 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  private static int n ;
  private static long a,b ;
  private static long[] enemy ;
  private static boolean C(long k){
    long cnt=0 ;
    for(long hp : enemy){
      hp-=b*k ;
      if(hp>0){
        cnt+=Math.ceil((double)hp/(a-b));
      }
    }
    if(cnt>k)return false ;
    else return true ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    n=Integer.parseInt(str[0]);
    a=Long.parseLong(str[1]);
    b=Long.parseLong(str[2]);
    enemy=new long[n];
    for(int i=0 ; i<n ; i++)enemy[i]=Long.parseLong(br.readLine());
    long l=0,r=(long)1e9+1,med=-1 ;
    while(r-l>0){
      med=(r+l)/2 ;
      if(C(med)){
        r=med ;
      }
      else {
        l=med+1 ;
      }
    }
    System.out.println(l);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute a : long;
  static   attribute enemy : Sequence(long);
  static   operation C( k : long) : boolean
  pre: true
  post: true
  activity: (     var cnt : long ; cnt := 0 ;
     for (hp : enemy) do ( (     hp := hp-(b * k) ; 
     if (hp > 0) then (     cnt := cnt+((hp->oclAsType(double) / (a - b))->ceil()) ) else skip )  ) ; 
     if (cnt > k) then     return false else     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    n := (str[0+1])->toInteger() ; 
    a := (str[1+1])->toLong() ; 
    b := (str[2+1])->toLong() ; 
    enemy := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     enemy[i+1] := (br.readLine())->toLong() ;  ;     i := i + 1 ) ; 
    var l : long ; l := 0 ;
    var r : long ; r := 1e9->oclAsType(long) + 1 ;
    var med : long ; med := -1 ;
    while (r - l > 0) do (     med := (r + l) / 2 ; 
     if (C(med)) then (     r := med ) else (     l := med + 1 ) ) ; 
    OclFile["System.out"].println(l) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int[] monsters=new int[n];
    for(int i=0 ; i<n ; i++){
      monsters[i]=sc.nextInt();
    }
    Arrays.sort(monsters);
    int left=0 ;
    int right=1000000000 ;
    while(right-left>1){
      int m=left+(right-left)/2 ;
      if(check(monsters,a,b,m)){
        right=m ;
      }
      else {
        left=m ;
      }
    }
    System.out.println(right);
  }
  static boolean check(int[] arr,long max,long avg,long value){
    long minus=avg*value ;
    long bonus=max-avg ;
    for(int i=arr.length-1 ; i>=0 && value>=0 ; i--){
      if(arr[i]-minus>0){
        value-=(arr[i]-minus+bonus-1)/bonus ;
      }
      else {
        break ;
      }
    }
    return value>=0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var monsters : Sequence(int) ; monsters := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     monsters[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    monsters := monsters->sort() ; 
    var left : int ; left := 0 ;
    var right : int ; right := 1000000000 ;
    while (right - left > 1) do (     var m : int ; m := left + (right - left) / 2 ;
     if (check(monsters, a, b, m)) then (     right := m ) else (     left := m ) ) ; 
    OclFile["System.out"].println(right) ; 
 );
  static   operation check( arr : Sequence(int), max : long, avg : long, value : long) : boolean
  pre: true
  post: true
  activity: (     var minus : long ; minus := avg * value ;
     var bonus : long ; bonus := max - avg ;
         var i : int ; i := arr->size() - 1 ; while i >= 0 & value >= 0 do ( (     if (arr[i+1] - minus > 0) then (     value := value-((arr[i+1] - minus + bonus - 1) / bonus) ) else (     break ) )  ;     i := i - 1 ) ; 
     return value >= 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public void main(Scanner sc){
    int n=sc.nextInt();
    long a=sc.nextLong();
    long b=sc.nextLong();
    long h[]=new long[n];
    for(int i=0 ; i<n ; i++){
      h[i]=sc.nextLong();
    }
    long l=1 ;
    long r=1_000_000_000 ;
    while(l!=r){
      long mid=(l+r)/2 ;
      if(count(mid,h,a,b)<=mid){
        r=mid ;
      }
      else {
        l=mid+1 ;
      }
    }
    System.out.println(l);
  }
  private long count(long mid,long h[],long a,long b){
    long sa=a-b ;
    long cnt=0 ;
    for(int i=0 ; i<h.length ; i++){
      cnt+=Math.max((h[i]-mid*b+sa-1)/sa,0);
    }
    return cnt ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    new Main().main(sc);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var a : long ; a := sc.nextLong() ;
    var b : long ; b := sc.nextLong() ;
    var h : Sequence(long) ; h := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     h[i+1] := sc.nextLong() )  ;     i := i + 1 ) ; 
    var l : long ; l := 1 ;
    var r : long ; r := 1_000_000_000 ;
    while (l /= r) do (     var mid : long ; mid := (l + r) / 2 ;
     if (count(mid, h, a, b) <= mid) then (     r := mid ) else (     l := mid + 1 ) ) ; 
    OclFile["System.out"].println(l) ; 
 );
   operation count( mid : long, h : Sequence(long), a : long, b : long) : long
  pre: true
  post: true
  activity: (     var sa : long ; sa := a - b ;
     var cnt : long ; cnt := 0 ;
         var i : int ; i := 0 ; while i < h->size() do ( (     cnt := cnt+(Set{(h[i+1] - mid * b + sa - 1) / sa, 0}->max()) )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Main.newMain().main(sc) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int minOperation(int arr[],int n){
    HashMap<Integer,Integer>hash=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++)if(hash.containsKey(arr[i]))hash.put(arr[i],hash.get(arr[i])+1);
    else hash.put(arr[i],1);
    int max_count=0 ;
    Set<Integer>s=hash.keySet();
    for(int i : s)if(max_count<hash.get(i))max_count=hash.get(i);
    return(n-max_count);
  }
  public static void main(String[] args){
    int arr[]={
      1,5,2,1,3,2,1 };
      int n=arr.length ;
      System.out.print(minOperation(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minOperation( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var hash : Map(int,int) ; hash := Map{} ;
         var i : int ; i := 0 ; while i < n do (     if (hash->keys()->includes(arr[i+1])) then     hash := hash->union(Map{arr[i+1] |-> hash->at(arr[i+1]) + 1}) else     hash := hash->union(Map{arr[i+1] |-> 1}) ; ;   ;     i := i + 1 ) ; 
    var max_count : int ; max_count := 0 ;
    var s : Set(int) ; s := hash->keys() ;
    for (i : s) do (     if (max_count < hash->at(i)) then     max_count := hash->at(i) ; else skip ;  ) ; 
    return (n - max_count) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,2,1,3,2,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(minOperation(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Comparator ;
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      long b=0L,answer=0L ;
      Queue<Integer>leftQueue=new PriorityQueue<>(Comparator.reverseOrder());
      Queue<Integer>rightQueue=new PriorityQueue<>();
      for(int i=0 ; i<n ; i++){
        int command=scanner.nextInt();
        if(1==command){
          int a=scanner.nextInt();
          b+=scanner.nextInt();
          if(leftQueue.isEmpty()){
            leftQueue.add(a);
          }
          else if(a<leftQueue.peek()){
            leftQueue.add(a);
            answer+=leftQueue.peek()-a ;
          }
          else {
            rightQueue.add(a);
            answer+=a-leftQueue.peek();
          }
          if(leftQueue.size()-rightQueue.size()>1){
            rightQueue.add(leftQueue.poll());
            answer+=(rightQueue.peek()-leftQueue.peek())*(rightQueue.size()-leftQueue.size());
          }
          else if(rightQueue.size()>leftQueue.size()){
            answer+=(rightQueue.peek()-leftQueue.peek())*(leftQueue.size()-rightQueue.size());
            leftQueue.add(rightQueue.poll());
          }
        }
        else {
          System.out.println(leftQueue.peek()+" "+(answer+b));
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var b : long ; b := 0L ;
    var answer : long ; answer := 0L ;
    var leftQueue : Sequence(int) ; leftQueue := Sequence{}->union(Comparator.reverseOrder()) ;
    var rightQueue : Sequence(int) ; rightQueue := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var command : int ; command := scanner.getCurrent()->toInteger() ;
     if (1 = command) then (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     b := b+(scanner.getCurrent()->toInteger()) ; 
     if (leftQueue->isEmpty()) then (     leftQueue := leftQueue->including(a) ) else     if (a < leftQueue->min()) then (     leftQueue := leftQueue->including(a) ; 
     answer := answer+(leftQueue->min() - a) ) else (     rightQueue := rightQueue->including(a) ; 
     answer := answer+(a - leftQueue->min()) ) ;  ;  
     if (leftQueue->size() - rightQueue->size() > 1) then (     rightQueue := rightQueue->including(leftQueue->min()) ; 
     answer := answer+((rightQueue->min() - leftQueue->min()) * (rightQueue->size() - leftQueue->size())) ) else     if (rightQueue->size() > leftQueue->size()) then (     answer := answer+((rightQueue->min() - leftQueue->min()) * (leftQueue->size() - rightQueue->size())) ; 
     leftQueue := leftQueue->including(rightQueue->min()) ) else skip ; ) else (     OclFile["System.out"].println(leftQueue->min() + " " + (answer + b)) ) )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int getLargestSum(int N){
    int max_sum=0 ;
    for(int i=1 ; i<=N ; i++){
      for(int j=i+1 ; j<=N ; j++){
        if(i*j %(i+j)==0)max_sum=Math.max(max_sum,i+j);
      }
    }
    return max_sum ;
  }
  public static void main(String[] args){
    int N=25 ;
    int max_sum=getLargestSum(N);
    System.out.print(max_sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getLargestSum( N : int) : int
  pre: true
  post: true
  activity: (     var max_sum : int ; max_sum := 0 ;
         var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := i + 1 ; while j <= N do ( (     if (i * j mod (i + j) = 0) then     max_sum := Set{max_sum, i + j}->max() ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return max_sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 25 ;
     var max_sum : int ; max_sum := getLargestSum(N) ;
     OclFile["System.out"].print(max_sum) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=scanner.nextInt();
    }
    scanner.close();
    int firstIndex=-1 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]!=0){
        firstIndex=i ;
        break ;
      }
    }
    if(firstIndex==-1){
      System.out.println(0);
      return ;
    }
    int stepsCount=0 ;
    boolean inList=false ;
    for(int i=firstIndex ; i<n ; i++){
      if(! inList && arr[i]==1){
        inList=true ;
        stepsCount++;
      }
      if(inList && i<n-1 && arr[i+1]==1){
        stepsCount++;
      }
      else if(inList){
        stepsCount++;
        inList=false ;
      }
    }
    System.out.println(stepsCount-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var firstIndex : int ; firstIndex := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] /= 0) then (     firstIndex := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (firstIndex = -1) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var stepsCount : int ; stepsCount := 0 ;
    var inList : boolean ; inList := false ;
        var i : int ; i := firstIndex ; while i < n do ( (     if (not(inList) & arr[i+1] = 1) then (     inList := true ; 
     stepsCount := stepsCount + 1 ) else skip ; 
     if (inList & i < n - 1 & arr[i + 1+1] = 1) then (     stepsCount := stepsCount + 1 ) else     if (inList) then (     stepsCount := stepsCount + 1 ; 
     inList := false ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(stepsCount - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class code {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    ArrayList<Integer>a=new ArrayList<>();
    for(int i=0 ; i<t ; i++){
      a.add(sc.nextInt());
    }
    if(a.size()==0 || ! a.contains(1)){
      System.out.println(0);
      return ;
    }
    else {
      int c=0 ;
      if(a.get(0)==1)c+=2 ;
      for(int i=1 ; i<a.size(); i++){
        if(a.get(i)==1){
          if(a.get(i-1)==1)c+=1 ;
          else c+=2 ;
        }
      }
      System.out.println(c-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < t do ( (     a := a->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    if (a->size() = 0 or not(a->includes(1))) then (     OclFile["System.out"].println(0) ; 
     return ) else (     var c : int ; c := 0 ;
     if (a->at(0+1) = 1) then     c := c+(2) ; else skip ; 
         var i : int ; i := 1 ; while i < a->size() do ( (     if (a->at(i+1) = 1) then (     if (a->at(i - 1+1) = 1) then     c := c+(1) ; else     c := c+(2) ; ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(c - 1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.math.BigDecimal ;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    InputReader in=new InputReader();
    PrintWriter out=new PrintWriter(System.out);
    solve(in,out);
    out.close();
  }
  public static void solve(InputReader in,PrintWriter out){
    int n=in.nextInt();
    int[] a=new int[n];
    int res=0 ;
    int pre=0,cnt=0,diff=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
      if(pre==0 && a[i]==1){
        diff++;
      }
      if(a[i]==1){
        cnt++;
      }
      pre=a[i];
    }
    res=cnt+diff-1 ;
    if(res<0)res=0 ;
    out.println(res);
  }
}
class InputReader {
  BufferedReader buf ;
  StringTokenizer tok ;
  InputReader(){
    buf=new BufferedReader(new InputStreamReader(System.in));
  }
  boolean hasNext(){
    while(tok==null || ! tok.hasMoreElements()){
      try {
        tok=new StringTokenizer(buf.readLine());
      }
      catch(Exception e){
        return false ;
      }
    }
    return true ;
  }
  String next(){
    if(hasNext())return tok.nextToken();
    return null ;
  }
  char[] nextChars(){
    if(hasNext())return tok.nextToken().toCharArray();
    return null ;
  }
  int nextInt(){
    return Integer.parseInt(next());
  }
  long nextLong(){
    return Long.parseLong(next());
  }
  double nextDouble(){
    return Double.parseDouble(next());
  }
  BigInteger nextBigInteger(){
    return new BigInteger(next());
  }
  BigDecimal nextBigDecimal(){
    return new BigDecimal(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : InputReader ; in := InputReader.newInputReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     execute solve(in, out) ; 
     skip );
  static   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var res : int ; res := 0 ;
    var pre : int ; pre := 0 ;
    var cnt : int ; cnt := 0 ;
    var diff : int ; diff := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.nextInt() ; 
     if (pre = 0 & a[i+1] = 1) then (     diff := diff + 1 ) else skip ; 
     if (a[i+1] = 1) then (     cnt := cnt + 1 ) else skip ; 
     pre := a[i+1] )  ;     i := i + 1 ) ; 
    res := cnt + diff - 1 ; 
    if (res < 0) then     res := 0 ; else skip ; 
    skip ; 
 );
}
class InputReader {
   attribute buf : OclFile;
   attribute tok : OclIterator;
   static operation newInputReader() : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     buf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (tok = null or not(tok.hasNext())) do (     try (     tok := OclIterator.newOclIterator_String(buf.readLine()) )   catch (e : ProgramException) do (     return false )
 ) ; 
     return true );
   operation next() : String
  pre: true
  post: true
  activity: (     if (hasNext()) then     return tok.next() else skip ; 
     return null );
   operation nextChars() : Sequence(String)
  pre: true
  post: true
  activity: (     if (hasNext()) then     return tok.next()->characters() else skip ; 
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextBigInteger() : long
  pre: true
  post: true
  activity: (     return long(next()) );
   operation nextBigDecimal() : double
  pre: true
  post: true
  activity: (     return double(next()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B465 {
  public static int rec(int[] arr){
    int res=arr[0],prev=arr[0],l1=0 ;
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]==1)l1=i ;
    }
    for(int i=1 ; i<arr.length ; i++){
      if(arr[i]==0){
        if(i==l1+1)break ;
        if(prev==1)res++;
        else continue ;
      }
      else {
        res++;
      }
      prev=arr[i];
    }
    return res ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    System.out.println(rec(arr));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B465 {
  static   operation rec( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var res : int ; res := arr[0+1] ;
    var prev : int ; prev := arr[0+1] ;
    var l1 : int ; l1 := 0 ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = 1) then     l1 := i ; else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i < arr->size() do ( (     if (arr[i+1] = 0) then (     if (i = l1 + 1) then     break else skip ; 
     if (prev = 1) then     res := res + 1 ; else     continue ) else (     res := res + 1 ) ;  
     prev := arr[i+1] )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(rec(arr)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class PetyaAndJava {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    ArrayList<Integer>list=new ArrayList<>();
    int num=in.nextInt();
    int counter=0 ;
    for(int i=0 ; i<num ; i++){
      list.add(in.nextInt());
    }
    counter=num ;
    for(int i=0 ; i<num ; i++){
      if(i==0 || i==(num-1)){
        if(list.get(i)==0){
          counter--;
        }
      }
      if(i!=num-1 && list.get(i)==0 && list.get(i+1)==0){
        counter--;
      }
    }
    if(! list.contains(1)){
      System.out.println("0");
      return ;
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class PetyaAndJava {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(int) ; list := Sequence{} ;
    var num : int ; num := in.getCurrent()->toInteger() ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < num do ( (     list := list->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    counter := num ; 
        var i : int ; i := 0 ; while i < num do ( (     if (i = 0 or i = (num - 1)) then (     if (list->at(i+1) = 0) then (     counter := counter - 1 ) else skip ) else skip ; 
     if (i /= num - 1 & list->at(i+1) = 0 & list->at(i + 1+1) = 0) then (     counter := counter - 1 ) else skip )  ;     i := i + 1 ) ; 
    if (not(list->includes(1))) then (     OclFile["System.out"].println("0") ; 
     return ) else skip ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A91 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char[] H=in.next().toCharArray();
    char[] S=in.next().toCharArray();
    boolean[] exists=new boolean[26];
    int[][] next=new int[H.length+1][26];
    for(int pos=H.length-1 ; pos>=0 ; pos--){
      System.arraycopy(next[pos+1],0,next[pos],0,26);
      int c=H[pos]-'a' ;
      exists[c]=true ;
      next[pos][c]=pos+1 ;
    }
    int answer=1 ;
    int pos=0 ;
    for(char c : S){
      int i=c-'a' ;
      if(! exists[i]){
        answer=-1 ;
        break ;
      }
      pos=next[pos][i];
      if(pos==0){
        answer++;
        pos=next[0][i];
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A91 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : Sequence(String) ; H := in.getCurrent()->characters() ;
    var S : Sequence(String) ; S := in.getCurrent()->characters() ;
    var exists : Sequence(boolean) ; exists := Integer.subrange(1,26)->collect(false) ;
    var next : Sequence(Sequence(int)) ; next := Integer.subrange(1,H->size() + 1)->collect(Integer.subrange(1,26)->collect(0)) ;
        var pos : int ; pos := H->size() - 1 ; while pos >= 0 do ( (     for _x : Integer.subrange(1,26) do next[pos+1][0 + _x] := next[pos + 1+1][0 + _x] ; 
     var c : int ; c := H[pos+1] - ('a')->char2byte() ;
     exists[c+1] := true ; 
     next[pos+1][c+1] := pos + 1 )  ;     pos := pos - 1 ) ; 
    var answer : int ; answer := 1 ;
    var pos : int ; pos := 0 ;
    for (c : S) do ( (     var i : int ; i := c - ('a')->char2byte() ;
     if (not(exists[i+1])) then (     answer := -1 ; 
     break ) else skip ; 
     pos := next[pos+1][i+1] ; 
     if (pos = 0) then (     answer := answer + 1 ; 
     pos := next[0+1][i+1] ) else skip )  ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class pre368 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int tc=obj.nextInt();
    while(tc--!=0){
      int n=obj.nextInt(),a=obj.nextInt(),b=obj.nextInt();
      int k=0 ;
      for(int i=0 ; i<n ; i++){
        System.out.print((char)('a'+(k % b)));
        k++;
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre368 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var tc : int ; tc := obj.nextInt() ;
         while (tc /= 0) do (    skip ; (     var n : int ; n := obj.nextInt() ;
    var a : int ; a := obj.nextInt() ;
    var b : int ; b := obj.nextInt() ;
     var k : int ; k := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(('a' + (k mod b))->oclAsType(String)) ; 
     k := k + 1 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    char[] line=new char[26];
    int index=0 ;
    for(char c='a' ; c<='z' ; c++){
      line[index++]=c ;
    }
    for(int tt=0 ; tt<T ; tt++){
      int size=in.nextInt(),length=in.nextInt(),max=in.nextInt();
      StringBuilder sb=new StringBuilder();
      for(int i=0 ; i<size ; i++){
        sb.append((line[i % max]));
      }
      System.out.println(sb.toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
    var line : Sequence(String) ; line := Integer.subrange(1,26)->collect(0) ;
    var index : int ; index := 0 ;
        var c : String ; c := 'a' ; while c <= 'z' do ( (      line[index+1] := c  ; index := index + 1 )  ;     c := c + 1 ) ; 
        var tt : int ; tt := 0 ; while tt < T do ( (     var size : int ; size := in.getCurrent()->toInteger() ;
    var length : int ; length := in.getCurrent()->toInteger() ;
    var max : int ; max := in.getCurrent()->toInteger() ;
     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < size do ( (     sb := sb + StringLib.newString((line[i mod max+1])) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sb+"") )  ;     tt := tt + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      int a=sc.nextInt();
      int b=sc.nextInt();
      StringBuilder sb=new StringBuilder();
      for(int i=0 ; i<b ; i++){
        sb.append((char)('a'+i));
      }
      int i=0,j=b ;
      while(j<n){
        sb.append(sb.charAt(i));
        j++;
        i++;
      }
      System.out.println(sb.toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < b do ( (     sb := sb + StringLib.newString(('a' + i)->oclAsType(String)) )  ;     i := i + 1 ) ; 
    var i : int ; i := 0 ;
    var j : int ; j := b ;
    while (j < n) do (     sb := sb + StringLib.newString(sb->at(i+1)) ; 
     j := j + 1 ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=10000 ;
  static HashSet<Integer>s=new HashSet<Integer>();
  static void SieveOfEratosthenes(){
    boolean[] prime=new boolean[MAX];
    Arrays.fill(prime,true);
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<MAX ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<MAX ; i+=p)prime[i]=false ;
      }
    }
    int product=1 ;
    for(int p=2 ; p<MAX ; p++){
      if(prime[p]){
        product=product*p ;
        s.add(product+1);
      }
    }
  }
  static boolean isEuclid(int n){
    if(s.contains(n))return true ;
    else return false ;
  }
  public static void main(String[] args){
    SieveOfEratosthenes();
    int n=31 ;
    if(isEuclid(n))System.out.println("Yes");
    else System.out.println("No");
    n=42 ;
    if(isEuclid(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 10000;
  static   attribute s : Set(int) := Set{};
  static   operation SieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,MAX)->collect(false) ;
     prime := prime->collect(true) ; 
    prime[0+1] := false ; 
    prime[1+1] := false ; 
        var p : int ; p := 2 ; while p * p < MAX do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i < MAX do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var product : int ; product := 1 ;
        var p : int ; p := 2 ; while p < MAX do ( (     if (prime[p+1]) then (     product := product * p ; 
     s := s->including(product + 1) ) else skip )  ;     p := p + 1 ) ; 
 );
  static   operation isEuclid( n : int) : boolean
  pre: true
  post: true
  activity: (     if (s->includes(n)) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes() ; 
     var n : int ; n := 31 ;
    if (isEuclid(n)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
    n := 42 ; 
    if (isEuclid(n)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int test=cin.nextInt();
    while(test-->0){
      solve(cin);
    }
  }
  private static void solve(Scanner cin){
    int n=cin.nextInt();
    int a=cin.nextInt();
    int b=cin.nextInt();
    StringBuilder builder=new StringBuilder();
    int cnt=0 ;
    for(int i=0 ; i<n ; i++,cnt++){
      char j=(char)((char)(cnt % b)+'a');
      builder.append(j);
    }
    System.out.println(builder);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := cin.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     execute solve(cin) ) ;  ) );
  static   operation solve( cin : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := cin.getCurrent()->toInteger() ;
     var a : int ; a := cin.getCurrent()->toInteger() ;
    var b : int ; b := cin.getCurrent()->toInteger() ;
    var builder : String ; builder := StringLib.newString() ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var j : String ; j := ((cnt mod b)->oclAsType(String) + 'a')->oclAsType(String) ;
     builder := builder + StringLib.newString(j) )  ;     i := i + 1 ;     cnt := cnt + 1 ) ; 
    OclFile["System.out"].println(builder) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long k=sc.nextLong();
    long left=1 ;
    long right=k+1 ;
    while(right-left>1){
      long m=(left+right)/2 ;
      long x=m ;
      long total=0 ;
      for(int i=0 ; i<n && x>0 && total<=k ; i++){
        total+=x ;
        x/=2 ;
      }
      if(total<=k){
        left=m ;
      }
      else {
        right=m ;
      }
    }
    System.out.println(left);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var left : long ; left := 1 ;
    var right : long ; right := k + 1 ;
    while (right - left > 1) do (     var m : long ; m := (left + right) / 2 ;
     var x : long ; x := m ;
    var total : long ; total := 0 ;
        var i : int ; i := 0 ; while i < n & x > 0 & total <= k do ( (     total := total+(x) ; 
     x := x/(2) )  ;     i := i + 1 ) ; 
    if (total <= k) then (     left := m ) else (     right := m ) ;  
 ) ; 
    OclFile["System.out"].println(left) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int N=sc.nextInt();
      long W=sc.nextLong();
      long[] dp=new long[N*100+1];
      for(int i=0 ; i<N*100+1 ; i++){
        dp[i]=Long.MAX_VALUE/6 ;
      }
      dp[0]=0 ;
      for(int i=0 ; i<N ; i++){
        int v=sc.nextInt();
        long w=sc.nextLong();
        for(int j=N*100-v ; j>=0 ; j--){
          if(dp[j]+w<=Math.min(dp[j+v],W)){
            dp[j+v]=dp[j]+w ;
          }
        }
      }
      int ans=0 ;
      for(int i=0 ; i<N*100+1 ; i++){
        if(dp[i]!=Long.MAX_VALUE/6){
          ans=i ;
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var W : long ; W := sc.getCurrent()->toLong() ;
    var dp : Sequence(long) ; dp := Integer.subrange(1,N * 100 + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N * 100 + 1 do ( (     dp[i+1] := "9223372036854775807"->toLong() / 6 )  ;     i := i + 1 ) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < N do ( (     var v : int ; v := sc.getCurrent()->toInteger() ;
     var w : long ; w := sc.getCurrent()->toLong() ;
         var j : int ; j := N * 100 - v ; while j >= 0 do ( (     if (dp[j+1] + w <= Set{dp[j + v+1], W}->min()) then (     dp[j + v+1] := dp[j+1] + w ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < N * 100 + 1 do ( (     if (dp[i+1] /= "9223372036854775807"->toLong() / 6) then (     ans := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  int n ;
  long w ;
  Item[] is ;
  private final static int MAX_V=100 ;
  public static void main(String[] args){
    Main m=new Main();
    m.read();
    m.solve();
  }
  private void read(){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    w=sc.nextLong();
    is=new Item[n];
    for(int i=0 ; i<n ; i++){
      int v=sc.nextInt();
      long w=sc.nextLong();
      is[i]=new Item(v,w);
    }
  }
  private void solve(){
    long[][] dp=new long[n+1][MAX_V*(n+1)];
    for(int i=0 ; i<dp.length ; i++){
      Arrays.fill(dp[i],1000000001);
    }
    dp[0][0]=0 ;
    for(int i=1 ; i<dp.length ; i++){
      long localW=is[i-1] .w ;
      int localV=is[i-1] .v ;
      for(int j=0 ; j<dp[0] .length ; j++){
        if(j-localV<0){
          dp[i][j]=dp[i-1][j];
        }
        else {
          dp[i][j]=Math.min(dp[i-1][j],dp[i-1][j-localV]+localW);
        }
      }
    }
    int ans=0 ;
    for(int i=0 ; i<dp[0] .length ; i++){
      if(dp[n][i]!=0 && dp[n][i]<=w && ans<i)ans=i ;
    }
    System.out.println(ans);
  }
  private class Item {
    int v ;
    long w ;
    Item(int v,long w){
      this.v=v ;
      this.w=w ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute w : long;
   attribute is : Sequence(Item);
  static   attribute MAX_V : int := 100;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.read() ; 
     m.solve() );
   operation read() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    w := sc.getCurrent()->toLong() ; 
    is := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := sc.getCurrent()->toInteger() ;
     var w : long ; w := sc.getCurrent()->toLong() ;
     is[i+1] := Item.newItem(v, w) )  ;     i := i + 1 ) ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,MAX_V * (n + 1))->collect(0)) ;
         var i : int ; i := 0 ; while i < dp->size() do ( (     dp[i+1] := dp[i+1]->collect(1000000001) )  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := 0 ; 
        var i : int ; i := 1 ; while i < dp->size() do ( (     var localW : long ; localW := is[i - 1+1].w ;
     var localV : int ; localV := is[i - 1+1].v ;
         var j : int ; j := 0 ; while j < dp[0+1]->size() do ( (     if (j - localV < 0) then (     dp[i+1][j+1] := dp[i - 1+1][j+1] ) else (     dp[i+1][j+1] := Set{dp[i - 1+1][j+1], dp[i - 1+1][j - localV+1] + localW}->min() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < dp[0+1]->size() do ( (     if (dp[n+1][i+1] /= 0 & dp[n+1][i+1] <= w & ans < i) then     ans := i ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
 class Item {
   attribute v : int;
   attribute w : long;
   static operation newItem( v : int, w : long) : Item
  pre: true
  post: true
  activity:
  ( var self : Item ;
    self := createItem();
    self.initialise(v, w);
    return self );
  operation initialise( v : int, w : long) : void
  pre: true  post: true
  activity: (     self.v := v ; 
     self.w := w );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] argv)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int W=Integer.parseInt(str[1]);
    int[] v=new int[n];
    int[] w=new int[n];
    int sumOfV=0 ;
    for(int i=0 ; i<n ; i++){
      str=br.readLine().split(" ");
      v[i]=Integer.parseInt(str[0]);
      w[i]=Integer.parseInt(str[1]);
      sumOfV+=v[i];
    }
    int[][] dp=new int[n+1][sumOfV+1];
    dp[n][0]=0 ;
    for(int i=1 ; i<=sumOfV ; i++)dp[n][i]=Integer.MAX_VALUE/2 ;
    for(int i=n-1 ; i>=0 ; i--){
      for(int j=0 ; j<=sumOfV ; j++){
        if(v[i]>j){
          dp[i][j]=dp[i+1][j];
        }
        else {
          dp[i][j]=Integer.min(dp[i+1][j],dp[i+1][j-v[i] ]+w[i]);
        }
      }
    }
    int ans=sumOfV ;
    while(dp[0][ans]>W)ans--;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( argv : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var W : int ; W := (str[1+1])->toInteger() ;
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
    var w : Sequence(int) ; w := Integer.subrange(1,n)->collect(0) ;
    var sumOfV : int ; sumOfV := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     str := br.readLine()->split(" ") ; 
     v[i+1] := (str[0+1])->toInteger() ; 
     w[i+1] := (str[1+1])->toInteger() ; 
     sumOfV := sumOfV+(v[i+1]) )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,sumOfV + 1)->collect(0)) ;
    dp[n+1][0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= sumOfV do (     dp[n+1][i+1] := 2147483647 / 2 ;  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j <= sumOfV do ( (     if (v[i+1] > j) then (     dp[i+1][j+1] := dp[i + 1+1][j+1] ) else (     dp[i+1][j+1] := Set{dp[i + 1+1][j+1], dp[i + 1+1][j - v[i+1]+1] + w[i+1]}->min() ) )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    var ans : int ; ans := sumOfV ;
    while (dp[0+1][ans+1] > W) do     ans := ans - 1 ; ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int total=in.nextInt();
    int[] v=new int[n];
    int[] w=new int[n];
    for(int i=0 ; i<n ; i++){
      v[i]=in.nextInt();
      w[i]=in.nextInt();
    }
    int[][] t=new int[n+1][n*100+1];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<=n*100 ; j++){
        t[i][j]=total+1 ;
      }
    }
    t[0][0]=0 ;
    t[0][v[0] ]=w[0];
    int sum=v[0];
    for(int i=1 ; i<n ; i++){
      sum+=v[i];
      for(int j=0 ; j<=sum ; j++){
        if(v[i]>j){
          t[i][j]=Math.min(t[i-1][j],w[i]);
        }
        else {
          if(t[i-1][j-v[i] ]+w[i]>total){
            t[i][j]=t[i-1][j];
          }
          else {
            t[i][j]=Math.min(t[i-1][j],t[i-1][j-v[i] ]+w[i]);
          }
        }
      }
    }
    int rtn=0 ;
    for(int i=n*100 ; i>=0 ; i--){
      if(t[n-1][i]>0 && t[n-1][i]<=total){
        rtn=i ;
        break ;
      }
    }
    System.out.println(rtn);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var total : int ; total := in.getCurrent()->toInteger() ;
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
    var w : Sequence(int) ; w := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     v[i+1] := in.getCurrent()->toInteger() ; 
     w[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var t : Sequence(Sequence(int)) ; t := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n * 100 + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j <= n * 100 do ( (     t[i+1][j+1] := total + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    t[0+1][0+1] := 0 ; 
    t[0+1][v[0+1]+1] := w[0+1] ; 
    var sum : int ; sum := v[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     sum := sum+(v[i+1]) ; 
         var j : int ; j := 0 ; while j <= sum do ( (     if (v[i+1] > j) then (     t[i+1][j+1] := Set{t[i - 1+1][j+1], w[i+1]}->min() ) else (     if (t[i - 1+1][j - v[i+1]+1] + w[i+1] > total) then (     t[i+1][j+1] := t[i - 1+1][j+1] ) else (     t[i+1][j+1] := Set{t[i - 1+1][j+1], t[i - 1+1][j - v[i+1]+1] + w[i+1]}->min() ) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var rtn : int ; rtn := 0 ;
        var i : int ; i := n * 100 ; while i >= 0 do ( (     if (t[n - 1+1][i+1] > 0 & t[n - 1+1][i+1] <= total) then (     rtn := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(rtn) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GfG {
  public static int sum(int a[],int n){
    Map<Integer,Integer>cnt=new HashMap<Integer,Integer>();
    int ans=0,pre_sum=0 ;
    for(int i=0 ; i<n ; i++){
      ans+=(i*a[i])-pre_sum ;
      pre_sum+=a[i];
      if(cnt.containsKey(a[i]-1))ans-=cnt.get(a[i]-1);
      if(cnt.containsKey(a[i]+1))ans+=cnt.get(a[i]+1);
      if(cnt.containsKey(a[i])){
        cnt.put(a[i],cnt.get(a[i])+1);
      }
      else {
        cnt.put(a[i],1);
      }
    }
    return ans ;
  }
  public static void main(String args[]){
    int a[]={
      1,2,3,1,3 };
      int n=a.length ;
      System.out.println(sum(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation sum( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var cnt : Map(int,int) ; cnt := Map{} ;
     var ans : int ; ans := 0 ;
    var pre_sum : int ; pre_sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     ans := ans+((i * a[i+1]) - pre_sum) ; 
     pre_sum := pre_sum+(a[i+1]) ; 
    if (cnt->keys()->includes(a[i+1] - 1)) then     ans := ans-(cnt->at(a[i+1] - 1)) ; else skip ; 
    if (cnt->keys()->includes(a[i+1] + 1)) then     ans := ans+(cnt->at(a[i+1] + 1)) ; else skip ; 
    if (cnt->keys()->includes(a[i+1])) then (     cnt := cnt->union(Map{a[i+1] |-> cnt->at(a[i+1]) + 1}) ) else (     cnt := cnt->union(Map{a[i+1] |-> 1}) ) ;  
 )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,1,3} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(sum(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void factors(int n,int i){
    if(i<=n){
      if(n % i==0){
        System.out.print(i+" ");
      }
      factors(n,i+1);
    }
  }
  public static void main(String args[]){
    int N=16 ;
    factors(N,1);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation factors( n : int, i : int) : void
  pre: true
  post: true
  activity: (     if (i <= n) then (     if (n mod i = 0) then (     OclFile["System.out"].print(i + " ") ) else skip ; 
     execute factors(n, i + 1) ) else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 16 ;
     execute factors(N, 1) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int longestCommon(int n,int m){
    int mx=-Integer.MAX_VALUE ;
    String s1=Integer.toBinaryString(n);
    String s2=Integer.toBinaryString(m);
    String res=null ;
    int len=s1.length();
    int l=len ;
    while(len>0){
      for(int i=0 ; i<l-len+1 ; i++){
        String temp=s1.substring(i,i+len);
        int tlen=temp.length();
        if(tlen>mx && s2.contains(temp)){
          res=temp ;
          mx=tlen ;
        }
      }
      len=len-1 ;
    }
    if(res=="")return-1 ;
    return Integer.parseInt(res,2);
  }
  public static void main(String[] args){
    int n=10 ;
    int m=11 ;
    System.out.println("Longest common decimal value : "+longestCommon(m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation longestCommon( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var mx : int ; mx := -2147483647 ;
     var s1 : String ; s1 := (MathLib.decimal2binary(n) + "") ;
    var s2 : String ; s2 := (MathLib.decimal2binary(m) + "") ;
    var res : String ; res := null ;
    var len : int ; len := s1->size() ;
    var l : int ; l := len ;
    while (len > 0) do (         var i : int ; i := 0 ; while i < l - (len)->char2byte() + 1 do ( (     var temp : String ; temp := s1.subrange(i+1,i + len) ;
     var tlen : int ; tlen := temp->size() ;
     if (tlen > mx & s2->includes(temp)) then (     res := temp ; 
     mx := tlen ) else skip )  ;     i := i + 1 ) ; 
     len := (len)->char2byte() - 1 ) ; 
    if (res = "") then     return -1 else skip ; 
    return (res)->toInteger() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     var m : int ; m := 11 ;
     OclFile["System.out"].println("Longest common decimal value : " + longestCommon(m, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.Scanner ;
import java.util.Vector ;
public class SS {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int b=in.nextInt();
    int[] arr=new int[n];
    Vector<Integer>v=new Vector<>();
    int odd=0,even=0,count=0 ;
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=in.nextInt();
    }
    for(int i=0 ; i<arr.length ; i++){
      if(i!=0 && odd==even)v.add(Math.abs(arr[i]-arr[i-1]));
      if(arr[i] % 2==0){
        even++;
      }
      else odd++;
    }
    Collections.sort(v);
    for(int i=0 ; i<v.size(); i++){
      if(b>=v.get(i)){
        count++;
        b-=v.get(i);
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class SS {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var v : Sequence(int) ; v := Sequence{} ;
    var odd : int ; odd := 0 ;
    var even : int ; even := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (i /= 0 & odd = even) then     v := v->including(if arr[i+1] - arr[i - 1+1] < 0 then -(arr[i+1] - arr[i - 1+1]) else arr[i+1] - arr[i - 1+1] endif) ; else skip ; 
     if (arr[i+1] mod 2 = 0) then (     even := even + 1 ) else     odd := odd + 1 ; )  ;     i := i + 1 ) ; 
    v := v->sort() ; 
        var i : int ; i := 0 ; while i < v->size() do ( (     if (b >= v->at(i+1)) then (     count := count + 1 ; 
     b := b-(v->at(i+1)) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Bets {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] time=new int[n+1];
    time[0]=0 ;
    for(int i=1 ; i<=n ; i++)time[i]=Integer.MAX_VALUE ;
    int[] profit=new int[n+1];
    for(int i=0 ; i<m ; i++){
      int li=sc.nextInt();
      int ri=sc.nextInt();
      int ti=sc.nextInt();
      int ci=sc.nextInt();
      for(int index=ri ; index>=li ; index--){
        if(time[index]>ti){
          time[index]=ti ;
          profit[index]=ci ;
        }
      }
    }
    int totalProfit=0 ;
    for(int i=0 ; i<=n ; i++)totalProfit+=profit[i];
    System.out.println(totalProfit);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Bets {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var time : Sequence(int) ; time := Integer.subrange(1,n + 1)->collect(0) ;
    time[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do (     time[i+1] := 2147483647 ;  ;     i := i + 1 ) ; 
    var profit : Sequence(int) ; profit := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     var li : int ; li := sc.getCurrent()->toInteger() ;
     var ri : int ; ri := sc.getCurrent()->toInteger() ;
    var ti : int ; ti := sc.getCurrent()->toInteger() ;
    var ci : int ; ci := sc.getCurrent()->toInteger() ;
        var index : int ; index := ri ; while index >= li do ( (     if (time[index+1] > ti) then (     time[index+1] := ti ; 
     profit[index+1] := ci ) else skip )  ;     index := index - 1 ) ; 
 )  ;     i := i + 1 ) ; 
    var totalProfit : int ; totalProfit := 0 ;
        var i : int ; i := 0 ; while i <= n do (     totalProfit := totalProfit+(profit[i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(totalProfit) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class test {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int[][] cost=new int[m][n+1];
    int[][] time=new int[m][n+1];
    for(int i=0 ; i<m ; i++){
      int li=in.nextInt();
      int ri=in.nextInt();
      int ti=in.nextInt();
      int ci=in.nextInt();
      for(int j=li ; j<=ri ; j++){
        cost[i][j]=ci ;
        time[i][j]=ti ;
      }
    }
    int maxProfit=0 ;
    for(int j=1 ; j<=n ; j++){
      int profit=cost[0][j];
      int minTime=1000 ;
      for(int i=0 ; i<m ; i++){
        if(time[i][j]>0){
          if(time[i][j]<minTime){
            minTime=time[i][j];
            profit=cost[i][j];
          }
        }
      }
      maxProfit+=profit ;
    }
    System.out.println(maxProfit);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var cost : Sequence(Sequence(int)) ; cost := Integer.subrange(1,m)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
    var time : Sequence(Sequence(int)) ; time := Integer.subrange(1,m)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (     var li : int ; li := in.getCurrent()->toInteger() ;
     var ri : int ; ri := in.getCurrent()->toInteger() ;
    var ti : int ; ti := in.getCurrent()->toInteger() ;
    var ci : int ; ci := in.getCurrent()->toInteger() ;
        var j : int ; j := li ; while j <= ri do ( (     cost[i+1][j+1] := ci ; 
     time[i+1][j+1] := ti )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    var maxProfit : int ; maxProfit := 0 ;
        var j : int ; j := 1 ; while j <= n do ( (     var profit : int ; profit := cost[0+1][j+1] ;
     var minTime : int ; minTime := 1000 ;
         var i : int ; i := 0 ; while i < m do ( (     if (time[i+1][j+1] > 0) then (     if (time[i+1][j+1] < minTime) then (     minTime := time[i+1][j+1] ; 
     profit := cost[i+1][j+1] ) else skip ) else skip )  ;     i := i + 1 ) ; 
     maxProfit := maxProfit+(profit) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(maxProfit) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] time=new int[n+1];
    time[0]=0 ;
    for(int i=1 ; i<=n ; i++)time[i]=Integer.MAX_VALUE ;
    int[] profit=new int[n+1];
    for(int i=0 ; i<m ; i++){
      int li=sc.nextInt();
      int ri=sc.nextInt();
      int ti=sc.nextInt();
      int ci=sc.nextInt();
      for(int index=ri ; index>=li ; index--){
        if(time[index]>ti){
          time[index]=ti ;
          profit[index]=ci ;
        }
      }
    }
    int totalProfit=0 ;
    for(int i=0 ; i<=n ; i++)totalProfit+=profit[i];
    System.out.println(totalProfit);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var time : Sequence(int) ; time := Integer.subrange(1,n + 1)->collect(0) ;
    time[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do (     time[i+1] := 2147483647 ;  ;     i := i + 1 ) ; 
    var profit : Sequence(int) ; profit := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     var li : int ; li := sc.getCurrent()->toInteger() ;
     var ri : int ; ri := sc.getCurrent()->toInteger() ;
    var ti : int ; ti := sc.getCurrent()->toInteger() ;
    var ci : int ; ci := sc.getCurrent()->toInteger() ;
        var index : int ; index := ri ; while index >= li do ( (     if (time[index+1] > ti) then (     time[index+1] := ti ; 
     profit[index+1] := ci ) else skip )  ;     index := index - 1 ) ; 
 )  ;     i := i + 1 ) ; 
    var totalProfit : int ; totalProfit := 0 ;
        var i : int ; i := 0 ; while i <= n do (     totalProfit := totalProfit+(profit[i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(totalProfit) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class CountMultiples {
  static int ans[];
  static void countSieve(int arr[],int n){
    int MAX=arr[0];
    for(int i=1 ; i<n ; i++)MAX=Math.max(arr[i],MAX);
    int cnt[]=new int[MAX+1];
    ans=new int[MAX+1];
    for(int i=0 ; i<n ; ++i)++cnt[arr[i] ];
    for(int i=1 ; i<=MAX ; ++i)for(int j=i ; j<=MAX ; j+=i)ans[i]+=cnt[j];
    return ;
  }
  static int countMultiples(int k){
    return ans[k];
  }
  public static void main(String args[]){
    int arr[]={
      2,4,9,15,21,20 };
      int n=6 ;
      countSieve(arr,n);
      int k=2 ;
      System.out.println(countMultiples(k));
      k=3 ;
      System.out.println(countMultiples(k));
      k=5 ;
      System.out.println(countMultiples(k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class CountMultiples {
  static   attribute ans : Sequence(int);
  static   operation countSieve( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var MAX : int ; MAX := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do (     MAX := Set{arr[i+1], MAX}->max() ;  ;     i := i + 1 ) ; 
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,MAX + 1)->collect(0) ;
    ans := Integer.subrange(1,MAX + 1)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     cnt[arr[i+1]+1] := cnt[arr[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= MAX do (         var j : int ; j := i ; while j <= MAX do (     ans[i+1] := ans[i+1]+(cnt[j+1]) ;  ;     j := j+(i) ) ;  ;     i := i + 1 ) ; 
    return 
 );
  static   operation countMultiples( k : int) : int
  pre: true
  post: true
  activity: (     return ans[k+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,9,15,21,20} ;
     var n : int ; n := 6 ;
    execute countSieve(arr, n) ; 
    var k : int ; k := 2 ;
    OclFile["System.out"].println(countMultiples(k)) ; 
    k := 3 ; 
    OclFile["System.out"].println(countMultiples(k)) ; 
    k := 5 ; 
    OclFile["System.out"].println(countMultiples(k)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int[][] transpose(int[][] A){
    int R=A.length,C=A[0] .length ;
    int[][] ans=new int[C][R];
    for(int r=0 ; r<R ; ++r)for(int c=0 ; c<C ; ++c){
      ans[c][r]=A[r][c];
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation transpose( A : Sequence(Sequence(int))) : Sequence(Sequence(int))
  pre: true
  post: true
  activity: (     var R : int ; R := A->size() ;
    var C : int ; C := A[0+1]->size() ;
     var ans : Sequence(Sequence(int)) ; ans := Integer.subrange(1,C)->collect(Integer.subrange(1,R)->collect(0)) ;
         var r : int ; r := 0 ; while r < R do (         var c : int ; c := 0 ; while c < C do ( (     ans[c+1][r+1] := A[r+1][c+1] )  ;     c := c + 1 ) ;  ;     r := r + 1 ) ; 
     return ans );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int findMaxGCD(int[] arr,int n,int k){
    Arrays.sort(arr);
    int high=arr[n-1];
    int[] divisors=new int[high+1];
    for(int i=0 ; i<n ; i++){
      for(int j=1 ; j<=Math.sqrt(arr[i]); j++){
        if(arr[i] % j==0){
          divisors[j]++;
          if(j!=arr[i]/j)divisors[arr[i]/j]++;
        }
      }
    }
    for(int i=high ; i>=1 ; i--)if(divisors[i]>=k)return i ;
    return 0 ;
  }
  static public void main(String[] args){
    int[] arr={
      1,2,4,8,8,12 };
      int k=3 ;
      int n=arr.length ;
      System.out.println(findMaxGCD(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMaxGCD( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var high : int ; high := arr[n - 1+1] ;
    var divisors : Sequence(int) ; divisors := Integer.subrange(1,high + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 1 ; while j <= (arr[i+1])->sqrt() do ( (     if (arr[i+1] mod j = 0) then (     divisors[j+1] := divisors[j+1] + 1 ; 
     if (j /= arr[i+1] / j) then     divisors[arr[i+1] / j+1] := divisors[arr[i+1] / j+1] + 1 ; else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := high ; while i >= 1 do (     if (divisors[i+1] >= k) then     return i else skip ;  ;     i := i - 1 ) ; 
    return 0 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,4,8,8,12} ;
     var k : int ; k := 3 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMaxGCD(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int A=sc.nextInt();
    int B=sc.nextInt();
    if(A % 2==1 && B % 2==1){
      System.out.println("Alice");
      return ;
    }
    if(A % 2==0 && B % 2==0){
      System.out.println("Alice");
      return ;
    }
    System.out.println("Borys");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    if (A mod 2 = 1 & B mod 2 = 1) then (     OclFile["System.out"].println("Alice") ; 
     return ) else skip ; 
    if (A mod 2 = 0 & B mod 2 = 0) then (     OclFile["System.out"].println("Alice") ; 
     return ) else skip ; 
    OclFile["System.out"].println("Borys") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;
import java.util.regex.*;
public class Main {
  private static BufferedReader br ;
  private static StringTokenizer st ;
  private static PrintWriter pw ;
  public static void main(String[] args)throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    int qq=Integer.MAX_VALUE ;
    for(int casenum=1 ; casenum<=qq ; casenum++){
      int n=readInt();
      int a=readInt();
      int b=readInt();
      if(a % 2==b % 2){
        pw.println("Alice");
      }
      else {
        pw.println("Borys");
      }
    }
    exitImmediately();
  }
  private static void exitImmediately(){
    pw.close();
    System.exit(0);
  }
  private static long readLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  private static double readDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  private static int readInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  private static String nextLine()throws IOException {
    if(! br.ready()){
      exitImmediately();
    }
    st=null ;
    return br.readLine();
  }
  private static String nextToken()throws IOException {
    while(st==null || ! st.hasMoreTokens()){
      if(! br.ready()){
        exitImmediately();
      }
      st=new StringTokenizer(br.readLine().trim());
    }
    return st.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile;
  static   attribute st : OclIterator;
  static   attribute pw : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ; 
    var qq : int ; qq := 2147483647 ;
        var casenum : int ; casenum := 1 ; while casenum <= qq do ( (     var n : int ; n := readInt() ;
     var a : int ; a := readInt() ;
     var b : int ; b := readInt() ;
     if (a mod 2 = b mod 2) then (     skip ) else (     skip ) )  ;     casenum := casenum + 1 ) ; 
    execute exitImmediately() ; 
 );
  static   operation exitImmediately() : void
  pre: true
  post: true
  activity: (     skip ; 
 OclProcess.exit(0) );
  static   operation readLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
  static   operation readDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
  static   operation readInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (not(br.canRead())) then (     execute exitImmediately() ) else skip ; 
     st := null ; 
     return br.readLine() );
  static   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     if (not(br.canRead())) then (     execute exitImmediately() ) else skip ; 
     st := OclIterator.newOclIterator_String(br.readLine()->trim()) ) ; 
     return st.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.abs ;
import static java.lang.Math.pow ;
import static java.lang.System.*;
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static int[] freq=new int[1001];
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    String word=sc.next();
    int counter=0 ;
    for(int i=0 ; i<word.length()/2 ; i++){
      if(word.charAt(i)==word.charAt(word.length()-1-i))counter++;
    }
    if(counter==(word.length()/2)-1)out.println("YES");
    else if(word.length()% 2!=0 && counter==word.length()/2)out.println("YES");
    else out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute freq : Sequence(int) := Integer.subrange(1,1001)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var word : String ; word := sc.getCurrent() ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < word->size() / 2 do ( (     if (word->at(i+1) = word->at(word->size() - 1 - i+1)) then     counter := counter + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (counter = (word->size() / 2) - 1) then     out.println("YES") else     if (word->size() mod 2 /= 0 & counter = word->size() / 2) then     out.println("YES") else     out.println("NO") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  FastScanner in ;
  PrintWriter out ;
  void solve(){
    int n=in.nextInt();
    int a=in.nextInt();
    int b=in.nextInt();
    int dist=Math.abs(b-a)% 2 ;
    out.println(dist==1 ? "Borys" : "Alice");
  }
  void run(){
    try {
      in=new FastScanner(new File("Main.in"));
      out=new PrintWriter(new File("Main.out"));
      solve();
      out.close();
    }
    catch(FileNotFoundException e){
      e.printStackTrace();
    }
  }
  void runIO(){
    in=new FastScanner(System.in);
    out=new PrintWriter(System.out);
    solve();
    out.close();
  }
  class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(File f){
      try {
        br=new BufferedReader(new FileReader(f));
      }
      catch(FileNotFoundException e){
        e.printStackTrace();
      }
    }
    public FastScanner(InputStream f){
      br=new BufferedReader(new InputStreamReader(f));
    }
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        String s=null ;
        try {
          s=br.readLine();
        }
        catch(IOException e){
          e.printStackTrace();
        }
        if(s==null)return null ;
        st=new StringTokenizer(s);
      }
      return st.nextToken();
    }
    boolean hasMoreTokens(){
      while(st==null || ! st.hasMoreTokens()){
        String s=null ;
        try {
          s=br.readLine();
        }
        catch(IOException e){
          e.printStackTrace();
        }
        if(s==null)return false ;
        st=new StringTokenizer(s);
      }
      return true ;
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
  public static void main(String[] args){
    new Main().runIO();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : FastScanner;
   attribute out : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var a : int ; a := in.nextInt() ;
    var b : int ; b := in.nextInt() ;
    var dist : int ; dist := if b - a < 0 then -(b - a) else b - a endif mod 2 ;
    skip ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     in := FastScanner.newFastScanner(OclFile("Main.in")) ; 
     out := OclFile.newOclFile_Write(OclFile("Main.out")) ; 
     execute solve() ; 
     skip )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
 );
   operation runIO() : void
  pre: true
  post: true
  activity: (     in := FastScanner.newFastScanner(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     execute solve() ; 
     skip );
 class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( f : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(f)) )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
 );
   static operation newFastScanner( f : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(f)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     var s : String ; s := null ;
     try (     s := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     if (s = null) then     return null else skip ; 
     st := OclIterator.newOclIterator_String(s) ) ; 
     return st.next() );
   operation hasMoreTokens() : boolean
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     var s : String ; s := null ;
     try (     s := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     if (s = null) then     return false else skip ; 
     st := OclIterator.newOclIterator_String(s) ) ; 
     return true );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().runIO() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),b=in.nextInt(),even=0,odd=0,c=0 ;
    int[] a=new int[n];
    ArrayList<Integer>costs=new ArrayList();
    for(int i=0 ; i<n ; i++)a[i]=in.nextInt();
    for(int i=0,j=1 ; i<n-1 ; i++,j++){
      if(a[i] % 2==0)even++;
      else odd++;
      if(even==odd)costs.add(Math.abs(a[j]-a[i]));
    }
    Collections.sort(costs);
    for(int i=0 ; i<costs.size(); i++){
      b-=costs.get(i);
      if(b<0)break ;
      c++;
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var even : int ; even := 0 ;
    var odd : int ; odd := 0 ;
    var c : int ; c := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var costs : Sequence(int) ; costs := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ;
    var j : int ; j := 1 ; while i < n - 1 do ( (     if (a[i+1] mod 2 = 0) then     even := even + 1 else     odd := odd + 1 ; ;  
     if (even = odd) then     costs := costs->including(if a[j+1] - a[i+1] < 0 then -(a[j+1] - a[i+1]) else a[j+1] - a[i+1] endif) ; else skip )  ;     i := i + 1 ;     j := j + 1 ) ; 
    costs := costs->sort() ; 
        var i : int ; i := 0 ; while i < costs->size() do ( (     b := b-(costs->at(i+1)) ; 
     if (b < 0) then     break else skip ; 
     c := c + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] nab=br.readLine().split(" ");
    int n=Integer.parseInt(nab[0]);
    int a=Integer.parseInt(nab[1]);
    int b=Integer.parseInt(nab[2]);
    String ans ;
    if(Math.abs(a-b)% 2==1){
      ans="Borys" ;
    }
    else {
      ans="Alice" ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var nab : Sequence(String) ; nab := br.readLine()->split(" ") ;
    var n : int ; n := (nab[0+1])->toInteger() ;
    var a : int ; a := (nab[1+1])->toInteger() ;
    var b : int ; b := (nab[2+1])->toInteger() ;
    var ans : String ;
    if (if a - b < 0 then -(a - b) else a - b endif mod 2 = 1) then (     ans := "Borys" ) else (     ans := "Alice" ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int len=sc.nextInt();
    int[] array=new int[len];
    int A=sc.nextInt();
    int B=sc.nextInt();
    int A_flag=0 ;
    int B_flag=0 ;
    if((B-A-1)% 2==1){
      System.out.println("Alice");
    }
    else if((B-A-1)% 2==0){
      System.out.println("Borys");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,len)->collect(0) ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var A_flag : int ; A_flag := 0 ;
    var B_flag : int ; B_flag := 0 ;
    if ((B - A - 1) mod 2 = 1) then (     OclFile["System.out"].println("Alice") ) else     if ((B - A - 1) mod 2 = 0) then (     OclFile["System.out"].println("Borys") ) else skip ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int sho=0 ;
    int amrS=0 ;
    int ans=0 ;
    for(int i=1 ; i<n+1 ; i++){
      sho=i ;
      amrS=0 ;
      while(sho!=0){
        amrS+=sho % 10 ;
        sho/=10 ;
      }
      if(amrS>=a && amrS<=b){
        ans+=i ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var sho : int ; sho := 0 ;
    var amrS : int ; amrS := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     sho := i ; 
     amrS := 0 ; 
     while (sho /= 0) do (     amrS := amrS+(sho mod 10) ; 
     sho := sho/(10) ) ; 
     if (amrS >= a & amrS <= b) then (     ans := ans+(i) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ABC083BSomeSums solver=new ABC083BSomeSums();
    solver.solve(1,in,out);
    out.close();
  }
  static class ABC083BSomeSums {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=Integer.parseInt(in.next());
      int a=Integer.parseInt(in.next());
      int b=Integer.parseInt(in.next());
      int ans=0 ;
      for(int i=1 ; i<=n ; i++){
        int sum=someDigits(i);
        if(sum>=a && sum<=b){
          ans+=i ;
        }
      }
      System.out.println(String.valueOf(ans));
    }
    private int someDigits(int i){
      int sum=0 ;
      while(i>0){
        sum+=i % 10 ;
        i/=10 ;
      }
      return sum ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ABC083BSomeSums ; solver := ABC083BSomeSums.newABC083BSomeSums() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ABC083BSomeSums {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (in.getCurrent())->toInteger() ;
     var a : int ; a := (in.getCurrent())->toInteger() ;
    var b : int ; b := (in.getCurrent())->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var sum : int ; sum := someDigits(i) ;
     if (sum >= a & sum <= b) then (     ans := ans+(i) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(((ans) + "")) ; 
 );
   operation someDigits( i : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (i > 0) do (     sum := sum+(i mod 10) ; 
     i := i/(10) ) ; 
     return sum );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] temp=br.readLine().split(" ");
    int N=Integer.parseInt(temp[0]);
    int A=Integer.parseInt(temp[1]);
    int B=Integer.parseInt(temp[2]);
    int tempSum=0,sumAns=0 ;
    for(int i=1 ; i<=N ; i++){
      int n=i ;
      while(n>0){
        tempSum+=n % 10 ;
        n/=10 ;
      }
      if(A<=tempSum && tempSum<=B){
        sumAns+=i ;
      }
      tempSum=0 ;
    }
    System.out.println(sumAns);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
    var N : int ; N := (temp[0+1])->toInteger() ;
    var A : int ; A := (temp[1+1])->toInteger() ;
    var B : int ; B := (temp[2+1])->toInteger() ;
    var tempSum : int ; tempSum := 0 ;
    var sumAns : int ; sumAns := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     var n : int ; n := i ;
     while (n > 0) do (     tempSum := tempSum+(n mod 10) ; 
     n := n/(10) ) ; 
     if (A <= tempSum & tempSum <= B) then (     sumAns := sumAns+(i) ) else skip ; 
     tempSum := 0 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sumAns) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static int sumDigit(int num){
    int sum=0 ;
    int n=num ;
    while(n>0){
      sum+=n % 10 ;
      n=n/10 ;
    }
    return sum ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int A=sc.nextInt();
    int B=sc.nextInt();
    int sumnum=0 ;
    for(int i=1 ; i<N+1 ; i++){
      if(A<=sumDigit(i)&& sumDigit(i)<=B){
        sumnum+=i ;
      }
    }
    System.out.println(sumnum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation sumDigit( num : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var n : int ; n := num ;
     while (n > 0) do (     sum := sum+(n mod 10) ; 
     n := n / 10 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var sumnum : int ; sumnum := 0 ;
        var i : int ; i := 1 ; while i < N + 1 do ( (     if (A <= sumDigit(i) & sumDigit(i) <= B) then (     sumnum := sumnum+(i) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sumnum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final int n=sc.nextInt();
    final int a=sc.nextInt();
    final int b=sc.nextInt();
    int result=0 ;
    for(int i=1 ; i<=n ; i++){
      final String iList[]=(String.valueOf(i)).split("");
      int iTotal=0 ;
      for(final String item : iList){
        iTotal=iTotal+Integer.parseInt(item);
      }
      if(a<=iTotal && iTotal<=b){
        result=result+i ;
      }
    }
    System.out.print(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var result : int ; result := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var iList : Sequence(String) ; iList := (((i) + ""))->split("") ;
     var iTotal : int ; iTotal := 0 ;
     for (item : iList) do ( (     iTotal := iTotal + (item)->toInteger() )  ) ; 
     if (a <= iTotal & iTotal <= b) then (     result := result + i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void print_asterisk(int asterisk){
    if(asterisk==0)return ;
    System.out.print("*");
    print_asterisk(asterisk-1);
  }
  static void pattern_upper(int n,int num){
    if(n==0)return ;
    print_asterisk(n);
    System.out.println();
    pattern_upper(n-1,num);
  }
  static void pattern_lower(int n,int num){
    if(n==0)return ;
    print_asterisk(num-n+1);
    System.out.println();
    pattern_lower(n-1,num);
  }
  static void pattern(int n,int num){
    pattern_upper(n,num);
    pattern_lower(n-1,num);
  }
  public static void main(String[] args){
    int n=5 ;
    pattern(n,n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation print_asterisk( asterisk : int) : void
  pre: true
  post: true
  activity: (     if (asterisk = 0) then     return else skip ; 
     OclFile["System.out"].print("*") ; 
     execute print_asterisk(asterisk - 1) );
  static   operation pattern_upper( n : int, num : int) : void
  pre: true
  post: true
  activity: (     if (n = 0) then     return else skip ; 
     execute print_asterisk(n) ; 
     OclFile["System.out"].println() ; 
     execute pattern_upper(n - 1, num) );
  static   operation pattern_lower( n : int, num : int) : void
  pre: true
  post: true
  activity: (     if (n = 0) then     return else skip ; 
     execute print_asterisk(num - n + 1) ; 
     OclFile["System.out"].println() ; 
     execute pattern_lower(n - 1, num) );
  static   operation pattern( n : int, num : int) : void
  pre: true
  post: true
  activity: (     execute pattern_upper(n, num) ; 
     execute pattern_lower(n - 1, num) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute pattern(n, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void print_asterisk(int asterisk){
    if(asterisk==0)return ;
    System.out.print("*");
    print_asterisk(asterisk-1);
  }
  static void print_space(int space){
    if(space==0)return ;
    System.out.print(" ");
    System.out.print(" ");
    print_space(space-1);
  }
  static void pattern_upper(int n,int num){
    if(n==0)return ;
    print_asterisk(n);
    print_space(2*(num-n)+1);
    print_asterisk(n);
    System.out.print("\n");
    pattern_upper(n-1,num);
  }
  static void pattern_lower(int n,int num){
    if(n==0)return ;
    print_asterisk(num-n+1);
    print_space(2*n-1);
    print_asterisk(num-n+1);
    System.out.print("\n");
    pattern_lower(n-1,num);
  }
  static void pattern(int n,int num){
    pattern_upper(n,num);
    pattern_lower(n-1,num);
  }
  public static void main(String[] args){
    int n=5 ;
    pattern(n,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation print_asterisk( asterisk : int) : void
  pre: true
  post: true
  activity: (     if (asterisk = 0) then     return else skip ; 
     OclFile["System.out"].print("*") ; 
     execute print_asterisk(asterisk - 1) );
  static   operation print_space( space : int) : void
  pre: true
  post: true
  activity: (     if (space = 0) then     return else skip ; 
     OclFile["System.out"].print(" ") ; 
     OclFile["System.out"].print(" ") ; 
     execute print_space(space - 1) );
  static   operation pattern_upper( n : int, num : int) : void
  pre: true
  post: true
  activity: (     if (n = 0) then     return else skip ; 
     execute print_asterisk(n) ; 
    execute print_space(2 * (num - n) + 1) ; 
    execute print_asterisk(n) ; 
    OclFile["System.out"].print("\n") ; 
    execute pattern_upper(n - 1, num) ; 
 );
  static   operation pattern_lower( n : int, num : int) : void
  pre: true
  post: true
  activity: (     if (n = 0) then     return else skip ; 
     execute print_asterisk(num - n + 1) ; 
    execute print_space(2 * n - 1) ; 
    execute print_asterisk(num - n + 1) ; 
    OclFile["System.out"].print("\n") ; 
    execute pattern_lower(n - 1, num) ; 
 );
  static   operation pattern( n : int, num : int) : void
  pre: true
  post: true
  activity: (     execute pattern_upper(n, num) ; 
     execute pattern_lower(n - 1, num) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute pattern(n, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    if(reverse(s)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
  public static boolean reverse(String s){
    if(s.length()==1){
      return true ;
    }
    int mid=s.length()/2 ;
    int count=0 ;
    if(s.length()% 2==0){
      for(int i=0 ; i<mid ; i++){
        if(s.charAt(i)!=s.charAt(s.length()-1-i)){
          count++;
        }
      }
      return count==1 ;
    }
    else {
      for(int i=0 ; i<mid ; i++){
        if(s.charAt(i)!=s.charAt(s.length()-1-i)){
          count++;
        }
      }
      return count==0 || count==1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
     if (reverse(s)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
  static   operation reverse( s : String) : boolean
  pre: true
  post: true
  activity: (     if (s->size() = 1) then (     return true ) else skip ; 
     var mid : int ; mid := s->size() / 2 ;
     var count : int ; count := 0 ;
     if (s->size() mod 2 = 0) then (         var i : int ; i := 0 ; while i < mid do ( (     if (s->at(i+1) /= s->at(s->size() - 1 - i+1)) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     return count = 1 ) else (         var i : int ; i := 0 ; while i < mid do ( (     if (s->at(i+1) /= s->at(s->size() - 1 - i+1)) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     return count = 0 or count = 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf1535A {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int i=1 ; i<=t ; i++){
      int[] a=new int[4];
      for(int k=0 ; k<4 ; k++)a[k]=input.nextInt();
      if(Math.max(a[0],a[1])>Math.min(a[2],a[3])&& Math.max(a[2],a[3])>Math.min(a[0],a[1]))System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1535A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= t do ( (     var a : Sequence(int) ; a := Integer.subrange(1,4)->collect(0) ;
         var k : int ; k := 0 ; while k < 4 do (     a[k+1] := input.getCurrent()->toInteger() ;  ;     k := k + 1 ) ; 
     if (Set{a[0+1], a[1+1]}->max() > Set{a[2+1], a[3+1]}->min() & Set{a[2+1], a[3+1]}->max() > Set{a[0+1], a[1+1]}->min()) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int N=in.nextInt();
    int cash=in.nextInt();
    int[] A=new int[N];
    for(int n=0 ; n<N ; n++){
      A[n]=in.nextInt();
    }
    int even=0 ;
    int[] cuts=new int[100];
    for(int n=0 ; n<N-1 ; n++){
      if(A[n] % 2==0){
        even++;
      }
      if(2*even==n+1){
        cuts[Math.abs(A[n+1]-A[n])]++;
      }
    }
    int answer=cuts[0];
    for(int i=1 ; i<cuts.length ; i++){
      int use=Math.min(cuts[i],cash/i);
      answer+=use ;
      cash-=use*i ;
    }
    pw.println(answer);
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var cash : int ; cash := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var even : int ; even := 0 ;
    var cuts : Sequence(int) ; cuts := Integer.subrange(1,100)->collect(0) ;
        var n : int ; n := 0 ; while n < N - 1 do ( (     if (A[n+1] mod 2 = 0) then (     even := even + 1 ) else skip ; 
     if (2 * even = n + 1) then (     cuts[if A[n + 1+1] - A[n+1] < 0 then -(A[n + 1+1] - A[n+1]) else A[n + 1+1] - A[n+1] endif+1] := cuts[if A[n + 1+1] - A[n+1] < 0 then -(A[n + 1+1] - A[n+1]) else A[n + 1+1] - A[n+1] endif+1] + 1 ) else skip )  ;     n := n + 1 ) ; 
    var answer : int ; answer := cuts[0+1] ;
        var i : int ; i := 1 ; while i < cuts->size() do ( (     var use : int ; use := Set{cuts[i+1], cash / i}->min() ;
     answer := answer+(use) ; 
     cash := cash-(use * i) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void print_asterisk(int asterisk){
    if(asterisk==0)return ;
    System.out.print("*");
    print_asterisk(asterisk-1);
  }
  static void print_space(int space){
    if(space==0)return ;
    System.out.print(" ");
    System.out.print(" ");
    print_space(space-1);
  }
  static void pattern_upper(int n,int num){
    if(n==0)return ;
    print_asterisk(num-n+1);
    print_space(2*n-1);
    print_asterisk(num-n+1);
    System.out.println();
    pattern_upper(n-1,num);
  }
  static void pattern_lower(int n,int num){
    if(n==0)return ;
    print_asterisk(n);
    print_space(2*(num-n)+1);
    print_asterisk(n);
    System.out.println();
    pattern_lower(n-1,num);
  }
  static void pattern(int n,int num){
    pattern_upper(n,num);
    pattern_lower(n-1,num);
  }
  public static void main(String[] args){
    int n=5 ;
    pattern(n,n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation print_asterisk( asterisk : int) : void
  pre: true
  post: true
  activity: (     if (asterisk = 0) then     return else skip ; 
     OclFile["System.out"].print("*") ; 
     execute print_asterisk(asterisk - 1) );
  static   operation print_space( space : int) : void
  pre: true
  post: true
  activity: (     if (space = 0) then     return else skip ; 
     OclFile["System.out"].print(" ") ; 
     OclFile["System.out"].print(" ") ; 
     execute print_space(space - 1) );
  static   operation pattern_upper( n : int, num : int) : void
  pre: true
  post: true
  activity: (     if (n = 0) then     return else skip ; 
     execute print_asterisk(num - n + 1) ; 
    execute print_space(2 * n - 1) ; 
    execute print_asterisk(num - n + 1) ; 
    OclFile["System.out"].println() ; 
    execute pattern_upper(n - 1, num) ; 
 );
  static   operation pattern_lower( n : int, num : int) : void
  pre: true
  post: true
  activity: (     if (n = 0) then     return else skip ; 
     execute print_asterisk(n) ; 
    execute print_space(2 * (num - n) + 1) ; 
    execute print_asterisk(n) ; 
    OclFile["System.out"].println() ; 
    execute pattern_lower(n - 1, num) ; 
 );
  static   operation pattern( n : int, num : int) : void
  pre: true
  post: true
  activity: (     execute pattern_upper(n, num) ; 
     execute pattern_lower(n - 1, num) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute pattern(n, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int dfs(int node,int parent,Vector<Integer>[] adj,boolean[] vis){
    int ans=1 ;
    vis[node]=true ;
    for(Integer it : adj[node]){
      if(it!=parent)ans+=dfs(it,node,adj,vis);
    }
    return ans ;
  }
  static int countPaths(Vector<Integer>[] adj,int k,int maxn){
    boolean[] vis=new boolean[maxn+1];
    int ans=0 ;
    Arrays.fill(vis,false);
    for(int i=1 ; i<=maxn ; i++){
      if(! vis[i]){
        int numNodes=dfs(i,0,adj,vis);
        ans+=numNodes*(numNodes-1)/2 ;
      }
    }
    return ans ;
  }
  static void addEdge(Vector<Integer>[] adj,int u,int v,int k){
    if(u>k && v>k){
      adj[u] .add(v);
      adj[v] .add(u);
    }
  }
  public static void main(String[] args){
    int maxn=12 ;
    @ SuppressWarnings("unchecked")Vector<Integer>[] adj=new Vector[maxn+1];
    for(int i=0 ; i<maxn+1 ; i++){
      adj[i]=new Vector<>();
    }
    int k=3 ;
    addEdge(adj,2,11,k);
    addEdge(adj,2,6,k);
    addEdge(adj,5,11,k);
    addEdge(adj,5,10,k);
    addEdge(adj,5,12,k);
    addEdge(adj,6,7,k);
    addEdge(adj,6,8,k);
    System.out.println(countPaths(adj,k,maxn));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation dfs( node : int, parent : int, adj : Sequence(Sequence(int)), vis : Sequence(boolean)) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
     vis[node+1] := true ; 
     for (it : adj[node+1]) do ( (     if (it /= parent) then     ans := ans+(dfs(it, node, adj, vis)) ; else skip )  ) ; 
     return ans );
  static   operation countPaths( adj : Sequence(Sequence(int)), k : int, maxn : int) : int
  pre: true
  post: true
  activity: (     var vis : Sequence(boolean) ; vis := Integer.subrange(1,maxn + 1)->collect(false) ;
     var ans : int ; ans := 0 ;
    vis := vis->collect(false) ; 
        var i : int ; i := 1 ; while i <= maxn do ( (     if (not(vis[i+1])) then (     var numNodes : int ; numNodes := dfs(i, 0, adj, vis) ;
     ans := ans+(numNodes * (numNodes - 1) / 2) ) else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation addEdge( adj : Sequence(Sequence(int)), u : int, v : int, k : int) : void
  pre: true
  post: true
  activity: (     if (u > k & v > k) then (     adj[u+1]->excludes(v) ; 
     adj[v+1]->excludes(u) ) else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var maxn : int ; maxn := 12 ;
     var adj : Sequence(Sequence(int)) ; adj := Integer.subrange(1,maxn + 1)->collect(null) ;
        var i : int ; i := 0 ; while i < maxn + 1 do ( (     adj[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
    var k : int ; k := 3 ;
    execute addEdge(adj, 2, 11, k) ; 
    execute addEdge(adj, 2, 6, k) ; 
    execute addEdge(adj, 5, 11, k) ; 
    execute addEdge(adj, 5, 10, k) ; 
    execute addEdge(adj, 5, 12, k) ; 
    execute addEdge(adj, 6, 7, k) ; 
    execute addEdge(adj, 6, 8, k) ; 
    OclFile["System.out"].println(countPaths(adj, k, maxn)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPalindrome(char[] str){
    int len=str.length ;
    if(len==1)return true ;
    char ptr1=str[0];
    char ptr2=str[len-1];
    while(ptr2>ptr1){
      if(ptr1!=ptr2)return false ;
      ptr1++;
      ptr2--;
    }
    return true ;
  }
  static int noOfAppends(String s){
    if(isPalindrome(s.toCharArray()))return 0 ;
    s=s.substring(1);
    return 1+noOfAppends(s);
  }
  public static void main(String arr[]){
    String s="abede" ;
    System.out.printf("%d\n",noOfAppends(s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPalindrome( str : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     if (len = 1) then     return true else skip ; 
    var ptr1 : String ; ptr1 := str[0+1] ;
    var ptr2 : String ; ptr2 := str[len - 1+1] ;
    while (ptr2 > ptr1) do (     if (ptr1 /= ptr2) then     return false else skip ; 
     ptr1 := ptr1 + 1 ; 
     ptr2 := ptr2 - 1 ) ; 
    return true 
 );
  static   operation noOfAppends( s : String) : int
  pre: true
  post: true
  activity: (     if (isPalindrome(s->characters())) then     return 0 else skip ; 
     s := s.subrange(1+1,1) ; 
     return 1 + noOfAppends(s) );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abede" ;
     OclFile["System.out"].printf("%d\n", noOfAppends(s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static int power(int x,int y,int p){
    int res=1 ;
    x=x % p ;
    while(y>0){
      if((y & 1)==1)res=(res*x)% p ;
      y=y>>1 ;
      x=(x*x)% p ;
    }
    return res ;
  }
  static boolean miillerTest(int d,int n){
    int a=2+(int)(Math.random()%(n-4));
    int x=power(a,d,n);
    if(x==1 || x==n-1)return true ;
    while(d!=n-1){
      x=(x*x)% n ;
      d*=2 ;
      if(x==1)return false ;
      if(x==n-1)return true ;
    }
    return false ;
  }
  static boolean isPrime(int n,int k){
    if(n<=1 || n==4)return false ;
    if(n<=3)return true ;
    int d=n-1 ;
    while(d % 2==0)d/=2 ;
    for(int i=0 ; i<k ; i++)if(! miillerTest(d,n))return false ;
    return true ;
  }
  public static void main(String args[]){
    int k=4 ;
    System.out.println("All primes smaller "+"than 100: ");
    for(int n=1 ; n<100 ; n++)if(isPrime(n,k))System.out.print(n+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation power( x : int, y : int, p : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     if ((y & 1) = 1) then     res := (res * x) mod p ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res );
  static   operation miillerTest( d : int, n : int) : boolean
  pre: true
  post: true
  activity: (     var a : int ; a := 2 + (MathLib.random() mod (n - 4))->oclAsType(int) ;
     var x : int ; x := power(a, d, n) ;
    if (x = 1 or x = n - 1) then     return true else skip ; 
    while (d /= n - 1) do (     x := (x * x) mod n ; 
     d := d*(2) ; 
     if (x = 1) then     return false else skip ; 
     if (x = n - 1) then     return true else skip ) ; 
    return false 
 );
  static   operation isPrime( n : int, k : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1 or n = 4) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    var d : int ; d := n - 1 ;
    while (d mod 2 = 0) do     d := d/(2) ; ; 
        var i : int ; i := 0 ; while i < k do (     if (not(miillerTest(d, n))) then     return false else skip ;  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 4 ;
     OclFile["System.out"].println("All primes smaller " + "than 100: ") ; 
         var n : int ; n := 1 ; while n < 100 do (     if (isPrime(n, k)) then     OclFile["System.out"].print(n + " ") ; else skip ;  ;     n := n + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class RelativelyPrime {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long l=sc.nextLong();
    long r=sc.nextLong();
    System.out.println("YES");
    for(long i=l ; i<r ; i+=2){
      System.out.println(i+" "+(i+1));
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class RelativelyPrime {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : long ; l := sc.getCurrent()->toLong() ;
    var r : long ; r := sc.getCurrent()->toLong() ;
    OclFile["System.out"].println("YES") ; 
        var i : long ; i := l ; while i < r do ( (     OclFile["System.out"].println(i + " " + (i + 1)) )  ;     i := i+(2) ) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class RelativelyPrimePair {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    long left=scn.nextLong();
    long right=scn.nextLong();
    System.out.println("YES");
    for(long i=left ; i<right ; i+=2){
      System.out.println(i+" "+(i+1));
    }
    scn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class RelativelyPrimePair {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var left : long ; left := scn.getCurrent()->toLong() ;
    var right : long ; right := scn.getCurrent()->toLong() ;
    OclFile["System.out"].println("YES") ; 
        var i : long ; i := left ; while i < right do ( (     OclFile["System.out"].println(i + " " + (i + 1)) )  ;     i := i+(2) ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] $){
    long a=scanner.nextInt(),b=scanner.nextInt(),c=scanner.nextInt();
    System.out.println(a % 2+b % 2+c % 2==3 ? Math.min(Math.min(a*b,b*c),c*a): 0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ; a := scanner.getCurrent()->toInteger() ;
    var b : long ; b := scanner.getCurrent()->toInteger() ;
    var c : long ; c := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if a mod 2 + b mod 2 + c mod 2 = 3 then Set{Set{a * b, b * c}->min(), c * a}->min() else 0 endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static Scanner sc ;
  private static Printer pr ;
  private static void solve(){
    long a=sc.nextInt();
    long b=sc.nextInt();
    long c=sc.nextInt();
    if(a % 2==0 || b % 2==0 || c % 2==0){
      pr.println(0);
    }
    else {
      long min=Long.MAX_VALUE ;
      min=Math.min(min,a*b);
      min=Math.min(min,b*c);
      min=Math.min(min,c*a);
      pr.println(min);
    }
  }
  public static void main(String[] args){
    sc=new Scanner(System.in);
    pr=new Printer(System.out);
    solve();
    pr.close();
    sc.close();
  }
  private static class Printer extends PrintWriter {
    Printer(PrintStream out){
      super(out);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile;
  static   attribute pr : Printer;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var a : long ; a := sc.getCurrent()->toInteger() ;
     var b : long ; b := sc.getCurrent()->toInteger() ;
     var c : long ; c := sc.getCurrent()->toInteger() ;
     if (a mod 2 = 0 or b mod 2 = 0 or c mod 2 = 0) then (     pr.println(0) ) else (     var min : long ; min := "9223372036854775807"->toLong() ;
     min := Set{min, a * b}->min() ; 
    min := Set{min, b * c}->min() ; 
    min := Set{min, c * a}->min() ; 
    pr.println(min) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     pr := Printer.newPrinter(OclFile["System.out"]) ; 
    execute solve() ; 
    pr.close() ; 
    skip ; 
 );
  static class Printer extends OclFile {
   static operation newPrinter( out : OclFile) : Printer
  pre: true
  post: true
  activity:
  ( var self : Printer ;
    self := createPrinter();
    self.initialise(out);
    return self );
  operation initialise( out : OclFile) : void
  pre: true  post: true
  activity: (     execute super(out) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    long A=nl();
    long B=nl();
    long C=nl();
    long diff=Long.MAX_VALUE ;
    diff=Math.min(diff,(long)(Math.ceil(A/2.0)-Math.floor(A/2.0))*B*C);
    diff=Math.min(diff,(long)(Math.ceil(B/2.0)-Math.floor(B/2.0))*A*C);
    diff=Math.min(diff,(long)(Math.ceil(C/2.0)-Math.floor(C/2.0))*B*A);
    out.println(diff);
  }
  static int ni(){
    return sc.nextInt();
  }
  static long nl(){
    return sc.nextLong();
  }
  static String ns(){
    return sc.next();
  }
  static int[] niarr(int N){
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextInt();
    }
    return a ;
  }
  static long[] nlarr(int N){
    long[] a=new long[N];
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextLong();
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : long ; A := nl() ;
     var B : long ; B := nl() ;
    var C : long ; C := nl() ;
    var diff : long ; diff := "9223372036854775807"->toLong() ;
    diff := Set{diff, ((A / 2.0)->ceil() - (A / 2.0)->floor())->oclAsType(long) * B * C}->min() ; 
    diff := Set{diff, ((B / 2.0)->ceil() - (B / 2.0)->floor())->oclAsType(long) * A * C}->min() ; 
    diff := Set{diff, ((C / 2.0)->ceil() - (C / 2.0)->floor())->oclAsType(long) * B * A}->min() ; 
    out.println(diff) ; 
 );
  static   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
  static   operation nl() : long
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toLong() );
  static   operation ns() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
  static   operation niarr( N : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
         var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return a );
  static   operation nlarr( N : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,N)->collect(0) ;
         var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class TestJava {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int size=s.nextInt();
    int b=s.nextInt();
    int arr[]=new int[size];
    for(int i=0 ; i<arr.length ; i++)arr[i]=s.nextInt();
    int odd=0 ;
    int even=0 ;
    ArrayList<Integer>ls=new ArrayList<>();
    for(int i=0 ; i<arr.length ; i++){
      if(i!=0 && odd==even){
        ls.add(Math.abs(arr[i]-arr[i-1]));
      }
      if(arr[i] % 2==0)even++;
      else odd++;
    }
    Collections.sort(ls);
    int ans=0 ;
    for(int i=0 ; i<ls.size(); i++){
      if(b>=ls.get(i)){
        ans++;
        b-=ls.get(i);
      }
      else break ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class TestJava {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var size : int ; size := s.getCurrent()->toInteger() ;
    var b : int ; b := s.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do (     arr[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var odd : int ; odd := 0 ;
    var even : int ; even := 0 ;
    var ls : Sequence(int) ; ls := Sequence{} ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (i /= 0 & odd = even) then (     ls := ls->including(if arr[i+1] - arr[i - 1+1] < 0 then -(arr[i+1] - arr[i - 1+1]) else arr[i+1] - arr[i - 1+1] endif) ) else skip ; 
     if (arr[i+1] mod 2 = 0) then     even := even + 1 ; else     odd := odd + 1 ; )  ;     i := i + 1 ) ; 
    ls := ls->sort() ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < ls->size() do ( (     if (b >= ls->at(i+1)) then (     ans := ans + 1 ; 
     b := b-(ls->at(i+1)) ) else     break )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class mikepal {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int n=s.length();
    int count=0 ;
    for(int i=0 ; i<n/2 ; i++){
      if(s.charAt(i)!=s.charAt(n-1-i))count++;
    }
    System.out.println(count<=1 && n % 2==1 ? "YES" : count==1 ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class mikepal {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var n : int ; n := s->size() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n / 2 do ( (     if (s->at(i+1) /= s->at((n)->char2byte() - 1 - i+1)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if count <= 1 & n mod 2 = 1 then "YES" else if count = 1 then "YES" else "NO" endif endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    long a=sc.nextLong();
    long b=sc.nextLong();
    long c=sc.nextLong();
    if(a % 2==0 || b % 2==0 || c % 2==0){
      System.out.println(0);
    }
    else {
      System.out.println(Math.min(a*b,Math.min(b*c,c*a)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
     var c : long ; c := sc.getCurrent()->toLong() ;
     if (a mod 2 = 0 or b mod 2 = 0 or c mod 2 = 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(Set{a * b, Set{b * c, c * a}->min()}->min()) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static void myout(Object t){
    System.out.println(t);
  }
  static void myerr(Object t){
    System.err.println(t);
  }
  static String getStr(){
    return sc.next();
  }
  static int getInt(){
    return sc.nextInt();
  }
  static Long getLong(){
    return sc.nextLong();
  }
  static boolean isNext(){
    return sc.hasNext();
  }
  static char[] splitSingle(String str){
    return str.toCharArray();
  }
  public static void main(String[] args){
    long A=getLong();
    long B=getLong();
    long C=getLong();
    if(A % 2==0 || B % 2==0 || C % 2==0){
      myout(0);
      return ;
    }
    else {
      myout(Math.min(A*B,Math.min(A*C,B*C)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation myout( t : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(t) );
  static   operation myerr( t : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println(t) );
  static   operation getStr() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
  static   operation getLong() : long
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toLong() );
  static   operation isNext() : boolean
  pre: true
  post: true
  activity: (     return sc.hasNext() );
  static   operation splitSingle( str : String) : Sequence(String)
  pre: true
  post: true
  activity: (     return str->characters() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : long ; A := getLong() ;
     var B : long ; B := getLong() ;
     var C : long ; C := getLong() ;
     if (A mod 2 = 0 or B mod 2 = 0 or C mod 2 = 0) then (     execute myout(0) ; 
     return ) else (     execute myout(Set{A * B, Set{A * C, B * C}->min()}->min()) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class RobotSequence {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),res=0 ;
    String s=sc.next();
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j+=2){
        if(countLRUD(s.substring(i,j+1))){
          res++;
        }
      }
    }
    System.out.print(res);
  }
  private static boolean countLRUD(String s){
    int cLR=0,cUD=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='L')cLR++;
      else if(s.charAt(i)=='R')cLR--;
      if(s.charAt(i)=='U')cUD++;
      else if(s.charAt(i)=='D')cUD--;
    }
    return cUD==0 && cLR==0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class RobotSequence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
    var s : String ; s := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (countLRUD(s.subrange(i+1,j + 1))) then (     res := res + 1 ) else skip )  ;     j := j+(2) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(res) ; 
 );
  static   operation countLRUD( s : String) : boolean
  pre: true
  post: true
  activity: (     var cLR : int ; cLR := 0 ;
    var cUD : int ; cUD := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'L') then     cLR := cLR + 1 else     if (s->at(i+1) = 'R') then     cLR := cLR - 1 ; else skip ; ;  
     if (s->at(i+1) = 'U') then     cUD := cUD + 1 ; else     if (s->at(i+1) = 'D') then     cUD := cUD - 1 ; else skip ; )  ;     i := i + 1 ) ; 
     return cUD = 0 & cLR = 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A {
  public static void main(String ar[])throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String S=br.readLine();
    int a[][]=new int[n][2];
    HashMap<String,Integer>hm=new HashMap<String,Integer>();
    int c=0 ;
    String ss1="0 0" ;
    hm.put(ss1,1);
    for(int i=0 ; i<n ; i++){
      if(i!=0){
        a[i][0]=a[i-1][0];
        a[i][1]=a[i-1][1];
      }
      if(S.charAt(i)=='L')a[i][0]--;
      else if(S.charAt(i)=='R')a[i][0]++;
      else if(S.charAt(i)=='U')a[i][1]++;
      else a[i][1]--;
      String ss=a[i][0]+" "+a[i][1];
      if(hm.containsKey(ss)){
        c+=hm.get(ss);
        hm.put(ss,1+hm.get(ss));
      }
      else hm.put(ss,1);
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( ar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var S : String ; S := br.readLine() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
    var hm : Map(String,int) ; hm := Map{} ;
    var c : int ; c := 0 ;
    var ss1 : String ; ss1 := "0 0" ;
    hm := hm->union(Map{ss1 |-> 1}) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i /= 0) then (     a[i+1][0+1] := a[(i)->char2byte() - 1+1][0+1] ; 
     a[i+1][1+1] := a[(i)->char2byte() - 1+1][1+1] ) else skip ; 
     if (S->at(i+1) = 'L') then     a[i+1][0+1] := a[i+1][0+1] - 1 else     if (S->at(i+1) = 'R') then     a[i+1][0+1] := a[i+1][0+1] + 1 else     if (S->at(i+1) = 'U') then     a[i+1][1+1] := a[i+1][1+1] + 1 else     a[i+1][1+1] := a[i+1][1+1] - 1 ; ;  ;  ;  
     var ss : String ; ss := a[i+1][0+1] + " " + a[i+1][1+1] ;
     if (hm->keys()->includes(ss)) then (     c := c+(hm->at(ss)) ; 
     hm := hm->union(Map{ss |-> 1 + hm->at(ss)}) ) else     hm := hm->union(Map{ss |-> 1}) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class abc {
  public static void main(String ar[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long ans=0L ;
    String s=sc.next();
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        int u=0 ;
        int d=0 ;
        int l=0 ;
        int r=0 ;
        String s1=s.substring(i,j+1);
        for(int k=0 ; k<s1.length(); k++){
          if(s1.charAt(k)=='U')u++;
          else if(s1.charAt(k)=='D')d++;
          else if(s1.charAt(k)=='L')l++;
          else r++;
        }
        if(u==d && l==r)ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class abc {
  static   operation main( ar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : long ; ans := 0L ;
    var s : String ; s := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var u : int ; u := 0 ;
     var d : int ; d := 0 ;
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    var s1 : String ; s1 := s.subrange(i+1,j + 1) ;
        var k : int ; k := 0 ; while k < s1->size() do ( (     if (s1->at(k+1) = 'U') then     u := u + 1 ; else     if (s1->at(k+1) = 'D') then     d := d + 1 else     if (s1->at(k+1) = 'L') then     l := l + 1 else     r := r + 1 ; ;  ;  )  ;     k := k + 1 ) ; 
    if (u = d & l = r) then     ans := ans + 1 ; else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class abc {
  public static void main(String ar[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long ans=0L ;
    String s=sc.next();
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        int u=0 ;
        int d=0 ;
        int l=0 ;
        int r=0 ;
        String s1=s.substring(i,j+1);
        for(int k=0 ; k<s1.length(); k++){
          if(s1.charAt(k)=='U')u++;
          else if(s1.charAt(k)=='D')d++;
          else if(s1.charAt(k)=='L')l++;
          else r++;
        }
        if(u==d && l==r)ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class abc {
  static   operation main( ar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : long ; ans := 0L ;
    var s : String ; s := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var u : int ; u := 0 ;
     var d : int ; d := 0 ;
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    var s1 : String ; s1 := s.subrange(i+1,j + 1) ;
        var k : int ; k := 0 ; while k < s1->size() do ( (     if (s1->at(k+1) = 'U') then     u := u + 1 ; else     if (s1->at(k+1) = 'D') then     d := d + 1 else     if (s1->at(k+1) = 'L') then     l := l + 1 else     r := r + 1 ; ;  ;  )  ;     k := k + 1 ) ; 
    if (u = d & l = r) then     ans := ans + 1 ; else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int countSubstringWithEqualEnds(String s){
    int result=0 ;
    int n=s.length();
    for(int i=0 ; i<n ; i++)for(int j=i ; j<n ; j++)if(s.charAt(i)==s.charAt(j))result++;
    return result ;
  }
  public static void main(String args[]){
    String s="abcab" ;
    System.out.println(countSubstringWithEqualEnds(s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSubstringWithEqualEnds( s : String) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var n : int ; n := s->size() ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i ; while j < n do (     if (s->at(i+1) = s->at(j+1)) then     result := result + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abcab" ;
     OclFile["System.out"].println(countSubstringWithEqualEnds(s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String m=scan.next();
    if(m.contains("ABC")|| m.contains("BAC")|| m.contains("BCA")|| m.contains("ACB")|| m.contains("CBA")|| m.contains("CAB"))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : String ; m := scan.getCurrent() ;
     if (m->includes("ABC") or m->includes("BAC") or m->includes("BCA") or m->includes("ACB") or m->includes("CBA") or m->includes("CAB")) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ABlend {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String s=input.next();
    for(int i=0 ; i<s.length()-2 ; i++){
      String z=s.substring(i,i+3);
      if(z.indexOf('.')==-1 && z.charAt(0)!=z.charAt(1)&& z.charAt(1)!=z.charAt(2)&& z.charAt(2)!=z.charAt(0)){
        System.out.println("Yes");
        return ;
      }
    }
    System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class ABlend {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := input.getCurrent() ;
         var i : int ; i := 0 ; while i < s->size() - 2 do ( (     var z : String ; z := s.subrange(i+1,i + 3) ;
     if (z->indexOf('.')-1 = -1 & z->at(0+1) /= z->at(1+1) & z->at(1+1) /= z->at(2+1) & z->at(2+1) /= z->at(0+1)) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("No") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ComplexButNotBoring {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String target=scan.next();
    int lastIndex=0 ;
    String possibles[]={
      "ABC","BCA","CAB","BAC","ACB","CBA" };
      for(int i=0 ; i<6 ; i++){
        if(target.indexOf(possibles[i])!=-1){
          System.out.println("YES");
          System.exit(0);
        }
      }
      System.out.println("NO");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class ComplexButNotBoring {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var target : String ; target := scan.getCurrent() ;
    var lastIndex : int ; lastIndex := 0 ;
    var possibles : Sequence(String) ; possibles := Sequence{"ABC","BCA","CAB","BAC","ACB","CBA"} ;
        var i : int ; i := 0 ; while i < 6 do ( (     if (target->indexOf(possibles[i+1])-1 /= -1) then (     OclFile["System.out"].println("YES") ; 
 OclProcess.exit(0) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner read=new Scanner(System.in);
    String s=read.nextLine();
    String result="NO" ;
    for(int i=0 ; i<s.length()-2 ; ++i){
      char firstChar=s.charAt(i);
      char secondChar=s.charAt(i+1);
      char thirdChar=s.charAt(i+2);
      boolean areLetters=(firstChar!='.' && secondChar!='.' && thirdChar!='.');
      if(areLetters){
        if(firstChar!=secondChar && firstChar!=thirdChar && secondChar!=thirdChar){
          result="YES" ;
          break ;
        }
      }
    }
    System.out.println(result);
    read.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : OclFile ; read := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := read.nextLine() ;
    var result : String ; result := "NO" ;
        var i : int ; i := 0 ; while i < s->size() - 2 do ( (     var firstChar : String ; firstChar := s->at(i+1) ;
     var secondChar : String ; secondChar := s->at(i + 1+1) ;
    var thirdChar : String ; thirdChar := s->at(i + 2+1) ;
    var areLetters : boolean ; areLetters := (firstChar /= '.' & secondChar /= '.' & thirdChar /= '.') ;
    if (areLetters) then (     if (firstChar /= secondChar & firstChar /= thirdChar & secondChar /= thirdChar) then (     result := "YES" ; 
     break ) else skip ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class helloWorld {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String str=in.next();
    String ans="No" ;
    for(int i=1 ; i+1<str.length(); i++)if(str.charAt(i)!=str.charAt(i-1)&& str.charAt(i-1)!='.')if(str.charAt(i)!=str.charAt(i+1)&& str.charAt(i)!='.')if(str.charAt(i-1)!=str.charAt(i+1)&& str.charAt(i+1)!='.')ans="Yes" ;
    System.out.println(ans);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class helloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := in.getCurrent() ;
    var ans : String ; ans := "No" ;
        var i : int ; i := 1 ; while i + 1 < str->size() do (     if (str->at(i+1) /= str->at((i)->char2byte() - 1+1) & str->at((i)->char2byte() - 1+1) /= '.') then     if (str->at(i+1) /= str->at(i + 1+1) & str->at(i+1) /= '.') then     if (str->at((i)->char2byte() - 1+1) /= str->at(i + 1+1) & str->at(i + 1+1) /= '.') then     ans := "Yes" ; else skip ; else skip ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static int countPairs(int A1[],int A2[],int n1,int n2,int K){
    int res=0 ;
    Map<Integer,Integer>m=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n1 ; ++i){
      if(m.containsKey(A1[i]))m.put(A1[i],m.get(A1[i])+1);
      else m.put(A1[i],1);
    }
    for(int i=0 ; i<n2 ; ++i){
      int temp=K-A2[i];
      if(m.containsKey(temp)&& m.get(temp)!=0){
        res++;
        m.put(temp,m.get(A1[i])-1);
      }
    }
    return res ;
  }
  public static void main(String[] args){
    int A1[]={
      1,1,3,4,5,6,6 };
      int A2[]={
        1,4,4,5,7 },K=10 ;
        int n1=A1.length ;
        int n2=A2.length ;
        System.out.println(countPairs(A1,A2,n1,n2,K));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation countPairs( A1 : Sequence(int), A2 : Sequence(int), n1 : int, n2 : int, K : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     var m : Map(int,int) ; m := Map{} ;
        var i : int ; i := 0 ; while i < n1 do ( (     if (m->keys()->includes(A1[i+1])) then     m := m->union(Map{A1[i+1] |-> m->at(A1[i+1]) + 1}) ; else     m := m->union(Map{A1[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n2 do ( (     var temp : int ; temp := K - A2[i+1] ;
     if (m->keys()->includes(temp) & m->at(temp) /= 0) then (     res := res + 1 ; 
     m := m->union(Map{temp |-> m->at(A1[i+1]) - 1}) ) else skip )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A1 : Sequence(int) ; A1 := Sequence{1,1,3,4,5,6,6} ;
     var A2 : Sequence(int) ; A2 := Sequence{1,4,4,5,7} ;
    var K : int ; K := 10 ;
    var n1 : int ; n1 := A1->size() ;
    var n2 : int ; n2 := A2->size() ;
    OclFile["System.out"].println(countPairs(A1, A2, n1, n2, K)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static List<List<Integer>>perms=new ArrayList<>();
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    StringBuilder sb=new StringBuilder(sc.next());
    if(sb.length()<2){
      System.out.println("0");
      return ;
    }
    int[] arr=new int[n];
    int temp=0 ;
    for(int i=0 ; i<n ; i++){
      if(sb.charAt(i)=='U'){
        temp++;
      }
      else {
        temp--;
      }
      arr[i]=temp ;
    }
    int pay=0 ;
    for(int i=0 ; i<n-2 ; i++){
      if(arr[i]==-1 && arr[i+1]==0 && arr[i+2]==1){
        pay++;
      }
      else if(arr[i]==1 && arr[i+1]==0 && arr[i+2]==-1){
        pay++;
      }
    }
    System.out.println(pay);
  }
  public static void heapsAlgo(int k,int[] A){
    if(k==1){
      List<Integer>list=new ArrayList<>();
      for(int i=0 ; i<A.length ; i++){
        list.add(A[i]);
      }
      perms.add(list);
    }
    else {
      heapsAlgo(k-1,A);
      for(int i=0 ; i<k-1 ; i++){
        if(k % 2==0){
          int temp=A[i];
          A[i]=A[k-1];
          A[k-1]=temp ;
        }
        else {
          int temp=A[0];
          A[0]=A[k-1];
          A[k-1]=temp ;
        }
        heapsAlgo(k-1,A);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute perms : Sequence(Sequence(int)) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString(sc.getCurrent()) ;
    if (sb->size() < 2) then (     OclFile["System.out"].println("0") ; 
     return ) else skip ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var temp : int ; temp := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (sb->at(i+1) = 'U') then (     temp := temp + 1 ) else (     temp := temp - 1 ) ;  
     arr[i+1] := temp )  ;     i := i + 1 ) ; 
    var pay : int ; pay := 0 ;
        var i : int ; i := 0 ; while i < n - 2 do ( (     if (arr[i+1] = -1 & arr[i + 1+1] = 0 & arr[i + 2+1] = 1) then (     pay := pay + 1 ) else     if (arr[i+1] = 1 & arr[i + 1+1] = 0 & arr[i + 2+1] = -1) then (     pay := pay + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(pay) ; 
 );
  static   operation heapsAlgo( k : int, A : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (k = 1) then (     var list : Sequence(int) ; list := Sequence{} ;
         var i : int ; i := 0 ; while i < A->size() do ( (     list := list->including(A[i+1]) )  ;     i := i + 1 ) ; 
     perms := perms->including(list) ) else (     execute heapsAlgo(k - 1, A) ; 
         var i : int ; i := 0 ; while i < k - 1 do ( (     if (k mod 2 = 0) then (     var temp : int ; temp := A[i+1] ;
     A[i+1] := A[k - 1+1] ; 
     A[k - 1+1] := temp ) else (     var temp : int ; temp := A[0+1] ;
     A[0+1] := A[k - 1+1] ; 
     A[k - 1+1] := temp ) ;  
     execute heapsAlgo(k - 1, A) )  ;     i := i + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B935 {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String s=br.readLine();
    String state="" ;
    String previousState="" ;
    int[] arr=new int[n];
    int check=0 ;
    for(int i=0 ; i<n ; i++){
      char cur=s.charAt(i);
      if(cur=='U'){
        check++;
      }
      else if(cur=='R'){
        check--;
      }
      arr[i]=check ;
    }
    int payment=0 ;
    for(int i=0 ; i<arr.length ; i++){
      if(i+2<arr.length){
        if((arr[i]==1 && arr[i+1]==0 && arr[i+2]==-1)||(arr[i]==-1 && arr[i+1]==0 && arr[i+2]==1)){
          payment++;
        }
      }
    }
    System.out.println(payment);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B935 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var s : String ; s := br.readLine() ;
    var state : String ; state := "" ;
    var previousState : String ; previousState := "" ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var check : int ; check := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var cur : String ; cur := s->at(i+1) ;
     if (cur = 'U') then (     check := check + 1 ) else     if (cur = 'R') then (     check := check - 1 ) else skip ; ;  
     arr[i+1] := check )  ;     i := i + 1 ) ; 
    var payment : int ; payment := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (i + 2 < arr->size()) then (     if ((arr[i+1] = 1 & arr[i + 1+1] = 0 & arr[i + 2+1] = -1) or (arr[i+1] = -1 & arr[i + 1+1] = 0 & arr[i + 2+1] = 1)) then (     payment := payment + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(payment) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String s=in.next();
    int x=0 ;
    int y=0 ;
    int count=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='U'){
        y++;
      }
      else {
        x++;
      }
      if(x==y){
        if(i!=s.length()-1){
          if(s.charAt(i+1)==s.charAt(i)){
            count++;
          }
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'U') then (     y := y + 1 ) else (     x := x + 1 ) ;  
     if (x = y) then (     if (i /= s->size() - 1) then (     if (s->at(i + 1+1) = s->at(i+1)) then (     count := count + 1 ) else skip ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.List ;
import java.util.Objects ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class B935 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int moves=Integer.parseInt(scanner.nextLine());
    int coins=0 ;
    String line=scanner.nextLine();
    List<String>input=Arrays.stream(line.split("")).collect(Collectors.toList());
    int x=0 ;
    int y=0 ;
    for(int i=0 ; i<input.size()-1 ; i++){
      if(input.get(i).equals("U")){
        y++;
      }
      if(input.get(i).equals("R")){
        x++;
      }
      if(x==y && x+y!=0){
        if(Objects.equals(input.get(i),input.get(i+1))){
          coins++;
        }
      }
    }
    System.out.println(coins);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B935 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var moves : int ; moves := (scanner.nextLine())->toInteger() ;
    var coins : int ; coins := 0 ;
    var line : String ; line := scanner.nextLine() ;
    var input : Sequence(String) ; input := stream(line->split("")).collect(Collectors.toList()) ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
        var i : int ; i := 0 ; while i < input->size() - 1 do ( (     if (input->at(i+1) = "U") then (     y := y + 1 ) else skip ; 
     if (input->at(i+1) = "R") then (     x := x + 1 ) else skip ; 
     if (x = y & x + y /= 0) then (     if (Objects = input->at(i+1), input->at(i + 1+1)) then (     coins := coins + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(coins) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
public final class p109 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p109().run());
  }
  public String run(){
    points=new ArrayList<>();
    for(int i=1 ; i<=20 ; i++){
      for(int j=1 ; j<=3 ; j++)points.add(i*j);
    }
    points.add(25);
    points.add(50);
    List<Integer>doublePoints=new ArrayList<>();
    for(int i=1 ; i<=20 ; i++)doublePoints.add(i*2);
    doublePoints.add(25*2);
    ways=new int[3][101][points.size()];
    for(int[][] x : ways){
      for(int[] y : x)Arrays.fill(y,-1);
    }
    int checkouts=0 ;
    for(int remainingPoints=1 ; remainingPoints<100 ; remainingPoints++){
      for(int throwz=0 ; throwz<=2 ; throwz++){
        for(int p : doublePoints){
          if(p<=remainingPoints)checkouts+=ways(throwz,remainingPoints-p,points.size()-1);
        }
      }
    }
    return Integer.toString(checkouts);
  }
  private List<Integer>points ;
  private int[][][] ways ;
  private int ways(int throwz,int total,int maxIndex){
    if(ways[throwz][total][maxIndex]==-1){
      int result ;
      if(throwz==0)result=total==0 ? 1 : 0 ;
      else {
        result=0 ;
        if(maxIndex>0)result+=ways(throwz,total,maxIndex-1);
        if(points.get(maxIndex)<=total)result+=ways(throwz-1,total-points.get(maxIndex),maxIndex);
      }
      ways[throwz][total][maxIndex]=result ;
    }
    return ways[throwz][total][maxIndex];
  }
}
------------------------------------------------------------
OCL File:
---------
 class p109 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p109.newp109().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     points := Sequence{} ; 
         var i : int ; i := 1 ; while i <= 20 do ( (         var j : int ; j := 1 ; while j <= 3 do (     points->excludes(i * j) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    points->excludes(25) ; 
    points->excludes(50) ; 
    var doublePoints : Sequence(int) ; doublePoints := Sequence{} ;
        var i : int ; i := 1 ; while i <= 20 do (     doublePoints := doublePoints->including(i * 2) ;  ;     i := i + 1 ) ; 
    doublePoints := doublePoints->including(25 * 2) ; 
    ways := Integer.subrange(1,3)->collect(Integer.subrange(1,101)->collect(Integer.subrange(1,points->size())->collect(0))) ; 
    for (x : ways) do ( (     for (y : x) do (     y := y->collect(-1) ;  ) )  ) ; 
    var checkouts : int ; checkouts := 0 ;
        var remainingPoints : int ; remainingPoints := 1 ; while remainingPoints < 100 do ( (         var throwz : int ; throwz := 0 ; while throwz <= 2 do ( (     for (p : doublePoints) do ( (     if (p <= remainingPoints) then     checkouts := checkouts+(ways(throwz, remainingPoints - p, points->size() - 1)) ; else skip )  ) )  ;     throwz := throwz + 1 ) )  ;     remainingPoints := remainingPoints + 1 ) ; 
    return ((checkouts) + "") 
 );
   attribute points : Sequence(int);
   attribute ways : Sequence(Sequence(Sequence(int)));
   operation ways( throwz : int, total : int, maxIndex : int) : int
  pre: true
  post: true
  activity: (     if (ways[throwz+1][total+1][maxIndex+1] = -1) then (     var result : int ;
     if (throwz = 0) then     result := if total = 0 then 1 else 0 endif else (     result := 0 ; 
     if (maxIndex > 0) then     result := result+(ways(throwz, total, maxIndex - 1)) ; else skip ; 
     if (points->at(maxIndex+1) <= total) then     result := result+(ways(throwz - 1, total - points->at(maxIndex+1), maxIndex)) ; else skip ) ;  
     ways[throwz+1][total+1][maxIndex+1] := result ) else skip ; 
     return ways[throwz+1][total+1][maxIndex+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    Arrays.sort(a);
    int min=a[0],max=a[n-1];
    int res=max-min+1-n ;
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var min : int ; min := a[0+1] ;
    var max : int ; max := a[n - 1+1] ;
    var res : int ; res := max - min + 1 - n ;
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static void vietaFormula(int roots[],int n){
    int coeff[]=new int[++n+1];
    Arrays.fill(coeff,0);
    coeff[n]=1 ;
    for(int i=1 ; i<n ; i++){
      for(int j=n-i-1 ; j<n ; j++){
        coeff[j]=coeff[j]+(-1)*roots[i-1]*coeff[j+1];
      }
    }
    System.out.print("Polynomial Coefficients: ");
    for(int i=n ; i>0 ; i--){
      System.out.print(coeff[i]+" ");
    }
  }
  public static void main(String[] args){
    int n=4 ;
    int roots[]={
-1,2,-3,7 };
      vietaFormula(roots,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation vietaFormula( roots : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var coeff : Sequence(int) ; coeff := Integer.subrange(1,(n + 1) + 1)->collect(0) ;
     coeff := coeff->collect(0) ; 
    coeff[n+1] := 1 ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := n - i - 1 ; while j < n do ( (     coeff[j+1] := coeff[j+1] + (-1) * roots[i - 1+1] * coeff[j + 1+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("Polynomial Coefficients: ") ; 
        var i : int ; i := n ; while i > 0 do ( (     OclFile["System.out"].print(coeff[i+1] + " ") )  ;     i := i - 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var roots : Sequence(int) ; roots := Sequence{-1,2,-3,7} ;
     execute vietaFormula(roots, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=arr[n-i-1];
    }
    for(int i=1 ; i<n/2 ; i+=2){
      int temp=res[i];
      res[i]=res[n-1-i];
      res[n-1-i]=temp ;
    }
    int i=0 ;
    for(; i<n-1 ; i++)System.out.print(res[i]+" ");
    System.out.print(res[i]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     res[i+1] := arr[n - i - 1+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n / 2 do ( (     var temp : int ; temp := res[i+1] ;
     res[i+1] := res[n - 1 - i+1] ; 
     res[n - 1 - i+1] := temp )  ;     i := i+(2) ) ; 
    var i : int ; i := 0 ;
      while i < n - 1 do (     OclFile["System.out"].print(res[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(res[i+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static long getNthTerm(long N){
    return(7*(int)Math.pow(N,2)-19*N+15);
  }
  public static void main(String arr[]){
    long N=4 ;
    System.out.println(getNthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation getNthTerm( N : long) : long
  pre: true
  post: true
  activity: (     return (7 * N->pow(2)->oclAsType(int) - 19 * N + 15) );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := 4 ;
     OclFile["System.out"].println(getNthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<a.length ; i++){
      a[i]=sc.nextInt();
    }
    int temp ;
    if(n % 2==1){
      for(int i=0 ; i<n-i+1 ; i++){
        temp=a[i];
        a[i]=a[n-i-1];
        a[n-i-1]=temp ;
        i++;
      }
    }
    else for(int i=0 ;
    i<n-i ;
    i++){
      temp=a[i];
      a[i]=a[n-i-1];
      a[n-i-1]=temp ;
      i++;
    }
    for(int i=0 ; i<n ; i++)System.out.print(a[i]+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var temp : int ;
    if (n mod 2 = 1) then (         var i : int ; i := 0 ; while i < n - i + 1 do ( (     temp := a[i+1] ; 
     a[i+1] := a[n - i - 1+1] ; 
     a[n - i - 1+1] := temp ; 
     i := i + 1 )  ;     i := i + 1 ) ) else         var i : int ; i := 0 ; while i < n - i do ( (     temp := a[i+1] ; 
     a[i+1] := a[n - i - 1+1] ; 
     a[n - i - 1+1] := temp ; 
     i := i + 1 )  ;     i := i + 1 ) ; ;  
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<a.length ; i++){
      a[i]=sc.nextInt();
    }
    int temp ;
    if(n % 2==1){
      for(int i=0 ; i<n-i+1 ; i++){
        temp=a[i];
        a[i]=a[n-i-1];
        a[n-i-1]=temp ;
        i++;
      }
    }
    else for(int i=0 ;
    i<n-i ;
    i++){
      temp=a[i];
      a[i]=a[n-i-1];
      a[n-i-1]=temp ;
      i++;
    }
    for(int i=0 ; i<n ; i++)System.out.print(a[i]+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var temp : int ;
    if (n mod 2 = 1) then (         var i : int ; i := 0 ; while i < n - i + 1 do ( (     temp := a[i+1] ; 
     a[i+1] := a[n - i - 1+1] ; 
     a[n - i - 1+1] := temp ; 
     i := i + 1 )  ;     i := i + 1 ) ) else         var i : int ; i := 0 ; while i < n - i do ( (     temp := a[i+1] ; 
     a[i+1] := a[n - i - 1+1] ; 
     a[n - i - 1+1] := temp ; 
     i := i + 1 )  ;     i := i + 1 ) ; ;  
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMinLength(String arr[],int n){
    int min=arr[0] .length();
    for(int i=1 ; i<n ; i++){
      if(arr[i] .length()<min){
        min=arr[i] .length();
      }
    }
    return(min);
  }
  static String commonPrefix(String arr[],int n){
    int minlen=findMinLength(arr,n);
    String result="" ;
    char current ;
    for(int i=0 ; i<minlen ; i++){
      current=arr[0] .charAt(i);
      for(int j=1 ; j<n ; j++){
        if(arr[j] .charAt(i)!=current){
          return result ;
        }
      }
      result+=(current);
    }
    return(result);
  }
  public static void main(String[] args){
    String arr[]={
      "geeksforgeeks","geeks","geek","geezer" };
      int n=arr.length ;
      String ans=commonPrefix(arr,n);
      if(ans.length()>0){
        System.out.println("The longest common prefix is "+ans);
      }
      else {
        System.out.println("There is no common prefix");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMinLength( arr : Sequence(String), n : int) : int
  pre: true
  post: true
  activity: (     var min : int ; min := arr[0+1]->size() ;
         var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1]->size() < min) then (     min := arr[i+1]->size() ) else skip )  ;     i := i + 1 ) ; 
     return (min) );
  static   operation commonPrefix( arr : Sequence(String), n : int) : String
  pre: true
  post: true
  activity: (     var minlen : int ; minlen := findMinLength(arr, n) ;
     var result : String ; result := "" ;
    var current : String ;
        var i : int ; i := 0 ; while i < minlen do ( (     current := arr[0+1]->at(i+1) ; 
         var j : int ; j := 1 ; while j < n do ( (     if (arr[j+1]->at(i+1) /= current) then (     return result ) else skip )  ;     j := j + 1 ) ; 
     result := result+((current)) )  ;     i := i + 1 ) ; 
    return (result) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"geeksforgeeks","geeks","geek","geezer"} ;
     var n : int ; n := arr->size() ;
     var ans : String ; ans := commonPrefix(arr, n) ;
     if (ans->size() > 0) then (     OclFile["System.out"].println("The longest common prefix is " + ans) ) else (     OclFile["System.out"].println("There is no common prefix") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int s=scanner.nextInt();
    String t=scanner.next();
    char[] ans=t.toCharArray();
    if(ans[3]>'5'){
      ans[3]='0' ;
    }
    if(s==12){
      if(ans[0]=='0' && ans[1]=='0'){
        ans[1]='1' ;
      }
      else if(10*(ans[0]-'0')+(ans[1]-'0')>12 && ans[1]>'0'){
        ans[0]='0' ;
      }
      else if(10*(ans[0]-'0')+(ans[1]-'0')>12 && ans[1]=='0'){
        ans[0]='1' ;
      }
    }
    else {
      if(10*(ans[0]-'0')+(ans[1]-'0')>=24){
        ans[0]='0' ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : int ; s := scanner.getCurrent()->toInteger() ;
    var t : String ; t := scanner.getCurrent() ;
    var ans : Sequence(String) ; ans := t->characters() ;
    if (ans[3+1] > '5') then (     ans[3+1] := '0' ) else skip ; 
    if (s = 12) then (     if (ans[0+1] = '0' & ans[1+1] = '0') then (     ans[1+1] := '1' ) else     if (10 * (ans[0+1] - ('0')->char2byte()) + (ans[1+1] - ('0')->char2byte()) > 12 & ans[1+1] > '0') then (     ans[0+1] := '0' ) else     if (10 * (ans[0+1] - ('0')->char2byte()) + (ans[1+1] - ('0')->char2byte()) > 12 & ans[1+1] = '0') then (     ans[0+1] := '1' ) else skip ; ;  ) else (     if (10 * (ans[0+1] - ('0')->char2byte()) + (ans[1+1] - ('0')->char2byte()) >= 24) then (     ans[0+1] := '0' ) else skip ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class CFC {
  public static void main(String[] args)throws Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter writer=new PrintWriter(System.out);
    int mode=Integer.parseInt(reader.readLine());
    String time=reader.readLine();
    char[] ans=time.toCharArray();
    int a=time.charAt(0)-'0' ;
    int b=time.charAt(1)-'0' ;
    int c=time.charAt(3)-'0' ;
    int d=time.charAt(4)-'0' ;
    if(mode==12){
      if(a==0){
        if(b==0){
          ans[1]='1' ;
        }
      }
      else if(a==1){
        if(b>2){
          ans[1]='0' ;
        }
      }
      else {
        if(b==0){
          ans[0]='1' ;
        }
        else {
          ans[0]='0' ;
        }
      }
    }
    else {
      if(a==0 || a==1){
      }
      else if(a==2){
        if(b<=3){
        }
        else {
          ans[0]='0' ;
        }
      }
      else {
        ans[0]='0' ;
      }
    }
    if(c>5){
      ans[3]='0' ;
    }
    writer.println(new String(ans));
    reader.close();
    writer.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CFC {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var mode : int ; mode := (reader.readLine())->toInteger() ;
    var time : String ; time := reader.readLine() ;
    var ans : Sequence(String) ; ans := time->characters() ;
    var a : int ; a := time->at(0+1) - ('0')->char2byte() ;
    var b : int ; b := time->at(1+1) - ('0')->char2byte() ;
    var c : int ; c := time->at(3+1) - ('0')->char2byte() ;
    var d : int ; d := time->at(4+1) - ('0')->char2byte() ;
    if (mode = 12) then (     if (a = 0) then (     if (b = 0) then (     ans[1+1] := '1' ) else skip ) else     if (a = 1) then (     if (b > 2) then (     ans[1+1] := '0' ) else skip ) else (     if (b = 0) then (     ans[0+1] := '1' ) else (     ans[0+1] := '0' ) ) ;  ) else (     if (a = 0 or a = 1) then skip else     if (a = 2) then (     if (b <= 3) then skip else (     ans[0+1] := '0' ) ) else (     ans[0+1] := '0' ) ;  ) ;  
    if (c > 5) then (     ans[3+1] := '0' ) else skip ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Ideone {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.nextLine().trim());
    String s[]=sc.nextLine().trim().split(":");
    if(s[1] .charAt(0)>'5')s[1]="0"+s[1] .charAt(1);
    int hour=Integer.parseInt(s[0]);
    if(n==24){
      if(hour>=24){
        s[0]="0"+s[0] .charAt(1);
      }
    }
    else {
      if(hour>12){
        if(hour % 10==0){
          s[0]="1"+s[0] .charAt(1);
        }
        else {
          s[0]="0"+s[0] .charAt(1);
        }
      }
      else {
        if(hour==0){
          s[0]="1"+s[0] .charAt(1);
        }
      }
    }
    System.out.println(s[0]+":"+s[1]);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ideone {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.nextLine()->trim())->toInteger() ;
    var s : Sequence(String) ; s := sc.nextLine()->trim()->split(":") ;
    if (s[1+1]->at(0+1) > '5') then     s[1+1] := "0" + s[1+1]->at(1+1) ; else skip ; 
    var hour : int ; hour := (s[0+1])->toInteger() ;
    if (n = 24) then (     if (hour >= 24) then (     s[0+1] := "0" + s[0+1]->at(1+1) ) else skip ) else (     if (hour > 12) then (     if (hour mod 10 = 0) then (     s[0+1] := "1" + s[0+1]->at(1+1) ) else (     s[0+1] := "0" + s[0+1]->at(1+1) ) ) else (     if (hour = 0) then (     s[0+1] := "1" + s[0+1]->at(1+1) ) else skip ) ) ;  
    OclFile["System.out"].println(s[0+1] + ":" + s[1+1]) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Cheker {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String str=sc.next();
    if(n==12){
      int min=Integer.valueOf(str.substring(3,5));
      min=(min % 60);
      String temp="" ;
      if(Integer.valueOf(str.substring(0,2))==0){
        temp+="01:" ;
      }
      else if(Integer.valueOf(str.substring(0,2))>12){
        if(Integer.valueOf(str.substring(0,2))% 10==0){
          temp+="10:" ;
        }
        else {
          int h=Integer.valueOf(str.substring(0,2))% 10 ;
          temp+="0"+String.valueOf(h)+":" ;
        }
      }
      else {
        temp+=str.substring(0,3);
      }
      if(min>=10)temp+=String.valueOf(min);
      else {
        temp+="0"+min ;
      }
      System.out.println(temp);
    }
    else {
      int min=Integer.valueOf(str.substring(3,5));
      min=(min % 60);
      String temp="" ;
      if(Integer.valueOf(str.substring(0,2))>23){
        temp+="0"+str.charAt(1)+":" ;
      }
      else {
        temp+=str.substring(0,3);
      }
      if(min>=10)temp+=String.valueOf(min);
      else {
        temp+="0"+min ;
      }
      System.out.println(temp);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cheker {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var str : String ; str := sc.getCurrent() ;
    if (n = 12) then (     var min : int ; min := (str.subrange(3+1,5))->toInteger() ;
     min := (min mod 60) ; 
    var temp : String ; temp := "" ;
    if ((str.subrange(0+1,2))->toInteger() = 0) then (     temp := temp+("01:") ) else     if ((str.subrange(0+1,2))->toInteger() > 12) then (     if ((str.subrange(0+1,2))->toInteger() mod 10 = 0) then (     temp := temp+("10:") ) else (     var h : int ; h := (str.subrange(0+1,2))->toInteger() mod 10 ;
     temp := temp+("0" + ((h) + "") + ":") ) ) else (     temp := temp+(str.subrange(0+1,3)) ) ;  ;  
    if (min >= 10) then     temp := temp+(((min) + "")) else (     temp := temp+("0" + min) ) ;  
    OclFile["System.out"].println(temp) ; 
 ) else (     var min : int ; min := (str.subrange(3+1,5))->toInteger() ;
     min := (min mod 60) ; 
    var temp : String ; temp := "" ;
    if ((str.subrange(0+1,2))->toInteger() > 23) then (     temp := temp+("0" + str->at(1+1) + ":") ) else (     temp := temp+(str.subrange(0+1,3)) ) ;  
    if (min >= 10) then     temp := temp+(((min) + "")) else (     temp := temp+("0" + min) ) ;  
    OclFile["System.out"].println(temp) ; 
 ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static final int INF=100000 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int D=sc.nextInt();
    long G=sc.nextLong();
    int[] p=new int[D];
    int[] c=new int[D];
    for(int i=0 ; i<D ; i++){
      p[i]=sc.nextInt();
      c[i]=sc.nextInt();
    }
    int min=INF ;
    for(int bit=0 ; bit<(1<<D); bit++){
      int score=0 ;
      int solve_num=0 ;
      for(int i=0 ; i<D ; i++){
        if((bit &(1<<i))!=0){
          score+=100*(i+1)*p[i]+c[i];
          solve_num+=p[i];
        }
      }
      if(score<G){
        loop : for(int i=D-1 ;
        i>=0 ;
        i--){
          if((bit &(1<<i))==0){
            for(int j=0 ; j<p[i]-1 ; j++){
              score+=100*(i+1);
              solve_num++;
              if(score>=G){
                break loop ;
              }
            }
          }
        }
      }
      if(score>=G){
        min=Math.min(min,solve_num);
      }
    }
    System.out.println(min);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := 100000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var D : int ; D := sc.getCurrent()->toInteger() ;
    var G : long ; G := sc.getCurrent()->toLong() ;
    var p : Sequence(int) ; p := Integer.subrange(1,D)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,D)->collect(0) ;
        var i : int ; i := 0 ; while i < D do ( (     p[i+1] := sc.getCurrent()->toInteger() ; 
     c[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var min : int ; min := INF ;
        var bit : int ; bit := 0 ; while bit < ((1*(2->pow(D)))->oclAsType(long)) do ( (     var score : int ; score := 0 ;
     var solve_num : int ; solve_num := 0 ;
        var i : int ; i := 0 ; while i < D do ( (     if ((MathLib.bitwiseAnd(bit,((1*(2->pow(i)))->oclAsType(long)))) /= 0) then (     score := score+(100 * (i + 1) * p[i+1] + c[i+1]) ; 
     solve_num := solve_num+(p[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    if (score < G) then (         var i : int ; i := D - 1 ; while i >= 0 do ( (     if ((MathLib.bitwiseAnd(bit,((1*(2->pow(i)))->oclAsType(long)))) = 0) then (         var j : int ; j := 0 ; while j < p[i+1] - 1 do ( (     score := score+(100 * (i + 1)) ; 
     solve_num := solve_num + 1 ; 
     if (score >= G) then (     break ) else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i - 1 ) ; ) else skip ; 
    if (score >= G) then (     min := Set{min, solve_num}->min() ) else skip ; 
 )  ;     bit := bit + 1 ) ; 
    OclFile["System.out"].println(min) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GFG {
  private static final int MAX=0 ;
  public static void leyland(int n){
    List<Integer>ans=new ArrayList<Integer>();
    for(int x=2 ; x<=n ; x++){
      for(int y=2 ; y<=x ; y++){
        int temp=(int)Math.pow(x,y)+(int)Math.pow(y,x);
        ans.add(temp);
      }
    }
    Collections.sort(ans);
    for(int i=0 ; i<n ; i++)System.out.print(ans.get(i)+" ");
  }
  public static void main(String args[]){
    int n=6 ;
    leyland(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX : int := 0;
  static   operation leyland( n : int) : void
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Sequence{} ;
         var x : int ; x := 2 ; while x <= n do ( (         var y : int ; y := 2 ; while y <= x do ( (     var temp : int ; temp := x->pow(y)->oclAsType(int) + y->pow(x)->oclAsType(int) ;
     ans := ans->including(temp) )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
     ans := ans->sort() ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(ans->at(i+1) + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     execute leyland(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new FileReader("in.txt"));
    PrintWriter pw=new PrintWriter(new FileWriter("out.txt"));
    int N=Integer.parseInt(br.readLine());
    for(int pp=0 ; pp<N ; pp++){
      String[] ss=br.readLine().split(" ");
      int d=Integer.parseInt(ss[0]);
      int n=Integer.parseInt(ss[1]);
      double max=0.0 ;
      for(int i=0 ; i<n ; i++){
        ss=br.readLine().split(" ");
        int k=Integer.parseInt(ss[0]);
        int s=Integer.parseInt(ss[1]);
        double time=(d-k)/((double)s);
        System.out.println(d+" "+k+" "+s+" "+time);
        max=Math.max(max,time);
      }
      double ret=d/max ;
      pw.println("Case #"+(pp+1)+": "+ret);
    }
    pw.flush();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("in.txt"))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("out.txt"))) ;
    var N : int ; N := (br.readLine())->toInteger() ;
        var pp : int ; pp := 0 ; while pp < N do ( (     var ss : Sequence(String) ; ss := br.readLine()->split(" ") ;
     var d : int ; d := (ss[0+1])->toInteger() ;
    var n : int ; n := (ss[1+1])->toInteger() ;
    var max : double ; max := 0.0 ;
        var i : int ; i := 0 ; while i < n do ( (     ss := br.readLine()->split(" ") ; 
     var k : int ; k := (ss[0+1])->toInteger() ;
    var s : int ; s := (ss[1+1])->toInteger() ;
    var time : double ; time := (d - k) / (s->oclAsType(double)) ;
    OclFile["System.out"].println(d + " " + k + " " + s + " " + time) ; 
    max := Set{max, time}->max() ; 
 )  ;     i := i + 1 ) ; 
    var ret : double ; ret := d / max ;
    skip ; 
 )  ;     pp := pp + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package year2017.round1b ;
import java.io.File ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class CruiseControl {
  public static void main(String[] args)throws Exception {
    File inputFile=new File("A-large.in");
    Scanner in=new Scanner(inputFile);
    File outputFile=new File("output.txt");
    PrintWriter out=new PrintWriter(outputFile);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      double D=in.nextDouble();
      int N=in.nextInt();
      double maxTime=0 ;
      for(int n=0 ; n<N ; n++){
        double K=in.nextDouble();
        double S=in.nextDouble();
        double time=(D-K)/S ;
        maxTime=Math.max(time,maxTime);
      }
      double speed=D/maxTime ;
      out.println("Case #"+(t+1)+": "+speed);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CruiseControl {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputFile : OclFile ; inputFile := OclFile("A-large.in") ;
     var in : OclFile ; in := OclFile.newOclFile_Read(inputFile) ;
    var outputFile : OclFile ; outputFile := OclFile("output.txt") ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputFile) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < T do ( (     var D : double ; D := in.getCurrent()->toReal() ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var maxTime : double ; maxTime := 0 ;
        var n : int ; n := 0 ; while n < N do ( (     var K : double ; K := in.getCurrent()->toReal() ;
     var S : double ; S := in.getCurrent()->toReal() ;
     var time : double ; time := (D - K) / S ;
     maxTime := Set{time, maxTime}->max() )  ;     n := n + 1 ) ; 
    var speed : double ; speed := D / maxTime ;
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static long getNthTerm(long N){
    return((int)Math.pow(N,2)+N+1);
  }
  public static void main(String arr[]){
    long N=11 ;
    System.out.println(getNthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation getNthTerm( N : long) : long
  pre: true
  post: true
  activity: (     return (N->pow(2)->oclAsType(int) + N + 1) );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := 11 ;
     OclFile["System.out"].println(getNthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Double.parseDouble ;
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
import static java.lang.Math.max ;
import static java.lang.System.exit ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
import java.util.Locale ;
import java.util.StringTokenizer ;
public class A {
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  static int test ;
  static void solve()throws Exception {
    int d=nextInt();
    int n=nextInt();
    double ans=0 ;
    for(int i=0 ; i<n ; i++){
      int k=nextInt();
      int s=nextInt();
      ans=max(ans,(double)(d-k)/s);
    }
    printCase();
    out.printf(Locale.US,"%.9f\n",d/ans);
  }
  static void printCase(){
    out.print("Case #"+test+": ");
  }
  static void printlnCase(){
    out.println("Case #"+test+":");
  }
  static int nextInt()throws IOException {
    return parseInt(next());
  }
  static long nextLong()throws IOException {
    return parseLong(next());
  }
  static double nextDouble()throws IOException {
    return parseDouble(next());
  }
  static String next()throws IOException {
    while(tok==null || ! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  public static void main(String[] args){
    try {
      in=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(new OutputStreamWriter(System.out));
      int tests=nextInt();
      for(test=1 ; test<=tests ; test++){
        solve();
      }
      in.close();
      out.close();
    }
    catch(Throwable e){
      e.printStackTrace();
      exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
  static   attribute test : int;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var d : int ; d := nextInt() ;
     var n : int ; n := nextInt() ;
    var ans : double ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var k : int ; k := nextInt() ;
     var s : int ; s := nextInt() ;
     ans := Set{ans, (d - k)->oclAsType(double) / s}->max() )  ;     i := i + 1 ) ; 
    execute printCase() ; 
    skip ; 
 );
  static   operation printCase() : void
  pre: true
  post: true
  activity: (     skip );
  static   operation printlnCase() : void
  pre: true
  post: true
  activity: (     skip );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next() + "")->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return parseLong(next()) );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return parseDouble(next()) );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (tok = null or not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return tok.next() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var tests : int ; tests := nextInt() ;
        test := 1 ; while test <= tests do ( (     execute solve() )  ;     test := test + 1 ) ; 
    skip ; 
    skip ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
     execute exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package codejam ;
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.nio.file.Files ;
import java.nio.file.Paths ;
public class Horse {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new FileReader("src/codejam/A-large.in"));
    StringBuilder sb=new StringBuilder();
    int T=Integer.parseInt(br.readLine());
    for(int t_i=1 ; t_i<=T ; t_i++){
      String[] split=br.readLine().split(" ");
      int D=Integer.parseInt(split[0]);
      int N=Integer.parseInt(split[1]);
      int[] k=new int[N];
      int[] s=new int[N];
      double latest=0 ;
      for(int n_i=0 ; n_i<N ; n_i++){
        split=br.readLine().split(" ");
        k[n_i]=Integer.parseInt(split[0]);
        s[n_i]=Integer.parseInt(split[1]);
        double time=1.*(D-k[n_i])/s[n_i];
        if(time>latest)latest=time ;
      }
      sb.append("Case #").append(t_i).append(": ").append(D/latest).append("\n");
    }
    Files.write(Paths.get("src/codejam/horse.out"),sb.toString().getBytes());
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Horse {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("src/codejam/A-large.in"))) ;
     var sb : String ; sb := StringLib.newString() ;
    var T : int ; T := (br.readLine())->toInteger() ;
        var t_i : int ; t_i := 1 ; while t_i <= T do ( (     var split : Sequence(String) ; split := br.readLine()->split(" ") ;
     var D : int ; D := (split[0+1])->toInteger() ;
    var N : int ; N := (split[1+1])->toInteger() ;
    var k : Sequence(int) ; k := Integer.subrange(1,N)->collect(0) ;
    var s : Sequence(int) ; s := Integer.subrange(1,N)->collect(0) ;
    var latest : double ; latest := 0 ;
        var n_i : int ; n_i := 0 ; while n_i < N do ( (     split := br.readLine()->split(" ") ; 
     k[n_i+1] := (split[0+1])->toInteger() ; 
    s[n_i+1] := (split[1+1])->toInteger() ; 
    var time : double ; time := 1. * (D - k[n_i+1]) / s[n_i+1] ;
    if (time > latest) then     latest := time ; else skip ; 
 )  ;     n_i := n_i + 1 ) ; 
    sb := sb + StringLib.newString("Case #") + StringLib.newString(t_i) + StringLib.newString(": ") + StringLib.newString(D / latest) + StringLib.newString("\n") ; 
 )  ;     t_i := t_i + 1 ) ; 
OclFile.newOclFile_Write(OclFile.newOclFile(Paths->at("src/codejam/horse.out"+1))).writeNbytes(sb+""->characters()->collect( _c | _c->char2byte() ),sb+""->characters()->collect( _c | _c->char2byte() )->size()) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package Y2017.r1b ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.io.UnsupportedEncodingException ;
import java.util.Scanner ;
public class CruiseControl {
  public static void main(String[] args)throws FileNotFoundException,UnsupportedEncodingException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    scanner.nextLine();
    try(PrintWriter writer=new PrintWriter("solution.txt","UTF-8")){
      for(int i=1 ; i<=n ; ++i){
        writer.print(String.format("Case #%d: ",i));
        solve(scanner,writer);
      }
    }
  }
  public static void solve(Scanner scanner,PrintWriter writer){
    int D=scanner.nextInt();
    int N=scanner.nextInt();
    double duration=0 ;
    for(int i=0 ; i<N ; ++i){
      int K=scanner.nextInt();
      int S=scanner.nextInt();
      double d=(D-K)/((double)S);
      duration=Math.max(duration,d);
    }
    writer.println(D/duration);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CruiseControl {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
     skip ; 
     try (    var writer : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile("solution.txt", "UTF-8")) ;
 (         var i : int ; i := 1 ; while i <= n do ( (     skip ; 
     execute solve(scanner, writer) )  ;     i := i + 1 ) ))  );
  static   operation solve( scanner : OclFile, writer : OclFile) : void
  pre: true
  post: true
  activity: (     var D : int ; D := scanner.getCurrent()->toInteger() ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var duration : double ; duration := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var K : int ; K := scanner.getCurrent()->toInteger() ;
     var S : int ; S := scanner.getCurrent()->toInteger() ;
     var d : double ; d := (D - K) / (S->oclAsType(double)) ;
     duration := Set{duration, d}->max() )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static void solve(){
    int p=in.nextInt();
    int q=in.nextInt();
    p=q/gcd(p,q);
    long ans=1 ;
    for(int i=2 ; i*i<=p ; i++){
      if(p % i==0){
        ans*=i ;
        while(p % i==0)p/=i ;
      }
    }
    if(p!=1)ans*=p ;
    out.println(ans);
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    solve();
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var p : int ; p := in.getCurrent()->toInteger() ;
     var q : int ; q := in.getCurrent()->toInteger() ;
    p := q / gcd(p, q) ; 
    var ans : long ; ans := 1 ;
        var i : int ; i := 2 ; while i * i <= p do ( (     if (p mod i = 0) then (     ans := ans*(i) ; 
     while (p mod i = 0) do     p := p/(i) ; ) else skip )  ;     i := i + 1 ) ; 
    if (p /= 1) then     ans := ans*(p) ; else skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    execute solve() ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] tmpArray=br.readLine().split(" ");
    int p=Integer.parseInt(tmpArray[0]);
    int q=Integer.parseInt(tmpArray[1]);
    int g=gcd(p,q);
    q/=g ;
    int result=1 ;
    for(int i=2 ; i<=q ; i++){
      boolean divided=false ;
      while(q % i==0){
        divided=true ;
        q/=i ;
      }
      if(divided){
        result*=i ;
      }
    }
    System.out.println(result);
  }
  static int gcd(int a,int b){
    int tmp ;
    while(a % b!=0){
      tmp=b ;
      b=a % b ;
      a=tmp ;
    }
    return b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
    var p : int ; p := (tmpArray[0+1])->toInteger() ;
    var q : int ; q := (tmpArray[1+1])->toInteger() ;
    var g : int ; g := gcd(p, q) ;
    q := q/(g) ; 
    var result : int ; result := 1 ;
        var i : int ; i := 2 ; while i <= q do ( (     var divided : boolean ; divided := false ;
     while (q mod i = 0) do (     divided := true ; 
     q := q/(i) ) ; 
     if (divided) then (     result := result*(i) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var tmp : int ;
     while (a mod b /= 0) do (     tmp := b ; 
     b := a mod b ; 
     a := tmp ) ; 
     return b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    ArrayList<Long>yaku=new ArrayList<Long>();
    Scanner scn=new Scanner(System.in);
    long p=scn.nextLong(),q=scn.nextLong();
    scn.close();
    long qs ;
    long ans=1 ;
    long bp=p,bq=q,buf=p ;
    while(bq % bp!=0){
      buf=bq % bp ;
      bq=bp ;
      bp=buf ;
    }
    qs=q/buf ;
    for(long i=2 ; i<=Math.sqrt(qs); i++){
      if(qs % i==0){
        while(qs % i==0){
          qs/=i ;
        }
        ans*=i ;
      }
    }
    ans*=qs ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var yaku : Sequence(long) ; yaku := Sequence{} ;
     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var p : long ; p := scn.getCurrent()->toLong() ;
    var q : long ; q := scn.getCurrent()->toLong() ;
    skip ; 
    var qs : long ;
    var ans : long ; ans := 1 ;
    var bp : long ; bp := p ;
    var bq : long ; bq := q ;
    var buf : long ; buf := p ;
    while (bq mod bp /= 0) do (     buf := bq mod bp ; 
     bq := bp ; 
     bp := buf ) ; 
    qs := q / buf ; 
        var i : long ; i := 2 ; while i <= (qs)->sqrt() do ( (     if (qs mod i = 0) then (     while (qs mod i = 0) do (     qs := qs/(i) ) ; 
     ans := ans*(i) ) else skip )  ;     i := i + 1 ) ; 
    ans := ans*(qs) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Chernovik {
  public static void main(String[] args)throws IOException {
    PrintWriter pw=new PrintWriter(System.out);
    int a=nextInt();
    int mas[]=new int[a];
    for(int i=0 ; i<mas.length ; i++){
      mas[i]=nextInt();
    }
    Arrays.sort(mas);
    long sum=0 ;
    for(int i=0 ; i<mas.length-1 ; i++){
      sum+=mas[i+1]-mas[i]-1 ;
    }
    System.out.println(sum);
  }
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter out=new PrintWriter(System.out);
  static StringTokenizer in=new StringTokenizer("");
  public static boolean hasNext()throws IOException {
    if(in.hasMoreTokens())return true ;
    String s ;
    while((s=br.readLine())!=null){
      in=new StringTokenizer(s);
      if(in.hasMoreTokens())return true ;
    }
    return false ;
  }
  public static String nextToken()throws IOException {
    while(! in.hasMoreTokens()){
      in=new StringTokenizer(br.readLine());
    }
    return in.nextToken();
  }
  public static int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public static double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  public static long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Chernovik {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var a : int ; a := nextInt() ;
    var mas : Sequence(int) ; mas := Integer.subrange(1,a)->collect(0) ;
        var i : int ; i := 0 ; while i < mas->size() do ( (     mas[i+1] := nextInt() )  ;     i := i + 1 ) ; 
    mas := mas->sort() ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < mas->size() - 1 do ( (     sum := sum+(mas[i + 1+1] - mas[i+1] - 1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclIterator := OclIterator.newOclIterator_String("");
  static   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     if (in.hasNext()) then     return true else skip ; 
     var s : String ;
         s := br.readLine() ;
    while ((s) /= null) do (    skip ; (     in := OclIterator.newOclIterator_String(s) ; 
     if (in.hasNext()) then     return true else skip ) ;     s := br.readLine() ;
 ) ;  
     return false );
  static   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (not(in.hasNext())) do (     in := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return in.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  private static long gcd(long a,long b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    long p=in.nextLong(),q=in.nextLong();
    q/=gcd(p,q);
    long ans=1 ;
    for(long i=2 ; i*i<=q ; i++){
      if(q % i!=0)continue ;
      ans*=i ;
      while(q % i==0){
        q/=i ;
      }
    }
    ans*=q ;
    out.println(ans);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var p : long ; p := in.getCurrent()->toLong() ;
    var q : long ; q := in.getCurrent()->toLong() ;
    q := q/(gcd(p, q)) ; 
    var ans : long ; ans := 1 ;
        var i : long ; i := 2 ; while i * i <= q do ( (     if (q mod i /= 0) then     continue else skip ; 
     ans := ans*(i) ; 
     while (q mod i = 0) do (     q := q/(i) ) )  ;     i := i + 1 ) ; 
    ans := ans*(q) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    solve();
  }
  public static void solve(){
    Scanner sc=new Scanner(System.in);
    int p=sc.nextInt();
    int q=sc.nextInt();
    if(q % p==0){
      q/=p ;
      p=1 ;
    }
    boolean[] judge=new boolean[(int)Math.sqrt(1000000000)+5];
    Arrays.fill(judge,true);
    judge[0]=false ;
    judge[1]=false ;
    boolean flag=false ;
    for(int i=2 ; i<judge.length ; i++){
      if(judge[i]){
        if(p % i==0 && q % i==0){
          p/=i ;
          q/=i ;
          flag=true ;
        }
        for(int j=i*2 ; j<judge.length ; j+=i){
          judge[j]=false ;
        }
        if(flag){
          flag=false ;
          i--;
        }
      }
    }
    for(int i=2 ; i<judge.length ; i++){
      if(judge[i] && q %(i*i)==0){
        q/=i ;
        i--;
      }
    }
    System.out.println(q);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : int ; p := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    if (q mod p = 0) then (     q := q/(p) ; 
     p := 1 ) else skip ; 
    var judge : Sequence(boolean) ; judge := Integer.subrange(1,(1000000000)->sqrt()->oclAsType(int) + 5)->collect(false) ;
    judge := judge->collect(true) ; 
    judge[0+1] := false ; 
    judge[1+1] := false ; 
    var flag : boolean ; flag := false ;
        var i : int ; i := 2 ; while i < judge->size() do ( (     if (judge[i+1]) then (     if (p mod i = 0 & q mod i = 0) then (     p := p/(i) ; 
     q := q/(i) ; 
     flag := true ) else skip ; 
         var j : int ; j := i * 2 ; while j < judge->size() do ( (     judge[j+1] := false )  ;     j := j+(i) ) ; 
     if (flag) then (     flag := false ; 
     i := i - 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i < judge->size() do ( (     if (judge[i+1] & q mod (i * i) = 0) then (     q := q/(i) ; 
     i := i - 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(q) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
public class GFG {
  static int countWords(String str[],int n){
    HashMap<String,Integer>m=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(m.containsKey(str[i])){
        int get=m.get(str[i]);
        m.put(str[i],get+1);
      }
      else {
        m.put(str[i],1);
      }
    }
    int res=0 ;
    for(Map.Entry<String,Integer>it : m.entrySet()){
      if(it.getValue()==2)res++;
    }
    return res ;
  }
  public static void main(String args[]){
    String s[]={
      "hate","love","peace","love","peace","hate","love","peace","love","peace" };
      int n=s.length ;
      System.out.println(countWords(s,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countWords( str : Sequence(String), n : int) : int
  pre: true
  post: true
  activity: (     var m : Map(String,int) ; m := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (m->keys()->includes(str[i+1])) then (     var get : int ; get := m->at(str[i+1]) ;
     m := m->union(Map{str[i+1] |-> get + 1}) ) else (     m := m->union(Map{str[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    for (it : m->asSet()) do ( (     if (it.getValue() = 2) then     res := res + 1 ; else skip )  ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := Sequence{"hate","love","peace","love","peace","hate","love","peace","love","peace"} ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].println(countWords(s, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class P688A_Opponents {
  public static void main(String[] subhani)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken()),d=Integer.parseInt(st.nextToken());
    String[] a=new String[d];
    for(int i=0 ; i<d ; ++i)a[i]=br.readLine();
    solve(d,a,n);
  }
  public static void solve(int d,String[] a,int n){
    int days=0,l=0,r=0 ;
    while(r<d){
      if(a[r] .contains("0")){
        days=Math.max(days,r-l+1);
      }
      else {
        l=r+1 ;
      }
      r++;
    }
    System.out.println(days);
  }
}
------------------------------------------------------------
OCL File:
---------
 class P688A_Opponents {
  static   operation main( subhani : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var d : int ; d := (st.next())->toInteger() ;
    var a : Sequence(String) ; a := Integer.subrange(1,d)->collect(null) ;
        var i : int ; i := 0 ; while i < d do (     a[i+1] := br.readLine() ;  ;     i := i + 1 ) ; 
    execute solve(d, a, n) ; 
 );
  static   operation solve( d : int, a : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (     var days : int ; days := 0 ;
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
     while (r < d) do (     if (a[r+1]->includes("0")) then (     days := Set{days, r - l + 1}->max() ) else (     l := r + 1 ) ;  
     r := r + 1 ) ; 
     OclFile["System.out"].println(days) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void main(String[] args){
    long ans=1 ;
    long mod=(long)1000000007*120 ;
    for(int i=0 ; i<5 ; i++)ans=(ans*(55555-i))% mod ;
    ans=ans/120 ;
    System.out.println("Answer using"+" shortcut: "+ans);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
     var mod : long ; mod := 1000000007->oclAsType(long) * 120 ;
        var i : int ; i := 0 ; while i < 5 do (     ans := (ans * (55555 - i)) mod mod ;  ;     i := i + 1 ) ; 
    ans := ans / 120 ; 
    OclFile["System.out"].println("Answer using" + " shortcut: " + ans) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static long getNthTerm(long N){
    return 4*(long)Math.pow(N,2)-3*N+2 ;
  }
  public static void main(String arr[]){
    long N=10 ;
    System.out.println(getNthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation getNthTerm( N : long) : long
  pre: true
  post: true
  activity: (     return 4 * N->pow(2)->oclAsType(long) - 3 * N + 2 );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := 10 ;
     OclFile["System.out"].println(getNthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class FridayNight {
  public int countconsecutivedays(String[] nums,int d,int n){
    int maxans=0 ;
    int ans=0 ;
    for(int i=0 ; i<d ; i++){
      int j ;
      for(j=0 ; j<n ; j++){
        if(nums[i] .charAt(j)!='1'){
          ans++;
          break ;
        }
        if(nums[i] .charAt(j)=='1'){
          if(j==n-1){
            ans=0 ;
            break ;
          }
        }
      }
      if(ans>maxans)maxans=ans ;
    }
    System.out.println(maxans);
    return maxans ;
  }
  public static void main(String[] args){
    FridayNight obj=new FridayNight();
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int d=sc.nextInt();
    String[] s=new String[d];
    for(int i=0 ; i<d ; i++){
      s[i]=sc.next();
    }
    obj.countconsecutivedays(s,d,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class FridayNight {
   operation countconsecutivedays( nums : Sequence(String), d : int, n : int) : int
  pre: true
  post: true
  activity: (     var maxans : int ; maxans := 0 ;
     var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < d do ( (     var j : int ;
         j := 0 ; while j < n do ( (     if (nums[i+1]->at(j+1) /= '1') then (     ans := ans + 1 ; 
     break ) else skip ; 
     if (nums[i+1]->at(j+1) = '1') then (     if (j = n - 1) then (     ans := 0 ; 
     break ) else skip ) else skip )  ;     j := j + 1 ) ; 
     if (ans > maxans) then     maxans := ans ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(maxans) ; 
    return maxans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FridayNight ; obj := FridayNight.newFridayNight() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := Integer.subrange(1,d)->collect(null) ;
        var i : int ; i := 0 ; while i < d do ( (     s[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    obj.countconsecutivedays(s, d, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class FridayNight {
  public int countconsecutivedays(String[] nums,int d,int n){
    int maxans=0 ;
    int ans=0 ;
    for(int i=0 ; i<d ; i++){
      for(int j=0 ; j<n ; j++){
        if(nums[i] .charAt(j)=='0'){
          ans++;
          break ;
        }
        if(nums[i] .charAt(j)=='1'){
          if(j==n-1){
            ans=0 ;
            break ;
          }
        }
      }
      if(ans>maxans)maxans=ans ;
    }
    System.out.println(maxans);
    return maxans ;
  }
  public static void main(String[] args){
    FridayNight obj=new FridayNight();
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int d=sc.nextInt();
    String[] s=new String[d];
    for(int i=0 ; i<d ; i++){
      s[i]=sc.next();
    }
    obj.countconsecutivedays(s,d,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class FridayNight {
   operation countconsecutivedays( nums : Sequence(String), d : int, n : int) : int
  pre: true
  post: true
  activity: (     var maxans : int ; maxans := 0 ;
     var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < d do ( (         var j : int ; j := 0 ; while j < n do ( (     if (nums[i+1]->at(j+1) = '0') then (     ans := ans + 1 ; 
     break ) else skip ; 
     if (nums[i+1]->at(j+1) = '1') then (     if (j = n - 1) then (     ans := 0 ; 
     break ) else skip ) else skip )  ;     j := j + 1 ) ; 
     if (ans > maxans) then     maxans := ans ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(maxans) ; 
    return maxans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FridayNight ; obj := FridayNight.newFridayNight() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := Integer.subrange(1,d)->collect(null) ;
        var i : int ; i := 0 ; while i < d do ( (     s[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    obj.countconsecutivedays(s, d, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] a=new int[m];
    int[] b=new int[m];
    int[] c=new int[m];
    for(int i=0 ; i<m ; i++){
      a[i]=sc.nextInt()-1 ;
      b[i]=sc.nextInt()-1 ;
      c[i]=sc.nextInt();
    }
    int[][] dist=new int[n][n];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(i==j){
          dist[i][j]=0 ;
        }
        else {
          dist[i][j]=Integer.MAX_VALUE>>1 ;
        }
      }
    }
    for(int i=0 ; i<m ; i++){
      dist[a[i] ][b[i] ]=Math.min(dist[a[i] ][b[i] ],c[i]);
      dist[b[i] ][a[i] ]=Math.min(dist[b[i] ][a[i] ],c[i]);
    }
    for(int k=0 ; k<n ; k++){
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          dist[i][j]=Math.min(dist[i][j],dist[i][k]+dist[k][j]);
        }
      }
    }
    int count=0 ;
    for(int i=0 ; i<m ; i++){
      if(dist[a[i] ][b[i] ]!=c[i]){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := sc.getCurrent()->toInteger() - 1 ; 
     b[i+1] := sc.getCurrent()->toInteger() - 1 ; 
     c[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dist : Sequence(Sequence(int)) ; dist := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (i = j) then (     dist[i+1][j+1] := 0 ) else (     dist[i+1][j+1] := (2147483647/(2->pow(1)))->oclAsType(long) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     dist[a[i+1]+1][b[i+1]+1] := Set{dist[a[i+1]+1][b[i+1]+1], c[i+1]}->min() ; 
     dist[b[i+1]+1][a[i+1]+1] := Set{dist[b[i+1]+1][a[i+1]+1], c[i+1]}->min() )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < n do ( (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     dist[i+1][j+1] := Set{dist[i+1][j+1], dist[i+1][k+1] + dist[k+1][j+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     if (dist[a[i+1]+1][b[i+1]+1] /= c[i+1]) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[][] ar=new int[n][n];
    for(int i=0 ; i<n ; i++){
      Arrays.fill(ar[i],Integer.MAX_VALUE/2);
    }
    int[] a=new int[m];
    int[] b=new int[m];
    int[] c=new int[m];
    for(int i=0 ; i<m ; i++){
      a[i]=sc.nextInt()-1 ;
      b[i]=sc.nextInt()-1 ;
      c[i]=sc.nextInt();
      ar[a[i] ][b[i] ]=c[i];
      ar[b[i] ][a[i] ]=c[i];
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        for(int k=0 ; k<n ; k++){
          if(i!=j && j!=k && i!=k){
            ar[j][k]=Math.min(ar[j][k],ar[j][i]+ar[i][k]);
          }
        }
      }
    }
    int ans=0 ;
    for(int i=0 ; i<m ; i++){
      if(ar[a[i] ][b[i] ]<c[i]){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var ar : Sequence(Sequence(int)) ; ar := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := ar[i+1]->collect(2147483647 / 2) )  ;     i := i + 1 ) ; 
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := sc.getCurrent()->toInteger() - 1 ; 
     b[i+1] := sc.getCurrent()->toInteger() - 1 ; 
    c[i+1] := sc.getCurrent()->toInteger() ; 
    ar[a[i+1]+1][b[i+1]+1] := c[i+1] ; 
    ar[b[i+1]+1][a[i+1]+1] := c[i+1] ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (         var k : int ; k := 0 ; while k < n do ( (     if (i /= j & j /= k & i /= k) then (     ar[j+1][k+1] := Set{ar[j+1][k+1], ar[j+1][i+1] + ar[i+1][k+1]}->min() ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     if (ar[a[i+1]+1][b[i+1]+1] < c[i+1]) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),j=0,c=0 ;
    int a[]=new int[n],min=Integer.MAX_VALUE,max=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      if(a[i]<min)min=a[i];
      if(a[i]>max)max=a[i];
    }
    Arrays.sort(a);
    for(int i=0 ; i<n-1 ; i++){
      if(a[i+1]-a[i]!=1)c+=a[i+1]-a[i]-1 ;
      j++;
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var j : int ; j := 0 ;
    var c : int ; c := 0 ;
    var a : Sequence(void) ; a := Integer.subrange(1,n)->collect(0) ;
    var min : int ; min := 2147483647 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (a[i+1] < min) then     min := a[i+1] ; else skip ; 
     if (a[i+1] > max) then     max := a[i+1] ; else skip )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (a[i + 1+1] - a[i+1] /= 1) then     c := c+(a[i + 1+1] - a[i+1] - 1) ; else skip ; 
     j := j + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.lang.Math ;
class GfG {
  static int maxCount(int n,int a[]){
    HashMap<Integer,Integer>freq=new HashMap<>();
    for(int i=0 ; i<n ; ++i){
      if(freq.containsKey(a[i]))freq.put(a[i],freq.get(a[i])+1);
      else freq.put(a[i],1);
    }
    int ans=0 ;
    for(Integer key : freq.keySet()){
      if(freq.containsKey(key+1))ans=Math.max(ans,freq.get(key)+freq.get(key+1));
    }
    return ans ;
  }
  public static void main(String[] args){
    int n=5 ;
    int arr[]={
      2,2,3,4,5 };
      System.out.println(maxCount(n,arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation maxCount( n : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var freq : Map(int,int) ; freq := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (freq->keys()->includes(a[i+1])) then     freq := freq->union(Map{a[i+1] |-> freq->at(a[i+1]) + 1}) ; else     freq := freq->union(Map{a[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (key : freq->keys()) do ( (     if (freq->keys()->includes(key + 1)) then     ans := Set{ans, freq->at(key) + freq->at(key + 1)}->max() ; else skip )  ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var arr : Sequence(int) ; arr := Sequence{2,2,3,4,5} ;
     OclFile["System.out"].println(maxCount(n, arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int totalSum(int a[],int n){
    int i,sum=0,sum1=0,j ;
    for(i=0 ; i<n ; i++){
      sum1=0 ;
      for(j=i ; j<n ; j++){
        sum1=(sum1 | a[j]);
        sum=sum+sum1 ;
      }
    }
    return sum ;
  }
  public static void main(String args[]){
    int a[]={
      1,2,3,4,5 };
      int n=a.length ;
      System.out.println(totalSum(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation totalSum( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var sum : int ; sum := 0 ;
    var sum1 : int ; sum1 := 0 ;
    var j : int ;
         i := 0 ; while i < n do ( (     sum1 := 0 ; 
         j := i ; while j < n do ( (     sum1 := (MathLib.bitwiseOr(sum1,a[j+1])) ; 
     sum := sum + sum1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,4,5} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(totalSum(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  static int[] nums ;
  static boolean[] used ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    words=br.readLine().split(" ");
    nums=new int[9];
    used=new boolean[10];
    for(int i=0 ; i<words.length ; i++){
      nums[i]=parseInt(words[i]);
      if(nums[i]!=-1)used[nums[i] ]=true ;
    }
    System.out.println(solve(0));
  }
  static int solve(int idx){
    if(idx==nums.length){
      if(check())return 1 ;
      else return 0 ;
    }
    int ret=0 ;
    if(nums[idx]==-1){
      for(int k=1 ; k<=9 ; k++){
        if(! used[k]){
          nums[idx]=k ;
          used[k]=true ;
          ret+=solve(idx+1);
          nums[idx]=-1 ;
          used[k]=false ;
        }
      }
    }
    else {
      ret=solve(idx+1);
    }
    return ret ;
  }
  static boolean check(){
    return nums[0]+nums[1]*10+nums[2]+nums[3]*100+nums[4]*10+nums[5]==nums[6]*100+nums[7]*10+nums[8];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute nums : Sequence(int);
  static   attribute used : Sequence(boolean);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    words := br.readLine()->split(" ") ; 
    nums := Integer.subrange(1,9)->collect(0) ; 
    used := Integer.subrange(1,10)->collect(false) ; 
        var i : int ; i := 0 ; while i < words->size() do ( (     nums[i+1] := (words[i+1] + "")->toInteger() ; 
     if (nums[i+1] /= -1) then     used[nums[i+1]+1] := true ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(0)) ; 
 );
  static   operation solve( idx : int) : int
  pre: true
  post: true
  activity: (     if (idx = nums->size()) then (     if (check()) then     return 1 else     return 0 ) else skip ; 
     var ret : int ; ret := 0 ;
     if (nums[idx+1] = -1) then (         var k : int ; k := 1 ; while k <= 9 do ( (     if (not(used[k+1])) then (     nums[idx+1] := k ; 
     used[k+1] := true ; 
    ret := ret+(solve(idx + 1)) ; 
    nums[idx+1] := -1 ; 
    used[k+1] := false ; 
 ) else skip )  ;     k := k + 1 ) ) else (     ret := solve(idx + 1) ) ;  
     return ret );
  static   operation check() : boolean
  pre: true
  post: true
  activity: (     return nums[0+1] + nums[1+1] * 10 + nums[2+1] + nums[3+1] * 100 + nums[4+1] * 10 + nums[5+1] = nums[6+1] * 100 + nums[7+1] * 10 + nums[8+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  static int[] nums ;
  static boolean[] used ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    words=br.readLine().split(" ");
    nums=new int[9];
    used=new boolean[10];
    for(int i=0 ; i<words.length ; i++){
      nums[i]=parseInt(words[i]);
      if(nums[i]!=-1)used[nums[i] ]=true ;
    }
    System.out.println(solve(0));
  }
  static int solve(int idx){
    if(idx==nums.length){
      int a=nums[3]*100+(nums[1]+nums[4])*10+nums[0]+nums[2]+nums[5];
      int b=nums[6]*100+nums[7]*10+nums[8];
      if(a==b)return 1 ;
      else return 0 ;
    }
    int ret=0 ;
    if(nums[idx]==-1){
      for(int k=1 ; k<=9 ; k++){
        if(! used[k]){
          nums[idx]=k ;
          used[k]=true ;
          ret+=solve(idx+1);
          nums[idx]=-1 ;
          used[k]=false ;
        }
      }
    }
    else {
      ret=solve(idx+1);
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute nums : Sequence(int);
  static   attribute used : Sequence(boolean);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    words := br.readLine()->split(" ") ; 
    nums := Integer.subrange(1,9)->collect(0) ; 
    used := Integer.subrange(1,10)->collect(false) ; 
        var i : int ; i := 0 ; while i < words->size() do ( (     nums[i+1] := (words[i+1] + "")->toInteger() ; 
     if (nums[i+1] /= -1) then     used[nums[i+1]+1] := true ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(0)) ; 
 );
  static   operation solve( idx : int) : int
  pre: true
  post: true
  activity: (     if (idx = nums->size()) then (     var a : int ; a := nums[3+1] * 100 + (nums[1+1] + nums[4+1]) * 10 + nums[0+1] + nums[2+1] + nums[5+1] ;
     var b : int ; b := nums[6+1] * 100 + nums[7+1] * 10 + nums[8+1] ;
     if (a = b) then     return 1 else     return 0 ) else skip ; 
     var ret : int ; ret := 0 ;
     if (nums[idx+1] = -1) then (         var k : int ; k := 1 ; while k <= 9 do ( (     if (not(used[k+1])) then (     nums[idx+1] := k ; 
     used[k+1] := true ; 
    ret := ret+(solve(idx + 1)) ; 
    nums[idx+1] := -1 ; 
    used[k+1] := false ; 
 ) else skip )  ;     k := k + 1 ) ) else (     ret := solve(idx + 1) ) ;  
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.HashMap ;
import java.util.List ;
import java.util.ArrayList ;
import java.util.Map.Entry ;
import java.util.Comparator ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    String[] S=new String[N];
    for(int i=0 ; i<N ; i++){
      S[i]=sc.next();
    }
    sc.close();
    HashMap<String,Integer>mp=new HashMap<>();
    for(int i=0 ; i<N ; i++){
      mp.put(S[i],mp.getOrDefault(S[i],0)+1);
    }
    List<String>res=new ArrayList<>();
    int max_val=0 ;
    for(Entry<String,Integer>e : mp.entrySet()){
      max_val=Math.max(max_val,e.getValue());
    }
    for(Entry<String,Integer>e : mp.entrySet()){
      if(max_val==e.getValue()){
        res.add(e.getKey());
      }
    }
    res.sort(Comparator.naturalOrder());
    for(String s : res){
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var S : Sequence(String) ; S := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     S[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    skip ; 
    var mp : Map(String,int) ; mp := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     mp := mp->union(Map{S[i+1] |-> (if mp->keys()->contains(S[i+1]) then mp->at(S[i+1]) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var res : Sequence(String) ; res := Sequence{} ;
    var max_val : int ; max_val := 0 ;
    for (e : mp->asSet()) do ( (     max_val := Set{max_val, e.getValue()}->max() )  ) ; 
    for (e : mp->asSet()) do ( (     if (max_val = e.getValue()) then (     res := res->including(e.getKey()) ) else skip )  ) ; 
    res := res.sort(Comparator.naturalOrder()) ; 
    for (s : res) do ( (     OclFile["System.out"].println(s) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void PossibleValues(int b,int x,int n){
    int leastdivisible=(b/x+1)*x ;
    int flag=1 ;
    while(leastdivisible<=n){
      if(leastdivisible-b>=1){
        System.out.print(leastdivisible-b+" ");
        leastdivisible+=x ;
        flag=0 ;
      }
      else break ;
    }
    if(flag>0)System.out.println(-1);
  }
  public static void main(String[] args){
    int b=10,x=6,n=40 ;
    PossibleValues(b,x,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation PossibleValues( b : int, x : int, n : int) : void
  pre: true
  post: true
  activity: (     var leastdivisible : int ; leastdivisible := (b / x + 1) * x ;
     var flag : int ; flag := 1 ;
     while (leastdivisible <= n) do (     if (leastdivisible - b >= 1) then (     OclFile["System.out"].print(leastdivisible - b + " ") ; 
     leastdivisible := leastdivisible+(x) ; 
     flag := 0 ) else     break ) ; 
     if (flag > 0) then     OclFile["System.out"].println(-1) ; else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var b : int ; b := 10 ;
    var x : int ; x := 6 ;
    var n : int ; n := 40 ;
     execute PossibleValues(b, x, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int count=scanner.nextInt();
    scanner.nextLine();
    List<String>list=new ArrayList<>();
    for(int i=0 ; i<count ; i++){
      list.add(scanner.nextLine());
    }
    Map<String,Long>grouped=list.stream().collect(Collectors.groupingBy(x->x,Collectors.counting()));
    Map<Long,List<String>>map=grouped.keySet().stream().collect(Collectors.groupingBy(grouped :: get));
    long max=map.keySet().stream().mapToLong(m->m).max().getAsLong();
    map.get(max).stream().sorted().forEach(System.out :: println);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := scanner.getCurrent()->toInteger() ;
    skip ; 
    var list : Sequence(String) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < count do ( (     list := list->including(scanner.nextLine()) )  ;     i := i + 1 ) ; 
    var grouped : Map(String,long) ; grouped := list.collect(Collectors.groupingBy(lambda x : OclAny in x, Collectors.counting())) ;
    var map : Map(long,Sequence(String)) ; map := grouped->keys().collect(Collectors.groupingBy(lambda _pars : OclAny in grouped.newgrouped().get(_pars))) ;
    var max : long ; max := map->keys()->collect( _x1 | (lambda m : OclAny in m)->apply(_x1) ).max().getAsLong() ;
    for _forEach : map->at(max)->sort() do
    (    skip ;) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    Map<String,Integer>tV=new TreeMap<>();
    int nV=scn.nextInt();
    int[] VList=new int[nV];
    for(int i=0 ; i<nV ; i++){
      String v=scn.next();
      if(! tV.isEmpty()){
        if(tV.containsKey(v)){
          tV.put(v,tV.get(v)+1);
        }
        else {
          tV.put(v,1);
        }
      }
      else {
        tV.put(v,1);
      }
      VList[i]=tV.get(v);
    }
    Arrays.sort(VList);
    if(VList[nV-1]==VList[0]){
      for(Map.Entry<String,Integer>vote : tV.entrySet()){
        System.out.println(vote.getKey().toString());
      }
    }
    else {
      if(VList[0]!=VList[nV-1]){
        for(Map.Entry<String,Integer>vote : tV.entrySet()){
          if(vote.getValue()==VList[nV-1]){
            System.out.println(vote.getKey().toString());
          }
        }
      }
    }
    scn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tV : Map(String,int) ; tV := Map{} ;
    var nV : int ; nV := scn.getCurrent()->toInteger() ;
    var VList : Sequence(int) ; VList := Integer.subrange(1,nV)->collect(0) ;
        var i : int ; i := 0 ; while i < nV do ( (     var v : String ; v := scn.getCurrent() ;
     if (not(tV->isEmpty())) then (     if (tV->keys()->includes(v)) then (     tV := tV->union(Map{v |-> tV->at(v) + 1}) ) else (     tV := tV->union(Map{v |-> 1}) ) ) else (     tV := tV->union(Map{v |-> 1}) ) ;  
     VList[i+1] := tV->at(v) )  ;     i := i + 1 ) ; 
    VList := VList->sort() ; 
    if (VList[nV - 1+1] = VList[0+1]) then (     for (vote : tV->asSet()) do ( (     OclFile["System.out"].println(vote.getKey()+"") )  ) ) else (     if (VList[0+1] /= VList[nV - 1+1]) then (     for (vote : tV->asSet()) do ( (     if (vote.getValue() = VList[nV - 1+1]) then (     OclFile["System.out"].println(vote.getKey()+"") ) else skip )  ) ) else skip ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.function.Predicate ;
import java.util.stream.Collectors ;
import java.util.stream.Stream ;
import static java.util.Map.Entry.comparingByKey ;
import static java.util.Map.Entry.comparingByValue ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.nextLine());
    Map<String,Integer>map=new HashMap<>();
    for(int i=0 ; i<N ; i++){
      String s=sc.nextLine();
      Integer c=map.get(s);
      if(c==null){
        map.put(s,0);
      }
      else {
        map.put(s,c+1);
      }
    }
    List<Map.Entry<String,Integer>>collect=map.entrySet().stream().sorted(comparingByKey()).sorted(Collections.reverseOrder(comparingByValue())).collect(Collectors.toList());
    int max=0 ;
    for(Map.Entry<String,Integer>e : collect){
      if(max<=e.getValue()){
        max=e.getValue();
        System.out.println(e.getKey());
      }
      else {
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.nextLine())->toInteger() ;
    var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     var s : String ; s := sc.nextLine() ;
     var c : int ; c := map->at(s) ;
     if (c = null) then (     map := map->union(Map{s |-> 0}) ) else (     map := map->union(Map{s |-> c + 1}) ) )  ;     i := i + 1 ) ; 
    var collect : Sequence(Map(String,int)) ; collect := map->asSet()->sort()->sort().collect(Collectors.toList()) ;
    var max : int ; max := 0 ;
    for (e : collect) do ( (     if (max <= e.getValue()) then (     max := e.getValue() ; 
     OclFile["System.out"].println(e.getKey()) ) else (     break ) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Heist {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Integer>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      list.add(sc.nextInt());
    }
    System.out.println(solve(list));
  }
  static int solve(List<Integer>arr){
    int res=0 ;
    Collections.sort(arr);
    for(int i=0 ; i<arr.size()-1 ; i++){
      if(arr.get(i+1)-arr.get(i)!=1){
        res+=(arr.get(i+1)-arr.get(i)-1);
      }
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Heist {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(list)) ; 
 );
  static   operation solve( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     arr := arr->sort() ; 
         var i : int ; i := 0 ; while i < arr->size() - 1 do ( (     if (arr->at(i + 1+1) - arr->at(i+1) /= 1) then (     res := res+((arr->at(i + 1+1) - arr->at(i+1) - 1)) ) else skip )  ;     i := i + 1 ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int N=gi();
    String[] S=new String[N];
    Map<String,Integer>m=new HashMap<String,Integer>();
    int max=1 ;
    for(int i=0 ; i<N ; i++){
      S[i]=gs();
      if(m.containsKey(S[i])){
        int n=m.get(S[i])+1 ;
        m.put(S[i],n);
        if(n>max)max=n ;
      }
      else {
        m.put(S[i],1);
      }
    }
    List<String>ss=new ArrayList<String>();
    for(Map.Entry<String,Integer>entry : m.entrySet()){
      if(entry.getValue()==max){
        ss.add(entry.getKey());
      }
    }
    Collections.sort(ss);
    for(int i=0 ; i<ss.size(); i++){
      System.out.println(ss.get(i));
    }
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : int ; N := gi() ;
    var S : Sequence(String) ; S := Integer.subrange(1,N)->collect(null) ;
    var m : Map(String,int) ; m := Map{} ;
    var max : int ; max := 1 ;
        var i : int ; i := 0 ; while i < N do ( (     S[i+1] := gs() ; 
     if (m->keys()->includes(S[i+1])) then (     var n : int ; n := m->at(S[i+1]) + 1 ;
     m := m->union(Map{S[i+1] |-> n}) ; 
     if (n > max) then     max := n ; else skip ) else (     m := m->union(Map{S[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var ss : Sequence(String) ; ss := Sequence{} ;
    for (entry : m->asSet()) do ( (     if (entry.getValue() = max) then (     ss := ss->including(entry.getKey()) ) else skip )  ) ; 
    ss := ss->sort() ; 
        var i : int ; i := 0 ; while i < ss->size() do ( (     OclFile["System.out"].println(ss->at(i+1)) )  ;     i := i + 1 ) ; 
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++)A[i]=sc.nextInt();
    System.out.println(win(A)? "First" : "Second");
    sc.close();
  }
  static boolean win(int[] A){
    int N=A.length ;
    int even=0 ;
    for(int i=0 ; i<N ; i++)if(A[i] % 2==0)even++;
    if(even % 2==1){
      return true ;
    }
    else {
      if(even==N-1){
        for(int i=0 ; i<N ; i++){
          if(A[i] % 2==1){
            if(A[i]==1)return false ;
            A[i]--;
            break ;
          }
        }
        int gcd=A[0];
        for(int i=1 ; i<N ; i++)gcd=gcd(gcd,A[i]);
        for(int i=0 ; i<N ; i++)A[i]/=gcd ;
        return ! win(A);
      }
      else {
        return false ;
      }
    }
  }
  static int gcd(int a,int b){
    return a % b==0 ? b : gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     A[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if win(A) then "First" else "Second" endif) ; 
    skip ; 
 );
  static   operation win( A : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var N : int ; N := A->size() ;
     var even : int ; even := 0 ;
         var i : int ; i := 0 ; while i < N do (     if (A[i+1] mod 2 = 0) then     even := even + 1 ; else skip ;  ;     i := i + 1 ) ; 
     if (even mod 2 = 1) then (     return true ) else (     if (even = N - 1) then (         var i : int ; i := 0 ; while i < N do ( (     if (A[i+1] mod 2 = 1) then (     if (A[i+1] = 1) then     return false else skip ; 
     A[i+1] := A[i+1] - 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     var gcd : int ; gcd := A[0+1] ;
        var i : int ; i := 1 ; while i < N do (     gcd := gcd(gcd, A[i+1]) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do (     A[i+1] := A[i+1]/(gcd) ;  ;     i := i + 1 ) ; 
    return not(win(A)) 
 ) else (     return false ) ) );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if a mod b = 0 then b else gcd(b, a mod b) endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    long[] A=new long[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
    }
    System.out.println(solve(A)? "First" : "Second");
  }
  static boolean solve(long[] A){
    int N=A.length ;
    long sum=0 ;
    ArrayList<Integer>oddIdx=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      sum+=A[i];
      if(A[i] % 2==1){
        oddIdx.add(i);
      }
    }
    sum-=N ;
    if(sum % 2==1){
      return true ;
    }
    if(oddIdx.size()!=1){
      return false ;
    }
    if(A[oddIdx.get(0)]==1){
      return false ;
    }
    A[oddIdx.get(0)]--;
    long gcd=A[0];
    for(int i=1 ; i<N ; i++){
      gcd=gcd(gcd,A[i]);
    }
    for(int i=0 ; i<N ; i++){
      A[i]/=gcd ;
    }
    return ! solve(A);
  }
  static long gcd(long a,long b){
    return b==0 ? a : gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
         var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if solve(A) then "First" else "Second" endif) );
  static   operation solve( A : Sequence(long)) : boolean
  pre: true
  post: true
  activity: (     var N : int ; N := A->size() ;
     var sum : long ; sum := 0 ;
    var oddIdx : Sequence(int) ; oddIdx := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     sum := sum+(A[i+1]) ; 
     if (A[i+1] mod 2 = 1) then (     oddIdx := oddIdx->including(i) ) else skip )  ;     i := i + 1 ) ; 
    sum := sum-(N) ; 
    if (sum mod 2 = 1) then (     return true ) else skip ; 
    if (oddIdx->size() /= 1) then (     return false ) else skip ; 
    if (A[oddIdx->at(0+1)+1] = 1) then (     return false ) else skip ; 
    A[oddIdx->at(0+1)+1] := A[oddIdx->at(0+1)+1] - 1 ; 
    var gcd : long ; gcd := A[0+1] ;
        var i : int ; i := 1 ; while i < N do ( (     gcd := gcd(gcd, A[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := A[i+1]/(gcd) )  ;     i := i + 1 ) ; 
    return not(solve(A)) 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static long pref[]=new long[100010];
  static boolean isPerfectSquare(int x){
    int s=(int)Math.sqrt(x);
    return(s*s==x);
  }
  static int isNonFibonacci(int n){
    if(isPerfectSquare(5*n*n+4)|| isPerfectSquare(5*n*n-4))return 0 ;
    else return n ;
  }
  static void compute(){
    for(int i=1 ; i<=100000 ; ++i){
      pref[i]=pref[i-1]+isNonFibonacci(i);
    }
  }
  static void printSum(int L,int R){
    int sum=(int)(pref[R]-pref[L-1]);
    System.out.print(sum+" ");
  }
  public static void main(String[] args){
    compute();
    int Q=2 ;
    int arr[][]={
      {
        1,5 },{
          6,10 }
        };
        for(int i=0 ; i<Q ; i++){
          printSum(arr[i][0],arr[i][1]);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute pref : long := Integer.subrange(1,100010)->collect(0);
  static   operation isPerfectSquare( x : int) : boolean
  pre: true
  post: true
  activity: (     var s : int ; s := (x)->sqrt()->oclAsType(int) ;
     return (s * s = x) );
  static   operation isNonFibonacci( n : int) : int
  pre: true
  post: true
  activity: (     if (isPerfectSquare(5 * n * n + 4) or isPerfectSquare(5 * n * n - 4)) then     return 0 else     return n );
  static   operation compute() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= 100000 do ( (     pref[i+1] := pref[i - 1+1] + isNonFibonacci(i) )  ;     i := i + 1 ) );
  static   operation printSum( L : int, R : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := (pref[R+1] - pref[L - 1+1])->oclAsType(int) ;
     OclFile["System.out"].print(sum + " ") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute compute() ; 
     var Q : int ; Q := 2 ;
     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,5},Sequence{6,10}} ;
         var i : int ; i := 0 ; while i < Q do ( (     execute printSum(arr[i+1][0+1], arr[i+1][1+1]) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int ain=sc.nextInt()*3600+sc.nextInt()*60+sc.nextInt();
    int aout=sc.nextInt()*3600+sc.nextInt()*60+sc.nextInt();
    int bin=sc.nextInt()*3600+sc.nextInt()*60+sc.nextInt();
    int bout=sc.nextInt()*3600+sc.nextInt()*60+sc.nextInt();
    int cin=sc.nextInt()*3600+sc.nextInt()*60+sc.nextInt();
    int cout=sc.nextInt()*3600+sc.nextInt()*60+sc.nextInt();
    int a=aout-ain ;
    int b=bout-bin ;
    int c=cout-cin ;
    System.out.println(a/3600+" "+(a % 3600)/60+" "+((a % 3600)% 60));
    System.out.println(b/3600+" "+(b % 3600)/60+" "+((b % 3600)% 60));
    System.out.println(c/3600+" "+(c % 3600)/60+" "+((c % 3600)% 60));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ain : int ; ain := sc.getCurrent()->toInteger() * 3600 + sc.getCurrent()->toInteger() * 60 + sc.getCurrent()->toInteger() ;
    var aout : int ; aout := sc.getCurrent()->toInteger() * 3600 + sc.getCurrent()->toInteger() * 60 + sc.getCurrent()->toInteger() ;
    var bin : int ; bin := sc.getCurrent()->toInteger() * 3600 + sc.getCurrent()->toInteger() * 60 + sc.getCurrent()->toInteger() ;
    var bout : int ; bout := sc.getCurrent()->toInteger() * 3600 + sc.getCurrent()->toInteger() * 60 + sc.getCurrent()->toInteger() ;
    var cin : int ; cin := sc.getCurrent()->toInteger() * 3600 + sc.getCurrent()->toInteger() * 60 + sc.getCurrent()->toInteger() ;
    var cout : int ; cout := sc.getCurrent()->toInteger() * 3600 + sc.getCurrent()->toInteger() * 60 + sc.getCurrent()->toInteger() ;
    var a : int ; a := aout - ain ;
    var b : int ; b := bout - bin ;
    var c : int ; c := cout - cin ;
    OclFile["System.out"].println(a / 3600 + " " + (a mod 3600) / 60 + " " + ((a mod 3600) mod 60)) ; 
    OclFile["System.out"].println(b / 3600 + " " + (b mod 3600) / 60 + " " + ((b mod 3600) mod 60)) ; 
    OclFile["System.out"].println(c / 3600 + " " + (c mod 3600) / 60 + " " + ((c mod 3600) mod 60)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.String.*;
import static java.lang.System.*;
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner scan=null ;
    try {
      scan=new Scanner(System.in);
      for(int z=0 ; z!=3 ; z++){
        int[][] time=new int[2][3];
        for(int i=0 ; i<time.length ; i++){
          for(int j=0 ; j<time[i] .length ; j++){
            time[i][j]=scan.nextInt();
          }
        }
        int[] sec=new int[2];
        for(int i=0 ; i<2 ; i++){
          sec[0]+=time[0][i];
          sec[1]+=time[1][i];
          sec[0]*=60 ;
          sec[1]*=60 ;
        }
        sec[0]+=time[0][2];
        sec[1]+=time[1][2];
        int second=sec[1]-sec[0];
        int hour=second/3600 ;
        second %=3600 ;
        int minute=second/60 ;
        second %=60 ;
        out.println(valueOf(hour)+" "+valueOf(minute)+" "+valueOf(second));
      }
    }
    finally {
      if(scan!=null)scan.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := null ;
     try (     scan := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
         var z : int ; z := 0 ; while z /= 3 do ( (     var time : Sequence(Sequence(int)) ; time := Integer.subrange(1,2)->collect(Integer.subrange(1,3)->collect(0)) ;
         var i : int ; i := 0 ; while i < time->size() do ( (         var j : int ; j := 0 ; while j < time[i+1]->size() do ( (     time[i+1][j+1] := scan.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sec : Sequence(int) ; sec := Integer.subrange(1,2)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 do ( (     sec[0+1] := sec[0+1]+(time[0+1][i+1]) ; 
     sec[1+1] := sec[1+1]+(time[1+1][i+1]) ; 
     sec[0+1] := sec[0+1]*(60) ; 
     sec[1+1] := sec[1+1]*(60) )  ;     i := i + 1 ) ; 
    sec[0+1] := sec[0+1]+(time[0+1][2+1]) ; 
    sec[1+1] := sec[1+1]+(time[1+1][2+1]) ; 
    var second : int ; second := sec[1+1] - sec[0+1] ;
    var hour : int ; hour := second / 3600 ;
    second := second mod 3600 ; 
    var minute : int ; minute := second / 60 ;
    second := second mod 60 ; 
    out.println(valueOf(hour) + " " + valueOf(minute) + " " + valueOf(second)) ; 
 )  ;     z := z + 1 ) )   finally (     if (scan /= null) then     skip ; else skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    for(int i=0 ; i<3 ; i++){
      int h1=sc.nextInt();
      int m1=sc.nextInt();
      int s1=sc.nextInt();
      int h2=sc.nextInt();
      int m2=sc.nextInt();
      int s2=sc.nextInt();
      int h=h2-h1 ;
      int m=m2-m1 ;
      int s=s2-s1 ;
      if(s<0){
        s+=60 ;
        m--;
      }
      if(m<0){
        m+=60 ;
        h--;
      }
      println(h+" "+m+" "+s);
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 3 do ( (     var h1 : int ; h1 := sc.getCurrent()->toInteger() ;
     var m1 : int ; m1 := sc.getCurrent()->toInteger() ;
    var s1 : int ; s1 := sc.getCurrent()->toInteger() ;
    var h2 : int ; h2 := sc.getCurrent()->toInteger() ;
    var m2 : int ; m2 := sc.getCurrent()->toInteger() ;
    var s2 : int ; s2 := sc.getCurrent()->toInteger() ;
    var h : int ; h := h2 - h1 ;
    var m : int ; m := m2 - m1 ;
    var s : int ; s := s2 - s1 ;
    if (s < 0) then (     s := s+(60) ; 
     m := m - 1 ) else skip ; 
    if (m < 0) then (     m := m+(60) ; 
     h := h - 1 ) else skip ; 
    execute println(h + " " + m + " " + s) ; 
 )  ;     i := i + 1 ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void reverseArray(int arr[],int n){
    int x=(Integer.MIN_VALUE/Integer.MAX_VALUE);
    for(int i=0 ; i<n/2 ; i++)swap(arr,i,n+(x*i)+x);
  }
  static int[] swap(int[] arr,int i,int j){
    int temp=arr[i];
    arr[i]=arr[j];
    arr[j]=temp ;
    return arr ;
  }
  public static void main(String[] args){
    int arr[]={
      5,3,7,2,1,6 };
      int n=arr.length ;
      reverseArray(arr,n);
      for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation reverseArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var x : int ; x := (-2147483648 / 2147483647) ;
         var i : int ; i := 0 ; while i < n / 2 do (     execute swap(arr, i, n + (x * i) + x) ;  ;     i := i + 1 ) );
  static   operation swap( arr : Sequence(int), i : int, j : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := arr[j+1] ; 
     arr[j+1] := temp ; 
     return arr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,3,7,2,1,6} ;
     var n : int ; n := arr->size() ;
     execute reverseArray(arr, n) ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    boolean[] arg=null ;
    int length=0,out=0 ;
    int i=0,rou=0,store=1,sc=0 ;
    int state=0 ;
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String line ;
      while((line=br.readLine())!=null){
        i++;
        String[] tokens=line.split(" ");
        int[] time=new int[line.length()];
        int[] result=new int[3];
        for(int k=0 ; k<tokens.length ; k++){
          time[k]=Integer.parseInt(tokens[k]);
        }
        if(time[2]>time[5]){
          time[1]++;
          result[0]=(60-time[2]+time[5]);
        }
        else {
          result[0]=(time[5]-time[2]);
        }
        if(time[1]>time[4]){
          time[0]++;
          result[1]=(60-time[1]+time[4]);
        }
        else {
          result[1]=(time[4]-time[1]);
        }
        result[2]=time[3]-time[0];
        System.out.println(result[2]+" "+result[1]+" "+result[0]);
        if(i==3){
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arg : Sequence(boolean) ; arg := null ;
     var length : int ; length := 0 ;
    var out : int ; out := 0 ;
    var i : int ; i := 0 ;
    var rou : int ; rou := 0 ;
    var store : int ; store := 1 ;
    var sc : int ; sc := 0 ;
    var state : int ; state := 0 ;
    try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     i := i + 1 ; 
     var tokens : Sequence(String) ; tokens := line->split(" ") ;
    var time : Sequence(int) ; time := Integer.subrange(1,line->size())->collect(0) ;
    var result : Sequence(int) ; result := Integer.subrange(1,3)->collect(0) ;
        var k : int ; k := 0 ; while k < tokens->size() do ( (     time[k+1] := (tokens[k+1])->toInteger() )  ;     k := k + 1 ) ; 
    if (time[2+1] > time[5+1]) then (     time[1+1] := time[1+1] + 1 ; 
     result[0+1] := (60 - time[2+1] + time[5+1]) ) else (     result[0+1] := (time[5+1] - time[2+1]) ) ;  
    if (time[1+1] > time[4+1]) then (     time[0+1] := time[0+1] + 1 ; 
     result[1+1] := (60 - time[1+1] + time[4+1]) ) else (     result[1+1] := (time[4+1] - time[1+1]) ) ;  
    result[2+1] := time[3+1] - time[0+1] ; 
    OclFile["System.out"].println(result[2+1] + " " + result[1+1] + " " + result[0+1]) ; 
    if (i = 3) then (     break ) else skip ; 
 ) ;     line := br.readLine() ;
 ) ))  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int time=60 ;
  final static int numPerson=3 ;
  static int[] calcTime(int[] after,int[] before){
    int[] ans=new int[3];
    for(int r=0 ; r<ans.length ; r++){
      ans[r]=after[r]-before[r];
    }
    int secCheck=0,minCheck=0 ;
    if(ans[2]<0){
      ans[2]+=60 ;
      secCheck=-1 ;
    }
    ans[1]+=secCheck ;
    if(ans[1]<0){
      ans[1]+=60 ;
      minCheck=-1 ;
    }
    ans[0]+=minCheck ;
    return(ans);
  }
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int[][] ans=new int[numPerson][];
    for(int k=0 ; k<numPerson ; k++){
      int[] before=new int[3];
      int[] after=new int[3];
      for(int r=0 ; r<2 ; r++){
        for(int c=0 ; c<3 ; c++){
          if(r==0)before[c]=stdIn.nextInt();
          else after[c]=stdIn.nextInt();
        }
      }
      ans[k]=calcTime(after,before);
    }
    for(int r=0 ; r<numPerson ; r++){
      for(int c=0 ; c<3 ; c++){
        System.out.print(ans[r][c]);
        System.out.print((c==2)? '\n' : ' ');
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute time : int := 60;
  static   attribute numPerson : int := 3;
  static   operation calcTime( after : Sequence(int), before : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Integer.subrange(1,3)->collect(0) ;
         var r : int ; r := 0 ; while r < ans->size() do ( (     ans[r+1] := after[r+1] - before[r+1] )  ;     r := r + 1 ) ; 
    var secCheck : int ; secCheck := 0 ;
    var minCheck : int ; minCheck := 0 ;
    if (ans[2+1] < 0) then (     ans[2+1] := ans[2+1]+(60) ; 
     secCheck := -1 ) else skip ; 
    ans[1+1] := ans[1+1]+(secCheck) ; 
    if (ans[1+1] < 0) then (     ans[1+1] := ans[1+1]+(60) ; 
     minCheck := -1 ) else skip ; 
    ans[0+1] := ans[0+1]+(minCheck) ; 
    return (ans) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ans : Sequence(Sequence(int)) ; ans := Integer.subrange(1,numPerson)->collect(Sequence{}) ;
         var k : int ; k := 0 ; while k < numPerson do ( (     var before : Sequence(int) ; before := Integer.subrange(1,3)->collect(0) ;
     var after : Sequence(int) ; after := Integer.subrange(1,3)->collect(0) ;
         var r : int ; r := 0 ; while r < 2 do ( (         var c : int ; c := 0 ; while c < 3 do ( (     if (r = 0) then     before[c+1] := stdIn.getCurrent()->toInteger() ; else     after[c+1] := stdIn.getCurrent()->toInteger() ; )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
     ans[k+1] := calcTime(after, before) )  ;     k := k + 1 ) ; 
         var r : int ; r := 0 ; while r < numPerson do ( (         var c : int ; c := 0 ; while c < 3 do ( (     OclFile["System.out"].print(ans[r+1][c+1]) ; 
     OclFile["System.out"].print(if (c = 2) then '
' else ' ' endif) )  ;     c := c + 1 ) )  ;     r := r + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    Arrays.sort(a);
    int min=a[0],max=a[n-1];
    int res=max-min+1-n ;
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var min : int ; min := a[0+1] ;
    var max : int ; max := a[n - 1+1] ;
    var res : int ; res := max - min + 1 - n ;
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int power(int x,int y){
    int res=1 ;
    while(y>0){
      if((y & 1)==1)res=res*x ;
      y=y>>1 ;
      x=x*x ;
    }
    return res ;
  }
  public static void main(String[] args){
    int x=3 ;
    int y=5 ;
    System.out.println("Power is "+power(x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation power( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     while (y > 0) do (     if ((y & 1) = 1) then     res := res * x ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := x * x ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 3 ;
     var y : int ; y := 5 ;
     OclFile["System.out"].println("Power is " + power(x, y)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int power(int x,int y,int p){
    int res=1 ;
    x=x % p ;
    if(x==0)return 0 ;
    while(y>0){
      if((y & 1)==1)res=(res*x)% p ;
      y=y>>1 ;
      x=(x*x)% p ;
    }
    return res ;
  }
  public static void main(String args[]){
    int x=2 ;
    int y=5 ;
    int p=13 ;
    System.out.println("Power is "+power(x,y,p));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation power( x : int, y : int, p : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     x := x mod p ; 
    if (x = 0) then     return 0 else skip ; 
    while (y > 0) do (     if ((y & 1) = 1) then     res := (res * x) mod p ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 2 ;
     var y : int ; y := 5 ;
     var p : int ; p := 13 ;
     OclFile["System.out"].println("Power is " + power(x, y, p)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static int summation(int n){
    int sum=0 ;
    for(int i=1 ; i<=n ; i++)sum+=(i*i);
    return sum ;
  }
  public static void main(String args[]){
    int n=2 ;
    System.out.println(summation(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation summation( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do (     sum := sum+((i * i)) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(summation(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int count_minimum_operations(long n){
    int count=0 ;
    while(n>1){
      if(n % 3==0)n/=3 ;
      else if(n % 3==1)n--;
      else {
        if(n==2)n--;
        else n++;
      }
      count++;
    }
    return count ;
  }
  public static void main(String[] args){
    long n=4 ;
    long ans=count_minimum_operations(n);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation count_minimum_operations( n : long) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 1) do (     if (n mod 3 = 0) then     n := n/(3) else     if (n mod 3 = 1) then     n := n - 1 else (     if (n = 2) then     n := n - 1 ; else     n := n + 1 ; ) ;  ;  
     count := count + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 4 ;
     var ans : long ; ans := count_minimum_operations(n) ;
     OclFile["System.out"].println(ans) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sqrtSearch(int low,int high,int N){
    if(low<=high){
      int mid=(int)(low+high)/2 ;
      if((mid*mid<=N)&&((mid+1)*(mid+1)>N)){
        return mid ;
      }
      else if(mid*mid<N){
        return sqrtSearch(mid+1,high,N);
      }
      else {
        return sqrtSearch(low,mid-1,N);
      }
    }
    return low ;
  }
  public static void main(String[] args){
    int N=25 ;
    System.out.println(sqrtSearch(0,N,N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sqrtSearch( low : int, high : int, N : int) : int
  pre: true
  post: true
  activity: (     if (low <= high) then (     var mid : int ; mid := (low + high)->oclAsType(int) / 2 ;
     if ((mid * mid <= N) & ((mid + 1) * (mid + 1) > N)) then (     return mid ) else     if (mid * mid < N) then (     return sqrtSearch(mid + 1, high, N) ) else (     return sqrtSearch(low, mid - 1, N) ) ;  ) else skip ; 
     return low );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 25 ;
     OclFile["System.out"].println(sqrtSearch(0, N, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Solution {
  public int maximumProduct(int[] nums){
    int min1=Integer.MAX_VALUE,min2=Integer.MAX_VALUE ;
    int max1=Integer.MIN_VALUE,max2=Integer.MIN_VALUE,max3=Integer.MIN_VALUE ;
    for(int n : nums){
      if(n<=min1){
        min2=min1 ;
        min1=n ;
      }
      else if(n<=min2){
        min2=n ;
      }
      if(n>=max1){
        max3=max2 ;
        max2=max1 ;
        max1=n ;
      }
      else if(n>=max2){
        max3=max2 ;
        max2=n ;
      }
      else if(n>=max3){
        max3=n ;
      }
    }
    return Math.max(min1*min2*max1,max1*max2*max3);
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation maximumProduct( nums : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var min1 : int ; min1 := 2147483647 ;
    var min2 : int ; min2 := 2147483647 ;
     var max1 : int ; max1 := -2147483648 ;
    var max2 : int ; max2 := -2147483648 ;
    var max3 : int ; max3 := -2147483648 ;
     for (n : nums) do ( (     if (n <= min1) then (     min2 := min1 ; 
     min1 := n ) else     if (n <= min2) then (     min2 := n ) else skip ; ;  
     if (n >= max1) then (     max3 := max2 ; 
     max2 := max1 ; 
     max1 := n ) else     if (n >= max2) then (     max3 := max2 ; 
     max2 := n ) else     if (n >= max3) then (     max3 := n ) else skip ; ;  )  ) ; 
     return Set{min1 * min2 * max1, max1 * max2 * max3}->max() );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.Scanner ;
import java.util.Vector ;
public class main {
  public static void main(String[] args){
    Vector v=new Vector();
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int m=input.nextInt();
    int[][] arr=new int[n][m];
    for(int r=0 ; r<n ; r++)for(int c=0 ; c<m ; c++)arr[r][c]=input.nextInt();
    for(int r=0 ; r<n ; r++){
      int min=arr[r][0];
      for(int c=0 ; c<m ; c++){
        if(arr[r][c]<min)min=arr[r][c];
      }
      v.add(min);
    }
    Collections.sort(v);
    int s=v.size();
    System.out.println(v.get(s-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var v : Sequence ; v := Sequence{} ;
     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := input.getCurrent()->toInteger() ;
    var m : int ; m := input.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var r : int ; r := 0 ; while r < n do (         var c : int ; c := 0 ; while c < m do (     arr[r+1][c+1] := input.getCurrent()->toInteger() ;  ;     c := c + 1 ) ;  ;     r := r + 1 ) ; 
        var r : int ; r := 0 ; while r < n do ( (     var min : int ; min := arr[r+1][0+1] ;
         var c : int ; c := 0 ; while c < m do ( (     if (arr[r+1][c+1] < min) then     min := arr[r+1][c+1] ; else skip )  ;     c := c + 1 ) ; 
     v := v->including(min) )  ;     r := r + 1 ) ; 
    v := v->sort() ; 
    var s : int ; s := v->size() ;
    OclFile["System.out"].println(v->at(s - 1+1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int m=sc.nextInt();
      int arr[][]=new int[n][m];
      ArrayList<Integer>al=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<m ; j++){
          arr[i][j]=sc.nextInt();
        }
      }
      int ans=Integer.MIN_VALUE ;
      for(int i=0 ; i<n ; i++){
        int cur=Integer.MAX_VALUE ;
        for(int j=0 ; j<m ; j++){
          cur=Math.min(cur,arr[i][j]);
        }
        ans=Math.max(ans,cur);
      }
      System.out.println(ans);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var al : Sequence(int) ; al := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     arr[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     var cur : int ; cur := 2147483647 ;
         var j : int ; j := 0 ; while j < m do ( (     cur := Set{cur, arr[i+1][j+1]}->min() )  ;     j := j + 1 ) ; 
     ans := Set{ans, cur}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    int[][] a=new int[n][m];
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<m ; j++)a[i][j]=sc.nextInt();
    if(n==1){
      Arrays.sort(a[0]);
      out.println(a[0][0]);
    }
    else if(m==1){
      int mx=-1 ;
      for(int i=0 ; i<n ; i++)mx=Math.max(mx,a[i][0]);
      out.println(mx);
    }
    else {
      int[] mn=new int[n];
      for(int i=0 ; i<n ; i++)mn[i]=2000000000 ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<m ; j++){
          mn[i]=Math.min(mn[i],a[i][j]);
        }
      }
      Arrays.sort(mn);
      out.println(mn[--n]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < m do (     a[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    if (n = 1) then (     a[0+1] := a[0+1]->sort() ; 
     out.println(a[0+1][0+1]) ) else     if (m = 1) then (     var mx : int ; mx := -1 ;
         var i : int ; i := 0 ; while i < n do (     mx := Set{mx, a[i+1][0+1]}->max() ;  ;     i := i + 1 ) ; 
     out.println(mx) ) else (     var mn : Sequence(int) ; mn := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     mn[i+1] := 2000000000 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     mn[i+1] := Set{mn[i+1], a[i+1][j+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    mn := mn->sort() ; 
    n := n - 1 ;
    out.println(mn[(n - 1)+1]) ; 
 ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Iterator ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Forming_Teams {
  int count ;
  boolean[] seen ;
  int path=0,cycle=1 ;
  LinkedList<LinkedList<Integer>>graph ;
  public int dfs(int child,int par){
    if(seen[child]==true)return cycle ;
    seen[child]=true ;
    for(Integer i : graph.get(child)){
      if(i!=par){
        this.count++;
        if(dfs(i,child)==cycle)return cycle ;
      }
    }
    return path ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int m=sc.nextInt();
    int n=sc.nextInt();
    Forming_Teams ft=new Forming_Teams();
    ft.graph=new LinkedList<>();
    for(int i=0 ; i<=m ; i++){
      ft.graph.add(new LinkedList<Integer>());
    }
    ft.seen=new boolean[m+1];
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      ft.graph.get(x).add(y);
      ft.graph.get(y).add(x);
    }
    int toremove=0 ;
    for(int i=1 ; i<=m ; i++){
      if(! ft.seen[i]){
        ft.count=0 ;
        if(ft.dfs(i,0)==ft.cycle){
          if(ft.count % 2==1)toremove++;
        }
      }
    }
    if((m-toremove)% 2==1)toremove++;
    System.out.println(toremove);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Forming_Teams {
   attribute count : int;
   attribute seen : Sequence(boolean);
   attribute path : int := 0;
   attribute graph : Sequence(Sequence(int));
   operation dfs( child : int, par : int) : int
  pre: true
  post: true
  activity: (     if (seen[child+1] = true) then     return cycle else skip ; 
     seen[child+1] := true ; 
     for (i : graph->at(child+1)) do ( (     if (i /= par) then (     self.count := self.count + 1 ; 
     if (dfs(i, child) = cycle) then     return cycle else skip ) else skip )  ) ; 
     return path );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var ft : Forming_Teams ; ft := Forming_Teams.newForming_Teams() ;
    ft.graph := Sequence{} ; 
        var i : int ; i := 0 ; while i <= m do ( (     ft.graph->excludes(Sequence{}) )  ;     i := i + 1 ) ; 
    ft.seen := Integer.subrange(1,m + 1)->collect(false) ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     ft.graph->at(x+1)->excludes(y) ; 
     ft.graph->at(y+1)->excludes(x) )  ;     i := i + 1 ) ; 
    var toremove : int ; toremove := 0 ;
        var i : int ; i := 1 ; while i <= m do ( (     if (not(ft.seen[i+1])) then (     ft.count := 0 ; 
     if (ft.dfs(i, 0) = ft.cycle) then (     if (ft.count mod 2 = 1) then     toremove := toremove + 1 ; else skip ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if ((m - toremove) mod 2 = 1) then     toremove := toremove + 1 ; else skip ; 
    OclFile["System.out"].println(toremove) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static int guess=1 ;
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),m=in.nextInt();
    int a[][]=new int[n][m];
    int max=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      int min=Integer.MAX_VALUE ;
      for(int j=0 ; j<m ; j++){
        a[i][j]=in.nextInt();
        min=Math.min(min,a[i][j]);
      }
      max=Math.max(max,min);
    }
    pw.println(max);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute guess : int := 1;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var max : int ; max := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     var min : int ; min := 2147483647 ;
         var j : int ; j := 0 ; while j < m do ( (     a[i+1][j+1] := in.getCurrent()->toInteger() ; 
     min := Set{min, a[i+1][j+1]}->min() )  ;     j := j + 1 ) ; 
     max := Set{max, min}->max() )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    String[] a={
      "a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z" };
      Scanner sc=new Scanner(System.in);
      String ns=sc.nextLine();
      sc.close();
      BigInteger norg=new BigInteger(ns);
      BigInteger n=norg ;
      int[] ans=new int[12];
      int i=1 ;
      BigInteger max=new BigInteger("26");
      for(i=1 ; i<12 ; i++){
        if(n.compareTo(max)<=0)break ;
        n=n.subtract(max);
        max=max.multiply(new BigInteger("26"));
      }
      n=n.subtract(BigInteger.ONE);
      for(int j=1 ; j<=i ; j++){
        ans[j]=n.mod(new BigInteger("26")).intValue();
        n=n.divide(new BigInteger("26"));
      }
      for(int j=i ; j>0 ; j--){
        System.out.print(a[ans[j] ]);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := Sequence{"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"} ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var ns : String ; ns := sc.nextLine() ;
    skip ; 
    var norg : long ; norg := long(ns) ;
    var n : long ; n := norg ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,12)->collect(0) ;
    var i : int ; i := 1 ;
    var max : long ; max := long("26") ;
        i := 1 ; while i < 12 do ( (     if (n->compareTo(max) <= 0) then     break else skip ; 
     n := n.subtract(max) ; 
     max := max.multiply(long("26")) )  ;     i := i + 1 ) ; 
    n := n.subtract(1) ; 
        var j : int ; j := 1 ; while j <= i do ( (     ans[j+1] := n.mod(long("26"))->oclAsType(int) ; 
     n := n.divide(long("26")) )  ;     j := j + 1 ) ; 
        var j : int ; j := i ; while j > 0 do ( (     OclFile["System.out"].print(a[ans[j+1]+1]) )  ;     j := j - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long[] pow26=new long[14];
    for(int i=1 ; i<14 ; i++){
      pow26[i]=pow26[i-1]+(long)Math.pow(26,i);
    }
    int length=0 ;
    for(int i=0 ; i<14 ; i++){
      if(n>pow26[i] && n<=pow26[i+1]){
        length=i+1 ;
        break ;
      }
    }
    int x=(int)(n % 26);
    x=x==0 ? 26 : x ;
    String s=String.valueOf((char)(x+96));
    n-=26 ;
    for(int i=1 ; i<length ; i++){
      long z=n %(long)Math.pow(26,i+1);
      z=z==0 ?(long)Math.pow(26,i+1): z ;
      int y=(int)((z-1)/(long)Math.pow(26,i))+1 ;
      s=String.valueOf((char)(y+96))+s ;
      n-=(long)Math.pow(26,i+1);
    }
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var pow26 : Sequence(long) ; pow26 := Integer.subrange(1,14)->collect(0) ;
        var i : int ; i := 1 ; while i < 14 do ( (     pow26[i+1] := pow26[i - 1+1] + 26->pow(i)->oclAsType(long) )  ;     i := i + 1 ) ; 
    var length : int ; length := 0 ;
        var i : int ; i := 0 ; while i < 14 do ( (     if (n > pow26[i+1] & n <= pow26[i + 1+1]) then (     length := i + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var x : int ; x := (n mod 26)->oclAsType(int) ;
    x := if x = 0 then 26 else x endif ; 
    var s : String ; s := (((x + 96)->oclAsType(String)) + "") ;
    n := n-(26) ; 
        var i : int ; i := 1 ; while i < length do ( (     var z : long ; z := n mod 26->pow(i + 1)->oclAsType(long) ;
     z := if z = 0 then 26->pow(i + 1)->oclAsType(long) else z endif ; 
    var y : int ; y := ((z - 1) / 26->pow(i)->oclAsType(long))->oclAsType(int) + 1 ;
    s := (((y + 96)->oclAsType(String)) + "") + s ; 
    n := n-(26->pow(i + 1)->oclAsType(long)) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    long dog=Long.parseLong(br.readLine());
    String res="" ;
    while(dog-->0){
      res=(char)('a'+(dog % 26))+res ;
      dog/=26 ;
    }
    bw.write(res+"\n");
    bw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var dog : long ; dog := (br.readLine())->toLong() ;
    var res : String ; res := "" ;
        while (dog > 0) do (        dog := dog - 1 ;     skip ; (     res := ('a' + (dog mod 26))->oclAsType(String) + res ; 
     dog := dog/(26) ) ;  ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    String s=num2alphabet(N);
    System.out.println(s);
  }
  public static String num2alphabet(long num){
    long firstIndexAlpha=(int)'a' ;
    long sizeAlpha=26 ;
    if(num<=0){
      return "" ;
    }
    else if(num<=sizeAlpha){
      return String.valueOf((char)(firstIndexAlpha+num-1));
    }
    else {
      long offset=num-1 ;
      long tmp=offset ;
      String str="" ;
      while(true){
        long div=tmp/sizeAlpha ;
        long mod=tmp % sizeAlpha ;
        str=num2alphabet(mod+1)+str ;
        if(div<=0){
          break ;
        }
        tmp=(div-1);
      };
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
     var s : String ; s := num2alphabet(N) ;
     OclFile["System.out"].println(s) );
  static   operation num2alphabet( num : long) : String
  pre: true
  post: true
  activity: (     var firstIndexAlpha : long ; firstIndexAlpha := ('a')->char2byte() ;
     var sizeAlpha : long ; sizeAlpha := 26 ;
     if (num <= 0) then (     return "" ) else     if (num <= sizeAlpha) then (     return (((firstIndexAlpha + num - 1)->oclAsType(String)) + "") ) else (     var offset : long ; offset := num - 1 ;
     var tmp : long ; tmp := offset ;
    var str : String ; str := "" ;
    while (true) do (     var div : long ; div := tmp / sizeAlpha ;
     var mod : long ; mod := tmp mod sizeAlpha ;
    str := num2alphabet(mod + 1) + str ; 
    if (div <= 0) then (     break ) else skip ; 
    tmp := ((div)->char2byte() - 1) ; 
 ) ; 
    return str 
 ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String integer_to_string(int n,int base){
    String str="" ;
    while(n>0){
      int digit=n % base ;
      n/=base ;
      str+=(char)(digit+'0');
    }
    return str ;
  }
  static int isPalindrome(int i,int k){
    int temp=i ;
    int m=0 ;
    while(temp>0){
      m=temp % 10+m*10 ;
      temp/=10 ;
    }
    if(m==i){
      String str=integer_to_string(m,k);
      StringBuilder sb=new StringBuilder(str);
      String str1=sb.reverse().toString();
      if(str.equals(str1)){
        return i ;
      }
    }
    return 0 ;
  }
  static void sumPalindrome(int n,int k){
    int sum=0 ;
    for(int i=1 ; i<n ; i++){
      sum+=isPalindrome(i,k);
    }
    System.out.println("Total sum is "+sum);
  }
  public static void main(String[] args){
    int n=100 ;
    int k=2 ;
    sumPalindrome(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation integer_to_string( n : int, base : int) : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     while (n > 0) do (     var digit : int ; digit := n mod base ;
     n := n/(base) ; 
     str := str+((digit + '0')->oclAsType(String)) ) ; 
     return str );
  static   operation isPalindrome( i : int, k : int) : int
  pre: true
  post: true
  activity: (     var temp : int ; temp := i ;
     var m : int ; m := 0 ;
    while (temp > 0) do (     m := temp mod 10 + m * 10 ; 
     temp := temp/(10) ) ; 
    if (m = i) then (     var str : String ; str := integer_to_string(m, k) ;
     var sb : String ; sb := StringLib.newString(str) ;
     var str1 : String ; str1 := sb->reverse()+"" ;
     if (str = str1) then (     return i ) else skip ) else skip ; 
    return 0 
 );
  static   operation sumPalindrome( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     sum := sum+(isPalindrome(i, k)) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Total sum is " + sum) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 100 ;
     var k : int ; k := 2 ;
     execute sumPalindrome(n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=br.readLine();
    int num=Integer.parseInt(str);
    System.out.println((int)Math.pow(num,3));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := br.readLine() ;
     var num : int ; num := (str)->toInteger() ;
     OclFile["System.out"].println(num->pow(3)->oclAsType(int)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args)throws IOException {
    int x,ans ;
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    x=Integer.parseInt(br.readLine());
    ans=x*x*x ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ;
    var ans : int ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    x := (br.readLine())->toInteger() ; 
    ans := x * x * x ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static long[] distances ;
  static ArrayList<Road>[] lists ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    distances=new long[n];
    lists=new ArrayList[n];
    for(int i=0 ; i<n ; i++){
      distances[i]=Long.MAX_VALUE ;
      lists[i]=new ArrayList<Road>();
    }
    for(int i=0 ; i<n-1 ; i++){
      int u=sc.nextInt();
      int v=sc.nextInt();
      int w=sc.nextInt();
      lists[u-1] .add(new Road(v-1,w));
      lists[v-1] .add(new Road(u-1,w));
    }
    int idx=0 ;
    while(idx!=-1){
      search(idx,0);
      idx=getNext();
    }
    StringBuilder sb=new StringBuilder();
    for(long x : distances){
      if(x % 2==0){
        sb.append(0);
      }
      else {
        sb.append(1);
      }
      sb.append("\n");
    }
    System.out.println(sb);
  }
  static int getNext(){
    for(int i=0 ; i<distances.length ; i++){
      if(distances[i]==Long.MAX_VALUE){
        return i ;
      }
    }
    return-1 ;
  }
  static void search(int idx,long distance){
    if(distances[idx]<=distance){
      return ;
    }
    distances[idx]=distance ;
    for(Road r : lists[idx]){
      search(r.dest,distance+r.weight);
    }
  }
  static class Road {
    int dest ;
    int weight ;
    public Road(int dest,int weight){
      this.dest=dest ;
      this.weight=weight ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute distances : Sequence(long);
  static   attribute lists : Sequence(Sequence(Road));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    distances := Integer.subrange(1,n)->collect(0) ; 
    lists := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do ( (     distances[i+1] := "9223372036854775807"->toLong() ; 
     lists[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var u : int ; u := sc.getCurrent()->toInteger() ;
     var v : int ; v := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    lists[u - 1+1]->excludes(Road.newRoad(v - 1, w)) ; 
    lists[v - 1+1]->excludes(Road.newRoad(u - 1, w)) ; 
 )  ;     i := i + 1 ) ; 
    var idx : int ; idx := 0 ;
    while (idx /= -1) do (     execute search(idx, 0) ; 
     idx := getNext() ) ; 
    var sb : String ; sb := StringLib.newString() ;
    for (x : distances) do ( (     if (x mod 2 = 0) then (     sb := sb + StringLib.newString(0) ) else (     sb := sb + StringLib.newString(1) ) ;  
     sb := sb + StringLib.newString("\n") )  ) ; 
    OclFile["System.out"].println(sb) ; 
 );
  static   operation getNext() : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < distances->size() do ( (     if (distances[i+1] = "9223372036854775807"->toLong()) then (     return i ) else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation search( idx : int, distance : long) : void
  pre: true
  post: true
  activity: (     if (distances[idx+1] <= distance) then (     return ) else skip ; 
     distances[idx+1] := distance ; 
     for (r : lists[idx+1]) do ( (     execute search(r.dest, distance + r.weight) )  ) );
  static class Road {
   attribute dest : int;
   attribute weight : int;
   static operation newRoad( dest : int, weight : int) : Road
  pre: true
  post: true
  activity:
  ( var self : Road ;
    self := createRoad();
    self.initialise(dest, weight);
    return self );
  operation initialise( dest : int, weight : int) : void
  pre: true  post: true
  activity: (     self.dest := dest ; 
     self.weight := weight );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static boolean[] visited ;
  public static ArrayList<ArrayList<Integer>>graph ;
  public static int counter=0 ;
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    String[] inputs=s.nextLine().split(" ");
    int nodes=Integer.valueOf(inputs[0]);
    int vertices=Integer.valueOf(inputs[1]);
    graph=new ArrayList<>(nodes);
    visited=new boolean[nodes];
    for(int i=0 ; i<nodes ; i++){
      graph.add(new ArrayList<>());
    }
    for(int i=0 ; i<vertices ; i++){
      String[] vertex=s.nextLine().split(" ");
      int n1=Integer.valueOf(vertex[0]);
      int n2=Integer.valueOf(vertex[1]);
      graph.get(n1-1).add(n2-1);
      graph.get(n2-1).add(n1-1);
    }
    int totalCount=0 ;
    for(int i=0 ; i<nodes ; i++){
      if(! visited[i]){
        totalCount+=(solver(i,-1)&& counter % 2==1)? counter-1 : counter ;
        counter=0 ;
      }
    }
    while(totalCount % 2!=0){
      totalCount--;
    }
    System.out.println(nodes-totalCount);
  }
  public static boolean solver(int node,int parent){
    visited[node]=true ;
    counter++;
    for(int neighbour : graph.get(node)){
      if(! visited[neighbour]){
        if(solver(neighbour,node)){
          return true ;
        }
      }
      else if(parent!=neighbour){
        return true ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute visited : Sequence(boolean);
  static   attribute graph : Sequence(Sequence(int));
  static   attribute counter : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inputs : Sequence(String) ; inputs := s.nextLine()->split(" ") ;
    var nodes : int ; nodes := (inputs[0+1])->toInteger() ;
    var vertices : int ; vertices := (inputs[1+1])->toInteger() ;
    graph := Sequence{} ; 
    visited := Integer.subrange(1,nodes)->collect(false) ; 
        var i : int ; i := 0 ; while i < nodes do ( (     graph := graph->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < vertices do ( (     var vertex : Sequence(String) ; vertex := s.nextLine()->split(" ") ;
     var n1 : int ; n1 := (vertex[0+1])->toInteger() ;
    var n2 : int ; n2 := (vertex[1+1])->toInteger() ;
    graph->at(n1 - 1+1)->excludes(n2 - 1) ; 
    graph->at(n2 - 1+1)->excludes(n1 - 1) ; 
 )  ;     i := i + 1 ) ; 
    var totalCount : int ; totalCount := 0 ;
        var i : int ; i := 0 ; while i < nodes do ( (     if (not(visited[i+1])) then (     totalCount := totalCount+(if (solver(i, -1) & counter mod 2 = 1) then counter - 1 else counter endif) ; 
     counter := 0 ) else skip )  ;     i := i + 1 ) ; 
    while (totalCount mod 2 /= 0) do (     totalCount := totalCount - 1 ) ; 
    OclFile["System.out"].println(nodes - totalCount) ; 
 );
  static   operation solver( node : int, parent : int) : boolean
  pre: true
  post: true
  activity: (     visited[node+1] := true ; 
     counter := counter + 1 ; 
     for (neighbour : graph->at(node+1)) do ( (     if (not(visited[neighbour+1])) then (     if (solver(neighbour, node)) then (     return true ) else skip ) else     if (parent /= neighbour) then (     return true ) else skip ; )  ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public void solve(){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    System.out.println(x*x*x);
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(x * x * x) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args){
    try(BufferedReader stdReader=new BufferedReader(new InputStreamReader(System.in))){
      String line=null ;
      while((line=stdReader.readLine())!=null){
        if(! line.equals("")){
          int i=Integer.parseInt(line);
          System.out.print(i*i*i);
        }
        break ;
      }
      stdReader.close();
      System.out.println();
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var stdReader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var line : String ; line := null ;
         line := stdReader.readLine() ;
    while ((line) /= null) do (    skip ; (     if (not(line = "")) then (     var i : int ; i := (line)->toInteger() ;
     OclFile["System.out"].print(i * i * i) ) else skip ; 
     break ) ;     line := stdReader.readLine() ;
 ) ;  
     skip ; 
     OclFile["System.out"].println() ))   catch (e : ProgramException) do skip
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      int num=Integer.parseInt(br.readLine());
      System.out.println((int)Math.pow(num,3));
    }
    catch(IOException e){
      System.err.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var num : int ; num := (br.readLine())->toInteger() ;
     OclFile["System.out"].println(num->pow(3)->oclAsType(int)) )   catch (e : IOException) do (     OclFile["System.err"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    sc.close();
    int d=a+c-b ;
    int a_13=0 ;
    if(d % 2!=0 || d<0){
      System.out.println("Impossible");
      System.exit(0);
    }
    else a_13=d/2 ;
    int a_12=a-a_13 ;
    if(a_12<0){
      System.out.println("Impossible");
      System.exit(0);
    }
    int a_23=c-a_13 ;
    if(a_23<0){
      System.out.println("Impossible");
      System.exit(0);
    }
    System.out.printf("%d %d %d",a_12,a_23,a_13);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    skip ; 
    var d : int ; d := a + c - b ;
    var a    var aint3 : int ; aint3 := 03 : int ; a    var aint3 : int ; aint3 := 03 := 0 ;
    if (d mod 2 /= 0 or d < 0) then (     OclFile["System.out"].println("Impossible") ; 
 OclProcess.exit(0) ) else     aa_133 := d / 2 ; ;  
    var a    var aint2 : int ; aint2 := a - aa32 : int ; a    var aint2 : int ; aint2 := a - aa32 := a - aa3 ;
    if (a_12 < 0) then (     OclFile["System.out"].println("Impossible") ; 
 OclProcess.exit(0) ) else skip ; 
    var ac - ac33 : int ; ac - ac33 := c - ac3 ;
    if (a03 < 0) then (     OclFile["System.out"].println("Impossible") ; 
 OclProcess.exit(0) ) else skip ; 
    OclFile["System.out"].printf("%d %d %d", a"%d %d %d"2, a_23, aa_233) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    long x=in.nextInt(),y=in.nextInt(),z=in.nextInt();
    if((x+y+z)% 2!=0 || x+y<z || y+z<x || z+x<y)System.out.println("Impossible");
    else System.out.println((x+y-z)/2+" "+(y+z-x)/2+" "+(z+x-y)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := in.getCurrent()->toInteger() ;
    var y : long ; y := in.getCurrent()->toInteger() ;
    var z : long ; z := in.getCurrent()->toInteger() ;
     if ((x + y + z) mod 2 /= 0 or x + y < z or y + z < x or z + x < y) then     OclFile["System.out"].println("Impossible") ; else     OclFile["System.out"].println((x + y - z) / 2 + " " + (y + z - x) / 2 + " " + (z + x - y) / 2) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] arg){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    for(int i=0 ; i<=a ; i++){
      if((b-i)==(c-a+i)&& a<=(b+c)){
        System.out.println(i+" "+(b-i)+" "+(a-i));
        return ;
      }
    }
    System.out.println("Impossible");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i <= a do ( (     if ((b - i) = (c - a + i) & a <= (b + c)) then (     OclFile["System.out"].println(i + " " + (b - i) + " " + (a - i)) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Impossible") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class BearAndFiveCards {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int sum=0 ;
    Map<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<5 ; i++){
      int val=scanner.nextInt();
      sum+=val ;
      map.put(val,map.getOrDefault(val,0)+1);
    }
    int sol=sum ;
    for(Integer key : map.keySet()){
      if(map.get(key)>=3){
        sol=Math.min(sol,sum-(key*3));
      }
      if(map.get(key)==2){
        sol=Math.min(sol,sum-key*2);
      }
    }
    System.out.println(sol);
  }
}
------------------------------------------------------------
OCL File:
---------
 class BearAndFiveCards {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sum : int ; sum := 0 ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < 5 do ( (     var val : int ; val := scanner.getCurrent()->toInteger() ;
     sum := sum+(val) ; 
     map := map->union(Map{val |-> (if map->keys()->contains(val) then map->at(val) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var sol : int ; sol := sum ;
    for (key : map->keys()) do ( (     if (map->at(key) >= 3) then (     sol := Set{sol, sum - (key * 3)}->min() ) else skip ; 
     if (map->at(key) = 2) then (     sol := Set{sol, sum - key * 2}->min() ) else skip )  ) ; 
    OclFile["System.out"].println(sol) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class BearAndFiveDiscards {
  public static void main(String[] args)throws IOException {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(is);
    String[] vals=br.readLine().split(" ");
    int occ[]=new int[101];
    int total=0 ;
    for(int i=0 ; i<5 ; i++){
      int x=Integer.parseInt(vals[i]);
      occ[x]++;
      total+=x ;
    }
    int max_double_sum=0 ;
    int max_triple_sum=0 ;
    for(int i=0 ; i<101 ; i++){
      if(occ[i]>=2){
        max_double_sum=Math.max(max_double_sum,2*i);
      }
      if(occ[i]>=3){
        max_triple_sum=Math.max(max_triple_sum,3*i);
      }
    }
    System.out.println(total-Math.max(max_triple_sum,max_double_sum));
  }
}
------------------------------------------------------------
OCL File:
---------
 class BearAndFiveDiscards {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(is) ;
    var vals : Sequence(String) ; vals := br.readLine()->split(" ") ;
    var occ : Sequence(int) ; occ := Integer.subrange(1,101)->collect(0) ;
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < 5 do ( (     var x : int ; x := (vals[i+1])->toInteger() ;
     occ[x+1] := occ[x+1] + 1 ; 
     total := total+(x) )  ;     i := i + 1 ) ; 
    var max_double_sum : int ; max_double_sum := 0 ;
    var max_triple_sum : int ; max_triple_sum := 0 ;
        var i : int ; i := 0 ; while i < 101 do ( (     if (occ[i+1] >= 2) then (     max_double_sum := Set{max_double_sum, 2 * i}->max() ) else skip ; 
     if (occ[i+1] >= 3) then (     max_triple_sum := Set{max_triple_sum, 3 * i}->max() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total - Set{max_triple_sum, max_double_sum}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import java.io.*;
public class Hello {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int a[]=new int[5];
    int sum=0 ;
    for(int i=0 ; i<5 ; i++){
      a[i]=in.nextInt();
      sum+=a[i];
    }
    Arrays.sort(a);
    int s1=0 ;
    if(a[0]==a[1] && a[2]==a[1]){
      s1=a[0]+a[1]+a[2];
    }
    int s2=0 ;
    if(a[2]==a[3] && a[4]==a[3]){
      s2=a[4]+a[3]+a[2];
    }
    int s3=0 ;
    if(a[0]==a[1]){
      s3=a[0]+a[1];
    }
    int s4=0 ;
    if(a[2]==a[1]){
      s4=a[2]+a[1];
    }
    int s5=0 ;
    if(a[2]==a[3]){
      s5=a[2]+a[3];
    }
    int s6=0 ;
    if(a[4]==a[3]){
      s6=a[4]+a[3];
    }
    int s7=0 ;
    if(a[3]==a[1] && a[2]==a[1]){
      s7=a[3]+a[1]+a[2];
    }
    pw.println(sum-Math.max(s1,Math.max(s2,Math.max(s3,Math.max(s4,Math.max(s5,Math.max(s6,s7)))))));
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hello {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : Sequence(int) ; a := Integer.subrange(1,5)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 5 do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var s1 : int ; s1 := 0 ;
    if (a[0+1] = a[1+1] & a[2+1] = a[1+1]) then (     s1 := a[0+1] + a[1+1] + a[2+1] ) else skip ; 
    var s2 : int ; s2 := 0 ;
    if (a[2+1] = a[3+1] & a[4+1] = a[3+1]) then (     s2 := a[4+1] + a[3+1] + a[2+1] ) else skip ; 
    var s3 : int ; s3 := 0 ;
    if (a[0+1] = a[1+1]) then (     s3 := a[0+1] + a[1+1] ) else skip ; 
    var s4 : int ; s4 := 0 ;
    if (a[2+1] = a[1+1]) then (     s4 := a[2+1] + a[1+1] ) else skip ; 
    var s5 : int ; s5 := 0 ;
    if (a[2+1] = a[3+1]) then (     s5 := a[2+1] + a[3+1] ) else skip ; 
    var s6 : int ; s6 := 0 ;
    if (a[4+1] = a[3+1]) then (     s6 := a[4+1] + a[3+1] ) else skip ; 
    var s7 : int ; s7 := 0 ;
    if (a[3+1] = a[1+1] & a[2+1] = a[1+1]) then (     s7 := a[3+1] + a[1+1] + a[2+1] ) else skip ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    int[] A=new int[N+1];
    int[] rec=new int[N+1];
    HashSet<Integer>dic=new HashSet<>();
    for(int i=1 ; i<=N ; i++){
      A[i]=sc.nextInt();
      dic.add(A[i]);
      rec[A[i] ]++;
    }
    int ans=0 ;
    if(dic.size()<=K){
      System.out.println(ans);
      System.exit(0);
    }
    Arrays.sort(rec);
    int i=0 ;
    while(rec[i]==0)i++;
    for(int j=i ; j<i+(dic.size()-K); j++){
      ans+=rec[j];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N + 1)->collect(0) ;
    var rec : Sequence(int) ; rec := Integer.subrange(1,N + 1)->collect(0) ;
    var dic : Set(int) ; dic := Set{} ;
        var i : int ; i := 1 ; while i <= N do ( (     A[i+1] := sc.getCurrent()->toInteger() ; 
     dic := dic->including(A[i+1]) ; 
     rec[A[i+1]+1] := rec[A[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    if (dic->size() <= K) then (     OclFile["System.out"].println(ans) ; 
 OclProcess.exit(0) ) else skip ; 
    rec := rec->sort() ; 
    var i : int ; i := 0 ;
    while (rec[i+1] = 0) do     i := i + 1 ; ; 
        var j : int ; j := i ; while j < i + (dic->size() - K) do ( (     ans := ans+(rec[j+1]) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n ;
    int total ;
    double hyouzyun ;
    double m ;
    double a ;
    double[] student ;
    for(; ; ){
      n=scan.nextInt();
      total=0 ;
      hyouzyun=0.0 ;
      a=0.0 ;
      if(n==0){
        break ;
      }
      student=new double[n];
      for(int i=0 ; i<n ; i++){
        student[i]=scan.nextDouble();
        total+=student[i];
      }
      m=(double)total/(double)n ;
      for(int i=0 ; i<n ; i++){
        a+=Math.pow((student[i]-m),2);
      }
      a/=n ;
      hyouzyun=Math.sqrt(a);
      System.out.println(String.format("%.8f",hyouzyun));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var total : int ;
    var hyouzyun : double ;
    var m : double ;
    var a : double ;
    var student : Sequence(double) ;
      while true do ( (     n := scan.getCurrent()->toInteger() ; 
     total := 0 ; 
    hyouzyun := 0.0 ; 
    a := 0.0 ; 
    if (n = 0) then (     break ) else skip ; 
    student := Integer.subrange(1,n)->collect(0.0) ; 
        var i : int ; i := 0 ; while i < n do ( (     student[i+1] := scan.getCurrent()->toReal() ; 
     total := total+(student[i+1]) )  ;     i := i + 1 ) ; 
    m := total->oclAsType(double) / n->oclAsType(double) ; 
        var i : int ; i := 0 ; while i < n do ( (     a := a+((student[i+1] - m)->pow(2)) )  ;     i := i + 1 ) ; 
    a := a/(n) ; 
    hyouzyun := (a)->sqrt() ; 
    OclFile["System.out"].println(StringLib.format("%.8f",Sequence{hyouzyun})) ; 
 )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Map ;
import java.util.Map.Entry ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    Map<Integer,Integer>n=new TreeMap<>();
    for(int i=0 ; i<N ; i++){
      Integer integer=sc.nextInt();
      if(n.containsKey(integer)){
        int count=n.get(integer)+1 ;
        n.put(integer,count);
      }
      else {
        n.put(integer,1);
      }
    }
    int ans=0 ;
    if(K<n.size()){
      List<Map.Entry<Integer,Integer>>mapValuesList=new ArrayList<Map.Entry<Integer,Integer>>(n.entrySet());
      Collections.sort(mapValuesList,new Comparator<Map.Entry<Integer,Integer>>(){
        @ Override public int compare(Entry<Integer,Integer>entry1,Entry<Integer,Integer>entry2){
          return((Integer)entry1.getValue()).compareTo((Integer)entry2.getValue());
        }
      }
);
      int diff=n.size()-K ;
      for(int i=0 ; i<diff ; i++){
        ans+=(int)mapValuesList.get(i).getValue();
      }
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var n : Map(int,int) ; n := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     var integer : int ; integer := sc.getCurrent()->toInteger() ;
     if (n->keys()->includes(integer)) then (     var count : int ; count := n->at(integer) + 1 ;
     n := n->union(Map{integer |-> count}) ) else (     n := n->union(Map{integer |-> 1}) ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    if (K < n.size()) then (     var mapValuesList : Sequence(Map(int,int)) ; mapValuesList := Sequence{}->union(n->asSet()) ;
     mapValuesList, OclComparator<Map(int,int)>.newOclComparator() := mapValuesList, OclComparator<Map(int,int)>.newOclComparator()->sort() ; 
     var diff : int ; diff := n.size() - K ;
         var i : int ; i := 0 ; while i < diff do ( (     ans := ans+(mapValuesList->at(i+1).getValue()->oclAsType(int)) )  ;     i := i + 1 ) ) else skip ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Map.Entry ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner reader=new Scanner(System.in);
    int N=reader.nextInt();
    int K=reader.nextInt();
    int ans=0 ;
    Map<Integer,Integer>map=new HashMap<Integer,Integer>();
    for(int i=0 ; i<N ; i++){
      int A=reader.nextInt();
      int value=1 ;
      if(map.containsKey(A)){
        value+=map.get(A);
      }
      map.put(A,value);
    }
    int arr[]=new int[map.size()];
    int count=0 ;
    for(Entry<Integer,Integer>entry : map.entrySet()){
      arr[count]=entry.getValue();
      count++;
    }
    Arrays.sort(arr);
    for(int i=0 ; i<map.size()-K ; i++){
      ans+=arr[i];
    }
    System.out.print(ans);
    reader.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := reader.getCurrent()->toInteger() ;
    var K : int ; K := reader.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     var A : int ; A := reader.getCurrent()->toInteger() ;
     var value : int ; value := 1 ;
     if (map->keys()->includes(A)) then (     value := value+(map->at(A)) ) else skip ; 
     map := map->union(Map{A |-> value}) )  ;     i := i + 1 ) ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,map.size())->collect(0) ;
    var count : int ; count := 0 ;
    for (entry : map->asSet()) do ( (     arr[count+1] := entry.getValue() ; 
     count := count + 1 )  ) ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < map.size() - K do ( (     ans := ans+(arr[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int k=Integer.parseInt(sc.next());
    Map<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int a=Integer.parseInt(sc.next());
      int v=map.getOrDefault(a,0);
      v++;
      map.put(a,v);
    }
    System.out.println(map.values().stream().mapToInt(Integer :: intValue).sorted().limit(Math.max(map.size()-k,0)).sum());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var k : int ; k := (sc.getCurrent())->toInteger() ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := (sc.getCurrent())->toInteger() ;
     var v : int ; v := (if map->keys()->contains(a) then map->at(a) else 0 endif) ;
     v := v + 1 ; 
     map := map->union(Map{a |-> v}) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(map->values()->collect( _x1 | (lambda _pars : OclAny in Integer.newInteger().intValue(_pars))->apply(_x1) )->sort().subrange(1,Set{map.size() - k, 0}->max())->sum()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    System.out.println();
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] a=new int[n];
    int c=0 ;
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt()-1 ;
      if(a[x]==0)c++;
      a[x]++;
    }
    Arrays.sort(a);
    int ans=0 ;
    for(int i=n-c ; i<n-k ; i++){
      ans+=a[i];
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println() ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
     if (a[x+1] = 0) then     c := c + 1 ; else skip ; 
     a[x+1] := a[x+1] + 1 )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := n - c ; while i < n - k do ( (     ans := ans+(a[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void solveWordWrap(int arr[],int n,int k){
    int i,j ;
    int currlen ;
    int cost ;
    int dp[]=new int[n];
    int ans[]=new int[n];
    dp[n-1]=0 ;
    ans[n-1]=n-1 ;
    for(i=n-2 ; i>=0 ; i--){
      currlen=-1 ;
      dp[i]=Integer.MAX_VALUE ;
      for(j=i ; j<n ; j++){
        currlen+=(arr[j]+1);
        if(currlen>k)break ;
        if(j==n-1)cost=0 ;
        else cost=(k-currlen)*(k-currlen)+dp[j+1];
        if(cost<dp[i]){
          dp[i]=cost ;
          ans[i]=j ;
        }
      }
    }
    i=0 ;
    while(i<n){
      System.out.print((i+1)+" "+(ans[i]+1)+" ");
      i=ans[i]+1 ;
    }
  }
  public static void main(String[] args){
    int arr[]={
      3,2,2,5 };
      int n=arr.length ;
      int M=6 ;
      solveWordWrap(arr,n,M);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solveWordWrap( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var currlen : int ;
    var cost : int ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
    dp[n - 1+1] := 0 ; 
    ans[n - 1+1] := n - 1 ; 
        i := n - 2 ; while i >= 0 do ( (     currlen := -1 ; 
     dp[i+1] := 2147483647 ; 
         j := i ; while j < n do ( (     currlen := currlen+((arr[j+1] + 1)) ; 
     if (currlen > k) then     break else skip ; 
     if (j = n - 1) then     cost := 0 else     cost := (k - currlen) * (k - currlen) + dp[j + 1+1] ; ;  
     if (cost < dp[i+1]) then (     dp[i+1] := cost ; 
     ans[i+1] := j ) else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    i := 0 ; 
    while (i < n) do (     OclFile["System.out"].print((i + 1) + " " + (ans[i+1] + 1) + " ") ; 
     i := ans[i+1] + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,2,2,5} ;
     var n : int ; n := arr->size() ;
     var M : int ; M := 6 ;
     execute solveWordWrap(arr, n, M) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round3 ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class D {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int cases=sc.nextInt();
    for(int caze=1 ; caze<=cases ; caze++){
      int P=sc.nextInt();
      long[] vals=new long[P],freqs=new long[P];
      Map<Long,Integer>pos=new HashMap<Long,Integer>();
      for(int i=0 ; i<vals.length ; i++){
        vals[i]=sc.nextLong();
        pos.put(vals[i],i);
      }
      long total=0 ;
      for(int i=0 ; i<vals.length ; i++){
        freqs[i]=sc.nextLong();
        total+=freqs[i];
      }
      int cant=0 ;
      long tmp=total ;
      while(tmp>1){
        tmp/=2 ;
        cant++;
      }
      long[] ans=new long[cant];
      int sumIdx=0,setIdx=0 ;
      for(setIdx=0 ; setIdx<cant ; setIdx++){
        for(int m=0 ; m<(1<<setIdx); m++){
          if(setIdx!=0 &&(m &(1<<(setIdx-1)))==0)continue ;
          long val=0 ;
          for(int i=0 ; i<setIdx ; i++)if((m &(1<<i))!=0)val+=ans[i];
          freqs[pos.get(val)]--;
        }
        while(freqs[sumIdx]==0){
          sumIdx++;
        }
        ans[setIdx]=vals[sumIdx];
      }
      System.out.print("Case #"+caze+":");
      for(int i=0 ; i<ans.length ; i++){
        System.out.print(" "+ans[i]);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cases : int ; cases := sc.getCurrent()->toInteger() ;
         var caze : int ; caze := 1 ; while caze <= cases do ( (     var P : int ; P := sc.getCurrent()->toInteger() ;
     var vals : Sequence(long) ; vals := Integer.subrange(1,P)->collect(0) ;
    var freqs : Sequence(long) ; freqs := Integer.subrange(1,P)->collect(0) ;
    var pos : Map(long,int) ; pos := Map{} ;
        var i : int ; i := 0 ; while i < vals->size() do ( (     vals[i+1] := sc.getCurrent()->toLong() ; 
     pos := pos->union(Map{vals[i+1] |-> i}) )  ;     i := i + 1 ) ; 
    var total : long ; total := 0 ;
        var i : int ; i := 0 ; while i < vals->size() do ( (     freqs[i+1] := sc.getCurrent()->toLong() ; 
     total := total+(freqs[i+1]) )  ;     i := i + 1 ) ; 
    var cant : int ; cant := 0 ;
    var tmp : long ; tmp := total ;
    while (tmp > 1) do (     tmp := tmp/(2) ; 
     cant := cant + 1 ) ; 
    var ans : Sequence(long) ; ans := Integer.subrange(1,cant)->collect(0) ;
    var sumIdx : int ; sumIdx := 0 ;
    var setIdx : int ; setIdx := 0 ;
        setIdx := 0 ; while setIdx < cant do ( (         var m : int ; m := 0 ; while m < ((1*(2->pow(setIdx)))->oclAsType(long)) do ( (     if (setIdx /= 0 & (MathLib.bitwiseAnd(m,((1*(2->pow((setIdx - 1))))->oclAsType(long)))) = 0) then     continue else skip ; 
     var val : long ; val := 0 ;
         var i : int ; i := 0 ; while i < setIdx do (     if ((MathLib.bitwiseAnd(m,((1*(2->pow(i)))->oclAsType(long)))) /= 0) then     val := val+(ans[i+1]) ; else skip ;  ;     i := i + 1 ) ; 
     freqs[pos->at(val)+1] := freqs[pos->at(val)+1] - 1 )  ;     m := m + 1 ) ; 
     while (freqs[sumIdx+1] = 0) do (     sumIdx := sumIdx + 1 ) ; 
     ans[setIdx+1] := vals[sumIdx+1] )  ;     setIdx := setIdx + 1 ) ; 
    OclFile["System.out"].print("Case #" + caze + ":") ; 
        var i : int ; i := 0 ; while i < ans->size() do ( (     OclFile["System.out"].print(" " + ans[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     caze := caze + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
public class D {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int numCases=sc.nextInt();
    for(int caseNum=1 ; caseNum<=numCases ; caseNum++){
      int P=sc.nextInt();
      int[] E=new int[P];
      int[] F=new int[P];
      for(int i=0 ; i<P ; i++){
        E[i]=sc.nextInt();
      }
      int total=0 ;
      for(int i=0 ; i<P ; i++){
        F[i]=sc.nextInt();
        total+=F[i];
      }
      int numElems=(int)(Math.log(total)/Math.log(2)+0.5);
      List<Integer>S=new ArrayList<>();
      Map<Integer,Integer>frequencies=new HashMap<>();
      frequencies.put(0,1);
      for(int i=0 ; i<P ; i++){
        if(! frequencies.containsKey(E[i])){
          frequencies.put(E[i],0);
        }
        while(frequencies.get(E[i])<F[i]){
          S.add(E[i]);
          Map<Integer,Integer>temp=new HashMap<>(frequencies);
          for(Map.Entry<Integer,Integer>entry : frequencies.entrySet()){
            int sum=entry.getKey()+E[i];
            if(temp.containsKey(sum)){
              temp.put(sum,entry.getValue()+frequencies.get(sum));
            }
            else {
              temp.put(sum,entry.getValue());
            }
          }
          frequencies=temp ;
        }
      }
      System.out.print("Case #"+caseNum+":");
      for(int i : S){
        System.out.print(" "+i);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numCases : int ; numCases := sc.getCurrent()->toInteger() ;
         var caseNum : int ; caseNum := 1 ; while caseNum <= numCases do ( (     var P : int ; P := sc.getCurrent()->toInteger() ;
     var E : Sequence(int) ; E := Integer.subrange(1,P)->collect(0) ;
    var F : Sequence(int) ; F := Integer.subrange(1,P)->collect(0) ;
        var i : int ; i := 0 ; while i < P do ( (     E[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < P do ( (     F[i+1] := sc.getCurrent()->toInteger() ; 
     total := total+(F[i+1]) )  ;     i := i + 1 ) ; 
    var numElems : int ; numElems := ((total)->log() / (2)->log() + 0.5)->oclAsType(int) ;
    var S : Sequence(int) ; S := Sequence{} ;
    var frequencies : Map(int,int) ; frequencies := Map{} ;
    frequencies := frequencies->union(Map{0 |-> 1}) ; 
        var i : int ; i := 0 ; while i < P do ( (     if (not(frequencies->keys()->includes(E[i+1]))) then (     frequencies := frequencies->union(Map{E[i+1] |-> 0}) ) else skip ; 
     while (frequencies->at(E[i+1]) < F[i+1]) do (     S := S->including(E[i+1]) ; 
     var temp : Map(int,int) ; temp := Map{}->union(frequencies) ;
     for (entry : frequencies->asSet()) do ( (     var sum : int ; sum := entry.getKey() + E[i+1] ;
     if (temp->keys()->includes(sum)) then (     temp := temp->union(Map{sum |-> entry.getValue() + frequencies->at(sum)}) ) else (     temp := temp->union(Map{sum |-> entry.getValue()}) ) )  ) ; 
     frequencies := temp ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("Case #" + caseNum + ":") ; 
    for (i : S) do ( (     OclFile["System.out"].print(" " + i) )  ) ; 
    OclFile["System.out"].println() ; 
 )  ;     caseNum := caseNum + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] t=new int[n+1];
    int[] x=new int[n+1];
    int[] y=new int[n+1];
    t[0]=0 ;
    x[0]=0 ;
    y[0]=0 ;
    for(int i=1 ; i<=n ; i++){
      t[i]=sc.nextInt();
      x[i]=sc.nextInt();
      y[i]=sc.nextInt();
    }
    boolean success=true ;
    for(int i=1 ; i<=n ; i++){
      int T=t[i]-t[i-1];
      int a=Math.abs(x[i]-x[i-1]);
      int b=Math.abs(y[i]-y[i-1]);
      int m=T-(a+b);
      if(m<0 || m % 2!=0){
        success=false ;
        break ;
      }
    }
    if(success){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,n + 1)->collect(0) ;
    var x : Sequence(int) ; x := Integer.subrange(1,n + 1)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n + 1)->collect(0) ;
    t[0+1] := 0 ; 
    x[0+1] := 0 ; 
    y[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (     t[i+1] := sc.getCurrent()->toInteger() ; 
     x[i+1] := sc.getCurrent()->toInteger() ; 
     y[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var success : boolean ; success := true ;
        var i : int ; i := 1 ; while i <= n do ( (     var T : int ; T := t[i+1] - t[i - 1+1] ;
     var a : int ; a := if x[i+1] - x[i - 1+1] < 0 then -(x[i+1] - x[i - 1+1]) else x[i+1] - x[i - 1+1] endif ;
    var b : int ; b := if y[i+1] - y[i - 1+1] < 0 then -(y[i+1] - y[i - 1+1]) else y[i+1] - y[i - 1+1] endif ;
    var m : int ; m := T - (a + b) ;
    if (m < 0 or m mod 2 /= 0) then (     success := false ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (success) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    InputReader in=new InputReader();
    PrintWriter out=new PrintWriter(System.out);
    int t=1 ;
    Solver s=new Solver();
    for(int i=1 ; i<=t ; i++){
      s.solve(i,in,out);
    }
    out.close();
  }
}
class Solver {
  void solve(int test,InputReader in,PrintWriter out)throws IOException {
    int n=in.nextInt();
    int x=0,y=0,t=0 ;
    for(int i=0 ; i<n ; i++){
      int t1=in.nextInt();
      int x1=in.nextInt();
      int y1=in.nextInt();
      int diff=t1-t ;
      int dist=Math.abs(x1-x)+Math.abs(y1-y);
      if(diff>=dist){
        if(dist % 2==0 && diff % 2==1){
          out.println("No");
          return ;
        }
        x=x1 ;
        y=y1 ;
        t=t1 ;
        continue ;
      }
      out.println("No");
      return ;
    }
    out.println("Yes");
  }
}
class InputReader {
  BufferedReader br ;
  StringTokenizer st ;
  public InputReader(){
    br=new BufferedReader(new InputStreamReader(System.in));
    st=null ;
  }
  public String next(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return st.nextToken();
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
  public String nextLine()throws IOException {
    return br.readLine();
  }
  public double nextDouble(){
    return Double.parseDouble(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : InputReader ; in := InputReader.newInputReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := 1 ;
    var s : Solver ; s := Solver.newSolver() ;
        var i : int ; i := 1 ; while i <= t do ( (     s.solve(i, in, out) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
class Solver {
   operation solve( test : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var t : int ; t := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var t1 : int ; t1 := in.nextInt() ;
     var x1 : int ; x1 := in.nextInt() ;
    var y1 : int ; y1 := in.nextInt() ;
    var diff : int ; diff := t1 - t ;
    var dist : int ; dist := if x1 - x < 0 then -(x1 - x) else x1 - x endif + if y1 - y < 0 then -(y1 - y) else y1 - y endif ;
    if (diff >= dist) then (     if (dist mod 2 = 0 & diff mod 2 = 1) then (     skip ; 
     return ) else skip ; 
     x := x1 ; 
    y := y1 ; 
    t := t1 ; 
    continue 
 ) else skip ; 
    skip ; 
    return 
 )  ;     i := i + 1 ) ; 
     skip );
}
class InputReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newInputReader() : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
class GFG {
  public static int kthSmallest(Integer[] arr,int k){
    Arrays.sort(arr);
    return arr[k-1];
  }
  public static void main(String[] args){
    Integer arr[]=new Integer[] {
      12,3,5,7,19 };
      int k=2 ;
      System.out.print("K'th smallest element is "+kthSmallest(arr,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation kthSmallest( arr : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     return arr[k - 1+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,3,5,7,19} ;
     var k : int ; k := 2 ;
     OclFile["System.out"].print("K'th smallest element is " + kthSmallest(arr, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Schedule {
  int t ;
  int x ;
  int y ;
  Schedule(int t,int x,int y){
    this.t=t ;
    this.x=x ;
    this.y=y ;
  }
  int getT(){
    return this.t ;
  }
  int getX(){
    return this.x ;
  }
  int getY(){
    return this.y ;
  }
  static int getDistance(Schedule s1,Schedule s2){
    int d=Math.abs(s1.getX()-s2.getX())+Math.abs(s1.getY()-s2.getY());
    return d ;
  }
  static int getTimeDifference(Schedule s1,Schedule s2){
    int d=Math.abs(s1.getT()-s2.getT());
    return d ;
  }
}
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<Schedule>s=new ArrayList<Schedule>();
    s.add(new Schedule(0,0,0));
    for(int i=0 ; i<n ; i++){
      int t=sc.nextInt();
      int x=sc.nextInt();
      int y=sc.nextInt();
      Schedule newS=new Schedule(t,x,y);
      s.add(newS);
    }
    String ans="Yes" ;
    for(int i=0 ; i<s.size()-1 ; i++){
      Schedule s1,s2 ;
      s1=s.get(i);
      s2=s.get(i+1);
      int dist=Schedule.getDistance(s1,s2);
      int timeDiff=Schedule.getTimeDifference(s1,s2);
      if(dist<=timeDiff &&(dist % 2==timeDiff % 2)){
        continue ;
      }
      ans="No" ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Schedule {
   attribute t : int;
   attribute x : int;
   attribute y : int;
   static operation newSchedule( t : int, x : int, y : int) : Schedule
  pre: true
  post: true
  activity:
  ( var self : Schedule ;
    self := createSchedule();
    self.initialise(t, x,y);
    return self );
  operation initialise( t : int, x : int, y : int) : void
  pre: true  post: true
  activity: (     self.t := t ; 
     self.x := x ; 
     self.y := y );
   operation getT() : int
  pre: true
  post: true
  activity: (     return self.t );
   operation getX() : int
  pre: true
  post: true
  activity: (     return self.x );
   operation getY() : int
  pre: true
  post: true
  activity: (     return self.y );
  static   operation getDistance( s1 : Schedule, s2 : Schedule) : int
  pre: true
  post: true
  activity: (     var d : int ; d := if s1.getX() - s2.getX() < 0 then -(s1.getX() - s2.getX()) else s1.getX() - s2.getX() endif + if s1.getY() - s2.getY() < 0 then -(s1.getY() - s2.getY()) else s1.getY() - s2.getY() endif ;
     return d );
  static   operation getTimeDifference( s1 : Schedule, s2 : Schedule) : int
  pre: true
  post: true
  activity: (     var d : int ; d := if s1.getT() - s2.getT() < 0 then -(s1.getT() - s2.getT()) else s1.getT() - s2.getT() endif ;
     return d );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(Schedule) ; s := Sequence{} ;
    s := s->including(Schedule.newSchedule(0, 0, 0)) ; 
        var i : int ; i := 0 ; while i < n do ( (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var newS : Schedule ; newS := Schedule.newSchedule(t, x, y) ;
    s := s->including(newS) ; 
 )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "Yes" ;
        var i : int ; i := 0 ; while i < s->size() - 1 do ( (     var s1 : Schedule ;
    var s2 : Schedule ;
     s1 := s->at(i+1) ; 
    s2 := s->at(i + 1+1) ; 
    var dist : int ; dist := Schedule.getDistance(s1, s2) ;
    var timeDiff : int ; timeDiff := Schedule.getTimeDifference(s1, s2) ;
    if (dist <= timeDiff & (dist mod 2 = timeDiff mod 2)) then (     continue ) else skip ; 
    ans := "No" ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Optional ;
import java.util.OptionalDouble ;
import java.util.stream.DoubleStream ;
import java.util.stream.Stream ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String line ;
      String[] lines ;
      double[] s ;
      while(!(line=br.readLine()).equals("0")){
        int n=Integer.parseInt(line);
        lines=br.readLine().split(" ");
        s=Stream.of(lines).mapToDouble(Double :: parseDouble).toArray();
        double dm=Arrays.stream(s).average().getAsDouble();
        double result=Arrays.stream(s).map(d->Math.pow((d-dm),2)).sum();
        result=Math.sqrt((result)/n);
        System.out.printf("%.8f\n",result);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var line : String ;
     var lines : Sequence(String) ;
     var s : Sequence(double) ;
     while (not((line) = "0")) do (     var n : int ; n := (line)->toInteger() ;
     lines := br.readLine()->split(" ") ; 
    s := Sequence{lines}->collect( _x1 | (lambda _s : String in _s->toReal())->apply(_x1) )->asSequence() ; 
    var dm : double ; dm := stream(s).average().getAsDouble() ;
    var result : double ; result := stream(s)->collect( _x1 | (lambda d : OclAny in (d - dm)->pow(2))->apply(_x1) )->sum() ;
    result := ((result) / n)->sqrt() ; 
    OclFile["System.out"].printf("%.8f\n", result) ; 
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int count=scan.nextInt();
    int[] before={
      0,0,0 };
      boolean judge=true ;
      for(int i=0 ; i<count ; i++){
        boolean temp=check(scan,before);
        if(judge){
          judge=temp ;
        }
      }
      if(judge){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
    protected static boolean check(Scanner scan,int[] before){
      int t=scan.nextInt();
      int x=scan.nextInt();
      int y=scan.nextInt();
      int dif=Math.abs(x-before[1])+Math.abs(y-before[2]);
      int before_bak=before[0];
      before[0]=t ;
      before[1]=x ;
      before[2]=y ;
      t=t-before_bak ;
      while(t>0){
        if(dif==t){
          return true ;
        }
        t-=2 ;
      }
      return false ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := scan.getCurrent()->toInteger() ;
    var before : Sequence(int) ; before := Sequence{0,0,0} ;
    var judge : boolean ; judge := true ;
        var i : int ; i := 0 ; while i < count do ( (     var temp : boolean ; temp := check(scan, before) ;
     if (judge) then (     judge := temp ) else skip )  ;     i := i + 1 ) ; 
    if (judge) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
   static   operation check( scan : OclFile, before : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var t : int ; t := scan.getCurrent()->toInteger() ;
     var x : int ; x := scan.getCurrent()->toInteger() ;
    var y : int ; y := scan.getCurrent()->toInteger() ;
    var dif : int ; dif := if x - before[1+1] < 0 then -(x - before[1+1]) else x - before[1+1] endif + if y - before[2+1] < 0 then -(y - before[2+1]) else y - before[2+1] endif ;
    var before_bak : int ; before_bak := before[0+1] ;
    before[0+1] := t ; 
    before[1+1] := x ; 
    before[2+1] := y ; 
    t := t - before_bak ; 
    while (t > 0) do (     if (dif = t) then (     return true ) else skip ; 
     t := t-(2) ) ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int[][] data=new int[n][3];
      for(int i=0 ; i<n ; i++){
        data[i][0]=sc.nextInt();
        data[i][1]=sc.nextInt();
        data[i][2]=sc.nextInt();
      }
      int x=0,y=0,time=0 ;
      boolean flg=true ;
      for(int i=0 ; i<n ; i++){
        int dis=Math.abs(x-data[i][1])+Math.abs(y-data[i][2]);
        int distime=data[i][0]-time ;
        if(distime<dis){
          flg=false ;
          break ;
        }
        int diff=distime-dis ;
        if(diff % 2!=0){
          flg=false ;
          break ;
        }
      }
      System.out.println(flg ? "Yes" : "No");
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var data : Sequence(Sequence(int)) ; data := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     data[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     data[i+1][1+1] := sc.getCurrent()->toInteger() ; 
     data[i+1][2+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var time : int ; time := 0 ;
    var flg : boolean ; flg := true ;
        var i : int ; i := 0 ; while i < n do ( (     var dis : int ; dis := if x - data[i+1][1+1] < 0 then -(x - data[i+1][1+1]) else x - data[i+1][1+1] endif + if y - data[i+1][2+1] < 0 then -(y - data[i+1][2+1]) else y - data[i+1][2+1] endif ;
     var distime : int ; distime := data[i+1][0+1] - time ;
    if (distime < dis) then (     flg := false ; 
     break ) else skip ; 
    var diff : int ; diff := distime - dis ;
    if (diff mod 2 /= 0) then (     flg := false ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if flg then "Yes" else "No" endif) ; 
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      char[] s=sc.next().toCharArray();
      int sum=0 ;
      int i ;
      for(i=0 ; i<s.length-1 ; i++){
        if(f(s[i])>=f(s[i+1]))sum+=f(s[i]);
        else {
          sum+=f(s[i+1])-f(s[i]);
          i++;
        }
      }
      if(i<s.length)sum+=f(s[i]);
      System.out.println(sum);
    }
  }
  public static int f(char c){
    return c=='I' ? 1 : c=='V' ? 5 : c=='X' ? 10 : c=='L' ? 50 : c=='C' ? 100 : c=='D' ? 500 : 1000 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
     var sum : int ; sum := 0 ;
    var i : int ;
        i := 0 ; while i < s->size() - 1 do ( (     if (f(s[i+1]) >= f(s[i + 1+1])) then     sum := sum+(f(s[i+1])) ; else (     sum := sum+(f(s[i + 1+1]) - f(s[i+1])) ; 
     i := i + 1 ) )  ;     i := i + 1 ) ; 
    if (i < s->size()) then     sum := sum+(f(s[i+1])) ; else skip ; 
    OclFile["System.out"].println(sum) ; 
 ) );
  static   operation f( c : String) : int
  pre: true
  post: true
  activity: (     return if c = 'I' then 1 else if c = 'V' then 5 else if c = 'X' then 10 else if c = 'L' then 50 else if c = 'C' then 100 else if c = 'D' then 500 else 1000 endif endif endif endif endif endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String Roman=sc.next();
      int ans=getNum(Roman);
      System.out.println(ans);
    }
  }
  public static int getNum(String roman){
    int sum=0 ;
    int a=0 ;
    if(roman.length()>1){
      a=getFigure(roman.substring(roman.length()-2,roman.length()-1));
    }
    int b=getFigure(roman.substring(roman.length()-1,roman.length()));
    sum=b ;
    if(a<b){
      sum-=a ;
    }
    if(a>=b){
      sum+=a ;
    }
    for(int i=roman.length()-3 ; i>=0 ; i--){
      b=a ;
      if(i!=-1)a=getFigure(roman.substring(i,i+1));
      if(a<b){
        sum-=a ;
      }
      if(a>=b){
        sum+=a ;
      }
    }
    return sum ;
  }
  public static int getFigure(String num){
    if(num.equals("I")){
      return 1 ;
    }
    if(num.equals("V")){
      return 5 ;
    }
    if(num.equals("X")){
      return 10 ;
    }
    if(num.equals("L")){
      return 50 ;
    }
    if(num.equals("C")){
      return 100 ;
    }
    if(num.equals("D")){
      return 500 ;
    }
    if(num.equals("M")){
      return 1000 ;
    }
    return 0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var Roman : String ; Roman := sc.getCurrent() ;
     var ans : int ; ans := getNum(Roman) ;
     OclFile["System.out"].println(ans) ) );
  static   operation getNum( roman : String) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var a : int ; a := 0 ;
    if (roman->size() > 1) then (     a := getFigure(roman.subrange(roman->size() - 2+1,roman->size() - 1)) ) else skip ; 
    var b : int ; b := getFigure(roman.subrange(roman->size() - 1+1,roman->size())) ;
    sum := b ; 
    if (a < b) then (     sum := sum-(a) ) else skip ; 
    if (a >= b) then (     sum := sum+(a) ) else skip ; 
        var i : int ; i := roman->size() - 3 ; while i >= 0 do ( (     b := a ; 
     if (i /= -1) then     a := getFigure(roman.subrange(i+1,i + 1)) ; else skip ; 
     if (a < b) then (     sum := sum-(a) ) else skip ; 
     if (a >= b) then (     sum := sum+(a) ) else skip )  ;     i := i - 1 ) ; 
    return sum 
 );
  static   operation getFigure( num : String) : int
  pre: true
  post: true
  activity: (     if (num = "I") then (     return 1 ) else skip ; 
     if (num = "V") then (     return 5 ) else skip ; 
    if (num = "X") then (     return 10 ) else skip ; 
    if (num = "L") then (     return 50 ) else skip ; 
    if (num = "C") then (     return 100 ) else skip ; 
    if (num = "D") then (     return 500 ) else skip ; 
    if (num = "M") then (     return 1000 ) else skip ; 
    return 0 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    while(true){
      String line=reader.readLine();
      if(line==null || line.isEmpty()){
        break ;
      }
      line+='Z' ;
      int sum=0 ;
      int n1=numbers[line.charAt(0)-'A'];
      for(int i=0 ; i<line.length()-1 ; i++){
        int n2=numbers[line.charAt(i+1)-'A'];
        if(n1>=n2){
          sum+=n1 ;
        }
        else {
          sum-=n1 ;
        }
        n1=n2 ;
      }
      out.println(sum);
    }
  }
  private static final int[] numbers={
    0,0,100,500,0,0,0,0,1,0,0,50,1000,0,0,0,0,0,0,0,0,5,0,10,0,0 };
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     while (true) do (     var line : String ; line := reader.readLine() ;
     if (line = null or line->isEmpty()) then (     break ) else skip ; 
    line := line+('Z') ; 
    var sum : int ; sum := 0 ;
    var n1 : int ; n1 := numbers[line->at(0+1) - ('A')->char2byte()+1] ;
        var i : int ; i := 0 ; while i < line->size() - 1 do ( (     var n2 : int ; n2 := numbers[line->at(i + 1+1) - ('A')->char2byte()+1] ;
     if (n1 >= n2) then (     sum := sum+(n1) ) else (     sum := sum-(n1) ) ;  
     n1 := n2 )  ;     i := i + 1 ) ; 
    out.println(sum) ; 
 ) );
  static    attribute numbers : Sequence(int) := Sequence{0,0,100,500,0,0,0,0,1,0,0,50,1000,0,0,0,0,0,0,0,0,5,0,10,0,0};
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  static Map<Character,Integer>roman_int=new HashMap<Character,Integer>();
  static {
    Main.roman_int.put('I',1);
    Main.roman_int.put('V',5);
    Main.roman_int.put('X',10);
    Main.roman_int.put('L',50);
    Main.roman_int.put('C',100);
    Main.roman_int.put('D',500);
    Main.roman_int.put('M',1000);
  }
  static int toDecimal(String roman){
    char[] r=roman.toCharArray();
    int result=0 ;
    Comparator<Character>rComperator=new Comparator<Character>(){
      @ Override public int compare(Character c1,Character c2){
        int i1=Main.roman_int.get(c1);
        int i2=Main.roman_int.get(c2);
        if(i1<i2)return-1 ;
        else if(i1==i2)return 0 ;
        else return 1 ;
      }
    };
    char lastc=r[0];
    int temp=0 ;
    for(char c : r){
      switch(rComperator.compare(lastc,c)){
        case-1 : result+=-temp ;
        temp=Main.roman_int.get(c);
        break ;
        case 1 : result+=temp ;
        temp=Main.roman_int.get(c);
        break ;
        case 0 : default : temp+=Main.roman_int.get(c);
      }
      lastc=c ;
    }
    result+=temp ;
    return result ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextLine()){
      System.out.println(Main.toDecimal(sc.nextLine()));
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute roman_int : Map(String,int) := Map{};
  static operation initialiseClass()
  pre: true post: true
  activity:     Main := Main.roman_int->union(Map{'I' |-> 1}) ; 
    Main := Main.roman_int->union(Map{'V' |-> 5}) ; 
    Main := Main.roman_int->union(Map{'X' |-> 10}) ; 
    Main := Main.roman_int->union(Map{'L' |-> 50}) ; 
    Main := Main.roman_int->union(Map{'C' |-> 100}) ; 
    Main := Main.roman_int->union(Map{'D' |-> 500}) ; 
    Main := Main.roman_int->union(Map{'M' |-> 1000}) ; 
;
  static   operation toDecimal( roman : String) : int
  pre: true
  post: true
  activity: (     var r : Sequence(String) ; r := roman->characters() ;
     var result : int ; result := 0 ;
    var rComperator : Function(<String>,(<String>,boolean)) ; rComperator := OclComparator<String>.newOclComparator() ;
    var lastc : String ; lastc := r[0+1] ;
    var temp : int ; temp := 0 ;
    for (c : r) do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (rComperator.compare(lastc, c)) ; 
       if _switchval = -1 then
     result := result+(-temp) ; 
    temp := Main.roman_int->at(c+1) ; 
    break 
   else skip ;
       if _switchval = 1 then
     result := result+(temp) ; 
    temp := Main.roman_int->at(c+1) ; 
    break 
   else skip ;
    if _switchval = 0 or true then
    temp := temp+(Main.roman_int->at(c+1)) ; 
   else skip ;
 )
     lastc := c )  ) ; 
    result := result+(temp) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextLine()) do (     OclFile["System.out"].println(Main.toDecimal(sc.nextLine())) ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int __gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static int countPrimeFactors(int x){
    int res=0 ;
    if(x % 2==0){
      res++;
      while(x % 2==0)x=x/2 ;
    }
    for(int i=3 ; i<=Math.sqrt(x); i=i+2){
      if(x % i==0){
        res++;
        while(x % i==0)x=x/i ;
      }
    }
    if(x>2)res++;
    return res ;
  }
  static int countCommonPrimeFactors(int a,int b){
    int gcd=__gcd(a,b);
    return countPrimeFactors(gcd);
  }
  public static void main(String[] args){
    int a=6,b=12 ;
    System.out.println(countCommonPrimeFactors(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
    if (a = b) then     return a else skip ; 
    if (a > b) then     return __gcd(a - b, b) else skip ; 
    return __gcd(a, b - a) 
 );
  static   operation countPrimeFactors( x : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     if (x mod 2 = 0) then (     res := res + 1 ; 
     while (x mod 2 = 0) do     x := x / 2 ; ) else skip ; 
        var i : int ; i := 3 ; while i <= (x)->sqrt() do ( (     if (x mod i = 0) then (     res := res + 1 ; 
     while (x mod i = 0) do     x := x / i ; ) else skip )  ;     i := i + 2 ) ; 
    if (x > 2) then     res := res + 1 ; else skip ; 
    return res 
 );
  static   operation countCommonPrimeFactors( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var gcd : int ; gcd := __gcd(a, b) ;
     return countPrimeFactors(gcd) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 6 ;
    var b : int ; b := 12 ;
     OclFile["System.out"].println(countCommonPrimeFactors(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class ques {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int[] arr=new int[n];
      int[] arr2=new int[n];
      try {
        for(int j=0 ; j<n ; j++){
          arr[j]=sc.nextInt();
          arr2[j]=j+1 ;
        }
        for(int j=0 ; j<n-1 ; j++){
          if(arr2[j]==arr[j]){
            int temp=arr2[j];
            arr2[j]=arr2[j+1];
            arr2[j+1]=temp ;
          }
        }
        if(arr2[n-1]==arr[n-1]){
          int temp=arr2[n-1];
          arr2[n-1]=arr2[n-2];
          arr2[n-2]=temp ;
        }
        for(int j=0 ; j<n ; j++){
          System.out.print(arr2[j]+" ");
        }
        System.out.println();
      }
      catch(Exception e){
        System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ques {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
     var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,n)->collect(0) ;
     try (         var j : int ; j := 0 ; while j < n do ( (     arr[j+1] := sc.getCurrent()->toInteger() ; 
     arr2[j+1] := j + 1 )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < n - 1 do ( (     if (arr2[j+1] = arr[j+1]) then (     var temp : int ; temp := arr2[j+1] ;
     arr2[j+1] := arr2[j + 1+1] ; 
     arr2[j + 1+1] := temp ) else skip )  ;     j := j + 1 ) ; 
    if (arr2[n - 1+1] = arr[n - 1+1]) then (     var temp : int ; temp := arr2[n - 1+1] ;
     arr2[n - 1+1] := arr2[n - 2+1] ; 
     arr2[n - 2+1] := temp ) else skip ; 
        var j : int ; j := 0 ; while j < n do ( (     OclFile["System.out"].print(arr2[j+1] + " ") )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println() ; 
 )   catch (e : ProgramException) do (     OclFile["System.out"].println(-1) )
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isPossibleToZero(int a[],int n){
    int even=0,odd=0 ;
    for(int i=0 ; i<n ; i++){
      if((i & 1)==0)odd+=a[i];
      else even+=a[i];
    }
    return(odd==even);
  }
  public static void main(String[] args){
    int arr[]={
      0,1,1,0 };
      int n=arr.length ;
      if(isPossibleToZero(arr,n))System.out.println("YES");
      else System.out.println("NO");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPossibleToZero( a : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var even : int ; even := 0 ;
    var odd : int ; odd := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if ((MathLib.bitwiseAnd(i,1)) = 0) then     odd := odd+(a[i+1]) ; else     even := even+(a[i+1]) ; )  ;     i := i + 1 ) ; 
     return (odd = even) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,1,1,0} ;
     var n : int ; n := arr->size() ;
     if (isPossibleToZero(arr, n)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static Queue<Integer>q=new LinkedList<Integer>();
  static boolean checkSorted(int n){
    Stack<Integer>st=new Stack<Integer>();
    int expected=1 ;
    int fnt ;
    while(q.size()!=0){
      fnt=q.peek();
      q.poll();
      if(fnt==expected)expected++;
      else {
        if(st.size()==0){
          st.push(fnt);
        }
        else if(st.size()!=0 && st.peek()<fnt){
          return false ;
        }
        else st.push(fnt);
      }
      while(st.size()!=0 && st.peek()==expected){
        st.pop();
        expected++;
      }
    }
    if(expected-1==n && st.size()==0)return true ;
    return false ;
  }
  public static void main(String args[]){
    q.add(5);
    q.add(1);
    q.add(2);
    q.add(3);
    q.add(4);
    int n=q.size();
    if(checkSorted(n))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute q : Sequence(int) := Sequence{};
  static   operation checkSorted( n : int) : boolean
  pre: true
  post: true
  activity: (     var st : Sequence(int) ; st := Sequence{} ;
     var expected : int ; expected := 1 ;
    var fnt : int ;
    while (q->size() /= 0) do (     fnt := q->min() ; 
     q := q->sort()->tail() ; 
     if (fnt = expected) then     expected := expected + 1 else (     if (st->size() = 0) then (     st := st->append(fnt) ) else     if (st->size() /= 0 & st->min() < fnt) then (     return false ) else     st := st->append(fnt) ; ;  ) ;  
     while (st->size() /= 0 & st->min() = expected) do (     st := st->front() ; 
     expected := expected + 1 ) ) ; 
    if (expected - 1 = n & st->size() = 0) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     q := q->including(5) ; 
     q := q->including(1) ; 
    q := q->including(2) ; 
    q := q->including(3) ; 
    q := q->including(4) ; 
    var n : int ; n := q->size() ;
    if (checkSorted(n)) then     OclFile["System.out"].print("Yes") else     OclFile["System.out"].print("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int intLoop=scan.nextInt();
    double dbAve=0 ;
    int intTemp=0 ;
    double dbVariance=0 ;
    double dbDeviation=0 ;
    ArrayList<Integer>list=new ArrayList<Integer>();
    ArrayList<Double>devList=new ArrayList<Double>();
    while(intLoop!=0){
      dbAve=0 ;
      intTemp=0 ;
      dbVariance=0 ;
      dbDeviation=0 ;
      list=new ArrayList<Integer>();
      for(int i=0 ; i<intLoop ; i++){
        intTemp=scan.nextInt();
        list.add(intTemp);
        dbAve+=intTemp ;
      }
      dbAve=dbAve/intLoop ;
      for(int i=0 ; i<intLoop ; i++){
        dbVariance+=Math.pow(list.get(i)-dbAve,2);
      }
      dbVariance/=intLoop ;
      dbDeviation=Math.sqrt(dbVariance);
      devList.add(dbDeviation);
      intLoop=scan.nextInt();
    }
    for(int i=0 ; i<devList.size(); i++){
      System.out.println(devList.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var intLoop : int ; intLoop := scan.getCurrent()->toInteger() ;
    var dbAve : double ; dbAve := 0 ;
    var intTemp : int ; intTemp := 0 ;
    var dbVariance : double ; dbVariance := 0 ;
    var dbDeviation : double ; dbDeviation := 0 ;
    var list : Sequence(int) ; list := Sequence{} ;
    var devList : Sequence(double) ; devList := Sequence{} ;
    while (intLoop /= 0) do (     dbAve := 0 ; 
     intTemp := 0 ; 
    dbVariance := 0 ; 
    dbDeviation := 0 ; 
    list := Sequence{} ; 
        var i : int ; i := 0 ; while i < intLoop do ( (     intTemp := scan.getCurrent()->toInteger() ; 
     list := list->including(intTemp) ; 
     dbAve := dbAve+(intTemp) )  ;     i := i + 1 ) ; 
    dbAve := dbAve / intLoop ; 
        var i : int ; i := 0 ; while i < intLoop do ( (     dbVariance := dbVariance+(list->at(i+1) - dbAve->pow(2)) )  ;     i := i + 1 ) ; 
    dbVariance := dbVariance/(intLoop) ; 
    dbDeviation := (dbVariance)->sqrt() ; 
    devList := devList->including(dbDeviation) ; 
    intLoop := scan.getCurrent()->toInteger() ; 
 ) ; 
        var i : int ; i := 0 ; while i < devList->size() do ( (     OclFile["System.out"].println(devList->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  public static void main(String omkar[])throws Exception {
    BufferedReader infile=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(infile.readLine());
    int N=Integer.parseInt(st.nextToken());
    Thing[] arr=new Thing[N];
    st=new StringTokenizer(infile.readLine());
    for(int i=0 ; i<N ; i++)arr[i]=new Thing(i,Integer.parseInt(st.nextToken()));
    dp=new long[N+1][N+1];
    for(int i=0 ; i<=N ; i++)Arrays.fill(dp[i],-1);
    Arrays.sort(arr);
    System.out.println(dfs(0,0,arr));
  }
  static long[][] dp ;
  public static long dfs(int a,int b,Thing[] arr){
    if(dp[a][b]!=-1)return dp[a][b];
    int N=dp.length-1 ;
    if(a+b==N)return 0L ;
    Thing curr=arr[a+b];
    long res=(long)curr.val*Math.abs(curr.index-a)+dfs(a+1,b,arr);
    res=Math.max(res,(long)curr.val*Math.abs(curr.index-(N-1-b))+dfs(a,b+1,arr));
    return dp[a][b]=res ;
  }
}
class Thing implements Comparable<Thing>{
  public int index ;
  public int val ;
  public Thing(int a,int b){
    index=a ;
    val=b ;
  }
  public int compareTo(Thing oth){
    return oth.val-val ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( omkar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var infile : OclFile ; infile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(infile.readLine()) ;
    var N : int ; N := (st.next())->toInteger() ;
    var arr : Sequence(Thing) ; arr := Integer.subrange(1,N)->collect(null) ;
    st := OclIterator.newOclIterator_String(infile.readLine()) ; 
        var i : int ; i := 0 ; while i < N do (     arr[i+1] := Thing.newThing(i, (st.next())->toInteger()) ;  ;     i := i + 1 ) ; 
    dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ; 
        var i : int ; i := 0 ; while i <= N do (     dp[i+1] := dp[i+1]->collect(-1) ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    OclFile["System.out"].println(dfs(0, 0, arr)) ; 
 );
  static   attribute dp : Sequence(Sequence(long));
  static   operation dfs( a : int, b : int, arr : Sequence(Thing)) : long
  pre: true
  post: true
  activity: (     if (dp[a+1][b+1] /= -1) then     return dp[a+1][b+1] else skip ; 
     var N : int ; N := dp->size() - 1 ;
    if (a + b = N) then     return 0L else skip ; 
    var curr : Thing ; curr := arr[a + b+1] ;
    var res : long ; res := curr.val->oclAsType(long) * if curr.index - a < 0 then -(curr.index - a) else curr.index - a endif + dfs(a + 1, b, arr) ;
    res := Set{res, curr.val->oclAsType(long) * if curr.index - (N - 1 - b) < 0 then -(curr.index - (N - 1 - b)) else curr.index - (N - 1 - b) endif + dfs(a, b + 1, arr)}->max() ; 
    return dp[a+1][b+1] 
 );
}
class Thing implements Comparable<Thing> {
   attribute index : int;
   attribute val : int;
   static operation newThing( a : int, b : int) : Thing
  pre: true
  post: true
  activity:
  ( var self : Thing ;
    self := createThing();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     index := a ; 
     val := b );
   operation compareTo( oth : Thing) : int
  pre: true
  post: true
  activity: (     return oth.val - val );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  List<Pair>list=new ArrayList<>();
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    int n=sc.nextInt();
    long[][] dp=new long[n+1][n+1];
    long[] arr=new long[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      Pair tmpP=new Pair(i,arr[i]);
      list.add(tmpP);
    }
    Collections.sort(list,(o1,o2)->Long.compare(o2.power,o1.power));
    long ans=0 ;
    label : for(int i=0 ;
    i<n ;
    i++){
      for(int j=0 ; j<n ; j++){
        if(n<=i+j)continue label ;
        Pair tmp=list.get(i+j);
        dp[i+1][j]=Math.max(dp[i+1][j],dp[i][j]+(tmp.idx-i)*tmp.power);
        dp[i][j+1]=Math.max(dp[i][j+1],dp[i][j]+(n-1-j-tmp.idx)*tmp.power);
      }
    }
    for(int i=0 ; i<=n ; i++){
      ans=Math.max(ans,dp[i][n-i]);
    }
    System.out.println(ans);
  }
  class Pair {
    long idx ;
    long power ;
    public Pair(long i,long p){
      this.idx=i ;
      this.power=p ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute list : Sequence(Map) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     var tmpP : Map ; tmpP := Map(i, arr[i+1]) ;
     list := list->including(tmpP) )  ;     i := i + 1 ) ; 
    list, lambda (o1 , o2) : OclAny in compare(o2.power, o1.power) := list, lambda (o1 , o2) : OclAny in compare(o2.power, o1.power)->sort() ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (n <= i + j) then     continue else skip ; 
     var tmp : Map ; tmp := list->at(i + j+1) ;
     dp[i + 1+1][j+1] := Set{dp[i + 1+1][j+1], dp[i+1][j+1] + (tmp.idx - i) * tmp.power}->max() ; 
     dp[i+1][j + 1+1] := Set{dp[i+1][j + 1+1], dp[i+1][j+1] + (n - 1 - j - tmp.idx) * tmp.power}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= n do ( (     ans := Set{ans, dp[i+1][n - i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
 class Pair {
   attribute idx : long;
   attribute power : long;
   static operation newPair( i : long, p : long) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(i, p);
    return self );
  operation initialise( i : long, p : long) : void
  pre: true  post: true
  activity: (     self.idx := i ; 
     self.power := p );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Arrays ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] A=new int[N];
    ArrayList<int[]>list=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
      int[] a={
        i,A[i] };
        list.add(a);
      }
      long[][] dp=new long[N+1][N+1];
      long max=0L ;
      Collections.sort(list,new Comparator<int[]>(){
        @ Override public int compare(int[] obj1,int[] obj2){
          return obj2[1]-obj1[1];
        }
      }
);
      for(int x=0 ; x<N ; x++){
        for(int y=0 ; y<N ; y++){
          if(x+y<N){
            int[] dpm=list.get(x+y);
            if(y+1<=N)dp[x][y+1]=Math.max(dp[x][y+1],dp[x][y]+(long)dpm[1]*Math.abs(dpm[0]-(N-y-1)));
            if(x+1<=N)dp[x+1][y]=Math.max(dp[x+1][y],dp[x][y]+(long)dpm[1]*Math.abs(dpm[0]-x));
          }
        }
      }
      for(int i=0 ; i<N+1 ; i++){
        max=Math.max(max,dp[i][N-i]);
      }
      System.out.println(max);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var list : Sequence(Sequence(int)) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() ; 
     var a : Sequence(int) ; a := Sequence{i,A[i+1]} ;
     list := list->including(a) )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
    var max : long ; max := 0L ;
    list, OclComparator<Sequence(int)>.newOclComparator() := list, OclComparator<Sequence(int)>.newOclComparator()->sort() ; 
        var x : int ; x := 0 ; while x < N do ( (         var y : int ; y := 0 ; while y < N do ( (     if (x + y < N) then (     var dpm : Sequence(int) ; dpm := list->at(x + y+1) ;
     if (y + 1 <= N) then     dp[x+1][y + 1+1] := Set{dp[x+1][y + 1+1], dp[x+1][y+1] + dpm[1+1]->oclAsType(long) * if dpm[0+1] - (N - y - 1) < 0 then -(dpm[0+1] - (N - y - 1)) else dpm[0+1] - (N - y - 1) endif}->max() ; else skip ; 
     if (x + 1 <= N) then     dp[x + 1+1][y+1] := Set{dp[x + 1+1][y+1], dp[x+1][y+1] + dpm[1+1]->oclAsType(long) * if dpm[0+1] - x < 0 then -(dpm[0+1] - x) else dpm[0+1] - x endif}->max() ; else skip ) else skip )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
        var i : int ; i := 0 ; while i < N + 1 do ( (     max := Set{max, dp[i+1][N - i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  static Long[][] dp ;
  static int INF=(int)1e9+7 ;
  static Integer[][] arr ;
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int N=s.nextInt();
    arr=new Integer[N][2];
    for(int i=0 ; i<N ; i++){
      arr[i][0]=s.nextInt();
      arr[i][1]=i ;
    }
    Arrays.sort(arr,(a,b)->b[0]-a[0]);
    dp=new Long[N][N];
    System.out.println(dfs(0,0,N-1));
  }
  private static long dfs(int index,int left,int right){
    if(index==arr.length){
      return 0 ;
    }
    if(dp[left][right]!=null){
      return dp[left][right];
    }
    return dp[left][right]=Math.max(dfs(index+1,left+1,right)+(long)arr[index][0]*Math.abs(arr[index][1]-left),dfs(index+1,left,right-1)+(long)arr[index][0]*Math.abs(arr[index][1]-right));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dp : Sequence(Sequence(long));
  static   attribute INF : int := 1e9->oclAsType(int) + 7;
  static   attribute arr : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := s.getCurrent()->toInteger() ;
    arr := Integer.subrange(1,N)->collect(Integer.subrange(1,2)->collect(null)) ; 
        var i : int ; i := 0 ; while i < N do ( (     arr[i+1][0+1] := s.getCurrent()->toInteger() ; 
     arr[i+1][1+1] := i )  ;     i := i + 1 ) ; 
    arr := OclComparator.sortWith(arr, lambda (a , b) : OclAny in b[0+1] - a[0+1]) ; 
    dp := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(null)) ; 
    OclFile["System.out"].println(dfs(0, 0, N - 1)) ; 
 );
  static   operation dfs( index : int, left : int, right : int) : long
  pre: true
  post: true
  activity: (     if (index = arr->size()) then (     return 0 ) else skip ; 
     if (dp[left+1][right+1] /= null) then (     return dp[left+1][right+1] ) else skip ; 
     return dp[left+1][right+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    StringTokenizer st=new StringTokenizer(br.readLine());
    ArrayList<Info>infants=new ArrayList<>();
    for(int i=1 ; i<=n ; i++){
      infants.add(new Info(i,Long.parseLong(st.nextToken())));
    }
    Collections.sort(infants,Collections.reverseOrder());
    long dp[][]=new long[n+1][n+1];
    for(int i=0 ; i<n ; i++){
      Info curr=infants.get(i);
      for(int l=0 ; l<=i+1 ; l++){
        long op1=0,op2=0 ;
        int r=i+1-l ;
        if(l!=0){
          op1=dp[l-1][r]+curr.val*(Math.abs(l-curr.index));
        }
        if(r!=0){
          op2=dp[l][r-1]+curr.val*(Math.abs(n-r+1-curr.index));
        }
        dp[l][r]=Math.max(op1,op2);
      }
    }
    long ans=0 ;
    for(int i=0 ; i<=n ; i++){
      ans=Math.max(ans,dp[i][n-i]);
    }
    System.out.println(ans);
  }
}
class Info implements Comparable<Info>{
  long val ;
  int index ;
  public Info(int index,long val){
    this.val=val ;
    this.index=index ;
  }
  @ Override public int compareTo(Info o){
    return Long.compare(this.val,o.val);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var infants : Sequence(Info) ; infants := Sequence{} ;
        var i : int ; i := 1 ; while i <= n do ( (     infants := infants->including(Info.newInfo(i, (st.next())->toLong())) )  ;     i := i + 1 ) ; 
    infants, reverseOrder() := infants, reverseOrder()->sort() ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var curr : Info ; curr := infants->at(i+1) ;
         var l : int ; l := 0 ; while l <= i + 1 do ( (     var op1 : long ; op1 := 0 ;
    var op2 : long ; op2 := 0 ;
     var r : int ; r := i + 1 - l ;
    if (l /= 0) then (     op1 := dp[l - 1+1][r+1] + curr.val * (if l - curr.index < 0 then -(l - curr.index) else l - curr.index endif) ) else skip ; 
    if (r /= 0) then (     op2 := dp[l+1][r - 1+1] + curr.val * (if n - r + 1 - curr.index < 0 then -(n - r + 1 - curr.index) else n - r + 1 - curr.index endif) ) else skip ; 
    dp[l+1][r+1] := Set{op1, op2}->max() ; 
 )  ;     l := l + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i <= n do ( (     ans := Set{ans, dp[i+1][n - i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}
class Info implements Comparable<Info> {
   attribute val : long;
   attribute index : int;
   static operation newInfo( index : int, val : long) : Info
  pre: true
  post: true
  activity:
  ( var self : Info ;
    self := createInfo();
    self.initialise(index, val);
    return self );
  operation initialise( index : int, val : long) : void
  pre: true  post: true
  activity: (     self.val := val ; 
     self.index := index );
      operation compareTo( o : Info) : int
  pre: true
  post: true
  activity: (     return compare(self.val, o.val) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printReverseFloyd(int n){
    int curr_val=n*(n+1)/2 ;
    for(int i=n ; i>=1 ; i--){
      for(int j=i ; j>=1 ; j--){
        System.out.printf("%2d  ",curr_val--);
      }
      System.out.println("");
    }
  }
  public static void main(String[] args){
    int n=7 ;
    printReverseFloyd(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printReverseFloyd( n : int) : void
  pre: true
  post: true
  activity: (     var curr_val : int ; curr_val := n * (n + 1) / 2 ;
         var i : int ; i := n ; while i >= 1 do ( (         var j : int ; j := i ; while j >= 1 do ( (     OclFile["System.out"].printf("%2d  ", curr_val) )  ;     j := j - 1 ) ; 
     OclFile["System.out"].println("") )  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     execute printReverseFloyd(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class GFG {
  static void solve(int arr[],int n,int k){
    Arrays.sort(arr);
    if(k==1 && arr[n-2]!=arr[n-1]){
      System.out.println(arr[n-1]);
      return ;
    }
    int count=1 ;
    for(int i=n-2 ; i>=0 ; i--){
      if(arr[i]==arr[i+1])count++;
      else count=1 ;
      if(count==k &&(i==0 ||(arr[i-1]!=arr[i]))){
        System.out.println(arr[i]);
        return ;
      }
    }
    System.out.println("No such element");
  }
  public static void main(String args[]){
    int arr[]={
      1,1,2,3,3,4,5,5,6,6,6 };
      int k=2 ;
      int n=arr.length ;
      solve(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     if (k = 1 & arr[n - 2+1] /= arr[n - 1+1]) then (     OclFile["System.out"].println(arr[n - 1+1]) ; 
     return ) else skip ; 
    var count : int ; count := 1 ;
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (arr[i+1] = arr[i + 1+1]) then     count := count + 1 else     count := 1 ; ;  
     if (count = k & (i = 0 or (arr[i - 1+1] /= arr[i+1]))) then (     OclFile["System.out"].println(arr[i+1]) ; 
     return ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println("No such element") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,2,3,3,4,5,5,6,6,6} ;
     var k : int ; k := 2 ;
     var n : int ; n := arr->size() ;
     execute solve(arr, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Wifi {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      if(n==1){
        System.out.println(-1);
        continue ;
      }
      int[] ans=new int[n];
      for(int i=0 ; i<n ; i++){
        ans[i]=i+1 ;
      }
      for(int i=0 ; i<n ; i++){
        if(ans[i]==arr[i]){
          if(i==n-1){
            int pre=ans[i-1];
            ans[i-1]=ans[i];
            ans[i]=pre ;
          }
          else {
            int f=ans[i+1];
            ans[i+1]=ans[i];
            ans[i]=f ;
          }
        }
      }
      for(int i : ans){
        System.out.print(i+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Wifi {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (n = 1) then (     OclFile["System.out"].println(-1) ; 
     continue ) else skip ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ans[i+1] := i + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (ans[i+1] = arr[i+1]) then (     if (i = n - 1) then (     var pre : int ; pre := ans[i - 1+1] ;
     ans[i - 1+1] := ans[i+1] ; 
     ans[i+1] := pre ) else (     var f : int ; f := ans[i + 1+1] ;
     ans[i + 1+1] := ans[i+1] ; 
     ans[i+1] := f ) ) else skip )  ;     i := i + 1 ) ; 
    for (i : ans) do ( (     OclFile["System.out"].print(i + " ") )  ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static void longestSubsequence(int a[],int n,int q[],int m){
    Arrays.sort(a);
    int sum=0 ;
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++){
      sum+=a[i];
      double av=(double)(sum)/(double)(i+1);
      b[i]=((int)(av+1));
    }
    Arrays.sort(b);
    for(int i=0 ; i<m ; i++){
      int k=q[i];
      int longest=upperBound(b,0,n,k);
      System.out.println("Answer to Query"+(i+1)+": "+longest);
    }
  }
  private static int upperBound(int[] a,int low,int high,int element){
    while(low<high){
      int middle=low+(high-low)/2 ;
      if(a[middle]>element)high=middle ;
      else low=middle+1 ;
    }
    return low ;
  }
  public static void main(String[] args){
    int a[]={
      1,3,2,5,4 };
      int n=a.length ;
      int q[]={
        4,2,1,5 };
        int m=q.length ;
        longestSubsequence(a,n,q,m);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation longestSubsequence( a : Sequence(int), n : int, q : Sequence(int), m : int) : void
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var sum : int ; sum := 0 ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(a[i+1]) ; 
     var av : double ; av := (sum)->oclAsType(double) / (i + 1)->oclAsType(double) ;
     b[i+1] := ((av + 1)->oclAsType(int)) )  ;     i := i + 1 ) ; 
    b := b->sort() ; 
        var i : int ; i := 0 ; while i < m do ( (     var k : int ; k := q[i+1] ;
     var longest : int ; longest := upperBound(b, 0, n, k) ;
     OclFile["System.out"].println("Answer to Query" + (i + 1) + ": " + longest) )  ;     i := i + 1 ) ; 
 );
  static   operation upperBound( a : Sequence(int), low : int, high : int, element : int) : int
  pre: true
  post: true
  activity: (     while (low < high) do (     var middle : int ; middle := low + (high - low) / 2 ;
     if (a[middle+1] > element) then     high := middle ; else     low := middle + 1 ; ) ; 
     return low );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,3,2,5,4} ;
     var n : int ; n := a->size() ;
    var q : Sequence(int) ; q := Sequence{4,2,1,5} ;
    var m : int ; m := q->size() ;
    execute longestSubsequence(a, n, q, m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  static boolean coprime(int a,int b){
    if(__gcd(a,b)==1)return true ;
    else return false ;
  }
  static boolean isPrime(int n){
    if(n<=1)return false ;
    if(n==2 || n==3)return true ;
    for(int i=2 ; i*i<=n ; i++)if(n % i==0)return false ;
    return true ;
  }
  static void findNumbers(int a,int b,int n){
    boolean possible=true ;
    if(! coprime(a,b))possible=false ;
    int c1=1 ;
    int c2=1 ;
    int num1,num2 ;
    HashSet<Integer>st=new HashSet<Integer>();
    if(possible){
      while((int)st.size()!=n){
        num1=a+(c1*b);
        if(isPrime(num1)){
          st.add(num1);
        }
        c1++;
        num2=b+(c2*a);
        if(isPrime(num2)){
          st.add(num2);
        }
        c2++;
      }
      for(int i : st)System.out.print(i+" ");
    }
    else System.out.print("-1");
  }
  public static void main(String[] args){
    int a=3 ;
    int b=5 ;
    int n=4 ;
    findNumbers(a,b,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation coprime( a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     if (__gcd(a, b) = 1) then     return true else     return false );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n = 2 or n = 3) then     return true else skip ; 
         var i : int ; i := 2 ; while i * i <= n do (     if (n mod i = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation findNumbers( a : int, b : int, n : int) : void
  pre: true
  post: true
  activity: (     var possible : boolean ; possible := true ;
     if (not(coprime(a, b))) then     possible := false ; else skip ; 
    var c1 : int ; c1 := 1 ;
    var c2 : int ; c2 := 1 ;
    var num1 : int ;
    var num2 : int ;
    var st : Set(int) ; st := Set{} ;
    if (possible) then (     while (st->size()->oclAsType(int) /= n) do (     num1 := a + (c1 * b) ; 
     if (isPrime(num1)) then (     st := st->including(num1) ) else skip ; 
    c1 := c1 + 1 ; 
    num2 := b + (c2 * a) ; 
    if (isPrime(num2)) then (     st := st->including(num2) ) else skip ; 
    c2 := c2 + 1 ; 
 ) ; 
     for (i : st) do (     OclFile["System.out"].print(i + " ") ;  ) ) else     OclFile["System.out"].print("-1") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
     var b : int ; b := 5 ;
     var n : int ; n := 4 ;
     execute findNumbers(a, b, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static void shufleArray(int[] a,int n){
    int temp ;
    n=n/2 ;
    for(int start=n+1,j=n+1,done=0,i ; done<2*n-2 ; done++){
      if(start==j){
        start--;
        j--;
      }
      i=j>n ? j-n : j ;
      j=j>n ? 2*i : 2*i-1 ;
      temp=a[start];
      a[start]=a[j];
      a[j]=temp ;
    }
  }
  static public void main(String[] args){
    int[] a={
-1,1,3,5,7,2,4,6,8 };
      int n=a.length ;
      shufleArray(a,n);
      for(int i=1 ; i<n ; i++)System.out.print(a[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation shufleArray( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var temp : int ;
     n := n / 2 ; 
         var start : int ; start := n + 1 ;
    var j : int ; j := n + 1 ;
    var done : int ; done := 0 ;
    var i : int ; while done < 2 * n - 2 do ( (     if (start = j) then (     start := start - 1 ; 
     j := j - 1 ) else skip ; 
     i := if j > n then j - n else j endif ; 
    j := if j > n then 2 * i else 2 * i - 1 endif ; 
    temp := a[start+1] ; 
    a[start+1] := a[j+1] ; 
    a[j+1] := temp ; 
 )  ;     done := done + 1 ) );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{-1,1,3,5,7,2,4,6,8} ;
     var n : int ; n := a->size() ;
     execute shufleArray(a, n) ; 
         var i : int ; i := 1 ; while i < n do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static final int BIG_NUM=2000000000 ;
  public static final int MOD=1000000007 ;
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int N ;
    double M,SUM ;
    try {
      while((N=Integer.parseInt(br.readLine()))!=0){
        String input[]=br.readLine().split("\\s+");
        double array[]=new double[input.length];
        SUM=0 ;
        for(int i=0 ; i<input.length ; i++){
          array[i]=Double.parseDouble(input[i]);
          SUM+=array[i];
        }
        M=SUM/(double)N ;
        SUM=0 ;
        for(int i=0 ; i<array.length ; i++){
          SUM+=(array[i]-M)*(array[i]-M);
        }
        System.out.printf("%.10f\n",Math.sqrt(SUM/(double)N));
      }
    }
    catch(NumberFormatException e){
      e.printStackTrace();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BIG_NUM : int := 2000000000;
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var N : int ;
     var M : double ;
    var SUM : double ;
     try (         N := (br.readLine())->toInteger() ;
    while ((N) /= 0) do (    skip ; (     var input : Sequence(String) ; input := br.readLine()->split("\\s+") ;
     var array : Sequence(double) ; array := Integer.subrange(1,input->size())->collect(0.0) ;
    SUM := 0 ; 
        var i : int ; i := 0 ; while i < input->size() do ( (     array[i+1] := (input[i+1])->toReal() ; 
     SUM := SUM+(array[i+1]) )  ;     i := i + 1 ) ; 
    M := SUM / N->oclAsType(double) ; 
    SUM := 0 ; 
        var i : int ; i := 0 ; while i < array->size() do ( (     SUM := SUM+((array[i+1] - M) * (array[i+1] - M)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.10f\n", (SUM / N->oclAsType(double))->sqrt()) ; 
 ) ;     N := (br.readLine())->toInteger() ;
 ) )   catch (e : IncorrectElementException) do (     e.printStackTrace() )
   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  static class State implements Comparable<State>{
    int v,cost ;
    State(int v,int cost){
      this.v=v ;
      this.cost=cost ;
    }
    public int compareTo(State s){
      return this.cost-s.cost ;
    }
  }
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      boolean[][] edge=new boolean[n+1][n+1];
      for(int i=0 ; i<n ; i++){
        int r=sc.nextInt();
        int k=sc.nextInt();
        for(int j=0 ; j<k ; j++){
          int t=sc.nextInt();
          edge[r][t]=true ;
        }
      }
      int p=sc.nextInt();
      int[] dis=new int[n+1];
      PriorityQueue<State>pq=new PriorityQueue<>();
      int INF=100000000 ;
      while(p-->0){
        int s=sc.nextInt();
        int g=sc.nextInt();
        int v=sc.nextInt();
        pq.clear();
        Arrays.fill(dis,INF);
        pq.add(new State(s,0));
        while(! pq.isEmpty()){
          State state=pq.poll();
          if(dis[state.v]!=INF)continue ;
          dis[state.v]=state.cost ;
          if(state.v==g)break ;
          for(int i=1 ; i<=n ; i++){
            if(! edge[state.v][i])continue ;
            pq.add(new State(i,state.cost+1));
          }
        }
        if(dis[g]==INF || dis[g]>=v)System.out.println("NA");
        else System.out.println(dis[g]+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class State implements Comparable<State> {
   attribute v : int;
   static operation newState( v : int, cost : int) : State
  pre: true
  post: true
  activity:
  ( var self : State ;
    self := createState();
    self.initialise(v, cost);
    return self );
  operation initialise( v : int, cost : int) : void
  pre: true  post: true
  activity: (     self.v := v ; 
     self.cost := cost );
   operation compareTo( s : State) : int
  pre: true
  post: true
  activity: (     return self.cost - s.cost );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var edge : Sequence(Sequence(boolean)) ; edge := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(false)) ;
        var i : int ; i := 0 ; while i < n do ( (     var r : int ; r := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < k do ( (     var t : int ; t := sc.getCurrent()->toInteger() ;
     edge[r+1][t+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var p : int ; p := sc.getCurrent()->toInteger() ;
    var dis : Sequence(int) ; dis := Integer.subrange(1,n + 1)->collect(0) ;
    var pq : Sequence(State) ; pq := Sequence{} ;
    var INF : int ; INF := 100000000 ;
        while (p > 0) do (        p := p - 1 ;     skip ; (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var g : int ; g := sc.getCurrent()->toInteger() ;
    var v : int ; v := sc.getCurrent()->toInteger() ;
    pq := pq->intersection(Set{}) ; 
    dis := dis->collect(INF) ; 
    pq := pq->including(State.newState(s, 0)) ; 
    while (not(pq->isEmpty())) do (     var state : State ; state := pq->min() ;
     if (dis[state.v+1] /= INF) then     continue else skip ; 
    dis[state.v+1] := state.cost ; 
    if (state.v = g) then     break else skip ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (not(edge[state.v+1][i+1])) then     continue else skip ; 
     pq := pq->including(State.newState(i, state.cost + 1)) )  ;     i := i + 1 ) ; 
 ) ; 
    if (dis[g+1] = INF or dis[g+1] >= v) then     OclFile["System.out"].println("NA") else     OclFile["System.out"].println(dis[g+1] + 1) ; ;  
 ) ;  ) ;  
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static final int MAX=1000000 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[][] map=new int[n+1][n+1];
    for(int i=0 ; i<n ; i++){
      int from=sc.nextInt();
      int m=sc.nextInt();
      for(int j=0 ; j<m ; j++){
        map[from][sc.nextInt()]=1 ;
      }
    }
    floyd(map);
    int m=sc.nextInt();
    for(int i=0 ; i<m ; i++){
      int from=sc.nextInt();
      int to=sc.nextInt();
      int rem=sc.nextInt();
      if(map[from][to]<MAX && rem>=map[from][to]+1){
        System.out.println(map[from][to]+1);
      }
      else {
        System.out.println("NA");
      }
    }
  }
  private static void floyd(int[][] map){
    int n=map.length-1 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=n ; j++){
        map[i][j]=map[i][j]==0 ? MAX : map[i][j];
      }
    }
    for(int k=1 ; k<=n ; k++){
      for(int i=1 ; i<=n ; i++){
        for(int j=1 ; j<=n ; j++){
          if(i==j)continue ;
          map[i][j]=Math.min(map[i][j],map[i][k]+map[k][j]);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 1000000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var from : int ; from := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < m do ( (     map[from+1][sc.getCurrent()->toInteger()+1] := 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    execute floyd(map) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     var from : int ; from := sc.getCurrent()->toInteger() ;
     var to : int ; to := sc.getCurrent()->toInteger() ;
     var rem : int ; rem := sc.getCurrent()->toInteger() ;
     if (map[from+1][to+1] < MAX & rem >= map[from+1][to+1] + 1) then (     OclFile["System.out"].println(map[from+1][to+1] + 1) ) else (     OclFile["System.out"].println("NA") ) )  ;     i := i + 1 ) ; 
 );
  static   operation floyd( map : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var n : int ; n := map->size() - 1 ;
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     map[i+1][j+1] := if map[i+1][j+1] = 0 then MAX else map[i+1][j+1] endif )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
         var k : int ; k := 1 ; while k <= n do ( (         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     if (i = j) then     continue else skip ; 
     map[i+1][j+1] := Set{map[i+1][j+1], map[i+1][k+1] + map[k+1][j+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  static short[][] d ;
  static final short INF=Short.MAX_VALUE ;
  public static void main(String[] args){
    PrintWriter out=new PrintWriter(System.out);
    Scanner scan=new Scanner(System.in);
    short n=scan.nextShort();
    d=new short[n][n];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        d[i][j]=i!=j ? INF : 0 ;
      }
    }
    for(int i=0 ; i<n ; i++){
      short id=scan.nextShort();
      short c=scan.nextShort();
      for(int j=0 ; j<c ; j++){
        d[id-1][scan.nextShort()-1]=1 ;
      }
    }
    for(int k=0 ; k<n ; k++){
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          d[i][j]=(short)Math.min(d[i][j],d[i][k]+d[k][j]);
        }
      }
    }
    int p=scan.nextInt();
    for(int i=0 ; i<p ; i++){
      short s=scan.nextShort();
      short g=scan.nextShort();
      short ttl=scan.nextShort();
      out.println(ttl<=d[s-1][g-1] || d[s-1][g-1]==INF ? "NA" : d[s-1][g-1]+1);
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute d : Sequence(Sequence(int));
  static    attribute INF : int := 32767;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := scan.nextShort() ;
    d := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     d[i+1][j+1] := if i /= j then INF else 0 endif )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var id : int ; id := scan.nextShort() ;
     var c : int ; c := scan.nextShort() ;
         var j : int ; j := 0 ; while j < c do ( (     d[id - 1+1][scan.nextShort() - 1+1] := 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < n do ( (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     d[i+1][j+1] := (Set{d[i+1][j+1], d[i+1][k+1] + d[k+1][j+1]}->min() mod 32768) )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    var p : int ; p := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < p do ( (     var s : int ; s := scan.nextShort() ;
     var g : int ; g := scan.nextShort() ;
     var ttl : int ; ttl := scan.nextShort() ;
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  int[][] cost ;
  boolean[] visit ;
  int[] dist ;
  int n ;
  public void run(){
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      n=scan.nextInt();
      cost=new int[n][n];
      for(int i=0 ; i<n ; i++){
        Arrays.fill(cost[i],100000);
      }
      for(int i=0 ; i<n ; i++){
        int r=scan.nextInt()-1 ;
        int k=scan.nextInt();
        for(int j=0 ; j<k ; j++){
          int t=scan.nextInt()-1 ;
          cost[r][t]=1 ;
        }
      }
      int p=scan.nextInt();
      for(int i=0 ; i<p ; i++){
        int s=scan.nextInt()-1 ;
        int d=scan.nextInt()-1 ;
        int v=scan.nextInt();
        visit=new boolean[n];
        dist=new int[n];
        Arrays.fill(dist,1000000);
        dijkstra(s);
        System.out.println((dist[d]+1<=v)? Math.min(dist[d]+1,v): "NA");
      }
    }
  }
  public void dijkstra(int start){
    dist[start]=0 ;
    while(true){
      int min=1000000 ;
      int next=-1 ;
      for(int u=0 ; u<n ; u++){
        if(visit[u]){
          continue ;
        }
        dist[u]=Math.min(dist[u],dist[start]+cost[start][u]);
        if(dist[u]<min){
          min=dist[u];
          next=u ;
        }
      }
      visit[start]=true ;
      start=next ;
      if(start==-1){
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute cost : Sequence(Sequence(int));
   attribute visit : Sequence(boolean);
   attribute dist : Sequence(int);
   attribute n : int;
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     n := scan.getCurrent()->toInteger() ; 
     cost := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
        var i : int ; i := 0 ; while i < n do ( (     cost[i+1] := cost[i+1]->collect(100000) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var r : int ; r := scan.getCurrent()->toInteger() - 1 ;
     var k : int ; k := scan.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < k do ( (     var t : int ; t := scan.getCurrent()->toInteger() - 1 ;
     cost[r+1][t+1] := 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var p : int ; p := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < p do ( (     var s : int ; s := scan.getCurrent()->toInteger() - 1 ;
     var d : int ; d := scan.getCurrent()->toInteger() - 1 ;
    var v : int ; v := scan.getCurrent()->toInteger() ;
    visit := Integer.subrange(1,n)->collect(false) ; 
    dist := Integer.subrange(1,n)->collect(0) ; 
    dist := dist->collect(1000000) ; 
    execute dijkstra(s) ; 
    OclFile["System.out"].println(if (dist[d+1] + 1 <= v) then Set{dist[d+1] + 1, v}->min() else "NA" endif) ; 
 )  ;     i := i + 1 ) ; 
 ) );
   operation dijkstra( start : int) : void
  pre: true
  post: true
  activity: (     dist[start+1] := 0 ; 
     while (true) do (     var min : int ; min := 1000000 ;
     var next : int ; next := -1 ;
        var u : int ; u := 0 ; while u < n do ( (     if (visit[u+1]) then (     continue ) else skip ; 
     dist[u+1] := Set{dist[u+1], dist[start+1] + cost[start+1][u+1]}->min() ; 
     if (dist[u+1] < min) then (     min := dist[u+1] ; 
     next := u ) else skip )  ;     u := u + 1 ) ; 
    visit[start+1] := true ; 
    start := next ; 
    if (start = -1) then (     break ) else skip ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class NewSkateboard {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    char[] s=br.readLine().toCharArray();
    int[] skate=new int[s.length];
    for(int i=0 ; i<s.length ; i++)skate[i]=Character.getNumericValue(s[i]);
    long mod=0 ;
    for(int i=0 ; i<skate.length ; i++)mod+=skate[i] % 4==0 ? 1 : 0 ;
    for(int i=0 ; i<skate.length-1 ; i++)mod+=(skate[i]*10+skate[i+1])% 4==0 ? i+1 : 0 ;
    System.out.println(mod);
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewSkateboard {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : Sequence(String) ; s := br.readLine()->characters() ;
    var skate : Sequence(int) ; skate := Integer.subrange(1,s->size())->collect(0) ;
        var i : int ; i := 0 ; while i < s->size() do (     skate[i+1] := ("" + s[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var mod : long ; mod := 0 ;
        var i : int ; i := 0 ; while i < skate->size() do (     mod := mod+(if skate[i+1] mod 4 = 0 then 1 else 0 endif) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < skate->size() - 1 do (     mod := mod+(if (skate[i+1] * 10 + skate[i + 1+1]) mod 4 = 0 then i + 1 else 0 endif) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(mod) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a=sc.nextLong();
    long b=sc.nextLong();
    long c=sc.nextLong();
    long d=sc.nextLong();
    System.out.println(Math.max(Math.max(Math.max(a*c,b*d),a*d),b*c));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var c : long ; c := sc.getCurrent()->toLong() ;
    var d : long ; d := sc.getCurrent()->toLong() ;
    OclFile["System.out"].println(Set{Set{Set{a * c, b * d}->max(), a * d}->max(), b * c}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    System.out.println(solve(s));
    sc.close();
  }
  static long solve(String s){
    long result=0 ;
    for(int i=0 ; i<s.length(); ++i){
      if((s.charAt(i)-'0')% 4==0){
++result ;
      }
      if(i!=0 && Integer.parseInt(s.substring(i-1,i+1))% 4==0){
        result+=i ;
      }
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
     OclFile["System.out"].println(solve(s)) ; 
     skip );
  static   operation solve( s : String) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if ((s->at(i+1) - ('0')->char2byte()) mod 4 = 0) then (     result := result + 1 ) else skip ; 
     if (i /= 0 & (s.subrange(i - 1+1,i + 1))->toInteger() mod 4 = 0) then (     result := result+(i) ) else skip )  ;     i := i + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int nearest(int n){
    int prevSquare=(int)Math.sqrt(n);
    int nextSquare=prevSquare+1 ;
    prevSquare=prevSquare*prevSquare ;
    nextSquare=nextSquare*nextSquare ;
    int ans=(n-prevSquare)<(nextSquare-n)?(prevSquare-n):(nextSquare-n);
    return ans ;
  }
  public static void main(String[] args){
    int n=14 ;
    System.out.println(nearest(n));
    n=16 ;
    System.out.println(nearest(n));
    n=18 ;
    System.out.println(nearest(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nearest( n : int) : int
  pre: true
  post: true
  activity: (     var prevSquare : int ; prevSquare := (n)->sqrt()->oclAsType(int) ;
     var nextSquare : int ; nextSquare := prevSquare + 1 ;
    prevSquare := prevSquare * prevSquare ; 
    nextSquare := nextSquare * nextSquare ; 
    var ans : int ; ans := if (n - prevSquare) < (nextSquare - n) then (prevSquare - n) else (nextSquare - n) endif ;
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 14 ;
     OclFile["System.out"].println(nearest(n)) ; 
    n := 16 ; 
    OclFile["System.out"].println(nearest(n)) ; 
    n := 18 ; 
    OclFile["System.out"].println(nearest(n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int cases=sc.nextInt();
    for(int i=0 ; i<cases ; i++){
      int n=sc.nextInt();
      sc.nextLine();
      int[] c={
        0,0,0 };
        for(String value : sc.nextLine().split(" ")){
          if(Short.parseShort(value)% 3==0){
            c[0]+=1 ;
          }
          if(Short.parseShort(value)% 3==1){
            c[1]+=1 ;
          }
          if(Short.parseShort(value)% 3==2){
            c[2]+=1 ;
          }
        }
        int equilibrio=n/3 ;
        int times=0 ;
        while(c[0]!=c[1] || c[1]!=c[2] || c[0]!=c[2]){
          int maxIndex=max(c);
          times+=c[maxIndex]-equilibrio ;
          c[(maxIndex+1)% 3]+=c[maxIndex]-equilibrio ;
          c[maxIndex]=equilibrio ;
        }
        System.out.println(times);
      }
    }
    public static int max(int[] values){
      int max=0 ;
      int index=0 ;
      for(int i=0 ; i<3 ; i++){
        if(max<values[i]){
          max=values[i];
          index=i ;
        }
      }
      return index ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cases : int ; cases := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < cases do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     skip ; 
    var c : Sequence(int) ; c := Sequence{0,0,0} ;
    for (value : sc.nextLine()->split(" ")) do ( (     if ((value)->toInteger() mod 3 = 0) then (     c[0+1] := c[0+1]+(1) ) else skip ; 
     if ((value)->toInteger() mod 3 = 1) then (     c[1+1] := c[1+1]+(1) ) else skip ; 
     if ((value)->toInteger() mod 3 = 2) then (     c[2+1] := c[2+1]+(1) ) else skip )  ) ; 
    var equilibrio : int ; equilibrio := n / 3 ;
    var times : int ; times := 0 ;
    while (c[0+1] /= c[1+1] or c[1+1] /= c[2+1] or c[0+1] /= c[2+1]) do (     var maxIndex : int ; maxIndex := max(c) ;
     times := times+(c[maxIndex+1] - equilibrio) ; 
     c[(maxIndex + 1) mod 3+1] := c[(maxIndex + 1) mod 3+1]+(c[maxIndex+1] - equilibrio) ; 
     c[maxIndex+1] := equilibrio ) ; 
    OclFile["System.out"].println(times) ; 
 )  ;     i := i + 1 ) );
  static   operation max( values : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var max : int ; max := 0 ;
     var index : int ; index := 0 ;
         var i : int ; i := 0 ; while i < 3 do ( (     if (max < values[i+1]) then (     max := values[i+1] ; 
     index := i ) else skip )  ;     i := i + 1 ) ; 
     return index );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Codeforces {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int tests=sc.nextInt();
    for(int t=0 ; t<tests ; t++){
      int length=sc.nextInt();
      int a=0,b=0,c=0 ;
      for(int i=0 ; i<length ; i++){
        int val=sc.nextInt();
        if(val % 3==0)a++;
        if(val % 3==1)b++;
        if(val % 3==2)c++;
      }
      int res=0 ;
      int obj=length/3 ;
      while(a<obj){
        if(c>obj){
          c--;
          a++;
          res++;
        }
        else {
          b--;
          a++;
          res+=2 ;
        }
      }
      while(b<obj){
        if(a>obj){
          a--;
          b++;
          res++;
        }
        else {
          c--;
          b++;
          res+=2 ;
        }
      }
      while(c<obj){
        if(b>obj){
          b--;
          c++;
          res++;
        }
        else {
          a--;
          c++;
          res+=2 ;
        }
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tests : int ; tests := sc.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < tests do ( (     var length : int ; length := sc.getCurrent()->toInteger() ;
     var a : int ; a := 0 ;
    var b : int ; b := 0 ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < length do ( (     var val : int ; val := sc.getCurrent()->toInteger() ;
     if (val mod 3 = 0) then     a := a + 1 ; else skip ; 
     if (val mod 3 = 1) then     b := b + 1 ; else skip ; 
     if (val mod 3 = 2) then     c := c + 1 ; else skip )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    var obj : int ; obj := length / 3 ;
    while (a < obj) do (     if (c > obj) then (     c := c - 1 ; 
     a := a + 1 ; 
     res := res + 1 ) else (     b := b - 1 ; 
     a := a + 1 ; 
     res := res+(2) ) ) ; 
    while (b < obj) do (     if (a > obj) then (     a := a - 1 ; 
     b := b + 1 ; 
     res := res + 1 ) else (     c := c - 1 ; 
     b := b + 1 ; 
     res := res+(2) ) ) ; 
    while (c < obj) do (     if (b > obj) then (     b := b - 1 ; 
     c := c + 1 ; 
     res := res + 1 ) else (     a := a - 1 ; 
     c := c + 1 ; 
     res := res+(2) ) ) ; 
    OclFile["System.out"].println(res) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    while(true){
      final int n=sc.nextInt();
      if(n==0){
        break ;
      }
      int[] arr=new int[n];
      long sum=0 ;
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
        sum+=arr[i];
      }
      double sigma=0 ;
      for(int i=0 ; i<n ; i++){
        sigma+=(arr[i]-(sum/(double)(n)))*((arr[i]-(sum/(double)(n))));
      }
      sigma/=(double)(n);
      System.out.printf("%.7f\n",Math.sqrt(sigma));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    var sigma : double ; sigma := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sigma := sigma+((arr[i+1] - (sum / (n)->oclAsType(double))) * ((arr[i+1] - (sum / (n)->oclAsType(double))))) )  ;     i := i + 1 ) ; 
    sigma := sigma/((n)->oclAsType(double)) ; 
    OclFile["System.out"].printf("%.7f\n", (sigma)->sqrt()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  static final Scanner cin=new Scanner(System.in);
  public static void main(String[] args){
    int t=cin.nextInt();
    while(t>0){
      solve();
      t--;
    }
  }
  public static void solve(){
    int size=cin.nextInt();
    int n=size ;
    int[] arr=new int[3];
    for(int i=0 ; i<size ; i++){
      int a=cin.nextInt();
      if(a % 3==0)arr[0]++;
      else if(a % 3==1)arr[1]++;
      else if(a % 3==2)arr[2]++;
    }
    int count=0 ;
    while(arr[0]<n/3){
      if(arr[2]>n/3){
        arr[0]++;
        arr[2]--;
        count+=1 ;
      }
      else {
        arr[0]++;
        arr[1]--;
        count+=2 ;
      }
    }
    while(arr[1]<n/3){
      if(arr[0]>n/3){
        arr[1]++;
        arr[0]--;
        count+=1 ;
      }
      else {
        arr[1]++;
        arr[2]--;
        count+=2 ;
      }
    }
    while(arr[2]<n/3){
      if(arr[1]>n/3){
        arr[2]++;
        arr[1]--;
        count+=1 ;
      }
      else {
        arr[2]++;
        arr[0]--;
        count+=2 ;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute cin : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := cin.getCurrent()->toInteger() ;
     while (t > 0) do (     execute solve() ; 
     t := t - 1 ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var size : int ; size := cin.getCurrent()->toInteger() ;
     var n : int ; n := size ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < size do ( (     var a : int ; a := cin.getCurrent()->toInteger() ;
     if (a mod 3 = 0) then     arr[0+1] := arr[0+1] + 1 ; else     if (a mod 3 = 1) then     arr[1+1] := arr[1+1] + 1 else     if (a mod 3 = 2) then     arr[2+1] := arr[2+1] + 1 ; else skip ; ;  )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    while (arr[0+1] < n / 3) do (     if (arr[2+1] > n / 3) then (     arr[0+1] := arr[0+1] + 1 ; 
     arr[2+1] := arr[2+1] - 1 ; 
     count := count+(1) ) else (     arr[0+1] := arr[0+1] + 1 ; 
     arr[1+1] := arr[1+1] - 1 ; 
     count := count+(2) ) ) ; 
    while (arr[1+1] < n / 3) do (     if (arr[0+1] > n / 3) then (     arr[1+1] := arr[1+1] + 1 ; 
     arr[0+1] := arr[0+1] - 1 ; 
     count := count+(1) ) else (     arr[1+1] := arr[1+1] + 1 ; 
     arr[2+1] := arr[2+1] - 1 ; 
     count := count+(2) ) ) ; 
    while (arr[2+1] < n / 3) do (     if (arr[1+1] > n / 3) then (     arr[2+1] := arr[2+1] + 1 ; 
     arr[1+1] := arr[1+1] - 1 ; 
     count := count+(1) ) else (     arr[2+1] := arr[2+1] + 1 ; 
     arr[0+1] := arr[0+1] - 1 ; 
     count := count+(2) ) ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Remainders {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int Q=Integer.parseInt(br.readLine());
    for(int i=0 ; i<Q ; i++){
      int N=Integer.parseInt(br.readLine());
      int[] arr=new int[N];
      String line=br.readLine();
      StringTokenizer sr=new StringTokenizer(line);
      int[] counts=new int[3];
      for(int j=0 ; j<N ; j++){
        arr[j]=Integer.parseInt(sr.nextToken())% 3 ;
        if(arr[j]==0){
          counts[0]++;
        }
        else if(arr[j]==1){
          counts[1]++;
        }
        else {
          counts[2]++;
        }
      }
      int desired=N/3 ;
      int count=0 ;
      while(counts[0]!=desired || counts[1]!=desired || counts[2]!=desired){
        for(int j=0 ; j<3 ; j++){
          if(counts[j]>desired){
            count+=counts[j]-desired ;
            counts[(j+1)% 3]+=counts[j]-desired ;
            counts[j]=desired ;
          }
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Remainders {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var Q : int ; Q := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < Q do ( (     var N : int ; N := (br.readLine())->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
    var line : String ; line := br.readLine() ;
    var sr : OclIterator ; sr := OclIterator.newOclIterator_String(line) ;
    var counts : Sequence(int) ; counts := Integer.subrange(1,3)->collect(0) ;
        var j : int ; j := 0 ; while j < N do ( (     arr[j+1] := (sr.next())->toInteger() mod 3 ; 
     if (arr[j+1] = 0) then (     counts[0+1] := counts[0+1] + 1 ) else     if (arr[j+1] = 1) then (     counts[1+1] := counts[1+1] + 1 ) else (     counts[2+1] := counts[2+1] + 1 ) ;  )  ;     j := j + 1 ) ; 
    var desired : int ; desired := N / 3 ;
    var count : int ; count := 0 ;
    while (counts[0+1] /= desired or counts[1+1] /= desired or counts[2+1] /= desired) do (         var j : int ; j := 0 ; while j < 3 do ( (     if (counts[j+1] > desired) then (     count := count+(counts[j+1] - desired) ; 
     counts[(j + 1) mod 3+1] := counts[(j + 1) mod 3+1]+(counts[j+1] - desired) ; 
     counts[j+1] := desired ) else skip )  ;     j := j + 1 ) ) ; 
    OclFile["System.out"].println(count) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  static long pow(long a,long b){
    if(b==0){
      return 1 ;
    }
    long ans=0L ;
    if(b % 2==0){
      long val=pow(a,b/2);
      ans+=val*val ;
    }
    else {
      long val=pow(a,b/2);
      ans+=val*val*2 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      int cnt0=0,cnt1=0,cnt2=0 ;
      for(int i=0 ; i<n ; i++){
        if((arr[i] % 3)==0){
          cnt0++;
        }
        else if((arr[i] % 3)==1){
          cnt1++;
        }
        else {
          cnt2++;
        }
      }
      int ans=0 ;
      while((cnt0!=cnt1)||(cnt1!=cnt2)){
        while(cnt0>(n/3)){
          cnt0--;
          cnt1++;
          ans++;
        }
        while(cnt1>(n/3)){
          cnt1--;
          ans++;
          cnt2++;
        }
        while(cnt2>(n/3)){
          ans++;
          cnt0++;
          cnt2--;
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation pow( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return 1 ) else skip ; 
     var ans : long ; ans := 0L ;
     if (b mod 2 = 0) then (     var val : long ; val := pow(a, b / 2) ;
     ans := ans+(val * val) ) else (     var val : long ; val := pow(a, b / 2) ;
     ans := ans+(val * val * 2) ) ;  
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cnt0 : int ; cnt0 := 0 ;
    var cnt1 : int ; cnt1 := 0 ;
    var cnt2 : int ; cnt2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if ((arr[i+1] mod 3) = 0) then (     cnt0 := cnt0 + 1 ) else     if ((arr[i+1] mod 3) = 1) then (     cnt1 := cnt1 + 1 ) else (     cnt2 := cnt2 + 1 ) ;  )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    while ((cnt0 /= cnt1) or (cnt1 /= cnt2)) do (     while (cnt0 > (n / 3)) do (     cnt0 := cnt0 - 1 ; 
     cnt1 := cnt1 + 1 ; 
     ans := ans + 1 ) ; 
     while (cnt1 > (n / 3)) do (     cnt1 := cnt1 - 1 ; 
     ans := ans + 1 ; 
     cnt2 := cnt2 + 1 ) ; 
     while (cnt2 > (n / 3)) do (     ans := ans + 1 ; 
     cnt0 := cnt0 + 1 ; 
     cnt2 := cnt2 - 1 ) ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printPattern(int n){
    int var1,var=1 ;
    for(int i=1 ; i<=n ; i++){
      if(i % 2!=0){
        var=var+i-1 ;
        for(int j=1 ; j<=i ; j++){
          if(j==1){
            System.out.print(var);
          }
          else System.out.print("*"+var);
          var++;
        }
      }
      else {
        var1=var+i-1 ;
        for(int j=1 ; j<=i ; j++){
          if(j==1){
            System.out.print(var1);
          }
          else {
            System.out.print("*"+var1);
          }
          var1--;
        }
      }
      System.out.print("\n");
    }
  }
  public static void main(String[] arg){
    int n=5 ;
    printPattern(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printPattern( n : int) : void
  pre: true
  post: true
  activity: (     var var1 : int ;
    var var : int ; var := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (     if (i mod 2 /= 0) then (     var := var + i - 1 ; 
         var j : int ; j := 1 ; while j <= i do ( (     if (j = 1) then (     OclFile["System.out"].print(var) ) else     OclFile["System.out"].print("*" + var) ; ;  
     var := var + 1 )  ;     j := j + 1 ) ) else (     var1 := var + i - 1 ; 
         var j : int ; j := 1 ; while j <= i do ( (     if (j = 1) then (     OclFile["System.out"].print(var1) ) else (     OclFile["System.out"].print("*" + var1) ) ;  
     var1 := var1 - 1 )  ;     j := j + 1 ) ) ;  
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute printPattern(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printPattern(int n){
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=i ; j++)System.out.print(i);
      System.out.print("\n");
    }
    for(int i=n-1 ; i>0 ; i--){
      for(int j=i ; j>0 ; j--)System.out.print(i);
      System.out.print("\n");
    }
  }
  public static void main(String arg[]){
    int n=8 ;
    printPattern(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printPattern( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= i do (     OclFile["System.out"].print(i) ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) ; 
         var i : int ; i := n - 1 ; while i > 0 do ( (         var j : int ; j := i ; while j > 0 do (     OclFile["System.out"].print(i) ;  ;     j := j - 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     i := i - 1 ) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     execute printPattern(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p329 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p329().run());
  }
  private static final int START_NUM=1 ;
  private static final int END_NUM=500 ;
  private static final String CROAK_SEQ="PPPPNNPPPNPPNPN" ;
  static {
    assert 0<=START_NUM && START_NUM<END_NUM && END_NUM<Integer.MAX_VALUE ;
    assert 1<=CROAK_SEQ.length()&& CROAK_SEQ.length()<=31 ;
  }
  private static final int NUM_JUMPS=CROAK_SEQ.length()-1 ;
  private static final int NUM_TRIALS=1<<NUM_JUMPS ;
  public String run(){
    long globalNumerator=0 ;
    boolean[] isPrime=Library.listPrimality(END_NUM);
    for(int i=START_NUM ; i<=END_NUM ; i++){
      for(int j=0 ; j<NUM_TRIALS ; j++){
        int pos=i ;
        int trialNumerator=1 ;
        if(isPrime[pos]==(CROAK_SEQ.charAt(0)=='P'))trialNumerator*=2 ;
        for(int k=0 ; k<NUM_JUMPS ; k++){
          if(pos<=START_NUM)pos++;
          else if(pos>=END_NUM)pos--;
          else if(((j>>>k)& 1)==0)pos++;
          else pos--;
          if(isPrime[pos]==(CROAK_SEQ.charAt(k+1)=='P'))trialNumerator*=2 ;
        }
        globalNumerator+=trialNumerator ;
      }
    }
    BigInteger globalDenominator=BigInteger.valueOf(END_NUM+1L-START_NUM).shiftLeft(NUM_JUMPS).multiply(BigInteger.valueOf(3).pow(CROAK_SEQ.length()));
    return new Fraction(BigInteger.valueOf(globalNumerator),globalDenominator).toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class p329 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p329.newp329().run()) );
  static    attribute START_NUM : int := 1;
  static    attribute END_NUM : int := 500;
  static    attribute CROAK_SEQ : String := "PPPPNNPPPNPPNPN";
  static operation initialiseClass()
  pre: true post: true
  activity:     assert 0 <= START_NUM & START_NUM < END_NUM & END_NUM < 2147483647 ; 
    assert 1 <= CROAK_SEQ->size() & CROAK_SEQ->size() <= 31 ; 
;
  static    attribute NUM_JUMPS : int := CROAK_SEQ->size() - 1;
  static    attribute NUM_TRIALS : int := (1*(2->pow(NUM_JUMPS)))->oclAsType(long);
   operation run() : String
  pre: true
  post: true
  activity: (     var globalNumerator : long ; globalNumerator := 0 ;
     var isPrime : Sequence(boolean) ; isPrime := Library.listPrimality(END_NUM) ;
        var i : int ; i := START_NUM ; while i <= END_NUM do ( (         var j : int ; j := 0 ; while j < NUM_TRIALS do ( (     var pos : int ; pos := i ;
     var trialNumerator : int ; trialNumerator := 1 ;
    if (isPrime[pos+1] = (CROAK_SEQ->at(0+1) = 'P')) then     trialNumerator := trialNumerator*(2) ; else skip ; 
        var k : int ; k := 0 ; while k < NUM_JUMPS do ( (     if (pos <= START_NUM) then     pos := pos + 1 else     if (pos >= END_NUM) then     pos := pos - 1 else     if ((((j/(2->pow(k)))->oclAsType(long)) & 1) = 0) then     pos := pos + 1 else     pos := pos - 1 ; ;  ;  ;  
     if (isPrime[pos+1] = (CROAK_SEQ->at(k + 1+1) = 'P')) then     trialNumerator := trialNumerator*(2) ; else skip )  ;     k := k + 1 ) ; 
    globalNumerator := globalNumerator+(trialNumerator) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var globalDenominator : long ; globalDenominator := (END_NUM + 1L - START_NUM + "")->toLong().shiftLeft(NUM_JUMPS).multiply((3 + "")->toLong().pow(CROAK_SEQ->size())) ;
    return Fraction.newFraction((globalNumerator + "")->toLong(), globalDenominator)+"" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPossible(int x,int y){
    if((x-y)==1)return false ;
    return true ;
  }
  public static void main(String[] args){
    int x=100,y=98 ;
    if(isPossible(x,y))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPossible( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     if ((x - y) = 1) then     return false else skip ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 100 ;
    var y : int ; y := 98 ;
     if (isPossible(x, y)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countSolutions(int n){
    int res=0 ;
    for(int x=0 ; x*x<n ; x++)for(int y=0 ; x*x+y*y<n ; y++)res++;
    return res ;
  }
  public static void main(String args[]){
    System.out.println("Total Number of distinct Non-Negative pairs is "+countSolutions(6));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSolutions( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var x : int ; x := 0 ; while x * x < n do (         var y : int ; y := 0 ; while x * x + y * y < n do (     res := res + 1 ;  ;     y := y + 1 ) ;  ;     x := x + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Total Number of distinct Non-Negative pairs is " + countSolutions(6)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countOccurrences(String s,int K){
    int n=s.length();
    int C=0,c1=0,c2=0 ;
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='a')c1++;
      if(s.charAt(i)=='b'){
        c2++;
        C+=c1 ;
      }
    }
    return C*K+(K*(K-1)/2)*c1*c2 ;
  }
  public static void main(String[] args){
    String S="abcb" ;
    int k=2 ;
    System.out.println(countOccurrences(S,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countOccurrences( s : String, K : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var C : int ; C := 0 ;
    var c1 : int ; c1 := 0 ;
    var c2 : int ; c2 := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = 'a') then     c1 := c1 + 1 ; else skip ; 
     if (s->at(i+1) = 'b') then (     c2 := c2 + 1 ; 
     C := C+(c1) ) else skip )  ;     i := i + 1 ) ; 
     return C * K + (K * (K - 1) / 2) * c1 * c2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := "abcb" ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(countOccurrences(S, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Improve {
  static void pattern(int nos,int i,int space){
    char prt='$' ;
    int s,j ;
    for(s=nos ; s>=1 ; s--){
      System.out.print("  ");
    }
    for(j=1 ; j<=i ; j++){
      if(space!=0){
        if(i==9 && j==1){
          continue ;
        }
      }
      if(i==1 || i==9){
        System.out.print(prt+"");
      }
      else if(j==1 || j==i){
        System.out.print(prt+"");
      }
      else {
        System.out.print("  ");
      }
    }
  }
  public static void main(String args[]){
    int i,nos=0,nosp=-1,nbsp=-1 ;
    for(i=9 ; i>=1 ; i-=2){
      pattern(nos,i,0);
      pattern(nosp,i,1);
      pattern(nbsp,i,1);
      System.out.println();
      nos++;
      nosp=nosp+2 ;
      nbsp=nbsp+2 ;
    }
    nos=3 ;
    nosp=5 ;
    nbsp=5 ;
    for(i=3 ; i<=9 ; i+=2){
      pattern(nos,i,0);
      pattern(nosp,i,1);
      pattern(nbsp,i,1);
      System.out.println();
      nos--;
      nosp=nosp-2 ;
      nbsp=nbsp-2 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class Improve {
  static   operation pattern( nos : int, i : int, space : int) : void
  pre: true
  post: true
  activity: (     var prt : String ; prt := '$' ;
     var s : int ;
    var j : int ;
         s := nos ; while s >= 1 do ( (     OclFile["System.out"].print("  ") )  ;     s := s - 1 ) ; 
         j := 1 ; while j <= i do ( (     if (space /= 0) then (     if (i = 9 & j = 1) then (     continue ) else skip ) else skip ; 
     if (i = 1 or i = 9) then (     OclFile["System.out"].print(prt + "") ) else     if (j = 1 or j = i) then (     OclFile["System.out"].print(prt + "") ) else (     OclFile["System.out"].print("  ") ) ;  )  ;     j := j + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var nos : int ; nos := 0 ;
    var nosp : int ; nosp := -1 ;
    var nbsp : int ; nbsp := -1 ;
         i := 9 ; while i >= 1 do ( (     execute pattern(nos, i, 0) ; 
     execute pattern(nosp, i, 1) ; 
    execute pattern(nbsp, i, 1) ; 
    OclFile["System.out"].println() ; 
    nos := nos + 1 ; 
    nosp := nosp + 2 ; 
    nbsp := nbsp + 2 ; 
 )  ;     i := i-(2) ) ; 
    nos := 3 ; 
    nosp := 5 ; 
    nbsp := 5 ; 
        i := 3 ; while i <= 9 do ( (     execute pattern(nos, i, 0) ; 
     execute pattern(nosp, i, 1) ; 
    execute pattern(nbsp, i, 1) ; 
    OclFile["System.out"].println() ; 
    nos := nos - 1 ; 
    nosp := nosp - 2 ; 
    nbsp := nbsp - 2 ; 
 )  ;     i := i+(2) ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.PrintWriter ;
public class ETIntelligence {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new FileReader("input.txt"));
    PrintWriter pr=new PrintWriter("output.txt");
    int amountOfNumbers=Integer.parseInt(br.readLine());
    String[] numbersString=br.readLine().split("");
    int[] numbers=new int[amountOfNumbers];
    int howManyOnes=0 ;
    boolean works=true ;
    for(int i=0 ; i<amountOfNumbers ; i++){
      numbers[i]=Integer.parseInt(numbersString[i]);
      if(numbers[i]==1){
        howManyOnes++;
      }
    }
    int gap=0 ;
    int savePosition=0 ;
    int currentOnes=0 ;
    for(int i=0 ; i<amountOfNumbers ; i++){
      if(numbers[i]==1){
        savePosition=i+1 ;
        currentOnes++;
        for(int j=savePosition ; j<amountOfNumbers ; j++){
          if(numbers[j]==0){
            gap++;
          }
          else {
            savePosition=j+1 ;
            currentOnes++;
            break ;
          }
        }
        break ;
      }
    }
    boolean emergencyLeave=false ;
    for(int i=savePosition ; i<amountOfNumbers ; i++){
      for(int j=0 ; j<gap ; j++){
        i++;
        if(i>=amountOfNumbers){
          emergencyLeave=true ;
        }
      }
      if(emergencyLeave){
        break ;
      }
      if(currentOnes==howManyOnes){
        break ;
      }
      else if(numbers[i]!=1){
        works=false ;
        break ;
      }
      else {
        currentOnes++;
      }
    }
    if(currentOnes==howManyOnes && works==true){
      pr.println("YES");
    }
    else {
      pr.println("NO");
    }
    pr.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ETIntelligence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
    var amountOfNumbers : int ; amountOfNumbers := (br.readLine())->toInteger() ;
    var numbersString : Sequence(String) ; numbersString := br.readLine()->split("") ;
    var numbers : Sequence(int) ; numbers := Integer.subrange(1,amountOfNumbers)->collect(0) ;
    var howManyOnes : int ; howManyOnes := 0 ;
    var works : boolean ; works := true ;
        var i : int ; i := 0 ; while i < amountOfNumbers do ( (     numbers[i+1] := (numbersString[i+1])->toInteger() ; 
     if (numbers[i+1] = 1) then (     howManyOnes := howManyOnes + 1 ) else skip )  ;     i := i + 1 ) ; 
    var gap : int ; gap := 0 ;
    var savePosition : int ; savePosition := 0 ;
    var currentOnes : int ; currentOnes := 0 ;
        var i : int ; i := 0 ; while i < amountOfNumbers do ( (     if (numbers[i+1] = 1) then (     savePosition := i + 1 ; 
     currentOnes := currentOnes + 1 ; 
         var j : int ; j := savePosition ; while j < amountOfNumbers do ( (     if (numbers[j+1] = 0) then (     gap := gap + 1 ) else (     savePosition := j + 1 ; 
     currentOnes := currentOnes + 1 ; 
     break ) )  ;     j := j + 1 ) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var emergencyLeave : boolean ; emergencyLeave := false ;
        var i : int ; i := savePosition ; while i < amountOfNumbers do ( (         var j : int ; j := 0 ; while j < gap do ( (     i := i + 1 ; 
     if (i >= amountOfNumbers) then (     emergencyLeave := true ) else skip )  ;     j := j + 1 ) ; 
     if (emergencyLeave) then (     break ) else skip ; 
     if (currentOnes = howManyOnes) then (     break ) else     if (numbers[i+1] /= 1) then (     works := false ; 
     break ) else (     currentOnes := currentOnes + 1 ) ;  )  ;     i := i + 1 ) ; 
    if (currentOnes = howManyOnes & works = true) then (     skip ) else (     skip ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int firstNonRepeating(int arr[],int n){
    Map<Integer,Integer>m=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(m.containsKey(arr[i])){
        m.put(arr[i],m.get(arr[i])+1);
      }
      else {
        m.put(arr[i],1);
      }
    }
    for(int i=0 ; i<n ; i++)if(m.get(arr[i])==1)return arr[i];
    return-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      9,4,9,6,7,4 };
      int n=arr.length ;
      System.out.println(firstNonRepeating(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation firstNonRepeating( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var m : Map(int,int) ; m := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (m->keys()->includes(arr[i+1])) then (     m := m->union(Map{arr[i+1] |-> m->at(arr[i+1]) + 1}) ) else (     m := m->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do (     if (m->at(arr[i+1]) = 1) then     return arr[i+1] else skip ;  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{9,4,9,6,7,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(firstNonRepeating(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Gfg {
  static int vowel_calc(String s){
    int n=s.length();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      if(i==0)arr[i]=n ;
      else arr[i]=(n-i)+arr[i-1]-i ;
    }
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      char ch=s.charAt(i);
      if(ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u')sum+=arr[i];
    }
    return sum ;
  }
  public static void main(String args[]){
    String s="daceh" ;
    System.out.println(vowel_calc(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Gfg {
  static   operation vowel_calc( s : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     if (i = 0) then     arr[i+1] := n ; else     arr[i+1] := (n - i) + arr[i - 1+1] - i ; )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var ch : String ; ch := s->at(i+1) ;
     if (ch = 'a' or ch = 'e' or ch = 'i' or ch = 'o' or ch = 'u') then     sum := sum+(arr[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "daceh" ;
     OclFile["System.out"].println(vowel_calc(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
import java.io.*;
public class codeforces {
  public static void main(String args[])throws IOException {
    File obj1=new File("input.txt");
    Scanner sc=new Scanner(obj1);
    FileWriter fw=new FileWriter("output.txt");
    int n=sc.nextInt();
    String s=sc.next();
    int i ;
    ArrayList<Integer>a=new ArrayList<>();
    for(i=0 ; i<n ; i++){
      char ch=s.charAt(i);
      if(ch=='1'){
        a.add(i);
      }
    }
    int m=a.get(1)-a.get(0);
    int c=0 ;
    for(i=1 ; i<a.size()-1 ; i++){
      if(a.get(i+1)-a.get(i)==m){
      }
      else {
        c=1 ;
        break ;
      }
    }
    String st="" ;
    if(c==0)st="YES" ;
    else st="NO" ;
    fw.write(st+"\n");
    fw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj1 : OclFile ; obj1 := OclFile("input.txt") ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(obj1) ;
    var fw : OclFile ; fw := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var i : int ;
    var a : Sequence(int) ; a := Sequence{} ;
        i := 0 ; while i < n do ( (     var ch : String ; ch := s->at(i+1) ;
     if (ch = '1') then (     a := a->including(i) ) else skip )  ;     i := i + 1 ) ; 
    var m : int ; m := a->at(1+1) - a->at(0+1) ;
    var c : int ; c := 0 ;
        i := 1 ; while i < a->size() - 1 do ( (     if (a->at(i + 1+1) - a->at(i+1) = m) then skip else (     c := 1 ; 
     break ) )  ;     i := i + 1 ) ; 
    var st : String ; st := "" ;
    if (c = 0) then     st := "YES" else     st := "NO" ; ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
import java.io.*;
public class codeforces {
  public static void main(String args[])throws IOException {
    File obj1=new File("input.txt");
    Scanner sc=new Scanner(obj1);
    File obj2=new File("output.txt");
    FileWriter fw=new FileWriter(obj2);
    int n=sc.nextInt();
    String s=sc.next();
    int i ;
    ArrayList<Integer>a=new ArrayList<>();
    for(i=0 ; i<n ; i++){
      char ch=s.charAt(i);
      if(ch=='1'){
        a.add(i);
      }
    }
    int m=a.get(1)-a.get(0);
    int c=0 ;
    for(i=1 ; i<a.size()-1 ; i++){
      if(a.get(i+1)-a.get(i)==m){
      }
      else {
        c=1 ;
        break ;
      }
    }
    String st="" ;
    if(c==0)st="YES" ;
    else st="NO" ;
    fw.write(st+"\n");
    fw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj1 : OclFile ; obj1 := OclFile("input.txt") ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(obj1) ;
    var obj2 : OclFile ; obj2 := OclFile("output.txt") ;
    var fw : OclFile ; fw := OclFile.newOclFile_Write(obj2) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var i : int ;
    var a : Sequence(int) ; a := Sequence{} ;
        i := 0 ; while i < n do ( (     var ch : String ; ch := s->at(i+1) ;
     if (ch = '1') then (     a := a->including(i) ) else skip )  ;     i := i + 1 ) ; 
    var m : int ; m := a->at(1+1) - a->at(0+1) ;
    var c : int ; c := 0 ;
        i := 1 ; while i < a->size() - 1 do ( (     if (a->at(i + 1+1) - a->at(i+1) = m) then skip else (     c := 1 ; 
     break ) )  ;     i := i + 1 ) ; 
    var st : String ; st := "" ;
    if (c = 0) then     st := "YES" else     st := "NO" ; ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
import java.io.*;
import java.io.File ;
public class codeforces {
  public static void main(String args[])throws IOException {
    File obj1=new File("input.txt");
    Scanner sc=new Scanner(obj1);
    FileWriter fw=new FileWriter("output.txt");
    int n=sc.nextInt();
    String s=sc.next();
    int i ;
    ArrayList<Integer>a=new ArrayList<>();
    for(i=0 ; i<n ; i++){
      char ch=s.charAt(i);
      if(ch=='1'){
        a.add(i);
      }
    }
    int m=a.get(1)-a.get(0);
    int c=0 ;
    for(i=1 ; i<a.size()-1 ; i++){
      if(a.get(i+1)-a.get(i)==m){
      }
      else {
        c=1 ;
        break ;
      }
    }
    String st="" ;
    if(c==0)st="YES" ;
    else st="NO" ;
    fw.write(st+"\n");
    fw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj1 : OclFile ; obj1 := OclFile("input.txt") ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(obj1) ;
    var fw : OclFile ; fw := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var i : int ;
    var a : Sequence(int) ; a := Sequence{} ;
        i := 0 ; while i < n do ( (     var ch : String ; ch := s->at(i+1) ;
     if (ch = '1') then (     a := a->including(i) ) else skip )  ;     i := i + 1 ) ; 
    var m : int ; m := a->at(1+1) - a->at(0+1) ;
    var c : int ; c := 0 ;
        i := 1 ; while i < a->size() - 1 do ( (     if (a->at(i + 1+1) - a->at(i+1) = m) then skip else (     c := 1 ; 
     break ) )  ;     i := i + 1 ) ; 
    var st : String ; st := "" ;
    if (c = 0) then     st := "YES" else     st := "NO" ; ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static double distance(double lat1,double lat2,double lon1,double lon2){
    lon1=Math.toRadians(lon1);
    lon2=Math.toRadians(lon2);
    lat1=Math.toRadians(lat1);
    lat2=Math.toRadians(lat2);
    double dlon=lon2-lon1 ;
    double dlat=lat2-lat1 ;
    double a=Math.pow(Math.sin(dlat/2),2)+Math.cos(lat1)*Math.cos(lat2)*Math.pow(Math.sin(dlon/2),2);
    double c=2*Math.asin(Math.sqrt(a));
    double r=6371 ;
    return(c*r);
  }
  public static void main(String[] args){
    double lat1=53.32055555555556 ;
    double lat2=53.31861111111111 ;
    double lon1=-1.7297222222222221 ;
    double lon2=-1.6997222222222223 ;
    System.out.println(distance(lat1,lat2,lon1,lon2)+" K.M");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation distance( lat1 : double, lat2 : double, lon1 : double, lon2 : double) : double
  pre: true
  post: true
  activity: (     lon1 := (0.017453292519943295*(lon1)) ; 
     lon2 := (0.017453292519943295*(lon2)) ; 
    lat1 := (0.017453292519943295*(lat1)) ; 
    lat2 := (0.017453292519943295*(lat2)) ; 
    var dlon : double ; dlon := lon2 - lon1 ;
    var dlat : double ; dlat := lat2 - lat1 ;
    var a : double ; a := (dlat / 2)->sin()->pow(2) + (lat1)->cos() * (lat2)->cos() * (dlon / 2)->sin()->pow(2) ;
    var c : double ; c := 2 * ((a)->sqrt())->asin() ;
    var r : double ; r := 6371 ;
    return (c * r) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var lat1 : double ; lat1 := 53.32055555555556 ;
     var lat2 : double ; lat2 := 53.31861111111111 ;
    var lon1 : double ; lon1 := -1.7297222222222221 ;
    var lon2 : double ; lon2 := -1.6997222222222223 ;
    OclFile["System.out"].println(distance(lat1, lat2, lon1, lon2) + " K.M") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Demo {
  public static void main(String[] args)throws IOException {
    PrintWriter writer=new PrintWriter("output.txt");
    File file=new File("input.txt");
    Scanner sc=new Scanner(file);
    int n=sc.nextInt();
    String s=sc.next();
    int p=0 ;
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='1'){
        a[p++]=i ;
      }
    }
    int x=a[1]-a[0];
    for(int i=2 ; i<p ; i++){
      if((a[i]-a[i-1])!=x){
        writer.println("NO");
        writer.close();
      }
    }
    writer.println("YES");
    writer.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Demo {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
     var file : OclFile ; file := OclFile("input.txt") ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(file) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var p : int ; p := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = '1') then (      a[p+1] := i  ; p := p + 1 ) else skip )  ;     i := i + 1 ) ; 
    var x : int ; x := a[1+1] - a[0+1] ;
        var i : int ; i := 2 ; while i < p do ( (     if ((a[i+1] - a[i - 1+1]) /= x) then (     skip ; 
     skip ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static long split(long n,long k){
    long sum=0 ;
    while(n>0){
      sum+=n % k ;
      n/=k ;
    }
    return sum ;
  }
  private static long solve(long n,long s){
    long k ;
    for(k=2 ; k*k<=n || k<100 ; k++){
      if(split(n,k)==s){
        return k ;
      }
    }
    while(k<=n){
      long a=n/k ;
      long b=n % k ;
      if((a+b-s)% a==0){
        long dk=(a+b-s)/a ;
        if(dk>=0 && b-dk*a>=0){
          return k+dk ;
        }
      }
      k=n/a+1 ;
    }
    if(n==s){
      return n+1 ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    long nl=s.nextLong();
    long sl=s.nextLong();
    System.out.println(solve(nl,sl));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation split( n : long, k : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     while (n > 0) do (     sum := sum+(n mod k) ; 
     n := n/(k) ) ; 
     return sum );
  static   operation solve( n : long, s : long) : long
  pre: true
  post: true
  activity: (     var k : long ;
         k := 2 ; while k * k <= n or k < 100 do ( (     if (split(n, k) = s) then (     return k ) else skip )  ;     k := k + 1 ) ; 
    while (k <= n) do (     var a : long ; a := n / k ;
     var b : long ; b := n mod k ;
     if ((a + b - s) mod a = 0) then (     var dk : long ; dk := (a + b - s) / a ;
     if (dk >= 0 & b - dk * a >= 0) then (     return k + dk ) else skip ) else skip ; 
     k := n / a + 1 ) ; 
    if (n = s) then (     return n + 1 ) else skip ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var nl : long ; nl := s.getCurrent()->toLong() ;
     var sl : long ; sl := s.getCurrent()->toLong() ;
     OclFile["System.out"].println(solve(nl, sl)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileNotFoundException ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    new Main().run();
  }
  public void run()throws FileNotFoundException {
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long s=sc.nextLong();
    long sqrt=(long)(Math.sqrt(n));
    for(int b=2 ; b<=sqrt ; ++b){
      if(f(n,b)==s){
        System.out.println(b);
        return ;
      }
    }
    if(n-s==0){
      System.out.println(n+1);
      return ;
    }
    ArrayList<Long>div=new ArrayList<>();
    for(long i=1 ; i*i<=n-s ; ++i){
      if((n-s)% i==0){
        div.add(i);
        div.add((n-s)/i);
      }
    }
    Collections.sort(div);
    for(long v : div){
      if(f(n,v+1)==s){
        System.out.println(v+1);
        return ;
      }
    }
    System.out.println(-1);
  }
  long f(long n,long b){
    long ret=0 ;
    while(n>0){
      ret+=n % b ;
      n/=b ;
    }
    return ret ;
  }
  void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var s : long ; s := sc.getCurrent()->toLong() ;
    var sqrt : long ; sqrt := ((n)->sqrt())->oclAsType(long) ;
        var b : int ; b := 2 ; while b <= sqrt do ( (     if (f(n, b) = s) then (     OclFile["System.out"].println(b) ; 
     return ) else skip )  ;     b := b + 1 ) ; 
    if (n - s = 0) then (     OclFile["System.out"].println(n + 1) ; 
     return ) else skip ; 
    var div : Sequence(long) ; div := Sequence{} ;
        var i : long ; i := 1 ; while i * i <= n - s do ( (     if ((n - s) mod i = 0) then (     div := div->including(i) ; 
     div := div->including((n - s) / i) ) else skip )  ;     i := i + 1 ) ; 
    div := div->sort() ; 
    for (v : div) do ( (     if (f(n, v + 1) = s) then (     OclFile["System.out"].println(v + 1) ; 
     return ) else skip )  ) ; 
    OclFile["System.out"].println(-1) ; 
 );
   operation f( n : long, b : long) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := 0 ;
     while (n > 0) do (     ret := ret+(n mod b) ; 
     n := n/(b) ) ; 
     return ret );
   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public void main(Scanner sc){
    long n=sc.nextLong();
    long s=sc.nextLong();
    if(n==s){
      System.out.println(n+1);
      return ;
    }
    if((n+1)/2<s){
      System.out.println(-1);
      return ;
    }
    for(long b=2 ; b*b<=n ; b++){
      if(f(n,b)==s){
        System.out.println(b);
        return ;
      }
    }
    long min=Long.MAX_VALUE ;
    for(long p=1 ; p*p<=n ; p++){
      long b=(n-s)/p+1 ;
      if(f(n,b)==s){
        min=Math.min(min,b);
      }
    }
    System.out.println(min);
  }
  private long f(long n,long b){
    if(n<b){
      return n ;
    }
    else {
      return f(n/b,b)+n % b ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    new Main().main(sc);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.nextLong() ;
     var s : long ; s := sc.nextLong() ;
    if (n = s) then (     OclFile["System.out"].println(n + 1) ; 
     return ) else skip ; 
    if ((n + 1) / 2 < s) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
        var b : long ; b := 2 ; while b * b <= n do ( (     if (f(n, b) = s) then (     OclFile["System.out"].println(b) ; 
     return ) else skip )  ;     b := b + 1 ) ; 
    var min : long ; min := "9223372036854775807"->toLong() ;
        var p : long ; p := 1 ; while p * p <= n do ( (     var b : long ; b := (n - s) / p + 1 ;
     if (f(n, b) = s) then (     min := Set{min, b}->min() ) else skip )  ;     p := p + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
   operation f( n : long, b : long) : long
  pre: true
  post: true
  activity: (     if (n < b) then (     return n ) else (     return f(n / b, b) + n mod b ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Main.newMain().main(sc) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long s=sc.nextLong();
    System.out.println(ans(n,s));
  }
  static long ans(long n,long s){
    if(n<s){
      return-1 ;
    }
    else if(n==s){
      return n+1 ;
    }
    else {
      List<Long>divisor=new ArrayList<Long>();
      for(long i=1 ; i<=Math.sqrt(n-s); i++){
        if(digitSum(n,i+1)==s){
          return i+1 ;
        }
        if((n-s)% i==0){
          divisor.add(i);
        }
      }
      Collections.reverse(divisor);
      for(Long l : divisor){
        if(digitSum(n,(n-s)/l+1)==s){
          return(n-s)/l+1 ;
        }
      }
      return-1 ;
    }
  }
  static long digitSum(long n,long b){
    if(n<b){
      return n ;
    }
    else {
      return(n % b+digitSum(n/b,b));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
     var s : long ; s := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println(ans(n, s)) );
  static   operation ans( n : long, s : long) : long
  pre: true
  post: true
  activity: (     if (n < s) then (     return -1 ) else     if (n = s) then (     return n + 1 ) else (     var divisor : Sequence(long) ; divisor := Sequence{} ;
         var i : long ; i := 1 ; while i <= (n - s)->sqrt() do ( (     if (digitSum(n, i + 1) = s) then (     return i + 1 ) else skip ; 
     if ((n - s) mod i = 0) then (     divisor := divisor->including(i) ) else skip )  ;     i := i + 1 ) ; 
    divisor := divisor->reverse() ; 
    for (l : divisor) do ( (     if (digitSum(n, (n - s) / l + 1) = s) then (     return (n - s) / l + 1 ) else skip )  ) ; 
    return -1 
 ) ;  );
  static   operation digitSum( n : long, b : long) : long
  pre: true
  post: true
  activity: (     if (n < b) then (     return n ) else (     return (n mod b + digitSum(n / b, b)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long s=sc.nextLong();
    long ans=(long)Math.pow(10,12);
    if(n==s){
      ans=n+1 ;
    }
    else {
      for(long b=2 ; (b*b)<=n ; b++){
        long t=n ;
        long c=0 ;
        while(t>0){
          c+=(t % b);
          t/=b ;
        }
        if(c==s){
          ans=Math.min(ans,b);
          break ;
        }
      }
      for(long p=1 ; (p*p)<=n ; p++){
        long q=s-p ;
        if((q>=0)&&(n>q)&&(((n-q)% p)==0)){
          long b=(n-q)/p ;
          if((b>p)&&(b>q)){
            long t=n ;
            long c=0 ;
            while(t>0){
              c+=(t % b);
              t/=b ;
            }
            if(c==s)ans=Math.min(ans,b);
          }
        }
      }
      if(s==1)ans=Math.min(ans,n);
      if(ans==(long)Math.pow(10,12))ans=-1 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var s : long ; s := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 10->pow(12)->oclAsType(long) ;
    if (n = s) then (     ans := n + 1 ) else (         var b : long ; b := 2 ; while (b * b) <= n do ( (     var t : long ; t := n ;
     var c : long ; c := 0 ;
     while (t > 0) do (     c := c+((t mod b)) ; 
     t := t/(b) ) ; 
     if (c = s) then (     ans := Set{ans, b}->min() ; 
     break ) else skip )  ;     b := b + 1 ) ; 
         var p : long ; p := 1 ; while (p * p) <= n do ( (     var q : long ; q := s - p ;
     if ((q >= 0) & (n > q) & (((n - q) mod p) = 0)) then (     var b : long ; b := (n - q) / p ;
     if ((b > p) & (b > q)) then (     var t : long ; t := n ;
     var c : long ; c := 0 ;
     while (t > 0) do (     c := c+((t mod b)) ; 
     t := t/(b) ) ; 
     if (c = s) then     ans := Set{ans, b}->min() ; else skip ) else skip ) else skip )  ;     p := p + 1 ) ; 
     if (s = 1) then     ans := Set{ans, n}->min() ; else skip ; 
     if (ans = 10->pow(12)->oclAsType(long)) then     ans := -1 ; else skip ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int len=sc.next().length();
    long MOD=1000000007 ;
    long[][] dp=new long[N+1][N+1];
    dp[0][0]=1 ;
    for(int i=1 ; i<=N ; i++){
      dp[i][0]=dp[i-1][0];
      if(i>=2)dp[i][0]+=dp[i-1][1];
      dp[i][0] %=MOD ;
      for(int j=1 ; j<=N ; j++){
        dp[i][j]=dp[i-1][j-1]*2 ;
        if(j+2<=i)dp[i][j]+=dp[i-1][j+1];
        while(dp[i][j]>=MOD)dp[i][j]-=MOD ;
      }
    }
    long ans=dp[N][len];
    for(int i=0 ; i<len ; ++i){
      ans=(ans*500000004)% MOD ;
    }
    System.out.println(ans);
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var len : int ; len := sc.getCurrent()->size() ;
    var MOD : long ; MOD := 1000000007 ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= N do ( (     dp[i+1][0+1] := dp[i - 1+1][0+1] ; 
     if (i >= 2) then     dp[i+1][0+1] := dp[i+1][0+1]+(dp[i - 1+1][1+1]) ; else skip ; 
     dp[i+1][0+1] := dp[i+1][0+1] mod MOD ; 
         var j : int ; j := 1 ; while j <= N do ( (     dp[i+1][j+1] := dp[i - 1+1][j - 1+1] * 2 ; 
     if (j + 2 <= i) then     dp[i+1][j+1] := dp[i+1][j+1]+(dp[i - 1+1][j + 1+1]) ; else skip ; 
     while (dp[i+1][j+1] >= MOD) do     dp[i+1][j+1] := dp[i+1][j+1]-(MOD) ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := dp[N+1][len+1] ;
        var i : int ; i := 0 ; while i < len do ( (     ans := (ans * 500000004) mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class diagonalWalking {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    long coords[][]=new long[q][2];
    long steps[]=new long[q];
    for(int i=0 ; i<q ; i++){
      coords[i][0]=Math.abs(sc.nextLong());
      coords[i][1]=Math.abs(sc.nextLong());
      steps[i]=sc.nextLong();
    }
    for(int i=0 ; i<q ; i++){
      long min=Math.min(coords[i][0],coords[i][1]);
      long max=Math.max(coords[i][0],coords[i][1]);
      if(steps[i]<max)System.out.println("-1");
      else {
        if((coords[i][0]+coords[i][1])% 2==0){
          if((steps[i]-max)% 2==0)System.out.println(steps[i]);
          else System.out.println(steps[i]-2);
        }
        else System.out.println(steps[i]-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class diagonalWalking {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
    var coords : Sequence(Sequence(long)) ; coords := Integer.subrange(1,q)->collect(Integer.subrange(1,2)->collect(0)) ;
    var steps : Sequence(long) ; steps := Integer.subrange(1,q)->collect(0) ;
        var i : int ; i := 0 ; while i < q do ( (     coords[i+1][0+1] := if sc.getCurrent()->toLong() < 0 then -(sc.getCurrent()->toLong()) else sc.getCurrent()->toLong() endif ; 
     coords[i+1][1+1] := if sc.getCurrent()->toLong() < 0 then -(sc.getCurrent()->toLong()) else sc.getCurrent()->toLong() endif ; 
     steps[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var min : long ; min := Set{coords[i+1][0+1], coords[i+1][1+1]}->min() ;
     var max : long ; max := Set{coords[i+1][0+1], coords[i+1][1+1]}->max() ;
     if (steps[i+1] < max) then     OclFile["System.out"].println("-1") ; else (     if ((coords[i+1][0+1] + coords[i+1][1+1]) mod 2 = 0) then (     if ((steps[i+1] - max) mod 2 = 0) then     OclFile["System.out"].println(steps[i+1]) ; else     OclFile["System.out"].println(steps[i+1] - 2) ; ) else     OclFile["System.out"].println(steps[i+1] - 1) ; ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
interface Main {
  static void main(String[] $){
    Scanner s=new Scanner(System.in);
    final int D=1000000007,N=s.nextInt(),M=s.next().length();
    s.close();
    long[] p=new long[N+1],a=new long[N+1];
    p[M]=1 ;
    for(int i=N ; i>=1 ; i--){
      a[0]=(p[0]+p[1])% D ;
      for(int j=1 ; j<i ; j++)a[j]=(p[j-1]*2+p[j+1])% D ;
      System.arraycopy(a,0,p,0,i);
    }
    System.out.println(a[0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 interface Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var D : int ; D := 1000000007 ;
    var N : int ; N := s.getCurrent()->toInteger() ;
    var M : int ; M := s.getCurrent()->size() ;
    skip ; 
    var p : Sequence(long) ; p := Integer.subrange(1,N + 1)->collect(0) ;
    var a : Sequence(long) ; a := Integer.subrange(1,N + 1)->collect(0) ;
    p[M+1] := 1 ; 
        var i : int ; i := N ; while i >= 1 do ( (     a[0+1] := (p[0+1] + p[1+1]) mod D ; 
         var j : int ; j := 1 ; while j < i do (     a[j+1] := (p[j - 1+1] * 2 + p[j + 1+1]) mod D ;  ;     j := j + 1 ) ; 
     for _x : Integer.subrange(1,i) do p[0 + _x] := a[0 + _x] )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(a[0+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  final static long MOD=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.next().length();
    long[][] dp=new long[2][N+1];
    dp[0][0]=1 ;
    for(int i=0 ; i<N ; i++){
      Arrays.fill(dp[(i+1)% 2],0);
      for(int j=0 ; j<=i ; j++){
        dp[(i+1)% 2][j+1]=(dp[(i+1)% 2][j+1]+dp[i % 2][j]*2)% MOD ;
        dp[(i+1)% 2][Math.max(0,j-1)]=(dp[(i+1)% 2][Math.max(0,j-1)]+dp[i % 2][j])% MOD ;
      }
    }
    long ans=dp[N % 2][M];
    long div2=(MOD+1)/2 ;
    for(int i=0 ; i<M ; i++)ans=(ans*div2)% MOD ;
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : long := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->size() ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 0 ; while i < N do ( (     dp[(i + 1) mod 2+1] := dp[(i + 1) mod 2+1]->collect(0) ; 
         var j : int ; j := 0 ; while j <= i do ( (     dp[(i + 1) mod 2+1][j + 1+1] := (dp[(i + 1) mod 2+1][j + 1+1] + dp[i mod 2+1][j+1] * 2) mod MOD ; 
     dp[(i + 1) mod 2+1][Set{0, j - 1}->max()+1] := (dp[(i + 1) mod 2+1][Set{0, j - 1}->max()+1] + dp[i mod 2+1][j+1]) mod MOD )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := dp[N mod 2+1][M+1] ;
    var div2 : long ; div2 := (MOD + 1) / 2 ;
        var i : int ; i := 0 ; while i < M do (     ans := (ans * div2) mod MOD ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int centeredOctahedral(int n){
    return(2*n+1)*(2*n*n+2*n+3)/3 ;
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.print(centeredOctahedral(n));
    System.out.println();
    n=9 ;
    System.out.print(centeredOctahedral(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation centeredOctahedral( n : int) : int
  pre: true
  post: true
  activity: (     return (2 * n + 1) * (2 * n * n + 2 * n + 3) / 3 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].print(centeredOctahedral(n)) ; 
    OclFile["System.out"].println() ; 
    n := 9 ; 
    OclFile["System.out"].print(centeredOctahedral(n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
interface Main {
  static void main(String[] $){
    Scanner s=new Scanner(System.in);
    final int D=1000000007,N=s.nextInt(),M=s.next().length();
    s.close();
    long[] p=new long[M+N+2],a=new long[M+N+2];
    p[M]=1 ;
    for(int i=1 ; i<=N ; i++){
      a[0]=(p[0]+p[1])% D ;
      for(int j=1 ; j<=M+i ; j++)a[j]=(p[j-1]*2+p[j+1])% D ;
      System.arraycopy(a,0,p,0,M+N+2);
    }
    System.out.println(a[0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 interface Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var D : int ; D := 1000000007 ;
    var N : int ; N := s.getCurrent()->toInteger() ;
    var M : int ; M := s.getCurrent()->size() ;
    skip ; 
    var p : Sequence(long) ; p := Integer.subrange(1,M + N + 2)->collect(0) ;
    var a : Sequence(long) ; a := Integer.subrange(1,M + N + 2)->collect(0) ;
    p[M+1] := 1 ; 
        var i : int ; i := 1 ; while i <= N do ( (     a[0+1] := (p[0+1] + p[1+1]) mod D ; 
         var j : int ; j := 1 ; while j <= M + i do (     a[j+1] := (p[j - 1+1] * 2 + p[j + 1+1]) mod D ;  ;     j := j + 1 ) ; 
     for _x : Integer.subrange(1,M + N + 2) do p[0 + _x] := a[0 + _x] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a[0+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void find(int n,int m){
    if(n<=2*m)System.out.println("Minimum "+0);
    else System.out.println("Minimum "+(n-2*m));
    int i ;
    for(i=1 ; i<=n ; i++){
      if(i*(i-1)/2>=m)break ;
    }
    System.out.println("Maximum "+(n-i));
  }
  public static void main(String[] args){
    int n=4 ;
    int m=2 ;
    find(n,m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation find( n : int, m : int) : void
  pre: true
  post: true
  activity: (     if (n <= 2 * m) then     OclFile["System.out"].println("Minimum " + 0) else     OclFile["System.out"].println("Minimum " + (n - 2 * m)) ; ;  
     var i : int ;
         i := 1 ; while i <= n do ( (     if (i * (i - 1) / 2 >= m) then     break else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Maximum " + (n - i)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var m : int ; m := 2 ;
     execute find(n, m) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  public static int Largercount(int arr1[],int arr2[],int m,int n){
    int count=0 ;
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(int i=0 ; i<m ; i++){
      int key=arr1[i];
      if(mp.containsKey(key)){
        int freq=mp.get(key);
        freq++;
        mp.put(key,freq);
      }
      else mp.put(key,1);
    }
    for(int i=0 ; i<n ; i++){
      if(mp.containsKey(arr2[i])&& mp.get(arr2[i])!=0){
        int freq=mp.get(arr2[i]);
        freq--;
        mp.put(arr2[i],freq);
      }
    }
    for(int i=0 ; i<m ; i++){
      if(mp.get(arr1[i])!=0){
        count++;
        mp.put(arr1[i],0);
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int arr1[]=new int[] {
      2,4,4,6,6,6,8,9 };
      int arr2[]=new int[] {
        2,2,4,6,6 };
        System.out.print(Largercount(arr1,arr2,8,5));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Largercount( arr1 : Sequence(int), arr2 : Sequence(int), m : int, n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var mp : Map(int,int) ; mp := Map{} ;
        var i : int ; i := 0 ; while i < m do ( (     var key : int ; key := arr1[i+1] ;
     if (mp->keys()->includes(key)) then (     var freq : int ; freq := mp->at(key) ;
     freq := freq + 1 ; 
     mp := mp->union(Map{key |-> freq}) ) else     mp := mp->union(Map{key |-> 1}) ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (mp->keys()->includes(arr2[i+1]) & mp->at(arr2[i+1]) /= 0) then (     var freq : int ; freq := mp->at(arr2[i+1]) ;
     freq := freq - 1 ; 
     mp := mp->union(Map{arr2[i+1] |-> freq}) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     if (mp->at(arr1[i+1]) /= 0) then (     count := count + 1 ; 
     mp := mp->union(Map{arr1[i+1] |-> 0}) ) else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{2,4,4,6,6,6,8,9} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{2,2,4,6,6} ;
     OclFile["System.out"].print(Largercount(arr1, arr2, 8, 5)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static double ReuleauxArea(double r){
    if(r<0)return-1 ;
    double A=0.70477*2*Math.pow(r,2);
    return A ;
  }
  public static void main(String args[]){
    double r=6 ;
    System.out.println(ReuleauxArea(r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation ReuleauxArea( r : double) : double
  pre: true
  post: true
  activity: (     if (r < 0) then     return -1 else skip ; 
     var A : double ; A := 0.70477 * 2 * r->pow(2) ;
     return A );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : double ; r := 6 ;
     OclFile["System.out"].println(ReuleauxArea(r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  static int binarySearch(int arr[],int low,int high,int key){
    if(high<low)return-1 ;
    int mid=(low+high)/2 ;
    if(key==arr[mid])return mid ;
    if(key>arr[mid])return binarySearch(arr,(mid+1),high,key);
    return binarySearch(arr,low,(mid-1),key);
  }
  static int deleteElement(int arr[],int n,int key){
    int pos=binarySearch(arr,0,n-1,key);
    if(pos==-1){
      System.out.println("Element not found");
      return n ;
    }
    int i ;
    for(i=pos ; i<n-1 ; i++)arr[i]=arr[i+1];
    return n-1 ;
  }
  public static void main(String[] args){
    int i ;
    int arr[]={
      10,20,30,40,50 };
      int n=arr.length ;
      int key=30 ;
      System.out.print("Array before deletion:\n");
      for(i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
      n=deleteElement(arr,n,key);
      System.out.print("\n\nArray after deletion:\n");
      for(i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation binarySearch( arr : Sequence(int), low : int, high : int, key : int) : int
  pre: true
  post: true
  activity: (     if (high < low) then     return -1 else skip ; 
     var mid : int ; mid := (low + high) / 2 ;
    if (key = arr[mid+1]) then     return mid else skip ; 
    if (key > arr[mid+1]) then     return binarySearch(arr, (mid + 1), high, key) else skip ; 
    return binarySearch(arr, low, (mid - 1), key) 
 );
  static   operation deleteElement( arr : Sequence(int), n : int, key : int) : int
  pre: true
  post: true
  activity: (     var pos : int ; pos := binarySearch(arr, 0, n - 1, key) ;
     if (pos = -1) then (     OclFile["System.out"].println("Element not found") ; 
     return n ) else skip ; 
    var i : int ;
        i := pos ; while i < n - 1 do (     arr[i+1] := arr[i + 1+1] ;  ;     i := i + 1 ) ; 
    return n - 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
     var arr : Sequence(int) ; arr := Sequence{10,20,30,40,50} ;
    var n : int ; n := arr->size() ;
    var key : int ; key := 30 ;
    OclFile["System.out"].print("Array before deletion:\n") ; 
        i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
    n := deleteElement(arr, n, key) ; 
    OclFile["System.out"].print("\n\nArray after deletion:\n") ; 
        i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAX=100 ;
  static int[][] mat=new int[MAX][MAX];
  static void fillRemaining(int i,int j,int n){
    int x=2 ;
    for(int k=i+1 ; k<n ; k++)mat[k][j]=x++;
    for(int k=0 ; k<i ; k++)mat[k][j]=x++;
  }
  static void constructMatrix(int n){
    int right=n-1,left=0 ;
    for(int i=0 ; i<n ; i++){
      if(i % 2==0){
        mat[i][right]=1 ;
        fillRemaining(i,right,n);
        right--;
      }
      else {
        mat[i][left]=1 ;
        fillRemaining(i,left,n);
        left++;
      }
    }
  }
  public static void main(String args[]){
    int n=5 ;
    constructMatrix(n);
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++)System.out.print(mat[i][j]+" ");
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 100;
  static   attribute mat : Sequence(Sequence(int)) := Integer.subrange(1,MAX)->collect(Integer.subrange(1,MAX)->collect(0));
  static   operation fillRemaining( i : int, j : int, n : int) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 2 ;
         var k : int ; k := i + 1 ; while k < n do (      mat[k+1][j+1] := x  ; x := x + 1 ;  ;     k := k + 1 ) ; 
         var k : int ; k := 0 ; while k < i do (      mat[k+1][j+1] := x  ; x := x + 1 ;  ;     k := k + 1 ) );
  static   operation constructMatrix( n : int) : void
  pre: true
  post: true
  activity: (     var right : int ; right := n - 1 ;
    var left : int ; left := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then (     mat[i+1][right+1] := 1 ; 
     execute fillRemaining(i, right, n) ; 
     right := right - 1 ) else (     mat[i+1][left+1] := 1 ; 
     execute fillRemaining(i, left, n) ; 
     left := left + 1 ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute constructMatrix(n) ; 
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do (     OclFile["System.out"].print(mat[i+1][j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Node {
    int data ;
    Node next ;
    Node prev ;
  };
  static Node sort(Node head){
    if(head==null || head.next==null){
      return head ;
    }
    Node front=head ;
    Node last=head ;
    Node res=new Node();
    Node resEnd=res ;
    Node next ;
    while(last.next!=null){
      last=last.next ;
    }
    while(front!=last){
      if(last.data<=front.data){
        resEnd.next=last ;
        next=last.prev ;
        last.prev.next=null ;
        last.prev=resEnd ;
        last=next ;
        resEnd=resEnd.next ;
      }
      else {
        resEnd.next=front ;
        next=front.next ;
        front.next=null ;
        front.prev=resEnd ;
        front=next ;
        resEnd=resEnd.next ;
      }
    }
    resEnd.next=front ;
    front.prev=resEnd ;
    return res.next ;
  }
  static Node push(Node head_ref,int new_data){
    Node new_node=new Node();
    new_node.data=new_data ;
    new_node.prev=null ;
    new_node.next=(head_ref);
    if((head_ref)!=null)(head_ref).prev=new_node ;
(head_ref)=new_node ;
    return head_ref ;
  }
  static void printList(Node head){
    if(head==null)System.out.print("Doubly Linked list empty");
    while(head!=null){
      System.out.print(head.data+" ");
      head=head.next ;
    }
  }
  public static void main(String args[]){
    Node head=null ;
    head=push(head,1);
    head=push(head,4);
    head=push(head,6);
    head=push(head,10);
    head=push(head,12);
    head=push(head,7);
    head=push(head,5);
    head=push(head,2);
    System.out.print("Original Doubly linked list:\n");
    printList(head);
    head=sort(head);
    System.out.print("\nDoubly linked list after sorting:\n");
    printList(head);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
   attribute prev : Node;
}
  static   operation sort( head : Node) : Node
  pre: true
  post: true
  activity: (     if (head = null or head.next = null) then (     return head ) else skip ; 
     var front : Node ; front := head ;
    var last : Node ; last := head ;
    var res : Node ; res := Node.newNode() ;
    var resEnd : Node ; resEnd := res ;
    var next : Node ;
    while (last.next /= null) do (     last := last.next ) ; 
    while (front /= last) do (     if (last.data <= front.data) then (     resEnd.next := last ; 
     next := last.prev ; 
    last.prev.next := null ; 
    last.prev := resEnd ; 
    last := next ; 
    resEnd := resEnd.next ; 
 ) else (     resEnd.next := front ; 
     next := front.next ; 
    front.next := null ; 
    front.prev := resEnd ; 
    front := next ; 
    resEnd := resEnd.next ; 
 ) ) ; 
    resEnd.next := front ; 
    front.prev := resEnd ; 
    return res.next 
 );
  static   operation push( head_ref : Node, new_data : int) : Node
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode() ;
     new_node.data := new_data ; 
    new_node.prev := null ; 
    new_node.next := (head_ref) ; 
    if ((head_ref) /= null) then     (head_ref).prev := new_node ; else skip ; 
    (head_ref) := new_node ; 
    return head_ref 
 );
  static   operation printList( head : Node) : void
  pre: true
  post: true
  activity: (     if (head = null) then     OclFile["System.out"].print("Doubly Linked list empty") ; else skip ; 
     while (head /= null) do (     OclFile["System.out"].print(head.data + " ") ; 
     head := head.next ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := null ;
     head := push(head, 1) ; 
    head := push(head, 4) ; 
    head := push(head, 6) ; 
    head := push(head, 10) ; 
    head := push(head, 12) ; 
    head := push(head, 7) ; 
    head := push(head, 5) ; 
    head := push(head, 2) ; 
    OclFile["System.out"].print("Original Doubly linked list:\n") ; 
    execute printList(head) ; 
    head := sort(head) ; 
    OclFile["System.out"].print("\nDoubly linked list after sorting:\n") ; 
    execute printList(head) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int optCost(int freq[],int i,int j){
    if(j<i)return 0 ;
    if(j==i)return freq[i];
    int fsum=sum(freq,i,j);
    int min=Integer.MAX_VALUE ;
    for(int r=i ; r<=j ; ++r){
      int cost=optCost(freq,i,r-1)+optCost(freq,r+1,j);
      if(cost<min)min=cost ;
    }
    return min+fsum ;
  }
  static int optimalSearchTree(int keys[],int freq[],int n){
    return optCost(freq,0,n-1);
  }
  static int sum(int freq[],int i,int j){
    int s=0 ;
    for(int k=i ; k<=j ; k++)s+=freq[k];
    return s ;
  }
  public static void main(String[] args){
    int keys[]={
      10,12,20 };
      int freq[]={
        34,8,50 };
        int n=keys.length ;
        System.out.println("Cost of Optimal BST is "+optimalSearchTree(keys,freq,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation optCost( freq : Sequence(int), i : int, j : int) : int
  pre: true
  post: true
  activity: (     if (j < i) then     return 0 else skip ; 
     if (j = i) then     return freq[i+1] else skip ; 
    var fsum : int ; fsum := sum(freq, i, j) ;
    var min : int ; min := 2147483647 ;
        var r : int ; r := i ; while r <= j do ( (     var cost : int ; cost := optCost(freq, i, r - 1) + optCost(freq, r + 1, j) ;
     if (cost < min) then     min := cost ; else skip )  ;     r := r + 1 ) ; 
    return min + fsum 
 );
  static   operation optimalSearchTree( keys : Sequence(int), freq : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     return optCost(freq, 0, n - 1) );
  static   operation sum( freq : Sequence(int), i : int, j : int) : int
  pre: true
  post: true
  activity: (     var s : int ; s := 0 ;
         var k : int ; k := i ; while k <= j do (     s := s+(freq[k+1]) ;  ;     k := k + 1 ) ; 
     return s );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var keys : Sequence(int) ; keys := Sequence{10,12,20} ;
     var freq : Sequence(int) ; freq := Sequence{34,8,50} ;
     var n : int ; n := keys->size() ;
     OclFile["System.out"].println("Cost of Optimal BST is " + optimalSearchTree(keys, freq, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      long[] b=new long[n];
      for(int i=0 ; i<n ; i++){
        b[i]=sc.nextLong();
      }
      Set<Long>chk=new HashSet<>();
      for(int i=0 ; i<n ; i++){
        chk.add(b[i]);
      }
      if(chk.size()==n)System.out.println("NO");
      else System.out.println("YES");
    }
  }
  static boolean isPrime(long n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static long gcd(long a,long b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static long lcm(long a,long b){
    return(a/gcd(a,b))*b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var chk : Set(long) ; chk := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     chk := chk->including(b[i+1]) )  ;     i := i + 1 ) ; 
    if (chk->size() = n) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  
 ) ;  ) );
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a / gcd(a, b)) * b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float percent(int n,int x){
    float p=n*x ;
    p/=100 ;
    return p ;
  }
  static float getLoss(int price[],int quantity[],int X[],int n){
    float loss=0 ;
    for(int i=0 ; i<n ; i++){
      float originalPrice=price[i];
      float sellingPrice=originalPrice+percent((int)originalPrice,X[i]);
      float afterDiscount=sellingPrice-percent((int)sellingPrice,X[i]);
      loss+=((originalPrice-afterDiscount)*quantity[i]);
    }
    return loss ;
  }
  public static void main(String args[]){
    int price[]={
      20,48,200,100 };
      int quantity[]={
        20,48,1,1 };
        int X[]={
          0,48,200,5 };
          int n=X.length ;
          System.out.print(getLoss(price,quantity,X,n));
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation percent( n : int, x : int) : double
  pre: true
  post: true
  activity: (     var p : double ; p := n * x ;
     p := p/(100) ; 
     return p );
  static   operation getLoss( price : Sequence(int), quantity : Sequence(int), X : Sequence(int), n : int) : double
  pre: true
  post: true
  activity: (     var loss : double ; loss := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var originalPrice : double ; originalPrice := price[i+1] ;
     var sellingPrice : double ; sellingPrice := originalPrice + percent(originalPrice->oclAsType(int), X[i+1]) ;
     var afterDiscount : double ; afterDiscount := sellingPrice - percent(sellingPrice->oclAsType(int), X[i+1]) ;
     loss := loss+(((originalPrice - afterDiscount) * quantity[i+1])) )  ;     i := i + 1 ) ; 
     return loss );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var price : Sequence(int) ; price := Sequence{20,48,200,100} ;
     var quantity : Sequence(int) ; quantity := Sequence{20,48,1,1} ;
    var X : Sequence(int) ; X := Sequence{0,48,200,5} ;
    var n : int ; n := X->size() ;
    OclFile["System.out"].print(getLoss(price, quantity, X, n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Set ;
import java.util.StringTokenizer ;
public class Main {
  private static class FastScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public FastScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
      tokenizer=null ;
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          return reader.readLine();
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken("\n");
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public int[] nextIntArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    public long[] nextLongArray(int n){
      long[] a=new long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
  }
  public static void main(String[] args){
    FastScanner sc=new FastScanner(System.in);
    String s=sc.next();
    Set<String>chars=new HashSet<>();
    chars.addAll(Arrays.asList(s.split("")));
    if(chars.size()==2){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.nextToken("\n") );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var s : String ; s := sc.next() ;
    var chars : Set(String) ; chars := Set{} ;
    chars := chars->union(s->split("")) ; 
    if (chars->size() = 2) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MaxGCD(int a[],int n){
    int[] Prefix=new int[n+2];
    int[] Suffix=new int[n+2];
    Prefix[1]=a[0];
    for(int i=2 ; i<=n ; i+=1){
      Prefix[i]=__gcd(Prefix[i-1],a[i-1]);
    }
    Suffix[n]=a[n-1];
    for(int i=n-1 ; i>=1 ; i-=1){
      Suffix[i]=__gcd(Suffix[i+1],a[i-1]);
    }
    int ans=Math.max(Suffix[2],Prefix[n-1]);
    for(int i=2 ; i<n ; i+=1){
      ans=Math.max(ans,__gcd(Prefix[i-1],Suffix[i+1]));
    }
    return ans ;
  }
  static int __gcd(int a,int b){
    return b==0 ? a : __gcd(b,a % b);
  }
  public static void main(String[] args){
    int a[]={
      6,7,8 };
      int n=a.length ;
      System.out.println(MaxGCD(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation MaxGCD( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var Prefix : Sequence(int) ; Prefix := Integer.subrange(1,n + 2)->collect(0) ;
     var Suffix : Sequence(int) ; Suffix := Integer.subrange(1,n + 2)->collect(0) ;
    Prefix[1+1] := a[0+1] ; 
        var i : int ; i := 2 ; while i <= n do ( (     Prefix[i+1] := __gcd(Prefix[i - 1+1], a[i - 1+1]) )  ;     i := i+(1) ) ; 
    Suffix[n+1] := a[n - 1+1] ; 
        var i : int ; i := n - 1 ; while i >= 1 do ( (     Suffix[i+1] := __gcd(Suffix[i + 1+1], a[i - 1+1]) )  ;     i := i-(1) ) ; 
    var ans : int ; ans := Set{Suffix[2+1], Prefix[n - 1+1]}->max() ;
        var i : int ; i := 2 ; while i < n do ( (     ans := Set{ans, __gcd(Prefix[i - 1+1], Suffix[i + 1+1])}->max() )  ;     i := i+(1) ) ; 
    return ans 
 );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else __gcd(b, a mod b) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{6,7,8} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(MaxGCD(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.sqrt ;
public class Primmefunc {
  public static void prime(long n){
    int flag=0 ;
    if((n+1)% 6!=0 &&(n-1)% 6!=0){
      System.out.println("Not Prime");
    }
    else {
      double s=sqrt(n);
      if((s*s)==n){
        System.out.println("Semi-Prime");
      }
      else {
        long f=(long)s ;
        long l=(long)((f*f));
        for(long i=f+1 ; i<l ; i++){
          long p=i-(long)(sqrt((i*i)-(n)));
          long q=n/p ;
          if(p<2 || q<2){
            break ;
          }
          if((p*q)==n){
            flag=1 ;
            break ;
          }
          else {
            flag=2 ;
          }
        }
        if(flag==1){
          System.out.println("Semi-Prime");
        }
        else if(flag==2){
          System.out.println("Prime");
        }
      }
    }
  }
  public static void main(String[] args){
    prime(8179);
    prime(7894561);
    prime(90000000);
    prime(841);
    prime(22553);
    prime(1187);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Primmefunc {
  static   operation prime( n : long) : void
  pre: true
  post: true
  activity: (     var flag : int ; flag := 0 ;
     if ((n + 1) mod 6 /= 0 & (n - 1) mod 6 /= 0) then (     OclFile["System.out"].println("Not Prime") ) else (     var s : double ; s := sqrt(n) ;
     if ((s * s) = n) then (     OclFile["System.out"].println("Semi-Prime") ) else (     var f : long ; f := s->oclAsType(long) ;
     var l : long ; l := ((f * f))->oclAsType(long) ;
         var i : long ; i := f + 1 ; while i < l do ( (     var p : long ; p := i - (sqrt((i * i) - (n)))->oclAsType(long) ;
     var q : long ; q := n / p ;
     if (p < 2 or q < 2) then (     break ) else skip ; 
     if ((p * q) = n) then (     flag := 1 ; 
     break ) else (     flag := 2 ) )  ;     i := i + 1 ) ; 
     if (flag = 1) then (     OclFile["System.out"].println("Semi-Prime") ) else     if (flag = 2) then (     OclFile["System.out"].println("Prime") ) else skip ; ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute prime(8179) ; 
     execute prime(7894561) ; 
    execute prime(90000000) ; 
    execute prime(841) ; 
    execute prime(22553) ; 
    execute prime(1187) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    int e=sc.nextInt();
    int x=e*a ;
    int y=0 ;
    if(c<e){
      y=b+(e-c)*d ;
    }
    else {
      y=b ;
    }
    if(y<x)System.out.println(y);
    else System.out.println(x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var e : int ; e := sc.getCurrent()->toInteger() ;
    var x : int ; x := e * a ;
    var y : int ; y := 0 ;
    if (c < e) then (     y := b + (e - c) * d ) else (     y := b ) ;  
    if (y < x) then     OclFile["System.out"].println(y) else     OclFile["System.out"].println(x) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    int companyXFeeRate=Integer.parseInt(bufferedReader.readLine());
    int companyYBase=Integer.parseInt(bufferedReader.readLine());
    int companyYLimit=Integer.parseInt(bufferedReader.readLine());
    int companyYAdd=Integer.parseInt(bufferedReader.readLine());
    int usedWater=Integer.parseInt(bufferedReader.readLine());
    int companyXFee=companyXFeeRate*usedWater ;
    int companyYFee=0 ;
    if(companyYLimit<usedWater){
      int over=usedWater-companyYLimit ;
      companyYFee=companyYBase+companyYAdd*over ;
    }
    else {
      companyYFee=companyYBase ;
    }
    System.out.println(companyXFee<companyYFee ? companyXFee : companyYFee);
  }
  public static String getStringCharAt(String str,int position){
    return String.valueOf(str.charAt(position));
  }
  public static String[] getStringCharArr(String str){
    String[] arrResult=new String[str.length()];
    for(int i=0 ; i<str.length(); i++)arrResult[i]=getStringCharAt(str,i);
    return arrResult ;
  }
  public static boolean isInnerPosition(int x1,int x2,int searchPosition){
    return x1<=searchPosition && searchPosition<=x2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var companyXFeeRate : int ; companyXFeeRate := (bufferedReader.readLine())->toInteger() ;
    var companyYBase : int ; companyYBase := (bufferedReader.readLine())->toInteger() ;
    var companyYLimit : int ; companyYLimit := (bufferedReader.readLine())->toInteger() ;
    var companyYAdd : int ; companyYAdd := (bufferedReader.readLine())->toInteger() ;
    var usedWater : int ; usedWater := (bufferedReader.readLine())->toInteger() ;
    var companyXFee : int ; companyXFee := companyXFeeRate * usedWater ;
    var companyYFee : int ; companyYFee := 0 ;
    if (companyYLimit < usedWater) then (     var over : int ; over := usedWater - companyYLimit ;
     companyYFee := companyYBase + companyYAdd * over ) else (     companyYFee := companyYBase ) ;  
    OclFile["System.out"].println(if companyXFee < companyYFee then companyXFee else companyYFee endif) ; 
 );
  static   operation getStringCharAt( str : String, position : int) : String
  pre: true
  post: true
  activity: (     return ((str->at(position+1)) + "") );
  static   operation getStringCharArr( str : String) : Sequence(String)
  pre: true
  post: true
  activity: (     var arrResult : Sequence(String) ; arrResult := Integer.subrange(1,str->size())->collect(null) ;
         var i : int ; i := 0 ; while i < str->size() do (     arrResult[i+1] := getStringCharAt(str, i) ;  ;     i := i + 1 ) ; 
     return arrResult );
  static   operation isInnerPosition( x1 : int, x2 : int, searchPosition : int) : boolean
  pre: true
  post: true
  activity: (     return x1 <= searchPosition & searchPosition <= x2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  static final PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int a=Integer.parseInt(line);
      int b=Integer.parseInt(br.readLine());
      int c=Integer.parseInt(br.readLine());
      int d=Integer.parseInt(br.readLine());
      int p=Integer.parseInt(br.readLine());
      int x=a*p ;
      int y=(p>=c)? b+(p-c)*d : b ;
      out.println(Math.min(x,y));
      out.flush();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var a : int ; a := (line)->toInteger() ;
     var b : int ; b := (br.readLine())->toInteger() ;
    var c : int ; c := (br.readLine())->toInteger() ;
    var d : int ; d := (br.readLine())->toInteger() ;
    var p : int ; p := (br.readLine())->toInteger() ;
    var x : int ; x := a * p ;
    var y : int ; y := if (p >= c) then b + (p - c) * d else b endif ;
    skip ; 
    skip ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static int calcX(int A,int P){
    return A*P ;
  }
  private static int calcY(int B,int C,int D,int P){
    return(P<C)? B : B+D*(P-C);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int A=Integer.parseInt(sc.next());
      int B=Integer.parseInt(sc.next());
      int C=Integer.parseInt(sc.next());
      int D=Integer.parseInt(sc.next());
      int P=Integer.parseInt(sc.next());
      System.out.println(Math.min(calcX(A,P),calcY(B,C,D,P)));
    }
  };
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation calcX( A : int, P : int) : int
  pre: true
  post: true
  activity: (     return A * P );
  static   operation calcY( B : int, C : int, D : int, P : int) : int
  pre: true
  post: true
  activity: (     return if (P < C) then B else B + D * (P - C) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var A : int ; A := (sc.getCurrent())->toInteger() ;
     var B : int ; B := (sc.getCurrent())->toInteger() ;
    var C : int ; C := (sc.getCurrent())->toInteger() ;
    var D : int ; D := (sc.getCurrent())->toInteger() ;
    var P : int ; P := (sc.getCurrent())->toInteger() ;
    OclFile["System.out"].println(Set{calcX(A, P), calcY(B, C, D, P)}->min()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int x=scan.nextInt();
    int kihon=scan.nextInt();
    int zyougen=scan.nextInt();
    int tuika=scan.nextInt();
    int joi=scan.nextInt();
    int ryokin=x*joi ;
    int hikaku=0 ;
    if(zyougen>=joi){
      if(ryokin>kihon){
        ryokin=kihon ;
        System.out.println(kihon);
      }
      else {
        System.out.println(ryokin);
      }
    }
    else {
      hikaku=kihon+(joi-zyougen)*tuika ;
      if(hikaku>ryokin){
        System.out.println(ryokin);
      }
      else System.out.println(hikaku);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := scan.getCurrent()->toInteger() ;
    var kihon : int ; kihon := scan.getCurrent()->toInteger() ;
    var zyougen : int ; zyougen := scan.getCurrent()->toInteger() ;
    var tuika : int ; tuika := scan.getCurrent()->toInteger() ;
    var joi : int ; joi := scan.getCurrent()->toInteger() ;
    var ryokin : int ; ryokin := x * joi ;
    var hikaku : int ; hikaku := 0 ;
    if (zyougen >= joi) then (     if (ryokin > kihon) then (     ryokin := kihon ; 
     OclFile["System.out"].println(kihon) ) else (     OclFile["System.out"].println(ryokin) ) ) else (     hikaku := kihon + (joi - zyougen) * tuika ; 
     if (hikaku > ryokin) then (     OclFile["System.out"].println(ryokin) ) else     OclFile["System.out"].println(hikaku) ; ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    int N=in.nextInt();
    int[] A=new int[N];
    int[] B=new int[N];
    long tmp=1_000_000_000_000L ;
    long sum=0L ;
    int flag=0 ;
    for(int i=0 ; i<N ; i++){
      A[i]=in.nextInt();
      B[i]=in.nextInt();
      if(A[i]!=B[i])flag=1 ;
      sum+=A[i];
      if(A[i]>B[i])tmp=Math.min(tmp,B[i]);
    }
    if(flag==0)out.println(0);
    else out.println(sum-tmp);
    out.close();
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var N : int ; N := in.nextInt() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,N)->collect(0) ;
    var tmp : long ; tmp := 1_000_000_000_000L ;
    var sum : long ; sum := 0L ;
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := in.nextInt() ; 
     B[i+1] := in.nextInt() ; 
    if (A[i+1] /= B[i+1]) then     flag := 1 ; else skip ; 
    sum := sum+(A[i+1]) ; 
    if (A[i+1] > B[i+1]) then     tmp := Set{tmp, B[i+1]}->min() ; else skip ; 
 )  ;     i := i + 1 ) ; 
    if (flag = 0) then     skip else     skip ; ;  
    skip ; 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int Q=scanner.nextInt();
    long count=0 ;
    long minb=Integer.MAX_VALUE ;
    int[] A=new int[Q];
    int[] B=new int[Q];
    for(int i=0 ; i<Q ; i++){
      A[i]=scanner.nextInt();
      B[i]=scanner.nextInt();
      count+=A[i];
      if(A[i]>B[i]){
        minb=Math.min(minb,B[i]);
      }
    }
    scanner.close();
    if(Arrays.equals(A,B)){
      System.out.println(0);
      return ;
    }
    System.out.println((count-minb));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var Q : int ; Q := scanner.getCurrent()->toInteger() ;
    var count : long ; count := 0 ;
    var minb : long ; minb := 2147483647 ;
    var A : Sequence(int) ; A := Integer.subrange(1,Q)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,Q)->collect(0) ;
        var i : int ; i := 0 ; while i < Q do ( (     A[i+1] := scanner.getCurrent()->toInteger() ; 
     B[i+1] := scanner.getCurrent()->toInteger() ; 
     count := count+(A[i+1]) ; 
     if (A[i+1] > B[i+1]) then (     minb := Set{minb, B[i+1]}->min() ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    if (A = B) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    OclFile["System.out"].println((count - minb)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cp {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      boolean st=false ;
      int arr[]=new int[n];
      Set<Integer>set=new HashSet<>();
      for(int i=0 ; i<n ; i++){
        arr[i]=s.nextInt();
        if(set.contains(arr[i]))st=true ;
        set.add(arr[i]);
      }
      if(st)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var st : boolean ; st := false ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() ; 
     if (set->includes(arr[i+1])) then     st := true ; else skip ; 
     set := set->including(arr[i+1]) )  ;     i := i + 1 ) ; 
    if (st) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] d=new int[n];
    Arrays.fill(d,-1);
    Map<Integer,Map<Integer,Integer>>l=new HashMap<>();
    Map<Integer,List<Integer>>m=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      m.put(i,new ArrayList<>());
      l.put(i,new HashMap<Integer,Integer>());
    }
    for(int i=0 ; i<n-1 ; i++){
      int u=sc.nextInt()-1 ;
      int v=sc.nextInt()-1 ;
      int w=sc.nextInt()% 2 ;
      m.get(u).add(v);
      m.get(v).add(u);
      l.get(u).put(v,w);
      l.get(v).put(u,w);
    }
    d[0]=0 ;
    Deque<Integer>q=new ArrayDeque<>();
    q.add(0);
    while(q.size()>0){
      int r=q.pollFirst();
      for(int p : m.get(r)){
        if(d[p]!=-1)continue ;
        d[p]=d[r]+l.get(r).get(p);
        q.offerFirst(p);
      }
    }
    for(int i=0 ; i<n ; i++){
      if(d[i] % 2==0)System.out.println(0);
      else System.out.println(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
    d := d->collect(-1) ; 
    var l : Map(int,Map(int,int)) ; l := Map{} ;
    var m : Map(int,Sequence(int)) ; m := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     m := m->union(Map{i |-> Sequence{}}) ; 
     l := l->union(Map{i |-> Map{}}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var u : int ; u := sc.getCurrent()->toInteger() - 1 ;
     var v : int ; v := sc.getCurrent()->toInteger() - 1 ;
    var w : int ; w := sc.getCurrent()->toInteger() mod 2 ;
    m->at(u)->excludes(v) ; 
    m->at(v)->excludes(u) ; 
    l := l->at(u)->union(Map{v |-> w}) ; 
    l := l->at(v)->union(Map{u |-> w}) ; 
 )  ;     i := i + 1 ) ; 
    d[0+1] := 0 ; 
    var q : Sequence(int) ; q := ArrayDeque<OclAny>.newArrayDeque() ;
    q := q->including(0) ; 
    while (q->size() > 0) do (     var r : int ; r := q->first() ;
     for (p : m->at(r)) do ( (     if (d[p+1] /= -1) then     continue else skip ; 
     d[p+1] := d[r+1] + l->at(r)->at(p+1) ; 
     q := q->prepend(p) )  ) ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (d[i+1] mod 2 = 0) then     OclFile["System.out"].println(0) ; else     OclFile["System.out"].println(1) ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Counter<T>extends HashMap<T,Integer>{
  public Counter(){
    super();
  }
  public Integer get(Object elm){
    return getOrDefault(elm,0);
  }
  public void add(T elm,int amount){
    if(! this.containsKey(elm))put(elm,amount);
    else replace(elm,get(elm)+amount);
  }
  public void addOne(T elm){
    add(elm,1);
  }
  public void remove(T elm,int amount){
    replace(elm,Math.max(get(elm)-amount,0));
  }
  public void removeOne(T elm){
    remove(elm,1);
  }
}
public class Main {
  static void yes(){
    System.out.println("Yes");
    System.exit(0);
  }
  static void no(){
    System.out.println("No");
    System.exit(0);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    Counter<Character>count=new Counter<>();
    for(int i=0 ; i<S.length(); i++)count.addOne(S.charAt(i));
    for(char c : count.keySet())if(count.get(c)!=2)no();
    yes();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Counter<T> extends Map(T,int) {
   static operation newCounter() : Counter
  pre: true
  post: true
  activity:
  ( var self : Counter ;
    self := createCounter();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super() );
   operation get( elm : OclAny) : int
  pre: true
  post: true
  activity: (     return getOrDefault(elm, 0) );
   operation add( elm : T, amount : int) : void
  pre: true
  post: true
  activity: (     if (not(self.containsKey(elm))) then     execute put(elm, amount) ; else     execute replace(elm, at(elm+1) + amount) ; );
   operation addOne( elm : T) : void
  pre: true
  post: true
  activity: (     execute add(elm, 1) );
   operation remove( elm : T, amount : int) : void
  pre: true
  post: true
  activity: (     execute replace(elm, Set{get(elm) - amount, 0}->max()) );
   operation removeOne( elm : T) : void
  pre: true
  post: true
  activity: (     execute remove(elm, 1) );
}
class Main {
  static   operation yes() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Yes") ; 
 OclProcess.exit(0) );
  static   operation no() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("No") ; 
 OclProcess.exit(0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    var count : Counter<String> ; count := Counter<OclAny>.newCounter() ;
        var i : int ; i := 0 ; while i < S->size() do (     count.addOne(S->at(i+1)) ;  ;     i := i + 1 ) ; 
    for (c : count.keySet()) do (     if (count->at(c+1) /= 2) then     execute no() ; else skip ;  ) ; 
    execute yes() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.PriorityQueue ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int a[]=new int[n];
    int b[]=new int[n];
    long result=0 ;
    long minB=Long.MAX_VALUE ;
    boolean same=true ;
    for(int i=0 ; i<n ; i++){
      String[] tmpArray=br.readLine().split(" ");
      a[i]=Integer.parseInt(tmpArray[0]);
      b[i]=Integer.parseInt(tmpArray[1]);
      result+=a[i];
      if(a[i]>b[i] && minB>b[i]){
        minB=b[i];
      }
      if(a[i]!=b[i]){
        same=false ;
      }
    }
    if(! same){
      result-=minB ;
    }
    else {
      result=0 ;
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var result : long ; result := 0 ;
    var minB : long ; minB := "9223372036854775807"->toLong() ;
    var same : boolean ; same := true ;
        var i : int ; i := 0 ; while i < n do ( (     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
     a[i+1] := (tmpArray[0+1])->toInteger() ; 
    b[i+1] := (tmpArray[1+1])->toInteger() ; 
    result := result+(a[i+1]) ; 
    if (a[i+1] > b[i+1] & minB > b[i+1]) then (     minB := b[i+1] ) else skip ; 
    if (a[i+1] /= b[i+1]) then (     same := false ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (not(same)) then (     result := result-(minB) ) else (     result := 0 ) ;  
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int N ;
  static final long INF=1L<<60 ;
  public static void main(String[] args){
    N=sc.nextInt();
    int[] A=new int[N];
    int[] B=new int[N];
    long a=INF ;
    long sum=0 ;
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
      B[i]=sc.nextInt();
      if(A[i]>B[i]){
        a=Math.min(a,B[i]);
      }
      sum+=A[i];
    }
    System.out.println(a==INF ? 0 : sum-a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int;
  static    attribute INF : long := (1L*(2->pow(60)))->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,N)->collect(0) ;
    var a : long ; a := INF ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() ; 
     B[i+1] := sc.getCurrent()->toInteger() ; 
     if (A[i+1] > B[i+1]) then (     a := Set{a, B[i+1]}->min() ) else skip ; 
     sum := sum+(A[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if a = INF then 0 else sum - a endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int[] a=new int[n];
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++){
      String[] sa=br.readLine().split(" ");
      a[i]=Integer.parseInt(sa[0]);
      b[i]=Integer.parseInt(sa[1]);
    }
    br.close();
    long sum=0 ;
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      sum+=a[i];
      if(a[i]>b[i]){
        min=Math.min(min,b[i]);
      }
    }
    System.out.println(min==Integer.MAX_VALUE ? 0 : sum-min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
     a[i+1] := (sa[0+1])->toInteger() ; 
     b[i+1] := (sa[1+1])->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var sum : long ; sum := 0 ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(a[i+1]) ; 
     if (a[i+1] > b[i+1]) then (     min := Set{min, b[i+1]}->min() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if min = 2147483647 then 0 else sum - min endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    Scanner sc=new Scanner(systemin);
    int N=sc.nextInt();
    int ret=-1 ;
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<N ; i++){
      int a=sc.nextInt();
      if(a<min){
        min=a ;
        ret=i ;
      }
    }
    result.printf("%d\n",ret+1);
    sc.close();
    return false ;
  }
  PrintStream log ;
  PrintStream result=System.out ;
  BufferedReader systemin ;
  static Main instance=new Main();
  Main(){
    systemin=new BufferedReader(new InputStreamReader(System.in));
    log=new PrintStream(new OutputStream(){
      public void write(int b){
      }
    }
);
  }
  public static void main(String[] args)throws IOException {
    instance.main();
    instance.systemin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(systemin) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var ret : int ; ret := -1 ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (a < min) then (     min := a ; 
     ret := i ) else skip )  ;     i := i + 1 ) ; 
    result.printf("%d\n", ret + 1) ; 
    skip ; 
    return false 
 );
   attribute log : OclFile;
   attribute result : OclFile := OclFile["System.out"];
   attribute systemin : OclFile;
  static   attribute instance : Main := Main.newMain();
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     systemin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     log := OclFile.newOclFile_Write(OclFile()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     instance.main() ; 
     instance.systemin.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int min=Integer.MAX_VALUE ;
    int minIdx=0 ;
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      if(min>x){
        min=x ;
        minIdx=i+1 ;
      }
    }
    System.out.println(minIdx);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var min : int ; min := 2147483647 ;
    var minIdx : int ; minIdx := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (min > x) then (     min := x ; 
     minIdx := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(minIdx) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static double[][] nums ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int min=Integer.MAX_VALUE ;
    int ans=0 ;
    int tmp ;
    for(int i=0 ; i<n ; i++){
      tmp=sc.nextInt();
      if(min>tmp){
        min=tmp ;
        ans=i ;
      }
    }
    System.out.println(ans+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute nums : Sequence(Sequence(double));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var min : int ; min := 2147483647 ;
    var ans : int ; ans := 0 ;
    var tmp : int ;
        var i : int ; i := 0 ; while i < n do ( (     tmp := sc.getCurrent()->toInteger() ; 
     if (min > tmp) then (     min := tmp ; 
     ans := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int min=Integer.MAX_VALUE ;
    int total=0 ;
    for(int i=1 ; i<=n ; i++){
      total+=sc.nextInt();
      min=Math.min(min,total/i);
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var min : int ; min := 2147483647 ;
    var total : int ; total := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     total := total+(sc.getCurrent()->toInteger()) ; 
     min := Set{min, total / i}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean checkcomposite(int n){
    for(int i=2 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        return true ;
      }
    }
    return false ;
  }
  static int power(int x,int y,int mod){
    int res=1 ;
    while(y!=0){
      if((y & 1)==1){
        res=(res*x)% mod ;
      }
      y=y>>1 ;
      x=(x*x)% mod ;
    }
    return res ;
  }
  static int Check(int n,int a){
    if(a>1 && checkcomposite(n)&& power(a,n-1,n)==1){
      return 1 ;
    }
    return 0 ;
  }
  public static void main(String[] args){
    int N=645 ;
    int a=2 ;
    System.out.println(Check(N,a));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkcomposite( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     return true ) else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation power( x : int, y : int, mod : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     while (y /= 0) do (     if ((y & 1) = 1) then (     res := (res * x) mod mod ) else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod mod ) ; 
     return res );
  static   operation Check( n : int, a : int) : int
  pre: true
  post: true
  activity: (     if (a > 1 & checkcomposite(n) & power(a, n - 1, n) = 1) then (     return 1 ) else skip ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 645 ;
     var a : int ; a := 2 ;
     OclFile["System.out"].println(Check(N, a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.LinkedList ;
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    LinkedList<Integer>value=new LinkedList<Integer>();
    for(int i=0 ; i<N ; i++){
      int in=sc.nextInt();
      value.add(in);
    }
    long ans=0 ;
    for(int al=0 ; al<=N && al<=K ; al++){
      int i,j ;
      for(i=0 ; i<=al ; i++){
        for(j=0 ; j<=al-i ; j++){
          LinkedList<Integer>hand=new LinkedList<Integer>();
          for(int u=0 ; u<i ; u++){
            hand.add(value.get(u));
          }
          for(int u=0 ; u<j ; u++){
            hand.add(value.get(value.size()-u-1));
          }
          Collections.sort(hand);
          for(int k=0 ; k<K-al && hand.size()>0 ; k++){
            if(hand.get(0)<0)hand.remove(0);
            else break ;
          }
          long ret=0 ;
          for(int num : hand){
            ret+=num ;
            ans=Math.max(ans,ret);
          }
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var value : Sequence(int) ; value := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var in : int ; in := sc.getCurrent()->toInteger() ;
     value := value->including(in) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var al : int ; al := 0 ; while al <= N & al <= K do ( (     var i : int ;
    var j : int ;
         i := 0 ; while i <= al do ( (         j := 0 ; while j <= al - i do ( (     var hand : Sequence(int) ; hand := Sequence{} ;
         var u : int ; u := 0 ; while u < i do ( (     hand := hand->including(value->at(u+1)) )  ;     u := u + 1 ) ; 
        var u : int ; u := 0 ; while u < j do ( (     hand := hand->including(value->at(value->size() - u - 1+1)) )  ;     u := u + 1 ) ; 
    hand := hand->sort() ; 
        var k : int ; k := 0 ; while k < K - al & hand->size() > 0 do ( (     if (hand->at(0+1) < 0) then     hand := hand->excludingAt(0+1) ; else     break )  ;     k := k + 1 ) ; 
    var ret : long ; ret := 0 ;
    for (num : hand) do ( (     ret := ret+(num) ; 
     ans := Set{ans, ret}->max() )  ) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     al := al + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Collections ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    equeue solver=new equeue();
    solver.solve(1,in,out);
    out.close();
  }
  static class equeue {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int k=in.nextInt();
      int[] v=new int[n];
      for(int i=0 ; i<n ; i++){
        v[i]=in.nextInt();
      }
      long result=0 ;
      for(int r=0 ; r<=Math.min(n,k); r++){
        for(int l=0 ; r+l<=Math.min(n,k); l++){
          long score=0 ;
          List<Integer>having=new ArrayList<>();
          for(int i=0 ; i<l ; i++){
            having.add(v[i]);
            score+=v[i];
          }
          for(int i=0 ; i<r ; i++){
            having.add(v[n-1-i]);
            score+=v[n-1-i];
          }
          Collections.sort(having);
          for(int i=0 ; i<Math.min(k-(r+l),having.size()); i++){
            if(having.get(i)<0){
              score-=having.get(i);
            }
          }
          result=Math.max(result,score);
        }
      }
      out.print(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : equeue ; solver := equeue.newequeue() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class equeue {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     v[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var result : long ; result := 0 ;
        var r : int ; r := 0 ; while r <= Set{n, k}->min() do ( (         var l : int ; l := 0 ; while r + l <= Set{n, k}->min() do ( (     var score : long ; score := 0 ;
     var having : Sequence(int) ; having := Sequence{} ;
        var i : int ; i := 0 ; while i < l do ( (     having := having->including(v[i+1]) ; 
     score := score+(v[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < r do ( (     having := having->including(v[n - 1 - i+1]) ; 
     score := score+(v[n - 1 - i+1]) )  ;     i := i + 1 ) ; 
    having := having->sort() ; 
        var i : int ; i := 0 ; while i < Set{k - (r + l), having->size()}->min() do ( (     if (having->at(i+1) < 0) then (     score := score-(having->at(i+1)) ) else skip )  ;     i := i + 1 ) ; 
    result := Set{result, score}->max() ; 
 )  ;     l := l + 1 ) )  ;     r := r + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    ArrayList<String>l=new ArrayList<>();
    int diffCnt=0 ;
    int cnt=0 ;
    for(int i=0 ; i<S.length(); i++){
      l.add(String.valueOf(S.charAt(i)));
    }
    Collections.sort(l);
    for(int i=0 ; i<l.size()-1 ; i++){
      if(l.get(i).equals(l.get(i+1))){
        diffCnt++;
      }
    }
    System.out.println(diffCnt==2 ? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    var l : Sequence(String) ; l := Sequence{} ;
    var diffCnt : int ; diffCnt := 0 ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < S->size() do ( (     l := l->including(((S->at(i+1)) + "")) )  ;     i := i + 1 ) ; 
    l := l->sort() ; 
        var i : int ; i := 0 ; while i < l->size() - 1 do ( (     if (l->at(i+1) = l->at(i + 1+1)) then (     diffCnt := diffCnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if diffCnt = 2 then "Yes" else "No" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int binomialCoeff(int n,int k){
    int[] C=new int[k+1];
    C[0]=1 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=Math.min(i,k); j>0 ; j--)C[j]=C[j]+C[j-1];
    }
    return C[k];
  }
  static int countArray(int N,int K){
    return binomialCoeff(K-1,N-1);
  }
  public static void main(String[] args){
    int N=2,K=3 ;
    System.out.println(countArray(N,K));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation binomialCoeff( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var C : Sequence(int) ; C := Integer.subrange(1,k + 1)->collect(0) ;
     C[0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := Set{i, k}->min() ; while j > 0 do (     C[j+1] := C[j+1] + C[j - 1+1] ;  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
     return C[k+1] );
  static   operation countArray( N : int, K : int) : int
  pre: true
  post: true
  activity: (     return binomialCoeff(K - 1, N - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 2 ;
    var K : int ; K := 3 ;
     OclFile["System.out"].println(countArray(N, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Map.Entry ;
class Main {
  static int mod=(int)(Math.pow(10,9)+7);
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    long[] a=new long[(int)N];
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextLong();
    }
    long ans=0 ;
    for(int i=0 ; i<K+1 ; i++){
      for(int j=0 ; j<K-i+1 ; j++){
        long[] m=new long[N];
        if(i+j>N)continue ;
        int d=K-i-j ;
        long now=0 ;
        int cnt=0 ;
        for(int l=0 ; l<i ; l++){
          m[cnt]=a[l];
          now=now+a[l];
          cnt++;
        }
        for(int r=0 ; r<j ; r++){
          m[cnt]=a[a.length-r-1];
          now=now+a[a.length-r-1];
          cnt++;
        }
        Arrays.sort(m);
        for(int n=0 ; n<d ; n++){
          if(m[n]>=0)break ;
          now=now-m[n];
        }
        ans=Math.max(ans,now);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := (10->pow(9) + 7)->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,N->oclAsType(int))->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < K + 1 do ( (         var j : int ; j := 0 ; while j < K - i + 1 do ( (     var m : Sequence(long) ; m := Integer.subrange(1,N)->collect(0) ;
     if (i + j > N) then     continue else skip ; 
    var d : int ; d := K - i - j ;
    var now : long ; now := 0 ;
    var cnt : int ; cnt := 0 ;
        var l : int ; l := 0 ; while l < i do ( (     m[cnt+1] := a[l+1] ; 
     now := now + a[l+1] ; 
     cnt := cnt + 1 )  ;     l := l + 1 ) ; 
        var r : int ; r := 0 ; while r < j do ( (     m[cnt+1] := a[a->size() - r - 1+1] ; 
     now := now + a[a->size() - r - 1+1] ; 
     cnt := cnt + 1 )  ;     r := r + 1 ) ; 
    m := m->sort() ; 
        var n : int ; n := 0 ; while n < d do ( (     if (m[n+1] >= 0) then     break else skip ; 
     now := now - m[n+1] )  ;     n := n + 1 ) ; 
    ans := Set{ans, now}->max() ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int r=Math.min(n,k);
    int[] values=new int[n];
    for(int i=0 ; i<n ; i++){
      values[i]=sc.nextInt();
    }
    int opCount=1 ;
    long max=0 ;
    while(opCount<=r){
      for(int i=0 ; i<=opCount ; i++){
        long score=calcScore(values,k,i,opCount-i);
        max=Math.max(max,score);
      }
      opCount++;
    }
    System.out.println(max);
  }
  public static long calcScore(int[] values,int k,int aCount,int bCount){
    List<Integer>list=new ArrayList<Integer>();
    for(int i=0 ; i<aCount ; i++){
      list.add(values[i]);
    }
    for(int i=values.length-1 ; i>values.length-1-bCount ; i--){
      list.add(values[i]);
    }
    Collections.sort(list);
    int canRemoveCount=k-aCount-bCount ;
    while(list.get(0)<0){
      if(canRemoveCount>0){
        list.remove(0);
        canRemoveCount--;
        if(list.isEmpty())break ;
      }
      else {
        break ;
      }
    }
    long score=0 ;
    for(Integer v : list){
      score+=(long)v ;
    }
    return score ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var r : int ; r := Set{n, k}->min() ;
    var values : Sequence(int) ; values := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     values[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var opCount : int ; opCount := 1 ;
    var max : long ; max := 0 ;
    while (opCount <= r) do (         var i : int ; i := 0 ; while i <= opCount do ( (     var score : long ; score := calcScore(values, k, i, opCount - i) ;
     max := Set{max, score}->max() )  ;     i := i + 1 ) ; 
     opCount := opCount + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static   operation calcScore( values : Sequence(int), k : int, aCount : int, bCount : int) : long
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
         var i : int ; i := 0 ; while i < aCount do ( (     list := list->including(values[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := values->size() - 1 ; while i > values->size() - 1 - bCount do ( (     list := list->including(values[i+1]) )  ;     i := i - 1 ) ; 
    list := list->sort() ; 
    var canRemoveCount : int ; canRemoveCount := k - aCount - bCount ;
    while (list->at(0+1) < 0) do (     if (canRemoveCount > 0) then (     list := list->excludingAt(0+1) ; 
     canRemoveCount := canRemoveCount - 1 ; 
     if (list->isEmpty()) then     break else skip ) else (     break ) ) ; 
    var score : long ; score := 0 ;
    for (v : list) do ( (     score := score+(v->oclAsType(long)) )  ) ; 
    return score 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    int[] V=new int[N];
    for(int i=0 ; i<V.length ; ++i){
      V[i]=sc.nextInt();
    }
    System.out.println(solve(V,K));
    sc.close();
  }
  static int solve(int[] V,int K){
    int result=0 ;
    for(int leftLength=0 ; leftLength<=V.length ; ++leftLength){
      for(int rightLength=0 ; rightLength<=Math.min(V.length,K)-leftLength ; ++rightLength){
        int sum=0 ;
        PriorityQueue<Integer>negatives=new PriorityQueue<>();
        for(int i=0 ; i<leftLength ; ++i){
          sum+=V[i];
          if(V[i]<0){
            negatives.offer(V[i]);
          }
        }
        for(int i=V.length-rightLength ; i<V.length ; ++i){
          sum+=V[i];
          if(V[i]<0){
            negatives.offer(V[i]);
          }
        }
        for(int i=0 ; i<K-leftLength-rightLength ; ++i){
          if(! negatives.isEmpty()){
            sum-=negatives.poll();
          }
        }
        result=Math.max(result,sum);
      }
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var V : Sequence(int) ; V := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < V->size() do ( (     V[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(V, K)) ; 
    skip ; 
 );
  static   operation solve( V : Sequence(int), K : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var leftLength : int ; leftLength := 0 ; while leftLength <= V->size() do ( (         var rightLength : int ; rightLength := 0 ; while rightLength <= Set{V->size(), K}->min() - leftLength do ( (     var sum : int ; sum := 0 ;
     var negatives : Sequence(int) ; negatives := Sequence{} ;
        var i : int ; i := 0 ; while i < leftLength do ( (     sum := sum+(V[i+1]) ; 
     if (V[i+1] < 0) then (     negatives := negatives->including(V[i+1]) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := V->size() - rightLength ; while i < V->size() do ( (     sum := sum+(V[i+1]) ; 
     if (V[i+1] < 0) then (     negatives := negatives->including(V[i+1]) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < K - leftLength - rightLength do ( (     if (not(negatives->isEmpty())) then (     sum := sum - (negatives->min()) ;     negatives := negatives->sort()->tail() ) else skip )  ;     i := i + 1 ) ; 
    result := Set{result, sum}->max() ; 
 )  ;     rightLength := rightLength + 1 ) )  ;     leftLength := leftLength + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int findS(int s){
    int l=1,r=(s/2)+1 ;
    while(l<=r){
      int mid=(l+r)/2 ;
      int sum=mid*(mid+1)/2 ;
      if(sum==s)return mid ;
      else if(sum>s)r=mid-1 ;
      else l=mid+1 ;
    }
    return-1 ;
  }
  static public void main(String[] args){
    int s=15 ;
    int n=findS(s);
    if(n==-1)System.out.println("-1");
    else System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findS( s : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 1 ;
    var r : int ; r := (s / 2) + 1 ;
     while (l <= r) do (     var mid : int ; mid := (l + r) / 2 ;
     var sum : int ; sum := mid * (mid + 1) / 2 ;
     if (sum = s) then     return mid else     if (sum > s) then     r := mid - 1 else     l := mid + 1 ; ;  ) ; 
     return -1 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : int ; s := 15 ;
     var n : int ; n := findS(s) ;
     if (n = -1) then     OclFile["System.out"].println("-1") ; else     OclFile["System.out"].println(n) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int setKthBit(int n,int k){
    return((1<<k)| n);
  }
  public static void main(String arg[]){
    int n=10,k=2 ;
    System.out.print("Kth bit set number="+setKthBit(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation setKthBit( n : int, k : int) : int
  pre: true
  post: true
  activity: (     return (((1*(2->pow(k)))->oclAsType(long)) or n) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
    var k : int ; k := 2 ;
     OclFile["System.out"].print("Kth bit set number=" + setKthBit(n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int i ;
    BigInteger s=new BigInteger("0");
    BigInteger x=new BigInteger("1");
    BigInteger y=new BigInteger("0");
    BigInteger[] a=new BigInteger[n];
    for(i=0 ; i<n ; i++){
      a[i]=input.nextBigInteger();
      s=s.add(a[i] .add(a[i] .subtract(x).multiply(y)));
      y=y.add(x);
    }
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var i : int ;
    var s : long ; s := long("0") ;
    var x : long ; x := long("1") ;
    var y : long ; y := long("0") ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(null) ;
        i := 0 ; while i < n do ( (     a[i+1] := input.nextBigInteger() ; 
     s := s->excludes(a[i+1]->excludes(a[i+1].subtract(x).multiply(y))) ; 
     y := y->excludes(x) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int i ;
    BigInteger s=new BigInteger("0");
    BigInteger x=new BigInteger("1");
    BigInteger y=new BigInteger("0");
    BigInteger[] a=new BigInteger[n];
    for(i=0 ; i<n ; i++){
      a[i]=input.nextBigInteger();
      s=s.add(a[i] .add(a[i] .subtract(x).multiply(y)));
      y=y.add(x);
    }
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var i : int ;
    var s : long ; s := long("0") ;
    var x : long ; x := long("1") ;
    var y : long ; y := long("0") ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(null) ;
        i := 0 ; while i < n do ( (     a[i+1] := input.nextBigInteger() ; 
     s := s->excludes(a[i+1]->excludes(a[i+1].subtract(x).multiply(y))) ; 
     y := y->excludes(x) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class codeforces {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int i,j ;
    long sum=0 ;
    long arr[]=new long[n];
    for(i=0 ; i<n ; i++){
      arr[i]=sc.nextLong();
    }
    for(i=0 ; i<n ; i++){
      sum=sum+arr[i];
      for(j=i+1 ; j<n ; j++){
        sum=sum+(arr[j]-1);
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var i : int ;
    var j : int ;
    var sum : long ; sum := 0 ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     sum := sum + arr[i+1] ; 
         j := i + 1 ; while j < n do ( (     sum := sum + (arr[j+1] - 1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int palindrome(int arr[],int begin,int end){
    if(begin>=end){
      return 1 ;
    }
    if(arr[begin]==arr[end]){
      return palindrome(arr,begin+1,end-1);
    }
    else {
      return 0 ;
    }
  }
  public static void main(String[] args){
    int a[]={
      3,6,0,6,3 };
      int n=a.length ;
      if(palindrome(a,0,n-1)==1)System.out.print("Palindrome");
      else System.out.println("Not Palindrome");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation palindrome( arr : Sequence(int), begin : int, end : int) : int
  pre: true
  post: true
  activity: (     if (begin >= end) then (     return 1 ) else skip ; 
     if (arr[begin+1] = arr[end+1]) then (     return palindrome(arr, begin + 1, end - 1) ) else (     return 0 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{3,6,0,6,3} ;
     var n : int ; n := a->size() ;
     if (palindrome(a, 0, n - 1) = 1) then     OclFile["System.out"].print("Palindrome") ; else     OclFile["System.out"].println("Not Palindrome") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map.Entry ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    char[] targ=s.toCharArray();
    HashMap<Character,Integer>map=new HashMap<>();
    for(int i=0 ; i<targ.length ; i++){
      if(! map.containsKey(targ[i])){
        map.put(targ[i],1);
      }
      else {
        map.put(targ[i],map.get(targ[i])+1);
      }
    }
    boolean ok=true ;
    for(Entry<Character,Integer>c : map.entrySet()){
      if(c.getValue()!=2){
        ok=false ;
        break ;
      }
    }
    if(ok && map.size()==2){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
    var targ : Sequence(String) ; targ := s->characters() ;
    var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < targ->size() do ( (     if (not(map->keys()->includes(targ[i+1]))) then (     map := map->union(Map{targ[i+1] |-> 1}) ) else (     map := map->union(Map{targ[i+1] |-> map->at(targ[i+1]) + 1}) ) )  ;     i := i + 1 ) ; 
    var ok : boolean ; ok := true ;
    for (c : map->asSet()) do ( (     if (c.getValue() /= 2) then (     ok := false ; 
     break ) else skip )  ) ; 
    if (ok & map.size() = 2) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printElements(int a[],int n){
    Arrays.sort(a);
    a=reverse(a);
    int cnt=1 ;
    for(int i=0 ; i<n-1 ; i++){
      if(a[i]!=a[i+1]){
        System.out.print(a[i]+" occurs "+cnt+" times\n");
        cnt=1 ;
      }
      else cnt+=1 ;
    }
    System.out.print(a[n-1]+" occurs "+cnt+" times\n");
  }
  static int[] reverse(int a[]){
    int i,n=a.length,t ;
    for(i=0 ; i<n/2 ; i++){
      t=a[i];
      a[i]=a[n-i-1];
      a[n-i-1]=t ;
    }
    return a ;
  }
  public static void main(String[] args){
    int a[]={
      1,1,1,2,3,4,9,9,10 };
      int n=a.length ;
      printElements(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printElements( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     a := reverse(a) ; 
    var cnt : int ; cnt := 1 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (a[i+1] /= a[i + 1+1]) then (     OclFile["System.out"].print(a[i+1] + " occurs " + cnt + " times\n") ; 
     cnt := 1 ) else     cnt := cnt+(1) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(a[n - 1+1] + " occurs " + cnt + " times\n") ; 
 );
  static   operation reverse( a : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var i : int ;
    var n : int ; n := a->size() ;
    var t : int ;
         i := 0 ; while i < n / 2 do ( (     t := a[i+1] ; 
     a[i+1] := a[n - i - 1+1] ; 
     a[n - i - 1+1] := t )  ;     i := i + 1 ) ; 
     return a );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,1,1,2,3,4,9,9,10} ;
     var n : int ; n := a->size() ;
     execute printElements(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1574 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int A=in.nextInt();
      int B=in.nextInt();
      int C=in.nextInt();
      int M=in.nextInt();
      int sum=A+B+C ;
      int max=Math.max(Math.max(A,B),C);
      int maxPairs=sum-3 ;
      int minPairs=Math.max(0,max-1-(sum-max));
      boolean possible=(minPairs<=M)&&(M<=maxPairs);
      System.out.println(possible ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1574 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var A : int ; A := in.getCurrent()->toInteger() ;
     var B : int ; B := in.getCurrent()->toInteger() ;
    var C : int ; C := in.getCurrent()->toInteger() ;
    var M : int ; M := in.getCurrent()->toInteger() ;
    var sum : int ; sum := A + B + C ;
    var max : int ; max := Set{Set{A, B}->max(), C}->max() ;
    var maxPairs : int ; maxPairs := sum - 3 ;
    var minPairs : int ; minPairs := Set{0, max - 1 - (sum - max)}->max() ;
    var possible : boolean ; possible := (minPairs <= M) & (M <= maxPairs) ;
    OclFile["System.out"].println(if possible then "YES" else "NO" endif) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countNum(int N,int arr[]){
    int sum=0,count=0 ;
    for(int i=0 ; i<N ; i++){
      sum+=arr[i];
    }
    for(int i=0 ; i<N ; i++){
      if((sum-arr[i])% arr[i]==0){
        count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      3,10,4,6,7 };
      int n=arr.length ;
      System.out.println(countNum(n,arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countNum( N : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
    var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < N do ( (     if ((sum - arr[i+1]) mod arr[i+1] = 0) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,10,4,6,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countNum(n, arr)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countNum(int N,int arr[]){
    int count=0 ;
    for(int i=0 ; i<N ; i++){
      int sum=0 ;
      for(int j=0 ; j<N ; j++){
        if(i==j)continue ;
        else sum+=arr[j];
      }
      if(sum % arr[i]==0)count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      3,10,4,6,7 };
      int n=arr.length ;
      System.out.println(countNum(n,arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countNum( N : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < N do ( (     if (i = j) then     continue else     sum := sum+(arr[j+1]) ; )  ;     j := j + 1 ) ; 
     if (sum mod arr[i+1] = 0) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,10,4,6,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countNum(n, arr)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int count=0 ;
    int maxH=0 ;
    for(int i=0 ; i<N ; i++){
      int h=sc.nextInt();
      if(maxH>h){
        continue ;
      }
      maxH=h ;
      count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var maxH : int ; maxH := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var h : int ; h := sc.getCurrent()->toInteger() ;
     if (maxH > h) then (     continue ) else skip ; 
     maxH := h ; 
     count := count + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BGreatOceanView solver=new BGreatOceanView();
    solver.solve(1,in,out);
    out.close();
  }
  static class BGreatOceanView {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int N=in.nextInt();
      int H[]=new int[N];
      for(int i=0 ; i<N ; i++){
        H[i]=in.nextInt();
      }
      int nb=1 ;
      int start=H[0];
      for(int i=1 ; i<N ; i++){
        if(H[i]>=start){
          start=H[i];
          nb++;
        }
      }
      out.println(nb);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BGreatOceanView ; solver := BGreatOceanView.newBGreatOceanView() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BGreatOceanView {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
     var H : Sequence(int) ; H := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     H[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var nb : int ; nb := 1 ;
    var start : int ; start := H[0+1] ;
        var i : int ; i := 1 ; while i < N do ( (     if (H[i+1] >= start) then (     start := H[i+1] ; 
     nb := nb + 1 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sc.nextLine();
    List<Integer>tmp=Arrays.stream(sc.nextLine().split(" ")).map(e->Integer.valueOf(e)).collect(Collectors.toList());
    int available=0 ;
    int preMax=-1 ;
    for(int tar : tmp){
      if(preMax<=tar){
        preMax=tar ;
        available++;
      }
    }
    System.out.println(available);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var tmp : Sequence(int) ; tmp := stream(sc.nextLine()->split(" "))->collect( _x1 | (lambda e : OclAny in (e)->toInteger())->apply(_x1) ).collect(Collectors.toList()) ;
    var available : int ; available := 0 ;
    var preMax : int ; preMax := -1 ;
    for (tar : tmp) do ( (     if (preMax <= tar) then (     preMax := tar ; 
     available := available + 1 ) else skip )  ) ; 
    OclFile["System.out"].println(available) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    in.readLine();
    String[] d=in.readLine().split(" ");
    byte max=Byte.MIN_VALUE ;
    byte num=0 ;
    Byte h ;
    for(String c : d){
      h=Byte.valueOf(c);
      if(h>=max){
        num++;
        max=h ;
      }
    }
    System.out.print(num);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     skip ; 
    var d : Sequence(String) ; d := in.readLine()->split(" ") ;
    var max : int ; max := -128 ;
    var num : int ; num := 0 ;
    var h : int ;
    for (c : d) do ( (     h := (c)->toInteger() ; 
     if (h >= max) then (     num := num + 1 ; 
     max := h ) else skip )  ) ; 
    OclFile["System.out"].print(num) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int hotel=sc.nextInt();
    ArrayList<Integer>mountains=new ArrayList<Integer>();
    for(int i=0 ; i<hotel ; i++){
      final int mountain=sc.nextInt();
      mountains.add(mountain);
    }
    int firstHotel=mountains.get(0);
    int largestHotel=mountains.get(0);
    int result=0 ;
    for(int j=1 ; j<hotel ; j++){
      if(firstHotel<=mountains.get(j)&& largestHotel<=mountains.get(j)){
        largestHotel=mountains.get(j);
        result++;
      }
    }
    System.out.println(result+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var hotel : int ; hotel := sc.getCurrent()->toInteger() ;
    var mountains : Sequence(int) ; mountains := Sequence{} ;
        var i : int ; i := 0 ; while i < hotel do ( (     var mountain : int ; mountain := sc.getCurrent()->toInteger() ;
     mountains := mountains->including(mountain) )  ;     i := i + 1 ) ; 
    var firstHotel : int ; firstHotel := mountains->at(0+1) ;
    var largestHotel : int ; largestHotel := mountains->at(0+1) ;
    var result : int ; result := 0 ;
        var j : int ; j := 1 ; while j < hotel do ( (     if (firstHotel <= mountains->at(j+1) & largestHotel <= mountains->at(j+1)) then (     largestHotel := mountains->at(j+1) ; 
     result := result + 1 ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(result + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  static final PrintStream out=System.out ;
  static Scanner sc=new Scanner(System.in);
  static final long Mod=1000_000_007L ;
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
    System.exit(0);
  }
  void solve(){
    String S=next();
    char[] cArray=S.toCharArray();
    String res="No" ;
    for(int i=1 ; i<cArray.length ; i++){
      if(cArray[0]==cArray[i]){
        int ti=0,tj=0 ;
        if(i==1){
          ti=2 ;
          tj=3 ;
        }
        if(i==2){
          ti=1 ;
          tj=3 ;
        }
        if(i==3){
          ti=1 ;
          tj=2 ;
        }
        if(cArray[ti]==cArray[tj]){
          if(cArray[ti]!=cArray[i]){
            res="Yes" ;
          }
        }
      }
    }
    out.println(res);
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
  public String next(){
    return sc.next();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute out : OclFile := OclFile["System.out"];
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute Mod : long := 1000_000_007L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() ; 
 OclProcess.exit(0) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var S : String ; S := next() ;
     var cArray : Sequence(String) ; cArray := S->characters() ;
    var res : String ; res := "No" ;
        var i : int ; i := 1 ; while i < cArray->size() do ( (     if (cArray[0+1] = cArray[i+1]) then (     var ti : int ; ti := 0 ;
    var tj : int ; tj := 0 ;
     if (i = 1) then (     ti := 2 ; 
     tj := 3 ) else skip ; 
    if (i = 2) then (     ti := 1 ; 
     tj := 3 ) else skip ; 
    if (i = 3) then (     ti := 1 ; 
     tj := 2 ) else skip ; 
    if (cArray[ti+1] = cArray[tj+1]) then (     if (cArray[ti+1] /= cArray[i+1]) then (     res := "Yes" ) else skip ) else skip ; 
 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation next() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    int[] num={
      0,6,2,8,3,4,5,7,1,9 };
      char[] ch={
        'Z','X','W','G','H','R','F','V','O','E' };
        String[] word={
          "ZERO","SIX","TWO","EIGHT","THREE","FOUR","FIVE","SEVEN","ONE","NINE" };
          for(int zz=1 ; zz<=T ; zz++){
            String S=in.next();
            int[] C=new int[26];
            for(int i=0 ; i<S.length(); i++){
              C[(int)(S.charAt(i)-'A')]++;
            }
            int[] ans=new int[10];
            for(int i=0 ; i<10 ; i++){
              int count=C[(int)(ch[i]-'A')];
              ans[num[i] ]+=count ;
              for(int j=0 ; j<word[i] .length(); j++){
                C[(int)(word[i] .charAt(j)-'A')]-=count ;
              }
            }
            for(int i=0 ; i<10 ; i++){
              if(C[i]!=0){
                throw new RuntimeException();
              }
            }
            System.out.format("Case #%d: ",zz);
            for(int i=0 ; i<10 ; i++)for(int j=0 ; j<ans[i]; j++)System.out.print(i);
            System.out.println();
          }
        }
      }

------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
    var num : Sequence(int) ; num := Sequence{0,6,2,8,3,4,5,7,1,9} ;
    var ch : Sequence(String) ; ch := Sequence{'Z','X','W','G','H','R','F','V','O','E'} ;
    var word : Sequence(String) ; word := Sequence{"ZERO","SIX","TWO","EIGHT","THREE","FOUR","FIVE","SEVEN","ONE","NINE"} ;
        var zz : int ; zz := 1 ; while zz <= T do ( (     var S : String ; S := in.getCurrent() ;
     var C : Sequence(int) ; C := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < S->size() do ( (     C[(S->at(i+1) - ('A')->char2byte())->oclAsType(int)+1] := C[(S->at(i+1) - ('A')->char2byte())->oclAsType(int)+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < 10 do ( (     var count : int ; count := C[(ch[i+1] - ('A')->char2byte())->oclAsType(int)+1] ;
     ans[num[i+1]+1] := ans[num[i+1]+1]+(count) ; 
         var j : int ; j := 0 ; while j < word[i+1]->size() do ( (     C[(word[i+1]->at(j+1) - ('A')->char2byte())->oclAsType(int)+1] := C[(word[i+1]->at(j+1) - ('A')->char2byte())->oclAsType(int)+1]-(count) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 10 do ( (     if (C[i+1] /= 0) then (     error ProgramException() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].format("Case #%d: ", zz) ; 
        var i : int ; i := 0 ; while i < 10 do (         var j : int ; j := 0 ; while j < ans[i+1] do (     OclFile["System.out"].print(i) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     zz := zz + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package r1b2016 ;
import java.io.File ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class A {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(new File("A.out"));
    for(int t=Integer.valueOf(in.nextLine()),cs=1 ; t>0 ; t--,cs++){
      out.print("Case #"+cs+": ");
      int[] cnt=new int[256];
      char[] s=in.next().toCharArray();
      for(char c : s){
        cnt[c]++;
      }
      int[] ans=new int[10];
      for(int i=0 ; i<10 ; i++){
        while(cnt[oo[i] ]>0){
          ans[dd[i] ]++;
          for(int j=0 ; j<ss[i] .length(); j++){
            cnt[ss[i] .charAt(j)]--;
          }
        }
      }
      for(int i=0 ; i<10 ; i++){
        for(int j=0 ; j<ans[i]; j++){
          out.print(i);
        }
      }
      out.println();
    }
    out.flush();
  }
  static char[] oo={
    'X','G','U','W','Z','F','V','R','I','O' };
    static String[] ss={
      "SIX","EIGHT","FOUR","TWO","ZERO","FIVE","SEVEN","THREE","NINE","ONE" };
      static int[] dd={
        6,8,4,2,0,5,7,3,9,1 };
      }

------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("A.out")) ;
         var t : int ; t := (in.nextLine())->toInteger() ;
    var cs : int ; cs := 1 ; while t > 0 do ( (     skip ; 
     var cnt : Sequence(int) ; cnt := Integer.subrange(1,256)->collect(0) ;
    var s : Sequence(String) ; s := in.getCurrent()->characters() ;
    for (c : s) do ( (     cnt[c+1] := cnt[c+1] + 1 )  ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < 10 do ( (     while (cnt[oo[i+1]+1] > 0) do (     ans[dd[i+1]+1] := ans[dd[i+1]+1] + 1 ; 
         var j : int ; j := 0 ; while j < ss[i+1]->size() do ( (     cnt[ss[i+1]->at(j+1)+1] := cnt[ss[i+1]->at(j+1)+1] - 1 )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < ans[i+1] do ( (     skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     t := t - 1 ;     cs := cs + 1 ) ; 
     skip );
  static   attribute oo : Sequence(String) := Sequence{'X','G','U','W','Z','F','V','R','I','O'};
  static   attribute ss : Sequence(String) := Sequence{"SIX","EIGHT","FOUR","TWO","ZERO","FIVE","SEVEN","THREE","NINE","ONE"};
  static   attribute dd : Sequence(int) := Sequence{6,8,4,2,0,5,7,3,9,1};
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws InterruptedException {
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Solution solution=new Solution();
    solution.solve(in,out);
    out.close();
  }
  static class Solution {
    int t ;
    public void solve(InputReader in,PrintWriter out){
      t=in.nextInt();
      while(t>0){
        int a,b,c,m ;
        a=in.nextInt();
        b=in.nextInt();
        c=in.nextInt();
        m=in.nextInt();
        if(a<b){
          int t=a ;
          a=b ;
          b=t ;
        }
        if(a<c){
          int t=a ;
          a=c ;
          c=t ;
        }
        if(b<c){
          int t=b ;
          b=c ;
          c=t ;
        }
        int max=a+b+c-3 ;
        a=a-b+c ;
        b=c ;
        a=a-b-c-1 ;
        int min=Math.max(0,a);
        out.println((m>=min && m<=max)? "YES" : "NO");
        t--;
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public char nextChar(){
      return next().charAt(0);
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solution : Solution ; solution := Solution.newSolution() ;
    solution.solve(in, out) ; 
    skip ; 
 );
  static class Solution {
   attribute t : int;
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     t := in.nextInt() ; 
     while (t > 0) do (     var a : int ;
    var b : int ;
    var c : int ;
    var m : int ;
     a := in.nextInt() ; 
    b := in.nextInt() ; 
    c := in.nextInt() ; 
    m := in.nextInt() ; 
    if (a < b) then (     var t : int ; t := a ;
     a := b ; 
     b := t ) else skip ; 
    if (a < c) then (     var t : int ; t := a ;
     a := c ; 
     c := t ) else skip ; 
    if (b < c) then (     var t : int ; t := b ;
     b := c ; 
     c := t ) else skip ; 
    var max : int ; max := a + b + c - 3 ;
    a := a - b + c ; 
    b := c ; 
    a := a - b - c - 1 ; 
    var min : int ; min := Set{0, a}->max() ;
    skip ; 
    t := t - 1 ; 
 ) );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class GuessThePermutation {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int[] a=new int[n];
      boolean f=false ;
      for(int j=0 ; j<n ; j++){
        a[j]=sc.nextInt();
        if(a[j]==n-1)f=true ;
        if(a[j]==0)a[i]=n ;
      }
      if(f){
        for(int j=0 ; j<n ; j++){
          System.out.print(a[j]+" ");
        }
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GuessThePermutation {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
     var f : boolean ; f := false ;
         var j : int ; j := 0 ; while j < n do ( (     a[j+1] := sc.getCurrent()->toInteger() ; 
     if (a[j+1] = n - 1) then     f := true ; else skip ; 
     if (a[j+1] = 0) then     a[i+1] := n ; else skip )  ;     j := j + 1 ) ; 
     if (f) then (         var j : int ; j := 0 ; while j < n do ( (     OclFile["System.out"].print(a[j+1] + " ") )  ;     j := j + 1 ) ; 
     break ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class JavaApplication34 {
  public static FastReader input=new FastReader();
  static Queue<Integer>pres=new ArrayDeque<Integer>();
  static Map<Integer,Integer>map=new TreeMap();
  public static void main(String[] args)throws IOException {
    int n=input.ni();
    Set<Integer>s=new TreeSet<>();
    for(int i=1 ; i<=n ; i++)s.add(i);
    for(int i=0 ; i<n ; i++){
      int max=0 ;
      for(int x=0 ; x<n ; x++)max=Math.max(max,input.ni());
      for(int z=max ; z<=n ; z++){
        if(s.contains(z)){
          System.out.print(z+" ");
          s.remove(z);
          break ;
        }
      }
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in),32768);
      st=null ;
    }
    String next()throws IOException {
      while(st==null || ! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(Exception e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    int ni()throws IOException {
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication34 {
  static   attribute input : FastReader := FastReader.newFastReader();
  static   attribute pres : Sequence(int) := ArrayDeque<int>.newArrayDeque();
  static   attribute map : Map(int,int) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := input.ni() ;
     var s : Set(int) ; s := Set{} ;
         var i : int ; i := 1 ; while i <= n do (     s := s->including(i) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     var max : int ; max := 0 ;
         var x : int ; x := 0 ; while x < n do (     max := Set{max, input.ni()}->max() ;  ;     x := x + 1 ) ; 
         var z : int ; z := max ; while z <= n do ( (     if (s->includes(z)) then (     OclFile["System.out"].print(z + " ") ; 
     s := s->excludingAt(z+1) ; 
     break ) else skip )  ;     z := z + 1 ) )  ;     i := i + 1 ) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 32768) ; 
     st := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class JavaApplication34 {
  public static FastReader input=new FastReader();
  static Queue<Integer>pres=new ArrayDeque<Integer>();
  static Map<Integer,Integer>map=new TreeMap();
  public static void main(String[] args)throws IOException {
    int n=input.ni();
    Set<Integer>s=new TreeSet<>();
    for(int i=1 ; i<=n ; i++)s.add(i);
    for(int i=0 ; i<n ; i++){
      PriorityQueue<Integer>pr=new PriorityQueue<>(Collections.reverseOrder());
      for(int x=0 ; x<n ; x++){
        pr.add(input.ni());
      }
      for(int z=pr.peek(); z<=n ; z++){
        if(s.contains(z)){
          System.out.print(z+" ");
          s.remove(z);
          break ;
        }
      }
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in),32768);
      st=null ;
    }
    String next()throws IOException {
      while(st==null || ! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(Exception e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    int ni()throws IOException {
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication34 {
  static   attribute input : FastReader := FastReader.newFastReader();
  static   attribute pres : Sequence(int) := ArrayDeque<int>.newArrayDeque();
  static   attribute map : Map(int,int) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := input.ni() ;
     var s : Set(int) ; s := Set{} ;
         var i : int ; i := 1 ; while i <= n do (     s := s->including(i) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     var pr : Sequence(int) ; pr := Sequence{}->union(reverseOrder()) ;
         var x : int ; x := 0 ; while x < n do ( (     pr := pr->including(input.ni()) )  ;     x := x + 1 ) ; 
         var z : int ; z := pr->min() ; while z <= n do ( (     if (s->includes(z)) then (     OclFile["System.out"].print(z + " ") ; 
     s := s->excludingAt(z+1) ; 
     break ) else skip )  ;     z := z + 1 ) )  ;     i := i + 1 ) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 32768) ; 
     st := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedHashSet ;
import java.util.Scanner ;
public class Solution {
  public static void main(String...args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    LinkedHashSet<Integer>set=new LinkedHashSet<>();
    boolean b=false ;
    for(int i=0 ; i<n ; i++){
      set.clear();
      for(int j=0 ; j<n ; j++){
        set.add(in.nextInt());
        if(set.size()==n){
          b=true ;
          break ;
        }
      }
      if(b)break ;
    }
    for(int i : set){
      if(i==0)System.out.print(n+" ");
      else System.out.print(i+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
    var b : boolean ; b := false ;
        var i : int ; i := 0 ; while i < n do ( (     set := set->intersection(Set{}) ; 
         var j : int ; j := 0 ; while j < n do ( (     set := set->including(in.getCurrent()->toInteger()) ; 
     if (set->size() = n) then (     b := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (b) then     break else skip )  ;     i := i + 1 ) ; 
    for (i : set) do ( (     if (i = 0) then     OclFile["System.out"].print(n + " ") ; else     OclFile["System.out"].print(i + " ") ; )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication {
  static Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    int l=in.nextInt(),b=in.nextInt();
    for(int i=1 ; i<Integer.MAX_VALUE ; i++){
      l*=3 ;
      b*=2 ;
      if(l>b){
        System.out.println(i);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i < 2147483647 do ( (     l := l*(3) ; 
     b := b*(2) ; 
     if (l > b) then (     OclFile["System.out"].println(i) ; 
     return ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class code {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int a=scan.nextInt();
    int b=scan.nextInt();
    int year=0 ;
    while(a<=b){
      a*=3 ;
      b*=2 ;
      year++;
    }
    System.out.println(year);
  }
}
------------------------------------------------------------
OCL File:
---------
 class code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    var year : int ; year := 0 ;
    while (a <= b) do (     a := a*(3) ; 
     b := b*(2) ; 
     year := year + 1 ) ; 
    OclFile["System.out"].println(year) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int limakw=sc.nextInt();
    int Bobw=sc.nextInt();
    int year=0 ;
    for(int i=0 ; i<18 ; i++){
      limakw*=3 ;
      Bobw*=2 ;
      year++;
      if(limakw>Bobw)break ;
    }
    System.out.println(year);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var limakw : int ; limakw := sc.getCurrent()->toInteger() ;
    var Bobw : int ; Bobw := sc.getCurrent()->toInteger() ;
    var year : int ; year := 0 ;
        var i : int ; i := 0 ; while i < 18 do ( (     limakw := limakw*(3) ; 
     Bobw := Bobw*(2) ; 
     year := year + 1 ; 
     if (limakw > Bobw) then     break else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(year) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.*;
import static java.lang.Math.max ;
public class Main {
  public static void main(String args[])throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Map<String,Integer>map=new HashMap<>();
    map.put("AC",0);
    map.put("WA",0);
    map.put("TLE",0);
    map.put("RE",0);
    while(n-->0){
      String word=sc.next();
      map.put(word,map.get(word)+1);
    }
    System.out.println("AC "+"x "+map.get("AC"));
    System.out.println("WA "+"x "+map.get("WA"));
    System.out.println("TLE "+"x "+map.get("TLE"));
    System.out.println("RE "+"x "+map.get("RE"));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var map : Map(String,int) ; map := Map{} ;
    map := map->union(Map{"AC" |-> 0}) ; 
    map := map->union(Map{"WA" |-> 0}) ; 
    map := map->union(Map{"TLE" |-> 0}) ; 
    map := map->union(Map{"RE" |-> 0}) ; 
        while (n > 0) do (        n := n - 1 ;     skip ; (     var word : String ; word := sc.getCurrent() ;
     map := map->union(Map{word |-> map->at(word) + 1}) ) ;  ) ;  
    OclFile["System.out"].println("AC " + "x " + map->at("AC")) ; 
    OclFile["System.out"].println("WA " + "x " + map->at("WA")) ; 
    OclFile["System.out"].println("TLE " + "x " + map->at("TLE")) ; 
    OclFile["System.out"].println("RE " + "x " + map->at("RE")) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class main {
  public static void main(String[] arge){
    Scanner in=new Scanner(System.in);
    int a,b,c=0 ;
    a=in.nextInt();
    b=in.nextInt();
    while(a<=b){
      c++;
      a*=3 ;
      b*=2 ;
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( arge : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ;
    var b : int ;
    var c : int ; c := 0 ;
    a := in.getCurrent()->toInteger() ; 
    b := in.getCurrent()->toInteger() ; 
    while (a <= b) do (     c := c + 1 ; 
     a := a*(3) ; 
     b := b*(2) ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int c=A-B ;
    int d=A+B ;
    int e=A*B ;
    int ans=0 ;
    if(c>d){
      ans=c ;
    }
    else {
      ans=d ;
    }
    if(ans>e){
      System.out.println(ans);
    }
    else {
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var c : int ; c := A - B ;
    var d : int ; d := A + B ;
    var e : int ; e := A * B ;
    var ans : int ; ans := 0 ;
    if (c > d) then (     ans := c ) else (     ans := d ) ;  
    if (ans > e) then (     OclFile["System.out"].println(ans) ) else (     OclFile["System.out"].println(e) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    long a=sc.nextLong();
    long b=sc.nextLong();
    long ans=Math.max(a+b,Math.max(a-b,a*b));
    System.out.println(ans);
  }
  static class MyScanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),1<<15);
    StringTokenizer tokenizer ;
    String next(){
      try {
        while(tokenizer==null || ! tokenizer.hasMoreTokens()){
          tokenizer=new StringTokenizer(reader.readLine());
        }
      }
      catch(IOException ignored){
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var a : long ; a := sc.nextLong() ;
    var b : long ; b := sc.nextLong() ;
    var ans : long ; ans := Set{a + b, Set{a - b, a * b}->max()}->max() ;
    OclFile["System.out"].println(ans) ; 
 );
  static class MyScanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (1*(2->pow(15)))->oclAsType(long));
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (ignored : IOException) do skip
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int a[]=new int[3];
      for(int i=0 ; i<3 ; i++){
        a[i]=sc.nextInt();
      }
      int m=sc.nextInt();
      int max_pairs=(a[0]-1)+(a[1]-1)+(a[2]-1);
      Arrays.sort(a);
      int min_pairs=a[2]-a[1]-a[0]-1 ;
      if(m>=min_pairs && m<=max_pairs)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
         var i : int ; i := 0 ; while i < 3 do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var max_pairs : int ; max_pairs := (a[0+1] - 1) + (a[1+1] - 1) + (a[2+1] - 1) ;
    a := a->sort() ; 
    var min_pairs : int ; min_pairs := a[2+1] - a[1+1] - a[0+1] - 1 ;
    if (m >= min_pairs & m <= max_pairs) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Collections ;
import java.util.Arrays ;
public class Main {
  static final Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int A=sc.nextInt();
    int B=sc.nextInt();
    System.out.println(Math.max(Math.max(A+B,A-B),A*B));
  }
  static void sort(int[] a,int b){
    if(b==0){
      Arrays.sort(a);
      int t=0 ;
      int c=a.length-1 ;
      for(int i=c ; i>=c/2+1 ; i--){
        t=a[i];
        a[i]=a[c-i];
        a[c-i]=t ;
      }
    }
    else {
      Arrays.sort(a);
    }
  }
  static int SI(String a){
    return Integer.parseInt(a);
  }
  static char SC(String a){
    return a.charAt(0);
  }
  static double SD(String a){
    return new Double(a).doubleValue();
  }
  static String CS(char a){
    return String.valueOf(a);
  }
  static int DI(double a){
    return new Double(a).intValue();
  }
  static String DS(double a){
    return Double.toString(a);
  }
  static int LI(long a){
    return new Long(a).intValue();
  }
  static char LC(long a){
    return Long.toString(a).charAt(0);
  }
  static double LD(long a){
    return new Long(a).doubleValue();
  }
  static long IL(int a){
    return new Integer(a).longValue();
  }
  static double ID(int a){
    return new Integer(a).doubleValue();
  }
  static char IC(int a){
    return Integer.toString(a).charAt(0);
  }
  static String IS(int a){
    return Integer.toString(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(Set{Set{A + B, A - B}->max(), A * B}->max()) );
  static   operation sort( a : Sequence(int), b : int) : void
  pre: true
  post: true
  activity: (     if (b = 0) then (     a := a->sort() ; 
     var t : int ; t := 0 ;
     var c : int ; c := a->size() - 1 ;
         var i : int ; i := c ; while i >= c / 2 + 1 do ( (     t := a[i+1] ; 
     a[i+1] := a[c - i+1] ; 
     a[c - i+1] := t )  ;     i := i - 1 ) ) else (     a := a->sort() ) );
  static   operation SI( a : String) : int
  pre: true
  post: true
  activity: (     return (a)->toInteger() );
  static   operation SC( a : String) : String
  pre: true
  post: true
  activity: (     return a->at(0+1) );
  static   operation SD( a : String) : double
  pre: true
  post: true
  activity: (     return ("" + (a))->toReal()->oclAsType(double) );
  static   operation CS( a : String) : String
  pre: true
  post: true
  activity: (     return ((a) + "") );
  static   operation DI( a : double) : int
  pre: true
  post: true
  activity: (     return ("" + (a))->toReal()->oclAsType(int) );
  static   operation DS( a : double) : String
  pre: true
  post: true
  activity: (     return ((a) + "") );
  static   operation LI( a : long) : int
  pre: true
  post: true
  activity: (     return ("" + (a))->toLong()->oclAsType(int) );
  static   operation LC( a : long) : String
  pre: true
  post: true
  activity: (     return ((a) + "")->at(0+1) );
  static   operation LD( a : long) : double
  pre: true
  post: true
  activity: (     return ("" + (a))->toLong()->oclAsType(double) );
  static   operation IL( a : int) : long
  pre: true
  post: true
  activity: (     return ("" + (a))->toInteger()->oclAsType(long) );
  static   operation ID( a : int) : double
  pre: true
  post: true
  activity: (     return ("" + (a))->toInteger()->oclAsType(double) );
  static   operation IC( a : int) : String
  pre: true
  post: true
  activity: (     return ((a) + "")->at(0+1) );
  static   operation IS( a : int) : String
  pre: true
  post: true
  activity: (     return ((a) + "") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int[] compare={
      a-b,a+b,a*b };
      int max=compare[0];
      for(int i=1 ; i<compare.length ; i++){
        if(max<compare[i]){
          max=compare[i];
        }
      }
      System.out.println(max);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var compare : Sequence(int) ; compare := Sequence{a - b,a + b,a * b} ;
    var max : int ; max := compare[0+1] ;
        var i : int ; i := 1 ; while i < compare->size() do ( (     if (max < compare[i+1]) then (     max := compare[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] value=br.readLine().split(" ");
    int a=Integer.parseInt(value[0]);
    int b=Integer.parseInt(value[1]);
    System.out.println(Math.max(a*b,Math.max(a+b,a-b)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var value : Sequence(String) ; value := br.readLine()->split(" ") ;
    var a : int ; a := (value[0+1])->toInteger() ;
    var b : int ; b := (value[1+1])->toInteger() ;
    OclFile["System.out"].println(Set{a * b, Set{a + b, a - b}->max()}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printAllKLength(char[] set,int k){
    int n=set.length ;
    printAllKLengthRec(set,"",n,k);
  }
  static void printAllKLengthRec(char[] set,String prefix,int n,int k){
    if(k==0){
      System.out.println(prefix);
      return ;
    }
    for(int i=0 ; i<n ; ++i){
      String newPrefix=prefix+set[i];
      printAllKLengthRec(set,newPrefix,n,k-1);
    }
  }
  public static void main(String[] args){
    System.out.println("First Test");
    char[] set1={
      'a','b' };
      int k=3 ;
      printAllKLength(set1,k);
      System.out.println("\nSecond Test");
      char[] set2={
        'a','b','c','d' };
        k=1 ;
        printAllKLength(set2,k);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printAllKLength( set : Sequence(String), k : int) : void
  pre: true
  post: true
  activity: (     var n : int ; n := set->size() ;
     execute printAllKLengthRec(set, "", n, k) );
  static   operation printAllKLengthRec( set : Sequence(String), prefix : String, n : int, k : int) : void
  pre: true
  post: true
  activity: (     if (k = 0) then (     OclFile["System.out"].println(prefix) ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     var newPrefix : String ; newPrefix := prefix + set[i+1] ;
     execute printAllKLengthRec(set, newPrefix, n, k - 1) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("First Test") ; 
     var set1 : Sequence(String) ; set1 := Sequence{'a','b'} ;
    var k : int ; k := 3 ;
    execute printAllKLength(set1, k) ; 
    OclFile["System.out"].println("\nSecond Test") ; 
    var set2 : Sequence(String) ; set2 := Sequence{'a','b','c','d'} ;
    k := 1 ; 
    execute printAllKLength(set2, k) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int calcNodes(int N,int I){
    int result=0 ;
    result=I*(N-1)+1 ;
    return result ;
  }
  public static void main(String[] args){
    int N=5,I=2 ;
    System.out.println("Leaf nodes="+calcNodes(N,I));
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation calcNodes( N : int, I : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     result := I * (N - 1) + 1 ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
    var I : int ; I := 2 ;
     OclFile["System.out"].println("Leaf nodes=" + calcNodes(N, I)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int n ;
  static int[] bit ;
  static void add(int x,int y){
    for(int i=x ; i<=n ; i+=i &(-i)){
      bit[i]+=y ;
    }
  }
  static int sum(int x){
    int tmp=0 ;
    for(int i=x ; i>0 ; i-=i &(-i)){
      tmp+=bit[i];
    }
    return tmp ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    char[] c=s.toCharArray();
    n=s.length();
    bit=new int[n+1];
    int k=sc.nextInt();
    ArrayList<ArrayDeque<Integer>>list=new ArrayList<ArrayDeque<Integer>>();
    for(int i=0 ; i<26 ; i++){
      ArrayDeque<Integer>add=new ArrayDeque<Integer>();
      list.add(add);
    }
    for(int i=0 ; i<n ; i++){
      list.get((int)c[i]-97).addLast(i);
      add(i+1,1);
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<26 ; j++){
        if(list.get(j).size()==0)continue ;
        int pos=list.get(j).getFirst();
        int cnt=sum(pos);
        if(cnt<=k){
          list.get(j).pollFirst();
          k-=cnt ;
          sb.append((char)(97+j));
          add(pos+1,-1);
          break ;
        }
      }
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute bit : Sequence(int);
  static   operation add( x : int, y : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := x ; while i <= n do ( (     bit[i+1] := bit[i+1]+(y) )  ;     i := i+(MathLib.bitwiseAnd(i,(-i))) ) );
  static   operation sum( x : int) : int
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := 0 ;
         var i : int ; i := x ; while i > 0 do ( (     tmp := tmp+(bit[i+1]) )  ;     i := i-(MathLib.bitwiseAnd(i,(-i))) ) ; 
     return tmp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var c : Sequence(String) ; c := s->characters() ;
    n := s->size() ; 
    bit := Integer.subrange(1,n + 1)->collect(0) ; 
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var list : Sequence(Sequence(int)) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < 26 do ( (     var add : Sequence(int) ; add := ArrayDeque<int>.newArrayDeque() ;
     list := list->including(add) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     list := list->at(c[i+1]->oclAsType(int) - 97+1)->append(i) ; 
     execute add(i + 1, 1) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 26 do ( (     if (list->at(j+1)->size() = 0) then     continue else skip ; 
     var pos : int ; pos := list->at(j+1)->first() ;
     var cnt : int ; cnt := sum(pos) ;
     if (cnt <= k) then (     list := list->at(j+1)->tail() ; 
     k := k-(cnt) ; 
    sb := sb + StringLib.newString((97 + j)->oclAsType(String)) ; 
    execute add(pos + 1, -1) ; 
    break 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.time.LocalTime ;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;
public class Main {
  public static void main(String[] args){
    FastScanner scan=new FastScanner();
    int n=scan.nextInt();
    int[] a=new int[4];
    for(int i=0 ; i<n ; i++){
      String str=scan.next();
      if(str.equals("AC"))a[0]++;
      else if(str.equals("WA"))a[1]++;
      else if(str.equals("TLE"))a[2]++;
      else a[3]++;
    }
    System.out.println("AC x "+a[0]);
    System.out.println("WA x "+a[1]);
    System.out.println("TLE x "+a[2]);
    System.out.println("RE x "+a[3]);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : FastScanner ; scan := FastScanner.newFastScanner() ;
     var n : int ; n := scan.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := scan.next() ;
     if (str = "AC") then     a[0+1] := a[0+1] + 1 ; else     if (str = "WA") then     a[1+1] := a[1+1] + 1 else     if (str = "TLE") then     a[2+1] := a[2+1] + 1 else     a[3+1] := a[3+1] + 1 ; ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("AC x " + a[0+1]) ; 
    OclFile["System.out"].println("WA x " + a[1+1]) ; 
    OclFile["System.out"].println("TLE x " + a[2+1]) ; 
    OclFile["System.out"].println("RE x " + a[3+1]) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void countPairs(int arr[],int n,int k){
    int i,j,cnt=0 ;
    for(i=0 ; i<n-1 ; i++){
      for(j=i+1 ; j<n ; j++){
        if((arr[i]-arr[j]+k)% k==0)cnt+=1 ;
      }
    }
    System.out.print(cnt+"\n");
  }
  public static void main(String[] args){
    int arr[]={
      3,3,3 };
      int k=3 ;
      int n=arr.length ;
      countPairs(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPairs( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var cnt : int ; cnt := 0 ;
         i := 0 ; while i < n - 1 do ( (         j := i + 1 ; while j < n do ( (     if ((arr[i+1] - arr[j+1] + k) mod k = 0) then     cnt := cnt+(1) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(cnt + "\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,3,3} ;
     var k : int ; k := 3 ;
     var n : int ; n := arr->size() ;
     execute countPairs(arr, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findSum(String str){
    String temp="" ;
    int sum=0 ;
    for(int i=0 ; i<str.length(); i++){
      char ch=str.charAt(i);
      if(Character.isDigit(ch))temp+=ch ;
      else {
        sum+=Integer.parseInt(temp);
        temp="0" ;
      }
    }
    return sum+Integer.parseInt(temp);
  }
  public static void main(String[] args){
    String str="12abc20yz68" ;
    System.out.println(findSum(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findSum( str : String) : int
  pre: true
  post: true
  activity: (     var temp : String ; temp := "" ;
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     var ch : String ; ch := str->at(i+1) ;
     if ((ch + "")->isMatch("[0-9]")) then     temp := temp+(ch) ; else (     sum := sum+((temp)->toInteger()) ; 
     temp := "0" ) )  ;     i := i + 1 ) ; 
     return sum + (temp)->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "12abc20yz68" ;
     OclFile["System.out"].println(findSum(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void CountTriangles(int[] A){
    int n=A.length ;
    Arrays.sort(A);
    int count=0 ;
    for(int i=n-1 ; i>=1 ; i--){
      int l=0,r=i-1 ;
      while(l<r){
        if(A[l]+A[r]>A[i]){
          count+=r-l ;
          r--;
        }
        else {
          l++;
        }
      }
    }
    System.out.print("No of possible solutions: "+count);
  }
  public static void main(String[] args){
    int[] A={
      4,3,5,7,6 };
      CountTriangles(A);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation CountTriangles( A : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := A->size() ;
     A := A->sort() ; 
    var count : int ; count := 0 ;
        var i : int ; i := n - 1 ; while i >= 1 do ( (     var l : int ; l := 0 ;
    var r : int ; r := i - 1 ;
     while (l < r) do (     if (A[l+1] + A[r+1] > A[i+1]) then (     count := count+(r - l) ; 
     r := r - 1 ) else (     l := l + 1 ) ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].print("No of possible solutions: " + count) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{4,3,5,7,6} ;
     execute CountTriangles(A) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Scanner ;
public class c {
  public static void main(String[] args)throws IOException {
    Scanner input=new Scanner(System.in);
    PrintWriter out=new PrintWriter(new File("c.txt"));
    int T=input.nextInt();
    for(int t=0 ; t<T ; t++){
      out.print("Case #"+(t+1)+": \n");
      int r=input.nextInt(),n=input.nextInt(),m=input.nextInt(),k=input.nextInt();
      for(int rr=0 ; rr<r ; rr++){
        int twopow=0,threepow=0,fivepow=0 ;
        for(int i=0 ; i<k ; i++){
          int p=input.nextInt();
          int fives=0 ;
          while(p % 5==0 && p>0){
            p/=5 ;
            fives++;
          }
          fivepow=Math.max(fives,fivepow);
          int twos=0 ;
          while(p % 2==0 && p>0){
            p/=2 ;
            twos++;
          }
          twopow=Math.max(twos,twopow);
          int threes=0 ;
          while(p % 3==0 && p>0){
            p/=3 ;
            threes++;
          }
          threepow=Math.max(threes,threepow);
        }
        int used=0 ;
        while(fivepow>0){
          used++;
          fivepow--;
          out.print(5);
        }
        while(threepow>0){
          used++;
          threepow--;
          out.print(3);
        }
        while(twopow>n-used){
          twopow-=2 ;
          used++;
          out.print(4);
        }
        while(used<n){
          used++;
          out.print(2);
        }
        out.println();
      }
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class c {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("c.txt")) ;
    var T : int ; T := input.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < T do ( (     skip ; 
     var r : int ; r := input.getCurrent()->toInteger() ;
    var n : int ; n := input.getCurrent()->toInteger() ;
    var m : int ; m := input.getCurrent()->toInteger() ;
    var k : int ; k := input.getCurrent()->toInteger() ;
         var rr : int ; rr := 0 ; while rr < r do ( (     var twopow : int ; twopow := 0 ;
    var threepow : int ; threepow := 0 ;
    var fivepow : int ; fivepow := 0 ;
         var i : int ; i := 0 ; while i < k do ( (     var p : int ; p := input.getCurrent()->toInteger() ;
     var fives : int ; fives := 0 ;
    while (p mod 5 = 0 & p > 0) do (     p := p/(5) ; 
     fives := fives + 1 ) ; 
    fivepow := Set{fives, fivepow}->max() ; 
    var twos : int ; twos := 0 ;
    while (p mod 2 = 0 & p > 0) do (     p := p/(2) ; 
     twos := twos + 1 ) ; 
    twopow := Set{twos, twopow}->max() ; 
    var threes : int ; threes := 0 ;
    while (p mod 3 = 0 & p > 0) do (     p := p/(3) ; 
     threes := threes + 1 ) ; 
    threepow := Set{threes, threepow}->max() ; 
 )  ;     i := i + 1 ) ; 
    var used : int ; used := 0 ;
    while (fivepow > 0) do (     used := used + 1 ; 
     fivepow := fivepow - 1 ; 
     skip ) ; 
    while (threepow > 0) do (     used := used + 1 ; 
     threepow := threepow - 1 ; 
     skip ) ; 
    while (twopow > n - used) do (     twopow := twopow-(2) ; 
     used := used + 1 ; 
     skip ) ; 
    while (used < n) do (     used := used + 1 ; 
     skip ) ; 
    skip ; 
 )  ;     rr := rr + 1 ) )  ;     t := t + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    while(n-->0){
      int s=scanner.nextInt();
      int g=scanner.nextInt();
      int ans=0 ;
      while(s<g){
        int to=1 ;
        while(true){
          int next=to*2 ;
          if(s % next!=0)break ;
          if(s+next>g)break ;
          to=next ;
        }
        s+=to ;
        ans++;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var s : int ; s := scanner.getCurrent()->toInteger() ;
     var g : int ; g := scanner.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    while (s < g) do (     var to : int ; to := 1 ;
     while (true) do (     var next : int ; next := to * 2 ;
     if (s mod next /= 0) then     break else skip ; 
     if (s + next > g) then     break else skip ; 
     to := next ) ; 
     s := s+(to) ; 
     ans := ans + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package codejam2013 ;
import java.io.IOException ;
abstract public class CodeJam2013 {
  abstract public void solveCases(String inputSize)throws IOException ;
  public static void main(String[] args){
    String inputSize="s1" ;
    Round1AC.main(inputSize);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeJam2013 {
      operation solveCases( inputSize : String) : void
  pre: true
  post: true;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputSize : String ; inputSize := "s1" ;
     Round1AC.main(inputSize) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Luck1 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int numCases=in.nextInt();
    int numRows=in.nextInt();
    int setSize=in.nextInt();
    int setLimit=in.nextInt();
    int numProducts=in.nextInt();
    long[] products=new long[numProducts];
    StringBuilder output=new StringBuilder();
    for(int caseNum=1 ; caseNum<=numCases ; ++caseNum){
      output.append(String.format("Case #%d:\n",caseNum));
      for(int curRow=0 ; curRow<numRows ; ++curRow){
        for(int i=0 ; i<numProducts ; ++i)products[i]=in.nextLong();
        int[] best=new int[setSize];
        Arrays.fill(best,2);
        double bestProb=0.0 ;
        for(int e1=2 ; e1<=setLimit ; ++e1){
          for(int e2=2 ; e2<=setLimit ; ++e2){
            for(int e3=2 ; e3<=setLimit ; ++e3){
              int[] tempSet=new int[] {
                e1,e2,e3 };
                double checkProb=1.0 ;
                for(int pCheck=0 ; pCheck<products.length ; ++pCheck){
                  int counter=0 ;
                  for(int bitMask=0 ; bitMask<(1<<tempSet.length); ++bitMask){
                    int checkProduct=1 ;
                    for(int bit=1,idx=0 ; bit<=bitMask ; bit<<=1,++idx){
                      if((bit & bitMask)!=0){
                        checkProduct*=tempSet[idx];
                      }
                    }
                    if(checkProduct==products[pCheck]){
++counter ;
                    }
                  }
                  checkProb*=(counter/8.0);
                }
                if(checkProb>bestProb){
                  best=tempSet ;
                  bestProb=checkProb ;
                }
              }
            }
          }
          output.append(best[0]);
          output.append(best[1]);
          output.append(best[2]);
          output.append('\n');
        }
      }
      System.out.print(output);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Luck1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numCases : int ; numCases := in.getCurrent()->toInteger() ;
    var numRows : int ; numRows := in.getCurrent()->toInteger() ;
    var setSize : int ; setSize := in.getCurrent()->toInteger() ;
    var setLimit : int ; setLimit := in.getCurrent()->toInteger() ;
    var numProducts : int ; numProducts := in.getCurrent()->toInteger() ;
    var products : Sequence(long) ; products := Integer.subrange(1,numProducts)->collect(0) ;
    var output : String ; output := StringLib.newString() ;
        var caseNum : int ; caseNum := 1 ; while caseNum <= numCases do ( (     output := output + StringLib.newString(StringLib.format("Case #%d:\n",Sequence{caseNum})) ; 
         var curRow : int ; curRow := 0 ; while curRow < numRows do ( (         var i : int ; i := 0 ; while i < numProducts do (     products[i+1] := in.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
     var best : Sequence(int) ; best := Integer.subrange(1,setSize)->collect(0) ;
    best := best->collect(2) ; 
    var bestProb : double ; bestProb := 0.0 ;
        var e1 : int ; e1 := 2 ; while e1 <= setLimit do ( (         var e2 : int ; e2 := 2 ; while e2 <= setLimit do ( (         var e3 : int ; e3 := 2 ; while e3 <= setLimit do ( (     var tempSet : Sequence(int) ; tempSet := Sequence{e1,e2,e3} ;
     var checkProb : double ; checkProb := 1.0 ;
         var pCheck : int ; pCheck := 0 ; while pCheck < products->size() do ( (     var counter : int ; counter := 0 ;
         var bitMask : int ; bitMask := 0 ; while bitMask < ((1*(2->pow(tempSet->size())))->oclAsType(long)) do ( (     var checkProduct : int ; checkProduct := 1 ;
         var bit : int ; bit := 1 ;
    var idx : int ; idx := 0 ; while bit <= bitMask do ( (     if ((MathLib.bitwiseAnd(bit,bitMask)) /= 0) then (     checkProduct := checkProduct*(tempSet[idx+1]) ) else skip )  ;     bit := bit*(2->pow(1)) ;     idx := idx + 1 ) ; 
     if (checkProduct = products[pCheck+1]) then (     counter := counter + 1 ) else skip )  ;     bitMask := bitMask + 1 ) ; 
     checkProb := checkProb*((counter / 8.0)) )  ;     pCheck := pCheck + 1 ) ; 
     if (checkProb > bestProb) then (     best := tempSet ; 
     bestProb := checkProb ) else skip )  ;     e3 := e3 + 1 ) )  ;     e2 := e2 + 1 ) )  ;     e1 := e1 + 1 ) ; 
    output := output + StringLib.newString(best[0+1]) ; 
    output := output + StringLib.newString(best[1+1]) ; 
    output := output + StringLib.newString(best[2+1]) ; 
    output := output + StringLib.newString('
') ; 
 )  ;     curRow := curRow + 1 ) )  ;     caseNum := caseNum + 1 ) ; 
    OclFile["System.out"].print(output) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class C {
  public static void main(String[] args)throws Exception {
    String path="D:\\C-small-1-attempt0" ;
    Scanner sc=new Scanner(new File(path+".in"));
    PrintWriter pw=new PrintWriter(path+".out");
    int testCases=sc.nextInt();
    for(int testCase=1 ; testCase<=testCases ; testCase++){
      int R=sc.nextInt();
      int N=sc.nextInt();
      int M=sc.nextInt();
      int K=sc.nextInt();
      pw.println("Case #"+testCase+":");
      for(int i=0 ; i<R ; i++){
        Set<Integer>s=new HashSet<Integer>();
        for(int j=0 ; j<K ; j++){
          s.add(sc.nextInt());
        }
        int[] b=new int[N+1];
        Arrays.fill(b,2);
        while(b[N]==2){
          Set<Integer>s1=new HashSet<Integer>(s);
          for(int mask=0 ; mask<1<<N ; mask++){
            int p=1 ;
            for(int j=0 ; j<N ; j++){
              if((mask &(1<<j))!=0){
                p*=b[j];
              }
            }
            s1.remove(p);
          }
          if(s1.isEmpty()){
            break ;
          }
++b[0];
          for(int j=0 ; j<N ; j++){
            if(b[j]>M){
              b[j]=2 ;
++b[j+1];
            }
          }
        }
        for(int j=0 ; j<N ; j++){
          pw.print(b[j]);
        }
        pw.println();
        pw.flush();
      }
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var path : String ; path := "D:\\C-small-1-attempt0" ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile(path + ".in")) ;
    var pw : OclFile ; pw := OclFile.newOclFile_Write(path + ".out") ;
    var testCases : int ; testCases := sc.getCurrent()->toInteger() ;
        var testCase : int ; testCase := 1 ; while testCase <= testCases do ( (     var R : int ; R := sc.getCurrent()->toInteger() ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    skip ; 
        var i : int ; i := 0 ; while i < R do ( (     var s : Set(int) ; s := Set{} ;
         var j : int ; j := 0 ; while j < K do ( (     s := s->including(sc.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,N + 1)->collect(0) ;
    b := b->collect(2) ; 
    while (b[N+1] = 2) do (     var s1 : Set(int) ; s1 := Set{}->union(s) ;
         var mask : int ; mask := 0 ; while mask < (1*(2->pow(N)))->oclAsType(long) do ( (     var p : int ; p := 1 ;
         var j : int ; j := 0 ; while j < N do ( (     if ((MathLib.bitwiseAnd(mask,((1*(2->pow(j)))->oclAsType(long)))) /= 0) then (     p := p*(b[j+1]) ) else skip )  ;     j := j + 1 ) ; 
     s1 := s1->excludingAt(p+1) )  ;     mask := mask + 1 ) ; 
    if (s1->isEmpty()) then (     break ) else skip ; 
    b[0+1] := b[0+1] + 1 ; 
        var j : int ; j := 0 ; while j < N do ( (     if (b[j+1] > M) then (     b[j+1] := 2 ; 
     b[j + 1+1] := b[j + 1+1] + 1 ) else skip )  ;     j := j + 1 ) ; 
 ) ; 
        var j : int ; j := 0 ; while j < N do ( (     skip )  ;     j := j + 1 ) ; 
    skip ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
 )  ;     testCase := testCase + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class C {
  private static int[] SET={
    4,5,3,2,1 };
    public static void main(String[] args){
      Scanner scan=new Scanner(System.in);
      int cases=scan.nextInt();
      int r,n,m,k,count ;
      int[] res ;
      long lcmAll ;
      for(int c=1 ; c<=cases ; c++){
        r=scan.nextInt();
        n=scan.nextInt();
        m=scan.nextInt();
        k=scan.nextInt();
        res=new int[n];
        System.out.println("Case #"+c+": ");
        for(int i=0 ; i<r ; i++){
          lcmAll=1 ;
          for(int j=0 ; j<k ; j++)lcmAll=lcm(lcmAll,scan.nextInt());
          count=0 ;
          for(int j : SET){
            while(count<n &&(lcmAll % j)==0){
              lcmAll/=j ;
              res[count]=j ;
              count++;
            }
          }
          if(res[0]==4 && res[n-1]==1){
            res[0]=2 ;
            res[n-1]=2 ;
          }
          for(int j : res)System.out.print(j==1 ? 2 : j);
          System.out.println();
        }
      }
    }
    private static long gcd(long a,long b){
      if(b==0)return a ;
      return gcd(b,a % b);
    }
    private static long lcm(long a,long b){
      return a/gcd(a,b)*b ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class C {
  static   attribute SET : Sequence(int) := Sequence{4,5,3,2,1};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cases : int ; cases := scan.getCurrent()->toInteger() ;
    var r : int ;
    var n : int ;
    var m : int ;
    var k : int ;
    var count : int ;
    var res : Sequence(int) ;
    var lcmAll : long ;
        var c : int ; c := 1 ; while c <= cases do ( (     r := scan.getCurrent()->toInteger() ; 
     n := scan.getCurrent()->toInteger() ; 
    m := scan.getCurrent()->toInteger() ; 
    k := scan.getCurrent()->toInteger() ; 
    res := Integer.subrange(1,n)->collect(0) ; 
    OclFile["System.out"].println("Case #" + c + ": ") ; 
        var i : int ; i := 0 ; while i < r do ( (     lcmAll := 1 ; 
         var j : int ; j := 0 ; while j < k do (     lcmAll := lcm(lcmAll, scan.getCurrent()->toInteger()) ;  ;     j := j + 1 ) ; 
    count := 0 ; 
    for (j : SET) do ( (     while (count < n & (lcmAll mod j) = 0) do (     lcmAll := lcmAll/(j) ; 
     res[count+1] := j ; 
     count := count + 1 ) )  ) ; 
    if (res[0+1] = 4 & res[n - 1+1] = 1) then (     res[0+1] := 2 ; 
     res[n - 1+1] := 2 ) else skip ; 
    for (j : res) do (     OclFile["System.out"].print(if j = 1 then 2 else j endif) ;  ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) ; 
 )  ;     c := c + 1 ) ; 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return a / gcd(a, b) * b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int __gcd(int a,int b){
    if(a==0 && b==0)return 0 ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static int findMin(int a,int b){
    return(__gcd(a,b)==1)? a*b-a-b+1 :-1 ;
  }
  public static void main(String[] args){
    int a=4 ;
    int b=7 ;
    System.out.println(findMin(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0 & b = 0) then     return 0 else skip ; 
     if (a = b) then     return a else skip ; 
     if (a > b) then     return __gcd(a - b, b) else skip ; 
     return __gcd(a, b - a) );
  static   operation findMin( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if (__gcd(a, b) = 1) then a * b - a - b + 1 else -1 endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 4 ;
     var b : int ; b := 7 ;
     OclFile["System.out"].println(findMin(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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(Exception e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  static int modPower(int x,int y,int mod){
    int res=1 ;
    x %=mod ;
    if(x==0)return 0 ;
    while(y>0){
      if(y % 2==1){
        res=(res*x)% mod ;
      }
      y=y>>1 ;
      x=(x*x)% mod ;
    }
    return res ;
  }
  static class pair<T1,T2>{
    T1 first ;
    T2 second ;
    pair(T1 first,T2 second){
      this.first=first ;
      this.second=second ;
    }
  }
  public static void main(String[] args)throws java.lang.Exception {
    FastReader in=new FastReader();
    long[] a=new long[4];
    for(int i=0 ; i<4 ; i++)a[i]=in.nextLong();
    System.out.println(Math.max(a[0]*a[2],Math.max(a[1]*a[3],Math.max(a[0]*a[3],a[1]*a[2]))));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return str );
}
  static   operation modPower( x : int, y : int, mod : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     x := x mod mod ; 
    if (x = 0) then     return 0 else skip ; 
    while (y > 0) do (     if (y mod 2 = 1) then (     res := (res * x) mod mod ) else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod mod ) ; 
    return res 
 );
  static class pair<T1,T2> {
   attribute first : T1;
   attribute second : T2;
   static operation newpair( first : T1, second : T2) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : T1, second : T2) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var a : Sequence(long) ; a := Integer.subrange(1,4)->collect(0) ;
         var i : int ; i := 0 ; while i < 4 do (     a[i+1] := in.nextLong() ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(Set{a[0+1] * a[2+1], Set{a[1+1] * a[3+1], Set{a[0+1] * a[3+1], a[1+1] * a[2+1]}->max()}->max()}->max()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void getPermutation(int a[],int n){
    int[] ans=new int[n];
    ans[0]=a[0];
    for(int i=1 ; i<n ; i++)ans[i]=a[i]-a[i-1];
    boolean[] present=new boolean[n+1];
    for(int i=0 ; i<ans.length ; i++){
      if(present[ans[i] ]){
        System.out.print("-1");
        return ;
      }
      else present[ans[i] ]=true ;
    }
    for(int i=0 ; i<n ; i++)System.out.print(ans[i]+" ");
  }
  public static void main(String[] args){
    int a[]={
      2,3,6 };
      int n=a.length ;
      getPermutation(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getPermutation( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
     ans[0+1] := a[0+1] ; 
        var i : int ; i := 1 ; while i < n do (     ans[i+1] := a[i+1] - a[i - 1+1] ;  ;     i := i + 1 ) ; 
    var present : Sequence(boolean) ; present := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 0 ; while i < ans->size() do ( (     if (present[ans[i+1]+1]) then (     OclFile["System.out"].print("-1") ; 
     return ) else     present[ans[i+1]+1] := true ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(ans[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,3,6} ;
     var n : int ; n := a->size() ;
     execute getPermutation(a, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  final static long MODULO=1_000_000_000+7 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int T=sc.nextInt();
    int[] D=new int[N];
    for(int i=0 ; i<N ; ++i){
      D[i]=sc.nextInt();
    }
    Arrays.sort(D);
    long ans=1 ;
    int s=0 ;
    for(int i=0 ; i<N ; ++i){
      while(s<i && D[s]<D[i]-T){
++s ;
      }
      ans=(ans*(i-s+1))% MODULO ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MODULO : long := 1_000_000_000 + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
    var D : Sequence(int) ; D := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     D[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    D := D->sort() ; 
    var ans : long ; ans := 1 ;
    var s : int ; s := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     while (s < i & D[s+1] < D[i+1] - T) do (     s := s + 1 ) ; 
     ans := (ans * (i - s + 1)) mod MODULO )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  final static long MODULO=1_000_000_000+7 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    int T=Integer.parseInt(sc.next());
    int[] D=new int[N];
    for(int i=0 ; i<N ; ++i){
      D[i]=Integer.parseInt(sc.next());
    }
    Arrays.sort(D);
    long ans=1 ;
    int s=0 ;
    for(int i=0 ; i<N ; ++i){
      while(s<i && D[s]<D[i]-T){
++s ;
      }
      ans=(ans*(i-s+1))% MODULO ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MODULO : long := 1_000_000_000 + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var T : int ; T := (sc.getCurrent())->toInteger() ;
    var D : Sequence(int) ; D := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     D[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    D := D->sort() ; 
    var ans : long ; ans := 1 ;
    var s : int ; s := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     while (s < i & D[s+1] < D[i+1] - T) do (     s := s + 1 ) ; 
     ans := (ans * (i - s + 1)) mod MODULO )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int t=sc.nextInt();
      int[] data=new int[n];
      for(int i=0 ; i<n ; i++){
        data[i]=sc.nextInt();
      }
      Arrays.sort(data);
      long sum=1 ;
      long mod=1000000007L ;
      for(int i=1 ; i<n ; i++){
        int ind=bLowerSearch(data,data[i]-t);
        sum=(sum*(i-ind+1))% mod ;
      }
      System.out.println(sum);
    }
  }
  private int bLowerSearch(int a[],int patt){
    int mid,left=0,right=a.length-1 ;
    while(left<right){
      mid=(right+left)/2 ;
      if(a[mid]<patt){
        left=mid+1 ;
      }
      else {
        right=mid ;
      }
    }
    if(a[left]==patt){
      return left ;
    }
    else {
      return right ;
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var data : Sequence(int) ; data := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     data[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    data := data->sort() ; 
    var sum : long ; sum := 1 ;
    var mod : long ; mod := 1000000007L ;
        var i : int ; i := 1 ; while i < n do ( (     var ind : int ; ind := bLowerSearch(data, data[i+1] - t) ;
     sum := (sum * (i - ind + 1)) mod mod )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) );
   operation bLowerSearch( a : Sequence(int), patt : int) : int
  pre: true
  post: true
  activity: (     var mid : int ;
    var left : int ; left := 0 ;
    var right : int ; right := a->size() - 1 ;
     while (left < right) do (     mid := (right + left) / 2 ; 
     if (a[mid+1] < patt) then (     left := mid + 1 ) else (     right := mid ) ) ; 
     if (a[left+1] = patt) then (     return left ) else (     return right ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] arg){
    int MOD=1000000007 ;
    int N=sc.nextInt();
    int T=sc.nextInt();
    int[] D=new int[100001];
    for(int i=0 ; i<N ; ++i){
      D[sc.nextInt()]++;
    }
    int[] sum=new int[100001];
    long ans=1 ;
    for(int i=1 ; i<=100000 ; ++i){
      sum[i]=sum[i-1]+D[i];
      int pos=1+sum[i-1]-(i>T ? sum[i-T-1] : 0);
      for(int j=0 ; j<D[i]; ++j){
        ans*=pos+j ;
        ans %=MOD ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var MOD : int ; MOD := 1000000007 ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
    var D : Sequence(int) ; D := Integer.subrange(1,100001)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     D[sc.getCurrent()->toInteger()+1] := D[sc.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
    var sum : Sequence(int) ; sum := Integer.subrange(1,100001)->collect(0) ;
    var ans : long ; ans := 1 ;
        var i : int ; i := 1 ; while i <= 100000 do ( (     sum[i+1] := sum[i - 1+1] + D[i+1] ; 
     var pos : int ; pos := 1 + sum[i - 1+1] - (if i > T then sum[i - T - 1+1] else 0 endif) ;
         var j : int ; j := 0 ; while j < D[i+1] do ( (     ans := ans*(pos + j) ; 
     ans := ans mod MOD )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class AOJ0289 {
  public static void main(String...args){
    final Scanner sc=new Scanner(System.in);
    final int N=sc.nextInt();
    for(int i=0 ; i<N ; i++){
      int s=sc.nextInt();
      int d=sc.nextInt();
      int cnt=0 ;
      while(d>s){
        cnt+=(s & 1)+(d & 1);
        s+=s & 1 ;
        s>>=1 ;
        d>>=1 ;
      }
      System.out.println(cnt);
    }
  }
}
public class Main {
  public static void main(String...args){
    AOJ0289.main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class AOJ0289 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < N do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
    var cnt : int ; cnt := 0 ;
    while (d > s) do (     cnt := cnt+((MathLib.bitwiseAnd(s,1)) + (MathLib.bitwiseAnd(d,1))) ; 
     s := s+(MathLib.bitwiseAnd(s,1)) ; 
     s := s/(2->pow(1)) ; 
     d := d/(2->pow(1)) ) ; 
    OclFile["System.out"].println(cnt) ; 
 )  ;     i := i + 1 ) );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     AOJ0289.main() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[][] tile=new int[5][5];
    for(int i=0 ; i<n ; i++){
      for(int y=0 ; y<5 ; y++){
        for(int x=0 ; x<5 ; x++){
          tile[x][y]=scan.nextInt();
        }
      }
      int ans=0 ;
      for(int w=5 ; w>0 ; w--){
        for(int h=5 ; h>0 ; h--){
          if(w*h>ans){
            for(int xp=0 ; xp<=5-w ; xp++){
              for(int yp=0 ; yp<=5-h ; yp++){
                boolean okay=true ;
                for(int xpp=xp ; xpp<=w+xp-1 ; xpp++){
                  for(int ypp=yp ; ypp<=h+yp-1 ; ypp++){
                    if(tile[xpp][ypp]==0){
                      okay=false ;
                      break ;
                    }
                  }
                }
                if(okay){
                  ans=w*h ;
                }
              }
            }
          }
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
     var tile : Sequence(Sequence(int)) ; tile := Integer.subrange(1,5)->collect(Integer.subrange(1,5)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do ( (         var y : int ; y := 0 ; while y < 5 do ( (         var x : int ; x := 0 ; while x < 5 do ( (     tile[x+1][y+1] := scan.getCurrent()->toInteger() )  ;     x := x + 1 ) )  ;     y := y + 1 ) ; 
     var ans : int ; ans := 0 ;
         var w : int ; w := 5 ; while w > 0 do ( (         var h : int ; h := 5 ; while h > 0 do ( (     if (w * h > ans) then (         var xp : int ; xp := 0 ; while xp <= 5 - w do ( (         var yp : int ; yp := 0 ; while yp <= 5 - h do ( (     var okay : boolean ; okay := true ;
         var xpp : int ; xpp := xp ; while xpp <= w + xp - 1 do ( (         var ypp : int ; ypp := yp ; while ypp <= h + yp - 1 do ( (     if (tile[xpp+1][ypp+1] = 0) then (     okay := false ; 
     break ) else skip )  ;     ypp := ypp + 1 ) )  ;     xpp := xpp + 1 ) ; 
     if (okay) then (     ans := w * h ) else skip )  ;     yp := yp + 1 ) )  ;     xp := xp + 1 ) ) else skip )  ;     h := h - 1 ) )  ;     w := w - 1 ) ; 
     OclFile["System.out"].println(ans) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int T ;
  int n=5 ;
  int[][] a ;
  void run(){
    T=sc.nextInt();
    for(int k=0 ; k<T ; k++){
      a=new int[n][n];
      for(int j=0 ; j<n ; j++){
        for(int i=0 ; i<n ; i++){
          a[j][i]=sc.nextInt();
        }
      }
      solve();
    }
  }
  void solve(){
    int max=0 ;
    for(int y=0 ; y<n ; y++){
      for(int x=0 ; x<n ; x++){
        for(int w=1 ; w<=n ; w++){
          for(int h=1 ; h<=n ; h++){
            boolean ok=true ;
            for(int j=y ; j<y+h ; j++){
              if(j>=n){
                ok=false ;
                break ;
              }
              for(int i=x ; i<x+w ; i++){
                if(i>=n){
                  ok=false ;
                  break ;
                }
                ok &=a[j][i]==1 ;
              }
            }
            if(ok){
              max=max(max,w*h);
            }
          }
        }
      }
    }
    println(max+"");
  }
  void debug(Object...os){
    System.err.println(deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute T : int;
   attribute n : int := 5;
   attribute a : Sequence(Sequence(int));
   operation run() : void
  pre: true
  post: true
  activity: (     T := sc.getCurrent()->toInteger() ; 
         var k : int ; k := 0 ; while k < T do ( (     a := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
         var j : int ; j := 0 ; while j < n do ( (         var i : int ; i := 0 ; while i < n do ( (     a[j+1][i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
     execute solve() )  ;     k := k + 1 ) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var max : int ; max := 0 ;
         var y : int ; y := 0 ; while y < n do ( (         var x : int ; x := 0 ; while x < n do ( (         var w : int ; w := 1 ; while w <= n do ( (         var h : int ; h := 1 ; while h <= n do ( (     var ok : boolean ; ok := true ;
         var j : int ; j := y ; while j < y + h do ( (     if (j >= n) then (     ok := false ; 
     break ) else skip ; 
         var i : int ; i := x ; while i < x + w do ( (     if (i >= n) then (     ok := false ; 
     break ) else skip ; 
     ok := MathLib.bitwiseAnd(ok, a[j+1][i+1] = 1) )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
     if (ok) then (     max := Set{max, w * h}->max() ) else skip )  ;     h := h + 1 ) )  ;     w := w + 1 ) )  ;     x := x + 1 ) )  ;     y := y + 1 ) ; 
     execute println(max + "") );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static int map[][]=new int[5][5];
  static int max ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int p=0 ; p<n ; p++){
      for(int i=0 ; i<5 ; i++){
        for(int j=0 ; j<5 ; j++){
          map[i][j]=sc.nextInt();
        }
      }
      max=0 ;
      for(int i=0 ; i<5 ; i++){
        for(int j=0 ; j<5 ; j++){
          if(map[i][j]==0)continue ;
          search(i,j);
        }
      }
      System.out.println(max);
    }
  }
  static void search(int x,int y){
    int f=0,s=0 ;
    int i=0,j=0,k=0,l=0 ;
    for(i=x ; i<5 ; i++){
      for(j=y ; j<5 ; j++){
        f=1 ;
        for(k=x ; k<=i ; k++){
          for(l=y ; l<=j ; l++){
            if(map[k][l]==0){
              f=0 ;
              break ;
            }
          }
        }
        if(f==1)max=Math.max(max,(k-x)*(l-y));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute map : int := Integer.subrange(1,5)->collect(Integer.subrange(1,5)->collect(0));
  static   attribute max : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var p : int ; p := 0 ; while p < n do ( (         var i : int ; i := 0 ; while i < 5 do ( (         var j : int ; j := 0 ; while j < 5 do ( (     map[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     max := 0 ; 
         var i : int ; i := 0 ; while i < 5 do ( (         var j : int ; j := 0 ; while j < 5 do ( (     if (map[i+1][j+1] = 0) then     continue else skip ; 
     execute search(i, j) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(max) )  ;     p := p + 1 ) );
  static   operation search( x : int, y : int) : void
  pre: true
  post: true
  activity: (     var f : int ; f := 0 ;
    var s : int ; s := 0 ;
     var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    var k : int ; k := 0 ;
    var l : int ; l := 0 ;
         i := x ; while i < 5 do ( (         j := y ; while j < 5 do ( (     f := 1 ; 
         k := x ; while k <= i do ( (         l := y ; while l <= j do ( (     if (map[k+1][l+1] = 0) then (     f := 0 ; 
     break ) else skip )  ;     l := l + 1 ) )  ;     k := k + 1 ) ; 
     if (f = 1) then     max := Set{max, (k - x) * (l - y)}->max() ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileInputStream ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  static int[][] map ;
  static int calc(int sx,int sy,int tx,int ty){
    Boolean ok=true ;
    for(int x=sx ; x<=tx ; x++)for(int y=sy ; y<=ty ; y++){
      if(map[y][x]==0)ok=false ;
    }
    if(ok)return(tx-sx+1)*(ty-sy+1);
    else return 0 ;
  }
  static void start(){
    int max=0 ;
    for(int y=0 ; y<5 ; y++)for(int x=0 ; x<5 ; x++)for(int yy=y ; yy<5 ; yy++)for(int xx=x ; xx<5 ; xx++){
      int tmp=calc(x,y,xx,yy);
      max=Math.max(max,tmp);
    }
    System.out.println(max);
  }
  public static void main(String[] args){
    Scanner sca=new Scanner(System.in);
    while(true){
      int m=sca.nextInt();
      for(; m>0 ; m--){
        map=new int[5][5];
        for(int y=0 ; y<5 ; y++)for(int x=0 ; x<5 ; x++)map[y][x]=sca.nextInt();
        start();
      }
      break ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute map : Sequence(Sequence(int));
  static   operation calc( sx : int, sy : int, tx : int, ty : int) : int
  pre: true
  post: true
  activity: (     var ok : Boolean ; ok := true ;
         var x : int ; x := sx ; while x <= tx do (         var y : int ; y := sy ; while y <= ty do ( (     if (map[y+1][x+1] = 0) then     ok := false ; else skip )  ;     y := y + 1 ) ;  ;     x := x + 1 ) ; 
     if (ok) then     return (tx - sx + 1) * (ty - sy + 1) else     return 0 );
  static   operation start() : void
  pre: true
  post: true
  activity: (     var max : int ; max := 0 ;
         var y : int ; y := 0 ; while y < 5 do (         var x : int ; x := 0 ; while x < 5 do (         var yy : int ; yy := y ; while yy < 5 do (         var xx : int ; xx := x ; while xx < 5 do ( (     var tmp : int ; tmp := calc(x, y, xx, yy) ;
     max := Set{max, tmp}->max() )  ;     xx := xx + 1 ) ;  ;     yy := yy + 1 ) ;  ;     x := x + 1 ) ;  ;     y := y + 1 ) ; 
     OclFile["System.out"].println(max) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sca : OclFile ; sca := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var m : int ; m := sca.getCurrent()->toInteger() ;
       while m > 0 do ( (     map := Integer.subrange(1,5)->collect(Integer.subrange(1,5)->collect(0)) ; 
         var y : int ; y := 0 ; while y < 5 do (         var x : int ; x := 0 ; while x < 5 do (     map[y+1][x+1] := sca.getCurrent()->toInteger() ;  ;     x := x + 1 ) ;  ;     y := y + 1 ) ; 
     execute start() )  ;     m := m - 1 ) ; 
     break ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Scanner ;
import java.io.*;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader in=new FastReader();
    int n=in.nextInt();
    String AC="AC" ;
    String WA="WA" ;
    String TLE="TLE" ;
    String RE="RE" ;
    int counta=0 ;
    int countw=0 ;
    int countl=0 ;
    int countr=0 ;
    while(n-->0){
      String S=in.nextLine();
      if(S.equals(AC))counta++;
      else if(S.equals(WA))countw++;
      else if(S.equals(TLE))countl++;
      else if(S.equals(RE))countr++;
    }
    System.out.println("AC x "+counta);
    System.out.println("WA x "+countw);
    System.out.println("TLE x "+countl);
    System.out.println("RE x "+countr);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var n : int ; n := in.nextInt() ;
    var AC : String ; AC := "AC" ;
    var WA : String ; WA := "WA" ;
    var TLE : String ; TLE := "TLE" ;
    var RE : String ; RE := "RE" ;
    var counta : int ; counta := 0 ;
    var countw : int ; countw := 0 ;
    var countl : int ; countl := 0 ;
    var countr : int ; countr := 0 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var S : String ; S := in.nextLine() ;
     if (S = AC) then     counta := counta + 1 ; else     if (S = WA) then     countw := countw + 1 else     if (S = TLE) then     countl := countl + 1 else     if (S = RE) then     countr := countr + 1 ; else skip ; ;  ;  ) ;  ) ;  
    OclFile["System.out"].println("AC x " + counta) ; 
    OclFile["System.out"].println("WA x " + countw) ; 
    OclFile["System.out"].println("TLE x " + countl) ; 
    OclFile["System.out"].println("RE x " + countr) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  Scanner kbd=new Scanner(System.in);
  int ans ;
  int[][] map ;
  void run(){
    int m=kbd.nextInt();
    while(m>0){
      solve();
      m--;
    }
  }
  void solve(){
    ans=0 ;
    map=new int[5][5];
    for(int i=0 ; i<5 ; i++){
      for(int j=0 ; j<5 ; j++){
        map[i][j]=kbd.nextInt();
      }
    }
    int x=0,y=0,cnt=0 ;
    for(x=0 ; x<5 ; x++){
      for(y=0 ; y<5 ; y++){
        int a=x ;
        int b=y ;
        for(int i=0 ; i<5 ; i++){
          for(int j=0 ; j<5 ; j++){
            cnt=count(a,b,i,j);
            if(ans<cnt){
              ans=cnt ;
            }
            cnt=0 ;
          }
        }
      }
    }
    System.out.println(ans);
  }
  int count(int a,int b,int i,int j){
    boolean tf=true ;
    for(int n=0 ; n<=i ; n++){
      for(int l=0 ; l<=j ; l++){
        if(b+j>=5 || a+i>=5)tf=false ;
        else if(map[b+l][a+n]==1){
        }
        else tf=false ;
      }
    }
    if(tf)return(i+1)*(j+1);
    else return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute kbd : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute ans : int;
   attribute map : Sequence(Sequence(int));
   operation run() : void
  pre: true
  post: true
  activity: (     var m : int ; m := kbd.getCurrent()->toInteger() ;
     while (m > 0) do (     execute solve() ; 
     m := m - 1 ) );
   operation solve() : void
  pre: true
  post: true
  activity: (     ans := 0 ; 
     map := Integer.subrange(1,5)->collect(Integer.subrange(1,5)->collect(0)) ; 
        var i : int ; i := 0 ; while i < 5 do ( (         var j : int ; j := 0 ; while j < 5 do ( (     map[i+1][j+1] := kbd.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var cnt : int ; cnt := 0 ;
        x := 0 ; while x < 5 do ( (         y := 0 ; while y < 5 do ( (     var a : int ; a := x ;
     var b : int ; b := y ;
         var i : int ; i := 0 ; while i < 5 do ( (         var j : int ; j := 0 ; while j < 5 do ( (     cnt := count(a, b, i, j) ; 
     if (ans < cnt) then (     ans := cnt ) else skip ; 
     cnt := 0 )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation count( a : int, b : int, i : int, j : int) : int
  pre: true
  post: true
  activity: (     var tf : boolean ; tf := true ;
         var n : int ; n := 0 ; while n <= i do ( (         var l : int ; l := 0 ; while l <= j do ( (     if (b + j >= 5 or a + i >= 5) then     tf := false ; else     if (map[b + l+1][a + n+1] = 1) then skip else     tf := false ; ;  )  ;     l := l + 1 ) )  ;     n := n + 1 ) ; 
     if (tf) then     return (i + 1) * (j + 1) else     return -1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static final char CHECKED='C' ;
  static final char BLACK='.' ;
  static final char START='@' ;
  void run(){
    Scanner s=new Scanner(System.in);
    while(true){
      int w=s.nextInt();
      int h=s.nextInt();
      if(w==0 && h==w)break ;
      int x=0 ;
      int y=0 ;
      char tile[][]=new char[h][w];
      for(int i=0 ; i<h ; i++){
        String row=s.next();
        for(int j=0 ; j<w ; j++){
          tile[i][j]=row.charAt(j);
          if(tile[i][j]==START){
            y=i ;
            x=j ;
            tile[i][j]=BLACK ;
          }
        }
      }
      System.out.println(cntTile(tile,y,x));
    }
  }
  int cntTile(char[][] panel,int y,int x){
    if(y>=panel.length)return 0 ;
    if(y<0)return 0 ;
    if(x>=panel[0] .length)return 0 ;
    if(x<0)return 0 ;
    int cnt=0 ;
    if(panel[y][x]==BLACK){
      panel[y][x]=CHECKED ;
      cnt++;
      cnt+=cntTile(panel,y+1,x);
      cnt+=cntTile(panel,y-1,x);
      cnt+=cntTile(panel,y,x+1);
      cnt+=cntTile(panel,y,x-1);
      return cnt ;
    }
    else {
      return 0 ;
    }
  }
  public static void main(String args[]){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute CHECKED : String := 'C';
  static    attribute BLACK : String := '.';
  static    attribute START : String := '@';
   operation run() : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var w : int ; w := s.getCurrent()->toInteger() ;
     var h : int ; h := s.getCurrent()->toInteger() ;
    if (w = 0 & h = w) then     break else skip ; 
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var tile : Sequence(Sequence(String)) ; tile := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (     var row : String ; row := s.getCurrent() ;
         var j : int ; j := 0 ; while j < w do ( (     tile[i+1][j+1] := row->at(j+1) ; 
     if (tile[i+1][j+1] = START) then (     y := i ; 
     x := j ; 
     tile[i+1][j+1] := BLACK ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cntTile(tile, y, x)) ; 
 ) );
   operation cntTile( panel : Sequence(Sequence(String)), y : int, x : int) : int
  pre: true
  post: true
  activity: (     if (y >= panel->size()) then     return 0 else skip ; 
     if (y < 0) then     return 0 else skip ; 
    if (x >= panel[0+1]->size()) then     return 0 else skip ; 
    if (x < 0) then     return 0 else skip ; 
    var cnt : int ; cnt := 0 ;
    if (panel[y+1][x+1] = BLACK) then (     panel[y+1][x+1] := CHECKED ; 
     cnt := cnt + 1 ; 
    cnt := cnt+(cntTile(panel, y + 1, x)) ; 
    cnt := cnt+(cntTile(panel, y - 1, x)) ; 
    cnt := cnt+(cntTile(panel, y, x + 1)) ; 
    cnt := cnt+(cntTile(panel, y, x - 1)) ; 
    return cnt 
 ) else (     return 0 ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  String[] tile ;
  boolean[][] board ;
  void doIt(){
    Scanner stdIn=new Scanner(System.in);
    while(stdIn.hasNext()){
      Queue<Integer>qx=new LinkedList<Integer>();
      Queue<Integer>qy=new LinkedList<Integer>();
      int width=stdIn.nextInt();
      int height=stdIn.nextInt();
      if(width+height==0)break ;
      tile=new String[height];
      board=new boolean[height][width];
      for(int r=0 ; r<height ; r++){
        tile[r]=stdIn.next();
        for(int c=0 ; c<width ; c++){
          if(tile[r] .charAt(c)=='@'){
            qx.add(c);
            qy.add(r);
            board[r][c]=true ;
          }
        }
      }
      int[] fdx=new int[] {
        1,-1,0,0 };
        int[] fdy=new int[] {
          0,0,-1,1 };
          int count=1 ;
          while(! qx.isEmpty()){
            int nowx=qx.poll();
            int nowy=qy.poll();
            for(int r=0 ; r<fdx.length ; r++){
              int nextx=nowx+fdx[r];
              int nexty=nowy+fdy[r];
              if(!(nextx>=0 && nexty>=0 && nextx<width && nexty<height))continue ;
              if(tile[nexty] .charAt(nextx)!='#' && ! board[nexty][nextx]){
                qx.add(nextx);
                qy.add(nexty);
                board[nexty][nextx]=true ;
                count++;
              }
            }
          }
          System.out.println(count);
        }
      }
      public static void main(String[] args){
        new Main().doIt();
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute tile : Sequence(String);
   attribute board : Sequence(Sequence(boolean));
   operation doIt() : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (stdIn.hasNext()) do (     var qx : Sequence(int) ; qx := Sequence{} ;
     var qy : Sequence(int) ; qy := Sequence{} ;
    var width : int ; width := stdIn.getCurrent()->toInteger() ;
    var height : int ; height := stdIn.getCurrent()->toInteger() ;
    if (width + height = 0) then     break else skip ; 
    tile := Integer.subrange(1,height)->collect(null) ; 
    board := Integer.subrange(1,height)->collect(Integer.subrange(1,width)->collect(false)) ; 
        var r : int ; r := 0 ; while r < height do ( (     tile[r+1] := stdIn.getCurrent() ; 
         var c : int ; c := 0 ; while c < width do ( (     if (tile[r+1]->at(c+1) = '@') then (     qx := qx->including(c) ; 
     qy := qy->including(r) ; 
     board[r+1][c+1] := true ) else skip )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    var fdx : Sequence(int) ; fdx := Sequence{1,-1,0,0} ;
    var fdy : Sequence(int) ; fdy := Sequence{0,0,-1,1} ;
    var count : int ; count := 1 ;
    while (not(qx->isEmpty())) do (     var nowx : int ; nowx := qx->min() ;
     var nowy : int ; nowy := qy->min() ;
         var r : int ; r := 0 ; while r < fdx->size() do ( (     var nextx : int ; nextx := nowx + fdx[r+1] ;
     var nexty : int ; nexty := nowy + fdy[r+1] ;
     if (not((nextx >= 0 & nexty >= 0 & nextx < width & nexty < height))) then     continue else skip ; 
     if (tile[nexty+1]->at(nextx+1) /= '#' & not(board[nexty+1][nextx+1])) then (     qx := qx->including(nextx) ; 
     qy := qy->including(nexty) ; 
     board[nexty+1][nextx+1] := true ; 
     count := count + 1 ) else skip )  ;     r := r + 1 ) ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  char[][] map ;
  int count=0 ;
  public void run(){
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      int w=scan.nextInt();
      int h=scan.nextInt();
      if(w==0 && h==0){
        break ;
      }
      map=new char[h][w];
      for(int i=0 ; i<h ; i++){
        map[i]=scan.next().toCharArray();
      }
      count=0 ;
      boolean fl=false ;
      for(int i=0 ; i<h ; i++){
        for(int j=0 ; j<w ; j++){
          if(map[i][j]=='@'){
            count++;
            map[i][j]='#' ;
            if(i!=0){
              searchTile(i-1,j);
            }
            if(i!=h-1){
              searchTile(i+1,j);
            }
            if(j!=0){
              searchTile(i,j-1);
            }
            if(j!=w-1){
              searchTile(i,j+1);
            }
            fl=true ;
            break ;
          }
        }
        if(fl){
          break ;
        }
      }
      System.out.println(count);
    }
  }
  public void searchTile(int y,int x){
    if(map[y][x]=='#'){
      return ;
    }
    count++;
    map[y][x]='#' ;
    if(y!=0){
      searchTile(y-1,x);
    }
    if(y!=map.length-1){
      searchTile(y+1,x);
    }
    if(x!=0){
      searchTile(y,x-1);
    }
    if(x!=map[0] .length-1){
      searchTile(y,x+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute map : Sequence(Sequence(String));
   attribute count : int := 0;
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var w : int ; w := scan.getCurrent()->toInteger() ;
     var h : int ; h := scan.getCurrent()->toInteger() ;
    if (w = 0 & h = 0) then (     break ) else skip ; 
    map := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ; 
        var i : int ; i := 0 ; while i < h do ( (     map[i+1] := scan.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    count := 0 ; 
    var fl : boolean ; fl := false ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (map[i+1][j+1] = '@') then (     count := count + 1 ; 
     map[i+1][j+1] := '#' ; 
    if (i /= 0) then (     execute searchTile(i - 1, j) ) else skip ; 
    if (i /= h - 1) then (     execute searchTile(i + 1, j) ) else skip ; 
    if (j /= 0) then (     execute searchTile(i, j - 1) ) else skip ; 
    if (j /= w - 1) then (     execute searchTile(i, j + 1) ) else skip ; 
    fl := true ; 
    break 
 ) else skip )  ;     j := j + 1 ) ; 
     if (fl) then (     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
   operation searchTile( y : int, x : int) : void
  pre: true
  post: true
  activity: (     if (map[y+1][x+1] = '#') then (     return ) else skip ; 
     count := count + 1 ; 
    map[y+1][x+1] := '#' ; 
    if (y /= 0) then (     execute searchTile(y - 1, x) ) else skip ; 
    if (y /= map->size() - 1) then (     execute searchTile(y + 1, x) ) else skip ; 
    if (x /= 0) then (     execute searchTile(y, x - 1) ) else skip ; 
    if (x /= map[0+1]->size() - 1) then (     execute searchTile(y, x + 1) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int deleteElement(int A[],int L,int R,int N){
    int i,j=0 ;
    for(i=0 ; i<N ; i++){
      if(i<=L || i>=R){
        A[j]=A[i];
        j++;
      }
    }
    return j ;
  }
  public static void main(String args[]){
    int A[]=new int[] {
      5,8,11,15,26,14,19,17,10,14 };
      int L=2,R=7 ;
      int n=A.length ;
      int res_size=deleteElement(A,L,R,n);
      for(int i=0 ; i<res_size ; i++)System.out.print(A[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation deleteElement( A : Sequence(int), L : int, R : int, N : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ; j := 0 ;
         i := 0 ; while i < N do ( (     if (i <= L or i >= R) then (     A[j+1] := A[i+1] ; 
     j := j + 1 ) else skip )  ;     i := i + 1 ) ; 
     return j );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{5,8,11,15,26,14,19,17,10,14} ;
     var L : int ; L := 2 ;
    var R : int ; R := 7 ;
    var n : int ; n := A->size() ;
    var res_size : int ; res_size := deleteElement(A, L, R, n) ;
        var i : int ; i := 0 ; while i < res_size do (     OclFile["System.out"].print(A[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  int solve(int src,int dst){
    int answer=0 ;
    if(src==dst)return 0 ;
    if(src % 2!=0){
      answer++;
      src++;
    }
    if(dst % 2!=0){
      answer++;
      dst--;
    }
    answer+=solve(src/2,dst/2);
    return answer ;
  }
  void _solve(){
    int N,s,d ;
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    for(int i=0 ; i<N ; i++){
      s=sc.nextInt();
      d=sc.nextInt();
      System.out.println(solve(s,d));
    }
  }
  public static void main(String[] args){
    new Main()._solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve( src : int, dst : int) : int
  pre: true
  post: true
  activity: (     var answer : int ; answer := 0 ;
     if (src = dst) then     return 0 else skip ; 
    if (src mod 2 /= 0) then (     answer := answer + 1 ; 
     src := src + 1 ) else skip ; 
    if (dst mod 2 /= 0) then (     answer := answer + 1 ; 
     dst := dst - 1 ) else skip ; 
    answer := answer+(solve(src / 2, dst / 2)) ; 
    return answer 
 );
   operation _solve() : void
  pre: true
  post: true
  activity: (     var N : int ;
    var s : int ;
    var d : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
         var i : int ; i := 0 ; while i < N do ( (     s := sc.getCurrent()->toInteger() ; 
     d := sc.getCurrent()->toInteger() ; 
     OclFile["System.out"].println(solve(s, d)) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain()._solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double r=sc.nextDouble();
    double pi=Math.PI ;
    double area=r*r*pi ;
    double length=2*pi*r ;
    System.out.printf("%f %f",area,length);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : double ; r := sc.getCurrent()->toReal() ;
    var pi : double ; pi := 3.141592653589793 ;
    var area : double ; area := r * r * pi ;
    var length : double ; length := 2 * pi * r ;
    OclFile["System.out"].printf("%f %f", area, length) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    BigDecimal r=sc.nextBigDecimal();
    System.out.println(r.multiply(r).multiply(new BigDecimal(Math.PI))+" "+r.multiply(new BigDecimal(2).multiply(new BigDecimal(Math.PI))));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : double ; r := sc.nextBigDecimal() ;
     OclFile["System.out"].println(r.multiply(r).multiply(double(3.141592653589793)) + " " + r.multiply(double(2).multiply(double(3.141592653589793)))) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static final BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  private static final PrintWriter pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  private static StringTokenizer st ;
  private static int readInt()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return Integer.parseInt(st.nextToken());
  }
  private static String readToken()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public static void main(String[] args)throws IOException {
    int N=readInt();
    int ac=0 ;
    int wa=0 ;
    int tle=0 ;
    int re=0 ;
    for(int i=0 ; i<N ; i++){
      String verdict=readToken();
      switch(verdict){
        case "AC" : ac++;
        break ;
        case "WA" : wa++;
        break ;
        case "TLE" : tle++;
        break ;
        case "RE" : re++;
        break ;
        default : }
      }
      pw.println("AC x "+ac+"\nWA x "+wa+"\nTLE x "+tle+"\nRE x "+re);
      pw.close();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static    attribute pw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])));
  static   attribute st : OclIterator;
  static   operation readInt() : int
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return (st.next())->toInteger() );
  static   operation readToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := readInt() ;
     var ac : int ; ac := 0 ;
    var wa : int ; wa := 0 ;
    var tle : int ; tle := 0 ;
    var re : int ; re := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var verdict : String ; verdict := readToken() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (verdict) ; 
       if _switchval = "AC" then
     ac := ac + 1 ; 
    break 
   else skip ;
       if _switchval = "WA" then
     wa := wa + 1 ; 
    break 
   else skip ;
       if _switchval = "TLE" then
     tle := tle + 1 ; 
    break 
   else skip ;
       if _switchval = "RE" then
     re := re + 1 ; 
    break 
   else skip ;
   if true then
 )
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static final double b=Math.PI ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double a=sc.nextDouble();
    double syu ;
    double men ;
    syu=a*(double)2*b ;
    men=a*a*b ;
    System.out.printf("%f %f",men,syu);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute b : double := 3.141592653589793;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : double ; a := sc.getCurrent()->toReal() ;
    var syu : double ;
    var men : double ;
    syu := a * 2->oclAsType(double) * b ; 
    men := a * a * b ; 
    OclFile["System.out"].printf("%f %f", men, syu) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    while(scan.hasNext()){
      double r=scan.nextDouble();
      System.out.printf("%.6f %.6f",(Math.PI*r*r),(2*Math.PI*r));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     while (scan.hasNext()) do (     var r : double ; r := scan.getCurrent()->toReal() ;
     OclFile["System.out"].printf("%.6f %.6f", (3.141592653589793 * r * r), (2 * 3.141592653589793 * r)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.IOException ;
class Main {
  public static void main(String[] args)throws IOException {
    Scanner r=new Scanner(System.in);
    double rd=r.nextDouble();
    System.out.printf("%6f %6f",Math.PI*rd*rd,Math.PI*rd*2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var rd : double ; rd := r.getCurrent()->toReal() ;
     OclFile["System.out"].printf("%6f %6f", 3.141592653589793 * rd * rd, 3.141592653589793 * rd * 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Stack ;
class Test {
  static int arr[]={
    10,20,30,50,10,70,30 };
    static void printMaxOfMin(int n){
      Stack<Integer>s=new Stack<>();
      int left[]=new int[n+1];
      int right[]=new int[n+1];
      for(int i=0 ; i<n ; i++){
        left[i]=-1 ;
        right[i]=n ;
      }
      for(int i=0 ; i<n ; i++){
        while(! s.empty()&& arr[s.peek()]>=arr[i])s.pop();
        if(! s.empty())left[i]=s.peek();
        s.push(i);
      }
      while(! s.empty())s.pop();
      for(int i=n-1 ; i>=0 ; i--){
        while(! s.empty()&& arr[s.peek()]>=arr[i])s.pop();
        if(! s.empty())right[i]=s.peek();
        s.push(i);
      }
      int ans[]=new int[n+1];
      for(int i=0 ; i<=n ; i++)ans[i]=0 ;
      for(int i=0 ; i<n ; i++){
        int len=right[i]-left[i]-1 ;
        ans[len]=Math.max(ans[len],arr[i]);
      }
      for(int i=n-1 ; i>=1 ; i--)ans[i]=Math.max(ans[i],ans[i+1]);
      for(int i=1 ; i<=n ; i++)System.out.print(ans[i]+" ");
    }
    public static void main(String[] args){
      printMaxOfMin(arr.length);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Test {
  static   attribute arr : int := Sequence{10,20,30,50,10,70,30};
  static   operation printMaxOfMin( n : int) : void
  pre: true
  post: true
  activity: (     var s : Sequence(int) ; s := Sequence{} ;
     var left : Sequence(int) ; left := Integer.subrange(1,n + 1)->collect(0) ;
    var right : Sequence(int) ; right := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     left[i+1] := -1 ; 
     right[i+1] := n )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     while (not(s->isEmpty()) & arr[s->min()+1] >= arr[i+1]) do     s := s->front() ; ; 
     if (not(s->isEmpty())) then     left[i+1] := s->min() ; else skip ; 
     s := s->append(i) )  ;     i := i + 1 ) ; 
    while (not(s->isEmpty())) do     s := s->front() ; ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     while (not(s->isEmpty()) & arr[s->min()+1] >= arr[i+1]) do     s := s->front() ; ; 
     if (not(s->isEmpty())) then     right[i+1] := s->min() ; else skip ; 
     s := s->append(i) )  ;     i := i - 1 ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i <= n do (     ans[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var len : int ; len := right[i+1] - left[i+1] - 1 ;
     ans[len+1] := Set{ans[len+1], arr[i+1]}->max() )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 1 do (     ans[i+1] := Set{ans[i+1], ans[i + 1+1]}->max() ;  ;     i := i - 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (     OclFile["System.out"].print(ans[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute printMaxOfMin(arr->size()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    Map<Integer,Integer>fact=new HashMap<>();
    for(int i=2 ; i<=N ; i++)fact.put(i,0);
    for(int i=2 ; i<=N ; i++){
      int x=i ;
      for(int j=2 ; j<=Math.sqrt(i); j++){
        if(x % j==0){
          int n=0 ;
          while(x % j==0){
            x/=j ;
            n++;
          }
          fact.put(j,fact.get(j)+n);
        }
      }
      if(x>1)fact.put(x,fact.get(x)+1);
    }
    int sf=0,tf=0,ft=0,f=0,t=0 ;
    for(int i : fact.values()){
      if(i>=74)sf++;
      if(i>=24)tf++;
      if(i>=14)ft++;
      if(i>=4)f++;
      if(i>=2)t++;
    }
    System.out.println(sf+tf*(t-1)+ft*(f-1)+f*(f-1)/2*(t-2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var fact : Map(int,int) ; fact := Map{} ;
        var i : int ; i := 2 ; while i <= N do (     fact := fact->union(Map{i |-> 0}) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= N do ( (     var x : int ; x := i ;
         var j : int ; j := 2 ; while j <= (i)->sqrt() do ( (     if (x mod j = 0) then (     var n : int ; n := 0 ;
     while (x mod j = 0) do (     x := x/(j) ; 
     n := n + 1 ) ; 
     fact := fact->union(Map{j |-> fact->at(j) + n}) ) else skip )  ;     j := j + 1 ) ; 
     if (x > 1) then     fact := fact->union(Map{x |-> fact->at(x) + 1}) ; else skip )  ;     i := i + 1 ) ; 
    var sf : int ; sf := 0 ;
    var tf : int ; tf := 0 ;
    var ft : int ; ft := 0 ;
    var f : int ; f := 0 ;
    var t : int ; t := 0 ;
    for (i : fact->values()) do ( (     if (i >= 74) then     sf := sf + 1 ; else skip ; 
     if (i >= 24) then     tf := tf + 1 ; else skip ; 
    if (i >= 14) then     ft := ft + 1 ; else skip ; 
    if (i >= 4) then     f := f + 1 ; else skip ; 
    if (i >= 2) then     t := t + 1 ; else skip ; 
 )  ) ; 
    OclFile["System.out"].println(sf + tf * (t - 1) + ft * (f - 1) + f * (f - 1) / 2 * (t - 2)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.run();
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int p[]=new int[101];
    for(int i=1 ; i<=N ; i++){
      int x=i ;
      for(int j=2 ; j*j<=x ; j++){
        if(x % j==0){
          while(x % j==0){
            p[j]++;
            x/=j ;
          }
        }
      }
      if(x>1){
        p[x]++;
      }
    }
    int dp[][]=new int[102][76];
    dp[1][1]=1 ;
    for(int i=1 ; i<=N ; i++){
      for(int j=1 ; j<=75 ; j++){
        for(int k=0 ; k<=p[i]; k++){
          if(j*(k+1)<=75){
            dp[i+1][j*(k+1)]+=dp[i][j];
          }
        }
      }
    }
    System.out.println(dp[N][75]);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,101)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do ( (     var x : int ; x := i ;
         var j : int ; j := 2 ; while j * j <= x do ( (     if (x mod j = 0) then (     while (x mod j = 0) do (     p[j+1] := p[j+1] + 1 ; 
     x := x/(j) ) ) else skip )  ;     j := j + 1 ) ; 
     if (x > 1) then (     p[x+1] := p[x+1] + 1 ) else skip )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,102)->collect(Integer.subrange(1,76)->collect(0)) ;
    dp[1+1][1+1] := 1 ; 
        var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := 1 ; while j <= 75 do ( (         var k : int ; k := 0 ; while k <= p[i+1] do ( (     if (j * (k + 1) <= 75) then (     dp[i + 1+1][j * (k + 1)+1] := dp[i + 1+1][j * (k + 1)+1]+(dp[i+1][j+1]) ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[N+1][75+1]) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Collections ;
public class Main {
  public static void main(String args[])throws InterruptedException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] natural=new int[101];
    int[] yakusu=new int[101];
    int ans=0 ;
    int cnt74=0 ;
    int cnt24=0 ;
    int cnt14=0 ;
    int cnt5=0 ;
    int cnt4=0 ;
    int cnt2=0 ;
    for(int i=0 ; i<101 ; i++){
      natural[i]=i ;
    }
    for(int i=1 ; i<=n ; i++){
      for(int j=2 ; j<=i ; j++){
        while(natural[i] % j==0){
          natural[i]=natural[i]/j ;
          yakusu[j]++;
        }
        if(natural[i]==1){
          break ;
        }
      }
    }
    for(int i=0 ; i<=n ; i++){
      if(yakusu[i]>=74){
        cnt74++;
      }
      if(yakusu[i]>=24){
        cnt24++;
      }
      if(yakusu[i]>=14){
        cnt14++;
      }
      if(yakusu[i]>=4){
        cnt4++;
      }
      if(yakusu[i]>=2){
        cnt2++;
      }
    }
    ans=cnt74+cnt24*(cnt2-1)+cnt4*(cnt4-1)*(cnt2-2)/2+cnt14*(cnt4-1);
    System.out.println(ans);
    sc.close();
  }
  public static boolean isEven(int n){
    if(n % 2==0){
      return true ;
    }
    else {
      return false ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var natural : Sequence(int) ; natural := Integer.subrange(1,101)->collect(0) ;
    var yakusu : Sequence(int) ; yakusu := Integer.subrange(1,101)->collect(0) ;
    var ans : int ; ans := 0 ;
    var cnt74 : int ; cnt74 := 0 ;
    var cnt24 : int ; cnt24 := 0 ;
    var cnt14 : int ; cnt14 := 0 ;
    var cnt5 : int ; cnt5 := 0 ;
    var cnt4 : int ; cnt4 := 0 ;
    var cnt2 : int ; cnt2 := 0 ;
        var i : int ; i := 0 ; while i < 101 do ( (     natural[i+1] := i )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 2 ; while j <= i do ( (     while (natural[i+1] mod j = 0) do (     natural[i+1] := natural[i+1] / j ; 
     yakusu[j+1] := yakusu[j+1] + 1 ) ; 
     if (natural[i+1] = 1) then (     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= n do ( (     if (yakusu[i+1] >= 74) then (     cnt74 := cnt74 + 1 ) else skip ; 
     if (yakusu[i+1] >= 24) then (     cnt24 := cnt24 + 1 ) else skip ; 
    if (yakusu[i+1] >= 14) then (     cnt14 := cnt14 + 1 ) else skip ; 
    if (yakusu[i+1] >= 4) then (     cnt4 := cnt4 + 1 ) else skip ; 
    if (yakusu[i+1] >= 2) then (     cnt2 := cnt2 + 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    ans := cnt74 + cnt24 * (cnt2 - 1) + cnt4 * (cnt4 - 1) * (cnt2 - 2) / 2 + cnt14 * (cnt4 - 1) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
  static   operation isEven( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n mod 2 = 0) then (     return true ) else (     return false ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Solution {
  public int thirdMax(int[] nums){
    PriorityQueue<Integer>pq=new PriorityQueue<>(3);
    Set<Integer>set=new HashSet<>();
    for(int i : nums){
      if(set.contains(i))continue ;
      pq.offer(i);
      set.add(i);
      if(pq.size()>3)set.remove(pq.poll());
    }
    while(pq.size()<3 && pq.size()>1){
      pq.poll();
    }
    return pq.peek();
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation thirdMax( nums : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var pq : Sequence(int) ; pq := Sequence{} ;
     var set : Set(int) ; set := Set{} ;
    for (i : nums) do ( (     if (set->includes(i)) then     continue else skip ; 
     pq := pq->including(i) ; 
     set := set->including(i) ; 
     if (pq->size() > 3) then     set := set->excludingFirst(pq->min()) ; else skip )  ) ; 
    while (pq->size() < 3 & pq->size() > 1) do (     pq := pq->sort()->tail() ) ; 
    return pq->min() 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int d=sc.nextInt();
    int count[]=new int[100];
    for(int i=2 ; i<=d ; i++){
      int n=i ;
      int div=2 ;
      while(n>1){
        if(n % div==0){
          n/=div ;
          count[div]++;
        }
        else {
          div++;
        }
      }
    }
    int moreThan4=0 ;
    int moreThan2=0 ;
    int moreThan14=0 ;
    int moreThan24=0 ;
    for(int i=0 ; i<count.length ; i++){
      if(count[i]>=4){
        moreThan4++;
      }
      if(count[i]>=2){
        moreThan2++;
      }
      if(count[i]>=14){
        moreThan14++;
      }
      if(count[i]>=24){
        moreThan24++;
      }
    }
    int result ;
    if(moreThan4>=2 && moreThan2>=3){
      result=moreThan4*(moreThan4-1)/2*(moreThan2-2);
      if(moreThan14>0){
        result+=moreThan14*(moreThan4-1);
      }
      if(moreThan24>0){
        result+=moreThan24*(moreThan2-1);
      }
      if(count[2]>=74){
        result++;
      }
    }
    else {
      result=0 ;
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
    var count : Sequence(int) ; count := Integer.subrange(1,100)->collect(0) ;
        var i : int ; i := 2 ; while i <= d do ( (     var n : int ; n := i ;
     var div : int ; div := 2 ;
     while (n > 1) do (     if (n mod div = 0) then (     n := n/(div) ; 
     count[div+1] := count[div+1] + 1 ) else (     div := div + 1 ) ) )  ;     i := i + 1 ) ; 
    var moreThan4 : int ; moreThan4 := 0 ;
    var moreThan2 : int ; moreThan2 := 0 ;
    var moreThan14 : int ; moreThan14 := 0 ;
    var moreThan24 : int ; moreThan24 := 0 ;
        var i : int ; i := 0 ; while i < count->size() do ( (     if (count[i+1] >= 4) then (     moreThan4 := moreThan4 + 1 ) else skip ; 
     if (count[i+1] >= 2) then (     moreThan2 := moreThan2 + 1 ) else skip ; 
     if (count[i+1] >= 14) then (     moreThan14 := moreThan14 + 1 ) else skip ; 
     if (count[i+1] >= 24) then (     moreThan24 := moreThan24 + 1 ) else skip )  ;     i := i + 1 ) ; 
    var result : int ;
    if (moreThan4 >= 2 & moreThan2 >= 3) then (     result := moreThan4 * (moreThan4 - 1) / 2 * (moreThan2 - 2) ; 
     if (moreThan14 > 0) then (     result := result+(moreThan14 * (moreThan4 - 1)) ) else skip ; 
     if (moreThan24 > 0) then (     result := result+(moreThan24 * (moreThan2 - 1)) ) else skip ; 
     if (count[2+1] >= 74) then (     result := result + 1 ) else skip ) else (     result := 0 ) ;  
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import java.lang.Math ;
import java.util.Map ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    int t=fs.nextInt();
    String[] ar=new String[t];
    for(int TT=0 ; TT<t ; TT++){
      ar[TT]=fs.next();
    }
    HashMap<String,Integer>x=new HashMap<>();
    x.put("AC",0);
    x.put("WA",0);
    x.put("TLE",0);
    x.put("RE",0);
    for(int i=0 ; i<t ; i++){
      x.put(ar[i],x.get(ar[i])+1);
    }
    System.out.println("AC x "+x.get("AC"));
    System.out.println("WA x "+x.get("WA"));
    System.out.println("TLE x "+x.get("TLE"));
    System.out.println("RE x "+x.get("RE"));
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var t : int ; t := fs.nextInt() ;
    var ar : Sequence(String) ; ar := Integer.subrange(1,t)->collect(null) ;
        var TT : int ; TT := 0 ; while TT < t do ( (     ar[TT+1] := fs.next() )  ;     TT := TT + 1 ) ; 
    var x : Map(String,int) ; x := Map{} ;
    x := x->union(Map{"AC" |-> 0}) ; 
    x := x->union(Map{"WA" |-> 0}) ; 
    x := x->union(Map{"TLE" |-> 0}) ; 
    x := x->union(Map{"RE" |-> 0}) ; 
        var i : int ; i := 0 ; while i < t do ( (     x := x->union(Map{ar[i+1] |-> x->at(ar[i+1]) + 1}) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("AC x " + x->at("AC")) ; 
    OclFile["System.out"].println("WA x " + x->at("WA")) ; 
    OclFile["System.out"].println("TLE x " + x->at("TLE")) ; 
    OclFile["System.out"].println("RE x " + x->at("RE")) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Test3 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String st=sc.nextLine();
    HashSet<Character>set=new HashSet<>();
    for(int i=0 ; i<st.length(); i++){
      if(st.charAt(i)>='a' && st.charAt(i)<='z'){
        set.add(st.charAt(i));
      }
    }
    System.out.println(set.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var st : String ; st := sc.nextLine() ;
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := 0 ; while i < st->size() do ( (     if (st->at(i+1) >= 'a' & st->at(i+1) <= 'z') then (     set := set->including(st->at(i+1)) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(set->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class replaceSpecialCharecter {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.nextLine();
    int count=1 ;
    str=str.replaceAll("\\s+","");
    str=str.replaceAll(",","");
    str=str.replaceAll("[{}] ","");
    char charArray[]=str.toCharArray();
    Arrays.sort(charArray);
    str=new String(charArray);
    for(int i=0 ; i<str.length()-1 ; i++){
      if(str.charAt(i)!=str.charAt(i+1)){
        count++;
      }
    }
    if(str.length()==0){
      System.out.println("0");
    }
    else {
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class replaceSpecialCharecter {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.nextLine() ;
    var count : int ; count := 1 ;
    str := str.replaceAllMatches("\\s+", "" ) ; 
    str := str.replaceAllMatches(",", "" ) ; 
    str := str.replaceAllMatches("[{}] ", "" ) ; 
    var charArray : Sequence(String) ; charArray := str->characters() ;
    charArray := charArray->sort() ; 
    str := StringLib.newString(charArray) ; 
        var i : int ; i := 0 ; while i < str->size() - 1 do ( (     if (str->at(i+1) /= str->at(i + 1+1)) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (str->size() = 0) then (     OclFile["System.out"].println("0") ) else (     OclFile["System.out"].println(count) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class demo1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] arr=sc.nextLine().toCharArray();
    HashSet<Character>set=new HashSet<>();
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]!='{' && arr[i]!='}' && arr[i]!=',' && arr[i]!=' '){
        set.add(arr[i]);
      }
    }
    System.out.println(set.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class demo1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(String) ; arr := sc.nextLine()->characters() ;
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] /= '{' & arr[i+1] /= '}' & arr[i+1] /= ',' & arr[i+1] /= ' ') then (     set := set->including(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(set->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    HashSet<Character>set=new HashSet<>();
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)>='a' && s.charAt(i)<='z')set.add(s.charAt(i));
    }
    System.out.println(set.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) >= 'a' & s->at(i+1) <= 'z') then     set := set->including(s->at(i+1)) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(set->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class AntonAndLetter {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String str=in.nextLine().replaceAll("[{},] ","");
    int i=str.chars().distinct().toArray().length ;
    System.out.println(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class AntonAndLetter {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := in.nextLine().replaceAllMatches("[{},] ", "" ) ;
     var i : int ; i := str.chars()->asOrderedSet()->asSequence()->size() ;
     OclFile["System.out"].println(i) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Chores {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int a=scan.nextInt();
    int b=scan.nextInt();
    int[] A=new int[n];
    scan.nextLine();
    for(int i=0 ; i<n ; i++){
      A[i]=scan.nextInt();
    }
    Arrays.sort(A);
    int res=A[n-a]-A[n-a-1];
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Chores {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,n)->collect(0) ;
    skip ; 
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    var res : int ; res := A[n - a+1] - A[n - a - 1+1] ;
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    PrintWriter pw=new PrintWriter(System.out);
    int n=nextInt();
    int a=nextInt()-1 ;
    int b=nextInt()-1 ;
    int mas[]=new int[n];
    for(int i=0 ; i<n ; i++){
      mas[i]=nextInt();
    }
    Arrays.sort(mas);
    if(a==n){
      System.out.println(0);
      return ;
    }
    System.out.println(mas[b+1]-mas[b]);
  }
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter out=new PrintWriter(System.out);
  static StringTokenizer in=new StringTokenizer("");
  public static boolean hasNext()throws IOException {
    if(in.hasMoreTokens())return true ;
    String s ;
    while((s=br.readLine())!=null){
      in=new StringTokenizer(s);
      if(in.hasMoreTokens())return true ;
    }
    return false ;
  }
  public static String nextToken()throws IOException {
    while(! in.hasMoreTokens()){
      in=new StringTokenizer(br.readLine());
    }
    return in.nextToken();
  }
  public static int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public static double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  public static long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var n : int ; n := nextInt() ;
    var a : int ; a := nextInt() - 1 ;
    var b : int ; b := nextInt() - 1 ;
    var mas : Sequence(int) ; mas := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     mas[i+1] := nextInt() )  ;     i := i + 1 ) ; 
    mas := mas->sort() ; 
    if (a = n) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    OclFile["System.out"].println(mas[b + 1+1] - mas[b+1]) ; 
 );
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclIterator := OclIterator.newOclIterator_String("");
  static   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     if (in.hasNext()) then     return true else skip ; 
     var s : String ;
         s := br.readLine() ;
    while ((s) /= null) do (    skip ; (     in := OclIterator.newOclIterator_String(s) ; 
     if (in.hasNext()) then     return true else skip ) ;     s := br.readLine() ;
 ) ;  
     return false );
  static   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (not(in.hasNext())) do (     in := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return in.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),a=sc.nextInt(),b=sc.nextInt();
    int h[]=new int[n];
    for(int i=0 ; i<n ; i++){
      h[i]=sc.nextInt();
    }
    Arrays.sort(h);
    System.out.println(h[b]-h[b-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var h : Sequence(int) ; h := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     h[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    h := h->sort() ; 
    OclFile["System.out"].println(h[b+1] - h[b - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class C {
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] nextArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  static class FastWriter extends PrintWriter {
    FastWriter(){
      super(System.out);
    }
    void println(int[] array){
      for(int i=0 ; i<array.length ; i++){
        print(array[i]+" ");
      }
      println();
    }
    void println(long[] array){
      for(int i=0 ; i<array.length ; i++){
        print(array[i]+" ");
      }
      println();
    }
  }
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    FastWriter out=new FastWriter();
    int n=in.nextInt();
    int a=in.nextInt();
    int b=in.nextInt();
    int[] ar=in.nextArray(n);
    Arrays.sort(ar);
    out.println(ar[n-a]-ar[n-a-1]);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static class FastWriter extends OclFile {
   static operation newFastWriter() : FastWriter
  pre: true
  post: true
  activity:
  ( var self : FastWriter ;
    self := createFastWriter();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"]) );
   operation println( array : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < array->size() do ( (     execute print(array[i+1] + " ") )  ;     i := i + 1 ) ; 
     execute println() );
   operation println( array : Sequence(long)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < array->size() do ( (     execute print(array[i+1] + " ") )  ;     i := i + 1 ) ; 
     execute println() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : FastWriter ; out := FastWriter.newFastWriter() ;
    var n : int ; n := in.nextInt() ;
    var a : int ; a := in.nextInt() ;
    var b : int ; b := in.nextInt() ;
    var ar : Sequence(int) ; ar := in.nextArray(n) ;
    ar := ar->sort() ; 
    out.println(ar[n - a+1] - ar[n - a - 1+1]) ; 
    out.close() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maxcoefficientvalue(int n){
    int[][] C=new int[n+1][n+1];
    for(int i=0 ; i<=n ; i++){
      for(int j=0 ; j<=Math.min(i,n); j++){
        if(j==0 || j==i)C[i][j]=1 ;
        else C[i][j]=C[i-1][j-1]+C[i-1][j];
      }
    }
    int maxvalue=0 ;
    for(int i=0 ; i<=n ; i++)maxvalue=Math.max(maxvalue,C[n][i]);
    return maxvalue ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(maxcoefficientvalue(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxcoefficientvalue( n : int) : int
  pre: true
  post: true
  activity: (     var C : Sequence(Sequence(int)) ; C := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= Set{i, n}->min() do ( (     if (j = 0 or j = i) then     C[i+1][j+1] := 1 ; else     C[i+1][j+1] := C[i - 1+1][j - 1+1] + C[i - 1+1][j+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var maxvalue : int ; maxvalue := 0 ;
        var i : int ; i := 0 ; while i <= n do (     maxvalue := Set{maxvalue, C[n+1][i+1]}->max() ;  ;     i := i + 1 ) ; 
    return maxvalue 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(maxcoefficientvalue(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static void printPairs(int arr[],int n){
    Vector<Integer>v=new Vector<Integer>();
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++)if(Math.abs(arr[i])==Math.abs(arr[j]))v.add(Math.abs(arr[i]));
    if(v.size()==0)return ;
    Collections.sort(v);
    for(int i=0 ; i<v.size(); i++)System.out.print(-v.get(i)+" "+v.get(i));
  }
  public static void main(String[] args){
    int arr[]={
      4,8,9,-4,1,-1,-8,-9 };
      int n=arr.length ;
      printPairs(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printPairs( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Sequence{} ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do (     if (if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif = if arr[j+1] < 0 then -(arr[j+1]) else arr[j+1] endif) then     v := v->including(if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif) ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    if (v->size() = 0) then     return else skip ; 
    v := v->sort() ; 
        var i : int ; i := 0 ; while i < v->size() do (     OclFile["System.out"].print(-v->at(i+1) + " " + v->at(i+1)) ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,8,9,-4,1,-1,-8,-9} ;
     var n : int ; n := arr->size() ;
     execute printPairs(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static boolean[] isDist ;
  static int N ;
  static int M ;
  static int p ;
  public static int INF=1<<24 ;
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    N=stdIn.nextInt();
    M=stdIn.nextInt();
    p=stdIn.nextInt();
    Limit=N*50 ;
    isDist=new boolean[N];
    for(int i=0 ; i<M ; i++){
      int d=stdIn.nextInt();
      isDist[d]=true ;
    }
    boolean[] isDist2=Arrays.copyOf(isDist,N);
    solv(1,p,0,0,false,isDist);
    solv(-1,p,0,0,false,isDist2);
    System.out.println(min);
  }
  static int min=1<<24 ;
  static int Limit ;
  public static void solv(int vec,int now,int coun,int cos,boolean alC,boolean[] isDist){
    int nowp=now ;
    int cost=cos ;
    int count=coun ;
    while(true){
      if(min<=cost)return ;
      if(nowp==N)nowp=0 ;
      else if(nowp==-1)nowp=N-1 ;
      if(count==M){
        if(min>cost)min=cost ;
        return ;
      }
      if(isDist[nowp]){
        isDist[nowp]=false ;
        count++;
        if(! alC && cost<Limit){
          boolean[] isDist2=Arrays.copyOf(isDist,N);
          solv(vec*-1,nowp+vec*-1,count,cost+100,true,isDist2);
        }
      }
      if(count==M){
        if(min>cost)min=cost ;
        return ;
      }
      while(true){
        if(nowp==N)nowp=0 ;
        else if(nowp==-1)nowp=N-1 ;
        if(! isDist[nowp]){
          nowp+=vec ;
          cost+=100 ;
        }
        else {
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute isDist : Sequence(boolean);
  static   attribute N : int;
  static   attribute M : int;
  static   attribute p : int;
  static   attribute INF : int := (1*(2->pow(24)))->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := stdIn.getCurrent()->toInteger() ; 
    M := stdIn.getCurrent()->toInteger() ; 
    p := stdIn.getCurrent()->toInteger() ; 
    Limit := N * 50 ; 
    isDist := Integer.subrange(1,N)->collect(false) ; 
        var i : int ; i := 0 ; while i < M do ( (     var d : int ; d := stdIn.getCurrent()->toInteger() ;
     isDist[d+1] := true )  ;     i := i + 1 ) ; 
    var isDist2 : Sequence(boolean) ; isDist2 := isDist.subrange(1,N) ;
    execute solv(1, p, 0, 0, false, isDist) ; 
    execute solv(-1, p, 0, 0, false, isDist2) ; 
    OclFile["System.out"].println(min) ; 
 );
  static   attribute min : int := (1*(2->pow(24)))->oclAsType(long);
  static   attribute Limit : int;
  static   operation solv( vec : int, now : int, coun : int, cos : int, alC : boolean, isDist : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (     var nowp : int ; nowp := now ;
     var cost : int ; cost := cos ;
     var count : int ; count := coun ;
     while (true) do (     if (min <= cost) then     return else skip ; 
     if (nowp = N) then     nowp := 0 else     if (nowp = -1) then     nowp := N - 1 ; else skip ; ;  
    if (count = M) then (     if (min > cost) then     min := cost ; else skip ; 
     return ) else skip ; 
    if (isDist[nowp+1]) then (     isDist[nowp+1] := false ; 
     count := count + 1 ; 
     if (not(alC) & cost < Limit) then (     var isDist2 : Sequence(boolean) ; isDist2 := isDist.subrange(1,N) ;
     execute solv(vec * -1, nowp + vec * -1, count, cost + 100, true, isDist2) ) else skip ) else skip ; 
    if (count = M) then (     if (min > cost) then     min := cost ; else skip ; 
     return ) else skip ; 
    while (true) do (     if (nowp = N) then     nowp := 0 else     if (nowp = -1) then     nowp := N - 1 ; else skip ; ;  
     if (not(isDist[nowp+1])) then (     nowp := nowp+(vec) ; 
     cost := cost+(100) ) else (     break ) ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int a=scanner.nextInt();
    int b=scanner.nextInt();
    int[] h=new int[n];
    for(int i=0 ; i<n ; i++){
      h[i]=scanner.nextInt();
    }
    Arrays.sort(h);
    System.out.println(Math.abs(h[b]-h[b-1]));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var h : Sequence(int) ; h := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     h[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    h := h->sort() ; 
    OclFile["System.out"].println(if h[b+1] - h[b - 1+1] < 0 then -(h[b+1] - h[b - 1+1]) else h[b+1] - h[b - 1+1] endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public boolean isPalindromeRange(String s,int i,int j){
    for(int k=i ; k<=i+(j-i)/2 ; k++){
      if(s.charAt(k)!=s.charAt(j-k+i))return false ;
    }
    return true ;
  }
  public boolean validPalindrome(String s){
    for(int i=0 ; i<s.length()/2 ; i++){
      if(s.charAt(i)!=s.charAt(s.length()-1-i)){
        int j=s.length()-1-i ;
        return(isPalindromeRange(s,i+1,j)|| isPalindromeRange(s,i,j-1));
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation isPalindromeRange( s : String, i : int, j : int) : boolean
  pre: true
  post: true
  activity: (         var k : int ; k := i ; while k <= i + (j - i) / 2 do ( (     if (s->at(k+1) /= s->at(j - k + i+1)) then     return false else skip )  ;     k := k + 1 ) ; 
     return true );
   operation validPalindrome( s : String) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() / 2 do ( (     if (s->at(i+1) /= s->at(s->size() - 1 - i+1)) then (     var j : int ; j := s->size() - 1 - i ;
     return (isPalindromeRange(s, i + 1, j) or isPalindromeRange(s, i, j - 1)) ) else skip )  ;     i := i + 1 ) ; 
     return true );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class test192 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int a=in.nextInt();
      int b[]=new int[n];
      boolean x=true ;
      for(int i=0 ; i<n ; i++){
        b[i]=in.nextInt();
        if(b[i]>a){
          x=false ;
        }
      }
      if(x){
        System.out.println("YES");
      }
      else {
        Arrays.sort(b);
        if(b[0]+b[1]<=a){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test192 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var x : boolean ; x := true ;
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := in.getCurrent()->toInteger() ; 
     if (b[i+1] > a) then (     x := false ) else skip )  ;     i := i + 1 ) ; 
    if (x) then (     OclFile["System.out"].println("YES") ) else (     b := b->sort() ; 
     if (b[0+1] + b[1+1] <= a) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int d=sc.nextInt();
      int[] arr=new int[n];
      int count=0,count1=0 ;
      for(int j=0 ; j<n ; j++){
        arr[j]=sc.nextInt();
      }
      Arrays.sort(arr);
      for(int j=1 ; j<n ; j++){
        if(arr[0]+arr[j]<=d){
          count++;
        }
        if(arr[j]>d){
          count1++;
        }
      }
      if((count>0)||(arr[n-1]<=d)){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var count : int ; count := 0 ;
    var count1 : int ; count1 := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     arr[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    arr := arr->sort() ; 
        var j : int ; j := 1 ; while j < n do ( (     if (arr[0+1] + arr[j+1] <= d) then (     count := count + 1 ) else skip ; 
     if (arr[j+1] > d) then (     count1 := count1 + 1 ) else skip )  ;     j := j + 1 ) ; 
    if ((count > 0) or (arr[n - 1+1] <= d)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class ReplacingElements {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      int d=sc.nextInt();
      int[] a=new int[n];
      int flag=0 ;
      int count=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      Arrays.sort(a);
      int sum=a[0]+a[1];
      for(int i=0 ; i<n ; i++){
        if(a[i]<=d){
          count++;
        }
      }
      if(count==n){
        flag=1 ;
      }
      else {
        if(sum<=d){
          flag=1 ;
        }
        else {
          flag=0 ;
        }
      }
      if(flag==1){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ReplacingElements {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var flag : int ; flag := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var sum : int ; sum := a[0+1] + a[1+1] ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] <= d) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (count = n) then (     flag := 1 ) else (     if (sum <= d) then (     flag := 1 ) else (     flag := 0 ) ) ;  
    if (flag = 1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1473A_ReplacingElements {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int amount=input.nextInt();
      int scale=input.nextInt();
      input.nextLine();
      LinkedList<Integer>list=new LinkedList<>();
      for(int i=0 ; i<amount ; i++){
        list.add(input.nextInt());
      }
      input.nextLine();
      Collections.sort(list);
      if(list.peekLast()<=scale){
        System.out.println("YES");
        continue ;
      }
      if(list.get(0)+list.get(1)<=scale){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1473A_ReplacingElements {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var amount : int ; amount := input.getCurrent()->toInteger() ;
     var scale : int ; scale := input.getCurrent()->toInteger() ;
    skip ; 
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < amount do ( (     list := list->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    skip ; 
    list := list->sort() ; 
    if (list.peekLast() <= scale) then (     OclFile["System.out"].println("YES") ; 
     continue ) else skip ; 
    if (list->at(0+1) + list->at(1+1) <= scale) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int createPalindrome(int input,int isOdd){
    int n=input ;
    int palin=input ;
    if(isOdd % 2==1){
      n/=10 ;
    }
    while(n>0){
      palin=palin*10+(n % 10);
      n/=10 ;
    }
    return palin ;
  }
  static Vector<Integer>generatePalindromes(int N){
    Vector<Integer>palindromes=new Vector<>();
    int number ;
    for(int j=0 ; j<2 ; j++){
      int i=1 ;
      while((number=createPalindrome(i++,j))<=N){
        palindromes.add(number);
      }
    }
    return palindromes ;
  }
  static String reverse(String input){
    char[] temparray=input.toCharArray();
    int left,right=0 ;
    right=temparray.length-1 ;
    for(left=0 ; left<right ; left++,right--){
      char temp=temparray[left];
      temparray[left]=temparray[right];
      temparray[right]=temp ;
    }
    return String.valueOf(temparray);
  }
  static int minimumNoOfPalindromes(int N){
    String a=String.valueOf(N);
    String b=String.valueOf(N);
    b=reverse(b);
    if(a.equals(b)){
      return 1 ;
    }
    Vector<Integer>palindromes=generatePalindromes(N);
    Collections.sort(palindromes);
    int l=0,r=palindromes.size()-1 ;
    while(l<r){
      if(palindromes.get(l)+palindromes.get(r)==N){
        return 2 ;
      }
      else if(palindromes.get(l)+palindromes.get(r)<N){
++l ;
      }
      else {
--r ;
      }
    }
    return 3 ;
  }
  public static void main(String[] args){
    int N=65 ;
    System.out.println(minimumNoOfPalindromes(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation createPalindrome( input : int, isOdd : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := input ;
     var palin : int ; palin := input ;
    if (isOdd mod 2 = 1) then (     n := n/(10) ) else skip ; 
    while (n > 0) do (     palin := palin * 10 + (n mod 10) ; 
     n := n/(10) ) ; 
    return palin 
 );
  static   operation generatePalindromes( N : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var palindromes : Sequence(int) ; palindromes := Sequence{} ;
     var number : int ;
         var j : int ; j := 0 ; while j < 2 do ( (     var i : int ; i := 1 ;
         number := createPalindrome(i, j) ;
    while ((number) <= N) do (        skip ;     skip ; (     palindromes := palindromes->including(number) ) ;     number := createPalindrome(i, j) ;
 ) )  ;     j := j + 1 ) ; 
     return palindromes );
  static   operation reverse( input : String) : String
  pre: true
  post: true
  activity: (     var temparray : Sequence(String) ; temparray := input->characters() ;
     var left : int ;
    var right : int ; right := 0 ;
    right := temparray->size() - 1 ; 
        left := 0 ; while left < right do ( (     var temp : String ; temp := temparray[left+1] ;
     temparray[left+1] := temparray[right+1] ; 
     temparray[right+1] := temp )  ;     left := left + 1 ;     right := right - 1 ) ; 
    return (temparray)->sum()  
 );
  static   operation minimumNoOfPalindromes( N : int) : int
  pre: true
  post: true
  activity: (     var a : String ; a := ((N) + "") ;
     var b : String ; b := ((N) + "") ;
    b := reverse(b) ; 
    if (a = b) then (     return 1 ) else skip ; 
    var palindromes : Sequence(int) ; palindromes := generatePalindromes(N) ;
    palindromes := palindromes->sort() ; 
    var l : int ; l := 0 ;
    var r : int ; r := palindromes->size() - 1 ;
    while (l < r) do (     if (palindromes->at(l+1) + palindromes->at(r+1) = N) then (     return 2 ) else     if (palindromes->at(l+1) + palindromes->at(r+1) < N) then (     l := l + 1 ) else (     r := r - 1 ) ;  ) ; 
    return 3 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 65 ;
     OclFile["System.out"].println(minimumNoOfPalindromes(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextLine()){
      String s=sc.nextLine();
      int n=s.length();
      int ioi=0,joi=0 ;
      for(int i=0 ; i<n-3 ; i++){
        String t=s.substring(i,i+3);
        if(t.equals("JOI")){
          joi++;
        }
        if(t.equals("IOI")){
          ioi++;
        }
      }
      System.out.println(joi);
      System.out.println(ioi);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextLine()) do (     var s : String ; s := sc.nextLine() ;
     var n : int ; n := s->size() ;
    var ioi : int ; ioi := 0 ;
    var joi : int ; joi := 0 ;
        var i : int ; i := 0 ; while i < (n)->char2byte() - 3 do ( (     var t : String ; t := s.subrange(i+1,i + 3) ;
     if (t = "JOI") then (     joi := joi + 1 ) else skip ; 
     if (t = "IOI") then (     ioi := ioi + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(joi) ; 
    OclFile["System.out"].println(ioi) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public final class Main {
  public static void main(String[] args){
    final Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    final String[] line=in.nextLine().split(" ");
    long x=Long.parseLong(line[0]);
    long k=Long.parseLong(line[1]);
    long d=Long.parseLong(line[2]);
    x=Math.abs(x);
    if((x/d)>=k){
      System.out.println(x-d*k);
    }
    else {
      k-=x/d ;
      long r=x % d ;
      if(k % 2==0){
        System.out.println(r);
      }
      else {
        System.out.println(d-r);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var line : Sequence(String) ; line := in.nextLine()->split(" ") ;
    var x : long ; x := (line[0+1])->toLong() ;
    var k : long ; k := (line[1+1])->toLong() ;
    var d : long ; d := (line[2+1])->toLong() ;
    x := if x < 0 then -(x) else x endif ; 
    if ((x / d) >= k) then (     OclFile["System.out"].println(x - d * k) ) else (     k := k-(x / d) ; 
     var r : long ; r := x mod d ;
     if (k mod 2 = 0) then (     OclFile["System.out"].println(r) ) else (     OclFile["System.out"].println(d - r) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    BigInteger X=s.nextBigInteger().abs();
    BigInteger K=s.nextBigInteger();
    BigInteger D=s.nextBigInteger();
    if(X.subtract(K.multiply(D)).signum()>=0){
      System.out.println(X.subtract(K.multiply(D)).toString());
    }
    else {
      if(X.divide(D).remainder(BigInteger.valueOf(2)).equals(K.remainder(BigInteger.valueOf(2)))){
        System.out.println(X.remainder(D).toString());
      }
      else System.out.println(X.remainder(D).subtract(D).abs().toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : long ; X := s.nextBigInteger().abs() ;
    var K : long ; K := s.nextBigInteger() ;
    var D : long ; D := s.nextBigInteger() ;
    if (X.subtract(K.multiply(D)).signum() >= 0) then (     OclFile["System.out"].println(X.subtract(K.multiply(D))+"") ) else (     if (X.divide(D).remainder((2 + "")->toLong()) = K.remainder((2 + "")->toLong())) then (     OclFile["System.out"].println(X.remainder(D)+"") ) else     OclFile["System.out"].println(X.remainder(D).subtract(D).abs()+"") ; ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static long mod(long x,long y){
    return x % y<0 ? x % y+(y<0 ?-y : y): x % y ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long x=sc.nextLong();
    x=Math.abs(x);
    long k=sc.nextLong();
    long d=sc.nextLong();
    long ans=0 ;
    if(x/d>k){
      ans=x-d*k ;
    }
    else {
      if((k-x/d)% 2==0){
        ans=mod(x,d);
      }
      else {
        ans=d-mod(x,d);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation mod( x : long, y : long) : long
  pre: true
  post: true
  activity: (     return if x mod y < 0 then x mod y + (if y < 0 then -y else y endif) else x mod y endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := sc.getCurrent()->toLong() ;
    x := if x < 0 then -(x) else x endif ; 
    var k : long ; k := sc.getCurrent()->toLong() ;
    var d : long ; d := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
    if (x / d > k) then (     ans := x - d * k ) else (     if ((k - x / d) mod 2 = 0) then (     ans := mod(x, d) ) else (     ans := d - mod(x, d) ) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.StringTokenizer ;
import static java.lang.Math.*;
public class Main {
  public static void main(final String[] args){
    final FastScanner scanner=new FastScanner(System.in);
    final long x=abs(scanner.nextLong());
    final long k=abs(scanner.nextLong());
    final long d=abs(scanner.nextLong());
    if(x/d>=k){
      System.out.println(x-d*k);
      return ;
    }
    final long k1=x/d ;
    if(k1 % 2==k % 2){
      System.out.println(abs(x-d*k1));
    }
    else {
      if(k1<=k-1){
        System.out.println(min(abs(x-d*(k1+1)),abs(x-d*(k1-1))));
      }
      else {
        System.out.println(abs(x-d*(k1-1)));
      }
    }
  }
  private static class FastScanner {
    private final BufferedReader reader ;
    private StringTokenizer tokenizer ;
    FastScanner(final InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(final IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    String nextLine(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          return reader.readLine();
        }
        catch(final IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken("\n");
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : FastScanner ; scanner := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var x : long ; x := abs(scanner.nextLong()) ;
    var k : long ; k := abs(scanner.nextLong()) ;
    var d : long ; d := abs(scanner.nextLong()) ;
    if (x / d >= k) then (     OclFile["System.out"].println(x - d * k) ; 
     return ) else skip ; 
    var k1 : long ; k1 := x / d ;
    if (k1 mod 2 = k mod 2) then (     OclFile["System.out"].println(abs(x - d * k1)) ) else (     if (k1 <= k - 1) then (     OclFile["System.out"].println(Set{abs(x - d * (k1 + 1)), abs(x - d * (k1 - 1))}->min()) ) else (     OclFile["System.out"].println(abs(x - d * (k1 - 1))) ) ) ;  
 );
  static class FastScanner {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.nextToken("\n") );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Works {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    int b=in.nextInt();
    int w=in.nextInt();
    int x=in.nextInt();
    long c=in.nextInt();
    if(b>=0 && b<w && x>0 && x<w)if(c<=a)System.out.println(0);
    else {
      long sec=(long)Math.ceil(1.0*((c-a)*x-b)/(w-x));
      System.out.println(sec+c-a);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Works {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var w : int ; w := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
    var c : long ; c := in.getCurrent()->toInteger() ;
    if (b >= 0 & b < w & x > 0 & x < w) then     if (c <= a) then     OclFile["System.out"].println(0) else (     var sec : long ; sec := (1.0 * ((c - a) * x - b) / (w - x))->ceil()->oclAsType(long) ;
     OclFile["System.out"].println(sec + c - a) ) ;  else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=100002 ;
  static void printUniqueElementsInSuffix(int[] arr,int n,int[] q,int m){
    int[] aux=new int[MAX];
    int[] mark=new int[MAX];
    aux[n-1]=1 ;
    mark[arr[n-1] ]=1 ;
    for(int i=n-2 ; i>=0 ; i--){
      if(mark[arr[i] ]==0){
        aux[i]=aux[i+1]+1 ;
        mark[arr[i] ]=1 ;
      }
      else {
        aux[i]=aux[i+1];
      }
    }
    for(int i=0 ; i<m ; i++){
      System.out.println(aux[q[i]-1]);
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,1,2,3,4,10000,999 };
      int n=arr.length ;
      int q[]={
        1,3,6 };
        int m=q.length ;
        printUniqueElementsInSuffix(arr,n,q,m);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100002;
  static   operation printUniqueElementsInSuffix( arr : Sequence(int), n : int, q : Sequence(int), m : int) : void
  pre: true
  post: true
  activity: (     var aux : Sequence(int) ; aux := Integer.subrange(1,MAX)->collect(0) ;
     var mark : Sequence(int) ; mark := Integer.subrange(1,MAX)->collect(0) ;
    aux[n - 1+1] := 1 ; 
    mark[arr[n - 1+1]+1] := 1 ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (mark[arr[i+1]+1] = 0) then (     aux[i+1] := aux[i + 1+1] + 1 ; 
     mark[arr[i+1]+1] := 1 ) else (     aux[i+1] := aux[i + 1+1] ) )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     OclFile["System.out"].println(aux[q[i+1] - 1+1]) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,1,2,3,4,10000,999} ;
     var n : int ; n := arr->size() ;
    var q : Sequence(int) ; q := Sequence{1,3,6} ;
    var m : int ; m := q->size() ;
    execute printUniqueElementsInSuffix(arr, n, q, m) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    int C=Integer.parseInt(sc.next());
    int K=Integer.parseInt(sc.next());
    int[] T=new int[N];
    for(int i=0 ; i<N ; i++){
      T[i]=Integer.parseInt(sc.next());
    }
    sc.close();
    Arrays.sort(T);
    int cnt=1 ;
    int bus_time=T[0];
    int bus=1 ;
    for(int i=1 ; i<N ; i++){
      if(cnt==C || T[i]>bus_time+K){
        cnt=0 ;
        bus_time=T[i];
        bus++;
      }
      cnt++;
    }
    System.out.println(bus);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var C : int ; C := (sc.getCurrent())->toInteger() ;
    var K : int ; K := (sc.getCurrent())->toInteger() ;
    var T : Sequence(int) ; T := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     T[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    T := T->sort() ; 
    var cnt : int ; cnt := 1 ;
    var bus_time : int ; bus_time := T[0+1] ;
    var bus : int ; bus := 1 ;
        var i : int ; i := 1 ; while i < N do ( (     if (cnt = C or T[i+1] > bus_time + K) then (     cnt := 0 ; 
     bus_time := T[i+1] ; 
     bus := bus + 1 ) else skip ; 
     cnt := cnt + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(bus) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    int N=sc.nextInt();
    int M=sc.nextInt();
    int p=sc.nextInt();
    int[] d=new int[M+1];
    for(int i=0 ; i<M ; i++)d[i]=sc.nextInt();
    d[M]=p ;
    Arrays.sort(d);
    int min=Integer.MAX_VALUE ;
    int start=Arrays.binarySearch(d,p);
    for(int i=0 ; i<=M ; i++){
      int right=0 ;
      if(start+i>M){
        right+=N-d[start];
        right+=d[(start+i)%(M+1)];
      }
      else {
        right+=d[start+i]-d[start];
      }
      int left=0 ;
      if(start+i+1>M){
        left+=d[start]-d[(start+i+1)%(M+1)];
      }
      else {
        left+=d[start];
        left+=N-d[(start+i+1)%(M+1)];
      }
      min=Math.min(min,Math.min(right*2+left,right+left*2));
    }
    System.out.println(min*100);
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var M : int ; M := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
    var d : Sequence(int) ; d := Integer.subrange(1,M + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < M do (     d[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    d[M+1] := p ; 
    d := d->sort() ; 
    var min : int ; min := 2147483647 ;
    var start : int ; start := (d->indexOf(p) - 1) ;
        var i : int ; i := 0 ; while i <= M do ( (     var right : int ; right := 0 ;
     if (start + i > M) then (     right := right+(N - d[start+1]) ; 
     right := right+(d[(start + i) mod (M + 1)+1]) ) else (     right := right+(d[start + i+1] - d[start+1]) ) ;  
    var left : int ; left := 0 ;
    if (start + i + 1 > M) then (     left := left+(d[start+1] - d[(start + i + 1) mod (M + 1)+1]) ) else (     left := left+(d[start+1]) ; 
     left := left+(N - d[(start + i + 1) mod (M + 1)+1]) ) ;  
    min := Set{min, Set{right * 2 + left, right + left * 2}->min()}->min() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min * 100) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
class Main {
  public static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  public static PrintWriter pw=new PrintWriter(System.out);
  public static String line ;
  public static StringTokenizer st ;
  public static ArrayList<ArrayList<Integer>>adjList ;
  public static int[] dx={
-1,0,1,0,-1,1,1,-1 };
    public static int[] dy={
      0,1,0,-1,1,1,-1,-1 };
      public static int INF=0x3f3f3f3f ;
      public static long LINF=0x3f3f3f3f3f3f3f3fL ;
      public static int MOD=1000000007 ;
      public static void main(String[] args)throws Exception {
        st=new StringTokenizer(br.readLine());
        int N=Integer.parseInt(st.nextToken());
        int C=Integer.parseInt(st.nextToken());
        int K=Integer.parseInt(st.nextToken());
        int[] A=new int[N];
        for(int i=0 ; i<N ; i++){
          A[i]=Integer.parseInt(br.readLine());
        }
        Arrays.sort(A);
        int last=A[0];
        int ans=1 ;
        int passengers=1 ;
        for(int i=1 ; i<N ; i++){
          if(last+K<A[i] || passengers>=C){
            ans++;
            last=A[i];
            passengers=1 ;
          }
          else {
            passengers++;
          }
        }
        pw.print(ans+"\n");
        pw.close();
        br.close();
      }
    }
    class Pair {
      public int a,b ;
      Pair(int a,int b){
        this.a=a ;
        this.b=b ;
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute line : String;
  static   attribute st : OclIterator;
  static   attribute adjList : Sequence(Sequence(int));
  static   attribute dx : Sequence(int) := Sequence{-1,0,1,0,-1,1,1,-1};
  static   attribute dy : Sequence(int) := Sequence{0,1,0,-1,1,1,-1,-1};
  static   attribute INF : int := 0x3f3f3f3f;
  static   attribute LINF : long := 0x3f3f3f3f3f3f3f3fL;
  static   attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var N : int ; N := (st.next())->toInteger() ;
    var C : int ; C := (st.next())->toInteger() ;
    var K : int ; K := (st.next())->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    var last : int ; last := A[0+1] ;
    var ans : int ; ans := 1 ;
    var passengers : int ; passengers := 1 ;
        var i : int ; i := 1 ; while i < N do ( (     if (last + K < A[i+1] or passengers >= C) then (     ans := ans + 1 ; 
     last := A[i+1] ; 
     passengers := 1 ) else (     passengers := passengers + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}
class Pair {
   attribute a : int;
   static operation newPair( a : int, b : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int len=line.length()-1 ;
      int joi=0 ;
      int ioi=0 ;
      for(int i=1 ; i<len ; i++){
        if(line.charAt(i)=='O'){
          if(line.charAt(i+1)=='I'){
            if(line.charAt(i-1)=='J'){
              joi++;
            }
            else if(line.charAt(i-1)=='I'){
              ioi++;
            }
          }
        }
      }
      System.out.println(joi+"\n"+ioi);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var len : int ; len := line->size() - 1 ;
     var joi : int ; joi := 0 ;
    var ioi : int ; ioi := 0 ;
        var i : int ; i := 1 ; while i < len do ( (     if (line->at(i+1) = 'O') then (     if (line->at(i + 1+1) = 'I') then (     if (line->at(i - 1+1) = 'J') then (     joi := joi + 1 ) else     if (line->at(i - 1+1) = 'I') then (     ioi := ioi + 1 ) else skip ; ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(joi + "\n" + ioi) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    long n=in.nextLong();
    long c=in.nextLong();
    long k=in.nextLong();
    ArrayList<Long>t=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      t.add(in.nextLong());
    }
    Collections.sort(t);
    long count=0 ;
    int i=0 ;
    while(t.size()>0){
      while(i<t.size()&& t.get(0)>=t.get(i)-k && i<c){
        i++;
      }
      count++;
      for(int j=0 ; j<i ; j++){
        t.remove(0);
      }
      i=0 ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toLong() ;
    var c : long ; c := in.getCurrent()->toLong() ;
    var k : long ; k := in.getCurrent()->toLong() ;
    var t : Sequence(long) ; t := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     t := t->including(in.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    t := t->sort() ; 
    var count : long ; count := 0 ;
    var i : int ; i := 0 ;
    while (t->size() > 0) do (     while (i < t->size() & t->at(0+1) >= t->at(i+1) - k & i < c) do (     i := i + 1 ) ; 
     count := count + 1 ; 
         var j : int ; j := 0 ; while j < i do ( (     t := t->excludingAt(0+1) )  ;     j := j + 1 ) ; 
     i := 0 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int N=gi();
    int C=gi();
    int K=gi();
    int[] T=new int[N];
    Queue<Integer>q=new LinkedList<Integer>();
    for(int i=0 ; i<N ; i++){
      T[i]=gi();
    }
    Arrays.parallelSort(T);
    long s=0 ;
    long bc=0 ;
    for(int i=0 ; i<N ; i++){
      if((q.size()!=0)&&((q.size()==C)||(K<T[i]-q.peek()))){
        q.clear();
        bc++;
      }
      q.add(T[i]);
    }
    if(q.size()!=0)bc++;
    System.out.println(bc);
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : int ; N := gi() ;
    var C : int ; C := gi() ;
    var K : int ; K := gi() ;
    var T : Sequence(int) ; T := Integer.subrange(1,N)->collect(0) ;
    var q : Sequence(int) ; q := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     T[i+1] := gi() )  ;     i := i + 1 ) ; 
    T := T->sort() ; 
    var s : long ; s := 0 ;
    var bc : long ; bc := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if ((q->size() /= 0) & ((q->size() = C) or (K < T[i+1] - q->min()))) then (     q := q->intersection(Set{}) ; 
     bc := bc + 1 ) else skip ; 
     q := q->including(T[i+1]) )  ;     i := i + 1 ) ; 
    if (q->size() /= 0) then     bc := bc + 1 ; else skip ; 
    OclFile["System.out"].println(bc) ; 
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    new Main().solve(in,out);
    in.close();
    out.close();
  }
  public void solve(Scanner in,PrintWriter out){
    int n=in.nextInt();
    int c=in.nextInt();
    int k=in.nextInt();
    int[] t=new int[n];
    for(int i=0 ; i<n ; ++i){
      t[i]=in.nextInt();
    }
    Arrays.sort(t);
    int p=1,ind=0,ans=1 ;
    for(int i=1 ; i<n ; ++i){
      if(p==c || t[i]-t[ind]>k){
        p=1 ;
        ind=i ;
++ans ;
      }
      else {
++p ;
      }
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    Main.newMain().solve(in, out) ; 
    skip ; 
    skip ; 
 );
   operation solve( in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var c : int ; c := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     t[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    t := t->sort() ; 
    var p : int ; p := 1 ;
    var ind : int ; ind := 0 ;
    var ans : int ; ans := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     if (p = c or t[i+1] - t[ind+1] > k) then (     p := 1 ; 
     ind := i ; 
     ans := ans + 1 ) else (     p := p + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Toy {
  public static void main(String args[]){
    int o,c,i,ogot,cgot ;
    Scanner sc=new Scanner(System.in);
    c=sc.nextInt();
    o=sc.nextInt();
    if(o>1 && c>=o-1){
      cgot=o-1 ;
      while(cgot<c){
        cgot=cgot+2 ;
      }
      if(cgot==c)System.out.println("Yes");
      else System.out.println("No");
    }
    else if(c>=o){
      System.out.println("No");
    }
    else if(o==1){
      System.out.println("Yes");
    }
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Toy {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : int ;
    var c : int ;
    var i : int ;
    var ogot : int ;
    var cgot : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    c := sc.getCurrent()->toInteger() ; 
    o := sc.getCurrent()->toInteger() ; 
    if (o > 1 & c >= o - 1) then (     cgot := o - 1 ; 
     while (cgot < c) do (     cgot := cgot + 2 ) ; 
     if (cgot = c) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; ) else     if (c >= o) then (     OclFile["System.out"].println("No") ) else     if (o = 1) then (     OclFile["System.out"].println("Yes") ) else     OclFile["System.out"].println("No") ; ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long y=in.nextLong(),x=in.nextLong();
    long need=y-(x-1);
    if(x==0 && y>0){
      pw.println("No");
      pw.close();
      return ;
    }
    if(need<0)pw.println("No");
    else if(need==0 && x==1)pw.println("Yes");
    else if(need % 2==0 && x!=1)pw.println("Yes");
    else pw.println("No");
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var y : long ; y := in.getCurrent()->toLong() ;
    var x : long ; x := in.getCurrent()->toLong() ;
    var need : long ; need := y - (x - 1) ;
    if (x = 0 & y > 0) then (     skip ; 
     skip ; 
     return ) else skip ; 
    if (need < 0) then     skip else     if (need = 0 & x = 1) then     skip else     if (need mod 2 = 0 & x /= 1) then     skip else     skip ; ;  ;  ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class demo {
  public static void main(String[] args){
    int x,y ;
    Scanner sc=new Scanner(System.in);
    x=sc.nextInt();
    y=sc.nextInt();
    if(y<2){
      if(x==0 && y==1)System.out.print("Yes");
      else System.out.print("No");
    }
    else {
      if(y==(x+1)||(x-y)% 2==1){
        System.out.print("Yes");
      }
      else {
        System.out.print("No");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class demo {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ;
    var y : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    x := sc.getCurrent()->toInteger() ; 
    y := sc.getCurrent()->toInteger() ; 
    if (y < 2) then (     if (x = 0 & y = 1) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; ) else (     if (y = (x + 1) or (x - y) mod 2 = 1) then (     OclFile["System.out"].print("Yes") ) else (     OclFile["System.out"].print("No") ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int count=0 ;
    TreeMap<String,ArrayList<Integer>>map=new TreeMap<>();
    for(int i=0 ; i<n ; i++){
      int query=scan.nextInt();
      String key=scan.next();
      switch(query){
        case 0 : int value=scan.nextInt();
        if(! map.containsKey(key))map.put(key,new ArrayList<Integer>());
        map.get(key).add(value);
        break ;
        case 1 : if(map.get(key)!=null)for(Integer x : map.get(key)){
          System.out.println(x);
        }
        break ;
        case 2 : if(map.get(key)!=null){
          map.remove(key);
        }
        break ;
        case 3 : String tilKey=scan.next();
        Map<String,ArrayList<Integer>>subM=map.subMap(key,true,tilKey,true);
        for(String x : subM.keySet()){
          for(Integer x2 : subM.get(x)){
            System.out.println(x+" "+x2);
          }
        }
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var map : Map(String,Sequence(int)) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var query : int ; query := scan.getCurrent()->toInteger() ;
     var key : String ; key := scan.getCurrent() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (query) ; 
       if _switchval = 0 then
     var value : int ; value := scan.getCurrent()->toInteger() ;
    if (not(map->keys()->includes(key))) then     map := map->union(Map{key |-> Sequence{}}) ; else skip ; 
    map->at(key)->excludes(value) ; 
    break 
   else skip ;
       if _switchval = 1 then
     if (map->at(key) /= null) then     for (x : map->at(key)) do ( (     OclFile["System.out"].println(x) )  ) ; else skip ; 
    break 
   else skip ;
       if _switchval = 2 then
     if (map->at(key) /= null) then (     map := map->antirestrict(Set{key}) ) else skip ; 
    break 
   else skip ;
       if _switchval = 3 then
     var tilKey : String ; tilKey := scan.getCurrent() ;
    var subM : Map(String,Sequence(int)) ; subM := map->restrict( _key | _key < true & _key >= key ) ;
    for (x : subM->keys()) do ( (     for (x2 : subM->at(x)) do ( (     OclFile["System.out"].println(x + " " + x2) )  ) )  ) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Iterator ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.TreeMap ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int q=sc.nextInt();
      TreeMap<String,List<Integer>>m=new TreeMap<>();
      for(int i=0 ; i<q ; i++){
        int query=sc.nextInt();
        Iterator<Integer>valueItr ;
        switch(query){
          case 0 : String key=sc.next();
          if(! m.containsKey(key)){
            m.put(key,new ArrayList<Integer>());
          }
          m.get(key).add(sc.nextInt());
          break ;
          case 1 : valueItr=m.getOrDefault(sc.next(),new ArrayList<Integer>()).iterator();
          if(valueItr.hasNext()){
            System.out.println(valueItr.next());
            while(valueItr.hasNext()){
              System.out.println(valueItr.next());
            }
          }
          break ;
          case 2 : m.remove(sc.next());
          break ;
          case 3 : Map<String,List<Integer>>sub=m.subMap(sc.next(),true,sc.next(),true);
          for(Map.Entry<String,List<Integer>>entry : sub.entrySet()){
            valueItr=entry.getValue().iterator();
            if(valueItr.hasNext()){
              System.out.println(String.format("%s %d",entry.getKey(),valueItr.next()));
              while(valueItr.hasNext()){
                System.out.println(String.format("%s %d",entry.getKey(),valueItr.next()));
              }
            }
          }
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var q : int ; q := sc.getCurrent()->toInteger() ;
     var m : Map(String,Sequence(int)) ; m := Map{} ;
         var i : int ; i := 0 ; while i < q do ( (     var query : int ; query := sc.getCurrent()->toInteger() ;
     var valueItr : OclIterator ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (query) ; 
       if _switchval = 0 then
     var key : String ; key := sc.getCurrent() ;
    if (not(m->keys()->includes(key))) then (     m := m->union(Map{key |-> Sequence{}}) ) else skip ; 
    m->at(key)->excludes(sc.getCurrent()->toInteger()) ; 
    break 
   else skip ;
       if _switchval = 1 then
     valueItr := (if m->keys()->contains(sc.getCurrent()) then m->at(sc.getCurrent()) else Sequence{} endif)->iterator() ; 
    if (valueItr.hasNext()) then (     OclFile["System.out"].println(valueItr.next()) ; 
     while (valueItr.hasNext()) do (     OclFile["System.out"].println(valueItr.next()) ) ) else skip ; 
    break 
   else skip ;
       if _switchval = 2 then
     m := m->antirestrict(Set{sc.getCurrent()}) ; 
    break 
   else skip ;
       if _switchval = 3 then
     var sub : Map(String,Sequence(int)) ; sub := m->restrict( _key | _key < true & _key >= sc.getCurrent() ) ;
    for (entry : sub->asSet()) do ( (     valueItr := entry.getValue()->iterator() ; 
     if (valueItr.hasNext()) then (     OclFile["System.out"].println(StringLib.format("%s %d",Sequence{entry.getKey(),valueItr.next()})) ; 
     while (valueItr.hasNext()) do (     OclFile["System.out"].println(StringLib.format("%s %d",Sequence{entry.getKey(),valueItr.next()})) ) ) else skip )  ) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    int p=scanner.nextInt();
    int[] d=new int[m];
    for(int i=0 ; i<m ; i++){
      int a=scanner.nextInt();
      d[i]=(a-p+n)% n ;
    }
    Arrays.sort(d);
    int ret=Math.min(n-d[0],d[m-1]);
    for(int i=0 ; i<m ; i++){
      if(i>0){
        int a=2*(n-d[i])+d[i-1];
        ret=Math.min(ret,a);
      }
      if(i<m-1){
        int b=2*d[i]+n-d[i+1];
        ret=Math.min(ret,b);
      }
    }
    System.out.println(ret*100);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var p : int ; p := scanner.getCurrent()->toInteger() ;
    var d : Sequence(int) ; d := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     d[i+1] := (a - p + n) mod n )  ;     i := i + 1 ) ; 
    d := d->sort() ; 
    var ret : int ; ret := Set{n - d[0+1], d[m - 1+1]}->min() ;
        var i : int ; i := 0 ; while i < m do ( (     if (i > 0) then (     var a : int ; a := 2 * (n - d[i+1]) + d[i - 1+1] ;
     ret := Set{ret, a}->min() ) else skip ; 
     if (i < m - 1) then (     var b : int ; b := 2 * d[i+1] + n - d[i + 1+1] ;
     ret := Set{ret, b}->min() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ret * 100) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int q=Integer.parseInt(str[0]);
    SortedMap<String,ArrayList<Integer>>mpa=new TreeMap<String,ArrayList<Integer>>();
    for(int i=0 ; i<q ; i++){
      str=br.readLine().split(" ");
      int op=Integer.parseInt(str[0]);
      if(op==0){
        String key=str[1];
        int x=Integer.parseInt(str[2]);
        if(mpa.get(key)==null){
          mpa.put(key,new ArrayList<Integer>());
        }
        mpa.get(key).add(x);
      }
      else if(op==1){
        String key=str[1];
        if(mpa.get(key)==null)continue ;
        Iterator<Integer>it=mpa.get(key).iterator();
        while(it.hasNext())System.out.println(it.next());
      }
      else if(op==2){
        String key=str[1];
        if(mpa.get(key)==null)continue ;
        mpa.get(key).clear();
      }
      else {
        String L=str[1];
        String R=str[2]+"#" ;
        SortedMap<String,ArrayList<Integer>>mpb=mpa.subMap(L,R);
        for(String s : mpb.keySet()){
          for(Integer num : mpb.get(s))System.out.println(s+" "+num);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var q : int ; q := (str[0+1])->toInteger() ;
    var mpa : Map(String,Sequence(int)) ; mpa := Map{} ;
        var i : int ; i := 0 ; while i < q do ( (     str := br.readLine()->split(" ") ; 
     var op : int ; op := (str[0+1])->toInteger() ;
     if (op = 0) then (     var key : String ; key := str[1+1] ;
     var x : int ; x := (str[2+1])->toInteger() ;
     if (mpa->at(key) = null) then (     mpa := mpa->union(Map{key |-> Sequence{}}) ) else skip ; 
     mpa->at(key)->excludes(x) ) else     if (op = 1) then (     var key : String ; key := str[1+1] ;
     if (mpa->at(key) = null) then     continue else skip ; 
     var it : OclIterator ; it := mpa->at(key)->iterator() ;
     while (it.hasNext()) do     OclFile["System.out"].println(it.next()) ; ) else     if (op = 2) then (     var key : String ; key := str[1+1] ;
     if (mpa->at(key) = null) then     continue else skip ; 
     mpa := mpa->at(key)->intersection(Set{}) ) else (     var L : String ; L := str[1+1] ;
     var R : String ; R := str[2+1] + "#" ;
     var mpb : Map(String,Sequence(int)) ; mpb := mpa->restrict( _key | _key < R & _key >= L ) ;
     for (s : mpb->keys()) do ( (     for (num : mpb->at(s)) do (     OclFile["System.out"].println(s + " " + num) ;  ) )  ) ) ;  ;  )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Map ;
import java.util.Objects ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    TreeMap<String,List<Integer>>map=new TreeMap<>();
    int q=sc.nextInt();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<q ; i++){
      int op=sc.nextInt();
      String key=sc.next();
      switch(op){
        case 0 : if(map.get(key)==null){
          map.put(key,new ArrayList<>());
        }
        map.get(key).add(sc.nextInt());
        break ;
        case 1 : if(! Objects.isNull(map.get(key))){
          for(int num : map.get(key)){
            sb.append(num);
            sb.append('\n');
          }
        }
        break ;
        case 2 : map.remove(key);
        break ;
        case 3 : String r=sc.next();
        Map<String,List<Integer>>submap=map.subMap(key,r);
        int count=0 ;
        for(String str : submap.keySet()){
          List<Integer>list=map.get(str);
          for(int num : list){
            sb.append(str);
            sb.append(' ');
            sb.append(map.get(str).get(count++));
            sb.append('\n');
          }
          count=0 ;
        }
        count=0 ;
        if(map.get(r)!=null){
          for(int num : map.get(r)){
            sb.append(r);
            sb.append(' ');
            sb.append(map.get(r).get(count++));
            sb.append('\n');
          }
        }
        break ;
      }
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var map : Map(String,Sequence(int)) ; map := Map{} ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < q do ( (     var op : int ; op := sc.getCurrent()->toInteger() ;
     var key : String ; key := sc.getCurrent() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (op) ; 
       if _switchval = 0 then
     if (map->at(key) = null) then (     map := map->union(Map{key |-> Sequence{}}) ) else skip ; 
    map->at(key)->excludes(sc.getCurrent()->toInteger()) ; 
    break 
   else skip ;
       if _switchval = 1 then
     if (not(Objects.isNull(map->at(key)))) then (     for (num : map->at(key)) do ( (     sb := sb + StringLib.newString(num) ; 
     sb := sb + StringLib.newString('
') )  ) ) else skip ; 
    break 
   else skip ;
       if _switchval = 2 then
     map := map->antirestrict(Set{key}) ; 
    break 
   else skip ;
       if _switchval = 3 then
     var r : String ; r := sc.getCurrent() ;
    var submap : Map(String,Sequence(int)) ; submap := map->restrict( _key | _key < r & _key >= key ) ;
    var count : int ; count := 0 ;
    for (str : submap->keys()) do ( (     var list : Sequence(int) ; list := map->at(str) ;
     for (num : list) do ( (     sb := sb + StringLib.newString(str) ; 
     sb := sb + StringLib.newString(' ') ; 
     sb := sb + StringLib.newString(map->at(str)->at(count+1)) ; 
     sb := sb + StringLib.newString('
') )  ) ; 
     count := 0 )  ) ; 
    count := 0 ; 
    if (map->at(r) /= null) then (     for (num : map->at(r)) do ( (     sb := sb + StringLib.newString(r) ; 
     sb := sb + StringLib.newString(' ') ; 
     sb := sb + StringLib.newString(map->at(r)->at(count+1)) ; 
     sb := sb + StringLib.newString('
') )  ) ) else skip ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.math.*;
import java.util.*;
class Main {
  int count(String s,String pat){
    int res=0 ;
    for(int i=-1 ; ; ){
      i=s.indexOf(pat,i+1);
      if(i==-1)break ;
      res++;
    }
    return res ;
  }
  void run()throws IOException {
    while(hasNext()){
      String s=next();
      int joi=count(s,"JOI");
      int ioi=count(s,"IOI");
      writer.println(joi);
      writer.println(ioi);
    }
  }
  BufferedReader reader ;
  StringTokenizer tokenizer ;
  PrintWriter writer ;
  boolean hasNext()throws IOException {
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      String s=reader.readLine();
      if(s==null)return false ;
      tokenizer=new StringTokenizer(s);
    }
    return true ;
  }
  String next()throws IOException {
    while(tokenizer==null || ! tokenizer.hasMoreTokens())tokenizer=new StringTokenizer(reader.readLine());
    return tokenizer.nextToken();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  BigInteger nextBigInteger()throws IOException {
    return new BigInteger(next());
  }
  void main(){
    try {
      reader=new BufferedReader(new InputStreamReader(System.in));
      tokenizer=null ;
      writer=new PrintWriter(System.out);
      run();
      reader.close();
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  public static void main(String[] args){
    new Main().main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation count( s : String, pat : String) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := -1 ; while true do ( (     i := s.subrange(i + 1+1)->indexOf(pat+"") + i + 1 - 1  ; 
     if (i = -1) then     break else skip ; 
     res := res + 1 )  ) ; 
     return res );
   operation run() : void
  pre: true
  post: true
  activity: (     while (hasNext()) do (     var s : String ; s := next() ;
     var joi : int ; joi := count(s, "JOI") ;
    var ioi : int ; ioi := count(s, "IOI") ;
    writer.println(joi) ; 
    writer.println(ioi) ; 
 ) );
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   attribute writer : OclFile;
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     var s : String ; s := reader.readLine() ;
     if (s = null) then     return false else skip ; 
     tokenizer := OclIterator.newOclIterator_String(s) ) ; 
     return true );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ; ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextBigInteger() : long
  pre: true
  post: true
  activity: (     return long(next()) );
   operation main() : void
  pre: true
  post: true
  activity: (     try (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := null ; 
    writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute run() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().main() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    TreeMap<String,ArrayList<Integer>>map=new TreeMap<>();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      int type=sc.nextInt();
      String key=sc.next();
      if(type==0){
        int value=sc.nextInt();
        if(! map.containsKey(key)){
          map.put(key,new ArrayList<>());
        }
        map.get(key).add(value);
      }
      else if(type==1){
        if(map.containsKey(key)){
          for(int x : map.get(key)){
            sb.append(x).append("\n");
          }
        }
      }
      else if(type==2){
        map.remove(key);
      }
      else {
        String end=sc.next();
        key=map.lowerKey(key);
        if(key==null){
          key="" ;
        }
        while((key=map.higherKey(key))!=null && key.compareTo(end)<=0){
          for(int x : map.get(key)){
            sb.append(key).append(" ").append(x).append("\n");
          }
        }
      }
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var map : Map(String,Sequence(int)) ; map := Map{} ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     var type : int ; type := sc.getCurrent()->toInteger() ;
     var key : String ; key := sc.getCurrent() ;
     if (type = 0) then (     var value : int ; value := sc.getCurrent()->toInteger() ;
     if (not(map->keys()->includes(key))) then (     map := map->union(Map{key |-> Sequence{}}) ) else skip ; 
     map->at(key)->excludes(value) ) else     if (type = 1) then (     if (map->keys()->includes(key)) then (     for (x : map->at(key)) do ( (     sb := sb + StringLib.newString(x) + StringLib.newString("\n") )  ) ) else skip ) else     if (type = 2) then (     map := map->antirestrict(Set{key}) ) else (     var end : String ; end := sc.getCurrent() ;
     key := map.lowerKey(key) ; 
     if (key = null) then (     key := "" ) else skip ; 
         key := map.higherKey(key) ;
    while ((key) /= null & key->compareTo(end) <= 0) do (    skip ; (     for (x : map->at(key)) do ( (     sb := sb + StringLib.newString(key) + StringLib.newString(" ") + StringLib.newString(x) + StringLib.newString("\n") )  ) ) ;     key := map.higherKey(key) ;
 ) ) ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static int[] fix(int[] A){
    for(int i=0 ; i<A.length ; i++){
      if(A[i]!=-1 && A[i]!=i){
        int x=A[i];
        while(A[x]!=-1 && A[x]!=x){
          int y=A[x];
          A[x]=x ;
          x=y ;
        }
        A[x]=x ;
        if(A[i]!=i){
          A[i]=-1 ;
        }
      }
    }
    return A ;
  }
  public static void main(String[] args){
    int A[]={
-1,-1,6,1,9,3,2,-1,4,-1 };
      System.out.println(Arrays.toString(fix(A)));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation fix( A : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < A->size() do ( (     if (A[i+1] /= -1 & A[i+1] /= i) then (     var x : int ; x := A[i+1] ;
     while (A[x+1] /= -1 & A[x+1] /= x) do (     var y : int ; y := A[x+1] ;
     A[x+1] := x ; 
     x := y ) ; 
     A[x+1] := x ; 
     if (A[i+1] /= i) then (     A[i+1] := -1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
     return A );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{-1,-1,6,1,9,3,2,-1,4,-1} ;
     OclFile["System.out"].println((fix(A) + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minSubarray(int A[],int n){
    int minValue=A[0];
    for(int i=1 ; i<n ; i++){
      if(A[i]<minValue)minValue=A[i];
    }
    int maxValue=A[0];
    for(int i=1 ; i<n ; i++){
      if(A[i]>maxValue)maxValue=A[i];
    }
    int pos_min=-1,pos_max=-1,ans=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(A[i]==minValue)pos_min=i ;
      if(A[i]==maxValue)pos_max=i ;
      if(pos_max!=-1 && pos_min!=-1)ans=Math.min(ans,Math.abs(pos_min-pos_max)+1);
    }
    return ans ;
  }
  public static void main(String args[]){
    int A[]={
      1,5,9,7,1,9,4 };
      int n=A.length ;
      System.out.println(minSubarray(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minSubarray( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var minValue : int ; minValue := A[0+1] ;
         var i : int ; i := 1 ; while i < n do ( (     if (A[i+1] < minValue) then     minValue := A[i+1] ; else skip )  ;     i := i + 1 ) ; 
    var maxValue : int ; maxValue := A[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     if (A[i+1] > maxValue) then     maxValue := A[i+1] ; else skip )  ;     i := i + 1 ) ; 
    var pos_min : int ; pos_min := -1 ;
    var pos_max : int ; pos_max := -1 ;
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     if (A[i+1] = minValue) then     pos_min := i ; else skip ; 
     if (A[i+1] = maxValue) then     pos_max := i ; else skip ; 
     if (pos_max /= -1 & pos_min /= -1) then     ans := Set{ans, if pos_min - pos_max < 0 then -(pos_min - pos_max) else pos_min - pos_max endif + 1}->min() ; else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{1,5,9,7,1,9,4} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].println(minSubarray(A, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class GFG {
  public static void findWord(String c,int n){
    int co=0,i ;
    char s[]=new char[n];
    for(i=0 ; i<n ; i++){
      if(i<n/2)co++;
      else co=n-i ;
      if((c.charAt(i)+co)<=122)s[i]=(char)((int)c.charAt(i)+co);
      else s[i]=(char)((int)c.charAt(i)+co-26);
    }
    String str=Arrays.toString(s);
    System.out.println(str);
  }
  public static void main(String args[]){
    String s="abcd" ;
    findWord(s,s.length());
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findWord( c : String, n : int) : void
  pre: true
  post: true
  activity: (     var co : int ; co := 0 ;
    var i : int ;
     var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do ( (     if (i < n / 2) then     co := co + 1 else     co := n - i ; ;  
     if ((c->at(i+1) + co) <= 122) then     s[i+1] := (c->at(i+1)->oclAsType(int) + co)->oclAsType(String) ; else     s[i+1] := (c->at(i+1)->oclAsType(int) + co - 26)->oclAsType(String) ; )  ;     i := i + 1 ) ; 
    var str : String ; str := (s + "") ;
    OclFile["System.out"].println(str) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abcd" ;
     execute findWord(s, s->size()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class BotTrust {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new FileReader("A-large.in"));
      int T=Integer.parseInt(br.readLine());
      PrintWriter pw=new PrintWriter(new FileWriter("output"));
      for(int I=1 ; I<=T ; I++){
        StringTokenizer st=new StringTokenizer(br.readLine()," \n\t",false);
        int n=Integer.parseInt(st.nextToken());
        int Opos=1,Bpos=1 ;
        int Oextra=0,Bextra=0 ;
        int ret=0 ;
        for(int i=0 ; i<n ; i++){
          int nextBot=(st.nextToken().equals("O")? 0 : 1);
          int button=Integer.parseInt(st.nextToken());
          if(nextBot==0){
            int dist=Math.abs(Opos-button);
            if(Oextra>=dist)dist=0 ;
            else dist-=Oextra ;
            ret+=dist+1 ;
            Bextra+=dist+1 ;
            Oextra=0 ;
            Opos=button ;
          }
          else {
            int dist=Math.abs(Bpos-button);
            if(Bextra>=dist)dist=0 ;
            else dist-=Bextra ;
            ret+=dist+1 ;
            Oextra+=dist+1 ;
            Bextra=0 ;
            Bpos=button ;
          }
        }
        pw.println("Case #"+I+": "+ret);
      }
      br.close();
      pw.flush();
      pw.close();
    }
    catch(IOException ie){
      ie.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BotTrust {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("A-large.in"))) ;
     var T : int ; T := (br.readLine())->toInteger() ;
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output"))) ;
        var I : int ; I := 1 ; while I <= T do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String_String(br.readLine(), " \n\t", false) ;
     var n : int ; n := (st.next())->toInteger() ;
    var Opos : int ; Opos := 1 ;
    var Bpos : int ; Bpos := 1 ;
    var Oextra : int ; Oextra := 0 ;
    var Bextra : int ; Bextra := 0 ;
    var ret : int ; ret := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var nextBot : int ; nextBot := (if st.next() = "O" then 0 else 1 endif) ;
     var button : int ; button := (st.next())->toInteger() ;
     if (nextBot = 0) then (     var dist : int ; dist := if Opos - button < 0 then -(Opos - button) else Opos - button endif ;
     if (Oextra >= dist) then     dist := 0 else     dist := dist-(Oextra) ; ;  
    ret := ret+(dist + 1) ; 
    Bextra := Bextra+(dist + 1) ; 
    Oextra := 0 ; 
    Opos := button ; 
 ) else (     var dist : int ; dist := if Bpos - button < 0 then -(Bpos - button) else Bpos - button endif ;
     if (Bextra >= dist) then     dist := 0 else     dist := dist-(Bextra) ; ;  
    ret := ret+(dist + 1) ; 
    Oextra := Oextra+(dist + 1) ; 
    Bextra := 0 ; 
    Bpos := button ; 
 ) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     I := I + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 )   catch (ie : IOException) do (     ie.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class bottrust {
  public static void main(String[] args){
    Scanner ins=new Scanner(System.in);
    int cc ;
    int ntc=ins.nextInt();
    for(cc=1 ; cc<=ntc ; cc++){
      int pos[]={
        1,1 },time[]={
          0,0 };
          int cnt=ins.nextInt();
          for(int i=0 ; i<cnt ; i++){
            String s=ins.next();
            int r=0 ;
            if(s.equals("B"))r=1 ;
            int p=ins.nextInt();
            int mtime=p-pos[r];
            if(mtime<0)mtime=-mtime ;
            mtime+=time[r]+1 ;
            if(mtime<=time[1-r])mtime=time[1-r]+1 ;
            time[r]=mtime ;
            pos[r]=p ;
          }
          int maxtime=time[0];
          if(time[1]>maxtime)maxtime=time[1];
          System.out.printf("Case #%d: %d\n",cc,maxtime);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class bottrust {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ins : OclFile ; ins := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cc : int ;
     var ntc : int ; ntc := ins.getCurrent()->toInteger() ;
         cc := 1 ; while cc <= ntc do ( (     var pos : Sequence(int) ; pos := Sequence{1,1} ;
    var time : Sequence(void) ; time := Sequence{0,0} ;
     var cnt : int ; cnt := ins.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < cnt do ( (     var s : String ; s := ins.getCurrent() ;
     var r : int ; r := 0 ;
    if (s = "B") then     r := 1 ; else skip ; 
    var p : int ; p := ins.getCurrent()->toInteger() ;
    var mtime : int ; mtime := p - pos[r+1] ;
    if (mtime < 0) then     mtime := -mtime ; else skip ; 
    mtime := mtime+(time[r+1] + 1) ; 
    if (mtime <= time[1 - (r)->char2byte()+1]) then     mtime := time[1 - (r)->char2byte()+1] + 1 ; else skip ; 
    time[r+1] := mtime ; 
    pos[r+1] := p ; 
 )  ;     i := i + 1 ) ; 
    var maxtime : int ; maxtime := time[0+1] ;
    if (time[1+1] > maxtime) then     maxtime := time[1+1] ; else skip ; 
    OclFile["System.out"].printf("Case #%d: %d\n", cc, maxtime) ; 
 )  ;     cc := cc + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.util.Iterator ;
public class InputFileParser implements Iterable<String[]>{
  private final int linesPerCase ;
  private final int totalCases ;
  private BufferedReader reader ;
  private int casesExtracted=0 ;
  public InputFileParser(int linesPerCase,String fileName){
    this.linesPerCase=linesPerCase ;
    try {
      FileReader fileReader=new FileReader(fileName);
      this.reader=new BufferedReader(fileReader);
      String line=this.reader.readLine();
      this.totalCases=Integer.parseInt(line);
    }
    catch(IOException e){
      throw new IllegalStateException(e);
    }
  }
  private String readLine(){
    try {
      return this.reader.readLine();
    }
    catch(IOException e){
      throw new IllegalStateException(e);
    }
  }
  @ Override public Iterator<String[]>iterator(){
    return new Iterator<String[]>(){
      @ Override public boolean hasNext(){
        return casesExtracted<totalCases ;
      }
      @ Override public String[] next(){
        String[] caseLines=new String[linesPerCase];
        for(int i=0 ; i<linesPerCase ; i++){
          caseLines[i]=readLine();
        }
        casesExtracted++;
        return caseLines ;
      }
      @ Override public void remove(){
      }
    };
  }
}
------------------------------------------------------------
OCL File:
---------
 class InputFileParser implements Sequence(Sequence(String)) {
   attribute linesPerCase : int;
   attribute totalCases : int;
   attribute reader : OclFile;
   attribute casesExtracted : int := 0;
   static operation newInputFileParser( linesPerCase : int, fileName : String) : InputFileParser
  pre: true
  post: true
  activity:
  ( var self : InputFileParser ;
    self := createInputFileParser();
    self.initialise(linesPerCase, fileName);
    return self );
  operation initialise( linesPerCase : int, fileName : String) : void
  pre: true  post: true
  activity: (     self.linesPerCase := linesPerCase ; 
     try (     var fileReader : OclFile ; fileReader := OclFile.newOclFile_Read(fileName) ;
     self.reader := OclFile.newOclFile_Read(fileReader) ; 
     var line : String ; line := self.reader.readLine() ;
     self.totalCases := (line)->toInteger() )   catch (e : IOException) do (     error IncorrectElementException(e) )
 );
   operation readLine() : String
  pre: true
  post: true
  activity: (     try (     return self.reader.readLine() )   catch (e : IOException) do (     error IncorrectElementException(e) )
 );
      operation iterator() : OclIterator
  pre: true
  post: true
  activity: (     return Iterator<Sequence(String)>.newIterator() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  int min(int a,int b){
    if(a<b)return a ;
    else return b ;
  }
  int max(int a,int b){
    if(a>b)return a ;
    else return b ;
  }
  Main(){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int[] N=new int[a];
    boolean[] flg=new boolean[a];
    for(int i=0 ; i<b ; i++){
      N[i]=sc.nextInt();
      N[i]-=c ;
      if(N[i]<0)N[i]+=a ;
      flg[N[i] ]=true ;
    }
    flg[0]=true ;
    int[] n=new int[a];
    int x=0 ;
    for(int i=0 ; i<a ; i++){
      if(flg[i]){
        n[x]=i ;
        x++;
      }
    }
    int ans=a ;
    for(int i=0 ; i<x ; i++){
      int L=n[i],R=n[(i+1)% x];
      int distL=L ;
      int distR=a-R ;
      if(distR==a)distR=0 ;
      ans=min(ans,min(distL,distR)*2+max(distL,distR));
    }
    System.out.println(ans*100);
  }
  public static void main(String[] arg){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation min( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a < b) then     return a else     return b );
   operation max( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a > b) then     return a else     return b );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var N : Sequence(int) ; N := Integer.subrange(1,a)->collect(0) ;
    var flg : Sequence(boolean) ; flg := Integer.subrange(1,a)->collect(false) ;
        var i : int ; i := 0 ; while i < b do ( (     N[i+1] := sc.getCurrent()->toInteger() ; 
     N[i+1] := N[i+1]-(c) ; 
     if (N[i+1] < 0) then     N[i+1] := N[i+1]+(a) ; else skip ; 
     flg[N[i+1]+1] := true )  ;     i := i + 1 ) ; 
    flg[0+1] := true ; 
    var n : Sequence(int) ; n := Integer.subrange(1,a)->collect(0) ;
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < a do ( (     if (flg[i+1]) then (     n[x+1] := i ; 
     x := x + 1 ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := a ;
        var i : int ; i := 0 ; while i < x do ( (     var L : int ; L := n[i+1] ;
    var R : int ; R := n[(i + 1) mod x+1] ;
     var distL : int ; distL := L ;
    var distR : int ; distR := a - R ;
    if (distR = a) then     distR := 0 ; else skip ; 
    ans := Set{ans, Set{distL, distR}->min() * 2 + Set{distL, distR}->max()}->min() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans * 100) ; 
 );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.regex.Pattern ;
public class GCJ2011QualA {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    for(int testCase=1 ; testCase<=T ; testCase++){
      int N=sc.nextInt();
      int oT=0,bT=0 ;
      int oP=1,bP=1 ;
      for(int i=0 ; i<N ; i++){
        char[] c=sc.next().toCharArray();
        int pos=sc.nextInt();
        if(c[0]=='O'){
          oT=Math.max(oT+Math.abs(pos-oP),bT)+1 ;
          oP=pos ;
        }
        else {
          bT=Math.max(bT+Math.abs(pos-bP),oT)+1 ;
          bP=pos ;
        }
      }
      System.out.println("Case #"+testCase+": "+Math.max(bT,oT));
    }
  }
  public static void main(String args[]){
    new GCJ2011QualA().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class GCJ2011QualA {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var testCase : int ; testCase := 1 ; while testCase <= T do ( (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var oT : int ; oT := 0 ;
    var bT : int ; bT := 0 ;
    var oP : int ; oP := 1 ;
    var bP : int ; bP := 1 ;
        var i : int ; i := 0 ; while i < N do ( (     var c : Sequence(String) ; c := sc.getCurrent()->characters() ;
     var pos : int ; pos := sc.getCurrent()->toInteger() ;
     if (c[0+1] = 'O') then (     oT := Set{oT + if pos - oP < 0 then -(pos - oP) else pos - oP endif, bT}->max() + 1 ; 
     oP := pos ) else (     bT := Set{bT + if pos - bP < 0 then -(pos - bP) else pos - bP endif, oT}->max() + 1 ; 
     bP := pos ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Case #" + testCase + ": " + Set{bT, oT}->max()) ; 
 )  ;     testCase := testCase + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     GCJ2011QualA.newGCJ2011QualA().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public void doMain()throws Exception {
    Scanner sc=new Scanner(new FileReader("input.txt"));
    PrintWriter pw=new PrintWriter(new FileWriter("output.txt"));
    int caseCnt=sc.nextInt();
    for(int caseNum=0 ; caseNum<caseCnt ; caseNum++){
      pw.print("Case #"+(caseNum+1)+": ");
      int curO=1,spareStepsO=0,curB=1,spareStepsB=0 ;
      int N=sc.nextInt();
      int res=0 ;
      for(int i=0 ; i<N ; i++){
        String who=sc.next();
        if(who.equals("O")){
          int pos=sc.nextInt();
          int dist=Math.abs(curO-pos)+1 ;
          dist-=Math.min(spareStepsO,dist-1);
          res+=dist ;
          spareStepsB+=dist ;
          spareStepsO=0 ;
          curO=pos ;
        }
        else {
          int pos=sc.nextInt();
          int dist=Math.abs(curB-pos)+1 ;
          dist-=Math.min(spareStepsB,dist-1);
          res+=dist ;
          spareStepsO+=dist ;
          spareStepsB=0 ;
          curB=pos ;
        }
      }
      pw.println(res);
    }
    pw.flush();
    pw.close();
    sc.close();
  }
  public static void main(String[] args)throws Exception {
    new Solution().doMain();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
   operation doMain() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt"))) ;
    var caseCnt : int ; caseCnt := sc.getCurrent()->toInteger() ;
        var caseNum : int ; caseNum := 0 ; while caseNum < caseCnt do ( (     skip ; 
     var curO : int ; curO := 1 ;
    var spareStepsO : int ; spareStepsO := 0 ;
    var curB : int ; curB := 1 ;
    var spareStepsB : int ; spareStepsB := 0 ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var who : String ; who := sc.getCurrent() ;
     if (who = "O") then (     var pos : int ; pos := sc.getCurrent()->toInteger() ;
     var dist : int ; dist := if curO - (pos)->char2byte() < 0 then -(curO - (pos)->char2byte()) else curO - (pos)->char2byte() endif + 1 ;
    dist := dist-(Set{spareStepsO, dist - 1}->min()) ; 
    res := res+(dist) ; 
    spareStepsB := spareStepsB+(dist) ; 
    spareStepsO := 0 ; 
    curO := pos ; 
 ) else (     var pos : int ; pos := sc.getCurrent()->toInteger() ;
     var dist : int ; dist := if curB - (pos)->char2byte() < 0 then -(curB - (pos)->char2byte()) else curB - (pos)->char2byte() endif + 1 ;
    dist := dist-(Set{spareStepsB, dist - 1}->min()) ; 
    res := res+(dist) ; 
    spareStepsO := spareStepsO+(dist) ; 
    spareStepsB := 0 ; 
    curB := pos ; 
 ) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     caseNum := caseNum + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Solution.newSolution().doMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static long sum(long n){
    long root=(long)Math.sqrt(n);
    long ans=0 ;
    for(int i=1 ; i<=root ; i++)ans+=n/i ;
    ans=2*ans-(root*root);
    return ans ;
  }
  public static void main(String[] args){
    long n=35 ;
    System.out.println(sum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sum( n : long) : long
  pre: true
  post: true
  activity: (     var root : long ; root := (n)->sqrt()->oclAsType(long) ;
     var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= root do (     ans := ans+(n / i) ;  ;     i := i + 1 ) ; 
    ans := 2 * ans - (root * root) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 35 ;
     OclFile["System.out"].println(sum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    String s ;
    char[] c ;
    int i,joi,ioi ;
    for(; sc.hasNextLine(); ){
      s=sc.nextLine();
      c=new char[s.length()];
      for(i=0 ; i<s.length(); i++)c[i]=s.charAt(i);
      joi=0 ;
      ioi=0 ;
      for(i=0 ; i<s.length()-2 ; i++){
        if(c[i]=='J' && c[i+1]=='O' && c[i+2]=='I'){
          joi++;
          i++;
        }
        else if(c[i]=='I' && c[i+1]=='O' && c[i+2]=='I'){
          ioi++;
          i++;
        }
      }
      out.println(joi);
      out.println(ioi);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var s : String ;
    var c : Sequence(String) ;
    var i : int ;
    var joi : int ;
    var ioi : int ;
      while sc.hasNextLine() do ( (     s := sc.nextLine() ; 
     c := Integer.subrange(1,s->size())->collect(0) ; 
        i := 0 ; while i < s->size() do (     c[i+1] := s->at(i+1) ;  ;     i := i + 1 ) ; 
    joi := 0 ; 
    ioi := 0 ; 
        i := 0 ; while i < s->size() - 2 do ( (     if (c[i+1] = 'J' & c[i + 1+1] = 'O' & c[i + 2+1] = 'I') then (     joi := joi + 1 ; 
     i := i + 1 ) else     if (c[i+1] = 'I' & c[i + 1+1] = 'O' & c[i + 2+1] = 'I') then (     ioi := ioi + 1 ; 
     i := i + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    out.println(joi) ; 
    out.println(ioi) ; 
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.lang.reflect.Array ;
import java.util.*;
public class B891 {
  public static void main(String[] args)throws IOException {
    StringBuffer ans=new StringBuffer();
    StringTokenizer st ;
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    st=new StringTokenizer(f.readLine());
    int n=Integer.parseInt(st.nextToken());
    int[] arr=new int[n];
    HashMap<Integer,Integer>hash=new HashMap<>();
    st=new StringTokenizer(f.readLine());
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(st.nextToken());
      hash.put(arr[i],i);
    }
    f.close();
    int[] arr1=arr.clone();
    Arrays.sort(arr1);
    for(int i=0 ; i<n ; i++){
      int r=hash.get(arr1[(i+1)% n]);
      arr[r]=arr1[i];
    }
    for(int i : arr)ans.append(i).append(" ");
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B891 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ans : String ; ans := StringLib.newString() ;
     var st : OclIterator ;
    var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    st := OclIterator.newOclIterator_String(f.readLine()) ; 
    var n : int ; n := (st.next())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var hash : Map(int,int) ; hash := Map{} ;
    st := OclIterator.newOclIterator_String(f.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (st.next())->toInteger() ; 
     hash := hash->union(Map{arr[i+1] |-> i}) )  ;     i := i + 1 ) ; 
    skip ; 
    var arr1 : Sequence(int) ; arr1 := arr->copy() ;
    arr1 := arr1->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     var r : int ; r := hash->at(arr1[(i + 1) mod n+1]) ;
     arr[r+1] := arr1[i+1] )  ;     i := i + 1 ) ; 
    for (i : arr) do (     ans := ans + StringLib.newString(i) + StringLib.newString(" ") ;  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long sumXOR(int arr[],int n){
    long sum=0 ;
    for(int i=0 ; i<32 ; i++){
      int zc=0,oc=0 ;
      long idsum=0 ;
      for(int j=0 ; j<n ; j++){
        if(arr[j] % 2==0)zc++;
        else oc++;
        arr[j]/=2 ;
      }
      idsum=oc*zc*(1<<i);
      sum+=idsum ;
    }
    return sum ;
  }
  public static void main(String args[]){
    long sum=0 ;
    int arr[]={
      5,9,7,6 };
      int n=arr.length ;
      sum=sumXOR(arr,n);
      System.out.println(sum);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumXOR( arr : Sequence(int), n : int) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var i : int ; i := 0 ; while i < 32 do ( (     var zc : int ; zc := 0 ;
    var oc : int ; oc := 0 ;
     var idsum : long ; idsum := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     if (arr[j+1] mod 2 = 0) then     zc := zc + 1 else     oc := oc + 1 ; ;  
     arr[j+1] := arr[j+1]/(2) )  ;     j := j + 1 ) ; 
    idsum := oc * zc * ((1*(2->pow(i)))->oclAsType(long)) ; 
    sum := sum+(idsum) ; 
 )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     var arr : Sequence(int) ; arr := Sequence{5,9,7,6} ;
    var n : int ; n := arr->size() ;
    sum := sumXOR(arr, n) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.HashSet ;
import java.util.Set ;
import java.util.StringTokenizer ;
public class Main {
  private void solve(InputReader in,PrintWriter out){
    int n=in.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
    }
    if(arr[0]!=0){
      out.println(1);
      return ;
    }
    int max=0 ;
    Set<Integer>set=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      if((! set.isEmpty()&& ! set.contains(arr[i]))&& arr[i]>max+1){
        out.println(i+1);
        return ;
      }
      max=Math.max(max,arr[i]);
      set.add(arr[i]);
    }
    out.println(-1);
  }
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    try(InputReader in=new InputReader(System.in);
    PrintWriter out=new PrintWriter(System.out)){
      solve(in,out);
    }
  }
  static class InputReader implements AutoCloseable {
    private BufferedReader reader ;
    private StringTokenizer tokenizer ;
    InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    @ Override public void close(){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    if (arr[0+1] /= 0) then (     out.println(1) ; 
     return ) else skip ; 
    var max : int ; max := 0 ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     if ((not(set->isEmpty()) & not(set->includes(arr[i+1]))) & arr[i+1] > max + 1) then (     out.println(i + 1) ; 
     return ) else skip ; 
     max := Set{max, arr[i+1]}->max() ; 
     set := set->including(arr[i+1]) )  ;     i := i + 1 ) ; 
    out.println(-1) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var in : InputReader := InputReader.newInputReader(OclFile["System.in"]) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]) ;
 (     execute solve(in, out) ))  );
  static class InputReader implements AutoCloseable {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
      operation close() : void
  pre: true
  post: true
  activity: skip;
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.TreeSet ;
public class JavaApplication4 {
  public static void main(String[] args)throws IOException {
    BufferedReader gi=new BufferedReader(new InputStreamReader(System.in));
    String[] s=gi.readLine().split(" ");
    int n=Integer.parseInt(s[0]);
    TreeSet<Integer>tree=new TreeSet<Integer>();
    s=gi.readLine().split(" ");
    int x ;
    boolean k=false ;
    for(int i=0 ; i<n ; i++){
      x=Integer.parseInt(s[i]);
      tree.add(x);
      if(tree.size()==1 && x!=0){
        System.out.println(1);
        k=true ;
        break ;
      }
      if(tree.first()!=x)if(tree.lower(x)!=x-1){
        System.out.println(i+1);
        k=true ;
        break ;
      }
    }
    if(! k){
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication4 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var gi : OclFile ; gi := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : Sequence(String) ; s := gi.readLine()->split(" ") ;
    var n : int ; n := (s[0+1])->toInteger() ;
    var tree : Set(int) ; tree := Set{} ;
    s := gi.readLine()->split(" ") ; 
    var x : int ;
    var k : boolean ; k := false ;
        var i : int ; i := 0 ; while i < n do ( (     x := (s[i+1])->toInteger() ; 
     tree := tree->including(x) ; 
     if (tree->size() = 1 & x /= 0) then (     OclFile["System.out"].println(1) ; 
     k := true ; 
     break ) else skip ; 
     if (tree->first() /= x) then     if (tree.lower(x) /= x - 1) then (     OclFile["System.out"].println(i + 1) ; 
     k := true ; 
     break ) else skip ; else skip )  ;     i := i + 1 ) ; 
    if (not(k)) then (     OclFile["System.out"].println(-1) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class AppendingMex {
  private static final Scanner scanner=new Scanner(System.in);
  public static void main(String[] args)throws IOException {
    long currMin=-1 ;
    int steps=scanner.nextInt();
    for(int i=0 ; i<steps ; i++){
      long currStep=scanner.nextLong();
      if(currStep==currMin+1){
        currMin++;
      }
      else if(currStep>currMin){
        System.out.println(i+1);
        return ;
      }
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class AppendingMex {
  static    attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var currMin : long ; currMin := -1 ;
     var steps : int ; steps := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < steps do ( (     var currStep : long ; currStep := scanner.getCurrent()->toLong() ;
     if (currStep = currMin + 1) then (     currMin := currMin + 1 ) else     if (currStep > currMin) then (     OclFile["System.out"].println(i + 1) ; 
     return ) else skip ; )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(-1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Mex {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=Integer.parseInt(scanner.nextLine());
    String[] inputArray=scanner.nextLine().split(" ");
    int mistake=-1 ;
    if(Integer.parseInt(inputArray[0])>0)System.out.println("1");
    else {
      int maxVal=0 ;
      for(int x=1 ; x<n ; x++){
        int currNum=Integer.parseInt(inputArray[x]);
        if(currNum>maxVal+1){
          mistake=x ;
          break ;
        }
        else {
          if(currNum==maxVal+1){
            maxVal++;
          }
        }
      }
      if(mistake<0)System.out.println(mistake);
      else System.out.println(mistake+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mex {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (scanner.nextLine())->toInteger() ;
    var inputArray : Sequence(String) ; inputArray := scanner.nextLine()->split(" ") ;
    var mistake : int ; mistake := -1 ;
    if ((inputArray[0+1])->toInteger() > 0) then     OclFile["System.out"].println("1") else (     var maxVal : int ; maxVal := 0 ;
         var x : int ; x := 1 ; while x < n do ( (     var currNum : int ; currNum := (inputArray[x+1])->toInteger() ;
     if (currNum > maxVal + 1) then (     mistake := x ; 
     break ) else (     if (currNum = maxVal + 1) then (     maxVal := maxVal + 1 ) else skip ) )  ;     x := x + 1 ) ; 
     if (mistake < 0) then     OclFile["System.out"].println(mistake) ; else     OclFile["System.out"].println(mistake + 1) ; ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  static int max_element(int A[]){
    int max=Integer.MIN_VALUE ;
    for(int i=0 ; i<A.length ; i++)if(max<A[i])max=A[i];
    return max ;
  }
  static void SumDivPrime(int A[],int n){
    int max_val=(max_element(A))+1 ;
    boolean prime[]=new boolean[max_val+1];
    for(int i=0 ; i<=max_val ; i++)prime[i]=true ;
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=max_val ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=max_val ; i+=p)prime[i]=false ;
      }
    }
    int sum=0 ;
    for(int i=0 ; i<n ; ++i){
      if(prime[A[i] ])sum+=A[i];
    }
    for(int i=0 ; i<n ; ++i){
      if(prime[A[i] ] && sum % A[i]==0){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
  public static void main(String args[]){
    int A[]={
      1,2,3,4,5 };
      int n=A.length ;
      SumDivPrime(A,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class Solution {
  static   operation max_element( A : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var max : int ; max := -2147483648 ;
         var i : int ; i := 0 ; while i < A->size() do (     if (max < A[i+1]) then     max := A[i+1] ; else skip ;  ;     i := i + 1 ) ; 
     return max );
  static   operation SumDivPrime( A : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var max_val : int ; max_val := (max_element(A)) + 1 ;
     var prime : Sequence(boolean) ; prime := Integer.subrange(1,max_val + 1)->collect(false) ;
        var i : int ; i := 0 ; while i <= max_val do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
    prime[0+1] := false ; 
    prime[1+1] := false ; 
        var p : int ; p := 2 ; while p * p <= max_val do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= max_val do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (prime[A[i+1]+1]) then     sum := sum+(A[i+1]) ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (prime[A[i+1]+1] & sum mod A[i+1] = 0) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{1,2,3,4,5} ;
     var n : int ; n := A->size() ;
     execute SumDivPrime(A, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static int minCost(int A[],int n){
    int cost=0 ;
    Arrays.sort(A);
    int K=A[n/2];
    for(int i=0 ; i<n ; ++i)cost+=Math.abs(A[i]-K);
    if(n % 2==0){
      int tempCost=0 ;
      K=A[(n/2)-1];
      for(int i=0 ; i<n ; ++i)tempCost+=Math.abs(A[i]-K);
      cost=Math.min(cost,tempCost);
    }
    return cost ;
  }
  public static void main(String[] args){
    int A[]={
      1,6,7,10 };
      int n=A.length ;
      System.out.println(minCost(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation minCost( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var cost : int ; cost := 0 ;
     A := A->sort() ; 
    var K : int ; K := A[n / 2+1] ;
        var i : int ; i := 0 ; while i < n do (     cost := cost+(if A[i+1] - K < 0 then -(A[i+1] - K) else A[i+1] - K endif) ;  ;     i := i + 1 ) ; 
    if (n mod 2 = 0) then (     var tempCost : int ; tempCost := 0 ;
     K := A[(n / 2) - 1+1] ; 
         var i : int ; i := 0 ; while i < n do (     tempCost := tempCost+(if A[i+1] - K < 0 then -(A[i+1] - K) else A[i+1] - K endif) ;  ;     i := i + 1 ) ; 
     cost := Set{cost, tempCost}->min() ) else skip ; 
    return cost 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{1,6,7,10} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].println(minCost(A, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  static long getSum(int n,int d){
    long sum=0 ;
    while(d<=n){
      sum+=d ;
      d+=10 ;
    }
    return sum ;
  }
  public static void main(String args[]){
    int n=30,d=3 ;
    System.out.print(getSum(n,d));
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
  static   operation getSum( n : int, d : int) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     while (d <= n) do (     sum := sum+(d) ; 
     d := d+(10) ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 30 ;
    var d : int ; d := 3 ;
     OclFile["System.out"].print(getSum(n, d)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void arrayConstruct(int N){
    for(int i=2 ; i<=N ; i=i+2)System.out.print(i+" ");
    for(int i=1 ; i<N-1 ; i=i+2)System.out.print(i+" ");
    System.out.print(N-1+(N/2)+"\n");
  }
  static void createArray(int N){
    if(N % 4==0)arrayConstruct(N);
    else System.out.print(-1+"\n");
  }
  public static void main(String[] args){
    int N=8 ;
    createArray(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation arrayConstruct( N : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i <= N do (     OclFile["System.out"].print(i + " ") ;  ;     i := i + 2 ) ; 
         var i : int ; i := 1 ; while i < N - 1 do (     OclFile["System.out"].print(i + " ") ;  ;     i := i + 2 ) ; 
     OclFile["System.out"].print(N - 1 + (N / 2) + "\n") );
  static   operation createArray( N : int) : void
  pre: true
  post: true
  activity: (     if (N mod 4 = 0) then     execute arrayConstruct(N) ; else     OclFile["System.out"].print(-1 + "\n") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 8 ;
     execute createArray(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class MatrixChainMultiplication {
  static int MatrixChainOrder(int p[],int n){
    int m[][]=new int[n][n];
    int i,j,k,L,q ;
    for(i=1 ; i<n ; i++)m[i][i]=0 ;
    for(L=2 ; L<n ; L++){
      for(i=1 ; i<n-L+1 ; i++){
        j=i+L-1 ;
        if(j==n)continue ;
        m[i][j]=Integer.MAX_VALUE ;
        for(k=i ; k<=j-1 ; k++){
          q=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
          if(q<m[i][j])m[i][j]=q ;
        }
      }
    }
    return m[1][n-1];
  }
  public static void main(String args[]){
    int arr[]=new int[] {
      1,2,3,4 };
      int size=arr.length ;
      System.out.println("Minimum number of multiplications is "+MatrixChainOrder(arr,size));
    }
  }

------------------------------------------------------------
OCL File:
---------
class MatrixChainMultiplication {
  static   operation MatrixChainOrder( p : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var m : Sequence(Sequence(int)) ; m := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
     var i : int ;
    var j : int ;
    var k : int ;
    var L : int ;
    var q : int ;
        i := 1 ; while i < n do (     m[i+1][i+1] := 0 ;  ;     i := i + 1 ) ; 
        L := 2 ; while L < n do ( (         i := 1 ; while i < n - L + 1 do ( (     j := i + L - 1 ; 
     if (j = n) then     continue else skip ; 
     m[i+1][j+1] := 2147483647 ; 
         k := i ; while k <= j - 1 do ( (     q := m[i+1][k+1] + m[k + 1+1][j+1] + p[i - 1+1] * p[k+1] * p[j+1] ; 
     if (q < m[i+1][j+1]) then     m[i+1][j+1] := q ; else skip )  ;     k := k + 1 ) )  ;     i := i + 1 ) )  ;     L := L + 1 ) ; 
    return m[1+1][n - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4} ;
     var size : int ; size := arr->size() ;
     OclFile["System.out"].println("Minimum number of multiplications is " + MatrixChainOrder(arr, size)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner stdIn=null ;
    String[] str=new String[100];
    int[][] result=new int[100][2];
    int index=0 ;
    try {
      stdIn=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
      while(stdIn.hasNext()){
        str[index]=stdIn.next();
        index++;
      }
      int count=0 ;
      for(int i=0 ; i<index ; i++){
        for(int j=0 ; j<str[i] .length()-2 ; j++){
          if(str[i] .charAt(j)=='J'){
            if(str[i] .charAt(j+1)=='O' && str[i] .charAt(j+2)=='I'){
              result[i][0]++;
            }
          }
          else if(str[i] .charAt(j)=='I'){
            if(str[i] .charAt(j+1)=='O' && str[i] .charAt(j+2)=='I'){
              result[i][1]++;
            }
          }
        }
      }
      for(int i=0 ; i<index ; i++){
        System.out.println(result[i][0]);
        System.out.println(result[i][1]);
      }
    }
    finally {
      if(stdIn!=null){
        stdIn.close();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := null ;
     var str : Sequence(String) ; str := Integer.subrange(1,100)->collect(null) ;
    var result : Sequence(Sequence(int)) ; result := Integer.subrange(1,100)->collect(Integer.subrange(1,2)->collect(0)) ;
    var index : int ; index := 0 ;
    try (     stdIn := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
     while (stdIn.hasNext()) do (     str[index+1] := stdIn.getCurrent() ; 
     index := index + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < index do ( (         var j : int ; j := 0 ; while j < str[i+1]->size() - 2 do ( (     if (str[i+1]->at(j+1) = 'J') then (     if (str[i+1]->at(j + 1+1) = 'O' & str[i+1]->at(j + 2+1) = 'I') then (     result[i+1][0+1] := result[i+1][0+1] + 1 ) else skip ) else     if (str[i+1]->at(j+1) = 'I') then (     if (str[i+1]->at(j + 1+1) = 'O' & str[i+1]->at(j + 2+1) = 'I') then (     result[i+1][1+1] := result[i+1][1+1] + 1 ) else skip ) else skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < index do ( (     OclFile["System.out"].println(result[i+1][0+1]) ; 
     OclFile["System.out"].println(result[i+1][1+1]) )  ;     i := i + 1 ) ; 
 )   finally (     if (stdIn /= null) then (     skip ) else skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  boolean debug=false ;
  int INF=1<<28 ;
  int N ;
  int[][] t ;
  int[] dp ;
  void solve(){
    Scanner sc=new Scanner(System.in);
    while(true){
      N=sc.nextInt();
      if(N==0)break ;
      t=new int[N][N+1];
      for(int i=0 ; i<N ; i++){
        for(int j=0 ; j<N+1 ; j++){
          t[i][j]=sc.nextInt();
        }
      }
      dp=new int[(1<<N)];
      Arrays.fill(dp,INF);
      dp[0]=0 ;
      for(int S=0 ; S<(1<<N); S++){
        for(int i=0 ; i<N ; i++){
          if(((S>>i)& 1)==0){
            int mintime=t[i][0];
            for(int j=0 ; j<N ; j++){
              if(((S>>j)& 1)==1){
                mintime=Math.min(mintime,t[i][j+1]);
              }
            }
            dp[S+(1<<i)]=Math.min(dp[S+(1<<i)],dp[S]+mintime);
          }
        }
      }
      System.out.println(dp[(1<<N)-1]);
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute debug : boolean := false;
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute N : int;
   attribute t : Sequence(Sequence(int));
   attribute dp : Sequence(int);
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     N := sc.getCurrent()->toInteger() ; 
     if (N = 0) then     break else skip ; 
    t := Integer.subrange(1,N)->collect(Integer.subrange(1,N + 1)->collect(0)) ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N + 1 do ( (     t[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    dp := Integer.subrange(1,((1*(2->pow(N)))->oclAsType(long)))->collect(0) ; 
    dp := dp->collect(INF) ; 
    dp[0+1] := 0 ; 
        var S : int ; S := 0 ; while S < ((1*(2->pow(N)))->oclAsType(long)) do ( (         var i : int ; i := 0 ; while i < N do ( (     if ((((S/(2->pow(i)))->oclAsType(long)) & 1) = 0) then (     var mintime : int ; mintime := t[i+1][0+1] ;
         var j : int ; j := 0 ; while j < N do ( (     if ((((S/(2->pow(j)))->oclAsType(long)) & 1) = 1) then (     mintime := Set{mintime, t[i+1][j + 1+1]}->min() ) else skip )  ;     j := j + 1 ) ; 
     dp[S + ((1*(2->pow(i)))->oclAsType(long))+1] := Set{dp[S + ((1*(2->pow(i)))->oclAsType(long))+1], dp[S+1] + mintime}->min() ) else skip )  ;     i := i + 1 ) )  ;     S := S + 1 ) ; 
    OclFile["System.out"].println(dp[((1*(2->pow(N)))->oclAsType(long)) - 1+1]) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int N ;
  static int[][] info ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(true){
      N=in.nextInt();
      if(N==0)break ;
      info=new int[N][N+1];
      for(int i=0 ; i<N ; i++){
        for(int j=0 ; j<N+1 ; j++){
          info[i][j]=in.nextInt();
        }
      }
      int size=1<<(N);
      int[] dp=new int[size];
      for(int i=0 ; i<size ; i++){
        dp[i]=Integer.MAX_VALUE ;
      }
      dp[0]=0 ;
      for(int k=0 ; k<N ; k++){
        int com=(1<<k)-1 ;
        while(com<1<<N){
          for(int l=0 ; l<N ; l++){
            if((com>>l & 1)==0){
              int cand=dp[com]+time(l,com);
              dp[com | 1<<l]=Math.min(dp[com | 1<<l],cand);
            }
          }
          int x=com &-com ;
          int y=com+x ;
          if(x==0)com=1 ;
          else com=((com & ~ y)/x>>1)| y ;
        }
      }
      System.out.println(dp[size-1]);
      System.gc();
    }
  }
  public static int time(int trg,int wepon){
    int time=info[trg][0];
    for(int i=0 ; i<N ; i++){
      if((wepon>>i & 1)==1){
        time=Math.min(time,info[trg][i+1]);
      }
    }
    return time ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute info : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     N := in.getCurrent()->toInteger() ; 
     if (N = 0) then     break else skip ; 
    info := Integer.subrange(1,N)->collect(Integer.subrange(1,N + 1)->collect(0)) ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N + 1 do ( (     info[i+1][j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var size : int ; size := (1*(2->pow((N))))->oclAsType(long) ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < size do ( (     dp[i+1] := 2147483647 )  ;     i := i + 1 ) ; 
    dp[0+1] := 0 ; 
        var k : int ; k := 0 ; while k < N do ( (     var com : int ; com := ((1*(2->pow(k)))->oclAsType(long)) - 1 ;
     while (com < (1*(2->pow(N)))->oclAsType(long)) do (         var l : int ; l := 0 ; while l < N do ( (     if ((MathLib.bitwiseAnd((com/(2->pow(l)))->oclAsType(long),1)) = 0) then (     var cand : int ; cand := dp[com+1] + time(l, com) ;
     dp[MathLib.bitwiseOr(com,(1*(2->pow(l)))->oclAsType(long))+1] := Set{dp[MathLib.bitwiseOr(com,(1*(2->pow(l)))->oclAsType(long))+1], cand}->min() ) else skip )  ;     l := l + 1 ) ; 
     var x : int ; x := MathLib.bitwiseAnd(com,-com) ;
     var y : int ; y := com + x ;
     if (x = 0) then     com := 1 ; else     com := (((MathLib.bitwiseAnd(com,-(y + 1))) / x/(2->pow(1)))->oclAsType(long)) or y ; ) )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(dp[size - 1+1]) ; 
gc() ; 
 ) );
  static   operation time( trg : int, wepon : int) : int
  pre: true
  post: true
  activity: (     var time : int ; time := info[trg+1][0+1] ;
         var i : int ; i := 0 ; while i < N do ( (     if ((MathLib.bitwiseAnd((wepon/(2->pow(i)))->oclAsType(long),1)) = 1) then (     time := Set{time, info[trg+1][i + 1+1]}->min() ) else skip )  ;     i := i + 1 ) ; 
     return time );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  public static int[] dist ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int[][] cost=new int[n][n+1];
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<=n ; j++)cost[i][j]=sc.nextInt();
      dist=new int[1<<n];
      Arrays.fill(dist,1<<30);
      dist[0]=0 ;
      Queue<Integer>q=new PriorityQueue<Integer>(n,new Comparator<Integer>(){
        public int compare(Integer o1,Integer o2){
          return dist[o1]-dist[o2];
        }
      }
);
      q.add(0);
      while(true){
        int u=q.poll();
        if(u==(1<<n)-1)break ;
        for(int i=0 ; i<n ; i++){
          if((u &(1<<i))>0)continue ;
          int nu=u |(1<<i);
          int min=dist[u]+cost[i][0];
          for(int j=0 ; j<n ; j++){
            if((u &(1<<j))>0)min=Math.min(min,dist[u]+cost[i][j+1]);
          }
          if(min<dist[nu]){
            dist[nu]=min ;
            q.add(nu);
          }
        }
      }
      System.out.println(dist[dist.length-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dist : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var cost : Sequence(Sequence(int)) ; cost := Integer.subrange(1,n)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j <= n do (     cost[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    dist := Integer.subrange(1,(1*(2->pow(n)))->oclAsType(long))->collect(0) ; 
    dist := dist->collect((1*(2->pow(30)))->oclAsType(long)) ; 
    dist[0+1] := 0 ; 
    var q : Sequence(int) ; q := Sequence{} ;
    q := q->including(0) ; 
    while (true) do (     var u : int ; u := q->min() ;
     if (u = ((1*(2->pow(n)))->oclAsType(long)) - 1) then     break else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     if ((MathLib.bitwiseAnd(u,((1*(2->pow(i)))->oclAsType(long)))) > 0) then     continue else skip ; 
     var nu : int ; nu := MathLib.bitwiseOr(u,((1*(2->pow(i)))->oclAsType(long))) ;
    var min : int ; min := dist[u+1] + cost[i+1][0+1] ;
        var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd(u,((1*(2->pow(j)))->oclAsType(long)))) > 0) then     min := Set{min, dist[u+1] + cost[i+1][j + 1+1]}->min() ; else skip )  ;     j := j + 1 ) ; 
    if (min < dist[nu+1]) then (     dist[nu+1] := min ; 
     q := q->including(nu) ) else skip ; 
 )  ;     i := i + 1 ) ) ; 
    OclFile["System.out"].println(dist[dist->size() - 1+1]) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void pr(Object o){
    System.out.println(o);
  }
  int[][] t ;
  int n ;
  int[] hash ;
  int min ;
  public void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      n=sc.nextInt();
      min=Integer.MAX_VALUE ;
      if(n==0){
        break ;
      }
      hash=new int[1<<n];
      for(int i=0 ; i<(1<<n); i++){
        hash[i]=Integer.MAX_VALUE ;
      }
      t=new int[n+1][n+1];
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<=n ; j++){
        t[i][j]=sc.nextInt();
      }
      hash[0]=0 ;
      for(int i=0 ; i<(1<<n); i++){
        for(int stage=0 ; stage<n ; stage++){
          if((i &(1<<stage))!=0){
            continue ;
          }
          hash[i+(1<<stage)]=Math.min(hash[i]+t[stage][0],hash[i+(1<<stage)]);
          for(int buki=0 ; buki<n ; buki++){
            if((i &(1<<buki))==0){
              continue ;
            }
            hash[i+(1<<stage)]=Math.min(hash[i]+t[stage][buki+1],hash[i+(1<<stage)]);
          }
        }
      }
      pr(hash[(1<<n)-1]);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
   attribute t : Sequence(Sequence(int));
   attribute n : int;
   attribute hash : Sequence(int);
   attribute min : int;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     n := sc.getCurrent()->toInteger() ; 
     min := 2147483647 ; 
    if (n = 0) then (     break ) else skip ; 
    hash := Integer.subrange(1,(1*(2->pow(n)))->oclAsType(long))->collect(0) ; 
        var i : int ; i := 0 ; while i < ((1*(2->pow(n)))->oclAsType(long)) do ( (     hash[i+1] := 2147483647 )  ;     i := i + 1 ) ; 
    t := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ; 
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j <= n do ( (     t[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    hash[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < ((1*(2->pow(n)))->oclAsType(long)) do ( (         var stage : int ; stage := 0 ; while stage < n do ( (     if ((MathLib.bitwiseAnd(i,((1*(2->pow(stage)))->oclAsType(long)))) /= 0) then (     continue ) else skip ; 
     hash[i + ((1*(2->pow(stage)))->oclAsType(long))+1] := Set{hash[i+1] + t[stage+1][0+1], hash[i + ((1*(2->pow(stage)))->oclAsType(long))+1]}->min() ; 
         var buki : int ; buki := 0 ; while buki < n do ( (     if ((MathLib.bitwiseAnd(i,((1*(2->pow(buki)))->oclAsType(long)))) = 0) then (     continue ) else skip ; 
     hash[i + ((1*(2->pow(stage)))->oclAsType(long))+1] := Set{hash[i+1] + t[stage+1][buki + 1+1], hash[i + ((1*(2->pow(stage)))->oclAsType(long))+1]}->min() )  ;     buki := buki + 1 ) )  ;     stage := stage + 1 ) )  ;     i := i + 1 ) ; 
    execute pr(hash[((1*(2->pow(n)))->oclAsType(long)) - 1+1]) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  static final int INF=1<<29 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int N=parseInt(line);
      if(N==0)break ;
      int[][] items=new int[N][N+1];
      for(int i=0 ; i<N ; i++){
        StringTokenizer st=new StringTokenizer(br.readLine());
        for(int j=0 ; j<=N ; j++){
          items[i][j]=parseInt(st.nextToken());
        }
      }
      int[] dp=new int[1<<N];
      Arrays.fill(dp,1,dp.length,INF);
      for(int i=0 ; i<1<<N ; i++){
        for(int j=0 ; j<N ; j++){
          if((i>>j & 1)==0){
            int fastest=items[j][0];
            for(int k=1 ; k<=N ; k++){
              if(((i>>(k-1))& 1)==1){
                fastest=Math.min(fastest,items[j][k]);
              }
            }
            dp[i | 1<<j]=Math.min(dp[i | 1<<j],dp[i]+fastest);
          }
        }
      }
      System.out.println(dp[(1<<N)-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := (1*(2->pow(29)))->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var N : int ; N := parseInt(line) ;
     if (N = 0) then     break else skip ; 
    var items : Sequence(Sequence(int)) ; items := Integer.subrange(1,N)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
         var j : int ; j := 0 ; while j <= N do ( (     items[i+1][j+1] := (st.next() + "")->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,(1*(2->pow(N)))->oclAsType(long))->collect(0) ;
    dp := dp->collect(INF) ; 
        var i : int ; i := 0 ; while i < (1*(2->pow(N)))->oclAsType(long) do ( (         var j : int ; j := 0 ; while j < N do ( (     if ((MathLib.bitwiseAnd((i/(2->pow(j)))->oclAsType(long),1)) = 0) then (     var fastest : int ; fastest := items[j+1][0+1] ;
         var k : int ; k := 1 ; while k <= N do ( (     if ((((i/(2->pow((k - 1))))->oclAsType(long)) & 1) = 1) then (     fastest := Set{fastest, items[j+1][k+1]}->min() ) else skip )  ;     k := k + 1 ) ; 
     dp[MathLib.bitwiseOr(i,(1*(2->pow(j)))->oclAsType(long))+1] := Set{dp[MathLib.bitwiseOr(i,(1*(2->pow(j)))->oclAsType(long))+1], dp[i+1] + fastest}->min() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[((1*(2->pow(N)))->oclAsType(long)) - 1+1]) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void leftRotate(int arr[],int n,int k){
    for(int i=k ; i<k+n ; i++)System.out.print(arr[i % n]+" ");
  }
  public static void main(String[] args){
    int arr[]={
      1,3,5,7,9 };
      int n=arr.length ;
      int k=2 ;
      leftRotate(arr,n,k);
      System.out.println();
      k=3 ;
      leftRotate(arr,n,k);
      System.out.println();
      k=4 ;
      leftRotate(arr,n,k);
      System.out.println();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation leftRotate( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := k ; while i < k + n do (     OclFile["System.out"].print(arr[i mod n+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,5,7,9} ;
     var n : int ; n := arr->size() ;
    var k : int ; k := 2 ;
    execute leftRotate(arr, n, k) ; 
    OclFile["System.out"].println() ; 
    k := 3 ; 
    execute leftRotate(arr, n, k) ; 
    OclFile["System.out"].println() ; 
    k := 4 ; 
    execute leftRotate(arr, n, k) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private void solve()throws Exception {
    int n=nextInt();
    int a[]=new int[n+1];
    for(int i=1 ; i<=n ; i++)a[i]=nextInt();
    int prev=-1 ;
    int ans=0 ;
    int trail=1 ;
    for(int i=1 ; i<=n ; i++){
      if(a[i]==prev+1){
        prev=a[i];
        trail++;
      }
      else {
        if(trail>=2)ans=Math.max(ans,trail-2+(a[i-trail]==1 ? 1 : 0)+(a[i-1]==1000 ? 1 : 0));
        trail=1 ;
        prev=a[i];
      }
    }
    if(trail>=2)ans=Math.max(ans,trail-2+(a[n-trail+1]==1 ? 1 : 0)+(a[n]==1000 ? 1 : 0));
    out.println(ans);
  }
  public void run()throws Exception {
    br=new BufferedReader(new InputStreamReader(System.in));
    st=null ;
    out=new PrintWriter(System.out);
    solve();
    br.close();
    out.close();
  }
  public static void main(String args[])throws Exception {
    new Main().run();
  }
  BufferedReader br ;
  StringTokenizer st ;
  PrintWriter out ;
  String nextToken()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  String nextLine()throws Exception {
    return br.readLine();
  }
  int nextInt()throws Exception {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws Exception {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws Exception {
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
    var prev : int ; prev := -1 ;
    var ans : int ; ans := 0 ;
    var trail : int ; trail := 1 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (a[i+1] = prev + 1) then (     prev := a[i+1] ; 
     trail := trail + 1 ) else (     if (trail >= 2) then     ans := Set{ans, trail - 2 + (if a[i - trail+1] = 1 then 1 else 0 endif) + (if a[i - 1+1] = 1000 then 1 else 0 endif)}->max() ; else skip ; 
     trail := 1 ; 
     prev := a[i+1] ) )  ;     i := i + 1 ) ; 
    if (trail >= 2) then     ans := Set{ans, trail - 2 + (if a[n - trail + 1+1] = 1 then 1 else 0 endif) + (if a[n+1] = 1000 then 1 else 0 endif)}->max() ; else skip ; 
    out.println(ans) ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := null ; 
    out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    br.close() ; 
    out.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute br : OclFile;
   attribute st : OclIterator;
   attribute out : OclFile;
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class APrank {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n+2];
    arr[0]=0 ;
    arr[n+1]=1001 ;
    for(int i=1 ; i<=n ; i++){
      arr[i]=sc.nextInt();
    }
    int c=0,max=0 ;
    for(int i=1 ; i<=n ; i++){
      if(arr[i]-arr[i-1]==1 && arr[i+1]-arr[i]==1){
        c++;
      }
      else {
        max=Math.max(c,max);
        c=0 ;
      }
    }
    max=Math.max(c,max);
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class APrank {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 2)->collect(0) ;
    arr[0+1] := 0 ; 
    arr[n + 1+1] := 1001 ; 
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (arr[i+1] - arr[i - 1+1] = 1 & arr[i + 1+1] - arr[i+1] = 1) then (     c := c + 1 ) else (     max := Set{c, max}->max() ; 
     c := 0 ) )  ;     i := i + 1 ) ; 
    max := Set{c, max}->max() ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(new BufferedInputStream(System.in));
    int n=in.nextInt();
    in.nextLine();
    String[] strings=in.nextLine().split(" ");
    int[] arr=new int[strings.length+2];
    arr[0]=0 ;
    arr[arr.length-1]=1001 ;
    for(int i=1 ; i<=strings.length ; i++){
      arr[i]=Integer.parseInt(strings[i-1]);
    }
    int ans=0 ;
    for(int i=0 ; i<arr.length ; i++){
      int index=i ;
      while(i+1<arr.length && arr[i+1]-arr[i]==1){
        i++;
      }
      if(i-index>0)ans=Math.max(ans,(i-index-1));
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    skip ; 
    var strings : Sequence(String) ; strings := in.nextLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,strings->size() + 2)->collect(0) ;
    arr[0+1] := 0 ; 
    arr[arr->size() - 1+1] := 1001 ; 
        var i : int ; i := 1 ; while i <= strings->size() do ( (     arr[i+1] := (strings[i - 1+1])->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     var index : int ; index := i ;
     while (i + 1 < arr->size() & arr[i + 1+1] - arr[i+1] = 1) do (     i := i + 1 ) ; 
     if (i - index > 0) then     ans := Set{ans, (i - index - 1)}->max() ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int steps(int source,int step,int dest){
    if(Math.abs(source)>(dest))return Integer.MAX_VALUE ;
    if(source==dest)return step ;
    int pos=steps(source+step+1,step+1,dest);
    int neg=steps(source-step-1,step+1,dest);
    return Math.min(pos,neg);
  }
  public static void main(String[] args){
    int dest=11 ;
    System.out.println("No.of steps required"+" to reach "+dest+" is "+steps(0,0,dest));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation steps( source : int, step : int, dest : int) : int
  pre: true
  post: true
  activity: (     if (if source < 0 then -(source) else source endif > (dest)) then     return 2147483647 else skip ; 
     if (source = dest) then     return step else skip ; 
    var pos : int ; pos := steps(source + step + 1, step + 1, dest) ;
    var neg : int ; neg := steps(source - step - 1, step + 1, dest) ;
    return Set{pos, neg}->min() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var dest : int ; dest := 11 ;
     OclFile["System.out"].println("No.of steps required" + " to reach " + dest + " is " + steps(0, 0, dest)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Test {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      String str=sc.next();
      List<Integer>indices=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        if(Character.getNumericValue(str.charAt(i))% 2==0)indices.add(i+1);
      }
      long counter=0 ;
      for(int i : indices){
        counter+=i-1 ;
      }
      counter+=indices.size();
      System.out.println(counter);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var str : String ; str := sc.getCurrent() ;
    var indices : Sequence(int) ; indices := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (("" + str->at(i+1))->toInteger() mod 2 = 0) then     indices := indices->including(i + 1) ; else skip )  ;     i := i + 1 ) ; 
    var counter : long ; counter := 0 ;
    for (i : indices) do ( (     counter := counter+(i - 1) )  ) ; 
    counter := counter+(indices->size()) ; 
    OclFile["System.out"].println(counter) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPrime(int n){
    if(n<=1){
      return false ;
    }
    if(n<=3){
      return true ;
    }
    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 ;
  }
  static int power(int x,int y,int p){
    int res=1 ;
    x=x % p ;
    while(y>0){
      if(y % 2==1){
        res=(res*x)% p ;
      }
      y=y>>1 ;
      x=(x*x)% p ;
    }
    return res ;
  }
  static void findPrimefactors(HashSet<Integer>s,int n){
    while(n % 2==0){
      s.add(2);
      n=n/2 ;
    }
    for(int i=3 ; i<=Math.sqrt(n); i=i+2){
      while(n % i==0){
        s.add(i);
        n=n/i ;
      }
    }
    if(n>2){
      s.add(n);
    }
  }
  static int findPrimitive(int n){
    HashSet<Integer>s=new HashSet<Integer>();
    if(isPrime(n)==false){
      return-1 ;
    }
    int phi=n-1 ;
    findPrimefactors(s,phi);
    for(int r=2 ; r<=phi ; r++){
      boolean flag=false ;
      for(Integer a : s){
        if(power(r,phi/(a),n)==1){
          flag=true ;
          break ;
        }
      }
      if(flag==false){
        return r ;
      }
    }
    return-1 ;
  }
  public static void main(String[] args){
    int n=761 ;
    System.out.println(" Smallest primitive root of "+n+" is "+findPrimitive(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then (     return false ) else skip ; 
     if (n <= 3) then (     return true ) else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then (     return false ) else skip ; 
        var i : int ; i := 5 ; while i * i <= n do ( (     if (n mod i = 0 or n mod (i + 2) = 0) then (     return false ) else skip )  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation power( x : int, y : int, p : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     if (y mod 2 = 1) then (     res := (res * x) mod p ) else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res );
  static   operation findPrimefactors( s : Set(int), n : int) : void
  pre: true
  post: true
  activity: (     while (n mod 2 = 0) do (     s->excludes(2) ; 
     n := n / 2 ) ; 
         var i : int ; i := 3 ; while i <= (n)->sqrt() do ( (     while (n mod i = 0) do (     s->excludes(i) ; 
     n := n / i ) )  ;     i := i + 2 ) ; 
     if (n > 2) then (     s->excludes(n) ) else skip );
  static   operation findPrimitive( n : int) : int
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
     if (isPrime(n) = false) then (     return -1 ) else skip ; 
    var phi : int ; phi := n - 1 ;
    execute findPrimefactors(s, phi) ; 
        var r : int ; r := 2 ; while r <= phi do ( (     var flag : boolean ; flag := false ;
     for (a : s) do ( (     if (power(r, phi / (a), n) = 1) then (     flag := true ; 
     break ) else skip )  ) ; 
     if (flag = false) then (     return r ) else skip )  ;     r := r + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 761 ;
     OclFile["System.out"].println(" Smallest primitive root of " + n + " is " + findPrimitive(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class P1139A {
  public static void main(String[] args)throws IOException {
    BufferedReader io=new BufferedReader(new InputStreamReader(System.in));
    Integer len=Integer.valueOf(io.readLine());
    String input=io.readLine();
    Integer sum=0 ;
    for(int i=0 ; i<input.length(); i++){
      if(input.charAt(i)=='0' || input.charAt(i)=='2' || input.charAt(i)=='4' || input.charAt(i)=='6' || input.charAt(i)=='8'){
        sum=sum+i+1 ;
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class P1139A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var len : int ; len := (io.readLine())->toInteger() ;
    var input : String ; input := io.readLine() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < input->size() do ( (     if (input->at(i+1) = '0' or input->at(i+1) = '2' or input->at(i+1) = '4' or input->at(i+1) = '6' or input->at(i+1) = '8') then (     sum := sum + i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class evensub {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,i,c=0 ;
    String s ;
    n=sc.nextInt();
    s=sc.next();
    for(i=0 ; i<n ; i++){
      if((int)(s.charAt(i)-48)% 2==0)c=c+(i+1);
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class evensub {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var i : int ;
    var c : int ; c := 0 ;
    var s : String ;
    n := sc.getCurrent()->toInteger() ; 
    s := sc.getCurrent() ; 
        i := 0 ; while i < n do ( (     if ((s->at(i+1) - 48)->oclAsType(int) mod 2 = 0) then     c := c + (i + 1) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class EvenSubstrings {
  public static void main(String[] args){
    Scanner keybord=new Scanner(System.in);
    int L=keybord.nextInt();
    String number=keybord.next();
    System.out.println(evenNumSubstring(number));
  }
  static int evenNumSubstring(String str){
    int len=str.length();
    int count=0 ;
    for(int i=0 ; i<len ; i++){
      int temp=str.charAt(i)-'0' ;
      if(temp % 2==0)count+=(i+1);
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class EvenSubstrings {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var keybord : OclFile ; keybord := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var L : int ; L := keybord.getCurrent()->toInteger() ;
     var number : String ; number := keybord.getCurrent() ;
     OclFile["System.out"].println(evenNumSubstring(number)) );
  static   operation evenNumSubstring( str : String) : int
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < len do ( (     var temp : int ; temp := str->at(i+1) - ('0')->char2byte() ;
     if (temp mod 2 = 0) then     count := count+((i + 1)) ; else skip )  ;     i := i + 1 ) ; 
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class MinCostOp_Mintowerheight {
  static long costOfOperation(int n,int h[],int cost[],int eq_h){
    long c=0 ;
    for(int i=0 ; i<n ; i++)c+=Math.abs(h[i]-eq_h)*cost[i];
    return c ;
  }
  static long Bsearch(int n,int h[],int cost[]){
    int max_h=Arrays.stream(h).max().getAsInt();
    long ans=Long.MAX_VALUE ;
    long high=1+max_h ;
    long low=0 ;
    while(high>low){
      int mid=(int)((low+high)>>1);
      long bm=(mid>0)? costOfOperation(n,h,cost,mid-1): Long.MAX_VALUE ;
      long m=costOfOperation(n,h,cost,mid);
      long am=costOfOperation(n,h,cost,mid+1);
      if(ans==m)break ;
      ans=Long.min(ans,m);
      if(bm<=m)high=mid ;
      else if(am<=m)low=mid+1 ;
      else return m ;
    }
    return ans ;
  }
  public static void main(String args[]){
    int h[]={
      1,2,3 };
      int cost[]={
        10,100,1000 };
        int n=h.length ;
        System.out.println(Bsearch(n,h,cost));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class MinCostOp_Mintowerheight {
  static   operation costOfOperation( n : int, h : Sequence(int), cost : Sequence(int), eq_h : int) : long
  pre: true
  post: true
  activity: (     var c : long ; c := 0 ;
         var i : int ; i := 0 ; while i < n do (     c := c+(if h[i+1] - eq_h < 0 then -(h[i+1] - eq_h) else h[i+1] - eq_h endif * cost[i+1]) ;  ;     i := i + 1 ) ; 
     return c );
  static   operation Bsearch( n : int, h : Sequence(int), cost : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var max_h : int ; max_h := stream(h).max().getAsInt() ;
     var ans : long ; ans := "9223372036854775807"->toLong() ;
    var high : long ; high := 1 + max_h ;
    var low : long ; low := 0 ;
    while (high > low) do (     var mid : int ; mid := (((low + high)/(2->pow(1)))->oclAsType(long))->oclAsType(int) ;
     var bm : long ; bm := if (mid > 0) then costOfOperation(n, h, cost, mid - 1) else "9223372036854775807"->toLong() endif ;
    var m : long ; m := costOfOperation(n, h, cost, mid) ;
    var am : long ; am := costOfOperation(n, h, cost, mid + 1) ;
    if (ans = m) then     break else skip ; 
    ans := Set{ans, m}->min() ; 
    if (bm <= m) then     high := mid else     if (am <= m) then     low := mid + 1 else     return m ;  ;  
 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var h : Sequence(int) ; h := Sequence{1,2,3} ;
     var cost : Sequence(int) ; cost := Sequence{10,100,1000} ;
     var n : int ; n := h->size() ;
     OclFile["System.out"].println(Bsearch(n, h, cost)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  private static final long mod=(long)1e9+7 ;
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    long a=sc.nextLong(),b=sc.nextLong(),c=sc.nextLong(),d=sc.nextLong();
    long aa[]={
      a,b };
      long bb[]={
        c,d };
        long ans=Long.MIN_VALUE ;
        for(int i=0 ; i<2 ; i++){
          for(int j=0 ; j<2 ; j++){
            ans=Math.max(ans,aa[i]*bb[j]*1l);
          }
        }
        out.println(ans);
        out.flush();
      }
      static boolean vis[]=new boolean[10001];
      static long gcd(long a,long b){
        if(a==0)return b ;
        return gcd(b % a,a);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute mod : long := 1e9->oclAsType(long) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var c : long ; c := sc.getCurrent()->toLong() ;
    var d : long ; d := sc.getCurrent()->toLong() ;
    var aa : Sequence(long) ; aa := Sequence{a,b} ;
    var bb : Sequence(long) ; bb := Sequence{c,d} ;
    var ans : long ; ans := "-9223372036854775808"->toLong() ;
        var i : int ; i := 0 ; while i < 2 do ( (         var j : int ; j := 0 ; while j < 2 do ( (     ans := Set{ans, aa[i+1] * bb[j+1] * 1l}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   attribute vis : boolean := Integer.subrange(1,10001)->collect(false);
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int centeredHexagonalNumber(int n){
    return 3*n*(n-1)+1 ;
  }
  public static void main(String args[]){
    int n=10 ;
    System.out.print(n+"th centered "+"hexagonal number: ");
    System.out.println(centeredHexagonalNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation centeredHexagonalNumber( n : int) : int
  pre: true
  post: true
  activity: (     return 3 * n * (n - 1) + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].print(n + "th centered " + "hexagonal number: ") ; 
     OclFile["System.out"].println(centeredHexagonalNumber(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
public class pre42 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int n=obj.nextInt(),arr[]=new int[n],newNumber[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=obj.nextInt();
    TreeSet<Integer>map=new TreeSet<>(),idx=new TreeSet<>();
    for(int i=0 ; i<n ; i++){
      if(! map.contains(arr[i])&& arr[i]<=n){
        newNumber[i]=arr[i];
        map.add(arr[i]);
        idx.add(arr[i]);
      }
    }
    int current=1 ;
    for(int i=0 ; i<n ; i++){
      if(newNumber[i]==0){
        while(idx.contains(current))current++;
        newNumber[i]=current ;
        idx.add(current);
      }
    }
    for(int i=0 ; i<n ; i++)System.out.print(newNumber[i]+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre42 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var n : int ; n := obj.nextInt() ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,n)->collect(0) ;
    var newNumber : Sequence(void) ; newNumber := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := obj.nextInt() ;  ;     i := i + 1 ) ; 
    var map : Set(int) ; map := Set{} ;
    var idx : Set(int) ; idx := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (not(map->includes(arr[i+1])) & arr[i+1] <= n) then (     newNumber[i+1] := arr[i+1] ; 
     map := map->including(arr[i+1]) ; 
     idx->excludes(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    var current : int ; current := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (newNumber[i+1] = 0) then (     while (idx->includes(current)) do     current := current + 1 ; ; 
     newNumber[i+1] := current ; 
     idx->excludes(current) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(newNumber[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Inventory {
  public static void main(String[] args){
    FastReader in=new FastReader();
    int n=in.nextInt();
    int j=1 ;
    int a[]=new int[n+2];
    int b[]=new int[100005];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
      b[a[i] ]++;
    }
    for(int i=0 ; i<n ; i++){
      while(b[j]>0)j++;
      if(b[a[i] ]>1 || a[i]>n){
        b[a[i] ]--;
        b[j]++;
        a[i]=j ;
      }
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(a[i]+" ");
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Inventory {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var n : int ; n := in.nextInt() ;
    var j : int ; j := 1 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 2)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,100005)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.nextInt() ; 
     b[a[i+1]+1] := b[a[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     while (b[j+1] > 0) do     j := j + 1 ; ; 
     if (b[a[i+1]+1] > 1 or a[i+1] > n) then (     b[a[i+1]+1] := b[a[i+1]+1] - 1 ; 
     b[j+1] := b[j+1] + 1 ; 
     a[i+1] := j ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(a[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s="" ;
    int c=0 ;
    int k=n ;
    for(int i=2 ; i<n ; i++){
      if(k % i==0){
        s=s+i ;
        s=s+(k/i);
        break ;
      }
    }
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := "" ;
    var c : int ; c := 0 ;
    var k : int ; k := n ;
        var i : int ; i := 2 ; while i < n do ( (     if (k mod i = 0) then (     s := s + i ; 
     s := s + (k / i) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class p1331B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    StringBuilder s=new StringBuilder();
    for(int i=2,j=(int)Math.sqrt(n); i<=j ; i++){
      if(n % i==0){
        System.out.print(i+""+n/i);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class p1331B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := StringLib.newString() ;
         var i : int ; i := 2 ;
    var j : int ; j := (n)->sqrt()->oclAsType(int) ; while i <= j do ( (     if (n mod i = 0) then (     OclFile["System.out"].print(i + "" + n / i) ; 
     return ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
import java.util.Arrays ;
public class Test1 {
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int i ;
    for(i=2 ; i<n ; i++){
      if(n % i==0){
        System.out.print(i+""+(n/i));
        break ;
      }
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var i : int ;
        i := 2 ; while i < n do ( (     if (n mod i = 0) then (     OclFile["System.out"].print(i + "" + (n / i)) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class A1158 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int M=in.nextInt();
    long bSum=0 ;
    int[] B=new int[N];
    for(int n=0 ; n<N ; n++){
      int b=in.nextInt();
      bSum+=b ;
      B[n]=b ;
    }
    long gSum=0 ;
    int[] G=new int[M];
    for(int m=0 ; m<M ; m++){
      int g=in.nextInt();
      gSum+=g ;
      G[m]=g ;
    }
    Arrays.sort(B);
    Arrays.sort(G);
    int bMax=B[N-1];
    long answer ;
    if(N==1){
      if(G[0]==B[0]){
        answer=gSum ;
      }
      else {
        answer=-1 ;
      }
    }
    else if(M==1){
      if(G[0]==bMax){
        answer=bSum ;
      }
      else {
        answer=-1 ;
      }
    }
    else if(G[0]<bMax){
      answer=-1 ;
    }
    else {
      answer=bSum*M+gSum-bMax*(long)M ;
      if(G[0]>bMax){
        answer+=bMax-B[N-2];
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1158 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var M : int ; M := in.getCurrent()->toInteger() ;
    var bSum : long ; bSum := 0 ;
    var B : Sequence(int) ; B := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     var b : int ; b := in.getCurrent()->toInteger() ;
     bSum := bSum+(b) ; 
     B[n+1] := b )  ;     n := n + 1 ) ; 
    var gSum : long ; gSum := 0 ;
    var G : Sequence(int) ; G := Integer.subrange(1,M)->collect(0) ;
        var m : int ; m := 0 ; while m < M do ( (     var g : int ; g := in.getCurrent()->toInteger() ;
     gSum := gSum+(g) ; 
     G[m+1] := g )  ;     m := m + 1 ) ; 
    B := B->sort() ; 
    G := G->sort() ; 
    var bMax : int ; bMax := B[N - 1+1] ;
    var answer : long ;
    if (N = 1) then (     if (G[0+1] = B[0+1]) then (     answer := gSum ) else (     answer := -1 ) ) else     if (M = 1) then (     if (G[0+1] = bMax) then (     answer := bSum ) else (     answer := -1 ) ) else     if (G[0+1] < bMax) then (     answer := -1 ) else (     answer := bSum * M + gSum - bMax * M->oclAsType(long) ; 
     if (G[0+1] > bMax) then (     answer := answer+(bMax - B[N - 2+1]) ) else skip ) ;  ;  ;  
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
import java.util.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    FastReader in=new FastReader();
    int n=in.nextInt();
    int prime[]=new int[95];
    int a[]=new int[500];
    a[0]=1 ;
    a[1]=1 ;
    int k=0 ;
    for(int i=2 ; i<=499 ; i++){
      if(a[i]==0){
        prime[k]=i ;
        k++;
        for(int j=2*i ; j<500 ; j+=i)a[j]=1 ;
      }
    }
    for(int i=0 ; i<95 ; i++){
      if(n % prime[i]==0){
        int q=n/prime[i];
        if(a[q]==0){
          System.out.print(prime[i]);
          System.out.print(q);
          System.out.println();
        }
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var n : int ; n := in.nextInt() ;
    var prime : Sequence(int) ; prime := Integer.subrange(1,95)->collect(0) ;
    var a : Sequence(int) ; a := Integer.subrange(1,500)->collect(0) ;
    a[0+1] := 1 ; 
    a[1+1] := 1 ; 
    var k : int ; k := 0 ;
        var i : int ; i := 2 ; while i <= 499 do ( (     if (a[i+1] = 0) then (     prime[k+1] := i ; 
     k := k + 1 ; 
         var j : int ; j := 2 * i ; while j < 500 do (     a[j+1] := 1 ;  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 95 do ( (     if (n mod prime[i+1] = 0) then (     var q : int ; q := n / prime[i+1] ;
     if (a[q+1] = 0) then (     OclFile["System.out"].print(prime[i+1]) ; 
     OclFile["System.out"].print(q) ; 
     OclFile["System.out"].println() ) else skip ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.lang.reflect.Array ;
import java.util.*;
public class Main {
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] nextArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long[] nextArray(long n){
      long[] a=new long[(int)n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  static class FastWriter extends PrintWriter {
    FastWriter(){
      super(System.out);
    }
    void println(int[] array){
      for(int i=0 ; i<array.length ; i++){
        print(array[i]+" ");
      }
      println();
    }
    void println(long[] array){
      for(int i=0 ; i<array.length ; i++){
        print(array[i]+" ");
      }
      println();
    }
  }
  static ArrayList<Integer>list=new ArrayList<>();
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    FastWriter out=new FastWriter();
    int t=in.nextInt();
    for(int i=2 ; i<t ; i++){
      if(t % i==0){
        System.out.println(i+""+t/i);
        return ;
      }
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextArray( n : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n->oclAsType(int))->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static class FastWriter extends OclFile {
   static operation newFastWriter() : FastWriter
  pre: true
  post: true
  activity:
  ( var self : FastWriter ;
    self := createFastWriter();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"]) );
   operation println( array : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < array->size() do ( (     execute print(array[i+1] + " ") )  ;     i := i + 1 ) ; 
     execute println() );
   operation println( array : Sequence(long)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < array->size() do ( (     execute print(array[i+1] + " ") )  ;     i := i + 1 ) ; 
     execute println() );
}
  static   attribute list : Sequence(int) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : FastWriter ; out := FastWriter.newFastWriter() ;
    var t : int ; t := in.nextInt() ;
        var i : int ; i := 2 ; while i < t do ( (     if (t mod i = 0) then (     OclFile["System.out"].println(i + "" + t / i) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    out.close() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String[] O=sc.nextLine().split("");
    String[] E=sc.nextLine().split("");
    String[] result=new String[O.length+E.length];
    int i_o=0 ;
    int i_e=0 ;
    for(int i=1 ; i<=O.length+E.length ; i++){
      if(i % 2!=0){
        System.out.print(O[i_o]);
        i_o++;
      }
      else {
        System.out.print(E[i_e]);
        i_e++;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var O : Sequence(String) ; O := sc.nextLine()->split("") ;
    var E : Sequence(String) ; E := sc.nextLine()->split("") ;
    var result : Sequence(String) ; result := Integer.subrange(1,O->size() + E->size())->collect(null) ;
    var i_o : int ; i_o := 0 ;
    var i_e : int ; i_e := 0 ;
        var i : int ; i := 1 ; while i <= O->size() + E->size() do ( (     if (i mod 2 /= 0) then (     OclFile["System.out"].print(O[i_o+1]) ; 
     i_o := i_o + 1 ) else (     OclFile["System.out"].print(E[i_e+1]) ; 
     i_e := i_e + 1 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Solution {
  static int closestMultiple(int n,int x){
    if(x>n)return x ;
    n=n+x/2 ;
    n=n-(n % x);
    return n ;
  }
  public static void main(String[] args){
    int n=56287,x=27 ;
    System.out.println(closestMultiple(n,x));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation closestMultiple( n : int, x : int) : int
  pre: true
  post: true
  activity: (     if (x > n) then     return x else skip ; 
     n := n + x / 2 ; 
     n := n - (n mod x) ; 
     return n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 56287 ;
    var x : int ; x := 27 ;
     OclFile["System.out"].println(closestMultiple(n, x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    Solver solver=new Solver();
    solver.init();
    for(; solver.hasNext(); ){
      solver.readBody(in.readLine());
    }
    solver.solve();
  }
}
class Solver {
  int N ;
  int cnt ;
  String[] pass ;
  public void init(){
    N=0 ;
    cnt=0 ;
    pass=new String[2];
  }
  public void readHead(String str){
    String[] strArr=str.split(" ");
  }
  public boolean hasNext(){
    return cnt<2 ;
  }
  public void readBody(String str){
    pass[cnt]=str ;
    cnt++;
  }
  public void solve(){
    for(int i=0 ; i<pass[0] .length(); i++){
      System.out.print(pass[0] .charAt(i));
      if(i<pass[1] .length())System.out.print(pass[1] .charAt(i));
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var solver : Solver ; solver := Solver.newSolver() ;
    solver.init() ; 
      while solver.hasNext() do ( (     solver.readBody(in.readLine()) )  ) ; 
    solver.solve() ; 
 );
}
class Solver {
   attribute N : int;
   attribute cnt : int;
   attribute pass : Sequence(String);
   operation init() : void
  pre: true
  post: true
  activity: (     N := 0 ; 
     cnt := 0 ; 
     pass := Integer.subrange(1,2)->collect(null) );
   operation readHead( str : String) : void
  pre: true
  post: true
  activity: (     var strArr : Sequence(String) ; strArr := str->split(" ") );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return cnt < 2 );
   operation readBody( str : String) : void
  pre: true
  post: true
  activity: (     pass[cnt+1] := str ; 
     cnt := cnt + 1 );
   operation solve() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < pass[0+1]->size() do ( (     OclFile["System.out"].print(pass[0+1]->at(i+1)) ; 
     if (i < pass[1+1]->size()) then     OclFile["System.out"].print(pass[1+1]->at(i+1)) ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Map ;
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Set ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastReader sc=new FastReader();
    String s=sc.next();
    String t=sc.next();
    StringBuilder res=new StringBuilder();
    int sPos=0 ;
    int tPos=0 ;
    while(sPos<s.length()|| tPos<t.length()){
      if(sPos<s.length()){
        res.append(s.charAt(sPos));
        sPos++;
      }
      if(tPos<t.length()){
        res.append(t.charAt(tPos));
        tPos++;
      }
    }
    System.out.println(res.toString());
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var s : String ; s := sc.next() ;
    var t : String ; t := sc.next() ;
    var res : String ; res := StringLib.newString() ;
    var sPos : int ; sPos := 0 ;
    var tPos : int ; tPos := 0 ;
    while (sPos < s->size() or tPos < t->size()) do (     if (sPos < s->size()) then (     res := res + StringLib.newString(s->at(sPos+1)) ; 
     sPos := sPos + 1 ) else skip ; 
     if (tPos < t->size()) then (     res := res + StringLib.newString(t->at(tPos+1)) ; 
     tPos := tPos + 1 ) else skip ) ; 
    OclFile["System.out"].println(res+"") ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static void solve(){
    String o=in.next();
    String e=in.next();
    int n=o.length();
    int m=e.length();
    int p=0,q=0 ;
    for(int i=0 ; i<n+m ; i++){
      if(i % 2==0){
        out.print(o.charAt(p));
        p++;
      }
      else {
        out.print(e.charAt(q));
        q++;
      }
    }
    out.println();
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    solve();
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var o : String ; o := in.getCurrent() ;
     var e : String ; e := in.getCurrent() ;
    var n : int ; n := o->size() ;
    var m : int ; m := e->size() ;
    var p : int ; p := 0 ;
    var q : int ; q := 0 ;
        var i : int ; i := 0 ; while i < n + m do ( (     if (i mod 2 = 0) then (     skip ; 
     p := p + 1 ) else (     skip ; 
     q := q + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    execute solve() ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ABC058_B solver=new ABC058_B();
    solver.solve(1,in,out);
    out.close();
  }
  static class ABC058_B {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      String O=in.next();
      String E=in.next();
      int len=O.length()+E.length();
      StringBuilder ans=new StringBuilder();
      for(int i=0 ; i<len ; ++i){
        if((i+1)% 2==0){
          ans.append(E.charAt(i/2));
        }
        else {
          ans.append(O.charAt(i/2));
        }
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ABC058_B ; solver := ABC058_B.newABC058_B() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ABC058_B {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var O : String ; O := in.getCurrent() ;
     var E : String ; E := in.getCurrent() ;
    var len : int ; len := O->size() + E->size() ;
    var ans : String ; ans := StringLib.newString() ;
        var i : int ; i := 0 ; while i < len do ( (     if ((i + 1) mod 2 = 0) then (     ans := ans + StringLib.newString(E->at(i / 2+1)) ) else (     ans := ans + StringLib.newString(O->at(i / 2+1)) ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int sumOfLargePrimeFactor(int n){
    int prime[]=new int[n+1],sum=0 ;
    Arrays.fill(prime,0);
    int max=n/2 ;
    for(int p=2 ; p<=max ; p++){
      if(prime[p]==0){
        for(int i=p*2 ; i<=n ; i+=p)prime[i]=p ;
      }
    }
    for(int p=2 ; p<=n ; p++){
      if(prime[p]!=0)sum+=prime[p];
      else sum+=p ;
    }
    return sum ;
  }
  public static void main(String args[]){
    int n=12 ;
    System.out.println("Sum="+sumOfLargePrimeFactor(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfLargePrimeFactor( n : int) : int
  pre: true
  post: true
  activity: (     var prime : Sequence(int) ; prime := Integer.subrange(1,n + 1)->collect(0) ;
    var sum : int ; sum := 0 ;
     prime := prime->collect(0) ; 
    var max : int ; max := n / 2 ;
        var p : int ; p := 2 ; while p <= max do ( (     if (prime[p+1] = 0) then (         var i : int ; i := p * 2 ; while i <= n do (     prime[i+1] := p ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
        var p : int ; p := 2 ; while p <= n do ( (     if (prime[p+1] /= 0) then     sum := sum+(prime[p+1]) ; else     sum := sum+(p) ; )  ;     p := p + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     OclFile["System.out"].println("Sum=" + sumOfLargePrimeFactor(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int digit_count(int x){
    int sum=0 ;
    while(x>0){
      sum++;
      x=x/10 ;
    }
    return sum ;
  }
  static int find_count(int[] arr,int k){
    int ans=0 ;
    for(int i : arr){
      int x=digit_count(i);
      if(x % k==0)ans+=1 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int[] arr={
      12,345,2,68,7896 };
      int K=2 ;
      System.out.print(find_count(arr,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation digit_count( x : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (x > 0) do (     sum := sum + 1 ; 
     x := x / 10 ) ; 
     return sum );
  static   operation find_count( arr : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     for (i : arr) do ( (     var x : int ; x := digit_count(i) ;
     if (x mod k = 0) then     ans := ans+(1) ; else skip )  ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,345,2,68,7896} ;
     var K : int ; K := 2 ;
     OclFile["System.out"].print(find_count(arr, K)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int max_element(int a[],int n){
    int m=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++)m=Math.max(m,a[i]);
    return m ;
  }
  static void findNum(int a[],int n,int b[],int m){
    int x=max_element(a,n);
    int y=max_element(b,m);
    System.out.print(x+" "+y);
  }
  public static void main(String args[]){
    int a[]={
      3,2,2 };
      int n=a.length ;
      int b[]={
        1,5,7,7,9 };
        int m=b.length ;
        findNum(a,n,b,m);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation max_element( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var m : int ; m := -2147483648 ;
         var i : int ; i := 0 ; while i < n do (     m := Set{m, a[i+1]}->max() ;  ;     i := i + 1 ) ; 
     return m );
  static   operation findNum( a : Sequence(int), n : int, b : Sequence(int), m : int) : void
  pre: true
  post: true
  activity: (     var x : int ; x := max_element(a, n) ;
     var y : int ; y := max_element(b, m) ;
     OclFile["System.out"].print(x + " " + y) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{3,2,2} ;
     var n : int ; n := a->size() ;
    var b : Sequence(int) ; b := Sequence{1,5,7,7,9} ;
    var m : int ; m := b->size() ;
    execute findNum(a, n, b, m) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int m=sc.nextInt();
    int n=sc.nextInt();
    if(m==2){
      int first=0 ;
      int second=0 ;
      for(int i=0 ; i<n ; i++){
        int x=sc.nextInt();
        if(i % 2==0){
          if(x==1){
            second++;
          }
          else {
            first++;
          }
        }
        else {
          if(x==1){
            first++;
          }
          else {
            second++;
          }
        }
      }
      System.out.println(Math.min(first,second));
    }
    else {
      int prev=sc.nextInt();
      int count=0 ;
      for(int i=1 ; i<n ; i++){
        int x=sc.nextInt();
        if(prev==x){
          count++;
          prev=0 ;
        }
        else {
          prev=x ;
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (m = 2) then (     var first : int ; first := 0 ;
     var second : int ; second := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (i mod 2 = 0) then (     if (x = 1) then (     second := second + 1 ) else (     first := first + 1 ) ) else (     if (x = 1) then (     first := first + 1 ) else (     second := second + 1 ) ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(Set{first, second}->min()) ) else (     var prev : int ; prev := sc.getCurrent()->toInteger() ;
     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (prev = x) then (     count := count + 1 ; 
     prev := 0 ) else (     prev := x ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.Math ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n,arr[];
    n=input.nextInt();
    arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=input.nextInt();
    }
    if(arr[n-1]==0){
      System.out.println("UP");
    }
    else if(arr[n-1]==15){
      System.out.println("DOWN");
    }
    else if(n==1){
      System.out.println(-1);
    }
    else if(arr[n-1]-arr[n-2]>=0){
      System.out.println("UP");
    }
    else {
      System.out.println("DOWN");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var arr : Sequence(void) ;
    n := input.getCurrent()->toInteger() ; 
    arr := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (arr[n - 1+1] = 0) then (     OclFile["System.out"].println("UP") ) else     if (arr[n - 1+1] = 15) then (     OclFile["System.out"].println("DOWN") ) else     if (n = 1) then (     OclFile["System.out"].println(-1) ) else     if (arr[n - 1+1] - arr[n - 2+1] >= 0) then (     OclFile["System.out"].println("UP") ) else (     OclFile["System.out"].println("DOWN") ) ;  ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p348 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p348().run());
  }
  private static final int TARGET_WAYS=4 ;
  private static final int TARGET_COUNT=5 ;
  static {
    assert 0<=TARGET_COUNT ;
    assert 0<=TARGET_WAYS && TARGET_WAYS<=Byte.MAX_VALUE-1 ;
  }
  public String run(){
    for(long limit=1 ; ; limit*=10){
      if(limit>Integer.MAX_VALUE)throw new AssertionError("Overflow");
      long answer=trySearch((int)limit);
      if(answer!=-1)return Long.toString(answer);
    }
  }
  private static long trySearch(int limit){
    byte[] ways=new byte[limit];
    for(int i=cbrt(limit-1); i>1 ; i--){
      int cube=i*i*i ;
      for(int j=Library.sqrt(limit-1-cube); j>1 ; j--){
        int index=cube+j*j ;
        ways[index]=(byte)Math.min(ways[index]+1,TARGET_WAYS+1);
      }
    }
    long result=0 ;
    int count=0 ;
    for(int i=0 ; i<ways.length ; i++){
      if(ways[i]==TARGET_WAYS && Library.isPalindrome(i)){
        result+=i ;
        count++;
        if(count==TARGET_COUNT)return result ;
      }
    }
    return-1 ;
  }
  private static int cbrt(int x){
    if(x<0)throw new IllegalArgumentException("Not implemented");
    int y=0 ;
    for(int i=1<<10 ; i!=0 ; i>>>=1){
      y |=i ;
      if(y>1290 || y*y*y>x)y ^=i ;
    }
    return y ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p348 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p348.newp348().run()) );
  static    attribute TARGET_WAYS : int := 4;
  static    attribute TARGET_COUNT : int := 5;
  static operation initialiseClass()
  pre: true post: true
  activity:     assert 0 <= TARGET_COUNT ; 
    assert 0 <= TARGET_WAYS & TARGET_WAYS <= 127 - 1 ; 
;
   operation run() : String
  pre: true
  post: true
  activity: (         var limit : long ; limit := 1 ; while true do ( (     if (limit > 2147483647) then     error AssertionException("Overflow") ; else skip ; 
     var answer : long ; answer := trySearch(limit->oclAsType(int)) ;
     if (answer /= -1) then     return ((answer) + "") else skip )  ;     limit := limit*(10) ) );
  static   operation trySearch( limit : int) : long
  pre: true
  post: true
  activity: (     var ways : Sequence(int) ; ways := Integer.subrange(1,limit)->collect(0) ;
         var i : int ; i := cbrt(limit - 1) ; while i > 1 do ( (     var cube : int ; cube := i * i * i ;
         var j : int ; j := Library.sqrt(limit - 1 - cube) ; while j > 1 do ( (     var index : int ; index := cube + j * j ;
     ways[index+1] := (Set{ways[index+1] + 1, TARGET_WAYS + 1}->min() mod 128) )  ;     j := j - 1 ) )  ;     i := i - 1 ) ; 
    var result : long ; result := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < ways->size() do ( (     if (ways[i+1] = TARGET_WAYS & Library.isPalindrome(i)) then (     result := result+(i) ; 
     count := count + 1 ; 
     if (count = TARGET_COUNT) then     return result else skip ) else skip )  ;     i := i + 1 ) ; 
    return -1 
 );
  static   operation cbrt( x : int) : int
  pre: true
  post: true
  activity: (     if (x < 0) then     error IllegalArgumentException.newIllegalArgumentException("Not implemented") ; else skip ; 
     var y : int ; y := 0 ;
         var i : int ; i := (1*(2->pow(10)))->oclAsType(long) ; while i /= 0 do ( (     y := MathLib.bitwiseOr(y, i) ; 
     if (y > 1290 or y * y * y > x) then     y := MathLib.bitwiseXor(y,i) ; else skip )  ;     i := i/(2->pow(1)) ) ; 
     return y );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class compititive_programmer {
  public static void main(String args[]){
    int t ;
    Scanner in=new Scanner(System.in);
    t=in.nextInt();
    in.nextLine();
    while(t!=0){
      t--;
      String s=in.nextLine();
      int zero=0,sum=0,even=0 ;
      for(int i=0 ; i<s.length(); i++){
        sum+=(s.charAt(i)-'0');
        if(s.charAt(i)=='0')zero++;
        if(s.charAt(i)% 2==0 && s.charAt(i)!='0')even++;
      }
      if(zero!=s.length()&&((even==0 && zero==1)|| zero==0 || sum % 3!=0))System.out.println("cyan");
      else System.out.println("red");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class compititive_programmer {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    t := in.getCurrent()->toInteger() ; 
    skip ; 
    while (t /= 0) do (     t := t - 1 ; 
     var s : String ; s := in.nextLine() ;
    var zero : int ; zero := 0 ;
    var sum : int ; sum := 0 ;
    var even : int ; even := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     sum := sum+((s->at(i+1) - ('0')->char2byte())) ; 
     if (s->at(i+1) = '0') then     zero := zero + 1 ; else skip ; 
     if (s->at(i+1) mod 2 = 0 & s->at(i+1) /= '0') then     even := even + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (zero /= s->size() & ((even = 0 & zero = 1) or zero = 0 or sum mod 3 /= 0)) then     OclFile["System.out"].println("cyan") else     OclFile["System.out"].println("red") ; ;  
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class UniversalSolution {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t!=0){
      solve(br,pr);
      t--;
    }
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    String s=br.readLine();
    int n=s.length();
    int countP=0 ;
    int countS=0 ;
    int countR=0 ;
    for(int i=0 ; i<s.length(); i++){
      char c=s.charAt(i);
      if(c=='P'){
        countP++;
      }
      else if(c=='S'){
        countS++;
      }
      else {
        countR++;
      }
    }
    StringBuffer res=new StringBuffer();
    int max=Math.max(countP,Math.max(countR,countS));
    if(max==countP){
      for(int i=0 ; i<n ; i++){
        res.append("S");
      }
    }
    else if(max==countR){
      for(int i=0 ; i<n ; i++){
        res.append("P");
      }
    }
    else if(max==countS){
      for(int i=0 ; i<n ; i++){
        res.append("R");
      }
    }
    pr.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class UniversalSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
    while (t /= 0) do (     execute solve(br, pr) ; 
     t := t - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := br.readLine() ;
     var n : int ; n := s->size() ;
    var countP : int ; countP := 0 ;
    var countS : int ; countS := 0 ;
    var countR : int ; countR := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var c : String ; c := s->at(i+1) ;
     if (c = 'P') then (     countP := countP + 1 ) else     if (c = 'S') then (     countS := countS + 1 ) else (     countR := countR + 1 ) ;  )  ;     i := i + 1 ) ; 
    var res : String ; res := StringLib.newString() ;
    var max : int ; max := Set{countP, Set{countR, countS}->max()}->max() ;
    if (max = countP) then (         var i : int ; i := 0 ; while i < n do ( (     res := res + StringLib.newString("S") )  ;     i := i + 1 ) ) else     if (max = countR) then (         var i : int ; i := 0 ; while i < n do ( (     res := res + StringLib.newString("P") )  ;     i := i + 1 ) ) else     if (max = countS) then (         var i : int ; i := 0 ; while i < n do ( (     res := res + StringLib.newString("R") )  ;     i := i + 1 ) ) else skip ; ;  ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-12 ;
  int n,m ;
  void run(){
    n=sc.nextInt();
    m=sc.nextInt();
    solve();
  }
  void solve(){
    double[] dp=new double[n+1];
    dp[0]=1 ;
    for(int j=1 ; j<=n ; j++){
      for(int i=1 ; i<=min(m,j); i++){
        dp[j]+=dp[j-i]/j ;
      }
    }
    println(String.format("%.12f",dp[n]));
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-12;
   attribute n : int;
   operation run() : void
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
     m := sc.getCurrent()->toInteger() ; 
     execute solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var dp : Sequence(double) ; dp := Integer.subrange(1,n + 1)->collect(0.0) ;
     dp[0+1] := 1 ; 
         var j : int ; j := 1 ; while j <= n do ( (         var i : int ; i := 1 ; while i <= Set{m, j}->min() do ( (     dp[j+1] := dp[j+1]+(dp[j - i+1] / j) )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
     execute println(StringLib.format("%.12f",Sequence{dp[n+1]})) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static final double PI=3.142 ;
  public static void main(String[] args){
    double x,ret,val ;
    x=60.0 ;
    val=(int)PI/180.0 ;
    ret=Math.cos(x*val);
    System.out.print("The cosine of "+x+" is ");
    System.out.print(ret);
    System.out.println(" degrees");
    x=90.0 ;
    val=(int)PI/180.0 ;
    ret=Math.cos(x*val);
    System.out.print("The cosine of "+x+" is ");
    System.out.print(ret);
    System.out.println(" degrees");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute PI : double := 3.142;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : double ;
    var ret : double ;
    var val : double ;
     x := 60.0 ; 
    val := PI->oclAsType(int) / 180.0 ; 
    ret := (x * val)->cos() ; 
    OclFile["System.out"].print("The cosine of " + x + " is ") ; 
    OclFile["System.out"].print(ret) ; 
    OclFile["System.out"].println(" degrees") ; 
    x := 90.0 ; 
    val := PI->oclAsType(int) / 180.0 ; 
    ret := (x * val)->cos() ; 
    OclFile["System.out"].print("The cosine of " + x + " is ") ; 
    OclFile["System.out"].print(ret) ; 
    OclFile["System.out"].println(" degrees") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1334 {
  public static boolean isValid(int[] p,int[] c){
    for(int i=0 ; i<p.length-1 ; i++){
      if(p[i]>p[i+1] || c[i]>c[i+1] || c[i+1]-c[i]>p[i+1]-p[i]){
        return false ;
      }
    }
    for(int i=0 ; i<p.length ; i++){
      if(c[i]>p[i]){
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      int n=scanner.nextInt();
      int[] p=new int[n];
      int[] c=new int[n];
      for(int i=0 ; i<n ; i++){
        p[i]=scanner.nextInt();
        c[i]=scanner.nextInt();
      }
      if(isValid(p,c)){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1334 {
  static   operation isValid( p : Sequence(int), c : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < p->size() - 1 do ( (     if (p[i+1] > p[i + 1+1] or c[i+1] > c[i + 1+1] or c[i + 1+1] - c[i+1] > p[i + 1+1] - p[i+1]) then (     return false ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < p->size() do ( (     if (c[i+1] > p[i+1]) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := scanner.getCurrent()->toInteger() ; 
     c[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (isValid(p, c)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1334 {
  public static boolean isValid(int[] p,int[] c){
    for(int i=0 ; i<p.length-1 ; i++){
      if(p[i]>p[i+1] || c[i]>c[i+1] || c[i+1]-c[i]>p[i+1]-p[i]){
        return false ;
      }
    }
    for(int i=0 ; i<p.length ; i++){
      if(c[i]>p[i]){
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      int n=scanner.nextInt();
      int[] p=new int[n];
      int[] c=new int[n];
      for(int i=0 ; i<n ; i++){
        p[i]=scanner.nextInt();
        c[i]=scanner.nextInt();
      }
      if(isValid(p,c)){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1334 {
  static   operation isValid( p : Sequence(int), c : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < p->size() - 1 do ( (     if (p[i+1] > p[i + 1+1] or c[i+1] > c[i + 1+1] or c[i + 1+1] - c[i+1] > p[i + 1+1] - p[i+1]) then (     return false ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < p->size() do ( (     if (c[i+1] > p[i+1]) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := scanner.getCurrent()->toInteger() ; 
     c[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (isValid(p, c)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
import java.io.*;
public class codeHundredSixty {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=input.nextInt();
      int a=0 ;
      int b=0 ;
      int flag=0 ;
      for(int i=0 ; i<n ; i++){
        int x=input.nextInt();
        int y=input.nextInt();
        if(a>x || b>y || x-a<y-b){
          flag=1 ;
        }
        a=x ;
        b=y ;
      }
      if(flag==1){
        System.out.println("No");
      }
      else {
        System.out.println("Yes");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var a : int ; a := 0 ;
    var b : int ; b := 0 ;
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := input.getCurrent()->toInteger() ;
     var y : int ; y := input.getCurrent()->toInteger() ;
    if (a > x or b > y or x - a < y - b) then (     flag := 1 ) else skip ; 
    a := x ; 
    b := y ; 
 )  ;     i := i + 1 ) ; 
    if (flag = 1) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) ;  
 )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
public class er {
  static int count[]=new int[30];
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    HashMap<Character,Integer>m=new HashMap<>();
    int np=Integer.parseInt(br.readLine());
    String s=br.readLine();
    char ch[]=s.toCharArray();
    for(int i=0 ; i<s.length(); i++){
      m.put(ch[i],++count[ch[i]-97]);
    }
    Object O[]=m.keySet().toArray();
    for(int i=0 ; i<m.size(); i++){
      if(m.get(O[i])>=2 || m.size()==1){
        System.out.println("YES");
        return ;
      }
      if(i==m.size()-1 && m.get(O[i])<2)System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class er {
  static   attribute count : int := Integer.subrange(1,30)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var m : Map(String,int) ; m := Map{} ;
    var np : int ; np := (br.readLine())->toInteger() ;
    var s : String ; s := br.readLine() ;
    var ch : Sequence(String) ; ch := s->characters() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     m := m->union(Map{ch[i+1] |-> (count[ch[i+1] - 97+1] + 1)}) )  ;     i := i + 1 ) ; 
    var O : Sequence(OclAny) ; O := m->keys()->asSequence() ;
        var i : int ; i := 0 ; while i < m.size() do ( (     if (m->at(O[i+1]) >= 2 or m.size() = 1) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
     if (i = m.size() - 1 & m->at(O[i+1]) < 2) then     OclFile["System.out"].println("NO") ; else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    String str=input.next();
    Character arr[]=new Character[n];
    for(int i=0 ; i<n ; i++)arr[i]=str.charAt(i);
    Arrays.sort(arr);
    if(str.length()==1){
      System.out.println("Yes");
      System.exit(0);
    }
    int same=0 ;
    for(int i=1 ; i<n ; i++){
      if(arr[i]==arr[i-1]){
        same++;
      }
    }
    if(same>=1)System.out.println("Yes");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var str : String ; str := input.getCurrent() ;
    var arr : Sequence(String) ; arr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := str->at(i+1) ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    if (str->size() = 1) then (     OclFile["System.out"].println("Yes") ; 
 OclProcess.exit(0) ) else skip ; 
    var same : int ; same := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] = arr[(i)->char2byte() - 1+1]) then (     same := same + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (same >= 1) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Dragons {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter p=new PrintWriter(System.out);
    int n=in.nextInt();
    String s=in.next();
    int[] arr=new int[200];
    if(n==1){
      p.println("YES");
      p.flush();
      System.exit(0);
    }
    for(int i=0 ; i<n ; i++){
      arr[s.charAt(i)]++;
      if(arr[s.charAt(i)]==2){
        p.println("YES");
        p.flush();
        System.exit(0);
      }
    }
    p.println("NO");
    p.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Dragons {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : OclFile ; p := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,200)->collect(0) ;
    if (n = 1) then (     skip ; 
     skip ; 
 OclProcess.exit(0) ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[s->at(i+1)+1] := arr[s->at(i+1)+1] + 1 ; 
     if (arr[s->at(i+1)+1] = 2) then (     skip ; 
     skip ; 
 OclProcess.exit(0) ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=in.nextInt();
    if(n==1){
      if(a[0]==15)pw.println("DOWN");
      else if(a[0]==0)pw.println("UP");
      else pw.println(-1);
      pw.close();
      return ;
    }
    if(a[n-1]==15)pw.println("DOWN");
    else if(a[n-1]==0)pw.println("UP");
    else if(a[n-2]>a[n-1])pw.println("DOWN");
    else pw.println("UP");
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    if (n = 1) then (     if (a[0+1] = 15) then     skip else     if (a[0+1] = 0) then     skip else     skip ; ;  ;  
     skip ; 
     return ) else skip ; 
    if (a[n - 1+1] = 15) then     skip else     if (a[n - 1+1] = 0) then     skip else     if (a[n - 2+1] > a[n - 1+1]) then     skip else     skip ; ;  ;  ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long doublefactorial(long n){
    if(n==0 || n==1)return 1 ;
    return n*doublefactorial(n-2);
  }
  static public void main(String[] args){
    System.out.println("Double factorial"+" is "+doublefactorial(5));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation doublefactorial( n : long) : long
  pre: true
  post: true
  activity: (     if (n = 0 or n = 1) then     return 1 else skip ; 
     return n * doublefactorial(n - 2) );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Double factorial" + " is " + doublefactorial(5)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class AA {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int p=0 ; p<t ; p++){
      String s=sc.next();
      int f=0 ;
      int g=0 ;
      int n=s.length();
      int d=0 ;
      for(int i=0 ; i<n ; i++){
        int q=s.charAt(i)-'0' ;
        d+=q ;
        if(q==0){
          if(f!=1)f=1 ;
          else g=1 ;
        }
        else if(q % 2==0){
          g=1 ;
        }
      }
      if(f==1 && g==1 && d % 3==0)System.out.println("red");
      else System.out.println("cyan");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var p : int ; p := 0 ; while p < t do ( (     var s : String ; s := sc.getCurrent() ;
     var f : int ; f := 0 ;
    var g : int ; g := 0 ;
    var n : int ; n := s->size() ;
    var d : int ; d := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var q : int ; q := s->at(i+1) - ('0')->char2byte() ;
     d := d+(q) ; 
     if (q = 0) then (     if (f /= 1) then     f := 1 ; else     g := 1 ; ) else     if (q mod 2 = 0) then (     g := 1 ) else skip ; )  ;     i := i + 1 ) ; 
    if (f = 1 & g = 1 & d mod 3 = 0) then     OclFile["System.out"].println("red") else     OclFile["System.out"].println("cyan") ; ;  
 )  ;     p := p + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    long[] value=new long[n];
    for(int i=0 ; i<n ; i++){
      value[i]=Long.parseLong(sc.next());
    }
    boolean minuscount=false ;
    long max=0 ;
    for(int i=0 ; i<n ; i++){
      if(value[i]<0)minuscount=! minuscount ;
    }
    for(int i=0 ; i<n ; i++){
      max+=Math.abs(value[i]);
    }
    if(minuscount){
      long min=Math.abs(value[0]);
      for(int i=0 ; i<n ; i++){
        if(min>Math.abs(value[i])){
          min=Math.abs(value[i]);
        }
      }
      max-=min*2L ;
    }
    System.out.println(max);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var value : Sequence(long) ; value := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     value[i+1] := (sc.getCurrent())->toLong() )  ;     i := i + 1 ) ; 
    var minuscount : boolean ; minuscount := false ;
    var max : long ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (value[i+1] < 0) then     minuscount := not(minuscount) ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     max := max+(if value[i+1] < 0 then -(value[i+1]) else value[i+1] endif) )  ;     i := i + 1 ) ; 
    if (minuscount) then (     var min : long ; min := if value[0+1] < 0 then -(value[0+1]) else value[0+1] endif ;
         var i : int ; i := 0 ; while i < n do ( (     if (min > if value[i+1] < 0 then -(value[i+1]) else value[i+1] endif) then (     min := if value[i+1] < 0 then -(value[i+1]) else value[i+1] endif ) else skip )  ;     i := i + 1 ) ; 
     max := max-(min * 2L) ) else skip ; 
    OclFile["System.out"].println(max) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=scan.nextInt();
    long[] a=new long[N];
    for(int i=0 ; i<N ; i++){
      a[i]=scan.nextLong();
    }
    long[][] dp=new long[N][2];
    dp[0][0]=a[0];
    dp[0][1]=-a[0];
    for(int i=1 ; i<N-1 ; i++){
      dp[i][0]=Math.max(dp[i-1][0]+a[i],dp[i-1][1]-a[i]);
      dp[i][1]=Math.max(dp[i-1][0]-a[i],dp[i-1][1]+a[i]);
    }
    long answer=dp[N-2][0]+a[N-1];
    answer=Math.max(answer,dp[N-2][1]-a[N-1]);
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := scan.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,N)->collect(Integer.subrange(1,2)->collect(0)) ;
    dp[0+1][0+1] := a[0+1] ; 
    dp[0+1][1+1] := -a[0+1] ; 
        var i : int ; i := 1 ; while i < N - 1 do ( (     dp[i+1][0+1] := Set{dp[i - 1+1][0+1] + a[i+1], dp[i - 1+1][1+1] - a[i+1]}->max() ; 
     dp[i+1][1+1] := Set{dp[i - 1+1][0+1] - a[i+1], dp[i - 1+1][1+1] + a[i+1]}->max() )  ;     i := i + 1 ) ; 
    var answer : long ; answer := dp[N - 2+1][0+1] + a[N - 1+1] ;
    answer := Set{answer, dp[N - 2+1][1+1] - a[N - 1+1]}->max() ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    long[] a=new long[n];
    long[] b=new long[2*n];
    int un=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=stdIn.nextInt();
      if(a[i]<0){
        un+=1 ;
        a[i]=Math.abs(a[i]);
      }
    }
    long min=a[0];
    long k=0 ;
    if(un % 2==0)k=addArray(a);
    if(un % 2==1){
      for(int i=0 ; i<a.length ; i++){
        if(min>a[i])min=a[i];
      }
      k=addArray(a);
      k=k-2*min ;
    }
    System.out.println(k);
  }
  static long addArray(long[] a){
    long count=0 ;
    for(int i=0 ; i<a.length ; i++){
      count+=a[i];
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,2 * n)->collect(0) ;
    var un : int ; un := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := stdIn.getCurrent()->toInteger() ; 
     if (a[i+1] < 0) then (     un := un+(1) ; 
     a[i+1] := if a[i+1] < 0 then -(a[i+1]) else a[i+1] endif ) else skip )  ;     i := i + 1 ) ; 
    var min : long ; min := a[0+1] ;
    var k : long ; k := 0 ;
    if (un mod 2 = 0) then     k := addArray(a) ; else skip ; 
    if (un mod 2 = 1) then (         var i : int ; i := 0 ; while i < a->size() do ( (     if (min > a[i+1]) then     min := a[i+1] ; else skip )  ;     i := i + 1 ) ; 
     k := addArray(a) ; 
     k := k - 2 * min ) else skip ; 
    OclFile["System.out"].println(k) ; 
 );
  static   operation addArray( a : Sequence(long)) : long
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
         var i : int ; i := 0 ; while i < a->size() do ( (     count := count+(a[i+1]) )  ;     i := i + 1 ) ; 
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] AN=new int[N];
    int[] AN2=new int[N];
    int changeCount=0 ;
    int min=2147483647 ;
    long S=0 ;
    for(int i=0 ; i<N ; i++){
      AN[i]=sc.nextInt();
      if(AN[i]<0){
        AN2[i]=-AN[i];
        changeCount++;
      }
      else {
        AN2[i]=AN[i];
      }
      min=(AN2[i]<min)? AN2[i] : min ;
    }
    if(changeCount % 2==0){
      for(int i=0 ; i<N ; i++){
        S+=AN2[i];
      }
      System.out.println(S);
    }
    else {
      for(int i=0 ; i<N ; i++){
        S+=AN2[i];
      }
      System.out.println(S-min*2);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var AN : Sequence(int) ; AN := Integer.subrange(1,N)->collect(0) ;
    var AN2 : Sequence(int) ; AN2 := Integer.subrange(1,N)->collect(0) ;
    var changeCount : int ; changeCount := 0 ;
    var min : int ; min := 2147483647 ;
    var S : long ; S := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     AN[i+1] := sc.getCurrent()->toInteger() ; 
     if (AN[i+1] < 0) then (     AN2[i+1] := -AN[i+1] ; 
     changeCount := changeCount + 1 ) else (     AN2[i+1] := AN[i+1] ) ;  
     min := if (AN2[i+1] < min) then AN2[i+1] else min endif )  ;     i := i + 1 ) ; 
    if (changeCount mod 2 = 0) then (         var i : int ; i := 0 ; while i < N do ( (     S := S+(AN2[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(S) ) else (         var i : int ; i := 0 ; while i < N do ( (     S := S+(AN2[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(S - min * 2) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int N=sc.nextInt();
      PriorityQueue<Integer>q=new PriorityQueue<>();
      int minus_cnt=0 ;
      for(int i=0 ; i<N ; i++){
        int a=sc.nextInt();
        if(a<0){
          minus_cnt++;
          a=(-1)*a ;
        }
        q.add(a);
      }
      long sum=0 ;
      if(minus_cnt % 2!=0){
        sum-=q.poll();
      }
      while(! q.isEmpty()){
        sum+=q.poll();
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var q : Sequence(int) ; q := Sequence{} ;
    var minus_cnt : int ; minus_cnt := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (a < 0) then (     minus_cnt := minus_cnt + 1 ; 
     a := (-1) * a ) else skip ; 
     q := q->including(a) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    if (minus_cnt mod 2 /= 0) then (     sum := sum - (q->min()) ;     q := q->sort()->tail() ) else skip ; 
    while (not(q->isEmpty())) do (     sum := sum + q->min() ;     q := q->sort()->tail() ) ; 
    OclFile["System.out"].println(sum) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class Getpairs {
  public static void findPair(int[] arr,int n){
    HashSet<Integer>s=new HashSet<Integer>();
    for(Integer i : arr){
      s.add(i);
    }
    boolean found=false ;
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        int sum=arr[i]+arr[j];
        if(s.contains(sum)){
          found=true ;
          System.out.println(arr[i]+" "+arr[j]);
        }
      }
    }
    if(found==false)System.out.println("Not Exist ");
  }
  public static void main(String args[]){
    int[] arr={
      10,4,8,13,5 };
      int n=arr.length ;
      findPair(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Getpairs {
  static   operation findPair( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
     for (i : arr) do ( (     s := s->including(i) )  ) ; 
    var found : boolean ; found := false ;
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var sum : int ; sum := arr[i+1] + arr[j+1] ;
     if (s->includes(sum)) then (     found := true ; 
     OclFile["System.out"].println(arr[i+1] + " " + arr[j+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (found = false) then     OclFile["System.out"].println("Not Exist ") ; else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,4,8,13,5} ;
     var n : int ; n := arr->size() ;
     execute findPair(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class AQES {
  static int LowerInsertionPoint(int arr[],int n,int X){
    if(X<arr[0])return 0 ;
    else if(X>arr[n-1])return n ;
    int lowerPnt=0 ;
    int i=1 ;
    while(i<n && arr[i]<X){
      lowerPnt=i ;
      i=i*2 ;
    }
    while(lowerPnt<n && arr[lowerPnt]<X)lowerPnt++;
    return lowerPnt ;
  }
  public static void main(String[] args){
    int arr[]={
      2,3,4,4,5,6,7,9 };
      int n=arr.length ;
      int X=4 ;
      System.out.println(LowerInsertionPoint(arr,n,X));
    }
  }

------------------------------------------------------------
OCL File:
---------
class AQES {
  static   operation LowerInsertionPoint( arr : Sequence(int), n : int, X : int) : int
  pre: true
  post: true
  activity: (     if (X < arr[0+1]) then     return 0 else     if (X > arr[n - 1+1]) then     return n else skip ; ;  
     var lowerPnt : int ; lowerPnt := 0 ;
    var i : int ; i := 1 ;
    while (i < n & arr[i+1] < X) do (     lowerPnt := i ; 
     i := i * 2 ) ; 
    while (lowerPnt < n & arr[lowerPnt+1] < X) do     lowerPnt := lowerPnt + 1 ; ; 
    return lowerPnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4,4,5,6,7,9} ;
     var n : int ; n := arr->size() ;
     var X : int ; X := 4 ;
     OclFile["System.out"].println(LowerInsertionPoint(arr, n, X)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int countSubseq(int arr[],int n){
    int count=0 ;
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++)if(mp.containsKey(arr[i]))mp.put(arr[i],mp.get(arr[i])+1);
    else mp.put(arr[i],1);
    for(Map.Entry<Integer,Integer>entry : mp.entrySet()){
      if(entry.getKey()==0)count+=Math.pow(2,entry.getValue())-1 ;
      else count+=Math.pow(2,entry.getValue()-1);
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      2,2,2,5,6 };
      int n=arr.length ;
      System.out.println(countSubseq(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSubseq( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var mp : Map(int,int) ; mp := Map{} ;
        var i : int ; i := 0 ; while i < n do (     if (mp->keys()->includes(arr[i+1])) then     mp := mp->union(Map{arr[i+1] |-> mp->at(arr[i+1]) + 1}) else     mp := mp->union(Map{arr[i+1] |-> 1}) ; ;   ;     i := i + 1 ) ; 
    for (entry : mp->asSet()) do ( (     if (entry.getKey() = 0) then     count := count+(2->pow(entry.getValue()) - 1) ; else     count := count+(2->pow(entry.getValue() - 1)) ; )  ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,2,2,5,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countSubseq(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minChanges(int arr[],int n){
    Map<Integer,Integer>mp=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(mp.containsKey(arr[i])){
        mp.put(arr[i],mp.get(arr[i])+1);
      }
      else {
        mp.put(arr[i],1);
      }
    }
    int maxElem=0 ;
    for(Map.Entry<Integer,Integer>entry : mp.entrySet()){
      maxElem=Math.max(maxElem,entry.getValue());
    }
    return n-maxElem ;
  }
  public static void main(String[] args){
    int arr[]={
      2,3,3,4 };
      int n=arr.length ;
      System.out.println(minChanges(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minChanges( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (mp->keys()->includes(arr[i+1])) then (     mp := mp->union(Map{arr[i+1] |-> mp->at(arr[i+1]) + 1}) ) else (     mp := mp->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var maxElem : int ; maxElem := 0 ;
    for (entry : mp->asSet()) do ( (     maxElem := Set{maxElem, entry.getValue()}->max() )  ) ; 
    return n - maxElem 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,3,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minChanges(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void countFreq(int arr[],int n){
    Map<Integer,Integer>mp=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(mp.containsKey(arr[i])){
        mp.put(arr[i],mp.get(arr[i])+1);
      }
      else {
        mp.put(arr[i],1);
      }
    }
    for(Map.Entry<Integer,Integer>entry : mp.entrySet()){
      System.out.println(entry.getKey()+" "+entry.getValue());
    }
  }
  public static void main(String args[]){
    int arr[]={
      10,20,20,10,10,20,5,20 };
      int n=arr.length ;
      countFreq(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countFreq( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (mp->keys()->includes(arr[i+1])) then (     mp := mp->union(Map{arr[i+1] |-> mp->at(arr[i+1]) + 1}) ) else (     mp := mp->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
     for (entry : mp->asSet()) do ( (     OclFile["System.out"].println(entry.getKey() + " " + entry.getValue()) )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,20,20,10,10,20,5,20} ;
     var n : int ; n := arr->size() ;
     execute countFreq(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int dp[][]=new int[901][8101];
  static int minimumNumberOfDigits(int a,int b){
    if(a>b || a<0 || b<0 || a>900 || b>8100){
      return-1 ;
    }
    if(a==0 && b==0){
      return 0 ;
    }
    if(dp[a][b]!=-1){
      return dp[a][b];
    }
    int ans=101 ;
    for(int i=9 ; i>=1 ; i--){
      int k=minimumNumberOfDigits(a-i,b-(i*i));
      if(k!=-1){
        ans=Math.min(ans,k+1);
      }
    }
    return dp[a][b]=ans ;
  }
  static void printSmallestNumber(int a,int b){
    for(int[] row : dp){
      Arrays.fill(row,-1);
    }
    dp[0][0]=0 ;
    int k=minimumNumberOfDigits(a,b);
    if(k==-1 || k>100){
      System.out.println("-1");
    }
    else {
      while(a>0 && b>0){
        for(int i=1 ; i<=9 ; i++){
          if(a>=i && b>=i*i && 1+dp[a-i][b-i*i]==dp[a][b]){
            System.out.print(i);
            a-=i ;
            b-=i*i ;
            break ;
          }
        }
      }
    }
  }
  public static void main(String args[]){
    int a=18,b=162 ;
    printSmallestNumber(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute dp : int := Integer.subrange(1,901)->collect(Integer.subrange(1,8101)->collect(0));
  static   operation minimumNumberOfDigits( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a > b or a < 0 or b < 0 or a > 900 or b > 8100) then (     return -1 ) else skip ; 
     if (a = 0 & b = 0) then (     return 0 ) else skip ; 
    if (dp[a+1][b+1] /= -1) then (     return dp[a+1][b+1] ) else skip ; 
    var ans : int ; ans := 101 ;
        var i : int ; i := 9 ; while i >= 1 do ( (     var k : int ; k := minimumNumberOfDigits(a - i, b - (i * i)) ;
     if (k /= -1) then (     ans := Set{ans, k + 1}->min() ) else skip )  ;     i := i - 1 ) ; 
    return dp[a+1][b+1] 
 );
  static   operation printSmallestNumber( a : int, b : int) : void
  pre: true
  post: true
  activity: (     for (row : dp) do ( (     row := row->collect(-1) )  ) ; 
     dp[0+1][0+1] := 0 ; 
     var k : int ; k := minimumNumberOfDigits(a, b) ;
     if (k = -1 or k > 100) then (     OclFile["System.out"].println("-1") ) else (     while (a > 0 & b > 0) do (         var i : int ; i := 1 ; while i <= 9 do ( (     if (a >= i & b >= i * i & 1 + dp[a - i+1][b - i * i+1] = dp[a+1][b+1]) then (     OclFile["System.out"].print(i) ; 
     a := a-(i) ; 
     b := b-(i * i) ; 
     break ) else skip )  ;     i := i + 1 ) ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 18 ;
    var b : int ; b := 162 ;
     execute printSmallestNumber(a, b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    if(n==1){
      if(a[0]==15){
        pw.print("DOWN");
      }
      else if(a[0]==0){
        pw.print("UP");
      }
      else {
        pw.print(-1);
      }
    }
    else {
      int sub=a[n-1]-a[n-2];
      if(sub==1 && a[n-1]!=15){
        pw.print("UP");
      }
      else {
        if(a[n-1]==0){
          pw.print("UP");
        }
        else {
          pw.print("DOWN");
        }
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (n = 1) then (     if (a[0+1] = 15) then (     skip ) else     if (a[0+1] = 0) then (     skip ) else (     skip ) ;  ) else (     var sub : int ; sub := a[n - 1+1] - a[n - 2+1] ;
     if (sub = 1 & a[n - 1+1] /= 15) then (     skip ) else (     if (a[n - 1+1] = 0) then (     skip ) else (     skip ) ) ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int xorOdd(int arr[],int n){
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      if(mp.containsKey(arr[i])){
        mp.put(arr[i],mp.get(arr[i])+1);
      }
      else {
        mp.put(arr[i],1);
      }
    }
    int xorArr=0 ;
    for(Map.Entry<Integer,Integer>it : mp.entrySet()){
      if(((it.getValue())% 2)==1){
        xorArr ^=it.getKey();
      }
    }
    return xorArr ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,1,3,3,4,2,3,1 };
      int n=arr.length ;
      System.out.println(xorOdd(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation xorOdd( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (mp->keys()->includes(arr[i+1])) then (     mp := mp->union(Map{arr[i+1] |-> mp->at(arr[i+1]) + 1}) ) else (     mp := mp->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var xorArr : int ; xorArr := 0 ;
    for (it : mp->asSet()) do ( (     if (((it.getValue()) mod 2) = 1) then (     xorArr := MathLib.bitwiseXor(xorArr,it.getKey()) ) else skip )  ) ; 
    return xorArr 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,1,3,3,4,2,3,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(xorOdd(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static Scanner scan=new Scanner(System.in);
  public static void main(String[] args){
    int n=Integer.parseInt(scan.next());
    int[] a=new int[n];
    int[] e ;
    int[] o ;
    if(n % 2==0){
      e=new int[n/2];
      o=new int[n/2];
    }
    else {
      e=new int[n/2+1];
      o=new int[n/2];
    }
    for(int i=0 ; i<n ; i++){
      if(i % 2==0)e[i/2]=Integer.parseInt(scan.next());
      else o[i/2]=Integer.parseInt(scan.next());
    }
    if(n % 2==0){
      int length=n/2 ;
      for(int i=0 ; i<length ; i++)a[i]=o[length-1-i];
      for(int i=0 ; i<length ; i++)a[i+length]=e[i];
    }
    else {
      int length=n/2+1 ;
      for(int i=0 ; i<length ; i++)a[i]=e[length-1-i];
      for(int i=0 ; i<length-1 ; i++)a[i+length]=o[i];
    }
    for(int i=0 ; i<n ; i++){
      if(i==0)System.out.print(a[i]);
      else System.out.print(" "+a[i]);
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (scan.getCurrent())->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var e : Sequence(int) ;
    var o : Sequence(int) ;
    if (n mod 2 = 0) then (     e := Integer.subrange(1,n / 2)->collect(0) ; 
     o := Integer.subrange(1,n / 2)->collect(0) ) else (     e := Integer.subrange(1,n / 2 + 1)->collect(0) ; 
     o := Integer.subrange(1,n / 2)->collect(0) ) ;  
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then     e[i / 2+1] := (scan.getCurrent())->toInteger() ; else     o[i / 2+1] := (scan.getCurrent())->toInteger() ; )  ;     i := i + 1 ) ; 
    if (n mod 2 = 0) then (     var length : int ; length := n / 2 ;
         var i : int ; i := 0 ; while i < length do (     a[i+1] := o[length - 1 - i+1] ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < length do (     a[i + length+1] := e[i+1] ;  ;     i := i + 1 ) ) else (     var length : int ; length := n / 2 + 1 ;
         var i : int ; i := 0 ; while i < length do (     a[i+1] := e[length - 1 - i+1] ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < length - 1 do (     a[i + length+1] := o[i+1] ;  ;     i := i + 1 ) ) ;  
        var i : int ; i := 0 ; while i < n do ( (     if (i = 0) then     OclFile["System.out"].print(a[i+1]) ; else     OclFile["System.out"].print(" " + a[i+1]) ; )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Iterator ;
import java.util.Scanner ;
import java.util.ArrayDeque ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskC solver=new TaskC();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskC {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      ArrayDeque<Integer>q=new ArrayDeque<>();
      boolean f=false ;
      for(int i=0 ; i<n ; ++i){
        if(f)q.addFirst(in.nextInt());
        else q.addLast(in.nextInt());
        f=! f ;
      }
      Iterator<Integer>it ;
      if(n % 2==0)it=q.iterator();
      else it=q.descendingIterator();
      while(it.hasNext()){
        out.print(it.next()+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskC ; solver := TaskC.newTaskC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskC {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var q : Sequence(int) ; q := ArrayDeque<OclAny>.newArrayDeque() ;
    var f : boolean ; f := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (f) then     q := q->prepend(in.getCurrent()->toInteger()) else     q := q->append(in.getCurrent()->toInteger()) ; ;  
     f := not(f) )  ;     i := i + 1 ) ; 
    var it : OclIterator ;
    if (n mod 2 = 0) then     it := q->iterator() else     it := q.descendingIterator() ; ;  
    while (it.hasNext()) do (     skip ) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    ArrayList<Integer>input=new ArrayList<Integer>();
    Scanner scanner=new Scanner(System.in);
    Integer n=Integer.valueOf(scanner.nextLine());
    String line=scanner.nextLine();
    Arrays.asList(line.split(" ")).forEach(it->input.add(Integer.valueOf(it)));
    List<Integer>evenList=IntStream.rangeClosed(0,input.size()-1).filter(i->i % 2==0).map(i->input.get(i)).boxed().collect(Collectors.toList());
    List<Integer>oddList=IntStream.rangeClosed(0,input.size()-1).filter(i->i % 2==1).map(i->Integer.valueOf(input.get(i))).boxed().collect(Collectors.toList());
    ArrayList<Integer>result=new ArrayList<Integer>();
    if(n % 2==0){
      Collections.reverse(oddList);
      result.addAll(oddList);
      result.addAll(evenList);
    }
    else {
      Collections.reverse(evenList);
      result.addAll(evenList);
      result.addAll(oddList);
    }
    result.forEach(it->System.out.print(it.toString()+" "));
    System.out.println("");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : Sequence(int) ; input := Sequence{} ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := (scanner.nextLine())->toInteger() ;
    var line : String ; line := scanner.nextLine() ;
    for it : line->split(" ") do
    (    input := input->including((it)->toInteger())) ; 
    var evenList : Sequence(int) ; evenList := Integer.subrange(0, input->size() - 1)->select( _x1 | (lambda i : OclAny in i mod 2 = 0)->apply(_x1) )->collect( _x1 | (lambda i : OclAny in input->at(i+1))->apply(_x1) ).collect(Collectors.toList()) ;
    var oddList : Sequence(int) ; oddList := Integer.subrange(0, input->size() - 1)->select( _x1 | (lambda i : OclAny in i mod 2 = 1)->apply(_x1) )->collect( _x1 | (lambda i : OclAny in (input->at(i+1))->toInteger())->apply(_x1) ).collect(Collectors.toList()) ;
    var result : Sequence(int) ; result := Sequence{} ;
    if (n mod 2 = 0) then (     oddList := oddList->reverse() ; 
     result := result->union(oddList) ; 
     result := result->union(evenList) ) else (     evenList := evenList->reverse() ; 
     result := result->union(evenList) ; 
     result := result->union(oddList) ) ;  
    for it : result do
    (    OclFile["System.out"].print(it+"" + " ")) ; 
    OclFile["System.out"].println("") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  @ SuppressWarnings("resource")public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int a[]=new int[n];
    if(n % 2==0){
      int k=n/2 ;
      int g=n/2-1 ;
      for(int i=1 ; i<=n ; i++){
        if(i % 2==1){
          a[k]=scanner.nextInt();
          k++;
        }
        else {
          a[g]=scanner.nextInt();
          g--;
        }
      }
    }
    else {
      int k=n/2 ;
      int g=n/2+1 ;
      for(int i=1 ; i<=n ; i++){
        if(i % 2==1){
          a[k]=scanner.nextInt();
          k--;
        }
        else {
          a[g]=scanner.nextInt();
          g++;
        }
      }
    }
    for(int tar : a){
      System.out.println(tar);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    if (n mod 2 = 0) then (     var k : int ; k := n / 2 ;
     var g : int ; g := n / 2 - 1 ;
         var i : int ; i := 1 ; while i <= n do ( (     if (i mod 2 = 1) then (     a[k+1] := scanner.getCurrent()->toInteger() ; 
     k := k + 1 ) else (     a[g+1] := scanner.getCurrent()->toInteger() ; 
     g := g - 1 ) )  ;     i := i + 1 ) ) else (     var k : int ; k := n / 2 ;
     var g : int ; g := n / 2 + 1 ;
         var i : int ; i := 1 ; while i <= n do ( (     if (i mod 2 = 1) then (     a[k+1] := scanner.getCurrent()->toInteger() ; 
     k := k - 1 ) else (     a[g+1] := scanner.getCurrent()->toInteger() ; 
     g := g + 1 ) )  ;     i := i + 1 ) ) ;  
    for (tar : a) do ( (     OclFile["System.out"].println(tar) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Deque ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().execute();
  }
  public void execute(){
    Scanner sc=new Scanner(System.in);
    final int N=sc.nextInt();
    LinkedList<Integer>b=new LinkedList<>();
    boolean head=true ;
    for(int i=0 ; i<N ; i++){
      int ai=sc.nextInt();
      if(head){
        b.add(ai);
      }
      else {
        b.addFirst(ai);
      }
      head=! head ;
    }
    Integer[] arr=b.toArray(new Integer[b.size()]);
    if(head){
      for(int i=0 ; i<N-1 ; i++){
        System.out.print(arr[i]+" ");
      }
      System.out.println(arr[N-1]);
    }
    else {
      for(int i=N-1 ; i>0 ; i--){
        System.out.print(arr[i]+" ");
      }
      System.out.println(arr[0]);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().execute() );
   operation execute() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Sequence{} ;
    var head : boolean ; head := true ;
        var i : int ; i := 0 ; while i < N do ( (     var ai : int ; ai := sc.getCurrent()->toInteger() ;
     if (head) then (     b := b->including(ai) ) else (     b := b->prepend(ai) ) ;  
     head := not(head) )  ;     i := i + 1 ) ; 
    var arr : Sequence(int) ; arr := b->asSequence() ;
    if (head) then (         var i : int ; i := 0 ; while i < N - 1 do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(arr[N - 1+1]) ) else (         var i : int ; i := N - 1 ; while i > 0 do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println(arr[0+1]) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPalindrome(int freq[],int k){
    int flag=0 ;
    int length=0 ;
    for(int i=0 ; i<26 ; i++){
      if(freq[i]==0)continue ;
      else if(freq[i]==1)flag=1 ;
      else {
        if(freq[i] % 2==1)flag=1 ;
        length+=freq[i]/2 ;
      }
    }
    if(k % 2==1){
      if(2*length+flag>=k)return true ;
    }
    else {
      if(2*length>=k)return true ;
    }
    return false ;
  }
  static boolean check(String str,int m,int k){
    int[] freq=new int[26];
    for(int i=0 ; i<m ; i++)freq[str.charAt(i)-'a']++;
    if(isPalindrome(freq,k))return true ;
    for(int i=m ; i<str.length(); i++){
      freq[str.charAt(i-m)-'a']--;
      freq[str.charAt(i)-'a']++;
      if(isPalindrome(freq,k))return true ;
    }
    return false ;
  }
  static int find(String str,int n,int k){
    int l=k ;
    int h=n ;
    int ans=-1 ;
    while(l<=h){
      int m=(l+h)/2 ;
      if(check(str,m,k)){
        ans=m ;
        h=m-1 ;
      }
      else l=m+1 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    String str="abcda" ;
    int n=str.length();
    int k=2 ;
    System.out.println(find(str,n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPalindrome( freq : Sequence(int), k : int) : boolean
  pre: true
  post: true
  activity: (     var flag : int ; flag := 0 ;
     var length : int ; length := 0 ;
        var i : int ; i := 0 ; while i < 26 do ( (     if (freq[i+1] = 0) then     continue else     if (freq[i+1] = 1) then     flag := 1 else (     if (freq[i+1] mod 2 = 1) then     flag := 1 ; else skip ; 
     length := length+(freq[i+1] / 2) ) ;  )  ;     i := i + 1 ) ; 
    if (k mod 2 = 1) then (     if (2 * length + flag >= k) then     return true else skip ) else (     if (2 * length >= k) then     return true else skip ) ;  
    return false 
 );
  static   operation check( str : String, m : int, k : int) : boolean
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
         var i : int ; i := 0 ; while i < m do (     freq[str->at(i+1) - ('a')->char2byte()+1] := freq[str->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    if (isPalindrome(freq, k)) then     return true else skip ; 
        var i : int ; i := m ; while i < str->size() do ( (     freq[str->at(i - m+1) - ('a')->char2byte()+1] := freq[str->at(i - m+1) - ('a')->char2byte()+1] - 1 ; 
     freq[str->at(i+1) - ('a')->char2byte()+1] := freq[str->at(i+1) - ('a')->char2byte()+1] + 1 ; 
     if (isPalindrome(freq, k)) then     return true else skip )  ;     i := i + 1 ) ; 
    return false 
 );
  static   operation find( str : String, n : int, k : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := k ;
     var h : int ; h := n ;
    var ans : int ; ans := -1 ;
    while (l <= h) do (     var m : int ; m := (l + h) / 2 ;
     if (check(str, m, k)) then (     ans := m ; 
     h := m - 1 ) else     l := m + 1 ; ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abcda" ;
     var n : int ; n := str->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(find(str, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findPairs(int arr[],int n,int x){
    int l=0,r=n-1 ;
    int result=0 ;
    while(l<r){
      if(arr[l]+arr[r]<x){
        result+=(r-l);
        l++;
      }
      else r--;
    }
    return result ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,6,7,8 };
      int n=arr.length ;
      int x=7 ;
      System.out.print(findPairs(arr,n,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findPairs( arr : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
    var r : int ; r := n - 1 ;
     var result : int ; result := 0 ;
     while (l < r) do (     if (arr[l+1] + arr[r+1] < x) then (     result := result+((r - l)) ; 
     l := l + 1 ) else     r := r - 1 ; ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6,7,8} ;
     var n : int ; n := arr->size() ;
     var x : int ; x := 7 ;
     OclFile["System.out"].print(findPairs(arr, n, x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minFlipsSub(String mat[],int i,int j){
    int cnt0=0,cnt1=0 ;
    if(mat[i] .charAt(j)=='1')cnt1++;
    else cnt0++;
    if(mat[i] .charAt(j+1)=='1')cnt1++;
    else cnt0++;
    if(mat[i+1] .charAt(j)=='1')cnt1++;
    else cnt0++;
    if(mat[i+1] .charAt(j+1)=='1')cnt1++;
    else cnt0++;
    return Math.min(cnt0,cnt1);
  }
  static int minFlips(String mat[],int r,int c){
    int res=Integer.MAX_VALUE ;
    for(int i=0 ; i<r-1 ; i++){
      for(int j=0 ; j<c-1 ; j++){
        res=Math.min(res,minFlipsSub(mat,i,j));
      }
    }
    return res ;
  }
  public static void main(String[] args){
    String mat[]={
      "0101","0101","0101" };
      int r=mat.length ;
      int c=mat[0] .length();
      System.out.print(minFlips(mat,r,c));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minFlipsSub( mat : Sequence(String), i : int, j : int) : int
  pre: true
  post: true
  activity: (     var cnt0 : int ; cnt0 := 0 ;
    var cnt1 : int ; cnt1 := 0 ;
     if (mat[i+1]->at(j+1) = '1') then     cnt1 := cnt1 + 1 else     cnt0 := cnt0 + 1 ; ;  
    if (mat[i+1]->at(j + 1+1) = '1') then     cnt1 := cnt1 + 1 else     cnt0 := cnt0 + 1 ; ;  
    if (mat[i + 1+1]->at(j+1) = '1') then     cnt1 := cnt1 + 1 else     cnt0 := cnt0 + 1 ; ;  
    if (mat[i + 1+1]->at(j + 1+1) = '1') then     cnt1 := cnt1 + 1 else     cnt0 := cnt0 + 1 ; ;  
    return Set{cnt0, cnt1}->min() 
 );
  static   operation minFlips( mat : Sequence(String), r : int, c : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 2147483647 ;
         var i : int ; i := 0 ; while i < r - 1 do ( (         var j : int ; j := 0 ; while j < c - 1 do ( (     res := Set{res, minFlipsSub(mat, i, j)}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(String) ; mat := Sequence{"0101","0101","0101"} ;
     var r : int ; r := mat->size() ;
     var c : int ; c := mat[0+1]->size() ;
     OclFile["System.out"].print(minFlips(mat, r, c)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int N=5005 ;
  static int n,k ;
  static Vector<Integer>[] gr=new Vector[N];
  static int[][] d=new int[N][505];
  static int ans=0 ;
  static void Add_edge(int x,int y){
    gr[x] .add(y);
    gr[y] .add(x);
  }
  static void dfs(int v,int par){
    d[v][0]=1 ;
    for(Integer i : gr[v]){
      if(i!=par){
        dfs(i,v);
        for(int j=1 ; j<=k ; j++)ans+=d[i][j-1]*d[v][k-j];
        for(int j=1 ; j<=k ; j++)d[v][j]+=d[i][j-1];
      }
    }
  }
  public static void main(String[] args){
    n=5 ;
    k=2 ;
    for(int i=0 ; i<N ; i++)gr[i]=new Vector<Integer>();
    Add_edge(1,2);
    Add_edge(2,3);
    Add_edge(3,4);
    Add_edge(2,5);
    dfs(1,0);
    System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute N : int := 5005;
  static   attribute n : int;
  static   attribute gr : Sequence(Sequence(int)) := Integer.subrange(1,N)->collect(null);
  static   attribute d : Sequence(Sequence(int)) := Integer.subrange(1,N)->collect(Integer.subrange(1,505)->collect(0));
  static   attribute ans : int := 0;
  static   operation Add_edge( x : int, y : int) : void
  pre: true
  post: true
  activity: (     gr[x+1]->excludes(y) ; 
     gr[y+1]->excludes(x) );
  static   operation dfs( v : int, par : int) : void
  pre: true
  post: true
  activity: (     d[v+1][0+1] := 1 ; 
     for (i : gr[v+1]) do ( (     if (i /= par) then (     execute dfs(i, v) ; 
         var j : int ; j := 1 ; while j <= k do (     ans := ans+(d[i+1][j - 1+1] * d[v+1][k - j+1]) ;  ;     j := j + 1 ) ; 
         var j : int ; j := 1 ; while j <= k do (     d[v+1][j+1] := d[v+1][j+1]+(d[i+1][j - 1+1]) ;  ;     j := j + 1 ) ) else skip )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := 5 ; 
     k := 2 ; 
        var i : int ; i := 0 ; while i < N do (     gr[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
    execute Add_edge(1, 2) ; 
    execute Add_edge(2, 3) ; 
    execute Add_edge(3, 4) ; 
    execute Add_edge(2, 5) ; 
    execute dfs(1, 0) ; 
    OclFile["System.out"].print(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countDigits(int n){
    int count=0 ;
    while(n>0){
      count+=1 ;
      n/=10 ;
    }
    return count ;
  }
  static int getDistinct(int d,int count){
    int num=0 ;
    count=(int)Math.pow(10,count-1);
    while(count>0){
      num+=(count*d);
      count/=10 ;
    }
    return num ;
  }
  static int findCount(int L,int R){
    int count=0 ;
    int countDigitsL=countDigits(L);
    int countDigitsR=countDigits(R);
    int firstDigitL=(L/(int)Math.pow(10,countDigitsL-1));
    int firstDigitR=(R/(int)Math.pow(10,countDigitsR-1));
    if(countDigitsL<countDigitsR){
      count+=(9*(countDigitsR-countDigitsL-1));
      if(getDistinct(firstDigitL,countDigitsL)>=L)count+=(9-firstDigitL+1);
      else count+=(9-firstDigitL);
      if(getDistinct(firstDigitR,countDigitsR)<=R)count+=firstDigitR ;
      else count+=(firstDigitR-1);
    }
    else {
      if(getDistinct(firstDigitL,countDigitsL)>=L)count+=(9-firstDigitL+1);
      else count+=(9-firstDigitL);
      if(getDistinct(firstDigitR,countDigitsR)<=R)count-=(9-firstDigitR);
      else count-=(9-firstDigitR+1);
    }
    return count ;
  }
  public static void main(String[] args){
    int L=10,R=50 ;
    System.out.println(findCount(L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDigits( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     count := count+(1) ; 
     n := n/(10) ) ; 
     return count );
  static   operation getDistinct( d : int, count : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := 0 ;
     count := 10->pow(count - 1)->oclAsType(int) ; 
     while (count > 0) do (     num := num+((count * d)) ; 
     count := count/(10) ) ; 
     return num );
  static   operation findCount( L : int, R : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var countDigitsL : int ; countDigitsL := countDigits(L) ;
    var countDigitsR : int ; countDigitsR := countDigits(R) ;
    var firstDigitL : int ; firstDigitL := (L / 10->pow(countDigitsL - 1)->oclAsType(int)) ;
    var firstDigitR : int ; firstDigitR := (R / 10->pow(countDigitsR - 1)->oclAsType(int)) ;
    if (countDigitsL < countDigitsR) then (     count := count+((9 * (countDigitsR - countDigitsL - 1))) ; 
     if (getDistinct(firstDigitL, countDigitsL) >= L) then     count := count+((9 - firstDigitL + 1)) else     count := count+((9 - firstDigitL)) ; ;  
     if (getDistinct(firstDigitR, countDigitsR) <= R) then     count := count+(firstDigitR) ; else     count := count+((firstDigitR - 1)) ; ) else (     if (getDistinct(firstDigitL, countDigitsL) >= L) then     count := count+((9 - firstDigitL + 1)) else     count := count+((9 - firstDigitL)) ; ;  
     if (getDistinct(firstDigitR, countDigitsR) <= R) then     count := count-((9 - firstDigitR)) ; else     count := count-((9 - firstDigitR + 1)) ; ) ;  
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 10 ;
    var R : int ; R := 50 ;
     OclFile["System.out"].println(findCount(L, R)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static char[][] arr=new char[30][30];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int ans=0 ;
    int n=sc.nextInt(),m=sc.nextInt();
    String temp=sc.nextLine();
    for(int i=1 ; i<=n ; i++){
      temp=sc.nextLine();
      for(int j=1 ; j<=temp.length(); j++){
        arr[i][j]=temp.charAt(j-1);
      }
    }
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=m ; j++){
        for(int k=i ; k<=n ; k++){
          for(int l=j ; l<=m ; l++){
            int I=i,J=j ;
            while(J<l && arr[I][J]=='0')J++;
            if(J!=l)break ;
            while(I<k && arr[I][J]=='0')I++;
            if(I!=k)break ;
            while(J>j && arr[I][J]=='0')J--;
            if(J!=j)break ;
            while(I>i && arr[I][J]=='0')I--;
            if(I!=i)break ;
            ans=Math.max(ans,2*(k-i+1+l-j+1));
          }
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute arr : Sequence(Sequence(String)) := Integer.subrange(1,30)->collect(Integer.subrange(1,30)->collect(0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ans : int ; ans := 0 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var temp : String ; temp := sc.nextLine() ;
        var i : int ; i := 1 ; while i <= n do ( (     temp := sc.nextLine() ; 
         var j : int ; j := 1 ; while j <= temp->size() do ( (     arr[i+1][j+1] := temp->at(j - 1+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= m do ( (         var k : int ; k := i ; while k <= n do ( (         var l : int ; l := j ; while l <= m do ( (     var I : int ; I := i ;
    var J : int ; J := j ;
     while (J < l & arr[I+1][J+1] = '0') do     J := J + 1 ; ; 
    if (J /= l) then     break else skip ; 
    while (I < k & arr[I+1][J+1] = '0') do     I := I + 1 ; ; 
    if (I /= k) then     break else skip ; 
    while (J > j & arr[I+1][J+1] = '0') do     J := J - 1 ; ; 
    if (J /= j) then     break else skip ; 
    while (I > i & arr[I+1][J+1] = '0') do     I := I - 1 ; ; 
    if (I /= i) then     break else skip ; 
    ans := Set{ans, 2 * (k - (i)->char2byte() + 1 + l - j + 1)}->max() ; 
 )  ;     l := l + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  final static int row=2,col=2 ;
  static float frobeniusNorm(int mat[][]){
    int sumSq=0 ;
    for(int i=0 ; i<row ; i++){
      for(int j=0 ; j<col ; j++){
        sumSq+=(int)Math.pow(mat[i][j],2);
      }
    }
    float res=(float)Math.sqrt(sumSq);
    return res ;
  }
  public static void main(String[] args){
    int mat[][]={
      {
        1,2 },{
          3,4 }
        };
        System.out.println(frobeniusNorm(mat));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute row : int := 2;
  static   operation frobeniusNorm( mat : Sequence(Sequence(int))) : double
  pre: true
  post: true
  activity: (     var sumSq : int ; sumSq := 0 ;
         var i : int ; i := 0 ; while i < row do ( (         var j : int ; j := 0 ; while j < col do ( (     sumSq := sumSq+(mat[i+1][j+1]->pow(2)->oclAsType(int)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     var res : double ; res := (sumSq)->sqrt()->oclAsType(double) ;
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,2},Sequence{3,4}} ;
     OclFile["System.out"].println(frobeniusNorm(mat)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void moveSpaceInFront(char str[]){
    int i=str.length-1 ;
    for(int j=i ; j>=0 ; j--)if(str[j]!=' '){
      char c=str[i];
      str[i]=str[j];
      str[j]=c ;
      i--;
    }
  }
  public static void main(String[] args){
    char str[]="Hey there,it's GeeksforGeeks".toCharArray();
    moveSpaceInFront(str);
    System.out.println(String.valueOf(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation moveSpaceInFront( str : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := str->size() - 1 ;
         var j : int ; j := i ; while j >= 0 do (     if (str[j+1] /= ' ') then (     var c : String ; c := str[i+1] ;
     str[i+1] := str[j+1] ; 
     str[j+1] := c ; 
     i := i - 1 ) else skip ;  ;     j := j - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := "Hey there,it's GeeksforGeeks"->characters() ;
     execute moveSpaceInFront(str) ; 
     OclFile["System.out"].println(((str) + "")) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void moveSpaceInFront(char str[]){
    int i=str.length-1 ;
    for(int j=i ; j>=0 ; j--)if(str[j]!=' ')str[i--]=str[j];
    while(i>=0)str[i--]=' ' ;
  }
  public static void main(String[] args){
    char str[]="Hey there,it's GeeksforGeeks".toCharArray();
    moveSpaceInFront(str);
    System.out.println(String.valueOf(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation moveSpaceInFront( str : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := str->size() - 1 ;
         var j : int ; j := i ; while j >= 0 do (     if (str[j+1] /= ' ') then      str[i+1] := str[j+1]  ; i := i - 1 ; else skip ;  ;     j := j - 1 ) ; 
     while (i >= 0) do      str[i+1] := ' '  ; i := i - 1 ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := "Hey there,it's GeeksforGeeks"->characters() ;
     execute moveSpaceInFront(str) ; 
     OclFile["System.out"].println(((str) + "")) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Codeforces756B {
  static long dp[];
  static boolean dpSeen[];
  static int n ;
  static long inputs[];
  public static void f(int index){
    int minsIndex=0 ;
    int dayIndex=0 ;
    for(int i=1 ; i<=n ; i++){
      while(inputs[minsIndex]<=inputs[i]-90)minsIndex++;
      while(inputs[dayIndex]<=inputs[i]-1440)dayIndex++;
      long valueOne=dp[i-1]+20 ;
      long valueMins=dp[minsIndex-1]+50 ;
      long valueDay=dp[dayIndex-1]+120 ;
      dp[i]=Math.min(valueOne,Math.min(valueDay,valueMins));
    }
  }
  public static void printAnswer(){
    for(int i=1 ; i<=n ; i++){
      System.out.println(dp[i]-dp[i-1]);
    }
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    n=in.nextInt();
    dp=new long[n+1];
    dpSeen=new boolean[n+1];
    inputs=new long[n+1];
    for(int i=1 ; i<=n ; i++){
      inputs[i]=in.nextLong();
      dp[i]=0 ;
    }
    inputs[0]=-10000 ;
    f(n);
    printAnswer();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces756B {
  static   attribute dp : Sequence(long);
  static   attribute dpSeen : Sequence(boolean);
  static   attribute n : int;
  static   attribute inputs : Sequence(long);
  static   operation f( index : int) : void
  pre: true
  post: true
  activity: (     var minsIndex : int ; minsIndex := 0 ;
     var dayIndex : int ; dayIndex := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     while (inputs[minsIndex+1] <= inputs[i+1] - 90) do     minsIndex := minsIndex + 1 ; ; 
     while (inputs[dayIndex+1] <= inputs[i+1] - 1440) do     dayIndex := dayIndex + 1 ; ; 
    var valueOne : long ; valueOne := dp[i - 1+1] + 20 ;
    var valueMins : long ; valueMins := dp[minsIndex - 1+1] + 50 ;
    var valueDay : long ; valueDay := dp[dayIndex - 1+1] + 120 ;
    dp[i+1] := Set{valueOne, Set{valueDay, valueMins}->min()}->min() ; 
 )  ;     i := i + 1 ) );
  static   operation printAnswer() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].println(dp[i+1] - dp[i - 1+1]) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := in.getCurrent()->toInteger() ; 
    dp := Integer.subrange(1,n + 1)->collect(0) ; 
    dpSeen := Integer.subrange(1,n + 1)->collect(false) ; 
    inputs := Integer.subrange(1,n + 1)->collect(0) ; 
        var i : int ; i := 1 ; while i <= n do ( (     inputs[i+1] := in.getCurrent()->toLong() ; 
     dp[i+1] := 0 )  ;     i := i + 1 ) ; 
    inputs[0+1] := -10000 ; 
    execute f(n) ; 
    execute printAnswer() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.TreeMap ;
public class TravelCard {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int[] ar=new int[n];
    TreeMap<Integer,Integer>map=new TreeMap<>();
    for(int i=0 ; i<n ; i++){
      ar[i]=Integer.parseInt(br.readLine());
      map.put(ar[i],i);
    }
    int[] dp=new int[n+1];
    for(int i=0 ; i<n ; i++){
      int curPos=ar[i];
      int minute90=(curPos-90<ar[0])? n : map.higherEntry(curPos-90).getValue()-1 ;
      int oneDay=(curPos-1440<ar[0])? n : map.higherEntry(curPos-1440).getValue()-1 ;
      dp[i]=Math.min(((i==0)? 0 : dp[i-1])+20,Math.min(dp[minute90]+50,dp[oneDay]+120));
    }
    int preSum=0 ;
    for(int i=0 ; i<n ; i++){
      System.out.println(dp[i]-preSum);
      preSum=dp[i];
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TravelCard {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := (br.readLine())->toInteger() ; 
     map := map->union(Map{ar[i+1] |-> i}) )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var curPos : int ; curPos := ar[i+1] ;
     var minute90 : int ; minute90 := if (curPos - 90 < ar[0+1]) then n else map.higherEntry(curPos - 90).getValue() - 1 endif ;
     var oneDay : int ; oneDay := if (curPos - 1440 < ar[0+1]) then n else map.higherEntry(curPos - 1440).getValue() - 1 endif ;
     dp[i+1] := Set{(if (i = 0) then 0 else dp[i - 1+1] endif) + 20, Set{dp[minute90+1] + 50, dp[oneDay+1] + 120}->min()}->min() )  ;     i := i + 1 ) ; 
    var preSum : int ; preSum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(dp[i+1] - preSum) ; 
     preSum := dp[i+1] )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    int n=Integer.parseInt(f.readLine());
    int[] t=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      t[i]=Integer.parseInt(f.readLine());
    }
    long[] dp=new long[n+1];
    int last1=1 ;
    int last90=1 ;
    int last1440=1 ;
    for(int i=1 ; i<=n ; i++){
      while(t[i]-t[last1]>=1){
        last1++;
      }
      while(t[i]-t[last90]>=90){
        last90++;
      }
      while(t[i]-t[last1440]>=1440){
        last1440++;
      }
      dp[i]=Math.min(dp[last1-1]+20,Math.min(dp[last90-1]+50,dp[last1440-1]+120));
    }
    for(int i=1 ; i<=n ; i++){
      out.println(dp[i]-dp[i-1]);
    }
    f.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    var n : int ; n := (f.readLine())->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     t[i+1] := (f.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(long) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
    var last1 : int ; last1 := 1 ;
    var last90 : int ; last90 := 1 ;
    var last1440 : int ; last1440 := 1 ;
        var i : int ; i := 1 ; while i <= n do ( (     while (t[i+1] - t[last1+1] >= 1) do (     last1 := last1 + 1 ) ; 
     while (t[i+1] - t[last90+1] >= 90) do (     last90 := last90 + 1 ) ; 
     while (t[i+1] - t[last1440+1] >= 1440) do (     last1440 := last1440 + 1 ) ; 
     dp[i+1] := Set{dp[last1 - 1+1] + 20, Set{dp[last90 - 1+1] + 50, dp[last1440 - 1+1] + 120}->min()}->min() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int a=0,b=0 ;
    while(t-->0){
      int d=sc.nextInt();
      for(int i=d+1 ; i<=1000+d ; i++){
        if(isPrime(i)==true){
          a=i ;
          break ;
        }
      }
      b=a+d ;
      for(int i=b ; i<1000+b ; i++){
        if(isPrime(i)==true){
          b=i ;
          break ;
        }
      }
      System.out.println(a*b);
    }
  }
  static boolean isPrime(int n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static int lcm(int a,int b){
    return(a/gcd(a,b))*b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     var a : int ; a := 0 ;
    var b : int ; b := 0 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var d : int ; d := sc.getCurrent()->toInteger() ;
         var i : int ; i := d + 1 ; while i <= 1000 + d do ( (     if (isPrime(i) = true) then (     a := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    b := a + d ; 
        var i : int ; i := b ; while i < 1000 + b do ( (     if (isPrime(i) = true) then (     b := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a * b) ; 
 ) ;  ) );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return (a / gcd(a, b)) * b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class B_Different_Divisors {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int T=reader.nextInt();
    while(T!=0){
      T--;
      int d=reader.nextInt();
      int a1=1+d ;
      while(! isPrime(a1)){
        a1++;
      }
      int a2=a1+d ;
      while(! isPrime(a2)){
        a2++;
      }
      System.out.println(a1*a2);
    }
  }
  public static boolean isPrime(int N){
    for(int i=2 ; i*i<=N ; i++){
      if(N % i==0){
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Different_Divisors {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var T : int ; T := reader.nextInt() ;
     while (T /= 0) do (     T := T - 1 ; 
     var d : int ; d := reader.nextInt() ;
    var a1 : int ; a1 := 1 + d ;
    while (not(isPrime(a1))) do (     a1 := a1 + 1 ) ; 
    var a2 : int ; a2 := a1 + d ;
    while (not(isPrime(a2))) do (     a2 := a2 + 1 ) ; 
    OclFile["System.out"].println(a1 * a2) ; 
 ) );
  static   operation isPrime( N : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= N do ( (     if (N mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findSubsequence(int arr[],int n){
    int len=1 ;
    int tmp ;
    int i,j,d ;
    int dp[]=new int[10];
    int cnt[]=new int[10];
    int locMax ;
    tmp=arr[0];
    while(tmp>0){
      dp[tmp % 10]=1 ;
      tmp/=10 ;
    }
    for(i=1 ; i<n ; i++){
      tmp=arr[i];
      locMax=1 ;
      Arrays.fill(cnt,0);
      while(tmp>0){
        cnt[tmp % 10]=1 ;
        tmp/=10 ;
      }
      for(d=0 ; d<=9 ; d++){
        if(cnt[d]==1){
          dp[d]++;
          locMax=Math.max(locMax,dp[d]);
        }
      }
      for(d=0 ; d<=9 ; d++){
        if(cnt[d]==1){
          dp[d]=locMax ;
        }
      }
      len=Math.max(len,locMax);
    }
    return len ;
  }
  public static void main(String[] args){
    int arr[]={
      1,12,44,29,33,96,89 };
      int n=arr.length ;
      System.out.print(findSubsequence(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSubsequence( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var len : int ; len := 1 ;
     var tmp : int ;
    var i : int ;
    var j : int ;
    var d : int ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,10)->collect(0) ;
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,10)->collect(0) ;
    var locMax : int ;
    tmp := arr[0+1] ; 
    while (tmp > 0) do (     dp[tmp mod 10+1] := 1 ; 
     tmp := tmp/(10) ) ; 
        i := 1 ; while i < n do ( (     tmp := arr[i+1] ; 
     locMax := 1 ; 
    cnt := cnt->collect(0) ; 
    while (tmp > 0) do (     cnt[tmp mod 10+1] := 1 ; 
     tmp := tmp/(10) ) ; 
        d := 0 ; while d <= 9 do ( (     if (cnt[d+1] = 1) then (     dp[d+1] := dp[d+1] + 1 ; 
     locMax := Set{locMax, dp[d+1]}->max() ) else skip )  ;     d := d + 1 ) ; 
        d := 0 ; while d <= 9 do ( (     if (cnt[d+1] = 1) then (     dp[d+1] := locMax ) else skip )  ;     d := d + 1 ) ; 
    len := Set{len, locMax}->max() ; 
 )  ;     i := i + 1 ) ; 
    return len 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,12,44,29,33,96,89} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(findSubsequence(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int get_unordered_pairs(int[] a,int n){
    ArrayList<Integer>vs=new ArrayList<Integer>();
    int[] m=new int[maximum(a)+1];
    for(int i=0 ; i<n ; i++){
      m[(int)a[i] ]++;
      if(m[a[i] ]==1)vs.add(a[i]);
    }
    int number_of_pairs=0 ;
    for(int i=0 ; i<vs.size(); i++){
      if(m[(int)vs.get(i)]<(int)vs.get(i))continue ;
      else if(m[(int)vs.get(i)]==(int)vs.get(i))number_of_pairs+=1 ;
      else {
        number_of_pairs+=1 ;
        for(int j=(int)vs.get(i)+1 ; j<=m[(int)vs.get(i)]; j++){
          if(m[j]>=(int)vs.get(i))number_of_pairs+=1 ;
        }
      }
    }
    return number_of_pairs ;
  }
  static int maximum(int[] arr){
    int max=Integer.MIN_VALUE ;
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]>max){
        max=arr[i];
      }
    }
    return max ;
  }
  public static void main(String[] args){
    int[] arr={
      3,3,2,2,2 };
      int n=arr.length ;
      System.out.println(get_unordered_pairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation get_unordered_pairs( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var vs : Sequence(int) ; vs := Sequence{} ;
     var m : Sequence(int) ; m := Integer.subrange(1,maximum(a) + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     m[a[i+1]->oclAsType(int)+1] := m[a[i+1]->oclAsType(int)+1] + 1 ; 
     if (m[a[i+1]+1] = 1) then     vs := vs->including(a[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    var number_of_pairs : int ; number_of_pairs := 0 ;
        var i : int ; i := 0 ; while i < vs->size() do ( (     if (m[vs->at(i+1)->oclAsType(int)+1] < vs->at(i+1)->oclAsType(int)) then     continue else     if (m[vs->at(i+1)->oclAsType(int)+1] = vs->at(i+1)->oclAsType(int)) then     number_of_pairs := number_of_pairs+(1) else (     number_of_pairs := number_of_pairs+(1) ; 
         var j : int ; j := vs->at(i+1)->oclAsType(int) + 1 ; while j <= m[vs->at(i+1)->oclAsType(int)+1] do ( (     if (m[j+1] >= vs->at(i+1)->oclAsType(int)) then     number_of_pairs := number_of_pairs+(1) ; else skip )  ;     j := j + 1 ) ) ;  )  ;     i := i + 1 ) ; 
    return number_of_pairs 
 );
  static   operation maximum( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var max : int ; max := -2147483648 ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] > max) then (     max := arr[i+1] ) else skip )  ;     i := i + 1 ) ; 
     return max );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,3,2,2,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(get_unordered_pairs(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findNthTerm(int x,int y,int n){
    int[] f=new int[6];
    f[0]=x ;
    f[1]=y ;
    for(int i=2 ; i<=5 ; i++)f[i]=f[i-1]-f[i-2];
    return f[n % 6];
  }
  public static void main(String args[]){
    int x=2,y=3,n=3 ;
    System.out.println(findNthTerm(x,y,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNthTerm( x : int, y : int, n : int) : int
  pre: true
  post: true
  activity: (     var f : Sequence(int) ; f := Integer.subrange(1,6)->collect(0) ;
     f[0+1] := x ; 
    f[1+1] := y ; 
        var i : int ; i := 2 ; while i <= 5 do (     f[i+1] := f[i - 1+1] - f[i - 2+1] ;  ;     i := i + 1 ) ; 
    return f[n mod 6+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 2 ;
    var y : int ; y := 3 ;
    var n : int ; n := 3 ;
     OclFile["System.out"].println(findNthTerm(x, y, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B22 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int R=in.nextInt();
    int C=in.nextInt();
    int[][] A=new int[R+1][C+1];
    for(int r=0 ; r<R ; r++){
      char[] row=in.next().toCharArray();
      for(int c=0 ; c<C ; c++){
        A[r+1][c+1]=A[r+1][c]+(row[c]-'0');
      }
    }
    for(int c=1 ; c<=C ; c++){
      for(int r=1 ; r<=R ; r++){
        A[r][c]+=A[r-1][c];
      }
    }
    int max=0 ;
    for(int rFrom=0 ; rFrom<R ; rFrom++){
      for(int rTo=rFrom ; rTo<R ; rTo++){
        for(int cFrom=0 ; cFrom<C ; cFrom++){
          for(int cTo=cFrom ; cTo<C ; cTo++){
            int sum=A[rTo+1][cTo+1]-A[rTo+1][cFrom]-A[rFrom][cTo+1]+A[rFrom][cFrom];
            if(sum==0){
              max=Math.max(max,2*(cTo-cFrom+rTo-rFrom+2));
            }
          }
        }
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B22 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var R : int ; R := in.getCurrent()->toInteger() ;
    var C : int ; C := in.getCurrent()->toInteger() ;
    var A : Sequence(Sequence(int)) ; A := Integer.subrange(1,R + 1)->collect(Integer.subrange(1,C + 1)->collect(0)) ;
        var r : int ; r := 0 ; while r < R do ( (     var row : Sequence(String) ; row := in.getCurrent()->characters() ;
         var c : int ; c := 0 ; while c < C do ( (     A[r + 1+1][c + 1+1] := A[r + 1+1][c+1] + (row[c+1] - ('0')->char2byte()) )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
        var c : int ; c := 1 ; while c <= C do ( (         var r : int ; r := 1 ; while r <= R do ( (     A[r+1][c+1] := A[r+1][c+1]+(A[r - 1+1][c+1]) )  ;     r := r + 1 ) )  ;     c := c + 1 ) ; 
    var max : int ; max := 0 ;
        var rFrom : int ; rFrom := 0 ; while rFrom < R do ( (         var rTo : int ; rTo := rFrom ; while rTo < R do ( (         var cFrom : int ; cFrom := 0 ; while cFrom < C do ( (         var cTo : int ; cTo := cFrom ; while cTo < C do ( (     var sum : int ; sum := A[rTo + 1+1][cTo + 1+1] - A[rTo + 1+1][cFrom+1] - A[rFrom+1][cTo + 1+1] + A[rFrom+1][cFrom+1] ;
     if (sum = 0) then (     max := Set{max, 2 * (cTo - cFrom + rTo - rFrom + 2)}->max() ) else skip )  ;     cTo := cTo + 1 ) )  ;     cFrom := cFrom + 1 ) )  ;     rTo := rTo + 1 ) )  ;     rFrom := rFrom + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  final static int N=100 ;
  final static int INF=1000000 ;
  static int dp[][]=new int[N][N];
  static int vis[][]=new int[N][N];
  static int findSum(int[] arr,int n,int k,int l,int r){
    if((l)+(n-1-r)==k)return arr[r]-arr[l];
    if(vis[l][r]==1)return dp[l][r];
    vis[l][r]=1 ;
    dp[l][r]=Math.min(findSum(arr,n,k,l,r-1),findSum(arr,n,k,l+1,r));
    return dp[l][r];
  }
  public static void main(String[] args){
    int arr[]={
      1,2,100,120,140 };
      int k=2 ;
      int n=arr.length ;
      System.out.println(findSum(arr,n,k,0,n-1));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 100;
  static   attribute INF : int := 1000000;
  static   attribute dp : int := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0));
  static   attribute vis : int := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0));
  static   operation findSum( arr : Sequence(int), n : int, k : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     if ((l) + (n - 1 - r) = k) then     return arr[r+1] - arr[l+1] else skip ; 
     if (vis[l+1][r+1] = 1) then     return dp[l+1][r+1] else skip ; 
    vis[l+1][r+1] := 1 ; 
    dp[l+1][r+1] := Set{findSum(arr, n, k, l, r - 1), findSum(arr, n, k, l + 1, r)}->min() ; 
    return dp[l+1][r+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,100,120,140} ;
     var k : int ; k := 2 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findSum(arr, n, k, 0, n - 1)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  static long p=1000000007 ;
  static long[] fact=new long[200000];
  static long[] factinv=new long[200000];
  static BigInteger bip=new BigInteger(Long.toString(p));
  static long val(int h,int w){
    int n=h+w ;
    int r=h ;
    long l=(((fact[n]*factinv[r])% p)*factinv[n-r])% p ;
    if(l<0)l+=p ;
    return l ;
  }
  public static void main(String[] args){
    long ma=0 ;
    fact[0]=1 ;
    for(int i=1 ; i<200000 ; i++){
      fact[i]=(fact[i-1]*i)% p ;
      if(fact[i]<0)fact[i]+=p ;
      BigInteger bi=new BigInteger(Long.toString(fact[i]));
      factinv[i]=bi.modInverse(bip).longValue();
      ma=Math.max(ma,factinv[i]);
    }
    factinv[0]=1 ;
    Scanner sc=new Scanner(System.in);
    long sum=0 ;
    {
      int h=sc.nextInt();
      int w=sc.nextInt();
      int a=sc.nextInt();
      int b=sc.nextInt();
      int colh=h-a ;
      int trh=h-a ;
      for(int i=0 ; i<colh ; i++){
        long colv=val(w-b-1,a+i);
        long mul=val(trh-i-1,b-1);
        sum=(sum+(colv*mul)% p)% p ;
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute p : long := 1000000007;
  static   attribute fact : Sequence(long) := Integer.subrange(1,200000)->collect(0);
  static   attribute factinv : Sequence(long) := Integer.subrange(1,200000)->collect(0);
  static   attribute bip : long := long(((p) + ""));
  static   operation val( h : int, w : int) : long
  pre: true
  post: true
  activity: (     var n : int ; n := h + w ;
     var r : int ; r := h ;
    var l : long ; l := (((fact[n+1] * factinv[r+1]) mod p) * factinv[n - r+1]) mod p ;
    if (l < 0) then     l := l+(p) ; else skip ; 
    return l 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ma : long ; ma := 0 ;
     fact[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < 200000 do ( (     fact[i+1] := (fact[i - 1+1] * i) mod p ; 
     if (fact[i+1] < 0) then     fact[i+1] := fact[i+1]+(p) ; else skip ; 
    var bi : long ; bi := long(((fact[i+1]) + "")) ;
    factinv[i+1] := bi.modInverse(bip)->oclAsType(long) ; 
    ma := Set{ma, factinv[i+1]}->max() ; 
 )  ;     i := i + 1 ) ; 
    factinv[0+1] := 1 ; 
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var sum : long ; sum := 0 ;
(     var h : int ; h := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var colh : int ; colh := h - a ;
    var trh : int ; trh := h - a ;
        var i : int ; i := 0 ; while i < colh do ( (     var colv : long ; colv := val(w - b - 1, a + i) ;
     var mul : long ; mul := val(trh - i - 1, b - 1) ;
     sum := (sum + (colv * mul) mod p) mod p )  ;     i := i + 1 ) ; 
 ) 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long H=sc.nextInt()-1 ;
    long W=sc.nextInt()-1 ;
    long A=sc.nextInt()-1 ;
    long B=sc.nextInt()-1 ;
    long MOD=1000000007L ;
    BigInteger BMOD=BigInteger.valueOf(MOD);
    long x=1 ;
    long y=1 ;
    for(long i=W-B ; i<=W-B-1+H ; i++){
      y=(y*i)% MOD ;
    }
    for(long i=1 ; i<=H ; i++){
      y=(y*BigInteger.valueOf(i).modInverse(BMOD).longValue())% MOD ;
    }
    long ans=(x*y)% MOD ;
    long a1=B+1 ;
    long a2=1 ;
    long b1=W-B-1+H ;
    long b2=H ;
    for(int i=1 ; i<H-A ; i++){
      x=(x*a1)% MOD ;
      x=(x*BigInteger.valueOf(a2).modInverse(BMOD).longValue())% MOD ;
      a1+=1 ;
      a2+=1 ;
      y=(y*b2)% MOD ;
      y=(y*BigInteger.valueOf(b1).modInverse(BMOD).longValue())% MOD ;
      b1-=1 ;
      b2-=1 ;
      ans=(ans+x*y)% MOD ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : long ; H := sc.getCurrent()->toInteger() - 1 ;
    var W : long ; W := sc.getCurrent()->toInteger() - 1 ;
    var A : long ; A := sc.getCurrent()->toInteger() - 1 ;
    var B : long ; B := sc.getCurrent()->toInteger() - 1 ;
    var MOD : long ; MOD := 1000000007L ;
    var BMOD : long ; BMOD := (MOD + "")->toLong() ;
    var x : long ; x := 1 ;
    var y : long ; y := 1 ;
        var i : long ; i := W - B ; while i <= W - B - 1 + H do ( (     y := (y * i) mod MOD )  ;     i := i + 1 ) ; 
        var i : long ; i := 1 ; while i <= H do ( (     y := (y * (i + "")->toLong().modInverse(BMOD)->oclAsType(long)) mod MOD )  ;     i := i + 1 ) ; 
    var ans : long ; ans := (x * y) mod MOD ;
    var a1 : long ; a1 := B + 1 ;
    var a2 : long ; a2 := 1 ;
    var b1 : long ; b1 := W - B - 1 + H ;
    var b2 : long ; b2 := H ;
        var i : int ; i := 1 ; while i < H - A do ( (     x := (x * a1) mod MOD ; 
     x := (x * (a2 + "")->toLong().modInverse(BMOD)->oclAsType(long)) mod MOD ; 
    a1 := a1+(1) ; 
    a2 := a2+(1) ; 
    y := (y * b2) mod MOD ; 
    y := (y * (b1 + "")->toLong().modInverse(BMOD)->oclAsType(long)) mod MOD ; 
    b1 := b1-(1) ; 
    b2 := b2-(1) ; 
    ans := (ans + x * y) mod MOD ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static final int MAX=1000005 ;
  static final int MOD=1000000007 ;
  static long[] fact=new long[MAX];
  static long[] factInv=new long[MAX];
  static long[] inv=new long[MAX];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    int A=sc.nextInt();
    int B=sc.nextInt();
    sc.close();
    factMOD();
    invMOD();
    factInvMOD();
    long ans=0 ;
    for(int i=B ; i<W ; i++){
      ans+=combMOD(H-A-1+i,i)*combMOD(W+A-i-2,A-1);
      ans %=MOD ;
    }
    System.out.println(ans);
  }
  static void factMOD(){
    fact[0]=1 ;
    for(int i=1 ; i<MAX ; i++){
      fact[i]=fact[i-1]*i % MOD ;
    }
  }
  static void invMOD(){
    inv[0]=1 ;
    inv[1]=1 ;
    for(int i=2 ; i<MAX ; i++){
      inv[i]=MOD-inv[(int)(MOD % i)]*(MOD/i)% MOD ;
    }
  }
  static void factInvMOD(){
    factInv[0]=1 ;
    for(int i=1 ; i<MAX ; i++){
      factInv[i]=factInv[i-1]*inv[i] % MOD ;
    }
  }
  static long combMOD(int n,int k){
    if(n<k)return 0 ;
    if(n<0 || k<0)return 0 ;
    return fact[n]*((factInv[k]*factInv[n-k])% MOD)% MOD ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 1000005;
  static    attribute MOD : int := 1000000007;
  static   attribute fact : Sequence(long) := Integer.subrange(1,MAX)->collect(0);
  static   attribute factInv : Sequence(long) := Integer.subrange(1,MAX)->collect(0);
  static   attribute inv : Sequence(long) := Integer.subrange(1,MAX)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    skip ; 
    execute factMOD() ; 
    execute invMOD() ; 
    execute factInvMOD() ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := B ; while i < W do ( (     ans := ans+(combMOD(H - A - 1 + i, i) * combMOD(W + A - i - 2, A - 1)) ; 
     ans := ans mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation factMOD() : void
  pre: true
  post: true
  activity: (     fact[0+1] := 1 ; 
         var i : int ; i := 1 ; while i < MAX do ( (     fact[i+1] := fact[i - 1+1] * i mod MOD )  ;     i := i + 1 ) );
  static   operation invMOD() : void
  pre: true
  post: true
  activity: (     inv[0+1] := 1 ; 
     inv[1+1] := 1 ; 
         var i : int ; i := 2 ; while i < MAX do ( (     inv[i+1] := MOD - inv[(MOD mod i)->oclAsType(int)+1] * (MOD / i) mod MOD )  ;     i := i + 1 ) );
  static   operation factInvMOD() : void
  pre: true
  post: true
  activity: (     factInv[0+1] := 1 ; 
         var i : int ; i := 1 ; while i < MAX do ( (     factInv[i+1] := factInv[i - 1+1] * inv[i+1] mod MOD )  ;     i := i + 1 ) );
  static   operation combMOD( n : int, k : int) : long
  pre: true
  post: true
  activity: (     if (n < k) then     return 0 else skip ; 
     if (n < 0 or k < 0) then     return 0 else skip ; 
     return fact[n+1] * ((factInv[k+1] * factInv[n - k+1]) mod MOD) mod MOD );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void gridStr(String str){
    int l=str.length();
    int k=0,row,column ;
    row=(int)Math.floor(Math.sqrt(l));
    column=(int)Math.ceil(Math.sqrt(l));
    if(row*column<l){
      row=column ;
    }
    char s[][]=new char[row][column];
    for(int i=0 ; i<row ; i++){
      for(int j=0 ; j<column ; j++){
        if(k<str.length())s[i][j]=str.charAt(k);
        k++;
      }
    }
    for(int i=0 ; i<row ; i++){
      for(int j=0 ; j<column ; j++){
        if(s[i][j]==0){
          break ;
        }
        System.out.print(s[i][j]);
      }
      System.out.println("");
    }
  }
  public static void main(String[] args){
    String str="GEEKSFORGEEKS" ;
    gridStr(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gridStr( str : String) : void
  pre: true
  post: true
  activity: (     var l : int ; l := str->size() ;
     var k : int ; k := 0 ;
    var row : int ;
    var column : int ;
    row := ((l)->sqrt())->floor()->oclAsType(int) ; 
    column := ((l)->sqrt())->ceil()->oclAsType(int) ; 
    if (row * column < l) then (     row := column ) else skip ; 
    var s : Sequence(Sequence(String)) ; s := Integer.subrange(1,row)->collect(Integer.subrange(1,column)->collect(0)) ;
        var i : int ; i := 0 ; while i < row do ( (         var j : int ; j := 0 ; while j < column do ( (     if (k < str->size()) then     s[i+1][j+1] := str->at(k+1) ; else skip ; 
     k := k + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < row do ( (         var j : int ; j := 0 ; while j < column do ( (     if (s[i+1][j+1] = 0) then (     break ) else skip ; 
     OclFile["System.out"].print(s[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GEEKSFORGEEKS" ;
     execute gridStr(str) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=input.nextInt();
      int m=input.nextInt();
      HashSet<Integer>set=new HashSet<Integer>();
      for(int j=0 ; j<n ; j++){
        set.add(input.nextInt());
      }
      int count=0 ;
      for(int j=0 ; j<m ; j++){
        if(set.add(input.nextInt())==false)count++;
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var m : int ; m := input.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
        var j : int ; j := 0 ; while j < n do ( (     set := set->including(input.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
    var count : int ; count := 0 ;
        var j : int ; j := 0 ; while j < m do ( (     if (set->excludes(input.getCurrent()->toInteger()) = false) then     count := count + 1 ; else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.StringBuilder ;
import java.io.BufferedReader ;
import java.io.DataInputStream ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Deque ;
import java.util.HashMap ;
import java.util.LinkedList ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.Stack ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String a=in.nextLine();
    String z,v,m ;
    int x=a.indexOf("+");
    int y=a.indexOf("=");
    z=a.substring(0,x);
    v=a.substring(x+1,y);
    m=a.substring(y+1,a.length());
    if(z.length()+v.length()==m.length()){
      System.out.println(a);
    }
    else if(z.length()+1+v.length()==m.length()-1 && m.length()-1>0){
      a='|'+a ;
      System.out.println(a.substring(0,a.length()-1));
    }
    else if(z.length()-1+v.length()==m.length()+1 && z.length()-1>0){
      a+='|' ;
      System.out.println(a.substring(1,a.length()));
    }
    else if(z.length()+v.length()-1==m.length()+1 && v.length()-1>0){
      v=v.substring(1,v.length());
      m+='|' ;
      System.out.println(z+"+"+v+"="+m);
    }
    else System.out.println("Impossible");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := in.nextLine() ;
    var z : String ;
    var v : String ;
    var m : String ;
    var x : int ; x := a->indexOf("+")-1 ;
    var y : int ; y := a->indexOf("=")-1 ;
    z := a.subrange(0+1,x) ; 
    v := a.subrange(x + 1+1,y) ; 
    m := a.subrange(y + 1+1,a->size()) ; 
    if (z->size() + v->size() = m->size()) then (     OclFile["System.out"].println(a) ) else     if (z->size() + 1 + v->size() = m->size() - 1 & m->size() - 1 > 0) then (     a := '|' + a ; 
     OclFile["System.out"].println(a.subrange(0+1,a->size() - 1)) ) else     if (z->size() - 1 + v->size() = m->size() + 1 & z->size() - 1 > 0) then (     a := a+('|') ; 
     OclFile["System.out"].println(a.subrange(1+1,a->size())) ) else     if (z->size() + v->size() - 1 = m->size() + 1 & v->size() - 1 > 0) then (     v := v.subrange(1+1,v->size()) ; 
     m := m+('|') ; 
     OclFile["System.out"].println(z + "+" + v + "=" + m) ) else     OclFile["System.out"].println("Impossible") ; ;  ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.StringBuilder ;
import java.io.BufferedReader ;
import java.io.DataInputStream ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Deque ;
import java.util.HashMap ;
import java.util.LinkedList ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.Stack ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String a=in.nextLine();
    String z,v,m ;
    int x=a.indexOf("+");
    int y=a.indexOf("=");
    z=a.substring(0,x);
    v=a.substring(x+1,y);
    m=a.substring(y+1,a.length());
    if(z.length()+v.length()==m.length()){
      System.out.println(a);
    }
    else if(z.length()+1+v.length()==m.length()-1 && m.length()>0){
      a='|'+a ;
      System.out.println(a.substring(0,a.length()-1));
    }
    else if(z.length()-1+v.length()==m.length()+1 && z.length()-1>0){
      a+='|' ;
      System.out.println(a.substring(1,a.length()));
    }
    else if(z.length()+v.length()-1==m.length()+1 && v.length()-1>0){
      v=v.substring(1,v.length());
      m+='|' ;
      System.out.println(z+"+"+v+"="+m);
    }
    else System.out.println("Impossible");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := in.nextLine() ;
    var z : String ;
    var v : String ;
    var m : String ;
    var x : int ; x := a->indexOf("+")-1 ;
    var y : int ; y := a->indexOf("=")-1 ;
    z := a.subrange(0+1,x) ; 
    v := a.subrange(x + 1+1,y) ; 
    m := a.subrange(y + 1+1,a->size()) ; 
    if (z->size() + v->size() = m->size()) then (     OclFile["System.out"].println(a) ) else     if (z->size() + 1 + v->size() = m->size() - 1 & m->size() > 0) then (     a := '|' + a ; 
     OclFile["System.out"].println(a.subrange(0+1,a->size() - 1)) ) else     if (z->size() - 1 + v->size() = m->size() + 1 & z->size() - 1 > 0) then (     a := a+('|') ; 
     OclFile["System.out"].println(a.subrange(1+1,a->size())) ) else     if (z->size() + v->size() - 1 = m->size() + 1 & v->size() - 1 > 0) then (     v := v.subrange(1+1,v->size()) ; 
     m := m+('|') ; 
     OclFile["System.out"].println(z + "+" + v + "=" + m) ) else     OclFile["System.out"].println("Impossible") ; ;  ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF_394_A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder s=new StringBuilder(sc.nextLine());
    int[] a=new int[3];
    int j=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='|'){
        a[j]=a[j]+1 ;
      }
      else {
        j++;
      }
    }
    if(a[0]+a[1]==a[2])System.out.println(s);
    else {
      int i=a[2]-a[0]-a[1];
      if(i==2){
        s.deleteCharAt(s.length()-1);
        s=new StringBuilder("|"+s);
        System.out.println(s);
      }
      else if(i==-2){
        if(a[0]>1)s.deleteCharAt(0);
        else s.deleteCharAt(2);
        s=new StringBuilder(s+"|");
        System.out.println(s);
      }
      else {
        System.out.println("Impossible");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF_394_A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := StringLib.newString(sc.nextLine()) ;
    var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '|') then (     a[j+1] := a[j+1] + 1 ) else (     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (a[0+1] + a[1+1] = a[2+1]) then     OclFile["System.out"].println(s) else (     var i : int ; i := a[2+1] - a[0+1] - a[1+1] ;
     if (i = 2) then (     s := s->excludingAt(s->size() - 1+1) ; 
     s := StringLib.newString("|" + s) ; 
     OclFile["System.out"].println(s) ) else     if (i = -2) then (     if (a[0+1] > 1) then     s := s->excludingAt(0+1) else     s := s->excludingAt(2+1) ; ;  
     s := StringLib.newString(s + "|") ; 
     OclFile["System.out"].println(s) ) else (     OclFile["System.out"].println("Impossible") ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Test {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String str=sc.next();
      int mid=(str.length()/2);
      if(str.length()% 2==0)mid-=1 ;
      if(mid==-1)mid=0 ;
      String ans=str.charAt(mid)+"" ;
      for(int i=mid-1,j=mid+1 ; i>=0 || j<str.length(); i--,j++){
        if(j<str.length()){
          ans=ans+""+str.charAt(j);
        }
        if(i>=0){
          ans=ans+""+str.charAt(i);
        }
      }
      System.out.println(ans);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var str : String ; str := sc.getCurrent() ;
     var mid : int ; mid := (str->size() / 2) ;
    if (str->size() mod 2 = 0) then     mid := mid-(1) ; else skip ; 
    if (mid = -1) then     mid := 0 ; else skip ; 
    var ans : String ; ans := str->at(mid+1) + "" ;
        var i : int ; i := (mid)->char2byte() - 1 ;
    var j : int ; j := mid + 1 ; while i >= 0 or j < str->size() do ( (     if (j < str->size()) then (     ans := ans + "" + str->at(j+1) ) else skip ; 
     if (i >= 0) then (     ans := ans + "" + str->at(i+1) ) else skip )  ;     i := i - 1 ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isFrequencyEqual(int arr[],int len){
    if(len % 2==1){
      System.out.print("No Such Element");
      return false ;
    }
    HashMap<Integer,Integer>freq=new HashMap<Integer,Integer>();
    for(int i=0 ; i<len ; i++)if(freq.containsKey(arr[i])){
      freq.put(arr[i],freq.get(arr[i])+1);
    }
    else {
      freq.put(arr[i],1);
    }
    for(int i=0 ; i<len ; i++){
      if(freq.containsKey(arr[i])&& freq.get(arr[i])==len/2){
        System.out.print(arr[i]+"\n");
        return true ;
      }
    }
    System.out.print("No such element");
    return false ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,2,3,3,3 };
      int n=6 ;
      isFrequencyEqual(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isFrequencyEqual( arr : Sequence(int), len : int) : boolean
  pre: true
  post: true
  activity: (     if (len mod 2 = 1) then (     OclFile["System.out"].print("No Such Element") ; 
     return false ) else skip ; 
     var freq : Map(int,int) ; freq := Map{} ;
        var i : int ; i := 0 ; while i < len do (     if (freq->keys()->includes(arr[i+1])) then (     freq := freq->union(Map{arr[i+1] |-> freq->at(arr[i+1]) + 1}) ) else (     freq := freq->union(Map{arr[i+1] |-> 1}) ) ;   ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < len do ( (     if (freq->keys()->includes(arr[i+1]) & freq->at(arr[i+1]) = len / 2) then (     OclFile["System.out"].print(arr[i+1] + "\n") ; 
     return true ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("No such element") ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,2,3,3,3} ;
     var n : int ; n := 6 ;
     execute isFrequencyEqual(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=10000 ;
  static ArrayList<Integer>primes=new ArrayList<Integer>();
  static void sieveSundaram(){
    boolean[] marked=new boolean[MAX/2+100];
    for(int i=1 ; i<=(Math.sqrt(MAX)-1)/2 ; i++)for(int j=(i*(i+1))<<1 ; j<=MAX/2 ; j=j+2*i+1)marked[j]=true ;
    primes.add(2);
    for(int i=1 ; i<=MAX/2 ; i++)if(marked[i]==false)primes.add(2*i+1);
  }
  static void findPrimes(int n){
    if(n<=2 || n % 2!=0){
      System.out.println("Invalid Input ");
      return ;
    }
    for(int i=0 ; primes.get(i)<=n/2 ; i++){
      int diff=n-primes.get(i);
      if(primes.contains(diff)){
        System.out.println(primes.get(i)+"+"+diff+"="+n);
        return ;
      }
    }
  }
  public static void main(String[] args){
    sieveSundaram();
    findPrimes(4);
    findPrimes(38);
    findPrimes(100);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 10000;
  static   attribute primes : Sequence(int) := Sequence{};
  static   operation sieveSundaram() : void
  pre: true
  post: true
  activity: (     var marked : Sequence(boolean) ; marked := Integer.subrange(1,MAX / 2 + 100)->collect(false) ;
         var i : int ; i := 1 ; while i <= ((MAX)->sqrt() - 1) / 2 do (         var j : int ; j := ((i * (i + 1))*(2->pow(1)))->oclAsType(long) ; while j <= MAX / 2 do (     marked[j+1] := true ;  ;     j := j + 2 * i + 1 ) ;  ;     i := i + 1 ) ; 
     primes := primes->including(2) ; 
         var i : int ; i := 1 ; while i <= MAX / 2 do (     if (marked[i+1] = false) then     primes := primes->including(2 * i + 1) ; else skip ;  ;     i := i + 1 ) );
  static   operation findPrimes( n : int) : void
  pre: true
  post: true
  activity: (     if (n <= 2 or n mod 2 /= 0) then (     OclFile["System.out"].println("Invalid Input ") ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while primes->at(i+1) <= n / 2 do ( (     var diff : int ; diff := n - primes->at(i+1) ;
     if (primes->includes(diff)) then (     OclFile["System.out"].println(primes->at(i+1) + "+" + diff + "=" + n) ; 
     return ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute sieveSundaram() ; 
     execute findPrimes(4) ; 
     execute findPrimes(38) ; 
     execute findPrimes(100) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String findMinLenStr(String str,int k){
    int n=str.length();
    int st=0 ;
    int end=0 ;
    int cnt[]=new int[26];
    for(int i=0 ; i<26 ; i++)cnt[i]=0 ;
    int distEle=0 ;
    int currlen ;
    int minlen=n ;
    int startInd=-1 ;
    while(end<n){
      cnt[str.charAt(end)-'a']++;
      if(cnt[str.charAt(end)-'a']==1)distEle++;
      if(distEle>k){
        while(st<end && distEle>k){
          if(cnt[str.charAt(st)-'a']==1)distEle--;
          cnt[str.charAt(st)-'a']--;
          st++;
        }
      }
      if(distEle==k){
        while(st<end && cnt[str.charAt(st)-'a']>1){
          cnt[str.charAt(st)-'a']--;
          st++;
        }
        currlen=end-st+1 ;
        if(currlen<minlen){
          minlen=currlen ;
          startInd=st ;
        }
      }
      end++;
    }
    return str.substring(startInd,startInd+minlen);
  }
  public static void main(String args[]){
    String str="efecfefd" ;
    int k=4 ;
    System.out.println(findMinLenStr(str,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMinLenStr( str : String, k : int) : String
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var st : int ; st := 0 ;
    var end : int ; end := 0 ;
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < 26 do (     cnt[i+1] := 0 ;  ;     i := i + 1 ) ; 
    var distEle : int ; distEle := 0 ;
    var currlen : int ;
    var minlen : int ; minlen := n ;
    var startInd : int ; startInd := -1 ;
    while (end < n) do (     cnt[str->at(end+1) - ('a')->char2byte()+1] := cnt[str->at(end+1) - ('a')->char2byte()+1] + 1 ; 
     if (cnt[str->at(end+1) - ('a')->char2byte()+1] = 1) then     distEle := distEle + 1 ; else skip ; 
    if (distEle > k) then (     while (st < end & distEle > k) do (     if (cnt[str->at(st+1) - ('a')->char2byte()+1] = 1) then     distEle := distEle - 1 ; else skip ; 
     cnt[str->at(st+1) - ('a')->char2byte()+1] := cnt[str->at(st+1) - ('a')->char2byte()+1] - 1 ; 
     st := st + 1 ) ) else skip ; 
    if (distEle = k) then (     while (st < end & cnt[str->at(st+1) - ('a')->char2byte()+1] > 1) do (     cnt[str->at(st+1) - ('a')->char2byte()+1] := cnt[str->at(st+1) - ('a')->char2byte()+1] - 1 ; 
     st := st + 1 ) ; 
     currlen := end - st + 1 ; 
     if (currlen < minlen) then (     minlen := currlen ; 
     startInd := st ) else skip ) else skip ; 
    end := end + 1 ; 
 ) ; 
    return str.subrange(startInd+1,startInd + minlen) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "efecfefd" ;
     var k : int ; k := 4 ;
     OclFile["System.out"].println(findMinLenStr(str, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    long[] a=new long[5];
    long[] b=new long[5];
    for(int i=1 ; i<=x ; i++){
      a[i % 5]++;
    }
    for(int i=1 ; i<=y ; i++){
      b[i % 5]++;
    }
    System.out.println(a[0]*b[0]+a[1]*b[4]+a[2]*b[3]+a[3]*b[2]+a[4]*b[1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,5)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,5)->collect(0) ;
        var i : int ; i := 1 ; while i <= x do ( (     a[i mod 5+1] := a[i mod 5+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= y do ( (     b[i mod 5+1] := b[i mod 5+1] + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a[0+1] * b[0+1] + a[1+1] * b[4+1] + a[2+1] * b[3+1] + a[3+1] * b[2+1] + a[4+1] * b[1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    long count=0 ;
    if(m % 5==0){
      System.out.println((long)n*(m/5));
    }
    else {
      count=(long)n*(m/5);
      for(long i=1 ; i<=n ; i++){
        for(long j=1+(m/5)*5 ; j<=m ; j++){
          if((i+j)% 5==0){
            count++;
          }
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var count : long ; count := 0 ;
    if (m mod 5 = 0) then (     OclFile["System.out"].println(n->oclAsType(long) * (m / 5)) ) else (     count := n->oclAsType(long) * (m / 5) ; 
         var i : long ; i := 1 ; while i <= n do ( (         var j : long ; j := 1 + (m / 5) * 5 ; while j <= m do ( (     if ((i + j) mod 5 = 0) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    long x=input.nextInt();
    long y=input.nextInt();
    long counter=0 ;
    for(int i=1 ; i<=x ; i++){
      counter+=((i+y)/5)-(i/5);
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := input.getCurrent()->toInteger() ;
    var y : long ; y := input.getCurrent()->toInteger() ;
    var counter : long ; counter := 0 ;
        var i : int ; i := 1 ; while i <= x do ( (     counter := counter+(((i + y) / 5) - (i / 5)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class P1453A {
  public static void main(String[] args)throws IOException {
    BufferedReader io=new BufferedReader(new InputStreamReader(System.in));
    Integer cnt=Integer.valueOf(io.readLine());
    List<Integer>rs=new ArrayList<Integer>();
    while(cnt>0){
      cnt--;
      String[] nm=io.readLine().split(" ");
      Integer n=Integer.valueOf(nm[0]);
      Integer m=Integer.valueOf(nm[1]);
      String[] ns=io.readLine().split(" ");
      String[] ms=io.readLine().split(" ");
      Integer tmp=0 ;
      for(int i=0 ; i<ns.length ; i++){
        for(int j=0 ; j<ms.length ; j++){
          if(ns[i] .equals(ms[j])){
            tmp++;
          }
        }
      }
      rs.add(tmp);
    }
    for(Integer integer : rs){
      System.out.println(integer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P1453A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var cnt : int ; cnt := (io.readLine())->toInteger() ;
    var rs : Sequence(int) ; rs := Sequence{} ;
    while (cnt > 0) do (     cnt := cnt - 1 ; 
     var nm : Sequence(String) ; nm := io.readLine()->split(" ") ;
    var n : int ; n := (nm[0+1])->toInteger() ;
    var m : int ; m := (nm[1+1])->toInteger() ;
    var ns : Sequence(String) ; ns := io.readLine()->split(" ") ;
    var ms : Sequence(String) ; ms := io.readLine()->split(" ") ;
    var tmp : int ; tmp := 0 ;
        var i : int ; i := 0 ; while i < ns->size() do ( (         var j : int ; j := 0 ; while j < ms->size() do ( (     if (ns[i+1] = ms[j+1]) then (     tmp := tmp + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    rs := rs->including(tmp) ; 
 ) ; 
    for (integer : rs) do ( (     OclFile["System.out"].println(integer) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  static FastScanner in=new FastScanner();
  static PrintWriter out=new PrintWriter(System.out);
  public static int bs(int i,long max){
    int result=0 ;
    int l=5,r=4_000_000 ;
    while(l!=r){
      int mid=(l+r)/2 ;
      if(mid-i<=max){
        result=mid ;
        l=mid+1 ;
      }
      else r=mid ;
    }
    return result ;
  }
  public static void main(String[] args){
    int n=in.nextInt(),m=in.nextInt();
    int max=Math.max(n,m),min=Math.min(n,m);
    long tempCount=4_000_000/5 ;
    long count=0 ;
    for(int i=1 ; i<=min ; i++){
      tempCount-=i % 5==0 ? 1 : 0 ;
      int temp=bs(i,max);
      temp-=temp % 5 ;
      int temp2=(4_000_000-temp)/5 ;
      count+=(tempCount-temp2);
    }
    out.println(count);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   attribute in : FastScanner := FastScanner.newFastScanner();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation bs( i : int, max : long) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var l : int ; l := 5 ;
    var r : int ; r := 4_000_000 ;
     while (l /= r) do (     var mid : int ; mid := (l + r) / 2 ;
     if (mid - i <= max) then (     result := mid ; 
     l := mid + 1 ) else     r := mid ; ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
    var m : int ; m := in.nextInt() ;
     var max : int ; max := Set{n, m}->max() ;
    var min : int ; min := Set{n, m}->min() ;
    var tempCount : long ; tempCount := 4_000_000 / 5 ;
    var count : long ; count := 0 ;
        var i : int ; i := 1 ; while i <= min do ( (     tempCount := tempCount-(if i mod 5 = 0 then 1 else 0 endif) ; 
     var temp : int ; temp := bs(i, max) ;
    temp := temp-(temp mod 5) ; 
    var temp2 : int ; temp2 := (4_000_000 - temp) / 5 ;
    count := count+((tempCount - temp2)) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class robots {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] ids=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      ids[i]=sc.nextInt();
    }
    long whichRobot=0 ;
    long currentSaid=0 ;
    while(currentSaid<k){
      whichRobot++;
      currentSaid=whichRobot*(whichRobot+1)/2 ;
    }
    int index=(int)((long)k-((whichRobot-1)*(whichRobot)/2));
    System.out.println(ids[index]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class robots {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var ids : Sequence(int) ; ids := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     ids[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var whichRobot : long ; whichRobot := 0 ;
    var currentSaid : long ; currentSaid := 0 ;
    while (currentSaid < k) do (     whichRobot := whichRobot + 1 ; 
     currentSaid := whichRobot * (whichRobot + 1) / 2 ) ; 
    var index : int ; index := (k->oclAsType(long) - ((whichRobot - 1) * (whichRobot) / 2))->oclAsType(int) ;
    OclFile["System.out"].println(ids[index+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    int n=in.nextInt();
    int k=in.nextInt();
    int[] a=readAnArray(n);
    long position=solve(k);
    long min=(position*(position+1))/2 ;
    if(k==min){
      System.out.println(a[(int)position-1]);
    }
    else {
      int ans=a[k-(int)min-1];
      System.out.println(ans);
    }
  }
  static long solve(long k){
    k=k*2 ;
    long d=1+4*k ;
    return(-1+(long)Math.sqrt(d))/2 ;
  }
  static int[] readAnArray(int n){
    int[] a=new int[n];
    for(int i=0 ; i<a.length ; i++){
      a[i]=in.nextInt();
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := readAnArray(n) ;
    var position : long ; position := solve(k) ;
    var min : long ; min := (position * (position + 1)) / 2 ;
    if (k = min) then (     OclFile["System.out"].println(a[position->oclAsType(int) - 1+1]) ) else (     var ans : int ; ans := a[k - min->oclAsType(int) - 1+1] ;
     OclFile["System.out"].println(ans) ) ;  
 );
  static   operation solve( k : long) : long
  pre: true
  post: true
  activity: (     k := k * 2 ; 
     var d : long ; d := 1 + 4 * k ;
     return (-1 + (d)->sqrt()->oclAsType(long)) / 2 );
  static   operation readAnArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Game_of_robot {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    long k=scanner.nextLong();
    long a[]=new long[n+1];
    for(int i=1 ; i<n+1 ; i++)a[i]=scanner.nextLong();
    scanner.close();
    long t=0,i=1 ;
    while(k>t){
      t+=i ;
      i++;
    }
    i--;
    t-=i ;
    k-=t ;
    System.out.println(a[(int)k]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Game_of_robot {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var k : long ; k := scanner.getCurrent()->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i < n + 1 do (     a[i+1] := scanner.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    skip ; 
    var t : long ; t := 0 ;
    var i : long ; i := 1 ;
    while (k > t) do (     t := t+(i) ; 
     i := i + 1 ) ; 
    i := i - 1 ; 
    t := t-(i) ; 
    k := k-(t) ; 
    OclFile["System.out"].println(a[k->oclAsType(int)+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    char[] s=in.next().toCharArray();
    int m=s.length/2 ;
    if(s.length % 2==0)m--;
    int r=m ;
    int l=m ;
    int cnt=0 ;
    pw.print(s[m]);
    while(r<s.length && l>=0){
      if(cnt % 2==0)r++;
      else l--;
      try {
        if(cnt % 2==0)pw.print(s[r]);
        else pw.print(s[l]);
      }
      catch(Exception e){
        break ;
      }
      cnt++;
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : Sequence(String) ; s := in.getCurrent()->characters() ;
    var m : int ; m := s->size() / 2 ;
    if (s->size() mod 2 = 0) then     m := m - 1 ; else skip ; 
    var r : int ; r := m ;
    var l : int ; l := m ;
    var cnt : int ; cnt := 0 ;
    skip ; 
    while (r < s->size() & l >= 0) do (     if (cnt mod 2 = 0) then     r := r + 1 else     l := l - 1 ; ;  
     try (     if (cnt mod 2 = 0) then     skip ; else     skip ; )   catch (e : ProgramException) do (     break )
     cnt := cnt + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Game_of_robot {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    long k=scanner.nextLong();
    long a[]=new long[n+1];
    for(int i=1 ; i<n+1 ; i++)a[i]=scanner.nextLong();
    scanner.close();
    long root=(long)Math.sqrt(k);
    long t=((root)*(root+1))/2 ;
    long i=root+1 ;
    while(k>t){
      t+=i ;
      i++;
    }
    i--;
    t-=i ;
    k-=t ;
    System.out.println(a[(int)k]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Game_of_robot {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var k : long ; k := scanner.getCurrent()->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i < n + 1 do (     a[i+1] := scanner.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    skip ; 
    var root : long ; root := (k)->sqrt()->oclAsType(long) ;
    var t : long ; t := ((root) * (root + 1)) / 2 ;
    var i : long ; i := root + 1 ;
    while (k > t) do (     t := t+(i) ; 
     i := i + 1 ) ; 
    i := i - 1 ; 
    t := t-(i) ; 
    k := k-(t) ; 
    OclFile["System.out"].println(a[k->oclAsType(int)+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class _670B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    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 sum=0,i=1 ;
    while(sum+i<=k){
      sum+=i ;
      i++;
    }
    if(sum-k==0)System.out.println(arr[i-2]);
    else System.out.println(arr[k-sum-1]);
  }
  public static int gcd(int a,int b){
    return(a==0)? b : gcd(b % a,a);
  }
  static int power(int x,int y){
    int ans=1 ;
    while(y>0){
      if((y & 1)!=0)ans*=x ;
      y=y>>1 ;
      x*=x ;
    }
    return ans ;
  }
  public static List<Integer>sieve(int n){
    List<Integer>primes=new LinkedList<>();
    boolean[] composite=new boolean[n+1];
    for(int i=2 ; i*i<=n ; i++)for(int j=i*i ; j<=n && ! composite[i]; j+=i)composite[j]=true ;
    for(int j=2 ; j<composite.length ; j++)if(! composite[j])primes.add(j);
    return primes ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class _670B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var i : int ; i := 1 ;
    while (sum + i <= k) do (     sum := sum+(i) ; 
     i := i + 1 ) ; 
    if (sum - k = 0) then     OclFile["System.out"].println(arr[i - 2+1]) else     OclFile["System.out"].println(arr[k - sum - 1+1]) ; ;  
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if (a = 0) then b else gcd(b mod a, a) endif );
  static   operation power( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
     while (y > 0) do (     if ((y & 1) /= 0) then     ans := ans*(x) ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := x*(x) ) ; 
     return ans );
  static   operation sieve( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var primes : Sequence(int) ; primes := Sequence{} ;
     var composite : Sequence(boolean) ; composite := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 2 ; while i * i <= n do (         var j : int ; j := i * i ; while j <= n & not(composite[i+1]) do (     composite[j+1] := true ;  ;     j := j+(i) ) ;  ;     i := i + 1 ) ; 
        var j : int ; j := 2 ; while j < composite->size() do (     if (not(composite[j+1])) then     primes := primes->including(j) ; else skip ;  ;     j := j + 1 ) ; 
    return primes 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int cntSquares(int n){
    int squares=0 ;
    for(int i=1 ; i<=n ; i++){
      squares+=Math.pow(i,2);
    }
    return squares ;
  }
  public static void main(String args[]){
    int n=4 ;
    System.out.print(cntSquares(4));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation cntSquares( n : int) : int
  pre: true
  post: true
  activity: (     var squares : int ; squares := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     squares := squares+(i->pow(2)) )  ;     i := i + 1 ) ; 
     return squares );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].print(cntSquares(4)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class MinCellsDestination {
  static final int SIZE=100 ;
  static int minCells(int mat[][],int m,int n){
    int dp[][]=new int[m][n];
    for(int i=0 ; i<m ; i++)for(int j=0 ; j<n ; j++)dp[i][j]=Integer.MAX_VALUE ;
    dp[0][0]=1 ;
    for(int i=0 ; i<m ; i++){
      for(int j=0 ; j<n ; j++){
        if(dp[i][j]!=Integer.MAX_VALUE &&(j+mat[i][j])<n &&(dp[i][j]+1)<dp[i][j+mat[i][j] ])dp[i][j+mat[i][j] ]=dp[i][j]+1 ;
        if(dp[i][j]!=Integer.MAX_VALUE &&(i+mat[i][j])<m &&(dp[i][j]+1)<dp[i+mat[i][j] ][j])dp[i+mat[i][j] ][j]=dp[i][j]+1 ;
      }
    }
    if(dp[m-1][n-1]!=Integer.MAX_VALUE)return dp[m-1][n-1];
    return-1 ;
  }
  public static void main(String args[]){
    int mat[][]={
      {
        2,3,2,1,4 },{
          3,2,5,8,2 },{
            1,1,2,2,1 }
          };
          int m=3,n=5 ;
          System.out.println("Minimum number of cells"+"="+minCells(mat,m,n));
        }
      }

------------------------------------------------------------
OCL File:
---------
class MinCellsDestination {
  static    attribute SIZE : int := 100;
  static   operation minCells( mat : Sequence(Sequence(int)), m : int, n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,m)->collect(Integer.subrange(1,n)->collect(0)) ;
         var i : int ; i := 0 ; while i < m do (         var j : int ; j := 0 ; while j < n do (     dp[i+1][j+1] := 2147483647 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j < n do ( (     if (dp[i+1][j+1] /= 2147483647 & (j + mat[i+1][j+1]) < n & (dp[i+1][j+1] + 1) < dp[i+1][j + mat[i+1][j+1]+1]) then     dp[i+1][j + mat[i+1][j+1]+1] := dp[i+1][j+1] + 1 ; else skip ; 
     if (dp[i+1][j+1] /= 2147483647 & (i + mat[i+1][j+1]) < m & (dp[i+1][j+1] + 1) < dp[i + mat[i+1][j+1]+1][j+1]) then     dp[i + mat[i+1][j+1]+1][j+1] := dp[i+1][j+1] + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (dp[m - 1+1][n - 1+1] /= 2147483647) then     return dp[m - 1+1][n - 1+1] else skip ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{2,3,2,1,4},Sequence{3,2,5,8,2},Sequence{1,1,2,2,1}} ;
     var m : int ; m := 3 ;
    var n : int ; n := 5 ;
     OclFile["System.out"].println("Minimum number of cells" + "=" + minCells(mat, m, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package c_2015 ;
import java.util.Scanner ;
public class C {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int kases=in.nextInt();
    for(int kas=1 ; kas<=kases ; kas++){
      int C=in.nextInt();
      int D=in.nextInt();
      int V=in.nextInt();
      if(kas==31){
        C=C ;
      }
      long max=0 ;
      int added=0 ;
      for(int i=0 ; i<D ; i++){
        long coin=in.nextLong();
        while(max+1<coin){
          max+=C*(max+1);
          added++;
        }
        max+=C*coin ;
      }
      while(max<V){
        max+=C*(max+1);
        added++;
      }
      System.out.println("Case #"+kas+": "+added);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var kases : int ; kases := in.getCurrent()->toInteger() ;
         var kas : int ; kas := 1 ; while kas <= kases do ( (     var C : int ; C := in.getCurrent()->toInteger() ;
     var D : int ; D := in.getCurrent()->toInteger() ;
    var V : int ; V := in.getCurrent()->toInteger() ;
    if (kas = 31) then (     C := C ) else skip ; 
    var max : long ; max := 0 ;
    var added : int ; added := 0 ;
        var i : int ; i := 0 ; while i < D do ( (     var coin : long ; coin := in.getCurrent()->toLong() ;
     while (max + 1 < coin) do (     max := max+(C * (max + 1)) ; 
     added := added + 1 ) ; 
     max := max+(C * coin) )  ;     i := i + 1 ) ; 
    while (max < V) do (     max := max+(C * (max + 1)) ; 
     added := added + 1 ) ; 
    OclFile["System.out"].println("Case #" + kas + ": " + added) ; 
 )  ;     kas := kas + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class Main {
  public static Scanner input=new Scanner(System.in);
  public static void main(String[] args){
    int t=input.nextInt();
    ArrayList<Integer>ar ;
    int count ;
    int n,m ;
    int am[];
    while(t>0){
      count=0 ;
      n=input.nextInt();
      m=input.nextInt();
      ar=new ArrayList<>();
      am=new int[m];
      for(int i=0 ; i<n ; i++){
        ar.add(input.nextInt());
      }
      for(int i=0 ; i<m ; i++){
        am[i]=input.nextInt();
        if(ar.contains(am[i])){
          count++;
        }
      }
      System.out.println(count);
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute input : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := input.getCurrent()->toInteger() ;
     var ar : Sequence(int) ;
    var count : int ;
    var n : int ;
    var m : int ;
    var am : Sequence(int) ;
    while (t > 0) do (     count := 0 ; 
     n := input.getCurrent()->toInteger() ; 
    m := input.getCurrent()->toInteger() ; 
    ar := Sequence{} ; 
    am := Integer.subrange(1,m)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     ar := ar->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     am[i+1] := input.getCurrent()->toInteger() ; 
     if (ar->includes(am[i+1])) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    t := t - 1 ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round1c ;
import java.io.BufferedOutputStream ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Kattio extends PrintWriter {
  public Kattio(InputStream i){
    super(new BufferedOutputStream(System.out));
    r=new BufferedReader(new InputStreamReader(i));
  }
  public Kattio(InputStream i,OutputStream o){
    super(new BufferedOutputStream(o));
    r=new BufferedReader(new InputStreamReader(i));
  }
  public boolean hasMoreTokens(){
    return peekToken()!=null ;
  }
  public int getInt(){
    return Integer.parseInt(nextToken());
  }
  public double getDouble(){
    return Double.parseDouble(nextToken());
  }
  public long getLong(){
    return Long.parseLong(nextToken());
  }
  public String getWord(){
    return nextToken();
  }
  private BufferedReader r ;
  private String line ;
  private StringTokenizer st ;
  private String token ;
  private String peekToken(){
    if(token==null)try {
      while(st==null || ! st.hasMoreTokens()){
        line=r.readLine();
        if(line==null)return null ;
        st=new StringTokenizer(line);
      }
      token=st.nextToken();
    }
    catch(IOException e){
    }
    return token ;
  }
  private String nextToken(){
    String ans=peekToken();
    token=null ;
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Kattio extends OclFile {
   static operation newKattio( i : OclFile) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(i);
    return self );
  operation initialise( i : OclFile) : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(i)) );
   static operation newKattio( i : OclFile, o : OclFile) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(i, o);
    return self );
  operation initialise( i : OclFile, o : OclFile) : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Write(o)) ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(i)) );
   operation hasMoreTokens() : boolean
  pre: true
  post: true
  activity: (     return peekToken() /= null );
   operation getInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation getDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
   operation getLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation getWord() : String
  pre: true
  post: true
  activity: (     return nextToken() );
   attribute r : OclFile;
   attribute line : String;
   attribute st : OclIterator;
   attribute token : String;
   operation peekToken() : String
  pre: true
  post: true
  activity: (     if (token = null) then     try (     while (st = null or not(st.hasNext())) do (     line := r.readLine() ; 
     if (line = null) then     return null else skip ; 
     st := OclIterator.newOclIterator_String(line) ) ; 
     token := st.next() )   catch (e : IOException) do skip
 else skip ; 
     return token );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     var ans : String ; ans := peekToken() ;
     token := null ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class SolutionD {
  static Scanner scan=new Scanner(System.in);
  static PrintStream out=System.out ;
  private static boolean doable(TreeSet<Long>demo,long C,long value){
    Iterator iter=demo.descendingIterator();
    while(iter.hasNext()){
      long d=(Long)(iter.next());
      if(value % d==0 && value/d<=C)return true ;
      value-=Math.min(value/d,C)*d ;
    }
    return false ;
  }
  private static void solve(){
    long C=scan.nextLong(),D=scan.nextLong(),V=scan.nextLong();
    TreeSet<Long>demo=new TreeSet<Long>();
    for(int i=0 ; i<D ; ++i)demo.add(scan.nextLong());
    long value=1 ;
    while(value<=V){
      if(demo.contains(value)){
        value=value*(C+1);
      }
      else if(! doable(demo,C,value)){
        demo.add(value);
        value=value*(C+1);
      }
      else {
        long sum=0 ;
        for(long t : demo){
          if(t<=value)sum+=C*t ;
        }
        value=Math.max(value+1,sum);
      }
    }
    out.println(demo.size()-D);
  }
  public static void main(String[] args){
    int T=scan.nextInt();
    for(int i=1 ; i<=T ; ++i){
      System.out.print("Case #"+i+": ");
      solve();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SolutionD {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile["System.out"];
  static   operation doable( demo : Set(long), C : long, value : long) : boolean
  pre: true
  post: true
  activity: (     var iter : OclIterator ; iter := demo.descendingIterator() ;
     while (iter.hasNext()) do (     var d : long ; d := (iter.next())->oclAsType(long) ;
     if (value mod d = 0 & value / d <= C) then     return true else skip ; 
     value := value-(Set{value / d, C}->min() * d) ) ; 
     return false );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var C : long ; C := scan.getCurrent()->toLong() ;
    var D : long ; D := scan.getCurrent()->toLong() ;
    var V : long ; V := scan.getCurrent()->toLong() ;
     var demo : Set(long) ; demo := Set{} ;
        var i : int ; i := 0 ; while i < D do (     demo := demo->including(scan.getCurrent()->toLong()) ;  ;     i := i + 1 ) ; 
    var value : long ; value := 1 ;
    while (value <= V) do (     if (demo->includes(value)) then (     value := value * (C + 1) ) else     if (not(doable(demo, C, value))) then (     demo := demo->including(value) ; 
     value := value * (C + 1) ) else (     var sum : long ; sum := 0 ;
     for (t : demo) do ( (     if (t <= value) then     sum := sum+(C * t) ; else skip )  ) ; 
     value := Set{value + 1, sum}->max() ) ;  ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := scan.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= T do ( (     OclFile["System.out"].print("Case #" + i + ": ") ; 
     execute solve() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.util.LinkedList ;
public class LessMoneyMoreProblems {
  public static void main(String[] args)throws NumberFormatException,IOException {
    FileReader input=new FileReader(args[0]);
    BufferedReader buffer=new BufferedReader(input);
    int max=Integer.parseInt(buffer.readLine().trim());
    for(int i=1 ; i<=max ; i++){
      System.out.println("Case #"+i+": "+solve(buffer));
    }
  }
  public static long solve(BufferedReader buffer)throws NumberFormatException,IOException {
    String[] split=buffer.readLine().trim().split("\\s+");
    long C=Long.parseLong(split[0]);
    int D=Integer.parseInt(split[1]);
    long V=Long.parseLong(split[2]);
    String[] sCoins=buffer.readLine().trim().split("\\s+");
    long[] coins=new long[D];
    for(int i=0 ; i<D ; i++){
      coins[i]=Long.parseLong(sCoins[i]);
    }
    int index=0 ;
    long current=0 ;
    long count=0 ;
    while(current<V){
      if(index<D && coins[index]<=current+1){
        current+=C*coins[index];
        index++;
      }
      else {
        current+=C*(current+1);
        count++;
      }
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class LessMoneyMoreProblems {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(args[0+1]) ;
     var buffer : OclFile ; buffer := OclFile.newOclFile_Read(input) ;
     var max : int ; max := (buffer.readLine()->trim())->toInteger() ;
         var i : int ; i := 1 ; while i <= max do ( (     OclFile["System.out"].println("Case #" + i + ": " + solve(buffer)) )  ;     i := i + 1 ) );
  static   operation solve( buffer : OclFile) : long
  pre: true
  post: true
  activity: (     var split : Sequence(String) ; split := buffer.readLine()->trim()->split("\\s+") ;
     var C : long ; C := (split[0+1])->toLong() ;
    var D : int ; D := (split[1+1])->toInteger() ;
    var V : long ; V := (split[2+1])->toLong() ;
    var sCoins : Sequence(String) ; sCoins := buffer.readLine()->trim()->split("\\s+") ;
    var coins : Sequence(long) ; coins := Integer.subrange(1,D)->collect(0) ;
        var i : int ; i := 0 ; while i < D do ( (     coins[i+1] := (sCoins[i+1])->toLong() )  ;     i := i + 1 ) ; 
    var index : int ; index := 0 ;
    var current : long ; current := 0 ;
    var count : long ; count := 0 ;
    while (current < V) do (     if (index < D & coins[index+1] <= current + 1) then (     current := current+(C * coins[index+1]) ; 
     index := index + 1 ) else (     current := current+(C * (current + 1)) ; 
     count := count + 1 ) ) ; 
    return count 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedWriter ;
import java.io.FileInputStream ;
import java.io.FileNotFoundException ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Locale ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try {
      Scanner scanner=new Scanner(new FileInputStream("input.txt"));
      scanner.useLocale(Locale.ENGLISH);
      BufferedWriter out=new BufferedWriter(new FileWriter("output1.txt"));
      int tests=scanner.nextInt();
      for(int i=0 ; i<tests ; i++){
        long c=scanner.nextLong();
        int d=scanner.nextInt();
        long v=scanner.nextLong();
        long[] values=new long[d];
        for(int j=0 ; j<d ; j++){
          values[j]=scanner.nextLong();
        }
        long result=0 ;
        long netWorth=0 ;
        int j=0 ;
        while(netWorth<v){
          if(j<values.length && values[j]<=netWorth+1){
            netWorth+=c*values[j];
            j++;
          }
          else {
            netWorth+=c*(netWorth+1);
            result++;
          }
        }
        out.write("Case #"+(i+1)+": "+result+"\n");
        out.flush();
      }
      out.close();
    }
    catch(FileNotFoundException e){
    }
    catch(IOException e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ;
     skip ; 
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output1.txt"))) ;
    var tests : int ; tests := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < tests do ( (     var c : long ; c := scanner.getCurrent()->toLong() ;
     var d : int ; d := scanner.getCurrent()->toInteger() ;
    var v : long ; v := scanner.getCurrent()->toLong() ;
    var values : Sequence(long) ; values := Integer.subrange(1,d)->collect(0) ;
        var j : int ; j := 0 ; while j < d do ( (     values[j+1] := scanner.getCurrent()->toLong() )  ;     j := j + 1 ) ; 
    var result : long ; result := 0 ;
    var netWorth : long ; netWorth := 0 ;
    var j : int ; j := 0 ;
    while (netWorth < v) do (     if (j < values->size() & values[j+1] <= netWorth + 1) then (     netWorth := netWorth+(c * values[j+1]) ; 
     j := j + 1 ) else (     netWorth := netWorth+(c * (netWorth + 1)) ; 
     result := result + 1 ) ) ; 
    skip ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 )   catch (e : FileNotFoundException) do skip
   catch (e : IOException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long N,K ;
    N=sc.nextLong();
    K=sc.nextLong();
    long a,b ;
    a=N/K ;
    long ans ;
    ans=a*a*a ;
    if(K % 2L==0L){
      b=(N+K/2L)/K ;
      ans+=b*b*b ;
    }
    System.out.println(ans);
  }
  public static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ;
    var K : long ;
    N := sc.getCurrent()->toLong() ; 
    K := sc.getCurrent()->toLong() ; 
    var a : long ;
    var b : long ;
    a := N / K ; 
    var ans : long ;
    ans := a * a * a ; 
    if (K mod 2L = 0L) then (     b := (N + K / 2L) / K ; 
     ans := ans+(b * b * b) ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A1085 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));
    String str=in.next();
    char[] ch=str.toCharArray();
    ArrayDeque<Character>dq=new ArrayDeque<>();
    ArrayList<Character>res=new ArrayList<>();
    for(char c : ch)dq.add(c);
    for(int i=0 ; i<ch.length ; i++){
      if(str.length()% 2!=0){
        if(i % 2==0)res.add(dq.pollFirst());
        else res.add(dq.pollLast());
      }
      else {
        if(i % 2==0)res.add(dq.pollLast());
        else res.add(dq.pollFirst());
      }
    }
    Collections.reverse(res);
    for(char c : res)pw.print(c);
    pw.println();
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1085 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var str : String ; str := in.getCurrent() ;
    var ch : Sequence(String) ; ch := str->characters() ;
    var dq : Sequence(String) ; dq := ArrayDeque<OclAny>.newArrayDeque() ;
    var res : Sequence(String) ; res := Sequence{} ;
    for (c : ch) do (     dq := dq->including(c) ;  ) ; 
        var i : int ; i := 0 ; while i < ch->size() do ( (     if (str->size() mod 2 /= 0) then (     if (i mod 2 = 0) then     res := res->including(dq->first()) ; else     res := res->including(dq->last()) ; ) else (     if (i mod 2 = 0) then     res := res->including(dq->last()) ; else     res := res->including(dq->first()) ; ) )  ;     i := i + 1 ) ; 
    res := res->reverse() ; 
    for (c : res) do (     skip ;  ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(1,in,out);
    out.close();
  }
  static class Task {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int N=in.nextInt();
      int K=in.nextInt();
      long a=N/K ;
      long b=K % 2==0 ?(N+K/2)/K : 0 ;
      long ans=(long)(Math.pow(a,3)+Math.pow(b,3));
      out.println(ans);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.nextInt() ;
     var K : int ; K := in.nextInt() ;
    var a : long ; a := N / K ;
    var b : long ; b := if K mod 2 = 0 then (N + K / 2) / K else 0 endif ;
    var ans : long ; ans := (a->pow(3) + b->pow(3))->oclAsType(long) ;
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str[]=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int k=Integer.parseInt(str[1]);
    long num[]=new long[k];
    for(int i=1 ; i<=n ; i++){
      num[i % k]++;
    }
    long res=0 ;
    for(int a=0 ; a<k ; ++a){
      int b=(k-a)% k ;
      int c=(k-a)% k ;
      if((b+b)% k!=0)continue ;
      res+=num[a]*num[b]*num[b];
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var k : int ; k := (str[1+1])->toInteger() ;
    var num : Sequence(long) ; num := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     num[i mod k+1] := num[i mod k+1] + 1 )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
        var a : int ; a := 0 ; while a < k do ( (     var b : int ; b := (k - a) mod k ;
     var c : int ; c := (k - a) mod k ;
     if ((b + b) mod k /= 0) then     continue else skip ; 
     res := res+(num[a+1] * num[b+1] * num[b+1]) )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    long N=gl();
    long K=gl();
    long ans=0 ;
    if(K % 2==0){
      long a=Math.floorDiv(N,K/2);
      if(a % 2==0){
        ans+=(Math.pow(a/2,3))*2 ;
      }
      else {
        ans+=(Math.pow((a-1)/2,3)+Math.pow((a+1)/2,3));
      }
    }
    else {
      ans+=Math.pow(Math.floorDiv(N,K),3);
    }
    System.out.print(ans);
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : long ; N := gl() ;
    var K : long ; K := gl() ;
    var ans : long ; ans := 0 ;
    if (K mod 2 = 0) then (     var a : long ; a := floorDiv(N, K / 2) ;
     if (a mod 2 = 0) then (     ans := ans+((a / 2->pow(3)) * 2) ) else (     ans := ans+(((a - 1) / 2->pow(3) + (a + 1) / 2->pow(3))) ) ) else (     ans := ans+(floorDiv(N, K)->pow(3)) ) ;  
    OclFile["System.out"].print(ans) ; 
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int max=cin.nextInt();
    int mul=cin.nextInt();
    if(mul % 2==0){
      int start=mul/2 ;
      int time=max/start ;
      long res=0 ;
      if(time % 2==0){
        res=(long)Math.pow((time/2),3)*2 ;
      }
      else {
        res=(long)Math.pow(time/2+1,3)+(long)Math.pow(time/2,3);
      }
      if(res<=Integer.MAX_VALUE)System.out.println((int)res);
      else System.out.println(res);
    }
    else {
      int time=max/mul ;
      long res=(long)Math.pow(time,3);
      if(res<=Integer.MAX_VALUE)System.out.println((int)res);
      else System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var max : int ; max := cin.getCurrent()->toInteger() ;
     var mul : int ; mul := cin.getCurrent()->toInteger() ;
     if (mul mod 2 = 0) then (     var start : int ; start := mul / 2 ;
     var time : int ; time := max / start ;
    var res : long ; res := 0 ;
    if (time mod 2 = 0) then (     res := (time / 2)->pow(3)->oclAsType(long) * 2 ) else (     res := time / 2 + 1->pow(3)->oclAsType(long) + time / 2->pow(3)->oclAsType(long) ) ;  
    if (res <= 2147483647) then     OclFile["System.out"].println(res->oclAsType(int)) else     OclFile["System.out"].println(res) ; ;  
 ) else (     var time : int ; time := max / mul ;
     var res : long ; res := time->pow(3)->oclAsType(long) ;
     if (res <= 2147483647) then     OclFile["System.out"].println(res->oclAsType(int)) ; else     OclFile["System.out"].println(res) ; ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GCD {
  static int totalPrimeFactors(int n){
    int count=0 ;
    if((n % 2==0)){
      count++;
      while((n % 2==0))n/=2 ;
    }
    for(int i=3 ; i*i<=n ; i=i+2){
      if((n % i==0))count++;
      while((n % i==0))n/=2 ;
    }
    if(n>2)count++;
    return count ;
  }
  static int countPairs(int G,int L){
    if(L % G!=0)return 0 ;
    int div=L/G ;
    return(1<<totalPrimeFactors(div));
  }
  public static void main(String[] args){
    int G=2,L=12 ;
    System.out.print("Total possible pair with GCD "+G);
    System.out.print(" & LCM "+L);
    System.out.print("="+countPairs(G,L));
  }
}
------------------------------------------------------------
OCL File:
---------
class GCD {
  static   operation totalPrimeFactors( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     if ((n mod 2 = 0)) then (     count := count + 1 ; 
     while ((n mod 2 = 0)) do     n := n/(2) ; ) else skip ; 
        var i : int ; i := 3 ; while i * i <= n do ( (     if ((n mod i = 0)) then     count := count + 1 ; else skip ; 
     while ((n mod i = 0)) do     n := n/(2) ; )  ;     i := i + 2 ) ; 
    if (n > 2) then     count := count + 1 ; else skip ; 
    return count 
 );
  static   operation countPairs( G : int, L : int) : int
  pre: true
  post: true
  activity: (     if (L mod G /= 0) then     return 0 else skip ; 
     var div : int ; div := L / G ;
     return ((1*(2->pow(totalPrimeFactors(div))))->oclAsType(long)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var G : int ; G := 2 ;
    var L : int ; L := 12 ;
     OclFile["System.out"].print("Total possible pair with GCD " + G) ; 
     OclFile["System.out"].print(" & LCM " + L) ; 
     OclFile["System.out"].print("=" + countPairs(G, L)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  static boolean isPrime(int n){
    if(n % 2==0)return false ;
    for(int i=3 ; i<=Math.sqrt(n); i+=2){
      if(n % i==0)return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    if(isPrime(19))System.out.println(" true");
    else System.out.println(" false");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n mod 2 = 0) then     return false else skip ; 
         var i : int ; i := 3 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then     return false else skip )  ;     i := i+(2) ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (isPrime(19)) then     OclFile["System.out"].println(" true") ; else     OclFile["System.out"].println(" false") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isPrime(int n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  public static void main(String args[]){
    if(isPrime(11))System.out.println(" true");
    else System.out.println(" false");
    if(isPrime(15))System.out.println(" true");
    else System.out.println(" false");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (isPrime(11)) then     OclFile["System.out"].println(" true") else     OclFile["System.out"].println(" false") ; ;  
     if (isPrime(15)) then     OclFile["System.out"].println(" true") ; else     OclFile["System.out"].println(" false") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPrime(int n){
    if(n<=1)return false ;
    for(int i=2 ; i<n ; i++)if(n % i==0)return false ;
    return true ;
  }
  public static void main(String args[]){
    if(isPrime(11))System.out.println(" true");
    else System.out.println(" false");
    if(isPrime(15))System.out.println(" true");
    else System.out.println(" false");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
         var i : int ; i := 2 ; while i < n do (     if (n mod i = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (isPrime(11)) then     OclFile["System.out"].println(" true") else     OclFile["System.out"].println(" false") ; ;  
     if (isPrime(15)) then     OclFile["System.out"].println(" true") ; else     OclFile["System.out"].println(" false") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] a=new int[n];
    int[] v=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    for(int i=0 ; i<m ; i++){
      int b=sc.nextInt();
      for(int j=0 ; j<n ; j++){
        if(a[j]<=b){
          v[j]++;
          break ;
        }
      }
    }
    int maxi=-1 ;
    int max=0 ;
    for(int i=0 ; i<n ; i++){
      if(v[i]>max){
        maxi=i ;
        max=v[i];
      }
    }
    System.out.println(maxi+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var b : int ; b := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < n do ( (     if (a[j+1] <= b) then (     v[j+1] := v[j+1] + 1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var maxi : int ; maxi := -1 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (v[i+1] > max) then (     maxi := i ; 
     max := v[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(maxi + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    int[] a=new int[n],b=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    for(int i=0 ; i<m ; i++){
      int c=sc.nextInt();
      for(int j=0 ; j<n ; j++)if(a[j]<=c){
        b[j]++;
        break ;
      }
    }
    int ans=-1 ;
    for(int i=0 ; i<n ; i++){
      if(ans<0 || b[ans]<b[i]){
        ans=i ;
      }
    }
    System.out.println(ans+1);
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var c : int ; c := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < n do (     if (a[j+1] <= c) then (     b[j+1] := b[j+1] + 1 ; 
     break ) else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (ans < 0 or b[ans+1] < b[i+1]) then (     ans := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans + 1) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public void vote(int[][] sn,int[] ol){
    for(int i=0 ; i<ol.length ; i++){
      for(int j=0 ; j<sn.length ; j++){
        if(ol[i]>=sn[j][0]){
          sn[j][1]++;
          break ;
        }
      }
    }
  }
  public int max(int[][] sn){
    int max=sn[0][1];
    int maxn=1 ;
    for(int i=0 ; i<sn.length ; i++){
      if(max<sn[i][1]){
        max=sn[i][1];
        maxn=i+1 ;
      }
    }
    return maxn ;
  }
  void doIt(){
    Scanner sc=new Scanner(System.in);
    int i ;
    int s=sc.nextInt();
    int o=sc.nextInt();
    int[][] sn=new int[s][2];
    int[] ol=new int[o];
    for(i=0 ; i<s ; i++){
      int m=sc.nextInt();
      sn[i][0]=m ;
      sn[i][1]=0 ;
    }
    for(i=0 ; i<o ; i++){
      int e=sc.nextInt();
      ol[i]=e ;
    }
    vote(sn,ol);
    System.out.printf("%d\n",max(sn));
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation vote( sn : Sequence(Sequence(int)), ol : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < ol->size() do ( (         var j : int ; j := 0 ; while j < sn->size() do ( (     if (ol[i+1] >= sn[j+1][0+1]) then (     sn[j+1][1+1] := sn[j+1][1+1] + 1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
   operation max( sn : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var max : int ; max := sn[0+1][1+1] ;
     var maxn : int ; maxn := 1 ;
         var i : int ; i := 0 ; while i < sn->size() do ( (     if (max < sn[i+1][1+1]) then (     max := sn[i+1][1+1] ; 
     maxn := i + 1 ) else skip )  ;     i := i + 1 ) ; 
     return maxn );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var o : int ; o := sc.getCurrent()->toInteger() ;
    var sn : Sequence(Sequence(int)) ; sn := Integer.subrange(1,s)->collect(Integer.subrange(1,2)->collect(0)) ;
    var ol : Sequence(int) ; ol := Integer.subrange(1,o)->collect(0) ;
        i := 0 ; while i < s do ( (     var m : int ; m := sc.getCurrent()->toInteger() ;
     sn[i+1][0+1] := m ; 
     sn[i+1][1+1] := 0 )  ;     i := i + 1 ) ; 
        i := 0 ; while i < o do ( (     var e : int ; e := sc.getCurrent()->toInteger() ;
     ol[i+1] := e )  ;     i := i + 1 ) ; 
    execute vote(sn, ol) ; 
    OclFile["System.out"].printf("%d\n", Set{sn}->max()) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next(),ans="" ;
    int len=s.length();
    if(len % 2==0){
      int left=len/2-1,right=left+2 ;
      ans=s.substring(left,right);
      while(left>0){
        left--;
        ans=ans+s.charAt(left);
        ans=ans+s.charAt(right);
        right++;
      }
    }
    else {
      int left=len/2,right=left+1 ;
      ans=s.substring(left,right);
      while(left>0){
        ans=ans+s.charAt(right);
        right++;
        left--;
        ans=ans+s.charAt(left);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var ans : String ; ans := "" ;
    var len : int ; len := s->size() ;
    if (len mod 2 = 0) then (     var left : int ; left := len / 2 - 1 ;
    var right : int ; right := left + 2 ;
     ans := s.subrange(left+1,right) ; 
     while (left > 0) do (     left := left - 1 ; 
     ans := ans + s->at(left+1) ; 
     ans := ans + s->at(right+1) ; 
     right := right + 1 ) ) else (     var left : int ; left := len / 2 ;
    var right : int ; right := left + 1 ;
     ans := s.subrange(left+1,right) ; 
     while (left > 0) do (     ans := ans + s->at(right+1) ; 
     right := right + 1 ; 
     left := left - 1 ; 
     ans := ans + s->at(left+1) ) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.Map.Entry ;
import java.util.Scanner ;
import java.util.TreeMap ;
import java.util.stream.IntStream ;
public class Main {
  static final Scanner s=new Scanner(System.in);
  static IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static IntStream REPS(int l,int r){
    return IntStream.rangeClosed(l,r);
  }
  static IntStream INS(int n){
    return REPS(n).map(i->getInt());
  }
  static int getInt(){
    return Integer.parseInt(s.next());
  }
  public static void main(String[] $){
    int n=getInt(),m=getInt();
    TreeMap<Integer,Integer>t=new TreeMap<>();
    HashMap<Integer,Integer>r=new HashMap<>();
    REPS(n).forEach(i->t.merge(getInt()-1,i+1,Math :: min));
    INS(m).mapToObj(t :: headMap).map(o->o.values().stream().min(Comparator.naturalOrder()).get()).forEach(i->r.merge(i,1,Integer :: sum));
    System.out.println(r.entrySet().stream().max(Entry.comparingByValue()).get().getKey());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static   operation REPS( l : int, r : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(l, r) );
  static   operation INS( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return REPS(n)->collect( _x1 | (lambda i : OclAny in getInt())->apply(_x1) ) );
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := getInt() ;
    var m : int ; m := getInt() ;
     var t : Map(int,int) ; t := Map{} ;
    var r : Map(int,int) ; r := Map{} ;
    for i : REPS(n) do
    (    t := t.merge(getInt() - 1, i + 1, lambda _pars : OclAny in Math.newMath().min(_pars))) ; 
    for i : INS(m).mapToObj(lambda _pars : OclAny in t.newt().headMap(_pars))->collect( _x1 | (lambda o : OclAny in o.allInstances()->min().get())->apply(_x1) ) do
    (    r := r.merge(i, 1, lambda _pars : OclAny in Integer.newInteger().sum(_pars))) ; 
    OclFile["System.out"].println(r->asSet()->max().get().getKey()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int[] Competition ;
  static int[] Member ;
  static int[] Voting ;
  static void MemberStandard(int std,int Competition_num){
    for(int r=0 ; r<Competition_num ; r++){
      if(Competition[r]<=std){
        Voting[r]++;
        break ;
      }
    }
  }
  static int MaxVotedIdx(int Competition_num){
    int max=Voting[0];
    int idx=0 ;
    for(int r=1 ; r<Competition_num ; r++)if(Voting[r]>max){
      max=Voting[r];
      idx=r ;
    }
    return(idx+1);
  }
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    final int Competition_num=stdIn.nextInt();
    final int Member_num=stdIn.nextInt();
    Competition=new int[Competition_num];
    for(int r=0 ; r<Competition_num ; r++)Competition[r]=stdIn.nextInt();
    Member=new int[Member_num];
    Voting=new int[Competition_num];
    for(int r=0 ; r<Member_num ; r++){
      Member[r]=stdIn.nextInt();
      MemberStandard(Member[r],Competition_num);
    }
    System.out.println(MaxVotedIdx(Competition_num));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute Competition : Sequence(int);
  static   attribute Member : Sequence(int);
  static   attribute Voting : Sequence(int);
  static   operation MemberStandard( std : int, Competition_num : int) : void
  pre: true
  post: true
  activity: (         var r : int ; r := 0 ; while r < Competition_num do ( (     if (Competition[r+1] <= std) then (     Voting[r+1] := Voting[r+1] + 1 ; 
     break ) else skip )  ;     r := r + 1 ) );
  static   operation MaxVotedIdx( Competition_num : int) : int
  pre: true
  post: true
  activity: (     var max : int ; max := Voting[0+1] ;
     var idx : int ; idx := 0 ;
         var r : int ; r := 1 ; while r < Competition_num do (     if (Voting[r+1] > max) then (     max := Voting[r+1] ; 
     idx := r ) else skip ;  ;     r := r + 1 ) ; 
     return (idx + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var Competition_num : int ; Competition_num := stdIn.getCurrent()->toInteger() ;
    var Member_num : int ; Member_num := stdIn.getCurrent()->toInteger() ;
    Competition := Integer.subrange(1,Competition_num)->collect(0) ; 
        var r : int ; r := 0 ; while r < Competition_num do (     Competition[r+1] := stdIn.getCurrent()->toInteger() ;  ;     r := r + 1 ) ; 
    Member := Integer.subrange(1,Member_num)->collect(0) ; 
    Voting := Integer.subrange(1,Competition_num)->collect(0) ; 
        var r : int ; r := 0 ; while r < Member_num do ( (     Member[r+1] := stdIn.getCurrent()->toInteger() ; 
     execute MemberStandard(Member[r+1], Competition_num) )  ;     r := r + 1 ) ; 
    OclFile["System.out"].println(MaxVotedIdx(Competition_num)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isToOne(int n){
    return(n>0);
  }
  public static void main(String[] args){
    int n=5 ;
    if(isToOne(n)==true)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isToOne( n : int) : boolean
  pre: true
  post: true
  activity: (     return (n > 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     if (isToOne(n) = true) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static final int MOD=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a=Long.parseLong(sc.next());
    long b=Long.parseLong(sc.next());
    long c=Long.parseLong(sc.next());
    long d=Long.parseLong(sc.next());
    long ans=a*c ;
    ans=Math.max(ans,a*d);
    ans=Math.max(ans,b*c);
    ans=Math.max(ans,b*d);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := (sc.getCurrent())->toLong() ;
    var b : long ; b := (sc.getCurrent())->toLong() ;
    var c : long ; c := (sc.getCurrent())->toLong() ;
    var d : long ; d := (sc.getCurrent())->toLong() ;
    var ans : long ; ans := a * c ;
    ans := Set{ans, a * d}->max() ; 
    ans := Set{ans, b * c}->max() ; 
    ans := Set{ans, b * d}->max() ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  private static int rows,cols ;
  private static int[][] matrix ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    rows=in.nextInt();
    cols=in.nextInt();
    matrix=new int[rows][cols+1];
    for(int r=0 ; r<rows ; r++){
      for(int c=1 ; c<=cols ; c++){
        matrix[r][c]=in.nextInt();
      }
    }
    solve();
  }
  private static void solve(){
    int xor=0 ;
    for(int r=rows-1 ; r>=0 ; r--)xor ^=matrix[r][1];
    if(xor>0){
      System.out.println("TAK");
      System.out.println(buildIndexes(0,1));
      return ;
    }
    for(int r=rows-1 ; r>=0 ; r--){
      for(int c=cols ; c>1 ; c--){
        if(matrix[r][c]!=matrix[r][1]){
          System.out.println("TAK");
          System.out.println(buildIndexes(r,c));
          return ;
        }
      }
    }
    System.out.println("NIE");
  }
  private static String buildIndexes(int r,int c){
    StringBuilder line=new StringBuilder();
    for(int i=0 ; i<r ; i++)line.append(1).append(" ");
    line.append(c).append(" ");
    for(int i=r+1 ; i<rows ; i++)line.append(1).append(" ");
    return line.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute rows : int;
  static   attribute matrix : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     rows := in.getCurrent()->toInteger() ; 
    cols := in.getCurrent()->toInteger() ; 
    matrix := Integer.subrange(1,rows)->collect(Integer.subrange(1,cols + 1)->collect(0)) ; 
        var r : int ; r := 0 ; while r < rows do ( (         var c : int ; c := 1 ; while c <= cols do ( (     matrix[r+1][c+1] := in.getCurrent()->toInteger() )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    execute solve() ; 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var xor : int ; xor := 0 ;
         var r : int ; r := rows - 1 ; while r >= 0 do (     xor := MathLib.bitwiseXor(xor,matrix[r+1][1+1]) ;  ;     r := r - 1 ) ; 
    if (xor > 0) then (     OclFile["System.out"].println("TAK") ; 
     OclFile["System.out"].println(buildIndexes(0, 1)) ; 
     return ) else skip ; 
        var r : int ; r := rows - 1 ; while r >= 0 do ( (         var c : int ; c := cols ; while c > 1 do ( (     if (matrix[r+1][c+1] /= matrix[r+1][1+1]) then (     OclFile["System.out"].println("TAK") ; 
     OclFile["System.out"].println(buildIndexes(r, c)) ; 
     return ) else skip )  ;     c := c - 1 ) )  ;     r := r - 1 ) ; 
    OclFile["System.out"].println("NIE") ; 
 );
  static   operation buildIndexes( r : int, c : int) : String
  pre: true
  post: true
  activity: (     var line : String ; line := StringLib.newString() ;
         var i : int ; i := 0 ; while i < r do (     line := line + StringLib.newString(1) + StringLib.newString(" ") ;  ;     i := i + 1 ) ; 
    line := line + StringLib.newString(c) + StringLib.newString(" ") ; 
        var i : int ; i := r + 1 ; while i < rows do (     line := line + StringLib.newString(1) + StringLib.newString(" ") ;  ;     i := i + 1 ) ; 
    return line+"" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int anagram_pairs(String[] s,int n){
    Map<String,Integer>mp=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      char[] chArr=s[i] .toCharArray();
      Arrays.sort(chArr);
      s[i]=new String(chArr);
      if(mp.containsKey(s[i])){
        mp.put(s[i],mp.get(s[i])+1);
      }
      else {
        mp.put(s[i],1);
      }
    }
    int ans=0 ;
    for(Map.Entry<String,Integer>i : mp.entrySet()){
      int k=i.getValue();
      ans+=(k*(k-1))/2 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    String[] s={
      "aaab","aaba","baaa","cde","dec" };
      int n=s.length ;
      System.out.println(anagram_pairs(s,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation anagram_pairs( s : Sequence(String), n : int) : int
  pre: true
  post: true
  activity: (     var mp : Map(String,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     var chArr : Sequence(String) ; chArr := s[i+1]->characters() ;
     chArr := chArr->sort() ; 
     s[i+1] := StringLib.newString(chArr) ; 
     if (mp->keys()->includes(s[i+1])) then (     mp := mp->union(Map{s[i+1] |-> mp->at(s[i+1]) + 1}) ) else (     mp := mp->union(Map{s[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (i : mp->asSet()) do ( (     var k : int ; k := i.getValue() ;
     ans := ans+((k * (k - 1)) / 2) )  ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := Sequence{"aaab","aaba","baaa","cde","dec"} ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].println(anagram_pairs(s, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.StringTokenizer ;
public class CodeforcesA {
  public static void main(String[] args){
    FastReader read=new FastReader();
    int t=read.nextInt();
    StringBuilder ans=new StringBuilder();
    HashMap<String,String>graph=new HashMap<>();
    while(t-->0){
      String from=read.next();
      String to=read.next();
      if(graph.size()==0){
        graph.put(from,to);
      }
      else {
        boolean foundNbr=false ;
        for(String parent : graph.keySet()){
          String child=graph.get(parent);
          if(child.equals(from)){
            graph.put(parent,to);
            foundNbr=true ;
            break ;
          }
        }
        if(! foundNbr)graph.put(from,to);
      }
    }
    ans.append(graph.size()).append("\n");
    for(String key : graph.keySet()){
      ans.append(key).append(" ").append(graph.get(key)).append("\n");
    }
    System.out.print(ans.toString());
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeforcesA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : FastReader ; read := FastReader.newFastReader() ;
     var t : int ; t := read.nextInt() ;
    var ans : String ; ans := StringLib.newString() ;
    var graph : Map(String,String) ; graph := Map{} ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var from : String ; from := read.next() ;
     var to : String ; to := read.next() ;
     if (graph.size() = 0) then (     graph := graph->union(Map{from |-> to}) ) else (     var foundNbr : boolean ; foundNbr := false ;
     for (parent : graph->keys()) do ( (     var child : String ; child := graph->at(parent) ;
     if (child = from) then (     graph := graph->union(Map{parent |-> to}) ; 
     foundNbr := true ; 
     break ) else skip )  ) ; 
     if (not(foundNbr)) then     graph := graph->union(Map{from |-> to}) ; else skip ) ) ;  ) ;  
    ans := ans + StringLib.newString(graph.size()) + StringLib.newString("\n") ; 
    for (key : graph->keys()) do ( (     ans := ans + StringLib.newString(key) + StringLib.newString(" ") + StringLib.newString(graph->at(key)) + StringLib.newString("\n") )  ) ; 
    OclFile["System.out"].print(ans+"") ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.System.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    int n=sc.nextInt();
    String[] old_arr=new String[n];
    String[] new_arr=new String[n];
    int[] flag=new int[n];
    Map<String,String>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      old_arr[i]=sc.next();
      new_arr[i]=sc.next();
    }
    for(int i=0 ; i<n ; i++){
      String first=old_arr[i];
      String second=new_arr[i];
      if(flag[i]==1)continue ;
      for(int j=i+1 ; j<n ; j++){
        if(second.equals(old_arr[j])){
          second=new_arr[j];
          flag[j]=1 ;
        }
      }
      map.put(first,second);
    }
    out.println(map.size());
    for(String key : map.keySet()){
      System.out.println(key+" "+map.get(key));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var old_arr : Sequence(String) ; old_arr := Integer.subrange(1,n)->collect(null) ;
    var new_arr : Sequence(String) ; new_arr := Integer.subrange(1,n)->collect(null) ;
    var flag : Sequence(int) ; flag := Integer.subrange(1,n)->collect(0) ;
    var map : Map(String,String) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     old_arr[i+1] := sc.getCurrent() ; 
     new_arr[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var first : String ; first := old_arr[i+1] ;
     var second : String ; second := new_arr[i+1] ;
    if (flag[i+1] = 1) then     continue else skip ; 
        var j : int ; j := i + 1 ; while j < n do ( (     if (second = old_arr[j+1]) then (     second := new_arr[j+1] ; 
     flag[j+1] := 1 ) else skip )  ;     j := j + 1 ) ; 
    map := map->union(Map{first |-> second}) ; 
 )  ;     i := i + 1 ) ; 
    out.println(map.size()) ; 
    for (key : map->keys()) do ( (     OclFile["System.out"].println(key + " " + map->at(key)) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int n=in.nextInt();
      int k=in.nextInt();
      int max=Math.max(n,k);
      int min=n+k-max ;
      int x1=in.nextInt();
      int y1=in.nextInt();
      int x2=in.nextInt();
      int y2=in.nextInt();
      if(x1+x2<=max){
        if(Math.max(y1,y2)<=min){
          System.out.println("YES");
          return ;
        }
      }
      if(x1+x2<=min){
        if(Math.max(y1,y2)<=max){
          System.out.println("YES");
          return ;
        }
      }
      if(y1+y2<=max){
        if(Math.max(x1,x2)<=min){
          System.out.println("YES");
          return ;
        }
      }
      if(y1+y2<=min){
        if(Math.max(x1,x2)<=max){
          System.out.println("YES");
          return ;
        }
      }
      if(x1+y2<=max){
        if(Math.max(y1,x2)<=min){
          System.out.println("YES");
          return ;
        }
      }
      if(x1+y2<=min){
        if(Math.max(y1,x2)<=max){
          System.out.println("YES");
          return ;
        }
      }
      if(y1+x2<=max){
        if(Math.max(x1,y2)<=min){
          System.out.println("YES");
          return ;
        }
      }
      if(y1+x2<=min){
        if(Math.max(x1,y2)<=max){
          System.out.println("YES");
          return ;
        }
      }
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var max : int ; max := Set{n, k}->max() ;
    var min : int ; min := n + k - max ;
    var x1 : int ; x1 := in.getCurrent()->toInteger() ;
    var y1 : int ; y1 := in.getCurrent()->toInteger() ;
    var x2 : int ; x2 := in.getCurrent()->toInteger() ;
    var y2 : int ; y2 := in.getCurrent()->toInteger() ;
    if (x1 + x2 <= max) then (     if (Set{y1, y2}->max() <= min) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    if (x1 + x2 <= min) then (     if (Set{y1, y2}->max() <= max) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    if (y1 + y2 <= max) then (     if (Set{x1, x2}->max() <= min) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    if (y1 + y2 <= min) then (     if (Set{x1, x2}->max() <= max) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    if (x1 + y2 <= max) then (     if (Set{y1, x2}->max() <= min) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    if (x1 + y2 <= min) then (     if (Set{y1, x2}->max() <= max) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    if (y1 + x2 <= max) then (     if (Set{x1, y2}->max() <= min) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    if (y1 + x2 <= min) then (     if (Set{x1, y2}->max() <= max) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    OclFile["System.out"].println("NO") ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int n=in.nextInt();
      int k=in.nextInt();
      int max=Math.max(n,k);
      int min=n+k-max ;
      int x1=in.nextInt();
      int y1=in.nextInt();
      int x2=in.nextInt();
      int y2=in.nextInt();
      if(x1+x2<=max){
        if(Math.max(y1,y2)<=min){
          System.out.println("YES");
          return ;
        }
      }
      if(x1+x2<=min){
        if(Math.max(y1,y2)<=max){
          System.out.println("YES");
          return ;
        }
      }
      if(y1+y2<=max){
        if(Math.max(x1,x2)<=min){
          System.out.println("YES");
          return ;
        }
      }
      if(y1+y2<=min){
        if(Math.max(x1,x2)<=max){
          System.out.println("YES");
          return ;
        }
      }
      if(x1+y2<=max){
        if(Math.max(y1,x2)<=min){
          System.out.println("YES");
          return ;
        }
      }
      if(x1+y2<=min){
        if(Math.max(y1,x2)<=max){
          System.out.println("YES");
          return ;
        }
      }
      if(y1+x2<=max){
        if(Math.max(x1,y2)<=min){
          System.out.println("YES");
          return ;
        }
      }
      if(y1+x2<=min){
        if(Math.max(x1,y2)<=max){
          System.out.println("YES");
          return ;
        }
      }
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var max : int ; max := Set{n, k}->max() ;
    var min : int ; min := n + k - max ;
    var x1 : int ; x1 := in.getCurrent()->toInteger() ;
    var y1 : int ; y1 := in.getCurrent()->toInteger() ;
    var x2 : int ; x2 := in.getCurrent()->toInteger() ;
    var y2 : int ; y2 := in.getCurrent()->toInteger() ;
    if (x1 + x2 <= max) then (     if (Set{y1, y2}->max() <= min) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    if (x1 + x2 <= min) then (     if (Set{y1, y2}->max() <= max) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    if (y1 + y2 <= max) then (     if (Set{x1, x2}->max() <= min) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    if (y1 + y2 <= min) then (     if (Set{x1, x2}->max() <= max) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    if (x1 + y2 <= max) then (     if (Set{y1, x2}->max() <= min) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    if (x1 + y2 <= min) then (     if (Set{y1, x2}->max() <= max) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    if (y1 + x2 <= max) then (     if (Set{x1, y2}->max() <= min) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    if (y1 + x2 <= min) then (     if (Set{x1, y2}->max() <= max) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    OclFile["System.out"].println("NO") ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF217A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[][] ps=new int[n][2];
    for(int i=0 ; i<n ; i++){
      ps[i][0]=in.nextInt();
      ps[i][1]=in.nextInt();
    }
    boolean[] visited=new boolean[n];
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      if(! visited[i])cnt++;
      dfs(ps,i,visited);
    }
    System.out.println(cnt-1);
  }
  public static void dfs(int[][] ps,int v,boolean[] vis){
    if(vis[v])return ;
    vis[v]=true ;
    for(int i=0 ; i<ps.length ; i++){
      if(ps[i][0]==ps[v][0] || ps[i][1]==ps[v][1])dfs(ps,i,vis);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF217A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var ps : Sequence(Sequence(int)) ; ps := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     ps[i+1][0+1] := in.getCurrent()->toInteger() ; 
     ps[i+1][1+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,n)->collect(false) ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (not(visited[i+1])) then     cnt := cnt + 1 ; else skip ; 
     execute dfs(ps, i, visited) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt - 1) ; 
 );
  static   operation dfs( ps : Sequence(Sequence(int)), v : int, vis : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (     if (vis[v+1]) then     return else skip ; 
     vis[v+1] := true ; 
         var i : int ; i := 0 ; while i < ps->size() do ( (     if (ps[i+1][0+1] = ps[v+1][0+1] or ps[i+1][1+1] = ps[v+1][1+1]) then     execute dfs(ps, i, vis) ; else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String convertToString(int sum){
    String str="" ;
    while(sum>0){
      str=str+(char)((sum % 10)+'0');
      sum=sum/10 ;
    }
    return str ;
  }
  static String GetIndividulaDigitSum(String str,int len){
    int sum=0 ;
    for(int i=0 ; i<len ; i++){
      sum=sum+str.charAt(i)-'0' ;
    }
    return convertToString(sum);
  }
  static int GetDigitalRoot(String str){
    if(str.length()==1){
      return str.charAt(0)-'0' ;
    }
    str=GetIndividulaDigitSum(str,str.length());
    return GetDigitalRoot(str);
  }
  public static void main(String[] args){
    String str="675987890789756545689070986776987" ;
    System.out.print(GetDigitalRoot(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation convertToString( sum : int) : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     while (sum > 0) do (     str := str + ((sum mod 10) + '0')->oclAsType(String) ; 
     sum := sum / 10 ) ; 
     return str );
  static   operation GetIndividulaDigitSum( str : String, len : int) : String
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < len do ( (     sum := sum + str->at(i+1) - ('0')->char2byte() )  ;     i := i + 1 ) ; 
     return convertToString(sum) );
  static   operation GetDigitalRoot( str : String) : int
  pre: true
  post: true
  activity: (     if (str->size() = 1) then (     return str->at(0+1) - ('0')->char2byte() ) else skip ; 
     str := GetIndividulaDigitSum(str, str->size()) ; 
     return GetDigitalRoot(str) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "675987890789756545689070986776987" ;
     OclFile["System.out"].print(GetDigitalRoot(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int n,prod ;
  static class Node {
    int data ;
    Node next ;
  };
  static Node push(Node head_ref,int new_data){
    Node new_node=new Node();
    new_node.data=new_data ;
    new_node.next=head_ref ;
    head_ref=new_node ;
    return head_ref ;
  }
  static void productOfLastN_Nodes(Node head){
    if(head==null)return ;
    productOfLastN_Nodes(head.next);
    if(n>0){
      prod=prod*head.data ;
--n ;
    }
  }
  static int productOfLastN_NodesUtil(Node head){
    if(n<=0)return 0 ;
    prod=1 ;
    productOfLastN_Nodes(head);
    return prod ;
  }
  public static void main(String[] args){
    Node head=null ;
    head=push(head,12);
    head=push(head,4);
    head=push(head,8);
    head=push(head,6);
    head=push(head,10);
    n=2 ;
    System.out.print(productOfLastN_NodesUtil(head));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute n : int;
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   operation push( head_ref : Node, new_data : int) : Node
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode() ;
     new_node.data := new_data ; 
    new_node.next := head_ref ; 
    head_ref := new_node ; 
    return head_ref 
 );
  static   operation productOfLastN_Nodes( head : Node) : void
  pre: true
  post: true
  activity: (     if (head = null) then     return else skip ; 
     execute productOfLastN_Nodes(head.next) ; 
     if (n > 0) then (     prod := prod * head.data ; 
     n := n - 1 ) else skip );
  static   operation productOfLastN_NodesUtil( head : Node) : int
  pre: true
  post: true
  activity: (     if (n <= 0) then     return 0 else skip ; 
     prod := 1 ; 
     execute productOfLastN_Nodes(head) ; 
     return prod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := null ;
     head := push(head, 12) ; 
    head := push(head, 4) ; 
    head := push(head, 8) ; 
    head := push(head, 6) ; 
    head := push(head, 10) ; 
    n := 2 ; 
    OclFile["System.out"].print(productOfLastN_NodesUtil(head)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  static float findWater(int i,int j,float X){
    if(j>i){
      System.out.println("Incorrect Input");
      System.exit(0);
    }
    int ll=Math.round((i*(i+1)));
    float[] glass=new float[ll+2];
    int index=0 ;
    glass[index]=X ;
    for(int row=1 ; row<=i ; ++row){
      for(int col=1 ; col<=row ; ++col,++index){
        X=glass[index];
        glass[index]=(X>=1.0f)? 1.0f : X ;
        X=(X>=1.0f)?(X-1): 0.0f ;
        glass[index+row]+=X/2 ;
        glass[index+row+1]+=X/2 ;
      }
    }
    return glass[(int)(i*(i-1)/2+j-1)];
  }
  public static void main(String[] args){
    int i=2,j=2 ;
    float X=2.0f ;
    System.out.println("Amount of water in jth "+"glass of ith row is: "+findWater(i,j,X));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findWater( i : int, j : int, X : double) : double
  pre: true
  post: true
  activity: (     if (j > i) then (     OclFile["System.out"].println("Incorrect Input") ; 
 OclProcess.exit(0) ) else skip ; 
     var ll : int ; ll := ((i * (i + 1)))->round() ;
    var glass : Sequence(double) ; glass := Integer.subrange(1,ll + 2)->collect(0.0) ;
    var index : int ; index := 0 ;
    glass[index+1] := X ; 
        var row : int ; row := 1 ; while row <= i do ( (         var col : int ; col := 1 ; while col <= row do ( (     X := glass[index+1] ; 
     glass[index+1] := if (X >= 1.0f) then 1.0f else X endif ; 
    X := if (X >= 1.0f) then (X - 1) else 0.0f endif ; 
    glass[index + row+1] := glass[index + row+1]+(X / 2) ; 
    glass[index + row + 1+1] := glass[index + row + 1+1]+(X / 2) ; 
 )  ;     col := col + 1 ;     index := index + 1 ) )  ;     row := row + 1 ) ; 
    return glass[(i * (i - 1) / 2 + j - 1)->oclAsType(int)+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 2 ;
    var j : int ; j := 2 ;
     var X : double ; X := 2.0f ;
     OclFile["System.out"].println("Amount of water in jth " + "glass of ith row is: " + findWater(i, j, X)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int calculate_sum(int a,int N){
    int m=N/a ;
    int sum=m*(m+1)/2 ;
    int ans=a*sum ;
    return ans ;
  }
  public static void main(String[] args){
    int a=7,N=49 ;
    System.out.println("Sum of multiples of "+a+" up to "+N+"="+calculate_sum(a,N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation calculate_sum( a : int, N : int) : int
  pre: true
  post: true
  activity: (     var m : int ; m := N / a ;
     var sum : int ; sum := m * (m + 1) / 2 ;
     var ans : int ; ans := a * sum ;
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 7 ;
    var N : int ; N := 49 ;
     OclFile["System.out"].println("Sum of multiples of " + a + " up to " + N + "=" + calculate_sum(a, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int bridge_length(int trainLength,int Speed,int Time){
    return((Time*Speed)-trainLength);
  }
  public static void main(String[] args){
    int trainLength=120 ;
    int Speed=30 ;
    int Time=18 ;
    System.out.print("Length of bridge="+bridge_length(trainLength,Speed,Time)+" meters");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation bridge_length( trainLength : int, Speed : int, Time : int) : int
  pre: true
  post: true
  activity: (     return ((Time * Speed) - trainLength) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var trainLength : int ; trainLength := 120 ;
     var Speed : int ; Speed := 30 ;
     var Time : int ; Time := 18 ;
     OclFile["System.out"].print("Length of bridge=" + bridge_length(trainLength, Speed, Time) + " meters") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void SieveOfEratosthenes(int n,boolean prime[],boolean primesquare[],int a[]){
    for(int i=2 ; i<=n ; i++)prime[i]=true ;
    for(int i=0 ; i<((n*n)+1); i++)primesquare[i]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=n ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=n ; i+=p)prime[i]=false ;
      }
    }
    int j=0 ;
    for(int p=2 ; p<=n ; p++){
      if(prime[p]){
        a[j]=p ;
        primesquare[p*p]=true ;
        j++;
      }
    }
  }
  static int countDivisors(int n){
    if(n==1)return 1 ;
    boolean prime[]=new boolean[n+1];
    boolean primesquare[]=new boolean[(n*n)+1];
    int a[]=new int[n];
    SieveOfEratosthenes(n,prime,primesquare,a);
    int ans=1 ;
    for(int i=0 ; ; i++){
      if(a[i]*a[i]*a[i]>n)break ;
      int cnt=1 ;
      while(n % a[i]==0){
        n=n/a[i];
        cnt=cnt+1 ;
      }
      ans=ans*cnt ;
    }
    if(prime[n])ans=ans*2 ;
    else if(primesquare[n])ans=ans*3 ;
    else if(n!=1)ans=ans*4 ;
    return ans ;
  }
  public static void main(String args[]){
    System.out.println("Total distinct divisors"+" of 100 are : "+countDivisors(100));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation SieveOfEratosthenes( n : int, prime : Sequence(boolean), primesquare : Sequence(boolean), a : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i <= n do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < ((n * n) + 1) do (     primesquare[i+1] := false ;  ;     i := i + 1 ) ; 
    prime[1+1] := false ; 
        var p : int ; p := 2 ; while p * p <= n do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= n do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var j : int ; j := 0 ;
        var p : int ; p := 2 ; while p <= n do ( (     if (prime[p+1]) then (     a[j+1] := p ; 
     primesquare[p * p+1] := true ; 
     j := j + 1 ) else skip )  ;     p := p + 1 ) ; 
 );
  static   operation countDivisors( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 1 else skip ; 
     var prime : Sequence(boolean) ; prime := Integer.subrange(1,n + 1)->collect(false) ;
    var primesquare : Sequence(boolean) ; primesquare := Integer.subrange(1,(n * n) + 1)->collect(false) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    execute SieveOfEratosthenes(n, prime, primesquare, a) ; 
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while true do ( (     if (a[i+1] * a[i+1] * a[i+1] > n) then     break else skip ; 
     var cnt : int ; cnt := 1 ;
     while (n mod a[i+1] = 0) do (     n := n / a[i+1] ; 
     cnt := cnt + 1 ) ; 
     ans := ans * cnt )  ;     i := i + 1 ) ; 
    if (prime[n+1]) then     ans := ans * 2 else     if (primesquare[n+1]) then     ans := ans * 3 else     if (n /= 1) then     ans := ans * 4 ; else skip ; ;  ;  
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Total distinct divisors" + " of 100 are : " + countDivisors(100)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int checkOdd(String number){
    int n=number.length();
    int num=number.charAt(n-1)-'0' ;
    return(num & 1);
  }
  static int splitIntoOdds(String number){
    int numLen=number.length();
    int splitDP[]=new int[numLen+1];
    for(int i=0 ; i<numLen+1 ; i++)splitDP[i]=-1 ;
    for(int i=1 ; i<=numLen ; i++){
      if(i<=9 &&(checkOdd(number.substring(0,i))==1))splitDP[i]=1 ;
      if(splitDP[i]!=-1){
        for(int j=1 ; j<=9 && i+j<=numLen ; j++){
          if(checkOdd(number.substring(i,i+j))==1){
            if(splitDP[i+j]==-1)splitDP[i+j]=1+splitDP[i];
            else splitDP[i+j]=Math.min(splitDP[i+j],1+splitDP[i]);
          }
        }
      }
    }
    return splitDP[numLen];
  }
  public static void main(String[] args){
    System.out.println(splitIntoOdds("123456789123456789123"));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkOdd( number : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := number->size() ;
     var num : int ; num := number->at(n - 1+1) - ('0')->char2byte() ;
     return (MathLib.bitwiseAnd(num,1)) );
  static   operation splitIntoOdds( number : String) : int
  pre: true
  post: true
  activity: (     var numLen : int ; numLen := number->size() ;
     var splitDP : Sequence(int) ; splitDP := Integer.subrange(1,numLen + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < numLen + 1 do (     splitDP[i+1] := -1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= numLen do ( (     if (i <= 9 & (checkOdd(number.subrange(0+1,i)) = 1)) then     splitDP[i+1] := 1 ; else skip ; 
     if (splitDP[i+1] /= -1) then (         var j : int ; j := 1 ; while j <= 9 & i + j <= numLen do ( (     if (checkOdd(number.subrange(i+1,i + j)) = 1) then (     if (splitDP[i + j+1] = -1) then     splitDP[i + j+1] := 1 + splitDP[i+1] ; else     splitDP[i + j+1] := Set{splitDP[i + j+1], 1 + splitDP[i+1]}->min() ; ) else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    return splitDP[numLen+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(splitIntoOdds("123456789123456789123")) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    while(true){
      String s=sc.next();
      if(s.equals("0"))break ;
      int N=s.length();
      int[] v=new int[N];
      for(int i=0 ; i<N ; ++i){
        v[i]=s.charAt(N-1-i)-'0' ;
        if(i % 2==1)v[i]*=-1 ;
      }
      int[] c=new int[11];
      c[0]=1 ;
      long ans=0 ;
      int sum=0 ;
      for(int i=0 ; i<N ; ++i){
        sum+=v[i];
        if(sum>10)sum-=11 ;
        if(sum<0)sum+=11 ;
        if(v[i]!=0)ans+=c[sum];
        c[sum]++;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var s : String ; s := sc.getCurrent() ;
     if (s = "0") then     break else skip ; 
    var N : int ; N := s->size() ;
    var v : Sequence(int) ; v := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     v[i+1] := s->at((N)->char2byte() - 1 - i+1) - ('0')->char2byte() ; 
     if (i mod 2 = 1) then     v[i+1] := v[i+1]*(-1) ; else skip )  ;     i := i + 1 ) ; 
    var c : Sequence(int) ; c := Integer.subrange(1,11)->collect(0) ;
    c[0+1] := 1 ; 
    var ans : long ; ans := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     sum := sum+(v[i+1]) ; 
     if (sum > 10) then     sum := sum-(11) ; else skip ; 
    if (sum < 0) then     sum := sum+(11) ; else skip ; 
    if (v[i+1] /= 0) then     ans := ans+(c[sum+1]) ; else skip ; 
    c[sum+1] := c[sum+1] + 1 ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.geom.*;
public class Main {
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(true){
      char[] c=sc.next().toCharArray();
      if(c.length<=1 && c[0]=='0'){
        break ;
      }
      int[][] dp=new int[2][11];
      if(c[0]!='0'){
        dp[0][c[0]-'0']=1 ;
      }
      int count=0 ;
      for(int i=1 ; i<c.length ; i++){
        int prev=(i+1)% 2 ;
        int num=c[i]-'0' ;
        Arrays.fill(dp[i % 2],0);
        if(i % 2==1)num*=-1 ;
        for(int j=0 ; j<11 ; j++){
          if(dp[prev][j]==0)continue ;
          int nextJ=(num+j+11)% 11 ;
          dp[i % 2][nextJ]+=dp[prev][j];
          if(nextJ==0)count+=dp[i % 2][nextJ];
        }
        if(num==0)continue ;
        dp[i % 2][(num+11)% 11]+=1 ;
      }
      System.out.println(count);
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var c : Sequence(String) ; c := sc.getCurrent()->characters() ;
     if (c->size() <= 1 & c[0+1] = '0') then (     break ) else skip ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,11)->collect(0)) ;
    if (c[0+1] /= '0') then (     dp[0+1][c[0+1] - ('0')->char2byte()+1] := 1 ) else skip ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < c->size() do ( (     var prev : int ; prev := (i + 1) mod 2 ;
     var num : int ; num := c[i+1] - ('0')->char2byte() ;
    dp[i mod 2+1] := dp[i mod 2+1]->collect(0) ; 
    if (i mod 2 = 1) then     num := num*(-1) ; else skip ; 
        var j : int ; j := 0 ; while j < 11 do ( (     if (dp[prev+1][j+1] = 0) then     continue else skip ; 
     var nextJ : int ; nextJ := (num + j + 11) mod 11 ;
     dp[i mod 2+1][nextJ+1] := dp[i mod 2+1][nextJ+1]+(dp[prev+1][j+1]) ; 
     if (nextJ = 0) then     count := count+(dp[i mod 2+1][nextJ+1]) ; else skip )  ;     j := j + 1 ) ; 
    if (num = 0) then     continue else skip ; 
    dp[i mod 2+1][(num + 11) mod 11+1] := dp[i mod 2+1][(num + 11) mod 11+1]+(1) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      if(line.equals("0"))break ;
      int N=line.length();
      int[][] dp=new int[N+1][11];
      for(int i=0 ; i<N ; i++){
        int d=line.charAt(i)-'0' ;
        dp[i+1][d]=(d>0 ? 1 : 0);
        for(int j=0 ; j<11 ; j++){
          if(dp[i][j]!=0){
            dp[i+1][(10*j+d)% 11]+=dp[i][j];
          }
        }
      }
      int ans=0 ;
      for(int i=0 ; i<N ; i++){
        ans+=dp[i+1][0];
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     if (line = "0") then     break else skip ; 
     var N : int ; N := line->size() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,11)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     var d : int ; d := line->at(i+1) - ('0')->char2byte() ;
     dp[i + 1+1][d+1] := (if d > 0 then 1 else 0 endif) ; 
         var j : int ; j := 0 ; while j < 11 do ( (     if (dp[i+1][j+1] /= 0) then (     dp[i + 1+1][(10 * j + d) mod 11+1] := dp[i + 1+1][(10 * j + d) mod 11+1]+(dp[i+1][j+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     ans := ans+(dp[i + 1+1][0+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static final int MAX=80000 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] numbers=new int[MAX];
    while(true){
      final String input=sc.next();
      if("0".equals(input)){
        break ;
      }
      final int size=input.length();
      for(int i=0 ; i<size ; i++){
        numbers[i]=input.charAt(i)-'0' ;
      }
      int count=0 ;
      int[] DP=new int[11];
      int[] next=new int[11];
      for(int i=0 ; i<size ; i++){
        Arrays.fill(next,0);
        for(int mod=0 ; mod<11 ; mod++){
          next[(mod*10+numbers[i])% 11]+=DP[mod];
        }
        if(numbers[i]!=0){
          next[numbers[i] ]++;
        }
        count+=next[0];
        int[] tmp=next ;
        next=DP ;
        DP=tmp ;
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 80000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numbers : Sequence(int) ; numbers := Integer.subrange(1,MAX)->collect(0) ;
     while (true) do (     var input : String ; input := sc.getCurrent() ;
     if ("0" = input) then (     break ) else skip ; 
    var size : int ; size := input->size() ;
        var i : int ; i := 0 ; while i < size do ( (     numbers[i+1] := input->at(i+1) - ('0')->char2byte() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var DP : Sequence(int) ; DP := Integer.subrange(1,11)->collect(0) ;
    var next : Sequence(int) ; next := Integer.subrange(1,11)->collect(0) ;
        var i : int ; i := 0 ; while i < size do ( (     next := next->collect(0) ; 
         var mod : int ; mod := 0 ; while mod < 11 do ( (     next[(mod * 10 + numbers[i+1]) mod 11+1] := next[(mod * 10 + numbers[i+1]) mod 11+1]+(DP[mod+1]) )  ;     mod := mod + 1 ) ; 
    if (numbers[i+1] /= 0) then (     next[numbers[i+1]+1] := next[numbers[i+1]+1] + 1 ) else skip ; 
    count := count+(next[0+1]) ; 
    var tmp : Sequence(int) ; tmp := next ;
    next := DP ; 
    DP := tmp ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    solver();
  }
  static void solver(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      char[] c=sc.next().toCharArray();
      int n=c.length ;
      if(n==1 && c[0]=='0')return ;
      int[] sum=new int[n+1];
      int[] cnt=new int[11];
      sum[0]=0 ;
      cnt[0]++;
      for(int i=0 ; i<n ; i++){
        if(i % 2==0){
          sum[i+1]=sum[i]-(c[i]-'0');
          sum[i+1]=(sum[i+1]+11)% 11 ;
        }
        else {
          sum[i+1]=sum[i]+(c[i]-'0');
          sum[i+1]=(sum[i+1]+11)% 11 ;
        }
        cnt[sum[i+1] ]++;
      }
      int ans=0 ;
      for(int i=0 ; i<n ; i++){
        cnt[sum[i] ]--;
        if(c[i]-'0'!=0){
          ans+=cnt[sum[i] ];
        }
      }
      System.out.println(ans);
    }
  }
  static void tr(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solver() );
  static   operation solver() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var c : Sequence(String) ; c := sc.getCurrent()->characters() ;
     var n : int ; n := c->size() ;
    if (n = 1 & c[0+1] = '0') then     return else skip ; 
    var sum : Sequence(int) ; sum := Integer.subrange(1,n + 1)->collect(0) ;
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,11)->collect(0) ;
    sum[0+1] := 0 ; 
    cnt[0+1] := cnt[0+1] + 1 ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then (     sum[i + 1+1] := sum[i+1] - (c[i+1] - ('0')->char2byte()) ; 
     sum[i + 1+1] := (sum[i + 1+1] + 11) mod 11 ) else (     sum[i + 1+1] := sum[i+1] + (c[i+1] - ('0')->char2byte()) ; 
     sum[i + 1+1] := (sum[i + 1+1] + 11) mod 11 ) ;  
     cnt[sum[i + 1+1]+1] := cnt[sum[i + 1+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     cnt[sum[i+1]+1] := cnt[sum[i+1]+1] - 1 ; 
     if (c[i+1] - ('0')->char2byte() /= 0) then (     ans := ans+(cnt[sum[i+1]+1]) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation tr( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int m=sc.nextInt();
    int n=sc.nextInt();
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++)nums[i]=sc.nextInt();
    int count1=0 ;
    int count2=0 ;
    int ans=0 ;
    if(m==2){
      for(int i=0 ; i<n ; i++){
        if(i % 2==0 && nums[i]==1 || i % 2==1 && nums[i]==2)count1++;
        else count2++;
      }
      System.out.println(Math.min(count1,count2));
    }
    else {
      for(int i=0 ; i<n-1 ; i++){
        if(nums[i]==nums[i+1]){
          nums[i+1]=-1 ;
          ans++;
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     nums[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var count1 : int ; count1 := 0 ;
    var count2 : int ; count2 := 0 ;
    var ans : int ; ans := 0 ;
    if (m = 2) then (         var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0 & nums[i+1] = 1 or i mod 2 = 1 & nums[i+1] = 2) then     count1 := count1 + 1 ; else     count2 := count2 + 1 ; )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(Set{count1, count2}->min()) ) else (         var i : int ; i := 0 ; while i < n - 1 do ( (     if (nums[i+1] = nums[i + 1+1]) then (     nums[i + 1+1] := -1 ; 
     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class multithreading {
  public static void main(String[] args){
    Scanner obj=new Scanner(System.in);
    int n=obj.nextInt();
    int[] a=new int[n];
    int count=n-1 ;
    for(int i=0 ; i<n ; i++)a[i]=obj.nextInt();
    for(int i=n-1 ; i>0 ; i--){
      if(a[i]<a[i-1])break ;
--count ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class multithreading {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : OclFile ; obj := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := obj.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var count : int ; count := n - 1 ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := obj.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i > 0 do ( (     if (a[i+1] < a[i - 1+1]) then     break else skip ; 
     count := count - 1 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isPalindrome(String str){
    int l=0 ;
    int h=str.length()-1 ;
    while(h>l)if(str.charAt(l++)!=str.charAt(h--))return false ;
    return true ;
  }
  static int minRemovals(String str){
    if(str.charAt(0)=='')return 0 ;
    if(isPalindrome(str))return 1 ;
    return 2 ;
  }
  public static void main(String[] args){
    System.out.println(minRemovals("010010"));
    System.out.println(minRemovals("0100101"));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPalindrome( str : String) : boolean
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
     var h : int ; h := str->size() - 1 ;
     while (h > l) do     if (str->at(l+1) /= str->at(h+1)) then     return false else skip ; ; 
     return true );
  static   operation minRemovals( str : String) : int
  pre: true
  post: true
  activity: (     if (str->at(0+1) = expression) then     return 0 else skip ; 
     if (isPalindrome(str)) then     return 1 else skip ; 
     return 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(minRemovals("010010")) ; 
     OclFile["System.out"].println(minRemovals("0100101")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Map ;
import java.util.StringTokenizer ;
import java.util.TreeMap ;
public class Transmigration {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    int m=Integer.parseInt(st.nextToken());
    int k=Integer.parseInt(st.nextToken().substring(2));
    TreeMap<String,Integer>skills=new TreeMap<>();
    for(int i=0 ; i<n ; i++){
      st=new StringTokenizer(br.readLine());
      String skillName=st.nextToken();
      int skillScore=Integer.parseInt(st.nextToken());
      int newSkillScore=skillScore*k/100 ;
      if(newSkillScore<100)continue ;
      skills.put(skillName,newSkillScore);
    }
    for(int i=0 ; i<m ; i++){
      String skillName=br.readLine();
      if(skills.containsKey(skillName))continue ;
      skills.put(skillName,0);
    }
    pw.println(skills.size());
    for(Map.Entry<String,Integer>skill : skills.entrySet())pw.println(skill.getKey()+" "+skill.getValue());
    pw.flush();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Transmigration {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var k : int ; k := (st.next().subrange(2+1,2))->toInteger() ;
    var skills : Map(String,int) ; skills := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var skillName : String ; skillName := st.next() ;
    var skillScore : int ; skillScore := (st.next())->toInteger() ;
    var newSkillScore : int ; newSkillScore := skillScore * k / 100 ;
    if (newSkillScore < 100) then     continue else skip ; 
    skills := skills->union(Map{skillName |-> newSkillScore}) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var skillName : String ; skillName := br.readLine() ;
     if (skills->keys()->includes(skillName)) then     continue else skip ; 
     skills := skills->union(Map{skillName |-> 0}) )  ;     i := i + 1 ) ; 
    skip ; 
    for (skill : skills->asSet()) do (     skip ;  ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Codeforcs {
  public static void main(String[] args){
    Scanner I=new Scanner(System.in);
    int k=I.nextInt();
    int l=I.nextInt();
    int m=I.nextInt();
    int n=I.nextInt();
    int d=I.nextInt();
    int counter=0 ;
    for(int i=1 ; i<=d ; i++){
      if(i % k==0 || i % m==0 || i % l==0 || i % n==0)counter++;
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforcs {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var I : OclFile ; I := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := I.getCurrent()->toInteger() ;
    var l : int ; l := I.getCurrent()->toInteger() ;
    var m : int ; m := I.getCurrent()->toInteger() ;
    var n : int ; n := I.getCurrent()->toInteger() ;
    var d : int ; d := I.getCurrent()->toInteger() ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 1 ; while i <= d do ( (     if (i mod k = 0 or i mod m = 0 or i mod l = 0 or i mod n = 0) then     counter := counter + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Madi {
  public static void main(String[] args){
    Scanner mad=new Scanner(System.in);
    int k=mad.nextInt();
    int l=mad.nextInt();
    int m=mad.nextInt();
    int n=mad.nextInt();
    int d=mad.nextInt();
    int count=0 ;
    for(int i=1 ; i<=d ; i++)if(i % k==0 || i % l==0 || i % m==0 || i % n==0)count++;
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Madi {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mad : OclFile ; mad := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := mad.getCurrent()->toInteger() ;
    var l : int ; l := mad.getCurrent()->toInteger() ;
    var m : int ; m := mad.getCurrent()->toInteger() ;
    var n : int ; n := mad.getCurrent()->toInteger() ;
    var d : int ; d := mad.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= d do (     if (i mod k = 0 or i mod l = 0 or i mod m = 0 or i mod n = 0) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int k=scanner.nextInt();
    int l=scanner.nextInt();
    int m=scanner.nextInt();
    int n=scanner.nextInt();
    int d=scanner.nextInt();
    int cont=0 ;
    for(int i=1 ; i<=d ; i++){
      if(i % k==0 || i % l==0 || i % m==0 || i % n==0)cont++;
    }
    System.out.print(cont);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := scanner.getCurrent()->toInteger() ;
    var l : int ; l := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var d : int ; d := scanner.getCurrent()->toInteger() ;
    var cont : int ; cont := 0 ;
        var i : int ; i := 1 ; while i <= d do ( (     if (i mod k = 0 or i mod l = 0 or i mod m = 0 or i mod n = 0) then     cont := cont + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(cont) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class main {
  public static void main(String[] arg){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    int l=sc.nextInt();
    int m=sc.nextInt();
    int n=sc.nextInt();
    int d=sc.nextInt();
    int c=0 ;
    for(int i=1 ; i<=d ; i++)if(i % k!=0 && i % l!=0 && i % m!=0 && i % n!=0)c+=1 ;
    System.out.println(d-c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
        var i : int ; i := 1 ; while i <= d do (     if (i mod k /= 0 & i mod l /= 0 & i mod m /= 0 & i mod n /= 0) then     c := c+(1) ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(d - c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class dargnon {
  public static void main(String[] args){
    java.util.Scanner in=new java.util.Scanner(System.in);
    int k=in.nextInt();
    int l=in.nextInt();
    int m=in.nextInt();
    int n=in.nextInt();
    int d=in.nextInt();
    int s[]=new int[100];
    int c=0 ;
    s[0]=k ;
    for(int i=1 ; i<=d ; i++){
      if(i % k==0 || i % l==0 || i % n==0 || i % m==0)c++;
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
class dargnon {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : Scanner ; in := Scanner.newScanner(OclFile["System.in"]) ;
     var k : int ; k := in.nextInt() ;
    var l : int ; l := in.nextInt() ;
    var m : int ; m := in.nextInt() ;
    var n : int ; n := in.nextInt() ;
    var d : int ; d := in.nextInt() ;
    var s : Sequence(int) ; s := Integer.subrange(1,100)->collect(0) ;
    var c : int ; c := 0 ;
    s[0+1] := k ; 
        var i : int ; i := 1 ; while i <= d do ( (     if (i mod k = 0 or i mod l = 0 or i mod n = 0 or i mod m = 0) then     c := c + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static boolean isPrime(char c){
    return(c=='2' || c=='3' || c=='5' || c=='7');
  }
  public static void decrease(StringBuilder s,int i){
    if(s.charAt(i)<='2'){
      s.deleteCharAt(i);
      s.setCharAt(i,'7');
    }
    else if(s.charAt(i)=='3')s.setCharAt(i,'2');
    else if(s.charAt(i)<='5')s.setCharAt(i,'3');
    else if(s.charAt(i)<='7')s.setCharAt(i,'5');
    else s.setCharAt(i,'7');
    return ;
  }
  public static String primeDigits(StringBuilder s){
    for(int i=0 ; i<s.length(); i++){
      if(! isPrime(s.charAt(i))){
        while(i>=0 && s.charAt(i)<='2')i--;
        if(i<0){
          i=0 ;
          decrease(s,i);
        }
        else decrease(s,i);
        for(int j=i+1 ; j<s.length(); j++)s.setCharAt(j,'7');
        break ;
      }
    }
    return s.toString();
  }
  public static void main(String[] args){
    StringBuilder s=new StringBuilder("45");
    System.out.println(primeDigits(s));
    s=new StringBuilder("1000");
    System.out.println(primeDigits(s));
    s=new StringBuilder("7721");
    System.out.println(primeDigits(s));
    s=new StringBuilder("7221");
    System.out.println(primeDigits(s));
    s=new StringBuilder("74545678912345689748593275897894708927680");
    System.out.println(primeDigits(s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( c : String) : boolean
  pre: true
  post: true
  activity: (     return (c = '2' or c = '3' or c = '5' or c = '7') );
  static   operation decrease( s : String, i : int) : void
  pre: true
  post: true
  activity: (     if (s->at(i+1) <= '2') then (     s := s->excludingAt(i+1) ; 
     s := s.setAt(i+1, '7') ) else     if (s->at(i+1) = '3') then     s := s.setAt(i+1, '2') else     if (s->at(i+1) <= '5') then     s := s.setAt(i+1, '3') else     if (s->at(i+1) <= '7') then     s := s.setAt(i+1, '5') else     s := s.setAt(i+1, '7') ; ;  ;  ;  ;  
     return );
  static   operation primeDigits( s : String) : String
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() do ( (     if (not(isPrime(s->at(i+1)))) then (     while (i >= 0 & s->at(i+1) <= '2') do     i := i - 1 ; ; 
     if (i < 0) then (     i := 0 ; 
     execute decrease(s, i) ) else     execute decrease(s, i) ; ;  
         var j : int ; j := i + 1 ; while j < s->size() do (     s := s.setAt(j+1, '7') ;  ;     j := j + 1 ) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     return s+"" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := StringLib.newString("45") ;
     OclFile["System.out"].println(primeDigits(s)) ; 
    s := StringLib.newString("1000") ; 
    OclFile["System.out"].println(primeDigits(s)) ; 
    s := StringLib.newString("7721") ; 
    OclFile["System.out"].println(primeDigits(s)) ; 
    s := StringLib.newString("7221") ; 
    OclFile["System.out"].println(primeDigits(s)) ; 
    s := StringLib.newString("74545678912345689748593275897894708927680") ; 
    OclFile["System.out"].println(primeDigits(s)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findPerm(int Q[],int n){
    int minval=0,qsum=0 ;
    for(int i=0 ; i<n-1 ; i++){
      qsum+=Q[i];
      if(qsum<minval)minval=qsum ;
    }
    int[] P=new int[n];
    P[0]=1-minval ;
    boolean permFound=true ;
    for(int i=0 ; i<n-1 ; i++){
      P[i+1]=P[i]+Q[i];
      if(P[i+1]>n || P[i+1]<1){
        permFound=false ;
        break ;
      }
    }
    if(permFound){
      for(int i=0 ; i<n ; i++){
        System.out.print(P[i]+" ");
      }
    }
    else {
      System.out.print(-1);
    }
  }
  public static void main(String[] args){
    int Q[]={
-2,1 };
      int n=1+Q.length ;
      findPerm(Q,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findPerm( Q : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var minval : int ; minval := 0 ;
    var qsum : int ; qsum := 0 ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     qsum := qsum+(Q[i+1]) ; 
     if (qsum < minval) then     minval := qsum ; else skip )  ;     i := i + 1 ) ; 
    var P : Sequence(int) ; P := Integer.subrange(1,n)->collect(0) ;
    P[0+1] := 1 - minval ; 
    var permFound : boolean ; permFound := true ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     P[i + 1+1] := P[i+1] + Q[i+1] ; 
     if (P[i + 1+1] > n or P[i + 1+1] < 1) then (     permFound := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (permFound) then (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(P[i+1] + " ") )  ;     i := i + 1 ) ) else (     OclFile["System.out"].print(-1) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Q : Sequence(int) ; Q := Sequence{-2,1} ;
     var n : int ; n := 1 + Q->size() ;
     execute findPerm(Q, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String ReverseComplement(char[] s,int n,int k){
    int rev=(k+1)/2 ;
    int complment=k-rev ;
    if(rev % 2==1)s=reverse(s);
    if(complment % 2==1){
      for(int i=0 ; i<n ; i++){
        if(s[i]=='0')s[i]='1' ;
        else s[i]='0' ;
      }
    }
    return String.valueOf(s);
  }
  static char[] reverse(char a[]){
    int i,n=a.length ;
    char t ;
    for(i=0 ; i<n/2 ; i++){
      t=a[i];
      a[i]=a[n-i-1];
      a[n-i-1]=t ;
    }
    return a ;
  }
  public static void main(String[] args){
    String str="10011" ;
    int k=5 ;
    int n=str.length();
    System.out.print(ReverseComplement(str.toCharArray(),n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation ReverseComplement( s : Sequence(String), n : int, k : int) : String
  pre: true
  post: true
  activity: (     var rev : int ; rev := (k + 1) / 2 ;
     var complment : int ; complment := k - rev ;
    if (rev mod 2 = 1) then     s := reverse(s) ; else skip ; 
    if (complment mod 2 = 1) then (         var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] = '0') then     s[i+1] := '1' ; else     s[i+1] := '0' ; )  ;     i := i + 1 ) ) else skip ; 
    return ((s) + "") 
 );
  static   operation reverse( a : Sequence(String)) : Sequence(String)
  pre: true
  post: true
  activity: (     var i : int ;
    var n : int ; n := a->size() ;
     var t : String ;
         i := 0 ; while i < n / 2 do ( (     t := a[i+1] ; 
     a[i+1] := a[n - i - 1+1] ; 
     a[n - i - 1+1] := t )  ;     i := i + 1 ) ; 
     return a );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "10011" ;
     var k : int ; k := 5 ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].print(ReverseComplement(str->characters(), n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int calculateLeaps(int n){
    if(n==0)return 1 ;
    return(1<<(n-1));
  }
  public static void main(String[] args){
    System.out.println(calculateLeaps(4));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation calculateLeaps( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     return ((1*(2->pow((n - 1))))->oclAsType(long)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(calculateLeaps(4)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    int c=Integer.parseInt(sc.next());
    sc.close();
    int ab=a+b ;
    int ac=a+c ;
    int bc=b+c ;
    int result=Math.min(Math.min(ab,ac),bc);
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := (sc.getCurrent())->toInteger() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    var c : int ; c := (sc.getCurrent())->toInteger() ;
    skip ; 
    var ab : int ; ab := a + b ;
    var ac : int ; ac := a + c ;
    var bc : int ; bc := b + c ;
    var result : int ; result := Set{Set{ab, ac}->min(), bc}->min() ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countSolutions(int a){
    int count=0 ;
    for(int i=0 ; i<=a ; i++){
      if(a==(i+(a ^ i)))count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int a=3 ;
    System.out.println(countSolutions(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSolutions( a : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i <= a do ( (     if (a = (i + (a xor i))) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
     OclFile["System.out"].println(countSolutions(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Multithreading {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(bf.readLine());
    StringTokenizer st=new StringTokenizer(bf.readLine());
    int[] x=new int[n];
    for(int j=0 ; j<x.length ; j++){
      x[j]=Integer.parseInt(st.nextToken());
    }
    int last=x[0];
    int currind=-1 ;
    boolean f=false ;
    for(int i=0 ; i<x.length ; i++){
      if(x[i]<last){
        f=true ;
        currind=i ;
      }
      last=x[i];
    }
    if(! f)System.out.println(0);
    else System.out.println(currind);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Multithreading {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (bf.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(bf.readLine()) ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < x->size() do ( (     x[j+1] := (st.next())->toInteger() )  ;     j := j + 1 ) ; 
    var last : int ; last := x[0+1] ;
    var currind : int ; currind := -1 ;
    var f : boolean ; f := false ;
        var i : int ; i := 0 ; while i < x->size() do ( (     if (x[i+1] < last) then (     f := true ; 
     currind := i ) else skip ; 
     last := x[i+1] )  ;     i := i + 1 ) ; 
    if (not(f)) then     OclFile["System.out"].println(0) else     OclFile["System.out"].println(currind) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Main main=new Main();
    main.solve();
  }
  void solve()throws Exception {
    try(Scanner cin=new Scanner(System.in)){
      int x1=cin.nextInt();
      int x2=cin.nextInt();
      int x3=cin.nextInt();
      List<Integer>list=new ArrayList<>();
      list.add(x1);
      list.add(x2);
      list.add(x3);
      Collections.sort(list);
      System.out.println(list.get(0)+list.get(1));
    }
    finally {
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     try (    var cin : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var x1 : int ; x1 := cin.getCurrent()->toInteger() ;
     var x2 : int ; x2 := cin.getCurrent()->toInteger() ;
    var x3 : int ; x3 := cin.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
    list := list->including(x1) ; 
    list := list->including(x2) ; 
    list := list->including(x3) ; 
    list := list->sort() ; 
    OclFile["System.out"].println(list->at(0+1) + list->at(1+1)) ; 
 ))   finally skip
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    int sum1=A+B ;
    int sum2=B+C ;
    int sum3=C+A ;
    if(sum1==sum2 && sum2==sum3){
      System.out.println(sum1);
    }
    if(sum1<sum2 && sum1<sum3){
      System.out.println(sum1);
    }
    if(sum2<sum1 && sum2<sum3){
      System.out.println(sum2);
    }
    if(sum3<sum2 && sum3<sum1){
      System.out.println(sum3);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var sum1 : int ; sum1 := A + B ;
    var sum2 : int ; sum2 := B + C ;
    var sum3 : int ; sum3 := C + A ;
    if (sum1 = sum2 & sum2 = sum3) then (     OclFile["System.out"].println(sum1) ) else skip ; 
    if (sum1 < sum2 & sum1 < sum3) then (     OclFile["System.out"].println(sum1) ) else skip ; 
    if (sum2 < sum1 & sum2 < sum3) then (     OclFile["System.out"].println(sum2) ) else skip ; 
    if (sum3 < sum2 & sum3 < sum1) then (     OclFile["System.out"].println(sum3) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintStream out=new PrintStream(System.out);
    int a,b,c,min ;
    a=sc.nextInt();
    b=sc.nextInt();
    c=sc.nextInt();
    min=a+b ;
    if(min>a+c){
      min=a+c ;
    }
    if(min>b+c){
      min=b+c ;
    }
    out.println(min);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : int ;
    var b : int ;
    var c : int ;
    var min : int ;
    a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    c := sc.getCurrent()->toInteger() ; 
    min := a + b ; 
    if (min > a + c) then (     min := a + c ) else skip ; 
    if (min > b + c) then (     min := b + c ) else skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String[] dat=scan.nextLine().split(" ");
    scan.close();
    int[] intdat=new int[3];
    for(int i=0 ; i<3 ; i++)intdat[i]=Integer.parseInt(dat[i]);
    Arrays.sort(intdat);
    System.out.println(intdat[0]+intdat[1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dat : Sequence(String) ; dat := scan.nextLine()->split(" ") ;
    skip ; 
    var intdat : Sequence(int) ; intdat := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do (     intdat[i+1] := (dat[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    intdat := intdat->sort() ; 
    OclFile["System.out"].println(intdat[0+1] + intdat[1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minCost(int arr[],int cost[],int n){
    int costThree=Integer.MAX_VALUE ;
    for(int j=0 ; j<n ; j++){
      int costI=Integer.MAX_VALUE ;
      int costK=Integer.MAX_VALUE ;
      for(int i=0 ; i<j ; i++){
        if(arr[i]<arr[j])costI=Math.min(costI,cost[i]);
      }
      for(int k=j+1 ; k<n ; k++){
        if(arr[k]>arr[j])costK=Math.min(costK,cost[k]);
      }
      if(costI!=Integer.MAX_VALUE && costK!=Integer.MAX_VALUE){
        costThree=Math.min(costThree,cost[j]+costI+costK);
      }
    }
    if(costThree==Integer.MAX_VALUE)return-1 ;
    return costThree ;
  }
  public static void main(String[] args){
    int arr[]={
      2,4,5,4,10 };
      int cost[]={
        40,30,20,10,40 };
        int n=arr.length ;
        System.out.println(minCost(arr,cost,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minCost( arr : Sequence(int), cost : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var costThree : int ; costThree := 2147483647 ;
         var j : int ; j := 0 ; while j < n do ( (     var costI : int ; costI := 2147483647 ;
     var costK : int ; costK := 2147483647 ;
        var i : int ; i := 0 ; while i < j do ( (     if (arr[i+1] < arr[j+1]) then     costI := Set{costI, cost[i+1]}->min() ; else skip )  ;     i := i + 1 ) ; 
        var k : int ; k := j + 1 ; while k < n do ( (     if (arr[k+1] > arr[j+1]) then     costK := Set{costK, cost[k+1]}->min() ; else skip )  ;     k := k + 1 ) ; 
    if (costI /= 2147483647 & costK /= 2147483647) then (     costThree := Set{costThree, cost[j+1] + costI + costK}->min() ) else skip ; 
 )  ;     j := j + 1 ) ; 
     if (costThree = 2147483647) then     return -1 else skip ; 
     return costThree );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,5,4,10} ;
     var cost : Sequence(int) ; cost := Sequence{40,30,20,10,40} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minCost(arr, cost, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isCorrectOrder(int n){
    boolean flag=true ;
    int prev=-1 ;
    int type=-1 ;
    while(n!=0){
      if(type==-1){
        if(prev==-1){
          prev=n % 10 ;
          n=n/10 ;
          continue ;
        }
        if(prev==n % 10){
          flag=false ;
          break ;
        }
        if(prev>n % 10){
          type=1 ;
          prev=n % 10 ;
          n=n/10 ;
          continue ;
        }
        prev=n % 10 ;
        n=n/10 ;
      }
      else {
        if(prev==n % 10){
          flag=false ;
          break ;
        }
        if(prev<n % 10){
          flag=false ;
          break ;
        }
        prev=n % 10 ;
        n=n/10 ;
      }
    }
    return flag ;
  }
  public static void main(String[] args){
    int n=123454321 ;
    if(isCorrectOrder(n))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isCorrectOrder( n : int) : boolean
  pre: true
  post: true
  activity: (     var flag : boolean ; flag := true ;
     var prev : int ; prev := -1 ;
    var type : int ; type := -1 ;
    while (n /= 0) do (     if (type = -1) then (     if (prev = -1) then (     prev := n mod 10 ; 
     n := n / 10 ; 
     continue ) else skip ; 
     if (prev = n mod 10) then (     flag := false ; 
     break ) else skip ; 
    if (prev > n mod 10) then (     type := 1 ; 
     prev := n mod 10 ; 
     n := n / 10 ; 
     continue ) else skip ; 
    prev := n mod 10 ; 
    n := n / 10 ; 
 ) else (     if (prev = n mod 10) then (     flag := false ; 
     break ) else skip ; 
     if (prev < n mod 10) then (     flag := false ; 
     break ) else skip ; 
     prev := n mod 10 ; 
     n := n / 10 ) ) ; 
    return flag 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 123454321 ;
     if (isCorrectOrder(n)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    for(int i=1 ; i<a.length ; i++){
      if(a[i]==a[i-1]){
        sum++;
        a[i]=a[i-1]+1 ;
        if(i<a.length-1 && a[i]==a[i+1])a[i]=a[i+1]-1 ;
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < a->size() do ( (     if (a[i+1] = a[i - 1+1]) then (     sum := sum + 1 ; 
     a[i+1] := a[i - 1+1] + 1 ; 
     if (i < a->size() - 1 & a[i+1] = a[i + 1+1]) then     a[i+1] := a[i + 1+1] - 1 ; else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  static String br=System.getProperty("line.separator");
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=nextInt();
    int a[]=new int[N];
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextInt();
    }
    int count=0 ;
    for(int i=0 ; i<N-1 ; i++){
      int now=a[i];
      int next=a[i+1];
      if(now==next){
        a[i+1]=-1 ;
        count++;
      }
    }
    println(count);
  }
  static long gcd(long a,long b){
    long temp ;
    while((temp=a % b)!=0){
      a=b ;
      b=temp ;
    }
    return b ;
  }
  static long lcm(long a,long b){
    long temp ;
    long c=a ;
    c*=b ;
    while((temp=a % b)!=0){
      a=b ;
      b=temp ;
    }
    return(c/b);
  }
  static int nextInt(){
    return Integer.parseInt(next());
  }
  static Long nextLong(){
    return Long.parseLong(next());
  }
  static String next(){
    return sc.next();
  }
  static void println(Object o){
    PrintWriter out=new PrintWriter(System.out);
    out.println(o);
    out.flush();
  }
  static void print(Object o){
    PrintWriter out=new PrintWriter(System.out);
    out.print(o);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : String := OclProcess.getEnvironmentProperty("line.separator");
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     var now : int ; now := a[i+1] ;
     var next : int ; next := a[i + 1+1] ;
     if (now = next) then (     a[i + 1+1] := -1 ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    execute println(count) ; 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var temp : long ;
         temp := a mod b ;
    while ((temp) /= 0) do (    skip ; (     a := b ; 
     b := temp ) ;     temp := a mod b ;
 ) ;  
     return b );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var temp : long ;
     var c : long ; c := a ;
    c := c*(b) ; 
        temp := a mod b ;
    while ((temp) /= 0) do (    skip ; (     a := b ; 
     b := temp ) ;     temp := a mod b ;
 ) ;  
    return (c / b) 
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation next() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
  static   operation println( o : OclAny) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     skip ; 
     skip );
  static   operation print( o : OclAny) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     skip ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    A solver=new A();
    solver.solve(1,in,out);
    out.close();
  }
  static class A {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=Integer.parseInt(in.next());
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=Integer.parseInt(in.next());
      }
      int ans=0 ;
      int ptr=1 ;
      int prev=a[0];
      for(int i=1 ; i<n ; i++){
        if(a[i]==prev){
          ptr++;
        }
        else {
          ans+=ptr/2 ;
          ptr=1 ;
        }
        if(i==n-1)ans+=ptr/2 ;
        prev=a[i];
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : A ; solver := A.newA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class A {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (in.getCurrent())->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (in.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var ptr : int ; ptr := 1 ;
    var prev : int ; prev := a[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] = prev) then (     ptr := ptr + 1 ) else (     ans := ans+(ptr / 2) ; 
     ptr := 1 ) ;  
     if (i = n - 1) then     ans := ans+(ptr / 2) ; else skip ; 
     prev := a[i+1] )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  private static int next(int[] arr,int target){
    int start=0,end=arr.length-1 ;
    int ans=-1 ;
    while(start<=end){
      int mid=(start+end)/2 ;
      if(arr[mid]<=target){
        start=mid+1 ;
      }
      else {
        ans=mid ;
        end=mid-1 ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int[] arr={
      1,2,3,5,8,12 };
      System.out.println(next(arr,8));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation next( arr : Sequence(int), target : int) : int
  pre: true
  post: true
  activity: (     var start : int ; start := 0 ;
    var end : int ; end := arr->size() - 1 ;
     var ans : int ; ans := -1 ;
     while (start <= end) do (     var mid : int ; mid := (start + end) / 2 ;
     if (arr[mid+1] <= target) then (     start := mid + 1 ) else (     ans := mid ; 
     end := mid - 1 ) ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,5,8,12} ;
     OclFile["System.out"].println(next(arr, 8)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    FastScanner sc=new FastScanner(System.in);
    int n=sc.nextInt();
    int ans=0 ;
    int chain=0 ;
    int prev=0 ;
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      if(a!=prev){
        ans+=chain/2 ;
        chain=1 ;
        prev=a ;
      }
      else {
        chain++;
      }
    }
    System.out.println(ans+chain/2);
  }
}
class FastScanner {
  private BufferedReader reader=null ;
  private StringTokenizer tokenizer=null ;
  public FastScanner(InputStream in){
    reader=new BufferedReader(new InputStreamReader(in));
    tokenizer=null ;
  }
  public String next(){
    if(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        tokenizer=new StringTokenizer(reader.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }
  public String nextLine(){
    if(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken("\n");
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public double nextDouble(){
    return Double.parseDouble(next());
  }
  public int[] nextIntArray(int n){
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public long[] nextLongArray(int n){
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=nextLong();
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var n : int ; n := sc.nextInt() ;
    var ans : int ; ans := 0 ;
    var chain : int ; chain := 0 ;
    var prev : int ; prev := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.nextInt() ;
     if (a /= prev) then (     ans := ans+(chain / 2) ; 
     chain := 1 ; 
     prev := a ) else (     chain := chain + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans + chain / 2) ; 
 );
}
class FastScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.nextToken("\n") );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt(),a[]=new int[n];
    for(int i=0 ; i<n ; ++i)a[i]=sc.nextInt()-1 ;
    int min=a[n-1],ans=0 ;
    for(int i=n-2 ; i>=0 ; --i){
      if(a[i]>min){
        ans+=i+1 ;
        break ;
      }
      min=Math.min(min,a[i]);
    }
    out.println(ans);
    out.flush();
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(void) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() - 1 ;  ;     i := i + 1 ) ; 
    var min : int ; min := a[n - 1+1] ;
    var ans : int ; ans := 0 ;
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (a[i+1] > min) then (     ans := ans+(i + 1) ; 
     break ) else skip ; 
     min := Set{min, a[i+1]}->min() )  ;     i := i - 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    Solver solver=new Solver();
    solver.init();
    solver.readHead(in.readLine());
    for(; solver.hasNext(); ){
      solver.readBody(in.readLine());
    }
  }
}
class Solver {
  int N ;
  int cnt ;
  public void init(){
    N=0 ;
    cnt=0 ;
  }
  public void readHead(String str){
    String[] strArr=str.split(" ");
    N=Integer.parseInt(strArr[0]);
  }
  public boolean hasNext(){
    return cnt<1 ;
  }
  public void readBody(String str){
    String[] strArr=str.split(" ");
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++){
      a[i]=Integer.parseInt(strArr[i]);
    }
    cnt++;
    if(N==2){
      if(a[0]==a[1])System.out.println(1);
      else System.out.println(0);
      return ;
    }
    int ans=0 ;
    for(int i=1 ; i<N-1 ; i++){
      if(a[i]==a[i-1] && a[i]==a[i+1]){
        a[i]=a[i-1]+a[i+1];
        ans++;
      }
    }
    for(int i=1 ; i<N-1 ; i++){
      if(a[i]==a[i-1] || a[i]==a[i+1]){
        a[i]=a[i-1]+a[i+1];
        ans++;
      }
    }
    System.out.println(ans);
  }
  public void solve(){
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var solver : Solver ; solver := Solver.newSolver() ;
    solver.init() ; 
    solver.readHead(in.readLine()) ; 
      while solver.hasNext() do ( (     solver.readBody(in.readLine()) )  ) ; 
 );
}
class Solver {
   attribute N : int;
   attribute cnt : int;
   operation init() : void
  pre: true
  post: true
  activity: (     N := 0 ; 
     cnt := 0 );
   operation readHead( str : String) : void
  pre: true
  post: true
  activity: (     var strArr : Sequence(String) ; strArr := str->split(" ") ;
     N := (strArr[0+1])->toInteger() );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return cnt < 1 );
   operation readBody( str : String) : void
  pre: true
  post: true
  activity: (     var strArr : Sequence(String) ; strArr := str->split(" ") ;
     var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := (strArr[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    cnt := cnt + 1 ; 
    if (N = 2) then (     if (a[0+1] = a[1+1]) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println(0) ; ;  
     return ) else skip ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < N - 1 do ( (     if (a[i+1] = a[i - 1+1] & a[i+1] = a[i + 1+1]) then (     a[i+1] := a[i - 1+1] + a[i + 1+1] ; 
     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < N - 1 do ( (     if (a[i+1] = a[i - 1+1] or a[i+1] = a[i + 1+1]) then (     a[i+1] := a[i - 1+1] + a[i + 1+1] ; 
     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: skip;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.Closeable ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    final int L=sc.nextInt();
    final int N=sc.nextInt();
    long sum=0 ;
    for(int i=0 ; i<N ; i++){
      sum+=(sc.nextLong()*sc.nextLong());
    }
    if(sum==0){
      System.out.println(0);
    }
    else {
      System.out.println(1);
      System.out.println((sum<0 ? 1 :-1)+" "+(Math.abs(sum)));
    }
  }
  public static class Scanner implements Closeable {
    private BufferedReader br ;
    private StringTokenizer tok ;
    public Scanner(InputStream is){
      br=new BufferedReader(new InputStreamReader(is));
    }
    private void getLine(){
      try {
        while(! hasNext()){
          tok=new StringTokenizer(br.readLine());
        }
      }
      catch(IOException e){
      }
    }
    private boolean hasNext(){
      return tok!=null && tok.hasMoreTokens();
    }
    public String next(){
      getLine();
      return tok.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public void close(){
      try {
        br.close();
      }
      catch(IOException e){
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var L : int ; L := sc.getCurrent()->toInteger() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     sum := sum+((sc.getCurrent()->toLong() * sc.getCurrent()->toLong())) )  ;     i := i + 1 ) ; 
    if (sum = 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(1) ; 
     OclFile["System.out"].println((if sum < 0 then 1 else -1 endif) + " " + (if sum < 0 then -(sum) else sum endif)) ) ;  
 );
  static class Scanner implements Closeable {
   attribute br : OclFile;
   attribute tok : OclIterator;
   static operation newScanner( is : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
   operation getLine() : void
  pre: true
  post: true
  activity: (     try (     while (not(hasNext())) do (     tok := OclIterator.newOclIterator_String(br.readLine()) ) )   catch (e : IOException) do skip
 );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return tok /= null & tok.hasNext() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute getLine() ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation close() : void
  pre: true
  post: true
  activity: (     try (     skip )   catch (e : IOException) do skip
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int L=sc.nextInt();
    int N=sc.nextInt();
    int[] x=new int[N];
    int[] w=new int[N];
    for(int i=0 ; i<N ; i++){
      x[i]=sc.nextInt();
      w[i]=sc.nextInt();
    }
    int l=0 ;
    int r=0 ;
    for(int i=0 ; i<N ; i++){
      if(x[i]==0)continue ;
      if(x[i]<0){
        l+=-x[i]*w[i];
      }
      else {
        r+=x[i]*w[i];
      }
    }
    int aN=0 ;
    ArrayList<Integer>xn=new ArrayList<Integer>();
    ArrayList<Integer>wn=new ArrayList<Integer>();
    if(l==r){
      aN=0 ;
    }
    else if(l<r){
      while(r-l>50000){
        aN++;
        xn.add(-1);
        wn.add(50000);
        l+=50000 ;
      }
      aN++;
      xn.add(-1);
      wn.add(r-l);
    }
    else {
      while(l-r>50000){
        aN++;
        xn.add(1);
        wn.add(50000);
        r+=50000 ;
      }
      aN++;
      xn.add(1);
      wn.add(l-r);
    }
    System.out.println(aN);
    for(int i=0 ; i<aN ; i++){
      System.out.println(xn.get(i)+" "+wn.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var L : int ; L := sc.getCurrent()->toInteger() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,N)->collect(0) ;
    var w : Sequence(int) ; w := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     w[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (x[i+1] = 0) then     continue else skip ; 
     if (x[i+1] < 0) then (     l := l+(-x[i+1] * w[i+1]) ) else (     r := r+(x[i+1] * w[i+1]) ) )  ;     i := i + 1 ) ; 
    var aN : int ; aN := 0 ;
    var xn : Sequence(int) ; xn := Sequence{} ;
    var wn : Sequence(int) ; wn := Sequence{} ;
    if (l = r) then (     aN := 0 ) else     if (l < r) then (     while (r - l > 50000) do (     aN := aN + 1 ; 
     xn := xn->including(-1) ; 
     wn := wn->including(50000) ; 
     l := l+(50000) ) ; 
     aN := aN + 1 ; 
     xn := xn->including(-1) ; 
     wn := wn->including(r - l) ) else (     while (l - r > 50000) do (     aN := aN + 1 ; 
     xn := xn->including(1) ; 
     wn := wn->including(50000) ; 
     r := r+(50000) ) ; 
     aN := aN + 1 ; 
     xn := xn->including(1) ; 
     wn := wn->including(l - r) ) ;  ;  
    OclFile["System.out"].println(aN) ; 
        var i : int ; i := 0 ; while i < aN do ( (     OclFile["System.out"].println(xn->at(i+1) + " " + wn->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int l=sc.nextInt();
    int n=sc.nextInt();
    StringBuilder sb=new StringBuilder();
    sb.append(n).append("\n");
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      int w=sc.nextInt();
      sb.append(-x).append(" ").append(w).append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString(n) + StringLib.newString("\n") ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
     sb := sb + StringLib.newString(-x) + StringLib.newString(" ") + StringLib.newString(w) + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.reflect.Array ;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static int cnt=1 ;
  public static void main(String[] args)throws IOException {
    FastReader in=new FastReader();
    Main main=new Main();
    long a=in.nextLong(),b=in.nextLong();
    a=main.GCD(a,b);
    factorial(a);
    System.out.print(cnt);
  }
  public static void factorial(long a){
    if(a % 2==0){
      cnt++;
    }
    while(a % 2==0){
      a/=2 ;
    }
    if(a % 3==0){
      cnt++;
    }
    while(a % 3==0){
      a/=3 ;
    }
    for(long i=5 ; i*i<=a ; i+=2){
      if(a % i==0){
        cnt++;
        while(a % i==0){
          a/=i ;
        }
      }
    }
    if(a>2){
      cnt++;
    }
  }
  private long GCD(long a,long b){
    if(b==0)return a ;
    return GCD(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   attribute cnt : int := 1;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var main : Main ; main := Main.newMain() ;
    var a : long ; a := in.nextLong() ;
    var b : long ; b := in.nextLong() ;
    a := main.GCD(a, b) ; 
    execute factorial(a) ; 
    OclFile["System.out"].print(cnt) ; 
 );
  static   operation factorial( a : long) : void
  pre: true
  post: true
  activity: (     if (a mod 2 = 0) then (     cnt := cnt + 1 ) else skip ; 
     while (a mod 2 = 0) do (     a := a/(2) ) ; 
    if (a mod 3 = 0) then (     cnt := cnt + 1 ) else skip ; 
    while (a mod 3 = 0) do (     a := a/(3) ) ; 
        var i : long ; i := 5 ; while i * i <= a do ( (     if (a mod i = 0) then (     cnt := cnt + 1 ; 
     while (a mod i = 0) do (     a := a/(i) ) ) else skip )  ;     i := i+(2) ) ; 
    if (a > 2) then (     cnt := cnt + 1 ) else skip ; 
 );
   operation GCD( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return GCD(b, a mod b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a=sc.nextLong();
    long b=sc.nextLong();
    long ans=solve(a,b);
    System.out.println(ans);
  }
  static long solve(long a,long b){
    long gcd=gcd(a,b);
    long ans=primeFactorize(gcd);
    return ans ;
  }
  private static long primeFactorize(long gcd){
    Map<Long,Long>m=new HashMap<>();
    for(long i=2 ; i*i<=gcd ; i++){
      if(gcd % i!=0){
        continue ;
      }
      while(gcd % i==0){
        gcd/=i ;
        m.put(i,m.getOrDefault(i,0L)+1);
      }
    }
    if(gcd>1){
      m.put(gcd,m.getOrDefault(gcd,0L)+1);
    }
    return m.keySet().size()+1 ;
  }
  static long gcd(long x,long y){
    if(y==0){
      return x ;
    }
    if(x>=y){
      x=x % y ;
    }
    return gcd(y,x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var ans : long ; ans := solve(a, b) ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation solve( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var gcd : long ; gcd := gcd(a, b) ;
     var ans : long ; ans := primeFactorize(gcd) ;
     return ans );
  static   operation primeFactorize( gcd : long) : long
  pre: true
  post: true
  activity: (     var m : Map(long,long) ; m := Map{} ;
         var i : long ; i := 2 ; while i * i <= gcd do ( (     if (gcd mod i /= 0) then (     continue ) else skip ; 
     while (gcd mod i = 0) do (     gcd := gcd/(i) ; 
     m := m->union(Map{i |-> (if m->keys()->contains(i) then m->at(i) else 0L endif) + 1}) ) )  ;     i := i + 1 ) ; 
     if (gcd > 1) then (     m := m->union(Map{gcd |-> (if m->keys()->contains(gcd) then m->at(gcd) else 0L endif) + 1}) ) else skip ; 
     return m->keys()->size() + 1 );
  static   operation gcd( x : long, y : long) : long
  pre: true
  post: true
  activity: (     if (y = 0) then (     return x ) else skip ; 
     if (x >= y) then (     x := x mod y ) else skip ; 
     return gcd(y, x) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    resolve(System.in,System.out);
  }
  static void resolve(InputStream is,PrintStream pw){
    Scanner sc=new Scanner(is);
    long a=Long.parseLong(sc.next());
    long b=Long.parseLong(sc.next());
    boolean aIsMin=a<b ;
    if(aIsMin){
      long[] minPrimes=primes(a);
      Set<Long>and=primesAnd(b,minPrimes);
      pw.println(and.size()+1);
    }
    else {
      long[] minPrimes=primes(b);
      Set<Long>and=primesAnd(a,minPrimes);
      pw.println(and.size()+1);
    }
  }
  static long[] primes(long n){
    long[] ans=new long[64];
    int count=0 ;
    if(n % 2==0){
      ans[count]=2 ;
      count++;
      n=n/2 ;
      while(n % 2==0){
        n=n/2 ;
      }
    }
    long d=3 ;
    while(d<=n){
      d=tryDivide(n,d);
      n=n/d ;
      ans[count]=d ;
      count++;
      while(n % d==0){
        n=n/d ;
      }
    }
    return ans ;
  }
  static long tryDivide(long n,long min){
    long max=(long)Math.sqrt(n);
    for(long i=min ; i<=max ; i+=2){
      if(n % i==0){
        return i ;
      }
    }
    return n ;
  }
  static Set<Long>primesAnd(long n,long[] prev){
    Set<Long>ans=new HashSet<>();
    for(long p : prev){
      if(p==0){
        break ;
      }
      if(n % p==0){
        ans.add(p);
        n=n/p ;
      }
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute resolve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation resolve( is : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(is) ;
     var a : long ; a := (sc.getCurrent())->toLong() ;
    var b : long ; b := (sc.getCurrent())->toLong() ;
    var aIsMin : boolean ; aIsMin := a < b ;
    if (aIsMin) then (     var minPrimes : Sequence(long) ; minPrimes := primes(a) ;
     var and : Set(long) ; and := primesAnd(b, minPrimes) ;
     pw.println(and->size() + 1) ) else (     var minPrimes : Sequence(long) ; minPrimes := primes(b) ;
     var and : Set(long) ; and := primesAnd(a, minPrimes) ;
     pw.println(and->size() + 1) ) ;  
 );
  static   operation primes( n : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var ans : Sequence(long) ; ans := Integer.subrange(1,64)->collect(0) ;
     var count : int ; count := 0 ;
    if (n mod 2 = 0) then (     ans[count+1] := 2 ; 
     count := count + 1 ; 
     n := n / 2 ; 
     while (n mod 2 = 0) do (     n := n / 2 ) ) else skip ; 
    var d : long ; d := 3 ;
    while (d <= n) do (     d := tryDivide(n, d) ; 
     n := n / d ; 
    ans[count+1] := d ; 
    count := count + 1 ; 
    while (n mod d = 0) do (     n := n / d ) ; 
 ) ; 
    return ans 
 );
  static   operation tryDivide( n : long, min : long) : long
  pre: true
  post: true
  activity: (     var max : long ; max := (n)->sqrt()->oclAsType(long) ;
         var i : long ; i := min ; while i <= max do ( (     if (n mod i = 0) then (     return i ) else skip )  ;     i := i+(2) ) ; 
     return n );
  static   operation primesAnd( n : long, prev : Sequence(long)) : Set(long)
  pre: true
  post: true
  activity: (     var ans : Set(long) ; ans := Set{} ;
     for (p : prev) do ( (     if (p = 0) then (     break ) else skip ; 
     if (n mod p = 0) then (     ans := ans->including(p) ; 
     n := n / p ) else skip )  ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    D solver=new D();
    solver.solve(1,in,out);
    out.close();
  }
  static class D {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      long A=in.nextLong();
      long B=in.nextLong();
      long max=gcd(A,B);
      Set<Long>list=new HashSet<>();
      for(long i=2 ; i*i<=max ; i++){
        if(max % i==0){
          list.add(i);
          while(max % i==0){
            max/=i ;
          }
        }
      }
      if(max>1){
        list.add(max);
      }
      out.println(list.size()+1);
    }
    long gcd(long a,long b){
      return b==0 ? a : gcd(b,a % b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : D ; solver := D.newD() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class D {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var A : long ; A := in.getCurrent()->toLong() ;
     var B : long ; B := in.getCurrent()->toLong() ;
    var max : long ; max := gcd(A, B) ;
    var list : Set(long) ; list := Set{} ;
        var i : long ; i := 2 ; while i * i <= max do ( (     if (max mod i = 0) then (     list := list->including(i) ; 
     while (max mod i = 0) do (     max := max/(i) ) ) else skip )  ;     i := i + 1 ) ; 
    if (max > 1) then (     list := list->including(max) ) else skip ; 
    skip ; 
 );
   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String word[]={
    "zero","one","two","three","four","five","six","seven","eight","nine" };
    static void printWordsWithoutIfSwitch(int n){
      int digits[]=new int[10];
      int dc=0 ;
      do {
        digits[dc]=n % 10 ;
        n=n/10 ;
        dc++;
      }
      while(n!=0);
      for(int i=dc-1 ; i>=0 ; i--)System.out.print(word[digits[i] ]+" ");
    }
    public static void main(String[] args){
      int n=350 ;
      printWordsWithoutIfSwitch(n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute word : String := Sequence{"zero","one","two","three","four","five","six","seven","eight","nine"};
  static   operation printWordsWithoutIfSwitch( n : int) : void
  pre: true
  post: true
  activity: (     var digits : Sequence(int) ; digits := Integer.subrange(1,10)->collect(0) ;
     var dc : int ; dc := 0 ;
   while true do ((     digits[dc+1] := n mod 10 ; 
     n := n / 10 ; 
     dc := dc + 1 ) ;
    if (n /= 0) then skip else break) ; 
         var i : int ; i := dc - 1 ; while i >= 0 do (     OclFile["System.out"].print(word[digits[i+1]+1] + " ") ;  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 350 ;
     execute printWordsWithoutIfSwitch(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader bf=null ;
    bf=new BufferedReader(new InputStreamReader(System.in));
    long a,b,ans=0,temp,kouyaku,n ;
    String str ;
    String[] s ;
    str=bf.readLine();
    s=str.split(" ");
    a=Long.parseLong(s[0]);
    b=Long.parseLong(s[1]);
    if(a<b){
      temp=a ;
      a=b ;
      b=temp ;
    }
    while(a % b!=0){
      temp=a % b ;
      a=b ;
      b=temp ;
    }
    kouyaku=b ;
    ans=1 ;
    if(kouyaku!=1){
      if(kouyaku % 2==0){
        ans++;
        while(kouyaku % 2==0){
          kouyaku/=2 ;
        }
      }
      n=3 ;
      if(kouyaku!=1){
        while(kouyaku>=n*n){
          if(kouyaku % n==0){
            ans++;
            while(kouyaku % n==0){
              kouyaku/=n ;
            }
          }
          n+=2 ;
        }
      }
      if(kouyaku!=1){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := null ;
     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
    var a : long ;
    var b : long ;
    var ans : long ; ans := 0 ;
    var temp : long ;
    var kouyaku : long ;
    var n : long ;
    var str : String ;
    var s : Sequence(String) ;
    str := bf.readLine() ; 
    s := str->split(" ") ; 
    a := (s[0+1])->toLong() ; 
    b := (s[1+1])->toLong() ; 
    if (a < b) then (     temp := a ; 
     a := b ; 
     b := temp ) else skip ; 
    while (a mod b /= 0) do (     temp := a mod b ; 
     a := b ; 
     b := temp ) ; 
    kouyaku := b ; 
    ans := 1 ; 
    if (kouyaku /= 1) then (     if (kouyaku mod 2 = 0) then (     ans := ans + 1 ; 
     while (kouyaku mod 2 = 0) do (     kouyaku := kouyaku/(2) ) ) else skip ; 
     n := 3 ; 
     if (kouyaku /= 1) then (     while (kouyaku >= n * n) do (     if (kouyaku mod n = 0) then (     ans := ans + 1 ; 
     while (kouyaku mod n = 0) do (     kouyaku := kouyaku/(n) ) ) else skip ; 
     n := n+(2) ) ) else skip ; 
     if (kouyaku /= 1) then (     ans := ans + 1 ) else skip ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int power(long x,long y,long p){
    int res=1 ;
    x=x % p ;
    while(y>0){
      long r=y & 1 ;
      if(r==1)res=(res*(int)x)%(int)p ;
      y=y>>1 ;
      x=(x*x)% p ;
    }
    return res ;
  }
  static int numberOfDigits(int x){
    int i=0 ;
    while(x!=0){
      x/=10 ;
      i++;
    }
    return i ;
  }
  static void LastTwoDigit(int n){
    System.out.print("Last "+2+" digits of "+2+"^");
    System.out.print(n+"=");
    int temp=1 ;
    for(int i=1 ; i<=2 ; i++)temp*=10 ;
    temp=power(2,n,temp);
    for(int i=0 ; i<(2-numberOfDigits(temp)); i++)System.out.print(0+" ");
    if(temp!=0)System.out.println(temp);
  }
  public static void main(String[] args){
    int n=72 ;
    LastTwoDigit(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation power( x : long, y : long, p : long) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     var r : long ; r := MathLib.bitwiseAnd(y,1) ;
     if (r = 1) then     res := (res * x->oclAsType(int)) mod p->oclAsType(int) ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res );
  static   operation numberOfDigits( x : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     while (x /= 0) do (     x := x/(10) ; 
     i := i + 1 ) ; 
     return i );
  static   operation LastTwoDigit( n : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("Last " + 2 + " digits of " + 2 + "^") ; 
     OclFile["System.out"].print(n + "=") ; 
    var temp : int ; temp := 1 ;
        var i : int ; i := 1 ; while i <= 2 do (     temp := temp*(10) ;  ;     i := i + 1 ) ; 
    temp := power(2, n, temp) ; 
        var i : int ; i := 0 ; while i < (2 - numberOfDigits(temp)) do (     OclFile["System.out"].print(0 + " ") ;  ;     i := i + 1 ) ; 
    if (temp /= 0) then     OclFile["System.out"].println(temp) ; else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 72 ;
     execute LastTwoDigit(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class Main {
  public static char[] lexo_small(int n,int k){
    char arr[]=new char[n];
    Arrays.fill(arr,'a');
    for(int i=n-1 ; i>=0 ; i--){
      k-=i ;
      if(k>=0){
        if(k>=26){
          arr[i]='z' ;
          k-=26 ;
        }
        else {
          arr[i]=(char)(k+97-1);
          k-=arr[i]-'a'+1 ;
        }
      }
      else break ;
      k+=i ;
    }
    return arr ;
  }
  public static void main(String[] args){
    int n=5,k=42 ;
    char arr[]=lexo_small(n,k);
    System.out.print(new String(arr));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation lexo_small( n : int, k : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Integer.subrange(1,n)->collect(0) ;
     arr := arr->collect('a') ; 
         var i : int ; i := n - 1 ; while i >= 0 do ( (     k := k-(i) ; 
     if (k >= 0) then (     if (k >= 26) then (     arr[i+1] := 'z' ; 
     k := k-(26) ) else (     arr[i+1] := (k + 97 - 1)->oclAsType(String) ; 
     k := k-(arr[i+1] - ('a')->char2byte() + 1) ) ) else     break ;  
     k := k+(i) )  ;     i := i - 1 ) ; 
     return arr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var k : int ; k := 42 ;
     var arr : Sequence(String) ; arr := lexo_small(n, k) ;
     OclFile["System.out"].print(StringLib.newString(arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int countTriplets(int[] arr,int n,int a,int b){
    int ans=0 ;
    for(int i=0 ; i<n-2 ; i++){
      for(int j=i+1 ; j<n-1 ; j++){
        for(int k=j+1 ; k<n ; k++){
          if(arr[i]+arr[j]+arr[k]>=a && arr[i]+arr[j]+arr[k]<=b){
            ans++;
          }
        }
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int[] arr={
      2,7,5,3,8,4,1,9 };
      int n=arr.length ;
      int a=8,b=16 ;
      System.out.println(""+countTriplets(arr,n,a,b));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countTriplets( arr : Sequence(int), n : int, a : int, b : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n - 2 do ( (         var j : int ; j := i + 1 ; while j < n - 1 do ( (         var k : int ; k := j + 1 ; while k < n do ( (     if (arr[i+1] + arr[j+1] + arr[k+1] >= a & arr[i+1] + arr[j+1] + arr[k+1] <= b) then (     ans := ans + 1 ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,7,5,3,8,4,1,9} ;
     var n : int ; n := arr->size() ;
     var a : int ; a := 8 ;
    var b : int ; b := 16 ;
     OclFile["System.out"].println("" + countTriplets(arr, n, a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Gfg {
  static float areacircumscribed(float a){
    float PI=3.14159265f ;
    return(a*a*(PI/2));
  }
  public static void main(String arg[]){
    float a=6 ;
    System.out.print("Area of an circumscribed"+"circle is :");
    System.out.println(areacircumscribed(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Gfg {
  static   operation areacircumscribed( a : double) : double
  pre: true
  post: true
  activity: (     var PI : double ; PI := 3.14159265f ;
     return (a * a * (PI / 2)) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 6 ;
     OclFile["System.out"].print("Area of an circumscribed" + "circle is :") ; 
     OclFile["System.out"].println(areacircumscribed(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float polydiagonal(float n,float a){
    if(a<0 && n<0){
      return-1 ;
    }
    return(float)(2*a*Math.sin((((n-2)*180)/(2*n))*3.14159/180));
  }
  public static void main(String[] args){
    float a=9,n=10 ;
    System.out.printf("%.3f",polydiagonal(n,a));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation polydiagonal( n : double, a : double) : double
  pre: true
  post: true
  activity: (     if (a < 0 & n < 0) then (     return -1 ) else skip ; 
     return (2 * a * ((((n - 2) * 180) / (2 * n)) * 3.14159 / 180)->sin())->oclAsType(double) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 9 ;
    var n : double ; n := 10 ;
     OclFile["System.out"].printf("%.3f", polydiagonal(n, a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String removeOddFrequencyCharacters(String s){
    HashMap<Character,Integer>m=new HashMap<Character,Integer>();
    for(int i=0 ; i<s.length(); i++){
      char p=s.charAt(i);
      Integer count=m.get(p);
      if(count==null){
        count=0 ;
        m.put(p,1);
      }
      else m.put(p,count+1);
    }
    String new_string="" ;
    for(int i=0 ; i<s.length(); i++){
      if((m.get(s.charAt(i))& 1)==1)continue ;
      new_string+=s.charAt(i);
    }
    return new_string ;
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    str=removeOddFrequencyCharacters(str);
    System.out.print(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation removeOddFrequencyCharacters( s : String) : String
  pre: true
  post: true
  activity: (     var m : Map(String,int) ; m := Map{} ;
         var i : int ; i := 0 ; while i < s->size() do ( (     var p : String ; p := s->at(i+1) ;
     var count : int ; count := m->at(p) ;
     if (count = null) then (     count := 0 ; 
     m := m->union(Map{p |-> 1}) ) else     m := m->union(Map{p |-> count + 1}) ; )  ;     i := i + 1 ) ; 
    var new_string : String ; new_string := "" ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if ((m->at(s->at(i+1)) & 1) = 1) then     continue else skip ; 
     new_string := new_string+(s->at(i+1)) )  ;     i := i + 1 ) ; 
    return new_string 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     str := removeOddFrequencyCharacters(str) ; 
     OclFile["System.out"].print(str) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countDivisors(int n){
    int count=0 ;
    for(int i=1 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        if(n/i==i)count++;
        else count+=2 ;
      }
    }
    return count ;
  }
  static int MaximumDivisors(int X,int Y){
    int maxDivisors=0,result=0 ;
    int[] arr=new int[Y-X+1];
    for(int i=X ; i<=Y ; i++){
      int Div=countDivisors(i);
      arr[i-X]=Div ;
      maxDivisors=Math.max(Div,maxDivisors);
    }
    for(int i=0 ; i<(Y-X+1); i++)if(arr[i]==maxDivisors)result++;
    return result ;
  }
  public static void main(String[] args){
    int X=1,Y=10 ;
    System.out.println(MaximumDivisors(X,Y));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countDivisors( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     if (n / i = i) then     count := count + 1 ; else     count := count+(2) ; ) else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation MaximumDivisors( X : int, Y : int) : int
  pre: true
  post: true
  activity: (     var maxDivisors : int ; maxDivisors := 0 ;
    var result : int ; result := 0 ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,Y - X + 1)->collect(0) ;
        var i : int ; i := X ; while i <= Y do ( (     var Div : int ; Div := countDivisors(i) ;
     arr[i - X+1] := Div ; 
     maxDivisors := Set{Div, maxDivisors}->max() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < (Y - X + 1) do (     if (arr[i+1] = maxDivisors) then     result := result + 1 ; else skip ;  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 1 ;
    var Y : int ; Y := 10 ;
     OclFile["System.out"].println(MaximumDivisors(X, Y)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Evaluate_BoolExp {
  static int evaluateBoolExpr(StringBuffer s){
    int n=s.length();
    for(int i=0 ; i<n ; i+=2){
      if(i+1<n && i+2<n){
        if(s.charAt(i+1)=='A'){
          if(s.charAt(i+2)=='0' || s.charAt(i)==0)s.setCharAt(i+2,'0');
          else s.setCharAt(i+2,'1');
        }
        else if((i+1)<n && s.charAt(i+1)=='B'){
          if(s.charAt(i+2)=='1' || s.charAt(i)=='1')s.setCharAt(i+2,'1');
          else s.setCharAt(i+2,'0');
        }
        else {
          if(s.charAt(i+2)==s.charAt(i))s.setCharAt(i+2,'0');
          else s.setCharAt(i+2,'1');
        }
      }
    }
    return s.charAt(n-1)-'0' ;
  }
  public static void main(String[] args){
    String s="1C1B1B0A0" ;
    StringBuffer sb=new StringBuffer(s);
    System.out.println(evaluateBoolExpr(sb));
  }
}
------------------------------------------------------------
OCL File:
---------
class Evaluate_BoolExp {
  static   operation evaluateBoolExpr( s : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
         var i : int ; i := 0 ; while i < n do ( (     if (i + 1 < n & i + 2 < n) then (     if (s->at(i + 1+1) = 'A') then (     if (s->at(i + 2+1) = '0' or s->at(i+1) = 0) then     s := s.setAt(i + 2+1, '0') ; else     s := s.setAt(i + 2+1, '1') ; ) else     if ((i + 1) < n & s->at(i + 1+1) = 'B') then (     if (s->at(i + 2+1) = '1' or s->at(i+1) = '1') then     s := s.setAt(i + 2+1, '1') ; else     s := s.setAt(i + 2+1, '0') ; ) else (     if (s->at(i + 2+1) = s->at(i+1)) then     s := s.setAt(i + 2+1, '0') ; else     s := s.setAt(i + 2+1, '1') ; ) ;  ) else skip )  ;     i := i+(2) ) ; 
     return s->at(n - 1+1) - ('0')->char2byte() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "1C1B1B0A0" ;
     var sb : String ; sb := StringLib.newString(s) ;
     OclFile["System.out"].println(evaluateBoolExpr(sb)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _513A_Game {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n1=input.nextInt();
    int n2=input.nextInt();
    int k1=input.nextInt();
    int k2=input.nextInt();
    if(n1>n2){
      System.out.println("First");
    }
    else {
      System.out.println("Second");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _513A_Game {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n1 : int ; n1 := input.getCurrent()->toInteger() ;
    var n2 : int ; n2 := input.getCurrent()->toInteger() ;
    var k1 : int ; k1 := input.getCurrent()->toInteger() ;
    var k2 : int ; k2 := input.getCurrent()->toInteger() ;
    if (n1 > n2) then (     OclFile["System.out"].println("First") ) else (     OclFile["System.out"].println("Second") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    StringTokenizer st=new StringTokenizer(f.readLine());
    int n=Integer.parseInt(st.nextToken());
    long k=Integer.parseInt(st.nextToken());
    long m=Integer.parseInt(st.nextToken());
    long[] a=new long[n];
    st=new StringTokenizer(f.readLine());
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(st.nextToken());
      sum+=a[i];
    }
    Arrays.sort(a);
    double max=(sum+Math.min(m,n*k))/(double)n ;
    for(int i=1 ; i<Math.min(n,m+1); i++){
      sum-=a[i-1];
      max=Math.max(max,(sum+Math.min(m-i,(n-i)*k))/(double)(n-i));
    }
    out.printf("%.20f\n",max);
    f.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var k : long ; k := (st.next())->toInteger() ;
    var m : long ; m := (st.next())->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    st := OclIterator.newOclIterator_String(f.readLine()) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (st.next())->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var max : double ; max := (sum + Set{m, n * k}->min()) / n->oclAsType(double) ;
        var i : int ; i := 1 ; while i < Set{n, m + 1}->min() do ( (     sum := sum-(a[i - 1+1]) ; 
     max := Set{max, (sum + Set{m - i, (n - i) * k}->min()) / (n - i)->oclAsType(double)}->max() )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Game {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    byte n1=s.nextByte();
    byte n2=s.nextByte();
    byte k1=s.nextByte();
    byte k2=s.nextByte();
    if(n1>n2)System.out.println("First");
    else System.out.println("Second");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Game {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n1 : int ; n1 := s.nextByte() ;
    var n2 : int ; n2 := s.nextByte() ;
    var k1 : int ; k1 := s.nextByte() ;
    var k2 : int ; k2 := s.nextByte() ;
    if (n1 > n2) then     OclFile["System.out"].println("First") else     OclFile["System.out"].println("Second") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class game {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n1=Integer.parseInt(st.nextToken());
    int n2=Integer.parseInt(st.nextToken());
    int k1=Integer.parseInt(st.nextToken());
    int k2=Integer.parseInt(st.nextToken());
    if(n1>n2){
      pw.println("First");
    }
    else {
      pw.println("Second");
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class game {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n1 : int ; n1 := (st.next())->toInteger() ;
    var n2 : int ; n2 := (st.next())->toInteger() ;
    var k1 : int ; k1 := (st.next())->toInteger() ;
    var k2 : int ; k2 := (st.next())->toInteger() ;
    if (n1 > n2) then (     skip ) else (     skip ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class _513a_Game {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n1=in.nextInt();
    int n2=in.nextInt();
    int k1=in.nextInt();
    int k2=in.nextInt();
    if(n2>=n1){
      System.out.println("Second");
    }
    else {
      System.out.println("First");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _513a_Game {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n1 : int ; n1 := in.getCurrent()->toInteger() ;
    var n2 : int ; n2 := in.getCurrent()->toInteger() ;
    var k1 : int ; k1 := in.getCurrent()->toInteger() ;
    var k2 : int ; k2 := in.getCurrent()->toInteger() ;
    if (n2 >= n1) then (     OclFile["System.out"].println("Second") ) else (     OclFile["System.out"].println("First") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Stack ;
public class solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      Stack<Integer>stack=new Stack<>();
      if(n % 2==0){
        while(n>0){
          stack.add(n-1);
          stack.add(n);
          n=n-2 ;
        }
      }
      else {
        while(n>1){
          stack.add(n-1);
          stack.add(n);
          n=n-2 ;
        }
        stack.push(1);
      }
      while(! stack.isEmpty())System.out.print(stack.pop()+" ");
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var stack : Sequence(int) ; stack := Sequence{} ;
    if (n mod 2 = 0) then (     while (n > 0) do (     stack := stack->including(n - 1) ; 
     stack := stack->including(n) ; 
     n := n - 2 ) ) else (     while (n > 1) do (     stack := stack->including(n - 1) ; 
     stack := stack->including(n) ; 
     n := n - 2 ) ; 
     stack := stack->append(1) ) ;  
    while (not(stack->isEmpty())) do     OclFile["System.out"].print(stack->last() + " ") ; ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    System.out.println(pythagoras(n));
  }
  public static int pythagoras(int n){
    int answer=0 ;
    for(int i=1 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        double num=Math.sqrt((Math.pow(i,2)+Math.pow(j,2)));
        if(num % 1==0 && num<=n){
          answer++;
        }
      }
    }
    return answer ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
     OclFile["System.out"].println(pythagoras(n)) );
  static   operation pythagoras( n : int) : int
  pre: true
  post: true
  activity: (     var answer : int ; answer := 0 ;
         var i : int ; i := 1 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var num : double ; num := ((i->pow(2) + j->pow(2)))->sqrt() ;
     if (num mod 1 = 0 & num <= n) then (     answer := answer + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return answer );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PythagoreanTheorem {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int count=0 ;
    for(int a=1 ; a<=n ; a++){
      for(int b=a+1 ; b<=n ; b++){
        int cc=a*a+b*b ;
        int c=(int)Math.sqrt(cc);
        if(c*c==cc && c<=n)count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class PythagoreanTheorem {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var a : int ; a := 1 ; while a <= n do ( (         var b : int ; b := a + 1 ; while b <= n do ( (     var cc : int ; cc := a * a + b * b ;
     var c : int ; c := (cc)->sqrt()->oclAsType(int) ;
     if (c * c = cc & c <= n) then     count := count + 1 ; else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PythagoreanTheoremII {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int count=0 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=i+1 ; j<=n ; j++){
        double ans=i*i+j*j ;
        ans=Math.sqrt(ans);
        if(ans<=n && Math.floor(ans)==ans)count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class PythagoreanTheoremII {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i + 1 ; while j <= n do ( (     var ans : double ; ans := i * i + j * j ;
     ans := (ans)->sqrt() ; 
     if (ans <= n & (ans)->floor() = ans) then     count := count + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int ans=0 ;
    for(int a=1 ; a<=n ; a++){
      for(int b=a ; b<=n ; b++){
        double cc=Math.sqrt(a*a+b*b);
        int c=(int)cc ;
        if(c<=n &&(c==cc)){
          ans++;
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var a : int ; a := 1 ; while a <= n do ( (         var b : int ; b := a ; while b <= n do ( (     var cc : double ; cc := (a * a + b * b)->sqrt() ;
     var c : int ; c := cc->oclAsType(int) ;
     if (c <= n & (c = cc)) then (     ans := ans + 1 ) else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void findNthTerm(int n){
    n=n*2 ;
    int a=1,b=1,c=-1*n ;
    int d=b*b-4*a*c ;
    double sqrt_val=Math.sqrt(Math.abs(d));
    int x1=(int)((-b+sqrt_val)/(2*a));
    int x2=(int)((-b-sqrt_val)/(2*a));
    if(x1>=1)System.out.println((char)('a'+x1));
    else if(x2>=1)System.out.println((char)('a'+x2));
  }
  public static void main(String[] args){
    int n=12 ;
    findNthTerm(n);
    n=288 ;
    findNthTerm(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNthTerm( n : int) : void
  pre: true
  post: true
  activity: (     n := n * 2 ; 
     var a : int ; a := 1 ;
    var b : int ; b := 1 ;
    var c : int ; c := -1 * n ;
    var d : int ; d := b * b - 4 * a * c ;
    var sqrt_val : double ; sqrt_val := (if d < 0 then -(d) else d endif)->sqrt() ;
    var x1 : int ; x1 := ((-b + sqrt_val) / (2 * a))->oclAsType(int) ;
    var x2 : int ; x2 := ((-b - sqrt_val) / (2 * a))->oclAsType(int) ;
    if (x1 >= 1) then     OclFile["System.out"].println(('a' + x1)->oclAsType(String)) else     if (x2 >= 1) then     OclFile["System.out"].println(('a' + x2)->oclAsType(String)) ; else skip ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     execute findNthTerm(n) ; 
     n := 288 ; 
     execute findNthTerm(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float area(float a,float b){
    if(a<0 || b<0)return-1 ;
    float A=a*b ;
    return A ;
  }
  public static void main(String[] args){
    float a=5,b=2 ;
    System.out.println(area(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation area( a : double, b : double) : double
  pre: true
  post: true
  activity: (     if (a < 0 or b < 0) then     return -1 else skip ; 
     var A : double ; A := a * b ;
     return A );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 5 ;
    var b : double ; b := 2 ;
     OclFile["System.out"].println(area(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Ishu {
  static Scanner scan=new Scanner(System.in);
  static void tc(){
    int n=scan.nextInt();
    int k=scan.nextInt();
    int m=scan.nextInt();
    long sum=0l ;
    int[] a=new int[n];
    int i,j ;
    int[] oper=new int[n];
    for(i=0 ; i<n ; ++i){
      a[i]=scan.nextInt();
      sum+=a[i];
    }
    int last=a[n-1];
    int cur=n ;
    double ans=0.0 ;
    Arrays.sort(a,0,n);
    i=0 ;
    j=n-1 ;
    int temp=m ;
    while(m>0 && i<=j){
      if(cur==1){
        ans=a[n-1]+Math.min(k-oper[n-1],m);
        break ;
      }
      double one=(sum-a[i])/(double)(cur-1);
      double two=(sum+1)/(double)(cur);
      if(one>=two){
        sum-=a[i++];
        cur--;
        ans=one ;
      }
      else {
        sum++;
        a[j]++;
        oper[j]++;
        if(oper[j]==k)--j ;
        ans=two ;
      }
      m--;
    }
    if(temp>=n){
      temp-=n-1 ;
      temp=Math.min(temp,k);
      ans=Math.max(ans,temp+last);
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    int t=1 ;
    while(t-->0)tc();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ishu {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation tc() : void
  pre: true
  post: true
  activity: (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var k : int ; k := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var sum : long ; sum := 0l ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var i : int ;
    var j : int ;
    var oper : Sequence(int) ; oper := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    var last : int ; last := a[n - 1+1] ;
    var cur : int ; cur := n ;
    var ans : double ; ans := 0.0 ;
    a := a.subrange(1,0)^(a.subrange(0+1,n)->sort())^a.subrange(n+1,a.size) ; 
    i := 0 ; 
    j := n - 1 ; 
    var temp : int ; temp := m ;
    while (m > 0 & i <= j) do (     if (cur = 1) then (     ans := a[n - 1+1] + Set{k - oper[n - 1+1], m}->min() ; 
     break ) else skip ; 
     var one : double ; one := (sum - a[i+1]) / (cur - 1)->oclAsType(double) ;
    var two : double ; two := (sum + 1) / (cur)->oclAsType(double) ;
    if (one >= two) then (      sum := sum - (a[i+1])  ; i := i + 1 ; 
     cur := cur - 1 ; 
     ans := one ) else (     sum := sum + 1 ; 
     a[j+1] := a[j+1] + 1 ; 
    oper[j+1] := oper[j+1] + 1 ; 
    if (oper[j+1] = k) then     j := j - 1 ; else skip ; 
    ans := two ; 
 ) ;  
    m := m - 1 ; 
 ) ; 
    if (temp >= n) then (     temp := temp-(n - 1) ; 
     temp := Set{temp, k}->min() ; 
     ans := Set{ans, temp + last}->max() ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ;     execute tc() ; ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Mridul6 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int k=0 ;
    while(k!=t){
      k=k+1 ;
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      double d=(double)c/b ;
      if(a>=c){
        System.out.println(-1+" "+10);
      }
      else if(d>a){
        System.out.println(10+" "+-1);
      }
      else if(d==a){
        int i=b ;
        while(i % b==0){
          i=i+1 ;
        }
        System.out.println(i % 1000000000+" "+-1);
      }
      else {
        System.out.println(1+" "+b);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mridul6 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     var k : int ; k := 0 ;
     while (k /= t) do (     k := k + 1 ; 
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : double ; d := c->oclAsType(double) / b ;
    if (a >= c) then (     OclFile["System.out"].println(-1 + " " + 10) ) else     if (d > a) then (     OclFile["System.out"].println(10 + " " + -1) ) else     if (d = a) then (     var i : int ; i := b ;
     while (i mod b = 0) do (     i := i + 1 ) ; 
     OclFile["System.out"].println(i mod 1000000000 + " " + -1) ) else (     OclFile["System.out"].println(1 + " " + b) ) ;  ;  ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      System.out.println(solve(a,b,c));
    }
    sc.close();
  }
  static String solve(int a,int b,int c){
    return String.format("%d %d",(a<c)? 1 :-1,(c<(long)a*b)? b :-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(a, b, c)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : int, b : int, c : int) : String
  pre: true
  post: true
  activity: (     return StringLib.format("%d %d",Sequence{if (a < c) then 1 else -1 endif,if (c < a->oclAsType(long) * b) then b else -1 endif}) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class problem1373A {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int t=scn.nextInt();
    while(t-->0){
      long a=scn.nextLong();
      long b=scn.nextLong();
      long c=scn.nextLong();
      if(a<c)System.out.print(1+" ");
      else System.out.print(-1+" ");
      if(b*a>c)System.out.print(b+" ");
      else System.out.print(-1+" ");
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class problem1373A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scn.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : long ; a := scn.getCurrent()->toLong() ;
     var b : long ; b := scn.getCurrent()->toLong() ;
    var c : long ; c := scn.getCurrent()->toLong() ;
    if (a < c) then     OclFile["System.out"].print(1 + " ") else     OclFile["System.out"].print(-1 + " ") ; ;  
    if (b * a > c) then     OclFile["System.out"].print(b + " ") else     OclFile["System.out"].print(-1 + " ") ; ;  
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class AA {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int p=0 ; p<t ; p++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      double y=(double)c/(double)b ;
      if(c<=a)System.out.println("-1 2");
      else if(y<a)System.out.println("1 "+b);
      else System.out.println("1-1");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class AA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var p : int ; p := 0 ; while p < t do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var y : double ; y := c->oclAsType(double) / b->oclAsType(double) ;
    if (c <= a) then     OclFile["System.out"].println("-1 2") else     if (y < a) then     OclFile["System.out"].println("1 " + b) else     OclFile["System.out"].println("1-1") ; ;  ;  
 )  ;     p := p + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1712 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      StringBuilder sb=new StringBuilder();
      int p=1 ;
      if(N % 2==1){
        sb.append(p++).append(' ');
      }
      while(p<N){
        int nextnext=p++;
        int next=p++;
        sb.append(next).append(' ').append(nextnext).append(' ');
      }
      System.out.println(sb);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1712 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var sb : String ; sb := StringLib.newString() ;
    var p : int ; p := 1 ;
    if (N mod 2 = 1) then (     sb := sb + StringLib.newString(p) + StringLib.newString(' ') ) else skip ; 
    while (p < N) do (     var nextnext : int ; nextnext := p ;
     var next : int ; next := p ;
     sb := sb + StringLib.newString(next) + StringLib.newString(' ') + StringLib.newString(nextnext) + StringLib.newString(' ') ) ; 
    OclFile["System.out"].println(sb) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class donutShops1000 {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int inp=sc.nextInt();
    while(inp-->0){
      long a=sc.nextLong();
      long b=sc.nextLong();
      long c=sc.nextLong();
      StringBuilder sb=new StringBuilder();
      if(1*a<c){
        sb.append("1 ");
      }
      else {
        sb.append("-1 ");
      }
      long val=a*b ;
      if(val>c){
        sb.append(b);
      }
      else {
        sb.append("-1");
      }
      System.out.println(sb.toString());
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class donutShops1000 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inp : int ; inp := sc.getCurrent()->toInteger() ;
         while (inp > 0) do (        inp := inp - 1 ;     skip ; (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
    var c : long ; c := sc.getCurrent()->toLong() ;
    var sb : String ; sb := StringLib.newString() ;
    if (1 * a < c) then (     sb := sb + StringLib.newString("1 ") ) else (     sb := sb + StringLib.newString("-1 ") ) ;  
    var val : long ; val := a * b ;
    if (val > c) then (     sb := sb + StringLib.newString(b) ) else (     sb := sb + StringLib.newString("-1") ) ;  
    OclFile["System.out"].println(sb+"") ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int i ;
    int a[]=new int[n];
    for(i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    for(i=0 ; i<n ; i++){
      int count=1 ;
      for(int j=0 ; j<n ; j++){
        if(a[i]<a[j] && i!=j){
          count++;
        }
      }
      System.out.print(count+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var i : int ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     var count : int ; count := 1 ;
         var j : int ; j := 0 ; while j < n do ( (     if (a[i+1] < a[j+1] & i /= j) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print(count + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int s=1 ;
      for(int j=0 ; j<n ; j++){
        if(a[j]>a[i]){
          s++;
        }
      }
      System.out.print(s+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var s : int ; s := 1 ;
         var j : int ; j := 0 ; while j < n do ( (     if (a[j+1] > a[i+1]) then (     s := s + 1 ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print(s + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class prog {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=s.nextInt();
    }
    int[] b=a.clone();
    Arrays.sort(b);
    for(int i=0 ; i<n ; i++){
      int sc=1 ;
      for(int j=0 ; j<n ; j++){
        if(a[i]<b[j])sc++;
      }
      System.out.print(sc+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class prog {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := a->copy() ;
    b := b->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     var sc : int ; sc := 1 ;
         var j : int ; j := 0 ; while j < n do ( (     if (a[i+1] < b[j+1]) then     sc := sc + 1 ; else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print(sc + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Bai4 {
  public static void main(String[] agrs){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] score=new int[n];
    for(int i=0 ; i<n ; i++){
      score[i]=sc.nextInt();
    }
    int[] score_sorted=score.clone();
    Arrays.sort(score_sorted);
    for(int i=0 ; i<n ; i++){
      int s=1 ;
      for(int j=0 ; j<n ; j++){
        if(score[i]<score_sorted[j]){
          s++;
        }
      }
      System.out.print(s+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Bai4 {
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var score : Sequence(int) ; score := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     score[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var score_sorted : Sequence(int) ; score_sorted := score->copy() ;
    score_sorted := score_sorted->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     var s : int ; s := 1 ;
         var j : int ; j := 0 ; while j < n do ( (     if (score[i+1] < score_sorted[j+1]) then (     s := s + 1 ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print(s + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    String[] in=br.readLine().split(" ");
    int n=Integer.parseInt(in[0]);
    int m=Integer.parseInt(in[1]);
    in=br.readLine().split(" ");
    int[] h=new int[n];
    for(int i=0 ; i<n ; i++){
      h[i]=Integer.parseInt(in[i]);
    }
    int[] ans=new int[n];
    for(int i=0 ; i<m ; i++){
      in=br.readLine().split(" ");
      int a=Integer.parseInt(in[0])-1 ;
      int b=Integer.parseInt(in[1])-1 ;
      if(h[a]<h[b]){
        ans[a]=-1 ;
      }
      else if(h[a]>h[b]){
        ans[b]=-1 ;
      }
      else {
        ans[a]=-1 ;
        ans[b]=-1 ;
      }
    }
    br.close();
    int cnt=0 ;
    for(int a : ans){
      if(a!=-1){
        cnt++;
      }
    }
    bw.write(String.valueOf(cnt));
    bw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var in : Sequence(String) ; in := br.readLine()->split(" ") ;
    var n : int ; n := (in[0+1])->toInteger() ;
    var m : int ; m := (in[1+1])->toInteger() ;
    in := br.readLine()->split(" ") ; 
    var h : Sequence(int) ; h := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     h[i+1] := (in[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     in := br.readLine()->split(" ") ; 
     var a : int ; a := (in[0+1])->toInteger() - 1 ;
     var b : int ; b := (in[1+1])->toInteger() - 1 ;
     if (h[a+1] < h[b+1]) then (     ans[a+1] := -1 ) else     if (h[a+1] > h[b+1]) then (     ans[b+1] := -1 ) else (     ans[a+1] := -1 ; 
     ans[b+1] := -1 ) ;  )  ;     i := i + 1 ) ; 
    skip ; 
    var cnt : int ; cnt := 0 ;
    for (a : ans) do ( (     if (a /= -1) then (     cnt := cnt + 1 ) else skip )  ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int t=in.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      int n=in.nextInt();
      HashSet<Integer>set=new HashSet<>();
      int indx=-1 ;
      for(int i=0 ; i<n ; i++){
        ArrayList<Integer>ls=new ArrayList<>();
        int k=in.nextInt();
        for(int j=0 ; j<k ; j++){
          int c=in.nextInt();
          if(! set.contains(c))ls.add(c);
        }
        Collections.sort(ls);
        if(indx==-1 && ls.isEmpty()){
          indx=(i+1);
          continue ;
        }
        else {
          if(ls.isEmpty())continue ;
          set.add(ls.get(0));
        }
      }
      boolean improve=false ;
      for(int i=1 ; i<=n ; i++){
        if(! set.contains(i)){
          pw.println("IMPROVE");
          pw.println(indx+" "+i);
          improve=true ;
          break ;
        }
      }
      if(! improve)pw.println("OPTIMAL");
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        var tt : int ; tt := 0 ; while tt < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var set : Set(int) ; set := Set{} ;
    var indx : int ; indx := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var ls : Sequence(int) ; ls := Sequence{} ;
     var k : int ; k := in.getCurrent()->toInteger() ;
        var j : int ; j := 0 ; while j < k do ( (     var c : int ; c := in.getCurrent()->toInteger() ;
     if (not(set->includes(c))) then     ls := ls->including(c) ; else skip )  ;     j := j + 1 ) ; 
    ls := ls->sort() ; 
    if (indx = -1 & ls->isEmpty()) then (     indx := (i + 1) ; 
     continue ) else (     if (ls->isEmpty()) then     continue else skip ; 
     set := set->including(ls->at(0+1)) ) ;  
 )  ;     i := i + 1 ) ; 
    var improve : boolean ; improve := false ;
        var i : int ; i := 1 ; while i <= n do ( (     if (not(set->includes(i))) then (     skip ; 
     skip ; 
     improve := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (not(improve)) then     skip ; else skip ; 
 )  ;     tt := tt + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] ans=new int[n];
    int p=0 ;
    for(int i=11 ; i<55555 ; i++){
      if(p>=n)break ;
      if(i % 5==1){
        int f=0 ;
        for(int j=2 ; j*j<=i ; j++){
          if(i % j==0){
            f++;
            break ;
          }
        }
        if(f==0){
          ans[p]=i ;
          p++;
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      if(i<n-1)System.out.print(ans[i]+" ");
      if(i==n-1)System.out.print(ans[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
    var p : int ; p := 0 ;
        var i : int ; i := 11 ; while i < 55555 do ( (     if (p >= n) then     break else skip ; 
     if (i mod 5 = 1) then (     var f : int ; f := 0 ;
         var j : int ; j := 2 ; while j * j <= i do ( (     if (i mod j = 0) then (     f := f + 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (f = 0) then (     ans[p+1] := i ; 
     p := p + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i < n - 1) then     OclFile["System.out"].print(ans[i+1] + " ") ; else skip ; 
     if (i = n - 1) then     OclFile["System.out"].print(ans[i+1]) ; else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    a[0]=11 ;
    int num=a[0];
    System.out.println(a[0]+" ");
    boolean bl ;
    for(int i=1 ; i<n ; i++){
      do {
        num+=10 ;
      }
      while(primJudge(num)==false);
      a[i]=num ;
      System.out.println(a[i]+" ");
    }
  }
  public static boolean primJudge(int k){
    boolean bl=true ;
    if(k==1)bl=false ;
    if(k==2)bl=true ;
    if(k>=3){
      for(int j=3 ; j*j<=k ; j+=2){
        if(k % j==0){
          bl=false ;
          break ;
        }
      }
    }
    return(bl);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    a[0+1] := 11 ; 
    var num : int ; num := a[0+1] ;
    OclFile["System.out"].println(a[0+1] + " ") ; 
    var bl : boolean ;
        var i : int ; i := 1 ; while i < n do ( (   while true do ((     num := num+(10) ) ;
    if (primJudge(num) = false) then skip else break) ; 
     a[i+1] := num ; 
     OclFile["System.out"].println(a[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation primJudge( k : int) : boolean
  pre: true
  post: true
  activity: (     var bl : boolean ; bl := true ;
     if (k = 1) then     bl := false ; else skip ; 
    if (k = 2) then     bl := true ; else skip ; 
    if (k >= 3) then (         var j : int ; j := 3 ; while j * j <= k do ( (     if (k mod j = 0) then (     bl := false ; 
     break ) else skip )  ;     j := j+(2) ) ) else skip ; 
    return (bl) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Deque ;
import java.util.List ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  private static final int BASE=55555 ;
  public static void main(final String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int n=scanner.nextInt();
    final Deque<Integer>primeNumbers=new ArrayDeque<>(sieveOfEratosthenes(BASE));
    final List<Integer>answers=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      int primeNumber ;
      while((primeNumber=primeNumbers.poll())% 5!=1);
      answers.add(primeNumber);
    }
    final String answer=answers.stream().map(i->Integer.toString(i)).collect(Collectors.joining(" "));
    System.out.println(answer);
  }
  private static List<Integer>sieveOfEratosthenes(final int number){
    List<Integer>list=new ArrayList<>();
    for(int i=2 ; i<=number ; i++){
      list.add(i);
    }
    final int sqrt=(int)Math.sqrt(number);
    final List<Integer>primeNumbers=new ArrayList<>();
    int condition ;
    do {
      final int prime=list.get(0);
      primeNumbers.add(prime);
      list=list.stream().filter(i->i % prime!=0).collect(Collectors.toList());
      condition=prime ;
    }
    while(condition<sqrt);
    primeNumbers.addAll(list);
    return primeNumbers ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BASE : int := 55555;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var primeNumbers : Sequence(int) ; primeNumbers := ArrayDeque<OclAny>.newArrayDeque(sieveOfEratosthenes(BASE)) ;
    var answers : Sequence(int) ; answers := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var primeNumber : int ;
         primeNumber := primeNumbers->min() ;
    while ((primeNumber) mod 5 /= 1) do (    skip ;  ;     primeNumber := primeNumbers->min() ;
 ) ;  
     answers := answers->including(primeNumber) )  ;     i := i + 1 ) ; 
    var answer : String ; answer := answers->collect( _x1 | (lambda i : OclAny in ((i) + ""))->apply(_x1) ).collect(Collectors.joining(" ")) ;
    OclFile["System.out"].println(answer) ; 
 );
  static   operation sieveOfEratosthenes( number : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
         var i : int ; i := 2 ; while i <= number do ( (     list := list->including(i) )  ;     i := i + 1 ) ; 
    var sqrt : int ; sqrt := (number)->sqrt()->oclAsType(int) ;
    var primeNumbers : Sequence(int) ; primeNumbers := Sequence{} ;
    var condition : int ;
  while true do ((     var prime : int ; prime := list->at(0+1) ;
     primeNumbers := primeNumbers->including(prime) ; 
     list := list->select( _x1 | (lambda i : OclAny in i mod prime /= 0)->apply(_x1) ).collect(Collectors.toList()) ; 
     condition := prime ) ;
    if (condition < sqrt) then skip else break) ; 
    primeNumbers := primeNumbers->union(list) ; 
    return primeNumbers 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  static final PrintStream so=System.out ;
  static final Scanner sc=new Scanner(System.in);
  static final int INF=Integer.MAX_VALUE ;
  static int[] mh={
    0,1,0,-1 };
    static int[] mw={
      1,0,-1,0 };
      public static void main(String[] args){
        int N=ni();
        int count=0 ;
        for(int i=6 ; i<=55555 ; i+=5){
          if(isPrime(i)){
            so.print(i+" ");
            count++;
          }
          if(count==N)break ;
        }
      }
      static boolean isPrime(int n){
        for(int i=2 ; i<=Math.sqrt(n); i++){
          if(n % i==0){
            return false ;
          }
        }
        return true ;
      }
      static int ni(){
        return sc.nextInt();
      }
      static long nl(){
        return sc.nextLong();
      }
      static char[] nsToChars(){
        return sc.next().toCharArray();
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute so : OclFile := OclFile["System.out"];
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute INF : int := 2147483647;
  static   attribute mh : Sequence(int) := Sequence{0,1,0,-1};
  static   attribute mw : Sequence(int) := Sequence{1,0,-1,0};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := ni() ;
     var count : int ; count := 0 ;
         var i : int ; i := 6 ; while i <= 55555 do ( (     if (isPrime(i)) then (     skip ; 
     count := count + 1 ) else skip ; 
     if (count = N) then     break else skip )  ;     i := i+(5) ) );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
  static   operation nl() : long
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toLong() );
  static   operation nsToChars() : Sequence(String)
  pre: true
  post: true
  activity: (     return sc.getCurrent()->characters() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    int lo=0,hi=n-1 ;
    while(lo<n-1 && a[lo]<a[lo+1])lo++;
    while(0<hi && a[hi-1]>a[hi])hi--;
    for(int i=lo ; i<hi ; i++)if(a[i]!=a[i+1]){
      System.out.println("NO");
      return ;
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var lo : int ; lo := 0 ;
    var hi : int ; hi := n - 1 ;
    while (lo < n - 1 & a[lo+1] < a[lo + 1+1]) do     lo := lo + 1 ; ; 
    while (0 < hi & a[hi - 1+1] > a[hi+1]) do     hi := hi - 1 ; ; 
        var i : int ; i := lo ; while i < hi do (     if (a[i+1] /= a[i + 1+1]) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    ArrayList<Integer>nums=new ArrayList<Integer>();
    int so=7 ;
    for(int i=0 ; i<n ; i++){
      while(true){
        so++;
        boolean sosuflag=true ;
        for(int j=2 ; j<so ; j++){
          if(so % j==0){
            sosuflag=false ;
            break ;
          }
        }
        if(sosuflag && so % 5==1){
          nums.add(so);
          break ;
        }
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      sb.append(nums.get(i)+" ");
    }
    sb.deleteCharAt(sb.length()-1);
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var nums : Sequence(int) ; nums := Sequence{} ;
    var so : int ; so := 7 ;
        var i : int ; i := 0 ; while i < n do ( (     while (true) do (     so := so + 1 ; 
     var sosuflag : boolean ; sosuflag := true ;
         var j : int ; j := 2 ; while j < so do ( (     if (so mod j = 0) then (     sosuflag := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (sosuflag & so mod 5 = 1) then (     nums := nums->including(so) ; 
     break ) else skip ) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     sb := sb + StringLib.newString(nums->at(i+1) + " ") )  ;     i := i + 1 ) ; 
    sb := sb->excludingAt(sb->size() - 1+1) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int findElement(int arr[],int n){
    int[] prefixSum=new int[n];
    prefixSum[0]=arr[0];
    for(int i=1 ; i<n ; i++)prefixSum[i]=prefixSum[i-1]+arr[i];
    int[] suffixSum=new int[n];
    suffixSum[n-1]=arr[n-1];
    for(int i=n-2 ; i>=0 ; i--)suffixSum[i]=suffixSum[i+1]+arr[i];
    for(int i=1 ; i<n-1 ; i++)if(prefixSum[i]==suffixSum[i])return arr[i];
    return-1 ;
  }
  public static void main(String args[]){
    int arr[]={
      1,4,2,5 };
      int n=arr.length ;
      System.out.println(findElement(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findElement( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var prefixSum : Sequence(int) ; prefixSum := Integer.subrange(1,n)->collect(0) ;
     prefixSum[0+1] := arr[0+1] ; 
        var i : int ; i := 1 ; while i < n do (     prefixSum[i+1] := prefixSum[i - 1+1] + arr[i+1] ;  ;     i := i + 1 ) ; 
    var suffixSum : Sequence(int) ; suffixSum := Integer.subrange(1,n)->collect(0) ;
    suffixSum[n - 1+1] := arr[n - 1+1] ; 
        var i : int ; i := n - 2 ; while i >= 0 do (     suffixSum[i+1] := suffixSum[i + 1+1] + arr[i+1] ;  ;     i := i - 1 ) ; 
        var i : int ; i := 1 ; while i < n - 1 do (     if (prefixSum[i+1] = suffixSum[i+1]) then     return arr[i+1] else skip ;  ;     i := i + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,4,2,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findElement(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codechef {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int mugs=sc.nextInt();
    int cup=sc.nextInt();
    ArrayList<Integer>list=new ArrayList<Integer>(mugs);
    for(int i=0 ; i<mugs ; i++){
      list.add(sc.nextInt());
    }
    Collections.sort(list);
    int c=0 ;
    for(int i=0 ; i<list.size()-1 ; i++){
      if(list.get(i)<=cup){
        cup-=list.get(i);
        c++;
      }
    }
    if(c==mugs-1){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var mugs : int ; mugs := sc.getCurrent()->toInteger() ;
    var cup : int ; cup := sc.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < mugs do ( (     list := list->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < list->size() - 1 do ( (     if (list->at(i+1) <= cup) then (     cup := cup-(list->at(i+1)) ; 
     c := c + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (c = mugs - 1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Myclass {
  public final static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int s,n ;
    n=scn.nextInt();
    s=scn.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; ++i){
      a[i]=scn.nextInt();
    }
    Arrays.sort(a);
    int sum=0 ;
    for(int i=0 ; i<n-1 ; ++i){
      sum+=a[i];
    }
    if(sum<=s){
      System.out.println("YES\n");
    }
    else {
      System.out.println("NO\n");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Myclass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : int ;
    var n : int ;
    n := scn.getCurrent()->toInteger() ; 
    s := scn.getCurrent()->toInteger() ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    if (sum <= s) then (     OclFile["System.out"].println("YES\n") ) else (     OclFile["System.out"].println("NO\n") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    C solver=new C();
    solver.solve(1,in,out);
    out.close();
  }
  static class C {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int N=in.nextInt();
      int M=in.nextInt();
      Set<Integer>set=new HashSet<>();
      int[] h=new int[N];
      for(int i=0 ; i<N ; i++){
        h[i]=in.nextInt();
      }
      for(int j=0 ; j<M ; j++){
        int a=in.nextInt();
        int b=in.nextInt();
        if(h[a-1]==h[b-1]){
          set.add(a);
          set.add(b);
        }
        else {
          set.add(h[a-1]<h[b-1] ? a : b);
        }
      }
      out.print(N-set.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : C ; solver := C.newC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class C {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
     var M : int ; M := in.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
    var h : Sequence(int) ; h := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     h[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < M do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
     if (h[a - 1+1] = h[b - 1+1]) then (     set := set->including(a) ; 
     set := set->including(b) ) else (     set := set->including(if h[a - 1+1] < h[b - 1+1] then a else b endif) ) )  ;     j := j + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.*;
public class App {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws Exception {
    if(System.getProperty("ONLINE_JUDGE")==null){
      File inputFile=new File("/Users/vipinjain/self/cp/input.txt");
      File outputFile=new File("/Users/vipinjain/self/cp/output.txt");
      br=new BufferedReader(new FileReader(inputFile));
      bw=new BufferedWriter(new FileWriter(outputFile));
    }
    int tests ;
    tests=1 ;
    while(tests-->0){
      solve();
    }
    bw.flush();
    bw.close();
    br.close();
  }
  static void solve()throws Exception {
    String[] tmp=br.readLine().split(" ");
    int n=Integer.parseInt(tmp[0]);
    int v=Integer.parseInt(tmp[1]);
    int[] arr=Stream.of(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    Arrays.sort(arr);
    int i=0,sum=0 ;
    while(i<n-1){
      sum+=arr[i];
      if(sum>v){
        bw.write("NO\n");
        return ;
      }
      i++;
    }
    bw.write("YES");
    bw.write("\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null) then (     var inputFile : OclFile ; inputFile := OclFile("/Users/vipinjain/self/cp/input.txt") ;
     var outputFile : OclFile ; outputFile := OclFile("/Users/vipinjain/self/cp/output.txt") ;
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputFile)) ; 
     bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputFile)) ) else skip ; 
     var tests : int ;
    tests := 1 ; 
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var tmp : Sequence(String) ; tmp := br.readLine()->split(" ") ;
     var n : int ; n := (tmp[0+1])->toInteger() ;
    var v : int ; v := (tmp[1+1])->toInteger() ;
    var arr : Sequence(int) ; arr := Sequence{br.readLine()->split(" ")}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    arr := arr->sort() ; 
    var i : int ; i := 0 ;
    var sum : int ; sum := 0 ;
    while (i < n - 1) do (     sum := sum+(arr[i+1]) ; 
     if (sum > v) then (     skip ; 
     return ) else skip ; 
     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p304 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p304().run());
  }
  private static final long BASE=100000000000000L ;
  private static final int SEARCH_RANGE=10000000 ;
  private static final long MODULUS=1234567891011L ;
  private static final BigInteger MODULUS_BI=BigInteger.valueOf(MODULUS);
  private boolean[] isComposite ;
  public String run(){
    int[] primes=Library.listPrimes((int)Library.sqrt(BASE+SEARCH_RANGE));
    isComposite=new boolean[SEARCH_RANGE];
    for(int p : primes){
      for(int i=(int)((BASE+p-1)/p*p-BASE); i<isComposite.length ; i+=p)isComposite[i]=true ;
    }
    long sum=0 ;
    int p=0 ;
    for(int i=0 ; i<100000 ; i++){
      p=nextPrime(p);
      sum=(sum+fibonacciMod(BASE+p))% MODULUS ;
    }
    return Long.toString(sum);
  }
  private int nextPrime(int n){
    do {
      n++;
      if(n>=isComposite.length)throw new AssertionError("Search range exhausted");
    }
    while(isComposite[n]);
    return n ;
  }
  private static long fibonacciMod(long n){
    BigInteger a=BigInteger.ZERO ;
    BigInteger b=BigInteger.ONE ;
    for(int i=63 ; i>=0 ; i--){
      BigInteger d=a.multiply(b.shiftLeft(1).subtract(a));
      BigInteger e=a.pow(2).add(b.pow(2));
      a=d ;
      b=e ;
      if(((n>>>i)& 1)!=0){
        BigInteger c=a.add(b);
        a=b ;
        b=c ;
      }
      a=a.mod(MODULUS_BI);
      b=b.mod(MODULUS_BI);
    }
    return a.longValue();
  }
}
------------------------------------------------------------
OCL File:
---------
 class p304 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p304.newp304().run()) );
  static    attribute BASE : long := 100000000000000L;
  static    attribute SEARCH_RANGE : int := 10000000;
  static    attribute MODULUS : long := 1234567891011L;
  static    attribute MODULUS_BI : long := (MODULUS + "")->toLong();
   attribute isComposite : Sequence(boolean);
   operation run() : String
  pre: true
  post: true
  activity: (     var primes : Sequence(int) ; primes := Library.listPrimes(Library.sqrt(BASE + SEARCH_RANGE)->oclAsType(int)) ;
     isComposite := Integer.subrange(1,SEARCH_RANGE)->collect(false) ; 
    for (p : primes) do ( (         var i : int ; i := ((BASE + p - 1) / p * p - BASE)->oclAsType(int) ; while i < isComposite->size() do (     isComposite[i+1] := true ;  ;     i := i+(p) ) )  ) ; 
    var sum : long ; sum := 0 ;
    var p : int ; p := 0 ;
        var i : int ; i := 0 ; while i < 100000 do ( (     p := nextPrime(p) ; 
     sum := (sum + fibonacciMod(BASE + p)) mod MODULUS )  ;     i := i + 1 ) ; 
    return ((sum) + "") 
 );
   operation nextPrime( n : int) : int
  pre: true
  post: true
  activity: (   while true do ((     n := n + 1 ; 
     if (n >= isComposite->size()) then     error AssertionException("Search range exhausted") ; else skip ) ;
    if (isComposite[n+1]) then skip else break) ; 
     return n );
  static   operation fibonacciMod( n : long) : long
  pre: true
  post: true
  activity: (     var a : long ; a := 0 ;
     var b : long ; b := 1 ;
         var i : int ; i := 63 ; while i >= 0 do ( (     var d : long ; d := a.multiply(b.shiftLeft(1).subtract(a)) ;
     var e : long ; e := a.pow(2)->excludes(b.pow(2)) ;
    a := d ; 
    b := e ; 
    if ((((n/(2->pow(i)))->oclAsType(long)) & 1) /= 0) then (     var c : long ; c := a->excludes(b) ;
     a := b ; 
     b := c ) else skip ; 
    a := a.mod(MODULUS_BI) ; 
    b := b.mod(MODULUS_BI) ; 
 )  ;     i := i - 1 ) ; 
     return a->oclAsType(long) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  public static void main(String[] args){
    int a=10,b=5 ;
    if(b>0){
      while(b>0){
        a++;
        b--;
      }
    }
    if(b<0){
      while(b<0){
        a--;
        b++;
      }
    }
    System.out.println("Sum is: "+a);
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 10 ;
    var b : int ; b := 5 ;
     if (b > 0) then (     while (b > 0) do (     a := a + 1 ; 
     b := b - 1 ) ) else skip ; 
     if (b < 0) then (     while (b < 0) do (     a := a - 1 ; 
     b := b + 1 ) ) else skip ; 
     OclFile["System.out"].println("Sum is: " + a) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int subsetCount(int arr[],int n){
    return 1<<n ;
  }
  public static void main(String[] args){
    int A[]={
      1,2,3 };
      int n=A.length ;
      System.out.println(subsetCount(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation subsetCount( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     return (1*(2->pow(n)))->oclAsType(long) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{1,2,3} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].println(subsetCount(A, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  static void sortArray(int arr[],int n,int A,int B,int C){
    for(int i=0 ; i<n ; i++)arr[i]=A*arr[i]*arr[i]+B*arr[i]+C ;
    int index=-1 ;
    int maximum=-999999 ;
    for(int i=0 ; i<n ; i++){
      if(maximum<arr[i]){
        index=i ;
        maximum=arr[i];
      }
    }
    int i=0,j=n-1 ;
    int[] new_arr=new int[n];
    int k=0 ;
    while(i<index && j>index){
      if(arr[i]<arr[j])new_arr[k++]=arr[i++];
      else new_arr[k++]=arr[j--];
    }
    while(i<index)new_arr[k++]=arr[i++];
    while(j>index)new_arr[k++]=arr[j--];
    new_arr[n-1]=maximum ;
    for(int p=0 ; p<n ; p++)arr[p]=new_arr[p];
  }
  public static void main(String[] args){
    int arr[]={
-21,-15,12,13,14 };
      int n=arr.length ;
      int A=-6,B=-7,C=2 ;
      sortArray(arr,n,A,B,C);
      System.out.println("Array after sorting is : ");
      for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation sortArray( arr : Sequence(int), n : int, A : int, B : int, C : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     arr[i+1] := A * arr[i+1] * arr[i+1] + B * arr[i+1] + C ;  ;     i := i + 1 ) ; 
     var index : int ; index := -1 ;
    var maximum : int ; maximum := -999999 ;
        var i : int ; i := 0 ; while i < n do ( (     if (maximum < arr[i+1]) then (     index := i ; 
     maximum := arr[i+1] ) else skip )  ;     i := i + 1 ) ; 
    var i : int ; i := 0 ;
    var j : int ; j := n - 1 ;
    var new_arr : Sequence(int) ; new_arr := Integer.subrange(1,n)->collect(0) ;
    var k : int ; k := 0 ;
    while (i < index & j > index) do (     if (arr[i+1] < arr[j+1]) then       new_arr[k+1] := arr[i+1]  ; k := k + 1  ; i := i + 1 ; else       new_arr[k+1] := arr[j+1]  ; k := k + 1  ; j := j - 1 ; ) ; 
    while (i < index) do       new_arr[k+1] := arr[i+1]  ; k := k + 1  ; i := i + 1 ; ; 
    while (j > index) do       new_arr[k+1] := arr[j+1]  ; k := k + 1  ; j := j - 1 ; ; 
    new_arr[n - 1+1] := maximum ; 
        var p : int ; p := 0 ; while p < n do (     arr[p+1] := new_arr[p+1] ;  ;     p := p + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-21,-15,12,13,14} ;
     var n : int ; n := arr->size() ;
    var A : int ; A := -6 ;
    var B : int ; B := -7 ;
    var C : int ; C := 2 ;
    execute sortArray(arr, n, A, B, C) ; 
    OclFile["System.out"].println("Array after sorting is : ") ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      String cipher=sc.next();
      int[] a=new int[n];
      int[] b=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt()-1 ;
        b[i]=sc.nextInt()-1 ;
      }
      for(int i=n-1 ; i>=0 ; i--){
        StringBuilder sb=new StringBuilder();
        int ca=cipher.charAt(a[i])-'a' ;
        int cb=cipher.charAt(b[i])-'a' ;
        int diff=b[i]-a[i];
        ca+=diff ;
        cb+=diff ;
        ca %=26 ;
        cb %=26 ;
        cipher=sb.append(cipher.substring(0,a[i])).append((char)('a'+cb)).append(cipher.substring(a[i]+1,b[i])).append((char)('a'+ca)).append(cipher.substring(b[i]+1)).toString();
      }
      System.out.println(cipher);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var cipher : String ; cipher := sc.getCurrent() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() - 1 ; 
     b[i+1] := sc.getCurrent()->toInteger() - 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     var sb : String ; sb := StringLib.newString() ;
     var ca : int ; ca := cipher->at(a[i+1]+1) - ('a')->char2byte() ;
    var cb : int ; cb := cipher->at(b[i+1]+1) - ('a')->char2byte() ;
    var diff : int ; diff := b[i+1] - a[i+1] ;
    ca := ca+(diff) ; 
    cb := cb+(diff) ; 
    ca := ca mod 26 ; 
    cb := cb mod 26 ; 
    cipher := sb + StringLib.newString(cipher.subrange(0+1,a[i+1])) + StringLib.newString(('a' + cb)->oclAsType(String)) + StringLib.newString(cipher.subrange(a[i+1] + 1+1,b[i+1])) + StringLib.newString(('a' + ca)->oclAsType(String)) + StringLib.newString(cipher.subrange(b[i+1] + 1+1,b[i+1] + 1))+"" ; 
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(cipher) ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Contest_3A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int size=Integer.parseInt(sc.nextLine());
    String[] input=sc.nextLine().split(" ");
    int[] data=new int[size];
    for(int i=0 ; i<size ; i++){
      data[i]=Integer.parseInt(input[i]);
    }
    boolean u=true,c=true,d=true ;
    boolean done=false ;
    for(int i=0 ; i<data.length-1 ; i++){
      if(data[i]<data[i+1]){
        if(! u){
          System.out.println("NO");
          done=true ;
          break ;
        }
      }
      else if(data[i]==data[i+1]){
        u=false ;
        if(! c){
          System.out.println("NO");
          done=true ;
          break ;
        }
      }
      else {
        c=false ;
        u=false ;
        if(! d){
          System.out.println("NO");
          done=true ;
          break ;
        }
      }
    }
    if(! done){
      System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Contest_3A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var size : int ; size := (sc.nextLine())->toInteger() ;
    var input : Sequence(String) ; input := sc.nextLine()->split(" ") ;
    var data : Sequence(int) ; data := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < size do ( (     data[i+1] := (input[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var u : boolean ; u := true ;
    var c : boolean ; c := true ;
    var d : boolean ; d := true ;
    var done : boolean ; done := false ;
        var i : int ; i := 0 ; while i < data->size() - 1 do ( (     if (data[i+1] < data[i + 1+1]) then (     if (not(u)) then (     OclFile["System.out"].println("NO") ; 
     done := true ; 
     break ) else skip ) else     if (data[i+1] = data[i + 1+1]) then (     u := false ; 
     if (not(c)) then (     OclFile["System.out"].println("NO") ; 
     done := true ; 
     break ) else skip ) else (     c := false ; 
     u := false ; 
     if (not(d)) then (     OclFile["System.out"].println("NO") ; 
     done := true ; 
     break ) else skip ) ;  )  ;     i := i + 1 ) ; 
    if (not(done)) then (     OclFile["System.out"].println("YES") ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int N=parseInt(line);
      if(N==0)break ;
      char[] msg=br.readLine().toCharArray();
      int[][] swaps=new int[N][2];
      for(int i=0 ; i<N ; i++){
        line=br.readLine();
        swaps[i][0]=parseInt(line.substring(0,line.indexOf(' ')))-1 ;
        ;
        swaps[i][1]=parseInt(line.substring(line.indexOf(' ')+1))-1 ;
        ;
      }
      for(int i=N-1 ; i>=0 ; i--){
        int shift=swaps[i][1]-swaps[i][0];
        for(int j : swaps[i]){
          msg[j]+=shift ;
          if(msg[j]>'z'){
            msg[j]-='z'+1 ;
            msg[j] %=26 ;
            msg[j]+='a' ;
          }
        }
        char tmp=msg[swaps[i][0] ];
        msg[swaps[i][0] ]=msg[swaps[i][1] ];
        msg[swaps[i][1] ]=tmp ;
      }
      System.out.println(msg);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var N : int ; N := parseInt(line) ;
     if (N = 0) then     break else skip ; 
    var msg : Sequence(String) ; msg := br.readLine()->characters() ;
    var swaps : Sequence(Sequence(int)) ; swaps := Integer.subrange(1,N)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     line := br.readLine() ; 
     swaps[i+1][0+1] := parseInt(line.subrange(0+1,line->indexOf(' ')-1)) - 1 ; 
    swaps[i+1][1+1] := parseInt(line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1)) - 1 ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := N - 1 ; while i >= 0 do ( (     var shift : int ; shift := swaps[i+1][1+1] - swaps[i+1][0+1] ;
     for (j : swaps[i+1]) do ( (     msg[j+1] := msg[j+1]+(shift) ; 
     if (msg[j+1] > 'z') then (     msg[j+1] := msg[j+1]-('z' + 1) ; 
     msg[j+1] := msg[j+1] mod 26 ; 
     msg[j+1] := msg[j+1]+('a') ) else skip )  ) ; 
    var tmp : String ; tmp := msg[swaps[i+1][0+1]+1] ;
    msg[swaps[i+1][0+1]+1] := msg[swaps[i+1][1+1]+1] ; 
    msg[swaps[i+1][1+1]+1] := tmp ; 
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(msg) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  char conv(char ch,int d){
    return(char)('a'+(int)(ch-'a'+d)% 26);
  }
  Main(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] a=new int[n+1];
      int[] b=new int[n+1];
      char[] ch=(sc.next()).toCharArray();
      for(int i=n-1 ; i>=0 ; --i){
        a[i]=sc.nextInt();
        b[i]=sc.nextInt();
        a[i]--;
        b[i]--;
      }
      for(int i=0 ; i<n ; ++i){
        ch[a[i] ]=conv(ch[a[i] ],b[i]-a[i]);
        ch[b[i] ]=conv(ch[b[i] ],b[i]-a[i]);
        char tmp=ch[a[i] ];
        ch[a[i] ]=ch[b[i] ];
        ch[b[i] ]=tmp ;
      }
      System.out.println(String.valueOf(ch));
    }
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation conv( ch : String, d : int) : String
  pre: true
  post: true
  activity: (     return ('a' + (ch - ('a')->char2byte() + d)->oclAsType(int) mod 26)->oclAsType(String) );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n + 1)->collect(0) ;
    var ch : Sequence(String) ; ch := (sc.getCurrent())->characters() ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() ; 
     a[i+1] := a[i+1] - 1 ; 
     b[i+1] := b[i+1] - 1 )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     ch[a[i+1]+1] := conv(ch[a[i+1]+1], b[i+1] - a[i+1]) ; 
     ch[b[i+1]+1] := conv(ch[b[i+1]+1], b[i+1] - a[i+1]) ; 
    var tmp : String ; tmp := ch[a[i+1]+1] ;
    ch[a[i+1]+1] := ch[b[i+1]+1] ; 
    ch[b[i+1]+1] := tmp ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((ch)->sum() ) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  Scanner sc ;
  Main(){
    sc=new Scanner(System.in);
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
  int N ;
  char[] message ;
  int[] a,b ;
  boolean init(){
    N=sc.nextInt();
    if(N==0)return false ;
    a=new int[N];
    b=new int[N];
    message=sc.next().toCharArray();
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextInt()-1 ;
      b[i]=sc.nextInt()-1 ;
    }
    return true ;
  }
  int rotate(char c,int d){
    return((c-'a')+d)% 26+'a' ;
  }
  void decipher(int ai,int bi){
    int d=Math.abs(ai-bi);
    message[ai]=(char)rotate(message[ai],d);
    message[bi]=(char)rotate(message[bi],d);
    char p=message[ai];
    char q=message[bi];
    message[ai]=q ;
    message[bi]=p ;
  }
  void run(){
    while(init()){
      for(int i=a.length-1 ; i>=0 ; i--){
        decipher(a[i],b[i]);
      }
      System.out.println(message);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
   attribute N : int;
   attribute message : Sequence(String);
   attribute a : Sequence(int);
   operation init() : boolean
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     if (N = 0) then     return false else skip ; 
    a := Integer.subrange(1,N)->collect(0) ; 
    b := Integer.subrange(1,N)->collect(0) ; 
    message := sc.getCurrent()->characters() ; 
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toInteger() - 1 ; 
     b[i+1] := sc.getCurrent()->toInteger() - 1 )  ;     i := i + 1 ) ; 
    return true 
 );
   operation rotate( c : String, d : int) : int
  pre: true
  post: true
  activity: (     return ((c - ('a')->char2byte()) + d) mod 26 + 'a' );
   operation decipher( ai : int, bi : int) : void
  pre: true
  post: true
  activity: (     var d : int ; d := if ai - bi < 0 then -(ai - bi) else ai - bi endif ;
     message[ai+1] := rotate(message[ai+1], d)->oclAsType(String) ; 
    message[bi+1] := rotate(message[bi+1], d)->oclAsType(String) ; 
    var p : String ; p := message[ai+1] ;
    var q : String ; q := message[bi+1] ;
    message[ai+1] := q ; 
    message[bi+1] := p ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     while (init()) do (         var i : int ; i := a->size() - 1 ; while i >= 0 do ( (     execute decipher(a[i+1], b[i+1]) )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println(message) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    int[] height=new int[n+1];
    for(int i=1 ; i<=n ; ++i){
      height[i]=scanner.nextInt();
    }
    Map<Integer,Map<Integer,Integer>>graph=new HashMap<>();
    for(int i=0 ; i<m ; ++i){
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      if(! graph.containsKey(a)){
        graph.put(a,new HashMap<>());
      }
      if(! graph.containsKey(b)){
        graph.put(b,new HashMap<>());
      }
      Integer aToB=graph.get(a).getOrDefault(b,0);
      graph.get(a).put(b,aToB+1);
      graph.get(b).put(a,aToB+1);
    }
    int[] good=new int[n+1];
    for(int i=1 ; i<=n ; ++i){
      if(good[i]==-1){
        continue ;
      }
      if(! graph.containsKey(i)){
        good[i]=1 ;
        continue ;
      }
      Map<Integer,Integer>neighbors=graph.get(i);
      for(Map.Entry<Integer,Integer>neighborRoads : neighbors.entrySet()){
        int neighbor=neighborRoads.getKey();
        if(height[neighbor]>=height[i]){
          good[i]=-1 ;
          break ;
        }
      }
      if(good[i]==0){
        good[i]=1 ;
      }
    }
    int ans=0 ;
    for(int i=1 ; i<=n ; ++i){
      if(good[i]==1){
++ans ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var height : Sequence(int) ; height := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     height[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var graph : Map(int,Map(int,int)) ; graph := Map{} ;
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
    if (not(graph->keys()->includes(a))) then (     graph := graph->union(Map{a |-> Map{}}) ) else skip ; 
    if (not(graph->keys()->includes(b))) then (     graph := graph->union(Map{b |-> Map{}}) ) else skip ; 
    var aToB : int ; aToB := graph->at(a)->at(b, 0+1) ;
    graph := graph->at(a)->union(Map{b |-> aToB + 1}) ; 
    graph := graph->at(b)->union(Map{a |-> aToB + 1}) ; 
 )  ;     i := i + 1 ) ; 
    var good : Sequence(int) ; good := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     if (good[i+1] = -1) then (     continue ) else skip ; 
     if (not(graph->keys()->includes(i))) then (     good[i+1] := 1 ; 
     continue ) else skip ; 
    var neighbors : Map(int,int) ; neighbors := graph->at(i) ;
    for (neighborRoads : neighbors->asSet()) do ( (     var neighbor : int ; neighbor := neighborRoads.getKey() ;
     if (height[neighbor+1] >= height[i+1]) then (     good[i+1] := -1 ; 
     break ) else skip )  ) ; 
    if (good[i+1] = 0) then (     good[i+1] := 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (good[i+1] = 1) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.awt.Point ;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      int N ;
      N=Integer.parseInt(in.readLine());
      if(N==0)break ;
      StringBuilder message=new StringBuilder(in.readLine());
      List<Point>list=new ArrayList<Point>();
      for(int i=0 ; i<N ; i++){
        String ab=in.readLine();
        int a,b ;
        a=Integer.parseInt(ab.substring(0,ab.indexOf(" ")));
        b=Integer.parseInt(ab.substring(ab.indexOf(" ")+1));
        Point p=new Point(a,b);
        list.add(p);
      }
      Collections.reverse(list);
      for(int i=0 ; i<N ; i++){
        int a,b,dif ;
        a=list.get(i).x ;
        b=list.get(i).y ;
        a--;
        b--;
        dif=Math.abs(a-b);
        char ca,cb ;
        ca=message.charAt(a);
        cb=message.charAt(b);
        ca=(char)((ca+dif-'a')% 26+'a');
        cb=(char)((cb+dif-'a')% 26+'a');
        message.replace(a,a+1,String.valueOf(cb));
        message.replace(b,b+1,String.valueOf(ca));
      }
      System.out.println(message);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var N : int ;
     N := (in.readLine())->toInteger() ; 
    if (N = 0) then     break else skip ; 
    var message : String ; message := StringLib.newString(in.readLine()) ;
    var list : Sequence(Point) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var ab : String ; ab := in.readLine() ;
     var a : int ;
    var b : int ;
    a := (ab.subrange(0+1,ab->indexOf(" ")-1))->toInteger() ; 
    b := (ab.subrange(ab->indexOf(" ")-1 + 1+1,ab->indexOf(" ")-1 + 1))->toInteger() ; 
    var p : Point ; p := Point.newPoint(a, b) ;
    list := list->including(p) ; 
 )  ;     i := i + 1 ) ; 
    list := list->reverse() ; 
        var i : int ; i := 0 ; while i < N do ( (     var a : int ;
    var b : int ;
    var dif : int ;
     a := list->at(i+1).x ; 
    b := list->at(i+1).y ; 
    a := a - 1 ; 
    b := b - 1 ; 
    dif := if (a)->char2byte() - (b)->char2byte() < 0 then -((a)->char2byte() - (b)->char2byte()) else (a)->char2byte() - (b)->char2byte() endif ; 
    var ca : String ;
    var cb : String ;
    ca := message->at(a+1) ; 
    cb := message->at(b+1) ; 
    ca := ((ca + dif - ('a')->char2byte()) mod 26 + 'a')->oclAsType(String) ; 
    cb := ((cb + dif - ('a')->char2byte()) mod 26 + 'a')->oclAsType(String) ; 
    message.replace(a, a + 1, ((cb) + "")) ; 
    message.replace(b, b + 1, ((ca) + "")) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(message) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  static int previousFibonacci(int n){
    double a=n/((1+(int)Math.sqrt(5))/2.0);
    return(int)Math.round(a);
  }
  static int nextFibonacci(int n){
    double a=n*(1+(int)Math.sqrt(5))/2.0 ;
    return(int)Math.round(a);
  }
  static boolean isPerfectSquare(int x){
    int s=(int)Math.sqrt(x);
    return(s*s==x);
  }
  static boolean isFibonacci(int n){
    return(isPerfectSquare(5*n*n+4)|| isPerfectSquare(5*n*n-4));
  }
  static int countFibonacciPairs(int arr[],int n){
    int res=0 ;
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++)if(isFibonacci(arr[i])&& isFibonacci(arr[j])){
      int prevFib=previousFibonacci(arr[i]);
      int nextFib=nextFibonacci(arr[i]);
      if(prevFib==arr[j] || nextFib==arr[j]){
        res++;
      }
    }
    return res ;
  }
  public static void main(String[] args){
    int[] a={
      3,5,8,11 };
      int n=a.length ;
      System.out.print(countFibonacciPairs(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation previousFibonacci( n : int) : int
  pre: true
  post: true
  activity: (     var a : double ; a := n / ((1 + (5)->sqrt()->oclAsType(int)) / 2.0) ;
     return (a)->round()->oclAsType(int) );
  static   operation nextFibonacci( n : int) : int
  pre: true
  post: true
  activity: (     var a : double ; a := n * (1 + (5)->sqrt()->oclAsType(int)) / 2.0 ;
     return (a)->round()->oclAsType(int) );
  static   operation isPerfectSquare( x : int) : boolean
  pre: true
  post: true
  activity: (     var s : int ; s := (x)->sqrt()->oclAsType(int) ;
     return (s * s = x) );
  static   operation isFibonacci( n : int) : boolean
  pre: true
  post: true
  activity: (     return (isPerfectSquare(5 * n * n + 4) or isPerfectSquare(5 * n * n - 4)) );
  static   operation countFibonacciPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do (     if (isFibonacci(arr[i+1]) & isFibonacci(arr[j+1])) then (     var prevFib : int ; prevFib := previousFibonacci(arr[i+1]) ;
     var nextFib : int ; nextFib := nextFibonacci(arr[i+1]) ;
     if (prevFib = arr[j+1] or nextFib = arr[j+1]) then (     res := res + 1 ) else skip ) else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{3,5,8,11} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(countFibonacciPairs(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void perfectCube(int N){
    int cube_root ;
    cube_root=(int)Math.round(Math.cbrt(N));
    if(cube_root*cube_root*cube_root==N){
      System.out.println("Yes");
      return ;
    }
    else {
      System.out.println("NO");
      return ;
    }
  }
  public static void main(String[] args){
    int N=125 ;
    perfectCube(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation perfectCube( N : int) : void
  pre: true
  post: true
  activity: (     var cube_root : int ;
     cube_root := ((N)->cbrt())->round()->oclAsType(int) ; 
     if (cube_root * cube_root * cube_root = N) then (     OclFile["System.out"].println("Yes") ; 
     return ) else (     OclFile["System.out"].println("NO") ; 
     return ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 125 ;
     execute perfectCube(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[] a=new int[M];
    int[] b=new int[M];
    int[] res=new int[N+1];
    for(int i=0 ; i<M ; i++){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
    }
    for(int i=0 ; i<M ; i++){
      res[a[i] ]++;
      res[b[i] ]++;
    }
    for(int i=1 ; i<res.length ; i++){
      System.out.println(res[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,M)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,M)->collect(0) ;
    var res : Sequence(int) ; res := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     res[a[i+1]+1] := res[a[i+1]+1] + 1 ; 
     res[b[i+1]+1] := res[b[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < res->size() do ( (     OclFile["System.out"].println(res[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    FastReader in=new FastReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskB solver=new TaskB();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskB {
    public void solve(int testNumber,FastReader in,PrintWriter out){
      int n=in.nextInt();
      int m=in.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<m ; i++){
        int e1=in.nextInt()-1 ;
        int e2=in.nextInt()-1 ;
        a[e1]++;
        a[e2]++;
      }
      for(int num : a){
        out.println(num);
      }
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(InputStream i){
      br=new BufferedReader(new InputStreamReader(i));
    }
    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());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : FastReader ; in := FastReader.newFastReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskB ; solver := TaskB.newTaskB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskB {
   operation solve( testNumber : int, in : FastReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var m : int ; m := in.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     var e1 : int ; e1 := in.nextInt() - 1 ;
     var e2 : int ; e2 := in.nextInt() - 1 ;
     a[e1+1] := a[e1+1] + 1 ; 
     a[e2+1] := a[e2+1] + 1 )  ;     i := i + 1 ) ; 
    for (num : a) do ( (     skip )  ) ; 
 );
}
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader( i : OclFile) : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise(i);
    return self );
  operation initialise( i : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(i)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner sc=new Scanner(System.in);
    int cntCity=sc.nextInt();
    int cntRoad=sc.nextInt();
    int[] city=new int[cntCity];
    for(int i=0 ; i<cntRoad ; i++){
      city[sc.nextInt()-1]+=1 ;
      city[sc.nextInt()-1]+=1 ;
    }
    for(int i : city){
      System.out.println(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cntCity : int ; cntCity := sc.getCurrent()->toInteger() ;
    var cntRoad : int ; cntRoad := sc.getCurrent()->toInteger() ;
    var city : Sequence(int) ; city := Integer.subrange(1,cntCity)->collect(0) ;
        var i : int ; i := 0 ; while i < cntRoad do ( (     city[sc.getCurrent()->toInteger() - 1+1] := city[sc.getCurrent()->toInteger() - 1+1]+(1) ; 
     city[sc.getCurrent()->toInteger() - 1+1] := city[sc.getCurrent()->toInteger() - 1+1]+(1) )  ;     i := i + 1 ) ; 
    for (i : city) do ( (     OclFile["System.out"].println(i) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    int j=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    while((j<n-1)&&(a[j]<a[j+1])){
      j++;
    }
    while((j<n-1)&&(a[j]==a[j+1])){
      j++;
    }
    while((j<n-1)&&(a[j]>a[j+1])){
      j++;
    }
    if(j==n-1){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    while ((j < n - 1) & (a[j+1] < a[j + 1+1])) do (     j := j + 1 ) ; 
    while ((j < n - 1) & (a[j+1] = a[j + 1+1])) do (     j := j + 1 ) ; 
    while ((j < n - 1) & (a[j+1] > a[j + 1+1])) do (     j := j + 1 ) ; 
    if (j = n - 1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line=br.readLine();
    String[] number=line.split(" ");
    int n=Integer.parseInt(number[0]);
    int m=Integer.parseInt(number[1]);
    int[] a=new int[n];
    int k=0 ;
    int l=0 ;
    for(int i=0 ; i<m ; i++){
      line=br.readLine();
      k=Integer.parseInt(line.split(" ")[0]);
      l=Integer.parseInt(line.split(" ")[1]);
      a[k-1]++;
      a[l-1]++;
    }
    for(int i=0 ; i<n ; i++){
      System.out.println(a[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := br.readLine() ;
    var number : Sequence(String) ; number := line->split(" ") ;
    var n : int ; n := (number[0+1])->toInteger() ;
    var m : int ; m := (number[1+1])->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var k : int ; k := 0 ;
    var l : int ; l := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     line := br.readLine() ; 
     k := (line->split(" ")[0+1])->toInteger() ; 
    l := (line->split(" ")[1+1])->toInteger() ; 
    a[k - 1+1] := a[k - 1+1] + 1 ; 
    a[l - 1+1] := a[l - 1+1] + 1 ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(a[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  private static Scanner sc ;
  public static void main(String[] args){
    sc=new Scanner(System.in);
    new Main().run();
  }
  private void run(){
    int N=sc.nextInt();
    int M=sc.nextInt();
    List<List<Integer>>roads=new ArrayList<List<Integer>>();
    for(int i=0 ; i<N ; i++){
      roads.add(new ArrayList());
    }
    for(int i=0 ; i<M ; i++){
      int from=sc.nextInt()-1 ;
      int to=sc.nextInt()-1 ;
      roads.get(from).add(to);
      roads.get(to).add(from);
    }
    for(List<Integer>list : roads){
      System.out.println(list.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var M : int ; M := sc.getCurrent()->toInteger() ;
    var roads : Sequence(Sequence(int)) ; roads := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     roads := roads->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var from : int ; from := sc.getCurrent()->toInteger() - 1 ;
     var to : int ; to := sc.getCurrent()->toInteger() - 1 ;
     roads->at(from+1)->excludes(to) ; 
     roads->at(to+1)->excludes(from) )  ;     i := i + 1 ) ; 
    for (list : roads) do ( (     OclFile["System.out"].println(list->size()) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] ip=br.readLine().split(" ");
    long a=Long.parseLong(ip[0]);
    long b=Long.parseLong(ip[1]);
    long c=Long.parseLong(ip[2]);
    long d=Long.parseLong(ip[3]);
    long p=a*c ;
    long q=a*d ;
    long r=b*c ;
    long s=b*d ;
    System.out.println(Math.max(p,Math.max(r,Math.max(q,s))));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var ip : Sequence(String) ; ip := br.readLine()->split(" ") ;
    var a : long ; a := (ip[0+1])->toLong() ;
    var b : long ; b := (ip[1+1])->toLong() ;
    var c : long ; c := (ip[2+1])->toLong() ;
    var d : long ; d := (ip[3+1])->toLong() ;
    var p : long ; p := a * c ;
    var q : long ; q := a * d ;
    var r : long ; r := b * c ;
    var s : long ; s := b * d ;
    OclFile["System.out"].println(Set{p, Set{r, Set{q, s}->max()}->max()}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.nio.Buffer ;
import java.util.*;
public class Main2 {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int testCases=sc.nextInt();
    while(testCases-->0){
      int length=sc.nextInt();
      Integer[] array=new Integer[length];
      int neg=0 ;
      int pos=0 ;
      for(int i=0 ; i<length ; i++){
        array[i]=sc.nextInt();
        if(array[i]>0)pos++;
        else neg++;
      }
      Arrays.sort(array);
      long ans=1 ;
      int zeroes=length-pos-neg ;
      if((pos>=1)){
        ans=array[array.length-1];
        long temp1=array[0]*array[1];
        long temp2=array[array.length-2]*array[array.length-3];
        if(temp1>=temp2){
          ans=ans*temp1 ;
          long temp3=array[2]*array[3];
          if(temp3>=temp2)ans=ans*temp3 ;
          else ans=ans*temp2 ;
        }
        else {
          ans=ans*temp2 ;
          long temp3=array[array.length-4]*array[array.length-5];
          if(temp3>=temp1)ans=ans*temp3 ;
          else ans=ans*temp1 ;
        }
        System.out.println(ans);
      }
      if(pos==0){
        if(zeroes>0)System.out.println(0);
        else {
          long pingo=1 ;
          pingo*=(long)array[array.length-1];
          pingo*=(long)array[array.length-2];
          pingo*=(long)array[array.length-3];
          pingo*=(long)array[array.length-4];
          pingo*=(long)array[array.length-5];
          System.out.println(pingo);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := sc.getCurrent()->toInteger() ;
         while (testCases > 0) do (        testCases := testCases - 1 ;     skip ; (     var length : int ; length := sc.getCurrent()->toInteger() ;
     var array : Sequence(int) ; array := Integer.subrange(1,length)->collect(null) ;
    var neg : int ; neg := 0 ;
    var pos : int ; pos := 0 ;
        var i : int ; i := 0 ; while i < length do ( (     array[i+1] := sc.getCurrent()->toInteger() ; 
     if (array[i+1] > 0) then     pos := pos + 1 ; else     neg := neg + 1 ; )  ;     i := i + 1 ) ; 
    array := array->sort() ; 
    var ans : long ; ans := 1 ;
    var zeroes : int ; zeroes := length - pos - neg ;
    if ((pos >= 1)) then (     ans := array[array->size() - 1+1] ; 
     var temp1 : long ; temp1 := array[0+1] * array[1+1] ;
    var temp2 : long ; temp2 := array[array->size() - 2+1] * array[array->size() - 3+1] ;
    if (temp1 >= temp2) then (     ans := ans * temp1 ; 
     var temp3 : long ; temp3 := array[2+1] * array[3+1] ;
     if (temp3 >= temp2) then     ans := ans * temp3 ; else     ans := ans * temp2 ; ) else (     ans := ans * temp2 ; 
     var temp3 : long ; temp3 := array[array->size() - 4+1] * array[array->size() - 5+1] ;
     if (temp3 >= temp1) then     ans := ans * temp3 ; else     ans := ans * temp1 ; ) ;  
    OclFile["System.out"].println(ans) ; 
 ) else skip ; 
    if (pos = 0) then (     if (zeroes > 0) then     OclFile["System.out"].println(0) ; else (     var pingo : long ; pingo := 1 ;
     pingo := pingo*(array[array->size() - 1+1]->oclAsType(long)) ; 
    pingo := pingo*(array[array->size() - 2+1]->oclAsType(long)) ; 
    pingo := pingo*(array[array->size() - 3+1]->oclAsType(long)) ; 
    pingo := pingo*(array[array->size() - 4+1]->oclAsType(long)) ; 
    pingo := pingo*(array[array->size() - 5+1]->oclAsType(long)) ; 
    OclFile["System.out"].println(pingo) ; 
 ) ) else skip ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int t=1 ; t<=test ; t++){
      int n=in.nextInt();
      long a[]=new long[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextLong();
      }
      Arrays.sort(a);
      pw.println(solve(a,n));
    }
    pw.close();
  }
  static long solve(long a[],int n){
    long max1=a[n-1]*a[n-2]*a[n-3]*a[n-4]*a[n-5];
    long max2=a[0]*a[1]*a[n-1]*a[n-2]*a[n-3];
    long max3=a[0]*a[1]*a[2]*a[3]*a[n-1];
    long ans=Math.max(max1,Math.max(max2,max3));
    return ans ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= test do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation solve( a : Sequence(long), n : int) : long
  pre: true
  post: true
  activity: (     var max1 : long ; max1 := a[n - 1+1] * a[n - 2+1] * a[n - 3+1] * a[n - 4+1] * a[n - 5+1] ;
     var max2 : long ; max2 := a[0+1] * a[1+1] * a[n - 1+1] * a[n - 2+1] * a[n - 3+1] ;
    var max3 : long ; max3 := a[0+1] * a[1+1] * a[2+1] * a[3+1] * a[n - 1+1] ;
    var ans : long ; ans := Set{max1, Set{max2, max3}->max()}->max() ;
    return ans 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GFG {
  static int check(int A[],int B[],int N){
    PriorityQueue<Integer>pq1=new PriorityQueue<Integer>(Collections.reverseOrder());
    PriorityQueue<Integer>pq2=new PriorityQueue<Integer>(Collections.reverseOrder());
    for(int i=0 ; i<N ; i++){
      pq1.add(A[i]);
    }
    for(int i=0 ; i<N ; i++){
      pq2.add(B[i]);
    }
    int c=0 ;
    for(int i=0 ; i<N ; i++){
      if(pq1.peek().compareTo(pq2.peek())==1){
        c++;
        pq1.poll();
        pq2.poll();
      }
      else {
        if(pq2.size()==0){
          break ;
        }
        pq2.poll();
      }
    }
    return(c);
  }
  public static void main(String args[]){
    int A[]={
      10,3,7,5,8 };
      int B[]={
        8,6,2,5,9 };
        int N=A.length ;
        System.out.println(check(A,B,N));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( A : Sequence(int), B : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var pq1 : Sequence(int) ; pq1 := Sequence{}->union(reverseOrder()) ;
     var pq2 : Sequence(int) ; pq2 := Sequence{}->union(reverseOrder()) ;
        var i : int ; i := 0 ; while i < N do ( (     pq1 := pq1->including(A[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     pq2 := pq2->including(B[i+1]) )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (pq1->min()->compareTo(pq2->min()) = 1) then (     c := c + 1 ; 
     pq1 := pq1->sort()->tail() ; 
     pq2 := pq2->sort()->tail() ) else (     if (pq2->size() = 0) then (     break ) else skip ; 
     pq2 := pq2->sort()->tail() ) )  ;     i := i + 1 ) ; 
    return (c) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{10,3,7,5,8} ;
     var B : Sequence(int) ; B := Sequence{8,6,2,5,9} ;
     var N : int ; N := A->size() ;
     OclFile["System.out"].println(check(A, B, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B157 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int r[]=new int[n];
    for(int i=0 ; i<n ; i++){
      r[i]=sc.nextInt();
    }
    for(int i=0 ; i<n-1 ; i++){
      int min=r[i];
      int minPos=i ;
      for(int j=i+1 ; j<n ; j++){
        if(r[j]<min){
          min=r[j];
          minPos=j ;
        }
      }
      int temp=r[i];
      r[i]=r[minPos];
      r[minPos]=temp ;
    }
    double total=0.0 ;
    if(n % 2==1){
      for(int i=0 ; i<n ; i+=2){
        double diff=0.0 ;
        if(i==0)diff=r[i]*r[i];
        else diff=r[i]*r[i]-r[i-1]*r[i-1];
        double ans=Math.PI*diff ;
        total+=ans ;
      }
    }
    else {
      for(int i=1 ; i<n ; i+=2){
        double diff=r[i]*r[i]-r[i-1]*r[i-1];
        double ans=Math.PI*diff ;
        total+=ans ;
      }
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B157 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var r : Sequence(int) ; r := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     r[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var min : int ; min := r[i+1] ;
     var minPos : int ; minPos := i ;
        var j : int ; j := i + 1 ; while j < n do ( (     if (r[j+1] < min) then (     min := r[j+1] ; 
     minPos := j ) else skip )  ;     j := j + 1 ) ; 
    var temp : int ; temp := r[i+1] ;
    r[i+1] := r[minPos+1] ; 
    r[minPos+1] := temp ; 
 )  ;     i := i + 1 ) ; 
    var total : double ; total := 0.0 ;
    if (n mod 2 = 1) then (         var i : int ; i := 0 ; while i < n do ( (     var diff : double ; diff := 0.0 ;
     if (i = 0) then     diff := r[i+1] * r[i+1] else     diff := r[i+1] * r[i+1] - r[i - 1+1] * r[i - 1+1] ; ;  
     var ans : double ; ans := 3.141592653589793 * diff ;
     total := total+(ans) )  ;     i := i+(2) ) ) else (         var i : int ; i := 1 ; while i < n do ( (     var diff : double ; diff := r[i+1] * r[i+1] - r[i - 1+1] * r[i - 1+1] ;
     var ans : double ; ans := 3.141592653589793 * diff ;
     total := total+(ans) )  ;     i := i+(2) ) ) ;  
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigDecimal ;
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Stack ;
public class Solution {
  static int[] nodeColors ;
  static boolean[] visited ;
  static String[][] neighborstring ;
  static List<Integer>[] startIndices ;
  static int[] edgesToPrint ;
  static int mod=998244353 ;
  static int[] parents ;
  static HashSet<Integer>cycleSet ;
  static PriorityQueue<Integer>[] neighborPriority ;
  static int[] minPointsToEnterRoom ;
  static int[] maxPointsToEnterRoom ;
  static int[] pointOfEachRoom ;
  static List<Integer>[] neighbors ;
  static int[][] memo ;
  public static void main(String[] args)throws IOException {
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    int num=Integer.parseInt(bufferedReader.readLine());
    int[] nums=new int[num];
    String[] s=bufferedReader.readLine().split(" ");
    for(int i=0 ; i<num ; i++){
      nums[i]=Integer.parseInt(s[i]);
    }
    Arrays.sort(nums);
    double ans=0 ;
    boolean add=true ;
    for(int i=num-1 ; i>=0 ; i--){
      double a=Math.pow(nums[i],2)*3.1415926536 ;
      if(add){
        ans+=a ;
      }
      else {
        ans-=a ;
      }
      add=! add ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute nodeColors : Sequence(int);
  static   attribute visited : Sequence(boolean);
  static   attribute neighborstring : Sequence(Sequence(String));
  static   attribute startIndices : Sequence(Sequence(int));
  static   attribute edgesToPrint : Sequence(int);
  static   attribute mod : int := 998244353;
  static   attribute parents : Sequence(int);
  static   attribute cycleSet : Set(int);
  static   attribute neighborPriority : Sequence(Sequence(int));
  static   attribute minPointsToEnterRoom : Sequence(int);
  static   attribute maxPointsToEnterRoom : Sequence(int);
  static   attribute pointOfEachRoom : Sequence(int);
  static   attribute neighbors : Sequence(Sequence(int));
  static   attribute memo : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var num : int ; num := (bufferedReader.readLine())->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,num)->collect(0) ;
    var s : Sequence(String) ; s := bufferedReader.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < num do ( (     nums[i+1] := (s[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    nums := nums->sort() ; 
    var ans : double ; ans := 0 ;
    var add : boolean ; add := true ;
        var i : int ; i := num - 1 ; while i >= 0 do ( (     var a : double ; a := nums[i+1]->pow(2) * 3.1415926536 ;
     if (add) then (     ans := ans+(a) ) else (     ans := ans-(a) ) ;  
     add := not(add) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.text.DecimalFormat ;
import java.util.*;
import java.awt.*;
public class Main {
  public static void main(String[] args)throws Exception {
    FastReader sc=new FastReader();
    StringBuilder sb=new StringBuilder();
    double m=sc.nextInt(),n=sc.nextInt();
    double ans=0 ;
    for(int i=1 ; i<=m ; i++){
      ans+=i*(Math.pow(i/m,n)-Math.pow((i-1)/m,n));
    }
    System.out.println(ans);
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    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 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var sb : String ; sb := StringLib.newString() ;
    var m : double ; m := sc.nextInt() ;
    var n : double ; n := sc.nextInt() ;
    var ans : double ; ans := 0 ;
        var i : int ; i := 1 ; while i <= m do ( (     ans := ans+(i * (i / m->pow(n) - (i - 1) / m->pow(n))) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class P_453A {
  public static void main(String[] args)throws IOException {
    try(BufferedReader in=new BufferedReader(new InputStreamReader(System.in))){
      String[] ar=in.readLine().split(" ");
      double m=Double.parseDouble(ar[0]);
      int n=Integer.parseInt(ar[1]);
      double ans=0d ;
      for(int i=1 ; i<m ; i++){
        ans+=power(i/m,n);
      }
      System.out.println(m-ans);
    }
  }
  private static double power(double a,int b){
    double cur=a ;
    double ans=1d ;
    while(b>0){
      if((b & 1)==1){
        ans=(ans*cur);
      }
      b=(b>>1);
      cur=(cur*cur);
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class P_453A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var ar : Sequence(String) ; ar := in.readLine()->split(" ") ;
     var m : double ; m := (ar[0+1])->toReal() ;
    var n : int ; n := (ar[1+1])->toInteger() ;
    var ans : double ; ans := 0d ;
        var i : int ; i := 1 ; while i < m do ( (     ans := ans+(power(i / m, n)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(m - ans) ; 
 ))  );
  static   operation power( a : double, b : int) : double
  pre: true
  post: true
  activity: (     var cur : double ; cur := a ;
     var ans : double ; ans := 1d ;
     while (b > 0) do (     if ((b & 1) = 1) then (     ans := (ans * cur) ) else skip ; 
     b := ((b/(2->pow(1)))->oclAsType(long)) ; 
     cur := (cur * cur) ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.util.*;
public class code {
  public static void main(String args[])throws IOException {
    Scanner scn=new Scanner(System.in);
    double m=scn.nextInt();
    int n=scn.nextInt();
    double ans=0 ;
    for(int i=1 ; i<=m-1 ; i++)ans=ans+Math.pow(i/m,n);
    ans=m-ans ;
    System.out.println(ans);
  }
}
class Job implements Comparable<Job>{
  int problems,time ;
  public Job(int problems,int time){
    this.problems=problems ;
    this.time=time ;
  }
  public int compareTo(Job x){
    if(this.problems==x.problems){
      return this.time-x.time ;
    }
    else {
      return x.problems-this.problems ;
    }
  }
  public boolean equals(Job x){
    return((this.problems==x.problems)&&(this.time==x.time));
  }
}
------------------------------------------------------------
OCL File:
---------
 class code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : double ; m := scn.getCurrent()->toInteger() ;
    var n : int ; n := scn.getCurrent()->toInteger() ;
    var ans : double ; ans := 0 ;
        var i : int ; i := 1 ; while i <= m - 1 do (     ans := ans + i / m->pow(n) ;  ;     i := i + 1 ) ; 
    ans := m - ans ; 
    OclFile["System.out"].println(ans) ; 
 );
}
class Job implements Comparable<Job> {
   attribute problems : int;
   static operation newJob( problems : int, time : int) : Job
  pre: true
  post: true
  activity:
  ( var self : Job ;
    self := createJob();
    self.initialise(problems, time);
    return self );
  operation initialise( problems : int, time : int) : void
  pre: true  post: true
  activity: (     self.problems := problems ; 
     self.time := time );
   operation compareTo( x : Job) : int
  pre: true
  post: true
  activity: (     if (self.problems = x.problems) then (     return self.time - x.time ) else (     return x.problems - self.problems ) );
   operation equals( x : Job) : boolean
  pre: true
  post: true
  activity: (     return ((self.problems = x.problems) & (self.time = x.time)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Scanner ;
public class Unimodal {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=0,cont=0,in=0,eq=0,de=0 ;
    n=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    for(int i=0 ; i<n-1 ; i++){
      if(in==0 && eq==0 && de==0){
        if(arr[i]<arr[i+1]){
          in=0 ;
        }
        else {
          in++;
        }
      }
      if(in!=0 && eq==0 && de==0){
        if(arr[i]==arr[i+1]){
          eq=0 ;
        }
        else {
          eq++;
        }
      }
      if(in!=0 && eq!=0 && de==0){
        if(arr[i]>arr[i+1]){
          de=0 ;
        }
        else {
          de++;
        }
      }
      else {
      }
    }
    if(de==1){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Unimodal {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := 0 ;
    var cont : int ; cont := 0 ;
    var in : int ; in := 0 ;
    var eq : int ; eq := 0 ;
    var de : int ; de := 0 ;
    n := sc.getCurrent()->toInteger() ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (in = 0 & eq = 0 & de = 0) then (     if (arr[i+1] < arr[i + 1+1]) then (     in := 0 ) else (     in := in + 1 ) ) else skip ; 
     if (in /= 0 & eq = 0 & de = 0) then (     if (arr[i+1] = arr[i + 1+1]) then (     eq := 0 ) else (     eq := eq + 1 ) ) else skip ; 
     if (in /= 0 & eq /= 0 & de = 0) then (     if (arr[i+1] > arr[i + 1+1]) then (     de := 0 ) else (     de := de + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    if (de = 1) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class A {
  public static void main(String hi[])throws Exception {
    BufferedReader infile=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(infile.readLine());
    int N=Integer.parseInt(st.nextToken());
    int T=Integer.parseInt(st.nextToken());
    if(N==1)System.out.println(1.0);
    else {
      double greater=1.0 ;
      for(int i=0 ; i<T ; i++)greater*=1.0*(N-1)/N ;
      greater=1.0-greater ;
      double res=greater*N ;
      for(int max=N-1 ; max>=1 ; max--){
        double prob=1.0-greater ;
        prob-=Math.pow(1.0*(max-1)/N,T);
        res+=max*prob ;
        greater+=prob ;
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( hi : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var infile : OclFile ; infile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(infile.readLine()) ;
    var N : int ; N := (st.next())->toInteger() ;
    var T : int ; T := (st.next())->toInteger() ;
    if (N = 1) then     OclFile["System.out"].println(1.0) else (     var greater : double ; greater := 1.0 ;
         var i : int ; i := 0 ; while i < T do (     greater := greater*(1.0 * (N - 1) / N) ;  ;     i := i + 1 ) ; 
    greater := 1.0 - greater ; 
    var res : double ; res := greater * N ;
        var max : int ; max := N - 1 ; while max >= 1 do ( (     var prob : double ; prob := 1.0 - greater ;
     prob := prob-(1.0 * (max - 1) / N->pow(T)) ; 
     res := res+(max * prob) ; 
     greater := greater+(prob) )  ;     max := max - 1 ) ; 
    OclFile["System.out"].println(res) ; 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  public static int sumOfSubstrings(String num){
    int n=num.length();
    int sumofdigit[]=new int[n];
    sumofdigit[0]=num.charAt(0)-'0' ;
    int res=sumofdigit[0];
    for(int i=1 ; i<n ; i++){
      int numi=num.charAt(i)-'0' ;
      sumofdigit[i]=(i+1)*numi+10*sumofdigit[i-1];
      res+=sumofdigit[i];
    }
    return res ;
  }
  public static void main(String[] args){
    String num="1234" ;
    System.out.println(sumOfSubstrings(num));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfSubstrings( num : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := num->size() ;
     var sumofdigit : Sequence(int) ; sumofdigit := Integer.subrange(1,n)->collect(0) ;
    sumofdigit[0+1] := num->at(0+1) - ('0')->char2byte() ; 
    var res : int ; res := sumofdigit[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     var numi : int ; numi := num->at(i+1) - ('0')->char2byte() ;
     sumofdigit[i+1] := (i + 1) * numi + 10 * sumofdigit[i - 1+1] ; 
     res := res+(sumofdigit[i+1]) )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : String ; num := "1234" ;
     OclFile["System.out"].println(sumOfSubstrings(num)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    Integer intN=scan.nextInt();
    Integer intM=scan.nextInt();
    int[] highArr=new int[intN+1];
    for(int i=1 ; i<=intN ; i++){
      highArr[i]=scan.nextInt();
    }
    List<Integer>ngList=new ArrayList<Integer>();
    while(scan.hasNext()){
      Integer intLeft=scan.nextInt();
      Integer intRight=scan.nextInt();
      if(highArr[intLeft]<highArr[intRight]){
        ngList.add(intLeft);
      }
      else if(highArr[intLeft]>highArr[intRight]){
        ngList.add(intRight);
      }
      else {
        ngList.add(intLeft);
        ngList.add(intRight);
      }
    }
    scan.close();
    ArrayList<Integer>retList=new ArrayList<Integer>(new HashSet<>(ngList));
    System.out.println(intN-retList.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var intN : int ; intN := scan.getCurrent()->toInteger() ;
    var intM : int ; intM := scan.getCurrent()->toInteger() ;
    var highArr : Sequence(int) ; highArr := Integer.subrange(1,intN + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= intN do ( (     highArr[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ngList : Sequence(int) ; ngList := Sequence{} ;
    while (scan.hasNext()) do (     var intLeft : int ; intLeft := scan.getCurrent()->toInteger() ;
     var intRight : int ; intRight := scan.getCurrent()->toInteger() ;
     if (highArr[intLeft+1] < highArr[intRight+1]) then (     ngList := ngList->including(intLeft) ) else     if (highArr[intLeft+1] > highArr[intRight+1]) then (     ngList := ngList->including(intRight) ) else (     ngList := ngList->including(intLeft) ; 
     ngList := ngList->including(intRight) ) ;  ) ; 
    skip ; 
    var retList : Sequence(int) ; retList := Sequence{}->union(Set{}->union(ngList)) ;
    OclFile["System.out"].println(intN - retList->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void compute(long S,long X){
    long A=(S-X)/2 ;
    int a=0,b=0 ;
    final int LONG_FIELD_SIZE=8 ;
    for(int i=0 ; i<8*LONG_FIELD_SIZE ; i++){
      long Xi=(X &(1<<i));
      long Ai=(A &(1<<i));
      if(Xi==0 && Ai==0){
      }
      else if(Xi==0 && Ai>0){
        a=((1<<i)| a);
        b=((1<<i)| b);
      }
      else if(Xi>0 && Ai==0){
        a=((1<<i)| a);
      }
      else {
        System.out.println("Not Possible");
        return ;
      }
    }
    System.out.println("a="+a+"\nb="+b);
  }
  public static void main(String[] args){
    long S=17,X=13 ;
    compute(S,X);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation compute( S : long, X : long) : void
  pre: true
  post: true
  activity: (     var A : long ; A := (S - X) / 2 ;
     var a : int ; a := 0 ;
    var b : int ; b := 0 ;
    var LONG_FIELD_SIZE : int ; LONG_FIELD_SIZE := 8 ;
        var i : int ; i := 0 ; while i < 8 * LONG_FIELD_SIZE do ( (     var Xi : long ; Xi := (MathLib.bitwiseAnd(X,((1*(2->pow(i)))->oclAsType(long)))) ;
     var Ai : long ; Ai := (MathLib.bitwiseAnd(A,((1*(2->pow(i)))->oclAsType(long)))) ;
     if (Xi = 0 & Ai = 0) then skip else     if (Xi = 0 & Ai > 0) then (     a := (((1*(2->pow(i)))->oclAsType(long)) or a) ; 
     b := (((1*(2->pow(i)))->oclAsType(long)) or b) ) else     if (Xi > 0 & Ai = 0) then (     a := (((1*(2->pow(i)))->oclAsType(long)) or a) ) else (     OclFile["System.out"].println("Not Possible") ; 
     return ) ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("a=" + a + "\nb=" + b) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := 17 ;
    var X : long ; X := 13 ;
     execute compute(S, X) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class _1320A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++)b[i]=sc.nextInt()-i-1 ;
    HashMap<Integer,Long>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      map.putIfAbsent(b[i],0L);
      map.put(b[i],map.get(b[i])+b[i]+i+1);
    }
    long beauty=0 ;
    for(Map.Entry<Integer,Long>itr : map.entrySet()){
      beauty=Math.max(itr.getValue(),beauty);
    }
    System.out.println(beauty);
  }
  public static int gcd(int a,int b){
    return(a==0)? b : gcd(b % a,a);
  }
  static int power(int x,int y){
    int ans=1 ;
    while(y>0){
      if((y & 1)!=0)ans*=x ;
      y=y>>1 ;
      x*=x ;
    }
    return ans ;
  }
  public static List<Integer>sieve(int n){
    List<Integer>primes=new LinkedList<>();
    boolean[] composite=new boolean[n+1];
    for(int i=2 ; i*i<=n ; i++)for(int j=i*i ; j<=n && ! composite[i]; j+=i)composite[j]=true ;
    for(int j=2 ; j<composite.length ; j++)if(! composite[j])primes.add(j);
    return primes ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1320A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     b[i+1] := sc.getCurrent()->toInteger() - i - 1 ;  ;     i := i + 1 ) ; 
    var map : Map(int,long) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     if map->keys()->includes(b[i+1]) then skip else map := map->union(Map{b[i+1] |-> 0L}) ; 
     map := map->union(Map{b[i+1] |-> map->at(b[i+1]) + b[i+1] + i + 1}) )  ;     i := i + 1 ) ; 
    var beauty : long ; beauty := 0 ;
    for (itr : map->asSet()) do ( (     beauty := Set{itr.getValue(), beauty}->max() )  ) ; 
    OclFile["System.out"].println(beauty) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if (a = 0) then b else gcd(b mod a, a) endif );
  static   operation power( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
     while (y > 0) do (     if ((y & 1) /= 0) then     ans := ans*(x) ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := x*(x) ) ; 
     return ans );
  static   operation sieve( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var primes : Sequence(int) ; primes := Sequence{} ;
     var composite : Sequence(boolean) ; composite := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 2 ; while i * i <= n do (         var j : int ; j := i * i ; while j <= n & not(composite[i+1]) do (     composite[j+1] := true ;  ;     j := j+(i) ) ;  ;     i := i + 1 ) ; 
        var j : int ; j := 2 ; while j < composite->size() do (     if (not(composite[j+1])) then     primes := primes->including(j) ; else skip ;  ;     j := j + 1 ) ; 
    return primes 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
public class JourneyPlanning {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    String[] temp=br.readLine().split(" ");
    Map<Integer,List<Integer>>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int b=Integer.parseInt(temp[i]);
      int mask=(i+1)-b ;
      if(map.containsKey(mask)==false){
        map.put(mask,new ArrayList<>());
      }
      map.get(mask).add(b);
    }
    long res=0 ;
    for(List<Integer>list : map.values()){
      long sum=0 ;
      for(int i : list){
        sum+=i ;
      }
      res=Math.max(sum,res);
    }
    pr.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JourneyPlanning {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
    var map : Map(int,Sequence(int)) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var b : int ; b := (temp[i+1])->toInteger() ;
     var mask : int ; mask := (i + 1) - b ;
     if (map->keys()->includes(mask) = false) then (     map := map->union(Map{mask |-> Sequence{}}) ) else skip ; 
     map->at(mask)->excludes(b) )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
    for (list : map->values()) do ( (     var sum : long ; sum := 0 ;
     for (i : list) do ( (     sum := sum+(i) )  ) ; 
     res := Set{sum, res}->max() )  ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class teams {
  static int n,b[];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int i ;
    n=sc.nextInt();
    b=new int[n];
    for(i=0 ; i<n ; i++)b[i]=sc.nextInt();
    long a[],c[];
    long max=0 ;
    a=new long[400005];
    c=new long[400005];
    for(i=0 ; i<n ; i++){
      if((i-b[i])>=0)a[i-b[i] ]+=b[i];
      else c[b[i]-i]+=b[i];
    }
    for(i=0 ; i<400005 ; i++)max=Math.max(max,a[i]);
    for(i=0 ; i<400005 ; i++)max=Math.max(max,c[i]);
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class teams {
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ;
    n := sc.getCurrent()->toInteger() ; 
    b := Integer.subrange(1,n)->collect(0) ; 
        i := 0 ; while i < n do (     b[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var a : Sequence(long) ;
    var c : Sequence(void) ;
    var max : long ; max := 0 ;
    a := Integer.subrange(1,400005)->collect(0) ; 
    c := Integer.subrange(1,400005)->collect(0) ; 
        i := 0 ; while i < n do ( (     if ((i - b[i+1]) >= 0) then     a[i - b[i+1]+1] := a[i - b[i+1]+1]+(b[i+1]) ; else     c[b[i+1] - i+1] := c[b[i+1] - i+1]+(b[i+1]) ; )  ;     i := i + 1 ) ; 
        i := 0 ; while i < 400005 do (     max := Set{max, a[i+1]}->max() ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < 400005 do (     max := Set{max, c[i+1]}->max() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] b=new int[n];
    for(int i=0 ; i<b.length ; ++i){
      b[i]=sc.nextInt();
    }
    System.out.println(solve(b));
    sc.close();
  }
  static long solve(int[] b){
    Map<Integer,Long>baseToSum=new HashMap<>();
    for(int i=0 ; i<b.length ; ++i){
      int base=b[i]-i ;
      baseToSum.put(base,baseToSum.getOrDefault(base,0L)+b[i]);
    }
    return baseToSum.values().stream().mapToLong(x->x).max().getAsLong();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < b->size() do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(b)) ; 
    skip ; 
 );
  static   operation solve( b : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var baseToSum : Map(int,long) ; baseToSum := Map{} ;
         var i : int ; i := 0 ; while i < b->size() do ( (     var base : int ; base := b[i+1] - i ;
     baseToSum := baseToSum->union(Map{base |-> (if baseToSum->keys()->contains(base) then baseToSum->at(base) else 0L endif) + b[i+1]}) )  ;     i := i + 1 ) ; 
     return baseToSum->values()->collect( _x1 | (lambda x : OclAny in x)->apply(_x1) ).max().getAsLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int numOfIncSubseqOfSizeK(int arr[],int n,int k){
    int dp[][]=new int[k][n],sum=0 ;
    for(int i=0 ; i<n ; i++){
      dp[0][i]=1 ;
    }
    for(int l=1 ; l<k ; l++){
      for(int i=l ; i<n ; i++){
        dp[l][i]=0 ;
        for(int j=l-1 ; j<i ; j++){
          if(arr[j]<arr[i]){
            dp[l][i]+=dp[l-1][j];
          }
        }
      }
    }
    for(int i=k-1 ; i<n ; i++){
      sum+=dp[k-1][i];
    }
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      12,8,11,13,10,15,14,16,20 };
      int n=arr.length ;
      int k=4 ;
      System.out.print("Number of Increasing Subsequences of size "+k+"="+numOfIncSubseqOfSizeK(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation numOfIncSubseqOfSizeK( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,k)->collect(Integer.subrange(1,n)->collect(0)) ;
    var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     dp[0+1][i+1] := 1 )  ;     i := i + 1 ) ; 
        var l : int ; l := 1 ; while l < k do ( (         var i : int ; i := l ; while i < n do ( (     dp[l+1][i+1] := 0 ; 
         var j : int ; j := l - 1 ; while j < i do ( (     if (arr[j+1] < arr[i+1]) then (     dp[l+1][i+1] := dp[l+1][i+1]+(dp[l - 1+1][j+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     l := l + 1 ) ; 
        var i : int ; i := k - 1 ; while i < n do ( (     sum := sum+(dp[k - 1+1][i+1]) )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,8,11,13,10,15,14,16,20} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 4 ;
     OclFile["System.out"].print("Number of Increasing Subsequences of size " + k + "=" + numOfIncSubseqOfSizeK(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int addOne(int x){
    return(-(~ x));
  }
  public static void main(String[] args){
    System.out.printf("%d",addOne(13));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation addOne( x : int) : int
  pre: true
  post: true
  activity: (     return (-(-(x + 1))) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].printf("%d", addOne(13)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long fifthPowerSum(int n){
    return((2*n*n*n*n*n*n)+(6*n*n*n*n*n)+(5*n*n*n*n)-(n*n))/12 ;
  }
  public static void main(String args[]){
    int n=5 ;
    System.out.println(fifthPowerSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fifthPowerSum( n : int) : long
  pre: true
  post: true
  activity: (     return ((2 * n * n * n * n * n * n) + (6 * n * n * n * n * n) + (5 * n * n * n * n) - (n * n)) / 12 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(fifthPowerSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int nextPowerOf2(int n){
    n--;
    n |=n>>1 ;
    n |=n>>2 ;
    n |=n>>4 ;
    n |=n>>8 ;
    n |=n>>16 ;
    n++;
    return n ;
  }
  public static void main(String args[]){
    int n=5 ;
    System.out.println(nextPowerOf2(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nextPowerOf2( n : int) : int
  pre: true
  post: true
  activity: (     n := n - 1 ; 
     n := MathLib.bitwiseOr(n, (n/(2->pow(1)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(2)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(4)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(8)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(16)))->oclAsType(long)) ; 
    n := n + 1 ; 
    return n 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(nextPowerOf2(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printArr(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  static void findArray(int n,int k,int s){
    int vis[]=new int[n];
    int cnt=0 ;
    int arr[]=new int[n];
    for(int i=0 ; i<n && cnt<k ; i+=2){
      arr[i]=s ;
      vis[i]=1 ;
      cnt++;
    }
    int val=s ;
    if(s % 2==0)val++;
    else val=val+2 ;
    for(int i=0 ; i<n ; i++){
      if(vis[i]==0){
        arr[i]=val ;
      }
    }
    printArr(arr,n);
  }
  public static void main(String[] args){
    int n=8,k=3,s=12 ;
    findArray(n,k,s);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation findArray( n : int, k : int, s : int) : void
  pre: true
  post: true
  activity: (     var vis : Sequence(int) ; vis := Integer.subrange(1,n)->collect(0) ;
     var cnt : int ; cnt := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n & cnt < k do ( (     arr[i+1] := s ; 
     vis[i+1] := 1 ; 
     cnt := cnt + 1 )  ;     i := i+(2) ) ; 
    var val : int ; val := s ;
    if (s mod 2 = 0) then     val := val + 1 else     val := val + 2 ; ;  
        var i : int ; i := 0 ; while i < n do ( (     if (vis[i+1] = 0) then (     arr[i+1] := val ) else skip )  ;     i := i + 1 ) ; 
    execute printArr(arr, n) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
    var k : int ; k := 3 ;
    var s : int ; s := 12 ;
     execute findArray(n, k, s) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long M=sc.nextLong();
    long[] H=new long[N];
    boolean[] ans=new boolean[N];
    for(int i=0 ; i<N ; i++){
      H[i]=sc.nextLong();
      ans[i]=true ;
    }
    for(int i=0 ; i<M ; i++){
      int temp1=sc.nextInt();
      int temp2=sc.nextInt();
      if(H[temp1-1]<H[temp2-1]){
        ans[temp1-1]=false ;
      }
      else if(H[temp1-1]>H[temp2-1]){
        ans[temp2-1]=false ;
      }
      else {
        ans[temp1-1]=false ;
        ans[temp2-1]=false ;
      }
    }
    int ans2=0 ;
    for(int i=0 ; i<N ; i++){
      if(ans[i]){
        ans2++;
      }
    }
    System.out.println(ans2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : long ; M := sc.getCurrent()->toLong() ;
    var H : Sequence(long) ; H := Integer.subrange(1,N)->collect(0) ;
    var ans : Sequence(boolean) ; ans := Integer.subrange(1,N)->collect(false) ;
        var i : int ; i := 0 ; while i < N do ( (     H[i+1] := sc.getCurrent()->toLong() ; 
     ans[i+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var temp1 : int ; temp1 := sc.getCurrent()->toInteger() ;
     var temp2 : int ; temp2 := sc.getCurrent()->toInteger() ;
     if (H[temp1 - 1+1] < H[temp2 - 1+1]) then (     ans[temp1 - 1+1] := false ) else     if (H[temp1 - 1+1] > H[temp2 - 1+1]) then (     ans[temp2 - 1+1] := false ) else (     ans[temp1 - 1+1] := false ; 
     ans[temp2 - 1+1] := false ) ;  )  ;     i := i + 1 ) ; 
    var ans2 : int ; ans2 := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (ans[i+1]) then (     ans2 := ans2 + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    HashSet<Integer>set=new HashSet<>();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
    }
    int i=0 ;
    while(i<n-1 && arr[i]<arr[i+1]){
      i++;
    }
    while(i<n-1 && arr[i]==arr[i+1]){
      i++;
    }
    while(i<n-1 && arr[i]>arr[i+1]){
      i++;
    }
    if(i==n-1){
      pw.println("YES");
    }
    else {
      pw.println("NO");
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var i : int ; i := 0 ;
    while (i < n - 1 & arr[i+1] < arr[i + 1+1]) do (     i := i + 1 ) ; 
    while (i < n - 1 & arr[i+1] = arr[i + 1+1]) do (     i := i + 1 ) ; 
    while (i < n - 1 & arr[i+1] > arr[i + 1+1]) do (     i := i + 1 ) ; 
    if (i = n - 1) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Demo {
  public static void main(String[] args){
    String w[]={
      "ABSINTH","BEER","BRANDY","CHAMPAGNE","GIN","RUM","SAKE","TEQUILA","VODKA","WHISKEY","WINE" };
      Scanner sc=new Scanner(System.in);
      int n=Integer.parseInt(sc.nextLine()),c=0 ;
      for(int i=0 ; i<n ; i++){
        String a=sc.nextLine();
        if(a.charAt(0)>='0' && a.charAt(0)<='9')if(Integer.parseInt(a)<18){
          c++;
          continue ;
        }
        for(int j=0 ; j<w.length ; j++)if(a.equals(w[j])){
          c++;
          break ;
        }
      }
      System.out.println(c);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Demo {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var w : Sequence(String) ; w := Sequence{"ABSINTH","BEER","BRANDY","CHAMPAGNE","GIN","RUM","SAKE","TEQUILA","VODKA","WHISKEY","WINE"} ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := (sc.nextLine())->toInteger() ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : String ; a := sc.nextLine() ;
     if (a->at(0+1) >= '0' & a->at(0+1) <= '9') then     if ((a)->toInteger() < 18) then (     c := c + 1 ; 
     continue ) else skip ; else skip ; 
         var j : int ; j := 0 ; while j < w->size() do (     if (a = w[j+1]) then (     c := c + 1 ; 
     break ) else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    HashSet<String>set=new HashSet<>();
    set.add("VODKA");
    set.add("WHISKEY");
    set.add("WINE");
    set.add("TEQUILA");
    set.add("SAKE");
    set.add("RUM");
    set.add("GIN");
    set.add("CHAMPAGNE");
    set.add("BEER");
    int ctr=0 ;
    set.add("BRANDY");
    set.add("ABSINTH");
    int n=s.nextInt();
    while(n-->0){
      String str=s.next();
      char ch=str.charAt(0);
      if(! Character.isLetter(ch)){
        if(Integer.parseInt(str)<18){
          ctr++;
        }
      }
      else {
        if(set.contains(str)){
          ctr++;
        }
      }
    }
    System.out.print(ctr);
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var set : Set(String) ; set := Set{} ;
    set := set->including("VODKA") ; 
    set := set->including("WHISKEY") ; 
    set := set->including("WINE") ; 
    set := set->including("TEQUILA") ; 
    set := set->including("SAKE") ; 
    set := set->including("RUM") ; 
    set := set->including("GIN") ; 
    set := set->including("CHAMPAGNE") ; 
    set := set->including("BEER") ; 
    var ctr : int ; ctr := 0 ;
    set := set->including("BRANDY") ; 
    set := set->including("ABSINTH") ; 
    var n : int ; n := s.getCurrent()->toInteger() ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var str : String ; str := s.getCurrent() ;
     var ch : String ; ch := str->at(0+1) ;
     if (not((ch + "")->isMatch("[a-zA-Z]"))) then (     if ((str)->toInteger() < 18) then (     ctr := ctr + 1 ) else skip ) else (     if (set->includes(str)) then (     ctr := ctr + 1 ) else skip ) ) ;  ) ;  
    OclFile["System.out"].print(ctr) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int findLargestDivisor(int n){
    for(int i=2 ; i<Math.sqrt(n)+1 ; i++){
      while(n %(i*i)==0){
        n=n/i ;
      }
    }
    return n ;
  }
  public static void main(String args[]){
    int n=12 ;
    System.out.println(findLargestDivisor(n));
    n=97 ;
    System.out.println(findLargestDivisor(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findLargestDivisor( n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i < (n)->sqrt() + 1 do ( (     while (n mod (i * i) = 0) do (     n := n / i ) )  ;     i := i + 1 ) ; 
     return n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     OclFile["System.out"].println(findLargestDivisor(n)) ; 
     n := 97 ; 
     OclFile["System.out"].println(findLargestDivisor(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long MOD=1000000007L ;
    int a=sc.nextInt();
    int p=sc.nextInt();
    System.out.println((3*a+p)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var MOD : long ; MOD := 1000000007L ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println((3 * a + p) / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    String[] arr=br.readLine().split(" ");
    int A=Integer.parseInt(arr[0]);
    int P=Integer.parseInt(arr[1]);
    out.println((A*3+P)/2);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var arr : Sequence(String) ; arr := br.readLine()->split(" ") ;
    var A : int ; A := (arr[0+1])->toInteger() ;
    var P : int ; P := (arr[1+1])->toInteger() ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  void solve(){
    int a=in.nextInt(),p=in.nextInt();
    p+=a*3 ;
    out.println(p/2);
  }
  public static PrintWriter out=new PrintWriter(System.out);
  public static Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main().solve();
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.nextInt() ;
    var p : int ; p := in.nextInt() ;
     p := p+(a * 3) ; 
     out.println(p / 2) );
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int p=sc.nextInt();
    int c=a*3 ;
    int pie=(c+p)/2 ;
    System.out.println(pie);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
    var c : int ; c := a * 3 ;
    var pie : int ; pie := (c + p) / 2 ;
    OclFile["System.out"].println(pie) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void solve(char[] a,char[] b){
    int l=a.length ;
    int min=0,max=0 ;
    for(int i=0 ; i<l ; i++){
      if(a[i]=='+' || b[i]=='+' || a[i]!=b[i])max++;
      if(a[i]!='+' && b[i]!='+' && a[i]!=b[i])min++;
    }
    System.out.print(min+max+"\n");
  }
  public static void main(String[] args){
    String s1="a+c",s2="++b" ;
    solve(s1.toCharArray(),s2.toCharArray());
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( a : Sequence(String), b : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := a->size() ;
     var min : int ; min := 0 ;
    var max : int ; max := 0 ;
         var i : int ; i := 0 ; while i < l do ( (     if (a[i+1] = '+' or b[i+1] = '+' or a[i+1] /= b[i+1]) then     max := max + 1 ; else skip ; 
     if (a[i+1] /= '+' & b[i+1] /= '+' & a[i+1] /= b[i+1]) then     min := min + 1 ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(min + max + "\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "a+c" ;
    var s2 : String ; s2 := "++b" ;
     execute solve(s1->characters(), s2->characters()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int P=sc.nextInt();
    int sumP=3*A+P ;
    int api=sumP/2 ;
    System.out.println(api);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var P : int ; P := sc.getCurrent()->toInteger() ;
    var sumP : int ; sumP := 3 * A + P ;
    var api : int ; api := sumP / 2 ;
    OclFile["System.out"].println(api) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int n ;
  int ary[];
  int cnt ;
  public static void main(String args[]){
    new Main().run();
  }
  Main(){
    Scanner scan=new Scanner(System.in);
    n=scan.nextInt();
    ary=new int[n];
    for(int i=0 ; i<n ; i++){
      ary[i]=scan.nextInt();
    }
  }
  void run(){
    mergeSort(ary,0,n);
    for(int i=0 ; i<n ; i++){
      System.out.print((i!=0 ? " " : "")+ary[i]);
    }
    System.out.println();
    System.out.println(cnt);
  }
  void mergeSort(int[] ary,int left,int right){
    if(left+1<right){
      int mid=(left+right)/2 ;
      mergeSort(ary,left,mid);
      mergeSort(ary,mid,right);
      merge(ary,left,mid,right);
    }
  }
  void merge(int[] ary,int left,int mid,int right){
    int n1=mid-left ;
    int n2=right-mid ;
    int l[]=new int[n1+1];
    int r[]=new int[n2+1];
    for(int i=0 ; i<n1 ; i++){
      l[i]=ary[left+i];
    }
    for(int i=0 ; i<n2 ; i++){
      r[i]=ary[mid+i];
    }
    l[n1]=Integer.MAX_VALUE ;
    r[n2]=Integer.MAX_VALUE ;
    int i=0 ;
    int j=0 ;
    for(int k=left ; k<right ; k++){
      if(l[i]<=r[j]){
        ary[k]=l[i];
        i++;
      }
      else {
        ary[k]=r[j];
        j++;
      }
      cnt++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute ary : Sequence(int);
   attribute cnt : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := scan.getCurrent()->toInteger() ; 
     ary := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do ( (     ary[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) );
   operation run() : void
  pre: true
  post: true
  activity: (     execute mergeSort(ary, 0, n) ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print((if i /= 0 then " " else "" endif) + ary[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ; 
     OclFile["System.out"].println(cnt) );
   operation mergeSort( ary : Sequence(int), left : int, right : int) : void
  pre: true
  post: true
  activity: (     if (left + 1 < right) then (     var mid : int ; mid := (left + right) / 2 ;
     execute mergeSort(ary, left, mid) ; 
     execute mergeSort(ary, mid, right) ; 
     execute merge(ary, left, mid, right) ) else skip );
   operation merge( ary : Sequence(int), left : int, mid : int, right : int) : void
  pre: true
  post: true
  activity: (     var n1 : int ; n1 := mid - left ;
     var n2 : int ; n2 := right - mid ;
    var l : Sequence(int) ; l := Integer.subrange(1,n1 + 1)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,n2 + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n1 do ( (     l[i+1] := ary[left + i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n2 do ( (     r[i+1] := ary[mid + i+1] )  ;     i := i + 1 ) ; 
    l[n1+1] := 2147483647 ; 
    r[n2+1] := 2147483647 ; 
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
        var k : int ; k := left ; while k < right do ( (     if (l[i+1] <= r[j+1]) then (     ary[k+1] := l[i+1] ; 
     i := i + 1 ) else (     ary[k+1] := r[j+1] ; 
     j := j + 1 ) ;  
     cnt := cnt + 1 )  ;     k := k + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class exp_sq {
  static long N=1000000007L ;
  public static void main(String[] args){
    long base=5 ;
    long exp=100000 ;
    long modulo=exponentiation(base,exp);
    System.out.println(modulo);
  }
  static long exponentiation(long base,long exp){
    long t=1L ;
    while(exp>0){
      if(exp % 2!=0)t=(t*base)% N ;
      base=(base*base)% N ;
      exp/=2 ;
    }
    return t % N ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class exp_sq {
  static   attribute N : long := 1000000007L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var base : long ; base := 5 ;
     var exp : long ; exp := 100000 ;
     var modulo : long ; modulo := exponentiation(base, exp) ;
     OclFile["System.out"].println(modulo) );
  static   operation exponentiation( base : long, exp : long) : long
  pre: true
  post: true
  activity: (     var t : long ; t := 1L ;
     while (exp > 0) do (     if (exp mod 2 /= 0) then     t := (t * base) mod N ; else skip ; 
     base := (base * base) mod N ; 
     exp := exp/(2) ) ; 
     return t mod N );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class exp_sq {
  static long N=1000000007L ;
  public static void main(String[] args){
    long base=5 ;
    long exp=100000 ;
    long modulo=exponentiation(base,exp);
    System.out.println(modulo);
  }
  static long exponentiation(long base,long exp){
    if(exp==0)return 1 ;
    if(exp==1)return base % N ;
    long t=exponentiation(base,exp/2);
    t=(t*t)% N ;
    if(exp % 2==0)return t ;
    else return((base % N)*t)% N ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class exp_sq {
  static   attribute N : long := 1000000007L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var base : long ; base := 5 ;
     var exp : long ; exp := 100000 ;
     var modulo : long ; modulo := exponentiation(base, exp) ;
     OclFile["System.out"].println(modulo) );
  static   operation exponentiation( base : long, exp : long) : long
  pre: true
  post: true
  activity: (     if (exp = 0) then     return 1 else skip ; 
     if (exp = 1) then     return base mod N else skip ; 
    var t : long ; t := exponentiation(base, exp / 2) ;
    t := (t * t) mod N ; 
    if (exp mod 2 = 0) then     return t else     return ((base mod N) * t) mod N ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class HelloWorld {
  static int distinctDigitSum(int n){
    boolean used[]=new boolean[10];
    int sum=0 ;
    while(n>0){
      int digit=n % 10 ;
      if(! used[digit]){
        used[digit]=true ;
        sum+=digit ;
      }
      n=n/10 ;
    }
    return sum ;
  }
  static String checkSum(int m,int n){
    int sumM=distinctDigitSum(m);
    int sumN=distinctDigitSum(n);
    if(sumM==sumN)return "YES" ;
    return "NO" ;
  }
  public static void main(String[] args){
    int m=2452,n=9222 ;
    System.out.println(checkSum(m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class HelloWorld {
  static   operation distinctDigitSum( n : int) : int
  pre: true
  post: true
  activity: (     var used : Sequence(boolean) ; used := Integer.subrange(1,10)->collect(false) ;
     var sum : int ; sum := 0 ;
     while (n > 0) do (     var digit : int ; digit := n mod 10 ;
     if (not(used[digit+1])) then (     used[digit+1] := true ; 
     sum := sum+(digit) ) else skip ; 
     n := n / 10 ) ; 
     return sum );
  static   operation checkSum( m : int, n : int) : String
  pre: true
  post: true
  activity: (     var sumM : int ; sumM := distinctDigitSum(m) ;
     var sumN : int ; sumN := distinctDigitSum(n) ;
     if (sumM = sumN) then     return "YES" else skip ; 
     return "NO" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 2452 ;
    var n : int ; n := 9222 ;
     OclFile["System.out"].println(checkSum(m, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void solve(int A,int B){
    double p=B/2.0 ;
    double M=Math.ceil(4*p);
    int N=1 ;
    int O=-2*A ;
    double Q=Math.ceil(A*A+4*p*p);
    System.out.println(M+" "+N+" "+O+" "+Q);
  }
  public static void main(String[] args){
    int a=1 ;
    int b=1 ;
    solve(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( A : int, B : int) : void
  pre: true
  post: true
  activity: (     var p : double ; p := B / 2.0 ;
     var M : double ; M := (4 * p)->ceil() ;
    var N : int ; N := 1 ;
    var O : int ; O := -2 * A ;
    var Q : double ; Q := (A * A + 4 * p * p)->ceil() ;
    OclFile["System.out"].println(M + " " + N + " " + O + " " + Q) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 1 ;
     var b : int ; b := 1 ;
     execute solve(a, b) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Geeks_For_Geeks {
  public static char[] sortArrays(char[] arr){
    int length=arr.length ;
    for(int j=0 ; j<arr.length-1 ; j++){
      int d1=arr[j];
      int d2=arr[j+1];
      if(d1>d2){
        char temp=arr[j];
        arr[j]=arr[j+1];
        arr[j+1]=temp ;
        j=-1 ;
      }
    }
    return arr ;
  }
  public static void main(String args[]){
    String geeks="GEEKSFORGEEKS" ;
    char arr[]=geeks.toCharArray();
    System.out.println("Original array: "+Arrays.toString(arr));
    arr=sortArrays(arr);
    System.out.println("Sorted array: "+Arrays.toString(arr));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Geeks_For_Geeks {
  static   operation sortArrays( arr : Sequence(String)) : Sequence(String)
  pre: true
  post: true
  activity: (     var length : int ; length := arr->size() ;
         var j : int ; j := 0 ; while j < arr->size() - 1 do ( (     var d1 : int ; d1 := arr[j+1] ;
     var d2 : int ; d2 := arr[j + 1+1] ;
     if (d1 > d2) then (     var temp : String ; temp := arr[j+1] ;
     arr[j+1] := arr[j + 1+1] ; 
     arr[j + 1+1] := temp ; 
     j := -1 ) else skip )  ;     j := j + 1 ) ; 
     return arr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var geeks : String ; geeks := "GEEKSFORGEEKS" ;
     var arr : Sequence(String) ; arr := geeks->characters() ;
    OclFile["System.out"].println("Original array: " + (arr + "")) ; 
    arr := sortArrays(arr) ; 
    OclFile["System.out"].println("Sorted array: " + (arr + "")) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static long solve(long a,long b,long x,long y,long n){
    long t=a+b-x-y ;
    if(t<=n)return x*y ;
    if(a<=b){
      t=a-x ;
      if(t>=n)return(a-n)*b ;
      else {
        long ans=x*(b-n+a-x);
        t=b-y ;
        if(t>=n)return Math.min(ans,a*(b-n));
        else return Math.min(ans,y*(a-n+b-y));
      }
    }
    if(b<a){
      t=b-y ;
      if(t>=n)return(b-n)*a ;
      else {
        long ans=y*(a-n+b-y);
        t=a-x ;
        if(t>=n)return Math.min(ans,b*(a-n));
        else return Math.min(ans,x*(b-n+a-x));
      }
    }
    return 0 ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      long a=sc.nextLong();
      long b=sc.nextLong();
      long x=sc.nextLong();
      long y=sc.nextLong();
      long n=sc.nextLong();
      System.out.println(solve(a,b,x,y,n));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation solve( a : long, b : long, x : long, y : long, n : long) : long
  pre: true
  post: true
  activity: (     var t : long ; t := a + b - x - y ;
     if (t <= n) then     return x * y else skip ; 
    if (a <= b) then (     t := a - x ; 
     if (t >= n) then     return (a - n) * b else (     var ans : long ; ans := x * (b - n + a - x) ;
     t := b - y ; 
     if (t >= n) then     return Set{ans, a * (b - n)}->min() else     return Set{ans, y * (a - n + b - y)}->min() ) ) else skip ; 
    if (b < a) then (     t := b - y ; 
     if (t >= n) then     return (b - n) * a else (     var ans : long ; ans := y * (a - n + b - y) ;
     t := a - x ; 
     if (t >= n) then     return Set{ans, b * (a - n)}->min() else     return Set{ans, x * (b - n + a - x)}->min() ) ) else skip ; 
    return 0 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
    var x : long ; x := sc.getCurrent()->toLong() ;
    var y : long ; y := sc.getCurrent()->toLong() ;
    var n : long ; n := sc.getCurrent()->toLong() ;
    OclFile["System.out"].println(solve(a, b, x, y, n)) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long a=sc.nextInt();
      long b=sc.nextInt();
      long x=sc.nextInt();
      long y=sc.nextInt();
      long n=sc.nextInt();
      long ans=(long)1e18 ;
      ans=Math.min(Math.max(a-n,x)*Math.max(b-(n-Math.min(n,a-x)),y),ans);
      ans=Math.min(Math.max(b-n,y)*Math.max(a-(n-Math.min(n,b-y)),x),ans);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : long ; a := sc.getCurrent()->toInteger() ;
     var b : long ; b := sc.getCurrent()->toInteger() ;
    var x : long ; x := sc.getCurrent()->toInteger() ;
    var y : long ; y := sc.getCurrent()->toInteger() ;
    var n : long ; n := sc.getCurrent()->toInteger() ;
    var ans : long ; ans := 1e18->oclAsType(long) ;
    ans := Set{Set{a - n, x}->max() * Set{b - (n - Set{n, a - x}->min()), y}->max(), ans}->min() ; 
    ans := Set{Set{b - n, y}->max() * Set{a - (n - Set{n, b - y}->min()), x}->max(), ans}->min() ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
import java.io.*;
public class codeHundredSixty {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      long a=input.nextLong();
      long b=input.nextLong();
      long x=input.nextLong();
      long y=input.nextLong();
      long n=input.nextLong();
      long mul=a*b ;
      long k1=Math.min(a-x,n);
      long m1=Math.min(n-k1,b-y);
      mul=Math.min(mul,(a-k1)*(b-m1));
      long tim=a ;
      a=b ;
      b=tim ;
      tim=x ;
      x=y ;
      y=tim ;
      long k2=Math.min(a-x,n);
      long m2=Math.min(n-k2,b-y);
      mul=Math.min(mul,(a-k2)*(b-m2));
      System.out.println(mul);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var a : long ; a := input.getCurrent()->toLong() ;
     var b : long ; b := input.getCurrent()->toLong() ;
    var x : long ; x := input.getCurrent()->toLong() ;
    var y : long ; y := input.getCurrent()->toLong() ;
    var n : long ; n := input.getCurrent()->toLong() ;
    var mul : long ; mul := a * b ;
    var k1 : long ; k1 := Set{a - x, n}->min() ;
    var m1 : long ; m1 := Set{n - k1, b - y}->min() ;
    mul := Set{mul, (a - k1) * (b - m1)}->min() ; 
    var tim : long ; tim := a ;
    a := b ; 
    b := tim ; 
    tim := x ; 
    x := y ; 
    y := tim ; 
    var k2 : long ; k2 := Set{a - x, n}->min() ;
    var m2 : long ; m2 := Set{n - k2, b - y}->min() ;
    mul := Set{mul, (a - k2) * (b - m2)}->min() ; 
    OclFile["System.out"].println(mul) ; 
 )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int TotalWays(int n,int s,int k){
    int[] dp=new int[n];
    dp[s-1]=1 ;
    for(int i=s ; i<n ; i++){
      int idx=Math.max(s-1,i-k);
      for(int j=idx ; j<i ; j++){
        dp[i]+=dp[j];
      }
    }
    return dp[n-1];
  }
  public static void main(String[] args){
    int n=5 ;
    int k=2 ;
    int s=2 ;
    System.out.print("Total Ways="+TotalWays(n,s,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation TotalWays( n : int, s : int, k : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
     dp[s - 1+1] := 1 ; 
         var i : int ; i := s ; while i < n do ( (     var idx : int ; idx := Set{s - 1, i - k}->max() ;
         var j : int ; j := idx ; while j < i do ( (     dp[i+1] := dp[i+1]+(dp[j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return dp[n - 1+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var k : int ; k := 2 ;
     var s : int ; s := 2 ;
     OclFile["System.out"].print("Total Ways=" + TotalWays(n, s, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int N=200 ;
  static int[] a=new int[N];
  static int[] b=new int[N];
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n,k ;
    n=in.nextInt();
    k=in.nextInt();
    int ans=(int)Double.NEGATIVE_INFINITY ;
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      for(int j=i ; j<n ; j++){
        ans=max(ans,solve(i,j,n,k));
      }
    }
    System.out.println(ans);
  }
  private static int max(int x,int y){
    if(x>y){
      return x ;
    }
    else {
      return y ;
    }
  }
  static int solve(int l,int r,int n,int k){
    int ans=0 ;
    b=a.clone();
    for(int i=l ; i<=r ; i++){
      ans+=a[i];
    }
    int p=0,q=0 ;
    int bmax,bmin ;
    for(int i=0 ; i<k ; i++){
      bmax=(int)Double.NEGATIVE_INFINITY ;
      bmin=(int)Double.POSITIVE_INFINITY ;
      for(int j=0 ; j<n ; j++){
        if((j<l || j>r)&& b[j]>bmax){
          bmax=b[j];
          p=j ;
        }
        else if((j>l && j<r)&& b[j]<bmin){
          bmin=b[j];
          q=j ;
        }
      }
      if(bmax<bmin){
        break ;
      }
      ans+=bmax-bmin ;
      int temp ;
      temp=b[p];
      b[p]=b[q];
      b[q]=temp ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int := 200;
  static   attribute a : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static   attribute b : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var k : int ;
    n := in.getCurrent()->toInteger() ; 
    k := in.getCurrent()->toInteger() ; 
    var ans : int ; ans := Math_NINFINITY->oclAsType(int) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i ; while j < n do ( (     ans := Set{ans, solve(i, j, n, k)}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation max( x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (x > y) then (     return x ) else (     return y ) );
  static   operation solve( l : int, r : int, n : int, k : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     b := a->copy() ; 
        var i : int ; i := l ; while i <= r do ( (     ans := ans+(a[i+1]) )  ;     i := i + 1 ) ; 
    var p : int ; p := 0 ;
    var q : int ; q := 0 ;
    var bmax : int ;
    var bmin : int ;
        var i : int ; i := 0 ; while i < k do ( (     bmax := Math_NINFINITY->oclAsType(int) ; 
     bmin := Math_PINFINITY->oclAsType(int) ; 
        var j : int ; j := 0 ; while j < n do ( (     if ((j < l or j > r) & b[j+1] > bmax) then (     bmax := b[j+1] ; 
     p := j ) else     if ((j > l & j < r) & b[j+1] < bmin) then (     bmin := b[j+1] ; 
     q := j ) else skip ; )  ;     j := j + 1 ) ; 
    if (bmax < bmin) then (     break ) else skip ; 
    ans := ans+(bmax - bmin) ; 
    var temp : int ;
    temp := b[p+1] ; 
    b[p+1] := b[q+1] ; 
    b[q+1] := temp ; 
 )  ;     i := i + 1 ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.NavigableSet ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class A425 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int K=in.nextInt();
    int[] A=new int[N];
    for(int n=0 ; n<N ; n++){
      A[n]=in.nextInt();
    }
    int answer=Integer.MIN_VALUE ;
    for(int L=0 ; L<N ; L++){
      for(int R=L ; R<N ; R++){
        int sum=0 ;
        List<Integer>outList=new ArrayList<>();
        List<Integer>inList=new ArrayList<>();
        for(int n=0 ; n<N ; n++){
          int a=A[n];
          if(L<=n && n<=R){
            inList.add(a);
            sum+=a ;
          }
          else {
            outList.add(a);
          }
        }
        Collections.sort(inList);
        Collections.sort(outList);
        int k=K ;
        int outIdx=outList.size()-1 ;
        int inIdx=0 ;
        while(k>0 && outIdx>=0 && inIdx<inList.size()){
          int big=outList.get(outIdx--);
          int small=inList.get(inIdx++);
          if(small<big){
            sum+=big ;
            sum-=small ;
            k--;
          }
          else {
            break ;
          }
        }
        answer=Math.max(answer,sum);
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A425 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var answer : int ; answer := -2147483648 ;
        var L : int ; L := 0 ; while L < N do ( (         var R : int ; R := L ; while R < N do ( (     var sum : int ; sum := 0 ;
     var outList : Sequence(int) ; outList := Sequence{} ;
    var inList : Sequence(int) ; inList := Sequence{} ;
        var n : int ; n := 0 ; while n < N do ( (     var a : int ; a := A[n+1] ;
     if (L <= n & n <= R) then (     inList := inList->including(a) ; 
     sum := sum+(a) ) else (     outList := outList->including(a) ) )  ;     n := n + 1 ) ; 
    inList := inList->sort() ; 
    outList := outList->sort() ; 
    var k : int ; k := K ;
    var outIdx : int ; outIdx := outList->size() - 1 ;
    var inIdx : int ; inIdx := 0 ;
    while (k > 0 & outIdx >= 0 & inIdx < inList->size()) do (     var big : int ; big := outList->at(outIdx+1) ;
     var small : int ; small := inList->at(inIdx+1) ;
     if (small < big) then (     sum := sum+(big) ; 
     sum := sum-(small) ; 
     k := k - 1 ) else (     break ) ) ; 
    answer := Set{answer, sum}->max() ; 
 )  ;     R := R + 1 ) )  ;     L := L + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  static int[] A ;
  static final int SENTINEL=Integer.MAX_VALUE ;
  static int count=0 ;
  static int[] L=new int[500000];
  static int[] R=new int[500000];
  static void merge(int l,int m,int r){
    int n1=m-l,n2=r-m ;
    for(int i=0 ; i<n1 ; i++)L[i]=A[l+i];
    for(int i=0 ; i<n2 ; i++)R[i]=A[m+i];
    L[n1]=SENTINEL ;
    R[n2]=SENTINEL ;
    int i=0,j=0 ;
    for(int k=l ; k<r ; k++){
      count++;
      if(L[i]<=R[j])A[k]=L[i++];
      else A[k]=R[j++];
    }
  }
  static void mergeSort(int l,int r){
    if(l+1<r){
      int m=(l+r)/2 ;
      mergeSort(l,m);
      mergeSort(m,r);
      merge(l,m,r);
    }
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    A=new int[n];
    String[] nums=br.readLine().trim().split("\\s+");
    for(int i=0 ; i<n ; i++)A[i]=Integer.parseInt(nums[i]);
    mergeSort(0,n);
    StringBuilder s=new StringBuilder().append(A[0]);
    for(int i=1 ; i<n ; i++)s.append(" ").append(A[i]);
    System.out.println(s);
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute A : Sequence(int);
  static    attribute SENTINEL : int := 2147483647;
  static   attribute count : int := 0;
  static   attribute L : Sequence(int) := Integer.subrange(1,500000)->collect(0);
  static   attribute R : Sequence(int) := Integer.subrange(1,500000)->collect(0);
  static   operation merge( l : int, m : int, r : int) : void
  pre: true
  post: true
  activity: (     var n1 : int ; n1 := m - l ;
    var n2 : int ; n2 := r - m ;
         var i : int ; i := 0 ; while i < n1 do (     L[i+1] := A[l + i+1] ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n2 do (     R[i+1] := A[m + i+1] ;  ;     i := i + 1 ) ; 
    L[n1+1] := SENTINEL ; 
    R[n2+1] := SENTINEL ; 
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
        var k : int ; k := l ; while k < r do ( (     count := count + 1 ; 
     if (L[i+1] <= R[j+1]) then      A[k+1] := L[i+1]  ; i := i + 1 ; else      A[k+1] := R[j+1]  ; j := j + 1 ; )  ;     k := k + 1 ) ; 
 );
  static   operation mergeSort( l : int, r : int) : void
  pre: true
  post: true
  activity: (     if (l + 1 < r) then (     var m : int ; m := (l + r) / 2 ;
     execute mergeSort(l, m) ; 
     execute mergeSort(m, r) ; 
     execute merge(l, m, r) ) else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    A := Integer.subrange(1,n)->collect(0) ; 
    var nums : Sequence(String) ; nums := br.readLine()->trim()->split("\\s+") ;
        var i : int ; i := 0 ; while i < n do (     A[i+1] := (nums[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    execute mergeSort(0, n) ; 
    var s : String ; s := StringLib.newString() + StringLib.newString(A[0+1]) ;
        var i : int ; i := 1 ; while i < n do (     s := s + StringLib.newString(" ") + StringLib.newString(A[i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void dfs(Vector<Integer>graph[],int node,int dist[],boolean vis[],int c){
    if(vis[node]){
      return ;
    }
    vis[node]=true ;
    dist[node]=c ;
    for(int i=0 ; i<graph[node] .size(); i++){
      if(! vis[graph[node] .get(i)]){
        dfs(graph,graph[node] .get(i),dist,vis,c+1);
      }
    }
  }
  static int countOfNodes(Vector<Integer>graph[],int n){
    boolean[] vis=new boolean[n+1];
    int[] dist=new int[n+1];
    dfs(graph,1,dist,vis,0);
    int even=0,odd=0 ;
    for(int i=1 ; i<=n ; i++){
      if(dist[i] % 2==0){
        even++;
      }
      else {
        odd++;
      }
    }
    int ans=((even*(even-1))+(odd*(odd-1)))/2 ;
    return ans ;
  }
  public static void main(String[] args){
    int n=5 ;
    Vector<Integer>[] graph=new Vector[n+1];
    for(int i=0 ; i<n+1 ; i++){
      graph[i]=new Vector<Integer>();
    }
    graph[0]=new Vector<Integer>();
    graph[1]=new Vector(Arrays.asList(2));
    graph[2]=new Vector<Integer>(1,3);
    graph[3]=new Vector<Integer>(2);
    int ans=countOfNodes(graph,n);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation dfs( graph : Sequence(Sequence(int)), node : int, dist : Sequence(int), vis : Sequence(boolean), c : int) : void
  pre: true
  post: true
  activity: (     if (vis[node+1]) then (     return ) else skip ; 
     vis[node+1] := true ; 
     dist[node+1] := c ; 
         var i : int ; i := 0 ; while i < graph[node+1]->size() do ( (     if (not(vis[graph[node+1]->at(i+1)+1])) then (     execute dfs(graph, graph[node+1]->at(i+1), dist, vis, c + 1) ) else skip )  ;     i := i + 1 ) );
  static   operation countOfNodes( graph : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     var vis : Sequence(boolean) ; vis := Integer.subrange(1,n + 1)->collect(false) ;
     var dist : Sequence(int) ; dist := Integer.subrange(1,n + 1)->collect(0) ;
    execute dfs(graph, 1, dist, vis, 0) ; 
    var even : int ; even := 0 ;
    var odd : int ; odd := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (dist[i+1] mod 2 = 0) then (     even := even + 1 ) else (     odd := odd + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := ((even * (even - 1)) + (odd * (odd - 1))) / 2 ;
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var graph : Sequence(Sequence(int)) ; graph := Integer.subrange(1,n + 1)->collect(null) ;
        var i : int ; i := 0 ; while i < n + 1 do ( (     graph[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
    graph[0+1] := Sequence{} ; 
    graph[1+1] := Sequence{}->union(2) ; 
    graph[2+1] := Sequence{} ; 
    graph[3+1] := Sequence{} ; 
    var ans : int ; ans := countOfNodes(graph, n) ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] arg){
    int n,l,lr,w,wr,sum ;
    final int[] srnk={
      60,80,100,120,140,160 },wrnk={
        2,5,10,15,20,25 },fee={
          600,800,1000,1200,1400,1600 };
          Scanner sc=new Scanner(System.in);
          while((n=sc.nextInt())!=0){
            sum=0 ;
            while(n-->0){
              l=sc.nextInt()+sc.nextInt()+sc.nextInt();
              w=sc.nextInt();
              lr=-1 ;
              for(int i=0 ; i<6 ; i++)if(l<=srnk[i]){
                lr=i ;
                break ;
              }
              if(lr==-1){
                continue ;
              }
              wr=-1 ;
              for(int i=0 ; i<6 ; i++)if(w<=wrnk[i]){
                wr=i ;
                break ;
              }
              if(wr==-1){
                continue ;
              }
              if(lr<wr){
                sum+=fee[wr];
              }
              else {
                sum+=fee[lr];
              }
            }
            System.out.println(sum);
          }
        }
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var l : int ;
    var lr : int ;
    var w : int ;
    var wr : int ;
    var sum : int ;
     var srnk : Sequence(int) ; srnk := Sequence{60,80,100,120,140,160} ;
    var wrnk : Sequence(int) ; wrnk := Sequence{2,5,10,15,20,25} ;
    var fee : Sequence(int) ; fee := Sequence{600,800,1000,1200,1400,1600} ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         n := sc.getCurrent()->toInteger() ;
    while ((n) /= 0) do (    skip ; (     sum := 0 ; 
         while (n > 0) do (        n := n - 1 ;     skip ; (     l := sc.getCurrent()->toInteger() + sc.getCurrent()->toInteger() + sc.getCurrent()->toInteger() ; 
     w := sc.getCurrent()->toInteger() ; 
    lr := -1 ; 
        var i : int ; i := 0 ; while i < 6 do (     if (l <= srnk[i+1]) then (     lr := i ; 
     break ) else skip ;  ;     i := i + 1 ) ; 
    if (lr = -1) then (     continue ) else skip ; 
    wr := -1 ; 
        var i : int ; i := 0 ; while i < 6 do (     if (w <= wrnk[i+1]) then (     wr := i ; 
     break ) else skip ;  ;     i := i + 1 ) ; 
    if (wr = -1) then (     continue ) else skip ; 
    if (lr < wr) then (     sum := sum+(fee[wr+1]) ) else (     sum := sum+(fee[lr+1]) ) ;  
 ) ;  ) ;  
     OclFile["System.out"].println(sum) ) ;     n := sc.getCurrent()->toInteger() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new A().doIt();
  }
  class A {
    int large[]={
      60,80,100,120,140,160 };
      int kgs[]={
        2,5,10,15,20,25 };
        int num[]={
          600,800,1000,1200,1400,1600 };
          int money(int kg,int xyz){
            int result=0 ;
            for(int i=large.length-1 ; i>=0 ; i--){
              if(kg<=kgs[i] && xyz<=large[i])result=num[i];
            }
            return result ;
          }
          void doIt(){
            while(true){
              int n=sc.nextInt();
              if(n==0)break ;
              int ans=0 ;
              for(int i=0 ; i<n ; i++){
                int x=sc.nextInt();
                int y=sc.nextInt();
                int z=sc.nextInt();
                int kg=sc.nextInt();
                int max=x+y+z ;
                ans=ans+money(kg,max);
              }
              System.out.println(ans);
            }
          }
        }
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     A.newA().doIt() );
 class A {
   attribute large : int := Sequence{60,80,100,120,140,160};
   attribute kgs : int := Sequence{2,5,10,15,20,25};
   attribute num : int := Sequence{600,800,1000,1200,1400,1600};
   operation money( kg : int, xyz : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := large->size() - 1 ; while i >= 0 do ( (     if (kg <= kgs[i+1] & xyz <= large[i+1]) then     result := num[i+1] ; else skip )  ;     i := i - 1 ) ; 
     return result );
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var z : int ; z := sc.getCurrent()->toInteger() ;
    var kg : int ; kg := sc.getCurrent()->toInteger() ;
    var max : int ; max := x + y + z ;
    ans := ans + money(kg, max) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static final char UNAVAILABLE='Z' ;
  private static final int[][] table={
    {
      60,2,600 },{
        80,5,800 },{
          100,10,1000 },{
            120,15,1200 },{
              140,20,1400 },{
                160,25,1600 }
              };
              public static void main(String[] args){
                Scanner sc=new Scanner(System.in);
                int numItem=0 ;
                while((numItem=sc.nextInt())!=0){
                  int fee=0 ;
                  int width,height,depth,weight ;
                  for(int i=0 ; i<numItem ; i++){
                    width=sc.nextInt();
                    height=sc.nextInt();
                    depth=sc.nextInt();
                    weight=sc.nextInt();
                    fee+=getFee(judgeSize(weight,width+height+depth));
                  }
                  System.out.println(fee);
                }
                sc.close();
              }
              public static int getFee(char size){
                return(size==UNAVAILABLE)? 0 : table[size-'A'][2];
              }
              public static char judgeSize(int weight,int length){
                char s1=judgeSizeByWeight(weight);
                char s2=judgeSizeByLength(length);
                return(char)Math.max(s1,s2);
              }
              private static char judgeSizeByWeight(int weight){
                if(weight<=2)return 'A' ;
                if(weight<=5)return 'B' ;
                if(weight<=10)return 'C' ;
                if(weight<=15)return 'D' ;
                if(weight<=20)return 'E' ;
                if(weight<=25)return 'F' ;
                return UNAVAILABLE ;
              }
              private static char judgeSizeByLength(int length){
                if(length<=60)return 'A' ;
                if(length<=80)return 'B' ;
                if(length<=100)return 'C' ;
                if(length<=120)return 'D' ;
                if(length<=140)return 'E' ;
                if(length<=160)return 'F' ;
                return UNAVAILABLE ;
              }
            }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute UNAVAILABLE : String := 'Z';
  static    attribute table : Sequence(Sequence(int)) := Sequence{Sequence{60,2,600},Sequence{80,5,800},Sequence{100,10,1000},Sequence{120,15,1200},Sequence{140,20,1400},Sequence{160,25,1600}};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numItem : int ; numItem := 0 ;
         numItem := sc.getCurrent()->toInteger() ;
    while ((numItem) /= 0) do (    skip ; (     var fee : int ; fee := 0 ;
     var width : int ;
    var height : int ;
    var depth : int ;
    var weight : int ;
         var i : int ; i := 0 ; while i < numItem do ( (     width := sc.getCurrent()->toInteger() ; 
     height := sc.getCurrent()->toInteger() ; 
    depth := sc.getCurrent()->toInteger() ; 
    weight := sc.getCurrent()->toInteger() ; 
    fee := fee+(getFee(judgeSize(weight, width + height + depth))) ; 
 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(fee) ) ;     numItem := sc.getCurrent()->toInteger() ;
 ) ;  
     skip );
  static   operation getFee( size : String) : int
  pre: true
  post: true
  activity: (     return if (size = UNAVAILABLE) then 0 else table[size - ('A')->char2byte()+1][2+1] endif );
  static   operation judgeSize( weight : int, length : int) : String
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := judgeSizeByWeight(weight) ;
     var s2 : String ; s2 := judgeSizeByLength(length) ;
     return Set{s1, s2}->max()->oclAsType(String) );
  static   operation judgeSizeByWeight( weight : int) : String
  pre: true
  post: true
  activity: (     if (weight <= 2) then     return 'A' else skip ; 
     if (weight <= 5) then     return 'B' else skip ; 
    if (weight <= 10) then     return 'C' else skip ; 
    if (weight <= 15) then     return 'D' else skip ; 
    if (weight <= 20) then     return 'E' else skip ; 
    if (weight <= 25) then     return 'F' else skip ; 
    return UNAVAILABLE 
 );
  static   operation judgeSizeByLength( length : int) : String
  pre: true
  post: true
  activity: (     if (length <= 60) then     return 'A' else skip ; 
     if (length <= 80) then     return 'B' else skip ; 
    if (length <= 100) then     return 'C' else skip ; 
    if (length <= 120) then     return 'D' else skip ; 
    if (length <= 140) then     return 'E' else skip ; 
    if (length <= 160) then     return 'F' else skip ; 
    return UNAVAILABLE 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int totalAmount=0 ;
  public static void solve(){
    int[] size={
      161,160,140,120,100,80,60 };
      int[] weight={
        26,25,20,15,10,5,2 };
        int[] fee={
          0,1600,1400,1200,1000,800,600 };
          int tempTotalAmount=fee[0];
          int vertical=sc.nextInt();
          int width=sc.nextInt();
          int height=sc.nextInt();
          int packWeight=sc.nextInt();
          int totalSize=vertical+width+height ;
          if(totalSize>=size[0] || packWeight>=weight[0]){
            return ;
          }
          for(int i=1 ; i<7 ; i++){
            if(totalSize<=size[i] && packWeight<=weight[i]){
              tempTotalAmount=fee[i];
            }
          }
          totalAmount+=tempTotalAmount ;
        }
        public static void main(String[] args){
          while(true){
            int totalPackage=sc.nextInt();
            if(totalPackage==0){
              break ;
            }
            int cnt=totalPackage ;
            while(cnt>0){
              solve();
              cnt-=1 ;
            }
            System.out.println(totalAmount);
            totalAmount=0 ;
          }
        }
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute totalAmount : int := 0;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var size : Sequence(int) ; size := Sequence{161,160,140,120,100,80,60} ;
     var weight : Sequence(int) ; weight := Sequence{26,25,20,15,10,5,2} ;
    var fee : Sequence(int) ; fee := Sequence{0,1600,1400,1200,1000,800,600} ;
    var tempTotalAmount : int ; tempTotalAmount := fee[0+1] ;
    var vertical : int ; vertical := sc.getCurrent()->toInteger() ;
    var width : int ; width := sc.getCurrent()->toInteger() ;
    var height : int ; height := sc.getCurrent()->toInteger() ;
    var packWeight : int ; packWeight := sc.getCurrent()->toInteger() ;
    var totalSize : int ; totalSize := vertical + width + height ;
    if (totalSize >= size[0+1] or packWeight >= weight[0+1]) then (     return ) else skip ; 
        var i : int ; i := 1 ; while i < 7 do ( (     if (totalSize <= size[i+1] & packWeight <= weight[i+1]) then (     tempTotalAmount := fee[i+1] ) else skip )  ;     i := i + 1 ) ; 
    totalAmount := totalAmount+(tempTotalAmount) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var totalPackage : int ; totalPackage := sc.getCurrent()->toInteger() ;
     if (totalPackage = 0) then (     break ) else skip ; 
    var cnt : int ; cnt := totalPackage ;
    while (cnt > 0) do (     execute solve() ; 
     cnt := cnt-(1) ) ; 
    OclFile["System.out"].println(totalAmount) ; 
    totalAmount := 0 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        int size=sc.nextInt()+sc.nextInt()+sc.nextInt();
        int w=sc.nextInt();
        int[] sizes={
          60,80,100,120,140,160 };
          int[] ws={
            2,5,10,15,20,25 };
            for(int k=0 ; k<6 ; k++){
              if(size<=sizes[k] && w<=ws[k]){
                sum+=600+k*200 ;
                break ;
              }
            }
          }
          println(""+sum);
        }
      }
      void debug(Object...os){
        System.err.println(Arrays.deepToString(os));
      }
      void print(String s){
        System.out.print(s);
      }
      void println(String s){
        System.out.println(s);
      }
      public static void main(String[] args){
        new Main().run();
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var size : int ; size := sc.getCurrent()->toInteger() + sc.getCurrent()->toInteger() + sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    var sizes : Sequence(int) ; sizes := Sequence{60,80,100,120,140,160} ;
    var ws : Sequence(int) ; ws := Sequence{2,5,10,15,20,25} ;
        var k : int ; k := 0 ; while k < 6 do ( (     if (size <= sizes[k+1] & w <= ws[k+1]) then (     sum := sum+(600 + k * 200) ; 
     break ) else skip )  ;     k := k + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    execute println("" + sum) ; 
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
class GFG {
  static int isMultipleOf3(int n){
    int odd_count=0 ;
    int even_count=0 ;
    if(n<0)n=-n ;
    if(n==0)return 1 ;
    if(n==1)return 0 ;
    while(n!=0){
      if((n & 1)!=0)odd_count++;
      if((n & 2)!=0)even_count++;
      n=n>>2 ;
    }
    return isMultipleOf3(Math.abs(odd_count-even_count));
  }
  public static void main(String[] args){
    int num=24 ;
    if(isMultipleOf3(num)!=0)System.out.println(num+" is multiple of 3");
    else System.out.println(num+" is not a multiple of 3");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isMultipleOf3( n : int) : int
  pre: true
  post: true
  activity: (     var odd_count : int ; odd_count := 0 ;
     var even_count : int ; even_count := 0 ;
    if (n < 0) then     n := -n ; else skip ; 
    if (n = 0) then     return 1 else skip ; 
    if (n = 1) then     return 0 else skip ; 
    while (n /= 0) do (     if ((n & 1) /= 0) then     odd_count := odd_count + 1 ; else skip ; 
     if ((n & 2) /= 0) then     even_count := even_count + 1 ; else skip ; 
     n := (n/(2->pow(2)))->oclAsType(long) ) ; 
    return isMultipleOf3(if odd_count - even_count < 0 then -(odd_count - even_count) else odd_count - even_count endif) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 24 ;
     if (isMultipleOf3(num) /= 0) then     OclFile["System.out"].println(num + " is multiple of 3") ; else     OclFile["System.out"].println(num + " is not a multiple of 3") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countEvenOdd(int n){
    int even_count=0 ;
    int odd_count=0 ;
    while(n>0){
      int rem=n % 10 ;
      if(rem % 2==0)even_count++;
      else odd_count++;
      n=n/10 ;
    }
    System.out.println("Even count : "+even_count);
    System.out.println("Odd count : "+odd_count);
    if(even_count % 2==0 && odd_count % 2!=0)return 1 ;
    else return 0 ;
  }
  public static void main(String[] args){
    int n ;
    n=2335453 ;
    int t=countEvenOdd(n);
    if(t==1)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countEvenOdd( n : int) : int
  pre: true
  post: true
  activity: (     var even_count : int ; even_count := 0 ;
     var odd_count : int ; odd_count := 0 ;
    while (n > 0) do (     var rem : int ; rem := n mod 10 ;
     if (rem mod 2 = 0) then     even_count := even_count + 1 else     odd_count := odd_count + 1 ; ;  
     n := n / 10 ) ; 
    OclFile["System.out"].println("Even count : " + even_count) ; 
    OclFile["System.out"].println("Odd count : " + odd_count) ; 
    if (even_count mod 2 = 0 & odd_count mod 2 /= 0) then     return 1 else     return 0 ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     n := 2335453 ; 
     var t : int ; t := countEvenOdd(n) ;
     if (t = 1) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Pair {
    int first,second ;
    public Pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static void lineFromPoints(Pair P,Pair Q){
    int a=Q.second-P.second ;
    int b=P.first-Q.first ;
    int c=a*(P.first)+b*(P.second);
    if(b<0){
      System.out.println("The line passing through points P and Q is: "+a+"x "+b+"y="+c);
    }
    else {
      System.out.println("The line passing through points P and Q is: "+a+"x+"+b+"y="+c);
    }
  }
  public static void main(String[] args){
    Pair P=new Pair(3,2);
    Pair Q=new Pair(2,6);
    lineFromPoints(P,Q);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Pair {
   attribute first : int;
   static operation newPair( first : int, second : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation lineFromPoints( P : Map, Q : Map) : void
  pre: true
  post: true
  activity: (     var a : int ; a := Q->at("second") - P->at("second") ;
     var b : int ; b := P->at("first") - Q->at("first") ;
     var c : int ; c := a * (P->at("first")) + b * (P->at("second")) ;
     if (b < 0) then (     OclFile["System.out"].println("The line passing through points P and Q is: " + a + "x " + b + "y=" + c) ) else (     OclFile["System.out"].println("The line passing through points P and Q is: " + a + "x+" + b + "y=" + c) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var P : Map ; P := Map(3, 2) ;
     var Q : Map ; Q := Map(2, 6) ;
     execute lineFromPoints(P, Q) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int calculateSum(int n){
    if(n<=0)return 0 ;
    int fibo[]=new int[n+1];
    fibo[0]=0 ;
    fibo[1]=1 ;
    int sum=fibo[0]+fibo[1];
    for(int i=2 ; i<=n ; i++){
      fibo[i]=fibo[i-1]+fibo[i-2];
      sum+=fibo[i];
    }
    return sum ;
  }
  public static void main(String args[]){
    int n=4 ;
    System.out.println("Sum of Fibonacci"+" numbers is : "+calculateSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculateSum( n : int) : int
  pre: true
  post: true
  activity: (     if (n <= 0) then     return 0 else skip ; 
     var fibo : Sequence(int) ; fibo := Integer.subrange(1,n + 1)->collect(0) ;
    fibo[0+1] := 0 ; 
    fibo[1+1] := 1 ; 
    var sum : int ; sum := fibo[0+1] + fibo[1+1] ;
        var i : int ; i := 2 ; while i <= n do ( (     fibo[i+1] := fibo[i - 1+1] + fibo[i - 2+1] ; 
     sum := sum+(fibo[i+1]) )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println("Sum of Fibonacci" + " numbers is : " + calculateSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int calculateSum(int n){
    int r1=2,r2=3 ;
    int a1=1,a2=1 ;
    return(int)(a1*(Math.pow(r1,n)-1)/(r1-1)+a2*(Math.pow(r2,n)-1)/(r2-1));
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println("Sum="+calculateSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation calculateSum( n : int) : int
  pre: true
  post: true
  activity: (     var r1 : int ; r1 := 2 ;
    var r2 : int ; r2 := 3 ;
     var a1 : int ; a1 := 1 ;
    var a2 : int ; a2 := 1 ;
     return (a1 * (r1->pow(n) - 1) / (r1 - 1) + a2 * (r2->pow(n) - 1) / (r2 - 1))->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println("Sum=" + calculateSum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class gfg {
  static int countMaxSetBits(int left,int right){
    int max_count=-1,num=0 ;
    for(int i=left ; i<=right ; ++i){
      int temp=i,cnt=0 ;
      while(temp>0){
        if(temp % 2==1)++cnt ;
        temp>>=1 ;
      }
      if(cnt>max_count){
        max_count=cnt ;
        num=i ;
      }
    }
    return num ;
  }
  public static void main(String[] args){
    int l=1,r=5 ;
    System.out.println(countMaxSetBits(l,r));
    l=1 ;
    r=10 ;
    System.out.print(countMaxSetBits(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class gfg {
  static   operation countMaxSetBits( left : int, right : int) : int
  pre: true
  post: true
  activity: (     var max_count : int ; max_count := -1 ;
    var num : int ; num := 0 ;
         var i : int ; i := left ; while i <= right do ( (     var temp : int ; temp := i ;
    var cnt : int ; cnt := 0 ;
     while (temp > 0) do (     if (temp mod 2 = 1) then     cnt := cnt + 1 ; else skip ; 
     temp := temp/(2->pow(1)) ) ; 
     if (cnt > max_count) then (     max_count := cnt ; 
     num := i ) else skip )  ;     i := i + 1 ) ; 
     return num );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 1 ;
    var r : int ; r := 5 ;
     OclFile["System.out"].println(countMaxSetBits(l, r)) ; 
    l := 1 ; 
    r := 10 ; 
    OclFile["System.out"].print(countMaxSetBits(l, r)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  private static int minJumps(int[] arr,int n){
    int jumps[]=new int[n];
    int i,j ;
    if(n==0 || arr[0]==0)return Integer.MAX_VALUE ;
    jumps[0]=0 ;
    for(i=1 ; i<n ; i++){
      jumps[i]=Integer.MAX_VALUE ;
      for(j=0 ; j<i ; j++){
        if(i<=j+arr[j] && jumps[j]!=Integer.MAX_VALUE){
          jumps[i]=Math.min(jumps[i],jumps[j]+1);
          break ;
        }
      }
    }
    return jumps[n-1];
  }
  public static void main(String[] args){
    int arr[]={
      1,3,6,1,0,9 };
      System.out.println("Minimum number of jumps to reach end is : "+minJumps(arr,arr.length));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minJumps( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var jumps : Sequence(int) ; jumps := Integer.subrange(1,n)->collect(0) ;
     var i : int ;
    var j : int ;
    if (n = 0 or arr[0+1] = 0) then     return 2147483647 else skip ; 
    jumps[0+1] := 0 ; 
        i := 1 ; while i < n do ( (     jumps[i+1] := 2147483647 ; 
         j := 0 ; while j < i do ( (     if (i <= j + arr[j+1] & jumps[j+1] /= 2147483647) then (     jumps[i+1] := Set{jumps[i+1], jumps[j+1] + 1}->min() ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return jumps[n - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,6,1,0,9} ;
     OclFile["System.out"].println("Minimum number of jumps to reach end is : " + minJumps(arr, arr->size())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minJumps(int arr[],int n){
    int[] jumps=new int[n];
    int min ;
    jumps[n-1]=0 ;
    for(int i=n-2 ; i>=0 ; i--){
      if(arr[i]==0)jumps[i]=Integer.MAX_VALUE ;
      else if(arr[i]>=n-i-1)jumps[i]=1 ;
      else {
        min=Integer.MAX_VALUE ;
        for(int j=i+1 ; j<n && j<=arr[i]+i ; j++){
          if(min>jumps[j])min=jumps[j];
        }
        if(min!=Integer.MAX_VALUE)jumps[i]=min+1 ;
        else jumps[i]=min ;
      }
    }
    return jumps[0];
  }
  public static void main(String[] args){
    int[] arr={
      1,3,6,1,0,9 };
      int size=arr.length ;
      System.out.println("Minimum number of"+" jumps to reach end is "+minJumps(arr,size));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minJumps( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var jumps : Sequence(int) ; jumps := Integer.subrange(1,n)->collect(0) ;
     var min : int ;
    jumps[n - 1+1] := 0 ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (arr[i+1] = 0) then     jumps[i+1] := 2147483647 ; else     if (arr[i+1] >= n - i - 1) then     jumps[i+1] := 1 else (     min := 2147483647 ; 
         var j : int ; j := i + 1 ; while j < n & j <= arr[i+1] + i do ( (     if (min > jumps[j+1]) then     min := jumps[j+1] ; else skip )  ;     j := j + 1 ) ; 
     if (min /= 2147483647) then     jumps[i+1] := min + 1 ; else     jumps[i+1] := min ; ) ;  )  ;     i := i - 1 ) ; 
    return jumps[0+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,6,1,0,9} ;
     var size : int ; size := arr->size() ;
     OclFile["System.out"].println("Minimum number of" + " jumps to reach end is " + minJumps(arr, size)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    try(Scanner sc=new Scanner(System.in)){
      int N=sc.nextInt();
      long S=sc.nextLong();
      long[] A=new long[N];
      for(int i=0 ; i<N ; i++){
        A[i]=sc.nextLong();
      }
      int i=0,j=0,ans=100000000 ;
      long sum=0 ;
      while(i<N){
        while(j<N && sum<S){
          sum+=A[j];
          j++;
        }
        if(sum>=S){
          ans=Math.min(j-i,ans);
        }
        sum-=A[i];
        i++;
      }
      if(ans==100000000){
        ans=0 ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var S : long ; S := sc.getCurrent()->toLong() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    var ans : int ; ans := 100000000 ;
    var sum : long ; sum := 0 ;
    while (i < N) do (     while (j < N & sum < S) do (     sum := sum+(A[j+1]) ; 
     j := j + 1 ) ; 
     if (sum >= S) then (     ans := Set{j - i, ans}->min() ) else skip ; 
     sum := sum-(A[i+1]) ; 
     i := i + 1 ) ; 
    if (ans = 100000000) then (     ans := 0 ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int S=in.nextInt();
    int a[]=new int[n+1];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    int p1=0,p2=0 ;
    int min=n+1 ;
    int prevSum=0 ;
    for(p1=0 ; p1<n ; p1++){
      int sum=prevSum ;
      while(sum<S){
        if(p2==n)break ;
        sum+=a[p2];
        p2++;
      }
      if(sum>=S){
        if(min>(p2-p1))min=p2-p1 ;
      }
      prevSum=sum-a[p1];
    }
    if(min==n+1)System.out.println(0);
    else System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var S : int ; S := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var p1 : int ; p1 := 0 ;
    var p2 : int ; p2 := 0 ;
    var min : int ; min := n + 1 ;
    var prevSum : int ; prevSum := 0 ;
        p1 := 0 ; while p1 < n do ( (     var sum : int ; sum := prevSum ;
     while (sum < S) do (     if (p2 = n) then     break else skip ; 
     sum := sum+(a[p2+1]) ; 
     p2 := p2 + 1 ) ; 
     if (sum >= S) then (     if (min > (p2 - p1)) then     min := p2 - p1 ; else skip ) else skip ; 
     prevSum := sum - a[p1+1] )  ;     p1 := p1 + 1 ) ; 
    if (min = n + 1) then     OclFile["System.out"].println(0) else     OclFile["System.out"].println(min) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int s=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    int right=0 ;
    int sum=arr[0];
    int min=Integer.MAX_VALUE ;
    for(int left=0 ; left<n ; left++){
      while(right<n && sum<s){
        right++;
        if(right>=n){
          break ;
        }
        sum+=arr[right];
      }
      if(right>=n){
        break ;
      }
      min=Math.min(min,right-left+1);
      sum-=arr[left];
    }
    if(min==Integer.MAX_VALUE){
      System.out.println(0);
    }
    else {
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var right : int ; right := 0 ;
    var sum : int ; sum := arr[0+1] ;
    var min : int ; min := 2147483647 ;
        var left : int ; left := 0 ; while left < n do ( (     while (right < n & sum < s) do (     right := right + 1 ; 
     if (right >= n) then (     break ) else skip ; 
     sum := sum+(arr[right+1]) ) ; 
     if (right >= n) then (     break ) else skip ; 
     min := Set{min, right - left + 1}->min() ; 
     sum := sum-(arr[left+1]) )  ;     left := left + 1 ) ; 
    if (min = 2147483647) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(min) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  @ SuppressWarnings("unchecked")private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int k=scanner.nextInt();
    List<Integer>[] lists=new ArrayList[10];
    for(int i=0 ; i<10 ; i++)lists[i]=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      int c=scanner.nextInt();
      int g=scanner.nextInt()-1 ;
      lists[g] .add(c);
    }
    int[] dp=new int[k+1];
    Arrays.fill(dp,-1);
    dp[0]=0 ;
    for(int i=0 ; i<10 ; i++){
      Collections.sort(lists[i],Collections.reverseOrder());
      ;
      for(int j=k-1 ; j>=0 ; j--){
        if(dp[j]==-1)continue ;
        int sum=0 ;
        for(int l=0 ; l<lists[i] .size()&& j+l<k ; l++){
          sum+=lists[i] .get(l);
          dp[j+l+1]=Math.max(dp[j+l+1],dp[j]+sum+(l+1)*l);
        }
      }
    }
    System.out.println(dp[k]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
      operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
    var lists : Sequence(Sequence(int)) ; lists := Integer.subrange(1,10)->collect(null) ;
        var i : int ; i := 0 ; while i < 10 do (     lists[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var c : int ; c := scanner.getCurrent()->toInteger() ;
     var g : int ; g := scanner.getCurrent()->toInteger() - 1 ;
     lists[g+1]->excludes(c) )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,k + 1)->collect(0) ;
    dp := dp->collect(-1) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < 10 do ( (     lists[i+1], reverseOrder() := lists[i+1], reverseOrder()->sort() ; 
         var j : int ; j := k - 1 ; while j >= 0 do ( (     if (dp[j+1] = -1) then     continue else skip ; 
     var sum : int ; sum := 0 ;
         var l : int ; l := 0 ; while l < lists[i+1]->size() & j + l < k do ( (     sum := sum+(lists[i+1]->at(l+1)) ; 
     dp[j + l + 1+1] := Set{dp[j + l + 1+1], dp[j+1] + sum + (l + 1) * l}->max() )  ;     l := l + 1 ) )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[k+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  static final int MOD=1_000_000_007 ;
  static final int INF=1_000_000_000 ;
  static final int MAX=10_000_000 ;
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int s=sc.nextInt();
    int[] ary=new int[n];
    int[] sum=new int[n];
    ary[0]=sc.nextInt();
    sum[0]=ary[0];
    for(int i=1 ; i<n ; i++){
      ary[i]=sc.nextInt();
      sum[i]=sum[i-1]+ary[i];
    }
    int poyo=0 ;
    int ans=MAX ;
    for(int i=0 ; i<n ; i++){
      if(sum[i]<s)continue ;
      for(int j=poyo ; j<n ; j++){
        poyo=j ;
        if(ans>i-j)ans=i-j ;
        if(sum[i]-sum[j]<s)break ;
      }
    }
    if(ans==MAX)ans=-1 ;
    System.out.println(ans+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1_000_000_007;
  static    attribute INF : int := 1_000_000_000;
  static    attribute MAX : int := 10_000_000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var ary : Sequence(int) ; ary := Integer.subrange(1,n)->collect(0) ;
    var sum : Sequence(int) ; sum := Integer.subrange(1,n)->collect(0) ;
    ary[0+1] := sc.getCurrent()->toInteger() ; 
    sum[0+1] := ary[0+1] ; 
        var i : int ; i := 1 ; while i < n do ( (     ary[i+1] := sc.getCurrent()->toInteger() ; 
     sum[i+1] := sum[i - 1+1] + ary[i+1] )  ;     i := i + 1 ) ; 
    var poyo : int ; poyo := 0 ;
    var ans : int ; ans := MAX ;
        var i : int ; i := 0 ; while i < n do ( (     if (sum[i+1] < s) then     continue else skip ; 
         var j : int ; j := poyo ; while j < n do ( (     poyo := j ; 
     if (ans > i - j) then     ans := i - j ; else skip ; 
     if (sum[i+1] - sum[j+1] < s) then     break else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (ans = MAX) then     ans := -1 ; else skip ; 
    OclFile["System.out"].println(ans + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int S=scan.nextInt();
    long[] a=new long[N];
    for(int i=0 ; i<N ; i++){
      a[i]=scan.nextLong();
    }
    scan.close();
    int min=Integer.MAX_VALUE ;
    long sum=0 ;
    int right=0 ;
    for(int left=0 ; left<N ; left++){
      while(right<N && sum+a[right]<S){
        sum+=a[right];
        right++;
      }
      if(right<N){
        if(sum+a[right]>=S){
          int l=right-left+1 ;
          min=Math.min(min,l);
        }
      }
      if(right==left){
        right++;
      }
      else {
        sum-=a[left];
      }
    }
    if(min==Integer.MAX_VALUE){
      System.out.println(0);
    }
    else {
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var S : int ; S := scan.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := scan.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    skip ; 
    var min : int ; min := 2147483647 ;
    var sum : long ; sum := 0 ;
    var right : int ; right := 0 ;
        var left : int ; left := 0 ; while left < N do ( (     while (right < N & sum + a[right+1] < S) do (     sum := sum+(a[right+1]) ; 
     right := right + 1 ) ; 
     if (right < N) then (     if (sum + a[right+1] >= S) then (     var l : int ; l := right - left + 1 ;
     min := Set{min, l}->min() ) else skip ) else skip ; 
     if (right = left) then (     right := right + 1 ) else (     sum := sum-(a[left+1]) ) )  ;     left := left + 1 ) ; 
    if (min = 2147483647) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(min) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class GabrielAndCaterpillar {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int h1=Integer.parseInt(str[0]);
    int h2=Integer.parseInt(str[1]);
    str=br.readLine().split(" ");
    int a=Integer.parseInt(str[0]);
    int b=Integer.parseInt(str[1]);
    int day=1 ;
    long l=h2-h1 ;
    l=l-(8*a);
    if(l<=0){
      System.out.print(0);
      return ;
    }
    l=l+(2*b);
    for(; ; day++){
      l=l+(10*b);
      l=l-(12*a);
      if(l<=0){
        System.out.print(day);
        return ;
      }
      l=l+(2*b);
      if(day==100004){
        System.out.println(-1);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GabrielAndCaterpillar {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var h1 : int ; h1 := (str[0+1])->toInteger() ;
    var h2 : int ; h2 := (str[1+1])->toInteger() ;
    str := br.readLine()->split(" ") ; 
    var a : int ; a := (str[0+1])->toInteger() ;
    var b : int ; b := (str[1+1])->toInteger() ;
    var day : int ; day := 1 ;
    var l : long ; l := h2 - h1 ;
    l := l - (8 * a) ; 
    if (l <= 0) then (     OclFile["System.out"].print(0) ; 
     return ) else skip ; 
    l := l + (2 * b) ; 
      while true do ( (     l := l + (10 * b) ; 
     l := l - (12 * a) ; 
    if (l <= 0) then (     OclFile["System.out"].print(day) ; 
     return ) else skip ; 
    l := l + (2 * b) ; 
    if (day = 100004) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
 )  ;     day := day + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class prog {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int h1=in.nextInt(),h2=in.nextInt(),a=in.nextInt(),b=in.nextInt(),ans=0 ;
    if(h1+a*8<h2 && a<=b){
      System.out.println(-1);
      return ;
    }
    else if(h1+a*8>=h2){
      System.out.println(0);
      return ;
    }
    h1+=a*8 ;
    while(h1<h2){
      h1+=12*(a-b);
      ans+=1 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class prog {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h1 : int ; h1 := in.getCurrent()->toInteger() ;
    var h2 : int ; h2 := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    if (h1 + a * 8 < h2 & a <= b) then (     OclFile["System.out"].println(-1) ; 
     return ) else     if (h1 + a * 8 >= h2) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; ;  
    h1 := h1+(a * 8) ; 
    while (h1 < h2) do (     h1 := h1+(12 * (a - b)) ; 
     ans := ans+(1) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int compare_count=0 ;
  public static void merge(int[] arr,int lo,int mid,int hi){
    int n_l=mid-lo+1 ;
    int n_r=hi-mid ;
    int[] L=new int[n_l+1];
    int[] R=new int[n_r+1];
    for(int i=0 ; i<n_l ; i++){
      L[i]=arr[lo+i];
    }
    for(int j=0 ; j<n_r ; j++){
      R[j]=arr[mid+j+1];
    }
    L[n_l]=Integer.MAX_VALUE ;
    R[n_r]=Integer.MAX_VALUE ;
    int i=lo ;
    int l_i=0,r_i=0 ;
    while(i<=hi){
      compare_count++;
      if(L[l_i]<R[r_i]){
        arr[i]=L[l_i];
        l_i++;
      }
      else {
        arr[i]=R[r_i];
        r_i++;
      }
      i++;
    }
    return ;
  }
  public static void merge_sort(int[] arr,int lo,int hi){
    if(lo==hi){
      return ;
    }
    int mid=(lo+hi)>>1 ;
    merge_sort(arr,lo,mid);
    merge_sort(arr,mid+1,hi);
    merge(arr,lo,mid,hi);
  }
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int n=cin.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=cin.nextInt();
    }
    merge_sort(arr,0,arr.length-1);
    for(int i=0 ; i<arr.length ; i++){
      System.out.print(arr[i]);
      if(i<arr.length-1){
        System.out.print(" ");
      }
      else {
        System.out.println();
      }
    }
    System.out.println(compare_count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute compare_count : int := 0;
  static   operation merge( arr : Sequence(int), lo : int, mid : int, hi : int) : void
  pre: true
  post: true
  activity: (     var n_l : int ; n_l := mid - lo + 1 ;
     var n_r : int ; n_r := hi - mid ;
    var L : Sequence(int) ; L := Integer.subrange(1,n_l + 1)->collect(0) ;
    var R : Sequence(int) ; R := Integer.subrange(1,n_r + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n_l do ( (     L[i+1] := arr[lo + i+1] )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < n_r do ( (     R[j+1] := arr[mid + j + 1+1] )  ;     j := j + 1 ) ; 
    L[n_l+1] := 2147483647 ; 
    R[n_r+1] := 2147483647 ; 
    var i : int ; i := lo ;
    var l_i : int ; l_i := 0 ;
    var r_i : int ; r_i := 0 ;
    while (i <= hi) do (     compare_count := compare_count + 1 ; 
     if (L[l_i+1] < R[r_i+1]) then (     arr[i+1] := L[l_i+1] ; 
     l_i := l_i + 1 ) else (     arr[i+1] := R[r_i+1] ; 
     r_i := r_i + 1 ) ;  
     i := i + 1 ) ; 
    return 
 );
  static   operation merge_sort( arr : Sequence(int), lo : int, hi : int) : void
  pre: true
  post: true
  activity: (     if (lo = hi) then (     return ) else skip ; 
     var mid : int ; mid := ((lo + hi)/(2->pow(1)))->oclAsType(long) ;
    execute merge_sort(arr, lo, mid) ; 
    execute merge_sort(arr, mid + 1, hi) ; 
    execute merge(arr, lo, mid, hi) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := cin.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := cin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute merge_sort(arr, 0, arr->size() - 1) ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (     OclFile["System.out"].print(arr[i+1]) ; 
     if (i < arr->size() - 1) then (     OclFile["System.out"].print(" ") ) else (     OclFile["System.out"].println() ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(compare_count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ProblemA {
  public int solve(int h1,int h2,int a,int b){
    h1+=8*a ;
    if(h1>=h2)return 0 ;
    if(a<=b)return-1 ;
    return(h2-h1+12*(a-b)-1)/12/(a-b);
  }
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int h1=sc.nextInt();
      int h2=sc.nextInt();
      int a=sc.nextInt();
      int b=sc.nextInt();
      System.out.println(new ProblemA().solve(h1,h2,a,b));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
   operation solve( h1 : int, h2 : int, a : int, b : int) : int
  pre: true
  post: true
  activity: (     h1 := h1+(8 * a) ; 
     if (h1 >= h2) then     return 0 else skip ; 
     if (a <= b) then     return -1 else skip ; 
     return (h2 - h1 + 12 * (a - b) - 1) / 12 / (a - b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var h1 : int ; h1 := sc.getCurrent()->toInteger() ;
     var h2 : int ; h2 := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(ProblemA.newProblemA().solve(h1, h2, a, b)) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Objects ;
public class D2A {
  public static void main(String args[])throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String line ;
      String[] tokens ;
      line=Objects.toString(br.readLine());
      tokens=line.split(" ");
      long h1=Long.parseLong(tokens[0]);
      long h2=Long.parseLong(tokens[1]);
      line=Objects.toString(br.readLine());
      tokens=line.split(" ");
      long a=Long.parseLong(tokens[0]);
      long b=Long.parseLong(tokens[1]);
      long h=h1 ;
      int n=100000 ;
      for(int i=0 ; i<=n ; i++){
        h+=a*(i==0 ? 8 : 12);
        if(h>=h2){
          System.out.println(i);
          return ;
        }
        h=h-b*12 ;
      }
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class D2A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var line : String ;
     var tokens : Sequence(String) ;
    line := Objects.toString(br.readLine()) ; 
    tokens := line->split(" ") ; 
    var h1 : long ; h1 := (tokens[0+1])->toLong() ;
    var h2 : long ; h2 := (tokens[1+1])->toLong() ;
    line := Objects.toString(br.readLine()) ; 
    tokens := line->split(" ") ; 
    var a : long ; a := (tokens[0+1])->toLong() ;
    var b : long ; b := (tokens[1+1])->toLong() ;
    var h : long ; h := h1 ;
    var n : int ; n := 100000 ;
        var i : int ; i := 0 ; while i <= n do ( (     h := h+(a * (if i = 0 then 8 else 12 endif)) ; 
     if (h >= h2) then (     OclFile["System.out"].println(i) ; 
     return ) else skip ; 
     h := h - b * 12 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.stream.Collectors ;
import java.util.stream.Stream ;
public class CodeForces {
  public static final int BUFFERSIZE=512000 ;
  private static Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in),BUFFERSIZE));
  private static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out,BUFFERSIZE));
  public static void solve()throws Exception {
    int h1=in.nextInt();
    int h2=in.nextInt();
    int u=in.nextInt();
    int d=in.nextInt();
    int initialClamp=8*u ;
    h1+=initialClamp ;
    if(d>=u){
      out.println(h1>=h2 ? 0 :-1);
      return ;
    }
    int days=0 ;
    while(h1<h2){
      h1-=12*d ;
      h1+=12*u ;
++days ;
    }
    out.println(days);
  }
  public static void main(String args[])throws Exception {
    in.init(System.in);
    solve();
    out.close();
  }
  public static class in {
    static BufferedReader reader ;
    static StringTokenizer tokenizer ;
    static void init(InputStream input){
      reader=new BufferedReader(new InputStreamReader(input),BUFFERSIZE);
      tokenizer=new StringTokenizer("");
    }
    static String next()throws IOException {
      while(! tokenizer.hasMoreTokens())tokenizer=new StringTokenizer(reader.readLine());
      return tokenizer.nextToken();
    }
    static int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    static double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    static long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static    attribute BUFFERSIZE : int := 512000;
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), BUFFERSIZE));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"], BUFFERSIZE));
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var h1 : int ; h1 := in.nextInt() ;
     var h2 : int ; h2 := in.nextInt() ;
    var u : int ; u := in.nextInt() ;
    var d : int ; d := in.nextInt() ;
    var initialClamp : int ; initialClamp := 8 * u ;
    h1 := h1+(initialClamp) ; 
    if (d >= u) then (     skip ; 
     return ) else skip ; 
    var days : int ; days := 0 ;
    while (h1 < h2) do (     h1 := h1-(12 * d) ; 
     h1 := h1+(12 * u) ; 
     days := days + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in.init(OclFile["System.in"]) ; 
     execute solve() ; 
     skip );
  static class in {
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   operation init( input : OclFile) : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(input), BUFFERSIZE) ; 
     tokenizer := OclIterator.newOclIterator_String("") );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ; ; 
     return tokenizer.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=1000001 ;
  static int countNum(int N,int K){
    int[] sumPF=new int[MAX];
    for(int i=2 ; i<N ; i++){
      if(sumPF[i]==0){
        for(int j=i ; j<N ; j+=i){
          sumPF[j]+=i ;
        }
      }
    }
    int count=0 ;
    for(int i=2 ; i<N ; i++){
      if(sumPF[i]==K)count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int N=20,K=7 ;
    System.out.println(countNum(N,K));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 1000001;
  static   operation countNum( N : int, K : int) : int
  pre: true
  post: true
  activity: (     var sumPF : Sequence(int) ; sumPF := Integer.subrange(1,MAX)->collect(0) ;
         var i : int ; i := 2 ; while i < N do ( (     if (sumPF[i+1] = 0) then (         var j : int ; j := i ; while j < N do ( (     sumPF[j+1] := sumPF[j+1]+(i) )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 2 ; while i < N do ( (     if (sumPF[i+1] = K) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 20 ;
    var K : int ; K := 7 ;
     OclFile["System.out"].println(countNum(N, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Pangram {
  public static void main(String[] args){
    boolean arr[]=new boolean[26];
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    sc.nextLine();
    String s=sc.nextLine().toLowerCase();
    int c=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)>=97 && s.charAt(i)<=122){
        if(! arr[s.charAt(i)-97]){
          arr[s.charAt(i)-97]=true ;
          c++;
        }
      }
    }
    if(c==26){
      System.out.println("YES");
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Pangram {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(boolean) ; arr := Integer.subrange(1,26)->collect(false) ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
    var s : String ; s := sc.nextLine()->toLowerCase() ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) >= 97 & s->at(i+1) <= 122) then (     if (not(arr[s->at(i+1) - 97+1])) then (     arr[s->at(i+1) - 97+1] := true ; 
     c := c + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (c = 26) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  @ SuppressWarnings("unchecked")private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    List<Integer>[] books=new List[10];
    for(int i=0 ; i<10 ; i++)books[i]=new ArrayList<Integer>();
    while(n-->0){
      int c=scanner.nextInt();
      int g=scanner.nextInt()-1 ;
      books[g] .add(c);
    }
    int[] dp=new int[m+1];
    Arrays.fill(dp,-1);
    dp[0]=0 ;
    for(int i=0 ; i<10 ; i++){
      Collections.sort(books[i],Collections.reverseOrder());
      for(int j=m-1 ; j>=0 ; j--){
        int sum=0 ;
        for(int k=0 ; k<books[i] .size()&& j+k<m ; k++){
          sum+=books[i] .get(k);
          dp[j+k+1]=Math.max(dp[j+k+1],dp[j]+sum+(k+1)*k);
        }
      }
    }
    System.out.println(dp[m]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
      operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var books : Sequence(Sequence(int)) ; books := Integer.subrange(1,10)->collect(null) ;
        var i : int ; i := 0 ; while i < 10 do (     books[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        while (n > 0) do (        n := n - 1 ;     skip ; (     var c : int ; c := scanner.getCurrent()->toInteger() ;
     var g : int ; g := scanner.getCurrent()->toInteger() - 1 ;
     books[g+1]->excludes(c) ) ;  ) ;  
    var dp : Sequence(int) ; dp := Integer.subrange(1,m + 1)->collect(0) ;
    dp := dp->collect(-1) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < 10 do ( (     books[i+1], reverseOrder() := books[i+1], reverseOrder()->sort() ; 
         var j : int ; j := m - 1 ; while j >= 0 do ( (     var sum : int ; sum := 0 ;
         var k : int ; k := 0 ; while k < books[i+1]->size() & j + k < m do ( (     sum := sum+(books[i+1]->at(k+1)) ; 
     dp[j + k + 1+1] := Set{dp[j + k + 1+1], dp[j+1] + sum + (k + 1) * k}->max() )  ;     k := k + 1 ) )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[m+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class JavaApplication38 {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    String s=input.next();
    Map<Character,Integer>check=new HashMap<Character,Integer>();
    if(s.length()<26){
      System.out.println("No");
    }
    else {
      s=s.toLowerCase();
      for(int i=0 ; i<s.length(); i++){
        check.put(s.charAt(i),0);
      }
      if(check.size()==26){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication38 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var s : String ; s := input.getCurrent() ;
    var check : Map(String,int) ; check := Map{} ;
    if (s->size() < 26) then (     OclFile["System.out"].println("No") ) else (     s := s->toLowerCase() ; 
         var i : int ; i := 0 ; while i < s->size() do ( (     check := check->union(Map{s->at(i+1) |-> 0}) )  ;     i := i + 1 ) ; 
     if (check.size() = 26) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.*;
public class Distinct {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String str=sc.next();
    String x=str.toLowerCase();
    int count=1 ;
    char charArray[]=x.toCharArray();
    Arrays.sort(charArray);
    String newStr=new String(charArray);
    for(int i=0 ; i<newStr.length()-1 ; i++){
      if(newStr.charAt(i)!=newStr.charAt(i+1)){
        count++;
      }
    }
    if(count<26){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Distinct {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var str : String ; str := sc.getCurrent() ;
    var x : String ; x := str->toLowerCase() ;
    var count : int ; count := 1 ;
    var charArray : Sequence(String) ; charArray := x->characters() ;
    charArray := charArray->sort() ; 
    var newStr : String ; newStr := StringLib.newString(charArray) ;
        var i : int ; i := 0 ; while i < newStr->size() - 1 do ( (     if (newStr->at(i+1) /= newStr->at(i + 1+1)) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (count < 26) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Pangram {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int num=in.nextByte();
    long str=in.next().toLowerCase().chars().distinct().count();
    if(str==26){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Pangram {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := in.nextByte() ;
     var str : long ; str := in.getCurrent()->toLowerCase().chars()->asOrderedSet()->size() ;
     if (str = 26) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static final int MAXN=4000000 ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int[] areas=new int[n];
    int left=MAXN,right=0,top=MAXN,bottom=0 ;
    for(int i=0 ; i<n ; i++){
      int x1,y1,x2,y2 ;
      x1=scanner.nextInt();
      y1=scanner.nextInt();
      x2=scanner.nextInt();
      y2=scanner.nextInt();
      areas[i]=(x2-x1)*(y2-y1);
      left=Math.min(x1,left);
      right=Math.max(x2,right);
      top=Math.min(y1,top);
      bottom=Math.max(y2,bottom);
    }
    int total=(right-left)*(bottom-top);
    int result=0 ;
    for(int i=0 ; i<n ; i++){
      result+=areas[i];
    }
    if((total==result)&&((right-left)==(bottom-top))){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAXN : int := 4000000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var areas : Sequence(int) ; areas := Integer.subrange(1,n)->collect(0) ;
    var left : int ; left := MAXN ;
    var right : int ; right := 0 ;
    var top : int ; top := MAXN ;
    var bottom : int ; bottom := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x1 : int ;
    var y1 : int ;
    var x2 : int ;
    var y2 : int ;
     x1 := scanner.getCurrent()->toInteger() ; 
    y1 := scanner.getCurrent()->toInteger() ; 
    x2 := scanner.getCurrent()->toInteger() ; 
    y2 := scanner.getCurrent()->toInteger() ; 
    areas[i+1] := (x2 - x1) * (y2 - y1) ; 
    left := Set{x1, left}->min() ; 
    right := Set{x2, right}->max() ; 
    top := Set{y1, top}->min() ; 
    bottom := Set{y2, bottom}->max() ; 
 )  ;     i := i + 1 ) ; 
    var total : int ; total := (right - left) * (bottom - top) ;
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     result := result+(areas[i+1]) )  ;     i := i + 1 ) ; 
    if ((total = result) & ((right - left) = (bottom - top))) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import com.oracle.jrockit.jfr.DataType ;
import java.io.*;
import java.util.*;
public class CF_325A {
  public static PrintWriter out ;
  public static class MyInputReader {
    BufferedReader br ;
    StringTokenizer st ;
    public MyInputReader(InputStream stream){
      br=new BufferedReader(new InputStreamReader(stream),32768);
    }
    String next(){
      while(st==null || ! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken().intern();
    }
    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.intern();
    }
  }
  public static void main(String[] args){
    MyInputReader in=new MyInputReader(System.in);
    out=new PrintWriter(new BufferedOutputStream(System.out));
    int n=in.nextInt();
    int minX=Integer.MAX_VALUE,minY=Integer.MAX_VALUE ;
    int maxX=Integer.MIN_VALUE,maxY=Integer.MIN_VALUE ;
    int x1,y1,x2,y2,area=0 ;
    while(n-->0){
      x1=in.nextInt();
      y1=in.nextInt();
      x2=in.nextInt();
      y2=in.nextInt();
      minX=Math.min(minX,x1);
      minY=Math.min(minY,y1);
      maxX=Math.max(maxX,x2);
      maxY=Math.max(maxY,y2);
      area+=((x2-x1)*(y2-y1));
    }
    int expectedArea=(maxX-minX)*(maxY-minY);
    if(area==expectedArea && maxX-minX==maxY-minY)System.out.println("YES");
    else System.out.println("NO");
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF_325A {
  static   attribute out : OclFile;
  static class MyInputReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyInputReader( stream : OclFile) : MyInputReader
  pre: true
  post: true
  activity:
  ( var self : MyInputReader ;
    self := createMyInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next()+"" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str+"" );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : MyInputReader ; in := MyInputReader.newMyInputReader(OclFile["System.in"]) ;
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var n : int ; n := in.nextInt() ;
    var minX : int ; minX := 2147483647 ;
    var minY : int ; minY := 2147483647 ;
    var maxX : int ; maxX := -2147483648 ;
    var maxY : int ; maxY := -2147483648 ;
    var x1 : int ;
    var y1 : int ;
    var x2 : int ;
    var y2 : int ;
    var area : int ; area := 0 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     x1 := in.nextInt() ; 
     y1 := in.nextInt() ; 
    x2 := in.nextInt() ; 
    y2 := in.nextInt() ; 
    minX := Set{minX, x1}->min() ; 
    minY := Set{minY, y1}->min() ; 
    maxX := Set{maxX, x2}->max() ; 
    maxY := Set{maxY, y2}->max() ; 
    area := area+(((x2 - x1) * (y2 - y1))) ; 
 ) ;  ) ;  
    var expectedArea : int ; expectedArea := (maxX - minX) * (maxY - minY) ;
    if (area = expectedArea & maxX - minX = maxY - minY) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static Scanner s=new Scanner(System.in);
  static int count=0 ;
  public static void main(String[] args){
    int n=s.nextInt();
    int[] a=new int[n];
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      a[i]=s.nextInt();
    }
    margeSort(a,0,n);
    for(int i=0 ; i<n-1 ; i++){
      sb=sb.append(a[i]+" ");
    }
    System.out.println(sb.toString()+a[n-1]);
    System.out.println(count);
  }
  public static void marge(int[] a,int l,int m,int r){
    int n1=m-l ;
    int n2=r-m ;
    int[] L=new int[n1+1];
    int[] R=new int[n2+1];
    for(int i=0 ; i<n1 ; i++){
      L[i]=a[l+i];
    }
    for(int i=0 ; i<n2 ; i++){
      R[i]=a[m+i];
    }
    L[n1]=1000000001 ;
    R[n2]=1000000001 ;
    int i=0,j=0 ;
    for(int k=l ; k<r ; k++){
      if(L[i]<=R[j] && L[i]!=1000000001){
        a[k]=L[i];
        i++;
        count++;
      }
      else {
        a[k]=R[j];
        j++;
        count++;
      }
    }
  }
  public static void margeSort(int[] a,int l,int r){
    int m ;
    if(l+1<r){
      m=(l+r)/2 ;
      margeSort(a,l,m);
      margeSort(a,m,r);
      marge(a,l,m,r);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute count : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute margeSort(a, 0, n) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     sb := sb + StringLib.newString(a[i+1] + " ") ;     sb := sb + StringLib.newString(a[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"" + a[n - 1+1]) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation marge( a : Sequence(int), l : int, m : int, r : int) : void
  pre: true
  post: true
  activity: (     var n1 : int ; n1 := m - l ;
     var n2 : int ; n2 := r - m ;
    var L : Sequence(int) ; L := Integer.subrange(1,n1 + 1)->collect(0) ;
    var R : Sequence(int) ; R := Integer.subrange(1,n2 + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n1 do ( (     L[i+1] := a[l + i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n2 do ( (     R[i+1] := a[m + i+1] )  ;     i := i + 1 ) ; 
    L[n1+1] := 1000000001 ; 
    R[n2+1] := 1000000001 ; 
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
        var k : int ; k := l ; while k < r do ( (     if (L[i+1] <= R[j+1] & L[i+1] /= 1000000001) then (     a[k+1] := L[i+1] ; 
     i := i + 1 ; 
     count := count + 1 ) else (     a[k+1] := R[j+1] ; 
     j := j + 1 ; 
     count := count + 1 ) )  ;     k := k + 1 ) ; 
 );
  static   operation margeSort( a : Sequence(int), l : int, r : int) : void
  pre: true
  post: true
  activity: (     var m : int ;
     if (l + 1 < r) then (     m := (l + r) / 2 ; 
     execute margeSort(a, l, m) ; 
     execute margeSort(a, m, r) ; 
     execute marge(a, l, m, r) ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n ;
    int x1,y1,x2,y2 ;
    while(in.hasNext()){
      int maxx=-1,minx=40000,maxy=-1,miny=40000 ;
      n=in.nextInt();
      long ans1,ans2=0 ;
      for(int i=0 ; i<n ; ++i){
        x1=in.nextInt();
        y1=in.nextInt();
        x2=in.nextInt();
        y2=in.nextInt();
        maxx=Math.max(x2,maxx);
        minx=Math.min(x1,minx);
        maxy=Math.max(y2,maxy);
        miny=Math.min(y1,miny);
        ans2+=Math.abs(x2-x1)*Math.abs(y2-y1);
      }
      ans1=Math.abs(maxx-minx)*Math.abs(maxy-miny);
      if(maxx-minx!=maxy-miny || ans1!=ans2)System.out.println("NO");
      else System.out.println("YES");
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var x1 : int ;
    var y1 : int ;
    var x2 : int ;
    var y2 : int ;
    while (in.hasNext()) do (     var maxx : int ; maxx := -1 ;
    var minx : int ; minx := 40000 ;
    var maxy : int ; maxy := -1 ;
    var miny : int ; miny := 40000 ;
     n := in.getCurrent()->toInteger() ; 
    var ans1 : long ;
    var ans2 : long ; ans2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x1 := in.getCurrent()->toInteger() ; 
     y1 := in.getCurrent()->toInteger() ; 
    x2 := in.getCurrent()->toInteger() ; 
    y2 := in.getCurrent()->toInteger() ; 
    maxx := Set{x2, maxx}->max() ; 
    minx := Set{x1, minx}->min() ; 
    maxy := Set{y2, maxy}->max() ; 
    miny := Set{y1, miny}->min() ; 
    ans2 := ans2+(if x2 - x1 < 0 then -(x2 - x1) else x2 - x1 endif * if y2 - y1 < 0 then -(y2 - y1) else y2 - y1 endif) ; 
 )  ;     i := i + 1 ) ; 
    ans1 := if maxx - minx < 0 then -(maxx - minx) else maxx - minx endif * if maxy - miny < 0 then -(maxy - miny) else maxy - miny endif ; 
    if (maxx - minx /= maxy - miny or ans1 /= ans2) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  
 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMaxProduct(int arr[],int n){
    int i ;
    int ans=Integer.MIN_VALUE ;
    int maxval=1 ;
    int minval=1 ;
    int prevMax ;
    for(i=0 ; i<n ; i++){
      if(arr[i]>0){
        maxval=maxval*arr[i];
        minval=Math.min(1,minval*arr[i]);
      }
      else if(arr[i]==0){
        minval=1 ;
        maxval=0 ;
      }
      else if(arr[i]<0){
        prevMax=maxval ;
        maxval=minval*arr[i];
        minval=prevMax*arr[i];
      }
      ans=Math.max(ans,maxval);
      if(maxval<=0){
        maxval=1 ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      0,-4,0,-2 };
      int n=arr.length ;
      System.out.println(findMaxProduct(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMaxProduct( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
     var ans : int ; ans := -2147483648 ;
    var maxval : int ; maxval := 1 ;
    var minval : int ; minval := 1 ;
    var prevMax : int ;
        i := 0 ; while i < n do ( (     if (arr[i+1] > 0) then (     maxval := maxval * arr[i+1] ; 
     minval := Set{1, minval * arr[i+1]}->min() ) else     if (arr[i+1] = 0) then (     minval := 1 ; 
     maxval := 0 ) else     if (arr[i+1] < 0) then (     prevMax := maxval ; 
     maxval := minval * arr[i+1] ; 
     minval := prevMax * arr[i+1] ) else skip ; ;  ;  
     ans := Set{ans, maxval}->max() ; 
     if (maxval <= 0) then (     maxval := 1 ) else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,-4,0,-2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMaxProduct(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    String[] commands=new String[n];
    scan.nextLine();
    for(int i=0 ; i<n ; i++){
      commands[i]=scan.nextLine();
    }
    printCommands(n,commands);
  }
  public static void printCommands(int n,String[] commands){
    StringBuilder sb=new StringBuilder();
    int and=1023 ;
    int or=0 ;
    int xor=0 ;
    for(String command : commands){
      char c=command.charAt(0);
      int val=Integer.parseInt(command.substring(2));
      if(c=='&'){
        and &=val ;
        or &=val ;
        xor &=val ;
      }
      else if(c=='|'){
        or |=val ;
        xor &=(~ val);
      }
      else {
        xor ^=val ;
      }
    }
    sb.append(3).append("\n");
    sb.append("& ").append(and).append("\n");
    sb.append("| ").append(or).append("\n");
    sb.append("^ ").append(xor).append("\n");
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var commands : Sequence(String) ; commands := Integer.subrange(1,n)->collect(null) ;
    skip ; 
        var i : int ; i := 0 ; while i < n do ( (     commands[i+1] := scan.nextLine() )  ;     i := i + 1 ) ; 
    execute printCommands(n, commands) ; 
 );
  static   operation printCommands( n : int, commands : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     var and : int ; and := 1023 ;
    var or : int ; or := 0 ;
    var xor : int ; xor := 0 ;
    for (command : commands) do ( (     var c : String ; c := command->at(0+1) ;
     var val : int ; val := (command.subrange(2+1,2))->toInteger() ;
     if (c = '&') then (     and := MathLib.bitwiseAnd(and, val) ; 
     or := MathLib.bitwiseAnd(or, val) ; 
     xor := MathLib.bitwiseAnd(xor, val) ) else     if (c = '|') then (     or := MathLib.bitwiseOr(or, val) ; 
     xor := MathLib.bitwiseAnd(xor, (-(val + 1))) ) else (     xor := MathLib.bitwiseXor(xor,val) ) ;  )  ) ; 
    sb := sb + StringLib.newString(3) + StringLib.newString("\n") ; 
    sb := sb + StringLib.newString("& ") + StringLib.newString(and) + StringLib.newString("\n") ; 
    sb := sb + StringLib.newString("| ") + StringLib.newString(or) + StringLib.newString("\n") ; 
    sb := sb + StringLib.newString("^ ") + StringLib.newString(xor) + StringLib.newString("\n") ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    int K=sc.nextInt();
    ArrayList<ArrayList<Integer>>p=new ArrayList<ArrayList<Integer>>();
    for(int i=0 ; i<10 ; ++i){
      p.add(new ArrayList<Integer>());
    }
    for(int i=0 ; i<N ; ++i){
      int C=sc.nextInt();
      int G=sc.nextInt()-1 ;
      p.get(G).add(C);
    }
    for(int i=0 ; i<10 ; ++i){
      Collections.sort(p.get(i));
      Collections.reverse(p.get(i));
    }
    int[][] dp=new int[11][K+1];
    for(int i=0 ; i<10 ; ++i){
      ArrayList<Integer>b=p.get(i);
      int sum=0 ;
      for(int j=0 ; j<=Math.min(b.size(),K); ++j){
        if(j!=0){
          sum+=b.get(j-1);
          sum+=2*(j-1);
        }
        for(int k=0 ; k+j<=K ; ++k){
          dp[i+1][k+j]=Math.max(dp[i+1][k+j],dp[i][k]+sum);
        }
      }
    }
    System.out.println(dp[10][K]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    var p : Sequence(Sequence(int)) ; p := Sequence{} ;
        var i : int ; i := 0 ; while i < 10 do ( (     p := p->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var C : int ; C := sc.getCurrent()->toInteger() ;
     var G : int ; G := sc.getCurrent()->toInteger() - 1 ;
     p->at(G+1)->excludes(C) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 10 do ( (     p->at(i+1) := p->at(i+1)->sort() ; 
     p->at(i+1) := p->at(i+1)->reverse() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,11)->collect(Integer.subrange(1,K + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < 10 do ( (     var b : Sequence(int) ; b := p->at(i+1) ;
     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j <= Set{b->size(), K}->min() do ( (     if (j /= 0) then (     sum := sum+(b->at(j - 1+1)) ; 
     sum := sum+(2 * (j - 1)) ) else skip ; 
         var k : int ; k := 0 ; while k + j <= K do ( (     dp[i + 1+1][k + j+1] := Set{dp[i + 1+1][k + j+1], dp[i+1][k+1] + sum}->max() )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[10+1][K+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int zero=0 ;
      int one=0 ;
      long sum=0 ;
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
        if(a[i]==0){
          zero++;
        }
        else {
          one++;
        }
      }
      long[] b=new long[n];
      for(int i=0 ; i<n ; i++){
        b[i]=sc.nextInt();
        sum+=b[i];
      }
      List<Long>list=new ArrayList<>();
      List<Long>list1=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        if(a[i]==0){
          list.add(b[i]);
        }
        else {
          list1.add(b[i]);
        }
      }
      Collections.sort(list,Collections.reverseOrder());
      Collections.sort(list1,Collections.reverseOrder());
      if(zero==one){
        sum*=2 ;
        sum-=Math.min(list.get(zero-1),list1.get(one-1));
        System.out.println(sum);
      }
      else {
        int mini=Math.min(zero,one);
        for(int i=0 ; i<mini ; i++){
          sum+=(list.get(i)+list1.get(i));
        }
        System.out.println(sum);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : long ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var zero : int ; zero := 0 ;
    var one : int ; one := 0 ;
    var sum : long ; sum := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (a[i+1] = 0) then (     zero := zero + 1 ) else (     one := one + 1 ) )  ;     i := i + 1 ) ; 
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(b[i+1]) )  ;     i := i + 1 ) ; 
    var list : Sequence(long) ; list := Sequence{} ;
    var list1 : Sequence(long) ; list1 := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = 0) then (     list := list->including(b[i+1]) ) else (     list1 := list1->including(b[i+1]) ) )  ;     i := i + 1 ) ; 
    list, reverseOrder() := list, reverseOrder()->sort() ; 
    list1, reverseOrder() := list1, reverseOrder()->sort() ; 
    if (zero = one) then (     sum := sum*(2) ; 
     sum := sum-(Set{list->at(zero - 1+1), list1->at(one - 1+1)}->min()) ; 
     OclFile["System.out"].println(sum) ) else (     var mini : int ; mini := Set{zero, one}->min() ;
         var i : int ; i := 0 ; while i < mini do ( (     sum := sum+((list->at(i+1) + list1->at(i+1))) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sum) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void print_sequence(int n,int k){
    int b=n/(k*(k+1)/2);
    if(b==0){
      System.out.println("-1");
    }
    else {
      int r=1 ;
      for(int x=1 ; x*x<=n ; x++){
        if(n % x!=0)continue ;
        if(x<=b && x>r)r=x ;
        if(n/x<=b && n/x>r)r=n/x ;
      }
      for(int i=1 ; i<k ; i++)System.out.print(r*i+" ");
      int res=n-(r*(k*(k-1)/2));
      System.out.println(res);
    }
  }
  public static void main(String[] args){
    int n=24 ;
    int k=4 ;
    print_sequence(n,k);
    n=24 ;
    k=5 ;
    print_sequence(n,k);
    n=6 ;
    k=4 ;
    print_sequence(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation print_sequence( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var b : int ; b := n / (k * (k + 1) / 2) ;
     if (b = 0) then (     OclFile["System.out"].println("-1") ) else (     var r : int ; r := 1 ;
         var x : int ; x := 1 ; while x * x <= n do ( (     if (n mod x /= 0) then     continue else skip ; 
     if (x <= b & x > r) then     r := x ; else skip ; 
     if (n / x <= b & n / x > r) then     r := n / x ; else skip )  ;     x := x + 1 ) ; 
        var i : int ; i := 1 ; while i < k do (     OclFile["System.out"].print(r * i + " ") ;  ;     i := i + 1 ) ; 
    var res : int ; res := n - (r * (k * (k - 1) / 2)) ;
    OclFile["System.out"].println(res) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 24 ;
     var k : int ; k := 4 ;
    execute print_sequence(n, k) ; 
    n := 24 ; 
    k := 5 ; 
    execute print_sequence(n, k) ; 
    n := 6 ; 
    k := 4 ; 
    execute print_sequence(n, k) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minOperations(int x,int y,int p,int q){
    if(y % x!=0)return-1 ;
    int d=y/x ;
    int a=0 ;
    while(d % p==0){
      d/=p ;
      a++;
    }
    int b=0 ;
    while(d % q==0){
      d/=q ;
      b++;
    }
    if(d!=1)return-1 ;
    return(a+b);
  }
  public static void main(String[] args){
    int x=12,y=2592,p=2,q=3 ;
    System.out.println(minOperations(x,y,p,q));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minOperations( x : int, y : int, p : int, q : int) : int
  pre: true
  post: true
  activity: (     if (y mod x /= 0) then     return -1 else skip ; 
     var d : int ; d := y / x ;
    var a : int ; a := 0 ;
    while (d mod p = 0) do (     d := d/(p) ; 
     a := a + 1 ) ; 
    var b : int ; b := 0 ;
    while (d mod q = 0) do (     d := d/(q) ; 
     b := b + 1 ) ; 
    if (d /= 1) then     return -1 else skip ; 
    return (a + b) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 12 ;
    var y : int ; y := 2592 ;
    var p : int ; p := 2 ;
    var q : int ; q := 3 ;
     OclFile["System.out"].println(minOperations(x, y, p, q)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] s=new int[n];
    int sum=0 ;
    int min=101 ;
    int min2=101 ;
    int check=0 ;
    for(int i=0 ; i<n ; i++){
      s[i]=sc.nextInt();
      if(min>s[i]){
        min=s[i];
      }
    }
    for(int i=0 ; i<n ; i++){
      sum+=s[i];
    }
    if(sum % 10!=0){
      System.out.println(sum);
    }
    else if(min % 10!=0){
      System.out.println(sum-min);
    }
    else {
      for(int i=0 ; i<n ; i++){
        if(min2>s[i] && s[i] % 10!=0){
          min2=s[i];
          check++;
        }
      }
      if(check==0){
        System.out.println(0);
      }
      else {
        System.out.println(sum-min2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
    var min : int ; min := 101 ;
    var min2 : int ; min2 := 101 ;
    var check : int ; check := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := sc.getCurrent()->toInteger() ; 
     if (min > s[i+1]) then (     min := s[i+1] ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(s[i+1]) )  ;     i := i + 1 ) ; 
    if (sum mod 10 /= 0) then (     OclFile["System.out"].println(sum) ) else     if (min mod 10 /= 0) then (     OclFile["System.out"].println(sum - min) ) else (         var i : int ; i := 0 ; while i < n do ( (     if (min2 > s[i+1] & s[i+1] mod 10 /= 0) then (     min2 := s[i+1] ; 
     check := check + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (check = 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(sum - min2) ) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.stream.IntStream ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CBugged solver=new CBugged();
    solver.solve(1,in,out);
    out.close();
  }
  static class CBugged {
    private static int ans=0 ;
    private static final boolean[][] dp=new boolean[10001][101];
    private static int[] s ;
    public void solve(int testNumber,Scanner in,PrintWriter out){
      s=IntStream.range(0,in.nextInt()).map(i->in.nextInt()).toArray();
      calc(0,0);
      out.println(ans);
    }
    private static void calc(int sum,int index){
      if(dp[sum][index]){
        return ;
      }
      dp[sum][index]=true ;
      if(index==s.length){
        if(sum % 10>0){
          ans=Math.max(ans,sum);
        }
        return ;
      }
      calc(sum,index+1);
      calc(sum+s[index],index+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CBugged ; solver := CBugged.newCBugged() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CBugged {
  static   attribute ans : int := 0;
  static    attribute dp : Sequence(Sequence(boolean)) := Integer.subrange(1,10001)->collect(Integer.subrange(1,101)->collect(false));
  static   attribute s : Sequence(int);
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     s := Integer.subrange(0, in.getCurrent()->toInteger()-1)->collect( _x1 | (lambda i : OclAny in in.getCurrent()->toInteger())->apply(_x1) )->asSequence() ; 
     execute calc(0, 0) ; 
     skip );
  static   operation calc( sum : int, index : int) : void
  pre: true
  post: true
  activity: (     if (dp[sum+1][index+1]) then (     return ) else skip ; 
     dp[sum+1][index+1] := true ; 
    if (index = s->size()) then (     if (sum mod 10 > 0) then (     ans := Set{ans, sum}->max() ) else skip ; 
     return ) else skip ; 
    execute calc(sum, index + 1) ; 
    execute calc(sum + s[index+1], index + 1) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=false ;
  private static PrintWriter _out=new PrintWriter(System.out);
  private static PrintWriter _err=new PrintWriter(System.err);
  private void solve(Scanner sc){
    int N=sc.nextInt();
    int[] s=new int[N];
    for(int i=0 ; i<N ; ++i){
      s[i]=sc.nextInt();
    }
    int sum=Arrays.stream(s).sum();
    if(sum % 10!=0){
      _out.println(sum);
    }
    else {
      Arrays.sort(s);
      for(int i=0 ; i<N ; ++i){
        if(s[i] % 10!=0){
          _out.println(sum-s[i]);
          return ;
        }
      }
      _out.println(0);
    }
  }
  private static BigInteger C(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    for(long i=r ; i>1 ; --i){
      res=res.divide(BigInteger.valueOf(i));
    }
    return res ;
  }
  private static BigInteger P(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    return res ;
  }
  public static void main(String[] args){
    long S=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    new Main().solve(sc);
    _out.flush();
    long G=System.currentTimeMillis();
    if(elapsed){
      _err.println((G-S)+"ms");
    }
    _err.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := false;
  static   attribute _out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute _err : OclFile := OclFile.newOclFile_Write(OclFile["System.err"]);
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.nextInt() ;
     var s : Sequence(int) ; s := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     s[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    var sum : int ; sum := stream(s)->sum() ;
    if (sum mod 10 /= 0) then (     skip ) else (     s := s->sort() ; 
         var i : int ; i := 0 ; while i < N do ( (     if (s[i+1] mod 10 /= 0) then (     skip ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     skip ) ;  
 );
  static   operation C( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
         var i : long ; i := r ; while i > 1 do ( (     res := res.divide((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation P( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    Main.newMain().solve(sc) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    for(int i=0 ; i<n ; i++){
      double xa=stdIn.nextDouble();
      double ya=stdIn.nextDouble();
      double ra=stdIn.nextDouble();
      double xb=stdIn.nextDouble();
      double yb=stdIn.nextDouble();
      double rb=stdIn.nextDouble();
      double distance=Math.sqrt(Math.pow(xa-xb,2)+Math.pow(ya-yb,2));
      if((ra+rb)<distance){
        System.out.println(0);
      }
      else if(Math.max(ra,rb)-Math.min(ra,rb)<=distance){
        System.out.println(1);
      }
      else if(ra<rb){
        System.out.println(-2);
      }
      else {
        System.out.println(2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var xa : double ; xa := stdIn.getCurrent()->toReal() ;
     var ya : double ; ya := stdIn.getCurrent()->toReal() ;
    var ra : double ; ra := stdIn.getCurrent()->toReal() ;
    var xb : double ; xb := stdIn.getCurrent()->toReal() ;
    var yb : double ; yb := stdIn.getCurrent()->toReal() ;
    var rb : double ; rb := stdIn.getCurrent()->toReal() ;
    var distance : double ; distance := (xa - xb->pow(2) + ya - yb->pow(2))->sqrt() ;
    if ((ra + rb) < distance) then (     OclFile["System.out"].println(0) ) else     if (Set{ra, rb}->max() - Set{ra, rb}->min() <= distance) then (     OclFile["System.out"].println(1) ) else     if (ra < rb) then (     OclFile["System.out"].println(-2) ) else (     OclFile["System.out"].println(2) ) ;  ;  ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    String str=input.readLine();
    int n=Integer.parseInt(str);
    ArrayList<Integer>list=new ArrayList();
    int sum=0 ;
    int temp ;
    for(int i=0 ; i<n ; i++){
      str=input.readLine();
      temp=Integer.parseInt(str);
      sum=sum+temp ;
      if(temp % 10!=0){
        list.add(temp);
      }
    }
    if(list.size()==0){
      sum=0 ;
    }
    else {
      Collections.sort(list);
      int j=0 ;
      while(sum % 10==0 && j<list.size()){
        sum=sum-list.get(j);
        j++;
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := input.readLine() ;
    var n : int ; n := (str)->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
    var sum : int ; sum := 0 ;
    var temp : int ;
        var i : int ; i := 0 ; while i < n do ( (     str := input.readLine() ; 
     temp := (str)->toInteger() ; 
     sum := sum + temp ; 
     if (temp mod 10 /= 0) then (     list := list->including(temp) ) else skip )  ;     i := i + 1 ) ; 
    if (list->size() = 0) then (     sum := 0 ) else (     list := list->sort() ; 
     var j : int ; j := 0 ;
     while (sum mod 10 = 0 & j < list->size()) do (     sum := sum - list->at(j+1) ; 
     j := j + 1 ) ) ;  
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    Solver solver=new Solver();
    solver.init();
    solver.readHead(in.readLine());
    for(; solver.hasNext(); ){
      solver.readBody(in.readLine());
    }
    solver.solve();
  }
}
class Solver {
  int N ;
  int cnt ;
  public void init(){
    N=0 ;
    cnt=0 ;
  }
  public void readHead(String str){
    String[] strArr=str.split(" ");
    N=Integer.parseInt(strArr[0]);
    Score=new int[N];
  }
  public boolean hasNext(){
    return cnt<N ;
  }
  int[] Score ;
  public void readBody(String str){
    Score[cnt]=Integer.parseInt(str);
    cnt++;
  }
  public void solve(){
    int sum=0 ;
    int min=101 ;
    for(int s : Score){
      sum+=s ;
      if(s % 10!=0 && s<min)min=s ;
    }
    if(sum % 10!=0)System.out.println(sum);
    else if(min>100)System.out.println(0);
    else System.out.println((sum-min));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var solver : Solver ; solver := Solver.newSolver() ;
    solver.init() ; 
    solver.readHead(in.readLine()) ; 
      while solver.hasNext() do ( (     solver.readBody(in.readLine()) )  ) ; 
    solver.solve() ; 
 );
}
class Solver {
   attribute N : int;
   attribute cnt : int;
   operation init() : void
  pre: true
  post: true
  activity: (     N := 0 ; 
     cnt := 0 );
   operation readHead( str : String) : void
  pre: true
  post: true
  activity: (     var strArr : Sequence(String) ; strArr := str->split(" ") ;
     N := (strArr[0+1])->toInteger() ; 
     Score := Integer.subrange(1,N)->collect(0) );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return cnt < N );
   attribute Score : Sequence(int);
   operation readBody( str : String) : void
  pre: true
  post: true
  activity: (     Score[cnt+1] := (str)->toInteger() ; 
     cnt := cnt + 1 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var min : int ; min := 101 ;
     for (s : Score) do ( (     sum := sum+(s) ; 
     if (s mod 10 /= 0 & s < min) then     min := s ; else skip )  ) ; 
     if (sum mod 10 /= 0) then     OclFile["System.out"].println(sum) ; else     if (min > 100) then     OclFile["System.out"].println(0) else     OclFile["System.out"].println((sum - min)) ; ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new AOJ0260().doIt();
  }
  class AOJ0260 {
    long n ;
    long[] p,j ;
    void solve(){
      Arrays.sort(j);
      long sum=0 ;
      long cnt=n ;
      for(int i=0 ; i<n ; i++)sum+=p[i];
      long max=sum*cnt ;
      for(int i=(int)n-2 ; i>=0 ; i--){
        sum=sum+j[i];
        cnt--;
        long calc=sum*cnt ;
        max=Math.max(max,calc);
      }
      System.out.println(max);
    }
    void doIt(){
      while(in.hasNext()){
        n=in.nextInt();
        if(n==0)break ;
        p=new long[(int)n];
        j=new long[(int)(n-1)];
        for(int i=0 ; i<n ; i++)p[i]=in.nextInt();
        for(int i=0 ; i<n-1 ; i++)j[i]=in.nextInt();
        solve();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     AOJ0260.newAOJ0260().doIt() );
 class AOJ0260 {
   attribute n : long;
   attribute p : Sequence(long);
   operation solve() : void
  pre: true
  post: true
  activity: (     j := j->sort() ; 
     var sum : long ; sum := 0 ;
    var cnt : long ; cnt := n ;
        var i : int ; i := 0 ; while i < n do (     sum := sum+(p[i+1]) ;  ;     i := i + 1 ) ; 
    var max : long ; max := sum * cnt ;
        var i : int ; i := n->oclAsType(int) - 2 ; while i >= 0 do ( (     sum := sum + j[i+1] ; 
     cnt := cnt - 1 ; 
     var calc : long ; calc := sum * cnt ;
     max := Set{max, calc}->max() )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (in.hasNext()) do (     n := in.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
    p := Integer.subrange(1,n->oclAsType(int))->collect(0) ; 
    j := Integer.subrange(1,(n - 1)->oclAsType(int))->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     p[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do (     j[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    execute solve() ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class Point {
    int x,y ;
    public Point(int x,int y){
      this.x=x ;
      this.y=y ;
    }
  };
  static int findmin(Point p[],int n){
    int a=0,b=0,c=0,d=0 ;
    for(int i=0 ; i<n ; i++){
      if(p[i] .x<=0)a++;
      else if(p[i] .x>=0)b++;
      if(p[i] .y>=0)c++;
      else if(p[i] .y<=0)d++;
    }
    return Math.min(Math.min(a,b),Math.min(c,d));
  }
  public static void main(String[] args){
    Point p[]={
      new Point(1,1),new Point(2,2),new Point(-1,-1),new Point(-2,2)};
      int n=p.length ;
      System.out.println(findmin(p,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Point {
   attribute x : int;
   static operation newPoint( x : int, y : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}
  static   operation findmin( p : Sequence(Point), n : int) : int
  pre: true
  post: true
  activity: (     var a : int ; a := 0 ;
    var b : int ; b := 0 ;
    var c : int ; c := 0 ;
    var d : int ; d := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (p[i+1].x <= 0) then     a := a + 1 else     if (p[i+1].x >= 0) then     b := b + 1 ; else skip ; ;  
     if (p[i+1].y >= 0) then     c := c + 1 ; else     if (p[i+1].y <= 0) then     d := d + 1 ; else skip ; )  ;     i := i + 1 ) ; 
     return Set{Set{a, b}->min(), Set{c, d}->min()}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : Sequence(Point) ; p := Sequence{Point.newPoint(1, 1),Point.newPoint(2, 2),Point.newPoint(-1, -1),Point.newPoint(-2, 2)} ;
     var n : int ; n := p->size() ;
     OclFile["System.out"].println(findmin(p, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      StringTokenizer input_n=new StringTokenizer(br.readLine());
      final int n=Integer.parseInt(input_n.nextToken());
      if(n==0){
        break ;
      }
      long sum=0 ;
      StringTokenizer input_p=new StringTokenizer(br.readLine());
      for(int i=0 ; i<n ; i++){
        sum+=Integer.parseInt(input_p.nextToken());
      }
      PriorityQueue<Integer>joint_queue=new PriorityQueue<Integer>(n-1,Collections.reverseOrder());
      StringTokenizer input_j=new StringTokenizer(br.readLine());
      for(int i=0 ; i<n-1 ; i++){
        joint_queue.add(Integer.parseInt(input_j.nextToken()));
      }
      long max=n*sum ;
      int cur_size=n ;
      while(! joint_queue.isEmpty()){
        int joint=joint_queue.poll();
        sum+=joint ;
        cur_size-=1 ;
        long cur=cur_size*sum ;
        if(max>cur){
          break ;
        }
        else {
          max=cur ;
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var input_n : OclIterator ; input_n := OclIterator.newOclIterator_String(br.readLine()) ;
     var n : int ; n := (input_n.next())->toInteger() ;
    if (n = 0) then (     break ) else skip ; 
    var sum : long ; sum := 0 ;
    var input_p : OclIterator ; input_p := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+((input_p.next())->toInteger()) )  ;     i := i + 1 ) ; 
    var joint_queue : Sequence(int) ; joint_queue := Sequence{} ;
    var input_j : OclIterator ; input_j := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     joint_queue := joint_queue->including((input_j.next())->toInteger()) )  ;     i := i + 1 ) ; 
    var max : long ; max := n * sum ;
    var cur_size : int ; cur_size := n ;
    while (not(joint_queue->isEmpty())) do (     var joint : int ; joint := joint_queue->min() ;
     sum := sum+(joint) ; 
    cur_size := cur_size-(1) ; 
    var cur : long ; cur := cur_size * sum ;
    if (max > cur) then (     break ) else (     max := cur ) ;  
 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class MyComp implements Comparator<Long>{
  public int compare(Long o1,Long o2){
    if(o1<o2){
      return 1 ;
    }
    else if(o1>o2){
      return-1 ;
    }
    return 0 ;
  }
}
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    Comparator<Long>c=new MyComp();
    PriorityQueue<Long>queJ=new PriorityQueue<Long>(11,c);
    while(true){
      int n=stdIn.nextInt();
      if(n==0){
        break ;
      }
      queJ.clear();
      Long sum=0L ;
      for(int i=0 ; i<n ; i++){
        sum+=stdIn.nextLong();
      }
      for(int i=0 ; i<n-1 ; i++){
        queJ.add(stdIn.nextLong());
      }
      Long max=0L ;
      for(int i=0 ; i<n ; i++){
        if(max<sum*(n-i)){
          max=sum*(n-i);
        }
        if(i<n-1){
          sum+=queJ.poll();
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyComp implements Function(<long>,(<long>,boolean)) {
   operation compare( o1 : long, o2 : long) : int
  pre: true
  post: true
  activity: (     if (o1 < o2) then (     return 1 ) else     if (o1 > o2) then (     return -1 ) else skip ; ;  
     return 0 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : Function(<long>,(<long>,boolean)) ; c := MyComp.newMyComp() ;
     var queJ : Sequence(long) ; queJ := Sequence{} ;
     while (true) do (     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    queJ := queJ->intersection(Set{}) ; 
    var sum : long ; sum := 0L ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(stdIn.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     queJ := queJ->including(stdIn.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    var max : long ; max := 0L ;
        var i : int ; i := 0 ; while i < n do ( (     if (max < sum * (n - i)) then (     max := sum * (n - i) ) else skip ; 
     if (i < n - 1) then (     sum := sum + queJ->min() ;     queJ := queJ->sort()->tail() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] q=new int[n-1];
      long sum=0 ;
      for(int i=0 ; i<n ; i++)sum+=sc.nextInt();
      for(int i=0 ; i<n-1 ; i++)q[i]=sc.nextInt();
      Arrays.sort(q);
      long res=sum*n ;
      for(int i=n-2 ; i>=0 ; i--){
        sum+=q[i];
        res=Math.max(res,sum*(i+1));
      }
      System.out.println(res);
    }
  }
  void debug(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var q : Sequence(int) ; q := Integer.subrange(1,n - 1)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (     sum := sum+(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do (     q[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    q := q->sort() ; 
    var res : long ; res := sum * n ;
        var i : int ; i := n - 2 ; while i >= 0 do ( (     sum := sum+(q[i+1]) ; 
     res := Set{res, sum * (i + 1)}->max() )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(res) ; 
 )  ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=parseInt(line);
      if(n==0)break ;
      long max=0 ;
      long len=0 ;
      int[] joint=new int[n-1];
      StringTokenizer st ;
      st=new StringTokenizer(br.readLine());
      for(int i=0 ; i<n ; i++){
        len+=parseInt(st.nextToken());
      }
      st=new StringTokenizer(br.readLine());
      for(int i=0 ; i<n-1 ; i++){
        joint[i]=parseInt(st.nextToken());
        len+=joint[i];
      }
      Arrays.sort(joint);
      max=len ;
      for(int i=0,j=2 ; i<n-1 ; i++,j++){
        len-=joint[i];
        max=Math.max(max,len*j);
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := parseInt(line) ;
     if (n = 0) then     break else skip ; 
    var max : long ; max := 0 ;
    var len : long ; len := 0 ;
    var joint : Sequence(int) ; joint := Integer.subrange(1,n - 1)->collect(0) ;
    var st : OclIterator ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     len := len+((st.next() + "")->toInteger()) )  ;     i := i + 1 ) ; 
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     joint[i+1] := (st.next() + "")->toInteger() ; 
     len := len+(joint[i+1]) )  ;     i := i + 1 ) ; 
    joint := joint->sort() ; 
    max := len ; 
        var i : int ; i := 0 ;
    var j : int ; j := 2 ; while i < n - 1 do ( (     len := len-(joint[i+1]) ; 
     max := Set{max, len * j}->max() )  ;     i := i + 1 ;     j := j + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double sum(double a,double b,double c,double d,double x){
    double ans=(x*(a+b)*(c-d))/((a*d)-(b*c));
    return ans ;
  }
  public static void main(String[] args){
    double a=1,b=2,c=9,d=13,x=5 ;
    System.out.println(sum(a,b,c,d,x));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sum( a : double, b : double, c : double, d : double, x : double) : double
  pre: true
  post: true
  activity: (     var ans : double ; ans := (x * (a + b) * (c - d)) / ((a * d) - (b * c)) ;
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 1 ;
    var b : double ; b := 2 ;
    var c : double ; c := 9 ;
    var d : double ; d := 13 ;
    var x : double ; x := 5 ;
     OclFile["System.out"].println(sum(a, b, c, d, x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class CodeTest {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n,nCount=0,eCount=0,dev ;
    double num[]=new double[1001];
    double res ;
    n=input.nextInt();
    if(n % 2==0)dev=(n/2);
    else dev=(n/2)+1 ;
    for(int i=0 ; i<n ; i++){
      num[i]=input.nextDouble();
      if(num[i]>0)eCount++;
      else if(num[i]<0)nCount++;
    }
    if(eCount>=dev){
      System.out.println(1);
    }
    else if(nCount>=dev){
      System.out.println(-1);
    }
    else System.out.println(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeTest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var nCount : int ; nCount := 0 ;
    var eCount : int ; eCount := 0 ;
    var dev : int ;
    var num : Sequence(double) ; num := Integer.subrange(1,1001)->collect(0.0) ;
    var res : double ;
    n := input.getCurrent()->toInteger() ; 
    if (n mod 2 = 0) then     dev := (n / 2) else     dev := (n / 2) + 1 ; ;  
        var i : int ; i := 0 ; while i < n do ( (     num[i+1] := input.getCurrent()->toReal() ; 
     if (num[i+1] > 0) then     eCount := eCount + 1 ; else     if (num[i+1] < 0) then     nCount := nCount + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    if (eCount >= dev) then (     OclFile["System.out"].println(1) ) else     if (nCount >= dev) then (     OclFile["System.out"].println(-1) ) else     OclFile["System.out"].println(0) ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Test {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int zeroCount=0,negCount=0,posCount=0 ;
      for(int i=0 ; i<n ; i++){
        int val=sc.nextInt();
        if(val<0)negCount+=1 ;
        else if(val==0)zeroCount+=1 ;
        else posCount+=1 ;
      }
      if(n % 2!=0)n+=1 ;
      if(posCount>=n/2)System.out.println("1");
      else if(negCount>=n/2)System.out.println("-1");
      else System.out.println("0");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var zeroCount : int ; zeroCount := 0 ;
    var negCount : int ; negCount := 0 ;
    var posCount : int ; posCount := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var val : int ; val := sc.getCurrent()->toInteger() ;
     if (val < 0) then     negCount := negCount+(1) ; else     if (val = 0) then     zeroCount := zeroCount+(1) else     posCount := posCount+(1) ; ;  )  ;     i := i + 1 ) ; 
    if (n mod 2 /= 0) then     n := n+(1) ; else skip ; 
    if (posCount >= n / 2) then     OclFile["System.out"].println("1") else     if (negCount >= n / 2) then     OclFile["System.out"].println("-1") else     OclFile["System.out"].println("0") ; ;  ;  
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static int X=0 ;
  public static int Y=1 ;
  public static int R=2 ;
  public static int A=0 ;
  public static int B=1 ;
  public static void main(String[] args){
    final Scanner stdin=new Scanner(System.in);
    final int T=stdin.nextInt();
    for(int t=0 ; t<T ; t++){
      final double[][] circles=new double[2][3];
      for(int i=0 ; i<2 ; i++){
        for(int j=0 ; j<3 ; j++){
          circles[i][j]=stdin.nextDouble();
        }
      }
      final double dx=circles[A][X]-circles[B][X];
      final double dy=circles[A][Y]-circles[B][Y];
      final double dist=Math.sqrt(dx*dx+dy*dy);
      if(circles[A][R]+circles[B][R]<dist){
        System.out.println(0);
      }
      else if(circles[A][R]>dist+circles[B][R]){
        System.out.println(2);
      }
      else if(circles[B][R]>dist+circles[A][R]){
        System.out.println(-2);
      }
      else {
        System.out.println(1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute X : int := 0;
  static   attribute Y : int := 1;
  static   attribute R : int := 2;
  static   attribute A : int := 0;
  static   attribute B : int := 1;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := stdin.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var circles : Sequence(Sequence(double)) ; circles := Integer.subrange(1,2)->collect(Integer.subrange(1,3)->collect(0.0)) ;
         var i : int ; i := 0 ; while i < 2 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     circles[i+1][j+1] := stdin.getCurrent()->toReal() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var dx : double ; dx := circles[A+1][X+1] - circles[B+1][X+1] ;
    var dy : double ; dy := circles[A+1][Y+1] - circles[B+1][Y+1] ;
    var dist : double ; dist := (dx * dx + dy * dy)->sqrt() ;
    if (circles[A+1][R+1] + circles[B+1][R+1] < dist) then (     OclFile["System.out"].println(0) ) else     if (circles[A+1][R+1] > dist + circles[B+1][R+1]) then (     OclFile["System.out"].println(2) ) else     if (circles[B+1][R+1] > dist + circles[A+1][R+1]) then (     OclFile["System.out"].println(-2) ) else (     OclFile["System.out"].println(1) ) ;  ;  ;  
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BePositive {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int pos=0,neg=0 ;
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      if(a<0)neg++;
      if(a>0)pos++;
    }
    if(n % 2!=0){
      if(neg<=n/2 && pos<=n/2)System.out.println(0);
      else {
        if(neg>n/2)System.out.println(-1);
        else System.out.println(1);
      }
    }
    if(n % 2==0){
      if(neg<n/2 && pos<n/2)System.out.println(0);
      else {
        if(neg>=n/2)System.out.println(-1);
        else System.out.println(1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BePositive {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var pos : int ; pos := 0 ;
    var neg : int ; neg := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (a < 0) then     neg := neg + 1 ; else skip ; 
     if (a > 0) then     pos := pos + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (n mod 2 /= 0) then (     if (neg <= n / 2 & pos <= n / 2) then     OclFile["System.out"].println(0) ; else (     if (neg > n / 2) then     OclFile["System.out"].println(-1) ; else     OclFile["System.out"].println(1) ; ) ) else skip ; 
    if (n mod 2 = 0) then (     if (neg < n / 2 & pos < n / 2) then     OclFile["System.out"].println(0) ; else (     if (neg >= n / 2) then     OclFile["System.out"].println(-1) ; else     OclFile["System.out"].println(1) ; ) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=10001 ;
  static void sieveOfEratosthenes(int[] s){
    boolean[] prime=new boolean[MAX+1];
    for(int i=2 ; i<=MAX ; i+=2)s[i]=2 ;
    for(int i=3 ; i<=MAX ; i+=2){
      if(prime[i]==false){
        s[i]=i ;
        for(int j=i ; j*i<=MAX ; j+=2){
          if(prime[i*j]==false){
            prime[i*j]=true ;
            s[i*j]=i ;
          }
        }
      }
    }
  }
  static int kPrimeFactor(int n,int k,int[] s){
    while(n>1){
      if(k==1)return s[n];
      k--;
      n/=s[n];
    }
    return-1 ;
  }
  public static void main(String[] args){
    int[] s=new int[MAX+1];
    sieveOfEratosthenes(s);
    int n=12,k=3 ;
    System.out.println(kPrimeFactor(n,k,s));
    n=14 ;
    k=3 ;
    System.out.println(kPrimeFactor(n,k,s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 10001;
  static   operation sieveOfEratosthenes( s : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,MAX + 1)->collect(false) ;
         var i : int ; i := 2 ; while i <= MAX do (     s[i+1] := 2 ;  ;     i := i+(2) ) ; 
         var i : int ; i := 3 ; while i <= MAX do ( (     if (prime[i+1] = false) then (     s[i+1] := i ; 
         var j : int ; j := i ; while j * i <= MAX do ( (     if (prime[i * j+1] = false) then (     prime[i * j+1] := true ; 
     s[i * j+1] := i ) else skip )  ;     j := j+(2) ) ) else skip )  ;     i := i+(2) ) );
  static   operation kPrimeFactor( n : int, k : int, s : Sequence(int)) : int
  pre: true
  post: true
  activity: (     while (n > 1) do (     if (k = 1) then     return s[n+1] else skip ; 
     k := k - 1 ; 
     n := n/(s[n+1]) ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Sequence(int) ; s := Integer.subrange(1,MAX + 1)->collect(0) ;
     execute sieveOfEratosthenes(s) ; 
    var n : int ; n := 12 ;
    var k : int ; k := 3 ;
    OclFile["System.out"].println(kPrimeFactor(n, k, s)) ; 
    n := 14 ; 
    k := 3 ; 
    OclFile["System.out"].println(kPrimeFactor(n, k, s)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Solution {
  static int maxGCD(int N,int P){
    int ans=1 ;
    Map<Integer,Integer>prime_factors=new HashMap<Integer,Integer>();
    for(int i=2 ; i*i<=P ; i++){
      while(P % i==0){
        if(prime_factors.get(i)==null)prime_factors.put(i,1);
        else prime_factors.put(i,(prime_factors.get(i)+1));
        P/=i ;
      }
    }
    if(P!=1)if(prime_factors.get(P)==null)prime_factors.put(P,1);
    else prime_factors.put(P,(prime_factors.get(P)+1));
    Set<Map.Entry<Integer,Integer>>st=prime_factors.entrySet();
    for(Map.Entry<Integer,Integer>me : st){
      ans*=Math.pow(me.getKey(),me.getValue()/N);
    }
    return ans ;
  }
  public static void main(String args[]){
    int N=3,P=24 ;
    System.out.println(maxGCD(N,P));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation maxGCD( N : int, P : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
     var prime_factors : Map(int,int) ; prime_factors := Map{} ;
        var i : int ; i := 2 ; while i * i <= P do ( (     while (P mod i = 0) do (     if (prime_factors->at(i) = null) then     prime_factors := prime_factors->union(Map{i |-> 1}) else     prime_factors := prime_factors->union(Map{i |-> (prime_factors->at(i) + 1)}) ; ;  
     P := P/(i) ) )  ;     i := i + 1 ) ; 
    if (P /= 1) then     if (prime_factors->at(P) = null) then     prime_factors := prime_factors->union(Map{P |-> 1}) else     prime_factors := prime_factors->union(Map{P |-> (prime_factors->at(P) + 1)}) ; ;  else skip ; 
    var st : Set(Map(int,int)) ; st := prime_factors->asSet() ;
    for (me : st) do ( (     ans := ans*(me.getKey()->pow(me.getValue() / N)) )  ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
    var P : int ; P := 24 ;
     OclFile["System.out"].println(maxGCD(N, P)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isPerfectSquare(int n){
    int sq=(int)Math.sqrt(n);
    return(n==sq*sq);
  }
  static int countPerfectDivisors(int n){
    int count=0 ;
    for(int i=1 ; i*i<=n ; ++i){
      if(n % i==0){
        if(isPerfectSquare(i))++count ;
        if(n/i!=i && isPerfectSquare(n/i))++count ;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int n=16 ;
    System.out.print("Total perfect "+"divisors of "+n);
    System.out.println("="+countPerfectDivisors(n));
    n=12 ;
    System.out.print("Total perfect "+"divisors of "+n);
    System.out.println("="+countPerfectDivisors(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPerfectSquare( n : int) : boolean
  pre: true
  post: true
  activity: (     var sq : int ; sq := (n)->sqrt()->oclAsType(int) ;
     return (n = sq * sq) );
  static   operation countPerfectDivisors( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     if (isPerfectSquare(i)) then     count := count + 1 ; else skip ; 
     if (n / i /= i & isPerfectSquare(n / i)) then     count := count + 1 ; else skip ) else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 16 ;
     OclFile["System.out"].print("Total perfect " + "divisors of " + n) ; 
    OclFile["System.out"].println("=" + countPerfectDivisors(n)) ; 
    n := 12 ; 
    OclFile["System.out"].print("Total perfect " + "divisors of " + n) ; 
    OclFile["System.out"].println("=" + countPerfectDivisors(n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int minMovesToSort(int arr[],int n){
    int moves=0 ;
    int i,mn=arr[n-1];
    for(i=n-2 ; i>=0 ; i--){
      if(arr[i]>mn)moves+=arr[i]-mn ;
      mn=arr[i];
    }
    return moves ;
  }
  public static void main(String[] args){
    int arr[]={
      3,5,2,8,4 };
      int n=arr.length ;
      System.out.println(minMovesToSort(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minMovesToSort( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var moves : int ; moves := 0 ;
     var i : int ;
    var mn : int ; mn := arr[n - 1+1] ;
         i := n - 2 ; while i >= 0 do ( (     if (arr[i+1] > mn) then     moves := moves+(arr[i+1] - mn) ; else skip ; 
     mn := arr[i+1] )  ;     i := i - 1 ) ; 
     return moves );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,5,2,8,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minMovesToSort(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static int reachTarget(int target){
    target=Math.abs(target);
    int sum=0,step=0 ;
    while(sum<target ||(sum-target)% 2!=0){
      step++;
      sum+=step ;
    }
    return step ;
  }
  public static void main(String args[]){
    int target=5 ;
    System.out.println(reachTarget(target));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation reachTarget( target : int) : int
  pre: true
  post: true
  activity: (     target := if target < 0 then -(target) else target endif ; 
     var sum : int ; sum := 0 ;
    var step : int ; step := 0 ;
     while (sum < target or (sum - target) mod 2 /= 0) do (     step := step + 1 ; 
     sum := sum+(step) ) ; 
     return step );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var target : int ; target := 5 ;
     OclFile["System.out"].println(reachTarget(target)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void solveEven(int n,int arr[],int b[]){
    int left=n-1 ;
    for(int i=0 ; i<(n/2); ++i){
      b[i]=arr[left];
      left=left-2 ;
      if(left<0)break ;
    }
    int right=0 ;
    for(int i=n/2 ; i<=n-1 ; ++i){
      b[i]=arr[right];
      right=right+2 ;
      if(right>n-2)break ;
    }
  }
  static void solveOdd(int n,int arr[],int b[]){
    int left=n-1 ;
    for(int i=0 ; i<(n/2)+1 ; ++i){
      b[i]=arr[left];
      left=left-2 ;
      if(left<0)break ;
    }
    int right=1 ;
    for(int i=(n/2)+1 ; i<=n-1 ; ++i){
      b[i]=arr[right];
      right=right+2 ;
      if(right>n-2)break ;
    }
  }
  static void solve(int n,int arr[]){
    int b[]=new int[n];
    if(n % 2==0)solveEven(n,arr,b);
    else solveOdd(n,arr,b);
    for(int i=0 ; i<=n-1 ; ++i){
      System.out.print(b[i]+" ");
    }
  }
  public static void main(String[] args){
    int[] arr={
      1,2,3,4 };
      int n=arr.length ;
      solve(n,arr);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solveEven( n : int, arr : Sequence(int), b : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var left : int ; left := n - 1 ;
         var i : int ; i := 0 ; while i < (n / 2) do ( (     b[i+1] := arr[left+1] ; 
     left := left - 2 ; 
     if (left < 0) then     break else skip )  ;     i := i + 1 ) ; 
     var right : int ; right := 0 ;
         var i : int ; i := n / 2 ; while i <= n - 1 do ( (     b[i+1] := arr[right+1] ; 
     right := right + 2 ; 
     if (right > n - 2) then     break else skip )  ;     i := i + 1 ) );
  static   operation solveOdd( n : int, arr : Sequence(int), b : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var left : int ; left := n - 1 ;
         var i : int ; i := 0 ; while i < (n / 2) + 1 do ( (     b[i+1] := arr[left+1] ; 
     left := left - 2 ; 
     if (left < 0) then     break else skip )  ;     i := i + 1 ) ; 
     var right : int ; right := 1 ;
         var i : int ; i := (n / 2) + 1 ; while i <= n - 1 do ( (     b[i+1] := arr[right+1] ; 
     right := right + 2 ; 
     if (right > n - 2) then     break else skip )  ;     i := i + 1 ) );
  static   operation solve( n : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
     if (n mod 2 = 0) then     execute solveEven(n, arr, b) else     execute solveOdd(n, arr, b) ; ;  
         var i : int ; i := 0 ; while i <= n - 1 do ( (     OclFile["System.out"].print(b[i+1] + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4} ;
     var n : int ; n := arr->size() ;
     execute solve(n, arr) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int[] s=new int[n];
      for(int i=0 ; i<s.length ; ++i){
        s[i]=sc.nextInt();
      }
      System.out.println(solve(s));
    }
    sc.close();
  }
  static int solve(int[] s){
    Set<Integer>set=Arrays.stream(s).boxed().collect(Collectors.toSet());
    for(int i=1 ; i<1024 ; ++i){
      int i_=i ;
      if(set.stream().map(x->x ^ i_).collect(Collectors.toSet()).equals(set)){
        return i ;
      }
    }
    return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < s->size() do ( (     s[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(solve(s)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( s : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var set : Set(int) ; set := stream(s).collect(Collectors.toSet()) ;
         var i : int ; i := 1 ; while i < 1024 do ( (     var i_ : int ; i_ := i ;
     if (set->collect( _x1 | (lambda x : OclAny in x xor i_)->apply(_x1) ).collect(Collectors.toSet()) = set) then (     return i ) else skip )  ;     i := i + 1 ) ; 
     return -1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class CF1362_D2_B {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    for(int i=0 ; i<t ; i++){
      solve(scanner);
    }
  }
  private static void solve(Scanner scanner){
    int n=scanner.nextInt();
    HashSet<Integer>set=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      set.add(scanner.nextInt());
    }
    for(int i=1 ; i<=1024 ; i++){
      boolean found=true ;
      for(int x : set){
        if(! set.contains(x ^ i)){
          found=false ;
          break ;
        }
      }
      if(found){
        System.out.println(i);
        return ;
      }
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF1362_D2_B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     execute solve(scanner) )  ;     i := i + 1 ) );
  static   operation solve( scanner : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     set := set->including(scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 1024 do ( (     var found : boolean ; found := true ;
     for (x : set) do ( (     if (not(set->includes(x xor i))) then (     found := false ; 
     break ) else skip )  ) ; 
     if (found) then (     OclFile["System.out"].println(i) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int tests=in.nextInt();
    while(tests-->0){
      int size=in.nextInt();
      Set<Integer>set=new HashSet<>(size);
      for(int j=0 ; j<size ; j++){
        set.add(in.nextInt());
      }
      solve(set);
    }
  }
  private static void solve(Set<Integer>set){
    for(int i=1 ; i<1024 ; i++){
      Set<Integer>check=new HashSet<>(set.size());
      for(int j : set){
        check.add(j ^ i);
      }
      if(check.equals(set)){
        System.out.println(i);
        return ;
      }
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tests : int ; tests := in.getCurrent()->toInteger() ;
         while (tests > 0) do (        tests := tests - 1 ;     skip ; (     var size : int ; size := in.getCurrent()->toInteger() ;
     var set : Set(int) ; set := Set{} ;
         var j : int ; j := 0 ; while j < size do ( (     set := set->including(in.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
     execute solve(set) ) ;  ) );
  static   operation solve( set : Set(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < 1024 do ( (     var check : Set(int) ; check := Set{}->union(set->size()) ;
     for (j : set) do ( (     check := check->including(MathLib.bitwiseXor(j,i)) )  ) ; 
     if (check = set) then (     OclFile["System.out"].println(i) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(-1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int findMaxGCD(int arr[],int n){
    int high=0 ;
    for(int i=0 ; i<n ; i++)high=Math.max(high,arr[i]);
    int count[]=new int[high+1];
    for(int i=0 ; i<n ; i++)count[arr[i] ]++;
    int counter=0 ;
    for(int i=high ; i>=1 ; i--){
      int j=i ;
      while(j<=high){
        if(count[j]>0)counter+=count[j];
        j+=i ;
        if(counter==2)return i ;
      }
      counter=0 ;
    }
    return 1 ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,4,8,8,12 };
      int n=arr.length ;
      System.out.println(findMaxGCD(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMaxGCD( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var high : int ; high := 0 ;
         var i : int ; i := 0 ; while i < n do (     high := Set{high, arr[i+1]}->max() ;  ;     i := i + 1 ) ; 
    var count : Sequence(int) ; count := Integer.subrange(1,high + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     count[arr[i+1]+1] := count[arr[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
    var counter : int ; counter := 0 ;
        var i : int ; i := high ; while i >= 1 do ( (     var j : int ; j := i ;
     while (j <= high) do (     if (count[j+1] > 0) then     counter := counter+(count[j+1]) ; else skip ; 
     j := j+(i) ; 
     if (counter = 2) then     return i else skip ) ; 
     counter := 0 )  ;     i := i - 1 ) ; 
    return 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,4,8,8,12} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMaxGCD(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    Main main=new Main();
    while((line=br.readLine())!=null){
      if(line.contains(" ")){
        String[] sp=line.split(" ");
        double[] dp=new double[6];
        for(int i=0 ; i<dp.length ; i++){
          dp[i]=Double.parseDouble(sp[i]);
        }
        Circle circle1=main.new Circle(dp[0],dp[1],dp[2]);
        Circle circle2=main.new Circle(dp[3],dp[4],dp[5]);
        System.out.println(circle1.getTopology(circle2));
      }
    }
  }
  public class Circle {
    public static final int TOPOLOGY_OUTER=2 ;
    public static final int TOPOLOGY_INNER=-2 ;
    public static final int TOPOLOGY_CROSS=1 ;
    public static final int TOPOLOGY_FARAWAY=0 ;
    private double x ;
    private double y ;
    private double r ;
    public Circle(double x,double y,double r){
      this.x=x ;
      this.y=y ;
      this.r=r ;
    }
    public double x(){
      return this.x ;
    }
    public double y(){
      return this.y ;
    }
    public double r(){
      return this.r ;
    }
    public int getTopology(Circle other){
      int retval=TOPOLOGY_FARAWAY ;
      double distance ;
      distance=Math.sqrt(Math.pow(x-other.x(),2)+Math.pow(y-other.y(),2));
      if(distance+other.r()<r)return TOPOLOGY_OUTER ;
      if(distance+r<other.r())return TOPOLOGY_INNER ;
      if(distance<=r+other.r())return TOPOLOGY_CROSS ;
      if(distance>r+other.r())return TOPOLOGY_FARAWAY ;
      return retval ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
     var main : Main ; main := Main.newMain() ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->includes(" ")) then (     var sp : Sequence(String) ; sp := line->split(" ") ;
     var dp : Sequence(double) ; dp := Integer.subrange(1,6)->collect(0.0) ;
        var i : int ; i := 0 ; while i < dp->size() do ( (     dp[i+1] := (sp[i+1])->toReal() )  ;     i := i + 1 ) ; 
    var circle1 : Circle ; circle1 := (main).newCircle(dp[0+1], dp[1+1], dp[2+1]) ;
    var circle2 : Circle ; circle2 := (main).newCircle(dp[3+1], dp[4+1], dp[5+1]) ;
    OclFile["System.out"].println(circle1.getTopology(circle2)) ; 
 ) else skip ) ;     line := br.readLine() ;
 ) );
 class Circle {
  static    attribute TOPOLOGY_OUTER : int := 2;
  static    attribute TOPOLOGY_INNER : int := -2;
  static    attribute TOPOLOGY_CROSS : int := 1;
  static    attribute TOPOLOGY_FARAWAY : int := 0;
   attribute x : double;
   attribute y : double;
   attribute r : double;
   static operation newCircle( x : double, y : double, r : double) : Circle
  pre: true
  post: true
  activity:
  ( var self : Circle ;
    self := createCircle();
    self.initialise(x, y,r);
    return self );
  operation initialise( x : double, y : double, r : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y ; 
     self.r := r );
   operation x() : double
  pre: true
  post: true
  activity: (     return self.x );
   operation y() : double
  pre: true
  post: true
  activity: (     return self.y );
   operation r() : double
  pre: true
  post: true
  activity: (     return self.r );
   operation getTopology( other : Circle) : int
  pre: true
  post: true
  activity: (     var retval : int ; retval := TOPOLOGY_FARAWAY ;
     var distance : double ;
    distance := (x - other.x()->pow(2) + y - other.y()->pow(2))->sqrt() ; 
    if (distance + other.r() < r) then     return TOPOLOGY_OUTER else skip ; 
    if (distance + r < other.r()) then     return TOPOLOGY_INNER else skip ; 
    if (distance <= r + other.r()) then     return TOPOLOGY_CROSS else skip ; 
    if (distance > r + other.r()) then     return TOPOLOGY_FARAWAY else skip ; 
    return retval 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    sc.close();
    int mod=998244353 ;
    long ans=1 ;
    int r=0 ;
    int g=0 ;
    int b=0 ;
    int rg=0 ;
    int gb=0 ;
    int br=0 ;
    for(int i=0 ; i<s.length(); i++){
      char ch=s.charAt(i);
      if(ch=='R'){
        if(gb>0){
          ans=ans*gb % mod ;
          gb--;
        }
        else if(g>0){
          ans=ans*g % mod ;
          g--;
          rg++;
        }
        else if(b>0){
          ans=ans*b % mod ;
          b--;
          br++;
        }
        else {
          r++;
        }
      }
      else if(ch=='G'){
        if(br>0){
          ans=ans*br % mod ;
          br--;
        }
        else if(b>0){
          ans=ans*b % mod ;
          b--;
          gb++;
        }
        else if(r>0){
          ans=ans*r % mod ;
          r--;
          rg++;
        }
        else {
          g++;
        }
      }
      else {
        if(rg>0){
          ans=ans*rg % mod ;
          rg--;
        }
        else if(r>0){
          ans=ans*r % mod ;
          r--;
          br++;
        }
        else if(g>0){
          ans=ans*g % mod ;
          g--;
          gb++;
        }
        else {
          b++;
        }
      }
    }
    long p=1 ;
    for(int i=2 ; i<=n ; i++){
      p=p*i % mod ;
    }
    System.out.println(ans*p % mod);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    skip ; 
    var mod : int ; mod := 998244353 ;
    var ans : long ; ans := 1 ;
    var r : int ; r := 0 ;
    var g : int ; g := 0 ;
    var b : int ; b := 0 ;
    var rg : int ; rg := 0 ;
    var gb : int ; gb := 0 ;
    var br : int ; br := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var ch : String ; ch := s->at(i+1) ;
     if (ch = 'R') then (     if (gb > 0) then (     ans := ans * gb mod mod ; 
     gb := gb - 1 ) else     if (g > 0) then (     ans := ans * g mod mod ; 
     g := g - 1 ; 
     rg := rg + 1 ) else     if (b > 0) then (     ans := ans * b mod mod ; 
     b := b - 1 ; 
     br := br + 1 ) else (     r := r + 1 ) ;  ;  ) else     if (ch = 'G') then (     if (br > 0) then (     ans := ans * br mod mod ; 
     br := br - 1 ) else     if (b > 0) then (     ans := ans * b mod mod ; 
     b := b - 1 ; 
     gb := gb + 1 ) else     if (r > 0) then (     ans := ans * r mod mod ; 
     r := r - 1 ; 
     rg := rg + 1 ) else (     g := g + 1 ) ;  ;  ) else (     if (rg > 0) then (     ans := ans * rg mod mod ; 
     rg := rg - 1 ) else     if (r > 0) then (     ans := ans * r mod mod ; 
     r := r - 1 ; 
     br := br + 1 ) else     if (g > 0) then (     ans := ans * g mod mod ; 
     g := g - 1 ; 
     gb := gb + 1 ) else (     b := b + 1 ) ;  ;  ) ;  )  ;     i := i + 1 ) ; 
    var p : long ; p := 1 ;
        var i : int ; i := 2 ; while i <= n do ( (     p := p * i mod mod )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans * p mod mod) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findCountOfPairs(int a,int b,int n){
    int ans=0 ;
    ans+=n*(a/n)*(b/n);
    ans+=(a/n)*(b % n);
    ans+=(a % n)*(b/n);
    ans+=((a % n)+(b % n))/n ;
    return ans ;
  }
  public static void main(String[] args){
    int a=5,b=13,n=3 ;
    System.out.println(findCountOfPairs(a,b,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findCountOfPairs( a : int, b : int, n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     ans := ans+(n * (a / n) * (b / n)) ; 
    ans := ans+((a / n) * (b mod n)) ; 
    ans := ans+((a mod n) * (b / n)) ; 
    ans := ans+(((a mod n) + (b mod n)) / n) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 5 ;
    var b : int ; b := 13 ;
    var n : int ; n := 3 ;
     OclFile["System.out"].println(findCountOfPairs(a, b, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Application {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    for(int i=0 ; i<n ; i++){
      int k=0 ;
      int a=scan.nextInt();
      int b=scan.nextInt();
      for(int j=0 ; j<a ; j++){
        k+=scan.nextInt();
      }
      if(b==k)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Application {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var k : int ; k := 0 ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
        var j : int ; j := 0 ; while j < a do ( (     k := k+(scan.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
    if (b = k) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final long mod=998244353 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] s=sc.next().toCharArray();
    int[] cat=new int[3*n];
    Arrays.fill(cat,-1);
    LinkedList<Character>st=new LinkedList<>();
    char wait=0 ;
    int op=0 ;
    for(int i=0 ; i<3*n ; i++){
      if(s[i]==wait){
        cat[i]=2 ;
        op--;
        if(op==0){
          wait=0 ;
        }
      }
      else if(st.isEmpty()|| st.peek()==s[i]){
        st.addFirst(s[i]);
        cat[i]=0 ;
      }
      else {
        char c=st.removeFirst();
        cat[i]=1 ;
        wait=wait(c,s[i]);
        op++;
      }
    }
    long[] dp=new long[3*n];
    int free=n,opened=0,middled=0 ;
    for(int i=0 ; i<3*n ; i++){
      if(cat[i]==0){
        dp[i]=free ;
        free--;
        opened++;
      }
      else if(cat[i]==1){
        dp[i]=opened ;
        opened--;
        middled++;
      }
      else {
        dp[i]=middled ;
        middled--;
      }
    }
    long res=1 ;
    for(long val : dp){
      res=(res*val)% mod ;
    }
    System.out.println(res);
  }
  static char wait(char a,char b){
    if(a>b){
      char aux=a ;
      a=b ;
      b=aux ;
    }
    if(a=='G' && b=='R')return 'B' ;
    if(a=='B' && b=='R')return 'G' ;
    else return 'R' ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute mod : long := 998244353;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var cat : Sequence(int) ; cat := Integer.subrange(1,3 * n)->collect(0) ;
    cat := cat->collect(-1) ; 
    var st : Sequence(String) ; st := Sequence{} ;
    var wait : String ; wait := 0 ;
    var op : int ; op := 0 ;
        var i : int ; i := 0 ; while i < 3 * n do ( (     if (s[i+1] = wait) then (     cat[i+1] := 2 ; 
     op := op - 1 ; 
     if (op = 0) then (     wait := 0 ) else skip ) else     if (st->isEmpty() or st->min() = s[i+1]) then (     st := st->prepend(s[i+1]) ; 
     cat[i+1] := 0 ) else (     var c : String ; c := st->first() ;
     cat[i+1] := 1 ; 
     wait := wait(c, s[i+1]) ; 
     op := op + 1 ) ;  )  ;     i := i + 1 ) ; 
    var dp : Sequence(long) ; dp := Integer.subrange(1,3 * n)->collect(0) ;
    var free : int ; free := n ;
    var opened : int ; opened := 0 ;
    var middled : int ; middled := 0 ;
        var i : int ; i := 0 ; while i < 3 * n do ( (     if (cat[i+1] = 0) then (     dp[i+1] := free ; 
     free := free - 1 ; 
     opened := opened + 1 ) else     if (cat[i+1] = 1) then (     dp[i+1] := opened ; 
     opened := opened - 1 ; 
     middled := middled + 1 ) else (     dp[i+1] := middled ; 
     middled := middled - 1 ) ;  )  ;     i := i + 1 ) ; 
    var res : long ; res := 1 ;
    for (val : dp) do ( (     res := (res * val) mod mod )  ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static   operation wait( a : String, b : String) : String
  pre: true
  post: true
  activity: (     if (a > b) then (     var aux : String ; aux := a ;
     a := b ; 
     b := aux ) else skip ; 
     if (a = 'G' & b = 'R') then     return 'B' else skip ; 
     if (a = 'B' & b = 'R') then     return 'G' else     return 'R' );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Grasshopper {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String s=scanner.next();
    int n=s.length(),f=0 ;
    int[] a ;
    a=new int[n];
    for(int i=0 ; i<n ; i++){
      char x=s.charAt(i);
      if(!(x=='A' || x=='E' || x=='Y' || x=='O' || x=='U' || x=='I'))a[f]++;
      else f++;
    }
    Arrays.sort(a);
    System.out.println(a[n-1]+1);
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Grasshopper {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scanner.getCurrent() ;
    var n : int ; n := s->size() ;
    var f : int ; f := 0 ;
    var a : Sequence(int) ;
    a := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : String ; x := s->at(i+1) ;
     if (not((x = 'A' or x = 'E' or x = 'Y' or x = 'O' or x = 'U' or x = 'I'))) then     a[f+1] := a[f+1] + 1 ; else     f := f + 1 ; )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    OclFile["System.out"].println(a[(n)->char2byte() - 1+1] + 1) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class B {
  public static Scanner scan=new Scanner(System.in);
  public static PrintWriter out=new PrintWriter(System.out);
  public static void solve(){
    char[] s=scan.next().toCharArray();
    int n=s.length ;
    int cnt=1 ;
    TreeSet<Integer>a=new TreeSet<Integer>();
    for(int i=0 ; i<n ; i++){
      if(s[i]=='A' || s[i]=='E' || s[i]=='I' || s[i]=='O' || s[i]=='U' || s[i]=='Y'){
        a.add(cnt);
        cnt=1 ;
      }
      else {
        cnt++;
      }
    }
    a.add(cnt);
    System.out.println(a.last());
  }
  public static void main(String[] args){
    solve();
    scan.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := scan.getCurrent()->characters() ;
     var n : int ; n := s->size() ;
    var cnt : int ; cnt := 1 ;
    var a : Set(int) ; a := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] = 'A' or s[i+1] = 'E' or s[i+1] = 'I' or s[i+1] = 'O' or s[i+1] = 'U' or s[i+1] = 'Y') then (     a := a->including(cnt) ; 
     cnt := 1 ) else (     cnt := cnt + 1 ) )  ;     i := i + 1 ) ; 
    a := a->including(cnt) ; 
    OclFile["System.out"].println(a->last()) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() ; 
     skip ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class GrasshopperStr {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next(),v="AEIOUY" ;
    in.close();
    int i,c=1,m=1 ;
    for(i=0 ; i<s.length(); i++){
      if(v.contains(s.substring(i,i+1))){
        m=Math.max(m,c);
        c=1 ;
      }
      else {
        c++;
      }
    }
    System.out.println(Math.max(m,c));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GrasshopperStr {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
    var v : String ; v := "AEIOUY" ;
    skip ; 
    var i : int ;
    var c : int ; c := 1 ;
    var m : int ; m := 1 ;
        i := 0 ; while i < s->size() do ( (     if (v->includes(s.subrange(i+1,i + 1))) then (     m := Set{m, c}->max() ; 
     c := 1 ) else (     c := c + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{m, c}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    String s=in.next();
    int min=1,c=1 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='A' || s.charAt(i)=='E' || s.charAt(i)=='I' || s.charAt(i)=='O' || s.charAt(i)=='U' || s.charAt(i)=='Y'){
        min=Math.max(c,min);
        c=1 ;
      }
      else {
        c++;
      }
    }
    int i1=s.lastIndexOf('A'),i2=s.lastIndexOf('E'),i3=s.lastIndexOf('I'),i4=s.lastIndexOf('O'),i5=s.lastIndexOf('U'),i6=s.lastIndexOf('Y');
    int max=Math.max(i1,Math.max(i2,Math.max(i3,Math.max(i4,Math.max(i5,i6)))));
    max=s.length()-max ;
    pw.println(Math.max(min,max));
    pw.close();
  }
  public static long solve(long n){
    return((n*n)+(2*n)+3);
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : String ; s := in.getCurrent() ;
    var min : int ; min := 1 ;
    var c : int ; c := 1 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'A' or s->at(i+1) = 'E' or s->at(i+1) = 'I' or s->at(i+1) = 'O' or s->at(i+1) = 'U' or s->at(i+1) = 'Y') then (     min := Set{c, min}->max() ; 
     c := 1 ) else (     c := c + 1 ) )  ;     i := i + 1 ) ; 
    var i1 : int ; i1 := s->lastIndexOf('A')-1 ;
    var i2 : int ; i2 := s->lastIndexOf('E')-1 ;
    var i3 : int ; i3 := s->lastIndexOf('I')-1 ;
    var i4 : int ; i4 := s->lastIndexOf('O')-1 ;
    var i5 : int ; i5 := s->lastIndexOf('U')-1 ;
    var i6 : int ; i6 := s->lastIndexOf('Y')-1 ;
    var max : int ; max := Set{i1, Set{i2, Set{i3, Set{i4, Set{i5, i6}->max()}->max()}->max()}->max()}->max() ;
    max := s->size() - max ; 
    skip ; 
    skip ; 
 );
  static   operation solve( n : long) : long
  pre: true
  post: true
  activity: (     return ((n * n) + (2 * n) + 3) );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String tmp=br.readLine();
      if(tmp==null){
        break ;
      }
      String[] tmpArray=tmp.split(",");
      int[] cards=new int[5];
      int[] appears=new int[13];
      for(int i=0 ; i<5 ; i++){
        cards[i]=Integer.parseInt(tmpArray[i]);
        appears[cards[i]-1]++;
      }
      Arrays.sort(cards);
      boolean fourcards=false ;
      boolean threecards=false ;
      int pair=0 ;
      for(int i=0 ; i<13 ; i++){
        if(appears[i]>=4){
          fourcards=true ;
          break ;
        }
        if(appears[i]==3){
          threecards=true ;
        }
        if(appears[i]==2){
          pair++;
        }
      }
      boolean straight=false ;
      if(cards[0]==1 && cards[1]==10 && cards[2]==11 && cards[3]==12 && cards[4]==13){
        straight=true ;
      }
      else {
        straight=true ;
        for(int j=1 ; j<5 ; j++){
          if(cards[j]!=cards[0]+j){
            straight=false ;
            break ;
          }
        }
      }
      if(fourcards){
        System.out.println("four card");
      }
      else if(threecards && pair==1){
        System.out.println("full house");
      }
      else if(straight){
        System.out.println("straight");
      }
      else if(threecards){
        System.out.println("three card");
      }
      else if(pair==2){
        System.out.println("two pair");
      }
      else if(pair==1){
        System.out.println("one pair");
      }
      else {
        System.out.println("null");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var tmp : String ; tmp := br.readLine() ;
     if (tmp = null) then (     break ) else skip ; 
    var tmpArray : Sequence(String) ; tmpArray := tmp->split(",") ;
    var cards : Sequence(int) ; cards := Integer.subrange(1,5)->collect(0) ;
    var appears : Sequence(int) ; appears := Integer.subrange(1,13)->collect(0) ;
        var i : int ; i := 0 ; while i < 5 do ( (     cards[i+1] := (tmpArray[i+1])->toInteger() ; 
     appears[cards[i+1] - 1+1] := appears[cards[i+1] - 1+1] + 1 )  ;     i := i + 1 ) ; 
    cards := cards->sort() ; 
    var fourcards : boolean ; fourcards := false ;
    var threecards : boolean ; threecards := false ;
    var pair : int ; pair := 0 ;
        var i : int ; i := 0 ; while i < 13 do ( (     if (appears[i+1] >= 4) then (     fourcards := true ; 
     break ) else skip ; 
     if (appears[i+1] = 3) then (     threecards := true ) else skip ; 
     if (appears[i+1] = 2) then (     pair := pair + 1 ) else skip )  ;     i := i + 1 ) ; 
    var straight : boolean ; straight := false ;
    if (cards[0+1] = 1 & cards[1+1] = 10 & cards[2+1] = 11 & cards[3+1] = 12 & cards[4+1] = 13) then (     straight := true ) else (     straight := true ; 
         var j : int ; j := 1 ; while j < 5 do ( (     if (cards[j+1] /= cards[0+1] + j) then (     straight := false ; 
     break ) else skip )  ;     j := j + 1 ) ) ;  
    if (fourcards) then (     OclFile["System.out"].println("four card") ) else     if (threecards & pair = 1) then (     OclFile["System.out"].println("full house") ) else     if (straight) then (     OclFile["System.out"].println("straight") ) else     if (threecards) then (     OclFile["System.out"].println("three card") ) else     if (pair = 2) then (     OclFile["System.out"].println("two pair") ) else     if (pair = 1) then (     OclFile["System.out"].println("one pair") ) else (     OclFile["System.out"].println("null") ) ;  ;  ;  ;  ;  ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  String check(String card){
    int one=card.indexOf("1");
    int two=card.indexOf("2");
    if(card.indexOf("4")!=-1)return "four card" ;
    else if(card.indexOf("3")!=-1){
      if(two!=-1)return "full house" ;
      else return "three card" ;
    }
    else if(two!=card.lastIndexOf("2"))return "two pair" ;
    else if(two!=-1)return "one pair" ;
    else {
      if(card.charAt(0)=='1' && card.charAt(9)=='1' && card.charAt(10)=='1' && card.charAt(11)=='1' && card.charAt(12)=='1')return "straight" ;
      for(int i=one+1 ; i<one+5 ; i++)if(card.charAt(one)!=card.charAt(i))return "null" ;
      return "straight" ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sc.useDelimiter("[\n,] ");
    Main m=new Main();
    int[] cards ;
    while(sc.hasNext()){
      String card="" ;
      cards=new int[13];
      for(int i=0 ; i<5 ; i++)cards[sc.nextInt()-1]++;
      for(int i=0 ; i<cards.length ; i++)card+=cards[i];
      String result=m.check(card);
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation check( card : String) : String
  pre: true
  post: true
  activity: (     var one : int ; one := card->indexOf("1")-1 ;
     var two : int ; two := card->indexOf("2")-1 ;
     if (card->indexOf("4")-1 /= -1) then     return "four card" else     if (card->indexOf("3")-1 /= -1) then (     if (two /= -1) then     return "full house" else     return "three card" ) else     if (two /= card->lastIndexOf("2")-1) then     return "two pair" else     if (two /= -1) then     return "one pair" else (     if (card->at(0+1) = '1' & card->at(9+1) = '1' & card->at(10+1) = '1' & card->at(11+1) = '1' & card->at(12+1) = '1') then     return "straight" else skip ; 
         var i : int ; i := one + 1 ; while i < one + 5 do (     if (card->at(one+1) /= card->at(i+1)) then     return "null" else skip ;  ;     i := i + 1 ) ; 
     return "straight" ) ;  ;  ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var m : Main ; m := Main.newMain() ;
    var cards : Sequence(int) ;
    while (sc.hasNext()) do (     var card : String ; card := "" ;
     cards := Integer.subrange(1,13)->collect(0) ; 
        var i : int ; i := 0 ; while i < 5 do (     cards[sc.getCurrent()->toInteger() - 1+1] := cards[sc.getCurrent()->toInteger() - 1+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < cards->size() do (     card := card+(cards[i+1]) ;  ;     i := i + 1 ) ; 
    var result : String ; result := m.check(card) ;
    OclFile["System.out"].println(result) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner scan=new Scanner(System.in);
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    while(scan.hasNext()){
      String[] cards=scan.next().split(",");
      int[] a=new int[5];
      for(int i=0 ; i<5 ; i++)a[i]=Integer.parseInt(cards[i]);
      Arrays.sort(a);
      if(pair(a).contains(4))out.println("four card");
      else if(pair(a).contains(3)&& pair(a).contains(2))out.println("full house");
      else if(a[4]-a[0]==4 ||(a[0]==1 && a[1]==10 && a[4]==13))out.println("straight");
      else if(pair(a).contains(3))out.println("three card");
      else if(pair(a).lastIndexOf(2)==1)out.println("two pair");
      else if(pair(a).contains(2))out.println("one pair");
      else out.println("null");
    }
    out.flush();
  }
  static ArrayList<Integer>pair(int[] a){
    ArrayList<Integer>list=new ArrayList<Integer>();
    for(int i=1 ; i<=13 ; i++){
      int tmp=0 ;
      for(int j=0 ; j<5 ; j++)if(a[j]==i)tmp++;
      if(tmp>=2)list.add(tmp);
    }
    return list ;
  }
  static int si(){
    return Integer.parseInt(scan.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (scan.hasNext()) do (     var cards : Sequence(String) ; cards := scan.getCurrent()->split(",") ;
     var a : Sequence(int) ; a := Integer.subrange(1,5)->collect(0) ;
        var i : int ; i := 0 ; while i < 5 do (     a[i+1] := (cards[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    if (pair(a)->includes(4)) then     skip else     if (pair(a)->includes(3) & pair(a)->includes(2)) then     skip else     if (a[4+1] - a[0+1] = 4 or (a[0+1] = 1 & a[1+1] = 10 & a[4+1] = 13)) then     skip else     if (pair(a)->includes(3)) then     skip else     if (pair(a)->lastIndexOf(2)-1 = 1) then     skip else     if (pair(a)->includes(2)) then     skip else     skip ; ;  ;  ;  ;  ;  ;  
 ) ; 
     skip );
  static   operation pair( a : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
         var i : int ; i := 1 ; while i <= 13 do ( (     var tmp : int ; tmp := 0 ;
         var j : int ; j := 0 ; while j < 5 do (     if (a[j+1] = i) then     tmp := tmp + 1 ; else skip ;  ;     j := j + 1 ) ; 
     if (tmp >= 2) then     list := list->including(tmp) ; else skip )  ;     i := i + 1 ) ; 
     return list );
  static   operation si() : int
  pre: true
  post: true
  activity: (     return (scan.getCurrent())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
import java.util.Arrays ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    while(true){
      String line=reader.readLine();
      if(line==null || line.isEmpty()){
        break ;
      }
      String[] values=line.split(",");
      int[] numbers=new int[5];
      int[] counts=new int[13];
      for(int i=0 ; i<5 ; i++){
        int number=Integer.parseInt(values[i]);
        numbers[i]=number ;
        counts[number-1]+=1 ;
      }
      String result=null ;
      Arrays.sort(counts);
      if(counts[12]==4){
        result="four card" ;
      }
      else if(counts[12]==3 && counts[11]==2){
        result="full house" ;
      }
      else {
        Arrays.sort(numbers);
        if(numbers[4]-numbers[0]==4 ||(numbers[0]==1 && numbers[1]+numbers[4]==23)){
          result="straight" ;
        }
        else if(counts[12]==3){
          result="three card" ;
        }
        else if(counts[11]==2){
          result="two pair" ;
        }
        else if(counts[12]==2){
          result="one pair" ;
        }
      }
      out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     while (true) do (     var line : String ; line := reader.readLine() ;
     if (line = null or line->isEmpty()) then (     break ) else skip ; 
    var values : Sequence(String) ; values := line->split(",") ;
    var numbers : Sequence(int) ; numbers := Integer.subrange(1,5)->collect(0) ;
    var counts : Sequence(int) ; counts := Integer.subrange(1,13)->collect(0) ;
        var i : int ; i := 0 ; while i < 5 do ( (     var number : int ; number := (values[i+1])->toInteger() ;
     numbers[i+1] := number ; 
     counts[number - 1+1] := counts[number - 1+1]+(1) )  ;     i := i + 1 ) ; 
    var result : String ; result := null ;
    counts := counts->sort() ; 
    if (counts[12+1] = 4) then (     result := "four card" ) else     if (counts[12+1] = 3 & counts[11+1] = 2) then (     result := "full house" ) else (     numbers := numbers->sort() ; 
     if (numbers[4+1] - numbers[0+1] = 4 or (numbers[0+1] = 1 & numbers[1+1] + numbers[4+1] = 23)) then (     result := "straight" ) else     if (counts[12+1] = 3) then (     result := "three card" ) else     if (counts[11+1] = 2) then (     result := "two pair" ) else     if (counts[12+1] = 2) then (     result := "one pair" ) else skip ; ;  ;  ) ;  ;  
    out.println(result) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
class Main {
  public static int circle_calc(ArrayList<Double>list){
    int res ;
    double xa,ya,ra,xb,yb,rb,d ;
    xa=list.get(0);
    ya=list.get(1);
    ra=list.get(2);
    xb=list.get(3);
    yb=list.get(4);
    rb=list.get(5);
    d=(xb-xa)*(xb-xa)+(yb-ya)*(yb-ya);
    d=Math.sqrt(d);
    if(d<Math.abs(ra-rb)){
      if(ra>rb)res=2 ;
      else res=-2 ;
    }
    else if(d>ra+rb)res=0 ;
    else res=1 ;
    return res ;
  }
  public static void main(String args[])throws IOException {
    String str ;
    ArrayList<Double>inp=new ArrayList<Double>();
    int out ;
    Scanner scan=new Scanner(System.in);
    str=scan.next();
    while(scan.hasNext()){
      inp.clear();
      for(int i=0 ; i<6 ; i++){
        str=scan.next();
        double x=Double.parseDouble(str);
        inp.add(x);
      }
      out=circle_calc(inp);
      System.out.println(out);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation circle_calc( list : Sequence(double)) : int
  pre: true
  post: true
  activity: (     var res : int ;
     var xa : double ;
    var ya : double ;
    var ra : double ;
    var xb : double ;
    var yb : double ;
    var rb : double ;
    var d : double ;
    xa := list->at(0+1) ; 
    ya := list->at(1+1) ; 
    ra := list->at(2+1) ; 
    xb := list->at(3+1) ; 
    yb := list->at(4+1) ; 
    rb := list->at(5+1) ; 
    d := (xb - xa) * (xb - xa) + (yb - ya) * (yb - ya) ; 
    d := (d)->sqrt() ; 
    if (d < if ra - rb < 0 then -(ra - rb) else ra - rb endif) then (     if (ra > rb) then     res := 2 ; else     res := -2 ; ) else     if (d > ra + rb) then     res := 0 else     res := 1 ; ;  ;  
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ;
     var inp : Sequence(double) ; inp := Sequence{} ;
    var out : int ;
    var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    str := scan.getCurrent() ; 
    while (scan.hasNext()) do (     inp := inp->intersection(Set{}) ; 
         var i : int ; i := 0 ; while i < 6 do ( (     str := scan.getCurrent() ; 
     var x : double ; x := (str)->toReal() ;
     inp := inp->including(x) )  ;     i := i + 1 ) ; 
     out := circle_calc(inp) ; 
     OclFile["System.out"].println(out) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int mask[]=new int[k];
    for(int i=0 ; i<k ; i++){
      mask[i]=sc.nextInt();
    }
    for(int i=0 ; i<Math.pow(2,k); i++){
      int bitArray[]=new int[n];
      int temp=i ;
      int index=0 ;
      for(int j=0 ; temp>0 ; j++){
        if(temp % 2==1){
          bitArray[mask[j] ]=1 ;
          index+=Math.pow(2,mask[j]);
        }
        temp/=2 ;
      }
      System.out.print(index+":");
      for(int j=0 ; j<k ; j++){
        if(bitArray[mask[j] ]==1)System.out.print(" "+mask[j]);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var mask : Sequence(int) ; mask := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     mask[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 2->pow(k) do ( (     var bitArray : Sequence(int) ; bitArray := Integer.subrange(1,n)->collect(0) ;
     var temp : int ; temp := i ;
    var index : int ; index := 0 ;
        var j : int ; j := 0 ; while temp > 0 do ( (     if (temp mod 2 = 1) then (     bitArray[mask[j+1]+1] := 1 ; 
     index := index+(2->pow(mask[j+1])) ) else skip ; 
     temp := temp/(2) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].print(index + ":") ; 
        var j : int ; j := 0 ; while j < k do ( (     if (bitArray[mask[j+1]+1] = 1) then     OclFile["System.out"].print(" " + mask[j+1]) ; else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Main(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String[] str=(sc.next()).split(",");
      int[] hand=new int[5];
      for(int i=0 ; i<5 ; i++)hand[i]=Integer.parseInt(str[i]);
      Arrays.sort(hand);
      String res ;
      if(straight(hand))res="straight" ;
      else res=func(hand);
      System.out.println(res);
    }
  }
  String func(int[] hand){
    int[] num=new int[14];
    for(int i=0 ; i<14 ; i++)num[i]=0 ;
    for(int i=0 ; i<5 ; i++)num[hand[i] ]++;
    for(int i=0 ; i<14 ; i++){
      if(num[i]==4)return "four card" ;
      else if(num[i]==3){
        for(int j=i+1 ; j<14 ; j++)if(num[j]==2)return "full house" ;
        return "three card" ;
      }
      else if(num[i]==2){
        for(int j=i+1 ; j<14 ; j++){
          if(num[j]==3)return "full house" ;
          else if(num[j]==2)return "two pair" ;
        }
        return "one pair" ;
      }
    }
    return "null" ;
  }
  boolean straight(int[] hand){
    boolean f ;
    if(hand[0]==1){
      f=true ;
      for(int i=1 ; i<5 && f ; i++)f=(hand[i]==9+i);
      if(f)return f ;
    }
    f=true ;
    for(int i=1 ; i<5 && f ; i++)f=(hand[i]==(hand[0]+i));
    return f ;
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var str : Sequence(String) ; str := (sc.getCurrent())->split(",") ;
     var hand : Sequence(int) ; hand := Integer.subrange(1,5)->collect(0) ;
        var i : int ; i := 0 ; while i < 5 do (     hand[i+1] := (str[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    hand := hand->sort() ; 
    var res : String ;
    if (straight(hand)) then     res := "straight" else     res := func(hand) ; ;  
    OclFile["System.out"].println(res) ; 
 ) );
   operation func( hand : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var num : Sequence(int) ; num := Integer.subrange(1,14)->collect(0) ;
         var i : int ; i := 0 ; while i < 14 do (     num[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 5 do (     num[hand[i+1]+1] := num[hand[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 14 do ( (     if (num[i+1] = 4) then     return "four card" else     if (num[i+1] = 3) then (         var j : int ; j := i + 1 ; while j < 14 do (     if (num[j+1] = 2) then     return "full house" else skip ;  ;     j := j + 1 ) ; 
     return "three card" ) else     if (num[i+1] = 2) then (         var j : int ; j := i + 1 ; while j < 14 do ( (     if (num[j+1] = 3) then     return "full house" else     if (num[j+1] = 2) then     return "two pair" else skip ; )  ;     j := j + 1 ) ; 
     return "one pair" ) else skip ; ;  )  ;     i := i + 1 ) ; 
    return "null" 
 );
   operation straight( hand : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var f : boolean ;
     if (hand[0+1] = 1) then (     f := true ; 
         var i : int ; i := 1 ; while i < 5 & f do (     f := (hand[i+1] = 9 + i) ;  ;     i := i + 1 ) ; 
     if (f) then     return f else skip ) else skip ; 
    f := true ; 
        var i : int ; i := 1 ; while i < 5 & f do (     f := (hand[i+1] = (hand[0+1] + i)) ;  ;     i := i + 1 ) ; 
    return f 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void prime_seive(int MAX,int[] isprime,Vector<Integer>prime){
    int i=2 ;
    while(i*i<=MAX){
      if(isprime[i]==1){
        prime.add(i);
        for(int j=i*2 ; j<MAX ; j+=i){
          isprime[j]=0 ;
        }
      }
      i+=1 ;
    }
  }
  static int printNearest(int N){
    int MAX=(int)1e6 ;
    int[] isprime=new int[MAX];
    for(int i=2 ; i<MAX ; i++)isprime[i]=1 ;
    Vector<Integer>prime=new Vector<Integer>();
    int i=0 ;
    prime_seive(MAX,isprime,prime);
    while(isprime[N]==0){
      N+=prime.get(i);
      i+=1 ;
    }
    return N ;
  }
  public static void main(String[] args){
    int N=8 ;
    System.out.printf("%d",printNearest(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation prime_seive( MAX : int, isprime : Sequence(int), prime : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 2 ;
     while (i * i <= MAX) do (     if (isprime[i+1] = 1) then (     prime->excludes(i) ; 
         var j : int ; j := i * 2 ; while j < MAX do ( (     isprime[j+1] := 0 )  ;     j := j+(i) ) ) else skip ; 
     i := i+(1) ) );
  static   operation printNearest( N : int) : int
  pre: true
  post: true
  activity: (     var MAX : int ; MAX := 1e6->oclAsType(int) ;
     var isprime : Sequence(int) ; isprime := Integer.subrange(1,MAX)->collect(0) ;
        var i : int ; i := 2 ; while i < MAX do (     isprime[i+1] := 1 ;  ;     i := i + 1 ) ; 
    var prime : Sequence(int) ; prime := Sequence{} ;
    var i : int ; i := 0 ;
    execute prime_seive(MAX, isprime, prime) ; 
    while (isprime[N+1] = 0) do (     N := N+(prime->at(i+1)) ; 
     i := i+(1) ) ; 
    return N 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 8 ;
     OclFile["System.out"].printf("%d", printNearest(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  static int findSum(int n){
    int sum=0 ;
    for(int i=1 ; 1<<i<n ; i++){
      for(int j=0 ; j<i ; j++){
        int num=(1<<i)+(1<<j);
        if(num<=n)sum+=num ;
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(findSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation findSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while (1*(2->pow(i)))->oclAsType(long) < n do ( (         var j : int ; j := 0 ; while j < i do ( (     var num : int ; num := ((1*(2->pow(i)))->oclAsType(long)) + ((1*(2->pow(j)))->oclAsType(long)) ;
     if (num <= n) then     sum := sum+(num) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(findSum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isMultipleof5(int n){
    while(n>0)n=n-5 ;
    if(n==0)return true ;
    return false ;
  }
  public static void main(String[] args){
    int n=19 ;
    if(isMultipleof5(n)==true)System.out.printf("%d is multiple of 5\n",n);
    else System.out.printf("%d is not a multiple of 5\n",n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isMultipleof5( n : int) : boolean
  pre: true
  post: true
  activity: (     while (n > 0) do     n := n - 5 ; ; 
     if (n = 0) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 19 ;
     if (isMultipleof5(n) = true) then     OclFile["System.out"].printf("%d is multiple of 5\n", n) ; else     OclFile["System.out"].printf("%d is not a multiple of 5\n", n) ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static boolean search(long a[],long b){
    int start=0 ;
    int end=a.length-1 ;
    while(true){
      if(a[start]==b || a[end]==b)return true ;
      else {
        int mid=(start+end)/2 ;
        if(a[mid]==b)return true ;
        else if(a[mid]<b)start=mid ;
        else end=mid ;
      }
      if(start+1>=end)return false ;
    }
  }
  public static boolean include(long a[],long b[]){
    for(int i=0 ; i<b.length ; i++){
      if(!(search(a,b[i])))return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long a[]=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextLong();
    int m=sc.nextInt();
    long b[]=new long[m];
    for(int i=0 ; i<m ; i++)b[i]=sc.nextLong();
    if(include(a,b))System.out.println(1);
    else System.out.println(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation search( a : Sequence(long), b : long) : boolean
  pre: true
  post: true
  activity: (     var start : int ; start := 0 ;
     var end : int ; end := a->size() - 1 ;
     while (true) do (     if (a[start+1] = b or a[end+1] = b) then     return true else (     var mid : int ; mid := (start + end) / 2 ;
     if (a[mid+1] = b) then     return true else     if (a[mid+1] < b) then     start := mid else     end := mid ; ;  ) ;  
     if (start + 1 >= end) then     return false else skip ) );
  static   operation include( a : Sequence(long), b : Sequence(long)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < b->size() do ( (     if (not((search(a, b[i+1])))) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var b : Sequence(long) ; b := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     b[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    if (include(a, b)) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println(0) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      int n=Integer.parseInt(reader.readLine());
      String[] str1=reader.readLine().split(" ");
      int m=Integer.parseInt(reader.readLine());
      String[] str2=reader.readLine().split(" ");
      int i=0 ;
      int flag=0 ;
      int k=0 ;
      while(i<m){
        flag=0 ;
        int i1=Integer.parseInt(str2[i]);
        for(int j=k ; j<n ; j++){
          if(Integer.parseInt(str1[j])==i1){
            flag=1 ;
            k=j+1 ;
            break ;
          }
          else if(Integer.parseInt(str1[j])>i1){
            flag=0 ;
            break ;
          }
        }
        if(flag==0){
          break ;
        }
        i++;
      }
      System.out.println(flag);
    }
    catch(IOException e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var n : int ; n := (reader.readLine())->toInteger() ;
     var str1 : Sequence(String) ; str1 := reader.readLine()->split(" ") ;
    var m : int ; m := (reader.readLine())->toInteger() ;
    var str2 : Sequence(String) ; str2 := reader.readLine()->split(" ") ;
    var i : int ; i := 0 ;
    var flag : int ; flag := 0 ;
    var k : int ; k := 0 ;
    while (i < m) do (     flag := 0 ; 
     var i1 : int ; i1 := (str2[i+1])->toInteger() ;
        var j : int ; j := k ; while j < n do ( (     if ((str1[j+1])->toInteger() = i1) then (     flag := 1 ; 
     k := j + 1 ; 
     break ) else     if ((str1[j+1])->toInteger() > i1) then (     flag := 0 ; 
     break ) else skip ; )  ;     j := j + 1 ) ; 
    if (flag = 0) then (     break ) else skip ; 
    i := i + 1 ; 
 ) ; 
    OclFile["System.out"].println(flag) ; 
 )   catch (e : IOException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static int start ;
  public static boolean nibutan(int array[],int start,int length,int num){
    int pos=-1 ;
    int lower=start ;
    int upper=length-1 ;
    while(lower<=upper){
      int mid=(lower+upper)/2 ;
      if(array[mid]==num){
        pos=mid ;
        break ;
      }
      else if(array[mid]<num){
        lower=mid+1 ;
      }
      else {
        upper=mid-1 ;
      }
    }
    if(pos!=-1){
      if(pos>0){
        start=pos-1 ;
      }
      return true ;
    }
    else {
      return false ;
    }
  }
  public static void main(String args[]){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    int a[]=new int[n];
    start=0 ;
    int count=1 ;
    boolean flag=true ;
    a[0]=stdIn.nextInt();
    for(int i=1 ; i<n ; i++){
      int num=stdIn.nextInt();
      if(a[count-1]!=num){
        a[count++]=num ;
      }
    }
    int m=stdIn.nextInt();
    int b[]=new int[m];
    for(int i=0 ; i<m ; i++){
      b[i]=stdIn.nextInt();
    }
    for(int i=0 ; i<m ; i++){
      flag=nibutan(a,start,count,b[i]);
      if(! flag){
        break ;
      }
    }
    if(flag){
      System.out.println(1);
    }
    else {
      System.out.println(0);
    }
    stdIn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute start : int;
  static   operation nibutan( array : Sequence(int), start : int, length : int, num : int) : boolean
  pre: true
  post: true
  activity: (     var pos : int ; pos := -1 ;
     var lower : int ; lower := start ;
    var upper : int ; upper := length - 1 ;
    while (lower <= upper) do (     var mid : int ; mid := (lower + upper) / 2 ;
     if (array[mid+1] = num) then (     pos := mid ; 
     break ) else     if (array[mid+1] < num) then (     lower := mid + 1 ) else (     upper := mid - 1 ) ;  ) ; 
    if (pos /= -1) then (     if (pos > 0) then (     start := pos - 1 ) else skip ; 
     return true ) else (     return false ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    start := 0 ; 
    var count : int ; count := 1 ;
    var flag : boolean ; flag := true ;
    a[0+1] := stdIn.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i < n do ( (     var num : int ; num := stdIn.getCurrent()->toInteger() ;
     if (a[count - 1+1] /= num) then (      a[count+1] := num  ; count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    var m : int ; m := stdIn.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := stdIn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     flag := nibutan(a, start, count, b[i+1]) ; 
     if (not(flag)) then (     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(0) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.*;
import java.awt.geom.Point2D ;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] $){
    int n=sc.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
    }
    int m=sc.nextInt();
    long[] b=new long[m];
    for(int i=0 ; i<m ; i++){
      b[i]=sc.nextLong();
    }
    int temp=0 ;
    for(int i=0 ; i<m ; i++){
      if(Arrays.binarySearch(a,b[i])>=0)temp++;
    }
    out.println(temp==m ? 1 : 0);
    out.close();
  }
  static PrintWriter out=new PrintWriter(System.out);
  static class sc {
    static Scanner s=new Scanner(System.in);
    static String next(){
      return s.next();
    }
    static String nextLine(){
      return s.nextLine();
    }
    static int nextInt(){
      return Integer.parseInt(s.next());
    }
    static long nextLong(){
      return Long.parseLong(s.next());
    }
    static double nextDouble(){
      return Double.parseDouble(s.next());
    }
    static boolean hasNext(){
      return s.hasNext();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.nextLong() )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.nextInt() ;
    var b : Sequence(long) ; b := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := sc.nextLong() )  ;     i := i + 1 ) ; 
    var temp : int ; temp := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     if ((a->indexOf(b[i+1]) - 1) >= 0) then     temp := temp + 1 ; else skip )  ;     i := i + 1 ) ; 
    out.println(if temp = m then 1 else 0 endif) ; 
    out.close() ; 
 );
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static class sc {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation next() : String
  pre: true
  post: true
  activity: (     return s.getCurrent() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     return s.nextLine() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toLong() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toReal() );
  static   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return s.hasNext() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    try {
      int n=scanner.nextInt();
      Set<String>set=new HashSet<>();
      for(int i=0 ; i<n ; i++){
        int a=scanner.nextInt();
        String s=Integer.toString(a);
        set.add(s);
      }
      int m=scanner.nextInt();
      boolean flag=true ;
      for(int i=0 ; i<m ; i++){
        int b=scanner.nextInt();
        String s1=Integer.toString(b);
        if(! set.contains(s1)){
          flag=false ;
          break ;
        }
      }
      System.out.println(flag ? 1 : 0);
    }
    catch(Exception e){
    }
    finally {
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     try (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var set : Set(String) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var s : String ; s := ((a) + "") ;
     set := set->including(s) )  ;     i := i + 1 ) ; 
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < m do ( (     var b : int ; b := scanner.getCurrent()->toInteger() ;
     var s1 : String ; s1 := ((b) + "") ;
     if (not(set->includes(s1))) then (     flag := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if flag then 1 else 0 endif) ; 
 )   catch (e : ProgramException) do skip
   finally skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  static int val(char c){
    if(c>='0' && c<='9')return(int)c-'0' ;
    else return(int)c-'A'+10 ;
  }
  static int toDeci(String str,int base){
    int len=str.length();
    int power=1 ;
    int num=0 ;
    int i ;
    for(i=len-1 ; i>=0 ; i--){
      if(val(str.charAt(i))>=base){
        System.out.println("Invalid Number");
        return-1 ;
      }
      num+=val(str.charAt(i))*power ;
      power=power*base ;
    }
    return num ;
  }
  public static boolean isEven(String num,int N){
    int deci=toDeci(num,N);
    return(deci % 2==0);
  }
  public static void main(String[] args){
    String num="11A" ;
    int N=16 ;
    if(isEven(num,N)){
      System.out.println("Even");
    }
    else {
      System.out.println("Odd");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation val( c : String) : int
  pre: true
  post: true
  activity: (     if (c >= '0' & c <= '9') then     return c->oclAsType(int) - ('0')->char2byte() else     return c->oclAsType(int) - ('A')->char2byte() + 10 );
  static   operation toDeci( str : String, base : int) : int
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     var power : int ; power := 1 ;
    var num : int ; num := 0 ;
    var i : int ;
        i := len - 1 ; while i >= 0 do ( (     if (val(str->at(i+1)) >= base) then (     OclFile["System.out"].println("Invalid Number") ; 
     return -1 ) else skip ; 
     num := num+(val(str->at(i+1)) * power) ; 
     power := power * base )  ;     i := i - 1 ) ; 
    return num 
 );
  static   operation isEven( num : String, N : int) : boolean
  pre: true
  post: true
  activity: (     var deci : int ; deci := toDeci(num, N) ;
     return (deci mod 2 = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : String ; num := "11A" ;
     var N : int ; N := 16 ;
     if (isEven(num, N)) then (     OclFile["System.out"].println("Even") ) else (     OclFile["System.out"].println("Odd") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    int[] array=new int[k];
    for(int i=0 ; i<k ; i++){
      array[i]=scan.nextInt();
    }
    for(int i=0 ; i<Math.pow(2,k); i++){
      int[] array2=new int[n];
      int tmp=i ;
      int index=0 ;
      for(int j=0 ; tmp>0 ; j++){
        if(tmp % 2==1){
          array2[array[j] ]=1 ;
          index+=Math.pow(2,array[j]);
        }
        tmp/=2 ;
      }
      System.out.print(index+":");
      for(int j=0 ; j<k ; j++){
        if(array2[array[j] ]==1)System.out.print(" "+array[j]);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     array[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 2->pow(k) do ( (     var array2 : Sequence(int) ; array2 := Integer.subrange(1,n)->collect(0) ;
     var tmp : int ; tmp := i ;
    var index : int ; index := 0 ;
        var j : int ; j := 0 ; while tmp > 0 do ( (     if (tmp mod 2 = 1) then (     array2[array[j+1]+1] := 1 ; 
     index := index+(2->pow(array[j+1])) ) else skip ; 
     tmp := tmp/(2) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].print(index + ":") ; 
        var j : int ; j := 0 ; while j < k do ( (     if (array2[array[j+1]+1] = 1) then     OclFile["System.out"].print(" " + array[j+1]) ; else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      int k=sc.nextInt();
      int tBit=0 ;
      for(int i=0 ; i<k ; i++){
        int j=sc.nextInt();
        if((tBit>>j & 1)==0)tBit+=1<<j ;
      }
      System.out.println("0:");
      for(int bit=1 ; bit<(1<<n); bit++){
        if((bit & ~ tBit)==0 &&(bit & tBit)!=0){
          System.out.print(bit+":");
          for(int j=0 ; j<n ; j++){
            if(((bit>>j)& 1)==1){
              System.out.print(" "+j);
            }
          }
          System.out.println();
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var tBit : int ; tBit := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     var j : int ; j := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseAnd((tBit/(2->pow(j)))->oclAsType(long),1)) = 0) then     tBit := tBit+((1*(2->pow(j)))->oclAsType(long)) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("0:") ; 
        var bit : int ; bit := 1 ; while bit < ((1*(2->pow(n)))->oclAsType(long)) do ( (     if ((MathLib.bitwiseAnd(bit,-(tBit + 1))) = 0 & (MathLib.bitwiseAnd(bit,tBit)) /= 0) then (     OclFile["System.out"].print(bit + ":") ; 
         var j : int ; j := 0 ; while j < n do ( (     if ((((bit/(2->pow(j)))->oclAsType(long)) & 1) = 1) then (     OclFile["System.out"].print(" " + j) ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() ) else skip )  ;     bit := bit + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    String[] str=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    str=br.readLine().split(" ");
    int k=Integer.parseInt(str[0]);
    int[] c=new int[k];
    int[] d=new int[k];
    for(int i=0 ; i<k ; i++){
      int b=Integer.parseInt(str[i+1]);
      int pow2=1 ;
      for(int j=0 ; j<b ; j++)pow2*=2 ;
      c[i]=pow2 ;
      d[i]=b ;
    }
    for(int i=0 ; i<(1<<k); i++){
      int sum=0 ;
      ArrayList<Integer>a=new ArrayList<Integer>();
      for(int j=0 ; j<k ; j++){
        if((i &(1<<j))!=0){
          sum+=c[j];
          a.add(d[j]);
        }
      }
      pw.print(sum+":");
      if(i>0)pw.print(" ");
      for(int j=0 ; j<a.size(); j++){
        pw.print(a.get(j));
        if(j!=a.size()-1)pw.print(" ");
      }
      pw.print("\n");
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    str := br.readLine()->split(" ") ; 
    var k : int ; k := (str[0+1])->toInteger() ;
    var c : Sequence(int) ; c := Integer.subrange(1,k)->collect(0) ;
    var d : Sequence(int) ; d := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     var b : int ; b := (str[i + 1+1])->toInteger() ;
     var pow2 : int ; pow2 := 1 ;
        var j : int ; j := 0 ; while j < b do (     pow2 := pow2*(2) ;  ;     j := j + 1 ) ; 
    c[i+1] := pow2 ; 
    d[i+1] := b ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < ((1*(2->pow(k)))->oclAsType(long)) do ( (     var sum : int ; sum := 0 ;
     var a : Sequence(int) ; a := Sequence{} ;
        var j : int ; j := 0 ; while j < k do ( (     if ((MathLib.bitwiseAnd(i,((1*(2->pow(j)))->oclAsType(long)))) /= 0) then (     sum := sum+(c[j+1]) ; 
     a := a->including(d[j+1]) ) else skip )  ;     j := j + 1 ) ; 
    skip ; 
    if (i > 0) then     skip ; else skip ; 
        var j : int ; j := 0 ; while j < a->size() do ( (     skip ; 
     if (j /= a->size() - 1) then     skip ; else skip )  ;     j := j + 1 ) ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class primeFactorization {
    int countOfPf,primeFactor ;
    public primeFactorization(int countOfPf,int primeFactor){
      this.countOfPf=countOfPf ;
      this.primeFactor=primeFactor ;
    }
  }
  static void generateDivisors(int curIndex,int curDivisor,Vector<primeFactorization>arr){
    if(curIndex==arr.size()){
      System.out.print(curDivisor+" ");
      return ;
    }
    for(int i=0 ; i<=arr.get(curIndex).countOfPf ; ++i){
      generateDivisors(curIndex+1,curDivisor,arr);
      curDivisor*=arr.get(curIndex).primeFactor ;
    }
  }
  static void findDivisors(int n){
    Vector<primeFactorization>arr=new Vector<>();
    for(int i=2 ; i*i<=n ; ++i){
      if(n % i==0){
        int count=0 ;
        while(n % i==0){
          n/=i ;
          count+=1 ;
        }
        arr.add(new primeFactorization(count,i));
      }
    }
    if(n>1){
      arr.add(new primeFactorization(1,n));
    }
    int curIndex=0,curDivisor=1 ;
    generateDivisors(curIndex,curDivisor,arr);
  }
  public static void main(String[] args){
    int n=6 ;
    findDivisors(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class primeFactorization {
   attribute countOfPf : int;
   static operation newprimeFactorization( countOfPf : int, primeFactor : int) : primeFactorization
  pre: true
  post: true
  activity:
  ( var self : primeFactorization ;
    self := createprimeFactorization();
    self.initialise(countOfPf, primeFactor);
    return self );
  operation initialise( countOfPf : int, primeFactor : int) : void
  pre: true  post: true
  activity: (     self.countOfPf := countOfPf ; 
     self.primeFactor := primeFactor );
}
  static   operation generateDivisors( curIndex : int, curDivisor : int, arr : Sequence(primeFactorization)) : void
  pre: true
  post: true
  activity: (     if (curIndex = arr->size()) then (     OclFile["System.out"].print(curDivisor + " ") ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i <= arr->at(curIndex+1).countOfPf do ( (     execute generateDivisors(curIndex + 1, curDivisor, arr) ; 
     curDivisor := curDivisor*(arr->at(curIndex+1).primeFactor) )  ;     i := i + 1 ) );
  static   operation findDivisors( n : int) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(primeFactorization) ; arr := Sequence{} ;
         var i : int ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     var count : int ; count := 0 ;
     while (n mod i = 0) do (     n := n/(i) ; 
     count := count+(1) ) ; 
     arr := arr->including(primeFactorization.newprimeFactorization(count, i)) ) else skip )  ;     i := i + 1 ) ; 
    if (n > 1) then (     arr := arr->including(primeFactorization.newprimeFactorization(1, n)) ) else skip ; 
    var curIndex : int ; curIndex := 0 ;
    var curDivisor : int ; curDivisor := 1 ;
    execute generateDivisors(curIndex, curDivisor, arr) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     execute findDivisors(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Chain {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int max=0 ;
    int n=sc.nextInt();
    int[] beacon=new int[1000001];
    int[] dp=new int[1000001];
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      beacon[a]=sc.nextInt();
    }
    if(beacon[0]!=0)dp[0]=1 ;
    for(int i=1 ; i<1000001 ; i++){
      if(beacon[i]!=0 && beacon[i]<i){
        dp[i]=dp[i-beacon[i]-1]+1 ;
      }
      else if(beacon[i]!=0){
        dp[i]=1 ;
      }
      else {
        dp[i]=dp[i-1];
      }
      max=Math.max(max,dp[i]);
    }
    System.out.print(n-max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Chain {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var max : int ; max := 0 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var beacon : Sequence(int) ; beacon := Integer.subrange(1,1000001)->collect(0) ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,1000001)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     beacon[a+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (beacon[0+1] /= 0) then     dp[0+1] := 1 ; else skip ; 
        var i : int ; i := 1 ; while i < 1000001 do ( (     if (beacon[i+1] /= 0 & beacon[i+1] < i) then (     dp[i+1] := dp[i - beacon[i+1] - 1+1] + 1 ) else     if (beacon[i+1] /= 0) then (     dp[i+1] := 1 ) else (     dp[i+1] := dp[i - 1+1] ) ;  ;  
     max := Set{max, dp[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(n - max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String largestPalinSub(String s){
    String res="" ;
    char mx=s.charAt(0);
    for(int i=1 ; i<s.length(); i++)mx=(char)Math.max((int)mx,(int)s.charAt(i));
    for(int i=0 ; i<s.length(); i++)if(s.charAt(i)==mx)res+=s.charAt(i);
    return res ;
  }
  public static void main(String[] args){
    String s="geeksforgeeks" ;
    System.out.println(largestPalinSub(s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation largestPalinSub( s : String) : String
  pre: true
  post: true
  activity: (     var res : String ; res := "" ;
     var mx : String ; mx := s->at(0+1) ;
        var i : int ; i := 1 ; while i < s->size() do (     mx := Set{(mx)->char2byte(), s->at(i+1)->oclAsType(int)}->max()->oclAsType(String) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < s->size() do (     if (s->at(i+1) = mx) then     res := res+(s->at(i+1)) ; else skip ;  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     OclFile["System.out"].println(largestPalinSub(s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      StringBuffer s=new StringBuffer(sc.next());
      int count ;
      int t=0 ;
      StringBuffer u=new StringBuffer();
      for(int k=0 ; k<n ; k++){
        for(int i=0 ; i<s.length(); i++){
          count=1 ;
          t=s.charAt(i);
          while(i<s.length()-1 && s.charAt(i+1)==t){
            i++;
            count++;
          }
          u.append(count);
          u.append((char)t);
        }
        s=new StringBuffer(u);
        u.delete(0,u.length());
      }
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var s : String ; s := StringLib.newString(sc.getCurrent()) ;
    var count : int ;
    var t : int ; t := 0 ;
    var u : String ; u := StringLib.newString() ;
        var k : int ; k := 0 ; while k < n do ( (         var i : int ; i := 0 ; while i < s->size() do ( (     count := 1 ; 
     t := s->at(i+1) ; 
    while (i < s->size() - 1 & s->at(i + 1+1) = t) do (     i := i + 1 ; 
     count := count + 1 ) ; 
    u := u + StringLib.newString(count) ; 
    u := u + StringLib.newString(t->oclAsType(String)) ; 
 )  ;     i := i + 1 ) ; 
     s := StringLib.newString(u) ; 
     u := u->antirestrict( Integer.subrange(0+1,u->size()) ) )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String line[]=br.readLine().split(" ");
      int n=Integer.parseInt(line[0]);
      if(n==0){
        break ;
      }
      String keep=br.readLine();
      ArrayList<Integer>answer=new ArrayList<Integer>();
      for(int i=0 ; i<keep.length(); i++){
        answer.add(Integer.parseInt(keep.substring(i,i+1)));
      }
      for(int i=0 ; i<n ; i++){
        ArrayList<Integer>result=new ArrayList<Integer>();
        int previous=0 ;
        int count=0 ;
        for(int j=0 ; j<answer.size(); j++){
          int now=answer.get(j);
          if(now==previous){
            count++;
          }
          else {
            if(count!=0){
              result=tryadd(result,count);
              result.add(previous);
            }
            previous=now ;
            count=1 ;
          }
        }
        result=tryadd(result,count);
        result.add(previous);
        answer=result ;
      }
      for(Integer ans : answer){
        System.out.print(ans);
      }
      System.out.println();
    }
  }
  static ArrayList<Integer>tryadd(ArrayList<Integer>list,int a){
    int moto=a ;
    int count=0 ;
    if(moto>=10){
      while(moto>=10){
        moto/=10 ;
        count++;
      }
      list.add(moto);
      return tryadd(list,a-moto*(int)Math.pow(10,count));
    }
    else {
      list.add(moto);
      return list ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
     var n : int ; n := (line[0+1])->toInteger() ;
    if (n = 0) then (     break ) else skip ; 
    var keep : String ; keep := br.readLine() ;
    var answer : Sequence(int) ; answer := Sequence{} ;
        var i : int ; i := 0 ; while i < keep->size() do ( (     answer := answer->including((keep.subrange(i+1,i + 1))->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var result : Sequence(int) ; result := Sequence{} ;
     var previous : int ; previous := 0 ;
    var count : int ; count := 0 ;
        var j : int ; j := 0 ; while j < answer->size() do ( (     var now : int ; now := answer->at(j+1) ;
     if (now = previous) then (     count := count + 1 ) else (     if (count /= 0) then (     result := tryadd(result, count) ; 
     result := result->including(previous) ) else skip ; 
     previous := now ; 
     count := 1 ) )  ;     j := j + 1 ) ; 
    result := tryadd(result, count) ; 
    result := result->including(previous) ; 
    answer := result ; 
 )  ;     i := i + 1 ) ; 
    for (ans : answer) do ( (     OclFile["System.out"].print(ans) )  ) ; 
    OclFile["System.out"].println() ; 
 ) );
  static   operation tryadd( list : Sequence(int), a : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var moto : int ; moto := a ;
     var count : int ; count := 0 ;
     if (moto >= 10) then (     while (moto >= 10) do (     moto := moto/(10) ; 
     count := count + 1 ) ; 
     list->excludes(moto) ; 
     return tryadd(list, a - moto * 10->pow(count)->oclAsType(int)) ) else (     list->excludes(moto) ; 
     return list ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      long n=scanner.nextLong();
      int sqrt=(int)Math.sqrt(n);
      int answer=0 ;
      for(int i=2 ; i<=sqrt ; i++){
        int count=0 ;
        while(0==(n % i)){
          n/=i ;
          count++;
        }
        for(int j=1 ; count-j>=0 ; j++){
          count-=j ;
          answer++;
        }
      }
      if(n>1){
        answer++;
      }
      System.out.println(answer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : long ; n := scanner.getCurrent()->toLong() ;
     var sqrt : int ; sqrt := (n)->sqrt()->oclAsType(int) ;
    var answer : int ; answer := 0 ;
        var i : int ; i := 2 ; while i <= sqrt do ( (     var count : int ; count := 0 ;
     while (0 = (n mod i)) do (     n := n/(i) ; 
     count := count + 1 ) ; 
         var j : int ; j := 1 ; while count - j >= 0 do ( (     count := count-(j) ; 
     answer := answer + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (n > 1) then (     answer := answer + 1 ) else skip ; 
    OclFile["System.out"].println(answer) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p071 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p071().run());
  }
  private static final int LIMIT=1000000 ;
  public String run(){
    int maxN=0 ;
    int maxD=1 ;
    for(int d=1 ; d<=LIMIT ; d++){
      int n=d*3/7 ;
      if(d % 7==0)n--;
      if((long)n*maxD>(long)maxN*d){
        maxN=n ;
        maxD=d ;
      }
    }
    return Integer.toString(maxN);
  }
}
------------------------------------------------------------
OCL File:
---------
class p071 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p071.newp071().run()) );
  static    attribute LIMIT : int := 1000000;
   operation run() : String
  pre: true
  post: true
  activity: (     var maxN : int ; maxN := 0 ;
     var maxD : int ; maxD := 1 ;
         var d : int ; d := 1 ; while d <= LIMIT do ( (     var n : int ; n := d * 3 / 7 ;
     if (d mod 7 = 0) then     n := n - 1 ; else skip ; 
     if (n->oclAsType(long) * maxD > maxN->oclAsType(long) * d) then (     maxN := n ; 
     maxD := d ) else skip )  ;     d := d + 1 ) ; 
     return ((maxN) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      StringBuffer s=new StringBuffer(sc.next());
      for(int j=0 ; j<n ; j++){
        StringBuffer t=new StringBuffer();
        int c=0 ;
        for(int i=0 ; i<s.length(); i++){
          c++;
          if(i==s.length()-1 || s.charAt(i)!=s.charAt(i+1)){
            t.append(c);
            t.append(s.charAt(i));
            c=0 ;
          }
        }
        s=t ;
      }
      println(s.toString());
    }
    System.out.flush();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    System.setOut(new PrintStream(new BufferedOutputStream(System.out)));
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var s : String ; s := StringLib.newString(sc.getCurrent()) ;
        var j : int ; j := 0 ; while j < n do ( (     var t : String ; t := StringLib.newString() ;
     var c : int ; c := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     c := c + 1 ; 
     if (i = s->size() - 1 or s->at(i+1) /= s->at(i + 1+1)) then (     t := t + StringLib.newString(c) ; 
     t := t + StringLib.newString(s->at(i+1)) ; 
     c := 0 ) else skip )  ;     i := i + 1 ) ; 
     s := t )  ;     j := j + 1 ) ; 
    execute println(s+"") ; 
 )  ) ; 
     OclFile["System.out"].flush() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ; 
     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder();
    int tt=fs.nextInt();
    while(tt-->0){
      int n=fs.nextInt(),m=fs.nextInt();
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        int a=fs.nextInt();
        sum+=a ;
      }
      sb.append(sum==m ? "YES" : "NO").append("\n");
    }
    out.print(sb);
    out.close();
  }
  static int isPerfectSquare(int x){
    if(x>=0){
      int sr=(int)Math.sqrt(x);
      if((sr*sr)==x)return sr ;
      else return 0 ;
    }
    return 0 ;
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    Long[] readArray(int n){
      Long[] a=new Long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    var tt : int ; tt := fs.nextInt() ;
        while (tt > 0) do (        tt := tt - 1 ;     skip ; (     var n : int ; n := fs.nextInt() ;
    var m : int ; m := fs.nextInt() ;
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := fs.nextInt() ;
     sum := sum+(a) )  ;     i := i + 1 ) ; 
     sb := sb + StringLib.newString(if sum = m then "YES" else "NO" endif) + StringLib.newString("\n") ) ;  ) ;  
    skip ; 
    skip ; 
 );
  static   operation isPerfectSquare( x : int) : int
  pre: true
  post: true
  activity: (     if (x >= 0) then (     var sr : int ; sr := (x)->sqrt()->oclAsType(int) ;
     if ((sr * sr) = x) then     return sr else     return 0 ) else skip ; 
     return 0 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.text.*;
public class Main {
  public static Scanner sc=new Scanner(System.in);
  public static LinkedList<Pair>list ;
  public static void main(String[] args)throws Exception {
    while(sc.hasNext()){
      int n=sc.nextInt();
      if(n==0)break ;
      String s=sc.next();
      for(int i=0 ; i<n ; i++){
        list=new LinkedList<>();
        for(int j=0 ; j<s.length(); j++){
          String c=s.substring(j,j+1);
          if(! list.isEmpty()){
            Pair p=list.getLast();
            if(! p.s.equals(c)){
              list.add(new Pair(c,1));
            }
            else {
              list.getLast().i++;
            }
          }
          else {
            list.add(new Pair(c,1));
          }
        }
        StringBuilder sb=new StringBuilder();
        for(int j=0 ; j<list.size(); j++){
          Pair p=list.get(j);
          sb.append(p.i).append(p.s);
        }
        s=sb.toString();
      }
      System.out.println(s);
    }
  }
}
class Pair {
  public String s ;
  public int i ;
  public Pair(String s,int i){
    this.s=s ;
    this.i=i ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute list : Sequence(Map);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var s : String ; s := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < n do ( (     list := Sequence{} ; 
         var j : int ; j := 0 ; while j < s->size() do ( (     var c : String ; c := s.subrange(j+1,j + 1) ;
     if (not(list->isEmpty())) then (     var p : Map ; p := list->last() ;
     if (not(p.s = c)) then (     list := list->including(Map(c, 1)) ) else (     list->last().i := list->last().i + 1 ) ) else (     list := list->including(Map(c, 1)) ) )  ;     j := j + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var j : int ; j := 0 ; while j < list->size() do ( (     var p : Map ; p := list->at(j+1) ;
     sb := sb.append(p.i) + StringLib.newString(p.s) )  ;     j := j + 1 ) ; 
    s := sb.toString() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 ) );
}
class Pair {
   attribute s : String;
   attribute i : int;
   static operation newPair( s : String, i : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(s, i);
    return self );
  operation initialise( s : String, i : int) : void
  pre: true  post: true
  activity: (     self.s := s ; 
     self.i := i );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    int count ;
    while((count=Integer.parseInt(line=br.readLine()))!=0){
      line=br.readLine();
      StringBuilder result=new StringBuilder();
      for(int i=0 ; i<count ; i++){
        line=metamorphose(line);
      }
      System.out.println(line);
    }
  }
  private static String metamorphose(String line){
    StringBuilder result=new StringBuilder();
    int count=1 ;
    for(int i=0 ; i<line.length(); i++){
      char now=line.charAt(i);
      char next=' ' ;
      if(i!=line.length()-1)next=line.charAt(i+1);
      if(i==line.length()-1){
        construct(result,count,now);
        break ;
      }
      if(now==next){
        count++;
      }
      else if(now!=next){
        construct(result,count,now);
        count=1 ;
      }
    }
    return result.toString();
  }
  private static void construct(StringBuilder result,int count,char now){
    result.append(count);
    result.append(now);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var count : int ;
         count := (line)->toInteger() ;
    while ((count) /= 0) do (    skip ; (     line := br.readLine() ; 
     var result : String ; result := StringLib.newString() ;
         var i : int ; i := 0 ; while i < count do ( (     line := metamorphose(line) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(line) ) ;     count := (line)->toInteger() ;
 ) );
  static   operation metamorphose( line : String) : String
  pre: true
  post: true
  activity: (     var result : String ; result := StringLib.newString() ;
     var count : int ; count := 1 ;
         var i : int ; i := 0 ; while i < line->size() do ( (     var now : String ; now := line->at(i+1) ;
     var next : String ; next := ' ' ;
    if (i /= line->size() - 1) then     next := line->at(i + 1+1) ; else skip ; 
    if (i = line->size() - 1) then (     execute construct(result, count, now) ; 
     break ) else skip ; 
    if (now = next) then (     count := count + 1 ) else     if (now /= next) then (     execute construct(result, count, now) ; 
     count := 1 ) else skip ; ;  
 )  ;     i := i + 1 ) ; 
     return result+"" );
  static   operation construct( result : String, count : int, now : String) : void
  pre: true
  post: true
  activity: (     result := result + StringLib.newString(count) ; 
     result := result + StringLib.newString(now) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Good_seq {
  static Scanner sc=new Scanner(System.in);
  static PrintWriter pw=new PrintWriter(System.out);
  static int dp[]=new int[100001];
  public static ArrayList<Integer>factoriseopt(int n){
    ArrayList<Integer>ans=new ArrayList<>();
    if(n==1){
      ans.add(1);
      return ans ;
    }
    for(int i=2 ; i*i<=n ; i++){
      if(n % i==0){
        int cnt=0 ;
        while(n % i==0){
          cnt++;
          n=n/i ;
        }
        ans.add(i);
      }
    }
    if(n!=1)ans.add(n);
    return ans ;
  }
  public static void main(String[] args){
    int n=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      ArrayList<Integer>ansArrayList=factoriseopt(arr[i]);
      int best=0 ;
      for(int x : ansArrayList){
        best=Math.max(best,dp[x]);
      }
      for(int x : ansArrayList){
        dp[x]=best+1 ;
      }
    }
    int maxsofar=0 ;
    for(int x : dp){
      maxsofar=Math.max(maxsofar,x);
    }
    System.out.println(maxsofar);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Good_seq {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute dp : int := Integer.subrange(1,100001)->collect(0);
  static   operation factoriseopt( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Sequence{} ;
     if (n = 1) then (     ans := ans->including(1) ; 
     return ans ) else skip ; 
        var i : int ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     var cnt : int ; cnt := 0 ;
     while (n mod i = 0) do (     cnt := cnt + 1 ; 
     n := n / i ) ; 
     ans := ans->including(i) ) else skip )  ;     i := i + 1 ) ; 
    if (n /= 1) then     ans := ans->including(n) ; else skip ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var ansArrayList : Sequence(int) ; ansArrayList := factoriseopt(arr[i+1]) ;
     var best : int ; best := 0 ;
     for (x : ansArrayList) do ( (     best := Set{best, dp[x+1]}->max() )  ) ; 
     for (x : ansArrayList) do ( (     dp[x+1] := best + 1 )  ) )  ;     i := i + 1 ) ; 
    var maxsofar : int ; maxsofar := 0 ;
    for (x : dp) do ( (     maxsofar := Set{maxsofar, x}->max() )  ) ; 
    OclFile["System.out"].println(maxsofar) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.math.BigInteger ;
import java.net.InetAddress ;
import java.net.ServerSocket ;
import java.net.Socket ;
import java.util.*;
import static java.lang.System.out ;
public class app {
  public static ArrayList<ArrayList<Integer>>as=new ArrayList<>();
  public static Boolean x[];
  public static int z ;
  public static long m ;
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int t=1 ;
    while(t-->0){
      int i=0,j=0 ;
      int ans=1 ;
      int n=sc.nextInt();
      int arr[]=new int[n];
      for(i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      int dp[]=new int[10000007];
      for(i=0 ; i<n ; i++){
        int max=1 ;
        if(arr[i]==1)continue ;
        for(j=1 ; j*j<=arr[i]; j++){
          if(arr[i] % j==0){
            max=Math.max(dp[j]+1,max);
            max=Math.max(dp[arr[i]/j]+1,max);
          }
        }
        for(j=2 ; j*j<=arr[i]; j++){
          if(arr[i] % j==0){
            dp[j]=Math.max(dp[j],max);
            dp[arr[i]/j]=Math.max(dp[arr[i]/j],max);
          }
        }
        dp[arr[i] ]++;
        ans=Math.max(ans,max);
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class app {
  static   attribute as : Sequence(Sequence(int)) := Sequence{};
  static   attribute x : Sequence(Boolean);
  static   attribute z : int;
  static   attribute m : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var i : int ; i := 0 ;
    var j : int ; j := 0 ;
     var ans : int ; ans := 1 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,10000007)->collect(0) ;
        i := 0 ; while i < n do ( (     var max : int ; max := 1 ;
     if (arr[i+1] = 1) then     continue else skip ; 
        j := 1 ; while j * j <= arr[i+1] do ( (     if (arr[i+1] mod j = 0) then (     max := Set{dp[j+1] + 1, max}->max() ; 
     max := Set{dp[arr[i+1] / j+1] + 1, max}->max() ) else skip )  ;     j := j + 1 ) ; 
        j := 2 ; while j * j <= arr[i+1] do ( (     if (arr[i+1] mod j = 0) then (     dp[j+1] := Set{dp[j+1], max}->max() ; 
     dp[arr[i+1] / j+1] := Set{dp[arr[i+1] / j+1], max}->max() ) else skip )  ;     j := j + 1 ) ; 
    dp[arr[i+1]+1] := dp[arr[i+1]+1] + 1 ; 
    ans := Set{ans, max}->max() ; 
 )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner console=new Scanner(System.in);
    int n=console.nextInt();
    int[] input=new int[n];
    for(int i=0 ; i<n ; i++){
      input[i]=console.nextInt();
    }
    System.out.println(lengthOfGoodSequence(input));
  }
  private static int lengthOfGoodSequence(int[] input){
    if(input.length==1)return 1 ;
    Map<Integer,Set<Integer>>numberToPrimeFactors=new HashMap<>();
    for(int num : input)numberToPrimeFactors.put(num,getPrimeFactors2(num));
    int[] dp=new int[input[input.length-1]+1];
    for(int num : input){
      Set<Integer>primeFactors=numberToPrimeFactors.get(num);
      int max=0 ;
      for(int prime : primeFactors){
        dp[prime]+=1 ;
        max=Math.max(max,dp[prime]);
      }
      for(int prime : primeFactors)dp[prime]=max ;
    }
    return Arrays.stream(dp).max().getAsInt();
  }
  private static Set<Integer>getPrimeFactors(int num){
    int div=2 ;
    Set<Integer>res=new HashSet<>();
    while(num>1){
      if(num % div==0){
        num/=div ;
        res.add(div);
      }
      else {
        div++;
      }
    }
    return res ;
  }
  private static Set<Integer>getPrimeFactors2(int num){
    Set<Integer>res=new HashSet<>();
    for(int i=2 ; i*i<=num ; i++){
      if(num % i==0){
        res.add(i);
        while(num % i==0)num/=i ;
      }
    }
    if(num>1)res.add(num);
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var console : OclFile ; console := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := console.getCurrent()->toInteger() ;
    var input : Sequence(int) ; input := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     input[i+1] := console.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(lengthOfGoodSequence(input)) ; 
 );
  static   operation lengthOfGoodSequence( input : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (input->size() = 1) then     return 1 else skip ; 
     var numberToPrimeFactors : Map(int,Set(int)) ; numberToPrimeFactors := Map{} ;
    for (num : input) do (     numberToPrimeFactors := numberToPrimeFactors->union(Map{num |-> getPrimeFactors2(num)}) ;  ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,input[input->size() - 1+1] + 1)->collect(0) ;
    for (num : input) do ( (     var primeFactors : Set(int) ; primeFactors := numberToPrimeFactors->at(num) ;
     var max : int ; max := 0 ;
     for (prime : primeFactors) do ( (     dp[prime+1] := dp[prime+1]+(1) ; 
     max := Set{max, dp[prime+1]}->max() )  ) ; 
     for (prime : primeFactors) do (     dp[prime+1] := max ;  ) )  ) ; 
    return stream(dp).max().getAsInt() 
 );
  static   operation getPrimeFactors( num : int) : Set(int)
  pre: true
  post: true
  activity: (     var div : int ; div := 2 ;
     var res : Set(int) ; res := Set{} ;
     while (num > 1) do (     if (num mod div = 0) then (     num := num/(div) ; 
     res := res->including(div) ) else (     div := div + 1 ) ) ; 
     return res );
  static   operation getPrimeFactors2( num : int) : Set(int)
  pre: true
  post: true
  activity: (     var res : Set(int) ; res := Set{} ;
         var i : int ; i := 2 ; while i * i <= num do ( (     if (num mod i = 0) then (     res := res->including(i) ; 
     while (num mod i = 0) do     num := num/(i) ; ) else skip )  ;     i := i + 1 ) ; 
     if (num > 1) then     res := res->including(num) ; else skip ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class B264 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    Map<Integer,Integer>map=new HashMap<>();
    int answer=0 ;
    for(int n=0 ; n<N ; n++){
      int a=in.nextInt();
      int max=1 ;
      for(int d=2 ; d*d<=a ; d++){
        if(a % d==0){
          int dd=a/d ;
          max=Math.max(max,map.getOrDefault(d,0)+1);
          max=Math.max(max,map.getOrDefault(dd,0)+1);
        }
      }
      map.put(a,max);
      for(int d=2 ; d*d<=a ; d++){
        if(a % d==0){
          int dd=a/d ;
          int count=map.getOrDefault(d,0);
          if(count<max){
            map.put(d,max);
          }
          count=map.getOrDefault(dd,0);
          if(count<max){
            map.put(dd,max);
          }
        }
      }
      answer=Math.max(answer,max);
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B264 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var map : Map(int,int) ; map := Map{} ;
    var answer : int ; answer := 0 ;
        var n : int ; n := 0 ; while n < N do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var max : int ; max := 1 ;
        var d : int ; d := 2 ; while d * d <= a do ( (     if (a mod d = 0) then (     var dd : int ; dd := a / d ;
     max := Set{max, (if map->keys()->contains(d) then map->at(d) else 0 endif) + 1}->max() ; 
     max := Set{max, (if map->keys()->contains(dd) then map->at(dd) else 0 endif) + 1}->max() ) else skip )  ;     d := d + 1 ) ; 
    map := map->union(Map{a |-> max}) ; 
        var d : int ; d := 2 ; while d * d <= a do ( (     if (a mod d = 0) then (     var dd : int ; dd := a / d ;
     var count : int ; count := (if map->keys()->contains(d) then map->at(d) else 0 endif) ;
    if (count < max) then (     map := map->union(Map{d |-> max}) ) else skip ; 
    count := (if map->keys()->contains(dd) then map->at(dd) else 0 endif) ; 
    if (count < max) then (     map := map->union(Map{dd |-> max}) ) else skip ; 
 ) else skip )  ;     d := d + 1 ) ; 
    answer := Set{answer, max}->max() ; 
 )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void initializeDiffArray(int A[],int D[]){
    int n=A.length ;
    D[0]=A[0];
    D[n]=0 ;
    for(int i=1 ; i<n ; i++)D[i]=A[i]-A[i-1];
  }
  static void update(int D[],int l,int r,int x){
    D[l]+=x ;
    D[r+1]-=x ;
  }
  static int printArray(int A[],int D[]){
    for(int i=0 ; i<A.length ; i++){
      if(i==0)A[i]=D[i];
      else A[i]=D[i]+A[i-1];
      System.out.print(A[i]+" ");
    }
    System.out.println();
    return 0 ;
  }
  public static void main(String[] args){
    int A[]={
      10,5,20,40 };
      int n=A.length ;
      int D[]=new int[n+1];
      initializeDiffArray(A,D);
      update(D,0,1,10);
      printArray(A,D);
      update(D,1,3,20);
      update(D,2,2,30);
      printArray(A,D);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation initializeDiffArray( A : Sequence(int), D : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := A->size() ;
     D[0+1] := A[0+1] ; 
     D[n+1] := 0 ; 
         var i : int ; i := 1 ; while i < n do (     D[i+1] := A[i+1] - A[i - 1+1] ;  ;     i := i + 1 ) );
  static   operation update( D : Sequence(int), l : int, r : int, x : int) : void
  pre: true
  post: true
  activity: (     D[l+1] := D[l+1]+(x) ; 
     D[r + 1+1] := D[r + 1+1]-(x) );
  static   operation printArray( A : Sequence(int), D : Sequence(int)) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < A->size() do ( (     if (i = 0) then     A[i+1] := D[i+1] else     A[i+1] := D[i+1] + A[i - 1+1] ; ;  
     OclFile["System.out"].print(A[i+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{10,5,20,40} ;
     var n : int ; n := A->size() ;
    var D : Sequence(int) ; D := Integer.subrange(1,n + 1)->collect(0) ;
    execute initializeDiffArray(A, D) ; 
    execute update(D, 0, 1, 10) ; 
    execute printArray(A, D) ; 
    execute update(D, 1, 3, 20) ; 
    execute update(D, 2, 2, 30) ; 
    execute printArray(A, D) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findMaxGuests(int arrl[],int exit[],int n){
    Arrays.sort(arrl);
    Arrays.sort(exit);
    int guests_in=1,max_guests=1,time=arrl[0];
    int i=1,j=0 ;
    while(i<n && j<n){
      if(arrl[i]<=exit[j]){
        guests_in++;
        if(guests_in>max_guests){
          max_guests=guests_in ;
          time=arrl[i];
        }
        i++;
      }
      else {
        guests_in--;
        j++;
      }
    }
    System.out.println("Maximum Number of Guests="+max_guests+" at time "+time);
  }
  public static void main(String[] args){
    int arrl[]={
      1,2,10,5,5 };
      int exit[]={
        4,5,12,9,12 };
        int n=arrl.length ;
        findMaxGuests(arrl,exit,n);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMaxGuests( arrl : Sequence(int), exit : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     arrl := arrl->sort() ; 
     exit := exit->sort() ; 
    var guests_in : int ; guests_in := 1 ;
    var max_guests : int ; max_guests := 1 ;
    var time : int ; time := arrl[0+1] ;
    var i : int ; i := 1 ;
    var j : int ; j := 0 ;
    while (i < n & j < n) do (     if (arrl[i+1] <= exit[j+1]) then (     guests_in := guests_in + 1 ; 
     if (guests_in > max_guests) then (     max_guests := guests_in ; 
     time := arrl[i+1] ) else skip ; 
     i := i + 1 ) else (     guests_in := guests_in - 1 ; 
     j := j + 1 ) ) ; 
    OclFile["System.out"].println("Maximum Number of Guests=" + max_guests + " at time " + time) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arrl : Sequence(int) ; arrl := Sequence{1,2,10,5,5} ;
     var exit : Sequence(int) ; exit := Sequence{4,5,12,9,12} ;
     var n : int ; n := arrl->size() ;
     execute findMaxGuests(arrl, exit, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long c[]=new long[100];
  static void coef(int n){
    c[0]=1 ;
    for(int i=0 ; i<n ; c[0]=-c[0],i++){
      c[1+i]=1 ;
      for(int j=i ; j>0 ; j--)c[j]=c[j-1]-c[j];
    }
  }
  static boolean isPrime(int n){
    coef(n);
    c[0]++;
    c[n]--;
    int i=n ;
    while((i--)>0 && c[i] % n==0);
    return i<0 ;
  }
  public static void main(String[] args){
    int n=37 ;
    if(isPrime(n))System.out.println("Prime");
    else System.out.println("Not Prime");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute c : long := Integer.subrange(1,100)->collect(0);
  static   operation coef( n : int) : void
  pre: true
  post: true
  activity: (     c[0+1] := 1 ; 
         var i : int ; i := 0 ; while i < n do ( (     c[1 + i+1] := 1 ; 
         var j : int ; j := i ; while j > 0 do (     c[j+1] := c[j - 1+1] - c[j+1] ;  ;     j := j - 1 ) )  ;     c[0+1] := -c[0+1] ;     i := i + 1 ) );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     execute coef(n) ; 
     c[0+1] := c[0+1] + 1 ; 
    c[n+1] := c[n+1] - 1 ; 
    var i : int ; i := n ;
        while ((i) > 0 & c[i+1] mod n = 0) do (    skip ;  ;  ) ;  
    return i < 0 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 37 ;
     if (isPrime(n)) then     OclFile["System.out"].println("Prime") ; else     OclFile["System.out"].println("Not Prime") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      String in=sc.next();
      if(in.equals("#END")){
        return ;
      }
      String ans="" ;
      for(int i=1 ; i<in.length(); i++){
        String lcs=lcs(in.substring(0,i),in.substring(i,in.length()));
        if(lcs.length()>ans.length()){
          ans=lcs ;
        }
      }
      System.out.println(ans);
    }
  }
  String lcs(String s,String t){
    int n=s.length();
    int m=t.length();
    int[][] dp=new int[n+1][m+1];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(s.charAt(i)==t.charAt(j)){
          dp[i+1][j+1]=dp[i][j]+1 ;
        }
        else {
          dp[i+1][j+1]=Math.max(dp[i+1][j],dp[i][j+1]);
        }
      }
    }
    char[] res=new char[dp[n][m] ];
    while(n>0 && m>0){
      if(dp[n][m]==dp[n-1][m]){
        n--;
      }
      else if(dp[n][m]==dp[n][m-1]){
        m--;
      }
      else {
        res[dp[n-1][m-1] ]=s.charAt(n-1);
        n--;
        m--;
      }
    }
    return String.valueOf(res);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var in : String ; in := sc.getCurrent() ;
     if (in = "#END") then (     return ) else skip ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 1 ; while i < in->size() do ( (     var lcs : String ; lcs := lcs(in.subrange(0+1,i), in.subrange(i+1,in->size())) ;
     if (lcs->size() > ans->size()) then (     ans := lcs ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ) );
   operation lcs( s : String, t : String) : String
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var m : int ; m := t->size() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (s->at(i+1) = t->at(j+1)) then (     dp[i + 1+1][j + 1+1] := dp[i+1][j+1] + 1 ) else (     dp[i + 1+1][j + 1+1] := Set{dp[i + 1+1][j+1], dp[i+1][j + 1+1]}->max() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : Sequence(String) ; res := Integer.subrange(1,dp[n+1][m+1])->collect(0) ;
    while (n > 0 & m > 0) do (     if (dp[n+1][m+1] = dp[(n)->char2byte() - 1+1][m+1]) then (     n := n - 1 ) else     if (dp[n+1][m+1] = dp[n+1][m - 1+1]) then (     m := m - 1 ) else (     res[dp[(n)->char2byte() - 1+1][m - 1+1]+1] := s->at((n)->char2byte() - 1+1) ; 
     n := n - 1 ; 
     m := m - 1 ) ;  ) ; 
    return (res)->sum()  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      String in=sc.next();
      if(in.equals("#END")){
        return ;
      }
      String ans="" ;
      for(int i=1 ; i<in.length(); i++){
        String lcs=lcs(in.substring(0,i),in.substring(i,in.length()));
        if(lcs.length()>ans.length()){
          ans=lcs ;
        }
      }
      System.out.println(ans);
    }
  }
  String lcs(String s,String t){
    int n=s.length();
    int m=t.length();
    int[][] dp=new int[n+1][m+1];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(s.charAt(i)==t.charAt(j)){
          dp[i+1][j+1]=dp[i][j]+1 ;
        }
        else {
          dp[i+1][j+1]=Math.max(dp[i+1][j],dp[i][j+1]);
        }
      }
    }
    char[] res=new char[dp[n][m] ];
    while(n>0 && m>0){
      if(dp[n][m]==dp[n-1][m]){
        n--;
      }
      else if(dp[n][m]==dp[n][m-1]){
        m--;
      }
      else {
        res[dp[n-1][m-1] ]=s.charAt(n-1);
        n--;
        m--;
      }
    }
    return String.valueOf(res);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var in : String ; in := sc.getCurrent() ;
     if (in = "#END") then (     return ) else skip ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 1 ; while i < in->size() do ( (     var lcs : String ; lcs := lcs(in.subrange(0+1,i), in.subrange(i+1,in->size())) ;
     if (lcs->size() > ans->size()) then (     ans := lcs ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ) );
   operation lcs( s : String, t : String) : String
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var m : int ; m := t->size() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (s->at(i+1) = t->at(j+1)) then (     dp[i + 1+1][j + 1+1] := dp[i+1][j+1] + 1 ) else (     dp[i + 1+1][j + 1+1] := Set{dp[i + 1+1][j+1], dp[i+1][j + 1+1]}->max() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : Sequence(String) ; res := Integer.subrange(1,dp[n+1][m+1])->collect(0) ;
    while (n > 0 & m > 0) do (     if (dp[n+1][m+1] = dp[(n)->char2byte() - 1+1][m+1]) then (     n := n - 1 ) else     if (dp[n+1][m+1] = dp[n+1][m - 1+1]) then (     m := m - 1 ) else (     res[dp[(n)->char2byte() - 1+1][m - 1+1]+1] := s->at((n)->char2byte() - 1+1) ; 
     n := n - 1 ; 
     m := m - 1 ) ;  ) ; 
    return (res)->sum()  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] s=sc.next().toCharArray();
    int len=0 ;
    for(int i=0 ; i<s.length ; i++){
      if(len % 2==0 && s[i]=='A' || len % 2==1 && s[i]=='Z'){
        len++;
      }
    }
    len/=2 ;
    if(len==0){
      System.out.println(-1);
    }
    else {
      StringBuilder sb=new StringBuilder();
      for(int i=0 ; i<len ; i++){
        sb.append("AZ");
      }
      System.out.println(sb.toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var len : int ; len := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (len mod 2 = 0 & s[i+1] = 'A' or len mod 2 = 1 & s[i+1] = 'Z') then (     len := len + 1 ) else skip )  ;     i := i + 1 ) ; 
    len := len/(2) ; 
    if (len = 0) then (     OclFile["System.out"].println(-1) ) else (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < len do ( (     sb := sb + StringLib.newString("AZ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sb+"") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Test {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int tc=Integer.parseInt(br.readLine());
    while(tc!=0){
      String[] nm=br.readLine().split(" ");
      int n=Integer.parseInt(nm[0]);
      int m=Integer.parseInt(nm[1]);
      int totalSum=0 ;
      String[] arr=br.readLine().split(" ");
      for(int i=0 ; i<n ; i++){
        totalSum=totalSum+Integer.parseInt(arr[i]);
      }
      if(totalSum==m)System.out.println("YES");
      else System.out.println("NO");
      tc--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tc : int ; tc := (br.readLine())->toInteger() ;
     while (tc /= 0) do (     var nm : Sequence(String) ; nm := br.readLine()->split(" ") ;
     var n : int ; n := (nm[0+1])->toInteger() ;
    var m : int ; m := (nm[1+1])->toInteger() ;
    var totalSum : int ; totalSum := 0 ;
    var arr : Sequence(String) ; arr := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < n do ( (     totalSum := totalSum + (arr[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    if (totalSum = m) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
    tc := tc - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      String in=sc.next();
      if(in.equals("#END")){
        return ;
      }
      String ans="" ;
      for(int i=1 ; i<in.length(); i++){
        String lcs=lcs(in.substring(0,i),in.substring(i,in.length()));
        if(lcs.length()>ans.length()){
          ans=lcs ;
        }
      }
      System.out.println(ans);
    }
  }
  String lcs(String s,String t){
    int n=s.length();
    int m=t.length();
    int[][] dp=new int[n+1][m+1];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(s.charAt(i)==t.charAt(j)){
          dp[i+1][j+1]=dp[i][j]+1 ;
        }
        else {
          dp[i+1][j+1]=Math.max(dp[i+1][j],dp[i][j+1]);
        }
      }
    }
    char[] res=new char[dp[n][m] ];
    while(n>0 && m>0){
      if(dp[n][m]==dp[n-1][m]){
        n--;
      }
      else if(dp[n][m]==dp[n][m-1]){
        m--;
      }
      else {
        res[dp[n-1][m-1] ]=s.charAt(n-1);
        n--;
        m--;
      }
    }
    return String.valueOf(res);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var in : String ; in := sc.getCurrent() ;
     if (in = "#END") then (     return ) else skip ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 1 ; while i < in->size() do ( (     var lcs : String ; lcs := lcs(in.subrange(0+1,i), in.subrange(i+1,in->size())) ;
     if (lcs->size() > ans->size()) then (     ans := lcs ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ) );
   operation lcs( s : String, t : String) : String
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var m : int ; m := t->size() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (s->at(i+1) = t->at(j+1)) then (     dp[i + 1+1][j + 1+1] := dp[i+1][j+1] + 1 ) else (     dp[i + 1+1][j + 1+1] := Set{dp[i + 1+1][j+1], dp[i+1][j + 1+1]}->max() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : Sequence(String) ; res := Integer.subrange(1,dp[n+1][m+1])->collect(0) ;
    while (n > 0 & m > 0) do (     if (dp[n+1][m+1] = dp[(n)->char2byte() - 1+1][m+1]) then (     n := n - 1 ) else     if (dp[n+1][m+1] = dp[n+1][m - 1+1]) then (     m := m - 1 ) else (     res[dp[(n)->char2byte() - 1+1][m - 1+1]+1] := s->at((n)->char2byte() - 1+1) ; 
     n := n - 1 ; 
     m := m - 1 ) ;  ) ; 
    return (res)->sum()  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  String lcs(String a,String b){
    int na=a.length(),nb=b.length();
    int dp[][]=new int[na+1][nb+1];
    for(int i=1 ; i<=na ; i++)for(int j=1 ; j<=nb ; j++){
      if(a.charAt(i-1)==b.charAt(j-1))dp[i][j]=dp[i-1][j-1]+1 ;
      else dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
    }
    char[] r=new char[dp[na][nb] ];
    int i=na,j=nb ;
    while(0<i && 0<j){
      if(dp[i][j]==dp[i-1][j])i--;
      else if(dp[i][j]==dp[i][j-1])j--;
      else {
        r[dp[i-1][j-1] ]=a.charAt(i-1);
        i--;
        j--;
      }
    }
    return new String(r);
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      String s=sc.next();
      if("#END".equals(s))break ;
      String res="" ;
      for(int i=1 ; i<s.length(); i++){
        String l=lcs(s.substring(0,i),s.substring(i));
        if(res.length()<l.length())res=l ;
      }
      System.out.println(res);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation lcs( a : String, b : String) : String
  pre: true
  post: true
  activity: (     var na : int ; na := a->size() ;
    var nb : int ; nb := b->size() ;
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,na + 1)->collect(Integer.subrange(1,nb + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= na do (         var j : int ; j := 1 ; while j <= nb do ( (     if (a->at(i - 1+1) = b->at(j - 1+1)) then     dp[i+1][j+1] := dp[i - 1+1][j - 1+1] + 1 ; else     dp[i+1][j+1] := Set{dp[i - 1+1][j+1], dp[i+1][j - 1+1]}->max() ; )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var r : Sequence(String) ; r := Integer.subrange(1,dp[na+1][nb+1])->collect(0) ;
    var i : int ; i := na ;
    var j : int ; j := nb ;
    while (0 < i & 0 < j) do (     if (dp[i+1][j+1] = dp[i - 1+1][j+1]) then     i := i - 1 ; else     if (dp[i+1][j+1] = dp[i+1][j - 1+1]) then     j := j - 1 else (     r[dp[i - 1+1][j - 1+1]+1] := a->at(i - 1+1) ; 
     i := i - 1 ; 
     j := j - 1 ) ;  ) ; 
    return StringLib.newString(r) 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var s : String ; s := sc.getCurrent() ;
     if ("#END" = s) then     break else skip ; 
    var res : String ; res := "" ;
        var i : int ; i := 1 ; while i < s->size() do ( (     var l : String ; l := lcs(s.subrange(0+1,i), s.subrange(i+1,i)) ;
     if (res->size() < l->size()) then     res := l ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    for(; ; ){
      String s=cin.next();
      if(s.equals("#END"))break ;
      String ans="" ;
      for(int i=1 ; i<s.length(); i++){
        String s1=s.substring(0,i);
        String s2=s.substring(i);
        String s3=lcs(s1,s2);
        if(ans.length()<s3.length()){
          ans=s3 ;
        }
      }
      System.out.println(ans);
      System.gc();
    }
  }
  public static String lcs(String a,String b){
    int na=a.length(),nb=b.length();
    int dp[][]=new int[na+1][nb+1];
    for(int i=1 ; i<=na ; i++)for(int j=1 ; j<=nb ; j++){
      if(a.charAt(i-1)==b.charAt(j-1))dp[i][j]=dp[i-1][j-1]+1 ;
      else dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
    }
    char[] r=new char[dp[na][nb] ];
    int i=na,j=nb ;
    while(0<i && 0<j){
      if(dp[i][j]==dp[i-1][j])i--;
      else if(dp[i][j]==dp[i][j-1])j--;
      else {
        r[dp[i-1][j-1] ]=a.charAt(i-1);
        i--;
        j--;
      }
    }
    return new String(r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var s : String ; s := cin.getCurrent() ;
     if (s = "#END") then     break else skip ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 1 ; while i < s->size() do ( (     var s1 : String ; s1 := s.subrange(0+1,i) ;
     var s2 : String ; s2 := s.subrange(i+1,i) ;
     var s3 : String ; s3 := lcs(s1, s2) ;
     if (ans->size() < s3->size()) then (     ans := s3 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
gc() ; 
 )  ) );
  static   operation lcs( a : String, b : String) : String
  pre: true
  post: true
  activity: (     var na : int ; na := a->size() ;
    var nb : int ; nb := b->size() ;
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,na + 1)->collect(Integer.subrange(1,nb + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= na do (         var j : int ; j := 1 ; while j <= nb do ( (     if (a->at((i)->char2byte() - 1+1) = b->at(j - 1+1)) then     dp[i+1][j+1] := dp[(i)->char2byte() - 1+1][j - 1+1] + 1 ; else     dp[i+1][j+1] := Set{dp[(i)->char2byte() - 1+1][j+1], dp[i+1][j - 1+1]}->max() ; )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var r : Sequence(String) ; r := Integer.subrange(1,dp[na+1][nb+1])->collect(0) ;
    var i : int ; i := na ;
    var j : int ; j := nb ;
    while (0 < i & 0 < j) do (     if (dp[i+1][j+1] = dp[(i)->char2byte() - 1+1][j+1]) then     i := i - 1 ; else     if (dp[i+1][j+1] = dp[i+1][j - 1+1]) then     j := j - 1 else (     r[dp[(i)->char2byte() - 1+1][j - 1+1]+1] := a->at((i)->char2byte() - 1+1) ; 
     i := i - 1 ; 
     j := j - 1 ) ;  ) ; 
    return StringLib.newString(r) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int calcFunction(int n,int r){
    int finalDenominator=1 ;
    int mx=Math.max(r,n-r);
    for(int i=mx+1 ; i<=n ; i++){
      int denominator=(int)Math.pow(i,i);
      int numerator=(int)Math.pow(i-mx,i-mx);
      finalDenominator=(finalDenominator*denominator)/numerator ;
    }
    return finalDenominator ;
  }
  public static void main(String[] args){
    int n=6,r=2 ;
    System.out.println("1/"+calcFunction(n,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation calcFunction( n : int, r : int) : int
  pre: true
  post: true
  activity: (     var finalDenominator : int ; finalDenominator := 1 ;
     var mx : int ; mx := Set{r, n - r}->max() ;
         var i : int ; i := mx + 1 ; while i <= n do ( (     var denominator : int ; denominator := i->pow(i)->oclAsType(int) ;
     var numerator : int ; numerator := i - mx->pow(i - mx)->oclAsType(int) ;
     finalDenominator := (finalDenominator * denominator) / numerator )  ;     i := i + 1 ) ; 
     return finalDenominator );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
    var r : int ; r := 2 ;
     OclFile["System.out"].println("1/" + calcFunction(n, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void isPerfectSquare(int x){
    int sr=(int)Math.sqrt(x);
    if(sr*sr==x)System.out.println("Yes");
    else System.out.println("No");
  }
  public static void main(String args[]){
    int n=7,k=2 ;
    isPerfectSquare(n+k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPerfectSquare( x : int) : void
  pre: true
  post: true
  activity: (     var sr : int ; sr := (x)->sqrt()->oclAsType(int) ;
     if (sr * sr = x) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
    var k : int ; k := 2 ;
     execute isPerfectSquare(n + k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  final static int NUM=(int)(1e5+2);
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    HashMap<Integer,Integer>map=new HashMap<>();
    PriorityQueue<Integer>nums=new PriorityQueue<>();
    for(int i=0 ; i<N ; i++){
      int tmp=sc.nextInt();
      nums.add(tmp);
      map.put(tmp,i);
    }
    int bin=0 ;
    int diff=0 ;
    while(! nums.isEmpty()){
      int num=nums.poll();
      int idx=map.get(num);
      if((bin % 2)!=(idx % 2)){
        diff++;
      }
      bin++;
      bin %=2 ;
    }
    int ans=(diff/2);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute NUM : int := (1e5 + 2)->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var map : Map(int,int) ; map := Map{} ;
    var nums : Sequence(int) ; nums := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var tmp : int ; tmp := sc.getCurrent()->toInteger() ;
     nums := nums->including(tmp) ; 
     map := map->union(Map{tmp |-> i}) )  ;     i := i + 1 ) ; 
    var bin : int ; bin := 0 ;
    var diff : int ; diff := 0 ;
    while (not(nums->isEmpty())) do (     var num : int ; num := nums->min() ;
     var idx : int ; idx := map->at(num) ;
    if ((bin mod 2) /= (idx mod 2)) then (     diff := diff + 1 ) else skip ; 
    bin := bin + 1 ; 
    bin := bin mod 2 ; 
 ) ; 
    var ans : int ; ans := (diff / 2) ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int count_greater(int arr[],int n){
    int min=Integer.MAX_VALUE ;
    int counter=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(arr[i]>min){
        counter++;
      }
      if(arr[i]<=min){
        min=arr[i];
      }
    }
    return counter ;
  }
  public static void main(String[] args){
    int arr[]={
      3,2,1,2,3,4,5 };
      int n=arr.length ;
      System.out.println(count_greater(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation count_greater( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var min : int ; min := 2147483647 ;
     var counter : int ; counter := 0 ;
         var i : int ; i := n - 1 ; while i >= 0 do ( (     if (arr[i+1] > min) then (     counter := counter + 1 ) else skip ; 
     if (arr[i+1] <= min) then (     min := arr[i+1] ) else skip )  ;     i := i - 1 ) ; 
     return counter );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,2,1,2,3,4,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(count_greater(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(final String[] args){
    final Scanner scanner=new Scanner(System.in);
    final List<Integer>list=IntStream.range(0,scanner.nextInt()).mapToObj(i->scanner.nextInt()).collect(Collectors.toList());
    final Map<Integer,Integer>index=new HashMap<>();
    for(int i=0 ; i<list.size(); i++){
      index.put(list.get(i),i);
    }
    Collections.sort(list);
    int count=0 ;
    for(int i=0 ; i<list.size(); i++){
      final int tmp=list.get(i);
      if(i % 2!=index.get(tmp)% 2){
        count++;
      }
    }
    System.out.println(count/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(int) ; list := Integer.subrange(0, scanner.getCurrent()->toInteger()-1).mapToObj(lambda i : OclAny in scanner.getCurrent()->toInteger()).collect(Collectors.toList()) ;
    var index : Map(int,int) ; index := Map{} ;
        var i : int ; i := 0 ; while i < list->size() do ( (     index := index->union(Map{list->at(i+1) |-> i}) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < list->size() do ( (     var tmp : int ; tmp := list->at(i+1) ;
     if (i mod 2 /= index->at(tmp) mod 2) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++)A[i]=sc.nextInt();
    int[] odd=new int[N-N/2];
    int[] even=new int[N/2];
    for(int i=0 ; i<N ; i++)if(i % 2==0)odd[i/2]=A[i];
    else even[i/2]=A[i];
    Arrays.sort(A);
    Arrays.sort(odd);
    Arrays.sort(even);
    int ans=0 ;
    int oi=0,ei=0 ;
    for(int i=0 ; i<N ; i++){
      if(oi<N-N/2 && A[i]==odd[oi]){
        if(i % 2!=0)ans++;
        oi++;
      }
      else {
        if(i % 2==0)ans++;
        ei++;
      }
    }
    System.out.println(ans/2);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     A[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var odd : Sequence(int) ; odd := Integer.subrange(1,N - N / 2)->collect(0) ;
    var even : Sequence(int) ; even := Integer.subrange(1,N / 2)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     if (i mod 2 = 0) then     odd[i / 2+1] := A[i+1] else     even[i / 2+1] := A[i+1] ; ;   ;     i := i + 1 ) ; 
    A := A->sort() ; 
    odd := odd->sort() ; 
    even := even->sort() ; 
    var ans : int ; ans := 0 ;
    var oi : int ; oi := 0 ;
    var ei : int ; ei := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (oi < N - N / 2 & A[i+1] = odd[oi+1]) then (     if (i mod 2 /= 0) then     ans := ans + 1 ; else skip ; 
     oi := oi + 1 ) else (     if (i mod 2 = 0) then     ans := ans + 1 ; else skip ; 
     ei := ei + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans / 2) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Unit[] arr=new Unit[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=new Unit(i,sc.nextInt());
    }
    Arrays.sort(arr);
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(i % 2!=arr[i] .idx % 2){
        count++;
      }
    }
    System.out.println(count/2);
  }
  static class Unit implements Comparable<Unit>{
    int idx ;
    int value ;
    public Unit(int idx,int value){
      this.idx=idx ;
      this.value=value ;
    }
    public int compareTo(Unit another){
      return value-another.value ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(Unit) ; arr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := Unit.newUnit(i, sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 /= arr[i+1].idx mod 2) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count / 2) ; 
 );
  static class Unit implements Comparable<Unit> {
   attribute idx : int;
   attribute value : int;
   static operation newUnit( idx : int, value : int) : Unit
  pre: true
  post: true
  activity:
  ( var self : Unit ;
    self := createUnit();
    self.initialise(idx, value);
    return self );
  operation initialise( idx : int, value : int) : void
  pre: true  post: true
  activity: (     self.idx := idx ; 
     self.value := value );
   operation compareTo( another : Unit) : int
  pre: true
  post: true
  activity: (     return value - another.value );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Cf {
  static Scanner inp=new Scanner(System.in);
  public static void solve(){
    int n=inp.nextInt();
    int m=inp.nextInt();
    int[] array=new int[n];
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      array[i]=inp.nextInt();
      sum+=array[i];
    }
    if(sum==m)System.out.println("YES");
    else System.out.println("NO");
  }
  public static void main(String[] args){
    int t=inp.nextInt();
    while(t-->0){
      solve();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cf {
  static   attribute inp : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := inp.getCurrent()->toInteger() ;
     var m : int ; m := inp.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := inp.getCurrent()->toInteger() ; 
     sum := sum+(array[i+1]) )  ;     i := i + 1 ) ; 
    if (sum = m) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := inp.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
import java.util.stream.Collectors ;
public class A {
  public static void main(String[] args){
    try(Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out)){
      int n=in.nextInt();
      List<Integer>a=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        int value=in.nextInt();
        a.add(value);
      }
      a=a.stream().distinct().sorted().collect(Collectors.toList());
      boolean found=false ;
      for(int i=0 ; i<a.size(); i++){
        if(i+1<a.size()&& i+2<a.size()){
          if(a.get(i)+1==a.get(i+1)&& a.get(i+1)+1==a.get(i+2)){
            found=true ;
          }
        }
      }
      out.println(found ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]) ;
 (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var value : int ; value := in.getCurrent()->toInteger() ;
     a := a->including(value) )  ;     i := i + 1 ) ; 
    a := a->asOrderedSet()->sort().collect(Collectors.toList()) ; 
    var found : boolean ; found := false ;
        var i : int ; i := 0 ; while i < a->size() do ( (     if (i + 1 < a->size() & i + 2 < a->size()) then (     if (a->at(i+1) + 1 = a->at(i + 1+1) & a->at(i + 1+1) + 1 = a->at(i + 2+1)) then (     found := true ) else skip ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    Set<Integer>set=new HashSet<>();
    boolean flag=false ;
    for(int i=0 ; i<n ; i++){
      int t=scanner.nextInt();
      if(flag){
        continue ;
      }
      if((set.contains(t-1)&& set.contains(t-2))||(set.contains(t-1)&& set.contains(t+1))||(set.contains(t+1)&& set.contains(t+2))){
        flag=true ;
      }
      set.add(t);
    }
    if(flag){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < n do ( (     var t : int ; t := scanner.getCurrent()->toInteger() ;
     if (flag) then (     continue ) else skip ; 
     if ((set->includes(t - 1) & set->includes(t - 2)) or (set->includes(t - 1) & set->includes(t + 1)) or (set->includes(t + 1) & set->includes(t + 2))) then (     flag := true ) else skip ; 
     set := set->including(t) )  ;     i := i + 1 ) ; 
    if (flag) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Set<Integer>set=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      set.add(sc.nextInt());
    }
    Integer[] a=new Integer[set.size()];
    System.out.println(pickGift(set.toArray(a)));
  }
  public static String pickGift(Integer[] a){
    Arrays.sort(a);
    int len=a.length ;
    if(len<3){
      return "NO" ;
    }
    int ans=0 ;
    for(int i=1 ; i<len-1 ; i++){
      if(Math.abs(a[i-1]-a[i+1])<=2){
        return "YES" ;
      }
    }
    return "NO" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     set := set->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var a : Sequence(int) ; a := Integer.subrange(1,set->size())->collect(null) ;
    OclFile["System.out"].println(pickGift(set->asSequence())) ; 
 );
  static   operation pickGift( a : Sequence(int)) : String
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var len : int ; len := a->size() ;
    if (len < 3) then (     return "NO" ) else skip ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < len - 1 do ( (     if (if a[i - 1+1] - a[i + 1+1] < 0 then -(a[i - 1+1] - a[i + 1+1]) else a[i - 1+1] - a[i + 1+1] endif <= 2) then (     return "YES" ) else skip )  ;     i := i + 1 ) ; 
    return "NO" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class ProblemA {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] t=new int[n];
    for(int i=0 ; i<n ; i++){
      t[i]=in.nextInt();
    }
    Arrays.sort(t);
    ArrayList<Integer>arrayList=new ArrayList<>();
    arrayList.add(t[0]);
    for(int i=1 ; i<n ; i++){
      if(t[i]!=arrayList.get(arrayList.size()-1)){
        arrayList.add(t[i]);
      }
    }
    String result="NO" ;
    for(int i=2 ; i<arrayList.size(); i++){
      if(arrayList.get(i)-arrayList.get(i-1)==1 && arrayList.get(i-1)-arrayList.get(i-2)==1){
        result="YES" ;
        break ;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     t[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    t := t->sort() ; 
    var arrayList : Sequence(int) ; arrayList := Sequence{} ;
    arrayList := arrayList->including(t[0+1]) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (t[i+1] /= arrayList->at(arrayList->size() - 1+1)) then (     arrayList := arrayList->including(t[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    var result : String ; result := "NO" ;
        var i : int ; i := 2 ; while i < arrayList->size() do ( (     if (arrayList->at(i+1) - arrayList->at((i)->char2byte() - 1+1) = 1 & arrayList->at((i)->char2byte() - 1+1) - arrayList->at((i)->char2byte() - 2+1) = 1) then (     result := "YES" ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Gift {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    while(scanner.hasNextInt()){
      int giftCount=scanner.nextInt();
      Set<Integer>giftSet=new TreeSet<>();
      for(int i=0 ; i<giftCount ; i++){
        giftSet.add(scanner.nextInt());
      }
      int[] giftArray=new int[giftSet.size()];
      int j=0 ;
      for(int num : giftSet){
        giftArray[j++]=num ;
      }
      boolean istrue=false ;
      for(int i=0 ; i<giftArray.length-2 ; i++){
        if((Math.abs(giftArray[i]-giftArray[i+1])<=2 && Math.abs(giftArray[i]-giftArray[i+1])>0)&&(Math.abs(giftArray[i]-giftArray[i+2])<=2 && Math.abs(giftArray[i]-giftArray[i+2])>0)&&(Math.abs(giftArray[i+1]-giftArray[i+2])<=2 && Math.abs(giftArray[i+1]-giftArray[i+2])>0)){
          istrue=true ;
          break ;
        }
      }
      if(istrue){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Gift {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scanner.hasNextInt()) do (     var giftCount : int ; giftCount := scanner.getCurrent()->toInteger() ;
     var giftSet : Set(int) ; giftSet := Set{} ;
        var i : int ; i := 0 ; while i < giftCount do ( (     giftSet := giftSet->including(scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var giftArray : Sequence(int) ; giftArray := Integer.subrange(1,giftSet->size())->collect(0) ;
    var j : int ; j := 0 ;
    for (num : giftSet) do ( (      giftArray[j+1] := num  ; j := j + 1 )  ) ; 
    var istrue : boolean ; istrue := false ;
        var i : int ; i := 0 ; while i < giftArray->size() - 2 do ( (     if ((if giftArray[i+1] - giftArray[i + 1+1] < 0 then -(giftArray[i+1] - giftArray[i + 1+1]) else giftArray[i+1] - giftArray[i + 1+1] endif <= 2 & if giftArray[i+1] - giftArray[i + 1+1] < 0 then -(giftArray[i+1] - giftArray[i + 1+1]) else giftArray[i+1] - giftArray[i + 1+1] endif > 0) & (if giftArray[i+1] - giftArray[i + 2+1] < 0 then -(giftArray[i+1] - giftArray[i + 2+1]) else giftArray[i+1] - giftArray[i + 2+1] endif <= 2 & if giftArray[i+1] - giftArray[i + 2+1] < 0 then -(giftArray[i+1] - giftArray[i + 2+1]) else giftArray[i+1] - giftArray[i + 2+1] endif > 0) & (if giftArray[i + 1+1] - giftArray[i + 2+1] < 0 then -(giftArray[i + 1+1] - giftArray[i + 2+1]) else giftArray[i + 1+1] - giftArray[i + 2+1] endif <= 2 & if giftArray[i + 1+1] - giftArray[i + 2+1] < 0 then -(giftArray[i + 1+1] - giftArray[i + 2+1]) else giftArray[i + 1+1] - giftArray[i + 2+1] endif > 0)) then (     istrue := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (istrue) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Playoff2 {
  public static void main(String[] args){
    Scanner o=new Scanner(System.in);
    int t=o.nextInt();
    while(t-->0){
      int arr[]=new int[4];
      int max=0,prev=max ;
      for(int i=0 ; i<4 ; i++){
        arr[i]=o.nextInt();
        if(arr[i]>max)max=arr[i];
      }
      for(int i=0 ; i<4 ; i++){
        if(arr[i]>prev && arr[i]!=max)prev=arr[i];
      }
      if((arr[0]==max || arr[1]==max)&&(arr[2]==prev || arr[3]==prev)||(arr[0]==prev || arr[1]==prev)&&(arr[2]==max || arr[3]==max))System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Playoff2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : OclFile ; o := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := o.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var arr : Sequence(int) ; arr := Integer.subrange(1,4)->collect(0) ;
     var max : int ; max := 0 ;
    var prev : int ; prev := max ;
        var i : int ; i := 0 ; while i < 4 do ( (     arr[i+1] := o.getCurrent()->toInteger() ; 
     if (arr[i+1] > max) then     max := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 4 do ( (     if (arr[i+1] > prev & arr[i+1] /= max) then     prev := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
    if ((arr[0+1] = max or arr[1+1] = max) & (arr[2+1] = prev or arr[3+1] = prev) or (arr[0+1] = prev or arr[1+1] = prev) & (arr[2+1] = max or arr[3+1] = max)) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static boolean check(ArrayList<Integer>b){
    if(b.get(0)!=1){
      return false ;
    }
    for(int i=1 ; i<b.size(); i++){
      if(b.get(i-1)!=b.get(i)-1){
        return false ;
      }
    }
    return true ;
  }
  static boolean gap(ArrayList<Integer>b){
    for(int i=0 ; i<b.size(); i++){
      if(b.get(i)<=0){
        return false ;
      }
    }
    return true ;
  }
  static void removeGap(ArrayList<Integer>b){
    for(int i=0 ; i<b.size(); i++){
      if(b.get(i)<=0){
        b.remove(i);
        i--;
        continue ;
      }
    }
    b.trimToSize();
  }
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    ArrayList<Integer>list=new ArrayList<Integer>();
    while(true){
      int N=stdIn.nextInt();
      if(N==0){
        break ;
      }
      for(int i=0 ; i<N ; i++){
        list.add(stdIn.nextInt());
      }
      int c=0 ;
      while(! check(list)&& c<10000){
        c++;
        if(gap(list)){
          int size=list.size();
          for(int i=0 ; i<list.size(); i++){
            list.set(i,list.get(i)-1);
          }
          list.add(size);
        }
        removeGap(list);
      }
      System.out.println((check(list))? c :-1);
      list.clear();
      list.trimToSize();
      System.gc();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation check( b : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     if (b->at(0+1) /= 1) then (     return false ) else skip ; 
         var i : int ; i := 1 ; while i < b->size() do ( (     if (b->at(i - 1+1) /= b->at(i+1) - 1) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation gap( b : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < b->size() do ( (     if (b->at(i+1) <= 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation removeGap( b : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < b->size() do ( (     if (b->at(i+1) <= 0) then (     b := b->excludingAt(i+1) ; 
     i := i - 1 ; 
     continue ) else skip )  ;     i := i + 1 ) ; 
     b.trimToSize() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(int) ; list := Sequence{} ;
     while (true) do (     var N : int ; N := stdIn.getCurrent()->toInteger() ;
     if (N = 0) then (     break ) else skip ; 
        var i : int ; i := 0 ; while i < N do ( (     list := list->including(stdIn.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
    while (not(check(list)) & c < 10000) do (     c := c + 1 ; 
     if (gap(list)) then (     var size : int ; size := list->size() ;
         var i : int ; i := 0 ; while i < list->size() do ( (     list := list.setAt(i+1,list->at(i+1) - 1) )  ;     i := i + 1 ) ; 
     list := list->including(size) ) else skip ; 
     execute removeGap(list) ) ; 
    OclFile["System.out"].println(if (check(list)) then c else -1 endif) ; 
    list := list->intersection(Set{}) ; 
    list := list.trimToSize() ; 
gc() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    boolean[] tri=new boolean[1000001];
    for(int i=1 ; i*(i+1)>>1<=1000000 ; i++){
      tri[i*(i+1)>>1]=true ;
    }
    int[] a=new int[1000001];
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      int sum=0 ;
      for(int i=1 ; i<=n ; i++){
        a[i]=sc.nextInt();
        sum+=a[i];
      }
      if(tri[sum]){
        int res=0 ;
        int R=n ;
        boolean f=false ;
        while(res<=10000){
          f=true ;
          for(int i=1 ; i<=R && f ; i++)f &=i==a[i];
          if(f)break ;
          int L=1 ;
          for(int i=1 ; i<=R ; i++){
            if(a[i]==1)continue ;
            a[L++]=a[i]-1 ;
          }
          a[L]=R ;
          R=L ;
          res++;
        }
        if(f){
          System.out.println(res);
          continue ;
        }
      }
      System.out.println(-1);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tri : Sequence(boolean) ; tri := Integer.subrange(1,1000001)->collect(false) ;
        var i : int ; i := 1 ; while (i * (i + 1)/(2->pow(1)))->oclAsType(long) <= 1000000 do ( (     tri[(i * (i + 1)/(2->pow(1)))->oclAsType(long)+1] := true )  ;     i := i + 1 ) ; 
    var a : Sequence(int) ; a := Integer.subrange(1,1000001)->collect(0) ;
      while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    if (tri[sum+1]) then (     var res : int ; res := 0 ;
     var R : int ; R := n ;
    var f : boolean ; f := false ;
    while (res <= 10000) do (     f := true ; 
         var i : int ; i := 1 ; while i <= R & f do (     f := MathLib.bitwiseAnd(f, i = a[i+1]) ;  ;     i := i + 1 ) ; 
    if (f) then     break else skip ; 
    var L : int ; L := 1 ;
        var i : int ; i := 1 ; while i <= R do ( (     if (a[i+1] = 1) then     continue else skip ; 
      a[L+1] := a[i+1] - 1  ; L := L + 1 )  ;     i := i + 1 ) ; 
    a[L+1] := R ; 
    R := L ; 
    res := res + 1 ; 
 ) ; 
    if (f) then (     OclFile["System.out"].println(res) ; 
     continue ) else skip ; 
 ) else skip ; 
    OclFile["System.out"].println(-1) ; 
 )  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(true){
      int n=in.nextInt();
      if(n==0)break ;
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=in.nextInt();
      int res=0 ;
      while(! isFinish(arr)&& res<10000){
        res++;
        arr=doit(arr);
        arr=remove(arr);
      }
      if(res==10000)res=-1 ;
      System.out.println(""+res);
    }
  }
  static boolean isFinish(int[] arr){
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]!=i+1)return false ;
    }
    return true ;
  }
  static int[] remove(int[] arr){
    int c=0 ;
    for(int i : arr)if(i!=0)c++;
    int[] res=new int[c];
    int t=0 ;
    for(int i : arr)if(i!=0)res[t++]=i ;
    return res ;
  }
  static int[] doit(int[] arr){
    int[] res=new int[arr.length+1];
    for(int i=0 ; i<arr.length ; i++){
      res[i]=arr[i]-1 ;
    }
    res[arr.length]=arr.length ;
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    while (not(isFinish(arr)) & res < 10000) do (     res := res + 1 ; 
     arr := doit(arr) ; 
     arr := remove(arr) ) ; 
    if (res = 10000) then     res := -1 ; else skip ; 
    OclFile["System.out"].println("" + res) ; 
 ) );
  static   operation isFinish( arr : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] /= i + 1) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation remove( arr : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
     for (i : arr) do (     if (i /= 0) then     c := c + 1 ; else skip ;  ) ; 
    var res : Sequence(int) ; res := Integer.subrange(1,c)->collect(0) ;
    var t : int ; t := 0 ;
    for (i : arr) do (     if (i /= 0) then      res[t+1] := i  ; t := t + 1 ; else skip ;  ) ; 
    return res 
 );
  static   operation doit( arr : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,arr->size() + 1)->collect(0) ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     res[i+1] := arr[i+1] - 1 )  ;     i := i + 1 ) ; 
     res[arr->size()+1] := arr->size() ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class QQQ {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long t=in.nextLong();
    for(int i=0 ; i<t ; i++){
      long r=in.nextLong();
      long b=in.nextLong();
      long k=0 ;
      for(int j=0 ; j<r ; j++)k+=in.nextLong();
      System.out.println(k==b ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class QQQ {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : long ; t := in.getCurrent()->toLong() ;
         var i : int ; i := 0 ; while i < t do ( (     var r : long ; r := in.getCurrent()->toLong() ;
     var b : long ; b := in.getCurrent()->toLong() ;
    var k : long ; k := 0 ;
        var j : int ; j := 0 ; while j < r do (     k := k+(in.getCurrent()->toLong()) ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(if k = b then "YES" else "NO" endif) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static boolean isDivisible(String S){
    int n=S.length();
    if(S.charAt(n-1)!='5' && S.charAt(n-1)!='0')return false ;
    int sum=0 ;
    for(int i=0 ; i<S.length(); i++)sum+=(int)S.charAt(i);
    if(sum % 3==0)return true ;
    else return false ;
  }
  public static void main(String[] args){
    String S="15645746327462384723984023940239" ;
    if(isDivisible(S)==true)System.out.println("Yes");
    else System.out.println("No");
    String S1="15645746327462384723984023940235" ;
    if(isDivisible(S1)==true)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isDivisible( S : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := S->size() ;
     if (S->at(n - 1+1) /= '5' & S->at(n - 1+1) /= '0') then     return false else skip ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < S->size() do (     sum := sum+(S->at(i+1)->oclAsType(int)) ;  ;     i := i + 1 ) ; 
    if (sum mod 3 = 0) then     return true else     return false ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := "15645746327462384723984023940239" ;
     if (isDivisible(S) = true) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
     var S1 : String ; S1 := "15645746327462384723984023940235" ;
     if (isDivisible(S1) = true) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p142 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p142().run());
  }
  private boolean[] isSquare ;
  public String run(){
    int sumLimit=10 ;
    while(true){
      isSquare=new boolean[sumLimit];
      for(int i=0 ; i*i<sumLimit ; i++)isSquare[i*i]=true ;
      int sum=findSum(sumLimit);
      if(sum!=-1){
        sum=sumLimit ;
        break ;
      }
      sumLimit*=10 ;
    }
    while(true){
      int sum=findSum(sumLimit);
      if(sum==-1)return Integer.toString(sumLimit);
      sumLimit=sum ;
    }
  }
  private int findSum(int limit){
    for(int a=1 ; a*a<limit ; a++){
      for(int b=a-1 ; b>0 ; b--){
        if((a+b)% 2!=0)continue ;
        int x=(a*a+b*b)/2 ;
        int y=(a*a-b*b)/2 ;
        if(x+y+1>=limit)continue ;
        int zlimit=Math.min(y,limit-x-y);
        for(int c=Library.sqrt(y)+1 ; c*c-y<zlimit ; c++){
          int z=c*c-y ;
          if(isSquare[x+z] && isSquare[x-z] && isSquare[y-z])return x+y+z ;
        }
      }
    }
    return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p142 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p142.newp142().run()) );
   attribute isSquare : Sequence(boolean);
   operation run() : String
  pre: true
  post: true
  activity: (     var sumLimit : int ; sumLimit := 10 ;
     while (true) do (     isSquare := Integer.subrange(1,sumLimit)->collect(false) ; 
         var i : int ; i := 0 ; while i * i < sumLimit do (     isSquare[i * i+1] := true ;  ;     i := i + 1 ) ; 
    var sum : int ; sum := findSum(sumLimit) ;
    if (sum /= -1) then (     sum := sumLimit ; 
     break ) else skip ; 
    sumLimit := sumLimit*(10) ; 
 ) ; 
     while (true) do (     var sum : int ; sum := findSum(sumLimit) ;
     if (sum = -1) then     return ((sumLimit) + "") else skip ; 
     sumLimit := sum ) );
   operation findSum( limit : int) : int
  pre: true
  post: true
  activity: (         var a : int ; a := 1 ; while a * a < limit do ( (         var b : int ; b := a - 1 ; while b > 0 do ( (     if ((a + b) mod 2 /= 0) then     continue else skip ; 
     var x : int ; x := (a * a + b * b) / 2 ;
    var y : int ; y := (a * a - b * b) / 2 ;
    if (x + y + 1 >= limit) then     continue else skip ; 
    var zlimit : int ; zlimit := Set{y, limit - x - y}->min() ;
        var c : int ; c := Library.sqrt(y) + 1 ; while c * c - y < zlimit do ( (     var z : int ; z := c * c - y ;
     if (isSquare[x + z+1] & isSquare[x - z+1] & isSquare[y - z+1]) then     return x + y + z else skip )  ;     c := c + 1 ) ; 
 )  ;     b := b - 1 ) )  ;     a := a + 1 ) ; 
     return -1 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    long A=Long.parseLong(stdIn.next());
    long B=Long.parseLong(stdIn.next());
    long K=Long.parseLong(stdIn.next());
    long n=A-K ;
    if(A+B<=K){
      System.out.println("0 0");
    }
    else if(n<0){
      System.out.println("0 "+(A+B-K));
    }
    else {
      System.out.println(n+" "+B);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : long ; A := (stdIn.getCurrent())->toLong() ;
    var B : long ; B := (stdIn.getCurrent())->toLong() ;
    var K : long ; K := (stdIn.getCurrent())->toLong() ;
    var n : long ; n := A - K ;
    if (A + B <= K) then (     OclFile["System.out"].println("0 0") ) else     if (n < 0) then (     OclFile["System.out"].println("0 " + (A + B - K)) ) else (     OclFile["System.out"].println(n + " " + B) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedWriter ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.lang.reflect.Array ;
import java.math.BigDecimal ;
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Iterator ;
import java.util.List ;
import java.util.Map ;
import java.util.Random ;
import java.util.Map.Entry ;
import java.util.Objects ;
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.Stack ;
import java.util.TreeMap ;
import java.util.TreeSet ;
import static java.util.Comparator.*;
public class Main {
  public static void main(String[] args){
    PrintWriter out=new PrintWriter(System.out);
    Solver solver=new Solver(System.in,out);
    solver.solve();
    out.close();
  }
}
class Solver {
  Scanner sc ;
  PrintWriter out ;
  public Solver(InputStream in,PrintWriter out){
    sc=new Scanner(in);
    this.out=out ;
  }
  public void solve(){
    long A=Long.parseLong(sc.next());
    long B=Long.parseLong(sc.next());
    long K=Long.parseLong(sc.next());
    if(K<=A)out.println((A-K)+" "+B);
    else out.println("0 "+(K-A<=B ?(B-(K-A)): 0));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var solver : Solver ; solver := Solver.newSolver(OclFile["System.in"], out) ;
     solver.solve() ; 
     skip );
}
class Solver {
   attribute sc : OclFile;
   attribute out : OclFile;
   static operation newSolver( in : OclFile, out : OclFile) : Solver
  pre: true
  post: true
  activity:
  ( var self : Solver ;
    self := createSolver();
    self.initialise(in, out);
    return self );
  operation initialise( in : OclFile, out : OclFile) : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(in) ; 
     self.out := out );
   operation solve() : void
  pre: true
  post: true
  activity: (     var A : long ; A := (sc.getCurrent())->toLong() ;
     var B : long ; B := (sc.getCurrent())->toLong() ;
     var K : long ; K := (sc.getCurrent())->toLong() ;
     if (K <= A) then     skip ; else     skip ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long x=sc.nextInt();
    List<Long>sweet=new ArrayList<Long>();
    for(int i=0 ; i<N ; i++){
      long a=sc.nextInt();
      sweet.add(a);
    }
    Collections.sort(sweet);
    int num=0 ;
    for(int i=0 ; i<N ; i++){
      if(x-sweet.get(num)>=0){
        x=x-sweet.get(num);
        num++;
      }
      else {
        break ;
      }
    }
    if((num==N)&&(x>0)){
      num-=1 ;
    }
    System.out.println(num);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var x : long ; x := sc.getCurrent()->toInteger() ;
    var sweet : Sequence(long) ; sweet := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var a : long ; a := sc.getCurrent()->toInteger() ;
     sweet := sweet->including(a) )  ;     i := i + 1 ) ; 
    sweet := sweet->sort() ; 
    var num : int ; num := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (x - sweet->at(num+1) >= 0) then (     x := x - sweet->at(num+1) ; 
     num := num + 1 ) else (     break ) )  ;     i := i + 1 ) ; 
    if ((num = N) & (x > 0)) then (     num := num-(1) ) else skip ; 
    OclFile["System.out"].println(num) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String W=in.readLine();
    String[] Ws=W.split(" ");
    long A=Long.parseLong(Ws[0]);
    long B=Long.parseLong(Ws[1]);
    long K=Long.parseLong(Ws[2]);
    System.out.println(Math.max(0,A-K)+" "+Math.max(0,B-Math.max(0,K-A)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var W : String ; W := in.readLine() ;
    var Ws : Sequence(String) ; Ws := W->split(" ") ;
    var A : long ; A := (Ws[0+1])->toLong() ;
    var B : long ; B := (Ws[1+1])->toLong() ;
    var K : long ; K := (Ws[2+1])->toLong() ;
    OclFile["System.out"].println(Set{0, A - K}->max() + " " + Set{0, B - Set{0, K - A}->max()}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BGreedyTakahashi solver=new BGreedyTakahashi();
    solver.solve(1,in,out);
    out.close();
  }
  static class BGreedyTakahashi {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      long a=in.nextLong();
      long b=in.nextLong();
      long k=in.nextLong();
      out.println(Math.max(0,a-k)+" "+Math.min(Math.max(0,a+b-k),b));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BGreedyTakahashi ; solver := BGreedyTakahashi.newBGreedyTakahashi() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BGreedyTakahashi {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : long ; a := in.getCurrent()->toLong() ;
     var b : long ; b := in.getCurrent()->toLong() ;
     var k : long ; k := in.getCurrent()->toLong() ;
     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isVowel(char c){
    return(c=='a' || c=='e' || c=='i' || c=='o' || c=='u');
  }
  static String encryptString(String s,int n,int k){
    int countVowels=0 ;
    int countConsonants=0 ;
    String ans="" ;
    for(int l=0 ; l<=n-k ; l++){
      countVowels=0 ;
      countConsonants=0 ;
      for(int r=l ; r<=l+k-1 ; r++){
        if(isVowel(s.charAt(r))==true){
          countVowels++;
        }
        else {
          countConsonants++;
        }
      }
      ans+=String.valueOf(countVowels*countConsonants);
    }
    return ans ;
  }
  static public void main(String[] args){
    String s="hello" ;
    int n=s.length();
    int k=2 ;
    System.out.println(encryptString(s,n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isVowel( c : String) : boolean
  pre: true
  post: true
  activity: (     return (c = 'a' or c = 'e' or c = 'i' or c = 'o' or c = 'u') );
  static   operation encryptString( s : String, n : int, k : int) : String
  pre: true
  post: true
  activity: (     var countVowels : int ; countVowels := 0 ;
     var countConsonants : int ; countConsonants := 0 ;
    var ans : String ; ans := "" ;
        var l : int ; l := 0 ; while l <= n - k do ( (     countVowels := 0 ; 
     countConsonants := 0 ; 
         var r : int ; r := l ; while r <= l + k - 1 do ( (     if (isVowel(s->at(r+1)) = true) then (     countVowels := countVowels + 1 ) else (     countConsonants := countConsonants + 1 ) )  ;     r := r + 1 ) ; 
     ans := ans+(((countVowels * countConsonants) + "")) )  ;     l := l + 1 ) ; 
    return ans 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "hello" ;
     var n : int ; n := s->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(encryptString(s, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int N=in.nextInt();
      int M=in.nextInt();
      String S=in.next();
      String T=in.next();
      int gcdNM=gcd(N,M);
      long lcmNM=((long)N/gcd(N,M))*M ;
      int stepS=M/gcdNM ;
      int stepT=N/gcdNM ;
      int curS=0 ;
      int curT=0 ;
      boolean isExisted=true ;
      while(curS<S.length()&& curT<T.length()){
        int idxXS=curS*stepS+1 ;
        int idxXT=curT*stepT+1 ;
        if(idxXS==idxXT){
          if(S.charAt(curS)!=T.charAt(curT)){
            isExisted=false ;
            break ;
          }
          else {
++curS ;
++curT ;
          }
        }
        else if(idxXS<idxXT){
++curS ;
        }
        else if(idxXT<idxXS){
++curT ;
        }
      }
      if(isExisted){
        System.out.println(lcmNM);
      }
      else {
        System.out.println(-1);
      }
    }
  }
  public static int gcd(int a,int b){
    return b==0 ? a : gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var N : int ; N := in.getCurrent()->toInteger() ;
     var M : int ; M := in.getCurrent()->toInteger() ;
    var S : String ; S := in.getCurrent() ;
    var T : String ; T := in.getCurrent() ;
    var gcdNM : int ; gcdNM := gcd(N, M) ;
    var lcmNM : long ; lcmNM := (N->oclAsType(long) / gcd(N, M)) * M ;
    var stepS : int ; stepS := M / gcdNM ;
    var stepT : int ; stepT := N / gcdNM ;
    var curS : int ; curS := 0 ;
    var curT : int ; curT := 0 ;
    var isExisted : boolean ; isExisted := true ;
    while (curS < S->size() & curT < T->size()) do (     var idxXS : int ; idxXS := curS * stepS + 1 ;
     var idxXT : int ; idxXT := curT * stepT + 1 ;
     if (idxXS = idxXT) then (     if (S->at(curS+1) /= T->at(curT+1)) then (     isExisted := false ; 
     break ) else (     curS := curS + 1 ; 
     curT := curT + 1 ) ) else     if (idxXS < idxXT) then (     curS := curS + 1 ) else     if (idxXT < idxXS) then (     curT := curT + 1 ) else skip ; ;  ) ; 
    if (isExisted) then (     OclFile["System.out"].println(lcmNM) ) else (     OclFile["System.out"].println(-1) ) ;  
 ) );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static long gcd(long a,long b){
    long p=Math.max(a,b);
    long q=Math.min(a,b);
    long r=p % q ;
    while(r!=0){
      p=q ;
      q=r ;
      r=p % q ;
    }
    return q ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long m=sc.nextLong();
    String s=sc.next();
    String t=sc.next();
    long gcd=gcd(n,m);
    long lcm=m/gcd*n ;
    long a=n/gcd ;
    long b=m/gcd ;
    boolean flag=true ;
    for(int i=0 ; i<gcd ; i++){
      int index1=(int)(i*a);
      int index2=(int)(i*b);
      if(s.charAt(index1)!=t.charAt(index2)){
        flag=false ;
        break ;
      }
    }
    System.out.println(flag ? lcm :-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var p : long ; p := Set{a, b}->max() ;
     var q : long ; q := Set{a, b}->min() ;
    var r : long ; r := p mod q ;
    while (r /= 0) do (     p := q ; 
     q := r ; 
     r := p mod q ) ; 
    return q 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var m : long ; m := sc.getCurrent()->toLong() ;
    var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var gcd : long ; gcd := gcd(n, m) ;
    var lcm : long ; lcm := m / gcd * n ;
    var a : long ; a := n / gcd ;
    var b : long ; b := m / gcd ;
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < gcd do ( (     var index1 : int ; index1 := (i * a)->oclAsType(int) ;
     var index2 : int ; index2 := (i * b)->oclAsType(int) ;
     if (s->at(index1+1) /= t->at(index2+1)) then (     flag := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if flag then lcm else -1 endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.function.IntPredicate ;
import org.omg.CORBA.Current ;
import static java.lang.Math.abs ;
import java.math.BigInteger ;
public class omar {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int size=input.nextInt();
    int count=0 ;
    int[] arr=new int[size];
    for(int i=0 ; i<size ; i++){
      arr[i]=input.nextInt();
    }
    Arrays.sort(arr);
    for(int i=1 ; i<size-1 ; i++){
      if(arr[i]>arr[0] && arr[i]<arr[size-1]){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class omar {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var size : int ; size := input.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < size do ( (     arr[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := 1 ; while i < size - 1 do ( (     if (arr[i+1] > arr[0+1] & arr[i+1] < arr[size - 1+1]) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in),1);
    String s ;
    String[] sl ;
    s=r.readLine();
    sl=s.split(" ");
    long n=Integer.parseInt(sl[0]);
    long m=Integer.parseInt(sl[1]);
    s=r.readLine();
    String t=r.readLine();
    long v=gcd(n,m);
    long z=n*m/v ;
    for(long i=0 ; i<n*m ; i+=z){
      if(s.charAt((int)(i/m))!=t.charAt((int)(i/n))){
        System.out.println("-1");
        System.exit(0);
      }
    }
    System.out.println(z);
  }
  public static long gcd(long n,long m){
    long t ;
    if(n<m){
      t=n ;
      n=m ;
      m=t ;
    }
    while(m!=0){
      n %=m ;
      t=n ;
      n=m ;
      m=t ;
    }
    return n ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 1) ;
     var s : String ;
    var sl : Sequence(String) ;
    s := r.readLine() ; 
    sl := s->split(" ") ; 
    var n : long ; n := (sl[0+1])->toInteger() ;
    var m : long ; m := (sl[1+1])->toInteger() ;
    s := r.readLine() ; 
    var t : String ; t := r.readLine() ;
    var v : long ; v := gcd(n, m) ;
    var z : long ; z := n * m / v ;
        var i : long ; i := 0 ; while i < n * m do ( (     if (s->at((i / m)->oclAsType(int)+1) /= t->at((i / n)->oclAsType(int)+1)) then (     OclFile["System.out"].println("-1") ; 
 OclProcess.exit(0) ) else skip )  ;     i := i+(z) ) ; 
    OclFile["System.out"].println(z) ; 
 );
  static   operation gcd( n : long, m : long) : long
  pre: true
  post: true
  activity: (     var t : long ;
     if (n < m) then (     t := n ; 
     n := m ; 
     m := t ) else skip ; 
     while (m /= 0) do (     n := n mod m ; 
     t := n ; 
     n := m ; 
     m := t ) ; 
     return n );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    String s=sc.next();
    String t=sc.next();
    long lcm=(long)n/(long)gcd(n,m)*(long)m ;
    HashMap<Long,Character>mapS=new HashMap<>();
    HashMap<Long,Character>mapT=new HashMap<>();
    long tempn=lcm/n ;
    int k=0 ;
    for(long i=0 ; i<n ; i++){
      mapS.put(i*tempn+1l,s.charAt(k));
++k ;
    }
    long tempm=lcm/m ;
    k=0 ;
    for(long i=0 ; i<m ; i++){
      mapT.put(i*tempm+1l,t.charAt(k));
++k ;
    }
    for(long i : mapS.keySet()){
      if(mapS.get(i)!=null && mapT.get(i)!=null && mapS.get(i)!=mapT.get(i)){
        out.println(-1);
        exit(0);
      }
    }
    out.println(lcm);
  }
  static int gcd(int a,int b){
    int temp ;
    while((temp=a % b)!=0){
      a=b ;
      b=temp ;
    }
    return b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var lcm : long ; lcm := n->oclAsType(long) / gcd(n, m)->oclAsType(long) * m->oclAsType(long) ;
    var mapS : Map(long,String) ; mapS := Map{} ;
    var mapT : Map(long,String) ; mapT := Map{} ;
    var tempn : long ; tempn := lcm / n ;
    var k : int ; k := 0 ;
        var i : long ; i := 0 ; while i < n do ( (     mapS := mapS->union(Map{i * tempn + 1l |-> s->at(k+1)}) ; 
     k := k + 1 )  ;     i := i + 1 ) ; 
    var tempm : long ; tempm := lcm / m ;
    k := 0 ; 
        var i : long ; i := 0 ; while i < m do ( (     mapT := mapT->union(Map{i * tempm + 1l |-> t->at(k+1)}) ; 
     k := k + 1 )  ;     i := i + 1 ) ; 
    for (i : mapS->keys()) do ( (     if (mapS->at(i) /= null & mapT->at(i) /= null & mapS->at(i) /= mapT->at(i)) then (     out.println(-1) ; 
     execute exit(0) ) else skip )  ) ; 
    out.println(lcm) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var temp : int ;
         temp := a mod b ;
    while ((temp) /= 0) do (    skip ; (     a := b ; 
     b := temp ) ;     temp := a mod b ;
 ) ;  
     return b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import java.util.stream.*;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] $){
    int n=scanner.nextInt(),m=scanner.nextInt(),gcd=BigInteger.valueOf(n).gcd(BigInteger.valueOf(m)).intValue();
    String s=scanner.next(),t=scanner.next();
    System.out.println(IntStream.range(0,gcd).filter(k->s.charAt(k*n/gcd)!=t.charAt(k*m/gcd)).mapToLong(k->-1).findAny().orElse(BigInteger.valueOf(n).multiply(BigInteger.valueOf(m)).divide(BigInteger.valueOf(gcd)).longValue()));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var gcd : int ; gcd := (n + "")->toLong().gcd((m + "")->toLong())->oclAsType(int) ;
     var s : String ; s := scanner.getCurrent() ;
    var t : String ; t := scanner.getCurrent() ;
     OclFile["System.out"].println(Integer.subrange(0, gcd-1)->select( _x1 | (lambda k : OclAny in s->at(k * n / gcd+1) /= t->at(k * m / gcd+1))->apply(_x1) )->collect( _x1 | (lambda k : OclAny in -1)->apply(_x1) )->any(true).orElse((n + "")->toLong().multiply((m + "")->toLong()).divide((gcd + "")->toLong())->oclAsType(long))) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.System.in ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    Arrays.sort(a);
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      x-=a[i];
      if(x<0)break ;
      else ans++;
    }
    if(x>0)ans--;
    PrintWriter out=new PrintWriter(System.out);
    out.println(ans);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x := x-(a[i+1]) ; 
     if (x < 0) then     break else     ans := ans + 1 ; )  ;     i := i + 1 ) ; 
    if (x > 0) then     ans := ans - 1 ; else skip ; 
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B203 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int M=in.nextInt();
    int[][] black=new int[N+2][N+2];
    for(int m=1 ; m<=M ; m++){
      int x=in.nextInt();
      int y=in.nextInt();
      for(int xx=x-1 ; xx<=x+1 ; xx++){
        for(int yy=y-1 ; yy<=y+1 ; yy++){
          if(++black[xx][yy]==9){
            System.out.println(m);
            return ;
          }
        }
      }
    }
    System.out.println("-1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class B203 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var M : int ; M := in.getCurrent()->toInteger() ;
    var black : Sequence(Sequence(int)) ; black := Integer.subrange(1,N + 2)->collect(Integer.subrange(1,N + 2)->collect(0)) ;
        var m : int ; m := 1 ; while m <= M do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var y : int ; y := in.getCurrent()->toInteger() ;
         var xx : int ; xx := x - 1 ; while xx <= x + 1 do ( (         var yy : int ; yy := y - 1 ; while yy <= y + 1 do ( (     if ((black[xx+1][yy+1] + 1) = 9) then (     OclFile["System.out"].println(m) ; 
     return ) else skip )  ;     yy := yy + 1 ) )  ;     xx := xx + 1 ) )  ;     m := m + 1 ) ; 
    OclFile["System.out"].println("-1") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B203 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int M=in.nextInt();
    int[][] black=new int[N+2][N+2];
    for(int m=1 ; m<=M ; m++){
      int x=in.nextInt();
      int y=in.nextInt();
      for(int xx=x-1 ; xx<=x+1 ; xx++){
        for(int yy=y-1 ; yy<=y+1 ; yy++){
          if(++black[xx][yy]==9){
            System.out.println(m);
            return ;
          }
        }
      }
    }
    System.out.println("-1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class B203 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var M : int ; M := in.getCurrent()->toInteger() ;
    var black : Sequence(Sequence(int)) ; black := Integer.subrange(1,N + 2)->collect(Integer.subrange(1,N + 2)->collect(0)) ;
        var m : int ; m := 1 ; while m <= M do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var y : int ; y := in.getCurrent()->toInteger() ;
         var xx : int ; xx := x - 1 ; while xx <= x + 1 do ( (         var yy : int ; yy := y - 1 ; while yy <= y + 1 do ( (     if ((black[xx+1][yy+1] + 1) = 9) then (     OclFile["System.out"].println(m) ; 
     return ) else skip )  ;     yy := yy + 1 ) )  ;     xx := xx + 1 ) )  ;     m := m + 1 ) ; 
    OclFile["System.out"].println("-1") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int dx[]={
      1,1,0,-1,};
      int dy[]={
        0,1,1,1 };
        Scanner in=new Scanner(System.in);
        for(; ; ){
          int n=in.nextInt();
          if(n==0)return ;
          int a[][]=new int[n][n];
          int ans=0 ;
          for(int i=0 ; i<n ; i++){
            String s=in.next();
            for(int j=0 ; j<n ; j++)a[i][j]=Integer.valueOf(s.charAt(j)-'0');
          }
          for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++){
            for(int k=0 ; k<4 ; k++){
              int cnt=0 ;
              int sy=i ;
              int sx=j ;
              while(0<=sx && sx<n && sy<n && a[sy][sx]==1){
                cnt++;
                sx+=dx[k];
                sy+=dy[k];
              }
              ans=Math.max(ans,cnt);
            }
          }
          System.out.println(ans);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var dx : Sequence(int) ; dx := Sequence{1,1,0,-1,} ;
     var dy : Sequence(int) ; dy := Sequence{0,1,1,1} ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := in.getCurrent() ;
         var j : int ; j := 0 ; while j < n do (     a[i+1][j+1] := (s->at(j+1) - ('0')->char2byte())->toInteger() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do ( (         var k : int ; k := 0 ; while k < 4 do ( (     var cnt : int ; cnt := 0 ;
     var sy : int ; sy := i ;
    var sx : int ; sx := j ;
    while (0 <= sx & sx < n & sy < n & a[sy+1][sx+1] = 1) do (     cnt := cnt + 1 ; 
     sx := sx+(dx[k+1]) ; 
     sy := sy+(dy[k+1]) ) ; 
    ans := Set{ans, cnt}->max() ; 
 )  ;     k := k + 1 ) )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  int D[][];
  final int dir[][]={
    {
      1,0 },{
        1,1 },{
          0,1 },{
-1,1 }
          };
          int N ;
          BufferedReader input ;
          int ni()throws Exception {
            return Integer.parseInt(input.readLine());
          }
          String ns()throws Exception {
            return input.readLine();
          }
          int search(int i,int j,int d){
            if(i<0 || i>=N || j<0 || j>=N || D[i][j]==0)return 0 ;
            else return 1+search(i+dir[d][0],j+dir[d][1],d);
          }
          int solve(){
            int max=0 ;
            for(int i=0 ; i<N ; ++i){
              for(int j=0 ; j<N ; ++j){
                for(int d=0 ; d<4 ; ++d){
                  int k=search(i,j,d);
                  max=max>k ? max : k ;
                }
              }
            }
            return max ;
          }
          void setD()throws Exception {
            D=new int[N][N];
            for(int i=0 ; i<N ; ++i){
              String s=ns();
              for(int j=0 ; j<N ; ++j){
                char c=s.charAt(j);
                if(c=='1')D[i][j]=1 ;
                else if(c=='0')D[i][j]=0 ;
              }
            }
          }
          void io(){
            input=new BufferedReader(new InputStreamReader(System.in));
            while(true){
              try {
                N=ni();
                if(N==0)break ;
                setD();
                System.out.println(solve());
              }
              catch(Exception e){
                e.printStackTrace();
              }
            }
          }
          public static void main(String[] args){
            new Main().io();
          }
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute D : Sequence(Sequence(int));
   attribute dir : int := Sequence{Sequence{1,0},Sequence{1,1},Sequence{0,1},Sequence{-1,1}};
   attribute N : int;
   attribute input : OclFile;
   operation ni() : int
  pre: true
  post: true
  activity: (     return (input.readLine())->toInteger() );
   operation ns() : String
  pre: true
  post: true
  activity: (     return input.readLine() );
   operation search( i : int, j : int, d : int) : int
  pre: true
  post: true
  activity: (     if (i < 0 or i >= N or j < 0 or j >= N or D[i+1][j+1] = 0) then     return 0 else     return 1 + search(i + dir[d+1][0+1], j + dir[d+1][1+1], d) );
   operation solve() : int
  pre: true
  post: true
  activity: (     var max : int ; max := 0 ;
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (         var d : int ; d := 0 ; while d < 4 do ( (     var k : int ; k := search(i, j, d) ;
     max := if max > k then max else k endif )  ;     d := d + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return max );
   operation setD() : void
  pre: true
  post: true
  activity: (     D := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ; 
         var i : int ; i := 0 ; while i < N do ( (     var s : String ; s := ns() ;
         var j : int ; j := 0 ; while j < N do ( (     var c : String ; c := s->at(j+1) ;
     if (c = '1') then     D[i+1][j+1] := 1 ; else     if (c = '0') then     D[i+1][j+1] := 0 ; else skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
   operation io() : void
  pre: true
  post: true
  activity: (     input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     while (true) do (     try (     N := ni() ; 
     if (N = 0) then     break else skip ; 
     execute setD() ; 
     OclFile["System.out"].println(solve()) )   catch (e : ProgramException) do (     e.printStackTrace() )
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().io() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  static int maxCount ;
  static void exec(int x,int y,final int dx,final int dy,final int n,final String[] map){
    int count=0 ;
    while(0<=x && x<n && 0<=y && y<n){
      if(map[y] .charAt(x)=='0'){
        if(maxCount<count){
          maxCount=count ;
        }
        count=0 ;
      }
      else {
        count=count+1 ;
      }
      x+=dx ;
      y+=dy ;
    }
    if(maxCount<count){
      maxCount=count ;
    }
  }
  public static void main(String[] args){
    final Scanner stdin=new Scanner(System.in);
    while(true){
      final int n=Integer.parseInt(stdin.nextLine());
      if(n==0){
        break ;
      }
      String[] map=new String[n];
      for(int i=0 ; i<n ; i++){
        map[i]=stdin.nextLine();
      }
      maxCount=0 ;
      for(int c=0 ; c<n ; c++){
        exec(c,0,0,1,n,map);
        exec(0,c,1,0,n,map);
        exec(0,c,1,1,n,map);
        exec(0,c,1,-1,n,map);
        exec(c,0,1,1,n,map);
        exec(c,n-1,1,-1,n,map);
      }
      System.out.println(maxCount);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute maxCount : int;
  static   operation exec( x : int, y : int, dx : int, dy : int, n : int, map : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (0 <= x & x < n & 0 <= y & y < n) do (     if (map[y+1]->at(x+1) = '0') then (     if (maxCount < count) then (     maxCount := count ) else skip ; 
     count := 0 ) else (     count := count + 1 ) ;  
     x := x+(dx) ; 
     y := y+(dy) ) ; 
     if (maxCount < count) then (     maxCount := count ) else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := (stdin.nextLine())->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var map : Sequence(String) ; map := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     map[i+1] := stdin.nextLine() )  ;     i := i + 1 ) ; 
    maxCount := 0 ; 
        var c : int ; c := 0 ; while c < n do ( (     execute exec(c, 0, 0, 1, n, map) ; 
     execute exec(0, c, 1, 0, n, map) ; 
    execute exec(0, c, 1, 1, n, map) ; 
    execute exec(0, c, 1, -1, n, map) ; 
    execute exec(c, 0, 1, 1, n, map) ; 
    execute exec(c, n - 1, 1, -1, n, map) ; 
 )  ;     c := c + 1 ) ; 
    OclFile["System.out"].println(maxCount) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static boolean[][] field ;
  static int n ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(true){
      n=in.nextInt();
      if(n==0)break ;
      int res=0 ;
      field=new boolean[n][n];
      for(int i=0 ; i<n ; i++){
        String str=in.next();
        char[] m=str.toCharArray();
        for(int j=0 ; j<n ; j++){
          field[i][j]=(m[j]=='1')? true : false ;
        }
      }
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          if(field[i][j]){
            res=Math.max(res,countSystem(i,j));
          }
        }
      }
      System.out.println(res);
    }
  }
  static int countSystem(int y,int x){
    int res=0 ;
    int dy[]={
-1,-1,0,1,1,1,1,0,-1 },dx[]={
        0,1,1,1,0,-1,-1,-1 };
        for(int i=0 ; i<8 ; i++){
          res=Math.max(res,1+countOne(y,x,dy[i],dx[i]));
        }
        return res ;
      }
      static int countOne(int y,int x,int dy,int dx){
        int py=y,px=x,res=0 ;
        while(true){
          if(py+dy>=0 && py+dy<n && px+dx>=0 && px+dx<n && field[py+dy][px+dx]){
            py+=dy ;
            px+=dx ;
          }
          else break ;
          res++;
        }
        return res ;
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute field : Sequence(Sequence(boolean));
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     n := in.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
    var res : int ; res := 0 ;
    field := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ; 
        var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := in.getCurrent() ;
     var m : Sequence(String) ; m := str->characters() ;
         var j : int ; j := 0 ; while j < n do ( (     field[i+1][j+1] := if (m[j+1] = '1') then true else false endif )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (field[i+1][j+1]) then (     res := Set{res, countSystem(i, j)}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 ) );
  static   operation countSystem( y : int, x : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     var dy : Sequence(int) ; dy := Sequence{-1,-1,0,1,1,1,1,0,-1} ;
    var dx : Sequence(void) ; dx := Sequence{0,1,1,1,0,-1,-1,-1} ;
         var i : int ; i := 0 ; while i < 8 do ( (     res := Set{res, 1 + countOne(y, x, dy[i+1], dx[i+1])}->max() )  ;     i := i + 1 ) ; 
     return res );
  static   operation countOne( y : int, x : int, dy : int, dx : int) : int
  pre: true
  post: true
  activity: (     var py : int ; py := y ;
    var px : int ; px := x ;
    var res : int ; res := 0 ;
     while (true) do (     if (py + dy >= 0 & py + dy < n & px + dx >= 0 & px + dx < n & field[py + dy+1][px + dx+1]) then (     py := py+(dy) ; 
     px := px+(dx) ) else     break ;  
     res := res + 1 ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr);
    int count=0 ;
    for(int i=1 ; i<arr.length ; i++){
      if(arr[i]>arr[0] && arr[i]<arr[arr.length-1]){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < arr->size() do ( (     if (arr[i+1] > arr[0+1] & arr[i+1] < arr[arr->size() - 1+1]) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static long fourthPowerSum(int n){
    return((6*n*n*n*n*n)+(15*n*n*n*n)+(10*n*n*n)-n)/30 ;
  }
  public static void main(String[] args){
    int n=6 ;
    System.out.println(fourthPowerSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fourthPowerSum( n : int) : long
  pre: true
  post: true
  activity: (     return ((6 * n * n * n * n * n) + (15 * n * n * n * n) + (10 * n * n * n) - n) / 30 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(fourthPowerSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class GFG {
  public static int maxLengthSub(int[] arr){
    int max_val=0 ;
    int start=0 ;
    HashMap<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<arr.length ; i++){
      int temp=0 ;
      if(map.containsKey(arr[i]-1)){
        temp=map.get(arr[i]-1);
      }
      if(map.containsKey(arr[i])){
        temp=Math.max(temp,map.get(arr[i]));
      }
      if(map.containsKey(arr[i]+1)){
        temp=Math.max(temp,map.get(arr[i]+1));
      }
      temp++;
      if(temp>max_val){
        max_val=temp ;
      }
      map.put(arr[i],temp);
    }
    return max_val ;
  }
  public static void main(String[] args){
    int arr[]={
      2,5,6,3,7,6,5,8 };
      System.out.println(maxLengthSub(arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxLengthSub( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var max_val : int ; max_val := 0 ;
     var start : int ; start := 0 ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     var temp : int ; temp := 0 ;
     if (map->keys()->includes(arr[i+1] - 1)) then (     temp := map->at(arr[i+1] - 1) ) else skip ; 
    if (map->keys()->includes(arr[i+1])) then (     temp := Set{temp, map->at(arr[i+1])}->max() ) else skip ; 
    if (map->keys()->includes(arr[i+1] + 1)) then (     temp := Set{temp, map->at(arr[i+1] + 1)}->max() ) else skip ; 
    temp := temp + 1 ; 
    if (temp > max_val) then (     max_val := temp ) else skip ; 
    map := map->union(Map{arr[i+1] |-> temp}) ; 
 )  ;     i := i + 1 ) ; 
    return max_val 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,5,6,3,7,6,5,8} ;
     OclFile["System.out"].println(maxLengthSub(arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int count=0 ;
    int x=scn.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<a.length ; ++i){
      a[i]=scn.nextInt();
    }
    long sum=0 ;
    for(int i=0 ; i<a.length ; ++i){
      sum=sum+a[i];
    }
    if(sum<x){
      System.out.println(n-1);
    }
    else if(sum==x){
      System.out.println(n);
    }
    else {
      Arrays.sort(a);
      for(int i=0 ; i<a.length ; ++i){
        if(x>=a[i]){
          x=x-a[i];
          count=count+1 ;
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var x : int ; x := scn.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := scn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < a->size() do ( (     sum := sum + a[i+1] )  ;     i := i + 1 ) ; 
    if (sum < x) then (     OclFile["System.out"].println(n - 1) ) else     if (sum = x) then (     OclFile["System.out"].println(n) ) else (     a := a->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do ( (     if (x >= a[i+1]) then (     x := x - a[i+1] ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static void rearrange(int[] arr){
    if(arr==null || arr.length % 2==1)return ;
    int currIdx=(arr.length-1)/2 ;
    while(currIdx>0){
      int count=currIdx,swapIdx=currIdx ;
      while(count-->0){
        int temp=arr[swapIdx+1];
        arr[swapIdx+1]=arr[swapIdx];
        arr[swapIdx]=temp ;
        swapIdx++;
      }
      currIdx--;
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,3,5,2,4,6 };
      rearrange(arr);
      for(int i=0 ; i<arr.length ; i++)System.out.print(" "+arr[i]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation rearrange( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (arr = null or arr->size() mod 2 = 1) then     return else skip ; 
     var currIdx : int ; currIdx := (arr->size() - 1) / 2 ;
     while (currIdx > 0) do (     var count : int ; count := currIdx ;
    var swapIdx : int ; swapIdx := currIdx ;
         while (count > 0) do (        count := count - 1 ;     skip ; (     var temp : int ; temp := arr[swapIdx + 1+1] ;
     arr[swapIdx + 1+1] := arr[swapIdx+1] ; 
     arr[swapIdx+1] := temp ; 
     swapIdx := swapIdx + 1 ) ;  ) ;  
     currIdx := currIdx - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,5,2,4,6} ;
     execute rearrange(arr) ; 
         var i : int ; i := 0 ; while i < arr->size() do (     OclFile["System.out"].print(" " + arr[i+1]) ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int a,b ;
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    while(true){
      a=s.nextInt();
      b=s.nextInt();
      if(a==0)System.exit(0);
      int[][] map=new int[a+1][a+1];
      for(int i=1 ; i<=a ; i++){
        for(int j=1 ; j<=a ; j++){
          map[i][j]=1<<25 ;
          if(i==j)map[i][j]=0 ;
        }
      }
      for(int n=0 ; n<b ; n++){
        int c=s.nextInt();
        if(c==1){
          int p=s.nextInt();
          int q=s.nextInt();
          int w=s.nextInt();
          if(map[p][q]<=w)continue ;
          map[p][q]=w ;
          map[q][p]=w ;
          for(int k=1 ; k<=a ; k++){
            for(int i=1 ; i<=a ; i++){
              for(int j=1 ; j<=a ; j++){
                if(map[i][j]>map[i][k]+map[k][j]){
                  map[i][j]=map[i][k]+map[k][j];
                }
              }
            }
          }
        }
        else {
          int x=s.nextInt();
          int y=s.nextInt();
          if(map[x][y]==1<<25){
            System.out.println(-1);
          }
          else {
            System.out.println(map[x][y]);
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     a := s.getCurrent()->toInteger() ; 
     b := s.getCurrent()->toInteger() ; 
    if (a = 0) then OclProcess.exit(0) ; else skip ; 
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,a + 1)->collect(Integer.subrange(1,a + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= a do ( (         var j : int ; j := 1 ; while j <= a do ( (     map[i+1][j+1] := (1*(2->pow(25)))->oclAsType(long) ; 
     if (i = j) then     map[i+1][j+1] := 0 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var n : int ; n := 0 ; while n < b do ( (     var c : int ; c := s.getCurrent()->toInteger() ;
     if (c = 1) then (     var p : int ; p := s.getCurrent()->toInteger() ;
     var q : int ; q := s.getCurrent()->toInteger() ;
    var w : int ; w := s.getCurrent()->toInteger() ;
    if (map[p+1][q+1] <= w) then     continue else skip ; 
    map[p+1][q+1] := w ; 
    map[q+1][p+1] := w ; 
        var k : int ; k := 1 ; while k <= a do ( (         var i : int ; i := 1 ; while i <= a do ( (         var j : int ; j := 1 ; while j <= a do ( (     if (map[i+1][j+1] > map[i+1][k+1] + map[k+1][j+1]) then (     map[i+1][j+1] := map[i+1][k+1] + map[k+1][j+1] ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
 ) else (     var x : int ; x := s.getCurrent()->toInteger() ;
     var y : int ; y := s.getCurrent()->toInteger() ;
     if (map[x+1][y+1] = (1*(2->pow(25)))->oclAsType(long)) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(map[x+1][y+1]) ) ) )  ;     n := n + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static void countCharacterType(String str){
    int vowels=0,consonant=0,specialChar=0,digit=0 ;
    for(int i=0 ; i<str.length(); i++){
      char ch=str.charAt(i);
      if((ch>='a' && ch<='z')||(ch>='A' && ch<='Z')){
        ch=Character.toLowerCase(ch);
        ;
        if(ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u')vowels++;
        else consonant++;
      }
      else if(ch>='0' && ch<='9')digit++;
      else specialChar++;
    }
    System.out.println("Vowels: "+vowels);
    System.out.println("Consonant: "+consonant);
    System.out.println("Digit: "+digit);
    System.out.println("Special Character: "+specialChar);
  }
  static public void main(String[] args){
    String str="geeks for geeks121" ;
    countCharacterType(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countCharacterType( str : String) : void
  pre: true
  post: true
  activity: (     var vowels : int ; vowels := 0 ;
    var consonant : int ; consonant := 0 ;
    var specialChar : int ; specialChar := 0 ;
    var digit : int ; digit := 0 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     var ch : String ; ch := str->at(i+1) ;
     if ((ch >= 'a' & ch <= 'z') or (ch >= 'A' & ch <= 'Z')) then (     ch := (ch + "")->toLowerCase() ; 
     if (ch = 'a' or ch = 'e' or ch = 'i' or ch = 'o' or ch = 'u') then     vowels := vowels + 1 ; else     consonant := consonant + 1 ; ) else     if (ch >= '0' & ch <= '9') then     digit := digit + 1 else     specialChar := specialChar + 1 ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Vowels: " + vowels) ; 
    OclFile["System.out"].println("Consonant: " + consonant) ; 
    OclFile["System.out"].println("Digit: " + digit) ; 
    OclFile["System.out"].println("Special Character: " + specialChar) ; 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeks for geeks121" ;
     execute countCharacterType(str) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double increaseInVol(double l,double b,double h){
    double percentInc=(1+(l/100))*(1+(b/100))*(1+(h/100));
    percentInc-=1 ;
    percentInc*=100 ;
    return percentInc ;
  }
  public static void main(String[] args){
    double l=50,b=20,h=10 ;
    System.out.println(increaseInVol(l,b,h)+"%");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation increaseInVol( l : double, b : double, h : double) : double
  pre: true
  post: true
  activity: (     var percentInc : double ; percentInc := (1 + (l / 100)) * (1 + (b / 100)) * (1 + (h / 100)) ;
     percentInc := percentInc-(1) ; 
     percentInc := percentInc*(100) ; 
     return percentInc );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : double ; l := 50 ;
    var b : double ; b := 20 ;
    var h : double ; h := 10 ;
     OclFile["System.out"].println(increaseInVol(l, b, h) + "%") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Arrays ;
class GFG {
  static int MaxTotalRectangleArea(int[] a,int n){
    Arrays.sort(a);
    int sum=0 ;
    boolean flag=false ;
    int len=0 ;
    for(int i=0 ; i<n ; i++){
      if((a[i]==a[i+1] || a[i]-a[i+1]==1)&& ! flag){
        flag=true ;
        len=a[i+1];
        i++;
      }
      else if((a[i]==a[i+1] || a[i]-a[i+1]==1)&&(flag)){
        sum=sum+a[i+1]*len ;
        flag=false ;
        i++;
      }
    }
    return sum ;
  }
  public static void main(String args[]){
    int[] a={
      10,10,10,10,11,10,11,10,9,9,8,8 };
      int n=a.length ;
      System.out.print(MaxTotalRectangleArea(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MaxTotalRectangleArea( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var sum : int ; sum := 0 ;
    var flag : boolean ; flag := false ;
    var len : int ; len := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if ((a[i+1] = a[i + 1+1] or a[i+1] - a[i + 1+1] = 1) & not(flag)) then (     flag := true ; 
     len := a[i + 1+1] ; 
     i := i + 1 ) else     if ((a[i+1] = a[i + 1+1] or a[i+1] - a[i + 1+1] = 1) & (flag)) then (     sum := sum + a[i + 1+1] * len ; 
     flag := false ; 
     i := i + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{10,10,10,10,11,10,11,10,9,9,8,8} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(MaxTotalRectangleArea(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    int max=Integer.MIN_VALUE ;
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]<min)min=arr[i];
      if(arr[i]>max)max=arr[i];
    }
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]>min && arr[i]<max){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] < min) then     min := arr[i+1] ; else skip ; 
     if (arr[i+1] > max) then     max := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] > min & arr[i+1] < max) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=scan.nextInt();
    long x=scan.nextLong();
    long[] a=new long[N];
    for(int i=0 ; i<N ; i++){
      a[i]=scan.nextLong();
    }
    Arrays.sort(a);
    int answer=0 ;
    for(int i=0 ; i<N ; i++){
      if(i==N-1){
        if(a[i]==x){
          answer+=1 ;
        }
        break ;
      }
      if(a[i]<=x){
        answer+=1 ;
        x-=a[i];
        continue ;
      }
      break ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var x : long ; x := scan.getCurrent()->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := scan.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var answer : int ; answer := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (i = N - 1) then (     if (a[i+1] = x) then (     answer := answer+(1) ) else skip ; 
     break ) else skip ; 
     if (a[i+1] <= x) then (     answer := answer+(1) ; 
     x := x-(a[i+1]) ; 
     continue ) else skip ; 
     break )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static void lastFiveDigits(int n){
    n=(n/10000)*10000+((n/100)% 10)*1000+(n % 10)*100+((n/10)% 10)*10+(n/1000)% 10 ;
    int ans=1 ;
    for(int i=0 ; i<5 ; i++){
      ans*=n ;
      ans %=100000 ;
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    int n=12345 ;
    lastFiveDigits(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation lastFiveDigits( n : int) : void
  pre: true
  post: true
  activity: (     n := (n / 10000) * 10000 + ((n / 100) mod 10) * 1000 + (n mod 10) * 100 + ((n / 10) mod 10) * 10 + (n / 1000) mod 10 ; 
     var ans : int ; ans := 1 ;
         var i : int ; i := 0 ; while i < 5 do ( (     ans := ans*(n) ; 
     ans := ans mod 100000 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12345 ;
     execute lastFiveDigits(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p080 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p080().run());
  }
  public String run(){
    int sum=0 ;
    for(int i=1 ; i<=100 ; i++){
      BigInteger x=BigInteger.valueOf(i);
      x=x.multiply(BigInteger.TEN.pow(100*2));
      BigInteger y=sqrt(x);
      if(! y.multiply(y).equals(x)){
        String s=y.toString().substring(0,100);
        for(int j=0 ; j<s.length(); j++)sum+=s.charAt(j)-'0' ;
      }
    }
    return Integer.toString(sum);
  }
  private static BigInteger sqrt(BigInteger x){
    int i=0 ;
    while(BigInteger.TEN.pow(i*2).compareTo(x)<=0)i++;
    BigInteger y=BigInteger.ZERO ;
    for(; i>=0 ; i--){
      int j ;
      BigInteger delta=null ;
      for(j=9 ; j>=0 ; j--){
        BigInteger temp=BigInteger.valueOf(j).multiply(BigInteger.TEN.pow(i));
        delta=y.shiftLeft(1).add(temp).multiply(temp);
        if(delta.compareTo(x)<=0)break ;
      }
      if(j<0)throw new AssertionError();
      x=x.subtract(delta);
      y=y.add(BigInteger.valueOf(j).multiply(BigInteger.TEN.pow(i)));
    }
    return y ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class p080 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p080.newp080().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= 100 do ( (     var x : long ; x := (i + "")->toLong() ;
     x := x.multiply(10.pow(100 * 2)) ; 
     var y : long ; y := sqrt(x) ;
     if (not(y.multiply(y) = x)) then (     var s : String ; s := y+"".subrange(0+1,100) ;
         var j : int ; j := 0 ; while j < s->size() do (     sum := sum+(s->at(j+1) - ('0')->char2byte()) ;  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
     return ((sum) + "") );
  static   operation sqrt( x : long) : long
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     while (10.pow(i * 2)->compareTo(x) <= 0) do     i := i + 1 ; ; 
    var y : long ; y := 0 ;
      while i >= 0 do ( (     var j : int ;
     var delta : long ; delta := null ;
        j := 9 ; while j >= 0 do ( (     var temp : long ; temp := (j + "")->toLong().multiply(10.pow(i)) ;
     delta := y.shiftLeft(1)->excludes(temp).multiply(temp) ; 
     if (delta->compareTo(x) <= 0) then     break else skip )  ;     j := j - 1 ) ; 
    if (j < 0) then     error AssertionException() ; else skip ; 
    x := x.subtract(delta) ; 
    y := y->excludes((j + "")->toLong().multiply(10.pow(i))) ; 
 )  ;     i := i - 1 ) ; 
    return y 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void evaluate(int n){
    if(n==1 || n==2)System.out.println("No Pythagoras "+"Triplet exists");
    else if(n % 2==0){
      int var=1*n*n/4 ;
      System.out.print("Pythagoras Triplets "+"exist i.e.");
      System.out.print(n+" ");
      System.out.print(var-1+" ");
      System.out.println(var+1+" ");
    }
    else if(n % 2!=0){
      int var=1*n*n+1 ;
      System.out.print("Pythagoras Triplets "+"exist i.e.");
      System.out.print(n+" ");
      System.out.print(var/2-1+" ");
      System.out.println(var/2+" ");
    }
  }
  public static void main(String[] args){
    int n=22 ;
    evaluate(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation evaluate( n : int) : void
  pre: true
  post: true
  activity: (     if (n = 1 or n = 2) then     OclFile["System.out"].println("No Pythagoras " + "Triplet exists") ; else     if (n mod 2 = 0) then (     var var : int ; var := 1 * n * n / 4 ;
     OclFile["System.out"].print("Pythagoras Triplets " + "exist i.e.") ; 
    OclFile["System.out"].print(n + " ") ; 
    OclFile["System.out"].print(var - 1 + " ") ; 
    OclFile["System.out"].println(var + 1 + " ") ; 
 ) else     if (n mod 2 /= 0) then (     var var : int ; var := 1 * n * n + 1 ;
     OclFile["System.out"].print("Pythagoras Triplets " + "exist i.e.") ; 
    OclFile["System.out"].print(n + " ") ; 
    OclFile["System.out"].print(var / 2 - 1 + " ") ; 
    OclFile["System.out"].println(var / 2 + " ") ; 
 ) else skip ; ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 22 ;
     execute evaluate(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    long a=sc.nextLong();
    long b=sc.nextLong();
    long x=sc.nextLong();
    long count=0 ;
    count+=b/x+1 ;
    if(a!=0){
      count-=(a-1)/x+1 ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var x : long ; x := sc.getCurrent()->toLong() ;
    var count : long ; count := 0 ;
    count := count+(b / x + 1) ; 
    if (a /= 0) then (     count := count-((a - 1) / x + 1) ) else skip ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.List ;
class Main {
  public static void main(final String[] args)throws Exception {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
){
      List<String>input=Arrays.asList(br.readLine().split(" "));
      long a=Long.parseLong(input.get(0));
      long b=Long.parseLong(input.get(1));
      long x=Long.parseLong(input.get(2));
      long ans=b/x-a/x ;
      if(a % x==0)ans++;
      System.out.println(ans);
    }
    catch(IOException | NumberFormatException e){
      e.printStackTrace();
      System.exit(0);
    }
    catch(final Exception e){
      e.printStackTrace();
      System.exit(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var input : Sequence(String) ; input := br.readLine()->split(" ") ;
     var a : long ; a := (input->at(0+1))->toLong() ;
    var b : long ; b := (input->at(1+1))->toLong() ;
    var x : long ; x := (input->at(2+1))->toLong() ;
    var ans : long ; ans := b / x - a / x ;
    if (a mod x = 0) then     ans := ans + 1 ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 ))   catch (e : OclException) do (     e.printStackTrace() ; 
 OclProcess.exit(0) )
  catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(0) )
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    BigInteger a=sc.nextBigInteger();
    BigInteger b=sc.nextBigInteger();
    BigInteger x=sc.nextBigInteger();
    BigInteger c=a.divide(x).add(BigInteger.valueOf(1));
    BigInteger d=b.divide(x).add(BigInteger.valueOf(1));
    BigInteger sa=d.subtract(c);
    if(a.mod(x).intValue()!=0){
      System.out.println(sa);
    }
    else {
      System.out.println(sa.add(BigInteger.valueOf(1)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.nextBigInteger() ;
    var b : long ; b := sc.nextBigInteger() ;
    var x : long ; x := sc.nextBigInteger() ;
    var c : long ; c := a.divide(x)->excludes((1 + "")->toLong()) ;
    var d : long ; d := b.divide(x)->excludes((1 + "")->toLong()) ;
    var sa : long ; sa := d.subtract(c) ;
    if (a.mod(x)->oclAsType(int) /= 0) then (     OclFile["System.out"].println(sa) ) else (     OclFile["System.out"].println(sa->excludes((1 + "")->toLong())) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
final class Solver {
  static final Solver INSTANCE=new Solver();
  void solve(Scanner sc){
    long A=sc.nextLong();
    long B=sc.nextLong();
    long X=sc.nextLong();
    long subtract=A==0 ? 0 : Math.floorDiv(A-1,X)+1 ;
    long result=Math.floorDiv(B,X)+1-subtract ;
    System.out.println(result);
  }
}
class Main {
  public static void main(String...args){
    Scanner in=new Scanner(System.in);
    Solver.INSTANCE.solve(in);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solver {
  static    attribute INSTANCE : Solver := Solver.newSolver();
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var A : long ; A := sc.nextLong() ;
     var B : long ; B := sc.nextLong() ;
    var X : long ; X := sc.nextLong() ;
    var subtract : long ; subtract := if A = 0 then 0 else floorDiv(A - 1, X) + 1 endif ;
    var result : long ; result := floorDiv(B, X) + 1 - subtract ;
    OclFile["System.out"].println(result) ; 
 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Solver.INSTANCE.solve(in) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str[]=br.readLine().split(" ");
    long a=Long.parseLong(str[0]);
    long b=Long.parseLong(str[1]);
    long x=Long.parseLong(str[2]);
    long bb=b/x ;
    long aa=(a-1)/x ;
    if(a==0){
      aa=-1 ;
    }
    System.out.println(bb-aa);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var a : long ; a := (str[0+1])->toLong() ;
    var b : long ; b := (str[1+1])->toLong() ;
    var x : long ; x := (str[2+1])->toLong() ;
    var bb : long ; bb := b / x ;
    var aa : long ; aa := ((a)->char2byte() - 1) / x ;
    if (a = 0) then (     aa := -1 ) else skip ; 
    OclFile["System.out"].println(bb - aa) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static int findNumber(int arr[],int n){
    int ans=arr[0];
    for(int i=0 ; i<n ; i++)ans=gcd(ans,arr[i]);
    for(int i=0 ; i<n ; i++)if(arr[i]==ans)return ans ;
    return-1 ;
  }
  public static void main(String args[]){
    int arr[]={
      2,2,4 };
      int n=arr.length ;
      System.out.println(findNumber(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation findNumber( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := arr[0+1] ;
         var i : int ; i := 0 ; while i < n do (     ans := gcd(ans, arr[i+1]) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do (     if (arr[i+1] = ans) then     return ans else skip ;  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,2,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findNumber(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder();
    int tt=fs.nextInt();
    long[] a=new long[tt];
    for(int i=0 ; i<tt ; i++){
      a[i]=fs.nextLong();
    }
    int cnt=0 ;
    Arrays.sort(a);
    for(int i=1 ; i<tt-1 ; i++){
      if(a[i]==a[0] || a[i]==a[tt-1])continue ;
      cnt++;
    }
    out.print(cnt);
    out.close();
  }
  static int isPerfectSquare(int x){
    if(x>=0){
      int sr=(int)Math.sqrt(x);
      if((sr*sr)==x)return sr ;
      else return 0 ;
    }
    return 0 ;
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    Long[] readArray(int n){
      Long[] a=new Long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    var tt : int ; tt := fs.nextInt() ;
    var a : Sequence(long) ; a := Integer.subrange(1,tt)->collect(0) ;
        var i : int ; i := 0 ; while i < tt do ( (     a[i+1] := fs.nextLong() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    a := a->sort() ; 
        var i : int ; i := 1 ; while i < (tt)->char2byte() - 1 do ( (     if (a[i+1] = a[0+1] or a[i+1] = a[(tt)->char2byte() - 1+1]) then     continue else skip ; 
     cnt := cnt + 1 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation isPerfectSquare( x : int) : int
  pre: true
  post: true
  activity: (     if (x >= 0) then (     var sr : int ; sr := (x)->sqrt()->oclAsType(int) ;
     if ((sr * sr) = x) then     return sr else     return 0 ) else skip ; 
     return 0 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    int n=Integer.parseInt(sa[0]);
    long x=Integer.parseInt(sa[1]);
    long[] a=new long[n];
    sa=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(sa[i]);
    }
    br.close();
    Arrays.parallelSort(a);
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      x-=a[i];
      if(x>=0){
        ans++;
      }
      else {
        break ;
      }
    }
    if(x>0){
      ans--;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var n : int ; n := (sa[0+1])->toInteger() ;
    var x : long ; x := (sa[1+1])->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    sa := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sa[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    a := a->sort() ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x := x-(a[i+1]) ; 
     if (x >= 0) then (     ans := ans + 1 ) else (     break ) )  ;     i := i + 1 ) ; 
    if (x > 0) then (     ans := ans - 1 ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countKdivPairs(int A[],int n,int K){
    int[] freq=new int[K];
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      int rem=A[i] % K ;
      if(rem!=0)ans+=freq[K-rem];
      else ans+=freq[0];
      freq[rem]++;
    }
    return ans ;
  }
  public static void main(String[] args){
    int A[]={
      2,2,1,7,5,3 };
      int n=A.length ;
      int K=4 ;
      System.out.println(countKdivPairs(A,n,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countKdivPairs( A : Sequence(int), n : int, K : int) : int
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,K)->collect(0) ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var rem : int ; rem := A[i+1] mod K ;
     if (rem /= 0) then     ans := ans+(freq[K - rem+1]) else     ans := ans+(freq[0+1]) ; ;  
     freq[rem+1] := freq[rem+1] + 1 )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{2,2,1,7,5,3} ;
     var n : int ; n := A->size() ;
     var K : int ; K := 4 ;
     OclFile["System.out"].println(countKdivPairs(A, n, K)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    scanner.useDelimiter(",");
    String a=scanner.next();
    String b=scanner.next();
    String c=scanner.next();
    System.out.println(a+" "+b+" "+c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var a : String ; a := scanner.getCurrent() ;
    var b : String ; b := scanner.getCurrent() ;
    var c : String ; c := scanner.getCurrent() ;
    OclFile["System.out"].println(a + " " + b + " " + c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=false ;
  private static PrintWriter _out=new PrintWriter(System.out);
  private static PrintWriter _err=new PrintWriter(System.err);
  private void solve(Scanner sc){
    String s=sc.next();
    s=s.replaceAll(","," ");
    _out.println(s);
  }
  private long C(long n,long r){
    long res=1 ;
    for(long i=n ; i>n-r ; --i){
      res*=i ;
    }
    for(long i=r ; i>1 ; --i){
      res/=i ;
    }
    return res ;
  }
  private long P(long n,long r){
    long res=1 ;
    for(long i=n ; i>n-r ; --i){
      res*=i ;
    }
    return res ;
  }
  public static void main(String[] args){
    long S=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    new Main().solve(sc);
    _out.flush();
    long G=System.currentTimeMillis();
    if(elapsed){
      _err.println((G-S)+"ms");
    }
    _err.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := false;
  static   attribute _out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute _err : OclFile := OclFile.newOclFile_Write(OclFile["System.err"]);
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := sc.next() ;
     s := s.replaceAllMatches(",", " " ) ; 
     skip );
   operation C( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res*(i) )  ;     i := i - 1 ) ; 
         var i : long ; i := r ; while i > 1 do ( (     res := res/(i) )  ;     i := i - 1 ) ; 
     return res );
   operation P( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res*(i) )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    Main.newMain().solve(sc) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.InputMismatchException ;
import java.io.IOException ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    FastScanner in=new FastScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(1,in,out);
    out.close();
  }
  static class Task {
    public void solve(int testNumber,FastScanner in,PrintWriter out){
      out.println(in.next().replace(',',' '));
    }
  }
  static class FastScanner {
    private InputStream in ;
    private byte[] buffer=new byte[1024];
    private int bufPointer ;
    private int bufLength ;
    public FastScanner(InputStream in){
      this.in=in ;
    }
    private int readByte(){
      if(bufPointer>=bufLength){
        if(bufLength==-1)throw new InputMismatchException();
        bufPointer=0 ;
        try {
          bufLength=in.read(buffer);
        }
        catch(IOException e){
          throw new InputMismatchException();
        }
        if(bufLength<=0)return-1 ;
      }
      return buffer[bufPointer++];
    }
    private static boolean isPrintableChar(int c){
      return c>=33 && c<=126 ;
    }
    public String next(){
      StringBuilder sb=new StringBuilder();
      int b=readByte();
      while(! isPrintableChar(b))b=readByte();
      while(isPrintableChar(b)){
        sb.appendCodePoint(b);
        b=readByte();
      }
      return sb.toString();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : FastScanner ; in := FastScanner.newFastScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( testNumber : int, in : FastScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     skip );
}
  static class FastScanner {
   attribute in : OclFile;
   attribute buffer : Sequence(int) := Integer.subrange(1,1024)->collect(0);
   attribute bufPointer : int;
   attribute bufLength : int;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     self.in := in );
   operation readByte() : int
  pre: true
  post: true
  activity: (     if (bufPointer >= bufLength) then (     if (bufLength = -1) then     error IncorrectElementException() ; else skip ; 
     bufPointer := 0 ; 
     try (     bufLength := in.read(buffer) )   catch (e : IOException) do (     error IncorrectElementException() )
     if (bufLength <= 0) then     return -1 else skip ) else skip ; 
     return buffer[bufPointer+1] );
  static   operation isPrintableChar( c : int) : boolean
  pre: true
  post: true
  activity: (     return c >= 33 & c <= 126 );
   operation next() : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     var b : int ; b := readByte() ;
    while (not(isPrintableChar(b))) do     b := readByte() ; ; 
    while (isPrintableChar(b)) do (     sb.appendCodePoint(b) ; 
     b := readByte() ) ; 
    return sb+"" 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
import java.util.TreeSet ;
import org.omg.Messaging.SyncScopeHelper ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new Test_100().doIt();
  }
  class Test_100 {
    void doIt(){
      String str[]=sc.next().split(",");
      System.out.println(str[0]+" "+str[1]+" "+str[2]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     TestTestTest    TestTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00.newTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00()00.newTestTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00.newTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00()00().doIt() ;00.newTest    TestTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00.newTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00()00.newTestTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00.newTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00()00().doIt() ;00().doIt()00.newTestTest    TestTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00.newTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00()00.newTestTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00.newTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00()00().doIt() ;00.newTest    TestTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00.newTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00()00.newTestTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00.newTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00()00().doIt() ;00().doIt()00()00.newTestTestTest    TestTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00.newTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00()00.newTestTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00.newTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00()00().doIt() ;00.newTest    TestTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00.newTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00()00.newTestTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00.newTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00()00().doIt() ;00().doIt()00.newTestTest    TestTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00.newTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00()00.newTestTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00.newTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00()00().doIt() ;00.newTest    TestTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00.newTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00()00.newTestTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00.newTestTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00.newTest    TestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00.newTestTestTest_100.newTest_100().doIt()00.newTestTest_100.newTest_100().doIt()00()00().doIt() ; 
00().doIt()00()00().doIt() ;00().doIt()00()00().doIt() );
 class Test_100 {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := sc.getCurrent()->split(",") ;
     OclFile["System.out"].println(str[0+1] + " " + str[1+1] + " " + str[2+1]) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    String a=br.readLine();
    sb.append(a.replace(","," "));
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var a : String ; a := br.readLine() ;
    sb := sb + StringLib.newString(a.replace(",", " ")) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=sc.nextInt();
    }
    int l=0,r=0 ;
    for(int i=0 ; i<n ; i++){
      if(l==0 && nums[n-i-1]!=nums[0]){
        l=n-i-1 ;
      }
      if(r==0 && nums[i]!=nums[n-1]){
        r=n-i-1 ;
      }
    }
    System.out.println(Math.max(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (l = 0 & nums[n - i - 1+1] /= nums[0+1]) then (     l := n - i - 1 ) else skip ; 
     if (r = 0 & nums[i+1] /= nums[n - 1+1]) then (     r := n - i - 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{l, r}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    int l=0,r=n-1 ;
    int min=0,min2=0 ;
    while(l<r){
      if(a[l]!=a[r]){
        min=r-l ;
        break ;
      }
      l++;
    }
    l=0 ;
    r=n-1 ;
    while(l<r){
      if(a[l]!=a[r]){
        min2=r-l ;
        break ;
      }
      r--;
    }
    System.out.println(Math.max(min2,min));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var l : int ; l := 0 ;
    var r : int ; r := n - 1 ;
    var min : int ; min := 0 ;
    var min2 : int ; min2 := 0 ;
    while (l < r) do (     if (a[l+1] /= a[r+1]) then (     min := r - l ; 
     break ) else skip ; 
     l := l + 1 ) ; 
    l := 0 ; 
    r := n - 1 ; 
    while (l < r) do (     if (a[l+1] /= a[r+1]) then (     min2 := r - l ; 
     break ) else skip ; 
     r := r - 1 ) ; 
    OclFile["System.out"].println(Set{min2, min}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    int l=0,r=n-1 ;
    int min=0,min1=0 ;
    while(l<r){
      if(a[l]!=a[r]){
        min=r-l ;
        break ;
      }
      l++;
    }
    l=0 ;
    r=n-1 ;
    while(l<r){
      if(a[l]!=a[r]){
        min1=r-l ;
        break ;
      }
      r--;
    }
    System.out.println(Math.max(min1,min));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var l : int ; l := 0 ;
    var r : int ; r := n - 1 ;
    var min : int ; min := 0 ;
    var min1 : int ; min1 := 0 ;
    while (l < r) do (     if (a[l+1] /= a[r+1]) then (     min := r - l ; 
     break ) else skip ; 
     l := l + 1 ) ; 
    l := 0 ; 
    r := n - 1 ; 
    while (l < r) do (     if (a[l+1] /= a[r+1]) then (     min1 := r - l ; 
     break ) else skip ; 
     r := r - 1 ) ; 
    OclFile["System.out"].println(Set{min1, min}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextInt();
    }
    int t=f(a[0]);
    for(int i=1 ; i<N ; i++){
      if(f(a[i])!=t){
        System.out.println(0);
        return ;
      }
    }
    long l=1 ;
    for(int i=0 ; i<N ; i++){
      l=lcm(l,a[i]/2);
      if(l>M){
        System.out.println(0);
        return ;
      }
    }
    System.out.println((M/l+1)/2);
  }
  private static long gcd(long a,long b){
    return b>0 ? gcd(b,a % b): a ;
  }
  private static long lcm(long a,long b){
    return a/gcd(a,b)*b ;
  }
  private static int f(int x){
    int ret=0 ;
    while(x % 2==0){
      ret++;
      x/=2 ;
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var t : int ; t := f(a[0+1]) ;
        var i : int ; i := 1 ; while i < N do ( (     if (f(a[i+1]) /= t) then (     OclFile["System.out"].println(0) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    var l : long ; l := 1 ;
        var i : int ; i := 0 ; while i < N do ( (     l := lcm(l, a[i+1] / 2) ; 
     if (l > M) then (     OclFile["System.out"].println(0) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((M / l + 1) / 2) ; 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return if b > 0 then gcd(b, a mod b) else a endif );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return a / gcd(a, b) * b );
  static   operation f( x : int) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
     while (x mod 2 = 0) do (     ret := ret + 1 ; 
     x := x/(2) ) ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner leer=new Scanner(System.in);
    int casos,x,y,conta=0,cont=0 ;
    casos=leer.nextInt();
    for(int i=0 ; i<casos ; i++){
      x=leer.nextInt();
      y=leer.nextInt();
      if(x>0){
        conta++;
      }
      else {
        cont++;
      }
    }
    if(conta>1 && cont>1){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var leer : OclFile ; leer := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var casos : int ;
    var x : int ;
    var y : int ;
    var conta : int ; conta := 0 ;
    var cont : int ; cont := 0 ;
    casos := leer.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < casos do ( (     x := leer.getCurrent()->toInteger() ; 
     y := leer.getCurrent()->toInteger() ; 
     if (x > 0) then (     conta := conta + 1 ) else (     cont := cont + 1 ) )  ;     i := i + 1 ) ; 
    if (conta > 1 & cont > 1) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
    }
    Arrays.sort(arr);
    int min=arr[0];
    int max=arr[n-1];
    int minCount=0 ;
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]!=min && arr[i]!=max){
        minCount++;
      }
    }
    out.println(minCount);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var min : int ; min := arr[0+1] ;
    var max : int ; max := arr[n - 1+1] ;
    var minCount : int ; minCount := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] /= min & arr[i+1] /= max) then (     minCount := minCount + 1 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.BigInteger ;
public class Main {
  public static long twoCount(long a){
    long count=0 ;
    while(a % 2==0){
      a=a/2 ;
      count++;
    }
    return count ;
  }
  private static long calcGcd(long m,long n){
    if(m<=0 || n<=0){
      throw new IllegalArgumentException("Arguments must be 1 and over.");
    }
    if(m<n){
      long tmp=m ;
      m=n ;
      n=tmp ;
    }
    long remainder=0 ;
    while((remainder=m % n)!=0){
      m=n ;
      n=remainder ;
    }
    return n ;
  }
  private static long calcLcm(long m,long n){
    return m*n/calcGcd(m,n);
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int N=s.nextInt();
    int M=s.nextInt();
    long[] A=new long[N];
    for(int i=0 ; i<N ; i++){
      A[i]=s.nextInt()/2 ;
    }
    boolean isExist=true ;
    for(int i=0 ; i<N-1 ; i++){
      if(twoCount(A[i])!=twoCount(A[i+1]))isExist=false ;
    }
    if(isExist){
      long maxLcm=A[0];
      boolean swi=false ;
      for(int i=0 ; i<N ; i++){
        maxLcm=calcLcm(A[i],maxLcm);
        if(maxLcm>M){
          swi=true ;
          break ;
        }
      }
      if(swi){
        System.out.println(0);
      }
      else {
        System.out.println((M/maxLcm+1)/2);
      }
    }
    else {
      System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation twoCount( a : long) : long
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
     while (a mod 2 = 0) do (     a := a / 2 ; 
     count := count + 1 ) ; 
     return count );
  static   operation calcGcd( m : long, n : long) : long
  pre: true
  post: true
  activity: (     if (m <= 0 or n <= 0) then (     error IllegalArgumentException.newIllegalArgumentException("Arguments must be 1 and over.") ) else skip ; 
     if (m < n) then (     var tmp : long ; tmp := m ;
     m := n ; 
     n := tmp ) else skip ; 
    var remainder : long ; remainder := 0 ;
        remainder := m mod n ;
    while ((remainder) /= 0) do (    skip ; (     m := n ; 
     n := remainder ) ;     remainder := m mod n ;
 ) ;  
    return n 
 );
  static   operation calcLcm( m : long, n : long) : long
  pre: true
  post: true
  activity: (     return m * n / calcGcd(m, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := s.getCurrent()->toInteger() ;
    var M : int ; M := s.getCurrent()->toInteger() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := s.getCurrent()->toInteger() / 2 )  ;     i := i + 1 ) ; 
    var isExist : boolean ; isExist := true ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     if (twoCount(A[i+1]) /= twoCount(A[i + 1+1])) then     isExist := false ; else skip )  ;     i := i + 1 ) ; 
    if (isExist) then (     var maxLcm : long ; maxLcm := A[0+1] ;
     var swi : boolean ; swi := false ;
         var i : int ; i := 0 ; while i < N do ( (     maxLcm := calcLcm(A[i+1], maxLcm) ; 
     if (maxLcm > M) then (     swi := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (swi) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println((M / maxLcm + 1) / 2) ) ) else (     OclFile["System.out"].println(0) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=Integer.parseInt(scan.next());
    long m=Long.parseLong(scan.next());
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Long.parseLong(scan.next());
      a[i]/=2 ;
    }
    scan.close();
    long lcm=a[0];
    for(int i=1 ; i<n ; i++){
      lcm*=a[i]/gcd(lcm,a[i]);
      if(lcm>m){
        System.out.println(0);
        return ;
      }
    }
    long twoCount=twoCount(a[0]);
    for(int i=1 ; i<n ; i++){
      long twoCountI=twoCount(a[i]);
      if(twoCountI!=twoCount){
        System.out.println(0);
        return ;
      }
    }
    System.out.println(1+(m-lcm)/(lcm*2));
  }
  private static long gcd(long a,long b){
    if(a % b==0){
      return b ;
    }
    else {
      return gcd(b,a % b);
    }
  }
  private static long twoCount(long a){
    long count=0 ;
    while(a % 2==0){
      a/=2 ;
      count++;
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (scan.getCurrent())->toInteger() ;
    var m : long ; m := (scan.getCurrent())->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (scan.getCurrent())->toLong() ; 
     a[i+1] := a[i+1]/(2) )  ;     i := i + 1 ) ; 
    skip ; 
    var lcm : long ; lcm := a[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     lcm := lcm*(a[i+1] / gcd(lcm, a[i+1])) ; 
     if (lcm > m) then (     OclFile["System.out"].println(0) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    var twoCount : long ; twoCount := twoCount(a[0+1]) ;
        var i : int ; i := 1 ; while i < n do ( (     var twoCountI : long ; twoCountI := twoCount(a[i+1]) ;
     if (twoCountI /= twoCount) then (     OclFile["System.out"].println(0) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(1 + (m - lcm) / (lcm * 2)) ; 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a mod b = 0) then (     return b ) else (     return gcd(b, a mod b) ) );
  static   operation twoCount( a : long) : long
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
     while (a mod 2 = 0) do (     a := a/(2) ; 
     count := count + 1 ) ; 
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long m=sc.nextLong();
    long[] a=new long[n];
    long lc=1 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
      a[i]/=2 ;
      long g=gcd(lc,a[i]);
      lc=g*(lc/g)*(a[i]/g);
    }
    int p=0 ;
    for(int i=0 ; i<n ; i++){
      long s=(lc/a[i]);
      if((s % 2)==0)p++;
    }
    long ans=0 ;
    if(p>0){
    }
    else {
      long k=(m/lc);
      ans=(k+1)/2 ;
    }
    System.out.println(ans);
  }
  public static long gcd(long x,long y){
    if(y==0)return x ;
    return gcd(y,(x % y));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : long ; m := sc.getCurrent()->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var lc : long ; lc := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() ; 
     a[i+1] := a[i+1]/(2) ; 
     var g : long ; g := gcd(lc, a[i+1]) ;
     lc := g * (lc / g) * (a[i+1] / g) )  ;     i := i + 1 ) ; 
    var p : int ; p := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var s : long ; s := (lc / a[i+1]) ;
     if ((s mod 2) = 0) then     p := p + 1 ; else skip )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    if (p > 0) then skip else (     var k : long ; k := (m / lc) ;
     ans := (k + 1) / 2 ) ;  
    OclFile["System.out"].println(ans) ; 
 );
  static   operation gcd( x : long, y : long) : long
  pre: true
  post: true
  activity: (     if (y = 0) then     return x else skip ; 
     return gcd(y, (x mod y)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int m=Integer.parseInt(sc.next());
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(sc.next())/2 ;
    }
    long gcd ;
    long lcd=1 ;
    for(int i=0 ; i<n ; i++){
      gcd=getGCD(lcd,a[i]);
      lcd=lcd*a[i]/gcd ;
      if(lcd>m){
        System.out.println(0);
        return ;
      }
    }
    for(int i=0 ; i<n ; i++){
      if((lcd/a[i])% 2==0){
        System.out.println(0);
        return ;
      }
    }
    System.out.println((m/lcd+1)/2);
  }
  public static long getGCD(long a,long b){
    if(b==0){
      return a ;
    }
    else {
      return getGCD(b,a % b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var m : int ; m := (sc.getCurrent())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sc.getCurrent())->toInteger() / 2 )  ;     i := i + 1 ) ; 
    var gcd : long ;
    var lcd : long ; lcd := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     gcd := getGCD(lcd, a[i+1]) ; 
     lcd := lcd * a[i+1] / gcd ; 
     if (lcd > m) then (     OclFile["System.out"].println(0) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if ((lcd / a[i+1]) mod 2 = 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((m / lcd + 1) / 2) ; 
 );
  static   operation getGCD( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else (     return getGCD(b, a mod b) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSubarrays(int[] arr,int n){
    int difference=0 ;
    int ans=0 ;
    int[] hash_positive=new int[n+1];
    int[] hash_negative=new int[n+1];
    hash_positive[0]=1 ;
    for(int i=0 ; i<n ; i++){
      if((arr[i] & 1)==1){
        difference++;
      }
      else {
        difference--;
      }
      if(difference<0){
        ans+=hash_negative[-difference];
        hash_negative[-difference]++;
      }
      else {
        ans+=hash_positive[difference];
        hash_positive[difference]++;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int[] arr=new int[] {
      3,4,6,8,1,10,5,7 };
      int n=arr.length ;
      System.out.println("Total Number of Even-Odd"+" subarrays are "+countSubarrays(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSubarrays( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var difference : int ; difference := 0 ;
     var ans : int ; ans := 0 ;
    var hash_positive : Sequence(int) ; hash_positive := Integer.subrange(1,n + 1)->collect(0) ;
    var hash_negative : Sequence(int) ; hash_negative := Integer.subrange(1,n + 1)->collect(0) ;
    hash_positive[0+1] := 1 ; 
        var i : int ; i := 0 ; while i < n do ( (     if ((arr[i+1] & 1) = 1) then (     difference := difference + 1 ) else (     difference := difference - 1 ) ;  
     if (difference < 0) then (     ans := ans+(hash_negative[-difference+1]) ; 
     hash_negative[-difference+1] := hash_negative[-difference+1] + 1 ) else (     ans := ans+(hash_positive[difference+1]) ; 
     hash_positive[difference+1] := hash_positive[difference+1] + 1 ) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,4,6,8,1,10,5,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Total Number of Even-Odd" + " subarrays are " + countSubarrays(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void printChar(String str,int n){
    int[] freq=new int[26];
    for(int i=0 ; i<n ; i++)freq[str.charAt(i)-'a']++;
    for(int i=0 ; i<n ; i++){
      if(freq[str.charAt(i)-'a'] % 2==1){
        System.out.print(str.charAt(i));
      }
    }
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    int n=str.length();
    printChar(str,n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printChar( str : String, n : int) : void
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     freq[str->at(i+1) - ('a')->char2byte()+1] := freq[str->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (freq[str->at(i+1) - ('a')->char2byte()+1] mod 2 = 1) then (     OclFile["System.out"].print(str->at(i+1)) ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var n : int ; n := str->size() ;
     execute printChar(str, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int SIZE=26 ;
  static void printChar(String str,int n){
    int[] freq=new int[SIZE];
    for(int i=0 ; i<n ; i++)freq[str.charAt(i)-'a']++;
    for(int i=0 ; i<n ; i++){
      if(freq[str.charAt(i)-'a'] % 2==0){
        System.out.print(str.charAt(i));
      }
    }
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    int n=str.length();
    printChar(str,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute SIZE : int := 26;
  static   operation printChar( str : String, n : int) : void
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,SIZE)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     freq[str->at(i+1) - ('a')->char2byte()+1] := freq[str->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (freq[str->at(i+1) - ('a')->char2byte()+1] mod 2 = 0) then (     OclFile["System.out"].print(str->at(i+1)) ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var n : int ; n := str->size() ;
     execute printChar(str, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countGreater(int arr[],int n,int k){
    int l=0 ;
    int r=n-1 ;
    int leftGreater=n ;
    while(l<=r){
      int m=l+(r-l)/2 ;
      if(arr[m]>k){
        leftGreater=m ;
        r=m-1 ;
      }
      else l=m+1 ;
    }
    return(n-leftGreater);
  }
  public static void main(String[] args){
    int arr[]={
      3,3,4,7,7,7,11,13,13 };
      int n=arr.length ;
      int k=7 ;
      System.out.println(countGreater(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countGreater( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
     var r : int ; r := n - 1 ;
    var leftGreater : int ; leftGreater := n ;
    while (l <= r) do (     var m : int ; m := l + (r - l) / 2 ;
     if (arr[m+1] > k) then (     leftGreater := m ; 
     r := m - 1 ) else     l := m + 1 ; ) ; 
    return (n - leftGreater) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,3,4,7,7,7,11,13,13} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 7 ;
     OclFile["System.out"].println(countGreater(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  int MOD=1000000 ;
  int[][] es={
    {
      0,1,2,3 },{
        0,1,2 },{
          0,1,2,4 },{
            2,3 },{
              0,4 }
            };
            int len=5 ;
            void run(){
              Scanner sc=new Scanner(System.in);
              int h=sc.nextInt(),w=sc.nextInt();
              if(w==1){
                int ret=1 ;
                for(int i=0 ; i<h ; i++)ret=ret*2 % MOD ;
                System.out.println(ret);
                return ;
              }
              int[][] cnt=new int[2][len];
              cnt[0][0]=1 ;
              int p=1 ;
              for(int i=0 ; i<=h ; i++){
                fill(cnt[p],0);
                for(int j=0 ; j<len ; j++)for(int k=0 ; k<es[j] .length ; k++){
                  cnt[p][es[j][k] ]=(cnt[p][es[j][k] ]+cnt[1-p][j])% MOD ;
                }
                p=1-p ;
              }
              System.out.println(cnt[1-p][2]);
            }
            void debug(Object...os){
              System.err.println(Arrays.deepToString(os));
            }
            public static void main(String[] args){
              new Main().run();
            }
          }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   attribute MOD : int := 1000000;
   attribute es : Sequence(Sequence(int)) := Sequence{Sequence{0,1,2,3},Sequence{0,1,2},Sequence{0,1,2,4},Sequence{2,3},Sequence{0,4}};
   attribute len : int := 5;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    if (w = 1) then (     var ret : int ; ret := 1 ;
         var i : int ; i := 0 ; while i < h do (     ret := ret * 2 mod MOD ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ret) ; 
     return ) else skip ; 
    var cnt : Sequence(Sequence(int)) ; cnt := Integer.subrange(1,2)->collect(Integer.subrange(1,len)->collect(0)) ;
    cnt[0+1][0+1] := 1 ; 
    var p : int ; p := 1 ;
        var i : int ; i := 0 ; while i <= h do ( (     execute fill(cnt[p+1], 0) ; 
         var j : int ; j := 0 ; while j < len do (         var k : int ; k := 0 ; while k < es[j+1]->size() do ( (     cnt[p+1][es[j+1][k+1]+1] := (cnt[p+1][es[j+1][k+1]+1] + cnt[1 - p+1][j+1]) mod MOD )  ;     k := k + 1 ) ;  ;     j := j + 1 ) ; 
     p := 1 - p )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt[1 - p+1][2+1]) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Fibonacci {
  static int findIndex(int n){
    float fibo=2.078087F*(float)Math.log(n)+1.672276F ;
    return Math.round(fibo);
  }
  public static void main(String[] args){
    int result=findIndex(55);
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
class Fibonacci {
  static   operation findIndex( n : int) : int
  pre: true
  post: true
  activity: (     var fibo : double ; fibo := 2.078087F * (n)->log()->oclAsType(double) + 1.672276F ;
     return (fibo)->round() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var result : int ; result := findIndex(55) ;
     OclFile["System.out"].println(result) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int c=0 ;
    for(int i=0 ; i<n ; i++){
      int x=s.nextInt();
      int y=s.nextInt();
      if(x<0)c++;
    }
    if(c==n || c==n-1 || c==0 || c==1)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := s.getCurrent()->toInteger() ;
     var y : int ; y := s.getCurrent()->toInteger() ;
     if (x < 0) then     c := c + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (c = n or c = n - 1 or c = 0 or c = 1) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findAandB(double N){
    double val=N*N-4.0*N ;
    if(val<0){
      System.out.println("NO");
      return ;
    }
    double a=(N+Math.sqrt(val))/2.0 ;
    double b=(N-Math.sqrt(val))/2.0 ;
    System.out.println("a="+a);
    System.out.println("b="+b);
  }
  public static void main(String[] args){
    double N=69.0 ;
    findAandB(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findAandB( N : double) : void
  pre: true
  post: true
  activity: (     var val : double ; val := N * N - 4.0 * N ;
     if (val < 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    var a : double ; a := (N + (val)->sqrt()) / 2.0 ;
    var b : double ; b := (N - (val)->sqrt()) / 2.0 ;
    OclFile["System.out"].println("a=" + a) ; 
    OclFile["System.out"].println("b=" + b) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : double ; N := 69.0 ;
     execute findAandB(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minAbsDiff(int n){
    int left=(int)Math.pow(2,(int)(Math.log(n)/Math.log(2)));
    int right=left*2 ;
    return Math.min((n-left),(right-n));
  }
  public static void main(String args[]){
    int n=15 ;
    System.out.println(minAbsDiff(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minAbsDiff( n : int) : int
  pre: true
  post: true
  activity: (     var left : int ; left := 2->pow(((n)->log() / (2)->log())->oclAsType(int))->oclAsType(int) ;
     var right : int ; right := left * 2 ;
     return Set{(n - left), (right - n)}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     OclFile["System.out"].println(minAbsDiff(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class submitfinal {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t!=0){
      int n=sc.nextInt();
      int x,y ;
      int temp1=Integer.MIN_VALUE,temp2=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; ++i){
        x=sc.nextInt();
        y=sc.nextInt();
        temp1=Math.max(temp1,x);
        temp2=Math.min(temp2,y);
      }
      System.out.println(Math.max(0,(temp1-temp2)));
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class submitfinal {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t /= 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ;
    var y : int ;
    var temp1 : int ; temp1 := -2147483648 ;
    var temp2 : int ; temp2 := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     x := sc.getCurrent()->toInteger() ; 
     y := sc.getCurrent()->toInteger() ; 
     temp1 := Set{temp1, x}->max() ; 
     temp2 := Set{temp2, y}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{0, (temp1 - temp2)}->max()) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.System.*;
import static java.lang.Math.max ;
import static java.lang.Math.min ;
import static java.lang.Math.abs ;
public class pre1 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int tc=obj.nextInt();
    while(tc--!=0){
      int n=obj.nextInt();
      if(n==1){
        obj.nextInt();
        obj.nextInt();
        out.println(0);
        continue ;
      }
      int max=0,min=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; i++){
        int x=obj.nextInt(),y=obj.nextInt();
        max=max(max,x);
        min=min(min,y);
      }
      out.println(max(max-min,0));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre1 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var tc : int ; tc := obj.nextInt() ;
         while (tc /= 0) do (    skip ; (     var n : int ; n := obj.nextInt() ;
     if (n = 1) then (     obj.nextInt() ; 
     obj.nextInt() ; 
     out.println(0) ; 
     continue ) else skip ; 
    var max : int ; max := 0 ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := obj.nextInt() ;
    var y : int ; y := obj.nextInt() ;
     max := Set{max, x}->max() ; 
     min := Set{min, y}->min() )  ;     i := i + 1 ) ; 
    out.println(Set{max - min, 0}->max()) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MathProblem {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0){
      int n=sc.nextInt();
      int max=Integer.MIN_VALUE ;
      int min=Integer.MAX_VALUE ;
      while(n-->0){
        int a=sc.nextInt();
        max=Math.max(max,a);
        int b=sc.nextInt();
        min=Math.min(min,b);
      }
      if(max<=min){
        System.out.println(0);
      }
      else {
        System.out.println(max-min);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MathProblem {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var max : int ; max := -2147483648 ;
    var min : int ; min := 2147483647 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     max := Set{max, a}->max() ; 
     var b : int ; b := sc.getCurrent()->toInteger() ;
     min := Set{min, b}->min() ) ;  ) ;  
    if (max <= min) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(max - min) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class submitfinal {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t!=0){
      int n=sc.nextInt();
      int x,y ;
      int temp1=Integer.MIN_VALUE,temp2=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; ++i){
        x=sc.nextInt();
        y=sc.nextInt();
        temp1=Math.max(temp1,x);
        temp2=Math.min(temp2,y);
      }
      System.out.println(Math.max(0,(temp1-temp2)));
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class submitfinal {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t /= 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ;
    var y : int ;
    var temp1 : int ; temp1 := -2147483648 ;
    var temp2 : int ; temp2 := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     x := sc.getCurrent()->toInteger() ; 
     y := sc.getCurrent()->toInteger() ; 
     temp1 := Set{temp1, x}->max() ; 
     temp2 := Set{temp2, y}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{0, (temp1 - temp2)}->max()) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Set<String>set=new HashSet<String>();
  static int n,m ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    n=in.nextInt();
    m=in.nextInt();
    for(int i=0 ; i<n ; i++){
      String str=in.next();
      if(str.contains("X"))set.add(str);
    }
    if(set.size()==1)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute set : Set(String) := Set{};
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := in.getCurrent()->toInteger() ; 
    m := in.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := in.getCurrent() ;
     if (str->includes("X")) then     set := set->including(str) ; else skip )  ;     i := i + 1 ) ; 
    if (set->size() = 1) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B745 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int R=in.nextInt();
    int C=in.nextInt();
    char[][] A=new char[R][];
    for(int r=0 ; r<R ; r++){
      A[r]=in.next().toCharArray();
    }
    int minR=Integer.MAX_VALUE ;
    int minC=Integer.MAX_VALUE ;
    int maxR=Integer.MIN_VALUE ;
    int maxC=Integer.MIN_VALUE ;
    for(int r=0 ; r<R ; r++){
      for(int c=0 ; c<C ; c++){
        if(A[r][c]=='X'){
          minR=Math.min(minR,r);
          maxR=Math.max(maxR,r);
          minC=Math.min(minC,c);
          maxC=Math.max(maxC,c);
        }
      }
    }
    boolean rectangle=true ;
    for(int r=minR ; r<=maxR ; r++){
      for(int c=minC ; c<=maxC ; c++){
        if(A[r][c]!='X'){
          rectangle=false ;
        }
      }
    }
    System.out.println(rectangle ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class B745 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var R : int ; R := in.getCurrent()->toInteger() ;
    var C : int ; C := in.getCurrent()->toInteger() ;
    var A : Sequence(Sequence(String)) ; A := Integer.subrange(1,R)->collect(Sequence{}) ;
        var r : int ; r := 0 ; while r < R do ( (     A[r+1] := in.getCurrent()->characters() )  ;     r := r + 1 ) ; 
    var minR : int ; minR := 2147483647 ;
    var minC : int ; minC := 2147483647 ;
    var maxR : int ; maxR := -2147483648 ;
    var maxC : int ; maxC := -2147483648 ;
        var r : int ; r := 0 ; while r < R do ( (         var c : int ; c := 0 ; while c < C do ( (     if (A[r+1][c+1] = 'X') then (     minR := Set{minR, r}->min() ; 
     maxR := Set{maxR, r}->max() ; 
     minC := Set{minC, c}->min() ; 
     maxC := Set{maxC, c}->max() ) else skip )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    var rectangle : boolean ; rectangle := true ;
        var r : int ; r := minR ; while r <= maxR do ( (         var c : int ; c := minC ; while c <= maxC do ( (     if (A[r+1][c+1] /= 'X') then (     rectangle := false ) else skip )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    OclFile["System.out"].println(if rectangle then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class HongcowSolvesAPuzzle {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    String[] temp=br.readLine().split(" ");
    int m=Integer.parseInt(temp[0]);
    int n=Integer.parseInt(temp[1]);
    char[][] grid=new char[m][n];
    for(int i=0 ; i<m ; i++){
      grid[i]=br.readLine().toCharArray();
    }
    int xMin=m ;
    int xMax=0 ;
    int yMin=n ;
    int yMax=0 ;
    for(int i=0 ; i<m ; i++){
      for(int j=0 ; j<n ; j++){
        if(grid[i][j]=='X'){
          xMin=Math.min(xMin,i);
          xMax=Math.max(xMax,i);
          yMin=Math.min(yMin,j);
          yMax=Math.max(yMax,j);
        }
      }
    }
    for(int i=xMin ; i<=xMax ; i++){
      for(int j=yMin ; j<=yMax ; j++){
        if(grid[i][j]!='X'){
          pr.println("NO");
          return ;
        }
      }
    }
    pr.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class HongcowSolvesAPuzzle {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
     var m : int ; m := (temp[0+1])->toInteger() ;
    var n : int ; n := (temp[1+1])->toInteger() ;
    var grid : Sequence(Sequence(String)) ; grid := Integer.subrange(1,m)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (     grid[i+1] := br.readLine()->characters() )  ;     i := i + 1 ) ; 
    var xMin : int ; xMin := m ;
    var xMax : int ; xMax := 0 ;
    var yMin : int ; yMin := n ;
    var yMax : int ; yMax := 0 ;
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j < n do ( (     if (grid[i+1][j+1] = 'X') then (     xMin := Set{xMin, i}->min() ; 
     xMax := Set{xMax, i}->max() ; 
     yMin := Set{yMin, j}->min() ; 
     yMax := Set{yMax, j}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := xMin ; while i <= xMax do ( (         var j : int ; j := yMin ; while j <= yMax do ( (     if (grid[i+1][j+1] /= 'X') then (     skip ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class TaskB {
  static final int SIZE=(int)1e3+5 ;
  public static void solve(InputReader in,PrintWriter out){
    int n=in.nextInt();
    int num=1 ;
    for(; ; num<<=1){
      if(num>n-1)break ;
    }
    num>>=1 ;
    for(int i=1 ; i<num ; ++i){
      out.print(i+" ");
    }
    out.print(0+" "+num+" ");
    for(int i=num+1 ; i<n ; ++i)out.println(i+" ");
    out.println();
  }
  private static class InputReader {
    private BufferedReader reader ;
    private StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=reader.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    InputReader in=new InputReader(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int T=1 ;
    T=in.nextInt();
    for(int i=1 ; i<=T ; ++i){
      solve(in,out);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class TaskB {
  static    attribute SIZE : int := 1e3->oclAsType(int) + 5;
  static   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var num : int ; num := 1 ;
      while true do ( (     if (num > n - 1) then     break else skip )  ;     num := num*(2->pow(1)) ) ; 
    num := num/(2->pow(1)) ; 
        var i : int ; i := 1 ; while i < num do ( (     out.print(i + " ") )  ;     i := i + 1 ) ; 
    out.print(0 + " " + num + " ") ; 
        var i : int ; i := num + 1 ; while i < n do (     out.println(i + " ") ;  ;     i := i + 1 ) ; 
    out.println() ; 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := reader.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : InputReader ; in := InputReader.newInputReader(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := 1 ;
    T := in.nextInt() ; 
        var i : int ; i := 1 ; while i <= T do ( (     execute solve(in, out) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] x=new int[n];
    int[] y=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=sc.nextInt();
      y[i]=sc.nextInt();
    }
    int count1=0 ;
    int count2=0 ;
    for(int i=0 ; i<n ; i++){
      if(x[i]<0)count1++;
      else if(x[i]>0)count2++;
    }
    if(count1==0 || count2==0 || count1==1 || count2==1){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     y[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count1 : int ; count1 := 0 ;
    var count2 : int ; count2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (x[i+1] < 0) then     count1 := count1 + 1 ; else     if (x[i+1] > 0) then     count2 := count2 + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    if (count1 = 0 or count2 = 0 or count1 = 1 or count2 = 1) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF769B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int h=Integer.highestOneBit(n-1);
      h--;
      while(h>=0){
        System.out.print(h+" ");
        h--;
      }
      h=Integer.highestOneBit(n-1);
      while(h<=n-1){
        System.out.print(h+" ");
        h++;
      }
      System.out.println();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF769B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var h : int ; h := highestOneBit(n - 1) ;
    h := h - 1 ; 
    while (h >= 0) do (     OclFile["System.out"].print(h + " ") ; 
     h := h - 1 ) ; 
    h := highestOneBit(n - 1) ; 
    while (h <= n - 1) do (     OclFile["System.out"].print(h + " ") ; 
     h := h + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static final long MOD=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      char[] aa=sc.next().toCharArray();
      if(aa[0]=='0'){
        break ;
      }
      char[] bb=sc.next().toCharArray();
      char[] cc=sc.next().toCharArray();
      int n=aa.length ;
      long[][] dp=new long[n+1][2];
      dp[0][0]=1 ;
      for(int i=1 ; i<=n ; i++){
        int da=aa[n-i]=='?' ?-1 : aa[n-i]-'0' ;
        int db=bb[n-i]=='?' ?-1 : bb[n-i]-'0' ;
        int dc=cc[n-i]=='?' ?-1 : cc[n-i]-'0' ;
        for(int j=0 ; j<2 ; j++){
          for(int carry=0 ; carry<2 ; carry++){
            int patterns=0 ;
            for(int a=0 ; a<10 ; a++){
              if(da!=-1 && da!=a){
                continue ;
              }
              for(int b=0 ; b<10 ; b++){
                if(db!=-1 && db!=b){
                  continue ;
                }
                int c=a+b+carry ;
                if((j==0 && c>=10)||(j==1 && c<10)){
                  continue ;
                }
                if(i==n){
                  if(a*b*c==0){
                    continue ;
                  }
                }
                if(dc==-1 || dc==c % 10){
                  patterns++;
                }
              }
            }
            dp[i][j]+=dp[i-1][carry]*patterns % MOD ;
            dp[i][j] %=MOD ;
          }
        }
      }
      System.out.println(dp[n][0]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var aa : Sequence(String) ; aa := sc.getCurrent()->characters() ;
     if (aa[0+1] = '0') then (     break ) else skip ; 
    var bb : Sequence(String) ; bb := sc.getCurrent()->characters() ;
    var cc : Sequence(String) ; cc := sc.getCurrent()->characters() ;
    var n : int ; n := aa->size() ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,2)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do ( (     var da : int ; da := if aa[n - i+1] = '?' then -1 else aa[n - i+1] - ('0')->char2byte() endif ;
     var db : int ; db := if bb[n - i+1] = '?' then -1 else bb[n - i+1] - ('0')->char2byte() endif ;
     var dc : int ; dc := if cc[n - i+1] = '?' then -1 else cc[n - i+1] - ('0')->char2byte() endif ;
         var j : int ; j := 0 ; while j < 2 do ( (         var carry : int ; carry := 0 ; while carry < 2 do ( (     var patterns : int ; patterns := 0 ;
         var a : int ; a := 0 ; while a < 10 do ( (     if (da /= -1 & da /= a) then (     continue ) else skip ; 
         var b : int ; b := 0 ; while b < 10 do ( (     if (db /= -1 & db /= b) then (     continue ) else skip ; 
     var c : int ; c := a + b + carry ;
    if ((j = 0 & c >= 10) or (j = 1 & c < 10)) then (     continue ) else skip ; 
    if (i = n) then (     if (a * b * c = 0) then (     continue ) else skip ) else skip ; 
    if (dc = -1 or dc = c mod 10) then (     patterns := patterns + 1 ) else skip ; 
 )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
     dp[i+1][j+1] := dp[i+1][j+1]+(dp[i - 1+1][carry+1] * patterns mod MOD) ; 
     dp[i+1][j+1] := dp[i+1][j+1] mod MOD )  ;     carry := carry + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[n+1][0+1]) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int LCIS(int arr1[],int n,int arr2[],int m){
    int table[]=new int[m];
    for(int j=0 ; j<m ; j++)table[j]=0 ;
    for(int i=0 ; i<n ; i++){
      int current=0 ;
      for(int j=0 ; j<m ; j++){
        if(arr1[i]==arr2[j])if(current+1>table[j])table[j]=current+1 ;
        if(arr1[i]>arr2[j])if(table[j]>current)current=table[j];
      }
    }
    int result=0 ;
    for(int i=0 ; i<m ; i++)if(table[i]>result)result=table[i];
    return result ;
  }
  public static void main(String[] args){
    int arr1[]={
      3,4,9,1 };
      int arr2[]={
        5,3,8,9,10,2,1 };
        int n=arr1.length ;
        int m=arr2.length ;
        System.out.println("Length of LCIS is "+LCIS(arr1,n,arr2,m));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation LCIS( arr1 : Sequence(int), n : int, arr2 : Sequence(int), m : int) : int
  pre: true
  post: true
  activity: (     var table : Sequence(int) ; table := Integer.subrange(1,m)->collect(0) ;
         var j : int ; j := 0 ; while j < m do (     table[j+1] := 0 ;  ;     j := j + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var current : int ; current := 0 ;
         var j : int ; j := 0 ; while j < m do ( (     if (arr1[i+1] = arr2[j+1]) then     if (current + 1 > table[j+1]) then     table[j+1] := current + 1 ; else skip ; else skip ; 
     if (arr1[i+1] > arr2[j+1]) then     if (table[j+1] > current) then     current := table[j+1] ; else skip ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < m do (     if (table[i+1] > result) then     result := table[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{3,4,9,1} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{5,3,8,9,10,2,1} ;
    var n : int ; n := arr1->size() ;
    var m : int ; m := arr2->size() ;
    OclFile["System.out"].println("Length of LCIS is " + LCIS(arr1, n, arr2, m)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Multiply {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int a=sc.nextInt();
      int two=0 ;
      int three=0 ;
      while(a % 2==0){
        a=a/2 ;
        two++;
      }
      while(a % 3==0){
        a=a/3 ;
        three++;
      }
      if(a==1){
        if(three>=two){
          int temp=two ;
          three-=two ;
          temp+=three*2 ;
          System.out.println(temp);
        }
        else {
          System.out.println("-1");
        }
      }
      else {
        System.out.println("-1");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Multiply {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var two : int ; two := 0 ;
    var three : int ; three := 0 ;
    while (a mod 2 = 0) do (     a := a / 2 ; 
     two := two + 1 ) ; 
    while (a mod 3 = 0) do (     a := a / 3 ; 
     three := three + 1 ) ; 
    if (a = 1) then (     if (three >= two) then (     var temp : int ; temp := two ;
     three := three-(two) ; 
     temp := temp+(three * 2) ; 
     OclFile["System.out"].println(temp) ) else (     OclFile["System.out"].println("-1") ) ) else (     OclFile["System.out"].println("-1") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class study {
  public static void main(String[] args){
    Scanner css=new Scanner(System.in);
    int n=css.nextInt();
    int[] count=new int[n];
    ;
    int[] t=new int[n];
    for(int i=0 ; i<n ; i++){
      t[i]=css.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      while(t[i]>1){
        if(t[i] % 6==0){
          t[i]/=6 ;
          count[i]++;
        }
        else {
          t[i]*=2 ;
          count[i]++;
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      if(t[i]==1){
        System.out.println(count[i]);
      }
      else System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class study {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var css : OclFile ; css := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := css.getCurrent()->toInteger() ;
    var count : Sequence(int) ; count := Integer.subrange(1,n)->collect(0) ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     t[i+1] := css.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     while (t[i+1] > 1) do (     if (t[i+1] mod 6 = 0) then (     t[i+1] := t[i+1]/(6) ; 
     count[i+1] := count[i+1] + 1 ) else (     t[i+1] := t[i+1]*(2) ; 
     count[i+1] := count[i+1] + 1 ) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (t[i+1] = 1) then (     OclFile["System.out"].println(count[i+1]) ) else     OclFile["System.out"].println(-1) ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MultiplyByTwoAndDivBySix {
  public static void main(String[] args){
    Scanner iScanner=new Scanner(System.in);
    int test=iScanner.nextInt();
    while(test>0){
      test--;
      long a=iScanner.nextLong();
      int count2=0 ;
      int count3=0 ;
      while(a % 2==0){
        a/=2 ;
        count2++;
      }
      while(a % 3==0){
        a/=3 ;
        count3++;
      }
      if(a==1 && count3>=count2)System.out.println(count3-count2+count3);
      else System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MultiplyByTwoAndDivBySix {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var iScanner : OclFile ; iScanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := iScanner.getCurrent()->toInteger() ;
     while (test > 0) do (     test := test - 1 ; 
     var a : long ; a := iScanner.getCurrent()->toLong() ;
    var count2 : int ; count2 := 0 ;
    var count3 : int ; count3 := 0 ;
    while (a mod 2 = 0) do (     a := a/(2) ; 
     count2 := count2 + 1 ) ; 
    while (a mod 3 = 0) do (     a := a/(3) ; 
     count3 := count3 + 1 ) ; 
    if (a = 1 & count3 >= count2) then     OclFile["System.out"].println(count3 - count2 + count3) else     OclFile["System.out"].println(-1) ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MultiplyBy2DivideBy6 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    while(test-->0){
      int n=sc.nextInt();
      System.out.println(getMinimumNumberOfMoves(n));
    }
  }
  public static int getMinimumNumberOfMoves(int n){
    if(n==1){
      return 0 ;
    }
    if(n==2){
      return-1 ;
    }
    int countOfFactor2=0 ;
    int countOfFactor3=0 ;
    while(n % 2==0){
      n/=2 ;
      countOfFactor2++;
    }
    while(n % 3==0){
      n/=3 ;
      countOfFactor3++;
    }
    if(countOfFactor2>countOfFactor3){
      return-1 ;
    }
    return n==1 && countOfFactor3>=countOfFactor2 ? 2*countOfFactor3-countOfFactor2 :-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class MultiplyBy2DivideBy6 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(getMinimumNumberOfMoves(n)) ) ;  ) );
  static   operation getMinimumNumberOfMoves( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then (     return 0 ) else skip ; 
     if (n = 2) then (     return -1 ) else skip ; 
    var countOfFactor2 : int ; countOfFactor2 := 0 ;
    var countOfFactor3 : int ; countOfFactor3 := 0 ;
    while (n mod 2 = 0) do (     n := n/(2) ; 
     countOfFactor2 := countOfFactor2 + 1 ) ; 
    while (n mod 3 = 0) do (     n := n/(3) ; 
     countOfFactor3 := countOfFactor3 + 1 ) ; 
    if (countOfFactor2 > countOfFactor3) then (     return -1 ) else skip ; 
    return if n = 1 & countOfFactor3 >= countOfFactor2 then 2 * countOfFactor3 - countOfFactor2 else -1 endif 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class J {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      int counter=0 ;
      int temp=in.nextInt();
      while(temp % 3==0){
        if(temp % 6!=0)temp*=2 ;
        else temp=temp/6 ;
        counter++;
      }
      if(temp!=1)System.out.println("-1");
      else System.out.println(counter);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class J {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var counter : int ; counter := 0 ;
     var temp : int ; temp := in.getCurrent()->toInteger() ;
     while (temp mod 3 = 0) do (     if (temp mod 6 /= 0) then     temp := temp*(2) else     temp := temp / 6 ; ;  
     counter := counter + 1 ) ; 
     if (temp /= 1) then     OclFile["System.out"].println("-1") ; else     OclFile["System.out"].println(counter) ; )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minIncrementForUnique(int[] A){
    HashMap<Integer,Integer>mpp=new HashMap<Integer,Integer>();
    for(int i : A){
      if(mpp.containsKey(i))mpp.put(i,mpp.get(i)+1);
      else mpp.put(i,1);
    }
    Vector<Integer>taken=new Vector<Integer>();
    int ans=0 ;
    for(int x=0 ; x<100000 ; x++){
      if(mpp.containsKey(x)&& mpp.get(x)>=2)taken.add(x*(mpp.get(x)-1));
      else if(taken.size()>0 &&((mpp.containsKey(x)&& mpp.get(x)==0)|| ! mpp.containsKey(x))){
        ans+=x-taken.get(taken.size()-1);
        taken.remove(taken.size()-1);
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int[] A={
      3,2,1,2,1,7 };
      System.out.print(minIncrementForUnique(A));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minIncrementForUnique( A : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var mpp : Map(int,int) ; mpp := Map{} ;
     for (i : A) do ( (     if (mpp->keys()->includes(i)) then     mpp := mpp->union(Map{i |-> mpp->at(i) + 1}) ; else     mpp := mpp->union(Map{i |-> 1}) ; )  ) ; 
    var taken : Sequence(int) ; taken := Sequence{} ;
    var ans : int ; ans := 0 ;
        var x : int ; x := 0 ; while x < 100000 do ( (     if (mpp->keys()->includes(x) & mpp->at(x) >= 2) then     taken := taken->including(x * (mpp->at(x) - 1)) ; else     if (taken->size() > 0 & ((mpp->keys()->includes(x) & mpp->at(x) = 0) or not(mpp->keys()->includes(x)))) then (     ans := ans+(x - taken->at(taken->size() - 1+1)) ; 
     taken := taken->excludingFirst(taken->size() - 1) ) else skip ; )  ;     x := x + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{3,2,1,2,1,7} ;
     OclFile["System.out"].print(minIncrementForUnique(A)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int number=sc.nextInt();
    int[] arr=new int[2];
    while(number--!=0){
      int a=sc.nextInt(),b=sc.nextInt();
      if(a>0){
        arr[0]++;
      }
      else {
        arr[1]++;
      }
    }
    if(arr[0]<=1 || arr[1]<=1){
      System.out.print("Yes");
    }
    else {
      System.out.print("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,2)->collect(0) ;
        while (number /= 0) do (    skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
     if (a > 0) then (     arr[0+1] := arr[0+1] + 1 ) else (     arr[1+1] := arr[1+1] + 1 ) ) ;  ) ;  
    if (arr[0+1] <= 1 or arr[1+1] <= 1) then (     OclFile["System.out"].print("Yes") ) else (     OclFile["System.out"].print("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  private static final int MOD=1000003 ;
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter writer=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    int n=Integer.parseInt(reader.readLine());
    long ans=n==0 ? 1 : pow(3,n-1,MOD);
    writer.println(ans);
    reader.close();
    writer.close();
  }
  static long pow(int a,int p,int m){
    if(p==0)return(long)1 % m ;
    if(p==1)return(long)a % m ;
    long v=pow(a,p/2,m);
    long ans=v*v % m ;
    if(p % 2==1)ans=ans*a % m ;
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static    attribute MOD : int := 1000003;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    var n : int ; n := (reader.readLine())->toInteger() ;
    var ans : long ; ans := if n = 0 then 1 else pow(3, n - 1, MOD) endif ;
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation pow( a : int, p : int, m : int) : long
  pre: true
  post: true
  activity: (     if (p = 0) then     return 1->oclAsType(long) mod m else skip ; 
     if (p = 1) then     return a->oclAsType(long) mod m else skip ; 
    var v : long ; v := pow(a, p / 2, m) ;
    var ans : long ; ans := v * v mod m ;
    if (p mod 2 = 1) then     ans := ans * a mod m ; else skip ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(1,in,out);
    out.close();
  }
  public static class Task {
    int mod=1000000+3 ;
    public long t(int n){
      if(n>2){
        return s(n-1)+2*t(n-1);
      }
      else if(n==2){
        return 3 ;
      }
      else if(n==0){
        return 1 ;
      }
      else {
        return 0 ;
      }
    }
    public long s(int n){
      if(n==0){
        return 1 ;
      }
      else if(n<0){
        return 0 ;
      }
      return s(n-1)+2*t(n-1);
    }
    public void solve(int cnt,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int ret=1 ;
      for(int i=0 ; i<n-1 ; i++){
        ret=(ret*3)% mod ;
      }
      out.println(ret);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class Task {
   attribute mod : int := 1000000 + 3;
   operation t( n : int) : long
  pre: true
  post: true
  activity: (     if (n > 2) then (     return s(n - 1) + 2 * t(n - 1) ) else     if (n = 2) then (     return 3 ) else     if (n = 0) then (     return 1 ) else (     return 0 ) ;  ;  );
   operation s( n : int) : long
  pre: true
  post: true
  activity: (     if (n = 0) then (     return 1 ) else     if (n < 0) then (     return 0 ) else skip ; ;  
     return s(n - 1) + 2 * t(n - 1) );
   operation solve( cnt : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var ret : int ; ret := 1 ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     ret := (ret * 3) mod mod )  ;     i := i + 1 ) ; 
     skip );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A70 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int answer=1 ;
    while(N>1){
      N--;
      answer*=3 ;
      answer %=1000003 ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A70 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var answer : int ; answer := 1 ;
    while (N > 1) do (     N := N - 1 ; 
     answer := answer*(3) ; 
     answer := answer mod 1000003 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.*;
import java.awt.geom.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] $){
    Scanner sc=new Scanner(in);
    int[] prime=Generate_prime(1299709);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int d=Arrays.binarySearch(prime,n);
      if(n==1 || d>0){
        out.println(0);
      }
      else {
        d=~ d ;
        out.println(prime[d]-prime[d-1]);
      }
    }
  }
  static int[] Generate_prime(int n){
    ArrayList<Integer>prime=new ArrayList<>();
    prime.add(2);
    prime.add(3);
    for(int i=6 ; i<=n ; i+=6){
      int p1=i-1,p2=i+1 ;
      if(isPrime(p1))prime.add(p1);
      if(isPrime(p2))prime.add(p2);
    }
    int t=prime.size();
    int[] Generated_prime=new int[t+1];
    for(int i=1 ; i<=t ; i++){
      Generated_prime[i]=prime.get(i-1);
    }
    return Generated_prime ;
  }
  static boolean isPrime(int p){
    if(p==1)return false ;
    int t=(int)(sqrt(p)+1);
    boolean f=true ;
    for(int i=5 ; i<=t && f ; i++)if(p % i==0)f=false ;
    return f ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var prime : Sequence(int) ; prime := Generate_prime(1299709) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
     var d : int ; d := (prime->indexOf(n) - 1) ;
     if (n = 1 or d > 0) then (     out.println(0) ) else (     d := -(d + 1) ; 
     out.println(prime[d+1] - prime[d - 1+1]) ) ) );
  static   operation Generate_prime( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var prime : Sequence(int) ; prime := Sequence{} ;
     prime := prime->including(2) ; 
    prime := prime->including(3) ; 
        var i : int ; i := 6 ; while i <= n do ( (     var p1 : int ; p1 := i - 1 ;
    var p2 : int ; p2 := i + 1 ;
     if (isPrime(p1)) then     prime := prime->including(p1) ; else skip ; 
     if (isPrime(p2)) then     prime := prime->including(p2) ; else skip )  ;     i := i+(6) ) ; 
    var t : int ; t := prime->size() ;
    var Generated_prime : Sequence(int) ; Generated_prime := Integer.subrange(1,t + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= t do ( (     Generated_prime[i+1] := prime->at(i - 1+1) )  ;     i := i + 1 ) ; 
    return Generated_prime 
 );
  static   operation isPrime( p : int) : boolean
  pre: true
  post: true
  activity: (     if (p = 1) then     return false else skip ; 
     var t : int ; t := (sqrt(p) + 1)->oclAsType(int) ;
    var f : boolean ; f := true ;
        var i : int ; i := 5 ; while i <= t & f do (     if (p mod i = 0) then     f := false ; else skip ;  ;     i := i + 1 ) ; 
    return f 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayDeque ;
import java.util.Deque ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    line=br.readLine();
    Deque<Character>az=new ArrayDeque<>();
    boolean a=true ;
    for(int i=0 ; i<line.length(); i++){
      char c=line.charAt(i);
      if(c=='A' && a){
        az.add(c);
        a=false ;
      }
      if(c=='Z' && ! a){
        az.add(c);
        a=true ;
      }
    }
    if(! az.isEmpty()&& az.peekLast()=='A'){
      az.pollLast();
    }
    if(! az.isEmpty()){
      for(char c : az){
        System.out.print(c);
      }
      System.out.println();
    }
    else {
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    line := br.readLine() ; 
    var az : Sequence(String) ; az := ArrayDeque<OclAny>.newArrayDeque() ;
    var a : boolean ; a := true ;
        var i : int ; i := 0 ; while i < line->size() do ( (     var c : String ; c := line->at(i+1) ;
     if (c = 'A' & a) then (     az := az->including(c) ; 
     a := false ) else skip ; 
     if (c = 'Z' & not(a)) then (     az := az->including(c) ; 
     a := true ) else skip )  ;     i := i + 1 ) ; 
    if (not(az->isEmpty()) & az.peekLast() = 'A') then (     az := az->front() ) else skip ; 
    if (not(az->isEmpty())) then (     for (c : az) do ( (     OclFile["System.out"].print(c) )  ) ; 
     OclFile["System.out"].println() ) else (     OclFile["System.out"].println(-1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSetBits(int n){
    int bitCount=0 ;
    for(int i=1 ; i<=n ; i++)bitCount+=countSetBitsUtil(i);
    return bitCount ;
  }
  static int countSetBitsUtil(int x){
    if(x<=0)return 0 ;
    return(x % 2==0 ? 0 : 1)+countSetBitsUtil(x/2);
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.print("Total set bit count is ");
    System.out.print(countSetBits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     var bitCount : int ; bitCount := 0 ;
         var i : int ; i := 1 ; while i <= n do (     bitCount := bitCount+(countSetBitsUtil(i)) ;  ;     i := i + 1 ) ; 
     return bitCount );
  static   operation countSetBitsUtil( x : int) : int
  pre: true
  post: true
  activity: (     if (x <= 0) then     return 0 else skip ; 
     return (if x mod 2 = 0 then 0 else 1 endif) + countSetBitsUtil(x / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].print("Total set bit count is ") ; 
     OclFile["System.out"].print(countSetBits(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MOD=(int)(1e9+7);
  static int modulo_13(String s,int n){
    long[][] dp=new long[n+1][13];
    dp[0][0]=1 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<10 ; j++){
        int nxt=s.charAt(i)-'0' ;
        if(s.charAt(i)=='?')nxt=j ;
        for(int k=0 ; k<13 ; k++){
          int rem=(10*k+nxt)% 13 ;
          dp[i+1][rem]+=dp[i][k];
          dp[i+1][rem] %=MOD ;
        }
        if(s.charAt(i)!='?')break ;
      }
    }
    return(int)dp[n][5];
  }
  public static void main(String[] args){
    String s="?44" ;
    int n=s.length();
    System.out.println(modulo_13(s,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MOD : int := (1e9 + 7)->oclAsType(int);
  static   operation modulo_13( s : String, n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,13)->collect(0)) ;
     dp[0+1][0+1] := 1 ; 
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 10 do ( (     var nxt : int ; nxt := s->at(i+1) - ('0')->char2byte() ;
     if (s->at(i+1) = '?') then     nxt := j ; else skip ; 
         var k : int ; k := 0 ; while k < 13 do ( (     var rem : int ; rem := (10 * k + nxt) mod 13 ;
     dp[i + 1+1][rem+1] := dp[i + 1+1][rem+1]+(dp[i+1][k+1]) ; 
     dp[i + 1+1][rem+1] := dp[i + 1+1][rem+1] mod MOD )  ;     k := k + 1 ) ; 
     if (s->at(i+1) /= '?') then     break else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return dp[n+1][5+1]->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "?44" ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].println(modulo(moduloOclFile["System.out"].println(modulo(modulo    OclFile["System.out"].println(modulo(moduloOclFile["System.out"].println(modulo(modulo    var s : String ; s := "?44" ;
3(s, n))3(s, n))3(s, n))3(s, n)) ;3(s, n))3(s, n))3(s, n))3(s, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countNums(int a,int b,int c,int d){
    int x=b/c-(a-1)/c ;
    int y=b/d-(a-1)/d ;
    int k=(c*d)/__gcd(c,d);
    int z=b/k-(a-1)/k ;
    return b-a+1-x-y+z ;
  }
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  public static void main(String[] args){
    int a=10,b=50,c=4,d=6 ;
    System.out.println(countNums(a,b,c,d));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countNums( a : int, b : int, c : int, d : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := b / c - (a - 1) / c ;
     var y : int ; y := b / d - (a - 1) / d ;
    var k : int ; k := (c * d) / __gcd(c, d) ;
    var z : int ; z := b / k - (a - 1) / k ;
    return b - a + 1 - x - y + z 
 );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 10 ;
    var b : int ; b := 50 ;
    var c : int ; c := 4 ;
    var d : int ; d := 6 ;
     OclFile["System.out"].println(countNums(a, b, c, d)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static void printSubstrings(int n){
    int s=(int)Math.log10(n);
    int d=(int)(Math.pow(10,s)+0.5);
    int k=d ;
    while(n>0){
      while(d>0){
        System.out.println(n/d);
        d=d/10 ;
      }
      n=n % k ;
      k=k/10 ;
      d=k ;
    }
  }
  public static void main(String args[]){
    int n=123 ;
    printSubstrings(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printSubstrings( n : int) : void
  pre: true
  post: true
  activity: (     var s : int ; s := (n)->log10()->oclAsType(int) ;
     var d : int ; d := (10->pow(s) + 0.5)->oclAsType(int) ;
     var k : int ; k := d ;
     while (n > 0) do (     while (d > 0) do (     OclFile["System.out"].println(n / d) ; 
     d := d / 10 ) ; 
     n := n mod k ; 
     k := k / 10 ; 
     d := k ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 123 ;
     execute printSubstrings(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static char NthCharacter(int n){
    String s="" ;
    int c=1 ;
    for(int i=1 ; ; i++){
      if(c<10)s+=Integer.toString(c);
      else {
        String s1="" ;
        int dup=c ;
        while(dup>0){
          s1+=Integer.toString(dup % 10);
          dup/=10 ;
        }
        StringBuilder temp=new StringBuilder();
        temp.append(s1);
        temp=temp.reverse();
        s+=temp ;
      }
      c++;
      if(s.length()>=n){
        return s.charAt(n-1);
      }
    }
  }
  public static void main(String[] args){
    int n=11 ;
    System.out.println(NthCharacter(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation NthCharacter( n : int) : String
  pre: true
  post: true
  activity: (     var s : String ; s := "" ;
     var c : int ; c := 1 ;
         var i : int ; i := 1 ; while true do ( (     if (c < 10) then     s := s+(((c) + "")) else (     var s1 : String ; s1 := "" ;
     var dup : int ; dup := c ;
    while (dup > 0) do (     s1 := s1+(((dup mod 10) + "")) ; 
     dup := dup/(10) ) ; 
    var temp : String ; temp := StringLib.newString() ;
    temp := temp + StringLib.newString(s1) ; 
    temp := temp->reverse() ;     temp := temp->reverse() ; 
    s := s+(temp) ; 
 ) ;  
     c := c + 1 ; 
     if (s->size() >= n) then (     return s->at(n - 1+1) ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 11 ;
     OclFile["System.out"].println(NthCharacter(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner leer=new Scanner(System.in);
    int w=leer.nextInt();
    int n=0,j=n ;
    for(int i=0 ; i<w ; i++){
      int q=leer.nextInt();
      int y=leer.nextInt();
      if(q>0){
        n++;
      }
      else {
        j++;
      }
    }
    if(j>1 && n>1){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var leer : OclFile ; leer := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := leer.getCurrent()->toInteger() ;
    var n : int ; n := 0 ;
    var j : int ; j := n ;
        var i : int ; i := 0 ; while i < w do ( (     var q : int ; q := leer.getCurrent()->toInteger() ;
     var y : int ; y := leer.getCurrent()->toInteger() ;
     if (q > 0) then (     n := n + 1 ) else (     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (j > 1 & n > 1) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int tosi[]=new int[n];
    int M[]=new int[n];
    int D[]=new int[n];
    int i ;
    int k ;
    int c=0 ;
    for(k=0 ; k<n ; k++){
      int total=0 ;
      int day=0 ;
      tosi[k]=sc.nextInt();
      M[k]=sc.nextInt();
      D[k]=sc.nextInt();
      for(i=tosi[k]+1 ; i<=1000 ; i++){
        if(i % 3==0){
          total+=200 ;
        }
        else {
          total+=195 ;
        }
      }
      if(tosi[k] % 3==0){
        int tuki=(M[k]-1)*20 ;
        day=tuki+D[k]-6 ;
      }
      else {
        if((M[k]-1)% 2==0){
          day=((M[k]-1)/2)*20+((M[k]-1)/2)*19+D[k]-1 ;
        }
        else {
          day=((M[k])/2)*20+((M[k]-1)/2)*19+D[k]-1 ;
        }
      }
      total=total-day ;
      System.out.println(total);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var tosi : Sequence(int) ; tosi := Integer.subrange(1,n)->collect(0) ;
    var M : Sequence(int) ; M := Integer.subrange(1,n)->collect(0) ;
    var D : Sequence(int) ; D := Integer.subrange(1,n)->collect(0) ;
    var i : int ;
    var k : int ;
    var c : int ; c := 0 ;
        k := 0 ; while k < n do ( (     var total : int ; total := 0 ;
     var day : int ; day := 0 ;
    tosi[k+1] := sc.getCurrent()->toInteger() ; 
    M[k+1] := sc.getCurrent()->toInteger() ; 
    D[k+1] := sc.getCurrent()->toInteger() ; 
        i := tosi[k+1] + 1 ; while i <= 1000 do ( (     if (i mod 3 = 0) then (     total := total+(200) ) else (     total := total+(195) ) )  ;     i := i + 1 ) ; 
    if (tosi[k+1] mod 3 = 0) then (     var tuki : int ; tuki := (M[k+1] - 1) * 20 ;
     day := tuki + D[k+1] - 6 ) else (     if ((M[k+1] - 1) mod 2 = 0) then (     day := ((M[k+1] - 1) / 2) * 20 + ((M[k+1] - 1) / 2) * 19 + D[k+1] - 1 ) else (     day := ((M[k+1]) / 2) * 20 + ((M[k+1] - 1) / 2) * 19 + D[k+1] - 1 ) ) ;  
    total := total - day ; 
    OclFile["System.out"].println(total) ; 
 )  ;     k := k + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static final int MAX=1000 ;
  public static void main(String[] args){
    int base=calc(MAX,1,1);
    try(Scanner scn=new Scanner(System.in)){
      int lmt=scn.nextInt();
      for(int i=0 ; i<lmt ; i++){
        System.out.println(base-calc(scn.nextInt(),scn.nextInt(),scn.nextInt()));
      }
    }
  }
  public static int calc(int y,int m,int d){
    int rslt=0 ;
    rslt+=~-y/3*590 ;
    rslt+=~-y % 3*195 ;
    if(y % 3==0){
      rslt+=~-m*20 ;
    }
    else {
      rslt+=~-m/2*39 ;
      rslt+=~-m % 2*20 ;
    }
    rslt+=d ;
    return rslt ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 1000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var base : int ; base := calc(MAX, 1, 1) ;
     try (    var scn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var lmt : int ; lmt := scn.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < lmt do ( (     OclFile["System.out"].println(base - calc(scn.getCurrent()->toInteger(), scn.getCurrent()->toInteger(), scn.getCurrent()->toInteger())) )  ;     i := i + 1 ) ))  );
  static   operation calc( y : int, m : int, d : int) : int
  pre: true
  post: true
  activity: (     var rslt : int ; rslt := 0 ;
     rslt := rslt+(-(-y + 1) / 3 * 590) ; 
    rslt := rslt+(-(-y + 1) mod 3 * 195) ; 
    if (y mod 3 = 0) then (     rslt := rslt+(-(-m + 1) * 20) ) else (     rslt := rslt+(-(-m + 1) / 2 * 39) ; 
     rslt := rslt+(-(-m + 1) mod 2 * 20) ) ;  
    rslt := rslt+(d) ; 
    return rslt 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[])throws Exception {
    final int L=20 ;
    final int S=19 ;
    final int[] DAY_YEAR={
      L,S,L,S,L,S,L,S,L,S };
      final int DAYS_YEAR=5*(L+S);
      final int DAYS_LEAP_YEAR=10*L ;
      final int NUM_MILL=(999-999/3)*DAYS_YEAR+999/3*DAYS_LEAP_YEAR+1 ;
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      int N=Integer.parseInt(br.readLine());
      int year,month,day ;
      int num_tot,num_prev_year,num_this_year ;
      for(int i=0 ; i<N ; i++){
        String[] buf=br.readLine().split(" ");
        year=Integer.parseInt(buf[0]);
        month=Integer.parseInt(buf[1]);
        day=Integer.parseInt(buf[2]);
        num_prev_year=(year-1-(year-1)/3)*DAYS_YEAR+(year-1)/3*DAYS_LEAP_YEAR ;
        if(year % 3==0){
          num_this_year=(month-1)*L+day ;
        }
        else {
          num_this_year=0 ;
          for(int j=0 ; j<month-1 ; j++){
            num_this_year+=DAY_YEAR[j];
          }
          num_this_year+=day ;
        }
        num_tot=num_prev_year+num_this_year ;
        System.out.println(NUM_MILL-num_tot);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 20 ;
     var S : int ; S := 19 ;
    var DAY_YEAR : Sequence(int) ; DAY_YEAR := Sequence{L,S,L,S,L,S,L,S,L,S} ;
    var DAYS_YEAR : int ; DAYS_YEAR := 5 * (L + S) ;
    var DAYS_LEAP_YEAR : int ; DAYS_LEAP_YEAR := 10 * L ;
    var NUM_MILL : int ; NUM_MILL := (999 - 999 / 3) * DAYS_YEAR + 999 / 3 * DAYS_LEAP_YEAR + 1 ;
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var N : int ; N := (br.readLine())->toInteger() ;
    var year : int ;
    var month : int ;
    var day : int ;
    var num_tot : int ;
    var num_prev_year : int ;
    var num_this_year : int ;
        var i : int ; i := 0 ; while i < N do ( (     var buf : Sequence(String) ; buf := br.readLine()->split(" ") ;
     year := (buf[0+1])->toInteger() ; 
    month := (buf[1+1])->toInteger() ; 
    day := (buf[2+1])->toInteger() ; 
    num_prev_year := (year - 1 - (year - 1) / 3) * DAYS_YEAR + (year - 1) / 3 * DAYS_LEAP_YEAR ; 
    if (year mod 3 = 0) then (     num_this_year := (month - 1) * L + day ) else (     num_this_year := 0 ; 
         var j : int ; j := 0 ; while j < month - 1 do ( (     num_this_year := num_this_year+(DAY_YEAR[j+1]) )  ;     j := j + 1 ) ; 
     num_this_year := num_this_year+(day) ) ;  
    num_tot := num_prev_year + num_this_year ; 
    OclFile["System.out"].println(NUM_MILL - num_tot) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static void solve(){
    int y=in.nextInt();
    int m=in.nextInt();
    int d=in.nextInt();
    int cnt=0 ;
    for(int i=y+1 ; i<1000 ; i++){
      for(int j=1 ; j<=10 ; j++){
        for(int k=1 ; k<=(j % 2==1 || i % 3==0 ? 20 : 19); k++){
          cnt++;
        }
      }
    }
    for(int j=m+1 ; j<=10 ; j++){
      for(int k=1 ; k<=(j % 2==1 || y % 3==0 ? 20 : 19); k++){
        cnt++;
      }
    }
    for(int k=d ; k<=(m % 2==1 || y % 3==0 ? 20 : 19); k++){
      cnt++;
    }
    out.println(cnt);
  }
  public static void main(String[] args){
    long start=System.currentTimeMillis();
    int n=in.nextInt();
    while(n-->0)solve();
    out.flush();
    long end=System.currentTimeMillis();
    in.close();
    out.close();
  }
  static void trace(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var y : int ; y := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := y + 1 ; while i < 1000 do ( (         var j : int ; j := 1 ; while j <= 10 do ( (         var k : int ; k := 1 ; while k <= (if j mod 2 = 1 or i mod 3 = 0 then 20 else 19 endif) do ( (     cnt := cnt + 1 )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var j : int ; j := m + 1 ; while j <= 10 do ( (         var k : int ; k := 1 ; while k <= (if j mod 2 = 1 or y mod 3 = 0 then 20 else 19 endif) do ( (     cnt := cnt + 1 )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
        var k : int ; k := d ; while k <= (if m mod 2 = 1 or y mod 3 = 0 then 20 else 19 endif) do ( (     cnt := cnt + 1 )  ;     k := k + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : long ; start := OclDate.getSystemTime() ;
     var n : int ; n := in.getCurrent()->toInteger() ;
        while (n > 0) do (        n := n - 1 ;     skip ;     execute solve() ; ;  ) ;  
    skip ; 
    var end : long ; end := OclDate.getSystemTime() ;
    skip ; 
    skip ; 
 );
  static   operation trace( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    ArrayList<String>input=new ArrayList<String>();
    Scanner insert=new Scanner(System.in);
    String line=insert.nextLine();
    int nn=Integer.parseInt(line);
    for(int i=0 ; i<nn ; i++){
      String line2=insert.nextLine();
      if(line2.equals("")){
        break ;
      }
      input.add(line2);
    }
    for(String a : input){
      int sum=0 ;
      String array1[]=a.split(" ");
      int y=Integer.parseInt(array1[0]);
      int m=Integer.parseInt(array1[1]);
      int day=Integer.parseInt(array1[2]);
      int n=1000-y ;
      for(int i=0 ; i<n ; i++){
        if(i % 3==0){
          sum+=200 ;
        }
        else {
          sum+=195 ;
        }
      }
      if(y % 3==0){
        for(int i=1 ; i<=m ; i++){
          sum-=20 ;
        }
      }
      else {
        for(int i=1 ; i<=m ; i++){
          if(i % 2==0){
            sum-=19 ;
          }
          else {
            sum-=20 ;
          }
        }
      }
      if((y % 3!=0)&&(m % 2==0)){
        sum+=(20-day);
      }
      else {
        sum+=(21-day);
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : Sequence(String) ; input := Sequence{} ;
     var insert : OclFile ; insert := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var line : String ; line := insert.nextLine() ;
    var nn : int ; nn := (line)->toInteger() ;
        var i : int ; i := 0 ; while i < nn do ( (     var line2 : String ; line2 := insert.nextLine() ;
     if (line2 = "") then (     break ) else skip ; 
     input := input->including(line2) )  ;     i := i + 1 ) ; 
    for (a : input) do ( (     var sum : int ; sum := 0 ;
     var array1 : Sequence(String) ; array1 := a->split(" ") ;
    var y : int ; y := (array1[0+1])->toInteger() ;
    var m : int ; m := (array1[1+1])->toInteger() ;
    var day : int ; day := (array1[2+1])->toInteger() ;
    var n : int ; n := 1000 - (y)->char2byte() ;
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 3 = 0) then (     sum := sum+(200) ) else (     sum := sum+(195) ) )  ;     i := i + 1 ) ; 
    if (y mod 3 = 0) then (         var i : int ; i := 1 ; while i <= m do ( (     sum := sum-(20) )  ;     i := i + 1 ) ) else (         var i : int ; i := 1 ; while i <= m do ( (     if (i mod 2 = 0) then (     sum := sum-(19) ) else (     sum := sum-(20) ) )  ;     i := i + 1 ) ) ;  
    if ((y mod 3 /= 0) & (m mod 2 = 0)) then (     sum := sum+((20 - day)) ) else (     sum := sum+((21 - day)) ) ;  
    OclFile["System.out"].println(sum) ; 
 )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean check_prime(int n){
    if(n<=1){
      return false ;
    }
    if(n<=3){
      return true ;
    }
    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 ;
  }
  static int countPrimeFrequent(String s){
    int count=0 ;
    Map<Character,Integer>mp=new HashMap<>();
    for(int i=0 ; i<s.length(); i++){
      if(mp.containsKey(s.charAt(i))){
        mp.put(s.charAt(i),mp.get(s.charAt(i))+1);
      }
      else {
        mp.put(s.charAt(i),1);
      }
    }
    for(Map.Entry<Character,Integer>entry : mp.entrySet()){
      if(check_prime(entry.getValue())){
        count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    String s="geeksforgeeks" ;
    System.out.println(countPrimeFrequent(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check_prime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then (     return false ) else skip ; 
     if (n <= 3) then (     return true ) else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then (     return false ) else skip ; 
        var i : int ; i := 5 ; while i * i <= n do ( (     if (n mod i = 0 or n mod (i + 2) = 0) then (     return false ) else skip )  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation countPrimeFrequent( s : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var mp : Map(String,int) ; mp := Map{} ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (mp->keys()->includes(s->at(i+1))) then (     mp := mp->union(Map{s->at(i+1) |-> mp->at(s->at(i+1)) + 1}) ) else (     mp := mp->union(Map{s->at(i+1) |-> 1}) ) )  ;     i := i + 1 ) ; 
    for (entry : mp->asSet()) do ( (     if (check_prime(entry.getValue())) then (     count := count + 1 ) else skip )  ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     OclFile["System.out"].println(countPrimeFrequent(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void Swap(int[] array,int position1,int position2){
    int temp=array[position1];
    array[position1]=array[position2];
    array[position2]=temp ;
  }
  static int partition(int[] arr,int low,int high){
    int pivot=arr[high];
    int i=(low-1);
    for(int j=low ; j<=high-1 ; j++){
      if(arr[j]<=pivot){
        i++;
        Swap(arr,i,j);
      }
    }
    Swap(arr,i+1,high);
    return(i+1);
  }
  static void quickSort(int[] arr,int low,int high){
    if(low<high){
      int pi=partition(arr,low,high);
      quickSort(arr,low,pi-1);
      quickSort(arr,pi+1,high);
    }
  }
  static void printArray(int[] arr,int size){
    int i ;
    for(i=0 ; i<size ; i++)System.out.print(" "+arr[i]);
    System.out.println();
  }
  static public void main(String[] args){
    int[] arr={
      10,7,8,9,1,5 };
      int n=arr.length ;
      quickSort(arr,0,n-1);
      System.out.println("Sorted array: ");
      printArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Swap( array : Sequence(int), position1 : int, position2 : int) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := array[position1+1] ;
     array[position1+1] := array[position2+1] ; 
     array[position2+1] := temp );
  static   operation partition( arr : Sequence(int), low : int, high : int) : int
  pre: true
  post: true
  activity: (     var pivot : int ; pivot := arr[high+1] ;
     var i : int ; i := (low - 1) ;
        var j : int ; j := low ; while j <= high - 1 do ( (     if (arr[j+1] <= pivot) then (     i := i + 1 ; 
     execute Swap(arr, i, j) ) else skip )  ;     j := j + 1 ) ; 
    execute Swap(arr, i + 1, high) ; 
    return (i + 1) 
 );
  static   operation quickSort( arr : Sequence(int), low : int, high : int) : void
  pre: true
  post: true
  activity: (     if (low < high) then (     var pi : int ; pi := partition(arr, low, high) ;
     execute quickSort(arr, low, pi - 1) ; 
     execute quickSort(arr, pi + 1, high) ) else skip );
  static   operation printArray( arr : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
         i := 0 ; while i < size do (     OclFile["System.out"].print(" " + arr[i+1]) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,7,8,9,1,5} ;
     var n : int ; n := arr->size() ;
    execute quickSort(arr, 0, n - 1) ; 
    OclFile["System.out"].println("Sorted array: ") ; 
    execute printArray(arr, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int m=input.nextInt();
    ArrayList<Integer>req=new ArrayList();
    ArrayList<Integer>pre=new ArrayList();
    for(int i=0 ; i<n ; i++){
      req.add(input.nextInt());
    }
    for(int i=0 ; i<m ; i++){
      pre.add(input.nextInt());
    }
    int i=n-1,j=m-1 ;
    int ans=0 ;
    while(i>=0 && j>=0){
      if(req.get(i)>pre.get(j)){
        ans++;
      }
      else {
        j--;
      }
      i--;
    }
    System.out.print(ans+i+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var m : int ; m := input.getCurrent()->toInteger() ;
    var req : Sequence(int) ; req := Sequence{} ;
    var pre : Sequence(int) ; pre := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     req := req->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     pre := pre->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var i : int ; i := n - 1 ;
    var j : int ; j := m - 1 ;
    var ans : int ; ans := 0 ;
    while (i >= 0 & j >= 0) do (     if (req->at(i+1) > pre->at(j+1)) then (     ans := ans + 1 ) else (     j := j - 1 ) ;  
     i := i - 1 ) ; 
    OclFile["System.out"].print(ans + i + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class LC {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    ArrayList<Integer>one=new ArrayList<>();
    ArrayList<Integer>two=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      one.add(sc.nextInt());
    }
    for(int i=0 ; i<m ; i++){
      two.add(sc.nextInt());
    }
    Collections.sort(one);
    Collections.sort(two);
    int i=0,j=0 ;
    while(i<one.size()&& j<two.size()){
      if(one.get(i)<=two.get(j)){
        i++;
        j++;
      }
      else j++;
    }
    System.out.println(one.size()-i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class LC {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var one : Sequence(int) ; one := Sequence{} ;
    var two : Sequence(int) ; two := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     one := one->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     two := two->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    one := one->sort() ; 
    two := two->sort() ; 
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    while (i < one->size() & j < two->size()) do (     if (one->at(i+1) <= two->at(j+1)) then (     i := i + 1 ; 
     j := j + 1 ) else     j := j + 1 ; ) ; 
    OclFile["System.out"].println(one->size() - i) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B387 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int a[]=new int[n];
    int b[]=new int[m];
    String s=" " ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    for(int i=0 ; i<m ; i++){
      b[i]=sc.nextInt();
      s+=b[i]+" " ;
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int j=0 ;
      for(j=0 ; j<m ; j++){
        if(a[i]<=b[j])break ;
      }
      if(j==m)count++;
      else b[j]=0 ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B387 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
    var s : String ; s := " " ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := sc.getCurrent()->toInteger() ; 
     s := s+(b[i+1] + " ") )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var j : int ; j := 0 ;
         j := 0 ; while j < m do ( (     if (a[i+1] <= b[j+1]) then     break else skip )  ;     j := j + 1 ) ; 
     if (j = m) then     count := count + 1 ; else     b[j+1] := 0 ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    int[] digits={
      111111,110,1011011,1001111,1100110,1101101,1111101,100111,1111111,1101111 };
      for(; ; ){
        int n=sc.nextInt();
        if(n<0){
          break ;
        }
        int digit=0 ;
        for(int k=0 ; k<n ; k++){
          int m=sc.nextInt();
          int d=1000000 ;
          for(int i=0 ; i<7 ; i++){
            if((digit/d)% 10==(digits[m]/d)% 10){
              print("0");
            }
            else {
              print("1");
            }
            d/=10 ;
          }
          println("");
          digit=digits[m];
        }
      }
    }
    void debug(Object...os){
      System.err.println(Arrays.deepToString(os));
    }
    void print(String s){
      System.out.print(s);
    }
    void println(String s){
      System.out.println(s);
    }
    public static void main(String[] args){
      new Main().run();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     var digits : Sequence(int) ; digits := Sequence{111111,110,1011011,1001111,1100110,1101101,1111101,100111,1111111,1101111} ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n < 0) then (     break ) else skip ; 
     var digit : int ; digit := 0 ;
         var k : int ; k := 0 ; while k < n do ( (     var m : int ; m := sc.getCurrent()->toInteger() ;
     var d : int ; d := 1000000 ;
        var i : int ; i := 0 ; while i < 7 do ( (     if ((digit / d) mod 10 = (digits[m+1] / d) mod 10) then (     execute print("0") ) else (     execute print("1") ) ;  
     d := d/(10) )  ;     i := i + 1 ) ; 
    execute println("") ; 
    digit := digits[m+1] ; 
 )  ;     k := k + 1 ) )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int catalanDP(int n){
    int catalan[]=new int[n+2];
    catalan[0]=1 ;
    catalan[1]=1 ;
    for(int i=2 ; i<=n ; i++){
      catalan[i]=0 ;
      for(int j=0 ; j<i ; j++){
        catalan[i]+=catalan[j]*catalan[i-j-1];
      }
    }
    return catalan[n];
  }
  public static void main(String[] args){
    for(int i=0 ; i<10 ; i++){
      System.out.print(catalanDP(i)+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation catalanDP( n : int) : int
  pre: true
  post: true
  activity: (     var catalan : Sequence(int) ; catalan := Integer.subrange(1,n + 2)->collect(0) ;
     catalan[0+1] := 1 ; 
    catalan[1+1] := 1 ; 
        var i : int ; i := 2 ; while i <= n do ( (     catalan[i+1] := 0 ; 
         var j : int ; j := 0 ; while j < i do ( (     catalan[i+1] := catalan[i+1]+(catalan[j+1] * catalan[i - j - 1+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return catalan[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 10 do ( (     OclFile["System.out"].print(catalanDP(i) + " ") )  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p243 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p243().run());
  }
  private static final Fraction TARGET=new Fraction(BigInteger.valueOf(15499),BigInteger.valueOf(94744));
  public String run(){
    BigInteger totient=BigInteger.ONE ;
    BigInteger denominator=BigInteger.ONE ;
    for(int p=2 ; ; ){
      totient=totient.multiply(BigInteger.valueOf(p-1));
      denominator=denominator.multiply(BigInteger.valueOf(p));
      do p++;
      while(! Library.isPrime(p));
      if(new Fraction(totient,denominator).compareTo(TARGET)<0){
        for(int i=1 ; i<p ; i++){
          BigInteger numer=BigInteger.valueOf(i).multiply(totient);
          BigInteger denom=BigInteger.valueOf(i).multiply(denominator);
          if(new Fraction(numer,denom.subtract(BigInteger.ONE)).compareTo(TARGET)<0)return denom.toString();
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class p243 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p243.newp243().run()) );
  static    attribute TARGET : Fraction := Fraction.newFraction((15499 + "")->toLong(), (94744 + "")->toLong());
   operation run() : String
  pre: true
  post: true
  activity: (     var totient : long ; totient := 1 ;
     var denominator : long ; denominator := 1 ;
         var p : int ; p := 2 ; while true do ( (     totient := totient.multiply((p - 1 + "")->toLong()) ; 
     denominator := denominator.multiply((p + "")->toLong()) ; 
   while true do (    p := p + 1 ; ;
    if (not(Library.isPrime(p))) then skip else break) ; 
     if (Fraction.newFraction(totient, denominator)->compareTo(TARGET) < 0) then (         var i : int ; i := 1 ; while i < p do ( (     var numer : long ; numer := (i + "")->toLong().multiply(totient) ;
     var denom : long ; denom := (i + "")->toLong().multiply(denominator) ;
     if (Fraction.newFraction(numer, denom.subtract(1))->compareTo(TARGET) < 0) then     return denom+"" else skip )  ;     i := i + 1 ) ) else skip )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Ishu {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int i,j,x=0,y=0,k=0,dx,dy ;
    boolean flag=true ;
    String s ;
    char[] ch=new char[100];
    int[][] co=new int[2][101];
    s=scan.next();
    ch=s.toCharArray();
    co[0][k]=x ;
    co[1][k]=y ;
++k ;
    for(i=0 ; i<s.length(); ++i){
      switch(ch[i]){
        case 'L' :--x ;
        break ;
        case 'R' :++x ;
        break ;
        case 'U' :++y ;
        break ;
        case 'D' :--y ;
        break ;
      }
      co[0][k]=x ;
      co[1][k]=y ;
++k ;
    }
    for(i=0 ; i<k-3 ; ++i){
      for(j=i+3 ; j<k ; ++j){
        dx=co[0][i]-co[0][j];
        dy=co[1][i]-co[1][j];
        if(dx<0)dx*=(-1);
        if(dy<0)dy*=(-1);
        if((dx<=1 && dy==0)||(dy<=1 && dx==0)){
          flag=false ;
          break ;
        }
      }
      if(! flag)break ;
    }
    if(flag)System.out.println("OK");
    else System.out.println("BUG");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ishu {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ;
    var j : int ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var k : int ; k := 0 ;
    var dx : int ;
    var dy : int ;
    var flag : boolean ; flag := true ;
    var s : String ;
    var ch : Sequence(String) ; ch := Integer.subrange(1,100)->collect(0) ;
    var co : Sequence(Sequence(int)) ; co := Integer.subrange(1,2)->collect(Integer.subrange(1,101)->collect(0)) ;
    s := scan.getCurrent() ; 
    ch := s->characters() ; 
    co[0+1][k+1] := x ; 
    co[1+1][k+1] := y ; 
    k := k + 1 ; 
        i := 0 ; while i < s->size() do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (ch[i+1]) ; 
       if _switchval = 'L' then
     x := x - 1 ; 
    break 
   else skip ;
       if _switchval = 'R' then
     x := x + 1 ; 
    break 
   else skip ;
       if _switchval = 'U' then
     y := y + 1 ; 
    break 
   else skip ;
       if _switchval = 'D' then
     y := y - 1 ; 
    break 
   else skip ;
 )
     co[0+1][k+1] := x ; 
     co[1+1][k+1] := y ; 
     k := k + 1 )  ;     i := i + 1 ) ; 
        i := 0 ; while i < k - 3 do ( (         j := i + 3 ; while j < k do ( (     dx := co[0+1][i+1] - co[0+1][j+1] ; 
     dy := co[1+1][i+1] - co[1+1][j+1] ; 
    if (dx < 0) then     dx := dx*((-1)) ; else skip ; 
    if (dy < 0) then     dy := dy*((-1)) ; else skip ; 
    if ((dx <= 1 & dy = 0) or (dy <= 1 & dx = 0)) then (     flag := false ; 
     break ) else skip ; 
 )  ;     j := j + 1 ) ; 
     if (not(flag)) then     break else skip )  ;     i := i + 1 ) ; 
    if (flag) then     OclFile["System.out"].println("OK") else     OclFile["System.out"].println("BUG") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Task8B {
  private static int[][] stepL={
    {
-1,0 },{
        0,-1 },{
          0,+1 }
        };
        private static int[][] stepR={
          {
            1,0 },{
              0,-1 },{
                0,+1 }
              };
              private static int[][] stepU={
                {
-1,0 },{
                    1,0 },{
                      0,+1 }
                    };
                    private static int[][] stepD={
                      {
-1,0 },{
                          1,0 },{
                            0,-1 }
                          };
                          public static void main(String[] args){
                            char[] path ;
                            try {
                              BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
                              path=br.readLine().toCharArray();
                            }
                            catch(IOException e){
                              System.out.println(e);
                              return ;
                            }
                            boolean[][] map=new boolean[path.length*2+3][path.length*2+3];
                            int x=path.length+1 ;
                            int y=x ;
                            int[][] step ;
                            int j ;
                            for(int i=0 ; i<path.length ; i++){
                              map[x][y]=true ;
                              switch(path[i]){
                                case 'L' : x--;
                                step=stepL ;
                                break ;
                                case 'R' : x++;
                                step=stepR ;
                                break ;
                                case 'U' : y++;
                                step=stepU ;
                                break ;
                                case 'D' : y--;
                                step=stepD ;
                                break ;
                                default : System.out.println("Unknown step '"+path[i]+"'");
                                return ;
                              }
                              if(map[x][y]){
                                System.out.println("BUG");
                                return ;
                              }
                              for(j=0 ; j<3 ; j++){
                                if(map[x+step[j][0] ][y+step[j][1] ]){
                                  System.out.println("BUG");
                                  return ;
                                }
                              }
                            }
                            System.out.println("OK");
                          }
                        }

------------------------------------------------------------
OCL File:
---------
 class Task8B {
  static   attribute stepL : Sequence(Sequence(int)) := Sequence{Sequence{-1,0},Sequence{0,-1},Sequence{0,1}};
  static   attribute stepR : Sequence(Sequence(int)) := Sequence{Sequence{1,0},Sequence{0,-1},Sequence{0,1}};
  static   attribute stepU : Sequence(Sequence(int)) := Sequence{Sequence{-1,0},Sequence{1,0},Sequence{0,1}};
  static   attribute stepD : Sequence(Sequence(int)) := Sequence{Sequence{-1,0},Sequence{1,0},Sequence{0,-1}};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var path : Sequence(String) ;
     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     path := br.readLine()->characters() )   catch (e : IOException) do (     OclFile["System.out"].println(e) ; 
     return )
    var map : Sequence(Sequence(boolean)) ; map := Integer.subrange(1,path->size() * 2 + 3)->collect(Integer.subrange(1,path->size() * 2 + 3)->collect(false)) ;
    var x : int ; x := path->size() + 1 ;
    var y : int ; y := x ;
    var step : Sequence(Sequence(int)) ;
    var j : int ;
        var i : int ; i := 0 ; while i < path->size() do ( (     map[x+1][y+1] := true ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (path[i+1]) ; 
       if _switchval = 'L' then
     x := x - 1 ; 
    step := stepL ; 
    break 
   else skip ;
       if _switchval = 'R' then
     x := x + 1 ; 
    step := stepR ; 
    break 
   else skip ;
       if _switchval = 'U' then
     y := y + 1 ; 
    step := stepU ; 
    break 
   else skip ;
       if _switchval = 'D' then
     y := y - 1 ; 
    step := stepD ; 
    break 
   else skip ;
       if true then
     OclFile["System.out"].println("Unknown step '" + path[i+1] + "'") ; 
    return 
   else skip ;
 )
     if (map[x+1][y+1]) then (     OclFile["System.out"].println("BUG") ; 
     return ) else skip ; 
         j := 0 ; while j < 3 do ( (     if (map[x + step[j+1][0+1]+1][y + step[j+1][1+1]+1]) then (     OclFile["System.out"].println("BUG") ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("OK") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean isPrime(int n){
    if(n<=1)return false ;
    for(int i=2 ; i<=Math.sqrt(n); i++){
      if(n % i==0)return false ;
    }
    return true ;
  }
  static boolean isPossible(int N){
    if(isPrime(N)&& isPrime(N-2))return true ;
    else return false ;
  }
  public static void main(String[] args){
    int n=13 ;
    if(isPossible(n)==true)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
         var i : int ; i := 2 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation isPossible( N : int) : boolean
  pre: true
  post: true
  activity: (     if (isPrime(N) & isPrime(N - 2)) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 13 ;
     if (isPossible(n) = true) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int countDyckPaths(int n){
    int res=1 ;
    for(int i=0 ; i<n ; ++i){
      res*=(2*n-i);
      res/=(i+1);
    }
    return res/(n+1);
  }
  public static void main(String args[]){
    int n=4 ;
    System.out.println("Number of Dyck Paths is "+countDyckPaths(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countDyckPaths( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     res := res*((2 * n - i)) ; 
     res := res/((i + 1)) )  ;     i := i + 1 ) ; 
     return res / (n + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println("Number of Dyck Paths is " + countDyckPaths(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      System.out.println(solve(n));
    }
    sc.close();
  }
  static String solve(int n){
    if(n<=30){
      return "NO" ;
    }
    else if(n==36 || n==40 || n==44){
      return String.format("YES\n6 10 15 %d",n-31);
    }
    else {
      return String.format("YES\n6 10 14 %d",n-30);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(n)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( n : int) : String
  pre: true
  post: true
  activity: (     if (n <= 30) then (     return "NO" ) else     if (n = 36 or n = 40 or n = 44) then (     return StringLib.format("YES\n6 10 15 %d",Sequence{n - 31}) ) else (     return StringLib.format("YES\n6 10 14 %d",Sequence{n - 30}) ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int partition(int[] arr,int low,int high){
    int pivot=arr[low];
    int i=low-1,j=high+1 ;
    while(true){
      do {
        i++;
      }
      while(arr[i]<pivot);
      do {
        j--;
      }
      while(arr[j]>pivot);
      if(i>=j)return j ;
      int temp=arr[i];
      arr[i]=arr[j];
      arr[j]=temp ;
    }
  }
  static void quickSort(int[] arr,int low,int high){
    if(low<high){
      int pi=partition(arr,low,high);
      quickSort(arr,low,pi);
      quickSort(arr,pi+1,high);
    }
  }
  static void printArray(int[] arr,int n){
    for(int i=0 ; i<n ; i++)System.out.print(" "+arr[i]);
    System.out.println();
  }
  static public void main(String[] args){
    int[] arr={
      10,7,8,9,1,5 };
      int n=arr.length ;
      quickSort(arr,0,n-1);
      System.out.println("Sorted array: ");
      printArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation partition( arr : Sequence(int), low : int, high : int) : int
  pre: true
  post: true
  activity: (     var pivot : int ; pivot := arr[low+1] ;
     var i : int ; i := low - 1 ;
    var j : int ; j := high + 1 ;
     while (true) do (   while true do ((     i := i + 1 ) ;
    if (arr[i+1] < pivot) then skip else break) ; 
   while true do ((     j := j - 1 ) ;
    if (arr[j+1] > pivot) then skip else break) ; 
    if (i >= j) then     return j else skip ; 
    var temp : int ; temp := arr[i+1] ;
    arr[i+1] := arr[j+1] ; 
    arr[j+1] := temp ; 
 ) );
  static   operation quickSort( arr : Sequence(int), low : int, high : int) : void
  pre: true
  post: true
  activity: (     if (low < high) then (     var pi : int ; pi := partition(arr, low, high) ;
     execute quickSort(arr, low, pi) ; 
     execute quickSort(arr, pi + 1, high) ) else skip );
  static   operation printArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(" " + arr[i+1]) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,7,8,9,1,5} ;
     var n : int ; n := arr->size() ;
    execute quickSort(arr, 0, n - 1) ; 
    OclFile["System.out"].println("Sorted array: ") ; 
    execute printArray(arr, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      if(n<=30)System.out.println("NO");
      else {
        System.out.println("YES");
        int rem=n-30 ;
        if(rem==6 || rem==10 || rem==14)System.out.println("6 10 15 "+(n-31));
        else System.out.println("6 10 14 "+(n-30));
      }
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n <= 30) then     OclFile["System.out"].println("NO") ; else (     OclFile["System.out"].println("YES") ; 
     var rem : int ; rem := n - 30 ;
     if (rem = 6 or rem = 10 or rem = 14) then     OclFile["System.out"].println("6 10 15 " + (n - 31)) ; else     OclFile["System.out"].println("6 10 14 " + (n - 30)) ; ) ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Round660A {
  public static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    long t=Integer.parseInt(br.readLine());
    while(t-->0){
      int n=Integer.parseInt(br.readLine());
      String ans="NO" ;
      if(n>30){
        ans="YES" ;
      }
      pw.println(ans);
      if(ans=="YES"){
        int[] nearly=new int[] {
          6,10,14,15,21,35 };
          printloop : for(int i=0 ;
          i<nearly.length ;
          i++){
            for(int j=i+1 ; j<nearly.length ; j++){
              for(int z=j+1 ; z<nearly.length ; z++){
                int notPrime=n-(nearly[i]+nearly[j]+nearly[z]);
                if(notPrime>0 && notPrime!=nearly[i] && notPrime!=nearly[j] && notPrime!=nearly[z]){
                  pw.println(nearly[i]+" "+nearly[j]+" "+nearly[z]+" "+notPrime);
                  break printloop ;
                }
              }
            }
          }
        }
      }
      pw.close();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Round660A {
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : long ; t := (br.readLine())->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
     var ans : String ; ans := "NO" ;
    if (n > 30) then (     ans := "YES" ) else skip ; 
    skip ; 
    if (ans = "YES") then (     var nearly : Sequence(int) ; nearly := Sequence{6,10,14,15,21,35} ;
         var i : int ; i := 0 ; while i < nearly->size() do ( (         var j : int ; j := i + 1 ; while j < nearly->size() do ( (         var z : int ; z := j + 1 ; while z < nearly->size() do ( (     var notPrime : int ; notPrime := n - (nearly[i+1] + nearly[j+1] + nearly[z+1]) ;
     if (notPrime > 0 & notPrime /= nearly[i+1] & notPrime /= nearly[j+1] & notPrime /= nearly[z+1]) then (     skip ; 
     break ) else skip )  ;     z := z + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; ) else skip ; 
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1535_FairPlayOff {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int a=input.nextInt();
      int b=input.nextInt();
      int c=input.nextInt();
      int d=input.nextInt();
      int team1Winner=Math.max(a,b);
      int team2Winner=Math.max(c,d);
      int team1Loser=Math.min(a,b);
      int team2Loser=Math.min(c,d);
      int second=Math.min(team1Winner,team2Winner);
      int third=Math.max(team1Loser,team2Loser);
      if(second>third){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1535_FairPlayOff {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var a : int ; a := input.getCurrent()->toInteger() ;
     var b : int ; b := input.getCurrent()->toInteger() ;
    var c : int ; c := input.getCurrent()->toInteger() ;
    var d : int ; d := input.getCurrent()->toInteger() ;
    var team1Winner : int ; team1Winner := Set{a, b}->max() ;
    var team2Winner : int ; team2Winner := Set{c, d}->max() ;
    var team1Loser : int ; team1Loser := Set{a, b}->min() ;
    var team2Loser : int ; team2Loser := Set{c, d}->min() ;
    var second : int ; second := Set{team1Winner, team2Winner}->min() ;
    var third : int ; third := Set{team1Loser, team2Loser}->max() ;
    if (second > third) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test271 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int x=in.nextInt();
      if(x<31){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
        if(x-30==6){
          System.out.println("6 10 15 5");
        }
        else if(x-30==10){
          System.out.println("6 10 15 9");
        }
        else if(x-30==14){
          System.out.println("6 10 15 13");
        }
        else {
          System.out.println("6 10 14 "+(x-30));
        }
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test271 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     if (x < 31) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ; 
     if (x - 30 = 6) then (     OclFile["System.out"].println("6 10 15 5") ) else     if (x - 30 = 10) then (     OclFile["System.out"].println("6 10 15 9") ) else     if (x - 30 = 14) then (     OclFile["System.out"].println("6 10 15 13") ) else (     OclFile["System.out"].println("6 10 14 " + (x - 30)) ) ;  ;  ) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    int ans=a[0];
    for(int i=1 ; i<n ; i++){
      ans=gcd(ans,a[i]);
    }
    System.out.println(ans);
  }
  private static int gcd(int a,int b){
    if(b==0){
      return a ;
    }
    return gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := a[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     ans := gcd(ans, a[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else skip ; 
     return gcd(b, a mod b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  private static void solve(){
    int n=ni();
    int[] ary=na(n);
    Arrays.sort(ary);
    int result=ary[0];
    for(int i=1 ; i<=n-1 ; i++){
      result=euclidDiv(result,ary[i]);
    }
    System.out.println(result);
  }
  static int euclidDiv(int a,int b){
    if(b==0)return a ;
    int mod=a % b ;
    return euclidDiv(b,mod);
  }
  private static Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    String debugDataPath=System.getenv("DD_PATH");
    if(debugDataPath!=null){
      try {
        scanner=new Scanner(new BufferedReader(new InputStreamReader(new FileInputStream(new File(debugDataPath)))));
      }
      catch(Exception e){
        throw new RuntimeException(e);
      }
    }
    solve();
  }
  private static StringTokenizer tokenizer=null ;
  public static String next(){
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        tokenizer=new StringTokenizer(scanner.nextLine());
      }
      catch(Exception e){
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }
  private static int ni(){
    return Integer.parseInt(next());
  }
  private static long nl(){
    return Long.parseLong(next());
  }
  private static double nd(){
    return Double.parseDouble(next());
  }
  private static int[] na(int n){
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=ni();
    return a ;
  }
  private static char[] ns(){
    return next().toCharArray();
  }
  private static long[] nal(int n){
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=nl();
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := ni() ;
     var ary : Sequence(int) ; ary := na(n) ;
    ary := ary->sort() ; 
    var result : int ; result := ary[0+1] ;
        var i : int ; i := 1 ; while i <= n - 1 do ( (     result := euclidDiv(result, ary[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation euclidDiv( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     var mod : int ; mod := a mod b ;
     return euclidDiv(b, mod) );
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var debugDataPath : String ; debugDataPath := OclProcess.getEnvironmentProperty("DD_PATH") ;
     if (debugDataPath /= null) then (     try (     scanner := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(debugDataPath))))) )   catch (e : ProgramException) do (     error ProgramException(e) )
 ) else skip ; 
     execute solve() );
  static   attribute tokenizer : OclIterator := null;
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(scanner.nextLine()) )   catch (e : ProgramException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
  static   operation ni() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nl() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation nd() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation na( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := ni() ;  ;     i := i + 1 ) ; 
     return a );
  static   operation ns() : Sequence(String)
  pre: true
  post: true
  activity: (     return next()->characters() );
  static   operation nal( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nl() ;  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static int findGCD(int arr[],int n){
    int result=arr[0];
    for(int i=1 ; i<n ; i++)result=gcd(arr[i],result);
    return result ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int numOfMon=sc.nextInt();
    int map[]=new int[numOfMon];
    for(int i=0 ; i<numOfMon ; i++){
      int Ai=sc.nextInt();
      map[i]=Ai ;
    }
    System.out.println(findGCD(map,numOfMon));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation findGCD( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do (     result := gcd(arr[i+1], result) ;  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numOfMon : int ; numOfMon := sc.getCurrent()->toInteger() ;
    var map : Sequence(int) ; map := Integer.subrange(1,numOfMon)->collect(0) ;
        var i : int ; i := 0 ; while i < numOfMon do ( (     var Ai : int ; Ai := sc.getCurrent()->toInteger() ;
     map[i+1] := Ai )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(findGCD(map, numOfMon)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int N ;
  static int[] A ;
  static int min ;
  public static void main(String[] args){
    readInput();
    solve();
  }
  static void solve(){
    while(true){
      int newMin=min ;
      for(int i=0 ; i<N ; i++){
        int a=A[i] % min ;
        if(a==0){
          a=min ;
        }
        if(newMin>a){
          newMin=a ;
        }
        A[i]=a ;
      }
      if(newMin==min){
        break ;
      }
      else {
        min=newMin ;
      }
    }
    System.out.println(min);
  }
  static void readInput(){
    try(Scanner sc=new Scanner(System.in)){
      N=sc.nextInt();
      A=new int[N];
      min=Integer.MAX_VALUE ;
      for(int i=0 ; i<N ; i++){
        A[i]=sc.nextInt();
        if(min>A[i]){
          min=A[i];
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute A : Sequence(int);
  static   attribute min : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute readInput() ; 
     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     while (true) do (     var newMin : int ; newMin := min ;
         var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := A[i+1] mod min ;
     if (a = 0) then (     a := min ) else skip ; 
     if (newMin > a) then (     newMin := a ) else skip ; 
     A[i+1] := a )  ;     i := i + 1 ) ; 
     if (newMin = min) then (     break ) else (     min := newMin ) ) ; 
     OclFile["System.out"].println(min) );
  static   operation readInput() : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     N := sc.getCurrent()->toInteger() ; 
     A := Integer.subrange(1,N)->collect(0) ; 
     min := 2147483647 ; 
         var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() ; 
     if (min > A[i+1]) then (     min := A[i+1] ) else skip )  ;     i := i + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<Integer>a=new ArrayList<>();
    if(n==1){
      System.out.println(sc.nextInt());
      System.exit(0);
    }
    for(int i=0 ; i<n ; i++){
      a.add(sc.nextInt());
    }
    Collections.sort(a);
    if(a.get(a.size()-1)==0){
      System.out.println(0);
      System.exit(0);
    }
    int ans=0 ;
    while(true){
      if(a.size()==1){
        ans=a.get(0);
        break ;
      }
      a=func(a);
    }
    System.out.println(ans);
  }
  private static ArrayList<Integer>func(ArrayList<Integer>A){
    ArrayList<Integer>a=A ;
    int min=0 ;
    for(int i=0 ; i<a.size(); i++){
      if(a.get(i)==0){
        a.remove(i);
        i--;
      }
      else {
        if(min!=0){
          a.set(i,a.get(i)% min);
          if(a.get(i)==1){
            System.out.println(1);
            System.exit(0);
          }
        }
        else {
          min=a.get(i);
        }
      }
    }
    Collections.sort(a);
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
    if (n = 1) then (     OclFile["System.out"].println(sc.getCurrent()->toInteger()) ; 
 OclProcess.exit(0) ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     a := a->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    if (a->at(a->size() - 1+1) = 0) then (     OclFile["System.out"].println(0) ; 
 OclProcess.exit(0) ) else skip ; 
    var ans : int ; ans := 0 ;
    while (true) do (     if (a->size() = 1) then (     ans := a->at(0+1) ; 
     break ) else skip ; 
     a := func(a) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation func( A : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := A ;
     var min : int ; min := 0 ;
        var i : int ; i := 0 ; while i < a->size() do ( (     if (a->at(i+1) = 0) then (     a := a->excludingAt(i+1) ; 
     i := i - 1 ) else (     if (min /= 0) then (     a := a.setAt(i+1,a->at(i+1) mod min) ; 
     if (a->at(i+1) = 1) then (     OclFile["System.out"].println(1) ; 
 OclProcess.exit(0) ) else skip ) else (     min := a->at(i+1) ) ) )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    return a 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B975 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] a=new int[14];
    for(int i=0 ; i<14 ; i++)a[i]=sc.nextInt();
    long max=0 ;
    for(int from=0 ; from<14 ; from++){
      int stones=a[from];
      int remainder=stones/14 ;
      long score=(remainder % 2==0)? remainder : 0 ;
      for(int i=1 ; i<14 ; i++){
        int count=a[(from+i)% 14]+(stones+14-i)/14 ;
        if(count % 2==0)score+=count ;
      }
      max=Math.max(max,score);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B975 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,14)->collect(0) ;
        var i : int ; i := 0 ; while i < 14 do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var max : long ; max := 0 ;
        var from : int ; from := 0 ; while from < 14 do ( (     var stones : int ; stones := a[from+1] ;
     var remainder : int ; remainder := stones / 14 ;
    var score : long ; score := if (remainder mod 2 = 0) then remainder else 0 endif ;
        var i : int ; i := 1 ; while i < 14 do ( (     var count : int ; count := a[(from + i) mod 14+1] + (stones + 14 - i) / 14 ;
     if (count mod 2 = 0) then     score := score+(count) ; else skip )  ;     i := i + 1 ) ; 
    max := Set{max, score}->max() ; 
 )  ;     from := from + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Mancala975B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    ArrayList<Long>list=new ArrayList<>();
    long arr2[]=new long[14];
    long arr[]=new long[14];
    long add[]=new long[14];
    for(int i=0 ; i<14 ; i++){
      arr2[i]=in.nextLong();
      arr[i]=arr2[i];
      add[i]=arr[i]/14 ;
    }
    long mod=0,ans=0 ;
    for(int i=0 ; i<14 ; i++){
      mod=arr[i] % 14 ;
      arr[i]=0 ;
      for(int j=0 ; j<14 ; j++){
        arr[j]+=add[i];
      }
      for(int j=0,count=i+1 ; j<mod ; j++,count++){
        if(count==14)count=0 ;
        arr[count]++;
      }
      for(int j=0 ; j<14 ; j++){
        if(arr[j] % 2==0)ans+=arr[j];
      }
      list.add(ans);
      ans=0 ;
      for(int j=0 ; j<14 ; j++){
        arr[j]=arr2[j];
      }
    }
    System.out.println(Collections.max(list));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mancala975B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(long) ; list := Sequence{} ;
    var arr2 : Sequence(long) ; arr2 := Integer.subrange(1,14)->collect(0) ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,14)->collect(0) ;
    var add : Sequence(long) ; add := Integer.subrange(1,14)->collect(0) ;
        var i : int ; i := 0 ; while i < 14 do ( (     arr2[i+1] := in.getCurrent()->toLong() ; 
     arr[i+1] := arr2[i+1] ; 
     add[i+1] := arr[i+1] / 14 )  ;     i := i + 1 ) ; 
    var mod : long ; mod := 0 ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < 14 do ( (     mod := arr[i+1] mod 14 ; 
     arr[i+1] := 0 ; 
        var j : int ; j := 0 ; while j < 14 do ( (     arr[j+1] := arr[j+1]+(add[i+1]) )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ;
    var count : int ; count := i + 1 ; while j < mod do ( (     if (count = 14) then     count := 0 ; else skip ; 
     arr[count+1] := arr[count+1] + 1 )  ;     j := j + 1 ;     count := count + 1 ) ; 
        var j : int ; j := 0 ; while j < 14 do ( (     if (arr[j+1] mod 2 = 0) then     ans := ans+(arr[j+1]) ; else skip )  ;     j := j + 1 ) ; 
    list := list->including(ans) ; 
    ans := 0 ; 
        var j : int ; j := 0 ; while j < 14 do ( (     arr[j+1] := arr2[j+1] )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println( list->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double maxSubArraySum(double a[],int size){
    double max_so_far=Integer.MIN_VALUE,max_ending_here=0 ;
    for(int i=0 ; i<size ; i++){
      max_ending_here=max_ending_here+a[i];
      if(max_so_far<max_ending_here)max_so_far=max_ending_here ;
      if(max_ending_here<0)max_ending_here=0 ;
    }
    return max_so_far ;
  }
  static void minPossibleSum(double a[],int n,double x){
    double mxSum=maxSubArraySum(a,n);
    double sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=a[i];
    }
    sum=sum-mxSum+mxSum/x ;
    System.out.print(sum+"\n");
  }
  public static void main(String[] args){
    int N=3 ;
    double X=2 ;
    double A[]={
      1,-2,3 };
      minPossibleSum(A,N,X);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxSubArraySum( a : Sequence(double), size : int) : double
  pre: true
  post: true
  activity: (     var max_so_far : double ; max_so_far := -2147483648 ;
    var max_ending_here : double ; max_ending_here := 0 ;
         var i : int ; i := 0 ; while i < size do ( (     max_ending_here := max_ending_here + a[i+1] ; 
     if (max_so_far < max_ending_here) then     max_so_far := max_ending_here ; else skip ; 
     if (max_ending_here < 0) then     max_ending_here := 0 ; else skip )  ;     i := i + 1 ) ; 
     return max_so_far );
  static   operation minPossibleSum( a : Sequence(double), n : int, x : double) : void
  pre: true
  post: true
  activity: (     var mxSum : double ; mxSum := maxSubArraySum(a, n) ;
     var sum : double ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    sum := sum - mxSum + mxSum / x ; 
    OclFile["System.out"].print(sum + "\n") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
     var X : double ; X := 2 ;
     var A : Sequence(double) ; A := Sequence{1,-2,3} ;
     execute minPossibleSum(A, N, X) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double pentdiagonal(double a){
    if(a<0)return-1 ;
    double d=1.22*a ;
    return d ;
  }
  static public void main(String args[]){
    double a=6 ;
    System.out.println(pentdiagonal(a));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation pentdiagonal( a : double) : double
  pre: true
  post: true
  activity: (     if (a < 0) then     return -1 else skip ; 
     var d : double ; d := 1.22 * a ;
     return d );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 6 ;
     OclFile["System.out"].println(pentdiagonal(a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      while(true){
        int T=sc.nextInt(),D=sc.nextInt(),L=sc.nextInt();
        if(T==0 && D==0 && L==0){
          break ;
        }
        int ans=0,time=0 ;
        for(int i=0 ; i<T-1 ; i++){
          int x=sc.nextInt();
          if(x>=L){
            time=D-1 ;
            ans++;
          }
          else if(time!=0){
            time--;
            ans++;
          }
        }
        sc.nextInt();
        System.out.println(ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (true) do (     var T : int ; T := sc.getCurrent()->toInteger() ;
    var D : int ; D := sc.getCurrent()->toInteger() ;
    var L : int ; L := sc.getCurrent()->toInteger() ;
     if (T = 0 & D = 0 & L = 0) then (     break ) else skip ; 
    var ans : int ; ans := 0 ;
    var time : int ; time := 0 ;
        var i : int ; i := 0 ; while i < T - 1 do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x >= L) then (     time := D - 1 ; 
     ans := ans + 1 ) else     if (time /= 0) then (     time := time - 1 ; 
     ans := ans + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(ans) ; 
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static double hexDiagonal(float a){
    if(a<0)return-1 ;
    double d=(double)1.73*a ;
    return d ;
  }
  public static void main(String[] args){
    float a=9 ;
    System.out.println(hexDiagonal(a));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation hexDiagonal( a : double) : double
  pre: true
  post: true
  activity: (     if (a < 0) then     return -1 else skip ; 
     var d : double ; d := 1.73->oclAsType(double) * a ;
     return d );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 9 ;
     OclFile["System.out"].println(hexDiagonal(a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void translate(char str[]){
    for(int i=1 ; i<str.length ; i++){
      if(str[i-1]=='A' && str[i]=='B'){
        str[i-1]='C' ;
        int j ;
        for(j=i ; j<str.length-1 ; j++)str[j]=str[j+1];
        str[j]=' ' ;
      }
    }
    return ;
  }
  public static void main(String args[]){
    String st="helloABworldABGfG" ;
    char str[]=st.toCharArray();
    translate(str);
    System.out.println("The modified string is :");
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation translate( str : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < str->size() do ( (     if (str[i - 1+1] = 'A' & str[i+1] = 'B') then (     str[i - 1+1] := 'C' ; 
     var j : int ;
         j := i ; while j < str->size() - 1 do (     str[j+1] := str[j + 1+1] ;  ;     j := j + 1 ) ; 
     str[j+1] := ' ' ) else skip )  ;     i := i + 1 ) ; 
     return );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var st : String ; st := "helloABworldABGfG" ;
     var str : Sequence(String) ; str := st->characters() ;
    execute translate(str) ; 
    OclFile["System.out"].println("The modified string is :") ; 
    OclFile["System.out"].println(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void translate(char str[]){
    int len=str.length ;
    if(len<2)return ;
    int i=0 ;
    int j=0 ;
    while(j<len-1){
      if(str[j]=='A' && str[j+1]=='B'){
        j=j+2 ;
        str[i++]='C' ;
        continue ;
      }
      str[i++]=str[j++];
    }
    if(j==len-1)str[i++]=str[j];
    str[i]=' ' ;
    str[len-1]=' ' ;
  }
  public static void main(String args[]){
    String st="helloABworldABGfG" ;
    char str[]=st.toCharArray();
    translate(str);
    System.out.println("The modified string is :");
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation translate( str : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     if (len < 2) then     return else skip ; 
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    while (j < len - 1) do (     if (str[j+1] = 'A' & str[j + 1+1] = 'B') then (     j := j + 2 ; 
      str[i+1] := 'C'  ; i := i + 1 ; 
     continue ) else skip ; 
       str[i+1] := str[j+1]  ; i := i + 1  ; j := j + 1 ) ; 
    if (j = len - 1) then      str[i+1] := str[j+1]  ; i := i + 1 ; else skip ; 
    str[i+1] := ' ' ; 
    str[len - 1+1] := ' ' ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var st : String ; st := "helloABworldABGfG" ;
     var str : Sequence(String) ; str := st->characters() ;
    execute translate(str) ; 
    OclFile["System.out"].println("The modified string is :") ; 
    OclFile["System.out"].println(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p128 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p128().run());
  }
  private static final int TARGET=2000 ;
  public String run(){
    int count=2 ;
    for(int ring=2 ; ; ring++){
      if((long)ring*12+5>Integer.MAX_VALUE)throw new ArithmeticException();
      if(Library.isPrime(ring*6-1)&& Library.isPrime(ring*6+1)&& Library.isPrime(ring*12+5)){
        count++;
        if(count==TARGET)return Long.toString((long)ring*(ring-1)*3+2);
      }
      if(Library.isPrime(ring*6-1)&& Library.isPrime(ring*6+5)&& Library.isPrime(ring*12-7)){
        count++;
        if(count==TARGET)return Long.toString((long)ring*(ring+1)*3+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class p128 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p128.newp128().run()) );
  static    attribute TARGET : int := 2000;
   operation run() : String
  pre: true
  post: true
  activity: (     var count : int ; count := 2 ;
         var ring : int ; ring := 2 ; while true do ( (     if (ring->oclAsType(long) * 12 + 5 > 2147483647) then     error ArithmeticException() ; else skip ; 
     if (Library.isPrime(ring * 6 - 1) & Library.isPrime(ring * 6 + 1) & Library.isPrime(ring * 12 + 5)) then (     count := count + 1 ; 
     if (count = TARGET) then     return ((ring->oclAsType(long) * (ring - 1) * 3 + 2) + "") else skip ) else skip ; 
     if (Library.isPrime(ring * 6 - 1) & Library.isPrime(ring * 6 + 5) & Library.isPrime(ring * 12 - 7)) then (     count := count + 1 ; 
     if (count = TARGET) then     return ((ring->oclAsType(long) * (ring + 1) * 3 + 1) + "") else skip ) else skip )  ;     ring := ring + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import static java.lang.Math.max ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int c=0 ;
    for(int i=0 ; i<=max(n,m); i++){
      for(int j=0 ; j<=max(n,m); j++){
        if((i*i)+j==n && i+(j*j)==m)c++;
      }
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i <= Set{n, m}->max() do ( (         var j : int ; j := 0 ; while j <= Set{n, m}->max() do ( (     if ((i * i) + j = n & i + (j * j) = m) then     c := c + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test226 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int m=in.nextInt();
    int n=in.nextInt();
    int a=0 ;
    for(int i=0 ; i*i<=m ; i++){
      for(int j=0 ; i*i+j<=m ; j++){
        if(i*i+j==m){
          if(j*j+i==n){
            a++;
          }
        }
      }
    }
    System.out.println(a);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test226 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : int ; a := 0 ;
        var i : int ; i := 0 ; while i * i <= m do ( (         var j : int ; j := 0 ; while i * i + j <= m do ( (     if (i * i + j = m) then (     if (j * j + i = n) then (     a := a + 1 ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class SystemOfAquaion {
  public static void main(String[] args)throws Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    StringTokenizer tok=new StringTokenizer(reader.readLine());
    int n=Integer.parseInt(tok.nextToken());
    int m=Integer.parseInt(tok.nextToken());
    double b=0,a=0 ;
    int counter=0 ;
    for(a=0 ; a*a<=n && a<=m ; a++){
      b=n-Math.pow(a,2);
      if(a+Math.pow(b,2)==m)counter++;
    }
    writer.write(counter+"");
    writer.newLine();
    writer.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class SystemOfAquaion {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var tok : OclIterator ; tok := OclIterator.newOclIterator_String(reader.readLine()) ;
    var n : int ; n := (tok.next())->toInteger() ;
    var m : int ; m := (tok.next())->toInteger() ;
    var b : double ; b := 0 ;
    var a : double ; a := 0 ;
    var counter : int ; counter := 0 ;
        a := 0 ; while a * a <= n & a <= m do ( (     b := n - a->pow(2) ; 
     if (a + b->pow(2) = m) then     counter := counter + 1 ; else skip )  ;     a := a + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  static int MOD=1000000007 ;
  static int[] arr=new int[100001];
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=1 ;
    while(t-->0){
      solve(s);
    }
  }
  public static void solve(Scanner s){
    int n=s.nextInt();
    int m=s.nextInt();
    int ans=0 ;
    for(int a=0 ; a*a<=n && a<=m ; a++){
      int b=n-a*a ;
      if(a+(b*b)==m)ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   attribute MOD : int := 1000000007;
  static   attribute arr : Sequence(int) := Integer.subrange(1,100001)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve(s) ) ;  ) );
  static   operation solve( s : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s.getCurrent()->toInteger() ;
     var m : int ; m := s.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var a : int ; a := 0 ; while a * a <= n & a <= m do ( (     var b : int ; b := n - a * a ;
     if (a + (b * b) = m) then     ans := ans + 1 ; else skip )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class Gfg {
  static void Digits(int n){
    int largest=0 ;
    int smallest=9 ;
    while(n!=0){
      int r=n % 10 ;
      largest=Math.max(r,largest);
      smallest=Math.min(r,smallest);
      n=n/10 ;
    }
    System.out.println(largest+" "+smallest);
  }
  public static void main(String[] args)throws java.lang.Exception {
    int n=2346 ;
    Digits(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Gfg {
  static   operation Digits( n : int) : void
  pre: true
  post: true
  activity: (     var largest : int ; largest := 0 ;
     var smallest : int ; smallest := 9 ;
     while (n /= 0) do (     var r : int ; r := n mod 10 ;
     largest := Set{r, largest}->max() ; 
     smallest := Set{r, smallest}->min() ; 
     n := n / 10 ) ; 
     OclFile["System.out"].println(largest + " " + smallest) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2346 ;
     execute Digits(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastScanner sc=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int t ;
    t=sc.nextInt();
    while(t-->0){
      int n ;
      n=sc.nextInt();
      int[] arr=new int[n+1];
      int[] indexOf=new int[n+1];
      for(int i=1 ; i<=n ; i++){
        arr[i]=sc.nextInt();
        indexOf[arr[i] ]=i ;
      }
      int least=n+1 ;
      ArrayList<Integer>ans=new ArrayList<Integer>();
      for(int e=n ; e>=1 ; e--){
        int ind=indexOf[e];
        if(ind>=least)continue ;
        for(int j=ind ; j<least ; j++)ans.add(arr[j]);
        least=ind ;
      }
      for(int e : ans)out.print(e+" ");
      out.println();
    }
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ;
    t := sc.nextInt() ; 
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ;
     n := sc.nextInt() ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
    var indexOf : Sequence(int) ; indexOf := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.nextInt() ; 
     indexOf[arr[i+1]+1] := i )  ;     i := i + 1 ) ; 
    var least : int ; least := n + 1 ;
    var ans : Sequence(int) ; ans := Sequence{} ;
        var e : int ; e := n ; while e >= 1 do ( (     var ind : int ; ind := indexOf[e+1] ;
     if (ind >= least) then     continue else skip ; 
         var j : int ; j := ind ; while j < least do (     ans := ans->including(arr[j+1]) ;  ;     j := j + 1 ) ; 
     least := ind )  ;     e := e - 1 ) ; 
    for (e : ans) do (     skip ;  ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  private static final int MOD=(int)1e9+7 ;
  public static void main(String[] args)throws FileNotFoundException {
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=in.nextInt(),d=in.nextInt(),l=in.nextInt();
    while(t!=0 && d!=0 && l!=0){
      long ans=0 ;
      long last=Integer.MIN_VALUE ;
      for(int i=1 ; i<=t ; i++){
        if(in.nextInt()>=l){
          if(i<=last){
            ans+=i+d-1-last ;
          }
          else {
            ans+=d ;
          }
          last=i+d-1 ;
        }
      }
      if(last!=Integer.MIN_VALUE && last>t){
        ans-=last-t ;
      }
      out.println(ans==0 ? 0 : ans-1);
      t=in.nextInt();
      d=in.nextInt();
      l=in.nextInt();
    }
    out.close();
  }
  private static class Task {
    int d,p ;
    public Task(int d,int p){
      this.d=d ;
      this.p=p ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1e9->oclAsType(int) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var l : int ; l := in.getCurrent()->toInteger() ;
    while (t /= 0 & d /= 0 & l /= 0) do (     var ans : long ; ans := 0 ;
     var last : long ; last := -2147483648 ;
        var i : int ; i := 1 ; while i <= t do ( (     if (in.getCurrent()->toInteger() >= l) then (     if (i <= last) then (     ans := ans+(i + d - 1 - last) ) else (     ans := ans+(d) ) ;  
     last := i + d - 1 ) else skip )  ;     i := i + 1 ) ; 
    if (last /= -2147483648 & last > t) then (     ans := ans-(last - t) ) else skip ; 
    skip ; 
    t := in.getCurrent()->toInteger() ; 
    d := in.getCurrent()->toInteger() ; 
    l := in.getCurrent()->toInteger() ; 
 ) ; 
    skip ; 
 );
  static class Task {
   attribute d : int;
   static operation newTask( d : int, p : int) : Task
  pre: true
  post: true
  activity:
  ( var self : Task ;
    self := createTask();
    self.initialise(d, p);
    return self );
  operation initialise( d : int, p : int) : void
  pre: true  post: true
  activity: (     self.d := d ; 
     self.p := p );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void solve(int d1,int d2,int d3){
    int maxx=Math.max(d1,Math.max(d2,d3));
    int sum=(d1+d2+d3);
    if(2*maxx>sum || sum % 2==1){
      System.out.print("-1");
      return ;
    }
    int x1=0,y1=0 ;
    int x2=d1,y2=0 ;
    int x3=(d1+d2-d3)/2 ;
    int y3=(d2+d3-d1)/2 ;
    System.out.print("("+x1+","+y1+"),("+x2+","+y2+")and("+x3+","+y3+")");
  }
  public static void main(String[] args){
    int d1=3,d2=4,d3=5 ;
    solve(d1,d2,d3);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( d1 : int, d2 : int, d3 : int) : void
  pre: true
  post: true
  activity: (     var maxx : int ; maxx := Set{d1, Set{d2, d3}->max()}->max() ;
     var sum : int ; sum := (d1 + d2 + d3) ;
    if (2 * maxx > sum or sum mod 2 = 1) then (     OclFile["System.out"].print("-1") ; 
     return ) else skip ; 
    var x1 : int ; x1 := 0 ;
    var y1 : int ; y1 := 0 ;
    var x2 : int ; x2 := d1 ;
    var y2 : int ; y2 := 0 ;
    var x3 : int ; x3 := (d1 + d2 - d3) / 2 ;
    var y3 : int ; y3 := (d2 + d3 - d1) / 2 ;
    OclFile["System.out"].print("(" + x1 + "," + y1 + "),(" + x2 + "," + y2 + ")and(" + x3 + "," + y3 + ")") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d1 : int ; d1 := 3 ;
    var d2 : int ; d2 := 4 ;
    var d3 : int ; d3 := 5 ;
     execute solve(d1, d2, d3) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int MAX_CHAR=26 ;
  static boolean distributingBalls(long k,long n,String str){
    int[] a=new int[MAX_CHAR];
    for(int i=0 ; i<n ; i++){
      a[str.charAt(i)-'a']++;
    }
    for(int i=0 ; i<MAX_CHAR ; i++)if(a[i]>k)return false ;
    return true ;
  }
  static public void main(String[] args){
    long n=6,k=3 ;
    String str="aacaab" ;
    if(distributingBalls(k,n,str))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX_CHAR : int := 26;
  static   operation distributingBalls( k : long, n : long, str : String) : boolean
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,MAX_CHAR)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[str->at(i+1) - ('a')->char2byte()+1] := a[str->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < MAX_CHAR do (     if (a[i+1] > k) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 6 ;
    var k : long ; k := 3 ;
     var str : String ; str := "aacaab" ;
     if (distributingBalls(k, n, str)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.time.format.DateTimeFormatter ;
import java.util.*;
import java.time.*;
public class Lesson {
  static Scanner sc=new Scanner(System.in);
  static public boolean check(StringBuilder sb){
    int t=0 ;
    for(int i=0 ; i<sb.length(); i++){
      if(Character.toString(sb.charAt(i)).equals("T")){
        t++;
      }
      else if(Character.toString(sb.charAt(i)).equals("M")){
        if(t<=0)return false ;
        t--;
      }
    }
    return true ;
  }
  public static void main(String...args){
    int t=sc.nextInt();
    OUTER_LOOP : while(t-->0){
      int n=sc.nextInt();
      StringBuilder sb=new StringBuilder(sc.next());
      if(sb.indexOf("M")<0){
        System.out.println("NO");
        continue ;
      }
      int T=0,m=0 ;
      for(int i=0 ; i<sb.length(); i++){
        if(Character.toString(sb.charAt(i)).equals("T"))T++;
        else m++;
      }
      if(T/2!=m){
        System.out.println("NO");
        continue ;
      }
      if(check(sb)==true && check(sb.reverse())==true)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Lesson {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    operation check( sb : String) : boolean
  pre: true
  post: true
  activity: (     var t : int ; t := 0 ;
         var i : int ; i := 0 ; while i < sb->size() do ( (     if ((sb->at(i+1) + "") = "T") then (     t := t + 1 ) else     if ((sb->at(i+1) + "") = "M") then (     if (t <= 0) then     return false else skip ; 
     t := t - 1 ) else skip ; )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var sb : String ; sb := StringLib.newString(sc.getCurrent()) ;
    if (sb->indexOf("M")-1 < 0) then (     OclFile["System.out"].println("NO") ; 
     continue ) else skip ; 
    var T : int ; T := 0 ;
    var m : int ; m := 0 ;
        var i : int ; i := 0 ; while i < sb->size() do ( (     if ((sb->at(i+1) + "") = "T") then     T := T + 1 ; else     m := m + 1 ; )  ;     i := i + 1 ) ; 
    if (T / 2 /= m) then (     OclFile["System.out"].println("NO") ; 
     continue ) else skip ; 
    if (check(sb) = true & check(sb->reverse()) = true) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=Integer.parseInt(sc.nextLine());
    for(int i=0 ; i<t ; i++){
      int n=Integer.parseInt(sc.nextLine());
      String seq=sc.nextLine();
      char[] c=seq.toCharArray();
      int nt=0 ;
      int ntm=0 ;
      int ntmt=0 ;
      int ct=0 ;
      int cm=0 ;
      for(int j=0 ; j<n ; j++){
        if(c[j]=='T'){
          ct++;
          if(ntm>0){
            ntmt++;
            ntm--;
          }
          nt++;
        }
        else if(c[j]=='M'){
          cm++;
          if(nt>0){
            nt--;
            ntm++;
          }
        }
      }
      if(ct==2*cm && ntmt==n/3){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := (sc.nextLine())->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := (sc.nextLine())->toInteger() ;
     var seq : String ; seq := sc.nextLine() ;
    var c : Sequence(String) ; c := seq->characters() ;
    var nt : int ; nt := 0 ;
    var ntm : int ; ntm := 0 ;
    var ntmt : int ; ntmt := 0 ;
    var ct : int ; ct := 0 ;
    var cm : int ; cm := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     if (c[j+1] = 'T') then (     ct := ct + 1 ; 
     if (ntm > 0) then (     ntmt := ntmt + 1 ; 
     ntm := ntm - 1 ) else skip ; 
     nt := nt + 1 ) else     if (c[j+1] = 'M') then (     cm := cm + 1 ; 
     if (nt > 0) then (     nt := nt - 1 ; 
     ntm := ntm + 1 ) else skip ) else skip ; )  ;     j := j + 1 ) ; 
    if (ct = 2 * cm & ntmt = n / 3) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.reflect.Array ;
import java.util.*;
public class main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int kk=sc.nextInt();
    while(kk-->0){
      int checksLeft=sc.nextInt();
      String s=sc.next();
      List<Integer>T=new ArrayList<>();
      List<Integer>M=new ArrayList<>();
      for(int i=0 ; i<checksLeft ; i++){
        if(s.charAt(i)=='T'){
          T.add(i);
        }
        else {
          M.add(i);
        }
      }
      System.out.println(check(T,M)? "YES" : "NO");
    }
  }
  public static boolean check(List<Integer>t,List<Integer>m){
    if(m.size()*2!=t.size()){
      return false ;
    }
    for(int i=0 ; i<m.size(); i++){
      if(t.get(i)>m.get(i)|| m.get(i)>t.get(m.size()+i)){
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var kk : int ; kk := sc.getCurrent()->toInteger() ;
         while (kk > 0) do (        kk := kk - 1 ;     skip ; (     var checksLeft : int ; checksLeft := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
    var T : Sequence(int) ; T := Sequence{} ;
    var M : Sequence(int) ; M := Sequence{} ;
        var i : int ; i := 0 ; while i < checksLeft do ( (     if (s->at(i+1) = 'T') then (     T := T->including(i) ) else (     M := M->including(i) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if check(T, M) then "YES" else "NO" endif) ; 
 ) ;  ) );
  static   operation check( t : Sequence(int), m : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     if (m->size() * 2 /= t->size()) then (     return false ) else skip ; 
         var i : int ; i := 0 ; while i < m->size() do ( (     if (t->at(i+1) > m->at(i+1) or m->at(i+1) > t->at(m->size() + i+1)) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int e[]=new int[13];
    int i ;
    int p=0 ;
    int k ;
    for(i=0 ; i<12 ; i++){
      e[i]=scan.nextInt();
    }
    for(i=0 ; i<12 ; i++){
      for(int j=0 ; j<12-i ; j++){
        if(e[j]<e[j+1]){
          int y=e[j];
          e[j]=e[j+1];
          e[j+1]=y ;
        }
      }
    }
    for(int u=0 ; u<3 ; u++){
      for(k=0 ; k<4 ; k++){
        i=u*4 ;
        if(e[i]==e[i+1] && e[i+2]==e[i+3] && e[i]==e[i+2] && e[i+1]==e[i+3] && e[i]==e[i+3] && e[i+1]==e[i+2]){
          p+=1 ;
        }
        else {
          p+=0 ;
        }
      }
    }
    if(p==12){
      System.out.println("yes");
    }
    else {
      System.out.println("no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var e : Sequence(int) ; e := Integer.subrange(1,13)->collect(0) ;
    var i : int ;
    var p : int ; p := 0 ;
    var k : int ;
        i := 0 ; while i < 12 do ( (     e[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        i := 0 ; while i < 12 do ( (         var j : int ; j := 0 ; while j < 12 - i do ( (     if (e[j+1] < e[j + 1+1]) then (     var y : int ; y := e[j+1] ;
     e[j+1] := e[j + 1+1] ; 
     e[j + 1+1] := y ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var u : int ; u := 0 ; while u < 3 do ( (         k := 0 ; while k < 4 do ( (     i := u * 4 ; 
     if (e[i+1] = e[i + 1+1] & e[i + 2+1] = e[i + 3+1] & e[i+1] = e[i + 2+1] & e[i + 1+1] = e[i + 3+1] & e[i+1] = e[i + 3+1] & e[i + 1+1] = e[i + 2+1]) then (     p := p+(1) ) else (     p := p+(0) ) )  ;     k := k + 1 ) )  ;     u := u + 1 ) ; 
    if (p = 12) then (     OclFile["System.out"].println("yes") ) else (     OclFile["System.out"].println("no") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  int[] cnt ;
  boolean check(){
    for(int i=0 ; i<=100 ; i++)if(cnt[i] % 4>0)return false ;
    return true ;
  }
  void solve(){
    Scanner sc=new Scanner(System.in);
    cnt=new int[101];
    for(int i=0 ; i<=100 ; i++)cnt[i]=0 ;
    for(int i=0 ; i<12 ; i++){
      int x=sc.nextInt();
      cnt[x]++;
    }
    if(check())System.out.println("yes");
    else System.out.println("no");
  }
  public static void main(String[] a){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute cnt : Sequence(int);
   operation check() : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= 100 do (     if (cnt[i+1] mod 4 > 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     cnt := Integer.subrange(1,101)->collect(0) ; 
        var i : int ; i := 0 ; while i <= 100 do (     cnt[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 12 do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     cnt[x+1] := cnt[x+1] + 1 )  ;     i := i + 1 ) ; 
    if (check()) then     OclFile["System.out"].println("yes") else     OclFile["System.out"].println("no") ; ;  
 );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    StringTokenizer st=new StringTokenizer(br.readLine());
    int[] sides=new int[101];
    for(int i=0 ; i<12 ; i++){
      sides[parseInt(st.nextToken())]++;
    }
    boolean ans=true ;
    for(int i=1 ; i<sides.length ; i++){
      if(!(sides[i]==0 || sides[i]==4 || sides[i]==8 || sides[i]==12)){
        ans=false ;
        break ;
      }
    }
    System.out.println(ans ? "yes" : "no");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var sides : Sequence(int) ; sides := Integer.subrange(1,101)->collect(0) ;
        var i : int ; i := 0 ; while i < 12 do ( (     sides[parseInt(st.next())+1] := sides[parseInt(st.next())+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : boolean ; ans := true ;
        var i : int ; i := 1 ; while i < sides->size() do ( (     if (not((sides[i+1] = 0 or sides[i+1] = 4 or sides[i+1] = 8 or sides[i+1] = 12))) then (     ans := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if ans then "yes" else "no" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] array=new int[12];
    int j,c=0,f=0 ;
    int tmp1,tmp2,tmp3 ;
    for(int i=0 ; i<12 ; ++i){
      f=0 ;
      tmp1=-1 ;
      tmp2=-1 ;
      tmp3=-1 ;
      array[i]=sc.nextInt();
      for(j=0 ; j<i ; ++j){
        if(array[j]==array[i]){
++f ;
          if(tmp1!=-1){
            if(tmp2!=-1){
              tmp3=j ;
            }
            else {
              tmp2=j ;
            }
          }
          else {
            tmp1=j ;
          }
        }
      }
      if(f>=3){
++c ;
        array[tmp1]=-1 ;
        array[tmp2]=-1 ;
        array[tmp3]=-1 ;
        array[i]=-1 ;
      }
    }
    System.out.println(c>=3 ? "yes" : "no");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var array : Sequence(int) ; array := Integer.subrange(1,12)->collect(0) ;
    var j : int ;
    var c : int ; c := 0 ;
    var f : int ; f := 0 ;
    var tmp1 : int ;
    var tmp2 : int ;
    var tmp3 : int ;
        var i : int ; i := 0 ; while i < 12 do ( (     f := 0 ; 
     tmp1 := -1 ; 
    tmp2 := -1 ; 
    tmp3 := -1 ; 
    array[i+1] := sc.getCurrent()->toInteger() ; 
        j := 0 ; while j < i do ( (     if (array[j+1] = array[i+1]) then (     f := f + 1 ; 
     if (tmp1 /= -1) then (     if (tmp2 /= -1) then (     tmp3 := j ) else (     tmp2 := j ) ) else (     tmp1 := j ) ) else skip )  ;     j := j + 1 ) ; 
    if (f >= 3) then (     c := c + 1 ; 
     array[tmp1+1] := -1 ; 
    array[tmp2+1] := -1 ; 
    array[tmp3+1] := -1 ; 
    array[i+1] := -1 ; 
 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if c >= 3 then "yes" else "no" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String strArr[]=br.readLine().split(" ");
    int[] a=new int[12];
    for(int j=0 ; j<12 ; j++){
      a[j]=Integer.parseInt(strArr[j]);
    }
    for(int i=0 ; i<12-1 ; i++){
      for(int j=12-1 ; j>i ; j--){
        if(a[j]<a[j-1]){
          int t=a[j];
          a[j]=a[j-1];
          a[j-1]=t ;
        }
      }
    }
    if(a[0]==a[1] && a[2]==a[1] && a[3]==a[2] && a[4]==a[5] && a[5]==a[6] && a[6]==a[7] && a[8]==a[9] && a[9]==a[10] && a[10]==a[11]){
      System.out.println("yes");
    }
    else {
      System.out.println("no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var strArr : Sequence(String) ; strArr := br.readLine()->split(" ") ;
    var a : Sequence(int) ; a := Integer.subrange(1,12)->collect(0) ;
        var j : int ; j := 0 ; while j < 12 do ( (     a[j+1] := (strArr[j+1])->toInteger() )  ;     j := j + 1 ) ; 
        var i : int ; i := 0 ; while i < 12 - 1 do ( (         var j : int ; j := 12 - 1 ; while j > i do ( (     if (a[j+1] < a[j - 1+1]) then (     var t : int ; t := a[j+1] ;
     a[j+1] := a[j - 1+1] ; 
     a[j - 1+1] := t ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    if (a[0+1] = a[1+1] & a[2+1] = a[1+1] & a[3+1] = a[2+1] & a[4+1] = a[5+1] & a[5+1] = a[6+1] & a[6+1] = a[7+1] & a[8+1] = a[9+1] & a[9+1] = a[10+1] & a[10+1] = a[11+1]) then (     OclFile["System.out"].println("yes") ) else (     OclFile["System.out"].println("no") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int T,D,L ;
      StringTokenizer st=new StringTokenizer(line);
      T=parseInt(st.nextToken());
      D=parseInt(st.nextToken());
      L=parseInt(st.nextToken());
      if((T | D | L)==0)break ;
      int[] elapsed=new int[T+D+1];
      for(int i=1 ; i<=T ; i++){
        int x=parseInt(br.readLine());
        if(x>=L){
          elapsed[i]++;
          elapsed[i+D]--;
        }
      }
      int ans=0 ;
      for(int i=1 ; i<T ; i++){
        elapsed[i]+=elapsed[i-1];
        if(elapsed[i]>0)ans++;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var T : int ;
    var D : int ;
    var L : int ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(line) ;
    T := (st.next() + "")->toInteger() ; 
    D := (st.next() + "")->toInteger() ; 
    L := (st.next() + "")->toInteger() ; 
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(T,D),L)) = 0) then     break else skip ; 
    var elapsed : Sequence(int) ; elapsed := Integer.subrange(1,T + D + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= T do ( (     var x : int ; x := parseInt(br.readLine()) ;
     if (x >= L) then (     elapsed[i+1] := elapsed[i+1] + 1 ; 
     elapsed[i + D+1] := elapsed[i + D+1] - 1 ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < T do ( (     elapsed[i+1] := elapsed[i+1]+(elapsed[i - 1+1]) ; 
     if (elapsed[i+1] > 0) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B_Card_Deck {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    int p=0 ;
    while(p<t){
      int n=s.nextInt();
      int array[]=new int[n];
      for(int i=0 ; i<n ; i++){
        array[i]=s.nextInt();
      }
      int max[]=new int[n];
      int maxx=Integer.MIN_VALUE ;
      for(int i=0 ; i<n ; i++){
        maxx=Math.max(maxx,array[i]);
        max[i]=maxx ;
      }
      ArrayList<ArrayList<Integer>>list=new ArrayList<ArrayList<Integer>>();
      ArrayList<Integer>yo=new ArrayList<Integer>();
      int maximum=n ;
      for(int i=n-1 ; i>=0 ; i--){
        if(array[i]!=maximum){
          yo.add(array[i]);
          continue ;
        }
        else {
          yo.add(array[i]);
          list.add(yo);
          yo=new ArrayList<Integer>();
          if(i!=0){
            maximum=max[i-1];
          }
        }
      }
      if(! yo.isEmpty()){
        list.add(yo);
      }
      for(int i=0 ; i<list.size(); i++){
        ArrayList<Integer>obj=list.get(i);
        for(int j=obj.size()-1 ; j>=0 ; j--){
          System.out.print(obj.get(j)+" ");
        }
      }
      System.out.println();
      p++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Card_Deck {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
     var p : int ; p := 0 ;
     while (p < t) do (     var n : int ; n := s.getCurrent()->toInteger() ;
     var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var max : Sequence(int) ; max := Integer.subrange(1,n)->collect(0) ;
    var maxx : int ; maxx := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     maxx := Set{maxx, array[i+1]}->max() ; 
     max[i+1] := maxx )  ;     i := i + 1 ) ; 
    var list : Sequence(Sequence(int)) ; list := Sequence{} ;
    var yo : Sequence(int) ; yo := Sequence{} ;
    var maximum : int ; maximum := n ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (array[i+1] /= maximum) then (     yo := yo->including(array[i+1]) ; 
     continue ) else (     yo := yo->including(array[i+1]) ; 
     list := list->including(yo) ; 
     yo := Sequence{} ; 
     if (i /= 0) then (     maximum := max[i - 1+1] ) else skip ) )  ;     i := i - 1 ) ; 
    if (not(yo->isEmpty())) then (     list := list->including(yo) ) else skip ; 
        var i : int ; i := 0 ; while i < list->size() do ( (     var obj : Sequence(int) ; obj := list->at(i+1) ;
         var j : int ; j := obj->size() - 1 ; while j >= 0 do ( (     OclFile["System.out"].print(obj->at(j+1) + " ") )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    p := p + 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int R=4 ;
  static int C=4 ;
  static int first(int arr[],int low,int high){
    if(high>=low){
      int mid=low+(high-low)/2 ;
      if((mid==0 || arr[mid-1]==0)&& arr[mid]==1)return mid ;
      else if(arr[mid]==0)return first(arr,(mid+1),high);
      else return first(arr,low,(mid-1));
    }
    return-1 ;
  }
  static void rowWith0s(int mat[][]){
    int max_row_index=0,max=Integer.MIN_VALUE ;
    int min_row_index=0,min=Integer.MAX_VALUE ;
    int i,index ;
    for(i=0 ; i<R ; i++){
      index=first(mat[i],0,C-1);
      int cntZeroes=0 ;
      if(index==-1){
        cntZeroes=C ;
      }
      else {
        cntZeroes=index ;
      }
      if(max<cntZeroes){
        max=cntZeroes ;
        max_row_index=i ;
      }
      if(min>cntZeroes){
        min=cntZeroes ;
        min_row_index=i ;
      }
    }
    System.out.println("Row with min 0s: "+(min_row_index+1));
    System.out.println("Row with max 0s: "+(max_row_index+1));
  }
  public static void main(String[] args){
    int mat[][]={
      {
        0,0,0,1 },{
          0,1,1,1 },{
            1,1,1,1 },{
              0,0,0,0 }
            };
            rowWith0s(mat);
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute R : int := 4;
  static   attribute C : int := 4;
  static   operation first( arr : Sequence(int), low : int, high : int) : int
  pre: true
  post: true
  activity: (     if (high >= low) then (     var mid : int ; mid := low + (high - low) / 2 ;
     if ((mid = 0 or arr[mid - 1+1] = 0) & arr[mid+1] = 1) then     return mid else     if (arr[mid+1] = 0) then     return first(arr, (mid + 1), high) else     return first(arr, low, (mid - 1)) ;  ) else skip ; 
     return -1 );
  static   operation rowWith0s( mat : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var max_row_index : int ; max_row_index := 0 ;
    var max : int ; max := -2147483648 ;
     var min_row_index : int ; min_row_index := 0 ;
    var min : int ; min := 2147483647 ;
    var i : int ;
    var index : int ;
        i := 0 ; while i < R do ( (     index := first(mat[i+1], 0, C - 1) ; 
     var cntZeroes : int ; cntZeroes := 0 ;
    if (index = -1) then (     cntZeroes := C ) else (     cntZeroes := index ) ;  
    if (max < cntZeroes) then (     max := cntZeroes ; 
     max_row_index := i ) else skip ; 
    if (min > cntZeroes) then (     min := cntZeroes ; 
     min_row_index := i ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Row with min 0s: " + (min_row_index + 1)) ; 
    OclFile["System.out"].println("Row with max 0s: " + (max_row_index + 1)) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{0,0,0,1},Sequence{0,1,1,1},Sequence{1,1,1,1},Sequence{0,0,0,0}} ;
     execute rowWith0s(mat) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int bitAtGivenPosSetOrUnset(int n,int k){
    int new_num=n>>(k-1);
    return(new_num & 1);
  }
  public static void main(String[] args){
    int n=10,k=2 ;
    if(bitAtGivenPosSetOrUnset(n,k)==1)System.out.println("Set");
    else System.out.println("Unset");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation bitAtGivenPosSetOrUnset( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var new_num : int ; new_num := (n/(2->pow((k - 1))))->oclAsType(long) ;
     return (MathLib.bitwiseAnd(new_num,1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
    var k : int ; k := 2 ;
     if (bitAtGivenPosSetOrUnset(n, k) = 1) then     OclFile["System.out"].println("Set") ; else     OclFile["System.out"].println("Unset") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Iterator ;
import java.util.StringTokenizer ;
public class MammothsGenomeDecoding {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    if(n % 4!=0){
      System.out.println("===");
      return ;
    }
    int themost=n/4 ;
    int numA=0 ;
    int numG=0 ;
    int numC=0 ;
    int numT=0 ;
    int numQM=0 ;
    StringTokenizer st=new StringTokenizer(br.readLine());
    StringBuffer sb=new StringBuffer(st.nextToken());
    for(int i=0 ; i<sb.length(); i++){
      if(sb.charAt(i)=='A')numA++;
      else if(sb.charAt(i)=='G')numG++;
      else if(sb.charAt(i)=='C')numC++;
      else if(sb.charAt(i)=='T')numT++;
      else numQM++;
    }
    if(numA>themost || numC>themost || numG>themost || numT>themost){
      System.out.println("===");
      return ;
    }
    for(int j=0 ; j<numQM ; j++){
      for(int i=0 ; i<sb.length(); i++){
        if(sb.charAt(i)=='?'){
          if(numA<themost){
            sb.replace(i,i+1,"A");
            numA++;
          }
          else if(numC<themost){
            sb.replace(i,i+1,"C");
            ;
            numC++;
          }
          else if(numG<themost){
            sb.replace(i,i+1,"G");
            ;
            numG++;
          }
          else if(numT<themost){
            sb.replace(i,i+1,"T");
            ;
            numT++;
          }
        }
      }
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MammothsGenomeDecoding {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    if (n mod 4 /= 0) then (     OclFile["System.out"].println("===") ; 
     return ) else skip ; 
    var themost : int ; themost := n / 4 ;
    var numA : int ; numA := 0 ;
    var numG : int ; numG := 0 ;
    var numC : int ; numC := 0 ;
    var numT : int ; numT := 0 ;
    var numQM : int ; numQM := 0 ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var sb : String ; sb := StringLib.newString(st.next()) ;
        var i : int ; i := 0 ; while i < sb->size() do ( (     if (sb->at(i+1) = 'A') then     numA := numA + 1 ; else     if (sb->at(i+1) = 'G') then     numG := numG + 1 else     if (sb->at(i+1) = 'C') then     numC := numC + 1 else     if (sb->at(i+1) = 'T') then     numT := numT + 1 else     numQM := numQM + 1 ; ;  ;  ;  )  ;     i := i + 1 ) ; 
    if (numA > themost or numC > themost or numG > themost or numT > themost) then (     OclFile["System.out"].println("===") ; 
     return ) else skip ; 
        var j : int ; j := 0 ; while j < numQM do ( (         var i : int ; i := 0 ; while i < sb->size() do ( (     if (sb->at(i+1) = '?') then (     if (numA < themost) then (     sb.replace(i, i + 1, "A") ; 
     numA := numA + 1 ) else     if (numC < themost) then (     sb.replace(i, i + 1, "C") ; 
     numC := numC + 1 ) else     if (numG < themost) then (     sb.replace(i, i + 1, "G") ; 
     numG := numG + 1 ) else     if (numT < themost) then (     sb.replace(i, i + 1, "T") ; 
     numT := numT + 1 ) else skip ; ;  ;  ) else skip )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _747B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    sc.nextLine();
    String s=sc.nextLine();
    if(n % 4!=0){
      System.out.println("===");
      return ;
    }
    int ca=n/4,cc=n/4,cg=n/4,ct=n/4 ;
    for(int i=0 ; i<n ; i++){
      switch(s.charAt(i)){
        case 'A' : ca--;
        break ;
        case 'C' : cc--;
        break ;
        case 'G' : cg--;
        break ;
        case 'T' : ct--;
        break ;
      }
    }
    if(ca<0 || cc<0 || cg<0 || ct<0){
      System.out.println("===");
      return ;
    }
    String ans="" ;
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='?'){
        if(ca>0){
          ans+='A' ;
          ca--;
        }
        else if(cc>0){
          ans+='C' ;
          cc--;
        }
        else if(cg>0){
          ans+='G' ;
          cg--;
        }
        else {
          ans+='T' ;
          ct--;
        }
      }
      else {
        ans+=s.charAt(i);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _747B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
    var s : String ; s := sc.nextLine() ;
    if (n mod 4 /= 0) then (     OclFile["System.out"].println("===") ; 
     return ) else skip ; 
    var ca : int ; ca := n / 4 ;
    var cc : int ; cc := n / 4 ;
    var cg : int ; cg := n / 4 ;
    var ct : int ; ct := n / 4 ;
        var i : int ; i := 0 ; while i < n do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (s->at(i+1)) ; 
       if _switchval = 'A' then
     ca := ca - 1 ; 
    break 
   else skip ;
       if _switchval = 'C' then
     cc := cc - 1 ; 
    break 
   else skip ;
       if _switchval = 'G' then
     cg := cg - 1 ; 
    break 
   else skip ;
       if _switchval = 'T' then
     ct := ct - 1 ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    if (ca < 0 or cc < 0 or cg < 0 or ct < 0) then (     OclFile["System.out"].println("===") ; 
     return ) else skip ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = '?') then (     if (ca > 0) then (     ans := ans+('A') ; 
     ca := ca - 1 ) else     if (cc > 0) then (     ans := ans+('C') ; 
     cc := cc - 1 ) else     if (cg > 0) then (     ans := ans+('G') ; 
     cg := cg - 1 ) else (     ans := ans+('T') ; 
     ct := ct - 1 ) ;  ;  ) else (     ans := ans+(s->at(i+1)) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Iterator ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      final int n=sc.nextInt();
      if(n==0){
        break ;
      }
      double[] pos=new double[9];
      for(int i=0 ; i<9 ; i++){
        pos[i]=0 ;
      }
      final int start=sc.next().toCharArray()[0]-'A' ;
      final int end=sc.next().toCharArray()[0]-'A' ;
      final int not=sc.next().toCharArray()[0]-'A' ;
      pos[start]=1 ;
      double[] next=new double[9];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<9 ; j++){
          next[j]=0 ;
        }
        for(int j=0 ; j<9 ; j++){
          if(j % 3!=0 && not!=j-1){
            next[j-1]+=pos[j]/4 ;
          }
          else {
            next[j]+=pos[j]/4 ;
          }
          if(j % 3!=2 && not!=j+1){
            next[j+1]+=pos[j]/4 ;
          }
          else {
            next[j]+=pos[j]/4 ;
          }
          if(j/3!=0 && not!=j-3){
            next[j-3]+=pos[j]/4 ;
          }
          else {
            next[j]+=pos[j]/4 ;
          }
          if(j/3!=2 && not!=j+3){
            next[j+3]+=pos[j]/4 ;
          }
          else {
            next[j]+=pos[j]/4 ;
          }
        }
        double[] tmp=next ;
        next=pos ;
        pos=tmp ;
      }
      System.out.printf("%.8f\n",pos[end]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var pos : Sequence(double) ; pos := Integer.subrange(1,9)->collect(0.0) ;
        var i : int ; i := 0 ; while i < 9 do ( (     pos[i+1] := 0 )  ;     i := i + 1 ) ; 
    var start : int ; start := sc.getCurrent()->characters()[0+1] - ('A')->char2byte() ;
    var end : int ; end := sc.getCurrent()->characters()[0+1] - ('A')->char2byte() ;
    var not : int ; not := sc.getCurrent()->characters()[0+1] - ('A')->char2byte() ;
    pos[start+1] := 1 ; 
    var next : Sequence(double) ; next := Integer.subrange(1,9)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 9 do ( (     next[j+1] := 0 )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < 9 do ( (     if (j mod 3 /= 0 & not /= j - 1) then (     next[j - 1+1] := next[j - 1+1]+(pos[j+1] / 4) ) else (     next[j+1] := next[j+1]+(pos[j+1] / 4) ) ;  
     if (j mod 3 /= 2 & not /= j + 1) then (     next[j + 1+1] := next[j + 1+1]+(pos[j+1] / 4) ) else (     next[j+1] := next[j+1]+(pos[j+1] / 4) ) ;  
     if (j / 3 /= 0 & not /= j - 3) then (     next[j - 3+1] := next[j - 3+1]+(pos[j+1] / 4) ) else (     next[j+1] := next[j+1]+(pos[j+1] / 4) ) ;  
     if (j / 3 /= 2 & not /= j + 3) then (     next[j + 3+1] := next[j + 3+1]+(pos[j+1] / 4) ) else (     next[j+1] := next[j+1]+(pos[j+1] / 4) ) )  ;     j := j + 1 ) ; 
    var tmp : Sequence(double) ; tmp := next ;
    next := pos ; 
    pos := tmp ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.8f\n", pos[end+1]) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int[] DR={
    1,0,-1,0 };
    static int[] DC={
      0,1,0,-1 };
      public static void main(String[] args)throws Exception {
        while(true){
          int N=sc.nextInt();
          if(N==0)break ;
          int s=sc.next().charAt(0)-'A' ;
          int t=sc.next().charAt(0)-'A' ;
          int b=sc.next().charAt(0)-'A' ;
          int r=s/3 ;
          int c=s % 3 ;
          double[][] prob=new double[3][3];
          prob[r][c]=1 ;
          for(int i=0 ; i<N ; ++i){
            double[][] next=new double[3][3];
            for(int j=0 ; j<3 ; ++j){
              for(int k=0 ; k<3 ; ++k){
                for(int l=0 ; l<4 ; ++l){
                  int nr=j+DR[l];
                  int nc=k+DC[l];
                  if(nr<0 || 3<=nr || nc<0 || 3<=nc || nr*3+nc==b){
                    next[j][k]+=prob[j][k]/4 ;
                  }
                  else {
                    next[nr][nc]+=prob[j][k]/4 ;
                  }
                }
              }
            }
            prob=next ;
          }
          System.out.printf("%.9f\n",prob[t/3][t % 3]);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute DR : Sequence(int) := Sequence{1,0,-1,0};
  static   attribute DC : Sequence(int) := Sequence{0,1,0,-1};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then     break else skip ; 
    var s : int ; s := sc.getCurrent()->at(0+1) - ('A')->char2byte() ;
    var t : int ; t := sc.getCurrent()->at(0+1) - ('A')->char2byte() ;
    var b : int ; b := sc.getCurrent()->at(0+1) - ('A')->char2byte() ;
    var r : int ; r := s / 3 ;
    var c : int ; c := s mod 3 ;
    var prob : Sequence(Sequence(double)) ; prob := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0.0)) ;
    prob[r+1][c+1] := 1 ; 
        var i : int ; i := 0 ; while i < N do ( (     var next : Sequence(Sequence(double)) ; next := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0.0)) ;
         var j : int ; j := 0 ; while j < 3 do ( (         var k : int ; k := 0 ; while k < 3 do ( (         var l : int ; l := 0 ; while l < 4 do ( (     var nr : int ; nr := j + DR[l+1] ;
     var nc : int ; nc := k + DC[l+1] ;
     if (nr < 0 or 3 <= nr or nc < 0 or 3 <= nc or nr * 3 + nc = b) then (     next[j+1][k+1] := next[j+1][k+1]+(prob[j+1][k+1] / 4) ) else (     next[nr+1][nc+1] := next[nr+1][nc+1]+(prob[j+1][k+1] / 4) ) )  ;     l := l + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
     prob := next )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.9f\n", prob[t / 3+1][t mod 3+1]) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      int[] xs=new int[3];
      int[] ys=new int[3];
      for(int i=0 ; i<3 ; i++){
        int a=scanner.next().charAt(0)-'A' ;
        xs[i]=a % 3 ;
        ys[i]=a/3 ;
      }
      double[][][] dp=new double[2][3][3];
      int u=0 ;
      dp[u][xs[0] ][ys[0] ]=1 ;
      for(int i=0 ; i<n ; i++){
        for(int x=0 ; x<3 ; x++){
          for(int y=0 ; y<3 ; y++){
            if(dp[u][x][y]==0)continue ;
            for(int[] m : move){
              int nx=x+m[0];
              int ny=y+m[1];
              if(nx==xs[2] && ny==ys[2] || nx<0 || 2<nx || ny<0 || 2<ny)dp[1-u][x][y]+=dp[u][x][y]/4 ;
              else dp[1-u][nx][ny]+=dp[u][x][y]/4 ;
            }
            dp[u][x][y]=0 ;
          }
        }
        u=1-u ;
      }
      System.out.printf("%.8f\n",dp[u][xs[1] ][ys[1] ]);
    }
  }
  int[][] move={
    {
-1,0 },{
        0,-1 },{
          0,1 },{
            1,0 }
          };
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var xs : Sequence(int) ; xs := Integer.subrange(1,3)->collect(0) ;
    var ys : Sequence(int) ; ys := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     var a : int ; a := scanner.getCurrent()->at(0+1) - ('A')->char2byte() ;
     xs[i+1] := a mod 3 ; 
     ys[i+1] := a / 3 )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(Sequence(double))) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0.0))) ;
    var u : int ; u := 0 ;
    dp[u+1][xs[0+1]+1][ys[0+1]+1] := 1 ; 
        var i : int ; i := 0 ; while i < n do ( (         var x : int ; x := 0 ; while x < 3 do ( (         var y : int ; y := 0 ; while y < 3 do ( (     if (dp[u+1][x+1][y+1] = 0) then     continue else skip ; 
     for (m : move) do ( (     var nx : int ; nx := x + m[0+1] ;
     var ny : int ; ny := y + m[1+1] ;
     if (nx = xs[2+1] & ny = ys[2+1] or nx < 0 or 2 < nx or ny < 0 or 2 < ny) then     dp[1 - u+1][x+1][y+1] := dp[1 - u+1][x+1][y+1]+(dp[u+1][x+1][y+1] / 4) ; else     dp[1 - u+1][nx+1][ny+1] := dp[1 - u+1][nx+1][ny+1]+(dp[u+1][x+1][y+1] / 4) ; )  ) ; 
     dp[u+1][x+1][y+1] := 0 )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
     u := 1 - u )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.8f\n", dp[u+1][xs[1+1]+1][ys[1+1]+1]) ; 
 ) );
   attribute move : Sequence(Sequence(int)) := Sequence{Sequence{-1,0},Sequence{0,-1},Sequence{0,1},Sequence{1,0}};
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[][] move={
      {
        0,1 },{
          0,-1 },{
            1,0 },{
-1,0 }
            };
            while(true){
              int n=sc.nextInt();
              if(n==0)break ;
              int x=sc.next().charAt(0)-'A' ;
              int si=x/3 ;
              int sj=x % 3 ;
              x=sc.next().charAt(0)-'A' ;
              int gi=x/3 ;
              int gj=x % 3 ;
              x=sc.next().charAt(0)-'A' ;
              int pi=x/3 ;
              int pj=x % 3 ;
              double[][][] ex=new double[3][3][n+1];
              ex[si][sj][0]=1 ;
              for(int k=1 ; k<=n ; k++){
                for(int i=0 ; i<3 ; i++){
                  for(int j=0 ; j<3 ; j++){
                    for(int d=0 ; d<4 ; d++){
                      int ni=i+move[d][0];
                      int nj=j+move[d][1];
                      if(0<=ni && ni<3 && 0<=nj && nj<3 && !(ni==pi && nj==pj)){
                        ex[ni][nj][k]+=0.25*ex[i][j][k-1];
                      }
                      else {
                        ex[i][j][k]+=0.25*ex[i][j][k-1];
                      }
                    }
                  }
                }
              }
              System.out.printf("%.8f\n",ex[gi][gj][n]);
            }
          }
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var move : Sequence(Sequence(int)) ; move := Sequence{Sequence{0,1},Sequence{0,-1},Sequence{1,0},Sequence{-1,0}} ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var x : int ; x := sc.getCurrent()->at(0+1) - ('A')->char2byte() ;
    var si : int ; si := x / 3 ;
    var sj : int ; sj := x mod 3 ;
    x := sc.getCurrent()->at(0+1) - ('A')->char2byte() ; 
    var gi : int ; gi := x / 3 ;
    var gj : int ; gj := x mod 3 ;
    x := sc.getCurrent()->at(0+1) - ('A')->char2byte() ; 
    var pi : int ; pi := x / 3 ;
    var pj : int ; pj := x mod 3 ;
    var ex : Sequence(Sequence(Sequence(double))) ; ex := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(Integer.subrange(1,n + 1)->collect(0.0))) ;
    ex[si+1][sj+1][0+1] := 1 ; 
        var k : int ; k := 1 ; while k <= n do ( (         var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (         var d : int ; d := 0 ; while d < 4 do ( (     var ni : int ; ni := i + move[d+1][0+1] ;
     var nj : int ; nj := j + move[d+1][1+1] ;
     if (0 <= ni & ni < 3 & 0 <= nj & nj < 3 & not((ni = pi & nj = pj))) then (     ex[ni+1][nj+1][k+1] := ex[ni+1][nj+1][k+1]+(0.25 * ex[i+1][j+1][k - 1+1]) ) else (     ex[i+1][j+1][k+1] := ex[i+1][j+1][k+1]+(0.25 * ex[i+1][j+1][k - 1+1]) ) )  ;     d := d + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    OclFile["System.out"].printf("%.8f\n", ex[gi+1][gj+1][n+1]) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      int[] xs=new int[3];
      int[] ys=new int[3];
      for(int i=0 ; i<3 ; i++){
        int a=scanner.next().charAt(0)-'A' ;
        xs[i]=a % 3 ;
        ys[i]=a/3 ;
      }
      double[][][] dp=new double[2][3][3];
      int u=0 ;
      dp[u][ys[0] ][xs[0] ]=1 ;
      for(int i=0 ; i<n ; i++){
        for(int y=0 ; y<3 ; y++){
          for(int x=0 ; x<3 ; x++){
            for(int[] m : move){
              int nx=x+m[0];
              int ny=y+m[1];
              if(nx==xs[2] && ny==ys[2] || nx<0 || 2<nx || ny<0 || 2<ny)dp[1-u][y][x]+=dp[u][y][x]/4 ;
              else dp[1-u][ny][nx]+=dp[u][y][x]/4 ;
            }
            dp[u][y][x]=0 ;
          }
        }
        u=1-u ;
      }
      System.out.printf("%.8f\n",dp[u][ys[1] ][xs[1] ]);
    }
  }
  int[][] move={
    {
-1,0 },{
        0,-1 },{
          0,1 },{
            1,0 }
          };
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var xs : Sequence(int) ; xs := Integer.subrange(1,3)->collect(0) ;
    var ys : Sequence(int) ; ys := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     var a : int ; a := scanner.getCurrent()->at(0+1) - ('A')->char2byte() ;
     xs[i+1] := a mod 3 ; 
     ys[i+1] := a / 3 )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(Sequence(double))) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0.0))) ;
    var u : int ; u := 0 ;
    dp[u+1][ys[0+1]+1][xs[0+1]+1] := 1 ; 
        var i : int ; i := 0 ; while i < n do ( (         var y : int ; y := 0 ; while y < 3 do ( (         var x : int ; x := 0 ; while x < 3 do ( (     for (m : move) do ( (     var nx : int ; nx := x + m[0+1] ;
     var ny : int ; ny := y + m[1+1] ;
     if (nx = xs[2+1] & ny = ys[2+1] or nx < 0 or 2 < nx or ny < 0 or 2 < ny) then     dp[1 - u+1][y+1][x+1] := dp[1 - u+1][y+1][x+1]+(dp[u+1][y+1][x+1] / 4) ; else     dp[1 - u+1][ny+1][nx+1] := dp[1 - u+1][ny+1][nx+1]+(dp[u+1][y+1][x+1] / 4) ; )  ) ; 
     dp[u+1][y+1][x+1] := 0 )  ;     x := x + 1 ) )  ;     y := y + 1 ) ; 
     u := 1 - u )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.8f\n", dp[u+1][ys[1+1]+1][xs[1+1]+1]) ; 
 ) );
   attribute move : Sequence(Sequence(int)) := Sequence{Sequence{-1,0},Sequence{0,-1},Sequence{0,1},Sequence{1,0}};
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int T=0,D=0,L=0 ;
    int z=0,x=0,k=0 ;
    long answe[]=new long[40];
    boolean w=false ;
    while(true){
      T=stdIn.nextInt();
      D=stdIn.nextInt();
      L=stdIn.nextInt();
      if(T==0 && D==0 && L==0)break ;
      long ans=0 ;
      x=D ;
      while(z<T){
        int y=stdIn.nextInt();
        if(y>=L){
          if(x==0 || x==D && w==false)ans--;
          ans++;
          w=true ;
          x=D ;
        }
        if(y<L){
          if(x!=D && x!=0){
            x--;
            ans++;
          }
          if(w){
            w=false ;
            x--;
            ans++;
          }
        }
        z++;
      }
      z=0 ;
      w=false ;
      answe[k]=ans ;
      k++;
    }
    z=0 ;
    while(z<k){
      System.out.println(answe[z]);
      z++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := 0 ;
    var D : int ; D := 0 ;
    var L : int ; L := 0 ;
    var z : int ; z := 0 ;
    var x : int ; x := 0 ;
    var k : int ; k := 0 ;
    var answe : Sequence(long) ; answe := Integer.subrange(1,40)->collect(0) ;
    var w : boolean ; w := false ;
    while (true) do (     T := stdIn.getCurrent()->toInteger() ; 
     D := stdIn.getCurrent()->toInteger() ; 
    L := stdIn.getCurrent()->toInteger() ; 
    if (T = 0 & D = 0 & L = 0) then     break else skip ; 
    var ans : long ; ans := 0 ;
    x := D ; 
    while (z < T) do (     var y : int ; y := stdIn.getCurrent()->toInteger() ;
     if (y >= L) then (     if (x = 0 or x = D & w = false) then     ans := ans - 1 ; else skip ; 
     ans := ans + 1 ; 
     w := true ; 
     x := D ) else skip ; 
     if (y < L) then (     if (x /= D & x /= 0) then (     x := x - 1 ; 
     ans := ans + 1 ) else skip ; 
     if (w) then (     w := false ; 
     x := x - 1 ; 
     ans := ans + 1 ) else skip ) else skip ; 
     z := z + 1 ) ; 
    z := 0 ; 
    w := false ; 
    answe[k+1] := ans ; 
    k := k + 1 ; 
 ) ; 
    z := 0 ; 
    while (z < k) do (     OclFile["System.out"].println(answe[z+1]) ; 
     z := z + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Sol {
  public static void main(String[] argc){
    Scanner sc=new Scanner(System.in);
    int l=sc.nextInt();
    int r=sc.nextInt();
    int ans=0 ;
    for(long i=1 ; i<=r ; i*=2){
      for(long j=1 ; j*i<=r ; j*=3){
        if(i*j>=l)ans+=1 ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sol {
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : long ; i := 1 ; while i <= r do ( (         var j : long ; j := 1 ; while j * i <= r do ( (     if (i * j >= l) then     ans := ans+(1) ; else skip )  ;     j := j*(3) ) )  ;     i := i*(2) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int t1=1 ; t1<=t ; t1++){
      int n=sc.nextInt();
      int[] ar=new int[n+1];
      int[] ind=new int[n+1];
      int max=0 ;
      for(int i=1 ; i<=n ; i++){
        ar[i]=sc.nextInt();
        if(ar[i]>max){
          max=ar[i];
          ind[i]=i ;
        }
        else {
          ind[i]=ind[i-1];
        }
      }
      int tmp=n ;
      while(tmp>0){
        int cur=ind[tmp];
        for(int i=cur ; i<=tmp ; i++){
          System.out.print(ar[i]+" ");
        }
        tmp=cur-1 ;
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var t1 : int ; t1 := 1 ; while t1 <= t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ar : Sequence(int) ; ar := Integer.subrange(1,n + 1)->collect(0) ;
    var ind : Sequence(int) ; ind := Integer.subrange(1,n + 1)->collect(0) ;
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     ar[i+1] := sc.getCurrent()->toInteger() ; 
     if (ar[i+1] > max) then (     max := ar[i+1] ; 
     ind[i+1] := i ) else (     ind[i+1] := ind[i - 1+1] ) )  ;     i := i + 1 ) ; 
    var tmp : int ; tmp := n ;
    while (tmp > 0) do (     var cur : int ; cur := ind[tmp+1] ;
         var i : int ; i := cur ; while i <= tmp do ( (     OclFile["System.out"].print(ar[i+1] + " ") )  ;     i := i + 1 ) ; 
     tmp := cur - 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     t1 := t1 + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    sc.close();
    int t=1 ;
    for(int i=0 ; i<N ; i++){
      t=Math.min(2*t,t+K);
    }
    System.out.println(t);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    skip ; 
    var t : int ; t := 1 ;
        var i : int ; i := 0 ; while i < N do ( (     t := Set{2 * t, t + K}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(t) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      int n=Integer.parseInt(br.readLine());
      int k=Integer.parseInt(br.readLine());
      int i=0 ;
      int value=1 ;
      for(; i<n && value<=k ; i++){
        value*=2 ;
      }
      for(; i<n ; i++){
        value+=k ;
      }
      System.out.println(value);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var n : int ; n := (br.readLine())->toInteger() ;
     var k : int ; k := (br.readLine())->toInteger() ;
    var i : int ; i := 0 ;
    var value : int ; value := 1 ;
      while i < n & value <= k do ( (     value := value*(2) )  ;     i := i + 1 ) ; 
      while i < n do ( (     value := value+(k) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(value) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      int k=scanner.nextInt();
      int result=1 ;
      for(int i=0 ; i<n ; i++){
        result=Math.min(result*2,result+k);
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var k : int ; k := scanner.getCurrent()->toInteger() ;
    var result : int ; result := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     result := Set{result * 2, result + k}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String input=br.readLine();
    int n=Integer.parseInt(input);
    int k=Integer.parseInt(br.readLine());
    int light=1 ;
    for(int i=0 ; i<n ; i++){
      if(light>k){
        light+=k ;
      }
      else {
        light*=2 ;
      }
    }
    System.out.println(light);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : String ; input := br.readLine() ;
    var n : int ; n := (input)->toInteger() ;
    var k : int ; k := (br.readLine())->toInteger() ;
    var light : int ; light := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (light > k) then (     light := light+(k) ) else (     light := light*(2) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(light) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=Integer.parseInt(scanner.nextLine());
    int K=Integer.parseInt(scanner.nextLine());
    int num=1 ;
    for(int i=0 ; i<N ; i++){
      if(mul(num)<add(num,K)){
        num=mul(num);
      }
      else {
        num=add(num,K);
      }
    }
    System.out.println(num);
  }
  static int mul(int n){
    return 2*n ;
  }
  static int add(int n,int k){
    return n+k ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (scanner.nextLine())->toInteger() ;
    var K : int ; K := (scanner.nextLine())->toInteger() ;
    var num : int ; num := 1 ;
        var i : int ; i := 0 ; while i < N do ( (     if (mul(num) < add(num, K)) then (     num := mul(num) ) else (     num := add(num, K) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(num) ; 
 );
  static   operation mul( n : int) : int
  pre: true
  post: true
  activity: (     return 2 * n );
  static   operation add( n : int, k : int) : int
  pre: true
  post: true
  activity: (     return n + k );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean arePermutations(int a[],int b[],int n,int m){
    int sum1=0,sum2=0,mul1=1,mul2=1 ;
    for(int i=0 ; i<n ; i++){
      sum1+=a[i];
      mul1*=a[i];
    }
    for(int i=0 ; i<m ; i++){
      sum2+=b[i];
      mul2*=b[i];
    }
    return((sum1==sum2)&&(mul1==mul2));
  }
  public static void main(String[] args){
    int a[]={
      1,3,2 };
      int b[]={
        3,1,2 };
        int n=a.length ;
        int m=b.length ;
        if(arePermutations(a,b,n,m)==true)System.out.println("Yes");
        else System.out.println("No");
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation arePermutations( a : Sequence(int), b : Sequence(int), n : int, m : int) : boolean
  pre: true
  post: true
  activity: (     var sum1 : int ; sum1 := 0 ;
    var sum2 : int ; sum2 := 0 ;
    var mul1 : int ; mul1 := 1 ;
    var mul2 : int ; mul2 := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     sum1 := sum1+(a[i+1]) ; 
     mul1 := mul1*(a[i+1]) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < m do ( (     sum2 := sum2+(b[i+1]) ; 
     mul2 := mul2*(b[i+1]) )  ;     i := i + 1 ) ; 
     return ((sum1 = sum2) & (mul1 = mul2)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,3,2} ;
     var b : Sequence(int) ; b := Sequence{3,1,2} ;
    var n : int ; n := a->size() ;
    var m : int ; m := b->size() ;
    if (arePermutations(a, b, n, m) = true) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX_CHAR=26 ;
  static void findAndPrintUncommonChars(String str1,String str2){
    int present[]=new int[MAX_CHAR];
    for(int i=0 ; i<MAX_CHAR ; i++){
      present[i]=0 ;
    }
    int l1=str1.length();
    int l2=str2.length();
    for(int i=0 ; i<l1 ; i++){
      present[str1.charAt(i)-'a']=1 ;
    }
    for(int i=0 ; i<l2 ; i++){
      if(present[str2.charAt(i)-'a']==1 || present[str2.charAt(i)-'a']==-1){
        present[str2.charAt(i)-'a']=-1 ;
      }
      else {
        present[str2.charAt(i)-'a']=2 ;
      }
    }
    for(int i=0 ; i<MAX_CHAR ; i++){
      if(present[i]==1 || present[i]==2){
        System.out.print((char)(i+'a')+" ");
      }
    }
  }
  public static void main(String[] args){
    String str1="characters" ;
    String str2="alphabets" ;
    findAndPrintUncommonChars(str1,str2);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX_CHAR : int := 26;
  static   operation findAndPrintUncommonChars( str1 : String, str2 : String) : void
  pre: true
  post: true
  activity: (     var present : Sequence(int) ; present := Integer.subrange(1,MAX_CHAR)->collect(0) ;
         var i : int ; i := 0 ; while i < MAX_CHAR do ( (     present[i+1] := 0 )  ;     i := i + 1 ) ; 
    var l1 : int ; l1 := str1->size() ;
    var l2 : int ; l2 := str2->size() ;
        var i : int ; i := 0 ; while i < l1 do ( (     present[str1->at(i+1) - ('a')->char2byte()+1] := 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < l2 do ( (     if (present[str2->at(i+1) - ('a')->char2byte()+1] = 1 or present[str2->at(i+1) - ('a')->char2byte()+1] = -1) then (     present[str2->at(i+1) - ('a')->char2byte()+1] := -1 ) else (     present[str2->at(i+1) - ('a')->char2byte()+1] := 2 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < MAX_CHAR do ( (     if (present[i+1] = 1 or present[i+1] = 2) then (     OclFile["System.out"].print((i + 'a')->oclAsType(String) + " ") ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "characters" ;
     var str2 : String ; str2 := "alphabets" ;
     execute findAndPrintUncommonChars(str1, str2) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isInside(int circle_x,int circle_y,int rad,int x,int y){
    if((x-circle_x)*(x-circle_x)+(y-circle_y)*(y-circle_y)<=rad*rad)return true ;
    else return false ;
  }
  public static void main(String arg[]){
    int x=1,y=1 ;
    int circle_x=0,circle_y=1,rad=2 ;
    if(isInside(circle_x,circle_y,rad,x,y))System.out.print("Inside");
    else System.out.print("Outside");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isInside( circle_x : int, circle_y : int, rad : int, x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     if ((x - circle_x) * (x - circle_x) + (y - circle_y) * (y - circle_y) <= rad * rad) then     return true else     return false );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 1 ;
    var y : int ; y := 1 ;
     var circle_x : int ; circle_x := 0 ;
    var circle_y : int ; circle_y := 1 ;
    var rad : int ; rad := 2 ;
     if (isInside(circle_x, circle_y, rad, x, y)) then     OclFile["System.out"].print("Inside") ; else     OclFile["System.out"].print("Outside") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isSmaller(String str1,String str2){
    int n1=str1.length(),n2=str2.length();
    if(n1<n2)return true ;
    if(n2<n1)return false ;
    for(int i=0 ; i<n1 ; i++)if(str1.charAt(i)<str2.charAt(i))return true ;
    else if(str1.charAt(i)>str2.charAt(i))return false ;
    return false ;
  }
  static String findDiff(String str1,String str2){
    if(isSmaller(str1,str2)){
      String t=str1 ;
      str1=str2 ;
      str2=t ;
    }
    String str="" ;
    int n1=str1.length(),n2=str2.length();
    str1=new StringBuilder(str1).reverse().toString();
    str2=new StringBuilder(str2).reverse().toString();
    int carry=0 ;
    for(int i=0 ; i<n2 ; i++){
      int sub=((int)(str1.charAt(i)-'0')-(int)(str2.charAt(i)-'0')-carry);
      if(sub<0){
        sub=sub+10 ;
        carry=1 ;
      }
      else carry=0 ;
      str+=(char)(sub+'0');
    }
    for(int i=n2 ; i<n1 ; i++){
      int sub=((int)(str1.charAt(i)-'0')-carry);
      if(sub<0){
        sub=sub+10 ;
        carry=1 ;
      }
      else carry=0 ;
      str+=(char)(sub+'0');
    }
    return new StringBuilder(str).reverse().toString();
  }
  public static void main(String[] args){
    String str1="978" ;
    String str2="12977" ;
    System.out.println(findDiff(str1,str2));
    String s1="100" ;
    String s2="1000000" ;
    System.out.println(findDiff(s1,s2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isSmaller( str1 : String, str2 : String) : boolean
  pre: true
  post: true
  activity: (     var n1 : int ; n1 := str1->size() ;
    var n2 : int ; n2 := str2->size() ;
     if (n1 < n2) then     return true else skip ; 
    if (n2 < n1) then     return false else skip ; 
        var i : int ; i := 0 ; while i < n1 do (     if (str1->at(i+1) < str2->at(i+1)) then     return true else     if (str1->at(i+1) > str2->at(i+1)) then     return false else skip ; ;   ;     i := i + 1 ) ; 
    return false 
 );
  static   operation findDiff( str1 : String, str2 : String) : String
  pre: true
  post: true
  activity: (     if (isSmaller(str1, str2)) then (     var t : String ; t := str1 ;
     str1 := str2 ; 
     str2 := t ) else skip ; 
     var str : String ; str := "" ;
    var n1 : int ; n1 := str1->size() ;
    var n2 : int ; n2 := str2->size() ;
    str1 := StringLib.newString(str1)->reverse()+"" ; 
    str2 := StringLib.newString(str2)->reverse()+"" ; 
    var carry : int ; carry := 0 ;
        var i : int ; i := 0 ; while i < n2 do ( (     var sub : int ; sub := ((str1->at(i+1) - ('0')->char2byte())->oclAsType(int) - (str2->at(i+1) - ('0')->char2byte())->oclAsType(int) - carry) ;
     if (sub < 0) then (     sub := sub + 10 ; 
     carry := 1 ) else     carry := 0 ; ;  
     str := str+((sub + '0')->oclAsType(String)) )  ;     i := i + 1 ) ; 
        var i : int ; i := n2 ; while i < n1 do ( (     var sub : int ; sub := ((str1->at(i+1) - ('0')->char2byte())->oclAsType(int) - carry) ;
     if (sub < 0) then (     sub := sub + 10 ; 
     carry := 1 ) else     carry := 0 ; ;  
     str := str+((sub + '0')->oclAsType(String)) )  ;     i := i + 1 ) ; 
    return StringLib.newString(str)->reverse()+"" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "978" ;
     var str2 : String ; str2 := "12977" ;
    OclFile["System.out"].println(findDiff(str1, str2)) ; 
    var s1 : String ; s1 := "100" ;
    var s2 : String ; s2 := "1000000" ;
    OclFile["System.out"].println(findDiff(s1, s2)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String input=br.readLine();
      String[] tmpArray=input.split(" ");
      int t=Integer.parseInt(tmpArray[0]);
      int d=Integer.parseInt(tmpArray[1]);
      int l=Integer.parseInt(tmpArray[2]);
      if(t==0 && d==0 && l==0){
        break ;
      }
      int tide[]=new int[t];
      for(int i=0 ; i<t ; i++){
        tide[i]=Integer.parseInt(br.readLine());
      }
      int result=0 ;
      int end=Integer.MIN_VALUE ;
      boolean dry[]=new boolean[t];
      for(int i=1 ; i<t ; i++){
        if(tide[i-1]>=l){
          if(i==0 || dry[i-1]){
          }
          end=i-1 ;
        }
        else if(i<=end+d){
        }
        else {
          dry[i]=true ;
        }
      }
      for(int i=1 ; i<t ; i++){
        if(! dry[i]){
          result++;
        }
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var input : String ; input := br.readLine() ;
     var tmpArray : Sequence(String) ; tmpArray := input->split(" ") ;
    var t : int ; t := (tmpArray[0+1])->toInteger() ;
    var d : int ; d := (tmpArray[1+1])->toInteger() ;
    var l : int ; l := (tmpArray[2+1])->toInteger() ;
    if (t = 0 & d = 0 & l = 0) then (     break ) else skip ; 
    var tide : Sequence(int) ; tide := Integer.subrange(1,t)->collect(0) ;
        var i : int ; i := 0 ; while i < t do ( (     tide[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
    var end : int ; end := -2147483648 ;
    var dry : Sequence(boolean) ; dry := Integer.subrange(1,t)->collect(false) ;
        var i : int ; i := 1 ; while i < t do ( (     if (tide[i - 1+1] >= l) then (     if (i = 0 or dry[i - 1+1]) then skip else skip ; 
     end := i - 1 ) else     if (i <= end + d) then skip else (     dry[i+1] := true ) ;  )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < t do ( (     if (not(dry[i+1])) then (     result := result + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minSum(int arr[],int n,int x){
    int sum=0 ;
    int largestDivisible=-1,minimum=arr[0];
    for(int i=0 ; i<n ; i++){
      sum+=arr[i];
      if(arr[i] % x==0 && largestDivisible<arr[i])largestDivisible=arr[i];
      if(arr[i]<minimum)minimum=arr[i];
    }
    if(largestDivisible==-1)return sum ;
    int sumAfterOperation=sum-minimum-largestDivisible+(x*minimum)+(largestDivisible/x);
    return Math.min(sum,sumAfterOperation);
  }
  public static void main(String[] args){
    int arr[]={
      5,5,5,5,6 };
      int n=arr.length ;
      int x=3 ;
      System.out.println(minSum(arr,n,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minSum( arr : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var largestDivisible : int ; largestDivisible := -1 ;
    var minimum : int ; minimum := arr[0+1] ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(arr[i+1]) ; 
     if (arr[i+1] mod x = 0 & largestDivisible < arr[i+1]) then     largestDivisible := arr[i+1] ; else skip ; 
     if (arr[i+1] < minimum) then     minimum := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
    if (largestDivisible = -1) then     return sum else skip ; 
    var sumAfterOperation : int ; sumAfterOperation := sum - minimum - largestDivisible + (x * minimum) + (largestDivisible / x) ;
    return Set{sum, sumAfterOperation}->min() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,5,5,5,6} ;
     var n : int ; n := arr->size() ;
     var x : int ; x := 3 ;
     OclFile["System.out"].println(minSum(arr, n, x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long nthTerm(long n){
    long nth ;
    if(n % 2==0)nth=2*((n*n)-n);
    else nth=(2*n*n)-n ;
    return nth ;
  }
  public static void main(String[] args){
    long n ;
    n=5 ;
    System.out.println(nthTerm(n));
    n=25 ;
    System.out.println(nthTerm(n));
    n=25000000 ;
    System.out.println(nthTerm(n));
    n=250000007 ;
    System.out.println(nthTerm(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nthTerm( n : long) : long
  pre: true
  post: true
  activity: (     var nth : long ;
     if (n mod 2 = 0) then     nth := 2 * ((n * n) - n) else     nth := (2 * n * n) - n ; ;  
     return nth );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ;
     n := 5 ; 
    OclFile["System.out"].println(nthTerm(n)) ; 
    n := 25 ; 
    OclFile["System.out"].println(nthTerm(n)) ; 
    n := 25000000 ; 
    OclFile["System.out"].println(nthTerm(n)) ; 
    n := 250000007 ; 
    OclFile["System.out"].println(nthTerm(n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printArray(int N,int SUM,int K){
    int minSum=(N*(N+1))/2 ;
    int maxSum=(N*K)-(N*(N-1))/2 ;
    if(minSum>SUM || maxSum<SUM){
      System.out.println("Not Possible");
      return ;
    }
    int arr[]=new int[N+1];
    for(int i=1 ; i<=N ; i++)arr[i]=i ;
    int sum=minSum ;
    for(int i=N ; i>=1 ; i--){
      int x=sum+(K-i);
      if(x<SUM){
        sum=sum+(K-i);
        arr[i]=K ;
        K--;
      }
      else {
        arr[i]+=(SUM-sum);
        sum=SUM ;
        break ;
      }
    }
    for(int i=1 ; i<=N ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String[] args){
    int N=3,SUM=15,K=8 ;
    printArray(N,SUM,K);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printArray( N : int, SUM : int, K : int) : void
  pre: true
  post: true
  activity: (     var minSum : int ; minSum := (N * (N + 1)) / 2 ;
     var maxSum : int ; maxSum := (N * K) - (N * (N - 1)) / 2 ;
    if (minSum > SUM or maxSum < SUM) then (     OclFile["System.out"].println("Not Possible") ; 
     return ) else skip ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do (     arr[i+1] := i ;  ;     i := i + 1 ) ; 
    var sum : int ; sum := minSum ;
        var i : int ; i := N ; while i >= 1 do ( (     var x : int ; x := sum + (K - i) ;
     if (x < SUM) then (     sum := sum + (K - i) ; 
     arr[i+1] := K ; 
     K := K - 1 ) else (     arr[i+1] := arr[i+1]+((SUM - sum)) ; 
     sum := SUM ; 
     break ) )  ;     i := i - 1 ) ; 
        var i : int ; i := 1 ; while i <= N do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
    var SUM : int ; SUM := 15 ;
    var K : int ; K := 8 ;
     execute printArray(N, SUM, K) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    List<Integer>list=new LinkedList<Integer>();
    ListIterator<Integer>iterator=list.listIterator();
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    for(int i=0 ; i<n ; i++){
      int cmd=scan.nextInt();
      switch(cmd){
        case 0 : iterator.add(scan.nextInt());
        iterator.previous();
        break ;
        case 1 : int d=scan.nextInt();
        if(d>0){
          for(int j=0 ; j<d ; j++)iterator.next();
        }
        else {
          for(int j=0 ; j>d ; j--)iterator.previous();
        }
        break ;
        case 2 : iterator.next();
        iterator.remove();
        break ;
      }
    }
    for(Integer i : list)System.out.println(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     var iterator : ListIterator<int> ; iterator := list->iterator() ;
    var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var cmd : int ; cmd := scan.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (cmd) ; 
       if _switchval = 0 then
     iterator->excludes(scan.getCurrent()->toInteger()) ; 
    iterator.previous() ; 
    break 
   else skip ;
       if _switchval = 1 then
     var d : int ; d := scan.getCurrent()->toInteger() ;
    if (d > 0) then (         var j : int ; j := 0 ; while j < d do (     iterator.next() ;  ;     j := j + 1 ) ) else (         var j : int ; j := 0 ; while j > d do (     iterator.previous() ;  ;     j := j - 1 ) ) ;  
    break 
   else skip ;
       if _switchval = 2 then
     iterator.next() ; 
    iterator := iterator.remove() ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    for (i : list) do (     OclFile["System.out"].println(i) ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static class Node {
    int value ;
    Node prev ;
    Node next ;
    public Node(int value,Node prev,Node next){
      this.value=value ;
      this.prev=prev ;
      this.next=next ;
    }
  }
  static class MyList {
    Node start ;
    Node end ;
    Node cursor ;
    public void insert(int num){
      Node tmp=new Node(num,cursor.prev,cursor);
      cursor.prev.next=tmp ;
      cursor.prev=tmp ;
      cursor=tmp ;
    }
    public void move(int d){
      if(d<0){
        d*=-1 ;
        for(int i=0 ; i<d ; i++){
          cursor=cursor.prev ;
        }
      }
      else {
        for(int i=0 ; i<d ; i++){
          cursor=cursor.next ;
        }
      }
    }
    public void erase(){
      cursor.prev.next=cursor.next ;
      cursor.next.prev=cursor.prev ;
      cursor=cursor.next ;
    }
    public void print(){
      Node tmp=start.next ;
      while(tmp!=end){
        System.out.println(tmp.value);
        tmp=tmp.next ;
      }
    }
    public MyList(){
      start=new Node(-1000000001,null,null);
      end=new Node(-1000000001,start,start);
      start.next=end ;
      start.prev=end ;
      cursor=end ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    MyList myList=new MyList();
    for(int i=0 ; i<q ; i++){
      switch(sc.nextInt()){
        case 0 : myList.insert(sc.nextInt());
        break ;
        case 1 : myList.move(sc.nextInt());
        break ;
        case 2 : myList.erase();
        break ;
      }
    }
    myList.print();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Node {
   attribute value : int;
   attribute prev : Node;
   attribute next : Node;
   static operation newNode( value : int, prev : Node, next : Node) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(value, prev,next);
    return self );
  operation initialise( value : int, prev : Node, next : Node) : void
  pre: true  post: true
  activity: (     self.value := value ; 
     self.prev := prev ; 
     self.next := next );
}
  static class MyList {
   attribute start : Node;
   attribute end : Node;
   attribute cursor : Node;
   operation insert( num : int) : void
  pre: true
  post: true
  activity: (     var tmp : Node ; tmp := Node.newNode(num, cursor.prev, cursor) ;
     cursor.prev.next := tmp ; 
     cursor.prev := tmp ; 
     cursor := tmp );
   operation move( d : int) : void
  pre: true
  post: true
  activity: (     if (d < 0) then (     d := d*(-1) ; 
         var i : int ; i := 0 ; while i < d do ( (     cursor := cursor.prev )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < d do ( (     cursor := cursor.next )  ;     i := i + 1 ) ) );
   operation erase() : void
  pre: true
  post: true
  activity: (     cursor.prev.next := cursor.next ; 
     cursor.next.prev := cursor.prev ; 
     cursor := cursor.next );
   operation print() : void
  pre: true
  post: true
  activity: (     var tmp : Node ; tmp := start.next ;
     while (tmp /= end) do (     OclFile["System.out"].println(tmp.value) ; 
     tmp := tmp.next ) );
   static operation newMyList() : MyList
  pre: true
  post: true
  activity:
  ( var self : MyList ;
    self := createMyList();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     start := Node.newNode(-1000000001, null, null) ; 
     end := Node.newNode(-1000000001, start, start) ; 
    start.next := end ; 
    start.prev := end ; 
    cursor := end ; 
 );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
    var myList : MyList ; myList := MyList.newMyList() ;
        var i : int ; i := 0 ; while i < q do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (sc.getCurrent()->toInteger()) ; 
       if _switchval = 0 then
     myList := myList.insertAt(sc.getCurrent()->toInteger()+1, StringLib.newString()) ; 
    break 
   else skip ;
       if _switchval = 1 then
     myList.move(sc.getCurrent()->toInteger()) ; 
    break 
   else skip ;
       if _switchval = 2 then
     myList.erase() ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    myList.print() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.lang.*;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    List list=new List();
    int n=Integer.parseInt(br.readLine());
    String l ;
    char query ;
    int x,d ;
    for(int i=0 ; i<n ; i++){
      l=br.readLine();
      query=l.charAt(0);
      switch(query){
        case '0' : x=Integer.parseInt(l.substring(2));
        list.insert(x);
        break ;
        case '1' : d=Integer.parseInt(l.substring(2));
        list.move(d);
        break ;
        case '2' : list.erase();
        break ;
      }
    }
    list.printAll();
  }
}
class List {
  Node pointed ;
  Node top,end ;
  List(){
    top=new Node(Integer.MAX_VALUE,null,end);
    end=new Node(Integer.MAX_VALUE,top,null);
    pointed=end ;
  }
  void insert(int x){
    Node new_node=new Node(x,pointed.left,pointed);
    pointed.left.right=new_node ;
    pointed.left=new_node ;
    pointed=new_node ;
  }
  void move(int d){
    if(d>0){
      while(d>0){
        pointed=pointed.right ;
        d--;
      }
    }
    else {
      while(d<0){
        pointed=pointed.left ;
        d++;
      }
    }
  }
  void erase(){
    pointed.left.right=pointed.right ;
    pointed.right.left=pointed.left ;
    pointed=pointed.right ;
  }
  void printAll(){
    Node now=top.right ;
    while(now.right!=null){
      System.out.println(now.num);
      now=now.right ;
    }
  }
}
class Node {
  int num ;
  Node left,right ;
  Node(int n,Node l,Node r){
    num=n ;
    left=l ;
    right=r ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var list : Sequence ; list := Sequence{} ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var l : String ;
    var query : String ;
    var x : int ;
    var d : int ;
        var i : int ; i := 0 ; while i < n do ( (     l := br.readLine() ; 
     query := l->at(0+1) ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (query) ; 
       if _switchval = '0' then
     x := (l.subrange(2+1,2))->toInteger() ; 
    list := list.insert(x) ; 
    break 
   else skip ;
       if _switchval = '1' then
     d := (l.subrange(2+1,2))->toInteger() ; 
    list := list.move(d) ; 
    break 
   else skip ;
       if _switchval = '2' then
     list := list.erase() ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    list := list.printAll() ; 
 );
}
class List {
   attribute pointed : Node;
   attribute top : Node;
   static operation newList() : List
  pre: true
  post: true
  activity:
  ( var self : List ;
    self := createList();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     top := Node.newNode(2147483647, null, end) ; 
     end := Node.newNode(2147483647, top, null) ; 
     pointed := end );
   operation insert( x : int) : void
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode(x, pointed.left, pointed) ;
     pointed.left.right := new_node ; 
     pointed.left := new_node ; 
     pointed := new_node );
   operation move( d : int) : void
  pre: true
  post: true
  activity: (     if (d > 0) then (     while (d > 0) do (     pointed := pointed.right ; 
     d := d - 1 ) ) else (     while (d < 0) do (     pointed := pointed.left ; 
     d := d + 1 ) ) );
   operation erase() : void
  pre: true
  post: true
  activity: (     pointed.left.right := pointed.right ; 
     pointed.right.left := pointed.left ; 
     pointed := pointed.right );
   operation printAll() : void
  pre: true
  post: true
  activity: (     var now : Node ; now := top.right ;
     while (now.right /= null) do (     OclFile["System.out"].println(now.num) ; 
     now := now.right ) );
}
class Node {
   attribute num : int;
   attribute left : Node;
   static operation newNode( n : int, l : Node, r : Node) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(n, l,r);
    return self );
  operation initialise( n : int, l : Node, r : Node) : void
  pre: true  post: true
  activity: (     num := n ; 
     left := l ; 
     right := r );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    mylist ml=new mylist();
    int q=in.nextInt();
    for(int i=0 ; i<q ; i++){
      int query=Integer.parseInt(in.next());
      switch(query){
        case 0 : int x=Integer.parseInt(in.next());
        ml.insert(x);
        break ;
        case 1 : int d=Integer.parseInt(in.next());
        ml.move(d);
        break ;
        case 2 : ml.delete();
        break ;
      }
    }
    ml.printls();
  }
}
class node {
  node next,prev ;
  int n ;
  boolean END=false ;
}
class mylist {
  node END=new node();
  node currentNode ;
  int position=0,size=0 ;
  mylist(){
    END=new node();
    END.END=true ;
    END.next=END ;
    END.prev=END ;
    currentNode=END ;
  }
  void insert(int x){
    node nn=new node();
    nn.n=x ;
    nn.next=currentNode ;
    nn.prev=currentNode.prev ;
    nn.prev.next=nn ;
    nn.next.prev=nn ;
    currentNode=nn ;
    size++;
  }
  void move(int m){
    for(int i=0 ; i<Math.abs(m); i++){
      if(m<0)currentNode=currentNode.prev ;
      else currentNode=currentNode.next ;
    }
  }
  void delete(){
    currentNode.prev.next=currentNode.next ;
    currentNode.next.prev=currentNode.prev ;
    currentNode=currentNode.next ;
    size--;
  }
  void printls(){
    node cn=END.next ;
    for(int i=0 ; i<size ; i++){
      System.out.println(cn.n);
      cn=cn.next ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ml : mylist ; ml := mylist.newmylist() ;
    var q : int ; q := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var query : int ; query := (in.getCurrent())->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (query) ; 
       if _switchval = 0 then
     var x : int ; x := (in.getCurrent())->toInteger() ;
    ml := ml.insertAt(x+1, StringLib.newString()) ; 
    break 
   else skip ;
       if _switchval = 1 then
     var d : int ; d := (in.getCurrent())->toInteger() ;
    ml.move(d) ; 
    break 
   else skip ;
       if _switchval = 2 then
     ml := ml ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    ml.printls() ; 
 );
}
class node {
   attribute next : node;
   attribute n : int;
   attribute END : boolean := false;
}
class mylist {
   attribute END : node := node.newnode();
   attribute currentNode : node;
   attribute position : int := 0;
   static operation newmylist() : mylist
  pre: true
  post: true
  activity:
  ( var self : mylist ;
    self := createmylist();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     END := node.newnode() ; 
     END.END := true ; 
    END.next := END ; 
    END.prev := END ; 
    currentNode := END ; 
 );
   operation insert( x : int) : void
  pre: true
  post: true
  activity: (     var nn : node ; nn := node.newnode() ;
     nn.n := x ; 
    nn.next := currentNode ; 
    nn.prev := currentNode.prev ; 
    nn.prev.next := nn ; 
    nn.next.prev := nn ; 
    currentNode := nn ; 
    size := size + 1 ; 
 );
   operation move( m : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < if m < 0 then -(m) else m endif do ( (     if (m < 0) then     currentNode := currentNode.prev ; else     currentNode := currentNode.next ; )  ;     i := i + 1 ) );
   operation delete() : void
  pre: true
  post: true
  activity: (     currentNode.prev.next := currentNode.next ; 
     currentNode.next.prev := currentNode.prev ; 
     currentNode := currentNode.next ; 
     size := size - 1 );
   operation printls() : void
  pre: true
  post: true
  activity: (     var cn : node ; cn := END.next ;
         var i : int ; i := 0 ; while i < size do ( (     OclFile["System.out"].println(cn.n) ; 
     cn := cn.next )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Iterator ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.ListIterator ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    LinkedList<Integer>list=new LinkedList<Integer>();
    ListIterator<Integer>it=list.listIterator();
    for(int i=0 ; i<n ; i++){
      String[] tmpArray=br.readLine().split(" ");
      if(tmpArray[0] .equals("0")){
        it.add(Integer.parseInt(tmpArray[1]));
        it.previous();
      }
      else if(tmpArray[0] .equals("1")){
        int x=Integer.parseInt(tmpArray[1]);
        if(x>0){
          for(int j=0 ; j<x ; j++){
            it.next();
          }
        }
        else {
          for(int j=0 ; j<-x ; j++){
            it.previous();
          }
        }
      }
      else {
        it.next();
        it.remove();
      }
    }
    printList(list);
  }
  static void printList(List list){
    Iterator it=list.listIterator(0);
    while(it.hasNext()){
      System.out.println(it.next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
    var it : ListIterator<int> ; it := list->iterator() ;
        var i : int ; i := 0 ; while i < n do ( (     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
     if (tmpArray[0+1] = "0") then (     it->excludes((tmpArray[1+1])->toInteger()) ; 
     it.previous() ) else     if (tmpArray[0+1] = "1") then (     var x : int ; x := (tmpArray[1+1])->toInteger() ;
     if (x > 0) then (         var j : int ; j := 0 ; while j < x do ( (     it.next() )  ;     j := j + 1 ) ) else (         var j : int ; j := 0 ; while j < -x do ( (     it.previous() )  ;     j := j + 1 ) ) ) else (     it.next() ; 
     it := it.remove() ) ;  )  ;     i := i + 1 ) ; 
    execute printList(list) ; 
 );
  static   operation printList( list : Sequence) : void
  pre: true
  post: true
  activity: (     var it : OclIterator ; it := list.subrange(0+1)->iterator() ;
     while (it.hasNext()) do (     OclFile["System.out"].println(it.next()) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class c1029A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    String s=scan.next();
    int ans=0 ;
    for(int i=1 ; i<s.length(); i++){
      if(s.substring(0,i).equals(s.substring(s.length()-i))){
        ans=i ;
      }
    }
    StringBuilder sb=new StringBuilder();
    sb.append(s.substring(s.length()-ans));
    for(int i=0 ; i<k ; i++){
      sb.append(s.substring(ans));
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class c1029A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var s : String ; s := scan.getCurrent() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < s->size() do ( (     if (s.subrange(0+1,i) = s.subrange(s->size() - i+1,s->size() - i)) then (     ans := i ) else skip )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString(s.subrange(s->size() - (ans)->char2byte()+1,s->size() - (ans)->char2byte())) ; 
        var i : int ; i := 0 ; while i < k do ( (     sb := sb + StringLib.newString(s.subrange(ans+1,ans)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigDecimal ;
import java.math.MathContext ;
import java.util.*;
public class ProblemD {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    String line[]=br.readLine().split(" ");
    int n=Integer.parseInt(line[0]);
    int k=Integer.parseInt(line[1]);
    String s=br.readLine();
    String res=s ;
    for(int i=0 ; i<n ; i++){
      boolean ok=false ;
      for(int j=i+1 ; j<=n ; j++){
        String tt=s.substring(i,j);
        String t=s+tt ;
        if(t.substring(t.length()-n,t.length()).equals(s)&& tt.length()<res.length()){
          res=tt ;
          ok=true ;
        }
      }
    }
    for(int i=0 ; i<k-1 ; i++){
      s+=res ;
    }
    System.out.println(s);
  }
  public static void sort(int arr[]){
    ArrayList<Integer>list=new ArrayList<>();
    for(int it : arr)list.add(it);
    Collections.sort(list);
    for(int i=0 ; i<list.size(); i++)arr[i]=list.get(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemD {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var n : int ; n := (line[0+1])->toInteger() ;
    var k : int ; k := (line[1+1])->toInteger() ;
    var s : String ; s := br.readLine() ;
    var res : String ; res := s ;
        var i : int ; i := 0 ; while i < n do ( (     var ok : boolean ; ok := false ;
         var j : int ; j := i + 1 ; while j <= n do ( (     var tt : String ; tt := s.subrange(i+1,j) ;
     var t : String ; t := s + tt ;
     if (t.subrange(t->size() - (n)->char2byte()+1,t->size()) = s & tt->size() < res->size()) then (     res := tt ; 
     ok := true ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k - 1 do ( (     s := s+(res) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 );
  static   operation sort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     for (it : arr) do (     list := list->including(it) ;  ) ; 
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < list->size() do (     arr[i+1] := list->at(i+1) ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GfG {
  static int minimumSwaps(int[] arr){
    int count=0 ;
    int i=0 ;
    while(i<arr.length){
      if(arr[i]!=i+1){
        while(arr[i]!=i+1){
          int temp=0 ;
          temp=arr[arr[i]-1];
          arr[arr[i]-1]=arr[i];
          arr[i]=temp ;
          count++;
        }
      }
      i++;
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      2,3,4,1,5 };
      System.out.println(minimumSwaps(arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation minimumSwaps( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var i : int ; i := 0 ;
     while (i < arr->size()) do (     if (arr[i+1] /= i + 1) then (     while (arr[i+1] /= i + 1) do (     var temp : int ; temp := 0 ;
     temp := arr[arr[i+1] - 1+1] ; 
    arr[arr[i+1] - 1+1] := arr[i+1] ; 
    arr[i+1] := temp ; 
    count := count + 1 ; 
 ) ) else skip ; 
     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4,1,5} ;
     OclFile["System.out"].println(minimumSwaps(arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sc.nextInt();
    int k=sc.nextInt();
    String t=sc.next();
    System.out.println(solve(t,k));
    sc.close();
  }
  static String solve(String t,int k){
    for(int i=1 ; ; i++){
      String suffix=t.substring(i);
      if(t.startsWith(suffix)){
        String prefix=t.substring(0,i);
        StringBuilder result=new StringBuilder();
        for(int j=0 ; j<k-1 ; j++){
          result.append(prefix);
        }
        result.append(t);
        return result.toString();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var t : String ; t := sc.getCurrent() ;
    OclFile["System.out"].println(solve(t, k)) ; 
    skip ; 
 );
  static   operation solve( t : String, k : int) : String
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while true do ( (     var suffix : String ; suffix := t.subrange(i+1,i) ;
     if (t->hasPrefix(suffix)) then (     var prefix : String ; prefix := t.subrange(0+1,i) ;
     var result : String ; result := StringLib.newString() ;
        var j : int ; j := 0 ; while j < k - 1 do ( (     result := result + StringLib.newString(prefix) )  ;     j := j + 1 ) ; 
    result := result + StringLib.newString(t) ; 
    return result+"" 
 ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),k=sc.nextInt();
    String s=sc.next();
    String ans=s ;
    String t=s ;
    for(int i=1 ; i<s.length(); i++){
      if(s.charAt(i)==s.charAt(0)){
        boolean temp=true ;
        int sum=0 ;
        for(int j=i ; j<n ; j++){
          if(s.charAt(j)!=s.charAt(sum++)){
            temp=false ;
            break ;
          }
        }
        if(temp){
          String str="" ;
          for(int j=n-i ; j<n ; j++){
            str+=s.charAt(j);
          }
          t=str ;
          break ;
        }
      }
    }
    for(int i=0 ; i<k-1 ; i++){
      ans+=t ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var ans : String ; ans := s ;
    var t : String ; t := s ;
        var i : int ; i := 1 ; while i < s->size() do ( (     if (s->at(i+1) = s->at(0+1)) then (     var temp : boolean ; temp := true ;
     var sum : int ; sum := 0 ;
         var j : int ; j := i ; while j < n do ( (     if (s->at(j+1) /= s->at(sum+1)) then (     temp := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (temp) then (     var str : String ; str := "" ;
         var j : int ; j := n - (i)->char2byte() ; while j < n do ( (     str := str+(s->at(j+1)) )  ;     j := j + 1 ) ; 
     t := str ; 
     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k - 1 do ( (     ans := ans+(t) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int COST=3 ;
  static int maxItems(int x,int y,int z){
    int type1=x/COST ;
    x %=COST ;
    int type2=y/COST ;
    y %=COST ;
    int type3=z/COST ;
    z %=COST ;
    int type4=Math.min(x,Math.min(y,z));
    int maxItems=type1+type2+type3+type4 ;
    return maxItems ;
  }
  public static void main(String[] args){
    int x=4,y=5,z=6 ;
    System.out.println(maxItems(x,y,z));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute COST : int := 3;
  static   operation maxItems( x : int, y : int, z : int) : int
  pre: true
  post: true
  activity: (     var type1 : int ; type1 := x / COST ;
     x := x mod COST ; 
    var type2 : int ; type2 := y / COST ;
    y := y mod COST ; 
    var type3 : int ; type3 := z / COST ;
    z := z mod COST ; 
    var type4 : int ; type4 := Set{x, Set{y, z}->min()}->min() ;
    var maxItems : int ; maxItems := type1 + type2 + type3 + type4 ;
    return maxItems 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 4 ;
    var y : int ; y := 5 ;
    var z : int ; z := 6 ;
     OclFile["System.out"].println(maxItems(x, y, z)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static final int no_of_chars=256 ;
  static String findSubString(String str,String pat){
    int len1=str.length();
    int len2=pat.length();
    if(len1<len2){
      System.out.println("No such window exists");
      return "" ;
    }
    int hash_pat[]=new int[no_of_chars];
    int hash_str[]=new int[no_of_chars];
    for(int i=0 ; i<len2 ; i++)hash_pat[pat.charAt(i)]++;
    int start=0,start_index=-1,min_len=Integer.MAX_VALUE ;
    int count=0 ;
    for(int j=0 ; j<len1 ; j++){
      hash_str[str.charAt(j)]++;
      if(hash_pat[str.charAt(j)]!=0 && hash_str[str.charAt(j)]<=hash_pat[str.charAt(j)])count++;
      if(count==len2){
        while(hash_str[str.charAt(start)]>hash_pat[str.charAt(start)] || hash_pat[str.charAt(start)]==0){
          if(hash_str[str.charAt(start)]>hash_pat[str.charAt(start)])hash_str[str.charAt(start)]--;
          start++;
        }
        int len_window=j-start+1 ;
        if(min_len>len_window){
          min_len=len_window ;
          start_index=start ;
        }
      }
    }
    if(start_index==-1){
      System.out.println("No such window exists");
      return "" ;
    }
    return str.substring(start_index,start_index+min_len);
  }
  public static void main(String[] args){
    String str="this is a test string" ;
    String pat="tist" ;
    System.out.print("Smallest window is :\n "+findSubString(str,pat));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute no_of_chars : int := 256;
  static   operation findSubString( str : String, pat : String) : String
  pre: true
  post: true
  activity: (     var len1 : int ; len1 := str->size() ;
     var len2 : int ; len2 := pat->size() ;
    if (len1 < len2) then (     OclFile["System.out"].println("No such window exists") ; 
     return "" ) else skip ; 
    var hash_pat : Sequence(int) ; hash_pat := Integer.subrange(1,no_of_chars)->collect(0) ;
    var hash_str : Sequence(int) ; hash_str := Integer.subrange(1,no_of_chars)->collect(0) ;
        var i : int ; i := 0 ; while i < len2 do (     hash_pat[pat->at(i+1)+1] := hash_pat[pat->at(i+1)+1] + 1 ;  ;     i := i + 1 ) ; 
    var start : int ; start := 0 ;
    var start_index : int ; start_index := -1 ;
    var min_len : int ; min_len := 2147483647 ;
    var count : int ; count := 0 ;
        var j : int ; j := 0 ; while j < len1 do ( (     hash_str[str->at(j+1)+1] := hash_str[str->at(j+1)+1] + 1 ; 
     if (hash_pat[str->at(j+1)+1] /= 0 & hash_str[str->at(j+1)+1] <= hash_pat[str->at(j+1)+1]) then     count := count + 1 ; else skip ; 
     if (count = len2) then (     while (hash_str[str->at(start+1)+1] > hash_pat[str->at(start+1)+1] or hash_pat[str->at(start+1)+1] = 0) do (     if (hash_str[str->at(start+1)+1] > hash_pat[str->at(start+1)+1]) then     hash_str[str->at(start+1)+1] := hash_str[str->at(start+1)+1] - 1 ; else skip ; 
     start := start + 1 ) ; 
     var len_window : int ; len_window := j - start + 1 ;
     if (min_len > len_window) then (     min_len := len_window ; 
     start_index := start ) else skip ) else skip )  ;     j := j + 1 ) ; 
    if (start_index = -1) then (     OclFile["System.out"].println("No such window exists") ; 
     return "" ) else skip ; 
    return str.subrange(start_index+1,start_index + min_len) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "this is a test string" ;
     var pat : String ; pat := "tist" ;
     OclFile["System.out"].print("Smallest window is :\n " + findSubString(str, pat)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      Point2 p[]=new Point2[4];
      for(int i=0 ; i<4 ; i++)p[i]=new Point2(in.nextDouble(),in.nextDouble());
      boolean judge=false ;
      if((ccw(p[0],p[3],p[1])>0 && ccw(p[1],p[3],p[2])>0 && ccw(p[2],p[3],p[0])>0)||(ccw(p[0],p[3],p[1])<0 && ccw(p[1],p[3],p[2])<0 && ccw(p[2],p[3],p[0])<0))judge=true ;
      System.out.println(judge ? "YES" : "NO");
    }
  }
  static double ccw(Point2 p1,Point2 p2,Point2 p3){
    return(p2.y-p1.y)*(p3.x-p1.x)-(p3.y-p1.y)*(p2.x-p1.x);
  }
}
class Point2 {
  double x ;
  double y ;
  Point2(double x,double y){
    this.x=x ;
    this.y=y ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var p : Sequence(Point2) ; p := Integer.subrange(1,4)->collect(null) ;
         var i : int ; i := 0 ; while i < 4 do (     p[i+1] := Point2.newPoint2(in.getCurrent()->toReal(), in.getCurrent()->toReal()) ;  ;     i := i + 1 ) ; 
    var judge : boolean ; judge := false ;
    if ((ccw(p[0+1], p[3+1], p[1+1]) > 0 & ccw(p[1+1], p[3+1], p[2+1]) > 0 & ccw(p[2+1], p[3+1], p[0+1]) > 0) or (ccw(p[0+1], p[3+1], p[1+1]) < 0 & ccw(p[1+1], p[3+1], p[2+1]) < 0 & ccw(p[2+1], p[3+1], p[0+1]) < 0)) then     judge := true ; else skip ; 
    OclFile["System.out"].println(if judge then "YES" else "NO" endif) ; 
 ) );
  static   operation ccw( p1 : Point2, p2 : Point2, p3 : Point2) : double
  pre: true
  post: true
  activity: (     return (p2.y - p1.y) * (p3.x - p1.x) - (p3.y - p1.y) * (p2.x - p1.x) );
}
class Point2 {
   attribute x : double;
   attribute y : double;
   static operation newPoint2( x : double, y : double) : Point2
  pre: true
  post: true
  activity:
  ( var self : Point2 ;
    self := createPoint2();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    String line=null ;
    while((line=reader.readLine())!=null){
      String[] values=line.split(" ");
      if(values.length<8){
        break ;
      }
      double x1=Double.parseDouble(values[0]);
      double y1=Double.parseDouble(values[1]);
      double x2=Double.parseDouble(values[2]);
      double y2=Double.parseDouble(values[3]);
      double x3=Double.parseDouble(values[4]);
      double y3=Double.parseDouble(values[5]);
      double xp=Double.parseDouble(values[6]);
      double yp=Double.parseDouble(values[7]);
      double area12=area(xp,yp,x1,y1,x2,y2);
      double area23=area(xp,yp,x2,y2,x3,y3);
      double area31=area(xp,yp,x3,y3,x1,y1);
      double area123=area(x1,y1,x2,y2,x3,y3);
      String result=area12+area23+area31-area123<0.0001 ? "YES" : "NO" ;
      out.println(result);
    }
  }
  static double area(double x1,double y1,double x2,double y2,double x3,double y3){
    return 0.5*Math.abs((x2-x1)*(y3-y1)-(y2-y1)*(x3-x1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     var line : String ; line := null ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     var values : Sequence(String) ; values := line->split(" ") ;
     if (values->size() < 8) then (     break ) else skip ; 
    var x1 : double ; x1 := (values[0+1])->toReal() ;
    var y1 : double ; y1 := (values[1+1])->toReal() ;
    var x2 : double ; x2 := (values[2+1])->toReal() ;
    var y2 : double ; y2 := (values[3+1])->toReal() ;
    var x3 : double ; x3 := (values[4+1])->toReal() ;
    var y3 : double ; y3 := (values[5+1])->toReal() ;
    var xp : double ; xp := (values[6+1])->toReal() ;
    var yp : double ; yp := (values[7+1])->toReal() ;
    var area12 : double ; area12 := area(xp, yp, x1, y1, x2, y2) ;
    var area23 : double ; area23 := area(xp, yp, x2, y2, x3, y3) ;
    var area31 : double ; area31 := area(xp, yp, x3, y3, x1, y1) ;
    var area123 : double ; area123 := area(x1, y1, x2, y2, x3, y3) ;
    var result : String ; result := if area12 + area23 + area31 - area123 < 0.0001 then "YES" else "NO" endif ;
    out.println(result) ; 
 ) ;     line := reader.readLine() ;
 ) );
  static   operation area( x1 : double, y1 : double, x2 : double, y2 : double, x3 : double, y3 : double) : double
  pre: true
  post: true
  activity: (     return 0.5 * if (x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1) < 0 then -((x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1)) else (x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1) endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Vector {
  private double pointX ;
  private double pointY ;
  Vector(double pointX,double pointY){
    this.pointX=pointX ;
    this.pointY=pointY ;
  }
  public double getPointX(){
    return pointX ;
  }
  public double getPointY(){
    return pointY ;
  }
  public void setPointX(int pointX){
    this.pointX=pointX ;
  }
  public void setPointY(int pointY){
    this.pointY=pointY ;
  }
}
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    while(sc.hasNext()){
      Vector a=new Vector(sc.nextDouble(),sc.nextDouble());
      Vector b=new Vector(sc.nextDouble(),sc.nextDouble());
      Vector c=new Vector(sc.nextDouble(),sc.nextDouble());
      Vector p=new Vector(sc.nextDouble(),sc.nextDouble());
      judgePoint(a,b,c,p);
    }
  }
  private static void judgePoint(Vector a,Vector b,Vector c,Vector p){
    Vector pa=new Vector(a.getPointX()-p.getPointX(),a.getPointY()-p.getPointY());
    Vector pb=new Vector(b.getPointX()-p.getPointX(),b.getPointY()-p.getPointY());
    Vector pc=new Vector(c.getPointX()-p.getPointX(),c.getPointY()-p.getPointY());
    double op_pa_pb=pa.getPointX()*pb.getPointY()-pb.getPointX()*pa.getPointY();
    double op_pb_pc=pb.getPointX()*pc.getPointY()-pc.getPointX()*pb.getPointY();
    double op_pc_pa=pc.getPointX()*pa.getPointY()-pa.getPointX()*pc.getPointY();
    if((op_pa_pb>0 && op_pb_pc>0 && op_pc_pa>0)||(op_pa_pb<0 && op_pb_pc<0 && op_pc_pa<0)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Vector {
   attribute pointX : double;
   attribute pointY : double;
   static operation newVector( pointX : double, pointY : double) : Vector
  pre: true
  post: true
  activity:
  ( var self : Vector ;
    self := createVector();
    self.initialise(pointX, pointY);
    return self );
  operation initialise( pointX : double, pointY : double) : void
  pre: true  post: true
  activity: (     self.pointX := pointX ; 
     self.pointY := pointY );
   operation getPointX() : double
  pre: true
  post: true
  activity: (     return pointX );
   operation getPointY() : double
  pre: true
  post: true
  activity: (     return pointY );
   operation setPointX( pointX : int) : void
  pre: true
  post: true
  activity: (     self.pointX := pointX );
   operation setPointY( pointY : int) : void
  pre: true
  post: true
  activity: (     self.pointY := pointY );
}
class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     var a : Sequence ; a := Sequence{} ;
     var b : Sequence ; b := Sequence{} ;
    var c : Sequence ; c := Sequence{} ;
    var p : Sequence ; p := Sequence{} ;
    execute judgePoint(a, b, c, p) ; 
 ) );
  static   operation judgePoint( a : Sequence, b : Sequence, c : Sequence, p : Sequence) : void
  pre: true
  post: true
  activity: (     var pa : Sequence ; pa := Sequence{} ;
     var pb : Sequence ; pb := Sequence{} ;
    var pc : Sequence ; pc := Sequence{} ;
    var op_pa_pb : double ; op_pa_pb := pa.getPointX() * pb.getPointY() - pb.getPointX() * pa.getPointY() ;
    var op_pb_pc : double ; op_pb_pc := pb.getPointX() * pc.getPointY() - pc.getPointX() * pb.getPointY() ;
    var op_pc_pa : double ; op_pc_pa := pc.getPointX() * pa.getPointY() - pa.getPointX() * pc.getPointY() ;
    if ((op_pa_pb > 0 & op_pb_pc > 0 & op_pc_pa > 0) or (op_pa_pb < 0 & op_pb_pc < 0 & op_pc_pa < 0)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  ;
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    for(; sc.hasNext(); ){
      P[] ps=new P[3];
      for(int i=0 ; i<3 ; i++){
        double x=sc.nextDouble();
        double y=sc.nextDouble();
        ps[i]=new P(x,y);
      }
      double xp=sc.nextDouble();
      double yp=sc.nextDouble();
      P q=new P(xp,yp);
      for(int i=0 ; i<3 ; i++){
        ps[i]=ps[i] .sub(q);
      }
      double[] signs=new double[3];
      for(int i=0 ; i<3 ; i++){
        signs[i]=Math.signum(ps[i] .det(ps[(i+1)% 3]));
      }
      if(signs[0]==signs[1] && signs[1]==signs[2]){
        println("YES");
      }
      else {
        println("NO");
      }
    }
  }
  class P {
    double x,y ;
    P(){
      this(0,0);
    }
    P(double x,double y){
      this.x=x ;
      this.y=y ;
    }
    P sub(P p){
      return new P(x-p.x,y-p.y);
    }
    double det(P p){
      return x*p.y-y*p.x ;
    }
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var ps : Sequence(P) ; ps := Integer.subrange(1,3)->collect(null) ;
         var i : int ; i := 0 ; while i < 3 do ( (     var x : double ; x := sc.getCurrent()->toReal() ;
     var y : double ; y := sc.getCurrent()->toReal() ;
     ps[i+1] := P.newP(x, y) )  ;     i := i + 1 ) ; 
    var xp : double ; xp := sc.getCurrent()->toReal() ;
    var yp : double ; yp := sc.getCurrent()->toReal() ;
    var q : P ; q := P.newP(xp, yp) ;
        var i : int ; i := 0 ; while i < 3 do ( (     ps[i+1] := ps[i+1].sub(q) )  ;     i := i + 1 ) ; 
    var signs : Sequence(double) ; signs := Integer.subrange(1,3)->collect(0.0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     signs[i+1] := signum(ps[i+1].det(ps[(i + 1) mod 3+1])) )  ;     i := i + 1 ) ; 
    if (signs[0+1] = signs[1+1] & signs[1+1] = signs[2+1]) then (     execute println("YES") ) else (     execute println("NO") ) ;  
 )  ) );
 class P {
   attribute x : double;
   static operation newP() : P
  pre: true
  post: true
  activity:
  ( var self : P ;
    self := createP();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(0, 0) );
   static operation newP( x : double, y : double) : P
  pre: true
  post: true
  activity:
  ( var self : P ;
    self := createP();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation sub( p : P) : P
  pre: true
  post: true
  activity: (     return P.newP(x - p.x, y - p.y) );
   operation det( p : P) : double
  pre: true
  post: true
  activity: (     return x * p.y - y * p.x );
}
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  double x ;
  double y ;
  public Main(double x,double y){
    this.x=x ;
    this.y=y ;
  }
  public static boolean isInTriangle(Main A,Main B,Main C,Main P){
    double a=0,b=0,c=0 ;
    Main MA=new Main(P.x-A.x,P.y-A.y);
    Main MB=new Main(P.x-B.x,P.y-B.y);
    Main MC=new Main(P.x-C.x,P.y-C.y);
    a=MA.x*MB.y-MA.y*MB.x ;
    b=MB.x*MC.y-MB.y*MC.x ;
    c=MC.x*MA.y-MC.y*MA.x ;
    if((a<=0 && b<=0 && c<=0)||(a>0 && b>0 && c>0))return true ;
    return false ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    double x1,y1,x2,y2,x3,y3,x,y ;
    while(in.hasNext()){
      x1=in.nextDouble();
      y1=in.nextDouble();
      x2=in.nextDouble();
      y2=in.nextDouble();
      x3=in.nextDouble();
      y3=in.nextDouble();
      x=in.nextDouble();
      y=in.nextDouble();
      boolean result=isInTriangle(new Main(x1,y1),new Main(x2,y2),new Main(x3,y3),new Main(x,y));
      if(! result){
        System.out.println("NO");
      }
      else System.out.println("YES");
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute x : double;
   attribute y : double;
   static operation newMain( x : double, y : double) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
  static   operation isInTriangle( A : Main, B : Main, C : Main, P : Main) : boolean
  pre: true
  post: true
  activity: (     var a : double ; a := 0 ;
    var b : double ; b := 0 ;
    var c : double ; c := 0 ;
     var MA : Main ; MA := Main.newMain(P.x - A.x, P.y - A.y) ;
    var MB : Main ; MB := Main.newMain(P.x - B.x, P.y - B.y) ;
    var MC : Main ; MC := Main.newMain(P.x - C.x, P.y - C.y) ;
    a := MA.x * MB.y - MA.y * MB.x ; 
    b := MB.x * MC.y - MB.y * MC.x ; 
    c := MC.x * MA.y - MC.y * MA.x ; 
    if ((a <= 0 & b <= 0 & c <= 0) or (a > 0 & b > 0 & c > 0)) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : double ;
    var y1 : double ;
    var x2 : double ;
    var y2 : double ;
    var x3 : double ;
    var y3 : double ;
    var x : double ;
    var y : double ;
     while (in.hasNext()) do (     x1 := in.getCurrent()->toReal() ; 
     y1 := in.getCurrent()->toReal() ; 
    x2 := in.getCurrent()->toReal() ; 
    y2 := in.getCurrent()->toReal() ; 
    x3 := in.getCurrent()->toReal() ; 
    y3 := in.getCurrent()->toReal() ; 
    x := in.getCurrent()->toReal() ; 
    y := in.getCurrent()->toReal() ; 
    var result : boolean ; result := isInTriangle(Main.newMain(x1, y1), Main.newMain(x2, y2), Main.newMain(x3, y3), Main.newMain(x, y)) ;
    if (not(result)) then (     OclFile["System.out"].println("NO") ) else     OclFile["System.out"].println("YES") ; ;  
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Queue ;
public final class p500 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p500().run());
  }
  private static final int TARGET=500500 ;
  private static final long MODULUS=500500507 ;
  public String run(){
    Queue<Long>queue=new PriorityQueue<>();
    int nextPrime=2 ;
    queue.add((long)nextPrime);
    long product=1 ;
    for(int i=0 ; i<TARGET ; i++){
      long item=queue.remove();
      product*=item % MODULUS ;
      product %=MODULUS ;
      queue.add(item*item);
      if(item==nextPrime){
        do nextPrime++;
        while(! Library.isPrime(nextPrime));
        queue.add((long)nextPrime);
      }
    }
    return Long.toString(product);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p500 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p500.newp500().run()) );
  static    attribute TARGET : int := 500500;
  static    attribute MODULUS : long := 500500507;
   operation run() : String
  pre: true
  post: true
  activity: (     var queue : Sequence(long) ; queue := Sequence{} ;
     var nextPrime : int ; nextPrime := 2 ;
    queue := queue->including(nextPrime->oclAsType(long)) ; 
    var product : long ; product := 1 ;
        var i : int ; i := 0 ; while i < TARGET do ( (     var item : long ; item := queue.remove() ;
     product := product*(item mod MODULUS) ; 
    product := product mod MODULUS ; 
    queue := queue->including(item * item) ; 
    if (item = nextPrime) then (   while true do (    nextPrime := nextPrime + 1 ; ;
    if (not(Library.isPrime(nextPrime))) then skip else break) ; 
     queue := queue->including(nextPrime->oclAsType(long)) ) else skip ; 
 )  ;     i := i + 1 ) ; 
    return ((product) + "") 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class PolandBoardAndGame {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    int m=sc.nextInt();
    if(n>m)System.out.println("YES");
    else if(m>n)System.out.println("NO");
    else {
      Map<String,Integer>map=new HashMap<String,Integer>();
      for(int i=0 ; i<n ; i++){
        map.put(sc.next(),1);
      }
      int dem=0 ;
      for(int i=0 ; i<m ; i++){
        if(map.containsKey(sc.next())){
          dem++;
        }
      }
      if(dem % 2==0){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PolandBoardAndGame {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     if (n > m) then     OclFile["System.out"].println("YES") ; else     if (m > n) then     OclFile["System.out"].println("NO") else (     var map : Map(String,int) ; map := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     map := map->union(Map{sc.getCurrent() |-> 1}) )  ;     i := i + 1 ) ; 
    var dem : int ; dem := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     if (map->keys()->includes(sc.getCurrent())) then (     dem := dem + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (dem mod 2 = 0) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class SolutionC {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    HashSet<String>set=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      String s=in.next();
      set.add(s);
    }
    int both=0 ;
    for(int i=0 ; i<m ; i++){
      String s=in.next();
      if(set.contains(s)){
        both++;
      }
    }
    n-=both ;
    m-=both ;
    while(true){
      if(both!=0){
        both--;
      }
      else if(n!=0){
        n--;
      }
      else {
        System.out.println("NO");
        return ;
      }
      if(both!=0){
        both--;
      }
      else if(m!=0){
        m--;
      }
      else {
        System.out.println("YES");
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SolutionC {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := in.getCurrent() ;
     set := set->including(s) )  ;     i := i + 1 ) ; 
    var both : int ; both := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var s : String ; s := in.getCurrent() ;
     if (set->includes(s)) then (     both := both + 1 ) else skip )  ;     i := i + 1 ) ; 
    n := n-(both) ; 
    m := m-(both) ; 
    while (true) do (     if (both /= 0) then (     both := both - 1 ) else     if (n /= 0) then (     n := n - 1 ) else (     OclFile["System.out"].println("NO") ; 
     return ) ;  ;  
     if (both /= 0) then (     both := both - 1 ) else     if (m /= 0) then (     m := m - 1 ) else (     OclFile["System.out"].println("YES") ; 
     return ) ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner cin=new Scanner(System.in);
  public static void main(String[] args){
    int n=cin.nextInt(),m=cin.nextInt();
    String[] nval=new String[n+1];
    String[] mval=new String[m+1];
    Map<String,Integer>mp=new HashMap<String,Integer>();
    for(int i=1 ; i<=n ; ++i){
      nval[i]=cin.next();
      if(mp.containsKey(nval[i])){
        mp.put(nval[i],mp.get(nval[i])+1);
      }
      else mp.put(nval[i],1);
    }
    for(int i=1 ; i<=m ; ++i){
      mval[i]=cin.next();
      if(mp.containsKey(mval[i])){
        mp.put(mval[i],mp.get(mval[i])+1);
      }
      else mp.put(mval[i],1);
    }
    int num=0 ;
    for(Map.Entry<String,Integer>e : mp.entrySet()){
      if(e.getValue()>1)++num ;
    }
    n=n-num+num % 2 ;
    m=m-num ;
    if(n>m)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute cin : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := cin.getCurrent()->toInteger() ;
    var m : int ; m := cin.getCurrent()->toInteger() ;
     var nval : Sequence(String) ; nval := Integer.subrange(1,n + 1)->collect(null) ;
    var mval : Sequence(String) ; mval := Integer.subrange(1,m + 1)->collect(null) ;
    var mp : Map(String,int) ; mp := Map{} ;
        var i : int ; i := 1 ; while i <= n do ( (     nval[i+1] := cin.getCurrent() ; 
     if (mp->keys()->includes(nval[i+1])) then (     mp := mp->union(Map{nval[i+1] |-> mp->at(nval[i+1]) + 1}) ) else     mp := mp->union(Map{nval[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= m do ( (     mval[i+1] := cin.getCurrent() ; 
     if (mp->keys()->includes(mval[i+1])) then (     mp := mp->union(Map{mval[i+1] |-> mp->at(mval[i+1]) + 1}) ) else     mp := mp->union(Map{mval[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
    var num : int ; num := 0 ;
    for (e : mp->asSet()) do ( (     if (e.getValue() > 1) then     num := num + 1 ; else skip )  ) ; 
    n := n - num + num mod 2 ; 
    m := m - num ; 
    if (n > m) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class PolandBallAndGame {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int N=in.nextInt();
    int M=in.nextInt();
    Set<String>set=new HashSet<>();
    for(int n=0 ; n<N ; n++){
      set.add(in.next());
    }
    int common=0 ;
    for(int m=0 ; m<M ; m++){
      if(! set.add(in.next())){
        common++;
      }
    }
    boolean first=(common % 2==0);
    if(first){
      first=N>M ;
    }
    else {
      first=N>=M ;
    }
    pw.println(first ? "YES" : "NO");
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class PolandBallAndGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var M : int ; M := in.getCurrent()->toInteger() ;
    var set : Set(String) ; set := Set{} ;
        var n : int ; n := 0 ; while n < N do ( (     set := set->including(in.getCurrent()) )  ;     n := n + 1 ) ; 
    var common : int ; common := 0 ;
        var m : int ; m := 0 ; while m < M do ( (     if (not(set->excludes(in.getCurrent()))) then (     common := common + 1 ) else skip )  ;     m := m + 1 ) ; 
    var first : boolean ; first := (common mod 2 = 0) ;
    if (first) then (     first := N > M ) else (     first := N >= M ) ;  
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int run_tasks(Queue<Integer>A,Queue<Integer>B){
    int total_time=0 ;
    while(! A.isEmpty()){
      int x=A.peek();
      int y=B.peek();
      if(x==y){
        A.remove();
        B.remove();
        total_time++;
      }
      else {
        A.remove();
        A.add(x);
        total_time+=2 ;
      }
    }
    return total_time ;
  }
  public static void main(String[] args){
    Queue<Integer>A=new LinkedList<Integer>();
    A.add(3);
    A.add(2);
    A.add(1);
    A.add(4);
    Queue<Integer>B=new LinkedList<Integer>();
    B.add(4);
    B.add(1);
    B.add(3);
    B.add(2);
    System.out.print(run_tasks(A,B));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation run_tasks( A : Sequence(int), B : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var total_time : int ; total_time := 0 ;
     while (not(A->isEmpty())) do (     var x : int ; x := A->min() ;
     var y : int ; y := B->min() ;
     if (x = y) then (     A := A.remove() ; 
     B := B.remove() ; 
     total_time := total_time + 1 ) else (     A := A.remove() ; 
     A->excludes(x) ; 
     total_time := total_time+(2) ) ) ; 
     return total_time );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{} ;
     A := A->including(3) ; 
    A := A->including(2) ; 
    A := A->including(1) ; 
    A := A->including(4) ; 
    var B : Sequence(int) ; B := Sequence{} ;
    B := B->including(4) ; 
    B := B->including(1) ; 
    B := B->including(3) ; 
    B := B->including(2) ; 
    OclFile["System.out"].print(run_tasks(A, B)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=100005 ;
  static Vector<Integer>addPrimes(){
    int n=MAX ;
    boolean[] prime=new boolean[n+1];
    Arrays.fill(prime,true);
    for(int p=2 ; p*p<=n ; p++){
      if(prime[p]==true){
        for(int i=p*p ; i<=n ; i+=p)prime[i]=false ;
      }
    }
    Vector<Integer>ans=new Vector<Integer>();
    for(int p=2 ; p<=n ; p++)if(prime[p])ans.add(p);
    return ans ;
  }
  static boolean is_prime(int n){
    return(n==3 || n==5 || n==7);
  }
  static int find_Sum(int n){
    int sum=0 ;
    Vector<Integer>v=addPrimes();
    for(int i=0 ; i<v.size()&& n>0 ; i++){
      int flag=1 ;
      int a=v.get(i);
      while(a!=0){
        int d=a % 10 ;
        a=a/10 ;
        if(is_prime(d)){
          flag=0 ;
          break ;
        }
      }
      if(flag==1){
        n--;
        sum=sum+v.get(i);
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=7 ;
    System.out.println(find_Sum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100005;
  static   operation addPrimes() : Sequence(int)
  pre: true
  post: true
  activity: (     var n : int ; n := MAX ;
     var prime : Sequence(boolean) ; prime := Integer.subrange(1,n + 1)->collect(false) ;
    prime := prime->collect(true) ; 
        var p : int ; p := 2 ; while p * p <= n do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * p ; while i <= n do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var ans : Sequence(int) ; ans := Sequence{} ;
        var p : int ; p := 2 ; while p <= n do (     if (prime[p+1]) then     ans := ans->including(p) ; else skip ;  ;     p := p + 1 ) ; 
    return ans 
 );
  static   operation is_prime( n : int) : boolean
  pre: true
  post: true
  activity: (     return (n = 3 or n = 5 or n = 7) );
  static   operation find_Sum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var v : Sequence(int) ; v := addPrimes() ;
         var i : int ; i := 0 ; while i < v->size() & n > 0 do ( (     var flag : int ; flag := 1 ;
     var a : int ; a := v->at(i+1) ;
     while (a /= 0) do (     var d : int ; d := a mod 10 ;
     a := a / 10 ; 
     if (is_prime(d)) then (     flag := 0 ; 
     break ) else skip ) ; 
     if (flag = 1) then (     n := n - 1 ; 
     sum := sum + v->at(i+1) ) else skip )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     OclFile["System.out"].println(find_Sum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] science=new int[4];
    int minsc=100 ;
    int sumsc=0 ;
    for(int i=0 ; i<4 ; i++){
      science[i]=sc.nextInt();
      minsc=Math.min(minsc,science[i]);
      sumsc+=science[i];
    }
    sumsc-=minsc ;
    int sumso=sc.nextInt();
    int x=sc.nextInt();
    if(sumso<x){
      sumso=x ;
    }
    System.out.println(sumsc+sumso);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var science : Sequence(int) ; science := Integer.subrange(1,4)->collect(0) ;
    var minsc : int ; minsc := 100 ;
    var sumsc : int ; sumsc := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     science[i+1] := sc.getCurrent()->toInteger() ; 
     minsc := Set{minsc, science[i+1]}->min() ; 
     sumsc := sumsc+(science[i+1]) )  ;     i := i + 1 ) ; 
    sumsc := sumsc-(minsc) ; 
    var sumso : int ; sumso := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    if (sumso < x) then (     sumso := x ) else skip ; 
    OclFile["System.out"].println(sumsc + sumso) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    Scanner sc=new Scanner(systemin);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    int D=sc.nextInt();
    int E=sc.nextInt();
    int F=sc.nextInt();
    int sum=A+B+C+D-Math.min(Math.min(A,B),Math.min(C,D))+Math.max(E,F);
    result.printf("%d\n",sum);
    sc.close();
    return false ;
  }
  PrintStream log ;
  PrintStream result=System.out ;
  BufferedReader systemin ;
  static Main instance=new Main();
  Main(){
    systemin=new BufferedReader(new InputStreamReader(System.in));
    log=new PrintStream(new OutputStream(){
      public void write(int b){
      }
    }
);
  }
  public static void main(String[] args)throws IOException {
    instance.main();
    instance.systemin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(systemin) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var D : int ; D := sc.getCurrent()->toInteger() ;
    var E : int ; E := sc.getCurrent()->toInteger() ;
    var F : int ; F := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := A + B + C + D - Set{Set{A, B}->min(), Set{C, D}->min()}->min() + Set{E, F}->max() ;
    result.printf("%d\n", sum) ; 
    skip ; 
    return false 
 );
   attribute log : OclFile;
   attribute result : OclFile := OclFile["System.out"];
   attribute systemin : OclFile;
  static   attribute instance : Main := Main.newMain();
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     systemin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     log := OclFile.newOclFile_Write(OclFile()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     instance.main() ; 
     instance.systemin.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int a=sc.nextInt();
  static int b=sc.nextInt();
  static int c=sc.nextInt();
  static int d=sc.nextInt();
  static int e=sc.nextInt();
  static int f=sc.nextInt();
  public static void main(String[] args){
    selectSubject();
  }
  private static void selectSubject(){
    ArrayList<Integer>sc=new ArrayList<Integer>();
    ArrayList<Integer>ss=new ArrayList<Integer>();
    sc.add(a);
    sc.add(b);
    sc.add(c);
    sc.add(d);
    ss.add(e);
    ss.add(f);
    Collections.sort(sc);
    Collections.sort(ss);
    System.out.println(sc.get(1)+sc.get(2)+sc.get(3)+ss.get(1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute a : int := sc.getCurrent()->toInteger();
  static   attribute b : int := sc.getCurrent()->toInteger();
  static   attribute c : int := sc.getCurrent()->toInteger();
  static   attribute d : int := sc.getCurrent()->toInteger();
  static   attribute e : int := sc.getCurrent()->toInteger();
  static   attribute f : int := sc.getCurrent()->toInteger();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute selectSubject() );
  static   operation selectSubject() : void
  pre: true
  post: true
  activity: (     var sc : Sequence(int) ; sc := Sequence{} ;
     var ss : Sequence(int) ; ss := Sequence{} ;
    sc := sc->including(a) ; 
    sc := sc->including(b) ; 
    sc := sc->including(c) ; 
    sc := sc->including(d) ; 
    ss := ss->including(e) ; 
    ss := ss->including(f) ; 
    sc := sc->sort() ; 
    ss := ss->sort() ; 
    OclFile["System.out"].println(sc->at(1+1) + sc->at(2+1) + sc->at(3+1) + ss->at(1+1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    int[] arg=new int[100];
    int i=0,sum=0 ;
    int[] k=new int[6];
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String line ;
      while((line=br.readLine())!=null){
        k[0]=Integer.parseInt(line);
        k[1]=Integer.parseInt(br.readLine());
        k[2]=Integer.parseInt(br.readLine());
        k[3]=Integer.parseInt(br.readLine());
        k[4]=Integer.parseInt(br.readLine());
        k[5]=Integer.parseInt(br.readLine());
        int min1=Integer.min(Integer.min(k[0],k[1]),Integer.min(k[2],k[3]));
        boolean end=false ;
        for(i=0 ; i<4 ; i++){
          if(k[i]==min1 && ! end){
            end=true ;
          }
          else {
            sum+=k[i];
          }
        }
        sum+=Integer.max(k[4],k[5]);
        System.out.println(sum);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arg : Sequence(int) ; arg := Integer.subrange(1,100)->collect(0) ;
     var i : int ; i := 0 ;
    var sum : int ; sum := 0 ;
     var k : Sequence(int) ; k := Integer.subrange(1,6)->collect(0) ;
     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     k[0+1] := (line)->toInteger() ; 
     k[1+1] := (br.readLine())->toInteger() ; 
    k[2+1] := (br.readLine())->toInteger() ; 
    k[3+1] := (br.readLine())->toInteger() ; 
    k[4+1] := (br.readLine())->toInteger() ; 
    k[5+1] := (br.readLine())->toInteger() ; 
    var min1 : int ; min1 := Set{Set{k[0+1], k[1+1]}->min(), Set{k[2+1], k[3+1]}->min()}->min() ;
    var end : boolean ; end := false ;
        i := 0 ; while i < 4 do ( (     if (k[i+1] = min1 & not(end)) then (     end := true ) else (     sum := sum+(k[i+1]) ) )  ;     i := i + 1 ) ; 
    sum := sum+(Set{k[4+1], k[5+1]}->max()) ; 
    OclFile["System.out"].println(sum) ; 
    break 
 ) ;     line := br.readLine() ;
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findUniquePair(int[] arr,int n){
    int XOR=arr[0];
    for(int i=1 ; i<n ; i++)XOR=XOR ^ arr[i];
    int set_bit_no=XOR & ~(XOR-1);
    int x=0,y=0 ;
    for(int i=0 ; i<n ; i++){
      if((arr[i] & set_bit_no)>0)x=x ^ arr[i];
      else y=y ^ arr[i];
    }
    System.out.println("The unique pair is("+x+","+y+")");
  }
  public static void main(String[] args){
    int[] a={
      6,1,3,5,1,3,7,6 };
      int n=a.length ;
      findUniquePair(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findUniquePair( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var XOR : int ; XOR := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do (     XOR := MathLib.bitwiseXor(XOR,arr[i+1]) ;  ;     i := i + 1 ) ; 
    var set_bit_no : int ; set_bit_no := MathLib.bitwiseAnd(XOR,-((XOR - 1) + 1)) ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if ((arr[i+1] & set_bit_no) > 0) then     x := MathLib.bitwiseXor(x,arr[i+1]) ; else     y := MathLib.bitwiseXor(y,arr[i+1]) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("The unique pair is(" + x + "," + y + ")") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{6,1,3,5,1,3,7,6} ;
     var n : int ; n := a->size() ;
     execute findUniquePair(a, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a[]=new int[4];
    int b[]=new int[2];
    a[0]=sc.nextInt();
    a[1]=sc.nextInt();
    a[2]=sc.nextInt();
    a[3]=sc.nextInt();
    b[0]=sc.nextInt();
    b[1]=sc.nextInt();
    Arrays.sort(a);
    Arrays.sort(b);
    System.out.println(a[1]+a[2]+a[3]+b[1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,4)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,2)->collect(0) ;
    a[0+1] := sc.getCurrent()->toInteger() ; 
    a[1+1] := sc.getCurrent()->toInteger() ; 
    a[2+1] := sc.getCurrent()->toInteger() ; 
    a[3+1] := sc.getCurrent()->toInteger() ; 
    b[0+1] := sc.getCurrent()->toInteger() ; 
    b[1+1] := sc.getCurrent()->toInteger() ; 
    a := a->sort() ; 
    b := b->sort() ; 
    OclFile["System.out"].println(a[1+1] + a[2+1] + a[3+1] + b[1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class BearAndGame1 {
  public static void main(String[] args){
    InputReader sc=new InputReader(System.in);
    int n=sc.nextInt();
    int[] array=new int[100];
    for(int i=0 ; i<n ; i++){
      array[i]=sc.nextInt();
    }
    int flag=15 ;
    for(int i=0 ; i<n ; i++){
      if(array[i]<=flag){
        flag=array[i]+15 ;
      }
      else {
        break ;
      }
    }
    int result=Math.min(flag,90);
    OutputStream outputStream=System.out ;
    PrintWriter out=new PrintWriter(outputStream);
    out.println(result);
    out.close();
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream));
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BearAndGame1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : InputReader ; sc := InputReader.newInputReader(OclFile["System.in"]) ;
     var n : int ; n := sc.nextInt() ;
    var array : Sequence(int) ; array := Integer.subrange(1,100)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    var flag : int ; flag := 15 ;
        var i : int ; i := 0 ; while i < n do ( (     if (array[i+1] <= flag) then (     flag := array[i+1] + 15 ) else (     break ) )  ;     i := i + 1 ) ; 
    var result : int ; result := Set{flag, 90}->min() ;
    var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    skip ; 
    skip ; 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class BearAndGame {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<Integer>a=new ArrayList<Integer>();
    int value ;
    for(int i=0 ; i<n ; i++){
      value=sc.nextInt();
      a.add(value);
    }
    int result,pos=0,flag=0 ;
    if(a.get(0)>15)result=15 ;
    else {
      for(int i=1 ; i<n ; i++){
        if(a.get(i)-a.get(i-1)>15){
          pos=i-1 ;
          flag=1 ;
          break ;
        }
      }
      if(flag==1)result=a.get(pos)+15 ;
      else result=a.get(n-1)+15 ;
    }
    if(result>90)result=90 ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class BearAndGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
    var value : int ;
        var i : int ; i := 0 ; while i < n do ( (     value := sc.getCurrent()->toInteger() ; 
     a := a->including(value) )  ;     i := i + 1 ) ; 
    var result : int ;
    var pos : int ; pos := 0 ;
    var flag : int ; flag := 0 ;
    if (a->at(0+1) > 15) then     result := 15 else (         var i : int ; i := 1 ; while i < n do ( (     if (a->at(i+1) - a->at(i - 1+1) > 15) then (     pos := i - 1 ; 
     flag := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (flag = 1) then     result := a->at(pos+1) + 15 ; else     result := a->at(n - 1+1) + 15 ; ) ;  
    if (result > 90) then     result := 90 ; else skip ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class BearAndGame {
  public static void main(String[] args)throws NumberFormatException,IOException {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(is);
    int n=Integer.parseInt(br.readLine());
    int arr[]=new int[n+2];
    String[] interesting=br.readLine().split(" ");
    for(int i=1 ; i<arr.length-1 ; i++){
      arr[i]=Integer.parseInt(interesting[i-1]);
    }
    arr[arr.length-1]=90 ;
    boolean flag=true ;
    for(int i=0 ; i<arr.length-1 ; i++){
      if(arr[i+1]-arr[i]>15){
        System.out.println(arr[i]+15);
        flag=false ;
        break ;
      }
    }
    if(flag){
      System.out.println(90);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BearAndGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(is) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 2)->collect(0) ;
    var interesting : Sequence(String) ; interesting := br.readLine()->split(" ") ;
        var i : int ; i := 1 ; while i < arr->size() - 1 do ( (     arr[i+1] := (interesting[i - 1+1])->toInteger() )  ;     i := i + 1 ) ; 
    arr[arr->size() - 1+1] := 90 ; 
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < arr->size() - 1 do ( (     if (arr[i + 1+1] - arr[i+1] > 15) then (     OclFile["System.out"].println(arr[i+1] + 15) ; 
     flag := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then (     OclFile["System.out"].println(90) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.Math ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    solution(n,arr);
  }
  public static void solution(int n,int[] arr){
    int start=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]-start>15){
        break ;
      }
      start=arr[i];
    }
    System.out.println(Math.min(start+15,90));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute solution(n, arr) ; 
 );
  static   operation solution( n : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var start : int ; start := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] - start > 15) then (     break ) else skip ; 
     start := arr[i+1] )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(Set{start + 15, 90}->min()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.regex.*;
class Main {
  public static void main(String[] args){
    try {
      Pattern pat=Pattern.compile("A.*?Z");
      Matcher mat=pat.matcher(new BufferedReader(new InputStreamReader(System.in)).readLine());
      boolean f=false ;
      for(; mat.find(); ){
        f=true ;
        System.out.print("AZ");
      }
      System.out.println(f ? "" : "-1");
    }
    catch(IOException e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var pat : OclRegex ; pat := OclRegex.compile("A.*?Z") ;
     var mat : OclRegex ; mat := pat.matcher(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])).readLine()) ;
    var f : boolean ; f := false ;
      while mat.nextMatch() do ( (     f := true ; 
     OclFile["System.out"].print("AZ") )  ) ; 
    OclFile["System.out"].println(if f then "" else "-1" endif) ; 
 )   catch (e : IOException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void line(double x0,double y0){
    double c=(int)(2*y0*x0);
    System.out.println(y0+"x"+"+"+x0+"y="+c);
  }
  public static void main(String[] args){
    double x0=4,y0=3 ;
    line(x0,y0);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation line( x0 : double, y0 : double) : void
  pre: true
  post: true
  activity: (     var c : double ; c := (2 * y0 * x0)->oclAsType(int) ;
     OclFile["System.out"].println(y0 + "x" + "+" + x0 + "y=" + c) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x0 : double ; x0 := 4 ;
    var y0 : double ; y0 := 3 ;
     execute line(x0, y0) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    int c[][]=new int[3][3];
    boolean b=true ;
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<3 ; j++){
        c[i][j]=sc.nextInt();
      }
    }
    loop : for(int i=0 ;
    i<2 ;
    i++){
      for(int j=i+1 ; j<3 ; j++){
        if(c[i][0]-c[j][0]==c[i][1]-c[j][1] && c[i][1]-c[j][1]==c[i][2]-c[j][2]){
        }
        else {
          b=false ;
          break loop ;
        }
      }
    }
    loop : for(int i=0 ;
    i<2 ;
    i++){
      for(int j=i+1 ; j<3 ; j++){
        if(c[0][i]-c[0][j]==c[1][i]-c[1][j] && c[1][i]-c[1][j]==c[2][i]-c[2][j]){
        }
        else {
          b=false ;
          break loop ;
        }
      }
    }
    if(b){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
    var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
    var b : boolean ; b := true ;
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     c[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 2 do ( (         var j : int ; j := i + 1 ; while j < 3 do ( (     if (c[i+1][0+1] - c[j+1][0+1] = c[i+1][1+1] - c[j+1][1+1] & c[i+1][1+1] - c[j+1][1+1] = c[i+1][2+1] - c[j+1][2+1]) then skip else (     b := false ; 
     break ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 2 do ( (         var j : int ; j := i + 1 ; while j < 3 do ( (     if (c[0+1][i+1] - c[0+1][j+1] = c[1+1][i+1] - c[1+1][j+1] & c[1+1][i+1] - c[1+1][j+1] = c[2+1][i+1] - c[2+1][j+1]) then skip else (     b := false ; 
     break ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (b) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int c11=sc.nextInt();
    int c12=sc.nextInt();
    int c13=sc.nextInt();
    int c21=sc.nextInt();
    int c22=sc.nextInt();
    int c23=sc.nextInt();
    int c31=sc.nextInt();
    int c32=sc.nextInt();
    int c33=sc.nextInt();
    int count=0 ;
    if(c12-c11==c22-c21 && c22-c21==c32-c31){
      if(c13-c12==c23-c22 && c23-c22==c33-c32){
        if(c11-c13==c21-c23 && c21-c23==c31-c33){
          if(c21-c11==c22-c12 && c22-c12==c23-c13){
            if(c31-c21==c32-c22 && c32-c22==c33-c23){
              if(c11-c31==c12-c32 && c12-c32==c13-c33){
              }
            }
            else {
              count++;
            }
          }
          else {
            count++;
          }
        }
        else {
          count++;
        }
      }
      else {
        count++;
      }
    }
    else {
      count++;
    }
    if(count!=0){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
    }
    sc.close();
  }
  public static int gcd(int a,int b){
    if(a<b){
      int tmp=a ;
      a=b ;
      b=tmp ;
    }
    int r=-1 ;
    while(r!=0){
      r=a % b ;
      a=b ;
      b=r ;
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c11 : int ; c11 := sc.getCurrent()->toInteger() ;
    var c12 : int ; c12 := sc.getCurrent()->toInteger() ;
    var c13 : int ; c13 := sc.getCurrent()->toInteger() ;
    var c21 : int ; c21 := sc.getCurrent()->toInteger() ;
    var c22 : int ; c22 := sc.getCurrent()->toInteger() ;
    var c23 : int ; c23 := sc.getCurrent()->toInteger() ;
    var c31 : int ; c31 := sc.getCurrent()->toInteger() ;
    var c32 : int ; c32 := sc.getCurrent()->toInteger() ;
    var c33 : int ; c33 := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    if (c12 - c11 = c22 - c21 & c22 - c21 = c32 - c31) then (     if (c13 - c12 = c23 - c22 & c23 - c22 = c33 - c32) then (     if (c11 - c13 = c21 - c23 & c21 - c23 = c31 - c33) then (     if (c21 - c11 = c22 - c12 & c22 - c12 = c23 - c13) then (     if (c31 - c21 = c32 - c22 & c32 - c22 = c33 - c23) then (     if (c11 - c31 = c12 - c32 & c12 - c32 = c13 - c33) then skip else skip ) else (     count := count + 1 ) ) else (     count := count + 1 ) ) else (     count := count + 1 ) ) else (     count := count + 1 ) ) else (     count := count + 1 ) ;  
    if (count /= 0) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) ;  
    skip ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a < b) then (     var tmp : int ; tmp := a ;
     a := b ; 
     b := tmp ) else skip ; 
     var r : int ; r := -1 ;
     while (r /= 0) do (     r := a mod b ; 
     a := b ; 
     b := r ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class ValeraX {
  public static void main(String[] args){
    CustomScanner cs=new CustomScanner();
    int n=cs.nextInt();
    char xch='\u0000',nxch='\u0000' ;
    for(int i=0 ; i<n ; i++){
      String line=cs.next();
      if(i==0){
        xch=line.charAt(0);
        nxch=line.charAt(1);
      }
      if(xch==nxch){
        System.out.println("NO");
        return ;
      }
      for(int j=0 ; j<n ; j++){
        if(j==i || j==n-i-1){
          if(line.charAt(j)!=xch){
            System.out.println("NO");
            return ;
          }
        }
        else {
          if(line.charAt(j)!=nxch){
            System.out.println("NO");
            return ;
          }
        }
      }
    }
    System.out.println("YES");
  }
  static class CustomScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=nextInt();
      }
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ValeraX {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cs : CustomScanner ; cs := CustomScanner.newCustomScanner() ;
     var n : int ; n := cs.nextInt() ;
    var xch : String ; xch := '\u0000' ;
    var nxch : String ; nxch := '\u0000' ;
        var i : int ; i := 0 ; while i < n do ( (     var line : String ; line := cs.next() ;
     if (i = 0) then (     xch := line->at(0+1) ; 
     nxch := line->at(1+1) ) else skip ; 
     if (xch = nxch) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
         var j : int ; j := 0 ; while j < n do ( (     if (j = i or j = n - (i)->char2byte() - 1) then (     if (line->at(j+1) /= xch) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ) else (     if (line->at(j+1) /= nxch) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
  static class CustomScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int matrix[][]=new int[3][3];
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<3 ; j++){
        matrix[i][j]=sc.nextInt();
      }
    }
    for(int j=0 ; j<2 ; j++){
      for(int i=1 ; i<3 ; i++){
        if(matrix[i-1][j]-matrix[i-1][j+1]!=matrix[i][j]-matrix[i][j+1]){
          System.out.println("No");
          return ;
        }
      }
    }
    for(int i=0 ; i<2 ; i++){
      for(int j=1 ; j<3 ; j++){
        if(matrix[i+1][j-1]-matrix[i][j-1]!=matrix[i+1][j]-matrix[i][j]){
          System.out.println("No");
          return ;
        }
      }
    }
    System.out.println("Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var matrix : Sequence(Sequence(int)) ; matrix := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     matrix[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < 2 do ( (         var i : int ; i := 1 ; while i < 3 do ( (     if (matrix[i - 1+1][j+1] - matrix[i - 1+1][j + 1+1] /= matrix[i+1][j+1] - matrix[i+1][j + 1+1]) then (     OclFile["System.out"].println("No") ; 
     return ) else skip )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
        var i : int ; i := 0 ; while i < 2 do ( (         var j : int ; j := 1 ; while j < 3 do ( (     if (matrix[i + 1+1][j - 1+1] - matrix[i+1][j - 1+1] /= matrix[i + 1+1][j+1] - matrix[i+1][j+1]) then (     OclFile["System.out"].println("No") ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Yes") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[][] c=new int[4][4];
    for(int row=1 ; row<=3 ; row++){
      for(int col=1 ; col<=3 ; col++){
        c[row][col]=sc.nextInt();
      }
    }
    String ans="Yes" ;
    for(int col=2 ; col<=3 ; col++){
      int cur=c[1][1]-c[1][col];
      int d1=c[2][1]-c[2][col];
      int d2=c[3][1]-c[3][col];
      if(cur!=d1 || cur!=d2)ans="No" ;
    }
    if(!(c[1][2]-c[1][3]==c[2][2]-c[2][3] && c[1][2]-c[1][3]==c[3][2]-c[3][3]))ans="No" ;
    for(int row=2 ; row<=3 ; row++){
      int cur=c[1][1]-c[row][1];
      int d1=c[1][2]-c[row][2];
      int d2=c[1][3]-c[row][3];
      if(cur!=d1 || cur!=d2)ans="No" ;
    }
    if(!(c[2][1]-c[3][1]==c[2][2]-c[3][2] && c[2][1]-c[3][1]==c[2][3]-c[3][3]))ans="No" ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,4)->collect(Integer.subrange(1,4)->collect(0)) ;
        var row : int ; row := 1 ; while row <= 3 do ( (         var col : int ; col := 1 ; while col <= 3 do ( (     c[row+1][col+1] := sc.getCurrent()->toInteger() )  ;     col := col + 1 ) )  ;     row := row + 1 ) ; 
    var ans : String ; ans := "Yes" ;
        var col : int ; col := 2 ; while col <= 3 do ( (     var cur : int ; cur := c[1+1][1+1] - c[1+1][col+1] ;
     var d1 : int ; d1 := c[2+1][1+1] - c[2+1][col+1] ;
     var d2 : int ; d2 := c[3+1][1+1] - c[3+1][col+1] ;
     if (cur /= d1 or cur /= d2) then     ans := "No" ; else skip )  ;     col := col + 1 ) ; 
    if (not((c[1+1][2+1] - c[1+1][3+1] = c[2+1][2+1] - c[2+1][3+1] & c[1+1][2+1] - c[1+1][3+1] = c[3+1][2+1] - c[3+1][3+1]))) then     ans := "No" ; else skip ; 
        var row : int ; row := 2 ; while row <= 3 do ( (     var cur : int ; cur := c[1+1][1+1] - c[row+1][1+1] ;
     var d1 : int ; d1 := c[1+1][2+1] - c[row+1][2+1] ;
     var d2 : int ; d2 := c[1+1][3+1] - c[row+1][3+1] ;
     if (cur /= d1 or cur /= d2) then     ans := "No" ; else skip )  ;     row := row + 1 ) ; 
    if (not((c[2+1][1+1] - c[3+1][1+1] = c[2+1][2+1] - c[3+1][2+1] & c[2+1][1+1] - c[3+1][1+1] = c[2+1][3+1] - c[3+1][3+1]))) then     ans := "No" ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int[][] c=new int[3][3];
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<3 ; j++){
        c[i][j]=sc.nextInt();
      }
    }
    String result="No" ;
    for(int a1=-200 ; a1<=200 ; a1++){
      boolean bool=true ;
      int b1=c[0][0]-a1 ;
      int b2=c[0][1]-a1 ;
      int b3=c[0][2]-a1 ;
      int a2=c[1][0]-b1 ;
      int a3=c[2][0]-b1 ;
      if(c[1][1]!=a2+b2)bool=false ;
      if(c[1][2]!=a2+b3)bool=false ;
      if(c[2][1]!=a3+b2)bool=false ;
      if(c[2][2]!=a3+b3)bool=false ;
      if(bool){
        result="Yes" ;
        break ;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     c[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var result : String ; result := "No" ;
        var a1 : int ; a1 := -200 ; while a1 <= 200 do ( (     var bool : boolean ; bool := true ;
     var b1 : int ; b1 := c[0+1][0+1] - (a1)->char2byte() ;
    var b2 : int ; b2 := c[0+1][1+1] - (a1)->char2byte() ;
    var b3 : int ; b3 := c[0+1][2+1] - (a1)->char2byte() ;
    var a2 : int ; a2 := c[1+1][0+1] - b1 ;
    var a3 : int ; a3 := c[2+1][0+1] - b1 ;
    if (c[1+1][1+1] /= a2 + b2) then     bool := false ; else skip ; 
    if (c[1+1][2+1] /= a2 + b3) then     bool := false ; else skip ; 
    if (c[2+1][1+1] /= a3 + b2) then     bool := false ; else skip ; 
    if (c[2+1][2+1] /= a3 + b3) then     bool := false ; else skip ; 
    if (bool) then (     result := "Yes" ; 
     break ) else skip ; 
 )  ;     a1 := a1 + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintStream ps=new PrintStream(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] a=new int[n];
      int[] b=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      boolean flag=true ;
      b[0]=a[0];
      for(int i=1 ; i<n ; i++){
        if(a[i]!=0 && b[i-1]-a[i]>=0){
          flag=false ;
          break ;
        }
        else b[i]=b[i-1]+a[i];
      }
      if(! flag)ps.println(-1);
      else {
        for(int i=0 ; i<n ; i++){
          ps.print(b[i]+" ");
        }
        ps.println();
      }
    }
    ps.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ps : OclFile ; ps := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := true ;
    b[0+1] := a[0+1] ; 
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] /= 0 & b[i - 1+1] - a[i+1] >= 0) then (     flag := false ; 
     break ) else     b[i+1] := b[i - 1+1] + a[i+1] ; )  ;     i := i + 1 ) ; 
    if (not(flag)) then     skip else (         var i : int ; i := 0 ; while i < n do ( (     skip )  ;     i := i + 1 ) ; 
     skip ) ;  
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.List ;
public class Main {
  static PrintWriter out=new PrintWriter(System.out);
  static Scanner in=new Scanner(System.in);
  static BufferedReader re=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter wr=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws IOException {
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int T=in.nextInt();
    while(T>0){
      Map<Integer,Integer>map=new HashMap<>();
      int n=in.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=in.nextInt();
      }
      int res[]=new int[n];
      res[0]=arr[0];
      int t=0 ;
      for(int i=1 ; i<n ; i++){
        res[i]=res[i-1]+arr[i];
        int x=res[i-1]-arr[i];
        if(x>=0 && x!=res[i])t++;
      }
      if(t>0)out.print("-1");
      else {
        for(int i=0 ; i<n ; i++)out.print(res[i]+" ");
      }
      out.println();
      T--;
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute re : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute wr : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
     while (T > 0) do (     var map : Map(int,int) ; map := Map{} ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
    res[0+1] := arr[0+1] ; 
    var t : int ; t := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     res[i+1] := res[i - 1+1] + arr[i+1] ; 
     var x : int ; x := res[i - 1+1] - arr[i+1] ;
     if (x >= 0 & x /= res[i+1]) then     t := t + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (t > 0) then     skip else (         var i : int ; i := 0 ; while i < n do (     skip ;  ;     i := i + 1 ) ) ;  
    skip ; 
    T := T - 1 ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=input.nextInt();
      }
      ArrayList<Integer>ans=new ArrayList<>();
      ans.add(a[0]);
      for(int i=1 ; i<n ; i++){
        int one=ans.get(i-1)-a[i];
        int two=ans.get(i-1)+a[i];
        if(one!=two && one>=0 && two>=0){
          System.out.println("-1");
          continue work ;
        }
        ans.add(ans.get(i-1)+a[i]);
      }
      for(Integer an : ans){
        System.out.print(an+" ");
      }
      System.out.println("");
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var tc : int ; tc := input.nextInt() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.nextInt() )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Sequence{} ;
    ans := ans->including(a[0+1]) ; 
        var i : int ; i := 1 ; while i < n do ( (     var one : int ; one := ans->at(i - 1+1) - a[i+1] ;
     var two : int ; two := ans->at(i - 1+1) + a[i+1] ;
     if (one /= two & one >= 0 & two >= 0) then (     OclFile["System.out"].println("-1") ; 
     continue ) else skip ; 
     ans := ans->including(ans->at(i - 1+1) + a[i+1]) )  ;     i := i + 1 ) ; 
    for (an : ans) do ( (     OclFile["System.out"].print(an + " ") )  ) ; 
    OclFile["System.out"].println("") ; 
 ) ;  ) ;  );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p218 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p218().run());
  }
  public String run(){
    return "0" ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p218 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p218.newp218().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     return "0" );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] agrs){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    Set<String>set=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      StringBuilder s=new StringBuilder(in.next());
      int l=s.length();
      int[] x=new int[26];
      String s1="" ;
      for(int j=0 ; j<l ; j++){
        int c=s.charAt(j)-'a' ;
        x[c]++;
      }
      for(int j=0 ; j<26 ; j++){
        if(x[j]>0)s1+=((char)('a'+j));
      }
      set.add(s1);
    }
    System.out.println(set.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := StringLib.newString(in.getCurrent()) ;
     var l : int ; l := s->size() ;
    var x : Sequence(int) ; x := Integer.subrange(1,26)->collect(0) ;
    var s1 : String ; s1 := "" ;
        var j : int ; j := 0 ; while j < l do ( (     var c : int ; c := s->at(j+1) - ('a')->char2byte() ;
     x[c+1] := x[c+1] + 1 )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < 26 do ( (     if (x[j+1] > 0) then     s1 := s1+((('a' + j)->oclAsType(String))) ; else skip )  ;     j := j + 1 ) ; 
    set := set->including(s1) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(set->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int search(int arr[],int x){
    int n=arr.length ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==x)return i ;
    }
    return-1 ;
  }
  public static void main(String args[]){
    int arr[]={
      2,3,4,10,40 };
      int x=10 ;
      int result=search(arr,x);
      if(result==-1)System.out.print("Element is not present in array");
      else System.out.print("Element is present at index "+result);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation search( arr : Sequence(int), x : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = x) then     return i else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4,10,40} ;
     var x : int ; x := 10 ;
     var result : int ; result := search(arr, x) ;
     if (result = -1) then     OclFile["System.out"].print("Element is not present in array") ; else     OclFile["System.out"].print("Element is present at index " + result) ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    while(true){
      int h=scan.nextInt();
      int w=scan.nextInt();
      if(h==0 && w==0)break ;
      for(int i=0 ; i<h ; ++i){
        for(int j=0 ; j<w ; ++j){
          System.out.print((i+j)% 2==0 ? '#' : '.');
        }
        System.out.println();
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var h : int ; h := scan.getCurrent()->toInteger() ;
     var w : int ; w := scan.getCurrent()->toInteger() ;
    if (h = 0 & w = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     OclFile["System.out"].print(if (i + j) mod 2 = 0 then '#' else '.' endif) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char arr[][]=new char[n][n];
    String str[]=new String[n];
    for(int i=0 ; i<n ; i++){
      str[i]=sc.next();
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        arr[i][j]=str[i] .charAt(j);
      }
    }
    char a=arr[0][0];
    char b=arr[0][1];
    if(a==b)System.out.println("NO");
    else {
      boolean res=true ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          if(i==j || i+j==n-1){
            if(arr[i][j]!=a){
              res=false ;
              break ;
            }
          }
          else {
            if(arr[i][j]!=b){
              res=false ;
              break ;
            }
          }
        }
      }
      if(res)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(String)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var str : Sequence(String) ; str := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     str[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     arr[i+1][j+1] := str[i+1]->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var a : String ; a := arr[0+1][0+1] ;
    var b : String ; b := arr[0+1][1+1] ;
    if (a = b) then     OclFile["System.out"].println("NO") else (     var res : boolean ; res := true ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (i = j or i + j = n - 1) then (     if (arr[i+1][j+1] /= a) then (     res := false ; 
     break ) else skip ) else (     if (arr[i+1][j+1] /= b) then (     res := false ; 
     break ) else skip ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (res) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  public void execution(int h,int w){
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        if((i % 2==0 && j % 2==0)||(i % 2==1 && j % 2==1)){
          System.out.print("#");
        }
        else System.out.print(".");
      }
      System.out.println();
    }
  }
  public void run(){
    sc=new Scanner(System.in);
    ArrayList<Integer>n=new ArrayList<Integer>();
    while(sc.hasNextInt()){
      int value=sc.nextInt();
      int value2=sc.nextInt();
      if(value==0 && value2==0){
        break ;
      }
      else {
        execution(value,value2);
        System.out.println();
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   operation execution( h : int, w : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if ((i mod 2 = 0 & j mod 2 = 0) or (i mod 2 = 1 & j mod 2 = 1)) then (     OclFile["System.out"].print("#") ) else     OclFile["System.out"].print(".") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : Sequence(int) ; n := Sequence{} ;
     while (sc.hasNextInt()) do (     var value : int ; value := sc.getCurrent()->toInteger() ;
     var value2 : int ; value2 := sc.getCurrent()->toInteger() ;
     if (value = 0 & value2 = 0) then (     break ) else (     execute execution(value, value2) ; 
     OclFile["System.out"].println() ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int count=0 ;
    int count_h=0 ;
    int count_w=0 ;
    while(h*w!=0){
      for(int i=0 ; i<h*w ; i++){
        if((count_h+count_w)% 2==0){
          System.out.printf("#");
        }
        else {
          System.out.printf(".");
        }
        count_w++;
        if(count_w==w){
          count_w=0 ;
          count_h++;
          System.out.printf("\n");
        }
      }
      System.out.printf("\n");
      count_h=0 ;
      h=sc.nextInt();
      w=sc.nextInt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var count_h : int ; count_h := 0 ;
    var count_w : int ; count_w := 0 ;
    while (h * w /= 0) do (         var i : int ; i := 0 ; while i < h * w do ( (     if ((count_h + count_w) mod 2 = 0) then (     OclFile["System.out"].printf("#") ) else (     OclFile["System.out"].printf(".") ) ;  
     count_w := count_w + 1 ; 
     if (count_w = w) then (     count_w := 0 ; 
     count_h := count_h + 1 ; 
     OclFile["System.out"].printf("\n") ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].printf("\n") ; 
    count_h := 0 ; 
    h := sc.getCurrent()->toInteger() ; 
    w := sc.getCurrent()->toInteger() ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] linearr ;
    int i,j,h,w ;
    int f=1 ;
    try {
      while(null!=(line=reader.readLine())){
        linearr=line.split(" ");
        h=Integer.parseInt(linearr[0]);
        w=Integer.parseInt(linearr[1]);
        if(h==0 && w==0){
          break ;
        }
        for(i=0 ; i<h ; i++){
          f=(i % 2==0)? 1 :-1 ;
          for(j=0 ; j<w ; j++){
            if(f==1)System.out.printf("#");
            else if(f==-1)System.out.printf(".");
            f*=-1 ;
          }
          System.out.printf("\n");
        }
        System.out.printf("\n");
      }
    }
    catch(IOException e){
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var linearr : Sequence(String) ;
    var i : int ;
    var j : int ;
    var h : int ;
    var w : int ;
    var f : int ; f := 1 ;
    try (         line := reader.readLine() ;
    while (null /= (line)) do (    skip ; (     linearr := line->split(" ") ; 
     h := (linearr[0+1])->toInteger() ; 
    w := (linearr[1+1])->toInteger() ; 
    if (h = 0 & w = 0) then (     break ) else skip ; 
        i := 0 ; while i < h do ( (     f := if (i mod 2 = 0) then 1 else -1 endif ; 
         j := 0 ; while j < w do ( (     if (f = 1) then     OclFile["System.out"].printf("#") else     if (f = -1) then     OclFile["System.out"].printf(".") ; else skip ; ;  
     f := f*(-1) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].printf("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("\n") ; 
 ) ;     line := reader.readLine() ;
 ) )   catch (e : IOException) do (     OclFile["System.out"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static String[] c={
    "#","." };
    static void print(int r){
      switch(r % 2){
        case 0 : System.out.print(c[0]);
        break ;
        case 1 : System.out.print(c[1]);
        break ;
      }
    }
    public static void main(String[] args){
      Scanner stdIn=new Scanner(System.in);
      while(true){
        int height=stdIn.nextInt();
        int width=stdIn.nextInt();
        if(height==0 && width==0)break ;
        for(int r=0 ; r<height ; r++){
          for(int c=(r % 2==0)? 0 : 1 ; c<((r % 2==0)? width : width+1); c++){
            print(c);
          }
          System.out.println();
        }
        System.out.println();
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute c : Sequence(String) := Sequence{"#","."};
  static   operation print( r : int) : void
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (r mod 2) ; 
       if _switchval = 0 then
     OclFile["System.out"].print(c[0+1]) ; 
    break 
   else skip ;
       if _switchval = 1 then
     OclFile["System.out"].print(c[1+1]) ; 
    break 
   else skip ;
 )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var height : int ; height := stdIn.getCurrent()->toInteger() ;
     var width : int ; width := stdIn.getCurrent()->toInteger() ;
    if (height = 0 & width = 0) then     break else skip ; 
        var r : int ; r := 0 ; while r < height do ( (         var c : int ; c := if (r mod 2 = 0) then 0 else 1 endif ; while c < (if (r mod 2 = 0) then width else width + 1 endif) do ( (     execute print(c) )  ;     c := c + 1 ) ; 
     OclFile["System.out"].println() )  ;     r := r + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] input=br.readLine().split(" ");
    int n=Integer.parseInt(input[0]);
    long c=Long.parseLong(input[1]);
    long forwardMax[]=new long[n+1];
    long backwardMax[]=new long[n+1];
    long positions[]=new long[n+1];
    long values[]=new long[n+1];
    positions[0]=0 ;
    values[0]=0 ;
    for(int i=1 ; i<=n ; i++){
      input=br.readLine().split(" ");
      positions[i]=Long.parseLong(input[0]);
      values[i]=Long.parseLong(input[1]);
    }
    long max=0 ;
    long sum=0 ;
    for(int i=0 ; i<=n ; i++){
      sum+=values[i];
      max=Math.max(max,sum-positions[i]);
      forwardMax[i]=max ;
    }
    max=0 ;
    sum=0 ;
    for(int i=n ; i>=0 ; i--){
      sum+=values[i];
      max=Math.max(max,sum-(c-positions[i]));
      backwardMax[i]=max ;
    }
    long res=0 ;
    for(int i=0 ; i<=n ; i++){
      res=Math.max(res,forwardMax[i]);
      if(i!=n)res=Math.max(res,forwardMax[i]-(positions[i])+backwardMax[i+1]);
      res=Math.max(res,backwardMax[i]);
      if(i!=0)res=Math.max(res,backwardMax[i]-(c-positions[i])+forwardMax[i-1]);
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : Sequence(String) ; input := br.readLine()->split(" ") ;
    var n : int ; n := (input[0+1])->toInteger() ;
    var c : long ; c := (input[1+1])->toLong() ;
    var forwardMax : Sequence(long) ; forwardMax := Integer.subrange(1,n + 1)->collect(0) ;
    var backwardMax : Sequence(long) ; backwardMax := Integer.subrange(1,n + 1)->collect(0) ;
    var positions : Sequence(long) ; positions := Integer.subrange(1,n + 1)->collect(0) ;
    var values : Sequence(long) ; values := Integer.subrange(1,n + 1)->collect(0) ;
    positions[0+1] := 0 ; 
    values[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (     input := br.readLine()->split(" ") ; 
     positions[i+1] := (input[0+1])->toLong() ; 
     values[i+1] := (input[1+1])->toLong() )  ;     i := i + 1 ) ; 
    var max : long ; max := 0 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i <= n do ( (     sum := sum+(values[i+1]) ; 
     max := Set{max, sum - positions[i+1]}->max() ; 
     forwardMax[i+1] := max )  ;     i := i + 1 ) ; 
    max := 0 ; 
    sum := 0 ; 
        var i : int ; i := n ; while i >= 0 do ( (     sum := sum+(values[i+1]) ; 
     max := Set{max, sum - (c - positions[i+1])}->max() ; 
     backwardMax[i+1] := max )  ;     i := i - 1 ) ; 
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i <= n do ( (     res := Set{res, forwardMax[i+1]}->max() ; 
     if (i /= n) then     res := Set{res, forwardMax[i+1] - (positions[i+1]) + backwardMax[i + 1+1]}->max() ; else skip ; 
     res := Set{res, backwardMax[i+1]}->max() ; 
     if (i /= 0) then     res := Set{res, backwardMax[i+1] - (c - positions[i+1]) + forwardMax[i - 1+1]}->max() ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[])throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long c=sc.nextLong();
    long[] xArr=new long[n];
    long[] vArr=new long[n];
    for(int i=0 ; i<n ; i++){
      xArr[i]=sc.nextLong();
      vArr[i]=sc.nextLong();
    }
    long[] left=new long[n+1];
    long[] leftBack=new long[n+1];
    long aSumValue=0 ;
    for(int i=1 ; i<n+1 ; i++){
      left[i]=Math.max(left[i-1],aSumValue+vArr[i-1]-xArr[i-1]);
      leftBack[i]=Math.max(leftBack[i-1],aSumValue+vArr[i-1]-xArr[i-1]*2);
      aSumValue+=vArr[i-1];
    }
    long[] right=new long[n+1];
    long[] rightBack=new long[n+1];
    long bSumValue=0 ;
    for(int i=1 ; i<n+1 ; i++){
      int idx=n-i ;
      right[i]=Math.max(right[i-1],bSumValue+vArr[idx]-(c-xArr[idx]));
      rightBack[i]=Math.max(rightBack[i-1],bSumValue+vArr[idx]-(c-xArr[idx])*2);
      bSumValue+=vArr[idx];
    }
    long max=0 ;
    for(int i=0 ; i<n+1 ; i++){
      max=Math.max(max,Math.max(left[i]+rightBack[n-i],right[n-i]+leftBack[i]));
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : long ; c := sc.getCurrent()->toLong() ;
    var xArr : Sequence(long) ; xArr := Integer.subrange(1,n)->collect(0) ;
    var vArr : Sequence(long) ; vArr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     xArr[i+1] := sc.getCurrent()->toLong() ; 
     vArr[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var left : Sequence(long) ; left := Integer.subrange(1,n + 1)->collect(0) ;
    var leftBack : Sequence(long) ; leftBack := Integer.subrange(1,n + 1)->collect(0) ;
    var aSumValue : long ; aSumValue := 0 ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     left[i+1] := Set{left[i - 1+1], aSumValue + vArr[i - 1+1] - xArr[i - 1+1]}->max() ; 
     leftBack[i+1] := Set{leftBack[i - 1+1], aSumValue + vArr[i - 1+1] - xArr[i - 1+1] * 2}->max() ; 
     aSumValue := aSumValue+(vArr[i - 1+1]) )  ;     i := i + 1 ) ; 
    var right : Sequence(long) ; right := Integer.subrange(1,n + 1)->collect(0) ;
    var rightBack : Sequence(long) ; rightBack := Integer.subrange(1,n + 1)->collect(0) ;
    var bSumValue : long ; bSumValue := 0 ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     var idx : int ; idx := n - i ;
     right[i+1] := Set{right[i - 1+1], bSumValue + vArr[idx+1] - (c - xArr[idx+1])}->max() ; 
     rightBack[i+1] := Set{rightBack[i - 1+1], bSumValue + vArr[idx+1] - (c - xArr[idx+1]) * 2}->max() ; 
     bSumValue := bSumValue+(vArr[idx+1]) )  ;     i := i + 1 ) ; 
    var max : long ; max := 0 ;
        var i : int ; i := 0 ; while i < n + 1 do ( (     max := Set{max, Set{left[i+1] + rightBack[n - i+1], right[n - i+1] + leftBack[i+1]}->max()}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long c=sc.nextLong();
    long[][] nums=new long[n][2];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<2 ; j++){
        nums[i][j]=sc.nextLong();
      }
    }
    long[][] max=new long[n+2][4];
    long[] sum=new long[2];
    for(int i=0 ; i<n ; i++){
      sum[0]+=nums[i][1];
      max[i+1][0]=Math.max(max[i][0],sum[0]-nums[i][0]);
      max[i+1][1]=Math.max(max[i][1],sum[0]-nums[i][0]*2);
      sum[1]+=nums[n-i-1][1];
      max[n-i][2]=Math.max(max[n-i+1][2],sum[1]-(c-nums[n-i-1][0]));
      max[n-i][3]=Math.max(max[n-i+1][3],sum[1]-(c-nums[n-i-1][0])*2);
    }
    long ans=0 ;
    for(int i=0 ; i<n+1 ; i++){
      ans=Math.max(ans,max[i][0]+max[i+1][3]);
      ans=Math.max(ans,max[i][1]+max[i+1][2]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : long ; c := sc.getCurrent()->toLong() ;
    var nums : Sequence(Sequence(long)) ; nums := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 2 do ( (     nums[i+1][j+1] := sc.getCurrent()->toLong() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : Sequence(Sequence(long)) ; max := Integer.subrange(1,n + 2)->collect(Integer.subrange(1,4)->collect(0)) ;
    var sum : Sequence(long) ; sum := Integer.subrange(1,2)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     sum[0+1] := sum[0+1]+(nums[i+1][1+1]) ; 
     max[i + 1+1][0+1] := Set{max[i+1][0+1], sum[0+1] - nums[i+1][0+1]}->max() ; 
    max[i + 1+1][1+1] := Set{max[i+1][1+1], sum[0+1] - nums[i+1][0+1] * 2}->max() ; 
    sum[1+1] := sum[1+1]+(nums[n - i - 1+1][1+1]) ; 
    max[n - i+1][2+1] := Set{max[n - i + 1+1][2+1], sum[1+1] - (c - nums[n - i - 1+1][0+1])}->max() ; 
    max[n - i+1][3+1] := Set{max[n - i + 1+1][3+1], sum[1+1] - (c - nums[n - i - 1+1][0+1]) * 2}->max() ; 
 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n + 1 do ( (     ans := Set{ans, max[i+1][0+1] + max[i + 1+1][3+1]}->max() ; 
     ans := Set{ans, max[i+1][1+1] + max[i + 1+1][2+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    int q=in.nextInt();
    for(int i=0 ; i<q ; i++)new CGL_2B().doIt();
  }
  class CGL_2B {
    void doIt(){
      Line2D l1=new Line2D.Double(in.nextDouble(),in.nextDouble(),in.nextDouble(),in.nextDouble());
      ;
      Line2D l2=new Line2D.Double(in.nextDouble(),in.nextDouble(),in.nextDouble(),in.nextDouble());
      ;
      if(l1.intersectsLine(l2))System.out.println("1");
      else System.out.println("0");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var q : int ; q := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < q do (     CGL()B.newCGL()B().doIt() ;  ;     i := i + 1 ) );
 class CGL{
   operation doIt() : void
  pre: true
  post: true
  activity: (     var l1 : Line2D ; l1 := Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal()) ;
    var l2 : Line2D ; l2 := Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal()) ;
    if (l1.intersectsLine(l2)) then     OclFile["System.out"].println("1") else     OclFile["System.out"].println("0") ; ;  
 );
}
B {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var l1 : Line2D ; l1 := Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal()) ;
    var l2 : Line2D ; l2 := Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal()) ;
    if (l1.intersectsLine(l2)) then     OclFile["System.out"].println("1") else     OclFile["System.out"].println("0") ; ;  
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.run();
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long c=sc.nextLong();
    long x[]=new long[n];
    long v[]=new long[n];
    for(int i=0 ; i<n ; i++){
      x[i]=sc.nextLong();
      v[i]=sc.nextLong();
    }
    long left[]=new long[n+1];
    long leftback[]=new long[n+1];
    long lsum=0 ;
    for(int i=0 ; i<n ; i++){
      left[i+1]=Math.max(left[i],lsum+v[n-1-i]-(c-x[n-1-i]));
      leftback[i+1]=Math.max(leftback[i],lsum+v[n-1-i]-2*(c-x[n-1-i]));
      lsum+=v[n-1-i];
    }
    long right[]=new long[n+1];
    long rightback[]=new long[n+1];
    long rsum=0 ;
    for(int i=0 ; i<n ; i++){
      right[i+1]=Math.max(right[i],rsum+v[i]-x[i]);
      rightback[i+1]=Math.max(rightback[i],rsum+v[i]-2*x[i]);
      rsum+=v[i];
    }
    long max=0 ;
    for(int i=0 ; i<=n ; i++){
      max=Math.max(max,Math.max(leftback[i]+right[n-i],rightback[i]+left[n-i]));
    }
    System.out.println(max);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : long ; c := sc.getCurrent()->toLong() ;
    var x : Sequence(long) ; x := Integer.subrange(1,n)->collect(0) ;
    var v : Sequence(long) ; v := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toLong() ; 
     v[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var left : Sequence(long) ; left := Integer.subrange(1,n + 1)->collect(0) ;
    var leftback : Sequence(long) ; leftback := Integer.subrange(1,n + 1)->collect(0) ;
    var lsum : long ; lsum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     left[i + 1+1] := Set{left[i+1], lsum + v[n - 1 - i+1] - (c - x[n - 1 - i+1])}->max() ; 
     leftback[i + 1+1] := Set{leftback[i+1], lsum + v[n - 1 - i+1] - 2 * (c - x[n - 1 - i+1])}->max() ; 
     lsum := lsum+(v[n - 1 - i+1]) )  ;     i := i + 1 ) ; 
    var right : Sequence(long) ; right := Integer.subrange(1,n + 1)->collect(0) ;
    var rightback : Sequence(long) ; rightback := Integer.subrange(1,n + 1)->collect(0) ;
    var rsum : long ; rsum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     right[i + 1+1] := Set{right[i+1], rsum + v[i+1] - x[i+1]}->max() ; 
     rightback[i + 1+1] := Set{rightback[i+1], rsum + v[i+1] - 2 * x[i+1]}->max() ; 
     rsum := rsum+(v[i+1]) )  ;     i := i + 1 ) ; 
    var max : long ; max := 0 ;
        var i : int ; i := 0 ; while i <= n do ( (     max := Set{max, Set{leftback[i+1] + right[n - i+1], rightback[i+1] + left[n - i+1]}->max()}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class _96B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long number=in.nextLong();
    long ans=-1,value=0 ;
    int mask=2 ;
    while(value<number){
      String s=Integer.toBinaryString(mask++).substring(1);
      int zeros=0 ;
      for(char c : s.toCharArray())if(c=='0')zeros++;
      if(zeros!=s.length()-zeros)continue ;
      s=s.replace('0','4');
      s=s.replace('1','7');
      value=Long.parseLong(s);
    }
    System.out.println(value);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _96B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : long ; number := in.getCurrent()->toLong() ;
    var ans : long ; ans := -1 ;
    var value : long ; value := 0 ;
    var mask : int ; mask := 2 ;
    while (value < number) do (     var s : String ; s := (MathLib.decimal2binary(mask) + "").subrange(1+1,1) ;
     var zeros : int ; zeros := 0 ;
    for (c : s->characters()) do (     if (c = '0') then     zeros := zeros + 1 ; else skip ;  ) ; 
    if (zeros /= s->size() - (zeros)->char2byte()) then     continue else skip ; 
    s := s.replace('0', '4') ; 
    s := s.replace('1', '7') ; 
    value := (s)->toLong() ; 
 ) ; 
    OclFile["System.out"].println(value) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class Main {
  private static BufferedReader br ;
  private static StringTokenizer strz ;
  public static void main(String[] args)throws java.lang.Exception {
    br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    strz=new StringTokenizer(br.readLine());
    long[] arr=new long[n];
    long xor=0 ;
    for(int i=0 ; i<n ; ++i){
      arr[i]=Long.parseLong(strz.nextToken());
      xor ^=arr[i];
    }
    for(int i=0 ; i<n ; ++i){
      System.out.print((xor ^ arr[i])+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile;
  static   attribute strz : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     var n : int ; n := (br.readLine())->toInteger() ;
    strz := OclIterator.newOclIterator_String(br.readLine()) ; 
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
    var xor : long ; xor := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (strz.next())->toLong() ; 
     xor := MathLib.bitwiseXor(xor,arr[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print((MathLib.bitwiseXor(xor,arr[i+1])) + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    E solver=new E();
    solver.solve(1,in,out);
    out.close();
  }
  static class E {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=Integer.parseInt(in.next());
      long[] a=new long[n];
      long sum=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=Long.parseLong(in.next());
        sum ^=a[i];
      }
      for(int i=0 ; i<n ; i++){
        out.printf("%d ",sum ^ a[i]);
      }
      out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : E ; solver := E.newE() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class E {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (in.getCurrent())->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (in.getCurrent())->toLong() ; 
     sum := MathLib.bitwiseXor(sum,a[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void solve(InputReader in,PrintWriter out)throws Exception {
    int n=in.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=in.nextInt();
    int xor=0 ;
    for(int i=0 ; i<n-1 ; i+=2)xor=xor ^ arr[i] ^ arr[i+1];
    for(int i=0 ; i<n ; i++)out.print((xor ^ arr[i])+" ");
    out.println();
  }
  private final static long hash(long x,long y){
    x+=offset ;
    y+=offset ;
    return x<<32 | y ;
  }
  private final static int offset=(int)3e5 ;
  public static void main(String[] args)throws Exception {
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    solve(in,out);
    out.close();
  }
  static class InputReader {
    private BufferedReader reader ;
    private StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    private String nextToken()throws IOException {
      while(tokenizer==null || ! tokenizer.hasMoreTokens())tokenizer=new StringTokenizer(reader.readLine());
      return tokenizer.nextToken();
    }
    public String nextLine()throws IOException {
      return reader.readLine();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(nextToken());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(nextToken());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(nextToken());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := in.nextInt() ;  ;     i := i + 1 ) ; 
    var xor : int ; xor := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do (     xor := MathLib.bitwiseXor(MathLib.bitwiseXor(xor,arr[i+1]),arr[i + 1+1]) ;  ;     i := i+(2) ) ; 
        var i : int ; i := 0 ; while i < n do (     out.print((MathLib.bitwiseXor(xor,arr[i+1])) + " ") ;  ;     i := i + 1 ) ; 
    out.println() ; 
 );
  static   operation hash( x : long, y : long) : long
  pre: true
  post: true
  activity: (     x := x+(offset) ; 
     y := y+(offset) ; 
     return MathLib.bitwiseOr((x*(2->pow(32)))->oclAsType(long),y) );
  static   attribute offset : int := 3e5->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    execute solve(in, out) ; 
    skip ; 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ; ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return reader.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashSet ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    int r=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      r ^=a[i];
    }
    for(int i=0 ; i<n ; i++){
      if(i!=0)System.out.print(" ");
      System.out.print(r ^ a[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var r : int ; r := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     r := MathLib.bitwiseXor(r,a[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i /= 0) then     OclFile["System.out"].print(" ") ; else skip ; 
     OclFile["System.out"].print(MathLib.bitwiseXor(r,a[i+1])) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  public static void main(String hi[])throws Exception {
    BufferedReader infile=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(infile.readLine());
    int N=Integer.parseInt(st.nextToken());
    int[] arr=new int[N];
    st=new StringTokenizer(infile.readLine());
    for(int i=0 ; i<N ; i++)arr[i]=Integer.parseInt(st.nextToken());
    long all=0L ;
    for(int x : arr)all ^=x ;
    StringBuilder sb=new StringBuilder();
    for(int x : arr)sb.append(all ^ x).append(" ");
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( hi : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var infile : OclFile ; infile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(infile.readLine()) ;
    var N : int ; N := (st.next())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
    st := OclIterator.newOclIterator_String(infile.readLine()) ; 
        var i : int ; i := 0 ; while i < N do (     arr[i+1] := (st.next())->toInteger() ;  ;     i := i + 1 ) ; 
    var all : long ; all := 0L ;
    for (x : arr) do (     all := MathLib.bitwiseXor(all,x) ;  ) ; 
    var sb : String ; sb := StringLib.newString() ;
    for (x : arr) do (     sb := sb + StringLib.newString(MathLib.bitwiseXor(all,x)) + StringLib.newString(" ") ;  ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int toggleBitsFromLToR(int n,int l,int r){
    int num=((1<<r)-1)^((1<<(l-1))-1);
    return(n ^ num);
  }
  static int unsetBitsInGivenRange(int n,int l,int r){
    int num=(1<<(4*8-1))-1 ;
    num=toggleBitsFromLToR(num,l,r);
    return(n & num);
  }
  public static void main(String[] args){
    int n=42 ;
    int l=2,r=5 ;
    System.out.println(unsetBitsInGivenRange(n,l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation toggleBitsFromLToR( n : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := MathLib.bitwiseXor((((1*(2->pow(r)))->oclAsType(long)) - 1),(((1*(2->pow((l - 1))))->oclAsType(long)) - 1)) ;
     return (n xor num) );
  static   operation unsetBitsInGivenRange( n : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := ((1*(2->pow((4 * 8 - 1))))->oclAsType(long)) - 1 ;
     num := toggleBitsFromLToR(num, l, r) ; 
     return (n & num) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 42 ;
     var l : int ; l := 2 ;
    var r : int ; r := 5 ;
     OclFile["System.out"].println(unsetBitsInGivenRange(n, l, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MinStep(int a[],int n){
    int positive=0,negative=0,zero=0 ;
    int step=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]==0){
        zero++;
      }
      else if(a[i]<0){
        negative++;
        step=step+(-1-a[i]);
      }
      else {
        positive++;
        step=step+(a[i]-1);
      }
    }
    if(negative % 2==0){
      step=step+zero ;
    }
    else {
      if(zero>0){
        step=step+zero ;
      }
      else {
        step=step+2 ;
      }
    }
    return step ;
  }
  public static void main(String[] args){
    int a[]={
      0,-2,-1,-3,4 };
      int n=a.length ;
      System.out.println(MinStep(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation MinStep( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var positive : int ; positive := 0 ;
    var negative : int ; negative := 0 ;
    var zero : int ; zero := 0 ;
     var step : int ; step := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = 0) then (     zero := zero + 1 ) else     if (a[i+1] < 0) then (     negative := negative + 1 ; 
     step := step + (-1 - a[i+1]) ) else (     positive := positive + 1 ; 
     step := step + (a[i+1] - 1) ) ;  )  ;     i := i + 1 ) ; 
    if (negative mod 2 = 0) then (     step := step + zero ) else (     if (zero > 0) then (     step := step + zero ) else (     step := step + 2 ) ) ;  
    return step 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{0,-2,-1,-3,4} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(MinStep(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int number=sc.nextInt(),start=sc.nextInt(),end=sc.nextInt();
    int[] arr=new int[number+1];
    String str=sc.next();
    for(int i=0 ; i<str.length(); i++){
      arr[i+1]=str.charAt(i)-'0' ;
    }
    if(arr[start]==arr[end]){
      System.out.println(0);
    }
    else {
      System.out.println(Math.abs(arr[start]-arr[end]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := sc.getCurrent()->toInteger() ;
    var start : int ; start := sc.getCurrent()->toInteger() ;
    var end : int ; end := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,number + 1)->collect(0) ;
    var str : String ; str := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < str->size() do ( (     arr[i + 1+1] := str->at(i+1) - ('0')->char2byte() )  ;     i := i + 1 ) ; 
    if (arr[start+1] = arr[end+1]) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(if arr[start+1] - arr[end+1] < 0 then -(arr[start+1] - arr[end+1]) else arr[start+1] - arr[end+1] endif) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MyClass {
  public static Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    int n=scanner.nextInt();
    int a=scanner.nextInt();
    int b=scanner.nextInt();
    String s=scanner.nextLine();
    s=scanner.nextLine();
    a--;
    b--;
    System.out.println((s.charAt(a)-'0')^(s.charAt(b)-'0'));
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var s : String ; s := scanner.nextLine() ;
    s := scanner.nextLine() ; 
    a := a - 1 ; 
    b := b - 1 ; 
    OclFile["System.out"].println((s->at(a+1) - ('0')->char2byte()) xor (s->at(b+1) - ('0')->char2byte())) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.awt.geom.Point2D ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    for(int i=0 ; i<n ; i++){
      String[] tmpArray=br.readLine().split(" ");
      Point2D[] points=new Point2D[4];
      for(int j=0 ; j<4 ; j++){
        int x=Integer.parseInt(tmpArray[j*2]);
        int y=Integer.parseInt(tmpArray[j*2+1]);
        points[j]=new Point2D.Double(x,y);
      }
      Line2D[] lines=new Line2D[2];
      for(int j=0 ; j<2 ; j++){
        lines[j]=new Line2D.Double(points[j*2],points[j*2+1]);
      }
      if(lines[0] .intersectsLine(lines[1])){
        System.out.println(1);
      }
      else {
        System.out.println(0);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
     var points : Sequence(Point2D) ; points := Integer.subrange(1,4)->collect(null) ;
        var j : int ; j := 0 ; while j < 4 do ( (     var x : int ; x := (tmpArray[j * 2+1])->toInteger() ;
     var y : int ; y := (tmpArray[j * 2 + 1+1])->toInteger() ;
     points[j+1] := Double.newDouble(x, y) )  ;     j := j + 1 ) ; 
    var lines : Sequence(Line2D) ; lines := Integer.subrange(1,2)->collect(null) ;
        var j : int ; j := 0 ; while j < 2 do ( (     lines[j+1] := Double.newDouble(points[j * 2+1], points[j * 2 + 1+1]) )  ;     j := j + 1 ) ; 
    if (lines[0+1].intersectsLine(lines[1+1])) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(0) ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public void doIt(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextLine()){
      String str=sc.nextLine();
      int len=str.length();
      for(int i=0 ; i<len ; i++){
        char now=str.charAt(i);
        if(now!='@'){
          System.out.print(now);
        }
        else {
          i++;
          int num=str.charAt(i)-'0' ;
          i++;
          if(0<=num && num<=9){
            now=str.charAt(i);
            for(int j=0 ; j<num ; j++){
              System.out.print(now);
            }
          }
        }
      }
      System.out.println("");
    }
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextLine()) do (     var str : String ; str := sc.nextLine() ;
     var len : int ; len := str->size() ;
         var i : int ; i := 0 ; while i < len do ( (     var now : String ; now := str->at(i+1) ;
     if (now /= '@') then (     OclFile["System.out"].print(now) ) else (     i := i + 1 ; 
     var num : int ; num := str->at(i+1) - ('0')->char2byte() ;
     i := i + 1 ; 
     if (0 <= num & num <= 9) then (     now := str->at(i+1) ; 
         var j : int ; j := 0 ; while j < num do ( (     OclFile["System.out"].print(now) )  ;     j := j + 1 ) ) else skip ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("") ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class VladikAndFlights {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),a=in.nextInt(),b=in.nextInt();
    char[] s=in.next().toCharArray();
    pw.println(solve(n,s,a,b));
    pw.close();
  }
  static int solve(int n,char[] s,int a,int b){
    a--;
    b--;
    if(s[a]==s[b])return 0 ;
    return 1 ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class VladikAndFlights {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := in.getCurrent()->characters() ;
    skip ; 
    skip ; 
 );
  static   operation solve( n : int, s : Sequence(String), a : int, b : int) : int
  pre: true
  post: true
  activity: (     a := a - 1 ; 
     b := b - 1 ; 
     if (s[a+1] = s[b+1]) then     return 0 else skip ; 
     return 1 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] num=new int[n];
      for(int i=0 ; i<n ; i++)num[i]=sc.nextInt();
      Arrays.sort(num);
      System.out.println(num[n-1]+num[n-2]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var num : Sequence(int) ; num := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     num[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    num := num->sort() ; 
    OclFile["System.out"].println(num[n - 1+1] + num[n - 2+1]) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] num=new int[n];
      for(int i=0 ; i<n ; i++)num[i]=sc.nextInt();
      Arrays.sort(num);
      System.out.println(num[n-1]+num[n-2]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var num : Sequence(int) ; num := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     num[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    num := num->sort() ; 
    OclFile["System.out"].println(num[n - 1+1] + num[n - 2+1]) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  static void noOfSquares(int x1,int y1,int x2,int y2){
    int dx=Math.abs(x2-x1);
    int dy=Math.abs(y2-y1);
    int ans=dx+dy-__gcd(dx,dy);
    System.out.println(ans);
  }
  public static void main(String[] args){
    int x1=1,y1=1,x2=4,y2=3 ;
    noOfSquares(x1,y1,x2,y2);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation noOfSquares( x1 : int, y1 : int, x2 : int, y2 : int) : void
  pre: true
  post: true
  activity: (     var dx : int ; dx := if x2 - x1 < 0 then -(x2 - x1) else x2 - x1 endif ;
     var dy : int ; dy := if y2 - y1 < 0 then -(y2 - y1) else y2 - y1 endif ;
     var ans : int ; ans := dx + dy - __gcd(dx, dy) ;
     OclFile["System.out"].println(ans) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x1 : int ; x1 := 1 ;
    var y1 : int ; y1 := 1 ;
    var x2 : int ; x2 := 4 ;
    var y2 : int ; y2 := 3 ;
     execute noOfSquares(x1, y1, x2, y2) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String get_maximum(char[] s,int a[]){
    int n=s.length ;
    for(int i=0 ; i<n ; i++){
      if(s[i]-'0'<a[s[i]-'0']){
        int j=i ;
        while(j<n &&(s[j]-'0'<=a[s[j]-'0'])){
          s[j]=(char)('0'+a[s[j]-'0']);
          j++;
        }
        return String.valueOf(s);
      }
    }
    return String.valueOf(s);
  }
  public static void main(String[] args){
    String s="1337" ;
    int a[]={
      0,1,2,5,4,6,6,3,1,9 };
      System.out.println(get_maximum(s.toCharArray(),a));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation get_maximum( s : Sequence(String), a : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
         var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] - ('0')->char2byte() < a[s[i+1] - ('0')->char2byte()+1]) then (     var j : int ; j := i ;
     while (j < n & (s[j+1] - ('0')->char2byte() <= a[s[j+1] - ('0')->char2byte()+1])) do (     s[j+1] := ('0' + a[s[j+1] - ('0')->char2byte()+1])->oclAsType(String) ; 
     j := j + 1 ) ; 
     return ((s) + "") ) else skip )  ;     i := i + 1 ) ; 
     return ((s) + "") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "1337" ;
     var a : Sequence(int) ; a := Sequence{0,1,2,5,4,6,6,3,1,9} ;
     OclFile["System.out"].println(get_maximum(s->characters(), a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
class GFG {
  static int MAX_DIGITS=20 ;
  static int isOctal(int n){
    while(n>0){
      if((n % 10)>=8)return 0 ;
      else n=n/10 ;
    }
    return 1 ;
  }
  static int isPalindrome(int n){
    int divide=(isOctal(n)==0)? 8 : 10 ;
    int octal[]=new int[MAX_DIGITS];
    int i=0 ;
    while(n!=0){
      octal[i++]=n % divide ;
      n=n/divide ;
    }
    for(int j=i-1,k=0 ; k<=j ; j--,k++)if(octal[j]!=octal[k])return 0 ;
    return 1 ;
  }
  public static void main(String[] args){
    int n=97 ;
    if(isPalindrome(n)>0)System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX_DIGITS : int := 20;
  static   operation isOctal( n : int) : int
  pre: true
  post: true
  activity: (     while (n > 0) do (     if ((n mod 10) >= 8) then     return 0 else     n := n / 10 ; ) ; 
     return 1 );
  static   operation isPalindrome( n : int) : int
  pre: true
  post: true
  activity: (     var divide : int ; divide := if (isOctal(n) = 0) then 8 else 10 endif ;
     var octal : Sequence(int) ; octal := Integer.subrange(1,MAX_DIGITS)->collect(0) ;
    var i : int ; i := 0 ;
    while (n /= 0) do (      octal[i+1] := n mod divide  ; i := i + 1 ; 
     n := n / divide ) ; 
        var j : int ; j := i - 1 ;
    var k : int ; k := 0 ; while k <= j do (     if (octal[j+1] /= octal[k+1]) then     return 0 else skip ;  ;     j := j - 1 ;     k := k + 1 ) ; 
    return 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 97 ;
     if (isPalindrome(n) > 0) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int x=0,y=0 ;
    int t=0 ;
    int n=in.nextInt();
    String str=in.next();
    char l[]=new char[str.length()];
    l=str.toCharArray();
    for(int i=0 ; i<n ; i++){
      if(l[i]!='4' && l[i]!='7'){
        t=1 ;
      }
    }
    if(t==1){
      System.out.println("NO");
    }
    else {
      for(int i=0 ; i<n/2 ; i++){
        x=x+Character.getNumericValue(l[i]);
      }
      for(int i=n-1 ; i>(n/2)-1 ; i--){
        y=y+Character.getNumericValue(l[i]);
      }
      if(x==y){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var t : int ; t := 0 ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var str : String ; str := in.getCurrent() ;
    var l : Sequence(String) ; l := Integer.subrange(1,str->size())->collect(0) ;
    l := str->characters() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (l[i+1] /= '4' & l[i+1] /= '7') then (     t := 1 ) else skip )  ;     i := i + 1 ) ; 
    if (t = 1) then (     OclFile["System.out"].println("NO") ) else (         var i : int ; i := 0 ; while i < n / 2 do ( (     x := x + ("" + l[i+1])->toInteger() )  ;     i := i + 1 ) ; 
         var i : int ; i := n - 1 ; while i > (n / 2) - 1 do ( (     y := y + ("" + l[i+1])->toInteger() )  ;     i := i - 1 ) ; 
     if (x = y) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class LuckyTicket {
  public static void main(String[] args){
    Scanner sn=new Scanner(System.in);
    int n=sn.nextInt();
    sn.nextLine();
    boolean is_lucky=true ;
    String number=sn.nextLine();
    int fours_first_half=0 ;
    int fours_second_half=0 ;
    for(int i=0 ; i<number.length(); i++){
      char ch=number.charAt(i);
      if(!(ch=='4' || ch=='7')){
        is_lucky=false ;
        break ;
      }
      if(i<number.length()/2){
        if(ch=='4'){
          fours_first_half++;
        }
      }
      else {
        if(ch=='4'){
          fours_second_half++;
        }
      }
    }
    System.out.println(is_lucky &&(fours_first_half==fours_second_half)? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class LuckyTicket {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sn : OclFile ; sn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sn.getCurrent()->toInteger() ;
    skip ; 
    var is_lucky : boolean ; is_lucky := true ;
    var number : String ; number := sn.nextLine() ;
    var fours_first_half : int ; fours_first_half := 0 ;
    var fours_second_half : int ; fours_second_half := 0 ;
        var i : int ; i := 0 ; while i < number->size() do ( (     var ch : String ; ch := number->at(i+1) ;
     if (not((ch = '4' or ch = '7'))) then (     is_lucky := false ; 
     break ) else skip ; 
     if (i < number->size() / 2) then (     if (ch = '4') then (     fours_first_half := fours_first_half + 1 ) else skip ) else (     if (ch = '4') then (     fours_second_half := fours_second_half + 1 ) else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if is_lucky & (fours_first_half = fours_second_half) then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int binarySearch(int arr[],int low,int high){
    if(high<low)return-1 ;
    int mid=(low+high)/2 ;
    int midValue=arr[mid];
    if(mid==arr[mid])return mid ;
    int leftindex=Math.min(mid-1,midValue);
    int left=binarySearch(arr,low,leftindex);
    if(left>=0)return left ;
    int rightindex=Math.max(mid+1,midValue);
    int right=binarySearch(arr,rightindex,high);
    return right ;
  }
  public static void main(String[] args){
    int arr[]={
-10,-5,2,2,2,3,4,7,9,12,13 };
      System.out.println("Fixed Point is "+binarySearch(arr,0,arr.length-1));
      int arr1[]={
-10,-1,3,3,10,30,30,50,100 };
        System.out.println("Fixed Point is "+binarySearch(arr1,0,arr1.length-1));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation binarySearch( arr : Sequence(int), low : int, high : int) : int
  pre: true
  post: true
  activity: (     if (high < low) then     return -1 else skip ; 
     var mid : int ; mid := (low + high) / 2 ;
    var midValue : int ; midValue := arr[mid+1] ;
    if (mid = arr[mid+1]) then     return mid else skip ; 
    var leftindex : int ; leftindex := Set{mid - 1, midValue}->min() ;
    var left : int ; left := binarySearch(arr, low, leftindex) ;
    if (left >= 0) then     return left else skip ; 
    var rightindex : int ; rightindex := Set{mid + 1, midValue}->max() ;
    var right : int ; right := binarySearch(arr, rightindex, high) ;
    return right 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-10,-5,2,2,2,3,4,7,9,12,13} ;
     OclFile["System.out"].println("Fixed Point is " + binarySearch(arr, 0, arr->size() - 1)) ; 
     var arr1 : Sequence(int) ; arr1 := Sequence{-10,-1,3,3,10,30,30,50,100} ;
     OclFile["System.out"].println("Fixed Point is " + binarySearch(arr1, 0, arr1->size() - 1)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    ArrayList<String>input=new ArrayList<String>();
    String buf ;
    while((buf=br.readLine())!=null){
      input.add(buf);
    }
    for(String str : input){
      System.out.println(unzipString(str));
    }
  }
  public static String zipString(String str){
    StringBuffer bf=new StringBuffer();
    return bf.toString();
  }
  public static String unzipString(String str){
    StringBuffer bf=new StringBuffer();
    char[] c=str.toCharArray();
    for(int i=0 ; i<c.length ; i++){
      if(c[i]=='@'){
        int n=Integer.parseInt(String.valueOf(c[++i]));
        char tmp=c[++i];
        for(int j=0 ; j<n ; j++){
          bf.append(tmp);
        }
      }
      else {
        bf.append(c[i]);
      }
    }
    return bf.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : Sequence(String) ; input := Sequence{} ;
    var buf : String ;
        buf := br.readLine() ;
    while ((buf) /= null) do (    skip ; (     input := input->including(buf) ) ;     buf := br.readLine() ;
 ) ;  
    for (str : input) do ( (     OclFile["System.out"].println(unzipString(str)) )  ) ; 
 );
  static   operation zipString( str : String) : String
  pre: true
  post: true
  activity: (     var bf : String ; bf := StringLib.newString() ;
     return bf+"" );
  static   operation unzipString( str : String) : String
  pre: true
  post: true
  activity: (     var bf : String ; bf := StringLib.newString() ;
     var c : Sequence(String) ; c := str->characters() ;
         var i : int ; i := 0 ; while i < c->size() do ( (     if (c[i+1] = '@') then (     var n : int ; n := (((c[(i + 1)+1]) + ""))->toInteger() ;
     var tmp : String ;     i := i + 1 ;
tmp := c[i+1] ;
         var j : int ; j := 0 ; while j < n do ( (     bf := bf + StringLib.newString(tmp) )  ;     j := j + 1 ) ) else (     bf := bf + StringLib.newString(c[i+1]) ) )  ;     i := i + 1 ) ; 
     return bf+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isAnyNotPalindrome(String s){
    Set<Character>unique=new HashSet<Character>();
    for(int i=0 ; i<s.length(); i++)unique.add(s.charAt(i));
    if(unique.size()>1)return true ;
    else return false ;
  }
  public static void main(String[] args){
    String s="aaaaab" ;
    if(isAnyNotPalindrome(s))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isAnyNotPalindrome( s : String) : boolean
  pre: true
  post: true
  activity: (     var unique : Set(String) ; unique := Set{} ;
         var i : int ; i := 0 ; while i < s->size() do (     unique := unique->including(s->at(i+1)) ;  ;     i := i + 1 ) ; 
     if (unique->size() > 1) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "aaaaab" ;
     if (isAnyNotPalindrome(s)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFg {
  static int MAX=10000 ;
  static int[] prodDig=new int[MAX];
  static int getDigitProduct(int x){
    if(x<10)return x ;
    if(prodDig[x]!=0)return prodDig[x];
    int prod=(x % 10)*getDigitProduct(x/10);
    return(prodDig[x]=prod);
  }
  static void findSeed(int n){
    List<Integer>res=new ArrayList<Integer>();
    for(int i=1 ; i<=n/2 ; i++)if(i*getDigitProduct(i)==n)res.add(i);
    if(res.size()==0){
      System.out.println("NO seed exists");
      return ;
    }
    for(int i=0 ; i<res.size(); i++)System.out.print(res.get(i)+" ");
  }
  public static void main(String[] args){
    int n=138 ;
    findSeed(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFg {
  static   attribute MAX : int := 10000;
  static   attribute prodDig : Sequence(int) := Integer.subrange(1,MAX)->collect(0);
  static   operation getDigitProduct( x : int) : int
  pre: true
  post: true
  activity: (     if (x < 10) then     return x else skip ; 
     if (prodDig[x+1] /= 0) then     return prodDig[x+1] else skip ; 
     var prod : int ; prod := (x mod 10) * getDigitProduct(x / 10) ;
     return (prodDig[x+1]) );
  static   operation findSeed( n : int) : void
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Sequence{} ;
         var i : int ; i := 1 ; while i <= n / 2 do (     if (i * getDigitProduct(i) = n) then     res := res->including(i) ; else skip ;  ;     i := i + 1 ) ; 
     if (res->size() = 0) then (     OclFile["System.out"].println("NO seed exists") ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < res->size() do (     OclFile["System.out"].print(res->at(i+1) + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 138 ;
     execute findSeed(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Queue ;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str[]=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int k=Integer.parseInt(str[1]);
    int x[]=new int[n];
    str=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      x[i]=Integer.parseInt(str[i]);
    }
    int ans=Integer.MAX_VALUE ;
    for(int i=0 ; i+k-1<n ; i++){
      int left=x[i];
      int right=x[i+k-1];
      ans=Math.min(ans,Math.min(Math.abs(left),Math.abs(right))+right-left);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var k : int ; k := (str[1+1])->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    str := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := (str[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i + k - 1 < n do ( (     var left : int ; left := x[i+1] ;
     var right : int ; right := x[i + k - 1+1] ;
     ans := Set{ans, Set{if left < 0 then -(left) else left endif, if right < 0 then -(right) else right endif}->min() + right - left}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.geom.Point2D ;
import java.awt.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] $){
    Scanner sc=new Scanner(in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] x=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=sc.nextInt();
    }
    long ans=1000000000 ;
    for(int i=0 ; i<=n-k ; i++){
      ans=min(min(x[i+k-1]-x[i]+abs(x[i]),x[k-1+i]-x[i]+abs(x[k-1+i])),ans);
    }
    out.println(ans);
  }
  static long power(long x,int n){
    long mod=1000000007 ;
    long ans=1 ;
    while(n>0){
      if((n & 1)==1){
        ans=(ans*x)% mod ;
      }
      x=(x*x)% mod ;
      n>>=1 ;
    }
    return ans ;
  }
  static int gcd(int a,int b){
    int temp ;
    while((temp=a % b)!=0){
      a=b ;
      b=temp ;
    }
    return b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 1000000000 ;
        var i : int ; i := 0 ; while i <= n - k do ( (     ans := Set{Set{x[i + k - 1+1] - x[i+1] + abs(x[i+1]), x[k - 1 + i+1] - x[i+1] + abs(x[k - 1 + i+1])}->min(), ans}->min() )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 );
  static   operation power( x : long, n : int) : long
  pre: true
  post: true
  activity: (     var mod : long ; mod := 1000000007 ;
     var ans : long ; ans := 1 ;
     while (n > 0) do (     if ((MathLib.bitwiseAnd(n,1)) = 1) then (     ans := (ans * x) mod mod ) else skip ; 
     x := (x * x) mod mod ; 
     n := n/(2->pow(1)) ) ; 
     return ans );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var temp : int ;
         temp := a mod b ;
    while ((temp) /= 0) do (    skip ; (     a := b ; 
     b := temp ) ;     temp := a mod b ;
 ) ;  
     return b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public final class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    List<Integer>pos=new ArrayList<>();
    List<Integer>neg=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      int x=in.nextInt();
      if(x>=0)pos.add(x);
      else neg.add(0,Math.abs(x));
    }
    int min=Integer.MAX_VALUE ;
    if(pos.size()>=k)min=Math.min(min,pos.get(k-1));
    if(neg.size()>=k)min=Math.min(min,neg.get(k-1));
    for(int i=0 ; i<pos.size()&& i<k ; i++){
      int left=k-i-1 ;
      if(neg.size()>=left && left>0){
        int a=pos.get(i);
        int b=neg.get(left-1);
        min=Math.min(min,Math.min(2*a+b,2*b+a));
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var pos : Sequence(int) ; pos := Sequence{} ;
    var neg : Sequence(int) ; neg := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     if (x >= 0) then     pos := pos->including(x) ; else     neg := neg.insertAt(0+1,if x < 0 then -(x) else x endif) ; )  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
    if (pos->size() >= k) then     min := Set{min, pos->at(k - 1+1)}->min() ; else skip ; 
    if (neg->size() >= k) then     min := Set{min, neg->at(k - 1+1)}->min() ; else skip ; 
        var i : int ; i := 0 ; while i < pos->size() & i < k do ( (     var left : int ; left := k - i - 1 ;
     if (neg->size() >= left & left > 0) then (     var a : int ; a := pos->at(i+1) ;
     var b : int ; b := neg->at(left - 1+1) ;
     min := Set{min, Set{2 * a + b, 2 * b + a}->min()}->min() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    int S[]=new int[N];
    for(int i=0 ; i<N ; i++)S[i]=sc.nextInt();
    int temp=0 ;
    int ans=1000000000 ;
    if(K==1){
      for(int i=0 ; i<N ; i++){
        temp=S[i];
        ans=Math.min(Math.abs(temp),ans);
      }
      System.out.println(ans);
    }
    else if(N-K!=0){
      for(int i=0 ; i<=N-K ; i++){
        int min=S[i];
        int max=S[i+K-1];
        if(min<0 && max>0)temp=Math.min(2*(-min)+max,(-min)+2*max);
        else temp=Math.max(Math.abs(min),Math.abs(max));
        ans=Math.min(ans,temp);
      }
      System.out.println(ans);
    }
    else {
      int min=S[0];
      int max=S[N-1];
      if(min<0 && max>0)System.out.println(Math.min(2*(-min)+max,(-min)+2*max));
      else System.out.println(Math.max(Math.abs(min),Math.abs(max)));
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var S : Sequence(int) ; S := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     S[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var temp : int ; temp := 0 ;
    var ans : int ; ans := 1000000000 ;
    if (K = 1) then (         var i : int ; i := 0 ; while i < N do ( (     temp := S[i+1] ; 
     ans := Set{if temp < 0 then -(temp) else temp endif, ans}->min() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) ) else     if (N - K /= 0) then (         var i : int ; i := 0 ; while i <= N - K do ( (     var min : int ; min := S[i+1] ;
     var max : int ; max := S[i + K - 1+1] ;
     if (min < 0 & max > 0) then     temp := Set{2 * (-min) + max, (-min) + 2 * max}->min() else     temp := Set{if min < 0 then -(min) else min endif, if max < 0 then -(max) else max endif}->max() ; ;  
     ans := Set{ans, temp}->min() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) ) else (     var min : int ; min := S[0+1] ;
     var max : int ; max := S[N - 1+1] ;
     if (min < 0 & max > 0) then     OclFile["System.out"].println(Set{2 * (-min) + max, (-min) + 2 * max}->min()) ; else     OclFile["System.out"].println(Set{if min < 0 then -(min) else min endif, if max < 0 then -(max) else max endif}->max()) ; ) ;  ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] x=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=sc.nextInt();
    }
    int ls=-1 ;
    int rs=n ;
    boolean ez=false ;
    for(int i=0 ; i<n ; i++){
      if(x[i]==0)ez=true ;
      if(x[i]<0)ls=i ;
    }
    for(int i=n-1 ; i>=0 ; i--){
      if(x[i]>0)rs=i ;
    }
    int nl=ls+1 ;
    int nr=n-rs ;
    if(ez){
      k--;
    }
    int ans=-1 ;
    for(int i=0 ; i<=nl ; i++){
      int toL=0 ;
      if(i!=0){
        toL=x[ls-i+1];
      }
      int needR=k-i ;
      if(needR>nr)continue ;
      int toR=0 ;
      if(needR!=0){
        toR=x[rs+needR-1];
      }
      int a1=Math.abs(2*toL)+Math.abs(toR);
      int a2=Math.abs(2*toR)+Math.abs(toL);
      if(ans==-1){
        ans=Math.min(a1,a2);
      }
      else {
        ans=Math.min(Math.min(a1,a2),ans);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ls : int ; ls := -1 ;
    var rs : int ; rs := n ;
    var ez : boolean ; ez := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (x[i+1] = 0) then     ez := true ; else skip ; 
     if (x[i+1] < 0) then     ls := i ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (x[i+1] > 0) then     rs := i ; else skip )  ;     i := i - 1 ) ; 
    var nl : int ; nl := ls + 1 ;
    var nr : int ; nr := n - rs ;
    if (ez) then (     k := k - 1 ) else skip ; 
    var ans : int ; ans := -1 ;
        var i : int ; i := 0 ; while i <= nl do ( (     var toL : int ; toL := 0 ;
     if (i /= 0) then (     toL := x[ls - i + 1+1] ) else skip ; 
    var needR : int ; needR := k - i ;
    if (needR > nr) then     continue else skip ; 
    var toR : int ; toR := 0 ;
    if (needR /= 0) then (     toR := x[rs + needR - 1+1] ) else skip ; 
    var a1 : int ; a1 := if 2 * toL < 0 then -(2 * toL) else 2 * toL endif + if toR < 0 then -(toR) else toR endif ;
    var a2 : int ; a2 := if 2 * toR < 0 then -(2 * toR) else 2 * toR endif + if toL < 0 then -(toL) else toL endif ;
    if (ans = -1) then (     ans := Set{a1, a2}->min() ) else (     ans := Set{Set{a1, a2}->min(), ans}->min() ) ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double diff(double n,double mid){
    if(n>(mid*mid*mid))return(n-(mid*mid*mid));
    else return((mid*mid*mid)-n);
  }
  static double cubicRoot(double n){
    double start=0,end=n ;
    double e=0.0000001 ;
    while(true){
      double mid=(start+end)/2 ;
      double error=diff(n,mid);
      if(error<=e)return mid ;
      if((mid*mid*mid)>n)end=mid ;
      else start=mid ;
    }
  }
  public static void main(String[] args){
    double n=3 ;
    System.out.println("Cube root of "+n+" is "+cubicRoot(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation diff( n : double, mid : double) : double
  pre: true
  post: true
  activity: (     if (n > (mid * mid * mid)) then     return (n - (mid * mid * mid)) else     return ((mid * mid * mid) - n) );
  static   operation cubicRoot( n : double) : double
  pre: true
  post: true
  activity: (     var start : double ; start := 0 ;
    var end : double ; end := n ;
     var e : double ; e := 0.0000001 ;
     while (true) do (     var mid : double ; mid := (start + end) / 2 ;
     var error : double ; error := diff(n, mid) ;
     if (error <= e) then     return mid else skip ; 
     if ((mid * mid * mid) > n) then     end := mid ; else     start := mid ; ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 3 ;
     OclFile["System.out"].println("Cube root of " + n + " is " + cubicRoot(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int a[]=new int[105];
    int max=0 ;
    for(int i=0 ; i<=n-1 ; i++){
      a[i]=sc.nextInt();
      if(i>0 && a[i]>a[max]){
        max=i ;
      }
    }
    int ansmax=a[max]+m ;
    for(int i=0 ; i<=m-1 ; i++){
      int min=0 ;
      for(int j=0 ; j<=n-1 ; j++){
        if(j>0 && a[j]<a[min]){
          min=j ;
        }
      }
      a[min]++;
    }
    max=0 ;
    for(int i=1 ; i<=n-1 ; i++){
      if(a[i]>a[max]){
        max=i ;
      }
    }
    int ansmin=a[max];
    System.out.print(ansmin+" "+ansmax);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,105)->collect(0) ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i <= n - 1 do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (i > 0 & a[i+1] > a[max+1]) then (     max := i ) else skip )  ;     i := i + 1 ) ; 
    var ansmax : int ; ansmax := a[max+1] + m ;
        var i : int ; i := 0 ; while i <= m - 1 do ( (     var min : int ; min := 0 ;
         var j : int ; j := 0 ; while j <= n - 1 do ( (     if (j > 0 & a[j+1] < a[min+1]) then (     min := j ) else skip )  ;     j := j + 1 ) ; 
     a[min+1] := a[min+1] + 1 )  ;     i := i + 1 ) ; 
    max := 0 ; 
        var i : int ; i := 1 ; while i <= n - 1 do ( (     if (a[i+1] > a[max+1]) then (     max := i ) else skip )  ;     i := i + 1 ) ; 
    var ansmin : int ; ansmin := a[max+1] ;
    OclFile["System.out"].print(ansmin + " " + ansmax) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  static HashSet<Integer>set ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int m=in.nextInt();
    int[] a=new int[n];
    Arrays.setAll(a,i->in.nextInt());
    Arrays.sort(a);
    pw.println(solve(a,n,m)+" "+(a[n-1]+m));
    pw.close();
  }
  static int solve(int[] a,int n,int m){
    int l=a[n-1],r=10_0000 ;
    int ans=0 ;
    while(l<=r){
      int mid=(l+r)/2 ;
      if(possible(a,mid,m)){
        r=mid-1 ;
        ans=mid ;
      }
      else l=mid+1 ;
    }
    return ans ;
  }
  static boolean possible(int[] a,int k,int need){
    int total=0 ;
    for(int i=0 ; i<a.length ; i++){
      total+=(k-a[i]);
    }
    if(total>=need)return true ;
    else return false ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute set : Set(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
setAll(a, lambda i : OclAny in in.getCurrent()->toInteger()) ; 
    a := a->sort() ; 
    skip ; 
    skip ; 
 );
  static   operation solve( a : Sequence(int), n : int, m : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := a[n - 1+1] ;
    var r : int ; r := 10_0000 ;
     var ans : int ; ans := 0 ;
     while (l <= r) do (     var mid : int ; mid := (l + r) / 2 ;
     if (possible(a, mid, m)) then (     r := mid - 1 ; 
     ans := mid ) else     l := mid + 1 ; ) ; 
     return ans );
  static   operation possible( a : Sequence(int), k : int, need : int) : boolean
  pre: true
  post: true
  activity: (     var total : int ; total := 0 ;
         var i : int ; i := 0 ; while i < a->size() do ( (     total := total+((k - a[i+1])) )  ;     i := i + 1 ) ; 
     if (total >= need) then     return true else     return false );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    String strIn=null ;
    while((strIn=parseStdin())!=null){
      System.out.println(decode(strIn));
    }
  }
  private static String decode(String plain){
    String decode="" ;
    int len=plain.length();
    for(int i=0 ; i<len ; i++){
      char c=plain.charAt(i);
      if(c=='@'){
        c=plain.charAt(i+2);
        for(int j=plain.charAt(i+1)-'0' ; j>0 ; j--){
          decode+=c ;
        }
        i+=2 ;
      }
      else {
        decode+=c ;
      }
    }
    return decode ;
  }
  private static String parseStdin(){
    String strNum=null ;
    try {
      String line=br.readLine();
      if(line!=null){
        if(! line.isEmpty()){
          strNum=line ;
        }
      }
    }
    catch(IOException e){
    }
    return strNum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var strIn : String ; strIn := null ;
         strIn := parseStdin() ;
    while ((strIn) /= null) do (    skip ; (     OclFile["System.out"].println(decode(strIn)) ) ;     strIn := parseStdin() ;
 ) );
  static   operation decode( plain : String) : String
  pre: true
  post: true
  activity: (     var decode : String ; decode := "" ;
     var len : int ; len := plain->size() ;
         var i : int ; i := 0 ; while i < len do ( (     var c : String ; c := plain->at(i+1) ;
     if (c = '@') then (     c := plain->at(i + 2+1) ; 
         var j : int ; j := plain->at(i + 1+1) - ('0')->char2byte() ; while j > 0 do ( (     decode := decode+(c) )  ;     j := j - 1 ) ; 
     i := i+(2) ) else (     decode := decode+(c) ) )  ;     i := i + 1 ) ; 
     return decode );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var strNum : String ; strNum := null ;
     try (     var line : String ; line := br.readLine() ;
     if (line /= null) then (     if (not(line->isEmpty())) then (     strNum := line ) else skip ) else skip )   catch (e : IOException) do skip
     return strNum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class C {
  static Scanner sc=new Scanner(System.in);
  public static void solve(){
    int n ;
    n=sc.nextInt();
    long m=sc.nextLong();
    long[] A=new long[n+2];
    long MaxA=Long.MIN_VALUE ;
    long S=0 ;
    for(int i=0 ; i<n ; i++){
      A[i]=sc.nextLong();
      MaxA=Math.max(MaxA,A[i]);
      S+=A[i];
    }
    long KMax=MaxA+m ;
    long KMin ;
    long k=(m+S)% n ;
    if(k % n==0){
      KMin=(m+S)/n ;
      if(KMin<MaxA){
        KMin=MaxA ;
      }
    }
    else {
      KMin=(m+S)/n+1 ;
      if(KMin<MaxA){
        KMin=MaxA ;
      }
    }
    System.out.println(KMin+" "+KMax);
  }
  public static void main(String[] args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ;
     n := sc.getCurrent()->toInteger() ; 
    var m : long ; m := sc.getCurrent()->toLong() ;
    var A : Sequence(long) ; A := Integer.subrange(1,n + 2)->collect(0) ;
    var MaxA : long ; MaxA := "-9223372036854775808"->toLong() ;
    var S : long ; S := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := sc.getCurrent()->toLong() ; 
     MaxA := Set{MaxA, A[i+1]}->max() ; 
     S := S+(A[i+1]) )  ;     i := i + 1 ) ; 
    var KMax : long ; KMax := MaxA + m ;
    var KMin : long ;
    var k : long ; k := (m + S) mod n ;
    if (k mod n = 0) then (     KMin := (m + S) / n ; 
     if (KMin < MaxA) then (     KMin := MaxA ) else skip ) else (     KMin := (m + S) / n + 1 ; 
     if (KMin < MaxA) then (     KMin := MaxA ) else skip ) ;  
    OclFile["System.out"].println(KMin + " " + KMax) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Test {
  public static int findMajority(int arr[],int n){
    return arr[n/2];
  }
  public static void main(String args[]){
    int arr[]={
      1,2,2,3 };
      int n=arr.length ;
      System.out.println(findMajority(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation findMajority( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     return arr[n / 2+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,2,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMajority(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int inv(int a,int m){
    int m0=m,t,q ;
    int x0=0,x1=1 ;
    if(m==1)return 0 ;
    while(a>1){
      q=a/m ;
      t=m ;
      m=a % m ;
      a=t ;
      t=x0 ;
      x0=x1-q*x0 ;
      x1=t ;
    }
    if(x1<0)x1+=m0 ;
    return x1 ;
  }
  static int findMinX(int num[],int rem[],int k){
    int prod=1 ;
    for(int i=0 ; i<k ; i++)prod*=num[i];
    int result=0 ;
    for(int i=0 ; i<k ; i++){
      int pp=prod/num[i];
      result+=rem[i]*inv(pp,num[i])*pp ;
    }
    return result % prod ;
  }
  public static void main(String args[]){
    int num[]={
      3,4,5 };
      int rem[]={
        2,3,1 };
        int k=num.length ;
        System.out.println("x is "+findMinX(num,rem,k));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation inv( a : int, m : int) : int
  pre: true
  post: true
  activity: (     var m0 : int ; m0 := m ;
    var t : int ;
    var q : int ;
     var x0 : int ; x0 := 0 ;
    var x1 : int ; x1 := 1 ;
    if (m = 1) then     return 0 else skip ; 
    while (a > 1) do (     q := a / m ; 
     t := m ; 
    m := a mod m ; 
    a := t ; 
    t := x0 ; 
    x0 := x1 - q * x0 ; 
    x1 := t ; 
 ) ; 
    if (x1 < 0) then     x1 := x1+(m0) ; else skip ; 
    return x1 
 );
  static   operation findMinX( num : Sequence(int), rem : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     var prod : int ; prod := 1 ;
         var i : int ; i := 0 ; while i < k do (     prod := prod*(num[i+1]) ;  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     var pp : int ; pp := prod / num[i+1] ;
     result := result+(rem[i+1] * inv(pp, num[i+1]) * pp) )  ;     i := i + 1 ) ; 
    return result mod prod 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : Sequence(int) ; num := Sequence{3,4,5} ;
     var rem : Sequence(int) ; rem := Sequence{2,3,1} ;
     var k : int ; k := num->size() ;
     OclFile["System.out"].println("x is " + findMinX(num, rem, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  boolean compare(int a,int b){
    return a>b ;
  }
  static int findMaxOR(int[] arr,int n){
    int temp ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        if(arr[i]<arr[j]){
          temp=arr[i];
          arr[i]=arr[j];
          arr[j]=temp ;
        }
      }
    }
    int maxOR=arr[0];
    int count=1 ;
    for(int i=1 ; i<n ; i++){
      if((maxOR | arr[i])>maxOR){
        maxOR=maxOR | arr[i];
        count++;
      }
    }
    return count ;
  }
  public static void main(String arrgs[]){
    int[] arr={
      5,1,3,4,2 };
      int n=arr.length ;
      System.out.println(findMaxOR(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution {
   operation compare( a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     return a > b );
  static   operation findMaxOR( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var temp : int ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (arr[i+1] < arr[j+1]) then (     temp := arr[i+1] ; 
     arr[i+1] := arr[j+1] ; 
     arr[j+1] := temp ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var maxOR : int ; maxOR := arr[0+1] ;
    var count : int ; count := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     if ((MathLib.bitwiseOr(maxOR,arr[i+1])) > maxOR) then (     maxOR := MathLib.bitwiseOr(maxOR,arr[i+1]) ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( arrgs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,1,3,4,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMaxOR(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int sumOfSeries(int n){
    int sum=0 ;
    for(int i=1 ; i<=n ; i++)sum=sum+(2*i-1)*(2*i-1);
    return sum ;
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(sumOfSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfSeries( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do (     sum := sum + (2 * i - 1) * (2 * i - 1) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(sumOfSeries(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static long fourthPowerSum(int n){
    long sum=0 ;
    for(int i=1 ; i<=n ; i++)sum=sum+(i*i*i*i);
    return sum ;
  }
  public static void main(String[] args){
    int n=6 ;
    System.out.println(fourthPowerSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fourthPowerSum( n : int) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do (     sum := sum + (i * i * i * i) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(fourthPowerSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int squareSum(int n){
    int sum=0 ;
    for(int i=1 ; i<=n ; i++)sum+=(2*i)*(2*i);
    return sum ;
  }
  public static void main(String args[])throws IOException {
    System.out.println(squareSum(8));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation squareSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do (     sum := sum+((2 * i) * (2 * i)) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(squareSum(8)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static float AvgofSquareN(int n){
    float sum=0 ;
    for(int i=1 ; i<=n ; i++)sum+=(i*i);
    return sum/n ;
  }
  static public void main(String[] args){
    int n=2 ;
    System.out.println(AvgofSquareN(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation AvgofSquareN( n : int) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do (     sum := sum+((i * i)) ;  ;     i := i + 1 ) ; 
     return sum / n );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(AvgofSquareN(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long fifthPowerSum(int n){
    long sum=0 ;
    for(int i=1 ; i<=n ; i++)sum=sum+(i*i*i*i*i);
    return sum ;
  }
  public static void main(String args[]){
    int n=6 ;
    System.out.println(fifthPowerSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fifthPowerSum( n : int) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do (     sum := sum + (i * i * i * i * i) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(fifthPowerSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int squaresum(int n){
    int sum=0 ;
    for(int i=1 ; i<=n ; i++)sum+=(i*i);
    return sum ;
  }
  public static void main(String args[])throws IOException {
    int n=4 ;
    System.out.println(squaresum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation squaresum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do (     sum := sum+((i * i)) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(squaresum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minSwaps(String s1,String s2){
    int c0=0,c1=0 ;
    for(int i=0 ; i<s1.length(); i++){
      if(s1.charAt(i)=='0' && s2.charAt(i)=='1'){
        c0++;
      }
      else if(s1.charAt(i)=='1' && s2.charAt(i)=='0'){
        c1++;
      }
    }
    int ans=c0/2+c1/2 ;
    if(c0 % 2==0 && c1 % 2==0){
      return ans ;
    }
    else if((c0+c1)% 2==0){
      return ans+2 ;
    }
    else {
      return-1 ;
    }
  }
  public static void main(String[] args){
    String s1="0011",s2="1111" ;
    int ans=minSwaps(s1,s2);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minSwaps( s1 : String, s2 : String) : int
  pre: true
  post: true
  activity: (     var c0 : int ; c0 := 0 ;
    var c1 : int ; c1 := 0 ;
         var i : int ; i := 0 ; while i < s1->size() do ( (     if (s1->at(i+1) = '0' & s2->at(i+1) = '1') then (     c0 := c0 + 1 ) else     if (s1->at(i+1) = '1' & s2->at(i+1) = '0') then (     c1 := c1 + 1 ) else skip ; )  ;     i := i + 1 ) ; 
     var ans : int ; ans := c0 / 2 + c1 / 2 ;
     if (c0 mod 2 = 0 & c1 mod 2 = 0) then (     return ans ) else     if ((c0 + c1) mod 2 = 0) then (     return ans + 2 ) else (     return -1 ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "0011" ;
    var s2 : String ; s2 := "1111" ;
     var ans : int ; ans := minSwaps(s1, s2) ;
     OclFile["System.out"].println(ans) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int aliquotSum(int n){
    int sum=0 ;
    for(int i=1 ; i<n ; i++)if(n % i==0)sum+=i ;
    return sum ;
  }
  public static void main(String args[])throws IOException {
    int n=12 ;
    System.out.println(aliquotSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation aliquotSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i < n do (     if (n mod i = 0) then     sum := sum+(i) ; else skip ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     OclFile["System.out"].println(aliquotSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findSum(int n){
    int sum=0 ;
    for(int i=1 ; i<=n ; i++)sum+=((i*(i+1)*(2*i+1))/6);
    return sum ;
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(findSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do (     sum := sum+(((i * (i + 1) * (2 * i + 1)) / 6)) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(findSum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigDecimal ;
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Stack ;
public class Solution {
  static int[] nodeColors ;
  static boolean[] visited ;
  static String[][] neighborstring ;
  static List<Integer>[] startIndices ;
  static int[] edgesToPrint ;
  static int mod=998244353 ;
  static int[] parents ;
  static HashSet<Integer>cycleSet ;
  static PriorityQueue<Integer>[] neighborPriority ;
  static int[] minPointsToEnterRoom ;
  static int[] maxPointsToEnterRoom ;
  static int[] pointOfEachRoom ;
  static List<Integer>[] neighbors ;
  static int[][] memo ;
  public static void main(String[] args)throws IOException {
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    int count=Integer.parseInt(bufferedReader.readLine());
    int pos=0 ;
    for(int i=0 ; i<count ; i++){
      String[] s=bufferedReader.readLine().split(" ");
      int no=Integer.parseInt(s[0]);
      if(s[1] .equals("South")){
        pos+=no ;
        if(pos>20000){
          break ;
        }
      }
      else if(s[1] .equals("North")){
        pos-=no ;
        if(pos<0){
          break ;
        }
      }
      else {
        if(pos==0 || pos==20000){
          pos=1 ;
          break ;
        }
      }
    }
    if(pos==0){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute nodeColors : Sequence(int);
  static   attribute visited : Sequence(boolean);
  static   attribute neighborstring : Sequence(Sequence(String));
  static   attribute startIndices : Sequence(Sequence(int));
  static   attribute edgesToPrint : Sequence(int);
  static   attribute mod : int := 998244353;
  static   attribute parents : Sequence(int);
  static   attribute cycleSet : Set(int);
  static   attribute neighborPriority : Sequence(Sequence(int));
  static   attribute minPointsToEnterRoom : Sequence(int);
  static   attribute maxPointsToEnterRoom : Sequence(int);
  static   attribute pointOfEachRoom : Sequence(int);
  static   attribute neighbors : Sequence(Sequence(int));
  static   attribute memo : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var count : int ; count := (bufferedReader.readLine())->toInteger() ;
    var pos : int ; pos := 0 ;
        var i : int ; i := 0 ; while i < count do ( (     var s : Sequence(String) ; s := bufferedReader.readLine()->split(" ") ;
     var no : int ; no := (s[0+1])->toInteger() ;
     if (s[1+1] = "South") then (     pos := pos+(no) ; 
     if (pos > 20000) then (     break ) else skip ) else     if (s[1+1] = "North") then (     pos := pos-(no) ; 
     if (pos < 0) then (     break ) else skip ) else (     if (pos = 0 or pos = 20000) then (     pos := 1 ; 
     break ) else skip ) ;  )  ;     i := i + 1 ) ; 
    if (pos = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int seriesSum(int n){
    int sum=0 ;
    for(int i=1 ; i<=n ; i++)sum+=i*(i+1)/2 ;
    return sum ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(seriesSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation seriesSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do (     sum := sum+(i * (i + 1) / 2) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(seriesSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int seriesSum(int n){
    int sum=0 ;
    for(int i=1 ; i<=n ; i++)sum+=i*(i+1)/2 ;
    return sum ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(seriesSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation seriesSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do (     sum := sum+(i * (i + 1) / 2) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(seriesSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findSum(int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=i*(n-i);
    return 2*sum ;
  }
  static public void main(String[] args){
    int n=3 ;
    System.out.println(findSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+(i * (n - i)) ;  ;     i := i + 1 ) ; 
     return 2 * sum );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(findSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int pentagon_pyramidal(int n){
    int sum=0 ;
    for(int i=1 ; i<=n ; i++){
      int p=(3*i*i-i)/2 ;
      sum=sum+p ;
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(pentagon_pyramidal(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pentagon_pyramidal( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     var p : int ; p := (3 * i * i - i) / 2 ;
     sum := sum + p )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(pentagon_pyramidal(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int solve(int n,int base){
    int sum=0 ;
    while(n>0){
      int remainder=n % base ;
      sum+=remainder ;
      n=n/base ;
    }
    return sum ;
  }
  static void SumsOfDigits(int n){
    int sum=0 ;
    for(int base=2 ; base<=n/2 ; ++base)sum+=solve(n,base);
    System.out.println(sum);
  }
  public static void main(String[] args){
    int n=8 ;
    SumsOfDigits(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( n : int, base : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n > 0) do (     var remainder : int ; remainder := n mod base ;
     sum := sum+(remainder) ; 
     n := n / base ) ; 
     return sum );
  static   operation SumsOfDigits( n : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var base : int ; base := 2 ; while base <= n / 2 do (     sum := sum+(solve(n, base)) ;  ;     base := base + 1 ) ; 
     OclFile["System.out"].println(sum) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     execute SumsOfDigits(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static final int N=10000 ;
  public static void main(String[] args){
    new Main().solve();
  }
  void solve(){
    Scanner sc=new Scanner(System.in);
    ArrayList<Long>p=new ArrayList<Long>();
    for(long i=2 ; p.size()<=N ; ++i){
      boolean f=true ;
      for(int j=0 ; j<p.size(); ++j){
        f &=i % p.get(j)!=0 ;
        if(! f)break ;
      }
      if(f){
        p.add(i);
      }
    }
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int sum=0 ;
      for(int i=0 ; i<n ; ++i){
        sum+=p.get(i);
      }
      System.out.println(sum);
    }
    sc.close();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute N : int := 10000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : Sequence(long) ; p := Sequence{} ;
        var i : long ; i := 2 ; while p->size() <= N do ( (     var f : boolean ; f := true ;
         var j : int ; j := 0 ; while j < p->size() do ( (     f := MathLib.bitwiseAnd(f, i mod p->at(j+1) /= 0) ; 
     if (not(f)) then     break else skip )  ;     j := j + 1 ) ; 
     if (f) then (     p := p->including(i) ) else skip )  ;     i := i + 1 ) ; 
    while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(p->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) ; 
    skip ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      int numOfPrimeNumbers=Integer.parseInt(br.readLine());
      if(numOfPrimeNumbers==0)break ;
      System.out.println(getSumOfPrimeNumbers(numOfPrimeNumbers));
    }
  }
  public static long getSumOfPrimeNumbers(int numOfPrimeNumbers){
    long sum=0 ;
    ArrayList<Long>primeNumber=getPrimeNumbers();
    for(int i=0 ; i<numOfPrimeNumbers ; i++){
      sum+=(long)primeNumber.get(i);
    }
    return sum ;
  }
  private static ArrayList<Long>getPrimeNumbers(){
    ArrayList<Long>primeNumber=new ArrayList<Long>();
    int numPrimeNumbers=0 ;
    long n=1 ;
    while(numPrimeNumbers<10000){
      if(isPrimeNumber(++n)){
        primeNumber.add(Long.valueOf(n));
        numPrimeNumbers++;
      }
    }
    return primeNumber ;
  }
  private static boolean isPrimeNumber(long target){
    if(target==2)return true ;
    if(target % 2==0)return false ;
    for(int i=3 ; i*i<target+1 ; i=i+2){
      if(target % i==0){
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var numOfPrimeNumbers : int ; numOfPrimeNumbers := (br.readLine())->toInteger() ;
     if (numOfPrimeNumbers = 0) then     break else skip ; 
     OclFile["System.out"].println(getSumOfPrimeNumbers(numOfPrimeNumbers)) ) );
  static   operation getSumOfPrimeNumbers( numOfPrimeNumbers : int) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     var primeNumber : Sequence(long) ; primeNumber := getPrimeNumbers() ;
         var i : int ; i := 0 ; while i < numOfPrimeNumbers do ( (     sum := sum+(primeNumber->at(i+1)->oclAsType(long)) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation getPrimeNumbers() : Sequence(long)
  pre: true
  post: true
  activity: (     var primeNumber : Sequence(long) ; primeNumber := Sequence{} ;
     var numPrimeNumbers : int ; numPrimeNumbers := 0 ;
    var n : long ; n := 1 ;
    while (numPrimeNumbers < 10000) do (     if (isPrimeNumber((n + 1))) then (     primeNumber := primeNumber->including((n)->toLong()) ; 
     numPrimeNumbers := numPrimeNumbers + 1 ) else skip ) ; 
    return primeNumber 
 );
  static   operation isPrimeNumber( target : long) : boolean
  pre: true
  post: true
  activity: (     if (target = 2) then     return true else skip ; 
     if (target mod 2 = 0) then     return false else skip ; 
         var i : int ; i := 3 ; while i * i < target + 1 do ( (     if (target mod i = 0) then (     return false ) else skip )  ;     i := i + 2 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    String s=reader.readLine();
    if(s==null)return false ;
    String d="" ;
    for(int i=0 ; i<s.length(); i++){
      char c=s.charAt(i);
      if(c=='@'){
        char r=s.charAt(++i);
        c=s.charAt(++i);
        for(int j=0 ; j<r-'0' ; j++){
          d+=c ;
        }
      }
      else {
        d+=c ;
      }
    }
    System.out.printf("%s\n",d);
    return true ;
  }
  private final static boolean DEBUG=false ;
  public static void main(String[] args)throws IOException {
    if(DEBUG){
      log=System.out ;
      String inputStr="ab@5C1@8050:" ;
      inputStr=inputStr.replace(":","\n");
      reader=new BufferedReader(new StringReader(inputStr));
    }
    else {
      log=new PrintStream(new OutputStream(){
        public void write(int b){
        }
      }
);
      reader=new BufferedReader(new InputStreamReader(System.in));
    }
    for(int i=0 ; ; i++){
      boolean b=new Main().main();
      if(! b)break ;
    }
    reader.close();
  }
  static PrintStream log ;
  static BufferedReader reader ;
  private static int[] readIntArray()throws IOException {
    String s=null ;
    for(; ; ){
      s=reader.readLine();
      log.printf("%s\n",s);
      if(s==null)return null ;
      s=s.trim();
      if(s.length()!=0)break ;
    }
    String[] sp=s.split("[,] ");
    int[] a=new int[sp.length];
    for(int i=0 ; i<sp.length ; i++){
      a[i]=Integer.parseInt(sp[i]);
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var s : String ; s := reader.readLine() ;
     if (s = null) then     return false else skip ; 
    var d : String ; d := "" ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var c : String ; c := s->at(i+1) ;
     if (c = '@') then (     var r : String ; r := s->at((i + 1)+1) ;
     c := s->at((i + 1)+1) ; 
         var j : int ; j := 0 ; while j < (r)->char2byte() - ('0')->char2byte() do ( (     d := d+(c) )  ;     j := j + 1 ) ) else (     d := d+(c) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%s\n", d) ; 
    return true 
 );
  static   attribute DEBUG : boolean := false;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (DEBUG) then (     log := OclFile["System.out"] ; 
     var inputStr : String ; inputStr := "ab@5C1@8050:" ;
     inputStr := inputStr.replace(":", "\n") ; 
     reader := OclFile.newOclFile_Read(StringReader.newStringReader(inputStr)) ) else (     log := OclFile.newOclFile_Write(OclFile()) ; 
     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ) ;  
         var i : int ; i := 0 ; while true do ( (     var b : boolean ; b := Main.newMain().main() ;
     if (not(b)) then     break else skip )  ;     i := i + 1 ) ; 
     reader.close() );
  static   attribute log : OclFile;
  static   attribute reader : OclFile;
  static   operation readIntArray() : Sequence(int)
  pre: true
  post: true
  activity: (     var s : String ; s := null ;
       while true do ( (     s := reader.readLine() ; 
     skip ; 
    if (s = null) then     return null else skip ; 
    s := s->trim() ; 
    if (s->size() /= 0) then     break else skip ; 
 )  ) ; 
    var sp : Sequence(String) ; sp := s->split("[,] ") ;
    var a : Sequence(int) ; a := Integer.subrange(1,sp->size())->collect(0) ;
        var i : int ; i := 0 ; while i < sp->size() do ( (     a[i+1] := (sp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    return a 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static boolean prime[]=new boolean[200000];
  static int[] result=new int[10002];
  static void Do(int k){
    int sum=0 ;
    for(int i=1 ; i<=k ; i++){
      sum+=P(i);
    }
  }
  static int P(int n){
    int cnt=0 ;
    for(int i=0 ; i<prime.length ; i++){
      if(prime[i]){
        cnt++;
        if(cnt==n)return i ;
      }
    }
    return 0 ;
  }
  static void doIt(int n){
    if(n==0)return ;
    result[n]=result[n-1]+P(n);
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    for(int i=0 ; i<prime.length ; i++)prime[i]=true ;
    prime[0]=false ;
    prime[1]=false ;
    for(int s=0 ; s<prime.length ; s++){
      if(prime[s])for(int i=s+s ;
      i<prime.length ;
      i+=s)prime[i]=false ;
    }
    for(int i=1 ; i<result.length ; i++)doIt(i);
    while(in.hasNext()){
      int x=in.nextInt();
      if(x==0)break ;
      System.out.println(result[x]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute prime : boolean := Integer.subrange(1,200000)->collect(false);
  static   attribute result : Sequence(int) := Integer.subrange(1,10002)->collect(0);
  static   operation Do( k : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= k do ( (     sum := sum+(P(i)) )  ;     i := i + 1 ) );
  static   operation P( n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < prime->size() do ( (     if (prime[i+1]) then (     cnt := cnt + 1 ; 
     if (cnt = n) then     return i else skip ) else skip )  ;     i := i + 1 ) ; 
     return 0 );
  static   operation doIt( n : int) : void
  pre: true
  post: true
  activity: (     if (n = 0) then     return else skip ; 
     result[n+1] := result[n - 1+1] + P(n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var i : int ; i := 0 ; while i < prime->size() do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
    prime[0+1] := false ; 
    prime[1+1] := false ; 
        var s : int ; s := 0 ; while s < prime->size() do ( (     if (prime[s+1]) then         var i : int ; i := s + s ; while i < prime->size() do (     prime[i+1] := false ;  ;     i := i+(s) ) ; else skip )  ;     s := s + 1 ) ; 
        var i : int ; i := 1 ; while i < result->size() do (     execute doIt(i) ;  ;     i := i + 1 ) ; 
    while (in.hasNext()) do (     var x : int ; x := in.getCurrent()->toInteger() ;
     if (x = 0) then     break else skip ; 
     OclFile["System.out"].println(result[x+1]) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    boolean[] sieve=new boolean[104729+1];
    for(int p=2 ; p<Math.sqrt(sieve.length); p++){
      if(sieve[p]){
        continue ;
      }
      for(int q=p*2 ; q<sieve.length ; q+=p){
        sieve[q]=true ;
      }
    }
    int[] sums=new int[10001];
    int k=0 ;
    for(int p=2 ; p<sieve.length ; p++){
      if(sieve[p]){
        continue ;
      }
      k++;
      sums[k]=sums[k-1]+p ;
    }
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    while(true){
      int n=Integer.parseInt(reader.readLine());
      if(n==0){
        break ;
      }
      out.println(sums[n]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var sieve : Sequence(boolean) ; sieve := Integer.subrange(1,104729 + 1)->collect(false) ;
         var p : int ; p := 2 ; while p < (sieve->size())->sqrt() do ( (     if (sieve[p+1]) then (     continue ) else skip ; 
         var q : int ; q := p * 2 ; while q < sieve->size() do ( (     sieve[q+1] := true )  ;     q := q+(p) ) )  ;     p := p + 1 ) ; 
    var sums : Sequence(int) ; sums := Integer.subrange(1,10001)->collect(0) ;
    var k : int ; k := 0 ;
        var p : int ; p := 2 ; while p < sieve->size() do ( (     if (sieve[p+1]) then (     continue ) else skip ; 
     k := k + 1 ; 
     sums[k+1] := sums[k - 1+1] + p )  ;     p := p + 1 ) ; 
    var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
    while (true) do (     var n : int ; n := (reader.readLine())->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
     out.println(sums[n+1]) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static boolean[] sieve(int n){
    boolean[] isPrime=new boolean[n];
    Arrays.fill(isPrime,true);
    int lim=(int)Math.sqrt(n);
    for(int i=4 ; i<isPrime.length ; i+=2)isPrime[i]=false ;
    for(int i=3 ; i<=lim ; i+=2){
      for(int j=3 ; i*j<isPrime.length ; j+=2)isPrime[i*j]=false ;
    }
    return isPrime ;
  }
  public static int solve(int n){
    int sum=0 ;
    boolean[] prime=sieve(1000000);
    for(int i=2,cnt=0 ; cnt<n ; i++){
      if(prime[i]){
        sum+=i ;
        cnt++;
      }
    }
    return sum ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      int num=Integer.parseInt(br.readLine());
      if(num==0)break ;
      System.out.println(solve(num));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation sieve( n : int) : Sequence(boolean)
  pre: true
  post: true
  activity: (     var isPrime : Sequence(boolean) ; isPrime := Integer.subrange(1,n)->collect(false) ;
     isPrime := isPrime->collect(true) ; 
    var lim : int ; lim := (n)->sqrt()->oclAsType(int) ;
        var i : int ; i := 4 ; while i < isPrime->size() do (     isPrime[i+1] := false ;  ;     i := i+(2) ) ; 
        var i : int ; i := 3 ; while i <= lim do ( (         var j : int ; j := 3 ; while i * j < isPrime->size() do (     isPrime[i * j+1] := false ;  ;     j := j+(2) ) )  ;     i := i+(2) ) ; 
    return isPrime 
 );
  static   operation solve( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var prime : Sequence(boolean) ; prime := sieve(1000000) ;
         var i : int ; i := 2 ;
    var cnt : int ; cnt := 0 ; while cnt < n do ( (     if (prime[i+1]) then (     sum := sum+(i) ; 
     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var num : int ; num := (br.readLine())->toInteger() ;
     if (num = 0) then     break else skip ; 
     OclFile["System.out"].println(solve(num)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int N=in.nextInt();
    int pos=0 ;
    boolean ok=true ;
    outer : for(int n=0 ;
    n<N ;
    n++){
      int T=in.nextInt();
      String dir=in.next();
      boolean dirSouth="South".equals(dir);
      boolean dirNorth="North".equals(dir);
      for(int t=0 ; t<T ; t++){
        if((pos==0 && ! dirSouth)||(pos==20000 && ! dirNorth)){
          ok=false ;
          break outer ;
        }
        if(dirSouth){
          pos++;
        }
        else if(dirNorth){
          pos--;
        }
      }
    }
    ok &=(pos==0);
    pw.println(ok ? "YES" : "NO");
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var pos : int ; pos := 0 ;
    var ok : boolean ; ok := true ;
        var n : int ; n := 0 ; while n < N do ( (     var T : int ; T := in.getCurrent()->toInteger() ;
     var dir : String ; dir := in.getCurrent() ;
    var dirSouth : boolean ; dirSouth := "South" = dir ;
    var dirNorth : boolean ; dirNorth := "North" = dir ;
        var t : int ; t := 0 ; while t < T do ( (     if ((pos = 0 & not(dirSouth)) or (pos = 20000 & not(dirNorth))) then (     ok := false ; 
     break ) else skip ; 
     if (dirSouth) then (     pos := pos + 1 ) else     if (dirNorth) then (     pos := pos - 1 ) else skip ; )  ;     t := t + 1 ) ; 
 )  ;     n := n + 1 ) ; 
    ok := MathLib.bitwiseAnd(ok, (pos = 0)) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileOutputStream ;
import java.io.FileReader ;
import java.io.PrintStream ;
import java.util.Hashtable ;
import java.util.Scanner ;
public class Saving {
  public void solve(Scanner in,PrintStream out)throws Exception {
    int numTests=in.nextInt();
    for(int t=1 ; t<=numTests ; t++){
      int numEngines=in.nextInt();
      Hashtable<String,Integer>table=new Hashtable<String,Integer>();
      in.nextLine();
      for(int e=0 ; e<numEngines ; e++){
        table.put(in.nextLine(),e);
      }
      int numQueries=in.nextInt();
      int[] query=new int[numQueries];
      in.nextLine();
      for(int q=0 ; q<numQueries ; q++){
        String a=in.nextLine();
        query[q]=table.get(a);
      }
      int numSwitches=0 ;
      int curEngine=-1 ;
      for(int curQ=0 ; curQ<numQueries ; curQ++){
        if(curEngine!=query[curQ] && curEngine!=-1){
          continue ;
        }
        int bestScore=0 ;
        int bestEngine=0 ;
        for(int e=0 ; e<numEngines ; e++){
          int curBest=0 ;
          for(int q=curQ ; q<numQueries ; q++){
            if(query[q]==e){
              break ;
            }
            curBest++;
          }
          if(curBest>bestScore){
            bestScore=curBest ;
            bestEngine=e ;
          }
        }
        curEngine=bestEngine ;
        numSwitches++;
      }
      numSwitches--;
      if(numSwitches<0){
        numSwitches=0 ;
      }
      out.println("Case #"+t+": "+numSwitches);
    }
  }
  public static void main(String[] args)throws Exception {
    Scanner in=null ;
    PrintStream out=null ;
    in=new Scanner(System.in);
    out=System.out ;
    in=new Scanner(new FileReader("A-large.in"));
    out=new PrintStream(new FileOutputStream("A-large.out"));
    new Saving().solve(in,out);
    out.close();
    System.exit(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Saving {
   operation solve( in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var numTests : int ; numTests := in.nextInt() ;
         var t : int ; t := 1 ; while t <= numTests do ( (     var numEngines : int ; numEngines := in.nextInt() ;
     var table : Map(String,int) ; table := Map{} ;
    in.nextLine() ; 
        var e : int ; e := 0 ; while e < numEngines do ( (     table := table->union(Map{in.nextLine() |-> e}) )  ;     e := e + 1 ) ; 
    var numQueries : int ; numQueries := in.nextInt() ;
    var query : Sequence(int) ; query := Integer.subrange(1,numQueries)->collect(0) ;
    in.nextLine() ; 
        var q : int ; q := 0 ; while q < numQueries do ( (     var a : String ; a := in.nextLine() ;
     query[q+1] := table->at(a) )  ;     q := q + 1 ) ; 
    var numSwitches : int ; numSwitches := 0 ;
    var curEngine : int ; curEngine := -1 ;
        var curQ : int ; curQ := 0 ; while curQ < numQueries do ( (     if (curEngine /= query[curQ+1] & curEngine /= -1) then (     continue ) else skip ; 
     var bestScore : int ; bestScore := 0 ;
    var bestEngine : int ; bestEngine := 0 ;
        var e : int ; e := 0 ; while e < numEngines do ( (     var curBest : int ; curBest := 0 ;
         var q : int ; q := curQ ; while q < numQueries do ( (     if (query[q+1] = e) then (     break ) else skip ; 
     curBest := curBest + 1 )  ;     q := q + 1 ) ; 
     if (curBest > bestScore) then (     bestScore := curBest ; 
     bestEngine := e ) else skip )  ;     e := e + 1 ) ; 
    curEngine := bestEngine ; 
    numSwitches := numSwitches + 1 ; 
 )  ;     curQ := curQ + 1 ) ; 
    numSwitches := numSwitches - 1 ; 
    if (numSwitches < 0) then (     numSwitches := 0 ) else skip ; 
    out.println("Case #" + t + ": " + numSwitches) ; 
 )  ;     t := t + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := null ;
     var out : OclFile ; out := null ;
    in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
    out := OclFile["System.out"] ; 
    in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("A-large.in"))) ; 
    out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("A-large.out"))) ; 
    Saving.newSaving().solve(in, out) ; 
    skip ; 
OclProcess.exit(0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package library ;
import java.util.*;
public class Translation<T>{
  Hashtable<T,Integer>a ;
  Hashtable<Integer,T>b ;
  int next ;
  public Translation(){
    a=new Hashtable<T,Integer>();
    b=new Hashtable<Integer,T>();
    next=0 ;
  }
  public int add(T item){
    if(a.containsKey(item)){
      return a.get(item);
    }
    a.put(item,next);
    b.put(next,item);
    next++;
    return next-1 ;
  }
  public int get(T item){
    if(a.containsKey(item)){
      return a.get(item);
    }
    return-1 ;
  }
  public T get(int index){
    if(b.containsKey(index)){
      return b.get(index);
    }
    return null ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Translation<T> {
   attribute a : Map(T,int);
   attribute b : Map(int,T);
   attribute next : int;
   static operation newTranslation() : Translation
  pre: true
  post: true
  activity:
  ( var self : Translation ;
    self := createTranslation();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     a := Map{} ; 
     b := Map{} ; 
     next := 0 );
   operation add( item : T) : int
  pre: true
  post: true
  activity: (     if (a->keys()->includes(item)) then (     return a->at(item) ) else skip ; 
     a := a->union(Map{item |-> next}) ; 
    b := b->union(Map{next |-> item}) ; 
    next := next + 1 ; 
    return next - 1 
 );
   operation get( item : T) : int
  pre: true
  post: true
  activity: (     if (a->keys()->includes(item)) then (     return a->at(item) ) else skip ; 
     return -1 );
   operation get( index : int) : T
  pre: true
  post: true
  activity: (     if (b->keys()->includes(index)) then (     return b->at(index) ) else skip ; 
     return null );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    new A().run();
  }
  int INF=1<<29 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int t=1 ; t<=n ; t++){
      int m=sc.nextInt();
      sc.nextLine();
      String[] ss=new String[m];
      for(int i=0 ; i<m ; i++)ss[i]=sc.nextLine();
      int q=sc.nextInt();
      sc.nextLine();
      String[] ts=new String[q];
      for(int i=0 ; i<q ; i++)ts[i]=sc.nextLine();
      int[] dp=new int[m];
      for(String s : ts){
        int min=minAll(dp);
        for(int i=0 ; i<m ; i++){
          if(ss[i] .equals(s))dp[i]=INF ;
          else dp[i]=min(dp[i],min+1);
        }
      }
      System.out.printf("Case #%d: %d%n",t,minAll(dp));
    }
  }
  int minAll(int...is){
    int res=is[0];
    for(int i=1 ; i<is.length ; i++){
      if(res>is[i])res=is[i];
    }
    return res ;
  }
  void debug(Object...os){
    System.err.println(deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     A.newA().run() );
   attribute INF : int := (1*(2->pow(29)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var t : int ; t := 1 ; while t <= n do ( (     var m : int ; m := sc.getCurrent()->toInteger() ;
     skip ; 
    var ss : Sequence(String) ; ss := Integer.subrange(1,m)->collect(null) ;
        var i : int ; i := 0 ; while i < m do (     ss[i+1] := sc.nextLine() ;  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
    skip ; 
    var ts : Sequence(String) ; ts := Integer.subrange(1,q)->collect(null) ;
        var i : int ; i := 0 ; while i < q do (     ts[i+1] := sc.nextLine() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,m)->collect(0) ;
    for (s : ts) do ( (     var min : int ; min := minAll(dp) ;
         var i : int ; i := 0 ; while i < m do ( (     if (ss[i+1] = s) then     dp[i+1] := INF ; else     dp[i+1] := Set{dp[i+1], min + 1}->min() ; )  ;     i := i + 1 ) )  ) ; 
    OclFile["System.out"].printf("Case #%d: %d%n", t, minAll(dp)) ; 
 )  ;     t := t + 1 ) );
   operation minAll( is : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var res : int ; res := is[0+1] ;
         var i : int ; i := 1 ; while i < is->size() do ( (     if (res > is[i+1]) then     res := is[i+1] ; else skip )  ;     i := i + 1 ) ; 
     return res );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package emm.cj08 ;
import java.io.*;
import java.util.*;
public class Search {
  private static final File IN=new File("/home/eric/cj/search-in.txt"),OUT=new File("/home/eric/cj/search-out.txt");
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new FileReader(IN));
    PrintStream ps=new PrintStream(OUT);
    int trials=Integer.parseInt(br.readLine());
    for(int trial=0 ; trial<trials ; trial++){
      HashMap<String,Integer>map=new HashMap<String,Integer>();
      int engines=Integer.parseInt(br.readLine());
      for(int engine=0 ; engine<engines ; engine++)map.put(br.readLine(),engine);
      int availCnt=engines ;
      boolean[] avail=getAvail(engines,-1);
      int changes=0 ;
      int queries=Integer.parseInt(br.readLine());
      for(int query=0 ; query<queries ; query++){
        int pos=map.get(br.readLine());
        if(avail[pos]){
          avail[pos]=false ;
          availCnt--;
          if(availCnt<=0){
            availCnt=engines-1 ;
            avail=getAvail(engines,pos);
            changes++;
          }
        }
      }
      ps.println("Case #"+(trial+1)+": "+changes);
    }
    br.close();
    ps.close();
  }
  private static boolean[] getAvail(int engines,int cur){
    boolean[] result=new boolean[engines];
    for(int i=0 ; i<engines ; i++)result[i]=i!=cur ;
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Search {
  static    attribute IN : OclFile := OclFile("/home/eric/cj/search-in.txt");
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(IN)) ;
     var ps : OclFile ; ps := OclFile.newOclFile_Write(OUT) ;
    var trials : int ; trials := (br.readLine())->toInteger() ;
        var trial : int ; trial := 0 ; while trial < trials do ( (     var map : Map(String,int) ; map := Map{} ;
     var engines : int ; engines := (br.readLine())->toInteger() ;
        var engine : int ; engine := 0 ; while engine < engines do (     map := map->union(Map{br.readLine() |-> engine}) ;  ;     engine := engine + 1 ) ; 
    var availCnt : int ; availCnt := engines ;
    var avail : Sequence(boolean) ; avail := getAvail(engines, -1) ;
    var changes : int ; changes := 0 ;
    var queries : int ; queries := (br.readLine())->toInteger() ;
        var query : int ; query := 0 ; while query < queries do ( (     var pos : int ; pos := map->at(br.readLine()) ;
     if (avail[pos+1]) then (     avail[pos+1] := false ; 
     availCnt := availCnt - 1 ; 
     if (availCnt <= 0) then (     availCnt := engines - 1 ; 
     avail := getAvail(engines, pos) ; 
     changes := changes + 1 ) else skip ) else skip )  ;     query := query + 1 ) ; 
    skip ; 
 )  ;     trial := trial + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation getAvail( engines : int, cur : int) : Sequence(boolean)
  pre: true
  post: true
  activity: (     var result : Sequence(boolean) ; result := Integer.subrange(1,engines)->collect(false) ;
         var i : int ; i := 0 ; while i < engines do (     result[i+1] := i /= cur ;  ;     i := i + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Comparator ;
public class CompareUnit implements Comparator {
  public int compare(Object o1,Object o2){
    Unit u1,u2 ;
    u1=(Unit)o1 ;
    u2=(Unit)o2 ;
    if(u1.turnTime<u2.turnTime)return-1 ;
    else if(u1.turnTime==u2.turnTime)return 0 ;
    else return 1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class CompareUnit implements Comparator {
   operation compare( o1 : OclAny, o2 : OclAny) : int
  pre: true
  post: true
  activity: (     var u1 : Unit ;
    var u2 : Unit ;
     u1 := o1->oclAsType(Unit) ; 
     u2 := o2->oclAsType(Unit) ; 
     if (u1.turnTime < u2.turnTime) then     return -1 else     if (u1.turnTime = u2.turnTime) then     return 0 else     return 1 ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static void main(String[] args){
    System.out.println(Integer.bitCount(4));
    System.out.println(Integer.bitCount(15));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(bitCount(4)) ; 
     OclFile["System.out"].println(bitCount(15)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class Gfg {
  static boolean isMajority(int a[],int n){
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++)if(mp.containsKey(a[i]))mp.put(a[i],mp.get(a[i])+1);
    else mp.put(a[i],1);
    for(Map.Entry<Integer,Integer>x : mp.entrySet())if(x.getValue()>=n/2)return true ;
    return false ;
  }
  public static void main(String[] args){
    int a[]={
      2,3,9,2,2 };
      int n=a.length ;
      if(isMajority(a,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Gfg {
  static   operation isMajority( a : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do (     if (mp->keys()->includes(a[i+1])) then     mp := mp->union(Map{a[i+1] |-> mp->at(a[i+1]) + 1}) else     mp := mp->union(Map{a[i+1] |-> 1}) ; ;   ;     i := i + 1 ) ; 
     for (x : mp->asSet()) do (     if (x.getValue() >= n / 2) then     return true else skip ;  ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,3,9,2,2} ;
     var n : int ; n := a->size() ;
     if (isMajority(a, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Optimal_BST2 {
  static int optimalSearchTree(int keys[],int freq[],int n){
    int cost[][]=new int[n+1][n+1];
    for(int i=0 ; i<n ; i++)cost[i][i]=freq[i];
    for(int L=2 ; L<=n ; L++){
      for(int i=0 ; i<=n-L+1 ; i++){
        int j=i+L-1 ;
        cost[i][j]=Integer.MAX_VALUE ;
        for(int r=i ; r<=j ; r++){
          int c=((r>i)? cost[i][r-1] : 0)+((r<j)? cost[r+1][j] : 0)+sum(freq,i,j);
          if(c<cost[i][j])cost[i][j]=c ;
        }
      }
    }
    return cost[0][n-1];
  }
  static int sum(int freq[],int i,int j){
    int s=0 ;
    for(int k=i ; k<=j ; k++){
      if(k>=freq.length)continue ;
      s+=freq[k];
    }
    return s ;
  }
  public static void main(String[] args){
    int keys[]={
      10,12,20 };
      int freq[]={
        34,8,50 };
        int n=keys.length ;
        System.out.println("Cost of Optimal BST is "+optimalSearchTree(keys,freq,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
class Optimal_BST2 {
  static   operation optimalSearchTree( keys : Sequence(int), freq : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var cost : Sequence(Sequence(int)) ; cost := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do (     cost[i+1][i+1] := freq[i+1] ;  ;     i := i + 1 ) ; 
         var L : int ; L := 2 ; while L <= n do ( (         var i : int ; i := 0 ; while i <= n - L + 1 do ( (     var j : int ; j := i + L - 1 ;
     cost[i+1][j+1] := 2147483647 ; 
         var r : int ; r := i ; while r <= j do ( (     var c : int ; c := (if (r > i) then cost[i+1][r - 1+1] else 0 endif) + (if (r < j) then cost[r + 1+1][j+1] else 0 endif) + sum(freq, i, j) ;
     if (c < cost[i+1][j+1]) then     cost[i+1][j+1] := c ; else skip )  ;     r := r + 1 ) )  ;     i := i + 1 ) )  ;     L := L + 1 ) ; 
     return cost[0+1][n - 1+1] );
  static   operation sum( freq : Sequence(int), i : int, j : int) : int
  pre: true
  post: true
  activity: (     var s : int ; s := 0 ;
         var k : int ; k := i ; while k <= j do ( (     if (k >= freq->size()) then     continue else skip ; 
     s := s+(freq[k+1]) )  ;     k := k + 1 ) ; 
     return s );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var keys : Sequence(int) ; keys := Sequence{10,12,20} ;
     var freq : Sequence(int) ; freq := Sequence{34,8,50} ;
     var n : int ; n := keys->size() ;
     OclFile["System.out"].println("Cost of Optimal BST is " + optimalSearchTree(keys, freq, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int get(int x,int y,int z){
    if(x>z)return-1 ;
    int val=z-x ;
    int div=(z-x)/y ;
    int ans=div*y+x ;
    return ans ;
  }
  public static void main(String[] args){
    int x=1,y=5,z=8 ;
    System.out.print(get(x,y,z)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation get( x : int, y : int, z : int) : int
  pre: true
  post: true
  activity: (     if (x > z) then     return -1 else skip ; 
     var val : int ; val := z - x ;
    var div : int ; div := (z - x) / y ;
    var ans : int ; ans := div * y + x ;
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 1 ;
    var y : int ; y := 5 ;
    var z : int ; z := 8 ;
     OclFile["System.out"].print(at(x, y, z+1) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CodeForces {
  public static final int BUFFERSIZE=512000 ;
  private static Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in),BUFFERSIZE));
  private static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out,BUFFERSIZE));
  public static void solve(){
    int n=sc.nextInt();
    HashMap<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      map.put(sc.nextInt(),i);
    }
    int lastLoc=map.get(1);
    long ans=0 ;
    for(int i=1 ; i<=n ; i++){
      int newLoc=map.get(i);
      ans+=Math.abs(lastLoc-newLoc);
      lastLoc=newLoc ;
    }
    out.println(ans);
  }
  public static void main(String args[])throws Exception {
    in.init(System.in);
    solve();
    out.close();
  }
  public static class in {
    static BufferedReader reader ;
    static StringTokenizer tokenizer ;
    static void init(InputStream input){
      reader=new BufferedReader(new InputStreamReader(input),BUFFERSIZE);
      tokenizer=new StringTokenizer("");
    }
    static String next()throws IOException {
      while(! tokenizer.hasMoreTokens())tokenizer=new StringTokenizer(reader.readLine());
      return tokenizer.nextToken();
    }
    static int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    static double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    static long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static    attribute BUFFERSIZE : int := 512000;
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), BUFFERSIZE));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"], BUFFERSIZE));
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     map := map->union(Map{sc.getCurrent()->toInteger() |-> i}) )  ;     i := i + 1 ) ; 
    var lastLoc : int ; lastLoc := map->at(1) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var newLoc : int ; newLoc := map->at(i) ;
     ans := ans+(if lastLoc - newLoc < 0 then -(lastLoc - newLoc) else lastLoc - newLoc endif) ; 
     lastLoc := newLoc )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in.init(OclFile["System.in"]) ; 
     execute solve() ; 
     skip );
  static class in {
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   operation init( input : OclFile) : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(input), BUFFERSIZE) ; 
     tokenizer := OclIterator.newOclIterator_String("") );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ; ; 
     return tokenizer.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int dp[]=new int[200001];
    for(int i=0 ; i<n ; i++){
      dp[s.nextInt()]=i ;
    }
    long ans=0 ;
    for(int i=2 ; i<=n ; i++){
      ans+=Math.abs(dp[i]-dp[i-1]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,200001)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     dp[s.getCurrent()->toInteger()+1] := i )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 2 ; while i <= n do ( (     ans := ans+(if dp[i+1] - dp[i - 1+1] < 0 then -(dp[i+1] - dp[i - 1+1]) else dp[i+1] - dp[i - 1+1] endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int countSubArrays(int arr[],int n,int K){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i ; j<n ; j++){
        int bitwise_or=0 ;
        for(int k=i ; k<=j ; k++){
          bitwise_or=bitwise_or | arr[k];
        }
        if(bitwise_or>=K)count++;
      }
    }
    return count ;
  }
  public static void main(String args[]){
    int arr[]={
      3,4,5 };
      int n=arr.length ;
      int k=6 ;
      System.out.println(countSubArrays(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation countSubArrays( arr : Sequence(int), n : int, K : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i ; while j < n do ( (     var bitwise_or : int ; bitwise_or := 0 ;
         var k : int ; k := i ; while k <= j do ( (     bitwise_or := MathLib.bitwiseOr(bitwise_or,arr[k+1]) )  ;     k := k + 1 ) ; 
     if (bitwise_or >= K) then     count := count + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,4,5} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 6 ;
     OclFile["System.out"].println(countSubArrays(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int binomialCoeff(int n,int k){
    int[][] C=new int[n+1][k+1];
    for(int i=0 ; i<=n ; i++){
      for(int j=0 ; j<=Math.min(i,k); j++){
        if(j==0 || j==i)C[i][j]=1 ;
        else C[i][j]=C[i-1][j-1]+C[i-1][j];
      }
    }
    return C[n][k];
  }
  static int maxcoefficientvalue(int n){
    if(n % 2==0)return binomialCoeff(n,n/2);
    else return binomialCoeff(n,(n+1)/2);
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(maxcoefficientvalue(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation binomialCoeff( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var C : Sequence(Sequence(int)) ; C := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,k + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= Set{i, k}->min() do ( (     if (j = 0 or j = i) then     C[i+1][j+1] := 1 ; else     C[i+1][j+1] := C[i - 1+1][j - 1+1] + C[i - 1+1][j+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return C[n+1][k+1] );
  static   operation maxcoefficientvalue( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 = 0) then     return binomialCoeff(n, n / 2) else     return binomialCoeff(n, (n + 1) / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(maxcoefficientvalue(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isVowel(char ch){
    switch(ch){
      case 'a' : case 'e' : case 'i' : case 'o' : case 'u' : return true ;
      default : return false ;
    }
  }
  static int vowelPairs(String s,int n){
    int cnt=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if(isVowel(s.charAt(i))&& isVowel(s.charAt(i+1)))cnt++;
    }
    return cnt ;
  }
  public static void main(String args[]){
    String s="abaebio" ;
    int n=s.length();
    System.out.print(vowelPairs(s,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isVowel( ch : String) : boolean
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (ch) ; 
    if _switchval = 'a' or _switchval = 'e' or _switchval = 'i' or _switchval = 'o' or _switchval = 'u' then
    return true 
   else skip ;
       if true then
     return false 
   else skip ;
 )
 );
  static   operation vowelPairs( s : String, n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     if (isVowel(s->at(i+1)) & isVowel(s->at(i + 1+1))) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abaebio" ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].print(vowelPairs(s, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    solve();
  }
  private static void solve(){
    Scanner scn=new Scanner(System.in);
    PrintWriter pr=new PrintWriter(System.out);
    while(true){
      int N=scn.nextInt();
      if(N==0)break ;
      int W=scn.nextInt();
      int H=scn.nextInt();
      int[][] map=new int[W+1][H+1];
      while(N-->0){
        map[scn.nextInt()][scn.nextInt()]++;
      }
      int S=scn.nextInt();
      int T=scn.nextInt();
      int max=0 ;
      for(int s=1 ; s<=W-S+1 ; s++){
        for(int t=1 ; t<=H-T+1 ; t++){
          int count=0 ;
          for(int a=s ; a<s+S ; a++){
            for(int b=t ; b<t+T ; b++){
              count+=map[a][b];
            }
          }
          if(max<count){
            max=count ;
          }
        }
      }
      pr.println(max);
    }
    pr.flush();
    scn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    while (true) do (     var N : int ; N := scn.getCurrent()->toInteger() ;
     if (N = 0) then     break else skip ; 
    var W : int ; W := scn.getCurrent()->toInteger() ;
    var H : int ; H := scn.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,W + 1)->collect(Integer.subrange(1,H + 1)->collect(0)) ;
        while (N > 0) do (        N := N - 1 ;     skip ; (     map[scn.getCurrent()->toInteger()+1][scn.getCurrent()->toInteger()+1] := map[scn.getCurrent()->toInteger()+1][scn.getCurrent()->toInteger()+1] + 1 ) ;  ) ;  
    var S : int ; S := scn.getCurrent()->toInteger() ;
    var T : int ; T := scn.getCurrent()->toInteger() ;
    var max : int ; max := 0 ;
        var s : int ; s := 1 ; while s <= W - S + 1 do ( (         var t : int ; t := 1 ; while t <= H - T + 1 do ( (     var count : int ; count := 0 ;
         var a : int ; a := s ; while a < s + S do ( (         var b : int ; b := t ; while b < t + T do ( (     count := count+(map[a+1][b+1]) )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
     if (max < count) then (     max := count ) else skip )  ;     t := t + 1 ) )  ;     s := s + 1 ) ; 
    skip ; 
 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
class Main {
  public static Scanner sc=new Scanner(in);
  public static Random rand=new Random();
  public void run(){
    TCase : while(true){
      int n=sc.nextInt();
      if(n==0)return ;
      int W=sc.nextInt(),H=sc.nextInt();
      boolean[][] kaki=new boolean[W][H];
      for(int i=0 ; i<n ; i++){
        kaki[sc.nextInt()-1][sc.nextInt()-1]=true ;
      }
      int S=sc.nextInt(),T=sc.nextInt();
      int max=0 ;
      for(int xs=0 ; xs<W ; xs++)for(int ys=0 ; ys<H ; ys++){
        if(xs+S<=W && ys+T<=H){
          int sum=0 ;
          for(int x=xs ; x<xs+S ; x++)for(int y=ys ; y<ys+T ; y++){
            if(kaki[x][y])sum++;
          }
          max=Math.max(sum,max);
        }
      }
      ln(max);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  public int[] nextIntArray(int n){
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=sc.nextInt();
    }
    return res ;
  }
  public static void pr(Object o){
    out.print(o);
  }
  public static void ln(Object o){
    out.println(o);
  }
  public static void ln(){
    out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(in);
  static   attribute rand : OclRandom := OclRandom.newOclRandom();
   operation run() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var H : int ; H := sc.getCurrent()->toInteger() ;
    var kaki : Sequence(Sequence(boolean)) ; kaki := Integer.subrange(1,W)->collect(Integer.subrange(1,H)->collect(false)) ;
        var i : int ; i := 0 ; while i < n do ( (     kaki[sc.getCurrent()->toInteger() - 1+1][sc.getCurrent()->toInteger() - 1+1] := true )  ;     i := i + 1 ) ; 
    var S : int ; S := sc.getCurrent()->toInteger() ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
    var max : int ; max := 0 ;
        var xs : int ; xs := 0 ; while xs < W do (         var ys : int ; ys := 0 ; while ys < H do ( (     if (xs + S <= W & ys + T <= H) then (     var sum : int ; sum := 0 ;
         var x : int ; x := xs ; while x < xs + S do (         var y : int ; y := ys ; while y < ys + T do ( (     if (kaki[x+1][y+1]) then     sum := sum + 1 ; else skip )  ;     y := y + 1 ) ;  ;     x := x + 1 ) ; 
     max := Set{sum, max}->max() ) else skip )  ;     ys := ys + 1 ) ;  ;     xs := xs + 1 ) ; 
    execute ln(max) ; 
 ) ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return res );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     out.println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,w,h,x,y,s,t,count,max,i,j,k,l ;
    boolean[][] f ;
    for(; ; ){
      n=sc.nextInt();
      if(n==0)break ;
      w=sc.nextInt();
      h=sc.nextInt();
      f=new boolean[w][h];
      for(; n-->0 ; ){
        x=sc.nextInt();
        y=sc.nextInt();
        f[x-1][y-1]=true ;
      }
      s=sc.nextInt();
      t=sc.nextInt();
      max=0 ;
      for(i=0 ; i<w+1-s ; i++)for(j=0 ; j<h+1-t ; j++){
        count=0 ;
        for(k=0 ; k<s ; k++)for(l=0 ; l<t ; l++)if(f[i+k][j+l])count++;
        if(max<count)max=count ;
      }
      out.println(max);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var w : int ;
    var h : int ;
    var x : int ;
    var y : int ;
    var s : int ;
    var t : int ;
    var count : int ;
    var max : int ;
    var i : int ;
    var j : int ;
    var k : int ;
    var l : int ;
    var f : Sequence(Sequence(boolean)) ;
      while true do ( (     n := sc.nextInt() ; 
     if (n = 0) then     break else skip ; 
    w := sc.nextInt() ; 
    h := sc.nextInt() ; 
    f := Integer.subrange(1,w)->collect(Integer.subrange(1,h)->collect(false)) ; 
      while n > 0 do ( (     x := sc.nextInt() ; 
     y := sc.nextInt() ; 
     f[x - 1+1][y - 1+1] := true )  ) ; 
    s := sc.nextInt() ; 
    t := sc.nextInt() ; 
    max := 0 ; 
        i := 0 ; while i < w + 1 - s do (         j := 0 ; while j < h + 1 - t do ( (     count := 0 ; 
         k := 0 ; while k < s do (         l := 0 ; while l < t do (     if (f[i + k+1][j + l+1]) then     count := count + 1 ; else skip ;  ;     l := l + 1 ) ;  ;     k := k + 1 ) ; 
     if (max < count) then     max := count ; else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    out.println(max) ; 
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int[][] dp ;
  static Knap[] knaps ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int w=sc.nextInt();
    knaps=new Knap[n];
    for(int i=0 ; i<n ; i++){
      knaps[i]=new Knap(sc.nextInt(),sc.nextInt());
    }
    Arrays.sort(knaps);
    dp=new int[n][w+1];
    System.out.println(dfw(n-1,w));
  }
  static int dfw(int idx,int weight){
    if(weight<0){
      return Integer.MIN_VALUE ;
    }
    if(idx<0){
      return 0 ;
    }
    if(dp[idx][weight]!=0){
      return dp[idx][weight];
    }
    if(weight % knaps[idx] .weight==0){
      return dp[idx][weight]=weight/knaps[idx] .weight*knaps[idx] .value ;
    }
    int max=0 ;
    for(int i=0 ; i*knaps[idx] .weight<=weight ; i++){
      max=Math.max(max,dfw(idx-1,weight-knaps[idx] .weight*i)+knaps[idx] .value*i);
    }
    return dp[idx][weight]=max ;
  }
  static class Knap implements Comparable<Knap>{
    int value ;
    int weight ;
    public Knap(int value,int weight){
      this.value=value ;
      this.weight=weight ;
    }
    public int compareTo(Knap another){
      return value*another.weight-another.value*weight ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dp : Sequence(Sequence(int));
  static   attribute knaps : Sequence(Knap);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    knaps := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do ( (     knaps[i+1] := Knap.newKnap(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    knaps := knaps->sort() ; 
    dp := Integer.subrange(1,n)->collect(Integer.subrange(1,w + 1)->collect(0)) ; 
    OclFile["System.out"].println(dfw(n - 1, w)) ; 
 );
  static   operation dfw( idx : int, weight : int) : int
  pre: true
  post: true
  activity: (     if (weight < 0) then (     return -2147483648 ) else skip ; 
     if (idx < 0) then (     return 0 ) else skip ; 
    if (dp[idx+1][weight+1] /= 0) then (     return dp[idx+1][weight+1] ) else skip ; 
    if (weight mod knaps[idx+1].weight = 0) then (     return dp[idx+1][weight+1] ) else skip ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i * knaps[idx+1].weight <= weight do ( (     max := Set{max, dfw(idx - 1, weight - knaps[idx+1].weight * i) + knaps[idx+1].value * i}->max() )  ;     i := i + 1 ) ; 
    return dp[idx+1][weight+1] 
 );
  static class Knap implements Comparable<Knap> {
   attribute value : int;
   attribute weight : int;
   static operation newKnap( value : int, weight : int) : Knap
  pre: true
  post: true
  activity:
  ( var self : Knap ;
    self := createKnap();
    self.initialise(value, weight);
    return self );
  operation initialise( value : int, weight : int) : void
  pre: true  post: true
  activity: (     self.value := value ; 
     self.weight := weight );
   operation compareTo( another : Knap) : int
  pre: true
  post: true
  activity: (     return value * another.weight - another.value * weight );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean solve(){
    int n=in.nextInt();
    if(n==0)return false ;
    int w=in.nextInt(),h=in.nextInt();
    int[][] field=new int[w+2][h+2];
    for(int i=0 ; i<n ; i++){
      field[in.nextInt()][in.nextInt()]++;
    }
    for(int i=1 ; i<=w ; i++){
      for(int j=1 ; j<=h ; j++){
        field[i+1][j]+=field[i][j];
        field[i][j+1]+=field[i][j];
        field[i+1][j+1]-=field[i][j];
      }
    }
    int s=in.nextInt(),t=in.nextInt();
    int max=0 ;
    for(int i=s ; i<=w ; i++){
      for(int j=t ; j<=h ; j++){
        max=Math.max(max,field[i][j]-field[i-s][j]-field[i][j-t]+field[i-s][j-t]);
      }
    }
    out.println(max);
    return true ;
  }
  public static void main(String[] args){
    long start=System.currentTimeMillis();
    while(solve());
    out.flush();
    long end=System.currentTimeMillis();
    in.close();
    out.close();
  }
  static void trace(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   operation solve() : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return false else skip ; 
    var w : int ; w := in.getCurrent()->toInteger() ;
    var h : int ; h := in.getCurrent()->toInteger() ;
    var field : Sequence(Sequence(int)) ; field := Integer.subrange(1,w + 2)->collect(Integer.subrange(1,h + 2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     field[in.getCurrent()->toInteger()+1][in.getCurrent()->toInteger()+1] := field[in.getCurrent()->toInteger()+1][in.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= w do ( (         var j : int ; j := 1 ; while j <= h do ( (     field[i + 1+1][j+1] := field[i + 1+1][j+1]+(field[i+1][j+1]) ; 
     field[i+1][j + 1+1] := field[i+1][j + 1+1]+(field[i+1][j+1]) ; 
     field[i + 1+1][j + 1+1] := field[i + 1+1][j + 1+1]-(field[i+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var s : int ; s := in.getCurrent()->toInteger() ;
    var t : int ; t := in.getCurrent()->toInteger() ;
    var max : int ; max := 0 ;
        var i : int ; i := s ; while i <= w do ( (         var j : int ; j := t ; while j <= h do ( (     max := Set{max, field[i+1][j+1] - field[i - s+1][j+1] - field[i+1][j - t+1] + field[i - s+1][j - t+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : long ; start := OclDate.getSystemTime() ;
     while (solve()) do  ; 
    skip ; 
    var end : long ; end := OclDate.getSystemTime() ;
    skip ; 
    skip ; 
 );
  static   operation trace( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  Scanner sc ;
  public void run(){
    sc=new Scanner(System.in);
    ArrayList<Integer>n=new ArrayList<Integer>();
    while(sc.hasNextInt()){
      int value=sc.nextInt();
      if(value!=0){
        int w=sc.nextInt();
        int h=sc.nextInt();
        calc(value,w,h);
      }
      else {
        break ;
      }
    }
  }
  public void calc(int n,int w,int h){
    int[][] map=new int[w][h];
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      map[x-1][y-1]=1 ;
    }
    int s=sc.nextInt();
    int t=sc.nextInt();
    int ans=0 ;
    for(int i=0 ; i<w-s+1 ; i++){
      for(int j=0 ; j<h-t+1 ; j++){
        int temp=0 ;
        for(int a=0 ; a<s ; a++){
          for(int b=0 ; b<t ; b++){
            temp=temp+map[i+a][j+b];
          }
        }
        if(temp>ans)ans=temp ;
      }
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : Sequence(int) ; n := Sequence{} ;
     while (sc.hasNextInt()) do (     var value : int ; value := sc.getCurrent()->toInteger() ;
     if (value /= 0) then (     var w : int ; w := sc.getCurrent()->toInteger() ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
     execute calc(value, w, h) ) else (     break ) ) );
   operation calc( n : int, w : int, h : int) : void
  pre: true
  post: true
  activity: (     var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,w)->collect(Integer.subrange(1,h)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     map[x - 1+1][y - 1+1] := 1 )  ;     i := i + 1 ) ; 
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < w - s + 1 do ( (         var j : int ; j := 0 ; while j < h - t + 1 do ( (     var temp : int ; temp := 0 ;
         var a : int ; a := 0 ; while a < s do ( (         var b : int ; b := 0 ; while b < t do ( (     temp := temp + map[i + a+1][j + b+1] )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
     if (temp > ans) then     ans := temp ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int isSubstring(String s1,String s2){
    int M=s1.length();
    int N=s2.length();
    for(int i=0 ; i<=N-M ; i++){
      int j ;
      for(j=0 ; j<M ; j++)if(s2.charAt(i+j)!=s1.charAt(j))break ;
      if(j==M)return i ;
    }
    return-1 ;
  }
  public static void main(String args[]){
    String s1="for" ;
    String s2="geeksforgeeks" ;
    int res=isSubstring(s1,s2);
    if(res==-1)System.out.println("Not present");
    else System.out.println("Present at index "+res);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isSubstring( s1 : String, s2 : String) : int
  pre: true
  post: true
  activity: (     var M : int ; M := s1->size() ;
     var N : int ; N := s2->size() ;
         var i : int ; i := 0 ; while i <= N - M do ( (     var j : int ;
         j := 0 ; while j < M do (     if (s2->at(i + j+1) /= s1->at(j+1)) then     break else skip ;  ;     j := j + 1 ) ; 
     if (j = M) then     return i else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "for" ;
     var s2 : String ; s2 := "geeksforgeeks" ;
     var res : int ; res := isSubstring(s1, s2) ;
     if (res = -1) then     OclFile["System.out"].println("Not present") ; else     OclFile["System.out"].println("Present at index " + res) ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float angleOncirCumference(float z){
    return(z/2);
  }
  public static void main(String[] args){
    float angle=65 ;
    float z=angleOncirCumference(angle);
    System.out.println("The angle is "+z+" degrees");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation angleOncirCumference( z : double) : double
  pre: true
  post: true
  activity: (     return (z / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var angle : double ; angle := 65 ;
     var z : double ; z := angleOncirCumference(angle) ;
     OclFile["System.out"].println("The angle is " + z + " degrees") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void countSubarraysof1and0(int a[],int n){
    int count1=0,count0=0 ;
    int number1=0,number0=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]==1){
        count1+=1 ;
      }
      else {
        number1+=(count1)*(count1+1)/2 ;
        count1=0 ;
      }
    }
    for(int i=0 ; i<n ; i++){
      if(a[i]==0){
        count0+=1 ;
      }
      else {
        number0+=(count0)*(count0+1)/2 ;
        count0=0 ;
      }
    }
    if(count1>0)number1+=(count1)*(count1+1)/2 ;
    if(count0>0)number0+=(count0)*(count0+1)/2 ;
    System.out.println("Count of subarrays of 0 only: "+number0);
    System.out.println("\nCount of subarrays of 1 only: "+number1);
  }
  public static void main(String[] args){
    int a[]={
      1,1,0,0,1,0,1,0,1,1,1,1 };
      int n=a.length ;
      countSubarraysof1and0(a,n);
      ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSubarraysof1and0( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var count1 : int ; count1 := 0 ;
    var count0 : int ; count0 := 0 ;
     var number1 : int ; number1 := 0 ;
    var number0 : int ; number0 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = 1) then (     count1 := count1+(1) ) else (     number1 := number1+((count1) * (count1 + 1) / 2) ; 
     count1 := 0 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = 0) then (     count0 := count0+(1) ) else (     number0 := number0+((count0) * (count0 + 1) / 2) ; 
     count0 := 0 ) )  ;     i := i + 1 ) ; 
    if (count1 > 0) then     number1 := number1+((count1) * (count1 + 1) / 2) ; else skip ; 
    if (count0 > 0) then     number0 := number0+((count0) * (count0 + 1) / 2) ; else skip ; 
    OclFile["System.out"].println("Count of subarrays of 0 only: " + number0) ; 
    OclFile["System.out"].println("\nCount of subarrays of 1 only: " + number1) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,1,0,0,1,0,1,0,1,1,1,1} ;
     var n : int ; n := a->size() ;
     execute countSubarraysof1and0(a, n) ; 
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean canBeEqual(int a,int b,int c,int k){
    int[] arr=new int[3];
    arr[0]=a ;
    arr[1]=b ;
    arr[2]=c ;
    Arrays.sort(arr);
    int diff=2*arr[2]-arr[1]-arr[0];
    k=k-diff ;
    if(k<0 || k % 3!=0)return false ;
    return true ;
  }
  public static void main(String[] args){
    int a1=6,b1=3,c1=2,k1=7 ;
    if(canBeEqual(a1,b1,c1,k1))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation canBeEqual( a : int, b : int, c : int, k : int) : boolean
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,3)->collect(0) ;
     arr[0+1] := a ; 
    arr[1+1] := b ; 
    arr[2+1] := c ; 
    arr := arr->sort() ; 
    var diff : int ; diff := 2 * arr[2+1] - arr[1+1] - arr[0+1] ;
    k := k - diff ; 
    if (k < 0 or k mod 3 /= 0) then     return false else skip ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a1 : int ; a1 := 6 ;
    var b1 : int ; b1 := 3 ;
    var c1 : int ; c1 := 2 ;
    var k1 : int ; k1 := 7 ;
     if (canBeEqual(a1, b1, c1, k1)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    try {
      final int N=sc.nextInt();
      int K=sc.nextInt();
      StringBuilder S=new StringBuilder(sc.next());
      boolean firstTime=true ;
      int step=1 ;
      while(K>0){
        StringBuilder T=new StringBuilder(S.toString());
        T.reverse();
        StringBuilder revU=new StringBuilder(S.toString()+T.toString());
        revU.reverse();
        String sDash=S.toString();
        for(int i=N ; i>=0 ; i-=step){
          String tmp=revU.substring(i,i+N);
          if(sDash.compareTo(tmp)>0){
            sDash=tmp ;
          }
          else {
            if(! firstTime){
              break ;
            }
          }
        }
        if(firstTime){
          firstTime=false ;
          if(Math.pow(2,K)>N){
            char c=sDash.charAt(0);
            for(int i=0 ; i<N ; i++){
              System.out.print(c);
            }
            System.out.println();
            System.exit(0);
          }
        }
        else {
          step+=step ;
        }
        K--;
        S=new StringBuilder(sDash);
        S.reverse();
      }
      System.out.println(S.reverse());
    }
    finally {
      sc.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     try (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    var S : String ; S := StringLib.newString(sc.getCurrent()) ;
    var firstTime : boolean ; firstTime := true ;
    var step : int ; step := 1 ;
    while (K > 0) do (     var T : String ; T := StringLib.newString(S+"") ;
     T := T->reverse() ; 
    var revU : String ; revU := StringLib.newString(S+"" + T+"") ;
    revU := revU->reverse() ; 
    var sDash : String ; sDash := S+"" ;
        var i : int ; i := N ; while i >= 0 do ( (     var tmp : String ; tmp := revU.subrange(i+1,i + N) ;
     if (sDash->compareTo(tmp) > 0) then (     sDash := tmp ) else (     if (not(firstTime)) then (     break ) else skip ) )  ;     i := i-(step) ) ; 
    if (firstTime) then (     firstTime := false ; 
     if (2->pow(K) > N) then (     var c : String ; c := sDash->at(0+1) ;
         var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].print(c) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ; 
 OclProcess.exit(0) ) else skip ) else (     step := step+(step) ) ;  
    K := K - 1 ; 
    S := StringLib.newString(sDash) ; 
    S := S->reverse() ; 
 ) ; 
    OclFile["System.out"].println(S->reverse()) ; 
 )   finally (     skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    try {
      final int N=sc.nextInt();
      int K=sc.nextInt();
      StringBuilder S=new StringBuilder(sc.next());
      boolean firstTime=true ;
      int step=1 ;
      while(K>0){
        StringBuilder T=new StringBuilder(S.toString());
        T.reverse();
        StringBuilder revU=new StringBuilder(S.toString()+T.toString());
        revU.reverse();
        String sDash=S.toString();
        for(int i=N ; i>=0 ; i-=step){
          String tmp=revU.substring(i,i+N);
          if(sDash.compareTo(tmp)>0){
            sDash=tmp ;
          }
          else {
            if(! firstTime){
              break ;
            }
          }
        }
        if(firstTime){
          firstTime=false ;
          if(Math.pow(2,K)>N){
            char c=sDash.charAt(0);
            for(int i=0 ; i<N ; i++){
              System.out.print(c);
            }
            System.out.println();
            System.exit(0);
          }
        }
        else {
          step+=step ;
        }
        K--;
        S=new StringBuilder(sDash);
        S.reverse();
      }
      System.out.println(S.reverse());
    }
    finally {
      sc.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     try (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    var S : String ; S := StringLib.newString(sc.getCurrent()) ;
    var firstTime : boolean ; firstTime := true ;
    var step : int ; step := 1 ;
    while (K > 0) do (     var T : String ; T := StringLib.newString(S+"") ;
     T := T->reverse() ; 
    var revU : String ; revU := StringLib.newString(S+"" + T+"") ;
    revU := revU->reverse() ; 
    var sDash : String ; sDash := S+"" ;
        var i : int ; i := N ; while i >= 0 do ( (     var tmp : String ; tmp := revU.subrange(i+1,i + N) ;
     if (sDash->compareTo(tmp) > 0) then (     sDash := tmp ) else (     if (not(firstTime)) then (     break ) else skip ) )  ;     i := i-(step) ) ; 
    if (firstTime) then (     firstTime := false ; 
     if (2->pow(K) > N) then (     var c : String ; c := sDash->at(0+1) ;
         var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].print(c) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ; 
 OclProcess.exit(0) ) else skip ) else (     step := step+(step) ) ;  
    K := K - 1 ; 
    S := StringLib.newString(sDash) ; 
    S := S->reverse() ; 
 ) ; 
    OclFile["System.out"].println(S->reverse()) ; 
 )   finally (     skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printNumbers(int N){
    int flag=1 ;
    int x=N ;
    if(N>0){
      while(x>0 && flag==1){
        int digit=x % 10 ;
        if(digit!=1 && digit!=3){
          flag=0 ;
        }
        x=x/10 ;
      }
      if(flag==1){
        System.out.print(N+" ");
      }
      printNumbers(N-1);
    }
  }
  public static void main(String[] args){
    int N=20 ;
    printNumbers(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printNumbers( N : int) : void
  pre: true
  post: true
  activity: (     var flag : int ; flag := 1 ;
     var x : int ; x := N ;
     if (N > 0) then (     while (x > 0 & flag = 1) do (     var digit : int ; digit := x mod 10 ;
     if (digit /= 1 & digit /= 3) then (     flag := 0 ) else skip ; 
     x := x / 10 ) ; 
     if (flag = 1) then (     OclFile["System.out"].print(N + " ") ) else skip ; 
     execute printNumbers(N - 1) ) else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 20 ;
     execute printNumbers(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printPermutation(int n,int k){
    int i,mx=n ;
    for(i=1 ; i<=k ; i++){
      System.out.print(mx+" ");
      mx--;
    }
    for(i=1 ; i<=mx ; i++)System.out.print(i+" ");
  }
  public static void main(String[] args){
    int N=5,K=3 ;
    if(K>=N-1)System.out.print("Not Possible");
    else printPermutation(N,K);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printPermutation( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var mx : int ; mx := n ;
         i := 1 ; while i <= k do ( (     OclFile["System.out"].print(mx + " ") ; 
     mx := mx - 1 )  ;     i := i + 1 ) ; 
         i := 1 ; while i <= mx do (     OclFile["System.out"].print(i + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
    var K : int ; K := 3 ;
     if (K >= N - 1) then     OclFile["System.out"].print("Not Possible") ; else     execute printPermutation(N, K) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  public void run()throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(reader.readLine());
    int n=Integer.parseInt(st.nextToken());
    int W=Integer.parseInt(st.nextToken());
    int[] v=new int[n];
    int[] w=new int[n];
    for(int i=0 ; i<n ; i++){
      st=new StringTokenizer(reader.readLine());
      v[i]=Integer.parseInt(st.nextToken());
      w[i]=Integer.parseInt(st.nextToken());
    }
    reader.close();
    System.out.println(getMaxValue(n,W,v,w));
  }
  private int getMaxValue(int n,int W,int[] v,int[] w){
    int[][] dp=new int[n+1][W+1];
    for(int i=0 ; i<n ; i++){
      int vl=v[i];
      int wt=w[i];
      for(int j=0 ; j<=W ; j++){
        if(wt>j){
          dp[i+1][j]=dp[i][j];
        }
        else {
          dp[i+1][j]=Math.max(dp[i][j],dp[i][j-wt]+vl);
          dp[i+1][j]=Math.max(dp[i][j],dp[i+1][j-wt]+vl);
        }
      }
    }
    return dp[n][W];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(reader.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var W : int ; W := (st.next())->toInteger() ;
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
    var w : Sequence(int) ; w := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     st := OclIterator.newOclIterator_String(reader.readLine()) ; 
     v[i+1] := (st.next())->toInteger() ; 
     w[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(getMaxValue(n, W, v, w)) ; 
 );
   operation getMaxValue( n : int, W : int, v : Sequence(int), w : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,W + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do ( (     var vl : int ; vl := v[i+1] ;
     var wt : int ; wt := w[i+1] ;
         var j : int ; j := 0 ; while j <= W do ( (     if (wt > j) then (     dp[i + 1+1][j+1] := dp[i+1][j+1] ) else (     dp[i + 1+1][j+1] := Set{dp[i+1][j+1], dp[i+1][j - wt+1] + vl}->max() ; 
     dp[i + 1+1][j+1] := Set{dp[i+1][j+1], dp[i + 1+1][j - wt+1] + vl}->max() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return dp[n+1][W+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TheRank {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int ans=0 ;
    int rank=1 ;
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      int a=in.nextInt();
      int b=in.nextInt();
      int c=in.nextInt();
      int d=in.nextInt();
      int sum=a+b+c+d ;
      arr[i]=sum ;
    }
    for(int j : arr){
      if(arr[0]<j){
        rank++;
      }
    }
    System.out.println(rank);
  }
}
------------------------------------------------------------
OCL File:
---------
 class TheRank {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    var rank : int ; rank := 1 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var sum : int ; sum := a + b + c + d ;
    arr[i+1] := sum ; 
 )  ;     i := i + 1 ) ; 
    for (j : arr) do ( (     if (arr[0+1] < j) then (     rank := rank + 1 ) else skip )  ) ; 
    OclFile["System.out"].println(rank) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastReader in=new FastReader();
    int caseno=in.nextInt();
    int thomas=0,rank=1 ;
    for(int i=1 ; i<=caseno ; i++){
      int a=in.nextInt();
      int b=in.nextInt();
      int c=in.nextInt();
      int d=in.nextInt();
      if(i==1){
        thomas=a+b+c+d ;
      }
      else if(a+b+c+d>thomas){
        rank++;
      }
    }
    System.out.println(rank);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
    String next(){
      while(st==null || ! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var caseno : int ; caseno := in.nextInt() ;
    var thomas : int ; thomas := 0 ;
    var rank : int ; rank := 1 ;
        var i : int ; i := 1 ; while i <= caseno do ( (     var a : int ; a := in.nextInt() ;
     var b : int ; b := in.nextInt() ;
    var c : int ; c := in.nextInt() ;
    var d : int ; d := in.nextInt() ;
    if (i = 1) then (     thomas := a + b + c + d ) else     if (a + b + c + d > thomas) then (     rank := rank + 1 ) else skip ; ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(rank) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1017A_TheRank {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int len=input.nextInt();
    Map<Integer,Integer>scores=new HashMap<>();
    for(int i=1 ; i<=len ; i++){
      int sum=0 ;
      for(int h=0 ; h<4 ; h++){
        sum+=input.nextInt();
      }
      scores.put(i,sum);
    }
    int thomasScore=scores.get(1);
    LinkedList<Integer>finalScores=new LinkedList<>(scores.values());
    Collections.sort(finalScores,Collections.reverseOrder());
    int rank=finalScores.indexOf(thomasScore)+1 ;
    System.out.println(rank);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1017A_TheRank {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := input.getCurrent()->toInteger() ;
    var scores : Map(int,int) ; scores := Map{} ;
        var i : int ; i := 1 ; while i <= len do ( (     var sum : int ; sum := 0 ;
         var h : int ; h := 0 ; while h < 4 do ( (     sum := sum+(input.getCurrent()->toInteger()) )  ;     h := h + 1 ) ; 
     scores := scores->union(Map{i |-> sum}) )  ;     i := i + 1 ) ; 
    var thomasScore : int ; thomasScore := scores->at(1) ;
    var finalScores : Sequence(int) ; finalScores := Sequence{}->union(scores->values()) ;
    finalScores, reverseOrder() := finalScores, reverseOrder()->sort() ; 
    var rank : int ; rank := finalScores->indexOf(thomasScore)-1 + 1 ;
    OclFile["System.out"].println(rank) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean check(String s1,String s2){
    Map<Character,Integer>mp=new HashMap<>();
    for(int i=0 ; i<s1.length(); i++){
      mp.put(s1.charAt(i),mp.get(s1.charAt(i))==null ? 1 : mp.get(s1.charAt(i))+1);
    }
    for(int i=0 ; i<s2.length(); i++){
      if(mp.get(s2.charAt(i))>0){
        return true ;
      }
    }
    return false ;
  }
  public static void main(String[] args){
    String s1="geeksforgeeks",s2="geeks" ;
    boolean yes_or_no=check(s1,s2);
    if(yes_or_no==true){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( s1 : String, s2 : String) : boolean
  pre: true
  post: true
  activity: (     var mp : Map(String,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < s1->size() do ( (     mp := mp->union(Map{s1->at(i+1) |-> if mp->at(s1->at(i+1)) = null then 1 else mp->at(s1->at(i+1)) + 1 endif}) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < s2->size() do ( (     if (mp->at(s2->at(i+1)) > 0) then (     return true ) else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "geeksforgeeks" ;
    var s2 : String ; s2 := "geeks" ;
     var yes_or_no : boolean ; yes_or_no := check(s1, s2) ;
     if (yes_or_no = true) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int d=sc.nextInt();
      boolean flag=false ;
      int k=n*(a-b);
      int m=n*(a+b);
      if(k>(c+d)|| m<(c-d))System.out.println("NO");
      else System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var flag : boolean ; flag := false ;
    var k : int ; k := n * (a - b) ;
    var m : int ; m := n * (a + b) ;
    if (k > (c + d) or m < (c - d)) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CodeF {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int d=sc.nextInt();
      if((a+b)*n<c-d ||(a-b)*n>c+d){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeF {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    if ((a + b) * n < c - d or (a - b) * n > c + d) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int i,top ;
    String s ;
    char az ;
    s=sc.next();
    az='A' ;
    top=0 ;
    for(i=0 ; i<s.length(); i++){
      if(s.charAt(i)==az){
        top++;
        if(az=='A')az='Z' ;
        else if(az=='Z')az='A' ;
      }
    }
    if(top<2)out.println("-1");
    else {
      for(i=0 ; i<top/2 ; i++)out.print("AZ");
      out.println();
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var i : int ;
    var top : int ;
    var s : String ;
    var az : String ;
    s := sc.next() ; 
    az := 'A' ; 
    top := 0 ; 
        i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = az) then (     top := top + 1 ; 
     if (az = 'A') then     az := 'Z' ; else     if (az = 'Z') then     az := 'A' ; else skip ; ) else skip )  ;     i := i + 1 ) ; 
    if (top < 2) then     out.println("-1") else (         i := 0 ; while i < top / 2 do (     out.print("AZ") ;  ;     i := i + 1 ) ; 
     out.println() ) ;  
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Vector<Vector<Integer>>adjacency=new Vector<Vector<Integer>>();
  static void insert(int x,int y){
    adjacency.get(x).add(y);
  }
  static void dfs(int node,int leaf[],int vis[]){
    leaf[node]=0 ;
    vis[node]=1 ;
    for(int i=0 ; i<adjacency.get(node).size(); i++){
      int it=adjacency.get(node).get(i);
      if(vis[it]==0){
        dfs(it,leaf,vis);
        leaf[node]+=leaf[it];
      }
    }
    if(adjacency.get(node).size()==0)leaf[node]=1 ;
  }
  static void printLeaf(int n,int leaf[]){
    for(int i=1 ; i<=n ; i++){
      System.out.print("The node "+i+" has "+leaf[i]+" leaf nodes\n");
    }
  }
  public static void main(String args[]){
    int N=6 ;
    for(int i=0 ; i<=N ; i++)adjacency.add(new Vector<Integer>());
    insert(1,2);
    insert(1,3);
    insert(3,4);
    insert(3,5);
    insert(3,6);
    int leaf[]=new int[N+1];
    int vis[]=new int[N+1];
    dfs(1,leaf,vis);
    printLeaf(N,leaf);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute adjacency : Sequence(Sequence(int)) := Sequence{};
  static   operation insert( x : int, y : int) : void
  pre: true
  post: true
  activity: (     adjacency->at(x+1)->excludes(y) );
  static   operation dfs( node : int, leaf : Sequence(int), vis : Sequence(int)) : void
  pre: true
  post: true
  activity: (     leaf[node+1] := 0 ; 
     vis[node+1] := 1 ; 
         var i : int ; i := 0 ; while i < adjacency->at(node+1)->size() do ( (     var it : int ; it := adjacency->at(node+1)->at(i+1) ;
     if (vis[it+1] = 0) then (     execute dfs(it, leaf, vis) ; 
     leaf[node+1] := leaf[node+1]+(leaf[it+1]) ) else skip )  ;     i := i + 1 ) ; 
     if (adjacency->at(node+1)->size() = 0) then     leaf[node+1] := 1 ; else skip );
  static   operation printLeaf( n : int, leaf : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].print("The node " + i + " has " + leaf[i+1] + " leaf nodes\n") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 6 ;
         var i : int ; i := 0 ; while i <= N do (     adjacency := adjacency->including(Sequence{}) ;  ;     i := i + 1 ) ; 
    execute insert(1, 2) ; 
    execute insert(1, 3) ; 
    execute insert(3, 4) ; 
    execute insert(3, 5) ; 
    execute insert(3, 6) ; 
    var leaf : Sequence(int) ; leaf := Integer.subrange(1,N + 1)->collect(0) ;
    var vis : Sequence(int) ; vis := Integer.subrange(1,N + 1)->collect(0) ;
    execute dfs(1, leaf, vis) ; 
    execute printLeaf(N, leaf) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int t ;
    Scanner scanner=new Scanner(System.in);
    t=scanner.nextInt();
    while(t-->0){
      int n,a,b,c,d,sub=0,add=0,subcd=0,addcd=0 ;
      n=scanner.nextInt();
      a=scanner.nextInt();
      b=scanner.nextInt();
      c=scanner.nextInt();
      d=scanner.nextInt();
      sub=Math.abs(n*(a-b));
      add=n*(a+b);
      subcd=Math.abs(c-d);
      addcd=c+d ;
      if(add<subcd || addcd<sub){
        System.out.println("No");
      }
      else System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     t := scanner.getCurrent()->toInteger() ; 
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ;
    var a : int ;
    var b : int ;
    var c : int ;
    var d : int ;
    var sub : int ; sub := 0 ;
    var add : int ; add := 0 ;
    var subcd : int ; subcd := 0 ;
    var addcd : int ; addcd := 0 ;
     n := scanner.getCurrent()->toInteger() ; 
    a := scanner.getCurrent()->toInteger() ; 
    b := scanner.getCurrent()->toInteger() ; 
    c := scanner.getCurrent()->toInteger() ; 
    d := scanner.getCurrent()->toInteger() ; 
    sub := if n * (a - b) < 0 then -(n * (a - b)) else n * (a - b) endif ; 
    add := n * (a + b) ; 
    subcd := if c - d < 0 then -(c - d) else c - d endif ; 
    addcd := c + d ; 
    if (add < subcd or addcd < sub) then (     OclFile["System.out"].println("No") ) else     OclFile["System.out"].println("YES") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int d=sc.nextInt();
      System.out.println(solve(n,a,b,c,d)? "Yes" : "No");
    }
    sc.close();
  }
  static boolean solve(int n,int a,int b,int c,int d){
    int min=n*(a-b);
    int max=n*(a+b);
    return !(min>c+d || max<c-d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(if solve(n, a, b, c, d) then "Yes" else "No" endif) ; 
 )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( n : int, a : int, b : int, c : int, d : int) : boolean
  pre: true
  post: true
  activity: (     var min : int ; min := n * (a - b) ;
     var max : int ; max := n * (a + b) ;
     return not((min > c + d or max < c - d)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static class KnapsackComplete {
    int capacity ;
    int n ;
    int[] cost ;
    int[] value ;
    public KnapsackComplete(int n,int capacity,int[] cost,int[] value){
      this.n=n ;
      this.capacity=capacity ;
      this.cost=cost ;
      this.value=value ;
    }
    int solve(){
      int[] rowCurr ;
      rowCurr=new int[capacity+1];
      for(int numOfItems=1 ; numOfItems<=n ; numOfItems++){
        int costThis=cost[numOfItems-1];
        for(int weight=costThis ; weight<=capacity ; weight++){
          rowCurr[weight]=Math.max(rowCurr[weight],rowCurr[weight-costThis]+value[numOfItems-1]);
        }
      }
      return rowCurr[capacity];
    }
  }
  static Scanner in=new Scanner(System.in);
  static KnapsackComplete readCase(){
    while(in.hasNext()){
      int n=in.nextInt();
      int capacity=in.nextInt();
      int[] cost=new int[n];
      int[] value=new int[n];
      for(int i=0 ; i<n ; i++){
        value[i]=in.nextInt();
        cost[i]=in.nextInt();
      }
      KnapsackComplete knapsack=new KnapsackComplete(n,capacity,cost,value);
      return knapsack ;
    }
    return null ;
  }
  public static void main(String[] args){
    KnapsackComplete knapsack=readCase();
    System.out.println(knapsack.solve());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class KnapsackComplete {
   attribute capacity : int;
   attribute n : int;
   attribute cost : Sequence(int);
   attribute value : Sequence(int);
   static operation newKnapsackComplete( n : int, capacity : int, cost : Sequence(int), value : Sequence(int)) : KnapsackComplete
  pre: true
  post: true
  activity:
  ( var self : KnapsackComplete ;
    self := createKnapsackComplete();
    self.initialise(n, capacity,cost,value);
    return self );
  operation initialise( n : int, capacity : int, cost : Sequence(int), value : Sequence(int)) : void
  pre: true  post: true
  activity: (     self.n := n ; 
     self.capacity := capacity ; 
     self.cost := cost ; 
     self.value := value );
   operation solve() : int
  pre: true
  post: true
  activity: (     var rowCurr : Sequence(int) ;
     rowCurr := Integer.subrange(1,capacity + 1)->collect(0) ; 
         var numOfItems : int ; numOfItems := 1 ; while numOfItems <= n do ( (     var costThis : int ; costThis := cost[numOfItems - 1+1] ;
         var weight : int ; weight := costThis ; while weight <= capacity do ( (     rowCurr[weight+1] := Set{rowCurr[weight+1], rowCurr[weight - costThis+1] + value[numOfItems - 1+1]}->max() )  ;     weight := weight + 1 ) )  ;     numOfItems := numOfItems + 1 ) ; 
     return rowCurr[capacity+1] );
}
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation readCase() : KnapsackComplete
  pre: true
  post: true
  activity: (     while (in.hasNext()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var capacity : int ; capacity := in.getCurrent()->toInteger() ;
    var cost : Sequence(int) ; cost := Integer.subrange(1,n)->collect(0) ;
    var value : Sequence(int) ; value := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     value[i+1] := in.getCurrent()->toInteger() ; 
     cost[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var knapsack : KnapsackComplete ; knapsack := KnapsackComplete.newKnapsackComplete(n, capacity, cost, value) ;
    return knapsack 
 ) ; 
     return null );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var knapsack : KnapsackComplete ; knapsack := readCase() ;
     OclFile["System.out"].println(knapsack.solve()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class GFG {
  static void findElements(int arr[],int n){
    for(int i=0 ; i<n ; i++){
      int count=0 ;
      for(int j=0 ; j<n ; j++)if(arr[j]>arr[i])count++;
      if(count>=2)System.out.print(arr[i]+" ");
    }
  }
  public static void main(String args[]){
    int arr[]={
      2,-6,3,5,1 };
      int n=arr.length ;
      findElements(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findElements( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < n do (     if (arr[j+1] > arr[i+1]) then     count := count + 1 ; else skip ;  ;     j := j + 1 ) ; 
     if (count >= 2) then     OclFile["System.out"].print(arr[i+1] + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,-6,3,5,1} ;
     var n : int ; n := arr->size() ;
     execute findElements(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int N=3 ;
  static int maxPathSum(int tri[][],int m,int n){
    for(int i=m-1 ; i>=0 ; i--){
      for(int j=0 ; j<=i ; j++){
        if(tri[i+1][j]>tri[i+1][j+1])tri[i][j]+=tri[i+1][j];
        else tri[i][j]+=tri[i+1][j+1];
      }
    }
    return tri[0][0];
  }
  public static void main(String[] args){
    int tri[][]={
      {
        1,0,0 },{
          4,8,0 },{
            1,5,3 }
          };
          System.out.println(maxPathSum(tri,2,2));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 3;
  static   operation maxPathSum( tri : Sequence(Sequence(int)), m : int, n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := m - 1 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j <= i do ( (     if (tri[i + 1+1][j+1] > tri[i + 1+1][j + 1+1]) then     tri[i+1][j+1] := tri[i+1][j+1]+(tri[i + 1+1][j+1]) ; else     tri[i+1][j+1] := tri[i+1][j+1]+(tri[i + 1+1][j + 1+1]) ; )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
     return tri[0+1][0+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var tri : Sequence(Sequence(int)) ; tri := Sequence{Sequence{1,0,0},Sequence{4,8,0},Sequence{1,5,3}} ;
     OclFile["System.out"].println(maxPathSum(tri, 2, 2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isHeap(int arr[],int n){
    for(int i=0 ; i<=(n-2)/2 ; i++){
      if(arr[2*i+1]>arr[i]){
        return false ;
      }
      if(2*i+2<n && arr[2*i+2]>arr[i]){
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    int arr[]={
      90,15,10,7,12,2,7,3 };
      int n=arr.length ;
      if(isHeap(arr,n)){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isHeap( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= (n - 2) / 2 do ( (     if (arr[2 * i + 1+1] > arr[i+1]) then (     return false ) else skip ; 
     if (2 * i + 2 < n & arr[2 * i + 2+1] > arr[i+1]) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{90,15,10,7,12,2,7,3} ;
     var n : int ; n := arr->size() ;
     if (isHeap(arr, n)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isHeap(int arr[],int i,int n){
    if(i>(n-2)/2){
      return true ;
    }
    if(arr[i]>=arr[2*i+1] && arr[i]>=arr[2*i+2] && isHeap(arr,2*i+1,n)&& isHeap(arr,2*i+2,n)){
      return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    int arr[]={
      90,15,10,7,12,2,7,3 };
      int n=arr.length-1 ;
      if(isHeap(arr,0,n)){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isHeap( arr : Sequence(int), i : int, n : int) : boolean
  pre: true
  post: true
  activity: (     if (i > (n - 2) / 2) then (     return true ) else skip ; 
     if (arr[i+1] >= arr[2 * i + 1+1] & arr[i+1] >= arr[2 * i + 2+1] & isHeap(arr, 2 * i + 1, n) & isHeap(arr, 2 * i + 2, n)) then (     return true ) else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{90,15,10,7,12,2,7,3} ;
     var n : int ; n := arr->size() - 1 ;
     if (isHeap(arr, 0, n)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int H=scanner.nextInt();
    int W=scanner.nextInt();
    char[][] map=new char[H][W];
    for(int i=0 ; i<H ; i++)map[i]=scanner.next().toCharArray();
    int[][] level=new int[H][W];
    Queue<Cell>queue=new LinkedList<>();
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        if(map[i][j]=='#'){
          queue.add(new Cell(i,j,0));
        }
      }
    }
    int max=0 ;
    while(! queue.isEmpty()){
      Cell c=queue.remove();
      max=Math.max(max,c.depth);
      for(int[] df : new int[][] { { -1,0 },{ 1,0 },{ 0,-1 },{ 0,1 } } ){
                int x=c.x+df[0];
                int y=c.y+df[1];
                if(x>=0 && x<H && y>=0 && y<W && map[x][y]=='.'){
                  map[x][y]='#' ;
                  queue.add(new Cell(x,y,c.depth+1));
                }
              }
            }
            System.out.println(max);
          }
          private static class Cell {
            private final int x ;
            private final int y ;
            private final int depth ;
            private Cell(int x,int y,int depth){
              this.x=x ;
              this.y=y ;
              this.depth=depth ;
            }
          }
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := scanner.getCurrent()->toInteger() ;
    var W : int ; W := scanner.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(String)) ; map := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var i : int ; i := 0 ; while i < H do (     map[i+1] := scanner.getCurrent()->characters() ;  ;     i := i + 1 ) ; 
    var level : Sequence(Sequence(int)) ; level := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
    var queue : Sequence(Cell) ; queue := Sequence{} ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (map[i+1][j+1] = '#') then (     queue := queue->including(Cell.newCell(i, j, 0)) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    while (not(queue->isEmpty())) do (     var c : Cell ; c := queue.remove() ;
     max := Set{max, c.depth}->max() ; 
     for (df : Sequence{Sequence{-1,0},Sequence{1,0},Sequence{0,-1},Sequence{0,1}}) do ( (     var x : int ; x := c.x + df[0+1] ;
     var y : int ; y := c.y + df[1+1] ;
     if (x >= 0 & x < H & y >= 0 & y < W & map[x+1][y+1] = '.') then (     map[x+1][y+1] := '#' ; 
     queue := queue->including(Cell.newCell(x, y, c.depth + 1)) ) else skip )  ) ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static class Cell {
   attribute x : int;
   attribute y : int;
   attribute depth : int;
   static operation newCell( x : int, y : int, depth : int) : Cell
  pre: true
  post: true
  activity:
  ( var self : Cell ;
    self := createCell();
    self.initialise(x, y,depth);
    return self );
  operation initialise( x : int, y : int, depth : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y ; 
     self.depth := depth );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=Integer.parseInt(sc.next());
    int w=Integer.parseInt(sc.next());
    int cm[][]=new int[h+2][w+2];
    Deque<Integer>que=new ArrayDeque<>();
    for(int i=1 ; i<=h ; i++){
      String s=sc.next();
      for(int j=1 ; j<=w ; j++){
        if(".".equals(s.substring(j-1,j))){
          cm[i][j]=-1 ;
        }
        else {
          que.add(i);
          que.add(j);
        }
      }
    }
    sc.close();
    int ans=0 ;
    while(que.size()>0){
      int y=que.poll();
      int x=que.poll();
      ans=cm[y][x]+1 ;
      if(cm[y+1][x]==-1){
        cm[y+1][x]=ans ;
        que.add(y+1);
        que.add(x);
      }
      if(cm[y-1][x]==-1){
        cm[y-1][x]=ans ;
        que.add(y-1);
        que.add(x);
      }
      if(cm[y][x+1]==-1){
        cm[y][x+1]=ans ;
        que.add(y);
        que.add(x+1);
      }
      if(cm[y][x-1]==-1){
        cm[y][x-1]=ans ;
        que.add(y);
        que.add(x-1);
      }
    }
    System.out.println(ans-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := (sc.getCurrent())->toInteger() ;
    var w : int ; w := (sc.getCurrent())->toInteger() ;
    var cm : Sequence(Sequence(int)) ; cm := Integer.subrange(1,h + 2)->collect(Integer.subrange(1,w + 2)->collect(0)) ;
    var que : Sequence(int) ; que := ArrayDeque<OclAny>.newArrayDeque() ;
        var i : int ; i := 1 ; while i <= h do ( (     var s : String ; s := sc.getCurrent() ;
         var j : int ; j := 1 ; while j <= w do ( (     if ("." = s.subrange((j)->char2byte() - 1+1,j)) then (     cm[i+1][j+1] := -1 ) else (     que := que->including(i) ; 
     que := que->including(j) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : int ; ans := 0 ;
    while (que->size() > 0) do (     var y : int ; y := que->min() ;
     var x : int ; x := que->min() ;
    ans := cm[y+1][x+1] + 1 ; 
    if (cm[y + 1+1][x+1] = -1) then (     cm[y + 1+1][x+1] := ans ; 
     que := que->including(y + 1) ; 
     que := que->including(x) ) else skip ; 
    if (cm[y - 1+1][x+1] = -1) then (     cm[y - 1+1][x+1] := ans ; 
     que := que->including(y - 1) ; 
     que := que->including(x) ) else skip ; 
    if (cm[y+1][x + 1+1] = -1) then (     cm[y+1][x + 1+1] := ans ; 
     que := que->including(y) ; 
     que := que->including(x + 1) ) else skip ; 
    if (cm[y+1][x - 1+1] = -1) then (     cm[y+1][x - 1+1] := ans ; 
     que := que->including(y) ; 
     que := que->including(x - 1) ) else skip ; 
 ) ; 
    OclFile["System.out"].println(ans - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    char[][] A=new char[H][W];
    Queue<int[]>queue=new ArrayDeque<int[]>();
    for(int i=0 ; i<H ; i++){
      String row=sc.next();
      for(int j=0 ; j<W ; j++){
        A[i][j]=row.charAt(j);
        if(A[i][j]=='#'){
          int[] start={
            i,j,0 };
            queue.add(start);
          }
        }
      }
      int[][] flag=new int[H][W];
      int ans=0 ;
      int[] dx={
        1,-1,0,0 };
        int[] dy={
          0,0,1,-1 };
          loop : while(! queue.isEmpty()){
            int[] temp=queue.remove();
            int y=temp[0];
            int x=temp[1];
            int depth=temp[2];
            for(int i=0 ; i<4 ; i++){
              if(0<=y+dy[i] && y+dy[i]<=H-1 && 0<=x+dx[i] && x+dx[i]<=W-1){
                if(flag[y+dy[i] ][x+dx[i] ]==0 && A[y+dy[i] ][x+dx[i] ]=='.'){
                  flag[y+dy[i] ][x+dx[i] ]=1 ;
                  int[] queue_add={
                    y+dy[i],x+dx[i],depth+1 };
                    queue.add(queue_add);
                    ans=depth+1 ;
                  }
                }
              }
            }
            System.out.println(ans);
          }
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var A : Sequence(Sequence(String)) ; A := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
    var queue : Sequence(Sequence(int)) ; queue := ArrayDeque<Sequence(int)>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < H do ( (     var row : String ; row := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < W do ( (     A[i+1][j+1] := row->at(j+1) ; 
     if (A[i+1][j+1] = '#') then (     var start : Sequence(int) ; start := Sequence{i,j,0} ;
     queue := queue->including(start) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var flag : Sequence(Sequence(int)) ; flag := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
    var ans : int ; ans := 0 ;
    var dx : Sequence(int) ; dx := Sequence{1,-1,0,0} ;
    var dy : Sequence(int) ; dy := Sequence{0,0,1,-1} ;
    while (not(queue->isEmpty())) do (     var temp : Sequence(int) ; temp := queue.remove() ;
     var y : int ; y := temp[0+1] ;
    var x : int ; x := temp[1+1] ;
    var depth : int ; depth := temp[2+1] ;
        var i : int ; i := 0 ; while i < 4 do ( (     if (0 <= y + dy[i+1] & y + dy[i+1] <= H - 1 & 0 <= x + dx[i+1] & x + dx[i+1] <= W - 1) then (     if (flag[y + dy[i+1]+1][x + dx[i+1]+1] = 0 & A[y + dy[i+1]+1][x + dx[i+1]+1] = '.') then (     flag[y + dy[i+1]+1][x + dx[i+1]+1] := 1 ; 
     var queue_add : Sequence(int) ; queue_add := Sequence{y + dy[i+1],x + dx[i+1],depth + 1} ;
     queue := queue->including(queue_add) ; 
     ans := depth + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner in=new Scanner(System.in);
    long ax=in.nextLong();
    long ay=in.nextLong();
    long bx=in.nextLong();
    long by=in.nextLong();
    long cx=in.nextLong();
    long cy=in.nextLong();
    System.out.println(((bx-ax)*(cy-ay)==(cx-ax)*(by-ay))||((ax-bx)*(ax-bx)+(ay-by)*(ay-by)!=(cx-bx)*(cx-bx)+(cy-by)*(cy-by))? "No" : "Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ax : long ; ax := in.getCurrent()->toLong() ;
    var ay : long ; ay := in.getCurrent()->toLong() ;
    var bx : long ; bx := in.getCurrent()->toLong() ;
    var by : long ; by := in.getCurrent()->toLong() ;
    var cx : long ; cx := in.getCurrent()->toLong() ;
    var cy : long ; cy := in.getCurrent()->toLong() ;
    OclFile["System.out"].println(if ((bx - ax) * (cy - ay) = (cx - ax) * (by - ay)) or ((ax - bx) * (ax - bx) + (ay - by) * (ay - by) /= (cx - bx) * (cx - bx) + (cy - by) * (cy - by)) then "No" else "Yes" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] $){
    Scanner s=new Scanner(System.in);
    String v=s.next();
    long n=s.nextLong();
    for(int i=0,e=(int)Math.min(v.length(),n); i<e ; ++i){
      if(v.charAt(i)!='1'){
        System.out.println(v.charAt(i));
        return ;
      }
    }
    System.out.println('1');
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var v : String ; v := s.getCurrent() ;
    var n : long ; n := s.getCurrent()->toLong() ;
        var i : int ; i := 0 ;
    var e : int ; e := Set{v->size(), n}->min()->oclAsType(int) ; while i < e do ( (     if (v->at(i+1) /= '1') then (     OclFile["System.out"].println(v->at(i+1)) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println('1') ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class task851b {
  void run(){
    Scanner sc=new Scanner(System.in);
    long ax=sc.nextInt();
    long ay=sc.nextInt();
    long bx=sc.nextInt();
    long by=sc.nextInt();
    long cx=sc.nextInt();
    long cy=sc.nextInt();
    long ab=(bx-ax)*(bx-ax)+(by-ay)*(by-ay);
    long bc=(bx-cx)*(bx-cx)+(by-cy)*(by-cy);
    if(ab==bc &&(by-ay)*(cx-ax)!=(cy-ay)*(bx-ax)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
  public static void main(String[] args){
    new task851b().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class task851b {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ax : long ; ax := sc.getCurrent()->toInteger() ;
    var ay : long ; ay := sc.getCurrent()->toInteger() ;
    var bx : long ; bx := sc.getCurrent()->toInteger() ;
    var by : long ; by := sc.getCurrent()->toInteger() ;
    var cx : long ; cx := sc.getCurrent()->toInteger() ;
    var cy : long ; cy := sc.getCurrent()->toInteger() ;
    var ab : long ; ab := (bx - ax) * (bx - ax) + (by - ay) * (by - ay) ;
    var bc : long ; bc := (bx - cx) * (bx - cx) + (by - cy) * (by - cy) ;
    if (ab = bc & (by - ay) * (cx - ax) /= (cy - ay) * (bx - ax)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     task851b.newtask851b().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.Integer ;
import java.lang.StringBuilder ;
import java.lang.Math ;
public class Main {
  private static int N ;
  private static int W ;
  private static int[] weight ;
  private static int[] value ;
  private static int[][] dp ;
  private static int calc(){
    for(int i=1 ; i<=N ; i++){
      for(int j=1 ; j<=W ; j++){
        if(j<weight[i]){
          dp[i][j]=dp[i-1][j];
        }
        else {
          dp[i][j]=Math.max(dp[i-1][j],dp[i][j-weight[i] ]+value[i]);
        }
      }
    }
    return dp[N][W];
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    N=in.nextInt();
    W=in.nextInt();
    value=new int[N+1];
    weight=new int[N+1];
    value[0]=0 ;
    weight[0]=0 ;
    for(int i=1 ; i<=N ; i++){
      value[i]=in.nextInt();
      weight[i]=in.nextInt();
    }
    dp=new int[N+1][W+1];
    for(int i=0 ; i<=N ; i++){
      dp[i][0]=0 ;
    }
    for(int j=0 ; j<=W ; j++){
      dp[0][j]=0 ;
    }
    int result=calc();
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute W : int;
  static   attribute weight : Sequence(int);
  static   attribute value : Sequence(int);
  static   attribute dp : Sequence(Sequence(int));
  static   operation calc() : int
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := 1 ; while j <= W do ( (     if (j < weight[i+1]) then (     dp[i+1][j+1] := dp[i - 1+1][j+1] ) else (     dp[i+1][j+1] := Set{dp[i - 1+1][j+1], dp[i+1][j - weight[i+1]+1] + value[i+1]}->max() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return dp[N+1][W+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := in.getCurrent()->toInteger() ; 
    W := in.getCurrent()->toInteger() ; 
    value := Integer.subrange(1,N + 1)->collect(0) ; 
    weight := Integer.subrange(1,N + 1)->collect(0) ; 
    value[0+1] := 0 ; 
    weight[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= N do ( (     value[i+1] := in.getCurrent()->toInteger() ; 
     weight[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,W + 1)->collect(0)) ; 
        var i : int ; i := 0 ; while i <= N do ( (     dp[i+1][0+1] := 0 )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j <= W do ( (     dp[0+1][j+1] := 0 )  ;     j := j + 1 ) ; 
    var result : int ; result := calc() ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.regex.*;
public class vk18 {
  public static void main(String[] stp)throws Exception {
    Scanner scan=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    long ax=Long.parseLong(st.nextToken()),ay=Long.parseLong(st.nextToken()),bx=Long.parseLong(st.nextToken()),by=Long.parseLong(st.nextToken()),cx=Long.parseLong(st.nextToken()),cy=Long.parseLong(st.nextToken());
    if(ax-bx==bx-cx && ay-by==by-cy)pw.write("No");
    else {
      if((ax-bx)*(ax-bx)+(ay-by)*(ay-by)==(bx-cx)*(bx-cx)+(by-cy)*(by-cy))pw.write("Yes");
      else pw.write("No");
    }
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class vk18 {
  static   operation main( stp : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var ax : long ; ax := (st.next())->toLong() ;
    var ay : long ; ay := (st.next())->toLong() ;
    var bx : long ; bx := (st.next())->toLong() ;
    var by : long ; by := (st.next())->toLong() ;
    var cx : long ; cx := (st.next())->toLong() ;
    var cy : long ; cy := (st.next())->toLong() ;
    if (ax - bx = bx - cx & ay - by = by - cy) then     skip else (     if ((ax - bx) * (ax - bx) + (ay - by) * (ay - by) = (bx - cx) * (bx - cx) + (by - cy) * (by - cy)) then     skip ; else     skip ; ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMinDel(int[] arr,int n){
    int min_num=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++)min_num=Math.min(arr[i],min_num);
    int cnt=0 ;
    for(int i=0 ; i<n ; i++)if(arr[i]==min_num)cnt++;
    return n-cnt ;
  }
  public static void main(String[] args){
    int arr[]={
      3,3,2 };
      int n=arr.length ;
      System.out.print(findMinDel(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMinDel( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var min_num : int ; min_num := 2147483647 ;
         var i : int ; i := 0 ; while i < n do (     min_num := Set{arr[i+1], min_num}->min() ;  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (arr[i+1] = min_num) then     cnt := cnt + 1 ; else skip ;  ;     i := i + 1 ) ; 
    return n - cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,3,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(findMinDel(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int count(int x,int y){
    int ans=0 ;
    Map<Integer,Integer>m=new HashMap<>();
    while(x % y!=0){
      x=x % y ;
      ans++;
      if(m.containsKey(x))return-1 ;
      m.put(x,1);
      x=x*10 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int res=count(1,2);
    if((res==-1))System.out.println("INF");
    else System.out.println(res);
    res=count(5,3);
    if((res==-1))System.out.println("INF");
    else System.out.println(res);
    res=count(3,5);
    if((res==-1))System.out.println("INF");
    else System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var m : Map(int,int) ; m := Map{} ;
     while (x mod y /= 0) do (     x := x mod y ; 
     ans := ans + 1 ; 
    if (m->keys()->includes(x)) then     return -1 else skip ; 
    m := m->union(Map{x |-> 1}) ; 
    x := x * 10 ; 
 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var res : int ; res := count(1, 2) ;
     if ((res = -1)) then     OclFile["System.out"].println("INF") else     OclFile["System.out"].println(res) ; ;  
    res := count(5, 3) ; 
    if ((res = -1)) then     OclFile["System.out"].println("INF") else     OclFile["System.out"].println(res) ; ;  
    res := count(3, 5) ; 
    if ((res = -1)) then     OclFile["System.out"].println("INF") else     OclFile["System.out"].println(res) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  public static boolean isPossibleToMakeDivisible(int arr[],int n){
    int remainder=0 ;
    for(int i=0 ; i<n ; i++)remainder=(remainder+arr[i])% 3 ;
    return(remainder==0);
  }
  public static void main(String[] args){
    int arr[]={
      40,50,90 };
      int n=3 ;
      if(isPossibleToMakeDivisible(arr,n))System.out.print("Yes\n");
      else System.out.print("No\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPossibleToMakeDivisible( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var remainder : int ; remainder := 0 ;
         var i : int ; i := 0 ; while i < n do (     remainder := (remainder + arr[i+1]) mod 3 ;  ;     i := i + 1 ) ; 
     return (remainder = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{40,50,90} ;
     var n : int ; n := 3 ;
     if (isPossibleToMakeDivisible(arr, n)) then     OclFile["System.out"].print("Yes\n") ; else     OclFile["System.out"].print("No\n") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  private static int N,K ;
  private static List<Integer>[] vec ;
  private static int ans ;
  public static void main(String args[]){
    new Thread(null,()->{
      Scanner sc=new Scanner(System.in);
      N=sc.nextInt();
      K=sc.nextInt();
      ans=0 ;
      vec=new ArrayList[N];
      for(int i=0 ; i<N ; i++){
        vec[i]=new ArrayList<>(0);
      }
      for(int i=0 ; i<N ; i++){
        int a=sc.nextInt()-1 ;
        if(i!=0){
          vec[a] .add(i);
        }
        else {
          if(a!=0){
            ans++;
          }
        }
      }
      dfs(0,0);
      System.out.println(ans);
    },"",1<<24).start();
  }
  private static int dfs(int v,int pre){
    int hight=0 ;
    for(int j=0 ; j<vec[v] .size(); j++){
      hight=Math.max(hight,dfs(vec[v] .get(j),v));
    }
    if(pre!=0 && hight==K-1){
      hight=0 ;
      ans++;
    }
    else {
      hight++;
    }
    return hight ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute vec : Sequence(Sequence(int));
  static   attribute ans : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(null, (lambdaParameters ( )) (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
    K := sc.getCurrent()->toInteger() ; 
    ans := 0 ; 
    vec := Integer.subrange(1,N)->collect(null) ; 
        var i : int ; i := 0 ; while i < N do ( (     vec[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
     if (i /= 0) then (     vec[a+1]->excludes(i) ) else (     if (a /= 0) then (     ans := ans + 1 ) else skip ) )  ;     i := i + 1 ) ; 
    execute dfs(0, 0) ; 
    OclFile["System.out"].println(ans) ; 
 ), "", (1*(2->pow(24)))->oclAsType(long)).start() );
  static   operation dfs( v : int, pre : int) : int
  pre: true
  post: true
  activity: (     var hight : int ; hight := 0 ;
         var j : int ; j := 0 ; while j < vec[v+1]->size() do ( (     hight := Set{hight, dfs(vec[v+1]->at(j+1), v)}->max() )  ;     j := j + 1 ) ; 
     if (pre /= 0 & hight = K - 1) then (     hight := 0 ; 
     ans := ans + 1 ) else (     hight := hight + 1 ) ;  
     return hight );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.StringTokenizer ;
public class Main implements Runnable {
  int ans,k ;
  List<Integer>[] r ;
  int dfs(int q,int p){
    int h=0 ;
    for(int w : r[q]){
      h=Math.max(h,dfs(w,q)+1);
    }
    if(h==k-1 && p!=0){
      ans++;
      h=-1 ;
    }
    return h ;
  }
  void solve()throws IOException {
    int n=nextInt();
    k=nextInt();
    r=new List[n];
    for(int i=0 ; i<n ; i++)r[i]=new ArrayList<>();
    ans=0 ;
    for(int i=0 ; i<n ; i++){
      int q=nextInt();
      if(i!=0)r[q-1] .add(i);
      else if(q!=1)ans++;
    }
    dfs(0,0);
    out.println(ans);
  }
  public static void main(String[] args){
    new Thread(null,new Main(),"name",1<<27).start();
  }
  @ Override public void run(){
    try {
      solve();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
    finally {
      out.close();
    }
  }
  BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  PrintWriter out=new PrintWriter(System.out);
  StringTokenizer st ;
  String nextToken()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(in.readLine());
    return st.nextToken();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
   attribute ans : int;
   attribute r : Sequence(Sequence(int));
   operation dfs( q : int, p : int) : int
  pre: true
  post: true
  activity: (     var h : int ; h := 0 ;
     for (w : r[q+1]) do ( (     h := Set{h, dfs(w, q) + 1}->max() )  ) ; 
     if (h = k - 1 & p /= 0) then (     ans := ans + 1 ; 
     h := -1 ) else skip ; 
     return h );
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     k := nextInt() ; 
    r := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do (     r[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
    ans := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     var q : int ; q := nextInt() ;
     if (i /= 0) then     r[q - 1+1]->excludes(i) ; else     if (q /= 1) then     ans := ans + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    execute dfs(0, 0) ; 
    out.println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(null, Main.newMain(), "name", (1*(2->pow(27)))->oclAsType(long)).start() );
      operation run() : void
  pre: true
  post: true
  activity: (     try (     execute solve() )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
   finally (     out.close() )
 );
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   attribute st : OclIterator;
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(in.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    new Thread(null,()->{
      int n ;
      int k ;
      List<Integer>as=new ArrayList<>();
      try(Scanner sc=new Scanner(System.in)){
        n=sc.nextInt();
        k=sc.nextInt();
        for(int i=0 ; i<n ; i++){
          as.add(sc.nextInt()-1);
        }
      }
      System.out.println(new Calculator(n,k,as).calculate());
    },"",1<<27).start();
  }
}
class Calculator {
  private int k ;
  private int answer=0 ;
  private boolean isCalculate=false ;
  private List<List<Integer>>lists=new ArrayList<>();
  Calculator(int n,int k,List<Integer>as){
    this.k=k ;
    for(int i=0 ; i<n ; i++){
      this.lists.add(new ArrayList<>());
    }
    for(int i=0 ; i<n ; i++){
      int j=as.get(i);
      if(0<i){
        this.lists.get(j).add(i);
      }
      else if(0<j){
        this.answer++;
      }
    }
  }
  int calculate(){
    if(! this.isCalculate){
      this.dfs(0,0);
      this.isCalculate=true ;
    }
    return this.answer ;
  }
  private int dfs(int a,int pre){
    int h=0 ;
    for(int i : this.lists.get(a)){
      h=Math.max(h,this.dfs(i,a));
    }
    if(0<pre && h==this.k-1){
      h=0 ;
      this.answer++;
    }
    else {
      h++;
    }
    return h ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(null, (lambdaParameters ( )) (     var n : int ;
     var k : int ;
    var as : Sequence(int) ; as := Sequence{} ;
    try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     n := sc.getCurrent()->toInteger() ; 
     k := sc.getCurrent()->toInteger() ; 
         var i : int ; i := 0 ; while i < n do ( (     as := as->including(sc.getCurrent()->toInteger() - 1) )  ;     i := i + 1 ) ))  
    OclFile["System.out"].println(Calculator.newCalculator(n, k, as).calculate()) ; 
 ), "", (1*(2->pow(27)))->oclAsType(long)).start() );
}
class Calculator {
   attribute k : int;
   attribute answer : int := 0;
   attribute isCalculate : boolean := false;
   attribute lists : Sequence(Sequence(int)) := Sequence{};
   static operation newCalculator( n : int, k : int, as : Sequence(int)) : Calculator
  pre: true
  post: true
  activity:
  ( var self : Calculator ;
    self := createCalculator();
    self.initialise(n, k,as);
    return self );
  operation initialise( n : int, k : int, as : Sequence(int)) : void
  pre: true  post: true
  activity: (     self.k := k ; 
         var i : int ; i := 0 ; while i < n do ( (     self.lists->excludes(Sequence{}) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     var j : int ; j := as->at(i+1) ;
     if (0 < i) then (     self.lists->at(j+1)->excludes(i) ) else     if (0 < j) then (     self.answer := self.answer + 1 ) else skip ; )  ;     i := i + 1 ) );
   operation calculate() : int
  pre: true
  post: true
  activity: (     if (not(self.isCalculate)) then (     self.dfs(0, 0) ; 
     self.isCalculate := true ) else skip ; 
     return self.answer );
   operation dfs( a : int, pre : int) : int
  pre: true
  post: true
  activity: (     var h : int ; h := 0 ;
     for (i : self.lists->at(a+1)) do ( (     h := Set{h, self.dfs(i, a)}->max() )  ) ; 
     if (0 < pre & h = self.k - 1) then (     h := 0 ; 
     self.answer := self.answer + 1 ) else (     h := h + 1 ) ;  
     return h );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileNotFoundException ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main implements Runnable {
  public static void main(String[] args)throws FileNotFoundException {
    new Thread(null,new Main(),"",Runtime.getRuntime().maxMemory()).start();
  }
  public void run(){
    input();
  }
  void input(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; ++i){
      a[i]=sc.nextInt();
--a[i];
    }
    solver(n,k,a);
  }
  int ans=0 ;
  void solver(int n,int k,int[] a){
    ArrayList<Integer>[] g=new ArrayList[n];
    for(int i=0 ; i<g.length ; ++i)g[i]=new ArrayList<>();
    for(int i=1 ; i<n ; ++i){
      g[a[i] ] .add(i);
    }
    if(a[0]!=0){
++ans ;
      a[0]=0 ;
    }
    depth=new int[n];
    dfs(0,-1,g,k);
    System.out.println(ans);
  }
  int[] depth ;
  void dfs(int cur,int par,ArrayList<Integer>[] g,int K){
    depth[cur]=0 ;
    for(int dst : g[cur]){
      dfs(dst,cur,g,K);
      depth[cur]=Math.max(depth[dst]+1,depth[cur]);
    }
    if(depth[cur]==K-1 && par!=0 && cur!=0){
++ans ;
      depth[cur]=-1 ;
    }
  }
  static void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(null, Main.newMain(), "", Runtime.getRuntime().maxMemory()).start() );
   operation run() : void
  pre: true
  post: true
  activity: (     execute input() );
   operation input() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     a[i+1] := a[i+1] - 1 )  ;     i := i + 1 ) ; 
    execute solver(n, k, a) ; 
 );
   attribute ans : int := 0;
   operation solver( n : int, k : int, a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var g : Sequence(Sequence(int)) ; g := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < g->size() do (     g[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     g[a[i+1]+1]->excludes(i) )  ;     i := i + 1 ) ; 
    if (a[0+1] /= 0) then (     ans := ans + 1 ; 
     a[0+1] := 0 ) else skip ; 
    depth := Integer.subrange(1,n)->collect(0) ; 
    execute dfs(0, -1, g, k) ; 
    OclFile["System.out"].println(ans) ; 
 );
   attribute depth : Sequence(int);
   operation dfs( cur : int, par : int, g : Sequence(Sequence(int)), K : int) : void
  pre: true
  post: true
  activity: (     depth[cur+1] := 0 ; 
     for (dst : g[cur+1]) do ( (     execute dfs(dst, cur, g, K) ; 
     depth[cur+1] := Set{depth[dst+1] + 1, depth[cur+1]}->max() )  ) ; 
     if (depth[cur+1] = K - 1 & par /= 0 & cur /= 0) then (     ans := ans + 1 ; 
     depth[cur+1] := -1 ) else skip );
  static   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    new Thread(null,new MyRunnable(),"",1<<26).start();
  }
}
class MyRunnable implements Runnable {
  @ Override public void run(){
    int n ;
    int k ;
    List<Integer>as=new ArrayList<>();
    try(Scanner sc=new Scanner(System.in)){
      n=sc.nextInt();
      k=sc.nextInt();
      for(int i=0 ; i<n ; i++){
        as.add(sc.nextInt()-1);
      }
    }
    System.out.println(new Calculator(n,k,as).calculate());
  }
}
class Calculator {
  private int k ;
  private int answer=0 ;
  private boolean isCalculate=false ;
  private List<List<Integer>>lists=new ArrayList<>();
  Calculator(int n,int k,List<Integer>as){
    this.k=k ;
    for(int i=0 ; i<n ; i++){
      this.lists.add(new ArrayList<>());
    }
    for(int i=0 ; i<n ; i++){
      int j=as.get(i);
      if(0<i){
        this.lists.get(j).add(i);
      }
      else if(0<j){
        this.answer++;
      }
    }
  }
  int calculate(){
    if(! this.isCalculate){
      this.dfs(0,0);
      this.isCalculate=true ;
    }
    return this.answer ;
  }
  private int dfs(int a,int pre){
    int h=0 ;
    for(int i : this.lists.get(a)){
      h=Math.max(h,this.dfs(i,a));
    }
    if(0<pre && h==this.k-1){
      h=0 ;
      this.answer++;
    }
    else {
      h++;
    }
    return h ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(null, MyRunnable.newMyRunnable(), "", (1*(2->pow(26)))->oclAsType(long)).start() );
}
class MyRunnable implements Runnable {
      operation run() : void
  pre: true
  post: true
  activity: (     var n : int ;
     var k : int ;
    var as : Sequence(int) ; as := Sequence{} ;
    try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     n := sc.getCurrent()->toInteger() ; 
     k := sc.getCurrent()->toInteger() ; 
         var i : int ; i := 0 ; while i < n do ( (     as := as->including(sc.getCurrent()->toInteger() - 1) )  ;     i := i + 1 ) ))  
    OclFile["System.out"].println(Calculator.newCalculator(n, k, as).calculate()) ; 
 );
}
class Calculator {
   attribute k : int;
   attribute answer : int := 0;
   attribute isCalculate : boolean := false;
   attribute lists : Sequence(Sequence(int)) := Sequence{};
   static operation newCalculator( n : int, k : int, as : Sequence(int)) : Calculator
  pre: true
  post: true
  activity:
  ( var self : Calculator ;
    self := createCalculator();
    self.initialise(n, k,as);
    return self );
  operation initialise( n : int, k : int, as : Sequence(int)) : void
  pre: true  post: true
  activity: (     self.k := k ; 
         var i : int ; i := 0 ; while i < n do ( (     self.lists->excludes(Sequence{}) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     var j : int ; j := as->at(i+1) ;
     if (0 < i) then (     self.lists->at(j+1)->excludes(i) ) else     if (0 < j) then (     self.answer := self.answer + 1 ) else skip ; )  ;     i := i + 1 ) );
   operation calculate() : int
  pre: true
  post: true
  activity: (     if (not(self.isCalculate)) then (     self.dfs(0, 0) ; 
     self.isCalculate := true ) else skip ; 
     return self.answer );
   operation dfs( a : int, pre : int) : int
  pre: true
  post: true
  activity: (     var h : int ; h := 0 ;
     for (i : self.lists->at(a+1)) do ( (     h := Set{h, self.dfs(i, a)}->max() )  ) ; 
     if (0 < pre & h = self.k - 1) then (     h := 0 ; 
     self.answer := self.answer + 1 ) else (     h := h + 1 ) ;  
     return h );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      String s=sc.next();
      long k=Long.parseLong(sc.next());
      int loopOne=0 ;
      String notOne="" ;
      for(int i=0 ; i<s.length(); i++){
        String subS=s.substring(i,i+1);
        if(! subS.equals("1")){
          notOne=subS ;
          break ;
        }
        loopOne++;
      }
      if(k<=loopOne)System.out.println(1);
      else System.out.println(notOne);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var s : String ; s := sc.getCurrent() ;
     var k : long ; k := (sc.getCurrent())->toLong() ;
    var loopOne : int ; loopOne := 0 ;
    var notOne : String ; notOne := "" ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var subS : String ; subS := s.subrange(i+1,i + 1) ;
     if (not(subS = "1")) then (     notOne := subS ; 
     break ) else skip ; 
     loopOne := loopOne + 1 )  ;     i := i + 1 ) ; 
    if (k <= loopOne) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println(notOne) ; ;  
 ))   catch (e : ProgramException) do (     e.printStackTrace() )
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static boolean dfs(Long sum,int count,Long n,int a,int b){
    if(a==b && sum>=n){
      System.out.println(sum);
      System.exit(0);
    }
    if(a<count){
      dfs(sum*10+4,count,n,a+1,b);
    }
    if(b<count){
      dfs(sum*10+7,count,n,a,b+1);
    }
    return false ;
  }
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String val=input.next();
    Long n=Long.valueOf(val);
    Long sum=new Long(0);
    for(int i=1 ; i<=10 ; i++){
      dfs(sum,i,n,0,0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation dfs( sum : long, count : int, n : long, a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     if (a = b & sum >= n) then (     OclFile["System.out"].println(sum) ; 
 OclProcess.exit(0) ) else skip ; 
     if (a < count) then (     execute dfs(sum * 10 + 4, count, n, a + 1, b) ) else skip ; 
     if (b < count) then (     execute dfs(sum * 10 + 7, count, n, a, b + 1) ) else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var val : String ; val := input.getCurrent() ;
    var n : long ; n := (val)->toLong() ;
    var sum : long ; sum := ("" + (0))->toLong() ;
        var i : int ; i := 1 ; while i <= 10 do ( (     execute dfs(sum, i, n, 0, 0) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static void printCubes(int a,int b){
    for(int i=a ; i<=b ; i++){
      for(int j=1 ; j*j*j<=i ; j++){
        if(j*j*j==i){
          System.out.print(j*j*j+"  ");
          break ;
        }
      }
    }
  }
  public static void main(String[] args){
    int a=1,b=100 ;
    System.out.println("Perfect cubes in given range:");
    printCubes(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation printCubes( a : int, b : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := a ; while i <= b do ( (         var j : int ; j := 1 ; while j * j * j <= i do ( (     if (j * j * j = i) then (     OclFile["System.out"].print(j * j * j + "  ") ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 1 ;
    var b : int ; b := 100 ;
     OclFile["System.out"].println("Perfect cubes in given range:") ; 
     execute printCubes(a, b) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getModulo(int n,int d){
    return(n &(d-1));
  }
  public static void main(String[] args){
    int n=6 ;
    int d=4 ;
    System.out.println(n+" moduo "+d+" is "+getModulo(n,d));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getModulo( n : int, d : int) : int
  pre: true
  post: true
  activity: (     return (n & (d - 1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     var d : int ; d := 4 ;
     OclFile["System.out"].println(n + " moduo " + d + " is " + getModulo(n, d)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class pre598 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int n=obj.nextInt(),d=obj.nextInt(),arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=obj.nextInt();
    Arrays.sort(arr);
    int max=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      int count=0,l=arr[i]+d ;
      for(int j=i ; j<n ; j++){
        if(l<arr[j])break ;
        count++;
      }
      max=Math.max(max,count);
    }
    System.out.println(n-max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre598 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var n : int ; n := obj.nextInt() ;
    var d : int ; d := obj.nextInt() ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := obj.nextInt() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var max : int ; max := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     var count : int ; count := 0 ;
    var l : int ; l := arr[i+1] + d ;
         var j : int ; j := i ; while j < n do ( (     if (l < arr[j+1]) then     break else skip ; 
     count := count + 1 )  ;     j := j + 1 ) ; 
     max := Set{max, count}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n - max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class file {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int d=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    Arrays.sort(arr);
    int p1=0 ;
    int p2=0 ;
    int res=0 ;
    while(p1<n && p2<n){
      while(p2<n && arr[p2]<=d+arr[p1])p2++;
      res=Math.max(res,p2-p1);
      p1++;
      p2=p1 ;
    }
    if(n==1)System.out.println(0);
    else System.out.println(n-res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class file {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var p1 : int ; p1 := 0 ;
    var p2 : int ; p2 := 0 ;
    var res : int ; res := 0 ;
    while (p1 < n & p2 < n) do (     while (p2 < n & arr[p2+1] <= d + arr[p1+1]) do     p2 := p2 + 1 ; ; 
     res := Set{res, p2 - p1}->max() ; 
     p1 := p1 + 1 ; 
     p2 := p1 ) ; 
    if (n = 1) then     OclFile["System.out"].println(0) else     OclFile["System.out"].println(n - res) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int d=s.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=s.nextInt();
    }
    Arrays.sort(arr);
    int ans=n-1 ;
    for(int i=0 ; i<n ; i++){
      int start=i,end=n-1,index=i ;
      while(start<=end){
        int mid=(start+end)/2 ;
        if(arr[mid]<=arr[i]+d){
          index=mid ;
          start=mid+1 ;
        }
        else {
          end=mid-1 ;
        }
      }
      if(index>i){
        int rem=n-(index-i+1);
        ans=Math.min(ans,rem);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var d : int ; d := s.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var ans : int ; ans := n - 1 ;
        var i : int ; i := 0 ; while i < n do ( (     var start : int ; start := i ;
    var end : int ; end := n - 1 ;
    var index : int ; index := i ;
     while (start <= end) do (     var mid : int ; mid := (start + end) / 2 ;
     if (arr[mid+1] <= arr[i+1] + d) then (     index := mid ; 
     start := mid + 1 ) else (     end := mid - 1 ) ) ; 
     if (index > i) then (     var rem : int ; rem := n - (index - i + 1) ;
     ans := Set{ans, rem}->min() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Code {
  static BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
  static StringTokenizer st ;
  static PrintWriter pr=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  public static void main(String[] args)throws IOException {
    int n=readInt(),d=readInt(),arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=readInt();
    }
    int ans=0 ;
    Arrays.sort(arr);
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(arr[i]-arr[j]<=d){
          ans=Math.max(ans,i-j);
        }
      }
    }
    println(n-ans-1);
  }
  static String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(input.readLine().trim());
    return st.nextToken();
  }
  static long readLong()throws IOException {
    return Long.parseLong(next());
  }
  static int readInt()throws IOException {
    return Integer.parseInt(next());
  }
  static double readDouble()throws IOException {
    return Double.parseDouble(next());
  }
  static char readChar()throws IOException {
    return next().charAt(0);
  }
  static String readLine()throws IOException {
    return input.readLine().trim();
  }
  static void print(Object b){
    System.out.print(b);
  }
  static void println(Object b){
    System.out.println(b);
  }
  static void println(){
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code {
  static   attribute input : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute st : OclIterator;
  static   attribute pr : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := readInt() ;
    var d : int ; d := readInt() ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := readInt() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (arr[i+1] - arr[j+1] <= d) then (     ans := Set{ans, i - j}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    execute println(n - ans - 1) ; 
 );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(input.readLine()->trim()) ; ; 
     return st.next() );
  static   operation readLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation readInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation readDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation readChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
  static   operation readLine() : String
  pre: true
  post: true
  activity: (     return input.readLine()->trim() );
  static   operation print( b : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(b) );
  static   operation println( b : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(b) );
  static   operation println() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
public class CodeForce {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    String sr=br.readLine();
    String ss=sr.substring(0,sr.length()-1);
    char ch=sr.charAt(sr.length()-1);
    ArrayList<Character>list=new ArrayList<Character>();
    list.add('f');
    list.add('e');
    list.add('d');
    list.add('a');
    list.add('b');
    list.add('c');
    Long x=Long.parseLong(ss);
    long m=x % 2 ;
    long k=(x-1)/4 ;
    long re=x-k ;
    long total=0l ;
    total=16*k ;
    if(m==0){
      total+=7+list.indexOf(ch)+1 ;
    }
    if(m==1){
      total+=list.indexOf(ch)+1 ;
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForce {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var sr : String ; sr := br.readLine() ;
    var ss : String ; ss := sr.subrange(0+1,sr->size() - 1) ;
    var ch : String ; ch := sr->at(sr->size() - 1+1) ;
    var list : Sequence(String) ; list := Sequence{} ;
    list := list->including('f') ; 
    list := list->including('e') ; 
    list := list->including('d') ; 
    list := list->including('a') ; 
    list := list->including('b') ; 
    list := list->including('c') ; 
    var x : long ; x := (ss)->toLong() ;
    var m : long ; m := x mod 2 ;
    var k : long ; k := (x - 1) / 4 ;
    var re : long ; re := x - k ;
    var total : long ; total := 0l ;
    total := 16 * k ; 
    if (m = 0) then (     total := total+(7 + list->indexOf(ch)-1 + 1) ) else skip ; 
    if (m = 1) then (     total := total+(list->indexOf(ch)-1 + 1) ) else skip ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B725 {
  public static void main(String[] args){
    int fullRoundTime=16 ;
    int halfRoundTime=7 ;
    Scanner in=new Scanner(System.in);
    String seat=in.next();
    long row=Long.parseLong(seat.substring(0,seat.length()-1))-1 ;
    char posInRow=seat.charAt(seat.length()-1);
    long fullRounds=row/4 ;
    boolean halfRound=((row % 2)==1);
    int timeInRow="fedabc".indexOf(posInRow)+1 ;
    long answer=fullRoundTime*fullRounds+(halfRound ? halfRoundTime : 0)+timeInRow ;
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B725 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fullRoundTime : int ; fullRoundTime := 16 ;
     var halfRoundTime : int ; halfRoundTime := 7 ;
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var seat : String ; seat := in.getCurrent() ;
    var row : long ; row := (seat.subrange(0+1,seat->size() - 1))->toLong() - 1 ;
    var posInRow : String ; posInRow := seat->at(seat->size() - 1+1) ;
    var fullRounds : long ; fullRounds := row / 4 ;
    var halfRound : boolean ; halfRound := ((row mod 2) = 1) ;
    var timeInRow : int ; timeInRow := "fedabc"->indexOf(posInRow)-1 + 1 ;
    var answer : long ; answer := fullRoundTime * fullRounds + (if halfRound then halfRoundTime else 0 endif) + timeInRow ;
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.HashSet ;
public class subset {
  static Scanner scn=new Scanner(System.in);
  public static void main(String[] args){
    String str=scn.next();
    char ch=str.charAt(str.length()-1);
    long n=Long.valueOf(str.substring(0,str.length()-1));
    long tot=0 ;
    if(n % 4==1 || n % 4==2){
      long cunt=n/2 ;
      tot=6*cunt+n-1 ;
      if(ch=='f')tot+=1 ;
      if(ch=='e')tot+=2 ;
      if(ch=='d')tot+=3 ;
      if(ch=='a')tot+=4 ;
      if(ch=='b')tot+=5 ;
      if(ch=='c')tot+=6 ;
    }
    else if(n % 4==3 || n % 4==0){
      long cunt=(n-2)/2 ;
      tot=6*cunt+n-3 ;
      if(ch=='f')tot+=1 ;
      if(ch=='e')tot+=2 ;
      if(ch=='d')tot+=3 ;
      if(ch=='a')tot+=4 ;
      if(ch=='b')tot+=5 ;
      if(ch=='c')tot+=6 ;
    }
    System.out.println(tot);
  }
}
------------------------------------------------------------
OCL File:
---------
 class subset {
  static   attribute scn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := scn.getCurrent() ;
     var ch : String ; ch := str->at(str->size() - 1+1) ;
    var n : long ; n := (str.subrange(0+1,str->size() - 1))->toLong() ;
    var tot : long ; tot := 0 ;
    if (n mod 4 = 1 or n mod 4 = 2) then (     var cunt : long ; cunt := n / 2 ;
     tot := 6 * cunt + n - 1 ; 
    if (ch = 'f') then     tot := tot+(1) ; else skip ; 
    if (ch = 'e') then     tot := tot+(2) ; else skip ; 
    if (ch = 'd') then     tot := tot+(3) ; else skip ; 
    if (ch = 'a') then     tot := tot+(4) ; else skip ; 
    if (ch = 'b') then     tot := tot+(5) ; else skip ; 
    if (ch = 'c') then     tot := tot+(6) ; else skip ; 
 ) else     if (n mod 4 = 3 or n mod 4 = 0) then (     var cunt : long ; cunt := ((n)->char2byte() - 2) / 2 ;
     tot := 6 * cunt + n - 3 ; 
    if (ch = 'f') then     tot := tot+(1) ; else skip ; 
    if (ch = 'e') then     tot := tot+(2) ; else skip ; 
    if (ch = 'd') then     tot := tot+(3) ; else skip ; 
    if (ch = 'a') then     tot := tot+(4) ; else skip ; 
    if (ch = 'b') then     tot := tot+(5) ; else skip ; 
    if (ch = 'c') then     tot := tot+(6) ; else skip ; 
 ) else skip ; ;  
    OclFile["System.out"].println(tot) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class FoodOnThePlane {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String seat=sc.nextLine();
    sc.close();
    long num=Long.parseLong(seat.substring(0,seat.length()-1))-1 ;
    char letter=seat.charAt(seat.length()-1);
    int ans=0 ;
    switch(letter){
      case 'f' : ans=1 ;
      break ;
      case 'e' : ans=2 ;
      break ;
      case 'd' : ans=3 ;
      break ;
      case 'a' : ans=4 ;
      break ;
      case 'b' : ans=5 ;
      break ;
      case 'c' : ans=6 ;
      break ;
    }
    System.out.println(ans+((num/4)*16)+((num % 2)*7));
  }
}
------------------------------------------------------------
OCL File:
---------
 class FoodOnThePlane {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var seat : String ; seat := sc.nextLine() ;
    skip ; 
    var num : long ; num := (seat.subrange(0+1,seat->size() - 1))->toLong() - 1 ;
    var letter : String ; letter := seat->at(seat->size() - 1+1) ;
    var ans : int ; ans := 0 ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (letter) ; 
       if _switchval = 'f' then
     ans := 1 ; 
    break 
   else skip ;
       if _switchval = 'e' then
     ans := 2 ; 
    break 
   else skip ;
       if _switchval = 'd' then
     ans := 3 ; 
    break 
   else skip ;
       if _switchval = 'a' then
     ans := 4 ; 
    break 
   else skip ;
       if _switchval = 'b' then
     ans := 5 ; 
    break 
   else skip ;
       if _switchval = 'c' then
     ans := 6 ; 
    break 
   else skip ;
 )
    OclFile["System.out"].println(ans + ((num / 4) * 16) + ((num mod 2) * 7)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    AizuKnapsackWithRepetitions solver=new AizuKnapsackWithRepetitions();
    solver.solve(1,in,out);
    out.close();
  }
  static class AizuKnapsackWithRepetitions {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int w=in.nextInt();
      int[] vs=new int[n];
      int[] ws=new int[n];
      for(int i=0 ; i<n ; i++){
        vs[i]=in.nextInt();
        ws[i]=in.nextInt();
      }
      out.printf("%d\n",knapsack(w,vs,ws,n));
    }
    private int knapsack(int w,int[] vs,int[] ws,int n){
      int[] dp=new int[w+1];
      for(int i=1 ; i<w+1 ; i++){
        for(int j=0 ; j<n ; j++){
          if(i>=ws[j]){
            dp[i]=Math.max(dp[i],vs[j]+dp[i-ws[j] ]);
          }
        }
      }
      return dp[w];
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : AizuKnapsackWithRepetitions ; solver := AizuKnapsackWithRepetitions.newAizuKnapsackWithRepetitions() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class AizuKnapsackWithRepetitions {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var w : int ; w := in.getCurrent()->toInteger() ;
    var vs : Sequence(int) ; vs := Integer.subrange(1,n)->collect(0) ;
    var ws : Sequence(int) ; ws := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     vs[i+1] := in.getCurrent()->toInteger() ; 
     ws[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation knapsack( w : int, vs : Sequence(int), ws : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,w + 1)->collect(0) ;
         var i : int ; i := 1 ; while i < w + 1 do ( (         var j : int ; j := 0 ; while j < n do ( (     if (i >= ws[j+1]) then (     dp[i+1] := Set{dp[i+1], vs[j+1] + dp[i - ws[j+1]+1]}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return dp[w+1] );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.math.MathContext ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String s=scanner.next();
    long k=scanner.nextLong();
    for(int i=0 ; i<s.length(); ++i){
      int a=Integer.valueOf(s.substring(i,i+1));
      if(a!=1){
        System.out.println(a);
        return ;
      }
      else if(k-1==i){
        System.out.println(a);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scanner.getCurrent() ;
     var k : long ; k := scanner.getCurrent()->toLong() ;
         var i : int ; i := 0 ; while i < s->size() do ( (     var a : int ; a := (s.subrange(i+1,i + 1))->toInteger() ;
     if (a /= 1) then (     OclFile["System.out"].println(a) ; 
     return ) else     if ((k)->char2byte() - 1 = i) then (     OclFile["System.out"].println(a) ; 
     return ) else skip ; )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPerfectCube(int x){
    int cr=(int)Math.cbrt(x);
    return(cr*cr*cr==x);
  }
  static void canBePerfectCube(int N,int K){
    if(isPerfectCube(N+K)|| isPerfectCube(N-K)==true)System.out.println("Yes");
    else System.out.println("No");
  }
  public static void main(String[] args){
    int N=7 ;
    int K=1 ;
    canBePerfectCube(N,K);
    N=5 ;
    K=4 ;
    canBePerfectCube(N,K);
    N=7 ;
    K=2 ;
    canBePerfectCube(N,K);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPerfectCube( x : int) : boolean
  pre: true
  post: true
  activity: (     var cr : int ; cr := (x)->cbrt()->oclAsType(int) ;
     return (cr * cr * cr = x) );
  static   operation canBePerfectCube( N : int, K : int) : void
  pre: true
  post: true
  activity: (     if (isPerfectCube(N + K) or isPerfectCube(N - K) = true) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 7 ;
     var K : int ; K := 1 ;
    execute canBePerfectCube(N, K) ; 
    N := 5 ; 
    K := 4 ; 
    execute canBePerfectCube(N, K) ; 
    N := 7 ; 
    K := 2 ; 
    execute canBePerfectCube(N, K) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    String s=sc.next();
    String t=sc.next();
    sc.close();
    int result=2*n ;
    for(int i=0 ; i<n ; i++){
      String foot=t.substring(0,n-i);
      if(s.endsWith(foot)){
        result-=foot.length();
        break ;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    skip ; 
    var result : int ; result := 2 * n ;
        var i : int ; i := 0 ; while i < n do ( (     var foot : String ; foot := t.subrange(0+1,n - i) ;
     if (s->hasSuffix(foot)) then (     result := result-(foot->size()) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  BufferedReader br ;
  PrintWriter out ;
  StringTokenizer st ;
  boolean eof ;
  void solve()throws IOException {
    int n=nextInt();
    String s=nextToken();
    String t=nextToken();
    for(int both=n ; both>=0 ; both--){
      if(s.substring(n-both).equals(t.subSequence(0,both))){
        out.println(2*n-both);
        return ;
      }
    }
  }
  Main()throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(System.out);
    solve();
    out.close();
  }
  public static void main(String[] args)throws IOException {
    new Main();
  }
  String nextToken(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
        eof=true ;
        return null ;
      }
    }
    return st.nextToken();
  }
  String nextString(){
    try {
      return br.readLine();
    }
    catch(IOException e){
      eof=true ;
      return null ;
    }
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute br : OclFile;
   attribute out : OclFile;
   attribute st : OclIterator;
   attribute eof : boolean;
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var s : String ; s := nextToken() ;
     var t : String ; t := nextToken() ;
         var both : int ; both := n ; while both >= 0 do ( (     if (s.subrange(n - (both)->char2byte()+1,n - (both)->char2byte()) = t.subrange(0+1,both)) then (     skip ; 
     return ) else skip )  ;     both := both - 1 ) );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     execute solve() ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     eof := true ; 
     return null )
 ) ; 
     return st.next() );
   operation nextString() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do (     eof := true ; 
     return null )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    String t=sc.next();
    sc.close();
    for(int i=n ; i>=0 ; i--){
      if(s.endsWith(t.substring(0,i))){
        System.out.println(i+(n-i)*2);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    skip ; 
        var i : int ; i := n ; while i >= 0 do ( (     if (s->hasSuffix(t.subrange(0+1,i))) then (     OclFile["System.out"].println(i + (n - (i)->char2byte()) * 2) ; 
     return ) else skip )  ;     i := i - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    String prefix=sc.next();
    String postfix=sc.next();
    int answser=0 ;
    if(N>=prefix.length()+postfix.length()){
      answser=N ;
    }
    else {
      if(prefix.contains(postfix)|| postfix.contains(prefix)){
        answser=Math.max(prefix.length(),postfix.length());
        if(answser<N)answser=N ;
      }
      else {
        answser=prefix.length()+postfix.length();
        for(int i=0 ; i<prefix.length()&& i<postfix.length(); i++){
          String tmp=prefix.substring(prefix.length()-i-1);
          if(postfix.startsWith(tmp)){
            answser=Math.min(answser,prefix.length()+postfix.length()-i-1);
          }
          if(answser==N){
            break ;
          }
        }
      }
    }
    System.out.println(answser);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var prefix : String ; prefix := sc.getCurrent() ;
    var postfix : String ; postfix := sc.getCurrent() ;
    var answser : int ; answser := 0 ;
    if (N >= prefix->size() + postfix->size()) then (     answser := N ) else (     if (prefix->includes(postfix) or postfix->includes(prefix)) then (     answser := Set{prefix->size(), postfix->size()}->max() ; 
     if (answser < N) then     answser := N ; else skip ) else (     answser := prefix->size() + postfix->size() ; 
         var i : int ; i := 0 ; while i < prefix->size() & i < postfix->size() do ( (     var tmp : String ; tmp := prefix.subrange(prefix->size() - i - 1+1,prefix->size() - i - 1) ;
     if (postfix->hasPrefix(tmp)) then (     answser := Set{answser, prefix->size() + postfix->size() - i - 1}->min() ) else skip ; 
     if (answser = N) then (     break ) else skip )  ;     i := i + 1 ) ) ) ;  
    OclFile["System.out"].println(answser) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Graph {
  private int V ;
  private LinkedList<Integer>adj[];
  Graph(int v){
    V=v ;
    adj=new LinkedList[v];
    for(int i=0 ; i<v ; ++i)adj[i]=new LinkedList();
  }
  void addEdge(int v,int w){
    adj[v] .add(w);
  }
  void DFSUtil(int v,boolean visited[]){
    visited[v]=true ;
    System.out.print(v+" ");
    Iterator<Integer>i=adj[v] .listIterator();
    while(i.hasNext()){
      int n=i.next();
      if(! visited[n])DFSUtil(n,visited);
    }
  }
  void DFS(int v){
    boolean visited[]=new boolean[V];
    DFSUtil(v,visited);
  }
  public static void main(String args[]){
    Graph g=new Graph(4);
    g.addEdge(0,1);
    g.addEdge(0,2);
    g.addEdge(1,2);
    g.addEdge(2,0);
    g.addEdge(2,3);
    g.addEdge(3,3);
    System.out.println("Following is Depth First Traversal "+"(starting from vertex 2)");
    g.DFS(2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Graph {
   attribute V : int;
   attribute adj : Sequence(Sequence(int));
   static operation newGraph( v : int) : Graph
  pre: true
  post: true
  activity:
  ( var self : Graph ;
    self := createGraph();
    self.initialise(v);
    return self );
  operation initialise( v : int) : void
  pre: true  post: true
  activity: (     V := v ; 
     adj := Integer.subrange(1,v)->collect(null) ; 
         var i : int ; i := 0 ; while i < v do (     adj[i+1] := Sequence{} ;  ;     i := i + 1 ) );
   operation addEdge( v : int, w : int) : void
  pre: true
  post: true
  activity: (     adj[v+1]->excludes(w) );
   operation DFSUtil( v : int, visited : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (     visited[v+1] := true ; 
     OclFile["System.out"].print(v + " ") ; 
     var i : OclIterator ; i := adj[v+1]->iterator() ;
     while (i.hasNext()) do (     var n : int ; n := i.next() ;
     if (not(visited[n+1])) then     execute DFSUtil(n, visited) ; else skip ) );
   operation DFS( v : int) : void
  pre: true
  post: true
  activity: (     var visited : Sequence(boolean) ; visited := Integer.subrange(1,V)->collect(false) ;
     execute DFSUtil(v, visited) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : Graph ; g := Graph.newGraph(4) ;
     g.addEdge(0, 1) ; 
    g.addEdge(0, 2) ; 
    g.addEdge(1, 2) ; 
    g.addEdge(2, 0) ; 
    g.addEdge(2, 3) ; 
    g.addEdge(3, 3) ; 
    OclFile["System.out"].println("Following is Depth First Traversal " + "(starting from vertex 2)") ; 
    g.DFS(2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  static void countDigits(double val,long[] arr){
    while((long)val>0){
      long digit=(long)val % 10 ;
      arr[(int)digit]++;
      val=(long)val/10 ;
    }
    return ;
  }
  static void countFrequency(int x,int n){
    long[] freq_count=new long[10];
    for(int i=1 ; i<=n ; i++){
      double val=Math.pow((double)x,(double)i);
      countDigits(val,freq_count);
    }
    for(int i=0 ; i<=9 ; i++){
      System.out.print(freq_count[i]+" ");
    }
  }
  public static void main(String args[]){
    int x=15,n=3 ;
    countFrequency(x,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDigits( val : double, arr : Sequence(long)) : void
  pre: true
  post: true
  activity: (     while (val->oclAsType(long) > 0) do (     var digit : long ; digit := val->oclAsType(long) mod 10 ;
     arr[digit->oclAsType(int)+1] := arr[digit->oclAsType(int)+1] + 1 ; 
     val := val->oclAsType(long) / 10 ) ; 
     return );
  static   operation countFrequency( x : int, n : int) : void
  pre: true
  post: true
  activity: (     var freq_count : Sequence(long) ; freq_count := Integer.subrange(1,10)->collect(0) ;
         var i : int ; i := 1 ; while i <= n do ( (     var val : double ; val := x->oclAsType(double)->pow(i->oclAsType(double)) ;
     execute countDigits(val, freq_count) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i <= 9 do ( (     OclFile["System.out"].print(freq_count[i+1] + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 15 ;
    var n : int ; n := 3 ;
     execute countFrequency(x, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static int n ;
  static StringBuffer str=new StringBuffer();
  static List<Long>a ;
  static void solve(){
    Collections.sort(a);
    long cur=a.get(0)*2 ;
    for(int i=1 ; i<n ; i++){
      if(a.get(i).equals(a.get(i-1)))continue ;
      if(a.get(i)<cur){
        str.append("YES\n");
        return ;
      }
      cur=a.get(i)*2 ;
    }
    str.append("NO\n");
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    String s[]=bf.readLine().trim().split("\\s+");
    n=Integer.parseInt(s[0]);
    a=new ArrayList<>();
    s=bf.readLine().trim().split("\\s+");
    for(int i=0 ; i<n ; i++)a.add(Long.parseLong(s[i]));
    solve();
    pw.println(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute n : int;
  static   attribute str : String := StringLib.newString();
  static   attribute a : Sequence(long);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var cur : long ; cur := a->at(0+1) * 2 ;
         var i : int ; i := 1 ; while i < n do ( (     if (a->at(i+1) = a->at(i - 1+1)) then     continue else skip ; 
     if (a->at(i+1) < cur) then (     str := str + StringLib.newString("YES\n") ; 
     return ) else skip ; 
     cur := a->at(i+1) * 2 )  ;     i := i + 1 ) ; 
     str := str + StringLib.newString("NO\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var s : Sequence(String) ; s := bf.readLine()->trim()->split("\\s+") ;
    n := (s[0+1])->toInteger() ; 
    a := Sequence{} ; 
    s := bf.readLine()->trim()->split("\\s+") ; 
        var i : int ; i := 0 ; while i < n do (     a := a->including((s[i+1])->toLong()) ;  ;     i := i + 1 ) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    doIt();
  }
  public static void doIt(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n!=-1){
      double rad=0 ;
      double hyp=1 ;
      for(int i=1 ; i<n ; i++){
        rad+=Math.atan(1/hyp);
        hyp=Math.sqrt(hyp*hyp+1);
      }
      System.out.println(hyp*Math.cos(rad));
      System.out.println(hyp*Math.sin(rad));
      n=sc.nextInt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doIt() );
  static   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     while (n /= -1) do (     var rad : double ; rad := 0 ;
     var hyp : double ; hyp := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     rad := rad+((1 / hyp)->atan()) ; 
     hyp := (hyp * hyp + 1)->sqrt() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(hyp * (rad)->cos()) ; 
    OclFile["System.out"].println(hyp * (rad)->sin()) ; 
    n := sc.getCurrent()->toInteger() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class B108 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    Integer[] A=new Integer[N];
    for(int n=0 ; n<N ; n++){
      A[n]=in.nextInt();
    }
    Arrays.sort(A);
    boolean ok=true ;
    for(int n=1 ; n<N ; n++){
      if(A[n-1]!=1 && A[n-1]<A[n] && 2*A[n-1]>A[n]){
        ok=false ;
        break ;
      }
    }
    System.out.println(ok ? "NO" : "YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class B108 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(null) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    A := A->sort() ; 
    var ok : boolean ; ok := true ;
        var n : int ; n := 1 ; while n < N do ( (     if (A[n - 1+1] /= 1 & A[n - 1+1] < A[n+1] & 2 * A[n - 1+1] > A[n+1]) then (     ok := false ; 
     break ) else skip )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(if ok then "NO" else "YES" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    char[] c=str.toCharArray();
    long k=sc.nextLong();
    int n=str.length();
    for(int i=0 ; i<k ; i++){
      if(c[i]=='1'){
        if(i==k-1){
          System.out.println(1);
          return ;
        }
      }
      else {
        System.out.println(c[i]);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var c : Sequence(String) ; c := str->characters() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var n : int ; n := str->size() ;
        var i : int ; i := 0 ; while i < k do ( (     if (c[i+1] = '1') then (     if (i = k - 1) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ) else (     OclFile["System.out"].println(c[i+1]) ; 
     return ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    Arrays.sort(arr);
    boolean flag=false ;
    for(int i=0 ; i<n-1 ; i++)if(arr[i]*2>arr[i+1] && arr[i]!=arr[i+1])flag=true ;
    System.out.println(flag ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < n - 1 do (     if (arr[i+1] * 2 > arr[i + 1+1] & arr[i+1] /= arr[i + 1+1]) then     flag := true ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if flag then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BDatatypes solver=new BDatatypes();
    solver.solve(1,in,out);
    out.close();
  }
  static class BDatatypes {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      Integer[] a=in.readIntegerArray(n);
      Arrays.sort(a);
      boolean bad=false ;
      for(int i=0,j=0 ; i<n ; i=j){
        while(j<n && a[i] .equals(a[j]))j++;
        if(j<n){
          if(a[i]*2>a[j]){
            bad=true ;
          }
        }
      }
      out.println(bad ? "YES" : "NO");
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public Integer[] readIntegerArray(int n){
      Integer[] x=new Integer[n];
      for(int i=0 ; i<n ; i++){
        x[i]=nextInt();
      }
      return x ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BDatatypes ; solver := BDatatypes.newBDatatypes() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BDatatypes {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var a : Sequence(int) ; a := in.readIntegerArray(n) ;
    a := a->sort() ; 
    var bad : boolean ; bad := false ;
        var i : int ; i := 0 ;
    var j : int ; j := 0 ; while i < n do ( (     while (j < n & a[i+1] = a[j+1]) do     j := j + 1 ; ; 
     if (j < n) then (     if (a[i+1] * 2 > a[j+1]) then (     bad := true ) else skip ) else skip )  ;     i := j ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readIntegerArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do ( (     x[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return x );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    Arrays.sort(a);
    for(int i=0 ; i<a.length-1 ; i++){
      if(a[i+1]<a[i]*2 && a[i]!=a[i+1]){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
        var i : int ; i := 0 ; while i < a->size() - 1 do ( (     if (a[i + 1+1] < a[i+1] * 2 & a[i+1] /= a[i + 1+1]) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=scan.nextInt();
      System.out.println(maxLeft(n));
    }
  }
  public static int maxLeft(int n){
    return n>2 ? n-2 : 0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     OclFile["System.out"].println(maxLeft(n)) )  ;     i := i + 1 ) );
  static   operation maxLeft( n : int) : int
  pre: true
  post: true
  activity: (     return if n > 2 then n - 2 else 0 endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long t=sc.nextLong();
    while(t>0){
      long n=sc.nextLong();
      System.out.println(((n>2)?(n-2): 0));
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : long ; t := sc.getCurrent()->toLong() ;
     while (t > 0) do (     var n : long ; n := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println((if (n > 2) then (n - 2) else 0 endif)) ; 
     t := t - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=s.nextInt();
      System.out.println((n>1)?(n-2): 0);
    }
    s.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := s.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if (n > 1) then (n - 2) else 0 endif) )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<t ; i++){
      int n=scan.nextInt();
      sb.append(maxLeft(n)).append("\n");
    }
    System.out.println(sb);
  }
  public static int maxLeft(int n){
    return n>2 ? n-2 : 0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     sb := sb + StringLib.newString(maxLeft(n)) + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
  static   operation maxLeft( n : int) : int
  pre: true
  post: true
  activity: (     return if n > 2 then n - 2 else 0 endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    HashSet<Integer>hs=new HashSet<>();
    int a=sc.nextInt();
    for(int i=0 ; i<a ; i++){
      hs.add(sc.nextInt());
    }
    int b=sc.nextInt();
    for(int i=0 ; i<b ; i++){
      hs.add(sc.nextInt());
    }
    if(hs.size()==n)System.out.println("I become the guy.");
    else System.out.print("Oh,my keyboard!");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var hs : Set(int) ; hs := Set{} ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < a do ( (     hs := hs->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var b : int ; b := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < b do ( (     hs := hs->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    if (hs->size() = n) then     OclFile["System.out"].println("I become the guy.") else     OclFile["System.out"].print("Oh,my keyboard!") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      double xa1=sc.nextDouble(),ya1=sc.nextDouble(),xa2=sc.nextDouble(),ya2=sc.nextDouble(),xb1=sc.nextDouble(),yb1=sc.nextDouble(),xb2=sc.nextDouble(),yb2=sc.nextDouble();
      double xaMin=Math.min(xa1,xa2),xaMax=Math.max(xa1,xa2),xbMin=Math.min(xb1,xb2),xbMax=Math.max(xb1,xb2),yaMin=Math.min(ya1,ya2),yaMax=Math.max(ya1,ya2),ybMin=Math.min(yb1,yb2),ybMax=Math.max(yb1,yb2);
      if(xaMax<xbMin || xbMax<xaMin || yaMax<ybMin || ybMax<yaMin){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var xa1 : double ; xa1 := sc.getCurrent()->toReal() ;
    var ya1 : double ; ya1 := sc.getCurrent()->toReal() ;
    var xa2 : double ; xa2 := sc.getCurrent()->toReal() ;
    var ya2 : double ; ya2 := sc.getCurrent()->toReal() ;
    var xb1 : double ; xb1 := sc.getCurrent()->toReal() ;
    var yb1 : double ; yb1 := sc.getCurrent()->toReal() ;
    var xb2 : double ; xb2 := sc.getCurrent()->toReal() ;
    var yb2 : double ; yb2 := sc.getCurrent()->toReal() ;
     var xaMin : double ; xaMin := Set{xa1, xa2}->min() ;
    var xaMax : double ; xaMax := Set{xa1, xa2}->max() ;
    var xbMin : double ; xbMin := Set{xb1, xb2}->min() ;
    var xbMax : double ; xbMax := Set{xb1, xb2}->max() ;
    var yaMin : double ; yaMin := Set{ya1, ya2}->min() ;
    var yaMax : double ; yaMax := Set{ya1, ya2}->max() ;
    var ybMin : double ; ybMin := Set{yb1, yb2}->min() ;
    var ybMax : double ; ybMax := Set{yb1, yb2}->max() ;
     if (xaMax < xbMin or xbMax < xaMin or yaMax < ybMin or ybMax < yaMin) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String line ;
      while((line=br.readLine())!=null){
        if(line.isEmpty())break ;
        String spl[]=line.split(" ");
        int a=Integer.parseInt(spl[0]);
        if(a==-1)break ;
        double[] nowLoca=new double[] {
          1.0,1.0 };
          for(int i=1 ; i<=a-2 ; i++){
            nowLoca=nextLoca(nowLoca);
          }
          System.out.println(nowLoca[0]);
          System.out.println(nowLoca[1]);
        }
        br.close();
      }
      catch(Exception e){
        e.printStackTrace();
      }
    }
    static double[] nextLoca(double[] nowLoca){
      double idoVx=-1*nowLoca[0]/Math.sqrt(nowLoca[0]*nowLoca[0]+nowLoca[1]*nowLoca[1]);
      double idoVy=-1*nowLoca[1]/Math.sqrt(nowLoca[0]*nowLoca[0]+nowLoca[1]*nowLoca[1]);
      double turnVx=idoVy,turnVy=-idoVx ;
      return new double[] {
        nowLoca[0]+turnVx,nowLoca[1]+turnVy };
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->isEmpty()) then     break else skip ; 
     var spl : Sequence(String) ; spl := line->split(" ") ;
    var a : int ; a := (spl[0+1])->toInteger() ;
    if (a = -1) then     break else skip ; 
    var nowLoca : Sequence(double) ; nowLoca := Sequence{1.0,1.0} ;
        var i : int ; i := 1 ; while i <= (a)->char2byte() - 2 do ( (     nowLoca := nextLoca(nowLoca) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(nowLoca[0+1]) ; 
    OclFile["System.out"].println(nowLoca[1+1]) ; 
 ) ;     line := br.readLine() ;
 ) ;  
     skip )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
  static   operation nextLoca( nowLoca : Sequence(double)) : Sequence(double)
  pre: true
  post: true
  activity: (     var idoVx : double ; idoVx := -1 * nowLoca[0+1] / (nowLoca[0+1] * nowLoca[0+1] + nowLoca[1+1] * nowLoca[1+1])->sqrt() ;
     var idoVy : double ; idoVy := -1 * nowLoca[1+1] / (nowLoca[0+1] * nowLoca[0+1] + nowLoca[1+1] * nowLoca[1+1])->sqrt() ;
     var turnVx : double ; turnVx := idoVy ;
    var turnVy : double ; turnVy := -idoVx ;
     return Sequence{nowLoca[0+1] + turnVx,nowLoca[1+1] + turnVy} );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class IwannaBeAGuy {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    HashSet<Integer>result=new HashSet<>();
    int level=in.nextInt();
    int x=in.nextInt();
    for(int i=0 ; i<x ; i++){
      result.add(in.nextInt());
    }
    int y=in.nextInt();
    for(int i=0 ; i<y ; i++){
      result.add(in.nextInt());
    }
    if(result.size()==level)System.out.println("I become the guy.");
    else System.out.println("Oh,my keyboard!");
  }
}
------------------------------------------------------------
OCL File:
---------
 class IwannaBeAGuy {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var result : Set(int) ; result := Set{} ;
    var level : int ; level := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < x do ( (     result := result->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var y : int ; y := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < y do ( (     result := result->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    if (result->size() = level) then     OclFile["System.out"].println("I become the guy.") else     OclFile["System.out"].println("Oh,my keyboard!") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int p=sc.nextInt();
    int flag=0 ;
    boolean array[]=new boolean[n+1];
    for(int i=0 ; i<p ; i++){
      int val=sc.nextInt();
      array[val]=true ;
    }
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      int val=sc.nextInt();
      array[val]=true ;
    }
    for(int i=1 ; i<=n ; i++){
      if(! array[i]){
        flag=1 ;
        break ;
      }
    }
    if(flag==1){
      System.out.println("Oh,my keyboard!");
    }
    else {
      System.out.println("I become the guy.");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
    var flag : int ; flag := 0 ;
    var array : Sequence(boolean) ; array := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 0 ; while i < p do ( (     var val : int ; val := sc.getCurrent()->toInteger() ;
     array[val+1] := true )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var val : int ; val := sc.getCurrent()->toInteger() ;
     array[val+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (not(array[i+1])) then (     flag := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 1) then (     OclFile["System.out"].println("Oh,my keyboard!") ) else (     OclFile["System.out"].println("I become the guy.") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    InputStream inputStream=System.in ;
    Scanner sc=new Scanner(inputStream);
    String out ;
    String N=sc.next();
    long A=sc.nextLong();
    long count=A ;
    int last=0 ;
    StringBuilder K=new StringBuilder();
    for(int i=0 ; i<N.length(); i++){
      count-=Math.pow(Character.getNumericValue(N.charAt(i)),500000000000000L);
      if(count<=0){
        System.out.println(N.charAt(i));
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(inputStream) ;
    var out : String ;
    var N : String ; N := sc.getCurrent() ;
    var A : long ; A := sc.getCurrent()->toLong() ;
    var count : long ; count := A ;
    var last : int ; last := 0 ;
    var K : String ; K := StringLib.newString() ;
        var i : int ; i := 0 ; while i < N->size() do ( (     count := count-(("" + N->at(i+1))->toInteger()->pow(500000000000000L)) ; 
     if (count <= 0) then (     OclFile["System.out"].println(N->at(i+1)) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class levels {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int levels=sc.nextInt();
    int sum=0 ;
    int sum2=0 ;
    int sum3=0 ;
    int[] arr=new int[levels];
    int count=0 ;
    for(int i=0 ; i<levels ; i++){
      arr[i]=sc.nextInt();
    }
    int level2=sc.nextInt();
    int level3=levels+level2 ;
    int[] arr2=new int[level3];
    for(int i=0 ; i<arr.length ; i++){
      arr2[i]=arr[i];
    }
    for(int i=arr.length ; i<level3 ; i++){
      arr2[i]=sc.nextInt();
    }
    for(int i=0 ; i<arr2.length ; i++){
    }
    int[] arr3=new int[n];
    int j=0 ;
    for(int i=0 ; i<n ; i++){
      arr3[i]=++j ;
    }
    for(int i=0 ; i<n ; i++){
      for(int x=0 ; x<arr2.length ; x++){
        if(arr3[i]==arr2[x]){
          count++;
          break ;
        }
      }
    }
    if(count==n){
      System.out.println("I become the guy.");
    }
    else {
      System.out.println("Oh,my keyboard!");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class levels {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var levels : int ; levels := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var sum2 : int ; sum2 := 0 ;
    var sum3 : int ; sum3 := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,levels)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < levels do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var level2 : int ; level2 := sc.getCurrent()->toInteger() ;
    var level3 : int ; level3 := levels + level2 ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,level3)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr2[i+1] := arr[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := arr->size() ; while i < level3 do ( (     arr2[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < arr2->size() do ( skip  ;     i := i + 1 ) ; 
    var arr3 : Sequence(int) ; arr3 := Integer.subrange(1,n)->collect(0) ;
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         j := j + 1 ;
 arr3[i+1] := j  )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var x : int ; x := 0 ; while x < arr2->size() do ( (     if (arr3[i+1] = arr2[x+1]) then (     count := count + 1 ; 
     break ) else skip )  ;     x := x + 1 ) )  ;     i := i + 1 ) ; 
    if (count = n) then (     OclFile["System.out"].println("I become the guy.") ) else (     OclFile["System.out"].println("Oh,my keyboard!") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int m=6,n=4 ;
  static int linearCheck(int ar[][],int arr[]){
    for(int i=0 ; i<m ; i++){
      boolean matched=true ;
      for(int j=0 ; j<n ; j++){
        if(ar[i][j]!=arr[j]){
          matched=false ;
          break ;
        }
      }
      if(matched)return i+1 ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    int mat[][]={
      {
        0,0,1,0 },{
          10,9,22,23 },{
            40,40,40,40 },{
              43,44,55,68 },{
                81,73,100,132 },{
                  100,75,125,133 }
                };
                int row[]={
                  10,9,22,23 };
                  System.out.println(linearCheck(mat,row));
                }
              }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute m : int := 6;
  static   operation linearCheck( ar : Sequence(Sequence(int)), arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < m do ( (     var matched : boolean ; matched := true ;
         var j : int ; j := 0 ; while j < n do ( (     if (ar[i+1][j+1] /= arr[j+1]) then (     matched := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (matched) then     return i + 1 else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{0,0,1,0},Sequence{10,9,22,23},Sequence{40,40,40,40},Sequence{43,44,55,68},Sequence{81,73,100,132},Sequence{100,75,125,133}} ;
     var row : Sequence(int) ; row := Sequence{10,9,22,23} ;
     OclFile["System.out"].println(linearCheck(mat, row)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CandyAndFriend {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      int[] a=new int[n];
      int sum=0,count=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
        sum+=a[i];
      }
      if(sum % n==0){
        int div=sum/n ;
        for(int i=0 ; i<n ; i++){
          if(a[i]>div){
            count++;
          }
        }
        System.out.println(count);
      }
      else {
        System.out.println(-1);
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CandyAndFriend {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    if (sum mod n = 0) then (     var div : int ; div := sum / n ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] > div) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) ) else (     OclFile["System.out"].println(-1) ) ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test194 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int sum=0,x=0 ;
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
        sum+=a[i];
      }
      if(sum % n==0){
        for(int i=0 ; i<n ; i++){
          if(a[i]>sum/n){
            x++;
          }
        }
        System.out.println(x);
      }
      else {
        System.out.println("-1");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test194 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var sum : int ; sum := 0 ;
    var x : int ; x := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    if (sum mod n = 0) then (         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] > sum / n) then (     x := x + 1 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(x) ) else (     OclFile["System.out"].println("-1") ) ;  
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int[] arr=new int[n];
      int sum=0 ;
      for(int j=0 ; j<n ; j++){
        arr[j]=sc.nextInt();
        sum=sum+arr[j];
      }
      if(sum % n==0){
        int num=sum/n ;
        int count=0 ;
        for(int j=0 ; j<n ; j++){
          if(arr[j]>num){
            count++;
          }
        }
        System.out.println(count);
      }
      else {
        System.out.println("-1");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     arr[j+1] := sc.getCurrent()->toInteger() ; 
     sum := sum + arr[j+1] )  ;     j := j + 1 ) ; 
    if (sum mod n = 0) then (     var num : int ; num := sum / n ;
     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (arr[j+1] > num) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(count) ) else (     OclFile["System.out"].println("-1") ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1538B_FriendsandCandies {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      final int len=parseInt(input.nextLine());
      double avg=0 ;
      int[] array=new int[len];
      for(int i=0 ; i<len ; i++){
        int num=input.nextInt();
        array[i]=num ;
        avg+=num ;
      }
      input.nextLine();
      avg/=len ;
      if(avg % 1!=0){
        System.out.println("-1");
        continue ;
      }
      int result=0 ;
      for(int i : array){
        if(i>avg){
          result++;
        }
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1538B_FriendsandCandies {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var len : int ; len := parseInt(input.nextLine()) ;
     var avg : double ; avg := 0 ;
    var array : Sequence(int) ; array := Integer.subrange(1,len)->collect(0) ;
        var i : int ; i := 0 ; while i < len do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
     array[i+1] := num ; 
     avg := avg+(num) )  ;     i := i + 1 ) ; 
    skip ; 
    avg := avg/(len) ; 
    if (avg mod 1 /= 0) then (     OclFile["System.out"].println("-1") ; 
     continue ) else skip ; 
    var result : int ; result := 0 ;
    for (i : array) do ( (     if (i > avg) then (     result := result + 1 ) else skip )  ) ; 
    OclFile["System.out"].println(result) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solveD();
  }
  private void solveD(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] t=new int[N];
    int sum_t=0 ;
    for(int i=0 ; i<N ; i++){
      t[i]=sc.nextInt()*2 ;
      sum_t+=t[i];
    }
    int[] v=new int[N];
    for(int i=0 ; i<N ; i++){
      v[i]=sc.nextInt()*2 ;
    }
    int tmp_v=0 ;
    int tmp_t=0 ;
    int[] max_v=new int[sum_t+1];
    for(int i=0 ; i<N ; i++){
      max_v[tmp_t]=v[i]<tmp_v ? v[i] : tmp_v ;
      tmp_v=max_v[tmp_t];
      for(int t_ind=0 ; t_ind<t[i]; t_ind++){
        max_v[++tmp_t]=v[i]<tmp_v+1 ? v[i] : tmp_v+1 ;
        tmp_v=max_v[tmp_t];
      }
    }
    tmp_v=0 ;
    for(int i=N-1 ; i>=0 ; i--){
      max_v[tmp_t]=v[i]<tmp_v ? v[i] : tmp_v ;
      tmp_v=max_v[tmp_t];
      for(int t_ind=0 ; t_ind<t[i]; t_ind++){
        int back_v=v[i]<tmp_v+1 ? v[i] : tmp_v+1 ;
--tmp_t ;
        max_v[tmp_t]=max_v[tmp_t]<back_v ? max_v[tmp_t] : back_v ;
        tmp_v=max_v[tmp_t];
      }
    }
    double answer=0 ;
    for(int i=0 ; i<sum_t ; i++){
      answer+=(max_v[i]+max_v[i+1]);
    }
    System.out.println(answer*0.125);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solveD() );
   operation solveD() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,N)->collect(0) ;
    var sum_t : int ; sum_t := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     t[i+1] := sc.getCurrent()->toInteger() * 2 ; 
     sum_t := sum_t+(t[i+1]) )  ;     i := i + 1 ) ; 
    var v : Sequence(int) ; v := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     v[i+1] := sc.getCurrent()->toInteger() * 2 )  ;     i := i + 1 ) ; 
    var tmp_v : int ; tmp_v := 0 ;
    var tmp_t : int ; tmp_t := 0 ;
    var max_v : Sequence(int) ; max_v := Integer.subrange(1,sum_t + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     max_v[tmp_t+1] := if v[i+1] < tmp_v then v[i+1] else tmp_v endif ; 
     tmp_v := max_v[tmp_t+1] ; 
         var t_ind : int ; t_ind := 0 ; while t_ind < t[i+1] do ( (         tmp_t := tmp_t + 1 ;
 max_v[tmp_t+1] := if v[i+1] < tmp_v + 1 then v[i+1] else tmp_v + 1 endif  ; 
     tmp_v := max_v[tmp_t+1] )  ;     t_ind := t_ind + 1 ) )  ;     i := i + 1 ) ; 
    tmp_v := 0 ; 
        var i : int ; i := N - 1 ; while i >= 0 do ( (     max_v[tmp_t+1] := if v[i+1] < tmp_v then v[i+1] else tmp_v endif ; 
     tmp_v := max_v[tmp_t+1] ; 
         var t_ind : int ; t_ind := 0 ; while t_ind < t[i+1] do ( (     var back_v : int ; back_v := if v[i+1] < tmp_v + 1 then v[i+1] else tmp_v + 1 endif ;
     tmp_t := tmp_t - 1 ; 
     max_v[tmp_t+1] := if max_v[tmp_t+1] < back_v then max_v[tmp_t+1] else back_v endif ; 
     tmp_v := max_v[tmp_t+1] )  ;     t_ind := t_ind + 1 ) )  ;     i := i - 1 ) ; 
    var answer : double ; answer := 0 ;
        var i : int ; i := 0 ; while i < sum_t do ( (     answer := answer+((max_v[i+1] + max_v[i + 1+1])) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer * 0.125) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.AWTException ;
import java.awt.Robot ;
import java.awt.event.InputEvent ;
import java.awt.event.KeyEvent ;
import java.awt.geom.Point2D ;
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new aoj0076().doIt();
  }
  class aoj0076 {
    void doIt(){
      double mapx[]=new double[1001];
      double mapy[]=new double[1001];
      mapx[1]=1 ;
      mapy[1]=0 ;
      int rand=90 ;
      for(int i=2 ; i<1001 ; i++){
        mapx[i]=(1/Math.sqrt(i-1))*(mapx[i-1]*Math.cos(Math.toRadians(rand))-mapy[i-1]*Math.sin(Math.toRadians(rand)))+mapx[i-1];
        mapy[i]=(1/Math.sqrt(i-1))*(mapx[i-1]*Math.sin(Math.toRadians(rand))+mapy[i-1]*Math.cos(Math.toRadians(rand)))+mapy[i-1];
      }
      while(true){
        int n=sc.nextInt();
        if(n==-1)break ;
        System.out.printf("%.2f\n",mapx[n]);
        System.out.printf("%.2f\n",mapy[n]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     aoj0076.newaoj0076().doIt() );
 class aoj0076 {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var mapx : Sequence(double) ; mapx := Integer.subrange(1,1001)->collect(0.0) ;
     var mapy : Sequence(double) ; mapy := Integer.subrange(1,1001)->collect(0.0) ;
    mapx[1+1] := 1 ; 
    mapy[1+1] := 0 ; 
    var rand : int ; rand := 90 ;
        var i : int ; i := 2 ; while i < 1001 do ( (     mapx[i+1] := (1 / (i - 1)->sqrt()) * (mapx[i - 1+1] * ((0.017453292519943295*(rand)))->cos() - mapy[i - 1+1] * ((0.017453292519943295*(rand)))->sin()) + mapx[i - 1+1] ; 
     mapy[i+1] := (1 / (i - 1)->sqrt()) * (mapx[i - 1+1] * ((0.017453292519943295*(rand)))->sin() + mapy[i - 1+1] * ((0.017453292519943295*(rand)))->cos()) + mapy[i - 1+1] )  ;     i := i + 1 ) ; 
    while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = -1) then     break else skip ; 
     OclFile["System.out"].printf("%.2f\n", mapx[n+1]) ; 
     OclFile["System.out"].printf("%.2f\n", mapy[n+1]) ) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static PrintWriter out=new PrintWriter(System.out);
  public static final void main(String[] args){
    new Main().solve();
    out.flush();
  }
  public void solve(){
    int n=sc.nextInt();
    double[] t=new double[n];
    double[] v=new double[n+1];
    for(int i=0 ; i<n ; i++)t[i]=sc.nextDouble();
    for(int i=0 ; i<n ; i++)v[i]=sc.nextDouble();
    v[n]=0.0 ;
    double ans=0.0,curV=0.0 ;
    for(int i=0 ; i<n ; i++){
      for(double j=0 ; j<t[i]; j+=0.5){
        boolean up=true,eq=true ;
        double tc=t[i]-j ;
        for(int k=i+1 ; k<n+1 ; k++){
          if(curV+0.5-tc>=v[k])up=false ;
          if(curV-tc>=v[k])eq=false ;
          if(k<n)tc+=t[k];
        }
        if(up && curV+0.5<=v[i]){
          ans+=curV*0.5+0.125 ;
          curV+=0.5 ;
        }
        else if(eq){
          ans+=curV*0.5 ;
        }
        else {
          ans+=curV*0.5-0.125 ;
          curV-=0.5 ;
        }
      }
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() ; 
     skip );
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var t : Sequence(double) ; t := Integer.subrange(1,n)->collect(0.0) ;
    var v : Sequence(double) ; v := Integer.subrange(1,n + 1)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do (     t[i+1] := sc.getCurrent()->toReal() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     v[i+1] := sc.getCurrent()->toReal() ;  ;     i := i + 1 ) ; 
    v[n+1] := 0.0 ; 
    var ans : double ; ans := 0.0 ;
    var curV : double ; curV := 0.0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : double ; j := 0 ; while j < t[i+1] do ( (     var up : boolean ; up := true ;
    var eq : boolean ; eq := true ;
     var tc : double ; tc := t[i+1] - j ;
         var k : int ; k := i + 1 ; while k < n + 1 do ( (     if (curV + 0.5 - tc >= v[k+1]) then     up := false ; else skip ; 
     if (curV - tc >= v[k+1]) then     eq := false ; else skip ; 
     if (k < n) then     tc := tc+(t[k+1]) ; else skip )  ;     k := k + 1 ) ; 
     if (up & curV + 0.5 <= v[i+1]) then (     ans := ans+(curV * 0.5 + 0.125) ; 
     curV := curV+(0.5) ) else     if (eq) then (     ans := ans+(curV * 0.5) ) else (     ans := ans+(curV * 0.5 - 0.125) ; 
     curV := curV-(0.5) ) ;  )  ;     j := j+(0.5) ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] t=new int[n+2],v=new int[n+2];
    int tSum=0 ;
    for(int i=1 ; i<=n ; i++){
      t[i]=in.nextInt()*2 ;
      tSum+=t[i];
    }
    for(int i=1 ; i<=n ; i++){
      v[i]=in.nextInt();
    }
    double[] vMax=new double[tSum+1];
    int idx=1 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=0 ; j<t[i]; j++){
        vMax[idx+j]=v[i];
      }
      idx+=t[i];
    }
    idx=0 ;
    for(int i=0 ; i<n ; i++){
      double max=v[i];
      int tmp=idx+1 ;
      while(max<vMax[tmp]){
        max+=0.5 ;
        vMax[tmp++]=max ;
        if(vMax.length<=tmp)break ;
      }
      idx+=t[i+1];
    }
    idx=tSum+1 ;
    for(int i=n+1 ; i>0 ; i--){
      double max=v[i];
      int tmp=idx-1 ;
      while(max<vMax[tmp]){
        vMax[tmp--]=max ;
        max+=0.5 ;
        if(tmp<0)break ;
      }
      idx-=t[i-1];
    }
    double ans=0,now=0 ;
    for(int i=0 ; i<vMax.length-1 ; i++){
      ans+=now*0.5 ;
      if(vMax[i]<vMax[i+1]){
        ans+=0.125 ;
        now+=0.5 ;
      }
      if(vMax[i+1]<vMax[i]){
        ans-=0.125 ;
        now-=0.5 ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,n + 2)->collect(0) ;
    var v : Sequence(int) ; v := Integer.subrange(1,n + 2)->collect(0) ;
    var tSum : int ; tSum := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     t[i+1] := in.getCurrent()->toInteger() * 2 ; 
     tSum := tSum+(t[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     v[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var vMax : Sequence(double) ; vMax := Integer.subrange(1,tSum + 1)->collect(0.0) ;
    var idx : int ; idx := 1 ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 0 ; while j < t[i+1] do ( (     vMax[idx + j+1] := v[i+1] )  ;     j := j + 1 ) ; 
     idx := idx+(t[i+1]) )  ;     i := i + 1 ) ; 
    idx := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     var max : double ; max := v[i+1] ;
     var tmp : int ; tmp := idx + 1 ;
     while (max < vMax[tmp+1]) do (     max := max+(0.5) ; 
      vMax[tmp+1] := max  ; tmp := tmp + 1 ; 
     if (vMax->size() <= tmp) then     break else skip ) ; 
     idx := idx+(t[i + 1+1]) )  ;     i := i + 1 ) ; 
    idx := tSum + 1 ; 
        var i : int ; i := n + 1 ; while i > 0 do ( (     var max : double ; max := v[i+1] ;
     var tmp : int ; tmp := idx - 1 ;
     while (max < vMax[tmp+1]) do (      vMax[tmp+1] := max  ; tmp := tmp - 1 ; 
     max := max+(0.5) ; 
     if (tmp < 0) then     break else skip ) ; 
     idx := idx-(t[i - 1+1]) )  ;     i := i - 1 ) ; 
    var ans : double ; ans := 0 ;
    var now : double ; now := 0 ;
        var i : int ; i := 0 ; while i < vMax->size() - 1 do ( (     ans := ans+(now * 0.5) ; 
     if (vMax[i+1] < vMax[i + 1+1]) then (     ans := ans+(0.125) ; 
     now := now+(0.5) ) else skip ; 
     if (vMax[i + 1+1] < vMax[i+1]) then (     ans := ans-(0.125) ; 
     now := now-(0.5) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int nthTerm(int n){
    return 2*(int)Math.pow(n,3)+(int)Math.pow(n,2);
  }
  public static void main(String arr[]){
    int N=3 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation nthTerm( n : int) : int
  pre: true
  post: true
  activity: (     return 2 * n->pow(3)->oclAsType(int) + n->pow(2)->oclAsType(int) );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
     OclFile["System.out"].println(nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int X=sc.nextInt();
    int prime=X ;
    int mid=prime/2 ;
    boolean flag=false ;
    while(true){
      for(int i=2 ; i<=mid ; ++i){
        if(prime % i==0){
          flag=true ;
          break ;
        }
      }
      if(! flag){
        break ;
      }
      else flag=false ;
      prime++;
    }
    System.out.println(prime);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : int ; X := sc.getCurrent()->toInteger() ;
    var prime : int ; prime := X ;
    var mid : int ; mid := prime / 2 ;
    var flag : boolean ; flag := false ;
    while (true) do (         var i : int ; i := 2 ; while i <= mid do ( (     if (prime mod i = 0) then (     flag := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (not(flag)) then (     break ) else     flag := false ; ;  
     prime := prime + 1 ) ; 
    OclFile["System.out"].println(prime) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int nthTerm(int n){
    return 3*(int)Math.pow(n,2)+n-2 ;
  }
  public static void main(String arr[]){
    int N=4 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation nthTerm( n : int) : int
  pre: true
  post: true
  activity: (     return 3 * n->pow(2)->oclAsType(int) + n - 2 );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int nthTerm(int n){
    return 2*(int)Math.pow(n,2)-n-1 ;
  }
  public static void main(String arr[]){
    int N=4 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation nthTerm( n : int) : int
  pre: true
  post: true
  activity: (     return 2 * n->pow(2)->oclAsType(int) - n - 1 );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int nthTerm(int n){
    return 2*(int)Math.pow(n,2)+4*n-2 ;
  }
  public static void main(String arr[]){
    int N=4 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation nthTerm( n : int) : int
  pre: true
  post: true
  activity: (     return 2 * n->pow(2)->oclAsType(int) + 4 * n - 2 );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int nthTerm(int n){
    return 5*(int)Math.pow(n,2)-5*n ;
  }
  public static void main(String arr[]){
    int N=4 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation nthTerm( n : int) : int
  pre: true
  post: true
  activity: (     return 5 * n->pow(2)->oclAsType(int) - 5 * n );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int nthTerm(int n){
    return 7*(int)Math.pow(n,2)-7*n+7 ;
  }
  public static void main(String arr[]){
    int N=4 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation nthTerm( n : int) : int
  pre: true
  post: true
  activity: (     return 7 * n->pow(2)->oclAsType(int) - 7 * n + 7 );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int nthTerm(int n){
    return(int)Math.pow(n,2)-2*n+2 ;
  }
  public static void main(String arr[]){
    int N=4 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation nthTerm( n : int) : int
  pre: true
  post: true
  activity: (     return n->pow(2)->oclAsType(int) - 2 * n + 2 );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    String line=null ;
    while((line=reader.readLine())!=null){
      if(line.isEmpty()){
        continue ;
      }
      int n=Integer.parseInt(line);
      if(n==-1){
        break ;
      }
      double x=1.0 ;
      double y=0.0 ;
      for(int i=0 ; i<n-1 ; i++){
        double d=Math.hypot(x,y);
        double dx=-y/d ;
        double dy=x/d ;
        x+=dx ;
        y+=dy ;
      }
      out.println(x);
      out.println(y);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     var line : String ; line := null ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->isEmpty()) then (     continue ) else skip ; 
     var n : int ; n := (line)->toInteger() ;
    if (n = -1) then (     break ) else skip ; 
    var x : double ; x := 1.0 ;
    var y : double ; y := 0.0 ;
        var i : int ; i := 0 ; while i < (n)->char2byte() - 1 do ( (     var d : double ; d := hypot(x, y) ;
     var dx : double ; dx := -y / d ;
    var dy : double ; dy := x / d ;
    x := x+(dx) ; 
    y := y+(dy) ; 
 )  ;     i := i + 1 ) ; 
    out.println(x) ; 
    out.println(y) ; 
 ) ;     line := reader.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int nthTerm(int n){
    return(int)Math.pow(n,2)+2*n+2 ;
  }
  public static void main(String arr[]){
    int N=4 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation nthTerm( n : int) : int
  pre: true
  post: true
  activity: (     return n->pow(2)->oclAsType(int) + 2 * n + 2 );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class shashwat {
  static Scanner in=new Scanner(System.in);
  public static void main(String args[]){
    int n1=in.nextInt();
    int n2=in.nextInt();
    int x=Math.abs(n1)+Math.abs(n2);
    if(n1>=0 && n2>=0)System.out.println(0+" "+x+" "+x+" "+0);
    else if(n1<0 && n2>=0)System.out.println("-"+x+" "+0+" "+0+" "+x);
    else if(n1<0 && n2<0)System.out.println("-"+x+" "+0+" "+0+"-"+x);
    else System.out.println(0+"-"+x+" "+x+" "+0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class shashwat {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n1 : int ; n1 := in.getCurrent()->toInteger() ;
     var n2 : int ; n2 := in.getCurrent()->toInteger() ;
     var x : int ; x := if n1 < 0 then -(n1) else n1 endif + if n2 < 0 then -(n2) else n2 endif ;
     if (n1 >= 0 & n2 >= 0) then     OclFile["System.out"].println(0 + " " + x + " " + x + " " + 0) ; else     if (n1 < 0 & n2 >= 0) then     OclFile["System.out"].println("-" + x + " " + 0 + " " + 0 + " " + x) else     if (n1 < 0 & n2 < 0) then     OclFile["System.out"].println("-" + x + " " + 0 + " " + 0 + "-" + x) else     OclFile["System.out"].println(0 + "-" + x + " " + x + " " + 0) ; ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    int r=(int)Math.abs(x)+(int)Math.abs(y);
    if(x>0 && y>0){
      System.out.print(0+" "+r+" "+r+" "+0);
    }
    if(x<0 && y>0){
      System.out.print((-r)+" "+0+" "+0+" "+r);
    }
    if(x<0 && y<0){
      System.out.print((-r)+" "+0+" "+0+" "+(-r));
    }
    if(x>0 && y<0){
      System.out.print(0+" "+(-r)+" "+(r)+" "+0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var r : int ; r := if x < 0 then -(x) else x endif->oclAsType(int) + if y < 0 then -(y) else y endif->oclAsType(int) ;
    if (x > 0 & y > 0) then (     OclFile["System.out"].print(0 + " " + r + " " + r + " " + 0) ) else skip ; 
    if (x < 0 & y > 0) then (     OclFile["System.out"].print((-r) + " " + 0 + " " + 0 + " " + r) ) else skip ; 
    if (x < 0 & y < 0) then (     OclFile["System.out"].print((-r) + " " + 0 + " " + 0 + " " + (-r)) ) else skip ; 
    if (x > 0 & y < 0) then (     OclFile["System.out"].print(0 + " " + (-r) + " " + (r) + " " + 0) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Vasily_the_Bear_and_Triangle {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int x=scan.nextInt();
    int y=scan.nextInt();
    int length=Math.abs(x)+Math.abs(y);
    if(x>0 && y>0){
      System.out.println(0+" "+length+" "+length+" "+0);
    }
    else if(x>0 && y<0){
      System.out.println(0+" "+(-length)+" "+length+" "+0);
    }
    else if(x<0 && y>0){
      System.out.println(-length+" "+0+" "+0+" "+length);
    }
    else {
      System.out.println(-length+" "+0+" "+0+" "+(-length));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Vasily_the_Bear_and_Triangle {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := scan.getCurrent()->toInteger() ;
    var y : int ; y := scan.getCurrent()->toInteger() ;
    var length : int ; length := if x < 0 then -(x) else x endif + if y < 0 then -(y) else y endif ;
    if (x > 0 & y > 0) then (     OclFile["System.out"].println(0 + " " + length + " " + length + " " + 0) ) else     if (x > 0 & y < 0) then (     OclFile["System.out"].println(0 + " " + (-length) + " " + length + " " + 0) ) else     if (x < 0 & y > 0) then (     OclFile["System.out"].println(-length + " " + 0 + " " + 0 + " " + length) ) else (     OclFile["System.out"].println(-length + " " + 0 + " " + 0 + " " + (-length)) ) ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
import java.util.Stack ;
public class Main {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer root ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(root==null || ! root.hasMoreTokens()){
        try {
          root=new StringTokenizer(br.readLine());
        }
        catch(Exception r){
          r.printStackTrace();
        }
      }
      return root.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(Exception r){
        r.printStackTrace();
      }
      return str ;
    }
  }
  public static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
  static int mod=(int)(1e9+7),n ;
  static long cf=998244353 ;
  static final int MAX=(int)1e6 ;
  public static List<Integer>[] edges ;
  public static int[][] parent ;
  public static int col=20 ;
  public static long[] Bit ;
  public static long[] fact,inv ;
  public static int[] prime ;
  public static long[] seg,lazy ;
  public static FastReader sc=new FastReader();
  public static void main(String[] args){
    int x=sc.nextInt();
    while(! BigInteger.valueOf(x).isProbablePrime(20))++x ;
    out.print(x);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute root : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (root = null or not(root.hasNext())) do (     try (     root := OclIterator.newOclIterator_String(br.readLine()) )   catch (r : ProgramException) do (     r.printStackTrace() )
 ) ; 
     return root.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (r : ProgramException) do (     r.printStackTrace() )
     return str );
}
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute mod : int := (1e9 + 7)->oclAsType(int);
  static   attribute cf : long := 998244353;
  static    attribute MAX : int := 1e6->oclAsType(int);
  static   attribute edges : Sequence(Sequence(int));
  static   attribute parent : Sequence(Sequence(int));
  static   attribute col : int := 20;
  static   attribute Bit : Sequence(long);
  static   attribute fact : Sequence(long);
  static   attribute prime : Sequence(int);
  static   attribute seg : Sequence(long);
  static   attribute sc : FastReader := FastReader.newFastReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := sc.nextInt() ;
     while (not((x + "")->toLong().isProbablePrime(20))) do     x := x + 1 ; ; 
     skip ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class VasilyTriangle {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int x=scan.nextInt();
    int y=scan.nextInt();
    int p=(Math.abs(x)+Math.abs(y));
    if(x>0 && y>0)System.out.println("0 "+p+" "+p+" "+0);
    else if(x<0 && y>=0)System.out.println(-p+" 0 0 "+p);
    else if(x>=0 && y<0)System.out.println("0 "+(-p)+" "+p+" 0");
    else System.out.println(-p+" 0 0 "+-p);
  }
}
------------------------------------------------------------
OCL File:
---------
 class VasilyTriangle {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := scan.getCurrent()->toInteger() ;
    var y : int ; y := scan.getCurrent()->toInteger() ;
    var p : int ; p := (if x < 0 then -(x) else x endif + if y < 0 then -(y) else y endif) ;
    if (x > 0 & y > 0) then     OclFile["System.out"].println("0 " + p + " " + p + " " + 0) else     if (x < 0 & y >= 0) then     OclFile["System.out"].println(-p + " 0 0 " + p) else     if (x >= 0 & y < 0) then     OclFile["System.out"].println("0 " + (-p) + " " + p + " 0") else     OclFile["System.out"].println(-p + " 0 0 " + -p) ; ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    try(Scanner in=new Scanner(System.in)){
      String s=in.nextLine();
      int K=Integer.parseInt(in.nextLine());
      HashSet<String>subs=new HashSet<>();
      for(int i=0 ; i<s.length(); i++){
        int index=i ;
        for(int j=0 ; j<K ; j++){
          if(index+1+j<=s.length()){
            subs.add(s.substring(index,index+1+j));
          }
        }
      }
      ArrayList<String>subs2=new ArrayList<>();
      subs2.addAll(subs);
      Collections.sort(subs2);
      System.out.println(subs2.get(K-1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var s : String ; s := in.nextLine() ;
     var K : int ; K := (in.nextLine())->toInteger() ;
    var subs : Set(String) ; subs := Set{} ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var index : int ; index := i ;
         var j : int ; j := 0 ; while j < K do ( (     if (index + 1 + j <= s->size()) then (     subs := subs->including(s.subrange(index+1,index + 1 + j)) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var subs2 : Sequence(String) ; subs2 := Sequence{} ;
    subs2 := subs2->union(subs) ; 
    subs2 := subs2->sort() ; 
    OclFile["System.out"].println(subs2->at((K)->char2byte() - 1+1)) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int k=sc.nextInt();
    ArrayList<String>list=new ArrayList<>();
    for(int i=1 ; i<=k ; i++){
      for(int j=0 ; j<s.length()-i+1 ; j++){
        try {
          if(! list.contains(s.substring(j,j+i)))list.add(s.substring(j,j+i));
        }
        catch(Exception e){
        }
      }
    }
    Collections.sort(list);
    System.out.println(list.get(k-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var list : Sequence(String) ; list := Sequence{} ;
        var i : int ; i := 1 ; while i <= k do ( (         var j : int ; j := 0 ; while j < s->size() - i + 1 do ( (     try (     if (not(list->includes(s.subrange(j+1,j + i)))) then     list := list->including(s.subrange(j+1,j + i)) ; else skip )   catch (e : ProgramException) do skip
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    OclFile["System.out"].println(list->at((k)->char2byte() - 1+1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String...args){
    System.out.println(findSubstring(scanString(),scanInt()));
  }
  private static String findSubstring(String s,int K){
    String last="" ;
    TreeSet<String>set=new TreeSet<>();
    for(int i=0 ; i<s.length(); ++i){
      if(! last.isEmpty()&& last.charAt(0)<s.charAt(i)){
        continue ;
      }
      int jj=Math.min(s.length(),i+K);
      for(int j=i+1 ; j<=jj ; ++j){
        set.add(s.substring(i,j));
        last=trim(K,set);
      }
    }
    return set.last();
  }
  private static String trim(int K,TreeSet<String>set){
    String last="" ;
    while(K<set.size()){
      last=set.pollLast();
    }
    return last ;
  }
  private static final Scanner SC=new Scanner(System.in);
  private static int scanInt(){
    return SC.nextInt();
  }
  private static String scanString(){
    return SC.next();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(findSubstring(scanString(), scanInt())) );
  static   operation findSubstring( s : String, K : int) : String
  pre: true
  post: true
  activity: (     var last : String ; last := "" ;
     var set : Set(String) ; set := Set{} ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (not(last->isEmpty()) & last->at(0+1) < s->at(i+1)) then (     continue ) else skip ; 
     var jj : int ; jj := Set{s->size(), i + K}->min() ;
         var j : int ; j := i + 1 ; while j <= jj do ( (     set := set->including(s.subrange(i+1,j)) ; 
     last := trim(K, set) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return set->last() );
  static   operation trim( K : int, set : Set(String)) : String
  pre: true
  post: true
  activity: (     var last : String ; last := "" ;
     while (K < set->size()) do (     last := set->last() ;     set := set->front() ) ; 
     return last );
  static    attribute SC : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation scanInt() : int
  pre: true
  post: true
  activity: (     return SC.getCurrent()->toInteger() );
  static   operation scanString() : String
  pre: true
  post: true
  activity: (     return SC.getCurrent() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int N=s.length();
    int K=sc.nextInt();
    String[] sub=new String[N*K];
    Arrays.fill(sub,"zzzzzz");
    int cnt=-1 ;
    for(int i=1 ; i<=Math.min(N,K); i++)for(int j=0 ; j<N-i+1 ; j++)sub[++cnt]=s.substring(j,j+i);
    Arrays.sort(sub);
    String ans="" ;
    int count=0 ;
    for(int i=0 ; i<N*K ; i++){
      if(! sub[i] .equals(ans)){
        ans=sub[i];
        count++;
      }
      if(count==K)break ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var N : int ; N := s->size() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var sub : Sequence(String) ; sub := Integer.subrange(1,N * K)->collect(null) ;
    sub := sub->collect("zzzzzz") ; 
    var cnt : int ; cnt := -1 ;
        var i : int ; i := 1 ; while i <= Set{N, K}->min() do (         var j : int ; j := 0 ; while j < (N)->char2byte() - i + 1 do (         cnt := cnt + 1 ;
 sub[cnt+1] := s.subrange(j+1,j + i)  ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    sub := sub->sort() ; 
    var ans : String ; ans := "" ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N * K do ( (     if (not(sub[i+1] = ans)) then (     ans := sub[i+1] ; 
     count := count + 1 ) else skip ; 
     if (count = K) then     break else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    ArrayList<Integer>point=new ArrayList<Integer>();
    double[][] tresure=new double[1000][2];
    double angle=0.0 ;
    int num=0 ;
    int max=0 ;
    tresure[0][0]=1.0 ;
    tresure[0][1]=1.0 ;
    while((num=parseNum())!=-1){
      point.add(num);
      max=Math.max(max,num);
    }
    tresure[1][0]=1.0 ;
    tresure[1][1]=1.0 ;
    for(int n=2 ; n<max ; n++){
      angle=Math.atan2(-tresure[n-1][1],-tresure[n-1][0])/Math.PI*180.0+90.0 ;
      tresure[n][0]=tresure[n-1][0]-Math.cos(angle/180.0*Math.PI);
      tresure[n][1]=tresure[n-1][1]-Math.sin(angle/180.0*Math.PI);
    }
    for(int n=0 ; n<point.size(); n++){
      int item=point.get(n);
      System.out.printf("%.2f\n%.2f\n",tresure[item-1][0],tresure[item-1][1]);
    }
  }
  private static int parseNum(){
    int num=-1 ;
    String strIn=null ;
    if((strIn=parseStdin())!=null){
      num=Integer.parseInt(strIn);
    }
    return num ;
  }
  private static String parseStdin(){
    String strNum=null ;
    try {
      String line=br.readLine();
      if(line!=null){
        if(! line.isEmpty()){
          strNum=line ;
        }
      }
    }
    catch(IOException e){
    }
    return strNum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var point : Sequence(int) ; point := Sequence{} ;
     var tresure : Sequence(Sequence(double)) ; tresure := Integer.subrange(1,1000)->collect(Integer.subrange(1,2)->collect(0.0)) ;
    var angle : double ; angle := 0.0 ;
    var num : int ; num := 0 ;
    var max : int ; max := 0 ;
    tresure[0+1][0+1] := 1.0 ; 
    tresure[0+1][1+1] := 1.0 ; 
        num := parseNum() ;
    while ((num) /= -1) do (    skip ; (     point := point->including(num) ; 
     max := Set{max, num}->max() ) ;     num := parseNum() ;
 ) ;  
    tresure[1+1][0+1] := 1.0 ; 
    tresure[1+1][1+1] := 1.0 ; 
        var n : int ; n := 2 ; while n < max do ( (     angle := atan2(-tresure[n - 1+1][1+1], -tresure[n - 1+1][0+1]) / 3.141592653589793 * 180.0 + 90.0 ; 
     tresure[n+1][0+1] := tresure[n - 1+1][0+1] - (angle / 180.0 * 3.141592653589793)->cos() ; 
     tresure[n+1][1+1] := tresure[n - 1+1][1+1] - (angle / 180.0 * 3.141592653589793)->sin() )  ;     n := n + 1 ) ; 
        var n : int ; n := 0 ; while n < point->size() do ( (     var item : int ; item := point->at(n+1) ;
     OclFile["System.out"].printf("%.2f\n%.2f\n", tresure[item - 1+1][0+1], tresure[item - 1+1][1+1]) )  ;     n := n + 1 ) ; 
 );
  static   operation parseNum() : int
  pre: true
  post: true
  activity: (     var num : int ; num := -1 ;
     var strIn : String ; strIn := null ;
     if ((strIn) /= null) then (     num := (strIn)->toInteger() ) else skip ; 
     return num );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var strNum : String ; strNum := null ;
     try (     var line : String ; line := br.readLine() ;
     if (line /= null) then (     if (not(line->isEmpty())) then (     strNum := line ) else skip ) else skip )   catch (e : IOException) do skip
     return strNum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      String s=sc.next();
      int k=sc.nextInt();
      Set<String>set=new TreeSet<>();
      for(char ch='a' ; ch<='z' ; ch++){
        for(int i=0 ; i<s.length(); i++){
          if(s.charAt(i)==ch){
            for(int j=1 ; j<=5 ; j++){
              if(i+j<=s.length()){
                set.add(s.substring(i,i+j));
              }
            }
          }
        }
        if(set.size()>=k){
          break ;
        }
      }
      List<String>list=new ArrayList<>(set);
      String ans=list.get(k-1);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var s : String ; s := sc.getCurrent() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var set : Set(String) ; set := Set{} ;
        var ch : String ; ch := 'a' ; while ch <= 'z' do ( (         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = ch) then (         var j : int ; j := 1 ; while j <= 5 do ( (     if (i + j <= s->size()) then (     set := set->including(s.subrange(i+1,i + j)) ) else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
     if (set->size() >= k) then (     break ) else skip )  ;     ch := ch + 1 ) ; 
    var list : Sequence(String) ; list := Sequence{}->union(set) ;
    var ans : String ; ans := list->at((k)->char2byte() - 1+1) ;
    OclFile["System.out"].println(ans) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  private List<Integer>memo ;
  public Solution(){
    memo=new ArrayList();
    memo.add(0);
    memo.add(1);
  }
  public int fib(int N){
    if(N<memo.size())return memo.get(N);
    for(int i=memo.size(); i<=N ; i++){
      memo.add(memo.get(i-1)+memo.get(i-2));
    }
    return memo.get(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   attribute memo : Sequence(int);
   static operation newSolution() : Solution
  pre: true
  post: true
  activity:
  ( var self : Solution ;
    self := createSolution();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     memo := Sequence{} ; 
     memo := memo->including(0) ; 
     memo := memo->including(1) );
   operation fib( N : int) : int
  pre: true
  post: true
  activity: (     if (N < memo->size()) then     return memo->at(N+1) else skip ; 
         var i : int ; i := memo->size() ; while i <= N do ( (     memo := memo->including(memo->at(i - 1+1) + memo->at(i - 2+1)) )  ;     i := i + 1 ) ; 
     return memo->at(N+1) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class ForbiddenSubsequence {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int[] alph=new int[26];
      String s=sc.next();
      String abc=sc.next();
      for(int i=0 ; i<s.length(); i++){
        alph[s.charAt(i)-'a']++;
      }
      if(abc.equals("abc")&&(alph[0]>0 && alph[1]>0 && alph[2]>0)){
        StringBuilder res=new StringBuilder();
        for(int i=0 ; i<26 ; i++){
          if(i==1){
            while(alph[2]>0){
              res.append((char)(2+'a'));
              alph[2]--;
            }
            while(alph[1]>0){
              res.append((char)(1+'a'));
              alph[1]--;
            }
            i++;
          }
          else {
            while(alph[i]>0){
              res.append((char)(i+'a'));
              alph[i]--;
            }
          }
        }
        pw.println(res);
      }
      else {
        StringBuilder res=new StringBuilder();
        for(int i=0 ; i<26 ; i++){
          while(alph[i]>0){
            res.append((char)(i+'a'));
            alph[i]--;
          }
        }
        pw.println(res);
      }
    }
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ForbiddenSubsequence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var alph : Sequence(int) ; alph := Integer.subrange(1,26)->collect(0) ;
     var s : String ; s := sc.getCurrent() ;
    var abc : String ; abc := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     alph[s->at(i+1) - ('a')->char2byte()+1] := alph[s->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    if (abc = "abc" & (alph[0+1] > 0 & alph[1+1] > 0 & alph[2+1] > 0)) then (     var res : String ; res := StringLib.newString() ;
         var i : int ; i := 0 ; while i < 26 do ( (     if (i = 1) then (     while (alph[2+1] > 0) do (     res := res + StringLib.newString((2 + 'a')->oclAsType(String)) ; 
     alph[2+1] := alph[2+1] - 1 ) ; 
     while (alph[1+1] > 0) do (     res := res + StringLib.newString((1 + 'a')->oclAsType(String)) ; 
     alph[1+1] := alph[1+1] - 1 ) ; 
     i := i + 1 ) else (     while (alph[i+1] > 0) do (     res := res + StringLib.newString((i + 'a')->oclAsType(String)) ; 
     alph[i+1] := alph[i+1] - 1 ) ) )  ;     i := i + 1 ) ; 
     skip ) else (     var res : String ; res := StringLib.newString() ;
         var i : int ; i := 0 ; while i < 26 do ( (     while (alph[i+1] > 0) do (     res := res + StringLib.newString((i + 'a')->oclAsType(String)) ; 
     alph[i+1] := alph[i+1] - 1 ) )  ;     i := i + 1 ) ; 
     skip ) ;  
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math.*;
class GFG {
  static final double PI=3.142 ;
  static double cosXSertiesSum(double x,int n){
    x=x*(PI/180.0);
    double res=1 ;
    double sign=1,fact=1,pow=1 ;
    for(int i=1 ; i<5 ; i++){
      sign=sign*-1 ;
      fact=fact*(2*i-1)*(2*i);
      pow=pow*x*x ;
      res=res+sign*pow/fact ;
    }
    return res ;
  }
  public static void main(String[] args){
    float x=50 ;
    int n=5 ;
    System.out.println((float)(cosXSertiesSum(x,5)*1000000)/1000000.00);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute PI : double := 3.142;
  static   operation cosXSertiesSum( x : double, n : int) : double
  pre: true
  post: true
  activity: (     x := x * (PI / 180.0) ; 
     var res : double ; res := 1 ;
    var sign : double ; sign := 1 ;
    var fact : double ; fact := 1 ;
    var pow : double ; pow := 1 ;
        var i : int ; i := 1 ; while i < 5 do ( (     sign := sign * -1 ; 
     fact := fact * (2 * i - 1) * (2 * i) ; 
     pow := pow * x * x ; 
     res := res + sign * pow / fact )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : double ; x := 50 ;
     var n : int ; n := 5 ;
     OclFile["System.out"].println((cosXSertiesSum(x, 5) * 1000000)->oclAsType(double) / 1000000.00) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float findNumber(int N,int S){
    float i=(((float)(N)*(float)(N+1))/4)-((float)(S+1)/2);
    return i ;
  }
  static void check(int N,int S){
    float i=findNumber(N,S);
    int integerI=(int)i ;
    if(i-integerI==0)System.out.println("Yes: "+integerI+","+(integerI+1));
    else System.out.println("No");
  }
  public static void main(String[] args){
    int N=4,S=3 ;
    check(N,S);
    N=5 ;
    S=3 ;
    check(N,S);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNumber( N : int, S : int) : double
  pre: true
  post: true
  activity: (     var i : double ; i := (((N)->oclAsType(double) * (N + 1)->oclAsType(double)) / 4) - ((S + 1)->oclAsType(double) / 2) ;
     return i );
  static   operation check( N : int, S : int) : void
  pre: true
  post: true
  activity: (     var i : double ; i := findNumber(N, S) ;
     var integerI : int ; integerI := i->oclAsType(int) ;
     if (i - integerI = 0) then     OclFile["System.out"].println("Yes: " + integerI + "," + (integerI + 1)) ; else     OclFile["System.out"].println("No") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
    var S : int ; S := 3 ;
     execute check(N, S) ; 
    N := 5 ; 
    S := 3 ; 
    execute check(N, S) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      boolean[] composite=new boolean[1_000_000+1];
      int X=in.nextInt();
      for(int p=2 ; p*p<1_000_000+1 ; p++){
        if(! composite[p]){
          for(int i=p*2 ; i<1_000_000+1 ; i+=p){
            composite[i]=true ;
          }
        }
      }
      for(int i=X ; i<=1_000_000 ; i++){
        if(! composite[i]){
          out.print(i);
          return ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var composite : Sequence(boolean) ; composite := Integer.subrange(1,1_000_000 + 1)->collect(false) ;
     var X : int ; X := in.getCurrent()->toInteger() ;
         var p : int ; p := 2 ; while p * p < 1_000_000 + 1 do ( (     if (not(composite[p+1])) then (         var i : int ; i := p * 2 ; while i < 1_000_000 + 1 do ( (     composite[i+1] := true )  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
         var i : int ; i := X ; while i <= 1_000_000 do ( (     if (not(composite[i+1])) then (     skip ; 
     return ) else skip )  ;     i := i + 1 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static boolean multipleOfThree(int K,int dig0,int dig1){
    long sum=0 ;
    int temp=(dig0+dig1)% 10 ;
    sum=dig0+dig1 ;
    if(K==2){
      if(sum % 3==0)return true ;
      else return false ;
    }
    sum+=temp ;
    long numberofGroups=(K-3)/4 ;
    int remNumberofDigits=(K-3)% 4 ;
    sum+=(numberofGroups*20);
    for(int i=0 ; i<remNumberofDigits ; i++){
      temp=(2*temp)% 10 ;
      sum+=temp ;
    }
    if(sum % 3==0)return true ;
    else return false ;
  }
  static public void main(String[] args){
    int K=5,dig0=3,dig1=4 ;
    if(multipleOfThree(K,dig0,dig1))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation multipleOfThree( K : int, dig0 : int, dig1 : int) : boolean
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     var temp : int ; temp := (dig0 + dig1) mod 10 ;
    sum := dig0 + dig1 ; 
    if (K = 2) then (     if (sum mod 3 = 0) then     return true else     return false ) else skip ; 
    sum := sum+(temp) ; 
    var numberofGroups : long ; numberofGroups := (K - 3) / 4 ;
    var remNumberofDigits : int ; remNumberofDigits := (K - 3) mod 4 ;
    sum := sum+((numberofGroups * 20)) ; 
        var i : int ; i := 0 ; while i < remNumberofDigits do ( (     temp := (2 * temp) mod 10 ; 
     sum := sum+(temp) )  ;     i := i + 1 ) ; 
    if (sum mod 3 = 0) then     return true else     return false ;  
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var K : int ; K := 5 ;
    var dig0 : int ; dig0 := 3 ;
    var dig1 : int ; dig1 := 4 ;
     if (multipleOfThree(K, dig0, dig1)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      long[] a=new long[n];
      long[] b=new long[n];
      long sum=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
        sum+=a[i];
      }
      for(int i=0 ; i<n ; i++)b[i]=sc.nextInt();
      Arrays.sort(b);
      long ans=b[n-1]+b[n-2];
      if(sum<=ans)System.out.println("YES");
      else System.out.println("NO");
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     b[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    b := b->sort() ; 
    var ans : long ; ans := b[n - 1+1] + b[n - 2+1] ;
    if (sum <= ans) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class CP {
  public static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(String s)throws FileNotFoundException {
      br=new BufferedReader(new InputStreamReader(new FileInputStream(s)));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
  static private long gcd(long a,long b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  static private void printArrayList(ArrayList<Object>al){
    for(Object i : al){
      System.out.print(i+" ");
    }
    System.out.println();
  }
  static private int digitSum(int n){
    int sum=0 ;
    while(n!=0){
      sum+=n % 10 ;
      n=n/10 ;
    }
    return sum ;
  }
  public static void main(String[] args){
    try {
      Scanner s=new Scanner(System.in);
      StringBuffer sb=new StringBuffer();
      int n=s.nextInt();
      long sum=0 ;
      for(int i=0 ; i<n ; i++){
        sum+=s.nextInt();
      }
      ArrayList<Integer>al=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        al.add(s.nextInt());
      }
      Collections.sort(al);
      if((al.get(al.size()-1)+al.get(al.size()-2))>=sum)sb.append("YES\n");
      else sb.append("NO\n");
      System.out.println(sb);
    }
    catch(Exception e){
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CP {
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( s : String) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static    operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static    operation printArrayList( al : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     for (i : al) do ( (     OclFile["System.out"].print(i + " ") )  ) ; 
     OclFile["System.out"].println() );
  static    operation digitSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n /= 0) do (     sum := sum+(n mod 10) ; 
     n := n / 10 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := s.getCurrent()->toInteger() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(s.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var al : Sequence(int) ; al := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     al := al->including(s.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    al := al->sort() ; 
    if ((al->at(al->size() - 1+1) + al->at(al->size() - 2+1)) >= sum) then     sb := sb + StringLib.newString("YES\n") else     sb := sb + StringLib.newString("NO\n") ; ;  
    OclFile["System.out"].println(sb) ; 
 )   catch (e : ProgramException) do (     OclFile["System.out"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Greed {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] b=new long[n];
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=sc.nextLong();
    }
    for(int i=0 ; i<n ; i++){
      b[i]=sc.nextLong();
    }
    Arrays.sort(b);
    if(sum<=b[n-1]+b[n-2])System.out.println("YES");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Greed {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(sc.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    b := b->sort() ; 
    if (sum <= b[n - 1+1] + b[n - 2+1]) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    TreeMap<Integer,Integer>map=new TreeMap<Integer,Integer>();
    while(n-->0){
      int num=sc.nextInt();
      if(map.lowerKey(num)==null){
        int val=map.getOrDefault(num,0);
        map.put(num,++val);
      }
      else {
        int key=map.lowerKey(num);
        int val=map.get(key);
        if(val==1){
          map.remove(key);
        }
        else {
          map.put(key,--val);
        }
        val=map.getOrDefault(num,0);
        map.put(num,++val);
      }
    }
    int ans=0 ;
    for(Integer key : map.keySet()){
      int val=map.get(key);
      ans+=val ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var map : Map(int,int) ; map := Map{} ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var num : int ; num := sc.getCurrent()->toInteger() ;
     if (map.lowerKey(num) = null) then (     var val : int ; val := (if map->keys()->contains(num) then map->at(num) else 0 endif) ;
     map := map->union(Map{num |-> (val + 1)}) ) else (     var key : int ; key := map.lowerKey(num) ;
     var val : int ; val := map->at(key) ;
    if (val = 1) then (     map := map->antirestrict(Set{key}) ) else (     map := map->union(Map{key |-> (val - 1)}) ) ;  
    val := (if map->keys()->contains(num) then map->at(num) else 0 endif) ; 
    map := map->union(Map{num |-> (val + 1)}) ; 
 ) ) ;  ) ;  
    var ans : int ; ans := 0 ;
    for (key : map->keys()) do ( (     var val : int ; val := map->at(key) ;
     ans := ans+(val) )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long volume[]=new long[(int)n];
    long capacity[]=new long[(int)n];
    for(int i=0 ; i<n ; i++){
      volume[(int)i]=sc.nextLong();
    }
    for(int i=0 ; i<n ; i++){
      capacity[(int)i]=sc.nextLong();
    }
    long remaining=0 ;
    for(int i=0 ; i<n ; i++){
      remaining=remaining+volume[(int)i];
    }
    Arrays.sort(capacity);
    if(remaining<=(capacity[(int)n-1]+capacity[(int)n-2])){
      System.out.println("YES");
      System.exit(0);
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var volume : Sequence(long) ; volume := Integer.subrange(1,n->oclAsType(int))->collect(0) ;
    var capacity : Sequence(long) ; capacity := Integer.subrange(1,n->oclAsType(int))->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     volume[i->oclAsType(int)+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     capacity[i->oclAsType(int)+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var remaining : long ; remaining := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     remaining := remaining + volume[i->oclAsType(int)+1] )  ;     i := i + 1 ) ; 
    capacity := capacity->sort() ; 
    if (remaining <= (capacity[n->oclAsType(int) - 1+1] + capacity[n->oclAsType(int) - 2+1])) then (     OclFile["System.out"].println("YES") ; 
 OclProcess.exit(0) ) else skip ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countOcc(String s){
    int cnt=0 ;
    for(int i=0 ; i<s.length()-3 ; i++){
      int c=0,l=0,a=0,p=0 ;
      for(int j=i ; j<i+4 ; j++){
        switch(s.charAt(j)){
          case 'c' : c++;
          break ;
          case 'l' : l++;
          break ;
          case 'a' : a++;
          break ;
          case 'p' : p++;
          break ;
        }
      }
      if(c==1 && l==1 && a==1 && p==1)cnt++;
    }
    return cnt ;
  }
  public static void main(String args[]){
    String s="clapc" ;
    System.out.print(countOcc(s.toLowerCase()));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countOcc( s : String) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < s->size() - 3 do ( (     var c : int ; c := 0 ;
    var l : int ; l := 0 ;
    var a : int ; a := 0 ;
    var p : int ; p := 0 ;
         var j : int ; j := i ; while j < i + 4 do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (s->at(j+1)) ; 
       if _switchval = 'c' then
     c := c + 1 ; 
    break 
   else skip ;
       if _switchval = 'l' then
     l := l + 1 ; 
    break 
   else skip ;
       if _switchval = 'a' then
     a := a + 1 ; 
    break 
   else skip ;
       if _switchval = 'p' then
     p := p + 1 ; 
    break 
   else skip ;
 )
 )  ;     j := j + 1 ) ; 
     if (c = 1 & l = 1 & a = 1 & p = 1) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "clapc" ;
     OclFile["System.out"].print(countOcc(s->toLowerCase())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countSteps(int x,int y){
    if(x % y==0)return x/y ;
    return x/y+countSteps(y,x % y);
  }
  public static void main(String[] args){
    int x=100,y=19 ;
    System.out.println(countSteps(x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSteps( x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (x mod y = 0) then     return x / y else skip ; 
     return x / y + countSteps(y, x mod y) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 100 ;
    var y : int ; y := 19 ;
     OclFile["System.out"].println(countSteps(x, y)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPerfectSquare(double x){
    double sr=Math.sqrt(x);
    return((sr-Math.floor(sr))==0);
  }
  static boolean isSunnyNum(int n){
    if(isPerfectSquare(n+1))return true ;
    return false ;
  }
  public static void main(String[] args){
    int n=3 ;
    if(isSunnyNum(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPerfectSquare( x : double) : boolean
  pre: true
  post: true
  activity: (     var sr : double ; sr := (x)->sqrt() ;
     return ((sr - (sr)->floor()) = 0) );
  static   operation isSunnyNum( n : int) : boolean
  pre: true
  post: true
  activity: (     if (isPerfectSquare(n + 1)) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     if (isSunnyNum(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  static double PI=3.14159265 ;
  public static double area_inscribed(double P,double B,double H){
    return((P+B-H)*(P+B-H)*(PI/4));
  }
  public static void main(String[] args){
    double P=3,B=4,H=5 ;
    System.out.println(area_inscribed(P,B,H));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute PI : double := 3.14159265;
  static   operation area_inscribed( P : double, B : double, H : double) : double
  pre: true
  post: true
  activity: (     return ((P + B - H) * (P + B - H) * (PI / 4)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var P : double ; P := 3 ;
    var B : double ; B := 4 ;
    var H : double ; H := 5 ;
     OclFile["System.out"].println(area_inscribed(P, B, H)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int N=sc.nextInt();
      if(N==0){
        break ;
      }
      char replaces[]=new char[256];
      for(int i=0 ; i<N ; i++){
        replaces[sc.next().toCharArray()[0] ]=sc.next().toCharArray()[0];
      }
      long M=sc.nextLong();
      for(long i=0 ; i<M ; i++){
        char c=sc.next().toCharArray()[0];
        System.out.print(replaces[c]!=0 ? replaces[c] : c);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then (     break ) else skip ; 
    var replaces : Sequence(String) ; replaces := Integer.subrange(1,256)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     replaces[sc.getCurrent()->characters()[0+1]+1] := sc.getCurrent()->characters()[0+1] )  ;     i := i + 1 ) ; 
    var M : long ; M := sc.getCurrent()->toLong() ;
        var i : long ; i := 0 ; while i < M do ( (     var c : String ; c := sc.getCurrent()->characters()[0+1] ;
     OclFile["System.out"].print(if replaces[c+1] /= 0 then replaces[c+1] else c endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.Math ;
class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int x=Integer.parseInt(stdIn.next());
    if(x!=2 && x % 2==0)x++;
    while(true){
      int i ;
      double sqrtNum=Math.sqrt(x);
      for(i=3 ; i<=sqrtNum ; i+=2){
        if(x % i==0)break ;
      }
      if(i>sqrtNum)break ;
      x+=2 ;
    }
    System.out.println(x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := (stdIn.getCurrent())->toInteger() ;
    if (x /= 2 & x mod 2 = 0) then     x := x + 1 ; else skip ; 
    while (true) do (     var i : int ;
     var sqrtNum : double ; sqrtNum := (x)->sqrt() ;
        i := 3 ; while i <= sqrtNum do ( (     if (x mod i = 0) then     break else skip )  ;     i := i+(2) ) ; 
    if (i > sqrtNum) then     break else skip ; 
    x := x+(2) ; 
 ) ; 
    OclFile["System.out"].println(x) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    int n=0 ;
    String[] conv=new String[123];
    while((line=br.readLine())!=null){
      if(n==0){
        if((n=Integer.parseInt(line))==0)break ;
      }
      else {
        if(line.contains(" ")){
          conv[line.charAt(0)]=line.substring(2);
        }
        else {
          if(conv[line.charAt(0)]!=null)System.out.print(conv[line.charAt(0)]);
          else System.out.print(line);
        }
        n--;
        if(n==0 && line.length()==1){
          System.out.println();
          conv=new String[123];
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
    var n : int ; n := 0 ;
    var conv : Sequence(String) ; conv := Integer.subrange(1,123)->collect(null) ;
        line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     if (n = 0) then (     if ((n) = 0) then     break else skip ) else (     if (line->includes(" ")) then (     conv[line->at(0+1)+1] := line.subrange(2+1,2) ) else (     if (conv[line->at(0+1)+1] /= null) then     OclFile["System.out"].print(conv[line->at(0+1)+1]) ; else     OclFile["System.out"].print(line) ; ) ;  
     n := n - 1 ; 
     if (n = 0 & line->size() = 1) then (     OclFile["System.out"].println() ; 
     conv := Integer.subrange(1,123)->collect(null) ) else skip ) ) ;     line := br.readLine() ;
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      Map<String,String>map=new HashMap<String,String>();
      while(n--!=0){
        map.put(sc.next(),sc.next());
      }
      int m=sc.nextInt();
      StringBuilder sb=new StringBuilder();
      while(m--!=0){
        String s=sc.next();
        if(map.containsKey(s))sb.append(map.get(s));
        else sb.append(s);
      }
      System.out.println(sb.toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var map : Map(String,String) ; map := Map{} ;
        while (n /= 0) do (    skip ; (     map := map->union(Map{sc.getCurrent() |-> sc.getCurrent()}) ) ;  ) ;  
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        while (m /= 0) do (    skip ; (     var s : String ; s := sc.getCurrent() ;
     if (map->keys()->includes(s)) then     sb := sb + StringLib.newString(map->at(s)) ; else     sb := sb + StringLib.newString(s) ; ) ;  ) ;  
    OclFile["System.out"].println(sb+"") ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  private StringTokenizer st ;
  private BufferedReader bf ;
  private int w ;
  Main(){
    readData();
  }
  private void readData(){
    try {
      bf=new BufferedReader(new InputStreamReader(System.in));
      st=new StringTokenizer(bf.readLine());
      while(true){
        int m=nextInt();
        if(m==0)break ;
        boolean[] r=new boolean[256];
        char[] table=new char[256];
        for(int i=0 ; i<256 ; i++)table[i]=(char)i ;
        for(int i=0 ; i<m ; i++){
          char a=next().charAt(0);
          char b=next().charAt(0);
          table[a]=b ;
          r[a]=true ;
        }
        int n=nextInt();
        String tmp ;
        StringBuilder result=new StringBuilder();
        for(int i=0 ; i<n ; i++){
          tmp=next();
          char c=tmp.charAt(0);
          if(r[c]){
            result.append(table[c]);
          }
          else {
            result.append(c);
          }
        }
        System.out.println(result.toString());
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  private int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  private String next()throws IOException {
    if(st==null || ! st.hasMoreTokens())st=new StringTokenizer(bf.readLine());
    return st.nextToken();
  }
  public static void main(String[] args){
    Main m=new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute st : OclIterator;
   attribute bf : OclFile;
   attribute w : int;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute readData() );
   operation readData() : void
  pre: true
  post: true
  activity: (     try (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := OclIterator.newOclIterator_String(bf.readLine()) ; 
     while (true) do (     var m : int ; m := nextInt() ;
     if (m = 0) then     break else skip ; 
    var r : Sequence(boolean) ; r := Integer.subrange(1,256)->collect(false) ;
    var table : Sequence(String) ; table := Integer.subrange(1,256)->collect(0) ;
        var i : int ; i := 0 ; while i < 256 do (     table[i+1] := i->oclAsType(String) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var a : String ; a := next()->at(0+1) ;
     var b : String ; b := next()->at(0+1) ;
     table[a+1] := b ; 
     r[a+1] := true )  ;     i := i + 1 ) ; 
    var n : int ; n := nextInt() ;
    var tmp : String ;
    var result : String ; result := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     tmp := next() ; 
     var c : String ; c := tmp->at(0+1) ;
     if (r[c+1]) then (     result := result + StringLib.newString(table[c+1]) ) else (     result := result + StringLib.newString(c) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result+"") ; 
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation next() : String
  pre: true
  post: true
  activity: (     if (st = null or not(st.hasNext())) then     st := OclIterator.newOclIterator_String(bf.readLine()) ; else skip ; 
     return st.next() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; ++i){
      long current=scanner.nextLong();
      a[i]=current ;
    }
    List<Long>numbers=new ArrayList<>();
    for(long num : a){
      int value=Collections.binarySearch(numbers,num);
      if(value>=0 && value<numbers.size()){
        int lessValue=Collections.binarySearch(numbers,num-1);
        if(lessValue>=0 && lessValue<numbers.size()){
          numbers.set(lessValue,num);
        }
        else {
          int lessPos=-1*(lessValue+1);
          if(lessPos-1>=0 && numbers.get(lessPos-1)<num){
            numbers.set(lessPos-1,num);
          }
          else {
            numbers.add(value,num);
          }
        }
        continue ;
      }
      int pos=-1*(value+1);
      if(pos-1>=0 && numbers.get(pos-1)<num){
        numbers.set(pos-1,num);
      }
      else {
        numbers.add(pos,num);
      }
    }
    System.out.println(numbers.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var current : long ; current := scanner.getCurrent()->toLong() ;
     a[i+1] := current )  ;     i := i + 1 ) ; 
    var numbers : Sequence(long) ; numbers := Sequence{} ;
    for (num : a) do ( (     var value : int ; value := .binarySearch(numbers, num) ;
     if (value >= 0 & value < numbers->size()) then (     var lessValue : int ; lessValue := .binarySearch(numbers, num - 1) ;
     if (lessValue >= 0 & lessValue < numbers->size()) then (     numbers := numbers.setAt(lessValue+1,num) ) else (     var lessPos : int ; lessPos := -1 * (lessValue + 1) ;
     if (lessPos - 1 >= 0 & numbers->at(lessPos - 1+1) < num) then (     numbers := numbers.setAt(lessPos - 1+1,num) ) else (     numbers := numbers.insertAt(value+1,num) ) ) ;  
     continue ) else skip ; 
     var pos : int ; pos := -1 * (value + 1) ;
     if (pos - 1 >= 0 & numbers->at(pos - 1+1) < num) then (     numbers := numbers.setAt(pos - 1+1,num) ) else (     numbers := numbers.insertAt(pos+1,num) ) )  ) ; 
    OclFile["System.out"].println(numbers->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb ;
    StringTokenizer st ;
    try {
      while(true){
        String line ;
        sb=new StringBuilder();
        Map<String,String>convTable=new HashMap<>();
        int convTableNum=Integer.parseInt(br.readLine().trim());
        if(convTableNum==0){
          break ;
        }
        for(int i=0 ; i<convTableNum ; i++){
          line=br.readLine();
          st=new StringTokenizer(line);
          convTable.put(st.nextToken(),st.nextToken());
        }
        int dataNum=Integer.parseInt(br.readLine().trim());
        for(int i=0 ; i<dataNum ; i++){
          line=br.readLine().trim();
          for(Map.Entry<String,String>entry : convTable.entrySet()){
            if(entry.getKey().equals(line)){
              line=entry.getValue();
              break ;
            }
          }
          sb.append(line);
        }
        System.out.println(sb.toString());
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ;
     var st : OclIterator ;
     try (     while (true) do (     var line : String ;
     sb := StringLib.newString() ; 
    var convTable : Map(String,String) ; convTable := Map{} ;
    var convTableNum : int ; convTableNum := (br.readLine()->trim())->toInteger() ;
    if (convTableNum = 0) then (     break ) else skip ; 
        var i : int ; i := 0 ; while i < convTableNum do ( (     line := br.readLine() ; 
     st := OclIterator.newOclIterator_String(line) ; 
     convTable := convTable->union(Map{st.next() |-> st.next()}) )  ;     i := i + 1 ) ; 
    var dataNum : int ; dataNum := (br.readLine()->trim())->toInteger() ;
        var i : int ; i := 0 ; while i < dataNum do ( (     line := br.readLine()->trim() ; 
     for (entry : convTable->asSet()) do ( (     if (entry.getKey() = line) then (     line := entry.getValue() ; 
     break ) else skip )  ) ; 
     sb := sb + StringLib.newString(line) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int getCount(int[] v,int n){
    Arrays.sort(v);
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      int tmp=n-1-upperBound(v,n,v[i]-1);
      if(tmp==v[i])cnt++;
    }
    return cnt ;
  }
  static int upperBound(int[] array,int length,int value){
    int low=0 ;
    int high=length ;
    while(low<high){
      final int mid=(low+high)/2 ;
      if(value>=array[mid]){
        low=mid+1 ;
      }
      else {
        high=mid ;
      }
    }
    return low ;
  }
  public static void main(String[] args){
    int n=4 ;
    int[] v={
      1,2,3,4 };
      System.out.println(getCount(v,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getCount( v : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     v := v->sort() ; 
     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var tmp : int ; tmp := n - 1 - upperBound(v, n, v[i+1] - 1) ;
     if (tmp = v[i+1]) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation upperBound( array : Sequence(int), length : int, value : int) : int
  pre: true
  post: true
  activity: (     var low : int ; low := 0 ;
     var high : int ; high := length ;
     while (low < high) do (     var mid : int ; mid := (low + high) / 2 ;
     if (value >= array[mid+1]) then (     low := mid + 1 ) else (     high := mid ) ) ; 
     return low );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var v : Sequence(int) ; v := Sequence{1,2,3,4} ;
     OclFile["System.out"].println(getCount(v, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int trailing_zeros(int N){
    int count_of_two=0,count_of_five=0 ;
    for(int i=1 ; i<=N ; i++){
      int val=i ;
      while(val % 2==0 && val>0){
        val/=2 ;
        count_of_two+=i ;
      }
      while(val % 5==0 && val>0){
        val/=5 ;
        count_of_five+=i ;
      }
    }
    int ans=Math.min(count_of_two,count_of_five);
    return ans ;
  }
  public static void main(String[] args){
    int N=12 ;
    System.out.println(trailing_zeros(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation trailing_zeros( N : int) : int
  pre: true
  post: true
  activity: (     var count_of_two : int ; count_of_two := 0 ;
    var count_of_five : int ; count_of_five := 0 ;
         var i : int ; i := 1 ; while i <= N do ( (     var val : int ; val := i ;
     while (val mod 2 = 0 & val > 0) do (     val := val/(2) ; 
     count_of_two := count_of_two+(i) ) ; 
     while (val mod 5 = 0 & val > 0) do (     val := val/(5) ; 
     count_of_five := count_of_five+(i) ) )  ;     i := i + 1 ) ; 
     var ans : int ; ans := Set{count_of_two, count_of_five}->min() ;
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 12 ;
     OclFile["System.out"].println(trailing_zeros(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GfG {
  public static int removeZero(int n){
    int res=0 ;
    int d=1 ;
    while(n>0){
      if(n % 10!=0){
        res+=(n % 10)*d ;
        d*=10 ;
      }
      n/=10 ;
    }
    return res ;
  }
  public static boolean isEqual(int a,int b){
    if(removeZero(a)+removeZero(b)==removeZero(a+b))return true ;
    return false ;
  }
  public static void main(String[] args){
    int a=105,b=106 ;
    if(isEqual(a,b)==true)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation removeZero( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     var d : int ; d := 1 ;
     while (n > 0) do (     if (n mod 10 /= 0) then (     res := res+((n mod 10) * d) ; 
     d := d*(10) ) else skip ; 
     n := n/(10) ) ; 
     return res );
  static   operation isEqual( a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     if (removeZero(a) + removeZero(b) = removeZero(a + b)) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 105 ;
    var b : int ; b := 106 ;
     if (isEqual(a, b) = true) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    new Main().mainrun();
  }
  Scanner scan ;
  private int N ;
  private final long MOD=1000000007 ;
  private Node[] node ;
  private void mainrun(){
    scan=new Scanner(System.in);
    N=scan.nextInt();
    node=new Node[N];
    for(int i=0 ; i<N ; i++){
      node[i]=new Node(scan.next());
    }
    for(int i=0 ; i<N-1 ; i++){
      node[scan.nextInt()-1] .child.add(scan.nextInt()-1);
    }
    System.out.println(looprun(node[0])% MOD);
    scan.close();
  }
  private long looprun(Node n){
    long ans=1 ;
    switch(n.type){
      case "E" : for(Integer no : n.child){
        ans*=looprun(node[no]);
        ans %=MOD ;
      }
      if(n.isOption){
        ans+=1 ;
      }
      break ;
      case "R" : for(Integer no : n.child){
        ans*=looprun(node[no])+1 ;
        ans %=MOD ;
      }
      if(! n.isOption){
        ans-=1 ;
      }
      break ;
      case "A" : for(Integer no : n.child){
        ans+=looprun(node[no]);
      }
      if(! n.isOption){
        ans-=1 ;
      }
      break ;
    }
    return ans ;
  }
}
class Node {
  String type ;
  boolean isOption ;
  LinkedList<Integer>child ;
  Node(String str){
    String[] sp=str.split("");
    type=sp[0];
    isOption=(sp.length==2);
    child=new LinkedList<>();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().mainrun() );
   attribute scan : OclFile;
   attribute N : int;
   attribute MOD : long := 1000000007;
   attribute node : Sequence(Node);
   operation mainrun() : void
  pre: true
  post: true
  activity: (     scan := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     N := scan.getCurrent()->toInteger() ; 
    node := Integer.subrange(1,N)->collect(null) ; 
        var i : int ; i := 0 ; while i < N do ( (     node[i+1] := Node.newNode(scan.getCurrent()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     node[scan.getCurrent()->toInteger() - 1+1].child->excludes(scan.getCurrent()->toInteger() - 1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(looprun(node[0+1]) mod MOD) ; 
    skip ; 
 );
   operation looprun( n : Node) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (n.type) ; 
       if _switchval = "E" then
     for (no : n.child) do ( (     ans := ans*(looprun(node[no+1])) ; 
     ans := ans mod MOD )  ) ; 
    if (n.isOption) then (     ans := ans+(1) ) else skip ; 
    break 
   else skip ;
       if _switchval = "R" then
     for (no : n.child) do ( (     ans := ans*(looprun(node[no+1]) + 1) ; 
     ans := ans mod MOD )  ) ; 
    if (not(n.isOption)) then (     ans := ans-(1) ) else skip ; 
    break 
   else skip ;
       if _switchval = "A" then
     for (no : n.child) do ( (     ans := ans+(looprun(node[no+1])) )  ) ; 
    if (not(n.isOption)) then (     ans := ans-(1) ) else skip ; 
    break 
   else skip ;
 )
     return ans );
}
class Node {
   attribute type : String;
   attribute isOption : boolean;
   attribute child : Sequence(int);
   static operation newNode( str : String) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(str);
    return self );
  operation initialise( str : String) : void
  pre: true  post: true
  activity: (     var sp : Sequence(String) ; sp := str->split("") ;
     type := sp[0+1] ; 
     isOption := (sp->size() = 2) ; 
     child := Sequence{} );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=s.charAt(i)-'0' ;
    }
    for(int j=0 ; j<n-1 ; j++){
      a[j]=Math.abs(a[j]-a[j+1]);
    }
    boolean all02=true ;
    for(int j=0 ; j<n-1 ; j++){
      if(a[j]==1){
        all02=false ;
      }
    }
    int[] b=new int[n-1];
    b[0]=0 ;
    for(int i=1 ; i<n-1 ; i++){
      b[i]=b[i-1];
      int j=i ;
      int k=n-1-i ;
      while(k % 2==0){
        k>>=1 ;
        b[i]++;
      }
      while(j % 2==0){
        j>>=1 ;
        b[i]--;
      }
    }
    int ans=0 ;
    for(int j=0 ; j<n-1 ; j++){
      if(b[j]==0){
        ans ^=a[j];
      }
    }
    System.out.println(all02 ? ans : ans % 2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := s->at(i+1) - ('0')->char2byte() )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < n - 1 do ( (     a[j+1] := if a[j+1] - a[j + 1+1] < 0 then -(a[j+1] - a[j + 1+1]) else a[j+1] - a[j + 1+1] endif )  ;     j := j + 1 ) ; 
    var all02 : boolean ; all02 := true ;
        var j : int ; j := 0 ; while j < n - 1 do ( (     if (a[j+1] = 1) then (     all02 := false ) else skip )  ;     j := j + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,n - 1)->collect(0) ;
    b[0+1] := 0 ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     b[i+1] := b[i - 1+1] ; 
     var j : int ; j := i ;
    var k : int ; k := n - 1 - i ;
    while (k mod 2 = 0) do (     k := k/(2->pow(1)) ; 
     b[i+1] := b[i+1] + 1 ) ; 
    while (j mod 2 = 0) do (     j := j/(2->pow(1)) ; 
     b[i+1] := b[i+1] - 1 ) ; 
 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var j : int ; j := 0 ; while j < n - 1 do ( (     if (b[j+1] = 0) then (     ans := MathLib.bitwiseXor(ans,a[j+1]) ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(if all02 then ans else ans mod 2 endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private int cal(String s,char c){
    int n=s.length();
    int m=n-1 ;
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)==c &&(m & i)==i){
        ans ^=1 ;
      }
    }
    return ans ;
  }
  private void solve(){
    int n=sc.nextInt();
    String s=sc.next();
    StringBuilder sb=new StringBuilder();
    for(int i=1 ; i<n ; i++){
      sb.append(Math.abs(s.charAt(i)-s.charAt(i-1)));
    }
    if(n==2){
      out.println(sb.charAt(0));
      return ;
    }
    s=sb.toString();
    if(s.contains("1")){
      out.println(cal(s,'1'));
    }
    else {
      out.println(cal(s,'2')*2);
    }
  }
  private static PrintWriter out ;
  private static MyScanner sc ;
  private static class MyScanner {
    BufferedReader br ;
    StringTokenizer st ;
    private 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());
    }
  }
  public static void main(String[] args){
    out=new PrintWriter(new BufferedOutputStream(System.out));
    sc=new MyScanner();
    new Main().solve();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation cal( s : String, c : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var m : int ; m := n - 1 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = c & (MathLib.bitwiseAnd(m,i)) = i) then (     ans := MathLib.bitwiseXor(ans,1) ) else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var s : String ; s := sc.next() ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 1 ; while i < n do ( (     sb := sb + StringLib.newString(if s->at(i+1) - s->at((i)->char2byte() - 1+1) < 0 then -(s->at(i+1) - s->at((i)->char2byte() - 1+1)) else s->at(i+1) - s->at((i)->char2byte() - 1+1) endif) )  ;     i := i + 1 ) ; 
    if (n = 2) then (     out.println(sb->at(0+1)) ; 
     return ) else skip ; 
    s := sb+"" ; 
    if (s->includes("1")) then (     out.println(cal(s, '1')) ) else (     out.println(cal(s, '2') * 2) ) ;  
 );
  static   attribute out : OclFile;
  static   attribute sc : MyScanner;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
     sc := MyScanner.newMyScanner() ; 
     Main.newMain().solve() ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.*;
import java.awt.geom.*;
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] in=sc.next().toCharArray();
    for(int i=0 ; i<in.length ; i++){
      if(in[i]!='A' && in[i]!='Z'){
        in[i]=0 ;
      }
    }
    boolean nowA=true ;
    for(int i=0 ; i<in.length ; i++){
      if(in[i]==0)continue ;
      if(nowA && in[i]=='Z'){
        in[i]=0 ;
        continue ;
      }
      if(! nowA && in[i]=='A'){
        in[i]=0 ;
        continue ;
      }
      if(in[i]=='A'){
        nowA=false ;
      }
      if(in[i]=='Z'){
        nowA=true ;
      }
    }
    for(int i=in.length-1 ; i>=0 ; i--){
      if(in[i]==0)continue ;
      if(in[i]=='A'){
        in[i]=0 ;
        break ;
      }
      if(in[i]=='Z'){
        break ;
      }
    }
    boolean check=false ;
    for(int i=0 ; i<in.length ; i++){
      if(in[i]=='A'){
        check=true ;
        break ;
      }
    }
    if(check)for(int i=0 ;
    i<in.length ;
    i++){
      if(in[i]!=0)System.out.print(in[i]);
    }
    else System.out.print(-1);
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var in : Sequence(String) ; in := sc.getCurrent()->characters() ;
        var i : int ; i := 0 ; while i < in->size() do ( (     if (in[i+1] /= 'A' & in[i+1] /= 'Z') then (     in[i+1] := 0 ) else skip )  ;     i := i + 1 ) ; 
    var nowA : boolean ; nowA := true ;
        var i : int ; i := 0 ; while i < in->size() do ( (     if (in[i+1] = 0) then     continue else skip ; 
     if (nowA & in[i+1] = 'Z') then (     in[i+1] := 0 ; 
     continue ) else skip ; 
    if (not(nowA) & in[i+1] = 'A') then (     in[i+1] := 0 ; 
     continue ) else skip ; 
    if (in[i+1] = 'A') then (     nowA := false ) else skip ; 
    if (in[i+1] = 'Z') then (     nowA := true ) else skip ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := in->size() - 1 ; while i >= 0 do ( (     if (in[i+1] = 0) then     continue else skip ; 
     if (in[i+1] = 'A') then (     in[i+1] := 0 ; 
     break ) else skip ; 
     if (in[i+1] = 'Z') then (     break ) else skip )  ;     i := i - 1 ) ; 
    var check : boolean ; check := false ;
        var i : int ; i := 0 ; while i < in->size() do ( (     if (in[i+1] = 'A') then (     check := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (check) then         var i : int ; i := 0 ; while i < in->size() do ( (     if (in[i+1] /= 0) then     OclFile["System.out"].print(in[i+1]) ; else skip )  ;     i := i + 1 ) else     OclFile["System.out"].print(-1) ; ;  
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner in=new Scanner(System.in)){
      int X=in.nextInt();
      int N=(int)1e6 ;
      boolean[] isPrime=new boolean[N];
      Arrays.fill(isPrime,true);
      for(int n=2 ; n<N ; n++){
        if(! isPrime[n]){
          continue ;
        }
        for(int i=n+n ; i<N ; i+=n){
          if(isPrime[i]){
            isPrime[i]=false ;
          }
        }
      }
      for(int x=X ; x<N ; x++){
        if(isPrime[x]){
          System.out.println(x);
          return ;
        }
      }
      throw new AssertionError();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var X : int ; X := in.getCurrent()->toInteger() ;
     var N : int ; N := 1e6->oclAsType(int) ;
    var isPrime : Sequence(boolean) ; isPrime := Integer.subrange(1,N)->collect(false) ;
    isPrime := isPrime->collect(true) ; 
        var n : int ; n := 2 ; while n < N do ( (     if (not(isPrime[n+1])) then (     continue ) else skip ; 
         var i : int ; i := n + n ; while i < N do ( (     if (isPrime[i+1]) then (     isPrime[i+1] := false ) else skip )  ;     i := i+(n) ) )  ;     n := n + 1 ) ; 
        var x : int ; x := X ; while x < N do ( (     if (isPrime[x+1]) then (     OclFile["System.out"].println(x) ; 
     return ) else skip )  ;     x := x + 1 ) ; 
    error AssertionException() ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=Integer.parseInt(scanner.nextLine());
    if(n==1){
      System.out.println(scanner.nextInt());
      return ;
    }
    char[] chars=scanner.nextLine().toCharArray();
    int[] a=new int[n-1];
    for(int i=1 ; i<n ; i++){
      a[i-1]=Math.abs(chars[i]-chars[i-1]);
    }
    if(n==2){
      System.out.println(a[0]);
      return ;
    };
    System.out.println(solution(a));
  }
  public static int solution(int[] a){
    int n=a.length ;
    if(! findParity(a))return 1 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]==1)return 0 ;
      a[i]/=2 ;
    }
    if(findParity(a))return 0 ;
    else return 2 ;
  }
  private static boolean findParity(int[] a){
    int n=a.length ;
    int ans=a[0] ^ a[n-1];
    int pow=0 ;
    for(int i=1 ; i<n-1 ; i++){
      if((i & 1)==0){
        int c=0 ;
        int t=i ;
        while((t & 1)==0){
          t>>=1 ;
          c++;
        }
        pow-=c ;
      }
      if(((n-i)& 1)==0){
        int c=0 ;
        int t=n-i ;
        while((t & 1)==0){
          t>>=1 ;
          c++;
        }
        pow+=c ;
      }
      if(pow==0){
        ans=ans ^ a[i];
      }
    }
    return(ans & 1)==0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (scanner.nextLine())->toInteger() ;
    if (n = 1) then (     OclFile["System.out"].println(scanner.getCurrent()->toInteger()) ; 
     return ) else skip ; 
    var chars : Sequence(String) ; chars := scanner.nextLine()->characters() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n - 1)->collect(0) ;
        var i : int ; i := 1 ; while i < n do ( (     a[i - 1+1] := if chars[i+1] - chars[i - 1+1] < 0 then -(chars[i+1] - chars[i - 1+1]) else chars[i+1] - chars[i - 1+1] endif )  ;     i := i + 1 ) ; 
    if (n = 2) then (     OclFile["System.out"].println(a[0+1]) ; 
     return ) else skip ; 
    OclFile["System.out"].println(solution(a)) ; 
 );
  static   operation solution( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() ;
     if (not(findParity(a))) then     return 1 else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = 1) then     return 0 else skip ; 
     a[i+1] := a[i+1]/(2) )  ;     i := i + 1 ) ; 
     if (findParity(a)) then     return 0 else     return 2 );
  static   operation findParity( a : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() ;
     var ans : int ; ans := MathLib.bitwiseXor(a[0+1],a[n - 1+1]) ;
    var pow : int ; pow := 0 ;
        var i : int ; i := 1 ; while i < n - 1 do ( (     if ((MathLib.bitwiseAnd(i,1)) = 0) then (     var c : int ; c := 0 ;
     var t : int ; t := i ;
     while ((MathLib.bitwiseAnd(t,1)) = 0) do (     t := t/(2->pow(1)) ; 
     c := c + 1 ) ; 
     pow := pow-(c) ) else skip ; 
     if (((n - i) & 1) = 0) then (     var c : int ; c := 0 ;
     var t : int ; t := n - i ;
     while ((MathLib.bitwiseAnd(t,1)) = 0) do (     t := t/(2->pow(1)) ; 
     c := c + 1 ) ; 
     pow := pow+(c) ) else skip ; 
     if (pow = 0) then (     ans := MathLib.bitwiseXor(ans,a[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    return (MathLib.bitwiseAnd(ans,1)) = 0 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n+1];
    arr[0]=Integer.MAX_VALUE ;
    int max=0 ;
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      if(arr[max]>=x){
        max++;
        arr[max]=x ;
        continue ;
      }
      int left=0 ;
      int right=max ;
      while(right-left>1){
        int m=(left+right)/2 ;
        if(arr[m]<x){
          right=m ;
        }
        else {
          left=m ;
        }
      }
      arr[right]=x ;
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
    arr[0+1] := 2147483647 ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (arr[max+1] >= x) then (     max := max + 1 ; 
     arr[max+1] := x ; 
     continue ) else skip ; 
    var left : int ; left := 0 ;
    var right : int ; right := max ;
    while (right - left > 1) do (     var m : int ; m := (left + right) / 2 ;
     if (arr[m+1] < x) then (     right := m ) else (     left := m ) ) ; 
    arr[right+1] := x ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    char[] a=br.readLine().toCharArray();
    br.close();
    boolean one=false ;
    for(int i=0 ; i<n ; i++){
      if(a[i]=='2'){
        one=true ;
        break ;
      }
    }
    int[] p=new int[n];
    for(int i=2 ; i<n ; i+=2){
      int x=i ;
      while(x % 2==0){
        p[i]++;
        x/=2 ;
      }
    }
    for(int i=1 ; i<n ; i++){
      p[i]+=p[i-1];
    }
    if(! one){
      for(int i=0 ; i<n ; i++){
        if(a[i]=='3'){
          a[i]='2' ;
        }
      }
    }
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]=='2'){
        if(p[n-1]-p[i]-p[n-1-i]<=0){
          ans++;
        }
      }
    }
    ans %=2 ;
    if(! one){
      ans*=2 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var a : Sequence(String) ; a := br.readLine()->characters() ;
    skip ; 
    var one : boolean ; one := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = '2') then (     one := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 2 ; while i < n do ( (     var x : int ; x := i ;
     while (x mod 2 = 0) do (     p[i+1] := p[i+1] + 1 ; 
     x := x/(2) ) )  ;     i := i+(2) ) ; 
        var i : int ; i := 1 ; while i < n do ( (     p[i+1] := p[i+1]+(p[i - 1+1]) )  ;     i := i + 1 ) ; 
    if (not(one)) then (         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = '3') then (     a[i+1] := '2' ) else skip )  ;     i := i + 1 ) ) else skip ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = '2') then (     if (p[n - 1+1] - p[i+1] - p[n - 1 - i+1] <= 0) then (     ans := ans + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    ans := ans mod 2 ; 
    if (not(one)) then (     ans := ans*(2) ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    int[] a=new int[n];
    boolean d1=false ;
    int[] d=new int[n-1];
    for(int i=0 ; i<s.length(); i++){
      a[i]=s.charAt(i)-'0' ;
      if(i>0){
        d[i-1]=a[i]-a[i-1];
        if(d[i-1]<0)d[i-1]*=-1 ;
        if(d[i-1]==1)d1=true ;
      }
    }
    int[] mod=new int[n];
    int m=n-1 ;
    int t1=0 ;
    int t2=0 ;
    for(int take=0 ; take<=m-1 ; take++){
      int nn=m-1 ;
      boolean odd=((nn)&((nn)-take))<=0 ;
      if((take &(nn-take))>0)odd=false ;
      else odd=true ;
      if(d[take]==1 && odd)t1++;
      if(d[take]==2 && odd)t2++;
    }
    t1=t1 % 2 ;
    t2=t2 % 2 ;
    if(t1<0)t1+=2 ;
    if(t2<0)t2+=2 ;
    if(t1==0 && t2==0)System.out.println(0);
    else if(t2==1 && t1==0){
      if(! d1)System.out.println(2);
      else System.out.println(0);
    }
    else System.out.println(1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var d1 : boolean ; d1 := false ;
    var d : Sequence(int) ; d := Integer.subrange(1,n - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     a[i+1] := s->at(i+1) - ('0')->char2byte() ; 
     if (i > 0) then (     d[i - 1+1] := a[i+1] - a[i - 1+1] ; 
     if (d[i - 1+1] < 0) then     d[i - 1+1] := d[i - 1+1]*(-1) ; else skip ; 
     if (d[i - 1+1] = 1) then     d1 := true ; else skip ) else skip )  ;     i := i + 1 ) ; 
    var mod : Sequence(int) ; mod := Integer.subrange(1,n)->collect(0) ;
    var m : int ; m := n - 1 ;
    var t1 : int ; t1 := 0 ;
    var t2 : int ; t2 := 0 ;
        var take : int ; take := 0 ; while take <= m - 1 do ( (     var nn : int ; nn := m - 1 ;
     var odd : boolean ; odd := (MathLib.bitwiseAnd((nn),((nn) - take))) <= 0 ;
    if ((MathLib.bitwiseAnd(take,(nn - take))) > 0) then     odd := false else     odd := true ; ;  
    if (d[take+1] = 1 & odd) then     t1 := t1 + 1 ; else skip ; 
    if (d[take+1] = 2 & odd) then     t2 := t2 + 1 ; else skip ; 
 )  ;     take := take + 1 ) ; 
    t1 := t1 mod 2 ; 
    t2 := t2 mod 2 ; 
    if (t1 < 0) then     t1 := t1+(2) ; else skip ; 
    if (t2 < 0) then     t2 := t2+(2) ; else skip ; 
    if (t1 = 0 & t2 = 0) then     OclFile["System.out"].println(0) else     if (t2 = 1 & t1 = 0) then (     if (not(d1)) then     OclFile["System.out"].println(2) ; else     OclFile["System.out"].println(0) ; ) else     OclFile["System.out"].println(1) ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class VasyaTheHipster {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a,b ;
    a=sc.nextInt();
    b=sc.nextInt();
    int count=0 ;
    while(true){
      if(a>0 && b>0){
        count++;
        a--;
        b--;
      }
      else break ;
    }
    int ans=a/2+b/2 ;
    System.out.println(count+" "+ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class VasyaTheHipster {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ;
    var b : int ;
    a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    var count : int ; count := 0 ;
    while (true) do (     if (a > 0 & b > 0) then (     count := count + 1 ; 
     a := a - 1 ; 
     b := b - 1 ) else     break ) ; 
    var ans : int ; ans := a / 2 + b / 2 ;
    OclFile["System.out"].println(count + " " + ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong(),m=sc.nextLong();
    System.out.println(Math.min(n,m)+" "+Math.abs(n-m)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var m : long ; m := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println(Set{n, m}->min() + " " + if n - m < 0 then -(n - m) else n - m endif / 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    OutputStreamWriter osr=new OutputStreamWriter(System.out);
    PrintWriter o=new PrintWriter(osr);
    FastReader fr=new FastReader();
    int a=fr.nextInt(),b=fr.nextInt();
    o.print(min(a,b)+" "+((max(a,b)-min(a,b))/2));
    o.close();
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    InputStreamReader isr=new InputStreamReader(System.in);
    br=new BufferedReader(isr);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String nextLine()throws IOException {
    return br.readLine();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public int[] intArray(int size)throws IOException {
    int[] arr=new int[size];
    for(int i=0 ; i<size ; i++)arr[i]=nextInt();
    return arr ;
  }
  public char[] charArray()throws IOException {
    return nextLine().toCharArray();
  }
}
class Pair {
  int x ;
  int y ;
  public Pair(int x,int y){
    this.x=x ;
    this.y=y ;
  }
  static class Compare implements Comparator<Pair>{
    @ Override public int compare(Pair o1,Pair o2){
      return(o1.y-o2.y);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var osr : OclFile ; osr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var o : OclFile ; o := OclFile.newOclFile_Write(osr) ;
    var fr : FastReader ; fr := FastReader.newFastReader() ;
    var a : int ; a := fr.nextInt() ;
    var b : int ; b := fr.nextInt() ;
    skip ; 
    skip ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     br := OclFile.newOclFile_Read(isr) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation intArray( size : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < size do (     arr[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return arr );
   operation charArray() : Sequence(String)
  pre: true
  post: true
  activity: (     return nextLine()->characters() );
}
class Pair {
   attribute x : int;
   attribute y : int;
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
  static class Compare implements Function(<Map>,(<Map>,boolean)) {
      operation compare( o1 : Map, o2 : Map) : int
  pre: true
  post: true
  activity: (     return (o1.y - o2.y) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A581 {
  static Scanner sc=new Scanner();
  public static void main(String[] args){
    solve();
  }
  public static void solve(){
    int a=sc.nextInt(),b=sc.nextInt();
    if(a>b){
      System.out.print(b+" "+(a-b)/2);
    }
    else if(a==b){
      System.out.print(a+" 0");
    }
    else {
      System.out.print(a+" "+(b-a)/2);
    }
  }
  static class Scanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A581 {
  static   attribute sc : OclFile := (arguments ( ));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
     if (a > b) then (     OclFile["System.out"].print(b + " " + (a - b) / 2) ) else     if (a = b) then (     OclFile["System.out"].print(a + " 0") ) else (     OclFile["System.out"].print(a + " " + (b - a) / 2) ) ;  );
  static class Scanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Hipster {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt(),b=in.nextInt();
    System.out.println(Math.min(a,b)+" "+Math.abs(b-a)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hipster {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println(Set{a, b}->min() + " " + if b - a < 0 then -(b - a) else b - a endif / 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Locale ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int size=scn.nextInt();
    int[] arr=new int[size];
    for(int i=0 ; i<size ; i++){
      arr[i]=scn.nextInt();
    }
    System.out.println(asd(arr));
  }
  public static int asd(int[] arr){
    Arrays.sort(arr);
    return arr[arr.length/2];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var size : int ; size := scn.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < size do ( (     arr[i+1] := scn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(asd(arr)) ; 
 );
  static   operation asd( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     return arr[arr->size() / 2+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
      Arrays.sort(arr);
      System.out.println(arr[n/2]);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    OclFile["System.out"].println(arr[n / 2+1]) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.util.*;
public class Garland {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    String s1=s.next();
    String s2=s.next();
    if(isValid(s1,s2)==false){
      System.out.println(-1);
    }
    else {
      HashMap<Character,Integer>m1=new HashMap<>();
      HashMap<Character,Integer>m2=new HashMap<>();
      for(char c : s1.toCharArray()){
        if(m1.containsKey(c)){
          m1.put(c,m1.get(c)+1);
        }
        else {
          m1.put(c,1);
        }
      }
      for(char c : s2.toCharArray()){
        if(m2.containsKey(c)){
          m2.put(c,m2.get(c)+1);
        }
        else {
          m2.put(c,1);
        }
      }
      int ans=0 ;
      HashSet<Character>hs=new HashSet<>();
      for(char c : s2.toCharArray()){
        if(! hs.contains(c)){
          hs.add(c);
          int x1=m1.get(c);
          int x2=m2.get(c);
          x1=Math.min(x1,x2);
          ans+=x1 ;
        }
      }
      System.out.println(ans);
    }
  }
  public static boolean isValid(String s1,String s2){
    int n1=s1.length();
    int n2=s2.length();
    HashMap<Character,Boolean>map=new HashMap<>();
    for(char c : s1.toCharArray()){
      map.put(c,true);
    }
    for(char c : s2.toCharArray()){
      if(! map.containsKey(c))return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Garland {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := s.getCurrent() ;
     var s2 : String ; s2 := s.getCurrent() ;
     if (isValid(s1, s2) = false) then (     OclFile["System.out"].println(-1) ) else (     var m1 : Map(String,int) ; m1 := Map{} ;
     var m2 : Map(String,int) ; m2 := Map{} ;
    for (c : s1->characters()) do ( (     if (m1->keys()->includes(c)) then (     m1 := m1->union(Map{c |-> m1->at(c) + 1}) ) else (     m1 := m1->union(Map{c |-> 1}) ) )  ) ; 
    for (c : s2->characters()) do ( (     if (m2->keys()->includes(c)) then (     m2 := m2->union(Map{c |-> m2->at(c) + 1}) ) else (     m2 := m2->union(Map{c |-> 1}) ) )  ) ; 
    var ans : int ; ans := 0 ;
    var hs : Set(String) ; hs := Set{} ;
    for (c : s2->characters()) do ( (     if (not(hs->includes(c))) then (     hs := hs->including(c) ; 
     var x1 : int ; x1 := m1->at(c) ;
    var x2 : int ; x2 := m2->at(c) ;
    x1 := Set{x1, x2}->min() ; 
    ans := ans+(x1) ; 
 ) else skip )  ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation isValid( s1 : String, s2 : String) : boolean
  pre: true
  post: true
  activity: (     var n1 : int ; n1 := s1->size() ;
     var n2 : int ; n2 := s2->size() ;
    var map : Map(String,Boolean) ; map := Map{} ;
    for (c : s1->characters()) do ( (     map := map->union(Map{c |-> true}) )  ) ; 
    for (c : s2->characters()) do ( (     if (not(map->keys()->includes(c))) then     return false else skip )  ) ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main extends PrintWriter {
  Main(){
    super(System.out,true);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    Main o=new Main();
    o.main();
    o.flush();
  }
  int[] ft ;
  void update(int i,int n,int x){
    while(i<n){
      ft[i]=Math.max(ft[i],x);
      i |=i+1 ;
    }
  }
  int query(int i){
    int x=0 ;
    while(i>=0){
      x=Math.max(x,ft[i]);
      i &=i+1 ;
      i--;
    }
    return x ;
  }
  void main(){
    int n=sc.nextInt();
    int[] aa=new int[n];
    Integer[] ii=new Integer[n];
    for(int i=0 ; i<n ; i++){
      aa[i]=sc.nextInt();
      ii[i]=i ;
    }
    Arrays.sort(ii,(i,j)->aa[i]!=aa[j] ? aa[j]-aa[i] : i-j);
    ft=new int[n];
    int ans=0 ;
    for(int h=0 ; h<n ; h++){
      int i=ii[h];
      int k=query(i)+1 ;
      ans=Math.max(ans,k);
      update(i,n,k);
    }
    println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends OclFile {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"], true) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : Main ; o := Main.newMain() ;
     o.main() ; 
     o.flush() );
   attribute ft : Sequence(int);
   operation update( i : int, n : int, x : int) : void
  pre: true
  post: true
  activity: (     while (i < n) do (     ft[i+1] := Set{ft[i+1], x}->max() ; 
     i := MathLib.bitwiseOr(i, i + 1) ) );
   operation query( i : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := 0 ;
     while (i >= 0) do (     x := Set{x, ft[i+1]}->max() ; 
     i := MathLib.bitwiseAnd(i, i + 1) ; 
     i := i - 1 ) ; 
     return x );
   operation main() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var aa : Sequence(int) ; aa := Integer.subrange(1,n)->collect(0) ;
    var ii : Sequence(int) ; ii := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     aa[i+1] := sc.getCurrent()->toInteger() ; 
     ii[i+1] := i )  ;     i := i + 1 ) ; 
    ii := OclComparator.sortWith(ii, lambda (i , j) : OclAny in if aa[i+1] /= aa[j+1] then aa[j+1] - aa[i+1] else i - j endif) ; 
    ft := Integer.subrange(1,n)->collect(0) ; 
    var ans : int ; ans := 0 ;
        var h : int ; h := 0 ; while h < n do ( (     var i : int ; i := ii[h+1] ;
     var k : int ; k := query(i) + 1 ;
     ans := Set{ans, k}->max() ; 
     execute update(i, n, k) )  ;     h := h + 1 ) ; 
    execute println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    OutputStreamWriter osr=new OutputStreamWriter(System.out);
    PrintWriter o=new PrintWriter(osr);
    FastReader fr=new FastReader();
    int n=fr.nextInt();
    int ans=0 ;
    for(int i=0 ; i<n ; i++)ans+=fr.nextInt();
    o.print(ans/n);
    o.close();
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    InputStreamReader isr=new InputStreamReader(System.in);
    br=new BufferedReader(isr);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String nextLine()throws IOException {
    return br.readLine();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public int[] intArray(int size)throws IOException {
    int[] arr=new int[size];
    for(int i=0 ; i<size ; i++)arr[i]=nextInt();
    return arr ;
  }
  public char[] charArray()throws IOException {
    return nextLine().toCharArray();
  }
}
class Pair {
  int x ;
  int y ;
  public Pair(int x,int y){
    this.x=x ;
    this.y=y ;
  }
  static class Compare implements Comparator<Pair>{
    @ Override public int compare(Pair o1,Pair o2){
      return(o1.y-o2.y);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var osr : OclFile ; osr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var o : OclFile ; o := OclFile.newOclFile_Write(osr) ;
    var fr : FastReader ; fr := FastReader.newFastReader() ;
    var n : int ; n := fr.nextInt() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do (     ans := ans+(fr.nextInt()) ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     br := OclFile.newOclFile_Read(isr) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation intArray( size : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < size do (     arr[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return arr );
   operation charArray() : Sequence(String)
  pre: true
  post: true
  activity: (     return nextLine()->characters() );
}
class Pair {
   attribute x : int;
   attribute y : int;
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
  static class Compare implements Function(<Map>,(<Map>,boolean)) {
      operation compare( o1 : Map, o2 : Map) : int
  pre: true
  post: true
  activity: (     return (o1.y - o2.y) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    OutputStreamWriter osr=new OutputStreamWriter(System.out);
    PrintWriter o=new PrintWriter(osr);
    FastReader fr=new FastReader();
    double n=fr.nextDouble(),m=fr.nextDouble();
    for(int i=0 ; i<m-(n % m); i++)o.print((int)(n/m)+" ");
    for(int i=(int)(m-(n % m)); i<m ; i++)o.print((int)ceil(n/m)+" ");
    o.close();
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    InputStreamReader isr=new InputStreamReader(System.in);
    br=new BufferedReader(isr);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String nextLine()throws IOException {
    return br.readLine();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public int[] intArray(int size)throws IOException {
    int[] arr=new int[size];
    for(int i=0 ; i<size ; i++)arr[i]=nextInt();
    return arr ;
  }
  public char[] charArray()throws IOException {
    return nextLine().toCharArray();
  }
}
class Pair {
  int x ;
  int y ;
  public Pair(int x,int y){
    this.x=x ;
    this.y=y ;
  }
  static class Compare implements Comparator<Pair>{
    @ Override public int compare(Pair o1,Pair o2){
      return(o1.y-o2.y);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var osr : OclFile ; osr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var o : OclFile ; o := OclFile.newOclFile_Write(osr) ;
    var fr : FastReader ; fr := FastReader.newFastReader() ;
    var n : double ; n := fr.nextDouble() ;
    var m : double ; m := fr.nextDouble() ;
        var i : int ; i := 0 ; while i < m - (n mod m) do (     skip ;  ;     i := i + 1 ) ; 
        var i : int ; i := (m - (n mod m))->oclAsType(int) ; while i < m do (     skip ;  ;     i := i + 1 ) ; 
    skip ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     br := OclFile.newOclFile_Read(isr) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation intArray( size : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < size do (     arr[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return arr );
   operation charArray() : Sequence(String)
  pre: true
  post: true
  activity: (     return nextLine()->characters() );
}
class Pair {
   attribute x : int;
   attribute y : int;
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
  static class Compare implements Function(<Map>,(<Map>,boolean)) {
      operation compare( o1 : Map, o2 : Map) : int
  pre: true
  post: true
  activity: (     return (o1.y - o2.y) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static Scanner input=new Scanner(System.in);
  public static void main(String[] args){
    int n=input.nextInt();
    int m=input.nextInt();
    int a[]=new int[m];
    if(n % m==0){
      for(int i=0 ; i<a.length ; i++){
        a[i]=n/m ;
      }
    }
    else {
      int sub=n/m ;
      for(int i=0 ; i<a.length ; i++){
        a[i]=sub ;
      }
      int test=n-(sub*m);
      int count=0 ;
      for(int i=0 ; i<test ; i++){
        a[count]=a[count]+1 ;
        count++;
        if(count>+a.length)count=0 ;
      }
    }
    for(int i=(a.length-1); i>=0 ; i--){
      System.out.print(a[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute input : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := input.getCurrent()->toInteger() ;
     var m : int ; m := input.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
    if (n mod m = 0) then (         var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := n / m )  ;     i := i + 1 ) ) else (     var sub : int ; sub := n / m ;
         var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sub )  ;     i := i + 1 ) ; 
    var test : int ; test := n - (sub * m) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < test do ( (     a[count+1] := a[count+1] + 1 ; 
     count := count + 1 ; 
     if (count > a->size()) then     count := 0 ; else skip )  ;     i := i + 1 ) ; 
 ) ;  
        var i : int ; i := (a->size() - 1) ; while i >= 0 do ( (     OclFile["System.out"].print(a[i+1] + " ") )  ;     i := i - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class codeforces {
  public static void main(String[] args){
    Scanner ob=new Scanner(System.in);
    int n=ob.nextInt();
    int m=ob.nextInt();
    int temp=n/m ;
    int n1=n-temp*m ;
    for(int i=0 ; i<n1 ; i++){
      System.out.print((temp+1)+" ");
    }
    for(int i=n1 ; i<m ; i++){
      System.out.print(temp+" ");
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ob : OclFile ; ob := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := ob.getCurrent()->toInteger() ;
    var m : int ; m := ob.getCurrent()->toInteger() ;
    var temp : int ; temp := n / m ;
    var n1 : int ; n1 := n - temp * m ;
        var i : int ; i := 0 ; while i < n1 do ( (     OclFile["System.out"].print((temp + 1) + " ") )  ;     i := i + 1 ) ; 
        var i : int ; i := n1 ; while i < m do ( (     OclFile["System.out"].print(temp + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int totalPairs(String s1,String s2){
    int count=0 ;
    int[] arr1=new int[7];
    int[] arr2=new int[7];
    for(int i=0 ; i<s1.length(); i++){
      int set_bits=Integer.bitCount(s1.charAt(i));
      arr1[set_bits]++;
    }
    for(int i=0 ; i<s2.length(); i++){
      int set_bits=Integer.bitCount(s2.charAt(i));
      arr2[set_bits]++;
    }
    for(int i=1 ; i<=6 ; i++){
      count+=(arr1[i]*arr2[i]);
    }
    return count ;
  }
  public static void main(String[] args){
    String s1="geeks" ;
    String s2="forgeeks" ;
    System.out.println(totalPairs(s1,s2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation totalPairs( s1 : String, s2 : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,7)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,7)->collect(0) ;
        var i : int ; i := 0 ; while i < s1->size() do ( (     var set_bits : int ; set_bits := bitCount(s1->at(i+1)) ;
     arr1[set_bits+1] := arr1[set_bits+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < s2->size() do ( (     var set_bits : int ; set_bits := bitCount(s2->at(i+1)) ;
     arr2[set_bits+1] := arr2[set_bits+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 6 do ( (     count := count+((arr1[i+1] * arr2[i+1])) )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "geeks" ;
     var s2 : String ; s2 := "forgeeks" ;
     OclFile["System.out"].println(totalPairs(s1, s2)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSubSeq(int i,int sum,int cnt,int a[],int n){
    if(i==n){
      if(sum==0 && cnt>0){
        return 1 ;
      }
      else {
        return 0 ;
      }
    }
    int ans=0 ;
    ans+=countSubSeq(i+1,sum,cnt,a,n);
    ans+=countSubSeq(i+1,sum+a[i],cnt+1,a,n);
    return ans ;
  }
  public static void main(String[] args){
    int a[]={
-1,2,-2,1 };
      int n=a.length ;
      System.out.println(countSubSeq(0,0,0,a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSubSeq( i : int, sum : int, cnt : int, a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (i = n) then (     if (sum = 0 & cnt > 0) then (     return 1 ) else (     return 0 ) ) else skip ; 
     var ans : int ; ans := 0 ;
    ans := ans+(countSubSeq(i + 1, sum, cnt, a, n)) ; 
    ans := ans+(countSubSeq(i + 1, sum + a[i+1], cnt + 1, a, n)) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{-1,2,-2,1} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(countSubSeq(0, 0, 0, a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Decoding {
  public static void main(String[] args){
    Scanner reader=new Scanner(System.in);
    int n=reader.nextInt();
    char[] s=new char[n];
    char[] newS=new char[n];
    String input=reader.next();
    s=input.toCharArray();
    int mid=(n-1)/2 ;
    int counter=0 ;
    for(int i=0 ; i<n ; i++){
      int temp=i+1 ;
      if(n % 2==0){
        newS[mid-counter]=s[i];
      }
      else {
        newS[mid+counter]=s[i];
      }
      if(counter>=0){
        counter=counter-temp ;
      }
      else {
        counter=counter+temp ;
      }
    }
    System.out.println(new String(newS));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Decoding {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := reader.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(0) ;
    var newS : Sequence(String) ; newS := Integer.subrange(1,n)->collect(0) ;
    var input : String ; input := reader.getCurrent() ;
    s := input->characters() ; 
    var mid : int ; mid := (n - 1) / 2 ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : int ; temp := i + 1 ;
     if (n mod 2 = 0) then (     newS[(mid)->char2byte() - counter+1] := s[i+1] ) else (     newS[mid + counter+1] := s[i+1] ) ;  
     if (counter >= 0) then (     counter := counter - temp ) else (     counter := counter + temp ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(StringLib.newString(newS)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner Reader=new Scanner(System.in);
    int n=Reader.nextInt();
    String x=Reader.next();
    StringBuilder out=new StringBuilder();
    out.append(x.charAt(0));
    for(int i=1 ; i<n ; i++){
      if(i % 2==0)out.append(x.charAt(i));
      else out.insert(0,x.charAt(i));
    }
    if(n % 2==0)System.out.println(out.reverse());
    else System.out.println(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Reader : OclFile ; Reader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := Reader.getCurrent()->toInteger() ;
    var x : String ; x := Reader.getCurrent() ;
    var out : String ; out := StringLib.newString() ;
    out := out + StringLib.newString(x->at(0+1)) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (i mod 2 = 0) then     out := out + StringLib.newString(x->at(i+1)) ; else     out := out.insertAt(0+1, StringLib.newString(x->at(i+1))) ; )  ;     i := i + 1 ) ; 
    if (n mod 2 = 0) then     OclFile["System.out"].println(out->reverse()) else     OclFile["System.out"].println(out) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Solution {
  public static void main(String[] args){
    System.out.println(solve());
  }
  public static String solve(){
    StringBuilder sb=new StringBuilder();
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    String str=s.next();
    if(str.length()% 2==1){
      int flag=0 ;
      for(int i=0 ; i<str.length(); i++){
        if(flag==0){
          flag=1 ;
          sb.append(str.charAt(i));
        }
        else {
          flag=0 ;
          sb=new StringBuilder(String.valueOf(str.charAt(i))+sb);
        }
      }
    }
    else {
      int flag=0 ;
      for(int i=0 ; i<str.length(); i++){
        if(flag==1){
          flag=0 ;
          sb.append(str.charAt(i));
        }
        else {
          flag=1 ;
          sb=new StringBuilder(String.valueOf(str.charAt(i))+sb);
        }
      }
    }
    return sb.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(solve()) );
  static   operation solve() : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := s.getCurrent()->toInteger() ;
    var str : String ; str := s.getCurrent() ;
    if (str->size() mod 2 = 1) then (     var flag : int ; flag := 0 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (flag = 0) then (     flag := 1 ; 
     sb := sb + StringLib.newString(str->at(i+1)) ) else (     flag := 0 ; 
     sb := StringLib.newString(((str->at(i+1)) + "") + sb) ) )  ;     i := i + 1 ) ) else (     var flag : int ; flag := 0 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (flag = 1) then (     flag := 0 ; 
     sb := sb + StringLib.newString(str->at(i+1)) ) else (     flag := 1 ; 
     sb := StringLib.newString(((str->at(i+1)) + "") + sb) ) )  ;     i := i + 1 ) ) ;  
    return sb+"" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Decode {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      String s=sc.next();
      StringBuilder ans=new StringBuilder();
      ans.append(s.charAt(0));
      for(int i=1 ; i<n ; i++){
        if(i % 2==0)ans.append(s.charAt(i));
        else ans.insert(0,s.charAt(i));
      }
      if(n % 2==1)System.out.println(ans);
      else System.out.println(ans.reverse());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Decode {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
    var ans : String ; ans := StringLib.newString() ;
    ans := ans + StringLib.newString(s->at(0+1)) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (i mod 2 = 0) then     ans := ans + StringLib.newString(s->at(i+1)) ; else     ans := ans.insertAt(0+1, StringLib.newString(s->at(i+1))) ; )  ;     i := i + 1 ) ; 
    if (n mod 2 = 1) then     OclFile["System.out"].println(ans) else     OclFile["System.out"].println(ans->reverse()) ; ;  
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class OracAndMedians_641B {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int cases=Integer.parseInt(br.readLine());
    while(cases-->0){
      StringTokenizer st=new StringTokenizer(br.readLine());
      int n=Integer.parseInt(st.nextToken());
      int target=Integer.parseInt(st.nextToken());
      int[] nums=new int[n];
      st=new StringTokenizer(br.readLine());
      for(int i=0 ; i<n ; i++){
        nums[i]=Integer.parseInt(st.nextToken());
      }
      helper(nums,target);
    }
  }
  private static void helper(int[] nums,int target){
    boolean isTargetFound=false,canPrintYes=false ;
    int score=0,prev=-1 ;
    for(int num : nums){
      if(num==target){
        isTargetFound=true ;
      }
      if(num<target){
        score--;
      }
      else {
        score++;
      }
      if(score>0 && prev>-1){
        canPrintYes=true ;
      }
      prev=score ;
      score=Math.max(score,0);
    }
    if((nums.length==1 || canPrintYes)&& isTargetFound){
      System.out.println("yes");
    }
    else {
      System.out.println("no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class OracAndMedians_641B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var cases : int ; cases := (br.readLine())->toInteger() ;
         while (cases > 0) do (        cases := cases - 1 ;     skip ; (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var n : int ; n := (st.next())->toInteger() ;
    var target : int ; target := (st.next())->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    execute helper(nums, target) ; 
 ) ;  ) );
  static   operation helper( nums : Sequence(int), target : int) : void
  pre: true
  post: true
  activity: (     var isTargetFound : boolean ; isTargetFound := false ;
    var canPrintYes : boolean ; canPrintYes := false ;
     var score : int ; score := 0 ;
    var prev : int ; prev := -1 ;
     for (num : nums) do ( (     if (num = target) then (     isTargetFound := true ) else skip ; 
     if (num < target) then (     score := score - 1 ) else (     score := score + 1 ) ;  
    if (score > 0 & prev > -1) then (     canPrintYes := true ) else skip ; 
    prev := score ; 
    score := Set{score, 0}->max() ; 
 )  ) ; 
     if ((nums->size() = 1 or canPrintYes) & isTargetFound) then (     OclFile["System.out"].println("yes") ) else (     OclFile["System.out"].println("no") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class LCS_3Strings {
  static int lcsOf3(String X,String Y,String Z,int m,int n,int o){
    int[][][] L=new int[m+1][n+1][o+1];
    for(int i=0 ; i<=m ; i++){
      for(int j=0 ; j<=n ; j++){
        for(int k=0 ; k<=o ; k++){
          if(i==0 || j==0 || k==0)L[i][j][k]=0 ;
          else if(X.charAt(i-1)==Y.charAt(j-1)&& X.charAt(i-1)==Z.charAt(k-1))L[i][j][k]=L[i-1][j-1][k-1]+1 ;
          else L[i][j][k]=Math.max(Math.max(L[i-1][j][k],L[i][j-1][k]),L[i][j][k-1]);
        }
      }
    }
    return L[m][n][o];
  }
  public static void main(String args[]){
    String X="AGGT12" ;
    String Y="12TXAYB" ;
    String Z="12XBA" ;
    int m=X.length();
    int n=Y.length();
    int o=Z.length();
    System.out.println("Length of LCS is "+lcsOf3(X,Y,Z,m,n,o));
  }
}
------------------------------------------------------------
OCL File:
---------
class LCS_3Strings {
  static   operation lcsOf3( X : String, Y : String, Z : String, m : int, n : int, o : int) : int
  pre: true
  post: true
  activity: (     var L : Sequence(Sequence(Sequence(int))) ; L := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,n + 1)->collect(Integer.subrange(1,o + 1)->collect(0))) ;
         var i : int ; i := 0 ; while i <= m do ( (         var j : int ; j := 0 ; while j <= n do ( (         var k : int ; k := 0 ; while k <= o do ( (     if (i = 0 or j = 0 or k = 0) then     L[i+1][j+1][k+1] := 0 ; else     if (X->at(i - 1+1) = Y->at(j - 1+1) & X->at(i - 1+1) = Z->at(k - 1+1)) then     L[i+1][j+1][k+1] := L[i - 1+1][j - 1+1][k - 1+1] + 1 else     L[i+1][j+1][k+1] := Set{Set{L[i - 1+1][j+1][k+1], L[i+1][j - 1+1][k+1]}->max(), L[i+1][j+1][k - 1+1]}->max() ; ;  )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return L[m+1][n+1][o+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : String ; X := "AGGT12" ;
     var Y : String ; Y := "12TXAYB" ;
    var Z : String ; Z := "12XBA" ;
    var m : int ; m := X->size() ;
    var n : int ; n := Y->size() ;
    var o : int ; o := Z->size() ;
    OclFile["System.out"].println("Length of LCS is " + lcsOf3(X, Y, Z, m, n, o)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String word=in.next();
    String x="" ;
    if(n % 2==1){
      for(int i=n-2 ; i>=0 ; i-=2){
        if(i % 2==1){
          x+=word.charAt(i);
        }
      }
      for(int i=0 ; i<n ; i+=2){
        if(i % 2==0){
          x+=word.charAt(i);
        }
      }
    }
    else {
      for(int i=n-2 ; i>=0 ; i-=2){
        x+=word.charAt(i);
      }
      for(int i=1 ; i<n ; i+=2){
        x+=word.charAt(i);
      }
    }
    System.out.println(x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var word : String ; word := in.getCurrent() ;
    var x : String ; x := "" ;
    if (n mod 2 = 1) then (         var i : int ; i := n - 2 ; while i >= 0 do ( (     if (i mod 2 = 1) then (     x := x+(word->at(i+1)) ) else skip )  ;     i := i-(2) ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then (     x := x+(word->at(i+1)) ) else skip )  ;     i := i+(2) ) ) else (         var i : int ; i := n - 2 ; while i >= 0 do ( (     x := x+(word->at(i+1)) )  ;     i := i-(2) ) ; 
         var i : int ; i := 1 ; while i < n do ( (     x := x+(word->at(i+1)) )  ;     i := i+(2) ) ) ;  
    OclFile["System.out"].println(x) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int n=sc.nextInt();
    int m=sc.nextInt();
    int count=0 ;
    for(int i=1 ; Math.pow(i+a,n)<=m ; i++){
      int x=(int)(Math.pow(i+a,n));
      int y=getCount(x);
      if(y==i){
        count++;
      }
    }
    System.out.println(count);
  }
  static int getCount(int x){
    int count=0 ;
    while(x>0){
      count+=x % 10 ;
      x/=10 ;
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i + a->pow(n) <= m do ( (     var x : int ; x := (i + a->pow(n))->oclAsType(int) ;
     var y : int ; y := getCount(x) ;
     if (y = i) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation getCount( x : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (x > 0) do (     count := count+(x mod 10) ; 
     x := x/(10) ) ; 
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
class Main {
  static int sum=0 ;
  public static void main(String[] args){
    SC sc=new SC(System.in);
    long A=sc.nextLong();
    long N=sc.nextLong();
    long M=sc.nextLong();
    long max=0 ;
    while(pw(max+A+1,N)<=M){
      max++;
    }
    for(long i=A ; i<=A+max ; i++){
      long zan=i-A ;
      long ma=ketawa(pw(i,N));
      if(zan==ma && zan>0){
        sum++;
      }
    }
    pl(sum);
  }
  static long ketawa(long a){
    long sum=0 ;
    while(a>0){
      sum+=a % 10 ;
      a/=10 ;
    }
    return sum ;
  }
  static long pw(long base,long p){
    long ans=1 ;
    for(long i=0 ; i<p ; i++){
      ans*=base ;
    }
    return ans ;
  }
  static class SC {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public SC(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
  public static void pl(Object o){
    System.out.println(o);
  }
  public static void pl(){
    System.out.println();
  }
  public static void p(Object o){
    System.out.print(o);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sum : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : SC ; sc := SC.newSC(OclFile["System.in"]) ;
     var A : long ; A := sc.nextLong() ;
    var N : long ; N := sc.nextLong() ;
    var M : long ; M := sc.nextLong() ;
    var max : long ; max := 0 ;
    while (pw(max + A + 1, N) <= M) do (     max := max + 1 ) ; 
        var i : long ; i := A ; while i <= A + max do ( (     var zan : long ; zan := i - A ;
     var ma : long ; ma := ketawa(pw(i, N)) ;
     if (zan = ma & zan > 0) then (     sum := sum + 1 ) else skip )  ;     i := i + 1 ) ; 
    execute pl(sum) ; 
 );
  static   operation ketawa( a : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     while (a > 0) do (     sum := sum+(a mod 10) ; 
     a := a/(10) ) ; 
     return sum );
  static   operation pw( base : long, p : long) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
         var i : long ; i := 0 ; while i < p do ( (     ans := ans*(base) )  ;     i := i + 1 ) ; 
     return ans );
  static class SC {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newSC( in : OclFile) : SC
  pre: true
  post: true
  activity:
  ( var self : SC ;
    self := createSC();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation pl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[])throws IOException {
    Scanner scan=new Scanner(System.in);
    int ans=0 ;
    int a=scan.nextInt();
    int n=scan.nextInt();
    int m=scan.nextInt();
    for(long i=a+a==0 ? 1 : 0 ; Math.pow(i,n)<=m && Math.pow(i,n)>=0 ; i++){
      long num2=(long)Math.pow(i,n);
      long y=Dudeney(num2);
      long x=(int)Math.pow(y+a,n);
      if(num2==x){
        ans++;
      }
    }
    System.out.println(ans);
    scan.close();
  }
  public static long Dudeney(long num){
    int Ans=0 ;
    while(num!=0){
      Ans+=num % 10 ;
      num/=10 ;
    }
    return Ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ans : int ; ans := 0 ;
    var a : int ; a := scan.getCurrent()->toInteger() ;
    var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
        var i : long ; i := if a + a = 0 then 1 else 0 endif ; while i->pow(n) <= m & i->pow(n) >= 0 do ( (     var num2 : long ; num2 := i->pow(n)->oclAsType(long) ;
     var y : long ; y := Dudeney(num2) ;
     var x : long ; x := y + a->pow(n)->oclAsType(int) ;
     if (num2 = x) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
  static   operation Dudeney( num : long) : long
  pre: true
  post: true
  activity: (     var Ans : int ; Ans := 0 ;
     while (num /= 0) do (     Ans := Ans+(num mod 10) ; 
     num := num/(10) ) ; 
     return Ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String...args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int n=sc.nextInt();
    int m=sc.nextInt();
    int sum ;
    int count=0 ;
    for(int i=1 ; i<=m ; i++){
      sum=0 ;
      for(int j=i ; j>0 ; j/=10){
        sum+=j % 10 ;
      }
      sum+=a ;
      int rst=1 ;
      for(int j=0 ; j<n ; j++){
        rst*=sum ;
      }
      if(rst==i){
        count++;
      }
    }
    System.out.println(count);
  }
  static int[] intSplit(int n){
    String[] s=Integer.toString(n).split("");
    int[] a=new int[s.length];
    for(int i=0 ; i<s.length ; i++){
      a[i]=Integer.parseInt(s[i]);
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var sum : int ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= m do ( (     sum := 0 ; 
         var j : int ; j := i ; while j > 0 do ( (     sum := sum+(j mod 10) )  ;     j := j/(10) ) ; 
    sum := sum+(a) ; 
    var rst : int ; rst := 1 ;
        var j : int ; j := 0 ; while j < n do ( (     rst := rst*(sum) )  ;     j := j + 1 ) ; 
    if (rst = i) then (     count := count + 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation intSplit( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := ((n) + "")->split("") ;
     var a : Sequence(int) ; a := Integer.subrange(1,s->size())->collect(0) ;
         var i : int ; i := 0 ; while i < s->size() do ( (     a[i+1] := (s[i+1])->toInteger() )  ;     i := i + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int n=sc.nextInt();
    int m=sc.nextInt();
    int max=(int)Math.pow(m,(double)1/n);
    int ans=0 ;
    for(int i=1 ; i<=max ; i++){
      int x=(int)Math.pow(i,n);
      String str=String.valueOf(x);
      int y=0 ;
      for(int j=0 ; j<str.length(); j++){
        y+=Integer.parseInt(str.substring(j,j+1));
      }
      if(y+a==i){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var max : int ; max := m->pow(1->oclAsType(double) / n)->oclAsType(int) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= max do ( (     var x : int ; x := i->pow(n)->oclAsType(int) ;
     var str : String ; str := ((x) + "") ;
    var y : int ; y := 0 ;
        var j : int ; j := 0 ; while j < str->size() do ( (     y := y+((str.subrange(j+1,j + 1))->toInteger()) )  ;     j := j + 1 ) ; 
    if (y + a = i) then (     ans := ans + 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  static int pivotedBinarySearch(int arr[],int n,int key){
    int pivot=findPivot(arr,0,n-1);
    if(pivot==-1)return binarySearch(arr,0,n-1,key);
    if(arr[pivot]==key)return pivot ;
    if(arr[0]<=key)return binarySearch(arr,0,pivot-1,key);
    return binarySearch(arr,pivot+1,n-1,key);
  }
  static int findPivot(int arr[],int low,int high){
    if(high<low)return-1 ;
    if(high==low)return low ;
    int mid=(low+high)/2 ;
    if(mid<high && arr[mid]>arr[mid+1])return mid ;
    if(mid>low && arr[mid]<arr[mid-1])return(mid-1);
    if(arr[low]>=arr[mid])return findPivot(arr,low,mid-1);
    return findPivot(arr,mid+1,high);
  }
  static int binarySearch(int arr[],int low,int high,int key){
    if(high<low)return-1 ;
    int mid=(low+high)/2 ;
    if(key==arr[mid])return mid ;
    if(key>arr[mid])return binarySearch(arr,(mid+1),high,key);
    return binarySearch(arr,low,(mid-1),key);
  }
  public static void main(String args[]){
    int arr1[]={
      5,6,7,8,9,10,1,2,3 };
      int n=arr1.length ;
      int key=3 ;
      System.out.println("Index of the element is : "+pivotedBinarySearch(arr1,n,key));
    }
  }

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation pivotedBinarySearch( arr : Sequence(int), n : int, key : int) : int
  pre: true
  post: true
  activity: (     var pivot : int ; pivot := findPivot(arr, 0, n - 1) ;
     if (pivot = -1) then     return binarySearch(arr, 0, n - 1, key) else skip ; 
    if (arr[pivot+1] = key) then     return pivot else skip ; 
    if (arr[0+1] <= key) then     return binarySearch(arr, 0, pivot - 1, key) else skip ; 
    return binarySearch(arr, pivot + 1, n - 1, key) 
 );
  static   operation findPivot( arr : Sequence(int), low : int, high : int) : int
  pre: true
  post: true
  activity: (     if (high < low) then     return -1 else skip ; 
     if (high = low) then     return low else skip ; 
    var mid : int ; mid := (low + high) / 2 ;
    if (mid < high & arr[mid+1] > arr[mid + 1+1]) then     return mid else skip ; 
    if (mid > low & arr[mid+1] < arr[mid - 1+1]) then     return (mid - 1) else skip ; 
    if (arr[low+1] >= arr[mid+1]) then     return findPivot(arr, low, mid - 1) else skip ; 
    return findPivot(arr, mid + 1, high) 
 );
  static   operation binarySearch( arr : Sequence(int), low : int, high : int, key : int) : int
  pre: true
  post: true
  activity: (     if (high < low) then     return -1 else skip ; 
     var mid : int ; mid := (low + high) / 2 ;
    if (key = arr[mid+1]) then     return mid else skip ; 
    if (key > arr[mid+1]) then     return binarySearch(arr, (mid + 1), high, key) else skip ; 
    return binarySearch(arr, low, (mid - 1), key) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{5,6,7,8,9,10,1,2,3} ;
     var n : int ; n := arr1->size() ;
     var key : int ; key := 3 ;
     OclFile["System.out"].println("Index of the element is : " + pivotedBinarySearch(arr1, n, key)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class HocJava {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,mod=1000000007 ;
    n=sc.nextInt();
    long res=0 ;
    long[][] c=new long[4050][4050];
    long[] dp=new long[4050];
    for(int i=1 ; i<=n ; i++){
      c[i][0]=1 ;
      for(int j=1 ; j<i ; j++){
        c[i][j]=(c[i-1][j-1]+c[i-1][j])% mod ;
      }
      c[i][i]=1 ;
    }
    dp[0]=1 ;
    dp[1]=1 ;
    for(int i=2 ; i<n ; i++){
      for(int j=0 ; j<i ; j++)dp[i]=(dp[i]+dp[j]*c[i-1][j])% mod ;
    }
    for(int i=0 ; i<n ; i++){
      long g=dp[i]*c[n][i] % mod ;
      res=(res+g)% mod ;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class HocJava {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var mod : int ; mod := 1000000007 ;
    n := sc.getCurrent()->toInteger() ; 
    var res : long ; res := 0 ;
    var c : Sequence(Sequence(long)) ; c := Integer.subrange(1,4050)->collect(Integer.subrange(1,4050)->collect(0)) ;
    var dp : Sequence(long) ; dp := Integer.subrange(1,4050)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     c[i+1][0+1] := 1 ; 
         var j : int ; j := 1 ; while j < i do ( (     c[i+1][j+1] := (c[i - 1+1][j - 1+1] + c[i - 1+1][j+1]) mod mod )  ;     j := j + 1 ) ; 
     c[i+1][i+1] := 1 )  ;     i := i + 1 ) ; 
    dp[0+1] := 1 ; 
    dp[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < n do ( (         var j : int ; j := 0 ; while j < i do (     dp[i+1] := (dp[i+1] + dp[j+1] * c[i - 1+1][j+1]) mod mod ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var g : long ; g := dp[i+1] * c[n+1][i+1] mod mod ;
     res := (res + g) mod mod )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class A843 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    Point[] P=new Point[N];
    for(int n=0 ; n<N ; n++){
      P[n]=new Point(n,in.nextInt());
    }
    Arrays.sort(P,new Comparator<Point>(){
      @ Override public int compare(Point o1,Point o2){
        return o1.y-o2.y ;
      }
    }
);
    StringBuilder output=new StringBuilder();
    int lineCount=0 ;
    boolean[] used=new boolean[N];
    for(int n=0 ; n<N ; n++){
      if(! used[n]){
        lineCount++;
        int count=0 ;
        int pos=n ;
        StringBuilder line=new StringBuilder();
        while(! used[pos]){
          count++;
          used[pos]=true ;
          line.append(' ').append(pos+1);
          pos=P[pos] .x ;
        }
        output.append(count).append(line).append('\n');
      }
    }
    System.out.println(lineCount);
    System.out.print(output);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A843 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var P : Sequence(Point) ; P := Integer.subrange(1,N)->collect(null) ;
        var n : int ; n := 0 ; while n < N do ( (     P[n+1] := Point.newPoint(n, in.getCurrent()->toInteger()) )  ;     n := n + 1 ) ; 
    P := OclComparator.sortWith(P, OclComparator<Point>.newOclComparator()) ; 
    var output : String ; output := StringLib.newString() ;
    var lineCount : int ; lineCount := 0 ;
    var used : Sequence(boolean) ; used := Integer.subrange(1,N)->collect(false) ;
        var n : int ; n := 0 ; while n < N do ( (     if (not(used[n+1])) then (     lineCount := lineCount + 1 ; 
     var count : int ; count := 0 ;
    var pos : int ; pos := n ;
    var line : String ; line := StringLib.newString() ;
    while (not(used[pos+1])) do (     count := count + 1 ; 
     used[pos+1] := true ; 
     line := line + StringLib.newString(' ') + StringLib.newString(pos + 1) ; 
     pos := P[pos+1].x ) ; 
    output := output + StringLib.newString(count) + StringLib.newString(line) + StringLib.newString('
') ; 
 ) else skip )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(lineCount) ; 
    OclFile["System.out"].print(output) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static void printKMissing(int[] arr,int n,int k){
    Arrays.sort(arr);
    int i=0 ;
    while(i<n && arr[i]<=0)i++;
    int count=0,curr=1 ;
    while(count<k && i<n){
      if(arr[i]!=curr){
        System.out.print(curr+" ");
        count++;
      }
      else i++;
      curr++;
    }
    while(count<k){
      System.out.print(curr+" ");
      curr++;
      count++;
    }
  }
  public static void main(String[] args){
    int[] arr={
      2,3,4 };
      int n=arr.length ;
      int k=3 ;
      printKMissing(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printKMissing( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var i : int ; i := 0 ;
    while (i < n & arr[i+1] <= 0) do     i := i + 1 ; ; 
    var count : int ; count := 0 ;
    var curr : int ; curr := 1 ;
    while (count < k & i < n) do (     if (arr[i+1] /= curr) then (     OclFile["System.out"].print(curr + " ") ; 
     count := count + 1 ) else     i := i + 1 ; ;  
     curr := curr + 1 ) ; 
    while (count < k) do (     OclFile["System.out"].print(curr + " ") ; 
     curr := curr + 1 ; 
     count := count + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     execute printKMissing(arr, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf596B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    long[] arr=new long[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=scan.nextInt();
    }
    long answer=Math.abs(arr[0]);
    for(int i=1 ; i<n ; i++){
      answer+=Math.abs(arr[i]-arr[i-1]);
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf596B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var answer : long ; answer := if arr[0+1] < 0 then -(arr[0+1]) else arr[0+1] endif ;
        var i : int ; i := 1 ; while i < n do ( (     answer := answer+(if arr[i+1] - arr[i - 1+1] < 0 then -(arr[i+1] - arr[i - 1+1]) else arr[i+1] - arr[i - 1+1] endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import static java.lang.Integer.parseInt ;
public class Main {
  static final int[][] DIR={
    {
-1,0 },{
        0,1 },{
          1,0 },{
            0,-1 },};
            public static void main(String[] args)throws IOException {
              BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
              String line ;
              String[] words ;
              while((line=br.readLine())!=null && ! line.isEmpty()){
                int d=parseInt(line);
                for(int i=0 ; i<d ; i++){
                  int n=parseInt(br.readLine());
                  char[][] grid=new char[n][n];
                  int[] path=new int[n];
                  for(int j=0 ; j<grid.length ; j++){
                    Arrays.fill(grid[j],' ');
                  }
                  for(int j=0 ; j<n ; j++){
                    path[j]=n-j ;
                    if(j>0 &&(j & 1)==0)path[j]++;
                  }
                  int y=n,x=0 ;
                  for(int j=0 ; j<path.length ; j++){
                    for(int k=0 ; k<path[j]; k++){
                      y+=DIR[j % 4][0];
                      x+=DIR[j % 4][1];
                      grid[y][x]='#' ;
                    }
                  }
                  for(int j=0 ; j<grid.length ; j++){
                    System.out.println(grid[j]);
                  }
                  if(i<d-1)System.out.println();
                }
              }
            }
          }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute DIR : Sequence(Sequence(int)) := Sequence{Sequence{-1,0},Sequence{0,1},Sequence{1,0},Sequence{0,-1},};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var d : int ; d := parseInt(line) ;
         var i : int ; i := 0 ; while i < d do ( (     var n : int ; n := parseInt(br.readLine()) ;
     var grid : Sequence(Sequence(String)) ; grid := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var path : Sequence(int) ; path := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < grid->size() do ( (     grid[j+1] := grid[j+1]->collect(' ') )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     path[j+1] := n - j ; 
     if (j > 0 & (MathLib.bitwiseAnd(j,1)) = 0) then     path[j+1] := path[j+1] + 1 ; else skip )  ;     j := j + 1 ) ; 
    var y : int ; y := n ;
    var x : int ; x := 0 ;
        var j : int ; j := 0 ; while j < path->size() do ( (         var k : int ; k := 0 ; while k < path[j+1] do ( (     y := y+(DIR[j mod 4+1][0+1]) ; 
     x := x+(DIR[j mod 4+1][1+1]) ; 
     grid[y+1][x+1] := '#' )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < grid->size() do ( (     OclFile["System.out"].println(grid[j+1]) )  ;     j := j + 1 ) ; 
    if (i < d - 1) then     OclFile["System.out"].println() ; else skip ; 
 )  ;     i := i + 1 ) ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  int dx[]={
-1,0,1,0 };
    int dy[]={
      0,-1,0,1 };
      void run(){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        for(int c=0 ; c<n ; c++){
          int d=sc.nextInt();
          boolean map[][]=new boolean[d+4][d+4];
          for(boolean[] a : map)fill(a,true);
          for(int i=1 ; i<d+3 ; i++)for(int j=1 ; j<d+3 ; j++)map[i][j]=false ;
          int sx=2 ;
          int sy=d+1 ;
          int dir=1 ;
          int cnt=0 ;
          for(; ; ){
            map[sy][sx]=true ;
            if(map[sy+2*dy[dir] ][sx+2*dx[dir] ]){
              dir=(dir+1)% 4 ;
              cnt++;
            }
            if(cnt==d)break ;
            sx+=dx[dir];
            sy+=dy[dir];
          }
          for(int i=2 ; i<d+2 ; i++){
            for(int j=2 ; j<d+2 ; j++){
              if(map[i][j])System.out.print("#");
              else System.out.print(" ");
            }
            System.out.println();
          }
          if(c!=n-1)System.out.println();
        }
      }
      public static void main(String[] args){
        new Main().run();
      }
      void debug(Object...os){
        System.err.println(Arrays.deepToString(os));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute dx : int := Sequence{-1,0,1,0};
   attribute dy : int := Sequence{0,-1,0,1};
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var c : int ; c := 0 ; while c < n do ( (     var d : int ; d := sc.getCurrent()->toInteger() ;
     var map : Sequence(Sequence(boolean)) ; map := Integer.subrange(1,d + 4)->collect(Integer.subrange(1,d + 4)->collect(false)) ;
    for (a : map) do (     execute fill(a, true) ;  ) ; 
        var i : int ; i := 1 ; while i < d + 3 do (         var j : int ; j := 1 ; while j < d + 3 do (     map[i+1][j+1] := false ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var sx : int ; sx := 2 ;
    var sy : int ; sy := d + 1 ;
    var dir : int ; dir := 1 ;
    var cnt : int ; cnt := 0 ;
      while true do ( (     map[sy+1][sx+1] := true ; 
     if (map[sy + 2 * dy[dir+1]+1][sx + 2 * dx[dir+1]+1]) then (     dir := (dir + 1) mod 4 ; 
     cnt := cnt + 1 ) else skip ; 
    if (cnt = d) then     break else skip ; 
    sx := sx+(dx[dir+1]) ; 
    sy := sy+(dy[dir+1]) ; 
 )  ) ; 
        var i : int ; i := 2 ; while i < d + 2 do ( (         var j : int ; j := 2 ; while j < d + 2 do ( (     if (map[i+1][j+1]) then     OclFile["System.out"].print("#") ; else     OclFile["System.out"].print(" ") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
    if (c /= n - 1) then     OclFile["System.out"].println() ; else skip ; 
 )  ;     c := c + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p090 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p090().run());
  }
  public String run(){
    int count=0 ;
    for(int i=0 ; i<(1<<10); i++){
      for(int j=i ; j<(1<<10); j++){
        if(Integer.bitCount(i)==6 && Integer.bitCount(j)==6 && isArrangementValid(i,j))count++;
      }
    }
    return Integer.toString(count);
  }
  private static int[][] SQUARES={
    {
      0,1 },{
        0,4 },{
          0,9 },{
            1,6 },{
              2,5 },{
                3,6 },{
                  4,9 },{
                    6,4 },{
                      8,1 }
                    };
                    private static boolean isArrangementValid(int a,int b){
                      if(testBit(a,6)|| testBit(a,9))a |=(1<<6)|(1<<9);
                      if(testBit(b,6)|| testBit(b,9))b |=(1<<6)|(1<<9);
                      for(int[] sqr : SQUARES){
                        if(!(testBit(a,sqr[0])&& testBit(b,sqr[1])|| testBit(a,sqr[1])&& testBit(b,sqr[0])))return false ;
                      }
                      return true ;
                    }
                    private static boolean testBit(int x,int i){
                      return((x>>>i)& 1)!=0 ;
                    }
                  }

------------------------------------------------------------
OCL File:
---------
class p090 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p090.newp090().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < ((1*(2->pow(10)))->oclAsType(long)) do ( (         var j : int ; j := i ; while j < ((1*(2->pow(10)))->oclAsType(long)) do ( (     if (bitCount(i) = 6 & bitCount(j) = 6 & isArrangementValid(i, j)) then     count := count + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ((count) + "") );
  static   attribute SQUARES : Sequence(Sequence(int)) := Sequence{Sequence{0,1},Sequence{0,4},Sequence{0,9},Sequence{1,6},Sequence{2,5},Sequence{3,6},Sequence{4,9},Sequence{6,4},Sequence{8,1}};
  static   operation isArrangementValid( a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     if (testBit(a, 6) or testBit(a, 9)) then     a := MathLib.bitwiseOr(a, ((1*(2->pow(6)))->oclAsType(long)) or ((1*(2->pow(9)))->oclAsType(long))) ; else skip ; 
     if (testBit(b, 6) or testBit(b, 9)) then     b := MathLib.bitwiseOr(b, ((1*(2->pow(6)))->oclAsType(long)) or ((1*(2->pow(9)))->oclAsType(long))) ; else skip ; 
     for (sqr : SQUARES) do ( (     if (not((testBit(a, sqr[0+1]) & testBit(b, sqr[1+1]) or testBit(a, sqr[1+1]) & testBit(b, sqr[0+1])))) then     return false else skip )  ) ; 
     return true );
  static   operation testBit( x : int, i : int) : boolean
  pre: true
  post: true
  activity: (     return (((x/(2->pow(i)))->oclAsType(long)) & 1) /= 0 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Scanner ;
import java.util.Iterator ;
class Graph {
  private int totalVertex ;
  private LinkedList<LinkedList<Integer>>adjList ;
  public Graph(){
    totalVertex=0 ;
  }
  public void loadAdjList(){
    Scanner in=new Scanner(System.in);
    totalVertex=in.nextInt();
    adjList=new LinkedList<LinkedList<Integer>>();
    for(int i=0 ; i<totalVertex ; i++){
      LinkedList<Integer>tmp=new LinkedList<Integer>();
      int idx1=in.nextInt()-1 ;
      int degree=in.nextInt();
      for(int j=0 ; j<degree ; j++){
        int idx2=in.nextInt()-1 ;
        tmp.add(idx2);
      }
      adjList.add(tmp);
    }
    in.close();
  }
  public void printAdjMatrix(){
    Integer[][] adjMatrix=new Integer[totalVertex][totalVertex];
    for(int i=0 ; i<totalVertex ; i++){
      LinkedList<Integer>vertexes=this.adjList.get(i);
      for(int j=0 ; j<totalVertex ; j++){
        if(vertexes.contains(j)){
          adjMatrix[i][j]=1 ;
          System.out.print("1");
        }
        else {
          adjMatrix[i][j]=0 ;
          System.out.print("0");
        }
        if(j!=totalVertex-1){
          System.out.print(" ");
        }
      }
      System.out.println();
    }
  }
}
public class Main {
  public static void main(String argv[]){
    Graph g=new Graph();
    g.loadAdjList();
    g.printAdjMatrix();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Graph {
   attribute totalVertex : int;
   attribute adjList : Sequence(Sequence(int));
   static operation newGraph() : Graph
  pre: true
  post: true
  activity:
  ( var self : Graph ;
    self := createGraph();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     totalVertex := 0 );
   operation loadAdjList() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     totalVertex := in.getCurrent()->toInteger() ; 
    adjList := Sequence{} ; 
        var i : int ; i := 0 ; while i < totalVertex do ( (     var tmp : Sequence(int) ; tmp := Sequence{} ;
     var idx1 : int ; idx1 := in.getCurrent()->toInteger() - 1 ;
    var degree : int ; degree := in.getCurrent()->toInteger() ;
        var j : int ; j := 0 ; while j < degree do ( (     var idx2 : int ; idx2 := in.getCurrent()->toInteger() - 1 ;
     tmp := tmp->including(idx2) )  ;     j := j + 1 ) ; 
    adjList := adjList->including(tmp) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation printAdjMatrix() : void
  pre: true
  post: true
  activity: (     var adjMatrix : Sequence(Sequence(int)) ; adjMatrix := Integer.subrange(1,totalVertex)->collect(Integer.subrange(1,totalVertex)->collect(null)) ;
         var i : int ; i := 0 ; while i < totalVertex do ( (     var vertexes : Sequence(int) ; vertexes := self.adjList->at(i+1) ;
         var j : int ; j := 0 ; while j < totalVertex do ( (     if (vertexes->includes(j)) then (     adjMatrix[i+1][j+1] := 1 ; 
     OclFile["System.out"].print("1") ) else (     adjMatrix[i+1][j+1] := 0 ; 
     OclFile["System.out"].print("0") ) ;  
     if (j /= totalVertex - 1) then (     OclFile["System.out"].print(" ") ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
}
class Main {
  static   operation main( argv : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : Graph ; g := Graph.newGraph() ;
     g.loadAdjList() ; 
     g.printAdjMatrix() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  public void run(){
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      int n=Integer.parseInt(br.readLine());
      int[][] graph=new int[n][n];
      String[] vInfo ;
      int degree ;
      for(int i=0,v=0 ; i<n ; i++){
        vInfo=br.readLine().split(" ");
        degree=Integer.parseInt(vInfo[1]);
        for(int j=0,k=2 ; j<degree ; j++){
          v=Integer.parseInt(vInfo[k++]);
          graph[i][--v]=1 ;
        }
      }
      StringBuilder buf=new StringBuilder(n*n);
      for(int[] vertex : graph){
        for(int v : vertex){
          buf.append(v).append(" ");
        }
        buf.setLength(buf.length()-1);
        buf.append("\n");
      }
      System.out.print(buf);
    }
    catch(IOException e){
      System.err.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var n : int ; n := (br.readLine())->toInteger() ;
     var graph : Sequence(Sequence(int)) ; graph := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var vInfo : Sequence(String) ;
    var degree : int ;
        var i : int ; i := 0 ;
    var v : int ; v := 0 ; while i < n do ( (     vInfo := br.readLine()->split(" ") ; 
     degree := (vInfo[1+1])->toInteger() ; 
         var j : int ; j := 0 ;
    var k : int ; k := 2 ; while j < degree do ( (     v := (vInfo[k+1])->toInteger() ; 
         v := v - 1 ;
 graph[i+1][v+1] := 1  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var buf : String ; buf := StringLib.newString(n * n) ;
    for (vertex : graph) do ( (     for (v : vertex) do ( (     buf := buf + StringLib.newString(v) + StringLib.newString(" ") )  ) ; 
     buf := buf.subrange(1,buf->size() - 1) ; 
     buf := buf + StringLib.newString("\n") )  ) ; 
    OclFile["System.out"].print(buf) ; 
 ))   catch (e : IOException) do (     OclFile["System.err"].println(e) )
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    AdjacencyMatrices am=new AdjacencyMatrices(scan.nextInt());
    am.readList(scan);
    am.printMatrix();
  }
}
class AdjacencyMatrices {
  int pointNum ;
  int[][] matrix ;
  public AdjacencyMatrices(int n){
    pointNum=n ;
    matrix=new int[n][];
    for(int i=0 ; i<n ; i++)matrix[i]=new int[n];
  }
  public void readList(Scanner scan){
    for(int i=0 ; i<pointNum ; i++){
      int index=scan.nextInt()-1 ;
      int dim=scan.nextInt();
      for(int j=0 ; j<dim ; j++)matrix[index][scan.nextInt()-1]=1 ;
    }
  }
  public void printMatrix(){
    StringBuilder temp=new StringBuilder();
    for(int i=0 ; i<pointNum ; i++){
      for(int j=0 ; j<pointNum ; j++){
        temp.append(matrix[i][j]);
        if(j!=pointNum-1)temp.append(" ");
      }
      temp.append("\n");
    }
    System.out.print(new String(temp));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var am : AdjacencyMatrices ; am := AdjacencyMatrices.newAdjacencyMatrices(scan.getCurrent()->toInteger()) ;
     am.readList(scan) ; 
     am.printMatrix() );
}
class AdjacencyMatrices {
   attribute pointNum : int;
   attribute matrix : Sequence(Sequence(int));
   static operation newAdjacencyMatrices( n : int) : AdjacencyMatrices
  pre: true
  post: true
  activity:
  ( var self : AdjacencyMatrices ;
    self := createAdjacencyMatrices();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     pointNum := n ; 
     matrix := Integer.subrange(1,n)->collect(Sequence{}) ; 
         var i : int ; i := 0 ; while i < n do (     matrix[i+1] := Integer.subrange(1,n)->collect(0) ;  ;     i := i + 1 ) );
   operation readList( scan : OclFile) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < pointNum do ( (     var index : int ; index := scan.getCurrent()->toInteger() - 1 ;
     var dim : int ; dim := scan.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < dim do (     matrix[index+1][scan.getCurrent()->toInteger() - 1+1] := 1 ;  ;     j := j + 1 ) )  ;     i := i + 1 ) );
   operation printMatrix() : void
  pre: true
  post: true
  activity: (     var temp : String ; temp := StringLib.newString() ;
         var i : int ; i := 0 ; while i < pointNum do ( (         var j : int ; j := 0 ; while j < pointNum do ( (     temp := temp + StringLib.newString(matrix[i+1][j+1]) ; 
     if (j /= pointNum - 1) then     temp := temp + StringLib.newString(" ") ; else skip )  ;     j := j + 1 ) ; 
     temp := temp + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(StringLib.newString(temp)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.stream.Collectors ;
class Main {
  Integer[][] array=new Integer[1000][1000];
  public void run(){
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      int width=Integer.parseInt(br.readLine());
      for(int i=0 ; i<width ; i++){
        for(int j=0 ; j<width ; j++){
          array[i][j]=0 ;
        }
      }
      br.lines().forEach(n->createMap(n.split(" ")));
      for(int i=0 ; i<width ; i++){
        System.out.print(array[i][0]);
        for(int j=1 ; j<width ; j++){
          System.out.print(" "+array[i][j]);
        }
        System.out.println();
      }
    }
    catch(Exception e){
      System.out.println(e);
    }
  }
  public void createMap(String[] n){
    for(int i=2 ; i<n.length ; i++){
      array[Integer.parseInt(n[0])-1][Integer.parseInt(n[i])-1]=1 ;
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute array : Sequence(Sequence(int)) := Integer.subrange(1,1000)->collect(Integer.subrange(1,1000)->collect(null));
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var width : int ; width := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < width do ( (         var j : int ; j := 0 ; while j < width do ( (     array[i+1][j+1] := 0 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     for n : br.lines() do
    (    execute createMap(n->split(" "))) ; 
         var i : int ; i := 0 ; while i < width do ( (     OclFile["System.out"].print(array[i+1][0+1]) ; 
         var j : int ; j := 1 ; while j < width do ( (     OclFile["System.out"].print(" " + array[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ))   catch (e : ProgramException) do (     OclFile["System.out"].println(e) )
  );
   operation createMap( n : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i < n->size() do ( (     array[(n[0+1])->toInteger() - 1+1][(n[i+1])->toInteger() - 1+1] := 1 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    InputStreamReader input=new InputStreamReader(System.in);
    BufferedReader buffer=new BufferedReader(input);
    String read=buffer.readLine();
    int amount=Integer.parseInt(read);
    int[][] graph=new int[amount][amount];
    for(int i=0 ; i<amount ; i++){
      read=buffer.readLine();
      String[] scan=read.split(" ");
      int[] scanInt=new int[scan.length];
      for(int j=0 ; j<scan.length ; j++){
        scanInt[j]=Integer.parseInt(scan[j]);
      }
      for(int j=2 ; j<scanInt[1]+2 ; j++){
        graph[i][scanInt[j]-1]=1 ;
      }
    }
    for(int j=0 ; j<amount ; j++){
      for(int k=0 ; k<amount ; k++){
        System.out.print(graph[j][k]);
        if(k==amount-1){
          System.out.println("");
        }
        else {
          System.out.print(" ");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var buffer : OclFile ; buffer := OclFile.newOclFile_Read(input) ;
    var read : String ; read := buffer.readLine() ;
    var amount : int ; amount := (read)->toInteger() ;
    var graph : Sequence(Sequence(int)) ; graph := Integer.subrange(1,amount)->collect(Integer.subrange(1,amount)->collect(0)) ;
        var i : int ; i := 0 ; while i < amount do ( (     read := buffer.readLine() ; 
     var scan : Sequence(String) ; scan := read->split(" ") ;
    var scanInt : Sequence(int) ; scanInt := Integer.subrange(1,scan->size())->collect(0) ;
        var j : int ; j := 0 ; while j < scan->size() do ( (     scanInt[j+1] := (scan[j+1])->toInteger() )  ;     j := j + 1 ) ; 
        var j : int ; j := 2 ; while j < scanInt[1+1] + 2 do ( (     graph[i+1][scanInt[j+1] - 1+1] := 1 )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < amount do ( (         var k : int ; k := 0 ; while k < amount do ( (     OclFile["System.out"].print(graph[j+1][k+1]) ; 
     if (k = (amount)->char2byte() - 1) then (     OclFile["System.out"].println("") ) else (     OclFile["System.out"].print(" ") ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] x=new int[n];
    for(int i=0 ; i<n ; ++i)x[i]=sc.nextInt();
    long all=0 ;
    for(int i=0 ; i<n ; ++i)all+=x[i];
    SegmentTree seg=new SegmentTree(n+1);
    for(int i=0 ; i<n ; ++i){
      long pre=seg.query(0,x[i]);
      seg.set(x[i],pre+x[i]);
    }
    long fix=seg.query(0,n+1);
    System.out.println(all-fix);
  }
  static class SegmentTree {
    int n=1 ;
    long[] val ;
    public SegmentTree(int n){
      while(this.n<n)this.n*=2 ;
      val=new long[2*this.n-1];
    }
    void set(int k,long l){
      k+=n-1 ;
      val[k]=l ;
      while(k>0){
        k=(k-1)/2 ;
        val[k]=Math.max(val[2*k+1],val[2*k+2]);
      }
    }
    long query(int a,int b){
      return query(a,b,0,n,0);
    }
    long query(int a,int b,int l,int r,int k){
      if(r<=a || b<=l)return 0 ;
      else if(a<=l && r<=b){
        return val[k];
      }
      else {
        long vl=query(a,b,l,(l+r)/2,2*k+1);
        long vr=query(a,b,(l+r)/2,r,2*k+2);
        return Math.max(vl,vr);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     x[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var all : long ; all := 0 ;
        var i : int ; i := 0 ; while i < n do (     all := all+(x[i+1]) ;  ;     i := i + 1 ) ; 
    var seg : SegmentTree ; seg := SegmentTree.newSegmentTree(n + 1) ;
        var i : int ; i := 0 ; while i < n do ( (     var pre : long ; pre := seg.query(0, x[i+1]) ;
     seg := seg.setAt(x[i+1]+1, pre + x[i+1]) )  ;     i := i + 1 ) ; 
    var fix : long ; fix := seg.query(0, n + 1) ;
    OclFile["System.out"].println(all - fix) ; 
 );
  static class SegmentTree {
   attribute n : int := 1;
   attribute val : Sequence(long);
   static operation newSegmentTree( n : int) : SegmentTree
  pre: true
  post: true
  activity:
  ( var self : SegmentTree ;
    self := createSegmentTree();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     while (self.n < n) do     self.n := self.n*(2) ; ; 
     val := Integer.subrange(1,2 * self.n - 1)->collect(0) );
   operation set( k : int, l : long) : void
  pre: true
  post: true
  activity: (     k := k+(n - 1) ; 
     val[k+1] := l ; 
     while (k > 0) do (     k := (k - 1) / 2 ; 
     val[k+1] := Set{val[2 * k + 1+1], val[2 * k + 2+1]}->max() ) );
   operation query( a : int, b : int) : long
  pre: true
  post: true
  activity: (     return query(a, b, 0, n, 0) );
   operation query( a : int, b : int, l : int, r : int, k : int) : long
  pre: true
  post: true
  activity: (     if (r <= a or b <= l) then     return 0 else     if (a <= l & r <= b) then (     return val[k+1] ) else (     var vl : long ; vl := query(a, b, l, (l + r) / 2, 2 * k + 1) ;
     var vr : long ; vr := query(a, b, (l + r) / 2, r, 2 * k + 2) ;
     return Set{vl, vr}->max() ) ;  );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printNumbers(int a[],int n){
    Map<Integer,Integer>mpp=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int num=a[i];
      for(int j=1 ; j*j<=num ; j++){
        if(num % j==0){
          if(j!=1){
            if(mpp.containsKey(j)){
              mpp.put(j,mpp.get(j)+1);
            }
            else {
              mpp.put(j,1);
            }
          }
          if((num/j)!=j){
            if(mpp.containsKey(num/j)){
              mpp.put(num/j,mpp.get(num/j)+1);
            }
            else {
              mpp.put(num/j,1);
            }
          }
        }
      }
    }
    int maxi=0 ;
    for(Map.Entry<Integer,Integer>it : mpp.entrySet()){
      maxi=Math.max(it.getValue(),maxi);
    }
    for(Map.Entry<Integer,Integer>it : mpp.entrySet()){
      if(it.getValue()==maxi)System.out.print(it.getKey()+" ");
    }
  }
  public static void main(String[] args){
    int a[]={
      12,15,27,20,40 };
      int n=a.length ;
      printNumbers(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printNumbers( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var mpp : Map(int,int) ; mpp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := a[i+1] ;
         var j : int ; j := 1 ; while j * j <= num do ( (     if (num mod j = 0) then (     if (j /= 1) then (     if (mpp->keys()->includes(j)) then (     mpp := mpp->union(Map{j |-> mpp->at(j) + 1}) ) else (     mpp := mpp->union(Map{j |-> 1}) ) ) else skip ; 
     if ((num / j) /= j) then (     if (mpp->keys()->includes(num / j)) then (     mpp := mpp->union(Map{num / j |-> mpp->at(num / j) + 1}) ) else (     mpp := mpp->union(Map{num / j |-> 1}) ) ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var maxi : int ; maxi := 0 ;
    for (it : mpp->asSet()) do ( (     maxi := Set{it.getValue(), maxi}->max() )  ) ; 
    for (it : mpp->asSet()) do ( (     if (it.getValue() = maxi) then     OclFile["System.out"].print(it.getKey() + " ") ; else skip )  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{12,15,27,20,40} ;
     var n : int ; n := a->size() ;
     execute printNumbers(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    char[][] pic=new char[n][m];
    String temp ;
    for(int i=0 ; i<n ; i++){
      temp=sc.next();
      for(int j=0 ; j<m ; j++){
        pic[i][j]=temp.charAt(j);
      }
    }
    int inc=0,inc1=0 ;
    boolean[] comeIn=new boolean[4];
    if(n>1 || m>1){
      for(int x=0 ; x<n-1 ; x++){
        for(int y=0 ; y<m-1 ; y++){
          for(int i=x ; i<2+x ; i++){
            for(int j=y ; j<2+y ; j++){
              if(pic[i][j]=='f' && comeIn[0]==false){
                inc++;
                comeIn[0]=true ;
              }
              else if(pic[i][j]=='a' && comeIn[1]==false){
                inc++;
                comeIn[1]=true ;
              }
              else if(pic[i][j]=='c' && comeIn[2]==false){
                inc++;
                comeIn[2]=true ;
              }
              else if(pic[i][j]=='e' && comeIn[3]==false){
                inc++;
                comeIn[3]=true ;
              }
            }
          }
          if(inc==4)inc1++;
          inc=0 ;
          Arrays.fill(comeIn,false);
        }
      }
      System.out.println(inc1);
    }
    else {
      System.out.println("0");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var pic : Sequence(Sequence(String)) ; pic := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var temp : String ;
        var i : int ; i := 0 ; while i < n do ( (     temp := sc.getCurrent() ; 
         var j : int ; j := 0 ; while j < m do ( (     pic[i+1][j+1] := temp->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var inc : int ; inc := 0 ;
    var inc1 : int ; inc1 := 0 ;
    var comeIn : Sequence(boolean) ; comeIn := Integer.subrange(1,4)->collect(false) ;
    if (n > 1 or m > 1) then (         var x : int ; x := 0 ; while x < n - 1 do ( (         var y : int ; y := 0 ; while y < m - 1 do ( (         var i : int ; i := x ; while i < 2 + x do ( (         var j : int ; j := y ; while j < 2 + y do ( (     if (pic[i+1][j+1] = 'f' & comeIn[0+1] = false) then (     inc := inc + 1 ; 
     comeIn[0+1] := true ) else     if (pic[i+1][j+1] = 'a' & comeIn[1+1] = false) then (     inc := inc + 1 ; 
     comeIn[1+1] := true ) else     if (pic[i+1][j+1] = 'c' & comeIn[2+1] = false) then (     inc := inc + 1 ; 
     comeIn[2+1] := true ) else     if (pic[i+1][j+1] = 'e' & comeIn[3+1] = false) then (     inc := inc + 1 ; 
     comeIn[3+1] := true ) else skip ; ;  ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (inc = 4) then     inc1 := inc1 + 1 ; else skip ; 
     inc := 0 ; 
     comeIn := comeIn->collect(false) )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
     OclFile["System.out"].println(inc1) ) else (     OclFile["System.out"].println("0") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Scanner ;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int n=in.nextInt();
    int m=in.nextInt();
    int sum=0 ;
    if(n>=2 && m>=2){
      char[][] a=new char[n][m];
      for(int i=0 ; i<n ; i++){
        String word=in.next();
        a[i]=word.toCharArray();
      }
      String word="" ;
      for(int i=0 ; i<n ; i++){
        for(int j=1 ; j<m ; j++){
          if(i+1<n)word=a[i][j]+""+a[i][j-1]+""+a[i+1][j]+""+a[i+1][j-1];
          char[] chars=word.toCharArray();
          Arrays.sort(chars);
          String sorted=new String(chars);
          if(sorted.contains("acef")){
            sum++;
          }
          word="" ;
        }
      }
      System.out.println(sum);
    }
    else {
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    if (n >= 2 & m >= 2) then (     var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do ( (     var word : String ; word := in.getCurrent() ;
     a[i+1] := word->characters() )  ;     i := i + 1 ) ; 
    var word : String ; word := "" ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 1 ; while j < m do ( (     if (i + 1 < n) then     word := a[i+1][j+1] + "" + a[i+1][j - 1+1] + "" + a[i + 1+1][j+1] + "" + a[i + 1+1][j - 1+1] ; else skip ; 
     var chars : Sequence(String) ; chars := word->characters() ;
    chars := chars->sort() ; 
    var sorted : String ; sorted := StringLib.newString(chars) ;
    if (sorted->includes("acef")) then (     sum := sum + 1 ) else skip ; 
    word := "" ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) else (     OclFile["System.out"].println(sum) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf596b {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    long[] a=new long[t];
    for(int i=0 ; i<t ; i++){
      a[i]=scan.nextInt();
    }
    scan.close();
    long ans=Math.abs(a[0]);
    for(int i=1 ; i<t ; i++){
      ans+=Math.abs(a[i]-a[i-1]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf596b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,t)->collect(0) ;
        var i : int ; i := 0 ; while i < t do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : long ; ans := if a[0+1] < 0 then -(a[0+1]) else a[0+1] endif ;
        var i : int ; i := 1 ; while i < t do ( (     ans := ans+(if a[i+1] - a[i - 1+1] < 0 then -(a[i+1] - a[i - 1+1]) else a[i+1] - a[i - 1+1] endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class FaceDetection {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line=br.readLine();
    StringTokenizer st=new StringTokenizer(line);
    int i=Integer.parseInt(st.nextToken());
    int j=Integer.parseInt(st.nextToken());
    char[][] c=new char[i][j];
    String[] s=new String[i];
    for(int m=0 ; m<i ; m++){
      s[m]=br.readLine();
      for(int n=0 ; n<j ; n++)c[m][n]=s[m] .charAt(n);
    }
    int k=0 ;
    for(int m=0 ; m<i-1 ; m++)for(int n=0 ; n<j-1 ; n++){
      String x=""+c[m][n]+c[m][n+1]+c[m+1][n]+c[m+1][n+1];
      if(x.contains("f")&& x.contains("a")&& x.contains("c")&& x.contains("e"))k++;
    }
    System.out.println(k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class FaceDetection {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := br.readLine() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(line) ;
    var i : int ; i := (st.next())->toInteger() ;
    var j : int ; j := (st.next())->toInteger() ;
    var c : Sequence(Sequence(String)) ; c := Integer.subrange(1,i)->collect(Integer.subrange(1,j)->collect(0)) ;
    var s : Sequence(String) ; s := Integer.subrange(1,i)->collect(null) ;
        var m : int ; m := 0 ; while m < i do ( (     s[m+1] := br.readLine() ; 
         var n : int ; n := 0 ; while n < j do (     c[m+1][n+1] := s[m+1]->at(n+1) ;  ;     n := n + 1 ) )  ;     m := m + 1 ) ; 
    var k : int ; k := 0 ;
        var m : int ; m := 0 ; while m < i - 1 do (         var n : int ; n := 0 ; while n < j - 1 do ( (     var x : String ; x := "" + c[m+1][n+1] + c[m+1][n + 1+1] + c[m + 1+1][n+1] + c[m + 1+1][n + 1+1] ;
     if (x->includes("f") & x->includes("a") & x->includes("c") & x->includes("e")) then     k := k + 1 ; else skip )  ;     n := n + 1 ) ;  ;     m := m + 1 ) ; 
    OclFile["System.out"].println(k) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Face_Detection {
  public static void main(String args[])throws Exception {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(f.readLine());
    int rows=Integer.parseInt(st.nextToken());
    int cols=Integer.parseInt(st.nextToken());
    char[][] arr=new char[rows][cols];
    for(int y=0 ; y<rows ; y++){
      String temp=f.readLine();
      for(int x=0 ; x<cols ; x++)arr[y][x]=temp.charAt(x);
    }
    int counter=0 ;
    for(int y=0 ; y<rows-1 ; y++)for(int x=0 ; x<cols-1 ; x++){
      int[] freq=new int[26];
      freq[arr[y][x]-97]++;
      freq[arr[y+1][x]-97]++;
      freq[arr[y][x+1]-97]++;
      freq[arr[y+1][x+1]-97]++;
      if(freq['f'-97]==1 && freq['a'-97]==1 && freq['c'-97]==1 && freq['e'-97]==1)counter++;
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Face_Detection {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
    var rows : int ; rows := (st.next())->toInteger() ;
    var cols : int ; cols := (st.next())->toInteger() ;
    var arr : Sequence(Sequence(String)) ; arr := Integer.subrange(1,rows)->collect(Integer.subrange(1,cols)->collect(0)) ;
        var y : int ; y := 0 ; while y < rows do ( (     var temp : String ; temp := f.readLine() ;
         var x : int ; x := 0 ; while x < cols do (     arr[y+1][x+1] := temp->at(x+1) ;  ;     x := x + 1 ) )  ;     y := y + 1 ) ; 
    var counter : int ; counter := 0 ;
        var y : int ; y := 0 ; while y < rows - 1 do (         var x : int ; x := 0 ; while x < cols - 1 do ( (     var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
     freq[arr[y+1][x+1] - 97+1] := freq[arr[y+1][x+1] - 97+1] + 1 ; 
    freq[arr[y + 1+1][x+1] - 97+1] := freq[arr[y + 1+1][x+1] - 97+1] + 1 ; 
    freq[arr[y+1][x + 1+1] - 97+1] := freq[arr[y+1][x + 1+1] - 97+1] + 1 ; 
    freq[arr[y + 1+1][x + 1+1] - 97+1] := freq[arr[y + 1+1][x + 1+1] - 97+1] + 1 ; 
    if (freq[('f')->char2byte() - 97+1] = 1 & freq[('a')->char2byte() - 97+1] = 1 & freq[('c')->char2byte() - 97+1] = 1 & freq[('e')->char2byte() - 97+1] = 1) then     counter := counter + 1 ; else skip ; 
 )  ;     x := x + 1 ) ;  ;     y := y + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    char[][] pic=new char[n][m];
    String temp ;
    for(int i=0 ; i<n ; i++){
      temp=sc.next();
      for(int j=0 ; j<m ; j++){
        pic[i][j]=temp.charAt(j);
      }
    }
    int inc=0,inc1=0 ;
    boolean[] comeIn=new boolean[4];
    if(n>1 || m>1){
      for(int x=0 ; x<n-1 ; x++){
        for(int y=0 ; y<m-1 ; y++){
          for(int i=x ; i<2+x ; i++){
            for(int j=y ; j<2+y ; j++){
              if(pic[i][j]=='f' && comeIn[0]==false){
                inc++;
                comeIn[0]=true ;
              }
              else if(pic[i][j]=='a' && comeIn[1]==false){
                inc++;
                comeIn[1]=true ;
              }
              else if(pic[i][j]=='c' && comeIn[2]==false){
                inc++;
                comeIn[2]=true ;
              }
              else if(pic[i][j]=='e' && comeIn[3]==false){
                inc++;
                comeIn[3]=true ;
              }
            }
          }
          if(inc==4)inc1++;
          inc=0 ;
          Arrays.fill(comeIn,false);
        }
      }
      System.out.println(inc1);
    }
    else {
      System.out.println("0");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var pic : Sequence(Sequence(String)) ; pic := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var temp : String ;
        var i : int ; i := 0 ; while i < n do ( (     temp := sc.getCurrent() ; 
         var j : int ; j := 0 ; while j < m do ( (     pic[i+1][j+1] := temp->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var inc : int ; inc := 0 ;
    var inc1 : int ; inc1 := 0 ;
    var comeIn : Sequence(boolean) ; comeIn := Integer.subrange(1,4)->collect(false) ;
    if (n > 1 or m > 1) then (         var x : int ; x := 0 ; while x < n - 1 do ( (         var y : int ; y := 0 ; while y < m - 1 do ( (         var i : int ; i := x ; while i < 2 + x do ( (         var j : int ; j := y ; while j < 2 + y do ( (     if (pic[i+1][j+1] = 'f' & comeIn[0+1] = false) then (     inc := inc + 1 ; 
     comeIn[0+1] := true ) else     if (pic[i+1][j+1] = 'a' & comeIn[1+1] = false) then (     inc := inc + 1 ; 
     comeIn[1+1] := true ) else     if (pic[i+1][j+1] = 'c' & comeIn[2+1] = false) then (     inc := inc + 1 ; 
     comeIn[2+1] := true ) else     if (pic[i+1][j+1] = 'e' & comeIn[3+1] = false) then (     inc := inc + 1 ; 
     comeIn[3+1] := true ) else skip ; ;  ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (inc = 4) then     inc1 := inc1 + 1 ; else skip ; 
     inc := 0 ; 
     comeIn := comeIn->collect(false) )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
     OclFile["System.out"].println(inc1) ) else (     OclFile["System.out"].println("0") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  @ SuppressWarnings("unchecked")public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int numNode=sc.nextInt();
    int numEdge=sc.nextInt();
    connect=new ArrayList[numNode];
    for(int i=0 ; i<numNode ; i++){
      connect[i]=new ArrayList<>();
    }
    for(int i=0 ; i<numEdge ; i++){
      int a=sc.nextInt()-1 ;
      int b=sc.nextInt()-1 ;
      connect[a] .add(b);
      connect[b] .add(a);
    }
    if(numEdge % 2!=0){
      System.out.println(-1);
      return ;
    }
    visited=new int[numNode];
    odd=new boolean[numNode];
    print=new StringBuilder();
    dfs(0,-1);
    System.out.println(print);
  }
  static ArrayList<Integer>connect[];
  static int visited[];
  static boolean odd[];
  static StringBuilder print ;
  static void dfs(int crt,int parent){
    visited[crt]=1 ;
    ArrayList<Integer>crtConnect=connect[crt];
    for(int child : crtConnect){
      if(child==parent || visited[child]==1){
        continue ;
      }
      else if(visited[child]==2){
        print.append((crt+1)+" "+(child+1)+"\n");
        odd[crt]=! odd[crt];
      }
      else {
        dfs(child,crt);
        if(odd[child]){
          print.append((child+1)+" "+(crt+1)+"\n");
          odd[child]=! odd[child];
        }
        else {
          print.append((crt+1)+" "+(child+1)+"\n");
          odd[crt]=! odd[crt];
        }
      }
    }
    visited[crt]=2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numNode : int ; numNode := sc.getCurrent()->toInteger() ;
    var numEdge : int ; numEdge := sc.getCurrent()->toInteger() ;
    connect := Integer.subrange(1,numNode)->collect(null) ; 
        var i : int ; i := 0 ; while i < numNode do ( (     connect[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < numEdge do ( (     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
     var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
     connect[a+1]->excludes(b) ; 
     connect[b+1]->excludes(a) )  ;     i := i + 1 ) ; 
    if (numEdge mod 2 /= 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    visited := Integer.subrange(1,numNode)->collect(0) ; 
    odd := Integer.subrange(1,numNode)->collect(false) ; 
    print := StringLib.newString() ; 
    execute dfs(0, -1) ; 
    OclFile["System.out"].println(print) ; 
 );
  static   attribute connect : Sequence(Sequence(int));
  static   attribute visited : Sequence(int);
  static   attribute odd : Sequence(boolean);
  static   attribute print : String;
  static   operation dfs( crt : int, parent : int) : void
  pre: true
  post: true
  activity: (     visited[crt+1] := 1 ; 
     var crtConnect : Sequence(int) ; crtConnect := connect[crt+1] ;
     for (child : crtConnect) do ( (     if (child = parent or visited[child+1] = 1) then (     continue ) else     if (visited[child+1] = 2) then (     print := print + StringLib.newString((crt + 1) + " " + (child + 1) + "\n") ; 
     odd[crt+1] := not(odd[crt+1]) ) else (     execute dfs(child, crt) ; 
     if (odd[child+1]) then (     print := print + StringLib.newString((child + 1) + " " + (crt + 1) + "\n") ; 
     odd[child+1] := not(odd[child+1]) ) else (     print := print + StringLib.newString((crt + 1) + " " + (child + 1) + "\n") ; 
     odd[crt+1] := not(odd[crt+1]) ) ) ;  )  ) ; 
     visited[crt+1] := 2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  static PrintWriter out=new PrintWriter(System.out,false);
  static Set<Point>set=new HashSet<>();
  static List<List<Integer>>edge=new ArrayList<>();
  static boolean[] visited ;
  public static void main(String[] $){
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    visited=new boolean[n];
    for(int i=0 ; i<n ; i++){
      edge.add(new ArrayList<>());
    }
    for(int i=0 ; i<m ; i++){
      int a=scanner.nextInt()-1 ;
      int b=scanner.nextInt()-1 ;
      edge.get(a).add(b);
      edge.get(b).add(a);
    }
    if(m % 2==1){
      System.out.println(-1);
    }
    else {
      dfs(-1,0);
    }
    out.flush();
  }
  static boolean dfs(int parent,int node){
    visited[node]=true ;
    int use=0 ;
    for(int i : edge.get(node)){
      if(i!=parent && ! set.contains(new Point(node,i))&&(visited[i] || dfs(node,i))){
        set.add(new Point(i,node));
        out.println((node+1)+" "+(i+1));
        use++;
      }
    }
    if(use % 2==1 && parent!=-1){
      out.println((node+1)+" "+(parent+1));
    }
    return use % 2==0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute set : Set(Point) := Set{};
  static   attribute edge : Sequence(Sequence(int)) := Sequence{};
  static   attribute visited : Sequence(boolean);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
    visited := Integer.subrange(1,n)->collect(false) ; 
        var i : int ; i := 0 ; while i < n do ( (     edge := edge->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := scanner.getCurrent()->toInteger() - 1 ;
     var b : int ; b := scanner.getCurrent()->toInteger() - 1 ;
     edge->at(a+1)->excludes(b) ; 
     edge->at(b+1)->excludes(a) )  ;     i := i + 1 ) ; 
    if (m mod 2 = 1) then (     OclFile["System.out"].println(-1) ) else (     execute dfs(-1, 0) ) ;  
    skip ; 
 );
  static   operation dfs( parent : int, node : int) : boolean
  pre: true
  post: true
  activity: (     visited[node+1] := true ; 
     var use : int ; use := 0 ;
    for (i : edge->at(node+1)) do ( (     if (i /= parent & not(set->includes(Point.newPoint(node, i))) & (visited[i+1] or dfs(node, i))) then (     set := set->including(Point.newPoint(i, node)) ; 
     skip ; 
     use := use + 1 ) else skip )  ) ; 
    if (use mod 2 = 1 & parent /= -1) then (     skip ) else skip ; 
    return use mod 2 = 0 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int C=scan.nextInt();
    long mod=(long)1e9+7 ;
    long[] A=new long[N];
    long[] B=new long[N];
    long[][] K=new long[401][401];
    for(int i=0 ; i<401 ; ++i){
      K[i][0]=1 ;
      for(int j=1 ; j<401 ; ++j){
        K[i][j]=(K[i][j-1]*(long)i)% mod ;
      }
    }
    for(int i=1 ; i<401 ; ++i){
      for(int j=0 ; j<401 ; ++j){
        K[i][j]=(K[i-1][j]+K[i][j])% mod ;
      }
    }
    for(int i=0 ; i<N ; ++i)A[i]=scan.nextLong();
    for(int i=0 ; i<N ; ++i)B[i]=scan.nextLong();
    long[][] dp=new long[N+1][C+1];
    dp[0][0]=1 ;
    for(int i=0 ; i<N ; ++i){
      for(int c=0 ; c<=C ; ++c){
        for(int k=0 ; k<=c ; ++k)dp[i+1][c]=(dp[i+1][c]+(((K[(int)B[i] ][k]-K[(int)A[i]-1][k]+mod)% mod)*dp[i][c-k])% mod)% mod ;
      }
    }
    System.out.println(dp[N][C]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var C : int ; C := scan.getCurrent()->toInteger() ;
    var mod : long ; mod := 1e9->oclAsType(long) + 7 ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
    var B : Sequence(long) ; B := Integer.subrange(1,N)->collect(0) ;
    var K : Sequence(Sequence(long)) ; K := Integer.subrange(1,401)->collect(Integer.subrange(1,401)->collect(0)) ;
        var i : int ; i := 0 ; while i < 401 do ( (     K[i+1][0+1] := 1 ; 
         var j : int ; j := 1 ; while j < 401 do ( (     K[i+1][j+1] := (K[i+1][j - 1+1] * i->oclAsType(long)) mod mod )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < 401 do ( (         var j : int ; j := 0 ; while j < 401 do ( (     K[i+1][j+1] := (K[i - 1+1][j+1] + K[i+1][j+1]) mod mod )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do (     A[i+1] := scan.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do (     B[i+1] := scan.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,C + 1)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 0 ; while i < N do ( (         var c : int ; c := 0 ; while c <= C do ( (         var k : int ; k := 0 ; while k <= c do (     dp[i + 1+1][c+1] := (dp[i + 1+1][c+1] + (((K[B[i+1]->oclAsType(int)+1][k+1] - K[A[i+1]->oclAsType(int) - 1+1][k+1] + mod) mod mod) * dp[i+1][c - k+1]) mod mod) mod mod ;  ;     k := k + 1 ) )  ;     c := c + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[N+1][C+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Stack ;
public class AlternatingCurrent {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    char[] in=br.readLine().trim().toCharArray();
    Stack<Character>stk=new Stack<>();
    for(Character c : in){
      if(stk.isEmpty()){
        stk.push(c);
        continue ;
      }
      char top=stk.peek();
      if(top==c){
        stk.pop();
      }
      else {
        stk.push(c);
      }
    }
    if(stk.isEmpty())System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class AlternatingCurrent {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var in : Sequence(String) ; in := br.readLine()->trim()->characters() ;
    var stk : Sequence(String) ; stk := Sequence{} ;
    for (c : in) do ( (     if (stk->isEmpty()) then (     stk := stk->append(c) ; 
     continue ) else skip ; 
     var top : String ; top := stk->min() ;
     if (top = c) then (     stk := stk->front() ) else (     stk := stk->append(c) ) )  ) ; 
    if (stk->isEmpty()) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf1146B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    StringBuilder str=new StringBuilder(scan.next());
    int index=str.indexOf("a");
    int aCnt=0 ;
    while(index!=-1){
      aCnt++;
      index=str.indexOf("a",index+1);
    }
    int sLength=(str.length()-aCnt)/2 ;
    String s=str.substring(0,str.length()-sLength);
    String s2=s ;
    String r=str.substring(str.length()-sLength);
    s=s.replaceAll("a","");
    if(s.equals(r)){
      System.out.println(s2);
    }
    else {
      System.out.println(":(");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1146B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := StringLib.newString(scan.getCurrent()) ;
    var index : int ; index := str->indexOf("a")-1 ;
    var aCnt : int ; aCnt := 0 ;
    while (index /= -1) do (     aCnt := aCnt + 1 ; 
     index := str.subrange(index + 1+1)->indexOf("a"+"") + index + 1 - 1  ) ; 
    var sLength : int ; sLength := (str->size() - aCnt) / 2 ;
    var s : String ; s := str.subrange(0+1,str->size() - sLength) ;
    var s2 : String ; s2 := s ;
    var r : String ; r := str.subrange(str->size() - sLength+1,str->size() - sLength) ;
    s := s.replaceAllMatches("a", "" ) ; 
    if (s = r) then (     OclFile["System.out"].println(s2) ) else (     OclFile["System.out"].println(":(") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class main {
  public static void main(String[] args){
    Stack<Character>st=new Stack<>();
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    for(int i=s.length()-1 ; i>=0 ; i--){
      char c=s.charAt(i);
      if(st.isEmpty()|| st.peek()!=c)st.push(c);
      else st.pop();
    }
    if(st.isEmpty())System.out.print("Yes\r\n"+"");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var st : Sequence(String) ; st := Sequence{} ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var s : String ; s := sc.getCurrent() ;
        var i : int ; i := s->size() - 1 ; while i >= 0 do ( (     var c : String ; c := s->at(i+1) ;
     if (st->isEmpty() or st->min() /= c) then     st := st->append(c) ; else     st := st->front() ; )  ;     i := i - 1 ) ; 
    if (st->isEmpty()) then     OclFile["System.out"].print("Yes\r\n" + "") else     OclFile["System.out"].print("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] s=br.readLine().split(" ");
    String str=s[0];
    int n=str.length();
    if(n % 2!=0){
      System.out.println("NO");
      return ;
    }
    Stack<Character>stack=new Stack<Character>();
    for(int i=0 ; i<n ; i++){
      char curr=str.charAt(i);
      if(stack.isEmpty()|| stack.peek()!=curr){
        stack.push(curr);
      }
      else {
        stack.pop();
      }
    }
    if(stack.isEmpty()){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
    var str : String ; str := s[0+1] ;
    var n : int ; n := str->size() ;
    if (n mod 2 /= 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    var stack : Sequence(String) ; stack := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var curr : String ; curr := str->at(i+1) ;
     if (stack->isEmpty() or stack->min() /= curr) then (     stack := stack->append(curr) ) else (     stack := stack->front() ) )  ;     i := i + 1 ) ; 
    if (stack->isEmpty()) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Stack ;
public class aa {
  @ SuppressWarnings("resource")public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    Stack<Integer>st=new Stack<Integer>();
    int n=s.length();
    for(int i=0 ; i<n ; i++){
      int u=s.charAt(i);
      if(st.size()>0 && st.peek()==u)st.pop();
      else st.push(u);
    }
    if(st.size()==0)System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class aa {
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var st : Sequence(int) ; st := Sequence{} ;
    var n : int ; n := s->size() ;
        var i : int ; i := 0 ; while i < n do ( (     var u : int ; u := s->at(i+1) ;
     if (st->size() > 0 & st->min() = u) then     st := st->front() ; else     st := st->append(u) ; )  ;     i := i + 1 ) ; 
    if (st->size() = 0) then     OclFile["System.out"].print("Yes") else     OclFile["System.out"].print("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf596B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    long out=0 ;
    int x=0 ;
    for(int i=0 ; i<n ; i++){
      int in=scan.nextInt();
      out+=Math.abs(x-in);
      x=in ;
    }
    System.out.println(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf596B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var out : long ; out := 0 ;
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var in : int ; in := scan.getCurrent()->toInteger() ;
     out := out+(if x - in < 0 then -(x - in) else x - in endif) ; 
     x := in )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().start();
  }
  int[] matchTo ;
  boolean[] vis ;
  ArrayList<Integer>[] g ;
  @ SuppressWarnings("unchecked")void start(){
    Scanner in=new Scanner(System.in);
    int x=in.nextInt();
    int y=in.nextInt();
    int e=in.nextInt();
    int[] xs=new int[e];
    int[] ys=new int[e];
    g=new ArrayList[x+y];
    for(int i=0 ; i<x+y ; i++){
      g[i]=new ArrayList<>();
    }
    for(int i=0 ; i<e ; i++){
      xs[i]=in.nextInt();
      ys[i]=in.nextInt()+x ;
      g[xs[i] ] .add(ys[i]);
      g[ys[i] ] .add(xs[i]);
    }
    vis=new boolean[x+y];
    matchTo=new int[x+y];
    Arrays.fill(matchTo,-1);
    int match=0 ;
    for(int i=0 ; i<x ; i++){
      Arrays.fill(vis,false);
      if(dfs(i))match++;
    }
    System.out.println(match);
    in.close();
  }
  boolean dfs(int v){
    if(v<0)return true ;
    for(int u : g[v]){
      if(vis[u])continue ;
      vis[u]=true ;
      if(dfs(matchTo[u])){
        matchTo[u]=v ;
        matchTo[v]=u ;
        return true ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().start() );
   attribute matchTo : Sequence(int);
   attribute vis : Sequence(boolean);
   attribute g : Sequence(Sequence(int));
     operation start() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := in.getCurrent()->toInteger() ;
    var y : int ; y := in.getCurrent()->toInteger() ;
    var e : int ; e := in.getCurrent()->toInteger() ;
    var xs : Sequence(int) ; xs := Integer.subrange(1,e)->collect(0) ;
    var ys : Sequence(int) ; ys := Integer.subrange(1,e)->collect(0) ;
    g := Integer.subrange(1,x + y)->collect(null) ; 
        var i : int ; i := 0 ; while i < x + y do ( (     g[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < e do ( (     xs[i+1] := in.getCurrent()->toInteger() ; 
     ys[i+1] := in.getCurrent()->toInteger() + x ; 
     g[xs[i+1]+1]->excludes(ys[i+1]) ; 
     g[ys[i+1]+1]->excludes(xs[i+1]) )  ;     i := i + 1 ) ; 
    vis := Integer.subrange(1,x + y)->collect(false) ; 
    matchTo := Integer.subrange(1,x + y)->collect(0) ; 
    matchTo := matchTo->collect(-1) ; 
    var match : int ; match := 0 ;
        var i : int ; i := 0 ; while i < x do ( (     vis := vis->collect(false) ; 
     if (dfs(i)) then     match := match + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(match) ; 
    skip ; 
 );
   operation dfs( v : int) : boolean
  pre: true
  post: true
  activity: (     if (v < 0) then     return true else skip ; 
     for (u : g[v+1]) do ( (     if (vis[u+1]) then     continue else skip ; 
     vis[u+1] := true ; 
     if (dfs(matchTo[u+1])) then (     matchTo[u+1] := v ; 
     matchTo[v+1] := u ; 
     return true ) else skip )  ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=100 ;
  static int countMountains(int a[][],int n){
    int[][] A=new int[n+2][n+2];
    int count=0 ;
    for(int i=0 ; i<n+2 ; i++){
      for(int j=0 ; j<n+2 ; j++){
        if((i==0)||(j==0)||(i==n+1)||(j==n+1)){
          A[i][j]=Integer.MIN_VALUE ;
        }
        else {
          A[i][j]=a[i-1][j-1];
        }
      }
    }
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=n ; j++){
        if((A[i][j]>A[i-1][j])&&(A[i][j]>A[i+1][j])&&(A[i][j]>A[i][j-1])&&(A[i][j]>A[i][j+1])&&(A[i][j]>A[i-1][j-1])&&(A[i][j]>A[i+1][j+1])&&(A[i][j]>A[i-1][j+1])&&(A[i][j]>A[i+1][j-1])){
          count++;
        }
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int a[][]={
      {
        1,2,3 },{
          4,5,6 },{
            7,8,9 }
          };
          int n=3 ;
          System.out.print(countMountains(a,n));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100;
  static   operation countMountains( a : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     var A : Sequence(Sequence(int)) ; A := Integer.subrange(1,n + 2)->collect(Integer.subrange(1,n + 2)->collect(0)) ;
     var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n + 2 do ( (         var j : int ; j := 0 ; while j < n + 2 do ( (     if ((i = 0) or (j = 0) or (i = n + 1) or (j = n + 1)) then (     A[i+1][j+1] := -2147483648 ) else (     A[i+1][j+1] := a[i - 1+1][j - 1+1] ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     if ((A[i+1][j+1] > A[i - 1+1][j+1]) & (A[i+1][j+1] > A[i + 1+1][j+1]) & (A[i+1][j+1] > A[i+1][j - 1+1]) & (A[i+1][j+1] > A[i+1][j + 1+1]) & (A[i+1][j+1] > A[i - 1+1][j - 1+1]) & (A[i+1][j+1] > A[i + 1+1][j + 1+1]) & (A[i+1][j+1] > A[i - 1+1][j + 1+1]) & (A[i+1][j+1] > A[i + 1+1][j - 1+1])) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(Sequence(int)) ; a := Sequence{Sequence{1,2,3},Sequence{4,5,6},Sequence{7,8,9}} ;
     var n : int ; n := 3 ;
     OclFile["System.out"].print(countMountains(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int N=100005 ;
  static int d[]=new int[N],pre[]=new int[N];
  static void Positive_Divisors(){
    for(int i=1 ; i<N ; i++){
      for(int j=1 ; j*j<=i ; j++){
        if(i % j==0){
          if(j*j==i)d[i]++;
          else d[i]+=2 ;
        }
      }
    }
    int ans=0 ;
    for(int i=2 ; i<N ; i++){
      if(d[i]==d[i-1])ans++;
      pre[i]=ans ;
    }
  }
  public static void main(String[] args){
    Positive_Divisors();
    int n=15 ;
    System.out.println(pre[n]);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 100005;
  static   attribute d : int := Integer.subrange(1,N)->collect(0);
  static   operation Positive_Divisors() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < N do ( (         var j : int ; j := 1 ; while j * j <= i do ( (     if (i mod j = 0) then (     if (j * j = i) then     d[i+1] := d[i+1] + 1 ; else     d[i+1] := d[i+1]+(2) ; ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     var ans : int ; ans := 0 ;
         var i : int ; i := 2 ; while i < N do ( (     if (d[i+1] = d[i - 1+1]) then     ans := ans + 1 ; else skip ; 
     pre[i+1] := ans )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute Positive_Divisors() ; 
     var n : int ; n := 15 ;
     OclFile["System.out"].println(pre[n+1]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    int m=s.nextInt();
    int[] memory=new int[m];
    int allocIdx=0 ;
    for(int j=0 ; j<t ; j++){
      switch(s.next()){
        case "alloc" : int n=s.nextInt();
        int len=0 ;
        boolean canAlloc=false ;
        for(int i=0 ; i<m ; i++){
          if(memory[i]==0)len++;
          else len=0 ;
          if(len==n){
            canAlloc=true ;
            len=i-n+1 ;
            break ;
          }
        }
        if(canAlloc){
          allocIdx++;
          for(int i=len ; i<len+n ; i++)memory[i]=allocIdx ;
          System.out.println(allocIdx);
        }
        else System.out.println("NULL");
        break ;
        case "erase" : int x=s.nextInt();
        if(x<=0){
          System.out.println("ILLEGAL_ERASE_ARGUMENT");
          break ;
        }
        boolean hasErased=false ;
        for(int i=0 ; i<m ; i++){
          if(memory[i]==x){
            memory[i]=0 ;
            hasErased=true ;
          }
        }
        if(! hasErased)System.out.println("ILLEGAL_ERASE_ARGUMENT");
        break ;
        case "defragment" : int d=0 ;
        for(int i=0 ; i<m ; i++){
          if(memory[i]==0)d++;
          else memory[i-d]=memory[i];
        }
        for(int i=m-d ; i<m ; i++)memory[i]=0 ;
        break ;
        default : System.out.println("h");
        break ;
      }
    }
    s.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
    var m : int ; m := s.getCurrent()->toInteger() ;
    var memory : Sequence(int) ; memory := Integer.subrange(1,m)->collect(0) ;
    var allocIdx : int ; allocIdx := 0 ;
        var j : int ; j := 0 ; while j < t do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (s.getCurrent()) ; 
       if _switchval = "alloc" then
     var n : int ; n := s.getCurrent()->toInteger() ;
    var len : int ; len := 0 ;
    var canAlloc : boolean ; canAlloc := false ;
        var i : int ; i := 0 ; while i < m do ( (     if (memory[i+1] = 0) then     len := len + 1 else     len := 0 ; ;  
     if (len = n) then (     canAlloc := true ; 
     len := i - n + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (canAlloc) then (     allocIdx := allocIdx + 1 ; 
         var i : int ; i := len ; while i < len + n do (     memory[i+1] := allocIdx ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(allocIdx) ) else     OclFile["System.out"].println("NULL") ; ;  
    break 
   else skip ;
       if _switchval = "erase" then
     var x : int ; x := s.getCurrent()->toInteger() ;
    if (x <= 0) then (     OclFile["System.out"].println("ILLEGAL_ERASE_ARGUMENT") ; 
     break ) else skip ; 
    var hasErased : boolean ; hasErased := false ;
        var i : int ; i := 0 ; while i < m do ( (     if (memory[i+1] = x) then (     memory[i+1] := 0 ; 
     hasErased := true ) else skip )  ;     i := i + 1 ) ; 
    if (not(hasErased)) then     OclFile["System.out"].println("ILLEGAL_ERASE_ARGUMENT") ; else skip ; 
    break 
   else skip ;
       if _switchval = "defragment" then
     var d : int ; d := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     if (memory[i+1] = 0) then     d := d + 1 ; else     memory[i - d+1] := memory[i+1] ; )  ;     i := i + 1 ) ; 
        var i : int ; i := m - d ; while i < m do (     memory[i+1] := 0 ;  ;     i := i + 1 ) ; 
    break 
   else skip ;
       if true then
     OclFile["System.out"].println("h") ; 
    break 
   else skip ;
 )
 )  ;     j := j + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static double area_of_regular_polygon(double n,double len){
    double P=(len*n);
    double A=len/(2*Math.tan((180/n)*3.14159/180));
    double area=(P*A)/2 ;
    return area ;
  }
  static double area_of_triangle_inscribed(double n,double len){
    double area=area_of_regular_polygon(n,len);
    double triangle=area/n ;
    double ins_tri=(triangle*3);
    return ins_tri ;
  }
  static public void main(String[] arg){
    double n=6,len=10 ;
    System.out.printf("%.3f",area_of_triangle_inscribed(n,len));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation area_of_regular_polygon( n : double, len : double) : double
  pre: true
  post: true
  activity: (     var P : double ; P := (len * n) ;
     var A : double ; A := len / (2 * ((180 / n) * 3.14159 / 180)->tan()) ;
     var area : double ; area := (P * A) / 2 ;
     return area );
  static   operation area_of_triangle_inscribed( n : double, len : double) : double
  pre: true
  post: true
  activity: (     var area : double ; area := area_of_regular_polygon(n, len) ;
     var triangle : double ; triangle := area / n ;
     var ins_tri : double ; ins_tri := (triangle * 3) ;
     return ins_tri );
  static    operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 6 ;
    var len : double ; len := 10 ;
     OclFile["System.out"].printf("%.3f", area_of_triangle_inscribed(n, len)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Project {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    StringBuilder str=new StringBuilder(scan.next());
    int index=str.indexOf("a");
    int aCnt=0 ;
    while(index!=-1){
      aCnt++;
      index=str.indexOf("a",index+1);
    }
    int sLength=(str.length()-aCnt)/2 ;
    String s=str.substring(0,str.length()-sLength);
    String s2=s ;
    String r=str.substring(str.length()-sLength);
    s=s.replaceAll("a","");
    if(s.equals(r)){
      System.out.println(s2);
    }
    else {
      System.out.println(":(");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Project {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := StringLib.newString(scan.getCurrent()) ;
    var index : int ; index := str->indexOf("a")-1 ;
    var aCnt : int ; aCnt := 0 ;
    while (index /= -1) do (     aCnt := aCnt + 1 ; 
     index := str.subrange(index + 1+1)->indexOf("a"+"") + index + 1 - 1  ) ; 
    var sLength : int ; sLength := (str->size() - aCnt) / 2 ;
    var s : String ; s := str.subrange(0+1,str->size() - sLength) ;
    var s2 : String ; s2 := s ;
    var r : String ; r := str.subrange(str->size() - sLength+1,str->size() - sLength) ;
    s := s.replaceAllMatches("a", "" ) ; 
    if (s = r) then (     OclFile["System.out"].println(s2) ) else (     OclFile["System.out"].println(":(") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static final int MAX=256 ;
  static String lastNonRepeating(String str,int n){
    int freq[]=new int[MAX];
    for(int i=0 ; i<n ; i++)freq[str.charAt(i)]++;
    for(int i=n-1 ; i>=0 ; i--){
      char ch=str.charAt(i);
      if(freq[ch]==1)return(""+ch);
    }
    return "-1" ;
  }
  public static void main(String[] args){
    String str="GeeksForGeeks" ;
    int n=str.length();
    System.out.println(lastNonRepeating(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 256;
  static   operation lastNonRepeating( str : String, n : int) : String
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,MAX)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     freq[str->at(i+1)+1] := freq[str->at(i+1)+1] + 1 ;  ;     i := i + 1 ) ; 
         var i : int ; i := n - 1 ; while i >= 0 do ( (     var ch : String ; ch := str->at(i+1) ;
     if (freq[ch+1] = 1) then     return ("" + ch) else skip )  ;     i := i - 1 ) ; 
     return "-1" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GeeksForGeeks" ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].println(lastNonRepeating(str, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int a[]=new int[n],b[]=new int[n];
    int left=Integer.MAX_VALUE,right=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
      b[i]=in.nextInt();
      left=Math.min(a[i],left);
      right=Math.max(b[i],right);
    }
    int ans=-1 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]==left && b[i]==right){
        ans=i+1 ;
        break ;
      }
    }
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(void) ; b := Integer.subrange(1,n)->collect(0) ;
    var left : int ; left := 2147483647 ;
    var right : int ; right := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     b[i+1] := in.getCurrent()->toInteger() ; 
     left := Set{a[i+1], left}->min() ; 
     right := Set{b[i+1], right}->max() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = left & b[i+1] = right) then (     ans := i + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B {
  static Scanner sc=null ;
  public static void main(String[] args){
    sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[][]=new int[n][2];
    int minI=Integer.MAX_VALUE ;
    int maxI=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      a[i][0]=sc.nextInt();
      a[i][1]=sc.nextInt();
      minI=Math.min(minI,a[i][0]);
      maxI=Math.max(maxI,a[i][1]);
    }
    int res=-1 ;
    for(int i=0 ; i<n ; i++){
      if(minI==a[i][0] && maxI==a[i][1]){
        res=i+1 ;
        break ;
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute sc : OclFile := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
    var minI : int ; minI := 2147483647 ;
    var maxI : int ; maxI := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     a[i+1][1+1] := sc.getCurrent()->toInteger() ; 
     minI := Set{minI, a[i+1][0+1]}->min() ; 
     maxI := Set{maxI, a[i+1][1+1]}->max() )  ;     i := i + 1 ) ; 
    var res : int ; res := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (minI = a[i+1][0+1] & maxI = a[i+1][1+1]) then (     res := i + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
import java.lang.Math ;
public class b06 {
  static final int INF=(int)1e9+5 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n ;
    n=sc.nextInt();
    ArrayList<Integer>a=new ArrayList<>();
    ArrayList<Integer>b=new ArrayList<>();
    int left=INF,right=0 ;
    for(int i=0 ; i<n ; i++){
      a.add(sc.nextInt());
      b.add(sc.nextInt());
      left=Math.min(left,a.get(i));
      right=Math.max(right,b.get(i));
    }
    for(int i=0 ; i<n ; i++){
      if(left==a.get(i)&& right==b.get(i)){
        System.out.println(++i);
        return ;
      }
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class b06 {
  static    attribute INF : int := 1e9->oclAsType(int) + 5;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    n := sc.getCurrent()->toInteger() ; 
    var a : Sequence(int) ; a := Sequence{} ;
    var b : Sequence(int) ; b := Sequence{} ;
    var left : int ; left := INF ;
    var right : int ; right := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a := a->including(sc.getCurrent()->toInteger()) ; 
     b := b->including(sc.getCurrent()->toInteger()) ; 
     left := Set{left, a->at(i+1)}->min() ; 
     right := Set{right, b->at(i+1)}->max() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (left = a->at(i+1) & right = b->at(i+1)) then (     OclFile["System.out"].println((i + 1)) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isSpiltPossible(int n,int a[]){
    int sum=0,c1=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=a[i];
      if(a[i]==1){
        c1++;
      }
    }
    if(sum % 2!=0)return false ;
    if((sum/2)% 2==0)return true ;
    if(c1>0)return true ;
    else return false ;
  }
  public static void main(String[] args){
    int n=3 ;
    int a[]={
      1,1,2 };
      if(isSpiltPossible(n,a))System.out.println("YES");
      else System.out.println("NO");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isSpiltPossible( n : int, a : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
    var c1 : int ; c1 := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(a[i+1]) ; 
     if (a[i+1] = 1) then (     c1 := c1 + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (sum mod 2 /= 0) then     return false else skip ; 
    if ((sum / 2) mod 2 = 0) then     return true else skip ; 
    if (c1 > 0) then     return true else     return false ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var a : Sequence(int) ; a := Sequence{1,1,2} ;
     if (isSpiltPossible(n, a)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class BigSegment {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int min=Integer.MAX_VALUE ;
    int max=Integer.MIN_VALUE ;
    int arr[]=new int[n];
    int arr2[]=new int[n];
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      arr2[i]=sc.nextInt();
      if(arr[i]<=min && arr2[i]>=max){
        min=arr[i];
        max=arr2[i];
        count=i+1 ;
      }
      else if(arr[i]<min){
        min=arr[i];
        count=-1 ;
      }
      else if(arr2[i]>max){
        max=arr2[i];
        count=-1 ;
      }
    }
    System.out.print(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class BigSegment {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var min : int ; min := 2147483647 ;
    var max : int ; max := -2147483648 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,n)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     arr2[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr[i+1] <= min & arr2[i+1] >= max) then (     min := arr[i+1] ; 
     max := arr2[i+1] ; 
     count := i + 1 ) else     if (arr[i+1] < min) then (     min := arr[i+1] ; 
     count := -1 ) else     if (arr2[i+1] > max) then (     max := arr2[i+1] ; 
     count := -1 ) else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float y(float x){
    return(1/(1+x));
  }
  static float BooleRule(float a,float b){
    int n=4 ;
    int h ;
    h=(int)((b-a)/n);
    float sum=0 ;
    float bl=(7*y(a)+32*y(a+h)+12*y(a+2*h)+32*y(a+3*h)+7*y(a+4*h))*2*h/45 ;
    sum=sum+bl ;
    return sum ;
  }
  public static void main(String[] args){
    System.out.printf(("f(x)=%.4f"),BooleRule(0,4));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation y( x : double) : double
  pre: true
  post: true
  activity: (     return (1 / (1 + x)) );
  static   operation BooleRule( a : double, b : double) : double
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var h : int ;
    h := ((b - a) / n)->oclAsType(int) ; 
    var sum : double ; sum := 0 ;
    var bl : double ; bl := (7 * y(a) + 32 * y(a + h) + 12 * y(a + 2 * h) + 32 * y(a + 3 * h) + 7 * y(a + 4 * h)) * 2 * h / 45 ;
    sum := sum + bl ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].printf(("f(x)=%.4f"), BooleRule(0, 4)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maxN=300 ;
  static int maxM=300 ;
  static int dp[][]=new int[maxN][maxM];
  static boolean v[][]=new boolean[maxN][maxM];
  static int findLen(int[] arr,int i,int curr,int n,int m){
    if(i==n){
      if(curr==m)return 0 ;
      else return-1 ;
    }
    if(v[i][curr])return dp[i][curr];
    v[i][curr]=true ;
    int l=findLen(arr,i+1,curr,n,m);
    int r=findLen(arr,i+1,curr & arr[i],n,m);
    dp[i][curr]=l ;
    if(r!=-1)dp[i][curr]=Math.max(dp[i][curr],r+1);
    return dp[i][curr];
  }
  public static void main(String args[]){
    int arr[]={
      3,7,2,3 };
      int n=arr.length ;
      int m=3 ;
      int ans=findLen(arr,0,((1<<8)-1),n,m);
      if(ans==-1)System.out.print(0);
      else System.out.print(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute maxN : int := 300;
  static   attribute maxM : int := 300;
  static   attribute dp : int := Integer.subrange(1,maxN)->collect(Integer.subrange(1,maxM)->collect(0));
  static   attribute v : boolean := Integer.subrange(1,maxN)->collect(Integer.subrange(1,maxM)->collect(false));
  static   operation findLen( arr : Sequence(int), i : int, curr : int, n : int, m : int) : int
  pre: true
  post: true
  activity: (     if (i = n) then (     if (curr = m) then     return 0 else     return -1 ) else skip ; 
     if (v[i+1][curr+1]) then     return dp[i+1][curr+1] else skip ; 
    v[i+1][curr+1] := true ; 
    var l : int ; l := findLen(arr, i + 1, curr, n, m) ;
    var r : int ; r := findLen(arr, i + 1, curr & arr[i+1], n, m) ;
    dp[i+1][curr+1] := l ; 
    if (r /= -1) then     dp[i+1][curr+1] := Set{dp[i+1][curr+1], r + 1}->max() ; else skip ; 
    return dp[i+1][curr+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,7,2,3} ;
     var n : int ; n := arr->size() ;
    var m : int ; m := 3 ;
    var ans : int ; ans := findLen(arr, 0, (((1*(2->pow(8)))->oclAsType(long)) - 1), n, m) ;
    if (ans = -1) then     OclFile["System.out"].print(0) else     OclFile["System.out"].print(ans) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxN=20 ;
  static int maxM=64 ;
  static int[][] dp=new int[maxN][maxM];
  static boolean[][] v=new boolean[maxN][maxM];
  static int findLen(int[] arr,int i,int curr,int n,int m){
    if(i==n){
      if(curr==m)return 0 ;
      else return-1 ;
    }
    if(v[i][curr])return dp[i][curr];
    v[i][curr]=true ;
    int l=findLen(arr,i+1,curr,n,m);
    int r=findLen(arr,i+1,curr | arr[i],n,m);
    dp[i][curr]=l ;
    if(r!=-1)dp[i][curr]=Math.max(dp[i][curr],r+1);
    return dp[i][curr];
  }
  public static void main(String[] args){
    int arr[]={
      3,7,2,3 };
      int n=arr.length ;
      int m=3 ;
      int ans=findLen(arr,0,0,n,m);
      if(ans==-1)System.out.println(0);
      else System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute maxN : int := 20;
  static   attribute maxM : int := 64;
  static   attribute dp : Sequence(Sequence(int)) := Integer.subrange(1,maxN)->collect(Integer.subrange(1,maxM)->collect(0));
  static   attribute v : Sequence(Sequence(boolean)) := Integer.subrange(1,maxN)->collect(Integer.subrange(1,maxM)->collect(false));
  static   operation findLen( arr : Sequence(int), i : int, curr : int, n : int, m : int) : int
  pre: true
  post: true
  activity: (     if (i = n) then (     if (curr = m) then     return 0 else     return -1 ) else skip ; 
     if (v[i+1][curr+1]) then     return dp[i+1][curr+1] else skip ; 
    v[i+1][curr+1] := true ; 
    var l : int ; l := findLen(arr, i + 1, curr, n, m) ;
    var r : int ; r := findLen(arr, i + 1, curr or arr[i+1], n, m) ;
    dp[i+1][curr+1] := l ; 
    if (r /= -1) then     dp[i+1][curr+1] := Set{dp[i+1][curr+1], r + 1}->max() ; else skip ; 
    return dp[i+1][curr+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,7,2,3} ;
     var n : int ; n := arr->size() ;
    var m : int ; m := 3 ;
    var ans : int ; ans := findLen(arr, 0, 0, n, m) ;
    if (ans = -1) then     OclFile["System.out"].println(0) else     OclFile["System.out"].println(ans) ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf1146B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    StringBuilder a=new StringBuilder();
    StringBuilder b=new StringBuilder();
    String t=in.next();
    for(int i=0 ; i<t.length(); i++){
      a.append(t.charAt(i));
      if(t.charAt(i)!='a'){
        b.append(t.charAt(i));
      }
      if(a.length()+b.length()==t.length()){
        break ;
      }
    }
    if(t.equals(a.toString()+b)){
      System.out.println(a);
    }
    else {
      System.out.println(":(");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1146B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := StringLib.newString() ;
    var b : String ; b := StringLib.newString() ;
    var t : String ; t := in.getCurrent() ;
        var i : int ; i := 0 ; while i < t->size() do ( (     a := a + StringLib.newString(t->at(i+1)) ; 
     if (t->at(i+1) /= 'a') then (     b := b + StringLib.newString(t->at(i+1)) ) else skip ; 
     if (a->size() + b->size() = t->size()) then (     break ) else skip )  ;     i := i + 1 ) ; 
    if (t = a+"" + b) then (     OclFile["System.out"].println(a) ) else (     OclFile["System.out"].println(":(") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int N ;
  public static void main(String[] args){
    String S=sc.next();
    N=Integer.parseInt(S);
    int ans=0 ;
    for(int i=3 ; i<=S.length()-1 ; i++){
      ans+=(int)Math.pow(3,i)-3*(int)Math.pow(2,i)+3 ;
    }
    ans+=f(3*(int)Math.pow(10,S.length()-1),S.length()-2);
    ans+=f(5*(int)Math.pow(10,S.length()-1),S.length()-2);
    ans+=f(7*(int)Math.pow(10,S.length()-1),S.length()-2);
    System.out.println(ans);
  }
  static int f(int a,int m){
    if(m>=0){
      return f(a+3*(int)Math.pow(10,m),m-1)+f(a+5*(int)Math.pow(10,m),m-1)+f(a+7*(int)Math.pow(10,m),m-1);
    }
    else {
      String s=Integer.toString(a);
      if(s.indexOf("3")!=-1 && s.indexOf("5")!=-1 && s.indexOf("7")!=-1 && a<=N){
        return 1 ;
      }
      else {
        return 0 ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := sc.getCurrent() ;
     N := (S)->toInteger() ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 3 ; while i <= S->size() - 1 do ( (     ans := ans+(3->pow(i)->oclAsType(int) - 3 * 2->pow(i)->oclAsType(int) + 3) )  ;     i := i + 1 ) ; 
    ans := ans+(f(3 * 10->pow(S->size() - 1)->oclAsType(int), S->size() - 2)) ; 
    ans := ans+(f(5 * 10->pow(S->size() - 1)->oclAsType(int), S->size() - 2)) ; 
    ans := ans+(f(7 * 10->pow(S->size() - 1)->oclAsType(int), S->size() - 2)) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation f( a : int, m : int) : int
  pre: true
  post: true
  activity: (     if (m >= 0) then (     return f(a + 3 * 10->pow(m)->oclAsType(int), m - 1) + f(a + 5 * 10->pow(m)->oclAsType(int), m - 1) + f(a + 7 * 10->pow(m)->oclAsType(int), m - 1) ) else (     var s : String ; s := ((a) + "") ;
     if (s->indexOf("3")-1 /= -1 & s->indexOf("5")-1 /= -1 & s->indexOf("7")-1 /= -1 & a <= N) then (     return 1 ) else (     return 0 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static long n ;
  static int nDigit ;
  static int[] nums={
    3,5,7 };
    static int memo[][]=new int[30][1000000];
    public static void main(String args[]){
      Scanner sc=new Scanner(System.in);
      n=sc.nextInt();
      nDigit=String.valueOf(n).length();
      for(int i=0 ; i<memo.length ; ++i){
        for(int j=0 ; j<memo[0] .length ; ++j){
          memo[i][j]=-1 ;
        }
      }
      System.out.println(solve(0,0,0,0));
    }
    private static int solve(long num,int digit,int stat,int bits){
      if(memo[digit][stat]!=-1){
        return memo[digit][stat];
      }
      int ret=0 ;
      for(int i=0 ; i<3 ; ++i){
        long nextNum=num*10+nums[i];
        int nextBits=bits |(1<<i);
        if(nextNum<=n){
          ret+=solve(nextNum,digit+1,stat*3+i,nextBits);
          if(nextBits==7){
++ret ;
          }
        }
      }
      return memo[digit][stat]=ret ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : long;
  static   attribute nDigit : int;
  static   attribute nums : Sequence(int) := Sequence{3,5,7};
  static   attribute memo : int := Integer.subrange(1,30)->collect(Integer.subrange(1,1000000)->collect(0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    nDigit := ((n) + "")->size() ; 
        var i : int ; i := 0 ; while i < memo->size() do ( (         var j : int ; j := 0 ; while j < memo[0+1]->size() do ( (     memo[i+1][j+1] := -1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(0, 0, 0, 0)) ; 
 );
  static   operation solve( num : long, digit : int, stat : int, bits : int) : int
  pre: true
  post: true
  activity: (     if (memo[digit+1][stat+1] /= -1) then (     return memo[digit+1][stat+1] ) else skip ; 
     var ret : int ; ret := 0 ;
         var i : int ; i := 0 ; while i < 3 do ( (     var nextNum : long ; nextNum := num * 10 + nums[i+1] ;
     var nextBits : int ; nextBits := MathLib.bitwiseOr(bits,((1*(2->pow(i)))->oclAsType(long))) ;
     if (nextNum <= n) then (     ret := ret+(solve(nextNum, digit + 1, stat * 3 + i, nextBits)) ; 
     if (nextBits = 7) then (     ret := ret + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
     return memo[digit+1][stat+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      arr[i]=sc.nextInt();
    }
    int[] dp=new int[5];
    for(int i=1 ; i<=n ; i++){
      dp[1]=dp[1]+(arr[i]==1 ? 1 : 0);
      dp[2]=Math.max(dp[1],dp[2]+(arr[i]==2 ? 1 : 0));
      dp[3]=Math.max(dp[2],dp[3]+(arr[i]==1 ? 1 : 0));
      dp[4]=Math.max(dp[3],dp[4]+(arr[i]==2 ? 1 : 0));
    }
    System.out.println(dp[4]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,5)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     dp[1+1] := dp[1+1] + (if arr[i+1] = 1 then 1 else 0 endif) ; 
     dp[2+1] := Set{dp[1+1], dp[2+1] + (if arr[i+1] = 2 then 1 else 0 endif)}->max() ; 
     dp[3+1] := Set{dp[2+1], dp[3+1] + (if arr[i+1] = 1 then 1 else 0 endif)}->max() ; 
     dp[4+1] := Set{dp[3+1], dp[4+1] + (if arr[i+1] = 2 then 1 else 0 endif)}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[4+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  private static long n ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextLong();
    System.out.println(dfs(0));
  }
  private static long dfs(long a){
    if(a>n)return 0 ;
    long i=a ;
    Set<Integer>set=new HashSet<>();
    while(i>0){
      if(i % 10==7){
        set.add(7);
      }
      else if(i % 10==5){
        set.add(5);
      }
      else if(i % 10==3){
        set.add(3);
      }
      if(set.size()>=3)break ;
      i/=10 ;
    }
    long b=set.size()>=3 ? 1 : 0 ;
    b+=dfs(a*10+7);
    b+=dfs(a*10+5);
    b+=dfs(a*10+3);
    return b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toLong() ; 
     OclFile["System.out"].println(dfs(0)) );
  static   operation dfs( a : long) : long
  pre: true
  post: true
  activity: (     if (a > n) then     return 0 else skip ; 
     var i : long ; i := a ;
    var set : Set(int) ; set := Set{} ;
    while (i > 0) do (     if (i mod 10 = 7) then (     set := set->including(7) ) else     if (i mod 10 = 5) then (     set := set->including(5) ) else     if (i mod 10 = 3) then (     set := set->including(3) ) else skip ; ;  ;  
     if (set->size() >= 3) then     break else skip ; 
     i := i/(10) ) ; 
    var b : long ; b := if set->size() >= 3 then 1 else 0 endif ;
    b := b+(dfs(a * 10 + 7)) ; 
    b := b+(dfs(a * 10 + 5)) ; 
    b := b+(dfs(a * 10 + 3)) ; 
    return b 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int N=gi();
    long i=357 ;
    int c=0 ;
    while(i<=N){
      String s=String.valueOf(i);
      if(s.contains("3")&& s.contains("5")&& s.contains("7"))c++;
      StringBuilder sb=new StringBuilder();
      boolean f=false ;
      for(int j=0 ; j<s.length(); j++){
        char a=s.charAt(s.length()-1-j);
        if(f){
          sb.append(a);
        }
        else {
          if(a=='3'){
            sb.append('5');
            f=true ;
          }
          else if(a=='5'){
            sb.append('7');
            f=true ;
          }
          else {
            sb.append('3');
          }
        }
      }
      if(! f)sb.append(3);
      StringBuffer sb2=new StringBuffer(sb);
      i=Long.parseLong(sb2.reverse().toString());
    }
    System.out.println(c);
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : int ; N := gi() ;
    var i : long ; i := 357 ;
    var c : int ; c := 0 ;
    while (i <= N) do (     var s : String ; s := ((i) + "") ;
     if (s->includes("3") & s->includes("5") & s->includes("7")) then     c := c + 1 ; else skip ; 
    var sb : String ; sb := StringLib.newString() ;
    var f : boolean ; f := false ;
        var j : int ; j := 0 ; while j < s->size() do ( (     var a : String ; a := s->at(s->size() - 1 - j+1) ;
     if (f) then (     sb := sb + StringLib.newString(a) ) else (     if (a = '3') then (     sb := sb + StringLib.newString('5') ; 
     f := true ) else     if (a = '5') then (     sb := sb + StringLib.newString('7') ; 
     f := true ) else (     sb := sb + StringLib.newString('3') ) ;  ) )  ;     j := j + 1 ) ; 
    if (not(f)) then     sb := sb + StringLib.newString(3) ; else skip ; 
    var sb2 : String ; sb2 := StringLib.newString(sb) ;
    i := (sb2->reverse()+"")->toLong() ; 
 ) ; 
    OclFile["System.out"].println(c) ; 
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    sc.close();
    List<String>list=new ArrayList<>(Arrays.asList(new String[] {
      "3","5","7" }
));
      for(int i=0 ; i<26484 ; i++){
        String base=list.get(i);
        list.add(base+3);
        list.add(base+5);
        list.add(base+7);
      }
      List<Long>longList=list.stream().filter(i->i.contains("3")&& i.contains("5")&& i.contains("7")).map(i->Long.parseLong(i)).collect(Collectors.toList());
      int result=0 ;
      for(int i=0 ; i<longList.size(); i++){
        if(longList.get(i)<=(long)n){
          result++;
        }
      }
      System.out.println(result);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    skip ; 
    var list : Sequence(String) ; list := Sequence{}->union(Sequence{"3","5","7"}) ;
        var i : int ; i := 0 ; while i < 26484 do ( (     var base : String ; base := list->at(i+1) ;
     list := list->including(base + 3) ; 
     list := list->including(base + 5) ; 
     list := list->including(base + 7) )  ;     i := i + 1 ) ; 
    var longList : Sequence(long) ; longList := list->select( _x1 | (lambda i : OclAny in i->includes("3") & i->includes("5") & i->includes("7"))->apply(_x1) )->collect( _x1 | (lambda i : OclAny in (i)->toLong())->apply(_x1) ).collect(Collectors.toList()) ;
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < longList->size() do ( (     if (longList->at(i+1) <= n->oclAsType(long)) then (     result := result + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BABC solver=new BABC();
    solver.solve(1,in,out);
    out.close();
  }
  static class BABC {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      String s=in.next().replaceAll("BC","D");
      long cnt=0 ;
      long tmp=0 ;
      for(int i=0 ; i<s.length(); i++){
        if(s.charAt(i)=='A'){
          tmp++;
        }
        else if(s.charAt(i)=='D'){
          cnt+=tmp ;
        }
        else {
          tmp=0 ;
        }
      }
      out.println(cnt);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BABC ; solver := BABC.newBABC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BABC {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.getCurrent().replaceAllMatches("BC", "D" ) ;
     var cnt : long ; cnt := 0 ;
    var tmp : long ; tmp := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'A') then (     tmp := tmp + 1 ) else     if (s->at(i+1) = 'D') then (     cnt := cnt+(tmp) ) else (     tmp := 0 ) ;  )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf1146B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String s=scan.next();
    StringBuilder sb=new StringBuilder(s);
    for(int i=0 ; i<sb.length(); i++){
      if(sb.charAt(i)=='a'){
        sb.deleteCharAt(i);
        i--;
      }
    }
    int x=sb.length()/2 ;
    if(sb.length()% 2==0 && sb.substring(0,x).equals(sb.substring(x,sb.length()))&& sb.substring(0,x).equals(s.substring(s.length()-x))){
      System.out.println(s.substring(0,s.length()-x));
    }
    else {
      System.out.println(":(");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1146B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scan.getCurrent() ;
    var sb : String ; sb := StringLib.newString(s) ;
        var i : int ; i := 0 ; while i < sb->size() do ( (     if (sb->at(i+1) = 'a') then (     sb := sb->excludingAt(i+1) ; 
     i := i - 1 ) else skip )  ;     i := i + 1 ) ; 
    var x : int ; x := sb->size() / 2 ;
    if (sb->size() mod 2 = 0 & sb.subrange(0+1,x) = sb.subrange(x+1,sb->size()) & sb.subrange(0+1,x) = s.subrange(s->size() - x+1,s->size() - x)) then (     OclFile["System.out"].println(s.subrange(0+1,s->size() - x)) ) else (     OclFile["System.out"].println(":(") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    char[] s=br.readLine().toCharArray();
    br.close();
    long ans=0 ;
    int bc=0 ;
    boolean c=false ;
    for(int i=s.length-1 ; i>=0 ; i--){
      if(s[i]=='A'){
        if(c){
          bc=0 ;
        }
        else {
          ans+=bc ;
        }
        c=false ;
      }
      else if(s[i]=='B'){
        if(c){
          bc++;
        }
        else {
          bc=0 ;
        }
        c=false ;
      }
      else if(s[i]=='C'){
        if(c){
          bc=0 ;
        }
        c=true ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : Sequence(String) ; s := br.readLine()->characters() ;
    skip ; 
    var ans : long ; ans := 0 ;
    var bc : int ; bc := 0 ;
    var c : boolean ; c := false ;
        var i : int ; i := s->size() - 1 ; while i >= 0 do ( (     if (s[i+1] = 'A') then (     if (c) then (     bc := 0 ) else (     ans := ans+(bc) ) ;  
     c := false ) else     if (s[i+1] = 'B') then (     if (c) then (     bc := bc + 1 ) else (     bc := 0 ) ;  
     c := false ) else     if (s[i+1] = 'C') then (     if (c) then (     bc := 0 ) else skip ; 
     c := true ) else skip ; ;  )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    char str[]=new char[s.length()+5];
    int pos=0 ;
    int spos=0 ;
    Arrays.fill(str,'3');
    for(int i=0 ; i<s.length(); i++){
      if(spos==s.length()){
        break ;
      }
      if(s.charAt(spos)=='A'){
        str[pos]='1' ;
        pos++;
        spos++;
      }
      else if(s.charAt(spos)=='B'){
        if(spos==s.length()-1){
          str[pos]='3' ;
          break ;
        }
        if(s.charAt(spos+1)=='C'){
          str[pos]='2' ;
          pos++;
          spos++;
          spos++;
        }
        else if(s.charAt(spos+1)=='A'){
          str[pos]='3' ;
          str[pos+1]='1' ;
          pos++;
          pos++;
          spos++;
          spos++;
        }
        else {
          str[pos]='3' ;
          pos++;
          spos++;
          spos++;
        }
      }
      else {
        str[pos]='3' ;
        pos++;
        spos++;
      }
    }
    long ans=0 ;
    long bccnt=0 ;
    long acnt=0 ;
    for(int i=0 ; i<s.length()+1 ; i++){
      if(str[i]=='3'){
        ans+=bccnt ;
        bccnt=0 ;
        acnt=0 ;
      }
      if(str[i]=='1'){
        acnt++;
      }
      if(str[i]=='2'){
        bccnt+=acnt ;
      }
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var str : Sequence(String) ; str := Integer.subrange(1,s->size() + 5)->collect(0) ;
    var pos : int ; pos := 0 ;
    var spos : int ; spos := 0 ;
    str := str->collect('3') ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     if (spos = s->size()) then (     break ) else skip ; 
     if (s->at(spos+1) = 'A') then (     str[pos+1] := '1' ; 
     pos := pos + 1 ; 
     spos := spos + 1 ) else     if (s->at(spos+1) = 'B') then (     if (spos = s->size() - 1) then (     str[pos+1] := '3' ; 
     break ) else skip ; 
     if (s->at(spos + 1+1) = 'C') then (     str[pos+1] := '2' ; 
     pos := pos + 1 ; 
     spos := spos + 1 ; 
     spos := spos + 1 ) else     if (s->at(spos + 1+1) = 'A') then (     str[pos+1] := '3' ; 
     str[pos + 1+1] := '1' ; 
    pos := pos + 1 ; 
    pos := pos + 1 ; 
    spos := spos + 1 ; 
    spos := spos + 1 ; 
 ) else (     str[pos+1] := '3' ; 
     pos := pos + 1 ; 
     spos := spos + 1 ; 
     spos := spos + 1 ) ;  ) else (     str[pos+1] := '3' ; 
     pos := pos + 1 ; 
     spos := spos + 1 ) ;  )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var bccnt : long ; bccnt := 0 ;
    var acnt : long ; acnt := 0 ;
        var i : int ; i := 0 ; while i < s->size() + 1 do ( (     if (str[i+1] = '3') then (     ans := ans+(bccnt) ; 
     bccnt := 0 ; 
     acnt := 0 ) else skip ; 
     if (str[i+1] = '1') then (     acnt := acnt + 1 ) else skip ; 
     if (str[i+1] = '2') then (     bccnt := bccnt+(acnt) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] arr=sc.next().toCharArray();
    int length=arr.length ;
    ArrayList<ArrayList<Boolean>>list=new ArrayList<>();
    int idx=0 ;
    while(idx<length){
      ArrayList<Boolean>each=new ArrayList<>();
      while(idx<length){
        if(arr[idx]=='A'){
          each.add(true);
          idx++;
        }
        else if(arr[idx]=='B' && idx<length-1 && arr[idx+1]=='C'){
          each.add(false);
          idx+=2 ;
        }
        else {
          idx++;
          break ;
        }
      }
      if(each.size()>0){
        list.add(each);
      }
    }
    long total=0 ;
    for(ArrayList<Boolean>each : list){
      int aSum=0 ;
      long count=0 ;
      for(boolean b : each){
        if(b){
          aSum++;
        }
        else {
          count+=aSum ;
        }
      }
      total+=count ;
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
    var length : int ; length := arr->size() ;
    var list : Sequence(Sequence(Boolean)) ; list := Sequence{} ;
    var idx : int ; idx := 0 ;
    while (idx < length) do (     var each : Sequence(Boolean) ; each := Sequence{} ;
     while (idx < length) do (     if (arr[idx+1] = 'A') then (     each := each->including(true) ; 
     idx := idx + 1 ) else     if (arr[idx+1] = 'B' & idx < length - 1 & arr[idx + 1+1] = 'C') then (     each := each->including(false) ; 
     idx := idx+(2) ) else (     idx := idx + 1 ; 
     break ) ;  ) ; 
     if (each->size() > 0) then (     list := list->including(each) ) else skip ) ; 
    var total : long ; total := 0 ;
    for (each : list) do ( (     var aSum : int ; aSum := 0 ;
     var count : long ; count := 0 ;
     for (b : each) do ( (     if (b) then (     aSum := aSum + 1 ) else (     count := count+(aSum) ) )  ) ; 
     total := total+(count) )  ) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    String S=scan.next();
    S=S.replaceAll("BC","D");
    char[] data=S.toCharArray();
    int length=data.length ;
    List<Integer>list=new ArrayList<>();
    for(int i=0 ; i<length ; i++){
      if(data[i]=='A'){
        list.add(1);
        continue ;
      }
      if(data[i]=='D'){
        list.add(2);
        continue ;
      }
      list.add(3);
    }
    long answer=0 ;
    int a=0 ;
    for(int x : list){
      if(x==1){
        a+=1 ;
        continue ;
      }
      if(x==2){
        answer+=a ;
        continue ;
      }
      if(x==3){
        a=0 ;
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var S : String ; S := scan.getCurrent() ;
    S := S.replaceAllMatches("BC", "D" ) ; 
    var data : Sequence(String) ; data := S->characters() ;
    var length : int ; length := data->size() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < length do ( (     if (data[i+1] = 'A') then (     list := list->including(1) ; 
     continue ) else skip ; 
     if (data[i+1] = 'D') then (     list := list->including(2) ; 
     continue ) else skip ; 
     list := list->including(3) )  ;     i := i + 1 ) ; 
    var answer : long ; answer := 0 ;
    var a : int ; a := 0 ;
    for (x : list) do ( (     if (x = 1) then (     a := a+(1) ; 
     continue ) else skip ; 
     if (x = 2) then (     answer := answer+(a) ; 
     continue ) else skip ; 
     if (x = 3) then (     a := 0 ) else skip )  ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minDiff(int arr[],int n,int k){
    int result=Integer.MAX_VALUE ;
    Arrays.sort(arr);
    for(int i=0 ; i<=n-k ; i++)result=Math.min(result,arr[i+k-1]-arr[i]);
    return result ;
  }
  public static void main(String[] args){
    int arr[]={
      10,100,300,200,1000,20,30 };
      int n=arr.length ;
      int k=3 ;
      System.out.println(minDiff(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minDiff( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 2147483647 ;
     arr := arr->sort() ; 
         var i : int ; i := 0 ; while i <= n - k do (     result := Set{result, arr[i + k - 1+1] - arr[i+1]}->min() ;  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,100,300,200,1000,20,30} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println(minDiff(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  int n ;
  int[] t=new int[10];
  Main(){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    while(n>0){
      n--;
      for(int i=0 ; i<10 ; i++){
        t[i]=sc.nextInt();
      }
      System.out.println(solve());
    }
  }
  String solve(){
    int L=0,R=0 ;
    for(int i=0 ; i<10 ; i++){
      if(L<t[i])L=t[i];
      else if(R<t[i])R=t[i];
      else return "NO" ;
    }
    return "YES" ;
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute t : Sequence(int) := Integer.subrange(1,10)->collect(0);
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
     while (n > 0) do (     n := n - 1 ; 
         var i : int ; i := 0 ; while i < 10 do ( (     t[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(solve()) ) );
   operation solve() : String
  pre: true
  post: true
  activity: (     var L : int ; L := 0 ;
    var R : int ; R := 0 ;
         var i : int ; i := 0 ; while i < 10 do ( (     if (L < t[i+1]) then     L := t[i+1] ; else     if (R < t[i+1]) then     R := t[i+1] else     return "NO" ;  )  ;     i := i + 1 ) ; 
     return "YES" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),v ;
    int[] dp=new int[5];
    for(int i=0 ; i<n ; i++){
      v=sc.nextInt();
      if(v==1){
        dp[1]++;
        dp[2]=Math.max(dp[1],dp[2]);
        dp[3]=Math.max(dp[2],dp[3]+1);
        dp[4]=Math.max(dp[3],dp[4]);
      }
      else {
        dp[2]=Math.max(dp[1],dp[2]+1);
        dp[3]=Math.max(dp[2],dp[3]);
        dp[4]=Math.max(dp[3],dp[4]+1);
      }
    }
    System.out.println(dp[4]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var v : int ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,5)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     v := sc.getCurrent()->toInteger() ; 
     if (v = 1) then (     dp[1+1] := dp[1+1] + 1 ; 
     dp[2+1] := Set{dp[1+1], dp[2+1]}->max() ; 
     dp[3+1] := Set{dp[2+1], dp[3+1] + 1}->max() ; 
     dp[4+1] := Set{dp[3+1], dp[4+1]}->max() ) else (     dp[2+1] := Set{dp[1+1], dp[2+1] + 1}->max() ; 
     dp[3+1] := Set{dp[2+1], dp[3+1]}->max() ; 
     dp[4+1] := Set{dp[3+1], dp[4+1] + 1}->max() ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[4+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int n ;
  static int count=0 ;
  static Pair pair ;
  static int num[][]=new int[100][10];
  public static void main(String[] args){
    read();
    pair=new Pair(0,0);
    for(int i=0 ; i<n ; i++){
      dfs(i,0);
    }
  }
  public static void read(){
    n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<10 ; j++){
        num[i][j]=sc.nextInt();
      }
    }
  }
  public static void dfs(int i,int j){
    if(count>=10){
      System.out.println("YES");
      init();
      return ;
    }
    count++;
    int nextNum=num[i][j];
    if(nextNum<pair.left && nextNum<pair.right){
      System.out.println("NO");
      init();
      return ;
    }
    if(nextNum>pair.left && nextNum>pair.right){
      if(nextNum-pair.left<=nextNum-pair.right){
        pair.left=nextNum ;
        dfs(i,++j);
        return ;
      }
      else {
        pair.right=nextNum ;
        dfs(i,++j);
        return ;
      }
    }
    if(nextNum<pair.left || nextNum<pair.right){
      if(nextNum>pair.left){
        pair.left=nextNum ;
        dfs(i,++j);
        return ;
      }
      else {
        pair.right=nextNum ;
        dfs(i,++j);
        return ;
      }
    }
  }
  public static void init(){
    count=0 ;
    pair.left=0 ;
    pair.right=0 ;
  }
}
class Pair {
  int left ;
  int right ;
  Pair(int a,int b){
    left=a ;
    right=b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   attribute count : int := 0;
  static   attribute pair : Map;
  static   attribute num : int := Integer.subrange(1,100)->collect(Integer.subrange(1,10)->collect(0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute read() ; 
     pair := Map(0, 0) ; 
         var i : int ; i := 0 ; while i < n do ( (     execute dfs(i, 0) )  ;     i := i + 1 ) );
  static   operation read() : void
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 10 do ( (     num[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation dfs( i : int, j : int) : void
  pre: true
  post: true
  activity: (     if (count >= 10) then (     OclFile["System.out"].println("YES") ; 
     execute init() ; 
     return ) else skip ; 
     count := count + 1 ; 
    var nextNum : int ; nextNum := num[i+1][j+1] ;
    if (nextNum < pair.left & nextNum < pair.right) then (     OclFile["System.out"].println("NO") ; 
     execute init() ; 
     return ) else skip ; 
    if (nextNum > pair.left & nextNum > pair.right) then (     if (nextNum - pair.left <= nextNum - pair.right) then (     pair.left := nextNum ; 
     execute dfs(i, (j + 1)) ; 
     return ) else (     pair.right := nextNum ; 
     execute dfs(i, (j + 1)) ; 
     return ) ) else skip ; 
    if (nextNum < pair.left or nextNum < pair.right) then (     if (nextNum > pair.left) then (     pair.left := nextNum ; 
     execute dfs(i, (j + 1)) ; 
     return ) else (     pair.right := nextNum ; 
     execute dfs(i, (j + 1)) ; 
     return ) ) else skip ; 
 );
  static   operation init() : void
  pre: true
  post: true
  activity: (     count := 0 ; 
     pair.left := 0 ; 
     pair.right := 0 );
}
class Pair {
   attribute left : int;
   attribute right : int;
   static operation newPair( a : int, b : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     left := a ; 
     right := b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
public class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String line ;
      br.readLine();
      while((line=br.readLine())!=null){
        if(line.equals(""))break ;
        String[] splited=line.split(" ");
        int[] ints=new int[10];
        for(int i=0 ; i<10 ; i++)ints[i]=Integer.parseInt(splited[i]);
        int tB=ints[0],tC=-1 ;
        boolean can=true ;
        for(int i=1 ; i<10 ; i++){
          if(tB>tC){
            if(ints[i]>tB){
              tB=ints[i];
              continue ;
            }
            if(ints[i]>tC){
              tC=ints[i];
              continue ;
            }
            can=false ;
            break ;
          }
          else {
            if(ints[i]>tC){
              tC=ints[i];
              continue ;
            }
            if(ints[i]>tB){
              tB=ints[i];
              continue ;
            }
            can=false ;
            break ;
          }
        }
        System.out.println((can)? "YES" : "NO");
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var line : String ;
     skip ; 
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line = "") then     break else skip ; 
     var splited : Sequence(String) ; splited := line->split(" ") ;
    var ints : Sequence(int) ; ints := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < 10 do (     ints[i+1] := (splited[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var tB : int ; tB := ints[0+1] ;
    var tC : int ; tC := -1 ;
    var can : boolean ; can := true ;
        var i : int ; i := 1 ; while i < 10 do ( (     if (tB > tC) then (     if (ints[i+1] > tB) then (     tB := ints[i+1] ; 
     continue ) else skip ; 
     if (ints[i+1] > tC) then (     tC := ints[i+1] ; 
     continue ) else skip ; 
     can := false ; 
     break ) else (     if (ints[i+1] > tC) then (     tC := ints[i+1] ; 
     continue ) else skip ; 
     if (ints[i+1] > tB) then (     tB := ints[i+1] ; 
     continue ) else skip ; 
     can := false ; 
     break ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if (can) then "YES" else "NO" endif) ; 
 ) ;     line := br.readLine() ;
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Deque ;
import java.util.LinkedList ;
import java.util.Scanner ;
class Main {
  static final String YES="YES" ;
  static final String NO="NO" ;
  public static void main(String[] args){
    Scanner sc=null ;
    try {
      sc=new Scanner(System.in);
      int countDataset=sc.nextInt();
      int[] ballNums=new int[10];
      for(int i=0 ; i<countDataset ; i++){
        for(int j=0 ; j<10 ; j++){
          ballNums[j]=sc.nextInt();
        }
        System.out.println(push(ballNums)? YES : NO);
      }
    }
    finally {
      sc.close();
    }
  }
  public static boolean push(int[] nums){
    Deque<Integer>list1=new LinkedList<Integer>();
    Deque<Integer>list2=new LinkedList<Integer>();
    list1.add(0);
    list2.add(0);
    for(int number : nums){
      if(list1.peek()<number){
        list1.push(number);
      }
      else if(list2.peek()<number){
        list2.push(number);
      }
      else {
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute YES : String := "YES";
  static    attribute NO : String := "NO";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := null ;
     try (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var countDataset : int ; countDataset := sc.getCurrent()->toInteger() ;
     var ballNums : Sequence(int) ; ballNums := Integer.subrange(1,10)->collect(0) ;
         var i : int ; i := 0 ; while i < countDataset do ( (         var j : int ; j := 0 ; while j < 10 do ( (     ballNums[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(if push(ballNums) then YES else NO endif) )  ;     i := i + 1 ) )   finally (     skip )
 );
  static   operation push( nums : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var list1 : Sequence(int) ; list1 := Sequence{} ;
     var list2 : Sequence(int) ; list2 := Sequence{} ;
    list1 := list1->including(0) ; 
    list2 := list2->including(0) ; 
    for (number : nums) do ( (     if (list1->min() < number) then (     list1 := list1->append(number) ) else     if (list2->min() < number) then (     list2 := list2->append(number) ) else (     return false ) ;  )  ) ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class hw13 {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    {
    }
    {
    }
    {
      StringBuilder sb=new StringBuilder(scan.next());
      StringBuilder output=new StringBuilder(sb);
      boolean hateA=true ;
      for(int i=0 ; i<output.length(); i++){
        if(output.charAt(i)=='a'){
          output.deleteCharAt(i);
          i--;
        }
      }
      if(output.length()>1 && output.length()% 2==0){
        if(! output.substring(0,output.length()/2).equals(output.substring(output.length()/2,output.length()))|| ! sb.substring(sb.length()-output.length()/2,sb.length()).equals(output.substring(output.length()/2,output.length()))){
          hateA=false ;
        }
        sb.delete(sb.length()-output.length()/2,sb.length());
      }
      else if(output.length()% 2==1){
        hateA=false ;
      }
      if(hateA){
        System.out.println(sb);
      }
      else {
        System.out.println(":(");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class hw13 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 skip 
 skip 
 (     var sb : String ; sb := StringLib.newString(scan.getCurrent()) ;
     var output : String ; output := StringLib.newString(sb) ;
    var hateA : boolean ; hateA := true ;
        var i : int ; i := 0 ; while i < output->size() do ( (     if (output->at(i+1) = 'a') then (     output := output->excludingAt(i+1) ; 
     i := i - 1 ) else skip )  ;     i := i + 1 ) ; 
    if (output->size() > 1 & output->size() mod 2 = 0) then (     if (not(output.subrange(0+1,output->size() / 2) = output.subrange(output->size() / 2+1,output->size())) or not(sb.subrange(sb->size() - output->size() / 2+1,sb->size()) = output.subrange(output->size() / 2+1,output->size()))) then (     hateA := false ) else skip ; 
     sb := sb->antirestrict( Integer.subrange(sb->size() - output->size() / 2+1,sb->size()) ) ) else     if (output->size() mod 2 = 1) then (     hateA := false ) else skip ; ;  
    if (hateA) then (     OclFile["System.out"].println(sb) ) else (     OclFile["System.out"].println(":(") ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  void run(){
    sc=new Scanner(System.in);
    int n=sc.nextInt();
    sc.nextLine();
    for(int k=0 ; k<n ; k++){
      String[] ss=sc.nextLine().split(" ");
      int[] a=new int[10];
      for(int i=0 ; i<10 ; i++)a[i]=Integer.parseInt(ss[i]);
      int x=0 ;
      for(int i=0 ; i<10 ; i++){
        if(a[i]>x){
          x=a[i];
          a[i]=-1 ;
        }
      }
      x=0 ;
      for(int i=0 ; i<10 ; i++){
        if(a[i]>x){
          x=a[i];
          a[i]=-1 ;
        }
      }
      boolean f=true ;
      for(int i=0 ; i<10 ; i++)if(a[i]!=-1){
        f=false ;
        break ;
      }
      println(f ? "YES" : "NO");
    }
    sc.close();
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
        var k : int ; k := 0 ; while k < n do ( (     var ss : Sequence(String) ; ss := sc.nextLine()->split(" ") ;
     var a : Sequence(int) ; a := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < 10 do (     a[i+1] := (ss[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < 10 do ( (     if (a[i+1] > x) then (     x := a[i+1] ; 
     a[i+1] := -1 ) else skip )  ;     i := i + 1 ) ; 
    x := 0 ; 
        var i : int ; i := 0 ; while i < 10 do ( (     if (a[i+1] > x) then (     x := a[i+1] ; 
     a[i+1] := -1 ) else skip )  ;     i := i + 1 ) ; 
    var f : boolean ; f := true ;
        var i : int ; i := 0 ; while i < 10 do (     if (a[i+1] /= -1) then (     f := false ; 
     break ) else skip ;  ;     i := i + 1 ) ; 
    execute println(if f then "YES" else "NO" endif) ; 
 )  ;     k := k + 1 ) ; 
    skip ; 
 );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    long[] times=new long[5];
    times[0]=sc.nextLong();
    times[1]=sc.nextLong();
    times[2]=sc.nextLong();
    times[3]=sc.nextLong();
    times[4]=sc.nextLong();
    int minNum=0 ;
    for(int i=1 ; i<5 ; i++){
      if(times[i]<times[minNum]){
        minNum=i ;
      }
    }
    double bottleNeck=(double)N/(double)times[minNum];
    bottleNeck=Math.ceil(bottleNeck);
    long bottleNeckl=(long)bottleNeck ;
    long t=bottleNeckl+4 ;
    System.out.println(t);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    var times : Sequence(long) ; times := Integer.subrange(1,5)->collect(0) ;
    times[0+1] := sc.getCurrent()->toLong() ; 
    times[1+1] := sc.getCurrent()->toLong() ; 
    times[2+1] := sc.getCurrent()->toLong() ; 
    times[3+1] := sc.getCurrent()->toLong() ; 
    times[4+1] := sc.getCurrent()->toLong() ; 
    var minNum : int ; minNum := 0 ;
        var i : int ; i := 1 ; while i < 5 do ( (     if (times[i+1] < times[minNum+1]) then (     minNum := i ) else skip )  ;     i := i + 1 ) ; 
    var bottleNeck : double ; bottleNeck := N->oclAsType(double) / times[minNum+1]->oclAsType(double) ;
    bottleNeck := (bottleNeck)->ceil() ; 
    var bottleNeckl : long ; bottleNeckl := bottleNeck->oclAsType(long) ;
    var t : long ; t := bottleNeckl + 4 ;
    OclFile["System.out"].println(t) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Queue ;
import java.util.Random ;
import java.util.Scanner ;
public class Main {
  private static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    long N=sc.nextLong();
    long min=0 ;
    for(int i=0 ; i<5 ; i++){
      if(i==0)min=sc.nextLong();
      else min=Math.min(min,sc.nextLong());
    }
    p((long)Math.ceil((double)N/min)+4);
  }
  static void p(String ans){
    System.out.println(ans);
  };
  static void p(int ans){
    System.out.println(ans);
  };
  static void p(){
    System.out.println();
  };
  static void p(long ans){
    System.out.println(ans);
  };
  static void p(double ans){
    System.out.println(ans);
  };
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := sc.getCurrent()->toLong() ;
     var min : long ; min := 0 ;
         var i : int ; i := 0 ; while i < 5 do ( (     if (i = 0) then     min := sc.getCurrent()->toLong() ; else     min := Set{min, sc.getCurrent()->toLong()}->min() ; )  ;     i := i + 1 ) ; 
     execute p((N->oclAsType(double) / min)->ceil()->oclAsType(long) + 4) );
  static   operation p( ans : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( ans : long) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : double) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.Scanner ;
import java.util.stream.LongStream ;
public class Main {
  static final PrintStream so=System.out ;
  static final Scanner sc=new Scanner(System.in);
  static final int INF=Integer.MAX_VALUE ;
  static int[] mh={
    0,1,0,-1 };
    static int[] mw={
      1,0,-1,0 };
      public static void main(String[] args){
        long N=nl();
        long[] p=new long[5];
        for(int i=0 ; i<5 ; i++){
          p[i]=nl();
        }
        long min=LongStream.of(p).min().getAsLong();
        so.println(5L+(N-1)/min);
      }
      static int ni(){
        return sc.nextInt();
      }
      static long nl(){
        return sc.nextLong();
      }
      static char[] nsToChars(){
        return sc.next().toCharArray();
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute so : OclFile := OclFile["System.out"];
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute INF : int := 2147483647;
  static   attribute mh : Sequence(int) := Sequence{0,1,0,-1};
  static   attribute mw : Sequence(int) := Sequence{1,0,-1,0};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := nl() ;
     var p : Sequence(long) ; p := Integer.subrange(1,5)->collect(0) ;
        var i : int ; i := 0 ; while i < 5 do ( (     p[i+1] := nl() )  ;     i := i + 1 ) ; 
    var min : long ; min := Sequence{p}.min().getAsLong() ;
    skip ; 
 );
  static   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
  static   operation nl() : long
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toLong() );
  static   operation nsToChars() : Sequence(String)
  pre: true
  post: true
  activity: (     return sc.getCurrent()->characters() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Solver {
  final long N ;
  final long[] W ;
  Solver(Scanner in){
    N=in.nextLong();
    W=new long[5];
    for(int i=0 ; i<W.length ; i++){
      W[i]=in.nextLong();
    }
  }
  void solve(){
    Arrays.sort(W);
    System.out.println((long)Math.ceil(N*1./W[0])+4);
  }
}
class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    new Solver(in).solve();
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solver {
   attribute N : long;
   attribute W : Sequence(long);
   static operation newSolver( in : OclFile) : Solver
  pre: true
  post: true
  activity:
  ( var self : Solver ;
    self := createSolver();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     N := in.nextLong() ; 
     W := Integer.subrange(1,5)->collect(0) ; 
         var i : int ; i := 0 ; while i < W->size() do ( (     W[i+1] := in.nextLong() )  ;     i := i + 1 ) );
   operation solve() : void
  pre: true
  post: true
  activity: (     W := W->sort() ; 
     OclFile["System.out"].println((N * 1. / W[0+1])->ceil()->oclAsType(long) + 4) );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Solver.newSolver(in).solve() ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static void myout(Object t){
    System.out.println(t);
  }
  static void myerr(Object t){
    System.err.println(t);
  }
  static String getStr(){
    return sc.next();
  }
  static int getInt(){
    return Integer.parseInt(getStr());
  }
  static long getLong(){
    return Long.parseLong(getStr());
  }
  static boolean hasNext(){
    return sc.hasNext();
  }
  static char[] mySplit(String str){
    return str.toCharArray();
  }
  public static void main(String[] args){
    long N=getLong();
    Long min=new Long("10000000000000007");
    while(hasNext()){
      min=Math.min(getLong(),min);
    }
    if(min>=N){
      myout(5);
    }
    else {
      long output=(N/min);
      if(N % min!=0){
        output++;
      }
      myout(output+4);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation myout( t : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(t) );
  static   operation myerr( t : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println(t) );
  static   operation getStr() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return (getStr())->toInteger() );
  static   operation getLong() : long
  pre: true
  post: true
  activity: (     return (getStr())->toLong() );
  static   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return sc.hasNext() );
  static   operation mySplit( str : String) : Sequence(String)
  pre: true
  post: true
  activity: (     return str->characters() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := getLong() ;
     var min : long ; min := ("" + ("10000000000000007"))->toLong() ;
     while (hasNext()) do (     min := Set{getLong(), min}->min() ) ; 
     if (min >= N) then (     execute myout(5) ) else (     var output : long ; output := (N / min) ;
     if (N mod min /= 0) then (     output := output + 1 ) else skip ; 
     execute myout(output + 4) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class problem1455b {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int x=sc.nextInt();
      int val=0 ;
      int turn=0 ;
      while(val<x){
        val+=turn+1 ;
        turn++;
      }
      if(val==x){
        System.out.println(turn);
      }
      else if(val==x+1){
        System.out.println(turn+1);
      }
      else {
        System.out.println(turn);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class problem1455b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var val : int ; val := 0 ;
    var turn : int ; turn := 0 ;
    while (val < x) do (     val := val+(turn + 1) ; 
     turn := turn + 1 ) ; 
    if (val = x) then (     OclFile["System.out"].println(turn) ) else     if (val = x + 1) then (     OclFile["System.out"].println(turn + 1) ) else (     OclFile["System.out"].println(turn) ) ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void count_even_odd(int min,int max,int steps[][]){
    int a,b,even,odd ;
    boolean beven=true,aeven=false ;
    int n=2 ;
    for(int i=0 ; i<n ; i++){
      a=steps[i][0];
      b=steps[i][1];
      if(!(aeven ||(a & 1)>0))aeven=true ;
      if(beven){
        if((b & 1)>0)beven=false ;
      }
      else if(!((a & 1)>0)){
        if(!((b & 1)>0))beven=true ;
      }
      else {
        if((b & 1)>0)beven=true ;
      }
    }
    if(beven){
      even=(int)max/2-(int)(min-1)/2 ;
      odd=0 ;
    }
    else {
      even=(int)max/2-(int)(min-1)/2 ;
      odd=0 ;
    }
    if(!(beven ^ aeven))even+=max-min+1-(int)max/2+(int)(min-1)/2 ;
    else odd+=max-min+1-(int)max/2+(int)(min-1)/2 ;
    System.out.print("even="+even+",odd="+odd);
  }
  public static void main(String[] args){
    int min=1,max=4 ;
    int steps[][]={
      {
        1,2 },{
          3,4 }
        };
        count_even_odd(min,max,steps);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count_even_odd( min : int, max : int, steps : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var a : int ;
    var b : int ;
    var even : int ;
    var odd : int ;
     var beven : boolean ; beven := true ;
    var aeven : boolean ; aeven := false ;
    var n : int ; n := 2 ;
        var i : int ; i := 0 ; while i < n do ( (     a := steps[i+1][0+1] ; 
     b := steps[i+1][1+1] ; 
     if (not((aeven or (MathLib.bitwiseAnd(a,1)) > 0))) then     aeven := true ; else skip ; 
     if (beven) then (     if ((MathLib.bitwiseAnd(b,1)) > 0) then     beven := false ; else skip ) else     if (not(((MathLib.bitwiseAnd(a,1)) > 0))) then (     if (not(((MathLib.bitwiseAnd(b,1)) > 0))) then     beven := true ; else skip ) else (     if ((MathLib.bitwiseAnd(b,1)) > 0) then     beven := true ; else skip ) ;  )  ;     i := i + 1 ) ; 
    if (beven) then (     even := max->oclAsType(int) / 2 - (min - 1)->oclAsType(int) / 2 ; 
     odd := 0 ) else (     even := max->oclAsType(int) / 2 - (min - 1)->oclAsType(int) / 2 ; 
     odd := 0 ) ;  
    if (not((MathLib.bitwiseXor(beven,aeven)))) then     even := even+(max - min + 1 - max->oclAsType(int) / 2 + (min - 1)->oclAsType(int) / 2) else     odd := odd+(max - min + 1 - max->oclAsType(int) / 2 + (min - 1)->oclAsType(int) / 2) ; ;  
    OclFile["System.out"].print("even=" + even + ",odd=" + odd) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var min : int ; min := 1 ;
    var max : int ; max := 4 ;
     var steps : Sequence(Sequence(int)) ; steps := Sequence{Sequence{1,2},Sequence{3,4}} ;
     execute count_even_odd(min, max, steps) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class b {
  static boolean debug=true ;
  static int offset,n ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int tt=0 ; tt<T ; tt++){
      int dest=in.nextInt();
      int sum=0 ;
      int toAdd=0 ;
      while(sum<dest){
        toAdd++;
        sum+=toAdd ;
      }
      if(sum!=dest+1){
        System.out.println(toAdd);
      }
      else {
        System.out.println(toAdd+1);
      }
    }
  }
  static boolean inBounds(int val){
    return(val>0-offset)&&(val+offset<n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class b {
  static   attribute debug : boolean := true;
  static   attribute offset : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var tt : int ; tt := 0 ; while tt < T do ( (     var dest : int ; dest := in.getCurrent()->toInteger() ;
     var sum : int ; sum := 0 ;
    var toAdd : int ; toAdd := 0 ;
    while (sum < dest) do (     toAdd := toAdd + 1 ; 
     sum := sum+(toAdd) ) ; 
    if (sum /= dest + 1) then (     OclFile["System.out"].println(toAdd) ) else (     OclFile["System.out"].println(toAdd + 1) ) ;  
 )  ;     tt := tt + 1 ) );
  static   operation inBounds( val : int) : boolean
  pre: true
  post: true
  activity: (     return (val > 0 - offset) & (val + offset < n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Jumps {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(reader.readLine());
    while(t>0){
      int x=Integer.parseInt(reader.readLine());
      int n=search(x<<1);
      long pos=(n*(n+1))/2L ;
      if(x==pos)System.out.println(n);
      else {
        if(x<pos-1)System.out.println(n);
        else System.out.println(n+1);
      }
      t--;
    }
  }
  private static int search(int target){
    int left=1,right=target ;
    while(left<=right){
      int mid=left+(right-left)/2 ;
      long value=1L*mid*(mid+1),valueOfLeft=1L*(mid-1)*mid ;
      if(value>=target &&(mid==1 || valueOfLeft<target))return mid ;
      else if(valueOfLeft>=target)right=mid-1 ;
      else left=mid+1 ;
    }
    return 0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Jumps {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (reader.readLine())->toInteger() ;
     while (t > 0) do (     var x : int ; x := (reader.readLine())->toInteger() ;
     var n : int ; n := search((x*(2->pow(1)))->oclAsType(long)) ;
    var pos : long ; pos := (n * (n + 1)) / 2L ;
    if (x = pos) then     OclFile["System.out"].println(n) else (     if (x < pos - 1) then     OclFile["System.out"].println(n) ; else     OclFile["System.out"].println(n + 1) ; ) ;  
    t := t - 1 ; 
 ) );
  static   operation search( target : int) : int
  pre: true
  post: true
  activity: (     var left : int ; left := 1 ;
    var right : int ; right := target ;
     while (left <= right) do (     var mid : int ; mid := left + (right - left) / 2 ;
     var value : long ; value := 1L * mid * (mid + 1) ;
    var valueOfLeft : long ; valueOfLeft := 1L * (mid - 1) * mid ;
     if (value >= target & (mid = 1 or valueOfLeft < target)) then     return mid else     if (valueOfLeft >= target) then     right := mid - 1 else     left := mid + 1 ; ;  ) ; 
     return 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class voting {
  public static void main(String args[]){
    FScanner in=new FScanner();
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt();
    int ans=0,max=0 ;
    int a[]=new int[1000001];
    for(int i=0 ; i<n ; i++){
      int b=in.nextInt();
      a[b]++;
      if(a[b]>max){
        max=a[b];
        ans=b ;
      }
    }
    out.print(ans);
    out.close();
  }
  static class FScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer sb=new StringTokenizer("");
    String next(){
      while(! sb.hasMoreTokens()){
        try {
          sb=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
        }
      }
      return sb.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class voting {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FScanner ; in := FScanner.newFScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.nextInt() ;
    var ans : int ; ans := 0 ;
    var max : int ; max := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,1000001)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var b : int ; b := in.nextInt() ;
     a[b+1] := a[b+1] + 1 ; 
     if (a[b+1] > max) then (     max := a[b+1] ; 
     ans := b ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute sb : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(sb.hasNext())) do (     try (     sb := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ) ; 
     return sb.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Jumps {
  public static void solve(int x){
    int num=(int)Math.ceil((Math.sqrt(1+(4*2*x))-1)/2);
    long s=(num*(num+1))/2 ;
    if(s-x!=1){
      System.out.println(num);
    }
    else {
      System.out.println(num+1);
    }
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      int x=in.nextInt();
      solve(x);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Jumps {
  static   operation solve( x : int) : void
  pre: true
  post: true
  activity: (     var num : int ; num := (((1 + (4 * 2 * x))->sqrt() - 1) / 2)->ceil()->oclAsType(int) ;
     var s : long ; s := (num * (num + 1)) / 2 ;
     if (s - x /= 1) then (     OclFile["System.out"].println(num) ) else (     OclFile["System.out"].println(num + 1) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     execute solve(x) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float Mean(float arr[],int n){
    float sum=0 ;
    for(int i=0 ; i<n ; i++)sum=sum+arr[i];
    return sum/n ;
  }
  static float meanAbsDevtion(float arr[],int n){
    float absSum=0 ;
    for(int i=0 ; i<n ; i++)absSum=absSum+Math.abs(arr[i]-Mean(arr,n));
    return absSum/n ;
  }
  public static void main(String[] args){
    float arr[]={
      10,15,15,17,18,21 };
      int n=arr.length ;
      System.out.println(meanAbsDevtion(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Mean( arr : Sequence(double), n : int) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum + arr[i+1] ;  ;     i := i + 1 ) ; 
     return sum / n );
  static   operation meanAbsDevtion( arr : Sequence(double), n : int) : double
  pre: true
  post: true
  activity: (     var absSum : double ; absSum := 0 ;
         var i : int ; i := 0 ; while i < n do (     absSum := absSum + if arr[i+1] - Mean(arr, n) < 0 then -(arr[i+1] - Mean(arr, n)) else arr[i+1] - Mean(arr, n) endif ;  ;     i := i + 1 ) ; 
     return absSum / n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(double) ; arr := Sequence{10,15,15,17,18,21} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(meanAbsDevtion(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p204 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p204().run());
  }
  public String run(){
    return Integer.toString(count(0,1));
  }
  private static long LIMIT=Library.pow(10,9);
  private int[] primes=Library.listPrimes(100);
  private int count(int primeIndex,long product){
    if(primeIndex==primes.length)return product<=LIMIT ? 1 : 0 ;
    else {
      int count=0 ;
      while(product<=LIMIT){
        count+=count(primeIndex+1,product);
        product*=primes[primeIndex];
      }
      return count ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class p204 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p204.newp204().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     return ((count(0, 1)) + "") );
  static   attribute LIMIT : long := Library.pow(10, 9);
   attribute primes : Sequence(int) := Library.listPrimes(100);
   operation count( primeIndex : int, product : long) : int
  pre: true
  post: true
  activity: (     if (primeIndex = primes->size()) then     return if product <= LIMIT then 1 else 0 endif else (     var count : int ; count := 0 ;
     while (product <= LIMIT) do (     count := count+(count(primeIndex + 1, product)) ; 
     product := product*(primes[primeIndex+1]) ) ; 
     return count ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int maximumXOR(int n,int l,int r){
    int x=0 ;
    for(int i=(int)(Math.log(r)/Math.log(2)); i>=0 ; --i){
      if((n &(1<<i))>0){
        if((x>r)||(x+(1<<i)-1<l))x ^=(1<<i);
      }
      else {
        if((x ^(1<<i))<=r)x ^=(1<<i);
      }
    }
    return n ^ x ;
  }
  public static void main(String args[]){
    int n=7,l=2,r=23 ;
    System.out.println("The output is "+maximumXOR(n,l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maximumXOR( n : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := 0 ;
         var i : int ; i := ((r)->log() / (2)->log())->oclAsType(int) ; while i >= 0 do ( (     if ((n & ((1*(2->pow(i)))->oclAsType(long))) > 0) then (     if ((x > r) or (x + ((1*(2->pow(i)))->oclAsType(long)) - 1 < l)) then     x := MathLib.bitwiseXor(x,((1*(2->pow(i)))->oclAsType(long))) ; else skip ) else (     if ((MathLib.bitwiseXor(x,((1*(2->pow(i)))->oclAsType(long)))) <= r) then     x := MathLib.bitwiseXor(x,((1*(2->pow(i)))->oclAsType(long))) ; else skip ) )  ;     i := i - 1 ) ; 
     return n xor x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
    var l : int ; l := 2 ;
    var r : int ; r := 23 ;
     OclFile["System.out"].println("The output is " + maximumXOR(n, l, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector ;
public class GFG {
  static int maxPrimefactorNum(int N){
    boolean arr[]=new boolean[N+5];
    for(int i=3 ; i*i<=N ; i+=2){
      if(! arr[i]){
        for(int j=i*i ; j<=N ; j+=i){
          arr[j]=true ;
        }
      }
    }
    Vector<Integer>prime=new Vector<>();
    prime.add(prime.size(),2);
    for(int i=3 ; i<=N ; i+=2){
      if(! arr[i]){
        prime.add(prime.size(),i);
      }
    }
    int i=0,ans=1 ;
    while(ans*prime.get(i)<=N && i<prime.size()){
      ans*=prime.get(i);
      i++;
    }
    return ans ;
  }
  public static void main(String[] args){
    int N=40 ;
    System.out.println(maxPrimefactorNum(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxPrimefactorNum( N : int) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(boolean) ; arr := Integer.subrange(1,N + 5)->collect(false) ;
         var i : int ; i := 3 ; while i * i <= N do ( (     if (not(arr[i+1])) then (         var j : int ; j := i * i ; while j <= N do ( (     arr[j+1] := true )  ;     j := j+(i) ) ) else skip )  ;     i := i+(2) ) ; 
    var prime : Sequence(int) ; prime := Sequence{} ;
    prime := prime.insertAt(prime->size()+1,2) ; 
        var i : int ; i := 3 ; while i <= N do ( (     if (not(arr[i+1])) then (     prime := prime.insertAt(prime->size()+1,i) ) else skip )  ;     i := i+(2) ) ; 
    var i : int ; i := 0 ;
    var ans : int ; ans := 1 ;
    while (ans * prime->at(i+1) <= N & i < prime->size()) do (     ans := ans*(prime->at(i+1)) ; 
     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 40 ;
     OclFile["System.out"].println(maxPrimefactorNum(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int CountTrailingZeros(int n){
    String bit=Integer.toBinaryString(n);
    StringBuilder bit1=new StringBuilder();
    bit1.append(bit);
    bit1=bit1.reverse();
    int zero=0 ;
    for(int i=0 ; i<64 ; i++){
      if(bit1.charAt(i)=='0')zero++;
      else break ;
    }
    return zero ;
  }
  public static void main(String[] args){
    int n=4 ;
    int ans=CountTrailingZeros(n);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation CountTrailingZeros( n : int) : int
  pre: true
  post: true
  activity: (     var bit : String ; bit := (MathLib.decimal2binary(n) + "") ;
     var bit1 : String ; bit1 := StringLib.newString() ;
    bit1 := bit1 + StringLib.newString(bit) ; 
    bit1 := bit1->reverse() ;     bit1 := bit1->reverse() ; 
    var zero : int ; zero := 0 ;
        var i : int ; i := 0 ; while i < 64 do ( (     if (bit1->at(i+1) = '0') then     zero := zero + 1 ; else     break )  ;     i := i + 1 ) ; 
    return zero 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var ans : int ; ans := CountTrailingZeros(n) ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    int N=S.length();
    int[] mod_arr=new int[N];
    int[] mod_cnt=new int[2019];
    int radix=1 ;
    for(int i=0 ; i<N ; i++){
      int tmp=((int)S.charAt(N-1-i)-(int)'0')*radix % 2019 ;
      if(i!=0)tmp=(tmp+mod_arr[i-1])% 2019 ;
      mod_arr[i]=tmp ;
      mod_cnt[tmp]++;
      radix=radix*10 % 2019 ;
    }
    long ans=0L ;
    mod_cnt[0]++;
    for(int i=0 ; i<2019 ; i++){
      ans+=mod_cnt[i]*(mod_cnt[i]-1)/2 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    var N : int ; N := S->size() ;
    var mod_arr : Sequence(int) ; mod_arr := Integer.subrange(1,N)->collect(0) ;
    var mod_cnt : Sequence(int) ; mod_cnt := Integer.subrange(1,2019)->collect(0) ;
    var radix : int ; radix := 1 ;
        var i : int ; i := 0 ; while i < N do ( (     var tmp : int ; tmp := (S->at((N)->char2byte() - 1 - i+1)->oclAsType(int) - ('0')->char2byte()) * radix mod 2019 ;
     if (i /= 0) then     tmp := (tmp + mod_arr[i - 1+1]) mod 2019 ; else skip ; 
    mod_arr[i+1] := tmp ; 
    mod_cnt[tmp+1] := mod_cnt[tmp+1] + 1 ; 
    radix := radix * 10 mod 2019 ; 
 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0L ;
    mod_cnt[0+1] := mod_cnt[0+1] + 1 ; 
        var i : int ; i := 0 ; while i < 2019 do ( (     ans := ans+(mod_cnt[i+1] * (mod_cnt[i+1] - 1) / 2) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    Integer max_len=s.length();
    int[] n_mod=new int[max_len+1];
    int[] map2019=new int[2019];
    int pow=1 ;
    for(int i=max_len-1 ; i>=0 ; i--){
      Integer num=Integer.valueOf(s.substring(i,i+1));
      Integer tmp=(num*pow+n_mod[i+1])% 2019 ;
      n_mod[i]=tmp ;
      map2019[tmp]+=1 ;
      pow*=10 ;
      pow %=2019 ;
    }
    Long count=(long)map2019[0];
    for(int i=0 ; i<2019 ; i++){
      Integer num=map2019[i];
      if(num<2)continue ;
      count+=num*(num-1)/2 ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var max_len : int ; max_len := s->size() ;
    var n_mod : Sequence(int) ; n_mod := Integer.subrange(1,max_len + 1)->collect(0) ;
    var map2019 : Sequence(int) ; map2019 := Integer.subrange(1,2019)->collect(0) ;
    var pow : int ; pow := 1 ;
        var i : int ; i := (max_len)->char2byte() - 1 ; while i >= 0 do ( (     var num : int ; num := (s.subrange(i+1,i + 1))->toInteger() ;
     var tmp : int ; tmp := (num * pow + n_mod[i + 1+1]) mod 2019 ;
    n_mod[i+1] := tmp ; 
    map2019[tmp+1] := map2019[tmp+1]+(1) ; 
    pow := pow*(10) ; 
    pow := pow mod 2019 ; 
 )  ;     i := i - 1 ) ; 
    var count : long ; count := map2019[0+1]->oclAsType(long) ;
        var i : int ; i := 0 ; while i < 2019 do ( (     var num : int ; num := map2019[i+1] ;
     if (num < 2) then     continue else skip ; 
     count := count+(num * (num - 1) / 2) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.StringTokenizer ;
public class R765A {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int t=Integer.parseInt(st.nextToken());
    while(t-->0){
      st=new StringTokenizer(br.readLine());
      int n=Integer.parseInt(st.nextToken());
      int[] arr=new int[n];
      st=new StringTokenizer(br.readLine());
      for(int i=0 ; i<n ; i++){
        arr[i]=Integer.parseInt(st.nextToken());
      }
      solve(arr);
    }
  }
  static class Diff {
    int prev ;
  }
  private static void solve(int[] arr){
    int max=-1 ;
    Map<Integer,Diff>map=new HashMap<>();
    for(int i=0 ; i<arr.length ; i++){
      if(map.containsKey(arr[i])){
        Diff diff=map.get(arr[i]);
        int prev=diff.prev ;
        int count=prev+arr.length-i ;
        if(count>max){
          max=count ;
        }
        diff.prev=i ;
      }
      else {
        Diff diff=new Diff();
        diff.prev=i ;
        map.put(arr[i],diff);
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class R765A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var t : int ; t := (st.next())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var n : int ; n := (st.next())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    execute solve(arr) ; 
 ) ;  ) );
  static class Diff {
   attribute prev : int;
}
  static   operation solve( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var max : int ; max := -1 ;
     var map : Map(int,Diff) ; map := Map{} ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     if (map->keys()->includes(arr[i+1])) then (     var diff : Diff ; diff := map->at(arr[i+1]) ;
     var prev : int ; prev := diff.prev ;
    var count : int ; count := prev + arr->size() - i ;
    if (count > max) then (     max := count ) else skip ; 
    diff.prev := i ; 
 ) else (     var diff : Diff ; diff := Diff.newDiff() ;
     diff.prev := i ; 
     map := map->union(Map{arr[i+1] |-> diff}) ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(max) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class JohnyLikesNumbers {
  public static void main(String[] args){
    java.util.Scanner input=new java.util.Scanner(System.in);
    int n=input.nextInt(),k=input.nextInt();
    ;
    System.out.println((n/k+1)*k);
  }
}
------------------------------------------------------------
OCL File:
---------
class JohnyLikesNumbers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : Scanner ; input := Scanner.newScanner(OclFile["System.in"]) ;
     var n : int ; n := input.nextInt() ;
    var k : int ; k := input.nextInt() ;
     OclFile["System.out"].println((n / k + 1) * k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Quiz {
  Scanner in=new Scanner(System.in);
  public void run(){
    int n ;
    int[] arr=new int[1001];
    int[] arr2=new int[1000001];
    n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
      arr2[arr[i] ]++;
    }
    int b=0 ;
    for(int j=0 ; j<n ; j++){
      if(arr2[arr[j] ]>b)b=arr2[arr[j] ];
    }
    for(int i=0 ; i<arr2.length ; i++){
      arr2[i]=0 ;
    }
    for(int i=0 ; i<n ; i++){
      arr2[arr[i] ]++;
      if(arr2[arr[i] ]==b){
        System.out.println(arr[i]);
        break ;
      }
    }
  }
  public static void main(String[] args){
    Quiz a=new Quiz();
    a.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Quiz {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,1001)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,1000001)->collect(0) ;
    n := in.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() ; 
     arr2[arr[i+1]+1] := arr2[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var b : int ; b := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     if (arr2[arr[j+1]+1] > b) then     b := arr2[arr[j+1]+1] ; else skip )  ;     j := j + 1 ) ; 
        var i : int ; i := 0 ; while i < arr2->size() do ( (     arr2[i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr2[arr[i+1]+1] := arr2[arr[i+1]+1] + 1 ; 
     if (arr2[arr[i+1]+1] = b) then (     OclFile["System.out"].println(arr[i+1]) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Quiz ; a := Quiz.newQuiz() ;
     a.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
class Main {
  public static void main(final String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    StringBuffer str=new StringBuffer(s);
    String r=str.reverse().toString();
    int size=r.length();
    int ans=0 ;
    int[] count=new int[2019];
    BigInteger total=BigInteger.ZERO ;
    BigInteger mod=new BigInteger("2019");
    BigInteger exp=BigInteger.ONE ;
    for(int i=0 ; i<size ; i++){
      count[total.intValue()]++;
      total=total.add(new BigInteger(r.substring(i,i+1)).multiply(exp)).remainder(mod);
      ans+=count[total.intValue()];
      exp=exp.multiply(BigInteger.TEN).remainder(mod);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var str : String ; str := StringLib.newString(s) ;
    var r : String ; r := str->reverse()+"" ;
    var size : int ; size := r->size() ;
    var ans : int ; ans := 0 ;
    var count : Sequence(int) ; count := Integer.subrange(1,2019)->collect(0) ;
    var total : long ; total := 0 ;
    var mod : long ; mod := long("2019") ;
    var exp : long ; exp := 1 ;
        var i : int ; i := 0 ; while i < size do ( (     count[total->oclAsType(int)+1] := count[total->oclAsType(int)+1] + 1 ; 
     total := total->excludes(long(r.subrange(i+1,i + 1)).multiply(exp)).remainder(mod) ; 
     ans := ans+(count[total->oclAsType(int)+1]) ; 
     exp := exp.multiply(10).remainder(mod) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Collection<Integer>generateModulusArray(String word){
    HashMap<Integer,Integer>seen=new HashMap<>();
    seen.put(0,1);
    int prevMod=0 ;
    int tensMod=1 ;
    for(int i=word.length()-1 ; i>=0 ; i--){
      prevMod=(tensMod*(word.charAt(i)-'0')+prevMod)% 2019 ;
      seen.merge(prevMod,1,Integer :: sum);
      tensMod=(tensMod*10)% 2019 ;
    }
    return seen.values();
  }
  public static void main(String[] args){
    int result=0 ;
    Scanner sc=new Scanner(System.in);
    String word=sc.next();
    Collection<Integer>reps=generateModulusArray(word);
    for(Integer r : reps)result+=(r*(r-1))/2 ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation generateModulusArray( word : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var seen : Map(int,int) ; seen := Map{} ;
     seen := seen->union(Map{0 |-> 1}) ; 
    var prevMod : int ; prevMod := 0 ;
    var tensMod : int ; tensMod := 1 ;
        var i : int ; i := word->size() - 1 ; while i >= 0 do ( (     prevMod := (tensMod * (word->at(i+1) - ('0')->char2byte()) + prevMod) mod 2019 ; 
     seen := seen.merge(prevMod, 1, lambda _pars : OclAny in Integer.newInteger().sum(_pars)) ; 
     tensMod := (tensMod * 10) mod 2019 )  ;     i := i - 1 ) ; 
    return seen->values() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var word : String ; word := sc.getCurrent() ;
    var reps : Sequence(int) ; reps := generateModulusArray(word) ;
    for (r : reps) do (     result := result+((r * (r - 1)) / 2) ;  ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    char[] s=sc.next().toCharArray();
    sc.close();
    int m=2019 ;
    Map<Integer,Integer>map=new HashMap<>();
    addCntMap(map,0);
    long ans=0 ;
    int now=0 ;
    int n=s.length ;
    for(int i=n-1 ; i>=0 ; i--){
      int d=s[i]-'0' ;
      d*=power(10,n-1-i,m);
      now+=d ;
      now %=2019 ;
      ans+=ntz(map.get(now));
      addCntMap(map,now);
    }
    System.out.println(ans);
  }
  static int power(int x,int n,int m){
    if(n==0){
      return 1 ;
    }
    int val=power(x,n/2,m);
    val=val*val % m ;
    if(n % 2==1){
      val=val*x % m ;
    }
    return val ;
  }
  static int ntz(Integer v){
    return v==null ? 0 : v ;
  }
  static void addCntMap(Map<Integer,Integer>map,Integer key){
    if(map.containsKey(key)){
      map.put(key,map.get(key)+1);
    }
    else {
      map.put(key,1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    skip ; 
    var m : int ; m := 2019 ;
    var map : Map(int,int) ; map := Map{} ;
    execute addCntMap(map, 0) ; 
    var ans : long ; ans := 0 ;
    var now : int ; now := 0 ;
    var n : int ; n := s->size() ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     var d : int ; d := s[i+1] - ('0')->char2byte() ;
     d := d*(power(10, n - 1 - i, m)) ; 
    now := now+(d) ; 
    now := now mod 2019 ; 
    ans := ans+(ntz(map->at(now))) ; 
    execute addCntMap(map, now) ; 
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation power( x : int, n : int, m : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then (     return 1 ) else skip ; 
     var val : int ; val := power(x, n / 2, m) ;
    val := val * val mod m ; 
    if (n mod 2 = 1) then (     val := val * x mod m ) else skip ; 
    return val 
 );
  static   operation ntz( v : int) : int
  pre: true
  post: true
  activity: (     return if v = null then 0 else v endif );
  static   operation addCntMap( map : Map(int,int), key : int) : void
  pre: true
  post: true
  activity: (     if (map->keys()->includes(key)) then (     map := map->union(Map{key |-> map->at(key) + 1}) ) else (     map := map->union(Map{key |-> 1}) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Shopping {
  public void input(int numberOne,int numberTwo,int numberThree){
    int one=numberOne+numberTwo+numberThree ;
    int two=2*(numberOne+numberTwo);
    int three=2*(numberOne+numberThree);
    int four=2*(numberTwo+numberThree);
    System.out.println(java.lang.Math.min(java.lang.Math.min(one,two),java.lang.Math.min(three,four)));
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    Shopping instance=new Shopping();
    int numOne=input.nextInt();
    int numTwo=input.nextInt();
    int numThree=input.nextInt();
    instance.input(numOne,numTwo,numThree);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Shopping {
   operation input( numberOne : int, numberTwo : int, numberThree : int) : void
  pre: true
  post: true
  activity: (     var one : int ; one := numberOne + numberTwo + numberThree ;
     var two : int ; two := 2 * (numberOne + numberTwo) ;
    var three : int ; three := 2 * (numberOne + numberThree) ;
    var four : int ; four := 2 * (numberTwo + numberThree) ;
    OclFile["System.out"].println(java.lang.Math->min()) ; 
 );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var instance : Shopping ; instance := Shopping.newShopping() ;
    var numOne : int ; numOne := input.getCurrent()->toInteger() ;
    var numTwo : int ; numTwo := input.getCurrent()->toInteger() ;
    var numThree : int ; numThree := input.getCurrent()->toInteger() ;
    instance.input(numOne, numTwo, numThree) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PatrickAndShopping {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int d1=input.nextInt();
    int d2=input.nextInt();
    int d3=input.nextInt();
    if(d1+d3<d2){
      System.out.println(2*(d1+d3));
    }
    else if(d2+d3<d1){
      System.out.println(2*(d2+d3));
    }
    else if(d1+d2<d3){
      System.out.println(2*(d1+d2));
    }
    else if(d1+d2>d3){
      System.out.println(d1+d2+d3);
    }
    else {
      System.out.println(d1+d2+d3);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PatrickAndShopping {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d1 : int ; d1 := input.getCurrent()->toInteger() ;
    var d2 : int ; d2 := input.getCurrent()->toInteger() ;
    var d3 : int ; d3 := input.getCurrent()->toInteger() ;
    if (d1 + d3 < d2) then (     OclFile["System.out"].println(2 * (d1 + d3)) ) else     if (d2 + d3 < d1) then (     OclFile["System.out"].println(2 * (d2 + d3)) ) else     if (d1 + d2 < d3) then (     OclFile["System.out"].println(2 * (d1 + d2)) ) else     if (d1 + d2 > d3) then (     OclFile["System.out"].println(d1 + d2 + d3) ) else (     OclFile["System.out"].println(d1 + d2 + d3) ) ;  ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication85 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num1=sc.nextInt();
    int num2=sc.nextInt();
    int num3=sc.nextInt();
    System.out.println(Math.min(Math.min(num1+num3+num3+num1,num2+num2+num3+num3),Math.min((num1+num2+num1+num2),(num1+num2+num3))));
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication85 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num1 : int ; num1 := sc.getCurrent()->toInteger() ;
    var num2 : int ; num2 := sc.getCurrent()->toInteger() ;
    var num3 : int ; num3 := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(Set{Set{num1 + num3 + num3 + num1, num2 + num2 + num3 + num3}->min(), Set{(num1 + num2 + num1 + num2), (num1 + num2 + num3)}->min()}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
import static java.lang.Double.parseDouble ;
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
public class Main {
  static BufferedWriter of=null ;
  static {
    try {
      of=new BufferedWriter(new FileWriter(new File("filee.txt")));
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  private static BufferedWriter ifile=null ;
  static {
    try {
      ifile=new BufferedWriter(new FileWriter(String.valueOf(System.in)));
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  private static final BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
  private static final Fast in=new Fast();
  public static void main(String[] args)throws IOException {
    int n1=in.nextInt();
    int n2=in.nextInt();
    int n3=in.nextInt();
    System.out.println(Math.min(n1,n2+n3)+Math.min(n2,n1+n3)+Math.min(n3,n1+n2));
  }
  public static class Fast {
    BufferedReader br ;
    StringTokenizer st ;
    public Fast(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public Fast(FileReader f){
      br=new BufferedReader(f);
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return parseInt(next());
    }
    public long nextLong()throws IOException {
      return parseLong(next());
    }
    public double nextDouble()throws IOException {
      return parseDouble(next());
    }
    public float nextFloat()throws IOException {
      return Float.parseFloat(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute of : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     try (     of := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile("filee.txt"))) )   catch (e : IOException) do (     e.printStackTrace() )
;
  static   attribute ifile : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     try (     ifile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(((OclFile["System.in"]) + ""))) )   catch (e : IOException) do (     e.printStackTrace() )
;
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static    attribute in : Fast := Fast.newFast();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n1 : int ; n1 := in.nextInt() ;
     var n2 : int ; n2 := in.nextInt() ;
     var n3 : int ; n3 := in.nextInt() ;
     OclFile["System.out"].println(Set{n1, n2 + n3}->min() + Set{n2, n1 + n3}->min() + Set{n3, n1 + n2}->min()) );
  static class Fast {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFast() : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   static operation newFast( f : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(f) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next() + "")->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return parseDouble(next()) );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test252 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    int b=in.nextInt();
    int c=in.nextInt();
    if(a>b){
      if(c>a+b){
        System.out.println(2*a+2*b);
      }
      else if(c<a){
        System.out.println(2*b+2*c);
      }
      else {
        System.out.println((c+a+b));
      }
    }
    else {
      if(c>a+b){
        System.out.println(2*a+2*b);
      }
      else if(c<b){
        System.out.println(2*a+2*c);
      }
      else {
        System.out.println((a+b+c));
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test252 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    if (a > b) then (     if (c > a + b) then (     OclFile["System.out"].println(2 * a + 2 * b) ) else     if (c < a) then (     OclFile["System.out"].println(2 * b + 2 * c) ) else (     OclFile["System.out"].println((c + a + b)) ) ;  ) else (     if (c > a + b) then (     OclFile["System.out"].println(2 * a + 2 * b) ) else     if (c < b) then (     OclFile["System.out"].println(2 * a + 2 * c) ) else (     OclFile["System.out"].println((a + b + c)) ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  final int MOD=1000000007 ;
  void doIt(){
    int n=sc.nextInt();
    UnionFindTree utf=new UnionFindTree(n);
    int m=sc.nextInt();
    for(int i=0 ; i<m ; i++){
      int x=sc.nextInt()-1 ;
      int y=sc.nextInt()-1 ;
      int z=sc.nextInt();
      utf.unite(x,y);
    }
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      if(utf.par[i]==i){
        cnt++;
      }
    }
    System.out.println(cnt);
  }
  class UnionFindTree {
    int n ;
    int[] par ;
    int[] rank ;
    UnionFindTree(int n){
      this.n=n ;
      par=new int[n];
      rank=new int[n];
      for(int i=0 ; i<n ; i++){
        par[i]=i ;
        rank[i]=0 ;
      }
    }
    int find(int x){
      if(par[x]==x){
        return x ;
      }
      else {
        return par[x]=find(par[x]);
      }
    }
    void unite(int x,int y){
      x=find(x);
      y=find(y);
      if(x==y)return ;
      if(rank[x]<rank[y])par[x]=y ;
      else {
        par[y]=x ;
        if(rank[x]==rank[y])rank[x]++;
      }
    }
    boolean same(int x,int y){
      return find(x)==find(y);
    }
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute MOD : int := 1000000007;
   operation doIt() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var utf : UnionFindTree ; utf := UnionFindTree.newUnionFindTree(n) ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
     var y : int ; y := sc.getCurrent()->toInteger() - 1 ;
     var z : int ; z := sc.getCurrent()->toInteger() ;
     utf.unite(x, y) )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (utf.par[i+1] = i) then (     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
 class UnionFindTree {
   attribute n : int;
   attribute par : Sequence(int);
   attribute rank : Sequence(int);
   static operation newUnionFindTree( n : int) : UnionFindTree
  pre: true
  post: true
  activity:
  ( var self : UnionFindTree ;
    self := createUnionFindTree();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     self.n := n ; 
     par := Integer.subrange(1,n)->collect(0) ; 
     rank := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do ( (     par[i+1] := i ; 
     rank[i+1] := 0 )  ;     i := i + 1 ) );
   operation find( x : int) : int
  pre: true
  post: true
  activity: (     if (par[x+1] = x) then (     return x ) else (     return par[x+1] ) );
   operation unite( x : int, y : int) : void
  pre: true
  post: true
  activity: (     x := find(x) ; 
     y := find(y) ; 
     if (x = y) then     return else skip ; 
     if (rank[x+1] < rank[y+1]) then     par[x+1] := y ; else (     par[y+1] := x ; 
     if (rank[x+1] = rank[y+1]) then     rank[x+1] := rank[x+1] + 1 ; else skip ) );
   operation same( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return find(x) = find(y) );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer in=new StringTokenizer(br.readLine());
    int N=Integer.parseInt(in.nextToken());
    int M=Integer.parseInt(in.nextToken());
    in=null ;
    int[] arr=new int[N+1];
    HashSet<Integer>rootNodes=new HashSet<Integer>();
    for(int i=0 ; i<M ; i++){
      in=new StringTokenizer(br.readLine());
      int x=Integer.parseInt(in.nextToken());
      int y=Integer.parseInt(in.nextToken());
      in=null ;
      union(arr,x,y);
    }
    br=null ;
    for(int i=1 ; i<=N ; i++){
      rootNodes.add(find(arr,i));
    }
    System.out.print(rootNodes.size());
  }
  static int find(int[] parent,int i){
    while(parent[i]!=0){
      i=parent[i];
    }
    return i ;
  }
  static void union(int[] parent,int x,int y){
    int xset=find(parent,x);
    int yset=find(parent,y);
    if(xset!=yset){
      if(xset<=yset){
        parent[xset]=yset ;
      }
      else {
        parent[yset]=xset ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var in : OclIterator ; in := OclIterator.newOclIterator_String(br.readLine()) ;
    var N : int ; N := (in.next())->toInteger() ;
    var M : int ; M := (in.next())->toInteger() ;
    in := null ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,N + 1)->collect(0) ;
    var rootNodes : Set(int) ; rootNodes := Set{} ;
        var i : int ; i := 0 ; while i < M do ( (     in := OclIterator.newOclIterator_String(br.readLine()) ; 
     var x : int ; x := (in.next())->toInteger() ;
    var y : int ; y := (in.next())->toInteger() ;
    in := null ; 
    execute union(arr, x, y) ; 
 )  ;     i := i + 1 ) ; 
    br := null ; 
        var i : int ; i := 1 ; while i <= N do ( (     rootNodes := rootNodes->including(find(arr, i)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(rootNodes->size()) ; 
 );
  static   operation find( parent : Sequence(int), i : int) : int
  pre: true
  post: true
  activity: (     while (parent[i+1] /= 0) do (     i := parent[i+1] ) ; 
     return i );
  static   operation union( parent : Sequence(int), x : int, y : int) : void
  pre: true
  post: true
  activity: (     var xset : int ; xset := find(parent, x) ;
     var yset : int ; yset := find(parent, y) ;
     if (xset /= yset) then (     if (xset <= yset) then (     parent[xset+1] := yset ) else (     parent[yset+1] := xset ) ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Quiz {
  Scanner in=new Scanner(System.in);
  public void run(){
    int n ;
    int[] a=new int[10000000];
    int[] f=new int[10000000];
    n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
      f[a[i] ]++;
    }
    int b=0 ;
    for(int j=0 ; j<n ; j++){
      if(f[a[j] ]>b)b=f[a[j] ];
    }
    for(int i=0 ; i<f.length ; i++){
      f[i]=0 ;
    }
    for(int i=0 ; i<n ; i++){
      f[a[i] ]++;
      if(f[a[i] ]==b){
        System.out.println(a[i]);
        break ;
      }
    }
  }
  public static void main(String[] args){
    Quiz a=new Quiz();
    a.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Quiz {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ;
     var a : Sequence(int) ; a := Integer.subrange(1,10000000)->collect(0) ;
    var f : Sequence(int) ; f := Integer.subrange(1,10000000)->collect(0) ;
    n := in.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     f[a[i+1]+1] := f[a[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var b : int ; b := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     if (f[a[j+1]+1] > b) then     b := f[a[j+1]+1] ; else skip )  ;     j := j + 1 ) ; 
        var i : int ; i := 0 ; while i < f->size() do ( (     f[i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     f[a[i+1]+1] := f[a[i+1]+1] + 1 ; 
     if (f[a[i+1]+1] = b) then (     OclFile["System.out"].println(a[i+1]) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Quiz ; a := Quiz.newQuiz() ;
     a.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner s=new Scanner(System.in);
    long n=s.nextLong(),k=s.nextLong();
    System.out.println(n+k-(n % k));
  }
}
class Scanner {
  StringTokenizer st ;
  BufferedReader br ;
  public Scanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public String nextLine()throws IOException {
    return br.readLine();
  }
  public double nextDouble()throws IOException {
    String x=next();
    StringBuilder sb=new StringBuilder("0");
    double res=0,f=1 ;
    boolean dec=false,neg=false ;
    int start=0 ;
    if(x.charAt(0)=='-'){
      neg=true ;
      start++;
    }
    for(int i=start ; i<x.length(); i++)if(x.charAt(i)=='.'){
      res=Long.parseLong(sb.toString());
      sb=new StringBuilder("0");
      dec=true ;
    }
    else {
      sb.append(x.charAt(i));
      if(dec)f*=10 ;
    }
    res+=Long.parseLong(sb.toString())/f ;
    return res*(neg ?-1 : 1);
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := s.getCurrent()->toLong() ;
    var k : long ; k := s.getCurrent()->toLong() ;
     OclFile["System.out"].println(n + k - (n mod k)) );
}
class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     var x : String ; x := next() ;
     var sb : String ; sb := StringLib.newString("0") ;
    var res : double ; res := 0 ;
    var f : double ; f := 1 ;
    var dec : boolean ; dec := false ;
    var neg : boolean ; neg := false ;
    var start : int ; start := 0 ;
    if (x->at(0+1) = '-') then (     neg := true ; 
     start := start + 1 ) else skip ; 
        var i : int ; i := start ; while i < x->size() do (     if (x->at(i+1) = '.') then (     res := (sb+"")->toLong() ; 
     sb := StringLib.newString("0") ; 
     dec := true ) else (     sb := sb + StringLib.newString(x->at(i+1)) ; 
     if (dec) then     f := f*(10) ; else skip ) ;   ;     i := i + 1 ) ; 
    res := res+((sb+"")->toLong() / f) ; 
    return res * (if neg then -1 else 1 endif) 
 );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
class UnionFind {
  int[] par ;
  int N ;
  public UnionFind(int n){
    N=n ;
    par=new int[N];
    for(int i=0 ; i<N ; i++){
      par[i]=i ;
    }
  }
  public int find(int x){
    if(par[x]==x)return x ;
    return par[x]=find(par[x]);
  }
  public Boolean same(int x,int y){
    return find(x)==find(y);
  }
  public void unite(int x,int y){
    if(find(x)==find(y))return ;
    par[find(x)]=find(y);
  }
  public int DistinctElementsNum(){
    HashSet<Integer>set=new HashSet<Integer>();
    for(int i=0 ; i<N ; i++){
      find(i);
      set.add(find(i));
    }
    return set.size();
  }
}
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    UnionFind uf=new UnionFind(N);
    for(int i=0 ; i<M ; i++){
      int X=sc.nextInt();
      int Y=sc.nextInt();
      int Z=sc.nextInt();
      uf.unite(X-1,Y-1);
    }
    System.out.println(uf.DistinctElementsNum());
  }
}
------------------------------------------------------------
OCL File:
---------
 class UnionFind {
   attribute par : Sequence(int);
   attribute N : int;
   static operation newUnionFind( n : int) : UnionFind
  pre: true
  post: true
  activity:
  ( var self : UnionFind ;
    self := createUnionFind();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     N := n ; 
     par := Integer.subrange(1,N)->collect(0) ; 
         var i : int ; i := 0 ; while i < N do ( (     par[i+1] := i )  ;     i := i + 1 ) );
   operation find( x : int) : int
  pre: true
  post: true
  activity: (     if (par[x+1] = x) then     return x else skip ; 
     return par[x+1] );
   operation same( x : int, y : int) : Boolean
  pre: true
  post: true
  activity: (     return find(x) = find(y) );
   operation unite( x : int, y : int) : void
  pre: true
  post: true
  activity: (     if (find(x) = find(y)) then     return else skip ; 
     par[find(x)+1] := find(y) );
   operation DistinctElementsNum() : int
  pre: true
  post: true
  activity: (     var set : Set(int) ; set := Set{} ;
         var i : int ; i := 0 ; while i < N do ( (     execute find(i) ; 
     set := set->including(find(i)) )  ;     i := i + 1 ) ; 
     return set->size() );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var uf : UnionFind ; uf := UnionFind.newUnionFind(N) ;
        var i : int ; i := 0 ; while i < M do ( (     var X : int ; X := sc.getCurrent()->toInteger() ;
     var Y : int ; Y := sc.getCurrent()->toInteger() ;
     var Z : int ; Z := sc.getCurrent()->toInteger() ;
     uf.unite(X - 1, Y - 1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(uf.DistinctElementsNum()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    List<int[]>list=new ArrayList<>();
    for(int i=0 ; i<m ; i++){
      int[] tmp=new int[3];
      tmp[0]=in.nextInt();
      tmp[1]=in.nextInt();
      tmp[2]=in.nextInt();
      list.add(tmp);
    }
    int[] uft=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      uft[i]=i ;
    }
    for(int i=0 ; i<list.size(); i++){
      int[] tmp=list.get(i);
      union(uft,tmp[0],tmp[1]);
    }
    boolean[] used=new boolean[n+1];
    int ans=0 ;
    for(int i=1 ; i<=n ; i++){
      if(! used[find(uft,i)]){
        used[find(uft,i)]=true ;
        ans++;
      }
    }
    System.out.println(ans);
  }
  public static int find(int[] tree,int idx){
    if(tree[idx]==idx)return idx ;
    else return tree[idx]=find(tree,tree[idx]);
  }
  public static void union(int[] tree,int idx1,int idx2){
    int root1=find(tree,idx1);
    int root2=find(tree,idx2);
    tree[root2]=root1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var list : Sequence(Sequence(int)) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     var tmp : Sequence(int) ; tmp := Integer.subrange(1,3)->collect(0) ;
     tmp[0+1] := in.getCurrent()->toInteger() ; 
    tmp[1+1] := in.getCurrent()->toInteger() ; 
    tmp[2+1] := in.getCurrent()->toInteger() ; 
    list := list->including(tmp) ; 
 )  ;     i := i + 1 ) ; 
    var uft : Sequence(int) ; uft := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     uft[i+1] := i )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < list->size() do ( (     var tmp : Sequence(int) ; tmp := list->at(i+1) ;
     execute union(uft, tmp[0+1], tmp[1+1]) )  ;     i := i + 1 ) ; 
    var used : Sequence(boolean) ; used := Integer.subrange(1,n + 1)->collect(false) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (not(used[find(uft, i)+1])) then (     used[find(uft, i)+1] := true ; 
     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation find( tree : Sequence(int), idx : int) : int
  pre: true
  post: true
  activity: (     if (tree[idx+1] = idx) then     return idx else     return tree[idx+1] );
  static   operation union( tree : Sequence(int), idx1 : int, idx2 : int) : void
  pre: true
  post: true
  activity: (     var root1 : int ; root1 := find(tree, idx1) ;
     var root2 : int ; root2 := find(tree, idx2) ;
     tree[root2+1] := root1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.run();
  }
  ArrayList<ArrayList<Integer>>g=new ArrayList<>();
  boolean used[];
  public void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    for(int i=0 ; i<N ; i++){
      g.add(new ArrayList<Integer>());
    }
    used=new boolean[N];
    for(int i=0 ; i<M ; i++){
      int x=sc.nextInt();
      x--;
      int y=sc.nextInt();
      y--;
      int z=sc.nextInt();
      g.get(x).add(y);
      g.get(y).add(x);
    }
    int cnt=0 ;
    for(int i=0 ; i<N ; i++){
      if(! used[i]){
        dfs(i);
        cnt++;
      }
    }
    System.out.println(cnt);
    sc.close();
  }
  public void dfs(int r){
    ArrayDeque<Integer>s=new ArrayDeque<Integer>();
    s.add(r);
    used[r]=true ;
    while(! s.isEmpty()){
      int u=s.pop();
      for(int i=0 ; i<g.get(u).size(); i++){
        int v=g.get(u).get(i);
        if(used[v])continue ;
        s.push(v);
        used[v]=true ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.run() );
   attribute g : Sequence(Sequence(int)) := Sequence{};
   attribute used : Sequence(boolean);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < N do ( (     g := g->including(Sequence{}) )  ;     i := i + 1 ) ; 
    used := Integer.subrange(1,N)->collect(false) ; 
        var i : int ; i := 0 ; while i < M do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     x := x - 1 ; 
    var y : int ; y := sc.getCurrent()->toInteger() ;
    y := y - 1 ; 
    var z : int ; z := sc.getCurrent()->toInteger() ;
    g->at(x+1)->excludes(y) ; 
    g->at(y+1)->excludes(x) ; 
 )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (not(used[i+1])) then (     execute dfs(i) ; 
     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
    skip ; 
 );
   operation dfs( r : int) : void
  pre: true
  post: true
  activity: (     var s : Sequence(int) ; s := ArrayDeque<int>.newArrayDeque() ;
     s := s->including(r) ; 
     used[r+1] := true ; 
     while (not(s->isEmpty())) do (     var u : int ; u := s->last() ;
         var i : int ; i := 0 ; while i < g->at(u+1)->size() do ( (     var v : int ; v := g->at(u+1)->at(i+1) ;
     if (used[v+1]) then     continue else skip ; 
     s := s->append(v) ; 
     used[v+1] := true )  ;     i := i + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      long a[]=new long[n];
      for(int i=0 ; i<n ; i++){
        a[i]=input.nextLong();
      }
      int count=0 ;
      for(int i=0 ; i<n-1 ; i++){
        if(a[i]>a[i+1]){
          count++;
          i++;
        }
      }
      System.out.println(count);
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var tc : int ; tc := input.nextInt() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.nextInt() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.nextLong() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (a[i+1] > a[i + 1+1]) then (     count := count + 1 ; 
     i := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;  ) ;  );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    StringBuilder sb=new StringBuilder();
    while(t-->0){
      int n=sc.nextInt(),ans=0,min=n+1 ;
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      for(int i=n-1 ; i>=0 ; i--){
        if(arr[i]>min){
          ans++;
          min=n+1 ;
        }
        else {
          min=Math.min(min,arr[i]);
        }
      }
      sb.append(ans);
      sb.append("\n");
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    var min : int ; min := n + 1 ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := (n)->char2byte() - 1 ; while i >= 0 do ( (     if (arr[i+1] > min) then (     ans := ans + 1 ; 
     min := n + 1 ) else (     min := Set{min, arr[i+1]}->min() ) )  ;     i := i - 1 ) ; 
    sb := sb + StringLib.newString(ans) ; 
    sb := sb + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt(),ans=0,min=n+1 ;
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      for(int i=n-1 ; i>=0 ; i--){
        if(arr[i]>min){
          ans++;
          min=n+1 ;
        }
        else {
          min=Math.min(min,arr[i]);
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    var min : int ; min := n + 1 ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (arr[i+1] > min) then (     ans := ans + 1 ; 
     min := n + 1 ) else (     min := Set{min, arr[i+1]}->min() ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class problemB {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num_tc=1 ;
    num_tc=sc.nextInt();
    for(int tc=1 ; tc<=num_tc ; tc++){
      solve(sc);
    }
  }
  static void solve(Scanner sc){
    int n=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    int ans=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if(arr[i]>arr[i+1]){
        ans++;
        i++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class problemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num_tc : int ; num_tc := 1 ;
     num_tc := sc.getCurrent()->toInteger() ; 
         var tc : int ; tc := 1 ; while tc <= num_tc do ( (     execute solve(sc) )  ;     tc := tc + 1 ) );
  static   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] > arr[i + 1+1]) then (     ans := ans + 1 ; 
     i := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    try(Scanner sc=new Scanner(System.in)){
      long MOD=1000000007 ;
      int N=sc.nextInt();
      long[] C=new long[N];
      for(int i=0 ; i<N ; i++){
        C[i]=sc.nextLong();
      }
      Arrays.sort(C);
      long P=pow(2,N-1,MOD);
      long ans=0 ;
      for(int i=0 ; i<N ; i++){
        ans=(ans+C[i]*((P+P*(N-i)% MOD)))% MOD ;
      }
      ans=(ans*P)% MOD ;
      System.out.println(ans);
    }
  }
  static long pow(long A,long B,long MOD){
    if(B==0){
      return 1 ;
    }
    else if(B % 2==0){
      long C=pow(A,B/2,MOD);
      return C*C % MOD ;
    }
    else {
      long C=pow(A,B-1,MOD);
      return A*C % MOD ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var MOD : long ; MOD := 1000000007 ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var C : Sequence(long) ; C := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     C[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    C := C->sort() ; 
    var P : long ; P := pow(2, N - 1, MOD) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     ans := (ans + C[i+1] * ((P + P * (N - i) mod MOD))) mod MOD )  ;     i := i + 1 ) ; 
    ans := (ans * P) mod MOD ; 
    OclFile["System.out"].println(ans) ; 
 ))  );
  static   operation pow( A : long, B : long, MOD : long) : long
  pre: true
  post: true
  activity: (     if (B = 0) then (     return 1 ) else     if (B mod 2 = 0) then (     var C : long ; C := pow(A, B / 2, MOD) ;
     return C * C mod MOD ) else (     var C : long ; C := pow(A, B - 1, MOD) ;
     return A * C mod MOD ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    long num=1000000007 ;
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    int n=Integer.parseInt(bf.readLine());
    ArrayList<Integer>array=new ArrayList<Integer>();
    StringTokenizer st2=new StringTokenizer(bf.readLine());
    for(int j=0 ; j<n ; j++){
      array.add(Integer.parseInt(st2.nextToken()));
    }
    Collections.sort(array);
    long prod=power(2,2*n-2,num);
    long sum=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      sum+=(long)((n+1-i))*(long)(array.get(i));
      sum %=num ;
    }
    out.println((sum*prod)% num);
    out.close();
  }
  public static int power(long x,long y,long mod){
    long ans=1 ;
    while(y>0){
      if(y % 2==1)ans=(ans*x)% mod ;
      x=(x*x)% mod ;
      y/=2 ;
    }
    return(int)(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : long ; num := 1000000007 ;
     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (bf.readLine())->toInteger() ;
    var array : Sequence(int) ; array := Sequence{} ;
    var st2 : OclIterator ; st2 := OclIterator.newOclIterator_String(bf.readLine()) ;
        var j : int ; j := 0 ; while j < n do ( (     array := array->including((st2.next())->toInteger()) )  ;     j := j + 1 ) ; 
    array := array->sort() ; 
    var prod : long ; prod := power(2, 2 * n - 2, num) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     sum := sum+(((n + 1 - i))->oclAsType(long) * (array->at(i+1))->oclAsType(long)) ; 
     sum := sum mod num )  ;     i := i - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation power( x : long, y : long, mod : long) : int
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
     while (y > 0) do (     if (y mod 2 = 1) then     ans := (ans * x) mod mod ; else skip ; 
     x := (x * x) mod mod ; 
     y := y/(2) ) ; 
     return (ans)->oclAsType(int) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package qualification.c ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class CLarge {
  Scanner in ;
  public CLarge(){
    in=new Scanner(System.in);
    int t=in.nextInt();
    for(int l=1 ; l<=t ; l++){
      int r=in.nextInt();
      int k=in.nextInt();
      int n=in.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=in.nextInt();
      }
      int[] nextGroup=new int[n];
      long[] money=new long[n];
      for(int i=0 ; i<n ; i++){
        long space=k ;
        int pointer=i ;
        long total=0 ;
        int srcPointer=pointer ;
        while(space>=arr[pointer]){
          space-=arr[pointer];
          total+=arr[pointer];
          if((pointer+1)% n==srcPointer){
            break ;
          }
          pointer=(pointer+1)% n ;
        }
        nextGroup[i]=pointer ;
        money[i]=total ;
      }
      int group=0 ;
      long total=0 ;
      for(int i=0 ; i<r ; i++){
        total+=money[group];
        group=nextGroup[group];
      }
      System.out.printf("Case #%d: %d\n",l,total);
    }
  }
  public static void main(String[] args){
    try {
      String p="C-large-practice" ;
      System.setIn(CLarge.class.getResourceAsStream(p+".in"));
      System.setOut(new PrintStream(new File("src/qualification/c/"+p+".out")));
    }
    catch(FileNotFoundException e){
      e.printStackTrace();
    }
    new CLarge();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CLarge {
   attribute in : OclFile;
   static operation newCLarge() : CLarge
  pre: true
  post: true
  activity:
  ( var self : CLarge ;
    self := createCLarge();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var t : int ; t := in.getCurrent()->toInteger() ;
         var l : int ; l := 1 ; while l <= t do ( (     var r : int ; r := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var nextGroup : Sequence(int) ; nextGroup := Integer.subrange(1,n)->collect(0) ;
    var money : Sequence(long) ; money := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var space : long ; space := k ;
     var pointer : int ; pointer := i ;
    var total : long ; total := 0 ;
    var srcPointer : int ; srcPointer := pointer ;
    while (space >= arr[pointer+1]) do (     space := space-(arr[pointer+1]) ; 
     total := total+(arr[pointer+1]) ; 
     if ((pointer + 1) mod n = srcPointer) then (     break ) else skip ; 
     pointer := (pointer + 1) mod n ) ; 
    nextGroup[i+1] := pointer ; 
    money[i+1] := total ; 
 )  ;     i := i + 1 ) ; 
    var group : int ; group := 0 ;
    var total : long ; total := 0 ;
        var i : int ; i := 0 ; while i < r do ( (     total := total+(money[group+1]) ; 
     group := nextGroup[group+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("Case #%d: %d\n", l, total) ; 
 )  ;     l := l + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var p : String ; p := "C-large-practice" ;
 setIn(OclType["CLarge"].getResourceAsStream(p + ".in")) ; 
 setOut(OclFile.newOclFile_Write(OclFile("src/qualification/c/" + p + ".out"))) )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
 CLarge.newCLarge() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    int n=Integer.parseInt(sa[0]);
    sa=br.readLine().split(" ");
    int[] c=new int[n];
    for(int i=0 ; i<n ; i++){
      c[i]=Integer.parseInt(sa[i]);
    }
    br.close();
    int mod=1000000007 ;
    if(n==1){
      System.out.println(c[0]*2 % mod);
      return ;
    }
    Arrays.parallelSort(c);
    long b=power(2,n);
    long a=power(2,n-2);
    long ans=0 ;
    for(int i=2 ; i<=n+1 ; i++){
      long val=a*i % mod ;
      val*=c[n+1-i];
      val %=mod ;
      ans+=val ;
      ans %=mod ;
    }
    ans*=b ;
    ans %=mod ;
    System.out.println(ans);
  }
  static long power(long x,long n){
    if(n==0){
      return 1 ;
    }
    int mod=1000000007 ;
    long val=power(x,n/2);
    val=val*val % mod ;
    if(n % 2==1){
      val=val*x % mod ;
    }
    return val ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var n : int ; n := (sa[0+1])->toInteger() ;
    sa := br.readLine()->split(" ") ; 
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := (sa[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var mod : int ; mod := 1000000007 ;
    if (n = 1) then (     OclFile["System.out"].println(c[0+1] * 2 mod mod) ; 
     return ) else skip ; 
    c := c->sort() ; 
    var b : long ; b := power(2, n) ;
    var a : long ; a := power(2, n - 2) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 2 ; while i <= n + 1 do ( (     var val : long ; val := a * i mod mod ;
     val := val*(c[n + 1 - i+1]) ; 
    val := val mod mod ; 
    ans := ans+(val) ; 
    ans := ans mod mod ; 
 )  ;     i := i + 1 ) ; 
    ans := ans*(b) ; 
    ans := ans mod mod ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation power( x : long, n : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then (     return 1 ) else skip ; 
     var mod : int ; mod := 1000000007 ;
    var val : long ; val := power(x, n / 2) ;
    val := val * val mod mod ; 
    if (n mod 2 = 1) then (     val := val * x mod mod ) else skip ; 
    return val 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner s=new Scanner(System.in);
    long n=s.nextLong(),k=s.nextLong();
    System.out.println(n+k-(n % k));
  }
}
class Scanner {
  StringTokenizer st ;
  BufferedReader br ;
  public Scanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public String nextLine()throws IOException {
    return br.readLine();
  }
  public double nextDouble()throws IOException {
    String x=next();
    StringBuilder sb=new StringBuilder("0");
    double res=0,f=1 ;
    boolean dec=false,neg=false ;
    int start=0 ;
    if(x.charAt(0)=='-'){
      neg=true ;
      start++;
    }
    for(int i=start ; i<x.length(); i++)if(x.charAt(i)=='.'){
      res=Long.parseLong(sb.toString());
      sb=new StringBuilder("0");
      dec=true ;
    }
    else {
      sb.append(x.charAt(i));
      if(dec)f*=10 ;
    }
    res+=Long.parseLong(sb.toString())/f ;
    return res*(neg ?-1 : 1);
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := s.getCurrent()->toLong() ;
    var k : long ; k := s.getCurrent()->toLong() ;
     OclFile["System.out"].println(n + k - (n mod k)) );
}
class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     var x : String ; x := next() ;
     var sb : String ; sb := StringLib.newString("0") ;
    var res : double ; res := 0 ;
    var f : double ; f := 1 ;
    var dec : boolean ; dec := false ;
    var neg : boolean ; neg := false ;
    var start : int ; start := 0 ;
    if (x->at(0+1) = '-') then (     neg := true ; 
     start := start + 1 ) else skip ; 
        var i : int ; i := start ; while i < x->size() do (     if (x->at(i+1) = '.') then (     res := (sb+"")->toLong() ; 
     sb := StringLib.newString("0") ; 
     dec := true ) else (     sb := sb + StringLib.newString(x->at(i+1)) ; 
     if (dec) then     f := f*(10) ; else skip ) ;   ;     i := i + 1 ) ; 
    res := res+((sb+"")->toLong() / f) ; 
    return res * (if neg then -1 else 1 endif) 
 );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main extends PrintWriter {
  Main(){
    super(System.out,true);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    Main o=new Main();
    o.main();
    o.flush();
  }
  static final int MD=1000000007 ;
  void main(){
    int n=sc.nextInt();
    int[] aa=new int[n];
    for(int i=0 ; i<n ; i++)aa[i]=sc.nextInt();
    aa=Arrays.stream(aa).boxed().sorted().mapToInt($->$).toArray();
    long ans=0 ;
    for(int i=0 ; i<n ; i++)ans=(ans+(long)(i+2)*aa[n-1-i])% MD ;
    while(--n>0)ans=ans*4 % MD ;
    println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends OclFile {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"], true) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : Main ; o := Main.newMain() ;
     o.main() ; 
     o.flush() );
  static    attribute MD : int := 1000000007;
   operation main() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var aa : Sequence(int) ; aa := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     aa[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    aa := stream(aa)->sort()->collect( _x1 | (lambda $ : OclAny in $)->apply(_x1) )->asSequence() ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do (     ans := (ans + (i + 2)->oclAsType(long) * aa[n - 1 - i+1]) mod MD ;  ;     i := i + 1 ) ; 
        n := n - 1 ;
    while ((n - 1) > 0) do (        n := n - 1 ;     skip ;     ans := ans * 4 mod MD ; ;     n := n - 1 ;
 ) ;  
    execute println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int distinctSubString(String P,String Q,int K,int N){
    HashSet<String>S=new HashSet<String>();
    for(int i=0 ; i<N ; ++i){
      int sum=0 ;
      String s="" ;
      for(int j=i ; j<N ; ++j){
        int pos=P.charAt(j)-'a' ;
        sum+=Q.charAt(pos)-'0' ;
        s+=P.charAt(j);
        if(sum<=K){
          S.add(s);
        }
        else {
          break ;
        }
      }
    }
    return S.size();
  }
  public static void main(String[] args){
    String P="abcde" ;
    String Q="12345678912345678912345678" ;
    int K=5 ;
    int N=P.length();
    System.out.print(distinctSubString(P,Q,K,N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation distinctSubString( P : String, Q : String, K : int, N : int) : int
  pre: true
  post: true
  activity: (     var S : Set(String) ; S := Set{} ;
         var i : int ; i := 0 ; while i < N do ( (     var sum : int ; sum := 0 ;
     var s : String ; s := "" ;
         var j : int ; j := i ; while j < N do ( (     var pos : int ; pos := P->at(j+1) - ('a')->char2byte() ;
     sum := sum+(Q->at(pos+1) - ('0')->char2byte()) ; 
     s := s+(P->at(j+1)) ; 
     if (sum <= K) then (     S := S->including(s) ) else (     break ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return S->size() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var P : String ; P := "abcde" ;
     var Q : String ; Q := "12345678912345678912345678" ;
    var K : int ; K := 5 ;
    var N : int ; N := P->size() ;
    OclFile["System.out"].print(distinctSubString(P, Q, K, N)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static char[] makeEven(String string){
    char[] str=string.toCharArray();
    int n=str.length ;
    int even=Integer.MAX_VALUE,index=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if((str[i]-'0')% 2==0){
        even=(str[i]-'0');
        index=i ;
      }
      if(even<=(str[n-1]-'0')){
        break ;
      }
    }
    if(even==Integer.MAX_VALUE){
      return str ;
    }
    swap(str,index,n-1);
    return str ;
  }
  static void swap(char[] str,int index1,int index2){
    char temp=str[index1];
    str[index1]=str[index2];
    str[index2]=temp ;
  }
  public static void main(String[] args){
    String str="1356425" ;
    System.out.print(makeEven(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation makeEven( string : String) : Sequence(String)
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := string->characters() ;
     var n : int ; n := str->size() ;
    var even : int ; even := 2147483647 ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if ((str[i+1] - ('0')->char2byte()) mod 2 = 0) then (     even := (str[i+1] - ('0')->char2byte()) ; 
     index := i ) else skip ; 
     if (even <= (str[n - 1+1] - ('0')->char2byte())) then (     break ) else skip )  ;     i := i + 1 ) ; 
    if (even = 2147483647) then (     return str ) else skip ; 
    execute swap(str, index, n - 1) ; 
    return str 
 );
  static   operation swap( str : Sequence(String), index1 : int, index2 : int) : void
  pre: true
  post: true
  activity: (     var temp : String ; temp := str[index1+1] ;
     str[index1+1] := str[index2+1] ; 
     str[index2+1] := temp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "1356425" ;
     OclFile["System.out"].print(makeEven(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findDivisors(int n){
    int[] div=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j*i<=n ; j++)div[i*j]++;
    }
    for(int i=1 ; i<=n ; i++)System.out.print(div[i]+" ");
  }
  public static void main(String args[]){
    int n=10 ;
    findDivisors(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findDivisors( n : int) : void
  pre: true
  post: true
  activity: (     var div : Sequence(int) ; div := Integer.subrange(1,n + 1)->collect(0) ;
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j * i <= n do (     div[i * j+1] := div[i * j+1] + 1 ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i <= n do (     OclFile["System.out"].print(div[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     execute findDivisors(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class ProB {
  static int a,b ;
  static long ans ;
  static String ss ;
  static char[] aa,bb ;
  static int[] mm=new int[200005];
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    ss=in.next();
    aa=ss.toCharArray();
    a=ss.length();
    ss=in.next();
    bb=ss.toCharArray();
    b=ss.length();
    for(int i=1 ; i<=b ; i++)mm[i]=mm[i-1]+bb[i-1]-'0' ;
    for(int i=0 ; i<a ; i++){
      if(aa[i]=='0')ans+=(long)mm[b-a+i+1]-mm[i];
      else ans+=(long)b-a+1-(mm[b-a+i+1]-mm[i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProB {
  static   attribute a : int;
  static   attribute ans : long;
  static   attribute ss : String;
  static   attribute aa : Sequence(String);
  static   attribute mm : Sequence(int) := Integer.subrange(1,200005)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     ss := in.getCurrent() ; 
    aa := ss->characters() ; 
    a := ss->size() ; 
    ss := in.getCurrent() ; 
    bb := ss->characters() ; 
    b := ss->size() ; 
        var i : int ; i := 1 ; while i <= b do (     mm[i+1] := mm[i - 1+1] + bb[i - 1+1] - ('0')->char2byte() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a do ( (     if (aa[i+1] = '0') then     ans := ans+(mm[b - a + i + 1+1]->oclAsType(long) - mm[i+1]) ; else     ans := ans+(b->oclAsType(long) - a + 1 - (mm[b - a + i + 1+1] - mm[i+1])) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    char[] a=reader.readLine().toCharArray();
    char[] b=reader.readLine().toCharArray();
    long d=0 ;
    if(a.length==b.length){
      for(int i=0 ; i<a.length ; i++){
        d+=a[i] ^ b[i];
      }
    }
    else {
      long freq[][]=new long[2][a.length];
      for(int i=0 ; i<b.length-a.length+1 ; i++){
        freq[b[i]-'0'][0]++;
      }
      for(int i=1 ; i<a.length ; i++){
        freq[0][i]=freq[0][i-1]-('1'-b[i-1])+('1'-b[b.length-a.length+i]);
        freq[1][i]=freq[1][i-1]-(b[i-1]-'0')+(b[b.length-a.length+i]-'0');
      }
      for(int i=0 ; i<a.length ; i++){
        d+=freq[('1'-a[i])][i];
      }
    }
    writer.write(d+"");
    writer.newLine();
    writer.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var a : Sequence(String) ; a := reader.readLine()->characters() ;
    var b : Sequence(String) ; b := reader.readLine()->characters() ;
    var d : long ; d := 0 ;
    if (a->size() = b->size()) then (         var i : int ; i := 0 ; while i < a->size() do ( (     d := d+(a[i+1] xor b[i+1]) )  ;     i := i + 1 ) ) else (     var freq : Sequence(Sequence(long)) ; freq := Integer.subrange(1,2)->collect(Integer.subrange(1,a->size())->collect(0)) ;
         var i : int ; i := 0 ; while i < b->size() - a->size() + 1 do ( (     freq[b[i+1] - ('0')->char2byte()+1][0+1] := freq[b[i+1] - ('0')->char2byte()+1][0+1] + 1 )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i < a->size() do ( (     freq[0+1][i+1] := freq[0+1][i - 1+1] - (('1')->char2byte() - b[i - 1+1]) + (('1')->char2byte() - b[b->size() - a->size() + i+1]) ; 
     freq[1+1][i+1] := freq[1+1][i - 1+1] - (b[i - 1+1] - ('0')->char2byte()) + (b[b->size() - a->size() + i+1] - ('0')->char2byte()) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < a->size() do ( (     d := d+(freq[(('1')->char2byte() - a[i+1])+1][i+1]) )  ;     i := i + 1 ) ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B608 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char[] A=in.next().toCharArray();
    char[] B=in.next().toCharArray();
    int[] ones=new int[B.length+1];
    for(int i=1 ; i<=B.length ; i++){
      ones[i]=ones[i-1]+(B[i-1]=='1' ? 1 : 0);
    }
    long answer=0 ;
    int distCount=B.length-A.length+1 ;
    for(int i=0 ; i<A.length ; i++){
      boolean one=(A[i]=='1');
      int oneCount=ones[i+distCount]-ones[i];
      int zeroCount=distCount-oneCount ;
      answer+=one ? zeroCount : oneCount ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B608 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : Sequence(String) ; A := in.getCurrent()->characters() ;
    var B : Sequence(String) ; B := in.getCurrent()->characters() ;
    var ones : Sequence(int) ; ones := Integer.subrange(1,B->size() + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= B->size() do ( (     ones[i+1] := ones[i - 1+1] + (if B[i - 1+1] = '1' then 1 else 0 endif) )  ;     i := i + 1 ) ; 
    var answer : long ; answer := 0 ;
    var distCount : int ; distCount := B->size() - A->size() + 1 ;
        var i : int ; i := 0 ; while i < A->size() do ( (     var one : boolean ; one := (A[i+1] = '1') ;
     var oneCount : int ; oneCount := ones[i + distCount+1] - ones[i+1] ;
     var zeroCount : int ; zeroCount := distCount - oneCount ;
     answer := answer+(if one then zeroCount else oneCount endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class GFG {
  static final int MAX_CHAR=256 ;
  static void printDistinct(String str){
    int n=str.length();
    int[] count=new int[MAX_CHAR];
    int[] index=new int[MAX_CHAR];
    for(int i=0 ; i<MAX_CHAR ; i++){
      count[i]=0 ;
      index[i]=n ;
    }
    for(int i=0 ; i<n ; i++){
      char x=str.charAt(i);
++count[x];
      if(count[x]==1 && x!=' ')index[x]=i ;
      if(count[x]==2)index[x]=n ;
    }
    Arrays.sort(index);
    for(int i=0 ; i<MAX_CHAR && index[i]!=n ; i++)System.out.print(str.charAt(index[i]));
  }
  public static void main(String args[]){
    String str="GeeksforGeeks" ;
    printDistinct(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX_CHAR : int := 256;
  static   operation printDistinct( str : String) : void
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var count : Sequence(int) ; count := Integer.subrange(1,MAX_CHAR)->collect(0) ;
    var index : Sequence(int) ; index := Integer.subrange(1,MAX_CHAR)->collect(0) ;
        var i : int ; i := 0 ; while i < MAX_CHAR do ( (     count[i+1] := 0 ; 
     index[i+1] := n )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : String ; x := str->at(i+1) ;
     count[x+1] := count[x+1] + 1 ; 
     if (count[x+1] = 1 & x /= ' ') then     index[x+1] := i ; else skip ; 
     if (count[x+1] = 2) then     index[x+1] := n ; else skip )  ;     i := i + 1 ) ; 
    index := index->sort() ; 
        var i : int ; i := 0 ; while i < MAX_CHAR & index[i+1] /= n do (     OclFile["System.out"].print(str->at(index[i+1]+1)) ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GeeksforGeeks" ;
     execute printDistinct(str) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] x=new int[n];
    for(int i=0 ; i<n ; ++i)x[i]=sc.nextInt();
    long all=0 ;
    for(int i=0 ; i<n ; ++i)all+=x[i];
    SegmentTree seg=new SegmentTree(n+1);
    for(int i=0 ; i<n ; ++i){
      long pre=seg.query(0,x[i]);
      seg.set(x[i],pre+x[i]);
    }
    long fix=seg.query(0,n+1);
    System.out.println(all-fix);
  }
  static class SegmentTree {
    int n=1 ;
    long[] val ;
    public SegmentTree(int n){
      while(this.n<n)this.n*=2 ;
      val=new long[2*this.n-1];
    }
    void set(int k,long l){
      k+=n-1 ;
      val[k]=l ;
      while(k>0){
        k=(k-1)/2 ;
        val[k]=Math.max(val[2*k+1],val[2*k+2]);
      }
    }
    long query(int a,int b){
      return query(a,b,0,n,0);
    }
    long query(int a,int b,int l,int r,int k){
      if(r<=a || b<=l)return 0 ;
      else if(a<=l && r<=b){
        return val[k];
      }
      else {
        long vl=query(a,b,l,(l+r)/2,2*k+1);
        long vr=query(a,b,(l+r)/2,r,2*k+2);
        return Math.max(vl,vr);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     x[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var all : long ; all := 0 ;
        var i : int ; i := 0 ; while i < n do (     all := all+(x[i+1]) ;  ;     i := i + 1 ) ; 
    var seg : SegmentTree ; seg := SegmentTree.newSegmentTree(n + 1) ;
        var i : int ; i := 0 ; while i < n do ( (     var pre : long ; pre := seg.query(0, x[i+1]) ;
     seg := seg.setAt(x[i+1]+1, pre + x[i+1]) )  ;     i := i + 1 ) ; 
    var fix : long ; fix := seg.query(0, n + 1) ;
    OclFile["System.out"].println(all - fix) ; 
 );
  static class SegmentTree {
   attribute n : int := 1;
   attribute val : Sequence(long);
   static operation newSegmentTree( n : int) : SegmentTree
  pre: true
  post: true
  activity:
  ( var self : SegmentTree ;
    self := createSegmentTree();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     while (self.n < n) do     self.n := self.n*(2) ; ; 
     val := Integer.subrange(1,2 * self.n - 1)->collect(0) );
   operation set( k : int, l : long) : void
  pre: true
  post: true
  activity: (     k := k+(n - 1) ; 
     val[k+1] := l ; 
     while (k > 0) do (     k := (k - 1) / 2 ; 
     val[k+1] := Set{val[2 * k + 1+1], val[2 * k + 2+1]}->max() ) );
   operation query( a : int, b : int) : long
  pre: true
  post: true
  activity: (     return query(a, b, 0, n, 0) );
   operation query( a : int, b : int, l : int, r : int, k : int) : long
  pre: true
  post: true
  activity: (     if (r <= a or b <= l) then     return 0 else     if (a <= l & r <= b) then (     return val[k+1] ) else (     var vl : long ; vl := query(a, b, l, (l + r) / 2, 2 * k + 1) ;
     var vr : long ; vr := query(a, b, (l + r) / 2, r, 2 * k + 2) ;
     return Set{vl, vr}->max() ) ;  );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int ara[]=new int[n];
    Map<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int v=in.nextInt();
      ara[i]=v ;
      if(! map.containsKey(v)){
        map.put(v,1);
      }
      else {
        map.put(v,map.get(v)+1);
      }
    }
    int max=0 ;
    for(Integer i : map.values()){
      max=Math.max(max,i);
    }
    Map<Integer,Integer>mm=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(! mm.containsKey(ara[i])){
        mm.put(ara[i],1);
        if(mm.get(ara[i])==max){
          pw.println(ara[i]);
          break ;
        }
      }
      else {
        mm.put(ara[i],mm.get(ara[i])+1);
        if(mm.get(ara[i])==max){
          pw.println(ara[i]);
          break ;
        }
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var ara : Sequence(int) ; ara := Integer.subrange(1,n)->collect(0) ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := in.getCurrent()->toInteger() ;
     ara[i+1] := v ; 
     if (not(map->keys()->includes(v))) then (     map := map->union(Map{v |-> 1}) ) else (     map := map->union(Map{v |-> map->at(v) + 1}) ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    for (i : map->values()) do ( (     max := Set{max, i}->max() )  ) ; 
    var mm : Map(int,int) ; mm := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (not(mm->keys()->includes(ara[i+1]))) then (     mm := mm->union(Map{ara[i+1] |-> 1}) ; 
     if (mm->at(ara[i+1]) = max) then (     skip ; 
     break ) else skip ) else (     mm := mm->union(Map{ara[i+1] |-> mm->at(ara[i+1]) + 1}) ; 
     if (mm->at(ara[i+1]) = max) then (     skip ; 
     break ) else skip ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int calculate(int x,int k,int m){
    int result=x ;
    k--;
    while(k-->0){
      result=(int)Math.pow(result,x);
      if(result>m)result %=m ;
    }
    return result ;
  }
  public static void main(String args[]){
    int x=5,k=2,m=3 ;
    System.out.println(calculate(x,k,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation calculate( x : int, k : int, m : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := x ;
     k := k - 1 ; 
         while (k > 0) do (        k := k - 1 ;     skip ; (     result := result->pow(x)->oclAsType(int) ; 
     if (result > m) then     result := result mod m ; else skip ) ;  ) ;  
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 5 ;
    var k : int ; k := 2 ;
    var m : int ; m := 3 ;
     OclFile["System.out"].println(calculate(x, k, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class Main {
  static void converthenumber(int n){
    String s=Integer.toString(n);
    String res="" ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='1' || s.charAt(i)=='3' || s.charAt(i)=='5' || s.charAt(i)=='7' || s.charAt(i)=='9')res+=s.charAt(i);
      if(res.length()==2)break ;
    }
    if(res.length()==2)System.out.println(res);
    else System.out.println(-1);
  }
  public static void main(String[] args){
    int n=18720 ;
    converthenumber(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation converthenumber( n : int) : void
  pre: true
  post: true
  activity: (     var s : String ; s := ((n) + "") ;
     var res : String ; res := "" ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '1' or s->at(i+1) = '3' or s->at(i+1) = '5' or s->at(i+1) = '7' or s->at(i+1) = '9') then     res := res+(s->at(i+1)) ; else skip ; 
     if (res->size() = 2) then     break else skip )  ;     i := i + 1 ) ; 
     if (res->size() = 2) then     OclFile["System.out"].println(res) ; else     OclFile["System.out"].println(-1) ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 18720 ;
     execute converthenumber(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    n++;
    int z=0 ;
    if(n % k!=0)z=k-n % k ;
    System.out.println(n+z);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    n := n + 1 ; 
    var z : int ; z := 0 ;
    if (n mod k /= 0) then     z := k - n mod k ; else skip ; 
    OclFile["System.out"].println(n + z) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    List<String>chk=new ArrayList<>();
    for(char c1='a' ; c1<='z' ; c1++){
      chk.add(c1+"");
    }
    for(char c1='a' ; c1<='z' ; c1++){
      for(char c2='a' ; c2<='z' ; c2++){
        chk.add(c1+""+c2);
      }
    }
    for(char c1='a' ; c1<='z' ; c1++){
      for(char c2='a' ; c2<='z' ; c2++){
        for(char c3='a' ; c3<='z' ; c3++){
          chk.add(c1+""+c2+""+c3);
        }
      }
    }
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      String s=sc.next();
      for(String str : chk){
        if(s.contains(str))continue ;
        System.out.println(str);
        break ;
      }
    }
  }
  public static boolean isPowerOfTen(long input){
    if(input % 10!=0 || input==0){
      return false ;
    }
    if(input==10){
      return true ;
    }
    return isPowerOfTen(input/10);
  }
  static boolean isPrime(long n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static long gcd(long a,long b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static long lcm(long a,long b){
    return(a/gcd(a,b))*b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var chk : Sequence(String) ; chk := Sequence{} ;
        var c1 : String ; c1 := 'a' ; while c1 <= 'z' do ( (     chk := chk->including(c1 + "") )  ;     c1 := c1 + 1 ) ; 
        var c1 : String ; c1 := 'a' ; while c1 <= 'z' do ( (         var c2 : String ; c2 := 'a' ; while c2 <= 'z' do ( (     chk := chk->including(c1 + "" + c2) )  ;     c2 := c2 + 1 ) )  ;     c1 := c1 + 1 ) ; 
        var c1 : String ; c1 := 'a' ; while c1 <= 'z' do ( (         var c2 : String ; c2 := 'a' ; while c2 <= 'z' do ( (         var c3 : String ; c3 := 'a' ; while c3 <= 'z' do ( (     chk := chk->including(c1 + "" + c2 + "" + c3) )  ;     c3 := c3 + 1 ) )  ;     c2 := c2 + 1 ) )  ;     c1 := c1 + 1 ) ; 
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
     for (str : chk) do ( (     if (s->includes(str)) then     continue else skip ; 
     OclFile["System.out"].println(str) ; 
     break )  ) ) ;  ) ;  
 );
  static   operation isPowerOfTen( input : long) : boolean
  pre: true
  post: true
  activity: (     if (input mod 10 /= 0 or input = 0) then (     return false ) else skip ; 
     if (input = 10) then (     return true ) else skip ; 
     return isPowerOfTen(input / 10) );
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a / gcd(a, b)) * b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
public class Main {
  static class Reader {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tokenizer=new StringTokenizer("");
    String next()throws IOException {
      while(! tokenizer.hasMoreTokens()){
        tokenizer=new StringTokenizer(reader.readLine());
      }
      return tokenizer.nextToken();
    }
    int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    void close()throws IOException {
      reader.close();
    }
  }
  public static void main(String[] args)throws IOException {
    Reader sc=new Reader();
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int TT=sc.nextInt();
    while(TT-->0){
      HashSet<Integer>set=new HashSet<>();
      int n=sc.nextInt();
      for(int i=0 ; i<n ; i++)set.add(sc.nextInt());
      for(int i=0 ; i<n ; i++)out.print(Math.max(i+1,set.size())+" ");
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Reader {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute tokenizer : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var TT : int ; TT := sc.getCurrent()->toInteger() ;
        while (TT > 0) do (        TT := TT - 1 ;     skip ; (     var set : Set(int) ; set := Set{} ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do (     set := set->including(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do (     skip ;  ;     i := i + 1 ) ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      Set<Integer>set=new HashSet<Integer>();
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
        set.add(arr[i]);
      }
      int pos=set.size();
      int chk=n-set.size();
      int i=0 ;
      while(i!=pos){
        System.out.print(set.size()+" ");
        i++;
      }
      for(i=0 ; i<chk ; i++)System.out.print((set.size()+i+1)+" ");
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     set := set->including(arr[i+1]) )  ;     i := i + 1 ) ; 
    var pos : int ; pos := set->size() ;
    var chk : int ; chk := n - set->size() ;
    var i : int ; i := 0 ;
    while (i /= pos) do (     OclFile["System.out"].print(set->size() + " ") ; 
     i := i + 1 ) ; 
        i := 0 ; while i < chk do (     OclFile["System.out"].print((set->size() + i + 1) + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int num=7 ;
    int res=1 ;
    while(num<n){
      num=num*10+7 ;
      res++;
    }
    Set<Integer>set=new HashSet<>();
    while(true){
      if(num % n==0)break ;
      num %=n ;
      res++;
      if(! set.add(num)){
        res=-1 ;
        break ;
      }
      num=num*10+7 ;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var num : int ; num := 7 ;
    var res : int ; res := 1 ;
    while (num < n) do (     num := num * 10 + 7 ; 
     res := res + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
    while (true) do (     if (num mod n = 0) then     break else skip ; 
     num := num mod n ; 
    res := res + 1 ; 
    if (not(set->excludes(num))) then (     res := -1 ; 
     break ) else skip ; 
    num := num * 10 + 7 ; 
 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static final BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  private static final PrintWriter pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  private static StringTokenizer st ;
  private static int readInt()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return Integer.parseInt(st.nextToken());
  }
  public static void main(String[] args)throws IOException {
    pw.println(solve());
    pw.close();
  }
  private static int solve()throws IOException {
    int K=readInt();
    if(K % 2==0 || K % 5==0)return-1 ;
    if(K % 7==0)K/=7 ;
    K*=9 ;
    int ans=1 ;
    int remainder=10 % K ;
    while(remainder!=1){
      ans++;
      remainder=remainder*10 % K ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static    attribute pw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])));
  static   attribute st : OclIterator;
  static   operation readInt() : int
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return (st.next())->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     skip ; 
     skip );
  static   operation solve() : int
  pre: true
  post: true
  activity: (     var K : int ; K := readInt() ;
     if (K mod 2 = 0 or K mod 5 = 0) then     return -1 else skip ; 
    if (K mod 7 = 0) then     K := K/(7) ; else skip ; 
    K := K*(9) ; 
    var ans : int ; ans := 1 ;
    var remainder : int ; remainder := 10 mod K ;
    while (remainder /= 1) do (     ans := ans + 1 ; 
     remainder := remainder * 10 mod K ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    int k=sc.nextInt();
    long t=7 ;
    int i=1 ;
    for(; i<=k ; i++){
      t=t % k ;
      if(t==0){
        System.out.println(i);
        return ;
      }
      else {
        t=t*10+7 ;
      }
    }
    System.out.println(-1);
  }
  static class MyScanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),1<<15);
    StringTokenizer tokenizer ;
    String next(){
      try {
        while(tokenizer==null || ! tokenizer.hasMoreTokens()){
          tokenizer=new StringTokenizer(reader.readLine());
        }
      }
      catch(IOException ignored){
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var k : int ; k := sc.nextInt() ;
    var t : long ; t := 7 ;
    var i : int ; i := 1 ;
      while i <= k do ( (     t := t mod k ; 
     if (t = 0) then (     OclFile["System.out"].println(i) ; 
     return ) else (     t := t * 10 + 7 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
 );
  static class MyScanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (1*(2->pow(15)))->oclAsType(long));
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (ignored : IOException) do skip
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    resolve(System.in,System.out);
  }
  static void resolve(InputStream is,PrintStream pw){
    Scanner sc=new Scanner(is);
    int k=Integer.parseInt(sc.next());
    if(k % 2==0){
      pw.println(-1);
      return ;
    }
    Set<Integer>knownRemains=new HashSet<>();
    int remain=7 % k ;
    knownRemains.add(remain);
    int ans=1 ;
    while(true){
      if(remain==0){
        pw.println(ans);
        return ;
      }
      remain=((remain*10)+7)% k ;
      if(knownRemains.contains(remain)){
        pw.println(-1);
        return ;
      }
      knownRemains.add(remain);
      ans++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute resolve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation resolve( is : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(is) ;
     var k : int ; k := (sc.getCurrent())->toInteger() ;
    if (k mod 2 = 0) then (     pw.println(-1) ; 
     return ) else skip ; 
    var knownRemains : Set(int) ; knownRemains := Set{} ;
    var remain : int ; remain := 7 mod k ;
    knownRemains := knownRemains->including(remain) ; 
    var ans : int ; ans := 1 ;
    while (true) do (     if (remain = 0) then (     pw.println(ans) ; 
     return ) else skip ; 
     remain := ((remain * 10) + 7) mod k ; 
    if (knownRemains->includes(remain)) then (     pw.println(-1) ; 
     return ) else skip ; 
    knownRemains := knownRemains->including(remain) ; 
    ans := ans + 1 ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int checkIfStartsWithCapital(String str){
    if(str.charAt(0)>='A' && str.charAt(0)<='Z')return 1 ;
    else return 0 ;
  }
  static void check(String str){
    if(checkIfStartsWithCapital(str)==1)System.out.println("Accepted");
    else System.out.println("Not Accepted");
  }
  public static void main(String[] args){
    String str="GeeksforGeeks" ;
    check(str);
    str="geeksforgeeks" ;
    check(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkIfStartsWithCapital( str : String) : int
  pre: true
  post: true
  activity: (     if (str->at(0+1) >= 'A' & str->at(0+1) <= 'Z') then     return 1 else     return 0 );
  static   operation check( str : String) : void
  pre: true
  post: true
  activity: (     if (checkIfStartsWithCapital(str) = 1) then     OclFile["System.out"].println("Accepted") ; else     OclFile["System.out"].println("Not Accepted") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GeeksforGeeks" ;
     execute check(str) ; 
     str := "geeksforgeeks" ; 
     execute check(str) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
import java.util.HashSet ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    int k=Integer.parseInt(br.readLine());
    HashSet<Long>hash=new HashSet<Long>();
    long val=0 ;
    for(int i=1 ; ; i++){
      val=((val*10)+7)% k ;
      if(val==0){
        bw.write(i+"");
        break ;
      }
      if(hash.contains(val)){
        bw.write("-1");
        break ;
      }
      hash.add(val);
    }
    bw.flush();
    bw.close();
    br.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var k : int ; k := (br.readLine())->toInteger() ;
    var hash : Set(long) ; hash := Set{} ;
    var val : long ; val := 0 ;
        var i : int ; i := 1 ; while true do ( (     val := ((val * 10) + 7) mod k ; 
     if (val = 0) then (     skip ; 
     break ) else skip ; 
     if (hash->includes(val)) then (     skip ; 
     break ) else skip ; 
     hash := hash->including(val) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int sn(int n,int an){
    return(n*(1+an))/2 ;
  }
  static int trace(int n,int m){
    int an=1+(n-1)*(m+1);
    int rowmajorSum=sn(n,an);
    an=1+(n-1)*(n+1);
    int colmajorSum=sn(n,an);
    return rowmajorSum+colmajorSum ;
  }
  static public void main(String[] args){
    int N=3,M=3 ;
    System.out.println(trace(N,M));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sn( n : int, an : int) : int
  pre: true
  post: true
  activity: (     return (n * (1 + an)) / 2 );
  static   operation trace( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var an : int ; an := 1 + (n - 1) * (m + 1) ;
     var rowmajorSum : int ; rowmajorSum := sn(n, an) ;
    an := 1 + (n - 1) * (n + 1) ; 
    var colmajorSum : int ; colmajorSum := sn(n, an) ;
    return rowmajorSum + colmajorSum 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
    var M : int ; M := 3 ;
     OclFile["System.out"].println(trace(N, M)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    char[][] field=new char[h][];
    int[][] orbs=new int[h+1][w+1];
    int[][] ingots=new int[h+1][w+1];
    for(int i=0 ; i<h ; i++){
      field[i]=sc.next().toCharArray();
      for(int j=w-1 ; j>=0 ; j--){
        orbs[i][j]=orbs[i][j+1];
        if(field[i][j]=='O'){
          orbs[i][j]++;
        }
      }
    }
    for(int j=0 ; j<w ; j++){
      for(int i=h-1 ; i>=0 ; i--){
        ingots[i][j]=ingots[i+1][j];
        if(field[i][j]=='I'){
          ingots[i][j]++;
        }
      }
    }
    long total=0 ;
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        if(field[i][j]=='J'){
          total+=orbs[i][j]*ingots[i][j];
        }
      }
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var field : Sequence(Sequence(String)) ; field := Integer.subrange(1,h)->collect(Sequence{}) ;
    var orbs : Sequence(Sequence(int)) ; orbs := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(0)) ;
    var ingots : Sequence(Sequence(int)) ; ingots := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (     field[i+1] := sc.getCurrent()->characters() ; 
         var j : int ; j := w - 1 ; while j >= 0 do ( (     orbs[i+1][j+1] := orbs[i+1][j + 1+1] ; 
     if (field[i+1][j+1] = 'O') then (     orbs[i+1][j+1] := orbs[i+1][j+1] + 1 ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < w do ( (         var i : int ; i := h - 1 ; while i >= 0 do ( (     ingots[i+1][j+1] := ingots[i + 1+1][j+1] ; 
     if (field[i+1][j+1] = 'I') then (     ingots[i+1][j+1] := ingots[i+1][j+1] + 1 ) else skip )  ;     i := i - 1 ) )  ;     j := j + 1 ) ; 
    var total : long ; total := 0 ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (field[i+1][j+1] = 'J') then (     total := total+(orbs[i+1][j+1] * ingots[i+1][j+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long n=in.nextLong(),k=in.nextLong();
    long re=((n/k)+1)*k ;
    System.out.println(re);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toLong() ;
    var k : long ; k := in.getCurrent()->toLong() ;
     var re : long ; re := ((n / k) + 1) * k ;
     OclFile["System.out"].println(re) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countDivisors(int n,int k){
    int count=0,i ;
    for(i=1 ; i<=n ; i++){
      if(n % i==0 && i % k==0){
        count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int n=12,k=3 ;
    System.out.println(countDivisors(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDivisors( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
    var i : int ;
         i := 1 ; while i <= n do ( (     if (n mod i = 0 & i mod k = 0) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
    var k : int ; k := 3 ;
     OclFile["System.out"].println(countDivisors(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countDivisors(int n,int k){
    int count=0,i ;
    for(i=1 ; i<Math.sqrt(n); i++){
      if(n % i==0){
        if(i % k==0){
          count++;
        }
        if((n/i)% k==0){
          count++;
        }
      }
    }
    if((i*i==n)&&(i % k==0)){
      count--;
    }
    return count ;
  }
  public static void main(String[] args){
    int n=12,k=3 ;
    System.out.println(countDivisors(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDivisors( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
    var i : int ;
         i := 1 ; while i < (n)->sqrt() do ( (     if (n mod i = 0) then (     if (i mod k = 0) then (     count := count + 1 ) else skip ; 
     if ((n / i) mod k = 0) then (     count := count + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
     if ((i * i = n) & (i mod k = 0)) then (     count := count - 1 ) else skip ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
    var k : int ; k := 3 ;
     OclFile["System.out"].println(countDivisors(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int power(int x,int y,int p){
    int res=1 ;
    x=x % p ;
    while(y>0){
      if(y % 2==1)res=(res*x)% p ;
      y=y>>1 ;
      x=(x*x)% p ;
    }
    return res ;
  }
  static int findModuloByM(int X,int N,int M){
    if(N<6){
      String temp="" ;
      for(int i=0 ; i<N ; i++)temp=temp+(char)(X+48);
      int res=Integer.parseInt(temp)% M ;
      return res ;
    }
    if(N % 2==0){
      int half=findModuloByM(X,N/2,M)% M ;
      int res=(half*power(10,N/2,M)+half)% M ;
      return res ;
    }
    else {
      int half=findModuloByM(X,N/2,M)% M ;
      int res=(half*power(10,N/2+1,M)+half*10+X)% M ;
      return res ;
    }
  }
  public static void main(String[] args){
    int X=6,N=14,M=9 ;
    System.out.println(findModuloByM(X,N,M));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation power( x : int, y : int, p : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     if (y mod 2 = 1) then     res := (res * x) mod p ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res );
  static   operation findModuloByM( X : int, N : int, M : int) : int
  pre: true
  post: true
  activity: (     if (N < 6) then (     var temp : String ; temp := "" ;
         var i : int ; i := 0 ; while i < N do (     temp := temp + (X + 48)->oclAsType(String) ;  ;     i := i + 1 ) ; 
     var res : int ; res := (temp)->toInteger() mod M ;
     return res ) else skip ; 
     if (N mod 2 = 0) then (     var half : int ; half := findModuloByM(X, N / 2, M) mod M ;
     var res : int ; res := (half * power(10, N / 2, M) + half) mod M ;
     return res ) else (     var half : int ; half := findModuloByM(X, N / 2, M) mod M ;
     var res : int ; res := (half * power(10, N / 2 + 1, M) + half * 10 + X) mod M ;
     return res ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 6 ;
    var N : int ; N := 14 ;
    var M : int ; M := 9 ;
     OclFile["System.out"].println(findModuloByM(X, N, M)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class IntegerPoints {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    long out[]=new long[t];
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int p2=0 ;
      for(int j=0 ; j<n ; j++){
        p2+=(sc.nextInt()% 2+1)% 2 ;
      }
      int m=sc.nextInt();
      int q2=0 ;
      for(int j=0 ; j<m ; j++){
        q2+=(sc.nextInt()% 2+1)% 2 ;
      }
      out[i]=(long)p2*q2+(long)(n-p2)*(m-q2);
    }
    for(int i=0 ; i<t ; i++){
      System.out.println(out[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class IntegerPoints {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var out : Sequence(long) ; out := Integer.subrange(1,t)->collect(0) ;
        var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var p2 : int ; p2 := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     p2 := p2+((sc.getCurrent()->toInteger() mod 2 + 1) mod 2) )  ;     j := j + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var q2 : int ; q2 := 0 ;
        var j : int ; j := 0 ; while j < m do ( (     q2 := q2+((sc.getCurrent()->toInteger() mod 2 + 1) mod 2) )  ;     j := j + 1 ) ; 
    out[i+1] := p2->oclAsType(long) * q2 + (n - p2)->oclAsType(long) * (m - q2) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < t do ( (     OclFile["System.out"].println(out[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; tc++){
      int[] p=readArray(sc);
      int[] q=readArray(sc);
      System.out.println(solve(p,q));
    }
    sc.close();
  }
  static int[] readArray(Scanner sc){
    int size=sc.nextInt();
    int[] result=new int[size];
    for(int i=0 ; i<result.length ; i++){
      result[i]=sc.nextInt();
    }
    return result ;
  }
  static long solve(int[] p,int[] q){
    int evenCountP=(int)Arrays.stream(p).filter(x->x % 2==0).count();
    int oddCountP=(int)Arrays.stream(p).filter(x->x % 2!=0).count();
    int evenCountQ=(int)Arrays.stream(q).filter(x->x % 2==0).count();
    int oddCountQ=(int)Arrays.stream(q).filter(x->x % 2!=0).count();
    return(long)evenCountP*evenCountQ+(long)oddCountP*oddCountQ ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var p : Sequence(int) ; p := readArray(sc) ;
     var q : Sequence(int) ; q := readArray(sc) ;
     OclFile["System.out"].println(solve(p, q)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation readArray( sc : OclFile) : Sequence(int)
  pre: true
  post: true
  activity: (     var size : int ; size := sc.getCurrent()->toInteger() ;
     var result : Sequence(int) ; result := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < result->size() do ( (     result[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return result );
  static   operation solve( p : Sequence(int), q : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var evenCountP : int ; evenCountP := stream(p)->select( _x1 | (lambda x : OclAny in x mod 2 = 0)->apply(_x1) )->size()->oclAsType(int) ;
     var oddCountP : int ; oddCountP := stream(p)->select( _x1 | (lambda x : OclAny in x mod 2 /= 0)->apply(_x1) )->size()->oclAsType(int) ;
    var evenCountQ : int ; evenCountQ := stream(q)->select( _x1 | (lambda x : OclAny in x mod 2 = 0)->apply(_x1) )->size()->oclAsType(int) ;
    var oddCountQ : int ; oddCountQ := stream(q)->select( _x1 | (lambda x : OclAny in x mod 2 /= 0)->apply(_x1) )->size()->oclAsType(int) ;
    return evenCountP->oclAsType(long) * evenCountQ + oddCountP->oclAsType(long) * oddCountQ 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findMaxDiff(int arr[],int n){
    if(n<2){
      System.out.println("Invalid ");
      return 0 ;
    }
    int min_val=Integer.MAX_VALUE,max_val=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      if((arr[i]-i)>max_val)max_val=arr[i]-i ;
      if((arr[i]-i)<min_val)min_val=arr[i]-i ;
    }
    return(max_val-min_val);
  }
  public static void main(String[] args){
    int arr[]={
      9,15,4,12,13 };
      int n=arr.length ;
      System.out.println(findMaxDiff(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMaxDiff( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n < 2) then (     OclFile["System.out"].println("Invalid ") ; 
     return 0 ) else skip ; 
     var min_val : int ; min_val := 2147483647 ;
    var max_val : int ; max_val := -2147483648 ;
         var i : int ; i := 0 ; while i < n do ( (     if ((arr[i+1] - i) > max_val) then     max_val := arr[i+1] - i ; else skip ; 
     if ((arr[i+1] - i) < min_val) then     min_val := arr[i+1] - i ; else skip )  ;     i := i + 1 ) ; 
     return (max_val - min_val) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{9,15,4,12,13} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMaxDiff(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float getAvg(float prev_avg,float x,int n){
    return(prev_avg*n+x)/(n+1);
  }
  static void streamAvg(float arr[],int n){
    float avg=0 ;
    for(int i=0 ; i<n ; i++){
      avg=getAvg(avg,arr[i],i);
      System.out.printf("Average of %d numbers is %f \n",i+1,avg);
    }
    return ;
  }
  public static void main(String[] args){
    float arr[]={
      10,20,30,40,50,60 };
      int n=arr.length ;
      streamAvg(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getAvg( prev_avg : double, x : double, n : int) : double
  pre: true
  post: true
  activity: (     return (prev_avg * n + x) / (n + 1) );
  static   operation streamAvg( arr : Sequence(double), n : int) : void
  pre: true
  post: true
  activity: (     var avg : double ; avg := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     avg := getAvg(avg, arr[i+1], i) ; 
     OclFile["System.out"].printf("Average of %d numbers is %f \n", i + 1, avg) )  ;     i := i + 1 ) ; 
     return );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(double) ; arr := Sequence{10,20,30,40,50,60} ;
     var n : int ; n := arr->size() ;
     execute streamAvg(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B1150 {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[][] arr=new String[n][n];
    for(int i=0 ; i<n ; i++){
      String line=br.readLine();
      for(int k=0 ; k<n ; k++){
        arr[i][k]=line.charAt(k)+"" ;
      }
    }
    System.out.println(solve(arr,n));
  }
  public static String solve(String[][] arr,int n){
    for(int i=0 ; i<n ; i++){
      for(int k=0 ; k<n ; k++){
        if(arr[i][k] .equals(".")){
          if(i+2<n && k+1<n && k-1>=0){
            if(arr[i][k] .equals(".")&& arr[i+1][k] .equals(".")&& arr[i+1][k-1] .equals(".")&& arr[i+1][k+1] .equals(".")&& arr[i+2][k] .equals(".")){
              arr[i][k]="#" ;
              arr[i+1][k]="#" ;
              arr[i+1][k-1]="#" ;
              arr[i+1][k+1]="#" ;
              arr[i+2][k]="#" ;
            }
            else {
              return "NO" ;
            }
          }
          else {
            return "NO" ;
          }
        }
      }
    }
    return "YES" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1150 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var arr : Sequence(Sequence(String)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(null)) ;
        var i : int ; i := 0 ; while i < n do ( (     var line : String ; line := br.readLine() ;
         var k : int ; k := 0 ; while k < n do ( (     arr[i+1][k+1] := line->at(k+1) + "" )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(arr, n)) ; 
 );
  static   operation solve( arr : Sequence(Sequence(String)), n : int) : String
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (         var k : int ; k := 0 ; while k < n do ( (     if (arr[i+1][k+1] = ".") then (     if (i + 2 < n & k + 1 < n & (k)->char2byte() - 1 >= 0) then (     if (arr[i+1][k+1] = "." & arr[i + 1+1][k+1] = "." & arr[i + 1+1][(k)->char2byte() - 1+1] = "." & arr[i + 1+1][k + 1+1] = "." & arr[i + 2+1][k+1] = ".") then (     arr[i+1][k+1] := "#" ; 
     arr[i + 1+1][k+1] := "#" ; 
    arr[i + 1+1][(k)->char2byte() - 1+1] := "#" ; 
    arr[i + 1+1][k + 1+1] := "#" ; 
    arr[i + 2+1][k+1] := "#" ; 
 ) else (     return "NO" ) ) else (     return "NO" ) ) else skip )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
     return "YES" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int numberOfPaths(int m,int n){
    int count[][]=new int[m][n];
    for(int i=0 ; i<m ; i++)count[i][0]=1 ;
    for(int j=0 ; j<n ; j++)count[0][j]=1 ;
    for(int i=1 ; i<m ; i++){
      for(int j=1 ; j<n ; j++)count[i][j]=count[i-1][j]+count[i][j-1];
    }
    return count[m-1][n-1];
  }
  public static void main(String args[]){
    System.out.println(numberOfPaths(3,3));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation numberOfPaths( m : int, n : int) : int
  pre: true
  post: true
  activity: (     var count : Sequence(Sequence(int)) ; count := Integer.subrange(1,m)->collect(Integer.subrange(1,n)->collect(0)) ;
         var i : int ; i := 0 ; while i < m do (     count[i+1][0+1] := 1 ;  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < n do (     count[0+1][j+1] := 1 ;  ;     j := j + 1 ) ; 
        var i : int ; i := 1 ; while i < m do ( (         var j : int ; j := 1 ; while j < n do (     count[i+1][j+1] := count[i - 1+1][j+1] + count[i+1][j - 1+1] ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return count[m - 1+1][n - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(numberOfPaths(3, 3)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Arrays ;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      long a[]=new long[n];
      long sum=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextLong();
        sum+=a[i];
      }
      if(sum % n!=0){
        System.out.println("NO");
      }
      else {
        sum/=n ;
        boolean flag=false ;
        for(int i=0 ; i<n ; i++){
          if(a[i]==sum){
            flag=true ;
            break ;
          }
        }
        if(flag){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    if (sum mod n /= 0) then (     OclFile["System.out"].println("NO") ) else (     sum := sum/(n) ; 
     var flag : boolean ; flag := false ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = sum) then (     flag := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (flag) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      double a[]=new double[n];
      double sum=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=input.nextDouble();
        sum+=a[i];
      }
      for(int i=0 ; i<n ; i++){
        double now=(sum-a[i])/(n-1);
        if(now==a[i]){
          System.out.println("YES");
          continue work ;
        }
      }
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := input.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.getCurrent()->toInteger() ;
     var a : Sequence(double) ; a := Integer.subrange(1,n)->collect(0.0) ;
    var sum : double ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.getCurrent()->toReal() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var now : double ; now := (sum - a[i+1]) / (n - 1) ;
     if (now = a[i+1]) then (     OclFile["System.out"].println("YES") ; 
     continue ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void printKPFNums(int A,int B,int K){
    boolean prime[]=new boolean[B+1];
    Arrays.fill(prime,true);
    int p_factors[]=new int[B+1];
    Arrays.fill(p_factors,0);
    for(int p=2 ; p<=B ; p++)if(p_factors[p]==0)for(int i=p ; i<=B ; i+=p)p_factors[i]++;
    for(int i=A ; i<=B ; i++)if(p_factors[i]==K)System.out.print(i+" ");
  }
  public static void main(String args[]){
    int A=14,B=18,K=2 ;
    printKPFNums(A,B,K);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printKPFNums( A : int, B : int, K : int) : void
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,B + 1)->collect(false) ;
     prime := prime->collect(true) ; 
    var p_factors : Sequence(int) ; p_factors := Integer.subrange(1,B + 1)->collect(0) ;
    p_factors := p_factors->collect(0) ; 
        var p : int ; p := 2 ; while p <= B do (     if (p_factors[p+1] = 0) then         var i : int ; i := p ; while i <= B do (     p_factors[i+1] := p_factors[i+1] + 1 ;  ;     i := i+(p) ) ; else skip ;  ;     p := p + 1 ) ; 
        var i : int ; i := A ; while i <= B do (     if (p_factors[i+1] = K) then     OclFile["System.out"].print(i + " ") ; else skip ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 14 ;
    var B : int ; B := 18 ;
    var K : int ; K := 2 ;
     execute printKPFNums(A, B, K) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class C1686A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=in.nextInt();
      int sum=0 ;
      int[] a=new int[n];
      for(int j=0 ; j<n ; j++){
        a[j]=in.nextInt();
        sum+=a[j];
      }
      boolean f=false ;
      for(int x=0 ; x<n ; x++){
        if(a[x]*n==sum)f=true ;
      }
      if(f){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C1686A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var sum : int ; sum := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     a[j+1] := in.getCurrent()->toInteger() ; 
     sum := sum+(a[j+1]) )  ;     j := j + 1 ) ; 
    var f : boolean ; f := false ;
        var x : int ; x := 0 ; while x < n do ( (     if (a[x+1] * n = sum) then     f := true ; else skip )  ;     x := x + 1 ) ; 
    if (f) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    while(t--!=0){
      int n=input.nextInt(),sum=0 ;
      int[] arr=new int[n];
      boolean flag=false ;
      for(int i=0 ; i<n ; i++){
        arr[i]=input.nextInt();
        sum+=arr[i];
      }
      for(int i=0 ; i<n ; i++){
        if(arr[i]*n==sum){
          flag=true ;
          break ;
        }
      }
      System.out.println(flag ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := input.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := input.getCurrent()->toInteger() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] * n = sum) then (     flag := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if flag then "YES" else "NO" endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isKthBitSet(int n,int k){
    if((n>>(k-1))==1)return true ;
    return false ;
  }
  static int setKthBit(int n,int k){
    return((1<<(k-1))| n);
  }
  static boolean allBitsAreSet(int n){
    if(((n+1)& n)==0)return true ;
    return false ;
  }
  static boolean bitsAreInAltOrder(int n){
    int num=n ^(n>>1);
    return allBitsAreSet(num);
  }
  static boolean bitsAreInAltPatrnInGivenRange(int n,int l,int r){
    int num,left_shift ;
    if(isKthBitSet(n,r)){
      num=n ;
      left_shift=r ;
    }
    else {
      num=setKthBit(n,(r+1));
      left_shift=r+1 ;
    }
    num=num &((1<<left_shift)-1);
    num=num>>(l-1);
    return bitsAreInAltOrder(num);
  }
  public static void main(String[] args){
    int n=18 ;
    int l=1,r=3 ;
    if(bitsAreInAltPatrnInGivenRange(n,l,r))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isKthBitSet( n : int, k : int) : boolean
  pre: true
  post: true
  activity: (     if (((n/(2->pow((k - 1))))->oclAsType(long)) = 1) then     return true else skip ; 
     return false );
  static   operation setKthBit( n : int, k : int) : int
  pre: true
  post: true
  activity: (     return (((1*(2->pow((k - 1))))->oclAsType(long)) or n) );
  static   operation allBitsAreSet( n : int) : boolean
  pre: true
  post: true
  activity: (     if (((n + 1) & n) = 0) then     return true else skip ; 
     return false );
  static   operation bitsAreInAltOrder( n : int) : boolean
  pre: true
  post: true
  activity: (     var num : int ; num := MathLib.bitwiseXor(n,((n/(2->pow(1)))->oclAsType(long))) ;
     return allBitsAreSet(num) );
  static   operation bitsAreInAltPatrnInGivenRange( n : int, l : int, r : int) : boolean
  pre: true
  post: true
  activity: (     var num : int ;
    var left_shift : int ;
     if (isKthBitSet(n, r)) then (     num := n ; 
     left_shift := r ) else (     num := setKthBit(n, (r + 1)) ; 
     left_shift := r + 1 ) ;  
    num := MathLib.bitwiseAnd(num,(((1*(2->pow(left_shift)))->oclAsType(long)) - 1)) ; 
    num := (num/(2->pow((l - 1))))->oclAsType(long) ; 
    return bitsAreInAltOrder(num) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 18 ;
     var l : int ; l := 1 ;
    var r : int ; r := 3 ;
     if (bitsAreInAltPatrnInGivenRange(n, l, r)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int factorial(int n){
    if(n<=1)return 1 ;
    return n*factorial(n-1);
  }
  static int nCr(int n,int r){
    return factorial(n)/(factorial(n-r)*factorial(r));
  }
  static int NumberOfWays(int n,int x,int y){
    return nCr(2*n-x-y,n-x)*factorial(n)*factorial(n);
  }
  public static void main(String[] args)throws java.lang.Exception {
    int n=5,x=4,y=2 ;
    System.out.println(NumberOfWays(n,x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation factorial( n : int) : int
  pre: true
  post: true
  activity: (     if (n <= 1) then     return 1 else skip ; 
     return n * factorial(n - 1) );
  static   operation nCr( n : int, r : int) : int
  pre: true
  post: true
  activity: (     return factorial(n) / (factorial(n - r) * factorial(r)) );
  static   operation NumberOfWays( n : int, x : int, y : int) : int
  pre: true
  post: true
  activity: (     return nCr(2 * n - x - y, n - x) * factorial(n) * factorial(n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var x : int ; x := 4 ;
    var y : int ; y := 2 ;
     OclFile["System.out"].println(NumberOfWays(n, x, y)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static String commonPrefixUtil(String str1,String str2){
    String result="" ;
    int n1=str1.length(),n2=str2.length();
    for(int i=0,j=0 ; i<=n1-1 && j<=n2-1 ; i++,j++){
      if(str1.charAt(i)!=str2.charAt(j)){
        break ;
      }
      result+=str1.charAt(i);
    }
    return(result);
  }
  static void commonPrefix(String arr[],int n){
    Arrays.sort(arr);
    System.out.println(commonPrefixUtil(arr[0],arr[n-1]));
  }
  public static void main(String[] args){
    String arr[]={
      "geeksforgeeks","geeks","geek","geezer" };
      int n=arr.length ;
      commonPrefix(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation commonPrefixUtil( str1 : String, str2 : String) : String
  pre: true
  post: true
  activity: (     var result : String ; result := "" ;
     var n1 : int ; n1 := str1->size() ;
    var n2 : int ; n2 := str2->size() ;
         var i : int ; i := 0 ;
    var j : int ; j := 0 ; while i <= (n1)->char2byte() - 1 & j <= (n2)->char2byte() - 1 do ( (     if (str1->at(i+1) /= str2->at(j+1)) then (     break ) else skip ; 
     result := result+(str1->at(i+1)) )  ;     i := i + 1 ;     j := j + 1 ) ; 
     return (result) );
  static   operation commonPrefix( arr : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     OclFile["System.out"].println(commonPrefixUtil(arr[0+1], arr[n - 1+1])) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"geeksforgeeks","geeks","geek","geezer"} ;
     var n : int ; n := arr->size() ;
     execute commonPrefix(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p050 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p050().run());
  }
  private static final int LIMIT=Library.pow(10,6);
  public String run(){
    boolean[] isPrime=Library.listPrimality(LIMIT);
    int[] primes=Library.listPrimes(LIMIT);
    long maxSum=0 ;
    int maxRun=-1 ;
    for(int i=0 ; i<primes.length ; i++){
      int sum=0 ;
      for(int j=i ; j<primes.length ; j++){
        sum+=primes[j];
        if(sum>LIMIT)break ;
        else if(j-i>maxRun && sum>maxSum && isPrime[sum]){
          maxSum=sum ;
          maxRun=j-i ;
        }
      }
    }
    return Long.toString(maxSum);
  }
}
------------------------------------------------------------
OCL File:
---------
class p050 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p050.newp050().run()) );
  static    attribute LIMIT : int := Library.pow(10, 6);
   operation run() : String
  pre: true
  post: true
  activity: (     var isPrime : Sequence(boolean) ; isPrime := Library.listPrimality(LIMIT) ;
     var primes : Sequence(int) ; primes := Library.listPrimes(LIMIT) ;
    var maxSum : long ; maxSum := 0 ;
    var maxRun : int ; maxRun := -1 ;
        var i : int ; i := 0 ; while i < primes->size() do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := i ; while j < primes->size() do ( (     sum := sum+(primes[j+1]) ; 
     if (sum > LIMIT) then     break else     if (j - i > maxRun & sum > maxSum & isPrime[sum+1]) then (     maxSum := sum ; 
     maxRun := j - i ) else skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return ((maxSum) + "") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long a[]=new long[N*3];
    for(int i=0 ; i<N*3 ; i++){
      a[i]=sc.nextLong();
    }
    Arrays.sort(a);
    long sum=0 ;
    for(int i=N ; i<3*N ; i+=2){
      sum+=a[i];
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,N * 3)->collect(0) ;
        var i : int ; i := 0 ; while i < N * 3 do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := N ; while i < 3 * N do ( (     sum := sum+(a[i+1]) )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] array=new int[3*n];
    for(int i=0 ; i<array.length ; i++)array[i]=sc.nextInt();
    Arrays.sort(array);
    int head=array.length-2 ;
    long res=0 ;
    for(int i=0 ; i<n ; i++){
      res+=array[head];
      head-=2 ;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,3 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < array->size() do (     array[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    array := array->sort() ; 
    var head : int ; head := array->size() - 2 ;
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     res := res+(array[head+1]) ; 
     head := head-(2) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
final class Solver {
  static final Solver INSTANCE=new Solver();
  void solve(Scanner sc){
    int N=sc.nextInt();
    int[] A=new int[3*N];
    for(int i=0 ; i<A.length ; i++){
      A[i]=sc.nextInt();
    }
    Arrays.sort(A);
    long sum=0 ;
    for(int i=N ; i<A.length ; i+=2){
      sum+=A[i];
    }
    System.out.println(sum);
  }
}
class Main {
  public static void main(String...args){
    Scanner in=new Scanner(System.in);
    Solver.INSTANCE.solve(in);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solver {
  static    attribute INSTANCE : Solver := Solver.newSolver();
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.nextInt() ;
     var A : Sequence(int) ; A := Integer.subrange(1,3 * N)->collect(0) ;
        var i : int ; i := 0 ; while i < A->size() do ( (     A[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := N ; while i < A->size() do ( (     sum := sum+(A[i+1]) )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Solver.INSTANCE.solve(in) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[] persons=new long[3*N];
    for(int i=0 ; i<3*N ; i++){
      persons[i]=sc.nextLong();
    }
    Arrays.sort(persons);
    long sum=0 ;
    for(int i=N ; i<3*N ; i+=2){
      sum+=persons[i];
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var persons : Sequence(long) ; persons := Integer.subrange(1,3 * N)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 * N do ( (     persons[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    persons := persons->sort() ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := N ; while i < 3 * N do ( (     sum := sum+(persons[i+1]) )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    java.util.Scanner s=new java.util.Scanner(System.in);
    int n=s.nextInt();
    BigInteger array[]=new BigInteger[n*3];
    for(int i=0 ; i<array.length ; i++){
      array[i]=BigInteger.valueOf(s.nextInt());
    }
    s.close();
    System.out.println(Main.calc(n,array));
  }
  private static BigInteger calc(int n,BigInteger[] array){
    BigInteger res=BigInteger.ZERO ;
    java.util.Arrays.sort(array,java.util.Collections.reverseOrder());
    for(int i=0 ; i<n ; i++){
      res=res.add(array[1+i*2]);
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Scanner ; s := Scanner.newScanner(OclFile["System.in"]) ;
     var n : int ; n := s.nextInt() ;
    var array : Sequence(long) ; array := Integer.subrange(1,n * 3)->collect(null) ;
        var i : int ; i := 0 ; while i < array->size() do ( (     array[i+1] := (s.nextInt() + "")->toLong() )  ;     i := i + 1 ) ; 
    s.close() ; 
    OclFile["System.out"].println(Main.calc(n, array)) ; 
 );
  static   operation calc( n : int, array : Sequence(long)) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 0 ;
     java.util.Arrays.sort(array, java.util.Collections.reverseOrder()) ; 
         var i : int ; i := 0 ; while i < n do ( (     res := res->excludes(array[1 + i * 2+1]) )  ;     i := i + 1 ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void reverseWords(String str){
    Stack<Character>st=new Stack<Character>();
    for(int i=0 ; i<str.length(); ++i){
      if(str.charAt(i)!=' ')st.push(str.charAt(i));
      else {
        while(st.empty()==false){
          System.out.print(st.pop());
        }
        System.out.print(" ");
      }
    }
    while(st.empty()==false){
      System.out.print(st.pop());
    }
  }
  public static void main(String[] args){
    String str="Geeks for Geeks" ;
    reverseWords(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation reverseWords( str : String) : void
  pre: true
  post: true
  activity: (     var st : Sequence(String) ; st := Sequence{} ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) /= ' ') then     st := st->append(str->at(i+1)) ; else (     while (st->isEmpty() = false) do (     OclFile["System.out"].print(st->last()) ) ; 
     OclFile["System.out"].print(" ") ) )  ;     i := i + 1 ) ; 
     while (st->isEmpty() = false) do (     OclFile["System.out"].print(st->last()) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "Geeks for Geeks" ;
     execute reverseWords(str) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] a=new int[N+1];
    for(int i=1 ; i<N+1 ; i++){
      a[i]=sc.nextInt();
    }
    sc.close();
    int count=0 ;
    boolean valid=true ;
    int current=1 ;
    while(valid){
      count++;
      current=a[current];
      if(current==2){
        valid=false ;
      }
      if(count==N){
        count=0 ;
        valid=false ;
      }
    }
    if(count==0){
      System.out.println(-1);
    }
    else {
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i < N + 1 do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var count : int ; count := 0 ;
    var valid : boolean ; valid := true ;
    var current : int ; current := 1 ;
    while (valid) do (     count := count + 1 ; 
     current := a[current+1] ; 
     if (current = 2) then (     valid := false ) else skip ; 
     if (count = N) then (     count := 0 ; 
     valid := false ) else skip ) ; 
    if (count = 0) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(count) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  InputStream in=System.in ;
  PrintStream out=System.out ;
  public void _main(String[] args){
    Scanner sc=new Scanner(in);
    int N=sc.nextInt();
    int[] a=new int[N+1];
    for(int i=1 ; i<=N ; i++){
      a[i]=sc.nextInt();
    }
    boolean[] visited=new boolean[N+1];
    sc.close();
    int p=1 ;
    int ans=0 ;
    while(true){
      if(p==2){
        break ;
      }
      if(visited[a[p] ]){
        ans=-1 ;
        break ;
      }
      p=a[p];
      visited[p]=true ;
      ans++;
    }
    out.println(ans);
  }
  public static void main(String[] args){
    new Main()._main(args);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile["System.in"];
   attribute out : OclFile := OclFile["System.out"];
   operation _main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,N + 1)->collect(false) ;
    skip ; 
    var p : int ; p := 1 ;
    var ans : int ; ans := 0 ;
    while (true) do (     if (p = 2) then (     break ) else skip ; 
     if (visited[a[p+1]+1]) then (     ans := -1 ; 
     break ) else skip ; 
    p := a[p+1] ; 
    visited[p+1] := true ; 
    ans := ans + 1 ; 
 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain()._main(args) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    try {
      InputStreamReader isr=new InputStreamReader(System.in);
      BufferedReader br=new BufferedReader(isr);
      int n=Integer.parseInt(br.readLine());
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=Integer.parseInt(br.readLine());
      }
      int now=a[0];
      int count=1 ;
      boolean flag=false ;
      while(count<n){
        if(now==2){
          System.out.println(count);
          flag=true ;
          break ;
        }
        now=a[now-1];
        count++;
      }
      if(! flag){
        System.out.println(-1);
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    var now : int ; now := a[0+1] ;
    var count : int ; count := 1 ;
    var flag : boolean ; flag := false ;
    while (count < n) do (     if (now = 2) then (     OclFile["System.out"].println(count) ; 
     flag := true ; 
     break ) else skip ; 
     now := a[now - 1+1] ; 
     count := count + 1 ) ; 
    if (not(flag)) then (     OclFile["System.out"].println(-1) ) else skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static Scanner scan=new Scanner(System.in);
  private static int N ;
  private static int[] a ;
  private static int count=0 ;
  public static void main(String[] args){
    N=Integer.parseInt(scan.next());
    a=new int[N];
    for(int i=0 ; i<N ; i++){
      int index=Integer.parseInt(scan.next())-1 ;
      a[i]=index ;
    }
    System.out.println(check(0)? count :-1);
    scan.close();
  }
  private static boolean check(int index){
    if(count>=N)return false ;
    count++;
    return a[index]==1 ? true : check(a[index]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int;
  static   attribute a : Sequence(int);
  static   attribute count : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     N := (scan.getCurrent())->toInteger() ; 
     a := Integer.subrange(1,N)->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     var index : int ; index := (scan.getCurrent())->toInteger() - 1 ;
     a[i+1] := index )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if check(0) then count else -1 endif) ; 
    skip ; 
 );
  static   operation check( index : int) : boolean
  pre: true
  post: true
  activity: (     if (count >= N) then     return false else skip ; 
     count := count + 1 ; 
     return if a[index+1] = 1 then true else check(a[index+1]) endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int lis(int[] arr,int n){
    int max=0 ;
    int[] lst=new int[n];
    Arrays.fill(lst,1);
    for(int i=1 ; i<n ; i++){
      for(int j=0 ; j<i ; j++){
        if(arr[i]>arr[j] && lst[i]<lst[j]+1)lst[i]=lst[j]+1 ;
      }
    }
    for(int i=0 ; i<n ; i++)if(max<lst[i])max=lst[i];
    return max ;
  }
  public static void main(String[] args){
    int[] arr={
      10,22,9,33,21,50,41,60 };
      int n=arr.length ;
      System.out.println("Length of lis is "+lis(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation lis( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max : int ; max := 0 ;
     var lst : Sequence(int) ; lst := Integer.subrange(1,n)->collect(0) ;
    lst := lst->collect(1) ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 0 ; while j < i do ( (     if (arr[i+1] > arr[j+1] & lst[i+1] < lst[j+1] + 1) then     lst[i+1] := lst[j+1] + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     if (max < lst[i+1]) then     max := lst[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    return max 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,22,9,33,21,50,41,60} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Length of lis is " + lis(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=Integer.parseInt(sc.next());
      ArrayList<Integer>list=new ArrayList<>();
      ArrayList<Boolean>boolList=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        list.add(Integer.parseInt(sc.next()));
        boolList.add(false);
      }
      int light=0 ;
      int ans=0 ;
      while(light!=1 && boolList.get(light)==false){
        boolList.set(light,true);
        int newLight=list.get(light)-1 ;
        light=newLight ;
        ans++;
      }
      if(light==1)System.out.println(ans);
      else System.out.println(-1);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := (sc.getCurrent())->toInteger() ;
     var list : Sequence(int) ; list := Sequence{} ;
    var boolList : Sequence(Boolean) ; boolList := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including((sc.getCurrent())->toInteger()) ; 
     boolList := boolList->including(false) )  ;     i := i + 1 ) ; 
    var light : int ; light := 0 ;
    var ans : int ; ans := 0 ;
    while (light /= 1 & boolList->at(light+1) = false) do (     boolList := boolList.setAt(light+1,true) ; 
     var newLight : int ; newLight := list->at(light+1) - 1 ;
     light := newLight ; 
     ans := ans + 1 ) ; 
    if (light = 1) then     OclFile["System.out"].println(ans) else     OclFile["System.out"].println(-1) ; ;  
 ))   catch (e : ProgramException) do (     e.printStackTrace() )
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p301 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p301().run());
  }
  public String run(){
    int a=0 ;
    int b=1 ;
    for(int i=0 ; i<32 ; i++){
      int c=a+b ;
      a=b ;
      b=c ;
    }
    return Integer.toString(a);
  }
}
------------------------------------------------------------
OCL File:
---------
class p301 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p301.newp301().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var a : int ; a := 0 ;
     var b : int ; b := 1 ;
         var i : int ; i := 0 ; while i < 32 do ( (     var c : int ; c := a + b ;
     a := b ; 
     b := c )  ;     i := i + 1 ) ; 
     return ((a) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findFrequencyUtil(int arr[],int low,int high,int[] freq){
    if(arr[low]==arr[high]){
      freq[arr[low] ]+=high-low+1 ;
    }
    else {
      int mid=(low+high)/2 ;
      findFrequencyUtil(arr,low,mid,freq);
      findFrequencyUtil(arr,mid+1,high,freq);
    }
  }
  static void findFrequency(int arr[],int n){
    int[] freq=new int[arr[n-1]+1];
    findFrequencyUtil(arr,0,n-1,freq);
    for(int i=0 ; i<=arr[n-1]; i++)if(freq[i]!=0)System.out.println("Element "+i+" occurs "+freq[i]+" times");
  }
  public static void main(String[] args){
    int arr[]={
      1,1,1,2,3,3,5,5,8,8,8,9,9,10 };
      int n=arr.length ;
      findFrequency(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findFrequencyUtil( arr : Sequence(int), low : int, high : int, freq : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (arr[low+1] = arr[high+1]) then (     freq[arr[low+1]+1] := freq[arr[low+1]+1]+(high - low + 1) ) else (     var mid : int ; mid := (low + high) / 2 ;
     execute findFrequencyUtil(arr, low, mid, freq) ; 
     execute findFrequencyUtil(arr, mid + 1, high, freq) ) );
  static   operation findFrequency( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,arr[n - 1+1] + 1)->collect(0) ;
     execute findFrequencyUtil(arr, 0, n - 1, freq) ; 
         var i : int ; i := 0 ; while i <= arr[n - 1+1] do (     if (freq[i+1] /= 0) then     OclFile["System.out"].println("Element " + i + " occurs " + freq[i+1] + " times") ; else skip ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,1,2,3,3,5,5,8,8,8,9,9,10} ;
     var n : int ; n := arr->size() ;
     execute findFrequency(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static int changeTable(char a){
    switch(a){
      case 'R' : return 0 ;
      case 'G' : return 1 ;
      case 'B' : return 2 ;
    }
    return-1 ;
  }
  public static char changeTable(int a){
    switch(a){
      case 0 : return 'R' ;
      case 1 : return 'G' ;
      case 2 : return 'B' ;
    }
    return '\0' ;
  }
  public static int restrgb(int t,int s){
    int tmp=s+t ;
    switch(tmp){
      case 1 : return 2 ;
      case 2 : return 1 ;
      case 3 : return 0 ;
    }
    return-1 ;
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    sc.close();
    long ans=0 ;
    int index[][]=new int[3][n+1];
    for(int i=n-1 ; i>=0 ; --i){
      int rgb=changeTable(s.charAt(i));
      for(int j=0 ; j<3 ; ++j){
        index[j][i]=index[j][i+1];
      }
      index[rgb][i]++;
    }
    for(int i=0 ; i<n ; ++i){
      char ti=s.charAt(i);
      int rgbi=changeTable(ti);
      for(int j=i+1 ; j<n ; ++j){
        char tj=s.charAt(j);
        int rgbj=changeTable(tj);
        if(ti==tj)continue ;
        int k=restrgb(rgbi,rgbj);
        char rest=changeTable(k);
        int tmp=2*j-i ;
        if(tmp<n){
          if(s.charAt(tmp)==rest)ans--;
        }
        ans+=(long)index[k][j+1];
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation changeTable( a : String) : int
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (a) ; 
       if _switchval = 'R' then
     return 0 
   else skip ;
       if _switchval = 'G' then
     return 1 
   else skip ;
       if _switchval = 'B' then
     return 2 
   else skip ;
 )
     return -1 );
  static   operation changeTable( a : int) : String
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (a) ; 
       if _switchval = 0 then
     return 'R' 
   else skip ;
       if _switchval = 1 then
     return 'G' 
   else skip ;
       if _switchval = 2 then
     return 'B' 
   else skip ;
 )
     return '\0' );
  static   operation restrgb( t : int, s : int) : int
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := s + t ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (tmp) ; 
       if _switchval = 1 then
     return 2 
   else skip ;
       if _switchval = 2 then
     return 1 
   else skip ;
       if _switchval = 3 then
     return 0 
   else skip ;
 )
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    skip ; 
    var ans : long ; ans := 0 ;
    var index : Sequence(Sequence(int)) ; index := Integer.subrange(1,3)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     var rgb : int ; rgb := changeTable(s->at(i+1)) ;
         var j : int ; j := 0 ; while j < 3 do ( (     index[j+1][i+1] := index[j+1][i + 1+1] )  ;     j := j + 1 ) ; 
     index[rgb+1][i+1] := index[rgb+1][i+1] + 1 )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var ti : String ; ti := s->at(i+1) ;
     var rgbi : int ; rgbi := changeTable(ti) ;
         var j : int ; j := i + 1 ; while j < n do ( (     var tj : String ; tj := s->at(j+1) ;
     var rgbj : int ; rgbj := changeTable(tj) ;
    if (ti = tj) then     continue else skip ; 
    var k : int ; k := restrgb(rgbi, rgbj) ;
    var rest : String ; rest := changeTable(k) ;
    var tmp : int ; tmp := 2 * j - i ;
    if (tmp < n) then (     if (s->at(tmp+1) = rest) then     ans := ans - 1 ; else skip ) else skip ; 
    ans := ans+(index[k+1][j + 1+1]->oclAsType(long)) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    char[] S=scanner.next().toCharArray();
    long[] freq=new long[26];
    for(char ch : S){
      freq[ch-'A']++;
    }
    long count=freq['R'-'A']*freq['G'-'A']*freq['B'-'A'];
    for(int i=1 ; i<N ; i++){
      for(int j=0 ; j+2*i<N ; j++){
        if(S[j]!=S[j+i] && S[j+i]!=S[j+i*2] && S[j]!=S[j+i*2])count--;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var S : Sequence(String) ; S := scanner.getCurrent()->characters() ;
    var freq : Sequence(long) ; freq := Integer.subrange(1,26)->collect(0) ;
    for (ch : S) do ( (     freq[ch - ('A')->char2byte()+1] := freq[ch - ('A')->char2byte()+1] + 1 )  ) ; 
    var count : long ; count := freq[('R')->char2byte() - ('A')->char2byte()+1] * freq[('G')->char2byte() - ('A')->char2byte()+1] * freq[('B')->char2byte() - ('A')->char2byte()+1] ;
        var i : int ; i := 1 ; while i < N do ( (         var j : int ; j := 0 ; while j + 2 * i < N do ( (     if (S[j+1] /= S[j + i+1] & S[j + i+1] /= S[j + i * 2+1] & S[j+1] /= S[j + i * 2+1]) then     count := count - 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    int countr=0 ;
    int countg=0 ;
    int countb=0 ;
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      if((int)s.charAt(i)==(int)'R'){
        countr++;
      }
      if((int)s.charAt(i)==(int)'G'){
        countg++;
      }
      if((int)s.charAt(i)==(int)'B'){
        countb++;
      }
    }
    sum=(long)countr*(long)countg*(long)countb ;
    long countx=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=1 ; j<n ; j++){
        if(i+2*j>=n){
          break ;
        }
        int left=(int)s.charAt(i);
        int center=(int)s.charAt(i+j);
        int right=(int)s.charAt(i+2*j);
        if(left!=center && center!=right && left!=right){
          countx++;
        }
      }
    }
    System.out.println(sum-countx);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var countr : int ; countr := 0 ;
    var countg : int ; countg := 0 ;
    var countb : int ; countb := 0 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1)->oclAsType(int) = ('R')->char2byte()) then (     countr := countr + 1 ) else skip ; 
     if (s->at(i+1)->oclAsType(int) = ('G')->char2byte()) then (     countg := countg + 1 ) else skip ; 
     if (s->at(i+1)->oclAsType(int) = ('B')->char2byte()) then (     countb := countb + 1 ) else skip )  ;     i := i + 1 ) ; 
    sum := (countr)->char2byte() * countg->oclAsType(long) * countb->oclAsType(long) ; 
    var countx : long ; countx := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 1 ; while j < n do ( (     if (i + 2 * j >= n) then (     break ) else skip ; 
     var left : int ; left := s->at(i+1)->oclAsType(int) ;
    var center : int ; center := s->at(i + j+1)->oclAsType(int) ;
    var right : int ; right := s->at(i + 2 * j+1)->oclAsType(int) ;
    if (left /= center & center /= right & left /= right) then (     countx := countx + 1 ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum - countx) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Task {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    int n=scanner.nextInt();
    int[] p=new int[n];
    for(int i=0 ; i<n ; i++){
      p[i]=scanner.nextInt();
    }
    int onlyFistSolve=0 ;
    int onlySecondSolve=0 ;
    for(int i=0 ; i<n ; i++){
      int r=scanner.nextInt();
      if(p[i]==1 && r==0){
        onlyFistSolve++;
      }
      else if(p[i]==0 && r==1){
        onlySecondSolve++;
      }
    }
    if(onlyFistSolve==0){
      System.out.println(-1);
    }
    else {
      System.out.println((onlySecondSolve+onlyFistSolve)/onlyFistSolve);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Task {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var onlyFistSolve : int ; onlyFistSolve := 0 ;
    var onlySecondSolve : int ; onlySecondSolve := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var r : int ; r := scanner.getCurrent()->toInteger() ;
     if (p[i+1] = 1 & r = 0) then (     onlyFistSolve := onlyFistSolve + 1 ) else     if (p[i+1] = 0 & r = 1) then (     onlySecondSolve := onlySecondSolve + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    if (onlyFistSolve = 0) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println((onlySecondSolve + onlyFistSolve) / onlyFistSolve) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    long rc=0 ;
    long gc=0 ;
    long bc=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='R'){
        rc++;
      }
      else if(s.charAt(i)=='G'){
        gc++;
      }
      else {
        bc++;
      }
    }
    long result=rc*gc*bc ;
    for(int i=1 ; i<=n ; i++){
      for(int k=i+1 ; k<=n ; k++){
        if((i+k)% 2==0){
          char is=s.charAt(i-1);
          char ks=s.charAt(k-1);
          char js=s.charAt(((i+k)/2)-1);
          if(is!=ks && ks!=js && js!=is){
            result--;
          }
        }
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var rc : long ; rc := 0 ;
    var gc : long ; gc := 0 ;
    var bc : long ; bc := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'R') then (     rc := rc + 1 ) else     if (s->at(i+1) = 'G') then (     gc := gc + 1 ) else (     bc := bc + 1 ) ;  )  ;     i := i + 1 ) ; 
    var result : long ; result := rc * gc * bc ;
        var i : int ; i := 1 ; while i <= n do ( (         var k : int ; k := i + 1 ; while k <= n do ( (     if ((i + k) mod 2 = 0) then (     var is : String ; is := s->at(i - 1+1) ;
     var ks : String ; ks := s->at(k - 1+1) ;
     var js : String ; js := s->at(((i + k) / 2) - 1+1) ;
     if (is /= ks & ks /= js & js /= is) then (     result := result - 1 ) else skip ) else skip )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sca=new Scanner(System.in);
    int n=sca.nextInt();
    String s=sca.next();
    int[] r=new int[4001];
    int r_index=1 ;
    int[] g=new int[4001];
    ;
    int g_index=1 ;
    int[] b=new int[4001];
    ;
    int b_index=1 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='R'){
        r[r_index]=i+1 ;
        r_index++;
      }
      else if(s.charAt(i)=='G'){
        g[g_index]=i+1 ;
        g_index++;
      }
      else {
        b[b_index]=i+1 ;
        b_index++;
      }
    }
    int[] h=new int[3];
    long max=(long)((r_index-1))*(g_index-1)*(b_index-1);
    for(int i=1 ; i<r_index ; i++){
      for(int j=1 ; j<g_index ; j++){
        int big ;
        int small ;
        if(r[i]>g[j]){
          big=r[i];
          small=g[j];
        }
        else {
          big=g[j];
          small=r[i];
        }
        if(big-small+big<=s.length()){
          if(s.charAt(big-small+big-1)=='B'){
            max--;
          }
        }
        if((small+big)% 2==0 && s.charAt((small+big)/2-1)=='B'){
          max--;
        }
        if(small-(big-small)>0){
          if(s.charAt(small-(big-small)-1)=='B'){
            max--;
          }
        }
      }
    }
    System.out.println(max);
    sca.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sca : OclFile ; sca := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sca.getCurrent()->toInteger() ;
    var s : String ; s := sca.getCurrent() ;
    var r : Sequence(int) ; r := Integer.subrange(1,4001)->collect(0) ;
    var r_index : int ; r_index := 1 ;
    var g : Sequence(int) ; g := Integer.subrange(1,4001)->collect(0) ;
    var g_index : int ; g_index := 1 ;
    var b : Sequence(int) ; b := Integer.subrange(1,4001)->collect(0) ;
    var b_index : int ; b_index := 1 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'R') then (     r[r_index+1] := i + 1 ; 
     r_index := r_index + 1 ) else     if (s->at(i+1) = 'G') then (     g[g_index+1] := i + 1 ; 
     g_index := g_index + 1 ) else (     b[b_index+1] := i + 1 ; 
     b_index := b_index + 1 ) ;  )  ;     i := i + 1 ) ; 
    var h : Sequence(int) ; h := Integer.subrange(1,3)->collect(0) ;
    var max : long ; max := ((r_index - 1))->oclAsType(long) * (g_index - 1) * (b_index - 1) ;
        var i : int ; i := 1 ; while i < r_index do ( (         var j : int ; j := 1 ; while j < g_index do ( (     var big : int ;
     var small : int ;
    if (r[i+1] > g[j+1]) then (     big := r[i+1] ; 
     small := g[j+1] ) else (     big := g[j+1] ; 
     small := r[i+1] ) ;  
    if (big - small + big <= s->size()) then (     if (s->at(big - small + big - 1+1) = 'B') then (     max := max - 1 ) else skip ) else skip ; 
    if ((small + big) mod 2 = 0 & s->at((small + big) / 2 - 1+1) = 'B') then (     max := max - 1 ) else skip ; 
    if (small - (big - small) > 0) then (     if (s->at(small - (big - small) - 1+1) = 'B') then (     max := max - 1 ) else skip ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public final class p070 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p070().run());
  }
  private static final int LIMIT=Library.pow(10,7);
  public String run(){
    int minNumer=1 ;
    int minDenom=0 ;
    int[] totients=Library.listTotients(LIMIT-1);
    for(int n=2 ; n<totients.length ; n++){
      int tot=totients[n];
      if((long)n*minDenom<(long)minNumer*tot && hasSameDigits(n,tot)){
        minNumer=n ;
        minDenom=tot ;
      }
    }
    if(minDenom==0)throw new RuntimeException("Not found");
    return Integer.toString(minNumer);
  }
  private static boolean hasSameDigits(int x,int y){
    char[] xdigits=Integer.toString(x).toCharArray();
    char[] ydigits=Integer.toString(y).toCharArray();
    Arrays.sort(xdigits);
    Arrays.sort(ydigits);
    return Arrays.equals(xdigits,ydigits);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p070 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p070.newp070().run()) );
  static    attribute LIMIT : int := Library.pow(10, 7);
   operation run() : String
  pre: true
  post: true
  activity: (     var minNumer : int ; minNumer := 1 ;
     var minDenom : int ; minDenom := 0 ;
    var totients : Sequence(int) ; totients := Library.listTotients(LIMIT - 1) ;
        var n : int ; n := 2 ; while n < totients->size() do ( (     var tot : int ; tot := totients[n+1] ;
     if (n->oclAsType(long) * minDenom < minNumer->oclAsType(long) * tot & hasSameDigits(n, tot)) then (     minNumer := n ; 
     minDenom := tot ) else skip )  ;     n := n + 1 ) ; 
    if (minDenom = 0) then     error ProgramException("Not found") ; else skip ; 
    return ((minNumer) + "") 
 );
  static   operation hasSameDigits( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     var xdigits : Sequence(String) ; xdigits := ((x) + "")->characters() ;
     var ydigits : Sequence(String) ; ydigits := ((y) + "")->characters() ;
    xdigits := xdigits->sort() ; 
    ydigits := ydigits->sort() ; 
    return xdigits = ydigits 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int k=(int)Math.log10(b)+1 ;
    a=(int)(a*Math.pow(10,k)+b);
    double yono=Math.sqrt(a);
    if(yono-Math.ceil(yono)==0){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var k : int ; k := (b)->log10()->oclAsType(int) + 1 ;
    a := (a * 10->pow(k) + b)->oclAsType(int) ; 
    var yono : double ; yono := (a)->sqrt() ;
    if (yono - (yono)->ceil() = 0) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void intersection(int a[],int b[],int n,int m){
    int i=0,j=0 ;
    while(i<n && j<m){
      if(a[i]>b[j]){
        j++;
      }
      else if(b[j]>a[i]){
        i++;
      }
      else {
        System.out.print(a[i]+" ");
        i++;
        j++;
      }
    }
  }
  public static void main(String[] args){
    int a[]={
      1,2,3,3,4,5,5,6 };
      int b[]={
        3,3,5 };
        int n=a.length ;
        int m=b.length ;
        intersection(a,b,n,m);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation intersection( a : Sequence(int), b : Sequence(int), n : int, m : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var j : int ; j := 0 ;
     while (i < n & j < m) do (     if (a[i+1] > b[j+1]) then (     j := j + 1 ) else     if (b[j+1] > a[i+1]) then (     i := i + 1 ) else (     OclFile["System.out"].print(a[i+1] + " ") ; 
     i := i + 1 ; 
     j := j + 1 ) ;  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,3,4,5,5,6} ;
     var b : Sequence(int) ; b := Sequence{3,3,5} ;
    var n : int ; n := a->size() ;
    var m : int ; m := b->size() ;
    execute intersection(a, b, n, m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findMin(int a[],int n){
    double sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=Math.log(a[i]);
    int x=(int)Math.exp(sum/n);
    return x+1 ;
  }
  public static void main(String[] args){
    int a[]={
      3,2,1,4 };
      int n=a.length ;
      System.out.println(findMin(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMin( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+((a[i+1])->log()) ;  ;     i := i + 1 ) ; 
     var x : int ; x := (sum / n)->exp()->oclAsType(int) ;
     return x + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{3,2,1,4} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(findMin(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int gcd(int a,int b){
    if(b==0)return a ;
    else return gcd(b,a % b);
  }
  static int lcmOfArray(int arr[],int n){
    if(n<1)return 0 ;
    int lcm=arr[0];
    for(int i=1 ; i<n ; i++)lcm=(lcm*arr[i])/gcd(lcm,arr[i]);
    return lcm ;
  }
  static int minPerfectSquare(int arr[],int n){
    int minPerfectSq ;
    int lcm=lcmOfArray(arr,n);
    minPerfectSq=(int)lcm ;
    int cnt=0 ;
    while(lcm>1 && lcm % 2==0){
      cnt++;
      lcm/=2 ;
    }
    if(cnt % 2!=0)minPerfectSq*=2 ;
    int i=3 ;
    while(lcm>1){
      cnt=0 ;
      while(lcm % i==0){
        cnt++;
        lcm/=i ;
      }
      if(cnt % 2!=0)minPerfectSq*=i ;
      i+=2 ;
    }
    return minPerfectSq ;
  }
  public static void main(String args[]){
    int arr[]={
      2,3,4,5,7 };
      int n=arr.length ;
      System.out.println(minPerfectSquare(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else     return gcd(b, a mod b) );
  static   operation lcmOfArray( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n < 1) then     return 0 else skip ; 
     var lcm : int ; lcm := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do (     lcm := (lcm * arr[i+1]) / gcd(lcm, arr[i+1]) ;  ;     i := i + 1 ) ; 
     return lcm );
  static   operation minPerfectSquare( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var minPerfectSq : int ;
     var lcm : int ; lcm := lcmOfArray(arr, n) ;
    minPerfectSq := lcm->oclAsType(int) ; 
    var cnt : int ; cnt := 0 ;
    while (lcm > 1 & lcm mod 2 = 0) do (     cnt := cnt + 1 ; 
     lcm := lcm/(2) ) ; 
    if (cnt mod 2 /= 0) then     minPerfectSq := minPerfectSq*(2) ; else skip ; 
    var i : int ; i := 3 ;
    while (lcm > 1) do (     cnt := 0 ; 
     while (lcm mod i = 0) do (     cnt := cnt + 1 ; 
     lcm := lcm/(i) ) ; 
     if (cnt mod 2 /= 0) then     minPerfectSq := minPerfectSq*(i) ; else skip ; 
     i := i+(2) ) ; 
    return minPerfectSq 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4,5,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minPerfectSquare(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class cfg {
  static int subarrayCount(int arr[],int n){
    int result=0 ;
    int fast=0,slow=0 ;
    for(int i=1 ; i<n ; i++){
      if(arr[i]-arr[i-1]==1){
        fast++;
      }
      else {
        int len=fast-slow+1 ;
        result+=len*(len-1)/2 ;
        fast=i ;
        slow=i ;
      }
    }
    if(fast!=slow){
      int len=fast-slow+1 ;
      result+=len*(len-1)/2 ;
    }
    return result ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,5,6,7 };
      int n=arr.length ;
      System.out.println(subarrayCount(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class cfg {
  static   operation subarrayCount( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var fast : int ; fast := 0 ;
    var slow : int ; slow := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] - arr[i - 1+1] = 1) then (     fast := fast + 1 ) else (     var len : int ; len := fast - slow + 1 ;
     result := result+(len * (len - 1) / 2) ; 
     fast := i ; 
     slow := i ) )  ;     i := i + 1 ) ; 
    if (fast /= slow) then (     var len : int ; len := fast - slow + 1 ;
     result := result+(len * (len - 1) / 2) ) else skip ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,5,6,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(subarrayCount(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class1 {
  public static void main(String arg[]){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    while(t-->0){
      long n=input.nextLong();
      long ans=0 ;
      int flag=0 ;
      while(n>0){
        int x=0 ;
        if(n % 2==0){
          long temp=n/2 ;
          if(n % 4==0 && n>8){
            temp=n-1 ;
            x++;
          }
          n=temp ;
          if(flag==0){
            flag=1 ;
            if(x>0){
              ans+=1 ;
            }
            else {
              ans+=temp ;
            }
          }
          else {
            flag=0 ;
          }
        }
        else {
          if(flag==0){
            n=n-1 ;
            ans+=1 ;
            flag=1 ;
          }
          else {
            n=n-1 ;
            flag=0 ;
          }
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class1 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := input.getCurrent()->toLong() ;
     var ans : long ; ans := 0 ;
    var flag : int ; flag := 0 ;
    while (n > 0) do (     var x : int ; x := 0 ;
     if (n mod 2 = 0) then (     var temp : long ; temp := n / 2 ;
     if (n mod 4 = 0 & n > 8) then (     temp := n - 1 ; 
     x := x + 1 ) else skip ; 
     n := temp ; 
     if (flag = 0) then (     flag := 1 ; 
     if (x > 0) then (     ans := ans+(1) ) else (     ans := ans+(temp) ) ) else (     flag := 0 ) ) else (     if (flag = 0) then (     n := n - 1 ; 
     ans := ans+(1) ; 
     flag := 1 ) else (     n := n - 1 ; 
     flag := 0 ) ) ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class ArenaOfGreed {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t!=0){
      solve(br,pr);
      t--;
    }
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    long n=Long.parseLong(br.readLine());
    long res=0 ;
    int round=0 ;
    while(n!=0){
      if(round % 2==0){
        if(n % 4==0 && n>8){
          res++;
          n--;
        }
        else {
          if(n % 2==0){
            res+=n/2 ;
            n/=2 ;
          }
          else {
            res++;
            n--;
          }
        }
      }
      else {
        if(n % 4==0 && n>8){
          n--;
        }
        else {
          if(n % 2==0){
            n/=2 ;
          }
          else {
            n--;
          }
        }
      }
      round++;
    }
    pr.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ArenaOfGreed {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
    while (t /= 0) do (     execute solve(br, pr) ; 
     t := t - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : long ; n := (br.readLine())->toLong() ;
     var res : long ; res := 0 ;
    var round : int ; round := 0 ;
    while (n /= 0) do (     if (round mod 2 = 0) then (     if (n mod 4 = 0 & n > 8) then (     res := res + 1 ; 
     n := n - 1 ) else (     if (n mod 2 = 0) then (     res := res+(n / 2) ; 
     n := n/(2) ) else (     res := res + 1 ; 
     n := n - 1 ) ) ) else (     if (n mod 4 = 0 & n > 8) then (     n := n - 1 ) else (     if (n mod 2 = 0) then (     n := n/(2) ) else (     n := n - 1 ) ) ) ;  
     round := round + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ArenaOfGreed {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int t=in.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      long n=in.nextLong();
      long[] res=solve(n);
      pw.println(res[0]);
    }
    pw.close();
  }
  static long[] solve(long n){
    long[] ans=new long[2];
    int i=0 ;
    while(n!=0){
      if(n % 4==0 && n>=8){
        ans[i % 2]++;
        n--;
        i++;
        continue ;
      }
      if(n % 2==0){
        ans[i % 2]+=n/2 ;
        n/=2 ;
        i++;
        continue ;
      }
      ans[i % 2]++;
      n--;
      i++;
    }
    return ans ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class ArenaOfGreed {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        var tt : int ; tt := 0 ; while tt < t do ( (     var n : long ; n := in.getCurrent()->toLong() ;
     var res : Sequence(long) ; res := solve(n) ;
     skip )  ;     tt := tt + 1 ) ; 
    skip ; 
 );
  static   operation solve( n : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var ans : Sequence(long) ; ans := Integer.subrange(1,2)->collect(0) ;
     var i : int ; i := 0 ;
     while (n /= 0) do (     if (n mod 4 = 0 & n >= 8) then (     ans[i mod 2+1] := ans[i mod 2+1] + 1 ; 
     n := n - 1 ; 
     i := i + 1 ; 
     continue ) else skip ; 
     if (n mod 2 = 0) then (     ans[i mod 2+1] := ans[i mod 2+1]+(n / 2) ; 
     n := n/(2) ; 
     i := i + 1 ; 
     continue ) else skip ; 
    ans[i mod 2+1] := ans[i mod 2+1] + 1 ; 
    n := n - 1 ; 
    i := i + 1 ; 
 ) ; 
     return ans );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] r=readArray(sc,n);
    int[] b=readArray(sc,n);
    System.out.println(solve(r,b));
    sc.close();
  }
  static int[] readArray(Scanner sc,int size){
    int[] result=new int[size];
    for(int i=0 ; i<result.length ; ++i){
      result[i]=sc.nextInt();
    }
    return result ;
  }
  static int solve(int[] r,int[] b){
    int countR=(int)IntStream.range(0,r.length).filter(i->r[i]==1 && b[i]==0).count();
    int countB=(int)IntStream.range(0,r.length).filter(i->r[i]==0 && b[i]==1).count();
    return(countR==0)?-1 : divideToCeil(countB+1,countR);
  }
  static int divideToCeil(int x,int y){
    return x/y+(x % y==0 ? 0 : 1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var r : Sequence(int) ; r := readArray(sc, n) ;
    var b : Sequence(int) ; b := readArray(sc, n) ;
    OclFile["System.out"].println(solve(r, b)) ; 
    skip ; 
 );
  static   operation readArray( sc : OclFile, size : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var result : Sequence(int) ; result := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < result->size() do ( (     result[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return result );
  static   operation solve( r : Sequence(int), b : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var countR : int ; countR := Integer.subrange(0, r->size()-1)->select( _x1 | (lambda i : OclAny in r[i+1] = 1 & b[i+1] = 0)->apply(_x1) )->size()->oclAsType(int) ;
     var countB : int ; countB := Integer.subrange(0, r->size()-1)->select( _x1 | (lambda i : OclAny in r[i+1] = 0 & b[i+1] = 1)->apply(_x1) )->size()->oclAsType(int) ;
     return if (countR = 0) then -1 else divideToCeil(countB + 1, countR) endif );
  static   operation divideToCeil( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return x / y + (if x mod y = 0 then 0 else 1 endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new java.util.Scanner(System.in);
    int n=scan.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scan.nextInt();
    }
    long sum,min,max ;
    sum=0 ;
    max=-1000000 ;
    min=1000000 ;
    for(int i=0 ; i<n ; i++){
      sum+=a[i];
      if(max<=a[i]){
        max=a[i];
      }
      if(min>=a[i]){
        min=a[i];
      }
    }
    System.out.println(min+" "+max+" "+sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := Scanner.newScanner(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum : long ;
    var min : long ;
    var max : long ;
    sum := 0 ; 
    max := -1000000 ; 
    min := 1000000 ; 
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(a[i+1]) ; 
     if (max <= a[i+1]) then (     max := a[i+1] ) else skip ; 
     if (min >= a[i+1]) then (     min := a[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min + " " + max + " " + sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    MyScanner in=new MyScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    B solver=new B();
    solver.solve(1,in,out);
    out.close();
  }
  static class B {
    public void solve(int testNumber,MyScanner in,PrintWriter out){
      String a=in.next();
      String b=in.next();
      int n=Integer.parseInt(a+b);
      if(n==Math.pow((int)Math.sqrt(n),2)){
        out.println("Yes");
      }
      else {
        out.println("No");
      }
    }
  }
  static class MyScanner {
    private BufferedReader in ;
    private StringTokenizer st ;
    public MyScanner(InputStream stream){
      in=new BufferedReader(new InputStreamReader(stream));
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          String rl=in.readLine();
          if(rl==null){
            return null ;
          }
          st=new StringTokenizer(rl);
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : MyScanner ; in := MyScanner.newMyScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : B ; solver := B.newB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class B {
   operation solve( testNumber : int, in : MyScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : String ; a := in.next() ;
     var b : String ; b := in.next() ;
     var n : int ; n := (a + b)->toInteger() ;
     if (n = (n)->sqrt()->oclAsType(int)->pow(2)) then (     skip ) else (     skip ) );
}
  static class MyScanner {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner( stream : OclFile) : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     var rl : String ; rl := in.readLine() ;
     if (rl = null) then (     return null ) else skip ; 
     st := OclIterator.newOclIterator_String(rl) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    List<Integer>list=new ArrayList<>();
    int count=0 ;
    while(true){
      list.add(sc.nextInt());
      if(count==list.get(0)){
        break ;
      }
      count++;
    }
    int min ;
    if(list.get(0)!=0){
      min=list.get(1);
    }
    else {
      min=0 ;
    }
    int max ;
    if(list.get(0)!=0){
      max=list.get(1);
    }
    else {
      max=0 ;
    }
    long add=0 ;
    for(int i=1 ; i<list.size(); i++){
      if(min>list.get(i))min=list.get(i);
      if(max<list.get(i))max=list.get(i);
      add=add+list.get(i);
    }
    System.out.println(min+" "+max+" "+add);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(int) ; list := Sequence{} ;
    var count : int ; count := 0 ;
    while (true) do (     list := list->including(sc.getCurrent()->toInteger()) ; 
     if (count = list->at(0+1)) then (     break ) else skip ; 
     count := count + 1 ) ; 
    var min : int ;
    if (list->at(0+1) /= 0) then (     min := list->at(1+1) ) else (     min := 0 ) ;  
    var max : int ;
    if (list->at(0+1) /= 0) then (     max := list->at(1+1) ) else (     max := 0 ) ;  
    var add : long ; add := 0 ;
        var i : int ; i := 1 ; while i < list->size() do ( (     if (min > list->at(i+1)) then     min := list->at(i+1) ; else skip ; 
     if (max < list->at(i+1)) then     max := list->at(i+1) ; else skip ; 
     add := add + list->at(i+1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min + " " + max + " " + add) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int[] ary=new int[n];
    int i=0 ;
    StringTokenizer st=new StringTokenizer(br.readLine());
    while(i<n){
      int a=Integer.parseInt(st.nextToken());
      ary[i]=a ;
      i++;
    }
    int max=ary[0];
    int min=ary[0];
    long sum=0 ;
    for(i=0 ; i<ary.length ; i++){
      int v=ary[i];
      if(v>max){
        max=v ;
      }
      if(v<min){
        min=v ;
      }
      sum=sum+v ;
    }
    System.out.println(min+" "+max+" "+sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var ary : Sequence(int) ; ary := Integer.subrange(1,n)->collect(0) ;
    var i : int ; i := 0 ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    while (i < n) do (     var a : int ; a := (st.next())->toInteger() ;
     ary[i+1] := a ; 
     i := i + 1 ) ; 
    var max : int ; max := ary[0+1] ;
    var min : int ; min := ary[0+1] ;
    var sum : long ; sum := 0 ;
        i := 0 ; while i < ary->size() do ( (     var v : int ; v := ary[i+1] ;
     if (v > max) then (     max := v ) else skip ; 
     if (v < min) then (     min := v ) else skip ; 
     sum := sum + v )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min + " " + max + " " + sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String str1=in.nextLine();
    String str2 ;
    int num1=Integer.parseInt(str1);
    int num2,max,min ;
    max=0 ;
    min=0 ;
    long sum=0 ;
    for(int i=0 ; i<num1 ; i++){
      str2=in.next();
      num2=Integer.parseInt(str2);
      sum+=num2 ;
      if(i==0){
        max=num2 ;
        min=num2 ;
      }
      else if(num2>max){
        max=num2 ;
      }
      else if(num2<min){
        min=num2 ;
      }
    }
    System.out.println(min+" "+max+" "+sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str1 : String ; str1 := in.nextLine() ;
    var str2 : String ;
    var num1 : int ; num1 := (str1)->toInteger() ;
    var num2 : int ;
    var max : int ;
    var min : int ;
    max := 0 ; 
    min := 0 ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < num1 do ( (     str2 := in.getCurrent() ; 
     num2 := (str2)->toInteger() ; 
     sum := sum+(num2) ; 
     if (i = 0) then (     max := num2 ; 
     min := num2 ) else     if (num2 > max) then (     max := num2 ) else     if (num2 < min) then (     min := num2 ) else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min + " " + max + " " + sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1345A_PuzzlePieces {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int row=input.nextInt();
      int col=input.nextInt();
      input.nextLine();
      int min=Math.min(col,row);
      if(min==1){
        System.out.println("YES");
      }
      else if(row<=2 && col<=2){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1345A_PuzzlePieces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var row : int ; row := input.getCurrent()->toInteger() ;
     var col : int ; col := input.getCurrent()->toInteger() ;
    skip ; 
    var min : int ; min := Set{col, row}->min() ;
    if (min = 1) then (     OclFile["System.out"].println("YES") ) else     if (row <= 2 & col <= 2) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PuzzlePiecesMain {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    short t=sc.nextShort();
    int[][] cases=new int[t][2];
    for(short i=0 ; i<cases.length ; i++){
      for(short j=0 ; j<cases[i] .length ; j++){
        cases[i][j]=sc.nextInt();
      }
    }
    for(short i=0 ; i<cases.length ; i++){
      solution(cases[i][0],cases[i][1]);
    }
    sc.close();
  }
  public static void solution(int m,int n){
    if(m<=2 && n<=2){
      System.out.println("YES");
    }
    else if(m==1 || n==1){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PuzzlePiecesMain {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.nextShort() ;
    var cases : Sequence(Sequence(int)) ; cases := Integer.subrange(1,t)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < cases->size() do ( (         var j : int ; j := 0 ; while j < cases[i+1]->size() do ( (     cases[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < cases->size() do ( (     execute solution(cases[i+1][0+1], cases[i+1][1+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation solution( m : int, n : int) : void
  pre: true
  post: true
  activity: (     if (m <= 2 & n <= 2) then (     OclFile["System.out"].println("YES") ) else     if (m = 1 or n = 1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
import java.util.*;
public class codeforcesA {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader sc=new FastReader();
    int t=sc.nextInt();
    StringBuilder sb=new StringBuilder();
    while(t-->0){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if(n==1 || m==1 ||(n==2 && m==2)){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforcesA {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var t : int ; t := sc.nextInt() ;
     var sb : String ; sb := StringLib.newString() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.nextInt() ;
     var m : int ; m := sc.nextInt() ;
     if (n = 1 or m = 1 or (n = 2 & m = 2)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    while(t--!=0){
      int a=input.nextInt();
      int b=input.nextInt();
      if(a<=1 || b<=1){
        System.out.println("YES");
      }
      else if(a==2 && b==2){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var a : int ; a := input.getCurrent()->toInteger() ;
     var b : int ; b := input.getCurrent()->toInteger() ;
     if (a <= 1 or b <= 1) then (     OclFile["System.out"].println("YES") ) else     if (a = 2 & b = 2) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test292 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=in.nextInt();
      int m=in.nextInt();
      if(m==1 || n==1){
        System.out.println("YES");
      }
      else if(m+n<5){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test292 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
     if (m = 1 or n = 1) then (     OclFile["System.out"].println("YES") ) else     if (m + n < 5) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class GFG {
  static final int MAX_CHARS=256 ;
  static String findSubString(String str){
    int n=str.length();
    int dist_count=0 ;
    boolean[] visited=new boolean[MAX_CHARS];
    Arrays.fill(visited,false);
    for(int i=0 ; i<n ; i++){
      if(visited[str.charAt(i)]==false){
        visited[str.charAt(i)]=true ;
        dist_count++;
      }
    }
    int start=0,start_index=-1 ;
    int min_len=Integer.MAX_VALUE ;
    int count=0 ;
    int[] curr_count=new int[MAX_CHARS];
    for(int j=0 ; j<n ; j++){
      curr_count[str.charAt(j)]++;
      if(curr_count[str.charAt(j)]==1)count++;
      if(count==dist_count){
        while(curr_count[str.charAt(start)]>1){
          if(curr_count[str.charAt(start)]>1)curr_count[str.charAt(start)]--;
          start++;
        }
        int len_window=j-start+1 ;
        if(min_len>len_window){
          min_len=len_window ;
          start_index=start ;
        }
      }
    }
    return str.substring(start_index,start_index+min_len);
  }
  public static void main(String args[]){
    String str="aabcbcdbca" ;
    System.out.println("Smallest window containing all distinct"+" characters is: "+findSubString(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX_CHARS : int := 256;
  static   operation findSubString( str : String) : String
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var dist_count : int ; dist_count := 0 ;
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,MAX_CHARS)->collect(false) ;
    visited := visited->collect(false) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (visited[str->at(i+1)+1] = false) then (     visited[str->at(i+1)+1] := true ; 
     dist_count := dist_count + 1 ) else skip )  ;     i := i + 1 ) ; 
    var start : int ; start := 0 ;
    var start_index : int ; start_index := -1 ;
    var min_len : int ; min_len := 2147483647 ;
    var count : int ; count := 0 ;
    var curr_count : Sequence(int) ; curr_count := Integer.subrange(1,MAX_CHARS)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     curr_count[str->at(j+1)+1] := curr_count[str->at(j+1)+1] + 1 ; 
     if (curr_count[str->at(j+1)+1] = 1) then     count := count + 1 ; else skip ; 
     if (count = dist_count) then (     while (curr_count[str->at(start+1)+1] > 1) do (     if (curr_count[str->at(start+1)+1] > 1) then     curr_count[str->at(start+1)+1] := curr_count[str->at(start+1)+1] - 1 ; else skip ; 
     start := start + 1 ) ; 
     var len_window : int ; len_window := j - start + 1 ;
     if (min_len > len_window) then (     min_len := len_window ; 
     start_index := start ) else skip ) else skip )  ;     j := j + 1 ) ; 
    return str.subrange(start_index+1,start_index + min_len) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "aabcbcdbca" ;
     OclFile["System.out"].println("Smallest window containing all distinct" + " characters is: " + findSubString(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  static class Fast {
    BufferedReader br ;
    StringTokenizer st ;
    public Fast(){
      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 ;
    }
  }
  public static void main(String args[])throws Exception {
    Fast in=new Fast();
    int n=in.nextInt();
    int b=in.nextInt();
    if(Math.sqrt(Integer.parseInt(n+""+b))==(int)Math.sqrt(Integer.parseInt(n+""+b))){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Fast {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFast() : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : Fast ; in := Fast.newFast() ;
     var n : int ; n := in.nextInt() ;
     var b : int ; b := in.nextInt() ;
     if (((n + "" + b)->toInteger())->sqrt() = ((n + "" + b)->toInteger())->sqrt()->oclAsType(int)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double A=sc.nextInt();
    double B=sc.nextInt();
    double C=sc.nextInt();
    double D=sc.nextInt();
    double E=sc.nextInt();
    double F=sc.nextInt();
    double water=0 ;
    double suger=0 ;
    double watmax=0 ;
    double sugmax=0 ;
    double maxnodo=100*E/(100+E);
    double nodo=0 ;
    double nodomax=0 ;
    for(int a=0 ; a<=F/100 ; a+=A){
      for(int b=0 ; b<=F/100 ; b+=B){
        for(int c=0 ; c<=F ; c+=C){
          for(int d=0 ; d<=F ; d+=D){
            water=100*a+100*b ;
            suger=c+d ;
            if(water==0 || water+suger>F){
              break ;
            }
            nodo=100*suger/(water+suger);
            if(nodo>=nodomax && nodo<=maxnodo){
              watmax=water ;
              sugmax=suger ;
              nodomax=nodo ;
            }
          }
        }
      }
    }
    System.out.println((int)watmax+(int)sugmax+" "+(int)sugmax);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : double ; A := sc.getCurrent()->toInteger() ;
    var B : double ; B := sc.getCurrent()->toInteger() ;
    var C : double ; C := sc.getCurrent()->toInteger() ;
    var D : double ; D := sc.getCurrent()->toInteger() ;
    var E : double ; E := sc.getCurrent()->toInteger() ;
    var F : double ; F := sc.getCurrent()->toInteger() ;
    var water : double ; water := 0 ;
    var suger : double ; suger := 0 ;
    var watmax : double ; watmax := 0 ;
    var sugmax : double ; sugmax := 0 ;
    var maxnodo : double ; maxnodo := 100 * E / (100 + E) ;
    var nodo : double ; nodo := 0 ;
    var nodomax : double ; nodomax := 0 ;
        var a : int ; a := 0 ; while a <= F / 100 do ( (         var b : int ; b := 0 ; while b <= F / 100 do ( (         var c : int ; c := 0 ; while c <= F do ( (         var d : int ; d := 0 ; while d <= F do ( (     water := 100 * a + 100 * b ; 
     suger := c + d ; 
    if (water = 0 or water + suger > F) then (     break ) else skip ; 
    nodo := 100 * suger / (water + suger) ; 
    if (nodo >= nodomax & nodo <= maxnodo) then (     watmax := water ; 
     sugmax := suger ; 
     nodomax := nodo ) else skip ; 
 )  ;     d := d+(D) ) )  ;     c := c+(C) ) )  ;     b := b+(B) ) )  ;     a := a+(A) ) ; 
    OclFile["System.out"].println(watmax->oclAsType(int) + sugmax->oclAsType(int) + " " + sugmax->oclAsType(int)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int a=Integer.parseInt(str[0]);
    int b=Integer.parseInt(str[1]);
    int c=Integer.parseInt(str[2]);
    int d=Integer.parseInt(str[3]);
    int e=Integer.parseInt(str[4]);
    int f=Integer.parseInt(str[5]);
    double maxDensity=0 ;
    int swMax=0 ;
    int sugarMax=0 ;
    for(int i=0 ; 100*i*a<=f ; i++){
      for(int j=0 ; 100*(i*a+j*b)<=f ; j++){
        int water=100*(i*a+j*b);
        int sugarLimit=(i*a+j*b)*e ;
        for(int k=0 ; k*c<=sugarLimit && water+k*c<=f ; k++){
          for(int l=0 ; k*c+l*d<=sugarLimit && water+k*c+l*d<=f ; l++){
            int sugar=k*c+l*d ;
            double tmpDens=(double)sugar/(sugar+water);
            if(tmpDens>maxDensity){
              maxDensity=tmpDens ;
              swMax=sugar+water ;
              sugarMax=sugar ;
            }
          }
        }
      }
    }
    if(sugarMax==0){
      System.out.println(100*a+" "+sugarMax);
    }
    else {
      System.out.println(swMax+" "+sugarMax);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var a : int ; a := (str[0+1])->toInteger() ;
    var b : int ; b := (str[1+1])->toInteger() ;
    var c : int ; c := (str[2+1])->toInteger() ;
    var d : int ; d := (str[3+1])->toInteger() ;
    var e : int ; e := (str[4+1])->toInteger() ;
    var f : int ; f := (str[5+1])->toInteger() ;
    var maxDensity : double ; maxDensity := 0 ;
    var swMax : int ; swMax := 0 ;
    var sugarMax : int ; sugarMax := 0 ;
        var i : int ; i := 0 ; while 100 * i * a <= f do ( (         var j : int ; j := 0 ; while 100 * (i * a + j * b) <= f do ( (     var water : int ; water := 100 * (i * a + j * b) ;
     var sugarLimit : int ; sugarLimit := (i * a + j * b) * e ;
         var k : int ; k := 0 ; while k * c <= sugarLimit & water + k * c <= f do ( (         var l : int ; l := 0 ; while k * c + l * d <= sugarLimit & water + k * c + l * d <= f do ( (     var sugar : int ; sugar := k * c + l * d ;
     var tmpDens : double ; tmpDens := sugar->oclAsType(double) / (sugar + water) ;
     if (tmpDens > maxDensity) then (     maxDensity := tmpDens ; 
     swMax := sugar + water ; 
     sugarMax := sugar ) else skip )  ;     l := l + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (sugarMax = 0) then (     OclFile["System.out"].println(100 * a + " " + sugarMax) ) else (     OclFile["System.out"].println(swMax + " " + sugarMax) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double a=sc.nextDouble();
    double b=sc.nextDouble();
    double c=sc.nextDouble();
    double d=sc.nextDouble();
    double e=sc.nextDouble();
    double f=sc.nextDouble();
    double baseConcentration=(100*e)/(100+e);
    double concentration ;
    double maxConcentration=0 ;
    int maxSugar=0 ;
    int maxSagerWater=0 ;
    for(int i=0 ; i*a*100<=f ; i++){
      for(int j=0 ; j*b*100<=f ; j++){
        double water=i*a*100+j*b*100 ;
        for(int k=0 ; k*c<=f ; k++){
          for(int l=0 ; l*d<=f ; l++){
            double sugar=c*k+d*l ;
            double sugarWater=sugar+water ;
            if(sugar==0 || water==0){
              concentration=0 ;
            }
            else {
              concentration=(100*sugar)/(sugarWater);
            }
            if(sugarWater<=f && concentration<=baseConcentration && concentration>=maxConcentration){
              if(water==0 && sugar!=0)continue ;
              maxConcentration=concentration ;
              maxSugar=(int)sugar ;
              maxSagerWater=(int)sugarWater ;
            }
          }
        }
      }
    }
    System.out.println(maxSagerWater+" "+maxSugar);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : double ; a := sc.getCurrent()->toReal() ;
    var b : double ; b := sc.getCurrent()->toReal() ;
    var c : double ; c := sc.getCurrent()->toReal() ;
    var d : double ; d := sc.getCurrent()->toReal() ;
    var e : double ; e := sc.getCurrent()->toReal() ;
    var f : double ; f := sc.getCurrent()->toReal() ;
    var baseConcentration : double ; baseConcentration := (100 * e) / (100 + e) ;
    var concentration : double ;
    var maxConcentration : double ; maxConcentration := 0 ;
    var maxSugar : int ; maxSugar := 0 ;
    var maxSagerWater : int ; maxSagerWater := 0 ;
        var i : int ; i := 0 ; while i * a * 100 <= f do ( (         var j : int ; j := 0 ; while j * b * 100 <= f do ( (     var water : double ; water := i * a * 100 + j * b * 100 ;
         var k : int ; k := 0 ; while k * c <= f do ( (         var l : int ; l := 0 ; while l * d <= f do ( (     var sugar : double ; sugar := c * k + d * l ;
     var sugarWater : double ; sugarWater := sugar + water ;
     if (sugar = 0 or water = 0) then (     concentration := 0 ) else (     concentration := (100 * sugar) / (sugarWater) ) ;  
     if (sugarWater <= f & concentration <= baseConcentration & concentration >= maxConcentration) then (     if (water = 0 & sugar /= 0) then     continue else skip ; 
     maxConcentration := concentration ; 
     maxSugar := sugar->oclAsType(int) ; 
     maxSagerWater := sugarWater->oclAsType(int) ) else skip )  ;     l := l + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(maxSagerWater + " " + maxSugar) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdin=new Scanner(System.in);
    int[] result=main(stdin.nextInt(),stdin.nextInt(),stdin.nextInt(),stdin.nextInt(),stdin.nextInt(),stdin.nextInt());
    System.out.println(result[0]+" "+result[1]);
    stdin.close();
  }
  public static int[] main(int A,int B,int C,int D,int E,int F){
    double max=0 ;
    int maxWater=0 ;
    int maxSugar=0 ;
    for(int a=0 ; a*100<=F ; a++){
      for(int b=(a==0)? 1 : 0 ; (A*a+B*b)*100<=F ; b++){
        int water=(A*a+B*b)*100 ;
        int sugarLimit=Math.min(E*(A*a+B*b),F-water);
        int sugar=maximizeSugar(C,D,sugarLimit);
        if(sugar==sugarLimit && sugar==E*(A*a+B*b)){
          return new int[] {
            water+sugar,sugar };
          }
          if(sugar>max*(water+sugar)){
            max=(double)sugar/(water+sugar);
            maxWater=water ;
            maxSugar=sugar ;
          }
        }
      }
      if(max==0){
        return new int[] {
          A*100,0 };
        }
        else {
          return new int[] {
            maxWater+maxSugar,maxSugar };
          }
        }
        private static int maximizeSugar(int C,int D,int limit){
          int minRem=limit ;
          for(int c=0 ; c<=limit/C ; c++){
            minRem=Math.min((limit-C*c)% D,minRem);
          }
          return limit-minRem ;
        }
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var result : Sequence(int) ; result := main(stdin.getCurrent()->toInteger(), stdin.getCurrent()->toInteger(), stdin.getCurrent()->toInteger(), stdin.getCurrent()->toInteger(), stdin.getCurrent()->toInteger(), stdin.getCurrent()->toInteger()) ;
     OclFile["System.out"].println(result[0+1] + " " + result[1+1]) ; 
     skip );
  static   operation main( A : int, B : int, C : int, D : int, E : int, F : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var max : double ; max := 0 ;
     var maxWater : int ; maxWater := 0 ;
    var maxSugar : int ; maxSugar := 0 ;
        var a : int ; a := 0 ; while a * 100 <= F do ( (         var b : int ; b := if (a = 0) then 1 else 0 endif ; while (A * a + B * b) * 100 <= F do ( (     var water : int ; water := (A * a + B * b) * 100 ;
     var sugarLimit : int ; sugarLimit := Set{E * (A * a + B * b), F - water}->min() ;
    var sugar : int ; sugar := maximizeSugar(C, D, sugarLimit) ;
    if (sugar = sugarLimit & sugar = E * (A * a + B * b)) then (     return Sequence{water + sugar,sugar} ) else skip ; 
    if (sugar > max * (water + sugar)) then (     max := sugar->oclAsType(double) / (water + sugar) ; 
     maxWater := water ; 
     maxSugar := sugar ) else skip ; 
 )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    if (max = 0) then (     return Sequence{A * 100,0} ) else (     return Sequence{maxWater + maxSugar,maxSugar} ) ;  
 );
  static   operation maximizeSugar( C : int, D : int, limit : int) : int
  pre: true
  post: true
  activity: (     var minRem : int ; minRem := limit ;
         var c : int ; c := 0 ; while c <= limit / C do ( (     minRem := Set{(limit - C * c) mod D, minRem}->min() )  ;     c := c + 1 ) ; 
     return limit - minRem );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] before=null ;
    while(true){
      if(! sc.hasNext()){
        break ;
      }
      String str[]=sc.next().split(",");
      int[] inner=new int[str.length];
      for(int i=0 ; i<str.length ; i++){
        inner[i]=Integer.parseInt(str[i]);
      }
      if(before==null){
        before=inner ;
      }
      else {
        int[] tmp=new int[inner.length];
        for(int i=0 ; i<before.length ; i++){
          if(i<tmp.length){
            if(tmp[i]<before[i]+inner[i]){
              tmp[i]=before[i]+inner[i];
            }
          }
          if(before.length>tmp.length){
            if((i-1)<tmp.length &&(i-1)>=0){
              if(tmp[i-1]<before[i]+inner[i-1]){
                tmp[i-1]=before[i]+inner[i-1];
              }
            }
          }
          else {
            if((i+1)<tmp.length){
              if(tmp[i+1]<before[i]+inner[i+1]){
                tmp[i+1]=before[i]+inner[i+1];
              }
            }
          }
        }
        before=tmp ;
      }
    }
    System.out.println(before[0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var before : Sequence(int) ; before := null ;
     while (true) do (     if (not(sc.hasNext())) then (     break ) else skip ; 
     var str : Sequence(String) ; str := sc.getCurrent()->split(",") ;
    var inner : Sequence(int) ; inner := Integer.subrange(1,str->size())->collect(0) ;
        var i : int ; i := 0 ; while i < str->size() do ( (     inner[i+1] := (str[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    if (before = null) then (     before := inner ) else (     var tmp : Sequence(int) ; tmp := Integer.subrange(1,inner->size())->collect(0) ;
         var i : int ; i := 0 ; while i < before->size() do ( (     if (i < tmp->size()) then (     if (tmp[i+1] < before[i+1] + inner[i+1]) then (     tmp[i+1] := before[i+1] + inner[i+1] ) else skip ) else skip ; 
     if (before->size() > tmp->size()) then (     if ((i - 1) < tmp->size() & (i - 1) >= 0) then (     if (tmp[i - 1+1] < before[i+1] + inner[i - 1+1]) then (     tmp[i - 1+1] := before[i+1] + inner[i - 1+1] ) else skip ) else skip ) else (     if ((i + 1) < tmp->size()) then (     if (tmp[i + 1+1] < before[i+1] + inner[i + 1+1]) then (     tmp[i + 1+1] := before[i+1] + inner[i + 1+1] ) else skip ) else skip ) )  ;     i := i + 1 ) ; 
     before := tmp ) ;  
 ) ; 
     OclFile["System.out"].println(before[0+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    try {
      System.setIn(new FileInputStream("src/aoj0089/input.txt"));
      System.setOut(new PrintStream(new FileOutputStream("src/xxxyyyy/result.txt")));
    }
    catch(FileNotFoundException e){
    }
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    final int inf=1<<29 ;
    int[] cur=new int[128];
    fill(cur,-inf);
    cur[0]=0 ;
    int prev_n=0 ;
    while(sc.hasNext()){
      String[] vars=sc.next().split(",");
      int n=vars.length ;
      int[] next=new int[128];
      fill(next,-inf);
      for(int i=0 ; i<vars.length ; i++){
        int v=Integer.valueOf(vars[i]);
        next[i]=max(next[i],cur[i]+v);
        if(n>prev_n && i-1>=0)next[i]=max(next[i],cur[i-1]+v);
        if(n<prev_n && i+1<prev_n)next[i]=max(next[i],cur[i+1]+v);
      }
      cur=copyOf(next,next.length);
      prev_n=n ;
    }
    int ans=-inf ;
    for(int x : cur)ans=max(ans,x);
    System.out.println(ans);
  }
  void debug(Object...os){
    System.err.println(deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("src/aoj0089/input.txt"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("src/xxxyyyy/result.txt")))) )   catch (e : FileNotFoundException) do skip
     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inf : int ; inf := (1*(2->pow(29)))->oclAsType(long) ;
    var cur : Sequence(int) ; cur := Integer.subrange(1,128)->collect(0) ;
    execute fill(cur, -inf) ; 
    cur[0+1] := 0 ; 
    var prev_n : int ; prev_n := 0 ;
    while (sc.hasNext()) do (     var vars : Sequence(String) ; vars := sc.getCurrent()->split(",") ;
     var n : int ; n := vars->size() ;
    var next : Sequence(int) ; next := Integer.subrange(1,128)->collect(0) ;
    execute fill(next, -inf) ; 
        var i : int ; i := 0 ; while i < vars->size() do ( (     var v : int ; v := (vars[i+1])->toInteger() ;
     next[i+1] := Set{next[i+1], cur[i+1] + v}->max() ; 
     if (n > prev_n & i - 1 >= 0) then     next[i+1] := Set{next[i+1], cur[i - 1+1] + v}->max() ; else skip ; 
     if (n < prev_n & i + 1 < prev_n) then     next[i+1] := Set{next[i+1], cur[i + 1+1] + v}->max() ; else skip )  ;     i := i + 1 ) ; 
    cur := copyOf(next, next->size()) ; 
    prev_n := n ; 
 ) ; 
    var ans : int ; ans := -inf ;
    for (x : cur) do (     ans := Set{ans, x}->max() ;  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    String line=null ;
    int[] results=new int[50];
    int lastLength=0 ;
    while((line=reader.readLine())!=null){
      if(line.isEmpty()){
        continue ;
      }
      String[] values=line.split(",");
      if(values.length>lastLength){
        for(int i=values.length-1 ; i>=0 ; i--){
          int left=i>0 ? results[i-1] : 0 ;
          int top=results[i];
          results[i]=Math.max(left,top)+Integer.parseInt(values[i]);
        }
      }
      else {
        for(int i=0 ; i<values.length ; i++){
          int top=results[i];
          int right=results[i+1];
          results[i]=Math.max(top,right)+Integer.parseInt(values[i]);
        }
      }
      lastLength=values.length ;
    }
    out.println(results[0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     var line : String ; line := null ;
    var results : Sequence(int) ; results := Integer.subrange(1,50)->collect(0) ;
    var lastLength : int ; lastLength := 0 ;
        line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->isEmpty()) then (     continue ) else skip ; 
     var values : Sequence(String) ; values := line->split(",") ;
     if (values->size() > lastLength) then (         var i : int ; i := values->size() - 1 ; while i >= 0 do ( (     var left : int ; left := if i > 0 then results[i - 1+1] else 0 endif ;
     var top : int ; top := results[i+1] ;
     results[i+1] := Set{left, top}->max() + (values[i+1])->toInteger() )  ;     i := i - 1 ) ) else (         var i : int ; i := 0 ; while i < values->size() do ( (     var top : int ; top := results[i+1] ;
     var right : int ; right := results[i + 1+1] ;
     results[i+1] := Set{top, right}->max() + (values[i+1])->toInteger() )  ;     i := i + 1 ) ) ;  
     lastLength := values->size() ) ;     line := reader.readLine() ;
 ) ;  
    out.println(results[0+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int N ;
  public static void main(String[] args){
    int[][] square=getSquare();
    int[][] dp=new int[100][100];
    dp[0][0]=square[0][0];
    for(int i=1 ; i<N ; i++){
      dp[0][i]=dp[0][i-1]+square[0][i];
      dp[i][0]=dp[i-1][0]+square[i][0];
    }
    for(int i=1 ; i<N ; i++){
      for(int j=1 ; j<N ; j++){
        dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1])+square[i][j];
      }
    }
    System.out.println(dp[N-1][N-1]);
  }
  static int[][] getSquare(){
    int[][] square=new int[100][100];
    Scanner sn=new Scanner(System.in);
    int ni=-1,nj=0,esLen=0 ;
    while(sn.hasNext()){
      String[] es=sn.nextLine().split(",");
      if(es.length>esLen)ni++;
      else nj++;
      esLen=es.length ;
      int i=ni,j=nj ;
      for(int k=0 ; k<es.length ; k++){
        square[i][j]=Integer.parseInt(es[k]);
        i--;
        j++;
      }
    }
    N=ni+1 ;
    return square ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var square : Sequence(Sequence(int)) ; square := getSquare() ;
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(0)) ;
    dp[0+1][0+1] := square[0+1][0+1] ; 
        var i : int ; i := 1 ; while i < N do ( (     dp[0+1][i+1] := dp[0+1][i - 1+1] + square[0+1][i+1] ; 
     dp[i+1][0+1] := dp[i - 1+1][0+1] + square[i+1][0+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < N do ( (         var j : int ; j := 1 ; while j < N do ( (     dp[i+1][j+1] := Set{dp[i - 1+1][j+1], dp[i+1][j - 1+1]}->max() + square[i+1][j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[N - 1+1][N - 1+1]) ; 
 );
  static   operation getSquare() : Sequence(Sequence(int))
  pre: true
  post: true
  activity: (     var square : Sequence(Sequence(int)) ; square := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(0)) ;
     var sn : OclFile ; sn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var ni : int ; ni := -1 ;
    var nj : int ; nj := 0 ;
    var esLen : int ; esLen := 0 ;
    while (sn.hasNext()) do (     var es : Sequence(String) ; es := sn.nextLine()->split(",") ;
     if (es->size() > esLen) then     ni := ni + 1 else     nj := nj + 1 ; ;  
    esLen := es->size() ; 
    var i : int ; i := ni ;
    var j : int ; j := nj ;
        var k : int ; k := 0 ; while k < es->size() do ( (     square[i+1][j+1] := (es[k+1])->toInteger() ; 
     i := i - 1 ; 
     j := j + 1 )  ;     k := k + 1 ) ; 
 ) ; 
    N := ni + 1 ; 
    return square 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String multiply(String num1,String num2){
    int len1=num1.length();
    int len2=num2.length();
    if(len1==0 || len2==0)return "0" ;
    int result[]=new int[len1+len2];
    int i_n1=0 ;
    int i_n2=0 ;
    for(int i=len1-1 ; i>=0 ; i--){
      int carry=0 ;
      int n1=num1.charAt(i)-'0' ;
      i_n2=0 ;
      for(int j=len2-1 ; j>=0 ; j--){
        int n2=num2.charAt(j)-'0' ;
        int sum=n1*n2+result[i_n1+i_n2]+carry ;
        carry=sum/10 ;
        result[i_n1+i_n2]=sum % 10 ;
        i_n2++;
      }
      if(carry>0)result[i_n1+i_n2]+=carry ;
      i_n1++;
    }
    int i=result.length-1 ;
    while(i>=0 && result[i]==0)i--;
    if(i==-1)return "0" ;
    String s="" ;
    while(i>=0)s+=(result[i--]);
    return s ;
  }
  public static void main(String[] args){
    String str1="1235421415454545454545454544" ;
    String str2="1714546546546545454544548544544545" ;
    if((str1.charAt(0)=='-' || str2.charAt(0)=='-')&&(str1.charAt(0)!='-' || str2.charAt(0)!='-'))System.out.print("-");
    if(str1.charAt(0)=='-' && str2.charAt(0)!='-'){
      str1=str1.substring(1);
    }
    else if(str1.charAt(0)!='-' && str2.charAt(0)=='-'){
      str2=str2.substring(1);
    }
    else if(str1.charAt(0)=='-' && str2.charAt(0)=='-'){
      str1=str1.substring(1);
      str2=str2.substring(1);
    }
    System.out.println(multiply(str1,str2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation multiply( num1 : String, num2 : String) : String
  pre: true
  post: true
  activity: (     var len1 : int ; len1 := num1->size() ;
     var len2 : int ; len2 := num2->size() ;
    if (len1 = 0 or len2 = 0) then     return "0" else skip ; 
    var result : Sequence(int) ; result := Integer.subrange(1,len1 + len2)->collect(0) ;
    var i_n1 : int ; i_n1 := 0 ;
    var i_n2 : int ; i_n2 := 0 ;
        var i : int ; i := len1 - 1 ; while i >= 0 do ( (     var carry : int ; carry := 0 ;
     var n1 : int ; n1 := num1->at(i+1) - ('0')->char2byte() ;
    i_n2 := 0 ; 
        var j : int ; j := len2 - 1 ; while j >= 0 do ( (     var n2 : int ; n2 := num2->at(j+1) - ('0')->char2byte() ;
     var sum : int ; sum := n1 * n2 + result[i_n1 + i_n2+1] + carry ;
    carry := sum / 10 ; 
    result[i_n1 + i_n2+1] := sum mod 10 ; 
    i_n2 := i_n2 + 1 ; 
 )  ;     j := j - 1 ) ; 
    if (carry > 0) then     result[i_n1 + i_n2+1] := result[i_n1 + i_n2+1]+(carry) ; else skip ; 
    i_n1 := i_n1 + 1 ; 
 )  ;     i := i - 1 ) ; 
    var i : int ; i := result->size() - 1 ;
    while (i >= 0 & result[i+1] = 0) do     i := i - 1 ; ; 
    if (i = -1) then     return "0" else skip ; 
    var s : String ; s := "" ;
    while (i >= 0) do      s := s + (result[i+1])  ; i := i - 1 ; ; 
    return s 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "1235421415454545454545454544" ;
     var str2 : String ; str2 := "1714546546546545454544548544544545" ;
    if ((str1->at(0+1) = '-' or str2->at(0+1) = '-') & (str1->at(0+1) /= '-' or str2->at(0+1) /= '-')) then     OclFile["System.out"].print("-") ; else skip ; 
    if (str1->at(0+1) = '-' & str2->at(0+1) /= '-') then (     str1 := str1.subrange(1+1,1) ) else     if (str1->at(0+1) /= '-' & str2->at(0+1) = '-') then (     str2 := str2.subrange(1+1,1) ) else     if (str1->at(0+1) = '-' & str2->at(0+1) = '-') then (     str1 := str1.subrange(1+1,1) ; 
     str2 := str2.subrange(1+1,1) ) else skip ; ;  ;  
    OclFile["System.out"].println(multiply(str1, str2)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public boolean isQube(Integer number){
    for(int i=0 ; i<100100 ; i++){
      if(i*i==number)return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    Main product=new Main();
    try {
      BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
      String inputLine=reader.readLine();
      String numbers[]=inputLine.split(" ");
      System.out.println(product.isQube(Integer.valueOf(numbers[0]+numbers[1]))? "Yes" : "No");
    }
    catch(IOException ignore){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation isQube( number : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 100100 do ( (     if (i * i = number) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var product : Main ; product := Main.newMain() ;
     try (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var inputLine : String ; inputLine := reader.readLine() ;
     var numbers : Sequence(String) ; numbers := inputLine->split(" ") ;
     OclFile["System.out"].println(if product.isQube((numbers[0+1] + numbers[1+1])->toInteger()) then "Yes" else "No" endif) )   catch (ignore : IOException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    if(n<=2)System.out.println("1");
    else System.out.println("2");
    for(int i=2 ; i<=n+1 ; i++){
      if(! prime(i)){
        System.out.print("2 ");
      }
      else System.out.print("1 ");
    }
  }
  static boolean prime(int n){
    int i ;
    for(i=2 ; i<=(int)Math.sqrt(n); i++){
      if(n % i==0)return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n <= 2) then     OclFile["System.out"].println("1") else     OclFile["System.out"].println("2") ; ;  
         var i : int ; i := 2 ; while i <= n + 1 do ( (     if (not(prime(i))) then (     OclFile["System.out"].print("2 ") ) else     OclFile["System.out"].print("1 ") ; )  ;     i := i + 1 ) );
  static   operation prime( n : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ;
         i := 2 ; while i <= (n)->sqrt()->oclAsType(int) do ( (     if (n mod i = 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  void run(){
    sc=new Scanner(System.in);
    int[] a=new int[100];
    int[] b=new int[100];
    int n=0 ;
    for(; sc.hasNext(); ){
      System.arraycopy(a,0,b,0,100);
      String[] s=sc.nextLine().split(",");
      if(s.length>n){
        for(int i=0 ; i<s.length ; i++){
          int m=Integer.parseInt(s[i]);
          if(i>0)a[i]=max(b[i-1]+m,b[i]+m);
          else a[i]=b[i]+m ;
        }
      }
      else {
        for(int i=0 ; i<s.length ; i++){
          int m=Integer.parseInt(s[i]);
          a[i]=max(b[i+1]+m,b[i]+m);
        }
      }
      n=s.length ;
    }
    println(a[0]+"");
    sc.close();
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var a : Sequence(int) ; a := Integer.subrange(1,100)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,100)->collect(0) ;
    var n : int ; n := 0 ;
      while sc.hasNext() do ( (     for _x : Integer.subrange(1,100) do b[0 + _x] := a[0 + _x] ; 
     var s : Sequence(String) ; s := sc.nextLine()->split(",") ;
     if (s->size() > n) then (         var i : int ; i := 0 ; while i < s->size() do ( (     var m : int ; m := (s[i+1])->toInteger() ;
     if (i > 0) then     a[i+1] := Set{b[i - 1+1] + m, b[i+1] + m}->max() ; else     a[i+1] := b[i+1] + m ; )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < s->size() do ( (     var m : int ; m := (s[i+1])->toInteger() ;
     a[i+1] := Set{b[i + 1+1] + m, b[i+1] + m}->max() )  ;     i := i + 1 ) ) ;  
     n := s->size() )  ) ; 
    execute println(a[0+1] + "") ; 
    skip ; 
 );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void countPairs(int arr[],int n){
    int even=0,odd=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] % 2==0)even++;
      else odd++;
    }
    System.out.println((even)*(n-1));
    System.out.println((odd)*(n-1));
  }
  public static void main(String args[]){
    int arr[]={
      2,3,4,5 };
      int n=arr.length ;
      countPairs(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countPairs( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var even : int ; even := 0 ;
    var odd : int ; odd := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 = 0) then     even := even + 1 ; else     odd := odd + 1 ; )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println((even) * (n - 1)) ; 
     OclFile["System.out"].println((odd) * (n - 1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4,5} ;
     var n : int ; n := arr->size() ;
     execute countPairs(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1613 {
  private static final double[] POWER={
    1,10,100,1000,10000,100000 };
    public static void main(String[] args){
      Scanner s=new Scanner(System.in);
      int noOfComparison=s.nextInt();
      for(int i=0 ; i<noOfComparison ; i++){
        int x1=s.nextInt();
        int p1=s.nextInt();
        int x2=s.nextInt();
        int p2=s.nextInt();
        compare(x1,p1,x2,p2);
      }
    }
    private static void compare(int x1,int p1,int x2,int p2){
      if(p1==p2){
        directCompare(x1,x2);
      }
      else {
        double xx1=x1 ;
        double xx2=x2 ;
        while(xx1 % 10==0){
          xx1/=10 ;
          p1++;
        }
        while(xx2 % 10==0){
          xx2/=10 ;
          p2++;
        }
        if(p1>p2){
          xx1*=cachedPower(p1-p2);
        }
        else if(p2>p1){
          xx2*=cachedPower(p2-p1);
        }
        directCompare(xx1,xx2);
      }
    }
    private static double cachedPower(int p){
      if(p<6){
        return POWER[p];
      }
      else {
        return Math.pow(10,(p));
      }
    }
    private static void directCompare(int x1,int x2){
      if(x1>x2){
        System.out.println(">");
      }
      else if(x2>x1){
        System.out.println("<");
      }
      else {
        System.out.println("=");
      }
    }
    private static void directCompare(double x1,double x2){
      if(x1>x2){
        System.out.println(">");
      }
      else if(x2>x1){
        System.out.println("<");
      }
      else {
        System.out.println("=");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class A1613 {
  static    attribute POWER : Sequence(double) := Sequence{1,10,100,1000,10000,100000};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var noOfComparison : int ; noOfComparison := s.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < noOfComparison do ( (     var x1 : int ; x1 := s.getCurrent()->toInteger() ;
     var p1 : int ; p1 := s.getCurrent()->toInteger() ;
    var x2 : int ; x2 := s.getCurrent()->toInteger() ;
    var p2 : int ; p2 := s.getCurrent()->toInteger() ;
    execute compare(x1, p1, x2, p2) ; 
 )  ;     i := i + 1 ) );
  static   operation compare( x1 : int, p1 : int, x2 : int, p2 : int) : void
  pre: true
  post: true
  activity: (     if (p1 = p2) then (     execute directCompare(x1, x2) ) else (     var xx1 : double ; xx1 := x1 ;
     var xx2 : double ; xx2 := x2 ;
    while (xx1 mod 10 = 0) do (     xx1 := xx1/(10) ; 
     p1 := p1 + 1 ) ; 
    while (xx2 mod 10 = 0) do (     xx2 := xx2/(10) ; 
     p2 := p2 + 1 ) ; 
    if (p1 > p2) then (     xx1 := xx1*(cachedPower(p1 - p2)) ) else     if (p2 > p1) then (     xx2 := xx2*(cachedPower(p2 - p1)) ) else skip ; ;  
    execute directCompare(xx1, xx2) ; 
 ) );
  static   operation cachedPower( p : int) : double
  pre: true
  post: true
  activity: (     if (p < 6) then (     return POWER[p+1] ) else (     return 10->pow((p)) ) );
  static   operation directCompare( x1 : int, x2 : int) : void
  pre: true
  post: true
  activity: (     if (x1 > x2) then (     OclFile["System.out"].println(">") ) else     if (x2 > x1) then (     OclFile["System.out"].println("<") ) else (     OclFile["System.out"].println("=") ) ;  );
  static   operation directCompare( x1 : double, x2 : double) : void
  pre: true
  post: true
  activity: (     if (x1 > x2) then (     OclFile["System.out"].println(">") ) else     if (x2 > x1) then (     OclFile["System.out"].println("<") ) else (     OclFile["System.out"].println("=") ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1613 {
  private static final int[] POWER={
    1,10,100,1000,10000,100000 };
    public static void main(String[] args){
      Scanner s=new Scanner(System.in);
      int noOfComparison=s.nextInt();
      for(int i=0 ; i<noOfComparison ; i++){
        int x1=s.nextInt();
        int p1=s.nextInt();
        int x2=s.nextInt();
        int p2=s.nextInt();
        compare(x1,p1,x2,p2);
      }
    }
    private static void compare(int x1,int p1,int x2,int p2){
      if(p1==p2){
        directCompare(x1,x2);
      }
      else {
        double xx1=x1 ;
        double xx2=x2 ;
        while(xx1 % 10==0){
          xx1/=10 ;
          p1++;
        }
        while(xx2 % 10==0){
          xx2/=10 ;
          p2++;
        }
        if(p1>p2){
          xx1*=Math.pow(10,(p1-p2));
        }
        else if(p2>p1){
          xx2*=Math.pow(10,p2-p1);
        }
        directCompare(xx1,xx2);
      }
    }
    private static void directCompare(int x1,int x2){
      if(x1>x2){
        System.out.println(">");
      }
      else if(x2>x1){
        System.out.println("<");
      }
      else {
        System.out.println("=");
      }
    }
    private static void directCompare(double x1,double x2){
      if(x1>x2){
        System.out.println(">");
      }
      else if(x2>x1){
        System.out.println("<");
      }
      else {
        System.out.println("=");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class A1613 {
  static    attribute POWER : Sequence(int) := Sequence{1,10,100,1000,10000,100000};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var noOfComparison : int ; noOfComparison := s.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < noOfComparison do ( (     var x1 : int ; x1 := s.getCurrent()->toInteger() ;
     var p1 : int ; p1 := s.getCurrent()->toInteger() ;
    var x2 : int ; x2 := s.getCurrent()->toInteger() ;
    var p2 : int ; p2 := s.getCurrent()->toInteger() ;
    execute compare(x1, p1, x2, p2) ; 
 )  ;     i := i + 1 ) );
  static   operation compare( x1 : int, p1 : int, x2 : int, p2 : int) : void
  pre: true
  post: true
  activity: (     if (p1 = p2) then (     execute directCompare(x1, x2) ) else (     var xx1 : double ; xx1 := x1 ;
     var xx2 : double ; xx2 := x2 ;
    while (xx1 mod 10 = 0) do (     xx1 := xx1/(10) ; 
     p1 := p1 + 1 ) ; 
    while (xx2 mod 10 = 0) do (     xx2 := xx2/(10) ; 
     p2 := p2 + 1 ) ; 
    if (p1 > p2) then (     xx1 := xx1*(10->pow((p1 - p2))) ) else     if (p2 > p1) then (     xx2 := xx2*(10->pow(p2 - p1)) ) else skip ; ;  
    execute directCompare(xx1, xx2) ; 
 ) );
  static   operation directCompare( x1 : int, x2 : int) : void
  pre: true
  post: true
  activity: (     if (x1 > x2) then (     OclFile["System.out"].println(">") ) else     if (x2 > x1) then (     OclFile["System.out"].println("<") ) else (     OclFile["System.out"].println("=") ) ;  );
  static   operation directCompare( x1 : double, x2 : double) : void
  pre: true
  post: true
  activity: (     if (x1 > x2) then (     OclFile["System.out"].println(">") ) else     if (x2 > x1) then (     OclFile["System.out"].println("<") ) else (     OclFile["System.out"].println("=") ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1613 {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int noOfComparison=s.nextInt();
    for(int i=0 ; i<noOfComparison ; i++){
      int x1=s.nextInt();
      int p1=s.nextInt();
      int x2=s.nextInt();
      int p2=s.nextInt();
      compare(x1,p1,x2,p2);
    }
  }
  private static void compare(int x1,int p1,int x2,int p2){
    if(p1==p2){
      directCompare(x1,x2);
    }
    else {
      while(x1 % 10==0){
        x1/=10 ;
        p1++;
      }
      while(x2 % 10==0){
        x2/=10 ;
        p2++;
      }
      if(p1>p2){
        x1*=Math.pow(10,(p1-p2));
      }
      else if(p2>p1){
        x2*=Math.pow(10,p2-p1);
      }
      directCompare(x1,x2);
    }
  }
  private static void directCompare(int x1,int x2){
    if(x1>x2){
      System.out.println(">");
    }
    else if(x2>x1){
      System.out.println("<");
    }
    else {
      System.out.println("=");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1613 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var noOfComparison : int ; noOfComparison := s.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < noOfComparison do ( (     var x1 : int ; x1 := s.getCurrent()->toInteger() ;
     var p1 : int ; p1 := s.getCurrent()->toInteger() ;
    var x2 : int ; x2 := s.getCurrent()->toInteger() ;
    var p2 : int ; p2 := s.getCurrent()->toInteger() ;
    execute compare(x1, p1, x2, p2) ; 
 )  ;     i := i + 1 ) );
  static   operation compare( x1 : int, p1 : int, x2 : int, p2 : int) : void
  pre: true
  post: true
  activity: (     if (p1 = p2) then (     execute directCompare(x1, x2) ) else (     while (x1 mod 10 = 0) do (     x1 := x1/(10) ; 
     p1 := p1 + 1 ) ; 
     while (x2 mod 10 = 0) do (     x2 := x2/(10) ; 
     p2 := p2 + 1 ) ; 
     if (p1 > p2) then (     x1 := x1*(10->pow((p1 - p2))) ) else     if (p2 > p1) then (     x2 := x2*(10->pow(p2 - p1)) ) else skip ; ;  
     execute directCompare(x1, x2) ) );
  static   operation directCompare( x1 : int, x2 : int) : void
  pre: true
  post: true
  activity: (     if (x1 > x2) then (     OclFile["System.out"].println(">") ) else     if (x2 > x1) then (     OclFile["System.out"].println("<") ) else (     OclFile["System.out"].println("=") ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    String arrs[]=new String[n];
    for(int i=0 ; i<n ; i++){
      arrs[i]=sc.next();
    }
    int[] length=new int[n];
    int index=0 ;
    int returnDex=0 ;
    for(String tmp : arrs){
      int dexG=tmp.indexOf("G");
      int dexS=tmp.indexOf("S");
      if(dexG>dexS){
        returnDex=-1 ;
      }
      length[index++]=dexS-dexG ;
    }
    HashSet set=new HashSet<Integer>();
    for(int len : length){
      set.add(len);
    }
    if(returnDex==-1){
      System.out.println(returnDex);
    }
    else {
      System.out.println(set.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arrs : Sequence(String) ; arrs := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     arrs[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    var length : Sequence(int) ; length := Integer.subrange(1,n)->collect(0) ;
    var index : int ; index := 0 ;
    var returnDex : int ; returnDex := 0 ;
    for (tmp : arrs) do ( (     var dexG : int ; dexG := tmp->indexOf("G")-1 ;
     var dexS : int ; dexS := tmp->indexOf("S")-1 ;
     if (dexG > dexS) then (     returnDex := -1 ) else skip ; 
      length[index+1] := dexS - dexG  ; index := index + 1 )  ) ; 
    var set : Set ; set := Set{} ;
    for (len : length) do ( (     set := set->including(len) )  ) ; 
    if (returnDex = -1) then (     OclFile["System.out"].println(returnDex) ) else (     OclFile["System.out"].println(set->size()) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    ArrayList<String>list=new ArrayList<>();
    int flag=0 ;
    for(int i=0 ; i<n ; i++){
      String temp=sc.next();
      list.add(temp);
      if(temp.lastIndexOf('G')>temp.lastIndexOf('S')){
        flag=1 ;
      }
    }
    int result=0 ;
    if(flag==1){
      result=-1 ;
    }
    else {
      HashSet<Integer>hset=new HashSet<>();
      for(int i=0 ; i<list.size(); i++){
        hset.add(list.get(i).indexOf('S')-list.get(i).indexOf('G'));
      }
      result=hset.size();
    }
    System.out.print(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var list : Sequence(String) ; list := Sequence{} ;
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : String ; temp := sc.getCurrent() ;
     list := list->including(temp) ; 
     if (temp->lastIndexOf('G')-1 > temp->lastIndexOf('S')-1) then (     flag := 1 ) else skip )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
    if (flag = 1) then (     result := -1 ) else (     var hset : Set(int) ; hset := Set{} ;
         var i : int ; i := 0 ; while i < list->size() do ( (     hset := hset->including(list->at(i+1)->indexOf('S')-1 - list->at(i+1)->indexOf('G')-1) )  ;     i := i + 1 ) ; 
     result := hset->size() ) ;  
    OclFile["System.out"].print(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean search(int arr[],int n,int x){
    int front=0,back=n-1 ;
    while(front<=back){
      if(arr[front]==x || arr[back]==x)return true ;
      front++;
      back--;
    }
    return false ;
  }
  public static void main(String[] args){
    int arr[]={
      10,20,80,30,60,50,110,100,130,170 };
      int x=130 ;
      int n=arr.length ;
      if(search(arr,n,x))System.out.print("Yes");
      else System.out.print("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation search( arr : Sequence(int), n : int, x : int) : boolean
  pre: true
  post: true
  activity: (     var front : int ; front := 0 ;
    var back : int ; back := n - 1 ;
     while (front <= back) do (     if (arr[front+1] = x or arr[back+1] = x) then     return true else skip ; 
     front := front + 1 ; 
     back := back - 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,20,80,30,60,50,110,100,130,170} ;
     var x : int ; x := 130 ;
     var n : int ; n := arr->size() ;
     if (search(arr, n, x)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void countFreq(int arr[],int n){
    Map<Integer,Integer>mp=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      mp.put(arr[i],mp.get(arr[i])==null ? 1 : mp.get(arr[i])+1);
    }
    for(int i=0 ; i<n ; i++){
      if(mp.get(arr[i])!=-1){
        System.out.println(arr[i]+" "+mp.get(arr[i]));
        mp.put(arr[i],-1);
      }
    }
  }
  public static void main(String[] args){
    int arr[]={
      10,20,20,10,10,20,5,20 };
      int n=arr.length ;
      countFreq(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countFreq( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     mp := mp->union(Map{arr[i+1] |-> if mp->at(arr[i+1]) = null then 1 else mp->at(arr[i+1]) + 1 endif}) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (mp->at(arr[i+1]) /= -1) then (     OclFile["System.out"].println(arr[i+1] + " " + mp->at(arr[i+1])) ; 
     mp := mp->union(Map{arr[i+1] |-> -1}) ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,20,20,10,10,20,5,20} ;
     var n : int ; n := arr->size() ;
     execute countFreq(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num1=sc.nextInt();
    int num2=sc.nextInt();
    int num3=0 ;
    if(num2<10)num3=num1*10+num2 ;
    else if(num2<100)num3=num1*100+num2 ;
    else num3=num1*1000+num2 ;
    boolean flag=false ;
    for(int i=0 ; i<316 ; i++){
      if(num3==i*i){
        System.out.println("Yes");
        flag=true ;
      }
    }
    if(! flag)System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num1 : int ; num1 := sc.getCurrent()->toInteger() ;
    var num2 : int ; num2 := sc.getCurrent()->toInteger() ;
    var num3 : int ; num3 := 0 ;
    if (num2 < 10) then     num3 := num1 * 10 + num2 else     if (num2 < 100) then     num3 := num1 * 100 + num2 else     num3 := num1 * 1000 + num2 ; ;  ;  
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < 316 do ( (     if (num3 = i * i) then (     OclFile["System.out"].println("Yes") ; 
     flag := true ) else skip )  ;     i := i + 1 ) ; 
    if (not(flag)) then     OclFile["System.out"].println("No") ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int H=scanner.nextInt();
    int W=scanner.nextInt();
    int N=scanner.nextInt();
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++)a[i]=scanner.nextInt();
    int[][] color=new int[H][W];
    int c=0 ;
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        int k=j ;
        if(i % 2!=0)k=W-j-1 ;
        if(a[c]==0)c++;
        color[i][k]=c+1 ;
        a[c]--;
      }
    }
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        System.out.print(color[i][j]);
        if(j<W-1)System.out.print(' ');
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := scanner.getCurrent()->toInteger() ;
    var W : int ; W := scanner.getCurrent()->toInteger() ;
    var N : int ; N := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     a[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var color : Sequence(Sequence(int)) ; color := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     var k : int ; k := j ;
     if (i mod 2 /= 0) then     k := W - j - 1 ; else skip ; 
    if (a[c+1] = 0) then     c := c + 1 ; else skip ; 
    color[i+1][k+1] := c + 1 ; 
    a[c+1] := a[c+1] - 1 ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     OclFile["System.out"].print(color[i+1][j+1]) ; 
     if (j < W - 1) then     OclFile["System.out"].print(' ') ; else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private void solve(){
    Scanner io=new Scanner(System.in);
    int H=io.nextInt();
    int W=io.nextInt();
    int N=io.nextInt();
    int[][] map=new int[H][W];
    int color=1 ;
    int num=io.nextInt();
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        if(num==0){
          color++;
          num=io.nextInt();
        }
        if(i % 2==0){
          map[i][j]=color ;
        }
        else {
          map[i][W-1-j]=color ;
        }
        num--;
      }
    }
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        System.out.print(map[i][j]);
        System.out.print((j==W-1)? "\n" : " ");
      }
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := io.getCurrent()->toInteger() ;
    var W : int ; W := io.getCurrent()->toInteger() ;
    var N : int ; N := io.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
    var color : int ; color := 1 ;
    var num : int ; num := io.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (num = 0) then (     color := color + 1 ; 
     num := io.getCurrent()->toInteger() ) else skip ; 
     if (i mod 2 = 0) then (     map[i+1][j+1] := color ) else (     map[i+1][W - 1 - j+1] := color ) ;  
     num := num - 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     OclFile["System.out"].print(map[i+1][j+1]) ; 
     OclFile["System.out"].print(if (j = W - 1) then "\n" else " " endif) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.*;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    solve(System.in,System.out);
  }
  static void solve(InputStream is,PrintStream os){
    Scanner sc=new Scanner(is);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int n=sc.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    List<Integer>list=new ArrayList<>(w*h);
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<a[i]; j++){
        list.add(i+1);
      }
    }
    boolean reverse=false ;
    List<String>lines=new ArrayList<>(h);
    for(int i=0 ; i<h ; i++){
      List<Integer>line=list.subList(i*w,(i+1)*w);
      if(reverse)Collections.reverse(line);
      lines.add(line.stream().map(String :: valueOf).collect(Collectors.joining(" ")));
      reverse=! reverse ;
    }
    os.println(String.join(System.lineSeparator(),lines));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation solve( is : OclFile, os : OclFile) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(is) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var list : Sequence(int) ; list := Sequence{}->union(w * h) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < a[i+1] do ( (     list := list->including(i + 1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var reverse : boolean ; reverse := false ;
    var lines : Sequence(String) ; lines := Sequence{} ;
        var i : int ; i := 0 ; while i < h do ( (     var line : Sequence(int) ; line := list.subrange(i * w+1,(i + 1) * w) ;
     if (reverse) then     line := line->reverse() ; else skip ; 
     lines := lines->including(line->collect( _x1 | (lambda _pars : OclAny in String.newString().valueOf(_pars))->apply(_x1) ).collect(Collectors.joining(" "))) ; 
     reverse := not(reverse) )  ;     i := i + 1 ) ; 
    os.println(join(lineSeparator(), lines)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    int h=Integer.parseInt(sa[0]);
    int w=Integer.parseInt(sa[1]);
    int n=Integer.parseInt(br.readLine());
    int[] a=new int[n];
    sa=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(sa[i]);
    }
    br.close();
    int[] c=new int[h*w];
    int k=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<a[i]; j++){
        c[k]=i+1 ;
        k++;
      }
    }
    for(int i=0 ; i<h ; i++){
      StringBuilder sb=new StringBuilder();
      for(int j=0 ; j<w ; j++){
        k=w*i ;
        if(i % 2==0){
          k+=j ;
        }
        else {
          k+=w-1-j ;
        }
        sb.append(c[k]).append(' ');
      }
      sb.deleteCharAt(sb.length()-1);
      System.out.println(sb.toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var h : int ; h := (sa[0+1])->toInteger() ;
    var w : int ; w := (sa[1+1])->toInteger() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    sa := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sa[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var c : Sequence(int) ; c := Integer.subrange(1,h * w)->collect(0) ;
    var k : int ; k := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < a[i+1] do ( (     c[k+1] := i + 1 ; 
     k := k + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < h do ( (     var sb : String ; sb := StringLib.newString() ;
         var j : int ; j := 0 ; while j < w do ( (     k := w * i ; 
     if (i mod 2 = 0) then (     k := k+(j) ) else (     k := k+(w - 1 - (j)->char2byte()) ) ;  
     sb := sb + StringLib.newString(c[k+1]) + StringLib.newString(' ') )  ;     j := j + 1 ) ; 
     sb := sb->excludingAt(sb->size() - 1+1) ; 
     OclFile["System.out"].println(sb+"") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MinCostTree(int arr[],int n){
    int ans=0 ;
    Vector<Integer>st=new Vector<Integer>();
    st.add(Integer.MAX_VALUE);
    for(int i=0 ; i<n ; i++){
      while(st.get(st.size()-1)<=arr[i]){
        int x=st.get(st.size()-1);
        st.remove(st.size()-1);
        ans+=x*Math.min(st.get(st.size()-1),arr[i]);
      }
      st.add(arr[i]);
    }
    for(int i=2 ; i<st.size(); i++)ans+=st.get(i)*st.get(i-1);
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      5,2,3 };
      int n=arr.length ;
      System.out.print(MinCostTree(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MinCostTree( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var st : Sequence(int) ; st := Sequence{} ;
    st := st->including(2147483647) ; 
        var i : int ; i := 0 ; while i < n do ( (     while (st->at(st->size() - 1+1) <= arr[i+1]) do (     var x : int ; x := st->at(st->size() - 1+1) ;
     st := st->excludingFirst(st->size() - 1) ; 
     ans := ans+(x * Set{st->at(st->size() - 1+1), arr[i+1]}->min()) ) ; 
     st := st->including(arr[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i < st->size() do (     ans := ans+(st->at(i+1) * st->at(i - 1+1)) ;  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,2,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(MinCostTree(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    String t=sc.next();
    int cache1[]=new int[26];
    int cache2[]=new int[26];
    for(int i=0 ; i<n ; i++){
      cache1[s.charAt(i)-'a']++;
      cache2[t.charAt(i)-'a']++;
    }
    int flag=0 ;
    for(int i=0 ; i<26 ; i++){
      if(cache1[i]!=cache2[i]){
        flag=1 ;
        break ;
      }
    }
    if(flag==1){
      System.out.println("-1");
      System.exit(0);
    }
    char[] s1=s.toCharArray();
    char[] s2=t.toCharArray();
    List<Integer>l=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      if(s1[i]==s2[i])continue ;
      int pos=-1 ;
      for(int j=i+1 ; j<n ; j++){
        if(s1[j]==s2[i]){
          pos=j ;
          break ;
        }
      }
      for(int j=pos-1 ; j>=i ; j--){
        l.add(j);
        char temp=s1[j+1];
        s1[j+1]=s1[j];
        s1[j]=temp ;
      }
      s1[i]=s2[i];
    }
    System.out.println(l.size());
    for(int x : l){
      System.out.print((x+1)+" ");
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var cache1 : Sequence(int) ; cache1 := Integer.subrange(1,26)->collect(0) ;
    var cache2 : Sequence(int) ; cache2 := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     cache1[s->at(i+1) - ('a')->char2byte()+1] := cache1[s->at(i+1) - ('a')->char2byte()+1] + 1 ; 
     cache2[t->at(i+1) - ('a')->char2byte()+1] := cache2[t->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < 26 do ( (     if (cache1[i+1] /= cache2[i+1]) then (     flag := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 1) then (     OclFile["System.out"].println("-1") ; 
 OclProcess.exit(0) ) else skip ; 
    var s1 : Sequence(String) ; s1 := s->characters() ;
    var s2 : Sequence(String) ; s2 := t->characters() ;
    var l : Sequence(int) ; l := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (s1[i+1] = s2[i+1]) then     continue else skip ; 
     var pos : int ; pos := -1 ;
        var j : int ; j := i + 1 ; while j < n do ( (     if (s1[j+1] = s2[i+1]) then (     pos := j ; 
     break ) else skip )  ;     j := j + 1 ) ; 
        var j : int ; j := pos - 1 ; while j >= i do ( (     l := l->including(j) ; 
     var temp : String ; temp := s1[j + 1+1] ;
     s1[j + 1+1] := s1[j+1] ; 
     s1[j+1] := temp )  ;     j := j - 1 ) ; 
    s1[i+1] := s2[i+1] ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(l->size()) ; 
    for (x : l) do ( (     OclFile["System.out"].print((x + 1) + " ") )  ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B_Obtaining_the_String {
  private static void swap(char[] s,int i,int j){
    char temp ;
    temp=s[i];
    s[i]=s[i+1];
    s[i+1]=temp ;
  }
  private static void swappedPosition(char[] s,char[] t){
    int n=s.length ;
    List<Integer>ans=new ArrayList<>();
    for(int i=0 ; i<n ; ++i){
      if(s[i]==t[i])continue ;
      int pos=-1 ;
      for(int j=i+1 ; j<n ; ++j){
        if(s[j]==t[i]){
          pos=j ;
          break ;
        }
      }
      if(pos==-1){
        System.out.println("-1");
        return ;
      }
      for(int j=pos-1 ; j>=i ; --j){
        swap(s,j,j+1);
        ans.add(j);
      }
    }
    System.out.println(ans.size());
    for(int itr : ans)System.out.print((itr+1)+" ");
  }
  private static Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    int n ;
    n=in.nextInt();
    String s=in.next();
    String t=in.next();
    char[] sChar=s.toCharArray();
    char[] tChar=t.toCharArray();
    swappedPosition(sChar,tChar);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Obtaining_the_String {
  static   operation swap( s : Sequence(String), i : int, j : int) : void
  pre: true
  post: true
  activity: (     var temp : String ;
     temp := s[i+1] ; 
     s[i+1] := s[i + 1+1] ; 
     s[i + 1+1] := temp );
  static   operation swappedPosition( s : Sequence(String), t : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var ans : Sequence(int) ; ans := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] = t[i+1]) then     continue else skip ; 
     var pos : int ; pos := -1 ;
        var j : int ; j := i + 1 ; while j < n do ( (     if (s[j+1] = t[i+1]) then (     pos := j ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (pos = -1) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
        var j : int ; j := pos - 1 ; while j >= i do ( (     execute swap(s, j, j + 1) ; 
     ans := ans->including(j) )  ;     j := j - 1 ) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans->size()) ; 
    for (itr : ans) do (     OclFile["System.out"].print((itr + 1) + " ") ;  ) ; 
 );
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     n := in.getCurrent()->toInteger() ; 
    var s : String ; s := in.getCurrent() ;
    var t : String ; t := in.getCurrent() ;
    var sChar : Sequence(String) ; sChar := s->characters() ;
    var tChar : Sequence(String) ; tChar := t->characters() ;
    execute swappedPosition(sChar, tChar) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class ObtainingTheString {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String s=br.readLine();
    StringBuilder sb=new StringBuilder(s);
    String t=br.readLine();
    List<Integer>res=new ArrayList<>();
    boolean flag=true ;
    for(int i=n-1 ; i>=0 ; i--){
      char c1=sb.charAt(i);
      char c2=t.charAt(i);
      if(c1!=c2){
        int pos=-1 ;
        for(int j=i-1 ; j>=0 ; j--){
          if(sb.charAt(j)==c2){
            pos=j ;
            break ;
          }
        }
        if(pos==-1){
          flag=false ;
          break ;
        }
        for(int j=pos ; j<i ; j++){
          swap(sb,j,j+1);
          res.add(j);
        }
      }
    }
    if(! flag)System.out.println(-1);
    else {
      System.out.println(res.size());
      for(int elem : res)System.out.print((elem+1)+" ");
      System.out.println();
    }
  }
  private static void swap(StringBuilder sb,int i,int j){
    char temp=sb.charAt(i);
    sb.setCharAt(i,sb.charAt(j));
    sb.setCharAt(j,temp);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ObtainingTheString {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var s : String ; s := br.readLine() ;
    var sb : String ; sb := StringLib.newString(s) ;
    var t : String ; t := br.readLine() ;
    var res : Sequence(int) ; res := Sequence{} ;
    var flag : boolean ; flag := true ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     var c1 : String ; c1 := sb->at(i+1) ;
     var c2 : String ; c2 := t->at(i+1) ;
     if (c1 /= c2) then (     var pos : int ; pos := -1 ;
         var j : int ; j := i - 1 ; while j >= 0 do ( (     if (sb->at(j+1) = c2) then (     pos := j ; 
     break ) else skip )  ;     j := j - 1 ) ; 
     if (pos = -1) then (     flag := false ; 
     break ) else skip ; 
         var j : int ; j := pos ; while j < i do ( (     execute swap(sb, j, j + 1) ; 
     res := res->including(j) )  ;     j := j + 1 ) ) else skip )  ;     i := i - 1 ) ; 
    if (not(flag)) then     OclFile["System.out"].println(-1) else (     OclFile["System.out"].println(res->size()) ; 
     for (elem : res) do (     OclFile["System.out"].print((elem + 1) + " ") ;  ) ; 
     OclFile["System.out"].println() ) ;  
 );
  static   operation swap( sb : String, i : int, j : int) : void
  pre: true
  post: true
  activity: (     var temp : String ; temp := sb->at(i+1) ;
     sb := sb.setAt(i+1, sb->at(j+1)) ; 
     sb := sb.setAt(j+1, temp) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static long[] tree=new long[400000];
  static long max(int pos,int l,int r,int min,int max){
    long ret=0 ;
    if(l==min && r==max)return tree[pos];
    int m=(l+r)/2 ;
    if(min<m){
      ret=Math.max(ret,max(pos*2+1,l,m,min,Math.min(m,max)));
    }
    if(m<max){
      ret=Math.max(ret,max(pos*2+2,m,r,Math.max(m,min),max));
    }
    return ret ;
  }
  static void set(int pos,int l,int r,int index,long v){
    tree[pos]=Math.max(tree[pos],v);
    if(l==r-1)return ;
    int m=(l+r)/2 ;
    if(index<m){
      set(pos*2+1,l,m,index,v);
    }
    else {
      set(pos*2+2,m,r,index,v);
    }
  }
  public static void main(String[] args){
    int N=sc.nextInt();
    int size=1 ;
    while(size<=N){
      size*=2 ;
    }
    for(int i=0 ; i<N ; ++i){
      int x=sc.nextInt();
      long max=max(0,0,size,0,x);
      set(0,0,size,x,max+x);
    }
    System.out.println((long)N*(N+1)/2-tree[0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute tree : Sequence(long) := Integer.subrange(1,400000)->collect(0);
  static   operation max( pos : int, l : int, r : int, min : int, max : int) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := 0 ;
     if (l = min & r = max) then     return tree[pos+1] else skip ; 
    var m : int ; m := (l + r) / 2 ;
    if (min < m) then (     ret := Set{ret, Set{pos * 2 + 1, l, m, min, Set{m, max}->min()}->max()}->max() ) else skip ; 
    if (m < max) then (     ret := Set{ret, Set{pos * 2 + 2, m, r, Set{m, min}->max(), max}->max()}->max() ) else skip ; 
    return ret 
 );
  static   operation set( pos : int, l : int, r : int, index : int, v : long) : void
  pre: true
  post: true
  activity: (     tree[pos+1] := Set{tree[pos+1], v}->max() ; 
     if (l = r - 1) then     return else skip ; 
     var m : int ; m := (l + r) / 2 ;
     if (index < m) then (     execute set(pos * 2 + 1, l, m, index, v) ) else (     execute set(pos * 2 + 2, m, r, index, v) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var size : int ; size := 1 ;
    while (size <= N) do (     size := size*(2) ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var max : long ; max := max(0, 0, size, 0, x) ;
     execute set(0, 0, size, x, max + x) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(N->oclAsType(long) * (N + 1) / 2 - tree[0+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
public class ProblemC extends CodeJammer {
  @ Override public void process()throws IOException {
    long[] line1=reader.readLongArray();
    long r=line1[0];
    long k=line1[1];
    int n=(int)line1[2];
    long[] g=reader.readLongArray();
    int depth=(int)(Math.log(r)/Math.log(2))+2 ;
    int[][] indexReached=new int[depth][n];
    long[][] riders=new long[depth][n];
    for(int i=0 ; i<n ; i++){
      long boarded=0 ;
      int next=i ;
      do {
        boarded+=g[next];
        next++;
        if(next>=n)next-=n ;
      }
      while(next!=i && boarded+g[next]<=k);
      indexReached[0][i]=next ;
      riders[0][i]=boarded ;
    }
    for(int d=1 ; d<depth ; d++){
      for(int i=0 ; i<n ; i++){
        int middleIndex=indexReached[d-1][i];
        indexReached[d][i]=indexReached[d-1][middleIndex];
        riders[d][i]=riders[d-1][i]+riders[d-1][middleIndex];
      }
    }
    long ridesLeft=r ;
    long total=0 ;
    int nextIndex=0 ;
    while(ridesLeft>0){
      long chunk=1 ;
      int d=0 ;
      while(2*chunk<=ridesLeft){
        chunk*=2 ;
        d+=1 ;
      }
      ridesLeft-=chunk ;
      total+=riders[d][nextIndex];
      nextIndex=indexReached[d][nextIndex];
    }
    output(total);
  }
  public static void main(String[] args){
    ProblemC p=new ProblemC();
    p.run(args);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemC extends CodeJammer {
      operation process() : void
  pre: true
  post: true
  activity: (     var line1 : Sequence(long) ; line1 := reader.readLongArray() ;
     var r : long ; r := line1[0+1] ;
    var k : long ; k := line1[1+1] ;
    var n : int ; n := line1[2+1]->oclAsType(int) ;
    var g : Sequence(long) ; g := reader.readLongArray() ;
    var depth : int ; depth := ((r)->log() / (2)->log())->oclAsType(int) + 2 ;
    var indexReached : Sequence(Sequence(int)) ; indexReached := Integer.subrange(1,depth)->collect(Integer.subrange(1,n)->collect(0)) ;
    var riders : Sequence(Sequence(long)) ; riders := Integer.subrange(1,depth)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var boarded : long ; boarded := 0 ;
     var next : int ; next := i ;
  while true do ((     boarded := boarded+(g[next+1]) ; 
     next := next + 1 ; 
     if (next >= n) then     next := next-(n) ; else skip ) ;
    if (next /= i & boarded + g[next+1] <= k) then skip else break) ; 
    indexReached[0+1][i+1] := next ; 
    riders[0+1][i+1] := boarded ; 
 )  ;     i := i + 1 ) ; 
        var d : int ; d := 1 ; while d < depth do ( (         var i : int ; i := 0 ; while i < n do ( (     var middleIndex : int ; middleIndex := indexReached[d - 1+1][i+1] ;
     indexReached[d+1][i+1] := indexReached[d - 1+1][middleIndex+1] ; 
     riders[d+1][i+1] := riders[d - 1+1][i+1] + riders[d - 1+1][middleIndex+1] )  ;     i := i + 1 ) )  ;     d := d + 1 ) ; 
    var ridesLeft : long ; ridesLeft := r ;
    var total : long ; total := 0 ;
    var nextIndex : int ; nextIndex := 0 ;
    while (ridesLeft > 0) do (     var chunk : long ; chunk := 1 ;
     var d : int ; d := 0 ;
    while (2 * chunk <= ridesLeft) do (     chunk := chunk*(2) ; 
     d := d+(1) ) ; 
    ridesLeft := ridesLeft-(chunk) ; 
    total := total+(riders[d+1][nextIndex+1]) ; 
    nextIndex := indexReached[d+1][nextIndex+1] ; 
 ) ; 
    execute output(total) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : ProblemC ; p := ProblemC.newProblemC() ;
     p.run(args) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findEquation(int a,int b){
    int sum=(a+b);
    int product=(a*b);
    System.out.println("x^2-("+sum+"x)+("+product+")=0");
  }
  public static void main(String args[]){
    int a=2,b=3 ;
    findEquation(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findEquation( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := (a + b) ;
     var product : int ; product := (a * b) ;
     OclFile["System.out"].println("x^2-(" + sum + "x)+(" + product + ")=0") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2 ;
    var b : int ; b := 3 ;
     execute findEquation(a, b) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static void circle_equation(double x1,double y1,double r){
    double a=-2*x1 ;
    double b=-2*y1 ;
    double c=(r*r)-(x1*x1)-(y1*y1);
    System.out.print("x^2+("+a+" x)+");
    System.out.print("y^2+("+b+" y)=");
    System.out.println(c+".");
  }
  public static void main(String arr[]){
    double x1=2,y1=-3,r=8 ;
    circle_equation(x1,y1,r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation circle_equation( x1 : double, y1 : double, r : double) : void
  pre: true
  post: true
  activity: (     var a : double ; a := -2 * x1 ;
     var b : double ; b := -2 * y1 ;
    var c : double ; c := (r * r) - (x1 * x1) - (y1 * y1) ;
    OclFile["System.out"].print("x^2+(" + a + " x)+") ; 
    OclFile["System.out"].print("y^2+(" + b + " y)=") ; 
    OclFile["System.out"].println(c + ".") ; 
 );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x1 : double ; x1 := 2 ;
    var y1 : double ; y1 := -3 ;
    var r : double ; r := 8 ;
     execute circle_equation(x1, y1, r) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Stack ;
public class Main {
  static int h ;
  static int w ;
  static int c ;
  static int ans ;
  static int count ;
  static int[] color_order ;
  static int[][] map ;
  static int[][] tmp ;
  public static void main(String[] args)throws java.io.IOException {
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String ns[]=sc.nextLine().split(" ");
      Stack<Double>stack=new Stack<Double>();
      for(int i=0 ; i<ns.length ; i++){
        if(ns[i] .length()>1){
          stack.push(Double.parseDouble(ns[i]));
        }
        else {
          char sw=ns[i] .charAt(0);
          switch(sw){
            case '0' : case '1' : case '2' : case '3' : case '4' : case '5' : case '6' : case '7' : case '8' : case '9' : stack.push(Double.parseDouble(ns[i]));
            break ;
            case '+' : {
              double x=stack.pop();
              double y=stack.pop();
              stack.push(x+y);
            }
            break ;
            case '-' : {
              double x=stack.pop();
              double y=stack.pop();
              stack.push(y-x);
            }
            break ;
            case '*' : {
              double x=stack.pop();
              double y=stack.pop();
              stack.push(y*x);
            }
            break ;
            case '/' : double x=stack.pop();
            double y=stack.pop();
            stack.push(y/x);
            break ;
          }
        }
      }
      double ans=stack.pop();
      System.out.printf("%.6f\n",ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute h : int;
  static   attribute w : int;
  static   attribute c : int;
  static   attribute ans : int;
  static   attribute count : int;
  static   attribute color_order : Sequence(int);
  static   attribute map : Sequence(Sequence(int));
  static   attribute tmp : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var ns : Sequence(String) ; ns := sc.nextLine()->split(" ") ;
     var stack : Sequence(double) ; stack := Sequence{} ;
        var i : int ; i := 0 ; while i < ns->size() do ( (     if (ns[i+1]->size() > 1) then (     stack := stack->append((ns[i+1])->toReal()) ) else (     var sw : String ; sw := ns[i+1]->at(0+1) ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (sw) ; 
    if _switchval = '0' or _switchval = '1' or _switchval = '2' or _switchval = '3' or _switchval = '4' then
   if _switchval = '5' then
   if _switchval = '6' then
   if _switchval = '7' then
   if _switchval = '8' then
   if _switchval = '9' then
    stack := stack->append((ns[i+1])->toReal()) ; 
    break 
   else skip ;
       if _switchval = '+' then
 (     var x : double ; x := stack->last() ;
     var y : double ; y := stack->last() ;
     stack := stack->append(x + y) ) 
    break 
   else skip ;
       if _switchval = '-' then
 (     var x : double ; x := stack->last() ;
     var y : double ; y := stack->last() ;
     stack := stack->append(y - (x)->char2byte()) ) 
    break 
   else skip ;
       if _switchval = '*' then
 (     var x : double ; x := stack->last() ;
     var y : double ; y := stack->last() ;
     stack := stack->append(y * x) ) 
    break 
   else skip ;
       if _switchval = '/' then
     var x : double ; x := stack->last() ;
    var y : double ; y := stack->last() ;
    stack := stack->append(y / x) ; 
    break 
   else skip ;
 )
 ) )  ;     i := i + 1 ) ; 
    var ans : double ; ans := stack->last() ;
    OclFile["System.out"].printf("%.6f\n", ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void unique_combination(int l,int sum,int K,Vector<Integer>local,Vector<Integer>A){
    if(sum==K){
      System.out.print("{");
      for(int i=0 ; i<local.size(); i++){
        if(i!=0)System.out.print(" ");
        System.out.print(local.get(i));
        if(i!=local.size()-1)System.out.print(",");
      }
      System.out.println("}");
      return ;
    }
    for(int i=l ; i<A.size(); i++){
      if(sum+A.get(i)>K)continue ;
      if(i==1 && A.get(i)==A.get(i-1)&& i>l)continue ;
      local.add(A.get(i));
      unique_combination(i+1,sum+A.get(i),K,local,A);
      local.remove(local.size()-1);
    }
  }
  static void Combination(Vector<Integer>A,int K){
    Collections.sort(A);
    Vector<Integer>local=new Vector<Integer>();
    unique_combination(0,0,K,local,A);
  }
  public static void main(String[] args){
    Integer[] arr={
      10,1,2,7,6,1,5 };
      Vector<Integer>A=new Vector<>(Arrays.asList(arr));
      int K=8 ;
      Combination(A,K);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation unique_combination( l : int, sum : int, K : int, local : Sequence(int), A : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (sum = K) then (     OclFile["System.out"].print("{") ; 
         var i : int ; i := 0 ; while i < local->size() do ( (     if (i /= 0) then     OclFile["System.out"].print(" ") ; else skip ; 
     OclFile["System.out"].print(local->at(i+1)) ; 
     if (i /= local->size() - 1) then     OclFile["System.out"].print(",") ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("}") ; 
     return ) else skip ; 
         var i : int ; i := l ; while i < A->size() do ( (     if (sum + A->at(i+1) > K) then     continue else skip ; 
     if (i = 1 & A->at(i+1) = A->at(i - 1+1) & i > l) then     continue else skip ; 
    local->excludes(A->at(i+1)) ; 
    execute unique_combination(i + 1, sum + A->at(i+1), K, local, A) ; 
    local := local->excludingFirst(local->size() - 1) ; 
 )  ;     i := i + 1 ) );
  static   operation Combination( A : Sequence(int), K : int) : void
  pre: true
  post: true
  activity: (     A := A->sort() ; 
     var local : Sequence(int) ; local := Sequence{} ;
     execute unique_combination(0, 0, K, local, A) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,1,2,7,6,1,5} ;
     var A : Sequence(int) ; A := Sequence{}->union(arr) ;
     var K : int ; K := 8 ;
     execute Combination(A, K) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class demo1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr);
    int q=sc.nextInt();
    for(int j=0 ; j<q ; j++){
      int x=sc.nextInt();
      int l=0 ;
      int r=n-1 ;
      int m=0 ;
      while(l<=r){
        m=(l+r)/2 ;
        if(x>=arr[m])l=m+1 ;
        else r=m-1 ;
      }
      System.out.println(l);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class demo1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var j : int ; j := 0 ; while j < q do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var l : int ; l := 0 ;
    var r : int ; r := n - 1 ;
    var m : int ; m := 0 ;
    while (l <= r) do (     m := (l + r) / 2 ; 
     if (x >= arr[m+1]) then     l := m + 1 ; else     r := m - 1 ; ) ; 
    OclFile["System.out"].println(l) ; 
 )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  private static int right(int q,int arr[]){
    int left=0,right=arr.length-1 ;
    while(left<right){
      int mid=left+(right-left)/2 ;
      if(arr[mid]>q)right=mid ;
      else left=mid+1 ;
    }
    return left ;
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=s.nextInt();
    int q=s.nextInt();
    Arrays.sort(arr);
    for(int i=0 ; i<q ; i++){
      int query=s.nextInt();
      int rightMost=right(query,arr);
      System.out.println(arr[rightMost]<=query ? arr.length : rightMost);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation right( q : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var left : int ; left := 0 ;
    var right : int ; right := arr->size() - 1 ;
     while (left < right) do (     var mid : int ; mid := left + (right - left) / 2 ;
     if (arr[mid+1] > q) then     right := mid ; else     left := mid + 1 ; ) ; 
     return left );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var q : int ; q := s.getCurrent()->toInteger() ;
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < q do ( (     var query : int ; query := s.getCurrent()->toInteger() ;
     var rightMost : int ; rightMost := right(query, arr) ;
     OclFile["System.out"].println(if arr[rightMost+1] <= query then arr->size() else rightMost endif) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Solution {
  public static void main(String[] args){
    FastReader reader=new FastReader();
    PrintWriter writer=new PrintWriter(System.out);
    int numOfShops=reader.nextInt(),val,minVal=Integer.MAX_VALUE,arr[]=new int[100001];
    for(int i=0 ; i<numOfShops ; i++){
      val=reader.nextInt();
      arr[val]++;
      minVal=Math.min(val,minVal);
    }
    for(; minVal<arr.length ; minVal++)arr[minVal]+=arr[minVal-1];
    int numOfDays=reader.nextInt();
    while(numOfDays--!=0){
      val=reader.nextInt();
      writer.println(val>=arr.length ? numOfShops : arr[val]);
    }
    writer.close();
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public FastReader(File f)throws FileNotFoundException {
    br=new BufferedReader(new FileReader(f));
  }
  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());
  }
  double nextDouble(){
    return Double.parseDouble(next());
  }
  long nextLong(){
    return Long.parseLong(next());
  }
  String nextLine(){
    String str="" ;
    try {
      str=br.readLine();
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return str ;
  }
  boolean ready()throws IOException {
    return br.ready();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var numOfShops : int ; numOfShops := reader.nextInt() ;
    var val : int ;
    var minVal : int ; minVal := 2147483647 ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,100001)->collect(0) ;
        var i : int ; i := 0 ; while i < numOfShops do ( (     val := reader.nextInt() ; 
     arr[val+1] := arr[val+1] + 1 ; 
     minVal := Set{val, minVal}->min() )  ;     i := i + 1 ) ; 
      while minVal < arr->size() do (     arr[minVal+1] := arr[minVal+1]+(arr[minVal - 1+1]) ;  ;     minVal := minVal + 1 ) ; 
    var numOfDays : int ; numOfDays := reader.nextInt() ;
        while (numOfDays /= 0) do (    skip ; (     val := reader.nextInt() ; 
     skip ) ;  ) ;  
    skip ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   static operation newFastReader( f : OclFile) : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(f)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static int low=0 ;
  static int high=0 ;
  static int mid=0 ;
  static int f(int[] buf,int n){
    low=0 ;
    high=buf.length-1 ;
    if(n>=buf[high])return high+1 ;
    while(low<high){
      mid=(low+high)/2 ;
      if(buf[mid]>n){
        high=mid ;
      }
      else if(buf[mid]<n){
        low=mid+1 ;
      }
      else {
        low=mid+1 ;
      }
    }
    return low ;
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int[] buf=new int[n];
    for(int i=0 ; i<n ; i++){
      buf[i]=s.nextInt();
    }
    Arrays.sort(buf);
    int q=s.nextInt();
    StringBuffer ans=new StringBuffer();
    for(int i=0 ; i<q ; i++){
      if(i==q-1)ans.append(f(buf,s.nextInt()));
      else ans.append(f(buf,s.nextInt())+"\n");
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute low : int := 0;
  static   attribute high : int := 0;
  static   attribute mid : int := 0;
  static   operation f( buf : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     low := 0 ; 
     high := buf->size() - 1 ; 
    if (n >= buf[high+1]) then     return high + 1 else skip ; 
    while (low < high) do (     mid := (low + high) / 2 ; 
     if (buf[mid+1] > n) then (     high := mid ) else     if (buf[mid+1] < n) then (     low := mid + 1 ) else (     low := mid + 1 ) ;  ) ; 
    return low 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var buf : Sequence(int) ; buf := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     buf[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    buf := buf->sort() ; 
    var q : int ; q := s.getCurrent()->toInteger() ;
    var ans : String ; ans := StringLib.newString() ;
        var i : int ; i := 0 ; while i < q do ( (     if (i = q - 1) then     ans := ans + StringLib.newString(f(buf, s.getCurrent()->toInteger())) ; else     ans := ans + StringLib.newString(f(buf, s.getCurrent()->toInteger()) + "\n") ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.regex.Pattern ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder builder=new StringBuilder();
    int n=Integer.parseInt(reader.readLine());
    Pattern pattern=Pattern.compile("that|this");
    while(n-->0){
      String result=reader.readLine();
      String a=result ;
      loop : for(int i=1 ;
      i<26 ;
      i=i+2){
        for(int j=0 ; j<26 ; j++){
          a=rep(result,i,j);
          if(pattern.matcher(a).find()){
            builder.append(a).append('\n');
            break loop ;
          }
        }
      }
    }
    System.out.print(builder);
  }
  private static String rep(String a,int i,int j){
    char[] chs=new char[a.length()];
    for(int k=0 ; k<a.length(); k++){
      if('a'<=a.charAt(k)&& a.charAt(k)<='z'){
        int b=a.charAt(k)-97 ;
        chs[k]=(char)((b*i+j)% 26+97);
      }
      else {
        chs[k]=a.charAt(k);
      }
    }
    return String.valueOf(chs);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var builder : String ; builder := StringLib.newString() ;
    var n : int ; n := (reader.readLine())->toInteger() ;
    var pattern : OclRegex ; pattern := OclRegex.compile("that|this") ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var result : String ; result := reader.readLine() ;
     var a : String ; a := result ;
         var i : int ; i := 1 ; while i < 26 do ( (         var j : int ; j := 0 ; while j < 26 do ( (     a := rep(result, i, j) ; 
     if (pattern.matcher(a).nextMatch()) then (     builder := builder + StringLib.newString(a) + StringLib.newString('
') ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 2 ) ; ) ;  ) ;  
    OclFile["System.out"].print(builder) ; 
 );
  static   operation rep( a : String, i : int, j : int) : String
  pre: true
  post: true
  activity: (     var chs : Sequence(String) ; chs := Integer.subrange(1,a->size())->collect(0) ;
         var k : int ; k := 0 ; while k < a->size() do ( (     if ('a' <= a->at(k+1) & a->at(k+1) <= 'z') then (     var b : int ; b := a->at(k+1) - 97 ;
     chs[k+1] := ((b * i + j) mod 26 + 97)->oclAsType(String) ) else (     chs[k+1] := a->at(k+1) ) )  ;     k := k + 1 ) ; 
     return (chs)->sum()  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class AffineCipher {
  String s,c ;
  String alph="abcdefghijklmnopqrstuvwxyz" ;
  int a[]={
    1,3,5,7,9,11,15,17,19,21,23,25 };
    AffineCipher(String s){
      this.s=s ;
      this.c=s ;
    }
    boolean Found(String t){
      if(t.indexOf("that")!=-1 || t.indexOf("this")!=-1)return true ;
      else return false ;
    }
    int Reciprocal(int A){
      for(int i=1 ; i<=25 ; i++){
        if((A*i)% 26==1){
          for(int j=0 ; j<12 ; j++){
            if(a[j]==i)return i ;
          }
        }
      }
      return 0 ;
    }
    String FindString(){
      for(int i=0 ; i<12 ; i++){
        for(int j=0 ; j<=25 ; j++){
          String t="" ;
          for(int k=0 ; k<this.s.length(); k++){
            if(alph.indexOf(this.s.charAt(k))!=-1)t=t+alph.charAt((a[i]*alph.indexOf(this.s.charAt(k))+j)% 26);
            else t=t+this.s.charAt(k);
          }
          this.s=this.c ;
          if(Found(t))return t ;
        }
        this.s=this.c ;
      }
      return "NotFound" ;
    }
  }
  class Main {
    public static void main(String args[]){
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      try {
        int n=Integer.parseInt(br.readLine());
        for(int i=0 ; i<n ; i++){
          AffineCipher ac=new AffineCipher(br.readLine());
          System.out.println(ac.FindString());
        }
      }
      catch(Exception e){
        e.printStackTrace();
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class AffineCipher {
   attribute s : String;
   attribute alph : String := "abcdefghijklmnopqrstuvwxyz";
   attribute a : int := Sequence{1,3,5,7,9,11,15,17,19,21,23,25};
   static operation newAffineCipher( s : String) : AffineCipher
  pre: true
  post: true
  activity:
  ( var self : AffineCipher ;
    self := createAffineCipher();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     self.s := s ; 
     self.c := s );
   operation Found( t : String) : boolean
  pre: true
  post: true
  activity: (     if (t->indexOf("that")-1 /= -1 or t->indexOf("this")-1 /= -1) then     return true else     return false );
   operation Reciprocal( A : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= 25 do ( (     if ((A * i) mod 26 = 1) then (         var j : int ; j := 0 ; while j < 12 do ( (     if (a[j+1] = i) then     return i else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
     return 0 );
   operation FindString() : String
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 12 do ( (         var j : int ; j := 0 ; while j <= 25 do ( (     var t : String ; t := "" ;
         var k : int ; k := 0 ; while k < self.s->size() do ( (     if (alph->indexOf(self.s->at(k+1))-1 /= -1) then     t := t + alph->at((a[i+1] * alph->indexOf(self.s->at(k+1))-1 + j) mod 26+1) ; else     t := t + self.s->at(k+1) ; )  ;     k := k + 1 ) ; 
     self.s := self.c ; 
     if (Found(t)) then     return t else skip )  ;     j := j + 1 ) ; 
     self.s := self.c )  ;     i := i + 1 ) ; 
     return "NotFound" );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var n : int ; n := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var ac : AffineCipher ; ac := AffineCipher.newAffineCipher(br.readLine()) ;
     OclFile["System.out"].println(ac.FindString()) )  ;     i := i + 1 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GfG {
  public static int[] fix(int[] A){
    Set<Integer>s=new HashSet<Integer>();
    for(int i=0 ; i<A.length ; i++){
      s.add(A[i]);
    }
    for(int i=0 ; i<A.length ; i++){
      if(s.contains(i))A[i]=i ;
      else A[i]=-1 ;
    }
    return A ;
  }
  public static void main(String[] args){
    int A[]={
-1,-1,6,1,9,3,2,-1,4,-1 };
      System.out.println(Arrays.toString(fix(A)));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation fix( A : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
         var i : int ; i := 0 ; while i < A->size() do ( (     s := s->including(A[i+1]) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < A->size() do ( (     if (s->includes(i)) then     A[i+1] := i ; else     A[i+1] := -1 ; )  ;     i := i + 1 ) ; 
     return A );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{-1,-1,6,1,9,3,2,-1,4,-1} ;
     OclFile["System.out"].println((fix(A) + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.lang.String ;
import java.lang.StringBuilder ;
import java.lang.System ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int lineNum=sc.nextInt();
    sc.nextLine();
    for(int i=0 ; i<lineNum ; i++){
      String str=sc.nextLine();
      str=findEncodedString(str);
      System.out.println(str);
    }
  }
  public static String findEncodedString(String s){
    for(int a=1 ; a<26 ; a++){
      for(int b=0 ; b<26 ; b++){
        String encStr=encode(s,a,b);
        for(String word : encStr.split(" ")){
          if(word.length()==4){
            if(word.equals("this")|| word.equals("that")){
              return encStr ;
            }
          }
          else {
            continue ;
          }
        }
      }
    }
    return s ;
  }
  public static String encode(String s,int a,int b){
    StringBuilder sb=new StringBuilder();
    for(char ch : s.toCharArray()){
      if('a'<=ch && ch<='z'){
        int x=(a*(ch-'a')+b)% 26 ;
        sb.append((char)('a'+x));
      }
      else {
        sb.append(ch);
      }
    }
    return sb.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var lineNum : int ; lineNum := sc.getCurrent()->toInteger() ;
     skip ; 
         var i : int ; i := 0 ; while i < lineNum do ( (     var str : String ; str := sc.nextLine() ;
     str := findEncodedString(str) ; 
     OclFile["System.out"].println(str) )  ;     i := i + 1 ) );
  static   operation findEncodedString( s : String) : String
  pre: true
  post: true
  activity: (         var a : int ; a := 1 ; while a < 26 do ( (         var b : int ; b := 0 ; while b < 26 do ( (     var encStr : String ; encStr := encode(s, a, b) ;
     for (word : encStr->split(" ")) do ( (     if (word->size() = 4) then (     if (word = "this" or word = "that") then (     return encStr ) else skip ) else (     continue ) )  ) )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
     return s );
  static   operation encode( s : String, a : int, b : int) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     for (ch : s->characters()) do ( (     if ('a' <= ch & ch <= 'z') then (     var x : int ; x := (a * (ch - ('a')->char2byte()) + b) mod 26 ;
     sb := sb + StringLib.newString(('a' + x)->oclAsType(String)) ) else (     sb := sb + StringLib.newString(ch) ) )  ) ; 
     return sb+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class Main {
  static int n ;
  static String line ;
  static Scanner sc=new Scanner(System.in);
  static boolean read(){
    if(! sc.hasNextLine())return false ;
    line=sc.nextLine();
    return true ;
  }
  static String solve(){
    int a=1 ;
    while(true){
      for(int b=0 ; b<=25 ; b++){
        if(a<=26){
          if(gcd(26,a)!=1)break ;
        }
        else {
          if(gcd(a,26)!=1)break ;
        }
        char[] str=line.toCharArray();
        int r,f ;
        for(int i=0 ; i<str.length ; i++){
          if(str[i]==' ')continue ;
          r=str[i]-'a' ;
          f=(a*r+b)% 26 ;
          str[i]=(char)(f+'a');
        }
        String _str=new String(str);
        String[] parsed=_str.split(" ");
        for(int i=0 ; i<parsed.length ; i++){
          if(parsed[i] .equals("that")|| parsed[i] .equals("this")){
            return _str ;
          }
        }
      }
      a++;
    }
  }
  static long gcd(long a,long b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  public static void main(String[] args){
    n=sc.nextInt();
    sc.nextLine();
    while(n-->0 && read()){
      System.out.println(solve());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute line : String;
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     if (not(sc.hasNextLine())) then     return false else skip ; 
     line := sc.nextLine() ; 
     return true );
  static   operation solve() : String
  pre: true
  post: true
  activity: (     var a : int ; a := 1 ;
     while (true) do (         var b : int ; b := 0 ; while b <= 25 do ( (     if (a <= 26) then (     if (gcd(26, a) /= 1) then     break else skip ) else (     if (gcd(a, 26) /= 1) then     break else skip ) ;  
     var str : Sequence(String) ; str := line->characters() ;
    var r : int ;
    var f : int ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str[i+1] = ' ') then     continue else skip ; 
     r := str[i+1] - ('a')->char2byte() ; 
     f := (a * r + b) mod 26 ; 
     str[i+1] := (f + 'a')->oclAsType(String) )  ;     i := i + 1 ) ; 
    var _str : String ; _str := StringLib.newString(str) ;
    var parsed : Sequence(String) ; parsed := _str->split(" ") ;
        var i : int ; i := 0 ; while i < parsed->size() do ( (     if (parsed[i+1] = "that" or parsed[i+1] = "this") then (     return _str ) else skip )  ;     i := i + 1 ) ; 
 )  ;     b := b + 1 ) ; 
     a := a + 1 ) );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
     skip ; 
         while (n > 0 & read()) do (    skip ; (     OclFile["System.out"].println(solve()) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    sc.nextLine();
    while(n!=0){
      char text[]=sc.nextLine().toCharArray();
      int alpha=0 ;
      int beta=0 ;
      for(int a=0 ; a<=100 ; a++){
        for(int b=0 ; b<=100 ; b++){
          Set<Character>set=new HashSet<Character>();
          Map<Character,Character>map=new HashMap<Character,Character>();
          for(int i=0 ; i<26 ; i++){
            set.add((char)('a'+((a*i+b)% 26)));
            map.put((char)('a'+i),(char)('a'+((a*i+b)% 26)));
          }
          if(set.size()==26){
            StringBuilder sb=new StringBuilder();
            for(int j=0 ; j<text.length ; j++){
              if(text[j]!=' ')sb.append(map.get(text[j]));
              else sb.append(' ');
            }
            String str=sb.toString();
            if(str.matches(".*"+"this"+".*")|| str.matches(".*"+"that"+".*")){
              System.out.println(str);
              a=101 ;
              break ;
            }
          }
        }
      }
      n--;
    }
  }
  public static void main(String[] args)throws Exception {
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     skip ; 
     while (n /= 0) do (     var text : Sequence(String) ; text := sc.nextLine()->characters() ;
     var alpha : int ; alpha := 0 ;
    var beta : int ; beta := 0 ;
        var a : int ; a := 0 ; while a <= 100 do ( (         var b : int ; b := 0 ; while b <= 100 do ( (     var set : Set(String) ; set := Set{} ;
     var map : Map(String,String) ; map := Map{} ;
         var i : int ; i := 0 ; while i < 26 do ( (     set := set->including(('a' + ((a * i + b) mod 26))->oclAsType(String)) ; 
     map := map->union(Map{('a' + i)->oclAsType(String) |-> ('a' + ((a * i + b) mod 26))->oclAsType(String)}) )  ;     i := i + 1 ) ; 
     if (set->size() = 26) then (     var sb : String ; sb := StringLib.newString() ;
         var j : int ; j := 0 ; while j < text->size() do ( (     if (text[j+1] /= ' ') then     sb := sb + StringLib.newString(map->at(text[j+1])) ; else     sb := sb + StringLib.newString(' ') ; )  ;     j := j + 1 ) ; 
     var str : String ; str := sb+"" ;
     if (str->isMatch(".*" + "this" + ".*") or str->isMatch(".*" + "that" + ".*")) then (     OclFile["System.out"].println(str) ; 
     a := 101 ; 
     break ) else skip ) else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    n := n - 1 ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
import java.util.Stack ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    String line=null ;
    while((line=reader.readLine())!=null){
      if(line.isEmpty()){
        continue ;
      }
      String[] tokens=line.split(" ");
      Stack<Double>stack=new Stack<Double>();
      for(String token : tokens){
        try {
          double number=Double.parseDouble(token);
          stack.push(number);
          continue ;
        }
        catch(NumberFormatException e){
        }
        double b=stack.pop();
        double a=stack.pop();
        double c=0.0 ;
        if(token.equals("+")){
          c=a+b ;
        }
        else if(token.equals("-")){
          c=a-b ;
        }
        else if(token.equals("*")){
          c=a*b ;
        }
        else if(token.equals("/")){
          c=a/b ;
        }
        stack.push(c);
      }
      double result=stack.pop();
      out.println(String.format("%.6f",result));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     var line : String ; line := null ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->isEmpty()) then (     continue ) else skip ; 
     var tokens : Sequence(String) ; tokens := line->split(" ") ;
    var stack : Sequence(double) ; stack := Sequence{} ;
    for (token : tokens) do ( (     try (     var number : double ; number := (token)->toReal() ;
     stack := stack->append(number) ; 
     continue )   catch (e : IncorrectElementException) do skip
     var b : double ; b := stack->last() ;
    var a : double ; a := stack->last() ;
    var c : double ; c := 0.0 ;
    if (token = "+") then (     c := a + b ) else     if (token = "-") then (     c := a - b ) else     if (token = "*") then (     c := a * b ) else     if (token = "/") then (     c := a / b ) else skip ; ;  ;  ;  
    stack := stack->append(c) ; 
 )  ) ; 
    var result : double ; result := stack->last() ;
    out.println(StringLib.format("%.6f",Sequence{result})) ; 
 ) ;     line := reader.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean findNature(int a,int b,int n){
    if(n==0)return(a & 1)==1 ? true : false ;
    if(n==1)return(b & 1)==1 ? true : false ;
    if((a & 1)==0){
      if((b & 1)==0)return false ;
      else return(n % 3!=0);
    }
    else {
      if((b & 1)==0)return((n-1)% 3!=0);
      else return((n+1)% 3!=0);
    }
  }
  public static void main(String[] args){
    int a=2,b=4 ;
    int n=3 ;
    if(findNature(a,b,n))System.out.println("Odd");
    else System.out.println("Even");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNature( a : int, b : int, n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 0) then     return if (a & 1) = 1 then true else false endif else skip ; 
     if (n = 1) then     return if (b & 1) = 1 then true else false endif else skip ; 
     if ((a & 1) = 0) then (     if ((b & 1) = 0) then     return false else     return (n mod 3 /= 0) ) else (     if ((b & 1) = 0) then     return ((n - 1) mod 3 /= 0) else     return ((n + 1) mod 3 /= 0) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2 ;
    var b : int ; b := 4 ;
     var n : int ; n := 3 ;
     if (findNature(a, b, n)) then     OclFile["System.out"].println("Odd") ; else     OclFile["System.out"].println("Even") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.*;
class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    for(; ; ){
      final int a=cin.nextInt();
      final int b=cin.nextInt();
      if(a==0)break ;
      System.out.println(IntStream.range(0,a/2+1).asDoubleStream().map(i->Math.abs(b-Math.hypot(i,a-i))).min().getAsDouble());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var a : int ; a := cin.getCurrent()->toInteger() ;
     var b : int ; b := cin.getCurrent()->toInteger() ;
     if (a = 0) then     break else skip ; 
     OclFile["System.out"].println(Integer.subrange(0, a / 2 + 1-1)->collect( _x1 | (lambda i : OclAny in if b - hypot(i, a - i) < 0 then -(b - hypot(i, a - i)) else b - hypot(i, a - i) endif)->apply(_x1) ).min().getAsDouble()) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String[] tmpArray=br.readLine().split(" ");
      int dist=Integer.parseInt(tmpArray[0]);
      int est=Integer.parseInt(tmpArray[1]);
      if(dist==0 && est==0){
        break ;
      }
      double diff=Integer.MAX_VALUE ;
      for(int x=0 ; x<=dist ; x++){
        double cost=Math.sqrt(x*x+(dist-x)*(dist-x));
        if(diff>Math.abs(est-cost)){
          diff=Math.abs(est-cost);
        }
      }
      System.out.println(diff);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
     var dist : int ; dist := (tmpArray[0+1])->toInteger() ;
    var est : int ; est := (tmpArray[1+1])->toInteger() ;
    if (dist = 0 & est = 0) then (     break ) else skip ; 
    var diff : double ; diff := 2147483647 ;
        var x : int ; x := 0 ; while x <= dist do ( (     var cost : double ; cost := (x * x + (dist - x) * (dist - x))->sqrt() ;
     if (diff > if est - cost < 0 then -(est - cost) else est - cost endif) then (     diff := if est - cost < 0 then -(est - cost) else est - cost endif ) else skip )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println(diff) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Spliterator ;
import java.util.Spliterators ;
import java.util.concurrent.ThreadLocalRandom ;
import java.util.concurrent.atomic.AtomicInteger ;
import java.util.stream.IntStream ;
import java.util.stream.Stream ;
import java.util.stream.StreamSupport ;
public class Main {
  static final Scanner s=new Scanner(System.in);
  static final long[] fal_rnd(int size){
    AtomicInteger l=new AtomicInteger(-1),r=new AtomicInteger(size);
    long[] res=new long[size];
    INS(size).unordered().parallel().mapToLong(Long :: parseLong).forEach(v->res[ThreadLocalRandom.current().nextBoolean()? l.incrementAndGet(): r.decrementAndGet()]=v);
    return res ;
  }
  static final IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static final Stream<String>INS(long size){
    return StreamSupport.stream(Spliterators.spliterator(s,size,Spliterator.NONNULL & Spliterator.IMMUTABLE),false).limit(size);
  }
  public static void main(String __[]){
    int d,e ;
    while(true){
      d=s.nextInt();
      e=s.nextInt();
      if(d+e==0)return ;
      double r=Math.abs(d-e);
      for(int i=1 ; i<d ; i++){
        r=Math.min(r,Math.abs(e-Math.sqrt(i*i+(d-i)*(d-i))));
      }
      System.out.println(r);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    operation fal_rnd( size : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var l : int ; l := (-1) ;
    var r : int ; r := (size) ;
     var res : Sequence(long) ; res := Integer.subrange(1,size)->collect(0) ;
     for v : INS(size)->collect( _x1 | (lambda _s : String in _s->toLong())->apply(_x1) ) do
    (    res[if MathLib.nextBoolean() then l+1 else r-1 endif+1] := v) ; 
     return res );
  static    operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static    operation INS( size : long) : Stream<String>
  pre: true
  post: true
  activity: (     return (OclIterator.newOclIterator_Sequence(s)).elements.subrange(1,size) );
  static   operation main( __ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : int ;
    var e : int ;
     while (true) do (     d := s.getCurrent()->toInteger() ; 
     e := s.getCurrent()->toInteger() ; 
    if (d + e = 0) then     return else skip ; 
    var r : double ; r := if d - e < 0 then -(d - e) else d - e endif ;
        var i : int ; i := 1 ; while i < d do ( (     r := Set{r, if e - (i * i + (d - i) * (d - i))->sqrt() < 0 then -(e - (i * i + (d - i) * (d - i))->sqrt()) else e - (i * i + (d - i) * (d - i))->sqrt() endif}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(r) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static double distance(double d,double plan){
    double y,min=101.0,tmp=0.0 ;
    int i ;
    for(i=0 ; i<(int)d ; i++){
      y=d-i ;
      tmp=Math.sqrt(Math.pow(y,2.0)+Math.pow(i,2.0));
      tmp-=plan ;
      tmp=Math.abs(tmp);
      if(tmp<min){
        min=tmp ;
      }
    }
    return min ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int i ;
    double d,p ;
    while(true){
      d=sc.nextDouble();
      p=sc.nextDouble();
      if(p==0.0 && d==0.0)break ;
      System.out.printf("%.3f\n",distance(d,p));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation distance( d : double, plan : double) : double
  pre: true
  post: true
  activity: (     var y : double ;
    var min : double ; min := 101.0 ;
    var tmp : double ; tmp := 0.0 ;
     var i : int ;
         i := 0 ; while i < d->oclAsType(int) do ( (     y := d - i ; 
     tmp := (y->pow(2.0) + i->pow(2.0))->sqrt() ; 
    tmp := tmp-(plan) ; 
    tmp := if tmp < 0 then -(tmp) else tmp endif ; 
    if (tmp < min) then (     min := tmp ) else skip ; 
 )  ;     i := i + 1 ) ; 
     return min );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ;
     var d : double ;
    var p : double ;
     while (true) do (     d := sc.getCurrent()->toReal() ; 
     p := sc.getCurrent()->toReal() ; 
     if (p = 0.0 & d = 0.0) then     break else skip ; 
     OclFile["System.out"].printf("%.3f\n", distance(d, p)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    try(final java.util.Scanner sc=new java.util.Scanner(in)){
      for(; ; ){
        final int D=sc.nextInt();
        final int E=sc.nextInt();
        if(D==0 && E==0)break ;
        double rval=Double.MAX_VALUE ;
        for(int u=0 ; u<=D ; ++u){
          final int v=D-u ;
          rval=Math.min(rval,Math.abs(Math.sqrt(u*u+v*v)-E));
        }
        System.out.println(rval);
      }
    }
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     try (    var sc : Scanner = Scanner.newScanner(in) ;
 (       while true do ( (     var D : int ; D := sc.nextInt() ;
     var E : int ; E := sc.nextInt() ;
    if (D = 0 & E = 0) then     break else skip ; 
    var rval : double ; rval := (2 - 2->pow(-52))*(2->pow(1023)) ;
        var u : int ; u := 0 ; while u <= D do ( (     var v : int ; v := D - u ;
     rval := Set{rval, if (u * u + v * v)->sqrt() - E < 0 then -((u * u + v * v)->sqrt() - E) else (u * u + v * v)->sqrt() - E endif}->min() )  ;     u := u + 1 ) ; 
    OclFile["System.out"].println(rval) ; 
 )  ) ))  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    Scanner sc=new Scanner(systemin);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    int sum=a+b+c+d ;
    int s1=Math.abs(sum-(a+b)*2);
    int s2=Math.abs(sum-(a+c)*2);
    int s3=Math.abs(sum-(a+d)*2);
    int min=Math.min(s1,Math.min(s2,s3));
    System.out.printf("%d\n",min);
    sc.close();
    return false ;
  }
  PrintStream log ;
  PrintStream result=System.out ;
  BufferedReader systemin ;
  static Main instance=new Main();
  Main(){
    systemin=new BufferedReader(new InputStreamReader(System.in));
    log=new PrintStream(new OutputStream(){
      public void write(int b){
      }
    }
);
  }
  public static void main(String[] args)throws IOException {
    instance.main();
    instance.systemin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(systemin) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := a + b + c + d ;
    var s1 : int ; s1 := if sum - (a + b) * 2 < 0 then -(sum - (a + b) * 2) else sum - (a + b) * 2 endif ;
    var s2 : int ; s2 := if sum - (a + c) * 2 < 0 then -(sum - (a + c) * 2) else sum - (a + c) * 2 endif ;
    var s3 : int ; s3 := if sum - (a + d) * 2 < 0 then -(sum - (a + d) * 2) else sum - (a + d) * 2 endif ;
    var min : int ; min := Set{s1, Set{s2, s3}->min()}->min() ;
    OclFile["System.out"].printf("%d\n", min) ; 
    skip ; 
    return false 
 );
   attribute log : OclFile;
   attribute result : OclFile := OclFile["System.out"];
   attribute systemin : OclFile;
  static   attribute instance : Main := Main.newMain();
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     systemin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     log := OclFile.newOclFile_Write(OclFile()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     instance.main() ; 
     instance.systemin.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int max_sum(int a[],int n){
    int[] dp=new int[n];
    if(n==1){
      dp[0]=Math.max(0,a[0]);
    }
    else if(n==2){
      dp[0]=Math.max(0,a[0]);
      dp[1]=Math.max(a[1],dp[0]);
    }
    else if(n>=3){
      dp[0]=Math.max(0,a[0]);
      dp[1]=Math.max(a[1],Math.max(0,a[0]));
      dp[2]=Math.max(a[2],Math.max(a[1],Math.max(0,a[0])));
      int i=3 ;
      while(i<n){
        dp[i]=Math.max(dp[i-1],a[i]+dp[i-3]);
        i++;
      }
    }
    return dp[n-1];
  }
  public static void main(String[] args){
    int arr[]={
      1,2,-2,4,3 };
      int n=arr.length ;
      System.out.println(max_sum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation max_sum( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
     if (n = 1) then (     dp[0+1] := Set{0, a[0+1]}->max() ) else     if (n = 2) then (     dp[0+1] := Set{0, a[0+1]}->max() ; 
     dp[1+1] := Set{a[1+1], dp[0+1]}->max() ) else     if (n >= 3) then (     dp[0+1] := Set{0, a[0+1]}->max() ; 
     dp[1+1] := Set{a[1+1], Set{0, a[0+1]}->max()}->max() ; 
    dp[2+1] := Set{a[2+1], Set{a[1+1], Set{0, a[0+1]}->max()}->max()}->max() ; 
    var i : int ; i := 3 ;
    while (i < n) do (     dp[i+1] := Set{dp[i - 1+1], a[i+1] + dp[i - 3+1]}->max() ; 
     i := i + 1 ) ; 
 ) else skip ; ;  ;  
     return dp[n - 1+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,-2,4,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(max_sum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Locale ;
import java.util.Scanner ;
public class Sleuth {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String question=scanner.nextLine().trim();
    String originalQ=question.substring(0,question.length()-1).trim();
    String ch=originalQ.substring(originalQ.length()-1);
    String[] vowels=new String[] {
      "A","E","I","O","U","Y" };
      boolean b=Arrays.stream(vowels).anyMatch(e->e.equalsIgnoreCase(ch)|| e.toLowerCase(Locale.US).equalsIgnoreCase(ch));
      System.out.println(b ? "YES" : "NO");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Sleuth {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var question : String ; question := scanner.nextLine()->trim() ;
    var originalQ : String ; originalQ := question.subrange(0+1,question->size() - 1)->trim() ;
    var ch : String ; ch := originalQ.subrange(originalQ->size() - 1+1,originalQ->size() - 1) ;
    var vowels : Sequence(String) ; vowels := Sequence{"A","E","I","O","U","Y"} ;
    var b : boolean ; b := stream(vowels)->exists( _x2 | (lambda e : OclAny in e->equalsIgnoreCase(ch) or e.toLowerCase(Locale.US)->equalsIgnoreCase(ch))->apply(_x2) ) ;
    OclFile["System.out"].println(if b then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Sleuth {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    int length=s.length();
    char ch=0 ;
    for(int i=length-1 ; i>=0 ; i--){
      if(s.charAt(i)!=' ' && s.charAt(i)!='?'){
        ch=s.charAt(i);
        break ;
      }
    }
    ch=Character.toLowerCase(ch);
    if(ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u' || ch=='y'){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sleuth {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var length : int ; length := s->size() ;
    var ch : String ; ch := 0 ;
        var i : int ; i := (length)->char2byte() - 1 ; while i >= 0 do ( (     if (s->at(i+1) /= ' ' & s->at(i+1) /= '?') then (     ch := s->at(i+1) ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    ch := (ch + "")->toLowerCase() ; 
    if (ch = 'a' or ch = 'e' or ch = 'i' or ch = 'o' or ch = 'u' or ch = 'y') then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class P3 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String f=sc.nextLine();
    f=f.replaceAll("\\s","");
    String s=f.toLowerCase();
    if(s.charAt(s.length()-2)=='a' || s.charAt(s.length()-2)=='e' || s.charAt(s.length()-2)=='i' || s.charAt(s.length()-2)=='o' || s.charAt(s.length()-2)=='u' || s.charAt(s.length()-2)=='y'){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var f : String ; f := sc.nextLine() ;
    f := f.replaceAllMatches("\\s", "" ) ; 
    var s : String ; s := f->toLowerCase() ;
    if (s->at(s->size() - 2+1) = 'a' or s->at(s->size() - 2+1) = 'e' or s->at(s->size() - 2+1) = 'i' or s->at(s->size() - 2+1) = 'o' or s->at(s->size() - 2+1) = 'u' or s->at(s->size() - 2+1) = 'y') then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  void run(){
    for(; sc.hasNext(); ){
      Scanner c=new Scanner(sc.nextLine());
      LinkedList<Double>stack=new LinkedList<Double>();
      for(; c.hasNext(); ){
        String s=c.next();
        if(Character.isDigit(s.charAt(0))|| s.length()>1){
          stack.addFirst(Double.parseDouble(s));
        }
        else {
          double d2=stack.removeFirst();
          double d1=stack.removeFirst();
          double d=0 ;
          switch(s.charAt(0)){
            case '+' : d=d1+d2 ;
            break ;
            case '-' : d=d1-d2 ;
            break ;
            case '*' : d=d1*d2 ;
            break ;
            case '/' : d=d1/d2 ;
            break ;
          }
          stack.addFirst(d);
        }
      }
      println(stack.removeFirst()+"");
    }
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var c : OclFile ; c := OclFile.newOclFile_Read(sc.nextLine()) ;
     var stack : Sequence(double) ; stack := Sequence{} ;
       while c.hasNext() do ( (     var s : String ; s := c.getCurrent() ;
     if ((s->at(0+1) + "")->isMatch("[0-9]") or s->size() > 1) then (     stack := stack->prepend((s)->toReal()) ) else (     var d2 : double ; d2 := stack->first() ;
     var d1 : double ; d1 := stack->first() ;
    var d : double ; d := 0 ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (s->at(0+1)) ; 
       if _switchval = '+' then
     d := d1 + d2 ; 
    break 
   else skip ;
       if _switchval = '-' then
     d := d1 - (d2)->char2byte() ; 
    break 
   else skip ;
       if _switchval = '*' then
     d := d1 * d2 ; 
    break 
   else skip ;
       if _switchval = '/' then
     d := d1 / d2 ; 
    break 
   else skip ;
 )
    stack := stack->prepend(d) ; 
 ) )  ) ; 
     execute println(stack->first() + "") )  ) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int minimumX(int n,int k){
    int mini=Integer.MAX_VALUE ;
    for(int i=1 ; i*i<=n ; i++){
      if(n % i==0){
        int fir=i ;
        int sec=n/i ;
        int num1=fir*k+sec ;
        int res=(num1/k)*(num1 % k);
        if(res==n)mini=Math.min(num1,mini);
        int num2=sec*k+fir ;
        res=(num2/k)*(num2 % k);
        if(res==n)mini=Math.min(num2,mini);
      }
    }
    return mini ;
  }
  public static void main(String args[]){
    int n=4,k=6 ;
    System.out.println(minimumX(n,k));
    n=5 ;
    k=5 ;
    System.out.println(minimumX(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation minimumX( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var mini : int ; mini := 2147483647 ;
         var i : int ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     var fir : int ; fir := i ;
     var sec : int ; sec := n / i ;
    var num1 : int ; num1 := fir * k + sec ;
    var res : int ; res := (num1 / k) * (num1 mod k) ;
    if (res = n) then     mini := Set{num1, mini}->min() ; else skip ; 
    var num2 : int ; num2 := sec * k + fir ;
    res := (num2 / k) * (num2 mod k) ; 
    if (res = n) then     mini := Set{num2, mini}->min() ; else skip ; 
 ) else skip )  ;     i := i + 1 ) ; 
     return mini );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
    var k : int ; k := 6 ;
     OclFile["System.out"].println(minimumX(n, k)) ; 
    n := 5 ; 
    k := 5 ; 
    OclFile["System.out"].println(minimumX(n, k)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class C {
  private static Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    int C=in.nextInt();
    for(int thisCase=1 ; thisCase<=C ; thisCase++){
      System.out.printf("Case #%d: %d%n",thisCase,largestCircle());
    }
  }
  private static int largestCircle(){
    int N=in.nextInt();
    int bff[]=new int[N];
    for(int i=0 ; i<N ; i++){
      bff[i]=in.nextInt()-1 ;
    }
    int status[]=new int[N];
    int chainLength[]=new int[N];
    for(int i=0 ; i<N ; i++){
      status[i]=-2 ;
      chainLength[i]=0 ;
    }
    for(int i=0 ; i<N ; i++){
      if(bff[bff[i] ]==i){
        status[i]=-1 ;
      }
    }
    int maxLoopSize=0 ;
    for(int i=0 ; i<N ; i++){
      if(status[i]!=-1){
        int current=bff[i];
        status[i]=i ;
        int steps=1 ;
        boolean done=false ;
        while(! done){
          if(current==i){
            if(steps>maxLoopSize){
              maxLoopSize=steps ;
            }
            done=true ;
          }
          else if(status[current]==i){
            done=true ;
          }
          else if(status[current]==-1){
            if(steps>chainLength[current]){
              chainLength[current]=steps ;
            }
            done=true ;
          }
          else {
            steps++;
            status[current]=i ;
            current=bff[current];
          }
        }
      }
    }
    int frankenCircle=0 ;
    for(int i=0 ; i<N ; i++){
      if(status[i]==-1){
        frankenCircle+=(chainLength[i]+1);
      }
    }
    return Math.max(frankenCircle,maxLoopSize);
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var C : int ; C := in.getCurrent()->toInteger() ;
         var thisCase : int ; thisCase := 1 ; while thisCase <= C do ( (     OclFile["System.out"].printf("Case #%d: %d%n", thisCase, largestCircle()) )  ;     thisCase := thisCase + 1 ) );
  static   operation largestCircle() : int
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
     var bff : Sequence(int) ; bff := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     bff[i+1] := in.getCurrent()->toInteger() - 1 )  ;     i := i + 1 ) ; 
    var status : Sequence(int) ; status := Integer.subrange(1,N)->collect(0) ;
    var chainLength : Sequence(int) ; chainLength := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     status[i+1] := -2 ; 
     chainLength[i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (bff[bff[i+1]+1] = i) then (     status[i+1] := -1 ) else skip )  ;     i := i + 1 ) ; 
    var maxLoopSize : int ; maxLoopSize := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (status[i+1] /= -1) then (     var current : int ; current := bff[i+1] ;
     status[i+1] := i ; 
    var steps : int ; steps := 1 ;
    var done : boolean ; done := false ;
    while (not(done)) do (     if (current = i) then (     if (steps > maxLoopSize) then (     maxLoopSize := steps ) else skip ; 
     done := true ) else     if (status[current+1] = i) then (     done := true ) else     if (status[current+1] = -1) then (     if (steps > chainLength[current+1]) then (     chainLength[current+1] := steps ) else skip ; 
     done := true ) else (     steps := steps + 1 ; 
     status[current+1] := i ; 
     current := bff[current+1] ) ;  ;  ) ; 
 ) else skip )  ;     i := i + 1 ) ; 
    var frankenCircle : int ; frankenCircle := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (status[i+1] = -1) then (     frankenCircle := frankenCircle+((chainLength[i+1] + 1)) ) else skip )  ;     i := i + 1 ) ; 
    return Set{frankenCircle, maxLoopSize}->max() 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class C {
  int solveOne(Scanner in){
    int n=in.nextInt();
    int f[]=new int[1+n];
    for(int i=1 ; i<=n ; i++){
      f[i]=in.nextInt();
    }
    boolean inPair[]=new boolean[1+n];
    for(int i=1 ; i<=n ; i++){
      if(f[f[i] ]==i){
        inPair[i]=true ;
      }
    }
    int chainLen[]=new int[1+n];
    boolean used[]=new boolean[1+n];
    int maxCircleLen=0 ;
    for(int first=1 ; first<=n ; first++){
      if(inPair[first]){
        continue ;
      }
      Arrays.fill(used,false);
      used[first]=true ;
      int cur=first ;
      int len=1 ;
      while(true){
        int next=f[cur];
        if(inPair[next]){
          chainLen[next]=Math.max(chainLen[next],len);
          break ;
        }
        if(next==first){
          maxCircleLen=Math.max(maxCircleLen,len);
          break ;
        }
        if(used[next]){
          break ;
        }
        used[next]=true ;
        len++;
        cur=next ;
      }
    }
    int joinLen=0 ;
    for(int i=1 ; i<=n ; i++){
      if(inPair[i]){
        joinLen+=1+chainLen[i];
      }
    }
    return Math.max(maxCircleLen,joinLen);
  }
  void solve(Scanner in,PrintWriter out){
    int nTests=in.nextInt();
    for(int iTest=1 ; iTest<=nTests ; iTest++){
      out.printf("Case #%d: %d%n",iTest,solveOne(in));
    }
  }
  void run(){
    try(Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
){
      solve(in,out);
    }
  }
  public static void main(String args[]){
    new C().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
   operation solveOne( in : OclFile) : int
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var f : Sequence(int) ; f := Integer.subrange(1,1 + n)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     f[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    var inPair : Sequence(boolean) ; inPair := Integer.subrange(1,1 + n)->collect(false) ;
        var i : int ; i := 1 ; while i <= n do ( (     if (f[f[i+1]+1] = i) then (     inPair[i+1] := true ) else skip )  ;     i := i + 1 ) ; 
    var chainLen : Sequence(int) ; chainLen := Integer.subrange(1,1 + n)->collect(0) ;
    var used : Sequence(boolean) ; used := Integer.subrange(1,1 + n)->collect(false) ;
    var maxCircleLen : int ; maxCircleLen := 0 ;
        var first : int ; first := 1 ; while first <= n do ( (     if (inPair[first+1]) then (     continue ) else skip ; 
     used := used->collect(false) ; 
    used[first+1] := true ; 
    var cur : int ; cur := first ;
    var len : int ; len := 1 ;
    while (true) do (     var next : int ; next := f[cur+1] ;
     if (inPair[next+1]) then (     chainLen[next+1] := Set{chainLen[next+1], len}->max() ; 
     break ) else skip ; 
    if (next = first) then (     maxCircleLen := Set{maxCircleLen, len}->max() ; 
     break ) else skip ; 
    if (used[next+1]) then (     break ) else skip ; 
    used[next+1] := true ; 
    len := len + 1 ; 
    cur := next ; 
 ) ; 
 )  ;     first := first + 1 ) ; 
    var joinLen : int ; joinLen := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (inPair[i+1]) then (     joinLen := joinLen+(1 + chainLen[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    return Set{maxCircleLen, joinLen}->max() 
 );
   operation solve( in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var nTests : int ; nTests := in.nextInt() ;
         var iTest : int ; iTest := 1 ; while iTest <= nTests do ( (     out.printf("Case #%d: %d%n", iTest, solveOne(in)) )  ;     iTest := iTest + 1 ) );
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]) ;
 (     execute solve(in, out) ))  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     C.newC().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package lab6zp ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Lab6ZP {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=Integer.parseInt(in.next());
    for(int i=0 ; i<n ; i++){
      boolean is=false ;
      int m=Integer.parseInt(in.next());
      int[] k=new int[m];
      int[] h=new int[m];
      int min=-1 ;
      for(int j=0 ; j<m ; j++){
        h[j]=0 ;
        k[j]=Integer.parseInt(in.next())-1 ;
      }
      System.out.print("Case #"+(i+1)+": ");
      int fullcounter=0 ;
      ArrayList<Integer>q=new ArrayList<>();
      for(int j=0 ; j<m ; j++){
        int p=j ;
        for(int z=0 ; z<m+2 ; z++){
          if(k[k[p] ]==p){
            if(z>h[p] || ! q.contains(p)){
              fullcounter-=h[p];
              fullcounter+=z ;
              if(! q.contains(p)){
                q.add(p);
                fullcounter++;
              }
              h[p]=z ;
            }
            if(min<fullcounter){
              min=fullcounter ;
            }
            z=m+1 ;
            continue ;
          }
          p=k[p];
          if(z>0 && p==k[j]){
            if(min<z){
              min=z ;
            }
            z=m+1 ;
          }
        }
      }
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Lab6ZP {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (in.getCurrent())->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var is : boolean ; is := false ;
     var m : int ; m := (in.getCurrent())->toInteger() ;
    var k : Sequence(int) ; k := Integer.subrange(1,m)->collect(0) ;
    var h : Sequence(int) ; h := Integer.subrange(1,m)->collect(0) ;
    var min : int ; min := -1 ;
        var j : int ; j := 0 ; while j < m do ( (     h[j+1] := 0 ; 
     k[j+1] := (in.getCurrent())->toInteger() - 1 )  ;     j := j + 1 ) ; 
    OclFile["System.out"].print("Case #" + (i + 1) + ": ") ; 
    var fullcounter : int ; fullcounter := 0 ;
    var q : Sequence(int) ; q := Sequence{} ;
        var j : int ; j := 0 ; while j < m do ( (     var p : int ; p := j ;
         var z : int ; z := 0 ; while z < m + 2 do ( (     if (k[k[p+1]+1] = p) then (     if (z > h[p+1] or not(q->includes(p))) then (     fullcounter := fullcounter-(h[p+1]) ; 
     fullcounter := fullcounter+(z) ; 
     if (not(q->includes(p))) then (     q := q->including(p) ; 
     fullcounter := fullcounter + 1 ) else skip ; 
     h[p+1] := z ) else skip ; 
     if (min < fullcounter) then (     min := fullcounter ) else skip ; 
     z := m + 1 ; 
     continue ) else skip ; 
     p := k[p+1] ; 
     if (z > 0 & p = k[j+1]) then (     if (min < z) then (     min := z ) else skip ; 
     z := m + 1 ) else skip )  ;     z := z + 1 ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package Round1A2016 ;
import java.lang.reflect.Array ;
import java.util.Arrays ;
import java.util.Scanner ;
public class C {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    for(int testCase=1 ; testCase<=T ; ++testCase){
      final int n=sc.nextInt();
      int[] bff=new int[n];
      boolean[] hasIncoming=new boolean[n];
      for(int i=0 ; i<n ; ++i){
        bff[i]=sc.nextInt()-1 ;
        hasIncoming[bff[i] ]=true ;
      }
      int[] loop=new int[n];
      int maxPeriod=0 ;
      for(int i=0 ; i<n ; ++i){
        boolean[] visited=new boolean[n];
        int cur=0 ;
        int[] index=new int[n];
        int j=i ;
        while(! visited[j]){
          visited[j]=true ;
          index[j]=cur++;
          j=bff[j];
        }
        final int period=cur-index[j];
        for(int k=0 ; k<period ; ++k){
          loop[j]=period ;
          j=bff[j];
        }
        maxPeriod=Math.max(maxPeriod,period);
      }
      int[] maxChain=new int[n];
      for(int i=0 ; i<n ; ++i){
        if(hasIncoming[i])continue ;
        int j=i ;
        int chain=0 ;
        while(loop[j]==0){
++chain ;
          j=bff[j];
        }
        maxChain[j]=Math.max(maxChain[j],chain);
      }
      int sum=0 ;
      for(int i=0 ; i<n ; ++i){
        if(loop[i]==2){
          sum+=1+maxChain[i];
        }
      }
      System.out.printf("Case #%d: %d\n",testCase,Math.max(sum,maxPeriod));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var testCase : int ; testCase := 1 ; while testCase <= T do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var bff : Sequence(int) ; bff := Integer.subrange(1,n)->collect(0) ;
    var hasIncoming : Sequence(boolean) ; hasIncoming := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     bff[i+1] := sc.getCurrent()->toInteger() - 1 ; 
     hasIncoming[bff[i+1]+1] := true )  ;     i := i + 1 ) ; 
    var loop : Sequence(int) ; loop := Integer.subrange(1,n)->collect(0) ;
    var maxPeriod : int ; maxPeriod := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var visited : Sequence(boolean) ; visited := Integer.subrange(1,n)->collect(false) ;
     var cur : int ; cur := 0 ;
    var index : Sequence(int) ; index := Integer.subrange(1,n)->collect(0) ;
    var j : int ; j := i ;
    while (not(visited[j+1])) do (     visited[j+1] := true ; 
      index[j+1] := cur  ; cur := cur + 1 ; 
     j := bff[j+1] ) ; 
    var period : int ; period := cur - index[j+1] ;
        var k : int ; k := 0 ; while k < period do ( (     loop[j+1] := period ; 
     j := bff[j+1] )  ;     k := k + 1 ) ; 
    maxPeriod := Set{maxPeriod, period}->max() ; 
 )  ;     i := i + 1 ) ; 
    var maxChain : Sequence(int) ; maxChain := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     if (hasIncoming[i+1]) then     continue else skip ; 
     var j : int ; j := i ;
    var chain : int ; chain := 0 ;
    while (loop[j+1] = 0) do (     chain := chain + 1 ; 
     j := bff[j+1] ) ; 
    maxChain[j+1] := Set{maxChain[j+1], chain}->max() ; 
 )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (loop[i+1] = 2) then (     sum := sum+(1 + maxChain[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("Case #%d: %d\n", testCase, Set{sum, maxPeriod}->max()) ; 
 )  ;     testCase := testCase + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] arr=new int[4];
    int total=0 ;
    for(int i=0 ; i<4 ; i++){
      arr[i]=sc.nextInt();
      total+=arr[i];
    }
    int min=Integer.MAX_VALUE ;
    for(int i=1 ; i<4 ; i++){
      min=Math.min(min,Math.abs(total-(arr[0]+arr[i])*2));
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,4)->collect(0) ;
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     total := total+(arr[i+1]) )  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
        var i : int ; i := 1 ; while i < 4 do ( (     min := Set{min, if total - (arr[0+1] + arr[i+1]) * 2 < 0 then -(total - (arr[0+1] + arr[i+1]) * 2) else total - (arr[0+1] + arr[i+1]) * 2 endif}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class C {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int tcc=sc.nextInt();
    for(int tc=1 ; tc<=tcc ; ++tc){
      int n=sc.nextInt();
      Kid[] kids=new Kid[n];
      for(int i=0 ; i<n ; ++i)kids[i]=new Kid(i+1);
      for(int i=0 ; i<n ; ++i)kids[i] .bff=kids[sc.nextInt()-1];
      int maxCycle=0 ;
      for(Kid first : kids){
        Set<Kid>set=new HashSet<Kid>();
        Kid k=first ;
        for(; ; ){
          if(set.contains(k)){
            if(k==first){
              first.cycle=set.size();
              maxCycle=Math.max(maxCycle,first.cycle);
            }
            break ;
          }
          set.add(k);
          k=k.bff ;
        }
      }
      for(Kid first : kids){
        Set<Kid>set=new HashSet<Kid>();
        Kid k=first ;
        for(; ; ){
          if(set.contains(k)){
            if(k.cycle==2){
              k.brings=Math.max(k.brings,set.size()-1);
            }
            break ;
          }
          set.add(k);
          k=k.bff ;
        }
      }
      int brings=0 ;
      for(Kid k : kids)if(k.cycle==2)brings+=k.brings ;
      System.out.printf("Case #%d: %d%n",tc,Math.max(maxCycle,brings));
    }
  }
}
class Kid {
  public Kid bff ;
  public int index ;
  public int cycle=0 ;
  public int brings=0 ;
  public Kid(int index){
    this.index=index ;
  }
  public String toString(){
    return this.index+"("+this.cycle+","+this.brings+")" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tcc : int ; tcc := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 1 ; while tc <= tcc do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var kids : Sequence(Kid) ; kids := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     kids[i+1] := Kid.newKid(i + 1) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     kids[i+1].bff := kids[sc.getCurrent()->toInteger() - 1+1] ;  ;     i := i + 1 ) ; 
    var maxCycle : int ; maxCycle := 0 ;
    for (first : kids) do ( (     var set : Set(Kid) ; set := Set{} ;
     var k : Kid ; k := first ;
       while true do ( (     if (set->includes(k)) then (     if (k = first) then (     first.cycle := set->size() ; 
     maxCycle := Set{maxCycle, first.cycle}->max() ) else skip ; 
     break ) else skip ; 
     set := set->including(k) ; 
     k := k.bff )  ) )  ) ; 
    for (first : kids) do ( (     var set : Set(Kid) ; set := Set{} ;
     var k : Kid ; k := first ;
       while true do ( (     if (set->includes(k)) then (     if (k.cycle = 2) then (     k.brings := Set{k.brings, set->size() - 1}->max() ) else skip ; 
     break ) else skip ; 
     set := set->including(k) ; 
     k := k.bff )  ) )  ) ; 
    var brings : int ; brings := 0 ;
    for (k : kids) do (     if (k.cycle = 2) then     brings := brings+(k.brings) ; else skip ;  ) ; 
    OclFile["System.out"].printf("Case #%d: %d%n", tc, Set{maxCycle, brings}->max()) ; 
 )  ;     tc := tc + 1 ) );
}
class Kid {
   attribute bff : Kid;
   attribute index : int;
   attribute cycle : int := 0;
   attribute brings : int := 0;
   static operation newKid( index : int) : Kid
  pre: true
  post: true
  activity:
  ( var self : Kid ;
    self := createKid();
    self.initialise(index);
    return self );
  operation initialise( index : int) : void
  pre: true  post: true
  activity: (     self.index := index );
   operation toString() : String
  pre: true
  post: true
  activity: (     return self.index + "(" + self.cycle + "," + self.brings + ")" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static float SellingPrice(float CP,float PP){
    float P_decimal=1+(PP/100);
    float res=P_decimal*CP ;
    return res ;
  }
  public static void main(String args[]){
    float C=720,P=13 ;
    System.out.println(SellingPrice(C,P));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation SellingPrice( CP : double, PP : double) : double
  pre: true
  post: true
  activity: (     var P_decimal : double ; P_decimal := 1 + (PP / 100) ;
     var res : double ; res := P_decimal * CP ;
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var C : double ; C := 720 ;
    var P : double ; P := 13 ;
     OclFile["System.out"].println(SellingPrice(C, P)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B_Beautiful_Numbers {
  static Scanner in=new Scanner(System.in);
  static int testCases,n ;
  static int a[];
  static void solve(){
    int position[]=new int[n+1];
    for(int i=0 ; i<n ; ++i){
      position[a[i]-1]=i ;
    }
    int l=n,r=0 ;
    StringBuilder ans=new StringBuilder();
    for(int i=0 ; i<n ; ++i){
      l=Math.min(l,position[i]);
      r=Math.max(r,position[i]);
      if(r-l==i){
        ans.append(1);
      }
      else {
        ans.append(0);
      }
    }
    System.out.println(ans.toString());
  }
  public static void main(String[] amit){
    testCases=in.nextInt();
    for(int t=0 ; t<testCases ; ++t){
      n=in.nextInt();
      a=new int[n];
      for(int i=0 ; i<n ; ++i){
        a[i]=in.nextInt();
      }
      solve();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Beautiful_Numbers {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute testCases : int;
  static   attribute a : Sequence(int);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var position : Sequence(int) ; position := Integer.subrange(1,n + 1)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     position[a[i+1] - 1+1] := i )  ;     i := i + 1 ) ; 
    var l : int ; l := n ;
    var r : int ; r := 0 ;
    var ans : String ; ans := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     l := Set{l, position[i+1]}->min() ; 
     r := Set{r, position[i+1]}->max() ; 
     if (r - l = i) then (     ans := ans + StringLib.newString(1) ) else (     ans := ans + StringLib.newString(0) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans+"") ; 
 );
  static   operation main( amit : Sequence(String)) : void
  pre: true
  post: true
  activity: (     testCases := in.getCurrent()->toInteger() ; 
         var t : int ; t := 0 ; while t < testCases do ( (     n := in.getCurrent()->toInteger() ; 
     a := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     execute solve() )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int[] a=new int[n];
      int[] b=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=s.nextInt();
        b[a[i]-1]=i ;
      }
      int mi=n+1 ;
      int ma=0 ;
      for(int i=0 ; i<n ; i++){
        mi=Math.min(b[i],mi);
        ma=Math.max(b[i],ma);
        if(ma-mi==i)System.out.print(1);
        else System.out.print(0);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := s.getCurrent()->toInteger() ; 
     b[a[i+1] - 1+1] := i )  ;     i := i + 1 ) ; 
    var mi : int ; mi := n + 1 ;
    var ma : int ; ma := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     mi := Set{b[i+1], mi}->min() ; 
     ma := Set{b[i+1], ma}->max() ; 
     if (ma - mi = i) then     OclFile["System.out"].print(1) ; else     OclFile["System.out"].print(0) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static double solve(List<String>list){
    int i=2 ;
    for(; i<list.size(); i++){
      if(list.get(i).equals("+")|| list.get(i).equals("-")|| list.get(i).equals("*")|| list.get(i).equals("/")){
        double x ;
        if(list.get(i).equals("+")){
          x=Double.parseDouble(list.get(i-2))+Double.parseDouble(list.get(i-1));
        }
        else if(list.get(i).equals("-")){
          x=Double.parseDouble(list.get(i-2))-Double.parseDouble(list.get(i-1));
        }
        else if(list.get(i).equals("*")){
          x=Double.parseDouble(list.get(i-2))*Double.parseDouble(list.get(i-1));
        }
        else {
          x=Double.parseDouble(list.get(i-2))/Double.parseDouble(list.get(i-1));
        }
        list.remove(i);
        list.remove(i-1);
        list.remove(i-2);
        list.add(i-2,Double.toString(x));
        i=1 ;
      }
    }
    return Double.parseDouble(list.get(0));
  }
  public static void main(String[] args){
    Scanner stdIn=null ;
    try {
      stdIn=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
      while(stdIn.hasNext()){
        String[] s=stdIn.nextLine().split(" ");
        List<String>express=new LinkedList<String>();
        for(String str : s){
          express.add(str);
        }
        System.out.printf("%.6f%n",solve(express));
      }
    }
    finally {
      if(stdIn!=null){
        stdIn.close();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( list : Sequence(String)) : double
  pre: true
  post: true
  activity: (     var i : int ; i := 2 ;
       while i < list->size() do ( (     if (list->at(i+1) = "+" or list->at(i+1) = "-" or list->at(i+1) = "*" or list->at(i+1) = "/") then (     var x : double ;
     if (list->at(i+1) = "+") then (     x := (list->at(i - 2+1))->toReal() + (list->at(i - 1+1))->toReal() ) else     if (list->at(i+1) = "-") then (     x := (list->at(i - 2+1))->toReal() - (list->at(i - 1+1))->toReal() ) else     if (list->at(i+1) = "*") then (     x := (list->at(i - 2+1))->toReal() * (list->at(i - 1+1))->toReal() ) else (     x := (list->at(i - 2+1))->toReal() / (list->at(i - 1+1))->toReal() ) ;  ;  ;  
    list := list->excludingAt(i+1) ; 
    list := list->excludingFirst(i - 1) ; 
    list := list->excludingFirst(i - 2) ; 
    list->excludes(i - 2, ((x) + "")) ; 
    i := 1 ; 
 ) else skip )  ;     i := i + 1 ) ; 
     return (list->at(0+1))->toReal() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := null ;
     try (     stdIn := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
     while (stdIn.hasNext()) do (     var s : Sequence(String) ; s := stdIn.nextLine()->split(" ") ;
     var express : Sequence(String) ; express := Sequence{} ;
     for (str : s) do ( (     express := express->including(str) )  ) ; 
     OclFile["System.out"].printf("%.6f%n", solve(express)) ) )   finally (     if (stdIn /= null) then (     skip ) else skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long n=scanner.nextLong();
    long s=scanner.nextLong();
    if(n<s){
      System.out.println(-1);
      return ;
    }
    for(int d=39 ; d>1 ; d--){
      long b=lowerBound(d,n);
      while(d*Math.log(b)<=Math.log(n)){
        if(test(b,n,s)){
          System.out.println(b);
          return ;
        }
        b++;
      }
    }
    for(int a1=(int)Math.sqrt(n-s); a1>=1 ; a1--){
      if((n-s)% a1==0){
        long b=(n-s)/a1+1 ;
        long a0=n-a1*b ;
        if(a0>=0 && a0<b && a0+a1==s){
          System.out.println(b);
          return ;
        }
      }
    }
    if(n==s){
      System.out.println(n+1);
    }
    else {
      System.out.println(-1);
    }
  }
  private static boolean test(long b,long n,long s){
    if(b<2)return false ;
    long sum=0 ;
    while(n>0){
      sum+=n % b ;
      n/=b ;
    }
    return sum==s ;
  }
  private static long lowerBound(int d,long n){
    long left=1 ;
    long right=n ;
    double logn=Math.log(n);
    while(right-left>1){
      long mid=(left+right)/2 ;
      double logm=(d+1)*Math.log(mid);
      if(logm>logn){
        right=mid ;
      }
      else {
        left=mid ;
      }
    }
    return right ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := scanner.getCurrent()->toLong() ;
    var s : long ; s := scanner.getCurrent()->toLong() ;
    if (n < s) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
        var d : int ; d := 39 ; while d > 1 do ( (     var b : long ; b := lowerBound(d, n) ;
     while (d * (b)->log() <= (n)->log()) do (     if (test(b, n, s)) then (     OclFile["System.out"].println(b) ; 
     return ) else skip ; 
     b := b + 1 ) )  ;     d := d - 1 ) ; 
        var a1 : int ; a1 := (n - s)->sqrt()->oclAsType(int) ; while a1 >= 1 do ( (     if ((n - s) mod a1 = 0) then (     var b : long ; b := (n - s) / a1 + 1 ;
     var a0 : long ; a0 := n - a1 * b ;
     if (a0 >= 0 & a0 < b & a0 + a1 = s) then (     OclFile["System.out"].println(b) ; 
     return ) else skip ) else skip )  ;     a1 := a1 - 1 ) ; 
    if (n = s) then (     OclFile["System.out"].println(n + 1) ) else (     OclFile["System.out"].println(-1) ) ;  
 );
  static   operation test( b : long, n : long, s : long) : boolean
  pre: true
  post: true
  activity: (     if (b < 2) then     return false else skip ; 
     var sum : long ; sum := 0 ;
     while (n > 0) do (     sum := sum+(n mod b) ; 
     n := n/(b) ) ; 
     return sum = s );
  static   operation lowerBound( d : int, n : long) : long
  pre: true
  post: true
  activity: (     var left : long ; left := 1 ;
     var right : long ; right := n ;
    var logn : double ; logn := (n)->log() ;
    while (right - left > 1) do (     var mid : long ; mid := (left + right) / 2 ;
     var logm : double ; logm := (d + 1) * (mid)->log() ;
     if (logm > logn) then (     right := mid ) else (     left := mid ) ) ; 
    return right 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long s=sc.nextLong();
    long ans=(long)Math.pow(10,15);
    for(long b=2 ; (b*b)<=n ; b++){
      long t=0 ;
      long u=n ;
      while(u>0){
        t+=(u % b);
        u/=b ;
      }
      if(t==s){
        ans=Math.min(ans,b);
        break ;
      }
    }
    if(ans==(long)Math.pow(10,15)){
      for(long p=0 ; (p*p)<=n ; p++){
        long q=s-p ;
        if(q>=0){
          if(p==0){
            if(n==s){
              ans=Math.min(ans,n+1);
            }
          }
          else {
            if(p==0){
              if(n==s){
                ans=Math.min(ans,n+1);
              }
            }
            else {
              long d=n-q ;
              long b=d/p ;
              long t=0 ;
              long y=n ;
              if(b>1){
                while(y>0){
                  t+=(y % b);
                  y/=b ;
                }
                if(t==s){
                  ans=Math.min(ans,b);
                }
              }
            }
          }
        }
      }
    }
    if(ans==(long)Math.pow(10,15))ans=-1 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var s : long ; s := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 10->pow(15)->oclAsType(long) ;
        var b : long ; b := 2 ; while (b * b) <= n do ( (     var t : long ; t := 0 ;
     var u : long ; u := n ;
     while (u > 0) do (     t := t+((u mod b)) ; 
     u := u/(b) ) ; 
     if (t = s) then (     ans := Set{ans, b}->min() ; 
     break ) else skip )  ;     b := b + 1 ) ; 
    if (ans = 10->pow(15)->oclAsType(long)) then (         var p : long ; p := 0 ; while (p * p) <= n do ( (     var q : long ; q := s - p ;
     if (q >= 0) then (     if (p = 0) then (     if (n = s) then (     ans := Set{ans, n + 1}->min() ) else skip ) else (     if (p = 0) then (     if (n = s) then (     ans := Set{ans, n + 1}->min() ) else skip ) else (     var d : long ; d := n - q ;
     var b : long ; b := d / p ;
    var t : long ; t := 0 ;
    var y : long ; y := n ;
    if (b > 1) then (     while (y > 0) do (     t := t+((y mod b)) ; 
     y := y/(b) ) ; 
     if (t = s) then (     ans := Set{ans, b}->min() ) else skip ) else skip ; 
 ) ) ) else skip )  ;     p := p + 1 ) ) else skip ; 
    if (ans = 10->pow(15)->oclAsType(long)) then     ans := -1 ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main().run();
  }
  long f(long b,long n){
    if(n<b){
      return n ;
    }
    else {
      return f(b,n/b)+n % b ;
    }
  }
  void run(){
    long n=sc.nextLong();
    long s=sc.nextLong();
    if(n==s){
      System.out.println(n+1);
      return ;
    }
    long ans=Long.MAX_VALUE ;
    for(long b=2 ; b*b<=n ; ++b){
      if(f(b,n)==s){
        ans=Math.min(ans,b);
      }
    }
    for(long p=1 ; p*p<n ; ++p){
      long b=(n-s)/p+1 ;
      if(b<2){
        continue ;
      }
      if(f(b,n)==s){
        ans=Math.min(ans,b);
      }
    }
    if(ans!=Long.MAX_VALUE){
      System.out.println(ans);
    }
    else {
      System.out.println(-1);
    }
  }
  int ni(){
    return Integer.parseInt(sc.next());
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation f( b : long, n : long) : long
  pre: true
  post: true
  activity: (     if (n < b) then (     return n ) else (     return f(b, n / b) + n mod b ) );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.getCurrent()->toLong() ;
     var s : long ; s := sc.getCurrent()->toLong() ;
    if (n = s) then (     OclFile["System.out"].println(n + 1) ; 
     return ) else skip ; 
    var ans : long ; ans := "9223372036854775807"->toLong() ;
        var b : long ; b := 2 ; while b * b <= n do ( (     if (f(b, n) = s) then (     ans := Set{ans, b}->min() ) else skip )  ;     b := b + 1 ) ; 
        var p : long ; p := 1 ; while p * p < n do ( (     var b : long ; b := (n - s) / p + 1 ;
     if (b < 2) then (     continue ) else skip ; 
     if (f(b, n) = s) then (     ans := Set{ans, b}->min() ) else skip )  ;     p := p + 1 ) ; 
    if (ans /= "9223372036854775807"->toLong()) then (     OclFile["System.out"].println(ans) ) else (     OclFile["System.out"].println(-1) ) ;  
 );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (sc.getCurrent())->toInteger() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long input_n=Long.parseLong(scanner.next());
    long input_s=Long.parseLong(scanner.next());
    scanner.close();
    boolean isFound=false ;
    if(input_n==input_s){
      System.out.println(input_n+1);
      isFound=true ;
    }
    else {
      for(int i=2 ; i<=Math.pow(input_n,0.5); i++){
        if(input_s==merge(i,input_n)){
          System.out.println(i);
          isFound=true ;
          break ;
        }
      }
      if(! isFound){
        for(int i=(int)Math.pow(input_n,0.5); i>0 ; i--){
          if((input_n-input_s)% i==0 &&(int)Math.pow(input_n,0.5)<(input_n-input_s)/i+1){
            if(input_s==merge((input_n-input_s)/i+1,input_n)){
              System.out.println((input_n-input_s)/i+1);
              isFound=true ;
              break ;
            }
          }
        }
      }
    }
    if(! isFound){
      System.out.println(-1);
    }
  }
  private static long merge(long exp,long n){
    if(n<exp){
      return n ;
    }
    else {
      return merge(exp,n/exp)+n % exp ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input_n : long ; input_n := (scanner.getCurrent())->toLong() ;
    var input_s : long ; input_s := (scanner.getCurrent())->toLong() ;
    skip ; 
    var isFound : boolean ; isFound := false ;
    if (input_n = input_s) then (     OclFile["System.out"].println(input_n + 1) ; 
     isFound := true ) else (         var i : int ; i := 2 ; while i <= input_n->pow(0.5) do ( (     if (input_s = merge(i, input_n)) then (     OclFile["System.out"].println(i) ; 
     isFound := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (not(isFound)) then (         var i : int ; i := input_n->pow(0.5)->oclAsType(int) ; while i > 0 do ( (     if ((input_n - input_s) mod i = 0 & input_n->pow(0.5)->oclAsType(int) < (input_n - input_s) / i + 1) then (     if (input_s = merge((input_n - input_s) / i + 1, input_n)) then (     OclFile["System.out"].println((input_n - input_s) / i + 1) ; 
     isFound := true ; 
     break ) else skip ) else skip )  ;     i := i - 1 ) ) else skip ) ;  
    if (not(isFound)) then (     OclFile["System.out"].println(-1) ) else skip ; 
 );
  static   operation merge( exp : long, n : long) : long
  pre: true
  post: true
  activity: (     if (n < exp) then (     return n ) else (     return merge(exp, n / exp) + n mod exp ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int[] r=new int[4];
    for(int i=0 ; i<4 ; i++){
      r[i]=sc.nextInt();
    }
    Arrays.sort(r);
    System.out.println(Math.abs(r[0]+r[3]-r[1]-r[2]));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : Sequence(int) ; r := Integer.subrange(1,4)->collect(0) ;
         var i : int ; i := 0 ; while i < 4 do ( (     r[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     r := r->sort() ; 
     OclFile["System.out"].println(if r[0+1] + r[3+1] - r[1+1] - r[2+1] < 0 then -(r[0+1] + r[3+1] - r[1+1] - r[2+1]) else r[0+1] + r[3+1] - r[1+1] - r[2+1] endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long s=sc.nextLong();
    System.out.println(solve(n,s));
    sc.close();
  }
  static long solve(long n,long s){
    long result=(s==n)?(n+1): Long.MAX_VALUE ;
    if(n>s){
      long product=n-s ;
      for(int f1=1 ; (long)f1*f1<=product ; ++f1){
        if(check(n,s,f1+1)){
          result=Math.min(result,f1+1);
        }
        long f2=product/f1 ;
        if(check(n,s,f2+1)){
          result=Math.min(result,f2+1);
        }
      }
    }
    for(int i=2 ; (long)i*i<=n ; ++i){
      if(check(n,s,i)){
        result=Math.min(result,i);
      }
    }
    return(result==Long.MAX_VALUE)?-1 : result ;
  }
  static boolean check(long n,long s,long base){
    long digitSum=0 ;
    while(n!=0){
      digitSum+=n % base ;
      n/=base ;
    }
    return digitSum==s ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var s : long ; s := sc.getCurrent()->toLong() ;
    OclFile["System.out"].println(solve(n, s)) ; 
    skip ; 
 );
  static   operation solve( n : long, s : long) : long
  pre: true
  post: true
  activity: (     var result : long ; result := if (s = n) then (n + 1) else "9223372036854775807"->toLong() endif ;
     if (n > s) then (     var product : long ; product := n - s ;
         var f1 : int ; f1 := 1 ; while f1->oclAsType(long) * f1 <= product do ( (     if (check(n, s, f1 + 1)) then (     result := Set{result, f1 + 1}->min() ) else skip ; 
     var f2 : long ; f2 := product / f1 ;
     if (check(n, s, f2 + 1)) then (     result := Set{result, f2 + 1}->min() ) else skip )  ;     f1 := f1 + 1 ) ) else skip ; 
         var i : int ; i := 2 ; while i->oclAsType(long) * i <= n do ( (     if (check(n, s, i)) then (     result := Set{result, i}->min() ) else skip )  ;     i := i + 1 ) ; 
     return if (result = "9223372036854775807"->toLong()) then -1 else result endif );
  static   operation check( n : long, s : long, base : long) : boolean
  pre: true
  post: true
  activity: (     var digitSum : long ; digitSum := 0 ;
     while (n /= 0) do (     digitSum := digitSum+(n mod base) ; 
     n := n/(base) ) ; 
     return digitSum = s );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.math.BigInteger ;
import java.util.*;
import static java.lang.Long.max ;
import static java.lang.Long.toHexString ;
import static java.lang.Math.abs ;
import static java.lang.Math.sin ;
public class B {
  public static void main(String[] args){
    MyScanner in=new MyScanner();
    int m=in.nextInt();
    int b=in.nextInt();
    long result=0 ;
    for(int x=1 ; x<=m*b ; ++x){
      long y=(long)(-1.0*x/m+b);
      result=Math.max(result,1L*(x+1)*(y)*(y+1)/2+1L*(y+1)*(x)*(x+1)/2);
    }
    System.out.println(result);
  }
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : MyScanner ; in := MyScanner.newMyScanner() ;
     var m : int ; m := in.nextInt() ;
    var b : int ; b := in.nextInt() ;
    var result : long ; result := 0 ;
        var x : int ; x := 1 ; while x <= m * b do ( (     var y : long ; y := (-1.0 * x / m + b)->oclAsType(long) ;
     result := Set{result, 1L * (x + 1) * (y) * (y + 1) / 2 + 1L * (y + 1) * (x) * (x + 1) / 2}->max() )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner is=new Scanner(System.in);
    final short m=is.nextShort();
    final short b=is.nextShort();
    long answer=0 ;
    for(long i=b,j=0 ; i>=b/4 ; i--,j+=m)answer=Math.max(answer,((i+1)*(j+1)*(i+j))/2);
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := is.nextShort() ;
    var b : int ; b := is.nextShort() ;
    var answer : long ; answer := 0 ;
        var i : long ; i := b ;
    var j : long ; j := 0 ; while i >= b / 4 do (     answer := Set{answer, ((i + 1) * (j + 1) * (i + j)) / 2}->max() ;  ;     i := i - 1 ;     j := j+(m) ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int check(int n,int m){
    if(m % n==0){
      System.out.print("YES");
    }
    else {
      System.out.print("NO");
    }
    return 0 ;
  }
  public static void main(String[] args){
    int n=5 ;
    int m=10 ;
    check(n,m);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation check( n : int, m : int) : int
  pre: true
  post: true
  activity: (     if (m mod n = 0) then (     OclFile["System.out"].print("YES") ) else (     OclFile["System.out"].print("NO") ) ;  
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var m : int ; m := 10 ;
     execute check(n, m) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] argv)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String cantidad=br.readLine();
    String[] solucion=new String[Integer.parseInt(cantidad)];
    for(int i=0 ; i<Integer.parseInt(cantidad); i++){
      String cantidadfor=br.readLine();
      int cantidadelementos=Integer.parseInt(cantidadfor);
      String[] elementosS=br.readLine().split(" ");
      int[] elementos=new int[cantidadelementos];
      for(int j=0 ; j<elementosS.length ; j++){
        elementos[j]=Integer.parseInt(elementosS[j]);
      }
      for(int j=0 ; j<cantidadelementos ; j++){
        boolean centinela=false ;
        for(int k=cantidadelementos-1 ; k>=0 ; k--){
          if(elementos[j]==elementos[k] && k-j>=2){
            solucion[i]="YES" ;
            break ;
          }
        }
        if(centinela)break ;
      }
    }
    for(int i=0 ; i<solucion.length ; i++){
      if(solucion[i]==null){
        solucion[i]="NO" ;
      }
    }
    for(int i=0 ; i<solucion.length ; i++){
      System.out.println(solucion[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( argv : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var cantidad : String ; cantidad := br.readLine() ;
    var solucion : Sequence(String) ; solucion := Integer.subrange(1,(cantidad)->toInteger())->collect(null) ;
        var i : int ; i := 0 ; while i < (cantidad)->toInteger() do ( (     var cantidadfor : String ; cantidadfor := br.readLine() ;
     var cantidadelementos : int ; cantidadelementos := (cantidadfor)->toInteger() ;
    var elementosS : Sequence(String) ; elementosS := br.readLine()->split(" ") ;
    var elementos : Sequence(int) ; elementos := Integer.subrange(1,cantidadelementos)->collect(0) ;
        var j : int ; j := 0 ; while j < elementosS->size() do ( (     elementos[j+1] := (elementosS[j+1])->toInteger() )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < cantidadelementos do ( (     var centinela : boolean ; centinela := false ;
         var k : int ; k := (cantidadelementos)->char2byte() - 1 ; while k >= 0 do ( (     if (elementos[j+1] = elementos[k+1] & k - j >= 2) then (     solucion[i+1] := "YES" ; 
     break ) else skip )  ;     k := k - 1 ) ; 
     if (centinela) then     break else skip )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < solucion->size() do ( (     if (solucion[i+1] = null) then (     solucion[i+1] := "NO" ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < solucion->size() do ( (     OclFile["System.out"].println(solucion[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Codeforces {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int tests=sc.nextInt();
    for(int t=0 ; t<tests ; t++){
      int n=sc.nextInt();
      int[] tab=new int[n];
      HashSet hs=new HashSet<Integer>();
      boolean res=false ;
      for(int i=0 ; i<n ; i++){
        tab[i]=sc.nextInt();
      }
      for(int i=2 ; i<n ; i++){
        hs.add(tab[i-2]);
        if(hs.contains(tab[i])){
          res=true ;
          break ;
        }
      }
      if(res)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tests : int ; tests := sc.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < tests do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var tab : Sequence(int) ; tab := Integer.subrange(1,n)->collect(0) ;
    var hs : Set ; hs := Set{} ;
    var res : boolean ; res := false ;
        var i : int ; i := 0 ; while i < n do ( (     tab[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i < n do ( (     hs := hs->including(tab[i - 2+1]) ; 
     if (hs->includes(tab[i+1])) then (     res := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (res) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Stack ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    String[] params=null ;
    while((params=parseParams())!=null){
      Stack<String>stack=new Stack<String>();
      for(String param : params){
        try {
          Double.parseDouble(param);
          stack.push(param);
        }
        catch(NumberFormatException e){
          double val2=Double.parseDouble(stack.pop());
          double val1=Double.parseDouble(stack.pop());
          String res=calc(param,val1,val2);
          if(res!=null){
            stack.push(res);
          }
        }
      }
      System.out.println(stack.pop());
    }
  }
  private static String calc(String sign,double val1,double val2){
    String result=null ;
    if(sign.equals("+")){
      result=String.format("%.6f",val1+val2);
    }
    else if(sign.equals("-")){
      result=String.format("%.6f",val1-val2);
    }
    else if(sign.equals("*")){
      result=String.format("%.6f",val1*val2);
    }
    else if(sign.equals("/")){
      result=String.format("%.6f",val1/val2);
    }
    return result ;
  }
  private static String[] parseParams(){
    String[] params=null ;
    String strIn=null ;
    if((strIn=parseStdin())!=null){
      params=strIn.split(" ");
    }
    return params ;
  }
  private static String parseStdin(){
    String stdin=null ;
    try {
      stdin=br.readLine();
    }
    catch(IOException e){
    }
    return stdin ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var params : Sequence(String) ; params := null ;
         params := parseParams() ;
    while ((params) /= null) do (    skip ; (     var stack : Sequence(String) ; stack := Sequence{} ;
     for (param : params) do ( (     try (     Double.parseDouble(param) ; 
     stack := stack->append(param) )   catch (e : IncorrectElementException) do (     var val2 : double ; val2 := (stack->last())->toReal() ;
     var val1 : double ; val1 := (stack->last())->toReal() ;
     var res : String ; res := calc(param, val1, val2) ;
     if (res /= null) then (     stack := stack->append(res) ) else skip )
 )  ) ; 
     OclFile["System.out"].println(stack->last()) ) ;     params := parseParams() ;
 ) );
  static   operation calc( sign : String, val1 : double, val2 : double) : String
  pre: true
  post: true
  activity: (     var result : String ; result := null ;
     if (sign = "+") then (     result := StringLib.format("%.6f",Sequence{val1 + val2}) ) else     if (sign = "-") then (     result := StringLib.format("%.6f",Sequence{val1 - val2}) ) else     if (sign = "*") then (     result := StringLib.format("%.6f",Sequence{val1 * val2}) ) else     if (sign = "/") then (     result := StringLib.format("%.6f",Sequence{val1 / val2}) ) else skip ; ;  ;  ;  
     return result );
  static   operation parseParams() : Sequence(String)
  pre: true
  post: true
  activity: (     var params : Sequence(String) ; params := null ;
     var strIn : String ; strIn := null ;
     if ((strIn) /= null) then (     params := strIn->split(" ") ) else skip ; 
     return params );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var stdin : String ; stdin := null ;
     try (     stdin := br.readLine() )   catch (e : IOException) do skip
     return stdin );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class ProblemA {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int test=Integer.parseInt(br.readLine());
    while(test-->0){
      int n=Integer.parseInt(br.readLine());
      String line[]=br.readLine().split(" ");
      int arr[]=new int[n];
      HashMap<Integer,Integer>map=new HashMap<>();
      String ans="NO" ;
      for(int i=0 ; i<n ; i++){
        arr[i]=Integer.parseInt(line[i]);
        if(map.containsKey(arr[i])){
          if(i-map.get(arr[i])>1){
            ans="YES" ;
          }
        }
        else {
          map.put(arr[i],i);
        }
      }
      sb.append(ans);
      sb.append("\n");
    }
    System.out.println(sb);
  }
  public static void sort(int arr[]){
    ArrayList<Integer>list=new ArrayList<>();
    for(int it : arr)list.add(it);
    Collections.sort(list);
    for(int i=0 ; i<list.size(); i++)arr[i]=list.get(i);
  }
}
class Pair {
  int l,r ;
  public Pair(int l,int r){
    this.l=l ;
    this.r=r ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var test : int ; test := (br.readLine())->toInteger() ;
        while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var map : Map(int,int) ; map := Map{} ;
    var ans : String ; ans := "NO" ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (line[i+1])->toInteger() ; 
     if (map->keys()->includes(arr[i+1])) then (     if ((i)->char2byte() - map->at(arr[i+1]) > 1) then (     ans := "YES" ) else skip ) else (     map := map->union(Map{arr[i+1] |-> i}) ) )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(ans) ; 
    sb := sb + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
  static   operation sort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     for (it : arr) do (     list := list->including(it) ;  ) ; 
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < list->size() do (     arr[i+1] := list->at(i+1) ;  ;     i := i + 1 ) );
}
class Pair {
   attribute l : int;
   static operation newPair( l : int, r : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(l, r);
    return self );
  operation initialise( l : int, r : int) : void
  pre: true  post: true
  activity: (     self.l := l ; 
     self.r := r );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(a<=b){
      System.out.println(b-a);
    }
    else {
      System.out.println(a-b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (a <= b) then (     OclFile["System.out"].println(b - a) ) else (     OclFile["System.out"].println(a - b) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[])throws IOException {
    Scanner scan=new Scanner(System.in);
    int x1=scan.nextInt();
    int x2=scan.nextInt();
    System.out.println(Math.abs(x1-x2));
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : int ; x1 := scan.getCurrent()->toInteger() ;
    var x2 : int ; x2 := scan.getCurrent()->toInteger() ;
    OclFile["System.out"].println(if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class A {
  public static void main(String...args){
    final Scanner sc=new Scanner(System.in);
    final int[] abcd=new int[4];
    Arrays.setAll(abcd,i->sc.nextInt());
    Arrays.sort(abcd);
    System.out.println(Math.abs(abcd[0]+abcd[3]-abcd[1]-abcd[2]));
  }
}
public class Main {
  public static void main(String...args){
    A.main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var abcd : Sequence(int) ; abcd := Integer.subrange(1,4)->collect(0) ;
setAll(abcd, lambda i : OclAny in sc.getCurrent()->toInteger()) ; 
    abcd := abcd->sort() ; 
    OclFile["System.out"].println(if abcd[0+1] + abcd[3+1] - abcd[1+1] - abcd[2+1] < 0 then -(abcd[0+1] + abcd[3+1] - abcd[1+1] - abcd[2+1]) else abcd[0+1] + abcd[3+1] - abcd[1+1] - abcd[2+1] endif) ; 
 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     A.main() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      while(scanner.hasNextLine()){
        String[] tmp=scanner.nextLine().split(" ");
        int x1=Integer.valueOf(tmp[0]);
        int x2=Integer.valueOf(tmp[1]);
        System.out.println(solver(x1,x2));
      }
    }
  }
  private static int solver(int x1,int x2){
    return Math.max(x1,x2)-Math.min(x1,x2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (scanner.hasNextLine()) do (     var tmp : Sequence(String) ; tmp := scanner.nextLine()->split(" ") ;
     var x1 : int ; x1 := (tmp[0+1])->toInteger() ;
     var x2 : int ; x2 := (tmp[1+1])->toInteger() ;
     OclFile["System.out"].println(solver(x1, x2)) ) ))  );
  static   operation solver( x1 : int, x2 : int) : int
  pre: true
  post: true
  activity: (     return Set{x1, x2}->max() - Set{x1, x2}->min() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    int[] i=ArrconvAtoi(s);
    System.out.println(Math.abs(i[0]-i[1]));
  }
  private static int[] ArrconvAtoi(String s){
    String[] strs=s.split(" ");
    int[] ints=new int[strs.length];
    int i=0 ;
    for(String st : strs){
      ints[i]=Integer.parseInt(st);
      i++;
    }
    return ints ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
     var i : Sequence(int) ; i := ArrconvAtoi(s) ;
     OclFile["System.out"].println(if i[0+1] - i[1+1] < 0 then -(i[0+1] - i[1+1]) else i[0+1] - i[1+1] endif) );
  static   operation ArrconvAtoi( s : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var strs : Sequence(String) ; strs := s->split(" ") ;
     var ints : Sequence(int) ; ints := Integer.subrange(1,strs->size())->collect(0) ;
    var i : int ; i := 0 ;
    for (st : strs) do ( (     ints[i+1] := (st)->toInteger() ; 
     i := i + 1 )  ) ; 
    return ints 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void solve(){
    int a,b ;
    Scanner sc=new Scanner(System.in);
    a=sc.nextInt();
    b=sc.nextInt();
    System.out.println((a>b)? a-b : b-a);
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ;
    var b : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    OclFile["System.out"].println(if (a > b) then a - b else b - a endif) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.*;
public class App {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws Exception {
    if(System.getProperty("ONLINE_JUDGE")==null){
      File inputFile=new File("/Users/vipinjain/self/cp/input.txt");
      File outputFile=new File("/Users/vipinjain/self/cp/output.txt");
      br=new BufferedReader(new FileReader(inputFile));
      bw=new BufferedWriter(new FileWriter(outputFile));
    }
    int tests ;
    tests=1 ;
    while(tests-->0){
      solve();
    }
    bw.flush();
    bw.close();
    br.close();
  }
  static void solve()throws Exception {
    String str=br.readLine();
    int index=str.indexOf(".");
    if(index==-1){
      bw.write(str);
      return ;
    }
    int d=str.charAt(index+1)-'0' ;
    int i=str.charAt(index-1)-'0' ;
    if(i==9){
      bw.write("GOTO Vasilisa.");
      return ;
    }
    if(d>=5){
      bw.write(str.substring(0,index-1)+(i+1));
    }
    else {
      bw.write(str.substring(0,index));
    }
    bw.write("\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null) then (     var inputFile : OclFile ; inputFile := OclFile("/Users/vipinjain/self/cp/input.txt") ;
     var outputFile : OclFile ; outputFile := OclFile("/Users/vipinjain/self/cp/output.txt") ;
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputFile)) ; 
     bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputFile)) ) else skip ; 
     var tests : int ;
    tests := 1 ; 
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var str : String ; str := br.readLine() ;
     var index : int ; index := str->indexOf(".")-1 ;
    if (index = -1) then (     skip ; 
     return ) else skip ; 
    var d : int ; d := str->at(index + 1+1) - ('0')->char2byte() ;
    var i : int ; i := str->at((index)->char2byte() - 1+1) - ('0')->char2byte() ;
    if (i = 9) then (     skip ; 
     return ) else skip ; 
    if (d >= 5) then (     skip ) else (     skip ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javax.swing.plaf.basic.BasicInternalFrameTitlePane ;
import java.util.*;
import java.math.*;
public class RiannePolicarpioKingdom {
  public static void main(String args[]){
    Scanner cin=new Scanner(System.in);
    BigDecimal x=cin.nextBigDecimal();
    if(x.toBigInteger().mod(BigInteger.TEN).compareTo(BigInteger.valueOf(9))==0){
      System.out.println("GOTO Vasilisa.");
    }
    else {
      System.out.println(x.setScale(0,BigDecimal.ROUND_HALF_UP));
      cin.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class RiannePolicarpioKingdom {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : double ; x := cin.nextBigDecimal() ;
     if (x.toBigInteger().mod(10)->compareTo((9 + "")->toLong()) = 0) then (     OclFile["System.out"].println("GOTO Vasilisa.") ) else (     OclFile["System.out"].println(x.setScale(0, ROUND_HALF_UP)) ; 
     skip ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    char[] str=new Scanner(System.in).nextLine().toCharArray();
    int dotIndex=0 ;
    for(int i=0 ; i<str.length ; i++)if(str[i]=='.'){
      dotIndex=i ;
      break ;
    }
    if(str[dotIndex-1]=='9'){
      System.out.println("GOTO Vasilisa.");
    }
    else if(Integer.parseInt(str[dotIndex+1]+"")>4){
      String _str="" ;
      for(int i=0 ; i<dotIndex ; i++)_str+=str[i];
      System.out.println(new BigInteger(_str).add(new BigInteger("1")).toString());
    }
    else {
      for(int i=0 ; i<dotIndex ; i++)System.out.print(str[i]);
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := OclFile.newOclFile_Read(OclFile["System.in"]).nextLine()->characters() ;
     var dotIndex : int ; dotIndex := 0 ;
         var i : int ; i := 0 ; while i < str->size() do (     if (str[i+1] = '.') then (     dotIndex := i ; 
     break ) else skip ;  ;     i := i + 1 ) ; 
     if (str[dotIndex - 1+1] = '9') then (     OclFile["System.out"].println("GOTO Vasilisa.") ) else     if ((str[dotIndex + 1+1] + "")->toInteger() > 4) then (     var _str : String ; _str := "" ;
         var i : int ; i := 0 ; while i < dotIndex do (     _str := _str+(str[i+1]) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(long(_str)->excludes(long("1"))+"") ) else (         var i : int ; i := 0 ; while i < dotIndex do (     OclFile["System.out"].print(str[i+1]) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    char[] c=new char[a];
    String s=sc.next();
    c=s.toCharArray();
    char[] ch=new char[26];
    for(int i=0 ; i<26 ; i++){
      ch[i]=(char)('a'+i);
    }
    for(int i=0 ; i<b ; i++){
      String m=sc.next();
      String n=sc.next();
      char mm=m.charAt(0);
      char nn=n.charAt(0);
      int flag=1 ;
      for(int j=0 ; j<26 ; j++){
        if(ch[j]==mm && flag==1){
          ch[j]=nn ;
          flag=0 ;
        }
        if(ch[j]==nn && flag==1){
          ch[j]=mm ;
          flag=0 ;
        }
        flag=1 ;
      }
    }
    for(int i=0 ; i<a ; i++){
      c[i]=ch[c[i]-97];
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : Sequence(String) ; c := Integer.subrange(1,a)->collect(0) ;
    var s : String ; s := sc.getCurrent() ;
    c := s->characters() ; 
    var ch : Sequence(String) ; ch := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < 26 do ( (     ch[i+1] := ('a' + i)->oclAsType(String) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < b do ( (     var m : String ; m := sc.getCurrent() ;
     var n : String ; n := sc.getCurrent() ;
    var mm : String ; mm := m->at(0+1) ;
    var nn : String ; nn := n->at(0+1) ;
    var flag : int ; flag := 1 ;
        var j : int ; j := 0 ; while j < 26 do ( (     if (ch[j+1] = mm & flag = 1) then (     ch[j+1] := nn ; 
     flag := 0 ) else skip ; 
     if (ch[j+1] = nn & flag = 1) then (     ch[j+1] := mm ; 
     flag := 0 ) else skip ; 
     flag := 1 )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a do ( (     c[i+1] := ch[c[i+1] - 97+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class FunctionHeight {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long k=sc.nextLong();
    System.out.println(n>=k ? 1 :(k % n==0 ? k/n :(k/n+1)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class FunctionHeight {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
     var k : long ; k := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println(if n >= k then 1 else (if k mod n = 0 then k / n else (k / n + 1) endif) endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Rebranding {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    if(scanner.hasNext()){
      int n=scanner.nextInt();
      int m=scanner.nextInt();
      String s=scanner.next();
      int c[]=new int[26];
      for(int i=0 ; i<26 ; i++)c[i]=i ;
      for(int i=0 ; i<m ; i++){
        int a=scanner.next().charAt(0)-'a' ;
        int b=scanner.next().charAt(0)-'a' ;
        for(int j=0 ; j<26 ; j++){
          if(c[j]==a)c[j]=b ;
          else if(c[j]==b)c[j]=a ;
        }
      }
      for(int i=0 ; i<n ; i++){
        int x=s.charAt(i)-'a' ;
        System.out.print((char)(c[x]+'a'));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Rebranding {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     if (scanner.hasNext()) then (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
    var s : String ; s := scanner.getCurrent() ;
    var c : Sequence(int) ; c := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < 26 do (     c[i+1] := i ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := scanner.getCurrent()->at(0+1) - ('a')->char2byte() ;
     var b : int ; b := scanner.getCurrent()->at(0+1) - ('a')->char2byte() ;
         var j : int ; j := 0 ; while j < 26 do ( (     if (c[j+1] = a) then     c[j+1] := b ; else     if (c[j+1] = b) then     c[j+1] := a ; else skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := s->at(i+1) - ('a')->char2byte() ;
     OclFile["System.out"].print((c[x+1] + 'a')->oclAsType(String)) )  ;     i := i + 1 ) ; 
 ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findNthOccur(String str,char ch,int N){
    int occur=0 ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)==ch){
        occur+=1 ;
      }
      if(occur==N)return i ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    String str="geeks" ;
    char ch='e' ;
    int N=2 ;
    System.out.print(findNthOccur(str,ch,N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNthOccur( str : String, ch : String, N : int) : int
  pre: true
  post: true
  activity: (     var occur : int ; occur := 0 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = ch) then (     occur := occur+(1) ) else skip ; 
     if (occur = N) then     return i else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeks" ;
     var ch : String ; ch := 'e' ;
     var N : int ; N := 2 ;
     OclFile["System.out"].print(findNthOccur(str, ch, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    int d1=Math.abs((a+b)-(c+d));
    int d2=Math.abs((a+c)-(b+d));
    int d3=Math.abs((a+d)-(b+c));
    System.out.println(Math.min(Math.min(d1,d2),d3));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var d1 : int ; d1 := if (a + b) - (c + d) < 0 then -((a + b) - (c + d)) else (a + b) - (c + d) endif ;
    var d2 : int ; d2 := if (a + c) - (b + d) < 0 then -((a + c) - (b + d)) else (a + c) - (b + d) endif ;
    var d3 : int ; d3 := if (a + d) - (b + c) < 0 then -((a + d) - (b + c)) else (a + d) - (b + c) endif ;
    OclFile["System.out"].println(Set{Set{d1, d2}->min(), d3}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int T=sc.nextInt();
    int[][] AB=new int[N][2];
    for(int i=0 ; i<N ; i++){
      AB[i][0]=sc.nextInt();
      AB[i][1]=sc.nextInt();
    }
    Arrays.sort(AB,(a,b)->a[0]-b[0]);
    int max=0 ;
    int[][] dp=new int[N+1][T];
    for(int i=0 ; i<N ; i++){
      int a=AB[i][0];
      int b=AB[i][1];
      for(int j=T-1 ; j>=0 ; j--){
        dp[i+1][j]=dp[i][j];
        if(j>=a){
          dp[i+1][j]=Math.max(dp[i+1][j],dp[i][j-a]+b);
        }
      }
      max=Math.max(max,dp[i][T-1]+b);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
    var AB : Sequence(Sequence(int)) ; AB := Integer.subrange(1,N)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     AB[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     AB[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    AB := OclComparator.sortWith(AB, lambda (a , b) : OclAny in a[0+1] - b[0+1]) ; 
    var max : int ; max := 0 ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,T)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := AB[i+1][0+1] ;
     var b : int ; b := AB[i+1][1+1] ;
         var j : int ; j := T - 1 ; while j >= 0 do ( (     dp[i + 1+1][j+1] := dp[i+1][j+1] ; 
     if (j >= a) then (     dp[i + 1+1][j+1] := Set{dp[i + 1+1][j+1], dp[i+1][j - a+1] + b}->max() ) else skip )  ;     j := j - 1 ) ; 
     max := Set{max, dp[i+1][T - 1+1] + b}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  static int[][] dp,ab ;
  static int n,t ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    t=sc.nextInt();
    ab=new int[n][2];
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt(),b=sc.nextInt();
      ab[i][0]=a ;
      ab[i][1]=b ;
    }
    sc.close();
    Arrays.sort(ab,(u,v)->u[0]>v[0] ? 1 : u[0]<v[0] ?-1 : 0);
    dp=new int[n][t+1];
    System.out.println(dp(0,t));
  }
  static int dp(int i,int rest){
    if(rest<=0 || i>=n)return 0 ;
    if(dp[i][rest]>0)return dp[i][rest];
    return dp[i][rest]=Math.max(dp(i+1,rest),dp(i+1,rest-ab[i][0])+ab[i][1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dp : Sequence(Sequence(int));
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    t := sc.getCurrent()->toInteger() ; 
    ab := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ; 
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
     ab[i+1][0+1] := a ; 
     ab[i+1][1+1] := b )  ;     i := i + 1 ) ; 
    skip ; 
    ab := OclComparator.sortWith(ab, lambda (u , v) : OclAny in if u[0+1] > v[0+1] then 1 else if u[0+1] < v[0+1] then -1 else 0 endif endif) ; 
    dp := Integer.subrange(1,n)->collect(Integer.subrange(1,t + 1)->collect(0)) ; 
    OclFile["System.out"].println(dp(0, t)) ; 
 );
  static   operation dp( i : int, rest : int) : int
  pre: true
  post: true
  activity: (     if (rest <= 0 or i >= n) then     return 0 else skip ; 
     if (dp[i+1][rest+1] > 0) then     return dp[i+1][rest+1] else skip ; 
     return dp[i+1][rest+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int T=sc.nextInt();
    int[][] AB=new int[N][2];
    for(int i=0 ; i<N ; i++){
      AB[i][0]=sc.nextInt();
      AB[i][1]=sc.nextInt();
    }
    Arrays.sort(AB,Comparator.comparingInt(a->a[0]));
    int[][] dp=new int[N+1][6001];
    for(int i=1 ; i<=N ; i++){
      for(int timeAfterEat=0 ; timeAfterEat<=6000 ; timeAfterEat++){
        dp[i][timeAfterEat]=Math.max(dp[i][timeAfterEat],dp[i-1][timeAfterEat]);
        int time=AB[i-1][0];
        int value=AB[i-1][1];
        if(0<=timeAfterEat-time && timeAfterEat-time<T){
          dp[i][timeAfterEat]=Math.max(dp[i][timeAfterEat],dp[i-1][timeAfterEat-time]+value);
        }
      }
    }
    System.out.println(Arrays.stream(dp[N]).max().getAsInt());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
    var AB : Sequence(Sequence(int)) ; AB := Integer.subrange(1,N)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     AB[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     AB[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    AB := OclComparator.sortWith(AB, Comparator.comparingInt(lambda a : OclAny in a[0+1])) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,6001)->collect(0)) ;
        var i : int ; i := 1 ; while i <= N do ( (         var timeAfterEat : int ; timeAfterEat := 0 ; while timeAfterEat <= 6000 do ( (     dp[i+1][timeAfterEat+1] := Set{dp[i+1][timeAfterEat+1], dp[i - 1+1][timeAfterEat+1]}->max() ; 
     var time : int ; time := AB[i - 1+1][0+1] ;
     var value : int ; value := AB[i - 1+1][1+1] ;
     if (0 <= timeAfterEat - time & timeAfterEat - time < T) then (     dp[i+1][timeAfterEat+1] := Set{dp[i+1][timeAfterEat+1], dp[i - 1+1][timeAfterEat - time+1] + value}->max() ) else skip )  ;     timeAfterEat := timeAfterEat + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(stream(dp[N+1]).max().getAsInt()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  static class C implements Comparator<Fud>{
    @ Override public int compare(Fud o1,Fud o2){
      return o1.a-o2.a ;
    }
  }
  static class Fud {
    int a ;
    int b ;
    public Fud(int a0,int b0){
      a=a0 ;
      b=b0 ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    long[] score=new long[t];
    long best=0 ;
    Fud[] fud=new Fud[n];
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      fud[i]=new Fud(a,b);
    }
    C c=new C();
    Arrays.sort(fud,c);
    for(int i=0 ; i<n ; i++){
      for(int x=0 ; x<t ; x++){
        best=Math.max(best,score[x]+fud[i] .b);
      }
      long[] scorenew=new long[t];
      for(int x=0 ; x<t ; x++){
        if(x+fud[i] .a<t){
          scorenew[x+fud[i] .a]=Math.max(score[x+fud[i] .a],score[x]+fud[i] .b);
        }
      }
      for(int x=0 ; x<t ; x++)score[x]=Math.max(score[x],scorenew[x]);
    }
    System.out.println(best);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class C implements Function(<Fud>,(<Fud>,boolean)) {
      operation compare( o1 : Fud, o2 : Fud) : int
  pre: true
  post: true
  activity: (     return o1.a - o2.a );
}
  static class Fud {
   attribute a : int;
   attribute b : int;
   static operation newFud( a0 : int, b0 : int) : Fud
  pre: true
  post: true
  activity:
  ( var self : Fud ;
    self := createFud();
    self.initialise(a0, b0);
    return self );
  operation initialise( a0 : int, b0 : int) : void
  pre: true  post: true
  activity: (     a := a0 ; 
     b := b0 );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var score : Sequence(long) ; score := Integer.subrange(1,t)->collect(0) ;
    var best : long ; best := 0 ;
    var fud : Sequence(Fud) ; fud := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     fud[i+1] := Fud.newFud(a, b) )  ;     i := i + 1 ) ; 
    var c : C ; c := C.newC() ;
    fud := OclComparator.sortWith(fud, c) ; 
        var i : int ; i := 0 ; while i < n do ( (         var x : int ; x := 0 ; while x < t do ( (     best := Set{best, score[x+1] + fud[i+1].b}->max() )  ;     x := x + 1 ) ; 
     var scorenew : Sequence(long) ; scorenew := Integer.subrange(1,t)->collect(0) ;
         var x : int ; x := 0 ; while x < t do ( (     if (x + fud[i+1].a < t) then (     scorenew[x + fud[i+1].a+1] := Set{score[x + fud[i+1].a+1], score[x+1] + fud[i+1].b}->max() ) else skip )  ;     x := x + 1 ) ; 
         var x : int ; x := 0 ; while x < t do (     score[x+1] := Set{score[x+1], scorenew[x+1]}->max() ;  ;     x := x + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(best) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.lang.reflect.Array ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=scan.nextInt();
    int T=scan.nextInt();
    int[] time=new int[6001];
    List<Pair>list=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      Pair p=new Pair(scan.nextInt(),scan.nextInt());
      list.add(p);
    }
    list.sort(new PairComparator());
    Arrays.fill(time,Integer.MIN_VALUE);
    time[0]=0 ;
    for(int i=0 ; i<N ; i++){
      int[] next_time=Arrays.copyOfRange(time,0,time.length);
      Pair p=list.get(i);
      for(int j=0 ; j<T ; j++){
        if(time[j]==Integer.MIN_VALUE){
          continue ;
        }
        next_time[j+p.A]=Math.max(next_time[j+p.A],time[j]+p.B);
      }
      time=next_time ;
    }
    int ans=0 ;
    for(int i=0 ; i<6001 ; i++){
      ans=Math.max(ans,time[i]);
    }
    System.out.println(ans);
  }
  class Pair {
    int A ;
    int B ;
    Pair(int A,int B){
      this.A=A ;
      this.B=B ;
    }
  }
  class PairComparator implements Comparator<Pair>{
    @ Override public int compare(Pair o1,Pair o2){
      if(o1.A!=o2.A){
        return Integer.compare(o1.A,o2.A);
      }
      return Integer.compare(o1.B,o2.B);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var T : int ; T := scan.getCurrent()->toInteger() ;
    var time : Sequence(int) ; time := Integer.subrange(1,6001)->collect(0) ;
    var list : Sequence(Map) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var p : Map ; p := Map(scan.getCurrent()->toInteger(), scan.getCurrent()->toInteger()) ;
     list := list->including(p) )  ;     i := i + 1 ) ; 
    list := list.sort(PairComparator.newPairComparator()) ; 
    time := time->collect(-2147483648) ; 
    time[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < N do ( (     var next_time : Sequence(int) ; next_time := time.subrange(0+1,time->size()) ;
     var p : Map ; p := list->at(i+1) ;
         var j : int ; j := 0 ; while j < T do ( (     if (time[j+1] = -2147483648) then (     continue ) else skip ; 
     next_time[j + p.A+1] := Set{next_time[j + p.A+1], time[j+1] + p.B}->max() )  ;     j := j + 1 ) ; 
     time := next_time )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 6001 do ( (     ans := Set{ans, time[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
 class Pair {
   attribute A : int;
   attribute B : int;
   static operation newPair( A : int, B : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(A, B);
    return self );
  operation initialise( A : int, B : int) : void
  pre: true  post: true
  activity: (     self.A := A ; 
     self.B := B );
}
 class PairComparator implements Function(<Map>,(<Map>,boolean)) {
      operation compare( o1 : Map, o2 : Map) : int
  pre: true
  post: true
  activity: (     if (o1.A /= o2.A) then (     return compare(o1.A, o2.A) ) else skip ; 
     return compare(o1.B, o2.B) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MUHandSticks {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    byte sticks[]=new byte[9];
    for(byte i=0 ; i<6 ; i++)sticks[s.nextInt()-1]++;
    boolean legs=false,headbody=false ;
    for(byte i=0 ; i<9 ; i++){
      if(sticks[i]>=4)legs=true ;
      if(sticks[i]>=6)headbody=true ;
      if(sticks[i]==2)headbody=true ;
    }
    if(legs && headbody)System.out.println("Elephant");
    else if(legs)System.out.println("Bear");
    else System.out.println("Alien");
  }
}
------------------------------------------------------------
OCL File:
---------
 class MUHandSticks {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sticks : Sequence(int) ; sticks := Integer.subrange(1,9)->collect(0) ;
        var i : int ; i := 0 ; while i < 6 do (     sticks[s.getCurrent()->toInteger() - 1+1] := sticks[s.getCurrent()->toInteger() - 1+1] + 1 ;  ;     i := i + 1 ) ; 
    var legs : boolean ; legs := false ;
    var headbody : boolean ; headbody := false ;
        var i : int ; i := 0 ; while i < 9 do ( (     if (sticks[i+1] >= 4) then     legs := true ; else skip ; 
     if (sticks[i+1] >= 6) then     headbody := true ; else skip ; 
     if (sticks[i+1] = 2) then     headbody := true ; else skip )  ;     i := i + 1 ) ; 
    if (legs & headbody) then     OclFile["System.out"].println("Elephant") else     if (legs) then     OclFile["System.out"].println("Bear") else     OclFile["System.out"].println("Alien") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class floor {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    List<Integer>a=new ArrayList<>();
    int m=0,i,c ;
    boolean f=false ;
    for(i=0 ; i<6 ; i++)a.add(sc.nextInt());
    Set<Integer>set=new HashSet<>();
    for(i=0 ; i<6 ; i++)set.add(a.get(i));
    if(set.size()>3){
      System.out.println("Alien");
      System.exit(0);
    }
    for(Integer j : set){
      c=0 ;
      for(i=0 ; i<6 ; i++){
        if(j==a.get(i))c++;
      }
      if(c>=4){
        f=true ;
        m=j ;
        break ;
      }
    }
    if(! f){
      System.out.println("Alien");
      System.exit(0);
    }
    for(i=1 ; i<=4 ; i++)a.remove(a.indexOf(m));
    if(a.get(0)==a.get(1))System.out.println("Elephant");
    else System.out.println("Bear");
  }
}
------------------------------------------------------------
OCL File:
---------
 class floor {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Sequence{} ;
    var m : int ; m := 0 ;
    var i : int ;
    var c : int ;
    var f : boolean ; f := false ;
        i := 0 ; while i < 6 do (     a := a->including(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
        i := 0 ; while i < 6 do (     set := set->including(a->at(i+1)) ;  ;     i := i + 1 ) ; 
    if (set->size() > 3) then (     OclFile["System.out"].println("Alien") ; 
 OclProcess.exit(0) ) else skip ; 
    for (j : set) do ( (     c := 0 ; 
         i := 0 ; while i < 6 do ( (     if (j = a->at(i+1)) then     c := c + 1 ; else skip )  ;     i := i + 1 ) ; 
     if (c >= 4) then (     f := true ; 
     m := j ; 
     break ) else skip )  ) ; 
    if (not(f)) then (     OclFile["System.out"].println("Alien") ; 
 OclProcess.exit(0) ) else skip ; 
        i := 1 ; while i <= 4 do (     a := a->excludingFirst(a->indexOf(m)-1) ;  ;     i := i + 1 ) ; 
    if (a->at(0+1) = a->at(1+1)) then     OclFile["System.out"].println("Elephant") else     OclFile["System.out"].println("Bear") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
import java.io.*;
public class A_MUH_and_Sticks {
  public static void main(String[] arg){
    Scanner s=new Scanner(System.in);
    int arr[]=new int[6];
    int freq[]=new int[10];
    for(int i=0 ; i<6 ; i++){
      arr[i]=s.nextInt();
      freq[arr[i] ]++;
    }
    int flag=0 ;
    HashMap<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<6 ; i++){
      if(map.containsKey(arr[i])){
        map.put(arr[i],map.get(arr[i])+1);
        if(map.get(arr[i])==4){
          flag=1 ;
          map.remove(arr[i]);
        }
      }
      else {
        map.put(arr[i],1);
      }
    }
    if(flag==1){
      if(map.size()==1){
        System.out.println("Elephant");
      }
      else {
        System.out.println("Bear");
      }
    }
    else {
      System.out.println("Alien");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_MUH_and_Sticks {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,6)->collect(0) ;
    var freq : Sequence(int) ; freq := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < 6 do ( (     arr[i+1] := s.getCurrent()->toInteger() ; 
     freq[arr[i+1]+1] := freq[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var flag : int ; flag := 0 ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < 6 do ( (     if (map->keys()->includes(arr[i+1])) then (     map := map->union(Map{arr[i+1] |-> map->at(arr[i+1]) + 1}) ; 
     if (map->at(arr[i+1]) = 4) then (     flag := 1 ; 
     map := map->antirestrict(Set{arr[i+1]}) ) else skip ) else (     map := map->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    if (flag = 1) then (     if (map.size() = 1) then (     OclFile["System.out"].println("Elephant") ) else (     OclFile["System.out"].println("Bear") ) ) else (     OclFile["System.out"].println("Alien") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class WriteNow {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    long n=Long.parseLong(scan.next());
    long k=Long.parseLong(scan.next());
    System.out.println((k+n-1)/n);
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class WriteNow {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := (scan.getCurrent())->toLong() ;
    var k : long ; k := (scan.getCurrent())->toLong() ;
    OclFile["System.out"].println((k + n - 1) / n) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p401 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p401().run());
  }
  private static final long LIMIT=1000000000000000L ;
  private static final long MODULUS=Library.pow(10,9);
  public String run(){
    int splitCount=(int)Library.sqrt(LIMIT);
    splitCount=Math.max(splitCount/3,1);
    int splitAt=(int)(LIMIT/(splitCount+1));
    long sum=0 ;
    for(int i=1 ; i<=splitAt ; i++){
      long count=LIMIT/i % MODULUS ;
      long term=(long)i*i % MODULUS ;
      term=term*count % MODULUS ;
      sum=(sum+term)% MODULUS ;
    }
    for(int i=splitCount ; i>=1 ; i--){
      long start=LIMIT/(i+1);
      long end=LIMIT/i ;
      long sumSquares=sumSquaresMod(end)-sumSquaresMod(start);
      sumSquares=(sumSquares+MODULUS)% MODULUS ;
      sum=(sum+i*sumSquares % MODULUS)% MODULUS ;
    }
    return Long.toString(sum);
  }
  private static final BigInteger MODULUS_BI=BigInteger.valueOf(MODULUS);
  private static final BigInteger SIX_BI=BigInteger.valueOf(6);
  private static long sumSquaresMod(long n){
    BigInteger x=BigInteger.valueOf(n);
    BigInteger y=x.multiply(x.add(BigInteger.ONE));
    y=y.multiply(x.shiftLeft(1).add(BigInteger.ONE));
    y=y.divide(SIX_BI);
    y=y.mod(MODULUS_BI);
    return y.longValue();
  }
}
------------------------------------------------------------
OCL File:
---------
 class p401 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p401.newp401().run()) );
  static    attribute LIMIT : long := 1000000000000000L;
  static    attribute MODULUS : long := Library.pow(10, 9);
   operation run() : String
  pre: true
  post: true
  activity: (     var splitCount : int ; splitCount := Library.sqrt(LIMIT)->oclAsType(int) ;
     splitCount := Set{splitCount / 3, 1}->max() ; 
    var splitAt : int ; splitAt := (LIMIT / (splitCount + 1))->oclAsType(int) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 1 ; while i <= splitAt do ( (     var count : long ; count := LIMIT / i mod MODULUS ;
     var term : long ; term := i->oclAsType(long) * i mod MODULUS ;
     term := term * count mod MODULUS ; 
     sum := (sum + term) mod MODULUS )  ;     i := i + 1 ) ; 
        var i : int ; i := splitCount ; while i >= 1 do ( (     var start : long ; start := LIMIT / (i + 1) ;
     var end : long ; end := LIMIT / i ;
    var sumSquares : long ; sumSquares := sumSquaresMod(end) - sumSquaresMod(start) ;
    sumSquares := (sumSquares + MODULUS) mod MODULUS ; 
    sum := (sum + i * sumSquares mod MODULUS) mod MODULUS ; 
 )  ;     i := i - 1 ) ; 
    return ((sum) + "") 
 );
  static    attribute MODULUS_BI : long := (MODULUS + "")->toLong();
  static    attribute SIX_BI : long := (6 + "")->toLong();
  static   operation sumSquaresMod( n : long) : long
  pre: true
  post: true
  activity: (     var x : long ; x := (n + "")->toLong() ;
     var y : long ; y := x.multiply(x->excludes(1)) ;
    y := y.multiply(x.shiftLeft(1)->excludes(1)) ; 
    y := y.divide(SIX_BI) ; 
    y := y.mod(MODULUS_BI) ; 
    return y->oclAsType(long) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Node {
    int data ;
    Node prev,next ;
  };
  static Node push(Node head_ref,int new_data){
    Node new_node=new Node();
    new_node.data=new_data ;
    new_node.prev=null ;
    new_node.next=(head_ref);
    if((head_ref)!=null)(head_ref).prev=new_node ;
(head_ref)=new_node ;
    return head_ref ;
  }
  static Node makeOddNode(Node head_ref,int A[],int n){
    Node ptr=head_ref ;
    Node next ;
    int i=0 ;
    while(ptr!=null){
      next=ptr.next ;
      if(ptr.data % 2==0){
        ptr.data=A[i];
        i++;
      }
      ptr=next ;
    }
    return head_ref ;
  }
  static void printList(Node head){
    while(head!=null){
      System.out.print(head.data+" ");
      head=head.next ;
    }
  }
  public static void main(String args[]){
    Node head=null ;
    int Arr[]={
      3,5,23,17,1 };
      head=push(head,4);
      head=push(head,7);
      head=push(head,8);
      head=push(head,9);
      head=push(head,6);
      int n=Arr.length ;
      System.out.print("Original List: ");
      printList(head);
      System.out.println();
      head=makeOddNode(head,Arr,n);
      System.out.print("New odd List: ");
      printList(head);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute prev : Node;
}
  static   operation push( head_ref : Node, new_data : int) : Node
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode() ;
     new_node.data := new_data ; 
    new_node.prev := null ; 
    new_node.next := (head_ref) ; 
    if ((head_ref) /= null) then     (head_ref).prev := new_node ; else skip ; 
    (head_ref) := new_node ; 
    return head_ref 
 );
  static   operation makeOddNode( head_ref : Node, A : Sequence(int), n : int) : Node
  pre: true
  post: true
  activity: (     var ptr : Node ; ptr := head_ref ;
     var next : Node ;
    var i : int ; i := 0 ;
    while (ptr /= null) do (     next := ptr.next ; 
     if (ptr.data mod 2 = 0) then (     ptr.data := A[i+1] ; 
     i := i + 1 ) else skip ; 
     ptr := next ) ; 
    return head_ref 
 );
  static   operation printList( head : Node) : void
  pre: true
  post: true
  activity: (     while (head /= null) do (     OclFile["System.out"].print(head.data + " ") ; 
     head := head.next ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := null ;
     var Arr : Sequence(int) ; Arr := Sequence{3,5,23,17,1} ;
    head := push(head, 4) ; 
    head := push(head, 7) ; 
    head := push(head, 8) ; 
    head := push(head, 9) ; 
    head := push(head, 6) ; 
    var n : int ; n := Arr->size() ;
    OclFile["System.out"].print("Original List: ") ; 
    execute printList(head) ; 
    OclFile["System.out"].println() ; 
    head := makeOddNode(head, Arr, n) ; 
    OclFile["System.out"].print("New odd List: ") ; 
    execute printList(head) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Immobile {
  public static void main(String[] args){
    Scanner o=new Scanner(System.in);
    int t=o.nextInt();
    while(t-->0){
      int n=o.nextInt(),m=o.nextInt();
      if(n==1 || m==1)System.out.println("1 1");
      else System.out.println("2 2");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Immobile {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : OclFile ; o := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := o.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := o.getCurrent()->toInteger() ;
    var m : int ; m := o.getCurrent()->toInteger() ;
     if (n = 1 or m = 1) then     OclFile["System.out"].println("1 1") ; else     OclFile["System.out"].println("2 2") ; ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.util.TreeMap ;
public class A {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt(),m=sc.nextInt();
      out.println(((n+1)/2)+" "+((m+2)/2));
    }
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public boolean hasNext(){
      return st.hasMoreTokens();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
     skip ) ;  ) ;  
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return st.hasNext() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
import static java.lang.Math.*;
public class abc {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    while(t-->0){
      String s[]=br.readLine().split("\\ ");
      double n=Integer.parseInt(s[0]);
      double m=Integer.parseInt(s[1]);
      System.out.println((int)Math.ceil(n/2)+" "+(int)Math.ceil(m/2));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class abc {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : Sequence(String) ; s := br.readLine()->split("\\ ") ;
     var n : double ; n := (s[0+1])->toInteger() ;
     var m : double ; m := (s[1+1])->toInteger() ;
     OclFile["System.out"].println((n / 2)->ceil()->oclAsType(int) + " " + (m / 2)->ceil()->oclAsType(int)) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n>0){
      int u=sc.nextInt();
      int m=sc.nextInt();
      int uu=u-1 ;
      int mm=m-1 ;
      boolean done=false ;
      int[][] arr=new int[u][m];
      for(int i=0 ; i<arr.length && done==false ; i++){
        for(int j=0 ; j<arr[i] .length ; j++){
          boolean ur=false ;
          boolean ul=false ;
          boolean dr=false ;
          boolean dl=false ;
          boolean lu=false ;
          boolean ld=false ;
          boolean ru=false ;
          boolean rd=false ;
          if(i+2<=uu){
            if(j+1<=mm){
              ur=! false ;
            }
            if(j-1>=0){
              ul=! false ;
            }
          }
          if(i-2>=0){
            if(j+1<=mm){
              dr=! false ;
            }
            if(j-1>=0){
              dl=! false ;
            }
          }
          if(j+2<=mm){
            if(i+1<=uu){
              ru=! false ;
            }
            if(i-1>=0){
              rd=! false ;
            }
          }
          if(j-2>=0){
            if(i+1<=uu){
              lu=! false ;
            }
            if(i-1>=0){
              ld=! false ;
            }
          }
          if((ul || ur || dl || dr || ru || rd || lu || ld)==false){
            System.out.println((i+1)+" "+(j+1));
            done=true ;
            break ;
          }
        }
      }
      if(! done)System.out.println((1+" "+1));
      n=n-1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     while (n > 0) do (     var u : int ; u := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var uu : int ; uu := u - 1 ;
    var mm : int ; mm := m - 1 ;
    var done : boolean ; done := false ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,u)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < arr->size() & done = false do ( (         var j : int ; j := 0 ; while j < arr[i+1]->size() do ( (     var ur : boolean ; ur := false ;
     var ul : boolean ; ul := false ;
    var dr : boolean ; dr := false ;
    var dl : boolean ; dl := false ;
    var lu : boolean ; lu := false ;
    var ld : boolean ; ld := false ;
    var ru : boolean ; ru := false ;
    var rd : boolean ; rd := false ;
    if (i + 2 <= uu) then (     if (j + 1 <= mm) then (     ur := not(false) ) else skip ; 
     if (j - 1 >= 0) then (     ul := not(false) ) else skip ) else skip ; 
    if (i - 2 >= 0) then (     if (j + 1 <= mm) then (     dr := not(false) ) else skip ; 
     if (j - 1 >= 0) then (     dl := not(false) ) else skip ) else skip ; 
    if (j + 2 <= mm) then (     if (i + 1 <= uu) then (     ru := not(false) ) else skip ; 
     if (i - 1 >= 0) then (     rd := not(false) ) else skip ) else skip ; 
    if (j - 2 >= 0) then (     if (i + 1 <= uu) then (     lu := not(false) ) else skip ; 
     if (i - 1 >= 0) then (     ld := not(false) ) else skip ) else skip ; 
    if ((ul or ur or dl or dr or ru or rd or lu or ld) = false) then (     OclFile["System.out"].println((i + 1) + " " + (j + 1)) ; 
     done := true ; 
     break ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (not(done)) then     OclFile["System.out"].println((1 + " " + 1)) ; else skip ; 
    n := n - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Map.Entry ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    for(int i=0 ; i<t ; i++){
      StringTokenizer st=new StringTokenizer(br.readLine());
      int n=Integer.parseInt(st.nextToken());
      int m=Integer.parseInt(st.nextToken());
      if(n==1 || m==1)pw.println(1+" "+1);
      else if(n==3 || m==3)pw.println(2+" "+2);
      else pw.println(1+" "+1);
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < t do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var n : int ; n := (st.next())->toInteger() ;
     var m : int ; m := (st.next())->toInteger() ;
     if (n = 1 or m = 1) then     skip ; else     if (n = 3 or m = 3) then     skip else     skip ; ;  )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CodeForces1389B {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=input.nextInt();
      int k=input.nextInt();
      int z=input.nextInt();
      int[] a=new int[n];
      for(int j=0 ; j<n ; j++){
        a[j]=input.nextInt();
      }
      int res=0 ;
      for(int zz=0 ; zz<=z ; zz++){
        int dist=k-2*zz ;
        if(dist<0){
          break ;
        }
        int max=0,score=0 ;
        for(int j=0 ; j<=dist ; j++){
          if(j<n-1){
            max=Math.max(max,a[j]+a[j+1]);
          }
          score+=a[j];
        }
        res=Math.max(res,score+max*zz);
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces1389B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var k : int ; k := input.getCurrent()->toInteger() ;
    var z : int ; z := input.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     a[j+1] := input.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    var res : int ; res := 0 ;
        var zz : int ; zz := 0 ; while zz <= z do ( (     var dist : int ; dist := k - 2 * zz ;
     if (dist < 0) then (     break ) else skip ; 
    var max : int ; max := 0 ;
    var score : int ; score := 0 ;
        var j : int ; j := 0 ; while j <= dist do ( (     if (j < n - 1) then (     max := Set{max, a[j+1] + a[j + 1+1]}->max() ) else skip ; 
     score := score+(a[j+1]) )  ;     j := j + 1 ) ; 
    res := Set{res, score + max * zz}->max() ; 
 )  ;     zz := zz + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.Math ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int len=scan.nextInt();
    int a[]=new int[len];
    int l=0 ;
    int r=0 ;
    boolean flag=false ;
    boolean isTrue=false ;
    for(int i=0 ; i<len ; i++){
      a[i]=scan.nextInt();
      if(a[i]!=i+1 && ! flag){
        l=i+1 ;
        flag=true ;
        continue ;
      }
      if(a[i]!=i+1 && flag){
        r=i+1 ;
        if((a[r-1]-a[r-2]>0))isTrue=true ;
      }
    }
    System.out.println((! isTrue)? l+" "+r : "0"+" "+"0");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,len)->collect(0) ;
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    var flag : boolean ; flag := false ;
    var isTrue : boolean ; isTrue := false ;
        var i : int ; i := 0 ; while i < len do ( (     a[i+1] := scan.getCurrent()->toInteger() ; 
     if (a[i+1] /= i + 1 & not(flag)) then (     l := i + 1 ; 
     flag := true ; 
     continue ) else skip ; 
     if (a[i+1] /= i + 1 & flag) then (     r := i + 1 ; 
     if ((a[r - 1+1] - a[r - 2+1] > 0)) then     isTrue := true ; else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if (not(isTrue)) then l + " " + r else "0" + " " + "0" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.Math ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int len=scan.nextInt();
    int a[]=new int[len];
    int l=0 ;
    int r=0 ;
    boolean flag=false ;
    boolean isTrue=false ;
    for(int i=0 ; i<len ; i++){
      a[i]=scan.nextInt();
      if(a[i]!=i+1 && ! flag){
        l=i+1 ;
        flag=true ;
        continue ;
      }
      if(a[i]!=i+1 && flag){
        r=i+1 ;
        if((a[r-1]-a[r-2]>0))isTrue=true ;
      }
    }
    System.out.println((! isTrue)? l+" "+r : "0"+" "+"0");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,len)->collect(0) ;
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    var flag : boolean ; flag := false ;
    var isTrue : boolean ; isTrue := false ;
        var i : int ; i := 0 ; while i < len do ( (     a[i+1] := scan.getCurrent()->toInteger() ; 
     if (a[i+1] /= i + 1 & not(flag)) then (     l := i + 1 ; 
     flag := true ; 
     continue ) else skip ; 
     if (a[i+1] /= i + 1 & flag) then (     r := i + 1 ; 
     if ((a[r - 1+1] - a[r - 2+1] > 0)) then     isTrue := true ; else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if (not(isTrue)) then l + " " + r else "0" + " " + "0" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.Math ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int len=scan.nextInt();
    int a[]=new int[len];
    for(int i=0 ; i<len ; i++){
      a[i]=scan.nextInt();
    }
    int l=0 ;
    int r=0 ;
    boolean flag=false ;
    boolean isTrue=false ;
    loop : for(int i=0 ;
    i<len ;
    i++){
      if(a[i]!=i+1 && ! flag){
        l=i+1 ;
        flag=true ;
        continue ;
      }
      if(a[i]!=i+1 && flag){
        r=i+1 ;
        if((a[r-1]-a[r-2]>0)){
          isTrue=true ;
          break loop ;
        }
      }
    }
    System.out.println((! isTrue)? l+" "+r : "0"+" "+"0");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,len)->collect(0) ;
        var i : int ; i := 0 ; while i < len do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    var flag : boolean ; flag := false ;
    var isTrue : boolean ; isTrue := false ;
        var i : int ; i := 0 ; while i < len do ( (     if (a[i+1] /= i + 1 & not(flag)) then (     l := i + 1 ; 
     flag := true ; 
     continue ) else skip ; 
     if (a[i+1] /= i + 1 & flag) then (     r := i + 1 ; 
     if ((a[r - 1+1] - a[r - 2+1] > 0)) then (     isTrue := true ; 
     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if (not(isTrue)) then l + " " + r else "0" + " " + "0" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem1036A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long k=sc.nextLong();
    System.out.println((n+k-1)/n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem1036A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
     var k : long ; k := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println((n + k - 1) / n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    int[][] dp=new int[11][331];
    boolean[] use=new boolean[10];
    dfs(1,0,dp,use);
    while((line=br.readLine())!=null){
      String[] values=line.split(" ");
      int n=Integer.parseInt(values[0]);
      int s=Integer.parseInt(values[1]);
      if(n>10 || s>330){
        System.out.println("0");
        continue ;
      }
      System.out.println(dp[n][s]);
    }
  }
  private static void dfs(int depth,int sum,int[][] dp,boolean[] use){
    dp[depth-1][sum]++;
    for(int i=0 ; i<=9 ; i++){
      if(! use[i]){
        use[i]=true ;
        dfs(depth+1,sum+depth*i,dp,use);
        use[i]=false ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,11)->collect(Integer.subrange(1,331)->collect(0)) ;
    var use : Sequence(boolean) ; use := Integer.subrange(1,10)->collect(false) ;
    execute dfs(1, 0, dp, use) ; 
        line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     var values : Sequence(String) ; values := line->split(" ") ;
     var n : int ; n := (values[0+1])->toInteger() ;
    var s : int ; s := (values[1+1])->toInteger() ;
    if (n > 10 or s > 330) then (     OclFile["System.out"].println("0") ; 
     continue ) else skip ; 
    OclFile["System.out"].println(dp[n+1][s+1]) ; 
 ) ;     line := br.readLine() ;
 ) ;  
 );
  static   operation dfs( depth : int, sum : int, dp : Sequence(Sequence(int)), use : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (     dp[depth - 1+1][sum+1] := dp[depth - 1+1][sum+1] + 1 ; 
         var i : int ; i := 0 ; while i <= 9 do ( (     if (not(use[i+1])) then (     use[i+1] := true ; 
     execute dfs(depth + 1, sum + depth * i, dp, use) ; 
     use[i+1] := false ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.Math ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int len=scan.nextInt();
    int a[]=new int[len];
    for(int i=0 ; i<len ; i++){
      a[i]=scan.nextInt();
    }
    int l=0 ;
    int r=0 ;
    boolean flag=false ;
    boolean isTrue=false ;
    for(int i=0 ; i<len ; i++){
      if(a[i]!=i+1 && ! flag){
        l=i+1 ;
        flag=true ;
        continue ;
      }
      if(a[i]!=i+1 && flag){
        r=i+1 ;
        if((a[r-1]-a[r-2]>0))isTrue=true ;
      }
    }
    System.out.println((! isTrue)? l+" "+r : "0"+" "+"0");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,len)->collect(0) ;
        var i : int ; i := 0 ; while i < len do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    var flag : boolean ; flag := false ;
    var isTrue : boolean ; isTrue := false ;
        var i : int ; i := 0 ; while i < len do ( (     if (a[i+1] /= i + 1 & not(flag)) then (     l := i + 1 ; 
     flag := true ; 
     continue ) else skip ; 
     if (a[i+1] /= i + 1 & flag) then (     r := i + 1 ; 
     if ((a[r - 1+1] - a[r - 2+1] > 0)) then     isTrue := true ; else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if (not(isTrue)) then l + " " + r else "0" + " " + "0" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[][][] b=new int[n][3][2];
    ;
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<3 ; j++)for(int k=0,h,m ; k<2 ; k++)b[i][j][k]=sc.nextInt()*60+sc.nextInt();
    int ans=0 ;
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)for(int k=0 ; k<n ; k++){
      int res=0 ;
      for(int p=0 ; p<n ; p++){
        if(b[p][0][0]<=b[i][0][1] && b[i][0][1]<=b[p][0][1] && b[p][1][0]<=b[j][1][1] && b[j][1][1]<=b[p][1][1] && b[p][2][0]<=b[k][2][1] && b[k][2][1]<=b[p][2][1])res++;
      }
      ans=Math.max(ans,res);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var b : Sequence(Sequence(Sequence(int))) ; b := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(Integer.subrange(1,2)->collect(0))) ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < 3 do (         var k : int ; k := 0 ;
    var h : int ;
    var m : int ; while k < 2 do (     b[i+1][j+1][k+1] := sc.getCurrent()->toInteger() * 60 + sc.getCurrent()->toInteger() ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (         var k : int ; k := 0 ; while k < n do ( (     var res : int ; res := 0 ;
         var p : int ; p := 0 ; while p < n do ( (     if (b[p+1][0+1][0+1] <= b[i+1][0+1][1+1] & b[i+1][0+1][1+1] <= b[p+1][0+1][1+1] & b[p+1][1+1][0+1] <= b[j+1][1+1][1+1] & b[j+1][1+1][1+1] <= b[p+1][1+1][1+1] & b[p+1][2+1][0+1] <= b[k+1][2+1][1+1] & b[k+1][2+1][1+1] <= b[p+1][2+1][1+1]) then     res := res + 1 ; else skip )  ;     p := p + 1 ) ; 
     ans := Set{ans, res}->max() )  ;     k := k + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[][][] periods=new int[n][3][2];
    int[][] check_point=new int[3][n];
    for(int i=0 ; i<n ; ++i){
      for(int j=0 ; j<3 ; ++j){
        for(int k=0 ; k<2 ; ++k){
          int h=sc.nextInt(),m=sc.nextInt();
          periods[i][j][k]=h*60+m ;
          if(k==1)check_point[j][i]=periods[i][j][k];
        }
      }
    }
    int max_n=0 ;
    for(int b : check_point[0]){
      for(int l : check_point[1]){
        for(int d : check_point[2]){
          int res=0 ;
          for(int i=0 ; i<n ; ++i){
            if(b>=periods[i][0][0] && b<=periods[i][0][1] && l>=periods[i][1][0] && l<=periods[i][1][1] && d>=periods[i][2][0] && d<=periods[i][2][1])++res ;
          }
          max_n=Math.max(max_n,res);
        }
      }
    }
    System.out.println(max_n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var periods : Sequence(Sequence(Sequence(int))) ; periods := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(Integer.subrange(1,2)->collect(0))) ;
    var check_point : Sequence(Sequence(int)) ; check_point := Integer.subrange(1,3)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 3 do ( (         var k : int ; k := 0 ; while k < 2 do ( (     var h : int ; h := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
     periods[i+1][j+1][k+1] := h * 60 + m ; 
     if (k = 1) then     check_point[j+1][i+1] := periods[i+1][j+1][k+1] ; else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max_n : int ; max_n := 0 ;
    for (b : check_point[0+1]) do ( (     for (l : check_point[1+1]) do ( (     for (d : check_point[2+1]) do ( (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (b >= periods[i+1][0+1][0+1] & b <= periods[i+1][0+1][1+1] & l >= periods[i+1][1+1][0+1] & l <= periods[i+1][1+1][1+1] & d >= periods[i+1][2+1][0+1] & d <= periods[i+1][2+1][1+1]) then     res := res + 1 ; else skip )  ;     i := i + 1 ) ; 
     max_n := Set{max_n, res}->max() )  ) )  ) )  ) ; 
    OclFile["System.out"].println(max_n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[][][] b=new int[n][3][2];
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<3 ; j++)for(int k=0 ; k<2 ; k++)b[i][j][k]=sc.nextInt()*60+sc.nextInt();
    int ans=0 ;
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)for(int k=0 ; k<n ; k++){
      int res=0 ;
      for(int p=0 ; p<n ; p++){
        if(b[p][0][0]<=b[i][0][0] && b[i][0][0]<=b[p][0][1] && b[p][1][0]<=b[j][1][0] && b[j][1][0]<=b[p][1][1] && b[p][2][0]<=b[k][2][0] && b[k][2][0]<=b[p][2][1])res++;
      }
      ans=Math.max(ans,res);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var b : Sequence(Sequence(Sequence(int))) ; b := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(Integer.subrange(1,2)->collect(0))) ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < 3 do (         var k : int ; k := 0 ; while k < 2 do (     b[i+1][j+1][k+1] := sc.getCurrent()->toInteger() * 60 + sc.getCurrent()->toInteger() ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (         var k : int ; k := 0 ; while k < n do ( (     var res : int ; res := 0 ;
         var p : int ; p := 0 ; while p < n do ( (     if (b[p+1][0+1][0+1] <= b[i+1][0+1][0+1] & b[i+1][0+1][0+1] <= b[p+1][0+1][1+1] & b[p+1][1+1][0+1] <= b[j+1][1+1][0+1] & b[j+1][1+1][0+1] <= b[p+1][1+1][1+1] & b[p+1][2+1][0+1] <= b[k+1][2+1][0+1] & b[k+1][2+1][0+1] <= b[p+1][2+1][1+1]) then     res := res + 1 ; else skip )  ;     p := p + 1 ) ; 
     ans := Set{ans, res}->max() )  ;     k := k + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new AOJ1159().doIt();
  }
  class AOJ1159 {
    int n,p ;
    void solve(){
      int[] person=new int[n];
      int wan=p ;
      int ban=0 ;
      int result=-1 ;
      while(true){
        if(wan==0){
          wan=person[ban];
          person[ban]=0 ;
        }
        else {
          wan--;
          person[ban]++;
        }
        if(person[ban]==p){
          result=ban ;
          break ;
        }
        ban=(ban+1)% n ;
      }
      System.out.println(result);
    }
    void doIt(){
      while(in.hasNext()){
        n=in.nextInt();
        p=in.nextInt();
        if(n+p==0)break ;
        solve();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     AOJ1159.newAOJ1159().doIt() );
 class AOJ1159 {
   attribute n : int;
   operation solve() : void
  pre: true
  post: true
  activity: (     var person : Sequence(int) ; person := Integer.subrange(1,n)->collect(0) ;
     var wan : int ; wan := p ;
    var ban : int ; ban := 0 ;
    var result : int ; result := -1 ;
    while (true) do (     if (wan = 0) then (     wan := person[ban+1] ; 
     person[ban+1] := 0 ) else (     wan := wan - 1 ; 
     person[ban+1] := person[ban+1] + 1 ) ;  
     if (person[ban+1] = p) then (     result := ban ; 
     break ) else skip ; 
     ban := (ban + 1) mod n ) ; 
    OclFile["System.out"].println(result) ; 
 );
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (in.hasNext()) do (     n := in.getCurrent()->toInteger() ; 
     p := in.getCurrent()->toInteger() ; 
     if (n + p = 0) then     break else skip ; 
     execute solve() ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
class Main {
  public static Scanner sc=new Scanner(in);
  public static Random rand=new Random();
  public void run(){
    while(true){
      int n=sc.nextInt(),p=sc.nextInt();
      if(n==0 && p==0)return ;
      int ind=0 ;
      int freestone=p ;
      int[] val=new int[n];
      while(val[ind]!=p){
        if(freestone==0){
          freestone=val[ind];
          val[ind]=0 ;
        }
        else {
          freestone--;
          val[ind]++;
        }
        ind=(ind+1)% n ;
      }
      ln(ind);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  public int[] nextIntArray(int n){
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=sc.nextInt();
    }
    return res ;
  }
  public static void pr(Object o){
    out.print(o);
  }
  public static void ln(Object o){
    out.println(o);
  }
  public static void ln(){
    out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(in);
  static   attribute rand : OclRandom := OclRandom.newOclRandom();
   operation run() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
     if (n = 0 & p = 0) then     return else skip ; 
    var ind : int ; ind := 0 ;
    var freestone : int ; freestone := p ;
    var val : Sequence(int) ; val := Integer.subrange(1,n)->collect(0) ;
    while (val[ind+1] /= p) do (     if (freestone = 0) then (     freestone := val[ind+1] ; 
     val[ind+1] := 0 ) else (     freestone := freestone - 1 ; 
     val[ind+1] := val[ind+1] + 1 ) ;  
     ind := (ind + 1) mod n ) ; 
    execute ln(ind) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return res );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     out.println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileInputStream ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  static int n,p ;
  static void start(){
    int[] have=new int[n];
    for(int i=0 ; i<n ; i++)have[i]=0 ;
    int whoturn=0 ;
    int owan=p ;
    while(true){
      if(owan!=0){
        have[whoturn]++;
        owan--;
        if(have[whoturn]==p)break ;
      }
      else {
        owan=have[whoturn];
        have[whoturn]=0 ;
      }
      whoturn++;
      if(whoturn==n)whoturn=0 ;
    }
    System.out.println(whoturn);
  }
  public static void main(String[] args){
    Scanner sca=new Scanner(System.in);
    while(true){
      n=sca.nextInt();
      p=sca.nextInt();
      if(n==0)break ;
      start();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   operation start() : void
  pre: true
  post: true
  activity: (     var have : Sequence(int) ; have := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     have[i+1] := 0 ;  ;     i := i + 1 ) ; 
    var whoturn : int ; whoturn := 0 ;
    var owan : int ; owan := p ;
    while (true) do (     if (owan /= 0) then (     have[whoturn+1] := have[whoturn+1] + 1 ; 
     owan := owan - 1 ; 
     if (have[whoturn+1] = p) then     break else skip ) else (     owan := have[whoturn+1] ; 
     have[whoturn+1] := 0 ) ;  
     whoturn := whoturn + 1 ; 
     if (whoturn = n) then     whoturn := 0 ; else skip ) ; 
    OclFile["System.out"].println(whoturn) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sca : OclFile ; sca := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     n := sca.getCurrent()->toInteger() ; 
     p := sca.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
     execute start() ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] arr=new int[n];
    int sum=0 ;
    int sum1=0 ;
    int arr1[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
      sum+=arr[i];
    }
    for(int i=0 ; i<n ; i++){
      arr1[i]=in.nextInt();
      sum1+=arr1[i];
    }
    if(sum>=sum1){
      System.out.println("YES");
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
    var sum1 : int ; sum1 := 0 ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr1[i+1] := in.getCurrent()->toInteger() ; 
     sum1 := sum1+(arr1[i+1]) )  ;     i := i + 1 ) ; 
    if (sum >= sum1) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A_Function_Height {
  static FastReader sc ;
  static void solve(){
    StringBuilder res=new StringBuilder();
    long n=sc.nextLong(),k=sc.nextLong();
    print((k+n-1)/n);
  }
  public static void main(String args[])throws IOException {
    sc=new FastReader();
    int tt=1 ;
    while(tt-->0){
      solve();
    }
  }
  static<E>void print(E res){
    System.out.println(res);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
    int[] readintarray(int n){
      int res[]=new int[n];
      for(int i=0 ; i<n ; i++)res[i]=nextInt();
      return res ;
    }
    long[] readlongarray(int n){
      long res[]=new long[n];
      for(int i=0 ; i<n ; i++)res[i]=nextLong();
      return res ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Function_Height {
  static   attribute sc : FastReader;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var res : String ; res := StringLib.newString() ;
     var n : long ; n := sc.nextLong() ;
    var k : long ; k := sc.nextLong() ;
     execute print((k + n - 1) / n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := FastReader.newFastReader() ; 
     var tt : int ; tt := 1 ;
         while (tt > 0) do (        tt := tt - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation print<E>( res : E) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(res) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation readintarray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     res[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return res );
   operation readlongarray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     res[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return res );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    int n=sc.nextInt();
    int q=sc.nextInt();
    int[] a=new int[n];
    a[0]=sc.nextInt();
    for(int i=1 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    PrintWriter pw=new PrintWriter(System.out);
    for(int i=0 ; i<q ; i++){
      long x=sc.nextLong();
      long cnt=0 ;
      int right=0 ;
      long sum=0 ;
      for(int left=0 ; left<n ; left++){
        while(right<n && sum+a[right]<=x)sum+=a[right++];
        cnt+=right-left ;
        if(right==left)right++;
        else sum-=a[left];
      }
      pw.println(cnt);
    }
    pw.flush();
  }
  static class MyScanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),1<<15);
    StringTokenizer tokenizer ;
    String next(){
      try {
        while(tokenizer==null || ! tokenizer.hasMoreTokens()){
          tokenizer=new StringTokenizer(reader.readLine());
        }
      }
      catch(IOException ignored){
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var n : int ; n := sc.nextInt() ;
    var q : int ; q := sc.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    a[0+1] := sc.nextInt() ; 
        var i : int ; i := 1 ; while i < n do ( (     a[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
        var i : int ; i := 0 ; while i < q do ( (     var x : long ; x := sc.nextLong() ;
     var cnt : long ; cnt := 0 ;
    var right : int ; right := 0 ;
    var sum : long ; sum := 0 ;
        var left : int ; left := 0 ; while left < n do ( (     while (right < n & sum + a[right+1] <= x) do      sum := sum + a[right+1]  ; right := right + 1 ; ; 
     cnt := cnt+(right - left) ; 
     if (right = left) then     right := right + 1 ; else     sum := sum-(a[left+1]) ; )  ;     left := left + 1 ) ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class MyScanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (1*(2->pow(15)))->oclAsType(long));
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (ignored : IOException) do skip
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    new Main().mainrun();
  }
  private Scanner scan ;
  private int N,Q ;
  private long[] A ;
  private void mainrun(){
    scan=new Scanner(System.in);
    N=scan.nextInt();
    Q=scan.nextInt();
    A=new long[N+1];
    A[N]=0 ;
    for(int i=0 ; i<N ; i++){
      A[i]=scan.nextLong();
    }
    for(int i=0 ; i<Q ; i++){
      System.out.println(Calculation(scan.nextLong()));
    }
    scan.close();
  }
  private long Calculation(long border){
    long sum=0,cnt=0 ;
    int cursor_r=0,cursor_l=0 ;
    while(cursor_l<N){
      if(sum+A[cursor_r]<=border && cursor_r<N){
        sum+=A[cursor_r++];
      }
      else {
        cnt+=cursor_r-cursor_l ;
        sum-=A[cursor_l++];
      }
    }
    return cnt ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().mainrun() );
   attribute scan : OclFile;
   attribute N : int;
   attribute A : Sequence(long);
   operation mainrun() : void
  pre: true
  post: true
  activity: (     scan := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     N := scan.getCurrent()->toInteger() ; 
    Q := scan.getCurrent()->toInteger() ; 
    A := Integer.subrange(1,N + 1)->collect(0) ; 
    A[N+1] := 0 ; 
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := scan.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Q do ( (     OclFile["System.out"].println(Calculation(scan.getCurrent()->toLong())) )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation Calculation( border : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
    var cnt : long ; cnt := 0 ;
     var cursor_r : int ; cursor_r := 0 ;
    var cursor_l : int ; cursor_l := 0 ;
     while (cursor_l < N) do (     if (sum + A[cursor_r+1] <= border & cursor_r < N) then (      sum := sum + A[cursor_r+1]  ; cursor_r := cursor_r + 1 ) else (     cnt := cnt+(cursor_r - cursor_l) ; 
      sum := sum - (A[cursor_l+1])  ; cursor_l := cursor_l + 1 ) ) ; 
     return cnt );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scan=new Scanner(System.in)){
      int N=scan.nextInt();
      int Q=scan.nextInt();
      int[] a=new int[N];
      long[] s=new long[N+1];
      for(int i=0 ; i<N ; i++){
        a[i]=scan.nextInt();
        s[i+1]=s[i]+a[i];
      }
      long[] x=new long[Q];
      for(int i=0 ; i<Q ; i++)x[i]=scan.nextLong();
      for(int i=0 ; i<Q ; i++){
        long X=x[i];
        int right=0 ;
        long goukei=0 ;
        for(int left=0 ; left<N ; left++){
          while(right<N && s[right+1]-s[left]<=X){
            right++;
          }
          goukei+=(right-left);
        }
        System.out.println(goukei);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := scan.getCurrent()->toInteger() ;
     var Q : int ; Q := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var s : Sequence(long) ; s := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := scan.getCurrent()->toInteger() ; 
     s[i + 1+1] := s[i+1] + a[i+1] )  ;     i := i + 1 ) ; 
    var x : Sequence(long) ; x := Integer.subrange(1,Q)->collect(0) ;
        var i : int ; i := 0 ; while i < Q do (     x[i+1] := scan.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Q do ( (     var X : long ; X := x[i+1] ;
     var right : int ; right := 0 ;
    var goukei : long ; goukei := 0 ;
        var left : int ; left := 0 ; while left < N do ( (     while (right < N & s[right + 1+1] - s[left+1] <= X) do (     right := right + 1 ) ; 
     goukei := goukei+((right - left)) )  ;     left := left + 1 ) ; 
    OclFile["System.out"].println(goukei) ; 
 )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int q=sc.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
    }
    long[] x=new long[q];
    for(int i=0 ; i<q ; i++){
      x[i]=sc.nextLong();
    }
    long[] ans=new long[q];
    for(int i=0 ; i<q ; i++){
      ans[i]=syakutori(a,x[i],n);
    }
    for(int i=0 ; i<q ; i++){
      System.out.println(ans[i]);
    }
  }
  public static long syakutori(long[] a,long x,int n){
    int right=0 ;
    long res=0 ;
    long sum=0 ;
    for(int left=0 ; left<n ; left++){
      while(right<n && sum+a[right]<=x){
        sum+=a[right];
        right++;
      }
      res+=Math.max(0,right-left);
      sum-=a[left];
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var x : Sequence(long) ; x := Integer.subrange(1,q)->collect(0) ;
        var i : int ; i := 0 ; while i < q do ( (     x[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var ans : Sequence(long) ; ans := Integer.subrange(1,q)->collect(0) ;
        var i : int ; i := 0 ; while i < q do ( (     ans[i+1] := syakutori(a, x[i+1], n) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     OclFile["System.out"].println(ans[i+1]) )  ;     i := i + 1 ) ; 
 );
  static   operation syakutori( a : Sequence(long), x : long, n : int) : long
  pre: true
  post: true
  activity: (     var right : int ; right := 0 ;
     var res : long ; res := 0 ;
    var sum : long ; sum := 0 ;
        var left : int ; left := 0 ; while left < n do ( (     while (right < n & sum + a[right+1] <= x) do (     sum := sum+(a[right+1]) ; 
     right := right + 1 ) ; 
     res := res+(Set{0, right - left}->max()) ; 
     sum := sum-(a[left+1]) )  ;     left := left + 1 ) ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int Q=scan.nextInt();
    long[] a=new long[N];
    long[] x=new long[Q];
    for(int i=0 ; i<N ; i++){
      a[i]=scan.nextLong();
    }
    for(int i=0 ; i<Q ; i++){
      x[i]=scan.nextLong();
    }
    scan.close();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<Q ; i++){
      long cnt=0 ;
      long sum=0 ;
      int right=0 ;
      for(int left=0 ; left<N ; left++){
        while(right<N && sum+a[right]<=x[i]){
          sum+=a[right];
          right++;
        }
        cnt+=(right-left);
        if(left==right){
          right++;
        }
        else {
          sum-=a[left];
        }
      }
      sb.append(cnt).append("\n");
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var Q : int ; Q := scan.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,N)->collect(0) ;
    var x : Sequence(long) ; x := Integer.subrange(1,Q)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := scan.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Q do ( (     x[i+1] := scan.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    skip ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < Q do ( (     var cnt : long ; cnt := 0 ;
     var sum : long ; sum := 0 ;
    var right : int ; right := 0 ;
        var left : int ; left := 0 ; while left < N do ( (     while (right < N & sum + a[right+1] <= x[i+1]) do (     sum := sum+(a[right+1]) ; 
     right := right + 1 ) ; 
     cnt := cnt+((right - left)) ; 
     if (left = right) then (     right := right + 1 ) else (     sum := sum-(a[left+1]) ) )  ;     left := left + 1 ) ; 
    sb := sb + StringLib.newString(cnt) + StringLib.newString("\n") ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CodeForce_1409A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    int a=0,b=0 ;
    for(int i=0 ; i<t ; i++){
      a=scanner.nextInt();
      b=scanner.nextInt();
      int counter=0 ;
      if(a<b){
        counter=(b-a)/10 ;
      }
      else if(a>b){
        counter=(a-b)/10 ;
      }
      if(a % 10!=b % 10){
        counter++;
      }
      System.out.println(counter);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForce_1409A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
     var a : int ; a := 0 ;
    var b : int ; b := 0 ;
         var i : int ; i := 0 ; while i < t do ( (     a := scanner.getCurrent()->toInteger() ; 
     b := scanner.getCurrent()->toInteger() ; 
    var counter : int ; counter := 0 ;
    if (a < b) then (     counter := (b - a) / 10 ) else     if (a > b) then (     counter := (a - b) / 10 ) else skip ; ;  
    if (a mod 10 /= b mod 10) then (     counter := counter + 1 ) else skip ; 
    OclFile["System.out"].println(counter) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class YetAnotherTwoIntegersProblem {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int numTestCases=in.nextInt();
    while(numTestCases-->0){
      int num1=in.nextInt();
      int num2=in.nextInt();
      int total=Math.abs(num2-num1);
      int ans=total/10 ;
      if(total % 10!=0)ans++;
      out.append(ans+"\n");
    }
    out.flush();
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new FileReader("sub.in"));
      }
      catch(FileNotFoundException ex){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException ex){
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException ex){
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class YetAnotherTwoIntegersProblem {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var numTestCases : int ; numTestCases := in.nextInt() ;
        while (numTestCases > 0) do (        numTestCases := numTestCases - 1 ;     skip ; (     var num1 : int ; num1 := in.nextInt() ;
     var num2 : int ; num2 := in.nextInt() ;
    var total : int ; total := if num2 - num1 < 0 then -(num2 - num1) else num2 - num1 endif ;
    var ans : int ; ans := total / 10 ;
    if (total mod 10 /= 0) then     ans := ans + 1 ; else skip ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("sub.in"))) )   catch (ex : FileNotFoundException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (ex : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (ex : IOException) do skip
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int cases=scan.nextInt();
    for(int i=0 ; i<cases ; i++){
      int a=scan.nextInt();
      int b=scan.nextInt();
      int diff=Math.abs(a-b);
      int result=(int)Math.ceil(diff/10.0);
      System.out.println(result);
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cases : int ; cases := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < cases do ( (     var a : int ; a := scan.getCurrent()->toInteger() ;
     var b : int ; b := scan.getCurrent()->toInteger() ;
    var diff : int ; diff := if a - b < 0 then -(a - b) else a - b endif ;
    var result : int ; result := (diff / 10.0)->ceil()->oclAsType(int) ;
    OclFile["System.out"].println(result) ; 
 )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class B {
  public static void main(String[] args)throws Exception {
    String path="D:\\B-large" ;
    Scanner sc=new Scanner(new File(path+".in"));
    PrintWriter pw=new PrintWriter(path+".out");
    int testCases=sc.nextInt();
    for(int testCase=1 ; testCase<=testCases ; testCase++){
      long E=sc.nextInt();
      long R=sc.nextInt();
      int n=sc.nextInt();
      long[] v=new long[n];
      for(int i=0 ; i<n ; i++){
        v[i]=sc.nextInt();
      }
      long res=0 ;
      long energy=E ;
      for(int i=0 ; i<n ; i++){
        long cur=energy ;
        for(int j=i+1 ; j<n ; j++){
          if(v[j]>v[i]){
            long d=j-i ;
            long regeneration=d*R ;
            long y=regeneration-(E-energy);
            cur=Math.min(y,energy);
            cur=Math.max(cur,0);
            break ;
          }
        }
        res+=cur*v[i];
        energy=Math.min(energy-cur+R,E);
      }
      pw.println("Case #"+testCase+": "+res);
      pw.flush();
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var path : String ; path := "D:\\B-large" ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile(path + ".in")) ;
    var pw : OclFile ; pw := OclFile.newOclFile_Write(path + ".out") ;
    var testCases : int ; testCases := sc.getCurrent()->toInteger() ;
        var testCase : int ; testCase := 1 ; while testCase <= testCases do ( (     var E : long ; E := sc.getCurrent()->toInteger() ;
     var R : long ; R := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var v : Sequence(long) ; v := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     v[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
    var energy : long ; energy := E ;
        var i : int ; i := 0 ; while i < n do ( (     var cur : long ; cur := energy ;
         var j : int ; j := i + 1 ; while j < n do ( (     if (v[j+1] > v[i+1]) then (     var d : long ; d := j - i ;
     var regeneration : long ; regeneration := d * R ;
    var y : long ; y := regeneration - (E - energy) ;
    cur := Set{y, energy}->min() ; 
    cur := Set{cur, 0}->max() ; 
    break 
 ) else skip )  ;     j := j + 1 ) ; 
     res := res+(cur * v[i+1]) ; 
     energy := Set{energy - cur + R, E}->min() )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 )  ;     testCase := testCase + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static int solve(int n,int s,boolean[] check){
    if(n>10){
      return 0 ;
    }
    if(s>n*(n+1)*(28-n)/3){
      return 0 ;
    }
    int a=s/n ;
    if(a>9){
      a=9 ;
    }
    if(n==1){
      if(s>9 || check[s]){
        return 0 ;
      }
      else {
        return 1 ;
      }
    }
    int count=0 ;
    for(int i=a ; i>=0 ; i--){
      if(check[i]){
        continue ;
      }
      check[i]=true ;
      count+=solve(n-1,s-i*n,check);
      check[i]=false ;
    }
    return count ;
  }
  public static void main(String[] args){
    Scanner stdIn=null ;
    List<Integer>result=new ArrayList<Integer>();
    try {
      stdIn=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
      while(stdIn.hasNext()){
        int n=stdIn.nextInt(),s=stdIn.nextInt();
        boolean[] check=new boolean[10];
        result.add(solve(n,s,check));
      }
      for(Integer sum : result){
        System.out.println(sum);
      }
    }
    finally {
      if(stdIn!=null){
        stdIn.close();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( n : int, s : int, check : Sequence(boolean)) : int
  pre: true
  post: true
  activity: (     if (n > 10) then (     return 0 ) else skip ; 
     if (s > n * (n + 1) * (28 - n) / 3) then (     return 0 ) else skip ; 
    var a : int ; a := s / n ;
    if (a > 9) then (     a := 9 ) else skip ; 
    if (n = 1) then (     if (s > 9 or check[s+1]) then (     return 0 ) else (     return 1 ) ) else skip ; 
    var count : int ; count := 0 ;
        var i : int ; i := a ; while i >= 0 do ( (     if (check[i+1]) then (     continue ) else skip ; 
     check[i+1] := true ; 
     count := count+(solve(n - 1, s - i * n, check)) ; 
     check[i+1] := false )  ;     i := i - 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := null ;
     var result : Sequence(int) ; result := Sequence{} ;
     try (     stdIn := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
     while (stdIn.hasNext()) do (     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var s : int ; s := stdIn.getCurrent()->toInteger() ;
     var check : Sequence(boolean) ; check := Integer.subrange(1,10)->collect(false) ;
     result := result->including(solve(n, s, check)) ) ; 
     for (sum : result) do ( (     OclFile["System.out"].println(sum) )  ) )   finally (     if (stdIn /= null) then (     skip ) else skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MyClass {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    while(t-->0){
      String s[]=br.readLine().split(" ");
      int a=Integer.parseInt(s[0]);
      int b=Integer.parseInt(s[1]);
      int diff=Math.abs(a-b);
      int ans=diff/10 ;
      if(diff % 10!=0)ans++;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
     var a : int ; a := (s[0+1])->toInteger() ;
    var b : int ; b := (s[1+1])->toInteger() ;
    var diff : int ; diff := if (a)->char2byte() - b < 0 then -((a)->char2byte() - b) else (a)->char2byte() - b endif ;
    var ans : int ; ans := diff / 10 ;
    if (diff mod 10 /= 0) then     ans := ans + 1 ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      int a=in.nextInt();
      int b=in.nextInt();
      int k=(Math.abs(a-b)+9)/10 ;
      System.out.println(k);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
     var k : int ; k := (if a - b < 0 then -(a - b) else a - b endif + 9) / 10 ;
     OclFile["System.out"].println(k) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
class GFG {
  static void findNthTerm(int n){
    if(n % 2==0){
      n=n/2 ;
      System.out.print(Math.pow(3,n-1)+"\n");
    }
    else {
      n=(n/2)+1 ;
      System.out.print(Math.pow(2,n-1)+"\n");
    }
  }
  public static void main(String[] args){
    int N=4 ;
    findNthTerm(N);
    N=11 ;
    findNthTerm(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNthTerm( n : int) : void
  pre: true
  post: true
  activity: (     if (n mod 2 = 0) then (     n := n / 2 ; 
     OclFile["System.out"].print(3->pow(n - 1) + "\n") ) else (     n := (n / 2) + 1 ; 
     OclFile["System.out"].print(2->pow(n - 1) + "\n") ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     execute findNthTerm(N) ; 
     N := 11 ; 
     execute findNthTerm(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1642 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      long[] X=new long[3];
      long[] Y=new long[3];
      for(int i=0 ; i<3 ; i++){
        X[i]=in.nextInt();
        Y[i]=in.nextInt();
      }
      long answer=0 ;
      for(int i=0 ; i<3 ; i++){
        if(Y[i]==Y[(i+1)% 3] && Y[i]>Y[(i+2)% 3]){
          answer+=Math.abs(X[(i+1)% 3]-X[i]);
        }
      }
      System.out.println(answer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1642 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var X : Sequence(long) ; X := Integer.subrange(1,3)->collect(0) ;
     var Y : Sequence(long) ; Y := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     X[i+1] := in.getCurrent()->toInteger() ; 
     Y[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var answer : long ; answer := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (Y[i+1] = Y[(i + 1) mod 3+1] & Y[i+1] > Y[(i + 2) mod 3+1]) then (     answer := answer+(if X[(i + 1) mod 3+1] - X[i+1] < 0 then -(X[(i + 1) mod 3+1] - X[i+1]) else X[(i + 1) mod 3+1] - X[i+1] endif) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static int find(int x1,int y1,int x2,int y2,int x3,int y3){
    if(y1==y2){
      if(y3>y1){
        return 0 ;
      }
      else {
        return Math.abs(x2-x1);
      }
    }
    else if(y2==y3){
      if(y1>y2){
        return 0 ;
      }
      else {
        return Math.abs(x2-x3);
      }
    }
    else if(y3==y1){
      if(y2>y3){
        return 0 ;
      }
      else {
        return Math.abs(x1-x3);
      }
    }
    else {
      return 0 ;
    }
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int x1=sc.nextInt();
      int y1=sc.nextInt();
      int x2=sc.nextInt();
      int y2=sc.nextInt();
      int x3=sc.nextInt();
      int y3=sc.nextInt();
      System.out.println(find(x1,y1,x2,y2,x3,y3));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation find( x1 : int, y1 : int, x2 : int, y2 : int, x3 : int, y3 : int) : int
  pre: true
  post: true
  activity: (     if (y1 = y2) then (     if (y3 > y1) then (     return 0 ) else (     return if x2 - x1 < 0 then -(x2 - x1) else x2 - x1 endif ) ) else     if (y2 = y3) then (     if (y1 > y2) then (     return 0 ) else (     return if x2 - x3 < 0 then -(x2 - x3) else x2 - x3 endif ) ) else     if (y3 = y1) then (     if (y2 > y3) then (     return 0 ) else (     return if x1 - x3 < 0 then -(x1 - x3) else x1 - x3 endif ) ) else (     return 0 ) ;  ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var x1 : int ; x1 := sc.getCurrent()->toInteger() ;
     var y1 : int ; y1 := sc.getCurrent()->toInteger() ;
    var x2 : int ; x2 := sc.getCurrent()->toInteger() ;
    var y2 : int ; y2 := sc.getCurrent()->toInteger() ;
    var x3 : int ; x3 := sc.getCurrent()->toInteger() ;
    var y3 : int ; y3 := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(find(x1, y1, x2, y2, x3, y3)) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf726 {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int t=scn.nextInt();
    while(t-->0){
      int x1=scn.nextInt();
      int y1=scn.nextInt();
      int x2=scn.nextInt();
      int y2=scn.nextInt();
      int x3=scn.nextInt();
      int y3=scn.nextInt();
      if(y1==y2 && y3<y1){
        System.out.println(Math.abs(x2-x1));
      }
      else if(y2==y3 && y1<y2){
        System.out.println(Math.abs(x2-x3));
      }
      else if(y3==y1 && y2<y1){
        System.out.println(Math.abs(x3-x1));
      }
      else {
        System.out.println("0");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf726 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scn.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x1 : int ; x1 := scn.getCurrent()->toInteger() ;
     var y1 : int ; y1 := scn.getCurrent()->toInteger() ;
    var x2 : int ; x2 := scn.getCurrent()->toInteger() ;
    var y2 : int ; y2 := scn.getCurrent()->toInteger() ;
    var x3 : int ; x3 := scn.getCurrent()->toInteger() ;
    var y3 : int ; y3 := scn.getCurrent()->toInteger() ;
    if (y1 = y2 & y3 < y1) then (     OclFile["System.out"].println(if x2 - x1 < 0 then -(x2 - x1) else x2 - x1 endif) ) else     if (y2 = y3 & y1 < y2) then (     OclFile["System.out"].println(if x2 - x3 < 0 then -(x2 - x3) else x2 - x3 endif) ) else     if (y3 = y1 & y2 < y1) then (     OclFile["System.out"].println(if x3 - x1 < 0 then -(x3 - x1) else x3 - x1 endif) ) else (     OclFile["System.out"].println("0") ) ;  ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPalindrome(String str){
    int len=str.length();
    for(int i=0 ; i<len/2 ; i++){
      if(str.charAt(i)!=str.charAt(len-1-i))return false ;
    }
    return true ;
  }
  static boolean createStringAndCheckPalindrome(int N){
    String sub=""+N,res_str="" ;
    int sum=0 ;
    while(N>0){
      int digit=N % 10 ;
      sum+=digit ;
      N=N/10 ;
    }
    while(res_str.length()<sum)res_str+=sub ;
    if(res_str.length()>sum)res_str=res_str.substring(0,sum);
    if(isPalindrome(res_str))return true ;
    return false ;
  }
  public static void main(String args[]){
    int N=10101 ;
    if(createStringAndCheckPalindrome(N))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPalindrome( str : String) : boolean
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
         var i : int ; i := 0 ; while i < len / 2 do ( (     if (str->at(i+1) /= str->at(len - 1 - i+1)) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation createStringAndCheckPalindrome( N : int) : boolean
  pre: true
  post: true
  activity: (     var sub : String ; sub := "" + N ;
    var res_str : String ; res_str := "" ;
     var sum : int ; sum := 0 ;
    while (N > 0) do (     var digit : int ; digit := N mod 10 ;
     sum := sum+(digit) ; 
     N := N / 10 ) ; 
    while (res_str->size() < sum) do     res_str := res_str+(sub) ; ; 
    if (res_str->size() > sum) then     res_str := res_str.subrange(0+1,sum) ; else skip ; 
    if (isPalindrome(res_str)) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 10101 ;
     if (createStringAndCheckPalindrome(N)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[][] array=new int[4][13];
    for(int i=1 ; i<=n ; i++){
      String s=sc.next();
      int a=sc.nextInt();
      if(s.equals("S")){
        array[0][a-1]=1 ;
      }
      else if(s.equals("H")){
        array[1][a-1]=1 ;
      }
      else if(s.equals("C")){
        array[2][a-1]=1 ;
      }
      else if(s.equals("D")){
        array[3][a-1]=1 ;
      }
    }
    for(int i=0 ; i<array.length ; i++){
      for(int j=0 ; j<array[0] .length ; j++){
        if(array[i][j]==0 && i==0){
          System.out.println("S "+(j+1));
        }
        else if(array[i][j]==0 && i==1){
          System.out.println("H "+(j+1));
        }
        else if(array[i][j]==0 && i==2){
          System.out.println("C "+(j+1));
        }
        else if(array[i][j]==0 && i==3){
          System.out.println("D "+(j+1));
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var array : Sequence(Sequence(int)) ; array := Integer.subrange(1,4)->collect(Integer.subrange(1,13)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (     var s : String ; s := sc.getCurrent() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (s = "S") then (     array[0+1][(a)->char2byte() - 1+1] := 1 ) else     if (s = "H") then (     array[1+1][(a)->char2byte() - 1+1] := 1 ) else     if (s = "C") then (     array[2+1][(a)->char2byte() - 1+1] := 1 ) else     if (s = "D") then (     array[3+1][(a)->char2byte() - 1+1] := 1 ) else skip ; ;  ;  )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < array->size() do ( (         var j : int ; j := 0 ; while j < array[0+1]->size() do ( (     if (array[i+1][j+1] = 0 & i = 0) then (     OclFile["System.out"].println("S " + (j + 1)) ) else     if (array[i+1][j+1] = 0 & i = 1) then (     OclFile["System.out"].println("H " + (j + 1)) ) else     if (array[i+1][j+1] = 0 & i = 2) then (     OclFile["System.out"].println("C " + (j + 1)) ) else     if (array[i+1][j+1] = 0 & i = 3) then (     OclFile["System.out"].println("D " + (j + 1)) ) else skip ; ;  ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class Main {
  public static final String EOL=System.getProperty("line.separator");
  public static final char[] SUIT={
    'S','H','C','D' };
    private int getSuitNum(char suit){
      switch(suit){
        case 'S' : return 0 ;
        case 'H' : return 1 ;
        case 'C' : return 2 ;
        case 'D' : return 3 ;
      }
      return-1 ;
    }
    public void exec()throws IOException {
      boolean[][] trump=new boolean[4][13];
      try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      PrintWriter out=new PrintWriter(System.out);
){
        int n=Integer.parseInt(br.readLine());
        for(int i=0 ; i<n ; i++){
          String[] str=br.readLine().split(" ");
          char suitChar=str[0] .charAt(0);
          int number=Integer.parseInt(str[1]);
          trump[getSuitNum(suitChar)][number-1]=true ;
        }
        StringBuilder sb=new StringBuilder();
        for(int suitNum=0 ; suitNum<SUIT.length ; suitNum++){
          for(int number=1 ; number<=13 ; number++){
            if(! trump[suitNum][number-1]){
              sb.append(SUIT[suitNum]).append(' ').append(number).append(EOL);
            }
          }
        }
        out.print(sb.toString());
        out.flush();
      }
    }
    public static void main(String[] args)throws IOException {
      new Main().exec();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute EOL : String := OclProcess.getEnvironmentProperty("line.separator");
  static    attribute SUIT : Sequence(String) := Sequence{'S','H','C','D'};
   operation getSuitNum( suit : String) : int
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (suit) ; 
       if _switchval = 'S' then
     return 0 
   else skip ;
       if _switchval = 'H' then
     return 1 
   else skip ;
       if _switchval = 'C' then
     return 2 
   else skip ;
       if _switchval = 'D' then
     return 3 
   else skip ;
 )
     return -1 );
   operation exec() : void
  pre: true
  post: true
  activity: (     var trump : Sequence(Sequence(boolean)) ; trump := Integer.subrange(1,4)->collect(Integer.subrange(1,13)->collect(false)) ;
     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]) ;
 (     var n : int ; n := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     var suitChar : String ; suitChar := str[0+1]->at(0+1) ;
     var number : int ; number := (str[1+1])->toInteger() ;
     trump[getSuitNum(suitChar)+1][(number)->char2byte() - 1+1] := true )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var suitNum : int ; suitNum := 0 ; while suitNum < SUIT->size() do ( (         var number : int ; number := 1 ; while number <= 13 do ( (     if (not(trump[suitNum+1][(number)->char2byte() - 1+1])) then (     sb := sb + StringLib.newString(SUIT[suitNum+1]) + StringLib.newString(' ') + StringLib.newString(number) + StringLib.newString(EOL) ) else skip )  ;     number := number + 1 ) )  ;     suitNum := suitNum + 1 ) ; 
    skip ; 
    skip ; 
 ))  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().exec() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
public class ThemePark {
  public static void main(String[] args)throws Exception {
    BufferedReader in=new BufferedReader(new FileReader("C-large.in"));
    PrintStream out=new PrintStream(new FileOutputStream("C-large.out"));
    long T=Integer.parseInt(in.readLine());
    String[] s ;
    long R,k ;
    int N ;
    long[] g=new long[1000],value=new long[1000];
    int[] next=new int[1000];
    for(int cas=1 ; cas<=T ; ++cas){
      s=in.readLine().split(" ");
      R=Long.parseLong(s[0]);
      k=Long.parseLong(s[1]);
      N=Integer.parseInt(s[2]);
      s=in.readLine().split(" ");
      for(int i=0 ; i<N ; ++i)g[i]=Long.parseLong(s[i]);
      for(int i=0 ; i<N ; ++i){
        value[i]=g[i];
        next[i]=(i+1)% N ;
        while(next[i]!=i && value[i]+g[next[i] ]<=k){
          value[i]+=g[next[i] ];
          next[i]=(next[i]+1)% N ;
        }
      }
      long euros=0 ;
      int group=0 ;
      for(int i=0 ; i<R ; ++i){
        euros+=value[group];
        group=next[group];
      }
      out.println("Case #"+cas+": "+euros);
    }
    in.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ThemePark {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("C-large.in"))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("C-large.out"))) ;
    var T : long ; T := (in.readLine())->toInteger() ;
    var s : Sequence(String) ;
    var R : long ;
    var k : long ;
    var N : int ;
    var g : Sequence(long) ; g := Integer.subrange(1,1000)->collect(0) ;
    var value : Sequence(long) ; value := Integer.subrange(1,1000)->collect(0) ;
    var next : Sequence(int) ; next := Integer.subrange(1,1000)->collect(0) ;
        var cas : int ; cas := 1 ; while cas <= T do ( (     s := in.readLine()->split(" ") ; 
     R := (s[0+1])->toLong() ; 
    k := (s[1+1])->toLong() ; 
    N := (s[2+1])->toInteger() ; 
    s := in.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < N do (     g[i+1] := (s[i+1])->toLong() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     value[i+1] := g[i+1] ; 
     next[i+1] := (i + 1) mod N ; 
     while (next[i+1] /= i & value[i+1] + g[next[i+1]+1] <= k) do (     value[i+1] := value[i+1]+(g[next[i+1]+1]) ; 
     next[i+1] := (next[i+1] + 1) mod N ) )  ;     i := i + 1 ) ; 
    var euros : long ; euros := 0 ;
    var group : int ; group := 0 ;
        var i : int ; i := 0 ; while i < R do ( (     euros := euros+(value[group+1]) ; 
     group := next[group+1] )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     cas := cas + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args)throws Exception {
    List<Card>cards=new ArrayList<>();
    IntStream.range(0,13).forEach(i->cards.add(new Card('S',i+1)));
    IntStream.range(0,13).forEach(i->cards.add(new Card('H',i+1)));
    IntStream.range(0,13).forEach(i->cards.add(new Card('C',i+1)));
    IntStream.range(0,13).forEach(i->cards.add(new Card('D',i+1)));
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    br.lines().forEach(s->{
      List<String>list=Arrays.stream(s.split(" ")).collect(Collectors.toList());
      Card card=new Card(list.get(0).charAt(0),Integer.valueOf(list.get(1)));
      cards.remove(card);
    }
);
    cards.forEach(c->System.out.println(c.toString()));
  }
}
class Card extends Object {
  private char suit ;
  private int number ;
  public Card(char suit,int number){
    this.suit=suit ;
    this.number=number ;
  }
  @ Override public boolean equals(Object object){
    if(!(object instanceof Card)){
      return false ;
    }
    else {
      Card card=(Card)object ;
      return this.suit==card.suit && this.number==card.number ;
    }
  }
  @ Override public int hashCode(){
    return suit*100+number ;
  }
  @ Override public String toString(){
    return String.valueOf(suit)+" "+String.valueOf(number);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cards : Sequence(Card) ; cards := Sequence{} ;
     for i : Integer.subrange(0, 13-1) do
    (    cards := cards->including(Card.newCard('S', i + 1))) ; 
    for i : Integer.subrange(0, 13-1) do
    (    cards := cards->including(Card.newCard('H', i + 1))) ; 
    for i : Integer.subrange(0, 13-1) do
    (    cards := cards->including(Card.newCard('C', i + 1))) ; 
    for i : Integer.subrange(0, 13-1) do
    (    cards := cards->including(Card.newCard('D', i + 1))) ; 
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    for s : br.lines() do
    (    skip) ; 
    for c : cards do
    (    OclFile["System.out"].println(c+"")) ; 
 );
}
class Card extends OclAny {
   attribute suit : String;
   attribute number : int;
   static operation newCard( suit : String, number : int) : Card
  pre: true
  post: true
  activity:
  ( var self : Card ;
    self := createCard();
    self.initialise(suit, number);
    return self );
  operation initialise( suit : String, number : int) : void
  pre: true  post: true
  activity: (     self.suit := suit ; 
     self.number := number );
      operation equals( object : OclAny) : boolean
  pre: true
  post: true
  activity: (     if (not((object->oclIsKindOf(Card)))) then (     return false ) else (     var card : Card ; card := object->oclAsType(Card) ;
     return self.suit = card.suit & self.number = card.number ) );
      operation hashCode() : int
  pre: true
  post: true
  activity: (     return suit * 100 + number );
      operation toString() : String
  pre: true
  post: true
  activity: (     return ((suit) + "") + " " + ((number) + "") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static final int BIG_NUM=2000000000 ;
  public static final int MOD=1000000007 ;
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int table[]=new int[128];
    String work[]=new String[2];
    String outPut[]={
      "S","H","C","D" };
      table['S']=0 ;
      table['H']=1 ;
      table['C']=2 ;
      table['D']=3 ;
      boolean check[][]=new boolean[4][14];
      for(int row=0 ; row<4 ; row++){
        for(int col=1 ; col<=13 ; col++)check[row][col]=false ;
      }
      try {
        int N=Integer.parseInt(br.readLine());
        for(int loop=0 ; loop<N ; loop++){
          work=br.readLine().split("\\s+");
          check[table[work[0] .charAt(0)] ][Integer.parseInt(work[1])]=true ;
        }
        for(int row=0 ; row<4 ; row++){
          for(int col=1 ; col<=13 ; col++){
            if(! check[row][col]){
              System.out.printf("%s %d\n",outPut[row],col);
            }
          }
        }
      }
      catch(NumberFormatException e){
        e.printStackTrace();
      }
      catch(IOException e){
        e.printStackTrace();
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BIG_NUM : int := 2000000000;
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var table : Sequence(int) ; table := Integer.subrange(1,128)->collect(0) ;
    var work : Sequence(String) ; work := Integer.subrange(1,2)->collect(null) ;
    var outPut : Sequence(String) ; outPut := Sequence{"S","H","C","D"} ;
    table['S'+1] := 0 ; 
    table['H'+1] := 1 ; 
    table['C'+1] := 2 ; 
    table['D'+1] := 3 ; 
    var check : Sequence(Sequence(boolean)) ; check := Integer.subrange(1,4)->collect(Integer.subrange(1,14)->collect(false)) ;
        var row : int ; row := 0 ; while row < 4 do ( (         var col : int ; col := 1 ; while col <= 13 do (     check[row+1][col+1] := false ;  ;     col := col + 1 ) )  ;     row := row + 1 ) ; 
    try (     var N : int ; N := (br.readLine())->toInteger() ;
         var loop : int ; loop := 0 ; while loop < N do ( (     work := br.readLine()->split("\\s+") ; 
     check[table[work[0+1]->at(0+1)+1]+1][(work[1+1])->toInteger()+1] := true )  ;     loop := loop + 1 ) ; 
         var row : int ; row := 0 ; while row < 4 do ( (         var col : int ; col := 1 ; while col <= 13 do ( (     if (not(check[row+1][col+1])) then (     OclFile["System.out"].printf("%s %d\n", outPut[row+1], col) ) else skip )  ;     col := col + 1 ) )  ;     row := row + 1 ) )   catch (e : IncorrectElementException) do (     e.printStackTrace() )
   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    String rank="SHCD" ;
    String[] input_data=new String[2];
    int[][] output_data=new int[4][13];
    Scanner sc=new Scanner(System.in);
    String input1=sc.nextLine();
    int n=Integer.parseInt(input1);
    String input2="" ;
    int rank_number=0 ;
    int card_number=0 ;
    boolean judge=true ;
    String output_rank="" ;
    if(n>0 && n<=52){
      out : for(int i=0 ;
      i<n ;
      i++){
        input2=sc.nextLine();
        input_data=input2.split(" ");
        rank_number=rank.indexOf(input_data[0]);
        card_number=Integer.parseInt(input_data[1]);
        if((rank_number==-1)||(1>card_number || card_number>13)){
          judge=false ;
          break out ;
        }
        if(output_data[rank_number][card_number-1]!=card_number){
          output_data[rank_number][card_number-1]=card_number ;
        }
      }
      if(judge==true){
        for(int j=0 ; j<output_data.length ; j++){
          output_rank=""+rank.charAt(j);
          for(int k=0 ; k<output_data[0] .length ; k++){
            if(output_data[j][k]!=(k+1)){
              System.out.println(output_rank+" "+(k+1));
            }
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var rank : String ; rank := "SHCD" ;
     var input_data : Sequence(String) ; input_data := Integer.subrange(1,2)->collect(null) ;
    var output_data : Sequence(Sequence(int)) ; output_data := Integer.subrange(1,4)->collect(Integer.subrange(1,13)->collect(0)) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var input1 : String ; input1 := sc.nextLine() ;
    var n : int ; n := (input1)->toInteger() ;
    var input2 : String ; input2 := "" ;
    var rank_number : int ; rank_number := 0 ;
    var card_number : int ; card_number := 0 ;
    var judge : boolean ; judge := true ;
    var output_rank : String ; output_rank := "" ;
    if (n > 0 & n <= 52) then (         var i : int ; i := 0 ; while i < n do ( (     input2 := sc.nextLine() ; 
     input_data := input2->split(" ") ; 
    rank_number := rank->indexOf(input_data[0+1])-1 ; 
    card_number := (input_data[1+1])->toInteger() ; 
    if ((rank_number = -1) or (1 > card_number or card_number > 13)) then (     judge := false ; 
     break ) else skip ; 
    if (output_data[rank_number+1][card_number - 1+1] /= card_number) then (     output_data[rank_number+1][card_number - 1+1] := card_number ) else skip ; 
 )  ;     i := i + 1 ) ; 
     if (judge = true) then (         var j : int ; j := 0 ; while j < output_data->size() do ( (     output_rank := "" + rank->at(j+1) ; 
         var k : int ; k := 0 ; while k < output_data[0+1]->size() do ( (     if (output_data[j+1][k+1] /= (k + 1)) then (     OclFile["System.out"].println(output_rank + " " + (k + 1)) ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ) else skip ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countNonIncreasing(int arr[],int n){
    int cnt=0 ;
    int len=1 ;
    for(int i=0 ; i<n-1 ; ++i){
      if(arr[i+1]>=arr[i])len++;
      else {
        cnt+=(((len+1)*len)/2);
        len=1 ;
      }
    }
    if(len>1)cnt+=(((len-1)*len)/2);
    return cnt ;
  }
  public static void main(String[] args){
    int arr[]={
      5,2,3,7,1,1 };
      int n=arr.length ;
      System.out.println(countNonIncreasing(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countNonIncreasing( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var len : int ; len := 1 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i + 1+1] >= arr[i+1]) then     len := len + 1 ; else (     cnt := cnt+((((len + 1) * len) / 2)) ; 
     len := 1 ) )  ;     i := i + 1 ) ; 
    if (len > 1) then     cnt := cnt+((((len - 1) * len) / 2)) ; else skip ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,2,3,7,1,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countNonIncreasing(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.util.Arrays ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner scan=new Scanner(System.in);
    int T=scan.nextInt();
    for(int i=0 ; i<T ; i++){
      String s=scan.next();
      int len=s.length();
      if(len==1){
        System.out.println("NO");
        continue ;
      }
      int count=1 ;
      boolean a=true ;
      for(int j=0 ; j<len-1 ; j++){
        if(s.charAt(j)==s.charAt(j+1)){
          count++;
        }
        else {
          if(count==1){
            a=false ;
            break ;
          }
          else if(j==len-2){
            a=false ;
          }
          else {
            count=1 ;
          }
        }
      }
      if(a==true){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < T do ( (     var s : String ; s := scan.getCurrent() ;
     var len : int ; len := s->size() ;
    if (len = 1) then (     OclFile["System.out"].println("NO") ; 
     continue ) else skip ; 
    var count : int ; count := 1 ;
    var a : boolean ; a := true ;
        var j : int ; j := 0 ; while j < (len)->char2byte() - 1 do ( (     if (s->at(j+1) = s->at(j + 1+1)) then (     count := count + 1 ) else (     if (count = 1) then (     a := false ; 
     break ) else     if (j = (len)->char2byte() - 2) then (     a := false ) else (     count := 1 ) ;  ) )  ;     j := j + 1 ) ; 
    if (a = true) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printDuplicates(int arr[],int n){
    int i ;
    int fl=0 ;
    for(i=0 ; i<n ; i++){
      if(arr[arr[i] % n]>=n){
        if(arr[arr[i] % n]<2*n){
          System.out.print(arr[i] % n+" ");
          fl=1 ;
        }
      }
      arr[arr[i] % n]+=n ;
    }
    if(!(fl>0))System.out.println("-1");
  }
  public static void main(String[] args){
    int arr[]={
      1,6,3,1,3,6,6 };
      int arr_size=arr.length ;
      printDuplicates(arr,arr_size);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printDuplicates( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
     var fl : int ; fl := 0 ;
         i := 0 ; while i < n do ( (     if (arr[arr[i+1] mod n+1] >= n) then (     if (arr[arr[i+1] mod n+1] < 2 * n) then (     OclFile["System.out"].print(arr[i+1] mod n + " ") ; 
     fl := 1 ) else skip ) else skip ; 
     arr[arr[i+1] mod n+1] := arr[arr[i+1] mod n+1]+(n) )  ;     i := i + 1 ) ; 
     if (not((fl > 0))) then     OclFile["System.out"].println("-1") ; else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,6,3,1,3,6,6} ;
     var arr_size : int ; arr_size := arr->size() ;
     execute printDuplicates(arr, arr_size) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF1293B {
  public static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    double res=0 ;
    for(int i=0 ; i<n ; i++)res+=(1.0/(double)(n-i));
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF1293B {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var res : double ; res := 0 ;
        var i : int ; i := 0 ; while i < n do (     res := res+((1.0 / (n - i)->oclAsType(double))) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.nio.charset.MalformedInputException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter o=new PrintWriter(System.out);
    double n=sc.nextDouble();
    double h=0 ;
    for(double i=1 ; i<=n ; i++){
      h+=(1/i);
    }
    o.println(h);
    o.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var o : OclFile ; o := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : double ; n := sc.getCurrent()->toReal() ;
    var h : double ; h := 0 ;
        var i : double ; i := 1 ; while i <= n do ( (     h := h+((1 / i)) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int Max_Sum(int n){
    return(n*(n-1))/2 ;
  }
  public static void main(String[] args){
    int n=8 ;
    System.out.println(Max_Sum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Max_Sum( n : int) : int
  pre: true
  post: true
  activity: (     return (n * (n - 1)) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     OclFile["System.out"].println(Max_Sum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      int n=sc.nextInt();
      int k=sc.nextInt();
      long res=solve(n,k);
      System.out.println(res);
    }
  }
  long[][] dp ;
  final int SET=1<<10 ;
  long solve(int n,int k){
    if(n<=0 || n>10)return 0 ;
    if(k<0 || k>385)return 0 ;
    if(dp==null){
      dp=new long[SET][400];
      dp[0][0]=1 ;
      for(int set=0 ; set<SET ; set++){
        int on=Integer.bitCount(set);
        for(int sum=0 ; sum<400 ; sum++)if(dp[set][sum]>0){
          for(int i=0 ; i<=9 ; i++){
            if((set>>i & 1)==0){
              int nset=set |(1<<i);
              int nsum=sum+(on+1)*i ;
              if(nsum<400){
                dp[nset][nsum]+=dp[set][sum];
              }
            }
          }
        }
      }
    }
    long res=0 ;
    for(int set=0 ; set<SET ; set++)if(Integer.bitCount(set)==n){
      res+=dp[set][k];
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     var res : long ; res := solve(n, k) ;
     OclFile["System.out"].println(res) )  ) );
   attribute dp : Sequence(Sequence(long));
   attribute SET : int := (1*(2->pow(10)))->oclAsType(long);
   operation solve( n : int, k : int) : long
  pre: true
  post: true
  activity: (     if (n <= 0 or n > 10) then     return 0 else skip ; 
     if (k < 0 or k > 385) then     return 0 else skip ; 
    if (dp = null) then (     dp := Integer.subrange(1,SET)->collect(Integer.subrange(1,400)->collect(0)) ; 
     dp[0+1][0+1] := 1 ; 
         var set : int ; set := 0 ; while set < SET do ( (     var on : int ; on := bitCount(set) ;
         var sum : int ; sum := 0 ; while sum < 400 do (     if (dp[set+1][sum+1] > 0) then (         var i : int ; i := 0 ; while i <= 9 do ( (     if ((MathLib.bitwiseAnd((set/(2->pow(i)))->oclAsType(long),1)) = 0) then (     var nset : int ; nset := MathLib.bitwiseOr(set,((1*(2->pow(i)))->oclAsType(long))) ;
     var nsum : int ; nsum := sum + (on + 1) * i ;
     if (nsum < 400) then (     dp[nset+1][nsum+1] := dp[nset+1][nsum+1]+(dp[set+1][sum+1]) ) else skip ) else skip )  ;     i := i + 1 ) ) else skip ;  ;     sum := sum + 1 ) )  ;     set := set + 1 ) ) else skip ; 
    var res : long ; res := 0 ;
        var set : int ; set := 0 ; while set < SET do (     if (bitCount(set) = n) then (     res := res+(dp[set+1][k+1]) ) else skip ;  ;     set := set + 1 ) ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int grayCode(int n){
    return n ^(n>>1);
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(grayCode(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation grayCode( n : int) : int
  pre: true
  post: true
  activity: (     return n xor ((n/(2->pow(1)))->oclAsType(long)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(grayCode(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  static int sum(int n){
    if(n==1){
      return 2 ;
    }
    else {
      return(n*(n+1)+sum(n-1));
    }
  }
  public static void main(String args[]){
    int n=2 ;
    System.out.println(sum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
  static   operation sum( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then (     return 2 ) else (     return (n * (n + 1) + sum(n - 1)) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(sum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sum(int m,int n){
    return 8*m*n-6*m-6*n+4 ;
  }
  public static void main(String[] args){
    int m=3,n=2 ;
    System.out.println(sum(m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sum( m : int, n : int) : int
  pre: true
  post: true
  activity: (     return 8 * m * n - 6 * m - 6 * n + 4 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 3 ;
    var n : int ; n := 2 ;
     OclFile["System.out"].println(sum(m, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findThirdDigit(int n){
    if(n<3)return 0 ;
    return(n & 1)>0 ? 1 : 6 ;
  }
  public static void main(String args[]){
    int n=7 ;
    System.out.println(findThirdDigit(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findThirdDigit( n : int) : int
  pre: true
  post: true
  activity: (     if (n < 3) then     return 0 else skip ; 
     return if (n & 1) > 0 then 1 else 6 endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     OclFile["System.out"].println(findThirdDigit(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maximize(int A1[],int A2[],int n,int x,int y){
    int[] c=new int[n];
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      c[i]=A2[i]-A1[i];
      sum+=A1[i];
    }
    int temp ;
    for(int i=0 ; i<n-1 ; i++){
      if(c[i]<c[i+1]){
        temp=c[i];
        c[i]=c[i+1];
        c[i+1]=temp ;
      }
    }
    int maxi=-1 ;
    for(int i=0 ; i<n ; i++){
      sum+=c[i];
      if(i+1>=(n-x))maxi=Math.max(sum,maxi);
    }
    return maxi ;
  }
  public static void main(String args[]){
    int A1[]={
      1,2,3,4,5 };
      int A2[]={
        5,4,3,2,1 };
        int n=5 ;
        int x=3,y=3 ;
        System.out.println(maximize(A1,A2,n,x,y));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maximize( A1 : Sequence(int), A2 : Sequence(int), n : int, x : int, y : int) : int
  pre: true
  post: true
  activity: (     var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
     var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := A2[i+1] - A1[i+1] ; 
     sum := sum+(A1[i+1]) )  ;     i := i + 1 ) ; 
    var temp : int ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (c[i+1] < c[i + 1+1]) then (     temp := c[i+1] ; 
     c[i+1] := c[i + 1+1] ; 
     c[i + 1+1] := temp ) else skip )  ;     i := i + 1 ) ; 
    var maxi : int ; maxi := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(c[i+1]) ; 
     if (i + 1 >= (n - x)) then     maxi := Set{sum, maxi}->max() ; else skip )  ;     i := i + 1 ) ; 
    return maxi 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A1 : Sequence(int) ; A1 := Sequence{1,2,3,4,5} ;
     var A2 : Sequence(int) ; A2 := Sequence{5,4,3,2,1} ;
    var n : int ; n := 5 ;
    var x : int ; x := 3 ;
    var y : int ; y := 3 ;
    OclFile["System.out"].println(maximize(A1, A2, n, x, y)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countIntersections(int n){
    return n*(n-1)/2 ;
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(countIntersections(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countIntersections( n : int) : int
  pre: true
  post: true
  activity: (     return n * (n - 1) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(countIntersections(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sum(int n){
    return n*(n+1)*(n+2)/3 ;
  }
  public static void main(String[] args){
    int n=2 ;
    System.out.println(sum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sum( n : int) : int
  pre: true
  post: true
  activity: (     return n * (n + 1) * (n + 2) / 3 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(sum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findSum(int n){
    return(n*(n+1)*(n+1)*(n+2))/12 ;
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(findSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findSum( n : int) : int
  pre: true
  post: true
  activity: (     return (n * (n + 1) * (n + 1) * (n + 2)) / 12 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(findSum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxHandshake(int n){
    return(n*(n-1))/2 ;
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(maxHandshake(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxHandshake( n : int) : int
  pre: true
  post: true
  activity: (     return (n * (n - 1)) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(maxHandshake(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void find_composite_nos(int n){
    System.out.println(9*n+" "+8*n);
  }
  public static void main(String[] args){
    int n=4 ;
    find_composite_nos(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find_composite_nos( n : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(9 * n + " " + 8 * n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     execute find_composite_nos(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int bitC(int a){
    if(a==0)return 0 ;
    return bitC(a>>1)+(a & 1);
  }
  void run(){
    int size=0 ;
    for(int i=0 ; i<10 ; i++)size+=i*(i+1);
    int[][] dp=new int[size+1][1<<10];
    int[][] map=new int[size+1][11];
    dp[0][0]=1 ;
    for(int z=0 ; z<10 ; z++){
      for(int j=0 ; j<1<<10 ; j++){
        if(bitC(j)!=z)continue ;
        for(int k=1,p=0 ; k<1<<10 ; k=k<<1,p++){
          if((j & k)!=0)continue ;
          int bc=bitC(j | k);
          for(int i=0 ; i+bc*p<size+1 ; i++){
            dp[i+bc*p][j | k]+=dp[i][j];
          }
        }
      }
    }
    for(int j=0 ; j<size+1 ; j++){
      for(int i=0 ; i<1<<10 ; i++){
        map[j][bitC(i)]+=dp[j][i];
      }
    }
    for(; sc.hasNextInt(); ){
      int n=sc.nextInt();
      int s=sc.nextInt();
      if(n>10 || s>size){
        System.out.println("0");
        continue ;
      }
      System.out.println(map[s][n]);
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation bitC( a : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return 0 else skip ; 
     return bitC((a/(2->pow(1)))->oclAsType(long)) + (a & 1) );
   operation run() : void
  pre: true
  post: true
  activity: (     var size : int ; size := 0 ;
         var i : int ; i := 0 ; while i < 10 do (     size := size+(i * (i + 1)) ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,size + 1)->collect(Integer.subrange(1,(1*(2->pow(10)))->oclAsType(long))->collect(0)) ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,size + 1)->collect(Integer.subrange(1,11)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var z : int ; z := 0 ; while z < 10 do ( (         var j : int ; j := 0 ; while j < (1*(2->pow(10)))->oclAsType(long) do ( (     if (bitC(j) /= z) then     continue else skip ; 
         var k : int ; k := 1 ;
    var p : int ; p := 0 ; while k < (1*(2->pow(10)))->oclAsType(long) do ( (     if ((MathLib.bitwiseAnd(j,k)) /= 0) then     continue else skip ; 
     var bc : int ; bc := bitC(MathLib.bitwiseOr(j,k)) ;
         var i : int ; i := 0 ; while i + bc * p < size + 1 do ( (     dp[i + bc * p+1][MathLib.bitwiseOr(j,k)+1] := dp[i + bc * p+1][MathLib.bitwiseOr(j,k)+1]+(dp[i+1][j+1]) )  ;     i := i + 1 ) )  ;     k := (k*(2->pow(1)))->oclAsType(long) ;     p := p + 1 ) )  ;     j := j + 1 ) )  ;     z := z + 1 ) ; 
        var j : int ; j := 0 ; while j < size + 1 do ( (         var i : int ; i := 0 ; while i < (1*(2->pow(10)))->oclAsType(long) do ( (     map[j+1][bitC(i)+1] := map[j+1][bitC(i)+1]+(dp[j+1][i+1]) )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
      while sc.hasNextInt() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : int ; s := sc.getCurrent()->toInteger() ;
     if (n > 10 or s > size) then (     OclFile["System.out"].println("0") ; 
     continue ) else skip ; 
     OclFile["System.out"].println(map[s+1][n+1]) )  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int possibleways(int n){
    if(n % 2==1)return 0 ;
    else if(n % 4==0)return n/4-1 ;
    else return n/4 ;
  }
  public static void main(String[] args){
    int n=20 ;
    System.out.println(possibleways(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation possibleways( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 = 1) then     return 0 else     if (n mod 4 = 0) then     return n / 4 - 1 else     return n / 4 ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 20 ;
     OclFile["System.out"].println(possibleways(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxLCM(int n){
    return(n*(n-1));
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(maxLCM(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxLCM( n : int) : int
  pre: true
  post: true
  activity: (     return (n * (n - 1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(maxLCM(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static long countMaxIntersect(long n){
    return(n)*(n-1)/2 ;
  }
  public static void main(String args[]){
    long n=8 ;
    System.out.println(countMaxIntersect(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countMaxIntersect( n : long) : long
  pre: true
  post: true
  activity: (     return (n) * (n - 1) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 8 ;
     OclFile["System.out"].println(countMaxIntersect(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int SUM(int n,int m){
    if(m==1)return(n*(n+1)/2);
    int sum=SUM(n,m-1);
    return(sum*(sum+1)/2);
  }
  public static void main(String[] args){
    int n=5 ;
    int m=3 ;
    System.out.println("SUM("+n+","+m+"): "+SUM(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation SUM( n : int, m : int) : int
  pre: true
  post: true
  activity: (     if (m = 1) then     return (n * (n + 1) / 2) else skip ; 
     var sum : int ; sum := SUM(n, m - 1) ;
     return (sum * (sum + 1) / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var m : int ; m := 3 ;
     OclFile["System.out"].println("SUM(" + n + "," + m + "): " + SUM(n, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int cntWays(int n){
    if(n % 2==1){
      return 0 ;
    }
    else {
      return(n-2)/4 ;
    }
  }
  public static void main(String[] args){
    int n=18 ;
    System.out.println(cntWays(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation cntWays( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 = 1) then (     return 0 ) else (     return (n - 2) / 4 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 18 ;
     OclFile["System.out"].println(cntWays(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MainClass {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int t=Integer.parseInt(st.nextToken());
    while(t-->0){
      st=new StringTokenizer(br.readLine());
      int x=Integer.parseInt(st.nextToken());
      String s=Integer.toString(x);
      int extra=s.length();
      int temp=Character.getNumericValue(s.charAt(0));
      int ans=0 ;
      for(int i=1 ; i<temp ; i++){
        ans+=10 ;
      }
      ans+=(extra)*(extra+1)/2 ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var t : int ; t := (st.next())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var x : int ; x := (st.next())->toInteger() ;
    var s : String ; s := ((x) + "") ;
    var extra : int ; extra := s->size() ;
    var temp : int ; temp := ("" + s->at(0+1))->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < temp do ( (     ans := ans+(10) )  ;     i := i + 1 ) ; 
    ans := ans+((extra) * (extra + 1) / 2) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int CountSetBits(int n){
    if(n==0)return 0 ;
    if((n & 1)==1)return 1+CountSetBits(n>>1);
    else return CountSetBits(n>>1);
  }
  public static void main(String[] args){
    int n=21 ;
    System.out.println(CountSetBits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation CountSetBits( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else skip ; 
     if ((n & 1) = 1) then     return 1 + CountSetBits((n/(2->pow(1)))->oclAsType(long)) else     return CountSetBits((n/(2->pow(1)))->oclAsType(long)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 21 ;
     OclFile["System.out"].println(CountSetBits(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int highestPowerOf2(int n){
    return(n &(~(n-1)));
  }
  public static void main(String[] args){
    int n=48 ;
    System.out.println(highestPowerOf2(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation highestPowerOf2( n : int) : int
  pre: true
  post: true
  activity: (     return (n & (-((n - 1) + 1))) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 48 ;
     OclFile["System.out"].println(highestPowerOf2(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    sc.close();
    String c="None" ;
    for(int i='a' ; i<='z' ; i++){
      if(! s.contains(""+(char)i)){
        c=""+(char)i ;
        break ;
      }
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    skip ; 
    var c : String ; c := "None" ;
        var i : int ; i := 'a' ; while i <= 'z' do ( (     if (not(s->includes("" + i->oclAsType(String)))) then (     c := "" + i->oclAsType(String) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskC solver=new TaskC();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskC {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      char[] s=in.next().toCharArray();
      int[] count=new int[26];
      for(char c : s){
        count[c-'a']++;
      }
      char i=0 ;
      while(i<26 && count[i]!=0){
        i++;
      }
      if(i==26){
        out.println("None");
      }
      else {
        out.println(""+(char)(i+'a'));
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextFloat(){
      return Double.parseDouble(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskC ; solver := TaskC.newTaskC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskC {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := in.next()->characters() ;
     var count : Sequence(int) ; count := Integer.subrange(1,26)->collect(0) ;
    for (c : s) do ( (     count[c - ('a')->char2byte()+1] := count[c - ('a')->char2byte()+1] + 1 )  ) ; 
    var i : String ; i := 0 ;
    while (i < 26 & count[i+1] /= 0) do (     i := i + 1 ) ; 
    if (i = 26) then (     skip ) else (     skip ) ;  
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static long mod=1000000007 ;
  static int fact(int n){
    int res=1 ;
    for(int i=2 ; i<=n ; i++)res=res*i ;
    return res ;
  }
  static int nCr(int n,int r){
    return fact(n)/(fact(r)*fact(n-r));
  }
  static long powmod(long a,long n){
    if(n==0)return 1 ;
    long pt=powmod(a,n/2);
    pt=(pt*pt)% mod ;
    if(n % 2==1)return(pt*a)% mod ;
    else return pt ;
  }
  static long CountSubset(int[] arr,int n){
    long ans=powmod(2,n-1);
    Arrays.sort(arr);
    for(int i=0 ; i<n ; ++i){
      int j=i+1 ;
      while(j<n && arr[j]==arr[i]){
        int r=n-1-j ;
        int l=i ;
        ans=(ans+nCr(l+r,l))% mod ;
        j++;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      2,3,2 };
      int n=arr.length ;
      System.out.println(CountSubset(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute mod : long := 1000000007;
  static   operation fact( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
         var i : int ; i := 2 ; while i <= n do (     res := res * i ;  ;     i := i + 1 ) ; 
     return res );
  static   operation nCr( n : int, r : int) : int
  pre: true
  post: true
  activity: (     return fact(n) / (fact(r) * fact(n - r)) );
  static   operation powmod( a : long, n : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     var pt : long ; pt := powmod(a, n / 2) ;
     pt := (pt * pt) mod mod ; 
     if (n mod 2 = 1) then     return (pt * a) mod mod else     return pt );
  static   operation CountSubset( arr : Sequence(int), n : int) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := powmod(2, n - 1) ;
     arr := arr->sort() ; 
         var i : int ; i := 0 ; while i < n do ( (     var j : int ; j := i + 1 ;
     while (j < n & arr[j+1] = arr[i+1]) do (     var r : int ; r := n - 1 - j ;
     var l : int ; l := i ;
     ans := (ans + nCr(l + r, l)) mod mod ; 
     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(CountSubset(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Map ;
import java.util.Map.Entry ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    new Main().solve();
    return ;
  }
  private void solve(){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    sc.close();
    Map<String,Integer>map=new TreeMap<String,Integer>();
    for(String s : "abcdefghijklmnopqrstuvwxyz".split("")){
      if(! s.equals("")){
        map.put(s,0);
      }
    }
    for(String s : S.split("")){
      if(! s.equals("")){
        map.put(s,map.get(s)+1);
      }
    }
    String output="None" ;
    for(Entry<String,Integer>entry : map.entrySet()){
      if(entry.getValue()==0){
        output=entry.getKey();
        break ;
      }
    }
    System.out.println(output);
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() ; 
     return );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    skip ; 
    var map : Map(String,int) ; map := Map{} ;
    for (s : "abcdefghijklmnopqrstuvwxyz"->split("")) do ( (     if (not(s = "")) then (     map := map->union(Map{s |-> 0}) ) else skip )  ) ; 
    for (s : S->split("")) do ( (     if (not(s = "")) then (     map := map->union(Map{s |-> map->at(s) + 1}) ) else skip )  ) ; 
    var output : String ; output := "None" ;
    for (entry : map->asSet()) do ( (     if (entry.getValue() = 0) then (     output := entry.getKey() ; 
     break ) else skip )  ) ; 
    OclFile["System.out"].println(output) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in))){
      final String s=reader.readLine();
      int alp=26 ;
      int num=alp ;
      int[] a=new int[num];
      Arrays.fill(a,0);
      for(int i=0 ; i<s.length(); i++){
        if(num==0)break ;
        if(0==a[s.charAt(i)-'a']){
          num--;
          a[s.charAt(i)-'a']=1 ;
        }
      }
      if(num==0){
        System.out.println("None");
      }
      else {
        for(int i=0 ; i<alp ; i++){
          if(a[i]==0){
            System.out.println((char)('a'+i));
            break ;
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var s : String ; s := reader.readLine() ;
     var alp : int ; alp := 26 ;
    var num : int ; num := alp ;
    var a : Sequence(int) ; a := Integer.subrange(1,num)->collect(0) ;
    a := a->collect(0) ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     if (num = 0) then     break else skip ; 
     if (0 = a[s->at(i+1) - ('a')->char2byte()+1]) then (     num := num - 1 ; 
     a[s->at(i+1) - ('a')->char2byte()+1] := 1 ) else skip )  ;     i := i + 1 ) ; 
    if (num = 0) then (     OclFile["System.out"].println("None") ) else (         var i : int ; i := 0 ; while i < alp do ( (     if (a[i+1] = 0) then (     OclFile["System.out"].println(('a' + i)->oclAsType(String)) ; 
     break ) else skip )  ;     i := i + 1 ) ) ;  
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    char[] c=s.toCharArray();
    String[] alp={
      "a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z" };
      String[] d=new String[c.length];
      Set<String>hs=new HashSet<String>();
      for(int i=0 ; i<s.length(); i++){
        d[i]=String.valueOf(c[i]);
        hs.add(d[i]);
      }
      if(hs.size()==26)System.out.println("None");
      else {
        for(int i=0 ; ; i++){
          if(!(hs.contains(alp[i]))){
            System.out.println(alp[i]);
            break ;
          }
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var c : Sequence(String) ; c := s->characters() ;
    var alp : Sequence(String) ; alp := Sequence{"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"} ;
    var d : Sequence(String) ; d := Integer.subrange(1,c->size())->collect(null) ;
    var hs : Set(String) ; hs := Set{} ;
        var i : int ; i := 0 ; while i < s->size() do ( (     d[i+1] := ((c[i+1]) + "") ; 
     hs := hs->including(d[i+1]) )  ;     i := i + 1 ) ; 
    if (hs->size() = 26) then     OclFile["System.out"].println("None") else (         var i : int ; i := 0 ; while true do ( (     if (not((hs->includes(alp[i+1])))) then (     OclFile["System.out"].println(alp[i+1]) ; 
     break ) else skip )  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A1581 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));
    int n=in.nextInt();
    int[] arr=new int[n];
    Arrays.setAll(arr,i->in.nextInt());
    Arrays.sort(arr);
    if(arr[0]==1){
      pw.println(1);
      pw.close();
      return ;
    }
    else {
      if(n==1){
        pw.println(arr[0]);
        pw.close();
        return ;
      }
    }
    boolean yes=true ;
    for(int i=1 ; i<n ; i++){
      if(arr[i] % arr[0]!=0){
        yes=false ;
        break ;
      }
    }
    if(yes)pw.println(arr[0]);
    else pw.println(-1);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
  static int GCD(int a,int b){
    if(b==0)return a ;
    else return GCD(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1581 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
setAll(arr, lambda i : OclAny in in.getCurrent()->toInteger()) ; 
    arr := arr->sort() ; 
    if (arr[0+1] = 1) then (     skip ; 
     skip ; 
     return ) else (     if (n = 1) then (     skip ; 
     skip ; 
     return ) else skip ) ;  
    var yes : boolean ; yes := true ;
        var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] mod arr[0+1] /= 0) then (     yes := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (yes) then     skip else     skip ; ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
  static   operation GCD( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else     return GCD(b, a mod b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] a=new int[n];
    int i ;
    int min ;
    for(i=0 ; i<n ; i++){
      a[i]=input.nextInt();
    }
    min=a[0];
    for(i=1 ; i<n ; i++){
      if(a[i]<min){
        min=a[i];
      }
    }
    for(i=0 ; i<n ; i++){
      if(a[i] % min!=0){
        break ;
      }
    }
    if(i<n){
      System.out.println(-1);
    }
    else {
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var i : int ;
    var min : int ;
        i := 0 ; while i < n do ( (     a[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    min := a[0+1] ; 
        i := 1 ; while i < n do ( (     if (a[i+1] < min) then (     min := a[i+1] ) else skip )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     if (a[i+1] mod min /= 0) then (     break ) else skip )  ;     i := i + 1 ) ; 
    if (i < n) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(min) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in))){
      int n=Integer.parseInt(reader.readLine());
      TreeSet<Integer>odd=new TreeSet<>();
      TreeSet<Integer>even=new TreeSet<>();
      String line=reader.readLine();
      StringTokenizer tokenizer=new StringTokenizer(line);
      while(tokenizer.hasMoreTokens()){
        int value=Integer.parseInt(tokenizer.nextToken());
        if((value & 1)==0)even.add(value);
        else odd.add(value);
      }
      int number=0 ;
      boolean exists=true ;
      if(! odd.isEmpty())number=odd.first();
      else number=even.first();
      for(Integer curEven : even){
        if(curEven % number!=0){
          exists=false ;
          break ;
        }
      }
      if(exists)for(Integer curOdd : odd)if(curOdd % number!=0){
        exists=false ;
        break ;
      }
      if(exists)System.out.println(number);
      else System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var n : int ; n := (reader.readLine())->toInteger() ;
     var odd : Set(int) ; odd := Set{} ;
    var even : Set(int) ; even := Set{} ;
    var line : String ; line := reader.readLine() ;
    var tokenizer : OclIterator ; tokenizer := OclIterator.newOclIterator_String(line) ;
    while (tokenizer.hasNext()) do (     var value : int ; value := (tokenizer.next())->toInteger() ;
     if ((MathLib.bitwiseAnd(value,1)) = 0) then     even := even->including(value) ; else     odd := odd->including(value) ; ) ; 
    var number : int ; number := 0 ;
    var exists : boolean ; exists := true ;
    if (not(odd->isEmpty())) then     number := odd->first() else     number := even->first() ; ;  
    for (curEven : even) do ( (     if (curEven mod number /= 0) then (     exists := false ; 
     break ) else skip )  ) ; 
    if (exists) then     for (curOdd : odd) do (     if (curOdd mod number /= 0) then (     exists := false ; 
     break ) else skip ;  ) ; else skip ; 
    if (exists) then     OclFile["System.out"].println(number) else     OclFile["System.out"].println(-1) ; ;  
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class boringApartments800 {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int inp=sc.nextInt();
    while(inp-->0){
      int num=sc.nextInt();
      int val=num ;
      int digits=0 ;
      while(val>0){
        digits++;
        val/=10 ;
      }
      int res=((num-1)% 10)*10+((digits==1)? 1 :((digits==2)? 3 :((digits==3)? 6 : 10)));
      System.out.println(res);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class boringApartments800 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inp : int ; inp := sc.getCurrent()->toInteger() ;
         while (inp > 0) do (        inp := inp - 1 ;     skip ; (     var num : int ; num := sc.getCurrent()->toInteger() ;
     var val : int ; val := num ;
    var digits : int ; digits := 0 ;
    while (val > 0) do (     digits := digits + 1 ; 
     val := val/(10) ) ; 
    var res : int ; res := ((num - 1) mod 10) * 10 + (if (digits = 1) then 1 else (if (digits = 2) then 3 else (if (digits = 3) then 6 else 10 endif) endif) endif) ;
    OclFile["System.out"].println(res) ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class KsushaArray {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    Arrays.sort(a);
    int min=a[0];
    for(int value : a){
      if(value % min!=0){
        System.out.println(-1);
        return ;
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class KsushaArray {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var min : int ; min := a[0+1] ;
    for (value : a) do ( (     if (value mod min /= 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip )  ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int[] A ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    A=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
    }
    sc.close();
    int[] M=new int[N];
    int[] L=new int[N];
    int[] R=new int[N];
    L[0]=A[0];
    for(int i=1 ; i<N ; i++){
      L[i]=gcd(L[i-1],A[i]);
    }
    R[N-1]=A[N-1];
    for(int i=N-2 ; i>=0 ; i--){
      R[i]=gcd(R[i+1],A[i]);
    }
    int answer=Math.max(L[N-2],R[1]);
    for(int i=1 ; i<N-1 ; i++){
      ;
      answer=Math.max(answer,gcd(L[i-1],R[i+1]));
    }
    System.out.println(answer);
  }
  public static int gcd(int a,int b){
    int tmp ;
    if(b>a){
      tmp=a ;
      a=b ;
      b=tmp ;
    }
    if(b==0){
      return a ;
    }
    int r=-1 ;
    do {
      r=a % b ;
      a=b ;
      b=r ;
    }
    while(r!=0);
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute A : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    A := Integer.subrange(1,N)->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var M : Sequence(int) ; M := Integer.subrange(1,N)->collect(0) ;
    var L : Sequence(int) ; L := Integer.subrange(1,N)->collect(0) ;
    var R : Sequence(int) ; R := Integer.subrange(1,N)->collect(0) ;
    L[0+1] := A[0+1] ; 
        var i : int ; i := 1 ; while i < N do ( (     L[i+1] := gcd(L[i - 1+1], A[i+1]) )  ;     i := i + 1 ) ; 
    R[N - 1+1] := A[N - 1+1] ; 
        var i : int ; i := N - 2 ; while i >= 0 do ( (     R[i+1] := gcd(R[i + 1+1], A[i+1]) )  ;     i := i - 1 ) ; 
    var answer : int ; answer := Set{L[N - 2+1], R[1+1]}->max() ;
        var i : int ; i := 1 ; while i < N - 1 do ( (  
     answer := Set{answer, gcd(L[i - 1+1], R[i + 1+1])}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var tmp : int ;
     if (b > a) then (     tmp := a ; 
     a := b ; 
     b := tmp ) else skip ; 
    if (b = 0) then (     return a ) else skip ; 
    var r : int ; r := -1 ;
  while true do ((     r := a mod b ; 
     a := b ; 
     b := r ) ;
    if (r /= 0) then skip else break) ; 
    return a 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  private static final boolean TEST=false ;
  public static void main(String[] args){
    Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int n=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    System.out.println(solve(a));
    in.close();
  }
  private static int solve(int[] a){
    int ans=0 ;
    int[] l=new int[a.length];
    int[] r=new int[a.length];
    l[0]=a[0];
    for(int i=1 ; i<a.length-1 ; i++)l[i]=gcm(l[i-1],a[i]);
    r[r.length-1]=a[a.length-1];
    for(int i=r.length-2 ; i>0 ; i--)r[i]=gcm(r[i+1],a[i]);
    ans=Math.max(r[1],l[l.length-2]);
    for(int i=1 ; i<a.length-1 ; i++)ans=Math.max(ans,gcm(l[i-1],r[i+1]));
    return ans ;
  }
  private static int gcm(int a,int b){
    if(a==b)return a ;
    if(b==0)return a ;
    if(a==0)return b ;
    if(a>b)return gcm(a % b,b);
    else return gcm(a,b % a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute TEST : boolean := false;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(a)) ; 
    skip ; 
 );
  static   operation solve( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var l : Sequence(int) ; l := Integer.subrange(1,a->size())->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,a->size())->collect(0) ;
    l[0+1] := a[0+1] ; 
        var i : int ; i := 1 ; while i < a->size() - 1 do (     l[i+1] := gcm(l[i - 1+1], a[i+1]) ;  ;     i := i + 1 ) ; 
    r[r->size() - 1+1] := a[a->size() - 1+1] ; 
        var i : int ; i := r->size() - 2 ; while i > 0 do (     r[i+1] := gcm(r[i + 1+1], a[i+1]) ;  ;     i := i - 1 ) ; 
    ans := Set{r[1+1], l[l->size() - 2+1]}->max() ; 
        var i : int ; i := 1 ; while i < a->size() - 1 do (     ans := Set{ans, gcm(l[i - 1+1], r[i + 1+1])}->max() ;  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation gcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = b) then     return a else skip ; 
     if (b = 0) then     return a else skip ; 
     if (a = 0) then     return b else skip ; 
     if (a > b) then     return gcm(a mod b, b) else     return gcm(a, b mod a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      long[] a=IntStream.range(0,n).mapToLong(i->scanner.nextLong()).toArray();
      long[] l=new long[n+1];
      l[0]=0L ;
      IntStream.rangeClosed(1,n).forEach(i->l[i]=gcd(l[i-1],a[i-1]));
      long[] r=new long[n+1];
      r[n]=0L ;
      IntStream.rangeClosed(1,n).map(i->n-i).forEach(i->r[i]=gcd(r[i+1],a[i]));
      System.out.println(IntStream.range(0,n).mapToLong(i->gcd(l[i],r[i+1])).max().getAsLong());
    }
  }
  private static long gcd(long m,long n){
    if(0L==n){
      return m ;
    }
    return gcd(n,m % n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(0, n-1)->collect( _x1 | (lambda i : OclAny in scanner.getCurrent()->toLong())->apply(_x1) )->asSequence() ;
    var l : Sequence(long) ; l := Integer.subrange(1,n + 1)->collect(0) ;
    l[0+1] := 0L ; 
    for i : Integer.subrange(1, n) do
    (    l[i+1] := gcd(l[i - 1+1], a[i - 1+1])) ; 
    var r : Sequence(long) ; r := Integer.subrange(1,n + 1)->collect(0) ;
    r[n+1] := 0L ; 
    for i : Integer.subrange(1, n)->collect( _x1 | (lambda i : OclAny in n - i)->apply(_x1) ) do
    (    r[i+1] := gcd(r[i + 1+1], a[i+1])) ; 
    OclFile["System.out"].println(Integer.subrange(0, n-1)->collect( _x1 | (lambda i : OclAny in gcd(l[i+1], r[i + 1+1]))->apply(_x1) ).max().getAsLong()) ; 
 ))  );
  static   operation gcd( m : long, n : long) : long
  pre: true
  post: true
  activity: (     if (0L = n) then (     return m ) else skip ; 
     return gcd(n, m mod n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner cin=new Scanner(System.in);
    int n=cin.nextInt();
    int[] num=new int[n];
    for(int i=0 ; i<n ; i++){
      num[i]=cin.nextInt();
    }
    int[] right=new int[n+1];
    for(int i=n-1 ; i>0 ; i--){
      right[i]=calGCD(num[i],right[i+1]);
    }
    int res=0 ;
    int left=0 ;
    for(int i=0 ; i<n ; i++){
      res=Math.max(calGCD(left,right[i+1]),res);
      left=calGCD(left,num[i]);
    }
    System.out.println(res);
  }
  private static int calGCD(int a,int b){
    if(a==0 || b==0){
      return a==0 ? b : a ;
    }
    if(a>=b){
      return calGCD(b,a % b);
    }
    else {
      return calGCD(a,b % a);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := cin.getCurrent()->toInteger() ;
    var num : Sequence(int) ; num := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     num[i+1] := cin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var right : Sequence(int) ; right := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := n - 1 ; while i > 0 do ( (     right[i+1] := calGCD(num[i+1], right[i + 1+1]) )  ;     i := i - 1 ) ; 
    var res : int ; res := 0 ;
    var left : int ; left := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     res := Set{calGCD(left, right[i + 1+1]), res}->max() ; 
     left := calGCD(left, num[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static   operation calGCD( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0 or b = 0) then (     return if a = 0 then b else a endif ) else skip ; 
     if (a >= b) then (     return calGCD(b, a mod b) ) else (     return calGCD(a, b mod a) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Long>aList=new ArrayList<>();
    List<Long>gcdList=new ArrayList<>();
    int countOne=0 ;
    int countTwo=0 ;
    for(int i=0 ; i<n ; i++){
      long a=sc.nextInt();
      aList.add(a);
    }
    long prevGcd=aList.get(0);
    for(int i=0 ; i<n ; i++){
      long a=aList.get(i);
      prevGcd=gcd(a,prevGcd);
      gcdList.add(prevGcd);
    }
    long tmpGcd=gcdList.get(n-2);
    long rightGcd=aList.get(n-1);
    long maxResult=tmpGcd ;
    for(int i=n-2 ; i>=1 ; i--){
      long curGcd ;
      long leftGcd=gcdList.get(i-1);
      rightGcd=gcd(rightGcd,aList.get(i+1));
      curGcd=gcd(leftGcd,rightGcd);
      maxResult=Math.max(maxResult,curGcd);
    }
    rightGcd=gcd(rightGcd,aList.get(1));
    maxResult=Math.max(maxResult,rightGcd);
    System.out.println(maxResult);
  }
  private static long gcd(long m,long n){
    if(m<n)return gcd(n,m);
    if(n==0)return m ;
    return gcd(n,m % n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var aList : Sequence(long) ; aList := Sequence{} ;
    var gcdList : Sequence(long) ; gcdList := Sequence{} ;
    var countOne : int ; countOne := 0 ;
    var countTwo : int ; countTwo := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : long ; a := sc.getCurrent()->toInteger() ;
     aList := aList->including(a) )  ;     i := i + 1 ) ; 
    var prevGcd : long ; prevGcd := aList->at(0+1) ;
        var i : int ; i := 0 ; while i < n do ( (     var a : long ; a := aList->at(i+1) ;
     prevGcd := gcd(a, prevGcd) ; 
     gcdList := gcdList->including(prevGcd) )  ;     i := i + 1 ) ; 
    var tmpGcd : long ; tmpGcd := gcdList->at(n - 2+1) ;
    var rightGcd : long ; rightGcd := aList->at(n - 1+1) ;
    var maxResult : long ; maxResult := tmpGcd ;
        var i : int ; i := n - 2 ; while i >= 1 do ( (     var curGcd : long ;
     var leftGcd : long ; leftGcd := gcdList->at(i - 1+1) ;
    rightGcd := gcd(rightGcd, aList->at(i + 1+1)) ; 
    curGcd := gcd(leftGcd, rightGcd) ; 
    maxResult := Set{maxResult, curGcd}->max() ; 
 )  ;     i := i - 1 ) ; 
    rightGcd := gcd(rightGcd, aList->at(1+1)) ; 
    maxResult := Set{maxResult, rightGcd}->max() ; 
    OclFile["System.out"].println(maxResult) ; 
 );
  static   operation gcd( m : long, n : long) : long
  pre: true
  post: true
  activity: (     if (m < n) then     return gcd(n, m) else skip ; 
     if (n = 0) then     return m else skip ; 
     return gcd(n, m mod n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    System.out.println(1200>sc.nextInt()? "ABC" : "ARC");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if 1200 > sc.getCurrent()->toInteger() then "ABC" else "ARC" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=false ;
  private static PrintWriter _out=new PrintWriter(System.out);
  private static PrintWriter _err=new PrintWriter(System.err);
  private void solve(Scanner sc){
    int x=sc.nextInt();
    _out.println((x<1200 ? "ABC" : "ARC"));
  }
  private static BigInteger C(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    for(long i=r ; i>1 ; --i){
      res=res.divide(BigInteger.valueOf(i));
    }
    return res ;
  }
  private static BigInteger P(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    return res ;
  }
  public static void main(String[] args){
    long S=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    new Main().solve(sc);
    _out.flush();
    long G=System.currentTimeMillis();
    if(elapsed){
      _err.println((G-S)+"ms");
    }
    _err.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := false;
  static   attribute _out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute _err : OclFile := OclFile.newOclFile_Write(OclFile["System.err"]);
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var x : int ; x := sc.nextInt() ;
     skip );
  static   operation C( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
         var i : long ; i := r ; while i > 1 do ( (     res := res.divide((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation P( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    Main.newMain().solve(sc) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String nyu=sc.nextLine();
    int D=Integer.parseInt(nyu);
    if(D<1200){
      System.out.println("ABC");
    }
    else {
      System.out.println("ARC");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var nyu : String ; nyu := sc.nextLine() ;
     var D : int ; D := (nyu)->toInteger() ;
     if (D < 1200) then (     OclFile["System.out"].println("ABC") ) else (     OclFile["System.out"].println("ARC") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner in=new Scanner(System.in)){
      solve(in);
    }
  }
  private static void solve(Scanner in){
    System.out.println(in.nextInt()<1200 ? "ABC" : "ARC");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     execute solve(in) ))  );
  static   operation solve( in : OclFile) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if in.getCurrent()->toInteger() < 1200 then "ABC" else "ARC" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class boringAparments {
  public static int firstNSum(int n){
    return((n*(n+1))/2);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int sum=0 ;
      int no=sc.nextInt();
      int rem=no % 10 ;
      sum+=(rem-1)*10 ;
      int cnt=0 ;
      while(no>0){
        no/=10 ;
        cnt++;
      }
      sum+=firstNSum(cnt);
      System.out.println(sum);
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class boringAparments {
  static   operation firstNSum( n : int) : int
  pre: true
  post: true
  activity: (     return ((n * (n + 1)) / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var sum : int ; sum := 0 ;
     var no : int ; no := sc.getCurrent()->toInteger() ;
    var rem : int ; rem := no mod 10 ;
    sum := sum+((rem - 1) * 10) ; 
    var cnt : int ; cnt := 0 ;
    while (no > 0) do (     no := no/(10) ; 
     cnt := cnt + 1 ) ; 
    sum := sum+(firstNSum(cnt)) ; 
    OclFile["System.out"].println(sum) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int rate=sc.nextInt();
    sc.close();
    String ans=rate>=1200 ? "ARC" : "ABC" ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var rate : int ; rate := sc.getCurrent()->toInteger() ;
    skip ; 
    var ans : String ; ans := if rate >= 1200 then "ARC" else "ABC" endif ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  static final int maxElementValue=(int)Math.pow(10,9);
  public static void main(String[] args)throws IOException {
    try(BufferedReader console=new BufferedReader(new InputStreamReader(System.in))){
      console.readLine();
      int[] elements=Arrays.stream(console.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
      int[] rightDistance=new int[elements.length+1];
      rightDistance[rightDistance.length-1]=maxElementValue ;
      int[] leftDistance=new int[elements.length+1];
      leftDistance[0]=maxElementValue ;
      for(int i=rightDistance.length-2 ; i>=0 ; i--){
        if(elements[i]==0){
          rightDistance[i]=0 ;
        }
        else {
          rightDistance[i]=rightDistance[i+1]+1 ;
        }
      }
      for(int j=1 ; j<leftDistance.length ; j++){
        if(elements[j-1]==0){
          leftDistance[j]=0 ;
        }
        else {
          leftDistance[j]=leftDistance[j-1]+1 ;
        }
      }
      for(int i=0 ; i<elements.length ; i++){
        System.out.print(Math.min(rightDistance[i],leftDistance[i+1]));
        if(i+1<elements.length)System.out.print(" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute maxElementValue : int := 10->pow(9)->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var console : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     skip ; 
     var elements : Sequence(int) ; elements := stream(console.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var rightDistance : Sequence(int) ; rightDistance := Integer.subrange(1,elements->size() + 1)->collect(0) ;
    rightDistance[rightDistance->size() - 1+1] := maxElementValue ; 
    var leftDistance : Sequence(int) ; leftDistance := Integer.subrange(1,elements->size() + 1)->collect(0) ;
    leftDistance[0+1] := maxElementValue ; 
        var i : int ; i := rightDistance->size() - 2 ; while i >= 0 do ( (     if (elements[i+1] = 0) then (     rightDistance[i+1] := 0 ) else (     rightDistance[i+1] := rightDistance[i + 1+1] + 1 ) )  ;     i := i - 1 ) ; 
        var j : int ; j := 1 ; while j < leftDistance->size() do ( (     if (elements[j - 1+1] = 0) then (     leftDistance[j+1] := 0 ) else (     leftDistance[j+1] := leftDistance[j - 1+1] + 1 ) )  ;     j := j + 1 ) ; 
        var i : int ; i := 0 ; while i < elements->size() do ( (     OclFile["System.out"].print(Set{rightDistance[i+1], leftDistance[i + 1+1]}->min()) ; 
     if (i + 1 < elements->size()) then     OclFile["System.out"].print(" ") ; else skip )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countOperations(int n){
    int i=2 ;
    while((i*i)<n &&(n % i)>0)i+=1 ;
    if((i*i)>n)i=n ;
    return(1+(n-i)/2);
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(countOperations(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countOperations( n : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 2 ;
     while ((i * i) < n & (n mod i) > 0) do     i := i+(1) ; ; 
     if ((i * i) > n) then     i := n ; else skip ; 
     return (1 + (n - i) / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(countOperations(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.TreeSet ;
public class DistancesToZero1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    TreeSet<Integer>set=new TreeSet<>();
    set.add(1000000000);
    set.add(-1000000000);
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      if(arr[i]==0){
        set.add(i);
      }
    }
    for(int i=0 ; i<n ; i++){
      if(arr[i]==0){
        System.out.print(0+" ");
      }
      else {
        int a=Math.abs(i-set.floor(i));
        int b=Math.abs(i-set.ceiling(i));
        int ans=Math.min(a,b);
        System.out.print(ans+" ");
      }
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class DistancesToZero1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
    set := set->including(1000000000) ; 
    set := set->including(-1000000000) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr[i+1] = 0) then (     set := set->including(i) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 0) then (     OclFile["System.out"].print(0 + " ") ) else (     var a : int ; a := if i - set.floor(i) < 0 then -(i - set.floor(i)) else i - set.floor(i) endif ;
     var b : int ; b := if i - set.ceiling(i) < 0 then -(i - set.ceiling(i)) else i - set.ceiling(i) endif ;
     var ans : int ; ans := Set{a, b}->min() ;
     OclFile["System.out"].print(ans + " ") ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int smallest(int x,int y,int z){
    int c=0 ;
    while(x!=0 && y!=0 && z!=0){
      x--;
      y--;
      z--;
      c++;
    }
    return c ;
  }
  public static void main(String[] args){
    int x=12,y=15,z=5 ;
    System.out.printf("Minimum of 3"+" numbers is %d",smallest(x,y,z));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation smallest( x : int, y : int, z : int) : int
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
     while (x /= 0 & y /= 0 & z /= 0) do (     x := x - 1 ; 
     y := y - 1 ; 
     z := z - 1 ; 
     c := c + 1 ) ; 
     return c );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 12 ;
    var y : int ; y := 15 ;
    var z : int ; z := 5 ;
     OclFile["System.out"].printf("Minimum of 3" + " numbers is %d", smallest(x, y, z)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int c1=scan.nextInt();
    int c5=scan.nextInt();
    int c10=scan.nextInt();
    int c50=scan.nextInt();
    int c100=scan.nextInt();
    int c500=scan.nextInt();
    if(c1+c5*5+c10*10+c50*50+c100*100+c500*500<1000){
      System.out.println("0");
    }
    else {
      System.out.println("1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c1 : int ; c1 := scan.getCurrent()->toInteger() ;
    var c5 : int ; c5 := scan.getCurrent()->toInteger() ;
    var c10 : int ; c10 := scan.getCurrent()->toInteger() ;
    var c50 : int ; c50 := scan.getCurrent()->toInteger() ;
    var c100 : int ; c100 := scan.getCurrent()->toInteger() ;
    var c500 : int ; c500 := scan.getCurrent()->toInteger() ;
    if (c1 + c5 * 5 + c10 * 10 + c50 * 50 + c100 * 100 + c500 * 500 < 1000) then (     OclFile["System.out"].println("0") ) else (     OclFile["System.out"].println("1") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int[] c ;
    int i ;
    c=new int[6];
    for(i=0 ; i<6 ; i++)c[i]=sc.nextInt();
    if(c[0]+c[1]*5+c[2]*10+c[3]*50+c[4]*100+c[5]*500>=1000)out.println("1");
    else out.println("0");
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var c : Sequence(int) ;
    var i : int ;
    c := Integer.subrange(1,6)->collect(0) ; 
        i := 0 ; while i < 6 do (     c[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
    if (c[0+1] + c[1+1] * 5 + c[2+1] * 10 + c[3+1] * 50 + c[4+1] * 100 + c[5+1] * 500 >= 1000) then     out.println("1") else     out.println("0") ; ;  
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  static final int[] coins=new int[] {
    1,5,10,50,100,500 };
    public static void main(String[] args)throws IOException {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String line ;
      String[] words ;
      StringTokenizer st=new StringTokenizer(br.readLine());
      int sum=0 ;
      for(int i=0 ; i<coins.length ; i++){
        sum+=parseInt(st.nextToken())*coins[i];
      }
      System.out.println(sum<1000 ? 0 : 1);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute coins : Sequence(int) := Sequence{1,5,10,50,100,500};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < coins->size() do ( (     sum := sum+((st.next() + "")->toInteger() * coins[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if sum < 1000 then 0 else 1 endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  int c1 ;
  int c5 ;
  int c10 ;
  int c50 ;
  int c100 ;
  int c500 ;
  int sum ;
  Main(){
    Scanner sc=new Scanner(System.in);
    c1=sc.nextInt();
    c5=sc.nextInt();
    c10=sc.nextInt();
    c50=sc.nextInt();
    c100=sc.nextInt();
    c500=sc.nextInt();
    c1=1*c1 ;
    c5=5*c5 ;
    c10=10*c10 ;
    c50=50*c50 ;
    c100=100*c100 ;
    c500=500*c500 ;
    sum=c1+c5+c10+c50+c100+c500 ;
    if(sum>=1000){
      System.out.println("1");
    }
    else {
      System.out.println("0");
    }
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute c1 : int;
   attribute c5 : int;
   attribute c10 : int;
   attribute c50 : int;
   attribute c100 : int;
   attribute c500 : int;
   attribute sum : int;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     c1 := sc.getCurrent()->toInteger() ; 
    c5 := sc.getCurrent()->toInteger() ; 
    c10 := sc.getCurrent()->toInteger() ; 
    c50 := sc.getCurrent()->toInteger() ; 
    c100 := sc.getCurrent()->toInteger() ; 
    c500 := sc.getCurrent()->toInteger() ; 
    c1 := 1 * c1 ; 
    c5 := 5 * c5 ; 
    c10 := 10 * c10 ; 
    c50 := 50 * c50 ; 
    c100 := 100 * c100 ; 
    c500 := 500 * c500 ; 
    sum := c1 + c5 + c10 + c50 + c100 + c500 ; 
    if (sum >= 1000) then (     OclFile["System.out"].println("1") ) else (     OclFile["System.out"].println("0") ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static final int[] coins={
    1,5,10,50,100,500 };
    public static void main(String[] args){
      int sum=0 ;
      try(Scanner scn=new Scanner(System.in)){
        for(int i=0 ; i<coins.length ; i++){
          sum+=coins[i]*scn.nextInt();
        }
      }
      System.out.println(sum<1000 ? 0 : 1);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute coins : Sequence(int) := Sequence{1,5,10,50,100,500};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     try (    var scn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (         var i : int ; i := 0 ; while i < coins->size() do ( (     sum := sum+(coins[i+1] * scn.getCurrent()->toInteger()) )  ;     i := i + 1 ) ))  
     OclFile["System.out"].println(if sum < 1000 then 0 else 1 endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Another {
  public static void main(String[] args)throws IOException {
    FastReader in=new FastReader();
    PrintWriter pw=new PrintWriter(System.out);
    long m=in.nextLong();
    long R=in.nextLong();
    pw.printf("%.12f\n",(2+2.*(m-1)*m*(m+1)/3/m/m-2*(2-Math.sqrt(2))+(2-Math.sqrt(2))*(2*m+2*(m-1))/m/m)*R);
    pw.flush();
    pw.close();
  }
  static class FastReader {
    StringTokenizer st ;
    BufferedReader br ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public String next()throws IOException {
      if(st==null || ! st.hasMoreTokens()){
        st=new StringTokenizer(br.readLine());
      }
      return st.nextToken();
    }
    public boolean hasNext()throws IOException {
      if(st!=null && st.hasMoreTokens()){
        return true ;
      }
      String s=br.readLine();
      if(s==null || s.isEmpty()){
        return false ;
      }
      st=new StringTokenizer(s);
      return true ;
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Another {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var m : long ; m := in.nextLong() ;
    var R : long ; R := in.nextLong() ;
    skip ; 
    skip ; 
    skip ; 
 );
  static class FastReader {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (st = null or not(st.hasNext())) then (     st := OclIterator.newOclIterator_String(br.readLine()) ) else skip ; 
     return st.next() );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     if (st /= null & st.hasNext()) then (     return true ) else skip ; 
     var s : String ; s := br.readLine() ;
    if (s = null or s->isEmpty()) then (     return false ) else skip ; 
    st := OclIterator.newOclIterator_String(s) ; 
    return true 
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Test {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testcases=sc.nextInt();
    while(testcases-->0){
      int n=sc.nextInt();
      int rem=n % 10 ;
      int sum=0 ;
      switch(rem-1){
        case 0 : break ;
        case 1 : sum+=10 ;
        break ;
        case 2 : sum+=20 ;
        break ;
        case 3 : sum+=30 ;
        break ;
        case 4 : sum+=40 ;
        break ;
        case 5 : sum+=50 ;
        break ;
        case 6 : sum+=60 ;
        break ;
        case 7 : sum+=70 ;
        break ;
        case 8 : sum+=80 ;
        break ;
      }
      int digit=0 ;
      while(n>0){
        digit++;
        n/=10 ;
      }
      switch(digit){
        case 1 : sum+=1 ;
        break ;
        case 2 : sum+=3 ;
        break ;
        case 3 : sum+=6 ;
        break ;
        case 4 : sum+=10 ;
        break ;
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testcases : int ; testcases := sc.getCurrent()->toInteger() ;
         while (testcases > 0) do (        testcases := testcases - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var rem : int ; rem := n mod 10 ;
    var sum : int ; sum := 0 ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (rem - 1) ; 
       if _switchval = 0 then
     break 
   else skip ;
       if _switchval = 1 then
     sum := sum+(10) ; 
    break 
   else skip ;
       if _switchval = 2 then
     sum := sum+(20) ; 
    break 
   else skip ;
       if _switchval = 3 then
     sum := sum+(30) ; 
    break 
   else skip ;
       if _switchval = 4 then
     sum := sum+(40) ; 
    break 
   else skip ;
       if _switchval = 5 then
     sum := sum+(50) ; 
    break 
   else skip ;
       if _switchval = 6 then
     sum := sum+(60) ; 
    break 
   else skip ;
       if _switchval = 7 then
     sum := sum+(70) ; 
    break 
   else skip ;
       if _switchval = 8 then
     sum := sum+(80) ; 
    break 
   else skip ;
 )
    var digit : int ; digit := 0 ;
    while (n > 0) do (     digit := digit + 1 ; 
     n := n/(10) ) ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (digit) ; 
       if _switchval = 1 then
     sum := sum+(1) ; 
    break 
   else skip ;
       if _switchval = 2 then
     sum := sum+(3) ; 
    break 
   else skip ;
       if _switchval = 3 then
     sum := sum+(6) ; 
    break 
   else skip ;
       if _switchval = 4 then
     sum := sum+(10) ; 
    break 
   else skip ;
 )
    OclFile["System.out"].println(sum) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static double sqrt2=Math.sqrt(2);
  static double GetSum(Long n){
    return(2+2*sqrt2)*n+n*(n-1);
  }
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    Long m=cin.nextLong(),R=cin.nextLong();
    double ans=0 ;
    for(int i=1 ; i<=m ; i++){
      ans+=2 ;
      if(i>1)ans+=sqrt2+2+GetSum((long)i-2);
      if(i<m)ans+=sqrt2+2+GetSum(m-i-1);
    }
    ans=ans*R/m/m ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sqrt2 : double := (2)->sqrt();
  static   operation GetSum( n : long) : double
  pre: true
  post: true
  activity: (     return (2 + 2 * sqrt2) * n + n * (n - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : long ; m := cin.getCurrent()->toLong() ;
    var R : long ; R := cin.getCurrent()->toLong() ;
    var ans : double ; ans := 0 ;
        var i : int ; i := 1 ; while i <= m do ( (     ans := ans+(2) ; 
     if (i > 1) then     ans := ans+(sqrt2 + 2 + GetSum(i->oclAsType(long) - 2)) ; else skip ; 
     if (i < m) then     ans := ans+(sqrt2 + 2 + GetSum(m - i - 1)) ; else skip )  ;     i := i + 1 ) ; 
    ans := ans * R / m / m ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  static void exec(Scanner in,PrintWriter out){
    in.nextInt();
    int Q=in.nextInt();
    String S=in.next();
    int[] t=new int[S.length()];
    for(int i=0 ; i<t.length-1 ; i+=1){
      if(S.charAt(i)=='A' && S.charAt(i+1)=='C'){
        t[i+1]=t[i]+1 ;
      }
      else {
        t[i+1]=t[i];
      }
    }
    for(int i=0 ; i<Q ; i+=1){
      int l=in.nextInt();
      int r=in.nextInt();
      out.println(t[r-1]-t[l-1]);
    }
  }
  public static void main(String[] args){
    PrintWriter w=new PrintWriter(System.out);
    exec(new Scanner(System.in),w);
    w.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation exec( in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     in.nextInt() ; 
     var Q : int ; Q := in.nextInt() ;
    var S : String ; S := in.next() ;
    var t : Sequence(int) ; t := Integer.subrange(1,S->size())->collect(0) ;
        var i : int ; i := 0 ; while i < t->size() - 1 do ( (     if (S->at(i+1) = 'A' & S->at(i + 1+1) = 'C') then (     t[i + 1+1] := t[i+1] + 1 ) else (     t[i + 1+1] := t[i+1] ) )  ;     i := i+(1) ) ; 
        var i : int ; i := 0 ; while i < Q do ( (     var l : int ; l := in.nextInt() ;
     var r : int ; r := in.nextInt() ;
     out.println(t[r - 1+1] - t[l - 1+1]) )  ;     i := i+(1) ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var w : OclFile ; w := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     execute exec(OclFile.newOclFile_Read(OclFile["System.in"]), w) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.math.BigDecimal ;
import java.math.RoundingMode ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(new BufferedInputStream(System.in));
    int m=cin.nextInt();
    BigDecimal R=cin.nextBigDecimal();
    BigDecimal ans=BigDecimal.ZERO,TWO=BigDecimal.valueOf(2),s2=new BigDecimal(Math.sqrt(2));
    for(int i=0 ; i!=m ; ++i){
      BigDecimal v=BigDecimal.ONE ;
      BigDecimal u=BigDecimal.valueOf(i);
      u=u.add(BigDecimal.ONE);
      BigDecimal dis=BigDecimal.ZERO ;
      if(u==v)dis=R.multiply(TWO);
      else if(i==1)dis=R.multiply(BigDecimal.valueOf(i*2)).add(s2.multiply(R));
      else dis=R.multiply(BigDecimal.valueOf(i*2-2)).add(s2.multiply(R.multiply(TWO)));
      if(i!=0)ans=ans.add(dis.multiply(BigDecimal.valueOf((m-i)*2)));
      else ans=ans.add(dis.multiply(BigDecimal.valueOf(m-i)));
    }
    ans=ans.divide(BigDecimal.valueOf(m),1000,RoundingMode.HALF_DOWN);
    ans=ans.divide(BigDecimal.valueOf(m),50,RoundingMode.HALF_DOWN);
    System.out.println(ans);
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var m : int ; m := cin.getCurrent()->toInteger() ;
    var R : double ; R := cin.nextBigDecimal() ;
    var ans : double ; ans := 0.0 ;
    var TWO : double ; TWO := (2 + "")->toReal() ;
    var s2 : double ; s2 := double((2)->sqrt()) ;
        var i : int ; i := 0 ; while i /= m do ( (     var v : double ; v := 1.0 ;
     var u : double ; u := (i + "")->toReal() ;
    u := u->excludes(1.0) ; 
    var dis : double ; dis := 0.0 ;
    if (u = v) then     dis := R.multiply(TWO) else     if (i = 1) then     dis := R.multiply((i * 2 + "")->toReal())->excludes(s2.multiply(R)) else     dis := R.multiply((i * 2 - 2 + "")->toReal())->excludes(s2.multiply(R.multiply(TWO))) ; ;  ;  
    if (i /= 0) then     ans := ans->excludes(dis.multiply(((m - i) * 2 + "")->toReal())) else     ans := ans->excludes(dis.multiply((m - i + "")->toReal())) ; ;  
 )  ;     i := i + 1 ) ; 
    ans := ans.divide((m + "")->toReal(), 1000, RoundingMode.HALF_DOWN) ; 
    ans := ans.divide((m + "")->toReal(), 50, RoundingMode.HALF_DOWN) ; 
    OclFile["System.out"].println(ans) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.math.BigDecimal ;
import java.math.RoundingMode ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(new BufferedInputStream(System.in));
    int m=cin.nextInt();
    BigDecimal R=cin.nextBigDecimal();
    BigDecimal ans=BigDecimal.ZERO,TWO=BigDecimal.valueOf(2),s2=new BigDecimal(Math.sqrt(2));
    for(int i=0 ; i!=m ; ++i){
      BigDecimal v=BigDecimal.ONE ;
      BigDecimal u=BigDecimal.valueOf(i);
      u=u.add(BigDecimal.ONE);
      BigDecimal dis=BigDecimal.ZERO ;
      if(u==v)dis=R.multiply(TWO);
      else if(i==1)dis=R.multiply(BigDecimal.valueOf(i*2)).add(s2.multiply(R));
      else dis=R.multiply(BigDecimal.valueOf(i*2-2)).add(s2.multiply(R.multiply(TWO)));
      if(i!=0)ans=ans.add(dis.multiply(BigDecimal.valueOf((m-i)*2)));
      else ans=ans.add(dis.multiply(BigDecimal.valueOf(m-i)));
    }
    ans=ans.divide(BigDecimal.valueOf(m),1000,RoundingMode.HALF_DOWN);
    ans=ans.divide(BigDecimal.valueOf(m),50,RoundingMode.HALF_DOWN);
    System.out.println(ans);
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var m : int ; m := cin.getCurrent()->toInteger() ;
    var R : double ; R := cin.nextBigDecimal() ;
    var ans : double ; ans := 0.0 ;
    var TWO : double ; TWO := (2 + "")->toReal() ;
    var s2 : double ; s2 := double((2)->sqrt()) ;
        var i : int ; i := 0 ; while i /= m do ( (     var v : double ; v := 1.0 ;
     var u : double ; u := (i + "")->toReal() ;
    u := u->excludes(1.0) ; 
    var dis : double ; dis := 0.0 ;
    if (u = v) then     dis := R.multiply(TWO) else     if (i = 1) then     dis := R.multiply((i * 2 + "")->toReal())->excludes(s2.multiply(R)) else     dis := R.multiply((i * 2 - 2 + "")->toReal())->excludes(s2.multiply(R.multiply(TWO))) ; ;  ;  
    if (i /= 0) then     ans := ans->excludes(dis.multiply(((m - i) * 2 + "")->toReal())) else     ans := ans->excludes(dis.multiply((m - i + "")->toReal())) ; ;  
 )  ;     i := i + 1 ) ; 
    ans := ans.divide((m + "")->toReal(), 1000, RoundingMode.HALF_DOWN) ; 
    ans := ans.divide((m + "")->toReal(), 50, RoundingMode.HALF_DOWN) ; 
    OclFile["System.out"].println(ans) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countCubes(int a,int b){
    return(int)(Math.floor(Math.cbrt(b))-Math.ceil(Math.cbrt(a))+1);
  }
  public static void main(String[] args){
    int a=7,b=28 ;
    System.out.print("Count of cubes is "+countCubes(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countCubes( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return (((b)->cbrt())->floor() - ((a)->cbrt())->ceil() + 1)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 7 ;
    var b : int ; b := 28 ;
     OclFile["System.out"].print("Count of cubes is " + countCubes(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int D=scanner.nextInt();
      int N=scanner.nextInt();
      if((D | N)==0)break ;
      int[] a=new int[N];
      int[] e=new int[N];
      int[] r=new int[N];
      for(int i=0 ; i<N ; i++){
        int aa=scanner.nextInt();
        int ee=scanner.nextInt();
        int rr=scanner.nextInt();
        a[i]=aa ;
        e[i]=ee ;
        r[i]=rr ;
      }
      int[][] dp=new int[D+1][101];
      for(int[] d : dp)Arrays.fill(d,INF);
      dp[D][0]=0 ;
      for(int i=D ; i>0 ; i--){
        for(int j=0 ; j<=100 ; j++){
          if(dp[i][j]==INF)continue ;
          for(int k=0 ; k<N ; k++){
            if(j<r[k])continue ;
            dp[Math.max(0,i-a[k])][Math.min(100,j+e[k])]=Math.min(dp[Math.max(0,i-a[k])][Math.min(100,j+e[k])],dp[i][j]+1);
          }
        }
      }
      int ret=INF ;
      for(int i=0 ; i<101 ; i++)ret=Math.min(ret,dp[0][i]);
      System.out.println(ret==INF ? "NA" : ret);
    }
  }
  int INF=1<<30 ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var D : int ; D := scanner.getCurrent()->toInteger() ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(D,N)) = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var e : Sequence(int) ; e := Integer.subrange(1,N)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     var aa : int ; aa := scanner.getCurrent()->toInteger() ;
     var ee : int ; ee := scanner.getCurrent()->toInteger() ;
    var rr : int ; rr := scanner.getCurrent()->toInteger() ;
    a[i+1] := aa ; 
    e[i+1] := ee ; 
    r[i+1] := rr ; 
 )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,D + 1)->collect(Integer.subrange(1,101)->collect(0)) ;
    for (d : dp) do (     d := d->collect(INF) ;  ) ; 
    dp[D+1][0+1] := 0 ; 
        var i : int ; i := D ; while i > 0 do ( (         var j : int ; j := 0 ; while j <= 100 do ( (     if (dp[i+1][j+1] = INF) then     continue else skip ; 
         var k : int ; k := 0 ; while k < N do ( (     if (j < r[k+1]) then     continue else skip ; 
     dp[Set{0, i - a[k+1]}->max()+1][Set{100, j + e[k+1]}->min()+1] := Set{dp[Set{0, i - a[k+1]}->max()+1][Set{100, j + e[k+1]}->min()+1], dp[i+1][j+1] + 1}->min() )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    var ret : int ; ret := INF ;
        var i : int ; i := 0 ; while i < 101 do (     ret := Set{ret, dp[0+1][i+1]}->min() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if ret = INF then "NA" else ret endif) ; 
 ) );
   attribute INF : int := (1*(2->pow(30)))->oclAsType(long);
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p012 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p012().run());
  }
  public String run(){
    int triangle=0 ;
    for(int i=1 ; ; i++){
      if(Integer.MAX_VALUE-triangle<i)throw new ArithmeticException("Overflow");
      triangle+=i ;
      if(countDivisors(triangle)>500)return Integer.toString(triangle);
    }
  }
  private static int countDivisors(int n){
    int count=0 ;
    int end=Library.sqrt(n);
    for(int i=1 ; i<end ; i++){
      if(n % i==0)count+=2 ;
    }
    if(end*end==n)count++;
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p012 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p012.newp012().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var triangle : int ; triangle := 0 ;
         var i : int ; i := 1 ; while true do ( (     if (2147483647 - triangle < i) then     error ArithmeticException("Overflow") ; else skip ; 
     triangle := triangle+(i) ; 
     if (countDivisors(triangle) > 500) then     return ((triangle) + "") else skip )  ;     i := i + 1 ) );
  static   operation countDivisors( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var end : int ; end := Library.sqrt(n) ;
        var i : int ; i := 1 ; while i < end do ( (     if (n mod i = 0) then     count := count+(2) ; else skip )  ;     i := i + 1 ) ; 
    if (end * end = n) then     count := count + 1 ; else skip ; 
    return count 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findDelta(int a,int b,int c,int d){
    return(b*c-a*d)/(d-c);
  }
  public static void main(String args[]){
    int a=3,b=9,c=3,d=5 ;
    System.out.print("\u0394X="+findDelta(a,b,c,d));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findDelta( a : int, b : int, c : int, d : int) : int
  pre: true
  post: true
  activity: (     return (b * c - a * d) / (d - c) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var b : int ; b := 9 ;
    var c : int ; c := 3 ;
    var d : int ; d := 5 ;
     OclFile["System.out"].print("\u0394X=" + findDelta(a, b, c, d)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_Boring_Apartments {
  public static void main(String[] args){
    Scanner sn=new Scanner(System.in);
    int t=sn.nextInt();
    while(t-->0){
      int n=sn.nextInt();
      int n1=n ;
      n=n % 10 ;
      int l=0 ;
      while(n1>0){
        l=l+1 ;
        n1/=10 ;
      }
      int ans=(10*(n-1)+(l*(l+1)/2));
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Boring_Apartments {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sn : OclFile ; sn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sn.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sn.getCurrent()->toInteger() ;
     var n1 : int ; n1 := n ;
    n := n mod 10 ; 
    var l : int ; l := 0 ;
    while (n1 > 0) do (     l := l + 1 ; 
     n1 := n1/(10) ) ; 
    var ans : int ; ans := (10 * (n - 1) + (l * (l + 1) / 2)) ;
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.io.StringReader ;
import java.util.StringTokenizer ;
public class Main implements Runnable {
  int[] ans_ar ;
  public static void main(String[] args){
    new Thread(null,new Main(),"",32*1024*1024).start();
  }
  public void run(){
    FastScanner sc=new FastScanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=Integer.parseInt(sc.next());
    int q=Integer.parseInt(sc.next());
    String str=sc.next();
    char[] c=str.toCharArray();
    int[] ar=new int[n];
    int tmp=0 ;
    ar[0]=0 ;
    for(int i=1 ; i<n ; i++){
      if(c[i-1]=='A' && c[i]=='C'){
        tmp++;
      }
      ar[i]=tmp ;
    }
    for(int i=0 ; i<q ; i++){
      int l=Integer.parseInt(sc.next())-1 ;
      int r=Integer.parseInt(sc.next())-1 ;
      out.println(ar[r]-ar[l]);
    }
    out.flush();
  }
  static class FastScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public FastScanner(String in){
      StringReader sr=new StringReader(in);
      reader=new BufferedReader(new BufferedReader(sr));
      tokenizer=null ;
    }
    public FastScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
      tokenizer=null ;
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
   attribute ans_ar : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(null, Main.newMain(), "", 32 * 1024 * 1024).start() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (sc.next())->toInteger() ;
    var q : int ; q := (sc.next())->toInteger() ;
    var str : String ; str := sc.next() ;
    var c : Sequence(String) ; c := str->characters() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
    var tmp : int ; tmp := 0 ;
    ar[0+1] := 0 ; 
        var i : int ; i := 1 ; while i < n do ( (     if (c[i - 1+1] = 'A' & c[i+1] = 'C') then (     tmp := tmp + 1 ) else skip ; 
     ar[i+1] := tmp )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var l : int ; l := (sc.next())->toInteger() - 1 ;
     var r : int ; r := (sc.next())->toInteger() - 1 ;
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class FastScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newFastScanner( in : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : String) : void
  pre: true  post: true
  activity: (     var sr : StringReader ; sr := StringReader.newStringReader(in) ;
     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(sr)) ; 
     tokenizer := null );
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int replaceDigit(int x,int d1,int d2){
    int result=0,multiply=1 ;
    while(x % 10>0){
      int remainder=x % 10 ;
      if(remainder==d1)result=result+d2*multiply ;
      else result=result+remainder*multiply ;
      multiply*=10 ;
      x=x/10 ;
    }
    return result ;
  }
  public static void main(String[] args){
    int x=645,d1=6,d2=5 ;
    System.out.println(replaceDigit(x,d1,d2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation replaceDigit( x : int, d1 : int, d2 : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
    var multiply : int ; multiply := 1 ;
     while (x mod 10 > 0) do (     var remainder : int ; remainder := x mod 10 ;
     if (remainder = d1) then     result := result + d2 * multiply else     result := result + remainder * multiply ; ;  
     multiply := multiply*(10) ; 
     x := x / 10 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 645 ;
    var d1 : int ; d1 := 6 ;
    var d2 : int ; d2 := 5 ;
     OclFile["System.out"].println(replaceDigit(x, d1, d2)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int h=scanner.nextInt();
    int w=scanner.nextInt();
    int n=scanner.nextInt();
    int sr=scanner.nextInt();
    int sc=scanner.nextInt();
    String s=scanner.next();
    String t=scanner.next();
    boolean end=false ;
    int usafe=1 ;
    int dsafe=h ;
    for(int i=n-1 ; i>=0 ; i--){
      if(s.charAt(i)=='U'){
        usafe++;
      }
      else if(s.charAt(i)=='D'){
        dsafe--;
      }
      if(usafe>dsafe){
        end=true ;
        break ;
      }
      if(i>0){
        if(t.charAt(i-1)=='U'){
          dsafe=Math.min(dsafe+1,h);
        }
        else if(t.charAt(i-1)=='D'){
          usafe=Math.max(usafe-1,1);
        }
      }
    }
    int lsafe=1 ;
    int rsafe=w ;
    for(int i=n-1 ; i>=0 ; i--){
      if(s.charAt(i)=='L'){
        lsafe++;
      }
      else if(s.charAt(i)=='R'){
        rsafe--;
      }
      if(lsafe>rsafe){
        end=true ;
        break ;
      }
      if(i>0){
        if(t.charAt(i-1)=='L'){
          rsafe=Math.min(rsafe+1,w);
        }
        else if(t.charAt(i-1)=='R'){
          lsafe=Math.max(lsafe-1,1);
        }
      }
    }
    if(sr>=usafe && sr<=dsafe && sc>=lsafe && sc<=rsafe && ! end){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := scanner.getCurrent()->toInteger() ;
    var w : int ; w := scanner.getCurrent()->toInteger() ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var sr : int ; sr := scanner.getCurrent()->toInteger() ;
    var sc : int ; sc := scanner.getCurrent()->toInteger() ;
    var s : String ; s := scanner.getCurrent() ;
    var t : String ; t := scanner.getCurrent() ;
    var end : boolean ; end := false ;
    var usafe : int ; usafe := 1 ;
    var dsafe : int ; dsafe := h ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (s->at(i+1) = 'U') then (     usafe := usafe + 1 ) else     if (s->at(i+1) = 'D') then (     dsafe := dsafe - 1 ) else skip ; ;  
     if (usafe > dsafe) then (     end := true ; 
     break ) else skip ; 
     if (i > 0) then (     if (t->at(i - 1+1) = 'U') then (     dsafe := Set{dsafe + 1, h}->min() ) else     if (t->at(i - 1+1) = 'D') then (     usafe := Set{usafe - 1, 1}->max() ) else skip ; ) else skip )  ;     i := i - 1 ) ; 
    var lsafe : int ; lsafe := 1 ;
    var rsafe : int ; rsafe := w ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (s->at(i+1) = 'L') then (     lsafe := lsafe + 1 ) else     if (s->at(i+1) = 'R') then (     rsafe := rsafe - 1 ) else skip ; ;  
     if (lsafe > rsafe) then (     end := true ; 
     break ) else skip ; 
     if (i > 0) then (     if (t->at(i - 1+1) = 'L') then (     rsafe := Set{rsafe + 1, w}->min() ) else     if (t->at(i - 1+1) = 'R') then (     lsafe := Set{lsafe - 1, 1}->max() ) else skip ; ) else skip )  ;     i := i - 1 ) ; 
    if (sr >= usafe & sr <= dsafe & sc >= lsafe & sc <= rsafe & not(end)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int h=in.nextInt();
    int w=in.nextInt();
    int n=in.nextInt();
    int sr=in.nextInt();
    int sc=in.nextInt();
    char[] s=in.next().toCharArray();
    char[] t=in.next().toCharArray();
    int l=0,r=0,u=0,d=0 ;
    int L=sc,R=w-sc+1,U=sr,D=h-sr+1 ;
    boolean ans=false ;
    for(int i=0 ; i<n ; i++){
      if(s[i]=='L')l++;
      if(s[i]=='R')r++;
      if(s[i]=='U')u++;
      if(s[i]=='D')d++;
      if(L<=l || R<=r || U<=u || D<=d){
        ans=true ;
        break ;
      }
      if(t[i]=='L' &&(0<r || Math.abs(r)<L-1))r--;
      if(t[i]=='R' &&(0<l || Math.abs(l)<R-1))l--;
      if(t[i]=='U' &&(0<d || Math.abs(d)<U-1))d--;
      if(t[i]=='D' &&(0<u || Math.abs(u)<D-1))u--;
    }
    System.out.println(ans ? "NO" : "YES");
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := in.getCurrent()->toInteger() ;
    var w : int ; w := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var sr : int ; sr := in.getCurrent()->toInteger() ;
    var sc : int ; sc := in.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := in.getCurrent()->characters() ;
    var t : Sequence(String) ; t := in.getCurrent()->characters() ;
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    var u : int ; u := 0 ;
    var d : int ; d := 0 ;
    var L : int ; L := sc ;
    var R : int ; R := w - sc + 1 ;
    var U : int ; U := sr ;
    var D : int ; D := h - sr + 1 ;
    var ans : boolean ; ans := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] = 'L') then     l := l + 1 ; else skip ; 
     if (s[i+1] = 'R') then     r := r + 1 ; else skip ; 
    if (s[i+1] = 'U') then     u := u + 1 ; else skip ; 
    if (s[i+1] = 'D') then     d := d + 1 ; else skip ; 
    if (L <= l or R <= r or U <= u or D <= d) then (     ans := true ; 
     break ) else skip ; 
    if (t[i+1] = 'L' & (0 < r or if r < 0 then -(r) else r endif < L - 1)) then     r := r - 1 ; else skip ; 
    if (t[i+1] = 'R' & (0 < l or if l < 0 then -(l) else l endif < R - 1)) then     l := l - 1 ; else skip ; 
    if (t[i+1] = 'U' & (0 < d or if d < 0 then -(d) else d endif < U - 1)) then     d := d - 1 ; else skip ; 
    if (t[i+1] = 'D' & (0 < u or if u < 0 then -(u) else u endif < D - 1)) then     u := u - 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if ans then "NO" else "YES" endif) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int H=scanner.nextInt();
    int W=scanner.nextInt();
    int N=scanner.nextInt();
    int sr=scanner.nextInt();
    int sc=scanner.nextInt();
    char[] s=scanner.next().toCharArray();
    char[] t=scanner.next().toCharArray();
    if(solve(H,W,N,sr,sc,s,t)){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
    }
  }
  private static boolean solve(int H,int W,int N,int sr,int sc,char[] s,char[] t){
    int[] rem=new int[] {
      sc,W-sc+1,sr,H-sr+1 };
      int[] max=new int[] {
        W,W,H,H };
        char[] dir=new char[] {
          'L','R','U','D' };
          char[] otherdir=new char[] {
            'R','L','D','U' };
            for(int i=0 ; i<4 ; i++){
              int r=rem[i];
              int m=max[i];
              char d=dir[i];
              char o=otherdir[i];
              for(int j=0 ; j<N ; j++){
                if(s[j]==d)r--;
                if(r<=0)return true ;
                if(t[j]==o)r=Math.min(r+1,m);
              }
            }
            return false ;
          }
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := scanner.getCurrent()->toInteger() ;
    var W : int ; W := scanner.getCurrent()->toInteger() ;
    var N : int ; N := scanner.getCurrent()->toInteger() ;
    var sr : int ; sr := scanner.getCurrent()->toInteger() ;
    var sc : int ; sc := scanner.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := scanner.getCurrent()->characters() ;
    var t : Sequence(String) ; t := scanner.getCurrent()->characters() ;
    if (solve(H, W, N, sr, sc, s, t)) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 );
  static   operation solve( H : int, W : int, N : int, sr : int, sc : int, s : Sequence(String), t : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     var rem : Sequence(int) ; rem := Sequence{sc,W - sc + 1,sr,H - sr + 1} ;
     var max : Sequence(int) ; max := Sequence{W,W,H,H} ;
    var dir : Sequence(String) ; dir := Sequence{'L','R','U','D'} ;
    var otherdir : Sequence(String) ; otherdir := Sequence{'R','L','D','U'} ;
        var i : int ; i := 0 ; while i < 4 do ( (     var r : int ; r := rem[i+1] ;
     var m : int ; m := max[i+1] ;
    var d : String ; d := dir[i+1] ;
    var o : String ; o := otherdir[i+1] ;
        var j : int ; j := 0 ; while j < N do ( (     if (s[j+1] = d) then     r := r - 1 ; else skip ; 
     if (r <= 0) then     return true else skip ; 
     if (t[j+1] = o) then     r := Set{r + 1, m}->min() ; else skip )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt(),W=sc.nextInt(),N=sc.nextInt();
    int Sr=sc.nextInt(),Sc=sc.nextInt();
    String S=sc.next(),T=sc.next();
    sc.close();
    int left=1,right=W,up=1,down=H ;
    boolean alive=true ;
    for(int i=N-1 ; i>=0 && alive ; i--){
      switch(T.charAt(i)){
        case 'L' : right=Math.min(W,right+1);
        break ;
        case 'R' : left=Math.max(1,left-1);
        break ;
        case 'U' : down=Math.min(H,down+1);
        break ;
        case 'D' : up=Math.max(1,up-1);
        break ;
      }
      switch(S.charAt(i)){
        case 'L' : left++;
        break ;
        case 'R' : right--;
        break ;
        case 'U' : up++;
        break ;
        case 'D' : down--;
        break ;
      }
      if(left>right || up>down)alive=false ;
    }
    boolean ans=alive && Sr>=up && Sr<=down && Sc>=left && Sc<=right ;
    System.out.println(ans ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var Sr : int ; Sr := sc.getCurrent()->toInteger() ;
    var Sc : int ; Sc := sc.getCurrent()->toInteger() ;
    var S : String ; S := sc.getCurrent() ;
    var T : String ; T := sc.getCurrent() ;
    skip ; 
    var left : int ; left := 1 ;
    var right : int ; right := W ;
    var up : int ; up := 1 ;
    var down : int ; down := H ;
    var alive : boolean ; alive := true ;
        var i : int ; i := N - 1 ; while i >= 0 & alive do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (T->at(i+1)) ; 
       if _switchval = 'L' then
     right := Set{W, right + 1}->min() ; 
    break 
   else skip ;
       if _switchval = 'R' then
     left := Set{1, (left)->char2byte() - 1}->max() ; 
    break 
   else skip ;
       if _switchval = 'U' then
     down := Set{H, down + 1}->min() ; 
    break 
   else skip ;
       if _switchval = 'D' then
     up := Set{1, (up)->char2byte() - 1}->max() ; 
    break 
   else skip ;
 )
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (S->at(i+1)) ; 
       if _switchval = 'L' then
     left := left + 1 ; 
    break 
   else skip ;
       if _switchval = 'R' then
     right := right - 1 ; 
    break 
   else skip ;
       if _switchval = 'U' then
     up := up + 1 ; 
    break 
   else skip ;
       if _switchval = 'D' then
     down := down - 1 ; 
    break 
   else skip ;
 )
     if (left > right or up > down) then     alive := false ; else skip )  ;     i := i - 1 ) ; 
    var ans : boolean ; ans := alive & Sr >= up & Sr <= down & Sc >= left & Sc <= right ;
    OclFile["System.out"].println(if ans then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int printPattern(int i,int j,int n){
    if(j>=n){
      return 0 ;
    }
    if(i>=n){
      return 1 ;
    }
    if(j==i || j==n-1-i){
      if(i==n-1-j){
        System.out.print("/");
      }
      else {
        System.out.print("\\");}}else{System.out.print("*");
      }
      if(printPattern(i,j+1,n)==1){
        return 1 ;
      }
      System.out.println();
      return printPattern(i+1,0,n);
    }
    public static void main(String[] args){
      int N=9 ;
      printPattern(0,0,N);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printPattern( i : int, j : int, n : int) : int
  pre: true
  post: true
  activity: (     if (j >= n) then (     return 0 ) else skip ; 
     if (i >= n) then (     return 1 ) else skip ; 
    if (j = i or j = n - 1 - i) then (     if (i = n - 1 - j) then (     OclFile["System.out"].print("/") ) else (     OclFile["System.out"].print("\\") ) ) else (     OclFile["System.out"].print("*") ) ;  
    if (printPattern(i, j + 1, n) = 1) then (     return 1 ) else skip ; 
    OclFile["System.out"].println() ; 
    return printPattern(i + 1, 0, n) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 9 ;
     execute printPattern(0, 0, N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class Test {
  static int arr[]=new int[] {
    1,5,7,-1,5 };
    static int getPairsCount(int n,int sum){
      HashMap<Integer,Integer>hm=new HashMap<>();
      for(int i=0 ; i<n ; i++){
        if(! hm.containsKey(arr[i]))hm.put(arr[i],0);
        hm.put(arr[i],hm.get(arr[i])+1);
      }
      int twice_count=0 ;
      for(int i=0 ; i<n ; i++){
        if(hm.get(sum-arr[i])!=null)twice_count+=hm.get(sum-arr[i]);
        if(sum-arr[i]==arr[i])twice_count--;
      }
      return twice_count/2 ;
    }
    public static void main(String[] args){
      int sum=6 ;
      System.out.println("Count of pairs is "+getPairsCount(arr.length,sum));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Test {
  static   attribute arr : int := Sequence{1,5,7,-1,5};
  static   operation getPairsCount( n : int, sum : int) : int
  pre: true
  post: true
  activity: (     var hm : Map(int,int) ; hm := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (not(hm->keys()->includes(arr[i+1]))) then     hm := hm->union(Map{arr[i+1] |-> 0}) ; else skip ; 
     hm := hm->union(Map{arr[i+1] |-> hm->at(arr[i+1]) + 1}) )  ;     i := i + 1 ) ; 
    var twice_count : int ; twice_count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (hm->at(sum - arr[i+1]) /= null) then     twice_count := twice_count+(hm->at(sum - arr[i+1])) ; else skip ; 
     if (sum - arr[i+1] = arr[i+1]) then     twice_count := twice_count - 1 ; else skip )  ;     i := i + 1 ) ; 
    return twice_count / 2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 6 ;
     OclFile["System.out"].println("Count of pairs is " + getPairsCount(arr->size(), sum)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int Count_subarray(int arr[],int n){
    int subarray_sum,remaining_sum,count=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i ; j<n ; j++){
        subarray_sum=0 ;
        remaining_sum=0 ;
        for(int k=i ; k<=j ; k++){
          subarray_sum+=arr[k];
        }
        for(int l=0 ; l<i ; l++){
          remaining_sum+=arr[l];
        }
        for(int l=j+1 ; l<n ; l++){
          remaining_sum+=arr[l];
        }
        if(subarray_sum>remaining_sum){
          count+=1 ;
        }
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      10,9,12,6 };
      int n=arr.length ;
      System.out.print(Count_subarray(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Count_subarray( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var subarray_sum : int ;
    var remaining_sum : int ;
    var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i ; while j < n do ( (     subarray_sum := 0 ; 
     remaining_sum := 0 ; 
        var k : int ; k := i ; while k <= j do ( (     subarray_sum := subarray_sum+(arr[k+1]) )  ;     k := k + 1 ) ; 
        var l : int ; l := 0 ; while l < i do ( (     remaining_sum := remaining_sum+(arr[l+1]) )  ;     l := l + 1 ) ; 
        var l : int ; l := j + 1 ; while l < n do ( (     remaining_sum := remaining_sum+(arr[l+1]) )  ;     l := l + 1 ) ; 
    if (subarray_sum > remaining_sum) then (     count := count+(1) ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,9,12,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(Count_subarray(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=scanner.nextInt();
      int x=scanner.nextInt();
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      int times=Math.min(a,b)-1+n-Math.max(a,b);
      if(times>x){
        System.out.println(n-1-(times-x));
      }
      else {
        System.out.println(n-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var x : int ; x := scanner.getCurrent()->toInteger() ;
    var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var times : int ; times := Set{a, b}->min() - 1 + n - Set{a, b}->max() ;
    if (times > x) then (     OclFile["System.out"].println(n - 1 - (times - x)) ) else (     OclFile["System.out"].println(n - 1) ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  final static long mod=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int q=sc.nextInt();
    char[] c=sc.next().toCharArray();
    int[][] range=new int[q][2];
    for(int i=0 ; i<q ; i++){
      range[i][0]=sc.nextInt();
      range[i][1]=sc.nextInt();
    }
    int[] frag=new int[n+1];
    int[] rui=new int[n+1];
    for(int i=2 ; i<=n ; i++){
      if(c[i-2]=='A' && c[i-1]=='C'){
        frag[i]++;
      }
      rui[i]=rui[i-1]+frag[i];
    }
    for(int i=0 ; i<q ; i++){
      int left=range[i][0];
      int right=range[i][1];
      System.out.println(rui[right]-rui[left]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var c : Sequence(String) ; c := sc.getCurrent()->characters() ;
    var range : Sequence(Sequence(int)) ; range := Integer.subrange(1,q)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < q do ( (     range[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     range[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var frag : Sequence(int) ; frag := Integer.subrange(1,n + 1)->collect(0) ;
    var rui : Sequence(int) ; rui := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 2 ; while i <= n do ( (     if (c[i - 2+1] = 'A' & c[i - 1+1] = 'C') then (     frag[i+1] := frag[i+1] + 1 ) else skip ; 
     rui[i+1] := rui[i - 1+1] + frag[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var left : int ; left := range[i+1][0+1] ;
     var right : int ; right := range[i+1][1+1] ;
     OclFile["System.out"].println(rui[right+1] - rui[left+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  private static final int INFINITY=Integer.MAX_VALUE/2 ;
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int N=Integer.parseInt(br.readLine());
    int K[][]=new int[N][N];
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        K[i][j]=INFINITY ;
      }
    }
    int m=Integer.parseInt(br.readLine());
    for(int i=0 ; i<m ; i++){
      String str[]=br.readLine().trim().split(",");
      int a=Integer.parseInt(str[0])-1 ;
      int b=Integer.parseInt(str[1])-1 ;
      K[a][b]=Integer.parseInt(str[2]);
      K[b][a]=Integer.parseInt(str[3]);
    }
    String str[]=br.readLine().split(",");
    int start=Integer.parseInt(str[0])-1 ;
    int goal=Integer.parseInt(str[1])-1 ;
    int V=Integer.parseInt(str[2]);
    int P=Integer.parseInt(str[3]);
    for(int k=0 ; k<N ; k++){
      for(int i=0 ; i<N ; i++){
        for(int j=0 ; j<N ; j++){
          if(K[i][j]>K[i][k]+K[k][j]){
            K[i][j]=K[i][k]+K[k][j];
          }
        }
      }
    }
    System.out.println(V-P-K[start][goal]-K[goal][start]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INFINITY : int := 2147483647 / 2;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var N : int ; N := (br.readLine())->toInteger() ;
    var K : Sequence(Sequence(int)) ; K := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     K[i+1][j+1] := INFINITY )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var m : int ; m := (br.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     var str : Sequence(String) ; str := br.readLine()->trim()->split(",") ;
     var a : int ; a := (str[0+1])->toInteger() - 1 ;
    var b : int ; b := (str[1+1])->toInteger() - 1 ;
    K[a+1][b+1] := (str[2+1])->toInteger() ; 
    K[b+1][a+1] := (str[3+1])->toInteger() ; 
 )  ;     i := i + 1 ) ; 
    var str : Sequence(String) ; str := br.readLine()->split(",") ;
    var start : int ; start := (str[0+1])->toInteger() - 1 ;
    var goal : int ; goal := (str[1+1])->toInteger() - 1 ;
    var V : int ; V := (str[2+1])->toInteger() ;
    var P : int ; P := (str[3+1])->toInteger() ;
        var k : int ; k := 0 ; while k < N do ( (         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     if (K[i+1][j+1] > K[i+1][k+1] + K[k+1][j+1]) then (     K[i+1][j+1] := K[i+1][k+1] + K[k+1][j+1] ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(V - P - K[start+1][goal+1] - K[goal+1][start+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  public int distance(int n,int x,int a,int b){
    if(a>b){
      int tmp=a ;
      a=b ;
      b=tmp ;
    }
    if(a==1 && b==n){
      return Math.abs(a-b);
    }
    int rightmostA=a ;
    int leftmostB=b ;
    while(x!=0 && rightmostA>=1){
      int r=Math.max(1,rightmostA-1);
      if(rightmostA==r){
        break ;
      }
      rightmostA=Math.min(r,rightmostA);
      x--;
    }
    while(x!=0 && leftmostB<=n){
      int l=Math.min(n,leftmostB+1);
      if(leftmostB==l){
        break ;
      }
      leftmostB=Math.max(l,leftmostB);
      x--;
    }
    return Math.abs(rightmostA-leftmostB);
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int total=scanner.nextInt();
    A test=new A();
    for(int i=0 ; i<total ; ++i){
      int n=scanner.nextInt();
      int x=scanner.nextInt();
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      System.out.println(test.distance(n,x,a,b));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   operation distance( n : int, x : int, a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a > b) then (     var tmp : int ; tmp := a ;
     a := b ; 
     b := tmp ) else skip ; 
     if (a = 1 & b = n) then (     return if a - b < 0 then -(a - b) else a - b endif ) else skip ; 
    var rightmostA : int ; rightmostA := a ;
    var leftmostB : int ; leftmostB := b ;
    while (x /= 0 & rightmostA >= 1) do (     var r : int ; r := Set{1, rightmostA - 1}->max() ;
     if (rightmostA = r) then (     break ) else skip ; 
     rightmostA := Set{r, rightmostA}->min() ; 
     x := x - 1 ) ; 
    while (x /= 0 & leftmostB <= n) do (     var l : int ; l := Set{n, leftmostB + 1}->min() ;
     if (leftmostB = l) then (     break ) else skip ; 
     leftmostB := Set{l, leftmostB}->max() ; 
     x := x - 1 ) ; 
    return if rightmostA - leftmostB < 0 then -(rightmostA - leftmostB) else rightmostA - leftmostB endif 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var total : int ; total := scanner.getCurrent()->toInteger() ;
     var test : A ; test := A.newA() ;
         var i : int ; i := 0 ; while i < total do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var x : int ; x := scanner.getCurrent()->toInteger() ;
    var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    OclFile["System.out"].println(test.distance(n, x, a, b)) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A_Two_Rival_Students {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int x=s.nextInt();
      int a=s.nextInt();
      int b=s.nextInt();
      if(Math.abs(a-b)>=n-1){
        System.out.println(n-1);
      }
      else {
        int initD=Math.abs(a-b);
        initD+=x ;
        if(initD>n-1){
          System.out.println(n-1);
        }
        else {
          System.out.println(initD);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Two_Rival_Students {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var x : int ; x := s.getCurrent()->toInteger() ;
    var a : int ; a := s.getCurrent()->toInteger() ;
    var b : int ; b := s.getCurrent()->toInteger() ;
    if (if a - b < 0 then -(a - b) else a - b endif >= n - 1) then (     OclFile["System.out"].println(n - 1) ) else (     var initD : int ; initD := if a - b < 0 then -(a - b) else a - b endif ;
     initD := initD+(x) ; 
     if (initD > n - 1) then (     OclFile["System.out"].println(n - 1) ) else (     OclFile["System.out"].println(initD) ) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.nio.charset.StandardCharsets ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class PaiDuiTest {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in,StandardCharsets.UTF_8.name());
    int num=Integer.parseInt(scanner.nextLine());
    List<int[]>list=new ArrayList<>();
    for(int i=0 ; i<num ; i++){
      String s=scanner.nextLine();
      String[] split=s.split(" ");
      int[] ints=Arrays.stream(split).mapToInt(Integer :: parseInt).toArray();
      list.add(ints);
    }
    for(int j=0 ; j<list.size(); j++){
      int[] ints=list.get(j);
      int count=ints[0];
      int maxChanges=ints[1];
      int indexA=ints[2]-1 ;
      int indexB=ints[3]-1 ;
      int maxIndex=Math.max(indexA,indexB);
      int minIndex=Math.min(indexA,indexB);
      if(minIndex>0){
        if(minIndex<=maxChanges){
          maxChanges-=minIndex ;
          minIndex=0 ;
        }
        else {
          minIndex-=maxChanges ;
          maxChanges=0 ;
        }
      }
      if(maxIndex<count-1 && maxChanges>0){
        int reamin=count-1-maxIndex ;
        if(maxChanges>=reamin){
          maxIndex=count-1 ;
          maxChanges-=reamin ;
        }
        else {
          maxIndex+=maxChanges ;
          maxChanges=0 ;
        }
      }
      int maxJuli=maxIndex-minIndex ;
      System.out.println(maxJuli);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PaiDuiTest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"], StandardCharsets.UTF_8.name()) ;
     var num : int ; num := (scanner.nextLine())->toInteger() ;
    var list : Sequence(Sequence(int)) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < num do ( (     var s : String ; s := scanner.nextLine() ;
     var split : Sequence(String) ; split := s->split(" ") ;
     var ints : Sequence(int) ; ints := stream(split)->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
     list := list->including(ints) )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < list->size() do ( (     var ints : Sequence(int) ; ints := list->at(j+1) ;
     var count : int ; count := ints[0+1] ;
    var maxChanges : int ; maxChanges := ints[1+1] ;
    var indexA : int ; indexA := ints[2+1] - 1 ;
    var indexB : int ; indexB := ints[3+1] - 1 ;
    var maxIndex : int ; maxIndex := Set{indexA, indexB}->max() ;
    var minIndex : int ; minIndex := Set{indexA, indexB}->min() ;
    if (minIndex > 0) then (     if (minIndex <= maxChanges) then (     maxChanges := maxChanges-(minIndex) ; 
     minIndex := 0 ) else (     minIndex := minIndex-(maxChanges) ; 
     maxChanges := 0 ) ) else skip ; 
    if (maxIndex < count - 1 & maxChanges > 0) then (     var reamin : int ; reamin := count - 1 - maxIndex ;
     if (maxChanges >= reamin) then (     maxIndex := count - 1 ; 
     maxChanges := maxChanges-(reamin) ) else (     maxIndex := maxIndex+(maxChanges) ; 
     maxChanges := 0 ) ) else skip ; 
    var maxJuli : int ; maxJuli := maxIndex - minIndex ;
    OclFile["System.out"].println(maxJuli) ; 
 )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class torivalStudent {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int testCase=in.nextInt();
    while(testCase-->0){
      int[] pro=new int[4];
      for(int i=0 ; i<4 ; i++){
        pro[i]=in.nextInt();
      }
      System.out.println(Math.min(pro[0]-1,Math.abs(pro[3]-pro[2])+pro[1]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class torivalStudent {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCase : int ; testCase := in.getCurrent()->toInteger() ;
         while (testCase > 0) do (        testCase := testCase - 1 ;     skip ; (     var pro : Sequence(int) ; pro := Integer.subrange(1,4)->collect(0) ;
         var i : int ; i := 0 ; while i < 4 do ( (     pro[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(Set{pro[0+1] - 1, if pro[3+1] - pro[2+1] < 0 then -(pro[3+1] - pro[2+1]) else pro[3+1] - pro[2+1] endif + pro[1+1]}->min()) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Comparator ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int sum=0 ;
    ArrayList<Integer>a=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      int tmp=scanner.nextInt();
      sum+=tmp ;
      if(tmp % 10!=0){
        a.add(tmp);
      }
    }
    a.sort(Comparator.naturalOrder());
    int i=0 ;
    while(sum % 10==0 && i<a.size()){
      sum-=a.get(i);
      i++;
    }
    if(sum % 10==0){
      sum=0 ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var a : Sequence(int) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var tmp : int ; tmp := scanner.getCurrent()->toInteger() ;
     sum := sum+(tmp) ; 
     if (tmp mod 10 /= 0) then (     a := a->including(tmp) ) else skip )  ;     i := i + 1 ) ; 
    a := a.sort(Comparator.naturalOrder()) ; 
    var i : int ; i := 0 ;
    while (sum mod 10 = 0 & i < a->size()) do (     sum := sum-(a->at(i+1)) ; 
     i := i + 1 ) ; 
    if (sum mod 10 = 0) then (     sum := 0 ) else skip ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(br.readLine());
    }
    boolean[][] dp=new boolean[n+1][10001];
    dp[0][0]=true ;
    for(int i=1 ; i<=n ; i++){
      int val=arr[i-1];
      for(int j=0 ; j<dp[0] .length ; j++){
        if(dp[i-1][j]){
          dp[i][j]=true ;
          if(j+val<dp[0] .length){
            dp[i][j+val]=true ;
          }
        }
      }
    }
    int max=0 ;
    for(int i=0 ; i<dp[0] .length ; i++){
      if(dp[n][i] && i % 10!=0){
        max=i ;
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(boolean)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,10001)->collect(false)) ;
    dp[0+1][0+1] := true ; 
        var i : int ; i := 1 ; while i <= n do ( (     var val : int ; val := arr[i - 1+1] ;
         var j : int ; j := 0 ; while j < dp[0+1]->size() do ( (     if (dp[i - 1+1][j+1]) then (     dp[i+1][j+1] := true ; 
     if (j + val < dp[0+1]->size()) then (     dp[i+1][j + val+1] := true ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < dp[0+1]->size() do ( (     if (dp[n+1][i+1] & i mod 10 /= 0) then (     max := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import java.math.*;
public class Main {
  static HashMap<String,Integer>map=new HashMap<String,Integer>();
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    ArrayList<Integer>s=new ArrayList<>();
    int mod10=0 ;
    for(int i=0 ; i<n ; i++){
      int num=Integer.parseInt(br.readLine());
      if(num % 10==0){
        mod10+=num ;
      }
      else {
        s.add(num);
      }
    }
    Collections.sort(s);
    solve(s,s.size(),mod10);
  }
  static void solve(ArrayList<Integer>s,int n,int mod10){
    Queue<ArrayList<Integer>>q=new ArrayDeque<>();
    q.add(s);
    while(q.peek()!=null){
      ArrayList<Integer>num=q.poll();
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        sum+=num.get(i);
      }
      if(sum % 10!=0){
        System.out.println(sum+mod10);
        return ;
      }
      for(int i=0 ; i<n ; i++){
        if(num.get(i)!=0){
          ArrayList<Integer>next=new ArrayList<>();
          for(int j=0 ; j<n ; j++){
            next.add(num.get(j));
          }
          next.set(i,0);
          q.add(next);
        }
      }
    }
    System.out.println(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute map : Map(String,int) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var s : Sequence(int) ; s := Sequence{} ;
    var mod10 : int ; mod10 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := (br.readLine())->toInteger() ;
     if (num mod 10 = 0) then (     mod10 := mod10+(num) ) else (     s := s->including(num) ) )  ;     i := i + 1 ) ; 
    s := s->sort() ; 
    execute solve(s, s->size(), mod10) ; 
 );
  static   operation solve( s : Sequence(int), n : int, mod10 : int) : void
  pre: true
  post: true
  activity: (     var q : Sequence(Sequence(int)) ; q := ArrayDeque<OclAny>.newArrayDeque() ;
     q := q->including(s) ; 
     while (q->min() /= null) do (     var num : Sequence(int) ; num := q->min() ;
     var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(num->at(i+1)) )  ;     i := i + 1 ) ; 
    if (sum mod 10 /= 0) then (     OclFile["System.out"].println(sum + mod10) ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     if (num->at(i+1) /= 0) then (     var next : Sequence(int) ; next := Sequence{} ;
         var j : int ; j := 0 ; while j < n do ( (     next := next->including(num->at(j+1)) )  ;     j := j + 1 ) ; 
     next := next.setAt(i+1,0) ; 
     q := q->including(next) ) else skip )  ;     i := i + 1 ) ; 
 ) ; 
     OclFile["System.out"].println(0) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int n=gi();
    long[] s=new long[n];
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      s[i]=gl();
      ans+=s[i];
    }
    if(ans % 10!=0){
      System.out.println(ans);
      return ;
    }
    Arrays.parallelSort(s);
    for(int i=0 ; i<n ; i++){
      if(s[i] % 10!=0){
        ans-=s[i];
        break ;
      }
    }
    if(ans % 10==0){
      System.out.println(0);
    }
    else {
      System.out.println(ans);
    }
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := gi() ;
    var s : Sequence(long) ; s := Integer.subrange(1,n)->collect(0) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := gl() ; 
     ans := ans+(s[i+1]) )  ;     i := i + 1 ) ; 
    if (ans mod 10 /= 0) then (     OclFile["System.out"].println(ans) ; 
     return ) else skip ; 
    s := s->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] mod 10 /= 0) then (     ans := ans-(s[i+1]) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (ans mod 10 = 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(ans) ) ;  
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Diversity {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] ch=sc.next().toCharArray();
    int k=sc.nextInt();
    if(k>ch.length){
      System.out.println("impossible");
      return ;
    }
    HashSet<Character>set=new HashSet<>();
    for(char c : ch){
      set.add(c);
    }
    System.out.println(Math.max(0,k-set.size()));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Diversity {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ch : Sequence(String) ; ch := sc.getCurrent()->characters() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    if (k > ch->size()) then (     OclFile["System.out"].println("impossible") ; 
     return ) else skip ; 
    var set : Set(String) ; set := Set{} ;
    for (c : ch) do ( (     set := set->including(c) )  ) ; 
    OclFile["System.out"].println(Set{0, k - set->size()}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Energy {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    StringBuilder out=new StringBuilder();
    int numCases=in.nextInt();
    for(int caseNum=1 ; caseNum<=numCases ; ++caseNum){
      out.append(String.format("Case #%d: ",caseNum));
      long maxEnergy=in.nextLong();
      long currentEnergy=maxEnergy ;
      long regen=in.nextLong();
      int numEvents=in.nextInt();
      long[] values=new long[numEvents];
      for(int i=0 ; i<values.length ; ++i)values[i]=in.nextLong();
      int curEvent=0 ;
      long totalValue=0 ;
      while(curEvent!=numEvents){
        int nextEvent=curEvent+1 ;
        while(nextEvent!=numEvents && values[nextEvent]<=values[curEvent])++nextEvent ;
        if(nextEvent==numEvents){
          totalValue+=values[curEvent]*currentEnergy ;
          currentEnergy=0 ;
        }
        else {
          long energyToLeave=Math.max(maxEnergy-regen*(nextEvent-curEvent),0L);
          if(energyToLeave>=currentEnergy){
          }
          else {
            long energyToSpend=currentEnergy-energyToLeave ;
            totalValue+=values[curEvent]*energyToSpend ;
            currentEnergy=energyToLeave ;
          }
        }
        currentEnergy+=regen ;
        currentEnergy=Math.min(currentEnergy,maxEnergy);
++curEvent ;
      }
      out.append(totalValue);
      out.append('\n');
    }
    System.out.print(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Energy {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : String ; out := StringLib.newString() ;
    var numCases : int ; numCases := in.getCurrent()->toInteger() ;
        var caseNum : int ; caseNum := 1 ; while caseNum <= numCases do ( (     out := out + StringLib.newString(StringLib.format("Case #%d: ",Sequence{caseNum})) ; 
     var maxEnergy : long ; maxEnergy := in.getCurrent()->toLong() ;
    var currentEnergy : long ; currentEnergy := maxEnergy ;
    var regen : long ; regen := in.getCurrent()->toLong() ;
    var numEvents : int ; numEvents := in.getCurrent()->toInteger() ;
    var values : Sequence(long) ; values := Integer.subrange(1,numEvents)->collect(0) ;
        var i : int ; i := 0 ; while i < values->size() do (     values[i+1] := in.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var curEvent : int ; curEvent := 0 ;
    var totalValue : long ; totalValue := 0 ;
    while (curEvent /= numEvents) do (     var nextEvent : int ; nextEvent := curEvent + 1 ;
     while (nextEvent /= numEvents & values[nextEvent+1] <= values[curEvent+1]) do     nextEvent := nextEvent + 1 ; ; 
    if (nextEvent = numEvents) then (     totalValue := totalValue+(values[curEvent+1] * currentEnergy) ; 
     currentEnergy := 0 ) else (     var energyToLeave : long ; energyToLeave := Set{maxEnergy - regen * (nextEvent - curEvent), 0L}->max() ;
     if (energyToLeave >= currentEnergy) then skip else (     var energyToSpend : long ; energyToSpend := currentEnergy - energyToLeave ;
     totalValue := totalValue+(values[curEvent+1] * energyToSpend) ; 
     currentEnergy := energyToLeave ) ) ;  
    currentEnergy := currentEnergy+(regen) ; 
    currentEnergy := Set{currentEnergy, maxEnergy}->min() ; 
    curEvent := curEvent + 1 ; 
 ) ; 
    out := out + StringLib.newString(totalValue) ; 
    out := out + StringLib.newString('
') ; 
 )  ;     caseNum := caseNum + 1 ) ; 
    OclFile["System.out"].print(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskC solver=new TaskC();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskC {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int N=in.nextInt();
      int Q=in.nextInt();
      String S=in.next();
      int s[]=new int[N+1];
      int count=0 ;
      for(int i=2 ; i<=N ; i++){
        if(S.charAt(i-1)=='C' && S.charAt(i-2)=='A'){
          count++;
        }
        s[i]=count ;
      }
      for(int i=0 ; i<Q ; i++){
        int l=in.nextInt();
        int r=in.nextInt();
        out.println(s[r]-s[l]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskC ; solver := TaskC.newTaskC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskC {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
     var Q : int ; Q := in.getCurrent()->toInteger() ;
    var S : String ; S := in.getCurrent() ;
    var s : Sequence(int) ; s := Integer.subrange(1,N + 1)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := 2 ; while i <= N do ( (     if (S->at(i - 1+1) = 'C' & S->at(i - 2+1) = 'A') then (     count := count + 1 ) else skip ; 
     s[i+1] := count )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Q do ( (     var l : int ; l := in.getCurrent()->toInteger() ;
     var r : int ; r := in.getCurrent()->toInteger() ;
     skip )  ;     i := i + 1 ) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int x=0 ;
    for(int i=0 ; i<n ; i++)x+=s.nextInt();
    int y=0 ;
    for(int i=0 ; i<n ; i++)y+=s.nextInt();
    if(y<=x)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < n do (     x := x+(s.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    var y : int ; y := 0 ;
        var i : int ; i := 0 ; while i < n do (     y := y+(s.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    if (y <= x) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int INF=1<<24 ;
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int[][] pass=new int[n][n];
      for(int i=0 ; i<n ; i++){
        Arrays.fill(pass[i],INF);
        pass[i][i]=0 ;
      }
      for(int i=0 ; i<m ; i++){
        String[] input=sc.next().split(",");
        int a=Integer.parseInt(input[0])-1 ;
        int b=Integer.parseInt(input[1])-1 ;
        int cost1=Integer.parseInt(input[2]);
        int cost2=Integer.parseInt(input[3]);
        pass[a][b]=cost1 ;
        pass[b][a]=cost2 ;
      }
      String[] lastinput=sc.next().split(",");
      int from=Integer.parseInt(lastinput[0])-1 ;
      int to=Integer.parseInt(lastinput[1])-1 ;
      int money=Integer.parseInt(lastinput[2]);
      int h=Integer.parseInt(lastinput[3]);
      for(int j=0 ; j<n ; j++){
        for(int i=0 ; i<n ; i++){
          for(int k=0 ; k<n ; k++){
            pass[i][k]=Math.min(pass[i][k],pass[i][j]+pass[j][k]);
          }
        }
      }
      int ans=money-(pass[from][to]+pass[to][from]+h);
      System.out.println(ans);
    }
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(24)))->oclAsType(long);
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var pass : Sequence(Sequence(int)) ; pass := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     pass[i+1] := pass[i+1]->collect(INF) ; 
     pass[i+1][i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var input : Sequence(String) ; input := sc.getCurrent()->split(",") ;
     var a : int ; a := (input[0+1])->toInteger() - 1 ;
    var b : int ; b := (input[1+1])->toInteger() - 1 ;
    var cost1 : int ; cost1 := (input[2+1])->toInteger() ;
    var cost2 : int ; cost2 := (input[3+1])->toInteger() ;
    pass[a+1][b+1] := cost1 ; 
    pass[b+1][a+1] := cost2 ; 
 )  ;     i := i + 1 ) ; 
    var lastinput : Sequence(String) ; lastinput := sc.getCurrent()->split(",") ;
    var from : int ; from := (lastinput[0+1])->toInteger() - 1 ;
    var to : int ; to := (lastinput[1+1])->toInteger() - 1 ;
    var money : int ; money := (lastinput[2+1])->toInteger() ;
    var h : int ; h := (lastinput[3+1])->toInteger() ;
        var j : int ; j := 0 ; while j < n do ( (         var i : int ; i := 0 ; while i < n do ( (         var k : int ; k := 0 ; while k < n do ( (     pass[i+1][k+1] := Set{pass[i+1][k+1], pass[i+1][j+1] + pass[j+1][k+1]}->min() )  ;     k := k + 1 ) )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    var ans : int ; ans := money - (pass[from+1][to+1] + pass[to+1][from+1] + h) ;
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import org.omg.PortableInterceptor.INACTIVE ;
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int t=1 ; t<=test ; t++){
      int n=in.nextInt();
      int k=in.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=in.nextInt();
      }
      int min=Integer.MAX_VALUE ;
      for(int i=1 ; i<=100 ; i++){
        int count=0 ;
        int j=0 ;
        while(j<n){
          if(arr[j]!=i){
            count++;
            j+=k ;
          }
          else {
            j++;
          }
        }
        min=Math.min(count,min);
      }
      System.out.println(min);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= test do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
        var i : int ; i := 1 ; while i <= 100 do ( (     var count : int ; count := 0 ;
     var j : int ; j := 0 ;
     while (j < n) do (     if (arr[j+1] /= i) then (     count := count + 1 ; 
     j := j+(k) ) else (     j := j + 1 ) ) ; 
     min := Set{count, min}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int findRepeatingNumber(int[] arr,int n){
    int sq=(int)Math.sqrt(n);
    int range=(n/sq)+1 ;
    int[] count=new int[range];
    for(int i=0 ; i<=n ; i++){
      count[(arr[i]-1)/sq]++;
    }
    int selected_block=range-1 ;
    for(int i=0 ; i<range-1 ; i++){
      if(count[i]>sq){
        selected_block=i ;
        break ;
      }
    }
    HashMap<Integer,Integer>m=new HashMap<>();
    for(int i=0 ; i<=n ; i++){
      if(((selected_block*sq)<arr[i])&&(arr[i]<=((selected_block+1)*sq))){
        m.put(arr[i],1);
        if(m.get(arr[i])==1)return arr[i];
      }
    }
    return-1 ;
  }
  public static void main(String args[]){
    int[] arr={
      1,1,2,3,5,4 };
      int n=5 ;
      System.out.println("One of the numbers repeated in the array is: "+findRepeatingNumber(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findRepeatingNumber( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sq : int ; sq := (n)->sqrt()->oclAsType(int) ;
     var range : int ; range := (n / sq) + 1 ;
    var count : Sequence(int) ; count := Integer.subrange(1,range)->collect(0) ;
        var i : int ; i := 0 ; while i <= n do ( (     count[(arr[i+1] - 1) / sq+1] := count[(arr[i+1] - 1) / sq+1] + 1 )  ;     i := i + 1 ) ; 
    var selected_block : int ; selected_block := range - 1 ;
        var i : int ; i := 0 ; while i < range - 1 do ( (     if (count[i+1] > sq) then (     selected_block := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var m : Map(int,int) ; m := Map{} ;
        var i : int ; i := 0 ; while i <= n do ( (     if (((selected_block * sq) < arr[i+1]) & (arr[i+1] <= ((selected_block + 1) * sq))) then (     m := m->union(Map{arr[i+1] |-> 1}) ; 
     if (m->at(arr[i+1]) = 1) then     return arr[i+1] else skip ) else skip )  ;     i := i + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,2,3,5,4} ;
     var n : int ; n := 5 ;
     OclFile["System.out"].println("One of the numbers repeated in the array is: " + findRepeatingNumber(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static long maxPrimeFactors(long n){
    long maxPrime=-1 ;
    while(n % 2==0){
      maxPrime=2 ;
      n>>=1 ;
    }
    for(int i=3 ; i<=Math.sqrt(n); i+=2){
      while(n % i==0){
        maxPrime=i ;
        n=n/i ;
      }
    }
    if(n>2)maxPrime=n ;
    return maxPrime ;
  }
  public static void main(String[] args){
    Long n=15l ;
    System.out.println(maxPrimeFactors(n));
    n=25698751364526l ;
    System.out.println(maxPrimeFactors(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxPrimeFactors( n : long) : long
  pre: true
  post: true
  activity: (     var maxPrime : long ; maxPrime := -1 ;
     while (n mod 2 = 0) do (     maxPrime := 2 ; 
     n := n/(2->pow(1)) ) ; 
        var i : int ; i := 3 ; while i <= (n)->sqrt() do ( (     while (n mod i = 0) do (     maxPrime := i ; 
     n := n / i ) )  ;     i := i+(2) ) ; 
    if (n > 2) then     maxPrime := n ; else skip ; 
    return maxPrime 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 15l ;
     OclFile["System.out"].println(maxPrimeFactors(n)) ; 
     n := 25698751364526l ; 
     OclFile["System.out"].println(maxPrimeFactors(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Beat {
  int number ;
  public Beat(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  static int numberEven=0 ;
  static int numberOdd=0 ;
  public void input(int number){
    if(number % 2==0){
      numberEven++;
    }
    else {
      numberOdd++;
    }
  }
  public void printResult(){
    System.out.println(java.lang.Math.min(numberEven,numberOdd));
    numberEven=0 ;
    numberOdd=0 ;
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    Beat instance=new Beat(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      int num=input.nextInt();
      for(int k=0 ; k<num ; k++){
        int n=input.nextInt();
        instance.input(n);
      }
      instance.printResult();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Beat {
   attribute number : int;
   static operation newBeat( number : int) : Beat
  pre: true
  post: true
  activity:
  ( var self : Beat ;
    self := createBeat();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
  static   attribute numberEven : int := 0;
  static   attribute numberOdd : int := 0;
   operation input( number : int) : void
  pre: true
  post: true
  activity: (     if (number mod 2 = 0) then (     numberEven := numberEven + 1 ) else (     numberOdd := numberOdd + 1 ) );
   operation printResult() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(java.lang.Math->min()) ; 
     numberEven := 0 ; 
     numberOdd := 0 );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
     var instance : Beat ; instance := Beat.newBeat(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
         var k : int ; k := 0 ; while k < num do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     instance.input(n) )  ;     k := k + 1 ) ; 
     instance.printResult() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=input.nextInt()% 2 ;
      }
      int odd=0,even=0 ;
      for(int i=0 ; i<n ; i++){
        if(a[i] % 2==0){
          even++;
        }
        else {
          odd++;
        }
      }
      System.out.println(Math.min(even,odd));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := input.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.getCurrent()->toInteger() mod 2 )  ;     i := i + 1 ) ; 
    var odd : int ; odd := 0 ;
    var even : int ; even := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] mod 2 = 0) then (     even := even + 1 ) else (     odd := odd + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{even, odd}->min()) ; 
 ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    while(t-->0){
      int n=scan.nextInt();
      int[] a=new int[n];
      int odd=0,even=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=scan.nextInt();
        if(a[i] % 2==1)odd++;
        else even++;
      }
      System.out.println(Math.min(odd,even));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var odd : int ; odd := 0 ;
    var even : int ; even := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() ; 
     if (a[i+1] mod 2 = 1) then     odd := odd + 1 ; else     even := even + 1 ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{odd, even}->min()) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test238 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int e=0,o=0 ;
      for(int i=0 ; i<n ; i++){
        if(in.nextInt()% 2==0){
          e++;
        }
        else {
          o++;
        }
      }
      if(e>o){
        System.out.println(o);
      }
      else {
        System.out.println(e);
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test238 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var e : int ; e := 0 ;
    var o : int ; o := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (in.getCurrent()->toInteger() mod 2 = 0) then (     e := e + 1 ) else (     o := o + 1 ) )  ;     i := i + 1 ) ; 
     if (e > o) then (     OclFile["System.out"].println(o) ) else (     OclFile["System.out"].println(e) ) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int N=Integer.parseInt(st.nextToken());
    int Q=Integer.parseInt(st.nextToken());
    char[] arr=br.readLine().toCharArray();
    int[] num=new int[N];
    num[0]=0 ;
    for(int i=1 ; i<N ; ++i){
      num[i]=num[i-1]+(arr[i-1]=='A' && arr[i]=='C' ? 1 : 0);
    }
    for(int i=0 ; i<Q ; ++i){
      st=new StringTokenizer(br.readLine());
      int start=Integer.parseInt(st.nextToken());
      int end=Integer.parseInt(st.nextToken());
      bw.write((num[end-1]-num[start-1])+"\n");
    }
    bw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var N : int ; N := (st.next())->toInteger() ;
    var Q : int ; Q := (st.next())->toInteger() ;
    var arr : Sequence(String) ; arr := br.readLine()->characters() ;
    var num : Sequence(int) ; num := Integer.subrange(1,N)->collect(0) ;
    num[0+1] := 0 ; 
        var i : int ; i := 1 ; while i < N do ( (     num[i+1] := num[i - 1+1] + (if arr[i - 1+1] = 'A' & arr[i+1] = 'C' then 1 else 0 endif) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Q do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var start : int ; start := (st.next())->toInteger() ;
     var end : int ; end := (st.next())->toInteger() ;
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    char[] s1=sc.next().toCharArray();
    int ans=0 ;
    int c1=0 ;
    int c0=0 ;
    for(int i=0 ; i<s1.length ; i++){
      if(s1[i]=='1'){
        if(c0>0){
          c0--;
          ans++;
        }
        else {
          c1++;
        }
      }
      else {
        if(c1>0){
          c1--;
          ans++;
        }
        else {
          c0++;
        }
      }
    }
    System.out.println(ans*2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : Sequence(String) ; s1 := sc.getCurrent()->characters() ;
    var ans : int ; ans := 0 ;
    var c1 : int ; c1 := 0 ;
    var c0 : int ; c0 := 0 ;
        var i : int ; i := 0 ; while i < s1->size() do ( (     if (s1[i+1] = '1') then (     if (c0 > 0) then (     c0 := c0 - 1 ; 
     ans := ans + 1 ) else (     c1 := c1 + 1 ) ) else (     if (c1 > 0) then (     c1 := c1 - 1 ; 
     ans := ans + 1 ) else (     c0 := c0 + 1 ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans * 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Vector ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Stack ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskB solver=new TaskB();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskB {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      String x=in.next();
      Stack<Character>s=new Stack<>();
      int c=0 ;
      for(int i=0 ; i<x.length(); i++){
        s.push(x.charAt(i));
        while(s.size()>1){
          Character p=s.pop();
          Character q=s.pop();
          if((p=='1' && q=='0')||(p=='0' && q=='1')){
            c++;
            continue ;
          }
          else {
            s.push(q);
            s.push(p);
            break ;
          }
        }
      }
      out.println(c*2);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskB ; solver := TaskB.newTaskB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskB {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var x : String ; x := in.next() ;
     var s : Sequence(String) ; s := Sequence{} ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < x->size() do ( (     s := s->append(x->at(i+1)) ; 
     while (s->size() > 1) do (     var p : String ; p := s->last() ;
     var q : String ; q := s->last() ;
     if ((p = '1' & q = '0') or (p = '0' & q = '1')) then (     c := c + 1 ; 
     continue ) else (     s := s->append(q) ; 
     s := s->append(p) ; 
     break ) ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    int red ;
    int blue ;
    red=str.length()-str.replaceAll("1","").length();
    blue=str.length()-str.replaceAll("0","").length();
    System.out.println(Math.min(red,blue)*2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var red : int ;
    var blue : int ;
    red := str->size() - str.replaceAllMatches("1", "" )->size() ; 
    blue := str->size() - str.replaceAllMatches("0", "" )->size() ; 
    OclFile["System.out"].println(Set{red, blue}->min() * 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    try(BufferedReader i=new BufferedReader(new InputStreamReader(System.in))){
      String S=i.readLine();
      int a=S.length();
      Long r=S.chars().filter(c->c=='0').count();
      Long b=a-r ;
      System.out.println(Math.min(r,b)*2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var i : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var S : String ; S := i.readLine() ;
     var a : int ; a := S->size() ;
    var r : long ; r := S.chars()->select( _x1 | (lambda c : OclAny in c = '0')->apply(_x1) )->size() ;
    var b : long ; b := (a)->char2byte() - r ;
    OclFile["System.out"].println(Set{r, b}->min() * 2) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    String cube[]=new String[S.length()];
    for(int i=0 ; i<S.length(); i++){
      cube[i]=S.substring(i,i+1);
    }
    HashMap<String,Integer>map=new HashMap<>();
    for(int i=0 ; i<S.length(); i++){
      if(! map.containsKey(cube[i])){
        map.put(cube[i],1);
      }
      else {
        int cnt=map.get(cube[i]);
        map.put(cube[i],cnt+1);
      }
    }
    if(! map.containsKey("0")|| ! map.containsKey("1")){
      System.out.println(0);
      return ;
    }
    int cnt0=map.get("0");
    int cnt1=map.get("1");
    System.out.println(Math.min(cnt0,cnt1)*2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    var cube : Sequence(String) ; cube := Integer.subrange(1,S->size())->collect(null) ;
        var i : int ; i := 0 ; while i < S->size() do ( (     cube[i+1] := S.subrange(i+1,i + 1) )  ;     i := i + 1 ) ; 
    var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < S->size() do ( (     if (not(map->keys()->includes(cube[i+1]))) then (     map := map->union(Map{cube[i+1] |-> 1}) ) else (     var cnt : int ; cnt := map->at(cube[i+1]) ;
     map := map->union(Map{cube[i+1] |-> cnt + 1}) ) )  ;     i := i + 1 ) ; 
    if (not(map->keys()->includes("0")) or not(map->keys()->includes("1"))) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var cnt0 : int ; cnt0 := map->at("0") ;
    var cnt1 : int ; cnt1 := map->at("1") ;
    OclFile["System.out"].println(Set{cnt0, cnt1}->min() * 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void pythagoreanTriplet(int n){
    for(int i=1 ; i<=n/3 ; i++){
      for(int j=i+1 ; j<=n/2 ; j++){
        int k=n-i-j ;
        if(i*i+j*j==k*k){
          System.out.print(i+","+j+","+k);
          return ;
        }
      }
    }
    System.out.print("No Triplet");
  }
  public static void main(String arg[]){
    int n=12 ;
    pythagoreanTriplet(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation pythagoreanTriplet( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= n / 3 do ( (         var j : int ; j := i + 1 ; while j <= n / 2 do ( (     var k : int ; k := n - i - j ;
     if (i * i + j * j = k * k) then (     OclFile["System.out"].print(i + "," + j + "," + k) ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("No Triplet") );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     execute pythagoreanTriplet(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int countDigits(int a,int b){
    if(a==0 || b==0)return 1 ;
    return(int)Math.floor(Math.log10(Math.abs(a))+Math.log10(Math.abs(b)))+1 ;
  }
  public static void main(String[] args){
    int a=33 ;
    int b=-24 ;
    System.out.print(countDigits(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countDigits( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0 or b = 0) then     return 1 else skip ; 
     return ((if a < 0 then -(a) else a endif)->log10() + (if b < 0 then -(b) else b endif)->log10())->floor()->oclAsType(int) + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 33 ;
     var b : int ; b := -24 ;
     OclFile["System.out"].print(countDigits(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int indexOfFirstOne(int arr[],int low,int high){
    int mid=0 ;
    while(low<=high){
      mid=(low+high)/2 ;
      if(arr[mid]==1 &&(mid==0 || arr[mid-1]==0))break ;
      else if(arr[mid]==1)high=mid-1 ;
      else low=mid+1 ;
    }
    return mid ;
  }
  public static int posOfFirstOne(int arr[]){
    int l=0,h=1 ;
    while(arr[h]==0){
      l=h ;
      h=2*h ;
    }
    return indexOfFirstOne(arr,l,h);
  }
  public static void main(String[] args){
    int arr[]={
      0,0,1,1,1,1 };
      System.out.println("Index="+posOfFirstOne(arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation indexOfFirstOne( arr : Sequence(int), low : int, high : int) : int
  pre: true
  post: true
  activity: (     var mid : int ; mid := 0 ;
     while (low <= high) do (     mid := (low + high) / 2 ; 
     if (arr[mid+1] = 1 & (mid = 0 or arr[mid - 1+1] = 0)) then     break else     if (arr[mid+1] = 1) then     high := mid - 1 else     low := mid + 1 ; ;  ) ; 
     return mid );
  static   operation posOfFirstOne( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
    var h : int ; h := 1 ;
     while (arr[h+1] = 0) do (     l := h ; 
     h := 2 * h ) ; 
     return indexOfFirstOne(arr, l, h) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,0,1,1,1,1} ;
     OclFile["System.out"].println("Index=" + posOfFirstOne(arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class main {
  public static void main(String[] args){
    FastReader fr=new FastReader();
    int n=fr.nextInt();
    int sum=0,total=0,i=1 ;
    if(n==2){
      System.out.println(1);
      return ;
    }
    while(n>0){
      n-=1 ;
      if(n>0){
        if(n>=2){
          total++;
        }
        n-=2 ;
      }
      total++;
    }
    System.out.println(total);
  }
  static class FastReader {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
      }
      return st.nextToken();
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fr : FastReader ; fr := FastReader.newFastReader() ;
     var n : int ; n := fr.nextInt() ;
    var sum : int ; sum := 0 ;
    var total : int ; total := 0 ;
    var i : int ; i := 1 ;
    if (n = 2) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    while (n > 0) do (     n := n-(1) ; 
     if (n > 0) then (     if (n >= 2) then (     total := total + 1 ) else skip ; 
     n := n-(2) ) else skip ; 
     total := total + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
  static class FastReader {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ; 
     return st.next() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public void doMain()throws Exception {
    Scanner sc=new Scanner(new FileReader("input.txt"));
    PrintWriter pw=new PrintWriter(new FileWriter("output.txt"));
    int T=sc.nextInt();
    for(int t=0 ; t<T ; t++){
      System.out.println("case "+t);
      pw.print("Case #"+(t+1)+": ");
      int R=sc.nextInt();
      long k=sc.nextLong();
      int N=sc.nextInt();
      long[] g=new long[N];
      for(int i=0 ; i<N ; i++)g[i]=sc.nextLong();
      int[] next=new int[N];
      long[] add=new long[N];
      for(int i=0 ; i<N ; i++){
        int cur=i ;
        long free=k ;
        while(free>=g[cur]){
          free-=g[cur];
          cur++;
          if(cur==N)cur=0 ;
          if(cur==i)break ;
        }
        next[i]=cur ;
        add[i]=k-free ;
      }
      long res=0 ;
      int cur=0 ;
      for(int i=0 ; i<R ; i++){
        res+=add[cur];
        cur=next[cur];
      }
      pw.println(res);
    }
    pw.flush();
    pw.close();
    sc.close();
  }
  public static void main(String[] args)throws Exception {
(new Solution()).doMain();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
   operation doMain() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt"))) ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < T do ( (     OclFile["System.out"].println("case " + t) ; 
     skip ; 
    var R : int ; R := sc.getCurrent()->toInteger() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var g : Sequence(long) ; g := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     g[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var next : Sequence(int) ; next := Integer.subrange(1,N)->collect(0) ;
    var add : Sequence(long) ; add := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     var cur : int ; cur := i ;
     var free : long ; free := k ;
    while (free >= g[cur+1]) do (     free := free-(g[cur+1]) ; 
     cur := cur + 1 ; 
     if (cur = N) then     cur := 0 ; else skip ; 
     if (cur = i) then     break else skip ) ; 
    next[i+1] := cur ; 
    add[i+1] := k - free ; 
 )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
    var cur : int ; cur := 0 ;
        var i : int ; i := 0 ; while i < R do ( (     res := res+(add[cur+1]) ; 
     cur := next[cur+1] )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Solution.newSolution()).doMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class P669A_LittleArtemAndPresents {
  public static void main(String[] subhani)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    solve(n);
  }
  public static void solve(int n){
    System.out.println((n/3)*2+(n % 3==0 ? 0 : 1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class P669A_LittleArtemAndPresents {
  static   operation main( subhani : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
     execute solve(n) );
  static   operation solve( n : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((n / 3) * 2 + (if n mod 3 = 0 then 0 else 1 endif)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int l=0,c=0 ;
    while(n>0){
      if(l==0){
        n-=1 ;
        l=1 ;
        c++;
      }
      else if(l==1 && n>=2){
        n-=2 ;
        c++;
        l=2 ;
      }
      else if(l==2){
        n-=1 ;
        c++;
        l=1 ;
      }
      else break ;
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var l : int ; l := 0 ;
    var c : int ; c := 0 ;
    while (n > 0) do (     if (l = 0) then (     n := n-(1) ; 
     l := 1 ; 
     c := c + 1 ) else     if (l = 1 & n >= 2) then (     n := n-(2) ; 
     c := c + 1 ; 
     l := 2 ) else     if (l = 2) then (     n := n-(1) ; 
     c := c + 1 ; 
     l := 1 ) else     break ;  ;  ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    double num ;
    Scanner sc=new Scanner(System.in);
    Doctor d ;
    while(true){
      num=sc.nextDouble();
      if(num<0){
        break ;
      }
      d=new Doctor(num);
      if(d.judge()){
        System.out.println(d.getBD());
      }
      else {
        System.out.println("NA");
      }
    }
  }
}
class Doctor {
  double num ;
  String bd ;
  int integers ;
  double decimals ;
  Doctor(double num){
    this.num=num ;
    bd="" ;
    integers=(int)num ;
    decimals=new BigDecimal(num-integers).setScale(4,BigDecimal.ROUND_UP).doubleValue();
  }
  public boolean judge(){
    if(integers>255 || decimals>0.9375){
      return false ;
    }
    return true ;
  }
  private boolean toBinaryDigits(){
    String tmp="" ;
    int count=1 ;
    for(int i=integers ; i>0 ; i/=2){
      tmp+=i % 2 ;
    }
    StringBuffer sb=new StringBuffer(tmp);
    for(int i=0 ; i<8-tmp.length(); i++){
      bd+="0" ;
    }
    bd+=sb.reverse().toString()+"." ;
    while(true){
      if(decimals==0){
        bd+="0000" ;
        break ;
      }
      if(count>4){
        return false ;
      }
      decimals*=2 ;
      if(decimals>=1){
        decimals-=1 ;
        bd+="1" ;
        if(decimals==0){
          for(int i=0 ; i<4-count ; i++){
            bd+="0" ;
          }
          break ;
        }
      }
      else {
        bd+="0" ;
      }
      count++;
    }
    return true ;
  }
  public String getBD(){
    if(toBinaryDigits()){
      return bd ;
    }
    return "NA" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : double ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : Doctor ;
     while (true) do (     num := sc.getCurrent()->toReal() ; 
     if (num < 0) then (     break ) else skip ; 
     d := Doctor.newDoctor(num) ; 
     if (d.judge()) then (     OclFile["System.out"].println(d.getBD()) ) else (     OclFile["System.out"].println("NA") ) ) );
}
class Doctor {
   attribute num : double;
   attribute bd : String;
   attribute integers : int;
   attribute decimals : double;
   static operation newDoctor( num : double) : Doctor
  pre: true
  post: true
  activity:
  ( var self : Doctor ;
    self := createDoctor();
    self.initialise(num);
    return self );
  operation initialise( num : double) : void
  pre: true  post: true
  activity: (     self.num := num ; 
     bd := "" ; 
     integers := num->oclAsType(int) ; 
     decimals := double(num - integers).setScale(4, ROUND_UP)->oclAsType(double) );
   operation judge() : boolean
  pre: true
  post: true
  activity: (     if (integers > 255 or decimals > 0.9375) then (     return false ) else skip ; 
     return true );
   operation toBinaryDigits() : boolean
  pre: true
  post: true
  activity: (     var tmp : String ; tmp := "" ;
     var count : int ; count := 1 ;
        var i : int ; i := integers ; while i > 0 do ( (     tmp := tmp+(i mod 2) )  ;     i := i/(2) ) ; 
    var sb : String ; sb := StringLib.newString(tmp) ;
        var i : int ; i := 0 ; while i < 8 - tmp->size() do ( (     bd := bd+("0") )  ;     i := i + 1 ) ; 
    bd := bd+(sb->reverse()+"" + ".") ; 
    while (true) do (     if (decimals = 0) then (     bd := bd+("0000") ; 
     break ) else skip ; 
     if (count > 4) then (     return false ) else skip ; 
    decimals := decimals*(2) ; 
    if (decimals >= 1) then (     decimals := decimals-(1) ; 
     bd := bd+("1") ; 
     if (decimals = 0) then (         var i : int ; i := 0 ; while i < 4 - (count)->char2byte() do ( (     bd := bd+("0") )  ;     i := i + 1 ) ; 
     break ) else skip ) else (     bd := bd+("0") ) ;  
    count := count + 1 ; 
 ) ; 
    return true 
 );
   operation getBD() : String
  pre: true
  post: true
  activity: (     if (toBinaryDigits()) then (     return bd ) else skip ; 
     return "NA" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    while(sc.hasNext()){
      double x=sc.nextDouble();
      if(x<0)break ;
      x*=16 ;
      if(x-(int)x>1e-6){
        System.out.println("NA");
      }
      else if(x>(1<<12)){
        System.out.println("NA");
      }
      else {
        int y=(int)x ;
        for(int i=11 ; i>3 ; i--){
          System.out.print(y>>i & 1);
        }
        System.out.print(".");
        for(int i=3 ; i>=0 ; i--){
          System.out.print(y>>i & 1);
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     var x : double ; x := sc.getCurrent()->toReal() ;
     if (x < 0) then     break else skip ; 
     x := x*(16) ; 
     if (x - x->oclAsType(int) > 1e-6) then (     OclFile["System.out"].println("NA") ) else     if (x > ((1*(2->pow(12)))->oclAsType(long))) then (     OclFile["System.out"].println("NA") ) else (     var y : int ; y := x->oclAsType(int) ;
         var i : int ; i := 11 ; while i > 3 do ( (     OclFile["System.out"].print(MathLib.bitwiseAnd((y/(2->pow(i)))->oclAsType(long),1)) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].print(".") ; 
        var i : int ; i := 3 ; while i >= 0 do ( (     OclFile["System.out"].print(MathLib.bitwiseAnd((y/(2->pow(i)))->oclAsType(long),1)) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader reader=new BufferedReader(isr);
    int n=Integer.valueOf(reader.readLine());
    int m=Integer.valueOf(reader.readLine());
    int cost[][]=new int[n][n];
    for(int i=0 ; i<n ; i++){
      Arrays.fill(cost[i],1<<29);
    }
    for(int i=0 ; i<m ; i++){
      String str[]=reader.readLine().split(",");
      int a=Integer.valueOf(str[0])-1 ;
      int b=Integer.valueOf(str[1])-1 ;
      cost[a][b]=Integer.valueOf(str[2]);
      cost[b][a]=Integer.valueOf(str[3]);
    }
    for(int k=0 ; k<n ; k++){
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          cost[i][j]=Math.min(cost[i][j],cost[i][k]+cost[k][j]);
        }
      }
    }
    String str[]=reader.readLine().split(",");
    int a=Integer.valueOf(str[0])-1 ;
    int b=Integer.valueOf(str[1])-1 ;
    int c=Integer.valueOf(str[2]);
    int d=Integer.valueOf(str[3]);
    System.out.println(c-d-cost[a][b]-cost[b][a]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(isr) ;
    var n : int ; n := (reader.readLine())->toInteger() ;
    var m : int ; m := (reader.readLine())->toInteger() ;
    var cost : Sequence(Sequence(int)) ; cost := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     cost[i+1] := cost[i+1]->collect((1*(2->pow(29)))->oclAsType(long)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var str : Sequence(String) ; str := reader.readLine()->split(",") ;
     var a : int ; a := (str[0+1])->toInteger() - 1 ;
    var b : int ; b := (str[1+1])->toInteger() - 1 ;
    cost[a+1][b+1] := (str[2+1])->toInteger() ; 
    cost[b+1][a+1] := (str[3+1])->toInteger() ; 
 )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < n do ( (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     cost[i+1][j+1] := Set{cost[i+1][j+1], cost[i+1][k+1] + cost[k+1][j+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    var str : Sequence(String) ; str := reader.readLine()->split(",") ;
    var a : int ; a := (str[0+1])->toInteger() - 1 ;
    var b : int ; b := (str[1+1])->toInteger() - 1 ;
    var c : int ; c := (str[2+1])->toInteger() ;
    var d : int ; d := (str[3+1])->toInteger() ;
    OclFile["System.out"].println(c - d - cost[a+1][b+1] - cost[b+1][a+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  Scanner sc=new Scanner(System.in);
  double n ;
  boolean[] bitsI ;
  boolean[] bitsD ;
  boolean NA ;
  int a ;
  double b ;
  void run(){
    while(sc.hasNext()){
      n=sc.nextDouble();
      if(n<0)break ;
      bitsI=new boolean[8];
      bitsD=new boolean[4];
      NA=false ;
      a=(int)n/1 ;
      b=n-a ;
      NA=getBitD()|| getBitI();
      if(NA)System.out.println("NA");
      else show();
    }
  }
  boolean getBitI(){
    if(a>255)return true ;
    int c=128 ;
    for(int i=0 ; i<bitsI.length ; i++){
      if(a>=c){
        bitsI[i]=true ;
        a-=c ;
      }
      c/=2 ;
    }
    if(a==0)return false ;
    return true ;
  }
  boolean getBitD(){
    double c=0.5 ;
    for(int i=0 ; i<bitsD.length ; i++){
      if(b>=c){
        bitsD[i]=true ;
        b-=c ;
      }
      c/=2 ;
    }
    if(b==0.0)return false ;
    return true ;
  }
  void show(){
    for(int i=0 ; i<bitsI.length ; i++)System.out.print(bitsI[i] ? "1" : "0");
    System.out.print(".");
    for(int i=0 ; i<bitsD.length ; i++)System.out.print(bitsD[i] ? "1" : "0");
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute n : double;
   attribute bitsI : Sequence(boolean);
   attribute bitsD : Sequence(boolean);
   attribute NA : boolean;
   attribute a : int;
   attribute b : double;
   operation run() : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     n := sc.getCurrent()->toReal() ; 
     if (n < 0) then     break else skip ; 
    bitsI := Integer.subrange(1,8)->collect(false) ; 
    bitsD := Integer.subrange(1,4)->collect(false) ; 
    NA := false ; 
    a := n->oclAsType(int) / 1 ; 
    b := n - a ; 
    NA := getBitD() or getBitI() ; 
    if (NA) then     OclFile["System.out"].println("NA") else     execute show() ; ;  
 ) );
   operation getBitI() : boolean
  pre: true
  post: true
  activity: (     if (a > 255) then     return true else skip ; 
     var c : int ; c := 128 ;
        var i : int ; i := 0 ; while i < bitsI->size() do ( (     if (a >= c) then (     bitsI[i+1] := true ; 
     a := a-(c) ) else skip ; 
     c := c/(2) )  ;     i := i + 1 ) ; 
    if (a = 0) then     return false else skip ; 
    return true 
 );
   operation getBitD() : boolean
  pre: true
  post: true
  activity: (     var c : double ; c := 0.5 ;
         var i : int ; i := 0 ; while i < bitsD->size() do ( (     if (b >= c) then (     bitsD[i+1] := true ; 
     b := b-(c) ) else skip ; 
     c := c/(2) )  ;     i := i + 1 ) ; 
     if (b = 0.0) then     return false else skip ; 
     return true );
   operation show() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < bitsI->size() do (     OclFile["System.out"].print(if bitsI[i+1] then "1" else "0" endif) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(".") ; 
         var i : int ; i := 0 ; while i < bitsD->size() do (     OclFile["System.out"].print(if bitsD[i+1] then "1" else "0" endif) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static double[] shou={
    0.0,0.5,0.25,0.125,0.0625 };
    public static void main(String[] args){
      Scanner cin=new Scanner(System.in);
      label : while(true){
        double d=cin.nextDouble();
        if(d<0.0){
          break ;
        }
        int dd=(int)d ;
        String seisuubu=Integer.toBinaryString(dd);
        if(seisuubu.length()>8){
          System.out.println("NA");
          continue ;
        }
        d=d-(double)dd ;
        for(int i=seisuubu.length(); i<8 ; i++){
          seisuubu="0"+seisuubu ;
        }
        if(d==0.0){
          System.out.println(seisuubu+"."+"0000");
          continue ;
        }
        for(int i=0 ; i<2 ; i++){
          for(int j=0 ; j<2 ; j++){
            for(int k=0 ; k<2 ; k++){
              for(int h=0 ; h<2 ; h++){
                double value=0.0 ;
                if(i==1){
                  value+=shou[1];
                }
                if(j==1){
                  value+=shou[2];
                }
                if(k==1){
                  value+=shou[3];
                }
                if(h==1){
                  value+=shou[4];
                }
                if(value==d){
                  System.out.print(seisuubu+".");
                  System.out.println(i+""+j+""+k+""+h);
                  continue label ;
                }
              }
            }
          }
        }
        System.out.println("NA");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute shou : Sequence(double) := Sequence{0.0,0.5,0.25,0.125,0.0625};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var d : double ; d := cin.getCurrent()->toReal() ;
     if (d < 0.0) then (     break ) else skip ; 
    var dd : int ; dd := d->oclAsType(int) ;
    var seisuubu : String ; seisuubu := (MathLib.decimal2binary(dd) + "") ;
    if (seisuubu->size() > 8) then (     OclFile["System.out"].println("NA") ; 
     continue ) else skip ; 
    d := d - dd->oclAsType(double) ; 
        var i : int ; i := seisuubu->size() ; while i < 8 do ( (     seisuubu := "0" + seisuubu )  ;     i := i + 1 ) ; 
    if (d = 0.0) then (     OclFile["System.out"].println(seisuubu + "." + "0000") ; 
     continue ) else skip ; 
        var i : int ; i := 0 ; while i < 2 do ( (         var j : int ; j := 0 ; while j < 2 do ( (         var k : int ; k := 0 ; while k < 2 do ( (         var h : int ; h := 0 ; while h < 2 do ( (     var value : double ; value := 0.0 ;
     if (i = 1) then (     value := value+(shou[1+1]) ) else skip ; 
    if (j = 1) then (     value := value+(shou[2+1]) ) else skip ; 
    if (k = 1) then (     value := value+(shou[3+1]) ) else skip ; 
    if (h = 1) then (     value := value+(shou[4+1]) ) else skip ; 
    if (value = d) then (     OclFile["System.out"].print(seisuubu + ".") ; 
     OclFile["System.out"].println(i + "" + j + "" + k + "" + h) ; 
     continue ) else skip ; 
 )  ;     h := h + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NA") ; 
 ) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      double n=in.nextDouble();
      if(n<0)return ;
      int bs4=(int)(n*16);
      if(bs4/16.0!=n || bs4>=4096)System.out.println("NA");
      else {
        BigInteger b=new BigInteger(bs4+"");
        String st=b.toString(2);
        while(st.length()<12)st="0"+st ;
        StringBuilder sb=new StringBuilder();
        sb.append(st);
        sb.insert(8,".");
        System.out.println(sb);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : double ; n := in.getCurrent()->toReal() ;
     if (n < 0) then     return else skip ; 
     var bs4 : int ; bs4 := (n * 16)->oclAsType(int) ;
     if (bs4 / 16.0 /= n or bs4 >= 4096) then     OclFile["System.out"].println("NA") ; else (     var b : long ; b := long(bs4 + "") ;
     var st : String ; st := b.toString(2) ;
    while (st->size() < 12) do     st := "0" + st ; ; 
    var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString(st) ; 
    sb := sb.insertAt(8+1, StringLib.newString(".")) ; 
    OclFile["System.out"].println(sb) ; 
 ) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int digSum(int n){
    int sum=0,rem=0 ;
    while(n>0){
      rem=n % 10 ;
      sum+=rem ;
      n/=10 ;
    }
    return sum ;
  }
  static int findX(int n){
    for(int i=0 ; i<=n ; i++)if(i+digSum(i)==n)return i ;
    return-1 ;
  }
  public static void main(String[] args){
    int n=43 ;
    System.out.println("x="+findX(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation digSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
    var rem : int ; rem := 0 ;
     while (n > 0) do (     rem := n mod 10 ; 
     sum := sum+(rem) ; 
     n := n/(10) ) ; 
     return sum );
  static   operation findX( n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= n do (     if (i + digSum(i) = n) then     return i else skip ;  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 43 ;
     OclFile["System.out"].println("x=" + findX(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Map.Entry ;
class Main {
  static int mod=(int)(Math.pow(10,9)+7);
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++){
      a[Integer.parseInt(sc.next())-1]=i ;
    }
    long ans=1 ;
    long cnt=1 ;
    for(int i=0 ; i<N ; i++){
      if(i!=N-1 && a[i]<a[i+1])cnt++;
      else {
        ans=Math.max(ans,cnt);
        cnt=1 ;
      }
    }
    ans=Math.max(ans,cnt);
    ans=N-ans ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := (10->pow(9) + 7)->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[(sc.getCurrent())->toInteger() - 1+1] := i )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 1 ;
    var cnt : long ; cnt := 1 ;
        var i : int ; i := 0 ; while i < N do ( (     if (i /= N - 1 & a[i+1] < a[i + 1+1]) then     cnt := cnt + 1 ; else (     ans := Set{ans, cnt}->max() ; 
     cnt := 1 ) )  ;     i := i + 1 ) ; 
    ans := Set{ans, cnt}->max() ; 
    ans := N - ans ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_FindDivisible {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String f ;
    int t ;
    String l,r ;
    t=scanner.nextInt();
    while(t>0){
      try {
        l=scanner.next();
        r=scanner.next();
        System.out.println(l+" "+Integer.parseInt(l)*2);
        t--;
      }
      catch(Exception e){
        System.exit(0);
      }
    }
    System.exit(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_FindDivisible {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var f : String ;
    var t : int ;
    var l : String ;
    var r : String ;
    t := scanner.getCurrent()->toInteger() ; 
    while (t > 0) do (     try (     l := scanner.getCurrent() ; 
     r := scanner.getCurrent() ; 
     OclFile["System.out"].println(l + " " + (l)->toInteger() * 2) ; 
     t := t - 1 )   catch (e : ProgramException) do ( OclProcess.exit(0) )
 ) ; 
OclProcess.exit(0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
import static java.lang.Math.max ;
import static java.lang.System.exit ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  static void solve()throws Exception {
    int n=scanInt();
    int pi[]=new int[n];
    for(int i=0 ; i<n ; i++){
      pi[scanInt()-1]=i ;
    }
    int ans=0 ;
    for(int i=0,j ; i<n ; i=j){
      for(j=i+1 ; j<n && pi[j]>pi[j-1]; j++){
      }
      ans=max(ans,j-i);
    }
    out.print(n-ans);
  }
  static int scanInt()throws IOException {
    return parseInt(scanString());
  }
  static long scanLong()throws IOException {
    return parseLong(scanString());
  }
  static String scanString()throws IOException {
    while(tok==null || ! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  public static void main(String[] args){
    try {
      in=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(System.out);
      solve();
      in.close();
      out.close();
    }
    catch(Throwable e){
      e.printStackTrace();
      exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanInt() ;
     var pi : Sequence(int) ; pi := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     pi[scanInt() - 1+1] := i )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ;
    var j : int ; while i < n do ( (         j := i + 1 ; while j < n & pi[j+1] > pi[j - 1+1] do ( skip  ;     j := j + 1 ) ; 
     ans := Set{ans, j - i}->max() )  ;     i := j ) ; 
    out.print(n - ans) ; 
 );
  static   operation scanInt() : int
  pre: true
  post: true
  activity: (     return (scanString() + "")->toInteger() );
  static   operation scanLong() : long
  pre: true
  post: true
  activity: (     return parseLong(scanString()) );
  static   operation scanString() : String
  pre: true
  post: true
  activity: (     while (tok = null or not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return tok.next() );
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
     execute exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public void main(Scanner sc){
    int n=sc.nextInt();
    int p[]=new int[n];
    int q[]=new int[n];
    for(int i=0 ; i<n ; i++){
      p[i]=sc.nextInt();
      q[p[i]-1]=i+1 ;
    }
    int max=0 ;
    int cnt=0 ;
    for(int i=0 ; i<n-1 ; i++){
      cnt++;
      if(q[i]>q[i+1]){
        max=Math.max(max,cnt);
        cnt=0 ;
      }
    }
    max=Math.max(max,cnt+1);
    System.out.println(n-max);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    new Main().main(sc);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    var q : Sequence(int) ; q := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := sc.nextInt() ; 
     q[p[i+1] - 1+1] := i + 1 )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     cnt := cnt + 1 ; 
     if (q[i+1] > q[i + 1+1]) then (     max := Set{max, cnt}->max() ; 
     cnt := 0 ) else skip )  ;     i := i + 1 ) ; 
    max := Set{max, cnt + 1}->max() ; 
    OclFile["System.out"].println(n - max) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Main.newMain().main(sc) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int[] P=new int[N];
    for(int i=0 ; i<N ; ++i)P[i]=scan.nextInt()-1 ;
    Map<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<N ; ++i)map.put(P[i],i);
    List<Integer>nglist=new ArrayList<>();
    for(int i=0 ; i<N-1 ; ++i)if(map.get(i)>map.get(i+1))nglist.add(i);
    if(nglist.isEmpty()){
      System.out.println(0);
      return ;
    }
    int ans=Math.min(N-nglist.get(0)-1,nglist.get(nglist.size()-1)+1);
    for(int i=0 ; i<nglist.size()-1 ; ++i){
      ans=Math.min(nglist.get(i)+1+N-nglist.get(i+1)-1,ans);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var P : Sequence(int) ; P := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     P[i+1] := scan.getCurrent()->toInteger() - 1 ;  ;     i := i + 1 ) ; 
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < N do (     map := map->union(Map{P[i+1] |-> i}) ;  ;     i := i + 1 ) ; 
    var nglist : Sequence(int) ; nglist := Sequence{} ;
        var i : int ; i := 0 ; while i < N - 1 do (     if (map->at(i) > map->at(i + 1)) then     nglist := nglist->including(i) ; else skip ;  ;     i := i + 1 ) ; 
    if (nglist->isEmpty()) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var ans : int ; ans := Set{N - nglist->at(0+1) - 1, nglist->at(nglist->size() - 1+1) + 1}->min() ;
        var i : int ; i := 0 ; while i < nglist->size() - 1 do ( (     ans := Set{nglist->at(i+1) + 1 + N - nglist->at(i + 1+1) - 1, ans}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    new Main().run();
  }
  public void run()throws NumberFormatException,IOException {
    BufferedReader file=new BufferedReader(new InputStreamReader(System.in));
    int N=Integer.parseInt(file.readLine());
    boolean[] bools=new boolean[N+1];
    int[] ints=new int[N+1];
    int max=0 ;
    for(int i=0 ; i<N ; i++){
      int x=Integer.parseInt(file.readLine());
      bools[x]=true ;
      if(bools[x-1])ints[x]=ints[x-1];
      else ints[x]=x ;
      max=Math.max(max,x-ints[x]+1);
    }
    System.out.println(N-max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var file : OclFile ; file := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var N : int ; N := (file.readLine())->toInteger() ;
    var bools : Sequence(boolean) ; bools := Integer.subrange(1,N + 1)->collect(false) ;
    var ints : Sequence(int) ; ints := Integer.subrange(1,N + 1)->collect(0) ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var x : int ; x := (file.readLine())->toInteger() ;
     bools[x+1] := true ; 
     if (bools[x - 1+1]) then     ints[x+1] := ints[x - 1+1] else     ints[x+1] := x ; ;  
     max := Set{max, x - ints[x+1] + 1}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(N - max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  private void compute(){
    Scanner scanner=new Scanner(System.in);
    for(int i=0 ; i<7 ; i++){
      int nHigh=scanner.nextInt();
      int nLow=scanner.nextInt();
      System.out.println(nHigh-nLow);
    }
  }
  public static void main(String args[]){
    new Main().compute();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation compute() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var i : int ; i := 0 ; while i < 7 do ( (     var nHigh : int ; nHigh := scanner.getCurrent()->toInteger() ;
     var nLow : int ; nLow := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(nHigh - nLow) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().compute() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  int n,m ;
  int[][] map ;
  int cost ;
  int expense ;
  void run(){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    m=sc.nextInt();
    map=new int[n][n];
    for(int i=0 ; i<n ; i++){
      fill(map[i],INF);
    }
    for(int i=0 ; i<m ; i++){
      String[] str=sc.next().split(",");
      int a=Integer.parseInt(str[0])-1 ;
      int b=Integer.parseInt(str[1])-1 ;
      int c=Integer.parseInt(str[2]);
      int d=Integer.parseInt(str[3]);
      map[a][b]=c ;
      map[b][a]=d ;
    }
    wf();
    String[] str=sc.next().split(",");
    int f=Integer.parseInt(str[0])-1 ;
    int t=Integer.parseInt(str[1])-1 ;
    cost=Integer.parseInt(str[2]);
    expense=Integer.parseInt(str[3]);
    System.out.println(cost-expense-map[f][t]-map[t][f]);
  }
  void wf(){
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)for(int k=0 ; k<n ; k++){
      map[i][k]=min(map[i][k],map[i][j]+map[j][k]);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute n : int;
   attribute map : Sequence(Sequence(int));
   attribute cost : int;
   attribute expense : int;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
    map := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
        var i : int ; i := 0 ; while i < n do ( (     execute fill(map[i+1], INF) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var str : Sequence(String) ; str := sc.getCurrent()->split(",") ;
     var a : int ; a := (str[0+1])->toInteger() - 1 ;
    var b : int ; b := (str[1+1])->toInteger() - 1 ;
    var c : int ; c := (str[2+1])->toInteger() ;
    var d : int ; d := (str[3+1])->toInteger() ;
    map[a+1][b+1] := c ; 
    map[b+1][a+1] := d ; 
 )  ;     i := i + 1 ) ; 
    execute wf() ; 
    var str : Sequence(String) ; str := sc.getCurrent()->split(",") ;
    var f : int ; f := (str[0+1])->toInteger() - 1 ;
    var t : int ; t := (str[1+1])->toInteger() - 1 ;
    cost := (str[2+1])->toInteger() ; 
    expense := (str[3+1])->toInteger() ; 
    OclFile["System.out"].println(cost - expense - map[f+1][t+1] - map[t+1][f+1]) ; 
 );
   operation wf() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (         var k : int ; k := 0 ; while k < n do ( (     map[i+1][k+1] := Set{map[i+1][k+1], map[i+1][j+1] + map[j+1][k+1]}->min() )  ;     k := k + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  int[] a=new int[8];
  int[] b=new int[8];
  int[] sa=new int[8];
  int nikka ;
  int ww ;
  public void syukei(){
    for(nikka=1 ; nikka<8 ; nikka++){
      a[nikka]=sc.nextInt();
      b[nikka]=sc.nextInt();
      sa[nikka]=a[nikka]-b[nikka];
    }
  }
  public void hyouji(){
    for(ww=1 ; ww<8 ; ww++){
      System.out.println(sa[ww]);
    }
  }
  public static void main(String[] args){
    Main wao=new Main();
    wao.syukei();
    wao.hyouji();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute a : Sequence(int) := Integer.subrange(1,8)->collect(0);
   attribute b : Sequence(int) := Integer.subrange(1,8)->collect(0);
   attribute sa : Sequence(int) := Integer.subrange(1,8)->collect(0);
   attribute nikka : int;
   attribute ww : int;
   operation syukei() : void
  pre: true
  post: true
  activity: (         nikka := 1 ; while nikka < 8 do ( (     a[nikka+1] := sc.getCurrent()->toInteger() ; 
     b[nikka+1] := sc.getCurrent()->toInteger() ; 
     sa[nikka+1] := a[nikka+1] - b[nikka+1] )  ;     nikka := nikka + 1 ) );
   operation hyouji() : void
  pre: true
  post: true
  activity: (         ww := 1 ; while ww < 8 do ( (     OclFile["System.out"].println(sa[ww+1]) )  ;     ww := ww + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var wao : Main ; wao := Main.newMain() ;
     wao.syukei() ; 
     wao.hyouji() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int a[]=new int[14];
    int b[]=new int[7];
    for(int i=0 ; i<14 ; i++){
      a[i]=stdIn.nextInt();
    }
    for(int i=0,j=0 ; i<7 ; i++){
      b[i]=a[j]-a[j+1];
      j=j+2 ;
    }
    for(int i=0 ; i<7 ; i++){
      System.out.println(b[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,14)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,7)->collect(0) ;
        var i : int ; i := 0 ; while i < 14 do ( (     a[i+1] := stdIn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ;
    var j : int ; j := 0 ; while i < 7 do ( (     b[i+1] := a[j+1] - a[j + 1+1] ; 
     j := j + 2 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 7 do ( (     OclFile["System.out"].println(b[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  int n ;
  int[] onndosa={
    1,2,3,4,5,6,7 };
    public void nyuuryoku(){
      for(n=0 ; n<=6 ; n++){
        int saikou=sc.nextInt();
        int saitei=sc.nextInt();
        onndosa[n]=saikou-saitei ;
      }
    }
    public void syuturyoku(){
      for(n=0 ; n<=6 ; n++){
        System.out.println(onndosa[n]);
      }
    }
    public static void main(String[] args){
      Main toi=new Main();
      toi.nyuuryoku();
      toi.syuturyoku();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute n : int;
   attribute onndosa : Sequence(int) := Sequence{1,2,3,4,5,6,7};
   operation nyuuryoku() : void
  pre: true
  post: true
  activity: (         n := 0 ; while n <= 6 do ( (     var saikou : int ; saikou := sc.getCurrent()->toInteger() ;
     var saitei : int ; saitei := sc.getCurrent()->toInteger() ;
     onndosa[n+1] := saikou - saitei )  ;     n := n + 1 ) );
   operation syuturyoku() : void
  pre: true
  post: true
  activity: (         n := 0 ; while n <= 6 do ( (     OclFile["System.out"].println(onndosa[n+1]) )  ;     n := n + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var toi : Main ; toi := Main.newMain() ;
     toi.nyuuryoku() ; 
     toi.syuturyoku() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private void compute(){
    Scanner scanner=new Scanner(System.in);
    for(int i=0 ; i<7 ; i++){
      int nHigh=scanner.nextInt();
      int nLow=scanner.nextInt();
      System.out.println(nHigh-nLow);
    }
  }
  public static void main(String[] args){
    new Main().compute();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation compute() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var i : int ; i := 0 ; while i < 7 do ( (     var nHigh : int ; nHigh := scanner.getCurrent()->toInteger() ;
     var nLow : int ; nLow := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(nHigh - nLow) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().compute() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long l=sc.nextLong(),r=sc.nextLong();
      if(l==1){
        System.out.println(l+" "+(l+1));
      }
      else {
        System.out.println(l+" "+(2*l));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var l : long ; l := sc.getCurrent()->toLong() ;
    var r : long ; r := sc.getCurrent()->toLong() ;
     if (l = 1) then (     OclFile["System.out"].println(l + " " + (l + 1)) ) else (     OclFile["System.out"].println(l + " " + (2 * l)) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double nthRoot(int A,int N){
    double xPre=Math.random()% 10 ;
    double eps=0.001 ;
    double delX=2147483647 ;
    double xK=0.0 ;
    while(delX>eps){
      xK=((N-1.0)*xPre+(double)A/Math.pow(xPre,N-1))/(double)N ;
      delX=Math.abs(xK-xPre);
      xPre=xK ;
    }
    return xK ;
  }
  public static void main(String[] args){
    int N=4 ;
    int A=81 ;
    double nthRootValue=nthRoot(A,N);
    System.out.println("Nth root is "+Math.round(nthRootValue*1000.0)/1000.0);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nthRoot( A : int, N : int) : double
  pre: true
  post: true
  activity: (     var xPre : double ; xPre := MathLib.random() mod 10 ;
     var eps : double ; eps := 0.001 ;
    var delX : double ; delX := 2147483647 ;
    var xK : double ; xK := 0.0 ;
    while (delX > eps) do (     xK := ((N - 1.0) * xPre + A->oclAsType(double) / xPre->pow(N - 1)) / N->oclAsType(double) ; 
     delX := if xK - xPre < 0 then -(xK - xPre) else xK - xPre endif ; 
     xPre := xK ) ; 
    return xK 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     var A : int ; A := 81 ;
     var nthRootValue : double ; nthRootValue := nthRoot(A, N) ;
     OclFile["System.out"].println("Nth root is " + (nthRootValue * 1000.0)->round() / 1000.0) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int X=sc.nextInt();
    int Y=sc.nextInt();
    int Z=sc.nextInt();
    int K=sc.nextInt();
    long[] A=new long[X+1];
    long[] B=new long[Y+1];
    long[] C=new long[Z+1];
    for(int i=1 ; i<=X ; i++){
      A[i]=sc.nextLong();
    }
    for(int i=1 ; i<=Y ; i++){
      B[i]=sc.nextLong();
    }
    for(int i=1 ; i<=Z ; i++){
      C[i]=sc.nextLong();
    }
    sc.close();
    long[] ANS=new long[1000000];
    Arrays.sort(A);
    Arrays.sort(B);
    Arrays.sort(C);
    int count=0 ;
    for(int i=1 ; i<=X ; i++){
      for(int j=1 ; j<=Y ; j++){
        for(int k=1 ; k<=Z ; k++){
          if(i*j*k<=3000){
            ANS[count]=A[X+1-i]+B[Y+1-j]+C[Z+1-k];
            count++;
          }
          else {
            break ;
          }
        }
      }
    }
    Arrays.sort(ANS);
    int p=ANS.length ;
    for(int i=0 ; i<K ; i++){
      System.out.println(ANS[p-i-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : int ; X := sc.getCurrent()->toInteger() ;
    var Y : int ; Y := sc.getCurrent()->toInteger() ;
    var Z : int ; Z := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var A : Sequence(long) ; A := Integer.subrange(1,X + 1)->collect(0) ;
    var B : Sequence(long) ; B := Integer.subrange(1,Y + 1)->collect(0) ;
    var C : Sequence(long) ; C := Integer.subrange(1,Z + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= X do ( (     A[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= Y do ( (     B[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= Z do ( (     C[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    skip ; 
    var ANS : Sequence(long) ; ANS := Integer.subrange(1,1000000)->collect(0) ;
    A := A->sort() ; 
    B := B->sort() ; 
    C := C->sort() ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= X do ( (         var j : int ; j := 1 ; while j <= Y do ( (         var k : int ; k := 1 ; while k <= Z do ( (     if (i * j * k <= 3000) then (     ANS[count+1] := A[X + 1 - i+1] + B[Y + 1 - j+1] + C[Z + 1 - k+1] ; 
     count := count + 1 ) else (     break ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    ANS := ANS->sort() ; 
    var p : int ; p := ANS->size() ;
        var i : int ; i := 0 ; while i < K do ( (     OclFile["System.out"].println(ANS[p - i - 1+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int x=sc.nextInt();
    int y=sc.nextInt();
    int z=sc.nextInt();
    int k=sc.nextInt();
    Long[] A=new Long[x];
    Long[] B=new Long[y];
    Long[] C=new Long[z];
    for(int i=0 ; i<x ; i++)A[i]=sc.nextLong();
    for(int i=0 ; i<y ; i++)B[i]=sc.nextLong();
    for(int i=0 ; i<z ; i++)C[i]=sc.nextLong();
    List<Long>abc=new ArrayList<>();
    Arrays.sort(A,Collections.reverseOrder());
    Arrays.sort(B,Collections.reverseOrder());
    Arrays.sort(C,Collections.reverseOrder());
    for(int a=0 ; a<x ; a++){
      for(int b=0 ; b<y ; b++){
        if(a*b>k)break ;
        for(int c=0 ; c<z ; c++){
          if(a*b*c>k)break ;
          abc.add(A[a]+B[b]+C[c]);
        }
      }
    }
    abc.sort(Comparator.reverseOrder());
    for(int i=0 ; i<k ; i++){
      System.out.println(abc.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var z : int ; z := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var A : Sequence(long) ; A := Integer.subrange(1,x)->collect(null) ;
    var B : Sequence(long) ; B := Integer.subrange(1,y)->collect(null) ;
    var C : Sequence(long) ; C := Integer.subrange(1,z)->collect(null) ;
        var i : int ; i := 0 ; while i < x do (     A[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < y do (     B[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < z do (     C[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var abc : Sequence(long) ; abc := Sequence{} ;
    A := OclComparator.sortWith(A, reverseOrder()) ; 
    B := OclComparator.sortWith(B, reverseOrder()) ; 
    C := OclComparator.sortWith(C, reverseOrder()) ; 
        var a : int ; a := 0 ; while a < x do ( (         var b : int ; b := 0 ; while b < y do ( (     if (a * b > k) then     break else skip ; 
         var c : int ; c := 0 ; while c < z do ( (     if (a * b * c > k) then     break else skip ; 
     abc := abc->including(A[a+1] + B[b+1] + C[c+1]) )  ;     c := c + 1 ) )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    abc := abc.sort(Comparator.reverseOrder()) ; 
        var i : int ; i := 0 ; while i < k do ( (     OclFile["System.out"].println(abc->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x[]=new int[3];
    int max=0 ;
    for(int i=0 ; i<3 ; ++i){
      x[i]=sc.nextInt();
      max=Math.max(max,x[i]);
    }
    int k=sc.nextInt();
    List<Long>a[]=new List[3];
    for(int i=0 ; i<3 ; ++i)a[i]=new ArrayList<Long>();
    for(int i=0 ; i<3 ; ++i){
      for(int j=0 ; j<x[i]; ++j)a[i] .add(sc.nextLong());
      Collections.sort(a[i]);
    }
    sc.close();
    List<Long>ans=new ArrayList<Long>();
    for(int i=0 ; i<x[0]; ++i){
      for(int j=0 ; j<x[1]; ++j){
        for(int m=0 ; m<x[2]; ++m){
          if((i+1)*(j+1)*(m+1)<=k){
            long tmp=a[0] .get(x[0]-i-1)+a[1] .get(x[1]-j-1)+a[2] .get(x[2]-m-1);
            ans.add(tmp);
          }
        }
      }
    }
    Collections.sort(ans);
    int n=ans.size();
    for(int i=0 ; i<k ; ++i)System.out.println(ans.get(n-i-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : Sequence(int) ; x := Integer.subrange(1,3)->collect(0) ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     max := Set{max, x[i+1]}->max() )  ;     i := i + 1 ) ; 
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(long)) ; a := Integer.subrange(1,3)->collect(null) ;
        var i : int ; i := 0 ; while i < 3 do (     a[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < x[i+1] do (     a[i+1]->excludes(sc.getCurrent()->toLong()) ;  ;     j := j + 1 ) ; 
     a[i+1] := a[i+1]->sort() )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : Sequence(long) ; ans := Sequence{} ;
        var i : int ; i := 0 ; while i < x[0+1] do ( (         var j : int ; j := 0 ; while j < x[1+1] do ( (         var m : int ; m := 0 ; while m < x[2+1] do ( (     if ((i + 1) * (j + 1) * (m + 1) <= k) then (     var tmp : long ; tmp := a[0+1]->at(x[0+1] - i - 1+1) + a[1+1]->at(x[1+1] - j - 1+1) + a[2+1]->at(x[2+1] - m - 1+1) ;
     ans := ans->including(tmp) ) else skip )  ;     m := m + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    ans := ans->sort() ; 
    var n : int ; n := ans->size() ;
        var i : int ; i := 0 ; while i < k do (     OclFile["System.out"].println(ans->at(n - i - 1+1)) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class Main {
  static public void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int x=scan.nextInt();
    int y=scan.nextInt();
    int z=scan.nextInt();
    int k=scan.nextInt();
    Long[] a=new Long[x];
    Long[] b=new Long[y];
    Long[] c=new Long[z];
    for(int i=0 ; i<x ; i++){
      a[i]=scan.nextLong();
    }
    for(int i=0 ; i<y ; i++){
      b[i]=scan.nextLong();
    }
    for(int i=0 ; i<z ; i++){
      c[i]=scan.nextLong();
    }
    List<Long>all=new ArrayList<>(k);
    Arrays.sort(a,Collections.reverseOrder());
    Arrays.sort(b,Collections.reverseOrder());
    Arrays.sort(c,Collections.reverseOrder());
    int p=0 ;
    for(int i=0 ; i<x ; i++){
      for(int j=0 ; j<y ; j++){
        for(int l=0 ; l<z ; l++){
          if((i+1)*(j+1)*(l+1)<=k){
            all.add(a[i]+b[j]+c[l]);
          }
          else {
            break ;
          }
        }
      }
    }
    Collections.sort(all,Collections.reverseOrder());
    for(int i=0 ; i<k ; i++){
      System.out.println(""+all.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := scan.getCurrent()->toInteger() ;
    var y : int ; y := scan.getCurrent()->toInteger() ;
    var z : int ; z := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,x)->collect(null) ;
    var b : Sequence(long) ; b := Integer.subrange(1,y)->collect(null) ;
    var c : Sequence(long) ; c := Integer.subrange(1,z)->collect(null) ;
        var i : int ; i := 0 ; while i < x do ( (     a[i+1] := scan.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < y do ( (     b[i+1] := scan.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < z do ( (     c[i+1] := scan.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var all : Sequence(long) ; all := Sequence{} ;
    a := OclComparator.sortWith(a, reverseOrder()) ; 
    b := OclComparator.sortWith(b, reverseOrder()) ; 
    c := OclComparator.sortWith(c, reverseOrder()) ; 
    var p : int ; p := 0 ;
        var i : int ; i := 0 ; while i < x do ( (         var j : int ; j := 0 ; while j < y do ( (         var l : int ; l := 0 ; while l < z do ( (     if ((i + 1) * (j + 1) * (l + 1) <= k) then (     all := all->including(a[i+1] + b[j+1] + c[l+1]) ) else (     break ) )  ;     l := l + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    all, reverseOrder() := all, reverseOrder()->sort() ; 
        var i : int ; i := 0 ; while i < k do ( (     OclFile["System.out"].println("" + all->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    int z=sc.nextInt();
    int k=sc.nextInt();
    long a[]=new long[x];
    long b[]=new long[y*x];
    int maxIndex=b.length>3000 ? 3000 : b.length ;
    long c[]=new long[maxIndex*z];
    for(int i=0 ; i<x ; i++){
      a[i]=sc.nextLong();
    }
    int count=0 ;
    for(int i=0 ; i<y ; i++){
      long yTmp=sc.nextLong();
      for(int j=0 ; j<x ; j++){
        b[count]=yTmp+a[j];
        count++;
      }
    }
    Arrays.sort(b);
    count=0 ;
    for(int i=0 ; i<z ; i++){
      long zTmp=sc.nextLong();
      for(int j=0 ; j<maxIndex ; j++){
        c[count]=zTmp+b[x*y-1-j];
        count++;
      }
    }
    Arrays.sort(c);
    for(int i=0 ; i<k ; i++){
      System.out.println(c[c.length-1-i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var z : int ; z := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,x)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,y * x)->collect(0) ;
    var maxIndex : int ; maxIndex := if b->size() > 3000 then 3000 else b->size() endif ;
    var c : Sequence(long) ; c := Integer.subrange(1,maxIndex * z)->collect(0) ;
        var i : int ; i := 0 ; while i < x do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < y do ( (     var yTmp : long ; yTmp := sc.getCurrent()->toLong() ;
         var j : int ; j := 0 ; while j < x do ( (     b[count+1] := yTmp + a[j+1] ; 
     count := count + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    b := b->sort() ; 
    count := 0 ; 
        var i : int ; i := 0 ; while i < z do ( (     var zTmp : long ; zTmp := sc.getCurrent()->toLong() ;
         var j : int ; j := 0 ; while j < maxIndex do ( (     c[count+1] := zTmp + b[x * y - 1 - j+1] ; 
     count := count + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    c := c->sort() ; 
        var i : int ; i := 0 ; while i < k do ( (     OclFile["System.out"].println(c[c->size() - 1 - i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int r1=input.nextInt(),r2=input.nextInt(),c1=input.nextInt(),c2=input.nextInt(),d1=input.nextInt(),d2=input.nextInt();
    if((c1+c2-r1-r2)!=0 ||(d1+d2-r1-r2)!=0)System.out.print(-1);
    else {
      boolean flag=true ;
      int t=(r2-d2+c2)/2,z=d2-c2+t,y=c2-t,x=r1+r2-y-z-t ;
      int[] box={
        x,y,z,t };
        for(int gem : box){
          if(gem>9 || gem<1){
            flag=false ;
            break ;
          }
        }
        if((x==y)||(x==z)||(x==t)||(y==z)||(y==t)||(z==t))flag=false ;
        if(flag)System.out.printf("%d %d%n%d %d",x,y,z,t);
        else System.out.print(-1);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r1 : int ; r1 := input.getCurrent()->toInteger() ;
    var r2 : int ; r2 := input.getCurrent()->toInteger() ;
    var c1 : int ; c1 := input.getCurrent()->toInteger() ;
    var c2 : int ; c2 := input.getCurrent()->toInteger() ;
    var d1 : int ; d1 := input.getCurrent()->toInteger() ;
    var d2 : int ; d2 := input.getCurrent()->toInteger() ;
     if ((c1 + c2 - r1 - r2) /= 0 or (d1 + d2 - r1 - r2) /= 0) then     OclFile["System.out"].print(-1) ; else (     var flag : boolean ; flag := true ;
     var t : int ; t := (r2 - d2 + c2) / 2 ;
    var z : int ; z := d2 - c2 + t ;
    var y : int ; y := c2 - t ;
    var x : int ; x := r1 + r2 - y - z - t ;
    var box : Sequence(int) ; box := Sequence{x,y,z,t} ;
    for (gem : box) do ( (     if (gem > 9 or gem < 1) then (     flag := false ; 
     break ) else skip )  ) ; 
    if ((x = y) or (x = z) or (x = t) or (y = z) or (y = t) or (z = t)) then     flag := false ; else skip ; 
    if (flag) then     OclFile["System.out"].printf("%d %d%n%d %d", x, y, z, t) else     OclFile["System.out"].print(-1) ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class pair {
    int first,second ;
    public pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static void performQueries(int[] A,pair[] q){
    int n=A.length ;
    int[] pref_xor=new int[n+1];
    for(int i=1 ; i<=n ; ++i){
      pref_xor[i]=pref_xor[i-1] ^ A[i-1];
    }
    for(pair i : q){
      int L=i.first,R=i.second ;
      if(L>R){
        int temp=L ;
        L=R ;
        R=temp ;
      }
      if(L!=R && pref_xor[R]==pref_xor[L-1])System.out.println("Yes");
      else System.out.println("No");
    }
  }
  static public void main(String[] arg){
    int[] Arr={
      1,1,2,2,1 };
      pair[] q={
        new pair(1,5),new pair(1,4),new pair(3,4)};
        performQueries(Arr,q);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class pair {
   attribute first : int;
   static operation newpair( first : int, second : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation performQueries( A : Sequence(int), q : Sequence(pair)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := A->size() ;
     var pref_xor : Sequence(int) ; pref_xor := Integer.subrange(1,n + 1)->collect(0) ;
         var i : int ; i := 1 ; while i <= n do ( (     pref_xor[i+1] := pref_xor[i - 1+1] xor A[i - 1+1] )  ;     i := i + 1 ) ; 
     for (i : q) do ( (     var L : int ; L := i->at("first") ;
    var R : int ; R := i->at("second") ;
     if (L > R) then (     var temp : int ; temp := L ;
     L := R ; 
     R := temp ) else skip ; 
     if (L /= R & pref_xor[R+1] = pref_xor[L - 1+1]) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; )  ) );
  static    operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Arr : Sequence(int) ; Arr := Sequence{1,1,2,2,1} ;
     var q : Sequence(pair) ; q := Sequence{pair.newpair(1, 5),pair.newpair(1, 4),pair.newpair(3, 4)} ;
     execute performQueries(Arr, q) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    ArrayList<Integer>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      list.add(in.nextInt());
    }
    Collections.sort(list);
    int c=1 ;
    for(int i=0 ; i<n ; i++){
      if(list.get(i)>=c){
        c++;
      }
    }
    pw.println(c);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var c : int ; c := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (list->at(i+1) >= c) then (     c := c + 1 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    ArrayList<Integer>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      list.add(in.nextInt());
    }
    Collections.sort(list);
    int c=1 ;
    for(int i=0 ; i<n ; i++){
      if(list.get(i)>=c){
        c++;
      }
    }
    pw.println(c);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var c : int ; c := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (list->at(i+1) >= c) then (     c := c + 1 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class P1096A {
  public static void main(String[] args)throws IOException {
    BufferedReader io=new BufferedReader(new InputStreamReader(System.in));
    Integer cnt=Integer.valueOf(io.readLine());
    List<String>rs=new ArrayList<String>();
    while(cnt>0){
      cnt--;
      String[] input=io.readLine().split(" ");
      rs.add(input[0]+" "+String.valueOf(Integer.valueOf(input[0])*2));
    }
    for(String string : rs){
      System.out.println(string);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P1096A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var cnt : int ; cnt := (io.readLine())->toInteger() ;
    var rs : Sequence(String) ; rs := Sequence{} ;
    while (cnt > 0) do (     cnt := cnt - 1 ; 
     var input : Sequence(String) ; input := io.readLine()->split(" ") ;
     rs := rs->including(input[0+1] + " " + (((input[0+1])->toInteger() * 2) + "")) ) ; 
    for (string : rs) do ( (     OclFile["System.out"].println(string) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class E {
  static FastScanner fs=null ;
  public static void main(String[] args){
    fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int t=1 ;
    while(t-->0){
      int n=fs.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=fs.nextInt();
      }
      sort(a);
      int nu=1 ;
      for(int i=0 ; i<n ; i++){
        a[i]=Math.min(a[i],nu);
        nu=1+Math.min(nu,a[i]);
      }
      int ans=a[n-1]+1 ;
      out.println(ans);
    }
    out.close();
  }
  static void sort(int[] a){
    ArrayList<Integer>l=new ArrayList<>();
    for(int i : a)l.add(i);
    Collections.sort(l);
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class E {
  static   attribute fs : FastScanner := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     fs := FastScanner.newFastScanner() ; 
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := 1 ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := fs.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := fs.nextInt() )  ;     i := i + 1 ) ; 
    execute sort(a) ; 
    var nu : int ; nu := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := Set{a[i+1], nu}->min() ; 
     nu := 1 + Set{nu, a[i+1]}->min() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := a[n - 1+1] + 1 ;
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l := l->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Div2_358B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    ArrayList<Long>ls=new ArrayList<>();
    for(int i=0 ; i<n ; i++)ls.add(in.nextLong());
    Collections.sort(ls);
    int Mex=1 ;
    for(int i=0 ; i<n ; i++){
      long cur=ls.get(i);
      if(cur<Mex)continue ;
      if(cur==Mex || cur>Mex){
        Mex++;
      }
    }
    pw.println(Mex);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Div2_358B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var ls : Sequence(long) ; ls := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     ls := ls->including(in.getCurrent()->toLong()) ;  ;     i := i + 1 ) ; 
    ls := ls->sort() ; 
    var Mex : int ; Mex := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     var cur : long ; cur := ls->at(i+1) ;
     if (cur < Mex) then     continue else skip ; 
     if (cur = Mex or cur > Mex) then (     Mex := Mex + 1 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Locale ;
import java.util.Scanner ;
public class B215 {
  public static void main(String[] args){
    Locale.setDefault(Locale.US);
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int[] R1=new int[N];
    for(int n=0 ; n<N ; n++){
      R1[n]=in.nextInt();
    }
    int M=in.nextInt();
    int[] P1=new int[M];
    for(int m=0 ; m<M ; m++){
      P1[m]=in.nextInt();
    }
    int K=in.nextInt();
    int[] P2=new int[K];
    for(int k=0 ; k<K ; k++){
      P2[k]=in.nextInt();
    }
    int A=in.nextInt();
    int B=in.nextInt();
    int maxR1=0 ;
    for(int r1 : R1){
      maxR1=Math.max(maxR1,r1);
    }
    int maxP1=0 ;
    for(int p1 : P1){
      maxP1=Math.max(maxP1,p1);
    }
    int minP2=Integer.MAX_VALUE ;
    for(int p2 : P2){
      minP2=Math.min(minP2,p2);
    }
    double r2=Math.sqrt(maxR1*maxR1*(double)B*maxP1/(A*minP2+B*maxP1));
    System.out.println(r2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B215 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.US) ; 
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var R1 : Sequence(int) ; R1 := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     R1[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var M : int ; M := in.getCurrent()->toInteger() ;
    var P1 : Sequence(int) ; P1 := Integer.subrange(1,M)->collect(0) ;
        var m : int ; m := 0 ; while m < M do ( (     P1[m+1] := in.getCurrent()->toInteger() )  ;     m := m + 1 ) ; 
    var K : int ; K := in.getCurrent()->toInteger() ;
    var P2 : Sequence(int) ; P2 := Integer.subrange(1,K)->collect(0) ;
        var k : int ; k := 0 ; while k < K do ( (     P2[k+1] := in.getCurrent()->toInteger() )  ;     k := k + 1 ) ; 
    var A : int ; A := in.getCurrent()->toInteger() ;
    var B : int ; B := in.getCurrent()->toInteger() ;
    var maxR1 : int ; maxR1 := 0 ;
    for (r1 : R1) do ( (     maxR1 := Set{maxR1, r1}->max() )  ) ; 
    var maxP1 : int ; maxP1 := 0 ;
    for (p1 : P1) do ( (     maxP1 := Set{maxP1, p1}->max() )  ) ; 
    var minP2 : int ; minP2 := 2147483647 ;
    for (p2 : P2) do ( (     minP2 := Set{minP2, p2}->min() )  ) ; 
    var r2 : double ; r2 := (maxR1 * maxR1 * B->oclAsType(double) * maxP1 / (A * minP2 + B * maxP1))->sqrt() ;
    OclFile["System.out"].println(r2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.StringTokenizer ;
public class OlympicMedal {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int i=0 ;
    int n=Integer.parseInt(st.nextToken());
    ArrayList<Integer>x=new ArrayList<>();
    for(i=0 ; i<n ; i++){
      x.add(Integer.parseInt(st.nextToken()));
    }
    st=new StringTokenizer(br.readLine());
    int m=Integer.parseInt(st.nextToken());
    ArrayList<Integer>y=new ArrayList<>();
    for(i=0 ; i<m ; i++){
      y.add(Integer.parseInt(st.nextToken()));
    }
    st=new StringTokenizer(br.readLine());
    int k=Integer.parseInt(st.nextToken());
    ArrayList<Integer>z=new ArrayList<>();
    for(i=0 ; i<k ; i++){
      z.add(Integer.parseInt(st.nextToken()));
    }
    st=new StringTokenizer(br.readLine());
    int a=Integer.parseInt(st.nextToken());
    int b=Integer.parseInt(st.nextToken());
    double maxR=Double.MIN_VALUE ;
    int xMax=Collections.max(x);
    int yMax=Collections.max(y);
    int zmin=Collections.min(z);
    double result=(b*yMax*Math.pow(xMax,2))/(a*zmin+b*yMax);
    result=Math.sqrt(result);
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class OlympicMedal {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var i : int ; i := 0 ;
    var n : int ; n := (st.next())->toInteger() ;
    var x : Sequence(int) ; x := Sequence{} ;
        i := 0 ; while i < n do ( (     x := x->including((st.next())->toInteger()) )  ;     i := i + 1 ) ; 
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    var m : int ; m := (st.next())->toInteger() ;
    var y : Sequence(int) ; y := Sequence{} ;
        i := 0 ; while i < m do ( (     y := y->including((st.next())->toInteger()) )  ;     i := i + 1 ) ; 
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    var k : int ; k := (st.next())->toInteger() ;
    var z : Sequence(int) ; z := Sequence{} ;
        i := 0 ; while i < k do ( (     z := z->including((st.next())->toInteger()) )  ;     i := i + 1 ) ; 
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    var a : int ; a := (st.next())->toInteger() ;
    var b : int ; b := (st.next())->toInteger() ;
    var maxR : double ; maxR := 2->pow(-1074) ;
    var xMax : int ; xMax := .max(x) ;
    var yMax : int ; yMax := .max(y) ;
    var zmin : int ; zmin := .min(z) ;
    var result : double ; result := (b * yMax * xMax->pow(2)) / (a * zmin + b * yMax) ;
    result := (result)->sqrt() ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class HelloWorld {
  public void trapeziumPattern(int num){
    int firsthalf=1 ;
    int secondhalf=(num*num)+1 ;
    int numOfSpaces=0 ;
    for(int numOfLines=num ; numOfLines>=1 ; numOfLines--){
      for(int numOfSpacesCounter=numOfSpaces ; numOfSpacesCounter>=1 ; numOfSpacesCounter--){
        System.out.print(" ");
      }
      for(int firstHalfCounter=1 ; firstHalfCounter<=numOfLines ; firstHalfCounter++){
        if(firstHalfCounter==numOfLines)System.out.print((firsthalf++));
        else System.out.print((firsthalf++)+"*");
      }
      for(int secondHalfCounter=1 ; secondHalfCounter<=numOfLines ; secondHalfCounter++){
        System.out.print("*"+(secondhalf++));
      }
      System.out.println();
      numOfSpaces+=2 ;
      secondhalf=(secondhalf-1)-((numOfLines-1)*2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class HelloWorld {
   operation trapeziumPattern( num : int) : void
  pre: true
  post: true
  activity: (     var firsthalf : int ; firsthalf := 1 ;
     var secondhalf : int ; secondhalf := (num * num) + 1 ;
     var numOfSpaces : int ; numOfSpaces := 0 ;
         var numOfLines : int ; numOfLines := num ; while numOfLines >= 1 do ( (         var numOfSpacesCounter : int ; numOfSpacesCounter := numOfSpaces ; while numOfSpacesCounter >= 1 do ( (     OclFile["System.out"].print(" ") )  ;     numOfSpacesCounter := numOfSpacesCounter - 1 ) ; 
         var firstHalfCounter : int ; firstHalfCounter := 1 ; while firstHalfCounter <= numOfLines do ( (     if (firstHalfCounter = numOfLines) then     OclFile["System.out"].print((firsthalf)) ; else     OclFile["System.out"].print((firsthalf) + "*") ; )  ;     firstHalfCounter := firstHalfCounter + 1 ) ; 
        var secondHalfCounter : int ; secondHalfCounter := 1 ; while secondHalfCounter <= numOfLines do ( (     OclFile["System.out"].print("*" + (secondhalf)) )  ;     secondHalfCounter := secondHalfCounter + 1 ) ; 
    OclFile["System.out"].println() ; 
    numOfSpaces := numOfSpaces+(2) ; 
    secondhalf := (secondhalf - 1) - ((numOfLines - 1) * 2) ; 
 )  ;     numOfLines := numOfLines - 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findPerm(int n,Vector<Integer>differences){
    Vector<Integer>ans=new Vector<Integer>();
    ans.clear();
    ans.add(0);
    int x=0 ;
    for(int i=0 ; i<=n-2 ; ++i){
      int diff=differences.get(i);
      x=x+diff ;
      ans.add(x);
    }
    Vector<Integer>anss=new Vector<Integer>();
    for(Integer obj : ans)anss.add(obj);
    Collections.sort(ans);
    int flag=-1 ;
    for(int i=1 ; i<=n-1 ; ++i){
      int res=ans.get(i)-ans.get(i-1);
      if(res!=1){
        flag=0 ;
      }
    }
    if(flag==0){
      System.out.print(-1);
      return ;
    }
    else {
      Map<Integer,Integer>mpp=new HashMap<>();
      mpp.clear();
      int j=1 ;
      Vector<Integer>value_at_index=new Vector<Integer>();
      for(Integer x1 : ans){
        mpp.put(x1,j);
++j ;
      }
      for(Integer x2 : anss){
        value_at_index.add(mpp.get(x2));
      }
      for(Integer x3 : value_at_index){
        System.out.print(x3+" ");
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    Vector<Integer>differences=new Vector<Integer>();
    differences.add(2);
    differences.add(-3);
    differences.add(2);
    int n=differences.size()+1 ;
    findPerm(n,differences);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findPerm( n : int, differences : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Sequence{} ;
     ans := ans->intersection(Set{}) ; 
    ans := ans->including(0) ; 
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i <= n - 2 do ( (     var diff : int ; diff := differences->at(i+1) ;
     x := x + diff ; 
     ans := ans->including(x) )  ;     i := i + 1 ) ; 
    var anss : Sequence(int) ; anss := Sequence{} ;
    for (obj : ans) do (     anss := anss->including(obj) ;  ) ; 
    ans := ans->sort() ; 
    var flag : int ; flag := -1 ;
        var i : int ; i := 1 ; while i <= n - 1 do ( (     var res : int ; res := ans->at(i+1) - ans->at(i - 1+1) ;
     if (res /= 1) then (     flag := 0 ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 0) then (     OclFile["System.out"].print(-1) ; 
     return ) else (     var mpp : Map(int,int) ; mpp := Map{} ;
     mpp := mpp->intersection(Map{}) ; 
    var j : int ; j := 1 ;
    var value_at_index : Sequence(int) ; value_at_index := Sequence{} ;
    for (x1 : ans) do ( (     mpp := mpp->union(Map{x1 |-> j}) ; 
     j := j + 1 )  ) ; 
    for (x2 : anss) do ( (     value_at_index := value_at_index->including(mpp->at(x2)) )  ) ; 
    for (x3 : value_at_index) do ( (     OclFile["System.out"].print(x3 + " ") )  ) ; 
    OclFile["System.out"].println() ; 
 ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var differences : Sequence(int) ; differences := Sequence{} ;
     differences := differences->including(2) ; 
    differences := differences->including(-3) ; 
    differences := differences->including(2) ; 
    var n : int ; n := differences->size() + 1 ;
    execute findPerm(n, differences) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String args[]){
    ConsoleScanner cin=new ConsoleScanner();
    PrintWriter cout=new PrintWriter(System.out);
    solve(cin,cout);
    cout.flush();
  }
  private static void solve(ConsoleScanner cin,PrintWriter cout){
    int n=cin.nextInt();
    int m=cin.nextInt();
    int[][] abs=new int[m][];
    for(int i=0 ; i<abs.length ; i++)abs[i]=new int[] {
      cin.nextInt(),cin.nextInt()};
      long millis=System.currentTimeMillis();
      boolean ans=solve(n,m,abs);
      if(ans)cout.println("POSSIBLE");
      else cout.println("IMPOSSIBLE");
      assert null!=cout.format("%d elapsed",System.currentTimeMillis()-millis);
    }
    private static boolean solve(int n,int m,int[][] abs){
      int[] ships=new int[n+1];
      for(int[] ab : abs){
        if(ab[0]==1)ships[ab[1] ]+=1 ;
        if(ab[1]==n)ships[ab[0] ]+=1 ;
        if(ships[ab[0] ]==2 || ships[ab[1] ]==2)return true ;
      }
      return false ;
    }
    static class ConsoleScanner {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      StringTokenizer st=new StringTokenizer("");
      String next(){
        try {
          while(! st.hasMoreElements())st=new StringTokenizer(br.readLine());
          return st.nextToken();
        }
        catch(IOException e){
          throw new AssertionError(e);
        }
      }
      int nextInt(){
        return Integer.parseInt(next());
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : ConsoleScanner ; cin := ConsoleScanner.newConsoleScanner() ;
     var cout : OclFile ; cout := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     execute solve(cin, cout) ; 
     skip );
  static   operation solve( cin : ConsoleScanner, cout : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := cin.nextInt() ;
     var m : int ; m := cin.nextInt() ;
    var abs : Sequence(Sequence(int)) ; abs := Integer.subrange(1,m)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < abs->size() do (     abs[i+1] := Sequence{cin.nextInt(),cin.nextInt()} ;  ;     i := i + 1 ) ; 
    var millis : long ; millis := OclDate.getSystemTime() ;
    var ans : boolean ; ans := solve(n, m, abs) ;
    if (ans) then     skip else     skip ; ;  
    assert null /= cout.format("%d elapsed", OclDate.getSystemTime() - millis) ; 
 );
  static   operation solve( n : int, m : int, abs : Sequence(Sequence(int))) : boolean
  pre: true
  post: true
  activity: (     var ships : Sequence(int) ; ships := Integer.subrange(1,n + 1)->collect(0) ;
     for (ab : abs) do ( (     if (ab[0+1] = 1) then     ships[ab[1+1]+1] := ships[ab[1+1]+1]+(1) ; else skip ; 
     if (ab[1+1] = n) then     ships[ab[0+1]+1] := ships[ab[0+1]+1]+(1) ; else skip ; 
     if (ships[ab[0+1]+1] = 2 or ships[ab[1+1]+1] = 2) then     return true else skip )  ) ; 
     return false );
  static class ConsoleScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() )   catch (e : IOException) do (     error AssertionException(e) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DS {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int r1=s.nextInt();
    int r2=s.nextInt();
    int c1=s.nextInt();
    int c2=s.nextInt();
    int d1=s.nextInt();
    int d2=s.nextInt();
    boolean b=false ;
    for(int i=1 ; i<10 ; i++){
      for(int j=1 ; j<10 ; j++){
        for(int k=1 ; k<10 ; k++){
          for(int a=1 ; a<10 ; a++){
            if(k!=a && j!=k && i!=a && i+j==r1 && k+a==r2 && j+k==d2 && i+a==d1 && i+k==c1 && j+a==c2 && i!=j && i!=k && j!=a){
              System.out.print(i+" "+j+"\n"+k+" "+a);
              b=true ;
            }
          }
        }
      }
    }
    if(! b)System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class DS {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r1 : int ; r1 := s.getCurrent()->toInteger() ;
    var r2 : int ; r2 := s.getCurrent()->toInteger() ;
    var c1 : int ; c1 := s.getCurrent()->toInteger() ;
    var c2 : int ; c2 := s.getCurrent()->toInteger() ;
    var d1 : int ; d1 := s.getCurrent()->toInteger() ;
    var d2 : int ; d2 := s.getCurrent()->toInteger() ;
    var b : boolean ; b := false ;
        var i : int ; i := 1 ; while i < 10 do ( (         var j : int ; j := 1 ; while j < 10 do ( (         var k : int ; k := 1 ; while k < 10 do ( (         var a : int ; a := 1 ; while a < 10 do ( (     if (k /= a & j /= k & i /= a & i + j = r1 & k + a = r2 & j + k = d2 & i + a = d1 & i + k = c1 & j + a = c2 & i /= j & i /= k & j /= a) then (     OclFile["System.out"].print(i + " " + j + "\n" + k + " " + a) ; 
     b := true ) else skip )  ;     a := a + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (not(b)) then     OclFile["System.out"].println(-1) ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.*;
import java.awt.geom.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] $){
    Scanner sc=new Scanner(in);
    int n=sc.nextInt(),m=sc.nextInt();
    int[] a=new int[200001];
    int[] b=new int[200001];
    HashSet<Integer>[] via=new HashSet[200001];
    for(int i=1 ; i<=200000 ; i++){
      via[i]=new HashSet<>();
    }
    for(int i=0 ; i<m ; i++){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
      via[a[i] ] .add(b[i]);
      via[b[i] ] .add(a[i]);
    }
    for(Integer k : via[1]){
      for(Integer l : via[k]){
        if(l==n){
          out.println("POSSIBLE");
          exit(0);
        }
      }
    }
    out.println("IMPOSSIBLE");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,200001)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,200001)->collect(0) ;
    var via : Sequence(Set(int)) ; via := Integer.subrange(1,200001)->collect(null) ;
        var i : int ; i := 1 ; while i <= 200000 do ( (     via[i+1] := Set{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() ; 
     via[a[i+1]+1]->excludes(b[i+1]) ; 
     via[b[i+1]+1]->excludes(a[i+1]) )  ;     i := i + 1 ) ; 
    for (k : via[1+1]) do ( (     for (l : via[k+1]) do ( (     if (l = n) then (     out.println("POSSIBLE") ; 
     execute exit(0) ) else skip )  ) )  ) ; 
    out.println("IMPOSSIBLE") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int N=gi();
    int M=gi();
    long[] A=new long[M];
    long[] B=new long[M];
    Map<Long,Integer>map=new HashMap<Long,Integer>();
    long sum=0 ;
    for(int i=0 ; i<M ; i++){
      A[i]=gl();
      B[i]=gl();
      if(A[i]==1){
        if(map.containsKey(B[i])){
          System.out.println("POSSIBLE");
          return ;
        }
        else {
          map.put(B[i],0);
        }
      }
      if(B[i]==N){
        if(map.containsKey(A[i])){
          System.out.println("POSSIBLE");
          return ;
        }
        else {
          map.put(A[i],0);
        }
      }
    }
    System.out.println("IMPOSSIBLE");
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : int ; N := gi() ;
    var M : int ; M := gi() ;
    var A : Sequence(long) ; A := Integer.subrange(1,M)->collect(0) ;
    var B : Sequence(long) ; B := Integer.subrange(1,M)->collect(0) ;
    var map : Map(long,int) ; map := Map{} ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     A[i+1] := gl() ; 
     B[i+1] := gl() ; 
     if (A[i+1] = 1) then (     if (map->keys()->includes(B[i+1])) then (     OclFile["System.out"].println("POSSIBLE") ; 
     return ) else (     map := map->union(Map{B[i+1] |-> 0}) ) ) else skip ; 
     if (B[i+1] = N) then (     if (map->keys()->includes(A[i+1])) then (     OclFile["System.out"].println("POSSIBLE") ; 
     return ) else (     map := map->union(Map{A[i+1] |-> 0}) ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("IMPOSSIBLE") ; 
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Divisible {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      int a=in.nextInt();
      int b=in.nextInt();
      System.out.print(a);
      System.out.print(" ");
      System.out.println(2*a);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Divisible {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    OclFile["System.out"].print(a) ; 
    OclFile["System.out"].print(" ") ; 
    OclFile["System.out"].println(2 * a) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static boolean[] vis1=new boolean[200010];
  private static boolean[] vis2=new boolean[200010];
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int i,j,n,m ;
    n=scan.nextInt();
    m=scan.nextInt();
    for(i=0 ; i<m ; i++){
      int a,b ;
      a=scan.nextInt();
      b=scan.nextInt();
      if(a==1){
        vis1[b]=true ;
      }
      if(b==n){
        vis2[a]=true ;
      }
    }
    for(i=2 ; i<n ; i++){
      if(vis1[i] && vis2[i]){
        break ;
      }
    }
    if(i==n){
      System.out.println("IMPOSSIBLE");
    }
    else {
      System.out.println("POSSIBLE");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute vis1 : Sequence(boolean) := Integer.subrange(1,200010)->collect(false);
  static   attribute vis2 : Sequence(boolean) := Integer.subrange(1,200010)->collect(false);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ;
    var j : int ;
    var n : int ;
    var m : int ;
    n := scan.getCurrent()->toInteger() ; 
    m := scan.getCurrent()->toInteger() ; 
        i := 0 ; while i < m do ( (     var a : int ;
    var b : int ;
     a := scan.getCurrent()->toInteger() ; 
    b := scan.getCurrent()->toInteger() ; 
    if (a = 1) then (     vis1[b+1] := true ) else skip ; 
    if (b = n) then (     vis2[a+1] := true ) else skip ; 
 )  ;     i := i + 1 ) ; 
        i := 2 ; while i < n do ( (     if (vis1[i+1] & vis2[i+1]) then (     break ) else skip )  ;     i := i + 1 ) ; 
    if (i = n) then (     OclFile["System.out"].println("IMPOSSIBLE") ) else (     OclFile["System.out"].println("POSSIBLE") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    ArrayList<HashSet<Integer>>adj=new ArrayList<HashSet<Integer>>();
    for(int i=0 ; i<n ; i++)adj.add(new HashSet<Integer>());
    for(int i=0 ; i<m ; i++){
      int x=sc.nextInt()-1,y=sc.nextInt()-1 ;
      adj.get(x).add(y);
    }
    for(int x : adj.get(0)){
      if(adj.get(x).contains(n-1)){
        System.out.println("POSSIBLE");
        return ;
      }
    }
    System.out.println("IMPOSSIBLE");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var adj : Sequence(Set(int)) ; adj := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     adj := adj->including(Set{}) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
    var y : int ; y := sc.getCurrent()->toInteger() - 1 ;
     adj->at(x+1)->excludes(y) )  ;     i := i + 1 ) ; 
    for (x : adj->at(0+1)) do ( (     if (adj->at(x+1)->includes(n - 1)) then (     OclFile["System.out"].println("POSSIBLE") ; 
     return ) else skip )  ) ; 
    OclFile["System.out"].println("IMPOSSIBLE") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countPrimeFactors(int n){
    int count=0 ;
    while(n % 2==0){
      n=n/2 ;
      count++;
    }
    for(int i=3 ; i<=Math.sqrt(n); i=i+2){
      while(n % i==0){
        n=n/i ;
        count++;
      }
    }
    if(n>2)count++;
    return(count);
  }
  static void printKAlmostPrimes(int k,int n){
    for(int i=1,num=2 ; i<=n ; num++){
      if(countPrimeFactors(num)==k){
        System.out.print(num+" ");
        i++;
      }
    }
    return ;
  }
  public static void main(String[] args){
    int n=10,k=2 ;
    System.out.println("First "+n+" "+k+"-almost prime numbers : ");
    printKAlmostPrimes(k,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPrimeFactors( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n mod 2 = 0) do (     n := n / 2 ; 
     count := count + 1 ) ; 
        var i : int ; i := 3 ; while i <= (n)->sqrt() do ( (     while (n mod i = 0) do (     n := n / i ; 
     count := count + 1 ) )  ;     i := i + 2 ) ; 
    if (n > 2) then     count := count + 1 ; else skip ; 
    return (count) 
 );
  static   operation printKAlmostPrimes( k : int, n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ;
    var num : int ; num := 2 ; while i <= n do ( (     if (countPrimeFactors(num) = k) then (     OclFile["System.out"].print(num + " ") ; 
     i := i + 1 ) else skip )  ;     num := num + 1 ) ; 
     return );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
    var k : int ; k := 2 ;
     OclFile["System.out"].println("First " + n + " " + k + "-almost prime numbers : ") ; 
     execute printKAlmostPrimes(k, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int solve(int N,int K){
    int[] combo ;
    combo=new int[50];
    combo[0]=1 ;
    for(int i=1 ; i<=K ; i++){
      for(int j=0 ; j<=N ; j++){
        if(j>=i){
          combo[j]+=combo[j-i];
        }
      }
    }
    return combo[N];
  }
  public static void main(String args[]){
    int N=29 ;
    int K=5 ;
    System.out.println(solve(N,K));
    solve(N,K);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( N : int, K : int) : int
  pre: true
  post: true
  activity: (     var combo : Sequence(int) ;
     combo := Integer.subrange(1,50)->collect(0) ; 
    combo[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= K do ( (         var j : int ; j := 0 ; while j <= N do ( (     if (j >= i) then (     combo[j+1] := combo[j+1]+(combo[j - i+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return combo[N+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 29 ;
     var K : int ; K := 5 ;
     OclFile["System.out"].println(solve(N, K)) ; 
     execute solve(N, K) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static int n ;
  static List<ArrayList<Edge>>g ;
  static int[] ans ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    g=new ArrayList();
    for(int i=0 ; i<n ; i++){
      g.add(new ArrayList<Edge>());
    }
    for(int i=0 ; i<n-1 ; i++){
      int a=Integer.parseInt(sc.next())-1 ;
      int b=Integer.parseInt(sc.next())-1 ;
      g.get(a).add(new Edge(i,b));
      g.get(b).add(new Edge(i,a));
    }
    ans=new int[n-1];
    dfs(0,-1,-1);
    int max=0 ;
    for(int temp : ans){
      max=Math.max(max,temp);
    }
    System.out.println(max);
    for(int c : ans){
      System.out.println(c);
    }
  }
  static void dfs(int to,int color,int parents){
    int k=1 ;
    for(Edge e : g.get(to)){
      if(e.to==parents)continue ;
      if(k==color)k++;
      ans[e.id]=k ;
      dfs(e.to,k,to);
      k++;
    }
  }
}
class Edge {
  Edge(int id,int to){
    this.id=id ;
    this.to=to ;
  }
  int id ;
  int to ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute g : Sequence(Sequence(Edge));
  static   attribute ans : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    g := Sequence{} ; 
        var i : int ; i := 0 ; while i < n do ( (     g := g->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var a : int ; a := (sc.getCurrent())->toInteger() - 1 ;
     var b : int ; b := (sc.getCurrent())->toInteger() - 1 ;
     g->at(a+1)->excludes(Edge.newEdge(i, b)) ; 
     g->at(b+1)->excludes(Edge.newEdge(i, a)) )  ;     i := i + 1 ) ; 
    ans := Integer.subrange(1,n - 1)->collect(0) ; 
    execute dfs(0, -1, -1) ; 
    var max : int ; max := 0 ;
    for (temp : ans) do ( (     max := Set{max, temp}->max() )  ) ; 
    OclFile["System.out"].println(max) ; 
    for (c : ans) do ( (     OclFile["System.out"].println(c) )  ) ; 
 );
  static   operation dfs( to : int, color : int, parents : int) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 1 ;
     for (e : g->at(to+1)) do ( (     if (e.to = parents) then     continue else skip ; 
     if (k = color) then     k := k + 1 ; else skip ; 
    ans[e.id+1] := k ; 
    execute dfs(e.to, k, to) ; 
    k := k + 1 ; 
 )  ) );
}
class Edge {
   static operation newEdge( id : int, to : int) : Edge
  pre: true
  post: true
  activity:
  ( var self : Edge ;
    self := createEdge();
    self.initialise(id, to);
    return self );
  operation initialise( id : int, to : int) : void
  pre: true  post: true
  activity: (     self.id := id ; 
     self.to := to );
   attribute id : int;
   attribute to : int;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    PrintWriter pw=new PrintWriter(System.out);
    int n=sc.nextInt();
    Node[] tree=new Node[n];
    int[] index=new int[n-1];
    for(int i=0 ; i<n ; i++){
      tree[i]=new Node();
    }
    for(int i=0 ; i<n-1 ; i++){
      int a=sc.nextInt()-1 ;
      int b=sc.nextInt()-1 ;
      index[i]=b ;
      tree[a] .child.add(b);
    }
    tree[0] .color=0 ;
    for(int i=0 ; i<n ; i++){
      int nowColor=1 ;
      int myColor=tree[i] .color ;
      for(int j : tree[i] .child){
        if(nowColor==myColor)nowColor++;
        tree[j] .color=nowColor ;
        nowColor++;
      }
    }
    int max=0 ;
    for(Node node : tree){
      max=Math.max(max,node.color);
    }
    pw.println(max);
    for(int i=0 ; i<n-1 ; i++){
      pw.println(tree[index[i] ] .color);
    }
    pw.flush();
  }
  static class Node {
    int color ;
    List<Integer>child ;
    Node(){
      child=new ArrayList<>();
    }
  }
  static class MyScanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),1<<15);
    StringTokenizer tokenizer ;
    String next(){
      try {
        while(tokenizer==null || ! tokenizer.hasMoreTokens()){
          tokenizer=new StringTokenizer(reader.readLine());
        }
      }
      catch(IOException ignored){
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.nextInt() ;
    var tree : Sequence(Node) ; tree := Integer.subrange(1,n)->collect(null) ;
    var index : Sequence(int) ; index := Integer.subrange(1,n - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     tree[i+1] := Node.newNode() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var a : int ; a := sc.nextInt() - 1 ;
     var b : int ; b := sc.nextInt() - 1 ;
     index[i+1] := b ; 
     tree[a+1].child->excludes(b) )  ;     i := i + 1 ) ; 
    tree[0+1].color := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     var nowColor : int ; nowColor := 1 ;
     var myColor : int ; myColor := tree[i+1].color ;
     for (j : tree[i+1].child) do ( (     if (nowColor = myColor) then     nowColor := nowColor + 1 ; else skip ; 
     tree[j+1].color := nowColor ; 
     nowColor := nowColor + 1 )  ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    for (node : tree) do ( (     max := Set{max, node.color}->max() )  ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class Node {
   attribute color : int;
   attribute child : Sequence(int);
   static operation newNode() : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     child := Sequence{} );
}
  static class MyScanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (1*(2->pow(15)))->oclAsType(long));
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (ignored : IOException) do skip
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.nextLine());
    int[] inf=new int[N+1];
    int now=0 ;
    int paint=1 ;
    int[] ans=new int[N-1];
    int max=0 ;
    int[][] val=new int[N-1][4];
    for(int i=0 ; i<N-1 ; i++){
      String[] S=sc.nextLine().split(" ");
      val[i][0]=Integer.parseInt(S[0]);
      val[i][1]=Integer.parseInt(S[1]);
      val[i][2]=i ;
    }
    Arrays.sort(val,(a,b)->Integer.compare(a[0],b[0]));
    for(int i=0 ; i<N-1 ; i++){
      int a=val[i][0];
      int b=val[i][1];
      if(a==now){
        paint++;
      }
      else {
        now=a ;
        paint=1 ;
      }
      if(inf[a]==paint){
        paint++;
      }
      val[i][3]=paint ;
      inf[b]=paint ;
      if(max<paint){
        max=paint ;
      }
    }
    Arrays.sort(val,(a,b)->Integer.compare(a[2],b[2]));
    System.out.println(max);
    for(int[] n : val){
      System.out.println(n[3]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.nextLine())->toInteger() ;
    var inf : Sequence(int) ; inf := Integer.subrange(1,N + 1)->collect(0) ;
    var now : int ; now := 0 ;
    var paint : int ; paint := 1 ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,N - 1)->collect(0) ;
    var max : int ; max := 0 ;
    var val : Sequence(Sequence(int)) ; val := Integer.subrange(1,N - 1)->collect(Integer.subrange(1,4)->collect(0)) ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     var S : Sequence(String) ; S := sc.nextLine()->split(" ") ;
     val[i+1][0+1] := (S[0+1])->toInteger() ; 
     val[i+1][1+1] := (S[1+1])->toInteger() ; 
     val[i+1][2+1] := i )  ;     i := i + 1 ) ; 
    val := OclComparator.sortWith(val, lambda (a , b) : OclAny in compare(a[0+1], b[0+1])) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     var a : int ; a := val[i+1][0+1] ;
     var b : int ; b := val[i+1][1+1] ;
    if (a = now) then (     paint := paint + 1 ) else (     now := a ; 
     paint := 1 ) ;  
    if (inf[a+1] = paint) then (     paint := paint + 1 ) else skip ; 
    val[i+1][3+1] := paint ; 
    inf[b+1] := paint ; 
    if (max < paint) then (     max := paint ) else skip ; 
 )  ;     i := i + 1 ) ; 
    val := OclComparator.sortWith(val, lambda (a , b) : OclAny in compare(a[2+1], b[2+1])) ; 
    OclFile["System.out"].println(max) ; 
    for (n : val) do ( (     OclFile["System.out"].println(n[3+1]) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelpVasilisaTheWise2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int r1=sc.nextInt();
    int r2=sc.nextInt();
    int c1=sc.nextInt();
    int c2=sc.nextInt();
    int d1=sc.nextInt();
    int d2=sc.nextInt();
    int y=(int)(0.5*c2-0.5*(d1-r1));
    int l=(int)(0.5*c2+0.5*(d1-r1));
    int x=r1-y ;
    int z=r2-l ;
    if(x<=0 || y<=0 || z<=0 || l<=0 || x==y || y==z || z==l || x==z || x==l || y==l || x>9 || y>9 || z>9 || l>9 || c1-x!=z || d2-y!=z)System.out.println(-1);
    else {
      System.out.println(x+" "+y);
      System.out.println(z+" "+l);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelpVasilisaTheWise2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r1 : int ; r1 := sc.getCurrent()->toInteger() ;
    var r2 : int ; r2 := sc.getCurrent()->toInteger() ;
    var c1 : int ; c1 := sc.getCurrent()->toInteger() ;
    var c2 : int ; c2 := sc.getCurrent()->toInteger() ;
    var d1 : int ; d1 := sc.getCurrent()->toInteger() ;
    var d2 : int ; d2 := sc.getCurrent()->toInteger() ;
    var y : int ; y := (0.5 * c2 - 0.5 * (d1 - r1))->oclAsType(int) ;
    var l : int ; l := (0.5 * c2 + 0.5 * (d1 - r1))->oclAsType(int) ;
    var x : int ; x := r1 - y ;
    var z : int ; z := r2 - l ;
    if (x <= 0 or y <= 0 or z <= 0 or l <= 0 or x = y or y = z or z = l or x = z or x = l or y = l or x > 9 or y > 9 or z > 9 or l > 9 or c1 - x /= z or d2 - y /= z) then     OclFile["System.out"].println(-1) else (     OclFile["System.out"].println(x + " " + y) ; 
     OclFile["System.out"].println(z + " " + l) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Point[] point=new Point[n];
    for(int i=0 ; i<n ; i++){
      point[i]=new Point();
    }
    int[] index=new int[n-1];
    for(int i=0 ; i<n-1 ; i++){
      int p=sc.nextInt()-1 ;
      int q=sc.nextInt()-1 ;
      index[i]=q ;
      point[p] .children.add(q);
    }
    point[0] .color=0 ;
    for(int i=0 ; i<n ; i++){
      int nowColor=1 ;
      int myColor=point[i] .color ;
      for(Integer child : point[i] .children){
        if(nowColor==myColor){
          nowColor++;
        }
        point[child] .color=nowColor ;
        nowColor++;
      }
    }
    int max=0 ;
    for(Point p : point){
      max=Math.max(max,p.color);
    }
    System.out.println(max);
    for(int i=0 ; i<n-1 ; i++){
      System.out.println(point[index[i] ] .color);
    }
  }
  public static class Point {
    int color ;
    List<Integer>children ;
    Point(){
      this.children=new ArrayList<Integer>();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var point : Sequence(Point) ; point := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     point[i+1] := Point.newPoint() )  ;     i := i + 1 ) ; 
    var index : Sequence(int) ; index := Integer.subrange(1,n - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var p : int ; p := sc.getCurrent()->toInteger() - 1 ;
     var q : int ; q := sc.getCurrent()->toInteger() - 1 ;
     index[i+1] := q ; 
     point[p+1].children->excludes(q) )  ;     i := i + 1 ) ; 
    point[0+1].color := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     var nowColor : int ; nowColor := 1 ;
     var myColor : int ; myColor := point[i+1].color ;
     for (child : point[i+1].children) do ( (     if (nowColor = myColor) then (     nowColor := nowColor + 1 ) else skip ; 
     point[child+1].color := nowColor ; 
     nowColor := nowColor + 1 )  ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    for (p : point) do ( (     max := Set{max, p.color}->max() )  ) ; 
    OclFile["System.out"].println(max) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     OclFile["System.out"].println(point[index[i+1]+1].color) )  ;     i := i + 1 ) ; 
 );
  static class Point {
   attribute color : int;
   attribute children : Sequence(int);
   static operation newPoint() : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.children := Sequence{} );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p249 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p249().run());
  }
  private static final int LIMIT=5000 ;
  private static final long MODULUS=10000000000000000L ;
  public String run(){
    boolean[] isPrime=Library.listPrimality(LIMIT*LIMIT/2);
    long[] numSubsets=new long[LIMIT*LIMIT/2];
    numSubsets[0]=1 ;
    int maxSum=0 ;
    for(int i=0 ; i<LIMIT ; i++){
      if(! isPrime[i])continue ;
      maxSum+=i ;
      for(int j=maxSum ; j>=i ; j--){
        long temp=numSubsets[j]+numSubsets[j-i];
        if(temp<MODULUS)numSubsets[j]=temp ;
        else numSubsets[j]=temp-MODULUS ;
      }
    }
    long sum=0 ;
    for(int i=0 ; i<numSubsets.length ; i++){
      if(isPrime[i])sum=(sum+numSubsets[i])% MODULUS ;
    }
    return Long.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
class p249 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p249.newp249().run()) );
  static    attribute LIMIT : int := 5000;
  static    attribute MODULUS : long := 10000000000000000L;
   operation run() : String
  pre: true
  post: true
  activity: (     var isPrime : Sequence(boolean) ; isPrime := Library.listPrimality(LIMIT * LIMIT / 2) ;
     var numSubsets : Sequence(long) ; numSubsets := Integer.subrange(1,LIMIT * LIMIT / 2)->collect(0) ;
    numSubsets[0+1] := 1 ; 
    var maxSum : int ; maxSum := 0 ;
        var i : int ; i := 0 ; while i < LIMIT do ( (     if (not(isPrime[i+1])) then     continue else skip ; 
     maxSum := maxSum+(i) ; 
         var j : int ; j := maxSum ; while j >= i do ( (     var temp : long ; temp := numSubsets[j+1] + numSubsets[j - i+1] ;
     if (temp < MODULUS) then     numSubsets[j+1] := temp ; else     numSubsets[j+1] := temp - MODULUS ; )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < numSubsets->size() do ( (     if (isPrime[i+1]) then     sum := (sum + numSubsets[i+1]) mod MODULUS ; else skip )  ;     i := i + 1 ) ; 
    return ((sum) + "") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    Scanner scanner=new Scanner(System.in);
    while(true){
      int x=scanner.nextInt();
      if(x==0)break ;
      boolean sign=x>0 ;
      StringBuilder builder=new StringBuilder();
      x=Math.abs(x);
      while(x>0){
        int t=(x % 10);
        if(! sign && t!=0){
          t=10-t ;
          x+=10 ;
        }
        builder.insert(0,t);
        sign=! sign ;
        x/=10 ;
      }
      System.out.println(builder);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var x : int ; x := scanner.getCurrent()->toInteger() ;
     if (x = 0) then     break else skip ; 
    var sign : boolean ; sign := x > 0 ;
    var builder : String ; builder := StringLib.newString() ;
    x := if x < 0 then -(x) else x endif ; 
    while (x > 0) do (     var t : int ; t := (x mod 10) ;
     if (not(sign) & t /= 0) then (     t := 10 - (t)->char2byte() ; 
     x := x+(10) ) else skip ; 
    builder := builder.insertAt(0+1, StringLib.newString(t)) ; 
    sign := not(sign) ; 
    x := x/(10) ; 
 ) ; 
    OclFile["System.out"].println(builder) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      long x=sc.nextLong();
      if(x==0)break ;
      boolean sign=x>0 ;
      String res="" ;
      x=Math.abs(x);
      boolean k=true ;
      while(x>0){
        int t=(int)(x % 10);
        if(sign==k)res=t+res ;
        else {
          res=(10-t)% 10+res ;
          if(t!=0)x+=10 ;
        }
        k=! k ;
        x/=10 ;
      }
      System.out.println(res);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var x : long ; x := sc.getCurrent()->toLong() ;
     if (x = 0) then     break else skip ; 
    var sign : boolean ; sign := x > 0 ;
    var res : String ; res := "" ;
    x := if x < 0 then -(x) else x endif ; 
    var k : boolean ; k := true ;
    while (x > 0) do (     var t : int ; t := (x mod 10)->oclAsType(int) ;
     if (sign = k) then     res := t + res else (     res := (10 - t) mod 10 + res ; 
     if (t /= 0) then     x := x+(10) ; else skip ) ;  
     k := not(k) ; 
     x := x/(10) ) ; 
    OclFile["System.out"].println(res) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  private void doit(){
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int sign=n<0 ? 1 : 0 ;
      n=Math.abs(n);
      StringBuilder ans=new StringBuilder();
      for(int i=0 ; ; i++){
        if(n==0)break ;
        int num=n % 10 ;
        if((sign+i)% 2==0){
          ans.append(num);
        }
        else {
          int num2=10-num ;
          ans.append(num2 % 10);
          if(num2!=10){
            n+=10 ;
          }
        }
        n=n/10 ;
      }
      System.out.println(ans.reverse().toString());
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation doit() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var sign : int ; sign := if n < 0 then 1 else 0 endif ;
    n := if n < 0 then -(n) else n endif ; 
    var ans : String ; ans := StringLib.newString() ;
        var i : int ; i := 0 ; while true do ( (     if (n = 0) then     break else skip ; 
     var num : int ; num := n mod 10 ;
     if ((sign + i) mod 2 = 0) then (     ans := ans + StringLib.newString(num) ) else (     var num2 : int ; num2 := 10 - num ;
     ans := ans + StringLib.newString(num2 mod 10) ; 
     if (num2 /= 10) then (     n := n+(10) ) else skip ) ;  
     n := n / 10 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans->reverse()+"") ; 
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static final int MAX=13 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      final long n=sc.nextLong();
      if(n==0L){
        break ;
      }
      StringBuilder sb=new StringBuilder();
      long rest=n ;
      boolean m_flag=false ;
      while(rest!=0){
        long a=rest/(10);
        long b=rest-a*(10);
        if(b<0 & ! m_flag){
          b+=(10);
          a-=1 ;
        }
        else if(b>0 && m_flag){
          b-=(10);
          a+=1 ;
        }
        if(b<0){
          b=-b ;
        }
        sb.insert(0,b);
        rest=a ;
        m_flag=! m_flag ;
      }
      System.out.println(sb.toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 13;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : long ; n := sc.getCurrent()->toLong() ;
     if (n = 0L) then (     break ) else skip ; 
    var sb : String ; sb := StringLib.newString() ;
    var rest : long ; rest := n ;
    var m_flag : boolean ; m_flag := false ;
    while (rest /= 0) do (     var a : long ; a := rest / (10) ;
     var b : long ; b := (rest)->char2byte() - a * (10) ;
    if (b < 0 & not(m_flag)) then (     b := b+((10)) ; 
     a := a-(1) ) else     if (b > 0 & m_flag) then (     b := b-((10)) ; 
     a := a+(1) ) else skip ; ;  
    if (b < 0) then (     b := -b ) else skip ; 
    sb := sb.insertAt(0+1, StringLib.newString(b)) ; 
    rest := a ; 
    m_flag := not(m_flag) ; 
 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float normal(float m,float n){
    float N=(float)((Math.abs(m)*Math.abs(n))/Math.sqrt((Math.abs(m)*Math.abs(m))+(Math.abs(n)*Math.abs(n))));
    return N ;
  }
  public static void main(String[] args){
    float m=-5,n=3 ;
    System.out.println(normal(m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation normal( m : double, n : double) : double
  pre: true
  post: true
  activity: (     var N : double ; N := ((if m < 0 then -(m) else m endif * if n < 0 then -(n) else n endif) / ((if m < 0 then -(m) else m endif * if m < 0 then -(m) else m endif) + (if n < 0 then -(n) else n endif * if n < 0 then -(n) else n endif))->sqrt())->oclAsType(double) ;
     return N );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : double ; m := -5 ;
    var n : double ; n := 3 ;
     OclFile["System.out"].println(normal(m, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Assignment4 {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=br.readLine();
    String[] num=str.split(" ");
    double n=Double.parseDouble(num[0]);
    double h=Double.parseDouble(num[1]);
    for(double i=1.0 ; i<n ; i++){
      double ans=h*Math.sqrt(i/n);
      System.out.printf("%f ",ans);
      if(i==n-1)System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Assignment4 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := br.readLine() ;
    var num : Sequence(String) ; num := str->split(" ") ;
    var n : double ; n := (num[0+1])->toReal() ;
    var h : double ; h := (num[1+1])->toReal() ;
        var i : double ; i := 1.0 ; while i < n do ( (     var ans : double ; ans := h * (i / n)->sqrt() ;
     OclFile["System.out"].printf("%f ", ans) ; 
     if (i = n - 1) then     OclFile["System.out"].println() ; else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int h=sc.nextInt();
    for(int i=1 ; i<n ; i++)System.out.printf("%.12f ",Math.sqrt(i/(n*1.0))*h);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i < n do (     OclFile["System.out"].printf("%.12f ", (i / (n * 1.0))->sqrt() * h) ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double n=sc.nextInt();
    double h=sc.nextDouble();
    double b=1 ;
    double a=(b*h)/(2*n);
    double t=Math.atan2(h,0.5);
    for(int m=1 ; m<=n-1 ; m++){
      double ax=m*a ;
      double ans=Math.sqrt(ax*Math.tan(t));
      System.out.print(ans+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : double ; n := sc.getCurrent()->toInteger() ;
    var h : double ; h := sc.getCurrent()->toReal() ;
    var b : double ; b := 1 ;
    var a : double ; a := (b * h) / (2 * n) ;
    var t : double ; t := atan2(h, 0.5) ;
        var m : int ; m := 1 ; while m <= n - 1 do ( (     var ax : double ; ax := m * a ;
     var ans : double ; ans := (ax * (t)->tan())->sqrt() ;
     OclFile["System.out"].print(ans + " ") )  ;     m := m + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class trailzero {
  public static void main(String[] args)throws Throwable {
    Scanner sc=new Scanner(System.in);
    double n=sc.nextDouble();
    double h=sc.nextDouble();
    for(int i=1 ; i<n ; i++){
      System.out.print((h*Math.sqrt(i/n*1.0))+" ");
    }
    System.out.println();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class trailzero {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : double ; n := sc.getCurrent()->toReal() ;
    var h : double ; h := sc.getCurrent()->toReal() ;
        var i : int ; i := 1 ; while i < n do ( (     OclFile["System.out"].print((h * (i / n * 1.0)->sqrt()) + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelpVasilisaTheWise2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int r1=sc.nextInt();
    int r2=sc.nextInt();
    int c1=sc.nextInt();
    int c2=sc.nextInt();
    int d1=sc.nextInt();
    int d2=sc.nextInt();
    int[][] b={
      {
        c2 },{
          d1-r1 }
        };
        double[][] ainv={
          {
            0.5,-0.5 },{
              0.5,0.5 }
            };
            double[][] yl={
              {
                ainv[0][0]*b[0][0]+ainv[0][1]*b[1][0] },{
                  ainv[1][0]*b[0][0]+ainv[1][1]*b[1][0] }
                };
                int y=(int)yl[0][0];
                int l=(int)yl[1][0];
                int x=r1-y ;
                int z=r2-l ;
                if(x<=0 || y<=0 || z<=0 || l<=0 || x==y || y==z || z==l || x==z || x==l || y==l || x>9 || y>9 || z>9 || l>9 || c1-x!=z || d2-y!=z)System.out.println(-1);
                else {
                  System.out.println(x+" "+y);
                  System.out.println(z+" "+l);
                }
                sc.close();
              }
            }

------------------------------------------------------------
OCL File:
---------
 class HelpVasilisaTheWise2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r1 : int ; r1 := sc.getCurrent()->toInteger() ;
    var r2 : int ; r2 := sc.getCurrent()->toInteger() ;
    var c1 : int ; c1 := sc.getCurrent()->toInteger() ;
    var c2 : int ; c2 := sc.getCurrent()->toInteger() ;
    var d1 : int ; d1 := sc.getCurrent()->toInteger() ;
    var d2 : int ; d2 := sc.getCurrent()->toInteger() ;
    var b : Sequence(Sequence(int)) ; b := Sequence{Sequence{c2},Sequence{d1 - r1}} ;
    var ainv : Sequence(Sequence(double)) ; ainv := Sequence{Sequence{0.5,-0.5},Sequence{0.5,0.5}} ;
    var yl : Sequence(Sequence(double)) ; yl := Sequence{Sequence{ainv[0+1][0+1] * b[0+1][0+1] + ainv[0+1][1+1] * b[1+1][0+1]},Sequence{ainv[1+1][0+1] * b[0+1][0+1] + ainv[1+1][1+1] * b[1+1][0+1]}} ;
    var y : int ; y := yl[0+1][0+1]->oclAsType(int) ;
    var l : int ; l := yl[1+1][0+1]->oclAsType(int) ;
    var x : int ; x := r1 - y ;
    var z : int ; z := r2 - l ;
    if (x <= 0 or y <= 0 or z <= 0 or l <= 0 or x = y or y = z or z = l or x = z or x = l or y = l or x > 9 or y > 9 or z > 9 or l > 9 or c1 - x /= z or d2 - y /= z) then     OclFile["System.out"].println(-1) else (     OclFile["System.out"].println(x + " " + y) ; 
     OclFile["System.out"].println(z + " " + l) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countOddNumber(int row_num){
    int count=0 ;
    while(row_num>0){
      count+=row_num & 1 ;
      row_num>>=1 ;
    }
    return(1<<count);
  }
  static void gouldSequence(int n){
    for(int row_num=0 ; row_num<n ; row_num++){
      System.out.print(countOddNumber(row_num)+" ");
    }
  }
  public static void main(String[] args){
    int n=16 ;
    gouldSequence(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countOddNumber( row_num : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (row_num > 0) do (     count := count+(row_num & 1) ; 
     row_num := row_num/(2->pow(1)) ) ; 
     return ((1*(2->pow(count)))->oclAsType(long)) );
  static   operation gouldSequence( n : int) : void
  pre: true
  post: true
  activity: (         var row_num : int ; row_num := 0 ; while row_num < n do ( (     OclFile["System.out"].print(countOddNumber(row_num) + " ") )  ;     row_num := row_num + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 16 ;
     execute gouldSequence(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countBits(int n){
    int count=0 ;
    while(n!=0){
      count++;
      n>>=1 ;
    }
    return count ;
  }
  public static void main(String[] arg){
    int i=65 ;
    System.out.print(countBits(i));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countBits( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n /= 0) do (     count := count + 1 ; 
     n := n/(2->pow(1)) ) ; 
     return count );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 65 ;
     OclFile["System.out"].print(countBits(i)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    System.out.println(h*w-(h/a*a)*(w/b*b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(h * w - (h / a * a) * (w / b * b)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    SC sc=new SC(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    int A=sc.nextInt();
    int B=sc.nextInt();
    int ans1=(H % A)*W+(W % B)*H-(H % A)*(W % B);
    pl(ans1);
  }
  static class SC {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public SC(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        throw new UncheckedIOException(e);
      }
    }
  }
  public static void pl(Object o){
    System.out.println(o);
  }
  public static void pl(){
    System.out.println();
  }
  public static void p(Object o){
    System.out.print(o);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : SC ; sc := SC.newSC(OclFile["System.in"]) ;
     var H : int ; H := sc.nextInt() ;
    var W : int ; W := sc.nextInt() ;
    var A : int ; A := sc.nextInt() ;
    var B : int ; B := sc.nextInt() ;
    var ans1 : int ; ans1 := (H mod A) * W + (W mod B) * H - (H mod A) * (W mod B) ;
    execute pl(ans1) ; 
 );
  static class SC {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newSC( in : OclFile) : SC
  pre: true
  post: true
  activity:
  ( var self : SC ;
    self := createSC();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 );
}
  static   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation pl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),max=0,ans=0 ;
    List<Integer>l=new ArrayList<>();
    int[] t=new int[n];
    for(int i=0 ; i<n ; i++){
      t[i]=sc.nextInt();
      max=Math.max(max,t[i]);
    }
    for(int i=1 ; i<=max ; i++){
      if(max % i==0){
        l.add(i);
      }
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<l.size(); j++){
        if(l.get(j)>=t[i]){
          ans+=l.get(j)-t[i];
          break ;
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var max : int ; max := 0 ;
    var ans : int ; ans := 0 ;
    var l : Sequence(int) ; l := Sequence{} ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     t[i+1] := sc.getCurrent()->toInteger() ; 
     max := Set{max, t[i+1]}->max() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= max do ( (     if (max mod i = 0) then (     l := l->including(i) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < l->size() do ( (     if (l->at(j+1) >= t[i+1]) then (     ans := ans+(l->at(j+1) - t[i+1]) ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] t=new int[n];
    for(int i=0 ; i<n ; i++){
      t[i]=sc.nextInt();
    }
    int maxValue=Arrays.stream(t).max().getAsInt();
    TreeSet<Integer>set=new TreeSet<>();
    for(int i=1 ; i<=maxValue ; i++){
      if(maxValue % i==0)set.add(i);
    }
    long ans=0 ;
    for(int num : t){
      ans+=set.ceiling(num)-num ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     t[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var maxValue : int ; maxValue := stream(t).max().getAsInt() ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 1 ; while i <= maxValue do ( (     if (maxValue mod i = 0) then     set := set->including(i) ; else skip )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    for (num : t) do ( (     ans := ans+(set.ceiling(num) - num) )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int max_t=0 ;
    int[] timing=new int[n];
    for(int i=0 ; i<n ; ++i){
      timing[i]=sc.nextInt();
      if(timing[i]>max_t)max_t=timing[i];
    }
    ArrayList<Integer>divisor=new ArrayList<Integer>();
    for(int i=1 ; i<=max_t>>1 ; ++i){
      if(max_t % i==0)divisor.add(i);
    }
    divisor.add(max_t);
    int adj=0 ;
    for(int t : timing){
      for(int d : divisor){
        if(d>=t){
          adj+=d-t ;
          break ;
        }
      }
    }
    System.out.println(adj);
  }
  public static void main(String[] a){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var max_t : int ; max_t := 0 ;
    var timing : Sequence(int) ; timing := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     timing[i+1] := sc.getCurrent()->toInteger() ; 
     if (timing[i+1] > max_t) then     max_t := timing[i+1] ; else skip )  ;     i := i + 1 ) ; 
    var divisor : Sequence(int) ; divisor := Sequence{} ;
        var i : int ; i := 1 ; while i <= (max_t/(2->pow(1)))->oclAsType(long) do ( (     if (max_t mod i = 0) then     divisor := divisor->including(i) ; else skip )  ;     i := i + 1 ) ; 
    divisor := divisor->including(max_t) ; 
    var adj : int ; adj := 0 ;
    for (t : timing) do ( (     for (d : divisor) do ( (     if (d >= t) then (     adj := adj+(d - t) ; 
     break ) else skip )  ) )  ) ; 
    OclFile["System.out"].println(adj) ; 
 );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    TreeSet<Integer>yakusu=new TreeSet<>();
    int n=sc.nextInt();
    int t[]=new int[n];
    for(int i=0 ; i<n ; i++){
      t[i]=sc.nextInt();
    }
    Arrays.sort(t);
    int max=t[n-1];
    for(int i=1 ; i<=10000 ; i++){
      if(max % i==0){
        yakusu.add(i);
      }
    }
    int ans=0 ;
    for(int i=0 ; i<n-1 ; i++){
      ans+=yakusu.ceiling(t[i])-t[i];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var yakusu : Set(int) ; yakusu := Set{} ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     t[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    t := t->sort() ; 
    var max : int ; max := t[n - 1+1] ;
        var i : int ; i := 1 ; while i <= 10000 do ( (     if (max mod i = 0) then (     yakusu := yakusu->including(i) ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     ans := ans+(yakusu.ceiling(t[i+1]) - t[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    int T=1,i,j=0,k=0 ;
    long n,m,l,ans=0l,ans2=0l,ans3=0l,b,c ;
    for(int tt=0 ; tt<T ; tt++){
      n=fs.nextLong();
      m=fs.nextLong();
      if(n==1){
        System.out.println(1);
        return ;
      }
      if(n-m>m-1)System.out.println(m+1);
      else System.out.println(m-1);
    }
  }
  static final Random random=new Random();
  static void ruffleSort(int[] a){
    int n=a.length ;
    for(int i=0 ; i<n ; i++){
      int oi=random.nextInt(n),temp=a[oi];
      a[oi]=a[i];
      a[i]=temp ;
    }
    Arrays.sort(a);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var T : int ; T := 1 ;
    var i : int ;
    var j : int ; j := 0 ;
    var k : int ; k := 0 ;
     var n : long ;
    var m : long ;
    var l : long ;
    var ans : long ; ans := 0l ;
    var ans2 : long ; ans2 := 0l ;
    var ans3 : long ; ans3 := 0l ;
    var b : long ;
    var c : long ;
         var tt : int ; tt := 0 ; while tt < T do ( (     n := fs.nextLong() ; 
     m := fs.nextLong() ; 
     if (n = 1) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
     if (n - m > m - 1) then     OclFile["System.out"].println(m + 1) ; else     OclFile["System.out"].println(m - 1) ; )  ;     tt := tt + 1 ) );
  static    attribute random : OclRandom := OclRandom.newOclRandom();
  static   operation ruffleSort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() ;
         var i : int ; i := 0 ; while i < n do ( (     var oi : int ; oi := random.nextInt(n) ;
    var temp : int ; temp := a[oi+1] ;
     a[oi+1] := a[i+1] ; 
     a[i+1] := temp )  ;     i := i + 1 ) ; 
     a := a->sort() );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader buf=new BufferedReader(new InputStreamReader(System.in));
    String st[]=(buf.readLine()).split(" ");
    int n=Integer.parseInt(st[0]);
    int m=Integer.parseInt(st[1]);
    int a ;
    if(n==1)a=1 ;
    else if(n==2){
      if(m==1)a=2 ;
      else a=1 ;
    }
    else {
      int mid ;
      if(n % 2==0)mid=n/2 ;
      else mid=(n/2)+1 ;
      if(n % 2==0){
        if(m<=mid)a=m+1 ;
        else a=m-1 ;
      }
      else {
        if(m<mid)a=m+1 ;
        else a=m-1 ;
      }
    }
    System.out.println(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var buf : OclFile ; buf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : Sequence(String) ; st := (buf.readLine())->split(" ") ;
    var n : int ; n := (st[0+1])->toInteger() ;
    var m : int ; m := (st[1+1])->toInteger() ;
    var a : int ;
    if (n = 1) then     a := 1 else     if (n = 2) then (     if (m = 1) then     a := 2 ; else     a := 1 ; ) else (     var mid : int ;
     if (n mod 2 = 0) then     mid := n / 2 else     mid := (n / 2) + 1 ; ;  
     if (n mod 2 = 0) then (     if (m <= mid) then     a := m + 1 ; else     a := m - 1 ; ) else (     if (m < mid) then     a := m + 1 ; else     a := m - 1 ; ) ) ;  ;  
    OclFile["System.out"].println(a) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector ;
class GFG {
  static int deno[]={
    1,2,5,10,20,50,100,500,1000 };
    static int n=deno.length ;
    static void findMin(int V){
      Vector<Integer>ans=new Vector<>();
      for(int i=n-1 ; i>=0 ; i--){
        while(V>=deno[i]){
          V-=deno[i];
          ans.add(deno[i]);
        }
      }
      for(int i=0 ; i<ans.size(); i++){
        System.out.print(" "+ans.elementAt(i));
      }
    }
    public static void main(String[] args){
      int n=93 ;
      System.out.print("Following is minimal number of change for "+n+": ");
      findMin(n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute deno : int := Sequence{1,2,5,10,20,50,100,500,1000};
  static   attribute n : int := deno->size();
  static   operation findMin( V : int) : void
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Sequence{} ;
         var i : int ; i := n - 1 ; while i >= 0 do ( (     while (V >= deno[i+1]) do (     V := V-(deno[i+1]) ; 
     ans := ans->including(deno[i+1]) ) )  ;     i := i - 1 ) ; 
         var i : int ; i := 0 ; while i < ans->size() do ( (     OclFile["System.out"].print(" " + ans->at(i+1)) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 93 ;
     OclFile["System.out"].print("Following is minimal number of change for " + n + ": ") ; 
     execute findMin(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int r1=sc.nextInt();
    int r2=sc.nextInt();
    int c1=sc.nextInt();
    int c2=sc.nextInt();
    int d1=sc.nextInt();
    int d2=sc.nextInt();
    int b=(d2+r1-c1)/2 ;
    int a=r1-b ;
    int c=c1-a ;
    int d=d1-a ;
    if(a<=0 || a>9 || b<=0 || b>9 || c<=0 || c>9 || d<=0 || d>9 || a==b || a==c || a==d || b==c || b==d || c==d || a+b!=r1 || c+d!=r2 || a+c!=c1 || b+d!=c2 || b+c!=d2 || a+d!=d1)System.out.println("-1");
    else {
      System.out.println(a+" "+b);
      System.out.println(c+" "+d);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r1 : int ; r1 := sc.getCurrent()->toInteger() ;
    var r2 : int ; r2 := sc.getCurrent()->toInteger() ;
    var c1 : int ; c1 := sc.getCurrent()->toInteger() ;
    var c2 : int ; c2 := sc.getCurrent()->toInteger() ;
    var d1 : int ; d1 := sc.getCurrent()->toInteger() ;
    var d2 : int ; d2 := sc.getCurrent()->toInteger() ;
    var b : int ; b := (d2 + r1 - c1) / 2 ;
    var a : int ; a := r1 - b ;
    var c : int ; c := c1 - a ;
    var d : int ; d := d1 - a ;
    if (a <= 0 or a > 9 or b <= 0 or b > 9 or c <= 0 or c > 9 or d <= 0 or d > 9 or a = b or a = c or a = d or b = c or b = d or c = d or a + b /= r1 or c + d /= r2 or a + c /= c1 or b + d /= c2 or b + c /= d2 or a + d /= d1) then     OclFile["System.out"].println("-1") else (     OclFile["System.out"].println(a + " " + b) ; 
     OclFile["System.out"].println(c + " " + d) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;
public class sg {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long m=sc.nextLong();
    if(n==1 && m==1){
      System.out.println(1);
      return ;
    }
    long a=n-m ;
    long b=m-1 ;
    if(a>b){
      System.out.println(m+1);
    }
    else if(b>a){
      System.out.println(m-1);
    }
    else {
      System.out.println(m-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class sg {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var m : long ; m := sc.getCurrent()->toLong() ;
    if (n = 1 & m = 1) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    var a : long ; a := n - m ;
    var b : long ; b := m - 1 ;
    if (a > b) then (     OclFile["System.out"].println(m + 1) ) else     if (b > a) then (     OclFile["System.out"].println(m - 1) ) else (     OclFile["System.out"].println(m - 1) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CodeForces570B {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int m=input.nextInt();
    if(n==1){
      System.out.println(1);
      return ;
    }
    if(m<=n/2){
      System.out.println(++m);
    }
    else {
      System.out.println(--m);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces570B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var m : int ; m := input.getCurrent()->toInteger() ;
    if (n = 1) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    if (m <= n / 2) then (     OclFile["System.out"].println((m + 1)) ) else (     OclFile["System.out"].println((m - 1)) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.Integer.*;
public class B {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    StringTokenizer st=new StringTokenizer(in.readLine());
    int n=parseInt(st.nextToken()),m=parseInt(st.nextToken());
    pw.println(solve(n,m));
    pw.close();
  }
  static int solve(int n,int m){
    if(n==1)return 1 ;
    if(m-1<n-m)return m+1 ;
    else return m-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(in.readLine()) ;
    var n : int ; n := parseInt(st.next()) ;
    var m : int ; m := parseInt(st.next()) ;
    skip ; 
    skip ; 
 );
  static   operation solve( n : int, m : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 1 else skip ; 
     if (m - 1 < n - m) then     return m + 1 else     return m - 1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isHeterogram(String s,int n){
    int hash[]=new int[26];
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)!=' '){
        if(hash[s.charAt(i)-'a']==0)hash[s.charAt(i)-'a']=1 ;
        else return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    String s="the big dwarf only jumps" ;
    int n=s.length();
    if(isHeterogram(s,n))System.out.print("YES");
    else System.out.print("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isHeterogram( s : String, n : int) : boolean
  pre: true
  post: true
  activity: (     var hash : Sequence(int) ; hash := Integer.subrange(1,26)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) /= ' ') then (     if (hash[s->at(i+1) - ('a')->char2byte()+1] = 0) then     hash[s->at(i+1) - ('a')->char2byte()+1] := 1 ; else     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "the big dwarf only jumps" ;
     var n : int ; n := s->size() ;
     if (isHeterogram(s, n)) then     OclFile["System.out"].print("YES") ; else     OclFile["System.out"].print("NO") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p024 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p024().run());
  }
  public String run(){
    int[] array=new int[10];
    for(int i=0 ; i<array.length ; i++)array[i]=i ;
    for(int i=0 ; i<999999 ; i++){
      if(! Library.nextPermutation(array))throw new AssertionError();
    }
    String ans="" ;
    for(int i=0 ; i<array.length ; i++)ans+=array[i];
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p024 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p024.newp024().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Integer.subrange(1,10)->collect(0) ;
         var i : int ; i := 0 ; while i < array->size() do (     array[i+1] := i ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 999999 do ( (     if (not(Library.nextPermutation(array))) then     error AssertionException() ; else skip )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < array->size() do (     ans := ans+(array[i+1]) ;  ;     i := i + 1 ) ; 
    return ans 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean FindPoint(int x1,int y1,int x2,int y2,int x,int y){
    if(x>x1 && x<x2 && y>y1 && y<y2)return true ;
    return false ;
  }
  public static void main(String[] args){
    int x1=0,y1=0,x2=10,y2=8 ;
    int x=1,y=5 ;
    if(FindPoint(x1,y1,x2,y2,x,y))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation FindPoint( x1 : int, y1 : int, x2 : int, y2 : int, x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     if (x > x1 & x < x2 & y > y1 & y < y2) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x1 : int ; x1 := 0 ;
    var y1 : int ; y1 := 0 ;
    var x2 : int ; x2 := 10 ;
    var y2 : int ; y2 := 8 ;
     var x : int ; x := 1 ;
    var y : int ; y := 5 ;
     if (FindPoint(x1, y1, x2, y2, x, y)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MX=2001 ;
  static int OFF=1000 ;
  static class point {
    int x,y ;
    public point(int x,int y){
      this.x=x ;
      this.y=y ;
    }
  };
  static int countPoints(int n,point points[]){
    int[] minx=new int[MX];
    int[] miny=new int[MX];
    for(int i=0 ; i<n ; i++){
      minx[i]=Integer.MAX_VALUE ;
      miny[i]=Integer.MAX_VALUE ;
    }
    int[] maxx=new int[MX];
    int[] maxy=new int[MX];
    int x,y ;
    for(int i=0 ; i<n ; i++){
      points[i] .x+=OFF ;
      points[i] .y+=OFF ;
      x=points[i] .x ;
      y=points[i] .y ;
      minx[y]=Math.min(minx[y],x);
      maxx[y]=Math.max(maxx[y],x);
      miny[x]=Math.min(miny[x],y);
      maxy[x]=Math.max(maxy[x],y);
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      x=points[i] .x ;
      y=points[i] .y ;
      if(x>minx[y] && x<maxx[y])if(y>miny[x] && y<maxy[x])count++;
    }
    return count ;
  }
  public static void main(String[] args){
    point points[]={
      new point(0,0),new point(0,1),new point(1,0),new point(0,-1),new point(-1,0)};
      int n=points.length ;
      System.out.println(countPoints(n,points));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MX : int := 2001;
  static   attribute OFF : int := 1000;
  static class point {
   attribute x : int;
   static operation newpoint( x : int, y : int) : point
  pre: true
  post: true
  activity:
  ( var self : point ;
    self := createpoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}
  static   operation countPoints( n : int, points : Sequence(point)) : int
  pre: true
  post: true
  activity: (     var minx : Sequence(int) ; minx := Integer.subrange(1,MX)->collect(0) ;
     var miny : Sequence(int) ; miny := Integer.subrange(1,MX)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     minx[i+1] := 2147483647 ; 
     miny[i+1] := 2147483647 )  ;     i := i + 1 ) ; 
    var maxx : Sequence(int) ; maxx := Integer.subrange(1,MX)->collect(0) ;
    var maxy : Sequence(int) ; maxy := Integer.subrange(1,MX)->collect(0) ;
    var x : int ;
    var y : int ;
        var i : int ; i := 0 ; while i < n do ( (     points[i+1].x := points[i+1].x+(OFF) ; 
     points[i+1].y := points[i+1].y+(OFF) ; 
    x := points[i+1].x ; 
    y := points[i+1].y ; 
    minx[y+1] := Set{minx[y+1], x}->min() ; 
    maxx[y+1] := Set{maxx[y+1], x}->max() ; 
    miny[x+1] := Set{miny[x+1], y}->min() ; 
    maxy[x+1] := Set{maxy[x+1], y}->max() ; 
 )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x := points[i+1].x ; 
     y := points[i+1].y ; 
     if (x > minx[y+1] & x < maxx[y+1]) then     if (y > miny[x+1] & y < maxy[x+1]) then     count := count + 1 ; else skip ; else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var points : Sequence(point) ; points := Sequence{point.newpoint(0, 0),point.newpoint(0, 1),point.newpoint(1, 0),point.newpoint(0, -1),point.newpoint(-1, 0)} ;
     var n : int ; n := points->size() ;
     OclFile["System.out"].println(countPoints(n, points)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    long X=scan.nextLong();
    long Y=scan.nextLong();
    long Z=Y/X ;
    long answer=f(Z)+1 ;
    System.out.println(answer);
  }
  public long f(long Z){
    long t=1 ;
    long result=0 ;
    while(t<Z){
      t*=2 ;
      result+=1 ;
    }
    if(t==Z){
      return result ;
    }
    return result-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var X : long ; X := scan.getCurrent()->toLong() ;
    var Y : long ; Y := scan.getCurrent()->toLong() ;
    var Z : long ; Z := Y / X ;
    var answer : long ; answer := f(Z) + 1 ;
    OclFile["System.out"].println(answer) ; 
 );
   operation f( Z : long) : long
  pre: true
  post: true
  activity: (     var t : long ; t := 1 ;
     var result : long ; result := 0 ;
    while (t < Z) do (     t := t*(2) ; 
     result := result+(1) ) ; 
    if (t = Z) then (     return result ) else skip ; 
    return result - 1 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.*;
import java.io.PrintWriter ;
import java.lang.reflect.Array ;
import java.math.BigInteger ;
import java.util.*;
import java.util.List ;
public class Main {
  static String br=System.getProperty("line.separator");
  static Scanner sc=new Scanner(System.in);
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    long X=nextLong();
    long Y=nextLong();
    int count=0 ;
    for(int i=1 ; ; i++){
      count++;
      X=X*2 ;
      if(X>Y)break ;
    }
    println(count);
  }
  static int nextInt(){
    return Integer.parseInt(next());
  }
  static Long nextLong(){
    return Long.parseLong(next());
  }
  static String next(){
    return sc.next();
  }
  static String nextLine(){
    return sc.nextLine();
  }
  static void println(Object o){
    out.println(o);
    out.flush();
  }
  static void print(Object o){
    PrintWriter out=new PrintWriter(System.out);
    out.print(o);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : String := OclProcess.getEnvironmentProperty("line.separator");
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : long ; X := nextLong() ;
     var Y : long ; Y := nextLong() ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while true do ( (     count := count + 1 ; 
     X := X * 2 ; 
     if (X > Y) then     break else skip )  ;     i := i + 1 ) ; 
    execute println(count) ; 
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation next() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     return sc.nextLine() );
  static   operation println( o : OclAny) : void
  pre: true
  post: true
  activity: (     skip ; 
     skip );
  static   operation print( o : OclAny) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     skip ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int cases=scan.nextInt();
    int e,r,n ;
    long result ;
    int[] maxE,minE ;
    ArrayList<Activity>activities=new ArrayList<Activity>();
    for(int c=1 ; c<=cases ; c++){
      e=scan.nextInt();
      r=scan.nextInt();
      if(r>e)r=e ;
      n=scan.nextInt();
      activities.clear();
      for(int i=0 ; i<n ; i++)activities.add(new Activity(i,scan.nextInt()));
      Collections.sort(activities);
      maxE=new int[n];
      minE=new int[n];
      Arrays.fill(maxE,e);
      Arrays.fill(minE,0);
      result=0 ;
      for(Activity act : activities){
        result+=(maxE[act.i]-minE[act.i])*(long)act.v ;
        for(int i=act.i+1,rNext=minE[act.i]+r ; i<n && rNext<maxE[i]; i++,rNext+=r)maxE[i]=rNext ;
        for(int i=act.i-1,rNext=maxE[act.i]-r ; i>=0 && rNext>=minE[i]; i--,rNext-=r)minE[i]=rNext ;
      }
      System.out.println("Case #"+c+": "+result);
    }
  }
  private static class Activity implements Comparable<Activity>{
    public final int i,v ;
    public Activity(int i,int v){
      this.i=i ;
      this.v=v ;
    }
    public int compareTo(Activity other){
      return-1*((Integer)v).compareTo(other.v);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cases : int ; cases := scan.getCurrent()->toInteger() ;
    var e : int ;
    var r : int ;
    var n : int ;
    var result : long ;
    var maxE : Sequence(int) ;
    var minE : Sequence(int) ;
    var activities : Sequence(Activity) ; activities := Sequence{} ;
        var c : int ; c := 1 ; while c <= cases do ( (     e := scan.getCurrent()->toInteger() ; 
     r := scan.getCurrent()->toInteger() ; 
    if (r > e) then     r := e ; else skip ; 
    n := scan.getCurrent()->toInteger() ; 
    activities := activities->intersection(Set{}) ; 
        var i : int ; i := 0 ; while i < n do (     activities := activities->including(Activity.newActivity(i, scan.getCurrent()->toInteger())) ;  ;     i := i + 1 ) ; 
    activities := activities->sort() ; 
    maxE := Integer.subrange(1,n)->collect(0) ; 
    minE := Integer.subrange(1,n)->collect(0) ; 
    maxE := maxE->collect(e) ; 
    minE := minE->collect(0) ; 
    result := 0 ; 
    for (act : activities) do ( (     result := result+((maxE[act.i+1] - minE[act.i+1]) * act.v->oclAsType(long)) ; 
         var i : int ; i := act.i + 1 ;
    var rNext : int ; rNext := minE[act.i+1] + r ; while i < n & rNext < maxE[i+1] do (     maxE[i+1] := rNext ;  ;     i := i + 1 ;     rNext := rNext+(r) ) ; 
         var i : int ; i := act.i - 1 ;
    var rNext : int ; rNext := maxE[act.i+1] - r ; while i >= 0 & rNext >= minE[i+1] do (     minE[i+1] := rNext ;  ;     i := i - 1 ;     rNext := rNext-(r) ) )  ) ; 
    OclFile["System.out"].println("Case #" + c + ": " + result) ; 
 )  ;     c := c + 1 ) ; 
 );
  static class Activity implements Comparable<Activity> {
   attribute i : int;
   static operation newActivity( i : int, v : int) : Activity
  pre: true
  post: true
  activity:
  ( var self : Activity ;
    self := createActivity();
    self.initialise(i, v);
    return self );
  operation initialise( i : int, v : int) : void
  pre: true  post: true
  activity: (     self.i := i ; 
     self.v := v );
   operation compareTo( other : Activity) : int
  pre: true
  post: true
  activity: (     return -1 * (v->oclAsType(int))->compareTo(other.v) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public final class p052 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p052().run());
  }
  public String run(){
    for(int i=1 ; ; i++){
      if(i>Integer.MAX_VALUE/6)throw new ArithmeticException("Overflow");
      if(multiplesHaveSameDigits(i))return Integer.toString(i);
    }
  }
  private static boolean multiplesHaveSameDigits(int x){
    for(int i=2 ; i<=6 ; i++){
      if(! Arrays.equals(toSortedDigits(x),toSortedDigits(i*x)))return false ;
    }
    return true ;
  }
  private static char[] toSortedDigits(int x){
    char[] result=Integer.toString(x).toCharArray();
    Arrays.sort(result);
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class p052 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p052.newp052().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while true do ( (     if (i > 2147483647 / 6) then     error ArithmeticException("Overflow") ; else skip ; 
     if (multiplesHaveSameDigits(i)) then     return ((i) + "") else skip )  ;     i := i + 1 ) );
  static   operation multiplesHaveSameDigits( x : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i <= 6 do ( (     if (not(toSortedDigits(x) = toSortedDigits(i * x))) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation toSortedDigits( x : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var result : Sequence(String) ; result := ((x) + "")->characters() ;
     result := result->sort() ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CMultipleGift solver=new CMultipleGift();
    solver.solve(1,in,out);
    out.close();
  }
  static class CMultipleGift {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      long x=in.nextLong();
      long y=in.nextLong();
      long now=x ;
      int res=0 ;
      while(now<=y){
        res++;
        now<<=1 ;
      }
      out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CMultipleGift ; solver := CMultipleGift.newCMultipleGift() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CMultipleGift {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var x : long ; x := in.getCurrent()->toLong() ;
     var y : long ; y := in.getCurrent()->toLong() ;
    var now : long ; now := x ;
    var res : int ; res := 0 ;
    while (now <= y) do (     res := res + 1 ; 
     now := now*(2->pow(1)) ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.SortedSet ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    for(; ; ){
      int n=Integer.parseInt(scan.next());
      int m=Integer.parseInt(scan.next());
      if(n==0 && m==0)break ;
      int a[]=new int[n];
      int w[]=new int[m];
      for(int i=0 ; i<n ; i++){
        a[i]=Integer.parseInt(scan.next());
      }
      for(int j=0 ; j<m ; j++){
        w[j]=Integer.parseInt(scan.next());
      }
      SortedSet<Integer>commonAdditions=null ;
      for(int i=0 ; i<n ; i++){
        SortedSet<Integer>additions=new TreeSet<Integer>();
        boolean bJust=calcNearestWeight(a[i],w,0,0,additions);
        if(! bJust){
          if(commonAdditions==null){
            commonAdditions=additions ;
          }
          else {
            commonAdditions.retainAll(additions);
          }
        }
      }
      if(commonAdditions==null){
        System.out.println(0);
      }
      else {
        if(commonAdditions.size()>0){
          System.out.println(commonAdditions.first());
        }
        else {
          System.out.println(-1);
        }
      }
    }
    scan.close();
  }
  private static boolean calcNearestWeight(int x,int w[],int i,int sum,SortedSet<Integer>additions){
    if(x==sum)return true ;
    if(i==w.length){
      additions.add(Math.abs(x-sum));
      return false ;
    }
    if(calcNearestWeight(x,w,i+1,sum,additions))return true ;
    if(calcNearestWeight(x,w,i+1,sum+w[i],additions))return true ;
    return calcNearestWeight(x,w,i+1,sum-w[i],additions);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := (scan.getCurrent())->toInteger() ;
     var m : int ; m := (scan.getCurrent())->toInteger() ;
    if (n = 0 & m = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var w : Sequence(int) ; w := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (scan.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < m do ( (     w[j+1] := (scan.getCurrent())->toInteger() )  ;     j := j + 1 ) ; 
    var commonAdditions : Set(int) ; commonAdditions := null ;
        var i : int ; i := 0 ; while i < n do ( (     var additions : Set(int) ; additions := Set{} ;
     var bJust : boolean ; bJust := calcNearestWeight(a[i+1], w, 0, 0, additions) ;
     if (not(bJust)) then (     if (commonAdditions = null) then (     commonAdditions := additions ) else (     commonAdditions := commonAdditions->intersection(additions) ) ) else skip )  ;     i := i + 1 ) ; 
    if (commonAdditions = null) then (     OclFile["System.out"].println(0) ) else (     if (commonAdditions->size() > 0) then (     OclFile["System.out"].println(commonAdditions->first()) ) else (     OclFile["System.out"].println(-1) ) ) ;  
 )  ) ; 
     skip );
  static   operation calcNearestWeight( x : int, w : Sequence(int), i : int, sum : int, additions : Set(int)) : boolean
  pre: true
  post: true
  activity: (     if (x = sum) then     return true else skip ; 
     if (i = w->size()) then (     additions := additions->including(if x - sum < 0 then -(x - sum) else x - sum endif) ; 
     return false ) else skip ; 
    if (calcNearestWeight(x, w, i + 1, sum, additions)) then     return true else skip ; 
    if (calcNearestWeight(x, w, i + 1, sum + w[i+1], additions)) then     return true else skip ; 
    return calcNearestWeight(x, w, i + 1, sum - w[i+1], additions) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  static Scanner s=new Scanner(System.in);
  static int gInt(){
    return Integer.parseInt(s.next());
  }
  static long gLong(){
    return Long.parseLong(s.next());
  }
  public static void main(String[] $){
    long r=0,x=gLong(),y=gLong();
    for(; x<=y ; x*=2)++r ;
    System.out.println(r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation gInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation gLong() : long
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toLong() );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : long ; r := 0 ;
    var x : long ; x := gLong() ;
    var y : long ; y := gLong() ;
       while x <= y do (     r := r + 1 ;  ;     x := x*(2) ) ; 
     OclFile["System.out"].println(r) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str_xy=br.readLine().split(" ");
    long x=Long.parseLong(str_xy[0]);
    long y=Long.parseLong(str_xy[1]);
    int count=1 ;
    while(x*2<=y){
      count++;
      x*=2 ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str_xy : Sequence(String) ; str_xy := br.readLine()->split(" ") ;
    var x : long ; x := (str_xy[0+1])->toLong() ;
    var y : long ; y := (str_xy[1+1])->toLong() ;
    var count : int ; count := 1 ;
    while (x * 2 <= y) do (     count := count + 1 ; 
     x := x*(2) ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int sticks[]={
    6,2,5,5,4,5,6,3,7,6 };
    static int countSticks(String str,int n){
      int cnt=0 ;
      for(int i=0 ; i<n ; i++){
        cnt+=(sticks[str.charAt(i)-'0']);
      }
      return cnt ;
    }
    public static void main(String[] args){
      String str="56" ;
      int n=str.length();
      System.out.println(countSticks(str,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute sticks : int := Sequence{6,2,5,5,4,5,6,3,7,6};
  static   operation countSticks( str : String, n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     cnt := cnt+((sticks[str->at(i+1) - ('0')->char2byte()+1])) )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "56" ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].println(countSticks(str, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    int t=Integer.parseInt(in.readLine());
    while(t-->0){
      int n=Integer.parseInt(in.readLine());
      int[] a=new int[n];
      StringTokenizer st=new StringTokenizer(in.readLine());
      for(int i=0 ; i<n ; i++){
        a[i]=Integer.parseInt(st.nextToken());
      }
      boolean replaceNext=false ;
      int ans=0 ;
      for(int i=1 ; i<n-1 ; i++){
        if(replaceNext){
          a[i]=Math.max(a[i-1],a[i+1]);
          ans++;
          replaceNext=false ;
        }
        if(a[i]>a[i-1] && a[i]>a[i+1]){
          replaceNext=true ;
        }
      }
      if(replaceNext){
        a[n-1]=a[n-2];
        ans++;
        replaceNext=false ;
      }
      out.println(ans);
      for(int i=0 ; i<n ; i++){
        out.print(a[i]+" ");
      }
      out.println();
    }
    in.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (in.readLine())->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := (in.readLine())->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(in.readLine()) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    var replaceNext : boolean ; replaceNext := false ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < n - 1 do ( (     if (replaceNext) then (     a[i+1] := Set{a[i - 1+1], a[i + 1+1]}->max() ; 
     ans := ans + 1 ; 
     replaceNext := false ) else skip ; 
     if (a[i+1] > a[i - 1+1] & a[i+1] > a[i + 1+1]) then (     replaceNext := true ) else skip )  ;     i := i + 1 ) ; 
    if (replaceNext) then (     a[n - 1+1] := a[n - 2+1] ; 
     ans := ans + 1 ; 
     replaceNext := false ) else skip ; 
    skip ; 
        var i : int ; i := 0 ; while i < n do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int testNumber=sc.nextInt();
    while(testNumber-->0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
      int ans=0 ;
      for(int i=1 ; i<n-1 ; i++){
        if(arr[i]>arr[i-1] && arr[i]>arr[i+1]){
          if(i+2<n && arr[i+2]>arr[i])arr[i+1]=arr[i+2];
          else arr[i+1]=arr[i];
          ans++;
        }
      }
      System.out.println(ans);
      for(int j=0 ; j<n ; j++)System.out.print(arr[j]+" ");
      System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testNumber : int ; testNumber := sc.getCurrent()->toInteger() ;
         while (testNumber > 0) do (        testNumber := testNumber - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < n - 1 do ( (     if (arr[i+1] > arr[i - 1+1] & arr[i+1] > arr[i + 1+1]) then (     if (i + 2 < n & arr[i + 2+1] > arr[i+1]) then     arr[i + 1+1] := arr[i + 2+1] else     arr[i + 1+1] := arr[i+1] ; ;  
     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
        var j : int ; j := 0 ; while j < n do (     OclFile["System.out"].print(arr[j+1] + " ") ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].println("") ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void command(boolean arr[],int a,int b){
    arr[a] ^=true ;
    arr[b+1] ^=true ;
  }
  static void process(boolean arr[],int n){
    for(int k=1 ; k<=n ; k++){
      arr[k] ^=arr[k-1];
    }
  }
  static void result(boolean arr[],int n){
    for(int k=1 ; k<=n ; k++){
      if(arr[k]==true)System.out.print("1"+" ");
      else System.out.print("0"+" ");
    }
  }
  public static void main(String args[]){
    int n=5,m=3 ;
    boolean arr[]=new boolean[n+2];
    command(arr,1,5);
    command(arr,2,5);
    command(arr,3,5);
    process(arr,n);
    result(arr,n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation command( arr : Sequence(boolean), a : int, b : int) : void
  pre: true
  post: true
  activity: (     arr[a+1] := MathLib.bitwiseXor(arr[a+1],true) ; 
     arr[b + 1+1] := MathLib.bitwiseXor(arr[b + 1+1],true) );
  static   operation process( arr : Sequence(boolean), n : int) : void
  pre: true
  post: true
  activity: (         var k : int ; k := 1 ; while k <= n do ( (     arr[k+1] := MathLib.bitwiseXor(arr[k+1],arr[k - 1+1]) )  ;     k := k + 1 ) );
  static   operation result( arr : Sequence(boolean), n : int) : void
  pre: true
  post: true
  activity: (         var k : int ; k := 1 ; while k <= n do ( (     if (arr[k+1] = true) then     OclFile["System.out"].print("1" + " ") ; else     OclFile["System.out"].print("0" + " ") ; )  ;     k := k + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var m : int ; m := 3 ;
     var arr : Sequence(boolean) ; arr := Integer.subrange(1,n + 2)->collect(false) ;
    execute command(arr, 1, 5) ; 
    execute command(arr, 2, 5) ; 
    execute command(arr, 3, 5) ; 
    execute process(arr, n) ; 
    execute result(arr, n) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int mostFrequent(int arr[],int n){
    Arrays.sort(arr);
    int max_count=1,res=arr[0];
    int curr_count=1 ;
    for(int i=1 ; i<n ; i++){
      if(arr[i]==arr[i-1])curr_count++;
      else {
        if(curr_count>max_count){
          max_count=curr_count ;
          res=arr[i-1];
        }
        curr_count=1 ;
      }
    }
    if(curr_count>max_count){
      max_count=curr_count ;
      res=arr[n-1];
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      1,5,2,1,3,2,1 };
      int n=arr.length ;
      System.out.println(mostFrequent(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation mostFrequent( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var max_count : int ; max_count := 1 ;
    var res : int ; res := arr[0+1] ;
    var curr_count : int ; curr_count := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] = arr[i - 1+1]) then     curr_count := curr_count + 1 ; else (     if (curr_count > max_count) then (     max_count := curr_count ; 
     res := arr[i - 1+1] ) else skip ; 
     curr_count := 1 ) )  ;     i := i + 1 ) ; 
    if (curr_count > max_count) then (     max_count := curr_count ; 
     res := arr[n - 1+1] ) else skip ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,2,1,3,2,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(mostFrequent(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=26 ;
  static int maxLength(String str,int len){
    int res=0 ;
    int lastPos[]=new int[MAX];
    for(int i=0 ; i<MAX ; i++){
      lastPos[i]=-1 ;
    }
    for(int i=0 ; i<len ; i++){
      int C=str.charAt(i)-'a' ;
      if(lastPos[C]!=-1){
        res=Math.max(len-(i-lastPos[C]-1)-1,res);
      }
      lastPos[C]=i ;
    }
    return res ;
  }
  public static void main(String args[]){
    String str="geeksforgeeks" ;
    int len=str.length();
    System.out.println(maxLength(str,len));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 26;
  static   operation maxLength( str : String, len : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     var lastPos : Sequence(int) ; lastPos := Integer.subrange(1,MAX)->collect(0) ;
        var i : int ; i := 0 ; while i < MAX do ( (     lastPos[i+1] := -1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < len do ( (     var C : int ; C := str->at(i+1) - ('a')->char2byte() ;
     if (lastPos[C+1] /= -1) then (     res := Set{len - (i - lastPos[C+1] - 1) - 1, res}->max() ) else skip ; 
     lastPos[C+1] := i )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var len : int ; len := str->size() ;
     OclFile["System.out"].println(maxLength(str, len)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static long count(int arr[],int n,int x){
    if(x==1){
      long ans=(long)Math.pow(2,n)-1 ;
      return ans ;
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] % x==0)count++;
    }
    long ans=(long)Math.pow(2,count)-1 ;
    return ans ;
  }
  public static void main(String args[]){
    int[] arr={
      2,4,3,5 };
      int n=arr.length ;
      int x=1 ;
      System.out.println(count(arr,n,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation count( arr : Sequence(int), n : int, x : int) : long
  pre: true
  post: true
  activity: (     if (x = 1) then (     var ans : long ; ans := 2->pow(n)->oclAsType(long) - 1 ;
     return ans ) else skip ; 
     var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod x = 0) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 2->pow(count)->oclAsType(long) - 1 ;
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,3,5} ;
     var n : int ; n := arr->size() ;
     var x : int ; x := 1 ;
     OclFile["System.out"].println(count(arr, n, x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAX=1000000 ;
  static int ksmallest(int arr[],int n,int k){
    int b[]=new int[MAX];
    for(int i=0 ; i<n ; i++){
      b[arr[i] ]=1 ;
    }
    for(int j=1 ; j<MAX ; j++){
      if(b[j]!=1){
        k--;
      }
      if(k!=1){
        return j ;
      }
    }
    return Integer.MAX_VALUE ;
  }
  public static void main(String[] args){
    int k=1 ;
    int arr[]={
      1 };
      int n=arr.length ;
      System.out.println(ksmallest(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 1000000;
  static   operation ksmallest( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var b : Sequence(int) ; b := Integer.subrange(1,MAX)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     b[arr[i+1]+1] := 1 )  ;     i := i + 1 ) ; 
         var j : int ; j := 1 ; while j < MAX do ( (     if (b[j+1] /= 1) then (     k := k - 1 ) else skip ; 
     if (k /= 1) then (     return j ) else skip )  ;     j := j + 1 ) ; 
     return 2147483647 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 1 ;
     var arr : Sequence(int) ; arr := Sequence{1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(ksmallest(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isDivisible(int n){
    int d ;
    while((n/100)>0){
      d=n % 10 ;
      n/=10 ;
      n=Math.abs(n+(d*13));
    }
    return(n % 43==0);
  }
  public static void main(String[] args){
    int N=2795 ;
    if(isDivisible(N))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isDivisible( n : int) : boolean
  pre: true
  post: true
  activity: (     var d : int ;
     while ((n / 100) > 0) do (     d := n mod 10 ; 
     n := n/(10) ; 
     n := if n + (d * 13) < 0 then -(n + (d * 13)) else n + (d * 13) endif ) ; 
     return (n mod 43 = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 2795 ;
     if (isDivisible(N)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x[]=new int[n];
    int y[]=new int[n];
    int sumx=0,sumy=0 ;
    for(int i=0 ; i<n ; i++){
      x[i]=sc.nextInt();
      sumx+=x[i];
    }
    for(int i=0 ; i<n ; i++){
      y[i]=sc.nextInt();
      sumy+=y[i];
    }
    if(sumy<=sumx)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
    var sumx : int ; sumx := 0 ;
    var sumy : int ; sumy := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     sumx := sumx+(x[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     y[i+1] := sc.getCurrent()->toInteger() ; 
     sumy := sumy+(y[i+1]) )  ;     i := i + 1 ) ; 
    if (sumy <= sumx) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class DP {
  static int mod=(int)1e9+7 ;
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int N=in.nextInt();
    int dp[]=new int[1<<3];
    Arrays.fill(dp,Integer.MAX_VALUE);
    dp[0]=0 ;
    for(int i=0 ; i<N ; i++){
      int price=in.nextInt();
      String s=in.next();
      int mask=0 ;
      if(s.contains("A"))mask |=1 ;
      if(s.contains("B"))mask |=2 ;
      if(s.contains("C"))mask |=4 ;
      for(int k=0 ; k<(1<<3); k++){
        if(dp[k]!=Integer.MAX_VALUE){
          int t=k | mask ;
          dp[t]=Math.min(dp[t],dp[k]+price);
        }
      }
    }
    out.println(dp[7]==Integer.MAX_VALUE ?-1 : dp[7]);
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(String s)throws FileNotFoundException {
      br=new BufferedReader(new FileReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DP {
  static   attribute mod : int := 1e9->oclAsType(int) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,(1*(2->pow(3)))->oclAsType(long))->collect(0) ;
    dp := dp->collect(2147483647) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < N do ( (     var price : int ; price := in.getCurrent()->toInteger() ;
     var s : String ; s := in.getCurrent() ;
    var mask : int ; mask := 0 ;
    if (s->includes("A")) then     mask := MathLib.bitwiseOr(mask, 1) ; else skip ; 
    if (s->includes("B")) then     mask := MathLib.bitwiseOr(mask, 2) ; else skip ; 
    if (s->includes("C")) then     mask := MathLib.bitwiseOr(mask, 4) ; else skip ; 
        var k : int ; k := 0 ; while k < ((1*(2->pow(3)))->oclAsType(long)) do ( (     if (dp[k+1] /= 2147483647) then (     var t : int ; t := MathLib.bitwiseOr(k,mask) ;
     dp[t+1] := Set{dp[t+1], dp[k+1] + price}->min() ) else skip )  ;     k := k + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(s))) );
   static operation newScanner( s : String) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isDivisible(int n){
    int d ;
    while((n/100)>0){
      d=n % 10 ;
      n/=10 ;
      n=Math.abs(n-(d*14));
    }
    return(n % 47==0);
  }
  public static void main(String[] args){
    int N=59173 ;
    if(isDivisible(N))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isDivisible( n : int) : boolean
  pre: true
  post: true
  activity: (     var d : int ;
     while ((n / 100) > 0) do (     d := n mod 10 ; 
     n := n/(10) ; 
     n := if n - (d * 14) < 0 then -(n - (d * 14)) else n - (d * 14) endif ) ; 
     return (n mod 47 = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 59173 ;
     if (isDivisible(N)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isDivisible(int n){
    int d ;
    while((n/100)<=0){
      d=n % 10 ;
      n/=10 ;
      n=Math.abs(n-(d*7));
    }
    return(n % 71==0);
  }
  public static void main(String args[]){
    int N=5041 ;
    if(isDivisible(N))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isDivisible( n : int) : boolean
  pre: true
  post: true
  activity: (     var d : int ;
     while ((n / 100) <= 0) do (     d := n mod 10 ; 
     n := n/(10) ; 
     n := if n - (d * 7) < 0 then -(n - (d * 7)) else n - (d * 7) endif ) ; 
     return (n mod 71 = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5041 ;
     if (isDivisible(N)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isDivisible(int n){
    int d ;
    while((n/100)>0){
      d=n % 10 ;
      n/=10 ;
      n=Math.abs(n-(d*3));
    }
    return(n % 31==0);
  }
  public static void main(String[] args){
    int N=1922 ;
    if(isDivisible(N))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isDivisible( n : int) : boolean
  pre: true
  post: true
  activity: (     var d : int ;
     while ((n / 100) > 0) do (     d := n mod 10 ; 
     n := n/(10) ; 
     n := if n - (d * 3) < 0 then -(n - (d * 3)) else n - (d * 3) endif ) ; 
     return (n mod 31 = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 1922 ;
     if (isDivisible(N)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long Odd_Sum(int n){
    long total=(n+1)/2 ;
    long odd=total*total ;
    return odd ;
  }
  static long Even_Sum(int n){
    long total=(n)/2 ;
    long even=total*(total+1);
    return even ;
  }
  static long sumLtoR(int L,int R){
    long odd_sum,even_sum ;
    odd_sum=Odd_Sum(R)-Odd_Sum(L-1);
    even_sum=Even_Sum(R)-Even_Sum(L-1);
    return even_sum-odd_sum ;
  }
  public static void main(String[] args){
    int L=1,R=5 ;
    System.out.println(sumLtoR(L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Odd_Sum( n : int) : long
  pre: true
  post: true
  activity: (     var total : long ; total := (n + 1) / 2 ;
     var odd : long ; odd := total * total ;
     return odd );
  static   operation Even_Sum( n : int) : long
  pre: true
  post: true
  activity: (     var total : long ; total := (n) / 2 ;
     var even : long ; even := total * (total + 1) ;
     return even );
  static   operation sumLtoR( L : int, R : int) : long
  pre: true
  post: true
  activity: (     var odd_sum : long ;
    var even_sum : long ;
     odd_sum := Odd_Sum(R) - Odd_Sum(L - 1) ; 
     even_sum := Even_Sum(R) - Even_Sum(L - 1) ; 
     return even_sum - odd_sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 1 ;
    var R : int ; R := 5 ;
     OclFile["System.out"].println(sumLtoR(L, R)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1077A_FrogJumping {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      long a=input.nextLong();
      long b=input.nextLong();
      long k=input.nextLong();
      input.nextLine();
      long mod=k % 2 ;
      long division=k/2 ;
      long result=(long)((division+mod)*a-division*b);
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1077A_FrogJumping {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var a : long ; a := input.getCurrent()->toLong() ;
     var b : long ; b := input.getCurrent()->toLong() ;
    var k : long ; k := input.getCurrent()->toLong() ;
    skip ; 
    var mod : long ; mod := k mod 2 ;
    var division : long ; division := k / 2 ;
    var result : long ; result := ((division + mod) * a - division * b)->oclAsType(long) ;
    OclFile["System.out"].println(result) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdin=new Scanner(System.in);
    int t=stdin.nextInt();
    for(int i=0 ; i<t ; i++){
      long a=stdin.nextInt();
      long b=stdin.nextInt();
      long k=stdin.nextInt();
      if(k % 2==0){
        k=k/2 ;
        System.out.println(a*k-b*k);
      }
      else {
        k=k/2+1 ;
        System.out.println(a*k-b*(k-1));
      }
    }
    stdin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := stdin.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : long ; a := stdin.getCurrent()->toInteger() ;
     var b : long ; b := stdin.getCurrent()->toInteger() ;
     var k : long ; k := stdin.getCurrent()->toInteger() ;
     if (k mod 2 = 0) then (     k := k / 2 ; 
     OclFile["System.out"].println(a * k - b * k) ) else (     k := k / 2 + 1 ; 
     OclFile["System.out"].println(a * k - b * (k - 1)) ) )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findEle(int arr[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=arr[i];
    for(int i=0 ; i<n ; i++)if(arr[i]==sum-arr[i])return arr[i];
    return-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,6 };
      int n=arr.length ;
      System.out.print(findEle(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findEle( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do (     if (arr[i+1] = sum - arr[i+1]) then     return arr[i+1] else skip ;  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(findEle(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      long a=s.nextInt();
      long b=s.nextInt();
      int k=s.nextInt();
      long c=0 ;
      int even=k/2 ;
      int odd=0 ;
      if(k % 2==0)odd=even ;
      else odd=even+1 ;
      c=odd*a+even*-b ;
      System.out.println(c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : long ; a := s.getCurrent()->toInteger() ;
     var b : long ; b := s.getCurrent()->toInteger() ;
    var k : int ; k := s.getCurrent()->toInteger() ;
    var c : long ; c := 0 ;
    var even : int ; even := k / 2 ;
    var odd : int ; odd := 0 ;
    if (k mod 2 = 0) then     odd := even else     odd := even + 1 ; ;  
    c := odd * a + even * -b ; 
    OclFile["System.out"].println(c) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test245 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      long a=in.nextLong();
      long b=in.nextLong();
      long c=in.nextLong();
      Long d=c/2 ;
      if(c % 2==0){
        System.out.println((a*d)-(b*d));
      }
      else {
        System.out.println((a*(d+1))-(b*d));
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test245 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var a : long ; a := in.getCurrent()->toLong() ;
     var b : long ; b := in.getCurrent()->toLong() ;
    var c : long ; c := in.getCurrent()->toLong() ;
    var d : long ; d := c / 2 ;
    if (c mod 2 = 0) then (     OclFile["System.out"].println((a * d) - (b * d)) ) else (     OclFile["System.out"].println((a * (d + 1)) - (b * d)) ) ;  
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Ratio {
  static boolean isRatioPossible(int lowCost,int upCost,int lowQuant,int upQuant,int r){
    for(int i=lowQuant ; i<=upQuant ; i++){
      int ans=i*r ;
      if(lowCost<=ans && ans<=upCost)return true ;
    }
    return false ;
  }
  public static void main(String args[]){
    int lowCost=14,upCost=30,lowQuant=5,upQuant=12,r=9 ;
    if(isRatioPossible(lowCost,upCost,lowQuant,upQuant,r))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ratio {
  static   operation isRatioPossible( lowCost : int, upCost : int, lowQuant : int, upQuant : int, r : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := lowQuant ; while i <= upQuant do ( (     var ans : int ; ans := i * r ;
     if (lowCost <= ans & ans <= upCost) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var lowCost : int ; lowCost := 14 ;
    var upCost : int ; upCost := 30 ;
    var lowQuant : int ; lowQuant := 5 ;
    var upQuant : int ; upQuant := 12 ;
    var r : int ; r := 9 ;
     if (isRatioPossible(lowCost, upCost, lowQuant, upQuant, r)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPowerOfTwo(int n){
    if(n==0)return false ;
    return(int)(Math.ceil((Math.log(n)/Math.log(2))))==(int)(Math.floor(((Math.log(n)/Math.log(2)))));
  }
  public static void main(String[] args){
    if(isPowerOfTwo(31))System.out.println("Yes");
    else System.out.println("No");
    if(isPowerOfTwo(64))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPowerOfTwo( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 0) then     return false else skip ; 
     return ((((n)->log() / (2)->log()))->ceil())->oclAsType(int) = (((((n)->log() / (2)->log())))->floor())->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (isPowerOfTwo(31)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
     if (isPowerOfTwo(64)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class AA {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int a=300001 ;
    int b=300001 ;
    int c=300001 ;
    int ab=300001 ;
    int bc=300001 ;
    int ca=300001 ;
    int abc=300001 ;
    for(int i=0 ; i<t ; i++){
      int co=sc.nextInt();
      String vit=sc.next();
      int n=vit.length();
      int s=0 ;
      for(int j=0 ; j<n ; j++){
        s=s+(int)vit.charAt(j);
      }
      if(s==131)ab=Math.min(ab,co);
      if(s==133)bc=Math.min(bc,co);
      if(s==132)ca=Math.min(ca,co);
      if(s==65)a=Math.min(a,co);
      if(s==66)b=Math.min(b,co);
      if(s==67)c=Math.min(c,co);
      if(s==198)abc=Math.min(abc,co);
    }
    ArrayList<Integer>ls=new ArrayList<Integer>();
    ls.add(abc);
    ls.add(ab+c);
    ls.add(bc+a);
    ls.add(ca+b);
    ls.add(ca+bc);
    ls.add(ab+bc);
    ls.add(ca+ab);
    ls.add(a+b+c);
    int y=Collections.min(ls);
    if(y>=300001)System.out.print(-1);
    else System.out.print(y);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class AA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var a : int ; a := 300001 ;
    var b : int ; b := 300001 ;
    var c : int ; c := 300001 ;
    var ab : int ; ab := 300001 ;
    var bc : int ; bc := 300001 ;
    var ca : int ; ca := 300001 ;
    var abc : int ; abc := 300001 ;
        var i : int ; i := 0 ; while i < t do ( (     var co : int ; co := sc.getCurrent()->toInteger() ;
     var vit : String ; vit := sc.getCurrent() ;
    var n : int ; n := vit->size() ;
    var s : int ; s := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     s := s + vit->at(j+1)->oclAsType(int) )  ;     j := j + 1 ) ; 
    if (s = 131) then     ab := Set{ab, co}->min() ; else skip ; 
    if (s = 133) then     bc := Set{bc, co}->min() ; else skip ; 
    if (s = 132) then     ca := Set{ca, co}->min() ; else skip ; 
    if (s = 65) then     a := Set{a, co}->min() ; else skip ; 
    if (s = 66) then     b := Set{b, co}->min() ; else skip ; 
    if (s = 67) then     c := Set{c, co}->min() ; else skip ; 
    if (s = 198) then     abc := Set{abc, co}->min() ; else skip ; 
 )  ;     i := i + 1 ) ; 
    var ls : Sequence(int) ; ls := Sequence{} ;
    ls := ls->including(abc) ; 
    ls := ls->including(ab + c) ; 
    ls := ls->including(bc + a) ; 
    ls := ls->including(ca + b) ; 
    ls := ls->including(ca + bc) ; 
    ls := ls->including(ab + bc) ; 
    ls := ls->including(ca + ab) ; 
    ls := ls->including(a + b + c) ; 
    var y : int ; y := .min(ls) ;
    if (y >= 300001) then     OclFile["System.out"].print(-1) else     OclFile["System.out"].print(y) ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Set ;
public final class p087 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p087().run());
  }
  private static final int LIMIT=50000000 ;
  public String run(){
    int[] primes=Library.listPrimes(Library.sqrt(LIMIT));
    Set<Integer>sums=new HashSet<>();
    sums.add(0);
    for(int i=2 ; i<=4 ; i++){
      Set<Integer>newsums=new HashSet<>();
      for(int p : primes){
        long q=1 ;
        for(int j=0 ; j<i ; j++)q*=p ;
        if(q>LIMIT)break ;
        int r=(int)q ;
        for(int x : sums){
          if(x+r<=LIMIT)newsums.add(x+r);
        }
      }
      sums=newsums ;
    }
    return Integer.toString(sums.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class p087 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p087.newp087().run()) );
  static    attribute LIMIT : int := 50000000;
   operation run() : String
  pre: true
  post: true
  activity: (     var primes : Sequence(int) ; primes := Library.listPrimes(Library.sqrt(LIMIT)) ;
     var sums : Set(int) ; sums := Set{} ;
    sums := sums->including(0) ; 
        var i : int ; i := 2 ; while i <= 4 do ( (     var newsums : Set(int) ; newsums := Set{} ;
     for (p : primes) do ( (     var q : long ; q := 1 ;
         var j : int ; j := 0 ; while j < i do (     q := q*(p) ;  ;     j := j + 1 ) ; 
    if (q > LIMIT) then     break else skip ; 
    var r : int ; r := q->oclAsType(int) ;
    for (x : sums) do ( (     if (x + r <= LIMIT) then     newsums := newsums->including(x + r) ; else skip )  ) ; 
 )  ) ; 
     sums := newsums )  ;     i := i + 1 ) ; 
    return ((sums->size()) + "") 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int longLenSub(int[] arr,int n){
    HashMap<Integer,Integer>um=new HashMap<Integer,Integer>();
    int longLen=0 ;
    for(int i=0 ; i<n ; i++){
      int len=0 ;
      if(um.containsKey(arr[i]-1)&& len<um.get(arr[i]-1))len=um.get(arr[i]-1);
      if(um.containsKey(arr[i]+1)&& len<um.get(arr[i]+1))len=um.get(arr[i]+1);
      um.put(arr[i],len+1);
      if(longLen<um.get(arr[i]))longLen=um.get(arr[i]);
    }
    return longLen ;
  }
  public static void main(String[] args){
    int[] arr={
      1,2,3,4,5,3,2 };
      int n=arr.length ;
      System.out.println("Longest length subsequence="+longLenSub(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation longLenSub( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var um : Map(int,int) ; um := Map{} ;
     var longLen : int ; longLen := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var len : int ; len := 0 ;
     if (um->keys()->includes(arr[i+1] - 1) & len < um->at(arr[i+1] - 1)) then     len := um->at(arr[i+1] - 1) ; else skip ; 
    if (um->keys()->includes(arr[i+1] + 1) & len < um->at(arr[i+1] + 1)) then     len := um->at(arr[i+1] + 1) ; else skip ; 
    um := um->union(Map{arr[i+1] |-> len + 1}) ; 
    if (longLen < um->at(arr[i+1])) then     longLen := um->at(arr[i+1]) ; else skip ; 
 )  ;     i := i + 1 ) ; 
     return longLen );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,3,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Longest length subsequence=" + longLenSub(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem1 {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int a=s.nextInt();
      int b=s.nextInt();
      System.out.println(a+b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := s.getCurrent()->toInteger() ;
     var b : int ; b := s.getCurrent()->toInteger() ;
     OclFile["System.out"].println(a + b) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class NewClass23 {
  public static void main(String[] args){
    java.util.Scanner in=new java.util.Scanner(System.in);
    int x=in.nextInt();
    while(x-->0){
      int a=in.nextInt();
      int b=in.nextInt();
      int sum=a+b ;
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class NewClass23 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : Scanner ; in := Scanner.newScanner(OclFile["System.in"]) ;
     var x : int ; x := in.nextInt() ;
         while (x > 0) do (        x := x - 1 ;     skip ; (     var a : int ; a := in.nextInt() ;
     var b : int ; b := in.nextInt() ;
     var sum : int ; sum := a + b ;
     OclFile["System.out"].println(sum) ) ;  ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class NewClass23 {
  public static void main(String[] args){
    java.util.Scanner in=new java.util.Scanner(System.in);
    int x=in.nextInt();
    while(x-->0){
      int a=in.nextInt();
      int b=in.nextInt();
      int sum=a+b ;
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class NewClass23 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : Scanner ; in := Scanner.newScanner(OclFile["System.in"]) ;
     var x : int ; x := in.nextInt() ;
         while (x > 0) do (        x := x - 1 ;     skip ; (     var a : int ; a := in.nextInt() ;
     var b : int ; b := in.nextInt() ;
     var sum : int ; sum := a + b ;
     OclFile["System.out"].println(sum) ) ;  ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.System.*;
import java.util.*;
class Main {
  public static void main(String[] arg){
    Scanner sc=new Scanner(in);
    int tcc=sc.nextInt();
    for(int tc=1 ; tc<=tcc ; ++tc){
      int r=sc.nextInt();
      int k=sc.nextInt();
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; ++i)arr[i]=sc.nextInt();
      long ans=0 ;
      long[] score=new long[n];
      int[] vis=new int[n];
      int pos=0 ;
      while(r>0){
        if(vis!=null && score!=null){
          if(vis[pos]!=0){
            int len=vis[pos]-r ;
            long change=ans-score[pos];
            int reps=r/len ;
            if(reps>0){
              r-=len*reps ;
              ans+=change*reps ;
            }
            vis=null ;
            score=null ;
            continue ;
          }
          score[pos]=ans ;
          vis[pos]=r ;
        }
        int s=k ;
        int g=0 ;
        while(s>=arr[pos] && g<n){
          s-=arr[pos];
          pos=(pos+1)% n ;
++g ;
        }
        ans+=k-s ;
--r ;
      }
      out.printf("Case #%d: %d%n",tc,ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var tcc : int ; tcc := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 1 ; while tc <= tcc do ( (     var r : int ; r := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var score : Sequence(long) ; score := Integer.subrange(1,n)->collect(0) ;
    var vis : Sequence(int) ; vis := Integer.subrange(1,n)->collect(0) ;
    var pos : int ; pos := 0 ;
    while (r > 0) do (     if (vis /= null & score /= null) then (     if (vis[pos+1] /= 0) then (     var len : int ; len := vis[pos+1] - r ;
     var change : long ; change := ans - score[pos+1] ;
    var reps : int ; reps := r / len ;
    if (reps > 0) then (     r := r-(len * reps) ; 
     ans := ans+(change * reps) ) else skip ; 
    vis := null ; 
    score := null ; 
    continue 
 ) else skip ; 
     score[pos+1] := ans ; 
     vis[pos+1] := r ) else skip ; 
     var s : int ; s := k ;
    var g : int ; g := 0 ;
    while (s >= arr[pos+1] & g < n) do (     s := s-(arr[pos+1]) ; 
     pos := (pos + 1) mod n ; 
     g := g + 1 ) ; 
    ans := ans+(k - s) ; 
    r := r - 1 ; 
 ) ; 
    out.printf("Case #%d: %d%n", tc, ans) ; 
 )  ;     tc := tc + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int i=0 ; i<t ; i++){
      int c=input.nextInt();
      int d=input.nextInt();
      System.out.println(c+d);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var c : int ; c := input.getCurrent()->toInteger() ;
     var d : int ; d := input.getCurrent()->toInteger() ;
     OclFile["System.out"].println(c + d) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class p1 {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    long num=scan.nextLong();
    for(int i=0 ; i<num ; i++){
      long a=scan.nextLong();
      long b=scan.nextLong();
      System.out.println(a+b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class p1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : long ; num := scan.getCurrent()->toLong() ;
         var i : int ; i := 0 ; while i < num do ( (     var a : long ; a := scan.getCurrent()->toLong() ;
     var b : long ; b := scan.getCurrent()->toLong() ;
     OclFile["System.out"].println(a + b) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long calculateSum(int n){
    long sum=0 ;
    sum=1<<n ;
    return(sum-1);
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println("Sum of all elements:"+calculateSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculateSum( n : int) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     sum := (1*(2->pow(n)))->oclAsType(long) ; 
     return (sum - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println("Sum of all elements:" + calculateSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long calculateSum(int n){
    long sum=0 ;
    for(int row=0 ; row<n ; row++){
      sum=sum+(1<<row);
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println("Sum of all elements:"+calculateSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculateSum( n : int) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var row : int ; row := 0 ; while row < n do ( (     sum := sum + ((1*(2->pow(row)))->oclAsType(long)) )  ;     row := row + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println("Sum of all elements:" + calculateSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxDiff(int arr[],int n){
    int diff=arr[1]-arr[0];
    int curr_sum=diff ;
    int max_sum=curr_sum ;
    for(int i=1 ; i<n-1 ; i++){
      diff=arr[i+1]-arr[i];
      if(curr_sum>0)curr_sum+=diff ;
      else curr_sum=diff ;
      if(curr_sum>max_sum)max_sum=curr_sum ;
    }
    return max_sum ;
  }
  public static void main(String[] args){
    int arr[]={
      80,2,6,3,100 };
      int n=arr.length ;
      System.out.print("Maximum difference is "+maxDiff(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxDiff( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var diff : int ; diff := arr[1+1] - arr[0+1] ;
     var curr_sum : int ; curr_sum := diff ;
    var max_sum : int ; max_sum := curr_sum ;
        var i : int ; i := 1 ; while i < n - 1 do ( (     diff := arr[i + 1+1] - arr[i+1] ; 
     if (curr_sum > 0) then     curr_sum := curr_sum+(diff) else     curr_sum := diff ; ;  
     if (curr_sum > max_sum) then     max_sum := curr_sum ; else skip )  ;     i := i + 1 ) ; 
    return max_sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{80,2,6,3,100} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print("Maximum difference is " + maxDiff(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean startsWith(String str,String pre){
    int strLen=str.length();
    int preLen=pre.length();
    int i=0,j=0 ;
    while(i<strLen && j<preLen){
      if(str.charAt(i)!=pre.charAt(j))return false ;
      i++;
      j++;
    }
    return true ;
  }
  static boolean endsWith(String str,String suff){
    int i=str.length()-1 ;
    int j=suff.length()-1 ;
    while(i>=0 && j>=0){
      if(str.charAt(i)!=suff.charAt(j))return false ;
      i--;
      j--;
    }
    return true ;
  }
  static boolean checkString(String str,String a,String b){
    if(str.length()!=a.length()+b.length())return false ;
    if(startsWith(str,a)){
      if(endsWith(str,b))return true ;
    }
    if(startsWith(str,b)){
      if(endsWith(str,a))return true ;
    }
    return false ;
  }
  public static void main(String args[]){
    String str="GeeksforGeeks" ;
    String a="Geeksfo" ;
    String b="rGeeks" ;
    if(checkString(str,a,b))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation startsWith( str : String, pre : String) : boolean
  pre: true
  post: true
  activity: (     var strLen : int ; strLen := str->size() ;
     var preLen : int ; preLen := pre->size() ;
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    while (i < strLen & j < preLen) do (     if (str->at(i+1) /= pre->at(j+1)) then     return false else skip ; 
     i := i + 1 ; 
     j := j + 1 ) ; 
    return true 
 );
  static   operation endsWith( str : String, suff : String) : boolean
  pre: true
  post: true
  activity: (     var i : int ; i := str->size() - 1 ;
     var j : int ; j := suff->size() - 1 ;
     while (i >= 0 & j >= 0) do (     if (str->at(i+1) /= suff->at(j+1)) then     return false else skip ; 
     i := i - 1 ; 
     j := j - 1 ) ; 
     return true );
  static   operation checkString( str : String, a : String, b : String) : boolean
  pre: true
  post: true
  activity: (     if (str->size() /= a->size() + b->size()) then     return false else skip ; 
     if (startsWith(str, a)) then (     if (endsWith(str, b)) then     return true else skip ) else skip ; 
     if (startsWith(str, b)) then (     if (endsWith(str, a)) then     return true else skip ) else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GeeksforGeeks" ;
     var a : String ; a := "Geeksfo" ;
     var b : String ; b := "rGeeks" ;
     if (checkString(str, a, b)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static String line ;
  static final int MOD=100000007 ;
  static long solve(int len,int loop){
    long ret=0 ;
    long[] dp=new long[len+1];
    dp[0]=1 ;
    for(int i=1 ; i<=len ; ++i){
      for(int j=1 ; j<=Math.min(loop,i); ++j){
        dp[i]+=dp[i-j];
      }
      dp[i] %=MOD ;
      if((len-i)% loop==0){
        ret+=dp[i];
        ret %=MOD ;
      }
    }
    return ret ;
  }
  static int solve(){
    long ans=1 ;
    int prev=0 ;
    for(int i=1 ; i<line.length(); ++i){
      if(line.charAt(i)!=line.charAt(i-1)){
        ans*=solve(i-prev,loop(line.charAt(prev)));
        ans %=MOD ;
        prev=i ;
      }
    }
    ans*=solve(line.length()-prev,loop(line.charAt(prev)));
    ans %=MOD ;
    return(int)ans ;
  }
  static int loop(char c){
    return c=='8' || c=='0' ? 3 : 5 ;
  }
  public static void main(String[] args)throws Exception {
    while(true){
      line=sc.next();
      if(line.equals("#"))break ;
      System.out.println(solve());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute line : String;
  static    attribute MOD : int := 100000007;
  static   operation solve( len : int, loop : int) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := 0 ;
     var dp : Sequence(long) ; dp := Integer.subrange(1,len + 1)->collect(0) ;
    dp[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= len do ( (         var j : int ; j := 1 ; while j <= Set{loop, i}->min() do ( (     dp[i+1] := dp[i+1]+(dp[i - j+1]) )  ;     j := j + 1 ) ; 
     dp[i+1] := dp[i+1] mod MOD ; 
     if ((len - i) mod loop = 0) then (     ret := ret+(dp[i+1]) ; 
     ret := ret mod MOD ) else skip )  ;     i := i + 1 ) ; 
    return ret 
 );
  static   operation solve() : int
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
     var prev : int ; prev := 0 ;
        var i : int ; i := 1 ; while i < line->size() do ( (     if (line->at(i+1) /= line->at(i - 1+1)) then (     ans := ans*(solve(i - prev, loop(line->at(prev+1)))) ; 
     ans := ans mod MOD ; 
     prev := i ) else skip )  ;     i := i + 1 ) ; 
    ans := ans*(solve(line->size() - prev, loop(line->at(prev+1)))) ; 
    ans := ans mod MOD ; 
    return ans->oclAsType(int) 
 );
  static   operation loop( c : String) : int
  pre: true
  post: true
  activity: (     return if c = '8' or c = '0' then 3 else 5 endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     line := sc.getCurrent() ; 
     if (line = "#") then     break else skip ; 
     OclFile["System.out"].println(solve()) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    long mod=100000007 ;
    for(; ; ){
      String s=sc.next();
      if(s.equals("#")){
        break ;
      }
      int pm=-1 ;
      long res=1 ;
      long[] dp={
        1 },dp2=null ;
        int n=1 ;
        s+="#" ;
        int k=0 ;
        for(char c : s.toCharArray()){
          int m=c-'0' ;
          if(m==pm){
            k++;
            for(int i=0 ; i<n ; i++){
              dp2[i]=dp[i];
            }
            fill(dp,0);
            for(int i=0 ; i<n ; i++){
              if(i==n-1){
                if(k % n==0)dp[0]+=1 ;
              }
              else {
                dp[i+1]+=dp2[i];
              }
              dp[0]+=dp2[i];
            }
            for(int i=0 ; i<n ; i++){
              dp[i] %=mod ;
            }
          }
          else {
            long mul=0 ;
            for(int i=0 ; i<n ; i++){
              mul+=dp[i];
            }
            res=res*mul % mod ;
            if(m==8 || m==0){
              n=3 ;
            }
            else {
              n=5 ;
            }
            dp=new long[n];
            dp2=new long[n];
            dp[0]=1 ;
            k=0 ;
          }
          pm=m ;
          if(c=='#'){
            break ;
          }
        }
        println(((int)res)+"");
      }
    }
    void println(String s){
      System.out.println(s);
    }
    public static void main(String[] args){
      new Main().run();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var mod : long ; mod := 100000007 ;
       while true do ( (     var s : String ; s := sc.getCurrent() ;
     if (s = "#") then (     break ) else skip ; 
    var pm : int ; pm := -1 ;
    var res : long ; res := 1 ;
    var dp : Sequence(long) ; dp := Sequence{1} ;
    var dp2 : Sequence(long) ; dp2 := null ;
    var n : int ; n := 1 ;
    s := s+("#") ; 
    var k : int ; k := 0 ;
    for (c : s->characters()) do ( (     var m : int ; m := c - ('0')->char2byte() ;
     if (m = pm) then (     k := k + 1 ; 
         var i : int ; i := 0 ; while i < n do ( (     dp2[i+1] := dp[i+1] )  ;     i := i + 1 ) ; 
    execute fill(dp, 0) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i = n - 1) then (     if (k mod n = 0) then     dp[0+1] := dp[0+1]+(1) ; else skip ) else (     dp[i + 1+1] := dp[i + 1+1]+(dp2[i+1]) ) ;  
     dp[0+1] := dp[0+1]+(dp2[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     dp[i+1] := dp[i+1] mod mod )  ;     i := i + 1 ) ; 
 ) else (     var mul : long ; mul := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     mul := mul+(dp[i+1]) )  ;     i := i + 1 ) ; 
    res := res * mul mod mod ; 
    if (m = 8 or m = 0) then (     n := 3 ) else (     n := 5 ) ;  
    dp := Integer.subrange(1,n)->collect(0) ; 
    dp2 := Integer.subrange(1,n)->collect(0) ; 
    dp[0+1] := 1 ; 
    k := 0 ; 
 ) ;  
     pm := m ; 
     if (c = '#') then (     break ) else skip )  ) ; 
    execute println((res->oclAsType(int)) + "") ; 
 )  ) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int countPairs(int n){
    int num=((n/2)+1);
    int max=n % num ;
    int count=0 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=n ; j++){
        int val=((n % i)% j)% n ;
        if(val==max)count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(countPairs(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countPairs( n : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := ((n / 2) + 1) ;
     var max : int ; max := n mod num ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     var val : int ; val := ((n mod i) mod j) mod n ;
     if (val = max) then     count := count + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(countPairs(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static char findExtraCharcter(char[] strA,char[] strB){
    int[] m1=new int[256];
    for(int i=0 ; i<strB.length ; i++)m1[strB[i] ]++;
    for(int i=0 ; i<strA.length ; i++)m1[strA[i] ]--;
    for(int i=0 ; i<m1.length ; i++){
      if(m1[i]==1)return(char)i ;
    }
    return Character.MIN_VALUE ;
  }
  public static void main(String[] args){
    String strA="abcd" ;
    String strB="cbdad" ;
    System.out.println(findExtraCharcter(strA.toCharArray(),strB.toCharArray()));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findExtraCharcter( strA : Sequence(String), strB : Sequence(String)) : String
  pre: true
  post: true
  activity: (     var m1 : Sequence(int) ; m1 := Integer.subrange(1,256)->collect(0) ;
         var i : int ; i := 0 ; while i < strB->size() do (     m1[strB[i+1]+1] := m1[strB[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < strA->size() do (     m1[strA[i+1]+1] := m1[strA[i+1]+1] - 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m1->size() do ( (     if (m1[i+1] = 1) then     return i->oclAsType(String) else skip )  ;     i := i + 1 ) ; 
    return "\u0000" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var strA : String ; strA := "abcd" ;
     var strB : String ; strB := "cbdad" ;
     OclFile["System.out"].println(findExtraCharcter(strA->characters(), strB->characters())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class IlyaAndQueries {
  static public Scanner sc=new Scanner(System.in);
  public static int[] calcMem(String s){
    int[] arr=new int[s.length()+1];
    for(int i=1 ; i<arr.length-1 ; i++){
      if(s.charAt(i-1)==s.charAt(i))arr[i]=arr[i-1]+1 ;
      else arr[i]=arr[i-1];
    }
    return arr ;
  }
  public static void main(String...args){
    String s=sc.next();
    int n=sc.nextInt();
    int[] arr=calcMem(s);
    while(n-->0){
      int Li=sc.nextInt(),Ri=sc.nextInt();
      int ans=arr[(Ri-1)]-arr[(Li-1)];
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class IlyaAndQueries {
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation calcMem( s : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,s->size() + 1)->collect(0) ;
         var i : int ; i := 1 ; while i < arr->size() - 1 do ( (     if (s->at(i - 1+1) = s->at(i+1)) then     arr[i+1] := arr[i - 1+1] + 1 ; else     arr[i+1] := arr[i - 1+1] ; )  ;     i := i + 1 ) ; 
     return arr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := sc.getCurrent() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := calcMem(s) ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var Li : int ; Li := sc.getCurrent()->toInteger() ;
    var Ri : int ; Ri := sc.getCurrent()->toInteger() ;
     var ans : int ; ans := arr[(Ri - 1)+1] - arr[(Li - 1)+1] ;
     OclFile["System.out"].println(ans) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf313b {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    int n=sc.nextInt();
    int[] dp=new int[str.length()];
    dp[0]=0 ;
    for(int i=1 ; i<str.length(); i++){
      int val=(str.charAt(i)==str.charAt(i-1))? 1 : 0 ;
      dp[i]=dp[i-1]+val ;
    }
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      System.out.println(dp[b-1]-dp[a-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf313b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,str->size())->collect(0) ;
    dp[0+1] := 0 ; 
        var i : int ; i := 1 ; while i < str->size() do ( (     var val : int ; val := if (str->at(i+1) = str->at(i - 1+1)) then 1 else 0 endif ;
     dp[i+1] := dp[i - 1+1] + val )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(dp[b - 1+1] - dp[a - 1+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      int m=scanner.nextInt();
      if((n | m)==0)break ;
      int[] pow3=new int[n+1];
      pow3[0]=1 ;
      for(int i=1 ; i<=n ; i++)pow3[i]=pow3[i-1]*3 ;
      int[] c=new int[n];
      for(int i=0 ; i<3 ; i++){
        int a=scanner.nextInt();
        for(int j=a ; j>0 ; j--){
          int k=scanner.nextInt();
          c[n-k]=i ;
        }
      }
      int p=0 ;
      int x=0 ;
      for(int i=n-1 ; i>=0 ; i--){
        int d=Math.abs(p-c[i]);
        x+=pow3[i]*d ;
        if(d==1)p=2-p ;
      }
      int y=pow3[n]-1-x ;
      if(x>y)x=y ;
      System.out.println(x>m ?-1 : x);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,m)) = 0) then     break else skip ; 
    var pow3 : Sequence(int) ; pow3 := Integer.subrange(1,n + 1)->collect(0) ;
    pow3[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do (     pow3[i+1] := pow3[i - 1+1] * 3 ;  ;     i := i + 1 ) ; 
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
         var j : int ; j := a ; while j > 0 do ( (     var k : int ; k := scanner.getCurrent()->toInteger() ;
     c[n - k+1] := i )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    var p : int ; p := 0 ;
    var x : int ; x := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     var d : int ; d := if p - c[i+1] < 0 then -(p - c[i+1]) else p - c[i+1] endif ;
     x := x+(pow3[i+1] * d) ; 
     if (d = 1) then     p := 2 - p ; else skip )  ;     i := i - 1 ) ; 
    var y : int ; y := pow3[n+1] - 1 - x ;
    if (x > y) then     x := y ; else skip ; 
    OclFile["System.out"].println(if x > m then -1 else x endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      int m=scanner.nextInt();
      if((n | m)==0)break ;
      int[] pow3=new int[n+1];
      pow3[0]=1 ;
      for(int i=1 ; i<=n ; i++)pow3[i]=pow3[i-1]*3 ;
      int[] c=new int[n];
      for(int i=0 ; i<3 ; i++){
        int a=scanner.nextInt();
        for(int j=a ; j>0 ; j--){
          int b=scanner.nextInt();
          c[n-b]=i ;
        }
      }
      int p=0 ;
      int x=0 ;
      for(int i=0 ; i<n ; i++){
        int d=Math.abs(p-c[i]);
        x+=pow3[i]*d ;
        if(d==1)p=2-p ;
      }
      int y=pow3[n]-x-1 ;
      x=Math.min(x,y);
      System.out.println(x>m ?-1 : x);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,m)) = 0) then     break else skip ; 
    var pow3 : Sequence(int) ; pow3 := Integer.subrange(1,n + 1)->collect(0) ;
    pow3[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do (     pow3[i+1] := pow3[i - 1+1] * 3 ;  ;     i := i + 1 ) ; 
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
         var j : int ; j := a ; while j > 0 do ( (     var b : int ; b := scanner.getCurrent()->toInteger() ;
     c[n - b+1] := i )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    var p : int ; p := 0 ;
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var d : int ; d := if p - c[i+1] < 0 then -(p - c[i+1]) else p - c[i+1] endif ;
     x := x+(pow3[i+1] * d) ; 
     if (d = 1) then     p := 2 - p ; else skip )  ;     i := i + 1 ) ; 
    var y : int ; y := pow3[n+1] - x - 1 ;
    x := Set{x, y}->min() ; 
    OclFile["System.out"].println(if x > m then -1 else x endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n,m ;
    int[] A=new int[100];
    int[] C=new int[100];
    int[] P=new int[100];
    int[] F=new int[100];
    while(true){
      n=in.nextInt();
      m=in.nextInt();
      if(n==0 && m==0)break ;
      for(int i=0 ; i<3 ; i++){
        int ph ;
        ph=in.nextInt();
        for(int j=0 ; j<ph ; j++){
          int in2 ;
          in2=in.nextInt();
          F[in2]=i ;
        }
      }
      P[n]=2 ;
      A[n]=F[n];
      C[n]=2-F[n];
      for(int i=n ; i>1 ; i--){
        P[i-1]=3*P[i]+2 ;
        if(F[i-1]==0){
          A[i-1]=A[i];
          C[i-1]=C[i]+2*P[i]+2 ;
        }
        else if(F[i-1]==1){
          A[i-1]=C[i]+P[i]+1 ;
          C[i-1]=A[i]+P[i]+1 ;
        }
        else if(F[i-1]==2){
          A[i-1]=A[i]+2*P[i]+2 ;
          C[i-1]=C[i];
        }
      }
      int ans=Math.min(A[1],C[1]);
      if(m<ans)System.out.println("-1");
      else System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var m : int ;
    var A : Sequence(int) ; A := Integer.subrange(1,100)->collect(0) ;
    var C : Sequence(int) ; C := Integer.subrange(1,100)->collect(0) ;
    var P : Sequence(int) ; P := Integer.subrange(1,100)->collect(0) ;
    var F : Sequence(int) ; F := Integer.subrange(1,100)->collect(0) ;
    while (true) do (     n := in.getCurrent()->toInteger() ; 
     m := in.getCurrent()->toInteger() ; 
    if (n = 0 & m = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < 3 do ( (     var ph : int ;
     ph := in.getCurrent()->toInteger() ; 
         var j : int ; j := 0 ; while j < ph do ( (     var in2 : int ;
     in2 := in.getCurrent()->toInteger() ; 
     F[in2+1] := i )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    P[n+1] := 2 ; 
    A[n+1] := F[n+1] ; 
    C[n+1] := 2 - F[n+1] ; 
        var i : int ; i := n ; while i > 1 do ( (     P[i - 1+1] := 3 * P[i+1] + 2 ; 
     if (F[i - 1+1] = 0) then (     A[i - 1+1] := A[i+1] ; 
     C[i - 1+1] := C[i+1] + 2 * P[i+1] + 2 ) else     if (F[i - 1+1] = 1) then (     A[i - 1+1] := C[i+1] + P[i+1] + 1 ; 
     C[i - 1+1] := A[i+1] + P[i+1] + 1 ) else     if (F[i - 1+1] = 2) then (     A[i - 1+1] := A[i+1] + 2 * P[i+1] + 2 ; 
     C[i - 1+1] := C[i+1] ) else skip ; ;  )  ;     i := i - 1 ) ; 
    var ans : int ; ans := Set{A[1+1], C[1+1]}->min() ;
    if (m < ans) then     OclFile["System.out"].println("-1") else     OclFile["System.out"].println(ans) ; ;  
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countIntegralSolutions(int n){
    int result=0 ;
    for(int i=0 ; i<=n ; i++)for(int j=0 ; j<=n-i ; j++)for(int k=0 ; k<=(n-i-j); k++)if(i+j+k==n)result++;
    return result ;
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(countIntegralSolutions(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countIntegralSolutions( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i <= n do (         var j : int ; j := 0 ; while j <= n - i do (         var k : int ; k := 0 ; while k <= (n - i - j) do (     if (i + j + k = n) then     result := result + 1 ; else skip ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(countIntegralSolutions(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int[] pow3=new int[16],c=new int[16];
    int n,m,i,j,k,d,x,y,p ;
    pow3[0]=1 ;
    for(i=1 ; i<=15 ; ++i){
      pow3[i]=pow3[i-1]*3 ;
    }
    while(true){
      n=in.nextInt();
      m=in.nextInt();
      if(n==0 && m==0)break ;
      for(i=0 ; i<3 ; i++){
        for(j=in.nextInt(); j>0 ; --j){
          k=in.nextInt();
          c[n-k]=i ;
        }
      }
      p=0 ;
      x=0 ;
      for(i=n-1 ; i>=0 ; --i){
        d=Math.abs(p-c[i]);
        x+=pow3[i]*d ;
        if(d==1)p=2-p ;
      }
      y=pow3[n]-1-x ;
      if(x>y)x=y ;
      if(m<x)System.out.println("-1");
      else System.out.println(x);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pow3 : Sequence(int) ; pow3 := Integer.subrange(1,16)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,16)->collect(0) ;
    var n : int ;
    var m : int ;
    var i : int ;
    var j : int ;
    var k : int ;
    var d : int ;
    var x : int ;
    var y : int ;
    var p : int ;
    pow3[0+1] := 1 ; 
        i := 1 ; while i <= 15 do ( (     pow3[i+1] := pow3[i - 1+1] * 3 )  ;     i := i + 1 ) ; 
    while (true) do (     n := in.getCurrent()->toInteger() ; 
     m := in.getCurrent()->toInteger() ; 
    if (n = 0 & m = 0) then     break else skip ; 
        i := 0 ; while i < 3 do ( (         j := in.getCurrent()->toInteger() ; while j > 0 do ( (     k := in.getCurrent()->toInteger() ; 
     c[n - k+1] := i )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    p := 0 ; 
    x := 0 ; 
        i := n - 1 ; while i >= 0 do ( (     d := if p - c[i+1] < 0 then -(p - c[i+1]) else p - c[i+1] endif ; 
     x := x+(pow3[i+1] * d) ; 
     if (d = 1) then     p := 2 - p ; else skip )  ;     i := i - 1 ) ; 
    y := pow3[n+1] - 1 - x ; 
    if (x > y) then     x := y ; else skip ; 
    if (m < x) then     OclFile["System.out"].println("-1") else     OclFile["System.out"].println(x) ; ;  
 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=100000 ;
  static void print(int g1[],int a,int g2[],int b){
    for(int i=0 ; i<a ; i++){
      System.out.print(g1[i]+" ");
    }
    System.out.print("and ");
    for(int i=0 ; i<b ; i++){
      System.out.print(g2[i]+" ");
    }
    System.out.println();
  }
  static boolean checksum(int g1[],int a,int g2[],int b){
    int i,x ;
    for(i=0,x=0 ; i<a ; i++){
      x+=g1[i];
    }
    for(i=0 ; i<b ; i++){
      x-=g2[i];
    }
    return(x==0);
  }
  static void formgroups(int arr[],int x,int g1[],int a,int g2[],int b,int n){
    if(x==n){
      if(checksum(g1,a,g2,b)){
        print(g1,a,g2,b);
      }
      return ;
    }
    g1[a]=arr[x];
    formgroups(arr,x+1,g1,a+1,g2,b,n);
    g2[b]=arr[x];
    formgroups(arr,x+1,g1,a,g2,b+1,n);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,9,4,5 };
      int n=arr.length ;
      int[] g1=new int[MAX];
      int[] g2=new int[MAX];
      formgroups(arr,0,g1,0,g2,0,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100000;
  static   operation print( g1 : Sequence(int), a : int, g2 : Sequence(int), b : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < a do ( (     OclFile["System.out"].print(g1[i+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("and ") ; 
         var i : int ; i := 0 ; while i < b do ( (     OclFile["System.out"].print(g2[i+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation checksum( g1 : Sequence(int), a : int, g2 : Sequence(int), b : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ;
    var x : int ;
         i := 0 ;     x := 0 ; while i < a do ( (     x := x+(g1[i+1]) )  ;     i := i + 1 ) ; 
         i := 0 ; while i < b do ( (     x := x-(g2[i+1]) )  ;     i := i + 1 ) ; 
     return (x = 0) );
  static   operation formgroups( arr : Sequence(int), x : int, g1 : Sequence(int), a : int, g2 : Sequence(int), b : int, n : int) : void
  pre: true
  post: true
  activity: (     if (x = n) then (     if (checksum(g1, a, g2, b)) then (     execute print(g1, a, g2, b) ) else skip ; 
     return ) else skip ; 
     g1[a+1] := arr[x+1] ; 
    execute formgroups(arr, x + 1, g1, a + 1, g2, b, n) ; 
    g2[b+1] := arr[x+1] ; 
    execute formgroups(arr, x + 1, g1, a, g2, b + 1, n) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,9,4,5} ;
     var n : int ; n := arr->size() ;
    var g1 : Sequence(int) ; g1 := Integer.subrange(1,MAX)->collect(0) ;
    var g2 : Sequence(int) ; g2 := Integer.subrange(1,MAX)->collect(0) ;
    execute formgroups(arr, 0, g1, 0, g2, 0, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class a {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] a=new int[3];
    a[0]=in.nextInt();
    a[1]=in.nextInt();
    a[2]=in.nextInt();
    Arrays.sort(a);
    int max=0 ;
    int d[]=new int[n+1];
    Arrays.fill(d,-500);
    d[0]=0 ;
    for(int i=0 ; i<=n ; i++)for(int j=0 ; j<3 ; j++)if(i-a[j]>=0 && d[i-a[j] ]!=-1)d[i]=Math.max(d[i],d[i-a[j] ]+1);
    System.out.println(d[n]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
    a[0+1] := in.getCurrent()->toInteger() ; 
    a[1+1] := in.getCurrent()->toInteger() ; 
    a[2+1] := in.getCurrent()->toInteger() ; 
    a := a->sort() ; 
    var max : int ; max := 0 ;
    var d : Sequence(int) ; d := Integer.subrange(1,n + 1)->collect(0) ;
    d := d->collect(-500) ; 
    d[0+1] := 0 ; 
        var i : int ; i := 0 ; while i <= n do (         var j : int ; j := 0 ; while j < 3 do (     if (i - a[j+1] >= 0 & d[i - a[j+1]+1] /= -1) then     d[i+1] := Set{d[i+1], d[i - a[j+1]+1] + 1}->max() ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(d[n+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.awt.geom.Point2D ;
import java.awt.geom.Point2D.Double ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
import java.util.TreeSet ;
import java.lang.Object ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new aoj1216().doIt();
  }
  class aoj1216 {
    int a[]=new int[101];
    int b[]=new int[101];
    void doIt(){
      for(int i=0 ; i<101 ; i++)a[i]=i*i*i ;
      for(int i=0 ; i<101 ; i++)b[i]=i*(i+1)*(i+2)/6 ;
      while(true){
        int n=sc.nextInt();
        if(n==0)break ;
        int num=0 ;
        for(int i=0 ; i<101 ; i++){
          for(int j=0 ; j<101 ; j++){
            if(a[i]+b[j]<=n)num=Math.max(num,a[i]+b[j]);
          }
        }
        System.out.println(num);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     aoj1216.newaoj1216().doIt() );
 class aoj1216 {
   attribute a : int := Integer.subrange(1,101)->collect(0);
   attribute b : int := Integer.subrange(1,101)->collect(0);
   operation doIt() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 101 do (     a[i+1] := i * i * i ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < 101 do (     b[i+1] := i * (i + 1) * (i + 2) / 6 ;  ;     i := i + 1 ) ; 
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var num : int ; num := 0 ;
        var i : int ; i := 0 ; while i < 101 do ( (         var j : int ; j := 0 ; while j < 101 do ( (     if (a[i+1] + b[j+1] <= n) then     num := Set{num, a[i+1] + b[j+1]}->max() ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(num) ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class demo1 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int maxn=4010 ;
    int a=scanner.nextInt();
    int b=scanner.nextInt();
    int c=scanner.nextInt();
    int[] arr={
      a,b,c };
      int[] dp=new int[maxn];
      for(int i=0 ; i<n ; i++){
        dp[i]=Integer.MIN_VALUE ;
      }
      dp[0]=0 ;
      for(int i=0 ; i<3 ; i++){
        for(int j=arr[i]; j<dp.length ; j++){
          dp[j]=Math.max(dp[j],dp[j-arr[i] ]+1);
        }
      }
      System.out.println(dp[n]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class demo1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var maxn : int ; maxn := 4010 ;
    var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Sequence{a,b,c} ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,maxn)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     dp[i+1] := -2147483648 )  ;     i := i + 1 ) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := arr[i+1] ; while j < dp->size() do ( (     dp[j+1] := Set{dp[j+1], dp[j - arr[i+1]+1] + 1}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[n+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class a {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] a=new int[3];
    a[0]=in.nextInt();
    a[1]=in.nextInt();
    a[2]=in.nextInt();
    Arrays.sort(a);
    int max=0 ;
    int d[]=new int[n+1];
    Arrays.fill(d,-1);
    d[0]=0 ;
    for(int i=0 ; i<=n ; i++)for(int j=0 ; j<3 ; j++)if(i-a[j]>=0 && d[i-a[j] ]!=-1)d[i]=Math.max(d[i],d[i-a[j] ]+1);
    System.out.println(d[n]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
    a[0+1] := in.getCurrent()->toInteger() ; 
    a[1+1] := in.getCurrent()->toInteger() ; 
    a[2+1] := in.getCurrent()->toInteger() ; 
    a := a->sort() ; 
    var max : int ; max := 0 ;
    var d : Sequence(int) ; d := Integer.subrange(1,n + 1)->collect(0) ;
    d := d->collect(-1) ; 
    d[0+1] := 0 ; 
        var i : int ; i := 0 ; while i <= n do (         var j : int ; j := 0 ; while j < 3 do (     if (i - a[j+1] >= 0 & d[i - a[j+1]+1] /= -1) then     d[i+1] := Set{d[i+1], d[i - a[j+1]+1] + 1}->max() ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(d[n+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  static int dp[];
  public static int sol(int a,int b,int c,int n){
    if(n==0){
      return 0 ;
    }
    if(n<0){
      return-1000000 ;
    }
    if(dp[n]!=0){
      return dp[n];
    }
    int x=1+sol(a,b,c,n-a);
    x=Math.max(x,1+sol(a,b,c,n-b));
    x=Math.max(x,1+sol(a,b,c,n-c));
    return dp[n]=x ;
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=1 ;
    int v=0 ;
    while(t-->0){
      v++;
      int n=s.nextInt();
      dp=new int[n+5];
      int a=s.nextInt();
      int b=s.nextInt();
      int c=s.nextInt();
      int ans=sol(a,b,c,n);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute dp : Sequence(int);
  static   operation sol( a : int, b : int, c : int, n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then (     return 0 ) else skip ; 
     if (n < 0) then (     return -1000000 ) else skip ; 
    if (dp[n+1] /= 0) then (     return dp[n+1] ) else skip ; 
    var x : int ; x := 1 + sol(a, b, c, n - a) ;
    x := Set{x, 1 + sol(a, b, c, n - b)}->max() ; 
    x := Set{x, 1 + sol(a, b, c, n - c)}->max() ; 
    return dp[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
     var v : int ; v := 0 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     v := v + 1 ; 
     var n : int ; n := s.getCurrent()->toInteger() ;
    dp := Integer.subrange(1,n + 5)->collect(0) ; 
    var a : int ; a := s.getCurrent()->toInteger() ;
    var b : int ; b := s.getCurrent()->toInteger() ;
    var c : int ; c := s.getCurrent()->toInteger() ;
    var ans : int ; ans := sol(a, b, c, n) ;
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int maxSubseq(int[] vec,int n){
    int suffix=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(vec[i]==1){
        suffix++;
        vec[i]=suffix ;
      }
    }
    int res=0 ;
    int zero=0 ;
    for(int i=0 ; i<n ; i++){
      if(vec[i]==0)zero++;
      if(vec[i]>0)res=Math.max(res,zero+vec[i]);
    }
    return Math.max(res,zero);
  }
  static public void main(String[] args){
    int[] input={
      0,1,0,0,1,0 };
      int n=input.length ;
      System.out.println(maxSubseq(input,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSubseq( vec : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var suffix : int ; suffix := 0 ;
         var i : int ; i := n - 1 ; while i >= 0 do ( (     if (vec[i+1] = 1) then (     suffix := suffix + 1 ; 
     vec[i+1] := suffix ) else skip )  ;     i := i - 1 ) ; 
    var res : int ; res := 0 ;
    var zero : int ; zero := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (vec[i+1] = 0) then     zero := zero + 1 ; else skip ; 
     if (vec[i+1] > 0) then     res := Set{res, zero + vec[i+1]}->max() ; else skip )  ;     i := i + 1 ) ; 
    return Set{res, zero}->max() 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : Sequence(int) ; input := Sequence{0,1,0,0,1,0} ;
     var n : int ; n := input->size() ;
     OclFile["System.out"].println(maxSubseq(input, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int R=4 ;
  static int C=4 ;
  static int countPaths(int maze[][]){
    if(maze[0][0]==-1)return 0 ;
    for(int i=0 ; i<R ; i++){
      if(maze[i][0]==0)maze[i][0]=1 ;
      else break ;
    }
    for(int i=1 ; i<C ; i++){
      if(maze[0][i]==0)maze[0][i]=1 ;
      else break ;
    }
    for(int i=1 ; i<R ; i++){
      for(int j=1 ; j<C ; j++){
        if(maze[i][j]==-1)continue ;
        if(maze[i-1][j]>0)maze[i][j]=(maze[i][j]+maze[i-1][j]);
        if(maze[i][j-1]>0)maze[i][j]=(maze[i][j]+maze[i][j-1]);
      }
    }
    return(maze[R-1][C-1]>0)? maze[R-1][C-1] : 0 ;
  }
  public static void main(String[] args){
    int maze[][]={
      {
        0,0,0,0 },{
          0,-1,0,0 },{
-1,0,0,0 },{
              0,0,0,0 }
            };
            System.out.println(countPaths(maze));
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute R : int := 4;
  static   attribute C : int := 4;
  static   operation countPaths( maze : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     if (maze[0+1][0+1] = -1) then     return 0 else skip ; 
         var i : int ; i := 0 ; while i < R do ( (     if (maze[i+1][0+1] = 0) then     maze[i+1][0+1] := 1 ; else     break )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < C do ( (     if (maze[0+1][i+1] = 0) then     maze[0+1][i+1] := 1 ; else     break )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < R do ( (         var j : int ; j := 1 ; while j < C do ( (     if (maze[i+1][j+1] = -1) then     continue else skip ; 
     if (maze[i - 1+1][j+1] > 0) then     maze[i+1][j+1] := (maze[i+1][j+1] + maze[i - 1+1][j+1]) ; else skip ; 
     if (maze[i+1][j - 1+1] > 0) then     maze[i+1][j+1] := (maze[i+1][j+1] + maze[i+1][j - 1+1]) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return if (maze[R - 1+1][C - 1+1] > 0) then maze[R - 1+1][C - 1+1] else 0 endif 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var maze : Sequence(Sequence(int)) ; maze := Sequence{Sequence{0,0,0,0},Sequence{0,-1,0,0},Sequence{-1,0,0,0},Sequence{0,0,0,0}} ;
     OclFile["System.out"].println(countPaths(maze)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void isPrime(int N){
    boolean isPrime=true ;
    int[] arr={
      7,11,13,17,19,23,29,31 };
      if(N<2){
        isPrime=false ;
      }
      if(N % 2==0 || N % 3==0 || N % 5==0){
        isPrime=false ;
      }
      for(int i=0 ; i<Math.sqrt(N); i+=30){
        for(int c : arr){
          if(c>Math.sqrt(N)){
            break ;
          }
          else {
            if(N %(c+i)==0){
              isPrime=false ;
              break ;
            }
          }
          if(! isPrime)break ;
        }
      }
      if(isPrime)System.out.println("Prime Number");
      else System.out.println("Not a Prime Number");
    }
    public static void main(String args[]){
      int N=121 ;
      isPrime(N);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPrime( N : int) : void
  pre: true
  post: true
  activity: (     var isPrime : boolean ; isPrime := true ;
     var arr : Sequence(int) ; arr := Sequence{7,11,13,17,19,23,29,31} ;
    if (N < 2) then (     isPrime := false ) else skip ; 
    if (N mod 2 = 0 or N mod 3 = 0 or N mod 5 = 0) then (     isPrime := false ) else skip ; 
        var i : int ; i := 0 ; while i < (N)->sqrt() do ( (     for (c : arr) do ( (     if (c > (N)->sqrt()) then (     break ) else (     if (N mod (c + i) = 0) then (     isPrime := false ; 
     break ) else skip ) ;  
     if (not(isPrime)) then     break else skip )  ) )  ;     i := i+(30) ) ; 
    if (isPrime) then     OclFile["System.out"].println("Prime Number") else     OclFile["System.out"].println("Not a Prime Number") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 121 ;
     execute isPrime(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int x1=scan.nextInt();
    int y1=scan.nextInt();
    int x2=scan.nextInt();
    int y2=scan.nextInt();
    int x3=x2+(y1-y2);
    int y3=y2-(x1-x2);
    int x4=x1-(y2-y1);
    int y4=y1+(x2-x1);
    System.out.println(x3+" "+y3+" "+x4+" "+y4);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : int ; x1 := scan.getCurrent()->toInteger() ;
    var y1 : int ; y1 := scan.getCurrent()->toInteger() ;
    var x2 : int ; x2 := scan.getCurrent()->toInteger() ;
    var y2 : int ; y2 := scan.getCurrent()->toInteger() ;
    var x3 : int ; x3 := x2 + (y1 - y2) ;
    var y3 : int ; y3 := y2 - (x1 - x2) ;
    var x4 : int ; x4 := x1 - (y2 - y1) ;
    var y4 : int ; y4 := y1 + (x2 - x1) ;
    OclFile["System.out"].println(x3 + " " + y3 + " " + x4 + " " + y4) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printCombination(int n){
    for(int i=1 ; i<n ; i++){
      if(i % 3!=0){
        for(int j=1 ; j<n ; j++){
          if(j % 3!=0){
            for(int k=1 ; k<n ; k++){
              if(k % 3!=0 &&(i+j+k)==n){
                System.out.println(i+" "+j+" "+k);
                return ;
              }
            }
          }
        }
      }
    }
  }
  public static void main(String[] args){
    int n=233 ;
    printCombination(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printCombination( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < n do ( (     if (i mod 3 /= 0) then (         var j : int ; j := 1 ; while j < n do ( (     if (j mod 3 /= 0) then (         var k : int ; k := 1 ; while k < n do ( (     if (k mod 3 /= 0 & (i + j + k) = n) then (     OclFile["System.out"].println(i + " " + j + " " + k) ; 
     return ) else skip )  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 233 ;
     execute printCombination(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().solveB();
  }
  private void solveA(){
    Scanner scanner=null ;
    int numK=0 ;
    int eqaC=0 ;
    int oddC=0 ;
    try {
      scanner=new Scanner(System.in);
      numK=scanner.nextInt();
      for(int i=1 ; i<=numK ; i++){
        if(i % 2==0){
          eqaC++;
        }
        else {
          oddC++;
        }
      }
      System.out.println(eqaC*oddC);
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
  private void solveB(){
    Scanner scanner=null ;
    int x1=0 ;
    int y1=0 ;
    int x2=0 ;
    int y2=0 ;
    try {
      scanner=new Scanner(System.in);
      x1=scanner.nextInt();
      y1=scanner.nextInt();
      x2=scanner.nextInt();
      y2=scanner.nextInt();
      int x3=x2-(y2-y1);
      int y3=y2+(x2-x1);
      int x4=x3-(y3-y2);
      int y4=y3+(x3-x2);
      System.out.println(x3+" "+y3+" "+x4+" "+y4);
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
  private void solveC(){
    Scanner scanner=null ;
    int numN=0 ;
    int numK=0 ;
    int numS=0 ;
    try {
      scanner=new Scanner(System.in);
      numN=scanner.nextInt();
      System.out.println("");
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
  private void solveD(){
    Scanner scanner=null ;
    int numN=0 ;
    int numK=0 ;
    int numS=0 ;
    try {
      scanner=new Scanner(System.in);
      numN=scanner.nextInt();
      System.out.println("");
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solveB() );
   operation solveA() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var numK : int ; numK := 0 ;
    var eqaC : int ; eqaC := 0 ;
    var oddC : int ; oddC := 0 ;
    try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     numK := scanner.getCurrent()->toInteger() ; 
         var i : int ; i := 1 ; while i <= numK do ( (     if (i mod 2 = 0) then (     eqaC := eqaC + 1 ) else (     oddC := oddC + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(eqaC * oddC) )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
   operation solveB() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var x1 : int ; x1 := 0 ;
    var y1 : int ; y1 := 0 ;
    var x2 : int ; x2 := 0 ;
    var y2 : int ; y2 := 0 ;
    try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     x1 := scanner.getCurrent()->toInteger() ; 
    y1 := scanner.getCurrent()->toInteger() ; 
    x2 := scanner.getCurrent()->toInteger() ; 
    y2 := scanner.getCurrent()->toInteger() ; 
    var x3 : int ; x3 := x2 - (y2 - y1) ;
    var y3 : int ; y3 := y2 + (x2 - x1) ;
    var x4 : int ; x4 := x3 - (y3 - y2) ;
    var y4 : int ; y4 := y3 + (x3 - x2) ;
    OclFile["System.out"].println(x3 + " " + y3 + " " + x4 + " " + y4) ; 
 )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
   operation solveC() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var numN : int ; numN := 0 ;
    var numK : int ; numK := 0 ;
    var numS : int ; numS := 0 ;
    try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     numN := scanner.getCurrent()->toInteger() ; 
     OclFile["System.out"].println("") )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
   operation solveD() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var numN : int ; numN := 0 ;
    var numK : int ; numK := 0 ;
    var numS : int ; numS := 0 ;
    try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     numN := scanner.getCurrent()->toInteger() ; 
     OclFile["System.out"].println("") )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ABC_108_B solver=new ABC_108_B();
    solver.solve(1,in,out);
    out.close();
  }
  static class ABC_108_B {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int x1=in.nextInt();
      int y1=in.nextInt();
      int x2=in.nextInt();
      int y2=in.nextInt();
      int x3,x4,y3,y4 ;
      int distX=x2-x1 ;
      int distY=y2-y1 ;
      x3=x2-distY ;
      y3=y2+distX ;
      x4=x3-distX ;
      y4=y3-distY ;
      out.print(x3+" "+y3+" "+x4+" "+y4);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ABCsolver08_B ; solver := ABCABCsolver08_B.newABCsolver08_B()08_B.newABCABCsolver08_B.newABCsolver08_B()08_B() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ABC_108_B {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var x1 : int ; x1 := in.getCurrent()->toInteger() ;
     var y1 : int ; y1 := in.getCurrent()->toInteger() ;
    var x2 : int ; x2 := in.getCurrent()->toInteger() ;
    var y2 : int ; y2 := in.getCurrent()->toInteger() ;
    var x3 : int ;
    var x4 : int ;
    var y3 : int ;
    var y4 : int ;
    var distX : int ; distX := x2 - x1 ;
    var distY : int ; distY := y2 - y1 ;
    x3 := x2 - distY ; 
    y3 := y2 + distX ; 
    x4 := x3 - distX ; 
    y4 := y3 - distY ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static int[] revpos(int[] p,int[] q){
    int[] vec={
      0,0 };
      for(int i=0 ; i<vec.length ; i++){
        vec[i]=p[i]-q[i];
      }
      int tmp=0 ;
      tmp=vec[0];
      vec[0]=vec[1];
      vec[1]=-tmp ;
      int[] newpos={
        0,0 };
        for(int i=0 ; i<newpos.length ; i++){
          newpos[i]=q[i]+vec[i];
        }
        return newpos ;
      }
      public static void main(String[] args){
        Scanner scan=new Scanner(System.in);
        int[] input={
          0,0,0,0 };
          for(int i=0 ; i<input.length ; i++){
            input[i]=scan.nextInt();
          }
          scan.close();
          int[][] position={
            {
              0,0 },{
                0,0 },{
                  0,0 },{
                    0,0 }
                  };
                  position[0][0]=input[0];
                  position[0][1]=input[1];
                  position[1][0]=input[2];
                  position[1][1]=input[3];
                  position[2]=revpos(position[0],position[1]);
                  position[3]=revpos(position[1],position[2]);
                  if(position[0]==revpos(position[2],position[3])){
                    System.out.println("OK");
                  }
                  int[] output={
                    0,0,0,0 };
                    output[0]=position[2][0];
                    output[1]=position[2][1];
                    output[2]=position[3][0];
                    output[3]=position[3][1];
                    for(int i : output){
                      System.out.println(i);
                    }
                  }
                }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation revpos( p : Sequence(int), q : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var vec : Sequence(int) ; vec := Sequence{0,0} ;
         var i : int ; i := 0 ; while i < vec->size() do ( (     vec[i+1] := p[i+1] - q[i+1] )  ;     i := i + 1 ) ; 
    var tmp : int ; tmp := 0 ;
    tmp := vec[0+1] ; 
    vec[0+1] := vec[1+1] ; 
    vec[1+1] := -tmp ; 
    var newpos : Sequence(int) ; newpos := Sequence{0,0} ;
        var i : int ; i := 0 ; while i < newpos->size() do ( (     newpos[i+1] := q[i+1] + vec[i+1] )  ;     i := i + 1 ) ; 
    return newpos 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : Sequence(int) ; input := Sequence{0,0,0,0} ;
        var i : int ; i := 0 ; while i < input->size() do ( (     input[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var position : Sequence(Sequence(int)) ; position := Sequence{Sequence{0,0},Sequence{0,0},Sequence{0,0},Sequence{0,0}} ;
    position[0+1][0+1] := input[0+1] ; 
    position[0+1][1+1] := input[1+1] ; 
    position[1+1][0+1] := input[2+1] ; 
    position[1+1][1+1] := input[3+1] ; 
    position[2+1] := revpos(position[0+1], position[1+1]) ; 
    position[3+1] := revpos(position[1+1], position[2+1]) ; 
    if (position[0+1] = revpos(position[2+1], position[3+1])) then (     OclFile["System.out"].println("OK") ) else skip ; 
    var output : Sequence(int) ; output := Sequence{0,0,0,0} ;
    output[0+1] := position[2+1][0+1] ; 
    output[1+1] := position[2+1][1+1] ; 
    output[2+1] := position[3+1][0+1] ; 
    output[3+1] := position[3+1][1+1] ; 
    for (i : output) do ( (     OclFile["System.out"].println(i) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x1=sc.nextInt();
    int y1=sc.nextInt();
    int x2=sc.nextInt();
    int y2=sc.nextInt();
    double x3=x2+((x1-x2)*Math.cos(-Math.PI/2)-(y1-y2)*Math.sin(-Math.PI/2));
    double y3=y2+((x1-x2)*Math.sin(-Math.PI/2)+(y1-y2)*Math.cos(-Math.PI/2));
    double x4=x1+((x2-x1)*Math.cos(Math.PI/2)-(y2-y1)*Math.sin(Math.PI/2));
    double y4=y1+((x2-x1)*Math.sin(Math.PI/2)+(y2-y1)*Math.cos(Math.PI/2));
    System.out.println((int)Math.rint(x3)+" "+(int)Math.rint(y3)+" "+(int)Math.rint(x4)+" "+(int)Math.rint(y4));
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : int ; x1 := sc.getCurrent()->toInteger() ;
    var y1 : int ; y1 := sc.getCurrent()->toInteger() ;
    var x2 : int ; x2 := sc.getCurrent()->toInteger() ;
    var y2 : int ; y2 := sc.getCurrent()->toInteger() ;
    var x3 : double ; x3 := x2 + ((x1 - x2) * (-3.141592653589793 / 2)->cos() - (y1 - y2) * (-3.141592653589793 / 2)->sin()) ;
    var y3 : double ; y3 := y2 + ((x1 - x2) * (-3.141592653589793 / 2)->sin() + (y1 - y2) * (-3.141592653589793 / 2)->cos()) ;
    var x4 : double ; x4 := x1 + ((x2 - x1) * (3.141592653589793 / 2)->cos() - (y2 - y1) * (3.141592653589793 / 2)->sin()) ;
    var y4 : double ; y4 := y1 + ((x2 - x1) * (3.141592653589793 / 2)->sin() + (y2 - y1) * (3.141592653589793 / 2)->cos()) ;
    OclFile["System.out"].println((1.0*((x3)->round()))->oclAsType(int) + " " + (1.0*((y3)->round()))->oclAsType(int) + " " + (1.0*((x4)->round()))->oclAsType(int) + " " + (1.0*((y4)->round()))->oclAsType(int)) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int max(int x,int y){
    return(x>y)? x : y ;
  }
  static int lps(char seq[],int i,int j){
    if(i==j){
      return 1 ;
    }
    if(seq[i]==seq[j] && i+1==j){
      return 2 ;
    }
    if(seq[i]==seq[j]){
      return lps(seq,i+1,j-1)+2 ;
    }
    return max(lps(seq,i,j-1),lps(seq,i+1,j));
  }
  public static void main(String[] args){
    String seq="GEEKSFORGEEKS" ;
    int n=seq.length();
    System.out.printf("The length of the LPS is %d",lps(seq.toCharArray(),0,n-1));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation max( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return if (x > y) then x else y endif );
  static   operation lps( seq : Sequence(String), i : int, j : int) : int
  pre: true
  post: true
  activity: (     if (i = j) then (     return 1 ) else skip ; 
     if (seq[i+1] = seq[j+1] & i + 1 = j) then (     return 2 ) else skip ; 
     if (seq[i+1] = seq[j+1]) then (     return lps(seq, i + 1, j - 1) + 2 ) else skip ; 
     return Set{lps(seq, i, j - 1), lps(seq, i + 1, j)}->max() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var seq : String ; seq := "GEEKSFORGEEKS" ;
     var n : int ; n := seq->size() ;
     OclFile["System.out"].printf("The length of the LPS is %d", lps(seq->characters(), 0, (n)->char2byte() - 1)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findLength(String str,int n){
    int ans=0 ;
    for(int i=0 ; i<=n-2 ; i++){
      int l=i,r=i+1 ;
      int lsum=0,rsum=0 ;
      while(r<n && l>=0){
        lsum+=str.charAt(l)-'0' ;
        rsum+=str.charAt(r)-'0' ;
        if(lsum==rsum){
          ans=Math.max(ans,r-l+1);
        }
        l--;
        r++;
      }
    }
    return ans ;
  }
  static public void main(String[] args){
    String str="123123" ;
    System.out.println("Length of the substring is "+findLength(str,str.length()));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findLength( str : String, n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i <= n - 2 do ( (     var l : int ; l := i ;
    var r : int ; r := i + 1 ;
     var lsum : int ; lsum := 0 ;
    var rsum : int ; rsum := 0 ;
     while (r < n & l >= 0) do (     lsum := lsum+(str->at(l+1) - ('0')->char2byte()) ; 
     rsum := rsum+(str->at(r+1) - ('0')->char2byte()) ; 
    if (lsum = rsum) then (     ans := Set{ans, r - l + 1}->max() ) else skip ; 
    l := l - 1 ; 
    r := r + 1 ; 
 ) )  ;     i := i + 1 ) ; 
     return ans );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "123123" ;
     OclFile["System.out"].println("Length of the substring is " + findLength(str, str->size())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static void print(char a[],int n,int ind){
    for(int i=ind ; i<n+ind ; i++)System.out.print(a[(i % n)]+" ");
  }
  public static void main(String argc[]){
    char[] a=new char[] {
      'A','B','C','D','E','F' };
      int n=6 ;
      print(a,n,3);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation print( a : Sequence(String), n : int, ind : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := ind ; while i < n + ind do (     OclFile["System.out"].print(a[(i mod n)+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := Sequence{'A','B','C','D','E','F'} ;
     var n : int ; n := 6 ;
     execute print(a, n, 3) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ER42B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),a=in.nextInt(),b=in.nextInt();
    String s=in.next();
    int ans=a+b ;
    int flip=a>b ? 1 :-1 ;
    for(int i=0 ; i<n ; i++){
      if(a==0 && b==0)break ;
      if(s.charAt(i)=='*')flip=a>b ? 1 :-1 ;
      else {
        if(flip==1)a=(a==0 ? 0 : a-1);
        else b=(b==0 ? 0 : b-1);
        flip*=-1 ;
      }
    }
    System.out.println(ans-a-b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ER42B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var ans : int ; ans := a + b ;
    var flip : int ; flip := if a > b then 1 else -1 endif ;
        var i : int ; i := 0 ; while i < n do ( (     if (a = 0 & b = 0) then     break else skip ; 
     if (s->at(i+1) = '*') then     flip := if a > b then 1 else -1 endif ; else (     if (flip = 1) then     a := (if a = 0 then 0 else a - 1 endif) else     b := (if b = 0 then 0 else b - 1 endif) ; ;  
     flip := flip*(-1) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((ans)->char2byte() - a - b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int id=sc.nextInt();
    Node root=new Node(++id,0,sc.next());
    for(int i=1 ; i<n ; i++){
      int targetId=sc.nextInt();
      Node parent=root.findNode(targetId);
      parent.children.add(new Node(++id,parent.depth+1,sc.next()));
    }
    root.printContents();
    sc.close();
  }
}
class Node {
  int id,depth ;
  String contents ;
  List<Node>children ;
  Node(int i,int d,String c){
    id=i ;
    depth=d ;
    contents=c ;
    children=new ArrayList<Node>();
  }
  public Node findNode(int id){
    if(id==this.id)return this ;
    for(Node child : children){
      Node target=child.findNode(id);
      if(target!=null)return target ;
    }
    return null ;
  }
  public void printContents(){
    for(int i=0 ; i<depth ; i++)System.out.print('.');
    System.out.println(contents);
    for(Node child : children)child.printContents();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var id : int ; id := sc.getCurrent()->toInteger() ;
    var root : Node ; root := Node.newNode((id + 1), 0, sc.getCurrent()) ;
        var i : int ; i := 1 ; while i < n do ( (     var targetId : int ; targetId := sc.getCurrent()->toInteger() ;
     var parent : Node ; parent := root.findNode(targetId) ;
     parent.children->excludes(Node.newNode((id + 1), parent.depth + 1, sc.getCurrent())) )  ;     i := i + 1 ) ; 
    root.printContents() ; 
    skip ; 
 );
}
class Node {
   attribute id : int;
   attribute contents : String;
   attribute children : Sequence(Node);
   static operation newNode( i : int, d : int, c : String) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(i, d,c);
    return self );
  operation initialise( i : int, d : int, c : String) : void
  pre: true  post: true
  activity: (     id := i ; 
     depth := d ; 
     contents := c ; 
     children := Sequence{} );
   operation findNode( id : int) : Node
  pre: true
  post: true
  activity: (     if (id = self.id) then     return self else skip ; 
     for (child : children) do ( (     var target : Node ; target := child.findNode(id) ;
     if (target /= null) then     return target else skip )  ) ; 
     return null );
   operation printContents() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < depth do (     OclFile["System.out"].print('.') ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(contents) ; 
     for (child : children) do (     child.printContents() ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  final static int TEN=10 ;
  static int digitSum(int n){
    int sum=0 ;
    while(n>0){
      sum+=n % TEN ;
      n/=TEN ;
    }
    return sum ;
  }
  static int getNthTerm(int n){
    int sum=digitSum(n);
    if(sum % TEN==0)return(n*TEN);
    int extra=TEN-(sum % TEN);
    return((n*TEN)+extra);
  }
  static void firstNTerms(int n){
    for(int i=1 ; i<=n ; i++)System.out.print(getNthTerm(i)+" ");
  }
  public static void main(String[] args){
    int n=10 ;
    firstNTerms(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute TEN : int := 10;
  static   operation digitSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n > 0) do (     sum := sum+(n mod TEN) ; 
     n := n/(TEN) ) ; 
     return sum );
  static   operation getNthTerm( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := digitSum(n) ;
     if (sum mod TEN = 0) then     return (n * TEN) else skip ; 
     var extra : int ; extra := TEN - (sum mod TEN) ;
     return ((n * TEN) + extra) );
  static   operation firstNTerms( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= n do (     OclFile["System.out"].print(getNthTerm(i) + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     execute firstNTerms(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    Main main=new Main();
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=parseInt(line);
      Post[] posts=new Post[n+1];
      posts[0]=main.new Post(0,"",-1);
      for(int i=1 ; i<=n ; i++){
        int k=parseInt(br.readLine());
        String msg=br.readLine();
        posts[i]=main.new Post(i,msg,posts[k] .depth+1);
        posts[k] .children.add(posts[i]);
      }
      System.out.print(posts[1] .toString());
    }
  }
  class Post {
    Post parent ;
    int id ;
    String msg ;
    int depth ;
    List<Post>children ;
    Post(int id,String msg,int depth){
      this.id=id ;
      this.msg=msg ;
      this.depth=depth ;
      children=new ArrayList<>();
    }
    public String toString(){
      StringBuilder ret=new StringBuilder();
      for(int i=0 ; i<depth ; i++){
        ret.append('.');
      }
      ret.append(msg).append('\n');
      for(Post c : children){
        ret.append(c.toString());
      }
      return ret.toString();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var main : Main ; main := Main.newMain() ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := parseInt(line) ;
     var posts : Sequence(Post) ; posts := Integer.subrange(1,n + 1)->collect(null) ;
    posts[0+1] := (main).newPost(0, "", -1) ; 
        var i : int ; i := 1 ; while i <= n do ( (     var k : int ; k := parseInt(br.readLine()) ;
     var msg : String ; msg := br.readLine() ;
     posts[i+1] := (main).newPost(i, msg, posts[k+1].depth + 1) ; 
     posts[k+1].children->excludes(posts[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(posts[1+1]+"") ; 
 ) ;     line := br.readLine() ;
 ) );
 class Post {
   attribute parent : Post;
   attribute id : int;
   attribute msg : String;
   attribute depth : int;
   attribute children : Sequence(Post);
   static operation newPost( id : int, msg : String, depth : int) : Post
  pre: true
  post: true
  activity:
  ( var self : Post ;
    self := createPost();
    self.initialise(id, msg,depth);
    return self );
  operation initialise( id : int, msg : String, depth : int) : void
  pre: true  post: true
  activity: (     self.id := id ; 
     self.msg := msg ; 
     self.depth := depth ; 
     children := Sequence{} );
   operation toString() : String
  pre: true
  post: true
  activity: (     var ret : String ; ret := StringLib.newString() ;
         var i : int ; i := 0 ; while i < depth do ( (     ret := ret + StringLib.newString('.') )  ;     i := i + 1 ) ; 
    ret := ret + StringLib.newString(msg) + StringLib.newString('
') ; 
    for (c : children) do ( (     ret := ret + StringLib.newString(c+"") )  ) ; 
    return ret+"" 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int[] cubes=new int[60];
  int[] tetras=new int[100];
  void run(){
    Scanner in=new Scanner(System.in);
    init();
    for(int n=in.nextInt(); n>0 ; n=in.nextInt()){
      System.out.println(solve(n));
    }
  }
  void init(){
    for(int i=0 ; i<60 ; i++)cubes[i]=i*i*i ;
    for(int i=0 ; i<100 ; i++)tetras[i]=i*(i+1)*(i+2)/6 ;
  }
  int solve(int n){
    int ret=0 ;
    for(int i=0 ; i<60 ; i++)for(int j=0 ; j<100 ; j++){
      if(cubes[i]+tetras[j]<=n && ret<cubes[i]+tetras[j]){
        ret=cubes[i]+tetras[j];
      }
    }
    return ret ;
  }
  public static void main(String args[]){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute cubes : Sequence(int) := Integer.subrange(1,60)->collect(0);
   attribute tetras : Sequence(int) := Integer.subrange(1,100)->collect(0);
   operation run() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute init() ; 
         var n : int ; n := in.getCurrent()->toInteger() ; while n > 0 do ( (     OclFile["System.out"].println(solve(n)) )  ;     n := in.getCurrent()->toInteger() ) );
   operation init() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 60 do (     cubes[i+1] := i * i * i ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < 100 do (     tetras[i+1] := i * (i + 1) * (i + 2) / 6 ;  ;     i := i + 1 ) );
   operation solve( n : int) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
         var i : int ; i := 0 ; while i < 60 do (         var j : int ; j := 0 ; while j < 100 do ( (     if (cubes[i+1] + tetras[j+1] <= n & ret < cubes[i+1] + tetras[j+1]) then (     ret := cubes[i+1] + tetras[j+1] ) else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return ret );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  Scanner sc=new Scanner(System.in);
  int[][] list ;
  String[] message ;
  public void run(){
    int n=sc.nextInt();
    calc(n);
  }
  public void calc(int n){
    list=new int[n+1][n+1];
    message=new String[n+1];
    for(int i=1 ; i<n+1 ; i++){
      int k=sc.nextInt();
      String s=sc.next();
      list[k][i]=1 ;
      message[i]=s ;
    }
    print(-1,0,n);
  }
  public void print(int depth,int k,int n){
    if(k!=0){
      for(int i=0 ; i<depth ; i++){
        System.out.print(".");
      }
      System.out.println(message[k]);
    }
    for(int i=0 ; i<n+1 ; i++){
      if(list[k][i]==1){
        print(depth+1,i,n);
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute list : Sequence(Sequence(int));
   attribute message : Sequence(String);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     execute calc(n) );
   operation calc( n : int) : void
  pre: true
  post: true
  activity: (     list := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ; 
     message := Integer.subrange(1,n + 1)->collect(null) ; 
         var i : int ; i := 1 ; while i < n + 1 do ( (     var k : int ; k := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
     list[k+1][i+1] := 1 ; 
     message[i+1] := s )  ;     i := i + 1 ) ; 
     execute print(-1, 0, n) );
   operation print( depth : int, k : int, n : int) : void
  pre: true
  post: true
  activity: (     if (k /= 0) then (         var i : int ; i := 0 ; while i < depth do ( (     OclFile["System.out"].print(".") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(message[k+1]) ) else skip ; 
         var i : int ; i := 0 ; while i < n + 1 do ( (     if (list[k+1][i+1] = 1) then (     execute print(depth + 1, i, n) ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    Node[] nodes=new Node[N];
    for(int i=0 ; i<N ; i++){
      int parent=sc.nextInt()-1 ;
      String v=sc.next();
      nodes[i]=new Node(v);
      if(i>0)nodes[parent] .children.add(nodes[i]);
    }
    nodes[0] .print(0);
  }
  static class Node {
    ArrayList<Node>children=new ArrayList<>();
    String v ;
    public Node(String v){
      this.v=v ;
    }
    void print(int depth){
      for(int i=0 ; i<depth ; i++){
        System.out.print(".");
      }
      System.out.println(v);
      for(Node c : children){
        c.print(depth+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var nodes : Sequence(Node) ; nodes := Integer.subrange(1,N)->collect(null) ;
         var i : int ; i := 0 ; while i < N do ( (     var parent : int ; parent := sc.getCurrent()->toInteger() - 1 ;
     var v : String ; v := sc.getCurrent() ;
     nodes[i+1] := Node.newNode(v) ; 
     if (i > 0) then     nodes[parent+1].children->excludes(nodes[i+1]) ; else skip )  ;     i := i + 1 ) ; 
     nodes[0+1].print(0) );
  static class Node {
   attribute children : Sequence(Node) := Sequence{};
   attribute v : String;
   static operation newNode( v : String) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(v);
    return self );
  operation initialise( v : String) : void
  pre: true  post: true
  activity: (     self.v := v );
   operation print( depth : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < depth do ( (     OclFile["System.out"].print(".") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(v) ; 
     for (c : children) do ( (     c.print(depth + 1) )  ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Vector ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    Submission array[]=new Submission[n];
    for(int i=0 ; i<n ; i++){
      int reply=Integer.parseInt(br.readLine());
      String message=br.readLine();
      Submission sub=new Submission(message);
      if(reply!=0){
        array[reply-1] .child.add(sub);
      }
      array[i]=sub ;
    }
    printThread(array,array[0],0);
  }
  static void printThread(Submission[] array,Submission sub,int depth){
    for(int i=0 ; i<depth ; i++){
      System.out.print('.');
    }
    System.out.println(sub.message);
    for(int i=0 ; i<sub.child.size(); i++){
      Submission tmp=sub.child.elementAt(i);
      printThread(array,tmp,depth+1);
    }
  }
}
class Submission {
  Vector<Submission>child=new Vector<Submission>();
  String message ;
  public Submission(String message){
    this.message=message ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var array : Sequence(Submission) ; array := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var reply : int ; reply := (br.readLine())->toInteger() ;
     var message : String ; message := br.readLine() ;
    var sub : Submission ; sub := Submission.newSubmission(message) ;
    if (reply /= 0) then (     array[reply - 1+1].child->excludes(sub) ) else skip ; 
    array[i+1] := sub ; 
 )  ;     i := i + 1 ) ; 
    execute printThread(array, array[0+1], 0) ; 
 );
  static   operation printThread( array : Sequence(Submission), sub : Submission, depth : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < depth do ( (     OclFile["System.out"].print('.') )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sub.message) ; 
         var i : int ; i := 0 ; while i < sub.child->size() do ( (     var tmp : Submission ; tmp := sub.child->at(i+1) ;
     execute printThread(array, tmp, depth + 1) )  ;     i := i + 1 ) );
}
class Submission {
   attribute child : Sequence(Submission) := Sequence{};
   attribute message : String;
   static operation newSubmission( message : String) : Submission
  pre: true
  post: true
  activity:
  ( var self : Submission ;
    self := createSubmission();
    self.initialise(message);
    return self );
  operation initialise( message : String) : void
  pre: true  post: true
  activity: (     self.message := message );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.nio.Buffer ;
import java.sql.Array ;
import java.util.*;
public class Main2 {
  static int v1 ;
  static int v2 ;
  static int t ;
  static int d ;
  static int[][] dp ;
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    v1=sc.nextInt();
    v2=sc.nextInt();
    t=sc.nextInt();
    d=sc.nextInt();
    dp=new int[t][1200];
    for(int[] x : dp)Arrays.fill(x,-1);
    int ans=-1 ;
    if(t==2)System.out.println(v1+v2);
    else System.out.println(v1+v2+calculate(1,v1,v1));
  }
  public static int calculate(int currentTime,int currentSpeed,int prev){
    if(currentSpeed<0)return-(int)(1e8);
    if(currentTime==t-1){
      if(Math.abs(currentSpeed-v2)<=d)return 0 ;
      return-(int)(1e8);
    }
    if(dp[currentTime][currentSpeed]!=-1){
      return dp[currentTime][currentSpeed];
    }
    int bestAns=-(int)(1e8);
    for(int i=0 ; i<=d ; i++){
      int ans=currentSpeed+i+calculate(currentTime+1,currentSpeed+i,currentSpeed);
      int ans2=currentSpeed-i+calculate(currentTime+1,currentSpeed-i,currentSpeed);
      bestAns=Math.max(bestAns,Math.max(ans,ans2));
    }
    return dp[currentTime][currentSpeed]=bestAns ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main2 {
  static   attribute v1 : int;
  static   attribute v2 : int;
  static   attribute t : int;
  static   attribute d : int;
  static   attribute dp : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     v1 := sc.getCurrent()->toInteger() ; 
    v2 := sc.getCurrent()->toInteger() ; 
    t := sc.getCurrent()->toInteger() ; 
    d := sc.getCurrent()->toInteger() ; 
    dp := Integer.subrange(1,t)->collect(Integer.subrange(1,1200)->collect(0)) ; 
    for (x : dp) do (     x := x->collect(-1) ;  ) ; 
    var ans : int ; ans := -1 ;
    if (t = 2) then     OclFile["System.out"].println(v1 + v2) else     OclFile["System.out"].println(v1 + v2 + calculate(1, v1, v1)) ; ;  
 );
  static   operation calculate( currentTime : int, currentSpeed : int, prev : int) : int
  pre: true
  post: true
  activity: (     if (currentSpeed < 0) then     return -(1e8)->oclAsType(int) else skip ; 
     if (currentTime = t - 1) then (     if (if currentSpeed - v2 < 0 then -(currentSpeed - v2) else currentSpeed - v2 endif <= d) then     return 0 else skip ; 
     return -(1e8)->oclAsType(int) ) else skip ; 
    if (dp[currentTime+1][currentSpeed+1] /= -1) then (     return dp[currentTime+1][currentSpeed+1] ) else skip ; 
    var bestAns : int ; bestAns := -(1e8)->oclAsType(int) ;
        var i : int ; i := 0 ; while i <= d do ( (     var ans : int ; ans := currentSpeed + i + calculate(currentTime + 1, currentSpeed + i, currentSpeed) ;
     var ans2 : int ; ans2 := currentSpeed - i + calculate(currentTime + 1, currentSpeed - i, currentSpeed) ;
     bestAns := Set{bestAns, Set{ans, ans2}->max()}->max() )  ;     i := i + 1 ) ; 
    return dp[currentTime+1][currentSpeed+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int v1=in.nextInt();
      int v2=in.nextInt();
      int t=in.nextInt();
      int d=in.nextInt();
      int[] a=new int[101];
      int[] b=new int[101];
      a[1]=v1 ;
      b[t]=v2 ;
      for(int i=2 ; i<=t ; i++){
        a[i]=a[i-1]+d ;
      }
      for(int i=t-1 ; i>=1 ; i--){
        b[i]=b[i+1]+d ;
      }
      int s=0 ;
      for(int i=1 ; i<=t ; i++){
        int q=Math.min(a[i],b[i]);
        s+=q ;
      }
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var v1 : int ; v1 := in.getCurrent()->toInteger() ;
     var v2 : int ; v2 := in.getCurrent()->toInteger() ;
    var t : int ; t := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,101)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,101)->collect(0) ;
    a[1+1] := v1 ; 
    b[t+1] := v2 ; 
        var i : int ; i := 2 ; while i <= t do ( (     a[i+1] := a[i - 1+1] + d )  ;     i := i + 1 ) ; 
        var i : int ; i := t - 1 ; while i >= 1 do ( (     b[i+1] := b[i + 1+1] + d )  ;     i := i - 1 ) ; 
    var s : int ; s := 0 ;
        var i : int ; i := 1 ; while i <= t do ( (     var q : int ; q := Set{a[i+1], b[i+1]}->min() ;
     s := s+(q) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Hello {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int v1=sc.nextInt();
    int v2=sc.nextInt();
    int t=sc.nextInt();
    int d=sc.nextInt();
    long[][] dp=new long[t-1][1150];
    for(int i=0 ; i<t-1 ; i++){
      Arrays.fill(dp[i],-(long)(1e17));
    }
    dp[0][v1]=v1 ;
    long sum=0 ;
    for(int i=1 ; i<t-1 ; i++){
      for(int j=0 ; j<1150 ; j++){
        for(int x=0 ; x<=d ; x++){
          if(j+x<1150)dp[i][j]=Math.max(dp[i][j],dp[i-1][j+x]+j);
        }
        for(int x=d ; x>=0 ; x--){
          if(j-x>=0){
            dp[i][j]=Math.max(dp[i][j],dp[i-1][j-x]+j);
          }
        }
      }
    }
    long ans=Long.MIN_VALUE ;
    for(int i=t-2 ; i<t-1 ; i++){
      for(int j=0 ; j<1150 ; j++){
        if(Math.abs(j-v2)<=d)ans=Math.max(ans,dp[i][j]+v2);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hello {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var v1 : int ; v1 := sc.getCurrent()->toInteger() ;
    var v2 : int ; v2 := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,t - 1)->collect(Integer.subrange(1,1150)->collect(0)) ;
        var i : int ; i := 0 ; while i < t - 1 do ( (     dp[i+1] := dp[i+1]->collect(-(1e17)->oclAsType(long)) )  ;     i := i + 1 ) ; 
    dp[0+1][v1+1] := v1 ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 1 ; while i < t - 1 do ( (         var j : int ; j := 0 ; while j < 1150 do ( (         var x : int ; x := 0 ; while x <= d do ( (     if (j + x < 1150) then     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i - 1+1][j + x+1] + j}->max() ; else skip )  ;     x := x + 1 ) ; 
         var x : int ; x := d ; while x >= 0 do ( (     if (j - x >= 0) then (     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i - 1+1][j - x+1] + j}->max() ) else skip )  ;     x := x - 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := "-9223372036854775808"->toLong() ;
        var i : int ; i := t - 2 ; while i < t - 1 do ( (         var j : int ; j := 0 ; while j < 1150 do ( (     if (if j - v2 < 0 then -(j - v2) else j - v2 endif <= d) then     ans := Set{ans, dp[i+1][j+1] + v2}->max() ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] a=sc.next().toCharArray(),b=sc.next().toCharArray();
    Arrays.sort(a);
    Arrays.sort(b);
    int j=n-1 ;
    for(int i=n-1 ; i>=0 ; --i){
      if(b[j]>=a[i])--j ;
    }
    System.out.println(j+1);
    j=0 ;
    for(int i=0 ; i<n ; ++i){
      if(b[i]>a[j])++j ;
    }
    System.out.print(j);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(String) ; a := sc.getCurrent()->characters() ;
    var b : Sequence(String) ; b := sc.getCurrent()->characters() ;
    a := a->sort() ; 
    b := b->sort() ; 
    var j : int ; j := n - 1 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (b[j+1] >= a[i+1]) then     j := j - 1 ; else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(j + 1) ; 
    j := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     if (b[i+1] > a[j+1]) then     j := j + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(j) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=Integer.parseInt(scanner.nextLine());
    int[] sh=new int[n];
    ArrayList<Integer>pm=new ArrayList<>();
    String str=scanner.nextLine();
    for(int i=0 ; i<sh.length ; i++){
      sh[i]=Character.getNumericValue(str.charAt(i));
    }
    str=scanner.nextLine();
    for(int i=0 ; i<n ; i++){
      pm.add(Character.getNumericValue(str.charAt(i)));
    }
    Collections.sort(pm);
    ArrayList<Integer>pmEq=new ArrayList<>(pm);
    int evade=0 ;
    int inflict=0 ;
    for(int i=0 ; i<sh.length ; i++){
      for(int j=0 ; j<pm.size(); j++){
        if(pm.get(j)>sh[i]){
          pm.remove(j);
          inflict++;
          break ;
        }
      }
      boolean unavoidable=true ;
      for(int j=0 ; j<pmEq.size(); j++){
        if(pmEq.get(j)>=sh[i]){
          pmEq.remove(j);
          unavoidable=false ;
          break ;
        }
      }
      if(unavoidable){
        evade++;
        pmEq.remove(0);
      }
    }
    System.out.println(evade);
    System.out.println(inflict);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (scanner.nextLine())->toInteger() ;
    var sh : Sequence(int) ; sh := Integer.subrange(1,n)->collect(0) ;
    var pm : Sequence(int) ; pm := Sequence{} ;
    var str : String ; str := scanner.nextLine() ;
        var i : int ; i := 0 ; while i < sh->size() do ( (     sh[i+1] := ("" + str->at(i+1))->toInteger() )  ;     i := i + 1 ) ; 
    str := scanner.nextLine() ; 
        var i : int ; i := 0 ; while i < n do ( (     pm := pm->including(("" + str->at(i+1))->toInteger()) )  ;     i := i + 1 ) ; 
    pm := pm->sort() ; 
    var pmEq : Sequence(int) ; pmEq := Sequence{}->union(pm) ;
    var evade : int ; evade := 0 ;
    var inflict : int ; inflict := 0 ;
        var i : int ; i := 0 ; while i < sh->size() do ( (         var j : int ; j := 0 ; while j < pm->size() do ( (     if (pm->at(j+1) > sh[i+1]) then (     pm := pm->excludingAt(j+1) ; 
     inflict := inflict + 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     var unavoidable : boolean ; unavoidable := true ;
         var j : int ; j := 0 ; while j < pmEq->size() do ( (     if (pmEq->at(j+1) >= sh[i+1]) then (     pmEq := pmEq->excludingAt(j+1) ; 
     unavoidable := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (unavoidable) then (     evade := evade + 1 ; 
     pmEq := pmEq->excludingAt(0+1) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(evade) ; 
    OclFile["System.out"].println(inflict) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int power(int x,int a){
    int res=1 ;
    while(a>0){
      if((a & 1)>0)res=res*x ;
      x=x*x ;
      a>>=1 ;
    }
    return res ;
  }
  static int breakInteger(int N){
    if(N==2)return 1 ;
    if(N==3)return 2 ;
    int maxProduct=-1 ;
    switch(N % 3){
      case 0 : maxProduct=power(3,N/3);
      break ;
      case 1 : maxProduct=2*2*power(3,(N/3)-1);
      break ;
      case 2 : maxProduct=2*power(3,N/3);
      break ;
    }
    return maxProduct ;
  }
  public static void main(String[] args){
    int maxProduct=breakInteger(10);
    System.out.println(maxProduct);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation power( x : int, a : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     while (a > 0) do (     if ((a & 1) > 0) then     res := res * x ; else skip ; 
     x := x * x ; 
     a := a/(2->pow(1)) ) ; 
     return res );
  static   operation breakInteger( N : int) : int
  pre: true
  post: true
  activity: (     if (N = 2) then     return 1 else skip ; 
     if (N = 3) then     return 2 else skip ; 
    var maxProduct : int ; maxProduct := -1 ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (N mod 3) ; 
       if _switchval = 0 then
     maxProduct := power(3, N / 3) ; 
    break 
   else skip ;
       if _switchval = 1 then
     maxProduct := 2 * 2 * power(3, (N / 3) - 1) ; 
    break 
   else skip ;
       if _switchval = 2 then
     maxProduct := 2 * power(3, N / 3) ; 
    break 
   else skip ;
 )
    return maxProduct 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var maxProduct : int ; maxProduct := breakInteger(10) ;
     OclFile["System.out"].println(maxProduct) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      int max=0 ;
      for(int i=0 ; i*i*i<=n ; i++){
        for(int j=0 ; j*(j+1)*(j+2)/6<=n ; j++){
          int k=i*i*i+j*(j+1)*(j+2)/6 ;
          if(k<=n){
            max=max(max,k);
          }
        }
      }
      println(max+"");
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i * i * i <= n do ( (         var j : int ; j := 0 ; while j * (j + 1) * (j + 2) / 6 <= n do ( (     var k : int ; k := i * i * i + j * (j + 1) * (j + 2) / 6 ;
     if (k <= n) then (     max := Set{max, k}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    execute println(max + "") ; 
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    char[] s=in.next().toCharArray();
    char[] m=in.next().toCharArray();
    int[] ans=solve(s,m,n);
    pw.println(ans[0]);
    pw.println(ans[1]);
    pw.close();
  }
  static int[] solve(char[] s,char[] m,int n){
    int mor=0 ;
    int shar=0 ;
    Arrays.sort(s);
    Arrays.sort(m);
    int mId=0 ;
    for(int i=0 ; i<n ; i++){
      while(mId<n && s[i]>m[mId])mId++;
      if(mId>=n)mor++;
      mId++;
    }
    mId=0 ;
    for(int i=0 ; i<n ; i++){
      while(mId<n && s[i]>=m[mId])mId++;
      if(mId<n)shar++;
      mId++;
    }
    int[] ans={
      mor,shar };
      return ans ;
    }
    static void debug(Object...obj){
      System.err.println(Arrays.deepToString(obj));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := in.getCurrent()->characters() ;
    var m : Sequence(String) ; m := in.getCurrent()->characters() ;
    var ans : Sequence(int) ; ans := solve(s, m, n) ;
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation solve( s : Sequence(String), m : Sequence(String), n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var mor : int ; mor := 0 ;
     var shar : int ; shar := 0 ;
    s := s->sort() ; 
    m := m->sort() ; 
    var mId : int ; mId := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     while (mId < n & s[i+1] > m[mId+1]) do     mId := mId + 1 ; ; 
     if (mId >= n) then     mor := mor + 1 ; else skip ; 
     mId := mId + 1 )  ;     i := i + 1 ) ; 
    mId := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     while (mId < n & s[i+1] >= m[mId+1]) do     mId := mId + 1 ; ; 
     if (mId < n) then     shar := shar + 1 ; else skip ; 
     mId := mId + 1 )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Sequence{mor,shar} ;
    return ans 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] num=new int[3];
    num[0]=sc.nextInt();
    num[1]=sc.nextInt();
    num[2]=sc.nextInt();
    Arrays.sort(num);
    int dis1=num[2]-num[0];
    int dis2=num[2]-num[1];
    int ans=0 ;
    if(dis1 % 2==0 && dis2 % 2==0){
      ans=dis1/2+dis2/2 ;
    }
    else if(dis1 % 2!=0 && dis2 % 2!=0){
      ans=dis1/2+dis2/2+1 ;
    }
    else {
      ans=dis1/2+dis2/2+2 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : Sequence(int) ; num := Integer.subrange(1,3)->collect(0) ;
    num[0+1] := sc.getCurrent()->toInteger() ; 
    num[1+1] := sc.getCurrent()->toInteger() ; 
    num[2+1] := sc.getCurrent()->toInteger() ; 
    num := num->sort() ; 
    var dis1 : int ; dis1 := num[2+1] - num[0+1] ;
    var dis2 : int ; dis2 := num[2+1] - num[1+1] ;
    var ans : int ; ans := 0 ;
    if (dis1 mod 2 = 0 & dis2 mod 2 = 0) then (     ans := dis1 / 2 + dis2 / 2 ) else     if (dis1 mod 2 /= 0 & dis2 mod 2 /= 0) then (     ans := dis1 / 2 + dis2 / 2 + 1 ) else (     ans := dis1 / 2 + dis2 / 2 + 2 ) ;  ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.*;
import java.math.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    StringTokenizer st=new StringTokenizer(bf.readLine());
    int a=Integer.parseInt(st.nextToken());
    int b=Integer.parseInt(st.nextToken());
    int c=Integer.parseInt(st.nextToken());
    int min=Integer.MAX_VALUE ;
    for(int i=-2 ; i<=52 ; i++){
      int ans=0 ;
      if(a>=i)ans+=(a-i);
      else {
        if((i-a)% 2==0)ans+=(i-a)/2 ;
        else ans+=(i-a)/2+2 ;
      }
      if(b>=i)ans+=(b-i);
      else {
        if((i-b)% 2==0)ans+=(i-b)/2 ;
        else ans+=(i-b)/2+2 ;
      }
      if(c>=i)ans+=(c-i);
      else {
        if((i-c)% 2==0)ans+=(i-c)/2 ;
        else ans+=(i-c)/2+2 ;
      }
      if(ans<min)min=ans ;
    }
    out.println(min);
    out.close();
    System.exit(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(bf.readLine()) ;
    var a : int ; a := (st.next())->toInteger() ;
    var b : int ; b := (st.next())->toInteger() ;
    var c : int ; c := (st.next())->toInteger() ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := -2 ; while i <= 52 do ( (     var ans : int ; ans := 0 ;
     if (a >= i) then     ans := ans+((a - i)) else (     if ((i - a) mod 2 = 0) then     ans := ans+((i - a) / 2) ; else     ans := ans+((i - a) / 2 + 2) ; ) ;  
    if (b >= i) then     ans := ans+((b - i)) else (     if ((i - b) mod 2 = 0) then     ans := ans+((i - b) / 2) ; else     ans := ans+((i - b) / 2 + 2) ; ) ;  
    if (c >= i) then     ans := ans+((c - i)) else (     if ((i - c) mod 2 = 0) then     ans := ans+((i - c) / 2) ; else     ans := ans+((i - c) / 2 + 2) ; ) ;  
    if (ans < min) then     min := ans ; else skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
OclProcess.exit(0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String[] tokens=in.nextLine().split(" ");
    List<Integer>values=new ArrayList<>();
    for(String token : tokens){
      values.add(Integer.parseInt(token));
    }
    Collections.sort(values);
    int result=0 ;
    while(true){
      int r=operation(values);
      if(r==0){
        break ;
      }
      result+=r ;
      Collections.sort(values);
    }
    System.out.println(result);
    in.close();
  }
  public static int operation(List<Integer>values){
    if(values.get(0)==values.get(2)){
      return 0 ;
    }
    if(values.get(0)==values.get(1)){
      int result=values.get(2)-values.get(1);
      values.set(0,values.get(2));
      values.set(1,values.get(2));
      return result ;
    }
    if((values.get(1)-values.get(0))% 2==0){
      int result=(values.get(1)-values.get(0))/2 ;
      values.set(0,values.get(1));
      return result ;
    }
    else {
      int result=(values.get(1)+1-values.get(0))/2 ;
      values.set(0,values.get(1));
      values.set(1,values.get(1)+1);
      return result ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tokens : Sequence(String) ; tokens := in.nextLine()->split(" ") ;
    var values : Sequence(int) ; values := Sequence{} ;
    for (token : tokens) do ( (     values := values->including((token)->toInteger()) )  ) ; 
    values := values->sort() ; 
    var result : int ; result := 0 ;
    while (true) do (     var r : int ; r := operation(values) ;
     if (r = 0) then (     break ) else skip ; 
     result := result+(r) ; 
     values := values->sort() ) ; 
    OclFile["System.out"].println(result) ; 
    skip ; 
 );
  static   operation operation( values : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (values->at(0+1) = values->at(2+1)) then (     return 0 ) else skip ; 
     if (values->at(0+1) = values->at(1+1)) then (     var result : int ; result := values->at(2+1) - values->at(1+1) ;
     values := values.setAt(0+1,values->at(2+1)) ; 
     values := values.setAt(1+1,values->at(2+1)) ; 
     return result ) else skip ; 
     if ((values->at(1+1) - values->at(0+1)) mod 2 = 0) then (     var result : int ; result := (values->at(1+1) - values->at(0+1)) / 2 ;
     values := values.setAt(0+1,values->at(1+1)) ; 
     return result ) else (     var result : int ; result := (values->at(1+1) + 1 - values->at(0+1)) / 2 ;
     values := values.setAt(0+1,values->at(1+1)) ; 
     values := values.setAt(1+1,values->at(1+1) + 1) ; 
     return result ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public void main(Scanner sc){
    int n[]=new int[3];
    for(int i=0 ; i<3 ; i++){
      n[i]=sc.nextInt();
    }
    Arrays.sort(n);
    int cnt=0 ;
    int tmp=(n[2]-n[0])/2 ;
    n[0]+=tmp*2 ;
    cnt+=tmp ;
    tmp=(n[2]-n[1])/2 ;
    n[1]+=tmp*2 ;
    cnt+=tmp ;
    tmp=n[0]+n[1]-2*n[2]+3 ;
    cnt+=tmp % 3 ;
    System.out.println(cnt);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    new Main().main(sc);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : Sequence(int) ; n := Integer.subrange(1,3)->collect(0) ;
         var i : int ; i := 0 ; while i < 3 do ( (     n[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    n := n->sort() ; 
    var cnt : int ; cnt := 0 ;
    var tmp : int ; tmp := (n[2+1] - n[0+1]) / 2 ;
    n[0+1] := n[0+1]+(tmp * 2) ; 
    cnt := cnt+(tmp) ; 
    tmp := (n[2+1] - n[1+1]) / 2 ; 
    n[1+1] := n[1+1]+(tmp * 2) ; 
    cnt := cnt+(tmp) ; 
    tmp := n[0+1] + n[1+1] - 2 * n[2+1] + 3 ; 
    cnt := cnt+(tmp mod 3) ; 
    OclFile["System.out"].println(cnt) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Main.newMain().main(sc) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    MyScanner sc=new MyScanner(System.in);
    int[] a=new int[3];
    a[0]=sc.nextInt();
    a[1]=sc.nextInt();
    a[2]=sc.nextInt();
    Arrays.sort(a);
    if(a[0]==a[1] && a[1]==a[2]){
      System.out.println(0);
    }
    else {
      int d=(2*a[2]-a[1]-a[0]);
      if(d % 2==0){
        System.out.println(d/2);
      }
      else {
        int d2=(2*(a[2]+1)-a[1]-a[0]-1);
        System.out.println(d2/2+1);
      }
    }
  }
  static class MyScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public MyScanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
    a[0+1] := sc.nextInt() ; 
    a[1+1] := sc.nextInt() ; 
    a[2+1] := sc.nextInt() ; 
    a := a->sort() ; 
    if (a[0+1] = a[1+1] & a[1+1] = a[2+1]) then (     OclFile["System.out"].println(0) ) else (     var d : int ; d := (2 * a[2+1] - a[1+1] - a[0+1]) ;
     if (d mod 2 = 0) then (     OclFile["System.out"].println(d / 2) ) else (     var d2 : int ; d2 := (2 * (a[2+1] + 1) - a[1+1] - a[0+1] - 1) ;
     OclFile["System.out"].println(d2 / 2 + 1) ) ) ;  
 );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner( s : OclFile) : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0){
      int n=sc.nextInt();
      for(int i=1 ; i<=n ; i++){
        for(int j=1 ; j<=i ; j++){
          if(j==1 || i==j){
            System.out.print(1+" ");
          }
          else {
            System.out.print(0+" ");
          }
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= i do ( (     if (j = 1 or i = j) then (     OclFile["System.out"].print(1 + " ") ) else (     OclFile["System.out"].print(0 + " ") ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    while(n-->0){
      int m=scan.nextInt();
      for(int i=0 ; i<m ; i++){
        for(int j=0 ; j<=i ; j++){
          System.out.print(((j==0 || j==i)? 1 : 0)+" ");
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var m : int ; m := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j <= i do ( (     OclFile["System.out"].print((if (j = 0 or j = i) then 1 else 0 endif) + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B_Bright_Nice_Brilliant {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int tc=sc.nextInt();
    while(tc-->0){
      int stairs=sc.nextInt();
      for(int i=1 ; i<=stairs ; i++){
        for(int j=1 ; j<=i ; j++){
          if(j==1 || j==i)System.out.print("1 ");
          else System.out.print("0 ");
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Bright_Nice_Brilliant {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := sc.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var stairs : int ; stairs := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= stairs do ( (         var j : int ; j := 1 ; while j <= i do ( (     if (j = 1 or j = i) then     OclFile["System.out"].print("1 ") ; else     OclFile["System.out"].print("0 ") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B_Bright_Nice_Brilliant {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int tc=sc.nextInt();
    while(tc-->0){
      int stairs=sc.nextInt();
      int temp=1 ;
      while(temp<=stairs){
        if(temp==1)printFirst();
        else if(temp==2)printSecond(2);
        else printOthers(temp);
        temp+=1 ;
      }
    }
  }
  public static void printFirst(){
    System.out.println("1");
  }
  public static void printSecond(int num){
    while(num-->0){
      System.out.print("1 ");
    }
    System.out.println();
  }
  public static void printOthers(int num){
    System.out.print("1 ");
    num--;
    while(num-->1){
      System.out.print("0 ");
    }
    System.out.println("1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Bright_Nice_Brilliant {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := sc.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var stairs : int ; stairs := sc.getCurrent()->toInteger() ;
     var temp : int ; temp := 1 ;
     while (temp <= stairs) do (     if (temp = 1) then     execute printFirst() else     if (temp = 2) then     execute printSecond(2) else     execute printOthers(temp) ; ;  ;  
     temp := temp+(1) ) ) ;  ) );
  static   operation printFirst() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("1") );
  static   operation printSecond( num : int) : void
  pre: true
  post: true
  activity: (         while (num > 0) do (        num := num - 1 ;     skip ; (     OclFile["System.out"].print("1 ") ) ;  ) ;  
     OclFile["System.out"].println() );
  static   operation printOthers( num : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("1 ") ; 
     num := num - 1 ; 
         while (num > 1) do (        num := num - 1 ;     skip ; (     OclFile["System.out"].print("0 ") ) ;  ) ;  
     OclFile["System.out"].println("1") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  final double EPS=1.0e-10 ;
  final int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    int cns[]=new int[101];
    int tns[]=new int[101];
    for(int i=0 ; i<101 ; i++){
      cns[i]=i*i*i ;
      tns[i]=i*(i+1)*(i+2)/6 ;
    }
    while(true){
      int f=sc.nextInt();
      if(f==0)break ;
      int lb=0 ;
      int ub=100 ;
      while(ub-lb>1){
        int mid=(lb+ub)/2 ;
        if(cns[mid]<f){
          lb=mid ;
        }
        else {
          ub=mid ;
        }
      }
      int cn=cns[lb];
      lb=0 ;
      ub=100 ;
      while(ub-lb>1){
        int mid=(lb+ub)/2 ;
        if(tns[mid]<f){
          lb=mid ;
        }
        else {
          ub=mid ;
        }
      }
      int tn=tns[lb];
      int max=Math.max(tn,cn);
      for(int i=0 ; i<100 ; i++){
        for(int j=0 ; j<100 ; j++){
          if(tns[i]+cns[j]<=f)max=Math.max(max,cns[j]+tns[i]);
          else break ;
        }
      }
      System.out.println(max);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute EPS : double := 1.0e-10;
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cns : Sequence(int) ; cns := Integer.subrange(1,101)->collect(0) ;
    var tns : Sequence(int) ; tns := Integer.subrange(1,101)->collect(0) ;
        var i : int ; i := 0 ; while i < 101 do ( (     cns[i+1] := i * i * i ; 
     tns[i+1] := i * (i + 1) * (i + 2) / 6 )  ;     i := i + 1 ) ; 
    while (true) do (     var f : int ; f := sc.getCurrent()->toInteger() ;
     if (f = 0) then     break else skip ; 
    var lb : int ; lb := 0 ;
    var ub : int ; ub := 100 ;
    while (ub - lb > 1) do (     var mid : int ; mid := (lb + ub) / 2 ;
     if (cns[mid+1] < f) then (     lb := mid ) else (     ub := mid ) ) ; 
    var cn : int ; cn := cns[lb+1] ;
    lb := 0 ; 
    ub := 100 ; 
    while (ub - lb > 1) do (     var mid : int ; mid := (lb + ub) / 2 ;
     if (tns[mid+1] < f) then (     lb := mid ) else (     ub := mid ) ) ; 
    var tn : int ; tn := tns[lb+1] ;
    var max : int ; max := Set{tn, cn}->max() ;
        var i : int ; i := 0 ; while i < 100 do ( (         var j : int ; j := 0 ; while j < 100 do ( (     if (tns[i+1] + cns[j+1] <= f) then     max := Set{max, cns[j+1] + tns[i+1]}->max() ; else     break )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void bin(Integer n){
    if(n>1)bin(n>>1);
    System.out.printf("%d",n & 1);
  }
  public static void main(String[] args){
    bin(131);
    System.out.printf("\n");
    bin(3);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation bin( n : int) : void
  pre: true
  post: true
  activity: (     if (n > 1) then     execute bin((n/(2->pow(1)))->oclAsType(long)) ; else skip ; 
     OclFile["System.out"].printf("%d", n & 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute bin(131) ; 
     OclFile["System.out"].printf("\n") ; 
     execute bin(3) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p001 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p001().run());
  }
  public String run(){
    int sum=0 ;
    for(int i=0 ; i<1000 ; i++){
      if(i % 3==0 || i % 5==0)sum+=i ;
    }
    return Integer.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
class p001 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p001.newp001().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < 1000 do ( (     if (i mod 3 = 0 or i mod 5 = 0) then     sum := sum+(i) ; else skip )  ;     i := i + 1 ) ; 
     return ((sum) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String str=sc.next();
    String s="" ;
    String s1="" ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)=='n'){
        s+="1 " ;
      }
      if(str.charAt(i)=='z'){
        s1+="0 " ;
      }
    }
    System.out.println(s+s1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var str : String ; str := sc.getCurrent() ;
    var s : String ; s := "" ;
    var s1 : String ; s1 := "" ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = 'n') then (     s := s+("1 ") ) else skip ; 
     if (str->at(i+1) = 'z') then (     s1 := s1+("0 ") ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s + s1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),one=0,zero=0 ;
    sc.nextLine();
    String s=sc.nextLine();
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='n')one++;
      else if(s.charAt(i)=='z')zero++;
    }
    while(one-->0)System.out.print(1+" ");
    while(zero-->0)System.out.print(0+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var one : int ; one := 0 ;
    var zero : int ; zero := 0 ;
    skip ; 
    var s : String ; s := sc.nextLine() ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = 'n') then     one := one + 1 ; else     if (s->at(i+1) = 'z') then     zero := zero + 1 ; else skip ; )  ;     i := i + 1 ) ; 
        while (one > 0) do (        one := one - 1 ;     skip ;     OclFile["System.out"].print(1 + " ") ; ;  ) ;  
        while (zero > 0) do (        zero := zero - 1 ;     skip ;     OclFile["System.out"].print(0 + " ") ; ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A1220 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));
    int n=in.nextInt();
    int nn=0,zz=0 ;
    char[] ch=in.next().toCharArray();
    for(char c : ch){
      if(c=='n')nn++;
      if(c=='z')zz++;
    }
    for(int i=0 ; i<nn ; i++)pw.print(1+" ");
    for(int i=0 ; i<zz ; i++)pw.print(0+" ");
    pw.println();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1220 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var nn : int ; nn := 0 ;
    var zz : int ; zz := 0 ;
    var ch : Sequence(String) ; ch := in.getCurrent()->characters() ;
    for (c : ch) do ( (     if (c = 'n') then     nn := nn + 1 ; else skip ; 
     if (c = 'z') then     zz := zz + 1 ; else skip )  ) ; 
        var i : int ; i := 0 ; while i < nn do (     skip ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < zz do (     skip ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static void solve(){
    Scanner sc=new Scanner(System.in);
    int R=sc.nextInt(),G=sc.nextInt();
    System.out.println((2*G)-R);
    sc.close();
  }
  public static void main(String args[]){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var R : int ; R := sc.getCurrent()->toInteger() ;
    var G : int ; G := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println((2 * G) - R) ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int R=scan.nextInt();
    int G=scan.nextInt();
    System.out.println(2*G-R);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var R : int ; R := scan.getCurrent()->toInteger() ;
     var G : int ; G := scan.getCurrent()->toInteger() ;
     OclFile["System.out"].println(2 * G - R) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static Scanner sc ;
  private static Printer pr ;
  private static void solve(){
    int r=sc.nextInt();
    int g=sc.nextInt();
    pr.println(2*g-r);
  }
  public static void main(String[] args){
    sc=new Scanner(System.in);
    pr=new Printer(System.out);
    solve();
    pr.close();
    sc.close();
  }
  private static class Printer extends PrintWriter {
    Printer(PrintStream out){
      super(out);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile;
  static   attribute pr : Printer;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var r : int ; r := sc.getCurrent()->toInteger() ;
     var g : int ; g := sc.getCurrent()->toInteger() ;
     pr.println(2 * g - r) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     pr := Printer.newPrinter(OclFile["System.out"]) ; 
    execute solve() ; 
    pr.close() ; 
    skip ; 
 );
  static class Printer extends OclFile {
   static operation newPrinter( out : OclFile) : Printer
  pre: true
  post: true
  activity:
  ( var self : Printer ;
    self := createPrinter();
    self.initialise(out);
    return self );
  operation initialise( out : OclFile) : void
  pre: true  post: true
  activity: (     execute super(out) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int r=sc.nextInt();
    int g=sc.nextInt();
    int result=g*2-r ;
    System.out.println(result);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var g : int ; g := sc.getCurrent()->toInteger() ;
    var result : int ; result := g * 2 - r ;
    OclFile["System.out"].println(result) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A376_Lever_Round221 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s ;
    s=sc.nextLine();
    sc.close();
    int part=s.indexOf("^");
    long left=0 ;
    long right=0 ;
    for(int i=0 ; i<part ; i++){
      if(s.charAt(i)<='9' && s.charAt(i)>='1'){
        left+=(part-i)*(s.charAt(i)-'0');
      }
    }
    for(int j=part+1 ; j<s.length(); j++){
      if(s.charAt(j)<='9' && s.charAt(j)>='1'){
        right+=(j-part)*(s.charAt(j)-'0');
      }
    }
    if(left==right){
      System.out.println("balance");
    }
    else if(left<right){
      System.out.println("right");
    }
    else if(right<left){
      System.out.println("left");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A376_Lever_Round221 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ;
    s := sc.nextLine() ; 
    skip ; 
    var part : int ; part := s->indexOf("^")-1 ;
    var left : long ; left := 0 ;
    var right : long ; right := 0 ;
        var i : int ; i := 0 ; while i < part do ( (     if (s->at(i+1) <= '9' & s->at(i+1) >= '1') then (     left := left+(((part)->char2byte() - i) * (s->at(i+1) - ('0')->char2byte())) ) else skip )  ;     i := i + 1 ) ; 
        var j : int ; j := part + 1 ; while j < s->size() do ( (     if (s->at(j+1) <= '9' & s->at(j+1) >= '1') then (     right := right+((j - (part)->char2byte()) * (s->at(j+1) - ('0')->char2byte())) ) else skip )  ;     j := j + 1 ) ; 
    if (left = right) then (     OclFile["System.out"].println("balance") ) else     if (left < right) then (     OclFile["System.out"].println("right") ) else     if (right < left) then (     OclFile["System.out"].println("left") ) else skip ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Deque ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0){
        sc.close();
        break ;
      }
      String[][] conv=new String[n][2];
      for(int i=0 ; i<conv.length ; i++){
        conv[i][0]=sc.next();
        conv[i][1]=sc.next();
      }
      String before=sc.next();
      String after=sc.next();
      Deque<String>deque=new ArrayDeque<String>();
      deque.addLast(before);
      int depth=0 ;
      boolean convertable=false ;
      bfs : while(! deque.isEmpty()){
        depth++;
        int size=deque.size();
        for(int q=0 ; q<size ; q++){
          String poll=deque.pollFirst();
          for(int i=0 ; i<conv.length ; i++){
            String test=poll.replaceAll(conv[i][0],conv[i][1]);
            if(test.equals(poll)){
              continue ;
            }
            else if(test.equals(after)){
              convertable=true ;
              break bfs ;
            }
            else if(test.length()<=after.length()){
              deque.addLast(test);
            }
          }
        }
      }
      if(convertable){
        System.out.println(depth);
      }
      else {
        System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     skip ; 
     break ) else skip ; 
    var conv : Sequence(Sequence(String)) ; conv := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(null)) ;
        var i : int ; i := 0 ; while i < conv->size() do ( (     conv[i+1][0+1] := sc.getCurrent() ; 
     conv[i+1][1+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    var before : String ; before := sc.getCurrent() ;
    var after : String ; after := sc.getCurrent() ;
    var deque : Sequence(String) ; deque := ArrayDeque<String>.newArrayDeque() ;
    deque := deque->append(before) ; 
    var depth : int ; depth := 0 ;
    var convertable : boolean ; convertable := false ;
    while (not(deque->isEmpty())) do (     depth := depth + 1 ; 
     var size : int ; size := deque->size() ;
         var q : int ; q := 0 ; while q < size do ( (     var poll : String ; poll := deque->first() ;
         var i : int ; i := 0 ; while i < conv->size() do ( (     var test : String ; test := poll.replaceAllMatches(conv[i+1][0+1], conv[i+1][1+1] ) ;
     if (test = poll) then (     continue ) else     if (test = after) then (     convertable := true ; 
     break ) else     if (test->size() <= after->size()) then (     deque := deque->append(test) ) else skip ; ;  )  ;     i := i + 1 ) )  ;     q := q + 1 ) ) ; 
    if (convertable) then (     OclFile["System.out"].println(depth) ) else (     OclFile["System.out"].println(-1) ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int r=scanner.nextInt(),g=scanner.nextInt();
      System.out.println(g*2-r);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var r : int ; r := scanner.getCurrent()->toInteger() ;
    var g : int ; g := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(g * 2 - r) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    StringBuilder sb=new StringBuilder(s);
    s=s.replace("2017","2018");
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var sb : String ; sb := StringLib.newString(s) ;
    s := s.replace("2017", "2018") ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int Circular(int n){
    int Result=1 ;
    while(n>0){
      Result=Result*n ;
      n--;
    }
    return Result ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(Circular(n-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Circular( n : int) : int
  pre: true
  post: true
  activity: (     var Result : int ; Result := 1 ;
     while (n > 0) do (     Result := Result * n ; 
     n := n - 1 ) ; 
     return Result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(Circular(n - 1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int productDiagonals(int arr[][],int n){
    int product=1 ;
    for(int i=0 ; i<n ; i++){
      product=product*arr[i][i];
      product=product*arr[i][n-i-1];
    }
    if(n % 2==1){
      product=product/arr[n/2][n/2];
    }
    return product ;
  }
  public static void main(String[] args){
    int arr1[][]={
      {
        1,2,3,4 },{
          5,6,7,8 },{
            9,7,4,2 },{
              2,2,2,1 }
            };
            System.out.print(productDiagonals(arr1,4)+"\n");
            int arr2[][]={
              {
                2,1,2,1,2 },{
                  1,2,1,2,1 },{
                    2,1,2,1,2 },{
                      1,2,1,2,1 },{
                        2,1,2,1,2 }
                      };
                      System.out.print(productDiagonals(arr2,5)+"\n");
                    }
                  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation productDiagonals( arr : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     var product : int ; product := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     product := product * arr[i+1][i+1] ; 
     product := product * arr[i+1][n - i - 1+1] )  ;     i := i + 1 ) ; 
     if (n mod 2 = 1) then (     product := product / arr[n / 2+1][n / 2+1] ) else skip ; 
     return product );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(Sequence(int)) ; arr1 := Sequence{Sequence{1,2,3,4},Sequence{5,6,7,8},Sequence{9,7,4,2},Sequence{2,2,2,1}} ;
     OclFile["System.out"].print(productDiagonals(arr1, 4) + "\n") ; 
     var arr2 : Sequence(Sequence(int)) ; arr2 := Sequence{Sequence{2,1,2,1,2},Sequence{1,2,1,2,1},Sequence{2,1,2,1,2},Sequence{1,2,1,2,1},Sequence{2,1,2,1,2}} ;
     OclFile["System.out"].print(productDiagonals(arr2, 5) + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      int map[]=new int[10];
      for(int i=0 ; i<n ; i++){
        map[sc.nextInt()]++;
      }
      for(int i=0 ; i<10 ; i++){
        String ans="-" ;
        if(map[i]!=0){
          char[] ch=new char[map[i] ];
          Arrays.fill(ch,'*');
          ans=new String(ch);
        }
        System.out.println(ans);
      }
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var map : Sequence(int) ; map := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     map[sc.getCurrent()->toInteger()+1] := map[sc.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 10 do ( (     var ans : String ; ans := "-" ;
     if (map[i+1] /= 0) then (     var ch : Sequence(String) ; ch := Integer.subrange(1,map[i+1])->collect(0) ;
     ch := ch->collect('*') ; 
     ans := StringLib.newString(ch) ) else skip ; 
     OclFile["System.out"].println(ans) )  ;     i := i + 1 ) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(true){
      int icegauretakazu=stdIn.nextInt();
      if(icegauretakazu==0){
        break ;
      }
      int[] uretaice=new int[icegauretakazu];
      int[] kakuicenouretakazu=new int[10];
      for(int i=0 ; i<icegauretakazu ; i++){
        uretaice[i]=stdIn.nextInt();
      }
      for(int i=0 ; i<uretaice.length ; i++){
        switch(uretaice[i]){
          case 0 : kakuicenouretakazu[0]++;
          break ;
          case 1 : kakuicenouretakazu[1]++;
          break ;
          case 2 : kakuicenouretakazu[2]++;
          break ;
          case 3 : kakuicenouretakazu[3]++;
          break ;
          case 4 : kakuicenouretakazu[4]++;
          break ;
          case 5 : kakuicenouretakazu[5]++;
          break ;
          case 6 : kakuicenouretakazu[6]++;
          break ;
          case 7 : kakuicenouretakazu[7]++;
          break ;
          case 8 : kakuicenouretakazu[8]++;
          break ;
          case 9 : kakuicenouretakazu[9]++;
          break ;
        }
      }
      for(int i=0 ; i<10 ; i++){
        if(kakuicenouretakazu[i]!=0){
          for(int j=0 ; j<kakuicenouretakazu[i]; j++){
            System.out.print('*');
          }
        }
        else {
          System.out.print('-');
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var icegauretakazu : int ; icegauretakazu := stdIn.getCurrent()->toInteger() ;
     if (icegauretakazu = 0) then (     break ) else skip ; 
    var uretaice : Sequence(int) ; uretaice := Integer.subrange(1,icegauretakazu)->collect(0) ;
    var kakuicenouretakazu : Sequence(int) ; kakuicenouretakazu := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < icegauretakazu do ( (     uretaice[i+1] := stdIn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < uretaice->size() do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (uretaice[i+1]) ; 
       if _switchval = 0 then
     kakuicenouretakazu[0+1] := kakuicenouretakazu[0+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 1 then
     kakuicenouretakazu[1+1] := kakuicenouretakazu[1+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 2 then
     kakuicenouretakazu[2+1] := kakuicenouretakazu[2+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 3 then
     kakuicenouretakazu[3+1] := kakuicenouretakazu[3+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 4 then
     kakuicenouretakazu[4+1] := kakuicenouretakazu[4+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 5 then
     kakuicenouretakazu[5+1] := kakuicenouretakazu[5+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 6 then
     kakuicenouretakazu[6+1] := kakuicenouretakazu[6+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 7 then
     kakuicenouretakazu[7+1] := kakuicenouretakazu[7+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 8 then
     kakuicenouretakazu[8+1] := kakuicenouretakazu[8+1] + 1 ; 
    break 
   else skip ;
       if _switchval = 9 then
     kakuicenouretakazu[9+1] := kakuicenouretakazu[9+1] + 1 ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 10 do ( (     if (kakuicenouretakazu[i+1] /= 0) then (         var j : int ; j := 0 ; while j < kakuicenouretakazu[i+1] do ( (     OclFile["System.out"].print('*') )  ;     j := j + 1 ) ) else (     OclFile["System.out"].print('-') ) ;  
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  final static char ASTER_='*' ;
  final static char HYPHEN='-' ;
  final static char RETURN='\n' ;
  final static int KINDS=10 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    StringBuilder sb=new StringBuilder();
    while((line=br.readLine())!=null){
      if(line.isEmpty()){
        continue ;
      }
      int[] ices=new int[KINDS];
      int n=Integer.parseInt(line);
      if(n==0){
        break ;
      }
      for(int i=0 ; i<n ; ++i){
++ices[Integer.parseInt(br.readLine())];
      }
      for(int i=0 ; i<KINDS ; ++i){
        if(ices[i]>0){
          for(int j=0 ; j<ices[i]; ++j){
            sb.append(ASTER_);
          }
        }
        else {
          sb.append(HYPHEN);
        }
        sb.append(RETURN);
      }
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ASTER_ : String := '*';
  static   attribute HYPHEN : String := '-';
  static   attribute RETURN : String := '
';
  static   attribute KINDS : int := 10;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
    var sb : String ; sb := StringLib.newString() ;
        line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->isEmpty()) then (     continue ) else skip ; 
     var ices : Sequence(int) ; ices := Integer.subrange(1,KINDS)->collect(0) ;
    var n : int ; n := (line)->toInteger() ;
    if (n = 0) then (     break ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     ices[(br.readLine())->toInteger()+1] := ices[(br.readLine())->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < KINDS do ( (     if (ices[i+1] > 0) then (         var j : int ; j := 0 ; while j < ices[i+1] do ( (     sb := sb + StringLib.newString(ASTER_) )  ;     j := j + 1 ) ) else (     sb := sb + StringLib.newString(HYPHEN) ) ;  
     sb := sb + StringLib.newString(RETURN) )  ;     i := i + 1 ) ; 
 ) ;     line := br.readLine() ;
 ) ;  
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] a=new int[10];
      for(int i=0 ; i<n ; i++){
        a[sc.nextInt()]++;
      }
      for(int i=0 ; i<10 ; i++){
        if(a[i]==0)System.out.println("-");
        else {
          for(int j=0 ; j<a[i]; j++){
            System.out.print("*");
          }
          System.out.println();
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[sc.getCurrent()->toInteger()+1] := a[sc.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 10 do ( (     if (a[i+1] = 0) then     OclFile["System.out"].println("-") ; else (         var j : int ; j := 0 ; while j < a[i+1] do ( (     OclFile["System.out"].print("*") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() ) )  ;     i := i + 1 ) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    final int END=0,KIND=10 ;
    int n ;
    int[] cnt ;
    String ret ;
    Scanner sc=new Scanner(System.in);
    while(true){
      n=sc.nextInt();
      if(n==END){
        break ;
      }
      cnt=new int[KIND];
      while(n-->0){
        cnt[sc.nextInt()]++;
      }
      for(int i=0 ; i<KIND ; i++){
        ret="" ;
        if(cnt[i]==0){
          ret="-" ;
        }
        else {
          for(int j=0 ; j<cnt[i]; j++){
            ret+="*" ;
          }
        }
        System.out.println(ret);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var END : int ; END := 0 ;
    var KIND : int ; KIND := 10 ;
     var n : int ;
    var cnt : Sequence(int) ;
    var ret : String ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (true) do (     n := sc.getCurrent()->toInteger() ; 
     if (n = END) then (     break ) else skip ; 
    cnt := Integer.subrange(1,KIND)->collect(0) ; 
        while (n > 0) do (        n := n - 1 ;     skip ; (     cnt[sc.getCurrent()->toInteger()+1] := cnt[sc.getCurrent()->toInteger()+1] + 1 ) ;  ) ;  
        var i : int ; i := 0 ; while i < KIND do ( (     ret := "" ; 
     if (cnt[i+1] = 0) then (     ret := "-" ) else (         var j : int ; j := 0 ; while j < cnt[i+1] do ( (     ret := ret+("*") )  ;     j := j + 1 ) ) ;  
     OclFile["System.out"].println(ret) )  ;     i := i + 1 ) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static final int NO_OF_CHARS=256 ;
  static char getSecondMostFreq(String str){
    int[] count=new int[NO_OF_CHARS];
    int i ;
    for(i=0 ; i<str.length(); i++)(count[str.charAt(i)])++;
    int first=0,second=0 ;
    for(i=0 ; i<NO_OF_CHARS ; i++){
      if(count[i]>count[first]){
        second=first ;
        first=i ;
      }
      else if(count[i]>count[second] && count[i]!=count[first])second=i ;
    }
    return(char)second ;
  }
  public static void main(String args[]){
    String str="geeksforgeeks" ;
    char res=getSecondMostFreq(str);
    if(res!='\0')System.out.println("Second most frequent char"+" is "+res);
    else System.out.println("No second most frequent"+"character");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute NO_OF_CHARS : int := 256;
  static   operation getSecondMostFreq( str : String) : String
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,NO_OF_CHARS)->collect(0) ;
     var i : int ;
        i := 0 ; while i < str->size() do (     (count[str->at(i+1)+1]) := (count[str->at(i+1)+1]) + 1 ;  ;     i := i + 1 ) ; 
    var first : int ; first := 0 ;
    var second : int ; second := 0 ;
        i := 0 ; while i < NO_OF_CHARS do ( (     if (count[i+1] > count[first+1]) then (     second := first ; 
     first := i ) else     if (count[i+1] > count[second+1] & count[i+1] /= count[first+1]) then     second := i ; else skip ; )  ;     i := i + 1 ) ; 
    return second->oclAsType(String) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var res : String ; res := getSecondMostFreq(str) ;
     if (res /= '\0') then     OclFile["System.out"].println("Second most frequent char" + " is " + res) ; else     OclFile["System.out"].println("No second most frequent" + "character") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Map.Entry ;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  int n ;
  HashMap<String,String>map=new HashMap<String,String>();
  String start,end ;
  int ans ;
  void run(){
    for(; ; ){
      n=sc.nextInt();
      if(n==0){
        break ;
      }
      map.clear();
      for(int i=0 ; i<n ; i++){
        String s=sc.next();
        String t=sc.next();
        map.put(s,t);
      }
      start=sc.next();
      end=sc.next();
      ans=-1 ;
      dfs(start,0);
      println(""+ans);
    }
  }
  void dfs(String s,int r){
    if(r>=ans && r>=10){
      return ;
    }
    else if(s.length()>end.length()){
      return ;
    }
    else if(s.equals(end)){
      if(ans==-1 || r<ans){
        ans=r ;
      }
      return ;
    }
    for(Entry<String,String>entry : map.entrySet()){
      if(s.contains(entry.getKey())){
        String t=s.replaceAll(entry.getKey(),entry.getValue());
        dfs(t,r+1);
      }
    }
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   attribute n : int;
   attribute map : Map(String,String) := Map{};
   attribute start : String;
   attribute ans : int;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then (     break ) else skip ; 
    map := map->intersection(Map{}) ; 
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
     var t : String ; t := sc.getCurrent() ;
     map := map->union(Map{s |-> t}) )  ;     i := i + 1 ) ; 
    start := sc.getCurrent() ; 
    end := sc.getCurrent() ; 
    ans := -1 ; 
    execute dfs(start, 0) ; 
    execute println("" + ans) ; 
 )  ) );
   operation dfs( s : String, r : int) : void
  pre: true
  post: true
  activity: (     if (r >= ans & r >= 10) then (     return ) else     if (s->size() > end->size()) then (     return ) else     if (s = end) then (     if (ans = -1 or r < ans) then (     ans := r ) else skip ; 
     return ) else skip ; ;  ;  
     for (entry : map->asSet()) do ( (     if (s->includes(entry.getKey())) then (     var t : String ; t := s.replaceAllMatches(entry.getKey(), entry.getValue() ) ;
     execute dfs(t, r + 1) ) else skip )  ) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int[][] dp=new int[5][4001];
    dp[0][0]=1 ;
    for(int i=1 ; i<5 ; i++){
      for(int ii=0 ; ii<=1000*i ; ii++){
        for(int iii=Math.max(0,ii-1000); iii<=ii ; iii++){
          dp[i][ii]+=dp[i-1][iii];
        }
      }
    }
    while(sc.hasNext()){
      System.out.println(dp[4][sc.nextInt()]);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,5)->collect(Integer.subrange(1,4001)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i < 5 do ( (         var ii : int ; ii := 0 ; while ii <= 1000 * i do ( (         var iii : int ; iii := Set{0, ii - 1000}->max() ; while iii <= ii do ( (     dp[i+1][ii+1] := dp[i+1][ii+1]+(dp[i - 1+1][iii+1]) )  ;     iii := iii + 1 ) )  ;     ii := ii + 1 ) )  ;     i := i + 1 ) ; 
    while (sc.hasNext()) do (     OclFile["System.out"].println(dp[4+1][sc.getCurrent()->toInteger()+1]) ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public void solve()throws IOException {
    long[][] dp=new long[5][4001];
    dp[0][0]=1 ;
    for(int i=1 ; i<5 ; i++){
      for(int j=0 ; j<=4000 ; j++){
        if(dp[i-1][j]>0){
          for(int k=0 ; k<=1000 && j+k<=4000 ; k++){
            dp[i][j+k]+=dp[i-1][j];
          }
        }
      }
    }
    while(stdIn.hasNext()){
      int n=stdIn.nextInt();
      writer.println(dp[4][n]);
    }
    writer.flush();
  }
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  Scanner stdIn ;
  BufferedReader reader ;
  StringTokenizer tokenizer ;
  PrintWriter writer ;
  public void run()throws IOException {
    try {
      reader=new BufferedReader(new InputStreamReader(System.in));
      stdIn=new Scanner(reader);
      tokenizer=null ;
      writer=new PrintWriter(System.out);
      solve();
      stdIn.close();
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  public String nextToken()throws IOException {
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,5)->collect(Integer.subrange(1,4001)->collect(0)) ;
     dp[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i < 5 do ( (         var j : int ; j := 0 ; while j <= 4000 do ( (     if (dp[i - 1+1][j+1] > 0) then (         var k : int ; k := 0 ; while k <= 1000 & j + k <= 4000 do ( (     dp[i+1][j + k+1] := dp[i+1][j + k+1]+(dp[i - 1+1][j+1]) )  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    while (stdIn.hasNext()) do (     var n : int ; n := stdIn.nextInt() ;
     writer.println(dp[4+1][n+1]) ) ; 
    writer.flush() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute stdIn : OclFile;
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   attribute writer : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     try (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     stdIn := OclFile.newOclFile_Read(reader) ; 
    tokenizer := null ; 
    writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.NoSuchElementException ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner sc=new FastScanner();
    String s=sc.next();
    String[] as=s.split("/");
    String ans="2018/"+as[1]+"/"+as[2];
    System.out.println(ans);
  }
}
class FastScanner {
  private static final InputStream in=System.in ;
  private static final PrintWriter out=new PrintWriter(System.out);
  private final byte[] buffer=new byte[2048];
  private int p=0 ;
  private int buflen=0 ;
  public FastScanner(){
  }
  private boolean hasNextByte(){
    if(p<buflen){
      return true ;
    }
    p=0 ;
    try {
      buflen=in.read(buffer);
    }
    catch(IOException e){
      e.printStackTrace();
    }
    if(buflen<=0){
      return false ;
    }
    return true ;
  }
  public boolean hasNext(){
    while(hasNextByte()&& ! isPrint(buffer[p])){
      p++;
    }
    return hasNextByte();
  }
  private boolean isPrint(int ch){
    if(ch>='!' && ch<='~'){
      return true ;
    }
    return false ;
  }
  private int nextByte(){
    if(! hasNextByte()){
      return-1 ;
    }
    return buffer[p++];
  }
  public String next(){
    if(! hasNext()){
      throw new NoSuchElementException();
    }
    StringBuilder sb=new StringBuilder();
    int b=-1 ;
    while(isPrint((b=nextByte()))){
      sb.appendCodePoint(b);
    }
    return sb.toString();
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
  public double nextDouble(){
    return Double.parseDouble(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner() ;
     var s : String ; s := sc.next() ;
    var as : Sequence(String) ; as := s->split("/") ;
    var ans : String ; ans := "2018/" + as[1+1] + "/" + as[2+1] ;
    OclFile["System.out"].println(ans) ; 
 );
}
class FastScanner {
  static    attribute in : OclFile := OclFile["System.in"];
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   attribute buffer : Sequence(int) := Integer.subrange(1,2048)->collect(0);
   attribute p : int := 0;
   attribute buflen : int := 0;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   operation hasNextByte() : boolean
  pre: true
  post: true
  activity: (     if (p < buflen) then (     return true ) else skip ; 
     p := 0 ; 
    try (     buflen := in.read(buffer) )   catch (e : IOException) do (     e.printStackTrace() )
    if (buflen <= 0) then (     return false ) else skip ; 
    return true 
 );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (hasNextByte() & not(isPrint(buffer[p+1]))) do (     p := p + 1 ) ; 
     return hasNextByte() );
   operation isPrint( ch : int) : boolean
  pre: true
  post: true
  activity: (     if (ch >= '!' & ch <= '~') then (     return true ) else skip ; 
     return false );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     if (not(hasNextByte())) then (     return -1 ) else skip ; 
     return buffer[p+1] );
   operation next() : String
  pre: true
  post: true
  activity: (     if (not(hasNext())) then (     error IncorrectElementException() ) else skip ; 
     var sb : String ; sb := StringLib.newString() ;
    var b : int ; b := -1 ;
    while (isPrint((b))) do (     sb.appendCodePoint(b) ) ; 
    return sb+"" 
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static int dfs(int rest,int remain,int[][] memo){
    if(memo[rest][remain]!=-1){
      return memo[rest][remain];
    }
    else if(rest==0){
      return remain==0 ? 1 : 0 ;
    }
    int ret=0 ;
    final int limit=Math.min(1000,remain);
    for(int cur=0 ; cur<=limit ; cur++){
      ret+=dfs(rest-1,remain-cur,memo);
    }
    return memo[rest][remain]=ret ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[][] memo=new int[5][4001];
    for(int i=0 ; i<5 ; i++){
      if(i==0){
        memo[0][0]=1 ;
      }
      else {
        Arrays.fill(memo[i],-1);
      }
    }
    while(sc.hasNextInt()){
      final int n=sc.nextInt();
      System.out.println(dfs(4,n,memo));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation dfs( rest : int, remain : int, memo : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     if (memo[rest+1][remain+1] /= -1) then (     return memo[rest+1][remain+1] ) else     if (rest = 0) then (     return if remain = 0 then 1 else 0 endif ) else skip ; ;  
     var ret : int ; ret := 0 ;
    var limit : int ; limit := Set{1000, remain}->min() ;
        var cur : int ; cur := 0 ; while cur <= limit do ( (     ret := ret+(dfs(rest - 1, remain - cur, memo)) )  ;     cur := cur + 1 ) ; 
    return memo[rest+1][remain+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var memo : Sequence(Sequence(int)) ; memo := Integer.subrange(1,5)->collect(Integer.subrange(1,4001)->collect(0)) ;
         var i : int ; i := 0 ; while i < 5 do ( (     if (i = 0) then (     memo[0+1][0+1] := 1 ) else (     memo[i+1] := memo[i+1]->collect(-1) ) )  ;     i := i + 1 ) ; 
     while (sc.hasNextInt()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(dfs(4, n, memo)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  static void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; sc.hasNext(); ){
      int n=sc.nextInt();
      int[] count=new int[2001];
      for(int i=0 ; i<=1000 ; i++){
        for(int j=0 ; j<=1000 ; j++){
          count[i+j]++;
        }
      }
      int ans=0 ;
      for(int i=0 ; i<=1000 ; i++){
        for(int j=0 ; j<=1000 ; j++){
          if(n-i-j>=0 && n-i-j<=2000){
            ans+=count[n-i-j];
          }
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
  static   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var count : Sequence(int) ; count := Integer.subrange(1,2001)->collect(0) ;
        var i : int ; i := 0 ; while i <= 1000 do ( (         var j : int ; j := 0 ; while j <= 1000 do ( (     count[i + j+1] := count[i + j+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i <= 1000 do ( (         var j : int ; j := 0 ; while j <= 1000 do ( (     if (n - i - j >= 0 & n - i - j <= 2000) then (     ans := ans+(count[n - i - j+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    int map[]=new int[2001];
    int num=-1 ;
    for(int a=0 ; a<=1000 ; a++){
      for(int b=0 ; b<=1000 ; b++){
        map[a+b]++;
      }
    }
    while((num=parseNum())!=-1){
      long cnt=0 ;
      for(int a=0 ; a<=2000 ; a++){
        if(a>num){
          break ;
        }
        for(int b=0 ; b<=2000 ; b++){
          if(a+b==num){
            cnt+=(long)map[a]*(long)map[b];
          }
          else if(a+b>num || num-a>2000){
            break ;
          }
        }
      }
      System.out.println(cnt);
    }
  }
  private static int parseNum(){
    int param=-1 ;
    String strin=null ;
    if((strin=parseStdin())!=null){
      param=Integer.parseInt(strin);
    }
    return param ;
  }
  private static String parseStdin(){
    String stdin=null ;
    try {
      String tmp=br.readLine();
      if(tmp!=null){
        if(! tmp.isEmpty()){
          stdin=tmp ;
        }
      }
    }
    catch(IOException e){
    }
    return stdin ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var map : Sequence(int) ; map := Integer.subrange(1,2001)->collect(0) ;
     var num : int ; num := -1 ;
         var a : int ; a := 0 ; while a <= 1000 do ( (         var b : int ; b := 0 ; while b <= 1000 do ( (     map[a + b+1] := map[a + b+1] + 1 )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
         num := parseNum() ;
    while ((num) /= -1) do (    skip ; (     var cnt : long ; cnt := 0 ;
         var a : int ; a := 0 ; while a <= 2000 do ( (     if (a > num) then (     break ) else skip ; 
         var b : int ; b := 0 ; while b <= 2000 do ( (     if (a + b = num) then (     cnt := cnt+(map[a+1]->oclAsType(long) * map[b+1]->oclAsType(long)) ) else     if (a + b > num or num - a > 2000) then (     break ) else skip ; )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
     OclFile["System.out"].println(cnt) ) ;     num := parseNum() ;
 ) );
  static   operation parseNum() : int
  pre: true
  post: true
  activity: (     var param : int ; param := -1 ;
     var strin : String ; strin := null ;
     if ((strin) /= null) then (     param := (strin)->toInteger() ) else skip ; 
     return param );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var stdin : String ; stdin := null ;
     try (     var tmp : String ; tmp := br.readLine() ;
     if (tmp /= null) then (     if (not(tmp->isEmpty())) then (     stdin := tmp ) else skip ) else skip )   catch (e : IOException) do skip
     return stdin );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class SortExample {
  static void mySort(Integer[] arr){
    int n=arr.length ;
    Arrays.sort(arr,0,n/2);
    Arrays.sort(arr,n/2,n,Collections.reverseOrder());
  }
  public static void main(String[] args){
    Integer[] arr={
      5,4,6,2,1,3,8,9,7 };
      mySort(arr);
      System.out.printf("Modified arr[] : %s",Arrays.toString(arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class SortExample {
  static   operation mySort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
     arr := arr.subrange(1,0)^(arr.subrange(0+1,n / 2)->sort())^arr.subrange(n / 2+1,arr.size) ; 
     arr, n / 2, n, reverseOrder() := arr, n / 2, n, reverseOrder()->sort() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,4,6,2,1,3,8,9,7} ;
     execute mySort(arr) ; 
     OclFile["System.out"].printf("Modified arr[] : %s", (arr + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int minflip(int[] arr1,int[] arr2,int[] arr3,int p,int q,int n){
    int flip=0 ;
    for(int i=0 ; i<n ; i++)if(arr1[i]>0 ^ arr2[i]>0!=arr3[i]>0)flip++;
    return(flip<=p+q)? flip :-1 ;
  }
  static public void main(String[] args){
    int[] arr1={
      1,0,1,1,1,1,1 };
      int[] arr2={
        0,1,1,1,1,0,0 };
        int[] arr3={
          1,1,1,1,0,0,1 };
          int n=arr1.length ;
          int p=2,q=4 ;
          System.out.println(minflip(arr1,arr2,arr3,p,q,n));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minflip( arr1 : Sequence(int), arr2 : Sequence(int), arr3 : Sequence(int), p : int, q : int, n : int) : int
  pre: true
  post: true
  activity: (     var flip : int ; flip := 0 ;
         var i : int ; i := 0 ; while i < n do (     if (arr1[i+1] > 0 xor arr2[i+1] > 0 /= arr3[i+1] > 0) then     flip := flip + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return if (flip <= p + q) then flip else -1 endif );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{1,0,1,1,1,1,1} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{0,1,1,1,1,0,0} ;
    var arr3 : Sequence(int) ; arr3 := Sequence{1,1,1,1,0,0,1} ;
    var n : int ; n := arr1->size() ;
    var p : int ; p := 2 ;
    var q : int ; q := 4 ;
    OclFile["System.out"].println(minflip(arr1, arr2, arr3, p, q, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double sum(int n){
    double i,s=0.0 ;
    for(i=1 ; i<=n ; i++)s=s+1/i ;
    return s ;
  }
  public static void main(String args[]){
    int n=5 ;
    System.out.printf("Sum is %f",sum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sum( n : int) : double
  pre: true
  post: true
  activity: (     var i : double ;
    var s : double ; s := 0.0 ;
         i := 1 ; while i <= n do (     s := s + 1 / i ;  ;     i := i + 1 ) ; 
     return s );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].printf("Sum is %f", sum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static class Point {
    public double x ;
    public double y ;
    public Point(double x_,double y_){
      x=x_ ;
      y=y_ ;
    }
  }
  public static Point sub(Point p1,Point p2){
    return new Point(p1.x-p2.x,p1.y-p2.y);
  }
  public static double extp(Point p1,Point p2){
    return p1.x*p2.y-p2.x*p1.y ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      Point[] p=new Point[3];
      for(int i=0 ; i<3 ; i++)p[i]=new Point(sc.nextDouble(),sc.nextDouble());
      Point p1=new Point(sc.nextDouble(),sc.nextDouble());
      Point p2=new Point(sc.nextDouble(),sc.nextDouble());
      boolean in1=false ;
      boolean in2=false ;
      boolean right=true ;
      boolean left=true ;
      boolean right2=true ;
      boolean left2=true ;
      for(int i=0 ; i<3 ; i++){
        Point base=sub(p[(i+1)% 3],p[i]);
        Point bec=sub(p1,p[i]);
        Point bec2=sub(p2,p[i]);
        if(extp(base,bec)<0)left=false ;
        else right=false ;
        if(extp(base,bec2)<0)left2=false ;
        else right2=false ;
      }
      in1=left | right ;
      in2=left2 | right2 ;
      System.out.println(in1!=in2 ? "OK" : "NG");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Point {
   attribute x : double;
   attribute y : double;
   static operation newPoint( x_ : double, y_ : double) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x_, y_);
    return self );
  operation initialise( x_ : double, y_ : double) : void
  pre: true  post: true
  activity: (     x := x_ ; 
     y := y_ );
}
  static   operation sub( p1 : Point, p2 : Point) : Point
  pre: true
  post: true
  activity: (     return Point.newPoint(p1.x - p2.x, p1.y - p2.y) );
  static   operation extp( p1 : Point, p2 : Point) : double
  pre: true
  post: true
  activity: (     return p1.x * p2.y - p2.x * p1.y );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var p : Sequence(Point) ; p := Integer.subrange(1,3)->collect(null) ;
         var i : int ; i := 0 ; while i < 3 do (     p[i+1] := Point.newPoint(sc.getCurrent()->toReal(), sc.getCurrent()->toReal()) ;  ;     i := i + 1 ) ; 
    var p1 : Point ; p1 := Point.newPoint(sc.getCurrent()->toReal(), sc.getCurrent()->toReal()) ;
    var p2 : Point ; p2 := Point.newPoint(sc.getCurrent()->toReal(), sc.getCurrent()->toReal()) ;
    var in1 : boolean ; in1 := false ;
    var in2 : boolean ; in2 := false ;
    var right : boolean ; right := true ;
    var left : boolean ; left := true ;
    var right2 : boolean ; right2 := true ;
    var left2 : boolean ; left2 := true ;
        var i : int ; i := 0 ; while i < 3 do ( (     var base : Point ; base := sub(p[(i + 1) mod 3+1], p[i+1]) ;
     var bec : Point ; bec := sub(p1, p[i+1]) ;
    var bec2 : Point ; bec2 := sub(p2, p[i+1]) ;
    if (extp(base, bec) < 0) then     left := false else     right := false ; ;  
    if (extp(base, bec2) < 0) then     left2 := false else     right2 := false ; ;  
 )  ;     i := i + 1 ) ; 
    in1 := left or right ; 
    in2 := left2 or right2 ; 
    OclFile["System.out"].println(if in1 /= in2 then "OK" else "NG" endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  private static int rec(String src,String dst,String[][] ab){
    int result=-1 ;
    if(src.equals(dst)){
      result=0 ;
    }
    else if(src.length()>=dst.length()){
      result=-1 ;
    }
    else {
      for(int i=0 ; i<ab.length ; i++){
        if(src.indexOf(ab[i][0])!=-1){
          int r=rec(src.replaceAll(ab[i][0],ab[i][1]),dst,ab);
          if(r!=-1){
            r++;
          }
          if(result<0 ||(r>0 && r<result)){
            result=r ;
          }
        }
      }
    }
    return result ;
  }
  private static void solve(){
    final Scanner scanner=new Scanner(System.in);
    while(true){
      final int n=scanner.nextInt();
      if(n==0){
        break ;
      }
      String[][] ab=new String[n][2];
      for(int i=0 ; i<n ; i++){
        ab[i][0]=scanner.next();
        ab[i][1]=scanner.next();
      }
      final String src=scanner.next();
      final String dst=scanner.next();
      System.out.println(rec(src,dst,ab));
    }
  }
  public static void main(String...args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation rec( src : String, dst : String, ab : Sequence(Sequence(String))) : int
  pre: true
  post: true
  activity: (     var result : int ; result := -1 ;
     if (src = dst) then (     result := 0 ) else     if (src->size() >= dst->size()) then (     result := -1 ) else (         var i : int ; i := 0 ; while i < ab->size() do ( (     if (src->indexOf(ab[i+1][0+1])-1 /= -1) then (     var r : int ; r := rec(src.replaceAllMatches(ab[i+1][0+1], ab[i+1][1+1] ), dst, ab) ;
     if (r /= -1) then (     r := r + 1 ) else skip ; 
     if (result < 0 or (r > 0 & r < result)) then (     result := r ) else skip ) else skip )  ;     i := i + 1 ) ) ;  ;  
     return result );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var ab : Sequence(Sequence(String)) ; ab := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(null)) ;
        var i : int ; i := 0 ; while i < n do ( (     ab[i+1][0+1] := scanner.getCurrent() ; 
     ab[i+1][1+1] := scanner.getCurrent() )  ;     i := i + 1 ) ; 
    var src : String ; src := scanner.getCurrent() ;
    var dst : String ; dst := scanner.getCurrent() ;
    OclFile["System.out"].println(rec(src, dst, ab)) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Polygon ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    int num=parseNum();
    for(int i=0 ; i<num ; i++){
      solve(parsePos());
    }
  }
  private static void solve(int[][] pos){
    Polygon tri=new Polygon();
    for(int i=0 ; i<3 ; i++){
      tri.addPoint(pos[i][0],pos[i][1]);
    }
    if(tri.contains(pos[3][0],pos[3][1])!=tri.contains(pos[4][0],pos[4][1])){
      System.out.println("OK");
    }
    else {
      System.out.println("NG");
    }
  }
  private static int[][] parsePos(){
    int[][] pos=null ;
    String str=null ;
    if((str=parseStdin())!=null){
      String[] lns=str.split(" ");
      pos=new int[5][2];
      for(int i=0 ; i<pos.length ; i++){
        pos[i][0]=Integer.parseInt(lns[i*2]);
        pos[i][1]=Integer.parseInt(lns[i*2+1]);
      }
    }
    return pos ;
  }
  private static int parseNum(){
    int param=0 ;
    String strin=null ;
    if((strin=parseStdin())!=null){
      param=Integer.parseInt(strin);
    }
    return param ;
  }
  private static String parseStdin(){
    String stdin=null ;
    try {
      String tmp=br.readLine();
      if(tmp!=null){
        if(! tmp.isEmpty()){
          stdin=tmp ;
        }
      }
    }
    catch(IOException e){
    }
    return stdin ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := parseNum() ;
         var i : int ; i := 0 ; while i < num do ( (     execute solve(parsePos()) )  ;     i := i + 1 ) );
  static   operation solve( pos : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var tri : Polygon ; tri := Polygon.newPolygon() ;
         var i : int ; i := 0 ; while i < 3 do ( (     tri.addPoint(pos[i+1][0+1], pos[i+1][1+1]) )  ;     i := i + 1 ) ; 
     if (tri->includes(pos[3+1][0+1], pos[3+1][1+1]) /= tri->includes(pos[4+1][0+1], pos[4+1][1+1])) then (     OclFile["System.out"].println("OK") ) else (     OclFile["System.out"].println("NG") ) );
  static   operation parsePos() : Sequence(Sequence(int))
  pre: true
  post: true
  activity: (     var pos : Sequence(Sequence(int)) ; pos := null ;
     var str : String ; str := null ;
     if ((str) /= null) then (     var lns : Sequence(String) ; lns := str->split(" ") ;
     pos := Integer.subrange(1,5)->collect(Integer.subrange(1,2)->collect(0)) ; 
         var i : int ; i := 0 ; while i < pos->size() do ( (     pos[i+1][0+1] := (lns[i * 2+1])->toInteger() ; 
     pos[i+1][1+1] := (lns[i * 2 + 1+1])->toInteger() )  ;     i := i + 1 ) ) else skip ; 
     return pos );
  static   operation parseNum() : int
  pre: true
  post: true
  activity: (     var param : int ; param := 0 ;
     var strin : String ; strin := null ;
     if ((strin) /= null) then (     param := (strin)->toInteger() ) else skip ; 
     return param );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var stdin : String ; stdin := null ;
     try (     var tmp : String ; tmp := br.readLine() ;
     if (tmp /= null) then (     if (not(tmp->isEmpty())) then (     stdin := tmp ) else skip ) else skip )   catch (e : IOException) do skip
     return stdin );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    while(N-->0){
      double xp1=in.nextDouble(),yp1=in.nextDouble();
      double xp2=in.nextDouble(),yp2=in.nextDouble();
      double xp3=in.nextDouble(),yp3=in.nextDouble();
      double xk=in.nextDouble(),yk=in.nextDouble();
      double xs=in.nextDouble(),ys=in.nextDouble();
      int kabe=0 ;
      if(judge(xp1,yp1,xp2,yp2,xk,yk,xs,ys))kabe++;
      if(judge(xp2,yp2,xp3,yp3,xk,yk,xs,ys))kabe++;
      if(judge(xp3,yp3,xp1,yp1,xk,yk,xs,ys))kabe++;
      System.out.println(kabe==1 ? "OK" : "NG");
    }
  }
  static boolean judge(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4){
    double jc1=(x1-x2)*(y3-y1)+(y1-y2)*(x1-x3);
    double jd1=(x1-x2)*(y4-y1)+(y1-y2)*(x1-x4);
    double jc2=(x3-x4)*(y1-y3)+(y3-y4)*(x3-x1);
    double jd2=(x3-x4)*(y2-y3)+(y3-y4)*(x3-x2);
    return jc1*jd1<0 && jc2*jd2<0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
         while (N > 0) do (        N := N - 1 ;     skip ; (     var xp1 : double ; xp1 := in.getCurrent()->toReal() ;
    var yp1 : double ; yp1 := in.getCurrent()->toReal() ;
     var xp2 : double ; xp2 := in.getCurrent()->toReal() ;
    var yp2 : double ; yp2 := in.getCurrent()->toReal() ;
    var xp3 : double ; xp3 := in.getCurrent()->toReal() ;
    var yp3 : double ; yp3 := in.getCurrent()->toReal() ;
    var xk : double ; xk := in.getCurrent()->toReal() ;
    var yk : double ; yk := in.getCurrent()->toReal() ;
    var xs : double ; xs := in.getCurrent()->toReal() ;
    var ys : double ; ys := in.getCurrent()->toReal() ;
    var kabe : int ; kabe := 0 ;
    if (judge(xp1, yp1, xp2, yp2, xk, yk, xs, ys)) then     kabe := kabe + 1 ; else skip ; 
    if (judge(xp2, yp2, xp3, yp3, xk, yk, xs, ys)) then     kabe := kabe + 1 ; else skip ; 
    if (judge(xp3, yp3, xp1, yp1, xk, yk, xs, ys)) then     kabe := kabe + 1 ; else skip ; 
    OclFile["System.out"].println(if kabe = 1 then "OK" else "NG" endif) ; 
 ) ;  ) );
  static   operation judge( x1 : double, y1 : double, x2 : double, y2 : double, x3 : double, y3 : double, x4 : double, y4 : double) : boolean
  pre: true
  post: true
  activity: (     var jc1 : double ; jc1 := (x1 - x2) * (y3 - y1) + (y1 - y2) * (x1 - x3) ;
     var jd1 : double ; jd1 := (x1 - x2) * (y4 - y1) + (y1 - y2) * (x1 - x4) ;
    var jc2 : double ; jc2 := (x3 - x4) * (y1 - y3) + (y3 - y4) * (x3 - x1) ;
    var jd2 : double ; jd2 := (x3 - x4) * (y2 - y3) + (y3 - y4) * (x3 - x2) ;
    return jc1 * jd1 < 0 & jc2 * jd2 < 0 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.util.*;
public class Main {
  public void doIt(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int[][] tri=new int[4][2];
      for(int j=0 ; j<3 ; j++){
        tri[j][0]=sc.nextInt();
        tri[j][1]=sc.nextInt();
      }
      tri[3][0]=tri[0][0];
      tri[3][1]=tri[0][1];
      int manX=sc.nextInt();
      int manY=sc.nextInt();
      int womanX=sc.nextInt();
      int womanY=sc.nextInt();
      Line2D.Double mAndw=new Line2D.Double(manX,manY,womanX,womanY);
      int intersectCount=0 ;
      for(int j=0 ; j<3 ; j++){
        Line2D.Double triLine=new Line2D.Double(tri[j][0],tri[j][1],tri[j+1][0],tri[j+1][1]);
        boolean result=mAndw.intersectsLine(triLine);
        if(result)intersectCount++;
      }
      if((intersectCount & 1)==0)System.out.println("NG");
      else System.out.println("OK");
    }
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var tri : Sequence(Sequence(int)) ; tri := Integer.subrange(1,4)->collect(Integer.subrange(1,2)->collect(0)) ;
         var j : int ; j := 0 ; while j < 3 do ( (     tri[j+1][0+1] := sc.getCurrent()->toInteger() ; 
     tri[j+1][1+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    tri[3+1][0+1] := tri[0+1][0+1] ; 
    tri[3+1][1+1] := tri[0+1][1+1] ; 
    var manX : int ; manX := sc.getCurrent()->toInteger() ;
    var manY : int ; manY := sc.getCurrent()->toInteger() ;
    var womanX : int ; womanX := sc.getCurrent()->toInteger() ;
    var womanY : int ; womanY := sc.getCurrent()->toInteger() ;
    var mAndw : Double ; mAndw := Double.newDouble(manX, manY, womanX, womanY) ;
    var intersectCount : int ; intersectCount := 0 ;
        var j : int ; j := 0 ; while j < 3 do ( (     var triLine : Double ; triLine := Double.newDouble(tri[j+1][0+1], tri[j+1][1+1], tri[j + 1+1][0+1], tri[j + 1+1][1+1]) ;
     var result : boolean ; result := mAndw.intersectsLine(triLine) ;
     if (result) then     intersectCount := intersectCount + 1 ; else skip )  ;     j := j + 1 ) ; 
    if ((MathLib.bitwiseAnd(intersectCount,1)) = 0) then     OclFile["System.out"].println("NG") else     OclFile["System.out"].println("OK") ; ;  
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] arr=new int[n];
    int sum=0 ;
    int sum1=0 ;
    int arr1[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
      sum+=arr[i];
    }
    for(int i=0 ; i<n ; i++){
      arr1[i]=in.nextInt();
      sum1+=arr1[i];
    }
    if(sum>=sum1){
      System.out.println("YES");
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
    var sum1 : int ; sum1 := 0 ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr1[i+1] := in.getCurrent()->toInteger() ; 
     sum1 := sum1+(arr1[i+1]) )  ;     i := i + 1 ) ; 
    if (sum >= sum1) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Already solver=new Already();
    solver.readInput();
    solver.solve();
    solver.writeOutput();
  }
  static class Already {
    private String input ;
    private String answer ;
    private Scanner scanner ;
    public Already(){
      scanner=new Scanner(System.in);
    }
    public void readInput(){
      input=scanner.next();
    }
    public void solve(){
      answer=input.replace("2017","2018");
    }
    public void writeOutput(){
      System.out.println(answer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var solver : Already ; solver := Already.newAlready() ;
     solver.readInput() ; 
     solver.solve() ; 
     solver.writeOutput() );
  static class Already {
   attribute input : String;
   attribute answer : String;
   attribute scanner : OclFile;
   static operation newAlready() : Already
  pre: true
  post: true
  activity:
  ( var self : Already ;
    self := createAlready();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation readInput() : void
  pre: true
  post: true
  activity: (     input := scanner.getCurrent() );
   operation solve() : void
  pre: true
  post: true
  activity: (     answer := input.replace("2017", "2018") );
   operation writeOutput() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(answer) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Path2D ;
import java.awt.geom.Point2D ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    while(n-->0){
      Point2D.Double[] points=new Point2D.Double[5];
      for(int i=0 ; i<5 ; i++){
        points[i]=new Point2D.Double(scanner.nextDouble(),scanner.nextDouble());
      }
      Path2D.Double path=new Path2D.Double();
      path.moveTo(points[0] .x,points[0] .y);
      path.lineTo(points[1] .x,points[1] .y);
      path.lineTo(points[2] .x,points[2] .y);
      if((path.contains(points[3])&& path.contains(points[4]))|| ! path.contains(points[3])&& ! path.contains(points[4])){
        System.out.println("NG");
      }
      else {
        System.out.println("OK");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var points : Sequence(Double) ; points := Integer.subrange(1,5)->collect(null) ;
         var i : int ; i := 0 ; while i < 5 do ( (     points[i+1] := Double.newDouble(scanner.getCurrent()->toReal(), scanner.getCurrent()->toReal()) )  ;     i := i + 1 ) ; 
    var path : Double ; path := Double.newDouble() ;
    path.moveTo(points[0+1].x, points[0+1].y) ; 
    path.lineTo(points[1+1].x, points[1+1].y) ; 
    path.lineTo(points[2+1].x, points[2+1].y) ; 
    if ((path->includes(points[3+1]) & path->includes(points[4+1])) or not(path->includes(points[3+1])) & not(path->includes(points[4+1]))) then (     OclFile["System.out"].println("NG") ) else (     OclFile["System.out"].println("OK") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void bitonicGenerator(int arr[],int n){
    Vector<Integer>evenArr=new Vector<Integer>();
    Vector<Integer>oddArr=new Vector<Integer>();
    for(int i=0 ; i<n ; i++){
      if(i % 2!=1){
        evenArr.add(arr[i]);
      }
      else {
        oddArr.add(arr[i]);
      }
    }
    Collections.sort(evenArr);
    Collections.sort(oddArr,Collections.reverseOrder());
    int i=0 ;
    for(int j=0 ; j<evenArr.size(); j++){
      arr[i++]=evenArr.get(j);
    }
    for(int j=0 ; j<oddArr.size(); j++){
      arr[i++]=oddArr.get(j);
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,5,8,9,6,7,3,4,2,0 };
      int n=arr.length ;
      bitonicGenerator(arr,n);
      for(int i=0 ; i<n ; i++){
        System.out.print(arr[i]+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation bitonicGenerator( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var evenArr : Sequence(int) ; evenArr := Sequence{} ;
     var oddArr : Sequence(int) ; oddArr := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 /= 1) then (     evenArr := evenArr->including(arr[i+1]) ) else (     oddArr := oddArr->including(arr[i+1]) ) )  ;     i := i + 1 ) ; 
    evenArr := evenArr->sort() ; 
    oddArr, reverseOrder() := oddArr, reverseOrder()->sort() ; 
    var i : int ; i := 0 ;
        var j : int ; j := 0 ; while j < evenArr->size() do ( (      arr[i+1] := evenArr->at(j+1)  ; i := i + 1 )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < oddArr->size() do ( (      arr[i+1] := oddArr->at(j+1)  ; i := i + 1 )  ;     j := j + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,8,9,6,7,3,4,2,0} ;
     var n : int ; n := arr->size() ;
     execute bitonicGenerator(arr, n) ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countPairs(int arr[],int n){
    int count=0 ;
    int right=0,left=0 ;
    boolean visited[]=new boolean[n];
    for(int i=0 ; i<n ; i++)visited[i]=false ;
    while(right<n){
      while(right<n && ! visited[arr[right] ]){
        count+=(right-left);
        visited[arr[right] ]=true ;
        right++;
      }
      while(left<right &&(right!=n && visited[arr[right] ])){
        visited[arr[left] ]=false ;
        left++;
      }
    }
    return count ;
  }
  public static void main(String args[]){
    int arr[]={
      1,4,2,4,3,2 };
      int n=arr.length ;
      System.out.println(countPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var right : int ; right := 0 ;
    var left : int ; left := 0 ;
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n do (     visited[i+1] := false ;  ;     i := i + 1 ) ; 
    while (right < n) do (     while (right < n & not(visited[arr[right+1]+1])) do (     count := count+((right - left)) ; 
     visited[arr[right+1]+1] := true ; 
     right := right + 1 ) ; 
     while (left < right & (right /= n & visited[arr[right+1]+1])) do (     visited[arr[left+1]+1] := false ; 
     left := left + 1 ) ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,4,2,4,3,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countPairs(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Solution {
  HashSet<String>trees=new HashSet<>();
  public boolean isSubtree(TreeNode s,TreeNode t){
    String tree1=preorder(s,true);
    String tree2=preorder(t,true);
    return tree1.indexOf(tree2)>=0 ;
  }
  public String preorder(TreeNode t,boolean left){
    if(t==null){
      if(left)return "lnull" ;
      else return "rnull" ;
    }
    return "#"+t.val+" "+preorder(t.left,true)+" "+preorder(t.right,false);
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   attribute trees : Set(String) := Set{};
   operation isSubtree( s : TreeNode, t : TreeNode) : boolean
  pre: true
  post: true
  activity: (     var tree1 : String ; tree1 := preorder(s, true) ;
     var tree2 : String ; tree2 := preorder(t, true) ;
     return tree1->indexOf(tree2)-1 >= 0 );
   operation preorder( t : TreeNode, left : boolean) : String
  pre: true
  post: true
  activity: (     if (t = null) then (     if (left) then     return "lnull" else     return "rnull" ) else skip ; 
     return "#" + t.val + " " + preorder(t.left, true) + " " + preorder(t.right, false) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int M=1001 ;
  static int MOD=998244353 ;
  static int[][] dp=new int[M][M];
  static int solve(int idx,int diff,int N,int M,int K){
    if(idx>N){
      if(diff==K)return 1 ;
      return 0 ;
    }
    if(dp[idx][diff]!=-1)return dp[idx][diff];
    int ans=solve(idx+1,diff,N,M,K);
    ans+=(M-1)*solve(idx+1,diff+1,N,M,K);
    return dp[idx][diff]=ans % MOD ;
  }
  public static void main(String[] args){
    int N=3,M=3,K=0 ;
    for(int i=0 ; i<=M ; i++)for(int j=0 ; j<=M ; j++)dp[i][j]=-1 ;
    System.out.println((M*solve(2,0,N,M,K)));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute M : int := 1001;
  static   attribute MOD : int := 998244353;
  static   attribute dp : Sequence(Sequence(int)) := Integer.subrange(1,M)->collect(Integer.subrange(1,M)->collect(0));
  static   operation solve( idx : int, diff : int, N : int, M : int, K : int) : int
  pre: true
  post: true
  activity: (     if (idx > N) then (     if (diff = K) then     return 1 else skip ; 
     return 0 ) else skip ; 
     if (dp[idx+1][diff+1] /= -1) then     return dp[idx+1][diff+1] else skip ; 
    var ans : int ; ans := solve(idx + 1, diff, N, M, K) ;
    ans := ans+((M - 1) * solve(idx + 1, diff + 1, N, M, K)) ; 
    return dp[idx+1][diff+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
    var M : int ; M := 3 ;
    var K : int ; K := 0 ;
         var i : int ; i := 0 ; while i <= M do (         var j : int ; j := 0 ; while j <= M do (     dp[i+1][j+1] := -1 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println((M * solve(2, 0, N, M, K))) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  int maxDepth ;
  String goal,cur ;
  HashMap<String,String>dict ;
  String[] rule ;
  int N ;
  Set<String>visited ;
  void run(){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      N=in.nextInt();
      if(N==0)return ;
      dict=new HashMap<String,String>();
      rule=new String[N];
      for(int i=0 ; i<N ; i++){
        rule[i]=in.next();
        dict.put(rule[i],in.next());
      }
      cur=in.next();
      goal=in.next();
      System.out.println(solve());
    }
  }
  int solve(){
    if(cur.equals(goal))return 0 ;
    for(maxDepth=1 ; maxDepth<=100 ; maxDepth++){
      visited=new HashSet<String>();
      if(dfs(0))return maxDepth ;
    }
    return-1 ;
  }
  boolean dfs(int depth){
    if(depth>maxDepth || cur.length()>goal.length()|| visited.contains(cur))return false ;
    if(depth>maxDepth)return false ;
    if(cur.equals(goal))return true ;
    visited.add(cur);
    String tmp=cur.toString();
    for(int i=0 ; i<N ; i++){
      cur=tmp.replaceAll(rule[i],dict.get(rule[i]));
      if(dfs(depth+1))return true ;
    }
    cur=tmp.toString();
    return false ;
  }
  public static void main(String args[]){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute maxDepth : int;
   attribute goal : String;
   attribute dict : Map(String,String);
   attribute rule : Sequence(String);
   attribute N : int;
   attribute visited : Set(String);
   operation run() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     N := in.getCurrent()->toInteger() ; 
     if (N = 0) then     return else skip ; 
    dict := Map{} ; 
    rule := Integer.subrange(1,N)->collect(null) ; 
        var i : int ; i := 0 ; while i < N do ( (     rule[i+1] := in.getCurrent() ; 
     dict := dict->union(Map{rule[i+1] |-> in.getCurrent()}) )  ;     i := i + 1 ) ; 
    cur := in.getCurrent() ; 
    goal := in.getCurrent() ; 
    OclFile["System.out"].println(solve()) ; 
 )  ) );
   operation solve() : int
  pre: true
  post: true
  activity: (     if (cur = goal) then     return 0 else skip ; 
         maxDepth := 1 ; while maxDepth <= 100 do ( (     visited := Set{} ; 
     if (dfs(0)) then     return maxDepth else skip )  ;     maxDepth := maxDepth + 1 ) ; 
     return -1 );
   operation dfs( depth : int) : boolean
  pre: true
  post: true
  activity: (     if (depth > maxDepth or cur->size() > goal->size() or visited->includes(cur)) then     return false else skip ; 
     if (depth > maxDepth) then     return false else skip ; 
    if (cur = goal) then     return true else skip ; 
    visited := visited->including(cur) ; 
    var tmp : String ; tmp := cur+"" ;
        var i : int ; i := 0 ; while i < N do ( (     cur := tmp.replaceAllMatches(rule[i+1], dict->at(rule[i+1]) ) ; 
     if (dfs(depth + 1)) then     return true else skip )  ;     i := i + 1 ) ; 
    cur := tmp+"" ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p222 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p222().run());
  }
  public String run(){
    sphereRadii=new double[21];
    for(int i=0 ; i<sphereRadii.length ; i++)sphereRadii[i]=(i+30)*1000 ;
    minLength=new double[sphereRadii.length][1<<sphereRadii.length];
    double min=Double.POSITIVE_INFINITY ;
    for(int i=0 ; i<sphereRadii.length ; i++)min=Math.min(findMinimumLength(i,(1<<sphereRadii.length)-1)+sphereRadii[i],min);
    return Long.toString(Math.round(min));
  }
  private double[] sphereRadii ;
  private double[][] minLength ;
  private double findMinimumLength(int currentSphereIndex,int setOfSpheres){
    if((setOfSpheres &(1<<currentSphereIndex))==0)throw new IllegalArgumentException();
    if(minLength[currentSphereIndex][setOfSpheres]==0){
      double result ;
      if(Integer.bitCount(setOfSpheres)==1)result=sphereRadii[currentSphereIndex];
      else {
        result=Double.POSITIVE_INFINITY ;
        int newSetOfSpheres=setOfSpheres ^(1<<currentSphereIndex);
        for(int i=0 ; i<sphereRadii.length ; i++){
          if((newSetOfSpheres &(1<<i))==0)continue ;
          double temp=Math.sqrt((sphereRadii[i]+sphereRadii[currentSphereIndex]-50000)*200000);
          temp+=findMinimumLength(i,newSetOfSpheres);
          result=Math.min(temp,result);
        }
      }
      minLength[currentSphereIndex][setOfSpheres]=result ;
    }
    return minLength[currentSphereIndex][setOfSpheres];
  }
}
------------------------------------------------------------
OCL File:
---------
class p222 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p222.newp222().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     sphereRadii := Integer.subrange(1,21)->collect(0.0) ; 
         var i : int ; i := 0 ; while i < sphereRadii->size() do (     sphereRadii[i+1] := (i + 30) * 1000 ;  ;     i := i + 1 ) ; 
    minLength := Integer.subrange(1,sphereRadii->size())->collect(Integer.subrange(1,(1*(2->pow(sphereRadii->size())))->oclAsType(long))->collect(0.0)) ; 
    var min : double ; min := Math_PINFINITY ;
        var i : int ; i := 0 ; while i < sphereRadii->size() do (     min := Set{findMinimumLength(i, ((1*(2->pow(sphereRadii->size())))->oclAsType(long)) - 1) + sphereRadii[i+1], min}->min() ;  ;     i := i + 1 ) ; 
    return (((min)->round()) + "") 
 );
   attribute sphereRadii : Sequence(double);
   attribute minLength : Sequence(Sequence(double));
   operation findMinimumLength( currentSphereIndex : int, setOfSpheres : int) : double
  pre: true
  post: true
  activity: (     if ((setOfSpheres & ((1*(2->pow(currentSphereIndex)))->oclAsType(long))) = 0) then     error IllegalArgumentException.newIllegalArgumentException() ; else skip ; 
     if (minLength[currentSphereIndex+1][setOfSpheres+1] = 0) then (     var result : double ;
     if (bitCount(setOfSpheres) = 1) then     result := sphereRadii[currentSphereIndex+1] else (     result := Math_PINFINITY ; 
     var newSetOfSpheres : int ; newSetOfSpheres := MathLib.bitwiseXor(setOfSpheres,((1*(2->pow(currentSphereIndex)))->oclAsType(long))) ;
         var i : int ; i := 0 ; while i < sphereRadii->size() do ( (     if ((MathLib.bitwiseAnd(newSetOfSpheres,((1*(2->pow(i)))->oclAsType(long)))) = 0) then     continue else skip ; 
     var temp : double ; temp := ((sphereRadii[i+1] + sphereRadii[currentSphereIndex+1] - 50000) * 200000)->sqrt() ;
     temp := temp+(findMinimumLength(i, newSetOfSpheres)) ; 
     result := Set{temp, result}->min() )  ;     i := i + 1 ) ) ;  
     minLength[currentSphereIndex+1][setOfSpheres+1] := result ) else skip ; 
     return minLength[currentSphereIndex+1][setOfSpheres+1] );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String args[]){
    int n ;
    int sides[]=new int[3];
    boolean judge=false ;
    String line ;
    String tmp[];
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      line=reader.readLine();
      n=Integer.parseInt(line);
      for(int i=0 ; i<n ; i++){
        line=reader.readLine();
        tmp=line.split(" ");
        for(int j=0 ; j<sides.length ; j++){
          sides[j]=Integer.parseInt(tmp[j]);
          sides[j]*=sides[j];
        }
        for(int j=0 ; j<sides.length ; j++){
          if(sides[j % 3]==sides[(j+1)% 3]+sides[(j+2)% 3]){
            judge=true ;
            break ;
          }
          else judge=false ;
        }
        Answer(judge);
      }
    }
    catch(IOException e){
      System.exit(0);
    }
  }
  static void Answer(boolean j){
    if(j)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     var sides : Sequence(int) ; sides := Integer.subrange(1,3)->collect(0) ;
    var judge : boolean ; judge := false ;
    var line : String ;
    var tmp : Sequence(String) ;
    var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    try (     line := reader.readLine() ; 
     n := (line)->toInteger() ; 
         var i : int ; i := 0 ; while i < n do ( (     line := reader.readLine() ; 
     tmp := line->split(" ") ; 
        var j : int ; j := 0 ; while j < sides->size() do ( (     sides[j+1] := (tmp[j+1])->toInteger() ; 
     sides[j+1] := sides[j+1]*(sides[j+1]) )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < sides->size() do ( (     if (sides[j mod 3+1] = sides[(j + 1) mod 3+1] + sides[(j + 2) mod 3+1]) then (     judge := true ; 
     break ) else     judge := false ; )  ;     j := j + 1 ) ; 
    execute Answer(judge) ; 
 )  ;     i := i + 1 ) )   catch (e : IOException) do ( OclProcess.exit(0) )
 );
  static   operation Answer( j : boolean) : void
  pre: true
  post: true
  activity: (     if (j) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  private final static String NEGATIVE="NO\n" ;
  private final static String AFFIRMATIVE="YES\n" ;
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in),512);
    int number=Integer.parseInt(br.readLine());
    int sides[]=new int[3];
    StringTokenizer tknz ;
    StringBuilder builder=new StringBuilder();
    for(; 0<number ; number--){
      tknz=new StringTokenizer(br.readLine());
      for(int i=0 ; i<3 ; i++){
        sides[i]=Integer.parseInt(tknz.nextToken());
      }
      Arrays.sort(sides);
      if(sides[0]*sides[1]*sides[2] % 60!=0){
        builder.append(NEGATIVE);
      }
      else if(Math.pow(sides[0],2)+Math.pow(sides[1],2)!=Math.pow(sides[2],2)){
        builder.append(NEGATIVE);
      }
      else {
        builder.append(AFFIRMATIVE);
      }
    }
    System.out.print(builder);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute NEGATIVE : String := "NO\n";
  static   attribute AFFIRMATIVE : String := "YES\n";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 512) ;
     var number : int ; number := (br.readLine())->toInteger() ;
    var sides : Sequence(int) ; sides := Integer.subrange(1,3)->collect(0) ;
    var tknz : OclIterator ;
    var builder : String ; builder := StringLib.newString() ;
      while 0 < number do ( (     tknz := OclIterator.newOclIterator_String(br.readLine()) ; 
         var i : int ; i := 0 ; while i < 3 do ( (     sides[i+1] := (tknz.next())->toInteger() )  ;     i := i + 1 ) ; 
     sides := sides->sort() ; 
     if (sides[0+1] * sides[1+1] * sides[2+1] mod 60 /= 0) then (     builder := builder + StringLib.newString(NEGATIVE) ) else     if (sides[0+1]->pow(2) + sides[1+1]->pow(2) /= sides[2+1]->pow(2)) then (     builder := builder + StringLib.newString(NEGATIVE) ) else (     builder := builder + StringLib.newString(AFFIRMATIVE) ) ;  )  ;     number := number - 1 ) ; 
    OclFile["System.out"].print(builder) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      final int n=sc.nextInt();
      while(sc.hasNext()){
        int[] x=new int[3];
        x[0]=sc.nextInt();
        x[1]=sc.nextInt();
        x[2]=sc.nextInt();
        Arrays.sort(x);
        boolean isTriangle=(x[0]*x[0])+(x[1]*x[1])==(x[2]*x[2]);
        System.out.println(isTriangle ? "YES" : "NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     while (sc.hasNext()) do (     var x : Sequence(int) ; x := Integer.subrange(1,3)->collect(0) ;
     x[0+1] := sc.getCurrent()->toInteger() ; 
    x[1+1] := sc.getCurrent()->toInteger() ; 
    x[2+1] := sc.getCurrent()->toInteger() ; 
    x := x->sort() ; 
    var isTriangle : boolean ; isTriangle := (x[0+1] * x[0+1]) + (x[1+1] * x[1+1]) = (x[2+1] * x[2+1]) ;
    OclFile["System.out"].println(if isTriangle then "YES" else "NO" endif) ; 
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner in=new Scanner(System.in);
    int checkNum=in.nextInt();
    for(int i=0 ; i<checkNum ; i++){
      int a=in.nextInt();
      int b=in.nextInt();
      int c=in.nextInt();
      int tmp=(a+b+c)/2 ;
      double space=Math.sqrt(tmp*(tmp-a)*(tmp-b)*(tmp-c));
      double angleA=0.0 ;
      double angleB=0.0 ;
      double angleC=0.0 ;
      double high=0.0 ;
      if(b<a && c<a){
        high=(2*space)/(double)a ;
        angleB=Math.toDegrees(Math.asin(high/c));
        angleC=Math.toDegrees(Math.asin(high/b));
        angleA=180.0-angleB-angleC ;
      }
      else if(a<b && c<b){
        high=(2*space)/(double)b ;
        angleC=Math.toDegrees(Math.asin(high/a));
        angleA=Math.toDegrees(Math.asin(high/c));
        angleB=180.0-angleA-angleC ;
      }
      else if(a<c && b<c){
        high=(2*space)/(double)c ;
        angleA=Math.toDegrees(Math.asin(high/b));
        angleB=Math.toDegrees(Math.asin(high/a));
        angleC=180.0-angleA-angleB ;
      }
      else {
      }
      if(((int)angleA)==90 ||((int)angleB)==90 ||((int)angleC)==90){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var checkNum : int ; checkNum := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < checkNum do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var tmp : int ; tmp := (a + b + c) / 2 ;
    var space : double ; space := (tmp * (tmp - a) * (tmp - b) * (tmp - c))->sqrt() ;
    var angleA : double ; angleA := 0.0 ;
    var angleB : double ; angleB := 0.0 ;
    var angleC : double ; angleC := 0.0 ;
    var high : double ; high := 0.0 ;
    if (b < a & c < a) then (     high := (2 * space) / a->oclAsType(double) ; 
     angleB := (57.29577951308232*((high / c)->asin())) ; 
     angleC := (57.29577951308232*((high / b)->asin())) ; 
     angleA := 180.0 - angleB - angleC ) else     if (a < b & c < b) then (     high := (2 * space) / b->oclAsType(double) ; 
     angleC := (57.29577951308232*((high / a)->asin())) ; 
     angleA := (57.29577951308232*((high / c)->asin())) ; 
     angleB := 180.0 - angleA - angleC ) else     if (a < c & b < c) then (     high := (2 * space) / c->oclAsType(double) ; 
     angleA := (57.29577951308232*((high / b)->asin())) ; 
     angleB := (57.29577951308232*((high / a)->asin())) ; 
     angleC := 180.0 - angleA - angleB ) else skip ;  ;  ;  
    if ((angleA->oclAsType(int)) = 90 or (angleB->oclAsType(int)) = 90 or (angleC->oclAsType(int)) = 90) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args){
    try {
      BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
      String s=reader.readLine();
      String date=s.substring(4);
      String year="2018" ;
      String ans=year.concat(date);
      System.out.println(ans);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := reader.readLine() ;
    var date : String ; date := s.subrange(4+1,4) ;
    var year : String ; year := "2018" ;
    var ans : String ; ans := year+date ;
    OclFile["System.out"].println(ans) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class Main {
  static InputReader in ;
  static PrintWriter out ;
  static class Solution {
    void solve()throws IOException {
      int N=in.nextInt();
      for(int i=0 ; i<N ; i++){
        int a=in.nextInt();
        int b=in.nextInt();
        int c=in.nextInt();
        if(a*a==b*b+c*c || b*b==c*c+a*a || c*c==a*a+b*b){
          out.println("YES");
        }
        else {
          out.println("NO");
        }
      }
    }
  }
  public static void main(String[] args)throws IOException {
    in=new InputReader(System.in);
    out=new PrintWriter(System.out);
    Solution solver=new Solution();
    solver.solve();
    out.close();
  }
  static class InputReader {
    public BufferedReader br ;
    public StringTokenizer st ;
    public InputReader(InputStream stream){
      br=new BufferedReader(new InputStreamReader(stream));
    }
    public int nextInt()throws IOException {
      while(st==null || ! st.hasMoreTokens()){
        st=new StringTokenizer(br.readLine());
      }
      return Integer.parseInt(st.nextToken());
    }
    public long nextLong()throws IOException {
      while(st==null || ! st.hasMoreTokens()){
        st=new StringTokenizer(br.readLine());
      }
      return Long.parseLong(st.nextToken());
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens()){
        st=new StringTokenizer(br.readLine());
      }
      return st.nextToken();
    }
    public double nextDouble()throws IOException {
      while(st==null || ! st.hasMoreTokens()){
        st=new StringTokenizer(br.readLine());
      }
      return Double.parseDouble(st.nextToken());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : InputReader;
  static   attribute out : OclFile;
  static class Solution {
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.nextInt() ;
         var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := in.nextInt() ;
     var b : int ; b := in.nextInt() ;
     var c : int ; c := in.nextInt() ;
     if (a * a = b * b + c * c or b * b = c * c + a * a or c * c = a * a + b * b) then (     skip ) else (     skip ) )  ;     i := i + 1 ) );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := InputReader.newInputReader(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    var solver : Solution ; solver := Solution.newSolution() ;
    solver.solve() ; 
    skip ; 
 );
  static class InputReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return (st.next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return (st.next())->toLong() );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return (st.next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int getTotalXorOfSubarrayXors(int arr[],int N){
    int res=0 ;
    for(int i=0 ; i<N ; i++){
      int freq=(i+1)*(N-i);
      if(freq % 2==1)res=res ^ arr[i];
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      3,5,2,4,6 };
      int N=arr.length ;
      System.out.println(getTotalXorOfSubarrayXors(arr,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getTotalXorOfSubarrayXors( arr : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     var freq : int ; freq := (i + 1) * (N - i) ;
     if (freq mod 2 = 1) then     res := MathLib.bitwiseXor(res,arr[i+1]) ; else skip )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,5,2,4,6} ;
     var N : int ; N := arr->size() ;
     OclFile["System.out"].println(getTotalXorOfSubarrayXors(arr, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int getTotalXorOfSubarrayXors(int arr[],int N){
    if(N % 2==0)return 0 ;
    int res=0 ;
    for(int i=0 ; i<N ; i+=2)res ^=arr[i];
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      3,5,2,4,6 };
      int N=arr.length ;
      System.out.println(getTotalXorOfSubarrayXors(arr,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getTotalXorOfSubarrayXors( arr : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     if (N mod 2 = 0) then     return 0 else skip ; 
     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < N do (     res := MathLib.bitwiseXor(res,arr[i+1]) ;  ;     i := i+(2) ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,5,2,4,6} ;
     var N : int ; N := arr->size() ;
     OclFile["System.out"].println(getTotalXorOfSubarrayXors(arr, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    double l,p,q ;
    l=input.nextDouble();
    p=input.nextDouble();
    q=input.nextDouble();
    System.out.println((p*l)/(p+q));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : double ;
    var p : double ;
    var q : double ;
    l := input.getCurrent()->toReal() ; 
    p := input.getCurrent()->toReal() ; 
    q := input.getCurrent()->toReal() ; 
    OclFile["System.out"].println((p * l) / (p + q)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    int z=sc.nextInt();
    double s=x/(double)(y+z);
    s*=y ;
    System.out.printf("%.4f",s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var z : int ; z := sc.getCurrent()->toInteger() ;
    var s : double ; s := x / (y + z)->oclAsType(double) ;
    s := s*(y) ; 
    OclFile["System.out"].printf("%.4f", s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int l=in.nextInt();
    int p=in.nextInt();
    int q=in.nextInt();
    System.out.println((float)l/(p+q)*p);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := in.getCurrent()->toInteger() ;
    var p : int ; p := in.getCurrent()->toInteger() ;
    var q : int ; q := in.getCurrent()->toInteger() ;
    OclFile["System.out"].println(l->oclAsType(double) / (p + q) * p) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int A=in.nextInt();
    int B=in.nextInt();
    int D=in.nextInt();
    double C=(double)A/(B+D)*B ;
    System.out.println(C);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := in.getCurrent()->toInteger() ;
    var B : int ; B := in.getCurrent()->toInteger() ;
    var D : int ; D := in.getCurrent()->toInteger() ;
    var C : double ; C := A->oclAsType(double) / (B + D) * B ;
    OclFile["System.out"].println(C) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.HashSet ;
import java.util.Set ;
import java.util.StringTokenizer ;
public class cp_test2 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        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().trim();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  static class FastWriter {
    private final BufferedWriter bw ;
    public FastWriter(){
      this.bw=new BufferedWriter(new OutputStreamWriter(System.out));
    }
    public void print(Object object)throws IOException {
      bw.append(""+object);
    }
    public void println(Object object)throws IOException {
      print(object);
      bw.append("\n");
    }
    public void close()throws IOException {
      bw.close();
    }
  }
  public static void main(String[] args){
    try {
      FastReader in=new FastReader();
      FastWriter out=new FastWriter();
      int l=in.nextInt();
      float hspeed=in.nextInt();
      float hnspeed=in.nextInt();
      float ans=l/(hspeed+hnspeed);
      System.out.println(ans*hspeed);
    }
    catch(Exception e){
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp_test2 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine()->trim() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return str );
}
  static class FastWriter {
   attribute bw : OclFile;
   static operation newFastWriter() : FastWriter
  pre: true
  post: true
  activity:
  ( var self : FastWriter ;
    self := createFastWriter();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) );
   operation print( object : OclAny) : void
  pre: true
  post: true
  activity: (     skip );
   operation println( object : OclAny) : void
  pre: true
  post: true
  activity: (     execute print(object) ; 
     skip );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : FastWriter ; out := FastWriter.newFastWriter() ;
    var l : int ; l := in.nextInt() ;
    var hspeed : double ; hspeed := in.nextInt() ;
    var hnspeed : double ; hnspeed := in.nextInt() ;
    var ans : double ; ans := l / (hspeed + hnspeed) ;
    OclFile["System.out"].println(ans * hspeed) ; 
 )   catch (e : ProgramException) do (     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      int arr[]=new int[2*n];
      for(int i=0 ; i<2*n ; i++){
        arr[i]=sc.nextInt();
      }
      Arrays.sort(arr);
      System.out.println(Math.abs(arr[n]-arr[n-1]));
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,2 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    OclFile["System.out"].println(if arr[n+1] - arr[n - 1+1] < 0 then -(arr[n+1] - arr[n - 1+1]) else arr[n+1] - arr[n - 1+1] endif) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class assigningToClasses1000 {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int inp=sc.nextInt();
    while(inp-->0){
      int n=sc.nextInt();
      int[] stud=new int[2*n];
      for(int i=0 ; i<2*n ; i++){
        stud[i]=sc.nextInt();
      }
      Arrays.sort(stud);
      System.out.println(Math.abs(stud[n-1]-stud[n]));
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class assigningToClasses1000 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inp : int ; inp := sc.getCurrent()->toInteger() ;
         while (inp > 0) do (        inp := inp - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var stud : Sequence(int) ; stud := Integer.subrange(1,2 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     stud[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    stud := stud->sort() ; 
    OclFile["System.out"].println(if stud[n - 1+1] - stud[n+1] < 0 then -(stud[n - 1+1] - stud[n+1]) else stud[n - 1+1] - stud[n+1] endif) ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public Main(){
  }
  public static void main(String[] args){
    new Main().solve();
  }
  private void solve(){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    System.out.println("2018"+s.substring(4));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
     OclFile["System.out"].println("2018" + s.subrange(4+1,4)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class AA {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int p=0 ; p<t ; p++){
      int n=sc.nextInt();
      int[] a=new int[2*n];
      for(int j=0 ; j<2*n ; j++)a[j]=sc.nextInt();
      Arrays.sort(a);
      System.out.println(a[n]-a[n-1]);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class AA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var p : int ; p := 0 ; while p < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,2 * n)->collect(0) ;
        var j : int ; j := 0 ; while j < 2 * n do (     a[j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ; 
    a := a->sort() ; 
    OclFile["System.out"].println(a[n+1] - a[n - 1+1]) ; 
 )  ;     p := p + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class problem1300B {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int t=scn.nextInt();
    while(t-->0){
      int n=scn.nextInt();
      int arr[]=new int[2*n];
      for(int i=0 ; i<2*n ; i++)arr[i]=scn.nextInt();
      Arrays.sort(arr);
      System.out.println(Math.abs(arr[n-1]-arr[n]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class problem1300B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scn.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scn.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,2 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 * n do (     arr[i+1] := scn.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    OclFile["System.out"].println(if arr[n - 1+1] - arr[n+1] < 0 then -(arr[n - 1+1] - arr[n+1]) else arr[n - 1+1] - arr[n+1] endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MainClass {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int t=Integer.parseInt(st.nextToken());
    while(t-->0){
      st=new StringTokenizer(br.readLine());
      int n=Integer.parseInt(st.nextToken());
      st=new StringTokenizer(br.readLine());
      int[] arr=new int[2*n];
      for(int i=0 ; i<(2*n); i++){
        arr[i]=Integer.parseInt(st.nextToken());
      }
      Arrays.sort(arr);
      int sum=arr[n]-arr[n-1];
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var t : int ; t := (st.next())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var n : int ; n := (st.next())->toInteger() ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,2 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < (2 * n) do ( (     arr[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var sum : int ; sum := arr[n+1] - arr[n - 1+1] ;
    OclFile["System.out"].println(sum) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  static String end ;
  static int ans=0 ;
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      int n=Integer.parseInt(br.readLine());
      if(n==0)break ;
      ans=Integer.MAX_VALUE ;
      String a[]=new String[n];
      String b[]=new String[n];
      for(int i=0 ; i<n ; i++){
        String str[]=br.readLine().split(" ");
        a[i]=str[0];
        b[i]=str[1];
      }
      String start=br.readLine();
      end=br.readLine();
      dfs(n,a,b,start,0);
      if(ans==Integer.MAX_VALUE)System.out.println("-1");
      else System.out.println(ans);
    }
  }
  static void dfs(int n,String a[],String b[],String str,int count){
    if(str.length()>end.length()|| str.length()>10){
      return ;
    }
    if(str.equals(end)){
      ans=Math.min(ans,count);
      return ;
    }
    for(int i=0 ; i<n ; i++){
      String res=str.replace(a[i],b[i]);
      if(! str.equals(res))dfs(n,a,b,res,count+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute end : String;
  static   attribute ans : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var n : int ; n := (br.readLine())->toInteger() ;
     if (n = 0) then     break else skip ; 
    ans := 2147483647 ; 
    var a : Sequence(String) ; a := Integer.subrange(1,n)->collect(null) ;
    var b : Sequence(String) ; b := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     a[i+1] := str[0+1] ; 
     b[i+1] := str[1+1] )  ;     i := i + 1 ) ; 
    var start : String ; start := br.readLine() ;
    end := br.readLine() ; 
    execute dfs(n, a, b, start, 0) ; 
    if (ans = 2147483647) then     OclFile["System.out"].println("-1") else     OclFile["System.out"].println(ans) ; ;  
 ) );
  static   operation dfs( n : int, a : Sequence(String), b : Sequence(String), str : String, count : int) : void
  pre: true
  post: true
  activity: (     if (str->size() > end->size() or str->size() > 10) then (     return ) else skip ; 
     if (str = end) then (     ans := Set{ans, count}->min() ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     var res : String ; res := str.replace(a[i+1], b[i+1]) ;
     if (not(str = res)) then     execute dfs(n, a, b, res, count + 1) ; else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class S {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    long cntp[]=new long[11];
    long cntn[]=new long[11];
    long cnt=0 ;
    for(int i=0 ; i<n ; i++){
      int a=in.nextInt();
      if(a==0)cnt++;
      else if(a>0)cntp[a]++;
      else if(a<0)cntn[Math.abs(a)]++;
    }
    long res=0 ;
    for(int i=1 ; i<11 ; i++)res=res+(cntp[i]*cntn[i]);
    res=res+((cnt*(cnt-1))/2);
    System.out.print(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class S {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var cntp : Sequence(long) ; cntp := Integer.subrange(1,11)->collect(0) ;
    var cntn : Sequence(long) ; cntn := Integer.subrange(1,11)->collect(0) ;
    var cnt : long ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     if (a = 0) then     cnt := cnt + 1 ; else     if (a > 0) then     cntp[a+1] := cntp[a+1] + 1 else     if (a < 0) then     cntn[if a < 0 then -(a) else a endif+1] := cntn[if a < 0 then -(a) else a endif+1] + 1 ; else skip ; ;  )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
        var i : int ; i := 1 ; while i < 11 do (     res := res + (cntp[i+1] * cntn[i+1]) ;  ;     i := i + 1 ) ; 
    res := res + ((cnt * (cnt - 1)) / 2) ; 
    OclFile["System.out"].print(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class OppositesAttract {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    long a[]=new long[11];
    long b[]=new long[11];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      if(arr[i]<0){
        b[Math.abs(arr[i])]++;
      }
      else {
        a[arr[i] ]++;
      }
    }
    long count=0 ;
    for(int i=1 ; i<a.length ; i++){
      count=(long)(count+(long)(a[i]*b[i]));
    }
    count=(long)(count+(long)((a[0]*(a[0]-1)/2)));
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class OppositesAttract {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var a : Sequence(long) ; a := Integer.subrange(1,11)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,11)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr[i+1] < 0) then (     b[if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif+1] := b[if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif+1] + 1 ) else (     a[arr[i+1]+1] := a[arr[i+1]+1] + 1 ) )  ;     i := i + 1 ) ; 
    var count : long ; count := 0 ;
        var i : int ; i := 1 ; while i < a->size() do ( (     count := (count + (a[i+1] * b[i+1])->oclAsType(long))->oclAsType(long) )  ;     i := i + 1 ) ; 
    count := (count + ((a[0+1] * (a[0+1] - 1) / 2))->oclAsType(long))->oclAsType(long) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int N=(int)1e5+5 ;
    long[] cnt=new long[21];
    for(int i=0 ; i<n ; i++){
      cnt[scan.nextInt()+10]++;
    }
    long res=0 ;
    for(int i=0 ; i<10 ; i++){
      res+=cnt[i]*cnt[20-i];
    }
    res+=(cnt[10]*(cnt[10]-1))/2 ;
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var N : int ; N := 1e5->oclAsType(int) + 5 ;
    var cnt : Sequence(long) ; cnt := Integer.subrange(1,21)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     cnt[scan.getCurrent()->toInteger() + 10+1] := cnt[scan.getCurrent()->toInteger() + 10+1] + 1 )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < 10 do ( (     res := res+(cnt[i+1] * cnt[20 - i+1]) )  ;     i := i + 1 ) ; 
    res := res+((cnt[10+1] * (cnt[10+1] - 1)) / 2) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF95A extends PrintWriter {
  CF95A(){
    super(System.out,true);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    CF95A o=new CF95A();
    o.main();
    o.flush();
  }
  int compare(char[] aa,int i,char[] bb,int j,int m){
    while(m-->0){
      char a=Character.toUpperCase(aa[i]);
      char b=Character.toUpperCase(bb[j]);
      if(a!=b)return a-b ;
      i++;
      j++;
    }
    return 0 ;
  }
  void main(){
    int n=sc.nextInt();
    char[][] ss=new char[n][];
    for(int i=0 ; i<n ; i++)ss[i]=sc.next().toCharArray();
    char[] cc=sc.next().toCharArray();
    int m=cc.length ;
    char c=sc.next().charAt(0);
    char c_=Character.toUpperCase(c);
    char a=c=='a' ? 'b' : 'a' ;
    char a_=Character.toUpperCase(a);
    boolean[] lucky=new boolean[m];
    for(int j=0 ; j<m ; j++)for(int i=0 ; i<n ; i++){
      int l=ss[i] .length ;
      if(m-j>=l && compare(cc,j,ss[i],0,l)==0)for(int h=0 ;
      h<l ;
      h++)lucky[j+h]=true ;
    }
    for(int j=0 ; j<m ; j++)if(lucky[j]){
      if(Character.toLowerCase(cc[j])==c)cc[j]=Character.isUpperCase(cc[j])? a_ : a ;
      else cc[j]=Character.isUpperCase(cc[j])? c_ : c ;
    }
    println(cc);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF95A extends OclFile {
   static operation newCF95A() : CF95A
  pre: true
  post: true
  activity:
  ( var self : CF95A ;
    self := createCF95A();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"], true) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : CF95A ; o := CF95A.newCF95A() ;
     o.main() ; 
     o.flush() );
   operation compare( aa : Sequence(String), i : int, bb : Sequence(String), j : int, m : int) : int
  pre: true
  post: true
  activity: (         while (m > 0) do (        m := m - 1 ;     skip ; (     var a : String ; a := (aa[i+1] + "")->toUpperCase() ;
     var b : String ; b := (bb[j+1] + "")->toUpperCase() ;
    if (a /= b) then     return (a)->char2byte() - (b)->char2byte() else skip ; 
    i := i + 1 ; 
    j := j + 1 ; 
 ) ;  ) ;  
     return 0 );
   operation main() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ss : Sequence(Sequence(String)) ; ss := Integer.subrange(1,n)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < n do (     ss[i+1] := sc.getCurrent()->characters() ;  ;     i := i + 1 ) ; 
    var cc : Sequence(String) ; cc := sc.getCurrent()->characters() ;
    var m : int ; m := cc->size() ;
    var c : String ; c := sc.getCurrent()->at(0+1) ;
    var c_ : String ; c_ := (c + "")->toUpperCase() ;
    var a : String ; a := if c = 'a' then 'b' else 'a' endif ;
    var a_ : String ; a_ := (a + "")->toUpperCase() ;
    var lucky : Sequence(boolean) ; lucky := Integer.subrange(1,m)->collect(false) ;
        var j : int ; j := 0 ; while j < m do (         var i : int ; i := 0 ; while i < n do ( (     var l : int ; l := ss[i+1]->size() ;
     if (m - j >= l & compare(cc, j, ss[i+1], 0, l) = 0) then         var h : int ; h := 0 ; while h < l do (     lucky[j + h+1] := true ;  ;     h := h + 1 ) ; else skip )  ;     i := i + 1 ) ;  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < m do (     if (lucky[j+1]) then (     if ((cc[j+1] + "")->toLowerCase() = c) then     cc[j+1] := if (cc[j+1]->toUpperCase() = cc[j+1]) then a_ else a endif ; else     cc[j+1] := if (cc[j+1]->toUpperCase() = cc[j+1]) then c_ else c endif ; ) else skip ;  ;     j := j + 1 ) ; 
    execute println(cc) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.File ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.util.StringTokenizer ;
public class Enclosure {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new FileReader(new File("in")));
    BufferedWriter bw=new BufferedWriter(new FileWriter(new File("out")));
    StringTokenizer st ;
    int T=Integer.parseInt(br.readLine());
    for(int cn=1 ; cn<=T ; cn++){
      st=new StringTokenizer(br.readLine());
      int N=Integer.parseInt(st.nextToken());
      int M=Integer.parseInt(st.nextToken());
      int K=Integer.parseInt(st.nextToken());
      int ans=K ;
      for(int i=3 ; i<=N ; i++){
        for(int j=3 ; j<=M ; j++){
          int stones=2*(i-2)+2*(j-2);
          int covered=i*j-4 ;
          if(K<=covered)ans=Math.min(ans,stones);
          for(int k=1 ; k<=4 ; k++)if(K<=covered+k)ans=Math.min(ans,stones+k);
          if(i<N || j<M)if(K<=covered+2)ans=Math.min(ans,stones+1);
        }
      }
      System.out.println(N+" "+M+" "+K+" "+ans);
      bw.append("Case #"+cn+": ");
      bw.append(ans+"\n");
    }
    bw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Enclosure {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile("in"))) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile("out"))) ;
    var st : OclIterator ;
    var T : int ; T := (br.readLine())->toInteger() ;
        var cn : int ; cn := 1 ; while cn <= T do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var N : int ; N := (st.next())->toInteger() ;
    var M : int ; M := (st.next())->toInteger() ;
    var K : int ; K := (st.next())->toInteger() ;
    var ans : int ; ans := K ;
        var i : int ; i := 3 ; while i <= N do ( (         var j : int ; j := 3 ; while j <= M do ( (     var stones : int ; stones := 2 * (i - 2) + 2 * (j - 2) ;
     var covered : int ; covered := i * j - 4 ;
    if (K <= covered) then     ans := Set{ans, stones}->min() ; else skip ; 
        var k : int ; k := 1 ; while k <= 4 do (     if (K <= covered + k) then     ans := Set{ans, stones + k}->min() ; else skip ;  ;     k := k + 1 ) ; 
    if (i < N or j < M) then     if (K <= covered + 2) then     ans := Set{ans, stones + 1}->min() ; else skip ; else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(N + " " + M + " " + K + " " + ans) ; 
    skip ; 
    skip ; 
 )  ;     cn := cn + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package codejam ;
import java.io.*;
import java.util.Scanner ;
public abstract class Task {
  protected abstract String getName();
  protected abstract void runOne(Scanner input,PrintWriter output);
  void run(InputStream input,OutputStream output){
    Scanner in=new Scanner(input);
    PrintWriter out=new PrintWriter(output);
    int testsCount=in.nextInt();
    in.nextLine();
    for(int test=1 ; test<=testsCount ; test++){
      System.out.println("solving "+test);
      out.print("Case #"+test+": ");
      runOne(in,out);
      out.flush();
    }
  }
  public static void runConsole(Task task){
    task.run(System.in,System.out);
  }
  public static void runSmall(Task task,int num)throws IOException {
    runFiles(task,new File("./"+task.getName()+"-small-attempt"+num+".in"),new File("./"+task.getName()+"-small-attempt"+num+".out"));
  }
  public static void runLarge(Task task)throws IOException {
    runFiles(task,new File("./"+task.getName()+"-large.in"),new File("./"+task.getName()+"-large.out"));
  }
  private static void runFiles(Task task,File input,File output)throws IOException {
    InputStream is=new BufferedInputStream(new FileInputStream(input));
    OutputStream os=new BufferedOutputStream(new FileOutputStream(output));
    task.run(is,os);
    is.close();
    os.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Task {
      operation getName() : String
  pre: true
  post: true;
      operation runOne( input : OclFile, output : OclFile) : void
  pre: true
  post: true;
   operation run( input : OclFile, output : OclFile) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(input) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(output) ;
    var testsCount : int ; testsCount := in.getCurrent()->toInteger() ;
    skip ; 
        var test : int ; test := 1 ; while test <= testsCount do ( (     OclFile["System.out"].println("solving " + test) ; 
     skip ; 
     execute runOne(in, out) ; 
     skip )  ;     test := test + 1 ) ; 
 );
  static   operation runConsole( task : Task) : void
  pre: true
  post: true
  activity: (     task.run(OclFile["System.in"], OclFile["System.out"]) );
  static   operation runSmall( task : Task, num : int) : void
  pre: true
  post: true
  activity: (     execute runFiles(task, OclFile("./" + task.getName() + "-small-attempt" + num + ".in"), OclFile("./" + task.getName() + "-small-attempt" + num + ".out")) );
  static   operation runLarge( task : Task) : void
  pre: true
  post: true
  activity: (     execute runFiles(task, OclFile("./" + task.getName() + "-large.in"), OclFile("./" + task.getName() + "-large.out")) );
  static   operation runFiles( task : Task, input : OclFile, output : OclFile) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile.newOclFile_Read(input)) ;
     var os : OclFile ; os := OclFile.newOclFile_Write(OclFile.newOclFile_Write(output)) ;
    task.run(is, os) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class C2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int cases=sc.nextInt();
    for(int caseNum=1 ; caseNum<=cases ; caseNum++){
      int N=sc.nextInt();
      int M=sc.nextInt();
      int K=sc.nextInt();
      if(N==1 || M==1){
        System.out.println("Case #"+caseNum+": "+K);
        continue ;
      }
      int answer=2*N+2*M-4 ;
      for(int stones=2*N+2*M-5 ; stones>0 ; stones--){
        int newEnclosed=Math.max(temp(M,N,stones),temp(N,M,stones));
        if(newEnclosed>=K){
          answer=stones ;
        }
        else {
          break ;
        }
      }
      System.out.println("Case #"+caseNum+": "+answer);
    }
  }
  private static int temp(int N,int M,int stones){
    int diff=2*N+2*M-4-stones ;
    int d1=diff/4 ;
    int d2=(diff+1)/4 ;
    int d3=(diff+2)/4 ;
    int d4=(diff+3)/4 ;
    int newEnclosed=0 ;
    for(int n=0 ; n<N ; n++){
      for(int m=0 ; m<M ; m++){
        if(n+m>=d1 && n+(M-1-m)>=d2 &&(N-1-n)+(M-1-m)>=d3 &&(N-1-n)+m>=d4){
          newEnclosed++;
        }
      }
    }
    return newEnclosed ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class C2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cases : int ; cases := sc.getCurrent()->toInteger() ;
         var caseNum : int ; caseNum := 1 ; while caseNum <= cases do ( (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var M : int ; M := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    if (N = 1 or M = 1) then (     OclFile["System.out"].println("Case #" + caseNum + ": " + K) ; 
     continue ) else skip ; 
    var answer : int ; answer := 2 * N + 2 * M - 4 ;
        var stones : int ; stones := 2 * N + 2 * M - 5 ; while stones > 0 do ( (     var newEnclosed : int ; newEnclosed := Set{temp(M, N, stones), temp(N, M, stones)}->max() ;
     if (newEnclosed >= K) then (     answer := stones ) else (     break ) )  ;     stones := stones - 1 ) ; 
    OclFile["System.out"].println("Case #" + caseNum + ": " + answer) ; 
 )  ;     caseNum := caseNum + 1 ) );
  static   operation temp( N : int, M : int, stones : int) : int
  pre: true
  post: true
  activity: (     var diff : int ; diff := 2 * N + 2 * M - 4 - stones ;
     var d1 : int ; d1 := diff / 4 ;
    var d2 : int ; d2 := (diff + 1) / 4 ;
    var d3 : int ; d3 := (diff + 2) / 4 ;
    var d4 : int ; d4 := (diff + 3) / 4 ;
    var newEnclosed : int ; newEnclosed := 0 ;
        var n : int ; n := 0 ; while n < N do ( (         var m : int ; m := 0 ; while m < M do ( (     if (n + m >= d1 & n + (M - 1 - m) >= d2 & (N - 1 - n) + (M - 1 - m) >= d3 & (N - 1 - n) + m >= d4) then (     newEnclosed := newEnclosed + 1 ) else skip )  ;     m := m + 1 ) )  ;     n := n + 1 ) ; 
    return newEnclosed 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Queue ;
public class NonReapatingCQueue {
  final static int MAX_CHAR=26 ;
  static void firstNonRepeating(String str){
    int[] charCount=new int[MAX_CHAR];
    Queue<Character>q=new LinkedList<Character>();
    for(int i=0 ; i<str.length(); i++){
      char ch=str.charAt(i);
      q.add(ch);
      charCount[ch-'a']++;
      while(! q.isEmpty()){
        if(charCount[q.peek()-'a']>1)q.remove();
        else {
          System.out.print(q.peek()+" ");
          break ;
        }
      }
      if(q.isEmpty())System.out.print(-1+" ");
    }
    System.out.println();
  }
  public static void main(String[] args){
    String str="aabc" ;
    firstNonRepeating(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class NonReapatingCQueue {
  static   attribute MAX_CHAR : int := 26;
  static   operation firstNonRepeating( str : String) : void
  pre: true
  post: true
  activity: (     var charCount : Sequence(int) ; charCount := Integer.subrange(1,MAX_CHAR)->collect(0) ;
     var q : Sequence(String) ; q := Sequence{} ;
         var i : int ; i := 0 ; while i < str->size() do ( (     var ch : String ; ch := str->at(i+1) ;
     q := q->including(ch) ; 
    charCount[(ch)->char2byte() - ('a')->char2byte()+1] := charCount[(ch)->char2byte() - ('a')->char2byte()+1] + 1 ; 
    while (not(q->isEmpty())) do (     if (charCount[q->min() - ('a')->char2byte()+1] > 1) then     q := q.remove() ; else (     OclFile["System.out"].print(q->min() + " ") ; 
     break ) ) ; 
    if (q->isEmpty()) then     OclFile["System.out"].print(-1 + " ") ; else skip ; 
 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "aabc" ;
     execute firstNonRepeating(str) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    char[] c=sc.next().toCharArray();
    int[] w=new int[a+1];
    int[] e=new int[a+1];
    int min=a ;
    for(int i=1 ; i<=a ; i++){
      if(c[i-1]=='W'){
        w[i]++;
      }
      else {
        e[i]++;
      }
      w[i]+=w[i-1];
      e[i]+=e[i-1];
    }
    for(int i=1 ; i<=a ; i++){
      min=Math.min(min,w[i-1]+e[a]-e[i]);
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var c : Sequence(String) ; c := sc.getCurrent()->characters() ;
    var w : Sequence(int) ; w := Integer.subrange(1,a + 1)->collect(0) ;
    var e : Sequence(int) ; e := Integer.subrange(1,a + 1)->collect(0) ;
    var min : int ; min := a ;
        var i : int ; i := 1 ; while i <= a do ( (     if (c[i - 1+1] = 'W') then (     w[i+1] := w[i+1] + 1 ) else (     e[i+1] := e[i+1] + 1 ) ;  
     w[i+1] := w[i+1]+(w[i - 1+1]) ; 
     e[i+1] := e[i+1]+(e[i - 1+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= a do ( (     min := Set{min, w[i - 1+1] + e[a+1] - e[i+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String S=sc.next();
    int[] w=new int[n+1];
    int[] e=new int[n+1];
    for(int i=0 ; i<n ; i++){
      if(S.charAt(i)=='E'){
        e[i+1]=e[i]+1 ;
      }
      else {
        e[i+1]=e[i];
      }
    }
    for(int i=0 ; i<n ; i++){
      if(S.charAt(i)=='W'){
        w[i+1]=w[i]+1 ;
      }
      else {
        w[i+1]=w[i];
      }
    }
    long ans=Long.MAX_VALUE ;
    for(int i=1 ; i<=n ; i++){
      int sum=w[i-1]+(e[n]-e[i]);
      if(sum<=ans){
        ans=sum ;
      }
    }
    System.out.println(ans);
  }
}
class Pair implements Comparable {
  int from ;
  int end ;
  int num ;
  int bango ;
  @ Override public int compareTo(Object other){
    Pair otherpair=(Pair)other ;
    return end-otherpair.end ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var S : String ; S := sc.getCurrent() ;
    var w : Sequence(int) ; w := Integer.subrange(1,n + 1)->collect(0) ;
    var e : Sequence(int) ; e := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     if (S->at(i+1) = 'E') then (     e[i + 1+1] := e[i+1] + 1 ) else (     e[i + 1+1] := e[i+1] ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (S->at(i+1) = 'W') then (     w[i + 1+1] := w[i+1] + 1 ) else (     w[i + 1+1] := w[i+1] ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := "9223372036854775807"->toLong() ;
        var i : int ; i := 1 ; while i <= n do ( (     var sum : int ; sum := w[i - 1+1] + (e[n+1] - e[i+1]) ;
     if (sum <= ans) then (     ans := sum ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}
class Pair implements OclAny {
   attribute from : int;
   attribute end : int;
   attribute num : int;
   attribute bango : int;
      operation compareTo( other : OclAny) : int
  pre: true
  post: true
  activity: (     var otherpair : Map ; otherpair := other->oclAsType(Map) ;
     return end - otherpair.end );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.min ;
import static java.lang.Math.max ;
import static java.lang.Math.abs ;
public class Practice {
  static Scanner scn=new Scanner(System.in);
  static StringBuilder sb=new StringBuilder();
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] HastaLaVistaLa){
    int t=1 ;
    for(int tests=0 ; tests<t ; tests++)solve();
    out.println(sb);
    out.close();
  }
  public static void solve(){
    int n=scn.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=scn.nextInt();
    int[] freq=new int[1010];
    int can=(n+1);
    for(int i : a){
      freq[i]++;
      if(freq[i]>can/2){
        sb.append("NO");
        return ;
      }
    }
    sb.append("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   attribute scn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute sb : String := StringLib.newString();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( HastaLaVistaLa : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
         var tests : int ; tests := 0 ; while tests < t do (     execute solve() ;  ;     tests := tests + 1 ) ; 
     skip ; 
     skip );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := scn.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := scn.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var freq : Sequence(int) ; freq := Integer.subrange(1,1010)->collect(0) ;
    var can : int ; can := (n + 1) ;
    for (i : a) do ( (     freq[i+1] := freq[i+1] + 1 ; 
     if (freq[i+1] > can / 2) then (     sb := sb + StringLib.newString("NO") ; 
     return ) else skip )  ) ; 
    sb := sb + StringLib.newString("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    try {
      InputStreamReader isr=new InputStreamReader(System.in);
      BufferedReader br=new BufferedReader(isr);
      int n=Integer.parseInt(br.readLine());
      String str=br.readLine();
      int countW=0 ;
      int arrW[]=new int[n];
      int countE=0 ;
      int arrE[]=new int[n];
      for(int i=0 ; i<n ; i++){
        char ch=str.charAt(i);
        if(ch=='W'){
          countW++;
        }
        else {
          countE++;
        }
        arrW[i]=countW ;
        arrE[i]=countE ;
      }
      int min=0 ;
      for(int i=0 ; i<n ; i++){
        if(i==0){
          min=arrE[n-1]-arrE[i];
        }
        else {
          int tmp=arrW[i-1]+(arrE[n-1]-arrE[i]);
          if(min>tmp){
            min=tmp ;
          }
        }
      }
      System.out.println(min);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var str : String ; str := br.readLine() ;
    var countW : int ; countW := 0 ;
    var arrW : Sequence(int) ; arrW := Integer.subrange(1,n)->collect(0) ;
    var countE : int ; countE := 0 ;
    var arrE : Sequence(int) ; arrE := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var ch : String ; ch := str->at(i+1) ;
     if (ch = 'W') then (     countW := countW + 1 ) else (     countE := countE + 1 ) ;  
     arrW[i+1] := countW ; 
     arrE[i+1] := countE )  ;     i := i + 1 ) ; 
    var min : int ; min := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i = 0) then (     min := arrE[n - 1+1] - arrE[i+1] ) else (     var tmp : int ; tmp := arrW[i - 1+1] + (arrE[n - 1+1] - arrE[i+1]) ;
     if (min > tmp) then (     min := tmp ) else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sc.nextInt();
    String S=sc.next();
    System.out.println(solve(S));
    sc.close();
  }
  static int solve(String S){
    int N=S.length();
    int leftWCount=0 ;
    int[] leftWCounts=new int[N];
    for(int i=0 ; i<leftWCounts.length ; ++i){
      leftWCounts[i]=leftWCount ;
      if(S.charAt(i)=='W'){
++leftWCount ;
      }
    }
    int rightECount=0 ;
    int[] rightECounts=new int[N];
    for(int i=rightECounts.length-1 ; i>=0 ; --i){
      rightECounts[i]=rightECount ;
      if(S.charAt(i)=='E'){
++rightECount ;
      }
    }
    return IntStream.range(0,N).map(i->leftWCounts[i]+rightECounts[i]).min().getAsInt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var S : String ; S := sc.getCurrent() ;
    OclFile["System.out"].println(solve(S)) ; 
    skip ; 
 );
  static   operation solve( S : String) : int
  pre: true
  post: true
  activity: (     var N : int ; N := S->size() ;
     var leftWCount : int ; leftWCount := 0 ;
    var leftWCounts : Sequence(int) ; leftWCounts := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < leftWCounts->size() do ( (     leftWCounts[i+1] := leftWCount ; 
     if (S->at(i+1) = 'W') then (     leftWCount := leftWCount + 1 ) else skip )  ;     i := i + 1 ) ; 
    var rightECount : int ; rightECount := 0 ;
    var rightECounts : Sequence(int) ; rightECounts := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := rightECounts->size() - 1 ; while i >= 0 do ( (     rightECounts[i+1] := rightECount ; 
     if (S->at(i+1) = 'E') then (     rightECount := rightECount + 1 ) else skip )  ;     i := i - 1 ) ; 
    return Integer.subrange(0, N-1)->collect( _x1 | (lambda i : OclAny in leftWCounts[i+1] + rightECounts[i+1])->apply(_x1) ).min().getAsInt() 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=Integer.parseInt(scan.next());
    String S=scan.next();
    int count1=0 ;
    int count2=0 ;
    int[] countW=new int[S.length()];
    Arrays.fill(countW,0);
    int[] countE=new int[S.length()];
    Arrays.fill(countE,0);
    int i=0 ;
    int j=S.length()-1 ;
    while(i<=S.length()-1 && 0<=j){
      if((0<=i-1)&& S.substring(i-1,i-1+1).equals("W"))count1++;
      countW[i]+=count1 ;
      if((j+1<=S.length()-1)&& S.substring(j+1,j+1+1).equals("E"))count2++;
      countE[j]+=count2 ;
      i++;
      j--;
    }
    int min=1111111111 ;
    int[] sum=new int[S.length()];
    for(int k=0 ; k<S.length(); k++){
      sum[k]=countW[k]+countE[k];
      if(sum[k]<min)min=sum[k];
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (scan.getCurrent())->toInteger() ;
    var S : String ; S := scan.getCurrent() ;
    var count1 : int ; count1 := 0 ;
    var count2 : int ; count2 := 0 ;
    var countW : Sequence(int) ; countW := Integer.subrange(1,S->size())->collect(0) ;
    countW := countW->collect(0) ; 
    var countE : Sequence(int) ; countE := Integer.subrange(1,S->size())->collect(0) ;
    countE := countE->collect(0) ; 
    var i : int ; i := 0 ;
    var j : int ; j := S->size() - 1 ;
    while (i <= S->size() - 1 & 0 <= j) do (     if ((0 <= i - 1) & S.subrange(i - 1+1,i - 1 + 1) = "W") then     count1 := count1 + 1 ; else skip ; 
     countW[i+1] := countW[i+1]+(count1) ; 
    if ((j + 1 <= S->size() - 1) & S.subrange(j + 1+1,j + 1 + 1) = "E") then     count2 := count2 + 1 ; else skip ; 
    countE[j+1] := countE[j+1]+(count2) ; 
    i := i + 1 ; 
    j := j - 1 ; 
 ) ; 
    var min : int ; min := 1111111111 ;
    var sum : Sequence(int) ; sum := Integer.subrange(1,S->size())->collect(0) ;
        var k : int ; k := 0 ; while k < S->size() do ( (     sum[k+1] := countW[k+1] + countE[k+1] ; 
     if (sum[k+1] < min) then     min := sum[k+1] ; else skip )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF1213A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int even=0 ;
    int odd=0 ;
    for(int i=0 ; i<n ; i++){
      int num1=scan.nextInt();
      if(num1 % 2==0){
        even++;
      }
      else {
        odd++;
      }
    }
    if(even>odd){
      System.out.println(odd);
    }
    else {
      System.out.println(even);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF1213A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var even : int ; even := 0 ;
    var odd : int ; odd := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var num1 : int ; num1 := scan.getCurrent()->toInteger() ;
     if (num1 mod 2 = 0) then (     even := even + 1 ) else (     odd := odd + 1 ) )  ;     i := i + 1 ) ; 
    if (even > odd) then (     OclFile["System.out"].println(odd) ) else (     OclFile["System.out"].println(even) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf1213A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int cntOdd=0 ;
    for(int i=0 ; i<n ; i++){
      int x=scan.nextInt();
      if(x % 2==1){
        cntOdd++;
      }
    }
    System.out.println(Math.min(n-cntOdd,cntOdd));
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1213A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var cntOdd : int ; cntOdd := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := scan.getCurrent()->toInteger() ;
     if (x mod 2 = 1) then (     cntOdd := cntOdd + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{n - cntOdd, cntOdd}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf1213A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int num=scan.nextInt();
    int oddcount=0 ;
    for(int i=0 ; i<num ; i++){
      int x=scan.nextInt();
      if(x % 2==1){
        oddcount+=1 ;
      }
    }
    System.out.println(Math.min(num-oddcount,oddcount));
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1213A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := scan.getCurrent()->toInteger() ;
    var oddcount : int ; oddcount := 0 ;
        var i : int ; i := 0 ; while i < num do ( (     var x : int ; x := scan.getCurrent()->toInteger() ;
     if (x mod 2 = 1) then (     oddcount := oddcount+(1) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{num - oddcount, oddcount}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ChipsMoving {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] nums=new int[n];
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      nums[i]=sc.nextInt();
      if(nums[i] % 2!=0){
        count++;
      }
    }
    System.out.println(Math.min(n-count,count));
  }
}
------------------------------------------------------------
OCL File:
---------
 class ChipsMoving {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := sc.getCurrent()->toInteger() ; 
     if (nums[i+1] mod 2 /= 0) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{n - count, count}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public void doIt(){
    Scanner sc=new Scanner(System.in);
    final int MAX=10000000 ;
    boolean[] prime=new boolean[MAX+1];
    for(int i=3 ; i<=MAX ; i+=2){
      prime[i]=true ;
    }
    for(int i=3 ; i*i<=MAX ; i+=2){
      if(prime[i]){
        for(int j=i*3 ; j<=MAX ; j+=i*2){
          prime[j]=false ;
        }
      }
    }
    int n=sc.nextInt();
    while(n!=0){
      if(n % 2==0)n--;
      for(int i=n ; i>=13 ; i-=2){
        if(prime[i] && prime[i-2] && prime[i-6] && prime[i-8]){
          System.out.println(i);
          break ;
        }
      }
      n=sc.nextInt();
    }
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var MAX : int ; MAX := 10000000 ;
    var prime : Sequence(boolean) ; prime := Integer.subrange(1,MAX + 1)->collect(false) ;
        var i : int ; i := 3 ; while i <= MAX do ( (     prime[i+1] := true )  ;     i := i+(2) ) ; 
        var i : int ; i := 3 ; while i * i <= MAX do ( (     if (prime[i+1]) then (         var j : int ; j := i * 3 ; while j <= MAX do ( (     prime[j+1] := false )  ;     j := j+(i * 2) ) ) else skip )  ;     i := i+(2) ) ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
    while (n /= 0) do (     if (n mod 2 = 0) then     n := n - 1 ; else skip ; 
         var i : int ; i := n ; while i >= 13 do ( (     if (prime[i+1] & prime[i - 2+1] & prime[i - 6+1] & prime[i - 8+1]) then (     OclFile["System.out"].println(i) ; 
     break ) else skip )  ;     i := i-(2) ) ; 
     n := sc.getCurrent()->toInteger() ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class CF862B {
  static Node[] arr ;
  static long totalFalse ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    arr=new Node[n];
    totalFalse=0 ;
    for(int i=0 ; i<n ; i++)arr[i]=new Node(i);
    for(int i=0 ; i<n-1 ; i++){
      int a=sc.nextInt()-1 ;
      int b=sc.nextInt()-1 ;
      arr[a] .neighbors.add(b);
      arr[b] .neighbors.add(a);
    }
    dfs(0,true);
    long total=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] .parity){
        total+=(totalFalse-arr[i] .neighbors.size());
      }
    }
    System.out.println(total);
  }
  static void dfs(Integer currNode,boolean parity){
    arr[currNode] .parity=parity ;
    if(! parity)totalFalse++;
    for(Integer nextNode : arr[currNode] .neighbors){
      if(arr[nextNode] .parity!=null)continue ;
      dfs(nextNode,! parity);
    }
  }
  static class Node {
    int index ;
    ArrayList<Integer>neighbors ;
    Boolean parity ;
    public Node(int index){
      this.index=index ;
      neighbors=new ArrayList<>();
      parity=null ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF862B {
  static   attribute arr : Sequence(Node);
  static   attribute totalFalse : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    arr := Integer.subrange(1,n)->collect(null) ; 
    totalFalse := 0 ; 
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := Node.newNode(i) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
     var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
     arr[a+1].neighbors->excludes(b) ; 
     arr[b+1].neighbors->excludes(a) )  ;     i := i + 1 ) ; 
    execute dfs(0, true) ; 
    var total : long ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1].parity) then (     total := total+((totalFalse - arr[i+1].neighbors->size())) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
  static   operation dfs( currNode : int, parity : boolean) : void
  pre: true
  post: true
  activity: (     arr[currNode+1].parity := parity ; 
     if (not(parity)) then     totalFalse := totalFalse + 1 ; else skip ; 
     for (nextNode : arr[currNode+1].neighbors) do ( (     if (arr[nextNode+1].parity /= null) then     continue else skip ; 
     execute dfs(nextNode, not(parity)) )  ) );
  static class Node {
   attribute index : int;
   attribute neighbors : Sequence(int);
   attribute parity : Boolean;
   static operation newNode( index : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(index);
    return self );
  operation initialise( index : int) : void
  pre: true  post: true
  activity: (     self.index := index ; 
     neighbors := Sequence{} ; 
     parity := null );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    boolean[] isnp=new boolean[10000000];
    for(int i=2 ; i*i<=isnp.length ; i++)if(! isnp[i])for(int j=i*i ; j<isnp.length ; j+=i)isnp[j]=true ;
    List<Integer>ans=new ArrayList<Integer>();
    for(int i=13 ; i<isnp.length ; i++){
      if(! isnp[i] && ! isnp[i-2] && ! isnp[i-6] && ! isnp[i-8]){
        ans.add(i);
      }
    }
    for(; sc.hasNext(); ){
      int n=sc.nextInt();
      if(n==0)break ;
      int idx=Collections.binarySearch(ans,n);
      if(idx>=0)System.out.println(ans.get(idx));
      else System.out.println(ans.get(-idx-2));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var isnp : Sequence(boolean) ; isnp := Integer.subrange(1,10000000)->collect(false) ;
         var i : int ; i := 2 ; while i * i <= isnp->size() do (     if (not(isnp[i+1])) then         var j : int ; j := i * i ; while j < isnp->size() do (     isnp[j+1] := true ;  ;     j := j+(i) ) ; else skip ;  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Sequence{} ;
        var i : int ; i := 13 ; while i < isnp->size() do ( (     if (not(isnp[i+1]) & not(isnp[i - 2+1]) & not(isnp[i - 6+1]) & not(isnp[i - 8+1])) then (     ans := ans->including(i) ) else skip )  ;     i := i + 1 ) ; 
      while sc.hasNext() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
     var idx : int ; idx := .binarySearch(ans, n) ;
     if (idx >= 0) then     OclFile["System.out"].println(ans->at(idx+1)) ; else     OclFile["System.out"].println(ans->at(-idx - 2+1)) ; )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class A296 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    if(n==1){
      System.out.println("YES");
      return ;
    }
    Arrays.sort(a);
    ArrayList<Integer>al=new ArrayList<>();
    int cnt=1 ;
    for(int i=1 ; i<n ; i++){
      if(a[i]!=a[i-1]){
        al.add(cnt);
        cnt=0 ;
      }
      cnt++;
    }
    al.add(cnt);
    Collections.sort(al);
    if(al.get(al.size()-1)>(n+1)/2)System.out.println("NO");
    else System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A296 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (n = 1) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
    a := a->sort() ; 
    var al : Sequence(int) ; al := Sequence{} ;
    var cnt : int ; cnt := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] /= a[i - 1+1]) then (     al := al->including(cnt) ; 
     cnt := 0 ) else skip ; 
     cnt := cnt + 1 )  ;     i := i + 1 ) ; 
    al := al->including(cnt) ; 
    al := al->sort() ; 
    if (al->at(al->size() - 1+1) > (n + 1) / 2) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
class Main {
  static int[] makePrimes(final int lim){
    BitSet isPrime=new BitSet(lim+1);
    isPrime.set(0,lim+1,true);
    isPrime.set(0,2,false);
    final int limIndex=(int)sqrt(lim);
    for(int index=2 ; index<=limIndex ; index++){
      if(isPrime.get(index)){
        for(int i=index*index ; i<=lim ; i+=index){
          isPrime.set(i,false);
        }
      }
    }
    final int count=isPrime.cardinality();
    int[] ans=new int[count];
    int index=0 ;
    for(int i=0 ; i<=lim ; i++){
      if(isPrime.get(i)){
        ans[index++]=i ;
      }
    }
    return ans ;
  }
  public static void main(final String[] args){
    final int[] primes=makePrimes(10000000);
    final Scanner stdin=new Scanner(System.in);
    while(true){
      final int n=stdin.nextInt();
      if(n==0){
        break ;
      }
      int index=Arrays.binarySearch(primes,n);
      if(index<0){
        index=min(primes.length,-index-2);
      }
      while(index>=3){
        while(index>=3 && primes[index]-primes[index-1]>2){
          index--;
        }
        if(primes[index-1]-primes[index-2]==4 && primes[index-2]-primes[index-3]==2){
          System.out.println(primes[index]);
          break ;
        }
        index--;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation makePrimes( lim : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var isPrime : Sequence(boolean) ; isPrime := MathLib.toBitSequence(lim + 1) ;
     isPrime := isPrime.setAt(0+1,true) ; 
    isPrime := isPrime.setAt(0+1,false) ; 
    var limIndex : int ; limIndex := sqrt(lim)->oclAsType(int) ;
        var index : int ; index := 2 ; while index <= limIndex do ( (     if (isPrime->at(index+1)) then (         var i : int ; i := index * index ; while i <= lim do ( (     isPrime := isPrime.setAt(i+1,false) )  ;     i := i+(index) ) ) else skip )  ;     index := index + 1 ) ; 
    var count : int ; count := isPrime.cardinality() ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,count)->collect(0) ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i <= lim do ( (     if (isPrime->at(i+1)) then (      ans[index+1] := i  ; index := index + 1 ) else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var primes : Sequence(int) ; primes := makePrimes(10000000) ;
     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := stdin.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var index : int ; index := (primes->indexOf(n) - 1) ;
    if (index < 0) then (     index := Set{primes->size(), -index - 2}->min() ) else skip ; 
    while (index >= 3) do (     while (index >= 3 & primes[index+1] - primes[index - 1+1] > 2) do (     index := index - 1 ) ; 
     if (primes[index - 1+1] - primes[index - 2+1] = 4 & primes[index - 2+1] - primes[index - 3+1] = 2) then (     OclFile["System.out"].println(primes[index+1]) ; 
     break ) else skip ; 
     index := index - 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Prime p=new Prime();
    int n ;
    Scanner sc=new Scanner(System.in);
    while(true){
      n=sc.nextInt();
      if(n==0){
        break ;
      }
      System.out.println(p.searchMaxQuadruplet(n));
    }
  }
}
class Prime {
  private final int size=664579 ;
  private int[] prime ;
  public Prime(){
    prime=new int[size];
    setPrime();
  }
  public void setPrime(){
    int counter=0 ;
    int ptr=0 ;
    prime[ptr++]=2 ;
    prime[ptr++]=3 ;
    for(int n=5 ; n<=10000000 ; n+=2){
      boolean flag=false ;
      for(int i=1 ; prime[i]*prime[i]<=n ; i++){
        counter+=2 ;
        if(0==n % prime[i]){
          flag=true ;
          break ;
        }
      }
      if(! flag){
        prime[ptr++]=n ;
        counter++;
      }
    }
  }
  private int getIndex(int n){
    for(int i=0 ; i<size ; i++){
      if(prime[i]>n){
        return i-1 ;
      }
      else if(prime[i]==n){
        return i ;
      }
    }
    return size-1 ;
  }
  public int searchMaxQuadruplet(int n){
    int idx=getIndex(n);
    while(true){
      if(prime[idx]-prime[idx-1]==2){
        if(prime[idx]-prime[idx-2]==6){
          if(prime[idx]-prime[idx-3]==8){
            return prime[idx];
          }
        }
      }
      idx--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : Prime ; p := Prime.newPrime() ;
     var n : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then (     break ) else skip ; 
     OclFile["System.out"].println(p.searchMaxQuadruplet(n)) ) );
}
class Prime {
   attribute size : int := 664579;
   attribute prime : Sequence(int);
   static operation newPrime() : Prime
  pre: true
  post: true
  activity:
  ( var self : Prime ;
    self := createPrime();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     prime := Integer.subrange(1,size)->collect(0) ; 
     execute setPrime() );
   operation setPrime() : void
  pre: true
  post: true
  activity: (     var counter : int ; counter := 0 ;
     var ptr : int ; ptr := 0 ;
     prime[ptr+1] := 2  ; ptr := ptr + 1 ; 
     prime[ptr+1] := 3  ; ptr := ptr + 1 ; 
        var n : int ; n := 5 ; while n <= 10000000 do ( (     var flag : boolean ; flag := false ;
         var i : int ; i := 1 ; while prime[i+1] * prime[i+1] <= n do ( (     counter := counter+(2) ; 
     if (0 = n mod prime[i+1]) then (     flag := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (not(flag)) then (      prime[ptr+1] := n  ; ptr := ptr + 1 ; 
     counter := counter + 1 ) else skip )  ;     n := n+(2) ) ; 
 );
   operation getIndex( n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < size do ( (     if (prime[i+1] > n) then (     return i - 1 ) else     if (prime[i+1] = n) then (     return i ) else skip ; )  ;     i := i + 1 ) ; 
     return size - 1 );
   operation searchMaxQuadruplet( n : int) : int
  pre: true
  post: true
  activity: (     var idx : int ; idx := getIndex(n) ;
     while (true) do (     if (prime[idx+1] - prime[idx - 1+1] = 2) then (     if (prime[idx+1] - prime[idx - 2+1] = 6) then (     if (prime[idx+1] - prime[idx - 3+1] = 8) then (     return prime[idx+1] ) else skip ) else skip ) else skip ; 
     idx := idx - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B_Spider_Man {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 FastReader scan=new FastReader();
  public static void main(String[] args){
    int t=1 ;
    while(t-->0){
      solve();
    }
  }
  public static void solve(){
    int t=scan.nextInt();
    int[] arr=new int[t];
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=scan.nextInt();
    }
    int prevWinner=0 ;
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]==1){
        if(prevWinner==0){
          prevWinner=2 ;
        }
      }
      if(prevWinner==2 || prevWinner==0){
        if((arr[i]-1)% 2==0){
          System.out.println(2);
          prevWinner=2 ;
        }
        else {
          System.out.println(1);
          prevWinner=1 ;
        }
      }
      else {
        if((arr[i]-1)% 2==0){
          System.out.println(1);
          prevWinner=1 ;
        }
        else {
          System.out.println(2);
          prevWinner=2 ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Spider_Man {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   attribute scan : FastReader := FastReader.newFastReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var t : int ; t := scan.nextInt() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,t)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := scan.nextInt() )  ;     i := i + 1 ) ; 
    var prevWinner : int ; prevWinner := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = 1) then (     if (prevWinner = 0) then (     prevWinner := 2 ) else skip ) else skip ; 
     if (prevWinner = 2 or prevWinner = 0) then (     if ((arr[i+1] - 1) mod 2 = 0) then (     OclFile["System.out"].println(2) ; 
     prevWinner := 2 ) else (     OclFile["System.out"].println(1) ; 
     prevWinner := 1 ) ) else (     if ((arr[i+1] - 1) mod 2 = 0) then (     OclFile["System.out"].println(1) ; 
     prevWinner := 1 ) else (     OclFile["System.out"].println(2) ; 
     prevWinner := 2 ) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean powerOfTwo(int n){
    return((n & n-1)==0);
  }
  static boolean onlyFirstAndLastAreSet(int n){
    if(n==1)return true ;
    return powerOfTwo(n-1);
  }
  public static void main(String[] args){
    int n=Integer.parseUnsignedInt("9");
    if(onlyFirstAndLastAreSet(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation powerOfTwo( n : int) : boolean
  pre: true
  post: true
  activity: (     return ((n & n - 1) = 0) );
  static   operation onlyFirstAndLastAreSet( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 1) then     return true else skip ; 
     return powerOfTwo(n - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := parseUnsignedInt("9") ;
     if (onlyFirstAndLastAreSet(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
class GFG {
  static int minimumCostOfBreaking(Integer X[],Integer Y[],int m,int n){
    int res=0 ;
    Arrays.sort(X,Collections.reverseOrder());
    Arrays.sort(Y,Collections.reverseOrder());
    int hzntl=1,vert=1 ;
    int i=0,j=0 ;
    while(i<m && j<n){
      if(X[i]>Y[j]){
        res+=X[i]*vert ;
        hzntl++;
        i++;
      }
      else {
        res+=Y[j]*hzntl ;
        vert++;
        j++;
      }
    }
    int total=0 ;
    while(i<m)total+=X[i++];
    res+=total*vert ;
    total=0 ;
    while(j<n)total+=Y[j++];
    res+=total*hzntl ;
    return res ;
  }
  public static void main(String arg[]){
    int m=6,n=4 ;
    Integer X[]={
      2,1,3,1,4 };
      Integer Y[]={
        4,1,2 };
        System.out.print(minimumCostOfBreaking(X,Y,m-1,n-1));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumCostOfBreaking( X : Sequence(int), Y : Sequence(int), m : int, n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     X := OclComparator.sortWith(X, reverseOrder()) ; 
    Y := OclComparator.sortWith(Y, reverseOrder()) ; 
    var hzntl : int ; hzntl := 1 ;
    var vert : int ; vert := 1 ;
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    while (i < m & j < n) do (     if (X[i+1] > Y[j+1]) then (     res := res+(X[i+1] * vert) ; 
     hzntl := hzntl + 1 ; 
     i := i + 1 ) else (     res := res+(Y[j+1] * hzntl) ; 
     vert := vert + 1 ; 
     j := j + 1 ) ) ; 
    var total : int ; total := 0 ;
    while (i < m) do      total := total + X[i+1]  ; i := i + 1 ; ; 
    res := res+(total * vert) ; 
    total := 0 ; 
    while (j < n) do      total := total + Y[j+1]  ; j := j + 1 ; ; 
    res := res+(total * hzntl) ; 
    return res 
 );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 6 ;
    var n : int ; n := 4 ;
     var X : Sequence(int) ; X := Sequence{2,1,3,1,4} ;
     var Y : Sequence(int) ; Y := Sequence{4,1,2} ;
     OclFile["System.out"].print(minimumCostOfBreaking(X, Y, m - 1, n - 1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int r=Integer.parseInt(sc.next());
    int d=Integer.parseInt(sc.next());
    int x=Integer.parseInt(sc.next());
    for(int i=0 ; i<10 ; i++){
      x=r*x-d ;
      System.out.println(x);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := (sc.getCurrent())->toInteger() ;
    var d : int ; d := (sc.getCurrent())->toInteger() ;
    var x : int ; x := (sc.getCurrent())->toInteger() ;
        var i : int ; i := 0 ; while i < 10 do ( (     x := r * x - d ; 
     OclFile["System.out"].println(x) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.nio.CharBuffer ;
import java.util.NoSuchElementException ;
public class Main {
  public static void main(String[] args){
    SimpleScanner scanner=new SimpleScanner(System.in);
    PrintWriter writer=new PrintWriter(System.out);
    int r=scanner.nextInt();
    int d=scanner.nextInt();
    long x=scanner.nextLong();
    for(int i=0 ; i<10 ; ++i){
      x=r*x-d ;
      writer.println(x);
    }
    writer.close();
  }
  private static class SimpleScanner {
    private static final int BUFFER_SIZE=10240 ;
    private Readable in ;
    private CharBuffer buffer ;
    private boolean eof ;
    SimpleScanner(InputStream in){
      this.in=new BufferedReader(new InputStreamReader(in));
      buffer=CharBuffer.allocate(BUFFER_SIZE);
      buffer.limit(0);
      eof=false ;
    }
    private char read(){
      if(! buffer.hasRemaining()){
        buffer.clear();
        int n ;
        try {
          n=in.read(buffer);
        }
        catch(IOException e){
          n=-1 ;
        }
        if(n<=0){
          eof=true ;
          return '\0' ;
        }
        buffer.flip();
      }
      return buffer.get();
    }
    void checkEof(){
      if(eof)throw new NoSuchElementException();
    }
    char nextChar(){
      checkEof();
      char b=read();
      checkEof();
      return b ;
    }
    String next(){
      char b ;
      do {
        b=read();
        checkEof();
      }
      while(Character.isWhitespace(b));
      StringBuilder sb=new StringBuilder();
      do {
        sb.append(b);
        b=read();
      }
      while(! eof && ! Character.isWhitespace(b));
      return sb.toString();
    }
    int nextInt(){
      return Integer.valueOf(next());
    }
    long nextLong(){
      return Long.valueOf(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : SimpleScanner ; scanner := SimpleScanner.newSimpleScanner(OclFile["System.in"]) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var r : int ; r := scanner.nextInt() ;
    var d : int ; d := scanner.nextInt() ;
    var x : long ; x := scanner.nextLong() ;
        var i : int ; i := 0 ; while i < 10 do ( (     x := r * x - d ; 
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class SimpleScanner {
  static    attribute BUFFER_SIZE : int := 10240;
   attribute in : Readable;
   attribute buffer : Sequence(int);
   attribute eof : boolean;
   static operation newSimpleScanner( in : OclFile) : SimpleScanner
  pre: true
  post: true
  activity:
  ( var self : SimpleScanner ;
    self := createSimpleScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     self.in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     buffer := CharBuffer.allocate(BUFFER_SIZE) ; 
     buffer := buffer.limit(0) ; 
     eof := false );
   operation read() : String
  pre: true
  post: true
  activity: (     if (not(buffer.hasRemaining())) then (     buffer := buffer->intersection(Set{}) ; 
     var n : int ;
    try (     n := in.read(buffer) )   catch (e : IOException) do (     n := -1 )
    if (n <= 0) then (     eof := true ; 
     return '\0' ) else skip ; 
    buffer := buffer.flip() ; 
 ) else skip ; 
     return buffer.get() );
   operation checkEof() : void
  pre: true
  post: true
  activity: (     if (eof) then     error IncorrectElementException() ; else skip );
   operation nextChar() : String
  pre: true
  post: true
  activity: (     execute checkEof() ; 
     var b : String ; b := read() ;
     execute checkEof() ; 
     return b );
   operation next() : String
  pre: true
  post: true
  activity: (     var b : String ;
   while true do ((     b := read() ; 
     execute checkEof() ) ;
    if ((b->isMatch("[\\t\\n ]")) then skip else break) ; 
    var sb : String ; sb := StringLib.newString() ;
  while true do ((     sb := sb + StringLib.newString(b) ; 
     b := read() ) ;
    if (not(eof) & not((b->isMatch("[\\t\\n ]"))) then skip else break) ; 
    return sb+"" 
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Reader rd=new Reader();
    int r,D,x ;
    {
      int[] a=rd.ii();
      r=a[0];
      D=a[1];
      x=a[2];
    }
    for(int i=0 ; i<10 ; i++){
      x=r*x-D ;
      println(x);
    }
  }
  static void print(Object o){
    System.out.print(o.toString());
  }
  static void println(Object o){
    System.out.println(o.toString());
  }
  static int Int(String s){
    return Integer.parseInt(s);
  }
  static long Long(String s){
    return Long.parseLong(s);
  }
  static class Reader extends BufferedReader {
    Reader(){
      super(new InputStreamReader(System.in));
    }
    String s()throws IOException {
      return readLine();
    }
    String[] ss()throws IOException {
      return s().split(" ");
    }
    int i()throws IOException {
      return Int(s());
    }
    int[] ii()throws IOException {
      String[] ss=ss();
      int size=ss.length ;
      int[] ii=new int[size];
      for(int j=0 ; j<size ; j++)ii[j]=Int(ss[j]);
      return ii ;
    }
    long l()throws IOException {
      return Long(s());
    }
    long[] ll()throws IOException {
      String[] ss=ss();
      int size=ss.length ;
      long[] ll=new long[size];
      for(int j=0 ; j<size ; j++)ll[j]=Long(ss[j]);
      return ll ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var rd : OclFile ; rd := OclFile() ;
     var r : int ;
    var D : int ;
    var x : int ;
 (     var a : Sequence(int) ; a := rd.ii() ;
     r := a[0+1] ; 
     D := a[1+1] ; 
     x := a[2+1] ) 
         var i : int ; i := 0 ; while i < 10 do ( (     x := r * x - D ; 
     execute println(x) )  ;     i := i + 1 ) );
  static   operation print( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o+"") );
  static   operation println( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o+"") );
  static   operation Int( s : String) : int
  pre: true
  post: true
  activity: (     return (s)->toInteger() );
  static   operation Long( s : String) : long
  pre: true
  post: true
  activity: (     return (s)->toLong() );
  static class Reader extends OclFile {
   static operation newReader() : Reader
  pre: true
  post: true
  activity:
  ( var self : Reader ;
    self := createReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation s() : String
  pre: true
  post: true
  activity: (     return readLine() );
   operation ss() : Sequence(String)
  pre: true
  post: true
  activity: (     return s()->split(" ") );
   operation i() : int
  pre: true
  post: true
  activity: (     return Int(s()) );
   operation ii() : Sequence(int)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var size : int ; size := ss->size() ;
    var ii : Sequence(int) ; ii := Integer.subrange(1,size)->collect(0) ;
        var j : int ; j := 0 ; while j < size do (     ii[j+1] := Int(ss[j+1]) ;  ;     j := j + 1 ) ; 
    return ii 
 );
   operation l() : long
  pre: true
  post: true
  activity: (     return Long(s()) );
   operation ll() : Sequence(long)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var size : int ; size := ss->size() ;
    var ll : Sequence(long) ; ll := Integer.subrange(1,size)->collect(0) ;
        var j : int ; j := 0 ; while j < size do (     ll[j+1] := Long(ss[j+1]) ;  ;     j := j + 1 ) ; 
    return ll 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class MEBIP {
  static int N ;
  static boolean[] vis ;
  static int[] color ;
  static long ans=0 ;
  static ArrayList<Integer>[] adj ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    StringTokenizer st=new StringTokenizer(br.readLine());
    N=Integer.parseInt(st.nextToken());
    adj=new ArrayList[N+1];
    color=new int[N+1];
    vis=new boolean[N+1];
    for(int i=1 ; i<=N ; i++)adj[i]=new ArrayList<>();
    for(int i=0 ; i<N-1 ; i++){
      st=new StringTokenizer(br.readLine());
      int u=Integer.parseInt(st.nextToken());
      int v=Integer.parseInt(st.nextToken());
      adj[u] .add(v);
      adj[v] .add(u);
    }
    dfs(1);
    long count0=0 ;
    long count1=0 ;
    for(int i : color){
      count0+=i==0 ? 1 : 0 ;
      count1+=i==1 ? 1 : 0 ;
    }
    count0--;
    ans=count0*count1-(N-1);
    pw.println(ans);
    pw.close();
  }
  public static void dfs(int u){
    vis[u]=true ;
    for(int v : adj[u]){
      if(! vis[v]){
        color[v]=1-color[u];
        dfs(v);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MEBIP {
  static   attribute N : int;
  static   attribute vis : Sequence(boolean);
  static   attribute color : Sequence(int);
  static   attribute ans : long := 0;
  static   attribute adj : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    N := (st.next())->toInteger() ; 
    adj := Integer.subrange(1,N + 1)->collect(null) ; 
    color := Integer.subrange(1,N + 1)->collect(0) ; 
    vis := Integer.subrange(1,N + 1)->collect(false) ; 
        var i : int ; i := 1 ; while i <= N do (     adj[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var u : int ; u := (st.next())->toInteger() ;
    var v : int ; v := (st.next())->toInteger() ;
    adj[u+1]->excludes(v) ; 
    adj[v+1]->excludes(u) ; 
 )  ;     i := i + 1 ) ; 
    execute dfs(1) ; 
    var count0 : long ; count0 := 0 ;
    var count1 : long ; count1 := 0 ;
    for (i : color) do ( (     count0 := count0+(if i = 0 then 1 else 0 endif) ; 
     count1 := count1+(if i = 1 then 1 else 0 endif) )  ) ; 
    count0 := count0 - 1 ; 
    ans := count0 * count1 - (N - 1) ; 
    skip ; 
    skip ; 
 );
  static   operation dfs( u : int) : void
  pre: true
  post: true
  activity: (     vis[u+1] := true ; 
     for (v : adj[u+1]) do ( (     if (not(vis[v+1])) then (     color[v+1] := 1 - color[u+1] ; 
     execute dfs(v) ) else skip )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(in,out);
    out.close();
  }
  static class Task {
    public void solve(InputReader in,PrintWriter out){
      int n=in.nextInt();
      int[] array=new int[1001];
      for(int i=0 ; i<n ; i++){
        int index=in.nextInt();
        array[index]++;
      }
      int countMax=-1 ;
      for(int i=1 ; i<array.length ; i++){
        if(countMax<array[i])countMax=array[i];
      }
      if(n % 2==0){
        if(countMax<=n/2){
          out.println("YES");
        }
        else {
          out.println("NO");
        }
      }
      else {
        if(countMax<=n/2+1){
          out.println("YES");
        }
        else {
          out.println("NO");
        }
      }
    }
  }
  static class InputReader {
    BufferedReader reader ;
    StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
    }
    String next(){
      while(tokenizer==null || ! tokenizer.hasMoreElements()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.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=reader.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var array : Sequence(int) ; array := Integer.subrange(1,1001)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var index : int ; index := in.nextInt() ;
     array[index+1] := array[index+1] + 1 )  ;     i := i + 1 ) ; 
    var countMax : int ; countMax := -1 ;
        var i : int ; i := 1 ; while i < array->size() do ( (     if (countMax < array[i+1]) then     countMax := array[i+1] ; else skip )  ;     i := i + 1 ) ; 
    if (n mod 2 = 0) then (     if (countMax <= n / 2) then (     skip ) else (     skip ) ) else (     if (countMax <= n / 2 + 1) then (     skip ) else (     skip ) ) ;  
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := reader.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    Solver solver=new Solver();
    solver.init();
    solver.readHead(in.readLine());
  }
}
class Solver {
  int N ;
  int cnt ;
  public void init(){
    N=0 ;
    cnt=0 ;
  }
  public void readHead(String str){
    String[] strArr=str.split(" ");
    int r=Integer.parseInt(strArr[0]);
    int D=Integer.parseInt(strArr[1]);
    int x=Integer.parseInt(strArr[2]);
    for(int i=0 ; i<10 ; i++){
      x=r*x-D ;
      System.out.println(x);
    }
  }
  public boolean hasNext(){
    return cnt<N ;
  }
  public void readBody(String str){
    cnt++;
  }
  public void solve(){
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var solver : Solver ; solver := Solver.newSolver() ;
     solver.init() ; 
     solver.readHead(in.readLine()) );
}
class Solver {
   attribute N : int;
   attribute cnt : int;
   operation init() : void
  pre: true
  post: true
  activity: (     N := 0 ; 
     cnt := 0 );
   operation readHead( str : String) : void
  pre: true
  post: true
  activity: (     var strArr : Sequence(String) ; strArr := str->split(" ") ;
     var r : int ; r := (strArr[0+1])->toInteger() ;
    var D : int ; D := (strArr[1+1])->toInteger() ;
    var x : int ; x := (strArr[2+1])->toInteger() ;
        var i : int ; i := 0 ; while i < 10 do ( (     x := r * x - D ; 
     OclFile["System.out"].println(x) )  ;     i := i + 1 ) ; 
 );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return cnt < N );
   operation readBody( str : String) : void
  pre: true
  post: true
  activity: (     cnt := cnt + 1 );
   operation solve() : void
  pre: true
  post: true
  activity: skip;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int r=sc.nextInt();
    int d=sc.nextInt();
    int x2000=sc.nextInt();
    if(r>=2 && r<=5 && d>=1 && d<=100 && x2000>d && x2000<=200){
      int a=((r*x2000)-d);
      System.out.println(a);
      int b=((r*a)-d);
      System.out.println(b);
      int c=((r*b)-d);
      System.out.println(c);
      int e=((r*c)-d);
      System.out.println(e);
      int f=((r*e)-d);
      System.out.println(f);
      int g=((r*f)-d);
      System.out.println(g);
      int h=((r*g)-d);
      System.out.println(h);
      int i=((r*h)-d);
      System.out.println(i);
      int j=((r*i)-d);
      System.out.println(j);
      int k=((r*j)-d);
      System.out.println(k);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var x2000 : int ; x2000 := sc.getCurrent()->toInteger() ;
    if (r >= 2 & r <= 5 & d >= 1 & d <= 100 & x2000 > d & x2000 <= 200) then (     var a : int ; a := ((r * x2000) - d) ;
     OclFile["System.out"].println(a) ; 
    var b : int ; b := ((r * a) - d) ;
    OclFile["System.out"].println(b) ; 
    var c : int ; c := ((r * b) - d) ;
    OclFile["System.out"].println(c) ; 
    var e : int ; e := ((r * c) - d) ;
    OclFile["System.out"].println(e) ; 
    var f : int ; f := ((r * e) - d) ;
    OclFile["System.out"].println(f) ; 
    var g : int ; g := ((r * f) - d) ;
    OclFile["System.out"].println(g) ; 
    var h : int ; h := ((r * g) - d) ;
    OclFile["System.out"].println(h) ; 
    var i : int ; i := ((r * h) - d) ;
    OclFile["System.out"].println(i) ; 
    var j : int ; j := ((r * i) - d) ;
    OclFile["System.out"].println(j) ; 
    var k : int ; k := ((r * j) - d) ;
    OclFile["System.out"].println(k) ; 
 ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GCD {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static int countPairs(int G,int L){
    int count=0 ;
    int p=G*L ;
    for(int a=1 ; a<=L ; a++)if((p % a==0)&& gcd(a,p/a)==G)count++;
    return count ;
  }
  public static void main(String[] args){
    int G=2,L=12 ;
    System.out.print("Total possible pair with GCD "+G);
    System.out.print(" & LCM "+L);
    System.out.print("="+countPairs(G,L));
  }
}
------------------------------------------------------------
OCL File:
---------
class GCD {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation countPairs( G : int, L : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var p : int ; p := G * L ;
         var a : int ; a := 1 ; while a <= L do (     if ((p mod a = 0) & gcd(a, p / a) = G) then     count := count + 1 ; else skip ;  ;     a := a + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var G : int ; G := 2 ;
    var L : int ; L := 12 ;
     OclFile["System.out"].print("Total possible pair with GCD " + G) ; 
     OclFile["System.out"].print(" & LCM " + L) ; 
     OclFile["System.out"].print("=" + countPairs(G, L)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void multiply(int a[][],int b[][]){
    int mul[][]=new int[3][3];
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<3 ; j++){
        mul[i][j]=0 ;
        for(int k=0 ; k<3 ; k++)mul[i][j]+=a[i][k]*b[k][j];
      }
    }
    for(int i=0 ; i<3 ; i++)for(int j=0 ; j<3 ; j++)a[i][j]=mul[i][j];
  }
  static int power(int F[][],int n){
    int M[][]={
      {
        1,1,1 },{
          1,0,0 },{
            0,1,0 }
          };
          if(n==1)return F[0][0]+F[0][1];
          power(F,n/2);
          multiply(F,F);
          if(n % 2!=0)multiply(F,M);
          return F[0][0]+F[0][1];
        }
        static int findNthTerm(int n){
          int F[][]={
            {
              1,1,1 },{
                1,0,0 },{
                  0,1,0 }
                };
                return power(F,n-2);
              }
              public static void main(String[] args){
                int n=5 ;
                System.out.println("F(5)is "+findNthTerm(n));
              }
            }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation multiply( a : Sequence(Sequence(int)), b : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var mul : Sequence(Sequence(int)) ; mul := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
         var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     mul[i+1][j+1] := 0 ; 
         var k : int ; k := 0 ; while k < 3 do (     mul[i+1][j+1] := mul[i+1][j+1]+(a[i+1][k+1] * b[k+1][j+1]) ;  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < 3 do (         var j : int ; j := 0 ; while j < 3 do (     a[i+1][j+1] := mul[i+1][j+1] ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) );
  static   operation power( F : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     var M : Sequence(Sequence(int)) ; M := Sequence{Sequence{1,1,1},Sequence{1,0,0},Sequence{0,1,0}} ;
     if (n = 1) then     return F[0+1][0+1] + F[0+1][1+1] else skip ; 
    execute power(F, n / 2) ; 
    execute multiply(F, F) ; 
    if (n mod 2 /= 0) then     execute multiply(F, M) ; else skip ; 
    return F[0+1][0+1] + F[0+1][1+1] 
 );
  static   operation findNthTerm( n : int) : int
  pre: true
  post: true
  activity: (     var F : Sequence(Sequence(int)) ; F := Sequence{Sequence{1,1,1},Sequence{1,0,0},Sequence{0,1,0}} ;
     return power(F, n - 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println("F(5)is " + findNthTerm(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void MinimumValue(int x,int y){
    if(x>y){
      int temp=x ;
      x=y ;
      y=temp ;
    }
    int a=1 ;
    int b=x-1 ;
    int c=y-b ;
    System.out.print(a+" "+b+" "+c);
  }
  public static void main(String[] args){
    int x=123,y=13 ;
    MinimumValue(x,y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MinimumValue( x : int, y : int) : void
  pre: true
  post: true
  activity: (     if (x > y) then (     var temp : int ; temp := x ;
     x := y ; 
     y := temp ) else skip ; 
     var a : int ; a := 1 ;
    var b : int ; b := x - 1 ;
    var c : int ; c := y - b ;
    OclFile["System.out"].print(a + " " + b + " " + c) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 123 ;
    var y : int ; y := 13 ;
     execute MinimumValue(x, y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public boolean checkPossibility(int[] nums){
    int brokenPoint=0 ;
    for(int i=0 ; i<nums.length-1 ; i++){
      if(nums[i]>nums[i+1]){
        brokenPoint++;
        if(brokenPoint>=2)return false ;
        if(i-1<0 || nums[i-1]<=nums[i+1])nums[i]=nums[i+1];
        else nums[i+1]=nums[i];
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation checkPossibility( nums : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var brokenPoint : int ; brokenPoint := 0 ;
         var i : int ; i := 0 ; while i < nums->size() - 1 do ( (     if (nums[i+1] > nums[i + 1+1]) then (     brokenPoint := brokenPoint + 1 ; 
     if (brokenPoint >= 2) then     return false else skip ; 
     if (i - 1 < 0 or nums[i - 1+1] <= nums[i + 1+1]) then     nums[i+1] := nums[i + 1+1] ; else     nums[i + 1+1] := nums[i+1] ; ) else skip )  ;     i := i + 1 ) ; 
     return true );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean check(int mid,int array[],int n,int K){
    int count=0 ;
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(array[i]>mid)return false ;
      sum+=array[i];
      if(sum>mid){
        count++;
        sum=array[i];
      }
    }
    count++;
    if(count<=K)return true ;
    return false ;
  }
  static int solve(int array[],int n,int K){
    int start=1 ;
    int end=0 ;
    for(int i=0 ; i<n ; i++){
      end+=array[i];
    }
    int answer=0 ;
    while(start<=end){
      int mid=(start+end)/2 ;
      if(check(mid,array,n,K)){
        answer=mid ;
        end=mid-1 ;
      }
      else {
        start=mid+1 ;
      }
    }
    return answer ;
  }
  public static void main(String[] args){
    int array[]={
      1,2,3,4 };
      int n=array.length ;
      int K=3 ;
      System.out.println(solve(array,n,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation check( mid : int, array : Sequence(int), n : int, K : int) : boolean
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (array[i+1] > mid) then     return false else skip ; 
     sum := sum+(array[i+1]) ; 
     if (sum > mid) then (     count := count + 1 ; 
     sum := array[i+1] ) else skip )  ;     i := i + 1 ) ; 
    count := count + 1 ; 
    if (count <= K) then     return true else skip ; 
    return false 
 );
  static   operation solve( array : Sequence(int), n : int, K : int) : int
  pre: true
  post: true
  activity: (     var start : int ; start := 1 ;
     var end : int ; end := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     end := end+(array[i+1]) )  ;     i := i + 1 ) ; 
    var answer : int ; answer := 0 ;
    while (start <= end) do (     var mid : int ; mid := (start + end) / 2 ;
     if (check(mid, array, n, K)) then (     answer := mid ; 
     end := mid - 1 ) else (     start := mid + 1 ) ) ; 
    return answer 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Sequence{1,2,3,4} ;
     var n : int ; n := array->size() ;
     var K : int ; K := 3 ;
     OclFile["System.out"].println(solve(array, n, K)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int M ;
  static int[] memo=new int[1<<22];
  public static void main(String[] args){
    while(true){
      M=sc.nextInt();
      int N=sc.nextInt();
      if(M==0)break ;
      ArrayList<Integer>list=new ArrayList<Integer>();
      for(int i=0 ; i<N ; ++i){
        list.add(Integer.parseInt(sc.next(),2));
      }
      Arrays.fill(memo,-1);
      System.out.println(rec(0,list));
    }
  }
  static int rec(int used,ArrayList<Integer>list){
    if(list.size()<=1)return 0 ;
    if(memo[used]>=0)return memo[used];
    int ret=99 ;
    for(int i=0 ; i<M ; ++i){
      if((used &(3<<(2*i)))!=0)continue ;
      ArrayList<Integer>on=new ArrayList<Integer>();
      ArrayList<Integer>off=new ArrayList<Integer>();
      for(int v : list){
        if((v &(1<<i))!=0){
          on.add(v);
        }
        else {
          off.add(v);
        }
      }
      if(on.isEmpty()|| off.isEmpty())continue ;
      ret=Math.min(ret,Math.max(rec(used |(1<<(2*i)),on),rec(used |(2<<(2*i)),off)));
    }
    memo[used]=ret+1 ;
    return ret+1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute M : int;
  static   attribute memo : Sequence(int) := Integer.subrange(1,(1*(2->pow(22)))->oclAsType(long))->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     M := sc.getCurrent()->toInteger() ; 
     var N : int ; N := sc.getCurrent()->toInteger() ;
    if (M = 0) then     break else skip ; 
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     list := list->including((sc.getCurrent())->toInteger()) )  ;     i := i + 1 ) ; 
    memo := memo->collect(-1) ; 
    OclFile["System.out"].println(rec(0, list)) ; 
 ) );
  static   operation rec( used : int, list : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (list->size() <= 1) then     return 0 else skip ; 
     if (memo[used+1] >= 0) then     return memo[used+1] else skip ; 
    var ret : int ; ret := 99 ;
        var i : int ; i := 0 ; while i < M do ( (     if ((used & ((3*(2->pow((2 * i))))->oclAsType(long))) /= 0) then     continue else skip ; 
     var on : Sequence(int) ; on := Sequence{} ;
    var off : Sequence(int) ; off := Sequence{} ;
    for (v : list) do ( (     if ((v & ((1*(2->pow(i)))->oclAsType(long))) /= 0) then (     on := on->including(v) ) else (     off := off->including(v) ) )  ) ; 
    if (on->isEmpty() or off->isEmpty()) then     continue else skip ; 
    ret := Set{ret, Set{rec(used or ((1*(2->pow((2 * i))))->oclAsType(long)), on), rec(used or ((2*(2->pow((2 * i))))->oclAsType(long)), off)}->max()}->min() ; 
 )  ;     i := i + 1 ) ; 
    memo[used+1] := ret + 1 ; 
    return ret + 1 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().solver();
  }
  int[][] memo ;
  int[] ans ;
  int n,m ;
  int rep(int masked,int answer){
    if(memo[masked][answer]!=-1){
      return memo[masked][answer];
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if((ans[i] & masked)==answer){
        count++;
      }
    }
    if(count<=1){
      memo[masked][answer]=0 ;
      return 0 ;
    }
    int min=1000 ;
    for(int i=0 ; i<m ; i++){
      int shi=1<<i ;
      if((masked & shi)!=0){
        continue ;
      }
      int z=shi ;
      min=Math.min(min,Math.max(rep(masked | z,answer),rep(masked | z,answer | z)));
    }
    memo[masked][answer]=min+1 ;
    return min+1 ;
  }
  void solver(){
    Scanner sc=new Scanner(System.in);
    while(true){
      m=sc.nextInt();
      n=sc.nextInt();
      memo=new int[1<<11][1<<11];
      for(int i=0 ; i<(1<<11); i++){
        Arrays.fill(memo[i],-1);
      }
      if(m==0 && n==0)break ;
      ans=new int[n];
      for(int i=0 ; i<n ; i++){
        ans[i]=sc.nextInt(2);
      }
      int m=rep(0,0);
      System.out.println(m);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solver() );
   attribute memo : Sequence(Sequence(int));
   attribute ans : Sequence(int);
   attribute n : int;
   operation rep( masked : int, answer : int) : int
  pre: true
  post: true
  activity: (     if (memo[masked+1][answer+1] /= -1) then (     return memo[masked+1][answer+1] ) else skip ; 
     var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if ((MathLib.bitwiseAnd(ans[i+1],masked)) = answer) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (count <= 1) then (     memo[masked+1][answer+1] := 0 ; 
     return 0 ) else skip ; 
    var min : int ; min := 1000 ;
        var i : int ; i := 0 ; while i < m do ( (     var shi : int ; shi := (1*(2->pow(i)))->oclAsType(long) ;
     if ((masked & shi) /= 0) then (     continue ) else skip ; 
     var z : int ; z := shi ;
     min := Set{min, Set{rep(masked or z, answer), rep(masked or z, answer or z)}->max()}->min() )  ;     i := i + 1 ) ; 
    memo[masked+1][answer+1] := min + 1 ; 
    return min + 1 
 );
   operation solver() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     m := sc.getCurrent()->toInteger() ; 
     n := sc.getCurrent()->toInteger() ; 
    memo := Integer.subrange(1,(1*(2->pow(11)))->oclAsType(long))->collect(Integer.subrange(1,(1*(2->pow(11)))->oclAsType(long))->collect(0)) ; 
        var i : int ; i := 0 ; while i < ((1*(2->pow(11)))->oclAsType(long)) do ( (     memo[i+1] := memo[i+1]->collect(-1) )  ;     i := i + 1 ) ; 
    if (m = 0 & n = 0) then     break else skip ; 
    ans := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     ans[i+1] := sc.nextInt(2) )  ;     i := i + 1 ) ; 
    var m : int ; m := rep(0, 0) ;
    OclFile["System.out"].println(m) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static int m,n ;
  private static int[][] memo=new int[1<<11][1<<11];
  private static int[] f=new int[128];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      m=sc.nextInt();
      n=sc.nextInt();
      if(m==0 && n==0)break ;
      for(int i=0 ; i<n ; i++){
        f[i]=sc.nextInt(2);
      }
      for(int i=0 ; i<(1<<m); i++){
        for(int j=0 ; j<(1<<m); j++){
          memo[i][j]=-1 ;
        }
      }
      System.out.println(dp(0,0));
    }
  }
  private static int dp(int q,int a){
    if(memo[q][a]!=-1)return memo[q][a];
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if((q & f[i])==a)count++;
    }
    if(count<=1){
      memo[q][a]=0 ;
      return memo[q][a];
    }
    int res=10000 ;
    for(int i=0 ; i<m ; i++){
      if((q>>i)% 2==1)continue ;
      res=Math.min(res,Math.max(dp(q |(1<<i),a),dp(q |(1<<i),a |(1<<i))));
    }
    memo[q][a]=res+1 ;
    return memo[q][a];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute m : int;
  static   attribute memo : Sequence(Sequence(int)) := Integer.subrange(1,(1*(2->pow(11)))->oclAsType(long))->collect(Integer.subrange(1,(1*(2->pow(11)))->oclAsType(long))->collect(0));
  static   attribute f : Sequence(int) := Integer.subrange(1,128)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     m := sc.getCurrent()->toInteger() ; 
     n := sc.getCurrent()->toInteger() ; 
    if (m = 0 & n = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     f[i+1] := sc.nextInt(2) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < ((1*(2->pow(m)))->oclAsType(long)) do ( (         var j : int ; j := 0 ; while j < ((1*(2->pow(m)))->oclAsType(long)) do ( (     memo[i+1][j+1] := -1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp(0, 0)) ; 
 ) );
  static   operation dp( q : int, a : int) : int
  pre: true
  post: true
  activity: (     if (memo[q+1][a+1] /= -1) then     return memo[q+1][a+1] else skip ; 
     var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if ((q & f[i+1]) = a) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (count <= 1) then (     memo[q+1][a+1] := 0 ; 
     return memo[q+1][a+1] ) else skip ; 
    var res : int ; res := 10000 ;
        var i : int ; i := 0 ; while i < m do ( (     if (((q/(2->pow(i)))->oclAsType(long)) mod 2 = 1) then     continue else skip ; 
     res := Set{res, Set{dp(q or ((1*(2->pow(i)))->oclAsType(long)), a), dp(q or ((1*(2->pow(i)))->oclAsType(long)), a or ((1*(2->pow(i)))->oclAsType(long)))}->max()}->min() )  ;     i := i + 1 ) ; 
    memo[q+1][a+1] := res + 1 ; 
    return memo[q+1][a+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class AAB {
  static int maxSumPair(int arr1[],int n1,int arr2[],int n2){
    int max1=Integer.MIN_VALUE ;
    int max2=Integer.MIN_VALUE ;
    for(int i=0 ; i<n1 ; i++){
      if(arr1[i]>max1)max1=arr1[i];
    }
    for(int i=0 ; i<n2 ; i++){
      if(arr2[i]>max2)max2=arr2[i];
    }
    return max1+max2 ;
  }
  public static void main(String[] args){
    int arr1[]={
      10,2,3 };
      int arr2[]={
        3,4,7 };
        int n1=arr1.length ;
        int n2=arr2.length ;
        System.out.println(maxSumPair(arr1,n1,arr2,n2));
      }
    }

------------------------------------------------------------
OCL File:
---------
class AAB {
  static   operation maxSumPair( arr1 : Sequence(int), n1 : int, arr2 : Sequence(int), n2 : int) : int
  pre: true
  post: true
  activity: (     var max1 : int ; max1 := -2147483648 ;
     var max2 : int ; max2 := -2147483648 ;
        var i : int ; i := 0 ; while i < n1 do ( (     if (arr1[i+1] > max1) then     max1 := arr1[i+1] ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n2 do ( (     if (arr2[i+1] > max2) then     max2 := arr2[i+1] ; else skip )  ;     i := i + 1 ) ; 
    return max1 + max2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{10,2,3} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{3,4,7} ;
    var n1 : int ; n1 := arr1->size() ;
    var n2 : int ; n2 := arr2->size() ;
    OclFile["System.out"].println(maxSumPair(arr1, n1, arr2, n2)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1433B_YetAnotherBookshelf {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int amount=parseInt(input.nextLine());
      List<Integer>list=new LinkedList<>();
      for(int i=0 ; i<amount ; i++){
        list.add(input.nextInt());
      }
      input.nextLine();
      int firstIndex=list.indexOf(1);
      int lastIndex=list.lastIndexOf(1);
      list=list.subList(firstIndex,lastIndex);
      System.out.println(Collections.frequency(list,0));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1433B_YetAnotherBookshelf {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var amount : int ; amount := parseInt(input.nextLine()) ;
     var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < amount do ( (     list := list->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    skip ; 
    var firstIndex : int ; firstIndex := list->indexOf(1)-1 ;
    var lastIndex : int ; lastIndex := list->lastIndexOf(1)-1 ;
    list := list.subrange(firstIndex+1,lastIndex) ; 
    OclFile["System.out"].println(frequency(list, 0)) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  int n ;
  int s ;
  int[] ans ;
  int memo[][];
  int rep(int masked,int answer){
    if(memo[masked][answer]!=-1){
      return memo[masked][answer];
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if((ans[i] & masked)==answer){
        count++;
      }
    }
    if(count<2){
      memo[masked][answer]=0 ;
      return 0 ;
    }
    int min=100 ;
    for(int i=0 ; i<s ; i++){
      int shi=1<<i ;
      if((masked & shi)!=0){
        continue ;
      }
      int z=shi ;
      min=Math.min(min,Math.max(rep(masked | z,answer),rep(masked | z,answer | z)));
    }
    memo[masked][answer]=min+1 ;
    return min+1 ;
  }
  void run(){
    memo=new int[1<<11][1<<11];
    for(; ; ){
      s=sc.nextInt();
      n=sc.nextInt();
      if(s+n==0){
        break ;
      }
      ans=new int[n];
      for(int i=0 ; i<n ; i++){
        ans[i]=sc.nextInt(2);
      }
      for(int i=0 ; i<1<<11 ; i++){
        Arrays.fill(memo[i],-1);
      }
      int m=rep(0,0);
      System.out.println(m);
    }
  }
  public static void main(String[] a){
    Main aa=new Main();
    aa.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute n : int;
   attribute s : int;
   attribute ans : Sequence(int);
   attribute memo : Sequence(Sequence(int));
   operation rep( masked : int, answer : int) : int
  pre: true
  post: true
  activity: (     if (memo[masked+1][answer+1] /= -1) then (     return memo[masked+1][answer+1] ) else skip ; 
     var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if ((MathLib.bitwiseAnd(ans[i+1],masked)) = answer) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (count < 2) then (     memo[masked+1][answer+1] := 0 ; 
     return 0 ) else skip ; 
    var min : int ; min := 100 ;
        var i : int ; i := 0 ; while i < s do ( (     var shi : int ; shi := (1*(2->pow(i)))->oclAsType(long) ;
     if ((masked & shi) /= 0) then (     continue ) else skip ; 
     var z : int ; z := shi ;
     min := Set{min, Set{rep(masked or z, answer), rep(masked or z, answer or z)}->max()}->min() )  ;     i := i + 1 ) ; 
    memo[masked+1][answer+1] := min + 1 ; 
    return min + 1 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     memo := Integer.subrange(1,(1*(2->pow(11)))->oclAsType(long))->collect(Integer.subrange(1,(1*(2->pow(11)))->oclAsType(long))->collect(0)) ; 
       while true do ( (     s := sc.getCurrent()->toInteger() ; 
     n := sc.getCurrent()->toInteger() ; 
    if (s + n = 0) then (     break ) else skip ; 
    ans := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     ans[i+1] := sc.nextInt(2) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < (1*(2->pow(11)))->oclAsType(long) do ( (     memo[i+1] := memo[i+1]->collect(-1) )  ;     i := i + 1 ) ; 
    var m : int ; m := rep(0, 0) ;
    OclFile["System.out"].println(m) ; 
 )  ) );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var aa : Main ; aa := Main.newMain() ;
     aa.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int a=sc.nextInt();
      int b=sc.nextInt();
      System.out.println(solve(a,b));
    }
    sc.close();
  }
  static int solve(int a,int b){
    return Math.min(Math.min(computeSquareArea(a+a,b),computeSquareArea(a+b,Math.max(a,b))),computeSquareArea(a,b+b));
  }
  static int computeSquareArea(int side1,int side2){
    int size=Math.max(side1,side2);
    return size*size ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(a, b)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return Set{Set{computeSquareArea(a + a, b), computeSquareArea(a + b, Set{a, b}->max())}->min(), computeSquareArea(a, b + b)}->min() );
  static   operation computeSquareArea( side1 : int, side2 : int) : int
  pre: true
  post: true
  activity: (     var size : int ; size := Set{side1, side2}->max() ;
     return size * size );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class square {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    while(n-->0){
      int a=in.nextInt();
      int b=in.nextInt();
      if(b>a)a*=2 ;
      else b*=2 ;
      int area=Math.max(a,b)*Math.max(a,b);
      System.out.println(area);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class square {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    if (b > a) then     a := a*(2) else     b := b*(2) ; ;  
    var area : int ; area := Set{a, b}->max() * Set{a, b}->max() ;
    OclFile["System.out"].println(area) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test120 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      int w=in.nextInt();
      int h=in.nextInt();
      if(w>h){
        if(2*h>=w){
          System.out.println((int)Math.pow(2*h,2));
        }
        else {
          System.out.println((int)Math.pow(w,2));
        }
      }
      else {
        if(2*w>=h){
          System.out.println((int)Math.pow(2*w,2));
        }
        else {
          System.out.println((int)Math.pow(h,2));
        }
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test120 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var w : int ; w := in.getCurrent()->toInteger() ;
     var h : int ; h := in.getCurrent()->toInteger() ;
     if (w > h) then (     if (2 * h >= w) then (     OclFile["System.out"].println(2 * h->pow(2)->oclAsType(int)) ) else (     OclFile["System.out"].println(w->pow(2)->oclAsType(int)) ) ) else (     if (2 * w >= h) then (     OclFile["System.out"].println(2 * w->pow(2)->oclAsType(int)) ) else (     OclFile["System.out"].println(h->pow(2)->oclAsType(int)) ) ) )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class _1360A_MinimalSquare {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=Integer.parseInt(input.nextLine());
    while(test-->0){
      int a=input.nextInt();
      int b=input.nextInt();
      input.nextLine();
      int min=Math.min(a,b);
      int max=Math.max(a,b);
      int side=Math.max(max,2*min);
      System.out.println(side*side);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1360A_MinimalSquare {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := (input.nextLine())->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var a : int ; a := input.getCurrent()->toInteger() ;
     var b : int ; b := input.getCurrent()->toInteger() ;
    skip ; 
    var min : int ; min := Set{a, b}->min() ;
    var max : int ; max := Set{a, b}->max() ;
    var side : int ; side := Set{max, 2 * min}->max() ;
    OclFile["System.out"].println(side * side) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int AG=sc.nextInt();
    while(AG-->0){
      int K=sc.nextInt();
      int P=sc.nextInt();
      int arq,valtm,cntm ;
      if(K>P){
        valtm=K ;
        cntm=P ;
      }
      else {
        valtm=P ;
        cntm=K ;
      }
      cntm=2*cntm ;
      if(valtm>cntm){
        arq=valtm*valtm ;
      }
      else arq=cntm*cntm ;
      System.out.println(arq);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var AG : int ; AG := sc.getCurrent()->toInteger() ;
         while (AG > 0) do (        AG := AG - 1 ;     skip ; (     var K : int ; K := sc.getCurrent()->toInteger() ;
     var P : int ; P := sc.getCurrent()->toInteger() ;
    var arq : int ;
    var valtm : int ;
    var cntm : int ;
    if (K > P) then (     valtm := K ; 
     cntm := P ) else (     valtm := P ; 
     cntm := K ) ;  
    cntm := 2 * cntm ; 
    if (valtm > cntm) then (     arq := valtm * valtm ) else     arq := cntm * cntm ; ;  
    OclFile["System.out"].println(arq) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Solution {
  public static boolean solve(int a[],int b[],int n){
    int[] ans=new int[n];
    int max=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      max=Math.max(max,(a[i]-b[i]));
    }
    if(max<0){
      return false ;
    }
    for(int i=0 ; i<n ; i++){
      int temp=a[i]-max ;
      if(temp<=0){
        ans[i]=0 ;
      }
      else {
        ans[i]=temp ;
      }
    }
    for(int i=0 ; i<n ; i++){
      if(ans[i]!=b[i]){
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int a[]=new int[n];
      int b[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        b[i]=sc.nextInt();
      }
      if(solve(a,b,n)==true){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation solve( a : Sequence(int), b : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
     var max : int ; max := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     max := Set{max, (a[i+1] - b[i+1])}->max() )  ;     i := i + 1 ) ; 
    if (max < 0) then (     return false ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     var temp : int ; temp := a[i+1] - max ;
     if (temp <= 0) then (     ans[i+1] := 0 ) else (     ans[i+1] := temp ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (ans[i+1] /= b[i+1]) then (     return false ) else skip )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (solve(a, b, n) = true) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static int countFreq(String str,String txt){
    int index=0,count=0 ;
    while((index=str.indexOf(txt,index))!=-1){
      count++;
      index++;
    }
    return count ;
  }
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        String s=sc.next();
        int n=s.length();
        StringBuilder str=new StringBuilder(s);
        String s1="ab" ;
        String s2="ba" ;
        int a1=countFreq(s,s1);
        int a2=countFreq(s,s2);
        if(a1==a2)System.out.println(s);
        else {
          if(a1-a2==1){
            str.setCharAt(n-1,'a');
          }
          else {
            str.setCharAt(n-1,'b');
          }
          System.out.println(str);
        }
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation countFreq( str : String, txt : String) : int
  pre: true
  post: true
  activity: (     var index : int ; index := 0 ;
    var count : int ; count := 0 ;
         index := str.subrange(index+1)->indexOf(txt+"") + index - 1  ;
    while ((index) /= -1) do (    skip ; (     count := count + 1 ; 
     index := index + 1 ) ;     index := str.subrange(index+1)->indexOf(txt+"") + index - 1  ;
 ) ;  
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : String ; s := sc.getCurrent() ;
     var n : int ; n := s->size() ;
    var str : String ; str := StringLib.newString(s) ;
    var s1 : String ; s1 := "ab" ;
    var s2 : String ; s2 := "ba" ;
    var a1 : int ; a1 := countFreq(s, s1) ;
    var a2 : int ; a2 := countFreq(s, s2) ;
    if (a1 = a2) then     OclFile["System.out"].println(s) else (     if ((a1)->char2byte() - a2 = 1) then (     str := str.setAt((n)->char2byte() - 1+1, 'a') ) else (     str := str.setAt((n)->char2byte() - 1+1, 'b') ) ;  
     OclFile["System.out"].println(str) ) ;  
 ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      String s=sc.next();
      System.out.println(solve(s));
    }
    sc.close();
  }
  static String solve(String s){
    return(s.charAt(0)==s.charAt(s.length()-1))? s : String.format("a%sa",s.substring(1,s.length()-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var s : String ; s := sc.getCurrent() ;
     OclFile["System.out"].println(solve(s)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( s : String) : String
  pre: true
  post: true
  activity: (     return if (s->at(0+1) = s->at(s->size() - 1+1)) then s else StringLib.format("a%sa",Sequence{s.subrange(1+1,s->size() - 1)}) endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class practice2 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String str=sc.nextLine();
    int pos=str.indexOf('^');
    long sum=0 ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)!='=' && str.charAt(i)!='^'){
        sum+=(str.charAt(i)-'0')*(i-pos);
      }
    }
    if(sum==0)System.out.println("balance");
    else if(sum<0)System.out.println("left");
    else System.out.println("right");
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.nextLine() ;
    var pos : int ; pos := str->indexOf('^')-1 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) /= '=' & str->at(i+1) /= '^') then (     sum := sum+((str->at(i+1) - ('0')->char2byte()) * (i - (pos)->char2byte())) ) else skip )  ;     i := i + 1 ) ; 
    if (sum = 0) then     OclFile["System.out"].println("balance") else     if (sum < 0) then     OclFile["System.out"].println("left") else     OclFile["System.out"].println("right") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int operations(int op[],int n,int k){
    int i,count=0 ;
    int nVal=0 ;
    int min=Integer.MAX_VALUE ;
    for(i=0 ; i<n ; i++){
      nVal+=op[i];
      min=Math.min(min,nVal);
      if((k+nVal)<=0)return(i+1);
    }
    if(nVal>=0)return-1 ;
    int times=(k-Math.abs(min))/Math.abs(nVal);
    k=(k-(times*Math.abs(nVal)));
    count=(times*n);
    while(k>0){
      for(i=0 ; i<n ; i++){
        k=k+op[i];
        count++;
        if(k<=0)break ;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int op[]={
-60,65,-1,14,-25 };
      int n=op.length ;
      int k=100000 ;
      System.out.print(operations(op,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation operations( op : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var count : int ; count := 0 ;
     var nVal : int ; nVal := 0 ;
    var min : int ; min := 2147483647 ;
        i := 0 ; while i < n do ( (     nVal := nVal+(op[i+1]) ; 
     min := Set{min, nVal}->min() ; 
     if ((k + nVal) <= 0) then     return (i + 1) else skip )  ;     i := i + 1 ) ; 
    if (nVal >= 0) then     return -1 else skip ; 
    var times : int ; times := (k - if min < 0 then -(min) else min endif) / if nVal < 0 then -(nVal) else nVal endif ;
    k := (k - (times * if nVal < 0 then -(nVal) else nVal endif)) ; 
    count := (times * n) ; 
    while (k > 0) do (         i := 0 ; while i < n do ( (     k := k + op[i+1] ; 
     count := count + 1 ; 
     if (k <= 0) then     break else skip )  ;     i := i + 1 ) ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var op : Sequence(int) ; op := Sequence{-60,65,-1,14,-25} ;
     var n : int ; n := op->size() ;
     var k : int ; k := 100000 ;
     OclFile["System.out"].print(operations(op, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class balance {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        String s=sc.next();
        int n=s.length();
        if(s.charAt(0)!=s.charAt(n-1))System.out.println(s.substring(0,n-1)+s.charAt(0));
        else System.out.println(s);
      }
    }
    catch(Exception e){
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class balance {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : String ; s := sc.getCurrent() ;
     var n : int ; n := s->size() ;
     if (s->at(0+1) /= s->at((n)->char2byte() - 1+1)) then     OclFile["System.out"].println(s.subrange(0+1,(n)->char2byte() - 1) + s->at(0+1)) ; else     OclFile["System.out"].println(s) ; ) ;  ) )   catch (e : ProgramException) do (     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Yet_Another_Bookshelf {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testcase=sc.nextInt();
    while(testcase!=0){
      testcase--;
      int count=0,start=0,end=0,len=sc.nextInt();
      boolean start_e=false ;
      int arr[]=new int[len];
      for(int i=0 ; i<len ; i++){
        arr[i]=sc.nextInt();
        if(arr[i]==1 && ! start_e){
          start=i ;
          start_e=true ;
        }
      }
      for(int i=len-1 ; i>=0 ; i--){
        if(arr[i]==1){
          end=i ;
          break ;
        }
      }
      for(int i=start ; i<=end ; i++){
        if(arr[i]==0){
          count++;
        }
      }
      System.out.print(count);
      if(testcase>0)System.out.println();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Yet_Another_Bookshelf {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testcase : int ; testcase := sc.getCurrent()->toInteger() ;
     while (testcase /= 0) do (     testcase := testcase - 1 ; 
     var count : int ; count := 0 ;
    var start : int ; start := 0 ;
    var end : int ; end := 0 ;
    var len : int ; len := sc.getCurrent()->toInteger() ;
    var start_e : boolean ; start_e := false ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,len)->collect(0) ;
        var i : int ; i := 0 ; while i < len do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr[i+1] = 1 & not(start_e)) then (     start := i ; 
     start_e := true ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := len - 1 ; while i >= 0 do ( (     if (arr[i+1] = 1) then (     end := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
        var i : int ; i := start ; while i <= end do ( (     if (arr[i+1] = 0) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(count) ; 
    if (testcase > 0) then     OclFile["System.out"].println() ; else skip ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String even_or_odd(String N){
    int len=N.length();
    if(N.charAt(len-1)=='0' || N.charAt(len-1)=='2' || N.charAt(len-1)=='4' || N.charAt(len-1)=='6')return("Even");
    else return("Odd");
  }
  public static void main(String[] args){
    String N="735" ;
    System.out.print(even_or_odd(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation even_or_odd( N : String) : String
  pre: true
  post: true
  activity: (     var len : int ; len := N->size() ;
     if (N->at(len - 1+1) = '0' or N->at(len - 1+1) = '2' or N->at(len - 1+1) = '4' or N->at(len - 1+1) = '6') then     return ("Even") else     return ("Odd") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : String ; N := "735" ;
     OclFile["System.out"].print(even_or_odd(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Vector {
  int[] A ;
  int length=0 ;
  Vector(){
    A=new int[20];
  }
  void add(int x){
    if(length==A.length){
      A=Arrays.copyOf(A,length*2);
    }
    A[length]=x ;
    length++;
  }
  void deleteBack(){
    length--;
  }
  public String toString(){
    StringBuilder sb=new StringBuilder();
    if(length>0)sb.append(A[0]);
    for(int i=1 ; i<length ; ++i){
      sb.append(" ");
      sb.append(A[i]);
    }
    return sb.toString();
  }
}
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),q=sc.nextInt();
    Vector[] v=new Vector[n];
    boolean[] active=new boolean[n];
    for(int i=0 ; i<q ; ++i){
      int req=sc.nextInt(),t=sc.nextInt();
      switch(req){
        case 0 : if(! active[t]){
          v[t]=new Vector();
          active[t]=true ;
        }
        v[t] .add(sc.nextInt());
        break ;
        case 1 : if(active[t])System.out.println(v[t]);
        else System.out.println();
        break ;
        case 2 : active[t]=false ;
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Vector {
   attribute A : Sequence(int);
   attribute length : int := 0;
   static operation newVector() : Vector
  pre: true
  post: true
  activity:
  ( var self : Vector ;
    self := createVector();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     A := Integer.subrange(1,20)->collect(0) );
   operation add( x : int) : void
  pre: true
  post: true
  activity: (     if (length = A->size()) then (     A := A.subrange(1,length * 2) ) else skip ; 
     A[length+1] := x ; 
     length := length + 1 );
   operation deleteBack() : void
  pre: true
  post: true
  activity: (     length := length - 1 );
   operation toString() : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     if (length > 0) then     sb := sb + StringLib.newString(A[0+1]) ; else skip ; 
         var i : int ; i := 1 ; while i < length do ( (     sb := sb + StringLib.newString(" ") ; 
     sb := sb + StringLib.newString(A[i+1]) )  ;     i := i + 1 ) ; 
     return sb+"" );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var v : Sequence(Sequence) ; v := Integer.subrange(1,n)->collect(null) ;
    var active : Sequence(boolean) ; active := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < q do ( (     var req : int ; req := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (req) ; 
       if _switchval = 0 then
     if (not(active[t+1])) then (     v[t+1] := Sequence{} ; 
     active[t+1] := true ) else skip ; 
    v[t+1]->excludes(sc.getCurrent()->toInteger()) ; 
    break 
   else skip ;
       if _switchval = 1 then
     if (active[t+1]) then     OclFile["System.out"].println(v[t+1]) else     OclFile["System.out"].println() ; ;  
    break 
   else skip ;
       if _switchval = 2 then
     active[t+1] := false ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt(),loop=in.nextInt();
    ArrayList<ArrayList<Integer>>vector2=new ArrayList<ArrayList<Integer>>();
    for(int i=0 ; i<n ; i++){
      ArrayList<Integer>arr=new ArrayList<>();
      vector2.add(arr);
    }
    for(int i=0 ; i<loop ; i++){
      int odr=Integer.parseInt(in.next()),index=Integer.parseInt(in.next());
      switch(odr){
        case 0 : vector2.get(index).add(Integer.parseInt(in.next()));
        break ;
        case 1 : int length=vector2.get(index).size();
        for(int j=0 ; j<length ; j++){
          out.printf("%d%s",vector2.get(index).get(j),(j<length-1)? " " : "");
        }
        out.println();
        break ;
        case 2 : vector2.get(index).clear();
        break ;
      }
    }
    out.flush();
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var loop : int ; loop := in.getCurrent()->toInteger() ;
    var vector2 : Sequence(Sequence(int)) ; vector2 := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var arr : Sequence(int) ; arr := Sequence{} ;
     vector2 := vector2->including(arr) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < loop do ( (     var odr : int ; odr := (in.getCurrent())->toInteger() ;
    var index : int ; index := (in.getCurrent())->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (odr) ; 
       if _switchval = 0 then
     vector2->at(index+1)->excludes((in.getCurrent())->toInteger()) ; 
    break 
   else skip ;
       if _switchval = 1 then
     var length : int ; length := vector2->at(index+1)->size() ;
        var j : int ; j := 0 ; while j < length do ( (     skip )  ;     j := j + 1 ) ; 
    skip ; 
    break 
   else skip ;
       if _switchval = 2 then
     vector2 := vector2->at(index+1)->intersection(Set{}) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Iterator ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.ListIterator ;
import java.util.Vector ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] tmpArray=br.readLine().split(" ");
    int n=Integer.parseInt(tmpArray[0]);
    int q=Integer.parseInt(tmpArray[1]);
    @ SuppressWarnings("unchecked")Vector<Integer>[] vecArray=new Vector[n];
    for(int i=0 ; i<n ; i++){
      vecArray[i]=new Vector<Integer>();
    }
    for(int i=0 ; i<q ; i++){
      tmpArray=br.readLine().split(" ");
      if(tmpArray[0] .equals("0")){
        int t=Integer.parseInt(tmpArray[1]);
        int x=Integer.parseInt(tmpArray[2]);
        vecArray[t] .add(x);
      }
      else if(tmpArray[0] .equals("1")){
        int t=Integer.parseInt(tmpArray[1]);
        printVec(vecArray[t]);
      }
      else {
        int t=Integer.parseInt(tmpArray[1]);
        vecArray[t]=new Vector<Integer>();
      }
    }
  }
  static void printVec(Vector vec){
    Iterator it=vec.iterator();
    StringBuffer sb=new StringBuffer();
    while(it.hasNext()){
      sb.append(it.next());
      if(it.hasNext()){
        sb.append(" ");
      }
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
    var n : int ; n := (tmpArray[0+1])->toInteger() ;
    var q : int ; q := (tmpArray[1+1])->toInteger() ;
    var vecArray : Sequence(Sequence(int)) ; vecArray := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     vecArray[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     tmpArray := br.readLine()->split(" ") ; 
     if (tmpArray[0+1] = "0") then (     var t : int ; t := (tmpArray[1+1])->toInteger() ;
     var x : int ; x := (tmpArray[2+1])->toInteger() ;
     vecArray[t+1]->excludes(x) ) else     if (tmpArray[0+1] = "1") then (     var t : int ; t := (tmpArray[1+1])->toInteger() ;
     execute printVec(vecArray[t+1]) ) else (     var t : int ; t := (tmpArray[1+1])->toInteger() ;
     vecArray[t+1] := Sequence{} ) ;  )  ;     i := i + 1 ) ; 
 );
  static   operation printVec( vec : Sequence) : void
  pre: true
  post: true
  activity: (     var it : OclIterator ; it := vec->iterator() ;
     var sb : String ; sb := StringLib.newString() ;
     while (it.hasNext()) do (     sb := sb + StringLib.newString(it.next()) ; 
     if (it.hasNext()) then (     sb := sb + StringLib.newString(" ") ) else skip ) ; 
     OclFile["System.out"].println(sb) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Vector ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      Vector<Vector<Integer>>vec=new Vector<>();
      int n=sc.nextInt();
      int q=sc.nextInt();
      int i,j ;
      for(i=0 ; i<n ; i++){
        vec.add(new Vector<>());
      }
      for(i=0 ; i<q ; i++){
        int order_number=sc.nextInt();
        int t=sc.nextInt();
        switch(order_number){
          case 0 : vec.get(t).add(sc.nextInt());
          break ;
          case 1 : for(j=0 ;
          j<vec.get(t).size();
          j++){
            if(j==vec.get(t).size()-1){
              System.out.print(vec.get(t).get(j));
            }
            else {
              System.out.print(vec.get(t).get(j)+" ");
            }
          }
          System.out.println();
          break ;
          case 2 : vec.get(t).clear();
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var vec : Sequence(Sequence(int)) ; vec := Sequence{} ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var i : int ;
    var j : int ;
        i := 0 ; while i < n do ( (     vec := vec->including(Sequence{}) )  ;     i := i + 1 ) ; 
        i := 0 ; while i < q do ( (     var order_number : int ; order_number := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (order_number) ; 
       if _switchval = 0 then
     vec->at(t+1)->excludes(sc.getCurrent()->toInteger()) ; 
    break 
   else skip ;
       if _switchval = 1 then
         j := 0 ; while j < vec->at(t+1)->size() do ( (     if (j = vec->at(t+1)->size() - 1) then (     OclFile["System.out"].print(vec->at(t+1)->at(j+1)) ) else (     OclFile["System.out"].print(vec->at(t+1)->at(j+1) + " ") ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println() ; 
    break 
   else skip ;
       if _switchval = 2 then
     vec := vec->at(t+1)->intersection(Set{}) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class pr6 {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt(),k1=0,k2=0,w1=0,w2=0,a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scan.nextInt();
      if(a[i] % 2==0){
        w1++;
        k1=i+1 ;
      }
      else {
        w2++;
        k2=i+1 ;
      }
    }
    System.out.println((w1==1)? k1 : k2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pr6 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k1 : int ; k1 := 0 ;
    var k2 : int ; k2 := 0 ;
    var w1 : int ; w1 := 0 ;
    var w2 : int ; w2 := 0 ;
    var a : Sequence(void) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() ; 
     if (a[i+1] mod 2 = 0) then (     w1 := w1 + 1 ; 
     k1 := i + 1 ) else (     w2 := w2 + 1 ; 
     k2 := i + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if (w1 = 1) then k1 else k2 endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class AIQTest {
  public static void main(String[] args){
    Scanner ob=new Scanner(System.in);
    int n=ob.nextInt();
    int array[]=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      array[i]=ob.nextInt();
    }
    int odd=0,even=0,odd_ind=0,even_ind=0 ;
    for(int i=1 ; i<=n ; i++){
      if(array[i] % 2==0){
        even++;
        even_ind=i ;
      }
      else {
        odd++;
        odd_ind=i ;
      }
    }
    if(odd>even)System.out.println(even_ind);
    else System.out.println(odd_ind);
  }
}
------------------------------------------------------------
OCL File:
---------
 class AIQTest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ob : OclFile ; ob := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := ob.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     array[i+1] := ob.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var odd : int ; odd := 0 ;
    var even : int ; even := 0 ;
    var odd_ind : int ; odd_ind := 0 ;
    var even_ind : int ; even_ind := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (array[i+1] mod 2 = 0) then (     even := even + 1 ; 
     even_ind := i ) else (     odd := odd + 1 ; 
     odd_ind := i ) )  ;     i := i + 1 ) ; 
    if (odd > even) then     OclFile["System.out"].println(even_ind) else     OclFile["System.out"].println(odd_ind) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  public static int[] pref=new int[100010];
  static int isPerfectCube(int x){
    double cr=Math.round(Math.cbrt(x));
    if(cr*cr*cr==(double)x)return x ;
    return 0 ;
  }
  static void compute(){
    for(int i=1 ; i<=100000 ; ++i){
      pref[i]=pref[i-1]+isPerfectCube(i);
    }
  }
  static void printSum(int L,int R){
    long sum=pref[R]-pref[L-1];
    System.out.print(sum+" ");
  }
  public static void main(String[] args){
    compute();
    int Q=4 ;
    int[][] arr={
      {
        1,10 },{
          1,100 },{
            2,25 },{
              4,50 }
            };
            for(int i=0 ; i<Q ; i++){
              printSum(arr[i][0],arr[i][1]);
            }
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute pref : Sequence(int) := Integer.subrange(1,100010)->collect(0);
  static   operation isPerfectCube( x : int) : int
  pre: true
  post: true
  activity: (     var cr : double ; cr := ((x)->cbrt())->round() ;
     if (cr * cr * cr = x->oclAsType(double)) then     return x else skip ; 
     return 0 );
  static   operation compute() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= 100000 do ( (     pref[i+1] := pref[i - 1+1] + isPerfectCube(i) )  ;     i := i + 1 ) );
  static   operation printSum( L : int, R : int) : void
  pre: true
  post: true
  activity: (     var sum : long ; sum := pref[R+1] - pref[L - 1+1] ;
     OclFile["System.out"].print(sum + " ") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute compute() ; 
     var Q : int ; Q := 4 ;
     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,10},Sequence{1,100},Sequence{2,25},Sequence{4,50}} ;
         var i : int ; i := 0 ; while i < Q do ( (     execute printSum(arr[i+1][0+1], arr[i+1][1+1]) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Practice {
  public static void main(String[] args){
    int n ;
    Scanner scan=new Scanner(System.in);
    n=scan.nextInt();
    int[] x=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=scan.nextInt();
    }
    int count1=0,count2=0 ;
    int number=0 ;
    for(int i=0 ; i<n ; i++){
      if(x[i] % 2==0){
        count1++;
      }
      if(x[i] % 2!=0){
        count2++;
      }
    }
    if(count1==1){
      for(int i=0 ; i<n ; i++){
        if(x[i] % 2==0){
          System.out.print(i+1);
          break ;
        }
      }
    }
    else if(count2==1){
      for(int i=0 ; i<n ; i++){
        if(x[i] % 2!=0){
          System.out.print(i+1);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := scan.getCurrent()->toInteger() ; 
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count1 : int ; count1 := 0 ;
    var count2 : int ; count2 := 0 ;
    var number : int ; number := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (x[i+1] mod 2 = 0) then (     count1 := count1 + 1 ) else skip ; 
     if (x[i+1] mod 2 /= 0) then (     count2 := count2 + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (count1 = 1) then (         var i : int ; i := 0 ; while i < n do ( (     if (x[i+1] mod 2 = 0) then (     OclFile["System.out"].print(i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ) else     if (count2 = 1) then (         var i : int ; i := 0 ; while i < n do ( (     if (x[i+1] mod 2 /= 0) then (     OclFile["System.out"].print(i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ) else skip ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Scanner ;
public class a {
  static int[] a=new int[1000];
  public static boolean check(int a){
    if(a % 2==0)return true ;
    else return false ;
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int o=0,j=0,i ;
    boolean flag=false ;
    for(i=1 ; i<=n ; i++){
      a[i]=scan.nextInt();
      a[i] %=2 ;
    }
    for(i=2 ; i<n ; i++){
      if(a[i]!=a[i-1] && a[i]!=a[i+1]){
        System.out.println(i);
        return ;
      }
    }
    if(a[1]!=a[2]){
      System.out.println(1);
    }
    if(a[n]!=a[n-1]){
      System.out.println(n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class a {
  static   attribute a : Sequence(int) := Integer.subrange(1,1000)->collect(0);
  static   operation check( a : int) : boolean
  pre: true
  post: true
  activity: (     if (a mod 2 = 0) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var o : int ; o := 0 ;
    var j : int ; j := 0 ;
    var i : int ;
    var flag : boolean ; flag := false ;
        i := 1 ; while i <= n do ( (     a[i+1] := scan.getCurrent()->toInteger() ; 
     a[i+1] := a[i+1] mod 2 )  ;     i := i + 1 ) ; 
        i := 2 ; while i < n do ( (     if (a[i+1] /= a[i - 1+1] & a[i+1] /= a[i + 1+1]) then (     OclFile["System.out"].println(i) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    if (a[1+1] /= a[2+1]) then (     OclFile["System.out"].println(1) ) else skip ; 
    if (a[n+1] /= a[n - 1+1]) then (     OclFile["System.out"].println(n) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(--t>=0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      String str="" ;
      for(int i=0 ; i<n ; ++i){
        arr[i]=sc.nextInt();
        str+=arr[i];
      }
      int l=0 ;
      for(int i=0 ; i<str.length(); ++i){
        if(str.charAt(i)=='1'){
          break ;
        }
        else {
++l ;
        }
      }
      str=str.substring(l);
      int r=0 ;
      for(int i=str.length()-1 ; i>0 ; --i){
        if(str.charAt(i)=='1'){
          break ;
        }
        else {
++r ;
        }
      }
      int cnt=0 ;
      str=str.substring(0,str.length()-r);
      for(int i=0 ; i<str.length(); ++i){
        if(str.charAt(i)=='0'){
++cnt ;
        }
      }
      System.out.println(cnt);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         t := t - 1 ;
    while ((t - 1) >= 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var str : String ; str := "" ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     str := str+(arr[i+1]) )  ;     i := i + 1 ) ; 
    var l : int ; l := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '1') then (     break ) else (     l := l + 1 ) )  ;     i := i + 1 ) ; 
    str := str.subrange(l+1,l) ; 
    var r : int ; r := 0 ;
        var i : int ; i := str->size() - 1 ; while i > 0 do ( (     if (str->at(i+1) = '1') then (     break ) else (     r := r + 1 ) )  ;     i := i - 1 ) ; 
    var cnt : int ; cnt := 0 ;
    str := str.subrange(0+1,str->size() - r) ; 
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '0') then (     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 ) ;     t := t - 1 ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int solve(String X,String Y,int N,int K){
    int[] count=new int[N+1];
    int sol=0 ;
    count[0]=0 ;
    for(int i=1 ; i<=N ; i++){
      count[i]=count[i-1]+Math.abs(X.charAt(i-1)-Y.charAt(i-1));
    }
    int j=0 ;
    for(int i=1 ; i<=N ; i++){
      while((count[i]-count[j])>K){
        j++;
      }
      sol=Math.max(sol,i-j);
    }
    return sol ;
  }
  public static void main(String[] args){
    int N=4 ;
    String X="abcd",Y="bcde" ;
    int K=3 ;
    System.out.print(solve(X,Y,N,K)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( X : String, Y : String, N : int, K : int) : int
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,N + 1)->collect(0) ;
     var sol : int ; sol := 0 ;
    count[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= N do ( (     count[i+1] := count[i - 1+1] + if X->at(i - 1+1) - Y->at(i - 1+1) < 0 then -(X->at(i - 1+1) - Y->at(i - 1+1)) else X->at(i - 1+1) - Y->at(i - 1+1) endif )  ;     i := i + 1 ) ; 
    var j : int ; j := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     while ((count[i+1] - count[j+1]) > K) do (     j := j + 1 ) ; 
     sol := Set{sol, i - j}->max() )  ;     i := i + 1 ) ; 
    return sol 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     var X : String ; X := "abcd" ;
    var Y : String ; Y := "bcde" ;
     var K : int ; K := 3 ;
     OclFile["System.out"].print(solve(X, Y, N, K) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    Map<Integer,List<Integer>>tm=new TreeMap<Integer,List<Integer>>();
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      if(tm.containsKey(a)){
        tm.get(a).add(b);
      }
      else {
        List<Integer>list=new ArrayList<Integer>();
        list.add(b);
        tm.put(a,list);
      }
    }
    sc.close();
    int ans=0 ;
    List<Integer>wages=new ArrayList<Integer>();
    for(int i=0 ; i<m ; i++){
      if(tm.containsKey(i+1)){
        wages.addAll(tm.get(i+1));
        Collections.sort(wages,Comparator.reverseOrder());
      }
      if(wages.size()>0){
        ans+=wages.remove(0);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var tm : Map(int,Sequence(int)) ; tm := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (tm->keys()->includes(a)) then (     tm->at(a)->excludes(b) ) else (     var list : Sequence(int) ; list := Sequence{} ;
     list := list->including(b) ; 
     tm := tm->union(Map{a |-> list}) ) )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : int ; ans := 0 ;
    var wages : Sequence(int) ; wages := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     if (tm->keys()->includes(i + 1)) then (     wages := wages->union(tm->at(i + 1)) ; 
     wages, Comparator.reverseOrder() := wages, Comparator.reverseOrder()->sort() ) else skip ; 
     if (wages->size() > 0) then (     ans := ans + wages->at(0+1) ;     wages := wages->excludingAt(0+1) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.PriorityQueue ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    int n=Integer.parseInt(sa[0]);
    int m=Integer.parseInt(sa[1]);
    Obj[] arr=new Obj[n];
    for(int i=0 ; i<n ; i++){
      sa=br.readLine().split(" ");
      Obj o=new Obj();
      o.a=Integer.parseInt(sa[0]);
      o.b=Integer.parseInt(sa[1]);
      arr[i]=o ;
    }
    br.close();
    Arrays.parallelSort(arr,new Comparator<Obj>(){
      public int compare(Obj o1,Obj o2){
        return o1.a-o2.a ;
      }
    }
);
    PriorityQueue<Obj>pq=new PriorityQueue<>(new Comparator<Obj>(){
      public int compare(Obj o1,Obj o2){
        return o2.b-o1.b ;
      }
    }
);
    int ans=0 ;
    int j=0 ;
    for(int i=1 ; i<=m ; i++){
      for(; j<n ; j++){
        if(arr[j] .a>i){
          break ;
        }
        pq.add(arr[j]);
      }
      Obj o=pq.poll();
      if(o!=null){
        ans+=o.b ;
      }
    }
    System.out.println(ans);
  }
  static class Obj {
    int a,b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var n : int ; n := (sa[0+1])->toInteger() ;
    var m : int ; m := (sa[1+1])->toInteger() ;
    var arr : Sequence(Obj) ; arr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     sa := br.readLine()->split(" ") ; 
     var o : Obj ; o := Obj.newObj() ;
    o.a := (sa[0+1])->toInteger() ; 
    o.b := (sa[1+1])->toInteger() ; 
    arr[i+1] := o ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    arr := arr->sort() ; 
    var pq : Sequence(Obj) ; pq := Sequence{}->union(OclComparator<Obj>.newOclComparator()) ;
    var ans : int ; ans := 0 ;
    var j : int ; j := 0 ;
        var i : int ; i := 1 ; while i <= m do ( (       while j < n do ( (     if (arr[j+1].a > i) then (     break ) else skip ; 
     pq := pq->including(arr[j+1]) )  ;     j := j + 1 ) ; 
     var o : Obj ; o := pq->min() ;
     if (o /= null) then (     ans := ans+(o.b) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class Obj {
   attribute a : int;
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static int mod=1000000007 ;
  public static void main(String[] $){
    System.err.println();
    Scanner s=new Scanner(System.in);
    int n=s.nextInt(),days=s.nextInt();
    HashMap<Integer,ArrayList<Integer>>m=new HashMap<>();
    PriorityQueue<Integer>tasks=new PriorityQueue<>(Comparator.reverseOrder());
    for(int i=0 ; i<n ; ++i){
      int time=s.nextInt(),pay=s.nextInt();
      m.computeIfAbsent(time,o->new ArrayList<>()).add(pay);
    }
    long r=0 ;
    for(int i=1 ; i<=days ; ++i){
      ArrayList<Integer>l=m.get(i);
      if(l!=null)l.forEach(tasks :: add);
      Integer task=tasks.poll();
      if(task!=null)r+=task ;
    }
    System.out.println(r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := 1000000007;
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println() ; 
     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := s.getCurrent()->toInteger() ;
    var days : int ; days := s.getCurrent()->toInteger() ;
    var m : Map(int,Sequence(int)) ; m := Map{} ;
    var tasks : Sequence(int) ; tasks := Sequence{}->union(Comparator.reverseOrder()) ;
        var i : int ; i := 0 ; while i < n do ( (     var time : int ; time := s.getCurrent()->toInteger() ;
    var pay : int ; pay := s.getCurrent()->toInteger() ;
     m.computeIfAbsent(time, lambda o : OclAny in Sequence{})->excludes(pay) )  ;     i := i + 1 ) ; 
    var r : long ; r := 0 ;
        var i : int ; i := 1 ; while i <= days do ( (     var l : Sequence(int) ; l := m->at(i) ;
     if (l /= null) then     for _forEach : l do
    (    skip ;) ; else skip ; 
     var task : int ; task := tasks->min() ;
     if (task /= null) then     r := r+(task) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(r) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Scanner ;
class Job implements Comparable<Job>{
  int a ;
  int b ;
  Job(int a,int b){
    this.a=a ;
    this.b=b ;
  }
  @ Override public int compareTo(Job otherJob){
    if(otherJob.a==this.a)return this.b-otherJob.b ;
    else return this.a-otherJob.a ;
  }
}
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String[] line=sc.nextLine().split(" ");
    int N=Integer.parseInt(line[0]);
    int M=Integer.parseInt(line[1]);
    Queue<Job>q=new PriorityQueue<>();
    for(int i=0 ; i<N ; i++){
      line=sc.nextLine().split(" ");
      q.add(new Job(Integer.parseInt(line[0]),Integer.parseInt(line[1])));
    }
    int cnt=0 ;
    Queue<Integer>jobQ=new PriorityQueue<>(Collections.reverseOrder());
    for(int i=1 ; i<=M ; i++){
      while(! q.isEmpty()){
        Job job=q.peek();
        if(job.a<=i){
          jobQ.add(q.poll().b);
        }
        else break ;
      }
      if(! jobQ.isEmpty())cnt+=jobQ.poll();
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Job implements Comparable<Job> {
   attribute a : int;
   attribute b : int;
   static operation newJob( a : int, b : int) : Job
  pre: true
  post: true
  activity:
  ( var self : Job ;
    self := createJob();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
      operation compareTo( otherJob : Job) : int
  pre: true
  post: true
  activity: (     if (otherJob.a = self.a) then     return self.b - otherJob.b else     return self.a - otherJob.a );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : Sequence(String) ; line := sc.nextLine()->split(" ") ;
    var N : int ; N := (line[0+1])->toInteger() ;
    var M : int ; M := (line[1+1])->toInteger() ;
    var q : Sequence(Job) ; q := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     line := sc.nextLine()->split(" ") ; 
     q := q->including(Job.newJob((line[0+1])->toInteger(), (line[1+1])->toInteger())) )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    var jobQ : Sequence(int) ; jobQ := Sequence{}->union(reverseOrder()) ;
        var i : int ; i := 1 ; while i <= M do ( (     while (not(q->isEmpty())) do (     var job : Job ; job := q->min() ;
     if (job.a <= i) then (     jobQ := jobQ->including(q->min().b) ) else     break ) ; 
     if (not(jobQ->isEmpty())) then     cnt := cnt + jobQ->min() ;     jobQ := jobQ->sort()->tail() ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static String joinInt(int[] a,String separator){
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<a.length ; i++){
      if(i>0){
        sb.append(separator);
      }
      sb.append(a[i]);
    }
    return sb.toString();
  }
  static int[] nextIntArray(Scanner sc,int N){
    int[] arr=new int[N];
    for(int i=0 ; i<N ; i++){
      arr[i]=sc.nextInt();
    }
    return arr ;
  }
  public static void main(String[] args){
    final long X=1000000 ;
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    long[] AB=new long[N];
    for(int i=0 ; i<N ; i++){
      long a=sc.nextLong();
      long b=sc.nextLong();
      AB[i]=a*X+b ;
    }
    Arrays.sort(AB);
    PriorityQueue<Integer>q=new PriorityQueue<>();
    int abi=0 ;
    int sum=0 ;
    for(int i=0 ; i<=M ; i++){
      while(abi<N && AB[abi]<(i+1)*X){
        int b=(int)(AB[abi] % X);
        q.add(-b);
        abi++;
      }
      if(q.size()>0){
        int v=q.poll();
        sum+=-v ;
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation joinInt( a : Sequence(int), separator : String) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < a->size() do ( (     if (i > 0) then (     sb := sb + StringLib.newString(separator) ) else skip ; 
     sb := sb + StringLib.newString(a[i+1]) )  ;     i := i + 1 ) ; 
     return sb+"" );
  static   operation nextIntArray( sc : OclFile, N : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
         var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
     return arr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : long ; X := 1000000 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var AB : Sequence(long) ; AB := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
     AB[i+1] := a * X + b )  ;     i := i + 1 ) ; 
    AB := AB->sort() ; 
    var q : Sequence(int) ; q := Sequence{} ;
    var abi : int ; abi := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i <= M do ( (     while (abi < N & AB[abi+1] < (i + 1) * X) do (     var b : int ; b := (AB[abi+1] mod X)->oclAsType(int) ;
     q := q->including(-b) ; 
     abi := abi + 1 ) ; 
     if (q->size() > 0) then (     var v : int ; v := q->min() ;
     sum := sum+(-v) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  int n,m ;
  int[] a ;
  void run(){
    n=sc.nextInt();
    m=sc.nextInt();
    a=new int[m];
    for(int i=0 ; i<m ; i++){
      a[i]=sc.nextInt();
    }
    solve();
  }
  void solve(){
    int gcd=a[0];
    for(int i=1 ; i<m ; i++){
      gcd=gcd(gcd,a[i]);
    }
    println(gcd(gcd,n)==1 ? "Yes" : "No");
  }
  int gcd(int a,int b){
    return a==0 ? b : gcd(b % a,a);
  }
  void println(String s){
    System.out.println(s);
  }
  void print(String s){
    System.out.print(s);
  }
  void debug(Object...os){
    System.err.println(deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   attribute n : int;
   attribute a : Sequence(int);
   operation run() : void
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
     m := sc.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,m)->collect(0) ; 
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute solve() ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var gcd : int ; gcd := a[0+1] ;
         var i : int ; i := 1 ; while i < m do ( (     gcd := gcd(gcd, a[i+1]) )  ;     i := i + 1 ) ; 
     execute println(if gcd(gcd, n) = 1 then "Yes" else "No" endif) );
   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if a = 0 then b else gcd(b mod a, a) endif );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tokenizer=new StringTokenizer(reader.readLine());
    int N=Integer.parseInt(tokenizer.nextToken());
    int R=Integer.parseInt(tokenizer.nextToken());
    int L=Integer.parseInt(tokenizer.nextToken());
    int[] po=new int[N];
    int[] c=new int[N];
    int now=0 ;
    int index=0 ;
    for(int i=0 ; i<R ; i++){
      tokenizer=new StringTokenizer(reader.readLine());
      int d=Integer.parseInt(tokenizer.nextToken())-1 ;
      int t=Integer.parseInt(tokenizer.nextToken());
      int x=Integer.parseInt(tokenizer.nextToken());
      c[index]+=t-now ;
      po[d]+=x ;
      now=t ;
      if(x>0){
        if(d==index)continue ;
        if(po[index]<po[d])index=d ;
        else if(po[index]==po[d] && index>d)index=d ;
      }
      else {
        if(d!=index)continue ;
        int maxp=Integer.MIN_VALUE ;
        for(int j=0 ; j<N ; j++){
          if(maxp<po[j]){
            maxp=po[j];
            index=j ;
          }
        }
      }
    }
    c[index]+=L-now ;
    int ans=0 ;
    int max=0 ;
    for(int i=0 ; i<N ; i++){
      if(c[i]>max){
        max=c[i];
        ans=i ;
      }
    }
    System.out.println(ans+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tokenizer : OclIterator ; tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ;
    var N : int ; N := (tokenizer.next())->toInteger() ;
    var R : int ; R := (tokenizer.next())->toInteger() ;
    var L : int ; L := (tokenizer.next())->toInteger() ;
    var po : Sequence(int) ; po := Integer.subrange(1,N)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,N)->collect(0) ;
    var now : int ; now := 0 ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < R do ( (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ; 
     var d : int ; d := (tokenizer.next())->toInteger() - 1 ;
    var t : int ; t := (tokenizer.next())->toInteger() ;
    var x : int ; x := (tokenizer.next())->toInteger() ;
    c[index+1] := c[index+1]+(t - now) ; 
    po[d+1] := po[d+1]+(x) ; 
    now := t ; 
    if (x > 0) then (     if (d = index) then     continue else skip ; 
     if (po[index+1] < po[d+1]) then     index := d ; else     if (po[index+1] = po[d+1] & index > d) then     index := d ; else skip ; ) else (     if (d /= index) then     continue else skip ; 
     var maxp : int ; maxp := -2147483648 ;
         var j : int ; j := 0 ; while j < N do ( (     if (maxp < po[j+1]) then (     maxp := po[j+1] ; 
     index := j ) else skip )  ;     j := j + 1 ) ) ;  
 )  ;     i := i + 1 ) ; 
    c[index+1] := c[index+1]+(L - now) ; 
    var ans : int ; ans := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (c[i+1] > max) then (     max := c[i+1] ; 
     ans := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPrime(int n,int i){
    if(n<=2)return(n==2)? true : false ;
    if(n % i==0)return false ;
    if(i*i>n)return true ;
    return isPrime(n,i+1);
  }
  public static void main(String[] args){
    int n=15 ;
    if(isPrime(n,2))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPrime( n : int, i : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 2) then     return if (n = 2) then true else false endif else skip ; 
     if (n mod i = 0) then     return false else skip ; 
     if (i * i > n) then     return true else skip ; 
     return isPrime(n, i + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     if (isPrime(n, 2)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPrime(int n){
    int i=2 ;
    while(i*i<=n){
      if(n % i==0)return false ;
      i++;
    }
    return true ;
  }
  static int minimumSum(int n){
    if(isPrime(n))return 1 ;
    if(n % 2==0)return 2 ;
    if(isPrime(n-2))return 2 ;
    return 3 ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(minimumSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ; i := 2 ;
     while (i * i <= n) do (     if (n mod i = 0) then     return false else skip ; 
     i := i + 1 ) ; 
     return true );
  static   operation minimumSum( n : int) : int
  pre: true
  post: true
  activity: (     if (isPrime(n)) then     return 1 else skip ; 
     if (n mod 2 = 0) then     return 2 else skip ; 
     if (isPrime(n - 2)) then     return 2 else skip ; 
     return 3 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(minimumSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPrime(int x){
    for(int i=2 ; i*i<=x ; i++){
      if(x % i==0)return false ;
    }
    return true ;
  }
  static int minimumCost(int n){
    if(isPrime(n))return 1 ;
    if(n % 2==1 && isPrime(n-2))return 2 ;
    if(n % 2==0)return 2 ;
    return 3 ;
  }
  public static void main(String args[]){
    int n=6 ;
    System.out.println(minimumCost(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPrime( x : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= x do ( (     if (x mod i = 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation minimumCost( n : int) : int
  pre: true
  post: true
  activity: (     if (isPrime(n)) then     return 1 else skip ; 
     if (n mod 2 = 1 & isPrime(n - 2)) then     return 2 else skip ; 
     if (n mod 2 = 0) then     return 2 else skip ; 
     return 3 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(minimumCost(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Another {
  int number ;
  public Another(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  static int firstOne=-1 ;
  static int lastOne=-1 ;
  static int zeroBetween=0 ;
  static int zeroCalc=0 ;
  public void input(int numberElement,int index,int num){
    if(num==1 && firstOne==-1 && lastOne==-1){
      firstOne=index ;
      lastOne=index ;
    }
    else if(num==1){
      lastOne=index ;
    }
    if(num==0 && firstOne!=-1 && lastOne!=-1){
      zeroCalc++;
    }
    if(lastOne==index){
      zeroBetween+=zeroCalc ;
      zeroCalc=0 ;
    }
    if(index==numberElement-1){
      System.out.println(zeroBetween);
      firstOne=-1 ;
      lastOne=-1 ;
      zeroBetween=0 ;
      zeroCalc=0 ;
    }
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    Another instance=new Another(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      int num=input.nextInt();
      for(int k=0 ; k<num ; k++){
        int n=input.nextInt();
        instance.input(num,k,n);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Another {
   attribute number : int;
   static operation newAnother( number : int) : Another
  pre: true
  post: true
  activity:
  ( var self : Another ;
    self := createAnother();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
  static   attribute firstOne : int := -1;
  static   attribute lastOne : int := -1;
  static   attribute zeroBetween : int := 0;
  static   attribute zeroCalc : int := 0;
   operation input( numberElement : int, index : int, num : int) : void
  pre: true
  post: true
  activity: (     if (num = 1 & firstOne = -1 & lastOne = -1) then (     firstOne := index ; 
     lastOne := index ) else     if (num = 1) then (     lastOne := index ) else skip ; ;  
     if (num = 0 & firstOne /= -1 & lastOne /= -1) then (     zeroCalc := zeroCalc + 1 ) else skip ; 
     if (lastOne = index) then (     zeroBetween := zeroBetween+(zeroCalc) ; 
     zeroCalc := 0 ) else skip ; 
     if (index = numberElement - 1) then (     OclFile["System.out"].println(zeroBetween) ; 
     firstOne := -1 ; 
    lastOne := -1 ; 
    zeroBetween := 0 ; 
    zeroCalc := 0 ; 
 ) else skip );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
     var instance : Another ; instance := Another.newAnother(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
         var k : int ; k := 0 ; while k < num do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     instance.input(num, k, n) )  ;     k := k + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int snoob(int x){
    int rightOne,nextHigherOneBit,rightOnesPattern,next=0 ;
    if(x>0){
      rightOne=x &-x ;
      nextHigherOneBit=x+rightOne ;
      rightOnesPattern=x ^ nextHigherOneBit ;
      rightOnesPattern=(rightOnesPattern)/rightOne ;
      rightOnesPattern>>=2 ;
      next=nextHigherOneBit | rightOnesPattern ;
    }
    return next ;
  }
  public static void main(String[] args){
    int x=156 ;
    System.out.println("Next higher number with same"+"number of set bits is "+snoob(x));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation snoob( x : int) : int
  pre: true
  post: true
  activity: (     var rightOne : int ;
    var nextHigherOneBit : int ;
    var rightOnesPattern : int ;
    var next : int ; next := 0 ;
     if (x > 0) then (     rightOne := x & -x ; 
     nextHigherOneBit := x + rightOne ; 
    rightOnesPattern := x xor nextHigherOneBit ; 
    rightOnesPattern := (rightOnesPattern) / rightOne ; 
    rightOnesPattern := rightOnesPattern/(2->pow(2)) ; 
    next := MathLib.bitwiseOr(nextHigherOneBit,rightOnesPattern) ; 
 ) else skip ; 
     return next );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 156 ;
     OclFile["System.out"].println("Next higher number with same" + "number of set bits is " + snoob(x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int properDivisorSum(int n){
    int sum=0 ;
    for(int i=1 ; i<=n ; ++i){
      for(int j=1 ; j*j<=i ; ++j){
        if(i % j==0){
          if(i/j==j)sum+=j ;
          else sum+=j+i/j ;
        }
      }
      sum=sum-i ;
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(properDivisorSum(n));
    n=5 ;
    System.out.println(properDivisorSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation properDivisorSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j * j <= i do ( (     if (i mod j = 0) then (     if (i / j = j) then     sum := sum+(j) ; else     sum := sum+(j + i / j) ; ) else skip )  ;     j := j + 1 ) ; 
     sum := sum - i )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(properDivisorSum(n)) ; 
     n := 5 ; 
     OclFile["System.out"].println(properDivisorSum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int getMinLength(double arr[],int n){
    int count=0 ;
    int result=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==1){
        count++;
      }
      else {
        if(count!=0)result=Math.min(result,count);
        count=0 ;
      }
    }
    return result ;
  }
  public static void main(String[] args){
    double arr[]={
      1,1,0,0,1,1,1,0,1,1,1,1 };
      int n=arr.length ;
      System.out.println(getMinLength(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getMinLength( arr : Sequence(double), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var result : int ; result := 2147483647 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 1) then (     count := count + 1 ) else (     if (count /= 0) then     result := Set{result, count}->min() ; else skip ; 
     count := 0 ) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(double) ; arr := Sequence{1,1,0,0,1,1,1,0,1,1,1,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(getMinLength(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int getLevenstein(StringBuilder input){
    StringBuilder revInput=new StringBuilder(input);
    revInput=revInput.reverse();
    int n=input.length();
    int[][] dp=new int[n+1][n+1];
    for(int i=0 ; i<=n ; ++i){
      dp[0][i]=i ;
      dp[i][0]=i ;
    }
    for(int i=1 ; i<=n ; ++i){
      for(int j=1 ; j<=n ; ++j){
        if(input.charAt(i-1)==revInput.charAt(j-1))dp[i][j]=dp[i-1][j-1];
        else dp[i][j]=1+Math.min(dp[i-1][j],dp[i][j-1]);
      }
    }
    int res=Integer.MAX_VALUE ;
    for(int i=n,j=0 ; i>=0 ; i--,j++){
      res=Math.min(res,dp[i][j]);
      if(i<n)res=Math.min(res,dp[i+1][j]);
      if(i>0)res=Math.min(res,dp[i-1][j]);
    }
    return res ;
  }
  public static void main(String[] args){
    StringBuilder input=new StringBuilder("myfirstgeekarticle");
    System.out.println(getLevenstein(input));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getLevenstein( input : String) : int
  pre: true
  post: true
  activity: (     var revInput : String ; revInput := StringLib.newString(input) ;
     revInput := revInput->reverse() ;     revInput := revInput->reverse() ; 
    var n : int ; n := input->size() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i <= n do ( (     dp[0+1][i+1] := i ; 
     dp[i+1][0+1] := i )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     if (input->at(i - 1+1) = revInput->at(j - 1+1)) then     dp[i+1][j+1] := dp[i - 1+1][j - 1+1] ; else     dp[i+1][j+1] := 1 + Set{dp[i - 1+1][j+1], dp[i+1][j - 1+1]}->min() ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : int ; res := 2147483647 ;
        var i : int ; i := n ;
    var j : int ; j := 0 ; while i >= 0 do ( (     res := Set{res, dp[i+1][j+1]}->min() ; 
     if (i < n) then     res := Set{res, dp[i + 1+1][j+1]}->min() ; else skip ; 
     if (i > 0) then     res := Set{res, dp[i - 1+1][j+1]}->min() ; else skip )  ;     i := i - 1 ;     j := j + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : String ; input := StringLib.newString("myfirstgeekarticle") ;
     OclFile["System.out"].println(getLevenstein(input)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Set ;
public final class p088 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p088().run());
  }
  private static final int LIMIT=12000 ;
  private int[] minSumProduct ;
  public String run(){
    minSumProduct=new int[LIMIT+1];
    Arrays.fill(minSumProduct,Integer.MAX_VALUE);
    for(int i=2 ; i<=LIMIT*2 ; i++)factorize(i,i,i,0,0);
    Set<Integer>items=new HashSet<>();
    for(int i=2 ; i<minSumProduct.length ; i++)items.add(minSumProduct[i]);
    int sum=0 ;
    for(int n : items)sum+=n ;
    return Integer.toString(sum);
  }
  private void factorize(int n,int remain,int maxFactor,int sum,int terms){
    if(remain==1){
      if(sum>n)throw new AssertionError();
      terms+=n-sum ;
      if(terms<=LIMIT && n<minSumProduct[terms])minSumProduct[terms]=n ;
    }
    else {
      for(int i=2 ; i<=maxFactor ; i++){
        if(remain % i==0){
          int factor=i ;
          factorize(n,remain/factor,Math.min(factor,maxFactor),sum+factor,terms+1);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class p088 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p088.newp088().run()) );
  static    attribute LIMIT : int := 12000;
   attribute minSumProduct : Sequence(int);
   operation run() : String
  pre: true
  post: true
  activity: (     minSumProduct := Integer.subrange(1,LIMIT + 1)->collect(0) ; 
     minSumProduct := minSumProduct->collect(2147483647) ; 
        var i : int ; i := 2 ; while i <= LIMIT * 2 do (     execute factorize(i, i, i, 0, 0) ;  ;     i := i + 1 ) ; 
    var items : Set(int) ; items := Set{} ;
        var i : int ; i := 2 ; while i < minSumProduct->size() do (     items := items->including(minSumProduct[i+1]) ;  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    for (n : items) do (     sum := sum+(n) ;  ) ; 
    return ((sum) + "") 
 );
   operation factorize( n : int, remain : int, maxFactor : int, sum : int, terms : int) : void
  pre: true
  post: true
  activity: (     if (remain = 1) then (     if (sum > n) then     error AssertionException() ; else skip ; 
     terms := terms+(n - sum) ; 
     if (terms <= LIMIT & n < minSumProduct[terms+1]) then     minSumProduct[terms+1] := n ; else skip ) else (         var i : int ; i := 2 ; while i <= maxFactor do ( (     if (remain mod i = 0) then (     var factor : int ; factor := i ;
     execute factorize(n, remain / factor, Set{factor, maxFactor}->min(), sum + factor, terms + 1) ) else skip )  ;     i := i + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] sa=br.readLine().split(" ");
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(sa[i]);
    }
    br.close();
    int mod=1000000007 ;
    long p=1 ;
    for(int i=2 ; i<=n ; i++){
      p=p*i % mod ;
    }
    long[] q=new long[n];
    q[0]=1 ;
    for(int i=1 ; i<n ; i++){
      q[i]=(q[i-1]+modinv(i+1,mod))% mod ;
    }
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      long val=q[i]+q[n-i-1]-1 ;
      val*=a[i];
      val %=mod ;
      val*=p ;
      val %=mod ;
      ans+=val ;
      ans %=mod ;
    }
    System.out.println(ans);
  }
  static long modinv(long a,int m){
    long b=m ;
    long u=1 ;
    long v=0 ;
    long tmp=0 ;
    while(b>0){
      long t=a/b ;
      a-=t*b ;
      tmp=a ;
      a=b ;
      b=tmp ;
      u-=t*v ;
      tmp=u ;
      u=v ;
      v=tmp ;
    }
    u %=m ;
    if(u<0)u+=m ;
    return u ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sa[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var mod : int ; mod := 1000000007 ;
    var p : long ; p := 1 ;
        var i : int ; i := 2 ; while i <= n do ( (     p := p * i mod mod )  ;     i := i + 1 ) ; 
    var q : Sequence(long) ; q := Integer.subrange(1,n)->collect(0) ;
    q[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < n do ( (     q[i+1] := (q[i - 1+1] + modinv(i + 1, mod)) mod mod )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var val : long ; val := q[i+1] + q[n - i - 1+1] - 1 ;
     val := val*(a[i+1]) ; 
    val := val mod mod ; 
    val := val*(p) ; 
    val := val mod mod ; 
    ans := ans+(val) ; 
    ans := ans mod mod ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation modinv( a : long, m : int) : long
  pre: true
  post: true
  activity: (     var b : long ; b := m ;
     var u : long ; u := 1 ;
    var v : long ; v := 0 ;
    var tmp : long ; tmp := 0 ;
    while (b > 0) do (     var t : long ; t := a / b ;
     a := a-(t * b) ; 
    tmp := a ; 
    a := b ; 
    b := tmp ; 
    u := u-(t * v) ; 
    tmp := u ; 
    u := v ; 
    v := tmp ; 
 ) ; 
    u := u mod m ; 
    if (u < 0) then     u := u+(m) ; else skip ; 
    return u 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tokenizer=new StringTokenizer(reader.readLine());
    int N=Integer.parseInt(tokenizer.nextToken());
    int R=Integer.parseInt(tokenizer.nextToken());
    int L=Integer.parseInt(tokenizer.nextToken());
    int[] po=new int[N];
    int[] c=new int[N];
    int now=0 ;
    int index=0 ;
    for(int i=0 ; i<R ; i++){
      tokenizer=new StringTokenizer(reader.readLine());
      int d=Integer.parseInt(tokenizer.nextToken())-1 ;
      int t=Integer.parseInt(tokenizer.nextToken());
      int x=Integer.parseInt(tokenizer.nextToken());
      c[index]+=t-now ;
      po[d]+=x ;
      now=t ;
      if(x>0){
        if(d==index)continue ;
        if(po[index]<po[d])index=d ;
        else if(po[index]==po[d] && index>d)index=d ;
      }
      if(x<0){
        if(d!=index)continue ;
        int maxp=Integer.MIN_VALUE ;
        for(int j=0 ; j<N ; j++){
          if(maxp<po[j]){
            maxp=po[j];
            index=j ;
          }
        }
      }
    }
    c[index]+=L-now ;
    int ans=0 ;
    int max=0 ;
    for(int i=0 ; i<N ; i++){
      if(c[i]>max){
        max=c[i];
        ans=i ;
      }
    }
    System.out.println(ans+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tokenizer : OclIterator ; tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ;
    var N : int ; N := (tokenizer.next())->toInteger() ;
    var R : int ; R := (tokenizer.next())->toInteger() ;
    var L : int ; L := (tokenizer.next())->toInteger() ;
    var po : Sequence(int) ; po := Integer.subrange(1,N)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,N)->collect(0) ;
    var now : int ; now := 0 ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < R do ( (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ; 
     var d : int ; d := (tokenizer.next())->toInteger() - 1 ;
    var t : int ; t := (tokenizer.next())->toInteger() ;
    var x : int ; x := (tokenizer.next())->toInteger() ;
    c[index+1] := c[index+1]+(t - now) ; 
    po[d+1] := po[d+1]+(x) ; 
    now := t ; 
    if (x > 0) then (     if (d = index) then     continue else skip ; 
     if (po[index+1] < po[d+1]) then     index := d ; else     if (po[index+1] = po[d+1] & index > d) then     index := d ; else skip ; ) else skip ; 
    if (x < 0) then (     if (d /= index) then     continue else skip ; 
     var maxp : int ; maxp := -2147483648 ;
         var j : int ; j := 0 ; while j < N do ( (     if (maxp < po[j+1]) then (     maxp := po[j+1] ; 
     index := j ) else skip )  ;     j := j + 1 ) ) else skip ; 
 )  ;     i := i + 1 ) ; 
    c[index+1] := c[index+1]+(L - now) ; 
    var ans : int ; ans := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (c[i+1] > max) then (     max := c[i+1] ; 
     ans := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static final long MOD=1_000_000_007 ;
  public static void main(String[] args){
    int N=sc.nextInt();
    long[] fact=new long[N+1];
    long[] inv=new long[N+2];
    fact[0]=1 ;
    for(int i=0 ; i<N ; i++){
      fact[i+1]=fact[i]*(i+1)% MOD ;
      inv[i+1]=inv(i+1);
    }
    long all=0 ;
    for(int i=2 ; i<=N ; i++){
      all+=fact[N]*inv[i] % MOD ;
    }
    all %=MOD ;
    long[] A=new long[N];
    long ans=0 ;
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
      ans+=A[i]*fact[N];
      ans+=A[i]*all ;
      ans %=MOD ;
      all+=MOD-fact[N]*inv[N-i] % MOD ;
      all+=fact[N]*inv[i+2];
      all %=MOD ;
    }
    System.out.println(ans);
  }
  static long inv(long v){
    return pow(v,(int)MOD-2);
  }
  static long pow(long v,int p){
    if(p==0)return 1 ;
    if(p==1)return v ;
    long ret=pow(v,p/2);
    ret*=ret ;
    ret %=MOD ;
    if(p % 2==1){
      ret*=v ;
      ret %=MOD ;
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute MOD : long := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var fact : Sequence(long) ; fact := Integer.subrange(1,N + 1)->collect(0) ;
    var inv : Sequence(long) ; inv := Integer.subrange(1,N + 2)->collect(0) ;
    fact[0+1] := 1 ; 
        var i : int ; i := 0 ; while i < N do ( (     fact[i + 1+1] := fact[i+1] * (i + 1) mod MOD ; 
     inv[i + 1+1] := inv(i + 1) )  ;     i := i + 1 ) ; 
    var all : long ; all := 0 ;
        var i : int ; i := 2 ; while i <= N do ( (     all := all+(fact[N+1] * inv[i+1] mod MOD) )  ;     i := i + 1 ) ; 
    all := all mod MOD ; 
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() ; 
     ans := ans+(A[i+1] * fact[N+1]) ; 
    ans := ans+(A[i+1] * all) ; 
    ans := ans mod MOD ; 
    all := all+(MOD - fact[N+1] * inv[N - i+1] mod MOD) ; 
    all := all+(fact[N+1] * inv[i + 2+1]) ; 
    all := all mod MOD ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation inv( v : long) : long
  pre: true
  post: true
  activity: (     return pow(v, MOD->oclAsType(int) - 2) );
  static   operation pow( v : long, p : int) : long
  pre: true
  post: true
  activity: (     if (p = 0) then     return 1 else skip ; 
     if (p = 1) then     return v else skip ; 
    var ret : long ; ret := pow(v, p / 2) ;
    ret := ret*(ret) ; 
    ret := ret mod MOD ; 
    if (p mod 2 = 1) then (     ret := ret*(v) ; 
     ret := ret mod MOD ) else skip ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static final Reader in=new Reader();
  static final long M=(long)1e9+7 ;
  public static void main(String[] args){
    int n=in.nextInt();
    long[] ps=new long[n+1];
    long nf=1 ;
    for(int i=1 ; i<=n ; ++i){
      ps[i]=(ps[i-1]+in.nextInt())% M ;
      nf=nf*i % M ;
    }
    long ans=nf*ps[n] % M,s=0 ;
    for(int i=1 ; i<=n-1 ; ++i){
      s=(s+ps[n-i]-ps[i]+M)% M ;
      ans=(ans+nf*modI((long)(i+1)*(i>=n-1 ? 1 : i+2),M)% M*2*s+nf*modI(i+1,M)% M*(ps[i]+ps[n]-ps[n-i]+M))% M ;
    }
    System.out.println(ans);
  }
  static long modI(long a,long m){
    return(a %=m)<=1 ? 1 :(1-modI(m % a,a)*m)/a+m ;
  }
  static class Reader {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st ;
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(Exception e){
        }
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile();
  static    attribute M : long := 1e9->oclAsType(long) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var ps : Sequence(long) ; ps := Integer.subrange(1,n + 1)->collect(0) ;
    var nf : long ; nf := 1 ;
        var i : int ; i := 1 ; while i <= n do ( (     ps[i+1] := (ps[i - 1+1] + in.getCurrent()->toInteger()) mod M ; 
     nf := nf * i mod M )  ;     i := i + 1 ) ; 
    var ans : long ; ans := nf * ps[n+1] mod M ;
    var s : long ; s := 0 ;
        var i : int ; i := 1 ; while i <= n - 1 do ( (     s := (s + ps[n - i+1] - ps[i+1] + M) mod M ; 
     ans := (ans + nf * modI((i + 1)->oclAsType(long) * (if i >= n - 1 then 1 else i + 2 endif), M) mod M * 2 * s + nf * modI(i + 1, M) mod M * (ps[i+1] + ps[n+1] - ps[n - i+1] + M)) mod M )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation modI( a : long, m : long) : long
  pre: true
  post: true
  activity: (     return if (a) <= 1 then 1 else (1 - modI(m mod a, a) * m) / a + m endif );
  static class Reader {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final int mod=((int)1e9)+7 ;
    int n=Integer.parseInt(sc.next());
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(sc.next());
    }
    long k=1 ;
    for(int i=1 ; i<=n ; i++){
      k*=i ;
      k %=mod ;
    }
    long[] r=new long[n+1];
    for(int i=1 ; i<=n ; i++){
      r[i]=(r[i-1]+mod_pow(i,mod-2,mod))% mod ;
    }
    long res=0L ;
    for(int i=0 ; i<n ; i++){
      res+=(r[i+1]+r[n-i]-r[1])*a[i];
      res %=mod ;
    }
    System.out.println(res*k % mod);
  }
  public static long mod_pow(long x,long p,long m){
    long a=1 ;
    while(p>0){
      if(p % 2==1){
        a=a*x % m ;
      }
      x=x*x % m ;
      p/=2 ;
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var mod : int ; mod := (1e9->oclAsType(int)) + 7 ;
    var n : int ; n := (sc.getCurrent())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var k : long ; k := 1 ;
        var i : int ; i := 1 ; while i <= n do ( (     k := k*(i) ; 
     k := k mod mod )  ;     i := i + 1 ) ; 
    var r : Sequence(long) ; r := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     r[i+1] := (r[i - 1+1] + mod_pow(i, mod - 2, mod)) mod mod )  ;     i := i + 1 ) ; 
    var res : long ; res := 0L ;
        var i : int ; i := 0 ; while i < n do ( (     res := res+((r[i + 1+1] + r[n - i+1] - r[1+1]) * a[i+1]) ; 
     res := res mod mod )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res * k mod mod) ; 
 );
  static   operation mod_pow( x : long, p : long, m : long) : long
  pre: true
  post: true
  activity: (     var a : long ; a := 1 ;
     while (p > 0) do (     if (p mod 2 = 1) then (     a := a * x mod m ) else skip ; 
     x := x * x mod m ; 
     p := p/(2) ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    final long DIV=1000000007 ;
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
    }
    sc.close();
    long[] p=new long[n];
    long[] sump=new long[n+1];
    for(int i=0 ; i<n ; i++){
      p[i]=inverseElement(i+1,DIV);
      sump[i+1]=sump[i]+p[i];
      sump[i+1] %=DIV ;
    }
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      ans+=a[i]*(sump[i-0+1]+sump[n-i]-p[0]);
      if(ans<0)ans+=DIV*DIV ;
      if(ans>0)ans %=DIV ;
    }
    for(int i=0 ; i<n ; i++){
      ans*=(i+1);
      ans %=DIV ;
    }
    System.out.println(ans);
  }
  public static long inverseElement(long a,long n){
    long b=n,u=1,v=0 ;
    while(b>0){
      long t=a/b ;
      a-=t*b ;
      u-=t*v ;
      t=a ;
      a=b ;
      b=t ;
      t=u ;
      u=v ;
      v=t ;
    }
    u=u % n ;
    if(u<0)u+=n ;
    return u ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var DIV : long ; DIV := 1000000007 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    skip ; 
    var p : Sequence(long) ; p := Integer.subrange(1,n)->collect(0) ;
    var sump : Sequence(long) ; sump := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := inverseElement(i + 1, DIV) ; 
     sump[i + 1+1] := sump[i+1] + p[i+1] ; 
     sump[i + 1+1] := sump[i + 1+1] mod DIV )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans+(a[i+1] * (sump[i - 0 + 1+1] + sump[n - i+1] - p[0+1])) ; 
     if (ans < 0) then     ans := ans+(DIV * DIV) ; else skip ; 
     if (ans > 0) then     ans := ans mod DIV ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     ans := ans*((i + 1)) ; 
     ans := ans mod DIV )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation inverseElement( a : long, n : long) : long
  pre: true
  post: true
  activity: (     var b : long ; b := n ;
    var u : long ; u := 1 ;
    var v : long ; v := 0 ;
     while (b > 0) do (     var t : long ; t := a / b ;
     a := a-(t * b) ; 
    u := u-(t * v) ; 
    t := a ; 
    a := b ; 
    b := t ; 
    t := u ; 
    u := v ; 
    v := t ; 
 ) ; 
    u := u mod n ; 
    if (u < 0) then     u := u+(n) ; else skip ; 
    return u 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static BitSet ps ;
  static BitSet eratosthenes(int m){
    int n=m+1 ;
    BitSet isp=new BitSet();
    if(n<2)return isp ;
    isp.set(2,n,true);
    for(int i=2 ; i*i<n ; i=isp.nextSetBit(i+1)){
      for(int j=i+i ; j<n ; j+=i){
        isp.set(j,false);
      }
    }
    return isp ;
  }
  static boolean solve(){
    int n=in.nextInt();
    if(n==0)return false ;
    if(ps.get(n)){
      out.println("0");
    }
    else {
      int l=n,r=n ;
      while(! ps.get(--l));
      while(! ps.get(++r));
      out.println((r-l));
    }
    return true ;
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    ps=eratosthenes(1300000);
    while(solve());
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   attribute ps : Sequence(boolean);
  static   operation eratosthenes( m : int) : Sequence(boolean)
  pre: true
  post: true
  activity: (     var n : int ; n := m + 1 ;
     var isp : Sequence(boolean) ; isp := MathLib.toBitSequence() ;
    if (n < 2) then     return isp else skip ; 
    isp := isp.setAt(2+1,true) ; 
        var i : int ; i := 2 ; while i * i < n do ( (         var j : int ; j := i + i ; while j < n do ( (     isp := isp.setAt(j+1,false) )  ;     j := j+(i) ) )  ;     i := isp.nextSetBit(i + 1) ) ; 
    return isp 
 );
  static   operation solve() : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return false else skip ; 
     if (ps->at(n+1)) then (     skip ) else (     var l : int ; l := n ;
    var r : int ; r := n ;
     while (not(ps->at((l - 1)+1))) do  ; 
     while (not(ps->at((r + 1)+1))) do  ; 
     skip ) ;  
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    ps := eratosthenes(1300000) ; 
    while (solve()) do  ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int[] parent ;
  int[] size ;
  void solve(){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    int[] p=new int[n];
    parent=new int[n];
    size=new int[n];
    for(int i=0 ; i<n ; i++){
      p[i]=scan.nextInt();
      parent[i]=i ;
      size[i]=1 ;
    }
    for(int i=0 ; i<m ; i++){
      int x=scan.nextInt()-1 ;
      int y=scan.nextInt()-1 ;
      unite(x,y);
    }
    int out=0 ;
    for(int i=0 ; i<n ; i++){
      if(same(i,p[i]-1))out++;
    }
    System.out.println(out);
  }
  int root(int x){
    if(parent[x]==x)return x ;
    return parent[x]=root(parent[x]);
  }
  boolean same(int x,int y){
    return root(x)==root(y);
  }
  void unite(int x,int y){
    x=root(x);
    y=root(y);
    if(x==y)return ;
    if(size[x]<size[y]){
      parent[x]=y ;
      size[y]+=size[x];
    }
    else {
      parent[y]=x ;
      size[x]+=size[y];
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute parent : Sequence(int);
   attribute size : Sequence(int);
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    parent := Integer.subrange(1,n)->collect(0) ; 
    size := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := scan.getCurrent()->toInteger() ; 
     parent[i+1] := i ; 
     size[i+1] := 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := scan.getCurrent()->toInteger() - 1 ;
     var y : int ; y := scan.getCurrent()->toInteger() - 1 ;
     execute unite(x, y) )  ;     i := i + 1 ) ; 
    var out : int ; out := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (same(i, p[i+1] - 1)) then     out := out + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(out) ; 
 );
   operation root( x : int) : int
  pre: true
  post: true
  activity: (     if (parent[x+1] = x) then     return x else skip ; 
     return parent[x+1] );
   operation same( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return root(x) = root(y) );
   operation unite( x : int, y : int) : void
  pre: true
  post: true
  activity: (     x := root(x) ; 
     y := root(y) ; 
     if (x = y) then     return else skip ; 
     if (size[x+1] < size[y+1]) then (     parent[x+1] := y ; 
     size[y+1] := size[y+1]+(size[x+1]) ) else (     parent[y+1] := x ; 
     size[x+1] := size[x+1]+(size[y+1]) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int solve(int n,int m,int obstacles,double range[]){
    double val=Math.min(n,m);
    Arrays.sort(range);
    int c=1 ;
    for(int i=obstacles-1 ; i>=0 ; i--){
      range[i]=2*range[i];
      val-=range[i];
      if(val<=0){
        return c ;
      }
      else {
        c++;
      }
    }
    if(val>0){
      return-1 ;
    }
    return 0 ;
  }
  public static void main(String[] args){
    int n=4,m=5,obstacles=3 ;
    double range[]={
      1.0,1.25,1.15 };
      System.out.print(solve(n,m,obstacles,range)+"\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( n : int, m : int, obstacles : int, range : Sequence(double)) : int
  pre: true
  post: true
  activity: (     var val : double ; val := Set{n, m}->min() ;
     range := range->sort() ; 
    var c : int ; c := 1 ;
        var i : int ; i := obstacles - 1 ; while i >= 0 do ( (     range[i+1] := 2 * range[i+1] ; 
     val := val-(range[i+1]) ; 
     if (val <= 0) then (     return c ) else (     c := c + 1 ) )  ;     i := i - 1 ) ; 
    if (val > 0) then (     return -1 ) else skip ; 
    return 0 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
    var m : int ; m := 5 ;
    var obstacles : int ; obstacles := 3 ;
     var range : Sequence(double) ; range := Sequence{1.0,1.25,1.15} ;
     OclFile["System.out"].print(solve(n, m, obstacles, range) + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Queue ;
import java.util.Stack ;
public class Queue_reverse {
  static Queue<Integer>queue ;
  static void Print(){
    while(! queue.isEmpty()){
      System.out.print(queue.peek()+" ");
      queue.remove();
    }
  }
  static Queue<Integer>reverseQueue(Queue<Integer>q){
    if(q.isEmpty())return q ;
    int data=q.peek();
    q.remove();
    q=reverseQueue(q);
    q.add(data);
    return q ;
  }
  public static void main(String args[]){
    queue=new LinkedList<Integer>();
    queue.add(56);
    queue.add(27);
    queue.add(30);
    queue.add(45);
    queue.add(85);
    queue.add(92);
    queue.add(58);
    queue.add(80);
    queue.add(90);
    queue.add(100);
    queue=reverseQueue(queue);
    Print();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Queue_reverse {
  static   attribute queue : Sequence(int);
  static   operation Print() : void
  pre: true
  post: true
  activity: (     while (not(queue->isEmpty())) do (     OclFile["System.out"].print(queue->min() + " ") ; 
     queue := queue.remove() ) );
  static   operation reverseQueue( q : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     if (q->isEmpty()) then     return q else skip ; 
     var data : int ; data := q->min() ;
    q := q.remove() ; 
    q := reverseQueue(q) ; 
    q->excludes(data) ; 
    return q 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     queue := Sequence{} ; 
     queue := queue->including(56) ; 
    queue := queue->including(27) ; 
    queue := queue->including(30) ; 
    queue := queue->including(45) ; 
    queue := queue->including(85) ; 
    queue := queue->including(92) ; 
    queue := queue->including(58) ; 
    queue := queue->including(80) ; 
    queue := queue->including(90) ; 
    queue := queue->including(100) ; 
    queue := reverseQueue(queue) ; 
    execute Print() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAX=1000000 ;
  static boolean prime[]=new boolean[MAX+1];
  static void SieveOfEratosthenes(){
    for(int i=0 ; i<MAX+1 ; i++)prime[i]=true ;
    prime[1]=false ;
    for(int p=2 ; p*p<=MAX ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=MAX ; i+=p)prime[i]=false ;
      }
    }
  }
  static int findDiff(int arr[],int n){
    int min=MAX+2,max=-1 ;
    for(int i=0 ; i<n ; i++){
      if(prime[arr[i] ]==true){
        if(arr[i]>max)max=arr[i];
        if(arr[i]<min)min=arr[i];
      }
    }
    return(max==-1)?-1 :(max-min);
  }
  public static void main(String[] args){
    SieveOfEratosthenes();
    int n=4 ;
    int arr[]={
      1,2,3,5 };
      int res=findDiff(arr,n);
      if(res==-1)System.out.print("No prime numbers");
      else System.out.println("Difference is "+res);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 1000000;
  static   attribute prime : boolean := Integer.subrange(1,MAX + 1)->collect(false);
  static   operation SieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < MAX + 1 do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p <= MAX do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= MAX do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation findDiff( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var min : int ; min := MAX + 2 ;
    var max : int ; max := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (prime[arr[i+1]+1] = true) then (     if (arr[i+1] > max) then     max := arr[i+1] ; else skip ; 
     if (arr[i+1] < min) then     min := arr[i+1] ; else skip ) else skip )  ;     i := i + 1 ) ; 
     return if (max = -1) then -1 else (max - min) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes() ; 
     var n : int ; n := 4 ;
    var arr : Sequence(int) ; arr := Sequence{1,2,3,5} ;
    var res : int ; res := findDiff(arr, n) ;
    if (res = -1) then     OclFile["System.out"].print("No prime numbers") else     OclFile["System.out"].println("Difference is " + res) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Point2D ;
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new AOJ_GRL_2();
  }
  class AOJ_GRL_2 {
    int cost[][];
    int d[];
    boolean used[];
    int V ;
    int INF ;
    int cnt ;
    void Prim(int s){
      d=new int[V];
      used=new boolean[V];
      INF=Integer.MAX_VALUE ;
      Arrays.fill(used,false);
      Arrays.fill(d,INF);
      d[s]=0 ;
      cnt=0 ;
      while(true){
        int v=-1 ;
        for(int u=0 ; u<V ; u++){
          if(! used[u] &&(v==-1 || d[u]<d[v]))v=u ;
        }
        if(v==-1)break ;
        used[v]=true ;
        int a=d[v]/100 ;
        if(a>0)a--;
        cnt+=a ;
        for(int k=0 ; k<V ; k++)if(! used[k] && cost[v][k]!=0){
          d[k]=Math.min(cost[v][k],d[k]);
        }
      }
    }
    public AOJ_GRL_2(){
      while(true){
        V=in.nextInt();
        cost=new int[V][V];
        if(V==0)break ;
        int n=in.nextInt();
        for(int i=0 ; i<n ; i++){
          String input[]=in.next().split(",");
          int a=Integer.parseInt(input[0]);
          int b=Integer.parseInt(input[1]);
          int c=Integer.parseInt(input[2]);
          cost[a][b]=c ;
          cost[b][a]=c ;
        }
        Prim(0);
        System.out.println(cnt);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: ( AOJ_GRL().newAOJ_GRL()() );
 class AOJ_GRL{
   attribute cost : Sequence(Sequence(int));
   attribute d : Sequence(int);
   attribute used : Sequence(boolean);
   attribute V : int;
   attribute INF : int;
   attribute cnt : int;
   operation Prim( s : int) : void
  pre: true
  post: true
  activity: (     d := Integer.subrange(1,V)->collect(0) ; 
     used := Integer.subrange(1,V)->collect(false) ; 
    INF := 2147483647 ; 
    used := used->collect(false) ; 
    d := d->collect(INF) ; 
    d[s+1] := 0 ; 
    cnt := 0 ; 
    while (true) do (     var v : int ; v := -1 ;
         var u : int ; u := 0 ; while u < V do ( (     if (not(used[u+1]) & (v = -1 or d[u+1] < d[v+1])) then     v := u ; else skip )  ;     u := u + 1 ) ; 
    if (v = -1) then     break else skip ; 
    used[v+1] := true ; 
    var a : int ; a := d[v+1] / 100 ;
    if (a > 0) then     a := a - 1 ; else skip ; 
    cnt := cnt+(a) ; 
        var k : int ; k := 0 ; while k < V do (     if (not(used[k+1]) & cost[v+1][k+1] /= 0) then (     d[k+1] := Set{cost[v+1][k+1], d[k+1]}->min() ) else skip ;  ;     k := k + 1 ) ; 
 ) ; 
 );
   static operation newAOJ_GRL()() : AOJ_GRL()
  pre: true
  post: true
  activity:
  ( var self : AOJ_GRL() ;
    self := createAOJ_GRL()();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     while (true) do (     V := in.getCurrent()->toInteger() ; 
     cost := Integer.subrange(1,V)->collect(Integer.subrange(1,V)->collect(0)) ; 
    if (V = 0) then     break else skip ; 
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var input : Sequence(String) ; input := in.getCurrent()->split(",") ;
     var a : int ; a := (input[0+1])->toInteger() ;
    var b : int ; b := (input[1+1])->toInteger() ;
    var c : int ; c := (input[2+1])->toInteger() ;
    cost[a+1][b+1] := c ; 
    cost[b+1][a+1] := c ; 
 )  ;     i := i + 1 ) ; 
    execute Prim(0) ; 
    OclFile["System.out"].println(cnt) ; 
 ) );
}
 {
   attribute cost : Sequence(Sequence(int));
   attribute d : Sequence(int);
   attribute used : Sequence(boolean);
   attribute V : int;
   attribute INF : int;
   attribute cnt : int;
   operation Prim( s : int) : void
  pre: true
  post: true
  activity: (     d := Integer.subrange(1,V)->collect(0) ; 
     used := Integer.subrange(1,V)->collect(false) ; 
    INF := 2147483647 ; 
    used := used->collect(false) ; 
    d := d->collect(INF) ; 
    d[s+1] := 0 ; 
    cnt := 0 ; 
    while (true) do (     var v : int ; v := -1 ;
         var u : int ; u := 0 ; while u < V do ( (     if (not(used[u+1]) & (v = -1 or d[u+1] < d[v+1])) then     v := u ; else skip )  ;     u := u + 1 ) ; 
    if (v = -1) then     break else skip ; 
    used[v+1] := true ; 
    var a : int ; a := d[v+1] / 100 ;
    if (a > 0) then     a := a - 1 ; else skip ; 
    cnt := cnt+(a) ; 
        var k : int ; k := 0 ; while k < V do (     if (not(used[k+1]) & cost[v+1][k+1] /= 0) then (     d[k+1] := Set{cost[v+1][k+1], d[k+1]}->min() ) else skip ;  ;     k := k + 1 ) ; 
 ) ; 
 );
   static operation newAOJ_GRL()() : AOJ_GRL()
  pre: true
  post: true
  activity:
  ( var self : AOJ_GRL() ;
    self := createAOJ_GRL()();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     while (true) do (     V := in.getCurrent()->toInteger() ; 
     cost := Integer.subrange(1,V)->collect(Integer.subrange(1,V)->collect(0)) ; 
    if (V = 0) then     break else skip ; 
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var input : Sequence(String) ; input := in.getCurrent()->split(",") ;
     var a : int ; a := (input[0+1])->toInteger() ;
    var b : int ; b := (input[1+1])->toInteger() ;
    var c : int ; c := (input[2+1])->toInteger() ;
    cost[a+1][b+1] := c ; 
    cost[b+1][a+1] := c ; 
 )  ;     i := i + 1 ) ; 
    execute Prim(0) ; 
    OclFile["System.out"].println(cnt) ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int r=sc.nextInt();
    int l=sc.nextInt();
    int d,t,x,time=0,max=0 ;
    int[] tv=new int[n];
    int[] score=new int[n];
    for(int i=0 ; i<r ; i++){
      d=sc.nextInt()-1 ;
      t=sc.nextInt();
      x=sc.nextInt();
      tv[max]+=t-time ;
      score[d]+=x ;
      if(x>0){
        if(score[max]<score[d]){
          max=d ;
        }
        else if(score[max]==score[d]){
          max=min(max,d);
        }
      }
      else if(max==d){
        max=0 ;
        for(int j=1 ; j<n ; j++){
          if(score[max]<score[j]){
            max=j ;
          }
        }
      }
      time=t ;
    }
    tv[max]+=l-time ;
    int ans=0 ;
    for(int i=1 ; i<n ; i++){
      if(tv[ans]<tv[i]){
        ans=i ;
      }
    }
    System.out.println(ans+1);
    sc.close();
  }
  static int min(int a,int b){
    return a<b ? a : b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var d : int ;
    var t : int ;
    var x : int ;
    var time : int ; time := 0 ;
    var max : int ; max := 0 ;
    var tv : Sequence(int) ; tv := Integer.subrange(1,n)->collect(0) ;
    var score : Sequence(int) ; score := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < r do ( (     d := sc.getCurrent()->toInteger() - 1 ; 
     t := sc.getCurrent()->toInteger() ; 
    x := sc.getCurrent()->toInteger() ; 
    tv[max+1] := tv[max+1]+(t - time) ; 
    score[d+1] := score[d+1]+(x) ; 
    if (x > 0) then (     if (score[max+1] < score[d+1]) then (     max := d ) else     if (score[max+1] = score[d+1]) then (     max := Set{max, d}->min() ) else skip ; ) else     if (max = d) then (     max := 0 ; 
         var j : int ; j := 1 ; while j < n do ( (     if (score[max+1] < score[j+1]) then (     max := j ) else skip )  ;     j := j + 1 ) ) else skip ; ;  
    time := t ; 
 )  ;     i := i + 1 ) ; 
    tv[max+1] := tv[max+1]+(l - time) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (tv[ans+1] < tv[i+1]) then (     ans := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans + 1) ; 
    skip ; 
 );
  static   operation min( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if a < b then a else b endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static class Edge implements Comparable<Edge>{
    int v1,v2 ;
    int weight ;
    Edge(int v1,int v2,int weight){
      this.v1=v1 ;
      this.v2=v2 ;
      this.weight=weight/100-1 ;
    }
    public int compareTo(Edge o){
      return this.weight-o.weight ;
    }
  }
  static class Vertex {
    Vertex parent ;
    Vertex(){
      this.parent=this ;
    }
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n,m ;
    Vertex vertex[];
    Edge edge[];
    int sumWeight ;
    n=sc.nextInt();
    while(n!=0){
      m=sc.nextInt();
      vertex=new Vertex[n];
      edge=new Edge[m];
      sumWeight=0 ;
      for(int i=0 ; i<n ; i++){
        vertex[i]=new Vertex();
      }
      for(int i=0 ; i<m ; i++){
        String s[]=sc.next().split(",");
        edge[i]=new Edge(Integer.parseInt(s[0]),Integer.parseInt(s[1]),Integer.parseInt(s[2]));
      }
      Arrays.sort(edge);
      for(int i=0 ; i<m ; i++){
        if(find(vertex[edge[i] .v1])!=(find(vertex[edge[i] .v2]))){
          sumWeight+=edge[i] .weight ;
          union(vertex[edge[i] .v1],vertex[edge[i] .v2]);
        }
      }
      System.out.println(sumWeight);
      n=sc.nextInt();
    }
  }
  public static Vertex find(Vertex vertex){
    if(vertex.parent==vertex){
      return vertex ;
    }
    else {
      return find(vertex.parent);
    }
  }
  public static void union(Vertex v1,Vertex v2){
    Vertex vertex1=find(v1);
    Vertex vertex2=find(v2);
    vertex1.parent=vertex2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Edge implements Comparable<Edge> {
   attribute v1 : int;
   attribute weight : int;
   static operation newEdge( v1 : int, v2 : int, weight : int) : Edge
  pre: true
  post: true
  activity:
  ( var self : Edge ;
    self := createEdge();
    self.initialise(v1, v2,weight);
    return self );
  operation initialise( v1 : int, v2 : int, weight : int) : void
  pre: true  post: true
  activity: (     self.v1 := v1 ; 
     self.v2 := v2 ; 
     self.weight := weight / 100 - 1 );
   operation compareTo( o : Edge) : int
  pre: true
  post: true
  activity: (     return self.weight - o.weight );
}
  static class Vertex {
   attribute parent : Vertex;
   static operation newVertex() : Vertex
  pre: true
  post: true
  activity:
  ( var self : Vertex ;
    self := createVertex();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.parent := self );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var m : int ;
    var vertex : Sequence(Vertex) ;
    var edge : Sequence(Edge) ;
    var sumWeight : int ;
    n := sc.getCurrent()->toInteger() ; 
    while (n /= 0) do (     m := sc.getCurrent()->toInteger() ; 
     vertex := Integer.subrange(1,n)->collect(null) ; 
    edge := Integer.subrange(1,m)->collect(null) ; 
    sumWeight := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     vertex[i+1] := Vertex.newVertex() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var s : Sequence(String) ; s := sc.getCurrent()->split(",") ;
     edge[i+1] := Edge.newEdge((s[0+1])->toInteger(), (s[1+1])->toInteger(), (s[2+1])->toInteger()) )  ;     i := i + 1 ) ; 
    edge := edge->sort() ; 
        var i : int ; i := 0 ; while i < m do ( (     if (find(vertex[edge[i+1].v1+1]) /= (find(vertex[edge[i+1].v2+1]))) then (     sumWeight := sumWeight+(edge[i+1].weight) ; 
     execute union(vertex[edge[i+1].v1+1], vertex[edge[i+1].v2+1]) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sumWeight) ; 
    n := sc.getCurrent()->toInteger() ; 
 ) ; 
 );
  static   operation find( vertex : Vertex) : Vertex
  pre: true
  post: true
  activity: (     if (vertex.parent = vertex) then (     return vertex ) else (     return find(vertex.parent) ) );
  static   operation union( v1 : Vertex, v2 : Vertex) : void
  pre: true
  post: true
  activity: (     var vertex1 : Vertex ; vertex1 := find(v1) ;
     var vertex2 : Vertex ; vertex2 := find(v2) ;
     vertex1.parent := vertex2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int m=sc.nextInt();
      ArrayList<ArrayList<Edge>>graph=new ArrayList<ArrayList<Edge>>();
      for(int i=0 ; i<n ; i++)graph.add(new ArrayList<Edge>());
      while(m-->0){
        String[] s=sc.next().split(",");
        int a=Integer.parseInt(s[0]);
        int b=Integer.parseInt(s[1]);
        int cost=Integer.parseInt(s[2])/100-1 ;
        graph.get(a).add(new Edge(b,cost));
        graph.get(b).add(new Edge(a,cost));
      }
      System.out.println(prim(graph));
    }
  }
  private static int prim(ArrayList<ArrayList<Edge>>graph){
    PriorityQueue<Edge>open=new PriorityQueue<Edge>();
    HashSet<Integer>closed=new HashSet<Integer>();
    int total=0 ;
    open.add(new Edge(0,0));
    while(closed.size()!=graph.size()){
      Edge st=open.poll();
      if(closed.contains(st.to)){
        continue ;
      }
      closed.add(st.to);
      total+=st.cost ;
      for(Edge e : graph.get(st.to)){
        if(! closed.contains(e.to)){
          open.add(e);
        }
      }
    }
    return total ;
  }
}
class Edge implements Comparable<Edge>{
  int to,cost ;
  Edge(int to,int cost){
    this.to=to ;
    this.cost=cost ;
  }
  public int compareTo(Edge e){
    return this.cost-e.cost ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var graph : Sequence(Sequence(Edge)) ; graph := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     graph := graph->including(Sequence{}) ;  ;     i := i + 1 ) ; 
        while (m > 0) do (        m := m - 1 ;     skip ; (     var s : Sequence(String) ; s := sc.getCurrent()->split(",") ;
     var a : int ; a := (s[0+1])->toInteger() ;
    var b : int ; b := (s[1+1])->toInteger() ;
    var cost : int ; cost := (s[2+1])->toInteger() / 100 - 1 ;
    graph->at(a+1)->excludes(Edge.newEdge(b, cost)) ; 
    graph->at(b+1)->excludes(Edge.newEdge(a, cost)) ; 
 ) ;  ) ;  
    OclFile["System.out"].println(prim(graph)) ; 
 ) );
  static   operation prim( graph : Sequence(Sequence(Edge))) : int
  pre: true
  post: true
  activity: (     var open : Sequence(Edge) ; open := Sequence{} ;
     var closed : Set(int) ; closed := Set{} ;
    var total : int ; total := 0 ;
    open := open->including(Edge.newEdge(0, 0)) ; 
    while (closed->size() /= graph->size()) do (     var st : Edge ; st := open->min() ;
     if (closed->includes(st.to)) then (     continue ) else skip ; 
    closed := closed->including(st.to) ; 
    total := total+(st.cost) ; 
    for (e : graph->at(st.to+1)) do ( (     if (not(closed->includes(e.to))) then (     open := open->including(e) ) else skip )  ) ; 
 ) ; 
    return total 
 );
}
class Edge implements Comparable<Edge> {
   attribute to : int;
   static operation newEdge( to : int, cost : int) : Edge
  pre: true
  post: true
  activity:
  ( var self : Edge ;
    self := createEdge();
    self.initialise(to, cost);
    return self );
  operation initialise( to : int, cost : int) : void
  pre: true  post: true
  activity: (     self.to := to ; 
     self.cost := cost );
   operation compareTo( e : Edge) : int
  pre: true
  post: true
  activity: (     return self.cost - e.cost );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int M=1000000 ;
    for(; ; ){
      int n=in.nextInt();
      if(n==0)return ;
      int m=in.nextInt();
      int cost[][]=new int[n][n];
      int mincost[]=new int[n];
      boolean use[]=new boolean[n];
      int total=0 ;
      for(int i=0 ; i<n ; i++)Arrays.fill(cost[i],M);
      Arrays.fill(mincost,M);
      Arrays.fill(use,false);
      for(int i=0 ; i<n ; i++)cost[i][i]=0 ;
      for(int i=0 ; i<m ; i++){
        String str[]=in.next().split(",");
        int s=Integer.valueOf(str[0]);
        int t=Integer.valueOf(str[1]);
        int c=Integer.valueOf(str[2]);
        cost[s][t]=c ;
        cost[t][s]=c ;
      }
      mincost[0]=0 ;
      for(; ; ){
        int v=-1 ;
        for(int j=0 ; j<n ; j++)if(! use[j] &&(v==-1 || mincost[v]>mincost[j]))v=j ;
        if(v==-1)break ;
        if(mincost[v]!=0)total+=((mincost[v]/100)-1);
        use[v]=true ;
        for(int j=0 ; j<n ; j++){
          if(! use[j] && mincost[j]>cost[v][j])mincost[j]=cost[v][j];
        }
      }
      System.out.println(total);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var M : int ; M := 1000000 ;
       while true do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var m : int ; m := in.getCurrent()->toInteger() ;
    var cost : Sequence(Sequence(int)) ; cost := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var mincost : Sequence(int) ; mincost := Integer.subrange(1,n)->collect(0) ;
    var use : Sequence(boolean) ; use := Integer.subrange(1,n)->collect(false) ;
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < n do (     cost[i+1] := cost[i+1]->collect(M) ;  ;     i := i + 1 ) ; 
    mincost := mincost->collect(M) ; 
    use := use->collect(false) ; 
        var i : int ; i := 0 ; while i < n do (     cost[i+1][i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var str : Sequence(String) ; str := in.getCurrent()->split(",") ;
     var s : int ; s := (str[0+1])->toInteger() ;
    var t : int ; t := (str[1+1])->toInteger() ;
    var c : int ; c := (str[2+1])->toInteger() ;
    cost[s+1][t+1] := c ; 
    cost[t+1][s+1] := c ; 
 )  ;     i := i + 1 ) ; 
    mincost[0+1] := 0 ; 
      while true do ( (     var v : int ; v := -1 ;
         var j : int ; j := 0 ; while j < n do (     if (not(use[j+1]) & (v = -1 or mincost[v+1] > mincost[j+1])) then     v := j ; else skip ;  ;     j := j + 1 ) ; 
    if (v = -1) then     break else skip ; 
    if (mincost[v+1] /= 0) then     total := total+(((mincost[v+1] / 100) - 1)) ; else skip ; 
    use[v+1] := true ; 
        var j : int ; j := 0 ; while j < n do ( (     if (not(use[j+1]) & mincost[j+1] > cost[v+1][j+1]) then     mincost[j+1] := cost[v+1][j+1] ; else skip )  ;     j := j + 1 ) ; 
 )  ) ; 
    OclFile["System.out"].println(total) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import static java.lang.Math.ceil ;
public class A_Summer_Camp {
  static BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException {
    int n=Integer.parseInt(in.readLine());
    String s="" ;
    for(int i=1 ; i<=n ; i++){
      s+=i ;
    }
    out.print(s.charAt(n-1));
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Summer_Camp {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (in.readLine())->toInteger() ;
     var s : String ; s := "" ;
        var i : int ; i := 1 ; while i <= n do ( (     s := s+(i) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    String s ;
    int i ;
    char[] ch ;
    int c=1 ;
    int x=0 ;
    while(true){
      s=String.valueOf(c);
      ch=s.toCharArray();
      for(i=0 ; i<s.length(); i++){
        x++;
        if(x==n){
          break ;
        }
      }
      if(i<s.length()){
        break ;
      }
      c++;
    }
    System.out.println(ch[i]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var s : String ;
    var i : int ;
    var ch : Sequence(String) ;
    var c : int ; c := 1 ;
    var x : int ; x := 0 ;
    while (true) do (     s := ((c) + "") ; 
     ch := s->characters() ; 
        i := 0 ; while i < s->size() do ( (     x := x + 1 ; 
     if (x = n) then (     break ) else skip )  ;     i := i + 1 ) ; 
    if (i < s->size()) then (     break ) else skip ; 
    c := c + 1 ; 
 ) ; 
    OclFile["System.out"].println(ch[i+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.*;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    if(k<=9)System.out.println(k);
    else if(k<=189){
      k-=9 ;
      int t=(k+1)/2 ;
      t+=9 ;
      if(k % 2==0)System.out.println(t % 10);
      else System.out.println(t/10);
    }
    else {
      k-=189 ;
      int t=(k+2)/3 ;
      t+=99 ;
      if(k % 3==0)System.out.println(t % 10);
      else if(k % 3==2){
        t=t/10 ;
        System.out.println(t % 10);
      }
      else {
        System.out.println(t/100);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     if (k <= 9) then     OclFile["System.out"].println(k) ; else     if (k <= 189) then (     k := k-(9) ; 
     var t : int ; t := (k + 1) / 2 ;
     t := t+(9) ; 
     if (k mod 2 = 0) then     OclFile["System.out"].println(t mod 10) ; else     OclFile["System.out"].println(t / 10) ; ) else (     k := k-(189) ; 
     var t : int ; t := (k + 2) / 3 ;
     t := t+(99) ; 
     if (k mod 3 = 0) then     OclFile["System.out"].println(t mod 10) ; else     if (k mod 3 = 2) then (     t := t / 10 ; 
     OclFile["System.out"].println(t mod 10) ) else (     OclFile["System.out"].println(t / 100) ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public void run(){
    String exp=sc.next();
    calc(exp);
  }
  public void calc(String exp){
    int ans1=0 ;
    int ans2=Integer.parseInt(exp.substring(0,1));
    int temp=ans2 ;
    for(int i=0 ; i<exp.length()/2 ; i++){
      String e=exp.substring(2*i+1,2*i+2);
      int k=Integer.parseInt(exp.substring(2*i+2,2*i+3));
      if(e.equals("+")){
        ans2+=k ;
        ans1+=temp ;
        temp=k ;
      }
      else {
        ans2*=k ;
        temp*=k ;
      }
    }
    ans1+=temp ;
    int bob_ans=sc.nextInt();
    String output="" ;
    if(bob_ans==ans1){
      if(bob_ans==ans2)output="U" ;
      else output="M" ;
    }
    else if(bob_ans==ans2)output="L" ;
    else output="I" ;
    System.out.println(output);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var exp : String ; exp := sc.getCurrent() ;
     execute calc(exp) );
   operation calc( exp : String) : void
  pre: true
  post: true
  activity: (     var ans1 : int ; ans1 := 0 ;
     var ans2 : int ; ans2 := (exp.subrange(0+1,1))->toInteger() ;
    var temp : int ; temp := ans2 ;
        var i : int ; i := 0 ; while i < exp->size() / 2 do ( (     var e : String ; e := exp.subrange(2 * i + 1+1,2 * i + 2) ;
     var k : int ; k := (exp.subrange(2 * i + 2+1,2 * i + 3))->toInteger() ;
     if (e = "+") then (     ans2 := ans2+(k) ; 
     ans1 := ans1+(temp) ; 
     temp := k ) else (     ans2 := ans2*(k) ; 
     temp := temp*(k) ) )  ;     i := i + 1 ) ; 
    ans1 := ans1+(temp) ; 
    var bob_ans : int ; bob_ans := sc.getCurrent()->toInteger() ;
    var output : String ; output := "" ;
    if (bob_ans = ans1) then (     if (bob_ans = ans2) then     output := "U" ; else     output := "M" ; ) else     if (bob_ans = ans2) then     output := "L" else     output := "I" ; ;  ;  
    OclFile["System.out"].println(output) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SummerCamp {
  static char[] generateString(){
    StringBuilder sb=new StringBuilder();
    for(int i=1 ; i<=1000 ; i++){
      sb.append(i);
    }
    return sb.toString().toCharArray();
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    System.out.println(generateString()[n-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class SummerCamp {
  static   operation generateString() : Sequence(String)
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 1 ; while i <= 1000 do ( (     sb := sb + StringLib.newString(i) )  ;     i := i + 1 ) ; 
     return sb+""->characters() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(generateString()[n - 1+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int distinctSubString(String P,int N){
    HashSet<String>S=new HashSet<String>();
    for(int i=0 ; i<N ; ++i){
      boolean[] freq=new boolean[26];
      String s="" ;
      for(int j=i ; j<N ; ++j){
        int pos=P.charAt(j)-'a' ;
        if(freq[pos]==true)break ;
        freq[pos]=true ;
        s+=P.charAt(j);
        S.add(s);
      }
    }
    return S.size();
  }
  public static void main(String[] args){
    String S="abba" ;
    int N=S.length();
    System.out.print(distinctSubString(S,N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation distinctSubString( P : String, N : int) : int
  pre: true
  post: true
  activity: (     var S : Set(String) ; S := Set{} ;
         var i : int ; i := 0 ; while i < N do ( (     var freq : Sequence(boolean) ; freq := Integer.subrange(1,26)->collect(false) ;
     var s : String ; s := "" ;
         var j : int ; j := i ; while j < N do ( (     var pos : int ; pos := P->at(j+1) - ('a')->char2byte() ;
     if (freq[pos+1] = true) then     break else skip ; 
    freq[pos+1] := true ; 
    s := s+(P->at(j+1)) ; 
    S := S->including(s) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return S->size() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := "abba" ;
     var N : int ; N := S->size() ;
     OclFile["System.out"].print(distinctSubString(S, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  String now ;
  String[] ptn={
    "0111111","0000110","1011011","1001111","1100110","1101101","1111101","0100111","1111111","1101111" };
    public String makeDisplay(String n,int to){
      String result="" ;
      for(int i=0 ; i<7 ; i++){
        if(n.charAt(i)==ptn[to] .charAt(i))result+="0" ;
        else result+="1" ;
      }
      return result ;
    }
    public static void main(String[] args){
      Main m=new Main();
      Scanner sc=new Scanner(System.in);
      while(! sc.hasNext("-1")){
        m.now="0000000" ;
        int n=sc.nextInt();
        for(int i=0 ; i<n ; i++){
          int num=sc.nextInt();
          System.out.println(m.makeDisplay(m.now,num));
          m.now=m.ptn[num];
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute now : String;
   attribute ptn : Sequence(String) := Sequence{"0111111","0000110","1011011","1001111","1100110","1101101","1111101","0100111","1111111","1101111"};
   operation makeDisplay( n : String, to : int) : String
  pre: true
  post: true
  activity: (     var result : String ; result := "" ;
         var i : int ; i := 0 ; while i < 7 do ( (     if (n->at(i+1) = ptn[to+1]->at(i+1)) then     result := result+("0") ; else     result := result+("1") ; )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (not(sc.hasNext("-1"))) do (     m.now := "0000000" ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(m.makeDisplay(m.now, num)) ; 
     m.now := m.ptn[num+1] )  ;     i := i + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    solve();
  }
  public static void solve(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    int x=0 ;
    if((n-k)%(k-1)==0){
      x=(n-k)/(k-1);
    }
    else {
      x=(n-k)/(k-1)+1 ;
    }
    System.out.println(x+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var x : int ; x := 0 ;
    if ((n - k) mod (k - 1) = 0) then (     x := (n - k) / (k - 1) ) else (     x := (n - k) / (k - 1) + 1 ) ;  
    OclFile["System.out"].println(x + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    FastScanner in=new FastScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ProblemC solver=new ProblemC();
    solver.solve(1,in,out);
    out.close();
  }
  static class ProblemC {
    public void solve(int testNumber,FastScanner in,PrintWriter out){
      int n=in.nextInt();
      int k=in.nextInt();
      int p=-1 ;
      for(int i=0 ; i<n ; i++){
        int x=in.nextInt();
        if(x==1){
          p=i ;
        }
      }
      int ans=n ;
      for(int i=0 ; i<n ; i++){
        if(p>=i && p<=i+k-1){
          int cur=1 ;
          int l=i ;
          int r=Math.max(0,n-i-k);
          cur+=(l+k-2)/(k-1);
          cur+=(r+k-2)/(k-1);
          ans=Math.min(ans,cur);
        }
      }
      out.println(ans);
    }
  }
  static class FastScanner {
    private BufferedReader in ;
    private StringTokenizer st ;
    public FastScanner(InputStream stream){
      in=new BufferedReader(new InputStreamReader(stream));
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          String rl=in.readLine();
          if(rl==null){
            return null ;
          }
          st=new StringTokenizer(rl);
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : FastScanner ; in := FastScanner.newFastScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ProblemC ; solver := ProblemC.newProblemC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ProblemC {
   operation solve( testNumber : int, in : FastScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var k : int ; k := in.nextInt() ;
    var p : int ; p := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.nextInt() ;
     if (x = 1) then (     p := i ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := n ;
        var i : int ; i := 0 ; while i < n do ( (     if (p >= i & p <= i + k - 1) then (     var cur : int ; cur := 1 ;
     var l : int ; l := i ;
    var r : int ; r := Set{0, n - i - k}->max() ;
    cur := cur+((l + k - 2) / (k - 1)) ; 
    cur := cur+((r + k - 2) / (k - 1)) ; 
    ans := Set{ans, cur}->min() ; 
 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class FastScanner {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( stream : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     var rl : String ; rl := in.readLine() ;
     if (rl = null) then (     return null ) else skip ; 
     st := OclIterator.newOclIterator_String(rl) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  private static final PrintStream ps=System.out ;
  private static final Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    int k=sc.nextInt();
    ps.println(f(n-1,k-1));
  }
  static int f(int a,int b){
    return(a+b-1)/b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute ps : OclFile := OclFile["System.out"];
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     skip );
  static   operation f( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return (a + b - 1) / b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    String[] input=br.readLine().split(" ");
    int N=Integer.parseInt(input[0]);
    int K=Integer.parseInt(input[1]);
    bw.write(String.format("%d\n",(N-1)/(K-1)+((N-1)%(K-1)>0 ? 1 : 0)));
    bw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var input : Sequence(String) ; input := br.readLine()->split(" ") ;
    var N : int ; N := (input[0+1])->toInteger() ;
    var K : int ; K := (input[1+1])->toInteger() ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    final int n ;
    final int k ;
    n=sc.nextInt();
    k=sc.nextInt();
    final int[] number=new int[n];
    int minIdx=0 ;
    for(int i=0 ; i<n ; ++i){
      number[i]=sc.nextInt();
      if(number[i]==1){
        minIdx=i ;
      }
    }
    if(k>=n){
      System.out.println(1);
      return ;
    }
    if(n==1){
      System.out.println(0);
      return ;
    }
    int minCount=Integer.MAX_VALUE ;
    for(int left=1 ; left<=k ; ++left){
      int leftCount=(minIdx+1-left)%(k-1)==0 ?(minIdx+1-left)/(k-1)+1 :(minIdx+1-left)/(k-1)+1+1 ;
      int right=k-left ;
      int rightCount=(n-1-minIdx-right)%(k-1)==0 ?(n-1-minIdx-right)/(k-1):(n-1-minIdx-right)/(k-1)+1 ;
      int currentCount=leftCount+rightCount ;
      if(currentCount<minCount){
        minCount=currentCount ;
      }
    }
    System.out.println(minCount);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var k : int ;
    n := sc.getCurrent()->toInteger() ; 
    k := sc.getCurrent()->toInteger() ; 
    var number : Sequence(int) ; number := Integer.subrange(1,n)->collect(0) ;
    var minIdx : int ; minIdx := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     number[i+1] := sc.getCurrent()->toInteger() ; 
     if (number[i+1] = 1) then (     minIdx := i ) else skip )  ;     i := i + 1 ) ; 
    if (k >= n) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    if (n = 1) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var minCount : int ; minCount := 2147483647 ;
        var left : int ; left := 1 ; while left <= k do ( (     var leftCount : int ; leftCount := if (minIdx + 1 - left) mod (k - 1) = 0 then (minIdx + 1 - left) / (k - 1) + 1 else (minIdx + 1 - left) / (k - 1) + 1 + 1 endif ;
     var right : int ; right := k - left ;
    var rightCount : int ; rightCount := if (n - 1 - minIdx - right) mod (k - 1) = 0 then (n - 1 - minIdx - right) / (k - 1) else (n - 1 - minIdx - right) / (k - 1) + 1 endif ;
    var currentCount : int ; currentCount := leftCount + rightCount ;
    if (currentCount < minCount) then (     minCount := currentCount ) else skip ; 
 )  ;     left := left + 1 ) ; 
    OclFile["System.out"].println(minCount) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minimumAdjacentDifference(int a[],int n,int k){
    int minDiff=Integer.MAX_VALUE ;
    for(int i=0 ; i<(1<<n); i++){
      int cnt=Integer.bitCount(i);
      if(cnt==n-k){
        Vector<Integer>temp=new Vector<Integer>();
        for(int j=0 ; j<n ; j++){
          if((i &(1<<j))!=0)temp.add(a[j]);
        }
        int maxDiff=Integer.MIN_VALUE ;
        for(int j=0 ; j<temp.size()-1 ; j++){
          maxDiff=Math.max(maxDiff,temp.get(j+1)-temp.get(j));
        }
        minDiff=Math.min(minDiff,maxDiff);
      }
    }
    return minDiff ;
  }
  public static void main(String args[]){
    int n=5 ;
    int k=2 ;
    int a[]={
      3,7,8,10,14 };
      System.out.println(minimumAdjacentDifference(a,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumAdjacentDifference( a : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var minDiff : int ; minDiff := 2147483647 ;
         var i : int ; i := 0 ; while i < ((1*(2->pow(n)))->oclAsType(long)) do ( (     var cnt : int ; cnt := bitCount(i) ;
     if (cnt = n - k) then (     var temp : Sequence(int) ; temp := Sequence{} ;
         var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd(i,((1*(2->pow(j)))->oclAsType(long)))) /= 0) then     temp := temp->including(a[j+1]) ; else skip )  ;     j := j + 1 ) ; 
    var maxDiff : int ; maxDiff := -2147483648 ;
        var j : int ; j := 0 ; while j < temp->size() - 1 do ( (     maxDiff := Set{maxDiff, temp->at(j + 1+1) - temp->at(j+1)}->max() )  ;     j := j + 1 ) ; 
    minDiff := Set{minDiff, maxDiff}->min() ; 
 ) else skip )  ;     i := i + 1 ) ; 
     return minDiff );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var k : int ; k := 2 ;
     var a : Sequence(int) ; a := Sequence{3,7,8,10,14} ;
     OclFile["System.out"].println(minimumAdjacentDifference(a, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void difference(int arr[],int n){
    int largest=arr[0];
    int i ;
    for(i=0 ; i<n ; i++){
      if(largest<arr[i])largest=arr[i];
    }
    for(i=0 ; i<n ; i++)arr[i]=largest-arr[i];
    for(i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String[] args){
    int arr[]={
      10,5,9,3,2 };
      int n=arr.length ;
      difference(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation difference( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var largest : int ; largest := arr[0+1] ;
     var i : int ;
        i := 0 ; while i < n do ( (     if (largest < arr[i+1]) then     largest := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do (     arr[i+1] := largest - arr[i+1] ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,5,9,3,2} ;
     var n : int ; n := arr->size() ;
     execute difference(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Count {
  public static int countKdivPairs(int A[],int n,int K){
    int freq[]=new int[K];
    for(int i=0 ; i<n ; i++)++freq[A[i] % K];
    int sum=freq[0]*(freq[0]-1)/2 ;
    for(int i=1 ; i<=K/2 && i!=(K-i); i++)sum+=freq[i]*freq[K-i];
    if(K % 2==0)sum+=(freq[K/2]*(freq[K/2]-1)/2);
    return sum ;
  }
  public static void main(String[] args){
    int A[]={
      2,2,1,7,5,3 };
      int n=6 ;
      int K=4 ;
      System.out.print(countKdivPairs(A,n,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Count {
  static   operation countKdivPairs( A : Sequence(int), n : int, K : int) : int
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,K)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     freq[A[i+1] mod K+1] := freq[A[i+1] mod K+1] + 1 ;  ;     i := i + 1 ) ; 
    var sum : int ; sum := freq[0+1] * (freq[0+1] - 1) / 2 ;
        var i : int ; i := 1 ; while i <= K / 2 & i /= (K - i) do (     sum := sum+(freq[i+1] * freq[K - i+1]) ;  ;     i := i + 1 ) ; 
    if (K mod 2 = 0) then     sum := sum+((freq[K / 2+1] * (freq[K / 2+1] - 1) / 2)) ; else skip ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{2,2,1,7,5,3} ;
     var n : int ; n := 6 ;
     var K : int ; K := 4 ;
     OclFile["System.out"].print(countKdivPairs(A, n, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  void run(){
    System.out.println(solve());
  }
  String solve(){
    Scanner sc=new Scanner(System.in);
    s=sc.next()+"=" ;
    long ans=sc.nextLong();
    long a=add();
    p=0 ;
    long b=num();
    char c=next();
    while(c!='='){
      long d=num();
      if(c=='*')b*=d ;
      else b+=d ;
      c=next();
    }
    if(a==ans && b==ans)return "U" ;
    if(a==ans)return "M" ;
    if(b==ans)return "L" ;
    return "I" ;
  }
  String s ;
  int p ;
  char next(){
    return s.charAt(p++);
  }
  long add(){
    long a=mlt();
    char c=next();
    while(c=='+'){
      long b=mlt();
      a+=b ;
      c=next();
    }
    p--;
    return a ;
  }
  long mlt(){
    long a=num();
    char c=next();
    while(c=='*'){
      long b=num();
      a*=b ;
      c=next();
    }
    p--;
    return a ;
  }
  long num(){
    return next()-'0' ;
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   operation run() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(solve()) );
   operation solve() : String
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     s := sc.getCurrent() + "=" ; 
    var ans : long ; ans := sc.getCurrent()->toLong() ;
    var a : long ; a := add() ;
    p := 0 ; 
    var b : long ; b := num() ;
    var c : String ; c := next() ;
    while (c /= '=') do (     var d : long ; d := num() ;
     if (c = '*') then     b := b*(d) else     b := b+(d) ; ;  
     c := next() ) ; 
    if (a = ans & b = ans) then     return "U" else skip ; 
    if (a = ans) then     return "M" else skip ; 
    if (b = ans) then     return "L" else skip ; 
    return "I" 
 );
   attribute s : String;
   attribute p : int;
   operation next() : String
  pre: true
  post: true
  activity: (     return s->at(p+1) );
   operation add() : long
  pre: true
  post: true
  activity: (     var a : long ; a := mlt() ;
     var c : String ; c := next() ;
    while (c = '+') do (     var b : long ; b := mlt() ;
     a := a+(b) ; 
     c := next() ) ; 
    p := p - 1 ; 
    return a 
 );
   operation mlt() : long
  pre: true
  post: true
  activity: (     var a : long ; a := num() ;
     var c : String ; c := next() ;
    while (c = '*') do (     var b : long ; b := num() ;
     a := a*(b) ; 
     c := next() ) ; 
    p := p - 1 ; 
    return a 
 );
   operation num() : long
  pre: true
  post: true
  activity: (     return next() - ('0')->char2byte() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    while(true){
      String[] S=new String[3];
      S[0]=sc.next();
      if(S[0] .equals("0")){
        break ;
      }
      S[1]=sc.next();
      S[2]=sc.next();
      boolean f=true ;
      for(int i=0 ; i<3 ; i++){
        if(S[i] .charAt(0)==S[i] .charAt(1)&& S[i] .charAt(1)==S[i] .charAt(2)&& S[i] .charAt(0)!='+'){
          System.out.println(S[i] .charAt(0));
          f=false ;
          break ;
        }
        if(S[0] .charAt(i)==S[1] .charAt(i)&& S[1] .charAt(i)==S[2] .charAt(i)&& S[0] .charAt(i)!='+'){
          System.out.println(S[0] .charAt(i));
          f=false ;
          break ;
        }
      }
      if(f && S[0] .charAt(0)==S[1] .charAt(1)&& S[1] .charAt(1)==S[2] .charAt(2)&& S[0] .charAt(0)!='+'){
        System.out.println(S[0] .charAt(0));
        f=false ;
      }
      if(f && S[0] .charAt(2)==S[1] .charAt(1)&& S[1] .charAt(1)==S[2] .charAt(0)&& S[0] .charAt(2)!='+'){
        System.out.println(S[0] .charAt(2));
        f=false ;
      }
      if(f){
        System.out.println("NA");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var S : Sequence(String) ; S := Integer.subrange(1,3)->collect(null) ;
     S[0+1] := sc.getCurrent() ; 
    if (S[0+1] = "0") then (     break ) else skip ; 
    S[1+1] := sc.getCurrent() ; 
    S[2+1] := sc.getCurrent() ; 
    var f : boolean ; f := true ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (S[i+1]->at(0+1) = S[i+1]->at(1+1) & S[i+1]->at(1+1) = S[i+1]->at(2+1) & S[i+1]->at(0+1) /= '+') then (     OclFile["System.out"].println(S[i+1]->at(0+1)) ; 
     f := false ; 
     break ) else skip ; 
     if (S[0+1]->at(i+1) = S[1+1]->at(i+1) & S[1+1]->at(i+1) = S[2+1]->at(i+1) & S[0+1]->at(i+1) /= '+') then (     OclFile["System.out"].println(S[0+1]->at(i+1)) ; 
     f := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (f & S[0+1]->at(0+1) = S[1+1]->at(1+1) & S[1+1]->at(1+1) = S[2+1]->at(2+1) & S[0+1]->at(0+1) /= '+') then (     OclFile["System.out"].println(S[0+1]->at(0+1)) ; 
     f := false ) else skip ; 
    if (f & S[0+1]->at(2+1) = S[1+1]->at(1+1) & S[1+1]->at(1+1) = S[2+1]->at(0+1) & S[0+1]->at(2+1) /= '+') then (     OclFile["System.out"].println(S[0+1]->at(2+1)) ; 
     f := false ) else skip ; 
    if (f) then (     OclFile["System.out"].println("NA") ) else skip ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    for(int t=1 ; t<=T ; t++){
      int D=sc.nextInt();
      int I=sc.nextInt();
      int M=sc.nextInt();
      int N=sc.nextInt();
      int[] A=new int[N];
      for(int i=0 ; i<N ; i++)A[i]=sc.nextInt();
      int[] DP=new int[256];
      Arrays.fill(DP,0);
      int[] CUR=new int[256];
      for(int at=N-1 ; at>=0 ; at--){
        for(int i=0 ; i<1000 ; i++){
          int prev ;
          if(i % 2==0)prev=A[at]+i/2 ;
          else prev=A[at]-(i+1)/2 ;
          if(prev<0 || prev>=256)continue ;
          int cost=DP[prev]+D ;
          for(int j=0 ; j<256 ; j++){
            if(abs(j-prev)<=M || prev==-1)cost=min(cost,DP[j]+abs(j-A[at]));
            if(abs(j-A[at])<abs(A[at]-prev)&&(prev==-1 || abs(j-prev)<=M))cost=min(cost,CUR[j]+I);
          }
          CUR[prev]=cost ;
        }
        for(int j=0 ; j<256 ; j++)DP[j]=CUR[j];
        Arrays.fill(CUR,0);
      }
      int ans=Integer.MAX_VALUE ;
      for(int i=0 ; i<DP.length ; i++)ans=min(ans,DP[i]);
      System.out.format("Case #%d: %d\n",t,ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var t : int ; t := 1 ; while t <= T do ( (     var D : int ; D := sc.getCurrent()->toInteger() ;
     var I : int ; I := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     A[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var DP : Sequence(int) ; DP := Integer.subrange(1,256)->collect(0) ;
    DP := DP->collect(0) ; 
    var CUR : Sequence(int) ; CUR := Integer.subrange(1,256)->collect(0) ;
        var at : int ; at := N - 1 ; while at >= 0 do ( (         var i : int ; i := 0 ; while i < 1000 do ( (     var prev : int ;
     if (i mod 2 = 0) then     prev := A[at+1] + i / 2 else     prev := A[at+1] - (i + 1) / 2 ; ;  
    if (prev < 0 or prev >= 256) then     continue else skip ; 
    var cost : int ; cost := DP[prev+1] + D ;
        var j : int ; j := 0 ; while j < 256 do ( (     if (abs(j - prev) <= M or prev = -1) then     cost := Set{cost, DP[j+1] + abs(j - A[at+1])}->min() ; else skip ; 
     if (abs(j - A[at+1]) < abs(A[at+1] - prev) & (prev = -1 or abs(j - prev) <= M)) then     cost := Set{cost, CUR[j+1] + I}->min() ; else skip )  ;     j := j + 1 ) ; 
    CUR[prev+1] := cost ; 
 )  ;     i := i + 1 ) ; 
         var j : int ; j := 0 ; while j < 256 do (     DP[j+1] := CUR[j+1] ;  ;     j := j + 1 ) ; 
     CUR := CUR->collect(0) )  ;     at := at - 1 ) ; 
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i < DP->size() do (     ans := Set{ans, DP[i+1]}->min() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].format("Case #%d: %d\n", t, ans) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  public static void main(String[] z)throws Exception {
    String r ;
    for(byte[] x=new byte[12]; System.in.read(x)>11 ; System.out.println(r)){
      r="NA" ;
      for(String y : "b w".split(" "))for(int i=0 ; i<5 ; ++i)if(i!=1 && new String(x).replaceAll("\n"," ").matches(String.format(".*%1$s.{%2$s}%1$s.{%2$s}%1$s.*",y,i)))r=y ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : String ;
         var x : Sequence(int) ; x := Integer.subrange(1,12)->collect(0) ; while OclFile["System.in"].read(x) > 11 do ( (     r := "NA" ; 
     for (y : "b w"->split(" ")) do (         var i : int ; i := 0 ; while i < 5 do (     if (i /= 1 & StringLib.newString(x).replaceAllMatches("\n", " " )->isMatch(StringLib.format(".*%1$s.{%2$s}%1$s.{%2$s}%1$s.*",Sequence{y,i}))) then     r := y ; else skip ;  ;     i := i + 1 ) ;  ) )  ;     OclFile["System.out"].println(r) ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      char[][] table=new char[3][];
      table[0]=sc.next().toCharArray();
      if(table[0][0]=='0')return ;
      table[1]=sc.next().toCharArray();
      table[2]=sc.next().toCharArray();
      String ans="NA" ;
      if(win(table,'b'))ans="b" ;
      else if(win(table,'w'))ans="w" ;
      System.out.println(ans);
    }
  }
  boolean win(char[][] table,char ch){
    for(int i=0 ; i<3 ; i++){
      int cnt=0 ;
      for(int j=0 ; j<3 ; j++){
        if(table[i][j]==ch){
          cnt++;
        }
      }
      if(cnt==3)return true ;
    }
    for(int j=0 ; j<3 ; j++){
      int cnt=0 ;
      for(int i=0 ; i<3 ; i++){
        if(table[i][j]==ch){
          cnt++;
        }
      }
      if(cnt==3)return true ;
    }
    if(table[0][0]==ch && table[1][1]==ch && table[2][2]==ch)return true ;
    if(table[0][2]==ch && table[1][1]==ch && table[2][0]==ch)return true ;
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var table : Sequence(Sequence(String)) ; table := Integer.subrange(1,3)->collect(Sequence{}) ;
     table[0+1] := sc.getCurrent()->characters() ; 
    if (table[0+1][0+1] = '0') then     return else skip ; 
    table[1+1] := sc.getCurrent()->characters() ; 
    table[2+1] := sc.getCurrent()->characters() ; 
    var ans : String ; ans := "NA" ;
    if (win(table, 'b')) then     ans := "b" else     if (win(table, 'w')) then     ans := "w" ; else skip ; ;  
    OclFile["System.out"].println(ans) ; 
 )  ) );
   operation win( table : Sequence(Sequence(String)), ch : String) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 3 do ( (     var cnt : int ; cnt := 0 ;
         var j : int ; j := 0 ; while j < 3 do ( (     if (table[i+1][j+1] = ch) then (     cnt := cnt + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (cnt = 3) then     return true else skip )  ;     i := i + 1 ) ; 
         var j : int ; j := 0 ; while j < 3 do ( (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < 3 do ( (     if (table[i+1][j+1] = ch) then (     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (cnt = 3) then     return true else skip )  ;     j := j + 1 ) ; 
    if (table[0+1][0+1] = ch & table[1+1][1+1] = ch & table[2+1][2+1] = ch) then     return true else skip ; 
    if (table[0+1][2+1] = ch & table[1+1][1+1] = ch & table[2+1][0+1] = ch) then     return true else skip ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      String s=sc.next();
      if(s.equals("0"))break ;
      char[][] m=new char[3][3];
      m[0]=s.toCharArray();
      for(int i=1 ; i<3 ; i++)m[i]=sc.next().toCharArray();
      int[][] c=new int[4][5];
      for(int i=0 ; i<3 ; i++){
        for(int j=0 ; j<3 ; j++){
          int x=m[i][j]=='b' ? 1 : m[i][j]=='w' ?-1 : 0 ;
          c[i+1][0]+=x ;
          c[0][j+1]+=x ;
          if(i==j)c[0][0]+=x ;
          if(i==2-j)c[0][4]+=x ;
        }
      }
      String ans="NA" ;
      for(int i=0 ; i<4 ; i++)if(Math.abs(c[i][0])==3)ans=c[i][0]==3 ? "b" : "w" ;
      for(int j=0 ; j<5 ; j++)if(Math.abs(c[0][j])==3)ans=c[0][j]==3 ? "b" : "w" ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var s : String ; s := sc.getCurrent() ;
     if (s = "0") then     break else skip ; 
    var m : Sequence(Sequence(String)) ; m := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
    m[0+1] := s->characters() ; 
        var i : int ; i := 1 ; while i < 3 do (     m[i+1] := sc.getCurrent()->characters() ;  ;     i := i + 1 ) ; 
    var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,4)->collect(Integer.subrange(1,5)->collect(0)) ;
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     var x : int ; x := if m[i+1][j+1] = 'b' then 1 else if m[i+1][j+1] = 'w' then -1 else 0 endif endif ;
     c[i + 1+1][0+1] := c[i + 1+1][0+1]+(x) ; 
    c[0+1][j + 1+1] := c[0+1][j + 1+1]+(x) ; 
    if (i = j) then     c[0+1][0+1] := c[0+1][0+1]+(x) ; else skip ; 
    if (i = 2 - j) then     c[0+1][4+1] := c[0+1][4+1]+(x) ; else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "NA" ;
        var i : int ; i := 0 ; while i < 4 do (     if (if c[i+1][0+1] < 0 then -(c[i+1][0+1]) else c[i+1][0+1] endif = 3) then     ans := if c[i+1][0+1] = 3 then "b" else "w" endif ; else skip ;  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < 5 do (     if (if c[0+1][j+1] < 0 then -(c[0+1][j+1]) else c[0+1][j+1] endif = 3) then     ans := if c[0+1][j+1] = 3 then "b" else "w" endif ; else skip ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      String[] s=new String[3];
      s[0]=sc.next();
      if(s[0] .equals("0")){
        break ;
      }
      for(int i=1 ; i<3 ; i++){
        s[i]=sc.next();
      }
      char[][] map=new char[3][];
      for(int i=0 ; i<3 ; i++){
        map[i]=s[i] .toCharArray();
      }
      char c=win(map);
      System.out.println(c=='+' ? "NA" : c);
    }
  }
  public static char win(char[][] map){
    for(int i=0 ; i<3 ; i++){
      char c=win(map,i,0,0,1);
      if(c!='+'){
        return c ;
      }
      c=win(map,0,i,1,0);
      if(c!='+'){
        return c ;
      }
    }
    char c=win(map,0,0,1,1);
    if(c!='+'){
      return c ;
    }
    return win(map,0,2,1,-1);
  }
  public static char win(char[][] map,int si,int sj,int di,int dj){
    char c=map[si][sj];
    if(c=='+'){
      return '+' ;
    }
    for(int i=1 ; i<3 ; i++){
      si+=di ;
      sj+=dj ;
      if(map[si][sj]!=c){
        return '+' ;
      }
    }
    return c ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var s : Sequence(String) ; s := Integer.subrange(1,3)->collect(null) ;
     s[0+1] := sc.getCurrent() ; 
    if (s[0+1] = "0") then (     break ) else skip ; 
        var i : int ; i := 1 ; while i < 3 do ( (     s[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    var map : Sequence(Sequence(String)) ; map := Integer.subrange(1,3)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < 3 do ( (     map[i+1] := s[i+1]->characters() )  ;     i := i + 1 ) ; 
    var c : String ; c := win(map) ;
    OclFile["System.out"].println(if c = '+' then "NA" else c endif) ; 
 ) );
  static   operation win( map : Sequence(Sequence(String))) : String
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 3 do ( (     var c : String ; c := win(map, i, 0, 0, 1) ;
     if (c /= '+') then (     return c ) else skip ; 
     c := win(map, 0, i, 1, 0) ; 
     if (c /= '+') then (     return c ) else skip )  ;     i := i + 1 ) ; 
     var c : String ; c := win(map, 0, 0, 1, 1) ;
     if (c /= '+') then (     return c ) else skip ; 
     return win(map, 0, 2, 1, -1) );
  static   operation win( map : Sequence(Sequence(String)), si : int, sj : int, di : int, dj : int) : String
  pre: true
  post: true
  activity: (     var c : String ; c := map[si+1][sj+1] ;
     if (c = '+') then (     return '+' ) else skip ; 
         var i : int ; i := 1 ; while i < 3 do ( (     si := si+(di) ; 
     sj := sj+(dj) ; 
     if (map[si+1][sj+1] /= c) then (     return '+' ) else skip )  ;     i := i + 1 ) ; 
     return c );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Binary {
  static int maxOnesIndex(int arr[],int n){
    int max_count=0 ;
    int max_index=0 ;
    int prev_zero=-1 ;
    int prev_prev_zero=-1 ;
    for(int curr=0 ; curr<n ; ++curr){
      if(arr[curr]==0){
        if(curr-prev_prev_zero>max_count){
          max_count=curr-prev_prev_zero ;
          max_index=prev_zero ;
        }
        prev_prev_zero=prev_zero ;
        prev_zero=curr ;
      }
    }
    if(n-prev_prev_zero>max_count)max_index=prev_zero ;
    return max_index ;
  }
  public static void main(String[] args){
    int arr[]={
      1,1,0,0,1,0,1,1,1,0,1,1,1 };
      int n=arr.length ;
      System.out.println("Index of 0 to be replaced is "+maxOnesIndex(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Binary {
  static   operation maxOnesIndex( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max_count : int ; max_count := 0 ;
     var max_index : int ; max_index := 0 ;
    var prev_zero : int ; prev_zero := -1 ;
    var prev_prev_zero : int ; prev_prev_zero := -1 ;
        var curr : int ; curr := 0 ; while curr < n do ( (     if (arr[curr+1] = 0) then (     if (curr - prev_prev_zero > max_count) then (     max_count := curr - prev_prev_zero ; 
     max_index := prev_zero ) else skip ; 
     prev_prev_zero := prev_zero ; 
     prev_zero := curr ) else skip )  ;     curr := curr + 1 ) ; 
    if (n - prev_prev_zero > max_count) then     max_index := prev_zero ; else skip ; 
    return max_index 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,0,0,1,0,1,1,1,0,1,1,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Index of 0 to be replaced is " + maxOnesIndex(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  static int minimumX(int n,int k){
    int ans=Integer.MAX_VALUE ;
    for(int rem=k-1 ; rem>0 ; rem--){
      if(n % rem==0)ans=Math.min(ans,rem+(n/rem)*k);
    }
    return ans ;
  }
  public static void main(String args[]){
    int n=4,k=6 ;
    System.out.println(minimumX(n,k));
    n=5 ;
    k=5 ;
    System.out.println(minimumX(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
  static   operation minimumX( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 2147483647 ;
         var rem : int ; rem := k - 1 ; while rem > 0 do ( (     if (n mod rem = 0) then     ans := Set{ans, rem + (n / rem) * k}->min() ; else skip )  ;     rem := rem - 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
    var k : int ; k := 6 ;
     OclFile["System.out"].println(minimumX(n, k)) ; 
    n := 5 ; 
    k := 5 ; 
    OclFile["System.out"].println(minimumX(n, k)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  private static List<Ab>getStrings(Scanner sc,int num){
    List<Ab>stringList=new ArrayList<>();
    while(num>0){
      long a=sc.nextLong();
      long b=sc.nextLong();
      stringList.add(new Ab(a,b));
      num--;
    }
    return stringList ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Ab>ablist=getStrings(sc,n);
    long suma=0 ;
    long sumb=0 ;
    List<Long>alist=new ArrayList<>();
    List<Long>blist=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      alist.add(ablist.get(i).a);
      blist.add(ablist.get(i).b);
    }
    alist.sort(Long :: compareTo);
    blist.sort(Long :: compareTo);
    double mediana=0 ;
    double medianb=0 ;
    if(n % 2==1){
      mediana=alist.get((n+1)/2-1);
      medianb=blist.get((n+1)/2-1);
      System.out.println((long)(medianb-mediana+1));
    }
    else {
      mediana=(alist.get(n/2-1)+alist.get(n/2))/2.0 ;
      medianb=(blist.get(n/2-1)+blist.get(n/2))/2.0 ;
      System.out.println((long)((medianb-mediana)*2+1));
    }
    return ;
  }
  public static class Ab {
    long a ;
    long b ;
    public Ab(long a,long b){
      this.a=a ;
      this.b=b ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation getStrings( sc : OclFile, num : int) : Sequence(Ab)
  pre: true
  post: true
  activity: (     var stringList : Sequence(Ab) ; stringList := Sequence{} ;
     while (num > 0) do (     var a : long ; a := sc.nextLong() ;
     var b : long ; b := sc.nextLong() ;
     stringList := stringList->including(Ab.newAb(a, b)) ; 
     num := num - 1 ) ; 
     return stringList );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ablist : Sequence(Ab) ; ablist := getStrings(sc, n) ;
    var suma : long ; suma := 0 ;
    var sumb : long ; sumb := 0 ;
    var alist : Sequence(long) ; alist := Sequence{} ;
    var blist : Sequence(long) ; blist := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     alist := alist->including(ablist->at(i+1).a) ; 
     blist := blist->including(ablist->at(i+1).b) )  ;     i := i + 1 ) ; 
    alist := alist.sort(lambda _pars : OclAny in Long.newLong().compareTo(_pars)) ; 
    blist := blist.sort(lambda _pars : OclAny in Long.newLong().compareTo(_pars)) ; 
    var mediana : double ; mediana := 0 ;
    var medianb : double ; medianb := 0 ;
    if (n mod 2 = 1) then (     mediana := alist->at((n + 1) / 2 - 1+1) ; 
     medianb := blist->at((n + 1) / 2 - 1+1) ; 
     OclFile["System.out"].println((medianb - mediana + 1)->oclAsType(long)) ) else (     mediana := (alist->at(n / 2 - 1+1) + alist->at(n / 2+1)) / 2.0 ; 
     medianb := (blist->at(n / 2 - 1+1) + blist->at(n / 2+1)) / 2.0 ; 
     OclFile["System.out"].println(((medianb - mediana) * 2 + 1)->oclAsType(long)) ) ;  
    return 
 );
  static class Ab {
   attribute a : long;
   attribute b : long;
   static operation newAb( a : long, b : long) : Ab
  pre: true
  post: true
  activity:
  ( var self : Ab ;
    self := createAb();
    self.initialise(a, b);
    return self );
  operation initialise( a : long, b : long) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    resolve(System.in,System.out);
  }
  static void resolve(InputStream is,PrintStream pw){
    Scanner sc=new Scanner(is);
    int n=Integer.parseInt(sc.next());
    int min[]=new int[n];
    int max[]=new int[n];
    for(int i=0 ; i<n ; i++){
      min[i]=Integer.parseInt(sc.next());
      max[i]=Integer.parseInt(sc.next());
    }
    Arrays.sort(min);
    Arrays.sort(max);
    if(n % 2==1){
      pw.println((int)median(max)-(int)median(min)+1);
    }
    else {
      pw.println((int)((median(max)-median(min))*2)+1);
    }
  }
  static double median(int sorted[]){
    if(sorted.length % 2==1){
      return sorted[sorted.length/2];
    }
    return(sorted[sorted.length/2-1]+sorted[sorted.length/2])/2d ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute resolve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation resolve( is : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(is) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var min : Sequence(int) ; min := Integer.subrange(1,n)->collect(0) ;
    var max : Sequence(int) ; max := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     min[i+1] := (sc.getCurrent())->toInteger() ; 
     max[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    min := min->sort() ; 
    max := max->sort() ; 
    if (n mod 2 = 1) then (     pw.println(median(max)->oclAsType(int) - median(min)->oclAsType(int) + 1) ) else (     pw.println(((median(max) - median(min)) * 2)->oclAsType(int) + 1) ) ;  
 );
  static   operation median( sorted : Sequence(int)) : double
  pre: true
  post: true
  activity: (     if (sorted->size() mod 2 = 1) then (     return sorted[sorted->size() / 2+1] ) else skip ; 
     return (sorted[sorted->size() / 2 - 1+1] + sorted[sorted->size() / 2+1]) / 2d );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    int num=998244353 ;
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    int n=Integer.parseInt(bf.readLine());
    ArrayList<Integer>ai=new ArrayList<Integer>();
    ArrayList<Integer>bi=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      StringTokenizer st=new StringTokenizer(bf.readLine());
      ai.add(Integer.parseInt(st.nextToken()));
      bi.add(Integer.parseInt(st.nextToken()));
    }
    Collections.sort(ai);
    Collections.sort(bi);
    if(n % 2==1){
      out.println(bi.get(bi.size()/2)-ai.get(ai.size()/2)+1);
      out.close();
    }
    else {
      double b=(ai.get(ai.size()/2)+ai.get(ai.size()/2-1)+0.0)/2 ;
      double c=(bi.get(bi.size()/2)+bi.get(bi.size()/2-1)+0.0)/2 ;
      out.println((int)(2*(c-b)+1));
      out.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 998244353 ;
     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (bf.readLine())->toInteger() ;
    var ai : Sequence(int) ; ai := Sequence{} ;
    var bi : Sequence(int) ; bi := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(bf.readLine()) ;
     ai := ai->including((st.next())->toInteger()) ; 
     bi := bi->including((st.next())->toInteger()) )  ;     i := i + 1 ) ; 
    ai := ai->sort() ; 
    bi := bi->sort() ; 
    if (n mod 2 = 1) then (     skip ; 
     skip ) else (     var b : double ; b := (ai->at(ai->size() / 2+1) + ai->at(ai->size() / 2 - 1+1) + 0.0) / 2 ;
     var c : double ; c := (bi->at(bi->size() / 2+1) + bi->at(bi->size() / 2 - 1+1) + 0.0) / 2 ;
     skip ; 
     skip ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int centered_cube(int n){
    return(2*n+1)*(n*n+n+1);
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.print(n+"th Centered"+" cube number: ");
    System.out.println(centered_cube(n));
    n=10 ;
    System.out.print(n+"th Centered"+" cube number: ");
    System.out.println(centered_cube(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation centered_cube( n : int) : int
  pre: true
  post: true
  activity: (     return (2 * n + 1) * (n * n + n + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].print(n + "th Centered" + " cube number: ") ; 
    OclFile["System.out"].println(centered_cube(n)) ; 
    n := 10 ; 
    OclFile["System.out"].print(n + "th Centered" + " cube number: ") ; 
    OclFile["System.out"].println(centered_cube(n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  static long bignum=1000000000+7 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<Integer>a=new ArrayList<Integer>();
    ArrayList<Integer>b=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      a.add(sc.nextInt());
      b.add(sc.nextInt());
    }
    Collections.sort(a);
    Collections.sort(b);
    if(n % 2==0){
      double min=((double)(a.get(n/2-1)+a.get(n/2)))/2 ;
      double max=((double)(b.get(n/2-1)+b.get(n/2)))/2 ;
      System.out.println((int)((max-min)/0.5)+1);
    }
    else {
      double min=a.get(n/2);
      double max=b.get(n/2);
      System.out.println((int)(max-min)+1);
    }
  }
  static long divn(int target,int times){
    int sqtimes=(int)Math.sqrt(times);
    long ans=1 ;
    for(int i=0 ; i<sqtimes ; i++){
      ans=(ans*target)%(1000000000+7);
    }
    long holder=ans ;
    ans=1 ;
    for(int i=0 ; i<sqtimes ; i++){
      ans=(ans*holder)%(1000000000+7);
    }
    for(int i=0 ; i<times-sqtimes*sqtimes ; i++){
      ans=(ans*target)%(1000000000+7);
    }
    return ans ;
  }
  static long div(long a){
    if(a<0)a+=1000000000+7 ;
    return a %(1000000000+7);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute bignum : long := 1000000000 + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
    var b : Sequence(int) ; b := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     a := a->including(sc.getCurrent()->toInteger()) ; 
     b := b->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    if (n mod 2 = 0) then (     var min : double ; min := ((a->at(n / 2 - 1+1) + a->at(n / 2+1))->oclAsType(double)) / 2 ;
     var max : double ; max := ((b->at(n / 2 - 1+1) + b->at(n / 2+1))->oclAsType(double)) / 2 ;
     OclFile["System.out"].println(((max - min) / 0.5)->oclAsType(int) + 1) ) else (     var min : double ; min := a->at(n / 2+1) ;
     var max : double ; max := b->at(n / 2+1) ;
     OclFile["System.out"].println((max - min)->oclAsType(int) + 1) ) ;  
 );
  static   operation divn( target : int, times : int) : long
  pre: true
  post: true
  activity: (     var sqtimes : int ; sqtimes := (times)->sqrt()->oclAsType(int) ;
     var ans : long ; ans := 1 ;
        var i : int ; i := 0 ; while i < sqtimes do ( (     ans := (ans * target) mod (1000000000 + 7) )  ;     i := i + 1 ) ; 
    var holder : long ; holder := ans ;
    ans := 1 ; 
        var i : int ; i := 0 ; while i < sqtimes do ( (     ans := (ans * holder) mod (1000000000 + 7) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < times - sqtimes * sqtimes do ( (     ans := (ans * target) mod (1000000000 + 7) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation div( a : long) : long
  pre: true
  post: true
  activity: (     if (a < 0) then     a := a+(1000000000 + 7) ; else skip ; 
     return a mod (1000000000 + 7) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    new Solver().run();
  }
}
class Solver {
  public void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] A=new int[N];
    int[] B=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
      B[i]=sc.nextInt();
    }
    int[] mina=Arrays.copyOf(A,A.length);
    int[] maxa=Arrays.copyOf(B,B.length);
    Arrays.sort(mina);
    Arrays.sort(maxa);
    if(N % 2==0){
      int l=mina[N/2]+mina[N/2-1];
      ;
      int r=maxa[N/2]+maxa[N/2-1];
      ;
      System.out.println(r-l+1);
    }
    else {
      System.out.println(maxa[N/2]-mina[N/2]+1);
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Solver.newSolver().run() );
}
class Solver {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() ; 
     B[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var mina : Sequence(int) ; mina := A.subrange(1,A->size()) ;
    var maxa : Sequence(int) ; maxa := B.subrange(1,B->size()) ;
    mina := mina->sort() ; 
    maxa := maxa->sort() ; 
    if (N mod 2 = 0) then (     var l : int ; l := mina[N / 2+1] + mina[N / 2 - 1+1] ;
    var r : int ; r := maxa[N / 2+1] + maxa[N / 2 - 1+1] ;
    OclFile["System.out"].println(r - l + 1) ; 
 ) else (     OclFile["System.out"].println(maxa[N / 2+1] - mina[N / 2+1] + 1) ) ;  
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long moduloMultiplication(long a,long b,long mod){
    long res=0 ;
    a %=mod ;
    while(b>0){
      if((b & 1)>0){
        res=(res+a)% mod ;
      }
      a=(2*a)% mod ;
      b>>=1 ;
    }
    return res ;
  }
  public static void main(String[] args){
    long a=10123465234878998L ;
    long b=65746311545646431L ;
    long m=10005412336548794L ;
    System.out.print(moduloMultiplication(a,b,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation moduloMultiplication( a : long, b : long, mod : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 0 ;
     a := a mod mod ; 
     while (b > 0) do (     if ((b & 1) > 0) then (     res := (res + a) mod mod ) else skip ; 
     a := (2 * a) mod mod ; 
     b := b/(2->pow(1)) ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ; a := 10123465234878998L ;
     var b : long ; b := 65746311545646431L ;
     var m : long ; m := 10005412336548794L ;
     OclFile["System.out"].print(moduloMultiplication(a, b, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  boolean union[];
  char[][] str ;
  int n ;
  void run(){
    for(; ; ){
      n=sc.nextInt();
      if(n==0)break ;
      int[] in=new int[256];
      int[] out=new int[256];
      str=new char[n][2];
      for(int i=0 ; i<n ; i++){
        char[] tmp=sc.next().toCharArray();
        str[i][0]=tmp[0];
        str[i][1]=tmp[tmp.length-1];
        in[str[i][0] ]++;
        out[str[i][1] ]++;
      }
      union=new boolean[256];
      dfs(str[0][0]);
      boolean flag=true ;
      for(int i='a' ; i<='z' ; i++){
        if(! union[i] && in[i]+out[i]!=0){
          flag=false ;
          break ;
        }
      }
      if(flag){
        boolean ok=true ;
        for(int i='a' ; i<='z' ; i++){
          if(Math.abs(in[i]-out[i])!=0){
            ok=false ;
            break ;
          }
        }
        System.out.println(ok ? "OK" : "NG");
      }
      else {
        System.out.println("NG");
      }
    }
  }
  void dfs(char c){
    for(int i=0 ; i<n ; i++){
      if(str[i][0]==c){
        if(! union[str[i][1] ]){
          union[str[i][1] ]=true ;
          dfs(str[i][1]);
        }
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute union : Sequence(boolean);
   attribute str : Sequence(Sequence(String));
   attribute n : int;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
    var in : Sequence(int) ; in := Integer.subrange(1,256)->collect(0) ;
    var out : Sequence(int) ; out := Integer.subrange(1,256)->collect(0) ;
    str := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ; 
        var i : int ; i := 0 ; while i < n do ( (     var tmp : Sequence(String) ; tmp := sc.getCurrent()->characters() ;
     str[i+1][0+1] := tmp[0+1] ; 
    str[i+1][1+1] := tmp[tmp->size() - 1+1] ; 
    in[str[i+1][0+1]+1] := in[str[i+1][0+1]+1] + 1 ; 
    out[str[i+1][1+1]+1] := out[str[i+1][1+1]+1] + 1 ; 
 )  ;     i := i + 1 ) ; 
    union := Integer.subrange(1,256)->collect(false) ; 
    execute dfs(str[0+1][0+1]) ; 
    var flag : boolean ; flag := true ;
        var i : int ; i := 'a' ; while i <= 'z' do ( (     if (not(union[i+1]) & in[i+1] + out[i+1] /= 0) then (     flag := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then (     var ok : boolean ; ok := true ;
         var i : int ; i := 'a' ; while i <= 'z' do ( (     if (if in[i+1] - out[i+1] < 0 then -(in[i+1] - out[i+1]) else in[i+1] - out[i+1] endif /= 0) then (     ok := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if ok then "OK" else "NG" endif) ) else (     OclFile["System.out"].println("NG") ) ;  
 )  ) );
   operation dfs( c : String) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (str[i+1][0+1] = c) then (     if (not(union[str[i+1][1+1]+1])) then (     union[str[i+1][1+1]+1] := true ; 
     execute dfs(str[i+1][1+1]) ) else skip ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static class UnionFind {
    int[] dat ;
    public UnionFind(int n){
      dat=new int[n];
      for(int i=0 ; i<n ; i++){
        dat[i]=i ;
      }
    }
    public int find(int x){
      if(dat[x]==x){
        return x ;
      }
      else {
        return dat[x]=find(dat[x]);
      }
    }
    public void union(int x,int y){
      if(find(x)==find(y)){
        return ;
      }
      else {
        dat[find(x)]=find(y);
      }
    }
    public boolean same(int x,int y){
      return find(x)==find(y);
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      final int n=sc.nextInt();
      if(n==0){
        break ;
      }
      int[] count=new int[26];
      HashSet<Integer>using=new HashSet<Integer>();
      UnionFind uf=new UnionFind(26);
      int start=-1 ;
      for(int i=0 ; i<n ; i++){
        char[] in=sc.next().toCharArray();
        final int from=in[0]-'a' ;
        final int to=in[in.length-1]-'a' ;
        count[from]--;
        count[to]++;
        uf.union(from,to);
        using.add(from);
        using.add(to);
        if(start==-1){
          start=from ;
        }
      }
      boolean flag=true ;
      for(int in : using){
        if(! uf.same(in,start)|| count[in]!=0){
          flag=false ;
          break ;
        }
      }
      if(! flag){
        System.out.println("NG");
      }
      else {
        System.out.println("OK");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class UnionFind {
   attribute dat : Sequence(int);
   static operation newUnionFind( n : int) : UnionFind
  pre: true
  post: true
  activity:
  ( var self : UnionFind ;
    self := createUnionFind();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     dat := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do ( (     dat[i+1] := i )  ;     i := i + 1 ) );
   operation find( x : int) : int
  pre: true
  post: true
  activity: (     if (dat[x+1] = x) then (     return x ) else (     return dat[x+1] ) );
   operation union( x : int, y : int) : void
  pre: true
  post: true
  activity: (     if (find(x) = find(y)) then (     return ) else (     dat[find(x)+1] := find(y) ) );
   operation same( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return find(x) = find(y) );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var count : Sequence(int) ; count := Integer.subrange(1,26)->collect(0) ;
    var using : Set(int) ; using := Set{} ;
    var uf : UnionFind ; uf := UnionFind.newUnionFind(26) ;
    var start : int ; start := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var in : Sequence(String) ; in := sc.getCurrent()->characters() ;
     var from : int ; from := in[0+1] - ('a')->char2byte() ;
    var to : int ; to := in[in->size() - 1+1] - ('a')->char2byte() ;
    count[from+1] := count[from+1] - 1 ; 
    count[to+1] := count[to+1] + 1 ; 
    uf.union(from, to) ; 
    using := using->including(from) ; 
    using := using->including(to) ; 
    if (start = -1) then (     start := from ) else skip ; 
 )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := true ;
    for (in : using) do ( (     if (not(uf.same(in, start)) or count[in+1] /= 0) then (     flag := false ; 
     break ) else skip )  ) ; 
    if (not(flag)) then (     OclFile["System.out"].println("NG") ) else (     OclFile["System.out"].println("OK") ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int[] a=IntStream.range(0,N).map(i->scan.nextInt()).toArray();
    int index=0 ;
    for(int i=0 ; i<N ; ++i)if(Math.abs(a[index])<Math.abs(a[i]))index=i ;
    System.out.println(2*N-1);
    for(int i=0 ; i<N ; ++i)System.out.println((index+1)+" "+(i+1));
    if(a[index]>0){
      for(int i=2 ; i<=N ; ++i)System.out.println((i-1)+" "+i);
    }
    else {
      for(int i=N-1 ; i>=1 ; --i)System.out.println((i+1)+" "+i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(0, N-1)->collect( _x1 | (lambda i : OclAny in scan.getCurrent()->toInteger())->apply(_x1) )->asSequence() ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < N do (     if (if a[index+1] < 0 then -(a[index+1]) else a[index+1] endif < if a[i+1] < 0 then -(a[i+1]) else a[i+1] endif) then     index := i ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(2 * N - 1) ; 
        var i : int ; i := 0 ; while i < N do (     OclFile["System.out"].println((index + 1) + " " + (i + 1)) ;  ;     i := i + 1 ) ; 
    if (a[index+1] > 0) then (         var i : int ; i := 2 ; while i <= N do (     OclFile["System.out"].println((i - 1) + " " + i) ;  ;     i := i + 1 ) ) else (         var i : int ; i := N - 1 ; while i >= 1 do (     OclFile["System.out"].println((i + 1) + " " + i) ;  ;     i := i - 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    long[] nums=new long[N];
    int minIndex=0 ;
    int maxIndex=0 ;
    for(int i=0 ; i<N ; i++){
      nums[i]=in.nextLong();
      if(nums[minIndex]>nums[i]){
        minIndex=i ;
      }
      if(nums[maxIndex]<nums[i]){
        maxIndex=i ;
      }
    }
    int useIndex=-1 ;
    boolean isNegative=false ;
    if(Math.abs(nums[minIndex])<Math.abs(nums[maxIndex])){
      useIndex=maxIndex ;
    }
    else {
      useIndex=minIndex ;
    }
    if(nums[useIndex]<0){
      isNegative=true ;
    }
    ArrayList<Integer>arr=new ArrayList<Integer>();
    if(isNegative){
      for(int i=N-1 ; i>=1 ; i--){
        while(nums[i-1]>nums[i]){
          nums[i-1]+=nums[useIndex];
          arr.add(useIndex+1);
          arr.add(i-1+1);
        }
        if(nums[i-1]<nums[useIndex]){
          useIndex=i-1 ;
        }
      }
    }
    else {
      for(int i=0 ; i<N-1 ; i++){
        while(nums[i]>nums[i+1]){
          nums[i+1]+=nums[useIndex];
          arr.add(useIndex+1);
          arr.add(i+1+1);
        }
        if(nums[useIndex]<nums[i+1]){
          useIndex=i+1 ;
        }
      }
    }
    System.out.println(arr.size()/2);
    for(int i=0 ; i<arr.size(); i+=2){
      System.out.printf("%d %d\n",arr.get(i),arr.get(i+1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var nums : Sequence(long) ; nums := Integer.subrange(1,N)->collect(0) ;
    var minIndex : int ; minIndex := 0 ;
    var maxIndex : int ; maxIndex := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     nums[i+1] := in.getCurrent()->toLong() ; 
     if (nums[minIndex+1] > nums[i+1]) then (     minIndex := i ) else skip ; 
     if (nums[maxIndex+1] < nums[i+1]) then (     maxIndex := i ) else skip )  ;     i := i + 1 ) ; 
    var useIndex : int ; useIndex := -1 ;
    var isNegative : boolean ; isNegative := false ;
    if (if nums[minIndex+1] < 0 then -(nums[minIndex+1]) else nums[minIndex+1] endif < if nums[maxIndex+1] < 0 then -(nums[maxIndex+1]) else nums[maxIndex+1] endif) then (     useIndex := maxIndex ) else (     useIndex := minIndex ) ;  
    if (nums[useIndex+1] < 0) then (     isNegative := true ) else skip ; 
    var arr : Sequence(int) ; arr := Sequence{} ;
    if (isNegative) then (         var i : int ; i := N - 1 ; while i >= 1 do ( (     while (nums[i - 1+1] > nums[i+1]) do (     nums[i - 1+1] := nums[i - 1+1]+(nums[useIndex+1]) ; 
     arr := arr->including(useIndex + 1) ; 
     arr := arr->including(i - 1 + 1) ) ; 
     if (nums[i - 1+1] < nums[useIndex+1]) then (     useIndex := i - 1 ) else skip )  ;     i := i - 1 ) ) else (         var i : int ; i := 0 ; while i < N - 1 do ( (     while (nums[i+1] > nums[i + 1+1]) do (     nums[i + 1+1] := nums[i + 1+1]+(nums[useIndex+1]) ; 
     arr := arr->including(useIndex + 1) ; 
     arr := arr->including(i + 1 + 1) ) ; 
     if (nums[useIndex+1] < nums[i + 1+1]) then (     useIndex := i + 1 ) else skip )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(arr->size() / 2) ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (     OclFile["System.out"].printf("%d %d\n", arr->at(i+1), arr->at(i + 1+1)) )  ;     i := i+(2) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner stdin=new Scanner(System.in);
    int N=stdin.nextInt();
    double sum=0 ;
    for(int i=1 ; i<=N ; i++){
      if(i % 2!=0){
        sum+=1 ;
      }
    }
    System.out.println(sum/N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := stdin.getCurrent()->toInteger() ;
    var sum : double ; sum := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     if (i mod 2 /= 0) then (     sum := sum+(1) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum / N) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static long MOD=1000000007 ;
  static char[] exp ;
  public static void main(String[] args){
    exp=sc.next().toCharArray();
    int v=sc.nextInt();
    int r1=calc1();
    int r2=calc2();
    if(v==r1){
      System.out.println(v==r2 ? 'U' : 'M');
    }
    else {
      System.out.println(v==r2 ? 'L' : 'I');
    }
  }
  static int calc1(){
    ArrayList<Integer>stack=new ArrayList<Integer>();
    stack.add(exp[0]-'0');
    for(int i=1 ; i<exp.length ; i+=2){
      if(exp[i]=='+'){
        stack.add(exp[i+1]-'0');
      }
      else {
        stack.set(stack.size()-1,stack.get(stack.size()-1)*(exp[i+1]-'0'));
      }
    }
    int ret=0 ;
    for(int v : stack){
      ret+=v ;
    }
    return ret ;
  }
  static int calc2(){
    int v=exp[0]-'0' ;
    for(int i=1 ; i<exp.length ; i+=2){
      if(exp[i]=='+'){
        v+=exp[i+1]-'0' ;
      }
      else {
        v*=exp[i+1]-'0' ;
      }
    }
    return v ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute MOD : long := 1000000007;
  static   attribute exp : Sequence(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     exp := sc.getCurrent()->characters() ; 
     var v : int ; v := sc.getCurrent()->toInteger() ;
    var r1 : int ; r1 := calc1() ;
    var r2 : int ; r2 := calc2() ;
    if (v = r1) then (     OclFile["System.out"].println(if v = r2 then 'U' else 'M' endif) ) else (     OclFile["System.out"].println(if v = r2 then 'L' else 'I' endif) ) ;  
 );
  static   operation calc1() : int
  pre: true
  post: true
  activity: (     var stack : Sequence(int) ; stack := Sequence{} ;
     stack := stack->including(exp[0+1] - ('0')->char2byte()) ; 
        var i : int ; i := 1 ; while i < exp->size() do ( (     if (exp[i+1] = '+') then (     stack := stack->including(exp[i + 1+1] - ('0')->char2byte()) ) else (     stack := stack.setAt(stack->size() - 1+1,stack->at(stack->size() - 1+1) * (exp[i + 1+1] - ('0')->char2byte())) ) )  ;     i := i+(2) ) ; 
    var ret : int ; ret := 0 ;
    for (v : stack) do ( (     ret := ret+(v) )  ) ; 
    return ret 
 );
  static   operation calc2() : int
  pre: true
  post: true
  activity: (     var v : int ; v := exp[0+1] - ('0')->char2byte() ;
         var i : int ; i := 1 ; while i < exp->size() do ( (     if (exp[i+1] = '+') then (     v := v+(exp[i + 1+1] - ('0')->char2byte()) ) else (     v := v*(exp[i + 1+1] - ('0')->char2byte()) ) )  ;     i := i+(2) ) ; 
     return v );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n+1];
    int abs=0 ;
    int num=1 ;
    for(int i=1 ; i<n+1 ; i++){
      int in=sc.nextInt();
      a[i]=in ;
      if(Math.abs(abs)<Math.abs(in)){
        abs=in ;
        num=i ;
      }
    }
    int cnt=0 ;
    String ans="" ;
    for(int i=1 ; i<n+1 ; i++){
      if(i!=num){
        ans+=num+" "+i+"\n" ;
        cnt++;
      }
    }
    if(abs<0){
      for(int i=n ; i>1 ; i--){
        ans+=i+" "+(i-1)+"\n" ;
        cnt++;
      }
    }
    else {
      for(int i=1 ; i<n ; i++){
        ans+=i+" "+(i+1)+"\n" ;
        cnt++;
      }
    }
    ans=cnt+"\n"+ans ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var abs : int ; abs := 0 ;
    var num : int ; num := 1 ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     var in : int ; in := sc.getCurrent()->toInteger() ;
     a[i+1] := in ; 
     if (if abs < 0 then -(abs) else abs endif < if in < 0 then -(in) else in endif) then (     abs := in ; 
     num := i ) else skip )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    var ans : String ; ans := "" ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     if (i /= num) then (     ans := ans+(num + " " + i + "\n") ; 
     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (abs < 0) then (         var i : int ; i := n ; while i > 1 do ( (     ans := ans+(i + " " + ((i)->char2byte() - 1) + "\n") ; 
     cnt := cnt + 1 )  ;     i := i - 1 ) ) else (         var i : int ; i := 1 ; while i < n do ( (     ans := ans+(i + " " + (i + 1) + "\n") ; 
     cnt := cnt + 1 )  ;     i := i + 1 ) ) ;  
    ans := cnt + "\n" + ans ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solveD();
  }
  private void solveD(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int a[]=new int[N+1];
    int max=0 ;
    int max_id=-1 ;
    int min=0 ;
    int min_id=-1 ;
    for(int i=1 ; i<=N ; i++){
      a[i]=sc.nextInt();
      if(max<a[i]){
        max=a[i];
        max_id=i ;
      }
      if(min>a[i]){
        min=a[i];
        min_id=i ;
      }
    }
    if(max>=-min && max_id!=-1){
      System.out.println(2*N-2);
      for(int i=1 ; i<=N ; i++){
        if(i==max_id){
          continue ;
        }
        System.out.println(max_id+" "+i);
      }
      for(int i=1 ; i<=N-1 ; i++){
        System.out.println(i+" "+(i+1));
      }
    }
    else if(max<=-min && min_id!=-1){
      System.out.println(2*N-2);
      for(int i=1 ; i<=N ; i++){
        if(i==min_id){
          continue ;
        }
        System.out.println(min_id+" "+i);
      }
      for(int i=N ; i>1 ; i--){
        System.out.println(i+" "+(i-1));
      }
    }
    else {
      System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solveD() );
   operation solveD() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N + 1)->collect(0) ;
    var max : int ; max := 0 ;
    var max_id : int ; max_id := -1 ;
    var min : int ; min := 0 ;
    var min_id : int ; min_id := -1 ;
        var i : int ; i := 1 ; while i <= N do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (max < a[i+1]) then (     max := a[i+1] ; 
     max_id := i ) else skip ; 
     if (min > a[i+1]) then (     min := a[i+1] ; 
     min_id := i ) else skip )  ;     i := i + 1 ) ; 
    if (max >= -min & max_id /= -1) then (     OclFile["System.out"].println(2 * N - 2) ; 
         var i : int ; i := 1 ; while i <= N do ( (     if (i = max_id) then (     continue ) else skip ; 
     OclFile["System.out"].println(max_id + " " + i) )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i <= N - 1 do ( (     OclFile["System.out"].println(i + " " + (i + 1)) )  ;     i := i + 1 ) ) else     if (max <= -min & min_id /= -1) then (     OclFile["System.out"].println(2 * N - 2) ; 
         var i : int ; i := 1 ; while i <= N do ( (     if (i = min_id) then (     continue ) else skip ; 
     OclFile["System.out"].println(min_id + " " + i) )  ;     i := i + 1 ) ; 
         var i : int ; i := N ; while i > 1 do ( (     OclFile["System.out"].println(i + " " + (i - 1)) )  ;     i := i - 1 ) ) else (     OclFile["System.out"].println(0) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] $){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int[] a=new int[n];
    Arrays.setAll(a,i->s.nextInt());
    ArrayList<String>r=new ArrayList<>();
    int m=0 ;
    for(int i=1 ; i<n ; ++i)if(Math.abs(a[m])<Math.abs(a[i]))m=i ;
    for(int i=0 ; i<n ; ++i)if(a[m]>=0 ^ a[i]>=0)r.add(m+1+" "+(i+1));
    if(a[m]>=0){
      for(int i=1 ; i<n ; ++i)r.add(i+" "+(i+1));
    }
    else {
      for(int i=n ; i>1 ; --i)r.add(i+" "+(i-1));
    }
    System.out.println(r.size());
    r.forEach(System.out :: println);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
setAll(a, lambda i : OclAny in s.getCurrent()->toInteger()) ; 
    var r : Sequence(String) ; r := Sequence{} ;
    var m : int ; m := 0 ;
        var i : int ; i := 1 ; while i < n do (     if (if a[m+1] < 0 then -(a[m+1]) else a[m+1] endif < if a[i+1] < 0 then -(a[i+1]) else a[i+1] endif) then     m := i ; else skip ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     if (a[m+1] >= 0 xor a[i+1] >= 0) then     r := r->including(m + 1 + " " + (i + 1)) ; else skip ;  ;     i := i + 1 ) ; 
    if (a[m+1] >= 0) then (         var i : int ; i := 1 ; while i < n do (     r := r->including(i + " " + (i + 1)) ;  ;     i := i + 1 ) ) else (         var i : int ; i := n ; while i > 1 do (     r := r->including(i + " " + (i - 1)) ;  ;     i := i - 1 ) ) ;  
    OclFile["System.out"].println(r->size()) ; 
    for _forEach : r do
    (    skip ;) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
public class GFG {
  static boolean checkPalindrome(String str){
    int len=str.length();
    len--;
    for(int i=0 ; i<len ; i++){
      if(str.charAt(i)!=str.charAt(len))return false ;
      len--;
    }
    return true ;
  }
  static void printSolution(ArrayList<ArrayList<String>>partitions){
    for(ArrayList<String>i : partitions){
      for(String j : i){
        System.out.print(j+" ");
      }
      System.out.println();
    }
  }
  static ArrayList<ArrayList<String>>addStrings(ArrayList<ArrayList<String>>v,String s,ArrayList<String>temp,int index){
    int len=s.length();
    String str="" ;
    ArrayList<String>current=new ArrayList<>(temp);
    if(index==0)temp.clear();
    for(int i=index ; i<len ; ++i){
      str=str+s.charAt(i);
      if(checkPalindrome(str)){
        temp.add(str);
        if(i+1<len){
          v=addStrings(v,s,temp,i+1);
        }
        else {
          v.add(temp);
        }
        temp=new ArrayList<>(current);
      }
    }
    return v ;
  }
  static void partition(String s,ArrayList<ArrayList<String>>v){
    ArrayList<String>temp=new ArrayList<>();
    v=addStrings(v,s,temp,0);
    printSolution(v);
  }
  public static void main(String args[]){
    String s="geeks" ;
    ArrayList<ArrayList<String>>partitions=new ArrayList<>();
    partition(s,partitions);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkPalindrome( str : String) : boolean
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     len := len - 1 ; 
         var i : int ; i := 0 ; while i < len do ( (     if (str->at(i+1) /= str->at(len+1)) then     return false else skip ; 
     len := len - 1 )  ;     i := i + 1 ) ; 
     return true );
  static   operation printSolution( partitions : Sequence(Sequence(String))) : void
  pre: true
  post: true
  activity: (     for (i : partitions) do ( (     for (j : i) do ( (     OclFile["System.out"].print(j + " ") )  ) ; 
     OclFile["System.out"].println() )  ) );
  static   operation addStrings( v : Sequence(Sequence(String)), s : String, temp : Sequence(String), index : int) : Sequence(Sequence(String))
  pre: true
  post: true
  activity: (     var len : int ; len := s->size() ;
     var str : String ; str := "" ;
    var current : Sequence(String) ; current := Sequence{}->union(temp) ;
    if (index = 0) then     temp := temp->intersection(Set{}) ; else skip ; 
        var i : int ; i := index ; while i < len do ( (     str := str + s->at(i+1) ; 
     if (checkPalindrome(str)) then (     temp->excludes(str) ; 
     if (i + 1 < len) then (     v := addStrings(v, s, temp, i + 1) ) else (     v->excludes(temp) ) ;  
     temp := Sequence{}->union(current) ) else skip )  ;     i := i + 1 ) ; 
    return v 
 );
  static   operation partition( s : String, v : Sequence(Sequence(String))) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(String) ; temp := Sequence{} ;
     v := addStrings(v, s, temp, 0) ; 
     execute printSolution(v) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeks" ;
     var partitions : Sequence(Sequence(String)) ; partitions := Sequence{} ;
     execute partition(s, partitions) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
class Main {
  public static void cout(String str){
    System.out.println(str);
  };
  public static void main(String args[]){
    Scanner cin=new Scanner(System.in);
    String a="",b="",str ;
    int n ;
    n=cin.nextInt();
    cin.nextLine();
    str=cin.nextLine();
    for(int i=0 ; i<n/2 ; i++){
      a=a+str.charAt(i);
    }
    if(str.equals(a+a))cout("Yes");
    else cout("No");
  }
};
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation cout( str : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(str) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := "" ;
    var b : String ; b := "" ;
    var str : String ;
    var n : int ;
    n := cin.getCurrent()->toInteger() ; 
    skip ; 
    str := cin.nextLine() ; 
        var i : int ; i := 0 ; while i < n / 2 do ( (     a := a + str->at(i+1) )  ;     i := i + 1 ) ; 
    if (str = a + a) then     execute cout("Yes") else     execute cout("No") ; ;  
 );
}
;

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    new Solution();
  }
}
class Solution {
  Reader reader ;
  public Solution(){
    reader=new Reader();
    while(reader.hasNext()){
      run_case();
    }
  }
  private void run_case(){
    int n=reader.ni();
    String str=reader.ns();
    String a=str.substring(str.length()/2);
    String b=str.substring(0,str.length()/2);
    if(a.equals(b)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
    return ;
  }
}
class Reader {
  BufferedReader br ;
  StringTokenizer st ;
  public Reader(){
    try {
      br=new BufferedReader(new InputStreamReader(System.in));
      st=new StringTokenizer(br.readLine());
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  public String next(){
    if(st.hasMoreTokens())return st.nextToken();
    try {
      st=new StringTokenizer(br.readLine());
    }
    catch(Exception e){
      e.printStackTrace();
    }
    return st.nextToken();
  }
  public boolean hasNext(){
    try {
      if(! st.hasMoreTokens()&& ! br.ready())return false ;
      else return true ;
    }
    catch(Exception e){
      e.printStackTrace();
    }
    return false ;
  }
  public int ni(){
    return Integer.parseInt(this.next());
  }
  public String ns(){
    return this.next();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Solution.newSolution() );
}
class Solution {
   attribute reader : OclFile;
   static operation newSolution() : Solution
  pre: true
  post: true
  activity:
  ( var self : Solution ;
    self := createSolution();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     reader := OclFile() ; 
     while (reader.hasNext()) do (     execute run_case() ) );
   operation run_case() : void
  pre: true
  post: true
  activity: (     var n : int ; n := reader.ni() ;
     var str : String ; str := reader.ns() ;
    var a : String ; a := str.subrange(str->size() / 2+1,str->size() / 2) ;
    var b : String ; b := str.subrange(0+1,str->size() / 2) ;
    if (a = b) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
    return 
 );
}
class Reader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newReader() : Reader
  pre: true
  post: true
  activity:
  ( var self : Reader ;
    self := createReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     if (st.hasNext()) then     return st.next() else skip ; 
     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     e.printStackTrace() )
     return st.next() );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     try (     if (not(st.hasNext()) & not(br.canRead())) then     return false else     return true )   catch (e : ProgramException) do (     e.printStackTrace() )
     return false );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (self.next())->toInteger() );
   operation ns() : String
  pre: true
  post: true
  activity: (     return self.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  static final PrintStream out=System.out ;
  static final Scanner sc=new Scanner(System.in);
  static final long Mod=1000_000_007L ;
  int N ;
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
    System.exit(0);
  }
  void solve(){
    N=nextInt();
    String S=next();
    if(N % 2==1){
      out.println("No");
      return ;
    }
    if(S.substring(0,N/2).equals(S.substring(N/2,N))){
      out.println("Yes");
    }
    else {
      out.println("No");
    }
  }
  public int[] nextIntArray(int n){
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public long[] nextLongArray(int n){
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=nextLong();
    return a ;
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
  public String next(){
    return sc.next();
  }
  long gcd(long m,long n){
    if(m<n)return gcd(n,m);
    if(n==0)return m ;
    return gcd(n,m % n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute out : OclFile := OclFile["System.out"];
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute Mod : long := 1000_000_007L;
   attribute N : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() ; 
 OclProcess.exit(0) );
   operation solve() : void
  pre: true
  post: true
  activity: (     N := nextInt() ; 
     var S : String ; S := next() ;
     if (N mod 2 = 1) then (     skip ; 
     return ) else skip ; 
     if (S.subrange(0+1,N / 2) = S.subrange(N / 2+1,N)) then (     skip ) else (     skip ) );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation next() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
   operation gcd( m : long, n : long) : long
  pre: true
  post: true
  activity: (     if (m < n) then     return gcd(n, m) else skip ; 
     if (n = 0) then     return m else skip ; 
     return gcd(n, m mod n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    String ss=s.next();
    if(t % 2==1)System.out.println("No");
    else if(! ss.substring(0,t/2).equals(ss.substring(t/2,t)))System.out.println("No");
    else System.out.println("Yes");
    s.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
    var ss : String ; ss := s.getCurrent() ;
    if (t mod 2 = 1) then     OclFile["System.out"].println("No") else     if (not(ss.subrange(0+1,t / 2) = ss.subrange(t / 2+1,t))) then     OclFile["System.out"].println("No") else     OclFile["System.out"].println("Yes") ; ;  ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.PrintWriter ;
import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.Math.*;
import static java.lang.System.*;
public class Main {
  public static int MOD=1000000007 ;
  public static void main(String[] args){
    int i,j ;
    Scanner sc=new Scanner(in);
    int n=parseInt(sc.next());
    char[] s=sc.next().toCharArray();
    sc.close();
    boolean f=false ;
    if(n % 2==0){
      f=true ;
      for(i=0 ; i<n/2 ; i++){
        if(s[i]!=s[i+n/2]){
          f=false ;
          break ;
        }
      }
    }
    out.println(f ? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
    var n : int ; n := parseInt(sc.getCurrent()) ;
    var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    skip ; 
    var f : boolean ; f := false ;
    if (n mod 2 = 0) then (     f := true ; 
         i := 0 ; while i < n / 2 do ( (     if (s[i+1] /= s[i + n / 2+1]) then (     f := false ; 
     break ) else skip )  ;     i := i + 1 ) ) else skip ; 
    out.println(if f then "Yes" else "No" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigDecimal ;
import java.math.RoundingMode ;
class Main {
  public static void main(String[] args)throws Exception {
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      double input=Double.parseDouble(br.readLine());
      double countOdd=Math.round(input/2);
      BigDecimal result=new BigDecimal(countOdd/input);
      result.setScale(10,RoundingMode.HALF_UP);
      System.out.println(result);
    }
    catch(IOException | NumberFormatException e){
      e.printStackTrace();
      System.exit(0);
    }
    catch(final Exception e){
      e.printStackTrace();
      System.exit(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : double ; input := (br.readLine())->toReal() ;
    var countOdd : double ; countOdd := (input / 2)->round() ;
    var result : double ; result := double(countOdd / input) ;
    result.setScale(10, RoundingMode.HALF_UP) ; 
    OclFile["System.out"].println(result) ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
 OclProcess.exit(0) )
   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(0) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
class Main {
  static final int M=100000007 ;
  public static int comb(int n,int c){
    BigInteger b=BigInteger.ONE ;
    for(int i=0 ; i<c ; i++){
      b=b.multiply(new BigInteger(String.valueOf(n-i))).divide(new BigInteger(String.valueOf(i+1)));
    }
    return b.mod(new BigInteger(String.valueOf(M))).intValue();
  }
  public static void main(String[] Z){
    Scanner cin=new Scanner(System.in);
    int r=cin.nextInt(),c=cin.nextInt(),a1=cin.nextInt(),a2=cin.nextInt(),b1=cin.nextInt(),b2=cin.nextInt();
    int x=Math.abs(a1-b1),y=Math.abs(a2-b2);
    x=Math.min(x,r-x);
    y=Math.min(y,c-y);
    int z=1 ;
    if(x==r-x)z*=2 ;
    if(y==c-y)z*=2 ;
    System.out.println(z*comb(x+y,Math.min(x,y))% M);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute M : int := 100000007;
  static   operation comb( n : int, c : int) : int
  pre: true
  post: true
  activity: (     var b : long ; b := 1 ;
         var i : int ; i := 0 ; while i < c do ( (     b := b.multiply(long(((n - i) + ""))).divide(long(((i + 1) + ""))) )  ;     i := i + 1 ) ; 
     return b.mod(long(((M) + "")))->oclAsType(int) );
  static   operation main( Z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := cin.getCurrent()->toInteger() ;
    var c : int ; c := cin.getCurrent()->toInteger() ;
    var a1 : int ; a1 := cin.getCurrent()->toInteger() ;
    var a2 : int ; a2 := cin.getCurrent()->toInteger() ;
    var b1 : int ; b1 := cin.getCurrent()->toInteger() ;
    var b2 : int ; b2 := cin.getCurrent()->toInteger() ;
    var x : int ; x := if a1 - b1 < 0 then -(a1 - b1) else a1 - b1 endif ;
    var y : int ; y := if a2 - b2 < 0 then -(a2 - b2) else a2 - b2 endif ;
    x := Set{x, r - x}->min() ; 
    y := Set{y, c - y}->min() ; 
    var z : int ; z := 1 ;
    if (x = r - x) then     z := z*(2) ; else skip ; 
    if (y = c - y) then     z := z*(2) ; else skip ; 
    OclFile["System.out"].println(z * comb(x + y, Set{x, y}->min()) mod M) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    Scanner sc=new Scanner(System.in);
    String exp=sc.next();
    int res=sc.nextInt();
    boolean m=multiple(exp,res);
    boolean l=left(exp,res);
    if(m && l)System.out.println('U');
    else if(m)System.out.println('M');
    else if(l)System.out.println('L');
    else System.out.println('I');
    sc.close();
  }
  private boolean left(String exp,int res){
    int result=0 ;
    char op='+' ;
    for(char c : exp.toCharArray()){
      if(Character.isDigit(c))if(op=='+')result+=c-'0' ;
      else result*=c-'0' ;
      else op=c ;
    }
    return result==res ;
  }
  private boolean multiple(String exp,int res){
    String[] terms=exp.split("\\+");
    int sum=0 ;
    for(String term : terms){
      String[] factors=term.split("\\*");
      int fact=1 ;
      for(String factor : factors){
        fact*=Integer.parseInt(factor);
      }
      sum+=fact ;
    }
    return res==sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var exp : String ; exp := sc.getCurrent() ;
    var res : int ; res := sc.getCurrent()->toInteger() ;
    var m : boolean ; m := multiple(exp, res) ;
    var l : boolean ; l := left(exp, res) ;
    if (m & l) then     OclFile["System.out"].println('U') else     if (m) then     OclFile["System.out"].println('M') else     if (l) then     OclFile["System.out"].println('L') else     OclFile["System.out"].println('I') ; ;  ;  ;  
    skip ; 
 );
   operation left( exp : String, res : int) : boolean
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var op : String ; op := '+' ;
     for (c : exp->characters()) do ( (     if ((c + "")->isMatch("[0-9]")) then     if (op = '+') then     result := result+(c - ('0')->char2byte()) else     result := result*(c - ('0')->char2byte()) ; ;  else     op := c ; )  ) ; 
     return result = res );
   operation multiple( exp : String, res : int) : boolean
  pre: true
  post: true
  activity: (     var terms : Sequence(String) ; terms := exp->split("\\+") ;
     var sum : int ; sum := 0 ;
     for (term : terms) do ( (     var factors : Sequence(String) ; factors := term->split("\\*") ;
     var fact : int ; fact := 1 ;
     for (factor : factors) do ( (     fact := fact*((factor)->toInteger()) )  ) ; 
     sum := sum+(fact) )  ) ; 
     return res = sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int R=sc.nextInt();
    int C=sc.nextInt();
    int Y1=sc.nextInt();
    int X1=sc.nextInt();
    int Y2=sc.nextInt();
    int X2=sc.nextInt();
    int h=Math.abs(Y2-Y1);
    h=Math.min(h,R-h);
    int w=Math.abs(X2-X1);
    w=Math.min(w,C-w);
    BigInteger ans=BigInteger.ONE ;
    for(int i=0 ; i<h ; ++i){
      ans=ans.multiply(BigInteger.valueOf(h+w-i)).divide(BigInteger.valueOf(i+1));
    }
    if(h*2==R){
      ans=ans.shiftLeft(1);
    }
    if(w*2==C){
      ans=ans.shiftLeft(1);
    }
    System.out.println(ans.mod(BigInteger.valueOf(100000007)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var R : int ; R := sc.getCurrent()->toInteger() ;
     var C : int ; C := sc.getCurrent()->toInteger() ;
    var Y1 : int ; Y1 := sc.getCurrent()->toInteger() ;
    var X1 : int ; X1 := sc.getCurrent()->toInteger() ;
    var Y2 : int ; Y2 := sc.getCurrent()->toInteger() ;
    var X2 : int ; X2 := sc.getCurrent()->toInteger() ;
    var h : int ; h := if Y2 - Y1 < 0 then -(Y2 - Y1) else Y2 - Y1 endif ;
    h := Set{h, R - h}->min() ; 
    var w : int ; w := if X2 - X1 < 0 then -(X2 - X1) else X2 - X1 endif ;
    w := Set{w, C - w}->min() ; 
    var ans : long ; ans := 1 ;
        var i : int ; i := 0 ; while i < h do ( (     ans := ans.multiply((h + w - i + "")->toLong()).divide((i + 1 + "")->toLong()) )  ;     i := i + 1 ) ; 
    if (h * 2 = R) then (     ans := ans.shiftLeft(1) ) else skip ; 
    if (w * 2 = C) then (     ans := ans.shiftLeft(1) ) else skip ; 
    OclFile["System.out"].println(ans.mod((100000007 + "")->toLong())) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  Scanner sc=new Scanner(in);
  final int mod=(int)1E8+7 ;
  int mod_pow(long x,int n){
    long res=1 ;
    while(n>0){
      if((n & 1)==1)res=(res*x)% mod ;
      x=(x*x)% mod ;
      n>>=1 ;
    }
    return(int)res ;
  }
  int mod_fact(int n){
    long res=1 ;
    for(int i=2 ; i<=n ; i++)res=(res*i)% mod ;
    return(int)res ;
  }
  int mod_comb(int n,int k){
    if(n<0 || k<0 || n<k)return 0 ;
    long res=mod_fact(n);
    res=(res*mod_pow(mod_fact(k),mod-2))% mod ;
    res=(res*mod_pow(mod_fact(n-k),mod-2))% mod ;
    return(int)res ;
  }
  void run(){
    int r=sc.nextInt(),c=sc.nextInt(),a1=sc.nextInt(),a2=sc.nextInt(),b1=sc.nextInt(),b2=sc.nextInt();
    int n,k,count=1 ;
    n=min(abs(a1-b1),r-abs(a1-b1));
    k=min(abs(a2-b2),c-abs(a2-b2));
    if(abs(a1-b1)==r-abs(a1-b1))count*=2 ;
    if(abs(a2-b2)==c-abs(a2-b2))count*=2 ;
    out.println((mod_comb(n+k,k)*count)% mod);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   attribute mod : int := 1E8->oclAsType(int) + 7;
   operation mod_pow( x : long, n : int) : int
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     while (n > 0) do (     if ((n & 1) = 1) then     res := (res * x) mod mod ; else skip ; 
     x := (x * x) mod mod ; 
     n := n/(2->pow(1)) ) ; 
     return res->oclAsType(int) );
   operation mod_fact( n : int) : int
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : int ; i := 2 ; while i <= n do (     res := (res * i) mod mod ;  ;     i := i + 1 ) ; 
     return res->oclAsType(int) );
   operation mod_comb( n : int, k : int) : int
  pre: true
  post: true
  activity: (     if (n < 0 or k < 0 or n < k) then     return 0 else skip ; 
     var res : long ; res := mod_fact(n) ;
    res := (res * mod_pow(mod_fact(k), mod - 2)) mod mod ; 
    res := (res * mod_pow(mod_fact(n - k), mod - 2)) mod mod ; 
    return res->oclAsType(int) 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     var r : int ; r := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var a1 : int ; a1 := sc.getCurrent()->toInteger() ;
    var a2 : int ; a2 := sc.getCurrent()->toInteger() ;
    var b1 : int ; b1 := sc.getCurrent()->toInteger() ;
    var b2 : int ; b2 := sc.getCurrent()->toInteger() ;
     var n : int ;
    var k : int ;
    var count : int ; count := 1 ;
    n := Set{abs(a1 - b1), r - abs(a1 - b1)}->min() ; 
    k := Set{abs(a2 - b2), c - abs(a2 - b2)}->min() ; 
    if (abs(a1 - b1) = r - abs(a1 - b1)) then     count := count*(2) ; else skip ; 
    if (abs(a2 - b2) = c - abs(a2 - b2)) then     count := count*(2) ; else skip ; 
    out.println((mod_comb(n + k, k) * count) mod mod) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    final int r=sc.nextInt();
    final int c=sc.nextInt();
    final int a1=sc.nextInt();
    final int a2=sc.nextInt();
    final int b1=sc.nextInt();
    final int b2=sc.nextInt();
    int b1_=Math.abs(b1-a1);
    int b2_=Math.abs(b2-a2);
    long pow=1 ;
    if(b1_==r-b1_){
      pow*=2 ;
    }
    if(b2_==c-b2_){
      pow*=2 ;
    }
    b1_=Math.min(b1_,r-b1_);
    b2_=Math.min(b2_,c-b2_);
    long dp[][]=new long[r][c];
    for(int i=0 ; i<r ; i++){
      for(int j=0 ; j<c ; j++){
        if(i==0 && j==0){
          dp[i][j]=1 ;
        }
        else if(i==0){
          dp[i][j]=dp[i][j-1];
        }
        else if(j==0){
          dp[i][j]=dp[i-1][j];
        }
        else {
          dp[i][j]=(dp[i-1][j]+dp[i][j-1])% 100000007 ;
        }
      }
    }
    System.out.println((dp[b1_][b2_]*pow)% 100000007);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var a1 : int ; a1 := sc.getCurrent()->toInteger() ;
    var a2 : int ; a2 := sc.getCurrent()->toInteger() ;
    var b1 : int ; b1 := sc.getCurrent()->toInteger() ;
    var b2 : int ; b2 := sc.getCurrent()->toInteger() ;
    var b1_ : int ; b1_ := if b1 - a1 < 0 then -(b1 - a1) else b1 - a1 endif ;
    var b2_ : int ; b2_ := if b2 - a2 < 0 then -(b2 - a2) else b2 - a2 endif ;
    var pow : long ; pow := 1 ;
    if (b1_ = r - b1_) then (     pow := pow*(2) ) else skip ; 
    if (b2_ = c - b2_) then (     pow := pow*(2) ) else skip ; 
    b1_ := Set{b1_, r - b1_}->min() ; 
    b2_ := Set{b2_, c - b2_}->min() ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,r)->collect(Integer.subrange(1,c)->collect(0)) ;
        var i : int ; i := 0 ; while i < r do ( (         var j : int ; j := 0 ; while j < c do ( (     if (i = 0 & j = 0) then (     dp[i+1][j+1] := 1 ) else     if (i = 0) then (     dp[i+1][j+1] := dp[i+1][j - 1+1] ) else     if (j = 0) then (     dp[i+1][j+1] := dp[i - 1+1][j+1] ) else (     dp[i+1][j+1] := (dp[i - 1+1][j+1] + dp[i+1][j - 1+1]) mod 100000007 ) ;  ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((dp[b1_+1][b2_+1] * pow) mod 100000007) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  final int p=100000007 ;
  int[][] dp=new int[1001][1001];
  void run(){
    init();
    int r=sc.nextInt();
    int c=sc.nextInt();
    int a1=sc.nextInt();
    int a2=sc.nextInt();
    int b1=sc.nextInt();
    int b2=sc.nextInt();
    int w1=Math.abs(a1-b1);
    int h1=Math.abs(a2-b2);
    int w2=r-Math.abs(a1-b1);
    int h2=c-Math.abs(a2-b2);
    int w=Math.min(w1,w2);
    int h=Math.min(h1,h2);
    int ans=dp[w+h][w];
    if(w1==w2)ans=ans*2 % p ;
    if(h1==h2)ans=ans*2 % p ;
    System.out.println(ans);
  }
  void init(){
    dp[0][0]=1 ;
    for(int i=1 ; i<1001 ; i++){
      dp[i][0]=1 ;
      for(int j=1 ; j<1001 ; j++){
        dp[i][j]=(dp[i-1][j]+dp[i-1][j-1])% p ;
      }
    }
  }
  public static void main(String[] args)throws Exception {
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute p : int := 100000007;
   attribute dp : Sequence(Sequence(int)) := Integer.subrange(1,1001)->collect(Integer.subrange(1,1001)->collect(0));
   operation run() : void
  pre: true
  post: true
  activity: (     execute init() ; 
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var a1 : int ; a1 := sc.getCurrent()->toInteger() ;
    var a2 : int ; a2 := sc.getCurrent()->toInteger() ;
    var b1 : int ; b1 := sc.getCurrent()->toInteger() ;
    var b2 : int ; b2 := sc.getCurrent()->toInteger() ;
    var w1 : int ; w1 := if a1 - b1 < 0 then -(a1 - b1) else a1 - b1 endif ;
    var h1 : int ; h1 := if a2 - b2 < 0 then -(a2 - b2) else a2 - b2 endif ;
    var w2 : int ; w2 := r - if a1 - b1 < 0 then -(a1 - b1) else a1 - b1 endif ;
    var h2 : int ; h2 := c - if a2 - b2 < 0 then -(a2 - b2) else a2 - b2 endif ;
    var w : int ; w := Set{w1, w2}->min() ;
    var h : int ; h := Set{h1, h2}->min() ;
    var ans : int ; ans := dp[w + h+1][w+1] ;
    if (w1 = w2) then     ans := ans * 2 mod p ; else skip ; 
    if (h1 = h2) then     ans := ans * 2 mod p ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation init() : void
  pre: true
  post: true
  activity: (     dp[0+1][0+1] := 1 ; 
         var i : int ; i := 1 ; while i < 1001 do ( (     dp[i+1][0+1] := 1 ; 
         var j : int ; j := 1 ; while j < 1001 do ( (     dp[i+1][j+1] := (dp[i - 1+1][j+1] + dp[i - 1+1][j - 1+1]) mod p )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findSubsequence(int[] arr,int n,int k){
    HashMap<Integer,Integer>M=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; ++i){
      if(M.containsKey(arr[i]))M.put(arr[i],M.get(arr[i])+1);
      else M.put(arr[i],1);
    }
    int[] numCount=new int[k+1];
    for(int i=0 ; i<=k ; ++i)numCount[i]=0 ;
    Iterator<HashMap.Entry<Integer,Integer>>itr=M.entrySet().iterator();
    while(itr.hasNext()){
      HashMap.Entry<Integer,Integer>entry=itr.next();
      if(entry.getKey()<=k){
        for(int i=1 ; ; ++i){
          if(entry.getKey()*i>k)break ;
          numCount[entry.getKey()*i]+=entry.getValue();
        }
      }
      else break ;
    }
    int lcm=0,length=0 ;
    for(int i=1 ; i<=k ; ++i){
      if(numCount[i]>length){
        length=numCount[i];
        lcm=i ;
      }
    }
    if(lcm==0)System.out.println(-1);
    else {
      System.out.println("LCM="+lcm+" Length="+length);
      System.out.print("Indexes=");
      for(int i=0 ; i<n ; ++i)if(lcm % arr[i]==0)System.out.print(i+" ");
    }
  }
  public static void main(String[] args){
    int k=14 ;
    int arr[]={
      2,3,4,5 };
      int n=arr.length ;
      findSubsequence(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSubsequence( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var M : Map(int,int) ; M := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (M->keys()->includes(arr[i+1])) then     M := M->union(Map{arr[i+1] |-> M->at(arr[i+1]) + 1}) ; else     M := M->union(Map{arr[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
    var numCount : Sequence(int) ; numCount := Integer.subrange(1,k + 1)->collect(0) ;
        var i : int ; i := 0 ; while i <= k do (     numCount[i+1] := 0 ;  ;     i := i + 1 ) ; 
    var itr : OclIterator ; itr := M->asSet()->iterator() ;
    while (itr.hasNext()) do (     var entry : Entry<int,int> ; entry := itr.next() ;
     if (entry.getKey() <= k) then (         var i : int ; i := 1 ; while true do ( (     if (entry.getKey() * i > k) then     break else skip ; 
     numCount[entry.getKey() * i+1] := numCount[entry.getKey() * i+1]+(entry.getValue()) )  ;     i := i + 1 ) ) else     break ) ; 
    var lcm : int ; lcm := 0 ;
    var length : int ; length := 0 ;
        var i : int ; i := 1 ; while i <= k do ( (     if (numCount[i+1] > length) then (     length := numCount[i+1] ; 
     lcm := i ) else skip )  ;     i := i + 1 ) ; 
    if (lcm = 0) then     OclFile["System.out"].println(-1) else (     OclFile["System.out"].println("LCM=" + lcm + " Length=" + length) ; 
     OclFile["System.out"].print("Indexes=") ; 
         var i : int ; i := 0 ; while i < n do (     if (lcm mod arr[i+1] = 0) then     OclFile["System.out"].print(i + " ") ; else skip ;  ;     i := i + 1 ) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 14 ;
     var arr : Sequence(int) ; arr := Sequence{2,3,4,5} ;
     var n : int ; n := arr->size() ;
     execute findSubsequence(arr, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int count_pairs(int a[],int b[],int n,int m){
    int odd1=0,even1=0 ;
    int odd2=0,even2=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i] % 2==1)odd1++;
      else even1++;
    }
    for(int i=0 ; i<m ; i++){
      if(b[i] % 2==1)odd2++;
      else even2++;
    }
    int pairs=Math.min(odd1,odd2)+Math.min(even1,even2);
    return pairs ;
  }
  public static void main(String[] args){
    int a[]={
      9,14,6,2,11 };
      int b[]={
        8,4,7,20 };
        int n=a.length ;
        int m=b.length ;
        System.out.println(count_pairs(a,b,n,m));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count_pairs( a : Sequence(int), b : Sequence(int), n : int, m : int) : int
  pre: true
  post: true
  activity: (     var odd1 : int ; odd1 := 0 ;
    var even1 : int ; even1 := 0 ;
     var odd2 : int ; odd2 := 0 ;
    var even2 : int ; even2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] mod 2 = 1) then     odd1 := odd1 + 1 ; else     even1 := even1 + 1 ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     if (b[i+1] mod 2 = 1) then     odd2 := odd2 + 1 ; else     even2 := even2 + 1 ; )  ;     i := i + 1 ) ; 
    var pairs : int ; pairs := Set{odd1, odd2}->min() + Set{even1, even2}->min() ;
    return pairs 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{9,14,6,2,11} ;
     var b : Sequence(int) ; b := Sequence{8,4,7,20} ;
    var n : int ; n := a->size() ;
    var m : int ; m := b->size() ;
    OclFile["System.out"].println(count_pairs(a, b, n, m)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int count_pairs(int a[],int b[],int n,int m){
    int odd1=0,even1=0 ;
    int odd2=0,even2=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i] % 2==1){
        odd1++;
      }
      else {
        even1++;
      }
    }
    for(int i=0 ; i<m ; i++){
      if(b[i] % 2==1){
        odd2++;
      }
      else {
        even2++;
      }
    }
    int pairs=Math.min(odd1,even2)+Math.min(odd2,even1);
    return pairs ;
  }
  public static void main(String[] args){
    int a[]={
      9,14,6,2,11 };
      int b[]={
        8,4,7,20 };
        int n=a.length ;
        int m=b.length ;
        System.out.println(count_pairs(a,b,n,m));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation count_pairs( a : Sequence(int), b : Sequence(int), n : int, m : int) : int
  pre: true
  post: true
  activity: (     var odd1 : int ; odd1 := 0 ;
    var even1 : int ; even1 := 0 ;
     var odd2 : int ; odd2 := 0 ;
    var even2 : int ; even2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] mod 2 = 1) then (     odd1 := odd1 + 1 ) else (     even1 := even1 + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     if (b[i+1] mod 2 = 1) then (     odd2 := odd2 + 1 ) else (     even2 := even2 + 1 ) )  ;     i := i + 1 ) ; 
    var pairs : int ; pairs := Set{odd1, even2}->min() + Set{odd2, even1}->min() ;
    return pairs 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{9,14,6,2,11} ;
     var b : Sequence(int) ; b := Sequence{8,4,7,20} ;
    var n : int ; n := a->size() ;
    var m : int ; m := b->size() ;
    OclFile["System.out"].println(count_pairs(a, b, n, m)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class MaximumDiffrence {
  int maxDiff(int arr[],int arr_size){
    int max_diff=arr[1]-arr[0];
    int min_element=arr[0];
    int i ;
    for(i=1 ; i<arr_size ; i++){
      if(arr[i]-min_element>max_diff)max_diff=arr[i]-min_element ;
      if(arr[i]<min_element)min_element=arr[i];
    }
    return max_diff ;
  }
  public static void main(String[] args){
    MaximumDiffrence maxdif=new MaximumDiffrence();
    int arr[]={
      1,2,90,10,110 };
      int size=arr.length ;
      System.out.println("MaximumDifference is "+maxdif.maxDiff(arr,size));
    }
  }

------------------------------------------------------------
OCL File:
---------
class MaximumDiffrence {
   operation maxDiff( arr : Sequence(int), arr_size : int) : int
  pre: true
  post: true
  activity: (     var max_diff : int ; max_diff := arr[1+1] - arr[0+1] ;
     var min_element : int ; min_element := arr[0+1] ;
    var i : int ;
        i := 1 ; while i < arr_size do ( (     if (arr[i+1] - min_element > max_diff) then     max_diff := arr[i+1] - min_element ; else skip ; 
     if (arr[i+1] < min_element) then     min_element := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
    return max_diff 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var maxdif : MaximumDiffrence ; maxdif := MaximumDiffrence.newMaximumDiffrence() ;
     var arr : Sequence(int) ; arr := Sequence{1,2,90,10,110} ;
     var size : int ; size := arr->size() ;
     OclFile["System.out"].println("MaximumDifference is " + maxdif.maxDiff(arr, size)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Lever {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    if(scanner.hasNext()){
      String s=scanner.nextLine();
      long count=0 ;
      long mid=s.indexOf("^");
      for(int i=0 ; i<s.length(); i++){
        if(s.charAt(i)!='=' && s.charAt(i)!='^'){
          count+=(s.charAt(i)-'0')*(i-mid);
        }
      }
      if(count==0){
        System.out.println("balance");
      }
      else if(count<0){
        System.out.println("left");
      }
      else {
        System.out.println("right");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Lever {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     if (scanner.hasNext()) then (     var s : String ; s := scanner.nextLine() ;
     var count : long ; count := 0 ;
    var mid : long ; mid := s->indexOf("^")-1 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) /= '=' & s->at(i+1) /= '^') then (     count := count+((s->at(i+1) - ('0')->char2byte()) * (i - mid)) ) else skip )  ;     i := i + 1 ) ; 
    if (count = 0) then (     OclFile["System.out"].println("balance") ) else     if (count < 0) then (     OclFile["System.out"].println("left") ) else (     OclFile["System.out"].println("right") ) ;  ;  
 ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    FastScanner scanner=new FastScanner();
    PrintWriter out=new PrintWriter(System.out,false);
    int n=scanner.nextInt();
    int od=0 ;
    for(int i=1 ; i<=n ; i++){
      if(i % 2==1)od++;
    }
    out.println((double)od/(n));
    out.flush();
  }
  public static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(Reader in){
      br=new BufferedReader(in);
    }
    public FastScanner(){
      this(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 readNextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : FastScanner ; scanner := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"], false) ;
    var n : int ; n := scanner.nextInt() ;
    var od : int ; od := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (i mod 2 = 1) then     od := od + 1 ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(in) );
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation readNextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int binomialCoeff(int n,int k){
    int[][] C=new int[n+1][k+1];
    int i,j ;
    for(i=0 ; i<=n ; i++){
      for(j=0 ; j<=Math.min(i,k); j++){
        if(j==0 || j==i)C[i][j]=1 ;
        else C[i][j]=C[i-1][j-1]+C[i-1][j];
      }
    }
    return C[n][k];
  }
  static int findMax(int n){
    return binomialCoeff(n,n/2);
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(findMax(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation binomialCoeff( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var C : Sequence(Sequence(int)) ; C := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,k + 1)->collect(0)) ;
     var i : int ;
    var j : int ;
         i := 0 ; while i <= n do ( (         j := 0 ; while j <= Set{i, k}->min() do ( (     if (j = 0 or j = i) then     C[i+1][j+1] := 1 ; else     C[i+1][j+1] := C[i - 1+1][j - 1+1] + C[i - 1+1][j+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return C[n+1][k+1] );
  static   operation findMax( n : int) : int
  pre: true
  post: true
  activity: (     return binomialCoeff(n, n / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(findMax(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  final static int MAX=26 ;
  static int max_element(int freq[]){
    int max_ele=freq[0];
    for(int i=0 ; i<MAX ; i++){
      if(max_ele<freq[i])max_ele=freq[i];
    }
    return max_ele ;
  }
  static int minimumAddition(String str,int len){
    int freq[]=new int[MAX];
    for(int i=0 ; i<len ; i++){
      freq[str.charAt(i)-'a']++;
    }
    int maxFreq=max_element(freq);
    int minAddition=0 ;
    for(int i=0 ; i<MAX ; i++){
      if(freq[i]>0){
        minAddition+=Math.abs(maxFreq-freq[i]);
      }
    }
    return minAddition ;
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    int len=str.length();
    System.out.println(minimumAddition(str,len));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 26;
  static   operation max_element( freq : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var max_ele : int ; max_ele := freq[0+1] ;
         var i : int ; i := 0 ; while i < MAX do ( (     if (max_ele < freq[i+1]) then     max_ele := freq[i+1] ; else skip )  ;     i := i + 1 ) ; 
     return max_ele );
  static   operation minimumAddition( str : String, len : int) : int
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,MAX)->collect(0) ;
         var i : int ; i := 0 ; while i < len do ( (     freq[str->at(i+1) - ('a')->char2byte()+1] := freq[str->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    var maxFreq : int ; maxFreq := max_element(freq) ;
    var minAddition : int ; minAddition := 0 ;
        var i : int ; i := 0 ; while i < MAX do ( (     if (freq[i+1] > 0) then (     minAddition := minAddition+(if maxFreq - freq[i+1] < 0 then -(maxFreq - freq[i+1]) else maxFreq - freq[i+1] endif) ) else skip )  ;     i := i + 1 ) ; 
    return minAddition 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var len : int ; len := str->size() ;
     OclFile["System.out"].println(minimumAddition(str, len)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
class MinStack {
  private Stack<Integer>stack ;
  private Stack<Integer>minStack ;
  public MinStack(){
    stack=new Stack<>();
    minStack=new Stack<>();
  }
  public void push(int x){
    stack.push(x);
    if(minStack.size()==0 || x<=minStack.peek())minStack.push(x);
    else minStack.push(minStack.peek());
  }
  public void pop(){
    stack.pop();
    minStack.pop();
  }
  public int top(){
    return stack.peek();
  }
  public int getMin(){
    return minStack.peek();
  }
}
------------------------------------------------------------
OCL File:
---------
 class MinStack {
   attribute stack : Sequence(int);
   attribute minStack : Sequence(int);
   static operation newMinStack() : MinStack
  pre: true
  post: true
  activity:
  ( var self : MinStack ;
    self := createMinStack();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     stack := Sequence{} ; 
     minStack := Sequence{} );
   operation push( x : int) : void
  pre: true
  post: true
  activity: (     stack := stack->append(x) ; 
     if (minStack->size() = 0 or x <= minStack->min()) then     minStack := minStack->append(x) ; else     minStack := minStack->append(minStack->min()) ; );
   operation pop() : void
  pre: true
  post: true
  activity: (     stack := stack->front() ; 
     minStack := minStack->front() );
   operation top() : int
  pre: true
  post: true
  activity: (     return stack->min() );
   operation getMin() : int
  pre: true
  post: true
  activity: (     return minStack->min() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test195 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    char a[]=in.next().toCharArray();
    char b[]=in.next().toCharArray();
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(Math.abs(a[i]-b[i])>5){
        sum+=10-Math.abs(a[i]-b[i]);
      }
      else {
        sum+=Math.abs(a[i]-b[i]);
      }
    }
    System.out.println(sum);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test195 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(String) ; a := in.getCurrent()->characters() ;
    var b : Sequence(String) ; b := in.getCurrent()->characters() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (if a[i+1] - b[i+1] < 0 then -(a[i+1] - b[i+1]) else a[i+1] - b[i+1] endif > 5) then (     sum := sum+(10 - if a[i+1] - b[i+1] < 0 then -(a[i+1] - b[i+1]) else a[i+1] - b[i+1] endif) ) else (     sum := sum+(if a[i+1] - b[i+1] < 0 then -(a[i+1] - b[i+1]) else a[i+1] - b[i+1] endif) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Lock {
  int sizeNumber ;
  List<Integer>list=new ArrayList<>();
  public Lock(int sizeNumber){
    this.sizeNumber=sizeNumber ;
  }
  public int awayOne(char c1,char c2){
    int num1=0 ;
    int num2=0 ;
    if(c1>'5'){
      num1=10-c1 ;
      num2=c2 ;
    }
    else {
      num1=c1-0 ;
      num2=10-c2 ;
    }
    return num1+num2 ;
  }
  public int awayTwo(char c1,char c2){
    int num=c1-c2 ;
    if(num<0){
      num*=-1 ;
    }
    return num ;
  }
  public int getSizeNumber(){
    return sizeNumber ;
  }
  public void input(String sOne,String sTwo){
    int count=0 ;
    for(int i=0 ; i<getSizeNumber(); i++){
      if(awayOne(sOne.charAt(i),sTwo.charAt(i))<awayTwo(sOne.charAt(i),sTwo.charAt(i))){
        count+=awayOne(sOne.charAt(i),sTwo.charAt(i));
      }
      else {
        count+=awayTwo(sOne.charAt(i),sTwo.charAt(i));
      }
    }
    System.out.println(count);
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int num=input.nextInt();
    Lock instance=new Lock(num);
    String sOne=input.next();
    String sTwo=input.next();
    instance.input(sOne,sTwo);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Lock {
   attribute sizeNumber : int;
   attribute list : Sequence(int) := Sequence{};
   static operation newLock( sizeNumber : int) : Lock
  pre: true
  post: true
  activity:
  ( var self : Lock ;
    self := createLock();
    self.initialise(sizeNumber);
    return self );
  operation initialise( sizeNumber : int) : void
  pre: true  post: true
  activity: (     self.sizeNumber := sizeNumber );
   operation awayOne( c1 : String, c2 : String) : int
  pre: true
  post: true
  activity: (     var num1 : int ; num1 := 0 ;
     var num2 : int ; num2 := 0 ;
     if (c1 > '5') then (     num1 := 10 - c1 ; 
     num2 := c2 ) else (     num1 := c1 - 0 ; 
     num2 := 10 - c2 ) ;  
     return num1 + num2 );
   operation awayTwo( c1 : String, c2 : String) : int
  pre: true
  post: true
  activity: (     var num : int ; num := c1 - c2 ;
     if (num < 0) then (     num := num*(-1) ) else skip ; 
     return num );
   operation getSizeNumber() : int
  pre: true
  post: true
  activity: (     return sizeNumber );
   operation input( sOne : String, sTwo : String) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < getSizeNumber() do ( (     if (awayOne(sOne->at(i+1), sTwo->at(i+1)) < awayTwo(sOne->at(i+1), sTwo->at(i+1))) then (     count := count+(awayOne(sOne->at(i+1), sTwo->at(i+1))) ) else (     count := count+(awayTwo(sOne->at(i+1), sTwo->at(i+1))) ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := input.getCurrent()->toInteger() ;
    var instance : Lock ; instance := Lock.newLock(num) ;
    var sOne : String ; sOne := input.getCurrent() ;
    var sTwo : String ; sTwo := input.getCurrent() ;
    instance.input(sOne, sTwo) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class _540A_CombinationLock {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int amount=Integer.parseInt(input.nextLine());
    String first=input.nextLine();
    String second=input.nextLine();
    int result=0 ;
    for(int i=0 ; i<amount ; i++){
      int current=first.charAt(i)-'0' ;
      int key=second.charAt(i)-'0' ;
      int move=Math.abs(key-current);
      result+=Math.min(move,10-move);
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _540A_CombinationLock {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var amount : int ; amount := (input.nextLine())->toInteger() ;
    var first : String ; first := input.nextLine() ;
    var second : String ; second := input.nextLine() ;
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < amount do ( (     var current : int ; current := first->at(i+1) - ('0')->char2byte() ;
     var key : int ; key := second->at(i+1) - ('0')->char2byte() ;
     var move : int ; move := if key - current < 0 then -(key - current) else key - current endif ;
     result := result+(Set{move, 10 - move}->min()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    int n=nextInt();
    String s=nextToken();
    String s1=nextToken();
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      char a=s.charAt(i);
      char b=s1.charAt(i);
      if(Math.abs(b-a)==9){
        ans+=1 ;
      }
      else {
        int x=Math.abs(b-a);
        int y=10-Math.max(a,b)+Math.min(a,b);
        ans+=Math.min(x,y);
      }
    }
    System.out.println(ans);
  }
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter out=new PrintWriter(System.out);
  static StringTokenizer in=new StringTokenizer("");
  public static String nextToken()throws IOException {
    while(in==null || ! in.hasMoreTokens()){
      in=new StringTokenizer(br.readLine());
    }
    return in.nextToken();
  }
  public static int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public static double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  public static long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var s : String ; s := nextToken() ;
    var s1 : String ; s1 := nextToken() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : String ; a := s->at(i+1) ;
     var b : String ; b := s1->at(i+1) ;
     if (if (b)->char2byte() - (a)->char2byte() < 0 then -((b)->char2byte() - (a)->char2byte()) else (b)->char2byte() - (a)->char2byte() endif = 9) then (     ans := ans+(1) ) else (     var x : int ; x := if (b)->char2byte() - (a)->char2byte() < 0 then -((b)->char2byte() - (a)->char2byte()) else (b)->char2byte() - (a)->char2byte() endif ;
     var y : int ; y := 10 - Set{a, b}->max() + Set{a, b}->min() ;
     ans := ans+(Set{x, y}->min()) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclIterator := OclIterator.newOclIterator_String("");
  static   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (in = null or not(in.hasNext())) do (     in := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return in.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    String str=sc.next();
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      int c=Character.getNumericValue(s.charAt(i));
      int d=Character.getNumericValue(str.charAt(i));
      if(Math.abs(c-d)<=5){
        sum=sum+Math.abs(c-d);
      }
      else {
        if(c>d){
          sum=sum+(10-c)+d ;
        }
        else {
          sum=sum+(10-d)+c ;
        }
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var str : String ; str := sc.getCurrent() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var c : int ; c := ("" + s->at(i+1))->toInteger() ;
     var d : int ; d := ("" + str->at(i+1))->toInteger() ;
     if (if c - d < 0 then -(c - d) else c - d endif <= 5) then (     sum := sum + if c - d < 0 then -(c - d) else c - d endif ) else (     if (c > d) then (     sum := sum + (10 - c) + d ) else (     sum := sum + (10 - d) + c ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int MAX=32 ;
  static long[] pow2=new long[MAX];
  static boolean[] visited=new boolean[MAX];
  static Vector<Long>ans=new Vector<>();
  static void power_2(){
    long ans=1 ;
    for(int i=0 ; i<MAX ; i++){
      pow2[i]=ans ;
      ans*=2 ;
    }
  }
  static int countSetBits(long x){
    int setBits=0 ;
    while(x!=0){
      x=x &(x-1);
      setBits++;
    }
    return setBits ;
  }
  static void add(long num){
    int point=0 ;
    long value=0 ;
    for(int i=0 ; i<MAX ; i++){
      if(visited[i])continue ;
      else {
        if(num % 2==1){
          value+=(1<<i);
        }
        num/=2 ;
      }
    }
    ans.add(value);
  }
  static void solve(long n,long k){
    ans.add(k);
    int countk=countSetBits(k);
    if(pow2[countk]<n){
      System.out.print(-1);
      return ;
    }
    int count=0 ;
    for(long i=0 ; i<pow2[countk]-1 ; i++){
      add(i);
      count++;
      if(count==n)break ;
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(ans.get(i)+" ");
    }
  }
  public static void main(String[] args){
    long n=3,k=5 ;
    power_2();
    solve(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX : int := 32;
  static   attribute pow2 : Sequence(long) := Integer.subrange(1,MAX)->collect(0);
  static   attribute visited : Sequence(boolean) := Integer.subrange(1,MAX)->collect(false);
  static   attribute ans : Sequence(long) := Sequence{};
  static   operation power_2() : void
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
         var i : int ; i := 0 ; while i < MAX do ( (     pow2[i+1] := ans ; 
     ans := ans*(2) )  ;     i := i + 1 ) );
  static   operation countSetBits( x : long) : int
  pre: true
  post: true
  activity: (     var setBits : int ; setBits := 0 ;
     while (x /= 0) do (     x := x & (x - 1) ; 
     setBits := setBits + 1 ) ; 
     return setBits );
  static   operation add( num : long) : void
  pre: true
  post: true
  activity: (     var point : int ; point := 0 ;
     var value : long ; value := 0 ;
         var i : int ; i := 0 ; while i < MAX do ( (     if (visited[i+1]) then     continue else (     if (num mod 2 = 1) then (     value := value+(((1*(2->pow(i)))->oclAsType(long))) ) else skip ; 
     num := num/(2) ) )  ;     i := i + 1 ) ; 
     ans->excludes(value) );
  static   operation solve( n : long, k : long) : void
  pre: true
  post: true
  activity: (     ans->excludes(k) ; 
     var countk : int ; countk := countSetBits(k) ;
    if (pow2[countk+1] < n) then (     OclFile["System.out"].print(-1) ; 
     return ) else skip ; 
    var count : int ; count := 0 ;
        var i : long ; i := 0 ; while i < pow2[countk+1] - 1 do ( (     execute add(i) ; 
     count := count + 1 ; 
     if (count = n) then     break else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(ans->at(i+1) + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 3 ;
    var k : long ; k := 5 ;
     execute power_2() ; 
     execute solve(n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p027 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p027().run());
  }
  public String run(){
    int bestNum=0 ;
    int bestA=0 ;
    int bestB=0 ;
    for(int a=-1000 ; a<=1000 ; a++){
      for(int b=-1000 ; b<=1000 ; b++){
        int num=numberOfConsecutivePrimesGenerated(a,b);
        if(num>bestNum){
          bestNum=num ;
          bestA=a ;
          bestB=b ;
        }
      }
    }
    return Integer.toString(bestA*bestB);
  }
  private static int numberOfConsecutivePrimesGenerated(int a,int b){
    for(int i=0 ; ; i++){
      int n=i*i+i*a+b ;
      if(n<0 || ! Library.isPrime(n))return i ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class p027 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p027.newp027().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var bestNum : int ; bestNum := 0 ;
     var bestA : int ; bestA := 0 ;
    var bestB : int ; bestB := 0 ;
        var a : int ; a := -1000 ; while a <= 1000 do ( (         var b : int ; b := -1000 ; while b <= 1000 do ( (     var num : int ; num := numberOfConsecutivePrimesGenerated(a, b) ;
     if (num > bestNum) then (     bestNum := num ; 
     bestA := a ; 
     bestB := b ) else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    return ((bestA * bestB) + "") 
 );
  static   operation numberOfConsecutivePrimesGenerated( a : int, b : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while true do ( (     var n : int ; n := i * i + i * a + b ;
     if (n < 0 or not(Library.isPrime(n))) then     return i else skip )  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigDecimal ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    double odds=0 ;
    if(num % 2==0){
      odds=(double)0.5 ;
    }
    else {
      int numHalf=(num/2)+1 ;
      odds=(double)numHalf/num ;
    }
    System.out.println(odds);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
    var odds : double ; odds := 0 ;
    if (num mod 2 = 0) then (     odds := 0.5->oclAsType(double) ) else (     var numHalf : int ; numHalf := (num / 2) + 1 ;
     odds := numHalf->oclAsType(double) / num ) ;  
    OclFile["System.out"].println(odds) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.util.*;
import static java.lang.System.out ;
import static java.lang.Math.*;
public class pre149 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int tc=obj.nextInt();
    while(tc--!=0){
      long n=obj.nextInt(),k=obj.nextInt();
      if(n>k){
        out.println((k*(k+1))/2);
      }
      else {
        n--;
        n=(n*(n+1))/2 ;
        n++;
        out.println(n);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre149 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var tc : int ; tc := obj.nextInt() ;
         while (tc /= 0) do (    skip ; (     var n : long ; n := obj.nextInt() ;
    var k : long ; k := obj.nextInt() ;
     if (n > k) then (     out.println((k * (k + 1)) / 2) ) else (     n := n - 1 ; 
     n := (n * (n + 1)) / 2 ; 
     n := n + 1 ; 
     out.println(n) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigDecimal ;
import java.math.BigInteger ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    int t=in.nextInt();
    while(t-->0){
      long n=in.nextLong();
      long r=in.nextLong();
      long sum=0 ;
      if(n<=r){
        sum+=(1+n-1)*(n-1)/2+1 ;
      }
      else {
        sum+=(1+r)*r/2 ;
      }
      System.out.println(sum);
    }
  }
  static InputStream inputStream=System.in ;
  static InputReader in=new InputReader(inputStream);
  static PrintWriter out=new PrintWriter(System.out);
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    boolean hasNext(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(Exception e){
          return false ;
        }
      }
      return true ;
    }
    public String nextLine(){
      String str=null ;
      try {
        str=reader.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public Double nextDouble(){
      return Double.parseDouble(next());
    }
    public BigInteger nextBigInteger(){
      return new BigInteger(next());
    }
    public BigDecimal nextBigDecimal(){
      return new BigDecimal(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := in.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := in.nextLong() ;
     var r : long ; r := in.nextLong() ;
    var sum : long ; sum := 0 ;
    if (n <= r) then (     sum := sum+((1 + n - 1) * (n - 1) / 2 + 1) ) else (     sum := sum+((1 + r) * r / 2) ) ;  
    OclFile["System.out"].println(sum) ; 
 ) ;  ) );
  static   attribute inputStream : OclFile := OclFile["System.in"];
  static   attribute in : InputReader := InputReader.newInputReader(inputStream);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : ProgramException) do (     return false )
 ) ; 
     return true );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := null ;
     try (     str := reader.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextBigInteger() : long
  pre: true
  post: true
  activity: (     return long(next()) );
   operation nextBigDecimal() : double
  pre: true
  post: true
  activity: (     return double(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class code {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int t=sc.nextInt();
    while(t-->0){
      solve();
    }
  }
  static void solve(){
    long n=sc.nextInt();
    long r=sc.nextInt();
    long ans2 ;
    if(n>r){
      ans2=(r*(r+1))/2 ;
    }
    else {
      ans2=(n*(n-1))/2 ;
      ans2+=1 ;
    }
    System.out.println((ans2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class code {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.getCurrent()->toInteger() ;
     var r : long ; r := sc.getCurrent()->toInteger() ;
    var ans2 : long ;
    if (n > r) then (     ans2 := (r * (r + 1)) / 2 ) else (     ans2 := (n * (n - 1)) / 2 ; 
     ans2 := ans2+(1) ) ;  
    OclFile["System.out"].println((ans2)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String one[]={
    "","one ","two ","three ","four ","five ","six ","seven ","eight ","nine ","ten ","eleven ","twelve ","thirteen ","fourteen ","fifteen ","sixteen ","seventeen ","eighteen ","nineteen " };
    static String ten[]={
      "","","twenty ","thirty ","forty ","fifty ","sixty ","seventy ","eighty ","ninety " };
      static String numToWords(int n,String s){
        String str="" ;
        if(n>19){
          str+=ten[n/10]+one[n % 10];
        }
        else {
          str+=one[n];
        }
        if(n!=0){
          str+=s ;
        }
        return str ;
      }
      static String convertToWords(long n){
        String out="" ;
        out+=numToWords((int)(n/10000000),"crore ");
        out+=numToWords((int)((n/100000)% 100),"lakh ");
        out+=numToWords((int)((n/1000)% 100),"thousand ");
        out+=numToWords((int)((n/100)% 10),"hundred ");
        if(n>100 && n % 100>0){
          out+="and " ;
        }
        out+=numToWords((int)(n % 100),"");
        return out ;
      }
      public static void main(String[] args){
        long n=438237764 ;
        System.out.printf(convertToWords(n));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute one : String := Sequence{"","one ","two ","three ","four ","five ","six ","seven ","eight ","nine ","ten ","eleven ","twelve ","thirteen ","fourteen ","fifteen ","sixteen ","seventeen ","eighteen ","nineteen "};
  static   attribute ten : String := Sequence{"","","twenty ","thirty ","forty ","fifty ","sixty ","seventy ","eighty ","ninety "};
  static   operation numToWords( n : int, s : String) : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     if (n > 19) then (     str := str+(ten[n / 10+1] + one[n mod 10+1]) ) else (     str := str+(one[n+1]) ) ;  
     if (n /= 0) then (     str := str+(s) ) else skip ; 
     return str );
  static   operation convertToWords( n : long) : String
  pre: true
  post: true
  activity: (     var out : String ; out := "" ;
     out := out+(numToWords((n / 10000000)->oclAsType(int), "crore ")) ; 
    out := out+(numToWords(((n / 100000) mod 100)->oclAsType(int), "lakh ")) ; 
    out := out+(numToWords(((n / 1000) mod 100)->oclAsType(int), "thousand ")) ; 
    out := out+(numToWords(((n / 100) mod 10)->oclAsType(int), "hundred ")) ; 
    if (n > 100 & n mod 100 > 0) then (     out := out+("and ") ) else skip ; 
    out := out+(numToWords((n mod 100)->oclAsType(int), "")) ; 
    return out 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 438237764 ;
     OclFile["System.out"].printf(convertToWords(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAX=100001 ;
  static int[] isPrime=new int[MAX];
  static int sieve(){
    for(int p=2 ; p*p<MAX ; p++){
      if(isPrime[p]==0){
        for(int i=p*2 ; i<MAX ; i+=p)isPrime[i]=1 ;
      }
    }
    return-1 ;
  }
  static int findSubset(int[] a,int n){
    int cnt1=0 ;
    for(int i=0 ; i<n ; i++)if(a[i]==1)cnt1++;
    if(cnt1>0){
      for(int i=0 ; i<n ; i++){
        if((a[i]!=1)&&(isPrime[a[i]+1]==0)){
          System.out.println(cnt1+1);
          for(int j=0 ; j<cnt1 ; j++)System.out.print(1+" ");
          System.out.println(a[i]);
          return 0 ;
        }
      }
    }
    if(cnt1>=2){
      System.out.println(cnt1);
      for(int i=0 ; i<cnt1 ; i++)System.out.print(1+" ");
      System.out.println();
      return 0 ;
    }
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        if(isPrime[a[i]+a[j] ]==0){
          System.out.println(2);
          System.out.println(a[i]+" "+a[j]);
          return 0 ;
        }
      }
    }
    System.out.println(-1);
    return-1 ;
  }
  public static void main(String args[]){
    sieve();
    int[] A=new int[] {
      2,1,1 };
      int n=A.length ;
      findSubset(A,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100001;
  static   attribute isPrime : Sequence(int) := Integer.subrange(1,MAX)->collect(0);
  static   operation sieve() : int
  pre: true
  post: true
  activity: (         var p : int ; p := 2 ; while p * p < MAX do ( (     if (isPrime[p+1] = 0) then (         var i : int ; i := p * 2 ; while i < MAX do (     isPrime[i+1] := 1 ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
     return -1 );
  static   operation findSubset( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var cnt1 : int ; cnt1 := 0 ;
         var i : int ; i := 0 ; while i < n do (     if (a[i+1] = 1) then     cnt1 := cnt1 + 1 ; else skip ;  ;     i := i + 1 ) ; 
    if (cnt1 > 0) then (         var i : int ; i := 0 ; while i < n do ( (     if ((a[i+1] /= 1) & (isPrime[a[i+1] + 1+1] = 0)) then (     OclFile["System.out"].println(cnt1 + 1) ; 
         var j : int ; j := 0 ; while j < cnt1 do (     OclFile["System.out"].print(1 + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(a[i+1]) ; 
     return 0 ) else skip )  ;     i := i + 1 ) ) else skip ; 
    if (cnt1 >= 2) then (     OclFile["System.out"].println(cnt1) ; 
         var i : int ; i := 0 ; while i < cnt1 do (     OclFile["System.out"].print(1 + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ; 
     return 0 ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (isPrime[a[i+1] + a[j+1]+1] = 0) then (     OclFile["System.out"].println(2) ; 
     OclFile["System.out"].println(a[i+1] + " " + a[j+1]) ; 
     return 0 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute sieve() ; 
     var A : Sequence(int) ; A := Sequence{2,1,1} ;
     var n : int ; n := A->size() ;
     execute findSubset(A, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n,r,t,sum,pos ;
    n=scan.nextInt();
    r=scan.nextInt();
    t=scan.nextInt();
    sum=0 ;
    int[] p=new int[n];
    int[] water=new int[r];
    int[] empty=new int[r];
    for(int i=0 ; i<n ; i++){
      p[i]=scan.nextInt();
    }
    for(int i=1 ; i<=t ; i++){
      for(int j=0 ; j<n ; j++){
        pos=(p[j]*i % r);
        if(i>1){
          empty[pos]++;
        }
        if(water[pos]>0){
          water[pos]--;
        }
        else {
          sum++;
        }
      }
      for(int j=0 ; j<r ; j++){
        if(empty[j]>0){
          water[j]+=empty[j];
          empty[j]=0 ;
        }
      }
    }
    System.out.println(sum);
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var r : int ;
    var t : int ;
    var sum : int ;
    var pos : int ;
    n := scan.getCurrent()->toInteger() ; 
    r := scan.getCurrent()->toInteger() ; 
    t := scan.getCurrent()->toInteger() ; 
    sum := 0 ; 
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    var water : Sequence(int) ; water := Integer.subrange(1,r)->collect(0) ;
    var empty : Sequence(int) ; empty := Integer.subrange(1,r)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= t do ( (         var j : int ; j := 0 ; while j < n do ( (     pos := (p[j+1] * i mod r) ; 
     if (i > 1) then (     empty[pos+1] := empty[pos+1] + 1 ) else skip ; 
     if (water[pos+1] > 0) then (     water[pos+1] := water[pos+1] - 1 ) else (     sum := sum + 1 ) )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < r do ( (     if (empty[j+1] > 0) then (     water[j+1] := water[j+1]+(empty[j+1]) ; 
     empty[j+1] := 0 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    s.nextLine();
    for(int j=0 ; j<n ; j++){
      char c[]=s.nextLine().toCharArray();
      for(int i=0 ; i<c.length-6 ; i++){
        if(c[i]=='H' && c[i+1]=='o' && c[i+2]=='s' && c[i+3]=='h' && c[i+4]=='i' && c[i+5]=='n' && c[i+6]=='o'){
          c[i+6]='a' ;
          i+=6 ;
        }
      }
      System.out.println(new String(c));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
     skip ; 
         var j : int ; j := 0 ; while j < n do ( (     var c : Sequence(String) ; c := s.nextLine()->characters() ;
         var i : int ; i := 0 ; while i < c->size() - 6 do ( (     if (c[i+1] = 'H' & c[i + 1+1] = 'o' & c[i + 2+1] = 's' & c[i + 3+1] = 'h' & c[i + 4+1] = 'i' & c[i + 5+1] = 'n' & c[i + 6+1] = 'o') then (     c[i + 6+1] := 'a' ; 
     i := i+(6) ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(StringLib.newString(c)) )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int N=Integer.parseInt(br.readLine());
    String Hoshina="Hoshina" ;
    String Hoshino="Hoshino" ;
    while(N--!=0){
      String ans="" ;
      String s=br.readLine();
      for(int i=0 ; i<s.length(); i++){
        if(s.length()-i-1>=Hoshino.length()-1 && Hoshino.equals(s.substring(i,i+Hoshino.length()))){
          ans+=Hoshina ;
          i+=Hoshino.length()-1 ;
        }
        else {
          ans+=s.charAt(i);
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var N : int ; N := (br.readLine())->toInteger() ;
    var Hoshina : String ; Hoshina := "Hoshina" ;
    var Hoshino : String ; Hoshino := "Hoshino" ;
        while (N /= 0) do (    skip ; (     var ans : String ; ans := "" ;
     var s : String ; s := br.readLine() ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->size() - (i)->char2byte() - 1 >= Hoshino->size() - 1 & Hoshino = s.subrange(i+1,i + Hoshino->size())) then (     ans := ans+(Hoshina) ; 
     i := i+(Hoshino->size() - 1) ) else (     ans := ans+(s->at(i+1)) ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    int t=sc.nextInt();
    sc.nextLine();
    while(t-->0){
      String line=sc.nextLine();
      System.out.println(line.replaceAll("Hoshino","Hoshina"));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
     skip ; 
         while (t > 0) do (        t := t - 1 ;     skip ; (     var line : String ; line := sc.nextLine() ;
     OclFile["System.out"].println(line.replaceAllMatches("Hoshino", "Hoshina" )) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
import java.util.*;
import static java.lang.System.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int min(int...ar){
    Arrays.sort(ar);
    return ar[0];
  }
  static int max(int...ar){
    Arrays.sort(ar);
    return ar[ar.length-1];
  }
  public static void main(String[] args){
    int n=sc.nextInt();
    sc.nextLine();
    for(int i=0 ; i<n ; i++){
      out.println(sc.nextLine().replace("Hoshino","Hoshina"));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation min( ar : Sequence(int)) : int
  pre: true
  post: true
  activity: (     ar := ar->sort() ; 
     return ar[0+1] );
  static   operation max( ar : Sequence(int)) : int
  pre: true
  post: true
  activity: (     ar := ar->sort() ; 
     return ar[ar->size() - 1+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     skip ; 
         var i : int ; i := 0 ; while i < n do ( (     out.println(sc.nextLine().replace("Hoshino", "Hoshina")) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileNotFoundException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    sc.close();
    int numE=(N+1)/2 ;
    float p=(float)numE/N ;
    System.out.printf("%.7f",p);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    skip ; 
    var numE : int ; numE := (N + 1) / 2 ;
    var p : double ; p := numE->oclAsType(double) / N ;
    OclFile["System.out"].printf("%.7f", p) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static void solve(){
    int n=in.nextInt();
    in.nextLine();
    while(n-->0){
      out.println(in.nextLine().replaceAll("Hoshino","Hoshina"));
    }
  }
  public static void main(String[] args){
    long start=System.currentTimeMillis();
    solve();
    out.flush();
    long end=System.currentTimeMillis();
    in.close();
    out.close();
  }
  static void trace(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     skip ; 
         while (n > 0) do (        n := n - 1 ;     skip ; (     skip ) ;  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : long ; start := OclDate.getSystemTime() ;
     execute solve() ; 
    skip ; 
    var end : long ; end := OclDate.getSystemTime() ;
    skip ; 
    skip ; 
 );
  static   operation trace( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class BinarySearch {
  static int countRotations(int arr[],int low,int high){
    if(high<low)return 0 ;
    if(high==low)return low ;
    int mid=low+(high-low)/2 ;
    if(mid<high && arr[mid+1]<arr[mid])return(mid+1);
    if(mid>low && arr[mid]<arr[mid-1])return mid ;
    if(arr[high]>arr[mid])return countRotations(arr,low,mid-1);
    return countRotations(arr,mid+1,high);
  }
  public static void main(String[] args){
    int arr[]={
      15,18,2,3,6,12 };
      int n=arr.length ;
      System.out.println(countRotations(arr,0,n-1));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class BinarySearch {
  static   operation countRotations( arr : Sequence(int), low : int, high : int) : int
  pre: true
  post: true
  activity: (     if (high < low) then     return 0 else skip ; 
     if (high = low) then     return low else skip ; 
    var mid : int ; mid := low + (high - low) / 2 ;
    if (mid < high & arr[mid + 1+1] < arr[mid+1]) then     return (mid + 1) else skip ; 
    if (mid > low & arr[mid+1] < arr[mid - 1+1]) then     return mid else skip ; 
    if (arr[high+1] > arr[mid+1]) then     return countRotations(arr, low, mid - 1) else skip ; 
    return countRotations(arr, mid + 1, high) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{15,18,2,3,6,12} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countRotations(arr, 0, n - 1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int k=scn.nextInt();
    int i=1,req=1 ;
    while(k-req>=0){
      if(k-req>=0){
        k=k-req ;
      }
      else {
        break ;
      }
      i++;
      if(i % n!=0)req=i % n ;
      else req=n ;
    }
    System.out.println(k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var k : int ; k := scn.getCurrent()->toInteger() ;
    var i : int ; i := 1 ;
    var req : int ; req := 1 ;
    while (k - req >= 0) do (     if (k - req >= 0) then (     k := k - req ) else (     break ) ;  
     i := i + 1 ; 
     if (i mod n /= 0) then     req := i mod n ; else     req := n ; ) ; 
    OclFile["System.out"].println(k) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    m %=n*(n+1)/2 ;
    for(int i=1 ; i<n+1 ; i++){
      if(m>=i)m-=i ;
    }
    System.out.println(m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    m := m mod n * (n + 1) / 2 ; 
        var i : int ; i := 1 ; while i < n + 1 do ( (     if (m >= i) then     m := m-(i) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int flipSign(int a){
    int neg=0 ;
    int tmp=a<0 ? 1 :-1 ;
    while(a!=0){
      neg+=tmp ;
      a+=tmp ;
    }
    return neg ;
  }
  static boolean areDifferentSign(int a,int b){
    return((a<0 && b>0)||(a>0 && b<0));
  }
  static int sub(int a,int b){
    return a+flipSign(b);
  }
  static int mul(int a,int b){
    if(a<b)return mul(b,a);
    int sum=0 ;
    for(int i=Math.abs(b); i>0 ; i--)sum+=a ;
    if(b<0)sum=flipSign(sum);
    return sum ;
  }
  static int division(int a,int b){
    if(b==0)throw new ArithmeticException();
    int quotient=0,dividend ;
    int divisor=flipSign(Math.abs(b));
    for(dividend=Math.abs(a); dividend>=Math.abs(divisor); dividend+=divisor)quotient++;
    if(areDifferentSign(a,b))quotient=flipSign(quotient);
    return quotient ;
  }
  public static void main(String[] args){
    System.out.println("Subtraction is "+sub(4,-2));
    System.out.println("Product is "+mul(-9,6));
    try {
      System.out.println("Division is "+division(8,2));
    }
    catch(ArithmeticException e){
      System.out.println("Exception :-Divide by 0");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation flipSign( a : int) : int
  pre: true
  post: true
  activity: (     var neg : int ; neg := 0 ;
     var tmp : int ; tmp := if a < 0 then 1 else -1 endif ;
     while (a /= 0) do (     neg := neg+(tmp) ; 
     a := a+(tmp) ) ; 
     return neg );
  static   operation areDifferentSign( a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     return ((a < 0 & b > 0) or (a > 0 & b < 0)) );
  static   operation sub( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return a + flipSign(b) );
  static   operation mul( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a < b) then     return mul(b, a) else skip ; 
     var sum : int ; sum := 0 ;
        var i : int ; i := if b < 0 then -(b) else b endif ; while i > 0 do (     sum := sum+(a) ;  ;     i := i - 1 ) ; 
    if (b < 0) then     sum := flipSign(sum) ; else skip ; 
    return sum 
 );
  static   operation division( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     error ArithmeticException() ; else skip ; 
     var quotient : int ; quotient := 0 ;
    var dividend : int ;
    var divisor : int ; divisor := flipSign(if b < 0 then -(b) else b endif) ;
        dividend := if a < 0 then -(a) else a endif ; while dividend >= if divisor < 0 then -(divisor) else divisor endif do (     quotient := quotient + 1 ;  ;     dividend := dividend+(divisor) ) ; 
    if (areDifferentSign(a, b)) then     quotient := flipSign(quotient) ; else skip ; 
    return quotient 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Subtraction is " + sub(4, -2)) ; 
     OclFile["System.out"].println("Product is " + mul(-9, 6)) ; 
     try (     OclFile["System.out"].println("Division is " + division(8, 2)) )   catch (e : ArithmeticException) do (     OclFile["System.out"].println("Exception :-Divide by 0") )
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt()%(n*(n+1)/2);
    int k=(int)((-1.0+Math.sqrt(8*m+1))/2);
    System.out.println(m-k*(k+1)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() mod (n * (n + 1) / 2) ;
    var k : int ; k := ((-1.0 + (8 * m + 1)->sqrt()) / 2)->oclAsType(int) ;
    OclFile["System.out"].println(m - k * (k + 1) / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Chips {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int num=scan.nextInt();
    int chips=scan.nextInt();
    boolean done=false ;
    while(true){
      for(int i=1 ; i<=num ; i++){
        if(chips-i>=0){
          chips-=i ;
        }
        else {
          done=true ;
          break ;
        }
      }
      if(done==true)break ;
    }
    System.out.println(chips);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Chips {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := scan.getCurrent()->toInteger() ;
    var chips : int ; chips := scan.getCurrent()->toInteger() ;
    var done : boolean ; done := false ;
    while (true) do (         var i : int ; i := 1 ; while i <= num do ( (     if (chips - i >= 0) then (     chips := chips-(i) ) else (     done := true ; 
     break ) )  ;     i := i + 1 ) ; 
     if (done = true) then     break else skip ) ; 
    OclFile["System.out"].println(chips) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static boolean modularSum(int arr[],int n,int m){
    if(n>m)return true ;
    boolean DP[]=new boolean[m];
    Arrays.fill(DP,false);
    for(int i=0 ; i<n ; i++){
      if(DP[0])return true ;
      boolean temp[]=new boolean[m];
      Arrays.fill(temp,false);
      for(int j=0 ; j<m ; j++){
        if(DP[j]==true){
          if(DP[(j+arr[i])% m]==false)temp[(j+arr[i])% m]=true ;
        }
      }
      for(int j=0 ; j<m ; j++)if(temp[j])DP[j]=true ;
      DP[arr[i] % m]=true ;
    }
    return DP[0];
  }
  public static void main(String arg[]){
    int arr[]={
      1,7 };
      int n=arr.length ;
      int m=5 ;
      if(modularSum(arr,n,m))System.out.print("YES\n");
      else System.out.print("NO\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation modularSum( arr : Sequence(int), n : int, m : int) : boolean
  pre: true
  post: true
  activity: (     if (n > m) then     return true else skip ; 
     var DP : Sequence(boolean) ; DP := Integer.subrange(1,m)->collect(false) ;
    DP := DP->collect(false) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (DP[0+1]) then     return true else skip ; 
     var temp : Sequence(boolean) ; temp := Integer.subrange(1,m)->collect(false) ;
    temp := temp->collect(false) ; 
        var j : int ; j := 0 ; while j < m do ( (     if (DP[j+1] = true) then (     if (DP[(j + arr[i+1]) mod m+1] = false) then     temp[(j + arr[i+1]) mod m+1] := true ; else skip ) else skip )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < m do (     if (temp[j+1]) then     DP[j+1] := true ; else skip ;  ;     j := j + 1 ) ; 
    DP[arr[i+1] mod m+1] := true ; 
 )  ;     i := i + 1 ) ; 
    return DP[0+1] 
 );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,7} ;
     var n : int ; n := arr->size() ;
     var m : int ; m := 5 ;
     if (modularSum(arr, n, m)) then     OclFile["System.out"].print("YES\n") ; else     OclFile["System.out"].print("NO\n") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      int b=sc.nextInt();
      int e=sc.nextInt();
      int k=sc.nextInt();
      int res=0 ;
      for(int j=b ; j<e ; j++)if(a[j]==k)res++;
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var b : int ; b := sc.getCurrent()->toInteger() ;
     var e : int ; e := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
        var j : int ; j := b ; while j < e do (     if (a[j+1] = k) then     res := res + 1 ; else skip ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static Scanner scInputData=new Scanner(System.in);
  static ArrayList<Integer>arrA=new ArrayList<Integer>();
  public static void main(String[] args){
    int iNumVar=0 ;
    getArr();
    iNumVar=getQueryNum();
    for(int iQueryNum=1 ; iQueryNum<=iNumVar ; iQueryNum++){
      doQuery();
    }
  }
  private static void doQuery(){
    int start=scInputData.nextInt();
    int end=scInputData.nextInt();
    int bingoNum=scInputData.nextInt();
    int iTotal=0 ;
    for(int iFactorNum=start ; iFactorNum<end ; iFactorNum++){
      if(arrA.get(iFactorNum).intValue()==bingoNum)iTotal++;
    }
    System.out.println(iTotal);
  }
  private static int getQueryNum(){
    return scInputData.nextInt();
  }
  private static void getArr(){
    int iArrNum=0 ;
    iArrNum=scInputData.nextInt();
    while(arrA.size()<iArrNum){
      arrA.add(scInputData.nextInt());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scInputData : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute arrA : Sequence(int) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var iNumVar : int ; iNumVar := 0 ;
     execute getArr() ; 
     iNumVar := getQueryNum() ; 
         var iQueryNum : int ; iQueryNum := 1 ; while iQueryNum <= iNumVar do ( (     execute doQuery() )  ;     iQueryNum := iQueryNum + 1 ) );
  static   operation doQuery() : void
  pre: true
  post: true
  activity: (     var start : int ; start := scInputData.getCurrent()->toInteger() ;
     var end : int ; end := scInputData.getCurrent()->toInteger() ;
    var bingoNum : int ; bingoNum := scInputData.getCurrent()->toInteger() ;
    var iTotal : int ; iTotal := 0 ;
        var iFactorNum : int ; iFactorNum := start ; while iFactorNum < end do ( (     if (arrA->at(iFactorNum+1)->oclAsType(int) = bingoNum) then     iTotal := iTotal + 1 ; else skip )  ;     iFactorNum := iFactorNum + 1 ) ; 
    OclFile["System.out"].println(iTotal) ; 
 );
  static   operation getQueryNum() : int
  pre: true
  post: true
  activity: (     return scInputData.getCurrent()->toInteger() );
  static   operation getArr() : void
  pre: true
  post: true
  activity: (     var iArrNum : int ; iArrNum := 0 ;
     iArrNum := scInputData.getCurrent()->toInteger() ; 
     while (arrA->size() < iArrNum) do (     arrA := arrA->including(scInputData.getCurrent()->toInteger()) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.util.*;
import static java.lang.System.out ;
import static java.lang.Math.*;
public class pre132 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int tc=obj.nextInt();
    while(tc--!=0){
      int n=obj.nextInt();
      char arr[]=obj.next().toCharArray();
      int r=n-1,l=-1 ;
      while(r>=0 && arr[r]=='1')r--;
      while(l+1<n && arr[0]=='0' && arr[l+1]=='0')l++;
      boolean flag[]=new boolean[n];
      for(int i=0 ; i<=l ; i++)flag[i]=true ;
      for(int i=n-1 ; i>=r && i>=0 ; i--)flag[i]=true ;
      for(int i=0 ; i<n ; i++)if(flag[i])out.print(arr[i]);
      out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre132 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var tc : int ; tc := obj.nextInt() ;
         while (tc /= 0) do (    skip ; (     var n : int ; n := obj.nextInt() ;
     var arr : Sequence(String) ; arr := obj.next()->characters() ;
    var r : int ; r := n - 1 ;
    var l : int ; l := -1 ;
    while (r >= 0 & arr[r+1] = '1') do     r := r - 1 ; ; 
    while (l + 1 < n & arr[0+1] = '0' & arr[l + 1+1] = '0') do     l := l + 1 ; ; 
    var flag : Sequence(boolean) ; flag := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i <= l do (     flag[i+1] := true ;  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= r & i >= 0 do (     flag[i+1] := true ;  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     if (flag[i+1]) then     out.print(arr[i+1]) ; else skip ;  ;     i := i + 1 ) ; 
    out.println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Scanner ;
import java.util.TreeMap ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      List<Integer>a=IntStream.range(0,n).mapToObj(x->sc.nextInt()).collect(Collectors.toList());
      int q=sc.nextInt();
      IntStream.range(0,q).mapToObj((x)->{
        int b=sc.nextInt();
        int e=sc.nextInt();
        int k=sc.nextInt();
        return Collections.frequency(a.subList(b,e),k);
      }
).collect(Collectors.toList()).forEach(System.out :: println);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(0, n-1).mapToObj(lambda x : OclAny in sc.getCurrent()->toInteger()).collect(Collectors.toList()) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
     for _forEach : Integer.subrange(0, q-1).mapToObj(lambda x : OclAny in (     var b : int ; b := sc.getCurrent()->toInteger() ;
     var e : int ; e := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     return frequency(a.subrange(b+1,e), k) )).collect(Collectors.toList()) do
    (    skip ;) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    int num=sc.nextInt();
    ArrayList<Integer>array=new ArrayList<>();
    for(int i=0 ; i<num ; i++){
      int tmp=sc.nextInt();
      array.add(tmp);
    }
    int num_query=sc.nextInt();
    for(int i=0 ; i<num_query ; i++){
      int left=sc.nextInt();
      int right=sc.nextInt();
      int key=sc.nextInt();
      int cnt=0 ;
      for(int j=left ; j<right ; j++){
        if(array.get(j)==key)cnt++;
      }
      sb.append(String.format("%d\n",cnt));
    }
    System.out.print(sb);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
    var num : int ; num := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Sequence{} ;
        var i : int ; i := 0 ; while i < num do ( (     var tmp : int ; tmp := sc.getCurrent()->toInteger() ;
     array := array->including(tmp) )  ;     i := i + 1 ) ; 
    var num_query : int ; num_query := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < num_query do ( (     var left : int ; left := sc.getCurrent()->toInteger() ;
     var right : int ; right := sc.getCurrent()->toInteger() ;
    var key : int ; key := sc.getCurrent()->toInteger() ;
    var cnt : int ; cnt := 0 ;
        var j : int ; j := left ; while j < right do ( (     if (array->at(j+1) = key) then     cnt := cnt + 1 ; else skip )  ;     j := j + 1 ) ; 
    sb := sb + StringLib.newString(StringLib.format("%d\n",Sequence{cnt})) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    List<Integer>list=new ArrayList<>(n);
    for(int i=0 ; i<n ; i++){
      list.add(Integer.parseInt(sc.next()));
    }
    int q=Integer.parseInt(sc.next());
    int start,end,search,count ;
    for(int i=0 ; i<q ; i++){
      start=Integer.parseInt(sc.next());
      end=Integer.parseInt(sc.next());
      search=Integer.parseInt(sc.next());
      count=0 ;
      for(int j=start ; j<end ; j++){
        if(list.get(j)==search)count++;
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including((sc.getCurrent())->toInteger()) )  ;     i := i + 1 ) ; 
    var q : int ; q := (sc.getCurrent())->toInteger() ;
    var start : int ;
    var end : int ;
    var search : int ;
    var count : int ;
        var i : int ; i := 0 ; while i < q do ( (     start := (sc.getCurrent())->toInteger() ; 
     end := (sc.getCurrent())->toInteger() ; 
    search := (sc.getCurrent())->toInteger() ; 
    count := 0 ; 
        var j : int ; j := start ; while j < end do ( (     if (list->at(j+1) = search) then     count := count + 1 ; else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long x=sc.nextInt();
    int[][] arr=new int[n][n];
    long[] totals=new long[n];
    for(int i=0 ; i<n ; i++){
      arr[0][i]=sc.nextInt();
      totals[0]+=arr[0][i];
    }
    for(int i=1 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        arr[i][j]=Math.min(arr[i-1][j],arr[i-1][(j-1+n)% n]);
        totals[i]+=arr[i][j];
      }
      totals[i]+=x*i ;
    }
    Arrays.sort(totals);
    System.out.println(totals[0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : long ; x := sc.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var totals : Sequence(long) ; totals := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[0+1][i+1] := sc.getCurrent()->toInteger() ; 
     totals[0+1] := totals[0+1]+(arr[0+1][i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     arr[i+1][j+1] := Set{arr[i - 1+1][j+1], arr[i - 1+1][(j - 1 + n) mod n+1]}->min() ; 
     totals[i+1] := totals[i+1]+(arr[i+1][j+1]) )  ;     j := j + 1 ) ; 
     totals[i+1] := totals[i+1]+(x * i) )  ;     i := i + 1 ) ; 
    totals := totals->sort() ; 
    OclFile["System.out"].println(totals[0+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  BufferedReader br ;
  PrintWriter out ;
  StringTokenizer st ;
  boolean eof ;
  void solve()throws IOException {
    int n=nextInt();
    int x=nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=nextInt();
    }
    long[] cost=new long[n];
    for(int i=0 ; i<n ; i++){
      int best=Integer.MAX_VALUE ;
      for(int j=0 ; j<n ; j++){
        int now=(i+n-j)% n ;
        best=Math.min(best,a[now]);
        cost[j]+=best ;
      }
    }
    long outp=Long.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      outp=Math.min(outp,cost[i]+(long)i*x);
    }
    out.println(outp);
  }
  Main()throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(System.out);
    solve();
    out.close();
  }
  public static void main(String[] args)throws IOException {
    new Main();
  }
  String nextToken(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
        eof=true ;
        return null ;
      }
    }
    return st.nextToken();
  }
  String nextString(){
    try {
      return br.readLine();
    }
    catch(IOException e){
      eof=true ;
      return null ;
    }
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute br : OclFile;
   attribute out : OclFile;
   attribute st : OclIterator;
   attribute eof : boolean;
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var x : int ; x := nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := nextInt() )  ;     i := i + 1 ) ; 
    var cost : Sequence(long) ; cost := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var best : int ; best := 2147483647 ;
         var j : int ; j := 0 ; while j < n do ( (     var now : int ; now := (i + n - j) mod n ;
     best := Set{best, a[now+1]}->min() ; 
     cost[j+1] := cost[j+1]+(best) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var outp : long ; outp := "9223372036854775807"->toLong() ;
        var i : int ; i := 0 ; while i < n do ( (     outp := Set{outp, cost[i+1] + i->oclAsType(long) * x}->min() )  ;     i := i + 1 ) ; 
    skip ; 
 );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     execute solve() ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     eof := true ; 
     return null )
 ) ; 
     return st.next() );
   operation nextString() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do (     eof := true ; 
     return null )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int factorial(int n){
    int i=n,fact=1 ;
    while(n/i!=n){
      fact=fact*i ;
      i--;
    }
    return fact ;
  }
  public static void main(String[] args){
    int num=5 ;
    System.out.println("Factorial of "+num+" is "+factorial(5));
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation factorial( n : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := n ;
    var fact : int ; fact := 1 ;
     while (n / i /= n) do (     fact := fact * i ; 
     i := i - 1 ) ; 
     return fact );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 5 ;
     OclFile["System.out"].println("Factorial of " + num + " is " + factorial(5)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.stream.LongStream ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BColorfulSlimes solver=new BColorfulSlimes();
    solver.solve(1,in,out);
    out.close();
  }
  static class BColorfulSlimes {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      long x=in.nextLong();
      long[][] a=new long[n][n];
      a[0]=LongStream.range(0,n).map(z->in.nextInt()).toArray();
      long ans=LongStream.of(a[0]).sum();
      for(int k=1 ; k<n ; k++){
        for(int i=0 ; i<n ; i++){
          a[k][i]=Math.min(a[k-1][(i+n-1)% n],a[0][i]);
        }
        ans=Math.min(ans,LongStream.of(a[k]).sum()+k*x);
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BColorfulSlimes ; solver := BColorfulSlimes.newBColorfulSlimes() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BColorfulSlimes {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var x : long ; x := in.getCurrent()->toLong() ;
    var a : Sequence(Sequence(long)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    a[0+1] := Integer.subrange(0, n-1)->collect( _x1 | (lambda z : OclAny in in.getCurrent()->toInteger())->apply(_x1) )->asSequence() ; 
    var ans : long ; ans := Sequence{a[0+1]}->sum() ;
        var k : int ; k := 1 ; while k < n do ( (         var i : int ; i := 0 ; while i < n do ( (     a[k+1][i+1] := Set{a[k - 1+1][(i + n - 1) mod n+1], a[0+1][i+1]}->min() )  ;     i := i + 1 ) ; 
     ans := Set{ans, Sequence{a[k+1]}->sum() + k * x}->min() )  ;     k := k + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    long x=scan.nextLong();
    List<Long>srimeList=new ArrayList<>(N);
    for(long i=0 ; i<N ; i++){
      srimeList.add(scan.nextLong());
    }
    List<Long[]>costList=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      costList.add(new Long[N]);
    }
    for(int i=0 ; i<N ; i++){
      costList.get(i)[0]=srimeList.get(i);
      for(int castNum=1 ; castNum<N ; castNum++){
        costList.get(i)[castNum]=Math.min(costList.get(i)[castNum-1],srimeList.get((i-castNum+N)% N));
      }
    }
    List<Long>result=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      final int j=i ;
      result.add(i*x+costList.stream().mapToLong(costArray->costArray[j]).sum());
    }
    System.out.println(result.stream().mapToLong(i->i).min().getAsLong());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var x : long ; x := scan.getCurrent()->toLong() ;
    var srimeList : Sequence(long) ; srimeList := Sequence{} ;
        var i : long ; i := 0 ; while i < N do ( (     srimeList := srimeList->including(scan.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    var costList : Sequence(Sequence(long)) ; costList := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     costList := costList->including(Integer.subrange(1,N)->collect(null)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     costList->at(i+1)[0+1] := srimeList->at(i+1) ; 
         var castNum : int ; castNum := 1 ; while castNum < N do ( (     costList->at(i+1)[castNum+1] := Set{costList->at(i+1)[castNum - 1+1], srimeList->at((i - castNum + N) mod N+1)}->min() )  ;     castNum := castNum + 1 ) )  ;     i := i + 1 ) ; 
    var result : Sequence(long) ; result := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var j : int ; j := i ;
     result := result->including(i * x + costList->collect( _x1 | (lambda costArray : OclAny in costArray[j+1])->apply(_x1) )->sum()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result->collect( _x1 | (lambda i : OclAny in i)->apply(_x1) ).min().getAsLong()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    final Scanner scanner=new Scanner(System.in);
    solve(scanner);
  }
  static void solve(Scanner scanner){
    int N=scanner.nextInt();
    long X=scanner.nextLong();
    scanner.nextLine();
    int[] a=Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    long[][] min=new long[N][N];
    for(int i=0 ; i<N ; i++){
      Arrays.fill(min[i],Long.MAX_VALUE/2);
      min[i][i]=a[i];
    }
    for(int i=1 ; i<N ; i++){
      for(int l=0 ; l<N ; l++){
        min[l][Math.floorMod(l+i,N)]=Math.min(min[l][Math.floorMod(l+i-1,N)],a[Math.floorMod(l+i,N)]);
      }
    }
    long ans=Long.MAX_VALUE ;
    for(int i=0 ; i<N ; i++){
      long tmp=i*X ;
      for(int j=0 ; j<N ; j++){
        tmp+=min[Math.floorMod(j-i,N)][j];
      }
      ans=Math.min(ans,tmp);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute solve(scanner) );
  static   operation solve( scanner : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := scanner.getCurrent()->toInteger() ;
     var X : long ; X := scanner.getCurrent()->toLong() ;
    skip ; 
    var a : Sequence(int) ; a := stream(scanner.nextLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var min : Sequence(Sequence(long)) ; min := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     min[i+1] := min[i+1]->collect("9223372036854775807"->toLong() / 2) ; 
     min[i+1][i+1] := a[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < N do ( (         var l : int ; l := 0 ; while l < N do ( (     min[l+1][floorMod(l + i, N)+1] := Set{min[l+1][floorMod(l + i - 1, N)+1], a[floorMod(l + i, N)+1]}->min() )  ;     l := l + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := "9223372036854775807"->toLong() ;
        var i : int ; i := 0 ; while i < N do ( (     var tmp : long ; tmp := i * X ;
         var j : int ; j := 0 ; while j < N do ( (     tmp := tmp+(min[floorMod(j - i, N)+1][j+1]) )  ;     j := j + 1 ) ; 
     ans := Set{ans, tmp}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.util.*;
import static java.lang.System.out ;
import static java.lang.Math.*;
public class pre132 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int tc=obj.nextInt();
    while(tc--!=0){
      int n=obj.nextInt();
      char arr[]=obj.next().toCharArray();
      int r=n-1,l=-1 ;
      while(r>=0 && arr[r]=='1')r--;
      while(l+1<n && arr[0]=='0' && arr[l+1]=='0')l++;
      boolean flag[]=new boolean[n];
      for(int i=0 ; i<=l ; i++)flag[i]=true ;
      for(int i=n-1 ; i>=r && i>=0 ; i--)flag[i]=true ;
      for(int i=0 ; i<n ; i++)if(flag[i])out.print(arr[i]);
      out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre132 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var tc : int ; tc := obj.nextInt() ;
         while (tc /= 0) do (    skip ; (     var n : int ; n := obj.nextInt() ;
     var arr : Sequence(String) ; arr := obj.next()->characters() ;
    var r : int ; r := n - 1 ;
    var l : int ; l := -1 ;
    while (r >= 0 & arr[r+1] = '1') do     r := r - 1 ; ; 
    while (l + 1 < n & arr[0+1] = '0' & arr[l + 1+1] = '0') do     l := l + 1 ; ; 
    var flag : Sequence(boolean) ; flag := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i <= l do (     flag[i+1] := true ;  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= r & i >= 0 do (     flag[i+1] := true ;  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     if (flag[i+1]) then     out.print(arr[i+1]) ; else skip ;  ;     i := i + 1 ) ; 
    out.println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String input=br.readLine();
      String[] tmpArray=input.split(" ");
      int h=Integer.parseInt(tmpArray[0]);
      int w=Integer.parseInt(tmpArray[1]);
      if(h==0 && w==0){
        break ;
      }
      int map[][]=new int[h][w];
      for(int i=0 ; i<h ; i++){
        tmpArray=br.readLine().split(" ");
        for(int j=0 ; j<w ; j++){
          map[i][j]=Integer.parseInt(tmpArray[j]);
        }
      }
      int result=0 ;
      for(int width=3 ; width<=w ; width++){
        for(int height=3 ; height<=h ; height++){
          for(int i=0 ; i+height<=h ; i++){
            for(int j=0 ; j+width<=w ; j++){
              int outerMinHeight=10 ;
              int innerMaxHeight=0 ;
              int sumHeight=0 ;
              for(int k=i ; k<i+height ; k++){
                for(int l=j ; l<j+width ; l++){
                  if(k==i || k==i+height-1 || l==j || l==j+width-1){
                    outerMinHeight=Math.min(outerMinHeight,map[k][l]);
                  }
                  else {
                    innerMaxHeight=Math.max(innerMaxHeight,map[k][l]);
                    sumHeight+=map[k][l];
                  }
                }
              }
              if(outerMinHeight>innerMaxHeight){
                result=Math.max(result,(width-2)*(height-2)*outerMinHeight-sumHeight);
              }
            }
          }
        }
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var input : String ; input := br.readLine() ;
     var tmpArray : Sequence(String) ; tmpArray := input->split(" ") ;
    var h : int ; h := (tmpArray[0+1])->toInteger() ;
    var w : int ; w := (tmpArray[1+1])->toInteger() ;
    if (h = 0 & w = 0) then (     break ) else skip ; 
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (     tmpArray := br.readLine()->split(" ") ; 
         var j : int ; j := 0 ; while j < w do ( (     map[i+1][j+1] := (tmpArray[j+1])->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
        var width : int ; width := 3 ; while width <= w do ( (         var height : int ; height := 3 ; while height <= h do ( (         var i : int ; i := 0 ; while i + height <= h do ( (         var j : int ; j := 0 ; while j + width <= w do ( (     var outerMinHeight : int ; outerMinHeight := 10 ;
     var innerMaxHeight : int ; innerMaxHeight := 0 ;
    var sumHeight : int ; sumHeight := 0 ;
        var k : int ; k := i ; while k < i + height do ( (         var l : int ; l := j ; while l < j + width do ( (     if (k = i or k = i + height - 1 or l = j or l = j + width - 1) then (     outerMinHeight := Set{outerMinHeight, map[k+1][l+1]}->min() ) else (     innerMaxHeight := Set{innerMaxHeight, map[k+1][l+1]}->max() ; 
     sumHeight := sumHeight+(map[k+1][l+1]) ) )  ;     l := l + 1 ) )  ;     k := k + 1 ) ; 
    if (outerMinHeight > innerMaxHeight) then (     result := Set{result, (width - 2) * (height - 2) * outerMinHeight - sumHeight}->max() ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     height := height + 1 ) )  ;     width := width + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    PrintWriter out=new PrintWriter(System.out);
    Scanner ir=new Scanner(System.in);
    for(; ; ){
      int d=ir.nextInt();
      int w=ir.nextInt();
      if(d==0 && w==0){
        break ;
      }
      int[][] e=new int[d][w];
      for(int i=0 ; i<d ; i++){
        for(int j=0 ; j<w ; j++){
          e[i][j]=ir.nextInt();
        }
      }
      int res=0 ;
      for(int i=0 ; i<d ; i++){
        for(int j=0 ; j<w ; j++){
          for(int k=i+2 ; k<d ; k++){
            for(int l=j+2 ; l<w ; l++){
              int ma=0 ;
              int mi=10 ;
              int tot=0 ;
              for(int m=i ; m<=k ; m++){
                for(int n=j ; n<=l ; n++){
                  if(m==i || m==k || n==j || n==l){
                    mi=Math.min(mi,e[m][n]);
                  }
                  else {
                    ma=Math.max(ma,e[m][n]);
                    tot+=e[m][n];
                  }
                }
              }
              if(mi>ma){
                res=Math.max(res,(k-i-1)*(l-j-1)*mi-tot);
              }
            }
          }
        }
      }
      out.println(res);
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var ir : OclFile ; ir := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var d : int ; d := ir.getCurrent()->toInteger() ;
     var w : int ; w := ir.getCurrent()->toInteger() ;
    if (d = 0 & w = 0) then (     break ) else skip ; 
    var e : Sequence(Sequence(int)) ; e := Integer.subrange(1,d)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < d do ( (         var j : int ; j := 0 ; while j < w do ( (     e[i+1][j+1] := ir.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < d do ( (         var j : int ; j := 0 ; while j < w do ( (         var k : int ; k := i + 2 ; while k < d do ( (         var l : int ; l := j + 2 ; while l < w do ( (     var ma : int ; ma := 0 ;
     var mi : int ; mi := 10 ;
    var tot : int ; tot := 0 ;
        var m : int ; m := i ; while m <= k do ( (         var n : int ; n := j ; while n <= l do ( (     if (m = i or m = k or n = j or n = l) then (     mi := Set{mi, e[m+1][n+1]}->min() ) else (     ma := Set{ma, e[m+1][n+1]}->max() ; 
     tot := tot+(e[m+1][n+1]) ) )  ;     n := n + 1 ) )  ;     m := m + 1 ) ; 
    if (mi > ma) then (     res := Set{res, (k - i - 1) * (l - j - 1) * mi - tot}->max() ) else skip ; 
 )  ;     l := l + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] A){
    Scanner s=new Scanner(System.in);
    int[][] f=new int[10][10];
    while(true){
      int h=s.nextInt(),w=s.nextInt();
      if(h+w==0)return ;
      for(int i=0 ; i<h ; ++i)for(int j=0 ; j<w ; ++j)f[i][j]=s.nextInt();
      int r=0 ;
      for(int i=0 ; i<h-2 ; ++i){
        for(int j=0 ; j<w-2 ; ++j){
          for(int k=i+2 ; k<h ; ++k){
            loop : for(int l=j+2 ;
            l<w ;
++l){
              int edge=9 ;
              for(int I=i ; I<=k ; ++I)edge=Math.min(edge,Math.min(f[I][j],f[I][l]));
              for(int J=j ; J<=l ; ++J)edge=Math.min(edge,Math.min(f[i][J],f[k][J]));
              int res=0 ;
              for(int I=i+1 ; I<k ; ++I){
                for(int J=j+1 ; J<l ; ++J){
                  if(f[I][J]>=edge)continue loop ;
                  res+=edge-f[I][J];
                }
              }
              r=Math.max(r,res);
            }
          }
        }
      }
      System.out.println(r);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( A : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var f : Sequence(Sequence(int)) ; f := Integer.subrange(1,10)->collect(Integer.subrange(1,10)->collect(0)) ;
     while (true) do (     var h : int ; h := s.getCurrent()->toInteger() ;
    var w : int ; w := s.getCurrent()->toInteger() ;
     if (h + w = 0) then     return else skip ; 
        var i : int ; i := 0 ; while i < h do (         var j : int ; j := 0 ; while j < w do (     f[i+1][j+1] := s.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var r : int ; r := 0 ;
        var i : int ; i := 0 ; while i < h - 2 do ( (         var j : int ; j := 0 ; while j < w - 2 do ( (         var k : int ; k := i + 2 ; while k < h do ( (         var l : int ; l := j + 2 ; while l < w do ( (     var edge : int ; edge := 9 ;
         var I : int ; I := i ; while I <= k do (     edge := Set{edge, Set{f[I+1][j+1], f[I+1][l+1]}->min()}->min() ;  ;     I := I + 1 ) ; 
        var J : int ; J := j ; while J <= l do (     edge := Set{edge, Set{f[i+1][J+1], f[k+1][J+1]}->min()}->min() ;  ;     J := J + 1 ) ; 
    var res : int ; res := 0 ;
        var I : int ; I := i + 1 ; while I < k do ( (         var J : int ; J := j + 1 ; while J < l do ( (     if (f[I+1][J+1] >= edge) then     continue else skip ; 
     res := res+(edge - f[I+1][J+1]) )  ;     J := J + 1 ) )  ;     I := I + 1 ) ; 
    r := Set{r, res}->max() ; 
 )  ;     l := l + 1 ) ; )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(r) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int[][] pond ;
  public static void main(String[] args){
    int d,w,count ;
    Scanner sc=new Scanner(System.in);
    while(true){
      w=sc.nextInt();
      if(w==0){
        break ;
      }
      d=sc.nextInt();
      count=0 ;
      pond=new int[w][d];
      for(int i=0 ; i<w ; i++){
        for(int j=0 ; j<d ; j++){
          pond[i][j]=sc.nextInt();
        }
      }
      for(int iw=0 ; iw<w-2 ; iw++){
        for(int id=0 ; id<d-2 ; id++){
          for(int jw=iw+2 ; jw<w ; jw++){
            for(int jd=id+2 ; jd<d ; jd++){
              count=Math.max(count,calc(iw,id,jw,jd));
            }
          }
        }
      }
      System.out.println(count);
    }
    sc.close();
  }
  public static int calc(int iw,int id,int jw,int jd){
    int height=10 ;
    for(int w=iw ; w<=jw ; w++){
      height=Math.min(pond[w][id],height);
      height=Math.min(pond[w][jd],height);
    }
    for(int d=id+1 ; d<jd ; d++){
      height=Math.min(pond[iw][d],height);
      height=Math.min(pond[jw][d],height);
    }
    int depth=0 ;
    for(int w=iw+1 ; w<jw ; w++){
      for(int d=id+1 ; d<jd ; d++){
        if(height<=pond[w][d]){
          return 0 ;
        }
        depth+=height-pond[w][d];
      }
    }
    return depth ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute pond : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : int ;
    var w : int ;
    var count : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     w := sc.getCurrent()->toInteger() ; 
     if (w = 0) then (     break ) else skip ; 
    d := sc.getCurrent()->toInteger() ; 
    count := 0 ; 
    pond := Integer.subrange(1,w)->collect(Integer.subrange(1,d)->collect(0)) ; 
        var i : int ; i := 0 ; while i < w do ( (         var j : int ; j := 0 ; while j < d do ( (     pond[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var iw : int ; iw := 0 ; while iw < w - 2 do ( (         var id : int ; id := 0 ; while id < d - 2 do ( (         var jw : int ; jw := iw + 2 ; while jw < w do ( (         var jd : int ; jd := id + 2 ; while jd < d do ( (     count := Set{count, calc(iw, id, jw, jd)}->max() )  ;     jd := jd + 1 ) )  ;     jw := jw + 1 ) )  ;     id := id + 1 ) )  ;     iw := iw + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ; 
     skip );
  static   operation calc( iw : int, id : int, jw : int, jd : int) : int
  pre: true
  post: true
  activity: (     var height : int ; height := 10 ;
         var w : int ; w := iw ; while w <= jw do ( (     height := Set{pond[w+1][id+1], height}->min() ; 
     height := Set{pond[w+1][jd+1], height}->min() )  ;     w := w + 1 ) ; 
        var d : int ; d := id + 1 ; while d < jd do ( (     height := Set{pond[iw+1][d+1], height}->min() ; 
     height := Set{pond[jw+1][d+1], height}->min() )  ;     d := d + 1 ) ; 
    var depth : int ; depth := 0 ;
        var w : int ; w := iw + 1 ; while w < jw do ( (         var d : int ; d := id + 1 ; while d < jd do ( (     if (height <= pond[w+1][d+1]) then (     return 0 ) else skip ; 
     depth := depth+(height - pond[w+1][d+1]) )  ;     d := d + 1 ) )  ;     w := w + 1 ) ; 
    return depth 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long k=sc.nextLong();
    long arr[]=new long[(int)n];
    for(long i=0 ; i<(int)n ; ++i){
      arr[(int)i]=sc.nextLong();
    }
    if(k==1){
      System.out.println(n);
      System.exit(0);
    }
    long ans[]=new long[(int)n];
    Arrays.sort(arr);
    for(long i=0 ; i<(int)n ; ++i){
      if(ans[(int)i]==0){
        long ktimes=k*arr[(int)i];
        long index=Arrays.binarySearch(arr,ktimes);
        if(index>=0){
          ans[(int)index]=-1 ;
        }
      }
    }
    long ans1=0 ;
    for(long i=0 ; i<n ; ++i){
      if(ans[(int)i]==0){
++ans1 ;
      }
    }
    System.out.println(ans1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n->oclAsType(int))->collect(0) ;
        var i : long ; i := 0 ; while i < n->oclAsType(int) do ( (     arr[i->oclAsType(int)+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    if (k = 1) then (     OclFile["System.out"].println(n) ; 
 OclProcess.exit(0) ) else skip ; 
    var ans : Sequence(long) ; ans := Integer.subrange(1,n->oclAsType(int))->collect(0) ;
    arr := arr->sort() ; 
        var i : long ; i := 0 ; while i < n->oclAsType(int) do ( (     if (ans[i->oclAsType(int)+1] = 0) then (     var ktimes : long ; ktimes := k * arr[i->oclAsType(int)+1] ;
     var index : long ; index := (arr->indexOf(ktimes) - 1) ;
     if (index >= 0) then (     ans[index->oclAsType(int)+1] := -1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    var ans1 : long ; ans1 := 0 ;
        var i : long ; i := 0 ; while i < n do ( (     if (ans[i->oclAsType(int)+1] = 0) then (     ans1 := ans1 + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
    String[] ins=br.readLine().trim().split(" ");
    int n=Integer.parseInt(ins[0]);
    int k=Integer.parseInt(ins[1]);
    ins=br.readLine().trim().split(" ");
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=Integer.parseInt(ins[i]);
    Arrays.sort(arr);
    HashSet<Integer>hs=new HashSet<Integer>();
    int res=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] % k!=0 || ! hs.contains(arr[i]/k)){
        res++;
        hs.add(arr[i]);
      }
    }
    out.write(res+"\n");
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var ins : Sequence(String) ; ins := br.readLine()->trim()->split(" ") ;
    var n : int ; n := (ins[0+1])->toInteger() ;
    var k : int ; k := (ins[1+1])->toInteger() ;
    ins := br.readLine()->trim()->split(" ") ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := (ins[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var hs : Set(int) ; hs := Set{} ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod k /= 0 or not(hs->includes(arr[i+1] / k))) then (     res := res + 1 ; 
     hs := hs->including(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int m=Integer.parseInt(sc.next());
    int[] p=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      p[i]=Integer.parseInt(sc.next());
    }
    UnionFind uf=new UnionFind(n+1);
    int x,y ;
    for(int i=0 ; i<m ; i++){
      x=Integer.parseInt(sc.next());
      y=Integer.parseInt(sc.next());
      uf.unite(x,y);
    }
    int ans=0 ;
    for(int i=1 ; i<=n ; i++){
      if(uf.same(i,p[i])){
        ans++;
      }
    }
    System.out.println(ans);
  }
  static class UnionFind {
    int[] parent ;
    int[] rank ;
    public UnionFind(int n){
      parent=new int[n];
      rank=new int[n];
      for(int i=0 ; i<n ; i++){
        parent[i]=i ;
      }
    }
    private int root(int x){
      if(parent[x]==x){
        return x ;
      }
      else {
        return parent[x]=root(parent[x]);
      }
    }
    private void unite(int x,int y){
      x=root(x);
      y=root(y);
      if(x==y)return ;
      if(rank[x]<rank[y]){
        parent[x]=y ;
      }
      else {
        parent[y]=x ;
        if(rank[x]==rank[y]){
          rank[x]++;
        }
      }
    }
    private boolean same(int x,int y){
      return root(x)==root(y);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var m : int ; m := (sc.getCurrent())->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     p[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var uf : UnionFind ; uf := UnionFind.newUnionFind(n + 1) ;
    var x : int ;
    var y : int ;
        var i : int ; i := 0 ; while i < m do ( (     x := (sc.getCurrent())->toInteger() ; 
     y := (sc.getCurrent())->toInteger() ; 
     uf.unite(x, y) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (uf.same(i, p[i+1])) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class UnionFind {
   attribute parent : Sequence(int);
   attribute rank : Sequence(int);
   static operation newUnionFind( n : int) : UnionFind
  pre: true
  post: true
  activity:
  ( var self : UnionFind ;
    self := createUnionFind();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     parent := Integer.subrange(1,n)->collect(0) ; 
     rank := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do ( (     parent[i+1] := i )  ;     i := i + 1 ) );
   operation root( x : int) : int
  pre: true
  post: true
  activity: (     if (parent[x+1] = x) then (     return x ) else (     return parent[x+1] ) );
   operation unite( x : int, y : int) : void
  pre: true
  post: true
  activity: (     x := root(x) ; 
     y := root(y) ; 
     if (x = y) then     return else skip ; 
     if (rank[x+1] < rank[y+1]) then (     parent[x+1] := y ) else (     parent[y+1] := x ; 
     if (rank[x+1] = rank[y+1]) then (     rank[x+1] := rank[x+1] + 1 ) else skip ) );
   operation same( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return root(x) = root(y) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int CntDivbyX(int arr[],int n,int x){
    int number=0 ;
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      number=number*2+arr[i];
      if((number % x==0))count+=1 ;
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      1,0,1,0,1,1,0 };
      int n=arr.length ;
      int x=2 ;
      System.out.println(CntDivbyX(arr,n,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation CntDivbyX( arr : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var number : int ; number := 0 ;
     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     number := number * 2 + arr[i+1] ; 
     if ((number mod x = 0)) then     count := count+(1) ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,0,1,0,1,1,0} ;
     var n : int ; n := arr->size() ;
     var x : int ; x := 2 ;
     OclFile["System.out"].println(CntDivbyX(arr, n, x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class k_multiple_free_set_6 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long k=sc.nextLong();
    long[] arr=new long[n];
    HashSet<Long>set=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextLong();
    }
    Arrays.sort(arr);
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] % k!=0){
        count++;
        set.add(arr[i]);
      }
      else if(! set.contains(arr[i]/k)){
        count++;
        set.add(arr[i]);
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class k_multiple_free_set_6 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
    var set : Set(long) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod k /= 0) then (     count := count + 1 ; 
     set := set->including(arr[i+1]) ) else     if (not(set->includes(arr[i+1] / k))) then (     count := count + 1 ; 
     set := set->including(arr[i+1]) ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Solution {
  public static void main(String[] args)throws Exception {
    FastReader fr=new FastReader();
    int n=fr.nextInt();
    int k=fr.nextInt();
    long a[]=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=fr.nextInt();
    }
    Arrays.sort(a);
    Set<Long>set=new HashSet<>();
    for(int i=n-1 ; i>=0 ; i--){
      long f=a[i]*k ;
      if(! set.contains(f))set.add(a[i]);
    }
    System.out.println(set.size());
  }
}
class Pair implements Comparable<Pair>{
  int x,y ;
  Pair(int x,int y){
    this.x=x ;
    this.y=y ;
  }
  @ Override public int compareTo(Pair o){
    return(this.y-o.y);
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    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 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fr : FastReader ; fr := FastReader.newFastReader() ;
     var n : int ; n := fr.nextInt() ;
    var k : int ; k := fr.nextInt() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := fr.nextInt() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var set : Set(long) ; set := Set{} ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     var f : long ; f := a[i+1] * k ;
     if (not(set->includes(f))) then     set := set->including(a[i+1]) ; else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(set->size()) ; 
 );
}
class Pair implements Comparable<Map> {
   attribute x : int;
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
      operation compareTo( o : Map) : int
  pre: true
  post: true
  activity: (     return (self.y - o.y) );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.lang.Math.*;
public class Inheritance {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      String s1=s.next();
      int count0=0 ;
      int count1=0 ;
      int c0=-1 ;
      int c1=n ;
      for(int i=0 ; i<n ; i++){
        if(s1.charAt(i)=='1'){
          c1=i ;
          break ;
        }
        else count0++;
      }
      for(int i=n-1 ; i>=0 ; i--){
        if(s1.charAt(i)=='0'){
          c0=i ;
          break ;
        }
        else count1++;
      }
      if(c1-c0==1 || c1==c0 || c1==n || c0==-1){
        System.out.println(s1);
        continue ;
      }
      String ans="" ;
      for(int i=0 ; i<=count0 ; i++){
        ans=ans+"0" ;
      }
      for(int i=1 ; i<=count1 ; i++){
        ans=ans+"1" ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Inheritance {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var s1 : String ; s1 := s.getCurrent() ;
    var count0 : int ; count0 := 0 ;
    var count1 : int ; count1 := 0 ;
    var c0 : int ; c0 := -1 ;
    var c1 : int ; c1 := n ;
        var i : int ; i := 0 ; while i < n do ( (     if (s1->at(i+1) = '1') then (     c1 := i ; 
     break ) else     count0 := count0 + 1 ; )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (s1->at(i+1) = '0') then (     c0 := i ; 
     break ) else     count1 := count1 + 1 ; )  ;     i := i - 1 ) ; 
    if (c1 - c0 = 1 or c1 = c0 or c1 = n or c0 = -1) then (     OclFile["System.out"].println(s1) ; 
     continue ) else skip ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i <= count0 do ( (     ans := ans + "0" )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= count1 do ( (     ans := ans + "1" )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package google.codejam2012.qualification ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class RecycledNumbers {
  static private int getDigitsCount(int number){
    int sh=10 ;
    int digits=1 ;
    while(sh<=number){
      sh*=10 ;
      digits++;
    }
    return digits ;
  }
  static private int getRecyclingPairsCount(int number,int limit){
    int digits=getDigitsCount(number);
    int sh=1 ;
    for(int i=1 ; i<digits ; i++){
      sh*=10 ;
    }
    int permutation=number ;
    int result=0 ;
    int[] usedNumbers=new int[digits];
    int usedNumbersCount=0 ;
    for(int i=1 ; i<digits ; i++){
      permutation=(permutation % 10)*sh+(permutation/10);
      if(number<permutation & permutation<=limit){
        boolean isNumberAlreadyUsed=false ;
        for(int j=0 ; j<usedNumbersCount ; j++){
          if(usedNumbers[j]==permutation){
            isNumberAlreadyUsed=true ;
            break ;
          }
        }
        if(! isNumberAlreadyUsed){
          usedNumbers[usedNumbersCount++]=permutation ;
          result++;
        }
      }
    }
    return result ;
  }
  static public void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in),64<<10);
      int testsNumber=Integer.parseInt(br.readLine().trim());
      for(int test=1 ; test<=testsNumber ; test++){
        StringTokenizer tokenizer=new StringTokenizer(br.readLine());
        int startingNumber=Integer.parseInt(tokenizer.nextToken());
        int endingNumber=Integer.parseInt(tokenizer.nextToken());
        int result=0 ;
        for(int number=startingNumber ; number<=endingNumber ; number++){
          result+=getRecyclingPairsCount(number,endingNumber);
        }
        System.out.println("Case #"+test+": "+result);
      }
    }
    catch(Exception e){
      System.err.println("Error:"+e.getMessage());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class RecycledNumbers {
  static    operation getDigitsCount( number : int) : int
  pre: true
  post: true
  activity: (     var sh : int ; sh := 10 ;
     var digits : int ; digits := 1 ;
     while (sh <= number) do (     sh := sh*(10) ; 
     digits := digits + 1 ) ; 
     return digits );
  static    operation getRecyclingPairsCount( number : int, limit : int) : int
  pre: true
  post: true
  activity: (     var digits : int ; digits := getDigitsCount(number) ;
     var sh : int ; sh := 1 ;
        var i : int ; i := 1 ; while i < digits do ( (     sh := sh*(10) )  ;     i := i + 1 ) ; 
    var permutation : int ; permutation := number ;
    var result : int ; result := 0 ;
    var usedNumbers : Sequence(int) ; usedNumbers := Integer.subrange(1,digits)->collect(0) ;
    var usedNumbersCount : int ; usedNumbersCount := 0 ;
        var i : int ; i := 1 ; while i < digits do ( (     permutation := (permutation mod 10) * sh + (permutation / 10) ; 
     if (number < permutation & permutation <= limit) then (     var isNumberAlreadyUsed : boolean ; isNumberAlreadyUsed := false ;
         var j : int ; j := 0 ; while j < usedNumbersCount do ( (     if (usedNumbers[j+1] = permutation) then (     isNumberAlreadyUsed := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (not(isNumberAlreadyUsed)) then (      usedNumbers[usedNumbersCount+1] := permutation  ; usedNumbersCount := usedNumbersCount + 1 ; 
     result := result + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    return result 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (64*(2->pow(10)))->oclAsType(long)) ;
     var testsNumber : int ; testsNumber := (br.readLine()->trim())->toInteger() ;
         var test : int ; test := 1 ; while test <= testsNumber do ( (     var tokenizer : OclIterator ; tokenizer := OclIterator.newOclIterator_String(br.readLine()) ;
     var startingNumber : int ; startingNumber := (tokenizer.next())->toInteger() ;
    var endingNumber : int ; endingNumber := (tokenizer.next())->toInteger() ;
    var result : int ; result := 0 ;
        var number : int ; number := startingNumber ; while number <= endingNumber do ( (     result := result+(getRecyclingPairsCount(number, endingNumber)) )  ;     number := number + 1 ) ; 
    OclFile["System.out"].println("Case #" + test + ": " + result) ; 
 )  ;     test := test + 1 ) )   catch (e : ProgramException) do (     OclFile["System.err"].println("Error:" + e.getMessage()) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package qualification ;
import java.io.*;
import java.util.*;
public class C_RecycledNumbers {
  private static String ID="C" ;
  private static String NAME="large" ;
  private static boolean STANDARD_OUTPUT=false ;
  public static void main(String[] args)throws Throwable {
    int[][] results=new int[2000001][];
    for(int i=0 ; i<results.length ; i++){
      int array[]=new int[8],n=0 ;
      String s=""+i ;
      loop : for(int p=1 ;
      p<s.length();
      p++)if(s.charAt(p)!='0'){
        int j=Integer.parseInt(s.substring(p)+s.substring(0,p));
        if(j<=i)continue loop ;
        for(int q=0 ; q<n ; q++)if(array[q]==j)continue loop ;
        if(array.length==n)array=Arrays.copyOf(array,n*2);
        array[n++]=j ;
      }
      results[i]=Arrays.copyOf(array,n);
      Arrays.sort(results[i]);
    }
    BufferedReader reader=new BufferedReader(new FileReader(new File("data/"+ID+"-"+NAME+".in")));
    if(! STANDARD_OUTPUT)System.setOut(new PrintStream(new File("data/"+ID+"-"+NAME+".out")));
    for(int c=1,T=Integer.parseInt(reader.readLine()); c<=T ; c++){
      String w[]=reader.readLine().trim().split("+");
      int A=Integer.parseInt(w[0]),B=Integer.parseInt(w[1]);
      int count=0 ;
      for(int i=A ; i<=B ; i++){
        for(int x : results[i])if(x<=B)count++;
      }
      System.out.println("Case #"+c+": "+count);
    }
    if(! STANDARD_OUTPUT)System.out.close();
    reader.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C_RecycledNumbers {
  static   attribute ID : String := "C";
  static   attribute NAME : String := "large";
  static   attribute STANDARD_OUTPUT : boolean := false;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var results : Sequence(Sequence(int)) ; results := Integer.subrange(1,2000001)->collect(Sequence{}) ;
         var i : int ; i := 0 ; while i < results->size() do ( (     var array : Sequence(int) ; array := Integer.subrange(1,8)->collect(0) ;
    var n : int ; n := 0 ;
     var s : String ; s := "" + i ;
        var p : int ; p := 1 ; while p < s->size() do (     if (s->at(p+1) /= '0') then (     var j : int ; j := (s.subrange(p+1,p) + s.subrange(0+1,p))->toInteger() ;
     if (j <= i) then     continue else skip ; 
        var q : int ; q := 0 ; while q < n do (     if (array[q+1] = j) then     continue else skip ;  ;     q := q + 1 ) ; 
    if (array->size() = n) then     array := array.subrange(1,n * 2) ; else skip ; 
     array[n+1] := j  ; n := n + 1 ; 
 ) else skip ;  ;     p := p + 1 ) ; 
    results[i+1] := array.subrange(1,n) ; 
    results[i+1] := results[i+1]->sort() ; 
 )  ;     i := i + 1 ) ; 
    var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile("data/" + ID + "-" + NAME + ".in"))) ;
    if (not(STANDARD_OUTPUT)) then setOut(OclFile.newOclFile_Write(OclFile("data/" + ID + "-" + NAME + ".out"))) ; else skip ; 
        var c : int ; c := 1 ;
    var T : int ; T := (reader.readLine())->toInteger() ; while c <= T do ( (     var w : Sequence(String) ; w := reader.readLine()->trim()->split("+") ;
     var A : int ; A := (w[0+1])->toInteger() ;
    var B : int ; B := (w[1+1])->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := A ; while i <= B do ( (     for (x : results[i+1]) do (     if (x <= B) then     count := count + 1 ; else skip ;  ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Case #" + c + ": " + count) ; 
 )  ;     c := c + 1 ) ; 
    if (not(STANDARD_OUTPUT)) then     OclFile["System.out"].close() ; else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileInputStream ;
import java.io.FileOutputStream ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    FileInputStream fis=new FileInputStream(new File("in.txt"));
    FileOutputStream fos=new FileOutputStream(new File("out.txt"));
    Scanner sc=new Scanner(fis);
    PrintWriter out=new PrintWriter(fos);
    int cases=sc.nextInt();
    for(int cs=1 ; cs<=cases ; cs++){
      int begin=sc.nextInt();
      int end=sc.nextInt();
      int cnt=0 ;
      for(int n=begin ; n<=end ; n++){
        int weishu=getWeishu(n);
        int cur=getNext(n,weishu);
        while(cur!=n){
          if(cur>n && cur<=end && getWeishu(cur)==weishu)cnt++;
          cur=getNext(cur,weishu);
        }
      }
      out.println("Case #"+cs+": "+cnt);
    }
    sc.close();
    out.close();
  }
  public static int getNext(int n,int weishu){
    return n % 10*getTens(weishu-1)+n/10 ;
  }
  private static int getTens(int n){
    int res=1 ;
    for(int i=0 ; i<n ; i++)res*=10 ;
    return res ;
  }
  private static int getWeishu(int n){
    int weishu=1 ;
    int nweishu=10 ;
    while(n>=nweishu){
      nweishu*=10 ;
      weishu++;
    }
    return weishu ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fis : OclFile ; fis := OclFile.newOclFile_Read(OclFile("in.txt")) ;
     var fos : OclFile ; fos := OclFile.newOclFile_Write(OclFile("out.txt")) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(fis) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(fos) ;
    var cases : int ; cases := sc.getCurrent()->toInteger() ;
        var cs : int ; cs := 1 ; while cs <= cases do ( (     var begin : int ; begin := sc.getCurrent()->toInteger() ;
     var end : int ; end := sc.getCurrent()->toInteger() ;
    var cnt : int ; cnt := 0 ;
        var n : int ; n := begin ; while n <= end do ( (     var weishu : int ; weishu := getWeishu(n) ;
     var cur : int ; cur := getNext(n, weishu) ;
     while (cur /= n) do (     if (cur > n & cur <= end & getWeishu(cur) = weishu) then     cnt := cnt + 1 ; else skip ; 
     cur := getNext(cur, weishu) ) )  ;     n := n + 1 ) ; 
    skip ; 
 )  ;     cs := cs + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation getNext( n : int, weishu : int) : int
  pre: true
  post: true
  activity: (     return n mod 10 * getTens(weishu - 1) + n / 10 );
  static   operation getTens( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
         var i : int ; i := 0 ; while i < n do (     res := res*(10) ;  ;     i := i + 1 ) ; 
     return res );
  static   operation getWeishu( n : int) : int
  pre: true
  post: true
  activity: (     var weishu : int ; weishu := 1 ;
     var nweishu : int ; nweishu := 10 ;
     while (n >= nweishu) do (     nweishu := nweishu*(10) ; 
     weishu := weishu + 1 ) ; 
     return weishu );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package gcj;
import java.util.*;
import java.io.*;
public class RecycledNumbers {
    final static String PROBLEM_NAME = "rnum";
    final static String WORK_DIR = "D:\\Gcj\\" + PROBLEM_NAME + "\\";
    void solve(Scanner sc, PrintWriter pw) {
        int A = sc.nextInt();
        int B = sc.nextInt();
        int res = 0;
        for (int n = A; n <= B; n++) {
            String s = "" + n;
            Set<Integer> cand = new HashSet<Integer>();
            for (int st = 1; st < s.length(); st++) {
                String ss = s.substring(st) + s.substring(0, st);
                int m = Integer.parseInt(ss);
                if (n < m && m >= A && m <= B) {
                    cand.add(m);
                }
            }
            res += cand.size();
        }
        pw.println(res);
    }
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(new FileReader(WORK_DIR + "input.txt"));
        PrintWriter pw = new PrintWriter(new FileWriter(WORK_DIR + "output.txt"));
        int caseCnt = sc.nextInt();
        for (int caseNum = 0; caseNum < caseCnt; caseNum++) {
            System.out.println("Processing test case " + (caseNum + 1));
            pw.print("Case #" + (caseNum + 1) + ": ");
            new RecycledNumbers().solve(sc, pw);
        }
        pw.flush();
        pw.close();
        sc.close();
    }
}

------------------------------------------------------------
OCL File:
---------
 class RecycledNumbers {
  static   attribute PROBLEM_NAME : String := "rnum";
  static   attribute WORK_DIR : String := "D:\\Gcj\\" + PROBLEM_NAME + "\\";
   operation solve( sc : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var A : int ; A := sc.nextInt() ;
     var B : int ; B := sc.nextInt() ;
    var res : int ; res := 0 ;
        var n : int ; n := A ; while n <= B do ( (     var s : String ; s := "" + n ;
     var cand : Set(int) ; cand := Set{} ;
         var st : int ; st := 1 ; while st < s->size() do ( (     var ss : String ; ss := s.subrange(st+1,st) + s.subrange(0+1,st) ;
     var m : int ; m := (ss)->toInteger() ;
     if (n < m & m >= A & m <= B) then (     cand := cand->including(m) ) else skip )  ;     st := st + 1 ) ; 
     res := res+(cand->size()) )  ;     n := n + 1 ) ; 
    pw.println(res) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(WORK_DIR + "input.txt")) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(WORK_DIR + "output.txt")) ;
    var caseCnt : int ; caseCnt := sc.getCurrent()->toInteger() ;
        var caseNum : int ; caseNum := 0 ; while caseNum < caseCnt do ( (     OclFile["System.out"].println("Processing test case " + (caseNum + 1)) ; 
     skip ; 
     RecycledNumbers.newRecycledNumbers().solve(sc, pw) )  ;     caseNum := caseNum + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sum(int k,int n){
    int sum=(int)(Math.pow(k,n+1)-Math.pow(k-1,n+1));
    return sum ;
  }
  public static void main(String args[]){
    int n=3 ;
    int K=3 ;
    System.out.print(sum(K,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sum( k : int, n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := (k->pow(n + 1) - k - 1->pow(n + 1))->oclAsType(int) ;
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var K : int ; K := 3 ;
     OclFile["System.out"].print(sum(K, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class FriendsDecision {
  static int count=0 ;
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    sc.nextLine();
    String[] arr=new String[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextLine();
      decision(arr[i]);
    }
    System.out.println(count);
  }
  private static void decision(String entery){
    int localct=0 ;
    String[] inputs=entery.split(" ");
    for(int i=0 ; i<inputs.length ; i++){
      if(inputs[i] .equals("1"))localct++;
    }
    if(localct>1)count++;
  }
}
------------------------------------------------------------
OCL File:
---------
 class FriendsDecision {
  static   attribute count : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
    var arr : Sequence(String) ; arr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.nextLine() ; 
     execute decision(arr[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation decision( entery : String) : void
  pre: true
  post: true
  activity: (     var localct : int ; localct := 0 ;
     var inputs : Sequence(String) ; inputs := entery->split(" ") ;
         var i : int ; i := 0 ; while i < inputs->size() do ( (     if (inputs[i+1] = "1") then     localct := localct + 1 ; else skip )  ;     i := i + 1 ) ; 
     if (localct > 1) then     count := count + 1 ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static final int INF=1_000_000_000 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long K=sc.nextLong();
    int[] A=new int[N+1];
    for(int i=1 ; i<=N ; i++){
      A[i]=sc.nextInt();
    }
    if(K<=N){
      int pos=1 ;
      for(int i=0 ; i<K ; i++){
        pos=A[pos];
      }
      System.out.println(pos);
      return ;
    }
    boolean[] visited=new boolean[N+1];
    int x=1 ;
    while(! visited[x]){
      visited[x]=true ;
      x=A[x];
    }
    int preLen=0 ;
    int pos=1 ;
    while(pos!=x){
      pos=A[pos];
      preLen++;
    }
    int len=1 ;
    pos=A[x];
    while(pos!=x){
      pos=A[pos];
      len++;
    }
    int modPos=(int)((K-preLen)% len);
    int ans=x ;
    for(int i=0 ; i<modPos ; i++){
      ans=A[ans];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := 1_000_000_000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : long ; K := sc.getCurrent()->toLong() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (K <= N) then (     var pos : int ; pos := 1 ;
         var i : int ; i := 0 ; while i < K do ( (     pos := A[pos+1] )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(pos) ; 
     return ) else skip ; 
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,N + 1)->collect(false) ;
    var x : int ; x := 1 ;
    while (not(visited[x+1])) do (     visited[x+1] := true ; 
     x := A[x+1] ) ; 
    var preLen : int ; preLen := 0 ;
    var pos : int ; pos := 1 ;
    while (pos /= x) do (     pos := A[pos+1] ; 
     preLen := preLen + 1 ) ; 
    var len : int ; len := 1 ;
    pos := A[x+1] ; 
    while (pos /= x) do (     pos := A[pos+1] ; 
     len := len + 1 ) ; 
    var modPos : int ; modPos := ((K - preLen) mod len)->oclAsType(int) ;
    var ans : int ; ans := x ;
        var i : int ; i := 0 ; while i < modPos do ( (     ans := A[ans+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    int[][] arr=new int[num][3];
    for(int x=0 ; x<num ; x++){
      for(int y=0 ; y<3 ; y++){
        arr[x][y]=sc.nextInt();
      }
    }
    int imp=0 ;
    for(int x=0 ; x<num ; x++){
      int sum=0 ;
      for(int y=0 ; y<3 ; y++){
        sum+=arr[x][y];
      }
      if(sum>=2){
        imp++;
      }
    }
    System.out.println(imp);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,num)->collect(Integer.subrange(1,3)->collect(0)) ;
        var x : int ; x := 0 ; while x < num do ( (         var y : int ; y := 0 ; while y < 3 do ( (     arr[x+1][y+1] := sc.getCurrent()->toInteger() )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
    var imp : int ; imp := 0 ;
        var x : int ; x := 0 ; while x < num do ( (     var sum : int ; sum := 0 ;
         var y : int ; y := 0 ; while y < 3 do ( (     sum := sum+(arr[x+1][y+1]) )  ;     y := y + 1 ) ; 
     if (sum >= 2) then (     imp := imp + 1 ) else skip )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println(imp) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
class GFG {
  public static int nthTerm(int N){
    int nth=0,i ;
    for(i=N ; i>0 ; i--){
      nth+=Math.pow(i,i);
    }
    return nth ;
  }
  public static void main(String[] args){
    int N=3 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nthTerm( N : int) : int
  pre: true
  post: true
  activity: (     var nth : int ; nth := 0 ;
    var i : int ;
         i := N ; while i > 0 do ( (     nth := nth+(i->pow(i)) )  ;     i := i - 1 ) ; 
     return nth );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
     OclFile["System.out"].println(nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CodeChef {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int count=0 ;
    while(t-->0){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      if((a==1 && b==1)||(a==1 && c==1)||(b==1 && c==1)||(a==1 && b==1 && c==1)){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeChef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
     if ((a = 1 & b = 1) or (a = 1 & c = 1) or (b = 1 & c = 1) or (a = 1 & b = 1 & c = 1)) then (     count := count + 1 ) else skip ) ;  ) ;  
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    short n=in.nextShort();
    short sum=0,temp=0 ;
    byte[][] array=new byte[n][3];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<3 ; j++){
        array[i][j]=in.nextByte();
      }
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<3 ; j++){
        sum+=array[i][j];
      }
      if(sum>=2){
        temp+=1 ;
      }
      sum=0 ;
    }
    System.out.println(temp);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.nextShort() ;
    var sum : int ; sum := 0 ;
    var temp : int ; temp := 0 ;
    var array : Sequence(Sequence(int)) ; array := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 3 do ( (     array[i+1][j+1] := in.nextByte() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 3 do ( (     sum := sum+(array[i+1][j+1]) )  ;     j := j + 1 ) ; 
     if (sum >= 2) then (     temp := temp+(1) ) else skip ; 
     sum := 0 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(temp) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class team {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String t=sc.nextLine();
    int ans=0 ;
    for(int i=0 ; i<Integer.parseInt(t); i++){
      int count1=0 ;
      int count0=0 ;
      String input=sc.nextLine();
      String[] nums=input.split(" ");
      for(int j=0 ; j<3 ; j++){
        if(nums[j] .equals("1")){
          count1++;
        }
        else {
          count0++;
        }
      }
      if(count1>count0){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class team {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : String ; t := sc.nextLine() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < (t)->toInteger() do ( (     var count1 : int ; count1 := 0 ;
     var count0 : int ; count0 := 0 ;
    var input : String ; input := sc.nextLine() ;
    var nums : Sequence(String) ; nums := input->split(" ") ;
        var j : int ; j := 0 ; while j < 3 do ( (     if (nums[j+1] = "1") then (     count1 := count1 + 1 ) else (     count0 := count0 + 1 ) )  ;     j := j + 1 ) ; 
    if (count1 > count0) then (     ans := ans + 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countSubarrays(int a[],int n,int x){
    int count=0 ;
    int number=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]>x){
        count+=1 ;
      }
      else {
        number+=(count)*(count+1)/2 ;
        count=0 ;
      }
    }
    if(count!=0)number+=(count)*(count+1)/2 ;
    return number ;
  }
  public static void main(String[] args){
    int a[]={
      3,4,5,6,7,2,10,11 };
      int n=a.length ;
      int k=5 ;
      System.out.println(countSubarrays(a,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSubarrays( a : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var number : int ; number := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] > x) then (     count := count+(1) ) else (     number := number+((count) * (count + 1) / 2) ; 
     count := 0 ) )  ;     i := i + 1 ) ; 
    if (count /= 0) then     number := number+((count) * (count + 1) / 2) ; else skip ; 
    return number 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{3,4,5,6,7,2,10,11} ;
     var n : int ; n := a->size() ;
     var k : int ; k := 5 ;
     OclFile["System.out"].println(countSubarrays(a, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minCost(int arr[],int n){
    int count_even=0 ;
    int count_odd=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] % 2==0)count_even++;
      else count_odd++;
    }
    return Math.min(count_even,count_odd);
  }
  public static void main(String[] args){
    int arr[]={
      2,4,3,1,5 };
      int n=arr.length ;
      System.out.println(minCost(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minCost( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count_even : int ; count_even := 0 ;
     var count_odd : int ; count_odd := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 = 0) then     count_even := count_even + 1 ; else     count_odd := count_odd + 1 ; )  ;     i := i + 1 ) ; 
     return Set{count_even, count_odd}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,3,1,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minCost(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static void printLastOccurrence(int a[],int n){
    HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++)map.put(a[i],i);
    for(int i=0 ; i<n ; i++){
      if(map.get(a[i])==i)System.out.print(a[i]+" ");
    }
  }
  public static void main(String[] args){
    int a[]={
      1,5,5,1,6,1 };
      int n=a.length ;
      printLastOccurrence(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printLastOccurrence( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var map : Map(int,int) ; map := Map{} ;
         var i : int ; i := 0 ; while i < n do (     map := map->union(Map{a[i+1] |-> i}) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (map->at(a[i+1]) = i) then     OclFile["System.out"].print(a[i+1] + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,5,5,1,6,1} ;
     var n : int ; n := a->size() ;
     execute printLastOccurrence(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0){
        return ;
      }
      int up1=0,up2=0 ;
      int[] k=new int[n];
      for(int i=0 ; i<n ; i++){
        k[i]=sc.nextInt();
        if(k[i]>0){
          up1++;
          if(k[i]>=2){
            up2++;
          }
        }
      }
      if(up2==0){
        System.out.println("NA");
      }
      else {
        System.out.println(up1+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     return ) else skip ; 
    var up1 : int ; up1 := 0 ;
    var up2 : int ; up2 := 0 ;
    var k : Sequence(int) ; k := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     k[i+1] := sc.getCurrent()->toInteger() ; 
     if (k[i+1] > 0) then (     up1 := up1 + 1 ; 
     if (k[i+1] >= 2) then (     up2 := up2 + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (up2 = 0) then (     OclFile["System.out"].println("NA") ) else (     OclFile["System.out"].println(up1 + 1) ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int N=parseInt(line);
      if(N==0)break ;
      int ans=0 ;
      boolean a=false ;
      StringTokenizer st=new StringTokenizer(br.readLine());
      while(st.hasMoreTokens()){
        int k=parseInt(st.nextToken());
        if(k>0)ans++;
        if(k>1)a |=true ;
      }
      System.out.println(a ? ans+1 : "NA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var N : int ; N := parseInt(line) ;
     if (N = 0) then     break else skip ; 
    var ans : int ; ans := 0 ;
    var a : boolean ; a := false ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    while (st.hasNext()) do (     var k : int ; k := parseInt(st.next()) ;
     if (k > 0) then     ans := ans + 1 ; else skip ; 
     if (k > 1) then     a := MathLib.bitwiseOr(a, true) ; else skip ) ; 
    OclFile["System.out"].println(if a then ans + 1 else "NA" endif) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String args[])throws Exception {
    BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
    String s[]=bu.readLine().split(" ");
    int n=Integer.parseInt(s[0]),i,a[]=new int[n+1];
    long k=Long.parseLong(s[1]);
    s=bu.readLine().split(" ");
    int pos=1,l=1 ;
    for(i=0 ; i<n ; i++)a[i+1]=Integer.parseInt(s[i]);
    ArrayList<Integer>path=new ArrayList<>();
    HashMap<Integer,Integer>hm=new HashMap<>();
    path.add(1);
    hm.put(1,1);
    while(true){
      pos=a[pos];
      if(hm.get(pos)==null){
        path.add(pos);
        hm.put(pos,path.size());
      }
      else {
        l=hm.get(pos);
        break ;
      }
    }
    if(k<path.size()){
      System.out.print(a[path.get((int)(k-1))]);
      return ;
    }
    l--;
    k-=l ;
    k %=(path.size()-l);
    k--;
    if(k==-1)k=path.size()-l-1 ;
    System.out.print(a[path.get((int)(l+k))]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bu : OclFile ; bu := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : Sequence(String) ; s := bu.readLine()->split(" ") ;
    var n : int ; n := (s[0+1])->toInteger() ;
    var i : int ;
    var a : Sequence(void) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var k : long ; k := (s[1+1])->toLong() ;
    s := bu.readLine()->split(" ") ; 
    var pos : int ; pos := 1 ;
    var l : int ; l := 1 ;
        i := 0 ; while i < n do (     a[i + 1+1] := (s[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var path : Sequence(int) ; path := Sequence{} ;
    var hm : Map(int,int) ; hm := Map{} ;
    path := path->including(1) ; 
    hm := hm->union(Map{1 |-> 1}) ; 
    while (true) do (     pos := a[pos+1] ; 
     if (hm->at(pos) = null) then (     path := path->including(pos) ; 
     hm := hm->union(Map{pos |-> path->size()}) ) else (     l := hm->at(pos) ; 
     break ) ) ; 
    if (k < path->size()) then (     OclFile["System.out"].print(a[path->at((k - 1)->oclAsType(int)+1)+1]) ; 
     return ) else skip ; 
    l := l - 1 ; 
    k := k-(l) ; 
    k := k mod (path->size() - l) ; 
    k := k - 1 ; 
    if (k = -1) then     k := path->size() - l - 1 ; else skip ; 
    OclFile["System.out"].print(a[path->at((l + k)->oclAsType(int)+1)+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  final int N=12 ;
  final int[][] ofs={
    {
      1,0 },{
        0,-1 },{
-1,0 },{
            0,1 }
          };
          void del(boolean[][] map,int y,int x){
            map[y][x]=false ;
            for(int i=0 ; i<4 ; ++i){
              int nx=x+ofs[i][0];
              int ny=y+ofs[i][1];
              if(0<=ny && ny<N && 0<=nx && nx<N){
                if(map[ny][nx]){
                  del(map,ny,nx);
                }
              }
            }
          }
          int solve(boolean map[][]){
            int c=0 ;
            for(int y=0 ; y<N ; ++y){
              for(int x=0 ; x<N ; ++x){
                if(map[y][x]){
                  c++;
                  del(map,y,x);
                }
              }
            }
            return c ;
          }
          void io(){
            Scanner sc=new Scanner(System.in);
            while(sc.hasNext()){
              char[][] str=new char[N][N];
              for(int i=0 ; i<N ; ++i){
                str[i]=sc.nextLine().toCharArray();
              }
              boolean[][] map=new boolean[N][N];
              for(int y=0 ; y<N ; ++y){
                for(int x=0 ; x<N ; ++x){
                  map[y][x]=str[y][x]=='1' ;
                }
              }
              System.out.println(solve(map));
              if(sc.hasNext()){
                sc.nextLine();
              }
            }
          }
          public static void main(String[] args){
            new Main().io();
          }
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute N : int := 12;
   attribute ofs : Sequence(Sequence(int)) := Sequence{Sequence{1,0},Sequence{0,-1},Sequence{-1,0},Sequence{0,1}};
   operation del( map : Sequence(Sequence(boolean)), y : int, x : int) : void
  pre: true
  post: true
  activity: (     map[y+1][x+1] := false ; 
         var i : int ; i := 0 ; while i < 4 do ( (     var nx : int ; nx := x + ofs[i+1][0+1] ;
     var ny : int ; ny := y + ofs[i+1][1+1] ;
     if (0 <= ny & ny < N & 0 <= nx & nx < N) then (     if (map[ny+1][nx+1]) then (     execute del(map, ny, nx) ) else skip ) else skip )  ;     i := i + 1 ) );
   operation solve( map : Sequence(Sequence(boolean))) : int
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
         var y : int ; y := 0 ; while y < N do ( (         var x : int ; x := 0 ; while x < N do ( (     if (map[y+1][x+1]) then (     c := c + 1 ; 
     execute del(map, y, x) ) else skip )  ;     x := x + 1 ) )  ;     y := y + 1 ) ; 
     return c );
   operation io() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var str : Sequence(Sequence(String)) ; str := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
         var i : int ; i := 0 ; while i < N do ( (     str[i+1] := sc.nextLine()->characters() )  ;     i := i + 1 ) ; 
    var map : Sequence(Sequence(boolean)) ; map := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(false)) ;
        var y : int ; y := 0 ; while y < N do ( (         var x : int ; x := 0 ; while x < N do ( (     map[y+1][x+1] := str[y+1][x+1] = '1' )  ;     x := x + 1 ) )  ;     y := y + 1 ) ; 
    OclFile["System.out"].println(solve(map)) ; 
    if (sc.hasNext()) then (     skip ) else skip ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().io() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int syu ;
  int nok ;
  int chaka ;
  int gokei ;
  public void solve(){
    Scanner sc=new Scanner(System.in);
    syu=sc.nextInt();
    while(syu!=0){
      gokei=0 ;
      chaka=1 ;
      for(int i=1 ; i<=syu ; i++){
        nok=sc.nextInt();
        if(nok>=2){
          gokei=gokei+1 ;
        }
        if(nok>0){
          chaka=chaka+1 ;
        }
      }
      if(gokei>0){
        System.out.println(chaka);
      }
      else {
        System.out.println("NA");
      }
      syu=sc.nextInt();
    }
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute syu : int;
   attribute nok : int;
   attribute chaka : int;
   attribute gokei : int;
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     syu := sc.getCurrent()->toInteger() ; 
     while (syu /= 0) do (     gokei := 0 ; 
     chaka := 1 ; 
        var i : int ; i := 1 ; while i <= syu do ( (     nok := sc.getCurrent()->toInteger() ; 
     if (nok >= 2) then (     gokei := gokei + 1 ) else skip ; 
     if (nok > 0) then (     chaka := chaka + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (gokei > 0) then (     OclFile["System.out"].println(chaka) ) else (     OclFile["System.out"].println("NA") ) ;  
    syu := sc.getCurrent()->toInteger() ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.math.BigInteger ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    while(true){
      final int N=sc.nextInt();
      if(N==0){
        break ;
      }
      int[] count=new int[N];
      for(int i=0 ; i<N ; i++){
        count[i]=sc.nextInt();
      }
      boolean has_over_two=false ;
      int tring=0 ;
      for(int i=0 ; i<N ; i++){
        if(count[i]>=1){
          tring++;
          if(count[i]>=2 && ! has_over_two){
            has_over_two=true ;
          }
        }
      }
      System.out.println(has_over_two ?(tring+1)+"" : "NA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then (     break ) else skip ; 
    var count : Sequence(int) ; count := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     count[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var has_over_two : boolean ; has_over_two := false ;
    var tring : int ; tring := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (count[i+1] >= 1) then (     tring := tring + 1 ; 
     if (count[i+1] >= 2 & not(has_over_two)) then (     has_over_two := true ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if has_over_two then (tring + 1) + "" else "NA" endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  Main(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int a=sc.nextInt();
      int b ;
      int c=0 ;
      int d=1 ;
      int m=100000 ;
      boolean x=true ;
      if(a==0)break ;
      for(int i=0 ; i<a ; i++){
        b=sc.nextInt();
        if(b>=2){
          x=false ;
          c++;
        }
        if(b>0)d++;
      }
      if(x){
        System.out.println("NA");
      }
      else if(c==1){
        System.out.println(2);
      }
      else {
        System.out.println(d);
      }
    }
  }
  public static void main(String[] arg){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ;
    var c : int ; c := 0 ;
    var d : int ; d := 1 ;
    var m : int ; m := 100000 ;
    var x : boolean ; x := true ;
    if (a = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < a do ( (     b := sc.getCurrent()->toInteger() ; 
     if (b >= 2) then (     x := false ; 
     c := c + 1 ) else skip ; 
     if (b > 0) then     d := d + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (x) then (     OclFile["System.out"].println("NA") ) else     if (c = 1) then (     OclFile["System.out"].println(2) ) else (     OclFile["System.out"].println(d) ) ;  ;  
 ) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
class GFG {
  public int countPaths(int m,int n){
    if(m==1 || n==1)return 1 ;
    return countPaths(m-1,n)+countPaths(m,n-1);
  }
  public static void main(String args[]){
    GFG g=new GFG();
    int n=5,m=5 ;
    System.out.println(g.countPaths(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
   operation countPaths( m : int, n : int) : int
  pre: true
  post: true
  activity: (     if (m = 1 or n = 1) then     return 1 else skip ; 
     return countPaths(m - 1, n) + countPaths(m, n - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : GFG ; g := GFG.newGFG() ;
     var n : int ; n := 5 ;
    var m : int ; m := 5 ;
     OclFile["System.out"].println(g.countPaths(n, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float sumOfAP(float a,float d,float n){
    float sum=(n/2)*(2*a+(n-1)*d);
    return sum ;
  }
  public static void main(String[] args){
    float n=20 ;
    float a=2.5f,d=1.5f ;
    System.out.print(sumOfAP(a,d,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumOfAP( a : double, d : double, n : double) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := (n / 2) * (2 * a + (n - 1) * d) ;
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 20 ;
     var a : double ; a := 2.5f ;
    var d : double ; d := 1.5f ;
     OclFile["System.out"].print(sumOfAP(a, d, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static long countPairs(int arr[],int n){
    long count=0 ;
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        if(arr[i]*arr[j]>arr[i]+arr[j])count++;
      }
    }
    return count ;
  }
  public static void main(String args[]){
    int arr[]={
      5,0,3,1,2 };
      int n=arr.length ;
      System.out.println(countPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation countPairs( arr : Sequence(int), n : int) : long
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
         var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (arr[i+1] * arr[j+1] > arr[i+1] + arr[j+1]) then     count := count + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,0,3,1,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countPairs(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void coordinateCompression(int arr[],int n){
    Set<Integer>s=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      s.add(arr[i]);
    }
    int index=0 ;
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(int itr : s){
      index++;
      mp.put(itr,index);
    }
    for(int i=0 ; i<n ; i++){
      arr[i]=mp.get(arr[i]);
    }
  }
  static int query(int BIT[],int index,int n){
    int ans=0 ;
    while(index>0){
      ans=Math.max(ans,BIT[index]);
      index-=index &(-index);
    }
    return ans ;
  }
  static void update(int BIT[],int index,int n){
    int x=query(BIT,index-1,n);
    int value=x+1 ;
    while(index<=n){
      BIT[index]=Math.max(BIT[index],value);
      index+=index &(-index);
    }
  }
  static int findLISLength(int arr[],int n){
    coordinateCompression(arr,n);
    int[] BIT=new int[n+1];
    for(int i=0 ; i<=n ; i++){
      BIT[i]=0 ;
    }
    for(int i=0 ; i<n ; i++){
      update(BIT,arr[i],n);
    }
    int ans=query(BIT,n,n);
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      6,5,1,3,2,4,8,7 };
      int n=arr.length ;
      int ans=findLISLength(arr,n);
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation coordinateCompression( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     s := s->including(arr[i+1]) )  ;     i := i + 1 ) ; 
    var index : int ; index := 0 ;
    var mp : Map(int,int) ; mp := Map{} ;
    for (itr : s) do ( (     index := index + 1 ; 
     mp := mp->union(Map{itr |-> index}) )  ) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := mp->at(arr[i+1]) )  ;     i := i + 1 ) ; 
 );
  static   operation query( BIT : Sequence(int), index : int, n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     while (index > 0) do (     ans := Set{ans, BIT[index+1]}->max() ; 
     index := index-(MathLib.bitwiseAnd(index,(-index))) ) ; 
     return ans );
  static   operation update( BIT : Sequence(int), index : int, n : int) : void
  pre: true
  post: true
  activity: (     var x : int ; x := query(BIT, index - 1, n) ;
     var value : int ; value := x + 1 ;
     while (index <= n) do (     BIT[index+1] := Set{BIT[index+1], value}->max() ; 
     index := index+(MathLib.bitwiseAnd(index,(-index))) ) );
  static   operation findLISLength( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     execute coordinateCompression(arr, n) ; 
     var BIT : Sequence(int) ; BIT := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i <= n do ( (     BIT[i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     execute update(BIT, arr[i+1], n) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := query(BIT, n, n) ;
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,5,1,3,2,4,8,7} ;
     var n : int ; n := arr->size() ;
     var ans : int ; ans := findLISLength(arr, n) ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Groups {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int Q=Integer.parseInt(br.readLine());
    for(int i=0 ; i<Q ; i++){
      int N=Integer.parseInt(br.readLine());
      int[][] schedule=new int[N][5];
      int x=0 ;
      for(int j=0 ; j<N ; j++){
        String line=br.readLine();
        StringTokenizer sr=new StringTokenizer(line);
        for(int k=0 ; k<5 ; k++){
          schedule[x][k]=Integer.parseInt(sr.nextToken());
        }
        x++;
      }
      boolean check=false ;
      outer : for(int j=0 ;
      j<4 ;
      j++){
        for(int k=j+1 ; k<5 ; k++){
          int day1count=0 ;
          int day2count=0 ;
          int bothcount=0 ;
          int neither=0 ;
          for(int l=0 ; l<schedule.length ; l++){
            if(schedule[l][j]==0 && schedule[l][k]==0){
              neither++;
            }
            if(schedule[l][j]==1 && schedule[l][k]==0){
              day1count++;
            }
            else if(schedule[l][j]==0 && schedule[l][k]==1){
              day2count++;
            }
            else if(schedule[l][j]==1 && schedule[l][k]==1){
              bothcount++;
            }
          }
          if(neither>0){
            continue ;
          }
          else if(day1count>schedule.length/2 || day2count>schedule.length/2){
            continue ;
          }
          else {
            check=true ;
            break outer ;
          }
        }
      }
      System.out.println(check ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Groups {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var Q : int ; Q := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < Q do ( (     var N : int ; N := (br.readLine())->toInteger() ;
     var schedule : Sequence(Sequence(int)) ; schedule := Integer.subrange(1,N)->collect(Integer.subrange(1,5)->collect(0)) ;
    var x : int ; x := 0 ;
        var j : int ; j := 0 ; while j < N do ( (     var line : String ; line := br.readLine() ;
     var sr : OclIterator ; sr := OclIterator.newOclIterator_String(line) ;
         var k : int ; k := 0 ; while k < 5 do ( (     schedule[x+1][k+1] := (sr.next())->toInteger() )  ;     k := k + 1 ) ; 
     x := x + 1 )  ;     j := j + 1 ) ; 
    var check : boolean ; check := false ;
        var j : int ; j := 0 ; while j < 4 do ( (         var k : int ; k := j + 1 ; while k < 5 do ( (     var day1count : int ; day1count := 0 ;
     var day2count : int ; day2count := 0 ;
    var bothcount : int ; bothcount := 0 ;
    var neither : int ; neither := 0 ;
        var l : int ; l := 0 ; while l < schedule->size() do ( (     if (schedule[l+1][j+1] = 0 & schedule[l+1][k+1] = 0) then (     neither := neither + 1 ) else skip ; 
     if (schedule[l+1][j+1] = 1 & schedule[l+1][k+1] = 0) then (     day1count := day1count + 1 ) else     if (schedule[l+1][j+1] = 0 & schedule[l+1][k+1] = 1) then (     day2count := day2count + 1 ) else     if (schedule[l+1][j+1] = 1 & schedule[l+1][k+1] = 1) then (     bothcount := bothcount + 1 ) else skip ; ;  )  ;     l := l + 1 ) ; 
    if (neither > 0) then (     continue ) else     if (day1count > schedule->size() / 2 or day2count > schedule->size() / 2) then (     continue ) else (     check := true ; 
     break ) ;  ;  
 )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(if check then "YES" else "NO" endif) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Groups {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int Q=Integer.parseInt(br.readLine());
    for(int i=0 ; i<Q ; i++){
      int N=Integer.parseInt(br.readLine());
      int[][] schedule=new int[N][5];
      int x=0 ;
      for(int j=0 ; j<N ; j++){
        String line=br.readLine();
        StringTokenizer sr=new StringTokenizer(line);
        for(int k=0 ; k<5 ; k++){
          schedule[x][k]=Integer.parseInt(sr.nextToken());
        }
        x++;
      }
      boolean check=false ;
      outer : for(int j=0 ;
      j<4 ;
      j++){
        for(int k=j+1 ; k<5 ; k++){
          int day1count=0 ;
          int day2count=0 ;
          int bothcount=0 ;
          int neither=0 ;
          inner : for(int l=0 ;
          l<schedule.length ;
          l++){
            if(schedule[l][j]==0 && schedule[l][k]==0){
              neither++;
            }
            if(schedule[l][j]==1 && schedule[l][k]==0){
              day1count++;
            }
            else if(schedule[l][j]==0 && schedule[l][k]==1){
              day2count++;
            }
            else if(schedule[l][j]==1 && schedule[l][k]==1){
              bothcount++;
            }
          }
          if(neither>0){
            continue ;
          }
          else if(day1count>schedule.length/2 || day2count>schedule.length/2){
            continue ;
          }
          else {
            check=true ;
            break outer ;
          }
        }
      }
      System.out.println(check ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Groups {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var Q : int ; Q := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < Q do ( (     var N : int ; N := (br.readLine())->toInteger() ;
     var schedule : Sequence(Sequence(int)) ; schedule := Integer.subrange(1,N)->collect(Integer.subrange(1,5)->collect(0)) ;
    var x : int ; x := 0 ;
        var j : int ; j := 0 ; while j < N do ( (     var line : String ; line := br.readLine() ;
     var sr : OclIterator ; sr := OclIterator.newOclIterator_String(line) ;
         var k : int ; k := 0 ; while k < 5 do ( (     schedule[x+1][k+1] := (sr.next())->toInteger() )  ;     k := k + 1 ) ; 
     x := x + 1 )  ;     j := j + 1 ) ; 
    var check : boolean ; check := false ;
        var j : int ; j := 0 ; while j < 4 do ( (         var k : int ; k := j + 1 ; while k < 5 do ( (     var day1count : int ; day1count := 0 ;
     var day2count : int ; day2count := 0 ;
    var bothcount : int ; bothcount := 0 ;
    var neither : int ; neither := 0 ;
        var l : int ; l := 0 ; while l < schedule->size() do ( (     if (schedule[l+1][j+1] = 0 & schedule[l+1][k+1] = 0) then (     neither := neither + 1 ) else skip ; 
     if (schedule[l+1][j+1] = 1 & schedule[l+1][k+1] = 0) then (     day1count := day1count + 1 ) else     if (schedule[l+1][j+1] = 0 & schedule[l+1][k+1] = 1) then (     day2count := day2count + 1 ) else     if (schedule[l+1][j+1] = 1 & schedule[l+1][k+1] = 1) then (     bothcount := bothcount + 1 ) else skip ; ;  )  ;     l := l + 1 ) ; 
    if (neither > 0) then (     continue ) else     if (day1count > schedule->size() / 2 or day2count > schedule->size() / 2) then (     continue ) else (     check := true ; 
     break ) ;  ;  
 )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(if check then "YES" else "NO" endif) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p164 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p164().run());
  }
  private static final int BASE=10 ;
  private static final int DIGITS=20 ;
  private static final int CONSECUTIVE=3 ;
  private static final int MAX_SUM=9 ;
  public String run(){
    BigInteger[][] ways=new BigInteger[DIGITS+CONSECUTIVE+1][Library.pow(BASE,CONSECUTIVE)];
    ways[0][0]=BigInteger.ONE ;
    for(int prefix=1 ; prefix<ways[0] .length ; prefix++)ways[0][prefix]=BigInteger.ZERO ;
    for(int digits=1 ; digits<ways.length ; digits++){
      for(int prefix=0 ; prefix<ways[digits] .length ; prefix++){
        BigInteger sum=BigInteger.ZERO ;
        if(digitSum(prefix)<=MAX_SUM){
          for(int nextDigit=0 ; nextDigit<BASE ; nextDigit++)sum=sum.add(ways[digits-1][prefix % Library.pow(BASE,CONSECUTIVE-1)*BASE+nextDigit]);
        }
        ways[digits][prefix]=sum ;
      }
    }
    return ways[DIGITS+CONSECUTIVE][0] .subtract(ways[DIGITS+CONSECUTIVE-1][0]).toString();
  }
  private static int digitSum(int n){
    int sum=0 ;
    for(; n!=0 ; n/=10)sum+=n % 10 ;
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class p164 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p164.newp164().run()) );
  static    attribute BASE : int := 10;
  static    attribute DIGITS : int := 20;
  static    attribute CONSECUTIVE : int := 3;
  static    attribute MAX_SUM : int := 9;
   operation run() : String
  pre: true
  post: true
  activity: (     var ways : Sequence(Sequence(long)) ; ways := Integer.subrange(1,DIGITS + CONSECUTIVE + 1)->collect(Integer.subrange(1,Library.pow(BASE, CONSECUTIVE))->collect(null)) ;
     ways[0+1][0+1] := 1 ; 
        var prefix : int ; prefix := 1 ; while prefix < ways[0+1]->size() do (     ways[0+1][prefix+1] := 0 ;  ;     prefix := prefix + 1 ) ; 
        var digits : int ; digits := 1 ; while digits < ways->size() do ( (         var prefix : int ; prefix := 0 ; while prefix < ways[digits+1]->size() do ( (     var sum : long ; sum := 0 ;
     if (digitSum(prefix) <= MAX_SUM) then (         var nextDigit : int ; nextDigit := 0 ; while nextDigit < BASE do (     sum := sum->excludes(ways[digits - 1+1][prefix mod Library.pow(BASE, CONSECUTIVE - 1) * BASE + nextDigit+1]) ;  ;     nextDigit := nextDigit + 1 ) ) else skip ; 
     ways[digits+1][prefix+1] := sum )  ;     prefix := prefix + 1 ) )  ;     digits := digits + 1 ) ; 
    return ways[DIGITS + CONSECUTIVE+1][0+1].subtract(ways[DIGITS + CONSECUTIVE - 1+1][0+1])+"" 
 );
  static   operation digitSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
       while n /= 0 do (     sum := sum+(n mod 10) ;  ;     n := n/(10) ) ; 
     return sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Test {
  public static void main(String[] args){
    System.out.println(isPower(10,1)? "True" : "False");
    System.out.println(isPower(1,20)? "True" : "False");
    System.out.println(isPower(2,128)? "True" : "False");
    System.out.println(isPower(2,30)? "True" : "False");
  }
  public static boolean isPower(int x,int y){
    if(x==1)return(y==1);
    int pow=1 ;
    while(pow<y)pow=pow*x ;
    return(pow==y);
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if isPower(10, 1) then "True" else "False" endif) ; 
     OclFile["System.out"].println(if isPower(1, 20) then "True" else "False" endif) ; 
     OclFile["System.out"].println(if isPower(2, 128) then "True" else "False" endif) ; 
     OclFile["System.out"].println(if isPower(2, 30) then "True" else "False" endif) );
  static   operation isPower( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     if (x = 1) then     return (y = 1) else skip ; 
     var pow : int ; pow := 1 ;
     while (pow < y) do     pow := pow * x ; ; 
     return (pow = y) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  final int MOD=1000000007 ;
  final int MAX=Integer.MAX_VALUE ;
  final long LMAX=Long.MAX_VALUE ;
  int len=(int)1e6+1 ;
  void doIt(){
    int N=sc.nextInt();
    long K=sc.nextLong();
    int A[]=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt()-1 ;
    }
    Set<Integer>used=new HashSet<>();
    int idx[]=new int[N];
    int pos[]=new int[N];
    int next=0,cur=0 ;
    while(! used.contains(next)){
      used.add(next);
      idx[next]=cur ;
      pos[cur]=next ;
      next=A[next];
      cur++;
    }
    long a=(long)cur-idx[next];
    long b=(long)idx[next];
    int ans=(int)((10000*a+K-b)% a+b);
    if(b>K)ans=(int)K ;
    System.out.println(pos[ans]+1);
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute MOD : int := 1000000007;
   attribute MAX : int := 2147483647;
   attribute LMAX : long := "9223372036854775807"->toLong();
   attribute len : int := 1e6->oclAsType(int) + 1;
   operation doIt() : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var K : long ; K := sc.getCurrent()->toLong() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() - 1 )  ;     i := i + 1 ) ; 
    var used : Set(int) ; used := Set{} ;
    var idx : Sequence(int) ; idx := Integer.subrange(1,N)->collect(0) ;
    var pos : Sequence(int) ; pos := Integer.subrange(1,N)->collect(0) ;
    var next : int ; next := 0 ;
    var cur : int ; cur := 0 ;
    while (not(used->includes(next))) do (     used := used->including(next) ; 
     idx[next+1] := cur ; 
    pos[cur+1] := next ; 
    next := A[next+1] ; 
    cur := cur + 1 ; 
 ) ; 
    var a : long ; a := cur->oclAsType(long) - idx[next+1] ;
    var b : long ; b := idx[next+1]->oclAsType(long) ;
    var ans : int ; ans := ((10000 * a + K - b) mod a + b)->oclAsType(int) ;
    if (b > K) then     ans := K->oclAsType(int) ; else skip ; 
    OclFile["System.out"].println(pos[ans+1] + 1) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.IllegalFormatCodePointException ;
import java.util.Scanner ;
public class Main {
  static ArrayList md=new ArrayList();
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String[] l=new String[4];
    l[0]=in.next();
    l[1]=in.next();
    l[2]=in.next();
    l[3]=in.next();
    char a ;
    boolean f=false ;
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<3 ; j++){
        a=l[i] .charAt(j);
        if(l[i] .charAt(j+1)==a){
          if(l[i+1] .charAt(j)==a || l[i+1] .charAt(j+1)==a){
            f=true ;
            break ;
          }
          else if(i>0 &&(l[i-1] .charAt(j)==a || l[i-1] .charAt(j+1)==a)){
            f=true ;
            break ;
          }
          else f=false ;
        }
        if(l[3] .charAt(j)==l[3] .charAt(j+1)&&(l[2] .charAt(j)==l[3] .charAt(j)|| l[2] .charAt(j+1)==l[3] .charAt(j+1))){
          f=true ;
          break ;
        }
      }
      if(f==true){
        break ;
      }
    }
    if(f==true){
      System.out.println("YES");
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute md : Sequence := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : Sequence(String) ; l := Integer.subrange(1,4)->collect(null) ;
    l[0+1] := in.getCurrent() ; 
    l[1+1] := in.getCurrent() ; 
    l[2+1] := in.getCurrent() ; 
    l[3+1] := in.getCurrent() ; 
    var a : String ;
    var f : boolean ; f := false ;
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     a := l[i+1]->at(j+1) ; 
     if (l[i+1]->at(j + 1+1) = a) then (     if (l[i + 1+1]->at(j+1) = a or l[i + 1+1]->at(j + 1+1) = a) then (     f := true ; 
     break ) else     if (i > 0 & (l[i - 1+1]->at(j+1) = a or l[i - 1+1]->at(j + 1+1) = a)) then (     f := true ; 
     break ) else     f := false ; ;  ) else skip ; 
     if (l[3+1]->at(j+1) = l[3+1]->at(j + 1+1) & (l[2+1]->at(j+1) = l[3+1]->at(j+1) or l[2+1]->at(j + 1+1) = l[3+1]->at(j + 1+1))) then (     f := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (f = true) then (     break ) else skip )  ;     i := i + 1 ) ; 
    if (f = true) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Mridul8 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String[] str=new String[4];
    int i=-1 ;
    while(i!=3){
      i=i+1 ;
      str[i]=sc.next();
    }
    int u=-1 ;
    i=-1 ;
    int yes=0 ;
    while(u!=2){
      u=u+1 ;
      i=-1 ;
      while(i!=2){
        i=i+1 ;
        if((str[u] .charAt(i)==str[u] .charAt(i+1)&&(str[u+1] .charAt(i)==str[u] .charAt(i)|| str[u+1] .charAt(i+1)==str[u] .charAt(i)))||(str[u+1] .charAt(i)==str[u+1] .charAt(i+1)&&(str[u] .charAt(i)==str[u+1] .charAt(i)|| str[u] .charAt(i+1)==str[u+1] .charAt(i)))){
          yes=1 ;
          System.out.println("YES");
          break ;
        }
      }
      if(yes==1){
        break ;
      }
    }
    if(yes==0){
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mridul8 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : Sequence(String) ; str := Integer.subrange(1,4)->collect(null) ;
    var i : int ; i := -1 ;
    while (i /= 3) do (     i := i + 1 ; 
     str[i+1] := sc.getCurrent() ) ; 
    var u : int ; u := -1 ;
    i := -1 ; 
    var yes : int ; yes := 0 ;
    while (u /= 2) do (     u := u + 1 ; 
     i := -1 ; 
     while (i /= 2) do (     i := i + 1 ; 
     if ((str[u+1]->at(i+1) = str[u+1]->at(i + 1+1) & (str[u + 1+1]->at(i+1) = str[u+1]->at(i+1) or str[u + 1+1]->at(i + 1+1) = str[u+1]->at(i+1))) or (str[u + 1+1]->at(i+1) = str[u + 1+1]->at(i + 1+1) & (str[u+1]->at(i+1) = str[u + 1+1]->at(i+1) or str[u+1]->at(i + 1+1) = str[u + 1+1]->at(i+1)))) then (     yes := 1 ; 
     OclFile["System.out"].println("YES") ; 
     break ) else skip ) ; 
     if (yes = 1) then (     break ) else skip ) ; 
    if (yes = 0) then (     OclFile["System.out"].println("NO") ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public boolean isToeplitzMatrix(int[][] matrix){
    for(int r=1 ; r<matrix.length ; ++r)for(int c=1 ; c<matrix[0] .length ; ++c)if(matrix[r-1][c-1]!=matrix[r][c])return false ;
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation isToeplitzMatrix( matrix : Sequence(Sequence(int))) : boolean
  pre: true
  post: true
  activity: (         var r : int ; r := 1 ; while r < matrix->size() do (         var c : int ; c := 1 ; while c < matrix[0+1]->size() do (     if (matrix[r - 1+1][c - 1+1] /= matrix[r+1][c+1]) then     return false else skip ;  ;     c := c + 1 ) ;  ;     r := r + 1 ) ; 
     return true );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p094 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p094().run());
  }
  private static final int LIMIT=Library.pow(10,9);
  public String run(){
    long sum=0 ;
    for(int s=1 ; s*s<=(LIMIT+1)/3 ; s+=2){
      for(int t=s-2 ; t>0 ; t-=2){
        if(Library.gcd(s,t)==1){
          int a=s*t ;
          int b=(s*s-t*t)/2 ;
          int c=(s*s+t*t)/2 ;
          if(a*2==c-1){
            int p=c*3-1 ;
            if(p<=LIMIT)sum+=p ;
          }
          if(a*2==c+1){
            int p=c*3+1 ;
            if(p<=LIMIT)sum+=p ;
          }
          if(b*2==c-1){
            int p=c*3-1 ;
            if(p<=LIMIT)sum+=p ;
          }
          if(b*2==c+1){
            int p=c*3+1 ;
            if(p<=LIMIT)sum+=p ;
          }
        }
      }
    }
    return Long.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
class p094 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p094.newp094().run()) );
  static    attribute LIMIT : int := Library.pow(10, 9);
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var s : int ; s := 1 ; while s * s <= (LIMIT + 1) / 3 do ( (         var t : int ; t := s - 2 ; while t > 0 do ( (     if (Library.gcd(s, t) = 1) then (     var a : int ; a := s * t ;
     var b : int ; b := (s * s - t * t) / 2 ;
    var c : int ; c := (s * s + t * t) / 2 ;
    if (a * 2 = c - 1) then (     var p : int ; p := c * 3 - 1 ;
     if (p <= LIMIT) then     sum := sum+(p) ; else skip ) else skip ; 
    if (a * 2 = c + 1) then (     var p : int ; p := c * 3 + 1 ;
     if (p <= LIMIT) then     sum := sum+(p) ; else skip ) else skip ; 
    if (b * 2 = c - 1) then (     var p : int ; p := c * 3 - 1 ;
     if (p <= LIMIT) then     sum := sum+(p) ; else skip ) else skip ; 
    if (b * 2 = c + 1) then (     var p : int ; p := c * 3 + 1 ;
     if (p <= LIMIT) then     sum := sum+(p) ; else skip ) else skip ; 
 ) else skip )  ;     t := t-(2) ) )  ;     s := s+(2) ) ; 
     return ((sum) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int N=sc.nextInt();
      int T=sc.nextInt();
      int L=sc.nextInt();
      int B=sc.nextInt();
      if(N==0 && T==0 && L==0 && B==0)break ;
      int[] square=new int[N+1];
      for(int i=0 ; i<L ; i++)square[sc.nextInt()]=1 ;
      for(int i=0 ; i<B ; i++)square[sc.nextInt()]=2 ;
      double[][] dp=new double[N+1][T+1];
      dp[0][0]=1 ;
      for(int j=0 ; j<T ; j++){
        for(int i=0 ; i<N ; i++){
          for(int s=1 ; s<=6 ; s++){
            int idx=1 ;
            int num=i+s ;
            if(square[i]==1)idx=2 ;
            if(i+s>N)num=2*N-(i+s);
            if(square[num]==2 && j+idx<=T){
              dp[0][j+idx]+=dp[i][j]*1.0/6 ;
            }
            else if(j+idx<=T){
              dp[num][j+idx]+=dp[i][j]*1.0/6 ;
            }
          }
        }
      }
      double goal=0.0 ;
      for(int i=0 ; i<=T ; i++)goal+=dp[N][i];
      System.out.printf("%.6f\n",goal);
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
    var L : int ; L := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    if (N = 0 & T = 0 & L = 0 & B = 0) then     break else skip ; 
    var square : Sequence(int) ; square := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < L do (     square[sc.getCurrent()->toInteger()+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < B do (     square[sc.getCurrent()->toInteger()+1] := 2 ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(double)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,T + 1)->collect(0.0)) ;
    dp[0+1][0+1] := 1 ; 
        var j : int ; j := 0 ; while j < T do ( (         var i : int ; i := 0 ; while i < N do ( (         var s : int ; s := 1 ; while s <= 6 do ( (     var idx : int ; idx := 1 ;
     var num : int ; num := i + s ;
    if (square[i+1] = 1) then     idx := 2 ; else skip ; 
    if (i + s > N) then     num := 2 * N - (i + s) ; else skip ; 
    if (square[num+1] = 2 & j + idx <= T) then (     dp[0+1][j + idx+1] := dp[0+1][j + idx+1]+(dp[i+1][j+1] * 1.0 / 6) ) else     if (j + idx <= T) then (     dp[num+1][j + idx+1] := dp[num+1][j + idx+1]+(dp[i+1][j+1] * 1.0 / 6) ) else skip ; ;  
 )  ;     s := s + 1 ) )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    var goal : double ; goal := 0.0 ;
        var i : int ; i := 0 ; while i <= T do (     goal := goal+(dp[N+1][i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.6f\n", goal) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  Scanner sc=new Scanner(in);
  double[][] memo ;
  int[] board ;
  int n ;
  double calc(int p,int turn){
    if(turn<0)return 0 ;
    if(memo[p][turn]<0){
      if(p==n)memo[p][turn]=1 ;
      else if(turn==0)memo[p][turn]=0 ;
      else {
        memo[p][turn]=0 ;
        for(int i=1 ; i<=6 ; i++){
          int t ;
          if(p+i<=n)t=p+i ;
          else t=n-(p+i-n);
          if(board[t]==1)memo[p][turn]+=calc(t,turn-2)/6.0 ;
          else if(board[t]==-1)memo[p][turn]+=calc(0,turn-1)/6.0 ;
          else memo[p][turn]+=calc(t,turn-1)/6.0 ;
        }
      }
    }
    return memo[p][turn];
  }
  void run(){
    while(true){
      int t,l,b ;
      n=sc.nextInt();
      t=sc.nextInt();
      l=sc.nextInt();
      b=sc.nextInt();
      if(n==0)break ;
      board=new int[n+1];
      for(int i=0 ; i<l ; i++)board[sc.nextInt()]=1 ;
      for(int i=0 ; i<b ; i++)board[sc.nextInt()]=-1 ;
      memo=new double[n+1][t+1];
      for(int i=0 ; i<=n ; i++)Arrays.fill(memo[i],-1);
      out.printf("%.7f\n",calc(0,t));
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   attribute memo : Sequence(Sequence(double));
   attribute board : Sequence(int);
   attribute n : int;
   operation calc( p : int, turn : int) : double
  pre: true
  post: true
  activity: (     if (turn < 0) then     return 0 else skip ; 
     if (memo[p+1][turn+1] < 0) then (     if (p = n) then     memo[p+1][turn+1] := 1 ; else     if (turn = 0) then     memo[p+1][turn+1] := 0 else (     memo[p+1][turn+1] := 0 ; 
         var i : int ; i := 1 ; while i <= 6 do ( (     var t : int ;
     if (p + i <= n) then     t := p + i else     t := n - (p + i - n) ; ;  
     if (board[t+1] = 1) then     memo[p+1][turn+1] := memo[p+1][turn+1]+(calc(t, turn - 2) / 6.0) ; else     if (board[t+1] = -1) then     memo[p+1][turn+1] := memo[p+1][turn+1]+(calc(0, turn - 1) / 6.0) else     memo[p+1][turn+1] := memo[p+1][turn+1]+(calc(t, turn - 1) / 6.0) ; ;  )  ;     i := i + 1 ) ) ;  ) else skip ; 
     return memo[p+1][turn+1] );
   operation run() : void
  pre: true
  post: true
  activity: (     while (true) do (     var t : int ;
    var l : int ;
    var b : int ;
     n := sc.getCurrent()->toInteger() ; 
    t := sc.getCurrent()->toInteger() ; 
    l := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    if (n = 0) then     break else skip ; 
    board := Integer.subrange(1,n + 1)->collect(0) ; 
        var i : int ; i := 0 ; while i < l do (     board[sc.getCurrent()->toInteger()+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < b do (     board[sc.getCurrent()->toInteger()+1] := -1 ;  ;     i := i + 1 ) ; 
    memo := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,t + 1)->collect(0.0)) ; 
        var i : int ; i := 0 ; while i <= n do (     memo[i+1] := memo[i+1]->collect(-1) ;  ;     i := i + 1 ) ; 
    out.printf("%.7f\n", calc(0, t)) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt(),T=sc.nextInt(),l=sc.nextInt(),b=sc.nextInt();
      if((n | T | l | b)==0)break ;
      boolean[] lose=new boolean[n+1];
      for(int i=0 ; i<l ; i++)lose[sc.nextInt()]=true ;
      boolean[] back=new boolean[n+1];
      for(int i=0 ; i<b ; i++)back[sc.nextInt()]=true ;
      double[][] p=new double[T+1][n+1];
      p[0][0]=1.0 ;
      for(int t=0 ; t<T ; t++)for(int i=0 ; i<=n ; i++){
        if(i==n){
          p[t+1][n]+=p[t][n];
          continue ;
        }
        for(int j=1 ; j<=6 ; j++){
          double dt=p[t][i]/6.0 ;
          int next=i+j ;
          if(n<next){
            int d=next-n ;
            next=n-d ;
          }
          if(lose[next]){
            if(t+2<=T)p[t+2][next]+=dt ;
          }
          else if(back[next]){
            p[t+1][0]+=dt ;
          }
          else p[t+1][next]+=dt ;
        }
      }
      System.out.printf("%.6f\n",p[T][n]);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseOr(MathLib.bitwiseOr(MathLib.bitwiseOr(n,T),l),b)) = 0) then     break else skip ; 
    var lose : Sequence(boolean) ; lose := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 0 ; while i < l do (     lose[sc.getCurrent()->toInteger()+1] := true ;  ;     i := i + 1 ) ; 
    var back : Sequence(boolean) ; back := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 0 ; while i < b do (     back[sc.getCurrent()->toInteger()+1] := true ;  ;     i := i + 1 ) ; 
    var p : Sequence(Sequence(double)) ; p := Integer.subrange(1,T + 1)->collect(Integer.subrange(1,n + 1)->collect(0.0)) ;
    p[0+1][0+1] := 1.0 ; 
        var t : int ; t := 0 ; while t < T do (         var i : int ; i := 0 ; while i <= n do ( (     if (i = n) then (     p[t + 1+1][n+1] := p[t + 1+1][n+1]+(p[t+1][n+1]) ; 
     continue ) else skip ; 
         var j : int ; j := 1 ; while j <= 6 do ( (     var dt : double ; dt := p[t+1][i+1] / 6.0 ;
     var next : int ; next := i + j ;
     if (n < next) then (     var d : int ; d := next - n ;
     next := n - d ) else skip ; 
     if (lose[next+1]) then (     if (t + 2 <= T) then     p[t + 2+1][next+1] := p[t + 2+1][next+1]+(dt) ; else skip ) else     if (back[next+1]) then (     p[t + 1+1][0+1] := p[t + 1+1][0+1]+(dt) ) else     p[t + 1+1][next+1] := p[t + 1+1][next+1]+(dt) ; ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ;  ;     t := t + 1 ) ; 
    OclFile["System.out"].printf("%.6f\n", p[T+1][n+1]) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt(),t=sc.nextInt(),l=sc.nextInt(),b=sc.nextInt();
      if(n==0)break ;
      int[] map=new int[n+1];
      double[][] dp=new double[n+1][t+1];
      for(double[] i : dp)Arrays.fill(i,-1);
      while(l-->0)map[sc.nextInt()]='l' ;
      while(b-->0)map[sc.nextInt()]='b' ;
      System.out.printf("%5f\n",solve(map,0,t,dp));
    }
  }
  public static double solve(int[] map,int n,int t,double[][] dp){
    if(n==map.length-1 && t>=0)return 1 ;
    if(t<=0)return 0 ;
    if(dp[n][t]!=-1)return dp[n][t];
    double sum=0 ;
    for(int i=1 ; i<=6 ; i++){
      int next=n+i ;
      if(next>=map.length){
        next=map.length-next % map.length-2 ;
      }
      switch(map[next]){
        case 'l' : sum+=solve(map,next,t-2,dp);
        break ;
        case 'b' : sum+=solve(map,0,t-1,dp);
        break ;
        default : sum+=solve(map,next,t-1,dp);
        break ;
      }
    }
    return(dp[n][t]=sum/6);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var map : Sequence(int) ; map := Integer.subrange(1,n + 1)->collect(0) ;
    var dp : Sequence(Sequence(double)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,t + 1)->collect(0.0)) ;
    for (i : dp) do (     i := i->collect(-1) ;  ) ; 
        while (l > 0) do (        l := l - 1 ;     skip ;     map[sc.getCurrent()->toInteger()+1] := 'l' ; ;  ) ;  
        while (b > 0) do (        b := b - 1 ;     skip ;     map[sc.getCurrent()->toInteger()+1] := 'b' ; ;  ) ;  
    OclFile["System.out"].printf("%5f\n", solve(map, 0, t, dp)) ; 
 ) );
  static   operation solve( map : Sequence(int), n : int, t : int, dp : Sequence(Sequence(double))) : double
  pre: true
  post: true
  activity: (     if (n = map->size() - 1 & t >= 0) then     return 1 else skip ; 
     if (t <= 0) then     return 0 else skip ; 
    if (dp[n+1][t+1] /= -1) then     return dp[n+1][t+1] else skip ; 
    var sum : double ; sum := 0 ;
        var i : int ; i := 1 ; while i <= 6 do ( (     var next : int ; next := n + i ;
     if (next >= map->size()) then (     next := map->size() - next mod map->size() - 2 ) else skip ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (map[next+1]) ; 
       if _switchval = 'l' then
     sum := sum+(solve(map, next, t - 2, dp)) ; 
    break 
   else skip ;
       if _switchval = 'b' then
     sum := sum+(solve(map, 0, t - 1, dp)) ; 
    break 
   else skip ;
       if true then
     sum := sum+(solve(map, next, t - 1, dp)) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    return (dp[n+1][t+1]) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    while(true){
      final int N=sc.nextInt();
      final int T=sc.nextInt();
      final int L=sc.nextInt();
      final int B=sc.nextInt();
      if(N==0 && T==0 && L==0 && B==0){
        break ;
      }
      boolean[] lose=new boolean[N+1];
      boolean[] back=new boolean[N+1];
      for(int i=0 ; i<L ; i++){
        lose[sc.nextInt()]=true ;
      }
      for(int i=0 ; i<B ; i++){
        back[sc.nextInt()]=true ;
      }
      double[][] DP=new double[T+1][N+1];
      DP[0][0]=1 ;
      for(int turn=0 ; turn<T ; turn++){
        for(int pos=0 ; pos<N ; pos++){
          for(int dice=1 ; dice<=6 ; dice++){
            int next=pos+dice ;
            if(next>N){
              next=2*N-next ;
            }
            if(back[next]){
              next=0 ;
            }
            if(lose[next] && turn==T-1){
              continue ;
            }
            DP[turn+1+(lose[next] ? 1 : 0)][next]+=DP[turn][pos]/6 ;
          }
        }
      }
      double sum=0 ;
      for(int turn=0 ; turn<=T ; turn++){
        sum+=DP[turn][N];
      }
      System.out.printf("%6f\n",sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
    var L : int ; L := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    if (N = 0 & T = 0 & L = 0 & B = 0) then (     break ) else skip ; 
    var lose : Sequence(boolean) ; lose := Integer.subrange(1,N + 1)->collect(false) ;
    var back : Sequence(boolean) ; back := Integer.subrange(1,N + 1)->collect(false) ;
        var i : int ; i := 0 ; while i < L do ( (     lose[sc.getCurrent()->toInteger()+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < B do ( (     back[sc.getCurrent()->toInteger()+1] := true )  ;     i := i + 1 ) ; 
    var DP : Sequence(Sequence(double)) ; DP := Integer.subrange(1,T + 1)->collect(Integer.subrange(1,N + 1)->collect(0.0)) ;
    DP[0+1][0+1] := 1 ; 
        var turn : int ; turn := 0 ; while turn < T do ( (         var pos : int ; pos := 0 ; while pos < N do ( (         var dice : int ; dice := 1 ; while dice <= 6 do ( (     var next : int ; next := pos + dice ;
     if (next > N) then (     next := 2 * N - next ) else skip ; 
    if (back[next+1]) then (     next := 0 ) else skip ; 
    if (lose[next+1] & turn = T - 1) then (     continue ) else skip ; 
    DP[turn + 1 + (if lose[next+1] then 1 else 0 endif)+1][next+1] := DP[turn + 1 + (if lose[next+1] then 1 else 0 endif)+1][next+1]+(DP[turn+1][pos+1] / 6) ; 
 )  ;     dice := dice + 1 ) )  ;     pos := pos + 1 ) )  ;     turn := turn + 1 ) ; 
    var sum : double ; sum := 0 ;
        var turn : int ; turn := 0 ; while turn <= T do ( (     sum := sum+(DP[turn+1][N+1]) )  ;     turn := turn + 1 ) ; 
    OclFile["System.out"].printf("%6f\n", sum) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Test {
  public static void main(String[] args){
    System.out.println(isPower(10,1)? 1 : 0);
    System.out.println(isPower(1,20)? 1 : 0);
    System.out.println(isPower(2,128)? 1 : 0);
    System.out.println(isPower(2,30)? 1 : 0);
  }
  public static boolean isPower(int x,int y){
    if(x==1)return(y==1);
    int pow=1 ;
    while(pow<y)pow=pow*x ;
    return(pow==y);
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if isPower(10, 1) then 1 else 0 endif) ; 
     OclFile["System.out"].println(if isPower(1, 20) then 1 else 0 endif) ; 
     OclFile["System.out"].println(if isPower(2, 128) then 1 else 0 endif) ; 
     OclFile["System.out"].println(if isPower(2, 30) then 1 else 0 endif) );
  static   operation isPower( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     if (x = 1) then     return (y = 1) else skip ; 
     var pow : int ; pow := 1 ;
     while (pow < y) do     pow := pow * x ; ; 
     return (pow = y) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    if(str.equals("AAA")|| str.equals("BBB")){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
     if (str = "AAA" or str = "BBB") then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String args[])throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    String str[]=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    long k=Long.parseLong(str[1]);
    int next[]=new int[n+1];
    int cnttillthere[]=new int[n+1];
    int cntr=0 ;
    str=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++)next[i+1]=Integer.parseInt(str[i]);
    int nxt=1 ;
    Arrays.fill(cnttillthere,-1);
    cnttillthere[1]=0 ;
    while(true){
      if(cnttillthere[next[nxt] ]>=0 || k==0)break ;
      cntr++;
      cnttillthere[next[nxt] ]=cntr ;
      nxt=next[nxt];
      k--;
    }
    if(k==0)pw.println(nxt);
    else {
      int noe=cntr+1-cnttillthere[next[nxt] ];
      k--;
      int rem=(int)(k % noe);
      nxt=next[nxt];
      for(int i=0 ; i<rem ; i++)nxt=next[nxt];
      pw.println(nxt);
    }
    pw.flush();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var k : long ; k := (str[1+1])->toLong() ;
    var next : Sequence(int) ; next := Integer.subrange(1,n + 1)->collect(0) ;
    var cnttillthere : Sequence(int) ; cnttillthere := Integer.subrange(1,n + 1)->collect(0) ;
    var cntr : int ; cntr := 0 ;
    str := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do (     next[i + 1+1] := (str[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var nxt : int ; nxt := 1 ;
    cnttillthere := cnttillthere->collect(-1) ; 
    cnttillthere[1+1] := 0 ; 
    while (true) do (     if (cnttillthere[next[nxt+1]+1] >= 0 or k = 0) then     break else skip ; 
     cntr := cntr + 1 ; 
    cnttillthere[next[nxt+1]+1] := cntr ; 
    nxt := next[nxt+1] ; 
    k := k - 1 ; 
 ) ; 
    if (k = 0) then     skip else (     var noe : int ; noe := cntr + 1 - cnttillthere[next[nxt+1]+1] ;
     k := k - 1 ; 
    var rem : int ; rem := (k mod noe)->oclAsType(int) ;
    nxt := next[nxt+1] ; 
        var i : int ; i := 0 ; while i < rem do (     nxt := next[nxt+1] ;  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.System.out ;
public class Main {
  static MyReader in=new MyReader();
  public static void main(String[] args){
    char[] S=in.s().toCharArray();
    String ans=S[0]==S[1] && S[1]==S[2] ? "No" : "Yes" ;
    out.println(ans);
  }
  static class MyReader extends BufferedReader {
    MyReader(){
      super(new InputStreamReader(System.in));
    }
    String s(){
      try {
        return readLine();
      }
      catch(IOException e){
        return "" ;
      }
    }
    String[] ss(){
      return s().split(" ");
    }
    int i(){
      return Integer.parseInt(s());
    }
    int[] ii(){
      String[] ss=ss();
      int[] ii=new int[ss.length];
      for(int j=0 ; j<ss.length ; j++)ii[j]=Integer.parseInt(ss[j]);
      return ii ;
    }
    ArrayList<Integer>li(){
      String[] ss=ss();
      ArrayList<Integer>li=new ArrayList<>();
      for(int j=0 ; j<ss.length ; j++)li.add(Integer.parseInt(ss[j]));
      return li ;
    }
    long l(){
      return Long.parseLong(s());
    }
    long[] ll(){
      String[] ss=ss();
      long[] ll=new long[ss.length];
      for(int j=0 ; j<ss.length ; j++)ll[j]=Long.parseLong(ss[j]);
      return ll ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : MyReader := MyReader.newMyReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : Sequence(String) ; S := in.s()->characters() ;
     var ans : String ; ans := if S[0+1] = S[1+1] & S[1+1] = S[2+1] then "No" else "Yes" endif ;
     out.println(ans) );
  static class MyReader extends OclFile {
   static operation newMyReader() : MyReader
  pre: true
  post: true
  activity:
  ( var self : MyReader ;
    self := createMyReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation s() : String
  pre: true
  post: true
  activity: (     try (     return readLine() )   catch (e : IOException) do (     return "" )
 );
   operation ss() : Sequence(String)
  pre: true
  post: true
  activity: (     return s()->split(" ") );
   operation i() : int
  pre: true
  post: true
  activity: (     return (s())->toInteger() );
   operation ii() : Sequence(int)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var ii : Sequence(int) ; ii := Integer.subrange(1,ss->size())->collect(0) ;
         var j : int ; j := 0 ; while j < ss->size() do (     ii[j+1] := (ss[j+1])->toInteger() ;  ;     j := j + 1 ) ; 
     return ii );
   operation li() : Sequence(int)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var li : Sequence(int) ; li := Sequence{} ;
         var j : int ; j := 0 ; while j < ss->size() do (     li := li->including((ss[j+1])->toInteger()) ;  ;     j := j + 1 ) ; 
     return li );
   operation l() : long
  pre: true
  post: true
  activity: (     return (s())->toLong() );
   operation ll() : Sequence(long)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var ll : Sequence(long) ; ll := Integer.subrange(1,ss->size())->collect(0) ;
         var j : int ; j := 0 ; while j < ss->size() do (     ll[j+1] := (ss[j+1])->toLong() ;  ;     j := j + 1 ) ; 
     return ll );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import java.util.Scanner ;
import java.lang.*;
import java.io.*;
import java.util.*;
import java.lang.Integer ;
import java.util.HashMap ;
class Main {
  public static void main(String args[])throws IOException {
    Reader.init(System.in);
    String s=Reader.next();
    char[] arr=s.toCharArray();
    int ans_b=0 ;
    for(int i=0 ; i<3 ; i++){
      char val=arr[i];
      if(val=='B'){
        ans_b++;
      }
    }
    if(ans_b==1 || ans_b==2){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
class solu {
}
class Reader {
  static BufferedReader reader ;
  static StringTokenizer tokenizer ;
  static void init(InputStream input){
    reader=new BufferedReader(new InputStreamReader(input));
    tokenizer=new StringTokenizer("");
  }
  static String next()throws IOException {
    while(! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Reader.init(OclFile["System.in"]) ; 
     var s : String ; s := Reader.next() ;
    var arr : Sequence(String) ; arr := s->characters() ;
    var ans_b : int ; ans_b := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     var val : String ; val := arr[i+1] ;
     if (val = 'B') then (     ans_b := ans_b + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (ans_b = 1 or ans_b = 2) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}
class solu { }
class Reader {
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   operation init( input : OclFile) : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(input)) ; 
     tokenizer := OclIterator.newOclIterator_String("") );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    AStationAndBus solver=new AStationAndBus();
    solver.solve(1,in,out);
    out.close();
  }
  static class AStationAndBus {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      String s=in.next();
      if(s.contains("A")&& s.contains("B")){
        out.println("Yes");
      }
      else {
        out.println("No");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : AStationAndBus ; solver := AStationAndBus.newAStationAndBus() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class AStationAndBus {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.getCurrent() ;
     if (s->includes("A") & s->includes("B")) then (     skip ) else (     skip ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static PrintWriter out ;
  static StringBuilder sb ;
  static long mod=998244353 ;
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    out=new PrintWriter(System.out);
    String s=sc.nextLine();
    if(s.contains("A")&& s.contains("B"))out.print("Yes");
    else out.print("No");
    out.flush();
  }
  static long modPow(long a,long e){
    long res=1 ;
    while(e>0){
      if((e & 1)==1)res=(res*a)% mod ;
      a=(a*a)% mod ;
      e>>=1 ;
    }
    return res ;
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream system){
      br=new BufferedReader(new InputStreamReader(system));
    }
    public Scanner(String file)throws Exception {
      br=new BufferedReader(new FileReader(file));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public char nextChar()throws IOException {
      return next().charAt(0);
    }
    public Long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
    public void waitForInput()throws InterruptedException {
      Thread.sleep(3000);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile;
  static   attribute sb : String;
  static   attribute mod : long := 998244353;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    var s : String ; s := sc.nextLine() ;
    if (s->includes("A") & s->includes("B")) then     skip else     skip ; ;  
    skip ; 
 );
  static   operation modPow( a : long, e : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     while (e > 0) do (     if ((e & 1) = 1) then     res := (res * a) mod mod ; else skip ; 
     a := (a * a) mod mod ; 
     e := e/(2->pow(1)) ) ; 
     return res );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( system : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(system);
    return self );
  operation initialise( system : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(system)) );
   static operation newScanner( file : String) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
   operation waitForInput() : void
  pre: true
  post: true
  activity: (     OclProcess.sleep(3000) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class oddsum {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int s=0 ;
      int o=0 ;
      int e=0 ;
      int a=in.nextInt();
      int x ;
      for(int i=0 ; i<a ; i++){
        x=in.nextInt();
        s+=x ;
        if(x % 2!=0){
          o++;
        }
        else e++;
      }
      if(s % 2!=0){
        System.out.println("YES");
      }
      else {
        if(o>=1 && e>=1)System.out.println("YES");
        else {
          System.out.println("NO");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class oddsum {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : int ; s := 0 ;
     var o : int ; o := 0 ;
    var e : int ; e := 0 ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var x : int ;
        var i : int ; i := 0 ; while i < a do ( (     x := in.getCurrent()->toInteger() ; 
     s := s+(x) ; 
     if (x mod 2 /= 0) then (     o := o + 1 ) else     e := e + 1 ; )  ;     i := i + 1 ) ; 
    if (s mod 2 /= 0) then (     OclFile["System.out"].println("YES") ) else (     if (o >= 1 & e >= 1) then     OclFile["System.out"].println("YES") ; else (     OclFile["System.out"].println("NO") ) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Ex3 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int q=in.nextInt();
    for(int t=0 ; t<q ; t++){
      int n=in.nextInt();
      int a[]=new int[n];
      int sum=0 ;
      boolean odd=false ;
      boolean even=false ;
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
        sum+=a[i];
        if(a[i] % 2==0){
          even=true ;
        }
        else if(a[i] % 2!=0){
          odd=true ;
        }
      }
      if(sum % 2!=0 ||(even && odd)){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
  public class ListNode<E>{
    private E value ;
    private ListNode next ;
    public ListNode(E newVal,ListNode<E>newNext){
      value=newVal ;
      next=newNext ;
    }
    public E getValue(){
      return value ;
    }
    public ListNode<E>getNext(){
      return next ;
    }
    public void setValue(E newValue){
      value=newValue ;
    }
    public void setNext(ListNode<E>newNext){
      next=newNext ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ex3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < q do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
    var odd : boolean ; odd := false ;
    var even : boolean ; even := false ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) ; 
     if (a[i+1] mod 2 = 0) then (     even := true ) else     if (a[i+1] mod 2 /= 0) then (     odd := true ) else skip ; )  ;     i := i + 1 ) ; 
    if (sum mod 2 /= 0 or (even & odd)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     t := t + 1 ) );
 class ListNode<E> {
   attribute value : E;
   attribute next : ListNode;
   static operation newListNode( newVal : E, newNext : ListNode<E>) : ListNode
  pre: true
  post: true
  activity:
  ( var self : ListNode ;
    self := createListNode();
    self.initialise(newVal, newNext);
    return self );
  operation initialise( newVal : E, newNext : ListNode<E>) : void
  pre: true  post: true
  activity: (     value := newVal ; 
     next := newNext );
   operation getValue() : E
  pre: true
  post: true
  activity: (     return value );
   operation getNext() : ListNode<E>
  pre: true
  post: true
  activity: (     return next );
   operation setValue( newValue : E) : void
  pre: true
  post: true
  activity: (     value := newValue );
   operation setNext( newNext : ListNode<E>) : void
  pre: true
  post: true
  activity: (     next := newNext );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ArrayWithOddSum {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      int[] a=new int[n];
      int sum=0 ;
      int odd=0 ;
      int even=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
        if(a[i] % 2==0){
          even++;
        }
        else {
          odd++;
        }
      }
      for(int i=0 ; i<n ; i++){
        sum+=a[i];
      }
      if(sum % 2!=0){
        System.out.println("YES");
      }
      else {
        if(even>=1 && odd!=0){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ArrayWithOddSum {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
    var odd : int ; odd := 0 ;
    var even : int ; even := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (a[i+1] mod 2 = 0) then (     even := even + 1 ) else (     odd := odd + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    if (sum mod 2 /= 0) then (     OclFile["System.out"].println("YES") ) else (     if (even >= 1 & odd /= 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class arrayWithOddSum {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
      int even=0 ;
      int odd=0 ;
      for(int i=0 ; i<n ; i++){
        if(arr[i] % 2==0)odd+=arr[i];
        else even+=arr[i];
      }
      if((odd+even)% 2!=0){
        System.out.println("YES");
      }
      else if(odd!=0 && even!=0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class arrayWithOddSum {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var even : int ; even := 0 ;
    var odd : int ; odd := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 = 0) then     odd := odd+(arr[i+1]) ; else     even := even+(arr[i+1]) ; )  ;     i := i + 1 ) ; 
    if ((odd + even) mod 2 /= 0) then (     OclFile["System.out"].println("YES") ) else     if (odd /= 0 & even /= 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  ;  
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static void normalSieve(int n){
    boolean prime[]=new boolean[n/2];
    Arrays.fill(prime,false);
    for(int i=3 ; i*i<n ; i+=2){
      if(prime[i/2]==false)for(int j=i*i ;
      j<n ;
      j+=i*2)prime[j/2]=true ;
    }
    System.out.print("2 ");
    for(int i=3 ; i<n ; i+=2)if(prime[i/2]==false)System.out.print(i+" ");
  }
  public static void main(String[] args){
    int n=100 ;
    normalSieve(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation normalSieve( n : int) : void
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,n / 2)->collect(false) ;
     prime := prime->collect(false) ; 
        var i : int ; i := 3 ; while i * i < n do ( (     if (prime[i / 2+1] = false) then         var j : int ; j := i * i ; while j < n do (     prime[j / 2+1] := true ;  ;     j := j+(i * 2) ) ; else skip )  ;     i := i+(2) ) ; 
    OclFile["System.out"].print("2 ") ; 
        var i : int ; i := 3 ; while i < n do (     if (prime[i / 2+1] = false) then     OclFile["System.out"].print(i + " ") ; else skip ;  ;     i := i+(2) ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 100 ;
     execute normalSieve(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minimumValue(int arr[],int n,int k){
    Arrays.sort(arr);
    int answer=0 ;
    for(int i=0 ; i<k ; i++)answer+=arr[i]*arr[i];
    return answer*(2*k-2);
  }
  public static void main(String[] args){
    int arr[]={
      4,21,5,3,8 },k=3 ;
      int n=arr.length ;
      System.out.print(minimumValue(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumValue( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var answer : int ; answer := 0 ;
         var i : int ; i := 0 ; while i < k do (     answer := answer+(arr[i+1] * arr[i+1]) ;  ;     i := i + 1 ) ; 
     return answer * (2 * k - 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,21,5,3,8} ;
    var k : int ; k := 3 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(minimumValue(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    InputReader in=new InputReader(inputStream);
    int T=in.nextInt();
    while(T-->0){
      int n=in.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<arr.length ; i++){
        arr[i]=in.nextInt();
      }
      int o=0 ;
      int sum=0 ;
      for(int a : arr){
        sum+=a ;
        if(a % 2==1){
          o++;
        }
      }
      if((o==n || o==0)&& sum % 2==0){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
     var T : int ; T := in.nextInt() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := in.nextInt() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    var o : int ; o := 0 ;
    var sum : int ; sum := 0 ;
    for (a : arr) do ( (     sum := sum+(a) ; 
     if (a mod 2 = 1) then (     o := o + 1 ) else skip )  ) ; 
    if ((o = n or o = 0) & sum mod 2 = 0) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 ) ;  ) );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minInsertions(int[] H,int n,int K){
    int inser=0 ;
    for(int i=1 ; i<n ; ++i){
      float diff=Math.abs(H[i]-H[i-1]);
      if(diff<=K)continue ;
      else inser+=Math.ceil(diff/K)-1 ;
    }
    return inser ;
  }
  public static void main(String[] args){
    int[] H=new int[] {
      2,4,8,16 };
      int K=3 ;
      int n=H.length ;
      System.out.println(minInsertions(H,n,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minInsertions( H : Sequence(int), n : int, K : int) : int
  pre: true
  post: true
  activity: (     var inser : int ; inser := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     var diff : double ; diff := if H[i+1] - H[i - 1+1] < 0 then -(H[i+1] - H[i - 1+1]) else H[i+1] - H[i - 1+1] endif ;
     if (diff <= K) then     continue else     inser := inser+((diff / K)->ceil() - 1) ; )  ;     i := i + 1 ) ; 
     return inser );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var H : Sequence(int) ; H := Sequence{2,4,8,16} ;
     var K : int ; K := 3 ;
     var n : int ; n := H->size() ;
     OclFile["System.out"].println(minInsertions(H, n, K)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    long K=scan.nextLong();
    int[] town_to=new int[N];
    for(int i=0 ; i<N ; i++){
      town_to[i]=scan.nextInt();
    }
    int[] flag=new int[N];
    int now_town=1 ;
    long k=K ;
    for(int j=0 ; j<K ; j++){
      flag[now_town-1]=1 ;
      now_town=town_to[now_town-1];
      k--;
      if(flag[now_town-1]==1){
        break ;
      }
    }
    long count=0 ;
    if(k!=0){
      while(true){
        flag[now_town-1]=0 ;
        now_town=town_to[now_town-1];
        count++;
        k--;
        if(k==0){
          break ;
        }
        if(flag[now_town-1]==0){
          break ;
        }
      }
    }
    if(k==0){
      System.out.println(now_town);
    }
    else {
      long nokori=k % count ;
      if(nokori==0){
        System.out.println(now_town);
      }
      else {
        for(long index=1 ; index<=nokori ; index++){
          now_town=town_to[now_town-1];
        }
        System.out.println(now_town);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var K : long ; K := scan.getCurrent()->toLong() ;
    var town_to : Sequence(int) ; town_to := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     town_to[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var flag : Sequence(int) ; flag := Integer.subrange(1,N)->collect(0) ;
    var now_town : int ; now_town := 1 ;
    var k : long ; k := K ;
        var j : int ; j := 0 ; while j < K do ( (     flag[now_town - 1+1] := 1 ; 
     now_town := town_to[now_town - 1+1] ; 
     k := k - 1 ; 
     if (flag[now_town - 1+1] = 1) then (     break ) else skip )  ;     j := j + 1 ) ; 
    var count : long ; count := 0 ;
    if (k /= 0) then (     while (true) do (     flag[now_town - 1+1] := 0 ; 
     now_town := town_to[now_town - 1+1] ; 
    count := count + 1 ; 
    k := k - 1 ; 
    if (k = 0) then (     break ) else skip ; 
    if (flag[now_town - 1+1] = 0) then (     break ) else skip ; 
 ) ) else skip ; 
    if (k = 0) then (     OclFile["System.out"].println(now_town) ) else (     var nokori : long ; nokori := k mod count ;
     if (nokori = 0) then (     OclFile["System.out"].println(now_town) ) else (         var index : long ; index := 1 ; while index <= nokori do ( (     now_town := town_to[now_town - 1+1] )  ;     index := index + 1 ) ; 
     OclFile["System.out"].println(now_town) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int countWords(String str,int len){
    int count=1 ;
    if(len==1)return count ;
    if(str.charAt(0)==str.charAt(1))count*=1 ;
    else count*=2 ;
    for(int j=1 ; j<len-1 ; j++){
      if(str.charAt(j)==str.charAt(j-1)&& str.charAt(j)==str.charAt(j+1))count*=1 ;
      else if(str.charAt(j)==str.charAt(j-1)|| str.charAt(j)==str.charAt(j+1)|| str.charAt(j-1)==str.charAt(j+1))count*=2 ;
      else count*=3 ;
    }
    if(str.charAt(len-1)==str.charAt(len-2))count*=1 ;
    else count*=2 ;
    return count ;
  }
  public static void main(String args[]){
    String str="abc" ;
    int len=str.length();
    System.out.println(countWords(str,len));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countWords( str : String, len : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 1 ;
     if (len = 1) then     return count else skip ; 
    if (str->at(0+1) = str->at(1+1)) then     count := count*(1) else     count := count*(2) ; ;  
        var j : int ; j := 1 ; while j < len - 1 do ( (     if (str->at(j+1) = str->at(j - 1+1) & str->at(j+1) = str->at(j + 1+1)) then     count := count*(1) ; else     if (str->at(j+1) = str->at(j - 1+1) or str->at(j+1) = str->at(j + 1+1) or str->at(j - 1+1) = str->at(j + 1+1)) then     count := count*(2) else     count := count*(3) ; ;  )  ;     j := j + 1 ) ; 
    if (str->at(len - 1+1) = str->at(len - 2+1)) then     count := count*(1) else     count := count*(2) ; ;  
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abc" ;
     var len : int ; len := str->size() ;
     OclFile["System.out"].println(countWords(str, len)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class evenSum {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException,InterruptedException {
    int n=Integer.parseInt(br.readLine()+"");
    long max=0 ;
    String s=br.readLine();
    String[] x=s.split(" ");
    ArrayList<Integer>even=new ArrayList<Integer>(n);
    ArrayList<Integer>odd=new ArrayList<Integer>(n);
    while(n-->0){
      int y=Integer.parseInt(x[n]);
      if(y % 2==0)even.add(y);
      else odd.add(y);
    }
    for(int i=0 ; i<even.size(); i++)max+=even.get(i);
    int[] odd2=new int[odd.size()];
    for(int i=0 ; i<odd.size(); i++)odd2[i]=odd.get(i);
    Arrays.sort(odd2);
    for(int i=odd2.length-1 ; i>0 ; i--)max+=odd2[i];
    if(odd2.length % 2==0 && odd2.length>0)max+=odd2[0];
    pw.println(max);
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class evenSum {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine() + "")->toInteger() ;
     var max : long ; max := 0 ;
    var s : String ; s := br.readLine() ;
    var x : Sequence(String) ; x := s->split(" ") ;
    var even : Sequence(int) ; even := Sequence{} ;
    var odd : Sequence(int) ; odd := Sequence{} ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var y : int ; y := (x[n+1])->toInteger() ;
     if (y mod 2 = 0) then     even := even->including(y) ; else     odd := odd->including(y) ; ) ;  ) ;  
        var i : int ; i := 0 ; while i < even->size() do (     max := max+(even->at(i+1)) ;  ;     i := i + 1 ) ; 
    var odd2 : Sequence(int) ; odd2 := Integer.subrange(1,odd->size())->collect(0) ;
        var i : int ; i := 0 ; while i < odd->size() do (     odd2[i+1] := odd->at(i+1) ;  ;     i := i + 1 ) ; 
    odd2 := odd2->sort() ; 
        var i : int ; i := odd2->size() - 1 ; while i > 0 do (     max := max+(odd2[i+1]) ;  ;     i := i - 1 ) ; 
    if (odd2->size() mod 2 = 0 & odd2->size() > 0) then     max := max+(odd2[0+1]) ; else skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Long>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++)list.add(sc.nextLong());
    List<Long>odd=new ArrayList<>();
    long sum=0 ;
    for(long i : list){
      if(i % 2==0)sum+=i ;
      else odd.add(i);
    }
    Collections.sort(odd);
    for(long i : odd)sum+=i ;
    if(odd.size()% 2!=0)sum-=odd.get(0);
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var list : Sequence(long) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     list := list->including(sc.getCurrent()->toLong()) ;  ;     i := i + 1 ) ; 
    var odd : Sequence(long) ; odd := Sequence{} ;
    var sum : long ; sum := 0 ;
    for (i : list) do ( (     if (i mod 2 = 0) then     sum := sum+(i) ; else     odd := odd->including(i) ; )  ) ; 
    odd := odd->sort() ; 
    for (i : odd) do (     sum := sum+(i) ;  ) ; 
    if (odd->size() mod 2 /= 0) then     sum := sum-(odd->at(0+1)) ; else skip ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Long>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++)list.add(sc.nextLong());
    List<Long>even=new ArrayList<>();
    List<Long>odd=new ArrayList<>();
    for(long i : list){
      if(i % 2==0)even.add(i);
      else odd.add(i);
    }
    Collections.sort(even);
    Collections.sort(odd);
    long sum=0 ;
    for(long i : even)sum+=i ;
    for(long i : odd)sum+=i ;
    if(odd.size()% 2!=0)sum-=odd.get(0);
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var list : Sequence(long) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     list := list->including(sc.getCurrent()->toLong()) ;  ;     i := i + 1 ) ; 
    var even : Sequence(long) ; even := Sequence{} ;
    var odd : Sequence(long) ; odd := Sequence{} ;
    for (i : list) do ( (     if (i mod 2 = 0) then     even := even->including(i) ; else     odd := odd->including(i) ; )  ) ; 
    even := even->sort() ; 
    odd := odd->sort() ; 
    var sum : long ; sum := 0 ;
    for (i : even) do (     sum := sum+(i) ;  ) ; 
    for (i : odd) do (     sum := sum+(i) ;  ) ; 
    if (odd->size() mod 2 /= 0) then     sum := sum-(odd->at(0+1)) ; else skip ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GFG {
  public static ArrayList<Integer>getPerfectSquares(int n){
    ArrayList<Integer>perfectSquares=new ArrayList<>();
    int current=1,i=1 ;
    while(current<=n){
      perfectSquares.add(current);
      current=(int)Math.pow(++i,2);
    }
    return perfectSquares ;
  }
  public static int maxPairSum(int arr[]){
    int n=arr.length ;
    int max,secondMax ;
    if(arr[0]>arr[1]){
      max=arr[0];
      secondMax=arr[1];
    }
    else {
      max=arr[1];
      secondMax=arr[0];
    }
    for(int i=2 ; i<n ; i++){
      if(arr[i]>max){
        secondMax=max ;
        max=arr[i];
      }
      else if(arr[i]>secondMax){
        secondMax=arr[i];
      }
    }
    return(max+secondMax);
  }
  public static int countPairsWith(int n,ArrayList<Integer>perfectSquares,HashSet<Integer>nums){
    int count=0 ;
    for(int i=0 ; i<perfectSquares.size(); i++){
      int temp=perfectSquares.get(i)-n ;
      if(temp>n && nums.contains(temp))count++;
    }
    return count ;
  }
  public static int countPairs(int arr[]){
    int i,n=arr.length ;
    int max=maxPairSum(arr);
    ArrayList<Integer>perfectSquares=getPerfectSquares(max);
    HashSet<Integer>nums=new HashSet<>();
    for(i=0 ; i<n ; i++)nums.add(arr[i]);
    int count=0 ;
    for(i=0 ; i<n ; i++){
      count+=countPairsWith(arr[i],perfectSquares,nums);
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      2,3,6,9,10,20 };
      System.out.println(countPairs(arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getPerfectSquares( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var perfectSquares : Sequence(int) ; perfectSquares := Sequence{} ;
     var current : int ; current := 1 ;
    var i : int ; i := 1 ;
     while (current <= n) do (     perfectSquares := perfectSquares->including(current) ; 
     current := (i + 1)->pow(2)->oclAsType(int) ) ; 
     return perfectSquares );
  static   operation maxPairSum( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
     var max : int ;
    var secondMax : int ;
    if (arr[0+1] > arr[1+1]) then (     max := arr[0+1] ; 
     secondMax := arr[1+1] ) else (     max := arr[1+1] ; 
     secondMax := arr[0+1] ) ;  
        var i : int ; i := 2 ; while i < n do ( (     if (arr[i+1] > max) then (     secondMax := max ; 
     max := arr[i+1] ) else     if (arr[i+1] > secondMax) then (     secondMax := arr[i+1] ) else skip ; )  ;     i := i + 1 ) ; 
    return (max + secondMax) 
 );
  static   operation countPairsWith( n : int, perfectSquares : Sequence(int), nums : Set(int)) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < perfectSquares->size() do ( (     var temp : int ; temp := perfectSquares->at(i+1) - n ;
     if (temp > n & nums->includes(temp)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation countPairs( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var n : int ; n := arr->size() ;
     var max : int ; max := maxPairSum(arr) ;
    var perfectSquares : Sequence(int) ; perfectSquares := getPerfectSquares(max) ;
    var nums : Set(int) ; nums := Set{} ;
        i := 0 ; while i < n do (     nums := nums->including(arr[i+1]) ;  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        i := 0 ; while i < n do ( (     count := count+(countPairsWith(arr[i+1], perfectSquares, nums)) )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,6,9,10,20} ;
     OclFile["System.out"].println(countPairs(arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double findHypotenuse(double side1,double side2){
    double h=Math.sqrt((side1*side1)+(side2*side2));
    return h ;
  }
  public static void main(String s[]){
    int side1=3,side2=4 ;
    System.out.printf("%.2f",findHypotenuse(side1,side2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findHypotenuse( side1 : double, side2 : double) : double
  pre: true
  post: true
  activity: (     var h : double ; h := ((side1 * side1) + (side2 * side2))->sqrt() ;
     return h );
  static   operation main( s : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var side1 : int ; side1 := 3 ;
    var side2 : int ; side2 := 4 ;
     OclFile["System.out"].printf("%.2f", findHypotenuse(side1, side2)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static void printTwoOdd(int arr[],int size){
    int xor2=arr[0];
    int set_bit_no ;
    int i ;
    int n=size-2 ;
    int x=0,y=0 ;
    for(i=1 ; i<size ; i++)xor2=xor2 ^ arr[i];
    set_bit_no=xor2 & ~(xor2-1);
    for(i=0 ; i<size ; i++){
      if((arr[i] & set_bit_no)>0)x=x ^ arr[i];
      else y=y ^ arr[i];
    }
    System.out.println("The two ODD elements are "+x+" & "+y);
  }
  public static void main(String[] args){
    int arr[]={
      4,2,4,5,2,3,3,1 };
      int arr_size=arr.length ;
      printTwoOdd(arr,arr_size);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation printTwoOdd( arr : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (     var xor2 : int ; xor2 := arr[0+1] ;
     var set_bit_no : int ;
    var i : int ;
    var n : int ; n := size - 2 ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
        i := 1 ; while i < size do (     xor2 := MathLib.bitwiseXor(xor2,arr[i+1]) ;  ;     i := i + 1 ) ; 
    set_bit_no := MathLib.bitwiseAnd(xor2,-((xor2 - 1) + 1)) ; 
        i := 0 ; while i < size do ( (     if ((arr[i+1] & set_bit_no) > 0) then     x := MathLib.bitwiseXor(x,arr[i+1]) ; else     y := MathLib.bitwiseXor(y,arr[i+1]) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("The two ODD elements are " + x + " & " + y) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,2,4,5,2,3,3,1} ;
     var arr_size : int ; arr_size := arr->size() ;
     execute printTwoOdd(arr, arr_size) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N ;
    N=sc.nextInt();
    Set<String>vs=new HashSet<>();
    Map<String,Set<String>>indeg=new HashMap<>();
    Map<String,Set<String>>outdeg=new HashMap<>();
    for(int i=0 ; i<N ; i++){
      String u,d,rel ;
      u='u'+sc.next();
      rel=sc.next();
      d='d'+sc.next();
      vs.add(u);
      vs.add(d);
      indeg.putIfAbsent(u,new HashSet<>());
      indeg.putIfAbsent(d,new HashSet<>());
      outdeg.putIfAbsent(u,new HashSet<>());
      outdeg.putIfAbsent(d,new HashSet<>());
      if(rel.equals("lock")){
        indeg.get(u).add(d);
        outdeg.get(d).add(u);
      }
      else {
        indeg.get(d).add(u);
        outdeg.get(u).add(d);
      }
    }
    Queue<String>que=new ArrayDeque<>();
    for(String v : indeg.keySet()){
      if(indeg.get(v).size()==0){
        que.offer(v);
      }
    }
    while(! que.isEmpty()){
      String u=que.poll();
      for(String v : outdeg.get(u)){
        indeg.get(v).remove(u);
        if(indeg.get(v).size()==0){
          que.offer(v);
        }
      }
      vs.remove(u);
    }
    System.out.println(vs.size()==0 ? 0 : 1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ;
    N := sc.getCurrent()->toInteger() ; 
    var vs : Set(String) ; vs := Set{} ;
    var indeg : Map(String,Set(String)) ; indeg := Map{} ;
    var outdeg : Map(String,Set(String)) ; outdeg := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     var u : String ;
    var d : String ;
    var rel : String ;
     u := 'u' + sc.getCurrent() ; 
    rel := sc.getCurrent() ; 
    d := 'd' + sc.getCurrent() ; 
    vs := vs->including(u) ; 
    vs := vs->including(d) ; 
    if indeg->keys()->includes(u) then skip else indeg := indeg->union(Map{u |-> Set{}}) ; 
    if indeg->keys()->includes(d) then skip else indeg := indeg->union(Map{d |-> Set{}}) ; 
    if outdeg->keys()->includes(u) then skip else outdeg := outdeg->union(Map{u |-> Set{}}) ; 
    if outdeg->keys()->includes(d) then skip else outdeg := outdeg->union(Map{d |-> Set{}}) ; 
    if (rel = "lock") then (     indeg->at(u)->excludes(d) ; 
     outdeg->at(d)->excludes(u) ) else (     indeg->at(d)->excludes(u) ; 
     outdeg->at(u)->excludes(d) ) ;  
 )  ;     i := i + 1 ) ; 
    var que : Sequence(String) ; que := ArrayDeque<OclAny>.newArrayDeque() ;
    for (v : indeg->keys()) do ( (     if (indeg->at(v)->size() = 0) then (     que := que->including(v) ) else skip )  ) ; 
    while (not(que->isEmpty())) do (     var u : String ; u := que->min() ;
     for (v : outdeg->at(u)) do ( (     indeg := indeg->at(v)->excludingFirst(u) ; 
     if (indeg->at(v)->size() = 0) then (     que := que->including(v) ) else skip )  ) ; 
     vs := vs->excludingFirst(u) ) ; 
    OclFile["System.out"].println(if vs->size() = 0 then 0 else 1 endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class StroneGame {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      int[] ar=new int[n];
      int max=0 ;
      int min=100000 ;
      int x=0 ;
      int y=0 ;
      for(int i=0 ; i<n ; i++){
        ar[i]=sc.nextInt();
        if(ar[i]<min){
          min=ar[i];
          x=i+1 ;
        }
        if(ar[i]>max){
          max=ar[i];
          y=i+1 ;
        }
      }
      int pos1,pos2=1,pos3,pos4=1,a,b,mm,total=0 ;
      pos1=x ;
      pos2+=n-x ;
      if(pos1<pos2){
        a=pos1 ;
      }
      else {
        a=pos2 ;
      }
      pos3=y ;
      pos4+=n-y ;
      if(pos3<pos4){
        b=pos3 ;
      }
      else {
        b=pos4 ;
      }
      int div=Math.abs(y-x);
      if(div<a || div<b){
        mm=Math.min(a,b);
        total+=mm+div ;
      }
      else {
        total+=a+b ;
      }
      System.out.println(total);
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class StroneGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := 0 ;
    var min : int ; min := 100000 ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := sc.getCurrent()->toInteger() ; 
     if (ar[i+1] < min) then (     min := ar[i+1] ; 
     x := i + 1 ) else skip ; 
     if (ar[i+1] > max) then (     max := ar[i+1] ; 
     y := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    var pos1 : int ;
    var pos2 : int ; pos2 := 1 ;
    var pos3 : int ;
    var pos4 : int ; pos4 := 1 ;
    var a : int ;
    var b : int ;
    var mm : int ;
    var total : int ; total := 0 ;
    pos1 := x ; 
    pos2 := pos2+(n - x) ; 
    if (pos1 < pos2) then (     a := pos1 ) else (     a := pos2 ) ;  
    pos3 := y ; 
    pos4 := pos4+(n - y) ; 
    if (pos3 < pos4) then (     b := pos3 ) else (     b := pos4 ) ;  
    var div : int ; div := if y - x < 0 then -(y - x) else y - x endif ;
    if (div < a or div < b) then (     mm := Set{a, b}->min() ; 
     total := total+(mm + div) ) else (     total := total+(a + b) ) ;  
    OclFile["System.out"].println(total) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
import java.io.*;
public class codeHundredSixty {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=input.nextInt();
      int[] arrayOne=new int[n];
      arrayOne[0]=input.nextInt();
      int min=arrayOne[0];
      int max=arrayOne[0];
      int index1=1 ;
      int index2=1 ;
      for(int i=1 ; i<n ; i++){
        arrayOne[i]=input.nextInt();
        if(arrayOne[i]<min){
          min=arrayOne[i];
          index1=i+1 ;
        }
        else if(arrayOne[i]>max){
          max=arrayOne[i];
          index2=i+1 ;
        }
      }
      int k1=Math.min(index1,index2);
      int k2=Math.min(n-index1+1,n-index2+1);
      int gabe1=k1+k2 ;
      int gabe2=Math.max(index1,index2);
      int gabe3=Math.max(n-index1+1,n-index2+1);
      System.out.println(Math.min(gabe1,Math.min(gabe2,gabe3)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var arrayOne : Sequence(int) ; arrayOne := Integer.subrange(1,n)->collect(0) ;
    arrayOne[0+1] := input.getCurrent()->toInteger() ; 
    var min : int ; min := arrayOne[0+1] ;
    var max : int ; max := arrayOne[0+1] ;
    var index1 : int ; index1 := 1 ;
    var index2 : int ; index2 := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     arrayOne[i+1] := input.getCurrent()->toInteger() ; 
     if (arrayOne[i+1] < min) then (     min := arrayOne[i+1] ; 
     index1 := i + 1 ) else     if (arrayOne[i+1] > max) then (     max := arrayOne[i+1] ; 
     index2 := i + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    var k1 : int ; k1 := Set{index1, index2}->min() ;
    var k2 : int ; k2 := Set{n - index1 + 1, n - index2 + 1}->min() ;
    var gabe1 : int ; gabe1 := k1 + k2 ;
    var gabe2 : int ; gabe2 := Set{index1, index2}->max() ;
    var gabe3 : int ; gabe3 := Set{n - index1 + 1, n - index2 + 1}->max() ;
    OclFile["System.out"].println(Set{gabe1, Set{gabe2, gabe3}->min()}->min()) ; 
 )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
import java.io.*;
public class codeHundredSixty {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=input.nextInt();
      int[] arrayOne=new int[n];
      arrayOne[0]=input.nextInt();
      int min=arrayOne[0];
      int max=arrayOne[0];
      int index1=1 ;
      int index2=1 ;
      for(int i=1 ; i<n ; i++){
        arrayOne[i]=input.nextInt();
        if(arrayOne[i]<min){
          min=arrayOne[i];
          index1=i+1 ;
        }
        else if(arrayOne[i]>max){
          max=arrayOne[i];
          index2=i+1 ;
        }
      }
      int k1=Math.min(index1,index2);
      int k2=Math.min(n-index1+1,n-index2+1);
      int gabe1=k1+k2 ;
      int gabe2=Math.max(index1,index2);
      int gabe3=Math.max(n-index1+1,n-index2+1);
      System.out.println(Math.min(gabe1,Math.min(gabe2,gabe3)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var arrayOne : Sequence(int) ; arrayOne := Integer.subrange(1,n)->collect(0) ;
    arrayOne[0+1] := input.getCurrent()->toInteger() ; 
    var min : int ; min := arrayOne[0+1] ;
    var max : int ; max := arrayOne[0+1] ;
    var index1 : int ; index1 := 1 ;
    var index2 : int ; index2 := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     arrayOne[i+1] := input.getCurrent()->toInteger() ; 
     if (arrayOne[i+1] < min) then (     min := arrayOne[i+1] ; 
     index1 := i + 1 ) else     if (arrayOne[i+1] > max) then (     max := arrayOne[i+1] ; 
     index2 := i + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    var k1 : int ; k1 := Set{index1, index2}->min() ;
    var k2 : int ; k2 := Set{n - index1 + 1, n - index2 + 1}->min() ;
    var gabe1 : int ; gabe1 := k1 + k2 ;
    var gabe2 : int ; gabe2 := Set{index1, index2}->max() ;
    var gabe3 : int ; gabe3 := Set{n - index1 + 1, n - index2 + 1}->max() ;
    OclFile["System.out"].println(Set{gabe1, Set{gabe2, gabe3}->min()}->min()) ; 
 )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B272 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    long[] stat=new long[30];
    for(int n=0 ; n<N ; n++){
      int a=in.nextInt();
      stat[Integer.bitCount(a)]++;
    }
    long answer=0 ;
    for(long count : stat){
      answer+=count*(count-1);
    }
    answer/=2 ;
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B272 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var stat : Sequence(long) ; stat := Integer.subrange(1,30)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     stat[bitCount(a)+1] := stat[bitCount(a)+1] + 1 )  ;     n := n + 1 ) ; 
    var answer : long ; answer := 0 ;
    for (count : stat) do ( (     answer := answer+(count * (count - 1)) )  ) ; 
    answer := answer/(2) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class StoneGame {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    byte t=s.nextByte();
    byte n,x,a,b,c,d,min ;
    while(t-->0){
      n=s.nextByte();
      a=n ;
      b=1 ;
      for(byte i=0 ; i<n ; i++){
        x=s.nextByte();
        if(x==1)a=i ;
        else if(x==n)b=i ;
      }
      if(a<b){
        c=a ;
        d=b ;
      }
      else {
        c=b ;
        d=a ;
      }
      min=n ;
      min=(byte)(d+1);
      min=(byte)(((n-c)<min)? n-c : min);
      min=(byte)(((c+1+n-d)<min)? c+1+n-d : min);
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class StoneGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.nextByte() ;
     var n : int ;
    var x : int ;
    var a : int ;
    var b : int ;
    var c : int ;
    var d : int ;
    var min : int ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     n := s.nextByte() ; 
     a := n ; 
    b := 1 ; 
        var i : int ; i := 0 ; while i < n do ( (     x := s.nextByte() ; 
     if (x = 1) then     a := i ; else     if (x = n) then     b := i ; else skip ; )  ;     i := i + 1 ) ; 
    if (a < b) then (     c := a ; 
     d := b ) else (     c := b ; 
     d := a ) ;  
    min := n ; 
    min := ((d + 1) mod 128) ; 
    min := ((if ((n - c) < min) then n - c else min endif) mod 128) ; 
    min := ((if ((c + 1 + n - d) < min) then c + 1 + n - d else min endif) mod 128) ; 
    OclFile["System.out"].println(min) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Throwable {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    String first=sc.next();
    String second=sc.next();
    HashMap<String,Integer>map=new HashMap<>();
    map.put("monday",1);
    map.put("tuesday",2);
    map.put("wednesday",3);
    map.put("thursday",4);
    map.put("friday",5);
    map.put("saturday",6);
    map.put("sunday",7);
    int diff=0 ;
    if(map.get(second)>=map.get(first))diff=map.get(second)-map.get(first);
    else diff=7-map.get(first)+map.get(second);
    boolean ok=diff==0 || diff==2 || diff==3 ;
    out.println(ok ? "YES" : "NO");
    out.flush();
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var first : String ; first := sc.getCurrent() ;
    var second : String ; second := sc.getCurrent() ;
    var map : Map(String,int) ; map := Map{} ;
    map := map->union(Map{"monday" |-> 1}) ; 
    map := map->union(Map{"tuesday" |-> 2}) ; 
    map := map->union(Map{"wednesday" |-> 3}) ; 
    map := map->union(Map{"thursday" |-> 4}) ; 
    map := map->union(Map{"friday" |-> 5}) ; 
    map := map->union(Map{"saturday" |-> 6}) ; 
    map := map->union(Map{"sunday" |-> 7}) ; 
    var diff : int ; diff := 0 ;
    if (map->at(second) >= map->at(first)) then     diff := map->at(second) - map->at(first) else     diff := 7 - map->at(first) + map->at(second) ; ;  
    var ok : boolean ; ok := diff = 0 or diff = 2 or diff = 3 ;
    skip ; 
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class CodeForces {
  public static void main(String[] args){
    Scanner input=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    String s1=input.next();
    String s2=input.next();
    int first=0 ;
    int second=0 ;
    if(s1.equals("monday")){
      first=1 ;
    }
    else if(s1.equals("tuesday")){
      first=2 ;
    }
    else if(s1.equals("wednesday")){
      first=3 ;
    }
    else if(s1.equals("thursday")){
      first=4 ;
    }
    else if(s1.equals("friday")){
      first=5 ;
    }
    else if(s1.equals("saturday")){
      first=6 ;
    }
    else {
      first=0 ;
    }
    if(s2.equals("monday")){
      second=1 ;
    }
    else if(s2.equals("tuesday")){
      second=2 ;
    }
    else if(s2.equals("wednesday")){
      second=3 ;
    }
    else if(s2.equals("thursday")){
      second=4 ;
    }
    else if(s2.equals("friday")){
      second=5 ;
    }
    else if(s2.equals("saturday")){
      second=6 ;
    }
    else {
      second=0 ;
    }
    if((first+31)% 7==second ||(first+28)% 7==second ||(first+30)% 7==second){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var s1 : String ; s1 := input.getCurrent() ;
    var s2 : String ; s2 := input.getCurrent() ;
    var first : int ; first := 0 ;
    var second : int ; second := 0 ;
    if (s1 = "monday") then (     first := 1 ) else     if (s1 = "tuesday") then (     first := 2 ) else     if (s1 = "wednesday") then (     first := 3 ) else     if (s1 = "thursday") then (     first := 4 ) else     if (s1 = "friday") then (     first := 5 ) else     if (s1 = "saturday") then (     first := 6 ) else (     first := 0 ) ;  ;  ;  ;  ;  ;  
    if (s2 = "monday") then (     second := 1 ) else     if (s2 = "tuesday") then (     second := 2 ) else     if (s2 = "wednesday") then (     second := 3 ) else     if (s2 = "thursday") then (     second := 4 ) else     if (s2 = "friday") then (     second := 5 ) else     if (s2 = "saturday") then (     second := 6 ) else (     second := 0 ) ;  ;  ;  ;  ;  ;  
    if ((first + 31) mod 7 = second or (first + 28) mod 7 = second or (first + 30) mod 7 = second) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.PrintWriter ;
public class r1 {
  static PrintWriter o=new PrintWriter(System.out);
  public static void main(String[] args){
    Scanner bh=new Scanner(System.in);
    String str1=bh.next();
    String str2=bh.next();
    String day[]={
      "monday","tuesday","wednesday","thursday","friday","saturday","sunday" };
      int n1=-1 ;
      int n2=-1 ;
      for(int i=0 ; i<7 ; i++){
        if(str1.equals(day[i])){
          n1=i ;
        }
        if(str2.equals(day[i])){
          n2=i ;
        }
      }
      if(n1==n2 ||(n1+2)% 7==n2 ||(n1+3)% 7==n2){
        o.println("YES");
      }
      else {
        o.println("NO");
      }
      o.close();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class r1 {
  static   attribute o : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bh : OclFile ; bh := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str1 : String ; str1 := bh.getCurrent() ;
    var str2 : String ; str2 := bh.getCurrent() ;
    var day : Sequence(String) ; day := Sequence{"monday","tuesday","wednesday","thursday","friday","saturday","sunday"} ;
    var n1 : int ; n1 := -1 ;
    var n2 : int ; n2 := -1 ;
        var i : int ; i := 0 ; while i < 7 do ( (     if (str1 = day[i+1]) then (     n1 := i ) else skip ; 
     if (str2 = day[i+1]) then (     n2 := i ) else skip )  ;     i := i + 1 ) ; 
    if (n1 = n2 or (n1 + 2) mod 7 = n2 or (n1 + 3) mod 7 = n2) then (     skip ) else (     skip ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    boolean f=false ;
    boolean s=false ;
    int ind=0 ;
    String[] x=new String[n];
    for(int i=0 ; i<n ; i++){
      x[i]=in.next();
      if(f==false){
        if(x[i] .contains("OO")){
          f=true ;
          ind=i ;
        }
      }
    }
    if(f==true){
      System.out.println("YES");
      for(int i=0 ; i<n ; i++){
        if(i!=ind){
          System.out.println(x[i]);
        }
        else {
          if(x[i] .substring(0,2).equals("OO")){
            System.out.print("++"+x[i] .substring(2,5)+"\n");
          }
          else if(x[i] .substring(3,5).equals("OO"))System.out.print(x[i] .substring(0,3)+"++"+"\n");
        }
      }
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var f : boolean ; f := false ;
    var s : boolean ; s := false ;
    var ind : int ; ind := 0 ;
    var x : Sequence(String) ; x := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := in.getCurrent() ; 
     if (f = false) then (     if (x[i+1]->includes("OO")) then (     f := true ; 
     ind := i ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (f = true) then (     OclFile["System.out"].println("YES") ; 
         var i : int ; i := 0 ; while i < n do ( (     if (i /= ind) then (     OclFile["System.out"].println(x[i+1]) ) else (     if (x[i+1].subrange(0+1,2) = "OO") then (     OclFile["System.out"].print("++" + x[i+1].subrange(2+1,5) + "\n") ) else     if (x[i+1].subrange(3+1,5) = "OO") then     OclFile["System.out"].print(x[i+1].subrange(0+1,3) + "++" + "\n") ; else skip ; ) )  ;     i := i + 1 ) ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test212 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    boolean x=false ;
    char a[][]=new char[t][];
    for(int j=0 ; j<t ; j++){
      char b[]=in.next().toCharArray();
      a[j]=b ;
      if(! x){
        if(a[j][0]=='O' && a[j][1]=='O'){
          a[j][0]='+' ;
          a[j][1]='+' ;
          x=true ;
        }
        else if(a[j][3]=='O' && a[j][4]=='O'){
          a[j][3]='+' ;
          a[j][4]='+' ;
          x=true ;
        }
      }
    }
    if(x){
      System.out.println("YES");
      for(int i=0 ; i<a.length ; i++){
        for(int j=0 ; j<a[i] .length ; j++){
          System.out.print(a[i][j]);
        }
        System.out.println();
      }
    }
    else {
      System.out.println("NO");
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test212 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var x : boolean ; x := false ;
    var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,t)->collect(Sequence{}) ;
        var j : int ; j := 0 ; while j < t do ( (     var b : Sequence(String) ; b := in.getCurrent()->characters() ;
     a[j+1] := b ; 
     if (not(x)) then (     if (a[j+1][0+1] = 'O' & a[j+1][1+1] = 'O') then (     a[j+1][0+1] := '+' ; 
     a[j+1][1+1] := '+' ; 
     x := true ) else     if (a[j+1][3+1] = 'O' & a[j+1][4+1] = 'O') then (     a[j+1][3+1] := '+' ; 
     a[j+1][4+1] := '+' ; 
     x := true ) else skip ; ) else skip )  ;     j := j + 1 ) ; 
    if (x) then (     OclFile["System.out"].println("YES") ; 
         var i : int ; i := 0 ; while i < a->size() do ( (         var j : int ; j := 0 ; while j < a[i+1]->size() do ( (     OclFile["System.out"].print(a[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ) else (     OclFile["System.out"].println("NO") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int countWays(int N){
    int E=(N*(N-1))/2 ;
    if(N==1)return 0 ;
    return(int)Math.pow(2,E-1);
  }
  public static void main(String[] args){
    int N=4 ;
    System.out.println(countWays(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation countWays( N : int) : int
  pre: true
  post: true
  activity: (     var E : int ; E := (N * (N - 1)) / 2 ;
     if (N = 1) then     return 0 else skip ; 
     return 2->pow(E - 1)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(countWays(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _711A_BustoUdayland {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int rows=parseInt(input.nextLine());
    String result="" ;
    boolean found=false ;
    for(int i=0 ; i<rows ; i++){
      String seats=input.nextLine();
      int index=seats.indexOf("OO");
      if(! found && index>=0){
        found=true ;
        seats=seats.replaceFirst("OO","++");
      }
      if(i==rows-1){
        result+=seats ;
      }
      else {
        result+=seats+"\n" ;
      }
    }
    if(found){
      System.out.println("YES");
      System.out.println(result);
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _711A_BustoUdayland {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var rows : int ; rows := parseInt(input.nextLine()) ;
    var result : String ; result := "" ;
    var found : boolean ; found := false ;
        var i : int ; i := 0 ; while i < rows do ( (     var seats : String ; seats := input.nextLine() ;
     var index : int ; index := seats->indexOf("OO")-1 ;
     if (not(found) & index >= 0) then (     found := true ; 
     seats := seats.replaceFirstMatch("OO", "++") ) else skip ; 
     if (i = rows - 1) then (     result := result+(seats) ) else (     result := result+(seats + "\n") ) )  ;     i := i + 1 ) ; 
    if (found) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(result) ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    char[][] s=new char[t][5];
    for(int i=0 ; i<t ; i++){
      String c=sc.next();
      for(int j=0 ; j<5 ; j++){
        s[i][j]=c.charAt(j);
      }
    }
    String str=solution(t,s);
    System.out.println(str);
    if(str.equals("Yes")){
      int c=0 ;
      for(int i=0 ; i<t ; i++){
        for(int j=0 ; j<4 ; j++){
          if(s[i][j]=='O' && s[i][j+1]=='O'){
            s[i][j]='+' ;
            s[i][j+1]='+' ;
            c++;
            break ;
          }
        }
        if(c>0){
          break ;
        }
      }
      for(int i=0 ; i<t ; i++){
        for(int j=0 ; j<5 ; j++){
          System.out.print(s[i][j]);
        }
        System.out.println();
      }
    }
  }
  public static String solution(int t,char[][] s){
    for(int i=0 ; i<t ; i++){
      for(int j=0 ; j<4 ; j++){
        if(s[i][j]=='O' && s[i][j+1]=='O'){
          return "Yes" ;
        }
      }
    }
    return "No" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var s : Sequence(Sequence(String)) ; s := Integer.subrange(1,t)->collect(Integer.subrange(1,5)->collect(0)) ;
        var i : int ; i := 0 ; while i < t do ( (     var c : String ; c := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < 5 do ( (     s[i+1][j+1] := c->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var str : String ; str := solution(t, s) ;
    OclFile["System.out"].println(str) ; 
    if (str = "Yes") then (     var c : int ; c := 0 ;
         var i : int ; i := 0 ; while i < t do ( (         var j : int ; j := 0 ; while j < 4 do ( (     if (s[i+1][j+1] = 'O' & s[i+1][j + 1+1] = 'O') then (     s[i+1][j+1] := '+' ; 
     s[i+1][j + 1+1] := '+' ; 
     c := c + 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (c > 0) then (     break ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < t do ( (         var j : int ; j := 0 ; while j < 5 do ( (     OclFile["System.out"].print(s[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ) else skip ; 
 );
  static   operation solution( t : int, s : Sequence(Sequence(String))) : String
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < t do ( (         var j : int ; j := 0 ; while j < 4 do ( (     if (s[i+1][j+1] = 'O' & s[i+1][j + 1+1] = 'O') then (     return "Yes" ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return "No" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Node {
    int data ;
    Node next ;
    Node(int x){
      data=x ;
      next=null ;
    }
  };
  static void printList(Node head){
    if(head==null)return ;
    Node temp=head ;
    do {
      System.out.print(temp.data+"->");
      temp=temp.next ;
    }
    while(temp!=head);
    System.out.println(head.data);
  }
  static Node deleteK(Node head_ref,int k){
    Node head=head_ref ;
    if(head==null)return null ;
    Node curr=head,prev=null ;
    while(true){
      if(curr.next==head && curr==head)break ;
      printList(head);
      for(int i=0 ; i<k ; i++){
        prev=curr ;
        curr=curr.next ;
      }
      if(curr==head){
        prev=head ;
        while(prev.next!=head)prev=prev.next ;
        head=curr.next ;
        prev.next=head ;
        head_ref=head ;
      }
      else if(curr.next==head){
        prev.next=head ;
      }
      else {
        prev.next=curr.next ;
      }
    }
    return head ;
  }
  static Node insertNode(Node head_ref,int x){
    Node head=head_ref ;
    Node temp=new Node(x);
    if(head==null){
      temp.next=temp ;
      head_ref=temp ;
      return head_ref ;
    }
    else {
      Node temp1=head ;
      while(temp1.next!=head)temp1=temp1.next ;
      temp1.next=temp ;
      temp.next=head ;
    }
    return head ;
  }
  public static void main(String args[]){
    Node head=null ;
    head=insertNode(head,1);
    head=insertNode(head,2);
    head=insertNode(head,3);
    head=insertNode(head,4);
    head=insertNode(head,5);
    head=insertNode(head,6);
    head=insertNode(head,7);
    head=insertNode(head,8);
    head=insertNode(head,9);
    int k=4 ;
    head=deleteK(head,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
   static operation newNode( x : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(x);
    return self );
  operation initialise( x : int) : void
  pre: true  post: true
  activity: (     data := x ; 
     next := null );
}
  static   operation printList( head : Node) : void
  pre: true
  post: true
  activity: (     if (head = null) then     return else skip ; 
     var temp : Node ; temp := head ;
   while true do ((     OclFile["System.out"].print(temp.data + "->") ; 
     temp := temp.next ) ;
    if (temp /= head) then skip else break) ; 
     OclFile["System.out"].println(head.data) );
  static   operation deleteK( head_ref : Node, k : int) : Node
  pre: true
  post: true
  activity: (     var head : Node ; head := head_ref ;
     if (head = null) then     return null else skip ; 
    var curr : Node ; curr := head ;
    var prev : Node ; prev := null ;
    while (true) do (     if (curr.next = head & curr = head) then     break else skip ; 
     execute printList(head) ; 
         var i : int ; i := 0 ; while i < k do ( (     prev := curr ; 
     curr := curr.next )  ;     i := i + 1 ) ; 
     if (curr = head) then (     prev := head ; 
     while (prev.next /= head) do     prev := prev.next ; ; 
    head := curr.next ; 
    prev.next := head ; 
    head_ref := head ; 
 ) else     if (curr.next = head) then (     prev.next := head ) else (     prev.next := curr.next ) ;  ) ; 
    return head 
 );
  static   operation insertNode( head_ref : Node, x : int) : Node
  pre: true
  post: true
  activity: (     var head : Node ; head := head_ref ;
     var temp : Node ; temp := Node.newNode(x) ;
     if (head = null) then (     temp.next := temp ; 
     head_ref := temp ; 
     return head_ref ) else (     var temp1 : Node ; temp1 := head ;
     while (temp1.next /= head) do     temp1 := temp1.next ; ; 
     temp1.next := temp ; 
     temp.next := head ) ;  
     return head );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := null ;
     head := insertNode(head, 1) ; 
    head := insertNode(head, 2) ; 
    head := insertNode(head, 3) ; 
    head := insertNode(head, 4) ; 
    head := insertNode(head, 5) ; 
    head := insertNode(head, 6) ; 
    head := insertNode(head, 7) ; 
    head := insertNode(head, 8) ; 
    head := insertNode(head, 9) ; 
    var k : int ; k := 4 ;
    head := deleteK(head, k) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int steps(int cur,int x,int n){
    if(x==0)return Integer.MAX_VALUE ;
    if(x>0)return Math.abs((n-cur)/x);
    else return Math.abs((cur-1)/x);
  }
  static int countSteps(int curx,int cury,int n,int m,int[][] moves){
    int count=0 ;
    int k=moves.length ;
    for(int i=0 ; i<k ; i++){
      int x=moves[i][0];
      int y=moves[i][1];
      int stepct=Math.min(steps(curx,x,n),steps(cury,y,m));
      count+=stepct ;
      curx+=stepct*x ;
      cury+=stepct*y ;
    }
    return count ;
  }
  public static void main(String[] args){
    int n=4,m=5,x=1,y=1 ;
    int[][] moves={
      {
        1,1 },{
          1,1 },{
            0,-2 }
          };
          System.out.print(countSteps(x,y,n,m,moves));
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation steps( cur : int, x : int, n : int) : int
  pre: true
  post: true
  activity: (     if (x = 0) then     return 2147483647 else skip ; 
     if (x > 0) then     return if (n - cur) / x < 0 then -((n - cur) / x) else (n - cur) / x endif else     return if (cur - 1) / x < 0 then -((cur - 1) / x) else (cur - 1) / x endif );
  static   operation countSteps( curx : int, cury : int, n : int, m : int, moves : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var k : int ; k := moves->size() ;
         var i : int ; i := 0 ; while i < k do ( (     var x : int ; x := moves[i+1][0+1] ;
     var y : int ; y := moves[i+1][1+1] ;
    var stepct : int ; stepct := Set{steps(curx, x, n), steps(cury, y, m)}->min() ;
    count := count+(stepct) ; 
    curx := curx+(stepct * x) ; 
    cury := cury+(stepct * y) ; 
 )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
    var m : int ; m := 5 ;
    var x : int ; x := 1 ;
    var y : int ; y := 1 ;
     var moves : Sequence(Sequence(int)) ; moves := Sequence{Sequence{1,1},Sequence{1,1},Sequence{0,-2}} ;
     OclFile["System.out"].print(countSteps(x, y, n, m, moves)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Zad272B {
  public static void main(String[] args){
    FastReader sc=new FastReader();
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    int a[]=new int[33];
    for(int i=0 ; i<n ; i++){
      a[rec(sc.nextInt())]++;
    }
    double answer=0 ;
    for(int i=0 ; i<a.length ; i++){
      double summ=(1+a[i]-1)/2.0*(a[i]-1);
      answer+=summ ;
    }
    out.println((long)answer);
    out.close();
  }
  static int rec(long x){
    int answer=0 ;
    for(int k=31 ; k>=0 ; k--){
      if((x &(1<<k))!=0)answer++;
    }
    return answer ;
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Zad272B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,33)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[rec(sc.nextInt())+1] := a[rec(sc.nextInt())+1] + 1 )  ;     i := i + 1 ) ; 
    var answer : double ; answer := 0 ;
        var i : int ; i := 0 ; while i < a->size() do ( (     var summ : double ; summ := (1 + a[i+1] - 1) / 2.0 * (a[i+1] - 1) ;
     answer := answer+(summ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation rec( x : long) : int
  pre: true
  post: true
  activity: (     var answer : int ; answer := 0 ;
         var k : int ; k := 31 ; while k >= 0 do ( (     if ((x & ((1*(2->pow(k)))->oclAsType(long))) /= 0) then     answer := answer + 1 ; else skip )  ;     k := k - 1 ) ; 
     return answer );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static ArrayList md=new ArrayList();
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int x1=in.nextInt();
    int x2=in.nextInt();
    int x3=in.nextInt();
    int point=Math.min(x1,Math.min(x2,x3));
    if((x1>x2 && x1<x3)||(x1>x3 && x1<x2)){
      point=x1 ;
    }
    else if((x1>x2 && x2>x3)||(x2<x3 && x2>x1)){
      point=x2 ;
    }
    else point=x3 ;
    int d=0 ;
    d=(Math.abs(x1-point)+Math.abs(x2-point)+Math.abs(x3-point));
    System.out.println(d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute md : Sequence := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : int ; x1 := in.getCurrent()->toInteger() ;
    var x2 : int ; x2 := in.getCurrent()->toInteger() ;
    var x3 : int ; x3 := in.getCurrent()->toInteger() ;
    var point : int ; point := Set{x1, Set{x2, x3}->min()}->min() ;
    if ((x1 > x2 & x1 < x3) or (x1 > x3 & x1 < x2)) then (     point := x1 ) else     if ((x1 > x2 & x2 > x3) or (x2 < x3 & x2 > x1)) then (     point := x2 ) else     point := x3 ; ;  ;  
    var d : int ; d := 0 ;
    d := (if x1 - point < 0 then -(x1 - point) else x1 - point endif + if x2 - point < 0 then -(x2 - point) else x2 - point endif + if x3 - point < 0 then -(x3 - point) else x3 - point endif) ; 
    OclFile["System.out"].println(d) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Ideone {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int a[]=new int[3];
    for(int i=0 ; i<3 ; i++){
      a[i]=sc.nextInt();
    }
    Arrays.sort(a);
    System.out.println((a[1]-a[0])+(a[2]-a[1]));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ideone {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    OclFile["System.out"].println((a[1+1] - a[0+1]) + (a[2+1] - a[1+1])) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class theNewYear {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x1=sc.nextInt();
    int x2=sc.nextInt();
    int x3=sc.nextInt();
    int d1=Math.abs(x1-x2)+Math.abs(x1-x3);
    int d2=Math.abs(x2-x1)+Math.abs(x2-x3);
    int d3=Math.abs(x3-x1)+Math.abs(x3-x2);
    System.out.println(Math.min(d1,Math.min(d2,d3)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class theNewYear {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : int ; x1 := sc.getCurrent()->toInteger() ;
    var x2 : int ; x2 := sc.getCurrent()->toInteger() ;
    var x3 : int ; x3 := sc.getCurrent()->toInteger() ;
    var d1 : int ; d1 := if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif + if x1 - x3 < 0 then -(x1 - x3) else x1 - x3 endif ;
    var d2 : int ; d2 := if x2 - x1 < 0 then -(x2 - x1) else x2 - x1 endif + if x2 - x3 < 0 then -(x2 - x3) else x2 - x3 endif ;
    var d3 : int ; d3 := if x3 - x1 < 0 then -(x3 - x1) else x3 - x1 endif + if x3 - x2 < 0 then -(x3 - x2) else x3 - x2 endif ;
    OclFile["System.out"].println(Set{d1, Set{d2, d3}->min()}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeMap ;
import java.io.*;
public class Solution {
  public static void main(String[] args)throws IOException {
    if(System.getProperty("ONLINE_JUDGE")==null){
      PrintStream ps=new PrintStream(new File("output.txt"));
      InputStream is=new FileInputStream("input.txt");
      System.setIn(is);
      System.setOut(ps);
    }
    solve();
  }
  public static void solve(){
    Scanner sc=new Scanner(System.in);
    int n,k,l,c,d,p,nl,np ;
    int[] arr=new int[3];
    for(int i=0 ; i<3 ; i++)arr[i]=sc.nextInt();
    Arrays.sort(arr);
    System.out.println(arr[2]-arr[0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null) then (     var ps : OclFile ; ps := OclFile.newOclFile_Write(OclFile("output.txt")) ;
     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile.newOclFile("input.txt")) ;
 setIn(is) ; 
 setOut(ps) ) else skip ; 
     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var k : int ;
    var l : int ;
    var c : int ;
    var d : int ;
    var p : int ;
    var nl : int ;
    var np : int ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    OclFile["System.out"].println(arr[2+1] - arr[0+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Ideone {
  public static int getMin(int h,int b,int c){
    int min=h ;
    if(b<min){
      min=b ;
    }
    if(c<min){
      min=c ;
    }
    return min ;
  }
  public static void main(String[] args)throws java.lang.Exception {
    int[] arr=new int[3];
    Scanner sc=new Scanner(System.in);
    for(int i=0 ; i<3 ; i++){
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr);
    int h=(arr[1]-arr[0])+(arr[2]-arr[0]);
    int b=(arr[1]-arr[0])+(arr[2]-arr[1]);
    int c=(arr[2]-arr[0])+(arr[2]-arr[1]);
    System.out.println(getMin(h,b,c));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ideone {
  static   operation getMin( h : int, b : int, c : int) : int
  pre: true
  post: true
  activity: (     var min : int ; min := h ;
     if (b < min) then (     min := b ) else skip ; 
     if (c < min) then (     min := c ) else skip ; 
     return min );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,3)->collect(0) ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
        var i : int ; i := 0 ; while i < 3 do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var h : int ; h := (arr[1+1] - arr[0+1]) + (arr[2+1] - arr[0+1]) ;
    var b : int ; b := (arr[1+1] - arr[0+1]) + (arr[2+1] - arr[1+1]) ;
    var c : int ; c := (arr[2+1] - arr[0+1]) + (arr[2+1] - arr[1+1]) ;
    OclFile["System.out"].println(getMin(h, b, c)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      int n=scanner.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; i++){
        a[i]=scanner.nextInt();
      }
      for(int i=n-1 ; i>=0 ; i--){
        if(i>=n/2){
          System.out.print(-a[i]+" ");
        }
        else {
          System.out.print(a[i]+" ");
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (i >= n / 2) then (     OclFile["System.out"].print(-a[i+1] + " ") ) else (     OclFile["System.out"].print(a[i+1] + " ") ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int cntSubArr(int[] arr,int n){
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      int curr_gcd=0 ;
      for(int j=i ; j<n ; j++){
        curr_gcd=__gcd(curr_gcd,arr[j]);
        ans+=(curr_gcd==1)? 1 : 0 ;
      }
    }
    return ans ;
  }
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  public static void main(String[] args){
    int arr[]={
      1,1,1 };
      int n=arr.length ;
      System.out.println(cntSubArr(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation cntSubArr( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var curr_gcd : int ; curr_gcd := 0 ;
         var j : int ; j := i ; while j < n do ( (     curr_gcd := __gcd(curr_gcd, arr[j+1]) ; 
     ans := ans+(if (curr_gcd = 1) then 1 else 0 endif) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(cntSubArr(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isVowel(char c){
    if(c=='a' || c=='e' || c=='i' || c=='o' || c=='u')return true ;
    return false ;
  }
  static boolean isVowelPrime(String str,int n){
    boolean[] prime=new boolean[n];
    Arrays.fill(prime,true);
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<n ; p++){
      if(prime[p]==true){
        for(int i=p*p ; i<n ; i+=p)prime[i]=false ;
      }
    }
    for(int i=0 ; i<n ; i++){
      if(isVowel(str.charAt(i))&& ! prime[i])return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    int n=str.length();
    if(isVowelPrime(str,n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isVowel( c : String) : boolean
  pre: true
  post: true
  activity: (     if (c = 'a' or c = 'e' or c = 'i' or c = 'o' or c = 'u') then     return true else skip ; 
     return false );
  static   operation isVowelPrime( str : String, n : int) : boolean
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,n)->collect(false) ;
     prime := prime->collect(true) ; 
    prime[0+1] := false ; 
    prime[1+1] := false ; 
        var p : int ; p := 2 ; while p * p < n do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * p ; while i < n do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (isVowel(str->at(i+1)) & not(prime[i+1])) then     return false else skip )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var n : int ; n := str->size() ;
     if (isVowelPrime(str, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int minStepToDeleteString(String str){
    int N=str.length();
    int[][] dp=new int[N+1][N+1];
    for(int i=0 ; i<=N ; i++)for(int j=0 ; j<=N ; j++)dp[i][j]=0 ;
    for(int len=1 ; len<=N ; len++){
      for(int i=0,j=len-1 ; j<N ; i++,j++){
        if(len==1)dp[i][j]=1 ;
        else {
          dp[i][j]=1+dp[i+1][j];
          if(str.charAt(i)==str.charAt(i+1))dp[i][j]=Math.min(1+dp[i+2][j],dp[i][j]);
          for(int K=i+2 ; K<=j ; K++)if(str.charAt(i)==str.charAt(K))dp[i][j]=Math.min(dp[i+1][K-1]+dp[K+1][j],dp[i][j]);
        }
      }
    }
    return dp[0][N-1];
  }
  public static void main(String args[]){
    String str="2553432" ;
    System.out.println(minStepToDeleteString(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minStepToDeleteString( str : String) : int
  pre: true
  post: true
  activity: (     var N : int ; N := str->size() ;
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i <= N do (         var j : int ; j := 0 ; while j <= N do (     dp[i+1][j+1] := 0 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var len : int ; len := 1 ; while len <= N do ( (         var i : int ; i := 0 ;
    var j : int ; j := len - 1 ; while j < N do ( (     if (len = 1) then     dp[i+1][j+1] := 1 ; else (     dp[i+1][j+1] := 1 + dp[i + 1+1][j+1] ; 
     if (str->at(i+1) = str->at(i + 1+1)) then     dp[i+1][j+1] := Set{1 + dp[i + 2+1][j+1], dp[i+1][j+1]}->min() ; else skip ; 
         var K : int ; K := i + 2 ; while K <= j do (     if (str->at(i+1) = str->at(K+1)) then     dp[i+1][j+1] := Set{dp[i + 1+1][K - 1+1] + dp[K + 1+1][j+1], dp[i+1][j+1]}->min() ; else skip ;  ;     K := K + 1 ) ) )  ;     i := i + 1 ;     j := j + 1 ) )  ;     len := len + 1 ) ; 
    return dp[0+1][N - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "2553432" ;
     OclFile["System.out"].println(minStepToDeleteString(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int limit=10000000 ;
  static int[] position=new int[limit+1];
  static void sieve(){
    position[0]=-1 ;
    position[1]=-1 ;
    int pos=0 ;
    for(int i=2 ; i<=limit ; i++){
      if(position[i]==0){
        position[i]=++pos ;
        for(int j=i*2 ; j<=limit ; j+=i)position[j]=-1 ;
      }
    }
  }
  public static void main(String[] args){
    sieve();
    int n=11 ;
    System.out.print(position[n]);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute limit : int := 10000000;
  static   attribute position : Sequence(int) := Integer.subrange(1,limit + 1)->collect(0);
  static   operation sieve() : void
  pre: true
  post: true
  activity: (     position[0+1] := -1 ; 
     position[1+1] := -1 ; 
     var pos : int ; pos := 0 ;
         var i : int ; i := 2 ; while i <= limit do ( (     if (position[i+1] = 0) then (         pos := pos + 1 ;
 position[i+1] := pos  ; 
         var j : int ; j := i * 2 ; while j <= limit do (     position[j+1] := -1 ;  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute sieve() ; 
     var n : int ; n := 11 ;
     OclFile["System.out"].print(position[n+1]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int DP_s=9 ;
  static int getNumMonotone(int len){
    int[][] DP=new int[len][DP_s];
    for(int i=0 ; i<DP_s ; ++i)DP[0][i]=i+1 ;
    for(int i=0 ; i<len ; ++i)DP[i][0]=1 ;
    for(int i=1 ; i<len ; ++i)for(int j=1 ; j<DP_s ; ++j)DP[i][j]=DP[i-1][j]+DP[i][j-1];
    return DP[len-1][DP_s-1];
  }
  public static void main(String[] args){
    System.out.println(getNumMonotone(10));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute DP_s : int := 9;
  static   operation getNumMonotone( len : int) : int
  pre: true
  post: true
  activity: (     var DP : Sequence(Sequence(int)) ; DP := Integer.subrange(1,len)->collect(Integer.subrange(1,DP_s)->collect(0)) ;
         var i : int ; i := 0 ; while i < DP_s do (     DP[0+1][i+1] := i + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < len do (     DP[i+1][0+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < len do (         var j : int ; j := 1 ; while j < DP_s do (     DP[i+1][j+1] := DP[i - 1+1][j+1] + DP[i+1][j - 1+1] ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return DP[len - 1+1][DP_s - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(getNumMonotone(10)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int N=100010 ;
  static Map<Integer,Integer>mp=new HashMap<Integer,Integer>();
  static int n ;
  static long ans ;
  static int get(int x){
    if(x==0)return 0 ;
    else if(x % 2==0)return get(x/2);
    else return get((x-1)/2)+1 ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    n=in.nextInt();
    while(n-->0){
      int t=in.nextInt();
      int tt=get(t);
      if(! mp.containsKey(tt))mp.put(tt,1);
      else mp.put(tt,mp.get(tt)+1);
    }
    for(Integer i : mp.keySet()){
      int t=mp.get(i);
      ans+=(long)t*(t-1)/2 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int := 100010;
  static   attribute mp : Map(int,int) := Map{};
  static   attribute n : int;
  static   attribute ans : long;
  static   operation get( x : int) : int
  pre: true
  post: true
  activity: (     if (x = 0) then     return 0 else     if (x mod 2 = 0) then     return at(x / 2+1) else     return at((x - 1) / 2+1) + 1 ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := in.getCurrent()->toInteger() ; 
        while (n > 0) do (        n := n - 1 ;     skip ; (     var t : int ; t := in.getCurrent()->toInteger() ;
     var tt : int ; tt := get(t) ;
     if (not(mp->keys()->includes(tt))) then     mp := mp->union(Map{tt |-> 1}) ; else     mp := mp->union(Map{tt |-> mp->at(tt) + 1}) ; ) ;  ) ;  
    for (i : mp->keys()) do ( (     var t : int ; t := mp->at(i) ;
     ans := ans+(t->oclAsType(long) * (t - 1) / 2) )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int DP_s=9 ;
  static int getNumMonotone(int len){
    int[][] DP=new int[len][DP_s];
    for(int i=0 ; i<DP_s ; ++i)DP[0][i]=i+1 ;
    for(int i=0 ; i<len ; ++i)DP[i][0]=1 ;
    for(int i=1 ; i<len ; ++i)for(int j=1 ; j<DP_s ; ++j)DP[i][j]=DP[i-1][j]+DP[i][j-1];
    return DP[len-1][DP_s-1];
  }
  public static void main(String[] args){
    System.out.println(getNumMonotone(10));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute DP_s : int := 9;
  static   operation getNumMonotone( len : int) : int
  pre: true
  post: true
  activity: (     var DP : Sequence(Sequence(int)) ; DP := Integer.subrange(1,len)->collect(Integer.subrange(1,DP_s)->collect(0)) ;
         var i : int ; i := 0 ; while i < DP_s do (     DP[0+1][i+1] := i + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < len do (     DP[i+1][0+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < len do (         var j : int ; j := 1 ; while j < DP_s do (     DP[i+1][j+1] := DP[i - 1+1][j+1] + DP[i+1][j - 1+1] ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return DP[len - 1+1][DP_s - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(getNumMonotone(10)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int maxCost(int a[],int n,int l,int r){
    int mx=0,k ;
    for(int i=0 ; i<n ; ++i)mx=Math.max(mx,a[i]);
    int[] count=new int[mx+1];
    for(int i=0 ; i<count.length ; i++)count[i]=0 ;
    for(int i=0 ; i<n ; i++)count[a[i] ]++;
    int[] res=new int[mx+1];
    res[0]=0 ;
    l=Math.min(l,r);
    for(int num=1 ; num<=mx ; num++){
      k=Math.max(num-l-1,0);
      res[num]=Math.max(res[num-1],num*count[num]+res[k]);
    }
    return res[mx];
  }
  public static void main(String[] args){
    int a[]={
      2,1,2,3,2,2,1 },l=1,r=1 ;
      int n=a.length ;
      System.out.println(maxCost(a,n,l,r));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxCost( a : Sequence(int), n : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     var mx : int ; mx := 0 ;
    var k : int ;
         var i : int ; i := 0 ; while i < n do (     mx := Set{mx, a[i+1]}->max() ;  ;     i := i + 1 ) ; 
    var count : Sequence(int) ; count := Integer.subrange(1,mx + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < count->size() do (     count[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     count[a[i+1]+1] := count[a[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
    var res : Sequence(int) ; res := Integer.subrange(1,mx + 1)->collect(0) ;
    res[0+1] := 0 ; 
    l := Set{l, r}->min() ; 
        var num : int ; num := 1 ; while num <= mx do ( (     k := Set{num - l - 1, 0}->max() ; 
     res[num+1] := Set{res[num - 1+1], num * count[num+1] + res[k+1]}->max() )  ;     num := num + 1 ) ; 
    return res[mx+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(void) ; a := Sequence{2,1,2,3,2,2,1} ;
    var l : int ; l := 1 ;
    var r : int ; r := 1 ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(maxCost(a, n, l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1680 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int R=in.nextInt();
      int C=in.nextInt();
      char[][] A=new char[R][];
      for(int r=0 ; r<R ; r++){
        A[r]=in.next().toCharArray();
      }
      int r=-1 ;
      int c=-1 ;
      outer : for(int rr=0 ;
      rr<R ;
      rr++){
        for(int cc=0 ; cc<C ; cc++){
          if(A[rr][cc]=='R'){
            r=rr ;
            c=cc ;
            break outer ;
          }
        }
      }
      boolean ok=true ;
      for(int rr=r+1 ; rr<R ; rr++){
        for(int cc=0 ; cc<c ; cc++){
          if(A[rr][cc]=='R'){
            ok=false ;
          }
        }
      }
      System.out.println(ok ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1680 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var R : int ; R := in.getCurrent()->toInteger() ;
     var C : int ; C := in.getCurrent()->toInteger() ;
    var A : Sequence(Sequence(String)) ; A := Integer.subrange(1,R)->collect(Sequence{}) ;
        var r : int ; r := 0 ; while r < R do ( (     A[r+1] := in.getCurrent()->characters() )  ;     r := r + 1 ) ; 
    var r : int ; r := -1 ;
    var c : int ; c := -1 ;
        var rr : int ; rr := 0 ; while rr < R do ( (         var cc : int ; cc := 0 ; while cc < C do ( (     if (A[rr+1][cc+1] = 'R') then (     r := rr ; 
     c := cc ; 
     break ) else skip )  ;     cc := cc + 1 ) )  ;     rr := rr + 1 ) ; 
    var ok : boolean ; ok := true ;
        var rr : int ; rr := r + 1 ; while rr < R do ( (         var cc : int ; cc := 0 ; while cc < c do ( (     if (A[rr+1][cc+1] = 'R') then (     ok := false ) else skip )  ;     cc := cc + 1 ) )  ;     rr := rr + 1 ) ; 
    OclFile["System.out"].println(if ok then "YES" else "NO" endif) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static PrintWriter out=new PrintWriter(System.out);
  static Scanner in=new Scanner(System.in);
  static BufferedReader re=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter wr=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws IOException {
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int T=in.nextInt();
    while(T>0){
      int t=0 ;
      int n=in.nextInt();
      int m=in.nextInt();
      char arr[][]=new char[n][m];
      for(int i=0 ; i<n ; i++){
        String s=in.next();
        arr[i]=s.toCharArray();
      }
      int x=0,y=0 ;
      int x1=0,y1=0 ;
      for(int i=0 ; i<n ; i++){
        int v=0 ;
        for(int j=0 ; j<m ; j++){
          if(arr[i][j]=='R'){
            x=i ;
            y=j ;
            v++;
            break ;
          }
        }
        if(v>0){
          break ;
        }
      }
      for(int i=0 ; i<m ; i++){
        int v=0 ;
        for(int j=0 ; j<n ; j++){
          if(arr[j][i]=='R'){
            x1=j ;
            y1=i ;
            v++;
            break ;
          }
        }
        if(v>0){
          break ;
        }
      }
      if(y1<y){
        out.println("NO");
      }
      else out.println("YES");
      T--;
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute re : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute wr : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
     while (T > 0) do (     var t : int ; t := 0 ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(String)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := in.getCurrent() ;
     arr[i+1] := s->characters() )  ;     i := i + 1 ) ; 
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var x1 : int ; x1 := 0 ;
    var y1 : int ; y1 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := 0 ;
         var j : int ; j := 0 ; while j < m do ( (     if (arr[i+1][j+1] = 'R') then (     x := i ; 
     y := j ; 
     v := v + 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (v > 0) then (     break ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var v : int ; v := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (arr[j+1][i+1] = 'R') then (     x1 := j ; 
     y1 := i ; 
     v := v + 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (v > 0) then (     break ) else skip )  ;     i := i + 1 ) ; 
    if (y1 < y) then (     skip ) else     skip ; ;  
    T := T - 1 ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int i=0 ; i<T ; i++){
      int N=in.nextInt();
      int[] a=new int[N];
      for(int j=0 ; j<N ; j++){
        a[j]=in.nextInt();
      }
      int[] b=new int[N];
      for(int j=0 ; j<N ; j++){
        if(j % 2==0){
          b[j]=a[j+1];
        }
        else {
          b[j]=-a[j-1];
        }
      }
      for(int j=0 ; j<N ; j++){
        System.out.print(b[j]+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var j : int ; j := 0 ; while j < N do ( (     a[j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,N)->collect(0) ;
        var j : int ; j := 0 ; while j < N do ( (     if (j mod 2 = 0) then (     b[j+1] := a[j + 1+1] ) else (     b[j+1] := -a[j - 1+1] ) )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < N do ( (     OclFile["System.out"].print(b[j+1] + " ") )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static final double PI=Math.PI ;
  static double findArea(int r){
    return PI*Math.pow(r,2);
  }
  public static void main(String[] args){
    System.out.println("Area is "+findArea(5));
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static    attribute PI : double := 3.141592653589793;
  static   operation findArea( r : int) : double
  pre: true
  post: true
  activity: (     return PI * r->pow(2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Area is " + findArea(5)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class DmwS {
  static int[] below ;
  static boolean[] vis ;
  static long result ;
  static int K ;
  static LinkedList[] adj ;
  static int[] unis ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    K=sc.nextInt();
    adj=new LinkedList[N];
    unis=new int[N];
    for(int i=0 ; i<N ; i++){
      adj[i]=new LinkedList();
    }
    for(int i=0 ; i<2*K ; i++){
      int town=sc.nextInt()-1 ;
      unis[town]++;
    }
    for(int i=0 ; i<N-1 ; i++){
      int x=sc.nextInt()-1 ;
      int y=sc.nextInt()-1 ;
      adj[x] .add(y);
      adj[y] .add(x);
    }
    below=new int[N];
    vis=new boolean[N];
    dfs(0);
    System.out.println(result);
  }
  static void dfs(int node){
    vis[node]=true ;
    below[node]=unis[node];
    for(Integer adj :(LinkedList<Integer>)adj[node]){
      if(vis[adj])continue ;
      dfs(adj);
      below[node]+=below[adj];
      result+=Math.min(below[adj],2*K-below[adj]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DmwS {
  static   attribute below : Sequence(int);
  static   attribute vis : Sequence(boolean);
  static   attribute result : long;
  static   attribute K : int;
  static   attribute adj : Sequence(Sequence);
  static   attribute unis : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    K := sc.getCurrent()->toInteger() ; 
    adj := Integer.subrange(1,N)->collect(null) ; 
    unis := Integer.subrange(1,N)->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     adj[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 2 * K do ( (     var town : int ; town := sc.getCurrent()->toInteger() - 1 ;
     unis[town+1] := unis[town+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
     var y : int ; y := sc.getCurrent()->toInteger() - 1 ;
     adj[x+1]->excludes(y) ; 
     adj[y+1]->excludes(x) )  ;     i := i + 1 ) ; 
    below := Integer.subrange(1,N)->collect(0) ; 
    vis := Integer.subrange(1,N)->collect(false) ; 
    execute dfs(0) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation dfs( node : int) : void
  pre: true
  post: true
  activity: (     vis[node+1] := true ; 
     below[node+1] := unis[node+1] ; 
     for (adj : adj[node+1]->oclAsType(Sequence(int))) do ( (     if (vis[adj+1]) then     continue else skip ; 
     execute dfs(adj) ; 
     below[node+1] := below[node+1]+(below[adj+1]) ; 
     result := result+(Set{below[adj+1], 2 * K - below[adj+1]}->min()) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Dmw {
  static int[] below ;
  static boolean[] vis ;
  static long result ;
  static int K ;
  static LinkedList[] adj ;
  static int[] unis ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    K=sc.nextInt();
    adj=new LinkedList[N];
    unis=new int[N];
    for(int i=0 ; i<N ; i++){
      adj[i]=new LinkedList();
    }
    for(int i=0 ; i<2*K ; i++){
      int town=sc.nextInt()-1 ;
      unis[town]++;
    }
    for(int i=0 ; i<N-1 ; i++){
      int x=sc.nextInt()-1 ;
      int y=sc.nextInt()-1 ;
      adj[x] .add(y);
      adj[y] .add(x);
    }
    below=new int[N];
    vis=new boolean[N];
    dfs(0);
    System.out.println(result);
  }
  static void dfs(int node){
    vis[node]=true ;
    below[node]=unis[node];
    for(Integer adj :(LinkedList<Integer>)adj[node]){
      if(vis[adj])continue ;
      dfs(adj);
      below[node]+=below[adj];
      result+=Math.min(below[adj],2*K-below[adj]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Dmw {
  static   attribute below : Sequence(int);
  static   attribute vis : Sequence(boolean);
  static   attribute result : long;
  static   attribute K : int;
  static   attribute adj : Sequence(Sequence);
  static   attribute unis : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    K := sc.getCurrent()->toInteger() ; 
    adj := Integer.subrange(1,N)->collect(null) ; 
    unis := Integer.subrange(1,N)->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     adj[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 2 * K do ( (     var town : int ; town := sc.getCurrent()->toInteger() - 1 ;
     unis[town+1] := unis[town+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
     var y : int ; y := sc.getCurrent()->toInteger() - 1 ;
     adj[x+1]->excludes(y) ; 
     adj[y+1]->excludes(x) )  ;     i := i + 1 ) ; 
    below := Integer.subrange(1,N)->collect(0) ; 
    vis := Integer.subrange(1,N)->collect(false) ; 
    execute dfs(0) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation dfs( node : int) : void
  pre: true
  post: true
  activity: (     vis[node+1] := true ; 
     below[node+1] := unis[node+1] ; 
     for (adj : adj[node+1]->oclAsType(Sequence(int))) do ( (     if (vis[adj+1]) then     continue else skip ; 
     execute dfs(adj) ; 
     below[node+1] := below[node+1]+(below[adj+1]) ; 
     result := result+(Set{below[adj+1], 2 * K - below[adj+1]}->min()) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
class GFG {
  public static int nthTerm(int N){
    return Math.abs(N*((N-1)*(N-3)*(N-5)));
  }
  public static void main(String[] args){
    int N=6 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nthTerm( N : int) : int
  pre: true
  post: true
  activity: (     return if N * ((N - 1) * (N - 3) * (N - 5)) < 0 then -(N * ((N - 1) * (N - 3) * (N - 5))) else N * ((N - 1) * (N - 3) * (N - 5)) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 6 ;
     OclFile["System.out"].println(nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class Gfg {
  static int getHeight(int X){
    return(2*X);
  }
  public static void main(String[] args)throws java.lang.Exception {
    int X=35 ;
    System.out.println(getHeight(X));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Gfg {
  static   operation getHeight( X : int) : int
  pre: true
  post: true
  activity: (     return (2 * X) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 35 ;
     OclFile["System.out"].println(getHeight(X)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class KPaths {
  static final int V=4 ;
  int countwalks(int graph[][],int u,int v,int k){
    if(k==0 && u==v)return 1 ;
    if(k==1 && graph[u][v]==1)return 1 ;
    if(k<=0)return 0 ;
    int count=0 ;
    for(int i=0 ; i<V ; i++)if(graph[u][i]==1)count+=countwalks(graph,i,v,k-1);
    return count ;
  }
  public static void main(String[] args)throws java.lang.Exception {
    int graph[][]=new int[][] {
      {
        0,1,1,1 },{
          0,0,0,1 },{
            0,0,0,1 },{
              0,0,0,0 }
            };
            int u=0,v=3,k=2 ;
            KPaths p=new KPaths();
            System.out.println(p.countwalks(graph,u,v,k));
          }
        }

------------------------------------------------------------
OCL File:
---------
 class KPaths {
  static    attribute V : int := 4;
   operation countwalks( graph : Sequence(Sequence(int)), u : int, v : int, k : int) : int
  pre: true
  post: true
  activity: (     if (k = 0 & u = v) then     return 1 else skip ; 
     if (k = 1 & graph[u+1][v+1] = 1) then     return 1 else skip ; 
    if (k <= 0) then     return 0 else skip ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < V do (     if (graph[u+1][i+1] = 1) then     count := count+(countwalks(graph, i, v, k - 1)) ; else skip ;  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var graph : Sequence(Sequence(int)) ; graph := Sequence{Sequence{0,1,1,1},Sequence{0,0,0,1},Sequence{0,0,0,1},Sequence{0,0,0,0}} ;
     var u : int ; u := 0 ;
    var v : int ; v := 3 ;
    var k : int ; k := 2 ;
     var p : KPaths ; p := KPaths.newKPaths() ;
     OclFile["System.out"].println(p.countwalks(graph, u, v, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static int min_noOf_operation(int arr[],int n,int k){
    int noOfSubtraction ;
    int res=0 ;
    for(int i=1 ; i<n ; i++){
      noOfSubtraction=0 ;
      if(arr[i]>arr[i-1]){
        noOfSubtraction=(arr[i]-arr[i-1])/k ;
        if((arr[i]-arr[i-1])% k!=0)noOfSubtraction++;
        arr[i]=arr[i]-k*noOfSubtraction ;
      }
      res=res+noOfSubtraction ;
    }
    return res ;
  }
  public static void main(String argc[]){
    int arr={
      1,1,2,3 };
      int N=4 ;
      int k=5 ;
      System.out.println(min_noOf_operation(arr,N,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation min_noOf_operation( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var noOfSubtraction : int ;
     var res : int ; res := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     noOfSubtraction := 0 ; 
     if (arr[i+1] > arr[i - 1+1]) then (     noOfSubtraction := (arr[i+1] - arr[i - 1+1]) / k ; 
     if ((arr[i+1] - arr[i - 1+1]) mod k /= 0) then     noOfSubtraction := noOfSubtraction + 1 ; else skip ; 
     arr[i+1] := arr[i+1] - k * noOfSubtraction ) else skip ; 
     res := res + noOfSubtraction )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : int ; arr := Sequence{1,1,2,3} ;
     var N : int ; N := 4 ;
     var k : int ; k := 5 ;
     OclFile["System.out"].println(min_noOf_operation(arr, N, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long findDigits(int n,int b){
    if(n<0)return 0 ;
    if(n<=1)return 1 ;
    double M_PI=3.141592 ;
    double M_E=2.7182 ;
    double x=((n*Math.log10(n/M_E)+Math.log10(2*M_PI*n)/2.0))/(Math.log10(b));
    return(long)(Math.floor(x)+1);
  }
  public static void main(String[] args){
    System.out.print(findDigits(4,16)+"\n");
    System.out.print(findDigits(5,8)+"\n");
    System.out.print(findDigits(12,16)+"\n");
    System.out.print(findDigits(19,13)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findDigits( n : int, b : int) : long
  pre: true
  post: true
  activity: (     if (n < 0) then     return 0 else skip ; 
     if (n <= 1) then     return 1 else skip ; 
    var M_PI : double ; M_PI := 3.141592 ;
    var M_E : double ; M_E := 2.7182 ;
    var x : double ; x := ((n * (n / M_E)->log10() + (2 * M_PI * n)->log10() / 2.0)) / ((b)->log10()) ;
    return ((x)->floor() + 1)->oclAsType(long) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(findDigits(4, 16) + "\n") ; 
     OclFile["System.out"].print(findDigits(5, 8) + "\n") ; 
     OclFile["System.out"].print(findDigits(12, 16) + "\n") ; 
     OclFile["System.out"].print(findDigits(19, 13) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int q=in.nextInt();
    init(n);
    for(int i=0 ; i<q ; i++){
      if(in.nextInt()==0){
        add(in.nextInt(),in.nextInt());
      }
      else {
        System.out.println(sum(in.nextInt(),in.nextInt()));
      }
    }
  }
  static int[] nodes ;
  static int size ;
  static void init(int n){
    size=1 ;
    while(size<n)size*=2 ;
    nodes=new int[size+1];
  }
  static void add(int target,int value){
    while(target<nodes.length){
      nodes[target]+=value ;
      target+=target &(-target);
    }
  }
  static int sum(int s,int t){
    return sum(t)-sum(s-1);
  }
  static int sum(int t){
    int res=0 ;
    while(t>0){
      res+=nodes[t];
      t-=t &(-t);
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var q : int ; q := in.getCurrent()->toInteger() ;
    execute init(n) ; 
        var i : int ; i := 0 ; while i < q do ( (     if (in.getCurrent()->toInteger() = 0) then (     execute add(in.getCurrent()->toInteger(), in.getCurrent()->toInteger()) ) else (     OclFile["System.out"].println(sum(in.getCurrent()->toInteger(), in.getCurrent()->toInteger())) ) )  ;     i := i + 1 ) ; 
 );
  static   attribute nodes : Sequence(int);
  static   attribute size : int;
  static   operation init( n : int) : void
  pre: true
  post: true
  activity: (     size := 1 ; 
     while (size < n) do     size := size*(2) ; ; 
     nodes := Integer.subrange(1,size + 1)->collect(0) );
  static   operation add( target : int, value : int) : void
  pre: true
  post: true
  activity: (     while (target < nodes->size()) do (     nodes[target+1] := nodes[target+1]+(value) ; 
     target := target+(target & (-target)) ) );
  static   operation sum( s : int, t : int) : int
  pre: true
  post: true
  activity: (     return sum(t) - sum(s - 1) );
  static   operation sum( t : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     while (t > 0) do (     res := res+(nodes[t+1]) ; 
     t := t-(t & (-t)) ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.function.*;
class BinaryIndexedTree<T>{
  public static class Monoid<T,R>implements BiFunction<T,T,R>{
    T identity ;
    BiFunction<T,T,R>f ;
    public Monoid(T identity,BiFunction<T,T,R>f){
      this.identity=identity ;
      this.f=f ;
    }
    @ Override public R apply(T t,T u){
      return f.apply(t,u);
    }
  }
  private final T[] array ;
  private final Monoid<T,T>merger ;
  @ SuppressWarnings("unchecked")public BinaryIndexedTree(int size,Monoid<T,T>merger){
    this.merger=merger ;
    this.array=(T[])new Object[size+1];
    Arrays.fill(array,merger.identity);
  }
  void merge(int p,T value){
++p ;
    for(final int n=array.length ; p<n ; p+=Integer.lowestOneBit(p))array[p]=merger.apply(array[p],value);
  }
  T query(int p){
    T s=merger.identity ;
    for(++p ; p>0 ; p ^=Integer.lowestOneBit(p))s=merger.apply(s,array[p]);
    return s ;
  }
}
public class Main {
  public static void main(String[] $){
    final Scanner s=new Scanner(System.in);
    final int n=s.nextInt();
    BinaryIndexedTree<Integer>bit=new BinaryIndexedTree<>(n,new BinaryIndexedTree.Monoid<>(0,Integer :: sum));
    for(int q=s.nextInt(); q>0 ; --q){
      if(s.nextByte()==0){
        bit.merge(s.nextInt()-1,s.nextInt());
      }
      else {
        int i=s.nextInt()-1 ;
        int j=s.nextInt()-1 ;
        System.out.println(bit.query(j)-bit.query(i-1));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BinaryIndexedTree<T> {
  static class Monoid<T,R> implements BiFunction<T,T,R> {
   attribute identity : T;
   attribute f : BiFunction<T,T,R>;
   static operation newMonoid( identity : T, f : BiFunction<T,T,R>) : Monoid
  pre: true
  post: true
  activity:
  ( var self : Monoid ;
    self := createMonoid();
    self.initialise(identity, f);
    return self );
  operation initialise( identity : T, f : BiFunction<T,T,R>) : void
  pre: true  post: true
  activity: (     self.identity := identity ; 
     self.f := f );
      operation apply( t : T, u : T) : R
  pre: true
  post: true
  activity: (     return f->apply(t, u) );
}
   attribute array : Sequence(T);
   attribute merger : Monoid<T,T>;
      static operation newBinaryIndexedTree( size : int, merger : Monoid<T,T>) : BinaryIndexedTree
  pre: true
  post: true
  activity:
  ( var self : BinaryIndexedTree ;
    self := createBinaryIndexedTree();
    self.initialise(size, merger);
    return self );
  operation initialise( size : int, merger : Monoid<T,T>) : void
  pre: true  post: true
  activity: (     self.merger := merger ; 
     self.array := Integer.subrange(1,size + 1)->collect(null)->oclAsType(Sequence(T)) ; 
     array := array->collect(merger.identity) );
   operation merge( p : int, value : T) : void
  pre: true
  post: true
  activity: (     p := p + 1 ; 
         var n : int ; n := array->size() ; while p < n do (     array[p+1] := merger->apply(array[p+1], value) ;  ;     p := p+(lowestOneBit(p)) ) );
   operation query( p : int) : T
  pre: true
  post: true
  activity: (     var s : T ; s := merger.identity ;
         p := p + 1 ; while p > 0 do (     s := merger->apply(s, array[p+1]) ;  ;     p := MathLib.bitwiseXor(p,lowestOneBit(p)) ) ; 
     return s );
}
class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
     var bit : BinaryIndexedTree<int> ; bit := BinaryIndexedTree<OclAny>.newBinaryIndexedTree(n, Monoid<OclAny>.newMonoid(0, lambda _pars : OclAny in Integer.newInteger().sum(_pars))) ;
         var q : int ; q := s.getCurrent()->toInteger() ; while q > 0 do ( (     if (s.nextByte() = 0) then (     bit.merge(s.getCurrent()->toInteger() - 1, s.getCurrent()->toInteger()) ) else (     var i : int ; i := s.getCurrent()->toInteger() - 1 ;
     var j : int ; j := s.getCurrent()->toInteger() - 1 ;
     OclFile["System.out"].println(bit.query(j) - bit.query(i - 1)) ) )  ;     q := q - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Problem1413A {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T--!=0){
      int n=sc.nextInt();
      int[] energies=new int[n];
      int[] requiredEnergies=new int[n];
      for(int i=0 ; i<n ; i++){
        energies[i]=sc.nextInt();
      }
      for(int i=0 ; i<n ; i+=2){
        requiredEnergies[i]=-(energies[i+1]);
        requiredEnergies[i+1]=(energies[i]);
      }
      for(int i=0 ; i<n ; i++){
        System.out.print(requiredEnergies[i]+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem1413A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         while (T /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var energies : Sequence(int) ; energies := Integer.subrange(1,n)->collect(0) ;
    var requiredEnergies : Sequence(int) ; requiredEnergies := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     energies[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     requiredEnergies[i+1] := -(energies[i + 1+1]) ; 
     requiredEnergies[i + 1+1] := (energies[i+1]) )  ;     i := i+(2) ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(requiredEnergies[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main implements Runnable {
  public static void main(String[] args){
    new Thread(null,new Main(),"",Runtime.getRuntime().maxMemory()).start();
  }
  class BIT {
    int n ;
    long[] v ;
    public BIT(int n_){
      n=n_ ;
      v=new long[n+1];
    }
    void add(int k,int val){
++k ;
      while(k<=n){
        v[k]+=val ;
        k+=k &-k ;
      }
    }
    long sum(int k){
++k ;
      long ret=0 ;
      while(k>0){
        ret+=v[k];
        k-=k &-k ;
      }
      return ret ;
    }
  }
  @ SuppressWarnings("unchecked")public void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int q=sc.nextInt();
    BIT bit=new BIT(n);
    while(q-->0){
      int com=sc.nextInt();
      int x=sc.nextInt();
      int y=sc.nextInt();
      if(com==0){
--x ;
        bit.add(x,y);
      }
      else {
--x ;
--y ;
        System.out.println(bit.sum(y)-bit.sum(x-1));
      }
    }
  }
  static void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(null, Main.newMain(), "", Runtime.getRuntime().maxMemory()).start() );
 class BIT {
   attribute n : int;
   attribute v : Sequence(long);
   static operation newBIT( n_ : int) : BIT
  pre: true
  post: true
  activity:
  ( var self : BIT ;
    self := createBIT();
    self.initialise(n_);
    return self );
  operation initialise( n_ : int) : void
  pre: true  post: true
  activity: (     n := n_ ; 
     v := Integer.subrange(1,n + 1)->collect(0) );
   operation add( k : int, val : int) : void
  pre: true
  post: true
  activity: (     k := k + 1 ; 
     while (k <= n) do (     v[k+1] := v[k+1]+(val) ; 
     k := k+(k & -k) ) );
   operation sum( k : int) : long
  pre: true
  post: true
  activity: (     k := k + 1 ; 
     var ret : long ; ret := 0 ;
     while (k > 0) do (     ret := ret+(v[k+1]) ; 
     k := k-(k & -k) ) ; 
     return ret );
}
      operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var bit : BIT ; bit := BIT.newBIT(n) ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     var com : int ; com := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     if (com = 0) then (     x := x - 1 ; 
     bit->excludes(x, y) ) else (     x := x - 1 ; 
     y := y - 1 ; 
     OclFile["System.out"].println(bit.sum(y) - bit.sum(x - 1)) ) ) ;  ) ;  
 );
  static   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  static int n=1 ;
  static int[] seg ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line=br.readLine();
    int n_=Integer.parseInt(line.substring(0,line.indexOf(" ")));
    int q=Integer.parseInt(line.substring(line.indexOf(" ")+1));
    while(n<=n_)n*=2 ;
    seg=new int[2*n-1];
    for(int i=0 ; i<q ; i++){
      line=br.readLine();
      String[] str=line.split(" ");
      int com=Integer.parseInt(str[0]);
      int x=Integer.parseInt(str[1]);
      int y=Integer.parseInt(str[2]);
      if(com==0)update(x,y);
      else System.out.println(query(x,y,0,0,n-1));
    }
    br.close();
  }
  static void update(int i,int a){
    i+=n-1 ;
    seg[i]+=a ;
    while(i>0){
      i=(i-1)/2 ;
      seg[i]=seg[2*i+1]+seg[2*i+2];
    }
  }
  static int query(int a,int b,int i,int l,int r){
    if(r<a || b<l)return 0 ;
    if(a<=l && r<=b){
      return seg[i];
    }
    else {
      int vl=query(a,b,i*2+1,l,(l+r)/2);
      int vr=query(a,b,i*2+2,(l+r+1)/2,r);
      return vl+vr ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int := 1;
  static   attribute seg : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := br.readLine() ;
    var n_ : int ; n_ := (line.subrange(0+1,line->indexOf(" ")-1))->toInteger() ;
    var q : int ; q := (line.subrange(line->indexOf(" ")-1 + 1+1,line->indexOf(" ")-1 + 1))->toInteger() ;
    while (n <= n_) do     n := n*(2) ; ; 
    seg := Integer.subrange(1,2 * n - 1)->collect(0) ; 
        var i : int ; i := 0 ; while i < q do ( (     line := br.readLine() ; 
     var str : Sequence(String) ; str := line->split(" ") ;
    var com : int ; com := (str[0+1])->toInteger() ;
    var x : int ; x := (str[1+1])->toInteger() ;
    var y : int ; y := (str[2+1])->toInteger() ;
    if (com = 0) then     execute update(x, y) else     OclFile["System.out"].println(query(x, y, 0, 0, n - 1)) ; ;  
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation update( i : int, a : int) : void
  pre: true
  post: true
  activity: (     i := i+(n - 1) ; 
     seg[i+1] := seg[i+1]+(a) ; 
     while (i > 0) do (     i := (i - 1) / 2 ; 
     seg[i+1] := seg[2 * i + 1+1] + seg[2 * i + 2+1] ) );
  static   operation query( a : int, b : int, i : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     if (r < a or b < l) then     return 0 else skip ; 
     if (a <= l & r <= b) then (     return seg[i+1] ) else (     var vl : int ; vl := query(a, b, i * 2 + 1, l, (l + r) / 2) ;
     var vr : int ; vr := query(a, b, i * 2 + 2, (l + r + 1) / 2, r) ;
     return vl + vr ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static boolean check(int n){
    if(n==1)return true ;
    else if(n % 2!=0)return false ;
    else return check(n/2);
  }
  public static void add(long rsq[],int i,int x,int n){
    i+=(n-1);
    rsq[i]+=x ;
    if(i==0)return ;
    i=(i-1)/2 ;
    while(i>=0){
      rsq[i]+=x ;
      i=(i-1)/2 ;
      if(i==0)break ;
    }
  }
  public static long getSum(long rsq[],int s,int t,int left,int right,int i){
    if(right<=s || left>t)return 0 ;
    else if(left>=s && right<=t+1)return rsq[i];
    else return getSum(rsq,s,t,left,(left+right)/2,2*i+1)+getSum(rsq,s,t,(left+right)/2,right,2*i+2);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int n_=n ;
    while(! check(n_))n_++;
    int q=sc.nextInt();
    long rsq[]=new long[2*n_-1];
    for(int i=0 ; i<2*n_-1 ; i++)rsq[i]=0L ;
    for(int i=0 ; i<q ; i++){
      int com=sc.nextInt();
      int x=sc.nextInt();
      int y=sc.nextInt();
      switch(com){
        case 0 : add(rsq,x-1,y,n_);
        break ;
        case 1 : System.out.println(getSum(rsq,x-1,y-1,0,n_,0));
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation check( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 1) then     return true else     if (n mod 2 /= 0) then     return false else     return check(n / 2) ;  );
  static   operation add( rsq : Sequence(long), i : int, x : int, n : int) : void
  pre: true
  post: true
  activity: (     i := i+((n - 1)) ; 
     rsq[i+1] := rsq[i+1]+(x) ; 
    if (i = 0) then     return else skip ; 
    i := (i - 1) / 2 ; 
    while (i >= 0) do (     rsq[i+1] := rsq[i+1]+(x) ; 
     i := (i - 1) / 2 ; 
     if (i = 0) then     break else skip ) ; 
 );
  static   operation getSum( rsq : Sequence(long), s : int, t : int, left : int, right : int, i : int) : long
  pre: true
  post: true
  activity: (     if (right <= s or left > t) then     return 0 else     if (left >= s & right <= t + 1) then     return rsq[i+1] else     return getSum(rsq, s, t, left, (left + right) / 2, 2 * i + 1) + getSum(rsq, s, t, (left + right) / 2, right, 2 * i + 2) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var n_ : int ; n_ := n ;
    while (not(check(n_))) do     n_ := n_ + 1 ; ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var rsq : Sequence(long) ; rsq := Integer.subrange(1,2 * n_ - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 * n_ - 1 do (     rsq[i+1] := 0L ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var com : int ; com := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (com) ; 
       if _switchval = 0 then
     execute add(rsq, x - 1, y, n_) ; 
    break 
   else skip ;
       if _switchval = 1 then
     OclFile["System.out"].println(getSum(rsq, x - 1, y - 1, 0, n_, 0)) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static Map<Long,Long>check=new HashMap<Long,Long>();
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String buf ;
    String[] input ;
    long N ;
    N=Long.parseLong(br.readLine());
    System.out.println(solve(N));
  }
  static long solve(long n){
    long a,b ;
    if(n==0)return 1 ;
    if(n==1)return 2 ;
    if(check.containsKey(n/2)){
      a=check.get(n/2);
    }
    else {
      a=solve(n/2)% 1000000007 ;
      check.put(n/2,a);
    }
    if(check.containsKey(n/2-1)){
      b=check.get(n/2-1);
    }
    else {
      b=solve(n/2-1)% 1000000007 ;
      check.put(n/2-1,b);
    }
    if(n % 2==1){
      return(2*a+b)% 1000000007 ;
    }
    else {
      return(2*b+a)% 1000000007 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute check : Map(long,long) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var buf : String ;
    var input : Sequence(String) ;
    var N : long ;
    N := (br.readLine())->toLong() ; 
    OclFile["System.out"].println(solve(N)) ; 
 );
  static   operation solve( n : long) : long
  pre: true
  post: true
  activity: (     var a : long ;
    var b : long ;
     if (n = 0) then     return 1 else skip ; 
    if (n = 1) then     return 2 else skip ; 
    if (check->keys()->includes(n / 2)) then (     a := check->at(n / 2) ) else (     a := solve(n / 2) mod 1000000007 ; 
     check := check->union(Map{n / 2 |-> a}) ) ;  
    if (check->keys()->includes(n / 2 - 1)) then (     b := check->at(n / 2 - 1) ) else (     b := solve(n / 2 - 1) mod 1000000007 ; 
     check := check->union(Map{n / 2 - 1 |-> b}) ) ;  
    if (n mod 2 = 1) then (     return (2 * a + b) mod 1000000007 ) else (     return (2 * b + a) mod 1000000007 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public static void main(String[] args){
    var sc=new java.util.Scanner(System.in);
    long n=sc.nextLong();
    sc.close();
    boolean[] nBits=new boolean[60];
    for(int i=0 ; i<60 ; i++)nBits[i]=(n &(1l<<i))!=0 ;
    final long MOD=1000000007 ;
    long[] dpA=new long[61];
    long[] dpB=new long[61];
    long[] dpC=new long[61];
    dpA[60]=1 ;
    for(int i=59 ; i>=0 ; i--){
      if(nBits[i]){
        dpB[i]+=dpA[i+1];
        dpA[i]+=dpA[i+1];
        dpC[i]+=dpB[i+1];
        dpC[i]+=dpB[i+1];
        dpB[i]+=dpB[i+1];
        dpC[i]+=dpC[i+1];
        dpC[i]+=dpC[i+1];
        dpC[i]+=dpC[i+1];
      }
      else {
        dpA[i]+=dpA[i+1];
        dpC[i]+=dpB[i+1];
        dpB[i]+=dpB[i+1];
        dpA[i]+=dpB[i+1];
        dpC[i]+=dpC[i+1];
        dpC[i]+=dpC[i+1];
        dpC[i]+=dpC[i+1];
      }
      dpA[i] %=MOD ;
      dpB[i] %=MOD ;
      dpC[i] %=MOD ;
    }
    long ans=dpA[0]+dpB[0]+dpC[0];
    System.out.println(ans % MOD);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : var ; sc := Scanner.newScanner(OclFile["System.in"]) ;
     var n : long ; n := sc.nextLong() ;
    sc.close() ; 
    var nBits : Sequence(boolean) ; nBits := Integer.subrange(1,60)->collect(false) ;
        var i : int ; i := 0 ; while i < 60 do (     nBits[i+1] := (MathLib.bitwiseAnd(n,((1l*(2->pow(i)))->oclAsType(long)))) /= 0 ;  ;     i := i + 1 ) ; 
    var MOD : long ; MOD := 1000000007 ;
    var dpA : Sequence(long) ; dpA := Integer.subrange(1,61)->collect(0) ;
    var dpB : Sequence(long) ; dpB := Integer.subrange(1,61)->collect(0) ;
    var dpC : Sequence(long) ; dpC := Integer.subrange(1,61)->collect(0) ;
    dpA[60+1] := 1 ; 
        var i : int ; i := 59 ; while i >= 0 do ( (     if (nBits[i+1]) then (     dpB[i+1] := dpB[i+1]+(dpA[i + 1+1]) ; 
     dpA[i+1] := dpA[i+1]+(dpA[i + 1+1]) ; 
    dpC[i+1] := dpC[i+1]+(dpB[i + 1+1]) ; 
    dpC[i+1] := dpC[i+1]+(dpB[i + 1+1]) ; 
    dpB[i+1] := dpB[i+1]+(dpB[i + 1+1]) ; 
    dpC[i+1] := dpC[i+1]+(dpC[i + 1+1]) ; 
    dpC[i+1] := dpC[i+1]+(dpC[i + 1+1]) ; 
    dpC[i+1] := dpC[i+1]+(dpC[i + 1+1]) ; 
 ) else (     dpA[i+1] := dpA[i+1]+(dpA[i + 1+1]) ; 
     dpC[i+1] := dpC[i+1]+(dpB[i + 1+1]) ; 
    dpB[i+1] := dpB[i+1]+(dpB[i + 1+1]) ; 
    dpA[i+1] := dpA[i+1]+(dpB[i + 1+1]) ; 
    dpC[i+1] := dpC[i+1]+(dpC[i + 1+1]) ; 
    dpC[i+1] := dpC[i+1]+(dpC[i + 1+1]) ; 
    dpC[i+1] := dpC[i+1]+(dpC[i + 1+1]) ; 
 ) ;  
     dpA[i+1] := dpA[i+1] mod MOD ; 
     dpB[i+1] := dpB[i+1] mod MOD ; 
     dpC[i+1] := dpC[i+1] mod MOD )  ;     i := i - 1 ) ; 
    var ans : long ; ans := dpA[0+1] + dpB[0+1] + dpC[0+1] ;
    OclFile["System.out"].println(ans mod MOD) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static long MOD=1000000007 ;
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    long n=scan.nextLong();
    int B=62 ;
    long[][] dp=new long[3][B];
    dp[0][B-1]=1 ;
    for(int i=B-2 ; i>=0 ; --i){
      for(int a=0 ; a<=2 ; ++a){
        if(n>>>i<a)continue ;
        long m=n>>>i ;
        int b=(int)(m/2-(m-a)/2);
        int c=(int)((m-a)% 2);
        if(c!=0)dp[a][i]=dp[b][i+1] % MOD ;
        else dp[a][i]=(dp[b][i+1]+dp[b+1][i+1])% MOD ;
      }
    }
    long[] r=new long[B],s=new long[B];
    r[0]=1 ;
    s[0]=0 ;
    for(int i=1 ; i<B ; ++i)r[i]=(3*r[i-1]+MOD-1)% MOD ;
    for(int i=1 ; i<B ; ++i)s[i]=(3*s[i-1]+1)% MOD ;
    long t=0 ;
    for(int i=B-2 ; i>=0 ; --i){
      if((n & 1L<<i)!=0){
        t+=dp[1][i]*r[i] % MOD ;
        t+=dp[2][i]*s[i] % MOD ;
        t %=MOD ;
      }
    }
    t=(t+dp[0][0])% MOD ;
    System.out.println(t);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : long := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := scan.getCurrent()->toLong() ;
    var B : int ; B := 62 ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,3)->collect(Integer.subrange(1,B)->collect(0)) ;
    dp[0+1][B - 1+1] := 1 ; 
        var i : int ; i := B - 2 ; while i >= 0 do ( (         var a : int ; a := 0 ; while a <= 2 do ( (     if ((n/(2->pow(i)))->oclAsType(long) < a) then     continue else skip ; 
     var m : long ; m := (n/(2->pow(i)))->oclAsType(long) ;
    var b : int ; b := (m / 2 - (m - a) / 2)->oclAsType(int) ;
    var c : int ; c := ((m - a) mod 2)->oclAsType(int) ;
    if (c /= 0) then     dp[a+1][i+1] := dp[b+1][i + 1+1] mod MOD else     dp[a+1][i+1] := (dp[b+1][i + 1+1] + dp[b + 1+1][i + 1+1]) mod MOD ; ;  
 )  ;     a := a + 1 ) )  ;     i := i - 1 ) ; 
    var r : Sequence(long) ; r := Integer.subrange(1,B)->collect(0) ;
    var s : Sequence(long) ; s := Integer.subrange(1,B)->collect(0) ;
    r[0+1] := 1 ; 
    s[0+1] := 0 ; 
        var i : int ; i := 1 ; while i < B do (     r[i+1] := (3 * r[i - 1+1] + MOD - 1) mod MOD ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < B do (     s[i+1] := (3 * s[i - 1+1] + 1) mod MOD ;  ;     i := i + 1 ) ; 
    var t : long ; t := 0 ;
        var i : int ; i := B - 2 ; while i >= 0 do ( (     if ((MathLib.bitwiseAnd(n,(1L*(2->pow(i)))->oclAsType(long))) /= 0) then (     t := t+(dp[1+1][i+1] * r[i+1] mod MOD) ; 
     t := t+(dp[2+1][i+1] * s[i+1] mod MOD) ; 
     t := t mod MOD ) else skip )  ;     i := i - 1 ) ; 
    t := (t + dp[0+1][0+1]) mod MOD ; 
    OclFile["System.out"].println(t) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static long MOD=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    System.out.println(f(n+1));
  }
  static HashMap<Long,Long>mb=new HashMap<>();
  public static long f(long n){
    Long memo=mb.get(n);
    if(memo!=null)return memo ;
    if(n<=2){
      return n ;
    }
    long res=f(n/2)+f((n-1)/2)+f((n+1)/2);
    res %=MOD ;
    mb.put(n,res);
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : long := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println(f(n + 1)) );
  static   attribute mb : Map(long,long) := Map{};
  static   operation f( n : long) : long
  pre: true
  post: true
  activity: (     var memo : long ; memo := mb->at(n) ;
     if (memo /= null) then     return memo else skip ; 
    if (n <= 2) then (     return n ) else skip ; 
    var res : long ; res := f(n / 2) + f((n - 1) / 2) + f((n + 1) / 2) ;
    res := res mod MOD ; 
    mb := mb->union(Map{n |-> res}) ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class UnionFindNode {
  public int index ;
  public UnionFindNode parent ;
  UnionFindNode(int index){
    this.index=index ;
    this.parent=null ;
  }
  public UnionFindNode getRoot(){
    ArrayList<UnionFindNode>notRoots=new ArrayList<UnionFindNode>();
    UnionFindNode current=this ;
    while(current.parent!=null){
      notRoots.add(current);
      current=current.parent ;
    }
    UnionFindNode root=current ;
    for(UnionFindNode ufn : notRoots){
      ufn.parent=root ;
    }
    return root ;
  }
  public static void merge(UnionFindNode n1,UnionFindNode n2){
    UnionFindNode root1=n1.getRoot();
    UnionFindNode root2=n2.getRoot();
    if(root1!=root2){
      root1.parent=root2 ;
    }
  }
}
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int m=s.nextInt();
    int[] p=new int[n+1];
    UnionFindNode[] ufns=new UnionFindNode[n+1];
    for(int i=1 ; i<=n ; i++){
      p[i]=s.nextInt();
      ufns[i]=new UnionFindNode(i);
    }
    for(int i=0 ; i<m ; i++){
      int x=s.nextInt();
      int y=s.nextInt();
      UnionFindNode.merge(ufns[x],ufns[y]);
    }
    int count=0 ;
    for(int i=1 ; i<=n ; i++){
      if(ufns[i] .getRoot()==ufns[p[i] ] .getRoot()){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class UnionFindNode {
   attribute index : int;
   attribute parent : UnionFindNode;
   static operation newUnionFindNode( index : int) : UnionFindNode
  pre: true
  post: true
  activity:
  ( var self : UnionFindNode ;
    self := createUnionFindNode();
    self.initialise(index);
    return self );
  operation initialise( index : int) : void
  pre: true  post: true
  activity: (     self.index := index ; 
     self.parent := null );
   operation getRoot() : UnionFindNode
  pre: true
  post: true
  activity: (     var notRoots : Sequence(UnionFindNode) ; notRoots := Sequence{} ;
     var current : UnionFindNode ; current := self ;
    while (current.parent /= null) do (     notRoots := notRoots->including(current) ; 
     current := current.parent ) ; 
    var root : UnionFindNode ; root := current ;
    for (ufn : notRoots) do ( (     ufn.parent := root )  ) ; 
    return root 
 );
  static   operation merge( n1 : UnionFindNode, n2 : UnionFindNode) : void
  pre: true
  post: true
  activity: (     var root1 : UnionFindNode ; root1 := n1.getRoot() ;
     var root2 : UnionFindNode ; root2 := n2.getRoot() ;
     if (root1 /= root2) then (     root1.parent := root2 ) else skip );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var m : int ; m := s.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n + 1)->collect(0) ;
    var ufns : Sequence(UnionFindNode) ; ufns := Integer.subrange(1,n + 1)->collect(null) ;
        var i : int ; i := 1 ; while i <= n do ( (     p[i+1] := s.getCurrent()->toInteger() ; 
     ufns[i+1] := UnionFindNode.newUnionFindNode(i) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := s.getCurrent()->toInteger() ;
     var y : int ; y := s.getCurrent()->toInteger() ;
     UnionFindNode.merge(ufns[x+1], ufns[y+1]) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (ufns[i+1].getRoot() = ufns[p[i+1]+1].getRoot()) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int CountSubSet(int arr[],int n,int X){
    int N=(int)Math.pow(2,n);
    int count=0 ;
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<n ; j++){
        if((i &(1<<j))!=0)if(arr[j]==X)count+=1 ;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      4,5,6,7 };
      int X=5 ;
      int n=arr.length ;
      System.out.print(CountSubSet(arr,n,X));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation CountSubSet( arr : Sequence(int), n : int, X : int) : int
  pre: true
  post: true
  activity: (     var N : int ; N := 2->pow(n)->oclAsType(int) ;
     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd(i,((1*(2->pow(j)))->oclAsType(long)))) /= 0) then     if (arr[j+1] = X) then     count := count+(1) ; else skip ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,5,6,7} ;
     var X : int ; X := 5 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(CountSubSet(arr, n, X)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int numerator ;
  static int denominator ;
  static int maxproduct ;
  static int parts ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      numerator=sc.nextInt();
      denominator=sc.nextInt();
      maxproduct=sc.nextInt();
      parts=sc.nextInt();
      if(parts==0)break ;
      int count=0 ;
      count+=Judge(numerator,denominator,parts,1,0);
      System.out.println(count);
    }
  }
  static int Judge(int p,int q,int separate,int now_pro,int prev_deno){
    int count=0 ;
    if(p==0){
      count++;
    }
    if(separate<=0)return count ;
    int deno=maxproduct/now_pro+1 ;
    while(separate*q<p*deno)deno--;
    while(p*deno>=q && prev_deno<=deno){
      int subtraction_deno=q*deno ;
      int subtraction_nume=p*deno-q ;
      if(now_pro*deno<=maxproduct){
        count+=Judge(subtraction_nume,subtraction_deno,separate-1,now_pro*deno,deno);
      }
      deno--;
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute numerator : int;
  static   attribute denominator : int;
  static   attribute maxproduct : int;
  static   attribute parts : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     numerator := sc.getCurrent()->toInteger() ; 
     denominator := sc.getCurrent()->toInteger() ; 
    maxproduct := sc.getCurrent()->toInteger() ; 
    parts := sc.getCurrent()->toInteger() ; 
    if (parts = 0) then     break else skip ; 
    var count : int ; count := 0 ;
    count := count+(Judge(numerator, denominator, parts, 1, 0)) ; 
    OclFile["System.out"].println(count) ; 
 ) );
  static   operation Judge( p : int, q : int, separate : int, now_pro : int, prev_deno : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     if (p = 0) then (     count := count + 1 ) else skip ; 
    if (separate <= 0) then     return count else skip ; 
    var deno : int ; deno := maxproduct / now_pro + 1 ;
    while (separate * q < p * deno) do     deno := deno - 1 ; ; 
    while (p * deno >= q & prev_deno <= deno) do (     var subtraction_deno : int ; subtraction_deno := q * deno ;
     var subtraction_nume : int ; subtraction_nume := p * deno - q ;
     if (now_pro * deno <= maxproduct) then (     count := count+(Judge(subtraction_nume, subtraction_deno, separate - 1, now_pro * deno, deno)) ) else skip ; 
     deno := deno - 1 ) ; 
    return count 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int __gcd(int a,int b){
    if(a==0 || b==0)return 0 ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static int findLCM(int arr[],int n){
    int lcm=arr[0];
    for(int i=1 ; i<n ; i++){
      lcm=(lcm*arr[i])/__gcd(arr[i],lcm);
    }
    return lcm ;
  }
  static int countNumbers(int arr[],int n,int l,int r){
    int lcm=findLCM(arr,n);
    int count=(r/lcm)-((l-1)/lcm);
    return count ;
  }
  public static void main(String args[]){
    int arr[]={
      1,4,2 };
      int n=arr.length ;
      int l=1,r=10 ;
      System.out.println(countNumbers(arr,n,l,r));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0 or b = 0) then     return 0 else skip ; 
     if (a = b) then     return a else skip ; 
     if (a > b) then     return __gcd(a - b, b) else skip ; 
     return __gcd(a, b - a) );
  static   operation findLCM( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var lcm : int ; lcm := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do ( (     lcm := (lcm * arr[i+1]) / __gcd(arr[i+1], lcm) )  ;     i := i + 1 ) ; 
     return lcm );
  static   operation countNumbers( arr : Sequence(int), n : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     var lcm : int ; lcm := findLCM(arr, n) ;
     var count : int ; count := (r / lcm) - ((l - 1) / lcm) ;
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,4,2} ;
     var n : int ; n := arr->size() ;
     var l : int ; l := 1 ;
    var r : int ; r := 10 ;
     OclFile["System.out"].println(countNumbers(arr, n, l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static int dfs(int p,int q,int a,int n,int cur_pro,int prev_d){
    if(n<0){
      return 0 ;
    }
    if(p==0 && cur_pro<=a){
      return 1 ;
    }
    else if(n==0){
      return 0 ;
    }
    int sum=0 ;
    int divide=a/cur_pro+1 ;
    while(p*divide>=q){
      if(divide*cur_pro>a){
        divide--;
        continue ;
      }
      else if(n*q<p*divide){
        divide--;
        continue ;
      }
      else if(divide<prev_d){
        break ;
      }
      final int upper=p*divide-q ;
      final int downer=q*divide ;
      sum+=dfs(upper,downer,a,n-1,cur_pro*divide,divide);
      divide--;
    }
    return sum ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      StringTokenizer tok=new StringTokenizer(br.readLine());
      final int p=Integer.parseInt(tok.nextToken());
      final int q=Integer.parseInt(tok.nextToken());
      final int a=Integer.parseInt(tok.nextToken());
      final int n=Integer.parseInt(tok.nextToken());
      if(p==0 && q==0 && a==0 && n==0){
        break ;
      }
      int sum=dfs(p,q,a,n,1,0);
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation dfs( p : int, q : int, a : int, n : int, cur_pro : int, prev_d : int) : int
  pre: true
  post: true
  activity: (     if (n < 0) then (     return 0 ) else skip ; 
     if (p = 0 & cur_pro <= a) then (     return 1 ) else     if (n = 0) then (     return 0 ) else skip ; ;  
    var sum : int ; sum := 0 ;
    var divide : int ; divide := a / cur_pro + 1 ;
    while (p * divide >= q) do (     if (divide * cur_pro > a) then (     divide := divide - 1 ; 
     continue ) else     if (n * q < p * divide) then (     divide := divide - 1 ; 
     continue ) else     if (divide < prev_d) then (     break ) else skip ; ;  ;  
     var upper : int ; upper := p * divide - q ;
    var downer : int ; downer := q * divide ;
    sum := sum+(dfs(upper, downer, a, n - 1, cur_pro * divide, divide)) ; 
    divide := divide - 1 ; 
 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var tok : OclIterator ; tok := OclIterator.newOclIterator_String(br.readLine()) ;
     var p : int ; p := (tok.next())->toInteger() ;
    var q : int ; q := (tok.next())->toInteger() ;
    var a : int ; a := (tok.next())->toInteger() ;
    var n : int ; n := (tok.next())->toInteger() ;
    if (p = 0 & q = 0 & a = 0 & n = 0) then (     break ) else skip ; 
    var sum : int ; sum := dfs(p, q, a, n, 1, 0) ;
    OclFile["System.out"].println(sum) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  Main(){
    sc=new Scanner(System.in);
  }
  int ni(){
    return sc.nextInt();
  }
  public static void main(String[] args){
    new Main().run();
  }
  int a,n ;
  int p,q ;
  int dfs(int last,int sa,int sn,double sm){
    if(sn>n){
      return 0 ;
    }
    int cnt=0 ;
    if(Math.abs(sm-(double)p/q)<1e-9){
++cnt ;
    }
    if((sm-(double)p/q)>1e-9){
      return 0 ;
    }
    for(int i=last ; i<=a/sa ; ++i){
      cnt+=dfs(i,sa*i,sn+1,sm+1.0/i);
    }
    return cnt ;
  }
  void run(){
    for(; ; ){
      p=ni();
      q=ni();
      a=ni();
      n=ni();
      if(p==0){
        break ;
      }
      System.out.println(dfs(1,1,0,0));
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute a : int;
   attribute p : int;
   operation dfs( last : int, sa : int, sn : int, sm : double) : int
  pre: true
  post: true
  activity: (     if (sn > n) then (     return 0 ) else skip ; 
     var cnt : int ; cnt := 0 ;
    if (if sm - p->oclAsType(double) / q < 0 then -(sm - p->oclAsType(double) / q) else sm - p->oclAsType(double) / q endif < 1e-9) then (     cnt := cnt + 1 ) else skip ; 
    if ((sm - p->oclAsType(double) / q) > 1e-9) then (     return 0 ) else skip ; 
        var i : int ; i := last ; while i <= a / sa do ( (     cnt := cnt+(dfs(i, sa * i, sn + 1, sm + 1.0 / i)) )  ;     i := i + 1 ) ; 
    return cnt 
 );
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     p := ni() ; 
     q := ni() ; 
    a := ni() ; 
    n := ni() ; 
    if (p = 0) then (     break ) else skip ; 
    OclFile["System.out"].println(dfs(1, 1, 0, 0)) ; 
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.HashMap ;
import java.util.LinkedList ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static int dfs(final int p,final int q,final int a,final int cur_a,final int n,final int pre_div){
    if(n==0){
      return p==0 ? 1 : 0 ;
    }
    else if(p==0){
      return 1 ;
    }
    int ret=0 ;
    for(int div=pre_div ; div<=a ; div++){
      if(p*div>q*n){
        break ;
      }
      else if(p*div-q<0){
        continue ;
      }
      else if(cur_a*div>a){
        continue ;
      }
      ret+=dfs(p*div-q,q*div,a,cur_a*div,n-1,div);
    }
    return ret ;
  }
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    while(true){
      final int p=sc.nextInt();
      final int q=sc.nextInt();
      final int a=sc.nextInt();
      final int n=sc.nextInt();
      if(p==0 && q==0 && a==0 && n==0){
        break ;
      }
      System.out.println(dfs(p,q,a,1,n,1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation dfs( p : int, q : int, a : int, cur_a : int, n : int, pre_div : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then (     return if p = 0 then 1 else 0 endif ) else     if (p = 0) then (     return 1 ) else skip ; ;  
     var ret : int ; ret := 0 ;
         var div : int ; div := pre_div ; while div <= a do ( (     if (p * div > q * n) then (     break ) else     if (p * div - q < 0) then (     continue ) else     if (cur_a * div > a) then (     continue ) else skip ; ;  ;  
     ret := ret+(dfs(p * div - q, q * div, a, cur_a * div, n - 1, div)) )  ;     div := div + 1 ) ; 
     return ret );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var p : int ; p := sc.getCurrent()->toInteger() ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    if (p = 0 & q = 0 & a = 0 & n = 0) then (     break ) else skip ; 
    OclFile["System.out"].println(dfs(p, q, a, 1, n, 1)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Arrays ;
class GFG {
  static String s="" ;
  static String ReverseString(String s){
    char[] arr=s.toCharArray();
    for(int i=0 ; i<arr.length/2 ; i++){
      char temp=arr[i];
      arr[i]=arr[arr.length-i-1];
      arr[arr.length-i-1]=temp ;
    }
    return new String(arr);
  }
  static void binary_conversion(int m){
    while(m!=0){
      int tmp=m % 2 ;
      s+=Integer.toString(tmp);
      m=(int)(m/2);
    }
    s=ReverseString(s);
  }
  static int find_character(int n,int m,int i){
    binary_conversion(m);
    String s1="" ;
    for(int x=0 ; x<n ; x++){
      for(int y=0 ; y<s.length(); y++){
        if(s.charAt(y)=='1')s1+="10" ;
        else s1+="01" ;
      }
      s=s1 ;
      s1="" ;
    }
    return s.charAt(i)-'0' ;
  }
  public static void main(String args[]){
    int m=5,n=2,i=8 ;
    System.out.print(find_character(n,m,i));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute s : String := "";
  static   operation ReverseString( s : String) : String
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := s->characters() ;
         var i : int ; i := 0 ; while i < arr->size() / 2 do ( (     var temp : String ; temp := arr[i+1] ;
     arr[i+1] := arr[arr->size() - i - 1+1] ; 
     arr[arr->size() - i - 1+1] := temp )  ;     i := i + 1 ) ; 
     return StringLib.newString(arr) );
  static   operation binary_conversion( m : int) : void
  pre: true
  post: true
  activity: (     while (m /= 0) do (     var tmp : int ; tmp := m mod 2 ;
     s := s+(((tmp) + "")) ; 
     m := (m / 2)->oclAsType(int) ) ; 
     s := ReverseString(s) );
  static   operation find_character( n : int, m : int, i : int) : int
  pre: true
  post: true
  activity: (     execute binary_conversion(m) ; 
     var s1 : String ; s1 := "" ;
         var x : int ; x := 0 ; while x < n do ( (         var y : int ; y := 0 ; while y < s->size() do ( (     if (s->at(y+1) = '1') then     s1 := s1+("10") ; else     s1 := s1+("01") ; )  ;     y := y + 1 ) ; 
     s := s1 ; 
     s1 := "" )  ;     x := x + 1 ) ; 
     return s->at(i+1) - ('0')->char2byte() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 5 ;
    var n : int ; n := 2 ;
    var i : int ; i := 8 ;
     OclFile["System.out"].print(find_character(n, m, i)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countSubsets(int arr[],int n){
    HashSet<Integer>us=new HashSet<>();
    int even_count=0 ;
    for(int i=0 ; i<n ; i++)if(arr[i] % 2==0)us.add(arr[i]);
    even_count=us.size();
    return(int)(Math.pow(2,even_count)-1);
  }
  public static void main(String[] args){
    int arr[]={
      4,2,1,9,2,6,5,3 };
      int n=arr.length ;
      System.out.println("Number of subsets="+countSubsets(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSubsets( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var us : Set(int) ; us := Set{} ;
     var even_count : int ; even_count := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (arr[i+1] mod 2 = 0) then     us := us->including(arr[i+1]) ; else skip ;  ;     i := i + 1 ) ; 
    even_count := us->size() ; 
    return (2->pow(even_count) - 1)->oclAsType(int) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,2,1,9,2,6,5,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Number of subsets=" + countSubsets(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=1000 ;
  static int[] f=new int[MAX];
  static int fib(int n){
    if(n==0)return 0 ;
    if(n==1 || n==2)return(f[n]=1);
    if(f[n]!=0)return f[n];
    int k=0 ;
    if((n & 1)!=0)k=(n+1)/2 ;
    else k=n/2 ;
    if((n & 1)!=0)f[n]=(fib(k)*fib(k)+fib(k-1)*fib(k-1));
    else f[n]=(2*fib(k-1)+fib(k))*fib(k);
    return f[n];
  }
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static int findLCMFibonacci(int a,int b){
    return(fib(a)*fib(b))/fib(gcd(a,b));
  }
  public static void main(String args[]){
    int a=3,b=12 ;
    System.out.println(findLCMFibonacci(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 1000;
  static   attribute f : Sequence(int) := Integer.subrange(1,MAX)->collect(0);
  static   operation fib( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else skip ; 
     if (n = 1 or n = 2) then     return (f[n+1]) else skip ; 
    if (f[n+1] /= 0) then     return f[n+1] else skip ; 
    var k : int ; k := 0 ;
    if ((n & 1) /= 0) then     k := (n + 1) / 2 else     k := n / 2 ; ;  
    if ((n & 1) /= 0) then     f[n+1] := (fib(k) * fib(k) + fib(k - 1) * fib(k - 1)) else     f[n+1] := (2 * fib(k - 1) + fib(k)) * fib(k) ; ;  
    return f[n+1] 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation findLCMFibonacci( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return (fib(a) * fib(b)) / fib(gcd(a, b)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var b : int ; b := 12 ;
     OclFile["System.out"].println(findLCMFibonacci(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findNumbers(int n,int w){
    int x=0,sum=0 ;
    if(w>=0 && w<=8){
      x=9-w ;
    }
    else if(w>=-9 && w<=-1){
      x=10+w ;
    }
    sum=(int)Math.pow(10,n-2);
    sum=(x*sum);
    return sum ;
  }
  public static void main(String args[]){
    int n,w ;
    n=3 ;
    w=4 ;
    System.out.println(findNumbers(n,w));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNumbers( n : int, w : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := 0 ;
    var sum : int ; sum := 0 ;
     if (w >= 0 & w <= 8) then (     x := 9 - w ) else     if (w >= -9 & w <= -1) then (     x := 10 + w ) else skip ; ;  
    sum := 10->pow(n - 2)->oclAsType(int) ; 
    sum := (x * sum) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var w : int ;
     n := 3 ; 
     w := 4 ; 
     OclFile["System.out"].println(findNumbers(n, w)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static Character findKthChar(String s,int k){
    int len=s.length();
    int i=0 ;
    int total_len=0 ;
    while(i<len){
      if(Character.isLetter(s.charAt(i))){
        total_len++;
        if(total_len==k)return s.charAt(i);
        i++;
      }
      else {
        int n=0 ;
        while(i<len && ! Character.isLetter(s.charAt(i))){
          n=n*10+(s.charAt(i)-'0');
          i++;
        }
        int next_total_len=total_len*n ;
        if(k<=next_total_len){
          int pos=k % total_len ;
          if(pos==0){
            pos=total_len ;
          }
          return findKthChar(s,pos);
        }
        else {
          total_len=next_total_len ;
        }
      }
    }
    return ' ' ;
  }
  public static void main(String[] args){
    String s="ab2c3" ;
    int k=5 ;
    System.out.println(findKthChar(s,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation findKthChar( s : String, k : int) : String
  pre: true
  post: true
  activity: (     var len : int ; len := s->size() ;
     var i : int ; i := 0 ;
    var total_len : int ; total_len := 0 ;
    while (i < len) do (     if ((s->at(i+1) + "")->isMatch("[a-zA-Z]")) then (     total_len := total_len + 1 ; 
     if (total_len = k) then     return s->at(i+1) else skip ; 
     i := i + 1 ) else (     var n : int ; n := 0 ;
     while (i < len & not((s->at(i+1) + "")->isMatch("[a-zA-Z]"))) do (     n := n * 10 + (s->at(i+1) - ('0')->char2byte()) ; 
     i := i + 1 ) ; 
     var next_total_len : int ; next_total_len := total_len * n ;
     if (k <= next_total_len) then (     var pos : int ; pos := k mod total_len ;
     if (pos = 0) then (     pos := total_len ) else skip ; 
     return findKthChar(s, pos) ) else (     total_len := next_total_len ) ) ) ; 
    return ' ' 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "ab2c3" ;
     var k : int ; k := 5 ;
     OclFile["System.out"].println(findKthChar(s, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int n=5 ;
  static int FindMaxProduct(int arr[][],int n){
    int max=0,result ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if((j-3)>=0){
          result=arr[i][j]*arr[i][j-1]*arr[i][j-2]*arr[i][j-3];
          if(max<result)max=result ;
        }
        if((i-3)>=0){
          result=arr[i][j]*arr[i-1][j]*arr[i-2][j]*arr[i-3][j];
          if(max<result)max=result ;
        }
        if((i-3)>=0 &&(j-3)>=0){
          result=arr[i][j]*arr[i-1][j-1]*arr[i-2][j-2]*arr[i-3][j-3];
          if(max<result)max=result ;
        }
        if((i-3)>=0 &&(j-1)<=0){
          result=arr[i][j]*arr[i-1][j+1]*arr[i-2][j+2]*arr[i-3][j+3];
          if(max<result)max=result ;
        }
      }
    }
    return max ;
  }
  public static void main(String[] args){
    int arr[][]={
      {
        1,2,3,4,5 },{
          6,7,8,9,1 },{
            2,3,4,5,6 },{
              7,8,9,1,0 },{
                9,6,4,2,3 }
              };
              System.out.print(FindMaxProduct(arr,n));
            }
          }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute n : int := 5;
  static   operation FindMaxProduct( arr : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     var max : int ; max := 0 ;
    var result : int ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if ((j - 3) >= 0) then (     result := arr[i+1][j+1] * arr[i+1][j - 1+1] * arr[i+1][j - 2+1] * arr[i+1][j - 3+1] ; 
     if (max < result) then     max := result ; else skip ) else skip ; 
     if ((i - 3) >= 0) then (     result := arr[i+1][j+1] * arr[i - 1+1][j+1] * arr[i - 2+1][j+1] * arr[i - 3+1][j+1] ; 
     if (max < result) then     max := result ; else skip ) else skip ; 
     if ((i - 3) >= 0 & (j - 3) >= 0) then (     result := arr[i+1][j+1] * arr[i - 1+1][j - 1+1] * arr[i - 2+1][j - 2+1] * arr[i - 3+1][j - 3+1] ; 
     if (max < result) then     max := result ; else skip ) else skip ; 
     if ((i - 3) >= 0 & (j - 1) <= 0) then (     result := arr[i+1][j+1] * arr[i - 1+1][j + 1+1] * arr[i - 2+1][j + 2+1] * arr[i - 3+1][j + 3+1] ; 
     if (max < result) then     max := result ; else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return max );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,2,3,4,5},Sequence{6,7,8,9,1},Sequence{2,3,4,5,6},Sequence{7,8,9,1,0},Sequence{9,6,4,2,3}} ;
     OclFile["System.out"].print(FindMaxProduct(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int a=Math.min(n,4);
    int[] num=new int[n];
    for(int i=0 ; i<n ; i++)num[i]=scanner.nextInt();
    Arrays.sort(num);
    List<Integer>ans=new ArrayList<Integer>();
    for(int i=0 ; i<a ; i++)for(int j=0 ; j<a ; j++){
      if(i==j)continue ;
      ans.add(Integer.valueOf(String.valueOf(num[i])+String.valueOf(num[j])));
    }
    Collections.sort(ans);
    System.out.println(ans.get(2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var a : int ; a := Set{n, 4}->min() ;
    var num : Sequence(int) ; num := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     num[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    num := num->sort() ; 
    var ans : Sequence(int) ; ans := Sequence{} ;
        var i : int ; i := 0 ; while i < a do (         var j : int ; j := 0 ; while j < a do ( (     if (i = j) then     continue else skip ; 
     ans := ans->including((((num[i+1]) + "") + ((num[j+1]) + ""))->toInteger()) )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    ans := ans->sort() ; 
    OclFile["System.out"].println(ans->at(2+1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int countNonEmptySubstr(String str){
    int n=str.length();
    return n*(n+1)/2 ;
  }
  public static void main(String args[]){
    String s="abcde" ;
    System.out.println(countNonEmptySubstr(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countNonEmptySubstr( str : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     return n * (n + 1) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abcde" ;
     OclFile["System.out"].println(countNonEmptySubstr(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=50002 ;
  static ArrayList<Integer>primes=new ArrayList<Integer>();
  public static void sieve(){
    boolean isPrime[]=new boolean[MAX];
    for(int i=0 ; i<MAX ; i++)isPrime[i]=true ;
    for(int p=2 ; p*p<MAX ; p++){
      if(isPrime[p]==true){
        for(int i=p*2 ; i<MAX ; i+=p)isPrime[i]=false ;
      }
    }
    for(int p=2 ; p<MAX ; p++)if(isPrime[p]==true)primes.add(p);
  }
  public static int power(int x,int y){
    int count=0 ;
    int z=y ;
    while(x>=z){
      count+=(x/z);
      z*=y ;
    }
    return count ;
  }
  public static int modMult(int a,int b,int mod){
    int res=0 ;
    a=a % mod ;
    while(b>0){
      if(b % 2==1)res=(res+a)% mod ;
      a=(a*2)% mod ;
      b/=2 ;
    }
    return res % mod ;
  }
  public static int countWays(int n,int m){
    int ans=1 ;
    for(int i=1 ; i<primes.size(); i++){
      int powers=power(n,primes.get(i));
      if(powers==0)break ;
      ans=modMult(ans,powers+1,m)% m ;
    }
    if(((ans-1)% m)<0)return(ans-1+m)% m ;
    else return(ans-1)% m ;
  }
  public static void main(String[] args){
    sieve();
    int n=4,m=7 ;
    System.out.println(countWays(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 50002;
  static   attribute primes : Sequence(int) := Sequence{};
  static   operation sieve() : void
  pre: true
  post: true
  activity: (     var isPrime : Sequence(boolean) ; isPrime := Integer.subrange(1,MAX)->collect(false) ;
         var i : int ; i := 0 ; while i < MAX do (     isPrime[i+1] := true ;  ;     i := i + 1 ) ; 
         var p : int ; p := 2 ; while p * p < MAX do ( (     if (isPrime[p+1] = true) then (         var i : int ; i := p * 2 ; while i < MAX do (     isPrime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
         var p : int ; p := 2 ; while p < MAX do (     if (isPrime[p+1] = true) then     primes := primes->including(p) ; else skip ;  ;     p := p + 1 ) );
  static   operation power( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var z : int ; z := y ;
     while (x >= z) do (     count := count+((x / z)) ; 
     z := z*(y) ) ; 
     return count );
  static   operation modMult( a : int, b : int, mod : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     a := a mod mod ; 
     while (b > 0) do (     if (b mod 2 = 1) then     res := (res + a) mod mod ; else skip ; 
     a := (a * 2) mod mod ; 
     b := b/(2) ) ; 
     return res mod mod );
  static   operation countWays( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
         var i : int ; i := 1 ; while i < primes->size() do ( (     var powers : int ; powers := power(n, primes->at(i+1)) ;
     if (powers = 0) then     break else skip ; 
     ans := modMult(ans, powers + 1, m) mod m )  ;     i := i + 1 ) ; 
     if (((ans - 1) mod m) < 0) then     return (ans - 1 + m) mod m else     return (ans - 1) mod m );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute sieve() ; 
     var n : int ; n := 4 ;
    var m : int ; m := 7 ;
     OclFile["System.out"].println(countWays(n, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int smallestIndexsum(int arr[],int n){
    int i=n-1 ;
    while(i>=0 && arr[i] % 2==1)i--;
    int sum=0 ;
    for(int j=0 ; j<=i ; j++)sum+=arr[j];
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      2,3,5,6,3,3 };
      int n=arr.length ;
      System.out.println(smallestIndexsum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation smallestIndexsum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := n - 1 ;
     while (i >= 0 & arr[i+1] mod 2 = 1) do     i := i - 1 ; ; 
    var sum : int ; sum := 0 ;
        var j : int ; j := 0 ; while j <= i do (     sum := sum+(arr[j+1]) ;  ;     j := j + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,5,6,3,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(smallestIndexsum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
(new Main()).solve();
  }
  void solve(){
    Scanner cin=new Scanner(System.in);
    int T=cin.nextInt();
    for(int C=1 ; C<=T ; ++C){
      int Row=cin.nextInt();
      int Col=cin.nextInt();
      int Num=cin.nextInt();
      System.out.println("Case #"+C+": "+solve(Row,Col,Num));
    }
  }
  int solve(int R,int C,int N){
    List<Integer>all=new ArrayList<Integer>();
    List<Integer>all2=new ArrayList<Integer>();
    for(int i=0 ; i<R ; ++i){
      for(int j=0 ; j<C ; ++j){
        int wall=0 ;
        if(i>0){
++wall ;
        }
        if(j>0){
++wall ;
        }
        if(i+1<R){
++wall ;
        }
        if(j+1<C){
++wall ;
        }
        if((i+j)% 2==0){
          all.add(wall);
        }
        else {
          all2.add(wall);
        }
      }
    }
    int ret=0 ;
    Collections.sort(all);
    for(int i=0 ; i<all.size()-(R*C-N); ++i){
      ret+=all.get(i);
    }
    int ret2=0 ;
    Collections.sort(all2);
    for(int i=0 ; i<all2.size()-(R*C-N); ++i){
      ret2+=all2.get(i);
    }
    return Math.min(ret,ret2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := cin.getCurrent()->toInteger() ;
         var C : int ; C := 1 ; while C <= T do ( (     var Row : int ; Row := cin.getCurrent()->toInteger() ;
     var Col : int ; Col := cin.getCurrent()->toInteger() ;
     var Num : int ; Num := cin.getCurrent()->toInteger() ;
     OclFile["System.out"].println("Case #" + C + ": " + solve(Row, Col, Num)) )  ;     C := C + 1 ) );
   operation solve( R : int, C : int, N : int) : int
  pre: true
  post: true
  activity: (     var all : Sequence(int) ; all := Sequence{} ;
     var all2 : Sequence(int) ; all2 := Sequence{} ;
        var i : int ; i := 0 ; while i < R do ( (         var j : int ; j := 0 ; while j < C do ( (     var wall : int ; wall := 0 ;
     if (i > 0) then (     wall := wall + 1 ) else skip ; 
    if (j > 0) then (     wall := wall + 1 ) else skip ; 
    if (i + 1 < R) then (     wall := wall + 1 ) else skip ; 
    if (j + 1 < C) then (     wall := wall + 1 ) else skip ; 
    if ((i + j) mod 2 = 0) then (     all := all->including(wall) ) else (     all2 := all2->including(wall) ) ;  
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ret : int ; ret := 0 ;
    all := all->sort() ; 
        var i : int ; i := 0 ; while i < all->size() - (R * C - N) do ( (     ret := ret+(all->at(i+1)) )  ;     i := i + 1 ) ; 
    var ret2 : int ; ret2 := 0 ;
    all2 := all2->sort() ; 
        var i : int ; i := 0 ; while i < all2->size() - (R * C - N) do ( (     ret2 := ret2+(all2->at(i+1)) )  ;     i := i + 1 ) ; 
    return Set{ret, ret2}->min() 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B {
  String solve(Scanner sc){
    int R=sc.nextInt();
    int C=sc.nextInt();
    int N=sc.nextInt();
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<1<<(R*C); i++){
      if(Integer.bitCount(i)==N){
        int s=0 ;
        boolean[][] b=new boolean[R][C];
        for(int r=0 ; r<R ; r++){
          for(int c=0 ; c<C ; c++){
            b[r][c]=(i &(1<<(r*C+c)))!=0 ;
            if(b[r][c]){
              if(r>0 && b[r-1][c]){
                s++;
              }
              if(c>0 && b[r][c-1]){
                s++;
              }
            }
          }
        }
        min=Math.min(min,s);
      }
    }
    return ""+min ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    for(int cs=1 ; cs<=T ; cs++){
      String res=new B().solve(sc);
      System.out.println("Case #"+cs+": "+res);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
   operation solve( sc : OclFile) : String
  pre: true
  post: true
  activity: (     var R : int ; R := sc.nextInt() ;
     var C : int ; C := sc.nextInt() ;
    var N : int ; N := sc.nextInt() ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < (1*(2->pow((R * C))))->oclAsType(long) do ( (     if (bitCount(i) = N) then (     var s : int ; s := 0 ;
     var b : Sequence(Sequence(boolean)) ; b := Integer.subrange(1,R)->collect(Integer.subrange(1,C)->collect(false)) ;
         var r : int ; r := 0 ; while r < R do ( (         var c : int ; c := 0 ; while c < C do ( (     b[r+1][c+1] := (MathLib.bitwiseAnd(i,((1*(2->pow((r * C + c))))->oclAsType(long)))) /= 0 ; 
     if (b[r+1][c+1]) then (     if (r > 0 & b[r - 1+1][c+1]) then (     s := s + 1 ) else skip ; 
     if (c > 0 & b[r+1][c - 1+1]) then (     s := s + 1 ) else skip ) else skip )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
     min := Set{min, s}->min() ) else skip )  ;     i := i + 1 ) ; 
    return "" + min 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var cs : int ; cs := 1 ; while cs <= T do ( (     var res : String ; res := B.newB().solve(sc) ;
     OclFile["System.out"].println("Case #" + cs + ": " + res) )  ;     cs := cs + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class NN {
  static Scanner sc=new Scanner(System.in);
  static int k ;
  {
    k=sc.nextInt();
    for(int kk=1 ; kk<=k ; kk++){
      System.out.print("Case #"+kk+": ");
      int r=sc.nextInt();
      int c=sc.nextInt();
      int n=sc.nextInt();
      int a=val(r,c,n);
      System.out.println(val(r,c,n));
    }
  }
  static int thing(int r,int c,int n,int basegood,int corn,int edg){
    if(n<=basegood)return 0 ;
    n-=basegood ;
    if(n<=corn)return 2*n ;
    int result=2*corn ;
    n-=corn ;
    if(n<=edg)return result+3*n ;
    result+=3*edg ;
    n-=edg ;
    return result+4*n ;
  }
  static int special(int size,int n){
    if(size % 2==0){
      if(n<=size/2)return 0 ;
      return 2*(n-size/2)-1 ;
    }
    else {
      if(n<=size/2+1)return 0 ;
      return 2*(n-size/2-1);
    }
  }
  static int val(int r,int c,int n){
    if(r==1)return special(c,n);
    if(c==1)return special(r,n);
    if((r*c)% 2==0)return thing(r,c,n,r*c/2,2,r+c-4);
    else return Math.min(thing(r,c,n,r*c/2+1,0,r+c-2),thing(r,c,n,r*c/2,4,r+c-6));
  }
  public static void main(String[] args){
    new NN();
  }
}
------------------------------------------------------------
OCL File:
---------
 class NN {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute k : int;
  operation initialiseInstance()
  pre: true post: true
  activity:     k := sc.getCurrent()->toInteger() ; 
        var kk : int ; kk := 1 ; while kk <= k do ( (     OclFile["System.out"].print("Case #" + kk + ": ") ; 
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := val(r, c, n) ;
    OclFile["System.out"].println(val(r, c, n)) ; 
 )  ;     kk := kk + 1 ) ; 
;
  static   operation thing( r : int, c : int, n : int, basegood : int, corn : int, edg : int) : int
  pre: true
  post: true
  activity: (     if (n <= basegood) then     return 0 else skip ; 
     n := n-(basegood) ; 
    if (n <= corn) then     return 2 * n else skip ; 
    var result : int ; result := 2 * corn ;
    n := n-(corn) ; 
    if (n <= edg) then     return result + 3 * n else skip ; 
    result := result+(3 * edg) ; 
    n := n-(edg) ; 
    return result + 4 * n 
 );
  static   operation special( size : int, n : int) : int
  pre: true
  post: true
  activity: (     if (size mod 2 = 0) then (     if (n <= size / 2) then     return 0 else skip ; 
     return 2 * (n - size / 2) - 1 ) else (     if (n <= size / 2 + 1) then     return 0 else skip ; 
     return 2 * (n - size / 2 - 1) ) );
  static   operation val( r : int, c : int, n : int) : int
  pre: true
  post: true
  activity: (     if (r = 1) then     return special(c, n) else skip ; 
     if (c = 1) then     return special(r, n) else skip ; 
     if ((r * c) mod 2 = 0) then     return thing(r, c, n, r * c / 2, 2, r + c - 4) else     return Set{thing(r, c, n, r * c / 2 + 1, 0, r + c - 2), thing(r, c, n, r * c / 2, 4, r + c - 6)}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( NN.newNN() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.text.DateFormat ;
import java.text.ParseException ;
import java.text.SimpleDateFormat ;
import java.util.*;
public class Main {
  static Scanner input=new Scanner(System.in);
  public static void main(String[] args)throws ParseException {
    String t1=input.next();
    String t2=input.next();
    DateFormat date=new SimpleDateFormat("yyyy:MM:dd");
    date.setTimeZone(TimeZone.getTimeZone("UTC"));
    System.out.println(Math.abs(date.parse(t1).getTime()-date.parse(t2).getTime())/(1000*60*60*24));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute input : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t1 : String ; t1 := input.getCurrent() ;
     var t2 : String ; t2 := input.getCurrent() ;
    var date : DateFormat ; date := SimpleDateFormat.newSimpleDateFormat("yyyy:MM:dd") ;
    date.setTimeZone(TimeZone.getTimeZone("UTC")) ; 
    OclFile["System.out"].println(if date.parse(t1).getTime() - date.parse(t2).getTime() < 0 then -(date.parse(t1).getTime() - date.parse(t2).getTime()) else date.parse(t1).getTime() - date.parse(t2).getTime() endif / (1000 * 60 * 60 * 24)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.text.DateFormat ;
import java.text.ParseException ;
import java.text.SimpleDateFormat ;
import java.util.*;
public class Main {
  static Scanner input=new Scanner(System.in);
  public static void main(String[] args)throws ParseException {
    String t1=input.next();
    String t2=input.next();
    DateFormat date=new SimpleDateFormat("yyyy:MM:dd");
    date.setTimeZone(TimeZone.getTimeZone("UTC"));
    System.out.println(Math.abs(date.parse(t1).getTime()-date.parse(t2).getTime())/(1000*60*60*24));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute input : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t1 : String ; t1 := input.getCurrent() ;
     var t2 : String ; t2 := input.getCurrent() ;
    var date : DateFormat ; date := SimpleDateFormat.newSimpleDateFormat("yyyy:MM:dd") ;
    date.setTimeZone(TimeZone.getTimeZone("UTC")) ; 
    OclFile["System.out"].println(if date.parse(t1).getTime() - date.parse(t2).getTime() < 0 then -(date.parse(t1).getTime() - date.parse(t2).getTime()) else date.parse(t1).getTime() - date.parse(t2).getTime() endif / (1000 * 60 * 60 * 24)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.text.ParseException ;
import java.text.SimpleDateFormat ;
import java.util.Date ;
public class dateProblem {
  public static void main(String[] args)throws IOException,ParseException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter wr=new BufferedWriter(new OutputStreamWriter(System.out));
    SimpleDateFormat format=new SimpleDateFormat("yyyy:MM:dd");
    Date start=format.parse(br.readLine());
    Date end=format.parse(br.readLine());
    double diff=end.getTime()-start.getTime();
    diff/=86400000.0 ;
    System.out.println(Math.abs(Math.round(diff)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class dateProblem {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var wr : OclFile ; wr := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var format : SimpleDateFormat ; format := SimpleDateFormat.newSimpleDateFormat("yyyy:MM:dd") ;
    var start : OclDate ; start := format.parse(br.readLine()) ;
    var end : OclDate ; end := format.parse(br.readLine()) ;
    var diff : double ; diff := end.time - start.time ;
    diff := diff/(86400000.0) ; 
    OclFile["System.out"].println(if (diff)->round() < 0 then -((diff)->round()) else (diff)->round() endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Pair {
  int x ;
  int y ;
  public Pair(int x,int y){
    this.x=x ;
    this.y=y ;
  }
}
class UnionFind {
  int[] par ;
  public UnionFind(int N){
    par=new int[N];
    for(int i=0 ; i<N ; i++)par[i]=i ;
  }
  int root(int x){
    if(par[x]==x)return x ;
    return par[x]=root(par[x]);
  }
  void unite(int x,int y){
    int rx=root(x);
    int ry=root(y);
    if(rx==ry)return ;
    par[rx]=ry ;
  }
  boolean same(int x,int y){
    int rx=root(x);
    int ry=root(y);
    return rx==ry ;
  }
}
public class Main {
  static int N ;
  static int M ;
  static int[] p ;
  static Pair[] sw ;
  static UnionFind uf ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    M=sc.nextInt();
    p=new int[N+1];
    sw=new Pair[M+1];
    for(int i=1 ; i<=N ; i++){
      p[i]=sc.nextInt();
    }
    for(int i=1 ; i<=M ; i++){
      sw[i]=new Pair(sc.nextInt(),sc.nextInt());
    }
    uf=new UnionFind(N+1);
    for(int i=1 ; i<=M ; i++){
      Pair s=sw[i];
      uf.unite(s.x,s.y);
    }
    int sum=0 ;
    for(int i=1 ; i<=N ; i++){
      if(uf.same(i,p[i]))sum++;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Pair {
   attribute x : int;
   attribute y : int;
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}
class UnionFind {
   attribute par : Sequence(int);
   static operation newUnionFind( N : int) : UnionFind
  pre: true
  post: true
  activity:
  ( var self : UnionFind ;
    self := createUnionFind();
    self.initialise(N);
    return self );
  operation initialise( N : int) : void
  pre: true  post: true
  activity: (     par := Integer.subrange(1,N)->collect(0) ; 
         var i : int ; i := 0 ; while i < N do (     par[i+1] := i ;  ;     i := i + 1 ) );
   operation root( x : int) : int
  pre: true
  post: true
  activity: (     if (par[x+1] = x) then     return x else skip ; 
     return par[x+1] );
   operation unite( x : int, y : int) : void
  pre: true
  post: true
  activity: (     var rx : int ; rx := root(x) ;
     var ry : int ; ry := root(y) ;
     if (rx = ry) then     return else skip ; 
     par[rx+1] := ry );
   operation same( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     var rx : int ; rx := root(x) ;
     var ry : int ; ry := root(y) ;
     return rx = ry );
}
class Main {
  static   attribute N : int;
  static   attribute M : int;
  static   attribute p : Sequence(int);
  static   attribute sw : Sequence(Map);
  static   attribute uf : UnionFind;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
    M := sc.getCurrent()->toInteger() ; 
    p := Integer.subrange(1,N + 1)->collect(0) ; 
    sw := Integer.subrange(1,M + 1)->collect(null) ; 
        var i : int ; i := 1 ; while i <= N do ( (     p[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= M do ( (     sw[i+1] := Map(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    uf := UnionFind.newUnionFind(N + 1) ; 
        var i : int ; i := 1 ; while i <= M do ( (     var s : Map ; s := sw[i+1] ;
     uf.unite(s.x, s.y) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     if (uf.same(i, p[i+1])) then     sum := sum + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] z){
    Scanner s=new Scanner(System.in);
    for(int i,j,c=0 ; s.hasNext(); System.out.println(c),c=0){
      int[] a=new int[156];
      for(i=0 ; i<12 ; ++i){
        z=s.next().split("");
        for(j=0 ; j<12 ; ++j)a[i*13+j]=z[j+1] .charAt(0);
      }
      for(i=0 ; i<12 ; ++i)for(j=0 ; j<12 ; ++j)if(a[i*13+j]>48)f(a,i*13+j,c++);
    }
  }
  static void f(int[] a,int x,int c){
    if(0<=x && x<156 && a[x]>48){
      a[x]=(byte)-c ;
      for(int i : new int[] { -13,-1,1,13 } )f(a,x+i,c);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var i : int ;
    var j : int ;
    var c : int ; c := 0 ; while s.hasNext() do ( (     var a : Sequence(int) ; a := Integer.subrange(1,156)->collect(0) ;
         i := 0 ; while i < 12 do ( (     z := s.getCurrent()->split("") ; 
         j := 0 ; while j < 12 do (     a[i * 13 + j+1] := z[j + 1+1]->at(0+1) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
         i := 0 ; while i < 12 do (         j := 0 ; while j < 12 do (     if (a[i * 13 + j+1] > 48) then     execute f(a, i * 13 + j, c) ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) )  ;     OclFile["System.out"].println(c) ;     c := 0 ) );
  static   operation f( a : Sequence(int), x : int, c : int) : void
  pre: true
  post: true
  activity: (     if (0 <= x & x < 156 & a[x+1] > 48) then (     a[x+1] := (-c mod 128) ; 
     for (i : Sequence{-13,-1,1,13}) do (     execute f(a, x + i, c) ;  ) ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.text.ParseException ;
import java.text.SimpleDateFormat ;
import java.util.Date ;
import java.util.TimeZone ;
import java.util.concurrent.TimeUnit ;
public class Solution {
  public static void main(String[] args)throws IOException,ParseException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    SimpleDateFormat sdf=new SimpleDateFormat("yyyy:MM:dd");
    sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
    Date date1=sdf.parse(br.readLine());
    Date date2=sdf.parse(br.readLine());
    long t=Math.abs(date1.getTime()-date2.getTime());
    System.out.println(TimeUnit.MILLISECONDS.toDays(t));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sdf : SimpleDateFormat ; sdf := SimpleDateFormat.newSimpleDateFormat("yyyy:MM:dd") ;
    sdf.setTimeZone(TimeZone.getTimeZone("UTC")) ; 
    var date1 : OclDate ; date1 := sdf.parse(br.readLine()) ;
    var date2 : OclDate ; date2 := sdf.parse(br.readLine()) ;
    var t : long ; t := if date1.time - date2.time < 0 then -(date1.time - date2.time) else date1.time - date2.time endif ;
    OclFile["System.out"].println(TimeUnit.MILLISECONDS.toDays(t)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.text.SimpleDateFormat ;
import java.util.Date ;
import java.util.Scanner ;
import java.util.TimeZone ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String s1=sc.next();
    String s2=sc.next();
    Date startDate ;
    Date endDate ;
    SimpleDateFormat sdf=new SimpleDateFormat("yyyy:MM:dd");
    sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
    if(s1.compareTo(s2)<0){
      startDate=sdf.parse(s1);
      endDate=sdf.parse(s2);
    }
    else {
      startDate=sdf.parse(s2);
      endDate=sdf.parse(s1);
    }
    long betweenDate=(endDate.getTime()-startDate.getTime())/(60*60*24*1000);
    System.out.println(betweenDate);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := sc.getCurrent() ;
    var s2 : String ; s2 := sc.getCurrent() ;
    var startDate : OclDate ;
    var endDate : OclDate ;
    var sdf : SimpleDateFormat ; sdf := SimpleDateFormat.newSimpleDateFormat("yyyy:MM:dd") ;
    sdf.setTimeZone(TimeZone.getTimeZone("UTC")) ; 
    if (s1->compareTo(s2) < 0) then (     startDate := sdf.parse(s1) ; 
     endDate := sdf.parse(s2) ) else (     startDate := sdf.parse(s2) ; 
     endDate := sdf.parse(s1) ) ;  
    var betweenDate : long ; betweenDate := (endDate.time - startDate.time) / (60 * 60 * 24 * 1000) ;
    OclFile["System.out"].println(betweenDate) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int count=0 ;
    for(int i=0 ; i<s.length(); i++){
      ArrayList<Character>al=new ArrayList<>();
      char c=s.charAt(i);
      if(c=='Q'){
        al.add(c);
      }
      for(int j=i+1 ; j<s.length(); j++){
        char a=s.charAt(j);
        if(al.size()>0){
          if(al.get(al.size()-1)=='Q' && a=='A'){
            al.add(a);
          }
          if(al.get(al.size()-1)=='A' && a=='Q'){
            al.add(a);
          }
          if(al.get(al.size()-1)=='A' && a=='A'){
            al.add(a);
          }
        }
        if(al.size()>=3 && al.get(0)=='Q' && al.get(al.size()-1)=='Q'){
          count=count+al.size()-3 ;
          al.remove(al.size()-1);
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var al : Sequence(String) ; al := Sequence{} ;
     var c : String ; c := s->at(i+1) ;
     if (c = 'Q') then (     al := al->including(c) ) else skip ; 
         var j : int ; j := i + 1 ; while j < s->size() do ( (     var a : String ; a := s->at(j+1) ;
     if (al->size() > 0) then (     if (al->at(al->size() - 1+1) = 'Q' & a = 'A') then (     al := al->including(a) ) else skip ; 
     if (al->at(al->size() - 1+1) = 'A' & a = 'Q') then (     al := al->including(a) ) else skip ; 
     if (al->at(al->size() - 1+1) = 'A' & a = 'A') then (     al := al->including(a) ) else skip ) else skip ; 
     if (al->size() >= 3 & al->at(0+1) = 'Q' & al->at(al->size() - 1+1) = 'Q') then (     count := count + al->size() - 3 ; 
     al := al->excludingFirst(al->size() - 1) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class QAQ {
  public static int fun(String str,String qaq,int i,int j,int arr[][]){
    if(qaq.length()==j){
      return 1 ;
    }
    if(str.length()==i){
      return 0 ;
    }
    if(arr[i][j]!=-1){
      return arr[i][j];
    }
    if(str.charAt(i)==qaq.charAt(j)){
      int x=fun(str,qaq,i+1,j+1,arr);
      int y=fun(str,qaq,i+1,j,arr);
      arr[i][j]=x+y ;
      return x+y ;
    }
    else {
      int y=fun(str,qaq,i+1,j,arr);
      arr[i][j]=y ;
      return y ;
    }
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    String str=st.nextToken();
    StringBuffer str1=new StringBuffer();
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)=='Q' || str.charAt(i)=='A'){
        str1.append(str.charAt(i));
      }
    }
    str=str1.toString();
    int arr[][]=new int[str.length()][3];
    for(int i=0 ; i<str1.length(); i++){
      arr[i][0]=-1 ;
      arr[i][1]=-1 ;
      arr[i][2]=-1 ;
    }
    System.out.println(fun(str,"QAQ",0,0,arr));
  }
}
------------------------------------------------------------
OCL File:
---------
 class QAQ {
  static   operation fun( str : String, qaq : String, i : int, j : int, arr : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     if (qaq->size() = j) then (     return 1 ) else skip ; 
     if (str->size() = i) then (     return 0 ) else skip ; 
     if (arr[i+1][j+1] /= -1) then (     return arr[i+1][j+1] ) else skip ; 
     if (str->at(i+1) = qaq->at(j+1)) then (     var x : int ; x := fun(str, qaq, i + 1, j + 1, arr) ;
     var y : int ; y := fun(str, qaq, i + 1, j, arr) ;
     arr[i+1][j+1] := x + y ; 
     return x + y ) else (     var y : int ; y := fun(str, qaq, i + 1, j, arr) ;
     arr[i+1][j+1] := y ; 
     return y ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var str : String ; str := st.next() ;
    var str1 : String ; str1 := StringLib.newString() ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = 'Q' or str->at(i+1) = 'A') then (     str1 := str1 + StringLib.newString(str->at(i+1)) ) else skip )  ;     i := i + 1 ) ; 
    str := str1+"" ; 
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,str->size())->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < str1->size() do ( (     arr[i+1][0+1] := -1 ; 
     arr[i+1][1+1] := -1 ; 
     arr[i+1][2+1] := -1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(fun(str, "QAQ", 0, 0, arr)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test208 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char s[]=in.next().toCharArray();
    int n=0,k=s.length,sum=0 ;
    for(int i=s.length-1 ; i>=0 ; i--){
      if(s[i]=='Q'){
        n=i ;
        break ;
      }
    }
    for(int i=0 ; i<s.length ; i++){
      if(s[i]=='Q'){
        k=i ;
        break ;
      }
    }
    for(int i=k ; i<=n ; i++){
      if(s[i]=='Q'){
        int b=0 ;
        boolean a=false ;
        for(int l=i ; l<=n ; l++){
          if(s[l]=='Q' && a){
            sum+=b ;
          }
          if(s[l]=='A'){
            a=true ;
            b++;
          }
        }
      }
    }
    System.out.println(sum);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test208 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := in.getCurrent()->characters() ;
    var n : int ; n := 0 ;
    var k : int ; k := s->size() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := s->size() - 1 ; while i >= 0 do ( (     if (s[i+1] = 'Q') then (     n := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s[i+1] = 'Q') then (     k := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := k ; while i <= n do ( (     if (s[i+1] = 'Q') then (     var b : int ; b := 0 ;
     var a : boolean ; a := false ;
         var l : int ; l := i ; while l <= n do ( (     if (s[l+1] = 'Q' & a) then (     sum := sum+(b) ) else skip ; 
     if (s[l+1] = 'A') then (     a := true ; 
     b := b + 1 ) else skip )  ;     l := l + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class AA {
  static int[] gem ;
  static int[][] dp ;
  static int d ;
  static int max=-1 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int n=s.length();
    int cou=0 ;
    for(int i=0 ; i<n ; i++){
      char c=s.charAt(i);
      if(c=='Q'){
        for(int j=i+1 ; j<n ; j++){
          char d=s.charAt(j);
          if(d=='A'){
            for(int k=(j+1); k<n ; k++){
              char e=s.charAt(k);
              if(e=='Q')cou++;
            }
          }
        }
      }
    }
    sc.close();
    System.out.print(cou);
  }
}
------------------------------------------------------------
OCL File:
---------
 class AA {
  static   attribute gem : Sequence(int);
  static   attribute dp : Sequence(Sequence(int));
  static   attribute d : int;
  static   attribute max : int := -1;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var n : int ; n := s->size() ;
    var cou : int ; cou := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var c : String ; c := s->at(i+1) ;
     if (c = 'Q') then (         var j : int ; j := i + 1 ; while j < n do ( (     var d : String ; d := s->at(j+1) ;
     if (d = 'A') then (         var k : int ; k := (j + 1) ; while k < n do ( (     var e : String ; e := s->at(k+1) ;
     if (e = 'Q') then     cou := cou + 1 ; else skip )  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.out"].print(cou) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class HelloWorld {
  public static void solve(char s[]){
    int n=s.length ;
    int ans=0 ;
    for(int i=0 ; i<n ; ++i){
      if(s[i]=='Q')for(int j=i+1 ;
      j<n ;
++j){
        if(s[j]=='A')for(int k=j+1 ;
        k<n ;
++k){
          if(s[k]=='Q'){
            ans++;
          }
        }
      }
    }
    System.out.println(ans);
  }
  public static void sol(){
    Scanner sc=new Scanner(System.in);
    int testcases=sc.nextInt();
    for(int t=0 ; t<testcases ; ++t){
      int n=sc.nextInt();
      char s[]=sc.next().toCharArray();
      int ans=0 ;
      int p=0 ;
      int cnt=1 ;
      for(; s[p]!='A' && p<n ; ++p){
      }
      p++;
      for(; p<n ; ++p){
        if(s[p]!=s[p-1]){
          if(s[p-1]=='P'){
            ans=Math.max(ans,cnt);
          }
          cnt=1 ;
        }
        else {
          cnt++;
        }
      }
      if(s[n-1]=='P'){
        ans=Math.max(ans,cnt);
      }
      System.out.println(ans);
    }
    sc.close();
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    solve(s.toCharArray());
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation solve( s : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] = 'Q') then         var j : int ; j := i + 1 ; while j < n do ( (     if (s[j+1] = 'A') then         var k : int ; k := j + 1 ; while k < n do ( (     if (s[k+1] = 'Q') then (     ans := ans + 1 ) else skip )  ;     k := k + 1 ) ; else skip )  ;     j := j + 1 ) ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) );
  static   operation sol() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testcases : int ; testcases := sc.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < testcases do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var ans : int ; ans := 0 ;
    var p : int ; p := 0 ;
    var cnt : int ; cnt := 1 ;
      while s[p+1] /= 'A' & p < n do ( skip  ;     p := p + 1 ) ; 
    p := p + 1 ; 
      while p < n do ( (     if (s[p+1] /= s[p - 1+1]) then (     if (s[p - 1+1] = 'P') then (     ans := Set{ans, cnt}->max() ) else skip ; 
     cnt := 1 ) else (     cnt := cnt + 1 ) )  ;     p := p + 1 ) ; 
    if (s[n - 1+1] = 'P') then (     ans := Set{ans, cnt}->max() ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     t := t + 1 ) ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
     execute solve(s->characters()) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    new Solver().run();
  }
}
class Solver {
  public void run(){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    long A=sc.nextLong();
    long B=sc.nextLong();
    long base=N/(A+B);
    long mod=N %(A+B);
    if(mod>=A)mod=A ;
    System.out.println(base*A+mod);
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Solver.newSolver().run() );
}
class Solver {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    var A : long ; A := sc.getCurrent()->toLong() ;
    var B : long ; B := sc.getCurrent()->toLong() ;
    var base : long ; base := N / (A + B) ;
    var mod : long ; mod := N mod (A + B) ;
    if (mod >= A) then     mod := A ; else skip ; 
    OclFile["System.out"].println(base * A + mod) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.math.BigInteger ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    BigInteger n=sc.nextBigInteger();
    BigInteger b=sc.nextBigInteger();
    BigInteger r=sc.nextBigInteger();
    sc.close();
    if(b.equals(new BigInteger("0"))){
      System.out.println("0");
    }
    else {
      BigInteger lp=b.add(r);
      BigInteger nDiv=n.divide(lp);
      BigInteger rem=n.mod(lp);
      BigInteger remMinRed=rem.subtract(r);
      BigInteger lpTimesBlue=nDiv.multiply(b);
      if(rem.compareTo(b)==0){
        System.out.println(lpTimesBlue);
      }
      else if(rem.compareTo(b)==1){
        System.out.println(lpTimesBlue.add(b));
      }
      else {
        System.out.println(lpTimesBlue.add(rem));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.nextBigInteger() ;
    var b : long ; b := sc.nextBigInteger() ;
    var r : long ; r := sc.nextBigInteger() ;
    skip ; 
    if (b = long("0")) then (     OclFile["System.out"].println("0") ) else (     var lp : long ; lp := b->excludes(r) ;
     var nDiv : long ; nDiv := n.divide(lp) ;
    var rem : long ; rem := n.mod(lp) ;
    var remMinRed : long ; remMinRed := rem.subtract(r) ;
    var lpTimesBlue : long ; lpTimesBlue := nDiv.multiply(b) ;
    if (rem->compareTo(b) = 0) then (     OclFile["System.out"].println(lpTimesBlue) ) else     if (rem->compareTo(b) = 1) then (     OclFile["System.out"].println(lpTimesBlue->excludes(b)) ) else (     OclFile["System.out"].println(lpTimesBlue->excludes(rem)) ) ;  ;  
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Objects ;
import java.util.Scanner ;
import java.util.stream.Stream ;
public class Main {
  public static void main(final String[] args)throws Exception {
    final Scanner sc=new Scanner(System.in);
    final long N=sc.nextLong();
    final long A=sc.nextLong();
    final long B=sc.nextLong();
    long result=0 ;
    if(A==0){
      result=0 ;
    }
    else if(B==0){
      result=N ;
    }
    else {
      long sum=N/(A+B);
      long remain=N %(A+B);
      result=sum*A ;
      result+=remain>=A ? A : remain ;
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    var A : long ; A := sc.getCurrent()->toLong() ;
    var B : long ; B := sc.getCurrent()->toLong() ;
    var result : long ; result := 0 ;
    if (A = 0) then (     result := 0 ) else     if (B = 0) then (     result := N ) else (     var sum : long ; sum := N / (A + B) ;
     var remain : long ; remain := N mod (A + B) ;
     result := sum * A ; 
     result := result+(if remain >= A then A else remain endif) ) ;  ;  
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String args[]){
    BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    String str="" ;
    int[] syugo ;
    int youso_kazu ;
    try {
      str=bfr.readLine();
      youso_kazu=Integer.parseInt(str);
      syugo=new int[youso_kazu];
      for(int i=0 ; i<youso_kazu ; i++){
        str=bfr.readLine();
        syugo[i]=Integer.parseInt(str);
      }
      int[] rank=new int[3];
      for(int i=0 ; i<3 ; i++){
        rank[i]=2000000000 ;
      }
      int kekka=0 ;
      String combine="" ;
      int tmp1,tmp2=0 ;
      for(int i=0 ; i<youso_kazu ; i++){
        for(int j=0 ; j<youso_kazu ; j++){
          if(i==j){
          }
          else {
            combine=String.valueOf(syugo[i])+String.valueOf(syugo[j]);
            kekka=Integer.parseInt(String.valueOf(combine));
            if(kekka<=rank[0] && kekka<=rank[1] && kekka<=rank[2]){
              tmp1=rank[0];
              tmp2=rank[1];
              rank[1]=tmp1 ;
              rank[2]=tmp2 ;
              rank[0]=kekka ;
            }
            else if(kekka>rank[0] && kekka<=rank[1] && kekka<=rank[2]){
              tmp1=rank[1];
              tmp2=rank[2];
              rank[2]=tmp1 ;
              rank[1]=kekka ;
            }
            if(kekka>rank[0] && kekka>rank[1] && kekka<=rank[2]){
              rank[2]=kekka ;
            }
          }
        }
      }
      System.out.println(rank[2]);
      if(str==""){
        System.exit(0);
      }
    }
    catch(IOException e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bfr : OclFile ; bfr := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := "" ;
    var syugo : Sequence(int) ;
    var youso_kazu : int ;
    try (     str := bfr.readLine() ; 
     youso_kazu := (str)->toInteger() ; 
    syugo := Integer.subrange(1,youso_kazu)->collect(0) ; 
        var i : int ; i := 0 ; while i < youso_kazu do ( (     str := bfr.readLine() ; 
     syugo[i+1] := (str)->toInteger() )  ;     i := i + 1 ) ; 
    var rank : Sequence(int) ; rank := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     rank[i+1] := 2000000000 )  ;     i := i + 1 ) ; 
    var kekka : int ; kekka := 0 ;
    var combine : String ; combine := "" ;
    var tmp1 : int ;
    var tmp2 : int ; tmp2 := 0 ;
        var i : int ; i := 0 ; while i < youso_kazu do ( (         var j : int ; j := 0 ; while j < youso_kazu do ( (     if (i = j) then skip else (     combine := ((syugo[i+1]) + "") + ((syugo[j+1]) + "") ; 
     kekka := (((combine) + ""))->toInteger() ; 
     if (kekka <= rank[0+1] & kekka <= rank[1+1] & kekka <= rank[2+1]) then (     tmp1 := rank[0+1] ; 
     tmp2 := rank[1+1] ; 
    rank[1+1] := tmp1 ; 
    rank[2+1] := tmp2 ; 
    rank[0+1] := kekka ; 
 ) else     if (kekka > rank[0+1] & kekka <= rank[1+1] & kekka <= rank[2+1]) then (     tmp1 := rank[1+1] ; 
     tmp2 := rank[2+1] ; 
     rank[2+1] := tmp1 ; 
     rank[1+1] := kekka ) else skip ; ;  
     if (kekka > rank[0+1] & kekka > rank[1+1] & kekka <= rank[2+1]) then (     rank[2+1] := kekka ) else skip ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(rank[2+1]) ; 
    if (str = "") then ( OclProcess.exit(0) ) else skip ; 
 )   catch (e : IOException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int m=Integer.parseInt(sc.next());
    Map<Integer,Integer>map=new HashMap<Integer,Integer>();
    int[] par=new int[n+1],rank=new int[n+1];
    int a,b,count=0 ;
    for(int i=0 ; i<n ; i++){
      map.put(Integer.parseInt(sc.next()),i+1);
    }
    for(int i=0 ; i<n+1 ; i++){
      par[i]=i ;
      rank[i]=0 ;
    }
    for(int i=0 ; i<m ; i++){
      a=Integer.parseInt(sc.next());
      b=Integer.parseInt(sc.next());
      unite(a,b,par,rank);
    }
    for(Integer key : map.keySet()){
      if(same(key,map.get(key),par)){
        count++;
      }
    }
    System.out.println(count);
    sc.close();
  }
  public static int getLeader(int a,int[] par){
    return par[a]==a ? a :(par[a]=getLeader(par[a],par));
  }
  public static boolean same(int a,int b,int[] par){
    return getLeader(a,par)==getLeader(b,par);
  }
  public static void unite(int a,int b,int[] par,int[] rank){
    a=getLeader(a,par);
    b=getLeader(b,par);
    if(a==b){
      return ;
    }
    if(rank[a]<rank[b]){
      par[a]=b ;
    }
    else {
      par[b]=a ;
      if(rank[a]==rank[b]){
        rank[a]++;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var m : int ; m := (sc.getCurrent())->toInteger() ;
    var map : Map(int,int) ; map := Map{} ;
    var par : Sequence(int) ; par := Integer.subrange(1,n + 1)->collect(0) ;
    var rank : Sequence(int) ; rank := Integer.subrange(1,n + 1)->collect(0) ;
    var a : int ;
    var b : int ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     map := map->union(Map{(sc.getCurrent())->toInteger() |-> i + 1}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n + 1 do ( (     par[i+1] := i ; 
     rank[i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     a := (sc.getCurrent())->toInteger() ; 
     b := (sc.getCurrent())->toInteger() ; 
     execute unite(a, b, par, rank) )  ;     i := i + 1 ) ; 
    for (key : map->keys()) do ( (     if (same(key, map->at(key), par)) then (     count := count + 1 ) else skip )  ) ; 
    OclFile["System.out"].println(count) ; 
    skip ; 
 );
  static   operation getLeader( a : int, par : Sequence(int)) : int
  pre: true
  post: true
  activity: (     return if par[a+1] = a then a else (par[a+1]) endif );
  static   operation same( a : int, b : int, par : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     return getLeader(a, par) = getLeader(b, par) );
  static   operation unite( a : int, b : int, par : Sequence(int), rank : Sequence(int)) : void
  pre: true
  post: true
  activity: (     a := getLeader(a, par) ; 
     b := getLeader(b, par) ; 
     if (a = b) then (     return ) else skip ; 
     if (rank[a+1] < rank[b+1]) then (     par[a+1] := b ) else (     par[b+1] := a ; 
     if (rank[a+1] = rank[b+1]) then (     rank[a+1] := rank[a+1] + 1 ) else skip ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long a=sc.nextLong();
    long b=sc.nextLong();
    long div=n/(a+b);
    long mod=n %(a+b);
    System.out.println(div*a+Math.min(mod,a));
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var div : long ; div := n / (a + b) ;
    var mod : long ; mod := n mod (a + b) ;
    OclFile["System.out"].println(div * a + Set{mod, a}->min()) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    long N=scan.nextLong();
    long A=scan.nextLong();
    long B=scan.nextLong();
    long k=0 ;
    if(1<=N && N<=Math.pow(10,18)&& 0<=A && 0<=B && 0<A+B && A+B<=Math.pow(10,18)){
      if(A+B<=N){
        k=N/(A+B);
        if(N-k*(A+B)>A){
          System.out.println(A*k+(N-k*(A+B))-(N-(k*(A+B)+A)));
        }
        else {
          System.out.println(A*k+(N-k*(A+B)));
        }
      }
      else if(A+B>N && A<=N){
        System.out.println(A);
      }
      else {
        System.out.println(N);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := scan.getCurrent()->toLong() ;
    var A : long ; A := scan.getCurrent()->toLong() ;
    var B : long ; B := scan.getCurrent()->toLong() ;
    var k : long ; k := 0 ;
    if (1 <= N & N <= 10->pow(18) & 0 <= A & 0 <= B & 0 < A + B & A + B <= 10->pow(18)) then (     if (A + B <= N) then (     k := N / (A + B) ; 
     if (N - k * (A + B) > A) then (     OclFile["System.out"].println(A * k + (N - k * (A + B)) - (N - (k * (A + B) + A))) ) else (     OclFile["System.out"].println(A * k + (N - k * (A + B))) ) ) else     if (A + B > N & A <= N) then (     OclFile["System.out"].println(A) ) else (     OclFile["System.out"].println(N) ) ;  ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      int k=scanner.nextInt();
      int[] a=new int[n];
      IntStream.range(0,n).forEach(i->a[i]=scanner.nextInt());
      if(1==n){
        System.out.println((k>a[0])? 1 : 0);
        return ;
      }
      Arrays.sort(a);
      int ng=0,ok=n+1 ;
      while(ok-ng>1){
        int mid=(ok+ng)/2 ;
        if(isNeeded(mid,n,k,a)){
          ok=mid ;
        }
        else {
          ng=mid ;
        }
      }
      System.out.println(ng);
    }
  }
  private static boolean isNeeded(int now,final int n,final int k,final int[] a){
    boolean[][] dp=new boolean[n+1][k+1];
    IntStream.range(0,n+1).forEach(i->Arrays.fill(dp[i],false));
    dp[0][0]=true ;
    IntStream.rangeClosed(1,n).forEach(i->IntStream.rangeClosed(0,k).forEach(j->{
      if(i==now){
        dp[i][j]=dp[i-1][j];
      }
      else {
        if(dp[i-1][j]){
          dp[i][j]=true ;
          if(j+a[i-1]<=k){
            dp[i][j+a[i-1] ]=true ;
          }
        }
      }
    }
));
    for(int i=k-1 ; i>=Math.max(k-a[now-1],0); i--){
      if(dp[n][i]){
        return true ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var k : int ; k := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    for i : Integer.subrange(0, n-1) do
    (    a[i+1] := scanner.getCurrent()->toInteger()) ; 
    if (1 = n) then (     OclFile["System.out"].println(if (k > a[0+1]) then 1 else 0 endif) ; 
     return ) else skip ; 
    a := a->sort() ; 
    var ng : int ; ng := 0 ;
    var ok : int ; ok := n + 1 ;
    while (ok - ng > 1) do (     var mid : int ; mid := (ok + ng) / 2 ;
     if (isNeeded(mid, n, k, a)) then (     ok := mid ) else (     ng := mid ) ) ; 
    OclFile["System.out"].println(ng) ; 
 ))  );
  static   operation isNeeded( now : int, n : int, k : int, a : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(boolean)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,k + 1)->collect(false)) ;
     for i : Integer.subrange(0, n + 1-1) do
    (    dp[i+1] := dp[i+1]->collect(false)) ; 
    dp[0+1][0+1] := true ; 
    for i : Integer.subrange(1, n) do
    (    for j : Integer.subrange(0, k) do
    (    skip)) ; 
        var i : int ; i := k - 1 ; while i >= Set{k - a[now - 1+1], 0}->max() do ( (     if (dp[n+1][i+1]) then (     return true ) else skip )  ;     i := i - 1 ) ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int K=scanner.nextInt();
    int[] a=new int[N+1];
    for(int i=1 ; i<=N ; i++)a[i]=scanner.nextInt();
    boolean[][] dp1=new boolean[N+1][K+1];
    for(int i=0 ; i<=N ; i++)dp1[i][0]=true ;
    for(int i=1 ; i<=N ; i++){
      for(int j=1 ; j<=K ; j++){
        dp1[i][j]=dp1[i-1][j] ||(j>=a[i] && dp1[i-1][j-a[i] ]);
      }
    }
    boolean[][] dp2=new boolean[N+1][K+1];
    for(int i=0 ; i<=N ; i++)dp2[i][0]=true ;
    for(int i=N-1 ; i>=0 ; i--){
      for(int j=1 ; j<=K ; j++){
        dp2[i][j]=dp2[i+1][j] ||(j>=a[i+1] && dp2[i+1][j-a[i+1] ]);
      }
    }
    int count=0 ;
    loop : for(int i=1 ;
    i<=N ;
    i++){
      int min=Math.max(0,K-a[i]);
      for(int k=min ; k<K ; k++){
        for(int j=0 ; j<=k ; j++){
          if(dp1[i-1][j] && dp2[i][k-j]){
            count++;
            continue loop ;
          }
        }
      }
    }
    System.out.println(N-count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var K : int ; K := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do (     a[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp1 : Sequence(Sequence(boolean)) ; dp1 := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,K + 1)->collect(false)) ;
        var i : int ; i := 0 ; while i <= N do (     dp1[i+1][0+1] := true ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := 1 ; while j <= K do ( (     dp1[i+1][j+1] := dp1[i - 1+1][j+1] or (j >= a[i+1] & dp1[i - 1+1][j - a[i+1]+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var dp2 : Sequence(Sequence(boolean)) ; dp2 := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,K + 1)->collect(false)) ;
        var i : int ; i := 0 ; while i <= N do (     dp2[i+1][0+1] := true ;  ;     i := i + 1 ) ; 
        var i : int ; i := N - 1 ; while i >= 0 do ( (         var j : int ; j := 1 ; while j <= K do ( (     dp2[i+1][j+1] := dp2[i + 1+1][j+1] or (j >= a[i + 1+1] & dp2[i + 1+1][j - a[i + 1+1]+1]) )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     var min : int ; min := Set{0, K - a[i+1]}->max() ;
         var k : int ; k := min ; while k < K do ( (         var j : int ; j := 0 ; while j <= k do ( (     if (dp1[i - 1+1][j+1] & dp2[i+1][k - j+1]) then (     count := count + 1 ; 
     continue ) else skip )  ;     j := j + 1 ) )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(N - count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
class Main {
  static Scanner s=new Scanner(System.in);
  static int gInt(){
    return Integer.parseInt(s.next());
  }
  public static void main(String[] $){
    int n=gInt(),k=gInt();
    int[] a=IntStream.range(0,n).map(i->gInt()).filter(i->i<k).toArray();
    n=a.length ;
    int res=0 ;
    byte[] memo=new byte[k+1];
    boolean[] dp=new boolean[k];
    loop : for(int i=0 ;
    i<n ;
++i){
      if(memo[a[i] ]!=0){
        if(memo[a[i] ]==1)++res ;
        continue ;
      }
      Arrays.fill(dp,false);
      dp[0]=true ;
      for(int j=0 ; j<n ; ++j)if(i!=j){
        for(int m=k-1-a[j]; m>=0 ; --m){
          if((dp[m+a[j] ] |=dp[m])&& m+a[j]>=k-a[i]){
            memo[a[i] ]=-1 ;
            continue loop ;
          }
        }
      }
      memo[a[i] ]=1 ;
++res ;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation gInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := gInt() ;
    var k : int ; k := gInt() ;
     var a : Sequence(int) ; a := Integer.subrange(0, n-1)->collect( _x1 | (lambda i : OclAny in gInt())->apply(_x1) )->select( _x1 | (lambda i : OclAny in i < k)->apply(_x1) )->asSequence() ;
    n := a->size() ; 
    var res : int ; res := 0 ;
    var memo : Sequence(int) ; memo := Integer.subrange(1,k + 1)->collect(0) ;
    var dp : Sequence(boolean) ; dp := Integer.subrange(1,k)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     if (memo[a[i+1]+1] /= 0) then (     if (memo[a[i+1]+1] = 1) then     res := res + 1 ; else skip ; 
     continue ) else skip ; 
     dp := dp->collect(false) ; 
    dp[0+1] := true ; 
        var j : int ; j := 0 ; while j < n do (     if (i /= j) then (         var m : int ; m := k - 1 - a[j+1] ; while m >= 0 do ( (     if ((dp[m + a[j+1]+1]) & m + a[j+1] >= k - a[i+1]) then (     memo[a[i+1]+1] := -1 ; 
     continue ) else skip )  ;     m := m - 1 ) ) else skip ;  ;     j := j + 1 ) ; 
    memo[a[i+1]+1] := 1 ; 
    res := res + 1 ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
    }
    Arrays.sort(a);
    int ans=-1 ;
    int left=0 ;
    int right=n ;
    while(left<right){
      int med=(left+right)/2 ;
      if(a[med]<k){
        boolean[][] dp=new boolean[n][k];
        if(med!=0){
          dp[0][0]=true ;
          if(a[0]<k)dp[0][(int)a[0] ]=true ;
        }
        else {
          dp[0][0]=true ;
          if(n>1){
            dp[1][0]=true ;
            if(a[1]<k)dp[1][(int)a[1] ]=true ;
          }
        }
        for(int i=1 ; i<n ; i++){
          dp[i][0]=true ;
          for(int j=1 ; j<k ; j++){
            dp[i][j]=dp[i-1][j];
            if((i!=med)&&(j>=a[i]))dp[i][j]=(dp[i][j] || dp[i-1][(int)(j-a[i])]);
          }
        }
        int p=0 ;
        for(int j=(int)(k-a[med]); j<k ; j++){
          if(dp[n-1][j])p++;
        }
        if(p==0){
          ans=med ;
          left=med+1 ;
        }
        else {
          right=med ;
        }
      }
      else {
        right=med ;
      }
    }
    ans++;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var ans : int ; ans := -1 ;
    var left : int ; left := 0 ;
    var right : int ; right := n ;
    while (left < right) do (     var med : int ; med := (left + right) / 2 ;
     if (a[med+1] < k) then (     var dp : Sequence(Sequence(boolean)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,k)->collect(false)) ;
     if (med /= 0) then (     dp[0+1][0+1] := true ; 
     if (a[0+1] < k) then     dp[0+1][a[0+1]->oclAsType(int)+1] := true ; else skip ) else (     dp[0+1][0+1] := true ; 
     if (n > 1) then (     dp[1+1][0+1] := true ; 
     if (a[1+1] < k) then     dp[1+1][a[1+1]->oclAsType(int)+1] := true ; else skip ) else skip ) ;  
        var i : int ; i := 1 ; while i < n do ( (     dp[i+1][0+1] := true ; 
         var j : int ; j := 1 ; while j < k do ( (     dp[i+1][j+1] := dp[i - 1+1][j+1] ; 
     if ((i /= med) & (j >= a[i+1])) then     dp[i+1][j+1] := (dp[i+1][j+1] or dp[i - 1+1][(j - a[i+1])->oclAsType(int)+1]) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var p : int ; p := 0 ;
        var j : int ; j := (k - a[med+1])->oclAsType(int) ; while j < k do ( (     if (dp[n - 1+1][j+1]) then     p := p + 1 ; else skip )  ;     j := j + 1 ) ; 
    if (p = 0) then (     ans := med ; 
     left := med + 1 ) else (     right := med ) ;  
 ) else (     right := med ) ) ; 
    ans := ans + 1 ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    int[] a=new int[N];
    for(int i=0 ; i<a.length ; ++i){
      a[i]=sc.nextInt();
    }
    System.out.println(solve(a,K));
    sc.close();
  }
  static int solve(int[] a,int K){
    Arrays.sort(a);
    int lastIndex=-1 ;
    int lower=0 ;
    int upper=a.length-1 ;
    while(lower<=upper){
      int middle=(lower+upper)/2 ;
      if(isUnnecessary(a,K,middle)){
        lastIndex=middle ;
        lower=middle+1 ;
      }
      else {
        upper=middle-1 ;
      }
    }
    return lastIndex+1 ;
  }
  static boolean isUnnecessary(int[] a,int K,int index){
    if(a[index]>=K){
      return false ;
    }
    boolean[] sums=new boolean[K];
    sums[0]=true ;
    for(int i=0 ; i<a.length ; ++i){
      if(i!=index){
        boolean[] nextSums=new boolean[K];
        for(int j=0 ; j<nextSums.length ; ++j){
          nextSums[j]=sums[j] ||(j>=a[i] && sums[j-a[i] ]);
          if(nextSums[j] && j+a[index]>=K){
            return false ;
          }
        }
        sums=nextSums ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(a, K)) ; 
    skip ; 
 );
  static   operation solve( a : Sequence(int), K : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var lastIndex : int ; lastIndex := -1 ;
    var lower : int ; lower := 0 ;
    var upper : int ; upper := a->size() - 1 ;
    while (lower <= upper) do (     var middle : int ; middle := (lower + upper) / 2 ;
     if (isUnnecessary(a, K, middle)) then (     lastIndex := middle ; 
     lower := middle + 1 ) else (     upper := middle - 1 ) ) ; 
    return lastIndex + 1 
 );
  static   operation isUnnecessary( a : Sequence(int), K : int, index : int) : boolean
  pre: true
  post: true
  activity: (     if (a[index+1] >= K) then (     return false ) else skip ; 
     var sums : Sequence(boolean) ; sums := Integer.subrange(1,K)->collect(false) ;
    sums[0+1] := true ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     if (i /= index) then (     var nextSums : Sequence(boolean) ; nextSums := Integer.subrange(1,K)->collect(false) ;
         var j : int ; j := 0 ; while j < nextSums->size() do ( (     nextSums[j+1] := sums[j+1] or (j >= a[i+1] & sums[j - a[i+1]+1]) ; 
     if (nextSums[j+1] & j + a[index+1] >= K) then (     return false ) else skip )  ;     j := j + 1 ) ; 
     sums := nextSums ) else skip )  ;     i := i + 1 ) ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int s=sc.nextInt();
    int k ;
    int count=0 ;
    for(int i=n ; i>0 ; i--){
      k=s/i ;
      count+=k ;
      s-=k*i ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var k : int ;
    var count : int ; count := 0 ;
        var i : int ; i := n ; while i > 0 do ( (     k := s / i ; 
     count := count+(k) ; 
     s := s-(k * i) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    int n=fs.nextInt();
    int s=fs.nextInt();
    if(s % n!=0)System.out.println(s/n+1);
    else System.out.println(s/n);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! 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());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var n : int ; n := fs.nextInt() ;
     var s : int ; s := fs.nextInt() ;
     if (s mod n /= 0) then     OclFile["System.out"].println(s / n + 1) ; else     OclFile["System.out"].println(s / n) ; );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    double[] a,b ;
    int i ;
    a=new double[4];
    b=new double[4];
    for(; sc.hasNext(); ){
      for(i=0 ; i<4 ; i++)a[i]=sc.nextDouble();
      for(i=0 ; i<4 ; i++)b[i]=sc.nextDouble();
      if(judge(a,b))out.println("YES");
      else out.println("NO");
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
  private static boolean judge(double[] a,double[] b){
    int i,j ;
    for(i=0 ; i<2 ; i++)for(j=0 ; j<2 ; j++)if(isin(a,b[i*2],b[1+j*2]))return true ;
    for(i=0 ; i<2 ; i++)for(j=0 ; j<2 ; j++)if(isin(b,a[i*2],a[1+j*2]))return true ;
    if(iscross(a,b)|| iscross(b,a))return true ;
    return false ;
  }
  private static boolean isin(double[] a,double x,double y){
    if(a[0]<=x && x<=a[2] && a[1]<=y && y<=a[3])return true ;
    return false ;
  }
  private static boolean iscross(double[] a,double[] b){
    if(a[0]<b[0] && b[2]<a[2] && b[1]<a[1] && a[3]<b[3])return true ;
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var a : Sequence(double) ;
    var b : Sequence(double) ;
    var i : int ;
    a := Integer.subrange(1,4)->collect(0.0) ; 
    b := Integer.subrange(1,4)->collect(0.0) ; 
      while sc.hasNext() do ( (         i := 0 ; while i < 4 do (     a[i+1] := sc.nextDouble() ;  ;     i := i + 1 ) ; 
         i := 0 ; while i < 4 do (     b[i+1] := sc.nextDouble() ;  ;     i := i + 1 ) ; 
     if (judge(a, b)) then     out.println("YES") ; else     out.println("NO") ; )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
  static   operation judge( a : Sequence(double), b : Sequence(double)) : boolean
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := 0 ; while i < 2 do (         j := 0 ; while j < 2 do (     if (isin(a, b[i * 2+1], b[1 + j * 2+1])) then     return true else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < 2 do (         j := 0 ; while j < 2 do (     if (isin(b, a[i * 2+1], a[1 + j * 2+1])) then     return true else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    if (iscross(a, b) or iscross(b, a)) then     return true else skip ; 
    return false 
 );
  static   operation isin( a : Sequence(double), x : double, y : double) : boolean
  pre: true
  post: true
  activity: (     if (a[0+1] <= x & x <= a[2+1] & a[1+1] <= y & y <= a[3+1]) then     return true else skip ; 
     return false );
  static   operation iscross( a : Sequence(double), b : Sequence(double)) : boolean
  pre: true
  post: true
  activity: (     if (a[0+1] < b[0+1] & b[2+1] < a[2+1] & b[1+1] < a[1+1] & a[3+1] < b[3+1]) then     return true else skip ; 
     return false );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    Arrays.sort(a);
    String x=Integer.toString(a[0]);
    String y=Integer.toString(a[1]);
    String z=Integer.toString(a[2]);
    String w=Integer.toString(a[3]);
    int[] b=new int[12];
    b[0]=Integer.valueOf(x+y);
    b[1]=Integer.valueOf(x+z);
    b[2]=Integer.valueOf(x+w);
    b[3]=Integer.valueOf(y+x);
    b[4]=Integer.valueOf(y+z);
    b[5]=Integer.valueOf(y+w);
    b[6]=Integer.valueOf(z+x);
    b[7]=Integer.valueOf(z+y);
    b[8]=Integer.valueOf(z+w);
    b[9]=Integer.valueOf(w+x);
    b[10]=Integer.valueOf(w+y);
    b[11]=Integer.valueOf(w+z);
    Arrays.sort(b);
    System.out.println(b[2]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var x : String ; x := ((a[0+1]) + "") ;
    var y : String ; y := ((a[1+1]) + "") ;
    var z : String ; z := ((a[2+1]) + "") ;
    var w : String ; w := ((a[3+1]) + "") ;
    var b : Sequence(int) ; b := Integer.subrange(1,12)->collect(0) ;
    b[0+1] := (x + y)->toInteger() ; 
    b[1+1] := (x + z)->toInteger() ; 
    b[2+1] := (x + w)->toInteger() ; 
    b[3+1] := (y + x)->toInteger() ; 
    b[4+1] := (y + z)->toInteger() ; 
    b[5+1] := (y + w)->toInteger() ; 
    b[6+1] := (z + x)->toInteger() ; 
    b[7+1] := (z + y)->toInteger() ; 
    b[8+1] := (z + w)->toInteger() ; 
    b[9+1] := (w + x)->toInteger() ; 
    b[10+1] := (w + y)->toInteger() ; 
    b[11+1] := (w + z)->toInteger() ; 
    b := b->sort() ; 
    OclFile["System.out"].println(b[2+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1061A_Coins {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    final int coin=input.nextInt();
    final int amount=input.nextInt();
    if(coin>=amount){
      System.out.println(1);
    }
    else {
      int res ;
      if(amount % coin==0){
        res=amount/coin ;
      }
      else {
        res=amount/coin+1 ;
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1061A_Coins {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var coin : int ; coin := input.getCurrent()->toInteger() ;
     var amount : int ; amount := input.getCurrent()->toInteger() ;
     if (coin >= amount) then (     OclFile["System.out"].println(1) ) else (     var res : int ;
     if (amount mod coin = 0) then (     res := amount / coin ) else (     res := amount / coin + 1 ) ;  
     OclFile["System.out"].println(res) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),k=sc.nextInt();
    String a=sc.next();
    if(k>n/2){
      while(k<n){
        System.out.println("RIGHT");
        k++;
      }
    }
    else {
      while(k>1){
        System.out.println("LEFT");
        k--;
      }
    }
    if(k==1){
      for(int i=0 ; i<a.length(); i++){
        System.out.println("PRINT "+a.charAt(i));
        if((i+1)<a.length()){
          System.out.println("RIGHT");
        }
      }
    }
    else {
      for(int i=a.length()-1 ; i>=0 ; i--){
        System.out.println("PRINT "+a.charAt(i));
        if((i-1)>=0){
          System.out.println("LEFT");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : String ; a := sc.getCurrent() ;
    if (k > n / 2) then (     while (k < n) do (     OclFile["System.out"].println("RIGHT") ; 
     k := k + 1 ) ) else (     while (k > 1) do (     OclFile["System.out"].println("LEFT") ; 
     k := k - 1 ) ) ;  
    if (k = 1) then (         var i : int ; i := 0 ; while i < a->size() do ( (     OclFile["System.out"].println("PRINT " + a->at(i+1)) ; 
     if ((i + 1) < a->size()) then (     OclFile["System.out"].println("RIGHT") ) else skip )  ;     i := i + 1 ) ) else (         var i : int ; i := a->size() - 1 ; while i >= 0 do ( (     OclFile["System.out"].println("PRINT " + a->at(i+1)) ; 
     if (((i)->char2byte() - 1) >= 0) then (     OclFile["System.out"].println("LEFT") ) else skip )  ;     i := i - 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static ArrayList<Integer>v=new ArrayList<Integer>();
  static void multiply(int x){
    int carry=0 ;
    int size=v.size();
    for(int i=0 ; i<size ; i++){
      int res=carry+v.get(i)*x ;
      v.set(i,res % 10);
      carry=res/10 ;
    }
    while(carry!=0){
      v.add(carry % 10);
      carry/=10 ;
    }
  }
  static int findSumOfDigits(int n){
    v.add(1);
    for(int i=1 ; i<=n ; i++)multiply(i);
    int sum=0 ;
    int size=v.size();
    for(int i=0 ; i<size ; i++)sum+=v.get(i);
    return sum ;
  }
  public static void main(String[] args){
    int n=1000 ;
    System.out.println(findSumOfDigits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute v : Sequence(int) := Sequence{};
  static   operation multiply( x : int) : void
  pre: true
  post: true
  activity: (     var carry : int ; carry := 0 ;
     var size : int ; size := v->size() ;
         var i : int ; i := 0 ; while i < size do ( (     var res : int ; res := carry + v->at(i+1) * x ;
     v := v.setAt(i+1,res mod 10) ; 
     carry := res / 10 )  ;     i := i + 1 ) ; 
     while (carry /= 0) do (     v := v->including(carry mod 10) ; 
     carry := carry/(10) ) );
  static   operation findSumOfDigits( n : int) : int
  pre: true
  post: true
  activity: (     v := v->including(1) ; 
         var i : int ; i := 1 ; while i <= n do (     execute multiply(i) ;  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var size : int ; size := v->size() ;
        var i : int ; i := 0 ; while i < size do (     sum := sum+(v->at(i+1)) ;  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1000 ;
     OclFile["System.out"].println(findSumOfDigits(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B436 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int M=in.nextInt();
    in.nextInt();
    int[] answer=new int[M];
    for(int n=0 ; n<N ; n++){
      char[] S=in.next().toCharArray();
      for(int m=0 ; m<M ; m++){
        char c=S[m];
        if(c=='L'){
          int hit=m-n ;
          if(hit>=0){
            answer[hit]++;
          }
        }
        else if(c=='R'){
          int hit=m+n ;
          if(hit<M){
            answer[hit]++;
          }
        }
        else if(c=='U'){
          if(n % 2==0){
            answer[m]++;
          }
        }
      }
    }
    StringBuilder output=new StringBuilder();
    for(int a : answer){
      output.append(a).append(' ');
    }
    System.out.println(output);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B436 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var M : int ; M := in.getCurrent()->toInteger() ;
    skip ; 
    var answer : Sequence(int) ; answer := Integer.subrange(1,M)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     var S : Sequence(String) ; S := in.getCurrent()->characters() ;
         var m : int ; m := 0 ; while m < M do ( (     var c : String ; c := S[m+1] ;
     if (c = 'L') then (     var hit : int ; hit := m - n ;
     if (hit >= 0) then (     answer[hit+1] := answer[hit+1] + 1 ) else skip ) else     if (c = 'R') then (     var hit : int ; hit := m + n ;
     if (hit < M) then (     answer[hit+1] := answer[hit+1] + 1 ) else skip ) else     if (c = 'U') then (     if (n mod 2 = 0) then (     answer[m+1] := answer[m+1] + 1 ) else skip ) else skip ; ;  )  ;     m := m + 1 ) )  ;     n := n + 1 ) ; 
    var output : String ; output := StringLib.newString() ;
    for (a : answer) do ( (     output := output + StringLib.newString(a) + StringLib.newString(' ') )  ) ; 
    OclFile["System.out"].println(output) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.*;
import javafx.util.Pair ;
public class Main {
  public static void main(String args[]){
    FastScanner input=new FastScanner();
    int n=input.nextInt();
    int m=input.nextInt();
    int k=input.nextInt();
    int ans[]=new int[m];
    char a[][]=new char[n][m];
    for(int i=0 ; i<n ; i++){
      a[i]=input.next().toCharArray();
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(a[i][j]=='U'){
          if(i % 2==0)ans[j]++;
        }
        else if(a[i][j]=='L'){
          if(j-i>=0){
            ans[j-i]++;
          }
        }
        else if(a[i][j]=='R'){
          if(j+i<m){
            ans[j+i]++;
          }
        }
      }
    }
    for(int an : ans){
      System.out.print(an+" ");
    }
    System.out.println("");
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var n : int ; n := input.nextInt() ;
    var m : int ; m := input.nextInt() ;
    var k : int ; k := input.nextInt() ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,m)->collect(0) ;
    var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.next()->characters() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (a[i+1][j+1] = 'U') then (     if (i mod 2 = 0) then     ans[j+1] := ans[j+1] + 1 ; else skip ) else     if (a[i+1][j+1] = 'L') then (     if (j - (i)->char2byte() >= 0) then (     ans[j - (i)->char2byte()+1] := ans[j - (i)->char2byte()+1] + 1 ) else skip ) else     if (a[i+1][j+1] = 'R') then (     if (j + i < m) then (     ans[j + i+1] := ans[j + i+1] + 1 ) else skip ) else skip ; ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    for (an : ans) do ( (     OclFile["System.out"].print(an + " ") )  ) ; 
    OclFile["System.out"].println("") ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeforces356A {
  public static void main(String[] args)throws Exception {
    FastReader in=new FastReader();
    int n=in.nextInt();
    TreeSet<Integer>left=new TreeSet<>();
    int[] answer=new int[n];
    for(int i=0 ; i<n ; i++){
      left.add(i);
    }
    int q=in.nextInt();
    while(q-->0){
      int l=in.nextInt()-1 ;
      int r=in.nextInt()-1 ;
      int win=in.nextInt();
      while(left.ceiling(l)!=null && left.ceiling(l)<=r){
        int curr=left.ceiling(l);
        answer[curr]=win ;
        left.remove(curr);
      }
      answer[win-1]=0 ;
      left.add(win-1);
    }
    StringBuilder ans=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      ans.append(answer[i]+" ");
    }
    System.out.println(ans);
  }
  static class FastReader {
    StringTokenizer st ;
    BufferedReader br ;
    public FastReader(){
      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 s="" ;
      while(st==null || st.hasMoreElements()){
        try {
          s=br.readLine();
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return s ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces356A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var n : int ; n := in.nextInt() ;
    var left : Set(int) ; left := Set{} ;
    var answer : Sequence(int) ; answer := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     left := left->including(i) )  ;     i := i + 1 ) ; 
    var q : int ; q := in.nextInt() ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     var l : int ; l := in.nextInt() - 1 ;
     var r : int ; r := in.nextInt() - 1 ;
    var win : int ; win := in.nextInt() ;
    while (left.ceiling(l) /= null & left.ceiling(l) <= r) do (     var curr : int ; curr := left.ceiling(l) ;
     answer[curr+1] := win ; 
     left := left->excludingAt(curr+1) ) ; 
    answer[win - 1+1] := 0 ; 
    left := left->including(win - 1) ; 
 ) ;  ) ;  
    var ans : String ; ans := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans + StringLib.newString(answer[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class FastReader {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var s : String ; s := "" ;
     while (st = null or st.hasNext()) do (     try (     s := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return s );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  static TreeSet<Long>set ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=in.nextLong();
    long[] dp=new long[n+1];
    Arrays.fill(dp,-1);
    dp[n-1]=a[n-1];
    for(int i=n-1 ; i>=0 ; i--){
      dp[i]=Math.max(dp[i+1],a[i]);
    }
    for(int i=0 ; i<n ; i++){
      if(a[i]>dp[i+1])pw.print(0+" ");
      else pw.print((dp[i+1]-a[i]+1)+" ");
    }
    pw.println();
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute set : Set(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(long) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
    dp := dp->collect(-1) ; 
    dp[n - 1+1] := a[n - 1+1] ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     dp[i+1] := Set{dp[i + 1+1], a[i+1]}->max() )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] > dp[i + 1+1]) then     skip ; else     skip ; )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B_Luxurious_Houses {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 FastReader scan=new FastReader();
  public static void main(String[] args){
    int t=1 ;
    while(t-->0){
      solve();
    }
  }
  public static void solve(){
    int n=scan.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=scan.nextInt();
    }
    int[] temp=new int[n];
    int max=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      temp[i]=max ;
      if(arr[i]>max){
        max=arr[i];
      }
    }
    for(int i=0 ; i<temp.length ; i++){
      if(arr[i]<=temp[i]){
        System.out.print(temp[i]-arr[i]+1+" ");
      }
      else {
        System.out.print(0+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Luxurious_Houses {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   attribute scan : FastReader := FastReader.newFastReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := scan.nextInt() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := scan.nextInt() )  ;     i := i + 1 ) ; 
    var temp : Sequence(int) ; temp := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     temp[i+1] := max ; 
     if (arr[i+1] > max) then (     max := arr[i+1] ) else skip )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < temp->size() do ( (     if (arr[i+1] <= temp[i+1]) then (     OclFile["System.out"].print(temp[i+1] - arr[i+1] + 1 + " ") ) else (     OclFile["System.out"].print(0 + " ") ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] arr=new int[n];
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=in.nextInt();
    int max=arr[n-1];
    int j=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(arr[i]<=max && i<n-1){
        a[j]=max-arr[i]+1 ;
        j++;
      }
      else {
        a[j]=0 ;
        max=arr[i];
        j++;
      }
    }
    for(int i=n-1 ; i>=0 ; i--)System.out.print(a[i]+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var max : int ; max := arr[n - 1+1] ;
    var j : int ; j := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (arr[i+1] <= max & i < n - 1) then (     a[j+1] := max - arr[i+1] + 1 ; 
     j := j + 1 ) else (     a[j+1] := 0 ; 
     max := arr[i+1] ; 
     j := j + 1 ) )  ;     i := i - 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class PellNumber {
  public static int pell(int n){
    if(n<=2)return n ;
    return 2*pell(n-1)+pell(n-2);
  }
  public static void main(String args[]){
    int n=4 ;
    System.out.println(pell(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class PellNumber {
  static   operation pell( n : int) : int
  pre: true
  post: true
  activity: (     if (n <= 2) then     return n else skip ; 
     return 2 * pell(n - 1) + pell(n - 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(pell(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int MAX=10 ;
    ArrayList<Integer>l=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      int b=sc.nextInt();
      if(l.size()<MAX || l.get(MAX-1)>=b)l.add(b);
      sort(l);
      if(l.size()==MAX)l.remove(MAX-1);
    }
    Integer[] a=l.toArray(new Integer[] {
    }
);
    ArrayList<Long>ans=new ArrayList<Long>();
    for(int i=0 ; i<a.length ; i++)for(int j=0 ; j<a.length ; j++)if(i!=j){
      ans.add(Long.parseLong(String.valueOf(a[i])+String.valueOf(a[j])));
    }
    sort(ans);
    System.out.println(ans.get(2));
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var MAX : int ; MAX := 10 ;
    var l : Sequence(int) ; l := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (l->size() < MAX or l->at(MAX - 1+1) >= b) then     l := l->including(b) ; else skip ; 
     execute sort(l) ; 
     if (l->size() = MAX) then     l := l->excludingFirst(MAX - 1) ; else skip )  ;     i := i + 1 ) ; 
    var a : Sequence(int) ; a := l->asSequence() ;
    var ans : Sequence(long) ; ans := Sequence{} ;
        var i : int ; i := 0 ; while i < a->size() do (         var j : int ; j := 0 ; while j < a->size() do (     if (i /= j) then (     ans := ans->including((((a[i+1]) + "") + ((a[j+1]) + ""))->toLong()) ) else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    execute sort(ans) ; 
    OclFile["System.out"].println(ans->at(2+1)) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Hello {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int square=n*n ;
    ArrayList<Integer>odd=new ArrayList<>();
    ArrayList<Integer>even=new ArrayList<>();
    for(int i=1 ; i<=square ; i++){
      if(i % 2==0){
        even.add(i);
      }
      else {
        odd.add(i);
      }
    }
    int loop=square/n ;
    int div=loop/2 ;
    debug(div);
    for(int i=1 ; i<=loop ; i++){
      for(int j=0 ; j<div ; j++){
        if(i % 2==1){
          pw.print(odd.remove(0)+" "+(even.remove(even.size()-1))+" ");
        }
        else {
          pw.print(even.remove(0)+" "+(odd.remove(odd.size()-1))+" ");
        }
      }
      pw.println();
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hello {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var square : int ; square := n * n ;
    var odd : Sequence(int) ; odd := Sequence{} ;
    var even : Sequence(int) ; even := Sequence{} ;
        var i : int ; i := 1 ; while i <= square do ( (     if (i mod 2 = 0) then (     even := even->including(i) ) else (     odd := odd->including(i) ) )  ;     i := i + 1 ) ; 
    var loop : int ; loop := square / n ;
    var div : int ; div := loop / 2 ;
    execute debug(div) ; 
        var i : int ; i := 1 ; while i <= loop do ( (         var j : int ; j := 0 ; while j < div do ( (     if (i mod 2 = 1) then (     skip ) else (     skip ) )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
import java.lang.Math ;
public class MainClass {
  public static void main(String[] agrs){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=n*n ;
    int[] lst=new int[n/2];
    for(int i=1 ; i<=n/2 ; i++)lst[i-1]=i ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<lst.length ; j++){
        System.out.print(lst[j]+" "+(k-lst[j]+1)+" ");
        lst[j]+=n/2 ;
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := n * n ;
    var lst : Sequence(int) ; lst := Integer.subrange(1,n / 2)->collect(0) ;
        var i : int ; i := 1 ; while i <= n / 2 do (     lst[i - 1+1] := i ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < lst->size() do ( (     OclFile["System.out"].print(lst[j+1] + " " + (k - lst[j+1] + 1) + " ") ; 
     lst[j+1] := lst[j+1]+(n / 2) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  private static void solve(Integer n,Integer k,String[] slogan){
    Integer half=n/2 ;
    if(k>half){
      for(int i=k ; i<n ; i++){
        System.out.println("RIGHT");
      }
      for(int i=n-1 ; i>=0 ; i--){
        System.out.println("PRINT "+slogan[i]);
        if(i!=0)System.out.println("LEFT");
      }
    }
    else {
      for(int i=k ; i>1 ; i--){
        System.out.println("LEFT");
      }
      for(int i=0 ; i<n ; i++){
        System.out.println("PRINT "+slogan[i]);
        if(i!=(n-1))System.out.println("RIGHT");
      }
    }
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String[] firstLine=scanner.nextLine().split(" ");
    Integer n=Integer.parseInt(firstLine[0]);
    Integer k=Integer.parseInt(firstLine[1]);
    String[] slogan=scanner.nextLine().split("");
    solve(n,k,slogan);
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation solve( n : int, k : int, slogan : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var half : int ; half := n / 2 ;
     if (k > half) then (         var i : int ; i := k ; while i < n do ( (     OclFile["System.out"].println("RIGHT") )  ;     i := i + 1 ) ; 
         var i : int ; i := n - 1 ; while i >= 0 do ( (     OclFile["System.out"].println("PRINT " + slogan[i+1]) ; 
     if (i /= 0) then     OclFile["System.out"].println("LEFT") ; else skip )  ;     i := i - 1 ) ) else (         var i : int ; i := k ; while i > 1 do ( (     OclFile["System.out"].println("LEFT") )  ;     i := i - 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println("PRINT " + slogan[i+1]) ; 
     if (i /= (n - 1)) then     OclFile["System.out"].println("RIGHT") ; else skip )  ;     i := i + 1 ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var firstLine : Sequence(String) ; firstLine := scanner.nextLine()->split(" ") ;
    var n : int ; n := (firstLine[0+1])->toInteger() ;
    var k : int ; k := (firstLine[1+1])->toInteger() ;
    var slogan : Sequence(String) ; slogan := scanner.nextLine()->split("") ;
    execute solve(n, k, slogan) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static void find(int n){
    int i=1 ;
    int j=(int)Math.pow(n,2);
    while(i<j){
      int val=n/2 ;
      while(val-->0 && i<j){
        System.out.print(i+" "+j+" ");
        i++;
        j--;
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    try {
      System.setIn(new FileInputStream("input.txt"));
      System.setOut(new PrintStream(new FileOutputStream("output.txt")));
    }
    catch(Exception e){
      System.err.println("Error");
    }
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    find(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation find( n : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 1 ;
     var j : int ; j := n->pow(2)->oclAsType(int) ;
     while (i < j) do (     var val : int ; val := n / 2 ;
         while (val > 0 & i < j) do (    skip ; (     OclFile["System.out"].print(i + " " + j + " ") ; 
     i := i + 1 ; 
     j := j - 1 ) ;  ) ;  
     OclFile["System.out"].println() ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) )   catch (e : ProgramException) do (     OclFile["System.err"].println("Error") )
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     execute find(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication96 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    ArrayList<Integer>arr=new ArrayList<>();
    String s1="" ;
    String s2="" ;
    int counter=0 ;
    for(int i=0 ; i<num*num ; i++){
      arr.add(i+1);
    }
    for(int i=0 ; i<arr.size()/2 ; i++){
      if(i % 2==0){
        s1+=arr.get(i)+" "+arr.get(arr.size()-i-1)+" " ;
      }
      else {
        s2+=arr.get(i)+" "+arr.get(arr.size()-i-1)+" " ;
      }
    }
    System.out.println(s1);
    System.out.println(s2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication96 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Sequence{} ;
    var s1 : String ; s1 := "" ;
    var s2 : String ; s2 := "" ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < num * num do ( (     arr := arr->including(i + 1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < arr->size() / 2 do ( (     if (i mod 2 = 0) then (     s1 := s1+(arr->at(i+1) + " " + arr->at(arr->size() - i - 1+1) + " ") ) else (     s2 := s2+(arr->at(i+1) + " " + arr->at(arr->size() - i - 1+1) + " ") ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s1) ; 
    OclFile["System.out"].println(s2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printSmall(int arr[],int asize,int n){
    int[] copy_arr=Arrays.copyOf(arr,asize);
    Arrays.sort(copy_arr);
    for(int i=0 ; i<asize ; ++i){
      if(Arrays.binarySearch(copy_arr,0,n,arr[i])>-1)System.out.print(arr[i]+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,5,8,9,6,7,3,4,2,0 };
      int asize=arr.length ;
      int n=5 ;
      printSmall(arr,asize,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printSmall( arr : Sequence(int), asize : int, n : int) : void
  pre: true
  post: true
  activity: (     var copy_arr : Sequence(int) ; copy_arr := arr.subrange(1,asize) ;
     copy_arr := copy_arr->sort() ; 
         var i : int ; i := 0 ; while i < asize do ( (     if ((copy_arr->indexOf(arr[i+1]) - 1) > -1) then     OclFile["System.out"].print(arr[i+1] + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,8,9,6,7,3,4,2,0} ;
     var asize : int ; asize := arr->size() ;
     var n : int ; n := 5 ;
     execute printSmall(arr, asize, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  static int countNumbers(int n){
    int k=0 ;
    int count=0 ;
    while(n>0){
      if((n & 1)==0)count+=(int)(Math.pow(2,k));
      k+=1 ;
      n>>=1 ;
    }
    return count ;
  }
  public static void main(String[] args){
    int n=11 ;
    System.out.println(countNumbers(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countNumbers( n : int) : int
  pre: true
  post: true
  activity: (     var k : int ; k := 0 ;
     var count : int ; count := 0 ;
     while (n > 0) do (     if ((n & 1) = 0) then     count := count+((2->pow(k))->oclAsType(int)) ; else skip ; 
     k := k+(1) ; 
     n := n/(2->pow(1)) ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 11 ;
     OclFile["System.out"].println(countNumbers(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),m=in.nextInt(),money=in.nextInt();
    int min=Integer.MAX_VALUE,max=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      min=Math.min(in.nextInt(),min);
    }
    for(int i=0 ; i<m ; i++){
      max=Math.max(in.nextInt(),max);
    }
    if(money % min==0){
      int div=money/min ;
      div=div*max ;
      pw.print(Math.max(div,money));
    }
    else {
      int div=money/min ;
      div=(div*max)+(money % min);
      pw.print(Math.max(div,money));
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var money : int ; money := in.getCurrent()->toInteger() ;
    var min : int ; min := 2147483647 ;
    var max : int ; max := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     min := Set{in.getCurrent()->toInteger(), min}->min() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     max := Set{in.getCurrent()->toInteger(), max}->max() )  ;     i := i + 1 ) ; 
    if (money mod min = 0) then (     var div : int ; div := money / min ;
     div := div * max ; 
     skip ) else (     var div : int ; div := money / min ;
     div := (div * max) + (money mod min) ; 
     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=26 ;
  static void updateFreq(String str,int freq[]){
    int len=str.length();
    for(int i=0 ; i<len ; i++){
      freq[str.charAt(i)-'a']++;
    }
  }
  static int maxCount(String str,String patt){
    int[] strFreq=new int[MAX];
    updateFreq(str,strFreq);
    int[] pattFreq=new int[MAX];
    updateFreq(patt,pattFreq);
    int ans=Integer.MAX_VALUE ;
    for(int i=0 ; i<MAX ; i++){
      if(pattFreq[i]==0)continue ;
      ans=Math.min(ans,strFreq[i]/pattFreq[i]);
    }
    return ans ;
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    String patt="geeks" ;
    System.out.print(maxCount(str,patt));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 26;
  static   operation updateFreq( str : String, freq : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
         var i : int ; i := 0 ; while i < len do ( (     freq[str->at(i+1) - ('a')->char2byte()+1] := freq[str->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) );
  static   operation maxCount( str : String, patt : String) : int
  pre: true
  post: true
  activity: (     var strFreq : Sequence(int) ; strFreq := Integer.subrange(1,MAX)->collect(0) ;
     execute updateFreq(str, strFreq) ; 
    var pattFreq : Sequence(int) ; pattFreq := Integer.subrange(1,MAX)->collect(0) ;
    execute updateFreq(patt, pattFreq) ; 
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i < MAX do ( (     if (pattFreq[i+1] = 0) then     continue else skip ; 
     ans := Set{ans, strFreq[i+1] / pattFreq[i+1]}->min() )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var patt : String ; patt := "geeks" ;
     OclFile["System.out"].print(maxCount(str, patt)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      int n=scan.nextInt();
      int[] str=new int[n];
      for(int i=0 ; i<n ; i++){
        str[i]=scan.nextInt();
      }
      Arrays.sort(str);
      int[] a=new int[3];
      int count=0 ;
      int t=0 ;
      for(int i=0 ; i<n && i<4 ; i++){
        for(int j=0 ; j<n && j<4 ; j++){
          if(i==j){
            continue ;
          }
          t=Integer.parseInt(str[i]+""+str[j]);
          if(count<3){
            a[count]=t ;
            count++;
          }
          else {
            if(count==3){
              Arrays.sort(a);
              count++;
            }
            if(a[2]>t){
              if(a[1]>t){
                a[2]=a[1];
                if(a[0]>t){
                  a[1]=a[0];
                  a[0]=t ;
                }
                else {
                  a[1]=t ;
                }
              }
              else {
                a[2]=t ;
              }
            }
          }
        }
      }
      System.out.println(a[2]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var str : Sequence(int) ; str := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     str[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    str := str->sort() ; 
    var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
    var count : int ; count := 0 ;
    var t : int ; t := 0 ;
        var i : int ; i := 0 ; while i < n & i < 4 do ( (         var j : int ; j := 0 ; while j < n & j < 4 do ( (     if (i = j) then (     continue ) else skip ; 
     t := (str[i+1] + "" + str[j+1])->toInteger() ; 
     if (count < 3) then (     a[count+1] := t ; 
     count := count + 1 ) else (     if (count = 3) then (     a := a->sort() ; 
     count := count + 1 ) else skip ; 
     if (a[2+1] > t) then (     if (a[1+1] > t) then (     a[2+1] := a[1+1] ; 
     if (a[0+1] > t) then (     a[1+1] := a[0+1] ; 
     a[0+1] := t ) else (     a[1+1] := t ) ) else (     a[2+1] := t ) ) else skip ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a[2+1]) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int a[]=new int[n+1];
    int b[]=new int[n+1];
    for(int i=1 ; i<=n ; i++)a[i]=in.nextInt();
    for(int i=1 ; i<=n ; i++)b[i]=in.nextInt();
    long a1=0,b1=0,ans=0 ;
    for(int i=1 ; i<=n ; i++){
      a1=a1 | a[i];
      b1=b1 | b[i];
      if(a1+b1>ans)ans=a1+b1 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (     b[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var a1 : long ; a1 := 0 ;
    var b1 : long ; b1 := 0 ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     a1 := MathLib.bitwiseOr(a1,a[i+1]) ; 
     b1 := MathLib.bitwiseOr(b1,b[i+1]) ; 
     if (a1 + b1 > ans) then     ans := a1 + b1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication142 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayList<Integer>arr=new ArrayList<>();
    ArrayList<Integer>arra=new ArrayList<>();
    int num=sc.nextInt();
    int c=0 ;
    int s=0 ;
    for(int i=0 ; i<num ; i++){
      arr.add(sc.nextInt());
    }
    for(int i=0 ; i<num ; i++){
      arra.add(sc.nextInt());
    }
    for(int i=0 ; i<num ; i++){
      c |=arr.get(i);
      s |=arra.get(i);
    }
    System.out.println(c+s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication142 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(int) ; arr := Sequence{} ;
    var arra : Sequence(int) ; arra := Sequence{} ;
    var num : int ; num := sc.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
    var s : int ; s := 0 ;
        var i : int ; i := 0 ; while i < num do ( (     arr := arr->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < num do ( (     arra := arra->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < num do ( (     c := MathLib.bitwiseOr(c, arr->at(i+1)) ; 
     s := MathLib.bitwiseOr(s, arra->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c + s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A354 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int L=in.nextInt();
    int R=in.nextInt();
    int QL=in.nextInt();
    int QR=in.nextInt();
    int[] W=new int[N];
    int[] sum=new int[N+1];
    for(int n=0 ; n<N ; n++){
      W[n]=in.nextInt();
      sum[n+1]=sum[n]+W[n];
    }
    long min=Long.MAX_VALUE ;
    for(int firstR=0 ; firstR<=N ; firstR++){
      int lCount=firstR ;
      int rCount=N-lCount ;
      long cand=sum[lCount]*L+(sum[N]-sum[lCount])*R ;
      int llCount=Math.max(0,lCount-rCount-1);
      int rrCount=Math.max(0,rCount-lCount-1);
      cand+=llCount*QL ;
      cand+=rrCount*QR ;
      min=Math.min(cand,min);
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A354 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var L : int ; L := in.getCurrent()->toInteger() ;
    var R : int ; R := in.getCurrent()->toInteger() ;
    var QL : int ; QL := in.getCurrent()->toInteger() ;
    var QR : int ; QR := in.getCurrent()->toInteger() ;
    var W : Sequence(int) ; W := Integer.subrange(1,N)->collect(0) ;
    var sum : Sequence(int) ; sum := Integer.subrange(1,N + 1)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     W[n+1] := in.getCurrent()->toInteger() ; 
     sum[n + 1+1] := sum[n+1] + W[n+1] )  ;     n := n + 1 ) ; 
    var min : long ; min := "9223372036854775807"->toLong() ;
        var firstR : int ; firstR := 0 ; while firstR <= N do ( (     var lCount : int ; lCount := firstR ;
     var rCount : int ; rCount := N - lCount ;
    var cand : long ; cand := sum[lCount+1] * L + (sum[N+1] - sum[lCount+1]) * R ;
    var llCount : int ; llCount := Set{0, lCount - rCount - 1}->max() ;
    var rrCount : int ; rrCount := Set{0, rCount - lCount - 1}->max() ;
    cand := cand+(llCount * QL) ; 
    cand := cand+(rrCount * QR) ; 
    min := Set{cand, min}->min() ; 
 )  ;     firstR := firstR + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.*;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=input.nextInt(),k=input.nextInt();
    input.nextLine();
    String s=input.nextLine();
    int p=0 ;
    if(n-k<=k-1){
      p=1 ;
      for(int i=0 ; i<n-k ; i++){
        System.out.println("RIGHT");
      }
    }
    else {
      for(int i=0 ; i<k-1 ; i++)System.out.println("LEFT");
    }
    String c="LEFT" ;
    if(p==0)c="RIGHT" ;
    for(int i=0 ; i<n ; i++){
      int j=i ;
      if(p>0)j=n-i-1 ;
      String m="PRINT "+s.charAt(j);
      System.out.println(m);
      if(p==0 && j<n-1)System.out.println(c);
      else if(p==1 && j>0)System.out.println(c);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := input.getCurrent()->toInteger() ;
    var k : int ; k := input.getCurrent()->toInteger() ;
    skip ; 
    var s : String ; s := input.nextLine() ;
    var p : int ; p := 0 ;
    if (n - k <= k - 1) then (     p := 1 ; 
         var i : int ; i := 0 ; while i < n - k do ( (     OclFile["System.out"].println("RIGHT") )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < k - 1 do (     OclFile["System.out"].println("LEFT") ;  ;     i := i + 1 ) ) ;  
    var c : String ; c := "LEFT" ;
    if (p = 0) then     c := "RIGHT" ; else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     var j : int ; j := i ;
     if (p > 0) then     j := n - (i)->char2byte() - 1 ; else skip ; 
    var m : String ; m := "PRINT " + s->at(j+1) ;
    OclFile["System.out"].println(m) ; 
    if (p = 0 & j < n - 1) then     OclFile["System.out"].println(c) else     if (p = 1 & j > 0) then     OclFile["System.out"].println(c) ; else skip ; ;  
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double wastedWater(double V,double M,double N){
    double wasted_amt,amt_per_min,time_to_fill ;
    amt_per_min=M-N ;
    time_to_fill=V/amt_per_min ;
    wasted_amt=N*time_to_fill ;
    return wasted_amt ;
  }
  public static void main(String[] args){
    double V,M,N ;
    V=700 ;
    M=10 ;
    N=3 ;
    System.out.println(wastedWater(V,M,N));
    V=1000 ;
    M=100 ;
    N=50 ;
    System.out.println(wastedWater(V,M,N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation wastedWater( V : double, M : double, N : double) : double
  pre: true
  post: true
  activity: (     var wasted_amt : double ;
    var amt_per_min : double ;
    var time_to_fill : double ;
     amt_per_min := M - N ; 
    time_to_fill := V / amt_per_min ; 
    wasted_amt := N * time_to_fill ; 
    return wasted_amt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var V : double ;
    var M : double ;
    var N : double ;
     V := 700 ; 
    M := 10 ; 
    N := 3 ; 
    OclFile["System.out"].println(wastedWater(V, M, N)) ; 
    V := 1000 ; 
    M := 100 ; 
    N := 50 ; 
    OclFile["System.out"].println(wastedWater(V, M, N)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxSubStr(String str,int n){
    int count0=0,count1=0 ;
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      if(str.charAt(i)=='0'){
        count0++;
      }
      else {
        count1++;
      }
      if(count0==count1){
        cnt++;
      }
    }
    if(count0!=count1){
      return-1 ;
    }
    return cnt ;
  }
  public static void main(String[] args){
    String str="0100110101" ;
    int n=str.length();
    System.out.println(maxSubStr(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxSubStr( str : String, n : int) : int
  pre: true
  post: true
  activity: (     var count0 : int ; count0 := 0 ;
    var count1 : int ; count1 := 0 ;
     var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (str->at(i+1) = '0') then (     count0 := count0 + 1 ) else (     count1 := count1 + 1 ) ;  
     if (count0 = count1) then (     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (count0 /= count1) then (     return -1 ) else skip ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "0100110101" ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].println(maxSubStr(str, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] abc=new int[3];
    abc[0]=sc.nextInt();
    abc[1]=sc.nextInt();
    abc[2]=sc.nextInt();
    int max=Integer.MIN_VALUE ;
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<3 ; i++){
      if(max<abc[i])max=abc[i];
      if(min>abc[i])min=abc[i];
    }
    System.out.println(min+" "+max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var abc : Sequence(int) ; abc := Integer.subrange(1,3)->collect(0) ;
    abc[0+1] := sc.getCurrent()->toInteger() ; 
    abc[1+1] := sc.getCurrent()->toInteger() ; 
    abc[2+1] := sc.getCurrent()->toInteger() ; 
    var max : int ; max := -2147483648 ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (max < abc[i+1]) then     max := abc[i+1] ; else skip ; 
     if (min > abc[i+1]) then     min := abc[i+1] ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min + " " + max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    System.out.println(min(a,b,c)+" "+max(a,b,c));
  }
  public static int max(int...ar){
    Arrays.sort(ar);
    return ar[ar.length-1];
  }
  public static int min(int...ar){
    Arrays.sort(ar);
    return ar[0];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(Set{a, b, c}->min() + " " + Set{a, b, c}->max()) );
  static   operation max( ar : Sequence(int)) : int
  pre: true
  post: true
  activity: (     ar := ar->sort() ; 
     return ar[ar->size() - 1+1] );
  static   operation min( ar : Sequence(int)) : int
  pre: true
  post: true
  activity: (     ar := ar->sort() ; 
     return ar[0+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    ArrayList<Integer>arrA=new ArrayList<Integer>();
    int max=0,min=0 ;
    Scanner scInputData=new Scanner(System.in);
    while(scInputData.hasNext()){
      arrA.add(scInputData.nextInt());
    }
    max=Math.max(arrA.get(0),arrA.get(1));
    max=Math.max(arrA.get(2),max);
    min=Math.min(arrA.get(0),arrA.get(1));
    min=Math.min(arrA.get(2),min);
    System.out.println(min+" "+max);
    scInputData.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arrA : Sequence(int) ; arrA := Sequence{} ;
     var max : int ; max := 0 ;
    var min : int ; min := 0 ;
    var scInputData : OclFile ; scInputData := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (scInputData.hasNext()) do (     arrA := arrA->including(scInputData.getCurrent()->toInteger()) ) ; 
    max := Set{arrA->at(0+1), arrA->at(1+1)}->max() ; 
    max := Set{arrA->at(2+1), max}->max() ; 
    min := Set{arrA->at(0+1), arrA->at(1+1)}->min() ; 
    min := Set{arrA->at(2+1), min}->min() ; 
    OclFile["System.out"].println(min + " " + max) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Collections ;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] line=br.readLine().split(" ",0);
    int min=Integer.MAX_VALUE,max=-Integer.MAX_VALUE,num=0 ;
    for(int i=0 ; i<3 ; i++){
      num=Integer.parseInt(line[i]);
      if(num<min){
        min=num ;
      }
      if(num>max){
        max=num ;
      }
    }
    System.out.println(min+" "+max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var min : int ; min := 2147483647 ;
    var max : int ; max := -2147483647 ;
    var num : int ; num := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     num := (line[i+1])->toInteger() ; 
     if (num < min) then (     min := num ) else skip ; 
     if (num > max) then (     max := num ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min + " " + max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Run {
  public static void main(String[] Z)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder op=new StringBuilder();
    StringTokenizer stz ;
    int T=Integer.parseInt(br.readLine());
    while(T-->0){
      int n=Integer.parseInt(br.readLine());
      stz=new StringTokenizer(br.readLine());
      int[] a=new int[4*n];
      for(int i=0 ; i<n<<2 ; i++){
        a[i]=Integer.parseInt(stz.nextToken());
      }
      boolean yes=true ;
      Arrays.sort(a);
      int area=a[0]*a[a.length-1];
      for(int i=0 ; i<n ; ++i){
        int lf=i*2,rg=4*n-(i*2)-1 ;
        if((a[lf]!=a[lf+1])||(a[rg]!=a[rg-1])||(a[lf]*a[rg]!=area)){
          yes=false ;
          break ;
        }
      }
      if(yes)op.append("YES\n");
      else op.append("NO\n");
    }
    System.out.println(op);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Run {
  static   operation main( Z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var op : String ; op := StringLib.newString() ;
    var stz : OclIterator ;
    var T : int ; T := (br.readLine())->toInteger() ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
     stz := OclIterator.newOclIterator_String(br.readLine()) ; 
    var a : Sequence(int) ; a := Integer.subrange(1,4 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < (n*(2->pow(2)))->oclAsType(long) do ( (     a[i+1] := (stz.next())->toInteger() )  ;     i := i + 1 ) ; 
    var yes : boolean ; yes := true ;
    a := a->sort() ; 
    var area : int ; area := a[0+1] * a[a->size() - 1+1] ;
        var i : int ; i := 0 ; while i < n do ( (     var lf : int ; lf := i * 2 ;
    var rg : int ; rg := 4 * n - (i * 2) - 1 ;
     if ((a[lf+1] /= a[lf + 1+1]) or (a[rg+1] /= a[rg - 1+1]) or (a[lf+1] * a[rg+1] /= area)) then (     yes := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (yes) then     op := op + StringLib.newString("YES\n") else     op := op + StringLib.newString("NO\n") ; ;  
 ) ;  ) ;  
    OclFile["System.out"].println(op) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static long max(long a,long b,long c){
    if(a>=b && a>=c)return a ;
    else if(b>=c)return b ;
    return c ;
  }
  public static long min(long a,long b,long c){
    if(a<=b && a<=c)return a ;
    else if(b<=c)return b ;
    return c ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a=sc.nextLong();
    long b=sc.nextLong();
    long c=sc.nextLong();
    System.out.println(min(a,b,c)+" "+max(a,b,c));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation max( a : long, b : long, c : long) : long
  pre: true
  post: true
  activity: (     if (a >= b & a >= c) then     return a else     if (b >= c) then     return b else skip ; ;  
     return c );
  static   operation min( a : long, b : long, c : long) : long
  pre: true
  post: true
  activity: (     if (a <= b & a <= c) then     return a else     if (b <= c) then     return b else skip ; ;  
     return c );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var c : long ; c := sc.getCurrent()->toLong() ;
    OclFile["System.out"].println(Set{a, b, c}->min() + " " + Set{a, b, c}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findS(int s){
    int sum=0 ;
    for(int n=1 ; sum<s ; n++){
      sum+=n ;
      if(sum==s)return n ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    int s=15 ;
    int n=findS(s);
    if(n==-1)System.out.println("-1");
    else System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findS( s : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var n : int ; n := 1 ; while sum < s do ( (     sum := sum+(n) ; 
     if (sum = s) then     return n else skip )  ;     n := n + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : int ; s := 15 ;
     var n : int ; n := findS(s) ;
     if (n = -1) then     OclFile["System.out"].println("-1") ; else     OclFile["System.out"].println(n) ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maximumAbsolute(int arr[],int n){
    int mn=Integer.MAX_VALUE ;
    int mx=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(i>0 && arr[i]==-1 && arr[i-1]!=-1){
        mn=Math.min(mn,arr[i-1]);
        mx=Math.max(mx,arr[i-1]);
      }
      if(i<n-1 && arr[i]==-1 && arr[i+1]!=-1){
        mn=Math.min(mn,arr[i+1]);
        mx=Math.max(mx,arr[i+1]);
      }
    }
    int common_integer=(mn+mx)/2 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==-1)arr[i]=common_integer ;
    }
    int max_diff=0 ;
    for(int i=0 ; i<n-1 ; i++){
      int diff=Math.abs(arr[i]-arr[i+1]);
      if(diff>max_diff)max_diff=diff ;
    }
    return max_diff ;
  }
  public static void main(String[] args){
    int arr[]={
-1,-1,11,-1,3,-1 };
      int n=arr.length ;
      System.out.print(maximumAbsolute(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maximumAbsolute( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var mn : int ; mn := 2147483647 ;
     var mx : int ; mx := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i > 0 & arr[i+1] = -1 & arr[i - 1+1] /= -1) then (     mn := Set{mn, arr[i - 1+1]}->min() ; 
     mx := Set{mx, arr[i - 1+1]}->max() ) else skip ; 
     if (i < n - 1 & arr[i+1] = -1 & arr[i + 1+1] /= -1) then (     mn := Set{mn, arr[i + 1+1]}->min() ; 
     mx := Set{mx, arr[i + 1+1]}->max() ) else skip )  ;     i := i + 1 ) ; 
    var common_integer : int ; common_integer := (mn + mx) / 2 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = -1) then     arr[i+1] := common_integer ; else skip )  ;     i := i + 1 ) ; 
    var max_diff : int ; max_diff := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var diff : int ; diff := if arr[i+1] - arr[i + 1+1] < 0 then -(arr[i+1] - arr[i + 1+1]) else arr[i+1] - arr[i + 1+1] endif ;
     if (diff > max_diff) then     max_diff := diff ; else skip )  ;     i := i + 1 ) ; 
    return max_diff 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-1,-1,11,-1,3,-1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(maximumAbsolute(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  final static int MOD=1000000007 ;
  static long countStrings(int N){
    int i,j ;
    int dp[][]=new int[N+1][3];
    for(i=0 ; i<N+1 ; i++){
      for(j=9 ; j<3 ; j++){
        dp[i][j]=0 ;
      }
    }
    dp[1][0]=1 ;
    dp[1][1]=1 ;
    dp[1][2]=0 ;
    for(i=2 ; i<=N ; i++){
      dp[i][0]=(dp[i-1][0]+dp[i-1][1]+dp[i-1][2])% MOD ;
      dp[i][1]=dp[i-1][0] % MOD ;
      dp[i][2]=dp[i-1][1] % MOD ;
    }
    int ans=(dp[N][0]+dp[N][1]+dp[N][2])% MOD ;
    return ans ;
  }
  public static void main(String[] args){
    int N=3 ;
    System.out.println(countStrings(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MOD : int := 1000000007;
  static   operation countStrings( N : int) : long
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,3)->collect(0)) ;
        i := 0 ; while i < N + 1 do ( (         j := 9 ; while j < 3 do ( (     dp[i+1][j+1] := 0 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    dp[1+1][0+1] := 1 ; 
    dp[1+1][1+1] := 1 ; 
    dp[1+1][2+1] := 0 ; 
        i := 2 ; while i <= N do ( (     dp[i+1][0+1] := (dp[i - 1+1][0+1] + dp[i - 1+1][1+1] + dp[i - 1+1][2+1]) mod MOD ; 
     dp[i+1][1+1] := dp[i - 1+1][0+1] mod MOD ; 
     dp[i+1][2+1] := dp[i - 1+1][1+1] mod MOD )  ;     i := i + 1 ) ; 
    var ans : int ; ans := (dp[N+1][0+1] + dp[N+1][1+1] + dp[N+1][2+1]) mod MOD ;
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
     OclFile["System.out"].println(countStrings(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void printDistSum(int arr[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=arr[i];
    boolean[][] dp=new boolean[n+1][sum+1];
    for(int i=0 ; i<=n ; i++)dp[i][0]=true ;
    for(int i=1 ; i<=n ; i++){
      dp[i][arr[i-1] ]=true ;
      for(int j=1 ; j<=sum ; j++){
        if(dp[i-1][j]==true){
          dp[i][j]=true ;
          dp[i][j+arr[i-1] ]=true ;
        }
      }
    }
    for(int j=0 ; j<=sum ; j++)if(dp[n][j]==true)System.out.print(j+" ");
  }
  public static void main(String[] args){
    int arr[]={
      2,3,4,5,6 };
      int n=arr.length ;
      printDistSum(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printDistSum( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(boolean)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,sum + 1)->collect(false)) ;
        var i : int ; i := 0 ; while i <= n do (     dp[i+1][0+1] := true ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     dp[i+1][arr[i - 1+1]+1] := true ; 
         var j : int ; j := 1 ; while j <= sum do ( (     if (dp[i - 1+1][j+1] = true) then (     dp[i+1][j+1] := true ; 
     dp[i+1][j + arr[i - 1+1]+1] := true ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j <= sum do (     if (dp[n+1][j+1] = true) then     OclFile["System.out"].print(j + " ") ; else skip ;  ;     j := j + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4,5,6} ;
     var n : int ; n := arr->size() ;
     execute printDistSum(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int longest_subseq(int n,int k,String s){
    int[] dp=new int[n];
    int[] max_length=new int[26];
    for(int i=0 ; i<n ; i++){
      int curr=s.charAt(i)-'a' ;
      int lower=Math.max(0,curr-k);
      int upper=Math.min(25,curr+k);
      for(int j=lower ; j<upper+1 ; j++){
        dp[i]=Math.max(dp[i],max_length[j]+1);
      }
      max_length[curr]=Math.max(dp[i],max_length[curr]);
    }
    int ans=0 ;
    for(int i : dp)ans=Math.max(i,ans);
    return ans ;
  }
  public static void main(String[] args){
    String s="geeksforgeeks" ;
    int n=s.length();
    int k=3 ;
    System.out.print(longest_subseq(n,k,s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation longest_subseq( n : int, k : int, s : String) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
     var max_length : Sequence(int) ; max_length := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var curr : int ; curr := s->at(i+1) - ('a')->char2byte() ;
     var lower : int ; lower := Set{0, curr - k}->max() ;
    var upper : int ; upper := Set{25, curr + k}->min() ;
        var j : int ; j := lower ; while j < upper + 1 do ( (     dp[i+1] := Set{dp[i+1], max_length[j+1] + 1}->max() )  ;     j := j + 1 ) ; 
    max_length[curr+1] := Set{dp[i+1], max_length[curr+1]}->max() ; 
 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (i : dp) do (     ans := Set{i, ans}->max() ;  ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     var n : int ; n := s->size() ;
     var k : int ; k := 3 ;
     OclFile["System.out"].print(longest_subseq(n, k, s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int longestFibonacciSubarray(int n,int a[]){
    if(n<=2)return n ;
    int len=2 ;
    int mx=Integer.MIN_VALUE ;
    for(int i=2 ; i<n ; i++){
      if(a[i]==a[i-1]+a[i-2])len++;
      else len=2 ;
      mx=Math.max(mx,len);
    }
    return mx ;
  }
  public static void main(String[] args){
    int n=5 ;
    int a[]={
      2,4,6,10,2 };
      System.out.println(longestFibonacciSubarray(n,a));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation longestFibonacciSubarray( n : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (n <= 2) then     return n else skip ; 
     var len : int ; len := 2 ;
    var mx : int ; mx := -2147483648 ;
        var i : int ; i := 2 ; while i < n do ( (     if (a[i+1] = a[i - 1+1] + a[i - 2+1]) then     len := len + 1 else     len := 2 ; ;  
     mx := Set{mx, len}->max() )  ;     i := i + 1 ) ; 
    return mx 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var a : Sequence(int) ; a := Sequence{2,4,6,10,2} ;
     OclFile["System.out"].println(longestFibonacciSubarray(n, a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minimumSubarrays(int ar[],int n){
    Vector se=new Vector();
    int cnt=1 ;
    for(int i=0 ; i<n ; i++){
      if(se.contains(ar[i])==false){
        se.add(ar[i]);
      }
      else {
        cnt++;
        se.clear();
        se.add(ar[i]);
      }
    }
    return cnt ;
  }
  public static void main(String[] args){
    int ar[]={
      1,2,1,3,4,2,4,4,4 };
      int n=ar.length ;
      System.out.println(minimumSubarrays(ar,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumSubarrays( ar : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var se : Sequence ; se := Sequence{} ;
     var cnt : int ; cnt := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (se->includes(ar[i+1]) = false) then (     se := se->including(ar[i+1]) ) else (     cnt := cnt + 1 ; 
     se := se->intersection(Set{}) ; 
     se := se->including(ar[i+1]) ) )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ar : Sequence(int) ; ar := Sequence{1,2,1,3,4,2,4,4,4} ;
     var n : int ; n := ar->size() ;
     OclFile["System.out"].println(minimumSubarrays(ar, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean check(int s){
    int[] freq=new int[10];
    int r,i ;
    for(i=0 ; i<10 ; i++){
      freq[i]=0 ;
    }
    while(s!=0){
      r=s % 10 ;
      s=(int)(s/10);
      freq[r]+=1 ;
    }
    int xor__=0 ;
    for(i=0 ; i<10 ; i++){
      xor__=xor__ ^ freq[i];
      if(xor__==0)return true ;
      else return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    int s=122233 ;
    if(check(s))System.out.println("Yes\n");
    else System.out.println("No\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation check( s : int) : boolean
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,10)->collect(0) ;
     var r : int ;
    var i : int ;
        i := 0 ; while i < 10 do ( (     freq[i+1] := 0 )  ;     i := i + 1 ) ; 
    while (s /= 0) do (     r := s mod 10 ; 
     s := (s / 10)->oclAsType(int) ; 
     freq[r+1] := freq[r+1]+(1) ) ; 
    var xor__ : int ; xor__ := 0 ;
        i := 0 ; while i < 10 do ( (     xor__ := MathLib.bitwiseXor(xor__,freq[i+1]) ; 
     if (xor__ = 0) then     return true else     return false )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : int ; s := 122233 ;
     if (check(s)) then     OclFile["System.out"].println("Yes\n") ; else     OclFile["System.out"].println("No\n") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.nio.charset.MalformedInputException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int g=m ;
    int f=0 ;
    int sum=0 ;
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      sum+=arr[i];
      if(m<=sum){
        f+=sum/m ;
        sum %=m ;
      }
      out.print(f+" ");
      f-=f ;
    }
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var g : int ; g := m ;
    var f : int ; f := 0 ;
    var sum : int ; sum := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(arr[i+1]) ; 
     if (m <= sum) then (     f := f+(sum / m) ; 
     sum := sum mod m ) else skip ; 
     skip ; 
     f := f-(f) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class ProblemA {
  static HashSet<Character>set[];
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int test=Integer.parseInt(br.readLine());
    while(test-->0){
      int n=Integer.parseInt(br.readLine());
      String line[]=br.readLine().split(" ");
      int arr[]=new int[4*n];
      for(int i=0 ; i<4*n ; i++)arr[i]=Integer.parseInt(line[i]);
      Arrays.sort(arr);
      HashSet<Integer>set=new HashSet<>();
      int size=(4*n)/2 ;
      for(int i=0 ; i<size ; i+=2){
        if(i+1<size && arr[i]!=arr[i+1])set.add(-1);
        if((4*n)-i-2>=size && arr[(4*n)-i-1]!=arr[(4*n)-i-2])set.add(-2);
        set.add(arr[i]*arr[(4*n)-i-1]);
      }
      String ans="NO" ;
      if(set.size()==1)ans="YES" ;
      sb.append(ans);
      sb.append("\n");
    }
    System.out.println(sb);
  }
}
class Pair {
  int x,y ;
  public Pair(int x,int y){
    this.x=x ;
    this.y=y ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
  static   attribute set : Sequence(Set(String));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var test : int ; test := (br.readLine())->toInteger() ;
        while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,4 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 * n do (     arr[i+1] := (line[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var set : Set(int) ; set := Set{} ;
    var size : int ; size := (4 * n) / 2 ;
        var i : int ; i := 0 ; while i < size do ( (     if (i + 1 < size & arr[i+1] /= arr[i + 1+1]) then     set := set->including(-1) ; else skip ; 
     if ((4 * n) - i - 2 >= size & arr[(4 * n) - i - 1+1] /= arr[(4 * n) - i - 2+1]) then     set := set->including(-2) ; else skip ; 
     set := set->including(arr[i+1] * arr[(4 * n) - i - 1+1]) )  ;     i := i+(2) ) ; 
    var ans : String ; ans := "NO" ;
    if (set->size() = 1) then     ans := "YES" ; else skip ; 
    sb := sb + StringLib.newString(ans) ; 
    sb := sb + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
}
class Pair {
   attribute x : int;
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public final class DeathNote {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int limit,pagesToTurn,left=0 ;
    while(n-->0){
      limit=sc.nextInt();
      pagesToTurn=(limit+left)/m ;
      left=(limit+left)% m ;
      System.out.print(pagesToTurn+" ");
    }
    System.out.println();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class DeathNote {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var limit : int ;
    var pagesToTurn : int ;
    var left : int ; left := 0 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     limit := sc.getCurrent()->toInteger() ; 
     pagesToTurn := (limit + left) / m ; 
     left := (limit + left) mod m ; 
     OclFile["System.out"].print(pagesToTurn + " ") ) ;  ) ;  
    OclFile["System.out"].println() ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cses {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int carry=0 ;
    ArrayList<Integer>a=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      int temp=sc.nextInt();
      temp+=carry ;
      carry=temp % m ;
      a.add(temp/m);
    }
    for(int i : a){
      System.out.print(i+" ");
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class cses {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var carry : int ; carry := 0 ;
    var a : Sequence(int) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : int ; temp := sc.getCurrent()->toInteger() ;
     temp := temp+(carry) ; 
     carry := temp mod m ; 
     a := a->including(temp / m) )  ;     i := i + 1 ) ; 
    for (i : a) do ( (     OclFile["System.out"].print(i + " ") )  ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    int turns=0 ;
    int[] out=new int[n];
    int outputTurns=0 ;
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=a[i];
      out[i]=sum/m ;
      sum=sum % m ;
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(out[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var turns : int ; turns := 0 ;
    var out : Sequence(int) ; out := Integer.subrange(1,n)->collect(0) ;
    var outputTurns : int ; outputTurns := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(a[i+1]) ; 
     out[i+1] := sum / m ; 
     sum := sum mod m )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(out[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class A1016_900_DeathNote_greedy_implementation_math_Round48 {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      sum+=a ;
      System.out.print(sum/m+" ");
      sum=sum % m ;
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1016_900_DeathNote_greedy_implementation_math_Round48 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     sum := sum+(a) ; 
     OclFile["System.out"].print(sum / m + " ") ; 
     sum := sum mod m )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAXN=1000005 ;
  static int even[]=new int[MAXN];
  static int odd[]=new int[MAXN];
  static void precompute(int arr[],int n){
    for(int i=0 ; i<n ; i++){
      if(arr[i] % 2==1)odd[i]=1 ;
      if(arr[i] % 2==0)even[i]=1 ;
    }
    for(int i=1 ; i<n ; i++){
      even[i]=even[i]+even[i-1];
      odd[i]=odd[i]+odd[i-1];
    }
  }
  static boolean isOdd(int L,int R){
    int cnt=odd[R];
    if(L>0)cnt-=odd[L-1];
    if(cnt==R-L+1)return true ;
    return false ;
  }
  static void performQueries(int a[],int n,int q[][],int m){
    precompute(a,n);
    for(int i=0 ; i<m ; i++){
      int L=q[i][0],R=q[i][1];
      if(isOdd(L,R))System.out.println("Odd");
      else System.out.println("Even");
    }
  }
  public static void main(String args[]){
    int[] a={
      2,1,5,7,6,8,9 };
      int n=a.length ;
      int q[][]={
        {
          0,2 },{
            1,2 },{
              2,3 },{
                3,6 }
              };
              int m=q.length ;
              performQueries(a,n,q,m);
            }
          }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAXN : int := 1000005;
  static   attribute even : int := Integer.subrange(1,MAXN)->collect(0);
  static   attribute odd : int := Integer.subrange(1,MAXN)->collect(0);
  static   operation precompute( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 = 1) then     odd[i+1] := 1 ; else skip ; 
     if (arr[i+1] mod 2 = 0) then     even[i+1] := 1 ; else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i < n do ( (     even[i+1] := even[i+1] + even[i - 1+1] ; 
     odd[i+1] := odd[i+1] + odd[i - 1+1] )  ;     i := i + 1 ) );
  static   operation isOdd( L : int, R : int) : boolean
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := odd[R+1] ;
     if (L > 0) then     cnt := cnt-(odd[L - 1+1]) ; else skip ; 
     if (cnt = R - L + 1) then     return true else skip ; 
     return false );
  static   operation performQueries( a : Sequence(int), n : int, q : Sequence(Sequence(int)), m : int) : void
  pre: true
  post: true
  activity: (     execute precompute(a, n) ; 
         var i : int ; i := 0 ; while i < m do ( (     var L : int ; L := q[i+1][0+1] ;
    var R : int ; R := q[i+1][1+1] ;
     if (isOdd(L, R)) then     OclFile["System.out"].println("Odd") ; else     OclFile["System.out"].println("Even") ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,1,5,7,6,8,9} ;
     var n : int ; n := a->size() ;
    var q : Sequence(Sequence(int)) ; q := Sequence{Sequence{0,2},Sequence{1,2},Sequence{2,3},Sequence{3,6}} ;
    var m : int ; m := q->size() ;
    execute performQueries(a, n, q, m) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int Subtract(int a,int b){
    int c ;
    c=a+(~ b+1);
    return c ;
  }
  public static void main(String[] args){
    int a=2,b=3 ;
    System.out.println(Subtract(a,b));
    a=9 ;
    b=7 ;
    System.out.println(Subtract(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Subtract( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var c : int ;
     c := a + (-(b + 1) + 1) ; 
     return c );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2 ;
    var b : int ; b := 3 ;
     OclFile["System.out"].println(Subtract(a, b)) ; 
    a := 9 ; 
    b := 7 ; 
    OclFile["System.out"].println(Subtract(a, b)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class pre422 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    String s[]=new String[1000];
    for(int n=1 ; n<=1000 ; n++){
      boolean flag=true ;
      for(int i=0 ; i<=1000 ; i++){
        for(int j=0 ; j<=1000 ; j++){
          if((n-i*3-j*5)% 7==0 &&(n-i*3-j*5)/7>=0){
            s[n-1]=(i+" "+j+" "+(n-i*3-j*5)/7);
            flag=false ;
            break ;
          }
        }
        if(! flag)break ;
      }
      if(flag)s[n-1]="-1" ;
    }
    int tc=obj.nextInt();
    while(tc--!=0){
      int n=obj.nextInt();
      System.out.println(s[n-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre422 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var s : Sequence(String) ; s := Integer.subrange(1,1000)->collect(null) ;
        var n : int ; n := 1 ; while n <= 1000 do ( (     var flag : boolean ; flag := true ;
         var i : int ; i := 0 ; while i <= 1000 do ( (         var j : int ; j := 0 ; while j <= 1000 do ( (     if (((n)->char2byte() - i * 3 - j * 5) mod 7 = 0 & ((n)->char2byte() - i * 3 - j * 5) / 7 >= 0) then (     s[(n)->char2byte() - 1+1] := (i + " " + j + " " + ((n)->char2byte() - i * 3 - j * 5) / 7) ; 
     flag := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (not(flag)) then     break else skip )  ;     i := i + 1 ) ; 
     if (flag) then     s[(n)->char2byte() - 1+1] := "-1" ; else skip )  ;     n := n + 1 ) ; 
    var tc : int ; tc := obj.nextInt() ;
        while (tc /= 0) do (    skip ; (     var n : int ; n := obj.nextInt() ;
     OclFile["System.out"].println(s[(n)->char2byte() - 1+1]) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class m {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int window=sc.nextInt();
      int th=0,f=0,s=0 ;
      if(window % 3==0){
        th=window/3 ;
        System.out.print(th+" "+f+" "+s+"\n");
      }
      else if(window % 3==2 && window>=5){
        th=window/3-1 ;
        f=1 ;
        System.out.print(th+" "+f+" "+s+"\n");
      }
      else if(window % 3==1 && window>=7){
        th=window/3-2 ;
        s=1 ;
        System.out.print(th+" "+f+" "+s+"\n");
      }
      else System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class m {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var window : int ; window := sc.getCurrent()->toInteger() ;
     var th : int ; th := 0 ;
    var f : int ; f := 0 ;
    var s : int ; s := 0 ;
     if (window mod 3 = 0) then (     th := window / 3 ; 
     OclFile["System.out"].print(th + " " + f + " " + s + "\n") ) else     if (window mod 3 = 2 & window >= 5) then (     th := window / 3 - 1 ; 
     f := 1 ; 
     OclFile["System.out"].print(th + " " + f + " " + s + "\n") ) else     if (window mod 3 = 1 & window >= 7) then (     th := window / 3 - 2 ; 
     s := 1 ; 
     OclFile["System.out"].print(th + " " + f + " " + s + "\n") ) else     OclFile["System.out"].println(-1) ; ;  ;  )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      System.out.println(solve(n));
    }
    sc.close();
  }
  static String solve(int n){
    for(int k=0 ; k*7<=n ; ++k){
      for(int j=0 ; k*7+j*5<=n ; ++j){
        if((n-k*7-j*5)% 3==0){
          return String.format("%d %d %d",(n-k*7-j*5)/3,j,k);
        }
      }
    }
    return "-1" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(n)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( n : int) : String
  pre: true
  post: true
  activity: (         var k : int ; k := 0 ; while k * 7 <= n do ( (         var j : int ; j := 0 ; while k * 7 + j * 5 <= n do ( (     if ((n - k * 7 - j * 5) mod 3 = 0) then (     return StringLib.format("%d %d %d",Sequence{(n - k * 7 - j * 5) / 3,j,k}) ) else skip )  ;     j := j + 1 ) )  ;     k := k + 1 ) ; 
     return "-1" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        int n=sc.nextInt();
        for(int target=2 ; true ; target++){
          if(gcd(n-1-target,target)!=1)continue ;
          System.out.println(n-1-target+" "+target+" "+1);
          if(n-1-target<=1)throw null ;
          break ;
        }
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var target : int ; target := 2 ; while true do ( (     if (gcd(n - 1 - target, target) /= 1) then     continue else skip ; 
     OclFile["System.out"].println(n - 1 - target + " " + target + " " + 1) ; 
     if (n - 1 - target <= 1) then     error null ; else skip ; 
     break )  ;     target := target + 1 ) ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] ar=new int[10002];
      ArrayList<Integer>al=new ArrayList<>();
      for(int i=0 ; i<n*4 ; i++){
        int a=sc.nextInt();
        ar[a]++;
      }
      for(int i=0 ; i<ar.length ; i++){
        int v=ar[i]/2 ;
        for(int j=0 ; j<v ; j++){
          al.add(i);
        }
      }
      boolean ok=true ;
      for(int i=0 ; i<ar.length ; i++){
        if(ar[i] % 2==1)ok=false ;
      }
      if(ok){
        int m=al.size()-1 ;
        int area=al.get(0)*al.get(m);
        int l=1 ;
        int en=m-1 ;
        while(l<m){
          if(al.get(l)*al.get(en)!=area){
            ok=false ;
            break ;
          }
          else {
            l++;
            en--;
          }
        }
      }
      System.out.println(ok ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ar : Sequence(int) ; ar := Integer.subrange(1,10002)->collect(0) ;
    var al : Sequence(int) ; al := Sequence{} ;
        var i : int ; i := 0 ; while i < n * 4 do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     ar[a+1] := ar[a+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < ar->size() do ( (     var v : int ; v := ar[i+1] / 2 ;
         var j : int ; j := 0 ; while j < v do ( (     al := al->including(i) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ok : boolean ; ok := true ;
        var i : int ; i := 0 ; while i < ar->size() do ( (     if (ar[i+1] mod 2 = 1) then     ok := false ; else skip )  ;     i := i + 1 ) ; 
    if (ok) then (     var m : int ; m := al->size() - 1 ;
     var area : int ; area := al->at(0+1) * al->at(m+1) ;
    var l : int ; l := 1 ;
    var en : int ; en := m - 1 ;
    while (l < m) do (     if (al->at(l+1) * al->at(en+1) /= area) then (     ok := false ; 
     break ) else (     l := l + 1 ; 
     en := en - 1 ) ) ; 
 ) else skip ; 
    OclFile["System.out"].println(if ok then "YES" else "NO" endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Gcd {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int N=Integer.parseInt(br.readLine());
    for(int i=0 ; i<N ; i++){
      int number=Integer.parseInt(br.readLine());
      for(int j=2 ; j<number-1 ; j++){
        if(gcd(j,number-1-j)!=1){
          continue ;
        }
        System.out.println(j+" "+(number-j-1)+" "+1);
        break ;
      }
    }
  }
  public static int gcd(int a,int b){
    if(a==0){
      return b ;
    }
    if(b==0){
      return a ;
    }
    if(b>a){
      return gcd(b % a,a);
    }
    if(b<a){
      return gcd(a % b,b);
    }
    else {
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Gcd {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var N : int ; N := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < N do ( (     var number : int ; number := (br.readLine())->toInteger() ;
         var j : int ; j := 2 ; while j < number - 1 do ( (     if (gcd(j, number - 1 - j) /= 1) then (     continue ) else skip ; 
     OclFile["System.out"].println(j + " " + (number - j - 1) + " " + 1) ; 
     break )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then (     return b ) else skip ; 
     if (b = 0) then (     return a ) else skip ; 
     if (b > a) then (     return gcd(b mod a, a) ) else skip ; 
     if (b < a) then (     return gcd(a mod b, b) ) else (     return a ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class contest {
  public static void main(String[] arguments){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int in=0 ; in<t ; in++){
      int n=sc.nextInt();
      int a=0,b=0,c=1 ;
      if(n % 2==0){
        a=(n-2)/2 ;
        b=a+1 ;
      }
      else {
        int x=(n-1)/2 ;
        if(x % 2==0)x++;
        else if(2*x==n-1){
          x+=2 ;
        }
        a=x ;
        b=n-a-c ;
      }
      System.out.println(a+" "+b+" "+c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class contest {
  static   operation main( arguments : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var in : int ; in := 0 ; while in < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : int ; a := 0 ;
    var b : int ; b := 0 ;
    var c : int ; c := 1 ;
     if (n mod 2 = 0) then (     a := (n - 2) / 2 ; 
     b := a + 1 ) else (     var x : int ; x := (n - 1) / 2 ;
     if (x mod 2 = 0) then     x := x + 1 else     if (2 * x = n - 1) then (     x := x+(2) ) else skip ; ;  
     a := x ; 
     b := n - a - c ) ;  
     OclFile["System.out"].println(a + " " + b + " " + c) )  ;     in := in + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int K=in.nextInt();
    String S=in.next();
    if(S.length()<=K){
      System.out.println(S);
    }
    else {
      System.out.println(S.substring(0,K)+"...");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var K : int ; K := in.getCurrent()->toInteger() ;
     var S : String ; S := in.getCurrent() ;
     if (S->size() <= K) then (     OclFile["System.out"].println(S) ) else (     OclFile["System.out"].println(S.subrange(0+1,K) + "...") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import java.lang.Math ;
import java.util.Map ;
import java.util.ArrayList ;
import java.util.Collections ;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    int len=fs.nextInt();
    String s=fs.next();
    if(s.length()>len){
      for(int i=0 ; i<len ; i++){
        System.out.print(s.charAt(i));
      }
      System.out.print("...");
    }
    else {
      System.out.println(s);
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var len : int ; len := fs.nextInt() ;
     var s : String ; s := fs.next() ;
     if (s->size() > len) then (         var i : int ; i := 0 ; while i < len do ( (     OclFile["System.out"].print(s->at(i+1)) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("...") ) else (     OclFile["System.out"].println(s) ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    String result="bon" ;
    int i=n % 10 ;
    if(s.length()<=n){
      result=s ;
    }
    else {
      result=s.substring(0,n);
      result+="..." ;
    }
    System.out.println(result);
  }
  public static class Scanner {
    private BufferedReader br ;
    private StringTokenizer tok ;
    public Scanner(InputStream is)throws IOException {
      br=new BufferedReader(new InputStreamReader(is));
    }
    private void getLine()throws IOException {
      while(! hasNext())tok=new StringTokenizer(br.readLine());
    }
    private boolean hasNext(){
      return tok!=null && tok.hasMoreTokens();
    }
    public String next()throws IOException {
      getLine();
      return tok.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var result : String ; result := "bon" ;
    var i : int ; i := n mod 10 ;
    if (s->size() <= n) then (     result := s ) else (     result := s.subrange(0+1,n) ; 
     result := result+("...") ) ;  
    OclFile["System.out"].println(result) ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute tok : OclIterator;
   static operation newScanner( is : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
   operation getLine() : void
  pre: true
  post: true
  activity: (     while (not(hasNext())) do     tok := OclIterator.newOclIterator_String(br.readLine()) ; );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return tok /= null & tok.hasNext() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute getLine() ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int K=Integer.parseInt(reader.readLine());
    String S=reader.readLine();
    int len=S.length();
    if(len<=K){
      System.out.println(S);
    }
    else {
      String h="" ;
      for(int i=0 ; i<K ; i++){
        h+=S.charAt(i);
      }
      h+="..." ;
      System.out.println(h);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var K : int ; K := (reader.readLine())->toInteger() ;
    var S : String ; S := reader.readLine() ;
    var len : int ; len := S->size() ;
    if (len <= K) then (     OclFile["System.out"].println(S) ) else (     var h : String ; h := "" ;
         var i : int ; i := 0 ; while i < K do ( (     h := h+(S->at(i+1)) )  ;     i := i + 1 ) ; 
     h := h+("...") ; 
     OclFile["System.out"].println(h) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class InfiniteSequence {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    long n1=Long.parseLong(br.readLine());
    long n=(long)((Math.sqrt(1+(8*n1))-1)/2);
    long ans=n1-(((n+1)*n)/2);
    System.out.print((ans!=0)? ans : n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class InfiniteSequence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n1 : long ; n1 := (br.readLine())->toLong() ;
    var n : long ; n := (((1 + (8 * n1))->sqrt() - 1) / 2)->oclAsType(long) ;
    var ans : long ; ans := n1 - (((n + 1) * n) / 2) ;
    OclFile["System.out"].print(if (ans /= 0) then ans else n endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int num=in.nextInt();
    String string=in.next();
    StringBuilder mBuilder=new StringBuilder();
    if(string.length()>num){
      mBuilder.append(string.substring(0,num)).append("...");
      System.out.println(mBuilder.toString());
    }
    else {
      System.out.println(string);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := in.getCurrent()->toInteger() ;
    var string : String ; string := in.getCurrent() ;
    var mBuilder : String ; mBuilder := StringLib.newString() ;
    if (string->size() > num) then (     mBuilder := mBuilder + StringLib.newString(string.subrange(0+1,num)) + StringLib.newString("...") ; 
     OclFile["System.out"].println(mBuilder+"") ) else (     OclFile["System.out"].println(string) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MinDeletion(int a[],int n){
    Map<Integer,Integer>mp=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(mp.containsKey(a[i])){
        mp.put(a[i],mp.get(a[i])+1);
      }
      else {
        mp.put(a[i],1);
      }
    }
    int ans=0 ;
    for(Map.Entry<Integer,Integer>i : mp.entrySet()){
      int x=i.getKey();
      int frequency=i.getValue();
      if(x<=frequency){
        ans+=(frequency-x);
      }
      else ans+=frequency ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int a[]={
      2,3,2,3,4,4,4,4,5 };
      int n=a.length ;
      System.out.println(MinDeletion(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MinDeletion( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (mp->keys()->includes(a[i+1])) then (     mp := mp->union(Map{a[i+1] |-> mp->at(a[i+1]) + 1}) ) else (     mp := mp->union(Map{a[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (i : mp->asSet()) do ( (     var x : int ; x := i.getKey() ;
     var frequency : int ; frequency := i.getValue() ;
     if (x <= frequency) then (     ans := ans+((frequency - x)) ) else     ans := ans+(frequency) ; )  ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,3,2,3,4,4,4,4,5} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(MinDeletion(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String args[])throws Exception {
    BufferedReader stdR=new BufferedReader(new InputStreamReader(System.in));
    String[] str=stdR.readLine().split(" ");
    int A=Integer.parseInt(str[0]);
    int B=Integer.parseInt(str[1]);
    int T=Integer.parseInt(str[2]);
    System.out.println(T/A*B);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdR : OclFile ; stdR := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := stdR.readLine()->split(" ") ;
    var A : int ; A := (str[0+1])->toInteger() ;
    var B : int ; B := (str[1+1])->toInteger() ;
    var T : int ; T := (str[2+1])->toInteger() ;
    OclFile["System.out"].println(T / A * B) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(InputReader in=new InputReader();
    PrintWriter out=new PrintWriter(System.out)){
      new Main().solve(in,out);
      out.flush();
    }
  }
  private void solve(InputReader in,PrintWriter out){
    int a=in.nextInt();
    int b=in.nextInt();
    int t=in.nextInt();
    out.println(t/a*b);
  }
}
class InputReader implements AutoCloseable {
  private final Scanner sc=new Scanner(System.in);
  String next(){
    return this.sc.next();
  }
  int nextInt(){
    return Integer.parseInt(this.sc.next());
  }
  long nextLong(){
    return Long.parseLong(this.sc.next());
  }
  double nextDouble(){
    return Double.parseDouble(this.sc.next());
  }
  @ Override public void close(){
    this.sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : InputReader := InputReader.newInputReader() ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]) ;
 (     Main.newMain().solve(in, out) ; 
     skip ))  );
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.nextInt() ;
     var b : int ; b := in.nextInt() ;
     var t : int ; t := in.nextInt() ;
     skip );
}
class InputReader implements AutoCloseable {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation next() : String
  pre: true
  post: true
  activity: (     return self.sc.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (self.sc.next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (self.sc.next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (self.sc.next())->toReal() );
      operation close() : void
  pre: true
  post: true
  activity: (     self.sc.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int sec=sc.nextInt();
    int per_num=sc.nextInt();
    double max_sec=(double)sc.nextInt()+0.5 ;
    int ans_num=0 ;
    for(int i=sec ; i<max_sec ; i+=sec){
      ans_num+=per_num ;
    }
    System.out.println(ans_num);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sec : int ; sec := sc.getCurrent()->toInteger() ;
    var per_num : int ; per_num := sc.getCurrent()->toInteger() ;
    var max_sec : double ; max_sec := sc.getCurrent()->toInteger()->oclAsType(double) + 0.5 ;
    var ans_num : int ; ans_num := 0 ;
        var i : int ; i := sec ; while i < max_sec do ( (     ans_num := ans_num+(per_num) )  ;     i := i+(sec) ) ; 
    OclFile["System.out"].println(ans_num) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int t=sc.nextInt();
    System.out.println(t/a*b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(t / a * b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class BusesBetweenCities {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    StringTokenizer st=new StringTokenizer(br.readLine());
    int a=Integer.parseInt(st.nextToken());
    int tA=Integer.parseInt(st.nextToken());
    st=new StringTokenizer(br.readLine());
    int b=Integer.parseInt(st.nextToken());
    int tB=Integer.parseInt(st.nextToken());
    String timing=br.readLine();
    int hrs=Integer.parseInt(timing.substring(0,2));
    int mins=Integer.parseInt(timing.substring(3));
    int simDeparture=hrs*60+mins ;
    int simArrival=simDeparture+tA ;
    int counter=0 ;
    for(int i=300 ; i<1440 ; i+=b){
      int busDeparture=i ;
      int busArrival=i+tB ;
      if(busDeparture>=simArrival || simDeparture>=busArrival)continue ;
      counter++;
    }
    pw.println(counter);
    pw.flush();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class BusesBetweenCities {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var a : int ; a := (st.next())->toInteger() ;
    var tA : int ; tA := (st.next())->toInteger() ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    var b : int ; b := (st.next())->toInteger() ;
    var tB : int ; tB := (st.next())->toInteger() ;
    var timing : String ; timing := br.readLine() ;
    var hrs : int ; hrs := (timing.subrange(0+1,2))->toInteger() ;
    var mins : int ; mins := (timing.subrange(3+1,3))->toInteger() ;
    var simDeparture : int ; simDeparture := hrs * 60 + mins ;
    var simArrival : int ; simArrival := simDeparture + tA ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 300 ; while i < 1440 do ( (     var busDeparture : int ; busDeparture := i ;
     var busArrival : int ; busArrival := i + tB ;
     if (busDeparture >= simArrival or simDeparture >= busArrival) then     continue else skip ; 
     counter := counter + 1 )  ;     i := i+(b) ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int out=3 ;
    boolean good=true ;
    ArrayList<Integer>playing=new ArrayList<Integer>();
    playing.add(1);
    playing.add(2);
    for(int i=0 ; i<n ; i++){
      int win=input.nextInt();
      if(win==out){
        good=false ;
        break ;
      }
      else {
        int replace=0 ;
        for(int j=1 ; j<=3 ; j++){
          if(win!=j && out!=j){
            replace=j ;
            break ;
          }
        }
        int index=0 ;
        for(int j=0 ; j<playing.size(); j++){
          if(playing.get(j)==replace){
            index=j ;
            break ;
          }
        }
        playing.remove(index);
        playing.add(out);
        out=replace ;
      }
    }
    if(good){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var out : int ; out := 3 ;
    var good : boolean ; good := true ;
    var playing : Sequence(int) ; playing := Sequence{} ;
    playing := playing->including(1) ; 
    playing := playing->including(2) ; 
        var i : int ; i := 0 ; while i < n do ( (     var win : int ; win := input.getCurrent()->toInteger() ;
     if (win = out) then (     good := false ; 
     break ) else (     var replace : int ; replace := 0 ;
         var j : int ; j := 1 ; while j <= 3 do ( (     if (win /= j & out /= j) then (     replace := j ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    var index : int ; index := 0 ;
        var j : int ; j := 0 ; while j < playing->size() do ( (     if (playing->at(j+1) = replace) then (     index := j ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    playing := playing->excludingAt(index+1) ; 
    playing := playing->including(out) ; 
    out := replace ; 
 ) )  ;     i := i + 1 ) ; 
    if (good) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Demo8 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int g=sc.nextInt();
    int[] arr=new int[g];
    int ax=sc.nextInt();
    if(ax==1){
      arr[0]=2 ;
    }
    else {
      arr[0]=1 ;
    }
    if(ax==3){
      System.out.println("NO");
    }
    else {
      for(int i=1 ; i<g ; i++){
        int x=sc.nextInt();
        if(x==arr[i-1]){
          System.out.println("NO");
          break ;
        }
        arr[i]=6-(x+arr[i-1]);
      }
      if(arr[g-1]!=0){
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Demo8 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var g : int ; g := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,g)->collect(0) ;
    var ax : int ; ax := sc.getCurrent()->toInteger() ;
    if (ax = 1) then (     arr[0+1] := 2 ) else (     arr[0+1] := 1 ) ;  
    if (ax = 3) then (     OclFile["System.out"].println("NO") ) else (         var i : int ; i := 1 ; while i < g do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x = arr[i - 1+1]) then (     OclFile["System.out"].println("NO") ; 
     break ) else skip ; 
     arr[i+1] := 6 - (x + arr[i - 1+1]) )  ;     i := i + 1 ) ; 
     if (arr[g - 1+1] /= 0) then (     OclFile["System.out"].println("YES") ) else skip ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Demo8 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int g=sc.nextInt();
    int[] arr=new int[g];
    int ax=sc.nextInt();
    if(ax==1){
      arr[0]=2 ;
    }
    else {
      arr[0]=1 ;
    }
    if(ax==3){
      System.out.println("NO");
    }
    else {
      for(int i=1 ; i<g ; i++){
        int x=sc.nextInt();
        if(x==arr[i-1]){
          System.out.println("NO");
          break ;
        }
        int sum=x+arr[i-1];
        arr[i]=6-sum ;
      }
      if(arr[g-1]!=0){
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Demo8 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var g : int ; g := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,g)->collect(0) ;
    var ax : int ; ax := sc.getCurrent()->toInteger() ;
    if (ax = 1) then (     arr[0+1] := 2 ) else (     arr[0+1] := 1 ) ;  
    if (ax = 3) then (     OclFile["System.out"].println("NO") ) else (         var i : int ; i := 1 ; while i < g do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x = arr[i - 1+1]) then (     OclFile["System.out"].println("NO") ; 
     break ) else skip ; 
     var sum : int ; sum := x + arr[i - 1+1] ;
     arr[i+1] := 6 - sum )  ;     i := i + 1 ) ; 
     if (arr[g - 1+1] /= 0) then (     OclFile["System.out"].println("YES") ) else skip ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CodeForces {
  public static final int BUFFERSIZE=512000 ;
  private static Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in),BUFFERSIZE));
  private static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out,BUFFERSIZE));
  public static void solve(){
    long position=sc.nextLong();
    long nrstSeqStartIndx=1 ;
    while(getValueAtIndex(nrstSeqStartIndx*2)<position){
      nrstSeqStartIndx*=2 ;
    }
    while(getValueAtIndex(nrstSeqStartIndx+1)<=position)nrstSeqStartIndx++;
    long startIndex=getValueAtIndex(nrstSeqStartIndx);
    out.println((position-startIndex)+1);
    long aa=1 ;
    for(int i=1 ; i<100_000_000 ; i++){
      aa+=i ;
    }
  }
  public static long getValueAtIndex(long index){
    return 1+((index-1)*index/2);
  }
  public static void main(String args[])throws Exception {
    in.init(System.in);
    solve();
    out.close();
  }
  public static class in {
    static BufferedReader reader ;
    static StringTokenizer tokenizer ;
    static void init(InputStream input){
      reader=new BufferedReader(new InputStreamReader(input),BUFFERSIZE);
      tokenizer=new StringTokenizer("");
    }
    static String next()throws IOException {
      while(! tokenizer.hasMoreTokens())tokenizer=new StringTokenizer(reader.readLine());
      return tokenizer.nextToken();
    }
    static int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    static double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    static long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static    attribute BUFFERSIZE : int := 512000;
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), BUFFERSIZE));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"], BUFFERSIZE));
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var position : long ; position := sc.getCurrent()->toLong() ;
     var nrstSeqStartIndx : long ; nrstSeqStartIndx := 1 ;
    while (getValueAtIndex(nrstSeqStartIndx * 2) < position) do (     nrstSeqStartIndx := nrstSeqStartIndx*(2) ) ; 
    while (getValueAtIndex(nrstSeqStartIndx + 1) <= position) do     nrstSeqStartIndx := nrstSeqStartIndx + 1 ; ; 
    var startIndex : long ; startIndex := getValueAtIndex(nrstSeqStartIndx) ;
    skip ; 
    var aa : long ; aa := 1 ;
        var i : int ; i := 1 ; while i < 100_000_000 do ( (     aa := aa+(i) )  ;     i := i + 1 ) ; 
 );
  static   operation getValueAtIndex( index : long) : long
  pre: true
  post: true
  activity: (     return 1 + ((index - 1) * index / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in.init(OclFile["System.in"]) ; 
     execute solve() ; 
     skip );
  static class in {
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   operation init( input : OclFile) : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(input), BUFFERSIZE) ; 
     tokenizer := OclIterator.newOclIterator_String("") );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ; ; 
     return tokenizer.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Demo8 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int g=sc.nextInt();
    int[] arr=new int[g];
    int ax=sc.nextInt();
    if(ax==1){
      arr[0]=2 ;
    }
    else {
      arr[0]=1 ;
    }
    if(ax==3){
      System.out.println("NO");
    }
    else {
      for(int i=1 ; i<g ; i++){
        int x=sc.nextInt();
        if(x==arr[i-1]){
          System.out.println("NO");
          break ;
        }
        for(int i2=1 ; i2<4 ; i2++){
          if(i2!=x && i2!=arr[i-1]){
            arr[i]=i2 ;
          }
        }
      }
      if(arr[g-1]!=0){
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Demo8 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var g : int ; g := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,g)->collect(0) ;
    var ax : int ; ax := sc.getCurrent()->toInteger() ;
    if (ax = 1) then (     arr[0+1] := 2 ) else (     arr[0+1] := 1 ) ;  
    if (ax = 3) then (     OclFile["System.out"].println("NO") ) else (         var i : int ; i := 1 ; while i < g do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x = arr[i - 1+1]) then (     OclFile["System.out"].println("NO") ; 
     break ) else skip ; 
         var i2 : int ; i2 := 1 ; while i2 < 4 do ( (     if (i2 /= x & i2 /= arr[i - 1+1]) then (     arr[i+1] := i2 ) else skip )  ;     i2 := i2 + 1 ) )  ;     i := i + 1 ) ; 
     if (arr[g - 1+1] /= 0) then (     OclFile["System.out"].println("YES") ) else skip ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class DeleteN {
  public static void main(String args[]){
    int in=1234 ;
    String inp=Integer.toString(in);
    int del=3 ;
    System.out.println("num_after_deleting_from_starting "+fromStart(inp,del));
    System.out.println("num_after_deleting_from_ending "+fromEnd(inp,del));
  }
  static String fromStart(String inp,int del){
    try {
      String inp1=inp.substring(0,del-1);
      String inp2=inp.substring(del,inp.length());
      return inp1+inp2 ;
    }
    catch(Exception e){
      return "Check Input" ;
    }
  }
  static String fromEnd(String inp,int del){
    try {
      String inp1=inp.substring(0,inp.length()-del);
      String inp2=inp.substring(inp.length()-del+1,inp.length());
      return inp1+inp2 ;
    }
    catch(Exception e){
      return "Check Input" ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class DeleteN {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : int ; in := 1234 ;
     var inp : String ; inp := ((in) + "") ;
    var del : int ; del := 3 ;
    OclFile["System.out"].println("num_after_deleting_from_starting " + fromStart(inp, del)) ; 
    OclFile["System.out"].println("num_after_deleting_from_ending " + fromEnd(inp, del)) ; 
 );
  static   operation fromStart( inp : String, del : int) : String
  pre: true
  post: true
  activity: (     try (     var inp1 : String ; inp1 := inp.subrange(0+1,(del)->char2byte() - 1) ;
     var inp2 : String ; inp2 := inp.subrange(del+1,inp->size()) ;
     return inp1 + inp2 )   catch (e : ProgramException) do (     return "Check Input" )
 );
  static   operation fromEnd( inp : String, del : int) : String
  pre: true
  post: true
  activity: (     try (     var inp1 : String ; inp1 := inp.subrange(0+1,inp->size() - (del)->char2byte()) ;
     var inp2 : String ; inp2 := inp.subrange(inp->size() - (del)->char2byte() + 1+1,inp->size()) ;
     return inp1 + inp2 )   catch (e : ProgramException) do (     return "Check Input" )
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.HashSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    boolean p1=true,p2=true,p3=true ;
    int t ;
    for(int i=0 ; i<n ; i++){
      t=sc.nextInt();
      if(i==0){
        if(t==1){
          p2=! p2 ;
        }
        else if(t==2){
          p1=! p1 ;
        }
        else if(t==3){
          System.out.println("NO");
          return ;
        }
      }
      else if(i>0){
        if(t==1){
          if(! p1){
            System.out.println("NO");
            return ;
          }
          p2=! p2 ;
          p3=! p3 ;
        }
        else if(t==2){
          if(! p2){
            System.out.println("NO");
            return ;
          }
          p1=! p1 ;
          p3=! p3 ;
        }
      }
      if(t==3){
        if(! p3){
          System.out.println("NO");
          return ;
        }
        p1=! p1 ;
        p2=! p2 ;
      }
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var p1 : boolean ; p1 := true ;
    var p2 : boolean ; p2 := true ;
    var p3 : boolean ; p3 := true ;
    var t : int ;
        var i : int ; i := 0 ; while i < n do ( (     t := sc.getCurrent()->toInteger() ; 
     if (i = 0) then (     if (t = 1) then (     p2 := not(p2) ) else     if (t = 2) then (     p1 := not(p1) ) else     if (t = 3) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; ;  ) else     if (i > 0) then (     if (t = 1) then (     if (not(p1)) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
     p2 := not(p2) ; 
     p3 := not(p3) ) else     if (t = 2) then (     if (not(p2)) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
     p1 := not(p1) ; 
     p3 := not(p3) ) else skip ; ) else skip ; ;  
     if (t = 3) then (     if (not(p3)) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
     p1 := not(p1) ; 
     p2 := not(p2) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Goro {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new FileReader("D-large.in"));
      int T=Integer.parseInt(br.readLine());
      PrintWriter pw=new PrintWriter(new FileWriter("output"));
      for(int I=1 ; I<=T ; I++){
        int N=Integer.parseInt(br.readLine());
        StringTokenizer st=new StringTokenizer(br.readLine()," ",false);
        int ret=N ;
        for(int i=0 ; i<N ; i++){
          int k=Integer.parseInt(st.nextToken());
          if(k==i+1)ret--;
        }
        pw.println("Case #"+I+": "+ret+".000000");
      }
      br.close();
      pw.flush();
      pw.close();
    }
    catch(IOException ie){
      ie.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Goro {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("D-large.in"))) ;
     var T : int ; T := (br.readLine())->toInteger() ;
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output"))) ;
        var I : int ; I := 1 ; while I <= T do ( (     var N : int ; N := (br.readLine())->toInteger() ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String_String(br.readLine(), " ", false) ;
    var ret : int ; ret := N ;
        var i : int ; i := 0 ; while i < N do ( (     var k : int ; k := (st.next())->toInteger() ;
     if (k = i + 1) then     ret := ret - 1 ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     I := I + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 )   catch (ie : IOException) do (     ie.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public void doIt()throws Exception {
    Scanner sc=new Scanner(new FileReader("input.txt"));
    PrintWriter pw=new PrintWriter(new FileWriter("output.txt"));
    final int MAX=1000 ;
    double[] invFact=new double[MAX+1];
    invFact[0]=1.0 ;
    for(int i=1 ; i<=MAX ; i++)invFact[i]=invFact[i-1]/(double)i ;
    double[] derang=new double[MAX+1];
    derang[0]=invFact[0];
    for(int i=1 ; i<=MAX ; i++)derang[i]=derang[i-1]+(i % 2==1 ?-1 : 1)*invFact[i];
    double[] avgTime=new double[MAX+1];
    avgTime[0]=0.0 ;
    for(int i=1 ; i<=MAX ; i++){
      double sum=1.0 ;
      for(int j=1 ; j<=i ; j++)sum+=avgTime[i-j]*invFact[j]*derang[i-j];
      avgTime[i]=sum/(1-invFact[0]*derang[i]);
    }
    int caseCnt=sc.nextInt();
    for(int caseNum=0 ; caseNum<caseCnt ; caseNum++){
      int N=sc.nextInt();
      int ans=0 ;
      for(int i=1 ; i<=N ; i++){
        int x=sc.nextInt();
        if(x!=i)ans++;
      }
      pw.println("Case #"+(caseNum+1)+": "+ans);
    }
    pw.flush();
    pw.close();
    sc.close();
  }
  public static void main(String[] args)throws Exception {
    new Solution().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt"))) ;
    var MAX : int ; MAX := 1000 ;
    var invFact : Sequence(double) ; invFact := Integer.subrange(1,MAX + 1)->collect(0.0) ;
    invFact[0+1] := 1.0 ; 
        var i : int ; i := 1 ; while i <= MAX do (     invFact[i+1] := invFact[i - 1+1] / i->oclAsType(double) ;  ;     i := i + 1 ) ; 
    var derang : Sequence(double) ; derang := Integer.subrange(1,MAX + 1)->collect(0.0) ;
    derang[0+1] := invFact[0+1] ; 
        var i : int ; i := 1 ; while i <= MAX do (     derang[i+1] := derang[i - 1+1] + (if i mod 2 = 1 then -1 else 1 endif) * invFact[i+1] ;  ;     i := i + 1 ) ; 
    var avgTime : Sequence(double) ; avgTime := Integer.subrange(1,MAX + 1)->collect(0.0) ;
    avgTime[0+1] := 0.0 ; 
        var i : int ; i := 1 ; while i <= MAX do ( (     var sum : double ; sum := 1.0 ;
         var j : int ; j := 1 ; while j <= i do (     sum := sum+(avgTime[i - j+1] * invFact[j+1] * derang[i - j+1]) ;  ;     j := j + 1 ) ; 
     avgTime[i+1] := sum / (1 - invFact[0+1] * derang[i+1]) )  ;     i := i + 1 ) ; 
    var caseCnt : int ; caseCnt := sc.getCurrent()->toInteger() ;
        var caseNum : int ; caseNum := 0 ; while caseNum < caseCnt do ( (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i <= N do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x /= i) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
     skip )  ;     caseNum := caseNum + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Solution.newSolution().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class d {
  static double[] memo=new double[1010];
  static double[][] memoo=new double[1010][1010];
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=1 ; t<=T ; t++){
      int n=in.nextInt();
      int k=0 ;
      for(int i=1 ; i<=n ; i++)if(i!=in.nextInt())k++;
      System.out.printf("Case #%d: %f%n",t,(double)k);
    }
  }
  public static double f(int k,int j){
    if(j<0 || j>k)return 0 ;
    if(k==0 && j==0)return 1 ;
    if(memoo[k][j]!=0)return memoo[k][j];
    double ans=f(k-1,j-1)+f(k-1,j)*(k-1-j)+f(k-1,j+1)*(j+1);
    ans/=k ;
    return memoo[k][j]=ans ;
  }
  public static double go(int k){
    if(k==0)return 0 ;
    if(memo[k]!=0)return memo[k];
    double total=1 ;
    for(int i=1 ; i<=k ; i++){
      total+=f(k,i)*go(k-i);
    }
    total/=(1-f(k,0));
    return memo[k]=total ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class d {
  static   attribute memo : Sequence(double) := Integer.subrange(1,1010)->collect(0.0);
  static   attribute memoo : Sequence(Sequence(double)) := Integer.subrange(1,1010)->collect(Integer.subrange(1,1010)->collect(0.0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 1 ; while t <= T do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := 0 ;
         var i : int ; i := 1 ; while i <= n do (     if (i /= in.getCurrent()->toInteger()) then     k := k + 1 ; else skip ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].printf("Case #%d: %f%n", t, k->oclAsType(double)) )  ;     t := t + 1 ) );
  static   operation f( k : int, j : int) : double
  pre: true
  post: true
  activity: (     if (j < 0 or j > k) then     return 0 else skip ; 
     if (k = 0 & j = 0) then     return 1 else skip ; 
    if (memoo[k+1][j+1] /= 0) then     return memoo[k+1][j+1] else skip ; 
    var ans : double ; ans := f(k - 1, j - 1) + f(k - 1, j) * (k - 1 - j) + f(k - 1, j + 1) * (j + 1) ;
    ans := ans/(k) ; 
    return memoo[k+1][j+1] 
 );
  static   operation go( k : int) : double
  pre: true
  post: true
  activity: (     if (k = 0) then     return 0 else skip ; 
     if (memo[k+1] /= 0) then     return memo[k+1] else skip ; 
    var total : double ; total := 1 ;
        var i : int ; i := 1 ; while i <= k do ( (     total := total+(f(k, i) * go(k - i)) )  ;     i := i + 1 ) ; 
    total := total/((1 - f(k, 0))) ; 
    return memo[k+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main implements Runnable {
  String file="D-large" ;
  private void solve()throws IOException {
    int tn=nextInt();
    for(int testN=1 ; testN<=tn ; ++testN){
      int n=nextInt();
      int ans=n ;
      for(int i=0 ; i<n ; ++i){
        if(nextInt()==i+1){
--ans ;
        }
      }
      out.printf("Case #%d: %d.000000\n",testN,ans);
    }
  }
  public static void main(String[] args){
    new Thread(new Main()).start();
  }
  StringTokenizer tok ;
  PrintWriter out ;
  BufferedReader br ;
  @ Override public void run(){
    try {
      Locale.setDefault(Locale.US);
      out=new PrintWriter(new FileWriter(file+".out"));
      br=new BufferedReader(new FileReader(file+".in"));
      tok=new StringTokenizer("");
      while(hasNext()){
        solve();
      }
      out.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  boolean hasNext()throws IOException {
    while(! tok.hasMoreElements()){
      String line=br.readLine();
      if(line==null){
        return false ;
      }
      tok=new StringTokenizer(line);
    }
    return true ;
  }
  String next()throws IOException {
    if(hasNext()){
      return tok.nextToken();
    }
    throw new IOException("No more tokens");
  }
  int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  String nextLine()throws IOException {
    if(hasNext()){
      return tok.nextToken("\n");
    }
    throw new IOException("No more tokens");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
   attribute file : String := "D-large";
   operation solve() : void
  pre: true
  post: true
  activity: (     var tn : int ; tn := nextInt() ;
         var testN : int ; testN := 1 ; while testN <= tn do ( (     var n : int ; n := nextInt() ;
     var ans : int ; ans := n ;
         var i : int ; i := 0 ; while i < n do ( (     if (nextInt() = i + 1) then (     ans := ans - 1 ) else skip )  ;     i := i + 1 ) ; 
     out.printf("Case #%d: %d.000000\n", testN, ans) )  ;     testN := testN + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(Main.newMain()).start() );
   attribute tok : OclIterator;
   attribute out : OclFile;
   attribute br : OclFile;
      operation run() : void
  pre: true
  post: true
  activity: (     try (     Locale.setDefault(Locale.US) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(file + ".out")) ; 
    br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file + ".in")) ; 
    tok := OclIterator.newOclIterator_String("") ; 
    while (hasNext()) do (     execute solve() ) ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (not(tok.hasNext())) do (     var line : String ; line := br.readLine() ;
     if (line = null) then (     return false ) else skip ; 
     tok := OclIterator.newOclIterator_String(line) ) ; 
     return true );
   operation next() : String
  pre: true
  post: true
  activity: (     if (hasNext()) then (     return tok.next() ) else skip ; 
     error IOException("No more tokens") );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (hasNext()) then (     return tok.nextToken("\n") ) else skip ; 
     error IOException("No more tokens") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class D {
  static double[] dpc=new double[1024];
  static double[] dpa=new double[1024];
  public static void main(String[] args)throws Exception {
    Scanner s=new Scanner(new File("D.in"));
    PrintWriter out=new PrintWriter(new File("D.out"));
    dpc[1]=0 ;
    dpc[2]=2 ;
    dpa[1]=0 ;
    dpa[2]=1 ;
    for(int i=3 ; i<=1000 ; i++){
      dpc[i]=1 ;
      for(int j=1 ; j<i ; j++){
        dpc[i]+=(dpc[j]+dpa[i-j])/i ;
      }
      dpc[i]*=((double)i)/(i-1);
      dpa[i]=dpc[i]-1 ;
    }
    int T=s.nextInt();
    int[] arr=new int[1024];
    boolean[] mark=new boolean[1024];
    for(int tc=1 ; tc<=T ; tc++){
      out.print("Case #"+tc+": ");
      int N=s.nextInt();
      for(int i=1 ; i<=N ; i++)arr[i]=s.nextInt();
      double answer=0 ;
      Arrays.fill(mark,false);
      for(int i=1 ; i<=N ; i++){
        int cycleLength=0 ;
        int cur=i ;
        while(! mark[cur]){
          mark[cur]=true ;
          cur=arr[cur];
          cycleLength++;
        }
        answer+=dpc[cycleLength];
      }
      out.println(answer);
    }
    out.close();
    System.out.println(dpc[1000]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   attribute dpc : Sequence(double) := Integer.subrange(1,1024)->collect(0.0);
  static   attribute dpa : Sequence(double) := Integer.subrange(1,1024)->collect(0.0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile("D.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("D.out")) ;
    dpc[1+1] := 0 ; 
    dpc[2+1] := 2 ; 
    dpa[1+1] := 0 ; 
    dpa[2+1] := 1 ; 
        var i : int ; i := 3 ; while i <= 1000 do ( (     dpc[i+1] := 1 ; 
         var j : int ; j := 1 ; while j < i do ( (     dpc[i+1] := dpc[i+1]+((dpc[j+1] + dpa[i - j+1]) / i) )  ;     j := j + 1 ) ; 
     dpc[i+1] := dpc[i+1]*((i->oclAsType(double)) / (i - 1)) ; 
     dpa[i+1] := dpc[i+1] - 1 )  ;     i := i + 1 ) ; 
    var T : int ; T := s.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,1024)->collect(0) ;
    var mark : Sequence(boolean) ; mark := Integer.subrange(1,1024)->collect(false) ;
        var tc : int ; tc := 1 ; while tc <= T do ( (     skip ; 
     var N : int ; N := s.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= N do (     arr[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var answer : double ; answer := 0 ;
    mark := mark->collect(false) ; 
        var i : int ; i := 1 ; while i <= N do ( (     var cycleLength : int ; cycleLength := 0 ;
     var cur : int ; cur := i ;
     while (not(mark[cur+1])) do (     mark[cur+1] := true ; 
     cur := arr[cur+1] ; 
     cycleLength := cycleLength + 1 ) ; 
     answer := answer+(dpc[cycleLength+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     tc := tc + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(dpc[1000+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int times(int[] steps,int n){
    int current_level=0 ;
    int previous_level=0 ;
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      previous_level=current_level ;
      current_level=current_level+steps[i];
      if((previous_level<0 && current_level>=0)||(previous_level>0 && current_level<=0)){
        count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int steps[]={
      1,-1,0,0,1,1,-3,2 };
      int n=steps.length ;
      System.out.println(times(steps,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation times( steps : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var current_level : int ; current_level := 0 ;
     var previous_level : int ; previous_level := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     previous_level := current_level ; 
     current_level := current_level + steps[i+1] ; 
     if ((previous_level < 0 & current_level >= 0) or (previous_level > 0 & current_level <= 0)) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var steps : Sequence(int) ; steps := Sequence{1,-1,0,0,1,1,-3,2} ;
     var n : int ; n := steps->size() ;
     OclFile["System.out"].println(times(steps, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Holiday[] holidays=new Holiday[n];
    for(int i=0 ; i<n ; i++){
      holidays[i]=new Holiday(sc.nextInt(),sc.nextInt(),sc.nextInt(),sc.nextInt());
    }
    int min=Integer.MAX_VALUE ;
    for(int i=1 ; i<=360 ; i++){
      int max=0 ;
      for(int j=0 ; j<n ; j++){
        max=Math.max(max,holidays[j] .getCrowded(i));
      }
      min=Math.min(min,max);
    }
    System.out.println(min);
  }
  static class Holiday {
    int start ;
    int end ;
    int value ;
    public Holiday(int month,int day,int time,int value){
      start=(month-1)*30+day ;
      end=start+time-1 ;
      if(end>360){
        end-=360 ;
      }
      this.value=value ;
    }
    public int getCrowded(int target){
      if(start>end){
        if(target<=end || target>=start){
          return value ;
        }
      }
      else {
        if(start<=target && target<=end){
          return value ;
        }
      }
      int v1 ;
      if(target<start){
        v1=Math.max(0,value-(start-target));
      }
      else {
        v1=Math.max(0,value-(360+start-target));
      }
      int v2 ;
      if(end<target){
        v2=Math.max(0,value-(target-end));
      }
      else {
        v2=Math.max(0,value-(360+target-end));
      }
      return Math.max(v1,v2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var holidays : Sequence(Holiday) ; holidays := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     holidays[i+1] := Holiday.newHoliday(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
        var i : int ; i := 1 ; while i <= 360 do ( (     var max : int ; max := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     max := Set{max, holidays[j+1].getCrowded(i)}->max() )  ;     j := j + 1 ) ; 
     min := Set{min, max}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
  static class Holiday {
   attribute start : int;
   attribute end : int;
   attribute value : int;
   static operation newHoliday( month : int, day : int, time : int, value : int) : Holiday
  pre: true
  post: true
  activity:
  ( var self : Holiday ;
    self := createHoliday();
    self.initialise(month, day,time,value);
    return self );
  operation initialise( month : int, day : int, time : int, value : int) : void
  pre: true  post: true
  activity: (     start := (month - 1) * 30 + day ; 
     end := start + time - 1 ; 
     if (end > 360) then (     end := end-(360) ) else skip ; 
     self.value := value );
   operation getCrowded( target : int) : int
  pre: true
  post: true
  activity: (     if (start > end) then (     if (target <= end or target >= start) then (     return value ) else skip ) else (     if (start <= target & target <= end) then (     return value ) else skip ) ;  
     var v1 : int ;
    if (target < start) then (     v1 := Set{0, value - (start - target)}->max() ) else (     v1 := Set{0, value - (360 + start - target)}->max() ) ;  
    var v2 : int ;
    if (end < target) then (     v2 := Set{0, value - (target - end)}->max() ) else (     v2 := Set{0, value - (360 + target - end)}->max() ) ;  
    return Set{v1, v2}->max() 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class PetrPermutations {
  public static void main(String[] args){
    FastScanner scanner=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int N=scanner.nextInt();
    int[] perm=new int[N];
    for(int i=0 ; i<N ; i++)perm[i]=scanner.nextInt();
    int swaps=0 ;
    boolean[] vis=new boolean[N];
    for(int i=0 ; i<N ; i++){
      int j=i,cycle=0 ;
      while(! vis[j]){
        vis[j]=true ;
        j=perm[j]-1 ;
        cycle++;
      }
      if(cycle>0)swaps+=cycle-1 ;
    }
    if(swaps % 2!=N % 2)out.println("Um_nik");
    else out.println("Petr");
    out.flush();
  }
  public static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(Reader in){
      br=new BufferedReader(in);
    }
    public FastScanner(){
      this(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 readNextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    int[] readIntArray(int n){
      int[] a=new int[n];
      for(int idx=0 ; idx<n ; idx++){
        a[idx]=nextInt();
      }
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PetrPermutations {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : FastScanner ; scanner := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := scanner.nextInt() ;
    var perm : Sequence(int) ; perm := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     perm[i+1] := scanner.nextInt() ;  ;     i := i + 1 ) ; 
    var swaps : int ; swaps := 0 ;
    var vis : Sequence(boolean) ; vis := Integer.subrange(1,N)->collect(false) ;
        var i : int ; i := 0 ; while i < N do ( (     var j : int ; j := i ;
    var cycle : int ; cycle := 0 ;
     while (not(vis[j+1])) do (     vis[j+1] := true ; 
     j := perm[j+1] - 1 ; 
     cycle := cycle + 1 ) ; 
     if (cycle > 0) then     swaps := swaps+(cycle - 1) ; else skip )  ;     i := i + 1 ) ; 
    if (swaps mod 2 /= N mod 2) then     skip else     skip ; ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(in) );
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation readNextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation readIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var idx : int ; idx := 0 ; while idx < n do ( (     a[idx+1] := nextInt() )  ;     idx := idx + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CodeForces {
  public static final int BUFFERSIZE=512000 ;
  private static Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in),BUFFERSIZE));
  private static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out,BUFFERSIZE));
  public static void solve(){
    long position=sc.nextLong();
    long nrstSeqStartIndx=1 ;
    while(getValueAtIndex(nrstSeqStartIndx*2)<position){
      nrstSeqStartIndx*=2 ;
    }
    while(getValueAtIndex(nrstSeqStartIndx+1)<=position)nrstSeqStartIndx++;
    long startIndex=getValueAtIndex(nrstSeqStartIndx);
    out.println((position-startIndex)+1);
  }
  public static long getValueAtIndex(long index){
    return 1+((index-1)*index/2);
  }
  public static void main(String args[])throws Exception {
    in.init(System.in);
    solve();
    out.close();
  }
  public static class in {
    static BufferedReader reader ;
    static StringTokenizer tokenizer ;
    static void init(InputStream input){
      reader=new BufferedReader(new InputStreamReader(input),BUFFERSIZE);
      tokenizer=new StringTokenizer("");
    }
    static String next()throws IOException {
      while(! tokenizer.hasMoreTokens())tokenizer=new StringTokenizer(reader.readLine());
      return tokenizer.nextToken();
    }
    static int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    static double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    static long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static    attribute BUFFERSIZE : int := 512000;
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), BUFFERSIZE));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"], BUFFERSIZE));
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var position : long ; position := sc.getCurrent()->toLong() ;
     var nrstSeqStartIndx : long ; nrstSeqStartIndx := 1 ;
    while (getValueAtIndex(nrstSeqStartIndx * 2) < position) do (     nrstSeqStartIndx := nrstSeqStartIndx*(2) ) ; 
    while (getValueAtIndex(nrstSeqStartIndx + 1) <= position) do     nrstSeqStartIndx := nrstSeqStartIndx + 1 ; ; 
    var startIndex : long ; startIndex := getValueAtIndex(nrstSeqStartIndx) ;
    skip ; 
 );
  static   operation getValueAtIndex( index : long) : long
  pre: true
  post: true
  activity: (     return 1 + ((index - 1) * index / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in.init(OclFile["System.in"]) ; 
     execute solve() ; 
     skip );
  static class in {
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   operation init( input : OclFile) : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(input), BUFFERSIZE) ; 
     tokenizer := OclIterator.newOclIterator_String("") );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ; ; 
     return tokenizer.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int nondecdigits(int n){
    int x=0 ;
    for(x=n ; x>=1 ; x--){
      int no=x ;
      int prev_dig=11 ;
      boolean flag=true ;
      while(no!=0){
        if(prev_dig<no % 10){
          flag=false ;
          break ;
        }
        prev_dig=no % 10 ;
        no/=10 ;
      }
      if(flag==true)break ;
    }
    return x ;
  }
  public static void main(String[] args){
    int n=200 ;
    System.out.println(nondecdigits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nondecdigits( n : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := 0 ;
         x := n ; while x >= 1 do ( (     var no : int ; no := x ;
     var prev_dig : int ; prev_dig := 11 ;
    var flag : boolean ; flag := true ;
    while (no /= 0) do (     if (prev_dig < no mod 10) then (     flag := false ; 
     break ) else skip ; 
     prev_dig := no mod 10 ; 
     no := no/(10) ) ; 
    if (flag = true) then     break else skip ; 
 )  ;     x := x - 1 ) ; 
     return x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 200 ;
     OclFile["System.out"].println(nondecdigits(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String smallest(String s){
    int l=s.length();
    String ans="" ;
    for(int i=0 ; i<l-1 ; i++){
      if(s.charAt(i)>s.charAt(i+1)){
        for(int j=0 ; j<l ; j++){
          if(i!=j){
            ans+=s.charAt(j);
          }
        }
        return ans ;
      }
    }
    ans=s.substring(0,l-1);
    return ans ;
  }
  public static void main(String[] args){
    String s="abcda" ;
    System.out.println(smallest(s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation smallest( s : String) : String
  pre: true
  post: true
  activity: (     var l : int ; l := s->size() ;
     var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < l - 1 do ( (     if (s->at(i+1) > s->at(i + 1+1)) then (         var j : int ; j := 0 ; while j < l do ( (     if (i /= j) then (     ans := ans+(s->at(j+1)) ) else skip )  ;     j := j + 1 ) ; 
     return ans ) else skip )  ;     i := i + 1 ) ; 
    ans := s.subrange(0+1,l - 1) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abcda" ;
     OclFile["System.out"].println(smallest(s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int[] g={
      0,0,2,0,1,0,1,0,0,1,0,1,0 };
      if(g[a]==g[b]){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var g : Sequence(int) ; g := Sequence{0,0,2,0,1,0,1,0,0,1,0,1,0} ;
    if (g[a+1] = g[b+1]) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    List<Integer>groupA=Arrays.asList(new Integer[] {
      1,3,5,7,8,10,12 }
);
      List<Integer>groupB=Arrays.asList(new Integer[] {
        4,6,9,11 }
);
        List<Integer>groupC=Arrays.asList(new Integer[] {
          2 }
);
          Scanner sc=new Scanner(System.in);
          final int firstNum=sc.nextInt();
          final int secondNum=sc.nextInt();
          if(isContainGroup(groupA,firstNum,secondNum)|| isContainGroup(groupB,firstNum,secondNum)|| isContainGroup(groupC,firstNum,secondNum)){
            System.out.print("Yes");
          }
          else {
            System.out.print("No");
          }
        }
        private static boolean isContainGroup(List group,int num1,int num2){
          return group.contains(num1)&& group.contains(num2);
        }
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var groupA : Sequence(int) ; groupA := Sequence{1,3,5,7,8,10,12} ;
     var groupB : Sequence(int) ; groupB := Sequence{4,6,9,11} ;
    var groupC : Sequence(int) ; groupC := Sequence{2} ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var firstNum : int ; firstNum := sc.getCurrent()->toInteger() ;
    var secondNum : int ; secondNum := sc.getCurrent()->toInteger() ;
    if (isContainGroup(groupA, firstNum, secondNum) or isContainGroup(groupB, firstNum, secondNum) or isContainGroup(groupC, firstNum, secondNum)) then (     OclFile["System.out"].print("Yes") ) else (     OclFile["System.out"].print("No") ) ;  
 );
  static   operation isContainGroup( group : Sequence, num1 : int, num2 : int) : boolean
  pre: true
  post: true
  activity: (     return group->includes(num1) & group->includes(num2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.List ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tokenizer=new StringTokenizer(input.readLine());
    int a=Integer.parseInt(tokenizer.nextToken());
    int b=Integer.parseInt(tokenizer.nextToken());
    List<List<Integer>>lists=Arrays.asList(Arrays.asList(1,3,5,7,8,10,12),Arrays.asList(4,6,9,11),Arrays.asList(2));
    for(int i=0 ; i<3 ; i++){
      if(lists.get(i).contains(a)&& lists.get(i).contains(b)){
        System.out.println("Yes");
        return ;
      }
    }
    System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tokenizer : OclIterator ; tokenizer := OclIterator.newOclIterator_String(input.readLine()) ;
    var a : int ; a := (tokenizer.next())->toInteger() ;
    var b : int ; b := (tokenizer.next())->toInteger() ;
    var lists : Sequence(Sequence(int)) ; lists := Sequence{Sequence{1,3,5,7,8,10,12},Sequence{4,6,9,11},2} ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (lists->at(i+1)->includes(a) & lists->at(i+1)->includes(b)) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("No") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    System.out.println(whichGroup(x)==whichGroup(y)? "Yes" : "No");
  }
  private static int whichGroup(int n){
    int group=0 ;
    switch(n){
      case 1 : case 3 : case 5 : case 7 : case 8 : case 10 : case 12 : group=1 ;
      break ;
      case 4 : case 6 : case 9 : case 11 : group=2 ;
      break ;
      case 2 : group=3 ;
      break ;
    }
    return group ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if whichGroup(x) = whichGroup(y) then "Yes" else "No" endif) );
  static   operation whichGroup( n : int) : int
  pre: true
  post: true
  activity: (     var group : int ; group := 0 ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (n) ; 
    if _switchval = 1 or _switchval = 3 or _switchval = 5 or _switchval = 7 or _switchval = 8 then
   if _switchval = 10 then
   if _switchval = 12 then
    group := 1 ; 
    break 
   else skip ;
    if _switchval = 4 or _switchval = 6 or _switchval = 9 or _switchval = 11 then
    group := 2 ; 
    break 
   else skip ;
       if _switchval = 2 then
     group := 3 ; 
    break 
   else skip ;
 )
     return group );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  @ SuppressWarnings("unchecked")private static final Set<Integer>[] SETS=new Set[] {
    Set.of(1,3,5,7,8,10,12),Set.of(4,6,9,11),Set.of(12)};
    public static void main(String[] args){
      try(Scanner scanner=new Scanner(System.in)){
        int x=scanner.nextInt(),y=scanner.nextInt();
        System.out.println((getSet(x)==getSet(y))? "Yes" : "No");
      }
    }
    private static Set<Integer>getSet(int n){
      for(Set<Integer>set : SETS){
        if(set.contains(n)){
          return set ;
        }
      }
      return null ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute SETS : Sequence(Set(int)) := Sequence{Set.of(1, 3, 5, 7, 8, 10, 12),Set.of(4, 6, 9, 11),Set.of(12)};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var x : int ; x := scanner.getCurrent()->toInteger() ;
    var y : int ; y := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if (getSet(x) = getSet(y)) then "Yes" else "No" endif) ))  );
  static   operation getSet( n : int) : Set(int)
  pre: true
  post: true
  activity: (     for (set : SETS) do ( (     if (set->includes(n)) then (     return set ) else skip )  ) ; 
     return null );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int FindMinNumber(int arr[],int n,int k){
    int i=0 ;
    int j=0 ;
    int min_num=Integer.MAX_VALUE ;
    boolean found=false ;
    int sum=0 ;
    while(i<n){
      sum=sum+arr[i];
      if(sum==k){
        min_num=Math.min(min_num,((n-(i+1))+j));
        found=true ;
      }
      else if(sum>k){
        while(sum>k){
          sum=sum-arr[j];
          j++;
        }
        if(sum==k){
          min_num=Math.min(min_num,((n-(i+1))+j));
          found=true ;
        }
      }
      i++;
    }
    if(found)return min_num ;
    return-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      1,3,2,5,6 };
      int n=arr.length ;
      int k=5 ;
      System.out.println(FindMinNumber(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation FindMinNumber( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var j : int ; j := 0 ;
    var min_num : int ; min_num := 2147483647 ;
    var found : boolean ; found := false ;
    var sum : int ; sum := 0 ;
    while (i < n) do (     sum := sum + arr[i+1] ; 
     if (sum = k) then (     min_num := Set{min_num, ((n - (i + 1)) + j)}->min() ; 
     found := true ) else     if (sum > k) then (     while (sum > k) do (     sum := sum - arr[j+1] ; 
     j := j + 1 ) ; 
     if (sum = k) then (     min_num := Set{min_num, ((n - (i + 1)) + j)}->min() ; 
     found := true ) else skip ) else skip ; ;  
     i := i + 1 ) ; 
    if (found) then     return min_num else skip ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,2,5,6} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 5 ;
     OclFile["System.out"].println(FindMinNumber(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static Scanner sc ;
  private static Printer pr ;
  private static void solve(){
    char[] s=sc.next().toCharArray();
    int cnt=0 ;
    for(char c : s){
      if(c=='1'){
        cnt++;
      }
    }
    pr.println(cnt);
  }
  public static void main(String[] args){
    sc=new Scanner(System.in);
    pr=new Printer(System.out);
    solve();
    pr.close();
    sc.close();
  }
  private static class Printer extends PrintWriter {
    Printer(PrintStream out){
      super(out);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile;
  static   attribute pr : Printer;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
     var cnt : int ; cnt := 0 ;
     for (c : s) do ( (     if (c = '1') then (     cnt := cnt + 1 ) else skip )  ) ; 
     pr.println(cnt) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     pr := Printer.newPrinter(OclFile["System.out"]) ; 
    execute solve() ; 
    pr.close() ; 
    skip ; 
 );
  static class Printer extends OclFile {
   static operation newPrinter( out : OclFile) : Printer
  pre: true
  post: true
  activity:
  ( var self : Printer ;
    self := createPrinter();
    self.initialise(out);
    return self );
  operation initialise( out : OclFile) : void
  pre: true  post: true
  activity: (     execute super(out) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws Exception {
    FastScanner scanner=new FastScanner(System.in);
    String threeDigit=scanner.next();
    int sum=0 ;
    for(int i=0 ; i<3 ; i++){
      if(threeDigit.charAt(i)=='1'){
        sum++;
      }
    }
    PrintWriter printWriter=new PrintWriter(System.out);
    printWriter.printf("%d\n",sum);
    printWriter.close();
  }
  static class FastScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public FastScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
      tokenizer=null ;
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          return reader.readLine();
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken("\n");
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public long nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public int[] nextIntArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=(int)nextInt();
      return a ;
    }
    public long[] nextLongArray(int n){
      long[] a=new long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : FastScanner ; scanner := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var threeDigit : String ; threeDigit := scanner.next() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (threeDigit->at(i+1) = '1') then (     sum := sum + 1 ) else skip )  ;     i := i + 1 ) ; 
    var printWriter : OclFile ; printWriter := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.nextToken("\n") );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextInt() : long
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt()->oclAsType(int) ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static int useRecursionToCountChars(String str,char key,int index){
    if(index>=str.length()){
      return 0 ;
    }
    int count=str.charAt(index)==key ? 1 : 0 ;
    return count+useRecursionToCountChars(str,key,index+1);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    int result=useRecursionToCountChars(str,'1',0);
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation useRecursionToCountChars( str : String, key : String, index : int) : int
  pre: true
  post: true
  activity: (     if (index >= str->size()) then (     return 0 ) else skip ; 
     var count : int ; count := if str->at(index+1) = key then 1 else 0 endif ;
     return count + useRecursionToCountChars(str, key, index + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
     var result : int ; result := useRecursionToCountChars(str, '1', 0) ;
     OclFile["System.out"].println(result) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  Scanner sc=new Scanner(System.in);
  public void lmap(int i,int j){
    map[i][j]='0' ;
    if(i-1>=0 && map[i-1][j]=='1'){
      lmap(i-1,j);
    }
    if(i+1<12 && map[i+1][j]=='1'){
      lmap(i+1,j);
    }
    if(j>=1 && map[i][j-1]=='1'){
      lmap(i-1,j-1);
    }
    if(j+1<12 && map[i][j+1]=='1'){
      lmap(i,j+1);
    }
  }
  char[][] map ;
  public void run(){
    while(sc.hasNext()){
      map=new char[12][12];
      for(int i=0 ; i<12 ; i++){
        map[i]=sc.next().toCharArray();
      }
      int count=0 ;
      for(int i=0 ; i<12 ; i++)for(int j=0 ; j<12 ; j++){
        if(map[i][j]=='1'){
          count++;
          lmap(i,j);
        }
      }
      ln(count);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  public static void pr(Object o){
    System.out.print(o);
  }
  public static void ln(Object o){
    System.out.println(o);
  }
  public static void ln(){
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation lmap( i : int, j : int) : void
  pre: true
  post: true
  activity: (     map[i+1][j+1] := '0' ; 
     if (i - 1 >= 0 & map[i - 1+1][j+1] = '1') then (     execute lmap(i - 1, j) ) else skip ; 
    if (i + 1 < 12 & map[i + 1+1][j+1] = '1') then (     execute lmap(i + 1, j) ) else skip ; 
    if (j >= 1 & map[i+1][j - 1+1] = '1') then (     execute lmap(i - 1, j - 1) ) else skip ; 
    if (j + 1 < 12 & map[i+1][j + 1+1] = '1') then (     execute lmap(i, j + 1) ) else skip ; 
 );
   attribute map : Sequence(Sequence(String));
   operation run() : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     map := Integer.subrange(1,12)->collect(Integer.subrange(1,12)->collect(0)) ; 
         var i : int ; i := 0 ; while i < 12 do ( (     map[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < 12 do (         var j : int ; j := 0 ; while j < 12 do ( (     if (map[i+1][j+1] = '1') then (     count := count + 1 ; 
     execute lmap(i, j) ) else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    execute ln(count) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class InfiniteSequence {
  public static void main(String[] args){
    long num=new Scanner(System.in).nextLong();
    long result=0 ;
    for(int i=1 ; i>0 ; i++){
      if(result+i==num){
        System.out.println(i);
        break ;
      }
      else if(result+i>num){
        System.out.println(num-result);
        break ;
      }
      result=result+i ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class InfiniteSequence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : long ; num := OclFile.newOclFile_Read(OclFile["System.in"]).nextLong() ;
     var result : long ; result := 0 ;
         var i : int ; i := 1 ; while i > 0 do ( (     if (result + i = num) then (     OclFile["System.out"].println(i) ; 
     break ) else     if (result + i > num) then (     OclFile["System.out"].println(num - result) ; 
     break ) else skip ; ;  
     result := result + i )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    int ans=0 ;
    for(char x : s.toCharArray()){
      if(x=='1'){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var ans : int ; ans := 0 ;
    for (x : s->characters()) do ( (     if (x = '1') then (     ans := ans + 1 ) else skip )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    String s=sc.next();
    int count=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='1'){
        count++;
      }
    }
    out.printf("%d\n",count);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : String ; s := sc.getCurrent() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '1') then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void nthPalindrome(int n,int k){
    int temp=(k & 1)!=0 ?(k/2):(k/2-1);
    int palindrome=(int)Math.pow(10,temp);
    palindrome+=n-1 ;
    System.out.print(palindrome);
    if((k & 1)>0)palindrome/=10 ;
    while(palindrome>0){
      System.out.print(palindrome % 10);
      palindrome/=10 ;
    }
    System.out.println("");
  }
  public static void main(String[] args){
    int n=6,k=5 ;
    System.out.print(n+"th palindrome of "+k+" digit=");
    nthPalindrome(n,k);
    n=10 ;
    k=6 ;
    System.out.print(n+"th palindrome of "+k+" digit=");
    nthPalindrome(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nthPalindrome( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := if (MathLib.bitwiseAnd(k,1)) /= 0 then (k / 2) else (k / 2 - 1) endif ;
     var palindrome : int ; palindrome := 10->pow(temp)->oclAsType(int) ;
    palindrome := palindrome+(n - 1) ; 
    OclFile["System.out"].print(palindrome) ; 
    if ((k & 1) > 0) then     palindrome := palindrome/(10) ; else skip ; 
    while (palindrome > 0) do (     OclFile["System.out"].print(palindrome mod 10) ; 
     palindrome := palindrome/(10) ) ; 
    OclFile["System.out"].println("") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
    var k : int ; k := 5 ;
     OclFile["System.out"].print(n + "th palindrome of " + k + " digit=") ; 
    execute nthPalindrome(n, k) ; 
    n := 10 ; 
    k := 6 ; 
    OclFile["System.out"].print(n + "th palindrome of " + k + " digit=") ; 
    execute nthPalindrome(n, k) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int INF=Integer.MAX_VALUE ;
  public static void main(String[] args){
    new Main().solve();
  }
  void solve(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long X=sc.nextLong();
    long[] x=new long[N];
    long[] xsum=new long[N+1];
    for(int i=0 ; i<N ; i++){
      x[i]=sc.nextInt();
      xsum[i+1]=xsum[i]+x[i];
    }
    long ans=X*N+5*xsum[N];
    for(int i=1 ; i<N ; i++){
      long cost=X*i+5*(xsum[N]-xsum[N-i]);
      for(int j=5,k=N-i ; k>=0 ; j+=2,k-=i){
        if(cost>ans){
          break ;
        }
        cost+=j*(xsum[k]-xsum[Math.max(k-i,0)]);
      }
      ans=Math.min(ans,cost);
    }
    System.out.println(ans+N*X);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := 2147483647;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var X : long ; X := sc.getCurrent()->toLong() ;
    var x : Sequence(long) ; x := Integer.subrange(1,N)->collect(0) ;
    var xsum : Sequence(long) ; xsum := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     xsum[i + 1+1] := xsum[i+1] + x[i+1] )  ;     i := i + 1 ) ; 
    var ans : long ; ans := X * N + 5 * xsum[N+1] ;
        var i : int ; i := 1 ; while i < N do ( (     var cost : long ; cost := X * i + 5 * (xsum[N+1] - xsum[N - i+1]) ;
         var j : int ; j := 5 ;
    var k : int ; k := N - i ; while k >= 0 do ( (     if (cost > ans) then (     break ) else skip ; 
     cost := cost+(j * (xsum[k+1] - xsum[Set{k - i, 0}->max()+1])) )  ;     j := j+(2) ;     k := k-(i) ) ; 
     ans := Set{ans, cost}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans + N * X) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long e=sc.nextLong();
    long[] x=new long[n];
    long[] xsum=new long[n+1];
    for(int i=0 ; i<n ; i++){
      x[i]=sc.nextLong();
      xsum[i+1]=xsum[i]+x[i];
    }
    sc.close();
    BigInteger ans=BigInteger.valueOf(Long.MAX_VALUE);
    for(int i=1 ; i<=n ; i++){
      BigInteger mans=BigInteger.ZERO ;
      int pos=0 ;
      int count=0 ;
      while(pos<n){
        int mcount=count==0 ? 1 : count ;
        if(n-pos>=i){
          long mval=(xsum[n-pos]-xsum[n-pos-i])*(2*mcount+3);
          mans=mans.add(BigInteger.valueOf(mval));
          count++;
          pos+=i ;
        }
        else {
          long mval=xsum[n-pos]*(2*mcount+3);
          mans=mans.add(BigInteger.valueOf(mval));
          pos=n ;
        }
      }
      mans=mans.add(BigInteger.valueOf((n+i)*e));
      ans=ans.min(mans);
    }
    System.out.println(ans.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var e : long ; e := sc.getCurrent()->toLong() ;
    var x : Sequence(long) ; x := Integer.subrange(1,n)->collect(0) ;
    var xsum : Sequence(long) ; xsum := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toLong() ; 
     xsum[i + 1+1] := xsum[i+1] + x[i+1] )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : long ; ans := ("9223372036854775807"->toLong() + "")->toLong() ;
        var i : int ; i := 1 ; while i <= n do ( (     var mans : long ; mans := 0 ;
     var pos : int ; pos := 0 ;
    var count : int ; count := 0 ;
    while (pos < n) do (     var mcount : int ; mcount := if count = 0 then 1 else count endif ;
     if (n - pos >= i) then (     var mval : long ; mval := (xsum[n - pos+1] - xsum[n - pos - i+1]) * (2 * mcount + 3) ;
     mans := mans->excludes((mval + "")->toLong()) ; 
     count := count + 1 ; 
     pos := pos+(i) ) else (     var mval : long ; mval := xsum[n - pos+1] * (2 * mcount + 3) ;
     mans := mans->excludes((mval + "")->toLong()) ; 
     pos := n ) ) ; 
    mans := mans->excludes(((n + i) * e + "")->toLong()) ; 
    ans := ans->min() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long x=sc.nextLong();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
    }
    long[] rui=new long[n];
    rui[0]=a[0];
    for(int i=1 ; i<n ; i++){
      rui[i]=rui[i-1]+a[i];
    }
    long ans=Long.MAX_VALUE ;
    for(int k=1 ; k<=n ; k++){
      long t=((long)(n+k))*x ;
      int p=n-1 ;
      int q=0 ;
      for(int j=1 ; j<=n ; j++){
        long c=rui[p];
        if((p-k)>=0)c-=rui[p-k];
        p-=k ;
        if(j==1){
          if((5*c)>=(Long.MAX_VALUE-t))q++;
          t+=(5*c);
        }
        else {
          if((2*j+1)>=(Long.MAX_VALUE/c))q++;
          if(((2*j+1)*c)>=(Long.MAX_VALUE-t))q++;
          t+=((2*j+1)*c);
        }
        if(p<0)break ;
      }
      if(q==0)ans=Math.min(ans,t);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : long ; x := sc.getCurrent()->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var rui : Sequence(long) ; rui := Integer.subrange(1,n)->collect(0) ;
    rui[0+1] := a[0+1] ; 
        var i : int ; i := 1 ; while i < n do ( (     rui[i+1] := rui[i - 1+1] + a[i+1] )  ;     i := i + 1 ) ; 
    var ans : long ; ans := "9223372036854775807"->toLong() ;
        var k : int ; k := 1 ; while k <= n do ( (     var t : long ; t := ((n + k)->oclAsType(long)) * x ;
     var p : int ; p := n - 1 ;
    var q : int ; q := 0 ;
        var j : int ; j := 1 ; while j <= n do ( (     var c : long ; c := rui[p+1] ;
     if ((p - k) >= 0) then     c := c-(rui[p - k+1]) ; else skip ; 
    p := p-(k) ; 
    if (j = 1) then (     if ((5 * c) >= ("9223372036854775807"->toLong() - t)) then     q := q + 1 ; else skip ; 
     t := t+((5 * c)) ) else (     if ((2 * j + 1) >= ("9223372036854775807"->toLong() / c)) then     q := q + 1 ; else skip ; 
     if (((2 * j + 1) * c) >= ("9223372036854775807"->toLong() - t)) then     q := q + 1 ; else skip ; 
     t := t+(((2 * j + 1) * c)) ) ;  
    if (p < 0) then     break else skip ; 
 )  ;     j := j + 1 ) ; 
    if (q = 0) then     ans := Set{ans, t}->min() ; else skip ; 
 )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long X=sc.nextLong();
    long[] positionArr=new long[N];
    long[] cumulativeSum=new long[N+1];
    for(int i=0 ; i<N ; i++){
      positionArr[i]=sc.nextLong();
      cumulativeSum[i+1]=cumulativeSum[i]+positionArr[i];
    }
    long sum=X*N+5*cumulativeSum[N];
    for(int i=1 ; i<N ; i++){
      long cost=X*i+5*(cumulativeSum[N]-cumulativeSum[N-i]);
      for(int j=5,k=N-i ; k>=0 ; j+=2,k-=i){
        if(cost>sum){
          break ;
        }
        cost+=j*(cumulativeSum[k]-cumulativeSum[Math.max(k-i,0)]);
      }
      sum=Math.min(sum,cost);
    }
    System.out.println(sum+X*N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var X : long ; X := sc.getCurrent()->toLong() ;
    var positionArr : Sequence(long) ; positionArr := Integer.subrange(1,N)->collect(0) ;
    var cumulativeSum : Sequence(long) ; cumulativeSum := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     positionArr[i+1] := sc.getCurrent()->toLong() ; 
     cumulativeSum[i + 1+1] := cumulativeSum[i+1] + positionArr[i+1] )  ;     i := i + 1 ) ; 
    var sum : long ; sum := X * N + 5 * cumulativeSum[N+1] ;
        var i : int ; i := 1 ; while i < N do ( (     var cost : long ; cost := X * i + 5 * (cumulativeSum[N+1] - cumulativeSum[N - i+1]) ;
         var j : int ; j := 5 ;
    var k : int ; k := N - i ; while k >= 0 do ( (     if (cost > sum) then (     break ) else skip ; 
     cost := cost+(j * (cumulativeSum[k+1] - cumulativeSum[Set{k - i, 0}->max()+1])) )  ;     j := j+(2) ;     k := k-(i) ) ; 
     sum := Set{sum, cost}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum + X * N) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    long X=scanner.nextLong();
    int[] x=new int[N];
    for(int i=0 ; i<N ; i++){
      x[i]=scanner.nextInt();
    }
    reverse(x);
    long sum=0 ;
    long[] xcum=new long[N+1];
    for(int i=0 ; i<N ; i++){
      sum+=x[i];
      xcum[i+1]=sum ;
    }
    long min=Long.MAX_VALUE ;
    for(int k=1 ; k<=N ; k++){
      long e=compute(xcum,k,N);
      if(e<0)continue ;
      e+=k*X ;
      e+=N*X ;
      if(min>e)min=e ;
    }
    System.out.println(min);
  }
  private static long compute(long[] xcum,int k,int N){
    long e=0 ;
    long co=5 ;
    for(int i=0 ; i<(N-1)/k+1 ; i++){
      if(i>1)co+=2 ;
      e+=co*(xcum[Math.min(k*(i+1),xcum.length-1)]-xcum[k*i]);
      if(e<0)return-1 ;
    }
    return e ;
  }
  private static void reverse(int[] x){
    int left=0 ;
    int right=x.length-1 ;
    while(left<right){
      int tmp=x[left];
      x[left]=x[right];
      x[right]=tmp ;
      left++;
      right--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var X : long ; X := scanner.getCurrent()->toLong() ;
    var x : Sequence(int) ; x := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     x[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute reverse(x) ; 
    var sum : long ; sum := 0 ;
    var xcum : Sequence(long) ; xcum := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     sum := sum+(x[i+1]) ; 
     xcum[i + 1+1] := sum )  ;     i := i + 1 ) ; 
    var min : long ; min := "9223372036854775807"->toLong() ;
        var k : int ; k := 1 ; while k <= N do ( (     var e : long ; e := compute(xcum, k, N) ;
     if (e < 0) then     continue else skip ; 
    e := e+(k * X) ; 
    e := e+(N * X) ; 
    if (min > e) then     min := e ; else skip ; 
 )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
  static   operation compute( xcum : Sequence(long), k : int, N : int) : long
  pre: true
  post: true
  activity: (     var e : long ; e := 0 ;
     var co : long ; co := 5 ;
         var i : int ; i := 0 ; while i < (N - 1) / k + 1 do ( (     if (i > 1) then     co := co+(2) ; else skip ; 
     e := e+(co * (xcum[Set{k * (i + 1), xcum->size() - 1}->min()+1] - xcum[k * i+1])) ; 
     if (e < 0) then     return -1 else skip )  ;     i := i + 1 ) ; 
     return e );
  static   operation reverse( x : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var left : int ; left := 0 ;
     var right : int ; right := x->size() - 1 ;
     while (left < right) do (     var tmp : int ; tmp := x[left+1] ;
     x[left+1] := x[right+1] ; 
    x[right+1] := tmp ; 
    left := left + 1 ; 
    right := right - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Solution {
  static final int MAX=10000 ;
  static int hashTable[]=new int[MAX];
  static int minOperations(int arr[],int n){
    Arrays.sort(arr);
    for(int i=0 ; i<n ; i++)hashTable[arr[i] ]++;
    int res=0 ;
    for(int i=0 ; i<n ; i++){
      if(hashTable[arr[i] ]!=0){
        for(int j=i ; j<n ; j++)if(arr[j] % arr[i]==0)hashTable[arr[j] ]=0 ;
        res++;
      }
    }
    return res ;
  }
  public static void main(String args[]){
    int arr[]={
      4,6,2,8,7,21,24,49,44 };
      int n=arr.length ;
      System.out.print(minOperations(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Solution {
  static    attribute MAX : int := 10000;
  static   attribute hashTable : int := Integer.subrange(1,MAX)->collect(0);
  static   operation minOperations( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
         var i : int ; i := 0 ; while i < n do (     hashTable[arr[i+1]+1] := hashTable[arr[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (hashTable[arr[i+1]+1] /= 0) then (         var j : int ; j := i ; while j < n do (     if (arr[j+1] mod arr[i+1] = 0) then     hashTable[arr[j+1]+1] := 0 ; else skip ;  ;     j := j + 1 ) ; 
     res := res + 1 ) else skip )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,6,2,8,7,21,24,49,44} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(minOperations(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Word {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String word=in.next();
    int uppercase=0 ;
    int lowercase=0 ;
    for(int i=0 ; i<word.length(); i++){
      char ch=word.charAt(i);
      if(Character.isUpperCase(ch)){
        uppercase++;
      }
      else {
        lowercase++;
      }
    }
    if(uppercase>lowercase)System.out.println(word.toUpperCase());
    else if(lowercase>uppercase)System.out.println(word.toLowerCase());
    else System.out.println(word.toLowerCase());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Word {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var word : String ; word := in.getCurrent() ;
    var uppercase : int ; uppercase := 0 ;
    var lowercase : int ; lowercase := 0 ;
        var i : int ; i := 0 ; while i < word->size() do ( (     var ch : String ; ch := word->at(i+1) ;
     if ((ch->toUpperCase() = ch)) then (     uppercase := uppercase + 1 ) else (     lowercase := lowercase + 1 ) )  ;     i := i + 1 ) ; 
    if (uppercase > lowercase) then     OclFile["System.out"].println(word->toUpperCase()) else     if (lowercase > uppercase) then     OclFile["System.out"].println(word->toLowerCase()) else     OclFile["System.out"].println(word->toLowerCase()) ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int x1=in.nextInt(),y1=in.nextInt(),x2=in.nextInt(),y2=in.nextInt();
    if(x1==x2){
      int dif=Math.abs(y1-y2);
      pw.println((x1+dif)+" "+y1+" "+(x1+dif)+" "+y2);
    }
    else if(y1==y2){
      int dif=Math.abs(x1-x2);
      pw.println((x1)+" "+(y1+dif)+" "+(x2)+" "+(y2+dif));
    }
    else if(Math.abs(x1-x2)==Math.abs(y1-y2)){
      pw.println(x1+" "+y2+" "+x2+" "+y1);
    }
    else {
      pw.println(-1);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var x1 : int ; x1 := in.getCurrent()->toInteger() ;
    var y1 : int ; y1 := in.getCurrent()->toInteger() ;
    var x2 : int ; x2 := in.getCurrent()->toInteger() ;
    var y2 : int ; y2 := in.getCurrent()->toInteger() ;
    if (x1 = x2) then (     var dif : int ; dif := if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif ;
     skip ) else     if (y1 = y2) then (     var dif : int ; dif := if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif ;
     skip ) else     if (if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif = if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif) then (     skip ) else (     skip ) ;  ;  ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int p1=input.nextInt();
    int p2=input.nextInt();
    int p3=input.nextInt();
    int p4=input.nextInt();
    int a=input.nextInt();
    int b=input.nextInt();
    int i ;
    int min=Math.min(Math.min(p1,p2),Math.min(p3,p4));
    int c=0 ;
    for(i=a ; i<=b ; i++){
      if(i<min){
        c++;
      }
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p1 : int ; p1 := input.getCurrent()->toInteger() ;
    var p2 : int ; p2 := input.getCurrent()->toInteger() ;
    var p3 : int ; p3 := input.getCurrent()->toInteger() ;
    var p4 : int ; p4 := input.getCurrent()->toInteger() ;
    var a : int ; a := input.getCurrent()->toInteger() ;
    var b : int ; b := input.getCurrent()->toInteger() ;
    var i : int ;
    var min : int ; min := Set{Set{p1, p2}->min(), Set{p3, p4}->min()}->min() ;
    var c : int ; c := 0 ;
        i := a ; while i <= b do ( (     if (i < min) then (     c := c + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long n=in.nextLong()-1 ;
    for(long i=1 ; i<=n ; i++){
      n-=i ;
    }
    pw.println(n+1);
    pw.close();
  }
  public static long binary_Search(long x){
    long left=0,right=(int)1e14,ans=left ;
    while(left<=right){
      long mid=(left+right)/2 ;
      if(sum(mid)>=x){
        ans=mid ;
        right=mid-1 ;
      }
      else {
        left=mid+1 ;
      }
    }
    return ans ;
  }
  static long sum(long n){
    return(n*(n+1))/2 ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := in.getCurrent()->toLong() - 1 ;
        var i : long ; i := 1 ; while i <= n do ( (     n := n-(i) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation binary_Search( x : long) : long
  pre: true
  post: true
  activity: (     var left : long ; left := 0 ;
    var right : long ; right := 1e14->oclAsType(int) ;
    var ans : long ; ans := left ;
     while (left <= right) do (     var mid : long ; mid := (left + right) / 2 ;
     if (sum(mid) >= x) then (     ans := mid ; 
     right := mid - 1 ) else (     left := mid + 1 ) ) ; 
     return ans );
  static   operation sum( n : long) : long
  pre: true
  post: true
  activity: (     return (n * (n + 1)) / 2 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedOutputStream ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Map ;
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
import java.util.TreeMap ;
public class Practice1 {
  public static void main(String[] args){
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    FastReader sc=new FastReader();
    int p1=sc.nextInt();
    int p2=sc.nextInt();
    int p3=sc.nextInt();
    int p4=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    p1=Math.min(Math.min(p1,p2),Math.min(p3,p4));
    if(p1<=b){
      out.println(Math.max(0,p1-a));
    }
    else {
      out.println(Math.max(0,b-a+1));
    }
    out.close();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var sc : FastReader ; sc := FastReader.newFastReader() ;
    var p1 : int ; p1 := sc.nextInt() ;
    var p2 : int ; p2 := sc.nextInt() ;
    var p3 : int ; p3 := sc.nextInt() ;
    var p4 : int ; p4 := sc.nextInt() ;
    var a : int ; a := sc.nextInt() ;
    var b : int ; b := sc.nextInt() ;
    p1 := Set{Set{p1, p2}->min(), Set{p3, p4}->min()}->min() ; 
    if (p1 <= b) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p033 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p033().run());
  }
  public String run(){
    int numer=1 ;
    int denom=1 ;
    for(int d=10 ; d<100 ; d++){
      for(int n=10 ; n<d ; n++){
        int n0=n % 10,n1=n/10 ;
        int d0=d % 10,d1=d/10 ;
        if(n1==d0 && n0*d==n*d1 || n0==d1 && n1*d==n*d0){
          numer*=n ;
          denom*=d ;
        }
      }
    }
    return Integer.toString(denom/Library.gcd(numer,denom));
  }
}
------------------------------------------------------------
OCL File:
---------
class p033 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p033.newp033().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var numer : int ; numer := 1 ;
     var denom : int ; denom := 1 ;
         var d : int ; d := 10 ; while d < 100 do ( (         var n : int ; n := 10 ; while n < d do ( (     var n0 : int ; n0 := n mod 10 ;
    var n1 : int ; n1 := n / 10 ;
     var d0 : int ; d0 := d mod 10 ;
    var d1 : int ; d1 := d / 10 ;
     if (n1 = d0 & n0 * d = n * d1 or n0 = d1 & n1 * d = n * d0) then (     numer := numer*(n) ; 
     denom := denom*(d) ) else skip )  ;     n := n + 1 ) )  ;     d := d + 1 ) ; 
     return ((denom / Library.gcd(numer, denom)) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countSetBits(int n){
    long count=0 ;
    while(n>0){
      count+=n & 1 ;
      n>>=1 ;
    }
    return(int)count ;
  }
  static int countOfOddsPascal(int n){
    int c=countSetBits(n);
    return(int)Math.pow(2,c);
  }
  public static void main(String[] args){
    int n=20 ;
    System.out.println(countOfOddsPascal(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
     while (n > 0) do (     count := count+(n & 1) ; 
     n := n/(2->pow(1)) ) ; 
     return count->oclAsType(int) );
  static   operation countOfOddsPascal( n : int) : int
  pre: true
  post: true
  activity: (     var c : int ; c := countSetBits(n) ;
     return 2->pow(c)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 20 ;
     OclFile["System.out"].println(countOfOddsPascal(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        int a=sc.nextInt();
        int b=sc.nextInt();
        int x=sc.nextInt();
        int y=sc.nextInt();
        int ans=Math.max(Math.max(x,a-1-x)*b,a*Math.max(y,b-1-y));
        System.out.println(ans);
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := Set{Set{x, a - 1 - x}->max() * b, a * Set{y, b - 1 - y}->max()}->max() ;
    OclFile["System.out"].println(ans) ; 
 ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int o=sc.nextInt();
    while(o-->0){
      int a=sc.nextInt(),b=sc.nextInt();
      int x=sc.nextInt(),y=sc.nextInt();
      int q=(a-1-x)*b,w=x*b,e=(b-1-y)*a,r=y*a ;
      int sum=Math.max(Math.max(q,Math.max(w,e)),r);
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var o : int ; o := sc.getCurrent()->toInteger() ;
         while (o > 0) do (        o := o - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var q : int ; q := (a - 1 - x) * b ;
    var w : int ; w := x * b ;
    var e : int ; e := (b - 1 - y) * a ;
    var r : int ; r := y * a ;
    var sum : int ; sum := Set{Set{q, Set{w, e}->max()}->max(), r}->max() ;
    OclFile["System.out"].println(sum) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javafx.util.Pair ;
import java.util.ArrayList ;
import java.util.*;
class GfG {
  public static int minSwaps(int[] arr){
    int n=arr.length ;
    ArrayList<Pair<Integer,Integer>>arrpos=new ArrayList<Pair<Integer,Integer>>();
    for(int i=0 ; i<n ; i++)arrpos.add(new Pair<Integer,Integer>(arr[i],i));
    arrpos.sort(new Comparator<Pair<Integer,Integer>>(){
      @ Override public int compare(Pair<Integer,Integer>o1,Pair<Integer,Integer>o2){
        if(o1.getKey()>o2.getKey())return-1 ;
        else if(o1.getKey().equals(o2.getKey()))return 0 ;
        else return 1 ;
      }
    }
);
    Boolean[] vis=new Boolean[n];
    Arrays.fill(vis,false);
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(vis[i] || arrpos.get(i).getValue()==i)continue ;
      int cycle_size=0 ;
      int j=i ;
      while(! vis[j]){
        vis[j]=true ;
        j=arrpos.get(j).getValue();
        cycle_size++;
      }
      if(cycle_size>0){
        ans+=(cycle_size-1);
      }
    }
    return ans ;
  }
}
class MinSwaps {
  public static void main(String[] args){
    int[] a={
      1,5,4,3,2 };
      GfG g=new GfG();
      System.out.println(g.minSwaps(a));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation minSwaps( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
     var arrpos : Sequence(Map(String,OclAny)) ; arrpos := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     arrpos := arrpos->including(Tuple(arr[i+1], i)) ;  ;     i := i + 1 ) ; 
    arrpos := arrpos.sort(OclComparator<Map(String,OclAny)>.newOclComparator()) ; 
    var vis : Sequence(Boolean) ; vis := Integer.subrange(1,n)->collect(null) ;
    vis := vis->collect(false) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (vis[i+1] or arrpos->at(i+1).getValue() = i) then     continue else skip ; 
     var cycle_size : int ; cycle_size := 0 ;
    var j : int ; j := i ;
    while (not(vis[j+1])) do (     vis[j+1] := true ; 
     j := arrpos->at(j+1).getValue() ; 
     cycle_size := cycle_size + 1 ) ; 
    if (cycle_size > 0) then (     ans := ans+((cycle_size - 1)) ) else skip ; 
 )  ;     i := i + 1 ) ; 
    return ans 
 );
}
class MinSwaps {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,5,4,3,2} ;
     var g : GfG ; g := GfG.newGfG() ;
     OclFile["System.out"].println(g.minSwaps(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int N=1000005 ;
  static boolean prime[]=new boolean[N];
  static void sieve(){
    Arrays.fill(prime,true);
    prime[1]=false ;
    prime[0]=false ;
    for(int i=2 ; i<N ; i++){
      if(prime[i]){
        for(int j=i*2 ; j<N ; j+=i){
          prime[j]=false ;
        }
      }
    }
  }
  static int sumTruncatablePrimes(int n){
    int sum=0 ;
    for(int i=2 ; i<n ; i++){
      int num=i ;
      boolean flag=true ;
      while(num>0){
        if(! prime[num]){
          flag=false ;
          break ;
        }
        num/=10 ;
      }
      num=i ;
      int power=10 ;
      while(num/power>0){
        if(! prime[num % power]){
          flag=false ;
          break ;
        }
        power*=10 ;
      }
      if(flag){
        sum+=i ;
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=25 ;
    sieve();
    System.out.println(sumTruncatablePrimes(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute N : int := 1000005;
  static   attribute prime : boolean := Integer.subrange(1,N)->collect(false);
  static   operation sieve() : void
  pre: true
  post: true
  activity: (     prime := prime->collect(true) ; 
     prime[1+1] := false ; 
     prime[0+1] := false ; 
         var i : int ; i := 2 ; while i < N do ( (     if (prime[i+1]) then (         var j : int ; j := i * 2 ; while j < N do ( (     prime[j+1] := false )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) );
  static   operation sumTruncatablePrimes( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 2 ; while i < n do ( (     var num : int ; num := i ;
     var flag : boolean ; flag := true ;
    while (num > 0) do (     if (not(prime[num+1])) then (     flag := false ; 
     break ) else skip ; 
     num := num/(10) ) ; 
    num := i ; 
    var power : int ; power := 10 ;
    while (num / power > 0) do (     if (not(prime[num mod power+1])) then (     flag := false ; 
     break ) else skip ; 
     power := power*(10) ) ; 
    if (flag) then (     sum := sum+(i) ) else skip ; 
 )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 25 ;
     execute sieve() ; 
     OclFile["System.out"].println(sumTruncatablePrimes(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GFG {
  static void findWeights(int X){
    int sum=0 ;
    int power=0 ;
    int number=3 ;
    while(sum<X){
      sum=number-1 ;
      sum/=2 ;
      power++;
      number*=3 ;
    }
    int ans=1 ;
    for(int i=1 ; i<=power ; i++){
      System.out.print(ans+" ");
      ans=ans*3 ;
    }
  }
  public static void main(String[] args){
    int X=2 ;
    findWeights(X);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findWeights( X : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var power : int ; power := 0 ;
    var number : int ; number := 3 ;
    while (sum < X) do (     sum := number - 1 ; 
     sum := sum/(2) ; 
     power := power + 1 ; 
     number := number*(3) ) ; 
    var ans : int ; ans := 1 ;
        var i : int ; i := 1 ; while i <= power do ( (     OclFile["System.out"].print(ans + " ") ; 
     ans := ans * 3 )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 2 ;
     execute findWeights(X) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PashmakAndGarden {
  private static void printIntArrayOnSameLine(int[] nums){
    StringBuilder stringBuilder=new StringBuilder();
    for(int n : nums){
      if(stringBuilder.length()>0)stringBuilder.append(" ");
      stringBuilder.append(n);
    }
    System.out.println(stringBuilder);
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int x1=scanner.nextInt(),y1=scanner.nextInt(),x2=scanner.nextInt(),y2=scanner.nextInt();
    if(x1==x2){
      printIntArrayOnSameLine(new int[] {
        x1+y2-y1,y1,x2+y2-y1,y2 }
);
      }
      else if(y1==y2){
        printIntArrayOnSameLine(new int[] {
          x1,y1+x2-x1,x2,y2+x2-x1 }
);
        }
        else if(Math.abs(x1-x2)==Math.abs(y1-y2)){
          printIntArrayOnSameLine(new int[] {
            x1,y2,x2,y1 }
);
          }
          else {
            System.out.println(-1);
          }
          scanner.close();
        }
      }

------------------------------------------------------------
OCL File:
---------
 class PashmakAndGarden {
  static   operation printIntArrayOnSameLine( nums : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var stringBuilder : String ; stringBuilder := StringLib.newString() ;
     for (n : nums) do ( (     if (stringBuilder->size() > 0) then     stringBuilder := stringBuilder + StringLib.newString(" ") ; else skip ; 
     stringBuilder := stringBuilder + StringLib.newString(n) )  ) ; 
     OclFile["System.out"].println(stringBuilder) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : int ; x1 := scanner.getCurrent()->toInteger() ;
    var y1 : int ; y1 := scanner.getCurrent()->toInteger() ;
    var x2 : int ; x2 := scanner.getCurrent()->toInteger() ;
    var y2 : int ; y2 := scanner.getCurrent()->toInteger() ;
     if (x1 = x2) then (     execute printIntArrayOnSameLine(Sequence{x1 + y2 - y1,y1,x2 + y2 - y1,y2}) ) else     if (y1 = y2) then (     execute printIntArrayOnSameLine(Sequence{x1,y1 + x2 - x1,x2,y2 + x2 - x1}) ) else     if (if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif = if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif) then (     execute printIntArrayOnSameLine(Sequence{x1,y2,x2,y1}) ) else (     OclFile["System.out"].println(-1) ) ;  ;  ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static ArrayList<Integer>addToArrayForm(ArrayList<Integer>A,int K){
    ArrayList<Integer>v=new ArrayList<Integer>();
    ArrayList<Integer>ans=new ArrayList<Integer>();
    int rem=0 ;
    int i=0 ;
    for(i=A.size()-1 ; i>=0 ; i--){
      int my=A.get(i)+K % 10+rem ;
      if(my>9){
        rem=1 ;
        v.add(my % 10);
      }
      else {
        v.add(my);
        rem=0 ;
      }
      K=K/10 ;
    }
    while(K>0){
      int my=K % 10+rem ;
      v.add(my % 10);
      if(my/10>0)rem=1 ;
      else rem=0 ;
      K=K/10 ;
    }
    if(rem>0)v.add(rem);
    for(int j=v.size()-1 ; j>=0 ; j--)ans.add(v.get(j));
    return ans ;
  }
  public static void main(String[] args){
    ArrayList<Integer>A=new ArrayList<Integer>();
    A.add(2);
    A.add(7);
    A.add(4);
    int K=181 ;
    ArrayList<Integer>ans=addToArrayForm(A,K);
    for(int i=0 ; i<ans.size(); i++)System.out.print(ans.get(i));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation addToArrayForm( A : Sequence(int), K : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Sequence{} ;
     var ans : Sequence(int) ; ans := Sequence{} ;
    var rem : int ; rem := 0 ;
    var i : int ; i := 0 ;
        i := A->size() - 1 ; while i >= 0 do ( (     var my : int ; my := A->at(i+1) + K mod 10 + rem ;
     if (my > 9) then (     rem := 1 ; 
     v := v->including(my mod 10) ) else (     v := v->including(my) ; 
     rem := 0 ) ;  
     K := K / 10 )  ;     i := i - 1 ) ; 
    while (K > 0) do (     var my : int ; my := K mod 10 + rem ;
     v := v->including(my mod 10) ; 
     if (my / 10 > 0) then     rem := 1 else     rem := 0 ; ;  
     K := K / 10 ) ; 
    if (rem > 0) then     v := v->including(rem) ; else skip ; 
        var j : int ; j := v->size() - 1 ; while j >= 0 do (     ans := ans->including(v->at(j+1)) ;  ;     j := j - 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{} ;
     A := A->including(2) ; 
    A := A->including(7) ; 
    A := A->including(4) ; 
    var K : int ; K := 181 ;
    var ans : Sequence(int) ; ans := addToArrayForm(A, K) ;
        var i : int ; i := 0 ; while i < ans->size() do (     OclFile["System.out"].print(ans->at(i+1)) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  private static void printPaths(char[][] input,int R,int C){
    for(int i=0 ; i<C ; i++){
      dfs(input,"",0,i,R,C);
      System.out.println();
    }
  }
  private static void dfs(char[][] input,String res,int i,int j,int R,int C){
    if(i==R){
      System.out.print(res+" ");
      return ;
    }
    res=res+input[i][j];
    for(int k=0 ; k<C ; k++){
      dfs(input,res,i+1,k,R,C);
      if(i+1==R){
        break ;
      }
    }
  }
  public static void main(String[] args){
    char[][] input={
      {
        'a','b' },{
          'd','e' }
        };
        int R=input.length ;
        int C=input[0] .length ;
        printPaths(input,R,C);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printPaths( input : Sequence(Sequence(String)), R : int, C : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < C do ( (     execute dfs(input, "", 0, i, R, C) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation dfs( input : Sequence(Sequence(String)), res : String, i : int, j : int, R : int, C : int) : void
  pre: true
  post: true
  activity: (     if (i = R) then (     OclFile["System.out"].print(res + " ") ; 
     return ) else skip ; 
     res := res + input[i+1][j+1] ; 
         var k : int ; k := 0 ; while k < C do ( (     execute dfs(input, res, i + 1, k, R, C) ; 
     if (i + 1 = R) then (     break ) else skip )  ;     k := k + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : Sequence(Sequence(String)) ; input := Sequence{Sequence{'a','b'},Sequence{'d','e'}} ;
     var R : int ; R := input->size() ;
     var C : int ; C := input[0+1]->size() ;
     execute printPaths(input, R, C) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      arr[i]=arr[i]-1 ;
    }
    boolean lt=false ;
    for(int i=0 ; i<n ; i++){
      if(i==arr[arr[arr[i] ] ]){
        lt=true ;
        break ;
      }
    }
    if(lt)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     arr[i+1] := arr[i+1] - 1 )  ;     i := i + 1 ) ; 
    var lt : boolean ; lt := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (i = arr[arr[arr[i+1]+1]+1]) then (     lt := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (lt) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int num=Integer.parseInt(sc.nextLine());
    String line=sc.nextLine();
    int[] hotel=new int[10];
    for(int i=0 ; i<num ; i++){
      char actual=line.charAt(i);
      if(actual=='L'){
        boolean bb=true ;
        for(int pos=0 ; pos<10 && bb==true ; pos++){
          if(hotel[pos]==0){
            hotel[pos]=1 ;
            bb=false ;
          }
        }
      }
      else {
        if(actual=='R'){
          boolean bb=true ;
          for(int pos=9 ; pos>=0 && bb==true ; pos--){
            if(hotel[pos]==0){
              hotel[pos]=1 ;
              bb=false ;
            }
          }
        }
        else {
          int pos=Integer.parseInt(actual+"");
          hotel[pos]=0 ;
        }
      }
    }
    StringBuilder res=new StringBuilder();
    for(int x : hotel){
      res.append(x);
    }
    System.out.println(res.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := (sc.nextLine())->toInteger() ;
    var line : String ; line := sc.nextLine() ;
    var hotel : Sequence(int) ; hotel := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < num do ( (     var actual : String ; actual := line->at(i+1) ;
     if (actual = 'L') then (     var bb : boolean ; bb := true ;
         var pos : int ; pos := 0 ; while pos < 10 & bb = true do ( (     if (hotel[pos+1] = 0) then (     hotel[pos+1] := 1 ; 
     bb := false ) else skip )  ;     pos := pos + 1 ) ) else (     if (actual = 'R') then (     var bb : boolean ; bb := true ;
         var pos : int ; pos := 9 ; while pos >= 0 & bb = true do ( (     if (hotel[pos+1] = 0) then (     hotel[pos+1] := 1 ; 
     bb := false ) else skip )  ;     pos := pos - 1 ) ) else (     var pos : int ; pos := (actual + "")->toInteger() ;
     hotel[pos+1] := 0 ) ) )  ;     i := i + 1 ) ; 
    var res : String ; res := StringLib.newString() ;
    for (x : hotel) do ( (     res := res + StringLib.newString(x) )  ) ; 
    OclFile["System.out"].println(res+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1200A_Hotelier {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int len=input.nextInt();
    String str=input.next();
    Integer[] chars=new Integer[10];
    for(int i=0 ; i<10 ; i++){
      chars[i]=0 ;
    }
    List<Integer>list=new ArrayList<>(Arrays.asList(chars));
    for(char c : str.toCharArray()){
      if(c=='L'){
        list.set(list.indexOf(0),1);
      }
      else if(c=='R'){
        list.set(list.lastIndexOf(0),1);
      }
      else if(Character.isDigit(c)){
        int index=c-'0' ;
        list.set(index,0);
      }
    }
    System.out.println(list.toString().replaceAll("[\\[\\],] ",""));
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1200A_Hotelier {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := input.getCurrent()->toInteger() ;
    var str : String ; str := input.getCurrent() ;
    var chars : Sequence(int) ; chars := Integer.subrange(1,10)->collect(null) ;
        var i : int ; i := 0 ; while i < 10 do ( (     chars[i+1] := 0 )  ;     i := i + 1 ) ; 
    var list : Sequence(int) ; list := Sequence{}->union(chars) ;
    for (c : str->characters()) do ( (     if (c = 'L') then (     list := list.setAt(list->indexOf(0)-1+1,1) ) else     if (c = 'R') then (     list := list.setAt(list->lastIndexOf(0)-1+1,1) ) else     if ((c + "")->isMatch("[0-9]")) then (     var index : int ; index := c - ('0')->char2byte() ;
     list := list.setAt(index+1,0) ) else skip ; ;  )  ) ; 
    OclFile["System.out"].println(list+"".replaceAllMatches("[\\[\\],] ", "" )) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class hotel {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,i ;
    String s ;
    n=sc.nextInt();
    s=sc.next();
    List<Integer>a=new ArrayList<>();
    for(i=0 ; i<10 ; i++)a.add(0);
    for(i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='L')a.set(a.indexOf(0),1);
      else if(s.charAt(i)=='R')a.set(a.lastIndexOf(0),1);
      else a.set(s.charAt(i)-48,0);
    }
    for(i=0 ; i<a.size(); i++)System.out.print(a.get(i));
  }
}
------------------------------------------------------------
OCL File:
---------
 class hotel {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var i : int ;
    var s : String ;
    n := sc.getCurrent()->toInteger() ; 
    s := sc.getCurrent() ; 
    var a : Sequence(int) ; a := Sequence{} ;
        i := 0 ; while i < 10 do (     a := a->including(0) ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'L') then     a := a.setAt(a->indexOf(0)-1+1,1) ; else     if (s->at(i+1) = 'R') then     a := a.setAt(a->lastIndexOf(0)-1+1,1) else     a := a.setAt(s->at(i+1) - 48+1,0) ; ;  )  ;     i := i + 1 ) ; 
        i := 0 ; while i < a->size() do (     OclFile["System.out"].print(a->at(i+1)) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a=sc.nextLong();
    double b=sc.nextDouble();
    long c=(long)Math.round(b*100);
    long d=a*c ;
    System.out.println(d/100);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : double ; b := sc.getCurrent()->toReal() ;
    var c : long ; c := (b * 100)->round()->oclAsType(long) ;
    var d : long ; d := a * c ;
    OclFile["System.out"].println(d / 100) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigDecimal ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    Main mainObj=new Main();
    mainObj.solve();
  }
  public void solve()throws IOException {
    FastScanner fs=new FastScanner();
    BigDecimal a=new BigDecimal(fs.next());
    BigDecimal b=new BigDecimal(fs.next());
    long ans=a.multiply(b).longValue();
    System.out.println(ans);
  }
  public class FastScanner {
    BufferedReader reader ;
    private StringTokenizer st ;
    public FastScanner(){
      st=null ;
      reader=new BufferedReader(new InputStreamReader(System.in));
    }
    public String next()throws IOException {
      if(st==null || ! st.hasMoreElements()){
        st=new StringTokenizer(reader.readLine());
      }
      return st.nextToken();
    }
    public String nextLine()throws IOException {
      st=null ;
      String readLine=null ;
      readLine=reader.readLine();
      return readLine ;
    }
    public int nextInt()throws NumberFormatException,IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws NumberFormatException,IOException {
      return Long.parseLong(next());
    }
    public int[] nextIntArr(int n)throws NumberFormatException,IOException {
      int[] retArr=new int[n];
      for(int i=0 ; i<n ; i++){
        retArr[i]=nextInt();
      }
      return retArr ;
    }
    public long[] nextLongArr(int n)throws NumberFormatException,IOException {
      long[] retArr=new long[n];
      for(int i=0 ; i<n ; i++){
        retArr[i]=nextLong();
      }
      return retArr ;
    }
    public void close()throws IOException {
      reader.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mainObj : Main ; mainObj := Main.newMain() ;
     mainObj.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var a : double ; a := double(fs.next()) ;
    var b : double ; b := double(fs.next()) ;
    var ans : long ; ans := a.multiply(b)->oclAsType(long) ;
    OclFile["System.out"].println(ans) ; 
 );
 class FastScanner {
   attribute reader : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     st := null ; 
     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (st = null or not(st.hasNext())) then (     st := OclIterator.newOclIterator_String(reader.readLine()) ) else skip ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     st := null ; 
     var readLine : String ; readLine := null ;
     readLine := reader.readLine() ; 
     return readLine );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextIntArr( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var retArr : Sequence(int) ; retArr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     retArr[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return retArr );
   operation nextLongArr( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var retArr : Sequence(long) ; retArr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     retArr[i+1] := nextLong() )  ;     i := i + 1 ) ; 
     return retArr );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.math.RoundingMode ;
import java.util.Scanner ;
public class Main {
  private static final int MOD=1_000_000_007 ;
  private static final String YES="Yes" ;
  private static final String NO="No" ;
  private static final double eps=0.0001 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long A=sc.nextLong();
    double B=sc.nextDouble();
    System.out.println(solve2(A,B));
  }
  private static String solve(long A,double B){
    BigDecimal b=BigDecimal.valueOf(A);
    b=b.multiply(BigDecimal.valueOf(B));
    return b.setScale(0,RoundingMode.DOWN).toString();
  }
  private static long solve2(long A,double B){
    int b100=(int)(B*100+eps);
    return A*b100/100 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1_000_000_007;
  static    attribute YES : String := "Yes";
  static    attribute NO : String := "No";
  static    attribute eps : double := 0.0001;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : long ; A := sc.getCurrent()->toLong() ;
     var B : double ; B := sc.getCurrent()->toReal() ;
     OclFile["System.out"].println(solve2(A, B)) );
  static   operation solve( A : long, B : double) : String
  pre: true
  post: true
  activity: (     var b : double ; b := (A + "")->toReal() ;
     b := b.multiply((B + "")->toReal()) ; 
     return b.setScale(0, RoundingMode.DOWN)+"" );
  static   operation solve2( A : long, B : double) : long
  pre: true
  post: true
  activity: (     var b100 : int ; b100 := (B * 100 + eps)->oclAsType(int) ;
     return A * b100 / 100 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a=sc.nextLong();
    String b=sc.next();
    char[] bChar=b.toCharArray();
    int length=bChar.length ;
    String bStr="" ;
    for(int i=0 ; i<length ; i++){
      if(bChar[i]!='.'){
        bStr+=bChar[i];
      }
    }
    int bInt=Integer.parseInt(bStr);
    long result=(a*bInt)/100 ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : String ; b := sc.getCurrent() ;
    var bChar : Sequence(String) ; bChar := b->characters() ;
    var length : int ; length := bChar->size() ;
    var bStr : String ; bStr := "" ;
        var i : int ; i := 0 ; while i < length do ( (     if (bChar[i+1] /= '.') then (     bStr := bStr+(bChar[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    var bInt : int ; bInt := (bStr)->toInteger() ;
    var result : long ; result := (a * bInt) / 100 ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PashmakAndGarden {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int x1=s.nextInt();
    int y1=s.nextInt();
    int x2=s.nextInt();
    int y2=s.nextInt();
    if(x1==x2){
      int dis=(int)Math.sqrt(Math.pow(y2-y1,2)+Math.pow(x1-x2,2));
      int x3=x1+dis ;
      int y3=y1 ;
      int x4=x2+dis ;
      int y4=y2 ;
      System.out.println(x3+" "+y3+" "+x4+" "+y4);
    }
    else if(y1==y2){
      int dis=(int)Math.sqrt(Math.pow(y2-y1,2)+Math.pow(x1-x2,2));
      int x3=x1 ;
      int y3=y1+dis ;
      int x4=x2 ;
      int y4=y2+dis ;
      System.out.println(x3+" "+y3+" "+x4+" "+y4);
    }
    else {
      int x3=0,y3=0,x4=0,y4=0 ;
      if((x1>x2 && y1>y2)||(x1<x2 && y1>y2)){
        x3=x2 ;
        y3=y1 ;
        x4=x1 ;
        y4=y2 ;
      }
      else if((x1>x2 && y1<y2)||(x1<x2 && y1<y2)){
        x3=x1 ;
        y3=y2 ;
        x4=x2 ;
        y4=y1 ;
      }
      if(Math.sqrt(Math.pow(y3-y1,2)+Math.pow(x1-x3,2))==Math.sqrt(Math.pow(y4-y1,2)+Math.pow(x1-x4,2))){
        System.out.println(x3+" "+y3+" "+x4+" "+y4);
      }
      else {
        System.out.println("-1");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PashmakAndGarden {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : int ; x1 := s.getCurrent()->toInteger() ;
    var y1 : int ; y1 := s.getCurrent()->toInteger() ;
    var x2 : int ; x2 := s.getCurrent()->toInteger() ;
    var y2 : int ; y2 := s.getCurrent()->toInteger() ;
    if (x1 = x2) then (     var dis : int ; dis := (y2 - y1->pow(2) + x1 - x2->pow(2))->sqrt()->oclAsType(int) ;
     var x3 : int ; x3 := x1 + dis ;
    var y3 : int ; y3 := y1 ;
    var x4 : int ; x4 := x2 + dis ;
    var y4 : int ; y4 := y2 ;
    OclFile["System.out"].println(x3 + " " + y3 + " " + x4 + " " + y4) ; 
 ) else     if (y1 = y2) then (     var dis : int ; dis := (y2 - y1->pow(2) + x1 - x2->pow(2))->sqrt()->oclAsType(int) ;
     var x3 : int ; x3 := x1 ;
    var y3 : int ; y3 := y1 + dis ;
    var x4 : int ; x4 := x2 ;
    var y4 : int ; y4 := y2 + dis ;
    OclFile["System.out"].println(x3 + " " + y3 + " " + x4 + " " + y4) ; 
 ) else (     var x3 : int ; x3 := 0 ;
    var y3 : int ; y3 := 0 ;
    var x4 : int ; x4 := 0 ;
    var y4 : int ; y4 := 0 ;
     if ((x1 > x2 & y1 > y2) or (x1 < x2 & y1 > y2)) then (     x3 := x2 ; 
     y3 := y1 ; 
     x4 := x1 ; 
     y4 := y2 ) else     if ((x1 > x2 & y1 < y2) or (x1 < x2 & y1 < y2)) then (     x3 := x1 ; 
     y3 := y2 ; 
     x4 := x2 ; 
     y4 := y1 ) else skip ; ;  
     if ((y3 - y1->pow(2) + x1 - x3->pow(2))->sqrt() = (y4 - y1->pow(2) + x1 - x4->pow(2))->sqrt()) then (     OclFile["System.out"].println(x3 + " " + y3 + " " + x4 + " " + y4) ) else (     OclFile["System.out"].println("-1") ) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long a=Long.parseLong(in.next());
    String b=in.next();
    long bb=0 ;
    int times=100 ;
    for(int i=0 ; i<4 ; i++){
      if(! b.substring(i,i+1).equals(".")){
        bb+=times*Integer.parseInt(b.substring(i,i+1));
        times/=10 ;
      }
    }
    long c=a*bb ;
    c-=c % 100 ;
    c/=100 ;
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := (in.getCurrent())->toLong() ;
    var b : String ; b := in.getCurrent() ;
    var bb : long ; bb := 0 ;
    var times : int ; times := 100 ;
        var i : int ; i := 0 ; while i < 4 do ( (     if (not(b.subrange(i+1,i + 1) = ".")) then (     bb := bb+(times * (b.subrange(i+1,i + 1))->toInteger()) ; 
     times := times/(10) ) else skip )  ;     i := i + 1 ) ; 
    var c : long ; c := a * bb ;
    c := c-(c mod 100) ; 
    c := c/(100) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class B_Square {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int T=reader.nextInt();
    while(T!=0){
      T--;
      int a1=reader.nextInt();
      int b1=reader.nextInt();
      int a2=reader.nextInt();
      int b2=reader.nextInt();
      int[] r1=new int[] {
        Math.min(a1,b1),Math.max(a1,b1)};
        int[] r2=new int[] {
          Math.min(a2,b2),Math.max(a2,b2)};
          if(r1[0]==r2[0] && r1[1]+r2[1]==r1[0]){
            System.out.println("Yes");
          }
          else if(r1[1]==r2[1] && r1[0]+r2[0]==r1[1]){
            System.out.println("Yes");
          }
          else {
            System.out.println("No");
          }
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class B_Square {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var T : int ; T := reader.nextInt() ;
     while (T /= 0) do (     T := T - 1 ; 
     var a1 : int ; a1 := reader.nextInt() ;
    var b1 : int ; b1 := reader.nextInt() ;
    var a2 : int ; a2 := reader.nextInt() ;
    var b2 : int ; b2 := reader.nextInt() ;
    var r1 : Sequence(int) ; r1 := Sequence{Set{a1, b1}->min(),Set{a1, b1}->max()} ;
    var r2 : Sequence(int) ; r2 := Sequence{Set{a2, b2}->min(),Set{a2, b2}->max()} ;
    if (r1[0+1] = r2[0+1] & r1[1+1] + r2[1+1] = r1[0+1]) then (     OclFile["System.out"].println("Yes") ) else     if (r1[1+1] = r2[1+1] & r1[0+1] + r2[0+1] = r1[1+1]) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.nio.charset.MalformedInputException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter o=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int a1=sc.nextInt(),a2=sc.nextInt(),b1=sc.nextInt(),b2=sc.nextInt();
      if(Math.max(a1,a2)==Math.max(b1,b2)&&(Math.min(a1,a2)+Math.min(b1,b2)==Math.max(a1,a2))){
        o.println("Yes");
      }
      else {
        o.println("No");
      }
    }
    o.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var o : OclFile ; o := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var a1 : int ; a1 := sc.getCurrent()->toInteger() ;
    var a2 : int ; a2 := sc.getCurrent()->toInteger() ;
    var b1 : int ; b1 := sc.getCurrent()->toInteger() ;
    var b2 : int ; b2 := sc.getCurrent()->toInteger() ;
     if (Set{a1, a2}->max() = Set{b1, b2}->max() & (Set{a1, a2}->min() + Set{b1, b2}->min() = Set{a1, a2}->max())) then (     skip ) else (     skip ) ) ;  ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A_Love_Triangle {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    Vector<Integer>v=new Vector<>();
    for(int i=0 ; i<n ; i++){
      v.add(s.nextInt());
    }
    int a=0,b=0,c=0,d=0 ;
    for(int i=0 ; i<n ; i++){
      a=v.get(i);
      b=v.get(a-1);
      c=v.get(b-1);
      d=v.get(c-1);
      if(d==a){
        break ;
      }
    }
    if(d==a){
      System.out.println("YES");
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Love_Triangle {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var v : Sequence(int) ; v := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     v := v->including(s.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
    var c : int ; c := 0 ;
    var d : int ; d := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a := v->at(i+1) ; 
     b := v->at(a - 1+1) ; 
    c := v->at(b - 1+1) ; 
    d := v->at(c - 1+1) ; 
    if (d = a) then (     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (d = a) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B1351 {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    for(int i=0 ; i<t ; i++){
      StringTokenizer st=new StringTokenizer(br.readLine());
      int a1=Integer.parseInt(st.nextToken()),b1=Integer.parseInt(st.nextToken());
      st=new StringTokenizer(br.readLine());
      int a2=Integer.parseInt(st.nextToken()),b2=Integer.parseInt(st.nextToken());
      System.out.println(solve(a1,b1,a2,b2));
    }
  }
  public static String solve(int a1,int b1,int a2,int b2){
    int biggerSide1=0,smallerSide1=0,biggerSide2=0,smallerSide2=0 ;
    if(a1>b1){
      biggerSide1=a1 ;
      smallerSide1=b1 ;
    }
    else {
      biggerSide1=b1 ;
      smallerSide1=a1 ;
    }
    if(a2>b2){
      biggerSide2=a2 ;
      smallerSide2=b2 ;
    }
    else {
      biggerSide2=b2 ;
      smallerSide2=a2 ;
    }
    if(smallerSide1+smallerSide2==biggerSide1 && smallerSide1+smallerSide2==biggerSide2){
      return "YES" ;
    }
    else {
      return "NO" ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1351 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var a1 : int ; a1 := (st.next())->toInteger() ;
    var b1 : int ; b1 := (st.next())->toInteger() ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    var a2 : int ; a2 := (st.next())->toInteger() ;
    var b2 : int ; b2 := (st.next())->toInteger() ;
    OclFile["System.out"].println(solve(a1, b1, a2, b2)) ; 
 )  ;     i := i + 1 ) );
  static   operation solve( a1 : int, b1 : int, a2 : int, b2 : int) : String
  pre: true
  post: true
  activity: (     var biggerSide1 : int ; biggerSide1 := 0 ;
    var smallerSide1 : int ; smallerSide1 := 0 ;
    var biggerSide2 : int ; biggerSide2 := 0 ;
    var smallerSide2 : int ; smallerSide2 := 0 ;
     if (a1 > b1) then (     biggerSide1 := a1 ; 
     smallerSide1 := b1 ) else (     biggerSide1 := b1 ; 
     smallerSide1 := a1 ) ;  
     if (a2 > b2) then (     biggerSide2 := a2 ; 
     smallerSide2 := b2 ) else (     biggerSide2 := b2 ; 
     smallerSide2 := a2 ) ;  
     if (smallerSide1 + smallerSide2 = biggerSide1 & smallerSide1 + smallerSide2 = biggerSide2) then (     return "YES" ) else (     return "NO" ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem4 {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int no=input.nextInt();
    while(no-->0){
      int n1=input.nextInt();
      int n2=input.nextInt();
      int n3=input.nextInt();
      int n4=input.nextInt();
      if(n1==n3 &&(n2+n4==n1))System.out.println("Yes");
      else if(n1==n4 &&(n2+n3==n1))System.out.println("Yes");
      else if(n2==n3 &&(n1+n4==n2))System.out.println("Yes");
      else if(n2==n4 &&(n1+n3==n2))System.out.println("Yes");
      else System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem4 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var no : int ; no := input.getCurrent()->toInteger() ;
         while (no > 0) do (        no := no - 1 ;     skip ; (     var n1 : int ; n1 := input.getCurrent()->toInteger() ;
     var n2 : int ; n2 := input.getCurrent()->toInteger() ;
    var n3 : int ; n3 := input.getCurrent()->toInteger() ;
    var n4 : int ; n4 := input.getCurrent()->toInteger() ;
    if (n1 = n3 & (n2 + n4 = n1)) then     OclFile["System.out"].println("Yes") else     if (n1 = n4 & (n2 + n3 = n1)) then     OclFile["System.out"].println("Yes") else     if (n2 = n3 & (n1 + n4 = n2)) then     OclFile["System.out"].println("Yes") else     if (n2 = n4 & (n1 + n3 = n2)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  ;  ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Eulerian {
  public static void precisionCompute(int x,int y,int n){
    if(y==0){
      System.out.print("Infinite");
      return ;
    }
    if(x==0){
      System.out.print("0");
      return ;
    }
    if(n<=0){
      System.out.print(x/y);
      return ;
    }
    if(((x>0)&&(y<0))||((x<0)&&(y>0))){
      System.out.print("-");
      x=x>0 ? x :-x ;
      y=y>0 ? y :-y ;
    }
    int d=x/y ;
    for(int i=0 ; i<=n ; i++){
      System.out.print(d);
      x=x-(y*d);
      if(x==0)break ;
      x=x*10 ;
      d=x/y ;
      if(i==0)System.out.print(".");
    }
  }
  public static void main(String[] args){
    int x=22,y=7,n=15 ;
    precisionCompute(x,y,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Eulerian {
  static   operation precisionCompute( x : int, y : int, n : int) : void
  pre: true
  post: true
  activity: (     if (y = 0) then (     OclFile["System.out"].print("Infinite") ; 
     return ) else skip ; 
     if (x = 0) then (     OclFile["System.out"].print("0") ; 
     return ) else skip ; 
    if (n <= 0) then (     OclFile["System.out"].print(x / y) ; 
     return ) else skip ; 
    if (((x > 0) & (y < 0)) or ((x < 0) & (y > 0))) then (     OclFile["System.out"].print("-") ; 
     x := if x > 0 then x else -x endif ; 
     y := if y > 0 then y else -y endif ) else skip ; 
    var d : int ; d := x / y ;
        var i : int ; i := 0 ; while i <= n do ( (     OclFile["System.out"].print(d) ; 
     x := x - (y * d) ; 
    if (x = 0) then     break else skip ; 
    x := x * 10 ; 
    d := x / y ; 
    if (i = 0) then     OclFile["System.out"].print(".") ; else skip ; 
 )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 22 ;
    var y : int ; y := 7 ;
    var n : int ; n := 15 ;
     execute precisionCompute(x, y, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int gcd(int a,int b){
    if(b==0)return a ;
    else return gcd(b,a % b);
  }
  static int lcmOfArray(int arr[],int n){
    if(n<1)return 0 ;
    int lcm=arr[0];
    for(int i=1 ; i<n ; i++)lcm=(lcm*arr[i])/gcd(lcm,arr[i]);
    return lcm ;
  }
  static int minPerfectCube(int arr[],int n){
    int minPerfectCube ;
    int lcm=lcmOfArray(arr,n);
    minPerfectCube=lcm ;
    int cnt=0 ;
    while(lcm>1 && lcm % 2==0){
      cnt++;
      lcm/=2 ;
    }
    if(cnt % 3==2)minPerfectCube*=2 ;
    else if(cnt % 3==1)minPerfectCube*=4 ;
    int i=3 ;
    while(lcm>1){
      cnt=0 ;
      while(lcm % i==0){
        cnt++;
        lcm/=i ;
      }
      if(cnt % 3==1)minPerfectCube*=i*i ;
      else if(cnt % 3==2)minPerfectCube*=i ;
      i+=2 ;
    }
    return minPerfectCube ;
  }
  public static void main(String args[]){
    int arr[]={
      10,125,14,42,100 };
      int n=arr.length ;
      System.out.println(minPerfectCube(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else     return gcd(b, a mod b) );
  static   operation lcmOfArray( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n < 1) then     return 0 else skip ; 
     var lcm : int ; lcm := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do (     lcm := (lcm * arr[i+1]) / gcd(lcm, arr[i+1]) ;  ;     i := i + 1 ) ; 
     return lcm );
  static   operation minPerfectCube( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var minPerfectCube : int ;
     var lcm : int ; lcm := lcmOfArray(arr, n) ;
    minPerfectCube := lcm ; 
    var cnt : int ; cnt := 0 ;
    while (lcm > 1 & lcm mod 2 = 0) do (     cnt := cnt + 1 ; 
     lcm := lcm/(2) ) ; 
    if (cnt mod 3 = 2) then     minPerfectCube := minPerfectCube*(2) else     if (cnt mod 3 = 1) then     minPerfectCube := minPerfectCube*(4) ; else skip ; ;  
    var i : int ; i := 3 ;
    while (lcm > 1) do (     cnt := 0 ; 
     while (lcm mod i = 0) do (     cnt := cnt + 1 ; 
     lcm := lcm/(i) ) ; 
     if (cnt mod 3 = 1) then     minPerfectCube := minPerfectCube*(i * i) else     if (cnt mod 3 = 2) then     minPerfectCube := minPerfectCube*(i) ; else skip ; ;  
     i := i+(2) ) ; 
    return minPerfectCube 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,125,14,42,100} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minPerfectCube(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void hollowSquare(int rows){
    int i,j ;
    for(i=1 ; i<=rows ; i++){
      if(i==1 || i==rows)for(j=1 ;
      j<=rows ;
      j++)System.out.print("*");
      else for(j=1 ;
      j<=rows ;
      j++)if(j==1 || j==rows)System.out.print("*");
      else System.out.print(" ");
      System.out.print("\n");
    }
  }
  static void solidSquare(int rows){
    int i,j ;
    for(i=1 ; i<=rows ; i++){
      for(j=1 ; j<=rows ; j++)System.out.print("*");
      System.out.print("\n");
    }
  }
  static void printPattern(int rows){
    System.out.print("\nSolid Square:\n");
    solidSquare(rows);
    System.out.print("\nHollow Square:\n");
    hollowSquare(rows);
  }
  public static void main(String[] args){
    int rows=5 ;
    printPattern(rows);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation hollowSquare( rows : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := 1 ; while i <= rows do ( (     if (i = 1 or i = rows) then         j := 1 ; while j <= rows do (     OclFile["System.out"].print("*") ;  ;     j := j + 1 ) else         j := 1 ; while j <= rows do (     if (j = 1 or j = rows) then     OclFile["System.out"].print("*") else     OclFile["System.out"].print(" ") ; ;   ;     j := j + 1 ) ; ;  
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) );
  static   operation solidSquare( rows : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := 1 ; while i <= rows do ( (         j := 1 ; while j <= rows do (     OclFile["System.out"].print("*") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) );
  static   operation printPattern( rows : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("\nSolid Square:\n") ; 
     execute solidSquare(rows) ; 
     OclFile["System.out"].print("\nHollow Square:\n") ; 
     execute hollowSquare(rows) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var rows : int ; rows := 5 ;
     execute printPattern(rows) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class PashmakandGarden {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int x1,y1,x2,y2 ;
    x1=Integer.parseInt(st.nextToken());
    y1=Integer.parseInt(st.nextToken());
    x2=Integer.parseInt(st.nextToken());
    y2=Integer.parseInt(st.nextToken());
    if(x1==x2)System.out.println((y1-y2+x1)+" "+y1+" "+(y1-y2+x2)+" "+y2);
    else if(y1==y2)System.out.println((x1)+" "+(y1+x1-x2)+" "+x2+" "+(y2+x1-x2));
    else if(Math.abs(x1-x2)==Math.abs(y1-y2))System.out.println(x1+" "+y2+" "+x2+" "+y1);
    else System.out.println("-1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class PashmakandGarden {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var x1 : int ;
    var y1 : int ;
    var x2 : int ;
    var y2 : int ;
    x1 := (st.next())->toInteger() ; 
    y1 := (st.next())->toInteger() ; 
    x2 := (st.next())->toInteger() ; 
    y2 := (st.next())->toInteger() ; 
    if (x1 = x2) then     OclFile["System.out"].println((y1 - y2 + x1) + " " + y1 + " " + (y1 - y2 + x2) + " " + y2) else     if (y1 = y2) then     OclFile["System.out"].println((x1) + " " + (y1 + x1 - x2) + " " + x2 + " " + (y2 + x1 - x2)) else     if (if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif = if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif) then     OclFile["System.out"].println(x1 + " " + y2 + " " + x2 + " " + y1) else     OclFile["System.out"].println("-1") ; ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import java.util.*;
import java.io.*;
public class x754A {
  public static void main(String omkar[])throws Exception {
    BufferedReader infile=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(infile.readLine());
    int N=Integer.parseInt(st.nextToken());
    int[] arr=readArr(N,infile,st);
    int tot=0 ;
    for(int x : arr)tot+=x ;
    if(tot!=0){
      System.out.println("YES");
      System.out.println(1);
      System.out.println(1+" "+N);
      return ;
    }
    int prefix=0 ;
    for(int i=0 ; i<N ; i++){
      prefix+=arr[i];
      if(prefix!=0){
        System.out.println("YES");
        System.out.println(2);
        System.out.println(1+" "+(i+1));
        System.out.println((i+2)+" "+N);
        return ;
      }
    }
    System.out.println("NO");
  }
  public static int[] readArr(int N,BufferedReader infile,StringTokenizer st)throws Exception {
    int[] arr=new int[N];
    st=new StringTokenizer(infile.readLine());
    for(int i=0 ; i<N ; i++)arr[i]=Integer.parseInt(st.nextToken());
    return arr ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class x754A {
  static   operation main( omkar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var infile : OclFile ; infile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(infile.readLine()) ;
    var N : int ; N := (st.next())->toInteger() ;
    var arr : Sequence(int) ; arr := readArr(N, infile, st) ;
    var tot : int ; tot := 0 ;
    for (x : arr) do (     tot := tot+(x) ;  ) ; 
    if (tot /= 0) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(1) ; 
     OclFile["System.out"].println(1 + " " + N) ; 
     return ) else skip ; 
    var prefix : int ; prefix := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     prefix := prefix+(arr[i+1]) ; 
     if (prefix /= 0) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(2) ; 
    OclFile["System.out"].println(1 + " " + (i + 1)) ; 
    OclFile["System.out"].println((i + 2) + " " + N) ; 
    return 
 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
  static   operation readArr( N : int, infile : OclFile, st : OclIterator) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
     st := OclIterator.newOclIterator_String(infile.readLine()) ; 
         var i : int ; i := 0 ; while i < N do (     arr[i+1] := (st.next())->toInteger() ;  ;     i := i + 1 ) ; 
     return arr );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class LeshaAndArraySplitting {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=in.nextLong();
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=a[i];
    }
    long curr=0 ;
    if(sum!=0){
      pw.println("YES");
      pw.println(1);
      pw.println(1+" "+n);
      pw.close();
      return ;
    }
    int it=0 ;
    for(long i : a){
      it++;
      curr+=i ;
      long temp=sum-curr ;
      if(temp!=0 && curr!=0){
        pw.println("YES");
        pw.println(2);
        pw.println(1+" "+it);
        pw.println((it+1)+" "+n);
        pw.close();
        return ;
      }
    }
    pw.println("NO");
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class LeshaAndArraySplitting {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    var curr : long ; curr := 0 ;
    if (sum /= 0) then (     skip ; 
     skip ; 
    skip ; 
    skip ; 
    return 
 ) else skip ; 
    var it : int ; it := 0 ;
    for (i : a) do ( (     it := it + 1 ; 
     curr := curr+(i) ; 
     var temp : long ; temp := sum - curr ;
     if (temp /= 0 & curr /= 0) then (     skip ; 
     skip ; 
    skip ; 
    skip ; 
    skip ; 
    return 
 ) else skip )  ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.*;
public class App {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws Exception {
    if(System.getProperty("ONLINE_JUDGE")==null){
      File inputFile=new File("/Users/vipinjain/self/cp/input.txt");
      File outputFile=new File("/Users/vipinjain/self/cp/output.txt");
      br=new BufferedReader(new FileReader(inputFile));
      bw=new BufferedWriter(new FileWriter(outputFile));
    }
    int tests ;
    tests=1 ;
    while(tests-->0){
      solve();
    }
    bw.flush();
    bw.close();
    br.close();
  }
  static int getNumberOfDays(int month){
    switch(month){
      case 1 : case 3 : case 5 : case 7 : case 8 : case 10 : case 12 : return 31 ;
      case 2 : return 28 ;
      default : return 30 ;
    }
  }
  static void solve()throws Exception {
    int n=Integer.parseInt(br.readLine());
    int[] freq=new int[101];
    Arrays.fill(freq,0);
    for(int i=0 ; i<n ; ++i){
      int[] arr=Stream.of(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
      for(int j=1 ; j<=arr[0]; ++j){
        freq[arr[j] ]++;
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int i=1 ; i<101 ; ++i){
      if(freq[i]==n){
        sb.append(i+" ");
      }
    }
    bw.write(sb.toString().trim());
    bw.write("\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null) then (     var inputFile : OclFile ; inputFile := OclFile("/Users/vipinjain/self/cp/input.txt") ;
     var outputFile : OclFile ; outputFile := OclFile("/Users/vipinjain/self/cp/output.txt") ;
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputFile)) ; 
     bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputFile)) ) else skip ; 
     var tests : int ;
    tests := 1 ; 
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation getNumberOfDays( month : int) : int
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (month) ; 
    if _switchval = 1 or _switchval = 3 or _switchval = 5 or _switchval = 7 or _switchval = 8 then
   if _switchval = 10 then
   if _switchval = 12 then
    return 31 
   else skip ;
       if _switchval = 2 then
     return 28 
   else skip ;
       if true then
     return 30 
   else skip ;
 )
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var freq : Sequence(int) ; freq := Integer.subrange(1,101)->collect(0) ;
    freq := freq->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     var arr : Sequence(int) ; arr := Sequence{br.readLine()->split(" ")}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
         var j : int ; j := 1 ; while j <= arr[0+1] do ( (     freq[arr[j+1]+1] := freq[arr[j+1]+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 1 ; while i < 101 do ( (     if (freq[i+1] = n) then (     sb := sb + StringLib.newString(i + " ") ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n==1){
      System.out.println('a');
    }
    else if(n==2){
      System.out.println("ab");
    }
    else if(n==3){
      System.out.println("abc");
    }
    else {
      for(int i=0 ; i<n/4 ; i++){
        System.out.print("abcd");
      }
      int t=n % 4 ;
      if(t==1){
        System.out.println('a');
      }
      else if(t==2){
        System.out.println("ab");
      }
      else if(t==3){
        System.out.println("abc");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 1) then (     OclFile["System.out"].println('a') ) else     if (n = 2) then (     OclFile["System.out"].println("ab") ) else     if (n = 3) then (     OclFile["System.out"].println("abc") ) else (         var i : int ; i := 0 ; while i < n / 4 do ( (     OclFile["System.out"].print("abcd") )  ;     i := i + 1 ) ; 
     var t : int ; t := n mod 4 ;
     if (t = 1) then (     OclFile["System.out"].println('a') ) else     if (t = 2) then (     OclFile["System.out"].println("ab") ) else     if (t = 3) then (     OclFile["System.out"].println("abc") ) else skip ; ;  ) ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CCF3_D {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] Number=new int[n+1];
    int i,count=0 ;
    int flag1,flag2,flag3 ;
    for(i=1 ; i<n+1 ; i++){
      Number[i]=input.nextInt();
    }
    for(i=1 ; i<n+1 ; i++){
      flag1=Number[i];
      flag2=Number[flag1];
      flag3=Number[flag2];
      if(flag3==i)count++;
    }
    if(count==0)System.out.println("NO");
    else System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class CCF3_D {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var Number : Sequence(int) ; Number := Integer.subrange(1,n + 1)->collect(0) ;
    var i : int ;
    var count : int ; count := 0 ;
    var flag1 : int ;
    var flag2 : int ;
    var flag3 : int ;
        i := 1 ; while i < n + 1 do ( (     Number[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        i := 1 ; while i < n + 1 do ( (     flag1 := Number[i+1] ; 
     flag2 := Number[flag1+1] ; 
     flag3 := Number[flag2+1] ; 
     if (flag3 = i) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (count = 0) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int len=sc.nextInt();
    char data[]=new char[len];
    for(int i=0 ; i<len ; i+=4){
      data[i]='a' ;
      if(i+1<len){
        data[i+1]='b' ;
      }
      if(i+2<len){
        data[i+2]='c' ;
      }
      if(i+3<len){
        data[i+3]='d' ;
      }
    }
    System.out.println(data);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := sc.getCurrent()->toInteger() ;
    var data : Sequence(String) ; data := Integer.subrange(1,len)->collect(0) ;
        var i : int ; i := 0 ; while i < len do ( (     data[i+1] := 'a' ; 
     if (i + 1 < len) then (     data[i + 1+1] := 'b' ) else skip ; 
     if (i + 2 < len) then (     data[i + 2+1] := 'c' ) else skip ; 
     if (i + 3 < len) then (     data[i + 3+1] := 'd' ) else skip )  ;     i := i+(4) ) ; 
    OclFile["System.out"].println(data) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class lucky {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,i,j,p=97 ;
    n=sc.nextInt();
    char c[]=new char[n];
    for(i=0 ; i<4 ; i++){
      for(j=i ; j<n ; j+=4)c[j]=(char)p ;
      p++;
    }
    for(i=0 ; i<n ; i++)System.out.print(c[i]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class lucky {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var i : int ;
    var j : int ;
    var p : int ; p := 97 ;
    n := sc.getCurrent()->toInteger() ; 
    var c : Sequence(String) ; c := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < 4 do ( (         j := i ; while j < n do (     c[j+1] := p->oclAsType(String) ;  ;     j := j+(4) ) ; 
     p := p + 1 )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do (     OclFile["System.out"].print(c[i+1]) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[][] data=new int[n+1][2];
    int maxLen=0 ;
    for(int i=1 ; i<=n ; i++){
      data[i][0]=in.nextInt();
      data[i][1]=in.nextInt();
      maxLen+=data[i][0];
    }
    in.close();
    int[] dp=new int[maxLen+1];
    Arrays.fill(dp,10000);
    dp[0]=0 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=maxLen ; j>=data[i][0]; j--){
        dp[j]=Math.min(dp[j],dp[j-data[i][0] ]+data[i][1]);
      }
    }
    for(int i=maxLen ; i>=0 ; i--){
      if(maxLen-i>=dp[i]){
        System.out.println(maxLen-i);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var data : Sequence(Sequence(int)) ; data := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,2)->collect(0)) ;
    var maxLen : int ; maxLen := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     data[i+1][0+1] := in.getCurrent()->toInteger() ; 
     data[i+1][1+1] := in.getCurrent()->toInteger() ; 
     maxLen := maxLen+(data[i+1][0+1]) )  ;     i := i + 1 ) ; 
    skip ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,maxLen + 1)->collect(0) ;
    dp := dp->collect(10000) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := maxLen ; while j >= data[i+1][0+1] do ( (     dp[j+1] := Set{dp[j+1], dp[j - data[i+1][0+1]+1] + data[i+1][1+1]}->min() )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := maxLen ; while i >= 0 do ( (     if (maxLen - i >= dp[i+1]) then (     OclFile["System.out"].println(maxLen - i) ; 
     return ) else skip )  ;     i := i - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] result=new int[10005];
    int[] vi=new int[n+1];
    int[] wi=new int[n+1];
    int total=0 ;
    for(int i=1 ; i<=n ; i++){
      vi[i]=in.nextInt();
      wi[i]=in.nextInt();
      total+=vi[i];
    }
    for(int i=1 ; i<=total ; i++){
      result[i]=(int)Math.pow(10,6);
    }
    for(int i=1 ; i<=n ; i++){
      for(int j=total ; j>=0 ; j--){
        if(j>=vi[i]){
          result[j]=Math.min(result[j],result[j-vi[i] ]+wi[i]);
        }
      }
    }
    int flag=0 ;
    for(int i=total ; i>=0 ; i--){
      if(total-i>=result[i]){
        flag=total-i ;
        break ;
      }
    }
    System.out.println(flag);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var result : Sequence(int) ; result := Integer.subrange(1,10005)->collect(0) ;
    var vi : Sequence(int) ; vi := Integer.subrange(1,n + 1)->collect(0) ;
    var wi : Sequence(int) ; wi := Integer.subrange(1,n + 1)->collect(0) ;
    var total : int ; total := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     vi[i+1] := in.getCurrent()->toInteger() ; 
     wi[i+1] := in.getCurrent()->toInteger() ; 
     total := total+(vi[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= total do ( (     result[i+1] := 10->pow(6)->oclAsType(int) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := total ; while j >= 0 do ( (     if (j >= vi[i+1]) then (     result[j+1] := Set{result[j+1], result[j - vi[i+1]+1] + wi[i+1]}->min() ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    var flag : int ; flag := 0 ;
        var i : int ; i := total ; while i >= 0 do ( (     if (total - i >= result[i+1]) then (     flag := total - i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(flag) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int x=sc.nextInt();
    if((x<a)||((a+b)<x))System.out.println("NO");
    else System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    if ((x < a) or ((a + b) < x)) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  static int mod=(int)1e9+7 ;
  static int DX[]={
-1,0,1,0 },DY[]={
      0,-1,0,1 };
      static int n ;
      static long k ;
      static long a[];
      public static void main(String[] args){
        Scanner fs=new Scanner(System.in);
        n=fs.nextInt();
        k=fs.nextLong();
        a=new long[n];
        for(int i=0 ; i<n ; ++i){
          a[i]=fs.nextLong();
        }
        Arrays.sort(a);
        long INF=(long)(1e18)+1 ;
        long l=-INF ;
        long r=INF ;
        while(l+1<r){
          long c=(l+r)/2 ;
          if(check(c))l=c ;
          else r=c ;
        }
        System.out.println(l);
      }
      static boolean check(long x){
        long tot=0 ;
        for(int i=0 ; i<n ; i++){
          long now=a[i];
          int l=0,r=n ;
          if(now>=0){
            while(l<r){
              int c=(l+r)/2 ;
              if(now*a[c]<x)l=c+1 ;
              else r=c ;
            }
            tot+=l ;
          }
          else {
            while(l<r){
              int c=(l+r)/2 ;
              if(now*a[c]>=x)l=c+1 ;
              else r=c ;
            }
            tot+=(n-l);
          }
          if((long)a[i]*a[i]<x)tot--;
        }
        if(tot/2<k)return true ;
        else return false ;
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := 1e9->oclAsType(int) + 7;
  static   attribute DX : int := Sequence{-1,0,1,0};
  static   attribute n : int;
  static   attribute k : long;
  static   attribute a : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : OclFile ; fs := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := fs.getCurrent()->toInteger() ; 
    k := fs.getCurrent()->toLong() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := fs.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var INF : long ; INF := (1e18)->oclAsType(long) + 1 ;
    var l : long ; l := -INF ;
    var r : long ; r := INF ;
    while (l + 1 < r) do (     var c : long ; c := (l + r) / 2 ;
     if (check(c)) then     l := c ; else     r := c ; ) ; 
    OclFile["System.out"].println(l) ; 
 );
  static   operation check( x : long) : boolean
  pre: true
  post: true
  activity: (     var tot : long ; tot := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var now : long ; now := a[i+1] ;
     var l : int ; l := 0 ;
    var r : int ; r := n ;
     if (now >= 0) then (     while (l < r) do (     var c : int ; c := (l + r) / 2 ;
     if (now * a[c+1] < x) then     l := c + 1 ; else     r := c ; ) ; 
     tot := tot+(l) ) else (     while (l < r) do (     var c : int ; c := (l + r) / 2 ;
     if (now * a[c+1] >= x) then     l := c + 1 ; else     r := c ; ) ; 
     tot := tot+((n - l)) ) ;  
     if (a[i+1]->oclAsType(long) * a[i+1] < x) then     tot := tot - 1 ; else skip )  ;     i := i + 1 ) ; 
     if (tot / 2 < k) then     return true else     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line[]=br.readLine().split(" ");
    int a=Integer.parseInt(line[0]);
    int b=Integer.parseInt(line[1]);
    int c=Integer.parseInt(line[2]);
    String ans="NO" ;
    if(a<=c && c<=a+b){
      ans="YES" ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var a : int ; a := (line[0+1])->toInteger() ;
    var b : int ; b := (line[1+1])->toInteger() ;
    var c : int ; c := (line[2+1])->toInteger() ;
    var ans : String ; ans := "NO" ;
    if (a <= c & c <= a + b) then (     ans := "YES" ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int a=reader.nextInt();
    int b=reader.nextInt();
    int x=reader.nextInt();
    if(a<=x && x<a+b)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var a : int ; a := reader.nextInt() ;
    var b : int ; b := reader.nextInt() ;
    var x : int ; x := reader.nextInt() ;
    if (a <= x & x < a + b) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solveA();
  }
  private void solveA(){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int X=sc.nextInt();
    System.out.println(A>X ? "NO" :(A+B>=X ? "YES" : "NO"));
  }
  private void solveB(){
    Scanner sc=new Scanner(System.in);
    System.out.println();
  }
  private void solveC(){
    Scanner sc=new Scanner(System.in);
    System.out.println();
  }
  private void solveD(){
    Scanner sc=new Scanner(System.in);
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solveA() );
   operation solveA() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var X : int ; X := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(if A > X then "NO" else (if A + B >= X then "YES" else "NO" endif) endif) ; 
 );
   operation solveB() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println() );
   operation solveC() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println() );
   operation solveD() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int X=sc.nextInt();
    if(A>X){
      System.out.println("NO");
    }
    else if(X<A+B){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var X : int ; X := sc.getCurrent()->toInteger() ;
    if (A > X) then (     OclFile["System.out"].println("NO") ) else     if (X < A + B) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findLargest(int[] arr,int n){
    int gcd=0 ;
    for(int i=0 ; i<n ; i++)gcd=__gcd(arr[i],gcd);
    return gcd ;
  }
  static int __gcd(int a,int b){
    return b==0 ? a : __gcd(b,a % b);
  }
  public static void main(String[] args){
    int arr[]={
      3,6,9 };
      int n=arr.length ;
      System.out.print(findLargest(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findLargest( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var gcd : int ; gcd := 0 ;
         var i : int ; i := 0 ; while i < n do (     gcd := __gcd(arr[i+1], gcd) ;  ;     i := i + 1 ) ; 
     return gcd );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else __gcd(b, a mod b) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,6,9} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(findLargest(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int numberOfPlanes=s.nextInt();
    s.nextLine();
    String[] planes=s.nextLine().split(" ");
    boolean yes=false ;
    for(int i=0 ; i<numberOfPlanes && ! yes ; i++){
      int avion=Integer.parseInt(planes[i]);
      int avion2=Integer.parseInt(planes[avion-1]);
      int avion3=Integer.parseInt(planes[avion2-1]);
      if(avion3==(i+1))yes=true ;
    }
    if(yes){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numberOfPlanes : int ; numberOfPlanes := s.getCurrent()->toInteger() ;
    skip ; 
    var planes : Sequence(String) ; planes := s.nextLine()->split(" ") ;
    var yes : boolean ; yes := false ;
        var i : int ; i := 0 ; while i < numberOfPlanes & not(yes) do ( (     var avion : int ; avion := (planes[i+1])->toInteger() ;
     var avion2 : int ; avion2 := (planes[avion - 1+1])->toInteger() ;
     var avion3 : int ; avion3 := (planes[avion2 - 1+1])->toInteger() ;
     if (avion3 = (i + 1)) then     yes := true ; else skip )  ;     i := i + 1 ) ; 
    if (yes) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findWinner(int n){
    if((n-1)% 6==0){
      System.out.println("Second Player wins the game");
    }
    else {
      System.out.println("First Player wins the game");
    }
  }
  public static void main(String[] args){
    int n=7 ;
    findWinner(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findWinner( n : int) : void
  pre: true
  post: true
  activity: (     if ((n - 1) mod 6 = 0) then (     OclFile["System.out"].println("Second Player wins the game") ) else (     OclFile["System.out"].println("First Player wins the game") ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     execute findWinner(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewBuildingForSIS {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int h=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int k=sc.nextInt();
    for(int i=1 ; i<=k ; i++){
      int ta=sc.nextInt();
      int fa=sc.nextInt();
      int tb=sc.nextInt();
      int fb=sc.nextInt();
      if(ta==tb)System.out.println(Math.abs(fb-fa));
      else if(a<=fa && fa<=b)System.out.println(Math.abs(tb-ta)+Math.abs(fb-fa));
      else if(fa<a)System.out.println(a-fa+Math.abs(fb-a)+Math.abs(tb-ta));
      else System.out.println(fa-b+Math.abs(fb-b)+Math.abs(tb-ta));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewBuildingForSIS {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= k do ( (     var ta : int ; ta := sc.getCurrent()->toInteger() ;
     var fa : int ; fa := sc.getCurrent()->toInteger() ;
    var tb : int ; tb := sc.getCurrent()->toInteger() ;
    var fb : int ; fb := sc.getCurrent()->toInteger() ;
    if (ta = tb) then     OclFile["System.out"].println(if fb - fa < 0 then -(fb - fa) else fb - fa endif) else     if (a <= fa & fa <= b) then     OclFile["System.out"].println(if tb - ta < 0 then -(tb - ta) else tb - ta endif + if fb - fa < 0 then -(fb - fa) else fb - fa endif) else     if (fa < a) then     OclFile["System.out"].println(a - fa + if fb - a < 0 then -(fb - a) else fb - a endif + if tb - ta < 0 then -(tb - ta) else tb - ta endif) else     OclFile["System.out"].println(fa - b + if fb - b < 0 then -(fb - b) else fb - b endif + if tb - ta < 0 then -(tb - ta) else tb - ta endif) ; ;  ;  ;  
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javax.swing.*;
import java.util.*;
public class Solve {
  static Scanner scan=new Scanner(System.in);
  public static void solve(long a,long b,long ta,long fa,long tb,long fb){
    long steps=0 ;
    long floor ;
    if(fa==fb && ta==tb){
      System.out.println(0);
      return ;
    }
    if(ta==tb){
      System.out.println(Math.abs(fb-fa));
      return ;
    }
    steps+=Math.abs(tb-ta);
    if(a<=fa && fa<=b || b<=fb && fb<=b){
      steps+=Math.abs(fb-fa);
      System.out.println(steps);
      return ;
    }
    if(Math.abs(a-fa)<Math.abs(b-fa)){
      steps+=Math.abs(a-fa);
      floor=a ;
    }
    else {
      steps+=Math.abs(b-fa);
      floor=b ;
    }
    steps+=Math.abs(fb-floor);
    System.out.println(steps);
  }
  public static void main(String[] args){
    long n=scan.nextLong();
    long h=scan.nextLong();
    long a=scan.nextLong();
    long b=scan.nextLong();
    int k=scan.nextInt();
    while(k-->0){
      long ta=scan.nextLong();
      long fa=scan.nextLong();
      long tb=scan.nextLong();
      long fb=scan.nextLong();
      solve(a,b,ta,fa,tb,fb);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solve {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation solve( a : long, b : long, ta : long, fa : long, tb : long, fb : long) : void
  pre: true
  post: true
  activity: (     var steps : long ; steps := 0 ;
     var floor : long ;
    if (fa = fb & ta = tb) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    if (ta = tb) then (     OclFile["System.out"].println(if fb - fa < 0 then -(fb - fa) else fb - fa endif) ; 
     return ) else skip ; 
    steps := steps+(if tb - ta < 0 then -(tb - ta) else tb - ta endif) ; 
    if (a <= fa & fa <= b or b <= fb & fb <= b) then (     steps := steps+(if fb - fa < 0 then -(fb - fa) else fb - fa endif) ; 
     OclFile["System.out"].println(steps) ; 
     return ) else skip ; 
    if (if a - fa < 0 then -(a - fa) else a - fa endif < if b - fa < 0 then -(b - fa) else b - fa endif) then (     steps := steps+(if a - fa < 0 then -(a - fa) else a - fa endif) ; 
     floor := a ) else (     steps := steps+(if b - fa < 0 then -(b - fa) else b - fa endif) ; 
     floor := b ) ;  
    steps := steps+(if fb - floor < 0 then -(fb - floor) else fb - floor endif) ; 
    OclFile["System.out"].println(steps) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := scan.getCurrent()->toLong() ;
     var h : long ; h := scan.getCurrent()->toLong() ;
    var a : long ; a := scan.getCurrent()->toLong() ;
    var b : long ; b := scan.getCurrent()->toLong() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
        while (k > 0) do (        k := k - 1 ;     skip ; (     var ta : long ; ta := scan.getCurrent()->toLong() ;
     var fa : long ; fa := scan.getCurrent()->toLong() ;
    var tb : long ; tb := scan.getCurrent()->toLong() ;
    var fb : long ; fb := scan.getCurrent()->toLong() ;
    execute solve(a, b, ta, fa, tb, fb) ; 
 ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int h=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int k=sc.nextInt();
    for(int i=0 ; i<k ; i++){
      int res=0 ;
      int ta=sc.nextInt();
      int fa=sc.nextInt();
      int tb=sc.nextInt();
      int fb=sc.nextInt();
      if(ta==tb){
        if(fb>fa){
          res=fb-fa ;
        }
        else {
          res=fa-fb ;
        }
      }
      else {
        if(tb>ta){
          res=res+(tb-ta);
        }
        else {
          res=res+(ta-tb);
        }
        if(fa>b || fa<a){
          int s=0 ;
          if(fa>b){
            res=res+(fa-b);
            s=b ;
          }
          if(fa<a){
            res=res+(a-fa);
            s=a ;
          }
          if(fb>s){
            res=res+(fb-s);
          }
          else {
            res=res+(s-fb);
          }
        }
        else {
          if(fb>fa){
            res=res+(fb-fa);
          }
          else {
            res=res+(fa-fb);
          }
        }
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < k do ( (     var res : int ; res := 0 ;
     var ta : int ; ta := sc.getCurrent()->toInteger() ;
    var fa : int ; fa := sc.getCurrent()->toInteger() ;
    var tb : int ; tb := sc.getCurrent()->toInteger() ;
    var fb : int ; fb := sc.getCurrent()->toInteger() ;
    if (ta = tb) then (     if (fb > fa) then (     res := fb - fa ) else (     res := fa - fb ) ) else (     if (tb > ta) then (     res := res + (tb - ta) ) else (     res := res + (ta - tb) ) ;  
     if (fa > b or fa < a) then (     var s : int ; s := 0 ;
     if (fa > b) then (     res := res + (fa - b) ; 
     s := b ) else skip ; 
     if (fa < a) then (     res := res + (a - fa) ; 
     s := a ) else skip ; 
     if (fb > s) then (     res := res + (fb - s) ) else (     res := res + (s - fb) ) ) else (     if (fb > fa) then (     res := res + (fb - fa) ) else (     res := res + (fa - fb) ) ) ) ;  
    OclFile["System.out"].println(res) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class BusGame {
  public static boolean canTake(int xNeeded,int xAvailable,int yNeeded,int yAvailable){
    if(xNeeded>xAvailable)return false ;
    if(yNeeded>yAvailable)return false ;
    return true ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int x=Integer.parseInt(st.nextToken());
    int y=Integer.parseInt(st.nextToken());
    int turn=0 ;
    while(true){
      if(turn % 2==0){
        if(canTake(2,x,2,y)){
          x-=2 ;
          y-=2 ;
        }
        else if(canTake(1,x,12,y)){
          x-=1 ;
          y-=12 ;
        }
        else if(canTake(0,x,22,y)){
          y-=22 ;
        }
        else {
          System.out.println("Hanako");
          return ;
        }
      }
      else {
        if(canTake(0,x,22,y)){
          y-=22 ;
        }
        else if(canTake(1,x,12,y)){
          x-=1 ;
          y-=12 ;
        }
        else if(canTake(2,x,2,y)){
          x-=2 ;
          y-=2 ;
        }
        else {
          System.out.println("Ciel");
          return ;
        }
      }
      turn++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BusGame {
  static   operation canTake( xNeeded : int, xAvailable : int, yNeeded : int, yAvailable : int) : boolean
  pre: true
  post: true
  activity: (     if (xNeeded > xAvailable) then     return false else skip ; 
     if (yNeeded > yAvailable) then     return false else skip ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var x : int ; x := (st.next())->toInteger() ;
    var y : int ; y := (st.next())->toInteger() ;
    var turn : int ; turn := 0 ;
    while (true) do (     if (turn mod 2 = 0) then (     if (canTake(2, x, 2, y)) then (     x := x-(2) ; 
     y := y-(2) ) else     if (canTake(1, x, 12, y)) then (     x := x-(1) ; 
     y := y-(12) ) else     if (canTake(0, x, 22, y)) then (     y := y-(22) ) else (     OclFile["System.out"].println("Hanako") ; 
     return ) ;  ;  ) else (     if (canTake(0, x, 22, y)) then (     y := y-(22) ) else     if (canTake(1, x, 12, y)) then (     x := x-(1) ; 
     y := y-(12) ) else     if (canTake(2, x, 2, y)) then (     x := x-(2) ; 
     y := y-(2) ) else (     OclFile["System.out"].println("Ciel") ; 
     return ) ;  ;  ) ;  
     turn := turn + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Graph {
  private int V ;
  private LinkedList<Integer>adj[];
  Graph(int v){
    V=v ;
    adj=new LinkedList[v];
    for(int i=0 ; i<v ; ++i)adj[i]=new LinkedList();
  }
  void addEdge(int v,int w){
    adj[v] .add(w);
  }
  void BFS(int s){
    boolean visited[]=new boolean[V];
    LinkedList<Integer>queue=new LinkedList<Integer>();
    visited[s]=true ;
    queue.add(s);
    while(queue.size()!=0){
      s=queue.poll();
      System.out.print(s+" ");
      Iterator<Integer>i=adj[s] .listIterator();
      while(i.hasNext()){
        int n=i.next();
        if(! visited[n]){
          visited[n]=true ;
          queue.add(n);
        }
      }
    }
  }
  public static void main(String args[]){
    Graph g=new Graph(4);
    g.addEdge(0,1);
    g.addEdge(0,2);
    g.addEdge(1,2);
    g.addEdge(2,0);
    g.addEdge(2,3);
    g.addEdge(3,3);
    System.out.println("Following is Breadth First Traversal "+"(starting from vertex 2)");
    g.BFS(2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Graph {
   attribute V : int;
   attribute adj : Sequence(Sequence(int));
   static operation newGraph( v : int) : Graph
  pre: true
  post: true
  activity:
  ( var self : Graph ;
    self := createGraph();
    self.initialise(v);
    return self );
  operation initialise( v : int) : void
  pre: true  post: true
  activity: (     V := v ; 
     adj := Integer.subrange(1,v)->collect(null) ; 
         var i : int ; i := 0 ; while i < v do (     adj[i+1] := Sequence{} ;  ;     i := i + 1 ) );
   operation addEdge( v : int, w : int) : void
  pre: true
  post: true
  activity: (     adj[v+1]->excludes(w) );
   operation BFS( s : int) : void
  pre: true
  post: true
  activity: (     var visited : Sequence(boolean) ; visited := Integer.subrange(1,V)->collect(false) ;
     var queue : Sequence(int) ; queue := Sequence{} ;
    visited[s+1] := true ; 
    queue := queue->including(s) ; 
    while (queue->size() /= 0) do (     s := queue->min() ;     queue := queue->sort()->tail() ; 
     OclFile["System.out"].print(s + " ") ; 
     var i : OclIterator ; i := adj[s+1]->iterator() ;
     while (i.hasNext()) do (     var n : int ; n := i.next() ;
     if (not(visited[n+1])) then (     visited[n+1] := true ; 
     queue := queue->including(n) ) else skip ) ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : Graph ; g := Graph.newGraph(4) ;
     g.addEdge(0, 1) ; 
    g.addEdge(0, 2) ; 
    g.addEdge(1, 2) ; 
    g.addEdge(2, 0) ; 
    g.addEdge(2, 3) ; 
    g.addEdge(3, 3) ; 
    OclFile["System.out"].println("Following is Breadth First Traversal " + "(starting from vertex 2)") ; 
    g.BFS(2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Graph {
  private int V ;
  private LinkedList<Integer>adj[];
  Graph(int v){
    V=v ;
    adj=new LinkedList[v];
    for(int i=0 ; i<v ; ++i)adj[i]=new LinkedList();
  }
  void addEdge(int v,int w){
    adj[v] .add(w);
  }
  void BFS(int s){
    boolean visited[]=new boolean[V];
    LinkedList<Integer>queue=new LinkedList<Integer>();
    visited[s]=true ;
    queue.add(s);
    while(queue.size()!=0){
      s=queue.poll();
      System.out.print(s+" ");
      Iterator<Integer>i=adj[s] .listIterator();
      while(i.hasNext()){
        int n=i.next();
        if(! visited[n]){
          visited[n]=true ;
          queue.add(n);
        }
      }
    }
  }
  public static void main(String args[]){
    Graph g=new Graph(4);
    g.addEdge(0,1);
    g.addEdge(0,2);
    g.addEdge(1,2);
    g.addEdge(2,0);
    g.addEdge(2,3);
    g.addEdge(3,3);
    System.out.println("Following is Breadth First Traversal "+"(starting from vertex 2)");
    g.BFS(2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Graph {
   attribute V : int;
   attribute adj : Sequence(Sequence(int));
   static operation newGraph( v : int) : Graph
  pre: true
  post: true
  activity:
  ( var self : Graph ;
    self := createGraph();
    self.initialise(v);
    return self );
  operation initialise( v : int) : void
  pre: true  post: true
  activity: (     V := v ; 
     adj := Integer.subrange(1,v)->collect(null) ; 
         var i : int ; i := 0 ; while i < v do (     adj[i+1] := Sequence{} ;  ;     i := i + 1 ) );
   operation addEdge( v : int, w : int) : void
  pre: true
  post: true
  activity: (     adj[v+1]->excludes(w) );
   operation BFS( s : int) : void
  pre: true
  post: true
  activity: (     var visited : Sequence(boolean) ; visited := Integer.subrange(1,V)->collect(false) ;
     var queue : Sequence(int) ; queue := Sequence{} ;
    visited[s+1] := true ; 
    queue := queue->including(s) ; 
    while (queue->size() /= 0) do (     s := queue->min() ;     queue := queue->sort()->tail() ; 
     OclFile["System.out"].print(s + " ") ; 
     var i : OclIterator ; i := adj[s+1]->iterator() ;
     while (i.hasNext()) do (     var n : int ; n := i.next() ;
     if (not(visited[n+1])) then (     visited[n+1] := true ; 
     queue := queue->including(n) ) else skip ) ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : Graph ; g := Graph.newGraph(4) ;
     g.addEdge(0, 1) ; 
    g.addEdge(0, 2) ; 
    g.addEdge(1, 2) ; 
    g.addEdge(2, 0) ; 
    g.addEdge(2, 3) ; 
    g.addEdge(3, 3) ; 
    OclFile["System.out"].println("Following is Breadth First Traversal " + "(starting from vertex 2)") ; 
    g.BFS(2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void getElements(int a,int arr[],int n){
    int elements[]=new int[n+1];
    elements[0]=a ;
    for(int i=0 ; i<n ; i++){
      elements[i+1]=arr[i] ^ elements[i];
    }
    for(int i=0 ; i<n+1 ; i++)System.out.print(elements[i]+" ");
  }
  public static void main(String[] args){
    int arr[]={
      13,2,6,1 };
      int n=arr.length ;
      int a=5 ;
      getElements(a,arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getElements( a : int, arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var elements : Sequence(int) ; elements := Integer.subrange(1,n + 1)->collect(0) ;
     elements[0+1] := a ; 
         var i : int ; i := 0 ; while i < n do ( (     elements[i + 1+1] := arr[i+1] xor elements[i+1] )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n + 1 do (     OclFile["System.out"].print(elements[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{13,2,6,1} ;
     var n : int ; n := arr->size() ;
     var a : int ; a := 5 ;
     execute getElements(a, arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  static Scanner sc=new Scanner(System.in);
  static char[] cs={
    'P','R','S' };
    static String[][] dp=new String[3][13];
    public static void main(String[] args){
      dp[0][0]="P" ;
      dp[1][0]="R" ;
      dp[2][0]="S" ;
      for(int i=1 ; i<dp[0] .length ; ++i){
        for(int j=0 ; j<3 ; ++j){
          dp[j][i]=dp[j][i-1]+dp[(j+1)% 3][i-1];
          String o=dp[(j+1)% 3][i-1]+dp[j][i-1];
          if(o.compareTo(dp[j][i])<0)dp[j][i]=o ;
        }
      }
      int T=sc.nextInt();
      for(int i=1 ; i<=T ; ++i){
        System.out.print("Case #"+i+": ");
        System.out.println(solve());
      }
    }
    static String solve(){
      int N=sc.nextInt();
      int R=sc.nextInt();
      int P=sc.nextInt();
      int S=sc.nextInt();
      String ret=null ;
      for(int i=0 ; i<3 ; ++i){
        int[] c=new int[3];
        for(char ch : dp[i][N] .toCharArray()){
          if(ch=='P')c[0]++;
          if(ch=='R')c[1]++;
          if(ch=='S')c[2]++;
        }
        if(c[0]==P && c[1]==R && c[2]==S){
          ret=dp[i][N];
        }
      }
      return ret==null ? "IMPOSSIBLE" : ret ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute cs : Sequence(String) := Sequence{'P','R','S'};
  static   attribute dp : Sequence(Sequence(String)) := Integer.subrange(1,3)->collect(Integer.subrange(1,13)->collect(null));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     dp[0+1][0+1] := "P" ; 
     dp[1+1][0+1] := "R" ; 
    dp[2+1][0+1] := "S" ; 
        var i : int ; i := 1 ; while i < dp[0+1]->size() do ( (         var j : int ; j := 0 ; while j < 3 do ( (     dp[j+1][i+1] := dp[j+1][i - 1+1] + dp[(j + 1) mod 3+1][i - 1+1] ; 
     var o : String ; o := dp[(j + 1) mod 3+1][i - 1+1] + dp[j+1][i - 1+1] ;
     if (o->compareTo(dp[j+1][i+1]) < 0) then     dp[j+1][i+1] := o ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var T : int ; T := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= T do ( (     OclFile["System.out"].print("Case #" + i + ": ") ; 
     OclFile["System.out"].println(solve()) )  ;     i := i + 1 ) ; 
 );
  static   operation solve() : String
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var R : int ; R := sc.getCurrent()->toInteger() ;
    var P : int ; P := sc.getCurrent()->toInteger() ;
    var S : int ; S := sc.getCurrent()->toInteger() ;
    var ret : String ; ret := null ;
        var i : int ; i := 0 ; while i < 3 do ( (     var c : Sequence(int) ; c := Integer.subrange(1,3)->collect(0) ;
     for (ch : dp[i+1][N+1]->characters()) do ( (     if (ch = 'P') then     c[0+1] := c[0+1] + 1 ; else skip ; 
     if (ch = 'R') then     c[1+1] := c[1+1] + 1 ; else skip ; 
     if (ch = 'S') then     c[2+1] := c[2+1] + 1 ; else skip )  ) ; 
     if (c[0+1] = P & c[1+1] = R & c[2+1] = S) then (     ret := dp[i+1][N+1] ) else skip )  ;     i := i + 1 ) ; 
    return if ret = null then "IMPOSSIBLE" else ret endif 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class _30_Chips {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int k=scn.nextInt();
    boolean[] row=new boolean[n];
    boolean[] col=new boolean[n];
    for(int i=0 ; i<k ; i++){
      int val=scn.nextInt();
      int val2=scn.nextInt();
      row[val-1]=true ;
      col[val2-1]=true ;
    }
    long ans=0 ;
    for(int i=1 ; i<n-1 ; i++){
      if(n % 2==1 && i==n/2){
        if(! row[i] || ! col[i]){
          ans++;
        }
      }
      else if(! row[i] || ! col[i]){
        ans=ans+((! row[i] && ! col[i])? 2 : 1);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _30_Chips {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var k : int ; k := scn.getCurrent()->toInteger() ;
    var row : Sequence(boolean) ; row := Integer.subrange(1,n)->collect(false) ;
    var col : Sequence(boolean) ; col := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < k do ( (     var val : int ; val := scn.getCurrent()->toInteger() ;
     var val2 : int ; val2 := scn.getCurrent()->toInteger() ;
     row[val - 1+1] := true ; 
     col[val2 - 1+1] := true )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i < n - 1 do ( (     if (n mod 2 = 1 & i = n / 2) then (     if (not(row[i+1]) or not(col[i+1])) then (     ans := ans + 1 ) else skip ) else     if (not(row[i+1]) or not(col[i+1])) then (     ans := ans + (if (not(row[i+1]) & not(col[i+1])) then 2 else 1 endif) ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class PracticeProblem {
  public static FastReader in=new FastReader();
  public static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    int n=in.nextInt(),m=in.nextInt();
    Set<Integer>bannedRows,bannedCols ;
    bannedRows=new HashSet<>();
    bannedCols=new HashSet<>();
    for(int i=0 ; i<m ; i++){
      int r=in.nextInt();
      if(r>1 && r<n)bannedRows.add(r);
      int c=in.nextInt();
      if(c>1 && c<n)bannedCols.add(c);
    }
    int answer=(n-2)*2 ;
    answer-=bannedRows.size();
    answer-=bannedCols.size();
    if(n % 2!=0){
      int mid=(n+1)/2 ;
      if(! bannedRows.contains(mid)&& ! bannedCols.contains(mid)){
        answer--;
      }
    }
    out.println(answer);
    out.close();
  }
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PracticeProblem {
  static   attribute in : FastReader := FastReader.newFastReader();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
    var m : int ; m := in.nextInt() ;
     var bannedRows : Set(int) ;
    var bannedCols : Set(int) ;
    bannedRows := Set{} ; 
    bannedCols := Set{} ; 
        var i : int ; i := 0 ; while i < m do ( (     var r : int ; r := in.nextInt() ;
     if (r > 1 & r < n) then     bannedRows := bannedRows->including(r) ; else skip ; 
     var c : int ; c := in.nextInt() ;
     if (c > 1 & c < n) then     bannedCols->excludes(c) ; else skip )  ;     i := i + 1 ) ; 
    var answer : int ; answer := (n - 2) * 2 ;
    answer := answer-(bannedRows->size()) ; 
    answer := answer-(bannedCols->size()) ; 
    if (n mod 2 /= 0) then (     var mid : int ; mid := (n + 1) / 2 ;
     if (not(bannedRows->includes(mid)) & not(bannedCols->includes(mid))) then (     answer := answer - 1 ) else skip ) else skip ; 
    skip ; 
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int nextZero(int i,int occurrences[]){
    while(i<occurrences.length){
      if(occurrences[i]==0)return i ;
      i++;
    }
    return-1 ;
  }
  static String getModifiedString(String str){
    int n=str.length();
    if(n>26)return "-1" ;
    char ch[]=str.toCharArray();
    int i,occurrences[]=new int[26];
    for(i=0 ; i<n ; i++)occurrences[ch[i]-'a']++;
    int index=nextZero(0,occurrences);
    for(i=0 ; i<n ; i++){
      if(occurrences[ch[i]-'a']>1){
        occurrences[ch[i]-'a']--;
        ch[i]=(char)('a'+index);
        occurrences[index]=1 ;
        index=nextZero(index+1,occurrences);
      }
    }
    return String.valueOf(ch);
  }
  public static void main(String arr[]){
    String str="geeksforgeeks" ;
    System.out.print(getModifiedString(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nextZero( i : int, occurrences : Sequence(int)) : int
  pre: true
  post: true
  activity: (     while (i < occurrences->size()) do (     if (occurrences[i+1] = 0) then     return i else skip ; 
     i := i + 1 ) ; 
     return -1 );
  static   operation getModifiedString( str : String) : String
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     if (n > 26) then     return "-1" else skip ; 
    var ch : Sequence(String) ; ch := str->characters() ;
    var i : int ;
    var occurrences : Sequence(void) ; occurrences := Integer.subrange(1,26)->collect(0) ;
        i := 0 ; while i < n do (     occurrences[ch[i+1] - ('a')->char2byte()+1] := occurrences[ch[i+1] - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    var index : int ; index := nextZero(0, occurrences) ;
        i := 0 ; while i < n do ( (     if (occurrences[ch[i+1] - ('a')->char2byte()+1] > 1) then (     occurrences[ch[i+1] - ('a')->char2byte()+1] := occurrences[ch[i+1] - ('a')->char2byte()+1] - 1 ; 
     ch[i+1] := ('a' + index)->oclAsType(String) ; 
     occurrences[index+1] := 1 ; 
     index := nextZero(index + 1, occurrences) ) else skip )  ;     i := i + 1 ) ; 
    return ((ch) + "") 
 );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     OclFile["System.out"].print(getModifiedString(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class RepeatElement {
  void printRepeating(int arr[],int size){
    int S=0 ;
    int P=1 ;
    int x,y ;
    int D ;
    int n=size-2,i ;
    for(i=0 ; i<size ; i++){
      S=S+arr[i];
      P=P*arr[i];
    }
    S=S-n*(n+1)/2 ;
    P=P/fact(n);
    D=(int)Math.sqrt(S*S-4*P);
    x=(D+S)/2 ;
    y=(S-D)/2 ;
    System.out.println("The two repeating elements are :");
    System.out.print(x+" "+y);
  }
  int fact(int n){
    return(n==0)? 1 : n*fact(n-1);
  }
  public static void main(String[] args){
    RepeatElement repeat=new RepeatElement();
    int arr[]={
      4,2,4,5,2,3,1 };
      int arr_size=arr.length ;
      repeat.printRepeating(arr,arr_size);
    }
  }

------------------------------------------------------------
OCL File:
---------
class RepeatElement {
   operation printRepeating( arr : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (     var S : int ; S := 0 ;
     var P : int ; P := 1 ;
    var x : int ;
    var y : int ;
    var D : int ;
    var n : int ; n := size - 2 ;
    var i : int ;
        i := 0 ; while i < size do ( (     S := S + arr[i+1] ; 
     P := P * arr[i+1] )  ;     i := i + 1 ) ; 
    S := S - n * (n + 1) / 2 ; 
    P := P / fact(n) ; 
    D := (S * S - 4 * P)->sqrt()->oclAsType(int) ; 
    x := (D + S) / 2 ; 
    y := (S - D) / 2 ; 
    OclFile["System.out"].println("The two repeating elements are :") ; 
    OclFile["System.out"].print(x + " " + y) ; 
 );
   operation fact( n : int) : int
  pre: true
  post: true
  activity: (     return if (n = 0) then 1 else n * fact(n - 1) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var repeat : RepeatElement ; repeat := RepeatElement.newRepeatElement() ;
     var arr : Sequence(int) ; arr := Sequence{4,2,4,5,2,3,1} ;
     var arr_size : int ; arr_size := arr->size() ;
     repeat.printRepeating(arr, arr_size) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package contest;
import java.util.*;
import java.io.*;
import java.math.*;
public class DataPacking {
    final static String PROBLEM_NAME = "dpack";
    final static String WORK_DIR = "D:\\GCJ\\" + PROBLEM_NAME + "\\";
    void solve(Scanner sc, PrintWriter pw) {
        int N = sc.nextInt();
        int X = sc.nextInt();
        int[] sz = new int[N];
        for (int i = 0; i < N; i++) {
            sz[i] = sc.nextInt();
        }
        Arrays.sort(sz);
        int ans = N;
        for (int t = 0; 2 * t <= N; t++) {
            boolean ok = true;
            for (int i = 0, j = 2 * t - 1; i < j; i++, j--) {
                if (sz[i] + sz[j] > X) {
                    ok = false;
                }
            }
            if (ok) {
                ans = Math.min(ans, N - t);
            }
        }
        pw.println(ans);
    }
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(new FileReader(WORK_DIR + "input.txt"));
        PrintWriter pw = new PrintWriter(new FileWriter(WORK_DIR + "output.txt"));
        int caseCnt = sc.nextInt();
        for (int caseNum = 0; caseNum < caseCnt; caseNum++) {
            System.out.println("Processing test case " + (caseNum + 1));
            pw.print("Case #" + (caseNum + 1) + ": ");
            new DataPacking().solve(sc, pw);
        }
        pw.flush();
        pw.close();
        sc.close();
    }
}

------------------------------------------------------------
OCL File:
---------
 class DataPacking {
  static   attribute PROBLEM_NAME : String := "dpack";
  static   attribute WORK_DIR : String := "D:\\GCJ\\" + PROBLEM_NAME + "\\";
   operation solve( sc : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.nextInt() ;
     var X : int ; X := sc.nextInt() ;
    var sz : Sequence(int) ; sz := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     sz[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    sz := sz->sort() ; 
    var ans : int ; ans := N ;
        var t : int ; t := 0 ; while 2 * t <= N do ( (     var ok : boolean ; ok := true ;
         var i : int ; i := 0 ;
    var j : int ; j := 2 * t - 1 ; while i < j do ( (     if (sz[i+1] + sz[j+1] > X) then (     ok := false ) else skip )  ;     i := i + 1 ;     j := j - 1 ) ; 
     if (ok) then (     ans := Set{ans, N - t}->min() ) else skip )  ;     t := t + 1 ) ; 
    pw.println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(WORK_DIR + "input.txt")) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(WORK_DIR + "output.txt")) ;
    var caseCnt : int ; caseCnt := sc.getCurrent()->toInteger() ;
        var caseNum : int ; caseNum := 0 ; while caseNum < caseCnt do ( (     OclFile["System.out"].println("Processing test case " + (caseNum + 1)) ; 
     skip ; 
     DataPacking.newDataPacking().solve(sc, pw) )  ;     caseNum := caseNum + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class DZYLovesChessboard {
  public static void main(String[] args)throws FileNotFoundException {
    FastReader in=new FastReader();
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    int n=in.nextInt();
    int m=in.nextInt();
    char[][] arr=new char[n][m];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextLine().toCharArray();
    }
    for(int i=0 ; i<n ; i++){
      boolean w=i % 2==0 ;
      for(int j=0 ; j<m ; j++){
        w=! w ;
        if(arr[i][j]=='.')out.print(w ? 'W' : 'B');
        else out.print('-');
      }
      out.println();
    }
    out.close();
  }
  private static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    FastReader()throws FileNotFoundException {
      br=new BufferedReader(new InputStreamReader(System.getProperty("ONLINE_JUDGE")==null ? new FileInputStream("input.txt"): 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DZYLovesChessboard {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := in.nextInt() ;
    var m : int ; m := in.nextInt() ;
    var arr : Sequence(Sequence(String)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.nextLine()->characters() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var w : boolean ; w := i mod 2 = 0 ;
         var j : int ; j := 0 ; while j < m do ( (     w := not(w) ; 
     if (arr[i+1][j+1] = '.') then     skip ; else     skip ; )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(if OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null then OclFile.newOclFile_Read(OclFile.newOclFile("input.txt")) else OclFile["System.in"] endif)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package com.google.codejam2014.round2 ;
import java.io.*;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class DataPacking {
  BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
  PrintWriter writer=new PrintWriter(System.out);
  StringTokenizer stringTokenizer ;
  DataPacking()throws IOException {
    reader=new BufferedReader(new FileReader("input.txt"));
    writer=new PrintWriter(new FileWriter("output.txt"));
  }
  String next()throws IOException {
    while(stringTokenizer==null || ! stringTokenizer.hasMoreTokens()){
      stringTokenizer=new StringTokenizer(reader.readLine());
    }
    return stringTokenizer.nextToken();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  void solveTestCase(int testNumber)throws IOException {
    writer.printf("Case #%d: ",testNumber);
    int n=nextInt();
    int x=nextInt();
    int[] s=new int[n];
    for(int i=0 ; i<n ; i++){
      s[i]=nextInt();
    }
    Arrays.sort(s);
    int limit=x/2 ;
    int i1=0 ;
    int i2=n-1 ;
    int ans=0 ;
    while(s[i2]>limit && i2>i1){
      ans++;
      if(s[i2]+s[i1]<=x){
        i1++;
      }
      i2--;
    }
    int left=i2-i1+1 ;
    ans+=left/2+left % 2 ;
    writer.println(ans);
  }
  void solve()throws IOException {
    int testsNumber=nextInt();
    for(int i=1 ; i<=testsNumber ; i++){
      solveTestCase(i);
      writer.flush();
    }
    writer.close();
  }
  public static void main(String[] args)throws IOException {
    new DataPacking().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class DataPacking {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute writer : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   attribute stringTokenizer : OclIterator;
   static operation newDataPacking() : DataPacking
  pre: true
  post: true
  activity:
  ( var self : DataPacking ;
    self := createDataPacking();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt"))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (stringTokenizer = null or not(stringTokenizer.hasNext())) do (     stringTokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return stringTokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation solveTestCase( testNumber : int) : void
  pre: true
  post: true
  activity: (     skip ; 
     var n : int ; n := nextInt() ;
    var x : int ; x := nextInt() ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := nextInt() )  ;     i := i + 1 ) ; 
    s := s->sort() ; 
    var limit : int ; limit := x / 2 ;
    var i1 : int ; i1 := 0 ;
    var i2 : int ; i2 := n - 1 ;
    var ans : int ; ans := 0 ;
    while (s[i2+1] > limit & i2 > i1) do (     ans := ans + 1 ; 
     if (s[i2+1] + s[i1+1] <= x) then (     i1 := i1 + 1 ) else skip ; 
     i2 := i2 - 1 ) ; 
    var left : int ; left := i2 - i1 + 1 ;
    ans := ans+(left / 2 + left mod 2) ; 
    skip ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var testsNumber : int ; testsNumber := nextInt() ;
         var i : int ; i := 1 ; while i <= testsNumber do ( (     execute solveTestCase(i) ; 
     skip )  ;     i := i + 1 ) ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     DataPacking.newDataPacking().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class DataPacking {
  private static Scanner input ;
  private static PrintWriter out ;
  public static void main(String[] args)throws Exception {
    input=new Scanner(new FileReader("A-large.in"));
    out=new PrintWriter(new FileWriter("A-large.out"));
    int testCases=input.nextInt();
    for(int testCase=1 ; testCase<=testCases ; testCase++){
      out.println("Case #"+testCase+": "+solveCase());
    }
    out.close();
  }
  public static int solveCase(){
    int n=input.nextInt(),max=input.nextInt();
    int[] values=new int[n];
    for(int i=0 ; i<n ; i++)values[i]=input.nextInt();
    Arrays.sort(values);
    int lower=0,upper=n-1,res=0 ;
    while(lower<=upper){
      if(lower==upper){
        res++;
        lower++;
      }
      else {
        if(values[upper]+values[lower]<=max){
          res++;
          lower++;
          upper--;
        }
        else {
          res++;
          upper--;
        }
      }
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class DataPacking {
  static   attribute input : OclFile;
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("A-large.in"))) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("A-large.out"))) ; 
    var testCases : int ; testCases := input.getCurrent()->toInteger() ;
        var testCase : int ; testCase := 1 ; while testCase <= testCases do ( (     skip )  ;     testCase := testCase + 1 ) ; 
    skip ; 
 );
  static   operation solveCase() : int
  pre: true
  post: true
  activity: (     var n : int ; n := input.getCurrent()->toInteger() ;
    var max : int ; max := input.getCurrent()->toInteger() ;
     var values : Sequence(int) ; values := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     values[i+1] := input.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    values := values->sort() ; 
    var lower : int ; lower := 0 ;
    var upper : int ; upper := n - 1 ;
    var res : int ; res := 0 ;
    while (lower <= upper) do (     if (lower = upper) then (     res := res + 1 ; 
     lower := lower + 1 ) else (     if (values[upper+1] + values[lower+1] <= max) then (     res := res + 1 ; 
     lower := lower + 1 ; 
     upper := upper - 1 ) else (     res := res + 1 ; 
     upper := upper - 1 ) ) ) ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner kbd=new Scanner(System.in);
  public static void main(String[] args){
    int[] p=new int[10000];
    putN(p);
    while(kbd.hasNext()){
      int n=kbd.nextInt();
      if(n!=0){
        int i=0 ;
        int s=0 ;
        int l=0 ;
        int c=0 ;
        while(p[i]!=0){
          if(s<n){
            s+=p[i];
            i++;
          }
          else if(s>n){
            s-=p[l];
            l++;
          }
          else ;
          if(s==n){
            c++;
            s+=p[i];
            i++;
          }
        }
        System.out.println(c);
      }
    }
  }
  static void putN(int[] p){
    int i=0,k ;
    for(k=2 ; k<10000 ; k++){
      if(check(k)){
        p[i]=k ;
        i++;
      }
    }
  }
  static boolean check(int n){
    int a,c=0 ;
    for(a=1 ; a<=n ; a++){
      if(n % a==0)c++;
    }
    if(c>2)return false ;
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute kbd : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : Sequence(int) ; p := Integer.subrange(1,10000)->collect(0) ;
     execute putN(p) ; 
     while (kbd.hasNext()) do (     var n : int ; n := kbd.getCurrent()->toInteger() ;
     if (n /= 0) then (     var i : int ; i := 0 ;
     var s : int ; s := 0 ;
    var l : int ; l := 0 ;
    var c : int ; c := 0 ;
    while (p[i+1] /= 0) do (     if (s < n) then (     s := s+(p[i+1]) ; 
     i := i + 1 ) else     if (s > n) then (     s := s-(p[l+1]) ; 
     l := l + 1 ) else  ;  ;  
     if (s = n) then (     c := c + 1 ; 
     s := s+(p[i+1]) ; 
     i := i + 1 ) else skip ) ; 
    OclFile["System.out"].println(c) ; 
 ) else skip ) );
  static   operation putN( p : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var k : int ;
         k := 2 ; while k < 10000 do ( (     if (check(k)) then (     p[i+1] := k ; 
     i := i + 1 ) else skip )  ;     k := k + 1 ) );
  static   operation check( n : int) : boolean
  pre: true
  post: true
  activity: (     var a : int ;
    var c : int ; c := 0 ;
         a := 1 ; while a <= n do ( (     if (n mod a = 0) then     c := c + 1 ; else skip )  ;     a := a + 1 ) ; 
     if (c > 2) then     return false else skip ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static boolean[] primes ;
  static void primeSet(final int MAX){
    primes=new boolean[MAX+1];
    primes[2]=true ;
    for(int i=3 ; i<=MAX ; i+=2){
      primes[i]=true ;
    }
    int rt=(int)Math.sqrt(MAX);
    for(int i=3 ; i<=rt ; i+=2){
      if(primes[i]){
        for(int j=i*i ; j<=MAX ; j+=i){
          primes[j]=false ;
        }
      }
    }
  }
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int p=0 ;
    while(true){
      int n=stdIn.nextInt();
      if(p<n){
        primeSet(n);
      }
      if(n==0){
        return ;
      }
      int before=0 ;
      int cnt=0 ;
      for(int i=2 ; i<=n ; i++){
        int sum=0 ;
        int start=0 ;
        for(int j=i ; j<=n ; j++){
          if(primes[j]){
            if(start==0){
              start=j ;
            }
            sum+=j ;
            if(sum==n){
              if(start==before){
                sum=0 ;
                start=0 ;
                break ;
              }
              before=start ;
              start=0 ;
              cnt++;
              sum=0 ;
              break ;
            }
            else if(sum>n){
              sum=0 ;
              break ;
            }
          }
        }
      }
      System.out.println(cnt);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute primes : Sequence(boolean);
  static   operation primeSet( MAX : int) : void
  pre: true
  post: true
  activity: (     primes := Integer.subrange(1,MAX + 1)->collect(false) ; 
     primes[2+1] := true ; 
        var i : int ; i := 3 ; while i <= MAX do ( (     primes[i+1] := true )  ;     i := i+(2) ) ; 
    var rt : int ; rt := (MAX)->sqrt()->oclAsType(int) ;
        var i : int ; i := 3 ; while i <= rt do ( (     if (primes[i+1]) then (         var j : int ; j := i * i ; while j <= MAX do ( (     primes[j+1] := false )  ;     j := j+(i) ) ) else skip )  ;     i := i+(2) ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : int ; p := 0 ;
     while (true) do (     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     if (p < n) then (     execute primeSet(n) ) else skip ; 
    if (n = 0) then (     return ) else skip ; 
    var before : int ; before := 0 ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 2 ; while i <= n do ( (     var sum : int ; sum := 0 ;
     var start : int ; start := 0 ;
         var j : int ; j := i ; while j <= n do ( (     if (primes[j+1]) then (     if (start = 0) then (     start := j ) else skip ; 
     sum := sum+(j) ; 
     if (sum = n) then (     if (start = before) then (     sum := 0 ; 
     start := 0 ; 
     break ) else skip ; 
     before := start ; 
    start := 0 ; 
    cnt := cnt + 1 ; 
    sum := 0 ; 
    break 
 ) else     if (sum > n) then (     sum := 0 ; 
     break ) else skip ; ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static char MAX_CHAR=26 ;
  static void countFreq(String str,int freq[],int len){
    for(int i=0 ; i<len ; i++){
      freq[str.charAt(i)-'a']++;
    }
  }
  static boolean canMakePalindrome(int freq[],int len){
    int count_odd=0 ;
    for(int i=0 ; i<MAX_CHAR ; i++){
      if(freq[i] % 2!=0){
        count_odd++;
      }
    }
    if(len % 2==0){
      if(count_odd>0){
        return false ;
      }
      else {
        return true ;
      }
    }
    if(count_odd!=1){
      return false ;
    }
    return true ;
  }
  static String findOddAndRemoveItsFreq(int freq[]){
    String odd_str="" ;
    for(int i=0 ; i<MAX_CHAR ; i++){
      if(freq[i] % 2!=0){
        freq[i]--;
        odd_str=odd_str+(char)(i+'a');
        return odd_str ;
      }
    }
    return odd_str ;
  }
  static String findPalindromicString(String str){
    int len=str.length();
    int freq[]=new int[MAX_CHAR];
    countFreq(str,freq,len);
    if(! canMakePalindrome(freq,len)){
      return "No Palindromic String" ;
    }
    String odd_str=findOddAndRemoveItsFreq(freq);
    String front_str="",rear_str=" " ;
    for(int i=0 ; i<MAX_CHAR ; i++){
      String temp="" ;
      if(freq[i]!=0){
        char ch=(char)(i+'a');
        for(int j=1 ; j<=freq[i]/2 ; j++){
          temp=temp+ch ;
        }
        front_str=front_str+temp ;
        rear_str=temp+rear_str ;
      }
    }
    return(front_str+odd_str+rear_str);
  }
  public static void main(String[] args){
    String str="malayalam" ;
    System.out.println(findPalindromicString(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX_CHAR : String := 26;
  static   operation countFreq( str : String, freq : Sequence(int), len : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < len do ( (     freq[str->at(i+1) - ('a')->char2byte()+1] := freq[str->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) );
  static   operation canMakePalindrome( freq : Sequence(int), len : int) : boolean
  pre: true
  post: true
  activity: (     var count_odd : int ; count_odd := 0 ;
         var i : int ; i := 0 ; while i < MAX_CHAR do ( (     if (freq[i+1] mod 2 /= 0) then (     count_odd := count_odd + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (len mod 2 = 0) then (     if (count_odd > 0) then (     return false ) else (     return true ) ) else skip ; 
    if (count_odd /= 1) then (     return false ) else skip ; 
    return true 
 );
  static   operation findOddAndRemoveItsFreq( freq : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var odd_str : String ; odd_str := "" ;
         var i : int ; i := 0 ; while i < MAX_CHAR do ( (     if (freq[i+1] mod 2 /= 0) then (     freq[i+1] := freq[i+1] - 1 ; 
     odd_str := odd_str + (i + 'a')->oclAsType(String) ; 
     return odd_str ) else skip )  ;     i := i + 1 ) ; 
     return odd_str );
  static   operation findPalindromicString( str : String) : String
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     var freq : Sequence(int) ; freq := Integer.subrange(1,MAX_CHAR)->collect(0) ;
    execute countFreq(str, freq, len) ; 
    if (not(canMakePalindrome(freq, len))) then (     return "No Palindromic String" ) else skip ; 
    var odd_str : String ; odd_str := findOddAndRemoveItsFreq(freq) ;
    var front_str : String ; front_str := "" ;
    var rear_str : String ; rear_str := " " ;
        var i : int ; i := 0 ; while i < MAX_CHAR do ( (     var temp : String ; temp := "" ;
     if (freq[i+1] /= 0) then (     var ch : String ; ch := (i + 'a')->oclAsType(String) ;
         var j : int ; j := 1 ; while j <= freq[i+1] / 2 do ( (     temp := temp + ch )  ;     j := j + 1 ) ; 
     front_str := front_str + temp ; 
     rear_str := temp + rear_str ) else skip )  ;     i := i + 1 ) ; 
    return (front_str + odd_str + rear_str) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "malayalam" ;
     OclFile["System.out"].println(findPalindromicString(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class planet {
  public static int[] FLIP={
    0,1,5,-1,-1,2,-1,-1,8,-1 };
    public static void main(String[] args){
      Scanner stdin=new Scanner(System.in);
      int nC=stdin.nextInt();
      for(int loop=0 ; loop<nC ; loop++){
        int hr=stdin.nextInt();
        int min=stdin.nextInt();
        StringTokenizer tok=new StringTokenizer(stdin.next(),":");
        int sHr=Integer.parseInt(tok.nextToken());
        int sMin=Integer.parseInt(tok.nextToken());
        int[] res=null ;
        for(int i=sHr*min+sMin ; i<hr*min ; i++){
          res=flip(i,hr,min);
          if(res!=null)break ;
        }
        if(res==null)res=new int[] {
          0,0,0,0 };
          System.out.printf("%d%d:%d%d\n",res[0],res[1],res[2],res[3]);
        }
      }
      public static int[] flip(int val,int hr,int min){
        int thisHr=val/min ;
        int thisMin=val % min ;
        int[] disp={
          thisMin % 10,thisMin/10,thisHr % 10,thisHr/10 };
          for(int i=0 ; i<disp.length ; i++){
            if(FLIP[disp[i] ]==-1)return null ;
            disp[i]=FLIP[disp[i] ];
          }
          int newHr=10*(disp[0])+disp[1];
          int newMin=10*(disp[2])+disp[3];
          if(newHr>=hr || newMin>=min)return null ;
          return new int[] {
            thisHr/10,thisHr % 10,thisMin/10,thisMin % 10 };
          }
        }

------------------------------------------------------------
OCL File:
---------
 class planet {
  static   attribute FLIP : Sequence(int) := Sequence{0,1,5,-1,-1,2,-1,-1,8,-1};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var nC : int ; nC := stdin.getCurrent()->toInteger() ;
         var loop : int ; loop := 0 ; while loop < nC do ( (     var hr : int ; hr := stdin.getCurrent()->toInteger() ;
     var min : int ; min := stdin.getCurrent()->toInteger() ;
    var tok : OclIterator ; tok := OclIterator.newOclIterator_String_String(stdin.getCurrent(), ":") ;
    var sHr : int ; sHr := (tok.next())->toInteger() ;
    var sMin : int ; sMin := (tok.next())->toInteger() ;
    var res : Sequence(int) ; res := null ;
        var i : int ; i := sHr * min + sMin ; while i < hr * min do ( (     res := flip(i, hr, min) ; 
     if (res /= null) then     break else skip )  ;     i := i + 1 ) ; 
    if (res = null) then     res := Sequence{0,0,0,0} ; else skip ; 
    OclFile["System.out"].printf("%d%d:%d%d\n", res[0+1], res[1+1], res[2+1], res[3+1]) ; 
 )  ;     loop := loop + 1 ) );
  static   operation flip( val : int, hr : int, min : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var thisHr : int ; thisHr := val / min ;
     var thisMin : int ; thisMin := val mod min ;
    var disp : Sequence(int) ; disp := Sequence{thisMin mod 10,thisMin / 10,thisHr mod 10,thisHr / 10} ;
        var i : int ; i := 0 ; while i < disp->size() do ( (     if (FLIP[disp[i+1]+1] = -1) then     return null else skip ; 
     disp[i+1] := FLIP[disp[i+1]+1] )  ;     i := i + 1 ) ; 
    var newHr : int ; newHr := 10 * (disp[0+1]) + disp[1+1] ;
    var newMin : int ; newMin := 10 * (disp[2+1]) + disp[3+1] ;
    if (newHr >= hr or newMin >= min) then     return null else skip ; 
    return Sequence{thisHr / 10,thisHr mod 10,thisMin / 10,thisMin mod 10} 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  private static int[] calcPrimes(int n){
    boolean[] table=new boolean[n+1];
    for(int i=2 ; i<=Math.sqrt(n); i++){
      if(! table[i]){
        for(int j=i+i ; j<=n ; j+=i){
          table[j]=true ;
        }
      }
    }
    int counter=0 ;
    for(int i=2 ; i<=n ; i++){
      if(! table[i]){
        counter++;
      }
    }
    int[] result=new int[counter];
    int index=0 ;
    for(int i=2 ; i<=n ; i++){
      if(! table[i]){
        result[index++]=i ;
      }
    }
    return result ;
  }
  private static void solve(){
    Scanner scanner=new Scanner(System.in);
    int[] primes=calcPrimes(10000+100);
    while(true){
      int n=scanner.nextInt();
      if(n==0){
        break ;
      }
      int counter=0 ;
      for(int i=0 ; i<primes.length && primes[i]<=n ; i++){
        int x=n ;
        for(int j=0 ; x>0 ; j++){
          x-=primes[i+j];
        }
        if(x==0){
          counter++;
        }
      }
      System.out.println(counter);
    }
  }
  public static void main(String...args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation calcPrimes( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var table : Sequence(boolean) ; table := Integer.subrange(1,n + 1)->collect(false) ;
         var i : int ; i := 2 ; while i <= (n)->sqrt() do ( (     if (not(table[i+1])) then (         var j : int ; j := i + i ; while j <= n do ( (     table[j+1] := true )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    var counter : int ; counter := 0 ;
        var i : int ; i := 2 ; while i <= n do ( (     if (not(table[i+1])) then (     counter := counter + 1 ) else skip )  ;     i := i + 1 ) ; 
    var result : Sequence(int) ; result := Integer.subrange(1,counter)->collect(0) ;
    var index : int ; index := 0 ;
        var i : int ; i := 2 ; while i <= n do ( (     if (not(table[i+1])) then (      result[index+1] := i  ; index := index + 1 ) else skip )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var primes : Sequence(int) ; primes := calcPrimes(10000 + 100) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < primes->size() & primes[i+1] <= n do ( (     var x : int ; x := n ;
         var j : int ; j := 0 ; while x > 0 do ( (     x := x-(primes[i + j+1]) )  ;     j := j + 1 ) ; 
     if (x = 0) then (     counter := counter + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class ADzyLovesChocolate {
  public static void main(String[] args)throws IOException {
    BufferedReader buf=new BufferedReader(new InputStreamReader(System.in));
    String[] inp=buf.readLine().split(" ");
    int n=Integer.parseInt(inp[0]);
    int m=Integer.parseInt(inp[1]);
    String[] ans=new String[n];
    for(int i=0 ; i<n ; i++){
      String str=buf.readLine();
      StringBuilder temp=new StringBuilder("");
      for(int j=0 ; j<m ; j++)if(str.charAt(j)=='-')temp.append("-");
      else {
        if((i+j)% 2==1)temp.append("W");
        else temp.append("B");
      }
      ans[i]=temp.toString();
    }
    for(int i=0 ; i<n ; i++){
      System.out.println(ans[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ADzyLovesChocolate {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var buf : OclFile ; buf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var inp : Sequence(String) ; inp := buf.readLine()->split(" ") ;
    var n : int ; n := (inp[0+1])->toInteger() ;
    var m : int ; m := (inp[1+1])->toInteger() ;
    var ans : Sequence(String) ; ans := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := buf.readLine() ;
     var temp : String ; temp := StringLib.newString("") ;
         var j : int ; j := 0 ; while j < m do (     if (str->at(j+1) = '-') then     temp := temp + StringLib.newString("-") else (     if ((i + j) mod 2 = 1) then     temp := temp + StringLib.newString("W") ; else     temp := temp + StringLib.newString("B") ; ) ;   ;     j := j + 1 ) ; 
     ans[i+1] := temp+"" )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(ans[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    double[] x=new double[n];
    double[] y=new double[n];
    for(int i=0 ; i<n ; ++i){
      x[i]=sc.nextDouble();
      y[i]=sc.nextDouble();
    }
    for(int i=0 ; i<n ; ++i){
      double[] deg=new double[n-1];
      int cnt=0 ;
      for(int j=0 ; j<n ; ++j){
        if(i==j)continue ;
        deg[cnt++]=(Math.atan2(y[j]-y[i],x[j]-x[i]));
      }
      Arrays.sort(deg);
      double ans=0 ;
      for(int j=0 ; j<n-2 ; ++j){
        ans=Math.max(ans,deg[(j+1)%(n-1)]-deg[j]);
      }
      ans=Math.max(ans,Math.PI*2+deg[0]-deg[n-2]);
      ans=ans-Math.PI ;
      if(ans<=0)System.out.println(0);
      else System.out.println(String.format("%.20f",ans/(2*Math.PI)));
    }
  }
  void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : Sequence(double) ; x := Integer.subrange(1,n)->collect(0.0) ;
    var y : Sequence(double) ; y := Integer.subrange(1,n)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toReal() ; 
     y[i+1] := sc.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var deg : Sequence(double) ; deg := Integer.subrange(1,n - 1)->collect(0.0) ;
     var cnt : int ; cnt := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     if (i = j) then     continue else skip ; 
      deg[cnt+1] := (atan2(y[j+1] - y[i+1], x[j+1] - x[i+1]))  ; cnt := cnt + 1 )  ;     j := j + 1 ) ; 
    deg := deg->sort() ; 
    var ans : double ; ans := 0 ;
        var j : int ; j := 0 ; while j < n - 2 do ( (     ans := Set{ans, deg[(j + 1) mod (n - 1)+1] - deg[j+1]}->max() )  ;     j := j + 1 ) ; 
    ans := Set{ans, 3.141592653589793 * 2 + deg[0+1] - deg[n - 2+1]}->max() ; 
    ans := ans - 3.141592653589793 ; 
    if (ans <= 0) then     OclFile["System.out"].println(0) else     OclFile["System.out"].println(StringLib.format("%.20f",Sequence{ans / (2 * 3.141592653589793)})) ; ;  
 )  ;     i := i + 1 ) ; 
 );
   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Comparator ;
import java.util.Arrays ;
import java.util.List ;
import java.util.ArrayList ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int[] x=new int[N];
    int[] y=new int[N];
    for(int i=0 ; i<N ; ++i){
      x[i]=scan.nextInt();
      y[i]=scan.nextInt();
    }
    for(int i=0 ; i<N ; ++i){
      List<Double>thetas=new ArrayList<>();
      for(int j=0 ; j<N ; ++j){
        if(i==j)continue ;
        thetas.add(Math.atan2(y[j]-y[i],x[j]-x[i]));
      }
      thetas.sort(Comparator.naturalOrder());
      thetas.add(thetas.get(0)+2*Math.PI);
      double ans=0 ;
      for(int k=0 ; k<N-1 ; ++k)ans=Math.max(ans,thetas.get(k+1)-thetas.get(k)-Math.PI);
      System.out.println(ans/(Math.PI*2));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,N)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     x[i+1] := scan.getCurrent()->toInteger() ; 
     y[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var thetas : Sequence(double) ; thetas := Sequence{} ;
         var j : int ; j := 0 ; while j < N do ( (     if (i = j) then     continue else skip ; 
     thetas := thetas->including(atan2(y[j+1] - y[i+1], x[j+1] - x[i+1])) )  ;     j := j + 1 ) ; 
    thetas := thetas.sort(Comparator.naturalOrder()) ; 
    thetas := thetas->including(thetas->at(0+1) + 2 * 3.141592653589793) ; 
    var ans : double ; ans := 0 ;
        var k : int ; k := 0 ; while k < N - 1 do (     ans := Set{ans, thetas->at(k + 1+1) - thetas->at(k+1) - 3.141592653589793}->max() ;  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(ans / (3.141592653589793 * 2)) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] x=new int[n];
    int[] y=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=sc.nextInt();
      y[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      double[] angle=new double[n];
      int p=0 ;
      for(int j=0 ; j<n ; j++){
        if(j!=i){
          angle[p++]=Math.atan2(y[j]-y[i],x[j]-x[i]);
        }
      }
      Arrays.sort(angle,0,p);
      angle[p++]=angle[0]+2*Math.PI ;
      double max=0 ;
      for(int j=0 ; j+1<angle.length ; j++){
        max=Math.max(max,angle[j+1]-angle[j]);
      }
      max=Math.max(max-Math.PI,0.0);
      System.out.printf("%.15f\n",max/(2*Math.PI));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     y[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var angle : Sequence(double) ; angle := Integer.subrange(1,n)->collect(0.0) ;
     var p : int ; p := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     if (j /= i) then (      angle[p+1] := atan2(y[j+1] - y[i+1], x[j+1] - x[i+1])  ; p := p + 1 ) else skip )  ;     j := j + 1 ) ; 
    angle := angle.subrange(1,0)^(angle.subrange(0+1,p)->sort())^angle.subrange(p+1,angle.size) ; 
     angle[p+1] := angle[0+1] + 2 * 3.141592653589793  ; p := p + 1 ; 
    var max : double ; max := 0 ;
        var j : int ; j := 0 ; while j + 1 < angle->size() do ( (     max := Set{max, angle[j + 1+1] - angle[j+1]}->max() )  ;     j := j + 1 ) ; 
    max := Set{max - 3.141592653589793, 0.0}->max() ; 
    OclFile["System.out"].printf("%.15f\n", max / (2 * 3.141592653589793)) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
    String st ;
    try {
      while(true){
        st=sc.readLine();
        if(st.equals("#"))break ;
        char[] c=st.toCharArray();
        int count=0,t=check(c[0]);
        for(int i=1 ; i<c.length ; i++)if(t!=check(c[i])){
          count++;
          t=check(c[i]);
        }
        System.out.println(count);
      }
    }
    catch(Exception e){
      System.out.println("Error");
    }
  }
  private static int check(char c){
    if(c=='q' || c=='w' || c=='e' || c=='r' || c=='t' || c=='a' || c=='s' || c=='d' || c=='f' || c=='g' || c=='z' || c=='x' || c=='c' || c=='v' || c=='b')return 1 ;
    else return 2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : String ;
     try (     while (true) do (     st := sc.readLine() ; 
     if (st = "#") then     break else skip ; 
    var c : Sequence(String) ; c := st->characters() ;
    var count : int ; count := 0 ;
    var t : int ; t := check(c[0+1]) ;
        var i : int ; i := 1 ; while i < c->size() do (     if (t /= check(c[i+1])) then (     count := count + 1 ; 
     t := check(c[i+1]) ) else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) )   catch (e : ProgramException) do (     OclFile["System.out"].println("Error") )
 );
  static   operation check( c : String) : int
  pre: true
  post: true
  activity: (     if (c = 'q' or c = 'w' or c = 'e' or c = 'r' or c = 't' or c = 'a' or c = 's' or c = 'd' or c = 'f' or c = 'g' or c = 'z' or c = 'x' or c = 'c' or c = 'v' or c = 'b') then     return 1 else     return 2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.stream.IntStream ;
public class Main {
  private enum right {
    y,u,i,o,p,h,j,k,l,n,m,;
  }
  static String current="" ;
  static int cnt=0 ;
  static List<String>hands=new ArrayList<>();
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine().trim())!=null && ! "#".equals(line)){
      output(line);
      clear();
    }
  }
  public static void output(String line){
    IntStream.range(0,line.length()).mapToObj(i->line.substring(i,i+1)).forEach(key->{
      if(Arrays.stream(right.values()).map(e->e.name()).anyMatch(e->key.equals(e))){
        hands.add("r");
      }
      else {
        hands.add("l");
      };
    }
);
    IntStream.range(0,hands.size()).mapToObj(i->hands.get(i)).forEach(hand->{
      if(! current.isEmpty()&& ! current.equals(hand)){
        cnt++;
      }
      current=hand ;
    }
);
    System.out.println(cnt);
  }
  public static void clear(){
    hands.clear();
    current="" ;
    cnt=0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   class right {     static attribute y : SelfClass := SelfClass.newSelfClass();
    static attribute u : SelfClass := SelfClass.newSelfClass();
    static attribute i : SelfClass := SelfClass.newSelfClass();
    static attribute o : SelfClass := SelfClass.newSelfClass();
    static attribute p : SelfClass := SelfClass.newSelfClass();
    static attribute h : SelfClass := SelfClass.newSelfClass();
    static attribute j : SelfClass := SelfClass.newSelfClass();
    static attribute k : SelfClass := SelfClass.newSelfClass();
    static attribute l : SelfClass := SelfClass.newSelfClass();
    static attribute n : SelfClass := SelfClass.newSelfClass();
    static attribute m : SelfClass := SelfClass.newSelfClass();
  }
  static   attribute current : String := "";
  static   attribute cnt : int := 0;
  static   attribute hands : Sequence(String) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine()->trim() ;
    while ((line) /= null & not("#" = line)) do (    skip ; (     execute output(line) ; 
     execute clear() ) ;     line := br.readLine()->trim() ;
 ) );
  static   operation output( line : String) : void
  pre: true
  post: true
  activity: (     for key : Integer.subrange(0, line->size()-1).mapToObj(lambda i : OclAny in line.subrange(i+1,i + 1)) do
    (    skip) ; 
     for hand : Integer.subrange(0, hands->size()-1).mapToObj(lambda i : OclAny in hands->at(i+1)) do
    (    skip) ; 
     OclFile["System.out"].println(cnt) );
  static   operation clear() : void
  pre: true
  post: true
  activity: (     hands := hands->intersection(Set{}) ; 
     current := "" ; 
     cnt := 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  Scanner sc=new Scanner(in);
  void run(){
    Set<Character>right=new HashSet<Character>();
    right.add('y');
    right.add('u');
    right.add('i');
    right.add('o');
    right.add('p');
    right.add('h');
    right.add('j');
    right.add('k');
    right.add('l');
    right.add('n');
    right.add('m');
    String s ;
    while(true){
      s=sc.nextLine();
      if(s.equals("#"))break ;
      char[] letters=s.toCharArray();
      boolean flag=right.contains(letters[0]);
      boolean fb ;
      int count=0 ;
      for(int i=1 ; i<letters.length ; i++){
        fb=right.contains(letters[i]);
        if(flag!=fb)count++;
        flag=fb ;
      }
      out.println(count);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   operation run() : void
  pre: true
  post: true
  activity: (     var right : Set(String) ; right := Set{} ;
     right := right->including('y') ; 
    right := right->including('u') ; 
    right := right->including('i') ; 
    right := right->including('o') ; 
    right := right->including('p') ; 
    right := right->including('h') ; 
    right := right->including('j') ; 
    right := right->including('k') ; 
    right := right->including('l') ; 
    right := right->including('n') ; 
    right := right->including('m') ; 
    var s : String ;
    while (true) do (     s := sc.nextLine() ; 
     if (s = "#") then     break else skip ; 
    var letters : Sequence(String) ; letters := s->characters() ;
    var flag : boolean ; flag := right->includes(letters[0+1]) ;
    var fb : boolean ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < letters->size() do ( (     fb := right->includes(letters[i+1]) ; 
     if (flag /= fb) then     count := count + 1 ; else skip ; 
     flag := fb )  ;     i := i + 1 ) ; 
    out.println(count) ; 
 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(stdIn.hasNext()){
      String str=stdIn.next();
      if(str.equals("#")){
        break ;
      }
      boolean flag ;
      if(str.charAt(0)=='y' || str.charAt(0)=='u' || str.charAt(0)=='i' || str.charAt(0)=='o' || str.charAt(0)=='p' || str.charAt(0)=='h' || str.charAt(0)=='j' || str.charAt(0)=='k' || str.charAt(0)=='l' || str.charAt(0)=='n' || str.charAt(0)=='m'){
        flag=true ;
      }
      else {
        flag=false ;
      }
      int count=0 ;
      for(int i=0 ; i<str.length(); ++i){
        if(! flag){
          if(str.charAt(i)=='y' || str.charAt(i)=='u' || str.charAt(i)=='i' || str.charAt(i)=='o' || str.charAt(i)=='p' || str.charAt(i)=='h' || str.charAt(i)=='j' || str.charAt(i)=='k' || str.charAt(i)=='l' || str.charAt(i)=='n' || str.charAt(i)=='m'){
            flag=! flag ;
++count ;
          }
        }
        else {
          if(!(str.charAt(i)=='y' || str.charAt(i)=='u' || str.charAt(i)=='i' || str.charAt(i)=='o' || str.charAt(i)=='p' || str.charAt(i)=='h' || str.charAt(i)=='j' || str.charAt(i)=='k' || str.charAt(i)=='l' || str.charAt(i)=='n' || str.charAt(i)=='m')){
            flag=! flag ;
++count ;
          }
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (stdIn.hasNext()) do (     var str : String ; str := stdIn.getCurrent() ;
     if (str = "#") then (     break ) else skip ; 
    var flag : boolean ;
    if (str->at(0+1) = 'y' or str->at(0+1) = 'u' or str->at(0+1) = 'i' or str->at(0+1) = 'o' or str->at(0+1) = 'p' or str->at(0+1) = 'h' or str->at(0+1) = 'j' or str->at(0+1) = 'k' or str->at(0+1) = 'l' or str->at(0+1) = 'n' or str->at(0+1) = 'm') then (     flag := true ) else (     flag := false ) ;  
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (not(flag)) then (     if (str->at(i+1) = 'y' or str->at(i+1) = 'u' or str->at(i+1) = 'i' or str->at(i+1) = 'o' or str->at(i+1) = 'p' or str->at(i+1) = 'h' or str->at(i+1) = 'j' or str->at(i+1) = 'k' or str->at(i+1) = 'l' or str->at(i+1) = 'n' or str->at(i+1) = 'm') then (     flag := not(flag) ; 
     count := count + 1 ) else skip ) else (     if (not((str->at(i+1) = 'y' or str->at(i+1) = 'u' or str->at(i+1) = 'i' or str->at(i+1) = 'o' or str->at(i+1) = 'p' or str->at(i+1) = 'h' or str->at(i+1) = 'j' or str->at(i+1) = 'k' or str->at(i+1) = 'l' or str->at(i+1) = 'n' or str->at(i+1) = 'm'))) then (     flag := not(flag) ; 
     count := count + 1 ) else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  boolean[] right=new boolean[0x100];
  void run(){
    right['y']=true ;
    right['u']=true ;
    right['i']=true ;
    right['o']=true ;
    right['p']=true ;
    right['h']=true ;
    right['j']=true ;
    right['k']=true ;
    right['l']=true ;
    right['n']=true ;
    right['m']=true ;
    Scanner in=new Scanner(System.in);
    for(; ; ){
      String line=in.nextLine();
      if(line.equals("#"))return ;
      System.out.println(solve(line));
    }
  }
  int solve(String str){
    int ret=0 ;
    boolean isRight=right[str.charAt(0)];
    for(int i=1 ; i<str.length(); i++){
      if(isRight ^ right[str.charAt(i)]){
        ret++;
      }
      isRight=right[str.charAt(i)];
    }
    return ret ;
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute right : Sequence(boolean) := Integer.subrange(1,0x100)->collect(false);
   operation run() : void
  pre: true
  post: true
  activity: (     right['y'+1] := true ; 
     right['u'+1] := true ; 
    right['i'+1] := true ; 
    right['o'+1] := true ; 
    right['p'+1] := true ; 
    right['h'+1] := true ; 
    right['j'+1] := true ; 
    right['k'+1] := true ; 
    right['l'+1] := true ; 
    right['n'+1] := true ; 
    right['m'+1] := true ; 
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
      while true do ( (     var line : String ; line := in.nextLine() ;
     if (line = "#") then     return else skip ; 
     OclFile["System.out"].println(solve(line)) )  ) ; 
 );
   operation solve( str : String) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
     var isRight : boolean ; isRight := right[str->at(0+1)+1] ;
         var i : int ; i := 1 ; while i < str->size() do ( (     if (MathLib.bitwiseXor(isRight,right[str->at(i+1)+1])) then (     ret := ret + 1 ) else skip ; 
     isRight := right[str->at(i+1)+1] )  ;     i := i + 1 ) ; 
     return ret );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String str=sc.next();
    int S=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if(str.charAt(i)=='S' && str.charAt(i+1)=='F')S++;
      else if(str.charAt(i)=='F' && str.charAt(i+1)=='S')S--;
    }
    if(S>0)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var str : String ; str := sc.getCurrent() ;
    var S : int ; S := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (str->at(i+1) = 'S' & str->at(i + 1+1) = 'F') then     S := S + 1 ; else     if (str->at(i+1) = 'F' & str->at(i + 1+1) = 'S') then     S := S - 1 ; else skip ; )  ;     i := i + 1 ) ; 
    if (S > 0) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class planet {
  public static int[] FLIP={
    0,1,5,-1,-1,2,-1,-1,8,-1 };
    public static void main(String[] args){
      Scanner stdin=new Scanner(System.in);
      int nC=stdin.nextInt();
      for(int loop=0 ; loop<nC ; loop++){
        int hr=stdin.nextInt();
        int min=stdin.nextInt();
        StringTokenizer tok=new StringTokenizer(stdin.next(),":");
        int sHr=Integer.parseInt(tok.nextToken());
        int sMin=Integer.parseInt(tok.nextToken());
        int[] res=null ;
        for(int i=sHr*min+sMin ; i<hr*min ; i++){
          res=flip(i,hr,min);
          if(res!=null)break ;
        }
        if(res==null)res=new int[] {
          0,0,0,0 };
          System.out.printf("%d%d:%d%d\n",res[0],res[1],res[2],res[3]);
        }
      }
      public static int[] flip(int val,int hr,int min){
        int thisHr=val/min ;
        int thisMin=val % min ;
        int[] disp={
          thisMin % 10,thisMin/10,thisHr % 10,thisHr/10 };
          for(int i=0 ; i<disp.length ; i++){
            if(FLIP[disp[i] ]==-1)return null ;
            disp[i]=FLIP[disp[i] ];
          }
          int newHr=10*(disp[0])+disp[1];
          int newMin=10*(disp[2])+disp[3];
          if(newHr>=hr || newMin>=min)return null ;
          return new int[] {
            thisHr/10,thisHr % 10,thisMin/10,thisMin % 10 };
          }
        }

------------------------------------------------------------
OCL File:
---------
 class planet {
  static   attribute FLIP : Sequence(int) := Sequence{0,1,5,-1,-1,2,-1,-1,8,-1};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var nC : int ; nC := stdin.getCurrent()->toInteger() ;
         var loop : int ; loop := 0 ; while loop < nC do ( (     var hr : int ; hr := stdin.getCurrent()->toInteger() ;
     var min : int ; min := stdin.getCurrent()->toInteger() ;
    var tok : OclIterator ; tok := OclIterator.newOclIterator_String_String(stdin.getCurrent(), ":") ;
    var sHr : int ; sHr := (tok.next())->toInteger() ;
    var sMin : int ; sMin := (tok.next())->toInteger() ;
    var res : Sequence(int) ; res := null ;
        var i : int ; i := sHr * min + sMin ; while i < hr * min do ( (     res := flip(i, hr, min) ; 
     if (res /= null) then     break else skip )  ;     i := i + 1 ) ; 
    if (res = null) then     res := Sequence{0,0,0,0} ; else skip ; 
    OclFile["System.out"].printf("%d%d:%d%d\n", res[0+1], res[1+1], res[2+1], res[3+1]) ; 
 )  ;     loop := loop + 1 ) );
  static   operation flip( val : int, hr : int, min : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var thisHr : int ; thisHr := val / min ;
     var thisMin : int ; thisMin := val mod min ;
    var disp : Sequence(int) ; disp := Sequence{thisMin mod 10,thisMin / 10,thisHr mod 10,thisHr / 10} ;
        var i : int ; i := 0 ; while i < disp->size() do ( (     if (FLIP[disp[i+1]+1] = -1) then     return null else skip ; 
     disp[i+1] := FLIP[disp[i+1]+1] )  ;     i := i + 1 ) ; 
    var newHr : int ; newHr := 10 * (disp[0+1]) + disp[1+1] ;
    var newMin : int ; newMin := 10 * (disp[2+1]) + disp[3+1] ;
    if (newHr >= hr or newMin >= min) then     return null else skip ; 
    return Sequence{thisHr / 10,thisHr mod 10,thisMin / 10,thisMin mod 10} 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
import java.util.*;
public class Test {
  static Scanner sc=new Scanner(System.in);
  static BufferedWriter write=new BufferedWriter(new OutputStreamWriter(System.out));
  static PrintWriter out=new PrintWriter(write);
  public static void main(String[] args)throws java.lang.Exception {
    int r=sc.nextInt();
    int c=sc.nextInt();
    char dp[][]=new char[r][c];
    sc.nextLine();
    for(int i=0 ; i<r ; i++){
      String s=sc.nextLine();
      for(int j=0 ; j<c ; j++){
        if(s.charAt(j)=='.'){
          if((j+i)% 2==0)dp[i][j]='B' ;
          else dp[i][j]='W' ;
        }
        else dp[i][j]='-' ;
      }
    }
    for(int i=0 ; i<r ; i++){
      for(int j=0 ; j<c ; j++)out.print(dp[i][j]);
      out.println();
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute write : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(write);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : int ; r := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
    var dp : Sequence(Sequence(String)) ; dp := Integer.subrange(1,r)->collect(Integer.subrange(1,c)->collect(0)) ;
    skip ; 
        var i : int ; i := 0 ; while i < r do ( (     var s : String ; s := sc.nextLine() ;
         var j : int ; j := 0 ; while j < c do ( (     if (s->at(j+1) = '.') then (     if ((j + i) mod 2 = 0) then     dp[i+1][j+1] := 'B' ; else     dp[i+1][j+1] := 'W' ; ) else     dp[i+1][j+1] := '-' ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < r do ( (         var j : int ; j := 0 ; while j < c do (     skip ;  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BetweenTheOffices {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),c=0,d=0 ;
    String s=sc.next();
    char[] ch=s.toCharArray();
    for(int i=0 ; i<s.length()-1 ; i++){
      if(ch[i]=='S' && ch[i+1]=='F'){
        c++;
      }
      else if(ch[i]=='F' && ch[i+1]=='S'){
        d++;
      }
    }
    if(c>d){
      System.out.println("YES");
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class BetweenTheOffices {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
    var d : int ; d := 0 ;
    var s : String ; s := sc.getCurrent() ;
    var ch : Sequence(String) ; ch := s->characters() ;
        var i : int ; i := 0 ; while i < s->size() - 1 do ( (     if (ch[i+1] = 'S' & ch[i + 1+1] = 'F') then (     c := c + 1 ) else     if (ch[i+1] = 'F' & ch[i + 1+1] = 'S') then (     d := d + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    if (c > d) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BetweentheOffices {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String s=in.next();
    String y=null ;
    int CountS=0 ;
    int CountF=0 ;
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='F'){
        if(y==null){
          y="F" ;
        }
        else if(y=="F"){
          continue ;
        }
        else {
          CountF++;
          y="F" ;
        }
      }
      else if(s.charAt(i)=='S'){
        if(y==null){
          y="S" ;
        }
        else if(y=="S"){
          continue ;
        }
        else {
          CountS++;
          y="S" ;
        }
      }
    }
    if(CountF>CountS){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BetweentheOffices {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var y : String ; y := null ;
    var CountS : int ; CountS := 0 ;
    var CountF : int ; CountF := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = 'F') then (     if (y = null) then (     y := "F" ) else     if (y = "F") then (     continue ) else (     CountF := CountF + 1 ; 
     y := "F" ) ;  ) else     if (s->at(i+1) = 'S') then (     if (y = null) then (     y := "S" ) else     if (y = "S") then (     continue ) else (     CountS := CountS + 1 ; 
     y := "S" ) ;  ) else skip ; )  ;     i := i + 1 ) ; 
    if (CountF > CountS) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    int n=fs.nextInt();
    String s=fs.next();
    int seattle=0 ;
    int sanfransico=0 ;
    for(int i=1 ; i<s.length(); i++)if(s.charAt(i)!=s.charAt(i-1)&& s.charAt(i-1)=='S')seattle++;
    else if(s.charAt(i)!=s.charAt(i-1)&& s.charAt(i-1)=='F')sanfransico++;
    if(seattle>sanfransico)System.out.println("YES");
    else System.out.println("NO");
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! 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());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var n : int ; n := fs.nextInt() ;
    var s : String ; s := fs.next() ;
    var seattle : int ; seattle := 0 ;
    var sanfransico : int ; sanfransico := 0 ;
        var i : int ; i := 1 ; while i < s->size() do (     if (s->at(i+1) /= s->at(i - 1+1) & s->at(i - 1+1) = 'S') then     seattle := seattle + 1 else     if (s->at(i+1) /= s->at(i - 1+1) & s->at(i - 1+1) = 'F') then     sanfransico := sanfransico + 1 ; else skip ; ;   ;     i := i + 1 ) ; 
    if (seattle > sanfransico) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] s=sc.next().toCharArray();
    int cnto=0 ;
    int cntz=0 ;
    for(int i=1 ; i<n ; ++i){
      if(s[i]=='F' && s[i-1]=='S'){
        cntz++;
      }
      else if(s[i]=='S' && s[i-1]=='F'){
        cnto++;
      }
    }
    if(cnto<cntz){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var cnto : int ; cnto := 0 ;
    var cntz : int ; cntz := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (s[i+1] = 'F' & s[i - 1+1] = 'S') then (     cntz := cntz + 1 ) else     if (s[i+1] = 'S' & s[i - 1+1] = 'F') then (     cnto := cnto + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    if (cnto < cntz) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test247 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      long a[]=new long[n];
      long max=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextLong();
      }
      if(n==2){
        max=a[0]*a[1];
      }
      for(int i=1 ; i<n-1 ; i++){
        if(a[i-1]>a[i+1]){
          if(a[i]*a[i-1]>max){
            max=a[i]*a[i-1];
          }
        }
        else {
          if(a[i]*a[i+1]>max){
            max=a[i]*a[i+1];
          }
        }
      }
      System.out.println(max);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test247 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var max : long ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    if (n = 2) then (     max := a[0+1] * a[1+1] ) else skip ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     if (a[i - 1+1] > a[i + 1+1]) then (     if (a[i+1] * a[i - 1+1] > max) then (     max := a[i+1] * a[i - 1+1] ) else skip ) else (     if (a[i+1] * a[i + 1+1] > max) then (     max := a[i+1] * a[i + 1+1] ) else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Cherry {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    while(test-->0){
      int n=sc.nextInt();
      long[] nums=new long[n];
      long product=1 ;
      for(int i=0 ; i<n ; i++){
        if(i==0 || i==n-1){
          nums[i]=sc.nextLong();
        }
        else {
          nums[i]=sc.nextLong();
          product=Math.max(product,nums[i]*nums[i-1]);
        }
      }
      product=Math.max(product,nums[n-1]*nums[n-2]);
      System.out.println(product);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cherry {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var nums : Sequence(long) ; nums := Integer.subrange(1,n)->collect(0) ;
    var product : long ; product := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i = 0 or i = n - 1) then (     nums[i+1] := sc.getCurrent()->toLong() ) else (     nums[i+1] := sc.getCurrent()->toLong() ; 
     product := Set{product, nums[i+1] * nums[i - 1+1]}->max() ) )  ;     i := i + 1 ) ; 
    product := Set{product, nums[n - 1+1] * nums[n - 2+1]}->max() ; 
    OclFile["System.out"].println(product) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A1544 {
  static FastScanner fs=null ;
  public static void main(String[] args){
    fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int t=fs.nextInt();
    while(t-->0){
      int n=fs.nextInt();
      long a[]=new long[n];
      for(int i=0 ; i<n ; i++){
        a[i]=fs.nextLong();
      }
      long ans=-(long)1 ;
      for(int i=1 ; i<n ; i++){
        long pr=a[i]*a[i-1];
        ans=Math.max(ans,pr);
      }
      out.println(ans);
    }
    out.close();
  }
  static void sort(int[] a){
    ArrayList<Integer>l=new ArrayList<>();
    for(int i : a)l.add(i);
    Collections.sort(l);
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1544 {
  static   attribute fs : FastScanner := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     fs := FastScanner.newFastScanner() ; 
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := fs.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := fs.nextInt() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := fs.nextLong() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := -1->oclAsType(long) ;
        var i : int ; i := 1 ; while i < n do ( (     var pr : long ; pr := a[i+1] * a[i - 1+1] ;
     ans := Set{ans, pr}->max() )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l := l->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
class Test {
  static int FindLCM(int a,int b){
    return(a*b)/new BigInteger(a+"").gcd(new BigInteger(b+"")).intValue();
  }
  static int rangeDivisor(int m,int n,int a,int b){
    int lcm=FindLCM(a,b);
    int a_divisor=n/a-(m-1)/a ;
    int b_divisor=n/b-(m-1)/b ;
    int common_divisor=n/lcm-(m-1)/lcm ;
    int ans=a_divisor+b_divisor-common_divisor ;
    return ans ;
  }
  public static void main(String args[]){
    int m=3,n=11,a=2,b=3 ;
    System.out.println(rangeDivisor(m,n,a,b));
    m=11 ;
    n=1000000 ;
    a=6 ;
    b=35 ;
    System.out.println(rangeDivisor(m,n,a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation FindLCM( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return (a * b) / long(a + "").gcd(long(b + ""))->oclAsType(int) );
  static   operation rangeDivisor( m : int, n : int, a : int, b : int) : int
  pre: true
  post: true
  activity: (     var lcm : int ; lcm := FindLCM(a, b) ;
     var a_divisor : int ; a_divisor := n / a - (m - 1) / a ;
    var b_divisor : int ; b_divisor := n / b - (m - 1) / b ;
    var common_divisor : int ; common_divisor := n / lcm - (m - 1) / lcm ;
    var ans : int ; ans := a_divisor + b_divisor - common_divisor ;
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 3 ;
    var n : int ; n := 11 ;
    var a : int ; a := 2 ;
    var b : int ; b := 3 ;
     OclFile["System.out"].println(rangeDivisor(m, n, a, b)) ; 
    m := 11 ; 
    n := 1000000 ; 
    a := 6 ; 
    b := 35 ; 
    OclFile["System.out"].println(rangeDivisor(m, n, a, b)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class Punctuation {
  public static boolean isLatinLetter(char c){
    return c>='a' && c<='z' ;
  }
  public static boolean isPunctuation(char c){
    if(c=='.')return true ;
    if(c==',')return true ;
    if(c=='!')return true ;
    if(c=='?')return true ;
    return false ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    String s=br.readLine();
    StringBuilder sb=new StringBuilder();
    int n=s.length();
    sb.append(s.charAt(0));
    for(int i=1 ; i<n ; i++){
      char c=s.charAt(i);
      if(isLatinLetter(c)){
        if(! isLatinLetter(s.charAt(i-1))){
          sb.append(' ');
        }
        sb.append(c);
      }
      else if(isPunctuation(c)){
        sb.append(c);
      }
    }
    pw.println(sb);
    pw.flush();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Punctuation {
  static   operation isLatinLetter( c : String) : boolean
  pre: true
  post: true
  activity: (     return c >= 'a' & c <= 'z' );
  static   operation isPunctuation( c : String) : boolean
  pre: true
  post: true
  activity: (     if (c = '.') then     return true else skip ; 
     if (c = ',') then     return true else skip ; 
    if (c = '!') then     return true else skip ; 
    if (c = '?') then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : String ; s := br.readLine() ;
    var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := s->size() ;
    sb := sb + StringLib.newString(s->at(0+1)) ; 
        var i : int ; i := 1 ; while i < n do ( (     var c : String ; c := s->at(i+1) ;
     if (isLatinLetter(c)) then (     if (not(isLatinLetter(s->at(i - 1+1)))) then (     sb := sb + StringLib.newString(' ') ) else skip ; 
     sb := sb + StringLib.newString(c) ) else     if (isPunctuation(c)) then (     sb := sb + StringLib.newString(c) ) else skip ; )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int smallestKFreq(int a[],int n,int k){
    HashMap<Integer,Integer>m=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++)if(m.containsKey(a[i]))m.put(a[i],m.get(a[i])+1);
    else m.put(a[i],1);
    int res=Integer.MAX_VALUE ;
    Set<Integer>s=m.keySet();
    for(int temp : s)if(m.get(temp)==k)res=Math.min(res,temp);
    return(res!=Integer.MAX_VALUE)? res :-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      2,2,1,3,1 };
      int k=2 ;
      System.out.println(smallestKFreq(arr,arr.length,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation smallestKFreq( a : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var m : Map(int,int) ; m := Map{} ;
         var i : int ; i := 0 ; while i < n do (     if (m->keys()->includes(a[i+1])) then     m := m->union(Map{a[i+1] |-> m->at(a[i+1]) + 1}) else     m := m->union(Map{a[i+1] |-> 1}) ; ;   ;     i := i + 1 ) ; 
    var res : int ; res := 2147483647 ;
    var s : Set(int) ; s := m->keys() ;
    for (temp : s) do (     if (m->at(temp) = k) then     res := Set{res, temp}->min() ; else skip ;  ) ; 
    return if (res /= 2147483647) then res else -1 endif 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,2,1,3,1} ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(smallestKFreq(arr, arr->size(), k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class FlippingGame {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    if(scanner.hasNext()){
      int n=scanner.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=scanner.nextInt();
      int max=Integer.MIN_VALUE ;
      for(int i=0 ; i<n ; i++){
        for(int j=i ; j<n ; j++){
          int x=0 ;
          int brr[]=new int[n];
          for(int k : arr)brr[x++]=k ;
          for(int k=i ; k<=j ; k++){
            if(brr[k]==0)brr[k]=1 ;
            else brr[k]=0 ;
          }
          int count=checKNo(brr);
          if(count>max)max=count ;
        }
      }
      if(n==1){
        if(arr[0]==1)System.out.println(0);
        else System.out.println(1);
      }
      else {
        System.out.println(max);
      }
    }
  }
  private static int checKNo(int[] brr){
    int val=0 ;
    for(int i : brr)if(i==1)++val ;
    return val ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class FlippingGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     if (scanner.hasNext()) then (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i ; while j < n do ( (     var x : int ; x := 0 ;
     var brr : Sequence(int) ; brr := Integer.subrange(1,n)->collect(0) ;
    for (k : arr) do (      brr[x+1] := k  ; x := x + 1 ;  ) ; 
        var k : int ; k := i ; while k <= j do ( (     if (brr[k+1] = 0) then     brr[k+1] := 1 ; else     brr[k+1] := 0 ; )  ;     k := k + 1 ) ; 
    var count : int ; count := checKNo(brr) ;
    if (count > max) then     max := count ; else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (n = 1) then (     if (arr[0+1] = 1) then     OclFile["System.out"].println(0) ; else     OclFile["System.out"].println(1) ; ) else (     OclFile["System.out"].println(max) ) ;  
 ) else skip );
  static   operation checKNo( brr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var val : int ; val := 0 ;
     for (i : brr) do (     if (i = 1) then     val := val + 1 ; else skip ;  ) ; 
     return val );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  static FastReader sc=null ;
  public static void main(String[] args){
    sc=new FastReader();
    int n=sc.nextInt();
    System.out.println(n/2+1);
    int x=1,y=1 ;
    int cur=0 ;
    while(cur<n){
      System.out.println(x+" "+y);
      if(cur % 2==1)y++;
      else x++;
      cur++;
    }
  }
  static int[] ruffleSort(int a[]){
    ArrayList<Integer>al=new ArrayList<>();
    for(int i : a)al.add(i);
    Collections.sort(al);
    for(int i=0 ; i<a.length ; i++)a[i]=al.get(i);
    return a ;
  }
  static void print(int a[]){
    for(int e : a){
      System.out.print(e+" ");
    }
    System.out.println();
  }
  static class FastReader {
    StringTokenizer st=new StringTokenizer("");
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String next(){
      while(! st.hasMoreTokens())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());
    }
    int[] readArray(int n){
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute sc : FastReader := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := FastReader.newFastReader() ; 
     var n : int ; n := sc.nextInt() ;
    OclFile["System.out"].println(n / 2 + 1) ; 
    var x : int ; x := 1 ;
    var y : int ; y := 1 ;
    var cur : int ; cur := 0 ;
    while (cur < n) do (     OclFile["System.out"].println(x + " " + y) ; 
     if (cur mod 2 = 1) then     y := y + 1 else     x := x + 1 ; ;  
     cur := cur + 1 ) ; 
 );
  static   operation ruffleSort( a : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var al : Sequence(int) ; al := Sequence{} ;
     for (i : a) do (     al := al->including(i) ;  ) ; 
    al := al->sort() ; 
        var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := al->at(i+1) ;  ;     i := i + 1 ) ; 
    return a 
 );
  static   operation print( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     for (e : a) do ( (     OclFile["System.out"].print(e + " ") )  ) ; 
     OclFile["System.out"].println() );
  static class FastReader {
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Map.Entry ;
class Main {
  static int mod=(int)(Math.pow(10,9)+7);
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S="0"+sc.next();
    char[] c=S.toCharArray();
    int N=c.length ;
    int[][] dp=new int[N+1][2];
    dp[N][0]=Character.getNumericValue(c[0]);
    dp[N][1]=10-Character.getNumericValue(c[0]);
    for(int i=N-1 ; i>=0 ; i--){
      Arrays.fill(dp[i],Integer.MAX_VALUE);
      for(int j=0 ; j<2 ; j++){
        for(int k=0 ; k<10 ; k++){
          int tmp=Character.getNumericValue(c[i])+j ;
          tmp=k-tmp ;
          if(tmp<0){
            dp[i][1]=Math.min(dp[i][1],dp[i+1][j]+tmp+10+k);
          }
          else {
            dp[i][0]=Math.min(dp[i][0],dp[i+1][j]+tmp+k);
          }
        }
      }
    }
    System.out.println(dp[0][0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := (10->pow(9) + 7)->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := "0" + sc.getCurrent() ;
    var c : Sequence(String) ; c := S->characters() ;
    var N : int ; N := c->size() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,2)->collect(0)) ;
    dp[N+1][0+1] := ("" + c[0+1])->toInteger() ; 
    dp[N+1][1+1] := 10 - ("" + c[0+1])->toInteger() ; 
        var i : int ; i := N - 1 ; while i >= 0 do ( (     dp[i+1] := dp[i+1]->collect(2147483647) ; 
         var j : int ; j := 0 ; while j < 2 do ( (         var k : int ; k := 0 ; while k < 10 do ( (     var tmp : int ; tmp := ("" + c[i+1])->toInteger() + j ;
     tmp := k - tmp ; 
     if (tmp < 0) then (     dp[i+1][1+1] := Set{dp[i+1][1+1], dp[i + 1+1][j+1] + tmp + 10 + k}->min() ) else (     dp[i+1][0+1] := Set{dp[i+1][0+1], dp[i + 1+1][j+1] + tmp + k}->min() ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(dp[0+1][0+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  Scanner sc ;
  String N ;
  private void calc(){
    sc=new Scanner(System.in);
    N=sc.next();
    int ans=0 ;
    int carry=0 ;
    for(int i=N.length()-1 ; i>=0 ; i--){
      int d=N.charAt(i)-'0'+carry ;
      int n=(i>0)? N.charAt(i-1)-'0' : 0 ;
      if(d>5 ||(d==5 && n>4)){
        carry=1 ;
        ans+=10-d ;
      }
      else {
        carry=0 ;
        ans+=d ;
      }
    }
    System.out.println(ans+carry);
  }
  public static void main(String[] args){
    new Main().calc();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute N : String;
   operation calc() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     N := sc.getCurrent() ; 
    var ans : int ; ans := 0 ;
    var carry : int ; carry := 0 ;
        var i : int ; i := N->size() - 1 ; while i >= 0 do ( (     var d : int ; d := N->at(i+1) - ('0')->char2byte() + carry ;
     var n : int ; n := if (i > 0) then N->at(i - 1+1) - ('0')->char2byte() else 0 endif ;
     if (d > 5 or (d = 5 & n > 4)) then (     carry := 1 ; 
     ans := ans+(10 - d) ) else (     carry := 0 ; 
     ans := ans+(d) ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans + carry) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().calc() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    final long INF=(long)1e15 ;
    Scanner sc=new Scanner(System.in);
    String number=sc.next();
    int[] digits=new int[number.length()+1];
    for(int i=0 ; i<number.length(); i++){
      digits[i]=number.charAt(number.length()-1-i)-'0' ;
    }
    int bills=0 ;
    for(int i=0 ; i<=number.length(); i++){
      if(digits[i]==10){
        digits[i+1]++;
        digits[i]=0 ;
      }
      if(digits[i]<5){
        bills+=digits[i];
      }
      else if(digits[i]==5){
        if(digits[i+1]>=5){
          digits[i+1]++;
        }
        bills+=5 ;
      }
      else {
        digits[i+1]++;
        bills+=10-digits[i];
      }
    }
    System.out.println(bills);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var INF : long ; INF := 1e15->oclAsType(long) ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var number : String ; number := sc.getCurrent() ;
    var digits : Sequence(int) ; digits := Integer.subrange(1,number->size() + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < number->size() do ( (     digits[i+1] := number->at(number->size() - 1 - i+1) - ('0')->char2byte() )  ;     i := i + 1 ) ; 
    var bills : int ; bills := 0 ;
        var i : int ; i := 0 ; while i <= number->size() do ( (     if (digits[i+1] = 10) then (     digits[i + 1+1] := digits[i + 1+1] + 1 ; 
     digits[i+1] := 0 ) else skip ; 
     if (digits[i+1] < 5) then (     bills := bills+(digits[i+1]) ) else     if (digits[i+1] = 5) then (     if (digits[i + 1+1] >= 5) then (     digits[i + 1+1] := digits[i + 1+1] + 1 ) else skip ; 
     bills := bills+(5) ) else (     digits[i + 1+1] := digits[i + 1+1] + 1 ; 
     bills := bills+(10 - digits[i+1]) ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(bills) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    StringBuffer sb=new StringBuffer(s);
    s=sb.reverse().toString();
    s=s+"0" ;
    char c[]=s.toCharArray();
    int n=s.length();
    int INF=Integer.MAX_VALUE/2 ;
    int dp[][]=new int[n+2][2];
    for(int i=0 ; i<n+1 ; i++){
      for(int j=0 ; j<2 ; j++)dp[i][j]=INF ;
    }
    dp[0][0]=0 ;
    for(int i=0 ; i<n ; i++){
      int now=c[i]-'0' ;
      for(int j=0 ; j<2 ; j++){
        now+=j ;
        for(int a=0 ; a<10 ; a++){
          int ni=i+1,nj=0 ;
          int b=a-now ;
          if(b<0){
            b+=10 ;
            nj=1 ;
          }
          dp[ni][nj]=Math.min(dp[ni][nj],dp[i][j]+a+b);
        }
      }
    }
    int ans=dp[n][0];
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var sb : String ; sb := StringLib.newString(s) ;
    s := sb->reverse()+"" ; 
    s := s + "0" ; 
    var c : Sequence(String) ; c := s->characters() ;
    var n : int ; n := s->size() ;
    var INF : int ; INF := 2147483647 / 2 ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 2)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n + 1 do ( (         var j : int ; j := 0 ; while j < 2 do (     dp[i+1][j+1] := INF ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     var now : int ; now := c[i+1] - ('0')->char2byte() ;
         var j : int ; j := 0 ; while j < 2 do ( (     now := now+(j) ; 
         var a : int ; a := 0 ; while a < 10 do ( (     var ni : int ; ni := i + 1 ;
    var nj : int ; nj := 0 ;
     var b : int ; b := a - now ;
     if (b < 0) then (     b := b+(10) ; 
     nj := 1 ) else skip ; 
     dp[ni+1][nj+1] := Set{dp[ni+1][nj+1], dp[i+1][j+1] + a + b}->min() )  ;     a := a + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := dp[n+1][0+1] ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    String S=scan.next();
    char[] d=S.toCharArray();
    int len=d.length ;
    int[] digits=new int[len+1];
    digits[0]=0 ;
    for(int i=1 ; i<=len ; i++){
      digits[i]=d[i-1]-'0' ;
    }
    int[][] dp=new int[len+1][2];
    dp[0][0]=0 ;
    dp[0][1]=1 ;
    for(int i=1 ; i<=len ; i++){
      dp[i][0]=Math.min(dp[i-1][0]+digits[i],dp[i-1][1]+10-digits[i]);
      dp[i][1]=Math.min(dp[i-1][0]+digits[i]+1,dp[i-1][1]+10-digits[i]-1);
    }
    System.out.println(dp[len][0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var S : String ; S := scan.getCurrent() ;
    var d : Sequence(String) ; d := S->characters() ;
    var len : int ; len := d->size() ;
    var digits : Sequence(int) ; digits := Integer.subrange(1,len + 1)->collect(0) ;
    digits[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= len do ( (     digits[i+1] := d[i - 1+1] - ('0')->char2byte() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,len + 1)->collect(Integer.subrange(1,2)->collect(0)) ;
    dp[0+1][0+1] := 0 ; 
    dp[0+1][1+1] := 1 ; 
        var i : int ; i := 1 ; while i <= len do ( (     dp[i+1][0+1] := Set{dp[i - 1+1][0+1] + digits[i+1], dp[i - 1+1][1+1] + 10 - digits[i+1]}->min() ; 
     dp[i+1][1+1] := Set{dp[i - 1+1][0+1] + digits[i+1] + 1, dp[i - 1+1][1+1] + 10 - digits[i+1] - 1}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[len+1][0+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean areVowelsInOrder(String s){
    int n=s.length();
    char c=(char)64 ;
    for(int i=1 ; i<n ; i++){
      if(s.charAt(i)=='a' || s.charAt(i)=='e' || s.charAt(i)=='i' || s.charAt(i)=='o' || s.charAt(i)=='u'){
        if(s.charAt(i)<c)return false ;
        else {
          c=s.charAt(i);
        }
      }
    }
    return true ;
  }
  public static void main(String[] args){
    String s="aabbbddeecc" ;
    if(areVowelsInOrder(s))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation areVowelsInOrder( s : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var c : String ; c := 64->oclAsType(String) ;
         var i : int ; i := 1 ; while i < n do ( (     if (s->at(i+1) = 'a' or s->at(i+1) = 'e' or s->at(i+1) = 'i' or s->at(i+1) = 'o' or s->at(i+1) = 'u') then (     if (s->at(i+1) < c) then     return false else (     c := s->at(i+1) ) ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "aabbbddeecc" ;
     if (areVowelsInOrder(s)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    int[] list1=new int[180];
    int[] cnt1=new int[1000001];
    int[] cnt2=new int[1000001];
    for(int i=0 ; i<180 ; i++){
      list1[i]=(i+1)*(i+2)*(i+3)/6 ;
    }
    for(int i=0 ; i<=1000000 ; i++){
      cnt1[i]=i ;
      cnt2[i]=i ;
    }
    for(int n=3,p=4 ; p<=1000000 ; n++){
      for(int i=0 ; i+p<=1000000 ; i++){
        cnt1[i+p]=Math.min(cnt1[i+p],cnt1[i]+1);
      }
      if(p % 2==1){
        for(int i=0 ; i+p<=1000000 ; i++){
          cnt2[i+p]=Math.min(cnt2[i+p],cnt2[i]+1);
        }
      }
      p=n*(n+1)*(n+2)/6 ;
    }
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      int num=Integer.parseInt(br.readLine());
      if(num==0)break ;
      System.out.println(cnt1[num]+" "+cnt2[num]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var list1 : Sequence(int) ; list1 := Integer.subrange(1,180)->collect(0) ;
     var cnt1 : Sequence(int) ; cnt1 := Integer.subrange(1,1000001)->collect(0) ;
    var cnt2 : Sequence(int) ; cnt2 := Integer.subrange(1,1000001)->collect(0) ;
        var i : int ; i := 0 ; while i < 180 do ( (     list1[i+1] := (i + 1) * (i + 2) * (i + 3) / 6 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= 1000000 do ( (     cnt1[i+1] := i ; 
     cnt2[i+1] := i )  ;     i := i + 1 ) ; 
        var n : int ; n := 3 ;
    var p : int ; p := 4 ; while p <= 1000000 do ( (         var i : int ; i := 0 ; while i + p <= 1000000 do ( (     cnt1[i + p+1] := Set{cnt1[i + p+1], cnt1[i+1] + 1}->min() )  ;     i := i + 1 ) ; 
     if (p mod 2 = 1) then (         var i : int ; i := 0 ; while i + p <= 1000000 do ( (     cnt2[i + p+1] := Set{cnt2[i + p+1], cnt2[i+1] + 1}->min() )  ;     i := i + 1 ) ) else skip ; 
     p := n * (n + 1) * (n + 2) / 6 )  ;     n := n + 1 ) ; 
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    while (true) do (     var num : int ; num := (br.readLine())->toInteger() ;
     if (num = 0) then     break else skip ; 
     OclFile["System.out"].println(cnt1[num+1] + " " + cnt2[num+1]) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import javax.naming.BinaryRefAddr ;
import static java.lang.System.*;
class Main {
  public static Scanner sc=new Scanner(in);
  public static Random rand=new Random();
  public void run(){
    List<Integer>pollock=new ArrayList<Integer>();
    for(int i=1 ; i*(i+1)*(i+2)/6<1000000 ; i++){
      pollock.add(i*(i+1)*(i+2)/6);
    }
    int[] dp=new int[1000000],dp2=new int[1000000];
    for(int i=1 ; i<1000000 ; i++){
      int min=Integer.MAX_VALUE ;
      for(int j : pollock){
        if(i-j>=0)min=Math.min(min,dp[i-j]+1);
      }
      dp[i]=min ;
    }
    for(int i=1 ; i<1000000 ; i++){
      int min=Integer.MAX_VALUE ;
      for(int j : pollock){
        if(i-j>=0 && j % 2==1)min=Math.min(min,dp2[i-j]+1);
      }
      dp2[i]=min ;
    }
    while(true){
      int n=sc.nextInt();
      if(n==0)return ;
      ln(dp[n]+" "+dp2[n]);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  public int[] nextIntArray(int n){
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=sc.nextInt();
    }
    return res ;
  }
  public static void pr(Object o){
    out.print(o);
  }
  public static void ln(Object o){
    out.println(o);
  }
  public static void ln(){
    out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(in);
  static   attribute rand : OclRandom := OclRandom.newOclRandom();
   operation run() : void
  pre: true
  post: true
  activity: (     var pollock : Sequence(int) ; pollock := Sequence{} ;
         var i : int ; i := 1 ; while i * (i + 1) * (i + 2) / 6 < 1000000 do ( (     pollock := pollock->including(i * (i + 1) * (i + 2) / 6) )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,1000000)->collect(0) ;
    var dp2 : Sequence(int) ; dp2 := Integer.subrange(1,1000000)->collect(0) ;
        var i : int ; i := 1 ; while i < 1000000 do ( (     var min : int ; min := 2147483647 ;
     for (j : pollock) do ( (     if (i - j >= 0) then     min := Set{min, dp[i - j+1] + 1}->min() ; else skip )  ) ; 
     dp[i+1] := min )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < 1000000 do ( (     var min : int ; min := 2147483647 ;
     for (j : pollock) do ( (     if (i - j >= 0 & j mod 2 = 1) then     min := Set{min, dp2[i - j+1] + 1}->min() ; else skip )  ) ; 
     dp2[i+1] := min )  ;     i := i + 1 ) ; 
    while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
     execute ln(dp[n+1] + " " + dp2[n+1]) ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return res );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     out.println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Word {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    byte uc=0,lc=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)>='a' && s.charAt(i)<='z')lc++;
      if(s.charAt(i)>='A' && s.charAt(i)<='Z')uc++;
    }
    System.out.println((lc<uc)? s.toUpperCase(): s.toLowerCase());
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Word {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var uc : int ; uc := 0 ;
    var lc : int ; lc := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) >= 'a' & s->at(i+1) <= 'z') then     lc := lc + 1 ; else skip ; 
     if (s->at(i+1) >= 'A' & s->at(i+1) <= 'Z') then     uc := uc + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if (lc < uc) then s->toUpperCase() else s->toLowerCase() endif) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  static int[][] map ;
  public static void main(String[] args)throws IOException {
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader reader=new BufferedReader(isr);
    Main app=new Main();
    while(true){
      map=new int[12][];
      for(int i=0 ; i<12 ; i++)map[i]=app.toIntegerArrays(reader.readLine().toCharArray(),0);
      int count=0 ;
      for(int i=0 ; i<12 ; i++){
        for(int j=0 ; j<12 ; j++){
          if(map[i][j]==1){
            app.check(i,j);
            count++;
          }
        }
      }
      System.out.println(count);
      if(reader.readLine()==null)break ;
    }
    isr.close();
    reader.close();
  }
  public void check(int x,int y){
    if(x>11 || y>11 || x<0 || y<0 || map[x][y]==0)return ;
    map[x][y]=0 ;
    check(x+1,y);
    check(x-1,y);
    check(x,y+1);
    check(x,y-1);
  }
  public int[] toIntegerArrays(char[] array,int i){
    int[] result=new int[12];
    for(int var : array)result[i++]=(int)var-(int)'0' ;
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute map : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(isr) ;
    var app : Main ; app := Main.newMain() ;
    while (true) do (     map := Integer.subrange(1,12)->collect(Sequence{}) ; 
         var i : int ; i := 0 ; while i < 12 do (     map[i+1] := app.toIntegerArrays(reader.readLine()->characters(), 0) ;  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < 12 do ( (         var j : int ; j := 0 ; while j < 12 do ( (     if (map[i+1][j+1] = 1) then (     app.check(i, j) ; 
     count := count + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    if (reader.readLine() = null) then     break else skip ; 
 ) ; 
    skip ; 
    skip ; 
 );
   operation check( x : int, y : int) : void
  pre: true
  post: true
  activity: (     if (x > 11 or y > 11 or x < 0 or y < 0 or map[x+1][y+1] = 0) then     return else skip ; 
     map[x+1][y+1] := 0 ; 
    execute check(x + 1, y) ; 
    execute check(x - 1, y) ; 
    execute check(x, y + 1) ; 
    execute check(x, y - 1) ; 
 );
   operation toIntegerArrays( array : Sequence(String), i : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var result : Sequence(int) ; result := Integer.subrange(1,12)->collect(0) ;
     for (var : array) do (      result[i+1] := var->oclAsType(int) - ('0')->char2byte()  ; i := i + 1 ;  ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int max=1000001 ;
  static int simentai(int n){
    return n*(n+1)*(n+2)/6 ;
  }
  public static void main(String[] args){
    List<Integer>data=new ArrayList<Integer>();
    for(int i=0 ; simentai(i)<max ; i++){
      data.add(simentai(i));
      if(data.get(i)>max)break ;
    }
    int num[]=new int[max];
    for(int i=0 ; i<max ; i++)num[i]=i ;
    for(int i=2 ; i<data.size(); i++){
      for(int s=0 ; s<max ; s++){
        if(s-data.get(i)<0)continue ;
        int test=num[s-data.get(i)]+1 ;
        num[s]=Math.min(test,num[s]);
      }
    }
    int kisuu[]=new int[max];
    for(int i=0 ; i<max ; i++)kisuu[i]=i ;
    for(int i=2 ; i<data.size(); i++){
      if(data.get(i)% 2==0)continue ;
      for(int s=0 ; s<max ; s++){
        if(s-data.get(i)<0)continue ;
        int test=kisuu[s-data.get(i)]+1 ;
        if(s==5)System.out.println(kisuu[s]+" or "+test+" "+i);
        kisuu[s]=Math.min(kisuu[s],test);
      }
    }
    Scanner in=new Scanner(System.in);
    while(true){
      int n=in.nextInt();
      if(n==0)break ;
      System.out.println(num[n]+" "+kisuu[n]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute max : int := 1000001;
  static   operation simentai( n : int) : int
  pre: true
  post: true
  activity: (     return n * (n + 1) * (n + 2) / 6 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var data : Sequence(int) ; data := Sequence{} ;
         var i : int ; i := 0 ; while simentai(i) < max do ( (     data := data->including(simentai(i)) ; 
     if (data->at(i+1) > max) then     break else skip )  ;     i := i + 1 ) ; 
    var num : Sequence(int) ; num := Integer.subrange(1,max)->collect(0) ;
        var i : int ; i := 0 ; while i < max do (     num[i+1] := i ;  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i < data->size() do ( (         var s : int ; s := 0 ; while s < max do ( (     if (s - data->at(i+1) < 0) then     continue else skip ; 
     var test : int ; test := num[s - data->at(i+1)+1] + 1 ;
     num[s+1] := Set{test, num[s+1]}->min() )  ;     s := s + 1 ) )  ;     i := i + 1 ) ; 
    var kisuu : Sequence(int) ; kisuu := Integer.subrange(1,max)->collect(0) ;
        var i : int ; i := 0 ; while i < max do (     kisuu[i+1] := i ;  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i < data->size() do ( (     if (data->at(i+1) mod 2 = 0) then     continue else skip ; 
         var s : int ; s := 0 ; while s < max do ( (     if (s - data->at(i+1) < 0) then     continue else skip ; 
     var test : int ; test := kisuu[s - data->at(i+1)+1] + 1 ;
     if (s = 5) then     OclFile["System.out"].println(kisuu[s+1] + " or " + test + " " + i) ; else skip ; 
     kisuu[s+1] := Set{kisuu[s+1], test}->min() )  ;     s := s + 1 ) )  ;     i := i + 1 ) ; 
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (true) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
     OclFile["System.out"].println(num[n+1] + " " + kisuu[n+1]) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MinChessBoard {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=n/2+1 ;
    System.out.println(m);
    int r=1,c=1 ;
    for(int i=0 ; i<n ; i++){
      System.out.println(r+" "+c);
      if(c<m)c++;
      else r++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MinChessBoard {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := n / 2 + 1 ;
    OclFile["System.out"].println(m) ; 
    var r : int ; r := 1 ;
    var c : int ; c := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(r + " " + c) ; 
     if (c < m) then     c := c + 1 ; else     r := r + 1 ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    while(true){
      int n=Integer.parseInt(in.next());
      if(n==0)break ;
      List<Integer>A=new ArrayList<>(),B=new ArrayList<>();
      int j=1,s=1 ;
      while(s<=n){
        A.add(s);
        if(s % 2==1)B.add(s);
        j++;
        s=j*(j+1)*(j+2)/6 ;
      }
      int DP[]=new int[n+1],INF=2000000000 ;
      for(int i=1 ; i<=n ; i++)DP[i]=INF ;
      for(int i=0 ; i<A.size(); i++){
        int t=A.get(i);
        for(int k=0 ; k+t<=n ; k++){
          DP[k+t]=Math.min(DP[k]+1,DP[k+t]);
        }
      }
      out.print(DP[n]+" ");
      for(int i=1 ; i<=n ; i++)DP[i]=INF ;
      for(int i=0 ; i<B.size(); i++){
        int t=B.get(i);
        for(int k=0 ; k+t<=n ; k++){
          DP[k+t]=Math.min(DP[k+t],DP[k]+1);
        }
      }
      out.println(DP[n]);
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     while (true) do (     var n : int ; n := (in.getCurrent())->toInteger() ;
     if (n = 0) then     break else skip ; 
    var A : Sequence(int) ; A := Sequence{} ;
    var B : Sequence(int) ; B := Sequence{} ;
    var j : int ; j := 1 ;
    var s : int ; s := 1 ;
    while (s <= n) do (     A := A->including(s) ; 
     if (s mod 2 = 1) then     B->excludes(s) ; else skip ; 
     j := j + 1 ; 
     s := j * (j + 1) * (j + 2) / 6 ) ; 
    var DP : Sequence(int) ; DP := Integer.subrange(1,n + 1)->collect(0) ;
    var INF : int ; INF := 2000000000 ;
        var i : int ; i := 1 ; while i <= n do (     DP[i+1] := INF ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < A->size() do ( (     var t : int ; t := A->at(i+1) ;
         var k : int ; k := 0 ; while k + t <= n do ( (     DP[k + t+1] := Set{DP[k+1] + 1, DP[k + t+1]}->min() )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 1 ; while i <= n do (     DP[i+1] := INF ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < B->size() do ( (     var t : int ; t := B->at(i+1) ;
         var k : int ; k := 0 ; while k + t <= n do ( (     DP[k + t+1] := Set{DP[k + t+1], DP[k+1] + 1}->min() )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countOfLetters(String str){
    int letter=0 ;
    for(int i=0 ; i<str.length(); i++){
      if((str.charAt(i)>='A' && str.charAt(i)<='Z')||(str.charAt(i)>='a' && str.charAt(i)<='z'))letter++;
    }
    return letter ;
  }
  static int countOfNumbers(String str){
    int number=0 ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)>='0' && str.charAt(i)<='9')number++;
    }
    return number ;
  }
  static void check(String str){
    if(countOfLetters(str)==countOfNumbers(str))System.out.print("Yes\n");
    else System.out.print("No\n");
  }
  public static void main(String[] args){
    String str="GeeKs01324" ;
    check(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countOfLetters( str : String) : int
  pre: true
  post: true
  activity: (     var letter : int ; letter := 0 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if ((str->at(i+1) >= 'A' & str->at(i+1) <= 'Z') or (str->at(i+1) >= 'a' & str->at(i+1) <= 'z')) then     letter := letter + 1 ; else skip )  ;     i := i + 1 ) ; 
     return letter );
  static   operation countOfNumbers( str : String) : int
  pre: true
  post: true
  activity: (     var number : int ; number := 0 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) >= '0' & str->at(i+1) <= '9') then     number := number + 1 ; else skip )  ;     i := i + 1 ) ; 
     return number );
  static   operation check( str : String) : void
  pre: true
  post: true
  activity: (     if (countOfLetters(str) = countOfNumbers(str)) then     OclFile["System.out"].print("Yes\n") ; else     OclFile["System.out"].print("No\n") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GeeKs01324" ;
     execute check(str) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int[] box=new int[10];
    int i=0 ;
    while(scan.hasNext()){
      int n=scan.nextInt();
      if(n==0){
        i--;
        System.out.println(box[i]);
      }
      else {
        box[i]=n ;
        i++;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var box : Sequence(int) ; box := Integer.subrange(1,10)->collect(0) ;
     var i : int ; i := 0 ;
     while (scan.hasNext()) do (     var n : int ; n := scan.getCurrent()->toInteger() ;
     if (n = 0) then (     i := i - 1 ; 
     OclFile["System.out"].println(box[i+1]) ) else (     box[i+1] := n ; 
     i := i + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    ArrayList<Integer>in=new ArrayList<Integer>();
    ArrayList<Integer>out=new ArrayList<Integer>();
    for(; scanner.hasNext(); ){
      int n=scanner.nextInt();
      if(n==0){
        int s=in.size()-1 ;
        out.add(in.get(s));
        in.remove(s);
      }
      else {
        in.add(n);
      }
    }
    for(Integer id : out){
      System.out.println(id);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var in : Sequence(int) ; in := Sequence{} ;
    var out : Sequence(int) ; out := Sequence{} ;
      while scanner.hasNext() do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then (     var s : int ; s := in->size() - 1 ;
     out := out->including(in->at(s+1)) ; 
     in := in->excludingAt(s+1) ) else (     in := in->including(n) ) )  ) ; 
    for (id : out) do ( (     OclFile["System.out"].println(id) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.NoSuchElementException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayList<Integer>trainsIn=new ArrayList<Integer>();
    ArrayList<Integer>trainsOut=new ArrayList<Integer>();
    try {
      while(true){
        int n=sc.nextInt();
        switch(n){
          case 0 : popTrain(trainsIn,trainsOut);
          break ;
          default : pushTrain(trainsIn,n);
          break ;
        }
      }
    }
    catch(NoSuchElementException e){
    }
    for(int i=0 ; i<trainsOut.size(); i++){
      System.out.println(trainsOut.get(i));
    }
  }
  private static void pushTrain(ArrayList<Integer>trains,int n){
    trains.add(n);
  }
  private static void popTrain(ArrayList<Integer>trains,ArrayList<Integer>trainsOut){
    Integer firstTrain=trains.get(trains.size()-1);
    trainsOut.add(firstTrain);
    trains.remove(trains.size()-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var trainsIn : Sequence(int) ; trainsIn := Sequence{} ;
    var trainsOut : Sequence(int) ; trainsOut := Sequence{} ;
    try (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (n) ; 
       if _switchval = 0 then
     execute popTrain(trainsIn, trainsOut) ; 
    break 
   else skip ;
       if true then
     execute pushTrain(trainsIn, n) ; 
    break 
   else skip ;
 )
 ) )   catch (e : IncorrectElementException) do skip
        var i : int ; i := 0 ; while i < trainsOut->size() do ( (     OclFile["System.out"].println(trainsOut->at(i+1)) )  ;     i := i + 1 ) ; 
 );
  static   operation pushTrain( trains : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     trains->excludes(n) );
  static   operation popTrain( trains : Sequence(int), trainsOut : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var firstTrain : int ; firstTrain := trains->at(trains->size() - 1+1) ;
     trainsOut := trainsOut->including(firstTrain) ; 
     trains := trains->excludingFirst(trains->size() - 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Stack {
  int top ;
  int[] stack ;
  int size ;
  public Stack(int size){
    top=-1 ;
    stack=new int[size];
    this.size=size ;
  }
  public void push(int value){
    stack[++top]=value ;
  }
  public int pop(){
    System.out.println(stack[top]);
    return stack[top--];
  }
}
public class Main {
  public static void main(String args[]){
    int number ;
    Stack st=new Stack(10);
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      number=sc.nextInt();
      if(number!=0){
        st.push(number);
      }
      else {
        st.pop();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Stack {
   attribute top : int;
   attribute stack : Sequence(int);
   attribute size : int;
   static operation newStack( size : int) : Stack
  pre: true
  post: true
  activity:
  ( var self : Stack ;
    self := createStack();
    self.initialise(size);
    return self );
  operation initialise( size : int) : void
  pre: true  post: true
  activity: (     top := -1 ; 
     stack := Integer.subrange(1,size)->collect(0) ; 
     self.size := size );
   operation push( value : int) : void
  pre: true
  post: true
  activity: (         top := top + 1 ;
 stack[top+1] := value  );
   operation pop() : int
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(stack[top+1]) ; 
     return stack[top+1] );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var number : int ;
     var st : Sequence ; st := Sequence{} ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     number := sc.getCurrent()->toInteger() ; 
     if (number /= 0) then (     st := st->append(number) ) else (     st := st->front() ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
import java.util.Stack ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    String line=null ;
    Stack<Integer>stack=new Stack<Integer>();
    while((line=reader.readLine())!=null && ! line.isEmpty()){
      int n=Integer.parseInt(line);
      if(n==0){
        out.println(stack.pop());
      }
      else {
        stack.push(n);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     var line : String ; line := null ;
     var stack : Sequence(int) ; stack := Sequence{} ;
         line := reader.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := (line)->toInteger() ;
     if (n = 0) then (     out.println(stack->last()) ) else (     stack := stack->append(n) ) ) ;     line := reader.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int N=sc.nextInt(),x=sc.nextInt();
      if(x==1 || x==2*N-1){
        System.out.println("No");
        break ;
      }
      System.out.println("Yes");
      int low=x-1,high=x+1 ;
      ArrayDeque<Integer>deq=new ArrayDeque<Integer>();
      deq.add(x);
      while(low!=0 || high!=2*N){
        if(low==0){
          deq.push(high);
          deq.add(high+1);
          high+=2 ;
        }
        else if(high==2*N){
          deq.add(low);
          deq.push(low-1);
          low-=2 ;
        }
        else {
          deq.push(low);
          low--;
          deq.add(high);
          high++;
        }
      }
      for(int s : deq)System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x = 1 or x = 2 * N - 1) then (     OclFile["System.out"].println("No") ; 
     break ) else skip ; 
    OclFile["System.out"].println("Yes") ; 
    var low : int ; low := x - 1 ;
    var high : int ; high := x + 1 ;
    var deq : Sequence(int) ; deq := ArrayDeque<int>.newArrayDeque() ;
    deq := deq->including(x) ; 
    while (low /= 0 or high /= 2 * N) do (     if (low = 0) then (     deq := deq->append(high) ; 
     deq := deq->including(high + 1) ; 
     high := high+(2) ) else     if (high = 2 * N) then (     deq := deq->including(low) ; 
     deq := deq->append(low - 1) ; 
     low := low-(2) ) else (     deq := deq->append(low) ; 
     low := low - 1 ; 
     deq := deq->including(high) ; 
     high := high + 1 ) ;  ) ; 
    for (s : deq) do (     OclFile["System.out"].println(s) ;  ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    AFlippingGame solver=new AFlippingGame();
    solver.solve(1,in,out);
    out.close();
  }
  static class AFlippingGame {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      int[] b=new int[n];
      for(int i=0 ; i<n ; i++){
        b[i]=a[i]==0 ? 1 :-1 ;
      }
      int max=-10 ;
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        sum+=b[i];
        max=Math.max(sum,max);
        if(sum<0)sum=0 ;
      }
      int count=0 ;
      for(int i=0 ; i<n ; i++){
        if(a[i]==1)++count ;
      }
      out.println(max+count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : AFlippingGame ; solver := AFlippingGame.newAFlippingGame() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class AFlippingGame {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := if a[i+1] = 0 then 1 else -1 endif )  ;     i := i + 1 ) ; 
    var max : int ; max := -10 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(b[i+1]) ; 
     max := Set{sum, max}->max() ; 
     if (sum < 0) then     sum := 0 ; else skip )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = 1) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int x=scanner.nextInt();
    print(x,n);
  }
  public static void print(int x,int n){
    int max=n*2-1 ;
    if(x==1 || x==max){
      System.out.println("No");
      return ;
    }
    System.out.println("Yes");
    String sep=System.lineSeparator();
    String ans=IntStream.range(x+n-1,x+n+max-1).mapToObj(e->(e % max+1)+sep).collect(StringBuilder :: new,StringBuilder :: append,StringBuilder :: append).toString();
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var x : int ; x := scanner.getCurrent()->toInteger() ;
     execute print(x, n) );
  static   operation print( x : int, n : int) : void
  pre: true
  post: true
  activity: (     var max : int ; max := n * 2 - 1 ;
     if (x = 1 or x = max) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
    OclFile["System.out"].println("Yes") ; 
    var sep : String ; sep := lineSeparator() ;
    var ans : String ; ans := Integer.subrange(x + n - 1, x + n + max - 1-1).mapToObj(lambda e : OclAny in (e mod max + 1) + sep).collect(lambda _pars : OclAny in String.newString().new(_pars), lambda _pars : OclAny in StringBuilder.newStringBuilder().append(_pars), lambda _pars : OclAny in StringBuilder.newStringBuilder().append(_pars))+"" ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    while(input.hasNext()){
      int N=input.nextInt();
      int x=input.nextInt();
      int rowNLen=2*N-1 ;
      if(x==1 || x==rowNLen){
        System.out.println("No");
      }
      else {
        int[] ans=new int[rowNLen+1];
        for(int i=0 ; i<ans.length ; ++i){
          ans[i]=i ;
        }
        int mid=N ;
        int tmp=ans[mid];
        ans[mid]=x ;
        ans[x]=tmp ;
        tmp=ans[mid-1];
        ans[mid-1]=rowNLen ;
        ans[rowNLen]=tmp ;
        if(ans[mid+1]!=1){
          tmp=ans[mid+1];
          ans[mid+1]=1 ;
          ans[1]=tmp ;
        }
        System.out.println("Yes");
        StringBuilder ansOut=new StringBuilder();
        for(int i=1 ; i<ans.length ; ++i){
          ansOut.append(String.format("%d\n",ans[i]));
        }
        System.out.print(ansOut);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (input.hasNext()) do (     var N : int ; N := input.getCurrent()->toInteger() ;
     var x : int ; x := input.getCurrent()->toInteger() ;
     var rowNLen : int ; rowNLen := 2 * N - 1 ;
     if (x = 1 or x = rowNLen) then (     OclFile["System.out"].println("No") ) else (     var ans : Sequence(int) ; ans := Integer.subrange(1,rowNLen + 1)->collect(0) ;
         var i : int ; i := 0 ; while i < ans->size() do ( (     ans[i+1] := i )  ;     i := i + 1 ) ; 
    var mid : int ; mid := N ;
    var tmp : int ; tmp := ans[mid+1] ;
    ans[mid+1] := x ; 
    ans[x+1] := tmp ; 
    tmp := ans[mid - 1+1] ; 
    ans[mid - 1+1] := rowNLen ; 
    ans[rowNLen+1] := tmp ; 
    if (ans[mid + 1+1] /= 1) then (     tmp := ans[mid + 1+1] ; 
     ans[mid + 1+1] := 1 ; 
     ans[1+1] := tmp ) else skip ; 
    OclFile["System.out"].println("Yes") ; 
    var ansOut : String ; ansOut := StringLib.newString() ;
        var i : int ; i := 1 ; while i < ans->size() do ( (     ansOut := ansOut + StringLib.newString(StringLib.format("%d\n",Sequence{ans[i+1]})) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(ansOut) ; 
 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    System.out.print(solve(n));
    sc.close();
  }
  static String solve(int n){
    int m=n/2+1 ;
    return String.format("%d\n%s",m,IntStream.range(0,n).mapToObj(i->String.format("%d %d",Math.max(1,i-m+2),Math.min(m,i+1))).collect(Collectors.joining("\n")));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].print(solve(n)) ; 
     skip );
  static   operation solve( n : int) : String
  pre: true
  post: true
  activity: (     var m : int ; m := n / 2 + 1 ;
     return StringLib.format("%d\n%s",Sequence{m,Integer.subrange(0, n-1).mapToObj(lambda i : OclAny in StringLib.format("%d %d",Sequence{Set{1, i - m + 2}->max(),Set{m, i + 1}->min()})).collect(Collectors.joining("\n"))}) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int N=sc.nextInt();
    int x=sc.nextInt();
    if(x==1 || x==2*N-1){
      pw.println("No");
    }
    else {
      pw.println("Yes");
      for(int i=0 ; i<2*N-1 ; i++)pw.println((i+x-N+2*N-1)%(2*N-1)+1);
    }
    sc.close();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    if (x = 1 or x = 2 * N - 1) then (     skip ) else (     skip ; 
         var i : int ; i := 0 ; while i < 2 * N - 1 do (     skip ;  ;     i := i + 1 ) ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=100001 ;
  static int[] perfectDiv=new int[MAX];
  static void precomputeCounts(){
    for(int i=1 ; i*i<MAX ; ++i){
      for(int j=i*i ; j<MAX ; j+=i*i)++perfectDiv[j];
    }
  }
  static int countPerfectDivisors(int n){
    return perfectDiv[n];
  }
  public static void main(String[] args){
    precomputeCounts();
    int n=16 ;
    System.out.println("Total perfect divisors of "+n+"="+countPerfectDivisors(n));
    n=12 ;
    System.out.println("Total perfect divisors of "+n+"="+countPerfectDivisors(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100001;
  static   attribute perfectDiv : Sequence(int) := Integer.subrange(1,MAX)->collect(0);
  static   operation precomputeCounts() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i * i < MAX do ( (         var j : int ; j := i * i ; while j < MAX do (     perfectDiv[j+1] := perfectDiv[j+1] + 1 ;  ;     j := j+(i * i) ) )  ;     i := i + 1 ) );
  static   operation countPerfectDivisors( n : int) : int
  pre: true
  post: true
  activity: (     return perfectDiv[n+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute precomputeCounts() ; 
     var n : int ; n := 16 ;
    OclFile["System.out"].println("Total perfect divisors of " + n + "=" + countPerfectDivisors(n)) ; 
    n := 12 ; 
    OclFile["System.out"].println("Total perfect divisors of " + n + "=" + countPerfectDivisors(n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    long nn=0 ;
    for(int i=0 ; i<n ; i++){
      nn+=sc.nextInt();
    }
    long mm=0 ;
    for(int i=0 ; i<m ; i++){
      mm+=sc.nextInt();
    }
    System.out.println(nn*mm);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var nn : long ; nn := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     nn := nn+(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var mm : long ; mm := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     mm := mm+(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(nn * mm) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    int e=sc.nextInt();
    int[] x=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      int check=x[i]*((t+e)/x[i]);
      if(check<=t+e && check>=t-e){
        System.out.println((i+1));
        return ;
      }
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var e : int ; e := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var check : int ; check := x[i+1] * ((t + e) / x[i+1]) ;
     if (check <= t + e & check >= t - e) then (     OclFile["System.out"].println((i + 1)) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main extends Template {
  public void solve()throws IOException {
    int n=nextInt();
    int t=nextInt();
    int e=nextInt();
    int[] x=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=nextInt();
      if(Math.ceil((double)(t-e)/x[i])<=Math.floor((double)(t+e)/x[i])){
        System.out.println(i+1);
        return ;
      }
    }
    System.out.println(-1);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
abstract class Template implements Runnable {
  public abstract void solve()throws IOException ;
  BufferedReader reader ;
  StringTokenizer tokenizer ;
  PrintWriter writer ;
  public void run(){
    try {
      reader=new BufferedReader(new InputStreamReader(System.in));
      tokenizer=null ;
      writer=new PrintWriter(System.out);
      solve();
      reader.close();
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  public String nextToken()throws IOException {
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends Template {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var t : int ; t := nextInt() ;
    var e : int ; e := nextInt() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := nextInt() ; 
     if (((t - e)->oclAsType(double) / x[i+1])->ceil() <= ((t + e)->oclAsType(double) / x[i+1])->floor()) then (     OclFile["System.out"].println(i + 1) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}
class Template implements Runnable {
     operation solve() : void
  pre: true
  post: true;
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   attribute writer : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     try (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := null ; 
    writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int N=in.nextInt();
      int T=in.nextInt();
      int E=in.nextInt();
      boolean judge=false ;
      int ans=-1 ;
      int s[]=new int[N];
      for(int i=0 ; i<N ; i++)s[i]=in.nextInt();
      for(int i=0 ; i<N ; i++){
        for(int j=0 ; ; j++){
          if(Math.abs(s[i]*j-T)<=E){
            judge=true ;
            ans=i+1 ;
          }
          if(s[i]*j>T+E)break ;
        }
        if(judge)break ;
      }
      System.out.println(judge ? ans :-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var N : int ; N := in.getCurrent()->toInteger() ;
     var T : int ; T := in.getCurrent()->toInteger() ;
    var E : int ; E := in.getCurrent()->toInteger() ;
    var judge : boolean ; judge := false ;
    var ans : int ; ans := -1 ;
    var s : Sequence(int) ; s := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     s[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while true do ( (     if (if s[i+1] * j - T < 0 then -(s[i+1] * j - T) else s[i+1] * j - T endif <= E) then (     judge := true ; 
     ans := i + 1 ) else skip ; 
     if (s[i+1] * j > T + E) then     break else skip )  ;     j := j + 1 ) ; 
     if (judge) then     break else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if judge then ans else -1 endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,t,e,x,i,j ;
    n=sc.nextInt();
    t=sc.nextInt();
    e=sc.nextInt();
    for(i=0 ; i<n ; i++){
      x=sc.nextInt();
      for(j=1 ; x*j<=t+e ; j++)if(t-e<=x*j)break ;
      if(t-e<=x*j && x*j<=t+e){
        out.println(i+1);
        break ;
      }
    }
    if(i==n)out.println("-1");
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var t : int ;
    var e : int ;
    var x : int ;
    var i : int ;
    var j : int ;
    n := sc.nextInt() ; 
    t := sc.nextInt() ; 
    e := sc.nextInt() ; 
        i := 0 ; while i < n do ( (     x := sc.nextInt() ; 
         j := 1 ; while x * j <= t + e do (     if (t - e <= x * j) then     break else skip ;  ;     j := j + 1 ) ; 
     if (t - e <= x * j & x * j <= t + e) then (     out.println(i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (i = n) then     out.println("-1") ; else skip ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int[] x,y ;
  static int n ;
  static int[] dx={
-2,-2,-2,-1,0,1,2,2,2,1,0,-1 };
    static int[] dy={
-1,0,1,2,2,2,1,0,-1,-2,-2,-2 };
      static boolean dfs(int nowx,int nowy,int count){
        if(count==n+1)return true ;
        for(int i=0 ; i<12 ; i++){
          if(nowx+dx[i]<0 || nowx+dx[i]>=10 || nowy+dy[i]<0 || nowy+dy[i]>=10){
            continue ;
          }
          if(nowx+dx[i]>=x[count]-1 && nowx+dx[i]<=x[count]+1 && nowy+dy[i]>=y[count]-1 && nowy+dy[i]<=y[count]+1){
            if(dfs(nowx+dx[i],nowy+dy[i],count+1)){
              return true ;
            }
          }
        }
        return false ;
      }
      public static void main(String[] args){
        try(Scanner sc=new Scanner(System.in)){
          while(sc.hasNext()){
            int px=sc.nextInt();
            int py=sc.nextInt();
            if(px+py==0)break ;
            n=sc.nextInt();
            x=new int[n+1];
            y=new int[n+1];
            for(int i=1 ; i<=n ; i++){
              x[i]=sc.nextInt();
              y[i]=sc.nextInt();
            }
            if(dfs(px,py,1))System.out.println("OK");
            else System.out.println("NA");
          }
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute x : Sequence(int);
  static   attribute n : int;
  static   attribute dx : Sequence(int) := Sequence{-2,-2,-2,-1,0,1,2,2,2,1,0,-1};
  static   attribute dy : Sequence(int) := Sequence{-1,0,1,2,2,2,1,0,-1,-2,-2,-2};
  static   operation dfs( nowx : int, nowy : int, count : int) : boolean
  pre: true
  post: true
  activity: (     if (count = n + 1) then     return true else skip ; 
         var i : int ; i := 0 ; while i < 12 do ( (     if (nowx + dx[i+1] < 0 or nowx + dx[i+1] >= 10 or nowy + dy[i+1] < 0 or nowy + dy[i+1] >= 10) then (     continue ) else skip ; 
     if (nowx + dx[i+1] >= x[count+1] - 1 & nowx + dx[i+1] <= x[count+1] + 1 & nowy + dy[i+1] >= y[count+1] - 1 & nowy + dy[i+1] <= y[count+1] + 1) then (     if (dfs(nowx + dx[i+1], nowy + dy[i+1], count + 1)) then (     return true ) else skip ) else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (sc.hasNext()) do (     var px : int ; px := sc.getCurrent()->toInteger() ;
     var py : int ; py := sc.getCurrent()->toInteger() ;
    if (px + py = 0) then     break else skip ; 
    n := sc.getCurrent()->toInteger() ; 
    x := Integer.subrange(1,n + 1)->collect(0) ; 
    y := Integer.subrange(1,n + 1)->collect(0) ; 
        var i : int ; i := 1 ; while i <= n do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     y[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (dfs(px, py, 1)) then     OclFile["System.out"].println("OK") else     OclFile["System.out"].println("NA") ; ;  
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
class GFG {
  public static void cal_IST(int h,double r){
    double IST=(h*r*1.0)/360 ;
    int int_IST=(int)IST ;
    int float_IST=(int)Math.ceil((int)((IST-int_IST)*60));
    System.out.println(int_IST+":"+float_IST);
  }
  public static void main(String[] args){
    int h=20 ;
    double r=150 ;
    cal_IST(h,r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation cal_IST( h : int, r : double) : void
  pre: true
  post: true
  activity: (     var IST : double ; IST := (h * r * 1.0) / 360 ;
     var int_IST : int ; int_IST := IST->oclAsType(int) ;
     var float_IST : int ; float_IST := (((IST - int_IST) * 60)->oclAsType(int))->ceil()->oclAsType(int) ;
     OclFile["System.out"].println(int_IST + ":" + float_IST) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var h : int ; h := 20 ;
     var r : double ; r := 150 ;
     execute cal_IST(h, r) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printRoots(int n){
    double theta=3.14*2/n ;
    for(int k=0 ; k<n ; k++){
      double real=Math.cos(k*theta);
      double img=Math.sin(k*theta);
      System.out.println(real);
      if(img>=0)System.out.println("+i ");
      else System.out.println("-i ");
      System.out.println(Math.abs(img));
    }
  }
  public static void main(String[] args){
    printRoots(1);
    printRoots(2);
    printRoots(3);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printRoots( n : int) : void
  pre: true
  post: true
  activity: (     var theta : double ; theta := 3.14 * 2 / n ;
         var k : int ; k := 0 ; while k < n do ( (     var real : double ; real := (k * theta)->cos() ;
     var img : double ; img := (k * theta)->sin() ;
    OclFile["System.out"].println(real) ; 
    if (img >= 0) then     OclFile["System.out"].println("+i ") else     OclFile["System.out"].println("-i ") ; ;  
    OclFile["System.out"].println(if img < 0 then -(img) else img endif) ; 
 )  ;     k := k + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute printRoots(1) ; 
     execute printRoots(2) ; 
     execute printRoots(3) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int m=(n+2)/2 ;
    System.out.println(m);
    int count=0 ;
    for(int i=1 ; i<=n ; i++){
      System.out.println((i+1)/2+" "+(i+2)/2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var m : int ; m := (n + 2) / 2 ;
    OclFile["System.out"].println(m) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].println((i + 1) / 2 + " " + (i + 2) / 2) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void findCart(int arr1[],int arr2[],int n,int n1){
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n1 ; j++)System.out.print("{"+arr1[i]+","+arr2[j]+"},");
  }
  public static void main(String[] args){
    int arr1[]={
      1,2,3 };
      int arr2[]={
        4,5,6 };
        int n1=arr1.length ;
        int n2=arr2.length ;
        findCart(arr1,arr2,n1,n2);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findCart( arr1 : Sequence(int), arr2 : Sequence(int), n : int, n1 : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n1 do (     OclFile["System.out"].print("{" + arr1[i+1] + "," + arr2[j+1] + "},") ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{1,2,3} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{4,5,6} ;
    var n1 : int ; n1 := arr1->size() ;
    var n2 : int ; n2 := arr2->size() ;
    execute findCart(arr1, arr2, n1, n2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int no_of_ways(String s){
    int n=s.length();
    int count_left=0,count_right=0 ;
    for(int i=0 ; i<n ; ++i){
      if(s.charAt(i)==s.charAt(0)){
++count_left ;
      }
      else break ;
    }
    for(int i=n-1 ; i>=0 ; --i){
      if(s.charAt(i)==s.charAt(n-1)){
++count_right ;
      }
      else break ;
    }
    if(s.charAt(0)==s.charAt(n-1))return((count_left+1)*(count_right+1));
    else return(count_left+count_right+1);
  }
  public static void main(String args[]){
    String s="geeksforgeeks" ;
    System.out.println(no_of_ways(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation no_of_ways( s : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var count_left : int ; count_left := 0 ;
    var count_right : int ; count_right := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = s->at(0+1)) then (     count_left := count_left + 1 ) else     break )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (s->at(i+1) = s->at(n - 1+1)) then (     count_right := count_right + 1 ) else     break )  ;     i := i - 1 ) ; 
    if (s->at(0+1) = s->at(n - 1+1)) then     return ((count_left + 1) * (count_right + 1)) else     return (count_left + count_right + 1) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     OclFile["System.out"].println(no_of_ways(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int MAX=1000000 ;
  static boolean prime[]=new boolean[MAX+1];
  static void SieveOfEratosthenes(){
    for(int i=0 ; i<prime.length ; i++){
      prime[i]=true ;
    }
    prime[1]=false ;
    prime[0]=false ;
    for(int p=2 ; p*p<=MAX ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=MAX ; i+=p){
          prime[i]=false ;
        }
      }
    }
  }
  static void SumOfKthPrimes(int arr[],int n,int k){
    int c=0 ;
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(prime[arr[i] ]){
        c++;
        if(c % k==0){
          sum+=arr[i];
          c=0 ;
        }
      }
    }
    System.out.println(sum);
  }
  public static void main(String[] args){
    SieveOfEratosthenes();
    int arr[]={
      2,3,5,7,11 };
      int n=arr.length ;
      int k=2 ;
      SumOfKthPrimes(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 1000000;
  static   attribute prime : boolean := Integer.subrange(1,MAX + 1)->collect(false);
  static   operation SieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < prime->size() do ( (     prime[i+1] := true )  ;     i := i + 1 ) ; 
     prime[1+1] := false ; 
     prime[0+1] := false ; 
         var p : int ; p := 2 ; while p * p <= MAX do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= MAX do ( (     prime[i+1] := false )  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation SumOfKthPrimes( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
     var sum : long ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (prime[arr[i+1]+1]) then (     c := c + 1 ; 
     if (c mod k = 0) then (     sum := sum+(arr[i+1]) ; 
     c := 0 ) else skip ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sum) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes() ; 
     var arr : Sequence(int) ; arr := Sequence{2,3,5,7,11} ;
    var n : int ; n := arr->size() ;
    var k : int ; k := 2 ;
    execute SumOfKthPrimes(arr, n, k) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=1000000 ;
  static boolean[] prime=new boolean[MAX+1];
  static void SieveOfEratosthenes(){
    prime[1]=true ;
    prime[0]=true ;
    for(int p=2 ; p*p<=MAX ; p++){
      if(prime[p]==false){
        for(int i=p*2 ; i<=MAX ; i+=p)prime[i]=true ;
      }
    }
  }
  static void productOfKthPrimes(int arr[],int n,int k){
    int c=0 ;
    int product=1 ;
    for(int i=0 ; i<n ; i++){
      if(! prime[arr[i] ]){
        c++;
        if(c % k==0){
          product*=arr[i];
          c=0 ;
        }
      }
    }
    System.out.println(product);
  }
  public static void main(String[] args){
    SieveOfEratosthenes();
    int n=5,k=2 ;
    int[] arr=new int[] {
      2,3,5,7,11 };
      productOfKthPrimes(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 1000000;
  static   attribute prime : Sequence(boolean) := Integer.subrange(1,MAX + 1)->collect(false);
  static   operation SieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (     prime[1+1] := true ; 
     prime[0+1] := true ; 
         var p : int ; p := 2 ; while p * p <= MAX do ( (     if (prime[p+1] = false) then (         var i : int ; i := p * 2 ; while i <= MAX do (     prime[i+1] := true ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation productOfKthPrimes( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
     var product : int ; product := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (not(prime[arr[i+1]+1])) then (     c := c + 1 ; 
     if (c mod k = 0) then (     product := product*(arr[i+1]) ; 
     c := 0 ) else skip ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(product) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes() ; 
     var n : int ; n := 5 ;
    var k : int ; k := 2 ;
     var arr : Sequence(int) ; arr := Sequence{2,3,5,7,11} ;
     execute productOfKthPrimes(arr, n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAX=1000000 ;
  static boolean[] prime=new boolean[MAX+1];
  static void SieveOfEratosthenes(){
    for(int i=0 ; i<=MAX ; i++)prime[i]=true ;
    prime[1]=false ;
    prime[0]=false ;
    for(int p=2 ; p*p<=MAX ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=MAX ; i+=p)prime[i]=false ;
      }
    }
  }
  static void solve(int[] arr,int n,int k){
    int c=0 ;
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(prime[arr[i] ]){
        c++;
        if(c % k==0){
          sum+=arr[i];
          c=0 ;
        }
      }
    }
    System.out.println(sum);
  }
  public static void main(String[] args){
    SieveOfEratosthenes();
    int n=5,k=2 ;
    int[] arr={
      2,3,5,7,11 };
      solve(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 1000000;
  static   attribute prime : Sequence(boolean) := Integer.subrange(1,MAX + 1)->collect(false);
  static   operation SieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= MAX do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
     prime[1+1] := false ; 
     prime[0+1] := false ; 
         var p : int ; p := 2 ; while p * p <= MAX do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= MAX do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation solve( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
     var sum : long ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (prime[arr[i+1]+1]) then (     c := c + 1 ; 
     if (c mod k = 0) then (     sum := sum+(arr[i+1]) ; 
     c := 0 ) else skip ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sum) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes() ; 
     var n : int ; n := 5 ;
    var k : int ; k := 2 ;
     var arr : Sequence(int) ; arr := Sequence{2,3,5,7,11} ;
     execute solve(arr, n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    String T=sc.next();
    int A=sc.nextInt();
    int B=sc.nextInt();
    String U=sc.next();
    if(U.equals(S)){
      System.out.println((A-1)+" "+B);
    }
    else {
      System.out.println(A+" "+(B-1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    var T : String ; T := sc.getCurrent() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var U : String ; U := sc.getCurrent() ;
    if (U = S) then (     OclFile["System.out"].println(((A)->char2byte() - 1) + " " + B) ) else (     OclFile["System.out"].println(A + " " + (B - 1)) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String s2=sc.next();
    int cnt1=sc.nextInt();
    int cnt2=sc.nextInt();
    String s3=sc.next();
    sc.close();
    if(s.equals(s3)){
      cnt1--;
    }
    else {
      cnt2--;
    }
    System.out.println(cnt1+" "+cnt2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var s2 : String ; s2 := sc.getCurrent() ;
    var cnt1 : int ; cnt1 := sc.getCurrent()->toInteger() ;
    var cnt2 : int ; cnt2 := sc.getCurrent()->toInteger() ;
    var s3 : String ; s3 := sc.getCurrent() ;
    skip ; 
    if (s = s3) then (     cnt1 := cnt1 - 1 ) else (     cnt2 := cnt2 - 1 ) ;  
    OclFile["System.out"].println(cnt1 + " " + cnt2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.*;
import java.util.*;
import java.util.ArrayList ;
import java.util.Iterator ;
import java.util.List ;
import java.util.Collections ;
public class Main {
  public static void main(final String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String t=sc.next();
    int a=sc.nextInt();
    int b=sc.nextInt();
    String u=sc.next();
    if(u.equals(s)){
      a-=1 ;
    }
    else {
      b-=1 ;
    }
    System.out.print(a+" "+b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var u : String ; u := sc.getCurrent() ;
    if (u = s) then (     a := a-(1) ) else (     b := b-(1) ) ;  
    OclFile["System.out"].print(a + " " + b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String[] str=in.readLine().split(" ");
    StringTokenizer st=new StringTokenizer(in.readLine());
    int a=Integer.parseInt(st.nextToken());
    int b=Integer.parseInt(st.nextToken());
    String u=in.readLine();
    System.out.println(u.equals(str[0])?(a-1)+" "+b : a+" "+(b-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := in.readLine()->split(" ") ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(in.readLine()) ;
    var a : int ; a := (st.next())->toInteger() ;
    var b : int ; b := (st.next())->toInteger() ;
    var u : String ; u := in.readLine() ;
    OclFile["System.out"].println(if u = str[0+1] then (a - 1) + " " + b else a + " " + (b - 1) endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  static FastReader sc=null ;
  public static void main(String[] args){
    sc=new FastReader();
    int n=sc.nextInt(),nax=105 ;
    int a[]=sc.readArray(n);
    int cnts[]=new int[nax];
    for(int e : a)cnts[e+1]++;
    int ans=0 ;
    int pre[]=new int[nax];
    for(int i=1 ; i<nax ; i++){
      pre[i]=pre[i-1]+cnts[i];
      int val=(pre[i]+i-1)/i ;
      ans=Math.max(ans,val);
    }
    System.out.println(ans);
  }
  static int[] ruffleSort(int a[]){
    ArrayList<Integer>al=new ArrayList<>();
    for(int i : a)al.add(i);
    Collections.sort(al);
    for(int i=0 ; i<a.length ; i++)a[i]=al.get(i);
    return a ;
  }
  static void print(int a[]){
    for(int e : a){
      System.out.print(e+" ");
    }
    System.out.println();
  }
  static class FastReader {
    StringTokenizer st=new StringTokenizer("");
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String next(){
      while(! st.hasMoreTokens())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());
    }
    int[] readArray(int n){
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute sc : FastReader := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := FastReader.newFastReader() ; 
     var n : int ; n := sc.nextInt() ;
    var nax : int ; nax := 105 ;
    var a : Sequence(int) ; a := sc.readArray(n) ;
    var cnts : Sequence(int) ; cnts := Integer.subrange(1,nax)->collect(0) ;
    for (e : a) do (     cnts[e + 1+1] := cnts[e + 1+1] + 1 ;  ) ; 
    var ans : int ; ans := 0 ;
    var pre : Sequence(int) ; pre := Integer.subrange(1,nax)->collect(0) ;
        var i : int ; i := 1 ; while i < nax do ( (     pre[i+1] := pre[i - 1+1] + cnts[i+1] ; 
     var val : int ; val := (pre[i+1] + i - 1) / i ;
     ans := Set{ans, val}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation ruffleSort( a : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var al : Sequence(int) ; al := Sequence{} ;
     for (i : a) do (     al := al->including(i) ;  ) ; 
    al := al->sort() ; 
        var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := al->at(i+1) ;  ;     i := i + 1 ) ; 
    return a 
 );
  static   operation print( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     for (e : a) do ( (     OclFile["System.out"].print(e + " ") )  ) ; 
     OclFile["System.out"].println() );
  static class FastReader {
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner w=new Scanner(System.in);
    String s=w.next();
    ;
    String t=w.next();
    int a=w.nextInt();
    int b=w.nextInt();
    String u=w.next();
    if(u.equals(s)){
      a=a-1 ;
    }
    else if(u.equals(t)){
      b=b-1 ;
    }
    System.out.print(a+" "+b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var w : OclFile ; w := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := w.getCurrent() ;
    var t : String ; t := w.getCurrent() ;
    var a : int ; a := w.getCurrent()->toInteger() ;
    var b : int ; b := w.getCurrent()->toInteger() ;
    var u : String ; u := w.getCurrent() ;
    if (u = s) then (     a := (a)->char2byte() - 1 ) else     if (u = t) then (     b := b - 1 ) else skip ; ;  
    OclFile["System.out"].print(a + " " + b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class NarrowFridge {
  private static Scanner s=new Scanner(System.in);
  public static void main(String[] args){
    int n=s.nextInt(),h=s.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=s.nextInt();
    PriorityQueue<Integer>overAllPq=new PriorityQueue<>(Collections.reverseOrder());
    int ans=-1 ;
    for(int i=0 ; i<n ; i++){
      overAllPq.add(arr[i]);
      PriorityQueue<Integer>pq=new PriorityQueue<>(Collections.reverseOrder());
      pq.addAll(overAllPq);
      int c1=h,c2=h ;
      boolean flag=true ;
      while(! pq.isEmpty()){
        if(flag){
          if(c1>=pq.peek()){
            c1-=pq.poll();
          }
          else {
            break ;
          }
          flag=false ;
        }
        else {
          if(c2>=pq.peek()){
            c2-=pq.poll();
          }
          else {
            break ;
          }
          flag=true ;
        }
      }
      if(pq.isEmpty()){
        ans=i+1 ;
      }
      else {
        break ;
      }
    }
    System.out.println(ans);
    s.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class NarrowFridge {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s.getCurrent()->toInteger() ;
    var h : int ; h := s.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var overAllPq : Sequence(int) ; overAllPq := Sequence{}->union(reverseOrder()) ;
    var ans : int ; ans := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     overAllPq := overAllPq->including(arr[i+1]) ; 
     var pq : Sequence(int) ; pq := Sequence{}->union(reverseOrder()) ;
    pq := pq->union(overAllPq) ; 
    var c1 : int ; c1 := h ;
    var c2 : int ; c2 := h ;
    var flag : boolean ; flag := true ;
    while (not(pq->isEmpty())) do (     if (flag) then (     if (c1 >= pq->min()) then (     c1 := c1 - (pq->min()) ;     pq := pq->sort()->tail() ) else (     break ) ;  
     flag := false ) else (     if (c2 >= pq->min()) then (     c2 := c2 - (pq->min()) ;     pq := pq->sort()->tail() ) else (     break ) ;  
     flag := true ) ) ; 
    if (pq->isEmpty()) then (     ans := i + 1 ) else (     break ) ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static int n,h ;
  static int a[];
  static boolean isPoss(int k){
    List<Integer>l=new ArrayList<>();
    long val=0 ;
    for(int i=0 ; i<k ; i++)l.add(a[i]);
    Collections.sort(l,Collections.reverseOrder());
    for(int i=0 ; i<k ; i+=2){
      val+=l.get(i);
    }
    return val<=h ;
  }
  static int solve(){
    int l=1,r=n ;
    int ans=1 ;
    while(l<=r){
      int mid=l+(r-l)/2 ;
      if(isPoss(mid)){
        ans=mid ;
        l=mid+1 ;
      }
      else r=mid-1 ;
    }
    return ans ;
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    String s[]=bf.readLine().trim().split("\\s+");
    n=Integer.parseInt(s[0]);
    h=Integer.parseInt(s[1]);
    a=new int[n];
    s=bf.readLine().trim().split("\\s+");
    for(int i=0 ; i<n ; i++)a[i]=Integer.parseInt(s[i]);
    str.append(solve()).append("\n");
    pw.print(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute n : int;
  static   attribute a : Sequence(int);
  static   operation isPoss( k : int) : boolean
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     var val : long ; val := 0 ;
        var i : int ; i := 0 ; while i < k do (     l := l->including(a[i+1]) ;  ;     i := i + 1 ) ; 
    l, reverseOrder() := l, reverseOrder()->sort() ; 
        var i : int ; i := 0 ; while i < k do ( (     val := val+(l->at(i+1)) )  ;     i := i+(2) ) ; 
    return val <= h 
 );
  static   operation solve() : int
  pre: true
  post: true
  activity: (     var l : int ; l := 1 ;
    var r : int ; r := n ;
     var ans : int ; ans := 1 ;
     while (l <= r) do (     var mid : int ; mid := l + (r - l) / 2 ;
     if (isPoss(mid)) then (     ans := mid ; 
     l := mid + 1 ) else     r := mid - 1 ; ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var s : Sequence(String) ; s := bf.readLine()->trim()->split("\\s+") ;
    n := (s[0+1])->toInteger() ; 
    h := (s[1+1])->toInteger() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
    s := bf.readLine()->trim()->split("\\s+") ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (s[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    str := str + StringLib.newString(solve()) + StringLib.newString("\n") ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Node {
    int data ;
    Node next ;
    Node(int data){
      this.data=data ;
      this.next=null ;
    }
  }
  static void printList(Node node){
    while(node!=null){
      System.out.print(node.data+"->");
      node=node.next ;
    }
    System.out.print("NULL");
  }
  static int cntNodes(Node node){
    if(node==null)return 0 ;
    return(1+cntNodes(node.next));
  }
  static void updateList(Node head,int m){
    int cnt=cntNodes(head);
    if(cnt!=m && m<cnt){
      int skip=cnt-m ;
      Node prev=null ;
      Node curr=head ;
      while(skip>0){
        prev=curr ;
        curr=curr.next ;
        skip--;
      }
      prev.next=null ;
      Node tempHead=head ;
      head=curr ;
      while(curr.next!=null)curr=curr.next ;
      curr.next=tempHead ;
    }
    printList(head);
  }
  public static void main(String[] args){
    Node head=new Node(4);
    head.next=new Node(5);
    head.next.next=new Node(6);
    head.next.next.next=new Node(1);
    head.next.next.next.next=new Node(2);
    head.next.next.next.next.next=new Node(3);
    int m=3 ;
    updateList(head,m);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
   static operation newNode( data : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(data);
    return self );
  operation initialise( data : int) : void
  pre: true  post: true
  activity: (     self.data := data ; 
     self.next := null );
}
  static   operation printList( node : Node) : void
  pre: true
  post: true
  activity: (     while (node /= null) do (     OclFile["System.out"].print(node.data + "->") ; 
     node := node.next ) ; 
     OclFile["System.out"].print("NULL") );
  static   operation cntNodes( node : Node) : int
  pre: true
  post: true
  activity: (     if (node = null) then     return 0 else skip ; 
     return (1 + cntNodes(node.next)) );
  static   operation updateList( head : Node, m : int) : void
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := cntNodes(head) ;
     if (cnt /= m & m < cnt) then (     var skip : int ; skip := cnt - m ;
     var prev : Node ; prev := null ;
    var curr : Node ; curr := head ;
    while (skip > 0) do (     prev := curr ; 
     curr := curr.next ; 
     skip := skip - 1 ) ; 
    prev.next := null ; 
    var tempHead : Node ; tempHead := head ;
    head := curr ; 
    while (curr.next /= null) do     curr := curr.next ; ; 
    curr.next := tempHead ; 
 ) else skip ; 
     execute printList(head) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := Node.newNode(4) ;
     head.next := Node.newNode(5) ; 
    head.next.next := Node.newNode(6) ; 
    head.next.next.next := Node.newNode(1) ; 
    head.next.next.next.next := Node.newNode(2) ; 
    head.next.next.next.next.next := Node.newNode(3) ; 
    var m : int ; m := 3 ;
    execute updateList(head, m) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int maxSubStrings(String s,int k){
    int maxSubStr=0,n=s.length();
    for(int c=0 ; c<26 ; c++){
      char ch=(char)((int)'a'+c);
      int curr=0 ;
      for(int i=0 ; i<=n-k ; i++){
        if(s.charAt(i)!=ch)continue ;
        int cnt=0 ;
        while(i<n && s.charAt(i)==ch && cnt!=k){
          i++;
          cnt++;
        }
        i--;
        if(cnt==k)curr++;
      }
      maxSubStr=Math.max(maxSubStr,curr);
    }
    return maxSubStr ;
  }
  public static void main(String[] args){
    String s="aaacaabbaa" ;
    int k=2 ;
    System.out.println(maxSubStrings(s,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSubStrings( s : String, k : int) : int
  pre: true
  post: true
  activity: (     var maxSubStr : int ; maxSubStr := 0 ;
    var n : int ; n := s->size() ;
         var c : int ; c := 0 ; while c < 26 do ( (     var ch : String ; ch := (('a')->char2byte() + c)->oclAsType(String) ;
     var curr : int ; curr := 0 ;
         var i : int ; i := 0 ; while i <= n - k do ( (     if (s->at(i+1) /= ch) then     continue else skip ; 
     var cnt : int ; cnt := 0 ;
    while (i < n & s->at(i+1) = ch & cnt /= k) do (     i := i + 1 ; 
     cnt := cnt + 1 ) ; 
    i := i - 1 ; 
    if (cnt = k) then     curr := curr + 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
     maxSubStr := Set{maxSubStr, curr}->max() )  ;     c := c + 1 ) ; 
     return maxSubStr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "aaacaabbaa" ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(maxSubStrings(s, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.nio.charset.MalformedInputException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
import java.util.HashSet ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter o=new PrintWriter(System.out);
    int n=sc.nextInt();
    int s=sc.nextInt();
    int max=0 ;
    while(n-->0){
      int f=sc.nextInt();
      int t=sc.nextInt();
      if(max<f+t){
        max=f+t ;
      }
    }
    o.println(Math.max(max,s));
    o.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var o : OclFile ; o := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var max : int ; max := 0 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var f : int ; f := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     if (max < f + t) then (     max := f + t ) else skip ) ;  ) ;  
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void ansQueries(int prefeven[],int prefodd[],int l,int r){
    if((r-l+1)% 2==0)System.out.println("0");
    else {
      if(l % 2==0)System.out.println(prefeven[r] ^ prefeven[l-1]);
      else System.out.println(prefodd[r] ^ prefodd[l-1]);
    }
  }
  static void wrapper(int arr[],int n,int l[],int r[],int q){
    int prefodd[]=new int[100];
    int prefeven[]=new int[100];
    for(int i=1 ; i<=n ; i++){
      if((i)% 2==0){
        prefeven[i]=arr[i-1] ^ prefeven[i-1];
        prefodd[i]=prefodd[i-1];
      }
      else {
        prefeven[i]=prefeven[i-1];
        prefodd[i]=prefodd[i-1] ^ arr[i-1];
      }
    }
    int i=0 ;
    while(i!=q){
      ansQueries(prefeven,prefodd,l[i],r[i]);
      i++;
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5 };
      int n=arr.length ;
      int l[]={
        1,1,2 };
        int r[]={
          2,3,4 };
          int q=l.length ;
          wrapper(arr,n,l,r,q);
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation ansQueries( prefeven : Sequence(int), prefodd : Sequence(int), l : int, r : int) : void
  pre: true
  post: true
  activity: (     if ((r - l + 1) mod 2 = 0) then     OclFile["System.out"].println("0") ; else (     if (l mod 2 = 0) then     OclFile["System.out"].println(prefeven[r+1] xor prefeven[l - 1+1]) ; else     OclFile["System.out"].println(prefodd[r+1] xor prefodd[l - 1+1]) ; ) );
  static   operation wrapper( arr : Sequence(int), n : int, l : Sequence(int), r : Sequence(int), q : int) : void
  pre: true
  post: true
  activity: (     var prefodd : Sequence(int) ; prefodd := Integer.subrange(1,100)->collect(0) ;
     var prefeven : Sequence(int) ; prefeven := Integer.subrange(1,100)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     if ((i) mod 2 = 0) then (     prefeven[i+1] := arr[i - 1+1] xor prefeven[i - 1+1] ; 
     prefodd[i+1] := prefodd[i - 1+1] ) else (     prefeven[i+1] := prefeven[i - 1+1] ; 
     prefodd[i+1] := prefodd[i - 1+1] xor arr[i - 1+1] ) )  ;     i := i + 1 ) ; 
    var i : int ; i := 0 ;
    while (i /= q) do (     execute ansQueries(prefeven, prefodd, l[i+1], r[i+1]) ; 
     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var n : int ; n := arr->size() ;
    var l : Sequence(int) ; l := Sequence{1,1,2} ;
    var r : Sequence(int) ; r := Sequence{2,3,4} ;
    var q : int ; q := l->size() ;
    execute wrapper(arr, n, l, r, q) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    Long[] ans=new Long[n];
    for(int i=0 ; i<n ; i++){
      ans[i]=in.nextLong();
    }
    Arrays.sort(ans);
    Long count=ans[n-1];
    for(int i=n-2 ; i>=0 ; i--){
      if(ans[i]<ans[i+1]){
        count+=ans[i];
      }
      else {
        while(ans[i]>=ans[i+1]){
          ans[i]--;
        }
        if(ans[i]>0){
          count+=ans[i];
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var ans : Sequence(long) ; ans := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     ans[i+1] := in.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    ans := ans->sort() ; 
    var count : long ; count := ans[n - 1+1] ;
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (ans[i+1] < ans[i + 1+1]) then (     count := count+(ans[i+1]) ) else (     while (ans[i+1] >= ans[i + 1+1]) do (     ans[i+1] := ans[i+1] - 1 ) ; 
     if (ans[i+1] > 0) then (     count := count+(ans[i+1]) ) else skip ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    in.nextLine();
    String[] strings=in.nextLine().split(" ");
    long[] arr=new long[strings.length];
    for(int i=0 ; i<strings.length ; i++){
      arr[i]=Long.parseLong(strings[i]);
      arr[i]=-arr[i];
    }
    long ans=0 ;
    Arrays.sort(arr);
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=-arr[i];
    }
    Set<Long>set=new HashSet<>();
    for(int i=0 ; i<arr.length ; i++){
      long t=arr[i];
      while(t>0 && set.contains(t)){
        t--;
      }
      ans+=t ;
      set.add(t);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    skip ; 
    var strings : Sequence(String) ; strings := in.nextLine()->split(" ") ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,strings->size())->collect(0) ;
        var i : int ; i := 0 ; while i < strings->size() do ( (     arr[i+1] := (strings[i+1])->toLong() ; 
     arr[i+1] := -arr[i+1] )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := -arr[i+1] )  ;     i := i + 1 ) ; 
    var set : Set(long) ; set := Set{} ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     var t : long ; t := arr[i+1] ;
     while (t > 0 & set->includes(t)) do (     t := t - 1 ) ; 
     ans := ans+(t) ; 
     set := set->including(t) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class MakingAString {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    long a[]=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextLong();
    }
    Arrays.sort(a);
    long count=-0 ;
    for(int i=n-2 ; i>=0 ; i--){
      for(int j=n-1 ; j>i ; j--){
        if(a[i]==a[j]){
          a[i]--;
          if(a[i]<0)a[i]=0 ;
        }
      }
    }
    for(int i=0 ; i<n ; i++)count+=a[i];
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MakingAString {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var count : long ; count := -0 ;
        var i : int ; i := n - 2 ; while i >= 0 do ( (         var j : int ; j := n - 1 ; while j > i do ( (     if (a[i+1] = a[j+1]) then (     a[i+1] := a[i+1] - 1 ; 
     if (a[i+1] < 0) then     a[i+1] := 0 ; else skip ) else skip )  ;     j := j - 1 ) )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     count := count+(a[i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class LuckyNumbers {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    ArrayList<Long>ls=new ArrayList<>();
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      long x=in.nextLong();
      ls.add(x);
    }
    Collections.sort(ls);
    long max=Long.MAX_VALUE ;
    long ans=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(ls.get(i)<max){
        ans+=ls.get(i);
        max=ls.get(i);
      }
      else {
        long x=ls.get(i);
        x=max-1 ;
        if(x<0)break ;
        ans+=x ;
        max=x ;
      }
    }
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class LuckyNumbers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var ls : Sequence(long) ; ls := Sequence{} ;
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var x : long ; x := in.getCurrent()->toLong() ;
     ls := ls->including(x) )  ;     i := i + 1 ) ; 
    ls := ls->sort() ; 
    var max : long ; max := "9223372036854775807"->toLong() ;
    var ans : long ; ans := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (ls->at(i+1) < max) then (     ans := ans+(ls->at(i+1)) ; 
     max := ls->at(i+1) ) else (     var x : long ; x := ls->at(i+1) ;
     x := max - 1 ; 
    if (x < 0) then     break else skip ; 
    ans := ans+(x) ; 
    max := x ; 
 ) )  ;     i := i - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class CD2C17 {
  public static void reverseArr(int arr[]){
    for(int i=0 ; i<arr.length/2 ; i++){
      int temp=arr[i];
      arr[i]=arr[arr.length-i-1];
      arr[arr.length-i-1]=temp ;
    }
  }
  public static void main(String args[])throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String input1[]=br.readLine().split(" ");
    int n=Integer.parseInt(input1[0]);
    String input2[]=br.readLine().split(" ");
    int data[]=new int[n];
    for(int i=0 ; i<n ; i++){
      data[i]=Integer.parseInt(input2[i]);
    }
    boolean visited[]=new boolean[n];
    int numPiles=0 ;
    Arrays.sort(data);
    reverseArr(data);
    for(int i=0 ; i<n ; i++){
      if(! visited[i]){
        visited[i]=true ;
        numPiles++;
        int cap=data[i];
        int itr=n-1 ;
        int fillRight=0 ;
        while(cap!=0 && itr>i){
          if(! visited[itr] && data[itr]>=fillRight){
            fillRight++;
            visited[itr]=true ;
            cap--;
          }
          itr--;
        }
      }
    }
    System.out.println(numPiles);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CD2C17 {
  static   operation reverseArr( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < arr->size() / 2 do ( (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := arr[arr->size() - i - 1+1] ; 
     arr[arr->size() - i - 1+1] := temp )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input1 : Sequence(String) ; input1 := br.readLine()->split(" ") ;
    var n : int ; n := (input1[0+1])->toInteger() ;
    var input2 : Sequence(String) ; input2 := br.readLine()->split(" ") ;
    var data : Sequence(int) ; data := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     data[i+1] := (input2[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,n)->collect(false) ;
    var numPiles : int ; numPiles := 0 ;
    data := data->sort() ; 
    execute reverseArr(data) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (not(visited[i+1])) then (     visited[i+1] := true ; 
     numPiles := numPiles + 1 ; 
    var cap : int ; cap := data[i+1] ;
    var itr : int ; itr := (n)->char2byte() - 1 ;
    var fillRight : int ; fillRight := 0 ;
    while (cap /= 0 & itr > i) do (     if (not(visited[itr+1]) & data[itr+1] >= fillRight) then (     fillRight := fillRight + 1 ; 
     visited[itr+1] := true ; 
     cap := cap - 1 ) else skip ; 
     itr := itr - 1 ) ; 
 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(numPiles) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int num=reader.nextInt();
    while(num-->0){
      int n=reader.nextInt();
      int k=reader.nextInt();
      long arr[]=new long[n*k];
      for(int i=0 ; i<n*k ; i++){
        arr[i]=reader.nextLong();
      }
      long sum=0 ;
      int skip=0 ;
      int start=k*n ;
      if(n % 2==0){
        skip=n/2 ;
        for(int i=1 ; i<=k ; i++){
          sum+=arr[start-skip-1];
          start=start-skip-1 ;
        }
      }
      else {
        skip=n/2+1 ;
        for(int i=1 ; i<=k ; i++){
          sum+=arr[start-skip];
          start=start-skip ;
        }
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var num : int ; num := reader.nextInt() ;
         while (num > 0) do (        num := num - 1 ;     skip ; (     var n : int ; n := reader.nextInt() ;
     var k : int ; k := reader.nextInt() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n * k)->collect(0) ;
        var i : int ; i := 0 ; while i < n * k do ( (     arr[i+1] := reader.nextLong() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    var skip : int ; skip := 0 ;
    var start : int ; start := k * n ;
    if (n mod 2 = 0) then (     skip := n / 2 ; 
         var i : int ; i := 1 ; while i <= k do ( (     sum := sum+(arr[start - skip - 1+1]) ; 
     start := start - skip - 1 )  ;     i := i + 1 ) ) else (     skip := n / 2 + 1 ; 
         var i : int ; i := 1 ; while i <= k do ( (     sum := sum+(arr[start - skip+1]) ; 
     start := start - skip )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(sum) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public final class Solution {
  public static void main(String[] args)throws IOException {
    BufferedReader bi=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(bi.readLine());
    while(t>0){
      String s[]=bi.readLine().split(" ");
      int n=Integer.parseInt(s[0]);
      int k=Integer.parseInt(s[1]);
      String s1[]=bi.readLine().split(" ");
      int m=(int)Math.ceil((double)n/2);
      int indx=(m-1)*k ;
      long sum=0 ;
      long skip=n-m+1 ;
      while(k>0){
        sum+=Integer.parseInt(s1[indx]);
        indx+=skip ;
        k--;
      }
      System.out.println(sum);
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bi : OclFile ; bi := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (bi.readLine())->toInteger() ;
     while (t > 0) do (     var s : Sequence(String) ; s := bi.readLine()->split(" ") ;
     var n : int ; n := (s[0+1])->toInteger() ;
    var k : int ; k := (s[1+1])->toInteger() ;
    var s1 : Sequence(String) ; s1 := bi.readLine()->split(" ") ;
    var m : int ; m := (n->oclAsType(double) / 2)->ceil()->oclAsType(int) ;
    var indx : int ; indx := ((m)->char2byte() - 1) * k ;
    var sum : long ; sum := 0 ;
    var skip : long ; skip := (n)->char2byte() - (m)->char2byte() + 1 ;
    while (k > 0) do (     sum := sum+((s1[indx+1])->toInteger()) ; 
     indx := indx+(skip) ; 
     k := k - 1 ) ; 
    OclFile["System.out"].println(sum) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class B {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int ttt=sc.nextInt();
    outer : while(ttt-->0){
      int n=sc.nextInt();
      int k=sc.nextInt();
      int[] a=new int[n*k];
      for(int i=0 ; i<(n*k); i++){
        a[i]=sc.nextInt();
      }
      int x=(int)Math.round(n/2.0);
      long sum=0 ;
      if(x!=1){
        for(int i=(n*k)-(n-x); i>(x-1)*k ; i=i-(n-x+1)){
          sum=sum+a[i-1];
        }
        System.out.println(sum);
      }
      else {
        for(int i=0 ; i<(n*k); i=i+(n-x+1)){
          sum=sum+a[i];
        }
        System.out.println(sum);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ttt : int ; ttt := sc.getCurrent()->toInteger() ;
         while (ttt > 0) do (        ttt := ttt - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n * k)->collect(0) ;
        var i : int ; i := 0 ; while i < (n * k) do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var x : int ; x := (n / 2.0)->round()->oclAsType(int) ;
    var sum : long ; sum := 0 ;
    if (x /= 1) then (         var i : int ; i := (n * k) - (n - x) ; while i > (x - 1) * k do ( (     sum := sum + a[i - 1+1] )  ;     i := i - (n - x + 1) ) ; 
     OclFile["System.out"].println(sum) ) else (         var i : int ; i := 0 ; while i < (n * k) do ( (     sum := sum + a[i+1] )  ;     i := i + (n - x + 1) ) ; 
     OclFile["System.out"].println(sum) ) ;  
 ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int k=sc.nextInt();
      int[] arr=new int[n*k];
      for(int i=0 ; i<n*k ; i++){
        arr[i]=sc.nextInt();
      }
      if((n==1 && k==1)||(n==2 && k==1)){
        System.out.println(arr[0]);
        continue ;
      }
      int k1=n/2+1 ;
      int k2=n-k1 ;
      long sum=0 ;
      for(int i=n*k-k1 ; i>=k*k2 ; i-=k1){
        sum+=arr[i];
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n * k)->collect(0) ;
        var i : int ; i := 0 ; while i < n * k do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if ((n = 1 & k = 1) or (n = 2 & k = 1)) then (     OclFile["System.out"].println(arr[0+1]) ; 
     continue ) else skip ; 
    var k1 : int ; k1 := n / 2 + 1 ;
    var k2 : int ; k2 := n - k1 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := n * k - k1 ; while i >= k * k2 do ( (     sum := sum+(arr[i+1]) )  ;     i := i-(k1) ) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.nio.charset.MalformedInputException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
import java.util.HashSet ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter o=new PrintWriter(System.out);
    int n=sc.nextInt();
    int s=sc.nextInt();
    int max=0 ;
    while(n-->0){
      int f=sc.nextInt();
      int t=sc.nextInt();
      if(max<f+t){
        max=f+t ;
      }
    }
    o.println(Math.max(max,s));
    o.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var o : OclFile ; o := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var max : int ; max := 0 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var f : int ; f := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     if (max < f + t) then (     max := f + t ) else skip ) ;  ) ;  
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int q=sc.nextInt();
    Map<Integer,Deque<Long>>Stack=new HashMap<>();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      Deque<Long>L=new ArrayDeque<>();
      Stack.put(i,L);
    }
    for(int i=0 ; i<q ; i++){
      int cmd=sc.nextInt();
      int t=sc.nextInt();
      if(cmd==0)Stack.get(t).push(sc.nextLong());
      else if(cmd==1 && Stack.get(t).size()!=0)sb.append(Stack.get(t).getFirst()+"\n");
      else if(cmd==2 && Stack.get(t).size()!=0)Stack.get(t).pop();
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var Stack : Map(int,Sequence(long)) ; Stack := Map{} ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     var L : Sequence(long) ; L := ArrayDeque<OclAny>.newArrayDeque() ;
     Stack := Stack->union(Map{i |-> L}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var cmd : int ; cmd := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     if (cmd = 0) then     Stack := Stack->at(t)->append(sc.getCurrent()->toLong()) ; else     if (cmd = 1 & Stack->at(t)->size() /= 0) then     sb := sb + StringLib.newString(Stack->at(t)->first() + "\n") else     if (cmd = 2 & Stack->at(t)->size() /= 0) then     Stack := Stack->at(t)->front() ; else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Deque ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    ArrayList<Deque<Integer>>deques=new ArrayList<Deque<Integer>>();
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      for(int i=0 ; i<n ; i++){
        deques.add(new ArrayDeque<Integer>());
      }
      int times=sc.nextInt();
      for(int i=0 ; i<times ; i++){
        int request=sc.nextInt();
        int deq=sc.nextInt();
        switch(request){
          case 0 : int x=sc.nextInt();
          deques.get(deq).addFirst(x);
          break ;
          case 1 : if(deques.get(deq).size()!=0){
            System.out.println(deques.get(deq).peek());
          }
          break ;
          case 2 : if(deques.get(deq).size()!=0){
            deques.get(deq).pop();
          }
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var deques : Sequence(Sequence(int)) ; deques := Sequence{} ;
     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     deques := deques->including(ArrayDeque<int>.newArrayDeque()) )  ;     i := i + 1 ) ; 
     var times : int ; times := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < times do ( (     var request : int ; request := sc.getCurrent()->toInteger() ;
     var deq : int ; deq := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (request) ; 
       if _switchval = 0 then
     var x : int ; x := sc.getCurrent()->toInteger() ;
    deques := deques->at(deq+1)->prepend(x) ; 
    break 
   else skip ;
       if _switchval = 1 then
     if (deques->at(deq+1)->size() /= 0) then (     OclFile["System.out"].println(deques->at(deq+1)->min()) ) else skip ; 
    break 
   else skip ;
       if _switchval = 2 then
     if (deques->at(deq+1)->size() /= 0) then (     deques := deques->at(deq+1)->front() ) else skip ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Deque ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    List<Deque<Integer>>list=new ArrayList<>();
    int n=sc.nextInt();
    int q=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      list.add(new ArrayDeque<>());
    }
    for(int i=0 ; i<q ; i++){
      switch(sc.nextInt()){
        case 0 : list.get(sc.nextInt()).addFirst(sc.nextInt());
        break ;
        case 1 : int t=sc.nextInt();
        if(! list.get(t).isEmpty()){
          System.out.println(list.get(t).peekFirst());
        }
        break ;
        case 2 : t=sc.nextInt();
        if(! list.get(t).isEmpty()){
          list.get(t).removeFirst();
        }
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(Sequence(int)) ; list := Sequence{} ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(ArrayDeque<OclAny>.newArrayDeque()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (sc.getCurrent()->toInteger()) ; 
       if _switchval = 0 then
     list := list->at(sc.getCurrent()->toInteger()+1)->prepend(sc.getCurrent()->toInteger()) ; 
    break 
   else skip ;
       if _switchval = 1 then
     var t : int ; t := sc.getCurrent()->toInteger() ;
    if (not(list->at(t+1)->isEmpty())) then (     OclFile["System.out"].println(list->at(t+1).peekFirst()) ) else skip ; 
    break 
   else skip ;
       if _switchval = 2 then
     t := sc.getCurrent()->toInteger() ; 
    if (not(list->at(t+1)->isEmpty())) then (     list := list->at(t+1)->tail() ) else skip ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printArray(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  static void removeMin(int arr[],int n){
    int i,minVal=arr[0];
    for(i=1 ; i<n ; i++)minVal=Math.min(minVal,arr[i]);
    for(i=0 ; i<n ; i++)arr[i]=arr[i]-minVal ;
  }
  static void removeFromMax(int arr[],int n){
    int i,maxVal=arr[0];
    for(i=1 ; i<n ; i++)maxVal=Math.max(maxVal,arr[i]);
    for(i=0 ; i<n ; i++)arr[i]=maxVal-arr[i];
  }
  static void modifyArray(int arr[],int n,int k){
    if(k % 2==0)removeMin(arr,n);
    else removeFromMax(arr,n);
    printArray(arr,n);
  }
  public static void main(String args[]){
    int arr[]={
      4,8,12,16 };
      int n=arr.length ;
      int k=2 ;
      modifyArray(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation removeMin( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var minVal : int ; minVal := arr[0+1] ;
         i := 1 ; while i < n do (     minVal := Set{minVal, arr[i+1]}->min() ;  ;     i := i + 1 ) ; 
         i := 0 ; while i < n do (     arr[i+1] := arr[i+1] - minVal ;  ;     i := i + 1 ) );
  static   operation removeFromMax( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var maxVal : int ; maxVal := arr[0+1] ;
         i := 1 ; while i < n do (     maxVal := Set{maxVal, arr[i+1]}->max() ;  ;     i := i + 1 ) ; 
         i := 0 ; while i < n do (     arr[i+1] := maxVal - arr[i+1] ;  ;     i := i + 1 ) );
  static   operation modifyArray( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     if (k mod 2 = 0) then     execute removeMin(arr, n) else     execute removeFromMax(arr, n) ; ;  
     execute printArray(arr, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,8,12,16} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     execute modifyArray(arr, n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int[] cnt=new int[100+1];
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      cnt[in.nextInt()]++;
    }
    int res=0 ;
    for(int i=0 ; i<=100 ; i++){
      int temp=i ;
      if(cnt[i]==0)continue ;
      for(int k=0 ; k<=100 ; k++){
        if(cnt[k]>0){
          i=k-1 ;
          break ;
        }
      }
      ArrayList<Integer>ls=new ArrayList<>();
      ls.add(temp);
      res++;
      cnt[temp]--;
      for(int j=0 ; j<=100 ; j++){
        if(j<ls.size()&& cnt[j]==0)continue ;
        while(ls.size()<=j && cnt[j]>0){
          cnt[j]--;
          ls.add(j);
        }
      }
    }
    pw.println(res);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,100 + 1)->collect(0) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     cnt[in.getCurrent()->toInteger()+1] := cnt[in.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i <= 100 do ( (     var temp : int ; temp := i ;
     if (cnt[i+1] = 0) then     continue else skip ; 
        var k : int ; k := 0 ; while k <= 100 do ( (     if (cnt[k+1] > 0) then (     i := k - 1 ; 
     break ) else skip )  ;     k := k + 1 ) ; 
    var ls : Sequence(int) ; ls := Sequence{} ;
    ls := ls->including(temp) ; 
    res := res + 1 ; 
    cnt[temp+1] := cnt[temp+1] - 1 ; 
        var j : int ; j := 0 ; while j <= 100 do ( (     if (j < ls->size() & cnt[j+1] = 0) then     continue else skip ; 
     while (ls->size() <= j & cnt[j+1] > 0) do (     cnt[j+1] := cnt[j+1] - 1 ; 
     ls := ls->including(j) ) )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double[] find_Centroid(double v[][]){
    double[] ans=new double[2];
    int n=v.length ;
    double signedArea=0 ;
    for(int i=0 ; i<n ; i++){
      double x0=v[i][0],y0=v[i][1];
      double x1=v[(i+1)% n][0],y1=v[(i+1)% n][1];
      double A=(x0*y1)-(x1*y0);
      signedArea+=A ;
      ans[0]+=(x0+x1)*A ;
      ans[1]+=(y0+y1)*A ;
    }
    signedArea*=0.5 ;
    ans[0]=(ans[0])/(6*signedArea);
    ans[1]=(ans[1])/(6*signedArea);
    return ans ;
  }
  public static void main(String[] args){
    double vp[][]={
      {
        1,2 },{
          3,-4 },{
            6,-7 }
          };
          double[] ans=find_Centroid(vp);
          System.out.println(ans[0]+" "+ans[1]);
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find_Centroid( v : Sequence(Sequence(double))) : Sequence(double)
  pre: true
  post: true
  activity: (     var ans : Sequence(double) ; ans := Integer.subrange(1,2)->collect(0.0) ;
     var n : int ; n := v->size() ;
    var signedArea : double ; signedArea := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x0 : double ; x0 := v[i+1][0+1] ;
    var y0 : double ; y0 := v[i+1][1+1] ;
     var x1 : double ; x1 := v[(i + 1) mod n+1][0+1] ;
    var y1 : double ; y1 := v[(i + 1) mod n+1][1+1] ;
    var A : double ; A := (x0 * y1) - (x1 * y0) ;
    signedArea := signedArea+(A) ; 
    ans[0+1] := ans[0+1]+((x0 + x1) * A) ; 
    ans[1+1] := ans[1+1]+((y0 + y1) * A) ; 
 )  ;     i := i + 1 ) ; 
    signedArea := signedArea*(0.5) ; 
    ans[0+1] := (ans[0+1]) / (6 * signedArea) ; 
    ans[1+1] := (ans[1+1]) / (6 * signedArea) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var vp : Sequence(Sequence(double)) ; vp := Sequence{Sequence{1,2},Sequence{3,-4},Sequence{6,-7}} ;
     var ans : Sequence(double) ; ans := find_Centroid(vp) ;
     OclFile["System.out"].println(ans[0+1] + " " + ans[1+1]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class App {
  public static void main(String[] args){
    String color="blue" ;
    boolean locked=false ;
    Scanner in=new Scanner(System.in);
    final int lines=in.nextInt();
    for(int i=0 ; i<lines ; i++){
      final String next=in.next();
      if("lock"==next.intern()){
        locked=true ;
        continue ;
      }
      if("unlock"==next.intern()){
        locked=false ;
        continue ;
      }
      if(locked){
        continue ;
      }
      color=next ;
    }
    System.out.println(color);
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var color : String ; color := "blue" ;
     var locked : boolean ; locked := false ;
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var lines : int ; lines := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < lines do ( (     var next : String ; next := in.getCurrent() ;
     if ("lock" = next+"") then (     locked := true ; 
     continue ) else skip ; 
    if ("unlock" = next+"") then (     locked := false ; 
     continue ) else skip ; 
    if (locked) then (     continue ) else skip ; 
    color := next ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(color) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class App {
  public static void main(String[] args){
    String color="blue" ;
    boolean locked=false ;
    Scanner in=new Scanner(System.in);
    final int lines=in.nextInt();
    for(int i=0 ; i<lines ; i++){
      final String next=in.next();
      if("lock".equals(next)){
        locked=true ;
        continue ;
      }
      if("unlock".equals(next)){
        locked=false ;
        continue ;
      }
      if(locked){
        continue ;
      }
      color=next ;
    }
    System.out.println(color);
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var color : String ; color := "blue" ;
     var locked : boolean ; locked := false ;
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var lines : int ; lines := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < lines do ( (     var next : String ; next := in.getCurrent() ;
     if ("lock" = next) then (     locked := true ; 
     continue ) else skip ; 
    if ("unlock" = next) then (     locked := false ; 
     continue ) else skip ; 
    if (locked) then (     continue ) else skip ; 
    color := next ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(color) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.Scanner ;
import static java.util.Collections.sort ;
public class hortels {
  public static void sortbyColumn(int arr[][],int col){
    Arrays.sort(arr,new Comparator<int[]>(){
      @ Override public int compare(final int[] entry1,final int[] entry2){
        if(entry1[col]>entry2[col])return 1 ;
        else return-1 ;
      }
    }
);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int n=sc.nextInt();
    int s=sc.nextInt();
    int sum=0 ;
    int floor=s ;
    int[][] arr=new int[n][2];
    for(int i=0 ; i<n ; i++){
      arr[i][0]=sc.nextInt();
      arr[i][1]=sc.nextInt();
    }
    for(int i=n-1 ; i>=0 ; i--){
      sum=sum+(floor-arr[i][0]);
      if(sum<arr[i][1]){
        sum=(arr[i][1]);
      }
      floor=arr[i][0];
    }
    sum+=floor ;
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class hortels {
  static   operation sortbyColumn( arr : Sequence(Sequence(int)), col : int) : void
  pre: true
  post: true
  activity: (     arr := OclComparator.sortWith(arr, OclComparator<Sequence(int)>.newOclComparator()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var floor : int ; floor := s ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     arr[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     sum := sum + (floor - arr[i+1][0+1]) ; 
     if (sum < arr[i+1][1+1]) then (     sum := (arr[i+1][1+1]) ) else skip ; 
     floor := arr[i+1][0+1] )  ;     i := i - 1 ) ; 
    sum := sum+(floor) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static class Bot {
    private String block ;
    private String color ;
    public Bot(){
      this.block="unlock" ;
      this.color="blue" ;
    }
    public void lock(){
      this.block="lock" ;
    }
    public void unlock(){
      this.block="unlock" ;
    }
    public void changeColor(String color){
      this.color=color ;
    }
    public String getBlock(){
      return block ;
    }
    public String getColor(){
      return color ;
    }
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    Bot bot=new Bot();
    for(int i=0 ; i<n ; i++){
      String command=scanner.next();
      if(command.equals("lock"))bot.lock();
      else if(command.equals("unlock"))bot.unlock();
      else if(bot.getBlock().equals("unlock"))bot.changeColor(command);
    }
    System.out.println(bot.getColor());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Bot {
   attribute block : String;
   attribute color : String;
   static operation newBot() : Bot
  pre: true
  post: true
  activity:
  ( var self : Bot ;
    self := createBot();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.block := "unlock" ; 
     self.color := "blue" );
   operation lock() : void
  pre: true
  post: true
  activity: (     self.block := "lock" );
   operation unlock() : void
  pre: true
  post: true
  activity: (     self.block := "unlock" );
   operation changeColor( color : String) : void
  pre: true
  post: true
  activity: (     self.color := color );
   operation getBlock() : String
  pre: true
  post: true
  activity: (     return block );
   operation getColor() : String
  pre: true
  post: true
  activity: (     return color );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var bot : Bot ; bot := Bot.newBot() ;
        var i : int ; i := 0 ; while i < n do ( (     var command : String ; command := scanner.getCurrent() ;
     if (command = "lock") then     bot.lock() ; else     if (command = "unlock") then     bot.unlock() else     if (bot.getBlock() = "unlock") then     bot.changeColor(command) ; else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(bot.getColor()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class First {
  public void run(){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    boolean lock=false ;
    String ans="blue" ;
    for(int i=0 ; i<n ; i++){
      String s=in.next();
      if(s.equals("lock")){
        lock=true ;
        continue ;
      }
      else if(s.equals("unlock")){
        lock=false ;
        continue ;
      }
      else if(! lock &&(s.equals("red")|| s.equals("orange")|| s.equals("yellow")|| s.equals("green")|| s.equals("blue")|| s.equals("indigo")|| s.equals("violet"))){
        ans=s ;
      }
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    new First().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class First {
   operation run() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var lock : boolean ; lock := false ;
    var ans : String ; ans := "blue" ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := in.getCurrent() ;
     if (s = "lock") then (     lock := true ; 
     continue ) else     if (s = "unlock") then (     lock := false ; 
     continue ) else     if (not(lock) & (s = "red" or s = "orange" or s = "yellow" or s = "green" or s = "blue" or s = "indigo" or s = "violet")) then (     ans := s ) else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     First.newFirst().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class geeksforgeeks {
  static int minOperations(int ar[],int k){
    Arrays.sort(ar);
    int opsNeeded=0 ;
    for(int i=0 ; i<k ; i++){
      opsNeeded+=ar[k-1]-ar[i];
    }
    int ans=opsNeeded ;
    for(int i=k ; i<ar.length ; i++){
      opsNeeded=opsNeeded-(ar[i-1]-ar[i-k]);
      opsNeeded+=(k-1)*(ar[i]-ar[i-1]);
      ans=Math.min(ans,opsNeeded);
    }
    return ans ;
  }
  public static void main(String[] args){
    int[] arr={
      3,1,9,100 };
      int n=arr.length ;
      int k=3 ;
      System.out.printf("%d",minOperations(arr,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class geeksforgeeks {
  static   operation minOperations( ar : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     ar := ar->sort() ; 
     var opsNeeded : int ; opsNeeded := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     opsNeeded := opsNeeded+(ar[k - 1+1] - ar[i+1]) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := opsNeeded ;
        var i : int ; i := k ; while i < ar->size() do ( (     opsNeeded := opsNeeded - (ar[i - 1+1] - ar[i - k+1]) ; 
     opsNeeded := opsNeeded+((k - 1) * (ar[i+1] - ar[i - 1+1])) ; 
     ans := Set{ans, opsNeeded}->min() )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,1,9,100} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     OclFile["System.out"].printf("%d", minOperations(arr, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void charCheck(char input_char){
    if((input_char>=65 && input_char<=90)||(input_char>=97 && input_char<=122))System.out.println(" Alphabet ");
    else if(input_char>=48 && input_char<=57)System.out.println(" Digit ");
    else System.out.println(" Special Character ");
  }
  public static void main(String[] args){
    char input_char='$' ;
    charCheck(input_char);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation charCheck( input_char : String) : void
  pre: true
  post: true
  activity: (     if ((input_char >= 65 & input_char <= 90) or (input_char >= 97 & input_char <= 122)) then     OclFile["System.out"].println(" Alphabet ") ; else     if (input_char >= 48 & input_char <= 57) then     OclFile["System.out"].println(" Digit ") else     OclFile["System.out"].println(" Special Character ") ; ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input_char : String ; input_char := '$' ;
     execute charCheck(input_char) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Integer>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++)list.add(sc.nextInt());
    for(int i=0 ; i<n ; i++){
      HashMap<Integer,Integer>map=new HashMap<>();
      map.put(i+1,1);
      int flag=0 ;
      int j=i ;
      while(flag==0){
        if(! map.containsKey(list.get(j)))map.put(list.get(j),1);
        else {
          flag=1 ;
          System.out.print(list.get(j)+" ");
        }
        j=list.get(j);
        j--;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     list := list->including(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var map : Map(int,int) ; map := Map{} ;
     map := map->union(Map{i + 1 |-> 1}) ; 
    var flag : int ; flag := 0 ;
    var j : int ; j := i ;
    while (flag = 0) do (     if (not(map->keys()->includes(list->at(j+1)))) then     map := map->union(Map{list->at(j+1) |-> 1}) else (     flag := 1 ; 
     OclFile["System.out"].print(list->at(j+1) + " ") ) ;  
     j := list->at(j+1) ; 
     j := j - 1 ) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Iterator ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Graph {
  private int V ;
  private LinkedList<Integer>adj[];
  @ SuppressWarnings("unchecked")Graph(int v){
    V=v ;
    adj=new LinkedList[v];
    for(int i=0 ; i<v ; ++i)adj[i]=new LinkedList();
  }
  void addEdge(int v,int w){
    adj[v] .add(w);
  }
  void DFSUtil(int v,boolean visited[]){
    visited[v]=true ;
    Iterator<Integer>i=adj[v] .listIterator();
    while(i.hasNext()){
      int n=i.next();
      if(! visited[n])DFSUtil(n,visited);
      if(f){
        System.out.print(n+1+" ");
        f=false ;
      }
    }
  }
  static boolean f=true ;
  void DFS(){
    for(int i=0 ; i<V ; ++i){
      boolean visited[]=new boolean[V];
      f=true ;
      if(visited[i]==false)DFSUtil(i,visited);
    }
  }
  static Scanner sc=new Scanner(System.in);
  static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args){
    int n=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    Graph graph=new Graph(n);
    for(int i=0 ; i<arr.length ; i++){
      graph.addEdge(i,arr[i]-1);
    }
    graph.DFS();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Graph {
   attribute V : int;
   attribute adj : Sequence(Sequence(int));
     static operation newGraph( v : int) : Graph
  pre: true
  post: true
  activity:
  ( var self : Graph ;
    self := createGraph();
    self.initialise(v);
    return self );
  operation initialise( v : int) : void
  pre: true  post: true
  activity: (     V := v ; 
     adj := Integer.subrange(1,v)->collect(null) ; 
         var i : int ; i := 0 ; while i < v do (     adj[i+1] := Sequence{} ;  ;     i := i + 1 ) );
   operation addEdge( v : int, w : int) : void
  pre: true
  post: true
  activity: (     adj[v+1]->excludes(w) );
   operation DFSUtil( v : int, visited : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (     visited[v+1] := true ; 
     var i : OclIterator ; i := adj[v+1]->iterator() ;
     while (i.hasNext()) do (     var n : int ; n := i.next() ;
     if (not(visited[n+1])) then     execute DFSUtil(n, visited) ; else skip ; 
     if (f) then (     OclFile["System.out"].print(n + 1 + " ") ; 
     f := false ) else skip ) );
  static   attribute f : boolean := true;
   operation DFS() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < V do ( (     var visited : Sequence(boolean) ; visited := Integer.subrange(1,V)->collect(false) ;
     f := true ; 
     if (visited[i+1] = false) then     execute DFSUtil(i, visited) ; else skip )  ;     i := i + 1 ) );
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var graph : Graph ; graph := Graph.newGraph(n) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     graph.addEdge(i, arr[i+1] - 1) )  ;     i := i + 1 ) ; 
    graph.DFS() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class zer {
  static Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    int n=in.nextInt();
    int m=in.nextInt();
    int[] p=new int[n];
    List<Set<Integer>>tab=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      p[i]=in.nextInt();
      tab.add(new HashSet<>());
    }
    int ans=3000003 ;
    for(int i=0 ; i<m ; i++){
      int a=in.nextInt()-1 ;
      int b=in.nextInt()-1 ;
      for(int x : tab.get(a)){
        if(tab.get(b).contains(x)){
          ans=Math.min(p[a]+p[b]+p[x],ans);
        }
      }
      tab.get(a).add(b);
      tab.get(b).add(a);
    }
    if(ans==3000003)System.out.println(-1);
    else System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class zer {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    var tab : Sequence(Set(int)) ; tab := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := in.getCurrent()->toInteger() ; 
     tab := tab->including(Set{}) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 3000003 ;
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := in.getCurrent()->toInteger() - 1 ;
     var b : int ; b := in.getCurrent()->toInteger() - 1 ;
    for (x : tab->at(a+1)) do ( (     if (tab->at(b+1)->includes(x)) then (     ans := Set{p[a+1] + p[b+1] + p[x+1], ans}->min() ) else skip )  ) ; 
    tab->at(a+1)->excludes(b) ; 
    tab->at(b+1)->excludes(a) ; 
 )  ;     i := i + 1 ) ; 
    if (ans = 3000003) then     OclFile["System.out"].println(-1) else     OclFile["System.out"].println(ans) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  static FastReader sc=null ;
  public static void main(String[] args){
    sc=new FastReader();
    int n=sc.nextInt(),nax=105 ;
    int a[]=sc.readArray(n);
    int cnts[]=new int[nax];
    for(int e : a)cnts[e+1]++;
    int ans=0 ;
    int pre[]=new int[nax];
    for(int i=1 ; i<nax ; i++){
      pre[i]=pre[i-1]+cnts[i];
      int val=(int)Math.ceil(1.0*pre[i]/i);
      ans=Math.max(ans,val);
    }
    System.out.println(ans);
  }
  static int[] ruffleSort(int a[]){
    ArrayList<Integer>al=new ArrayList<>();
    for(int i : a)al.add(i);
    Collections.sort(al);
    for(int i=0 ; i<a.length ; i++)a[i]=al.get(i);
    return a ;
  }
  static void print(int a[]){
    for(int e : a){
      System.out.print(e+" ");
    }
    System.out.println();
  }
  static class FastReader {
    StringTokenizer st=new StringTokenizer("");
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String next(){
      while(! st.hasMoreTokens())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());
    }
    int[] readArray(int n){
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute sc : FastReader := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := FastReader.newFastReader() ; 
     var n : int ; n := sc.nextInt() ;
    var nax : int ; nax := 105 ;
    var a : Sequence(int) ; a := sc.readArray(n) ;
    var cnts : Sequence(int) ; cnts := Integer.subrange(1,nax)->collect(0) ;
    for (e : a) do (     cnts[e + 1+1] := cnts[e + 1+1] + 1 ;  ) ; 
    var ans : int ; ans := 0 ;
    var pre : Sequence(int) ; pre := Integer.subrange(1,nax)->collect(0) ;
        var i : int ; i := 1 ; while i < nax do ( (     pre[i+1] := pre[i - 1+1] + cnts[i+1] ; 
     var val : int ; val := (1.0 * pre[i+1] / i)->ceil()->oclAsType(int) ;
     ans := Set{ans, val}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation ruffleSort( a : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var al : Sequence(int) ; al := Sequence{} ;
     for (i : a) do (     al := al->including(i) ;  ) ; 
    al := al->sort() ; 
        var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := al->at(i+1) ;  ;     i := i + 1 ) ; 
    return a 
 );
  static   operation print( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     for (e : a) do ( (     OclFile["System.out"].print(e + " ") )  ) ; 
     OclFile["System.out"].println() );
  static class FastReader {
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_Clothes {
  static Scanner in=new Scanner(System.in);
  static int n,m ;
  static long a[];
  static long u[],v[];
  static void solve(){
    boolean dp[][]=new boolean[n+1][n+1];
    for(int i=0 ; i<m ; i++){
      dp[(int)u[i] ][(int)v[i] ]=true ;
      dp[(int)v[i] ][(int)u[i] ]=true ;
    }
    long ans=Integer.MAX_VALUE ;
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=n ; j++){
        for(int k=1 ; k<=n ; k++){
          if(i!=j && j!=k && k!=i && dp[i][j] && dp[j][k] && dp[k][i]){
            ans=Math.min(ans,a[i]+a[j]+a[k]);
          }
        }
      }
    }
    System.out.println((ans==Integer.MAX_VALUE ?-1 : ans));
  }
  public static void main(String[] amit){
    n=in.nextInt();
    m=in.nextInt();
    a=new long[n+1];
    for(int i=1 ; i<=n ; i++)a[i]=in.nextLong();
    u=new long[m];
    v=new long[m];
    for(int i=0 ; i<m ; i++){
      u[i]=in.nextInt();
      v[i]=in.nextInt();
    }
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Clothes {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   attribute a : Sequence(long);
  static   attribute u : long;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(boolean)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(false)) ;
         var i : int ; i := 0 ; while i < m do ( (     dp[u[i+1]->oclAsType(int)+1][v[i+1]->oclAsType(int)+1] := true ; 
     dp[v[i+1]->oclAsType(int)+1][u[i+1]->oclAsType(int)+1] := true )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 2147483647 ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (         var k : int ; k := 1 ; while k <= n do ( (     if (i /= j & j /= k & k /= i & dp[i+1][j+1] & dp[j+1][k+1] & dp[k+1][i+1]) then (     ans := Set{ans, a[i+1] + a[j+1] + a[k+1]}->min() ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((if ans = 2147483647 then -1 else ans endif)) ; 
 );
  static   operation main( amit : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := in.getCurrent()->toInteger() ; 
     m := in.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,n + 1)->collect(0) ; 
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := in.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    u := Integer.subrange(1,m)->collect(0) ; 
    v := Integer.subrange(1,m)->collect(0) ; 
        var i : int ; i := 0 ; while i < m do ( (     u[i+1] := in.getCurrent()->toInteger() ; 
     v[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute solve() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),s=in.nextInt();
    int sum=s ;
    for(int i=0 ; i<n ; i++){
      int f=in.nextInt(),t=in.nextInt();
      sum=Math.max(sum,f+t);
    }
    pw.println(sum);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var s : int ; s := in.getCurrent()->toInteger() ;
    var sum : int ; sum := s ;
        var i : int ; i := 0 ; while i < n do ( (     var f : int ; f := in.getCurrent()->toInteger() ;
    var t : int ; t := in.getCurrent()->toInteger() ;
     sum := Set{sum, f + t}->max() )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class DominoForYoung_609B {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    StringTokenizer st=new StringTokenizer(br.readLine());
    long w=0,b=0 ;
    for(int i=0 ; i<n ; i++){
      int val=Integer.parseInt(st.nextToken());
      if(i % 2==0){
        w+=val/2 ;
        b+=(val+1)/2 ;
      }
      else {
        b+=val/2 ;
        w+=(val+1)/2 ;
      }
    }
    System.out.println(Math.min(w,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class DominoForYoung_609B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var w : long ; w := 0 ;
    var b : long ; b := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var val : int ; val := (st.next())->toInteger() ;
     if (i mod 2 = 0) then (     w := w+(val / 2) ; 
     b := b+((val + 1) / 2) ) else (     b := b+(val / 2) ; 
     w := w+((val + 1) / 2) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{w, b}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class dfyoung {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer in=new StringTokenizer(br.readLine());
    PrintWriter out=new PrintWriter(System.out);
    int n=Integer.parseInt(in.nextToken());
    in=new StringTokenizer(br.readLine());
    long w=0,b=0 ;
    for(int i=0 ; i<n ; i++){
      long next=Integer.parseInt(in.nextToken());
      if(i % 2==0){
        w+=(next/2);
        b+=next-(next/2);
      }
      else {
        w+=next-(next/2);
        b+=(next/2);
      }
    }
    out.println(Math.min(w,b));
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class dfyoung {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var in : OclIterator ; in := OclIterator.newOclIterator_String(br.readLine()) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (in.next())->toInteger() ;
    in := OclIterator.newOclIterator_String(br.readLine()) ; 
    var w : long ; w := 0 ;
    var b : long ; b := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var next : long ; next := (in.next())->toInteger() ;
     if (i mod 2 = 0) then (     w := w+((next / 2)) ; 
     b := b+(next - (next / 2)) ) else (     w := w+(next - (next / 2)) ; 
     b := b+((next / 2)) ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main2 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 int mod=(int)(1e9+7);
  static FastReader sc=new FastReader();
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    int t=1 ;
    z : while(t-->0){
      int n=sc.nextInt();
      long ans[]=new long[2];
      long x=0 ;
      for(int i=0 ; i<n ; i++){
        x=sc.nextInt();
        ans[i % 2]+=x/2 ;
        x++;
        ans[(i+1)% 2]+=x/2 ;
      }
      out.write(Math.min(ans[0],ans[1])+"");
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main2 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   attribute mod : int := (1e9 + 7)->oclAsType(int);
  static   attribute sc : FastReader := FastReader.newFastReader();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.nextInt() ;
     var ans : Sequence(long) ; ans := Integer.subrange(1,2)->collect(0) ;
    var x : long ; x := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x := sc.nextInt() ; 
     ans[i mod 2+1] := ans[i mod 2+1]+(x / 2) ; 
     x := x + 1 ; 
     ans[(i + 1) mod 2+1] := ans[(i + 1) mod 2+1]+(x / 2) )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF67B extends PrintWriter {
  CF67B(){
    super(System.out,true);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    CF67B o=new CF67B();
    o.main();
    o.flush();
  }
  void main(){
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] bb=new int[n];
    for(int i=0 ; i<n ; i++)bb[i]=sc.nextInt();
    int[] aa=new int[n];
    int m=0 ;
    for(int a=n-1 ; a>=0 ; a--){
      int j=0 ;
      while(bb[a]>0){
        if(aa[j]>=a+k)bb[a]--;
        j++;
      }
      for(int j_=m++; j_>j ; j_--)aa[j_]=aa[j_-1];
      aa[j]=a ;
    }
    for(int i=0 ; i<n ; i++)print(aa[i]+1+" ");
    println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF67B extends OclFile {
   static operation newCF67B() : CF67B
  pre: true
  post: true
  activity:
  ( var self : CF67B ;
    self := createCF67B();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"], true) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : CF67B ; o := CF67B.newCF67B() ;
     o.main() ; 
     o.flush() );
   operation main() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var bb : Sequence(int) ; bb := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     bb[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var aa : Sequence(int) ; aa := Integer.subrange(1,n)->collect(0) ;
    var m : int ; m := 0 ;
        var a : int ; a := n - 1 ; while a >= 0 do ( (     var j : int ; j := 0 ;
     while (bb[a+1] > 0) do (     if (aa[j+1] >= a + k) then     bb[a+1] := bb[a+1] - 1 ; else skip ; 
     j := j + 1 ) ; 
         var j_ : int ; j_ := m ; while j_ > j do (     aa[j_+1] := aa[j_ - 1+1] ;  ;     j_ := j_ - 1 ) ; 
     aa[j+1] := a )  ;     a := a - 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     execute print(aa[i+1] + 1 + " ") ;  ;     i := i + 1 ) ; 
    execute println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.Collectors ;
public class B147 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int[] c=new int[n];
    int[][] table=new int[50][50];
    for(int i=0 ; i<n ; i++){
      c[i]=scanner.nextInt();
    }
    Map<Integer,Point>map=new HashMap<>();
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=c[i-1]; j++){
        int cell=scanner.nextInt();
        map.put(cell,new Point(i,j));
        table[i-1][j-1]=cell ;
      }
    }
    int cnt=0 ;
    int m=0 ;
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<c[i]; j++){
        cnt++;
        if(table[i][j]==cnt)continue ;
        sb.append(i+1).append(" ");
        sb.append(j+1).append(" ");
        Point point=map.get(cnt);
        sb.append(point.x).append(" ");
        sb.append(point.y).append("\n");
        int tmp=table[i][j];
        table[i][j]=table[point.x-1][point.y-1];
        table[point.x-1][point.y-1]=tmp ;
        map.put(tmp,point);
        m++;
      }
    }
    System.out.println(m);
    String s=sb.toString();
    if(m>0)System.out.println(s);
  }
}
class Point {
  int x ;
  int y ;
  public Point(int x,int y){
    this.x=x ;
    this.y=y ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B147 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    var table : Sequence(Sequence(int)) ; table := Integer.subrange(1,50)->collect(Integer.subrange(1,50)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var map : Map(int,Point) ; map := Map{} ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= c[i - 1+1] do ( (     var cell : int ; cell := scanner.getCurrent()->toInteger() ;
     map := map->union(Map{cell |-> Point.newPoint(i, j)}) ; 
     table[i - 1+1][j - 1+1] := cell )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    var m : int ; m := 0 ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < c[i+1] do ( (     cnt := cnt + 1 ; 
     if (table[i+1][j+1] = cnt) then     continue else skip ; 
    sb := sb + StringLib.newString(i + 1) + StringLib.newString(" ") ; 
    sb := sb + StringLib.newString(j + 1) + StringLib.newString(" ") ; 
    var point : Point ; point := map->at(cnt) ;
    sb := sb + StringLib.newString(point.x) + StringLib.newString(" ") ; 
    sb := sb + StringLib.newString(point.y) + StringLib.newString("\n") ; 
    var tmp : int ; tmp := table[i+1][j+1] ;
    table[i+1][j+1] := table[point.x - 1+1][point.y - 1+1] ; 
    table[point.x - 1+1][point.y - 1+1] := tmp ; 
    map := map->union(Map{tmp |-> point}) ; 
    m := m + 1 ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(m) ; 
    var s : String ; s := sb+"" ;
    if (m > 0) then     OclFile["System.out"].println(s) ; else skip ; 
 );
}
class Point {
   attribute x : int;
   attribute y : int;
   static operation newPoint( x : int, y : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
class Main {
  static Scanner sc=new Scanner();
  public static void main(final String[] args)throws IOException {
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[sc.nextInt()-1]=i+1 ;
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(a[i]+" ");
    }
  }
  static class Scanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),1<<15);
    StringTokenizer tokenizer ;
    String next()throws IOException {
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        tokenizer=new StringTokenizer(reader.readLine());
      }
      return tokenizer.nextToken();
    }
    int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := (arguments ( ));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[sc.getCurrent()->toInteger() - 1+1] := i + 1 )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(a[i+1] + " ") )  ;     i := i + 1 ) );
  static class Scanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (1*(2->pow(15)))->oclAsType(long));
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Collections ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] A=new int[N];
    int[] x=new int[N];
    ArrayList<Integer>list=new ArrayList<Integer>();
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
      list.add(A[i]);
      x[A[i]-1]=i+1 ;
    }
    Collections.sort(list);
    for(int i=0 ; i<N ; i++){
      System.out.print(x[list.get(i)-1]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var x : Sequence(int) ; x := Integer.subrange(1,N)->collect(0) ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() ; 
     list := list->including(A[i+1]) ; 
     x[A[i+1] - 1+1] := i + 1 )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
        var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].print(x[list->at(i+1) - 1+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
@ SuppressWarnings("unchecked")public class Main {
  public static class Pair implements Comparable<Pair>{
    public final int first ;
    public final int second ;
    public Pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
    @ Override public int compareTo(Pair o){
      int ord=Integer.compare(this.first,o.first);
      if(ord!=0)return ord ;
      ord=Integer.compare(this.second,o.second);
      return ord ;
    }
  }
  public static String joinInt(int[] a,String separator){
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<a.length ; i++){
      if(i>0){
        sb.append(separator);
      }
      sb.append(a[i]);
    }
    return sb.toString();
  }
  static int[] nextIntArray(Scanner sc,int N){
    int[] arr=new int[N];
    for(int i=0 ; i<N ; i++){
      arr[i]=sc.nextInt();
    }
    return arr ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    Pair[] P=new Pair[N];
    for(int i=0 ; i<N ; i++){
      int a=sc.nextInt();
      P[i]=new Pair(a,i+1);
    }
    Arrays.sort(P);
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<N ; i++){
      if(i>0){
        sb.append(" ");
      }
      sb.append(P[i] .second);
    }
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Pair implements Comparable<Map> {
   attribute first : int;
   attribute second : int;
   static operation newPair( first : int, second : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
      operation compareTo( o : Map) : int
  pre: true
  post: true
  activity: (     var ord : int ; ord := compare(self->at("first"), o->at("first")) ;
     if (ord /= 0) then     return ord else skip ; 
     ord := compare(self->at("second"), o->at("second")) ; 
     return ord );
}
  static   operation joinInt( a : Sequence(int), separator : String) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < a->size() do ( (     if (i > 0) then (     sb := sb + StringLib.newString(separator) ) else skip ; 
     sb := sb + StringLib.newString(a[i+1]) )  ;     i := i + 1 ) ; 
     return sb+"" );
  static   operation nextIntArray( sc : OclFile, N : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
         var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
     return arr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var P : Sequence(Map) ; P := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     P[i+1] := Map(a, i + 1) )  ;     i := i + 1 ) ; 
    P := P->sort() ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < N do ( (     if (i > 0) then (     sb := sb + StringLib.newString(" ") ) else skip ; 
     sb := sb + StringLib.newString(P[i+1]->at("second")) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    int q=in.nextInt();
    for(int i=0 ; i<q ; i++)new CGL_2B().doIt();
  }
  class CGL_2B {
    double segSegDist(Line2D l1,Line2D l2){
      return l1.intersectsLine(l2)? 0 : Math.min(Math.min(l1.ptSegDist(l2.getP1()),l1.ptSegDist(l2.getP2())),Math.min(l2.ptSegDist(l1.getP1()),l2.ptSegDist(l1.getP2())));
    }
    void doIt(){
      Line2D l1=new Line2D.Double(in.nextDouble(),in.nextDouble(),in.nextDouble(),in.nextDouble());
      ;
      Line2D l2=new Line2D.Double(in.nextDouble(),in.nextDouble(),in.nextDouble(),in.nextDouble());
      ;
      System.out.printf("%.10f\n",segSegDist(l1,l2));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var q : int ; q := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < q do (     CGL()B.newCGL()B().doIt() ;  ;     i := i + 1 ) );
 class CGL{
   operation segSegDist( l1 : Line2D, l2 : Line2D) : double
  pre: true
  post: true
  activity: (     return if l1.intersectsLine(l2) then 0 else Set{Set{l1.ptSegDist(l2.getP1()), l1.ptSegDist(l2.getP2())}->min(), Set{l2.ptSegDist(l1.getP1()), l2.ptSegDist(l1.getP2())}->min()}->min() endif );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var l1 : Line2D ; l1 := Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal()) ;
    var l2 : Line2D ; l2 := Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal()) ;
    OclFile["System.out"].printf("%.10f\n", segSegDist(l1, l2)) ; 
 );
}
B {
   operation segSegDist( l1 : Line2D, l2 : Line2D) : double
  pre: true
  post: true
  activity: (     return if l1.intersectsLine(l2) then 0 else Set{Set{l1.ptSegDist(l2.getP1()), l1.ptSegDist(l2.getP2())}->min(), Set{l2.ptSegDist(l1.getP1()), l2.ptSegDist(l1.getP2())}->min()}->min() endif );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var l1 : Line2D ; l1 := Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal()) ;
    var l2 : Line2D ; l2 := Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal()) ;
    OclFile["System.out"].printf("%.10f\n", segSegDist(l1, l2)) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      StringBuilder sb=new StringBuilder();
      if(n==1){
        System.out.println(3);
      }
      else {
        while(n>0){
          int ans=n & 1 ;
          n=n>>1 ;
          if(ans==1){
            sb.insert(0,1);
            break ;
          }
          else {
            sb.insert(0,0);
          }
        }
        if(n==0){
          sb.deleteCharAt(sb.length()-1);
          sb.append(1);
        }
        int val=Integer.parseInt(sb.toString(),2);
        System.out.println(val);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var sb : String ; sb := StringLib.newString() ;
     if (n = 1) then (     OclFile["System.out"].println(3) ) else (     while (n > 0) do (     var ans : int ; ans := MathLib.bitwiseAnd(n,1) ;
     n := (n/(2->pow(1)))->oclAsType(long) ; 
     if (ans = 1) then (     sb := sb.insertAt(0+1, StringLib.newString(1)) ; 
     break ) else (     sb := sb.insertAt(0+1, StringLib.newString(0)) ) ) ; 
     if (n = 0) then (     sb := sb->excludingAt(sb->size() - 1+1) ; 
     sb := sb + StringLib.newString(1) ) else skip ; 
     var val : int ; val := (sb+"")->toInteger() ;
     OclFile["System.out"].println(val) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  static boolean isPrime(int n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static int primeBitsInRange(int l,int r){
    int tot_bit,count=0 ;
    for(int i=l ; i<=r ; i++){
      tot_bit=Integer.bitCount(i);
      if(isPrime(tot_bit))count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int l=6,r=10 ;
    System.out.println(primeBitsInRange(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation primeBitsInRange( l : int, r : int) : int
  pre: true
  post: true
  activity: (     var tot_bit : int ;
    var count : int ; count := 0 ;
         var i : int ; i := l ; while i <= r do ( (     tot_bit := bitCount(i) ; 
     if (isPrime(tot_bit)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 6 ;
    var r : int ; r := 10 ;
     OclFile["System.out"].println(primeBitsInRange(l, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Random ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskT solver=new TaskT();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskT {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int num_students=in.nextInt();
      Map<Integer,Integer>map=new HashMap<>();
      int[] arr=new int[num_students];
      for(int i=0 ; i<num_students ; i++){
        int num_present=in.nextInt();
        arr[i]=num_present ;
        map.put(num_present,i+1);
      }
      Arrays.sort(arr);
      for(int i=0 ; i<arr.length ; i++)System.out.print(map.get(arr[i])+" ");
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskT ; solver := TaskT.newTaskT() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskT {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var num_students : int ; num_students := in.nextInt() ;
     var map : Map(int,int) ; map := Map{} ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,num_students)->collect(0) ;
        var i : int ; i := 0 ; while i < num_students do ( (     var num_present : int ; num_present := in.nextInt() ;
     arr[i+1] := num_present ; 
     map := map->union(Map{num_present |-> i + 1}) )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < arr->size() do (     OclFile["System.out"].print(map->at(arr[i+1]) + " ") ;  ;     i := i + 1 ) ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static List<Integer>P ;
  public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    Map<Integer,Integer>idorder=new HashMap<>();
    for(int i=1 ; i<=N ; i++){
      int A=scanner.nextInt();
      idorder.put(A,i);
    }
    for(int i=1 ; i<=N ; i++){
      System.out.print(idorder.get(i));
      System.out.print(" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute P : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var idorder : Map(int,int) ; idorder := Map{} ;
        var i : int ; i := 1 ; while i <= N do ( (     var A : int ; A := scanner.getCurrent()->toInteger() ;
     idorder := idorder->union(Map{A |-> i}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (     OclFile["System.out"].print(idorder->at(i)) ; 
     OclFile["System.out"].print(" ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int sameOccurrence(int arr[],int n,int x,int y){
    int result=0 ;
    for(int i=0 ; i<=n-1 ; i++){
      int ctX=0,ctY=0 ;
      for(int j=i ; j<=n-1 ; j++){
        if(arr[j]==x)ctX+=1 ;
        else if(arr[j]==y)ctY+=1 ;
        if(ctX==ctY)result+=1 ;
      }
    }
    return(result);
  }
  public static void main(String args[]){
    int arr[]={
      1,2,2,3,4,1 };
      int n=arr.length ;
      int x=2,y=3 ;
      System.out.println(sameOccurrence(arr,n,x,y));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation sameOccurrence( arr : Sequence(int), n : int, x : int, y : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i <= n - 1 do ( (     var ctX : int ; ctX := 0 ;
    var ctY : int ; ctY := 0 ;
         var j : int ; j := i ; while j <= n - 1 do ( (     if (arr[j+1] = x) then     ctX := ctX+(1) else     if (arr[j+1] = y) then     ctY := ctY+(1) ; else skip ; ;  
     if (ctX = ctY) then     result := result+(1) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return (result) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,2,3,4,1} ;
     var n : int ; n := arr->size() ;
     var x : int ; x := 2 ;
    var y : int ; y := 3 ;
     OclFile["System.out"].println(sameOccurrence(arr, n, x, y)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test251 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      char[] a=in.next().toCharArray();
      if(a.length>=3){
        int z=0,o=0 ;
        for(int j=0 ; j<a.length ; j++){
          if(a[j]=='1'){
            o++;
          }
          else {
            z++;
          }
        }
        if(z>o){
          System.out.println(o);
        }
        else if(o>z){
          System.out.println(z);
        }
        else {
          System.out.println(z-1);
        }
      }
      else {
        System.out.println(0);
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test251 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : Sequence(String) ; a := in.getCurrent()->characters() ;
     if (a->size() >= 3) then (     var z : int ; z := 0 ;
    var o : int ; o := 0 ;
         var j : int ; j := 0 ; while j < a->size() do ( (     if (a[j+1] = '1') then (     o := o + 1 ) else (     z := z + 1 ) )  ;     j := j + 1 ) ; 
     if (z > o) then (     OclFile["System.out"].println(o) ) else     if (o > z) then (     OclFile["System.out"].println(z) ) else (     OclFile["System.out"].println(z - 1) ) ;  ) else (     OclFile["System.out"].println(0) ) )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class TaskF {
  static final int SIZE=(int)(1E5)+5 ;
  static String s ;
  public static void solve(InputReader in,PrintWriter out){
    s=in.next();
    int len=s.length();
    int zero=0 ;
    int one=0 ;
    for(int i=0 ; i<len ; ++i){
      if(s.charAt(i)=='0')zero++;
      else one++;
    }
    int res=0 ;
    if(one==zero){
      if(one!=1)res=one-1 ;
    }
    else {
      res=Math.min(one,zero);
    }
    out.println(res);
  }
  static void clear(int n){
  }
  static void init(){
  }
  private static class InputReader {
    private BufferedReader reader ;
    private StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=reader.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    init();
    InputReader in=new InputReader(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int T=1 ;
    T=in.nextInt();
    for(int i=1 ; i<=T ; ++i){
      solve(in,out);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class TaskF {
  static    attribute SIZE : int := (1E5)->oclAsType(int) + 5;
  static   attribute s : String;
  static   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     s := in.next() ; 
     var len : int ; len := s->size() ;
    var zero : int ; zero := 0 ;
    var one : int ; one := 0 ;
        var i : int ; i := 0 ; while i < len do ( (     if (s->at(i+1) = '0') then     zero := zero + 1 ; else     one := one + 1 ; )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    if (one = zero) then (     if (one /= 1) then     res := one - 1 ; else skip ) else (     res := Set{one, zero}->min() ) ;  
    out.println(res) ; 
 );
  static   operation clear( n : int) : void
  pre: true
  post: true
  activity: skip;
  static   operation init() : void
  pre: true
  post: true
  activity: skip;
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := reader.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute init() ; 
     var in : InputReader ; in := InputReader.newInputReader(OclFile["System.in"]) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := 1 ;
    T := in.nextInt() ; 
        var i : int ; i := 1 ; while i <= T do ( (     execute solve(in, out) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter o=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int one=0 ;
      int zero=0 ;
      String s=sc.next();
      for(int i=0 ; i<s.length(); i++){
        char c=s.charAt(i);
        if(c=='0'){
          zero++;
        }
        else {
          one++;
        }
      }
      if(zero!=one){
        o.println(Math.min(one,zero));
      }
      else {
        o.println(Math.min(one,zero)-1);
      }
    }
    o.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var o : OclFile ; o := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var one : int ; one := 0 ;
     var zero : int ; zero := 0 ;
    var s : String ; s := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var c : String ; c := s->at(i+1) ;
     if (c = '0') then (     zero := zero + 1 ) else (     one := one + 1 ) )  ;     i := i + 1 ) ; 
    if (zero /= one) then (     skip ) else (     skip ) ;  
 ) ;  ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static int n ;
  static int a[];
  static String solve(){
    int mx=0 ;
    for(int i=0 ; i<n ; i++)mx=Math.max(a[i],mx);
    Map<Integer,Integer>cnt=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      cnt.put(a[i],cnt.getOrDefault(a[i],0)+1);
    }
    if(cnt.get(mx)% 2!=0)return "Conan\n" ;
    else if(cnt.get(mx)==n)return "Agasa\n" ;
    else {
      for(Map.Entry<Integer,Integer>me : cnt.entrySet()){
        if(me.getValue()% 2!=0)return "Conan\n" ;
      }
      return "Agasa\n" ;
    }
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    String s[]=bf.readLine().trim().split("\\s+");
    n=Integer.parseInt(s[0]);
    a=new int[n];
    s=bf.readLine().trim().split("\\s+");
    for(int i=0 ; i<n ; i++)a[i]=Integer.parseInt(s[i]);
    str.append(solve()).append("\n");
    pw.print(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute n : int;
  static   attribute a : Sequence(int);
  static   operation solve() : String
  pre: true
  post: true
  activity: (     var mx : int ; mx := 0 ;
         var i : int ; i := 0 ; while i < n do (     mx := Set{a[i+1], mx}->max() ;  ;     i := i + 1 ) ; 
    var cnt : Map(int,int) ; cnt := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     cnt := cnt->union(Map{a[i+1] |-> (if cnt->keys()->contains(a[i+1]) then cnt->at(a[i+1]) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    if (cnt->at(mx) mod 2 /= 0) then     return "Conan\n" else     if (cnt->at(mx) = n) then     return "Agasa\n" else (     for (me : cnt->asSet()) do ( (     if (me.getValue() mod 2 /= 0) then     return "Conan\n" else skip )  ) ; 
     return "Agasa\n" ) ;  ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var s : Sequence(String) ; s := bf.readLine()->trim()->split("\\s+") ;
    n := (s[0+1])->toInteger() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
    s := bf.readLine()->trim()->split("\\s+") ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (s[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    str := str + StringLib.newString(solve()) + StringLib.newString("\n") ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Run {
  public static void main(String[] Z)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder op=new StringBuilder();
    StringTokenizer stz ;
    int n=Integer.parseInt(br.readLine());
    stz=new StringTokenizer(br.readLine());
    HashMap<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int num=Integer.parseInt(stz.nextToken());
      map.put(num,map.getOrDefault(num,0)+1);
    }
    boolean allFreqEven=true ;
    for(Map.Entry<Integer,Integer>entry : map.entrySet()){
      if(entry.getValue()% 2==1){
        allFreqEven=false ;
        break ;
      }
    }
    if(allFreqEven){
      System.out.println("Agasa");
    }
    else System.out.println("Conan");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Run {
  static   operation main( Z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var op : String ; op := StringLib.newString() ;
    var stz : OclIterator ;
    var n : int ; n := (br.readLine())->toInteger() ;
    stz := OclIterator.newOclIterator_String(br.readLine()) ; 
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := (stz.next())->toInteger() ;
     map := map->union(Map{num |-> (if map->keys()->contains(num) then map->at(num) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var allFreqEven : boolean ; allFreqEven := true ;
    for (entry : map->asSet()) do ( (     if (entry.getValue() mod 2 = 1) then (     allFreqEven := false ; 
     break ) else skip )  ) ; 
    if (allFreqEven) then (     OclFile["System.out"].println("Agasa") ) else     OclFile["System.out"].println("Conan") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ConanAndAgasaPlayACardGame {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=in.nextInt();
    int max=-1 ;
    for(int i=0 ; i<n ; i++)if(a[i]>max)max=a[i];
    int cntMax=0 ;
    for(int i : a)if(max==i)cntMax++;
    if(cntMax % 2!=0){
      pw.println("Conan");
      pw.close();
      return ;
    }
    HashMap<Integer,Integer>m=new HashMap<>();
    for(int i : a)m.put(i,m.getOrDefault(i,0)+1);
    boolean allEv=true ;
    for(int i : m.values()){
      if(i % 2!=0){
        allEv=false ;
        break ;
      }
    }
    if(allEv)pw.println("Agasa");
    else pw.println("Conan");
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class ConanAndAgasaPlayACardGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var max : int ; max := -1 ;
        var i : int ; i := 0 ; while i < n do (     if (a[i+1] > max) then     max := a[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    var cntMax : int ; cntMax := 0 ;
    for (i : a) do (     if (max = i) then     cntMax := cntMax + 1 ; else skip ;  ) ; 
    if (cntMax mod 2 /= 0) then (     skip ; 
     skip ; 
     return ) else skip ; 
    var m : Map(int,int) ; m := Map{} ;
    for (i : a) do (     m := m->union(Map{i |-> (if m->keys()->contains(i) then m->at(i) else 0 endif) + 1}) ;  ) ; 
    var allEv : boolean ; allEv := true ;
    for (i : m->values()) do ( (     if (i mod 2 /= 0) then (     allEv := false ; 
     break ) else skip )  ) ; 
    if (allEv) then     skip else     skip ; ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static void main(String[] args){
    int a[]={
      1,2,3,4,5 };
      int i ;
      for(i=0 ; i<5 ; i++)System.out.printf("%d ",a[i]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,4,5} ;
     var i : int ;
         i := 0 ; while i < 5 do (     OclFile["System.out"].printf("%d ", a[i+1]) ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSetBits(int n){
    int count=0 ;
    while(n>0){
      n &=(n-1);
      count++;
    }
    return count ;
  }
  static int pairs(int arr[],int n,int k){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        int sum=countSetBits(arr[i])+countSetBits(arr[j]);
        if(sum==k)count++;
      }
    }
    return count ;
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3,4,5 };
      int n=arr.length ;
      int k=4 ;
      System.out.println(pairs(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     n := MathLib.bitwiseAnd(n, (n - 1)) ; 
     count := count + 1 ) ; 
     return count );
  static   operation pairs( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var sum : int ; sum := countSetBits(arr[i+1]) + countSetBits(arr[j+1]) ;
     if (sum = k) then     count := count + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 4 ;
     OclFile["System.out"].println(pairs(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Bitmask {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int x=sc.nextInt();
      int y=x &(-x);
      while(x==y ||(x & y)==0){
        y+=1 ;
      }
      System.out.println(y);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Bitmask {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := MathLib.bitwiseAnd(x,(-x)) ;
     while (x = y or (MathLib.bitwiseAnd(x,y)) = 0) do (     y := y+(1) ) ; 
     OclFile["System.out"].println(y) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void main(String[] args){
    int target=93 ;
    int[] arr={
      1,31,3,1,93,3,31,1,93 };
      int length=arr.length ;
      int totalCount=0 ;
      for(int i=0 ; i<length-2 ; i++){
        if(target % arr[i]==0){
          for(int j=i+1 ; j<length-1 ; j++){
            if(target %(arr[i]*arr[j])==0){
              int toFind=target/(arr[i]*arr[j]);
              for(int k=j+1 ; k<length ; k++){
                if(arr[k]==toFind){
                  totalCount++;
                }
              }
            }
          }
        }
      }
      System.out.println("Total number of triplets found : "+totalCount);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var target : int ; target := 93 ;
     var arr : Sequence(int) ; arr := Sequence{1,31,3,1,93,3,31,1,93} ;
    var length : int ; length := arr->size() ;
    var totalCount : int ; totalCount := 0 ;
        var i : int ; i := 0 ; while i < length - 2 do ( (     if (target mod arr[i+1] = 0) then (         var j : int ; j := i + 1 ; while j < length - 1 do ( (     if (target mod (arr[i+1] * arr[j+1]) = 0) then (     var toFind : int ; toFind := target / (arr[i+1] * arr[j+1]) ;
         var k : int ; k := j + 1 ; while k < length do ( (     if (arr[k+1] = toFind) then (     totalCount := totalCount + 1 ) else skip )  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Total number of triplets found : " + totalCount) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Multiples_Of_Length {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    FastReader t=new FastReader();
    PrintWriter o=new PrintWriter(System.out);
    int n=t.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; ++i)a[i]=t.nextLong();
    if(n==1){
      o.println("1 1");
      o.println(-a[0]);
      o.println("1 1");
      o.println("0");
      o.println("1 1");
      o.println("0");
    }
    else {
      o.println("1 1");
      o.println(-a[0]);
      o.println("1 "+n);
      a[0]=0 ;
      for(int i=0 ; i<n ; ++i)o.print(-n*a[i]+" ");
      o.println("\n2 "+n);
      for(int i=1 ; i<n ; ++i)o.print((n-1)*a[i]+" ");
    }
    o.flush();
    o.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Multiples_Of_Length {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : FastReader ; t := FastReader.newFastReader() ;
     var o : OclFile ; o := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := t.nextInt() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := t.nextLong() ;  ;     i := i + 1 ) ; 
    if (n = 1) then (     skip ; 
     skip ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 ) else (     skip ; 
     skip ; 
    skip ; 
    a[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do (     skip ;  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 1 ; while i < n do (     skip ;  ;     i := i + 1 ) ; 
 ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Rating {
  public static Scanner in=new Scanner(System.in);
  static public void main(String args[]){
    int n=in.nextInt();
    long a[]=new long[n+7];
    for(int i=1 ; i<=n ; ++i)a[i]=in.nextLong();
    if(n==1)System.out.println("1 1\n0\n1 1\n0\n1 1\n"+-a[1]);
    else {
      System.out.println("1 "+n);
      for(int i=1 ; i<=n ; ++i){
        System.out.print(-a[i]*n+" ");
        a[i]=(1-n)*a[i];
      }
      System.out.println("");
      System.out.println("2 "+n);
      for(int i=2 ; i<=n ; ++i){
        System.out.print(-a[i]+" ");
      }
      System.out.println("");
      System.out.println("1 1\n"+-a[1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Rating {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n + 7)->collect(0) ;
         var i : int ; i := 1 ; while i <= n do (     a[i+1] := in.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
     if (n = 1) then     OclFile["System.out"].println("1 1\n0\n1 1\n0\n1 1\n" + -a[1+1]) ; else (     OclFile["System.out"].println("1 " + n) ; 
         var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].print(-a[i+1] * n + " ") ; 
     a[i+1] := (1 - n) * a[i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
    OclFile["System.out"].println("2 " + n) ; 
        var i : int ; i := 2 ; while i <= n do ( (     OclFile["System.out"].print(-a[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
    OclFile["System.out"].println("1 1\n" + -a[1+1]) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int finalNum(int arr[],int n){
    int result=0 ;
    for(int i=0 ; i<n ; i++){
      result=__gcd(result,arr[i]);
    }
    return result ;
  }
  static int __gcd(int a,int b){
    return b==0 ? a : __gcd(b,a % b);
  }
  public static void main(String[] args){
    int arr[]={
      3,9,6,36 };
      int n=arr.length ;
      System.out.print(finalNum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation finalNum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     result := __gcd(result, arr[i+1]) )  ;     i := i + 1 ) ; 
     return result );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else __gcd(b, a mod b) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,9,6,36} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(finalNum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int N=1000 ;
  static int lastElement(int a[],int n){
    int steps=1 ;
    Vector<Integer>[] v=new Vector[N];
    for(int i=0 ; i<N ; i++)v[i]=new Vector<Integer>();
    if(n==1)return a[0];
    for(int i=0 ; i<n ; i+=2)v[steps] .add(a[i] | a[i+1]);
    while(v[steps] .size()>1){
      steps+=1 ;
      for(int i=0 ; i<v[steps-1] .size(); i+=2){
        if(steps % 2==1)v[steps] .add(v[steps-1] .get(i)| v[steps-1] .get(i+1));
        else v[steps] .add(v[steps-1] .get(i)^ v[steps-1] .get(i+1));
      }
    }
    return v[steps] .get(0);
  }
  public static void main(String[] args){
    int a[]={
      1,4,5,6 };
      int n=a.length ;
      int index=0 ;
      int value=2 ;
      a[0]=2 ;
      System.out.println(lastElement(a,n));
      index=3 ;
      value=5 ;
      a[index]=value ;
      System.out.println(lastElement(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 1000;
  static   operation lastElement( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var steps : int ; steps := 1 ;
     var v : Sequence(Sequence(int)) ; v := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do (     v[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
    if (n = 1) then     return a[0+1] else skip ; 
        var i : int ; i := 0 ; while i < n do (     v[steps+1]->excludes(a[i+1] or a[i + 1+1]) ;  ;     i := i+(2) ) ; 
    while (v[steps+1]->size() > 1) do (     steps := steps+(1) ; 
         var i : int ; i := 0 ; while i < v[steps - 1+1]->size() do ( (     if (steps mod 2 = 1) then     v[steps+1]->excludes(v[steps - 1+1]->at(i+1) or v[steps - 1+1]->at(i + 1+1)) ; else     v[steps+1]->excludes(v[steps - 1+1]->at(i+1) xor v[steps - 1+1]->at(i + 1+1)) ; )  ;     i := i+(2) ) ) ; 
    return v[steps+1]->at(0+1) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,4,5,6} ;
     var n : int ; n := a->size() ;
    var index : int ; index := 0 ;
    var value : int ; value := 2 ;
    a[0+1] := 2 ; 
    OclFile["System.out"].println(lastElement(a, n)) ; 
    index := 3 ; 
    value := 5 ; 
    a[index+1] := value ; 
    OclFile["System.out"].println(lastElement(a, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int number_cake(int n){
    return(n*n*n+5*n+6)/6 ;
  }
  public static void main(String[] args){
    int n=2 ;
    System.out.println(number_cake(n));
    n=8 ;
    System.out.println(number_cake(n));
    n=25 ;
    System.out.println(number_cake(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation number_cake( n : int) : int
  pre: true
  post: true
  activity: (     return (n * n * n + 5 * n + 6) / 6 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(number_cake(n)) ; 
    n := 8 ; 
    OclFile["System.out"].println(number_cake(n)) ; 
    n := 25 ; 
    OclFile["System.out"].println(number_cake(n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner s=new Scanner(System.in);
  public static void main(String __[]){
    int n=s.nextInt(),x=s.nextInt(),ar[]=new int[n],init[]=new int[n];
    for(int i=0 ; i<n ; i++){
      ar[i]=s.nextInt();
      init[i]=ar[i];
    }
    ar[0]=Math.min(ar[0],x);
    for(int i=1 ; i<n ; i++){
      ar[i]=Math.min(ar[i],x-ar[i-1]);
    }
    long res=0 ;
    for(int i=0 ; i<n ; i++)res+=init[i]-ar[i];
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( __ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s.getCurrent()->toInteger() ;
    var x : int ; x := s.getCurrent()->toInteger() ;
    var ar : Sequence(void) ; ar := Integer.subrange(1,n)->collect(0) ;
    var init : Sequence(void) ; init := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := s.getCurrent()->toInteger() ; 
     init[i+1] := ar[i+1] )  ;     i := i + 1 ) ; 
    ar[0+1] := Set{ar[0+1], x}->min() ; 
        var i : int ; i := 1 ; while i < n do ( (     ar[i+1] := Set{ar[i+1], x - ar[i - 1+1]}->min() )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < n do (     res := res+(init[i+1] - ar[i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private void solve()throws IOException {
    int n=nextInt();
    int x=nextInt();
    int a[]=new int[n+1];
    for(int i=1 ; i<=n ; i++)a[i]=nextInt();
    long ans=Math.max(0,a[1]-x);
    a[1]-=Math.max(0,a[1]-x);
    for(int i=2 ; i<=n ; i++){
      int curr=Math.max(0,a[i]+a[i-1]-x);
      a[i]-=curr ;
      ans+=curr ;
    }
    out.println(ans);
  }
  public void run()throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    st=null ;
    out=new PrintWriter(System.out);
    solve();
    br.close();
    out.close();
  }
  public static void main(String args[])throws IOException {
    new Main().run();
  }
  BufferedReader br ;
  StringTokenizer st ;
  PrintWriter out ;
  String nextToken()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  String nextLine()throws IOException {
    return br.readLine();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var x : int ; x := nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := Set{0, a[1+1] - x}->max() ;
    a[1+1] := a[1+1]-(Set{0, a[1+1] - x}->max()) ; 
        var i : int ; i := 2 ; while i <= n do ( (     var curr : int ; curr := Set{0, a[i+1] + a[i - 1+1] - x}->max() ;
     a[i+1] := a[i+1]-(curr) ; 
     ans := ans+(curr) )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := null ; 
    out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    br.close() ; 
    out.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute br : OclFile;
   attribute st : OclIterator;
   attribute out : OclFile;
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.*;
import static java.lang.Double.*;
import static java.lang.Long.*;
import static java.lang.System.*;
import static java.lang.Math.*;
import java.io.PrintWriter ;
public class Main {
  public static long MAX=(long)2e12 ;
  public static void main(String[] args){
    int i,j ;
    Scanner sc=new Scanner(in);
    int n=parseInt(sc.next());
    long x=parseLong(sc.next());
    long[] a=new long[n];
    for(i=0 ; i<n ; i++){
      a[i]=parseLong(sc.next());
    }
    sc.close();
    long[] b=new long[n];
    for(i=0 ; i<n-1 ; i++){
      b[i]=a[i]+a[i+1];
    }
    long cnt=0 ;
    for(i=0 ; i<n-1 ; i++){
      long tmp=Math.max(b[i]-x,0);
      cnt+=tmp ;
      if(i==n-2)break ;
      b[i+1]-=Math.min(a[i+1],tmp);
    }
    out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MAX : long := 2e12->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
    var n : int ; n := parseInt(sc.getCurrent()) ;
    var x : long ; x := parseLong(sc.getCurrent()) ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do ( (     a[i+1] := parseLong(sc.getCurrent()) )  ;     i := i + 1 ) ; 
    skip ; 
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n - 1 do ( (     b[i+1] := a[i+1] + a[i + 1+1] )  ;     i := i + 1 ) ; 
    var cnt : long ; cnt := 0 ;
        i := 0 ; while i < n - 1 do ( (     var tmp : long ; tmp := Set{b[i+1] - x, 0}->max() ;
     cnt := cnt+(tmp) ; 
     if (i = n - 2) then     break else skip ; 
     b[i + 1+1] := b[i + 1+1]-(Set{a[i + 1+1], tmp}->min()) )  ;     i := i + 1 ) ; 
    out.println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DkdlpdDffff {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    int capital=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)<97){
        capital++;
      }
    }
    if(capital>s.length()/2)System.out.println(s.toUpperCase());
    else System.out.println(s.toLowerCase());
  }
}
------------------------------------------------------------
OCL File:
---------
 class DkdlpdDffff {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
    var capital : int ; capital := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) < 97) then (     capital := capital + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (capital > s->size() / 2) then     OclFile["System.out"].println(s->toUpperCase()) else     OclFile["System.out"].println(s->toLowerCase()) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Queue ;
import java.util.Stack ;
public class Reverse_k_element_queue {
  static Queue<Integer>queue ;
  static void reverseQueueFirstKElements(int k){
    if(queue.isEmpty()==true || k>queue.size())return ;
    if(k<=0)return ;
    Stack<Integer>stack=new Stack<Integer>();
    for(int i=0 ; i<k ; i++){
      stack.push(queue.peek());
      queue.remove();
    }
    while(! stack.empty()){
      queue.add(stack.peek());
      stack.pop();
    }
    for(int i=0 ; i<queue.size()-k ; i++){
      queue.add(queue.peek());
      queue.remove();
    }
  }
  static void Print(){
    while(! queue.isEmpty()){
      System.out.print(queue.peek()+" ");
      queue.remove();
    }
  }
  public static void main(String args[]){
    queue=new LinkedList<Integer>();
    queue.add(10);
    queue.add(20);
    queue.add(30);
    queue.add(40);
    queue.add(50);
    queue.add(60);
    queue.add(70);
    queue.add(80);
    queue.add(90);
    queue.add(100);
    int k=5 ;
    reverseQueueFirstKElements(k);
    Print();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Reverse_k_element_queue {
  static   attribute queue : Sequence(int);
  static   operation reverseQueueFirstKElements( k : int) : void
  pre: true
  post: true
  activity: (     if (queue->isEmpty() = true or k > queue->size()) then     return else skip ; 
     if (k <= 0) then     return else skip ; 
    var stack : Sequence(int) ; stack := Sequence{} ;
        var i : int ; i := 0 ; while i < k do ( (     stack := stack->append(queue->min()) ; 
     queue := queue.remove() )  ;     i := i + 1 ) ; 
    while (not(stack->isEmpty())) do (     queue := queue->including(stack->min()) ; 
     stack := stack->front() ) ; 
        var i : int ; i := 0 ; while i < queue->size() - k do ( (     queue := queue->including(queue->min()) ; 
     queue := queue.remove() )  ;     i := i + 1 ) ; 
 );
  static   operation Print() : void
  pre: true
  post: true
  activity: (     while (not(queue->isEmpty())) do (     OclFile["System.out"].print(queue->min() + " ") ; 
     queue := queue.remove() ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     queue := Sequence{} ; 
     queue := queue->including(10) ; 
    queue := queue->including(20) ; 
    queue := queue->including(30) ; 
    queue := queue->including(40) ; 
    queue := queue->including(50) ; 
    queue := queue->including(60) ; 
    queue := queue->including(70) ; 
    queue := queue->including(80) ; 
    queue := queue->including(90) ; 
    queue := queue->including(100) ; 
    var k : int ; k := 5 ;
    execute reverseQueueFirstKElements(k) ; 
    execute Print() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int numBoxes=sc.nextInt();
    int numLimit=sc.nextInt();
    int[] candyArray=new int[numBoxes];
    for(int i=0 ; i<numBoxes ; i++){
      candyArray[i]=sc.nextInt();
    }
    long totalAteCandies=0 ;
    for(int i=1 ; i<numBoxes ; i++){
      int numExcessCandies=calculateExcessCandies(numLimit,candyArray[i-1],candyArray[i]);
      totalAteCandies+=numExcessCandies ;
      eatCandies(candyArray,i,numExcessCandies);
    }
    System.out.println(totalAteCandies);
  }
  public static int calculateExcessCandies(int limit,int candy1,int candy2){
    int numCandies=candy1+candy2-limit ;
    if(numCandies<0){
      return 0 ;
    }
    else {
      return numCandies ;
    }
  }
  public static void eatCandies(int[] array,int index,int numExcessCandies){
    array[index]-=numExcessCandies ;
    if(array[index]<0){
      array[index-1]+=array[index];
      array[index]=0 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numBoxes : int ; numBoxes := sc.getCurrent()->toInteger() ;
    var numLimit : int ; numLimit := sc.getCurrent()->toInteger() ;
    var candyArray : Sequence(int) ; candyArray := Integer.subrange(1,numBoxes)->collect(0) ;
        var i : int ; i := 0 ; while i < numBoxes do ( (     candyArray[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var totalAteCandies : long ; totalAteCandies := 0 ;
        var i : int ; i := 1 ; while i < numBoxes do ( (     var numExcessCandies : int ; numExcessCandies := calculateExcessCandies(numLimit, candyArray[i - 1+1], candyArray[i+1]) ;
     totalAteCandies := totalAteCandies+(numExcessCandies) ; 
     execute eatCandies(candyArray, i, numExcessCandies) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(totalAteCandies) ; 
 );
  static   operation calculateExcessCandies( limit : int, candy1 : int, candy2 : int) : int
  pre: true
  post: true
  activity: (     var numCandies : int ; numCandies := candy1 + candy2 - limit ;
     if (numCandies < 0) then (     return 0 ) else (     return numCandies ) );
  static   operation eatCandies( array : Sequence(int), index : int, numExcessCandies : int) : void
  pre: true
  post: true
  activity: (     array[index+1] := array[index+1]-(numExcessCandies) ; 
     if (array[index+1] < 0) then (     array[index - 1+1] := array[index - 1+1]+(array[index+1]) ; 
     array[index+1] := 0 ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  static FastReader sc=null ;
  public static void main(String[] args){
    sc=new FastReader();
    int t=sc.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      int x=sc.nextInt();
      if(x==1){
        System.out.println(3);
        continue ;
      }
      int ans=0 ;
      for(int i=0 ; i<=31 ; i++){
        int val=(1<<i);
        if((val & x)>0){
          ans=val ;
          break ;
        }
      }
      if(ans==x)ans++;
      System.out.println(ans);
    }
  }
  static int[] ruffleSort(int a[]){
    ArrayList<Integer>al=new ArrayList<>();
    for(int i : a)al.add(i);
    Collections.sort(al);
    for(int i=0 ; i<a.length ; i++)a[i]=al.get(i);
    return a ;
  }
  static void print(int a[]){
    for(int e : a){
      System.out.print(e+" ");
    }
    System.out.println();
  }
  static class FastReader {
    StringTokenizer st=new StringTokenizer("");
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String next(){
      while(! st.hasMoreTokens())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());
    }
    int[] readArray(int n){
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute sc : FastReader := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := FastReader.newFastReader() ; 
     var t : int ; t := sc.nextInt() ;
         var tt : int ; tt := 0 ; while tt < t do ( (     var x : int ; x := sc.nextInt() ;
     if (x = 1) then (     OclFile["System.out"].println(3) ; 
     continue ) else skip ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i <= 31 do ( (     var val : int ; val := ((1*(2->pow(i)))->oclAsType(long)) ;
     if ((MathLib.bitwiseAnd(val,x)) > 0) then (     ans := val ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (ans = x) then     ans := ans + 1 ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     tt := tt + 1 ) );
  static   operation ruffleSort( a : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var al : Sequence(int) ; al := Sequence{} ;
     for (i : a) do (     al := al->including(i) ;  ) ; 
    al := al->sort() ; 
        var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := al->at(i+1) ;  ;     i := i + 1 ) ; 
    return a 
 );
  static   operation print( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     for (e : a) do ( (     OclFile["System.out"].print(e + " ") )  ) ; 
     OclFile["System.out"].println() );
  static class FastReader {
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CBoxesAndCandies solver=new CBoxesAndCandies();
    solver.solve(1,in,out);
    out.close();
  }
  static class CBoxesAndCandies {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt(),x=in.nextInt();
      long sum=0 ;
      int prev=0 ;
      long ans=0 ;
      for(int i=0 ; i<n ; i++){
        int a=in.nextInt();
        sum+=a ;
        if(sum>x){
          a-=sum-x ;
          ans+=sum-x ;
          sum=x ;
        }
        else {
        }
        sum-=prev ;
        prev=a ;
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CBoxesAndCandies ; solver := CBoxesAndCandies.newCBoxesAndCandies() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CBoxesAndCandies {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
     var sum : long ; sum := 0 ;
    var prev : int ; prev := 0 ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     sum := sum+(a) ; 
    if (sum > x) then (     a := a-(sum - x) ; 
     ans := ans+(sum - x) ; 
     sum := x ) else skip ;  
    sum := sum-(prev) ; 
    prev := a ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] input=sc.next().toCharArray();
    int result=0 ;
    int p=0 ;
    int g=1 ;
    for(int i=1 ; i<input.length ; i++){
      if(input[i]=='g'){
        if(p+1<=g){
          result++;
          p++;
        }
        else {
          g++;
        }
      }
      else {
        if(p+1<=g){
          p++;
        }
        else {
          g++;
          result--;
        }
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : Sequence(String) ; input := sc.getCurrent()->characters() ;
    var result : int ; result := 0 ;
    var p : int ; p := 0 ;
    var g : int ; g := 1 ;
        var i : int ; i := 1 ; while i < input->size() do ( (     if (input[i+1] = 'g') then (     if (p + 1 <= g) then (     result := result + 1 ; 
     p := p + 1 ) else (     g := g + 1 ) ) else (     if (p + 1 <= g) then (     p := p + 1 ) else (     g := g + 1 ; 
     result := result - 1 ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskD solver=new TaskD();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskD {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      String S=in.next();
      int score=0 ;
      for(int i=0 ; i<S.length(); i++){
        char my=i % 2==0 ? 'g' : 'p' ;
        char his=S.charAt(i);
        if(my!=his){
          score+=my=='p' ? 1 :-1 ;
        }
      }
      out.println(score);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskD ; solver := TaskD.newTaskD() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskD {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var S : String ; S := in.next() ;
     var score : int ; score := 0 ;
         var i : int ; i := 0 ; while i < S->size() do ( (     var my : String ; my := if i mod 2 = 0 then 'g' else 'p' endif ;
     var his : String ; his := S->at(i+1) ;
     if (my /= his) then (     score := score+(if my = 'p' then 1 else -1 endif) ) else skip )  ;     i := i + 1 ) ; 
     skip );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.Closeable ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.math.BigDecimal ;
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.Map.Entry ;
import java.util.PriorityQueue ;
import java.util.StringTokenizer ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args)throws IOException {
    final Scanner sc=new Scanner(System.in);
    final char[] chs=sc.next().toCharArray();
    long answer=0 ;
    int rest_p=0,rest_g=0 ;
    for(final char ch : chs){
      if(ch=='g'){
        rest_g++;
      }
      else if(ch=='p'){
        rest_p++;
      }
    }
    final int plus=rest_g/2 ;
    final int minus=rest_p/2 ;
    final int g_mod=rest_g % 2 ;
    final int p_mod=rest_p % 2 ;
    System.out.println((plus-minus)+Math.min(0,g_mod-p_mod));
  }
  public static class Scanner implements Closeable {
    private BufferedReader br ;
    private StringTokenizer tok ;
    public Scanner(InputStream is)throws IOException {
      br=new BufferedReader(new InputStreamReader(is));
    }
    private void getLine()throws IOException {
      while(! hasNext()){
        tok=new StringTokenizer(br.readLine());
      }
    }
    private boolean hasNext(){
      return tok!=null && tok.hasMoreTokens();
    }
    public String next()throws IOException {
      getLine();
      return tok.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public void close()throws IOException {
      br.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var chs : Sequence(String) ; chs := sc.getCurrent()->characters() ;
    var answer : long ; answer := 0 ;
    var rest_p : int ; rest_p := 0 ;
    var rest_g : int ; rest_g := 0 ;
    for (ch : chs) do ( (     if (ch = 'g') then (     rest_g := rest_g + 1 ) else     if (ch = 'p') then (     rest_p := rest_p + 1 ) else skip ; )  ) ; 
    var plus : int ; plus := rest_g / 2 ;
    var minus : int ; minus := rest_p / 2 ;
    var g_mod : int ; g_mod := rest_g mod 2 ;
    var p_mod : int ; p_mod := rest_p mod 2 ;
    OclFile["System.out"].println((plus - minus) + Set{0, g_mod - p_mod}->min()) ; 
 );
  static class Scanner implements Closeable {
   attribute br : OclFile;
   attribute tok : OclIterator;
   static operation newScanner( is : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
   operation getLine() : void
  pre: true
  post: true
  activity: (     while (not(hasNext())) do (     tok := OclIterator.newOclIterator_String(br.readLine()) ) );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return tok /= null & tok.hasNext() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute getLine() ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner cin=new Scanner(System.in);
    while(cin.hasNext()){
      String s=cin.next();
      System.out.println(getNum(s));
    }
  }
  public static int getNum(String s){
    int count=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='p')count++;
    }
    return s.length()/2-count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (cin.hasNext()) do (     var s : String ; s := cin.getCurrent() ;
     OclFile["System.out"].println(getNum(s)) ) );
  static   operation getNum( s : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'p') then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return s->size() / 2 - (count)->char2byte() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in),1);
    String s=r.readLine();
    int n=s.length();
    int[][] a={
      {
        0,-1 },{
          1,0 }
        };
        int p=0 ;
        for(int i=0 ; i<n ; i++){
          p+=a[i % 2][s.charAt(i)=='g' ? 0 : 1];
        }
        System.out.println(p);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 1) ;
     var s : String ; s := r.readLine() ;
    var n : int ; n := s->size() ;
    var a : Sequence(Sequence(int)) ; a := Sequence{Sequence{0,-1},Sequence{1,0}} ;
    var p : int ; p := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     p := p+(a[i mod 2+1][if s->at(i+1) = 'g' then 0 else 1 endif+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(p) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static void pattern(int N){
    int i,j,k=0,space=1,rows=N ;
    for(i=rows ; i>=1 ; i--){
      for(j=1 ; j<=i ; j++){
        System.out.print("*");
      }
      if(i!=rows){
        for(k=1 ; k<=space ; k++){
          System.out.print(" ");
        }
        space=space+2 ;
      }
      for(j=i ; j>=1 ; j--){
        if(j!=rows)System.out.print("*");
      }
      System.out.print("\n");
    }
    System.out.print("\n");
  }
  public static void main(String args[]){
    int N=6 ;
    pattern(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation pattern( N : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var k : int ; k := 0 ;
    var space : int ; space := 1 ;
    var rows : int ; rows := N ;
         i := rows ; while i >= 1 do ( (         j := 1 ; while j <= i do ( (     OclFile["System.out"].print("*") )  ;     j := j + 1 ) ; 
     if (i /= rows) then (         k := 1 ; while k <= space do ( (     OclFile["System.out"].print(" ") )  ;     k := k + 1 ) ; 
     space := space + 2 ) else skip ; 
         j := i ; while j >= 1 do ( (     if (j /= rows) then     OclFile["System.out"].print("*") ; else skip )  ;     j := j - 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     i := i - 1 ) ; 
     OclFile["System.out"].print("\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 6 ;
     execute pattern(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maximum_middle_value(int n,int k,int arr[]){
    int ans=-1 ;
    int low=(n+1-k)/2 ;
    int high=(n+1-k)/2+k ;
    for(int i=low ; i<=high ; i++){
      ans=Math.max(ans,arr[i-1]);
    }
    return ans ;
  }
  public static void main(String args[]){
    int n=5,k=2 ;
    int arr[]={
      9,5,3,7,10 };
      System.out.println(maximum_middle_value(n,k,arr));
      n=9 ;
      k=3 ;
      int arr1[]={
        2,4,3,9,5,8,7,6,10 };
        System.out.println(maximum_middle_value(n,k,arr1));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maximum_middle_value( n : int, k : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := -1 ;
     var low : int ; low := (n + 1 - k) / 2 ;
    var high : int ; high := (n + 1 - k) / 2 + k ;
        var i : int ; i := low ; while i <= high do ( (     ans := Set{ans, arr[i - 1+1]}->max() )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var k : int ; k := 2 ;
     var arr : Sequence(int) ; arr := Sequence{9,5,3,7,10} ;
    OclFile["System.out"].println(maximum_middle_value(n, k, arr)) ; 
    n := 9 ; 
    k := 3 ; 
    var arr1 : Sequence(int) ; arr1 := Sequence{2,4,3,9,5,8,7,6,10} ;
    OclFile["System.out"].println(maximum_middle_value(n, k, arr1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static void eraseIsland(char[][] field,int i,int j){
    field[i][j]='0' ;
    if(i<11 && field[i+1][j]=='1')eraseIsland(field,i+1,j);
    if(j<11 && field[i][j+1]=='1')eraseIsland(field,i,j+1);
    if(i>0 && field[i-1][j]=='1')eraseIsland(field,i-1,j);
    if(j>0 && field[i][j-1]=='1')eraseIsland(field,i,j-1);
  }
  static void solve(char[][] field){
    int island=0 ;
    for(int i=0 ; i<12 ; i++){
      for(int j=0 ; j<12 ; j++){
        if(field[i][j]=='1'){
          eraseIsland(field,i,j);
          island+=1 ;
        }
      }
    }
    System.out.println(island);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[][] field=new char[12][12];
    while(sc.hasNext()){
      for(int i=0 ; i<12 ; i++){
        field[i]=sc.nextLine().toCharArray();
      }
      if(sc.hasNext())sc.nextLine();
      solve(field);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation eraseIsland( field : Sequence(Sequence(String)), i : int, j : int) : void
  pre: true
  post: true
  activity: (     field[i+1][j+1] := '0' ; 
     if (i < 11 & field[i + 1+1][j+1] = '1') then     execute eraseIsland(field, i + 1, j) ; else skip ; 
    if (j < 11 & field[i+1][j + 1+1] = '1') then     execute eraseIsland(field, i, j + 1) ; else skip ; 
    if (i > 0 & field[i - 1+1][j+1] = '1') then     execute eraseIsland(field, i - 1, j) ; else skip ; 
    if (j > 0 & field[i+1][j - 1+1] = '1') then     execute eraseIsland(field, i, j - 1) ; else skip ; 
 );
  static   operation solve( field : Sequence(Sequence(String))) : void
  pre: true
  post: true
  activity: (     var island : int ; island := 0 ;
         var i : int ; i := 0 ; while i < 12 do ( (         var j : int ; j := 0 ; while j < 12 do ( (     if (field[i+1][j+1] = '1') then (     execute eraseIsland(field, i, j) ; 
     island := island+(1) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(island) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var field : Sequence(Sequence(String)) ; field := Integer.subrange(1,12)->collect(Integer.subrange(1,12)->collect(0)) ;
     while (sc.hasNext()) do (         var i : int ; i := 0 ; while i < 12 do ( (     field[i+1] := sc.nextLine()->characters() )  ;     i := i + 1 ) ; 
     if (sc.hasNext()) then     skip ; else skip ; 
     execute solve(field) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  private int result ;
  private HashMap<Integer,Integer>cache ;
  public int pathSum(TreeNode root,int sum){
    result=0 ;
    cache=new HashMap<Integer,Integer>();
    cache.put(0,1);
    pathSumHelper(root,sum,0);
    return result ;
  }
  private void pathSumHelper(TreeNode root,int target,int soFar){
    if(root!=null){
      int complement=soFar+root.val-target ;
      if(cache.containsKey(complement))result+=cache.get(complement);
      cache.put(soFar+root.val,cache.getOrDefault(soFar+root.val,0)+1);
      pathSumHelper(root.left,target,soFar+root.val);
      pathSumHelper(root.right,target,soFar+root.val);
      cache.put(soFar+root.val,cache.get(soFar+root.val)-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   attribute result : int;
   attribute cache : Map(int,int);
   operation pathSum( root : TreeNode, sum : int) : int
  pre: true
  post: true
  activity: (     result := 0 ; 
     cache := Map{} ; 
    cache := cache->union(Map{0 |-> 1}) ; 
    execute pathSumHelper(root, sum, 0) ; 
    return result 
 );
   operation pathSumHelper( root : TreeNode, target : int, soFar : int) : void
  pre: true
  post: true
  activity: (     if (root /= null) then (     var complement : int ; complement := soFar + root.val - target ;
     if (cache->keys()->includes(complement)) then     result := result+(cache->at(complement)) ; else skip ; 
    cache := cache->union(Map{soFar + root.val |-> (if cache->keys()->contains(soFar + root.val) then cache->at(soFar + root.val) else 0 endif) + 1}) ; 
    execute pathSumHelper(root.left, target, soFar + root.val) ; 
    execute pathSumHelper(root.right, target, soFar + root.val) ; 
    cache := cache->union(Map{soFar + root.val |-> cache->at(soFar + root.val) - 1}) ; 
 ) else skip );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void getmax(int arr[],int n,int x){
    int s=0 ;
    for(int i=0 ; i<n ; i++){
      s=s+arr[i];
    }
    System.out.print(Math.min(s,x));
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4 };
      int x=5 ;
      int arr_size=arr.length ;
      getmax(arr,arr_size,x);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getmax( arr : Sequence(int), n : int, x : int) : void
  pre: true
  post: true
  activity: (     var s : int ; s := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     s := s + arr[i+1] )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(Set{s, x}->min()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4} ;
     var x : int ; x := 5 ;
     var arr_size : int ; arr_size := arr->size() ;
     execute getmax(arr, arr_size, x) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int tc=input.nextInt();
    work : while(tc-->0){
      long n=input.nextLong();
      if(n==1){
        System.out.println("3");
        continue work ;
      }
      String s=Long.toBinaryString(n);
      int lastindex=0 ;
      int count=0 ;
      for(int i=0 ; i<s.length(); i++){
        if(s.charAt(i)=='1'){
          count++;
          lastindex=i ;
        }
      }
      if(count==1){
        System.out.println(n+1);
      }
      else {
        System.out.println(1<<(s.length()-lastindex-1));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := input.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : long ; n := input.getCurrent()->toLong() ;
     if (n = 1) then (     OclFile["System.out"].println("3") ; 
     continue ) else skip ; 
    var s : String ; s := (MathLib.decimal2binary(n) + "") ;
    var lastindex : int ; lastindex := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '1') then (     count := count + 1 ; 
     lastindex := i ) else skip )  ;     i := i + 1 ) ; 
    if (count = 1) then (     OclFile["System.out"].println(n + 1) ) else (     OclFile["System.out"].println((1*(2->pow((s->size() - (lastindex)->char2byte() - 1))))->oclAsType(long)) ) ;  
 ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws java.io.IOException {
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    for(int i=1 ; i<=n ; i++){
      System.out.println("Case "+i+":");
      msm(scan.nextInt(),1);
    }
  }
  public static void msm(int n,int c){
    if(c==11)return ;
    String str=Integer.toString(n*n);
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<8-str.length(); i++)sb.append(0);
    sb.append(str);
    str=sb.toString().substring(2,6);
    int out=Integer.parseInt(str);
    System.out.println(out);
    msm(out,c+1);
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].println("Case " + i + ":") ; 
     execute msm(scan.getCurrent()->toInteger(), 1) )  ;     i := i + 1 ) );
  static   operation msm( n : int, c : int) : void
  pre: true
  post: true
  activity: (     if (c = 11) then     return else skip ; 
     var str : String ; str := ((n * n) + "") ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < 8 - str->size() do (     sb := sb + StringLib.newString(0) ;  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(str) ; 
    str := sb+"".subrange(2+1,6) ; 
    var out : int ; out := (str)->toInteger() ;
    OclFile["System.out"].println(out) ; 
    execute msm(out, c + 1) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static int dataSet=1 ;
  boolean main()throws IOException {
    int a=readIntArray()[0];
    System.out.printf("Case %d:\n",dataSet++);
    for(int i=0 ; i<10 ; i++){
      a=a*a ;
      int r=a/100 ;
      r=r % 10000 ;
      System.out.printf("%d\n",r);
      a=r ;
    }
    return true ;
  }
  private final static boolean DEBUG=false ;
  public static void main(String[] args)throws IOException {
    if(DEBUG){
      log=System.out ;
      String inputStr="1:15:" ;
      inputStr=inputStr.replace(":","\n");
      reader=new BufferedReader(new StringReader(inputStr));
    }
    else {
      log=new PrintStream(new OutputStream(){
        public void write(int b){
        }
      }
);
      reader=new BufferedReader(new InputStreamReader(System.in));
    }
    int N=readIntArray()[0];
    for(int i=0 ; i<N ; i++){
      boolean b=new Main().main();
      if(! b)break ;
    }
    reader.close();
  }
  static PrintStream log ;
  static BufferedReader reader ;
  private static int[] readIntArray()throws IOException {
    String s=null ;
    for(; ; ){
      s=reader.readLine();
      if(s==null)return null ;
      s=s.trim();
      if(s.length()!=0)break ;
    }
    String[] sp=s.split("[,] ");
    int[] a=new int[sp.length];
    for(int i=0 ; i<sp.length ; i++){
      a[i]=Integer.parseInt(sp[i]);
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dataSet : int := 1;
   operation main() : boolean
  pre: true
  post: true
  activity: (     var a : int ; a := readIntArray()[0+1] ;
     OclFile["System.out"].printf("Case %d:\n", dataSet) ; 
         var i : int ; i := 0 ; while i < 10 do ( (     a := a * a ; 
     var r : int ; r := a / 100 ;
    r := r mod 10000 ; 
    OclFile["System.out"].printf("%d\n", r) ; 
    a := r ; 
 )  ;     i := i + 1 ) ; 
     return true );
  static   attribute DEBUG : boolean := false;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (DEBUG) then (     log := OclFile["System.out"] ; 
     var inputStr : String ; inputStr := "1:15:" ;
     inputStr := inputStr.replace(":", "\n") ; 
     reader := OclFile.newOclFile_Read(StringReader.newStringReader(inputStr)) ) else (     log := OclFile.newOclFile_Write(OclFile()) ; 
     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ) ;  
     var N : int ; N := readIntArray()[0+1] ;
         var i : int ; i := 0 ; while i < N do ( (     var b : boolean ; b := Main.newMain().main() ;
     if (not(b)) then     break else skip )  ;     i := i + 1 ) ; 
     reader.close() );
  static   attribute log : OclFile;
  static   attribute reader : OclFile;
  static   operation readIntArray() : Sequence(int)
  pre: true
  post: true
  activity: (     var s : String ; s := null ;
       while true do ( (     s := reader.readLine() ; 
     if (s = null) then     return null else skip ; 
     s := s->trim() ; 
     if (s->size() /= 0) then     break else skip )  ) ; 
    var sp : Sequence(String) ; sp := s->split("[,] ") ;
    var a : Sequence(int) ; a := Integer.subrange(1,sp->size())->collect(0) ;
        var i : int ; i := 0 ; while i < sp->size() do ( (     a[i+1] := (sp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    return a 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().io();
  }
  void solve(long s){
    for(int i=0 ; i<10 ; ++i){
      s=(s*s)% 100000000 ;
      int dig=s!=0 ?(int)(Math.log10(s))+1 : 0 ;
      String str=Long.toString(s);
      for(int j=dig ; j<8 ; ++j){
        str="0"+str ;
      }
      String str_=new String();
      for(int j=2 ; j<6 ; ++j){
        str_=str_+str.charAt(j);
      }
      s=Long.parseLong(str_);
      System.out.println(s);
    }
  }
  void io(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=1 ; i<=n ; ++i){
      System.out.println("Case "+i+":");
      int s=sc.nextInt();
      solve(s);
    }
    sc.close();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().io() );
   operation solve( s : long) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 10 do ( (     s := (s * s) mod 100000000 ; 
     var dig : int ; dig := if s /= 0 then ((s)->log10())->oclAsType(int) + 1 else 0 endif ;
    var str : String ; str := ((s) + "") ;
        var j : int ; j := dig ; while j < 8 do ( (     str := "0" + str )  ;     j := j + 1 ) ; 
    var str_ : String ; str_ := StringLib.newString() ;
        var j : int ; j := 2 ; while j < 6 do ( (     str_ := str_ + str->at(j+1) )  ;     j := j + 1 ) ; 
    s := (str_)->toLong() ; 
    OclFile["System.out"].println(s) ; 
 )  ;     i := i + 1 ) );
   operation io() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].println("Case " + i + ":") ; 
     var s : int ; s := sc.getCurrent()->toInteger() ;
     execute solve(s) )  ;     i := i + 1 ) ; 
     skip );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(input.readLine());
    for(int i=0 ; i<n ; i++){
      int s=Integer.parseInt(input.readLine());
      System.out.println("Case "+(i+1)+":");
      for(int j=0 ; j<10 ; j++){
        s*=s ;
        String str=Integer.toString(s);
        String zero="" ;
        for(int k=0 ; k<8-str.length(); k++){
          zero+="0" ;
        }
        str=zero+str ;
        String str_ans="" ;
        for(int k=2 ; k<=5 ; k++){
          str_ans+=str.charAt(k);
        }
        String str_s="" ;
        int count=0 ;
        for(int k=0 ; k<4 ; k++){
          if(str_ans.charAt(k)!='0'){
            str_s+=str_ans.charAt(k);
            count++;
          }
          else if(str_ans.charAt(k)=='0' && count!=0){
            str_s+=str_ans.charAt(k);
          }
        }
        if(str_s.length()==0)str_s="0" ;
        System.out.println(Integer.parseInt(str_s));
        s=Integer.parseInt(str_s);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (input.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var s : int ; s := (input.readLine())->toInteger() ;
     OclFile["System.out"].println("Case " + (i + 1) + ":") ; 
         var j : int ; j := 0 ; while j < 10 do ( (     s := s*(s) ; 
     var str : String ; str := ((s) + "") ;
    var zero : String ; zero := "" ;
        var k : int ; k := 0 ; while k < 8 - str->size() do ( (     zero := zero+("0") )  ;     k := k + 1 ) ; 
    str := zero + str ; 
    var str_ans : String ; str_ans := "" ;
        var k : int ; k := 2 ; while k <= 5 do ( (     str_ans := str_ans+(str->at(k+1)) )  ;     k := k + 1 ) ; 
    var str_s : String ; str_s := "" ;
    var count : int ; count := 0 ;
        var k : int ; k := 0 ; while k < 4 do ( (     if (str_ans->at(k+1) /= '0') then (     str_s := str_s+(str_ans->at(k+1)) ; 
     count := count + 1 ) else     if (str_ans->at(k+1) = '0' & count /= 0) then (     str_s := str_s+(str_ans->at(k+1)) ) else skip ; )  ;     k := k + 1 ) ; 
    if (str_s->size() = 0) then     str_s := "0" ; else skip ; 
    OclFile["System.out"].println((str_s)->toInteger()) ; 
    s := (str_s)->toInteger() ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    int n=sc.nextInt();
    for(int j=1 ; j<=n ; j++){
      int k=sc.nextInt();
      println("Case "+j+":");
      for(int i=0 ; i<10 ; i++){
        k=(k*k/100)% 10000 ;
        println(""+k);
      }
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var j : int ; j := 1 ; while j <= n do ( (     var k : int ; k := sc.getCurrent()->toInteger() ;
     execute println("Case " + j + ":") ; 
         var i : int ; i := 0 ; while i < 10 do ( (     k := (k * k / 100) mod 10000 ; 
     execute println("" + k) )  ;     i := i + 1 ) )  ;     j := j + 1 ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    boolean[] sosu=new boolean[123456*2+1];
    Arrays.fill(sosu,true);
    sosu[0]=false ;
    sosu[1]=false ;
    for(int i=2 ; i<123456*2 ; i++){
      if(sosu[i]){
        for(int j=2 ; i*j<123456*2+1 ; j++){
          sosu[i*j]=false ;
        }
      }
    }
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int count=0 ;
      for(int i=n+1 ; i<n*2+1 ; i++){
        if(sosu[i]){
          count++;
        }
        else {
          continue ;
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sosu : Sequence(boolean) ; sosu := Integer.subrange(1,123456 * 2 + 1)->collect(false) ;
    sosu := sosu->collect(true) ; 
    sosu[0+1] := false ; 
    sosu[1+1] := false ; 
        var i : int ; i := 2 ; while i < 123456 * 2 do ( (     if (sosu[i+1]) then (         var j : int ; j := 2 ; while i * j < 123456 * 2 + 1 do ( (     sosu[i * j+1] := false )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var count : int ; count := 0 ;
        var i : int ; i := n + 1 ; while i < n * 2 + 1 do ( (     if (sosu[i+1]) then (     count := count + 1 ) else (     continue ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public final class Ideone {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.nextLine());
    for(int i=0 ; i<n ; i++){
      int sum=-Integer.parseInt(sc.nextLine());
      for(String x : sc.nextLine().trim().split(" ")){
        sum+=Integer.parseInt(x);
      }
      if(sum % 2==0){
        System.out.println("maomao90");
      }
      else {
        System.out.println("errorgorn");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ideone {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.nextLine())->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var sum : int ; sum := -(sc.nextLine())->toInteger() ;
     for (x : sc.nextLine()->trim()->split(" ")) do ( (     sum := sum+((x)->toInteger()) )  ) ; 
     if (sum mod 2 = 0) then (     OclFile["System.out"].println("maomao90") ) else (     OclFile["System.out"].println("errorgorn") ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[]){
    boolean isPrime[]=new boolean[1000000];
    for(int i=2 ; i<=246912 ; i++){
      isPrime[i]=true ;
    }
    for(int i=2 ; i<=246912 ; i++){
      if(isPrime[i]){
        int n=2*i ;
        while(n<=246912){
          isPrime[n]=false ;
          n+=i ;
        }
      }
    }
    Scanner in=new Scanner(System.in);
    while(true){
      int n=in.nextInt();
      if(n==0)break ;
      int count=0 ;
      for(int i=n+1 ; i<=2*n ; i++){
        if(isPrime[i]){
          count++;
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isPrime : Sequence(boolean) ; isPrime := Integer.subrange(1,1000000)->collect(false) ;
         var i : int ; i := 2 ; while i <= 246912 do ( (     isPrime[i+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= 246912 do ( (     if (isPrime[i+1]) then (     var n : int ; n := 2 * i ;
     while (n <= 246912) do (     isPrime[n+1] := false ; 
     n := n+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (true) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var count : int ; count := 0 ;
        var i : int ; i := n + 1 ; while i <= 2 * n do ( (     if (isPrime[i+1]) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    while(true){
      int n=nextInt();
      if(n==0){
        break ;
      }
      int lim=2*n ;
      if(n==1){
        System.out.println(1);
        continue ;
      }
      else if(n % 2==0){
        n++;
      }
      else {
        n+=2 ;
      }
      ArrayList<Integer>list=new ArrayList<Integer>();
      while(n<=lim){
        boolean is_prime=true ;
        for(int i=1 ; 2*i+1<=Math.sqrt(n); i++){
          if(n %(2*i+1)==0){
            is_prime=false ;
            break ;
          }
        }
        if(is_prime){
          list.add(n);
        }
        n+=2 ;
      }
      System.out.println(list.size());
    }
  }
  static int nextInt(){
    int c ;
    try {
      c=System.in.read();
      while(c!='-' &&(c<'0' || c>'9'))c=System.in.read();
      if(c=='-')return-nextInt();
      int res=0 ;
      while(c>='0' && c<='9'){
        res=res*10+c-'0' ;
        c=System.in.read();
      }
      return res ;
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := nextInt() ;
     if (n = 0) then (     break ) else skip ; 
    var lim : int ; lim := 2 * n ;
    if (n = 1) then (     OclFile["System.out"].println(1) ; 
     continue ) else     if (n mod 2 = 0) then (     n := n + 1 ) else (     n := n+(2) ) ;  ;  
    var list : Sequence(int) ; list := Sequence{} ;
    while (n <= lim) do (     var is_prime : boolean ; is_prime := true ;
         var i : int ; i := 1 ; while 2 * i + 1 <= (n)->sqrt() do ( (     if (n mod (2 * i + 1) = 0) then (     is_prime := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (is_prime) then (     list := list->including(n) ) else skip ; 
     n := n+(2) ) ; 
    OclFile["System.out"].println(list->size()) ; 
 ) );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     var c : int ;
     try (     c := OclFile["System.in"].read() ; 
     while (c /= '-' & (c < '0' or c > '9')) do     c := OclFile["System.in"].read() ; ; 
    if (c = '-') then     return -nextInt() else skip ; 
    var res : int ; res := 0 ;
    while (c >= '0' & c <= '9') do (     res := res * 10 + c - ('0')->char2byte() ; 
     c := OclFile["System.in"].read() ) ; 
    return res 
 )   catch (e : IOException) do (     e.printStackTrace() )
     return -1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    System.out.println(A-(B*2)>0 ? A-(B*2): 0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if A - (B * 2) > 0 then A - (B * 2) else 0 endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxOR(int arr[],int n){
    int maxVal=0 ;
    for(int i=0 ; i<n-1 ; i++)for(int j=i+1 ; j<n ; j++){
      maxVal=Math.max(maxVal,arr[i] | arr[j]);
    }
    return maxVal ;
  }
  public static void main(String[] args){
    int arr[]={
      4,8,12,16 };
      int n=arr.length ;
      System.out.println(maxOR(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxOR( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var maxVal : int ; maxVal := 0 ;
         var i : int ; i := 0 ; while i < n - 1 do (         var j : int ; j := i + 1 ; while j < n do ( (     maxVal := Set{maxVal, arr[i+1] or arr[j+1]}->max() )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return maxVal );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,8,12,16} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxOR(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
class Solution {
  public int numJewelsInStones(String J,String S){
    int result=0 ;
    HashSet jHash=new HashSet<>();
    for(int j=0 ; j<J.length(); j++){
      jHash.add(J.charAt(j));
    }
    for(int s=0 ; s<S.length(); s++){
      if(jHash.contains(S.charAt(s))){
        result++;
      }
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
   operation numJewelsInStones( J : String, S : String) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var jHash : Set ; jHash := Set{} ;
        var j : int ; j := 0 ; while j < J->size() do ( (     jHash := jHash->including(J->at(j+1)) )  ;     j := j + 1 ) ; 
        var s : int ; s := 0 ; while s < S->size() do ( (     if (jHash->includes(S->at(s+1))) then (     result := result + 1 ) else skip )  ;     s := s + 1 ) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=100,n ;
  static int[] store=new int[MAX];
  static int[][] graph=new int[MAX][MAX];
  static int[] d=new int[MAX];
  static boolean is_clique(int b){
    for(int i=1 ; i<b ; i++){
      for(int j=i+1 ; j<b ; j++)if(graph[store[i] ][store[j] ]==0)return false ;
    }
    return true ;
  }
  static int maxCliques(int i,int l){
    int max_=0 ;
    for(int j=i+1 ; j<=n ; j++){
      store[l]=j ;
      if(is_clique(l+1)){
        max_=Math.max(max_,l);
        max_=Math.max(max_,maxCliques(j,l+1));
      }
    }
    return max_ ;
  }
  public static void main(String[] args){
    int[][] edges={
      {
        1,2 },{
          2,3 },{
            3,1 },{
              4,3 },{
                4,1 },{
                  4,2 }
                };
                int size=edges.length ;
                n=4 ;
                for(int i=0 ; i<size ; i++){
                  graph[edges[i][0] ][edges[i][1] ]=1 ;
                  graph[edges[i][1] ][edges[i][0] ]=1 ;
                  d[edges[i][0] ]++;
                  d[edges[i][1] ]++;
                }
                System.out.print(maxCliques(0,1));
              }
            }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100;
  static   attribute store : Sequence(int) := Integer.subrange(1,MAX)->collect(0);
  static   attribute graph : Sequence(Sequence(int)) := Integer.subrange(1,MAX)->collect(Integer.subrange(1,MAX)->collect(0));
  static   attribute d : Sequence(int) := Integer.subrange(1,MAX)->collect(0);
  static   operation is_clique( b : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < b do ( (         var j : int ; j := i + 1 ; while j < b do (     if (graph[store[i+1]+1][store[j+1]+1] = 0) then     return false else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return true );
  static   operation maxCliques( i : int, l : int) : int
  pre: true
  post: true
  activity: (     var max_ : int ; max_ := 0 ;
         var j : int ; j := i + 1 ; while j <= n do ( (     store[l+1] := j ; 
     if (is_clique(l + 1)) then (     max_ := Set{max_, l}->max() ; 
     max_ := Set{max_, maxCliques(j, l + 1)}->max() ) else skip )  ;     j := j + 1 ) ; 
     return max_ );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var edges : Sequence(Sequence(int)) ; edges := Sequence{Sequence{1,2},Sequence{2,3},Sequence{3,1},Sequence{4,3},Sequence{4,1},Sequence{4,2}} ;
     var size : int ; size := edges->size() ;
    n := 4 ; 
        var i : int ; i := 0 ; while i < size do ( (     graph[edges[i+1][0+1]+1][edges[i+1][1+1]+1] := 1 ; 
     graph[edges[i+1][1+1]+1][edges[i+1][0+1]+1] := 1 ; 
     d[edges[i+1][0+1]+1] := d[edges[i+1][0+1]+1] + 1 ; 
     d[edges[i+1][1+1]+1] := d[edges[i+1][1+1]+1] + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(maxCliques(0, 1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int setBitNumber(int n){
    int k=(int)(Math.log(n)/Math.log(2));
    return(int)(Math.pow(2,k));
  }
  public static void main(String arg[]){
    int n=273 ;
    System.out.print(setBitNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation setBitNumber( n : int) : int
  pre: true
  post: true
  activity: (     var k : int ; k := ((n)->log() / (2)->log())->oclAsType(int) ;
     return (2->pow(k))->oclAsType(int) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 273 ;
     OclFile["System.out"].print(setBitNumber(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.HashMap ;
public class XeniaAndSpies {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    String input[]=reader.readLine().split(" ");
    int m=Integer.parseInt(input[1]);
    int s=Integer.parseInt(input[2]);
    int f=Integer.parseInt(input[3]);
    int maxT=-1 ;
    HashMap<Integer,ArrayList<Integer>>map=new HashMap<>();
    while(m>0){
      String mth[]=reader.readLine().split(" ");
      int k=Integer.parseInt(mth[0]);
      map.put(k,new ArrayList<>());
      map.get(k).add(Integer.parseInt(mth[1]));
      map.get(k).add(Integer.parseInt(mth[2]));
      maxT=Math.max(maxT,k);
      m--;
    }
    StringBuilder actions=new StringBuilder();
    final char M=(s<f)? 'R' : 'L' ;
    int d=(s<f)?+1 :-1 ;
    int cur=s ;
    int a=-1 ;
    int b=-1 ;
    for(int t=1 ; t<=maxT ; t++){
      if(map.containsKey(t)){
        a=map.get(t).get(0).intValue();
        b=map.get(t).get(1).intValue();
      }
      if(map.containsKey(t)&&((cur>=a && cur<=b)||(cur+d>=a && cur+d<=b))){
        actions.append('X');
      }
      else {
        actions.append(M);
        cur+=d ;
      }
      if(cur==f)break ;
    }
    while(cur!=f){
      actions.append(M);
      cur+=d ;
    }
    System.out.println(actions);
  }
}
------------------------------------------------------------
OCL File:
---------
 class XeniaAndSpies {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : Sequence(String) ; input := reader.readLine()->split(" ") ;
    var m : int ; m := (input[1+1])->toInteger() ;
    var s : int ; s := (input[2+1])->toInteger() ;
    var f : int ; f := (input[3+1])->toInteger() ;
    var maxT : int ; maxT := -1 ;
    var map : Map(int,Sequence(int)) ; map := Map{} ;
    while (m > 0) do (     var mth : Sequence(String) ; mth := reader.readLine()->split(" ") ;
     var k : int ; k := (mth[0+1])->toInteger() ;
    map := map->union(Map{k |-> Sequence{}}) ; 
    map->at(k)->excludes((mth[1+1])->toInteger()) ; 
    map->at(k)->excludes((mth[2+1])->toInteger()) ; 
    maxT := Set{maxT, k}->max() ; 
    m := m - 1 ; 
 ) ; 
    var actions : String ; actions := StringLib.newString() ;
    var M : String ; M := if (s < f) then 'R' else 'L' endif ;
    var d : int ; d := if (s < f) then 1 else -1 endif ;
    var cur : int ; cur := s ;
    var a : int ; a := -1 ;
    var b : int ; b := -1 ;
        var t : int ; t := 1 ; while t <= maxT do ( (     if (map->keys()->includes(t)) then (     a := map->at(t)->at(0+1)->oclAsType(int) ; 
     b := map->at(t)->at(1+1)->oclAsType(int) ) else skip ; 
     if (map->keys()->includes(t) & ((cur >= a & cur <= b) or (cur + d >= a & cur + d <= b))) then (     actions := actions + StringLib.newString('X') ) else (     actions := actions + StringLib.newString(M) ; 
     cur := cur+(d) ) ;  
     if (cur = f) then     break else skip )  ;     t := t + 1 ) ; 
    while (cur /= f) do (     actions := actions + StringLib.newString(M) ; 
     cur := cur+(d) ) ; 
    OclFile["System.out"].println(actions) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B342 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    in.next();
    int M=in.nextInt();
    int current=in.nextInt();
    int goal=in.nextInt();
    int[] T=new int[M+1];
    int[] L=new int[M+1];
    int[] R=new int[M+1];
    for(int m=0 ; m<M ; m++){
      T[m]=in.nextInt();
      L[m]=in.nextInt();
      R[m]=in.nextInt();
    }
    StringBuilder answer=new StringBuilder();
    int time=0 ;
    int idx=0 ;
    while(current!=goal){
      time++;
      char c ;
      int next ;
      if(current<goal){
        c='R' ;
        next=current+1 ;
      }
      else {
        c='L' ;
        next=current-1 ;
      }
      if(time==T[idx]){
        if((L[idx]<=next && next<=R[idx])||(L[idx]<=current && current<=R[idx])){
          c='X' ;
          next=current ;
        }
        idx++;
      }
      current=next ;
      answer.append(c);
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B342 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var M : int ; M := in.getCurrent()->toInteger() ;
    var current : int ; current := in.getCurrent()->toInteger() ;
    var goal : int ; goal := in.getCurrent()->toInteger() ;
    var T : Sequence(int) ; T := Integer.subrange(1,M + 1)->collect(0) ;
    var L : Sequence(int) ; L := Integer.subrange(1,M + 1)->collect(0) ;
    var R : Sequence(int) ; R := Integer.subrange(1,M + 1)->collect(0) ;
        var m : int ; m := 0 ; while m < M do ( (     T[m+1] := in.getCurrent()->toInteger() ; 
     L[m+1] := in.getCurrent()->toInteger() ; 
     R[m+1] := in.getCurrent()->toInteger() )  ;     m := m + 1 ) ; 
    var answer : String ; answer := StringLib.newString() ;
    var time : int ; time := 0 ;
    var idx : int ; idx := 0 ;
    while (current /= goal) do (     time := time + 1 ; 
     var c : String ;
    var next : int ;
    if (current < goal) then (     c := 'R' ; 
     next := current + 1 ) else (     c := 'L' ; 
     next := current - 1 ) ;  
    if (time = T[idx+1]) then (     if ((L[idx+1] <= next & next <= R[idx+1]) or (L[idx+1] <= current & current <= R[idx+1])) then (     c := 'X' ; 
     next := current ) else skip ; 
     idx := idx + 1 ) else skip ; 
    current := next ; 
    answer := answer + StringLib.newString(c) ; 
 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class practice {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int arr[]=new int[n];
      int c=0 ;
      for(int i=0 ; i<n ; i++){
        arr[i]=s.nextInt();
        if(arr[i]>1){
          c+=arr[i]-1 ;
        }
      }
      if(c % 2==1){
        System.out.println("errorgorn");
      }
      else {
        System.out.println("maomao90");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() ; 
     if (arr[i+1] > 1) then (     c := c+(arr[i+1] - 1) ) else skip )  ;     i := i + 1 ) ; 
    if (c mod 2 = 1) then (     OclFile["System.out"].println("errorgorn") ) else (     OclFile["System.out"].println("maomao90") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class Test {
  static int subsetPairNotDivisibleByK(int arr[],int N,int K){
    int f[]=new int[K];
    Arrays.fill(f,0);
    for(int i=0 ; i<N ; i++)f[arr[i] % K]++;
    if(K % 2==0)f[K/2]=Math.min(f[K/2],1);
    int res=Math.min(f[0],1);
    for(int i=1 ; i<=K/2 ; i++)res+=Math.max(f[i],f[K-i]);
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      3,7,2,9,1 };
      int N=arr.length ;
      int K=3 ;
      System.out.print(subsetPairNotDivisibleByK(arr,N,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation subsetPairNotDivisibleByK( arr : Sequence(int), N : int, K : int) : int
  pre: true
  post: true
  activity: (     var f : Sequence(int) ; f := Integer.subrange(1,K)->collect(0) ;
     f := f->collect(0) ; 
        var i : int ; i := 0 ; while i < N do (     f[arr[i+1] mod K+1] := f[arr[i+1] mod K+1] + 1 ;  ;     i := i + 1 ) ; 
    if (K mod 2 = 0) then     f[K / 2+1] := Set{f[K / 2+1], 1}->min() ; else skip ; 
    var res : int ; res := Set{f[0+1], 1}->min() ;
        var i : int ; i := 1 ; while i <= K / 2 do (     res := res+(Set{f[i+1], f[K - i+1]}->max()) ;  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,7,2,9,1} ;
     var N : int ; N := arr->size() ;
     var K : int ; K := 3 ;
     OclFile["System.out"].print(subsetPairNotDivisibleByK(arr, N, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javafx.util.Pair ;
import org.omg.Messaging.SYNC_WITH_TRANSPORT ;
import java.util.*;
import java.io.*;
import java.util.Collections ;
public class Main {
  public static long ans=0 ;
  public static long get(long a){
    long ret=0 ;
    long now=1 ;
    long t=1 ;
    for(; ; ){
      if(now*10>a){
        ret+=(a-now+1)*t ;
        break ;
      }
      ret+=now*9*t ;
      now*=10 ;
      t++;
    }
    return ret ;
  }
  public static long binarySearch(long k,long l,long r,long x){
    if(r>=l){
      long mid=l+(r-l)/2 ;
      if(mid>ans && mid*k<=x)ans=mid ;
      if(k*mid==x)return mid ;
      if(k*mid>x)return binarySearch(k,l,mid-1,x);
      return binarySearch(k,mid+1,r,x);
    }
    return-1 ;
  }
  public static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  public static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException {
    Scanner S=new Scanner(System.in);
    long gen,st,tim ;
    gen=S.nextLong();
    st=S.nextLong();
    tim=S.nextLong();
    gen/=tim ;
    long beg=st-1,end=(long)Math.pow(10,18);
    while(true){
      long med=(beg+end)/2+1 ;
      if(get(med)-get(st-1)>gen){
        end=med-1 ;
      }
      else {
        beg=med ;
      }
      if(beg==end){
        System.out.println(beg-st+1);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ans : long := 0;
  static   operation get( a : long) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := 0 ;
     var now : long ; now := 1 ;
    var t : long ; t := 1 ;
      while true do ( (     if (now * 10 > a) then (     ret := ret+((a - now + 1) * t) ; 
     break ) else skip ; 
     ret := ret+(now * 9 * t) ; 
     now := now*(10) ; 
     t := t + 1 )  ) ; 
    return ret 
 );
  static   operation binarySearch( k : long, l : long, r : long, x : long) : long
  pre: true
  post: true
  activity: (     if (r >= l) then (     var mid : long ; mid := l + (r - l) / 2 ;
     if (mid > ans & mid * k <= x) then     ans := mid ; else skip ; 
    if (k * mid = x) then     return mid else skip ; 
    if (k * mid > x) then     return binarySearch(k, l, mid - 1, x) else skip ; 
    return binarySearch(k, mid + 1, r, x) 
 ) else skip ; 
     return -1 );
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : OclFile ; S := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var gen : long ;
    var st : long ;
    var tim : long ;
    gen := S.getCurrent()->toLong() ; 
    st := S.getCurrent()->toLong() ; 
    tim := S.getCurrent()->toLong() ; 
    gen := gen/(tim) ; 
    var beg : long ; beg := st - 1 ;
    var end : long ; end := 10->pow(18)->oclAsType(long) ;
    while (true) do (     var med : long ; med := (beg + end) / 2 + 1 ;
     if (get(med) - get(st - 1) > gen) then (     end := med - 1 ) else (     beg := med ) ;  
     if (beg = end) then (     OclFile["System.out"].println(beg - st + 1) ; 
     break ) else skip ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printRoots(long a,long b,long c){
    System.out.println(1+","+c/(a*1.0));
  }
  public static void main(String[] args){
    long a=2 ;
    long b=3 ;
    long c=-5 ;
    printRoots(a,b,c);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printRoots( a : long, b : long, c : long) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(1 + "," + c / (a * 1.0)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ; a := 2 ;
     var b : long ; b := 3 ;
     var c : long ; c := -5 ;
     execute printRoots(a, b, c) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int[][][] memo=new int[32][2][2];
  static int dp(int pos,int fl,int pr,String bin){
    if(pos==bin.length())return 1 ;
    if(memo[pos][fl][pr]!=-1)return memo[pos][fl][pr];
    int val=0 ;
    if(bin.charAt(pos)=='0')val=val+dp(pos+1,fl,0,bin);
    else if(bin.charAt(pos)=='1')val=val+dp(pos+1,1,0,bin);
    if(pr==0){
      if(fl==1){
        val+=dp(pos+1,fl,1,bin);
      }
      else if(bin.charAt(pos)=='1'){
        val+=dp(pos+1,fl,1,bin);
      }
    }
    return memo[pos][fl][pr]=val ;
  }
  static int findIntegers(int num){
    String bin="" ;
    while(num>0){
      if(num % 2==1)bin+="1" ;
      else bin+="0" ;
      num/=2 ;
    }
    bin=reverse(bin);
    for(int i=0 ; i<32 ; i++){
      for(int j=0 ; j<2 ; j++){
        for(int l=0 ; l<2 ; l++)memo[i][j][l]=-1 ;
      }
    }
    return dp(0,0,0,bin);
  }
  static String reverse(String input){
    char[] a=input.toCharArray();
    int l,r=a.length-1 ;
    for(l=0 ; l<r ; l++,r--){
      char temp=a[l];
      a[l]=a[r];
      a[r]=temp ;
    }
    return String.valueOf(a);
  }
  public static void main(String[] args){
    int N=12 ;
    System.out.print(findIntegers(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute memo : Sequence(Sequence(Sequence(int))) := Integer.subrange(1,32)->collect(Integer.subrange(1,2)->collect(Integer.subrange(1,2)->collect(0)));
  static   operation dp( pos : int, fl : int, pr : int, bin : String) : int
  pre: true
  post: true
  activity: (     if (pos = bin->size()) then     return 1 else skip ; 
     if (memo[pos+1][fl+1][pr+1] /= -1) then     return memo[pos+1][fl+1][pr+1] else skip ; 
    var val : int ; val := 0 ;
    if (bin->at(pos+1) = '0') then     val := val + dp(pos + 1, fl, 0, bin) else     if (bin->at(pos+1) = '1') then     val := val + dp(pos + 1, 1, 0, bin) ; else skip ; ;  
    if (pr = 0) then (     if (fl = 1) then (     val := val+(dp(pos + 1, fl, 1, bin)) ) else     if (bin->at(pos+1) = '1') then (     val := val+(dp(pos + 1, fl, 1, bin)) ) else skip ; ) else skip ; 
    return memo[pos+1][fl+1][pr+1] 
 );
  static   operation findIntegers( num : int) : int
  pre: true
  post: true
  activity: (     var bin : String ; bin := "" ;
     while (num > 0) do (     if (num mod 2 = 1) then     bin := bin+("1") else     bin := bin+("0") ; ;  
     num := num/(2) ) ; 
    bin := reverse(bin) ; 
        var i : int ; i := 0 ; while i < 32 do ( (         var j : int ; j := 0 ; while j < 2 do ( (         var l : int ; l := 0 ; while l < 2 do (     memo[i+1][j+1][l+1] := -1 ;  ;     l := l + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return dp(0, 0, 0, bin) 
 );
  static   operation reverse( input : String) : String
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := input->characters() ;
     var l : int ;
    var r : int ; r := a->size() - 1 ;
         l := 0 ; while l < r do ( (     var temp : String ; temp := a[l+1] ;
     a[l+1] := a[r+1] ; 
     a[r+1] := temp )  ;     l := l + 1 ;     r := r - 1 ) ; 
     return (a)->sum()  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 12 ;
     OclFile["System.out"].print(findIntegers(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String in=br.readLine();
      String chr[]=in.split(" ");
      int a=Integer.parseInt(chr[0]);
      int b=Integer.parseInt(chr[1]);
      System.out.println(b*2>=a ? 0 : a-b*2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var in : String ; in := br.readLine() ;
     var chr : Sequence(String) ; chr := in->split(" ") ;
    var a : int ; a := (chr[0+1])->toInteger() ;
    var b : int ; b := (chr[1+1])->toInteger() ;
    OclFile["System.out"].println(if b * 2 >= a then 0 else (a)->char2byte() - b * 2 endif) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  final static int N=4 ;
  static int MaximumDecimalValue(int mat[][],int n){
    int dp[][]=new int[n][n];
    if(mat[0][0]==1){
      dp[0][0]=1 ;
    }
    for(int i=1 ; i<n ; i++){
      if(mat[0][i]==1){
        dp[0][i]=(int)(dp[0][i-1]+Math.pow(2,i));
      }
      else {
        dp[0][i]=dp[0][i-1];
      }
    }
    for(int i=1 ; i<n ; i++){
      if(mat[i][0]==1){
        dp[i][0]=(int)(dp[i-1][0]+Math.pow(2,i));
      }
      else {
        dp[i][0]=dp[i-1][0];
      }
    }
    for(int i=1 ; i<n ; i++){
      for(int j=1 ; j<n ; j++){
        if(mat[i][j]==1){
          dp[i][j]=(int)(Math.max(dp[i][j-1],dp[i-1][j])+Math.pow(2,i+j));
        }
        else {
          dp[i][j]=Math.max(dp[i][j-1],dp[i-1][j]);
        }
      }
    }
    return dp[n-1][n-1];
  }
  public static void main(String[] args){
    int mat[][]={
      {
        1,1,0,1 },{
          0,1,1,0 },{
            1,0,0,1 },{
              1,0,1,1 },};
              System.out.println(MaximumDecimalValue(mat,4));
            }
          }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 4;
  static   operation MaximumDecimalValue( mat : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
     if (mat[0+1][0+1] = 1) then (     dp[0+1][0+1] := 1 ) else skip ; 
        var i : int ; i := 1 ; while i < n do ( (     if (mat[0+1][i+1] = 1) then (     dp[0+1][i+1] := (dp[0+1][i - 1+1] + 2->pow(i))->oclAsType(int) ) else (     dp[0+1][i+1] := dp[0+1][i - 1+1] ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (mat[i+1][0+1] = 1) then (     dp[i+1][0+1] := (dp[i - 1+1][0+1] + 2->pow(i))->oclAsType(int) ) else (     dp[i+1][0+1] := dp[i - 1+1][0+1] ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 1 ; while j < n do ( (     if (mat[i+1][j+1] = 1) then (     dp[i+1][j+1] := (Set{dp[i+1][j - 1+1], dp[i - 1+1][j+1]}->max() + 2->pow(i + j))->oclAsType(int) ) else (     dp[i+1][j+1] := Set{dp[i+1][j - 1+1], dp[i - 1+1][j+1]}->max() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return dp[n - 1+1][n - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,1,0,1},Sequence{0,1,1,0},Sequence{1,0,0,1},Sequence{1,0,1,1},} ;
     OclFile["System.out"].println(MaximumDecimalValue(mat, 4)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void createHash(HashSet<Integer>hash,int maxElement){
    int prev=0,curr=1 ;
    hash.add(prev);
    hash.add(curr);
    while(curr<maxElement){
      int temp=curr+prev ;
      hash.add(temp);
      prev=curr ;
      curr=temp ;
    }
  }
  static void findFibonacciPair(int n){
    HashSet<Integer>hash=new HashSet<Integer>();
    createHash(hash,n);
    for(int i=0 ; i<n ; i++){
      if(hash.contains(i)&& hash.contains(n-i)){
        System.out.print(i+","+(n-i)+"\n");
        return ;
      }
    }
    System.out.print("-1\n");
  }
  public static void main(String[] args){
    int N=90 ;
    findFibonacciPair(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation createHash( hash : Set(int), maxElement : int) : void
  pre: true
  post: true
  activity: (     var prev : int ; prev := 0 ;
    var curr : int ; curr := 1 ;
     hash->excludes(prev) ; 
     hash->excludes(curr) ; 
     while (curr < maxElement) do (     var temp : int ; temp := curr + prev ;
     hash->excludes(temp) ; 
     prev := curr ; 
     curr := temp ) );
  static   operation findFibonacciPair( n : int) : void
  pre: true
  post: true
  activity: (     var hash : Set(int) ; hash := Set{} ;
     execute createHash(hash, n) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (hash->includes(i) & hash->includes(n - i)) then (     OclFile["System.out"].print(i + "," + (n - i) + "\n") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("-1\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 90 ;
     execute findFibonacciPair(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int countgroup(int a[],int n){
    int xs=0 ;
    for(int i=0 ; i<n ; i++)xs=xs ^ a[i];
    if(xs==0)return(1<<(n-1))-1 ;
    return 0 ;
  }
  public static void main(String args[]){
    int a[]={
      1,2,3 };
      int n=a.length ;
      System.out.println(countgroup(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countgroup( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var xs : int ; xs := 0 ;
         var i : int ; i := 0 ; while i < n do (     xs := MathLib.bitwiseXor(xs,a[i+1]) ;  ;     i := i + 1 ) ; 
     if (xs = 0) then     return ((1*(2->pow((n - 1))))->oclAsType(long)) - 1 else skip ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(countgroup(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maxLength(String s,int n){
    int ans=Integer.MIN_VALUE ;
    Vector<Integer>A=new Vector<Integer>();
    Vector<Integer>L=new Vector<Integer>();
    Vector<Integer>R=new Vector<Integer>();
    int[] freq=new int[n+5];
    for(int i=0 ; i<26 ; i++){
      int count=0 ;
      for(int j=0 ; j<n ; j++){
        if(s.charAt(j)-'a'==i)count++;
        freq[j]=count ;
      }
      for(int j=1 ; j<n ; j++){
        L.add((2*freq[j-1])-j);
        R.add((2*freq[j])-j);
      }
      int max_len=Integer.MIN_VALUE ;
      int min_val=Integer.MAX_VALUE ;
      for(int j=0 ; j<L.size(); j++){
        min_val=Math.min(min_val,L.get(j));
        A.add(min_val);
        int l=0,r=j ;
        while(l<=r){
          int mid=(l+r)>>1 ;
          if(A.get(mid)<=R.get(j)){
            max_len=Math.max(max_len,j-mid+1);
            r=mid-1 ;
          }
          else {
            l=mid+1 ;
          }
        }
      }
      ans=Math.max(ans,max_len);
      A.clear();
      R.clear();
      L.clear();
    }
    return ans ;
  }
  public static void main(String[] args){
    String s="ababbbacbcbcca" ;
    int n=s.length();
    System.out.println(maxLength(s,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxLength( s : String, n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := -2147483648 ;
     var A : Sequence(int) ; A := Sequence{} ;
    var L : Sequence(int) ; L := Sequence{} ;
    var R : Sequence(int) ; R := Sequence{} ;
    var freq : Sequence(int) ; freq := Integer.subrange(1,n + 5)->collect(0) ;
        var i : int ; i := 0 ; while i < 26 do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (s->at(j+1) - ('a')->char2byte() = i) then     count := count + 1 ; else skip ; 
     freq[j+1] := count )  ;     j := j + 1 ) ; 
        var j : int ; j := 1 ; while j < n do ( (     L := L->including((2 * freq[j - 1+1]) - j) ; 
     R := R->including((2 * freq[j+1]) - j) )  ;     j := j + 1 ) ; 
    var max_len : int ; max_len := -2147483648 ;
    var min_val : int ; min_val := 2147483647 ;
        var j : int ; j := 0 ; while j < L->size() do ( (     min_val := Set{min_val, L->at(j+1)}->min() ; 
     A := A->including(min_val) ; 
     var l : int ; l := 0 ;
    var r : int ; r := j ;
     while (l <= r) do (     var mid : int ; mid := ((l + r)/(2->pow(1)))->oclAsType(long) ;
     if (A->at(mid+1) <= R->at(j+1)) then (     max_len := Set{max_len, j - mid + 1}->max() ; 
     r := mid - 1 ) else (     l := mid + 1 ) ) )  ;     j := j + 1 ) ; 
    ans := Set{ans, max_len}->max() ; 
    A := A->intersection(Set{}) ; 
    R := R->intersection(Set{}) ; 
    L := L->intersection(Set{}) ; 
 )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "ababbbacbcbcca" ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].println(maxLength(s, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class pair {
    int first,second ;
    public pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static int N=100005 ;
  static Vector<Integer>[] gr=new Vector[N];
  static int[] colour=new int[N];
  static Vector<pair>edges=new Vector<>();
  static boolean bip ;
  static void add_edge(int x,int y){
    gr[x] .add(y);
    gr[y] .add(x);
    edges.add(new pair(x,y));
  }
  static void dfs(int x,int col){
    colour[x]=col ;
    for(Integer i : gr[x]){
      if(colour[i]==-1)dfs(i,col ^ 1);
      else if(colour[i]==col)bip=false ;
    }
  }
  static void Directed_Graph(int n,int m){
    for(int i=0 ; i<N ; i++)colour[i]=-1 ;
    bip=true ;
    dfs(1,1);
    if(! bip){
      System.out.print(-1);
      return ;
    }
    for(int i=0 ; i<m ; i++){
      if(colour[edges.get(i).first]==0){
        Collections.swap(edges,edges.get(i).first,edges.get(i).second);
      }
      System.out.println(edges.get(i).first+" "+edges.get(i).second);
    }
  }
  public static void main(String[] args){
    int n=4,m=3 ;
    for(int i=0 ; i<N ; i++)gr[i]=new Vector<>();
    add_edge(1,2);
    add_edge(1,3);
    add_edge(1,4);
    Directed_Graph(n,m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class pair {
   attribute first : int;
   static operation newpair( first : int, second : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   attribute N : int := 100005;
  static   attribute gr : Sequence(Sequence(int)) := Integer.subrange(1,N)->collect(null);
  static   attribute colour : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static   attribute edges : Sequence(pair) := Sequence{};
  static   attribute bip : boolean;
  static   operation add_edge( x : int, y : int) : void
  pre: true
  post: true
  activity: (     gr[x+1]->excludes(y) ; 
     gr[y+1]->excludes(x) ; 
     edges := edges->including(pair.newpair(x, y)) );
  static   operation dfs( x : int, col : int) : void
  pre: true
  post: true
  activity: (     colour[x+1] := col ; 
     for (i : gr[x+1]) do ( (     if (colour[i+1] = -1) then     execute dfs(i, col xor 1) ; else     if (colour[i+1] = col) then     bip := false ; else skip ; )  ) );
  static   operation Directed_Graph( n : int, m : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do (     colour[i+1] := -1 ;  ;     i := i + 1 ) ; 
     bip := true ; 
    execute dfs(1, 1) ; 
    if (not(bip)) then (     OclFile["System.out"].print(-1) ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < m do ( (     if (colour[edges->at(i+1)->at("first")+1] = 0) then (     edges := Integer.subrange(1,edges.size)->collect( _x | if _x = edges->at(i+1)->at("first")+1 then edges->at(edges->at(i+1)->at("second")+1) else if _x = edges->at(i+1)->at("second")+1 then edges->at(edges->at(i+1)->at("first")+1) else edges->at(_x) endif endif ) ) else skip ; 
     OclFile["System.out"].println(edges->at(i+1)->at("first") + " " + edges->at(i+1)->at("second")) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
    var m : int ; m := 3 ;
         var i : int ; i := 0 ; while i < N do (     gr[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
    execute add_edge(1, 2) ; 
    execute add_edge(1, 3) ; 
    execute add_edge(1, 4) ; 
    execute Directed_Graph(n, m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int xorCalc(int k){
    if(k==1)return 2 ;
    if(((k+1)& k)==0)return k/2 ;
    return 1 ;
  }
  public static void main(String[] args){
    int k=31 ;
    System.out.println(xorCalc(k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation xorCalc( k : int) : int
  pre: true
  post: true
  activity: (     if (k = 1) then     return 2 else skip ; 
     if (((k + 1) & k) = 0) then     return k / 2 else skip ; 
     return 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 31 ;
     OclFile["System.out"].println(xorCalc(k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class EhabOddPerson {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine().trim());
    String line1[]=br.readLine().trim().split(" ");
    long arr[]=new long[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=Long.parseLong(line1[i]);
    }
    boolean odd=false,even=false ;
    ArrayList<Long>ans=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      if(arr[i] % 2==0){
        even=true ;
      }
      else {
        odd=true ;
      }
      ans.add(arr[i]);
    }
    if(odd && even){
      Collections.sort(ans);
    }
    for(int i=0 ; i<n ; i++){
      System.out.println(ans.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class EhabOddPerson {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine()->trim())->toInteger() ;
    var line1 : Sequence(String) ; line1 := br.readLine()->trim()->split(" ") ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (line1[i+1])->toLong() )  ;     i := i + 1 ) ; 
    var odd : boolean ; odd := false ;
    var even : boolean ; even := false ;
    var ans : Sequence(long) ; ans := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 = 0) then (     even := true ) else (     odd := true ) ;  
     ans := ans->including(arr[i+1]) )  ;     i := i + 1 ) ; 
    if (odd & even) then (     ans := ans->sort() ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(ans->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Solution {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    ArrayList<Integer>arr=new ArrayList<>();
    String[] st=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++)arr.add(Integer.parseInt(st[i]));
    boolean even=false ;
    boolean odd=false ;
    for(int i=0 ; i<n ; i++){
      if(arr.get(i)% 2==0)even=true ;
      else odd=true ;
      if(even && odd){
        Collections.sort(arr);
        break ;
      }
    }
    StringBuilder s=new StringBuilder(n);
    for(int i=0 ; i<n ; i++){
      s.append(arr.get(i)).append(" ");
    }
    System.out.print(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var arr : Sequence(int) ; arr := Sequence{} ;
    var st : Sequence(String) ; st := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < n do (     arr := arr->including((st[i+1])->toInteger()) ;  ;     i := i + 1 ) ; 
    var even : boolean ; even := false ;
    var odd : boolean ; odd := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr->at(i+1) mod 2 = 0) then     even := true else     odd := true ; ;  
     if (even & odd) then (     arr := arr->sort() ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var s : String ; s := StringLib.newString(n) ;
        var i : int ; i := 0 ; while i < n do ( (     s := s + StringLib.newString(arr->at(i+1)) + StringLib.newString(" ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class EhabOddPerson {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine().trim());
    String line1[]=br.readLine().trim().split(" ");
    long arr[]=new long[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=Long.parseLong(line1[i]);
    }
    boolean odd=false,even=false ;
    ArrayList<Long>ans=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      if(arr[i] % 2==0){
        even=true ;
      }
      else {
        odd=true ;
      }
      ans.add(arr[i]);
    }
    if(odd && even){
      Collections.sort(ans);
    }
    for(int i=0 ; i<ans.size(); i++){
      System.out.print(ans.get(i)+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class EhabOddPerson {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine()->trim())->toInteger() ;
    var line1 : Sequence(String) ; line1 := br.readLine()->trim()->split(" ") ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (line1[i+1])->toLong() )  ;     i := i + 1 ) ; 
    var odd : boolean ; odd := false ;
    var even : boolean ; even := false ;
    var ans : Sequence(long) ; ans := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 = 0) then (     even := true ) else (     odd := true ) ;  
     ans := ans->including(arr[i+1]) )  ;     i := i + 1 ) ; 
    if (odd & even) then (     ans := ans->sort() ) else skip ; 
        var i : int ; i := 0 ; while i < ans->size() do ( (     OclFile["System.out"].print(ans->at(i+1) + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Ehab {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int odd=0,even=0 ;
    Integer[] arr=new Integer[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      if(arr[i] % 2!=0){
        odd++;
      }
      else {
        even++;
      }
    }
    if(odd>0 && even>0){
      Arrays.sort(arr);
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      sb.append(arr[i]+" ");
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ehab {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var odd : int ; odd := 0 ;
    var even : int ; even := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr[i+1] mod 2 /= 0) then (     odd := odd + 1 ) else (     even := even + 1 ) )  ;     i := i + 1 ) ; 
    if (odd > 0 & even > 0) then (     arr := arr->sort() ) else skip ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     sb := sb + StringLib.newString(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int o,g,x=0 ;
    long n,borrow=0 ;
    o=sc.nextInt();
    n=sc.nextLong();
    g=sc.nextInt();
    for(int i=1 ; i<=g ; i++){
      x=x+i*o ;
    }
    borrow=x-n ;
    if(borrow<=0)System.out.println(0);
    else System.out.println(borrow);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var o : int ;
    var g : int ;
    var x : int ; x := 0 ;
    var n : long ;
    var borrow : long ; borrow := 0 ;
    o := sc.getCurrent()->toInteger() ; 
    n := sc.getCurrent()->toLong() ; 
    g := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i <= g do ( (     x := x + i * o )  ;     i := i + 1 ) ; 
    borrow := x - n ; 
    if (borrow <= 0) then     OclFile["System.out"].println(0) else     OclFile["System.out"].println(borrow) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    solve(System.in,System.out);
  }
  static void solve(InputStream is,PrintStream os){
    Scanner sc=new Scanner(is);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int ans=Math.max(0,a-2*b);
    os.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation solve( is : OclFile, os : OclFile) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(is) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := Set{0, a - 2 * b}->max() ;
    os.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    long n,k,w,sum=0 ;
    k=s.nextLong();
    n=s.nextLong();
    w=s.nextLong();
    for(int i=1 ; i<=w ; i++){
      sum=sum+(i*k);
    }
    if(sum>n){
      System.out.println(sum-n);
    }
    else {
      System.out.println("0");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ;
    var k : long ;
    var w : long ;
    var sum : long ; sum := 0 ;
    k := s.getCurrent()->toLong() ; 
    n := s.getCurrent()->toLong() ; 
    w := s.getCurrent()->toLong() ; 
        var i : int ; i := 1 ; while i <= w do ( (     sum := sum + (i * k) )  ;     i := i + 1 ) ; 
    if (sum > n) then (     OclFile["System.out"].println(sum - n) ) else (     OclFile["System.out"].println("0") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class SoldierAndBananas {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int cost=sc.nextInt();
    int initialMoney=sc.nextInt();
    int noBananas=sc.nextInt();
    int sum=cost ;
    for(int i=2 ; i<=noBananas ; i++){
      sum+=i*cost ;
    }
    if(sum<=initialMoney){
      System.out.println(0);
      System.exit(0);
    }
    System.out.println(sum-initialMoney);
  }
}
------------------------------------------------------------
OCL File:
---------
 class SoldierAndBananas {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cost : int ; cost := sc.getCurrent()->toInteger() ;
    var initialMoney : int ; initialMoney := sc.getCurrent()->toInteger() ;
    var noBananas : int ; noBananas := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := cost ;
        var i : int ; i := 2 ; while i <= noBananas do ( (     sum := sum+(i * cost) )  ;     i := i + 1 ) ; 
    if (sum <= initialMoney) then (     OclFile["System.out"].println(0) ; 
 OclProcess.exit(0) ) else skip ; 
    OclFile["System.out"].println(sum - initialMoney) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long pandu,vundu,urdu,c=0 ;
    pandu=sc.nextLong();
    vundu=sc.nextLong();
    urdu=sc.nextLong();
    for(int i=1 ; i<=urdu ; i++){
      c+=i*pandu ;
    }
    if(c<vundu){
      System.out.print("0");
    }
    else {
      System.out.print(c-vundu);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pandu : long ;
    var vundu : long ;
    var urdu : long ;
    var c : long ; c := 0 ;
    pandu := sc.getCurrent()->toLong() ; 
    vundu := sc.getCurrent()->toLong() ; 
    urdu := sc.getCurrent()->toLong() ; 
        var i : int ; i := 1 ; while i <= urdu do ( (     c := c+(i * pandu) )  ;     i := i + 1 ) ; 
    if (c < vundu) then (     OclFile["System.out"].print("0") ) else (     OclFile["System.out"].print(c - vundu) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.StrictMath.*;
import static javax.swing.JOptionPane.*;
public class uni {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int sum=0 ;
    int a=scan.nextInt();
    int b=scan.nextInt();
    int c=scan.nextInt();
    for(int i=1 ; i<=c ; i++){
      sum+=a*i ;
    }
    if(sum-b<0)System.out.println(0);
    else System.out.println(sum-b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class uni {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sum : int ; sum := 0 ;
    var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    var c : int ; c := scan.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= c do ( (     sum := sum+(a * i) )  ;     i := i + 1 ) ; 
    if (sum - b < 0) then     OclFile["System.out"].println(0) else     OclFile["System.out"].println(sum - b) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public boolean isPerfectSquare(int num){
    int low=1 ;
    int high=num ;
    while(low<=high){
      long mid=(low+high)>>>1 ;
      if(mid*mid==num){
        return true ;
      }
      else if(mid*mid<num){
        low=(int)mid+1 ;
      }
      else {
        high=(int)mid-1 ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation isPerfectSquare( num : int) : boolean
  pre: true
  post: true
  activity: (     var low : int ; low := 1 ;
     var high : int ; high := num ;
     while (low <= high) do (     var mid : long ; mid := ((low + high)/(2->pow(1)))->oclAsType(long) ;
     if (mid * mid = num) then (     return true ) else     if (mid * mid < num) then (     low := mid->oclAsType(int) + 1 ) else (     high := mid->oclAsType(int) - 1 ) ;  ) ; 
     return false );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean isPrime(int k){
    if(k<=1)return false ;
    for(int i=2 ; i<k ; i++)if(k % i==0)return false ;
    return true ;
  }
  static int check(int num,int k){
    int flag=1 ;
    for(int i=2 ; i<k ; i++){
      if(num % i==0)flag=0 ;
    }
    if(flag==1){
      if(num % k==0)return 1 ;
      else return 0 ;
    }
    else return 0 ;
  }
  static int findCount(int a,int b,int k){
    int count=0 ;
    if(! isPrime(k))return 0 ;
    else {
      int ans ;
      for(int i=a ; i<=b ; i++){
        ans=check(i,k);
        if(ans==1)count++;
        else continue ;
      }
    }
    return count ;
  }
  public static void main(String args[]){
    int a=2020,b=6300,k=29 ;
    System.out.println(findCount(a,b,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( k : int) : boolean
  pre: true
  post: true
  activity: (     if (k <= 1) then     return false else skip ; 
         var i : int ; i := 2 ; while i < k do (     if (k mod i = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation check( num : int, k : int) : int
  pre: true
  post: true
  activity: (     var flag : int ; flag := 1 ;
         var i : int ; i := 2 ; while i < k do ( (     if (num mod i = 0) then     flag := 0 ; else skip )  ;     i := i + 1 ) ; 
     if (flag = 1) then (     if (num mod k = 0) then     return 1 else     return 0 ) else     return 0 );
  static   operation findCount( a : int, b : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     if (not(isPrime(k))) then     return 0 else (     var ans : int ;
         var i : int ; i := a ; while i <= b do ( (     ans := check(i, k) ; 
     if (ans = 1) then     count := count + 1 ; else     continue )  ;     i := i + 1 ) ) ;  
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2020 ;
    var b : int ; b := 6300 ;
    var k : int ; k := 29 ;
     OclFile["System.out"].println(findCount(a, b, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    int D=sc.nextInt();
    final long MOD=998244353 ;
    long[][] dp=new long[D][C];
    long[][] sum=new long[D][C];
    sum[B-1][A-1]=1 ;
    for(int i=A ; i<C ; i++){
      sum[B-1][i]=(sum[B-1][i-1]*B)% MOD ;
    }
    for(int i=B ; i<D ; i++){
      for(int j=A ; j<C ; j++){
        dp[i][j]=dp[i-1][j]*j ;
        dp[i][j]+=sum[i-1][j-1]*j ;
        dp[i][j] %=MOD ;
        sum[i][j]=(sum[i][j-1]*(i+1)+dp[i][j])% MOD ;
      }
    }
    long ans=0 ;
    long powC=1 ;
    for(int i=D-1 ; i>=B ; i--){
      long powI=1 ;
      for(int j=C-1 ; j>=A ; j--){
        ans=(ans+dp[i][j]*((powC*powI)% MOD))% MOD ;
        powI=(powI*(i+1))% MOD ;
      }
      powC=(powC*C)% MOD ;
    }
    ans=(ans+(powC*sum[B-1][C-1])% MOD)% MOD ;
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var D : int ; D := sc.getCurrent()->toInteger() ;
    var MOD : long ; MOD := 998244353 ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,D)->collect(Integer.subrange(1,C)->collect(0)) ;
    var sum : Sequence(Sequence(long)) ; sum := Integer.subrange(1,D)->collect(Integer.subrange(1,C)->collect(0)) ;
    sum[B - 1+1][A - 1+1] := 1 ; 
        var i : int ; i := A ; while i < C do ( (     sum[B - 1+1][i+1] := (sum[B - 1+1][i - 1+1] * B) mod MOD )  ;     i := i + 1 ) ; 
        var i : int ; i := B ; while i < D do ( (         var j : int ; j := A ; while j < C do ( (     dp[i+1][j+1] := dp[i - 1+1][j+1] * j ; 
     dp[i+1][j+1] := dp[i+1][j+1]+(sum[i - 1+1][j - 1+1] * j) ; 
     dp[i+1][j+1] := dp[i+1][j+1] mod MOD ; 
     sum[i+1][j+1] := (sum[i+1][j - 1+1] * (i + 1) + dp[i+1][j+1]) mod MOD )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var powC : long ; powC := 1 ;
        var i : int ; i := D - 1 ; while i >= B do ( (     var powI : long ; powI := 1 ;
         var j : int ; j := C - 1 ; while j >= A do ( (     ans := (ans + dp[i+1][j+1] * ((powC * powI) mod MOD)) mod MOD ; 
     powI := (powI * (i + 1)) mod MOD )  ;     j := j - 1 ) ; 
     powC := (powC * C) mod MOD )  ;     i := i - 1 ) ; 
    ans := (ans + (powC * sum[B - 1+1][C - 1+1]) mod MOD) mod MOD ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  long MOD=998244353L ;
  long[][] dp=new long[3001][3001];
  void solve(Scanner sc,PrintWriter pw){
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    int D=sc.nextInt();
    dp[A][B]=1 ;
    for(int c=A ; c<=C ; c++){
      for(int d=B ; d<=D ; d++){
        if(c==A && d==B){
          continue ;
        }
        long ans=0 ;
        if(c>A){
          long part=dp[c-1][d];
          ans=(part*d);
        }
        if(d>B){
          long part=dp[c][d-1];
          ans=(ans+(part*c));
        }
        if(c>A && d>B){
          ans=(ans-(dp[c-1][d-1]*(c-1)*(d-1)));
        }
        dp[c][d]=((ans % MOD)+MOD)% MOD ;
      }
    }
    pw.println(dp[C][D]);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    new Main().solve(sc,pw);
    pw.flush();
    pw.close();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute MOD : long := 998244353L;
   attribute dp : Sequence(Sequence(long)) := Integer.subrange(1,3001)->collect(Integer.subrange(1,3001)->collect(0));
   operation solve( sc : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var A : int ; A := sc.nextInt() ;
     var B : int ; B := sc.nextInt() ;
    var C : int ; C := sc.nextInt() ;
    var D : int ; D := sc.nextInt() ;
    dp[A+1][B+1] := 1 ; 
        var c : int ; c := A ; while c <= C do ( (         var d : int ; d := B ; while d <= D do ( (     if (c = A & d = B) then (     continue ) else skip ; 
     var ans : long ; ans := 0 ;
    if (c > A) then (     var part : long ; part := dp[c - 1+1][d+1] ;
     ans := (part * d) ) else skip ; 
    if (d > B) then (     var part : long ; part := dp[c+1][d - 1+1] ;
     ans := (ans + (part * c)) ) else skip ; 
    if (c > A & d > B) then (     ans := (ans - (dp[c - 1+1][d - 1+1] * (c - 1) * (d - 1))) ) else skip ; 
    dp[c+1][d+1] := ((ans mod MOD) + MOD) mod MOD ; 
 )  ;     d := d + 1 ) )  ;     c := c + 1 ) ; 
    pw.println(dp[C+1][D+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    Main.newMain().solve(sc, pw) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int MOD=998244353 ;
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    int D=sc.nextInt();
    long[][] dp=new long[C+1][D+1];
    long[][] S=new long[C+1][D+1];
    dp[A][B]=1 ;
    for(int i=B ; i<D ; i++)dp[A][i+1]=dp[A][i]*A % MOD ;
    for(int i=A ; i<C ; i++)dp[i+1][B]=dp[i][B]*B % MOD ;
    for(int i=A+1 ; i<=C ; i++)for(int j=B+1 ; j<=D ; j++){
      S[i][j]=(S[i-1][j]*(j-1)+dp[i-1][j])% MOD ;
      dp[i][j]=(dp[i][j-1]*i+S[i][j])% MOD ;
    }
    System.out.println(dp[C][D]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var MOD : int ; MOD := 998244353 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var D : int ; D := sc.getCurrent()->toInteger() ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,C + 1)->collect(Integer.subrange(1,D + 1)->collect(0)) ;
    var S : Sequence(Sequence(long)) ; S := Integer.subrange(1,C + 1)->collect(Integer.subrange(1,D + 1)->collect(0)) ;
    dp[A+1][B+1] := 1 ; 
        var i : int ; i := B ; while i < D do (     dp[A+1][i + 1+1] := dp[A+1][i+1] * A mod MOD ;  ;     i := i + 1 ) ; 
        var i : int ; i := A ; while i < C do (     dp[i + 1+1][B+1] := dp[i+1][B+1] * B mod MOD ;  ;     i := i + 1 ) ; 
        var i : int ; i := A + 1 ; while i <= C do (         var j : int ; j := B + 1 ; while j <= D do ( (     S[i+1][j+1] := (S[i - 1+1][j+1] * (j - 1) + dp[i - 1+1][j+1]) mod MOD ; 
     dp[i+1][j+1] := (dp[i+1][j - 1+1] * i + S[i+1][j+1]) mod MOD )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[C+1][D+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int[][] red=new int[n][2];
    int[][] blue=new int[n][2];
    for(int i=0 ; i<n ; i++){
      red[i][0]=Integer.parseInt(sc.next());
      red[i][1]=Integer.parseInt(sc.next());
    }
    for(int i=0 ; i<n ; i++){
      blue[i][0]=Integer.parseInt(sc.next());
      blue[i][1]=Integer.parseInt(sc.next());
    }
    Arrays.sort(red,(a,b)->Integer.compare(a[0],b[0]));
    Arrays.sort(blue,(a,b)->Integer.compare(a[0],b[0]));
    System.out.println(calc(red,blue,n));
    sc.close();
  }
  public static int calc(int[][] red,int[][] blue,int n){
    int ret=0,maxtemp=-1,index=0,maxindex=0,flag=0 ;
    for(int i=0 ; i<n ; i++){
      index=0 ;
      flag=0 ;
      maxtemp=-1 ;
      while(index<n && red[index][0]<blue[i][0]){
        if(maxtemp<=red[index][1] && red[index][1]<blue[i][1]){
          maxtemp=red[index][1];
          maxindex=index ;
          flag=1 ;
        }
        index++;
      }
      if(flag==1){
        ret++;
        red[maxindex][1]=201 ;
      }
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var red : Sequence(Sequence(int)) ; red := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
    var blue : Sequence(Sequence(int)) ; blue := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     red[i+1][0+1] := (sc.getCurrent())->toInteger() ; 
     red[i+1][1+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     blue[i+1][0+1] := (sc.getCurrent())->toInteger() ; 
     blue[i+1][1+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    red := OclComparator.sortWith(red, lambda (a , b) : OclAny in compare(a[0+1], b[0+1])) ; 
    blue := OclComparator.sortWith(blue, lambda (a , b) : OclAny in compare(a[0+1], b[0+1])) ; 
    OclFile["System.out"].println(calc(red, blue, n)) ; 
    skip ; 
 );
  static   operation calc( red : Sequence(Sequence(int)), blue : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
    var maxtemp : int ; maxtemp := -1 ;
    var index : int ; index := 0 ;
    var maxindex : int ; maxindex := 0 ;
    var flag : int ; flag := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     index := 0 ; 
     flag := 0 ; 
    maxtemp := -1 ; 
    while (index < n & red[index+1][0+1] < blue[i+1][0+1]) do (     if (maxtemp <= red[index+1][1+1] & red[index+1][1+1] < blue[i+1][1+1]) then (     maxtemp := red[index+1][1+1] ; 
     maxindex := index ; 
     flag := 1 ) else skip ; 
     index := index + 1 ) ; 
    if (flag = 1) then (     ret := ret + 1 ; 
     red[maxindex+1][1+1] := 201 ) else skip ; 
 )  ;     i := i + 1 ) ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public void main(Scanner sc){
    int n=sc.nextInt();
    int a[][]=new int[n][2];
    int b[][]=new int[n][2];
    boolean used[]=new boolean[n];
    for(int i=0 ; i<n ; i++){
      a[i][0]=sc.nextInt();
      a[i][1]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      b[i][0]=sc.nextInt();
      b[i][1]=sc.nextInt();
    }
    Arrays.sort(a,(o1,o2)->o1[0]-o2[0]);
    Arrays.sort(b,(o1,o2)->o1[0]-o2[0]);
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      int pare=-1 ;
      int maxy=0 ;
      for(int j=0 ; j<n &&(a[j][0]<b[i][0]); j++){
        if(used[j]){
          continue ;
        }
        if(a[j][1]<b[i][1] && maxy<=a[j][1]){
          pare=j ;
          maxy=a[j][1];
        }
      }
      if(pare!=-1){
        used[pare]=true ;
        cnt++;
      }
    }
    System.out.println(cnt);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    new Main().main(sc);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
    var b : Sequence(Sequence(int)) ; b := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
    var used : Sequence(boolean) ; used := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1][0+1] := sc.nextInt() ; 
     a[i+1][1+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1][0+1] := sc.nextInt() ; 
     b[i+1][1+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    a := OclComparator.sortWith(a, lambda (o1 , o2) : OclAny in o1[0+1] - o2[0+1]) ; 
    b := OclComparator.sortWith(b, lambda (o1 , o2) : OclAny in o1[0+1] - o2[0+1]) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var pare : int ; pare := -1 ;
     var maxy : int ; maxy := 0 ;
         var j : int ; j := 0 ; while j < n & (a[j+1][0+1] < b[i+1][0+1]) do ( (     if (used[j+1]) then (     continue ) else skip ; 
     if (a[j+1][1+1] < b[i+1][1+1] & maxy <= a[j+1][1+1]) then (     pare := j ; 
     maxy := a[j+1][1+1] ) else skip )  ;     j := j + 1 ) ; 
     if (pare /= -1) then (     used[pare+1] := true ; 
     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Main.newMain().main(sc) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(final String[] args)throws Exception {
    final Scanner sc=new Scanner(System.in);
    long A ;
    A=sc.nextLong();
    long B ;
    B=sc.nextLong();
    final Solver solver=new Solver();
    solver.solve(A,B);
  }
}
class Solver {
  public void solve(long A,long B){
    int ans=(int)(A-2*B);
    System.out.println(ans>=0 ? ans : 0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : long ;
    A := sc.getCurrent()->toLong() ; 
    var B : long ;
    B := sc.getCurrent()->toLong() ; 
    var solver : Solver ; solver := Solver.newSolver() ;
    solver.solve(A, B) ; 
 );
}
class Solver {
   operation solve( A : long, B : long) : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := (A - 2 * B)->oclAsType(int) ;
     OclFile["System.out"].println(if ans >= 0 then ans else 0 endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Point red[]=new Point[n];
    for(int i=0 ; i<n ; i++){
      red[i]=new Point(sc.nextInt(),sc.nextInt());
    }
    Point blue[]=new Point[n];
    for(int i=0 ; i<n ; i++){
      blue[i]=new Point(sc.nextInt(),sc.nextInt());
    }
    Arrays.sort(red);
    Arrays.sort(blue);
    int result=0 ;
    boolean used[]=new boolean[n];
    for(int i=0 ; i<n ; i++){
      int maxIndex=-1 ;
      int maxY=-1 ;
      for(int j=0 ; j<n ; j++){
        if(red[j] .x>blue[i] .x){
          break ;
        }
        if(! used[j] && red[j] .y<blue[i] .y && red[j] .y>maxY){
          maxY=red[j] .y ;
          maxIndex=j ;
        }
      }
      if(maxIndex>=0){
        used[maxIndex]=true ;
        result++;
      }
    }
    System.out.println(result);
  }
}
class Point implements Comparable<Point>{
  int x ;
  int y ;
  Point(int x,int y){
    this.x=x ;
    this.y=y ;
  }
  @ Override public int compareTo(Point p){
    return this.x-p.x ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var red : Sequence(Point) ; red := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     red[i+1] := Point.newPoint(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var blue : Sequence(Point) ; blue := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     blue[i+1] := Point.newPoint(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    red := red->sort() ; 
    blue := blue->sort() ; 
    var result : int ; result := 0 ;
    var used : Sequence(boolean) ; used := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     var maxIndex : int ; maxIndex := -1 ;
     var maxY : int ; maxY := -1 ;
         var j : int ; j := 0 ; while j < n do ( (     if (red[j+1].x > blue[i+1].x) then (     break ) else skip ; 
     if (not(used[j+1]) & red[j+1].y < blue[i+1].y & red[j+1].y > maxY) then (     maxY := red[j+1].y ; 
     maxIndex := j ) else skip )  ;     j := j + 1 ) ; 
     if (maxIndex >= 0) then (     used[maxIndex+1] := true ; 
     result := result + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}
class Point implements Comparable<Point> {
   attribute x : int;
   attribute y : int;
   static operation newPoint( x : int, y : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
      operation compareTo( p : Point) : int
  pre: true
  post: true
  activity: (     return self.x - p.x );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Point implements Comparable<Point>{
  public int x,y ;
  public int color ;
  public static int red=0,blue=1 ;
  public Point(int x,int y,int color){
    this.x=x ;
    this.y=y ;
    this.color=color ;
  }
  public int compareTo(Point another){
    return this.x-another.x ;
  }
  public boolean connectable(Point another){
    return(this.x<another.x && this.y<another.y && this.color==red && another.color==blue)||(this.x>another.x && this.y>another.y && this.color==blue && another.color==red);
  }
  public void use(){
    color=-1 ;
  }
}
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    Point[] r=new Point[N];
    for(int n=0 ; n<N ; n++)r[n]=new Point(sc.nextInt(),sc.nextInt(),0);
    Point[] b=new Point[N];
    for(int n=0 ; n<N ; n++)b[n]=new Point(sc.nextInt(),sc.nextInt(),1);
    Arrays.sort(r);
    Arrays.sort(b);
    int ans=0 ;
    for(Point blue : b){
      int highest=-1 ;
      for(Point red : r)if(blue.connectable(red)&& red.y>highest)highest=red.y ;
      if(highest>=0){
        ans++;
        for(Point red : r)if(red.y==highest)red.use();
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Point implements Comparable<Point> {
   attribute x : int;
   attribute color : int;
  static   attribute red : int := 0;
   static operation newPoint( x : int, y : int, color : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y,color);
    return self );
  operation initialise( x : int, y : int, color : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y ; 
     self.color := color );
   operation compareTo( another : Point) : int
  pre: true
  post: true
  activity: (     return self.x - another.x );
   operation connectable( another : Point) : boolean
  pre: true
  post: true
  activity: (     return (self.x < another.x & self.y < another.y & self.color = red & another.color = blue) or (self.x > another.x & self.y > another.y & self.color = blue & another.color = red) );
   operation use() : void
  pre: true
  post: true
  activity: (     color := -1 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var r : Sequence(Point) ; r := Integer.subrange(1,N)->collect(null) ;
        var n : int ; n := 0 ; while n < N do (     r[n+1] := Point.newPoint(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger(), 0) ;  ;     n := n + 1 ) ; 
    var b : Sequence(Point) ; b := Integer.subrange(1,N)->collect(null) ;
        var n : int ; n := 0 ; while n < N do (     b[n+1] := Point.newPoint(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger(), 1) ;  ;     n := n + 1 ) ; 
    r := r->sort() ; 
    b := b->sort() ; 
    var ans : int ; ans := 0 ;
    for (blue : b) do ( (     var highest : int ; highest := -1 ;
     for (red : r) do (     if (blue.connectable(red) & red.y > highest) then     highest := red.y ; else skip ;  ) ; 
     if (highest >= 0) then (     ans := ans + 1 ; 
     for (red : r) do (     if (red.y = highest) then     red.use() ; else skip ;  ) ) else skip )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.security.spec.ECField ;
import java.util.HashMap ;
import java.util.StringTokenizer ;
public class Main {
  static int a[];
  static int l[];
  static int ans[];
  static HashMap<Integer,Boolean>map=new HashMap<>();
  public static void main(String[] args)throws Exception {
    InputReader reader=new InputReader();
    PrintWriter out=new PrintWriter(System.out);
    int n,k ;
    n=reader.nextInt();
    k=reader.nextInt();
    int[] str=new int[n];
    if(n<k){
      out.println("-1");
      out.flush();
      return ;
    }
    if(k==1){
      if(n>1)out.println("-1");
      else out.println("a");
      out.flush();
      return ;
    }
    for(int i=0 ; i<(n-k+2); i++){
      if(i<n){
        if(i % 2==0)str[i]=0 ;
        else str[i]=1 ;
      }
    }
    int j=2 ;
    for(int i=n-k+2 ; i<n ; i++){
      str[i]=j++;
    }
    for(int i=0 ; i<n ; i++){
      out.print((char)(str[i]+97));
    }
    out.flush();
  }
  static class InputReader {
    BufferedReader reader ;
    StringTokenizer tokenizer ;
    InputReader(){
      reader=new BufferedReader(new InputStreamReader(System.in));
      tokenizer=null ;
    }
    String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a : Sequence(int);
  static   attribute l : Sequence(int);
  static   attribute ans : Sequence(int);
  static   attribute map : Map(int,Boolean) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : InputReader ; reader := InputReader.newInputReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ;
    var k : int ;
    n := reader.nextInt() ; 
    k := reader.nextInt() ; 
    var str : Sequence(int) ; str := Integer.subrange(1,n)->collect(0) ;
    if (n < k) then (     skip ; 
     skip ; 
     return ) else skip ; 
    if (k = 1) then (     if (n > 1) then     skip else     skip ; ;  
     skip ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < (n - k + 2) do ( (     if (i < n) then (     if (i mod 2 = 0) then     str[i+1] := 0 ; else     str[i+1] := 1 ; ) else skip )  ;     i := i + 1 ) ; 
    var j : int ; j := 2 ;
        var i : int ; i := n - k + 2 ; while i < n do ( (      str[i+1] := j  ; j := j + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader() : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    String result="No" ;
    if(max(a,max(b,c))*2==a+b+c)result="Yes" ;
    System.out.println(result);
  }
  public static class Scanner {
    private BufferedReader br ;
    private StringTokenizer tok ;
    public Scanner(InputStream is)throws IOException {
      br=new BufferedReader(new InputStreamReader(is));
    }
    private void getLine()throws IOException {
      while(! hasNext())tok=new StringTokenizer(br.readLine());
    }
    private boolean hasNext(){
      return tok!=null && tok.hasMoreTokens();
    }
    public String next()throws IOException {
      getLine();
      return tok.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var result : String ; result := "No" ;
    if (Set{a, Set{b, c}->max()}->max() * 2 = a + b + c) then     result := "Yes" ; else skip ; 
    OclFile["System.out"].println(result) ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute tok : OclIterator;
   static operation newScanner( is : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
   operation getLine() : void
  pre: true
  post: true
  activity: (     while (not(hasNext())) do     tok := OclIterator.newOclIterator_String(br.readLine()) ; );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return tok /= null & tok.hasNext() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute getLine() ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxn=16 ;
  static int[] precompute(){
    int dp[]=new int[maxn],arr[]={
      4,6,9 };
      for(int i=0 ; i<maxn ; i++)dp[i]=-1 ;
      dp[0]=0 ;
      for(int i=1 ; i<maxn ; ++i){
        for(int k=0 ; k<3 ; k++){
          int j=arr[k];
          if(i>=j && dp[i-j]!=-1){
            dp[i]=Math.max(dp[i],dp[i-j]+1);
          }
        }
      }
      return dp ;
    }
    static int Maximum_Summands(int[] dp,int n){
      if(n<maxn)return dp[n];
      else {
        int t=(n-maxn)/4+1 ;
        return t+dp[n-4*t];
      }
    }
    public static void main(String args[]){
      int n=12 ;
      int[] dp=precompute();
      System.out.println(Maximum_Summands(dp,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute maxn : int := 16;
  static   operation precompute() : Sequence(int)
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,maxn)->collect(0) ;
    var arr : Sequence(void) ; arr := Sequence{4,6,9} ;
         var i : int ; i := 0 ; while i < maxn do (     dp[i+1] := -1 ;  ;     i := i + 1 ) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 1 ; while i < maxn do ( (         var k : int ; k := 0 ; while k < 3 do ( (     var j : int ; j := arr[k+1] ;
     if (i >= j & dp[i - j+1] /= -1) then (     dp[i+1] := Set{dp[i+1], dp[i - j+1] + 1}->max() ) else skip )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    return dp 
 );
  static   operation Maximum_Summands( dp : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n < maxn) then     return dp[n+1] else (     var t : int ; t := (n - maxn) / 4 + 1 ;
     return t + dp[n - 4 * t+1] ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     var dp : Sequence(int) ; dp := precompute() ;
     OclFile["System.out"].println(Maximum_Summands(dp, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSquares(int n){
    return(n*(n+1)/2)*(2*n+1)/3 ;
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println("Count of squares is "+countSquares(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSquares( n : int) : int
  pre: true
  post: true
  activity: (     return (n * (n + 1) / 2) * (2 * n + 1) / 3 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println("Count of squares is " + countSquares(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] a=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      a[i]=sc.nextInt();
    }
    long[] sum=new long[n+1];
    for(int i=1 ; i<=n ; i++){
      sum[i]=a[i]+sum[i-1];
    }
    HashMap<Long,Integer>map=new HashMap<Long,Integer>();
    for(int i=1 ; i<=n ; i++){
      map.put(sum[i] % m,0);
    }
    for(int i=1 ; i<=n ; i++){
      int x=map.get(sum[i] % m);
      map.put(sum[i] % m,x+1);
    }
    long ans=0 ;
    if(map.containsKey(0l)){
      ans=map.get(0l);
    }
    for(long i : map.keySet()){
      if(map.get(i)>=2){
        for(int j=map.get(i); j>1 ; j--){
          ans+=j-1 ;
        }
      }
    }
    System.out.println(ans);
  }
}
class Pair implements Comparable {
  int from ;
  int end ;
  int num ;
  int bango ;
  @ Override public int compareTo(Object other){
    Pair otherpair=(Pair)other ;
    return from-otherpair.from ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum : Sequence(long) ; sum := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     sum[i+1] := a[i+1] + sum[i - 1+1] )  ;     i := i + 1 ) ; 
    var map : Map(long,int) ; map := Map{} ;
        var i : int ; i := 1 ; while i <= n do ( (     map := map->union(Map{sum[i+1] mod m |-> 0}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     var x : int ; x := map->at(sum[i+1] mod m) ;
     map := map->union(Map{sum[i+1] mod m |-> x + 1}) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    if (map->keys()->includes(0l)) then (     ans := map->at(0l) ) else skip ; 
    for (i : map->keys()) do ( (     if (map->at(i) >= 2) then (         var j : int ; j := map->at(i) ; while j > 1 do ( (     ans := ans+(j - 1) )  ;     j := j - 1 ) ) else skip )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}
class Pair implements OclAny {
   attribute from : int;
   attribute end : int;
   attribute num : int;
   attribute bango : int;
      operation compareTo( other : OclAny) : int
  pre: true
  post: true
  activity: (     var otherpair : Map ; otherpair := other->oclAsType(Map) ;
     return from - otherpair.from );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.util.HashMap ;
import java.io.IOException ;
import java.util.InputMismatchException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskD solver=new TaskD();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskD {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int m=in.nextInt();
      int[] a=in.nextIntArray(n);
      HashMap<Integer,Integer>dp=new HashMap<>();
      long ans=0 ;
      int base=0 ;
      for(int i=0 ; i<n ; i++){
        base=(base-a[i] % m+m)% m ;
        dp.merge((base+a[i])% m,1,Integer :: sum);
        ans+=dp.getOrDefault(base,0);
      }
      out.println(ans);
    }
  }
  static class InputReader {
    private BufferedReader br ;
    private StringTokenizer st ;
    public InputReader(InputStream inputStream){
      br=new BufferedReader(new InputStreamReader(inputStream));
      st=new StringTokenizer("");
    }
    public String nextString(){
      while(! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine()," ");
        }
        catch(IOException e){
          throw new InputMismatchException();
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(nextString());
    }
    public int[] nextIntArray(int n){
      int[] res=new int[n];
      for(int i=0 ; i<n ; i++){
        res[i]=nextInt();
      }
      return res ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskD ; solver := TaskD.newTaskD() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskD {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var m : int ; m := in.nextInt() ;
    var a : Sequence(int) ; a := in.nextIntArray(n) ;
    var dp : Map(int,int) ; dp := Map{} ;
    var ans : long ; ans := 0 ;
    var base : int ; base := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     base := (base - a[i+1] mod m + m) mod m ; 
     dp := dp.merge((base + a[i+1]) mod m, 1, lambda _pars : OclAny in Integer.newInteger().sum(_pars)) ; 
     ans := ans+((if dp->keys()->contains(base) then dp->at(base) else 0 endif)) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newInputReader( inputStream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) ; 
     st := OclIterator.newOclIterator_String("") );
   operation nextString() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String_String(br.readLine(), " ") )   catch (e : IOException) do (     error IncorrectElementException() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextString())->toInteger() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return res );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    new Main().solve();
  }
  void solve(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long M=sc.nextLong();
    long[] A=new long[N];
    long Ans=0 ;
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextLong();
    }
    for(int i=1 ; i<N ; i++){
      A[i]+=A[i-1];
    }
    for(int i=0 ; i<N ; i++){
      A[i] %=M ;
    }
    Arrays.sort(A);
    long c=1 ;
    for(int i=0 ; i<N-1 ; i++){
      if(A[i]==A[i+1]){
        c++;
      }
      else {
        Ans+=c*(c-1)/2 ;
        c=1 ;
      }
    }
    Ans+=c*(c-1)/2 ;
    for(int i=0 ; i<N ; i++){
      if(A[i]==0){
        Ans++;
      }
    }
    System.out.println(Ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : long ; M := sc.getCurrent()->toLong() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
    var Ans : long ; Ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < N do ( (     A[i+1] := A[i+1]+(A[i - 1+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := A[i+1] mod M )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    var c : long ; c := 1 ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     if (A[i+1] = A[i + 1+1]) then (     c := c + 1 ) else (     Ans := Ans+(c * (c - 1) / 2) ; 
     c := 1 ) )  ;     i := i + 1 ) ; 
    Ans := Ans+(c * (c - 1) / 2) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (A[i+1] = 0) then (     Ans := Ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[] A=new int[N];
    Arrays.setAll(A,i->sc.nextInt());
    Map<Integer,Long>x=new HashMap<>();
    int[] S=new int[N];
    S[0]=A[0] % M ;
    x.put(0,1L);
    x.put(S[0],x.getOrDefault(S[0],0L)+1);
    for(int i=1 ; i<N ; i++){
      S[i]=(S[i-1]+A[i])% M ;
      x.put(S[i],x.getOrDefault(S[i],0L)+1);
    }
    long ans=0 ;
    for(int i : x.keySet())ans+=x.get(i)*(x.get(i)-1)/2 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
setAll(A, lambda i : OclAny in sc.getCurrent()->toInteger()) ; 
    var x : Map(int,long) ; x := Map{} ;
    var S : Sequence(int) ; S := Integer.subrange(1,N)->collect(0) ;
    S[0+1] := A[0+1] mod M ; 
    x := x->union(Map{0 |-> 1L}) ; 
    x := x->union(Map{S[0+1] |-> (if x->keys()->contains(S[0+1]) then x->at(S[0+1]) else 0L endif) + 1}) ; 
        var i : int ; i := 1 ; while i < N do ( (     S[i+1] := (S[i - 1+1] + A[i+1]) mod M ; 
     x := x->union(Map{S[i+1] |-> (if x->keys()->contains(S[i+1]) then x->at(S[i+1]) else 0L endif) + 1}) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    for (i : x->keys()) do (     ans := ans+(x->at(i) * (x->at(i) - 1) / 2) ;  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long m=sc.nextLong();
    long[] a=new long[n+1];
    long[] sum=new long[n+1];
    sum[0]=0 ;
    for(int i=1 ; i<n+1 ; i++){
      a[i]=sc.nextLong();
      sum[i]=sum[i-1]+a[i];
    }
    Map<Long,Long>div=new HashMap<>();
    for(int i=0 ; i<n+1 ; i++){
      long x=sum[i] % m ;
      if(div.containsKey(x)){
        long val=div.get(x);
        val++;
        div.put(x,val);
      }
      else {
        div.put(x,(long)1);
      }
    }
    long cnt=0 ;
    for(Map.Entry<Long,Long>e : div.entrySet()){
      long num=e.getValue();
      if(num>=2){
        cnt+=num*(num-1)/2 ;
      }
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : long ; m := sc.getCurrent()->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var sum : Sequence(long) ; sum := Integer.subrange(1,n + 1)->collect(0) ;
    sum[0+1] := 0 ; 
        var i : int ; i := 1 ; while i < n + 1 do ( (     a[i+1] := sc.getCurrent()->toLong() ; 
     sum[i+1] := sum[i - 1+1] + a[i+1] )  ;     i := i + 1 ) ; 
    var div : Map(long,long) ; div := Map{} ;
        var i : int ; i := 0 ; while i < n + 1 do ( (     var x : long ; x := sum[i+1] mod m ;
     if (div->keys()->includes(x)) then (     var val : long ; val := div->at(x) ;
     val := val + 1 ; 
     div := div->union(Map{x |-> val}) ) else (     div := div->union(Map{x |-> 1->oclAsType(long)}) ) )  ;     i := i + 1 ) ; 
    var cnt : long ; cnt := 0 ;
    for (e : div->asSet()) do ( (     var num : long ; num := e.getValue() ;
     if (num >= 2) then (     cnt := cnt+(num * (num - 1) / 2) ) else skip )  ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try {
      BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
      String[] x=bf.readLine().trim().split(" ");
      int a=Integer.parseInt(x[0]);
      int b=Integer.parseInt(x[1]);
      int c=a-b*2 ;
      if(c<0)c=0 ;
      System.out.println(c);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var x : Sequence(String) ; x := bf.readLine()->trim()->split(" ") ;
    var a : int ; a := (x[0+1])->toInteger() ;
    var b : int ; b := (x[1+1])->toInteger() ;
    var c : int ; c := a - b * 2 ;
    if (c < 0) then     c := 0 ; else skip ; 
    OclFile["System.out"].println(c) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int FindSubarray(int arr[],int n,int k){
    int[] count_one=new int[n];
    for(int i=0 ; i<n ; i++){
      count_one[i]=Integer.bitCount(arr[i]);
    }
    int sum=count_one[0];
    if(n==1){
      if(count_one[0]>=k)return 1 ;
      else return-1 ;
    }
    int ans=Integer.MAX_VALUE ;
    int i=1 ;
    int j=0 ;
    while(i<n){
      if(k==count_one[j]){
        ans=1 ;
        break ;
      }
      else if(k==count_one[i]){
        ans=1 ;
        break ;
      }
      else if(sum+count_one[i]<k){
        sum+=count_one[i];
        i++;
      }
      else if(sum+count_one[i]>k){
        ans=Math.min(ans,(i-j)+1);
        sum-=count_one[j];
        j++;
      }
      else if(sum+count_one[i]==k){
        ans=Math.min(ans,(i-j)+1);
        sum+=count_one[i];
        i++;
      }
    }
    if(ans!=Integer.MAX_VALUE)return ans ;
    else return-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,4,8 };
      int n=arr.length ;
      int k=2 ;
      System.out.println(FindSubarray(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation FindSubarray( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var count_one : Sequence(int) ; count_one := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     count_one[i+1] := bitCount(arr[i+1]) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := count_one[0+1] ;
    if (n = 1) then (     if (count_one[0+1] >= k) then     return 1 else     return -1 ) else skip ; 
    var ans : int ; ans := 2147483647 ;
    var i : int ; i := 1 ;
    var j : int ; j := 0 ;
    while (i < n) do (     if (k = count_one[j+1]) then (     ans := 1 ; 
     break ) else     if (k = count_one[i+1]) then (     ans := 1 ; 
     break ) else     if (sum + count_one[i+1] < k) then (     sum := sum+(count_one[i+1]) ; 
     i := i + 1 ) else     if (sum + count_one[i+1] > k) then (     ans := Set{ans, (i - j) + 1}->min() ; 
     sum := sum-(count_one[j+1]) ; 
     j := j + 1 ) else     if (sum + count_one[i+1] = k) then (     ans := Set{ans, (i - j) + 1}->min() ; 
     sum := sum+(count_one[i+1]) ; 
     i := i + 1 ) else skip ; ;  ;  ;  ) ; 
    if (ans /= 2147483647) then     return ans else     return -1 ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,4,8} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(FindSubarray(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void Loss(int SP,int P){
    float loss=0 ;
    loss=(float)(2*P*P*SP)/(100*100-P*P);
    System.out.println("Loss="+loss);
  }
  public static void main(String[] args){
    int SP=2400,P=30 ;
    Loss(SP,P);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Loss( SP : int, P : int) : void
  pre: true
  post: true
  activity: (     var loss : double ; loss := 0 ;
     loss := (2 * P * P * SP)->oclAsType(double) / (100 * 100 - P * P) ; 
     OclFile["System.out"].println("Loss=" + loss) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var SP : int ; SP := 2400 ;
    var P : int ; P := 30 ;
     execute Loss(SP, P) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
import java.lang.Integer ;
import java.lang.StringBuilder ;
import java.lang.Math ;
public class Main {
  private static int[] S ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    S=new int[3];
    for(int i=0 ; i<3 ; i++){
      S[i]=in.nextInt();
    }
    if(S[0]+S[1]==S[2] || S[0]==S[1]+S[2] || S[0]+S[2]==S[1]){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute S : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     S := Integer.subrange(1,3)->collect(0) ; 
         var i : int ; i := 0 ; while i < 3 do ( (     S[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     if (S[0+1] + S[1+1] = S[2+1] or S[0+1] = S[1+1] + S[2+1] or S[0+1] + S[2+1] = S[1+1]) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),m=in.nextInt(),x=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<m ; i++){
      a[in.nextInt()]=1 ;
    }
    int ans1=0,ans2=0 ;
    for(int i=x ; i>0 ; i--){
      ans1+=a[i];
    }
    for(int i=x ; i<n ; i++){
      ans2+=a[i];
    }
    System.out.println(Math.min(ans1,ans2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     a[in.getCurrent()->toInteger()+1] := 1 )  ;     i := i + 1 ) ; 
    var ans1 : int ; ans1 := 0 ;
    var ans2 : int ; ans2 := 0 ;
        var i : int ; i := x ; while i > 0 do ( (     ans1 := ans1+(a[i+1]) )  ;     i := i - 1 ) ; 
        var i : int ; i := x ; while i < n do ( (     ans2 := ans2+(a[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{ans1, ans2}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s1=sc.nextLine();
    String[] sr1=s1.split(" ");
    int n=Integer.parseInt(sr1[0]);
    int m=Integer.parseInt(sr1[1]);
    int x=Integer.parseInt(sr1[2]);
    String s2=sc.nextLine();
    String[] sr2=s2.split(" ");
    int count1=0 ;
    for(int i=x ; i<=n ; i++){
      for(int j=0 ; j<m ; j++){
        if(i==Integer.parseInt(sr2[j]))count1++;
      }
    }
    int count2=0 ;
    for(int i=x ; i>=0 ; i--){
      for(int j=0 ; j<m ; j++){
        if(i==Integer.parseInt(sr2[j]))count2++;
      }
    }
    if(count1<=count2){
      System.out.println(count1);
    }
    else {
      System.out.println(count2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := sc.nextLine() ;
    var sr1 : Sequence(String) ; sr1 := s1->split(" ") ;
    var n : int ; n := (sr1[0+1])->toInteger() ;
    var m : int ; m := (sr1[1+1])->toInteger() ;
    var x : int ; x := (sr1[2+1])->toInteger() ;
    var s2 : String ; s2 := sc.nextLine() ;
    var sr2 : Sequence(String) ; sr2 := s2->split(" ") ;
    var count1 : int ; count1 := 0 ;
        var i : int ; i := x ; while i <= n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (i = (sr2[j+1])->toInteger()) then     count1 := count1 + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count2 : int ; count2 := 0 ;
        var i : int ; i := x ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < m do ( (     if (i = (sr2[j+1])->toInteger()) then     count2 := count2 + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    if (count1 <= count2) then (     OclFile["System.out"].println(count1) ) else (     OclFile["System.out"].println(count2) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s[]=br.readLine().split(" ");
    int n=Integer.parseInt(s[0]);
    int m=Integer.parseInt(s[1]);
    int x=Integer.parseInt(s[2]);
    int arr[]=new int[m];
    String s1[]=br.readLine().split(" ");
    for(int i=0 ; i<s1.length ; i++){
      arr[i]=Integer.parseInt(s1[i]);
    }
    int res=0 ;
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]<x){
        res++;
      }
      else {
        break ;
      }
    }
    System.out.println(Math.min(res,m-res));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
    var n : int ; n := (s[0+1])->toInteger() ;
    var m : int ; m := (s[1+1])->toInteger() ;
    var x : int ; x := (s[2+1])->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,m)->collect(0) ;
    var s1 : Sequence(String) ; s1 := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < s1->size() do ( (     arr[i+1] := (s1[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] < x) then (     res := res + 1 ) else (     break ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{res, m - res}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.BigInteger ;
public class Main {
  static long[] list=new long[87];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String[] s=sc.nextLine().split(" ");
    int N=Integer.parseInt(s[0]);
    int M=Integer.parseInt(s[1]);
    int X=Integer.parseInt(s[2]);
    int[] num=new int[N+1];
    String[] te=sc.nextLine().split(" ");
    for(int i=1 ; i<=M ; i++){
      int temp=Integer.parseInt(te[i-1]);
      num[temp]=1 ;
    }
    int count=0 ;
    int count2=0 ;
    for(int i=Math.min(X,N); i<=Math.max(X,N); i++){
      count+=num[i];
    }
    for(int i=0 ; i<=X ; i++){
      count2+=num[i];
    }
    System.out.println(Math.min(count,count2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute list : Sequence(long) := Integer.subrange(1,87)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc.nextLine()->split(" ") ;
    var N : int ; N := (s[0+1])->toInteger() ;
    var M : int ; M := (s[1+1])->toInteger() ;
    var X : int ; X := (s[2+1])->toInteger() ;
    var num : Sequence(int) ; num := Integer.subrange(1,N + 1)->collect(0) ;
    var te : Sequence(String) ; te := sc.nextLine()->split(" ") ;
        var i : int ; i := 1 ; while i <= M do ( (     var temp : int ; temp := (te[i - 1+1])->toInteger() ;
     num[temp+1] := 1 )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var count2 : int ; count2 := 0 ;
        var i : int ; i := Set{X, N}->min() ; while i <= Set{X, N}->max() do ( (     count := count+(num[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= X do ( (     count2 := count2+(num[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{count, count2}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.IOException ;
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Deque ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int X=sc.nextInt();
    int sum_l=0 ;
    int sum_r=0 ;
    for(int i=0 ; i<M ; i++){
      int A=sc.nextInt();
      if(A<X)sum_l++;
      else sum_r++;
    }
    System.out.println(Math.min(sum_l,sum_r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var X : int ; X := sc.getCurrent()->toInteger() ;
    var sum_l : int ; sum_l := 0 ;
    var sum_r : int ; sum_r := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     var A : int ; A := sc.getCurrent()->toInteger() ;
     if (A < X) then     sum_l := sum_l + 1 ; else     sum_r := sum_r + 1 ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{sum_l, sum_r}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1138_SushiForTwo {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int len=1,prev=0,oneSeq=0,twoSeq=0 ;
    while(n-->0){
      byte x=scanner.nextByte();
      if(x==1){
        if(prev==1){
          oneSeq++;
        }
        else {
          oneSeq=1 ;
        }
        prev=1 ;
      }
      else {
        if(prev==2){
          twoSeq++;
        }
        else {
          twoSeq=1 ;
        }
        prev=2 ;
      }
      if(Math.min(oneSeq,twoSeq)>len)len=Math.min(oneSeq,twoSeq);
    }
    System.out.println(len*2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1138_SushiForTwo {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var len : int ; len := 1 ;
    var prev : int ; prev := 0 ;
    var oneSeq : int ; oneSeq := 0 ;
    var twoSeq : int ; twoSeq := 0 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var x : int ; x := scanner.nextByte() ;
     if (x = 1) then (     if (prev = 1) then (     oneSeq := oneSeq + 1 ) else (     oneSeq := 1 ) ;  
     prev := 1 ) else (     if (prev = 2) then (     twoSeq := twoSeq + 1 ) else (     twoSeq := 1 ) ;  
     prev := 2 ) ;  
     if (Set{oneSeq, twoSeq}->min() > len) then     len := Set{oneSeq, twoSeq}->min() ; else skip ) ;  ) ;  
    OclFile["System.out"].println(len * 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MainClass {
  public static void main(String[] agrs){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] lst=new int[n];
    for(int i=0 ; i<n ; i++)lst[i]=sc.nextInt();
    int x=0 ;
    int cnt1=0,cnt2=0 ;
    int res=0 ;
    int value=0 ;
    for(int i=0 ; i<n ; i++){
      if(lst[i]!=x){
        if(lst[i]==1){
          if(Math.min(cnt2,value)>res)res=Math.min(cnt2,value);
          cnt1++;
          value=cnt2 ;
          cnt2=0 ;
          x=1 ;
        }
        else {
          if(Math.min(cnt1,value)>res)res=Math.min(cnt1,value);
          cnt2++;
          value=cnt1 ;
          cnt1=0 ;
          x=2 ;
        }
      }
      else {
        if(lst[i]==1)cnt1++;
        else cnt2++;
      }
    }
    if(lst[n-1]==2){
      if(Math.min(cnt2,value)>res)res=Math.min(cnt2,value);
    }
    else {
      if(Math.min(cnt1,value)>res)res=Math.min(cnt1,value);
    }
    System.out.println(res*2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var lst : Sequence(int) ; lst := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     lst[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var x : int ; x := 0 ;
    var cnt1 : int ; cnt1 := 0 ;
    var cnt2 : int ; cnt2 := 0 ;
    var res : int ; res := 0 ;
    var value : int ; value := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (lst[i+1] /= x) then (     if (lst[i+1] = 1) then (     if (Set{cnt2, value}->min() > res) then     res := Set{cnt2, value}->min() ; else skip ; 
     cnt1 := cnt1 + 1 ; 
    value := cnt2 ; 
    cnt2 := 0 ; 
    x := 1 ; 
 ) else (     if (Set{cnt1, value}->min() > res) then     res := Set{cnt1, value}->min() ; else skip ; 
     cnt2 := cnt2 + 1 ; 
    value := cnt1 ; 
    cnt1 := 0 ; 
    x := 2 ; 
 ) ) else (     if (lst[i+1] = 1) then     cnt1 := cnt1 + 1 ; else     cnt2 := cnt2 + 1 ; ) )  ;     i := i + 1 ) ; 
    if (lst[n - 1+1] = 2) then (     if (Set{cnt2, value}->min() > res) then     res := Set{cnt2, value}->min() ; else skip ) else (     if (Set{cnt1, value}->min() > res) then     res := Set{cnt1, value}->min() ; else skip ) ;  
    OclFile["System.out"].println(res * 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] t=new int[n];
    for(int i=0 ; i<t.length ; i++){
      t[i]=sc.nextInt();
    }
    System.out.println(solve(t));
    sc.close();
  }
  static int solve(int[] t){
    int result=0 ;
    int prevCount=0 ;
    int count=1 ;
    for(int i=1 ; i<t.length ; i++){
      if(t[i]==t[i-1]){
        count++;
      }
      else {
        prevCount=count ;
        count=1 ;
      }
      result=Math.max(result,Math.min(prevCount,count)*2);
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < t->size() do ( (     t[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(t)) ; 
    skip ; 
 );
  static   operation solve( t : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var prevCount : int ; prevCount := 0 ;
    var count : int ; count := 1 ;
        var i : int ; i := 1 ; while i < t->size() do ( (     if (t[i+1] = t[i - 1+1]) then (     count := count + 1 ) else (     prevCount := count ; 
     count := 1 ) ;  
     result := Set{result, Set{prevCount, count}->min() * 2}->max() )  ;     i := i + 1 ) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int anser=0 ;
    int[] count=new int[5];
    for(int i=0 ; i<5 ; i++){
      int x=sc.nextInt();
      count[i]+=x ;
      if(count[i]==0){
        anser=i ;
      }
    }
    System.out.println(anser+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var anser : int ; anser := 0 ;
    var count : Sequence(int) ; count := Integer.subrange(1,5)->collect(0) ;
        var i : int ; i := 0 ; while i < 5 do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     count[i+1] := count[i+1]+(x) ; 
     if (count[i+1] = 0) then (     anser := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(anser + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p092 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p092().run());
  }
  private static final int LIMIT=Library.pow(10,7);
  public String run(){
    int count=0 ;
    for(int i=1 ; i<LIMIT ; i++){
      if(isClass89(i))count++;
    }
    return Integer.toString(count);
  }
  private static boolean isClass89(int x){
    while(true){
      switch(x){
        case 1 : return false ;
        case 89 : return true ;
        default : x=nextNumber(x);
      }
    }
  }
  private static int nextNumber(int x){
    int sum=0 ;
    while(x!=0){
      sum+=(x % 10)*(x % 10);
      x/=10 ;
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p092 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p092.newp092().run()) );
  static    attribute LIMIT : int := Library.pow(10, 7);
   operation run() : String
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i < LIMIT do ( (     if (isClass89(i)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return ((count) + "") );
  static   operation isClass89( x : int) : boolean
  pre: true
  post: true
  activity: (     while (true) do ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (x) ; 
       if _switchval = 1 then
     return false 
   else skip ;
       if _switchval = 89 then
     return true 
   else skip ;
       if true then
     x := nextNumber(x) ; 
   else skip ;
 )
 ) );
  static   operation nextNumber( x : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (x /= 0) do (     sum := sum+((x mod 10) * (x mod 10)) ; 
     x := x/(10) ) ; 
     return sum );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String in=br.readLine();
      String chr[]=in.split(" ");
      int a=Integer.parseInt(chr[0]);
      int b=Integer.parseInt(chr[1]);
      int c=Integer.parseInt(chr[2]);
      int x=Math.max((Math.max(a,b)),c);
      int y=Math.min((Math.min(a,b)),c);
      System.out.println(x-y==a || x-y==b || x-y==c ? "Yes" : "No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var in : String ; in := br.readLine() ;
     var chr : Sequence(String) ; chr := in->split(" ") ;
    var a : int ; a := (chr[0+1])->toInteger() ;
    var b : int ; b := (chr[1+1])->toInteger() ;
    var c : int ; c := (chr[2+1])->toInteger() ;
    var x : int ; x := Set{(Set{a, b}->max()), c}->max() ;
    var y : int ; y := Set{(Set{a, b}->min()), c}->min() ;
    OclFile["System.out"].println(if x - y = a or x - y = b or x - y = c then "Yes" else "No" endif) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public void doIt(){
    Scanner sc=new Scanner(System.in);
    int height=sc.nextInt();
    int width=sc.nextInt();
    while(height!=0 || width!=0){
      for(int i=0 ; i<height ; i++){
        for(int j=0 ; j<width ; j++){
          if(i==0 || i==height-1 || j==0 || j==width-1){
            System.out.print("#");
          }
          else {
            System.out.print(".");
          }
        }
        System.out.println("");
      }
      System.out.println("");
      height=sc.nextInt();
      width=sc.nextInt();
    }
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var height : int ; height := sc.getCurrent()->toInteger() ;
     var width : int ; width := sc.getCurrent()->toInteger() ;
     while (height /= 0 or width /= 0) do (         var i : int ; i := 0 ; while i < height do ( (         var j : int ; j := 0 ; while j < width do ( (     if (i = 0 or i = height - 1 or j = 0 or j = width - 1) then (     OclFile["System.out"].print("#") ) else (     OclFile["System.out"].print(".") ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("") ; 
     height := sc.getCurrent()->toInteger() ; 
     width := sc.getCurrent()->toInteger() ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    ArrayList<String>list=new ArrayList<String>();
    String str ;
    int a,b ;
    try {
      for(; ; ){
        str=br.readLine();
        if(str.equals("0 0")){
          break ;
        }
        list.add(str);
      }
      for(int i=0 ; i<list.size(); i++){
        a=Integer.parseInt((String)list.get(i).substring(0,list.get(i).indexOf(" ")));
        b=Integer.parseInt((String)list.get(i).substring(list.get(i).indexOf(" ")+1,list.get(i).length()));
        for(int h=0 ; h<a ; h++){
          for(int w=0 ; w<b ; w++){
            if(h==0 || h==a-1 || w==0 || w==b-1){
              System.out.print("#");
            }
            else {
              System.out.print(".");
            }
          }
          System.out.println();
        }
        System.out.println();
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var list : Sequence(String) ; list := Sequence{} ;
    var str : String ;
    var a : int ;
    var b : int ;
    try (       while true do ( (     str := br.readLine() ; 
     if (str = "0 0") then (     break ) else skip ; 
     list := list->including(str) )  ) ; 
         var i : int ; i := 0 ; while i < list->size() do ( (     a := (list->at(i+1).subrange(0+1,list->at(i+1)->indexOf(" ")-1)->oclAsType(String))->toInteger() ; 
     b := (list->at(i+1).subrange(list->at(i+1)->indexOf(" ")-1 + 1+1,list->at(i+1)->size())->oclAsType(String))->toInteger() ; 
         var h : int ; h := 0 ; while h < a do ( (         var w : int ; w := 0 ; while w < b do ( (     if (h = 0 or h = (a)->char2byte() - 1 or w = 0 or w = (b)->char2byte() - 1) then (     OclFile["System.out"].print("#") ) else (     OclFile["System.out"].print(".") ) )  ;     w := w + 1 ) ; 
     OclFile["System.out"].println() )  ;     h := h + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  private Scanner sc ;
  private ArrayList<Integer>height ;
  private ArrayList<Integer>width ;
  Main(){
    sc=new Scanner(System.in);
    height=new ArrayList<Integer>();
    width=new ArrayList<Integer>();
  }
  public static void main(String[] args){
    Main printFrame=new Main();
    printFrame.getInput();
    printFrame.drawAllRectangle();
  }
  private void getInput(){
    while(sc.hasNextLine()){
      int h=sc.nextInt();
      int w=sc.nextInt();
      if(!((h==0)&&(w==0))){
        height.add(h);
        width.add(w);
      }
      else {
        break ;
      }
    }
  }
  private boolean isEdge(int x,int y,int index){
    if(x==0 || x==(height.get(index)-1)){
      return true ;
    }
    else if(y==0 || y==(width.get(index)-1)){
      return true ;
    }
    else {
      return false ;
    }
  }
  private String selectLetter(int x,int y,int index){
    if(isEdge(x,y,index)){
      return "#" ;
    }
    else {
      return "." ;
    }
  }
  private void drawRectangle(int index){
    int h=height.get(index);
    int w=width.get(index);
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        System.out.printf(selectLetter(i,j,index));
      }
      System.out.println();
    }
    System.out.println();
  }
  private void drawAllRectangle(){
    int sumRectangle=height.size();
    if(sumRectangle==width.size()){
      for(int i=0 ; i<sumRectangle ; i++){
        drawRectangle(i);
      }
    }
    else {
      System.out.println("aa aa");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute height : Sequence(int);
   attribute width : Sequence(int);
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     height := Sequence{} ; 
     width := Sequence{} );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var printFrame : Main ; printFrame := Main.newMain() ;
     printFrame.getInput() ; 
     printFrame.drawAllRectangle() );
   operation getInput() : void
  pre: true
  post: true
  activity: (     while (sc.hasNextLine()) do (     var h : int ; h := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
     if (not(((h = 0) & (w = 0)))) then (     height := height->including(h) ; 
     width := width->including(w) ) else (     break ) ) );
   operation isEdge( x : int, y : int, index : int) : boolean
  pre: true
  post: true
  activity: (     if (x = 0 or x = (height->at(index+1) - 1)) then (     return true ) else     if (y = 0 or y = (width->at(index+1) - 1)) then (     return true ) else (     return false ) ;  );
   operation selectLetter( x : int, y : int, index : int) : String
  pre: true
  post: true
  activity: (     if (isEdge(x, y, index)) then (     return "#" ) else (     return "." ) );
   operation drawRectangle( index : int) : void
  pre: true
  post: true
  activity: (     var h : int ; h := height->at(index+1) ;
     var w : int ; w := width->at(index+1) ;
         var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     OclFile["System.out"].printf(selectLetter(i, j, index)) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
   operation drawAllRectangle() : void
  pre: true
  post: true
  activity: (     var sumRectangle : int ; sumRectangle := height->size() ;
     if (sumRectangle = width->size()) then (         var i : int ; i := 0 ; while i < sumRectangle do ( (     execute drawRectangle(i) )  ;     i := i + 1 ) ) else (     OclFile["System.out"].println("aa aa") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    List<Integer>listH=new ArrayList<>();
    List<Integer>listW=new ArrayList<>();
    listH.add(Integer.MIN_VALUE);
    listW.add(Integer.MIN_VALUE);
    int cnt=0 ;
    while(listH.get(cnt)!=0 || listW.get(cnt)!=0){
      listH.add(sc.nextInt());
      listW.add(sc.nextInt());
      if(listH.get(cnt)==0 && listW.get(cnt)==0){
        break ;
      }
      cnt++;
    }
    for(int i=1 ; i<listH.size()-1 ; i++){
      for(int j=0 ; j<listH.get(i); j++){
        for(int k=0 ; k<listW.get(i); k++){
          if(j==0 || j==listH.get(i)-1){
            System.out.print("#");
          }
          else if(k==0 || k==listW.get(i)-1){
            System.out.print("#");
          }
          else {
            System.out.print(".");
          }
        }
        System.out.println();
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var listH : Sequence(int) ; listH := Sequence{} ;
    var listW : Sequence(int) ; listW := Sequence{} ;
    listH := listH->including(-2147483648) ; 
    listW := listW->including(-2147483648) ; 
    var cnt : int ; cnt := 0 ;
    while (listH->at(cnt+1) /= 0 or listW->at(cnt+1) /= 0) do (     listH := listH->including(sc.getCurrent()->toInteger()) ; 
     listW := listW->including(sc.getCurrent()->toInteger()) ; 
     if (listH->at(cnt+1) = 0 & listW->at(cnt+1) = 0) then (     break ) else skip ; 
     cnt := cnt + 1 ) ; 
        var i : int ; i := 1 ; while i < listH->size() - 1 do ( (         var j : int ; j := 0 ; while j < listH->at(i+1) do ( (         var k : int ; k := 0 ; while k < listW->at(i+1) do ( (     if (j = 0 or j = listH->at(i+1) - 1) then (     OclFile["System.out"].print("#") ) else     if (k = 0 or k = listW->at(i+1) - 1) then (     OclFile["System.out"].print("#") ) else (     OclFile["System.out"].print(".") ) ;  )  ;     k := k + 1 ) ; 
     OclFile["System.out"].println() )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String[] in=br.readLine().split(" ");
      int H=Integer.parseInt(in[0]),W=Integer.parseInt(in[1]);
      if(H==0 & W==0)break ;
      StringBuilder sb=new StringBuilder();
      for(int i=0 ; i<H ; i++){
        for(int j=0 ; j<W ; j++)sb.append((i==0 || j==0 || i==H-1 || j==W-1)? '#' : '.');
        sb.append(System.getProperty("line.separator"));
      }
      System.out.println(sb);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var in : Sequence(String) ; in := br.readLine()->split(" ") ;
     var H : int ; H := (in[0+1])->toInteger() ;
    var W : int ; W := (in[1+1])->toInteger() ;
    if (H = 0 & W = 0) then     break else skip ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do (     sb := sb + StringLib.newString(if (i = 0 or j = 0 or i = H - 1 or j = W - 1) then '#' else '.' endif) ;  ;     j := j + 1 ) ; 
     sb := sb + StringLib.newString(OclProcess.getEnvironmentProperty("line.separator")) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int fact(int n){
    int fact=1 ;
    for(int i=1 ; i<=n ; i++)fact*=i ;
    return fact ;
  }
  static int countStrings(String str,int n){
    Set<Character>distinct_char=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      distinct_char.add(str.charAt(i));
    }
    return fact(distinct_char.size());
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    int n=str.length();
    System.out.println(countStrings(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fact( n : int) : int
  pre: true
  post: true
  activity: (     var fact : int ; fact := 1 ;
         var i : int ; i := 1 ; while i <= n do (     fact := fact*(i) ;  ;     i := i + 1 ) ; 
     return fact );
  static   operation countStrings( str : String, n : int) : int
  pre: true
  post: true
  activity: (     var distinct_char : Set(String) ; distinct_char := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     distinct_char := distinct_char->including(str->at(i+1)) )  ;     i := i + 1 ) ; 
     return fact(distinct_char->size()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].println(countStrings(str, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int M=4 ;
  static int N=5 ;
  static void printCommonElements(int mat[][]){
    Map<Integer,Integer>mp=new HashMap<>();
    for(int j=0 ; j<N ; j++)mp.put(mat[0][j],1);
    for(int i=1 ; i<M ; i++){
      for(int j=0 ; j<N ; j++){
        if(mp.get(mat[i][j])!=null && mp.get(mat[i][j])==i){
          mp.put(mat[i][j],i+1);
          if(i==M-1)System.out.print(mat[i][j]+" ");
        }
      }
    }
  }
  public static void main(String[] args){
    int mat[][]={
      {
        1,2,1,4,8 },{
          3,7,8,5,1 },{
            8,7,7,3,1 },{
              8,1,2,7,9 },};
              printCommonElements(mat);
            }
          }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute M : int := 4;
  static   attribute N : int := 5;
  static   operation printCommonElements( mat : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var j : int ; j := 0 ; while j < N do (     mp := mp->union(Map{mat[0+1][j+1] |-> 1}) ;  ;     j := j + 1 ) ; 
         var i : int ; i := 1 ; while i < M do ( (         var j : int ; j := 0 ; while j < N do ( (     if (mp->at(mat[i+1][j+1]) /= null & mp->at(mat[i+1][j+1]) = i) then (     mp := mp->union(Map{mat[i+1][j+1] |-> i + 1}) ; 
     if (i = M - 1) then     OclFile["System.out"].print(mat[i+1][j+1] + " ") ; else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,2,1,4,8},Sequence{3,7,8,5,1},Sequence{8,7,7,3,1},Sequence{8,1,2,7,9},} ;
     execute printCommonElements(mat) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.StringTokenizer ;
public class AntonAndLines {
  static double eps=10e-9 ;
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    StringTokenizer st=new StringTokenizer(br.readLine());
    double start=Double.parseDouble(st.nextToken());
    double end=Double.parseDouble(st.nextToken());
    ArrayList<Pair>first=new ArrayList<Pair>();
    ArrayList<Pair>second=new ArrayList<Pair>();
    for(int i=0 ; i<n ; i++){
      st=new StringTokenizer(br.readLine());
      double a=Double.parseDouble(st.nextToken());
      double b=Double.parseDouble(st.nextToken());
      double y1=a*(start+eps)+b ;
      double y2=a*(end-eps)+b ;
      first.add(new Pair(i+1,y1,y2));
      second.add(new Pair(i+1,y2,y1));
    }
    Collections.sort(first);
    Collections.sort(second);
    for(int i=0 ; i<first.size(); i++){
      if(first.get(i).id!=second.get(i).id){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
  static class Pair implements Comparable<Pair>{
    double x1,x2 ;
    int id ;
    public Pair(int i,double a,double b){
      x1=a ;
      x2=b ;
      id=i ;
    }
    @ Override public int compareTo(Pair o){
      return((Double)this.x1).compareTo(o.x1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AntonAndLines {
  static   attribute eps : double := 10e-9;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var start : double ; start := (st.next())->toReal() ;
    var end : double ; end := (st.next())->toReal() ;
    var first : Sequence(Map) ; first := Sequence{} ;
    var second : Sequence(Map) ; second := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var a : double ; a := (st.next())->toReal() ;
    var b : double ; b := (st.next())->toReal() ;
    var y1 : double ; y1 := a * (start + eps) + b ;
    var y2 : double ; y2 := a * (end - eps) + b ;
    first := first->including(Map(i + 1, y1, y2)) ; 
    second := second->including(Map(i + 1, y2, y1)) ; 
 )  ;     i := i + 1 ) ; 
    first := first->sort() ; 
    second := second->sort() ; 
        var i : int ; i := 0 ; while i < first->size() do ( (     if (first->at(i+1).id /= second->at(i+1).id) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
  static class Pair implements Comparable<Map> {
   attribute x1 : double;
   attribute id : int;
   static operation newPair( i : int, a : double, b : double) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(i, a,b);
    return self );
  operation initialise( i : int, a : double, b : double) : void
  pre: true  post: true
  activity: (     x1 := a ; 
     x2 := b ; 
     id := i );
      operation compareTo( o : Map) : int
  pre: true
  post: true
  activity: (     return (self.x1->oclAsType(double))->compareTo(o.x1) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    int[] s=new int[n];
    int[] d=new int[n];
    for(int i=0 ; i<n ; i++){
      s[i]=sc.nextInt();
      d[i]=sc.nextInt();
    }
    System.out.println(solve(s,d,t));
    sc.close();
  }
  static int solve(int[] s,int[] d,int t){
    int minTime=Integer.MAX_VALUE ;
    int result=-1 ;
    for(int i=0 ; i<s.length ; i++){
      int time=divideToCeil(t-s[i],d[i])*d[i]+s[i];
      if(time<minTime){
        minTime=time ;
        result=i+1 ;
      }
    }
    return result ;
  }
  static int divideToCeil(int x,int y){
    if(x<0){
      return 0 ;
    }
    return x/y+(x % y==0 ? 0 : 1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := sc.getCurrent()->toInteger() ; 
     d[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(s, d, t)) ; 
    skip ; 
 );
  static   operation solve( s : Sequence(int), d : Sequence(int), t : int) : int
  pre: true
  post: true
  activity: (     var minTime : int ; minTime := 2147483647 ;
     var result : int ; result := -1 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     var time : int ; time := divideToCeil(t - s[i+1], d[i+1]) * d[i+1] + s[i+1] ;
     if (time < minTime) then (     minTime := time ; 
     result := i + 1 ) else skip )  ;     i := i + 1 ) ; 
     return result );
  static   operation divideToCeil( x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (x < 0) then (     return 0 ) else skip ; 
     return x / y + (if x mod y = 0 then 0 else 1 endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.awt.geom.Point2D ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    for(int i=0 ; i<n ; i++){
      String[] tmpArray=br.readLine().split(" ");
      Point2D[] points=new Point2D[4];
      for(int j=0 ; j<4 ; j++){
        int x=Integer.parseInt(tmpArray[j*2]);
        int y=Integer.parseInt(tmpArray[j*2+1]);
        points[j]=new Point2D.Double(x,y);
      }
      Line2D[] lines=new Line2D[2];
      for(int j=0 ; j<2 ; j++){
        lines[j]=new Line2D.Double(points[j*2],points[j*2+1]);
      }
      double result=distance(lines[0],lines[1]);
      System.out.printf("%.8f\n",result);
    }
  }
  static double distance(Line2D l1,Line2D l2){
    if(l1.intersectsLine(l2)){
      return 0 ;
    }
    else {
      return Math.min(Math.min(l2.ptSegDist(l1.getP1()),l2.ptSegDist(l1.getP2())),Math.min(l1.ptSegDist(l2.getP1()),l1.ptSegDist(l2.getP2())));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
     var points : Sequence(Point2D) ; points := Integer.subrange(1,4)->collect(null) ;
        var j : int ; j := 0 ; while j < 4 do ( (     var x : int ; x := (tmpArray[j * 2+1])->toInteger() ;
     var y : int ; y := (tmpArray[j * 2 + 1+1])->toInteger() ;
     points[j+1] := Double.newDouble(x, y) )  ;     j := j + 1 ) ; 
    var lines : Sequence(Line2D) ; lines := Integer.subrange(1,2)->collect(null) ;
        var j : int ; j := 0 ; while j < 2 do ( (     lines[j+1] := Double.newDouble(points[j * 2+1], points[j * 2 + 1+1]) )  ;     j := j + 1 ) ; 
    var result : double ; result := distance(lines[0+1], lines[1+1]) ;
    OclFile["System.out"].printf("%.8f\n", result) ; 
 )  ;     i := i + 1 ) );
  static   operation distance( l1 : Line2D, l2 : Line2D) : double
  pre: true
  post: true
  activity: (     if (l1.intersectsLine(l2)) then (     return 0 ) else (     return Set{Set{l2.ptSegDist(l1.getP1()), l2.ptSegDist(l1.getP2())}->min(), Set{l1.ptSegDist(l2.getP1()), l1.ptSegDist(l2.getP2())}->min()}->min() ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    if((a+c)==b){
      System.out.println("Yes");
    }
    else if((a+b)==c){
      System.out.println("Yes");
    }
    else if((b+c)==a){
      System.out.println("Yes");
    }
    else if((a+b)<c){
      System.out.println("No");
    }
    else if((a+c)<b){
      System.out.println("No");
    }
    else if((b+c)<a){
      System.out.println("No");
    }
    else if((a+b)>c){
      System.out.println("No");
    }
    else if((b+c)>a){
      System.out.println("No");
    }
    else if((a+c)>b){
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    if ((a + c) = b) then (     OclFile["System.out"].println("Yes") ) else     if ((a + b) = c) then (     OclFile["System.out"].println("Yes") ) else     if ((b + c) = a) then (     OclFile["System.out"].println("Yes") ) else     if ((a + b) < c) then (     OclFile["System.out"].println("No") ) else     if ((a + c) < b) then (     OclFile["System.out"].println("No") ) else     if ((b + c) < a) then (     OclFile["System.out"].println("No") ) else     if ((a + b) > c) then (     OclFile["System.out"].println("No") ) else     if ((b + c) > a) then (     OclFile["System.out"].println("No") ) else     if ((a + c) > b) then (     OclFile["System.out"].println("No") ) else skip ; ;  ;  ;  ;  ;  ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.PrintWriter ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new java.io.InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    String[] input_array=br.readLine().split(" ");
    int result=0 ;
    for(String str : input_array){
      result+=1 ;
      if("0".equals(str))break ;
    }
    pw.println(result);
    br.close();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(InputStreamReader.newInputStreamReader(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var input_array : Sequence(String) ; input_array := br.readLine()->split(" ") ;
    var result : int ; result := 0 ;
    for (str : input_array) do ( (     result := result+(1) ; 
     if ("0" = str) then     break else skip )  ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A_Serval_and_Bus {
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  public static void main(String args[])throws IOException {
    FastScanner fs=new FastScanner();
    int n=fs.nextInt();
    int t=fs.nextInt();
    long[][] buses=new long[n][2];
    for(int i=0 ; i<n ; ++i){
      int x=fs.nextInt();
      int y=fs.nextInt();
      buses[i][0]=(long)x ;
      buses[i][1]=(long)y ;
    }
    for(int i=0 ; i<n ; ++i){
      if(t>buses[i][0]){
        long temp=t-buses[i][0];
        buses[i][0]+=Math.ceil((double)temp/buses[i][1])*buses[i][1];
      }
    }
    long min=999999999 ;
    int ans=0 ;
    for(int j=0 ; j<n ; ++j){
      if(buses[j][0]<min){
        min=buses[j][0];
        ans=j+1 ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Serval_and_Bus {
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var n : int ; n := fs.nextInt() ;
    var t : int ; t := fs.nextInt() ;
    var buses : Sequence(Sequence(long)) ; buses := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := fs.nextInt() ;
     var y : int ; y := fs.nextInt() ;
     buses[i+1][0+1] := x->oclAsType(long) ; 
     buses[i+1][1+1] := y->oclAsType(long) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (t > buses[i+1][0+1]) then (     var temp : long ; temp := t - buses[i+1][0+1] ;
     buses[i+1][0+1] := buses[i+1][0+1]+((temp->oclAsType(double) / buses[i+1][1+1])->ceil() * buses[i+1][1+1]) ) else skip )  ;     i := i + 1 ) ; 
    var min : long ; min := 999999999 ;
    var ans : int ; ans := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     if (buses[j+1][0+1] < min) then (     min := buses[j+1][0+1] ; 
     ans := j + 1 ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A_Serval_and_Bus {
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  public static void main(String args[])throws IOException {
    FastScanner fs=new FastScanner();
    int n=fs.nextInt();
    int t=fs.nextInt();
    long[][] buses=new long[n][2];
    for(int i=0 ; i<n ; ++i){
      int x=fs.nextInt();
      int y=fs.nextInt();
      buses[i][0]=(long)x ;
      buses[i][1]=(long)y ;
    }
    while(true){
      boolean change=false ;
      for(int i=0 ; i<n ; ++i){
        if(t>buses[i][0]){
          change=true ;
          buses[i][0]+=buses[i][1];
        }
      }
      if(! change){
        long min=999999999 ;
        int ans=0 ;
        for(int j=0 ; j<n ; ++j){
          if(buses[j][0]<min){
            min=buses[j][0];
            ans=j+1 ;
          }
        }
        System.out.println(ans);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Serval_and_Bus {
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var n : int ; n := fs.nextInt() ;
    var t : int ; t := fs.nextInt() ;
    var buses : Sequence(Sequence(long)) ; buses := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := fs.nextInt() ;
     var y : int ; y := fs.nextInt() ;
     buses[i+1][0+1] := x->oclAsType(long) ; 
     buses[i+1][1+1] := y->oclAsType(long) )  ;     i := i + 1 ) ; 
    while (true) do (     var change : boolean ; change := false ;
         var i : int ; i := 0 ; while i < n do ( (     if (t > buses[i+1][0+1]) then (     change := true ; 
     buses[i+1][0+1] := buses[i+1][0+1]+(buses[i+1][1+1]) ) else skip )  ;     i := i + 1 ) ; 
     if (not(change)) then (     var min : long ; min := 999999999 ;
     var ans : int ; ans := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     if (buses[j+1][0+1] < min) then (     min := buses[j+1][0+1] ; 
     ans := j + 1 ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    break 
 ) else skip ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float sumOfAP(float a,float d,int n){
    float sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum=sum+a ;
      a=a+d ;
    }
    return sum ;
  }
  public static void main(String args[]){
    int n=20 ;
    float a=2.5f,d=1.5f ;
    System.out.println(sumOfAP(a,d,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumOfAP( a : double, d : double, n : int) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum + a ; 
     a := a + d )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 20 ;
     var a : double ; a := 2.5f ;
    var d : double ; d := 1.5f ;
     OclFile["System.out"].println(sumOfAP(a, d, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void find3Numbers(int arr[],int n){
    int small=+2147483647,large=+2147483647 ;
    int i ;
    for(i=0 ; i<n ; i++){
      if(arr[i]<=small)small=arr[i];
      else if(arr[i]<=large)large=arr[i];
      else break ;
    }
    if(i==n){
      System.out.print("No such triplet found");
      return ;
    }
    for(int j=0 ; j<=i ; j++){
      if(arr[j]<large){
        small=arr[j];
        break ;
      }
    }
    System.out.print(small+" "+large+" "+arr[i]);
    return ;
  }
  public static void main(String arg[]){
    int arr[]={
      5,7,4,8 };
      int n=arr.length ;
      find3Numbers(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find3Numbers( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var small : int ; small := 2147483647 ;
    var large : int ; large := 2147483647 ;
     var i : int ;
        i := 0 ; while i < n do ( (     if (arr[i+1] <= small) then     small := arr[i+1] ; else     if (arr[i+1] <= large) then     large := arr[i+1] else     break ;  )  ;     i := i + 1 ) ; 
    if (i = n) then (     OclFile["System.out"].print("No such triplet found") ; 
     return ) else skip ; 
        var j : int ; j := 0 ; while j <= i do ( (     if (arr[j+1] < large) then (     small := arr[j+1] ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].print(small + " " + large + " " + arr[i+1]) ; 
    return 
 );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,7,4,8} ;
     var n : int ; n := arr->size() ;
     execute find3Numbers(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int findPairCount(int N,int K){
    int count=0 ;
    int rem[]=new int[K];
    rem[0]=N/K ;
    for(int i=1 ; i<K ; i++)rem[i]=(N-i)/K+1 ;
    if(K % 2==0){
      count+=(rem[0]*(rem[0]-1))/2 ;
      for(int i=1 ; i<K/2 ; i++)count+=rem[i]*rem[K-i];
      count+=(rem[K/2]*(rem[K/2]-1))/2 ;
    }
    else {
      count+=(rem[0]*(rem[0]-1))/2 ;
      for(int i=1 ; i<=K/2 ; i++)count+=rem[i]*rem[K-i];
    }
    return count ;
  }
  public static void main(String[] args){
    int N=10,K=4 ;
    System.out.println(findPairCount(N,K));
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation findPairCount( N : int, K : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var rem : Sequence(int) ; rem := Integer.subrange(1,K)->collect(0) ;
    rem[0+1] := N / K ; 
        var i : int ; i := 1 ; while i < K do (     rem[i+1] := (N - i) / K + 1 ;  ;     i := i + 1 ) ; 
    if (K mod 2 = 0) then (     count := count+((rem[0+1] * (rem[0+1] - 1)) / 2) ; 
         var i : int ; i := 1 ; while i < K / 2 do (     count := count+(rem[i+1] * rem[K - i+1]) ;  ;     i := i + 1 ) ; 
     count := count+((rem[K / 2+1] * (rem[K / 2+1] - 1)) / 2) ) else (     count := count+((rem[0+1] * (rem[0+1] - 1)) / 2) ; 
         var i : int ; i := 1 ; while i <= K / 2 do (     count := count+(rem[i+1] * rem[K - i+1]) ;  ;     i := i + 1 ) ) ;  
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 10 ;
    var K : int ; K := 4 ;
     OclFile["System.out"].println(findPairCount(N, K)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,m ;
    List<Integer>array=new ArrayList<Integer>(20000);
    n=sc.nextInt();
    m=sc.nextInt();
    while(!(n==0 && m==0)){
      array.clear();
      for(int i=0 ; i<n+m ; i++){
        array.add(sc.nextInt());
      }
      Collections.sort(array,Comparator.naturalOrder());
      int interval=0 ;
      int nt=0 ;
      for(int time : array){
        if(time-nt>interval){
          interval=time-nt ;
        }
        nt=time ;
      }
      System.out.println(interval);
      n=sc.nextInt();
      m=sc.nextInt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var m : int ;
    var array : Sequence(int) ; array := Sequence{} ;
    n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
    while (not((n = 0 & m = 0))) do (     array := array->intersection(Set{}) ; 
         var i : int ; i := 0 ; while i < n + m do ( (     array := array->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    array, Comparator.naturalOrder() := array, Comparator.naturalOrder()->sort() ; 
    var interval : int ; interval := 0 ;
    var nt : int ; nt := 0 ;
    for (time : array) do ( (     if (time - nt > interval) then (     interval := time - nt ) else skip ; 
     nt := time )  ) ; 
    OclFile["System.out"].println(interval) ; 
    n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if((n | m)==0)break ;
      int[] a=new int[n+m+1];
      a[0]=0 ;
      for(int i=0 ; i<n ; i++)a[i+1]=sc.nextInt();
      for(int j=0 ; j<m ; j++)a[j+n+1]=sc.nextInt();
      sort(a);
      int max=0 ;
      for(int i=0 ; i<n+m ; i++){
        max=max(max,a[i+1]-a[i]);
      }
      System.out.println(max);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,m)) = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n + m + 1)->collect(0) ;
    a[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do (     a[i + 1+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < m do (     a[j + n + 1+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ; 
    execute sort(a) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n + m do ( (     max := Set{max, a[i + 1+1] - a[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n,m ;
      n=Integer.parseInt(line.substring(0,line.indexOf(' ')));
      m=Integer.parseInt(line.substring(line.indexOf(' ')+1));
      if((n | m)==0)break ;
      int[] times=new int[n+m+1];
      if(n!=0){
        words=br.readLine().split(" ");
        for(int i=0 ; i<n ; i++){
          times[i+1]=parseInt(words[i]);
        }
      }
      if(m!=0){
        words=br.readLine().split(" ");
        for(int i=0 ; i<m ; i++){
          times[i+n+1]=parseInt(words[i]);
        }
      }
      Arrays.sort(times);
      int max=0 ;
      for(int i=1 ; i<times.length ; i++){
        max=Math.max(max,times[i]-times[i-1]);
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ;
    var m : int ;
     n := (line.subrange(0+1,line->indexOf(' ')-1))->toInteger() ; 
    m := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1))->toInteger() ; 
    if ((MathLib.bitwiseOr(n,m)) = 0) then     break else skip ; 
    var times : Sequence(int) ; times := Integer.subrange(1,n + m + 1)->collect(0) ;
    if (n /= 0) then (     words := br.readLine()->split(" ") ; 
         var i : int ; i := 0 ; while i < n do ( (     times[i + 1+1] := (words[i+1] + "")->toInteger() )  ;     i := i + 1 ) ) else skip ; 
    if (m /= 0) then (     words := br.readLine()->split(" ") ; 
         var i : int ; i := 0 ; while i < m do ( (     times[i + n + 1+1] := (words[i+1] + "")->toInteger() )  ;     i := i + 1 ) ) else skip ; 
    times := times->sort() ; 
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i < times->size() do ( (     max := Set{max, times[i+1] - times[i - 1+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  static int __gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static int lcm(int a,int b){
    return(a/__gcd(a,b)*b);
  }
  static int getMinValue(int c){
    int ans=Integer.MAX_VALUE ;
    for(int i=1 ; i<=Math.sqrt(c); i++){
      if(c % i==0 && lcm(i,c/i)==c){
        ans=Math.min(ans,Math.max(i,c/i));
      }
    }
    return ans ;
  }
  public static void main(String args[]){
    int c=6 ;
    System.out.println(getMinValue(c));
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
    if (a = b) then     return a else skip ; 
    if (a > b) then     return __gcd(a - b, b) else skip ; 
    return __gcd(a, b - a) 
 );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return (a / __gcd(a, b) * b) );
  static   operation getMinValue( c : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 2147483647 ;
         var i : int ; i := 1 ; while i <= (c)->sqrt() do ( (     if (c mod i = 0 & lcm(i, c / i) = c) then (     ans := Set{ans, Set{i, c / i}->max()}->min() ) else skip )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var c : int ; c := 6 ;
     OclFile["System.out"].println(getMinValue(c)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A59 {
  static FastScanner sc=new FastScanner();
  public static void main(String[] args){
    solve();
  }
  public static void solve(){
    String str=sc.next();
    int low=0,up=0 ;
    for(int i=0 ; i<str.length(); i++){
      if(Character.isUpperCase(str.charAt(i)))up++;
      else low++;
    }
    if(low>=up)System.out.print(str.toLowerCase());
    else System.out.print(str.toUpperCase());
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A59 {
  static   attribute sc : FastScanner := FastScanner.newFastScanner();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var str : String ; str := sc.next() ;
     var low : int ; low := 0 ;
    var up : int ; up := 0 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if ((str->at(i+1)->toUpperCase() = str->at(i+1))) then     up := up + 1 ; else     low := low + 1 ; )  ;     i := i + 1 ) ; 
     if (low >= up) then     OclFile["System.out"].print(str->toLowerCase()) ; else     OclFile["System.out"].print(str->toUpperCase()) ; );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String[] spl=br.readLine().split(" ");
      int[] num=new int[spl.length];
      for(int i=0 ; i<spl.length ; i++){
        num[i]=Integer.parseInt(spl[i]);
      }
      Arrays.sort(num);
      if(num[0]+num[1]==num[2]){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var spl : Sequence(String) ; spl := br.readLine()->split(" ") ;
     var num : Sequence(int) ; num := Integer.subrange(1,spl->size())->collect(0) ;
        var i : int ; i := 0 ; while i < spl->size() do ( (     num[i+1] := (spl[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    num := num->sort() ; 
    if (num[0+1] + num[1+1] = num[2+1]) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 ))   catch (e : IOException) do (     e.printStackTrace() )
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      while(true){
        String str[]=br.readLine().split(" ");
        if(str[0] .equals("0")&& str[1] .equals("0"))break ;
        int a[];
        a=new int[20001];
        int k=1,num=0 ;
        if(! str[0] .equals("0")){
          String str1[]=br.readLine().split(" ");
          for(int i=0 ; i<str1.length ; i++){
            num=0 ;
            for(int j=0 ; j<str1[i] .length(); j++)num=num*10+str1[i] .charAt(j)-'0' ;
            a[k]=num ;
            k++;
          }
        }
        if(! str[1] .equals("0")){
          String str2[]=br.readLine().split(" ");
          for(int i=0 ; i<str2.length ; i++){
            num=0 ;
            for(int j=0 ; j<str2[i] .length(); j++)num=num*10+str2[i] .charAt(j)-'0' ;
            a[k]=num ;
            k++;
          }
        }
        Arrays.sort(a,0,k);
        int max=0 ;
        for(int i=1 ; i<k ; i++)if(a[i]-a[i-1]>max)max=a[i]-a[i-1];
        System.out.println(max);
      }
    }
    catch(Exception e){
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     while (true) do (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     if (str[0+1] = "0" & str[1+1] = "0") then     break else skip ; 
    var a : Sequence(int) ;
    a := Integer.subrange(1,20001)->collect(0) ; 
    var k : int ; k := 1 ;
    var num : int ; num := 0 ;
    if (not(str[0+1] = "0")) then (     var str1 : Sequence(String) ; str1 := br.readLine()->split(" ") ;
         var i : int ; i := 0 ; while i < str1->size() do ( (     num := 0 ; 
         var j : int ; j := 0 ; while j < str1[i+1]->size() do (     num := num * 10 + str1[i+1]->at(j+1) - ('0')->char2byte() ;  ;     j := j + 1 ) ; 
     a[k+1] := num ; 
     k := k + 1 )  ;     i := i + 1 ) ) else skip ; 
    if (not(str[1+1] = "0")) then (     var str2 : Sequence(String) ; str2 := br.readLine()->split(" ") ;
         var i : int ; i := 0 ; while i < str2->size() do ( (     num := 0 ; 
         var j : int ; j := 0 ; while j < str2[i+1]->size() do (     num := num * 10 + str2[i+1]->at(j+1) - ('0')->char2byte() ;  ;     j := j + 1 ) ; 
     a[k+1] := num ; 
     k := k + 1 )  ;     i := i + 1 ) ) else skip ; 
    a := a.subrange(1,0)^(a.subrange(0+1,k)->sort())^a.subrange(k+1,a.size) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i < k do (     if (a[i+1] - a[(i)->char2byte() - 1+1] > max) then     max := a[i+1] - a[(i)->char2byte() - 1+1] ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) )   catch (e : ProgramException) do (     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.io.UncheckedIOException ;
import java.util.ArrayDeque ;
import java.util.Deque ;
import java.util.regex.Pattern ;
public class Main {
  public void exec(Stdin stdin,PrintWriter stdout){
    int[] x=stdin.nextIntArray(5);
    for(int i=0 ; i<5 ; i++){
      if(x[i]==0){
        stdout.println(i+1);
        return ;
      }
    }
  }
  public static void main(String[] args){
    Stdin stdin=new Stdin();
    PrintWriter stdout=new PrintWriter(System.out,false);
    new Main().exec(stdin,stdout);
    stdout.flush();
  }
  public static class Stdin {
    private BufferedReader stdin ;
    private Deque<String>tokens ;
    private Pattern delim ;
    public Stdin(){
      stdin=new BufferedReader(new InputStreamReader(System.in));
      tokens=new ArrayDeque<>();
      delim=Pattern.compile(" ");
    }
    public String nextString(){
      try {
        if(tokens.isEmpty()){
          String line=stdin.readLine();
          delim.splitAsStream(line).forEach(tokens :: addLast);
        }
        return tokens.pollFirst();
      }
      catch(IOException e){
        throw new UncheckedIOException(e);
      }
    }
    public int nextInt(){
      return Integer.parseInt(nextString());
    }
    public int[] nextIntArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation exec( stdin : Stdin, stdout : OclFile) : void
  pre: true
  post: true
  activity: (     var x : Sequence(int) ; x := stdin.nextIntArray(5) ;
         var i : int ; i := 0 ; while i < 5 do ( (     if (x[i+1] = 0) then (     stdout.println(i + 1) ; 
     return ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : Stdin ; stdin := Stdin.newStdin() ;
     var stdout : OclFile ; stdout := OclFile.newOclFile_Write(OclFile["System.out"], false) ;
     Main.newMain().exec(stdin, stdout) ; 
     skip );
  static class Stdin {
   attribute stdin : OclFile;
   attribute tokens : Sequence(String);
   attribute delim : OclRegex;
   static operation newStdin() : Stdin
  pre: true
  post: true
  activity:
  ( var self : Stdin ;
    self := createStdin();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     stdin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokens := ArrayDeque<OclAny>.newArrayDeque() ; 
     delim := OclRegex.compile(" ") );
   operation nextString() : String
  pre: true
  post: true
  activity: (     try (     if (tokens->isEmpty()) then (     var line : String ; line := stdin.readLine() ;
     for _forEach : delim.splitAsStream(line) do
    (    skip ;) ) else skip ; 
     return tokens->first() )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextString())->toInteger() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    try {
      while(true){
        int n=s.nextInt();
        int m=s.nextInt();
        if(n+m==0)return ;
        int a[]=new int[n+m];
        for(int i=0 ; i<n+m ; i++){
          a[i]=s.nextInt();
        }
        Arrays.sort(a);
        int max=a[0];
        for(int i=n+m-2 ; i>=0 ; i--){
          if(max<a[i+1]-a[i])max=a[i+1]-a[i];
        }
        System.out.println(max);
      }
    }
    catch(Exception e){
      System.err.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     try (     while (true) do (     var n : int ; n := s.getCurrent()->toInteger() ;
     var m : int ; m := s.getCurrent()->toInteger() ;
    if (n + m = 0) then     return else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n + m)->collect(0) ;
        var i : int ; i := 0 ; while i < n + m do ( (     a[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var max : int ; max := a[0+1] ;
        var i : int ; i := n + m - 2 ; while i >= 0 do ( (     if (max < a[i + 1+1] - a[i+1]) then     max := a[i + 1+1] - a[i+1] ; else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) )   catch (e : ProgramException) do (     OclFile["System.err"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<a.length ; i++){
      a[i]=sc.nextInt();
    }
    System.out.println(solve(a)? "YES" : "NO");
    sc.close();
  }
  static boolean solve(int[] a){
    long sum=Arrays.stream(a).asLongStream().sum();
    int max=Arrays.stream(a).max().getAsInt();
    return sum % 2==0 && max*2<=sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if solve(a) then "YES" else "NO" endif) ; 
    skip ; 
 );
  static   operation solve( a : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var sum : long ; sum := stream(a)->sum() ;
     var max : int ; max := stream(a).max().getAsInt() ;
     return sum mod 2 = 0 & max * 2 <= sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class1 {
  public static void main(String args[]){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    PriorityQueue<Long>p=new PriorityQueue<>(Collections.reverseOrder());
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      long temp=input.nextLong();
      p.add(temp);
      sum=sum+temp ;
    }
    int x=0 ;
    if(sum % 2!=0){
      x++;
    }
    else {
      long temp=p.poll();
      sum=sum-temp ;
      if(temp>sum){
        x++;
      }
    }
    if(x==0){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var p : Sequence(long) ; p := Sequence{}->union(reverseOrder()) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : long ; temp := input.getCurrent()->toLong() ;
     p := p->including(temp) ; 
     sum := sum + temp )  ;     i := i + 1 ) ; 
    var x : int ; x := 0 ;
    if (sum mod 2 /= 0) then (     x := x + 1 ) else (     var temp : long ; temp := p->min() ;
     sum := sum - temp ; 
     if (temp > sum) then (     x := x + 1 ) else skip ) ;  
    if (x = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double PHI=1.6180339 ;
  static int f[]={
    0,1,1,2,3,5 };
    static int fib(int n){
      if(n<6)return f[n];
      int t=5 ;
      int fn=5 ;
      while(t<n){
        fn=(int)Math.round(fn*PHI);
        t++;
      }
      return fn ;
    }
    public static void main(String[] args){
      int n=9 ;
      System.out.println(n+"th Fibonacci Number="+fib(n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute PHI : double := 1.6180339;
  static   attribute f : int := Sequence{0,1,1,2,3,5};
  static   operation fib( n : int) : int
  pre: true
  post: true
  activity: (     if (n < 6) then     return f[n+1] else skip ; 
     var t : int ; t := 5 ;
    var fn : int ; fn := 5 ;
    while (t < n) do (     fn := (fn * PHI)->round()->oclAsType(int) ; 
     t := t + 1 ) ; 
    return fn 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     OclFile["System.out"].println(n + "th Fibonacci Number=" + fib(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int kthSmallest(int n,int k){
    return(2*k);
  }
  public static void main(String args[]){
    int n=8,k=4 ;
    System.out.print(kthSmallest(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation kthSmallest( n : int, k : int) : int
  pre: true
  post: true
  activity: (     return (2 * k) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
    var k : int ; k := 4 ;
     OclFile["System.out"].print(kthSmallest(n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int n=5 ;
  static void printSumTricky(int mat[][],int k){
    if(k>n)return ;
    int stripSum[][]=new int[n][n];
    for(int j=0 ; j<n ; j++){
      int sum=0 ;
      for(int i=0 ; i<k ; i++)sum+=mat[i][j];
      stripSum[0][j]=sum ;
      for(int i=1 ; i<n-k+1 ; i++){
        sum+=(mat[i+k-1][j]-mat[i-1][j]);
        stripSum[i][j]=sum ;
      }
    }
    for(int i=0 ; i<n-k+1 ; i++){
      int sum=0 ;
      for(int j=0 ; j<k ; j++)sum+=stripSum[i][j];
      System.out.print(sum+" ");
      for(int j=1 ; j<n-k+1 ; j++){
        sum+=(stripSum[i][j+k-1]-stripSum[i][j-1]);
        System.out.print(sum+" ");
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    int mat[][]={
      {
        1,1,1,1,1 },{
          2,2,2,2,2 },{
            3,3,3,3,3 },{
              4,4,4,4,4 },{
                5,5,5,5,5 },};
                int k=3 ;
                printSumTricky(mat,k);
              }
            }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute n : int := 5;
  static   operation printSumTricky( mat : Sequence(Sequence(int)), k : int) : void
  pre: true
  post: true
  activity: (     if (k > n) then     return else skip ; 
     var stripSum : Sequence(Sequence(int)) ; stripSum := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
         var j : int ; j := 0 ; while j < n do ( (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < k do (     sum := sum+(mat[i+1][j+1]) ;  ;     i := i + 1 ) ; 
     stripSum[0+1][j+1] := sum ; 
         var i : int ; i := 1 ; while i < n - k + 1 do ( (     sum := sum+((mat[i + k - 1+1][j+1] - mat[i - 1+1][j+1])) ; 
     stripSum[i+1][j+1] := sum )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
         var i : int ; i := 0 ; while i < n - k + 1 do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < k do (     sum := sum+(stripSum[i+1][j+1]) ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].print(sum + " ") ; 
        var j : int ; j := 1 ; while j < n - k + 1 do ( (     sum := sum+((stripSum[i+1][j + k - 1+1] - stripSum[i+1][j - 1+1])) ; 
     OclFile["System.out"].print(sum + " ") )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,1,1,1,1},Sequence{2,2,2,2,2},Sequence{3,3,3,3,3},Sequence{4,4,4,4,4},Sequence{5,5,5,5,5},} ;
     var k : int ; k := 3 ;
     execute printSumTricky(mat, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class A30 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int A=in.nextInt();
    int B=in.nextInt();
    int N=in.nextInt();
    BigInteger bigA=BigInteger.valueOf(A);
    BigInteger bigB=BigInteger.valueOf(B);
    for(int x=-1000 ; x<=1000 ; x++){
      if(BigInteger.valueOf(x).pow(N).multiply(bigA).equals(bigB)){
        System.out.println(x);
        return ;
      }
    }
    System.out.println("No solution");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A30 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := in.getCurrent()->toInteger() ;
    var B : int ; B := in.getCurrent()->toInteger() ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var bigA : long ; bigA := (A + "")->toLong() ;
    var bigB : long ; bigB := (B + "")->toLong() ;
        var x : int ; x := -1000 ; while x <= 1000 do ( (     if ((x + "")->toLong().pow(N).multiply(bigA) = bigB) then (     OclFile["System.out"].println(x) ; 
     return ) else skip )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println("No solution") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    new Main().solve(new Scanner(System.in));
  }
  private void solve(Scanner sc){
    int A=sc.nextInt(),B=sc.nextInt(),n=sc.nextInt();
    if(A==0){
      if(B==0)System.out.println(1);
      else System.out.println("No solution");
      return ;
    }
    if(B % A!=0){
      System.out.println("No solution");
      return ;
    }
    B/=A ;
    boolean neg=B<0 ;
    if(neg && n % 2==0){
      System.out.println("No solution");
      return ;
    }
    if(neg)B=-B ;
    for(int x=0 ; x<=B ; x++){
      if(Math.pow(x,n)==B){
        System.out.println(neg ?-x : x);
        return ;
      }
    }
    System.out.println("No solution");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var A : int ; A := sc.nextInt() ;
    var B : int ; B := sc.nextInt() ;
    var n : int ; n := sc.nextInt() ;
     if (A = 0) then (     if (B = 0) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println("No solution") ; ;  
     return ) else skip ; 
    if (B mod A /= 0) then (     OclFile["System.out"].println("No solution") ; 
     return ) else skip ; 
    B := B/(A) ; 
    var neg : boolean ; neg := B < 0 ;
    if (neg & n mod 2 = 0) then (     OclFile["System.out"].println("No solution") ; 
     return ) else skip ; 
    if (neg) then     B := -B ; else skip ; 
        var x : int ; x := 0 ; while x <= B do ( (     if (x->pow(n) = B) then (     OclFile["System.out"].println(if neg then -x else x endif) ; 
     return ) else skip )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println("No solution") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Problem5 {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n1=input.nextInt();
    float[] arr=new float[n1];
    int sum=0 ;
    for(int i=0 ; i<n1 ; i++){
      int n2=input.nextInt();
      arr[i]=n2 ;
      sum+=(double)arr[i];
    }
    float summ=sum ;
    summ/=(double)n1 ;
    int nos=0 ;
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]==summ){
        nos++;
      }
    }
    System.out.println(nos);
    for(int i=0 ; i<n1 ; i++){
      if((double)arr[i]==summ){
        System.out.print((i+1)+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem5 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n1 : int ; n1 := input.getCurrent()->toInteger() ;
    var arr : Sequence(double) ; arr := Integer.subrange(1,n1)->collect(0.0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n1 do ( (     var n2 : int ; n2 := input.getCurrent()->toInteger() ;
     arr[i+1] := n2 ; 
     sum := sum+(arr[i+1]->oclAsType(double)) )  ;     i := i + 1 ) ; 
    var summ : double ; summ := sum ;
    summ := summ/(n1->oclAsType(double)) ; 
    var nos : int ; nos := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = summ) then (     nos := nos + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(nos) ; 
        var i : int ; i := 0 ; while i < n1 do ( (     if (arr[i+1]->oclAsType(double) = summ) then (     OclFile["System.out"].print((i + 1) + " ") ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int ncr(int n,int r){
    int ans=1 ;
    for(int i=1 ; i<=r ; i+=1){
      ans*=(n-r+i);
      ans/=i ;
    }
    return ans ;
  }
  static int totalWays(int X,int Y,int M,int W){
    return(ncr(M,X)*ncr(W,Y));
  }
  public static void main(String[] args){
    int X=4,Y=3,M=6,W=5 ;
    System.out.println(totalWays(X,Y,M,W));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation ncr( n : int, r : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
         var i : int ; i := 1 ; while i <= r do ( (     ans := ans*((n - r + i)) ; 
     ans := ans/(i) )  ;     i := i+(1) ) ; 
     return ans );
  static   operation totalWays( X : int, Y : int, M : int, W : int) : int
  pre: true
  post: true
  activity: (     return (ncr(M, X) * ncr(W, Y)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 4 ;
    var Y : int ; Y := 3 ;
    var M : int ; M := 6 ;
    var W : int ; W := 5 ;
     OclFile["System.out"].println(totalWays(X, Y, M, W)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int nextPowerOf2(int n){
    int count=0 ;
    if(n!=0 &&(n &(n-1))==0)return n ;
    while(n!=0){
      n>>=1 ;
      count+=1 ;
    }
    return 1<<count ;
  }
  static int removeElement(int n){
    if(n==1 || n==2)return 0 ;
    int a=nextPowerOf2(n);
    if(n==a || n==a-1)return 1 ;
    else if(n==a-2)return 0 ;
    else if(n % 2==0)return 1 ;
    else return 2 ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(removeElement(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nextPowerOf2( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     if (n /= 0 & (n & (n - 1)) = 0) then     return n else skip ; 
     while (n /= 0) do (     n := n/(2->pow(1)) ; 
     count := count+(1) ) ; 
     return (1*(2->pow(count)))->oclAsType(long) );
  static   operation removeElement( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1 or n = 2) then     return 0 else skip ; 
     var a : int ; a := nextPowerOf2(n) ;
     if (n = a or n = a - 1) then     return 1 else     if (n = a - 2) then     return 0 else     if (n mod 2 = 0) then     return 1 else     return 2 ;  ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(removeElement(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Character.isUpperCase ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String[] S=new String[100];
    int[] iVal=new int[5];
    for(int i=0 ; i<5 ; i+=1){
      iVal[i]=in.nextInt();
      if(iVal[i]==0){
        System.out.println(i+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : Sequence(String) ; S := Integer.subrange(1,100)->collect(null) ;
     var iVal : Sequence(int) ; iVal := Integer.subrange(1,5)->collect(0) ;
         var i : int ; i := 0 ; while i < 5 do ( (     iVal[i+1] := in.getCurrent()->toInteger() ; 
     if (iVal[i+1] = 0) then (     OclFile["System.out"].println(i + 1) ) else skip )  ;     i := i+(1) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class NumTh {
  static long Choose(long n,long k){
    long res=1 ;
    for(long i=n ; i>=n-k+1 ; i--){
      res*=i ;
      res/=k-n+i ;
    }
    return res ;
  }
}
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt(),P=sc.nextInt();
    long Even=0,Odd=0 ;
    for(int i=0 ; i<N ; i++){
      int A=sc.nextInt();
      if(A % 2==0)Even++;
      else Odd++;
    }
    if(Odd==0){
      if(P==0)System.out.println((long)1<<Even);
      else System.out.println(0);
    }
    else System.out.println((long)1<<(long)(N-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class NumTh {
  static   operation Choose( n : long, k : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i >= n - k + 1 do ( (     res := res*(i) ; 
     res := res/(k - n + i) )  ;     i := i - 1 ) ; 
     return res );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var P : int ; P := sc.getCurrent()->toInteger() ;
    var Even : long ; Even := 0 ;
    var Odd : long ; Odd := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var A : int ; A := sc.getCurrent()->toInteger() ;
     if (A mod 2 = 0) then     Even := Even + 1 ; else     Odd := Odd + 1 ; )  ;     i := i + 1 ) ; 
    if (Odd = 0) then (     if (P = 0) then     OclFile["System.out"].println((1->oclAsType(long)*(2->pow(Even)))->oclAsType(long)) ; else     OclFile["System.out"].println(0) ; ) else     OclFile["System.out"].println((1->oclAsType(long)*(2->pow((N - 1)->oclAsType(long))))->oclAsType(long)) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  private void solve()throws IOException {
    int n=nextInt();
    int p=nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    long[] d=new long[2];
    d[0]=1 ;
    for(int i=0 ; i<n ; i++){
      long[] dd=new long[2];
      dd[0]=d[0];
      dd[1]=d[1];
      dd[a[i] % 2]+=d[0];
      dd[(a[i]+1)% 2]+=d[1];
      d=dd ;
    }
    out.println(d[p]);
  }
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer st ;
  PrintWriter out=new PrintWriter(System.out);
  String next()throws IOException {
    while(st==null || ! st.hasMoreTokens()){
      st=new StringTokenizer(br.readLine());
    }
    return st.nextToken();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    solve();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var p : int ; p := nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
    var d : Sequence(long) ; d := Integer.subrange(1,2)->collect(0) ;
    d[0+1] := 1 ; 
        var i : int ; i := 0 ; while i < n do ( (     var dd : Sequence(long) ; dd := Integer.subrange(1,2)->collect(0) ;
     dd[0+1] := d[0+1] ; 
    dd[1+1] := d[1+1] ; 
    dd[a[i+1] mod 2+1] := dd[a[i+1] mod 2+1]+(d[0+1]) ; 
    dd[(a[i+1] + 1) mod 2+1] := dd[(a[i+1] + 1) mod 2+1]+(d[1+1]) ; 
    d := dd ; 
 )  ;     i := i + 1 ) ; 
    out.println(d[p+1]) ; 
 );
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator;
   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     execute solve() ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int p1=0,p0=0,n=scanner.nextInt(),p=scanner.nextInt();
    for(int i=1 ; i<=n ; i++){
      int tmp=scanner.nextInt();
      if((tmp & 1)==1)p1++;
      else p0++;
    }
    BigInteger[] c1=new BigInteger[p1+1];
    c1[0]=BigInteger.ONE ;
    for(int i=1 ; i<=p1 ; i++)c1[i]=c1[i-1] .multiply(BigInteger.valueOf(p1+1-i)).divide(BigInteger.valueOf(i));
    BigInteger ans=BigInteger.ZERO ;
    for(int i=p ; i<=p1 ; i+=2)ans=ans.add(c1[i] .multiply(BigInteger.valueOf(2).pow(p0)));
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p1 : int ; p1 := 0 ;
    var p0 : int ; p0 := 0 ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var p : int ; p := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= n do ( (     var tmp : int ; tmp := scanner.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseAnd(tmp,1)) = 1) then     p1 := p1 + 1 ; else     p0 := p0 + 1 ; )  ;     i := i + 1 ) ; 
    var c1 : Sequence(long) ; c1 := Integer.subrange(1,p1 + 1)->collect(null) ;
    c1[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= p1 do (     c1[i+1] := c1[i - 1+1].multiply((p1 + 1 - i + "")->toLong()).divide((i + "")->toLong()) ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := p ; while i <= p1 do (     ans := ans->excludes(c1[i+1].multiply((2 + "")->toLong().pow(p0))) ;  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N,P ;
    N=sc.nextInt();
    P=sc.nextInt();
    long oddCount=0,plusCount=0 ;
    long sum ;
    for(int i=0 ; i<N ; i++){
      if(sc.nextInt()% 2==0){
        plusCount++;
      }
      else {
        oddCount++;
      }
    }
    if(P==1){
      long plan=0 ;
      for(int i=1 ; i<=oddCount ; i+=2){
        plan+=C(i,oddCount);
      }
      sum=plan*nijyou(plusCount);
    }
    else {
      long plan=0 ;
      for(int i=0 ; i<=oddCount ; i+=2){
        plan+=C(i,oddCount);
      }
      sum=plan*nijyou(plusCount);
    }
    System.out.println(sum);
  }
  private static long nijyou(long n){
    long result=1 ;
    for(int i=0 ; i<n ; i++){
      result=result*2 ;
    }
    return result ;
  }
  private static long C(int m,long n){
    long result=1 ;
    if(m>n/2){
      m=(int)n-m ;
    }
    for(int i=0 ; i<m ; i++){
      result=result*(n-i);
    }
    for(int i=1 ; i<=m ; i++){
      result=result/i ;
    }
    if(result<0){
      System.out.println("Error");
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ;
    var P : int ;
    N := sc.getCurrent()->toInteger() ; 
    P := sc.getCurrent()->toInteger() ; 
    var oddCount : long ; oddCount := 0 ;
    var plusCount : long ; plusCount := 0 ;
    var sum : long ;
        var i : int ; i := 0 ; while i < N do ( (     if (sc.getCurrent()->toInteger() mod 2 = 0) then (     plusCount := plusCount + 1 ) else (     oddCount := oddCount + 1 ) )  ;     i := i + 1 ) ; 
    if (P = 1) then (     var plan : long ; plan := 0 ;
         var i : int ; i := 1 ; while i <= oddCount do ( (     plan := plan+(C(i, oddCount)) )  ;     i := i+(2) ) ; 
     sum := plan * nijyou(plusCount) ) else (     var plan : long ; plan := 0 ;
         var i : int ; i := 0 ; while i <= oddCount do ( (     plan := plan+(C(i, oddCount)) )  ;     i := i+(2) ) ; 
     sum := plan * nijyou(plusCount) ) ;  
    OclFile["System.out"].println(sum) ; 
 );
  static   operation nijyou( n : long) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     result := result * 2 )  ;     i := i + 1 ) ; 
     return result );
  static   operation C( m : int, n : long) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 1 ;
     if (m > n / 2) then (     m := n->oclAsType(int) - m ) else skip ; 
        var i : int ; i := 0 ; while i < m do ( (     result := result * (n - i) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= m do ( (     result := result / i )  ;     i := i + 1 ) ; 
    if (result < 0) then (     OclFile["System.out"].println("Error") ) else skip ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  static BigInteger C(int n,int m){
    BigInteger res=new BigInteger("1");
    for(int i=m-n+1 ; i<=m ; i++)res=res.multiply(BigInteger.valueOf(i));
    for(int i=1 ; i<=n ; i++)res=res.divide(BigInteger.valueOf(i));
    return res ;
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n,p ;
    int k0=0 ;
    int k1=0 ;
    n=sc.nextInt();
    p=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int x ;
      x=sc.nextInt();
      if(x % 2==1)k1++;
      else k0++;
    }
    BigInteger ans=new BigInteger("1");
    for(int i=0 ; i<k0 ; i++)ans=ans.multiply(BigInteger.valueOf(2));
    if(p==0){
      BigInteger add=new BigInteger("0");
      for(int i=0 ; i<=k1 ; i+=2)add=add.add(C(i,k1));
      ans=ans.multiply(add);
      System.out.println(ans);
    }
    else {
      BigInteger add=new BigInteger("0");
      for(int i=1 ; i<=k1 ; i+=2)add=add.add(C(i,k1));
      ans=ans.multiply(add);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation C( n : int, m : int) : long
  pre: true
  post: true
  activity: (     var res : long ; res := long("1") ;
         var i : int ; i := m - n + 1 ; while i <= m do (     res := res.multiply((i + "")->toLong()) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i <= n do (     res := res.divide((i + "")->toLong()) ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var p : int ;
    var k0 : int ; k0 := 0 ;
    var k1 : int ; k1 := 0 ;
    n := sc.getCurrent()->toInteger() ; 
    p := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : int ;
     x := sc.getCurrent()->toInteger() ; 
     if (x mod 2 = 1) then     k1 := k1 + 1 ; else     k0 := k0 + 1 ; )  ;     i := i + 1 ) ; 
    var ans : long ; ans := long("1") ;
        var i : int ; i := 0 ; while i < k0 do (     ans := ans.multiply((2 + "")->toLong()) ;  ;     i := i + 1 ) ; 
    if (p = 0) then (     var add : long ; add := long("0") ;
         var i : int ; i := 0 ; while i <= k1 do (     add := add->excludes(C(i, k1)) ;  ;     i := i+(2) ) ; 
     ans := ans.multiply(add) ; 
     OclFile["System.out"].println(ans) ) else (     var add : long ; add := long("0") ;
         var i : int ; i := 1 ; while i <= k1 do (     add := add->excludes(C(i, k1)) ;  ;     i := i+(2) ) ; 
     ans := ans.multiply(add) ; 
     OclFile["System.out"].println(ans) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] l=new int[2000];
    for(int i=0 ; i<n ; i++){
      l[i]=sc.nextInt();
    }
    for(int i=n ; i<2000 ; i++){
      l[i]=10000 ;
    }
    Arrays.sort(l);
    int ans=0 ;
    for(int i=0 ; i<n-2 ; i++){
      for(int j=i+1 ; j<n-1 ; j++){
        for(int k=j+1 ; (k<n)&&(l[k]<l[i]+l[j]); k++){
          if((l[i]<l[j]+l[k])&&(l[j]<l[k]+l[i])){
            ans++;
          }
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Integer.subrange(1,2000)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     l[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := n ; while i < 2000 do ( (     l[i+1] := 10000 )  ;     i := i + 1 ) ; 
    l := l->sort() ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n - 2 do ( (         var j : int ; j := i + 1 ; while j < n - 1 do ( (         var k : int ; k := j + 1 ; while (k < n) & (l[k+1] < l[i+1] + l[j+1]) do ( (     if ((l[i+1] < l[j+1] + l[k+1]) & (l[j+1] < l[k+1] + l[i+1])) then (     ans := ans + 1 ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.nio.charset.StandardCharsets ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader reader=new InputStreamReader(System.in,StandardCharsets.UTF_8);
    BufferedReader in=new BufferedReader(reader);
    int N=Integer.parseInt(in.readLine());
    String[] tokens=in.readLine().split(" ");
    List<Integer>list=new ArrayList<>(N);
    for(int i=0 ; i<N ; ++i){
      list.add(Integer.parseInt(tokens[i]));
    }
    Collections.sort(list);
    long count=0L ;
    for(int i=N-1 ; i>=0 ; --i){
      int longEdge=list.get(i);
      for(int j=i-1 ; j>=0 ; --j){
        int middleEdge=list.get(j);
        if(longEdge/2>=middleEdge){
          break ;
        }
        for(int k=j-1 ; k>=0 ; --k){
          if(list.get(k)+middleEdge>longEdge){
++count ;
          }
          else {
            break ;
          }
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"], StandardCharsets.UTF_8) ;
     var in : OclFile ; in := OclFile.newOclFile_Read(reader) ;
    var N : int ; N := (in.readLine())->toInteger() ;
    var tokens : Sequence(String) ; tokens := in.readLine()->split(" ") ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     list := list->including((tokens[i+1])->toInteger()) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var count : long ; count := 0L ;
        var i : int ; i := N - 1 ; while i >= 0 do ( (     var longEdge : int ; longEdge := list->at(i+1) ;
         var j : int ; j := i - 1 ; while j >= 0 do ( (     var middleEdge : int ; middleEdge := list->at(j+1) ;
     if (longEdge / 2 >= middleEdge) then (     break ) else skip ; 
         var k : int ; k := j - 1 ; while k >= 0 do ( (     if (list->at(k+1) + middleEdge > longEdge) then (     count := count + 1 ) else (     break ) )  ;     k := k - 1 ) )  ;     j := j - 1 ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean arraySortedOrNot(int arr[],int n){
    if(n==0 || n==1)return true ;
    for(int i=1 ; i<n ; i++)if(arr[i-1]>arr[i])return false ;
    return true ;
  }
  public static void main(String[] args){
    int arr[]={
      20,23,23,45,78,88 };
      int n=arr.length ;
      if(arraySortedOrNot(arr,n))System.out.print("Yes\n");
      else System.out.print("No\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation arraySortedOrNot( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 0 or n = 1) then     return true else skip ; 
         var i : int ; i := 1 ; while i < n do (     if (arr[i - 1+1] > arr[i+1]) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{20,23,23,45,78,88} ;
     var n : int ; n := arr->size() ;
     if (arraySortedOrNot(arr, n)) then     OclFile["System.out"].print("Yes\n") ; else     OclFile["System.out"].print("No\n") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    List<Integer>L=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      L.add(scanner.nextInt());
    }
    Collections.sort(L);
    int count=0 ;
    for(int i=0 ; i<N ; i++){
      for(int j=i+1 ; j<N ; j++){
        int a=L.get(i);
        int b=L.get(j);
        int res=find(L,j+1,a+b);
        count=count+res ;
      }
    }
    System.out.println(count);
  }
  public static int find(List<Integer>li,int from,int target){
    int low=from ;
    int upp=li.size()-1 ;
    int mid=(upp-low+1)% 2==0 ?(low+upp)/2+1 :(low+upp)/2 ;
    if(upp-low<0){
      return 0 ;
    }
    else if(li.get(from)>=target){
      return 0 ;
    }
    else if(li.get(upp)<target){
      return upp-low+1 ;
    }
    while(upp-low>1){
      if(li.get(mid)>=target){
        upp=mid ;
      }
      else {
        low=mid ;
      }
      mid=(upp-low+1)% 2==0 ?(low+upp)/2+1 :(low+upp)/2 ;
    }
    return low-from+1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var L : Sequence(int) ; L := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     L := L->including(scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    L := L->sort() ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := i + 1 ; while j < N do ( (     var a : int ; a := L->at(i+1) ;
     var b : int ; b := L->at(j+1) ;
     var res : int ; res := find(L, j + 1, a + b) ;
     count := count + res )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation find( li : Sequence(int), from : int, target : int) : int
  pre: true
  post: true
  activity: (     var low : int ; low := from ;
     var upp : int ; upp := li->size() - 1 ;
    var mid : int ; mid := if (upp - low + 1) mod 2 = 0 then (low + upp) / 2 + 1 else (low + upp) / 2 endif ;
    if (upp - low < 0) then (     return 0 ) else     if (li->at(from+1) >= target) then (     return 0 ) else     if (li->at(upp+1) < target) then (     return upp - low + 1 ) else skip ; ;  ;  
    while (upp - low > 1) do (     if (li->at(mid+1) >= target) then (     upp := mid ) else (     low := mid ) ;  
     mid := if (upp - low + 1) mod 2 = 0 then (low + upp) / 2 + 1 else (low + upp) / 2 endif ) ; 
    return low - from + 1 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws Exception {
    try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in))){
      int N=Integer.parseInt(reader.readLine());
      args=reader.readLine().split(" ");
      int[] L=new int[N];
      for(int i=0 ; i<N ; i++){
        L[i]=Integer.parseInt(args[i]);
      }
      Arrays.sort(L);
      int count=0 ;
      for(int i=0 ; i<N ; i++){
        for(int j=i+1 ; j<N ; j++){
          for(int k=j+1 ; k<N ; k++){
            if(L[k]>=L[i]+L[j]){
              break ;
            }
            count++;
          }
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var N : int ; N := (reader.readLine())->toInteger() ;
     args := reader.readLine()->split(" ") ; 
    var L : Sequence(int) ; L := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     L[i+1] := (args[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    L := L->sort() ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := i + 1 ; while j < N do ( (         var k : int ; k := j + 1 ; while k < N do ( (     if (L[k+1] >= L[i+1] + L[j+1]) then (     break ) else skip ; 
     count := count + 1 )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
import java.io.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long res=0 ;
    int[] l=new int[n];
    for(int i=0 ; i<n ; i++){
      l[i]=sc.nextInt();
    }
    Arrays.sort(l);
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        int nibutan=Algo.nibutan(l[i]+l[j],l);
        res+=(nibutan-j-1);
      }
    }
    System.out.println(res);
    sc.close();
  }
}
class io {
  public static void br(){
    System.out.println("");
  }
  public static void YesNo(boolean f){
    System.out.println(f ? "Yes" : "No");
  }
  public static void YESNO(boolean f){
    System.out.println(f ? "YES" : "NO");
  }
}
class Algo {
  public static int nibutan(int target,int[] ar){
    int res ;
    int high=ar.length ;
    int low=0 ;
    while(high>low){
      res=(high+low)/2 ;
      if(ar[res]<target){
        low=res+1 ;
      }
      else {
        high=res ;
      }
    }
    return low ;
  }
  public static boolean isOdd(int n){
    return n % 2==1 ;
  }
  public static boolean isEven(int n){
    return n % 2==0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var res : long ; res := 0 ;
    var l : Sequence(int) ; l := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     l[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    l := l->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var nibutan : int ; nibutan := Algo.nibutan(l[i+1] + l[j+1], l) ;
     res := res+((nibutan - j - 1)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
    skip ; 
 );
}
class io {
  static   operation br() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("") );
  static   operation YesNo( f : boolean) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if f then "Yes" else "No" endif) );
  static   operation YESNO( f : boolean) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if f then "YES" else "NO" endif) );
}
class Algo {
  static   operation nibutan( target : int, ar : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var res : int ;
     var high : int ; high := ar->size() ;
    var low : int ; low := 0 ;
    while (high > low) do (     res := (high + low) / 2 ; 
     if (ar[res+1] < target) then (     low := res + 1 ) else (     high := res ) ) ; 
    return low 
 );
  static   operation isOdd( n : int) : boolean
  pre: true
  post: true
  activity: (     return n mod 2 = 1 );
  static   operation isEven( n : int) : boolean
  pre: true
  post: true
  activity: (     return n mod 2 = 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int x1=in.nextInt();
    int x2=in.nextInt();
    int x3=in.nextInt();
    int x4=in.nextInt();
    int x5=in.nextInt();
    if(x1==0){
      System.out.println("1");
    }
    else if(x2==0){
      System.out.println("2");
    }
    else if(x3==0){
      System.out.println("3");
    }
    else if(x4==0){
      System.out.println("4");
    }
    else if(x5==0){
      System.out.println("5");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : int ; x1 := in.getCurrent()->toInteger() ;
    var x2 : int ; x2 := in.getCurrent()->toInteger() ;
    var x3 : int ; x3 := in.getCurrent()->toInteger() ;
    var x4 : int ; x4 := in.getCurrent()->toInteger() ;
    var x5 : int ; x5 := in.getCurrent()->toInteger() ;
    if (x1 = 0) then (     OclFile["System.out"].println("1") ) else     if (x2 = 0) then (     OclFile["System.out"].println("2") ) else     if (x3 = 0) then (     OclFile["System.out"].println("3") ) else     if (x4 = 0) then (     OclFile["System.out"].println("4") ) else     if (x5 = 0) then (     OclFile["System.out"].println("5") ) else skip ; ;  ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int modInverse(int a,int m){
    a=a % m ;
    for(int x=1 ; x<m ; x++)if((a*x)% m==1)return x ;
    return 1 ;
  }
  public static void main(String args[]){
    int a=3,m=11 ;
    System.out.println(modInverse(a,m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation modInverse( a : int, m : int) : int
  pre: true
  post: true
  activity: (     a := a mod m ; 
         var x : int ; x := 1 ; while x < m do (     if ((a * x) mod m = 1) then     return x else skip ;  ;     x := x + 1 ) ; 
     return 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var m : int ; m := 11 ;
     OclFile["System.out"].println(modInverse(a, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sumOfDigits(int x){
    int sum=0 ;
    while(x!=0){
      sum+=x % 10 ;
      x=x/10 ;
    }
    return sum ;
  }
  static int countNumbers(int l,int r){
    int count=0 ;
    for(int i=l ; i<=r ; i++){
      if(i % 2==0 && sumOfDigits(i)% 3==0)count++;
    }
    return count ;
  }
  public static void main(String args[]){
    int l=1000,r=6000 ;
    System.out.println(countNumbers(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumOfDigits( x : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (x /= 0) do (     sum := sum+(x mod 10) ; 
     x := x / 10 ) ; 
     return sum );
  static   operation countNumbers( l : int, r : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := l ; while i <= r do ( (     if (i mod 2 = 0 & sumOfDigits(i) mod 3 = 0) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 1000 ;
    var r : int ; r := 6000 ;
     OclFile["System.out"].println(countNumbers(l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void findGreater(int a,int b){
    double x=(double)a*(double)(Math.log((double)(b)));
    double y=(double)b*(double)(Math.log((double)(a)));
    if(y>x){
      System.out.println("a^b is greater");
    }
    else if(y<x){
      System.out.println("b^a is greater");
    }
    else {
      System.out.println("Both are equal");
    }
  }
  public static void main(String[] args){
    int a=3,b=5,c=2,d=4 ;
    findGreater(a,b);
    findGreater(c,d);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findGreater( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var x : double ; x := a->oclAsType(double) * (((b)->oclAsType(double))->log())->oclAsType(double) ;
     var y : double ; y := b->oclAsType(double) * (((a)->oclAsType(double))->log())->oclAsType(double) ;
     if (y > x) then (     OclFile["System.out"].println("a^b is greater") ) else     if (y < x) then (     OclFile["System.out"].println("b^a is greater") ) else (     OclFile["System.out"].println("Both are equal") ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var b : int ; b := 5 ;
    var c : int ; c := 2 ;
    var d : int ; d := 4 ;
     execute findGreater(a, b) ; 
     execute findGreater(c, d) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findAnswer(String str1,String str2,int n){
    int l=0,r=0 ;
    int ans=2 ;
    for(int i=0 ; i<n ; ++i){
      if(str1.charAt(i)!=str2.charAt(i)){
        l=i ;
        break ;
      }
    }
    for(int i=n-1 ; i>=0 ; i--){
      if(str1.charAt(i)!=str2.charAt(i)){
        r=i ;
        break ;
      }
    }
    if(r<l)return 26*(n+1);
    else if(l==r)return ans ;
    else {
      for(int i=l+1 ; i<=r ; i++){
        if(str1.charAt(i)!=str2.charAt(i-1)){
          ans--;
          break ;
        }
      }
      for(int i=l+1 ; i<=r ; i++){
        if(str1.charAt(i-1)!=str2.charAt(i)){
          ans--;
          break ;
        }
      }
      return ans ;
    }
  }
  public static void main(String args[]){
    String str1="toy",str2="try" ;
    int n=str1.length();
    System.out.println(findAnswer(str1,str2,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findAnswer( str1 : String, str2 : String, n : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
    var r : int ; r := 0 ;
     var ans : int ; ans := 2 ;
        var i : int ; i := 0 ; while i < n do ( (     if (str1->at(i+1) /= str2->at(i+1)) then (     l := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (str1->at(i+1) /= str2->at(i+1)) then (     r := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    if (r < l) then     return 26 * (n + 1) else     if (l = r) then     return ans else (         var i : int ; i := l + 1 ; while i <= r do ( (     if (str1->at(i+1) /= str2->at(i - 1+1)) then (     ans := ans - 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := l + 1 ; while i <= r do ( (     if (str1->at(i - 1+1) /= str2->at(i+1)) then (     ans := ans - 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     return ans ) ;  ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "toy" ;
    var str2 : String ; str2 := "try" ;
     var n : int ; n := str1->size() ;
     OclFile["System.out"].println(findAnswer(str1, str2, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution10 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    StringBuilder str=new StringBuilder();
    for(int z=0 ; z<t ; z++){
      int n=sc.nextInt();
      int x=sc.nextInt();
      int m=sc.nextInt();
      int[][] arr=new int[m][2];
      for(int i=0 ; i<m ; i++){
        arr[i][0]=sc.nextInt();
        arr[i][1]=sc.nextInt();
      }
      int si=x ;
      int ei=x ;
      for(int i=0 ; i<m ; i++){
        int l=arr[i][0];
        int r=arr[i][1];
        if((l<=si && si<=r)||(l<=ei && ei<=r)){
          si=Math.min(l,si);
          ei=Math.max(r,ei);
        }
      }
      str.append(ei-si+1);
      str.append("\n");
    }
    System.out.println(str.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution10 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var str : String ; str := StringLib.newString() ;
        var z : int ; z := 0 ; while z < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,m)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (     arr[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     arr[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var si : int ; si := x ;
    var ei : int ; ei := x ;
        var i : int ; i := 0 ; while i < m do ( (     var l : int ; l := arr[i+1][0+1] ;
     var r : int ; r := arr[i+1][1+1] ;
     if ((l <= si & si <= r) or (l <= ei & ei <= r)) then (     si := Set{l, si}->min() ; 
     ei := Set{r, ei}->max() ) else skip )  ;     i := i + 1 ) ; 
    str := str + StringLib.newString(ei - si + 1) ; 
    str := str + StringLib.newString("\n") ; 
 )  ;     z := z + 1 ) ; 
    OclFile["System.out"].println(str+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    int[] res=new int[T];
    int idx=0 ;
    while(T-->0){
      int n=sc.nextInt();
      int x=sc.nextInt();
      int m=sc.nextInt();
      int left=-1,right=-1 ;
      for(int i=0 ; i<m ; i++){
        int a=sc.nextInt();
        int b=sc.nextInt();
        if(left==-1 && right==-1){
          if(a<=x && x<=b){
            left=a ;
            right=b ;
          }
        }
        else {
          if(b<left || a>right){
            continue ;
          }
          else {
            left=Math.min(left,a);
            right=Math.max(right,b);
          }
        }
      }
      res[idx++]=right-left+1 ;
    }
    for(int i : res){
      System.out.println(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
    var res : Sequence(int) ; res := Integer.subrange(1,T)->collect(0) ;
    var idx : int ; idx := 0 ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var left : int ; left := -1 ;
    var right : int ; right := -1 ;
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (left = -1 & right = -1) then (     if (a <= x & x <= b) then (     left := a ; 
     right := b ) else skip ) else (     if (b < left or a > right) then (     continue ) else (     left := Set{left, a}->min() ; 
     right := Set{right, b}->max() ) ) )  ;     i := i + 1 ) ; 
     res[idx+1] := right - left + 1  ; idx := idx + 1 ; 
 ) ;  ) ;  
    for (i : res) do ( (     OclFile["System.out"].println(i) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Problem5 {
  public static void averageNumbers(float[] arr,int n,float sum){
    int cnt=0 ;
    sum/=(double)n ;
    System.out.println(count(arr,sum));
    for(int i=0 ; i<n ; i++){
      if((double)arr[i]==sum){
        System.out.print((i+1)+" ");
        cnt++;
      }
    }
  }
  static int count(float[] arr,float sum){
    int count=0 ;
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]==sum){
        count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n1=input.nextInt();
    float[] arr=new float[n1];
    int sum=0 ;
    for(int i=0 ; i<n1 ; i++){
      int n2=input.nextInt();
      arr[i]=n2 ;
      sum+=(double)arr[i];
    }
    averageNumbers(arr,n1,sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem5 {
  static   operation averageNumbers( arr : Sequence(double), n : int, sum : double) : void
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     sum := sum/(n->oclAsType(double)) ; 
     OclFile["System.out"].println(count(arr, sum)) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1]->oclAsType(double) = sum) then (     OclFile["System.out"].print((i + 1) + " ") ; 
     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) );
  static   operation count( arr : Sequence(double), sum : double) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = sum) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n1 : int ; n1 := input.getCurrent()->toInteger() ;
    var arr : Sequence(double) ; arr := Integer.subrange(1,n1)->collect(0.0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n1 do ( (     var n2 : int ; n2 := input.getCurrent()->toInteger() ;
     arr[i+1] := n2 ; 
     sum := sum+(arr[i+1]->oclAsType(double)) )  ;     i := i + 1 ) ; 
    execute averageNumbers(arr, n1, sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Shuffle {
  static Scanner sc=new Scanner(System.in);
  static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args){
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int x=sc.nextInt();
      int m=sc.nextInt();
      int lif=x,rght=x ;
      while(m-->0){
        int l=sc.nextInt();
        int r=sc.nextInt();
        if(Math.min(rght,r)>=Math.max(lif,l)){
          lif=Math.min(lif,l);
          rght=Math.max(rght,r);
        }
      }
      pw.println(rght-lif+1);
    }
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Shuffle {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var lif : int ; lif := x ;
    var rght : int ; rght := x ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
     if (Set{rght, r}->min() >= Set{lif, l}->max()) then (     lif := Set{lif, l}->min() ; 
     rght := Set{rght, r}->max() ) else skip ) ;  ) ;  
    skip ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean bitsAreInAltPatrnInGivenTRange(int n,int l,int r){
    int num,prev,curr ;
    num=n>>(l-1);
    prev=num & 1 ;
    num=num>>1 ;
    for(int i=1 ; i<=(r-l); i++){
      curr=num & 1 ;
      if(curr==prev)return false ;
      prev=curr ;
      num=num>>1 ;
    }
    return true ;
  }
  public static void main(String[] args){
    int n=18 ;
    int l=1,r=3 ;
    if(bitsAreInAltPatrnInGivenTRange(n,l,r))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation bitsAreInAltPatrnInGivenTRange( n : int, l : int, r : int) : boolean
  pre: true
  post: true
  activity: (     var num : int ;
    var prev : int ;
    var curr : int ;
     num := (n/(2->pow((l - 1))))->oclAsType(long) ; 
    prev := MathLib.bitwiseAnd(num,1) ; 
    num := (num/(2->pow(1)))->oclAsType(long) ; 
        var i : int ; i := 1 ; while i <= (r - l) do ( (     curr := MathLib.bitwiseAnd(num,1) ; 
     if (curr = prev) then     return false else skip ; 
     prev := curr ; 
     num := (num/(2->pow(1)))->oclAsType(long) )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 18 ;
     var l : int ; l := 1 ;
    var r : int ; r := 3 ;
     if (bitsAreInAltPatrnInGivenTRange(n, l, r)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class eugene {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    StringBuffer res=new StringBuffer();
    int o=0,e=0 ;
    for(int i=0 ; i<n ; i++)if(arr[i]==1)++o ;
    else++e ;
    for(int i=0 ; i<k ; i++){
      int l=sc.nextInt();
      int r=sc.nextInt();
      if((r-l+1)% 2==1)res.append("0\n");
      else {
        if((r-l+1)/2<=o &&(r-l+1)/2<=e)res.append("1\n");
        else res.append("0\n");
      }
    }
    System.out.print(res);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class eugene {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var res : String ; res := StringLib.newString() ;
    var o : int ; o := 0 ;
    var e : int ; e := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (arr[i+1] = 1) then     o := o + 1 else     e := e + 1 ; ;   ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do ( (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
     if ((r - l + 1) mod 2 = 1) then     res := res + StringLib.newString("0\n") ; else (     if ((r - l + 1) / 2 <= o & (r - l + 1) / 2 <= e) then     res := res + StringLib.newString("1\n") ; else     res := res + StringLib.newString("0\n") ; ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(res) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class EugeneAndArray {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] arr=new int[n];
    int positives=0 ;
    int negatives=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      if(arr[i]>0){
        positives++;
      }
      else {
        negatives++;
      }
    }
    StringBuilder ans=new StringBuilder();
    int sum=0 ;
    for(int i=0 ; i<m ; i++){
      int li=sc.nextInt();
      int ri=sc.nextInt();
      sum=ri-li+1 ;
      if(sum % 2==0 && sum/2<=positives && sum/2<=negatives){
        ans.append(1).append("\n");
      }
      else {
        ans.append(0).append("\n");
      }
    }
    System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class EugeneAndArray {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var positives : int ; positives := 0 ;
    var negatives : int ; negatives := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr[i+1] > 0) then (     positives := positives + 1 ) else (     negatives := negatives + 1 ) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := StringLib.newString() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var li : int ; li := sc.getCurrent()->toInteger() ;
     var ri : int ; ri := sc.getCurrent()->toInteger() ;
     sum := ri - li + 1 ; 
     if (sum mod 2 = 0 & sum / 2 <= positives & sum / 2 <= negatives) then (     ans := ans + StringLib.newString(1) + StringLib.newString("\n") ) else (     ans := ans + StringLib.newString(0) + StringLib.newString("\n") ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    boolean[] arr=new boolean[n+3];
    arr[0]=true ;
    arr[1]=true ;
    int count=0 ;
    for(int i=2 ; i<arr.length ; i++){
      if(! arr[i]){
        for(int j=2 ; j*i<arr.length ; j++){
          arr[i*j]=true ;
        }
        if(! arr[i] && ! arr[i-2]){
          count++;
        }
      }
    }
    System.out.println(count*2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(boolean) ; arr := Integer.subrange(1,n + 3)->collect(false) ;
    arr[0+1] := true ; 
    arr[1+1] := true ; 
    var count : int ; count := 0 ;
        var i : int ; i := 2 ; while i < arr->size() do ( (     if (not(arr[i+1])) then (         var j : int ; j := 2 ; while j * i < arr->size() do ( (     arr[i * j+1] := true )  ;     j := j + 1 ) ; 
     if (not(arr[i+1]) & not(arr[i - 2+1])) then (     count := count + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count * 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int nth_group(int n){
    return n*(2*(int)Math.pow(n,2)+1);
  }
  public static void main(String arr[]){
    int N=5 ;
    System.out.println(nth_group(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nth_group( n : int) : int
  pre: true
  post: true
  activity: (     return n * (2 * n->pow(2)->oclAsType(int) + 1) );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     OclFile["System.out"].println(nth_group(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Ex711B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    long[][] magic_square=new long[n][n];
    int row=-1,column=-1 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        magic_square[i][j]=in.nextInt();
        if(magic_square[i][j]==0){
          row=i ;
          column=j ;
        }
      }
    }
    if(n==1){
      System.out.println(1);
      return ;
    }
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(row!=0){
        sum+=magic_square[0][i];
      }
      else {
        sum+=magic_square[1][i];
      }
    }
    long answer=sum ;
    for(int i=0 ; i<n ; i++){
      answer-=magic_square[row][i];
    }
    magic_square[row][column]=answer ;
    int m=0 ;
    long current_sumi=0,current_sumj=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        current_sumi+=magic_square[i][j];
        current_sumj+=magic_square[j][i];
      }
      if(current_sumi!=sum || current_sumj!=sum){
        m++;
      }
      current_sumi=0 ;
      current_sumj=0 ;
    }
    for(int i=0 ; i<n ; i++){
      current_sumi+=magic_square[i][i];
      current_sumj+=magic_square[n-i-1][i];
    }
    if(current_sumi!=sum || current_sumj!=sum){
      m++;
    }
    if(m==0 && answer>0){
      System.out.println(answer);
    }
    else {
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ex711B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var magic_square : Sequence(Sequence(long)) ; magic_square := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var row : int ; row := -1 ;
    var column : int ; column := -1 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     magic_square[i+1][j+1] := in.getCurrent()->toInteger() ; 
     if (magic_square[i+1][j+1] = 0) then (     row := i ; 
     column := j ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (n = 1) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (row /= 0) then (     sum := sum+(magic_square[0+1][i+1]) ) else (     sum := sum+(magic_square[1+1][i+1]) ) )  ;     i := i + 1 ) ; 
    var answer : long ; answer := sum ;
        var i : int ; i := 0 ; while i < n do ( (     answer := answer-(magic_square[row+1][i+1]) )  ;     i := i + 1 ) ; 
    magic_square[row+1][column+1] := answer ; 
    var m : int ; m := 0 ;
    var current_sumi : long ; current_sumi := 0 ;
    var current_sumj : long ; current_sumj := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     current_sumi := current_sumi+(magic_square[i+1][j+1]) ; 
     current_sumj := current_sumj+(magic_square[j+1][i+1]) )  ;     j := j + 1 ) ; 
     if (current_sumi /= sum or current_sumj /= sum) then (     m := m + 1 ) else skip ; 
     current_sumi := 0 ; 
     current_sumj := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     current_sumi := current_sumi+(magic_square[i+1][i+1]) ; 
     current_sumj := current_sumj+(magic_square[n - i - 1+1][i+1]) )  ;     i := i + 1 ) ; 
    if (current_sumi /= sum or current_sumj /= sum) then (     m := m + 1 ) else skip ; 
    if (m = 0 & answer > 0) then (     OclFile["System.out"].println(answer) ) else (     OclFile["System.out"].println(-1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] arr=new int[n];
    int sum1=0,sum2=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      sum1=sum1+arr[i];
    }
    for(int i=1 ; i<n ; i++){
      int csum=0 ;
      csum=arr[i]+arr[i-1];
      if(k>csum){
        arr[i]=arr[i]+k-csum ;
      }
    }
    for(int i=0 ; i<n ; i++){
      sum2=sum2+arr[i];
    }
    System.out.println(sum2-sum1);
    for(int i=0 ; i<n ; i++){
      System.out.print(arr[i]+" ");
    }
    System.out.println();
  }
  static boolean isPrime(long n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static long gcd(long a,long b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static long lcm(long a,long b){
    return(a/gcd(a,b))*b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum1 : int ; sum1 := 0 ;
    var sum2 : int ; sum2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     sum1 := sum1 + arr[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     var csum : int ; csum := 0 ;
     csum := arr[i+1] + arr[i - 1+1] ; 
     if (k > csum) then (     arr[i+1] := arr[i+1] + k - csum ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     sum2 := sum2 + arr[i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum2 - sum1) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a / gcd(a, b)) * b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),k=in.nextInt();
    int a[]=new int[n];
    int count=0 ;
    Arrays.setAll(a,i->in.nextInt());
    for(int i=0 ; i<n-1 ; i++){
      int sum=a[i]+a[i+1];
      if(sum>=k){
        continue ;
      }
      else {
        int prev=a[i+1];
        a[i+1]=k-a[i];
        count+=a[i+1]-prev ;
      }
    }
    pw.println(count);
    for(int i : a){
      pw.print(i+" ");
    }
    pw.close();
  }
  public static long solve(long n){
    return((n*n)+(2*n)+3);
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var count : int ; count := 0 ;
setAll(a, lambda i : OclAny in in.getCurrent()->toInteger()) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var sum : int ; sum := a[i+1] + a[i + 1+1] ;
     if (sum >= k) then (     continue ) else (     var prev : int ; prev := a[i + 1+1] ;
     a[i + 1+1] := k - a[i+1] ; 
     count := count+(a[i + 1+1] - prev) ) )  ;     i := i + 1 ) ; 
    skip ; 
    for (i : a) do ( (     skip )  ) ; 
    skip ; 
 );
  static   operation solve( n : long) : long
  pre: true
  post: true
  activity: (     return ((n * n) + (2 * n) + 3) );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class problemB {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int a[]=new int[n+5];
    int dem=0 ;
    for(int i=1 ; i<=n ; i++)a[i]=sc.nextInt();
    for(int i=2 ; i<=n ; i++){
      if(a[i]+a[i-1]<k){
        dem+=k-a[i]-a[i-1];
        a[i]=k-a[i-1];
      }
    }
    System.out.println(dem);
    for(int i=1 ; i<=n ; i++){
      System.out.print(a[i]+" ");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class problemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 5)->collect(0) ;
    var dem : int ; dem := 0 ;
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= n do ( (     if (a[i+1] + a[i - 1+1] < k) then (     dem := dem+(k - a[i+1] - a[i - 1+1]) ; 
     a[i+1] := k - a[i - 1+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dem) ; 
        var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].print(a[i+1] + " ") )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A_Average_Numbers {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      sum+=arr[i];
    }
    int c=0 ;
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      if((sum-arr[i])%(n-1)==0 &&(sum-arr[i])/(n-1)==arr[i]){
        c++;
        sb.append((i+1)+" ");
      }
    }
    System.out.println(c);
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Average_Numbers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     if ((sum - arr[i+1]) mod (n - 1) = 0 & (sum - arr[i+1]) / (n - 1) = arr[i+1]) then (     c := c + 1 ; 
     sb := sb + StringLib.newString((i + 1) + " ") ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAX=1000000 ;
  static int maximumOccurredElement(int[] L,int[] R,int n){
    int[] arr=new int[MAX];
    int maxi=-1 ;
    for(int i=0 ; i<n ; i++){
      arr[L[i] ]+=1 ;
      arr[R[i]+1]-=1 ;
      if(R[i]>maxi){
        maxi=R[i];
      }
    }
    int msum=arr[0];
    int ind=0 ;
    for(int i=1 ; i<maxi+1 ; i++){
      arr[i]+=arr[i-1];
      if(msum<arr[i]){
        msum=arr[i];
        ind=i ;
      }
    }
    return ind ;
  }
  static public void main(String[] args){
    int[] L={
      1,4,9,13,21 };
      int[] R={
        15,8,12,20,30 };
        int n=L.length ;
        System.out.println(maximumOccurredElement(L,R,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 1000000;
  static   operation maximumOccurredElement( L : Sequence(int), R : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,MAX)->collect(0) ;
     var maxi : int ; maxi := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[L[i+1]+1] := arr[L[i+1]+1]+(1) ; 
     arr[R[i+1] + 1+1] := arr[R[i+1] + 1+1]-(1) ; 
     if (R[i+1] > maxi) then (     maxi := R[i+1] ) else skip )  ;     i := i + 1 ) ; 
    var msum : int ; msum := arr[0+1] ;
    var ind : int ; ind := 0 ;
        var i : int ; i := 1 ; while i < maxi + 1 do ( (     arr[i+1] := arr[i+1]+(arr[i - 1+1]) ; 
     if (msum < arr[i+1]) then (     msum := arr[i+1] ; 
     ind := i ) else skip )  ;     i := i + 1 ) ; 
    return ind 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : Sequence(int) ; L := Sequence{1,4,9,13,21} ;
     var R : Sequence(int) ; R := Sequence{15,8,12,20,30} ;
     var n : int ; n := L->size() ;
     OclFile["System.out"].println(maximumOccurredElement(L, R, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Rough_02 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long arr[]=new long[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextLong();
    }
    long count=1 ;
    for(int i=0 ; i<n-1 ; i++){
      if(arr[i]!=arr[i+1]){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Rough_02 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var count : long ; count := 1 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] /= arr[i + 1+1]) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Magnets {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String[] a=new String[n];
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.next();
      if(i>0){
        if(a[i] .charAt(0)==a[i-1] .charAt(1)){
          count++;
        }
      }
    }
    System.out.println(count+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Magnets {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(String) ; a := Integer.subrange(1,n)->collect(null) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent() ; 
     if (i > 0) then (     if (a[i+1]->at(0+1) = a[i - 1+1]->at(1+1)) then (     count := count + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    byte[] a=new byte[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextByte();
    int count=1 ;
    for(int i=0,k=1 ; k<n ; i++,k++)if(a[i]!=a[k])count++;
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.nextByte() ;  ;     i := i + 1 ) ; 
    var count : int ; count := 1 ;
        var i : int ; i := 0 ;
    var k : int ; k := 1 ; while k < n do (     if (a[i+1] /= a[k+1]) then     count := count + 1 ; else skip ;  ;     i := i + 1 ;     k := k + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MainClass {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int sum=in.nextInt();
    int count=0 ;
    String check="" ;
    in.nextLine();
    for(int i=0 ; i<sum ; i++){
      String island=in.nextLine();
      if(! island.equals(check)){
        check=island ;
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sum : int ; sum := in.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var check : String ; check := "" ;
    skip ; 
        var i : int ; i := 0 ; while i < sum do ( (     var island : String ; island := in.nextLine() ;
     if (not(island = check)) then (     check := island ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int numOFMagnet=in.nextInt();
    int previous=in.nextInt();
    int ans=1 ;
    for(int i=0 ; i<numOFMagnet-1 ; i++){
      int magnet=in.nextInt();
      if(magnet==previous)continue ;
      previous=magnet ;
      ans++;
    }
    out.println(ans);
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new FileReader("sub.in"));
      }
      catch(FileNotFoundException ex){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException ex){
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException ex){
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var numOFMagnet : int ; numOFMagnet := in.nextInt() ;
    var previous : int ; previous := in.nextInt() ;
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < numOFMagnet - 1 do ( (     var magnet : int ; magnet := in.nextInt() ;
     if (magnet = previous) then     continue else skip ; 
     previous := magnet ; 
     ans := ans + 1 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("sub.in"))) )   catch (ex : FileNotFoundException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (ex : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (ex : IOException) do skip
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    if(n==0){
      if(m!=0)System.out.println("Impossible");
      else System.out.println(0+" "+0);
      return ;
    }
    if(m<=n){
      if(m==0){
        m=1 ;
      }
      System.out.print(n+" "+(m+n-1));
      return ;
    }
    System.out.print(m+" "+(m+n-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    if (n = 0) then (     if (m /= 0) then     OclFile["System.out"].println("Impossible") else     OclFile["System.out"].println(0 + " " + 0) ; ;  
     return ) else skip ; 
    if (m <= n) then (     if (m = 0) then (     m := 1 ) else skip ; 
     OclFile["System.out"].print(n + " " + (m + n - 1)) ; 
     return ) else skip ; 
    OclFile["System.out"].print(m + " " + (m + n - 1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static float func(float x){
    return(1/(1+x*x));
  }
  static float calculate(float lower_limit,float upper_limit,int interval_limit){
    float value ;
    float interval_size=(upper_limit-lower_limit)/interval_limit ;
    float sum=func(lower_limit)+func(upper_limit);
    for(int i=1 ; i<interval_limit ; i++){
      if(i % 3==0)sum=sum+2*func(lower_limit+i*interval_size);
      else sum=sum+3*func(lower_limit+i*interval_size);
    }
    return(3*interval_size/8)*sum ;
  }
  public static void main(String[] args){
    int interval_limit=10 ;
    float lower_limit=1 ;
    float upper_limit=10 ;
    float integral_res=calculate(lower_limit,upper_limit,interval_limit);
    System.out.println(integral_res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation func( x : double) : double
  pre: true
  post: true
  activity: (     return (1 / (1 + x * x)) );
  static   operation calculate( lower_limit : double, upper_limit : double, interval_limit : int) : double
  pre: true
  post: true
  activity: (     var value : double ;
     var interval_size : double ; interval_size := (upper_limit - lower_limit) / interval_limit ;
    var sum : double ; sum := func(lower_limit) + func(upper_limit) ;
        var i : int ; i := 1 ; while i < interval_limit do ( (     if (i mod 3 = 0) then     sum := sum + 2 * func(lower_limit + i * interval_size) ; else     sum := sum + 3 * func(lower_limit + i * interval_size) ; )  ;     i := i + 1 ) ; 
    return (3 * interval_size / 8) * sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var interval_limit : int ; interval_limit := 10 ;
     var lower_limit : double ; lower_limit := 1 ;
    var upper_limit : double ; upper_limit := 10 ;
    var integral_res : double ; integral_res := calculate(lower_limit, upper_limit, interval_limit) ;
    OclFile["System.out"].println(integral_res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    long x=sc.nextLong();
    long y=sc.nextLong();
    long sum=0 ;
    if(n>k){
      sum+=x*k ;
      sum+=y*(n-k);
    }
    else {
      sum+=x*n ;
    }
    System.out.println(sum);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var x : long ; x := sc.getCurrent()->toLong() ;
    var y : long ; y := sc.getCurrent()->toLong() ;
    var sum : long ; sum := 0 ;
    if (n > k) then (     sum := sum+(x * k) ; 
     sum := sum+(y * (n - k)) ) else (     sum := sum+(x * n) ) ;  
    OclFile["System.out"].println(sum) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Problem5 {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n1=input.nextInt();
    float[] arr=new float[n1];
    int sum=0 ;
    for(int i=0 ; i<n1 ; i++){
      int n2=input.nextInt();
      arr[i]=n2 ;
      sum+=(double)arr[i];
    }
    float mean=sum ;
    mean=(float)(mean/(double)n1);
    int nos=0 ;
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]==mean){
        nos++;
      }
    }
    System.out.println(nos);
    for(int i=0 ; i<n1 ; i++){
      if((double)arr[i]==mean){
        System.out.print((i+1)+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem5 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n1 : int ; n1 := input.getCurrent()->toInteger() ;
    var arr : Sequence(double) ; arr := Integer.subrange(1,n1)->collect(0.0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n1 do ( (     var n2 : int ; n2 := input.getCurrent()->toInteger() ;
     arr[i+1] := n2 ; 
     sum := sum+(arr[i+1]->oclAsType(double)) )  ;     i := i + 1 ) ; 
    var mean : double ; mean := sum ;
    mean := (mean / n1->oclAsType(double))->oclAsType(double) ; 
    var nos : int ; nos := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = mean) then (     nos := nos + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(nos) ; 
        var i : int ; i := 0 ; while i < n1 do ( (     if (arr[i+1]->oclAsType(double) = mean) then (     OclFile["System.out"].print((i + 1) + " ") ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    int N=Integer.parseInt(input.readLine());
    int K=Integer.parseInt(input.readLine());
    int X=Integer.parseInt(input.readLine());
    int Y=Integer.parseInt(input.readLine());
    if(N>K){
      System.out.println(X*K+Y*(N-K));
    }
    else {
      System.out.println(X*N);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var N : int ; N := (input.readLine())->toInteger() ;
    var K : int ; K := (input.readLine())->toInteger() ;
    var X : int ; X := (input.readLine())->toInteger() ;
    var Y : int ; Y := (input.readLine())->toInteger() ;
    if (N > K) then (     OclFile["System.out"].println(X * K + Y * (N - K)) ) else (     OclFile["System.out"].println(X * N) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Printer pr=new Printer(System.out);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int x=sc.nextInt();
    int y=sc.nextInt();
    pr.println(Math.min(n,k)*x+Math.max(0,n-k)*y);
    pr.close();
    sc.close();
  }
  private static class Printer extends PrintWriter {
    Printer(PrintStream out){
      super(out);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pr : Printer ; pr := Printer.newPrinter(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    pr.println(Set{n, k}->min() * x + Set{0, n - k}->max() * y) ; 
    pr.close() ; 
    skip ; 
 );
  static class Printer extends OclFile {
   static operation newPrinter( out : OclFile) : Printer
  pre: true
  post: true
  activity:
  ( var self : Printer ;
    self := createPrinter();
    self.initialise(out);
    return self );
  operation initialise( out : OclFile) : void
  pre: true  post: true
  activity: (     execute super(out) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String in1=sc.nextLine();
    int n=Integer.parseInt(in1);
    String in2=sc.nextLine();
    int k=Integer.parseInt(in2);
    String in3=sc.nextLine();
    int x=Integer.parseInt(in3);
    String in4=sc.nextLine();
    int y=Integer.parseInt(in4);
    int shukuhaku=0 ;
    int wk=0 ;
    if(n>=k){
      for(int i=0 ; i<k ; i++){
        shukuhaku+=x ;
        wk=i ;
      }
      for(int j=wk+1 ; j<n ; j++){
        shukuhaku+=y ;
      }
    }
    else {
      for(int i=0 ; i<n ; i++){
        shukuhaku+=x ;
        wk=i ;
      }
    }
    System.out.println(shukuhaku);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var in1 : String ; in1 := sc.nextLine() ;
    var n : int ; n := (in1)->toInteger() ;
    var in2 : String ; in2 := sc.nextLine() ;
    var k : int ; k := (in2)->toInteger() ;
    var in3 : String ; in3 := sc.nextLine() ;
    var x : int ; x := (in3)->toInteger() ;
    var in4 : String ; in4 := sc.nextLine() ;
    var y : int ; y := (in4)->toInteger() ;
    var shukuhaku : int ; shukuhaku := 0 ;
    var wk : int ; wk := 0 ;
    if (n >= k) then (         var i : int ; i := 0 ; while i < k do ( (     shukuhaku := shukuhaku+(x) ; 
     wk := i )  ;     i := i + 1 ) ; 
         var j : int ; j := wk + 1 ; while j < n do ( (     shukuhaku := shukuhaku+(y) )  ;     j := j + 1 ) ) else (         var i : int ; i := 0 ; while i < n do ( (     shukuhaku := shukuhaku+(x) ; 
     wk := i )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(shukuhaku) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int k=scanner.nextInt();
    int x=scanner.nextInt();
    int y=scanner.nextInt();
    if(n>=k){
      System.out.println(k*x+(n-k)*y);
    }
    else {
      System.out.println(n*x);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
    var x : int ; x := scanner.getCurrent()->toInteger() ;
    var y : int ; y := scanner.getCurrent()->toInteger() ;
    if (n >= k) then (     OclFile["System.out"].println(k * x + (n - k) * y) ) else (     OclFile["System.out"].println(n * x) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      double x=sc.nextDouble();
      double h=sc.nextDouble();
      if(x==0 && h==0)break ;
      double c=Math.sqrt(h*h+(x/2)*(x/2));
      double ans=x*x+x*c/2*4 ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var x : double ; x := sc.getCurrent()->toReal() ;
     var h : double ; h := sc.getCurrent()->toReal() ;
    if (x = 0 & h = 0) then     break else skip ; 
    var c : double ; c := (h * h + (x / 2) * (x / 2))->sqrt() ;
    var ans : double ; ans := x * x + x * c / 2 * 4 ;
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean solve(){
    double x=in.nextInt();
    double h=in.nextInt();
    if(x+h==0)return false ;
    double l=Math.sqrt((x/2)*(x/2)+h*h);
    double s=x*x+x*l/2*4 ;
    out.println(s);
    return true ;
  }
  public static void main(String[] args){
    long start=System.currentTimeMillis();
    while(solve());
    out.flush();
    long end=System.currentTimeMillis();
    in.close();
    out.close();
  }
  static void trace(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   operation solve() : boolean
  pre: true
  post: true
  activity: (     var x : double ; x := in.getCurrent()->toInteger() ;
     var h : double ; h := in.getCurrent()->toInteger() ;
    if (x + h = 0) then     return false else skip ; 
    var l : double ; l := ((x / 2) * (x / 2) + h * h)->sqrt() ;
    var s : double ; s := x * x + x * l / 2 * 4 ;
    skip ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : long ; start := OclDate.getSystemTime() ;
     while (solve()) do  ; 
    skip ; 
    var end : long ; end := OclDate.getSystemTime() ;
    skip ; 
    skip ; 
 );
  static   operation trace( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Scanner ;
public class league {
  void solve(Scanner in,PrintWriter out){
    int n=in.nextInt();
    int num=0 ;
    int a[]=new int[1000001];
    int start=0 ;
    for(int i=1 ; i<=n ; i++){
      num+=in.nextInt();
      for(int j=start ; j<num ; j++){
        a[j]=i ;
      }
      start=num ;
    }
    int m=in.nextInt();
    for(int i=0 ; i<m ; i++){
      System.out.print(a[in.nextInt()-1]);
      System.out.println();
    }
  }
  void run(){
    try(Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out)){
      solve(in,out);
    }
  }
  public static void main(String[] args){
    new league().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class league {
   operation solve( in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var num : int ; num := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,1000001)->collect(0) ;
    var start : int ; start := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     num := num+(in.nextInt()) ; 
         var j : int ; j := start ; while j < num do ( (     a[j+1] := i )  ;     j := j + 1 ) ; 
     start := num )  ;     i := i + 1 ) ; 
    var m : int ; m := in.nextInt() ;
        var i : int ; i := 0 ; while i < m do ( (     OclFile["System.out"].print(a[in.nextInt() - 1+1]) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]) ;
 (     execute solve(in, out) ))  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     league.newleague().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigDecimal ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args){
    BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    String str="" ;
    StringTokenizer stk ;
    int tei,takasa ;
    try {
      while(true){
        str=bfr.readLine();
        if(str==""){
          System.exit(0);
        }
        tei=Integer.parseInt(str);
        str=bfr.readLine();
        if(str==""){
          System.exit(0);
        }
        takasa=Integer.parseInt(str);
        if(tei==0 && takasa==0){
          System.exit(0);
        }
        else {
          System.out.println(BigDecimal.valueOf(((double)tei)*((double)tei)+((double)tei)*Math.sqrt(((double)tei*tei/4)+((double)takasa*takasa))*2).toPlainString());
        }
      }
    }
    catch(IOException e){
      System.exit(0);
    }
    catch(NumberFormatException e){
      System.exit(0);
    }
    catch(NullPointerException e){
      System.exit(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bfr : OclFile ; bfr := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := "" ;
    var stk : OclIterator ;
    var tei : int ;
    var takasa : int ;
    try (     while (true) do (     str := bfr.readLine() ; 
     if (str = "") then ( OclProcess.exit(0) ) else skip ; 
    tei := (str)->toInteger() ; 
    str := bfr.readLine() ; 
    if (str = "") then ( OclProcess.exit(0) ) else skip ; 
    takasa := (str)->toInteger() ; 
    if (tei = 0 & takasa = 0) then ( OclProcess.exit(0) ) else (     OclFile["System.out"].println(((tei->oclAsType(double)) * (tei->oclAsType(double)) + (tei->oclAsType(double)) * ((tei->oclAsType(double) * tei / 4) + (takasa->oclAsType(double) * takasa))->sqrt() * 2 + "")->toReal().toPlainString()) ) ;  
 ) )   catch (e : IOException) do ( OclProcess.exit(0) )
   catch (e : IncorrectElementException) do ( OclProcess.exit(0) )
  catch (e : NullAccessException) do ( OclProcess.exit(0) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  Scanner sc=new Scanner(System.in);
  double x ;
  double h ;
  void run(){
    while(sc.hasNext()){
      x=sc.nextDouble();
      h=sc.nextDouble();
      if(x!=0)solve();
    }
  }
  void solve(){
    double r=Math.sqrt(h*h+(x/2)*(x/2));
    double s=x*x+2*(x*r);
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute x : double;
   attribute h : double;
   operation run() : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     x := sc.getCurrent()->toReal() ; 
     h := sc.getCurrent()->toReal() ; 
     if (x /= 0) then     execute solve() ; else skip ) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var r : double ; r := (h * h + (x / 2) * (x / 2))->sqrt() ;
     var s : double ; s := x * x + 2 * (x * r) ;
     OclFile["System.out"].println(s) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    String line=null ;
    while((line=reader.readLine())!=null){
      if(line.isEmpty()){
        continue ;
      }
      double x=Double.parseDouble(line);
      double h=Double.parseDouble(reader.readLine());
      if(x==0 && h==0){
        break ;
      }
      double result=x*x+x*Math.sqrt(4.0*h*h+x*x);
      out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     var line : String ; line := null ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->isEmpty()) then (     continue ) else skip ; 
     var x : double ; x := (line)->toReal() ;
    var h : double ; h := (reader.readLine())->toReal() ;
    if (x = 0 & h = 0) then (     break ) else skip ; 
    var result : double ; result := x * x + x * (4.0 * h * h + x * x)->sqrt() ;
    out.println(result) ; 
 ) ;     line := reader.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int size=Integer.parseInt(scanner.next());
    int quantum=Integer.parseInt(scanner.next());
    int sum=0 ;
    Queue queue=new Queue();
    for(int i=0 ; i<size ; i++){
      String name=scanner.next();
      int time=Integer.parseInt(scanner.next());
      if(time<=quantum){
        sum+=time ;
        System.out.println(name+" "+sum);
      }
      else {
        sum+=quantum ;
        queue.enqueue(new Process(name,time-quantum));
      }
    }
    while(! queue.isEmpty()){
      Process process=queue.dequeue();
      if(process.quantum<=quantum){
        sum+=process.quantum ;
        System.out.println(process.name+" "+sum);
      }
      else {
        sum+=quantum ;
        queue.enqueue(new Process(process.name,process.quantum-quantum));
      }
    }
  }
  static class Queue {
    static final int SIZE=100000 ;
    Process[] array=new Process[SIZE];
    int head=0 ;
    int tail=0 ;
    Process dequeue(){
      if(isEmpty()){
        throw new IllegalStateException("You dequeued from empty "+"queue.");
      }
      Process value=array[tail];
      tail+=1 ;
      if(tail==SIZE){
        tail-=SIZE ;
      }
      return value ;
    }
    void enqueue(Process process){
      if(isFull()){
        throw new IllegalStateException("You enqueued to full queue.");
      }
      array[head]=process ;
      head+=1 ;
      if(head==SIZE){
        head-=SIZE ;
      }
    }
    boolean isFull(){
      return head+1==(tail % SIZE);
    }
    boolean isEmpty(){
      return head==tail ;
    }
  }
  static class Process {
    String name ;
    int quantum ;
    Process(String name,int quantum){
      this.name=name ;
      this.quantum=quantum ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var size : int ; size := (scanner.getCurrent())->toInteger() ;
    var quantum : int ; quantum := (scanner.getCurrent())->toInteger() ;
    var sum : int ; sum := 0 ;
    var queue : Sequence ; queue := Sequence{} ;
        var i : int ; i := 0 ; while i < size do ( (     var name : String ; name := scanner.getCurrent() ;
     var time : int ; time := (scanner.getCurrent())->toInteger() ;
     if (time <= quantum) then (     sum := sum+(time) ; 
     OclFile["System.out"].println(name + " " + sum) ) else (     sum := sum+(quantum) ; 
     queue := queue.enqueue(OclProcess(name, (time)->char2byte() - quantum)) ) )  ;     i := i + 1 ) ; 
    while (not(queue->isEmpty())) do (     var process : OclProcess ; process := queue.dequeue() ;
     if (process.quantum <= quantum) then (     sum := sum+(process.quantum) ; 
     OclFile["System.out"].println(process.name + " " + sum) ) else (     sum := sum+(quantum) ; 
     queue := queue.enqueue(OclProcess(process.name, process.quantum - quantum)) ) ) ; 
 );
  static class Queue {
  static    attribute SIZE : int := 100000;
   attribute array : Sequence(OclProcess) := Integer.subrange(1,SIZE)->collect(null);
   attribute head : int := 0;
   attribute tail : int := 0;
   operation dequeue() : OclProcess
  pre: true
  post: true
  activity: (     if (isEmpty()) then (     error IncorrectElementException("You dequeued from empty " + "queue.") ) else skip ; 
     var value : OclProcess ; value := array[tail+1] ;
    tail := tail+(1) ; 
    if (tail = SIZE) then (     tail := tail-(SIZE) ) else skip ; 
    return value 
 );
   operation enqueue( process : OclProcess) : void
  pre: true
  post: true
  activity: (     if (isFull()) then (     error IncorrectElementException("You enqueued to full queue.") ) else skip ; 
     array[head+1] := process ; 
     head := head+(1) ; 
     if (head = SIZE) then (     head := head-(SIZE) ) else skip );
   operation isFull() : boolean
  pre: true
  post: true
  activity: (     return head + 1 = (tail mod SIZE) );
   operation isEmpty() : boolean
  pre: true
  post: true
  activity: (     return head = tail );
}
  static class Process {
   attribute name : String;
   attribute quantum : int;
   static operation newProcess( name : String, quantum : int) : Process
  pre: true
  post: true
  activity:
  ( var self : Process ;
    self := createProcess();
    self.initialise(name, quantum);
    return self );
  operation initialise( name : String, quantum : int) : void
  pre: true  post: true
  activity: (     self.name := name ; 
     self.quantum := quantum );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner scan=new Scanner(System.in);
    ArrayList<String>scList=new ArrayList<>();
    for(int i=0 ; i>=0 ; i++){
      try {
        scList.add(scan.nextLine());
      }
      catch(Exception e){
        break ;
      }
    }
    String[] numlist=scList.get(0).split(" ");
    int Sheep=Integer.parseInt(numlist[0]);
    int Wolve=Integer.parseInt(numlist[1]);
    if(Wolve>=Sheep){
      System.out.println("unsafe");
    }
    else {
      System.out.println("safe");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var scList : Sequence(String) ; scList := Sequence{} ;
        var i : int ; i := 0 ; while i >= 0 do ( (     try (     scList := scList->including(scan.nextLine()) )   catch (e : ProgramException) do (     break )
 )  ;     i := i + 1 ) ; 
    var numlist : Sequence(String) ; numlist := scList->at(0+1)->split(" ") ;
    var Sheep : int ; Sheep := (numlist[0+1])->toInteger() ;
    var Wolve : int ; Wolve := (numlist[1+1])->toInteger() ;
    if (Wolve >= Sheep) then (     OclFile["System.out"].println("unsafe") ) else (     OclFile["System.out"].println("safe") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.io.BufferedOutputStream ;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    int s=sc.nextInt();
    int w=sc.nextInt();
    if(w>=s){
      out.println("unsafe");
    }
    else out.println("safe");
    out.close();
  }
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var s : int ; s := sc.nextInt() ;
    var w : int ; w := sc.nextInt() ;
    if (w >= s) then (     skip ) else     skip ; ;  
    skip ; 
 );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int s=sc.nextInt();
    int w=sc.nextInt();
    if(s<=w){
      System.out.println("unsafe");
    }
    else {
      System.out.println("safe");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : int ; s := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
     if (s <= w) then (     OclFile["System.out"].println("unsafe") ) else (     OclFile["System.out"].println("safe") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
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 ;
  }
}
public class Main {
  public static PrintWriter out ;
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    out=new PrintWriter(new BufferedOutputStream(System.out));
    int s=sc.nextInt();
    int w=sc.nextInt();
    if(w>=s){
      out.println("unsafe");
    }
    else {
      out.println("safe");
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
class Main {
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var s : int ; s := sc.nextInt() ;
    var w : int ; w := sc.nextInt() ;
    if (w >= s) then (     skip ) else (     skip ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner scan ;
    int sheep ;
    int wolves ;
    sheep=0 ;
    wolves=0 ;
    scan=new Scanner(System.in);
    sheep=scan.nextInt();
    wolves=scan.nextInt();
    if(sheep>wolves){
      System.out.println("safe");
    }
    else {
      System.out.println("unsafe");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ;
     var sheep : int ;
    var wolves : int ;
    sheep := 0 ; 
    wolves := 0 ; 
    scan := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
    sheep := scan.getCurrent()->toInteger() ; 
    wolves := scan.getCurrent()->toInteger() ; 
    if (sheep > wolves) then (     OclFile["System.out"].println("safe") ) else (     OclFile["System.out"].println("unsafe") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class main {
  public static int count(int num){
    int sum=0 ;
    while(num>0){
      sum+=num % 10 ;
      num=num/10 ;
    }
    return sum ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int k,i=1,mo=19 ;
    k=in.nextInt();
    while(i!=k){
      mo++;
      if(10==count(mo)){
        i++;
      }
    }
    System.out.println(mo);
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation count( num : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (num > 0) do (     sum := sum+(num mod 10) ; 
     num := num / 10 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ;
    var i : int ; i := 1 ;
    var mo : int ; mo := 19 ;
    k := in.getCurrent()->toInteger() ; 
    while (i /= k) do (     mo := mo + 1 ; 
     if (10 = count(mo)) then (     i := i + 1 ) else skip ) ; 
    OclFile["System.out"].println(mo) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class tp {
  public static void main(String[] args)throws IOException {
    BufferedReader bs=new BufferedReader(new InputStreamReader(System.in));
    long size=Long.parseLong(bs.readLine());
    long count=1 ;
    long start=19 ;
    while(count!=size){
      start=start+9 ;
      if(getSum(start)==10){
        count++;
      }
    }
    System.out.println(start);
  }
  static long getSum(long n){
    long sum=0 ;
    while(n>0){
      sum+=n % 10 ;
      n=n/10 ;
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class tp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bs : OclFile ; bs := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var size : long ; size := (bs.readLine())->toLong() ;
    var count : long ; count := 1 ;
    var start : long ; start := 19 ;
    while (count /= size) do (     start := start + 9 ; 
     if (getSum(start) = 10) then (     count := count + 1 ) else skip ) ; 
    OclFile["System.out"].println(start) ; 
 );
  static   operation getSum( n : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     while (n > 0) do (     sum := sum+(n mod 10) ; 
     n := n / 10 ) ; 
     return sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class codforce {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int arr[]=new int[1000001];
    ArrayList<Integer>list=new ArrayList<>();
    int previous=0 ;
    int count=0 ;
    for(int i=0 ; i<t ; i++){
      list.add(sc.nextInt());
      count+=list.get(i);
      for(int j=previous+1 ; j<=count ; j++){
        arr[j]=i+1 ;
      }
      previous=count ;
    }
    int str=sc.nextInt();
    for(int i=0 ; i<str ; i++){
      System.out.println(arr[sc.nextInt()]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codforce {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,1000001)->collect(0) ;
    var list : Sequence(int) ; list := Sequence{} ;
    var previous : int ; previous := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < t do ( (     list := list->including(sc.getCurrent()->toInteger()) ; 
     count := count+(list->at(i+1)) ; 
         var j : int ; j := previous + 1 ; while j <= count do ( (     arr[j+1] := i + 1 )  ;     j := j + 1 ) ; 
     previous := count )  ;     i := i + 1 ) ; 
    var str : int ; str := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < str do ( (     OclFile["System.out"].println(arr[sc.getCurrent()->toInteger()+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    out=new PrintWriter(new BufferedOutputStream(System.out));
    int k=sc.nextInt();
    int cnt=0 ;
    int i=0 ;
    while(cnt<k){
      if(isPerfect(i)){
        cnt++;
      }
      i++;
    }
    System.out.println(i-1);
    out.close();
  }
  public static boolean isPerfect(int num){
    int sum=0 ;
    while(num!=0){
      sum+=num % 10 ;
      num=num/10 ;
    }
    return sum==10 ;
  }
  public static PrintWriter out ;
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var k : int ; k := sc.nextInt() ;
    var cnt : int ; cnt := 0 ;
    var i : int ; i := 0 ;
    while (cnt < k) do (     if (isPerfect(i)) then (     cnt := cnt + 1 ) else skip ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println(i - 1) ; 
    out.close() ; 
 );
  static   operation isPerfect( num : int) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (num /= 0) do (     sum := sum+(num mod 10) ; 
     num := num / 10 ) ; 
     return sum = 10 );
  static   attribute out : OclFile;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Perfect_Number {
  static Scanner sc=new Scanner(System.in);
  public static int sumn(int n){
    return n==0 ? 0 :(n % 10)+sumn(n/10);
  }
  public static void main(String[] args){
    int n=sc.nextInt();
    int c=0 ;
    while(true)if(sumn(++c)==10 &&(n--==1)){
      System.out.println(c);
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Perfect_Number {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation sumn( n : int) : int
  pre: true
  post: true
  activity: (     return if n = 0 then 0 else (n mod 10) + sumn(n / 10) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var c : int ; c := 0 ;
     while (true) do     if (sumn((c + 1)) = 10 & (n = 1)) then (     OclFile["System.out"].println(c) ; 
     return ) else skip ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
class GFG {
  static final int MAX=1000000 ;
  static boolean[] prime=new boolean[MAX];
  public static void sieve(){
    Arrays.fill(prime,true);
    for(int p=2 ; p*p<MAX ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<MAX ; i+=p)prime[i]=false ;
      }
    }
  }
  static void printPrimeQuad(int n){
    for(int i=0 ; i<n-7 ; i++){
      if(prime[i] && prime[i+2] && prime[i+6] && prime[i+8]){
        System.out.println(i+" "+(i+2)+" "+(i+6)+" "+(i+8));
      }
    }
  }
  public static void main(String[] args){
    int n=20 ;
    sieve();
    printPrimeQuad(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX : int := 1000000;
  static   attribute prime : Sequence(boolean) := Integer.subrange(1,MAX)->collect(false);
  static   operation sieve() : void
  pre: true
  post: true
  activity: (     prime := prime->collect(true) ; 
         var p : int ; p := 2 ; while p * p < MAX do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i < MAX do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation printPrimeQuad( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n - 7 do ( (     if (prime[i+1] & prime[i + 2+1] & prime[i + 6+1] & prime[i + 8+1]) then (     OclFile["System.out"].println(i + " " + (i + 2) + " " + (i + 6) + " " + (i + 8)) ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 20 ;
     execute sieve() ; 
     execute printPrimeQuad(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int K=scanner.nextInt();
    for(int i=0 ; i<K ; i++){
      System.out.print("ACL");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var K : int ; K := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < K do ( (     OclFile["System.out"].print("ACL") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    Main mainObj=new Main();
    mainObj.solve();
  }
  public void solve()throws IOException {
    FastScanner fs=new FastScanner();
    int k=fs.nextInt();
    String ans="" ;
    for(int i=0 ; i<k ; i++){
      ans+="ACL" ;
    }
    System.out.println(ans);
  }
  public class FastScanner {
    BufferedReader reader ;
    private StringTokenizer st ;
    public FastScanner(){
      st=null ;
      reader=new BufferedReader(new InputStreamReader(System.in));
    }
    public String next()throws IOException {
      if(st==null || ! st.hasMoreElements()){
        st=new StringTokenizer(reader.readLine());
      }
      return st.nextToken();
    }
    public String nextLine()throws IOException {
      st=null ;
      String readLine=null ;
      readLine=reader.readLine();
      return readLine ;
    }
    public int nextInt()throws NumberFormatException,IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws NumberFormatException,IOException {
      return Long.parseLong(next());
    }
    public int[] nextIntArr(int n)throws NumberFormatException,IOException {
      int[] retArr=new int[n];
      for(int i=0 ; i<n ; i++){
        retArr[i]=nextInt();
      }
      return retArr ;
    }
    public long[] nextLongArr(int n)throws NumberFormatException,IOException {
      long[] retArr=new long[n];
      for(int i=0 ; i<n ; i++){
        retArr[i]=nextLong();
      }
      return retArr ;
    }
    public void close()throws IOException {
      reader.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mainObj : Main ; mainObj := Main.newMain() ;
     mainObj.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var k : int ; k := fs.nextInt() ;
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < k do ( (     ans := ans+("ACL") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
 class FastScanner {
   attribute reader : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     st := null ; 
     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (st = null or not(st.hasNext())) then (     st := OclIterator.newOclIterator_String(reader.readLine()) ) else skip ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     st := null ; 
     var readLine : String ; readLine := null ;
     readLine := reader.readLine() ; 
     return readLine );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextIntArr( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var retArr : Sequence(int) ; retArr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     retArr[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return retArr );
   operation nextLongArr( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var retArr : Sequence(long) ; retArr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     retArr[i+1] := nextLong() )  ;     i := i + 1 ) ; 
     return retArr );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      PrintWriter ot=new PrintWriter(System.out);
      int t=Integer.parseInt(br.readLine().trim());
      while(t-->0){
        ot.print("ACL");
      }
      ot.close();
      br.close();
    }
    catch(Exception e){
      System.err.println("ERROR");
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var ot : OclFile ; ot := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine()->trim())->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     skip ) ;  ) ;  
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     OclFile["System.err"].println("ERROR") ; 
     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    FastReader s=new FastReader();
    int k=s.nextInt();
    System.out.println("ACL".repeat(k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : FastReader ; s := FastReader.newFastReader() ;
     var k : int ; k := s.nextInt() ;
     OclFile["System.out"].println("ACL".repeat(k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.reflect.Array ;
public class Main {
  static long mod=1000000007 ;
  static long mod2=998244353 ;
  static Scanner inp=new Scanner(System.in);
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String args[]){
    Main g=new Main();
    g.main();
    out.close();
  }
  void main(){
    int k=inp.nextInt();
    for(int i=0 ; i<k ; i++)out.print("ACL");
  }
  static void input(long a[],int n){
    for(int i=0 ; i<n ; i++){
      a[i]=inp.nextLong();
    }
  }
  static void input(int a[],int n){
    for(int i=0 ; i<n ; i++){
      a[i]=inp.nextInt();
    }
  }
  static void input(String s[],int n){
    for(int i=0 ; i<n ; i++){
      s[i]=inp.next();
    }
  }
  static void input(int a[][],int n,int m){
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        a[i][j]=inp.nextInt();
      }
    }
  }
  static void input(long a[][],int n,int m){
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        a[i][j]=inp.nextLong();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := 1000000007;
  static   attribute mod2 : long := 998244353;
  static   attribute inp : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : Main ; g := Main.newMain() ;
     g.main() ; 
     skip );
   operation main() : void
  pre: true
  post: true
  activity: (     var k : int ; k := inp.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < k do (     skip ;  ;     i := i + 1 ) );
  static   operation input( a : Sequence(long), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := inp.getCurrent()->toLong() )  ;     i := i + 1 ) );
  static   operation input( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := inp.getCurrent()->toInteger() )  ;     i := i + 1 ) );
  static   operation input( s : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     s[i+1] := inp.getCurrent() )  ;     i := i + 1 ) );
  static   operation input( a : Sequence(Sequence(int)), n : int, m : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     a[i+1][j+1] := inp.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation input( a : Sequence(Sequence(long)), n : int, m : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     a[i+1][j+1] := inp.getCurrent()->toLong() )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static final int MAX=1000 ;
  static int maxSubsequenceSubstring(char x[],char y[],int n,int m){
    int dp[][]=new int[MAX][MAX];
    for(int i=0 ; i<=m ; i++)for(int j=0 ; j<=n ; j++)dp[i][j]=0 ;
    for(int i=1 ; i<=m ; i++){
      for(int j=1 ; j<=n ; j++){
        if(x[j-1]==y[i-1])dp[i][j]=1+dp[i-1][j-1];
        else dp[i][j]=dp[i][j-1];
      }
    }
    int ans=0 ;
    for(int i=1 ; i<=m ; i++)ans=Math.max(ans,dp[i][n]);
    return ans ;
  }
  public static void main(String[] args){
    char x[]="ABCD".toCharArray();
    char y[]="BACDBDCD".toCharArray();
    int n=x.length,m=y.length ;
    System.out.println(maxSubsequenceSubstring(x,y,n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 1000;
  static   operation maxSubsequenceSubstring( x : Sequence(String), y : Sequence(String), n : int, m : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,MAX)->collect(Integer.subrange(1,MAX)->collect(0)) ;
         var i : int ; i := 0 ; while i <= m do (         var j : int ; j := 0 ; while j <= n do (     dp[i+1][j+1] := 0 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= m do ( (         var j : int ; j := 1 ; while j <= n do ( (     if (x[j - 1+1] = y[i - 1+1]) then     dp[i+1][j+1] := 1 + dp[i - 1+1][j - 1+1] ; else     dp[i+1][j+1] := dp[i+1][j - 1+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= m do (     ans := Set{ans, dp[i+1][n+1]}->max() ;  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : Sequence(String) ; x := "ABCD"->characters() ;
     var y : Sequence(String) ; y := "BACDBDCD"->characters() ;
     var n : int ; n := x->size() ;
    var m : int ; m := y->size() ;
     OclFile["System.out"].println(maxSubsequenceSubstring(x, y, n, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findSum(int n,int a,int b){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)if(i % a==0 || i % b==0)sum+=i ;
    return sum ;
  }
  public static void main(String[] args){
    int n=10,a=3,b=5 ;
    System.out.println(findSum(n,a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSum( n : int, a : int, b : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     if (i mod a = 0 or i mod b = 0) then     sum := sum+(i) ; else skip ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
    var a : int ; a := 3 ;
    var b : int ; b := 5 ;
     OclFile["System.out"].println(findSum(n, a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Scanner ;
public class Codeforces {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int piles=sc.nextInt();
    int[] tab=new int[piles];
    int totalWorms=0 ;
    for(int i=0 ; i<piles ; i++){
      int val=sc.nextInt();
      tab[i]=totalWorms+val ;
      totalWorms+=val ;
    }
    int juicies=sc.nextInt();
    for(int i=0 ; i<juicies ; i++){
      int key=sc.nextInt();
      if(piles==1){
        System.out.println(1);
        continue ;
      }
      if(key<=tab[0]){
        System.out.println(1);
        continue ;
      }
      int min=1 ;
      int max=tab.length-1 ;
      int mid=0 ;
      while(true){
        mid=(max+min)/2 ;
        if(tab[mid-1]>=key){
          max=mid-1 ;
        }
        else if(tab[mid]<key){
          min=mid+1 ;
        }
        else {
          break ;
        }
      }
      System.out.println(mid+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var piles : int ; piles := sc.getCurrent()->toInteger() ;
    var tab : Sequence(int) ; tab := Integer.subrange(1,piles)->collect(0) ;
    var totalWorms : int ; totalWorms := 0 ;
        var i : int ; i := 0 ; while i < piles do ( (     var val : int ; val := sc.getCurrent()->toInteger() ;
     tab[i+1] := totalWorms + val ; 
     totalWorms := totalWorms+(val) )  ;     i := i + 1 ) ; 
    var juicies : int ; juicies := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < juicies do ( (     var key : int ; key := sc.getCurrent()->toInteger() ;
     if (piles = 1) then (     OclFile["System.out"].println(1) ; 
     continue ) else skip ; 
    if (key <= tab[0+1]) then (     OclFile["System.out"].println(1) ; 
     continue ) else skip ; 
    var min : int ; min := 1 ;
    var max : int ; max := tab->size() - 1 ;
    var mid : int ; mid := 0 ;
    while (true) do (     mid := (max + min) / 2 ; 
     if (tab[mid - 1+1] >= key) then (     max := mid - 1 ) else     if (tab[mid+1] < key) then (     min := mid + 1 ) else (     break ) ;  ) ; 
    OclFile["System.out"].println(mid + 1) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class tanyaandpostcard {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    String s1=in.nextLine();
    String s2=in.nextLine();
    int a[]=new int[123];
    int b[]=new int[s1.length()];
    int i,y=0,w=0 ;
    char ch ;
    for(i=0 ; i<s2.length(); i++)a[s2.charAt(i)]+=1 ;
    for(i=0 ; i<s1.length(); i++){
      ch=s1.charAt(i);
      if(a[ch]>=1){
        a[ch]--;
        b[i]=1 ;
        y++;
      }
    }
    for(i=0 ; i<s1.length(); i++){
      ch=s1.charAt(i);
      if(b[i]==0){
        if(ch<=90)ch=(char)((int)ch+32);
        else ch=(char)((int)ch-32);
        if(a[ch]>=1){
          a[ch]--;
          w++;
        }
      }
    }
    System.out.println(y+" "+w);
  }
}
------------------------------------------------------------
OCL File:
---------
 class tanyaandpostcard {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := in.nextLine() ;
    var s2 : String ; s2 := in.nextLine() ;
    var a : Sequence(int) ; a := Integer.subrange(1,123)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,s1->size())->collect(0) ;
    var i : int ;
    var y : int ; y := 0 ;
    var w : int ; w := 0 ;
    var ch : String ;
        i := 0 ; while i < s2->size() do (     a[s2->at(i+1)+1] := a[s2->at(i+1)+1]+(1) ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < s1->size() do ( (     ch := s1->at(i+1) ; 
     if (a[ch+1] >= 1) then (     a[ch+1] := a[ch+1] - 1 ; 
     b[i+1] := 1 ; 
     y := y + 1 ) else skip )  ;     i := i + 1 ) ; 
        i := 0 ; while i < s1->size() do ( (     ch := s1->at(i+1) ; 
     if (b[i+1] = 0) then (     if (ch <= 90) then     ch := ((ch)->char2byte() + 32)->oclAsType(String) else     ch := ((ch)->char2byte() - 32)->oclAsType(String) ; ;  
     if (a[ch+1] >= 1) then (     a[ch+1] := a[ch+1] - 1 ; 
     w := w + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(y + " " + w) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.io.IOException ;
import java.util.LinkedList ;
public class Main {
  static int n,q ;
  static class Process {
    String pid ;
    int task ;
    int end ;
    public Process(String pid,int task){
      this.pid=pid ;
      this.task=task ;
    }
    public void setEnd(int end){
      this.end=end ;
    }
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    String[] st=br.readLine().split(" ");
    n=Integer.parseInt(st[0]);
    q=Integer.parseInt(st[1]);
    LinkedList<Process>Queue=new LinkedList<>();
    for(int i=0 ; i<n ; i++){
      st=br.readLine().split(" ");
      String pid=st[0];
      int task=Integer.parseInt(st[1]);
      Process p=new Process(pid,task);
      Queue.add(p);
    }
    int ePosition=0 ;
    Process[] endProcess=new Process[n];
    int time=0 ;
    while(! Queue.isEmpty()){
      Process p=Queue.pollFirst();
      if(p.task<q){
        time+=p.task ;
        p.end=time ;
        endProcess[ePosition++]=p ;
      }
      else if(p.task>q){
        p.task-=q ;
        time+=q ;
        Queue.add(p);
      }
      else {
        time+=q ;
        p.end=time ;
        endProcess[ePosition++]=p ;
      }
    }
    for(Process p : endProcess){
      bw.append(p.pid+" "+p.end+"\n");
    }
    bw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static class Process {
   attribute pid : String;
   attribute task : int;
   attribute end : int;
   static operation newProcess( pid : String, task : int) : Process
  pre: true
  post: true
  activity:
  ( var self : Process ;
    self := createProcess();
    self.initialise(pid, task);
    return self );
  operation initialise( pid : String, task : int) : void
  pre: true  post: true
  activity: (     self.pid := pid ; 
     self.task := task );
   operation setEnd( end : int) : void
  pre: true
  post: true
  activity: (     self.end := end );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var st : Sequence(String) ; st := br.readLine()->split(" ") ;
    n := (st[0+1])->toInteger() ; 
    q := (st[1+1])->toInteger() ; 
    var Queue : Sequence(OclProcess) ; Queue := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     st := br.readLine()->split(" ") ; 
     var pid : String ; pid := st[0+1] ;
    var task : int ; task := (st[1+1])->toInteger() ;
    var p : OclProcess ; p := OclProcess(pid, task) ;
    Queue := Queue->including(p) ; 
 )  ;     i := i + 1 ) ; 
    var ePosition : int ; ePosition := 0 ;
    var endProcess : Sequence(OclProcess) ; endProcess := Integer.subrange(1,n)->collect(null) ;
    var time : int ; time := 0 ;
    while (not(Queue->isEmpty())) do (     var p : OclProcess ; p := Queue->first() ;
     if (p.task < q) then (     time := time+(p.task) ; 
     p.end := time ; 
      endProcess[ePosition+1] := p  ; ePosition := ePosition + 1 ) else     if (p.task > q) then (     p.task := p.task-(q) ; 
     time := time+(q) ; 
     Queue := Queue->including(p) ) else (     time := time+(q) ; 
     p.end := time ; 
      endProcess[ePosition+1] := p  ; ePosition := ePosition + 1 ) ;  ) ; 
    for (p : endProcess) do ( (     skip )  ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Sol {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    StringBuilder s=new StringBuilder(scan.next());
    String t=scan.next();
    int ura=0 ;
    int opa=0 ;
    Map<Character,Integer>tmap=new HashMap<>();
    for(int i=0 ; i<t.length(); i++){
      Character ch=t.charAt(i);
      if(! tmap.containsKey(ch))tmap.put(ch,1);
      else tmap.put(ch,tmap.get(ch)+1);
    }
    int length=s.length();
    for(int i=0 ; i<length ; i++){
      Character ch=s.charAt(i);
      Integer num=tmap.get(ch);
      if(num==null)continue ;
      int inum=num ;
      if(inum==1)tmap.remove(ch);
      else tmap.put(ch,inum-1);
      s.setCharAt(i,'Я');
      ura++;
    }
    for(int i=0 ; i<length ; i++){
      Character ch=s.charAt(i);
      Character rch=reverse(ch);
      Integer num=tmap.get(rch);
      if(num==null)continue ;
      int inum=num ;
      if(inum==1)tmap.remove(rch);
      else tmap.put(rch,inum-1);
      opa++;
    }
    System.out.println(ura+" "+opa);
  }
  public static Character reverse(Character ch){
    if(Character.isLowerCase(ch)){
      return Character.toUpperCase(ch);
    }
    else return Character.toLowerCase(ch);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sol {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := StringLib.newString(scan.getCurrent()) ;
    var t : String ; t := scan.getCurrent() ;
    var ura : int ; ura := 0 ;
    var opa : int ; opa := 0 ;
    var tmap : Map(String,int) ; tmap := Map{} ;
        var i : int ; i := 0 ; while i < t->size() do ( (     var ch : String ; ch := t->at(i+1) ;
     if (not(tmap->keys()->includes(ch))) then     tmap := tmap->union(Map{ch |-> 1}) ; else     tmap := tmap->union(Map{ch |-> tmap->at(ch) + 1}) ; )  ;     i := i + 1 ) ; 
    var length : int ; length := s->size() ;
        var i : int ; i := 0 ; while i < length do ( (     var ch : String ; ch := s->at(i+1) ;
     var num : int ; num := tmap->at(ch) ;
    if (num = null) then     continue else skip ; 
    var inum : int ; inum := num ;
    if (inum = 1) then     tmap := tmap->antirestrict(Set{ch}) else     tmap := tmap->union(Map{ch |-> inum - 1}) ; ;  
    s := s.setAt(i+1, '?') ; 
    ura := ura + 1 ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < length do ( (     var ch : String ; ch := s->at(i+1) ;
     var rch : String ; rch := reverse(ch) ;
    var num : int ; num := tmap->at(rch) ;
    if (num = null) then     continue else skip ; 
    var inum : int ; inum := num ;
    if (inum = 1) then     tmap := tmap->antirestrict(Set{rch}) else     tmap := tmap->union(Map{rch |-> inum - 1}) ; ;  
    opa := opa + 1 ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ura + " " + opa) ; 
 );
  static   operation reverse( ch : String) : String
  pre: true
  post: true
  activity: (     if ((ch->toLowerCase() = ch)) then (     return (ch + "")->toUpperCase() ) else     return (ch + "")->toLowerCase() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=100000 ;
  static int sequence[]=new int[MAX+1];
  static void vanEckSequence(){
    for(int i=0 ; i<MAX ; i++){
      sequence[i]=0 ;
    }
    for(int i=0 ; i<MAX ; i++){
      for(int j=i-1 ; j>=0 ; j--){
        if(sequence[j]==sequence[i]){
          sequence[i+1]=i-j ;
          break ;
        }
      }
    }
  }
  static int getCount(int n){
    int nthTerm=sequence[n-1];
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(sequence[i]==nthTerm)count++;
    }
    return count ;
  }
  public static void main(String[] args){
    vanEckSequence();
    int n=5 ;
    System.out.println(getCount(n));
    n=11 ;
    System.out.println(getCount(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100000;
  static   attribute sequence : int := Integer.subrange(1,MAX + 1)->collect(0);
  static   operation vanEckSequence() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < MAX do ( (     sequence[i+1] := 0 )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < MAX do ( (         var j : int ; j := i - 1 ; while j >= 0 do ( (     if (sequence[j+1] = sequence[i+1]) then (     sequence[i + 1+1] := i - j ; 
     break ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) );
  static   operation getCount( n : int) : int
  pre: true
  post: true
  activity: (     var nthTerm : int ; nthTerm := sequence[n - 1+1] ;
     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (sequence[i+1] = nthTerm) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute vanEckSequence() ; 
     var n : int ; n := 5 ;
    OclFile["System.out"].println(getCount(n)) ; 
    n := 11 ; 
    OclFile["System.out"].println(getCount(n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=100000 ;
  static int sequence[]=new int[MAX+1];
  static void vanEckSequence(){
    for(int i=0 ; i<MAX ; i++){
      sequence[i]=0 ;
    }
    for(int i=0 ; i<MAX ; i++){
      for(int j=i-1 ; j>=0 ; j--){
        if(sequence[j]==sequence[i]){
          sequence[i+1]=i-j ;
          break ;
        }
      }
    }
  }
  static int getCount(int n){
    int count=1 ;
    int i=n-1 ;
    while(sequence[i+1]!=0){
      count++;
      i=i-sequence[i+1];
    }
    return count ;
  }
  public static void main(String[] args){
    vanEckSequence();
    int n=5 ;
    System.out.println(getCount(n));
    n=11 ;
    System.out.println(getCount(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100000;
  static   attribute sequence : int := Integer.subrange(1,MAX + 1)->collect(0);
  static   operation vanEckSequence() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < MAX do ( (     sequence[i+1] := 0 )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < MAX do ( (         var j : int ; j := i - 1 ; while j >= 0 do ( (     if (sequence[j+1] = sequence[i+1]) then (     sequence[i + 1+1] := i - j ; 
     break ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) );
  static   operation getCount( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 1 ;
     var i : int ; i := n - 1 ;
     while (sequence[i + 1+1] /= 0) do (     count := count + 1 ; 
     i := i - sequence[i + 1+1] ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute vanEckSequence() ; 
     var n : int ; n := 5 ;
    OclFile["System.out"].println(getCount(n)) ; 
    n := 11 ; 
    OclFile["System.out"].println(getCount(n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=1000 ;
  static int sequence[]=new int[MAX];
  static void vanEckSequence(){
    for(int i=0 ; i<MAX-1 ; i++){
      sequence[i]=0 ;
    }
    for(int i=0 ; i<MAX-1 ; i++){
      for(int j=i-1 ; j>=0 ; j--){
        if(sequence[j]==sequence[i]){
          sequence[i+1]=i-j ;
          break ;
        }
      }
    }
  }
  static int getNthTerm(int n){
    return sequence[n];
  }
  public static void main(String[] args){
    vanEckSequence();
    int n=6 ;
    System.out.println(getNthTerm(n));
    n=100 ;
    System.out.println(getNthTerm(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 1000;
  static   attribute sequence : int := Integer.subrange(1,MAX)->collect(0);
  static   operation vanEckSequence() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < MAX - 1 do ( (     sequence[i+1] := 0 )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < MAX - 1 do ( (         var j : int ; j := i - 1 ; while j >= 0 do ( (     if (sequence[j+1] = sequence[i+1]) then (     sequence[i + 1+1] := i - j ; 
     break ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) );
  static   operation getNthTerm( n : int) : int
  pre: true
  post: true
  activity: (     return sequence[n+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute vanEckSequence() ; 
     var n : int ; n := 6 ;
    OclFile["System.out"].println(getNthTerm(n)) ; 
    n := 100 ; 
    OclFile["System.out"].println(getNthTerm(n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int __gcd(int a,int b){
    if(a==0 || b==0)return 0 ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static int nthElement(int a,int b,int n){
    int lcm=(a*b)/__gcd(a,b);
    int l=1,r=Math.min(a,b)*n ;
    while(l<=r){
      int mid=(l+r)>>1 ;
      int val=mid/a+mid/b-mid/lcm ;
      if(val==n)return Math.max((mid/a)*a,(mid/b)*b);
      if(val<n)l=mid+1 ;
      else r=mid-1 ;
    }
    return 0 ;
  }
  static public void main(String[] args){
    int a=5,b=3,n=5 ;
    System.out.println(nthElement(a,b,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0 or b = 0) then     return 0 else skip ; 
     if (a = b) then     return a else skip ; 
     if (a > b) then     return __gcd(a - b, b) else skip ; 
     return __gcd(a, b - a) );
  static   operation nthElement( a : int, b : int, n : int) : int
  pre: true
  post: true
  activity: (     var lcm : int ; lcm := (a * b) / __gcd(a, b) ;
     var l : int ; l := 1 ;
    var r : int ; r := Set{a, b}->min() * n ;
     while (l <= r) do (     var mid : int ; mid := ((l + r)/(2->pow(1)))->oclAsType(long) ;
     var val : int ; val := mid / a + mid / b - mid / lcm ;
     if (val = n) then     return Set{(mid / a) * a, (mid / b) * b}->max() else skip ; 
     if (val < n) then     l := mid + 1 ; else     r := mid - 1 ; ) ; 
     return 0 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 5 ;
    var b : int ; b := 3 ;
    var n : int ; n := 5 ;
     OclFile["System.out"].println(nthElement(a, b, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.sql.Timestamp ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int y=in.nextInt();
    boolean leap=check_leap(y);
    int sum=0 ;
    int mod=0 ;
    for(int i=y+1 ; ; i++){
      if(check_leap(i)){
        sum+=366 ;
      }
      else {
        sum+=365 ;
      }
      if(sum % 7==0){
        if((check_leap(i)&& leap)||(! check_leap(i)&& ! leap)){
          System.out.println(i);
          return ;
        }
        else {
          continue ;
        }
      }
    }
  }
  static boolean check_leap(int y){
    return y % 400==0 ||(y % 4==0 && y % 100!=0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var y : int ; y := in.getCurrent()->toInteger() ;
    var leap : boolean ; leap := check_leap(y) ;
    var sum : int ; sum := 0 ;
    var mod : int ; mod := 0 ;
        var i : int ; i := y + 1 ; while true do ( (     if (check_leap(i)) then (     sum := sum+(366) ) else (     sum := sum+(365) ) ;  
     if (sum mod 7 = 0) then (     if ((check_leap(i) & leap) or (not(check_leap(i)) & not(leap))) then (     OclFile["System.out"].println(i) ; 
     return ) else (     continue ) ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation check_leap( y : int) : boolean
  pre: true
  post: true
  activity: (     return y mod 400 = 0 or (y mod 4 = 0 & y mod 100 /= 0) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class TheSameCalendar {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int currentDay=((isLeapYear(n))? 366 : 365)% 7 ;
    n+=1 ;
    System.out.println(getYear(n,currentDay,isLeapYear(n-1)));
  }
  private static int getYear(int n,int currentDay,boolean wasLeapYear){
    if(currentDay==0){
      if(wasLeapYear==isLeapYear(n)){
        return n ;
      }
    }
    currentDay+=(isLeapYear(n))? 366 : 365 ;
    n++;
    return getYear(n,currentDay % 7,wasLeapYear);
  }
  private static boolean isLeapYear(int n){
    if(n % 100!=0){
      return((n % 4)==0);
    }
    else {
      return((n % 400)==0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TheSameCalendar {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var currentDay : int ; currentDay := (if (isLeapYear(n)) then 366 else 365 endif) mod 7 ;
    n := n+(1) ; 
    OclFile["System.out"].println(getYear(n, currentDay, isLeapYear(n - 1))) ; 
 );
  static   operation getYear( n : int, currentDay : int, wasLeapYear : boolean) : int
  pre: true
  post: true
  activity: (     if (currentDay = 0) then (     if (wasLeapYear = isLeapYear(n)) then (     return n ) else skip ) else skip ; 
     currentDay := currentDay+(if (isLeapYear(n)) then 366 else 365 endif) ; 
     n := n + 1 ; 
     return getYear(n, currentDay mod 7, wasLeapYear) );
  static   operation isLeapYear( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n mod 100 /= 0) then (     return ((n mod 4) = 0) ) else (     return ((n mod 400) = 0) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class Main {
  static int n ;
  static Scanner sc=new Scanner(System.in);
  static Queue<String>events ;
  static boolean read(){
    int cnt=0 ;
    String event ;
    events=new LinkedList<String>();
    do {
      event=sc.next();
      if(event.equals("OUT")){
        cnt++;
      }
      else {
        events.offer(event);
      }
    }
    while(cnt<3);
    return true ;
  }
  static int solve(){
    int ans=0,s=0 ;
    while(! events.isEmpty()){
      String e=events.poll();
      s=(s<<1)+1 ;
      if(e.equals("HIT")){
        if((s & 8)>1){
          ans++;
        }
        s=(s & 7);
      }
      else {
        for(int i=1 ; i<16 ; i=(i<<1)){
          if((s & i)>=1){
            ans++;
          }
        }
        s=0 ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    n=sc.nextInt();
    while(n-->0 && read()){
      System.out.println(solve());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute events : Sequence(String);
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var event : String ;
    events := Sequence{} ; 
  while true do ((     event := sc.getCurrent() ; 
     if (event = "OUT") then (     cnt := cnt + 1 ) else (     events := events->including(event) ) ) ;
    if (cnt < 3) then skip else break) ; 
    return true 
 );
  static   operation solve() : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
    var s : int ; s := 0 ;
     while (not(events->isEmpty())) do (     var e : String ; e := events->min() ;
     s := ((s*(2->pow(1)))->oclAsType(long)) + 1 ; 
     if (e = "HIT") then (     if ((MathLib.bitwiseAnd(s,8)) > 1) then (     ans := ans + 1 ) else skip ; 
     s := (MathLib.bitwiseAnd(s,7)) ) else (         var i : int ; i := 1 ; while i < 16 do ( (     if ((MathLib.bitwiseAnd(s,i)) >= 1) then (     ans := ans + 1 ) else skip )  ;     i := ((i*(2->pow(1)))->oclAsType(long)) ) ; 
     s := 0 ) ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
         while (n > 0 & read()) do (    skip ; (     OclFile["System.out"].println(solve()) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    arr[0]=sc.nextInt();
    for(int i=1 ; i<n ; i++){
      int x=sc.nextInt();
      arr[i]=x+arr[i-1];
    }
    int m=sc.nextInt();
    int q[]=new int[m];
    for(int i=0 ; i<m ; i++)q[i]=sc.nextInt();
    for(int k=0 ; k<m ; k++)System.out.println(fun(arr,q[k],n,m)+1);
  }
  static int fun(int arr[],int q,int n,int m){
    int res=0 ;
    int i=0,j=n ;
    while(i<=j){
      int md=i+(j-i)/2 ;
      if(arr[md]==q)return md ;
      else if(arr[md]>q){
        res=md ;
        j=md-1 ;
      }
      else i=md+1 ;
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    arr[0+1] := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     arr[i+1] := x + arr[i - 1+1] )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var q : Sequence(int) ; q := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     q[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < m do (     OclFile["System.out"].println(fun(arr, q[k+1], n, m) + 1) ;  ;     k := k + 1 ) ; 
 );
  static   operation fun( arr : Sequence(int), q : int, n : int, m : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     var i : int ; i := 0 ;
    var j : int ; j := n ;
     while (i <= j) do (     var md : int ; md := i + (j - i) / 2 ;
     if (arr[md+1] = q) then     return md else     if (arr[md+1] > q) then (     res := md ; 
     j := md - 1 ) else     i := md + 1 ; ;  ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.Stack ;
import java.util.concurrent.ArrayBlockingQueue ;
import java.util.stream.Collectors ;
import java.util.stream.Stream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    List<Integer>n_q=Stream.of(sc.nextLine().split(" ")).map(Integer :: parseInt).collect(Collectors.toList());
    int q=n_q.get(1);
    Queue<String>qu=new ArrayBlockingQueue<>(n_q.get(0));
    int t=0 ;
    while(sc.hasNext()){
      qu.add(sc.nextLine());
    }
    while(! qu.isEmpty()){
      String[] name_time=qu.poll().split(" ");
      int time=Integer.parseInt(name_time[1]);
      if(time>q){
        time-=q ;
        t+=q ;
        qu.add(name_time[0]+" "+time);
      }
      else {
        t+=time ;
        System.out.println(name_time[0]+" "+t);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n_q : Sequence(int) ; n_q := Sequence{sc.nextLine()->split(" ")}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) ).collect(Collectors.toList()) ;
    var q : int ; q := n_q->at(1+1) ;
    var qu : Sequence(String) ; qu := Sequence{}->union(n_q->at(0+1)) ;
    var t : int ; t := 0 ;
    while (sc.hasNext()) do (     qu := qu->including(sc.nextLine()) ) ; 
    while (not(qu->isEmpty())) do (     var name_time : Sequence(String) ; name_time := qu->min()->split(" ") ;
     var time : int ; time := (name_time[1+1])->toInteger() ;
     if (time > q) then (     time := time-(q) ; 
     t := t+(q) ; 
     qu := qu->including(name_time[0+1] + " " + time) ) else (     t := t+(time) ; 
     OclFile["System.out"].println(name_time[0+1] + " " + t) ) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class Inning {
  int Point ;
  int OutCount ;
  boolean First ;
  boolean Second ;
  boolean Third ;
  public void InitInning(){
    Point=0 ;
    OutCount=0 ;
    First=false ;
    Second=false ;
    Third=false ;
  }
  public void DoHit(){
    if(Third==true){
      Point+=1 ;
      Third=false ;
    }
    if(Second==true){
      Third=true ;
      Second=false ;
    }
    if(First==true){
      Second=true ;
      First=false ;
    }
    First=true ;
  }
  public void DoOut(){
    OutCount+=1 ;
    if(OutCount==3){
      EndEninng();
    }
  }
  public void DoHomerun(){
    if(Third==true){
      Point+=1 ;
      Third=false ;
    }
    if(Second==true){
      Point+=1 ;
      Second=false ;
    }
    if(First==true){
      Point+=1 ;
      First=false ;
    }
    Point+=1 ;
  }
  public void EndEninng(){
    System.out.println(Point);
    InitInning();
  }
}
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner scan=new Scanner(System.in);
    int Inning=0 ;
    String str ;
    Inning obj=new Inning();
    obj.InitInning();
    while(scan.hasNext()){
      if(Inning==0){
        Inning=scan.nextInt();
      }
      else {
        str=scan.next();
        if(str.equals("HIT")){
          obj.DoHit();
        }
        else if(str.equals("HOMERUN")){
          obj.DoHomerun();
        }
        else if(str.equals("OUT")){
          obj.DoOut();
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Inning {
   attribute Point : int;
   attribute OutCount : int;
   attribute First : boolean;
   attribute Second : boolean;
   attribute Third : boolean;
   operation InitInning() : void
  pre: true
  post: true
  activity: (     Point := 0 ; 
     OutCount := 0 ; 
    First := false ; 
    Second := false ; 
    Third := false ; 
 );
   operation DoHit() : void
  pre: true
  post: true
  activity: (     if (Third = true) then (     Point := Point+(1) ; 
     Third := false ) else skip ; 
     if (Second = true) then (     Third := true ; 
     Second := false ) else skip ; 
     if (First = true) then (     Second := true ; 
     First := false ) else skip ; 
     First := true );
   operation DoOut() : void
  pre: true
  post: true
  activity: (     OutCount := OutCount+(1) ; 
     if (OutCount = 3) then (     execute EndEninng() ) else skip );
   operation DoHomerun() : void
  pre: true
  post: true
  activity: (     if (Third = true) then (     Point := Point+(1) ; 
     Third := false ) else skip ; 
     if (Second = true) then (     Point := Point+(1) ; 
     Second := false ) else skip ; 
     if (First = true) then (     Point := Point+(1) ; 
     First := false ) else skip ; 
     Point := Point+(1) );
   operation EndEninng() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(Point) ; 
     execute InitInning() );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var Inning : int ; Inning := 0 ;
    var str : String ;
    var obj : Inning ; obj := Inning.newInning() ;
    obj.InitInning() ; 
    while (scan.hasNext()) do (     if (Inning = 0) then (     Inning := scan.getCurrent()->toInteger() ) else (     str := scan.getCurrent() ; 
     if (str = "HIT") then (     obj.DoHit() ) else     if (str = "HOMERUN") then (     obj.DoHomerun() ) else     if (str = "OUT") then (     obj.DoOut() ) else skip ; ;  ) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  private static int score=0 ;
  private static int outCount=0 ;
  private static boolean runner[]=new boolean[3];
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      StringBuilder stringBuilder=new StringBuilder();
      int dataSet=Integer.parseInt(br.readLine());
      for(int i=0 ; i<dataSet ; i++){
        String line ;
        while((line=br.readLine())!=null){
          switch(line){
            case "HIT" : hit(runner);
            break ;
            case "HOMERUN" : homeRun();
            break ;
            case "OUT" : out();
            break ;
            default : break ;
          }
          if(outCount==3){
            runner=new boolean[3];
            outCount=0 ;
            break ;
          }
        }
        stringBuilder.append(score+"\n");
        score=0 ;
      }
      System.out.print(stringBuilder);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  public static void hit(boolean[] runner){
    if(runner[2]){
++score ;
    }
    else {
      runner[2]=runner[1];
      runner[1]=runner[0];
      runner[0]=true ;
    }
  }
  public static void homeRun(){
++score ;
    for(int j=0 ; j<runner.length ; j++){
      if(runner[j]){
++score ;
        runner[j]=false ;
      }
    }
  }
  public static int out(){
    if(outCount==3){
      return 0 ;
    }
    return++outCount ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute score : int := 0;
  static   attribute outCount : int := 0;
  static   attribute runner : boolean := Integer.subrange(1,3)->collect(false);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var stringBuilder : String ; stringBuilder := StringLib.newString() ;
    var dataSet : int ; dataSet := (br.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < dataSet do ( (     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (line) ; 
       if _switchval = "HIT" then
     execute hit(runner) ; 
    break 
   else skip ;
       if _switchval = "HOMERUN" then
     execute homeRun() ; 
    break 
   else skip ;
       if _switchval = "OUT" then
     execute out() ; 
    break 
   else skip ;
       if true then
     break 
   else skip ;
 )
     if (outCount = 3) then (     runner := Integer.subrange(1,3)->collect(false) ; 
     outCount := 0 ; 
     break ) else skip ) ;     line := br.readLine() ;
 ) ;  
     stringBuilder := stringBuilder + StringLib.newString(score + "\n") ; 
     score := 0 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(stringBuilder) ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
  static   operation hit( runner : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (     if (runner[2+1]) then (     score := score + 1 ) else (     runner[2+1] := runner[1+1] ; 
     runner[1+1] := runner[0+1] ; 
     runner[0+1] := true ) );
  static   operation homeRun() : void
  pre: true
  post: true
  activity: (     score := score + 1 ; 
         var j : int ; j := 0 ; while j < runner->size() do ( (     if (runner[j+1]) then (     score := score + 1 ; 
     runner[j+1] := false ) else skip )  ;     j := j + 1 ) );
  static   operation out() : int
  pre: true
  post: true
  activity: (     if (outCount = 3) then (     return 0 ) else skip ; 
     return (outCount + 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.LinkedList ;
import java.util.Queue ;
public class Main {
  public static void main(String[] args)throws IOException {
    Queue<Integer>qBase=new LinkedList<Integer>();
    BufferedReader bReader=new BufferedReader(new InputStreamReader(System.in));
    int inningCount=Integer.parseInt(bReader.readLine());
    int calcCount=0 ;
    int point=0 ;
    int out=0 ;
    qBase.offer(0);
    qBase.offer(0);
    qBase.offer(0);
    while(calcCount!=inningCount){
      String inputStr=bReader.readLine();
      if(inputStr.equals("HIT")){
        point+=qBase.peek();
        qBase.poll();
        qBase.offer(1);
      }
      else if(inputStr.equals("HOMERUN")){
        point+=qBase.peek();
        qBase.poll();
        point+=qBase.peek();
        qBase.poll();
        point+=qBase.peek();
        qBase.poll();
        point+=1 ;
        qBase.offer(0);
        qBase.offer(0);
        qBase.offer(0);
      }
      else if(inputStr.equals("OUT")){
        out++;
        if(out==3){
          System.out.println(point);
          calcCount++;
          out=0 ;
          point=0 ;
          qBase.clear();
          qBase.offer(0);
          qBase.offer(0);
          qBase.offer(0);
        }
      }
      else {
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var qBase : Sequence(int) ; qBase := Sequence{} ;
     var bReader : OclFile ; bReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var inningCount : int ; inningCount := (bReader.readLine())->toInteger() ;
    var calcCount : int ; calcCount := 0 ;
    var point : int ; point := 0 ;
    var out : int ; out := 0 ;
    qBase := qBase->including(0) ; 
    qBase := qBase->including(0) ; 
    qBase := qBase->including(0) ; 
    while (calcCount /= inningCount) do (     var inputStr : String ; inputStr := bReader.readLine() ;
     if (inputStr = "HIT") then (     point := point+(qBase->min()) ; 
     qBase := qBase->sort()->tail() ; 
     qBase := qBase->including(1) ) else     if (inputStr = "HOMERUN") then (     point := point+(qBase->min()) ; 
     qBase := qBase->sort()->tail() ; 
    point := point+(qBase->min()) ; 
    qBase := qBase->sort()->tail() ; 
    point := point+(qBase->min()) ; 
    qBase := qBase->sort()->tail() ; 
    point := point+(1) ; 
    qBase := qBase->including(0) ; 
    qBase := qBase->including(0) ; 
    qBase := qBase->including(0) ; 
 ) else     if (inputStr = "OUT") then (     out := out + 1 ; 
     if (out = 3) then (     OclFile["System.out"].println(point) ; 
     calcCount := calcCount + 1 ; 
    out := 0 ; 
    point := 0 ; 
    qBase := qBase->intersection(Set{}) ; 
    qBase := qBase->including(0) ; 
    qBase := qBase->including(0) ; 
    qBase := qBase->including(0) ; 
 ) else skip ) else skip ;  ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class App {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char[] s ;
    char[] t ;
    s=in.next().toCharArray();
    int n=s.length,q,f=0 ;
    for(int i=0 ; i<=n-26 ; i++){
      t=new char[26];
      int o=0 ;
      for(int k=i ; k<i+26 ; k++){
        t[o]=s[k];
++o ;
      }
      q=0 ;
      HashSet<Character>se=new HashSet<>();
      int[] vis=new int[26];
      for(int j=0 ; j<26 ; j++){
        if(t[j]=='?')q++;
        else {
          se.add(t[j]);
          vis[t[j]-'A']=1 ;
        }
      }
      if(se.size()+q==26){
        f=1 ;
        for(int j=i,a=0 ; a<26 ; j++,a++){
          if(s[j]=='?'){
            for(int jj=0 ; jj<26 ; jj++)if(vis[jj]==0){
              s[j]=(char)(jj+'A');
              vis[jj]=1 ;
              break ;
            }
          }
        }
        break ;
      }
    }
    if(f==1){
      for(int i=0 ; i<n ; i++)if(s[i]=='?')s[i]='A' ;
      System.out.println(s);
      ;
    }
    else System.out.println(-1);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ;
    var t : Sequence(String) ;
    s := in.getCurrent()->characters() ; 
    var n : int ; n := s->size() ;
    var q : int ;
    var f : int ; f := 0 ;
        var i : int ; i := 0 ; while i <= n - 26 do ( (     t := Integer.subrange(1,26)->collect(0) ; 
     var o : int ; o := 0 ;
        var k : int ; k := i ; while k < i + 26 do ( (     t[o+1] := s[k+1] ; 
     o := o + 1 )  ;     k := k + 1 ) ; 
    q := 0 ; 
    var se : Set(String) ; se := Set{} ;
    var vis : Sequence(int) ; vis := Integer.subrange(1,26)->collect(0) ;
        var j : int ; j := 0 ; while j < 26 do ( (     if (t[j+1] = '?') then     q := q + 1 ; else (     se := se->including(t[j+1]) ; 
     vis[t[j+1] - ('A')->char2byte()+1] := 1 ) )  ;     j := j + 1 ) ; 
    if (se->size() + q = 26) then (     f := 1 ; 
         var j : int ; j := i ;
    var a : int ; a := 0 ; while a < 26 do ( (     if (s[j+1] = '?') then (         var jj : int ; jj := 0 ; while jj < 26 do (     if (vis[jj+1] = 0) then (     s[j+1] := (jj + 'A')->oclAsType(String) ; 
     vis[jj+1] := 1 ; 
     break ) else skip ;  ;     jj := jj + 1 ) ) else skip )  ;     j := j + 1 ;     a := a + 1 ) ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (f = 1) then (         var i : int ; i := 0 ; while i < n do (     if (s[i+1] = '?') then     s[i+1] := 'A' ; else skip ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(s) ; 
  ) else     OclFile["System.out"].println(-1) ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    char[] s=in.next().toCharArray();
    char[] ans=solve(s);
    if(ans[0]=='1')pw.println(-1);
    else for(char c : ans)pw.print(c);
    pw.close();
  }
  static char[] solve(char[] s){
    HashSet<Character>latters=new HashSet<>();
    for(char c='A' ; c<='Z' ; c++){
      latters.add(c);
    }
    for(int i=0 ; i<s.length ; i++){
      HashSet<Character>temp=new HashSet<>();
      int blank=0 ;
      for(int j=i ; j<(i+26); j++){
        if(j>=s.length)break ;
        if(s[j]=='?')blank++;
        else temp.add(s[j]);
      }
      int need=0 ;
      for(char x : latters){
        if(! temp.contains(x))need++;
      }
      if(blank==need){
        ArrayDeque<Character>dq=new ArrayDeque<>();
        for(char x : latters){
          if(! temp.contains(x))dq.add(x);
        }
        for(int k=i ; k<(i+26); k++){
          if(dq.isEmpty())break ;
          if(s[k]=='?')s[k]=dq.poll();
        }
        for(int k=0 ; k<s.length ; k++)if(s[k]=='?')s[k]='A' ;
        return s ;
      }
    }
    char[] no={
      '1' };
      return no ;
    }
    static void debug(Object...obj){
      System.err.println(Arrays.deepToString(obj));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : Sequence(String) ; s := in.getCurrent()->characters() ;
    var ans : Sequence(String) ; ans := solve(s) ;
    if (ans[0+1] = '1') then     skip else     for (c : ans) do (     skip ;  ) ; ;  
    skip ; 
 );
  static   operation solve( s : Sequence(String)) : Sequence(String)
  pre: true
  post: true
  activity: (     var latters : Set(String) ; latters := Set{} ;
         var c : String ; c := 'A' ; while c <= 'Z' do ( (     latters := latters->including(c) )  ;     c := c + 1 ) ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     var temp : Set(String) ; temp := Set{} ;
     var blank : int ; blank := 0 ;
        var j : int ; j := i ; while j < (i + 26) do ( (     if (j >= s->size()) then     break else skip ; 
     if (s[j+1] = '?') then     blank := blank + 1 ; else     temp := temp->including(s[j+1]) ; )  ;     j := j + 1 ) ; 
    var need : int ; need := 0 ;
    for (x : latters) do ( (     if (not(temp->includes(x))) then     need := need + 1 ; else skip )  ) ; 
    if (blank = need) then (     var dq : Sequence(String) ; dq := ArrayDeque<OclAny>.newArrayDeque() ;
     for (x : latters) do ( (     if (not(temp->includes(x))) then     dq := dq->including(x) ; else skip )  ) ; 
        var k : int ; k := i ; while k < (i + 26) do ( (     if (dq->isEmpty()) then     break else skip ; 
     if (s[k+1] = '?') then     s[k+1] := dq->min() ;     dq := dq->sort()->tail() ; else skip )  ;     k := k + 1 ) ; 
        var k : int ; k := 0 ; while k < s->size() do (     if (s[k+1] = '?') then     s[k+1] := 'A' ; else skip ;  ;     k := k + 1 ) ; 
    return s 
 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    var no : Sequence(String) ; no := Sequence{'1'} ;
    return no 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String str=in.next();
    ArrayList<Character>list=new ArrayList<>();
    StringBuffer stringBuffer=new StringBuffer();
    int flag=1 ;
    for(int i=0 ; i+25<str.length(); i++){
      flag=1 ;
      HashMap<Character,Integer>map=new HashMap<>();
      for(int j=0 ; j<26 ; j++){
        char ch=str.charAt(i+j);
        if(ch!='?'){
          if(map.containsKey(ch)){
            flag=0 ;
            break ;
          }
          else map.put(ch,1);
        }
      }
      if(flag==1){
        stringBuffer=new StringBuffer(str.substring(0,i).replace("?","A"));
        for(char j='A' ; j<'Z'+1 ; j++){
          if(! map.containsKey(j))list.add(j);
        }
        for(int j=0,k=0 ; j<26 ; j++){
          if(str.charAt(i+j)!='?')stringBuffer.append(str.charAt(i+j));
          else stringBuffer.append(list.get(k++));
        }
        stringBuffer.append(str.substring(i+26).replace("?","A"));
        break ;
      }
    }
    if(str.length()<26 || flag==0)System.out.print(-1);
    else System.out.print(stringBuffer.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := in.getCurrent() ;
    var list : Sequence(String) ; list := Sequence{} ;
    var stringBuffer : String ; stringBuffer := StringLib.newString() ;
    var flag : int ; flag := 1 ;
        var i : int ; i := 0 ; while i + 25 < str->size() do ( (     flag := 1 ; 
     var map : Map(String,int) ; map := Map{} ;
         var j : int ; j := 0 ; while j < 26 do ( (     var ch : String ; ch := str->at(i + j+1) ;
     if (ch /= '?') then (     if (map->keys()->includes(ch)) then (     flag := 0 ; 
     break ) else     map := map->union(Map{ch |-> 1}) ; ) else skip )  ;     j := j + 1 ) ; 
     if (flag = 1) then (     stringBuffer := StringLib.newString(str.subrange(0+1,i).replace("?", "A")) ; 
         var j : String ; j := 'A' ; while j < 'Z' + 1 do ( (     if (not(map->keys()->includes(j))) then     list := list->including(j) ; else skip )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ;
    var k : int ; k := 0 ; while j < 26 do ( (     if (str->at(i + j+1) /= '?') then     stringBuffer := stringBuffer + StringLib.newString(str->at(i + j+1)) ; else     stringBuffer := stringBuffer + StringLib.newString(list->at(k+1)) ; )  ;     j := j + 1 ) ; 
    stringBuffer := stringBuffer + StringLib.newString(str.subrange(i + 26+1,i + 26).replace("?", "A")) ; 
    break 
 ) else skip )  ;     i := i + 1 ) ; 
    if (str->size() < 26 or flag = 0) then     OclFile["System.out"].print(-1) else     OclFile["System.out"].print(stringBuffer+"") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int __gcd(int a,int b){
    if(a==0 || b==0)return 0 ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static int findValue(int x,int y,int z){
    int g=__gcd(y,z);
    return(x*g)/__gcd(x,g);
  }
  public static void main(String[] args){
    int x=30,y=40,z=400 ;
    System.out.print(findValue(x,y,z));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0 or b = 0) then     return 0 else skip ; 
     if (a = b) then     return a else skip ; 
     if (a > b) then     return __gcd(a - b, b) else skip ; 
     return __gcd(a, b - a) );
  static   operation findValue( x : int, y : int, z : int) : int
  pre: true
  post: true
  activity: (     var g : int ; g := __gcd(y, z) ;
     return (x * g) / __gcd(x, g) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 30 ;
    var y : int ; y := 40 ;
    var z : int ; z := 400 ;
     OclFile["System.out"].print(findValue(x, y, z)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.text.*;
class solution {
  static void foot(float a,float b,float c,float d,float x1,float y1,float z1){
    float k=(-a*x1-b*y1-c*z1-d)/(float)(a*a+b*b+c*c);
    float x2=a*k+x1 ;
    float y2=b*k+y1 ;
    float z2=c*k+z1 ;
    DecimalFormat form=new DecimalFormat("0.0");
    System.out.print(" x2="+form.format(x2));
    System.out.print(" y2="+form.format(y2));
    System.out.print(" z2="+form.format(z2));
  }
  public static void main(String arr[]){
    float a=1 ;
    float b=-2 ;
    float c=0 ;
    float d=0 ;
    float x1=-1 ;
    float y1=3 ;
    float z1=4 ;
    foot(a,b,c,d,x1,y1,z1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation foot( a : double, b : double, c : double, d : double, x1 : double, y1 : double, z1 : double) : void
  pre: true
  post: true
  activity: (     var k : double ; k := (-a * x1 - b * y1 - c * z1 - d) / (a * a + b * b + c * c)->oclAsType(double) ;
     var x2 : double ; x2 := a * k + x1 ;
    var y2 : double ; y2 := b * k + y1 ;
    var z2 : double ; z2 := c * k + z1 ;
    var form : DecimalFormat ; form := DecimalFormat.newDecimalFormat("0.0") ;
    OclFile["System.out"].print(" x2=" + form.format(x2)) ; 
    OclFile["System.out"].print(" y2=" + form.format(y2)) ; 
    OclFile["System.out"].print(" z2=" + form.format(z2)) ; 
 );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 1 ;
     var b : double ; b := -2 ;
    var c : double ; c := 0 ;
    var d : double ; d := 0 ;
    var x1 : double ; x1 := -1 ;
    var y1 : double ; y1 := 3 ;
    var z1 : double ; z1 := 4 ;
    execute foot(a, b, c, d, x1, y1, z1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String c1=sc.next();
    String c2=sc.next();
    if(c1.charAt(0)==c2.charAt(c2.length()-1)&& c2.charAt(0)==c1.charAt(c1.length()-1)&& c1.charAt(1)==c2.charAt(1))System.out.println("YES");
    else System.out.println("NO");
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c1 : String ; c1 := sc.getCurrent() ;
    var c2 : String ; c2 := sc.getCurrent() ;
    if (c1->at(0+1) = c2->at(c2->size() - 1+1) & c2->at(0+1) = c1->at(c1->size() - 1+1) & c1->at(1+1) = c2->at(1+1)) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(in,out);
    out.close();
  }
  static class Task {
    void solve(InputReader in,PrintWriter out){
      String upper=in.next();
      String lower=in.next();
      out.println((new StringBuilder(upper)).reverse().toString().equals(lower)? "YES" : "NO");
    }
  }
  static class InputReader {
    BufferedReader reader ;
    StringTokenizer tokenizer ;
    InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream));
      tokenizer=null ;
    }
    String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var upper : String ; upper := in.next() ;
     var lower : String ; lower := in.next() ;
     skip );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int upper=0 ;
    int lower=0 ;
    for(int i=0 ; i<s.length(); i++){
      char ch=s.charAt(i);
      if(ch>='A' && ch<='Z')upper++;
      else if(ch>='a' && ch<='z')lower++;
    }
    if(upper<=lower)System.out.println(s.toLowerCase());
    else if(upper>lower)System.out.println(s.toUpperCase());
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var upper : int ; upper := 0 ;
    var lower : int ; lower := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var ch : String ; ch := s->at(i+1) ;
     if (ch >= 'A' & ch <= 'Z') then     upper := upper + 1 ; else     if (ch >= 'a' & ch <= 'z') then     lower := lower + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    if (upper <= lower) then     OclFile["System.out"].println(s->toLowerCase()) else     if (upper > lower) then     OclFile["System.out"].println(s->toUpperCase()) ; else skip ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    BufferedReader kb=new BufferedReader(new InputStreamReader(System.in));
    try {
      String[] str=kb.readLine().split(" ");
      int n=Integer.parseInt(str[0]);
      int q=Integer.parseInt(str[1]);
      LinkedList<String>ps=new LinkedList<String>();
      LinkedList<Integer>times=new LinkedList<Integer>();
      for(int i=0 ; i<n ; i++){
        str=kb.readLine().split(" ");
        ps.offer(str[0]);
        times.offer(Integer.parseInt(str[1]));
      }
      StringBuilder output=new StringBuilder();
      String job ;
      int time,t ;
      t=0 ;
      while(null!=(job=ps.peek())){
        time=times.peek();
        if(times.peek()<=q){
          output.append(job);
          output.append(" ");
          output.append(t+time);
          output.append("\n");
          t+=time ;
        }
        else {
          ps.offer(job);
          times.offer(time-q);
          t+=q ;
        }
        ps.poll();
        times.poll();
      }
      System.out.print(output);
    }
    catch(IOException e){
      System.err.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var kb : OclFile ; kb := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var str : Sequence(String) ; str := kb.readLine()->split(" ") ;
     var n : int ; n := (str[0+1])->toInteger() ;
    var q : int ; q := (str[1+1])->toInteger() ;
    var ps : Sequence(String) ; ps := Sequence{} ;
    var times : Sequence(int) ; times := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     str := kb.readLine()->split(" ") ; 
     ps := ps->including(str[0+1]) ; 
     times := times->including((str[1+1])->toInteger()) )  ;     i := i + 1 ) ; 
    var output : String ; output := StringLib.newString() ;
    var job : String ;
    var time : int ;
    var t : int ;
    t := 0 ; 
        job := ps->min() ;
    while (null /= (job)) do (    skip ; (     time := times->min() ; 
     if (times->min() <= q) then (     output := output + StringLib.newString(job) ; 
     output := output + StringLib.newString(" ") ; 
    output := output + StringLib.newString(t + time) ; 
    output := output + StringLib.newString("\n") ; 
    t := t+(time) ; 
 ) else (     ps := ps->including(job) ; 
     times := times->including((time)->char2byte() - q) ; 
     t := t+(q) ) ;  
     ps := ps->sort()->tail() ; 
     times := times->sort()->tail() ) ;     job := ps->min() ;
 ) ;  
    OclFile["System.out"].print(output) ; 
 )   catch (e : IOException) do (     OclFile["System.err"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int count9s(char number[]){
    int n=number.length ;
    int d[]=new int[9];
    d[0]=1 ;
    int result=0 ;
    int mod_sum=0,continuous_zero=0 ;
    for(int i=0 ; i<n ; i++){
      if((number[i]-'0')==0){
        continuous_zero++;
      }
      else {
        continuous_zero=0 ;
      }
      mod_sum+=(number[i]-'0');
      mod_sum %=9 ;
      result+=d[mod_sum];
      d[mod_sum]++;
      result-=continuous_zero ;
    }
    return result ;
  }
  public static void main(String[] args){
    System.out.println(count9s("01809".toCharArray()));
    System.out.println(count9s("1809".toCharArray()));
    System.out.println(count9s("4189".toCharArray()));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation count9s( number : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := number->size() ;
     var d : Sequence(int) ; d := Integer.subrange(1,9)->collect(0) ;
    d[0+1] := 1 ; 
    var result : int ; result := 0 ;
    var mod_sum : int ; mod_sum := 0 ;
    var continuous_zero : int ; continuous_zero := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if ((number[i+1] - ('0')->char2byte()) = 0) then (     continuous_zero := continuous_zero + 1 ) else (     continuous_zero := 0 ) ;  
     mod_sum := mod_sum+((number[i+1] - ('0')->char2byte())) ; 
    mod_sum := mod_sum mod 9 ; 
    result := result+(d[mod_sum+1]) ; 
    d[mod_sum+1] := d[mod_sum+1] + 1 ; 
    result := result-(continuous_zero) ; 
 )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(count9s("01809"->characters())) ; 
     OclFile["System.out"].println(count9s("1809"->characters())) ; 
     OclFile["System.out"].println(count9s("4189"->characters())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Ada {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int dp[]=new int[n+1];
    int pre[]=new int[n+1];
    int prevSum=dp[1]=1 ;
    for(int i=1 ; i<=n ; i++){
      if(i!=1){
        pre[i]=(pre[i-1]+pre[i])% m ;
        dp[i]=(prevSum+pre[i])% m ;
        prevSum=(prevSum+dp[i])% m ;
      }
      for(int p=2,j=2*i ; j<=n ; p++,j=p*i){
        int r=j+p ;
        pre[j]=(pre[j]+dp[i])% m ;
        if(r<=n)pre[r]=((pre[r]-dp[i])% m+m)% m ;
      }
    }
    System.out.println(dp[n]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ada {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
    var pre : Sequence(int) ; pre := Integer.subrange(1,n + 1)->collect(0) ;
    var prevSum : int ;     dp[1+1] := 1 ;
prevSum := dp[1+1] ;
        var i : int ; i := 1 ; while i <= n do ( (     if (i /= 1) then (     pre[i+1] := (pre[i - 1+1] + pre[i+1]) mod m ; 
     dp[i+1] := (prevSum + pre[i+1]) mod m ; 
     prevSum := (prevSum + dp[i+1]) mod m ) else skip ; 
         var p : int ; p := 2 ;
    var j : int ; j := 2 * i ; while j <= n do ( (     var r : int ; r := j + p ;
     pre[j+1] := (pre[j+1] + dp[i+1]) mod m ; 
     if (r <= n) then     pre[r+1] := ((pre[r+1] - dp[i+1]) mod m + m) mod m ; else skip )  ;     p := p + 1 ;     j := p * i ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[n+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    try(Scanner in=new Scanner(System.in)){
      String line1=in.next();
      String line2=in.next();
      for(int i=0 ; i<3 ; i++){
        if(line1.charAt(i)!=line2.charAt(2-i)){
          System.out.println("NO");
          return ;
        }
      }
      System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var line1 : String ; line1 := in.getCurrent() ;
     var line2 : String ; line2 := in.getCurrent() ;
         var i : int ; i := 0 ; while i < 3 do ( (     if (line1->at(i+1) /= line2->at(2 - (i)->char2byte()+1)) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("YES") ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileInputStream ;
import java.io.InputStream ;
import java.util.Scanner ;
public class Main {
  static Scanner sc ;
  public static void main(String[] args)throws Exception {
    InputStream in=System.in ;
    sc=new Scanner(in);
    String a=sc.next();
    String b=sc.next();
    String answer="YES" ;
    for(int i=0 ; i<3 ; i++){
      if(a.charAt(i)!=b.charAt(2-i)){
        answer="NO" ;
        break ;
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile["System.in"] ;
     sc := OclFile.newOclFile_Read(in) ; 
    var a : String ; a := sc.getCurrent() ;
    var b : String ; b := sc.getCurrent() ;
    var answer : String ; answer := "YES" ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (a->at(i+1) /= b->at(2 - (i)->char2byte()+1)) then (     answer := "NO" ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String t=sc.next();
    String result="YES" ;
    if(s.charAt(0)!=t.charAt(2))result="NO" ;
    if(s.charAt(1)!=t.charAt(1))result="NO" ;
    if(s.charAt(2)!=t.charAt(0))result="NO" ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var result : String ; result := "YES" ;
    if (s->at(0+1) /= t->at(2+1)) then     result := "NO" ; else skip ; 
    if (s->at(1+1) /= t->at(1+1)) then     result := "NO" ; else skip ; 
    if (s->at(2+1) /= t->at(0+1)) then     result := "NO" ; else skip ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int getMinimumOps(Vector<Integer>ar){
    int n=ar.size();
    int small=Collections.min(ar);
    int large=Collections.max(ar);
    int[][] dp=new int[n][large+1];
    for(int j=small ; j<=large ; j++){
      dp[0][j]=Math.abs(ar.get(0)-j);
    }
    for(int i=1 ; i<n ; i++){
      int minimum=Integer.MAX_VALUE ;
      for(int j=small ; j<=large ; j++){
        minimum=Math.min(minimum,dp[i-1][j]);
        dp[i][j]=minimum+Math.abs(ar.get(i)-j);
      }
    }
    int ans=Integer.MAX_VALUE ;
    for(int j=small ; j<=large ; j++){
      ans=Math.min(ans,dp[n-1][j]);
    }
    return ans ;
  }
  public static void main(String[] args){
    Integer[] arr={
      1,2,1,4,3 };
      Vector<Integer>ar=new Vector<>(Arrays.asList(arr));
      System.out.println(getMinimumOps(ar));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getMinimumOps( ar : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := ar->size() ;
     var small : int ; small := .min(ar) ;
    var large : int ; large := .max(ar) ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,large + 1)->collect(0)) ;
        var j : int ; j := small ; while j <= large do ( (     dp[0+1][j+1] := if ar->at(0+1) - j < 0 then -(ar->at(0+1) - j) else ar->at(0+1) - j endif )  ;     j := j + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     var minimum : int ; minimum := 2147483647 ;
         var j : int ; j := small ; while j <= large do ( (     minimum := Set{minimum, dp[i - 1+1][j+1]}->min() ; 
     dp[i+1][j+1] := minimum + if ar->at(i+1) - j < 0 then -(ar->at(i+1) - j) else ar->at(i+1) - j endif )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
        var j : int ; j := small ; while j <= large do ( (     ans := Set{ans, dp[n - 1+1][j+1]}->min() )  ;     j := j + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,1,4,3} ;
     var ar : Sequence(int) ; ar := Sequence{}->union(arr) ;
     OclFile["System.out"].println(getMinimumOps(ar)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  static double PI=3.14159265 ;
  public static double area_leaf(double a){
    return(a*a*(PI/2-1));
  }
  public static void main(String[] args){
    double a=7 ;
    System.out.println(area_leaf(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute PI : double := 3.14159265;
  static   operation area_leaf( a : double) : double
  pre: true
  post: true
  activity: (     return (a * a * (PI / 2 - 1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 7 ;
     OclFile["System.out"].println(area_leaf(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int n=s.length();
    boolean[] a=new boolean[100000];
    long MOD=1000000007 ;
    for(int i=0 ; i<n ; i++)a[i]=s.charAt(i)=='1' ;
    long an=0 ;
    long[] pow2=new long[100005];
    long[] pow3=new long[100005];
    long cp2=1 ;
    long cp3=1 ;
    for(int i=0 ; i<100005 ; i++){
      pow2[i]=cp2 ;
      pow3[i]=cp3 ;
      cp2=(cp2*2)% MOD ;
      cp3=(cp3*3)% MOD ;
    }
    int ones=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]){
        int digle=n-i-1 ;
        long cur=(pow3[digle]*pow2[ones])% MOD ;
        an=(an+cur)% MOD ;
        ones++;
      }
      else {
      }
    }
    long cur=(pow2[ones])% MOD ;
    an=(an+cur)% MOD ;
    System.out.println(an);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var n : int ; n := s->size() ;
    var a : Sequence(boolean) ; a := Integer.subrange(1,100000)->collect(false) ;
    var MOD : long ; MOD := 1000000007 ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := s->at(i+1) = '1' ;  ;     i := i + 1 ) ; 
    var an : long ; an := 0 ;
    var pow2 : Sequence(long) ; pow2 := Integer.subrange(1,100005)->collect(0) ;
    var pow3 : Sequence(long) ; pow3 := Integer.subrange(1,100005)->collect(0) ;
    var cp2 : long ; cp2 := 1 ;
    var cp3 : long ; cp3 := 1 ;
        var i : int ; i := 0 ; while i < 100005 do ( (     pow2[i+1] := cp2 ; 
     pow3[i+1] := cp3 ; 
     cp2 := (cp2 * 2) mod MOD ; 
     cp3 := (cp3 * 3) mod MOD )  ;     i := i + 1 ) ; 
    var ones : int ; ones := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1]) then (     var digle : int ; digle := (n)->char2byte() - i - 1 ;
     var cur : long ; cur := (pow3[digle+1] * pow2[ones+1]) mod MOD ;
     an := (an + cur) mod MOD ; 
     ones := ones + 1 ) else skip )  ;     i := i + 1 ) ; 
    var cur : long ; cur := (pow2[ones+1]) mod MOD ;
    an := (an + cur) mod MOD ; 
    OclFile["System.out"].println(an) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int M=1000000007 ;
    char[] s=sc.nextLine().toCharArray();
    int n=s.length ;
    int[][] dp=new int[n+1][2];
    dp[0][0]=1 ;
    for(int i=0 ; i<n ; i++){
      if(s[i]=='0'){
        dp[i+1][0]=dp[i][0];
        dp[i+1][1]=dp[i][1];
      }
      else {
        dp[i+1][1]=(dp[i][0]+dp[i][1])% M ;
      }
      if(s[i]=='0'){
        dp[i+1][1]+=(dp[i][1]*2)% M ;
        dp[i+1][1] %=M ;
      }
      else {
        dp[i+1][0]+=(dp[i][0]*2)% M ;
        dp[i+1][1]+=(dp[i][1]*2)% M ;
        dp[i+1][0] %=M ;
        dp[i+1][1] %=M ;
      }
    }
    System.out.println((dp[n][0]+dp[n][1])% M);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var M : int ; M := 1000000007 ;
    var s : Sequence(String) ; s := sc.nextLine()->characters() ;
    var n : int ; n := s->size() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,2)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] = '0') then (     dp[i + 1+1][0+1] := dp[i+1][0+1] ; 
     dp[i + 1+1][1+1] := dp[i+1][1+1] ) else (     dp[i + 1+1][1+1] := (dp[i+1][0+1] + dp[i+1][1+1]) mod M ) ;  
     if (s[i+1] = '0') then (     dp[i + 1+1][1+1] := dp[i + 1+1][1+1]+((dp[i+1][1+1] * 2) mod M) ; 
     dp[i + 1+1][1+1] := dp[i + 1+1][1+1] mod M ) else (     dp[i + 1+1][0+1] := dp[i + 1+1][0+1]+((dp[i+1][0+1] * 2) mod M) ; 
     dp[i + 1+1][1+1] := dp[i + 1+1][1+1]+((dp[i+1][1+1] * 2) mod M) ; 
     dp[i + 1+1][0+1] := dp[i + 1+1][0+1] mod M ; 
     dp[i + 1+1][1+1] := dp[i + 1+1][1+1] mod M ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((dp[n+1][0+1] + dp[n+1][1+1]) mod M) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayDeque ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    Stdin stdin=new Stdin();
    char[] l=stdin.nextToken().toCharArray();
    int n=l.length ;
    long m=1000000007 ;
    long[][] dp=new long[n+1][2];
    dp[0][1]=1 ;
    for(int i=0 ; i<n ; i++){
      dp[i+1][0]+=dp[i][0]*3 ;
      if(l[i]=='0'){
        dp[i+1][1]+=dp[i][1];
      }
      else {
        dp[i+1][0]+=dp[i][1];
        dp[i+1][1]+=dp[i][1]*2 ;
      }
      dp[i+1][0] %=m ;
      dp[i+1][1] %=m ;
    }
    long ans=(dp[n][0]+dp[n][1])% m ;
    System.out.println(ans);
  }
  private static final class Stdin {
    private BufferedReader stdin ;
    private ArrayDeque<String>tokens ;
    public Stdin(){
      this.stdin=new BufferedReader(new InputStreamReader(System.in));
      this.tokens=new ArrayDeque<>();
    }
    public String nextToken()throws IOException {
      if(tokens.isEmpty()){
        for(String token : stdin.readLine().split(" ")){
          tokens.add(token);
        }
      }
      return tokens.poll();
    }
    public int nextInt()throws NumberFormatException,IOException {
      return Integer.parseInt(nextToken());
    }
    public int nextLong()throws NumberFormatException,IOException {
      return Integer.parseInt(nextToken());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : Stdin ; stdin := Stdin.newStdin() ;
     var l : Sequence(String) ; l := stdin.next()->characters() ;
    var n : int ; n := l->size() ;
    var m : long ; m := 1000000007 ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,2)->collect(0)) ;
    dp[0+1][1+1] := 1 ; 
        var i : int ; i := 0 ; while i < n do ( (     dp[i + 1+1][0+1] := dp[i + 1+1][0+1]+(dp[i+1][0+1] * 3) ; 
     if (l[i+1] = '0') then (     dp[i + 1+1][1+1] := dp[i + 1+1][1+1]+(dp[i+1][1+1]) ) else (     dp[i + 1+1][0+1] := dp[i + 1+1][0+1]+(dp[i+1][1+1]) ; 
     dp[i + 1+1][1+1] := dp[i + 1+1][1+1]+(dp[i+1][1+1] * 2) ) ;  
     dp[i + 1+1][0+1] := dp[i + 1+1][0+1] mod m ; 
     dp[i + 1+1][1+1] := dp[i + 1+1][1+1] mod m )  ;     i := i + 1 ) ; 
    var ans : long ; ans := (dp[n+1][0+1] + dp[n+1][1+1]) mod m ;
    OclFile["System.out"].println(ans) ; 
 );
  static  class Stdin {
   attribute stdin : OclFile;
   attribute tokens : Sequence(String);
   static operation newStdin() : Stdin
  pre: true
  post: true
  activity:
  ( var self : Stdin ;
    self := createStdin();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.stdin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     self.tokens := ArrayDeque<OclAny>.newArrayDeque() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     if (tokens->isEmpty()) then (     for (token : stdin.readLine()->split(" ")) do ( (     tokens := tokens->including(token) )  ) ) else skip ; 
     return tokens->min() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(new File("B-large.in"));
    PrintWriter out=new PrintWriter(new FileWriter(new File("B-large.out")));
    int t=in.nextInt();
    for(int y=0 ; y<t ; y++){
      double c=in.nextDouble();
      double f=in.nextDouble();
      double x=in.nextDouble();
      long low=0 ;
      long high=(long)1E6 ;
      while(low+2<high){
        long mid1=low+(high-low)/3 ;
        long mid2=low+2*(high-low)/3 ;
        if(getTime(mid1,c,f,x)<getTime(mid2,c,f,x)){
          high=mid2-1 ;
        }
        else {
          low=mid1 ;
        }
      }
      double result=Double.POSITIVE_INFINITY ;
      for(long z=low ; z<=high ; z++){
        result=Math.min(result,getTime(z,c,f,x));
      }
      out.printf("Case #%d: %.7f\n",y+1,result);
    }
    out.close();
  }
  public static double getTime(long buildings,double c,double f,double x){
    double time=0 ;
    double rate=2 ;
    for(int i=0 ; i<buildings ; i++){
      time+=c/rate ;
      rate+=f ;
    }
    return time+(x/rate);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("B-large.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile("B-large.out"))) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        var y : int ; y := 0 ; while y < t do ( (     var c : double ; c := in.getCurrent()->toReal() ;
     var f : double ; f := in.getCurrent()->toReal() ;
    var x : double ; x := in.getCurrent()->toReal() ;
    var low : long ; low := 0 ;
    var high : long ; high := 1E6->oclAsType(long) ;
    while (low + 2 < high) do (     var mid1 : long ; mid1 := low + (high - low) / 3 ;
     var mid2 : long ; mid2 := low + 2 * (high - low) / 3 ;
     if (getTime(mid1, c, f, x) < getTime(mid2, c, f, x)) then (     high := mid2 - 1 ) else (     low := mid1 ) ) ; 
    var result : double ; result := Math_PINFINITY ;
        var z : long ; z := low ; while z <= high do ( (     result := Set{result, getTime(z, c, f, x)}->min() )  ;     z := z + 1 ) ; 
    skip ; 
 )  ;     y := y + 1 ) ; 
    skip ; 
 );
  static   operation getTime( buildings : long, c : double, f : double, x : double) : double
  pre: true
  post: true
  activity: (     var time : double ; time := 0 ;
     var rate : double ; rate := 2 ;
         var i : int ; i := 0 ; while i < buildings do ( (     time := time+(c / rate) ; 
     rate := rate+(f) )  ;     i := i + 1 ) ; 
     return time + (x / rate) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static long steps[];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String L=sc.next();
    long ari=1L ;
    long nasi=2L ;
    for(int i=1 ; i<L.length(); i++){
      ari=(ari*3)% 1000000007L ;
      switch(L.charAt(i)){
        case '0' : break ;
        case '1' : ari=(ari+nasi)% 1000000007L ;
        nasi=(nasi*2)% 1000000007L ;
        break ;
      }
    }
    System.out.println((ari+nasi)% 1000000007L);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute steps : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var L : String ; L := sc.getCurrent() ;
    var ari : long ; ari := 1L ;
    var nasi : long ; nasi := 2L ;
        var i : int ; i := 1 ; while i < L->size() do ( (     ari := (ari * 3) mod 1000000007L ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (L->at(i+1)) ; 
       if _switchval = '0' then
     break 
   else skip ;
       if _switchval = '1' then
     ari := (ari + nasi) mod 1000000007L ; 
    nasi := (nasi * 2) mod 1000000007L ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((ari + nasi) mod 1000000007L) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ESumEqualsXor solver=new ESumEqualsXor();
    solver.solve(1,in,out);
    out.close();
  }
  static class ESumEqualsXor {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      String s=in.next();
      int n=s.length();
      ModInt[] safe=new ModInt[n];
      ModInt[] giri=new ModInt[n];
      safe[0]=new ModInt(1);
      giri[0]=new ModInt(2);
      for(int i=1 ; i<n ; i++){
        if(s.charAt(i)=='0'){
          safe[i]=safe[i-1] .mul(3);
          giri[i]=giri[i-1];
        }
        else {
          safe[i]=safe[i-1] .mul(3).add(giri[i-1]);
          giri[i]=giri[i-1] .mul(2);
        }
      }
      out.println(safe[n-1] .add(giri[n-1]).getVal());
    }
  }
  static class ModInt {
    int val ;
    int MOD=(int)1e9+7 ;
    public ModInt(long i){
      this.val=(int)((i+MOD)% MOD);
    }
    public ModInt mul(long l){
      return new ModInt(this.val*l);
    }
    public ModInt add(ModInt m){
      return new ModInt(this.val+m.getVal());
    }
    public int getVal(){
      return val ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ESumEqualsXor ; solver := ESumEqualsXor.newESumEqualsXor() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ESumEqualsXor {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.getCurrent() ;
     var n : int ; n := s->size() ;
    var safe : Sequence(ModInt) ; safe := Integer.subrange(1,n)->collect(null) ;
    var giri : Sequence(ModInt) ; giri := Integer.subrange(1,n)->collect(null) ;
    safe[0+1] := ModInt.newModInt(1) ; 
    giri[0+1] := ModInt.newModInt(2) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (s->at(i+1) = '0') then (     safe[i+1] := safe[i - 1+1].mul(3) ; 
     giri[i+1] := giri[i - 1+1] ) else (     safe[i+1] := safe[i - 1+1].mul(3)->excludes(giri[i - 1+1]) ; 
     giri[i+1] := giri[i - 1+1].mul(2) ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class ModInt {
   attribute val : int;
   attribute MOD : int := 1e9->oclAsType(int) + 7;
   static operation newModInt( i : long) : ModInt
  pre: true
  post: true
  activity:
  ( var self : ModInt ;
    self := createModInt();
    self.initialise(i);
    return self );
  operation initialise( i : long) : void
  pre: true  post: true
  activity: (     self.val := ((i + MOD) mod MOD)->oclAsType(int) );
   operation mul( l : long) : ModInt
  pre: true
  post: true
  activity: (     return ModInt.newModInt(self.val * l) );
   operation add( m : ModInt) : ModInt
  pre: true
  post: true
  activity: (     return ModInt.newModInt(self.val + m.getVal()) );
   operation getVal() : int
  pre: true
  post: true
  activity: (     return val );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Deque ;
import java.util.LinkedList ;
public class SlidingWindow {
  static void printMax(int arr[],int n,int k){
    Deque<Integer>Qi=new LinkedList<Integer>();
    int i ;
    for(i=0 ; i<k ; ++i){
      while(! Qi.isEmpty()&& arr[i]>=arr[Qi.peekLast()])Qi.removeLast();
      Qi.addLast(i);
    }
    for(; i<n ; ++i){
      System.out.print(arr[Qi.peek()]+" ");
      while((! Qi.isEmpty())&& Qi.peek()<=i-k)Qi.removeFirst();
      while((! Qi.isEmpty())&& arr[i]>=arr[Qi.peekLast()])Qi.removeLast();
      Qi.addLast(i);
    }
    System.out.print(arr[Qi.peek()]);
  }
  public static void main(String[] args){
    int arr[]={
      12,1,78,90,57,89,56 };
      int k=3 ;
      printMax(arr,arr.length,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class SlidingWindow {
  static   operation printMax( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var Qi : Sequence(int) ; Qi := Sequence{} ;
     var i : int ;
        i := 0 ; while i < k do ( (     while (not(Qi->isEmpty()) & arr[i+1] >= arr[Qi.peekLast()+1]) do     Qi := Qi->front() ; ; 
     Qi := Qi->append(i) )  ;     i := i + 1 ) ; 
      while i < n do ( (     OclFile["System.out"].print(arr[Qi->min()+1] + " ") ; 
     while ((not(Qi->isEmpty())) & Qi->min() <= i - k) do     Qi := Qi->tail() ; ; 
     while ((not(Qi->isEmpty())) & arr[i+1] >= arr[Qi.peekLast()+1]) do     Qi := Qi->front() ; ; 
     Qi := Qi->append(i) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(arr[Qi->min()+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,1,78,90,57,89,56} ;
     var k : int ; k := 3 ;
     execute printMax(arr, arr->size(), k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Circular {
  public static int removeAlternate(int n){
    if(n==1)return 1 ;
    if(n % 2==0)return 2*removeAlternate(n/2)-1 ;
    else return 2*removeAlternate(((n-1)/2))+1 ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.print(removeAlternate(n));
    n=10 ;
    System.out.print("\n"+removeAlternate(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Circular {
  static   operation removeAlternate( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 1 else skip ; 
     if (n mod 2 = 0) then     return 2 * removeAlternate(n / 2) - 1 else     return 2 * removeAlternate(((n - 1) / 2)) + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].print(removeAlternate(n)) ; 
     n := 10 ; 
     OclFile["System.out"].print("\n" + removeAlternate(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long ans=0 ;
    for(int i=1 ; i<n+1 ; i++){
      ans+=(long)i*((long)n/(long)i)*(((long)n/(long)i)+1)/2 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     ans := ans+(i->oclAsType(long) * (n->oclAsType(long) / i->oclAsType(long)) * ((n->oclAsType(long) / i->oclAsType(long)) + 1) / 2) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.Collectors ;
import java.io.*;
import java.nio.charset.StandardCharsets ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader reader=new InputStreamReader(System.in,StandardCharsets.UTF_8);
    BufferedReader in=new BufferedReader(reader);
    Main ins=new Main(in);
    ins.calc();
    ins.showResult();
  }
  int N ;
  int[] memo ;
  Main(BufferedReader in)throws IOException {
    N=Integer.parseInt(in.readLine());
    memo=new int[N+1];
    Arrays.fill(memo,0);
  }
  void calc(){
    for(int i=1 ; i<=N ; ++i){
      for(int j=i ; j<=N ; j+=i){
        memo[j]++;
      }
    }
    long count=0 ;
    for(int i=1 ; i<=N ; ++i){
      count+=(long)i*(long)memo[i];
    }
    System.out.println(count);
  }
  void showResult(){
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"], StandardCharsets.UTF_8) ;
     var in : OclFile ; in := OclFile.newOclFile_Read(reader) ;
    var ins : Main ; ins := Main.newMain(in) ;
    ins.calc() ; 
    ins.showResult() ; 
 );
   attribute N : int;
   attribute memo : Sequence(int);
   static operation newMain( in : OclFile) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     N := (in.readLine())->toInteger() ; 
     memo := Integer.subrange(1,N + 1)->collect(0) ; 
     memo := memo->collect(0) );
   operation calc() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := i ; while j <= N do ( (     memo[j+1] := memo[j+1] + 1 )  ;     j := j+(i) ) )  ;     i := i + 1 ) ; 
     var count : long ; count := 0 ;
         var i : int ; i := 1 ; while i <= N do ( (     count := count+(i->oclAsType(long) * memo[i+1]->oclAsType(long)) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) );
   operation showResult() : void
  pre: true
  post: true
  activity: skip;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    long[] nod=NOD(n);
    long res=0 ;
    for(int i=1 ; i<=n ; i++){
      res+=i*nod[i];
    }
    pw.println(res);
    pw.close();
  }
  static long[] NOD(int n){
    long nod[]=new long[n+1];
    for(int i=1 ; i<=n ; i++){
      for(int j=i ; j<=n ; j+=i){
        nod[j]++;
      }
    }
    return nod ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var nod : Sequence(long) ; nod := NOD(n) ;
    var res : long ; res := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     res := res+(i * nod[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation NOD( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var nod : Sequence(int) ; nod := Integer.subrange(1,n + 1)->collect(0) ;
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i ; while j <= n do ( (     nod[j+1] := nod[j+1] + 1 )  ;     j := j+(i) ) )  ;     i := i + 1 ) ; 
     return nod );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class Main {
  static final int MAXN=10000001 ;
  static int spf[]=new int[MAXN];
  static void sieve(){
    spf[1]=1 ;
    for(int i=2 ; i<MAXN ; i++)spf[i]=i ;
    for(int i=4 ; i<MAXN ; i+=2)spf[i]=2 ;
    for(int i=3 ; i*i<MAXN ; i++){
      if(spf[i]==i){
        for(int j=i*i ; j<MAXN ; j+=i)if(spf[j]==j)spf[j]=i ;
      }
    }
  }
  static HashMap<Integer,Integer>getFactorization(int x){
    HashMap<Integer,Integer>ret=new HashMap<>();
    while(x!=1){
      if(ret.containsKey(spf[x]))ret.put(spf[x],ret.get(spf[x])+1);
      else ret.put(spf[x],1);
      x=x/spf[x];
    }
    return ret ;
  }
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    sieve();
    long ans=0 ;
    for(int i=1 ; i<n+1 ; i++){
      HashMap<Integer,Integer>mp=getFactorization(i);
      long facs=1 ;
      for(Map.Entry me : mp.entrySet()){
        facs*=((int)me.getValue()+1);
      }
      ans+=(facs*i);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAXN : int := 10000001;
  static   attribute spf : int := Integer.subrange(1,MAXN)->collect(0);
  static   operation sieve() : void
  pre: true
  post: true
  activity: (     spf[1+1] := 1 ; 
         var i : int ; i := 2 ; while i < MAXN do (     spf[i+1] := i ;  ;     i := i + 1 ) ; 
         var i : int ; i := 4 ; while i < MAXN do (     spf[i+1] := 2 ;  ;     i := i+(2) ) ; 
         var i : int ; i := 3 ; while i * i < MAXN do ( (     if (spf[i+1] = i) then (         var j : int ; j := i * i ; while j < MAXN do (     if (spf[j+1] = j) then     spf[j+1] := i ; else skip ;  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) );
  static   operation getFactorization( x : int) : Map(int,int)
  pre: true
  post: true
  activity: (     var ret : Map(int,int) ; ret := Map{} ;
     while (x /= 1) do (     if (ret->keys()->includes(spf[x+1])) then     ret := ret->union(Map{spf[x+1] |-> ret->at(spf[x+1]) + 1}) else     ret := ret->union(Map{spf[x+1] |-> 1}) ; ;  
     x := x / spf[x+1] ) ; 
     return ret );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    execute sieve() ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     var mp : Map(int,int) ; mp := getFactorization(i) ;
     var facs : long ; facs := 1 ;
     for (me : mp->asSet()) do ( (     facs := facs*((me.getValue()->oclAsType(int) + 1)) )  ) ; 
     ans := ans+((facs * i)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner stdIn=new Scanner(System.in);
    int N=stdIn.nextInt();
    ArrayList<Integer>f=new ArrayList<Integer>();
    long ans=0 ;
    for(int i=1 ; i<=N ; i++){
      long Y=(int)Math.floor((double)N/i);
      ans+=Y*(Y+1)*i/2 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := stdIn.getCurrent()->toInteger() ;
    var f : Sequence(int) ; f := Sequence{} ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     var Y : long ; Y := (N->oclAsType(double) / i)->floor()->oclAsType(int) ;
     ans := ans+(Y * (Y + 1) * i / 2) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void check(int n,int m){
    if(n==2 || m==2 || n % m==0){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
  public static void main(String[] args){
    int m=3,n=9 ;
    check(n,m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( n : int, m : int) : void
  pre: true
  post: true
  activity: (     if (n = 2 or m = 2 or n mod m = 0) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 3 ;
    var n : int ; n := 9 ;
     execute check(n, m) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedWriter ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.text.DecimalFormat ;
import java.util.Scanner ;
public class Cookie {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(new FileReader("jam.in"));
    BufferedWriter bw=new BufferedWriter(new FileWriter("jam.out"));
    int cases ;
    cases=sc.nextInt();
    for(int z=1 ; z<=cases ; z++){
      double C=sc.nextDouble();
      double F=sc.nextDouble();
      double X=sc.nextDouble();
      double product=2 ;
      double ans=0 ;
      while(X/(product+F)+C/product<X/product){
        ans+=C/product ;
        product+=F ;
      }
      ans+=X/product ;
      bw.write("Case #"+z+": ");
      DecimalFormat df=new DecimalFormat("0.00000000");
      bw.write(""+df.format(ans)+"\n");
    }
    sc.close();
    bw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cookie {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("jam.in"))) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("jam.out"))) ;
    var cases : int ;
    cases := sc.getCurrent()->toInteger() ; 
        var z : int ; z := 1 ; while z <= cases do ( (     var C : double ; C := sc.getCurrent()->toReal() ;
     var F : double ; F := sc.getCurrent()->toReal() ;
    var X : double ; X := sc.getCurrent()->toReal() ;
    var product : double ; product := 2 ;
    var ans : double ; ans := 0 ;
    while (X / (product + F) + C / product < X / product) do (     ans := ans+(C / product) ; 
     product := product+(F) ) ; 
    ans := ans+(X / product) ; 
    skip ; 
    var df : DecimalFormat ; df := DecimalFormat.newDecimalFormat("0.00000000") ;
    skip ; 
 )  ;     z := z + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.HashSet ;
import java.util.Set ;
public class ColorThePicture {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t!=0){
      solve(br,pr);
      t--;
    }
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    String[] temp=br.readLine().split(" ");
    int m=Integer.parseInt(temp[0]);
    int n=Integer.parseInt(temp[1]);
    int k=Integer.parseInt(temp[2]);
    long sum=0 ;
    int[] colors=new int[k];
    temp=br.readLine().split(" ");
    for(int i=0 ; i<k ; i++){
      colors[i]=Integer.parseInt(temp[i]);
      sum+=colors[i];
    }
    boolean flag=check(m,n,colors)|| check(n,m,colors);
    pr.println(flag ? "Yes" : "No");
  }
  public static boolean check(int m,int n,int[] colors){
    long count=0 ;
    Set<Integer>set=new HashSet<>();
    for(int i : colors){
      int max=i/m ;
      if(max>=2){
        count+=max ;
        set.add(max);
      }
    }
    if(count<n){
      return false ;
    }
    if(set.size()>=2){
      return true ;
    }
    if(set.size()==1){
      if(set.contains(2)){
        return n % 2==0 ? true : false ;
      }
      else {
        return true ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ColorThePicture {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
    while (t /= 0) do (     execute solve(br, pr) ; 
     t := t - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
     var m : int ; m := (temp[0+1])->toInteger() ;
    var n : int ; n := (temp[1+1])->toInteger() ;
    var k : int ; k := (temp[2+1])->toInteger() ;
    var sum : long ; sum := 0 ;
    var colors : Sequence(int) ; colors := Integer.subrange(1,k)->collect(0) ;
    temp := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < k do ( (     colors[i+1] := (temp[i+1])->toInteger() ; 
     sum := sum+(colors[i+1]) )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := check(m, n, colors) or check(n, m, colors) ;
    skip ; 
 );
  static   operation check( m : int, n : int, colors : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
     var set : Set(int) ; set := Set{} ;
    for (i : colors) do ( (     var max : int ; max := i / m ;
     if (max >= 2) then (     count := count+(max) ; 
     set := set->including(max) ) else skip )  ) ; 
    if (count < n) then (     return false ) else skip ; 
    if (set->size() >= 2) then (     return true ) else skip ; 
    if (set->size() = 1) then (     if (set->includes(2)) then (     return if n mod 2 = 0 then true else false endif ) else (     return true ) ) else skip ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int negProdSubArr(int arr[],int n){
    int positive=1,negative=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]>0)arr[i]=1 ;
      else arr[i]=-1 ;
      if(i>0)arr[i]*=arr[i-1];
      if(arr[i]==1)positive++;
      else negative++;
    }
    return(positive*negative);
  }
  public static void main(String[] args){
    int arr[]={
      5,-4,-3,2,-5 };
      int n=arr.length ;
      System.out.println(negProdSubArr(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation negProdSubArr( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var positive : int ; positive := 1 ;
    var negative : int ; negative := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] > 0) then     arr[i+1] := 1 else     arr[i+1] := -1 ; ;  
     if (i > 0) then     arr[i+1] := arr[i+1]*(arr[i - 1+1]) ; else skip ; 
     if (arr[i+1] = 1) then     positive := positive + 1 ; else     negative := negative + 1 ; )  ;     i := i + 1 ) ; 
     return (positive * negative) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,-4,-3,2,-5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(negProdSubArr(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int russianPeasant(int a,int b){
    int res=0 ;
    while(b>0){
      if((b & 1)!=0)res=res+a ;
      a=a<<1 ;
      b=b>>1 ;
    }
    return res ;
  }
  public static void main(String[] args){
    System.out.println(russianPeasant(18,1));
    System.out.println(russianPeasant(20,12));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation russianPeasant( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     while (b > 0) do (     if ((b & 1) /= 0) then     res := res + a ; else skip ; 
     a := (a*(2->pow(1)))->oclAsType(long) ; 
     b := (b/(2->pow(1)))->oclAsType(long) ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(russianPeasant(18, 1)) ; 
     OclFile["System.out"].println(russianPeasant(20, 12)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int negProdSubArr(int arr[],int n){
    int positive=1,negative=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]>0)arr[i]=1 ;
      else arr[i]=-1 ;
      if(i>0)arr[i]*=arr[i-1];
      if(arr[i]==1)positive++;
      else negative++;
    }
    return(positive*negative);
  }
  static int posProdSubArr(int arr[],int n){
    int total=(n*(n+1))/2 ;
    int cntNeg=negProdSubArr(arr,n);
    return(total-cntNeg);
  }
  public static void main(String[] args){
    int arr[]={
      5,-4,-3,2,-5 };
      int n=arr.length ;
      System.out.println(posProdSubArr(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation negProdSubArr( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var positive : int ; positive := 1 ;
    var negative : int ; negative := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] > 0) then     arr[i+1] := 1 else     arr[i+1] := -1 ; ;  
     if (i > 0) then     arr[i+1] := arr[i+1]*(arr[i - 1+1]) ; else skip ; 
     if (arr[i+1] = 1) then     positive := positive + 1 ; else     negative := negative + 1 ; )  ;     i := i + 1 ) ; 
     return (positive * negative) );
  static   operation posProdSubArr( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var total : int ; total := (n * (n + 1)) / 2 ;
     var cntNeg : int ; cntNeg := negProdSubArr(arr, n) ;
     return (total - cntNeg) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,-4,-3,2,-5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(posProdSubArr(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class CF3 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args)throws java.lang.Exception {
    FastReader in=new FastReader();
    int t=in.nextInt();
    while(t-->0){
      long n=in.nextLong();
      long k=in.nextLong();
      long sum=0,cur=1 ;
      while(cur<k){
        cur*=2 ;
++sum ;
      }
      if(cur<n)sum+=(n-cur+k-1)/k ;
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF3 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var t : int ; t := in.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := in.nextLong() ;
     var k : long ; k := in.nextLong() ;
    var sum : long ; sum := 0 ;
    var cur : long ; cur := 1 ;
    while (cur < k) do (     cur := cur*(2) ; 
     sum := sum + 1 ) ; 
    if (cur < n) then     sum := sum+((n - cur + k - 1) / k) ; else skip ; 
    OclFile["System.out"].println(sum) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int i ;
    long n,k ;
    long h ;
    long c ;
    int t=sc.nextInt();
    for(i=0 ; i<t ; i++){
      n=sc.nextLong();
      k=sc.nextLong();
      h=0 ;
      c=1 ;
      while(c<k){
        c*=2 ;
        h++;
      }
      if(c<n)h+=(n-c+k-1)/k ;
      System.out.println(h);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ;
    var n : long ;
    var k : long ;
    var h : long ;
    var c : long ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        i := 0 ; while i < t do ( (     n := sc.getCurrent()->toLong() ; 
     k := sc.getCurrent()->toLong() ; 
    h := 0 ; 
    c := 1 ; 
    while (c < k) do (     c := c*(2) ; 
     h := h + 1 ) ; 
    if (c < n) then     h := h+((n - c + k - 1) / k) ; else skip ; 
    OclFile["System.out"].println(h) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class Templ {
  static StreamTokenizer in ;
  static int nextInt()throws IOException {
    in.nextToken();
    return(int)in.nval ;
  }
  public static void main(String[] args)throws IOException {
    in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      long n=sc.nextLong();
      long k=sc.nextLong();
      long time=0 ;
      long size=1 ;
      while(size<n && size<=k){
        size<<=1 ;
        time++;
      }
      if(size<n){
        time+=(n-size)/k ;
        if((n-size)% k!=0)time++;
      }
      System.out.println(time);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Templ {
  static   attribute in : StreamTokenizer;
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     in.next() ; 
     return in.nval->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := StreamTokenizer.newStreamTokenizer(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : long ; n := sc.getCurrent()->toLong() ;
     var k : long ; k := sc.getCurrent()->toLong() ;
    var time : long ; time := 0 ;
    var size : long ; size := 1 ;
    while (size < n & size <= k) do (     size := size*(2->pow(1)) ; 
     time := time + 1 ) ; 
    if (size < n) then (     time := time+((n - size) / k) ; 
     if ((n - size) mod k /= 0) then     time := time + 1 ; else skip ) else skip ; 
    OclFile["System.out"].println(time) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long cnt=0 ;
      long n=sc.nextLong(),k=sc.nextLong();
      if(n==1 && k==1){
        System.out.println(0);
      }
      else if(k==1){
        System.out.println(n-1);
      }
      else {
        long kabel=1 ;
        n--;
        while(n>0){
          n-=kabel ;
          kabel*=2 ;
          cnt++;
          if(kabel>k){
            cnt+=(n+k-1)/k ;
            break ;
          }
        }
        System.out.println(cnt);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var cnt : long ; cnt := 0 ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
     if (n = 1 & k = 1) then (     OclFile["System.out"].println(0) ) else     if (k = 1) then (     OclFile["System.out"].println(n - 1) ) else (     var kabel : long ; kabel := 1 ;
     n := n - 1 ; 
     while (n > 0) do (     n := n-(kabel) ; 
     kabel := kabel*(2) ; 
     cnt := cnt + 1 ; 
     if (kabel > k) then (     cnt := cnt+((n + k - 1) / k) ; 
     break ) else skip ) ; 
     OclFile["System.out"].println(cnt) ) ;  ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(new BufferedOutputStream(System.out));
    String[] z=br.readLine().split(" ");
    int x=Integer.parseInt(z[0]);
    int y=Integer.parseInt(z[1]);
    int a=Integer.parseInt(z[2]);
    int b=Integer.parseInt(z[3]);
    int c=0,i,j ;
    int lcm=x*y/gcd(x,y);
    for(i=a ; i<=b ; i++){
      if(i % lcm==0){
        break ;
      }
    }
    for(j=b ; j>=a ; j--){
      if(j % lcm==0){
        break ;
      }
    }
    if(j % lcm==0 && i % lcm==0){
      c=(j-i)/lcm+1 ;
    }
    pw.println(c);
    pw.close();
  }
  public static int gcd(int a,int b){
    int temp=a ;
    if(a<b){
      a=b ;
      b=temp ;
    }
    if(a % b==0){
      return b ;
    }
    else {
      return gcd(b,a % b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var z : Sequence(String) ; z := br.readLine()->split(" ") ;
    var x : int ; x := (z[0+1])->toInteger() ;
    var y : int ; y := (z[1+1])->toInteger() ;
    var a : int ; a := (z[2+1])->toInteger() ;
    var b : int ; b := (z[3+1])->toInteger() ;
    var c : int ; c := 0 ;
    var i : int ;
    var j : int ;
    var lcm : int ; lcm := x * y / gcd(x, y) ;
        i := a ; while i <= b do ( (     if (i mod lcm = 0) then (     break ) else skip )  ;     i := i + 1 ) ; 
        j := b ; while j >= a do ( (     if (j mod lcm = 0) then (     break ) else skip )  ;     j := j - 1 ) ; 
    if (j mod lcm = 0 & i mod lcm = 0) then (     c := (j - i) / lcm + 1 ) else skip ; 
    skip ; 
    skip ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var temp : int ; temp := a ;
     if (a < b) then (     a := b ; 
     b := temp ) else skip ; 
     if (a mod b = 0) then (     return b ) else (     return gcd(b, a mod b) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class candies {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int a=in.nextInt();
      int x[]=new int[a];
      for(int i=0 ; i<a ; i++){
        x[i]=in.nextInt();
      }
      Arrays.sort(x);
      int s=0 ;
      for(int i=0 ; i<a ; i++){
        s+=Math.abs(x[i]-x[0]);
      }
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class candies {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := in.getCurrent()->toInteger() ;
     var x : Sequence(int) ; x := Integer.subrange(1,a)->collect(0) ;
        var i : int ; i := 0 ; while i < a do ( (     x[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    x := x->sort() ; 
    var s : int ; s := 0 ;
        var i : int ; i := 0 ; while i < a do ( (     s := s+(if x[i+1] - x[0+1] < 0 then -(x[i+1] - x[0+1]) else x[i+1] - x[0+1] endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(new BufferedOutputStream(System.out));
    String[] z=br.readLine().split(" ");
    int x=Integer.parseInt(z[0]);
    int y=Integer.parseInt(z[1]);
    int a=Integer.parseInt(z[2]);
    int b=Integer.parseInt(z[3]);
    int c=0,i,j ;
    int lcm=x*y/gcd(x,y);
    for(i=a ; i<=b ; i++){
      if(i % lcm==0){
        break ;
      }
    }
    for(j=b ; j>=a ; j--){
      if(j % lcm==0){
        break ;
      }
    }
    if(j % lcm==0 && i % lcm==0){
      c=(j-i)/lcm+1 ;
    }
    pw.println(c);
    pw.close();
  }
  public static int gcd(int a,int b){
    int temp=a ;
    if(a<b){
      a=b ;
      b=temp ;
    }
    if(a % b==0){
      return b ;
    }
    else {
      return gcd(b,a % b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var z : Sequence(String) ; z := br.readLine()->split(" ") ;
    var x : int ; x := (z[0+1])->toInteger() ;
    var y : int ; y := (z[1+1])->toInteger() ;
    var a : int ; a := (z[2+1])->toInteger() ;
    var b : int ; b := (z[3+1])->toInteger() ;
    var c : int ; c := 0 ;
    var i : int ;
    var j : int ;
    var lcm : int ; lcm := x * y / gcd(x, y) ;
        i := a ; while i <= b do ( (     if (i mod lcm = 0) then (     break ) else skip )  ;     i := i + 1 ) ; 
        j := b ; while j >= a do ( (     if (j mod lcm = 0) then (     break ) else skip )  ;     j := j - 1 ) ; 
    if (j mod lcm = 0 & i mod lcm = 0) then (     c := (j - i) / lcm + 1 ) else skip ; 
    skip ; 
    skip ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var temp : int ; temp := a ;
     if (a < b) then (     a := b ; 
     b := temp ) else skip ; 
     if (a mod b = 0) then (     return b ) else (     return gcd(b, a mod b) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TheWall {
  public static void main(String[] sh){
    Scanner s=new Scanner(System.in);
    long x=s.nextInt();
    long y=s.nextInt();
    long a=s.nextInt();
    long b=s.nextInt();
    long j=2,i,x1=0,y1=0,c=0 ;
    boolean ans=true ;
    c=Math.max(x,y);
    if(c>b){
      System.out.println("0");
      ans=false ;
    }
    while(c % Math.min(x,y)!=0 && ans){
      if(x>y){
        c=x*j ;
        j++;
      }
      else {
        c=y*j ;
        j++;
      }
      if(c>b){
        System.out.println("0");
        ans=false ;
        break ;
      }
    }
    if(ans){
      long count=0 ;
      i=a ;
      for(i=a ; i<=b ; i++){
        if(i % c==0)break ;
      }
      if(i!=b+1)System.out.println(((b-i)/c)+1);
      else System.out.println("0");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TheWall {
  static   operation main( sh : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := s.getCurrent()->toInteger() ;
    var y : long ; y := s.getCurrent()->toInteger() ;
    var a : long ; a := s.getCurrent()->toInteger() ;
    var b : long ; b := s.getCurrent()->toInteger() ;
    var j : long ; j := 2 ;
    var i : long ;
    var x1 : long ; x1 := 0 ;
    var y1 : long ; y1 := 0 ;
    var c : long ; c := 0 ;
    var ans : boolean ; ans := true ;
    c := Set{x, y}->max() ; 
    if (c > b) then (     OclFile["System.out"].println("0") ; 
     ans := false ) else skip ; 
    while (c mod Set{x, y}->min() /= 0 & ans) do (     if (x > y) then (     c := x * j ; 
     j := j + 1 ) else (     c := y * j ; 
     j := j + 1 ) ;  
     if (c > b) then (     OclFile["System.out"].println("0") ; 
     ans := false ; 
     break ) else skip ) ; 
    if (ans) then (     var count : long ; count := 0 ;
     i := a ; 
         i := a ; while i <= b do ( (     if (i mod c = 0) then     break else skip )  ;     i := i + 1 ) ; 
     if (i /= b + 1) then     OclFile["System.out"].println(((b - i) / c) + 1) ; else     OclFile["System.out"].println("0") ; ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int max=Math.max(x,y);
    int min=Math.min(x,y);
    while(max % min!=0){
      int r=max % min ;
      max=min ;
      min=r ;
    }
    int k=x*y ;
    int l=k/min ;
    int r1=(a-1)/l ;
    int r2=b/l ;
    System.out.print((r2-r1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var max : int ; max := Set{x, y}->max() ;
    var min : int ; min := Set{x, y}->min() ;
    while (max mod min /= 0) do (     var r : int ; r := max mod min ;
     max := min ; 
     min := r ) ; 
    var k : int ; k := x * y ;
    var l : int ; l := k / min ;
    var r1 : int ; r1 := (a - 1) / l ;
    var r2 : int ; r2 := b / l ;
    OclFile["System.out"].print((r2 - r1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  static int minRemove(int arr[],int n){
    int LIS[]=new int[n];
    int len=0 ;
    for(int i=0 ; i<n ; i++)LIS[i]=1 ;
    for(int i=1 ; i<n ; i++){
      for(int j=0 ; j<i ; j++){
        if(arr[i]>arr[j] &&(i-j)<=(arr[i]-arr[j]))LIS[i]=Math.max(LIS[i],LIS[j]+1);
      }
      len=Math.max(len,LIS[i]);
    }
    return n-len ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,6,5,4 };
      int n=arr.length ;
      System.out.println(minRemove(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation minRemove( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var LIS : Sequence(int) ; LIS := Integer.subrange(1,n)->collect(0) ;
     var len : int ; len := 0 ;
        var i : int ; i := 0 ; while i < n do (     LIS[i+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 0 ; while j < i do ( (     if (arr[i+1] > arr[j+1] & (i - j) <= (arr[i+1] - arr[j+1])) then     LIS[i+1] := Set{LIS[i+1], LIS[j+1] + 1}->max() ; else skip )  ;     j := j + 1 ) ; 
     len := Set{len, LIS[i+1]}->max() )  ;     i := i + 1 ) ; 
    return n - len 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,6,5,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minRemove(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class gfg {
  static boolean isValid(String str,int len){
    for(int i=1 ; i<len ; i++){
      if(str.charAt(i)==str.charAt(i-1))return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    String str="0110" ;
    int len=str.length();
    if(isValid(str,len))System.out.println("Valid");
    else System.out.println("Invalid");
  }
}
------------------------------------------------------------
OCL File:
---------
class gfg {
  static   operation isValid( str : String, len : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < len do ( (     if (str->at(i+1) = str->at(i - 1+1)) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "0110" ;
     var len : int ; len := str->size() ;
     if (isValid(str, len)) then     OclFile["System.out"].println("Valid") ; else     OclFile["System.out"].println("Invalid") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void print_max(int a[],int n,int k){
    int[] max_upto=new int[n];
    Stack<Integer>s=new Stack<>();
    s.push(0);
    for(int i=1 ; i<n ; i++){
      while(! s.empty()&& a[s.peek()]<a[i]){
        max_upto[s.peek()]=i-1 ;
        s.pop();
      }
      s.push(i);
    }
    while(! s.empty()){
      max_upto[s.peek()]=n-1 ;
      s.pop();
    }
    int j=0 ;
    for(int i=0 ; i<=n-k ; i++){
      while(j<i || max_upto[j]<i+k-1){
        j++;
      }
      System.out.print(a[j]+" ");
    }
    System.out.println();
  }
  public static void main(String[] args){
    int a[]={
      9,7,2,4,6,8,2,1,5 };
      int n=a.length ;
      int k=3 ;
      print_max(a,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation print_max( a : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var max_upto : Sequence(int) ; max_upto := Integer.subrange(1,n)->collect(0) ;
     var s : Sequence(int) ; s := Sequence{} ;
    s := s->append(0) ; 
        var i : int ; i := 1 ; while i < n do ( (     while (not(s->isEmpty()) & a[s->min()+1] < a[i+1]) do (     max_upto[s->min()+1] := i - 1 ; 
     s := s->front() ) ; 
     s := s->append(i) )  ;     i := i + 1 ) ; 
    while (not(s->isEmpty())) do (     max_upto[s->min()+1] := n - 1 ; 
     s := s->front() ) ; 
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i <= n - k do ( (     while (j < i or max_upto[j+1] < i + k - 1) do (     j := j + 1 ) ; 
     OclFile["System.out"].print(a[j+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{9,7,2,4,6,8,2,1,5} ;
     var n : int ; n := a->size() ;
     var k : int ; k := 3 ;
     execute print_max(a, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p056 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p056().run());
  }
  public String run(){
    int max=0 ;
    for(int a=1 ; a<100 ; a++){
      for(int b=1 ; b<100 ; b++){
        BigInteger pow=BigInteger.valueOf(a).pow(b);
        max=Math.max(digitSum(pow),max);
      }
    }
    return Integer.toString(max);
  }
  private static int digitSum(BigInteger n){
    int sum=0 ;
    String s=n.toString();
    for(int i=0 ; i<s.length(); i++)sum+=s.charAt(i)-'0' ;
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class p056 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p056.newp056().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var max : int ; max := 0 ;
         var a : int ; a := 1 ; while a < 100 do ( (         var b : int ; b := 1 ; while b < 100 do ( (     var pow : long ; pow := (a + "")->toLong().pow(b) ;
     max := Set{digitSum(pow), max}->max() )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
     return ((max) + "") );
  static   operation digitSum( n : long) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var s : String ; s := n+"" ;
         var i : int ; i := 0 ; while i < s->size() do (     sum := sum+(s->at(i+1) - ('0')->char2byte()) ;  ;     i := i + 1 ) ; 
     return sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class Test {
  static int countWindowDistinct(int win[],int k){
    int dist_count=0 ;
    for(int i=0 ; i<k ; i++){
      int j ;
      for(j=0 ; j<i ; j++)if(win[i]==win[j])break ;
      if(j==i)dist_count++;
    }
    return dist_count ;
  }
  static void countDistinct(int arr[],int n,int k){
    for(int i=0 ; i<=n-k ; i++)System.out.println(countWindowDistinct(Arrays.copyOfRange(arr,i,arr.length),k));
  }
  public static void main(String args[]){
    int arr[]={
      1,2,1,3,4,2,3 },k=4 ;
      countDistinct(arr,arr.length,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation countWindowDistinct( win : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     var dist_count : int ; dist_count := 0 ;
         var i : int ; i := 0 ; while i < k do ( (     var j : int ;
         j := 0 ; while j < i do (     if (win[i+1] = win[j+1]) then     break else skip ;  ;     j := j + 1 ) ; 
     if (j = i) then     dist_count := dist_count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return dist_count );
  static   operation countDistinct( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= n - k do (     OclFile["System.out"].println(countWindowDistinct(arr.subrange(i+1,arr->size()), k)) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,1,3,4,2,3} ;
    var k : int ; k := 4 ;
     execute countDistinct(arr, arr->size(), k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int evenNumSubstring(String str){
    int len=str.length();
    int count=0 ;
    for(int i=0 ; i<len ; i++){
      int temp=str.charAt(i)-'0' ;
      if(temp % 2==0)count+=(i+1);
    }
    return count ;
  }
  public static void main(String args[]){
    String str="1234" ;
    System.out.println(evenNumSubstring(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation evenNumSubstring( str : String) : int
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < len do ( (     var temp : int ; temp := str->at(i+1) - ('0')->char2byte() ;
     if (temp mod 2 = 0) then     count := count+((i + 1)) ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "1234" ;
     OclFile["System.out"].println(evenNumSubstring(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class solution {
  static final int max=4 ;
  static int countWays(int index,int cnt,int dp[][],int n,int m,int k){
    if(index==n){
      if(cnt==k)return 1 ;
      else return 0 ;
    }
    if(dp[index][cnt]!=-1)return dp[index][cnt];
    int ans=0 ;
    ans+=countWays(index+1,cnt,dp,n,m,k);
    ans+=(m-1)*countWays(index+1,cnt+1,dp,n,m,k);
    return dp[index][cnt]=ans ;
  }
  public static void main(String args[]){
    int n=3,m=3,k=2 ;
    int dp[][]=new int[n+1][max];
    for(int i=0 ; i<n+1 ; i++)for(int j=0 ; j<max ; j++)dp[i][j]=-1 ;
    System.out.println(m*countWays(1,0,dp,n,m,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class solution {
  static    attribute max : int := 4;
  static   operation countWays( index : int, cnt : int, dp : Sequence(Sequence(int)), n : int, m : int, k : int) : int
  pre: true
  post: true
  activity: (     if (index = n) then (     if (cnt = k) then     return 1 else     return 0 ) else skip ; 
     if (dp[index+1][cnt+1] /= -1) then     return dp[index+1][cnt+1] else skip ; 
    var ans : int ; ans := 0 ;
    ans := ans+(countWays(index + 1, cnt, dp, n, m, k)) ; 
    ans := ans+((m - 1) * countWays(index + 1, cnt + 1, dp, n, m, k)) ; 
    return dp[index+1][cnt+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
    var m : int ; m := 3 ;
    var k : int ; k := 2 ;
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,max)->collect(0)) ;
         var i : int ; i := 0 ; while i < n + 1 do (         var j : int ; j := 0 ; while j < max do (     dp[i+1][j+1] := -1 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(m * countWays(1, 0, dp, n, m, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package con2014Q ;
import java.io.*;
import java.util.*;
public class B {
  private static final String islarge="-large" ;
  private static final String fileName="results/con2014Q/"+B.class.getSimpleName().toLowerCase()+islarge ;
  private static final String inputFileName=fileName+".in" ;
  private static final String outputFileName=fileName+".out" ;
  private static Scanner in ;
  private static PrintWriter out ;
  private void solve(){
    double C=Double.parseDouble(in.next()),F=Double.parseDouble(in.next()),X=Double.parseDouble(in.next());
    double best=X/2 ;
    double cur=0 ;
    int a_farms=0 ;
    while(cur<best){
      cur+=C/(2+(a_farms*F));
      a_farms++;
      best=Math.min(best,cur+(X/(2+(a_farms*F))));
    }
    out.format("%.7f%n",best);
  }
  public static void main(String[] args)throws IOException {
    Locale.setDefault(Locale.US);
    long start=System.currentTimeMillis();
    in=new Scanner(new FileReader(inputFileName));
    out=new PrintWriter(outputFileName);
    int tests=in.nextInt();
    in.nextLine();
    for(int t=1 ; t<=tests ; t++){
      out.print("Case #"+t+": ");
      new B().solve();
      System.out.println("Case #"+t+": solved");
    }
    in.close();
    out.close();
    long stop=System.currentTimeMillis();
    System.out.println(stop-start+" ms");
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static    attribute islarge : String := "-large";
  static    attribute fileName : String := "results/con2014Q/" + OclType["B"].getSimpleName()->toLowerCase() + islarge;
  static    attribute inputFileName : String := fileName + ".in";
  static    attribute outputFileName : String := fileName + ".out";
  static   attribute in : OclFile;
  static   attribute out : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     var C : double ; C := (in.getCurrent())->toReal() ;
    var F : double ; F := (in.getCurrent())->toReal() ;
    var X : double ; X := (in.getCurrent())->toReal() ;
     var best : double ; best := X / 2 ;
    var cur : double ; cur := 0 ;
    var a_farms : int ; a_farms := 0 ;
    while (cur < best) do (     cur := cur+(C / (2 + (a_farms * F))) ; 
     a_farms := a_farms + 1 ; 
     best := Set{best, cur + (X / (2 + (a_farms * F)))}->min() ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.US) ; 
     var start : long ; start := OclDate.getSystemTime() ;
    in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(inputFileName))) ; 
    out := OclFile.newOclFile_Write(OclFile.newOclFile(outputFileName)) ; 
    var tests : int ; tests := in.getCurrent()->toInteger() ;
    skip ; 
        var t : int ; t := 1 ; while t <= tests do ( (     skip ; 
     B.newB().solve() ; 
     OclFile["System.out"].println("Case #" + t + ": solved") )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
    var stop : long ; stop := OclDate.getSystemTime() ;
    OclFile["System.out"].println(stop - start + " ms") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int getSum(int n){
    int sum=0 ;
    for(int i=1 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        if(n/i==i){
          sum=sum+i ;
        }
        else {
          sum=sum+i ;
          sum=sum+(n/i);
        }
      }
    }
    return sum-n ;
  }
  static void printAliquot(int n){
    System.out.printf("%d ",n);
    TreeSet<Integer>s=new TreeSet<>();
    s.add(n);
    int next=0 ;
    while(n>0){
      n=getSum(n);
      if(s.contains(n)&& n!=s.last()){
        System.out.print("\nRepeats with "+n);
        break ;
      }
      System.out.print(n+" ");
      s.add(n);
    }
  }
  public static void main(String[] args){
    printAliquot(12);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     if (n / i = i) then (     sum := sum + i ) else (     sum := sum + i ; 
     sum := sum + (n / i) ) ) else skip )  ;     i := i + 1 ) ; 
     return sum - n );
  static   operation printAliquot( n : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].printf("%d ", n) ; 
     var s : Set(int) ; s := Set{} ;
    s := s->including(n) ; 
    var next : int ; next := 0 ;
    while (n > 0) do (     n := getSum(n) ; 
     if (s->includes(n) & n /= s->last()) then (     OclFile["System.out"].print("\nRepeats with " + n) ; 
     break ) else skip ; 
     OclFile["System.out"].print(n + " ") ; 
     s := s->including(n) ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute printAliquot(12) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class PashaAndHamsters {
  public static void main(String[] args)throws IOException {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(is);
    String dims[]=br.readLine().split(" ");
    int total=Integer.parseInt(dims[0]);
    int at=Integer.parseInt(dims[1]);
    int pt=Integer.parseInt(dims[2]);
    boolean[] vals=new boolean[total];
    String as[]=br.readLine().split(" ");
    for(int i=0 ; i<as.length ; i++){
      int x=Integer.parseInt(as[i]);
      vals[x-1]=true ;
    }
    StringBuffer sb=new StringBuffer();
    for(int i=0 ; i<total ; i++){
      sb.append((vals[i] ? "1" : "2")+" ");
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class PashaAndHamsters {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(is) ;
    var dims : Sequence(String) ; dims := br.readLine()->split(" ") ;
    var total : int ; total := (dims[0+1])->toInteger() ;
    var at : int ; at := (dims[1+1])->toInteger() ;
    var pt : int ; pt := (dims[2+1])->toInteger() ;
    var vals : Sequence(boolean) ; vals := Integer.subrange(1,total)->collect(false) ;
    var as : Sequence(String) ; as := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < as->size() do ( (     var x : int ; x := (as[i+1])->toInteger() ;
     vals[x - 1+1] := true )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < total do ( (     sb := sb + StringLib.newString((if vals[i+1] then "1" else "2" endif) + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.nio.charset.IllegalCharsetNameException ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,a,b ;
    n=sc.nextInt();
    a=sc.nextInt();
    b=sc.nextInt();
    ArrayList<Integer>list1=new ArrayList<>();
    ArrayList<Integer>list2=new ArrayList<>();
    for(int i=0 ; i<a ; i++){
      list1.add(sc.nextInt());
    }
    for(int i=0 ; i<b ; i++){
      list2.add(sc.nextInt());
    }
    for(int i=0 ; i<n ; i++){
      if(list1.contains(i+1)){
        System.out.print(1+" ");
      }
      else {
        System.out.print(2+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var a : int ;
    var b : int ;
    n := sc.getCurrent()->toInteger() ; 
    a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    var list1 : Sequence(int) ; list1 := Sequence{} ;
    var list2 : Sequence(int) ; list2 := Sequence{} ;
        var i : int ; i := 0 ; while i < a do ( (     list1 := list1->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < b do ( (     list2 := list2->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (list1->includes(i + 1)) then (     OclFile["System.out"].print(1 + " ") ) else (     OclFile["System.out"].print(2 + " ") ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
import java.io.*;
public class codeforces {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    ArrayList<Integer>x=new ArrayList<>();
    ArrayList<Integer>y=new ArrayList<>();
    for(int i=1 ; i<=a ; i++)x.add(sc.nextInt());
    for(int i=1 ; i<=b ; i++)y.add(sc.nextInt());
    for(int i=1 ; i<=n ; i++){
      if(x.contains(i))System.out.print("1 ");
      else if(y.contains(i))System.out.print("2 ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Sequence{} ;
    var y : Sequence(int) ; y := Sequence{} ;
        var i : int ; i := 1 ; while i <= a do (     x := x->including(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= b do (     y := y->including(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (x->includes(i)) then     OclFile["System.out"].print("1 ") ; else     if (y->includes(i)) then     OclFile["System.out"].print("2 ") ; else skip ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class PashaAndHamsters {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int a=scan.nextInt();
    int b=scan.nextInt();
    scan.nextLine();
    int[] A=new int[a];
    for(int i=0 ; i<a ; i++){
      A[i]=scan.nextInt();
    }
    scan.nextLine();
    int[] B=new int[b];
    for(int i=0 ; i<b ; i++){
      B[i]=scan.nextInt();
    }
    Arrays.sort(A);
    Arrays.sort(B);
    int x=0 ;
    int y=0 ;
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      if(x<A.length && A[x]==i+1){
        res[i]=1 ;
        x++;
        if(y<B.length && B[y]==i+1)y++;
      }
      if(y<B.length && B[y]==i+1){
        res[i]=2 ;
        y++;
      }
    }
    for(int i=0 ; i<res.length ; i++){
      System.out.print(res[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PashaAndHamsters {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    skip ; 
    var A : Sequence(int) ; A := Integer.subrange(1,a)->collect(0) ;
        var i : int ; i := 0 ; while i < a do ( (     A[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var B : Sequence(int) ; B := Integer.subrange(1,b)->collect(0) ;
        var i : int ; i := 0 ; while i < b do ( (     B[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    B := B->sort() ; 
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     if (x < A->size() & A[x+1] = i + 1) then (     res[i+1] := 1 ; 
     x := x + 1 ; 
     if (y < B->size() & B[y+1] = i + 1) then     y := y + 1 ; else skip ) else skip ; 
     if (y < B->size() & B[y+1] = i + 1) then (     res[i+1] := 2 ; 
     y := y + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < res->size() do ( (     OclFile["System.out"].print(res[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Random ;
class GFG {
  static int lehmann(int n,int t){
    Random rand=new Random();
    int a=rand.nextInt(n-3)+2 ;
    float e=(n-1)/2 ;
    while(t>0){
      int result=((int)(Math.pow(a,e)))% n ;
      if((result % n)==1 ||(result % n)==(n-1)){
        a=rand.nextInt(n-3)+2 ;
        t-=1 ;
      }
      else return-1 ;
    }
    return 1 ;
  }
  public static void main(String[] args){
    int n=13 ;
    int t=10 ;
    if(n==2)System.out.println(" 2 is Prime.");
    if(n % 2==0)System.out.println(n+" is Composite");
    else {
      long flag=lehmann(n,t);
      if(flag==1)System.out.println(n+" may be Prime.");
      else System.out.println(n+" is Composite.");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation lehmann( n : int, t : int) : int
  pre: true
  post: true
  activity: (     var rand : OclRandom ; rand := OclRandom.newOclRandom() ;
     var a : int ; a := rand.nextInt(n - 3) + 2 ;
    var e : double ; e := (n - 1) / 2 ;
    while (t > 0) do (     var result : int ; result := ((a->pow(e))->oclAsType(int)) mod n ;
     if ((result mod n) = 1 or (result mod n) = (n - 1)) then (     a := rand.nextInt(n - 3) + 2 ; 
     t := t-(1) ) else     return -1 ) ; 
    return 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 13 ;
     var t : int ; t := 10 ;
     if (n = 2) then     OclFile["System.out"].println(" 2 is Prime.") ; else skip ; 
     if (n mod 2 = 0) then     OclFile["System.out"].println(n + " is Composite") ; else (     var flag : long ; flag := lehmann(n, t) ;
     if (flag = 1) then     OclFile["System.out"].println(n + " may be Prime.") ; else     OclFile["System.out"].println(n + " is Composite.") ; ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class DivideandSum_680B {
  static int mod=998244353 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] nums=new int[2*n];
    for(int i=0 ; i<2*n ; i++)nums[i]=sc.nextInt();
    sc.close();
    Arrays.sort(nums);
    long diff=0 ;
    for(int i=0 ; i<n ; i++)diff+=Math.abs(nums[i]-nums[2*n-i-1]);
    long a=1,b=1 ;
    for(int i=1 ; i<=2*n ; i++){
      if(i>n)b=(b*i)% mod ;
      else a=(a*i)% mod ;
    }
    long count=fastPow(b,a);
    System.out.println((diff % mod*count)% mod);
  }
  private static long fastPow(long b,long a){
    int c=mod-2 ;
    long res=b,base=a ;
    while(c>0){
      if(c % 2==1)res=(res*base)% mod ;
      base=base*base % mod ;
      c>>=1 ;
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class DivideandSum_680B {
  static   attribute mod : int := 998244353;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,2 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 * n do (     nums[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    skip ; 
    nums := nums->sort() ; 
    var diff : long ; diff := 0 ;
        var i : int ; i := 0 ; while i < n do (     diff := diff+(if nums[i+1] - nums[2 * n - i - 1+1] < 0 then -(nums[i+1] - nums[2 * n - i - 1+1]) else nums[i+1] - nums[2 * n - i - 1+1] endif) ;  ;     i := i + 1 ) ; 
    var a : long ; a := 1 ;
    var b : long ; b := 1 ;
        var i : int ; i := 1 ; while i <= 2 * n do ( (     if (i > n) then     b := (b * i) mod mod ; else     a := (a * i) mod mod ; )  ;     i := i + 1 ) ; 
    var count : long ; count := fastPow(b, a) ;
    OclFile["System.out"].println((diff mod mod * count) mod mod) ; 
 );
  static   operation fastPow( b : long, a : long) : long
  pre: true
  post: true
  activity: (     var c : int ; c := mod - 2 ;
     var res : long ; res := b ;
    var base : long ; base := a ;
     while (c > 0) do (     if (c mod 2 = 1) then     res := (res * base) mod mod ; else skip ; 
     base := base * base mod mod ; 
     c := c/(2->pow(1)) ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static void reverseArray(int arr[],int n){
    for(int i=0 ; i<n/2 ; i++){
      swap(arr,i,(n+~ i+1)+~ 1+1);
    }
  }
  static int[] swap(int[] arr,int i,int j){
    int temp=arr[i];
    arr[i]=arr[j];
    arr[j]=temp ;
    return arr ;
  }
  public static void main(String args[]){
    int arr[]={
      5,3,7,2,1,6 };
      int n=arr.length ;
      reverseArray(arr,n);
      for(int i=0 ; i<n ; i++){
        System.out.print(arr[i]+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation reverseArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n / 2 do ( (     execute swap(arr, i, (n + -(i + 1) + 1) + -(1 + 1) + 1) )  ;     i := i + 1 ) );
  static   operation swap( arr : Sequence(int), i : int, j : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := arr[j+1] ; 
     arr[j+1] := temp ; 
     return arr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,3,7,2,1,6} ;
     var n : int ; n := arr->size() ;
     execute reverseArray(arr, n) ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printSeriesSum(int N){
    double sum=0 ;
    int a=1 ;
    int cnt=0 ;
    boolean flag=true ;
    sum+=a ;
    while(cnt<N){
      int nextElement ;
      if(flag==true){
        nextElement=a*2 ;
        sum+=nextElement ;
        flag=! flag ;
      }
      else {
        nextElement=a*3/2 ;
        sum+=nextElement ;
        flag=! flag ;
      }
      a=nextElement ;
      cnt++;
    }
    System.out.println(sum);
  }
  public static void main(String[] args){
    int N=8 ;
    printSeriesSum(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printSeriesSum( N : int) : void
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
     var a : int ; a := 1 ;
    var cnt : int ; cnt := 0 ;
    var flag : boolean ; flag := true ;
    sum := sum+(a) ; 
    while (cnt < N) do (     var nextElement : int ;
     if (flag = true) then (     nextElement := a * 2 ; 
     sum := sum+(nextElement) ; 
     flag := not(flag) ) else (     nextElement := a * 3 / 2 ; 
     sum := sum+(nextElement) ; 
     flag := not(flag) ) ;  
     a := nextElement ; 
     cnt := cnt + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 8 ;
     execute printSeriesSum(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String line ;
    int T=sc.nextInt();
    for(int i=0 ; i<T ; i++){
      long h=sc.nextLong();
      long w=sc.nextLong();
      long gcd=gcd(h,w);
      h/=gcd ;
      w/=gcd ;
      if(h==w){
        System.out.println("1 0");
      }
      else if(h % 2==0 || w % 2==0){
        System.out.println("1 1");
      }
      else {
        long a,b ;
        a=(h*w)/2+1 ;
        b=(h*w)/2 ;
        System.out.println(a+" "+b);
      }
    }
  }
  static long gcd(long a,long b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : String ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < T do ( (     var h : long ; h := sc.getCurrent()->toLong() ;
     var w : long ; w := sc.getCurrent()->toLong() ;
    var gcd : long ; gcd := gcd(h, w) ;
    h := h/(gcd) ; 
    w := w/(gcd) ; 
    if (h = w) then (     OclFile["System.out"].println("1 0") ) else     if (h mod 2 = 0 or w mod 2 = 0) then (     OclFile["System.out"].println("1 1") ) else (     var a : long ;
    var b : long ;
     a := (h * w) / 2 + 1 ; 
     b := (h * w) / 2 ; 
     OclFile["System.out"].println(a + " " + b) ) ;  ;  
 )  ;     i := i + 1 ) );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File;
import java.io.PrintStream;
import java.util.Scanner;
public class B {
    static final Boolean SAMPLE = false;
    static final String PROBLEM = "B";
    static final String INPUT = "large";
    static final String ID = "0";
    static final String PATH = "F:\\software installation\\codejam-commandline-1.2-beta1\\source\\";
    public static void main(String args[]) throws Throwable {
        Scanner in = SAMPLE ? new Scanner(System.in) : new Scanner(new File(PATH + PROBLEM + "-" + INPUT + "-" + ID + ".in"));
        PrintStream out = SAMPLE ? System.out : new PrintStream(PATH + PROBLEM + "-" + INPUT + "-" + ID + ".out");
        int test = in.nextInt();
        for (int t = 1; t <= test; t++) {
            out.print("Case #" + t + ": ");
            double C = in.nextDouble();
            double F = in.nextDouble();
            double X = in.nextDouble();
            double time = 0;
            double speed = 2;
            while (X / speed > C / speed + X / (speed + F)) {
                time += C / speed;
                speed += F;
            }
            time += X / speed;
            out.println(time);
        }
        out.close();
        in.close();
        System.out.println("finish!");
    }
}

------------------------------------------------------------
OCL File:
---------
 class B {
  static    attribute SAMPLE : Boolean := false;
  static    attribute PROBLEM : String := "B";
  static    attribute INPUT : String := "large";
  static    attribute ID : String := "0";
  static    attribute PATH : String := "F:\\software installation\\codejam-commandline-1.2-beta1\\source\\";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := if SAMPLE then OclFile.newOclFile_Read(OclFile["System.in"]) else OclFile.newOclFile_Read(OclFile(PATH + PROBLEM + "-" + INPUT + "-" + ID + ".in")) endif ;
     var out : OclFile ; out := if SAMPLE then out else OclFile.newOclFile_Write(PATH + PROBLEM + "-" + INPUT + "-" + ID + ".out") endif ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= test do ( (     skip ; 
     var C : double ; C := in.getCurrent()->toReal() ;
    var F : double ; F := in.getCurrent()->toReal() ;
    var X : double ; X := in.getCurrent()->toReal() ;
    var time : double ; time := 0 ;
    var speed : double ; speed := 2 ;
    while (X / speed > C / speed + X / (speed + F)) do (     time := time+(C / speed) ; 
     speed := speed+(F) ) ; 
    time := time+(X / speed) ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
    OclFile["System.out"].println("finish!") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int getMaxLength(int arr[],int n){
    int start=0 ;
    int preCnt=0 ;
    while(start<n && arr[start]==1){
      preCnt++;
      start++;
    }
    int end=n-1 ;
    int suffCnt=0 ;
    while(end>=0 && arr[end]==1){
      suffCnt++;
      end--;
    }
    if(start>end)return n ;
    int midCnt=0 ;
    int result=0 ;
    for(int i=start ; i<=end ; i++){
      if(arr[i]==1){
        midCnt++;
        result=Math.max(result,midCnt);
      }
      else {
        midCnt=0 ;
      }
    }
    return Math.max(result,preCnt+suffCnt);
  }
  public static void main(String[] args){
    int arr[]=new int[] {
      1,1,0,0,1,0,1,0,1,1,1,1 };
      int n=arr.length ;
      System.out.println(getMaxLength(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation getMaxLength( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var start : int ; start := 0 ;
     var preCnt : int ; preCnt := 0 ;
    while (start < n & arr[start+1] = 1) do (     preCnt := preCnt + 1 ; 
     start := start + 1 ) ; 
    var end : int ; end := n - 1 ;
    var suffCnt : int ; suffCnt := 0 ;
    while (end >= 0 & arr[end+1] = 1) do (     suffCnt := suffCnt + 1 ; 
     end := end - 1 ) ; 
    if (start > end) then     return n else skip ; 
    var midCnt : int ; midCnt := 0 ;
    var result : int ; result := 0 ;
        var i : int ; i := start ; while i <= end do ( (     if (arr[i+1] = 1) then (     midCnt := midCnt + 1 ; 
     result := Set{result, midCnt}->max() ) else (     midCnt := 0 ) )  ;     i := i + 1 ) ; 
    return Set{result, preCnt + suffCnt}->max() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,0,0,1,0,1,0,1,1,1,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(getMaxLength(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import gcj.GCJ ;
import java.util.Scanner ;
public class FallingDiamonds {
  public static void main(String[] args){
    Scanner s=GCJ.createScanner('B',true);
    int T=s.nextInt();
    for(int i=1 ; i<=T ; i++){
      int n=s.nextInt();
      int x=s.nextInt();
      int y=s.nextInt();
      double p=0 ;
      int nn=1 ;
      int total=1 ;
      while(total+nn+1+nn+2<=n){
        total+=nn+1+nn+2 ;
        nn+=2 ;
      }
      int xy=Math.abs(x)+y ;
      if(xy<nn){
        p=1 ;
      }
      else if(xy>=nn+2){
        p=0 ;
      }
      else {
        int left=n-total ;
        if(left<y+1){
          p=0 ;
        }
        else {
          nn++;
          double[][] cand=new double[nn+1][nn+1];
          cand[0][0]=1 ;
          for(int w=1 ; w<=left ; w++){
            for(int u=0 ; u<w && u<=nn ; u++){
              int v=w-u-1 ;
              if(v>nn){
                continue ;
              }
              if(u==nn){
                cand[u][v+1]+=cand[u][v];
              }
              else if(v==nn){
                cand[u+1][v]+=cand[u][v];
              }
              else {
                cand[u+1][v]+=cand[u][v]/2 ;
                cand[u][v+1]+=cand[u][v]/2 ;
              }
            }
          }
          p=0 ;
          for(int u=y+1 ; u<=left && u<=nn ; u++){
            int v=left-u ;
            if(v>nn){
              continue ;
            }
            p+=cand[u][v];
          }
        }
      }
      GCJ.out(i,Double.toString(p));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class FallingDiamonds {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := GCJ.createScanner('B', true) ;
     var T : int ; T := s.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= T do ( (     var n : int ; n := s.getCurrent()->toInteger() ;
     var x : int ; x := s.getCurrent()->toInteger() ;
    var y : int ; y := s.getCurrent()->toInteger() ;
    var p : double ; p := 0 ;
    var nn : int ; nn := 1 ;
    var total : int ; total := 1 ;
    while (total + nn + 1 + nn + 2 <= n) do (     total := total+(nn + 1 + nn + 2) ; 
     nn := nn+(2) ) ; 
    var xy : int ; xy := if x < 0 then -(x) else x endif + y ;
    if (xy < nn) then (     p := 1 ) else     if (xy >= nn + 2) then (     p := 0 ) else (     var left : int ; left := n - total ;
     if (left < y + 1) then (     p := 0 ) else (     nn := nn + 1 ; 
     var cand : Sequence(Sequence(double)) ; cand := Integer.subrange(1,nn + 1)->collect(Integer.subrange(1,nn + 1)->collect(0.0)) ;
    cand[0+1][0+1] := 1 ; 
        var w : int ; w := 1 ; while w <= left do ( (         var u : int ; u := 0 ; while u < w & u <= nn do ( (     var v : int ; v := w - u - 1 ;
     if (v > nn) then (     continue ) else skip ; 
     if (u = nn) then (     cand[u+1][v + 1+1] := cand[u+1][v + 1+1]+(cand[u+1][v+1]) ) else     if (v = nn) then (     cand[u + 1+1][v+1] := cand[u + 1+1][v+1]+(cand[u+1][v+1]) ) else (     cand[u + 1+1][v+1] := cand[u + 1+1][v+1]+(cand[u+1][v+1] / 2) ; 
     cand[u+1][v + 1+1] := cand[u+1][v + 1+1]+(cand[u+1][v+1] / 2) ) ;  )  ;     u := u + 1 ) )  ;     w := w + 1 ) ; 
    p := 0 ; 
        var u : int ; u := y + 1 ; while u <= left & u <= nn do ( (     var v : int ; v := left - u ;
     if (v > nn) then (     continue ) else skip ; 
     p := p+(cand[u+1][v+1]) )  ;     u := u + 1 ) ; 
 ) ) ;  ;  
    GCJ.out(i, ((p) + "")) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int d=s.nextInt();
    int n=s.nextInt();
    int[] temp=new int[d];
    int[] a=new int[n];
    int[] b=new int[n];
    int[] c=new int[n];
    for(int i=0 ; i<d ; i++){
      temp[i]=s.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      a[i]=s.nextInt();
      b[i]=s.nextInt();
      c[i]=s.nextInt();
    }
    int[][] dp=new int[d][n];
    for(int i=0 ; i<d ; i++){
      for(int j=0 ; j<n ; j++){
        dp[i][j]=-1 ;
      }
    }
    for(int i=0 ; i<n ; i++){
      if(a[i]<=temp[0] && b[i]>=temp[0])dp[0][i]=0 ;
    }
    for(int i=1 ; i<d ; i++){
      for(int j=0 ; j<n ; j++){
        if(a[j]<=temp[i] && b[j]>=temp[i]){
          for(int k=0 ; k<n ; k++){
            if(dp[i-1][k]<0)continue ;
            dp[i][j]=Math.max(dp[i][j],dp[i-1][k]+Math.abs(c[j]-c[k]));
          }
        }
      }
    }
    int ans=0 ;
    for(int i=0 ; i<n ; ++i){
      ans=Math.max(ans,dp[d-1][i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : int ; d := s.getCurrent()->toInteger() ;
    var n : int ; n := s.getCurrent()->toInteger() ;
    var temp : Sequence(int) ; temp := Integer.subrange(1,d)->collect(0) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < d do ( (     temp[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := s.getCurrent()->toInteger() ; 
     b[i+1] := s.getCurrent()->toInteger() ; 
     c[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,d)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < d do ( (         var j : int ; j := 0 ; while j < n do ( (     dp[i+1][j+1] := -1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] <= temp[0+1] & b[i+1] >= temp[0+1]) then     dp[0+1][i+1] := 0 ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < d do ( (         var j : int ; j := 0 ; while j < n do ( (     if (a[j+1] <= temp[i+1] & b[j+1] >= temp[i+1]) then (         var k : int ; k := 0 ; while k < n do ( (     if (dp[i - 1+1][k+1] < 0) then     continue else skip ; 
     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i - 1+1][k+1] + if c[j+1] - c[k+1] < 0 then -(c[j+1] - c[k+1]) else c[j+1] - c[k+1] endif}->max() )  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ans := Set{ans, dp[d - 1+1][i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  Scanner sc=new Scanner(in);
  void run(){
    int d=sc.nextInt(),n=sc.nextInt();
    int[] t=new int[d];
    int[] a=new int[n];
    int[] b=new int[n];
    int[] c=new int[n];
    for(int i=0 ; i<d ; i++)t[i]=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
      c[i]=sc.nextInt();
    }
    int INF=-1 ;
    int[][] dp=new int[d][n];
    for(int i=0 ; i<n ; i++){
      if(!(a[i]<=t[0] && t[0]<=b[i]))dp[0][i]=INF ;
    }
    for(int i=1 ; i<d ; i++){
      for(int j=0 ; j<n ; j++){
        if(!(a[j]<=t[i] && t[i]<=b[j]))dp[i][j]=INF ;
        else {
          for(int k=0 ; k<n ; k++){
            if(dp[i-1][k]!=INF){
              dp[i][j]=Math.max(dp[i][j],dp[i-1][k]+Math.abs(c[j]-c[k]));
            }
          }
        }
      }
    }
    int res=-1 ;
    for(int i=0 ; i<n ; i++){
      res=Math.max(res,dp[d-1][i]);
    }
    out.println(res);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   operation run() : void
  pre: true
  post: true
  activity: (     var d : int ; d := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
     var t : Sequence(int) ; t := Integer.subrange(1,d)->collect(0) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < d do (     t[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() ; 
     c[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var INF : int ; INF := -1 ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,d)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     if (not((a[i+1] <= t[0+1] & t[0+1] <= b[i+1]))) then     dp[0+1][i+1] := INF ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < d do ( (         var j : int ; j := 0 ; while j < n do ( (     if (not((a[j+1] <= t[i+1] & t[i+1] <= b[j+1]))) then     dp[i+1][j+1] := INF ; else (         var k : int ; k := 0 ; while k < n do ( (     if (dp[i - 1+1][k+1] /= INF) then (     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i - 1+1][k+1] + if c[j+1] - c[k+1] < 0 then -(c[j+1] - c[k+1]) else c[j+1] - c[k+1] endif}->max() ) else skip )  ;     k := k + 1 ) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : int ; res := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     res := Set{res, dp[d - 1+1][i+1]}->max() )  ;     i := i + 1 ) ; 
    out.println(res) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class sub {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int num=in.nextInt();
    while(num-->0){
      int a=in.nextInt();
      int b=in.nextInt();
      int res=0 ;
      while(a!=0 && b!=0){
        if(a>=b){
          res+=a/b ;
          a %=b ;
        }
        else {
          res+=b/a ;
          b %=a ;
        }
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class sub {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := in.getCurrent()->toInteger() ;
         while (num > 0) do (        num := num - 1 ;     skip ; (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
    while (a /= 0 & b /= 0) do (     if (a >= b) then (     res := res+(a / b) ; 
     a := a mod b ) else (     res := res+(b / a) ; 
     b := b mod a ) ) ; 
    OclFile["System.out"].println(res) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int day,numberOfTypes,bestShowy=0 ;
    day=sc.nextInt();
    numberOfTypes=sc.nextInt();
    int temperature[]=new int[day];
    int clothesInfo[][]=new int[numberOfTypes][3];
    for(int i=0 ; i<day ; i++){
      temperature[i]=sc.nextInt();
    }
    for(int i=0 ; i<numberOfTypes ; i++){
      for(int j=0 ; j<3 ; j++){
        clothesInfo[i][j]=sc.nextInt();
      }
    }
    int showy[][]=new int[day][numberOfTypes];
    for(int i=0 ; i<day ; i++){
      for(int j=0 ; j<numberOfTypes ; j++){
        if(clothesInfo[j][0]<=temperature[i] && clothesInfo[j][1]>=temperature[i]){
          showy[i][j]=0 ;
        }
        else {
          showy[i][j]=-1 ;
        }
      }
    }
    for(int i=1 ; i<day ; i++){
      for(int j=0 ; j<numberOfTypes ; j++){
        if(showy[i][j]==0){
          for(int k=0 ; k<numberOfTypes ; k++){
            if(showy[i-1][k]!=-1){
              showy[i][j]=Math.max(showy[i][j],showy[i-1][k]+Math.abs(clothesInfo[k][2]-clothesInfo[j][2]));
            }
          }
        }
      }
    }
    for(int p=0 ; p<numberOfTypes ; p++){
      bestShowy=Math.max(bestShowy,showy[day-1][p]);
    }
    System.out.println(bestShowy);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var day : int ;
    var numberOfTypes : int ;
    var bestShowy : int ; bestShowy := 0 ;
    day := sc.getCurrent()->toInteger() ; 
    numberOfTypes := sc.getCurrent()->toInteger() ; 
    var temperature : Sequence(int) ; temperature := Integer.subrange(1,day)->collect(0) ;
    var clothesInfo : Sequence(Sequence(int)) ; clothesInfo := Integer.subrange(1,numberOfTypes)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < day do ( (     temperature[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < numberOfTypes do ( (         var j : int ; j := 0 ; while j < 3 do ( (     clothesInfo[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var showy : Sequence(Sequence(int)) ; showy := Integer.subrange(1,day)->collect(Integer.subrange(1,numberOfTypes)->collect(0)) ;
        var i : int ; i := 0 ; while i < day do ( (         var j : int ; j := 0 ; while j < numberOfTypes do ( (     if (clothesInfo[j+1][0+1] <= temperature[i+1] & clothesInfo[j+1][1+1] >= temperature[i+1]) then (     showy[i+1][j+1] := 0 ) else (     showy[i+1][j+1] := -1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < day do ( (         var j : int ; j := 0 ; while j < numberOfTypes do ( (     if (showy[i+1][j+1] = 0) then (         var k : int ; k := 0 ; while k < numberOfTypes do ( (     if (showy[i - 1+1][k+1] /= -1) then (     showy[i+1][j+1] := Set{showy[i+1][j+1], showy[i - 1+1][k+1] + if clothesInfo[k+1][2+1] - clothesInfo[j+1][2+1] < 0 then -(clothesInfo[k+1][2+1] - clothesInfo[j+1][2+1]) else clothesInfo[k+1][2+1] - clothesInfo[j+1][2+1] endif}->max() ) else skip )  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var p : int ; p := 0 ; while p < numberOfTypes do ( (     bestShowy := Set{bestShowy, showy[day - 1+1][p+1]}->max() )  ;     p := p + 1 ) ; 
    OclFile["System.out"].println(bestShowy) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    n=scanner.nextInt();
    m=scanner.nextInt();
    t=new int[n];
    for(int i=0 ; i<n ; i++)t[i]=scanner.nextInt();
    d=new int[3][m];
    for(int i=0 ; i<m ; i++)for(int j=0 ; j<3 ; j++){
      int a=scanner.nextInt();
      d[j][i]=a ;
    }
    dp=new int[n][m];
    for(int[] dp1 : dp)Arrays.fill(dp1,-1);
    int ans=0 ;
    for(int i=0 ; i<m ; i++){
      if(t[0]<d[0][i] || d[1][i]<t[0])continue ;
      ans=Math.max(ans,slove(1,i));
    }
    System.out.println(ans);
  }
  private int slove(int day,int x){
    if(day==n)return 0 ;
    if(dp[day][x]!=-1)return dp[day][x];
    int ret=0 ;
    for(int i=0 ; i<m ; i++){
      if(t[day]<d[0][i] || d[1][i]<t[day])continue ;
      ret=Math.max(ret,slove(day+1,i)+Math.abs(d[2][x]-d[2][i]));
    }
    return dp[day][x]=ret ;
  }
  int n,m ;
  int[] t ;
  int[][] d,dp ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := scanner.getCurrent()->toInteger() ; 
    m := scanner.getCurrent()->toInteger() ; 
    t := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     t[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    d := Integer.subrange(1,3)->collect(Integer.subrange(1,m)->collect(0)) ; 
        var i : int ; i := 0 ; while i < m do (         var j : int ; j := 0 ; while j < 3 do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     d[j+1][i+1] := a )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    dp := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ; 
    for (dp1 : dp) do (     dp1 := dp1->collect(-1) ;  ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     if (t[0+1] < d[0+1][i+1] or d[1+1][i+1] < t[0+1]) then     continue else skip ; 
     ans := Set{ans, slove(1, i)}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation slove( day : int, x : int) : int
  pre: true
  post: true
  activity: (     if (day = n) then     return 0 else skip ; 
     if (dp[day+1][x+1] /= -1) then     return dp[day+1][x+1] else skip ; 
    var ret : int ; ret := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     if (t[day+1] < d[0+1][i+1] or d[1+1][i+1] < t[day+1]) then     continue else skip ; 
     ret := Set{ret, slove(day + 1, i) + if d[2+1][x+1] - d[2+1][i+1] < 0 then -(d[2+1][x+1] - d[2+1][i+1]) else d[2+1][x+1] - d[2+1][i+1] endif}->max() )  ;     i := i + 1 ) ; 
    return dp[day+1][x+1] 
 );
   attribute n : int;
   attribute t : Sequence(int);
   attribute d : Sequence(Sequence(int));
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package exoB ;
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.logging.Level ;
import java.util.logging.Logger ;
public class ExoB {
  public static void main(String[] args){
    String base="/home/jean/gcj2014/q/ExoB/" ;
    String input=base+"b1.in" ;
    String output=base+"b1.out" ;
    try {
      Scanner sc=new Scanner(new FileReader(input));
      PrintWriter pw=new PrintWriter(output);
      int n=sc.nextInt();
      sc.nextLine();
      for(int c=0 ; c<n ; c++){
        System.out.println("Test case "+(c+1)+"...");
        pw.print("Case #"+(c+1)+": ");
        test(sc,pw);
        pw.println();
      }
      pw.println();
      pw.flush();
      pw.close();
      sc.close();
    }
    catch(FileNotFoundException ex){
      Logger.getLogger(ExoB.class.getName()).log(Level.SEVERE,null,ex);
    }
  }
  private static void test(Scanner sc,PrintWriter pw){
    double C=sc.nextDouble();
    double F=sc.nextDouble();
    double X=sc.nextDouble();
    double r=2.0 ;
    double t=0.0 ;
    while(X/r>C/r+X/(r+F)){
      t=t+C/r ;
      r+=F ;
    }
    t=t+X/r ;
    pw.print(t);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ExoB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var base : String ; base := "/home/jean/gcj2014/q/ExoB/" ;
     var input : String ; input := base + "b1.in" ;
     var output : String ; output := base + "b1.out" ;
     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(input))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile(output)) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
        var c : int ; c := 0 ; while c < n do ( (     OclFile["System.out"].println("Test case " + (c + 1) + "...") ; 
     skip ; 
     execute test(sc, pw) ; 
     skip )  ;     c := c + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 )   catch (ex : FileNotFoundException) do (     Logger.getLogger(OclType["ExoB"].getName()).log(Level.SEVERE, null, ex) )
 );
  static   operation test( sc : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var C : double ; C := sc.getCurrent()->toReal() ;
     var F : double ; F := sc.getCurrent()->toReal() ;
    var X : double ; X := sc.getCurrent()->toReal() ;
    var r : double ; r := 2.0 ;
    var t : double ; t := 0.0 ;
    while (X / r > C / r + X / (r + F)) do (     t := t + C / r ; 
     r := r+(F) ) ; 
    t := t + X / r ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long mod=(long)(1e9+7);
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int i1=0,i2=0 ;
    String s=in.next();
    boolean flag=true ;
    char ch[]=s.toCharArray();
    for(int i=0 ; i<s.length()-1 ; i++){
      if(ch[i]>ch[i+1]){
        i1=i+1 ;
        i2=i+2 ;
        flag=false ;
        break ;
      }
    }
    if(flag){
      pw.println("NO");
    }
    else {
      pw.println("YES");
      pw.println(i1+" "+i2);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := (1e9 + 7)->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var i1 : int ; i1 := 0 ;
    var i2 : int ; i2 := 0 ;
    var s : String ; s := in.getCurrent() ;
    var flag : boolean ; flag := true ;
    var ch : Sequence(String) ; ch := s->characters() ;
        var i : int ; i := 0 ; while i < s->size() - 1 do ( (     if (ch[i+1] > ch[i + 1+1]) then (     i1 := i + 1 ; 
     i2 := i + 2 ; 
     flag := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then (     skip ) else (     skip ; 
     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf1155a {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    String s=scan.next();
    scan.close();
    for(int i=0 ; i<t-1 ; i++){
      if(s.charAt(i)>s.charAt(i+1)){
        System.out.println("YES");
        System.out.println((i+1)+" "+(i+2));
        return ;
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1155a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
    var s : String ; s := scan.getCurrent() ;
    skip ; 
        var i : int ; i := 0 ; while i < t - 1 do ( (     if (s->at(i+1) > s->at(i + 1+1)) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println((i + 1) + " " + (i + 2)) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class hw14 {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    {
    }
    {
    }
    {
    }
    {
      int n=scan.nextInt();
      char[] in=scan.next().toCharArray();
      char[] in1=Arrays.copyOf(in,n);
      Arrays.sort(in1);
      if(Arrays.equals(in1,in)){
        System.out.println("NO");
      }
      else {
        for(int i=1 ; i<n ; i++){
          if(in[i]<in[i-1]){
            System.out.println("YES");
            System.out.print(i+" "+(i+1));
            break ;
          }
        }
      }
    }
  }
  public static int minDif(int[] a){
    Arrays.sort(a);
    int dif=100 ;
    for(int i=1 ; i<a.length ; i++){
      int i1=a[i]-a[i-1];
      if(i1<dif && i1!=0){
        dif=i1 ;
      }
    }
    for(int i=0 ; i<a.length ; i++){
      while(a[i] % dif!=0){
        dif=a[i] % dif ;
      }
    }
    return dif ;
  }
  public static boolean isPal(String str){
    StringBuilder rev=new StringBuilder(str);
    rev.reverse();
    return str.equals(rev.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class hw14 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 skip 
skip 
skip 
(     var n : int ; n := scan.getCurrent()->toInteger() ;
     var in : Sequence(String) ; in := scan.getCurrent()->characters() ;
    var in1 : Sequence(String) ; in1 := in.subrange(1,n) ;
    in1 := in1->sort() ; 
    if (in1 = in) then (     OclFile["System.out"].println("NO") ) else (         var i : int ; i := 1 ; while i < n do ( (     if (in[i+1] < in[i - 1+1]) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].print(i + " " + (i + 1)) ; 
     break ) else skip )  ;     i := i + 1 ) ) ;  
 ) 
 );
  static   operation minDif( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var dif : int ; dif := 100 ;
        var i : int ; i := 1 ; while i < a->size() do ( (     var i1 : int ; i1 := a[i+1] - a[i - 1+1] ;
     if (i1 < dif & i1 /= 0) then (     dif := i1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     while (a[i+1] mod dif /= 0) do (     dif := a[i+1] mod dif ) )  ;     i := i + 1 ) ; 
    return dif 
 );
  static   operation isPal( str : String) : boolean
  pre: true
  post: true
  activity: (     var rev : String ; rev := StringLib.newString(str) ;
     rev := rev->reverse() ; 
     return str = rev+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float sqroot(float s){
    int pSq=0 ;
    int N=0 ;
    for(int i=(int)(s); i>0 ; i--){
      for(int j=1 ; j<i ; j++){
        if(j*j==i){
          pSq=i ;
          N=j ;
          break ;
        }
      }
      if(pSq>0)break ;
    }
    float d=s-pSq ;
    float P=d/(2.0f*N);
    float A=N+P ;
    float sqrt_of_s=A-((P*P)/(2.0f*A));
    return sqrt_of_s ;
  }
  public static void main(String[] args){
    float num=9.2345f ;
    float sqroot_of_num=sqroot(num);
    System.out.print("Square root of "+num+"="+Math.round(sqroot_of_num*100000.0)/100000.0);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sqroot( s : double) : double
  pre: true
  post: true
  activity: (     var pSq : int ; pSq := 0 ;
     var N : int ; N := 0 ;
        var i : int ; i := (s)->oclAsType(int) ; while i > 0 do ( (         var j : int ; j := 1 ; while j < i do ( (     if (j * j = i) then (     pSq := i ; 
     N := j ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (pSq > 0) then     break else skip )  ;     i := i - 1 ) ; 
    var d : double ; d := s - pSq ;
    var P : double ; P := d / (2.0f * N) ;
    var A : double ; A := N + P ;
    var sqrt_of_s : double ; sqrt_of_s := A - ((P * P) / (2.0f * A)) ;
    return sqrt_of_s 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : double ; num := 9.2345f ;
     var sqroot_of_num : double ; sqroot_of_num := sqroot(num) ;
     OclFile["System.out"].print("Square root of " + num + "=" + (sqroot_of_num * 100000.0)->round() / 100000.0) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int n=in.nextInt();
      int[] a=new int[n];
      int[] b=new int[n];
      int s=-1 ;
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
        b[i]=0 ;
      }
      int tem=1 ;
      int q=0 ;
      while(q!=n){
        s++;
        if(tem==1){
          for(int i=0 ; i<n ; i++){
            if(a[i]<=q && b[i]==0){
              b[i]=1 ;
              q++;
            }
          }
          tem=0 ;
        }
        else {
          for(int i=n-1 ; i>=0 ; i--){
            if(a[i]<=q && b[i]==0){
              b[i]=1 ;
              q++;
            }
          }
          tem=1 ;
        }
      }
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var s : int ; s := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     b[i+1] := 0 )  ;     i := i + 1 ) ; 
    var tem : int ; tem := 1 ;
    var q : int ; q := 0 ;
    while (q /= n) do (     s := s + 1 ; 
     if (tem = 1) then (         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] <= q & b[i+1] = 0) then (     b[i+1] := 1 ; 
     q := q + 1 ) else skip )  ;     i := i + 1 ) ; 
     tem := 0 ) else (         var i : int ; i := n - 1 ; while i >= 0 do ( (     if (a[i+1] <= q & b[i+1] = 0) then (     b[i+1] := 1 ; 
     q := q + 1 ) else skip )  ;     i := i - 1 ) ; 
     tem := 1 ) ) ; 
    OclFile["System.out"].println(s) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int n=in.nextInt();
      int[] a=new int[n];
      int[] b=new int[n];
      int s=-1 ;
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
        b[i]=0 ;
      }
      int tem=1 ;
      int q=0 ;
      while(q!=n){
        s++;
        if(tem==1){
          for(int i=0 ; i<n ; i++){
            if(a[i]<=q && b[i]==0){
              b[i]=1 ;
              q++;
            }
          }
          tem=0 ;
        }
        else {
          for(int i=n-1 ; i>=0 ; i--){
            if(a[i]<=q && b[i]==0){
              b[i]=1 ;
              q++;
            }
          }
          tem=1 ;
        }
      }
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var s : int ; s := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     b[i+1] := 0 )  ;     i := i + 1 ) ; 
    var tem : int ; tem := 1 ;
    var q : int ; q := 0 ;
    while (q /= n) do (     s := s + 1 ; 
     if (tem = 1) then (         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] <= q & b[i+1] = 0) then (     b[i+1] := 1 ; 
     q := q + 1 ) else skip )  ;     i := i + 1 ) ; 
     tem := 0 ) else (         var i : int ; i := n - 1 ; while i >= 0 do ( (     if (a[i+1] <= q & b[i+1] = 0) then (     b[i+1] := 1 ; 
     q := q + 1 ) else skip )  ;     i := i - 1 ) ; 
     tem := 1 ) ) ; 
    OclFile["System.out"].println(s) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static double INF=100.0 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int r=sc.nextInt();
      int n=sc.nextInt();
      if(r==0){
        break ;
      }
      int[] field=new int[40];
      for(int i=0 ; i<n ; i++){
        int xl=sc.nextInt();
        int xr=sc.nextInt();
        int h=sc.nextInt();
        for(int j=xl+20 ; j<xr+20 ; j++){
          field[j]=Math.max(field[j],h);
        }
      }
      double minTime=INF ;
      for(int i=0 ; i<field.length ; i++){
        minTime=Math.min(minTime,crossTime(i-20,field[i],r));
        minTime=Math.min(minTime,crossTime(i+1-20,field[i],r));
      }
      System.out.println(minTime);
    }
  }
  public static double crossTime(int x,int y,int r){
    int d=(int)Math.pow(-2*(y+r),2)-4*(x*x+y*y+2*y*r);
    if(d<=0){
      return INF ;
    }
    else {
      double ans=(2*(y+r)-Math.sqrt(d))/2 ;
      return ans ;
    }
  }
  public static void printHeight(int[] field){
    for(int i=0 ; i<field.length ; i++){
      System.out.println((i-20)+"-"+((i-20)+1)+": "+field[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute INF : double := 100.0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var r : int ; r := sc.getCurrent()->toInteger() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    if (r = 0) then (     break ) else skip ; 
    var field : Sequence(int) ; field := Integer.subrange(1,40)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var xl : int ; xl := sc.getCurrent()->toInteger() ;
     var xr : int ; xr := sc.getCurrent()->toInteger() ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
         var j : int ; j := xl + 20 ; while j < xr + 20 do ( (     field[j+1] := Set{field[j+1], h}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var minTime : double ; minTime := INF ;
        var i : int ; i := 0 ; while i < field->size() do ( (     minTime := Set{minTime, crossTime(i - 20, field[i+1], r)}->min() ; 
     minTime := Set{minTime, crossTime(i + 1 - 20, field[i+1], r)}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(minTime) ; 
 ) );
  static   operation crossTime( x : int, y : int, r : int) : double
  pre: true
  post: true
  activity: (     var d : int ; d := -2 * (y + r)->pow(2)->oclAsType(int) - 4 * (x * x + y * y + 2 * y * r) ;
     if (d <= 0) then (     return INF ) else (     var ans : double ; ans := (2 * (y + r) - (d)->sqrt()) / 2 ;
     return ans ) );
  static   operation printHeight( field : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < field->size() do ( (     OclFile["System.out"].println((i - 20) + "-" + ((i - 20) + 1) + ": " + field[i+1]) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    long a=0,b=0,temp=0,ans=0 ;
    for(int i=0 ; i<n ; i++){
      ans=0 ;
      temp=0 ;
      a=scanner.nextLong();
      b=scanner.nextLong();
      while(a!=0 && b!=0){
        if(a>=b){
          temp=a % b ;
          if(temp==0){
            ans+=a/b ;
            break ;
          }
          else {
            ans+=a/b ;
            a=temp ;
          }
        }
        else {
          temp=b % a ;
          if(temp==0){
            ans+=b/a ;
            break ;
          }
          else {
            ans+=b/a ;
            b=temp ;
          }
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : long ; a := 0 ;
    var b : long ; b := 0 ;
    var temp : long ; temp := 0 ;
    var ans : long ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     ans := 0 ; 
     temp := 0 ; 
    a := scanner.getCurrent()->toLong() ; 
    b := scanner.getCurrent()->toLong() ; 
    while (a /= 0 & b /= 0) do (     if (a >= b) then (     temp := a mod b ; 
     if (temp = 0) then (     ans := ans+(a / b) ; 
     break ) else (     ans := ans+(a / b) ; 
     a := temp ) ) else (     temp := b mod a ; 
     if (temp = 0) then (     ans := ans+(b / a) ; 
     break ) else (     ans := ans+(b / a) ; 
     b := temp ) ) ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int r,n,i,j,xl,xr,h ;
    int[] maxh ;
    double t,mint ;
    for(; ; ){
      r=sc.nextInt();
      n=sc.nextInt();
      if(r==0 && n==0)break ;
      maxh=new int[40];
      for(i=0 ; i<40 ; i++)maxh[i]=0 ;
      for(i=0 ; i<n ; i++){
        xl=sc.nextInt();
        xr=sc.nextInt();
        h=sc.nextInt();
        for(j=xl ; j<xr ; j++){
          if(maxh[j+20]<h)maxh[j+20]=h ;
        }
      }
      mint=21 ;
      for(i=0 ; i<r ; i++){
        t=(double)maxh[19+i]+(double)r-Math.sqrt(r*r-i*i);
        if(mint>t)mint=t ;
        t=(double)maxh[20+i]+(double)r-Math.sqrt(r*r-i*i);
        if(mint>t)mint=t ;
        t=(double)maxh[19-i]+(double)r-Math.sqrt(r*r-i*i);
        if(mint>t)mint=t ;
        t=(double)maxh[20-i]+(double)r-Math.sqrt(r*r-i*i);
        if(mint>t)mint=t ;
      }
      out.println(mint);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var r : int ;
    var n : int ;
    var i : int ;
    var j : int ;
    var xl : int ;
    var xr : int ;
    var h : int ;
    var maxh : Sequence(int) ;
    var t : double ;
    var mint : double ;
      while true do ( (     r := sc.nextInt() ; 
     n := sc.nextInt() ; 
    if (r = 0 & n = 0) then     break else skip ; 
    maxh := Integer.subrange(1,40)->collect(0) ; 
        i := 0 ; while i < 40 do (     maxh[i+1] := 0 ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     xl := sc.nextInt() ; 
     xr := sc.nextInt() ; 
     h := sc.nextInt() ; 
         j := xl ; while j < xr do ( (     if (maxh[j + 20+1] < h) then     maxh[j + 20+1] := h ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    mint := 21 ; 
        i := 0 ; while i < r do ( (     t := maxh[19 + i+1]->oclAsType(double) + r->oclAsType(double) - (r * r - i * i)->sqrt() ; 
     if (mint > t) then     mint := t ; else skip ; 
    t := maxh[20 + i+1]->oclAsType(double) + r->oclAsType(double) - (r * r - i * i)->sqrt() ; 
    if (mint > t) then     mint := t ; else skip ; 
    t := maxh[19 - i+1]->oclAsType(double) + r->oclAsType(double) - (r * r - i * i)->sqrt() ; 
    if (mint > t) then     mint := t ; else skip ; 
    t := maxh[20 - i+1]->oclAsType(double) + r->oclAsType(double) - (r * r - i * i)->sqrt() ; 
    if (mint > t) then     mint := t ; else skip ; 
 )  ;     i := i + 1 ) ; 
    out.println(mint) ; 
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.ArrayIndexOutOfBoundsException ;
import java.math.*;
class Main {
  static Scanner sc=new Scanner(new InputStreamReader(System.in));
  public static void main(String[] args)throws Exception {
    try {
      while(true){
        int r=sc.nextInt();
        int n=sc.nextInt();
        if(r+n==0)break ;
        System.out.printf("%.4f\n",solve(r,n));
      }
    }
    catch(Exception e){
      System.out.println(e);
    }
  }
  static double solve(int r,int n){
    int[] dp=new int[40];
    for(int i=0 ; i<n ; i++){
      int xl=sc.nextInt();
      int xr=sc.nextInt();
      int h=sc.nextInt();
      for(int j=xl ; j<xr ; j++){
        int index=j+20 ;
        dp[index]=Math.max(dp[index],h);
      }
    }
    for(double ans=-r ; ans<20.0 ; ans+=0.0005){
      for(int i=1-r ; i<r ; i++){
        int index=i+20 ;
        int h=Math.min(dp[index-1],dp[index]);
        double dist=sqdist(0.0,ans,(double)i,(double)h);
        if(dist<=(double)(r*r)){
          return ans+(double)r ;
        }
      }
    }
    return 0.0 ;
  }
  public static double sq(double d){
    return d*d ;
  }
  public static double sqdist(double x1,double y1,double x2,double y2){
    return sq(x1-x2)+sq(y1-y2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     while (true) do (     var r : int ; r := sc.getCurrent()->toInteger() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (r + n = 0) then     break else skip ; 
     OclFile["System.out"].printf("%.4f\n", solve(r, n)) ) )   catch (e : ProgramException) do (     OclFile["System.out"].println(e) )
 );
  static   operation solve( r : int, n : int) : double
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,40)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     var xl : int ; xl := sc.getCurrent()->toInteger() ;
     var xr : int ; xr := sc.getCurrent()->toInteger() ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
         var j : int ; j := xl ; while j < xr do ( (     var index : int ; index := j + 20 ;
     dp[index+1] := Set{dp[index+1], h}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
         var ans : double ; ans := -r ; while ans < 20.0 do ( (         var i : int ; i := 1 - r ; while i < r do ( (     var index : int ; index := i + 20 ;
     var h : int ; h := Set{dp[index - 1+1], dp[index+1]}->min() ;
     var dist : double ; dist := sqdist(0.0, ans, i->oclAsType(double), h->oclAsType(double)) ;
     if (dist <= (r * r)->oclAsType(double)) then (     return ans + r->oclAsType(double) ) else skip )  ;     i := i + 1 ) )  ;     ans := ans+(0.0005) ) ; 
     return 0.0 );
  static   operation sq( d : double) : double
  pre: true
  post: true
  activity: (     return d * d );
  static   operation sqdist( x1 : double, y1 : double, x2 : double, y2 : double) : double
  pre: true
  post: true
  activity: (     return sq(x1 - x2) + sq(y1 - y2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findElement(int[] arr,int[][] ranges,int rotations,int index){
    for(int i=rotations-1 ; i>=0 ; i--){
      int left=ranges[i][0];
      int right=ranges[i][1];
      if(left<=index && right>=index){
        if(index==left)index=right ;
        else index--;
      }
    }
    return arr[index];
  }
  public static void main(String[] args){
    int[] arr={
      1,2,3,4,5 };
      int rotations=2 ;
      int[][] ranges={
        {
          0,2 },{
            0,3 }
          };
          int index=1 ;
          System.out.println(findElement(arr,ranges,rotations,index));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findElement( arr : Sequence(int), ranges : Sequence(Sequence(int)), rotations : int, index : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := rotations - 1 ; while i >= 0 do ( (     var left : int ; left := ranges[i+1][0+1] ;
     var right : int ; right := ranges[i+1][1+1] ;
     if (left <= index & right >= index) then (     if (index = left) then     index := right ; else     index := index - 1 ; ) else skip )  ;     i := i - 1 ) ; 
     return arr[index+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var rotations : int ; rotations := 2 ;
    var ranges : Sequence(Sequence(int)) ; ranges := Sequence{Sequence{0,2},Sequence{0,3}} ;
    var index : int ; index := 1 ;
    OclFile["System.out"].println(findElement(arr, ranges, rotations, index)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void doIt(){
    new Vampire().main();
  }
  class Vampire {
    final int MAX=Integer.MAX_VALUE ;
    void main(){
      while(true){
        int r=sc.nextInt();
        int n=sc.nextInt();
        if(n==0 && r==0)return ;
        double ymin[]=new double[41];
        double b[]=new double[40];
        Arrays.fill(ymin,MAX);
        for(int i=0 ; i<n ; i++){
          int left=sc.nextInt();
          int right=sc.nextInt();
          int h=sc.nextInt();
          for(int j=left ; j<right ; j++){
            b[j+20]=Math.max(b[j+20],h);
          }
        }
        ymin[0]=b[0];
        ymin[40]=b[39];
        for(int i=-19 ; i<20 ; i++){
          ymin[i+20]=Math.min(b[i+19],b[i+20]);
        }
        for(int i=-20 ; i<=20 ; i++){
          if(i<=-r || i>=r){
            ymin[i+20]=21 ;
          }
          else {
            double x=Math.abs(i);
            double a=Math.acos(x/r);
            double diff=r*Math.sin(a);
            ymin[i+20]-=diff ;
          }
        }
        double min=21.0 ;
        for(int i=0 ; i<41 ; i++){
          min=Math.min(min,r+ymin[i]);
        }
        System.out.println(Math.max(min,0));
      }
    }
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation doIt() : void
  pre: true
  post: true
  activity: (     Vampire.newVampire().main() );
 class Vampire {
   attribute MAX : int := 2147483647;
   operation main() : void
  pre: true
  post: true
  activity: (     while (true) do (     var r : int ; r := sc.getCurrent()->toInteger() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    if (n = 0 & r = 0) then     return else skip ; 
    var ymin : Sequence(double) ; ymin := Integer.subrange(1,41)->collect(0.0) ;
    var b : Sequence(double) ; b := Integer.subrange(1,40)->collect(0.0) ;
    ymin := ymin->collect(MAX) ; 
        var i : int ; i := 0 ; while i < n do ( (     var left : int ; left := sc.getCurrent()->toInteger() ;
     var right : int ; right := sc.getCurrent()->toInteger() ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
         var j : int ; j := left ; while j < right do ( (     b[j + 20+1] := Set{b[j + 20+1], h}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    ymin[0+1] := b[0+1] ; 
    ymin[40+1] := b[39+1] ; 
        var i : int ; i := -19 ; while i < 20 do ( (     ymin[i + 20+1] := Set{b[i + 19+1], b[i + 20+1]}->min() )  ;     i := i + 1 ) ; 
        var i : int ; i := -20 ; while i <= 20 do ( (     if (i <= -r or i >= r) then (     ymin[i + 20+1] := 21 ) else (     var x : double ; x := if i < 0 then -(i) else i endif ;
     var a : double ; a := (x / r)->acos() ;
     var diff : double ; diff := r * (a)->sin() ;
     ymin[i + 20+1] := ymin[i + 20+1]-(diff) ) )  ;     i := i + 1 ) ; 
    var min : double ; min := 21.0 ;
        var i : int ; i := 0 ; while i < 41 do ( (     min := Set{min, r + ymin[i+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{min, 0}->max()) ; 
 ) );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int r=sc.nextInt();
      if(r==0){
        sc.close();
        break ;
      }
      int n=sc.nextInt();
      int[] xl=new int[n];
      int[] xr=new int[n];
      int[] h=new int[n];
      for(int i=0 ; i<n ; i++){
        xl[i]=sc.nextInt();
        xr[i]=sc.nextInt();
        h[i]=sc.nextInt();
      }
      int[] cover=new int[2*r];
      for(int i=0 ; i<n ; i++){
        xl[i]+=r ;
        xr[i]+=r ;
        int ll=Math.max(0,xl[i]);
        int rr=Math.min(r*2,Math.max(0,xr[i]));
        int c=h[i];
        for(int j=ll ; j<rr ; j++){
          cover[j]=Math.max(cover[j],c);
        }
      }
      double res=100000.0 ;
      for(int i=0 ; i<cover.length ; i++){
        int xx=i-r>0 ? i-r+1 : r-i-1 ;
        double t1=cover[i]+r*(1-Math.sin(Math.acos((double)Math.abs(r-i)/r)));
        double t2=cover[i]+r*(1-Math.sin(Math.acos((double)xx/r)));
        res=Math.min(res,Math.min(t1,t2));
      }
      System.out.println(String.format("%.4f",res));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var r : int ; r := sc.getCurrent()->toInteger() ;
     if (r = 0) then (     skip ; 
     break ) else skip ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var xl : Sequence(int) ; xl := Integer.subrange(1,n)->collect(0) ;
    var xr : Sequence(int) ; xr := Integer.subrange(1,n)->collect(0) ;
    var h : Sequence(int) ; h := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     xl[i+1] := sc.getCurrent()->toInteger() ; 
     xr[i+1] := sc.getCurrent()->toInteger() ; 
     h[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cover : Sequence(int) ; cover := Integer.subrange(1,2 * r)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     xl[i+1] := xl[i+1]+(r) ; 
     xr[i+1] := xr[i+1]+(r) ; 
    var ll : int ; ll := Set{0, xl[i+1]}->max() ;
    var rr : int ; rr := Set{r * 2, Set{0, xr[i+1]}->max()}->min() ;
    var c : int ; c := h[i+1] ;
        var j : int ; j := ll ; while j < rr do ( (     cover[j+1] := Set{cover[j+1], c}->max() )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    var res : double ; res := 100000.0 ;
        var i : int ; i := 0 ; while i < cover->size() do ( (     var xx : int ; xx := if i - r > 0 then i - r + 1 else r - i - 1 endif ;
     var t1 : double ; t1 := cover[i+1] + r * (1 - ((if r - i < 0 then -(r - i) else r - i endif->oclAsType(double) / r)->acos())->sin()) ;
     var t2 : double ; t2 := cover[i+1] + r * (1 - ((xx->oclAsType(double) / r)->acos())->sin()) ;
     res := Set{res, Set{t1, t2}->min()}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(StringLib.format("%.4f",Sequence{res})) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=in.nextInt();
      ArrayList<Integer>list=new ArrayList<>();
      for(int j=0 ; j<n ; j++){
        list.add(in.nextInt());
      }
      find(list);
    }
  }
  public static void find(ArrayList<Integer>list){
    Collections.sort(list);
    int n=list.size();
    for(int i=n-1 ; i>=0 ; i--){
      if(list.get(i)<=i+1){
        System.out.println(i+2);
        return ;
      }
    }
    System.out.println(1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var list : Sequence(int) ; list := Sequence{} ;
         var j : int ; j := 0 ; while j < n do ( (     list := list->including(in.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
     execute find(list) )  ;     i := i + 1 ) );
  static   operation find( list : Sequence(int)) : void
  pre: true
  post: true
  activity: (     list := list->sort() ; 
     var n : int ; n := list->size() ;
         var i : int ; i := n - 1 ; while i >= 0 do ( (     if (list->at(i+1) <= i + 1) then (     OclFile["System.out"].println(i + 2) ; 
     return ) else skip )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println(1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B1358 {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int cases=Integer.parseInt(br.readLine());
    for(int i=0 ; i<cases ; i++){
      int result=0 ;
      int n=Integer.parseInt(br.readLine());
      int[] arr=new int[n];
      StringTokenizer st=new StringTokenizer(br.readLine());
      for(int j=0 ; j<n ; j++){
        arr[j]=Integer.parseInt(st.nextToken());
      }
      Arrays.sort(arr);
      for(int j=arr.length-1 ; j>=0 ; j--){
        if(arr[j]<=j+1){
          System.out.println(j+2);
          break ;
        }
        if(j==0){
          System.out.println(1);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1358 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var cases : int ; cases := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < cases do ( (     var result : int ; result := 0 ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var j : int ; j := 0 ; while j < n do ( (     arr[j+1] := (st.next())->toInteger() )  ;     j := j + 1 ) ; 
    arr := arr->sort() ; 
        var j : int ; j := arr->size() - 1 ; while j >= 0 do ( (     if (arr[j+1] <= j + 1) then (     OclFile["System.out"].println(j + 2) ; 
     break ) else skip ; 
     if (j = 0) then (     OclFile["System.out"].println(1) ; 
     break ) else skip )  ;     j := j - 1 ) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int num ;
  public static void main(String[] args){
    while(read()){
      solve();
    }
  }
  static boolean read(){
    if(sc.hasNextInt())num=sc.nextInt();
    if(num==0)return false ;
    return true ;
  }
  static void solve(){
    int table[]={
      0,1,2,3,5,7,8,9 };
      String s=Integer.toOctalString(num);
      for(int i=0 ; i<s.length(); i++){
        int num2=Integer.parseInt(""+s.charAt(i),8);
        System.out.print(table[num2]);
      }
      System.out.println();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute num : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (read()) do (     execute solve() ) );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     if (sc.hasNextInt()) then     num := sc.getCurrent()->toInteger() ; else skip ; 
     if (num = 0) then     return false else skip ; 
     return true );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var table : Sequence(int) ; table := Sequence{0,1,2,3,5,7,8,9} ;
     var s : String ; s := (MathLib.decimal2octal(num) + "") ;
         var i : int ; i := 0 ; while i < s->size() do ( (     var num2 : int ; num2 := ("" + s->at(i+1))->toInteger() ;
     OclFile["System.out"].print(table[num2+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine())!=null && ! line.isEmpty()&& ! "0".equals(line)){
      String oct=Integer.toOctalString(Integer.valueOf(line));
      oct=oct.replaceAll("7","9");
      oct=oct.replaceAll("6","8");
      oct=oct.replaceAll("5","7");
      oct=oct.replaceAll("4","5");
      System.out.println(oct);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty()) & not("0" = line)) do (    skip ; (     var oct : String ; oct := (MathLib.decimal2octal((line)->toInteger()) + "") ;
     oct := oct.replaceAllMatches("7", "9" ) ; 
    oct := oct.replaceAllMatches("6", "8" ) ; 
    oct := oct.replaceAllMatches("5", "7" ) ; 
    oct := oct.replaceAllMatches("4", "5" ) ; 
    OclFile["System.out"].println(oct) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws Exception {
    Main mo=new Main();
    ArrayList<String>dataSet=new ArrayList<String>();
    mo.inputDataSet(dataSet,"0");
    for(int i=0 ; i<dataSet.size(); i++){
      int n=Integer.parseInt(dataSet.get(i));
      RemoveUnluckyNumber run=new RemoveUnluckyNumber(n);
      run.showConvNum();
    }
  }
  public static void inputDataSet(ArrayList<String>dataSet,String terminal)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String line=br.readLine();
      if(line.equals(terminal))break ;
      dataSet.add(line);
    }
  }
}
class RemoveUnluckyNumber {
  private int n ;
  public RemoveUnluckyNumber(int n){
    this.n=n ;
  }
  public int extrOctalDigit(int decimalNum,int d){
    return(decimalNum>>3*(d-1))& 7 ;
  }
  public int singleDigitConv(int val){
    int convVal=val ;
    if(convVal>=4){
      convVal++;
      if(convVal>=6){
        convVal++;
      }
    }
    return convVal ;
  }
  public void showConvNum(){
    boolean printFlag=false ;
    for(int i=10 ; i>=1 ; i--){
      int octalNumber=extrOctalDigit(n,i);
      if(octalNumber>0){
        printFlag=true ;
      }
      if(printFlag){
        System.out.print(singleDigitConv(octalNumber));
      }
    }
    if(! printFlag){
      System.out.print(0);
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mo : Main ; mo := Main.newMain() ;
     var dataSet : Sequence(String) ; dataSet := Sequence{} ;
     mo.inputDataSet(dataSet, "0") ; 
         var i : int ; i := 0 ; while i < dataSet->size() do ( (     var n : int ; n := (dataSet->at(i+1))->toInteger() ;
     var run : RemoveUnluckyNumber ; run := RemoveUnluckyNumber.newRemoveUnluckyNumber(n) ;
     run.showConvNum() )  ;     i := i + 1 ) );
  static   operation inputDataSet( dataSet : Sequence(String), terminal : String) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var line : String ; line := br.readLine() ;
     if (line = terminal) then     break else skip ; 
     dataSet := dataSet->including(line) ) );
}
class RemoveUnluckyNumber {
   attribute n : int;
   static operation newRemoveUnluckyNumber( n : int) : RemoveUnluckyNumber
  pre: true
  post: true
  activity:
  ( var self : RemoveUnluckyNumber ;
    self := createRemoveUnluckyNumber();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     self.n := n );
   operation extrOctalDigit( decimalNum : int, d : int) : int
  pre: true
  post: true
  activity: (     return ((decimalNum/(2->pow(3 * (d - 1))))->oclAsType(long)) & 7 );
   operation singleDigitConv( val : int) : int
  pre: true
  post: true
  activity: (     var convVal : int ; convVal := val ;
     if (convVal >= 4) then (     convVal := convVal + 1 ; 
     if (convVal >= 6) then (     convVal := convVal + 1 ) else skip ) else skip ; 
     return convVal );
   operation showConvNum() : void
  pre: true
  post: true
  activity: (     var printFlag : boolean ; printFlag := false ;
         var i : int ; i := 10 ; while i >= 1 do ( (     var octalNumber : int ; octalNumber := extrOctalDigit(n, i) ;
     if (octalNumber > 0) then (     printFlag := true ) else skip ; 
     if (printFlag) then (     OclFile["System.out"].print(singleDigitConv(octalNumber)) ) else skip )  ;     i := i - 1 ) ; 
     if (not(printFlag)) then (     OclFile["System.out"].print(0) ) else skip ; 
     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Long e=Long.parseLong(sc.next());
    Map<Long,Long>map=new HashMap<>();
    map.put(0L,0L);
    map.put(1L,1L);
    map.put(2L,2L);
    map.put(3L,3L);
    map.put(4L,5L);
    map.put(5L,7L);
    map.put(6L,8L);
    map.put(7L,9L);
    while(! e.equals(0L)){
      List<Long>lists=new ArrayList<>();
      while(e/8!=0){
        lists.add(map.get(e % 8L));
        e=e/8L ;
      }
      lists.add(map.get(e % 8L));
      Collections.reverse(lists);
      System.out.println(lists.stream().map(Object :: toString).collect(Collectors.joining("")));
      e=Long.parseLong(sc.next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var e : long ; e := (sc.getCurrent())->toLong() ;
    var map : Map(long,long) ; map := Map{} ;
    map := map->union(Map{0L |-> 0L}) ; 
    map := map->union(Map{1L |-> 1L}) ; 
    map := map->union(Map{2L |-> 2L}) ; 
    map := map->union(Map{3L |-> 3L}) ; 
    map := map->union(Map{4L |-> 5L}) ; 
    map := map->union(Map{5L |-> 7L}) ; 
    map := map->union(Map{6L |-> 8L}) ; 
    map := map->union(Map{7L |-> 9L}) ; 
    while (not(e = 0L)) do (     var lists : Sequence(long) ; lists := Sequence{} ;
     while (e / 8 /= 0) do (     lists := lists->including(map->at(e mod 8L)) ; 
     e := e / 8L ) ; 
    lists := lists->including(map->at(e mod 8L)) ; 
    lists := lists->reverse() ; 
    OclFile["System.out"].println(lists->collect( _x1 | (lambda _pars : OclAny in Object.newObject().toString(_pars))->apply(_x1) ).collect(Collectors.joining(""))) ; 
    e := (sc.getCurrent())->toLong() ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Subtractions {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int p=input.nextInt();
    for(int i=0 ; i<p ; i++){
      int a=input.nextInt();
      int b=input.nextInt();
      int ops=0 ;
      while(a>0 && b>0){
        if(a>=b){
          ops+=a/b ;
          a=a % b ;
        }
        else {
          ops+=b/a ;
          b=b % a ;
        }
      }
      System.out.println(ops);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Subtractions {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : int ; p := input.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < p do ( (     var a : int ; a := input.getCurrent()->toInteger() ;
     var b : int ; b := input.getCurrent()->toInteger() ;
    var ops : int ; ops := 0 ;
    while (a > 0 & b > 0) do (     if (a >= b) then (     ops := ops+(a / b) ; 
     a := a mod b ) else (     ops := ops+(b / a) ; 
     b := b mod a ) ) ; 
    OclFile["System.out"].println(ops) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  static HashMap<String,Integer>map=new HashMap<String,Integer>();
  static {
    map.put("000",0);
    map.put("001",1);
    map.put("010",2);
    map.put("011",3);
    map.put("100",5);
    map.put("101",7);
    map.put("110",8);
    map.put("111",9);
  }
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    while(true){
      int n=cin.nextInt();
      if(n==0){
        break ;
      }
      String s=Integer.toBinaryString(n);
      int a=s.length()% 3 ;
      if(a!=0)for(int i=0 ;
      i<3-a ;
      i++){
        s="0"+s ;
      }
      for(int i=0 ; i<s.length(); i+=3){
        System.out.print(map.get(s.substring(i,i+3)));
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute map : Map(String,int) := Map{};
  static operation initialiseClass()
  pre: true post: true
  activity:     map := map->union(Map{"000" |-> 0}) ; 
    map := map->union(Map{"001" |-> 1}) ; 
    map := map->union(Map{"010" |-> 2}) ; 
    map := map->union(Map{"011" |-> 3}) ; 
    map := map->union(Map{"100" |-> 5}) ; 
    map := map->union(Map{"101" |-> 7}) ; 
    map := map->union(Map{"110" |-> 8}) ; 
    map := map->union(Map{"111" |-> 9}) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := cin.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var s : String ; s := (MathLib.decimal2binary(n) + "") ;
    var a : int ; a := s->size() mod 3 ;
    if (a /= 0) then         var i : int ; i := 0 ; while i < 3 - (a)->char2byte() do ( (     s := "0" + s )  ;     i := i + 1 ) ; else skip ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     OclFile["System.out"].print(map->at(s.subrange(i+1,i + 3))) )  ;     i := i+(3) ) ; 
    OclFile["System.out"].println() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAXN=1000001 ;
  static int[] spf=new int[MAXN];
  static int[] hash1=new int[MAXN];
  static void sieve(){
    spf[1]=1 ;
    for(int i=2 ; i<MAXN ; i++)spf[i]=i ;
    for(int i=4 ; i<MAXN ; i+=2)spf[i]=2 ;
    for(int i=3 ; i*i<MAXN ; i++){
      if(spf[i]==i){
        for(int j=i*i ; j<MAXN ; j+=i)if(spf[j]==j)spf[j]=i ;
      }
    }
  }
  static void getFactorization(int x){
    int temp ;
    while(x!=1){
      temp=spf[x];
      if(x % temp==0){
        hash1[spf[x] ]++;
        x=x/spf[x];
      }
      while(x % temp==0)x=x/temp ;
    }
  }
  static boolean check(int x){
    int temp ;
    while(x!=1){
      temp=spf[x];
      if(x % temp==0 && hash1[temp]>1)return false ;
      while(x % temp==0)x=x/temp ;
    }
    return true ;
  }
  static boolean hasValidNum(int[] arr,int n){
    sieve();
    for(int i=0 ; i<n ; i++)getFactorization(arr[i]);
    for(int i=0 ; i<n ; i++)if(check(arr[i]))return true ;
    return false ;
  }
  public static void main(String[] args){
    int[] arr={
      2,8,4,10,6,7 };
      int n=arr.length ;
      if(hasValidNum(arr,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAXN : int := 1000001;
  static   attribute spf : Sequence(int) := Integer.subrange(1,MAXN)->collect(0);
  static   attribute hash1 : Sequence(int) := Integer.subrange(1,MAXN)->collect(0);
  static   operation sieve() : void
  pre: true
  post: true
  activity: (     spf[1+1] := 1 ; 
         var i : int ; i := 2 ; while i < MAXN do (     spf[i+1] := i ;  ;     i := i + 1 ) ; 
         var i : int ; i := 4 ; while i < MAXN do (     spf[i+1] := 2 ;  ;     i := i+(2) ) ; 
         var i : int ; i := 3 ; while i * i < MAXN do ( (     if (spf[i+1] = i) then (         var j : int ; j := i * i ; while j < MAXN do (     if (spf[j+1] = j) then     spf[j+1] := i ; else skip ;  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) );
  static   operation getFactorization( x : int) : void
  pre: true
  post: true
  activity: (     var temp : int ;
     while (x /= 1) do (     temp := spf[x+1] ; 
     if (x mod temp = 0) then (     hash1[spf[x+1]+1] := hash1[spf[x+1]+1] + 1 ; 
     x := x / spf[x+1] ) else skip ; 
     while (x mod temp = 0) do     x := x / temp ; ) );
  static   operation check( x : int) : boolean
  pre: true
  post: true
  activity: (     var temp : int ;
     while (x /= 1) do (     temp := spf[x+1] ; 
     if (x mod temp = 0 & hash1[temp+1] > 1) then     return false else skip ; 
     while (x mod temp = 0) do     x := x / temp ; ) ; 
     return true );
  static   operation hasValidNum( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     execute sieve() ; 
         var i : int ; i := 0 ; while i < n do (     execute getFactorization(arr[i+1]) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do (     if (check(arr[i+1])) then     return true else skip ;  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,8,4,10,6,7} ;
     var n : int ; n := arr->size() ;
     if (hasValidNum(arr, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void generateArr(int[] arr,int n){
    if(n<=1)return ;
    int prev=arr[0];
    arr[0]=arr[0] & arr[1];
    for(int i=1 ; i<n-1 ; i++){
      int curr=arr[i];
      arr[i]=prev & arr[i+1];
      prev=curr ;
    }
    arr[n-1]=prev & arr[n-1];
  }
  public static void main(String[] args){
    int[] arr={
      1,2,3,4,5,6 };
      int n=arr.length ;
      generateArr(arr,n);
      for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation generateArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     if (n <= 1) then     return else skip ; 
     var prev : int ; prev := arr[0+1] ;
    arr[0+1] := arr[0+1] & arr[1+1] ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     var curr : int ; curr := arr[i+1] ;
     arr[i+1] := MathLib.bitwiseAnd(prev,arr[i + 1+1]) ; 
     prev := curr )  ;     i := i + 1 ) ; 
    arr[n - 1+1] := MathLib.bitwiseAnd(prev,arr[n - 1+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6} ;
     var n : int ; n := arr->size() ;
     execute generateArr(arr, n) ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void ReplaceElements(int[] arr,int n){
    if(n<=1)return ;
    int prev=arr[0];
    arr[0]=arr[0] ^ arr[1];
    for(int i=1 ; i<n-1 ; i++){
      int curr=arr[i];
      arr[i]=prev ^ arr[i+1];
      prev=curr ;
    }
    arr[n-1]=prev ^ arr[n-1];
  }
  public static void main(String[] args){
    int[] arr={
      2,3,4,5,6 };
      int n=arr.length ;
      ReplaceElements(arr,n);
      for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation ReplaceElements( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     if (n <= 1) then     return else skip ; 
     var prev : int ; prev := arr[0+1] ;
    arr[0+1] := arr[0+1] xor arr[1+1] ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     var curr : int ; curr := arr[i+1] ;
     arr[i+1] := MathLib.bitwiseXor(prev,arr[i + 1+1]) ; 
     prev := curr )  ;     i := i + 1 ) ; 
    arr[n - 1+1] := MathLib.bitwiseXor(prev,arr[n - 1+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4,5,6} ;
     var n : int ; n := arr->size() ;
     execute ReplaceElements(arr, n) ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void ReplaceElements(int arr[],int n){
    if(n<=1){
      return ;
    }
    int prev=arr[0];
    arr[0]=arr[0]+arr[1];
    for(int i=1 ; i<n-1 ; i++){
      int curr=arr[i];
      arr[i]=prev+arr[i+1];
      prev=curr ;
    }
    arr[n-1]=prev+arr[n-1];
  }
  public static void main(String[] args){
    int arr[]={
      2,3,4,5,6 };
      int n=arr.length ;
      ReplaceElements(arr,n);
      for(int i=0 ; i<n ; i++){
        System.out.print(arr[i]+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation ReplaceElements( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     if (n <= 1) then (     return ) else skip ; 
     var prev : int ; prev := arr[0+1] ;
    arr[0+1] := arr[0+1] + arr[1+1] ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     var curr : int ; curr := arr[i+1] ;
     arr[i+1] := prev + arr[i + 1+1] ; 
     prev := curr )  ;     i := i + 1 ) ; 
    arr[n - 1+1] := prev + arr[n - 1+1] ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4,5,6} ;
     var n : int ; n := arr->size() ;
     execute ReplaceElements(arr, n) ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static long countTriplets(int A,int B,int C){
    long ans=0 ;
    for(int i=1 ; i<=A ; i++){
      for(int j=1 ; j<=B ; j++){
        for(int k=1 ; k<=C ; k++){
          if(i*k>j*j)ans++;
        }
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int A=3,B=2,C=2 ;
    System.out.println(countTriplets(A,B,C));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countTriplets( A : int, B : int, C : int) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
         var i : int ; i := 1 ; while i <= A do ( (         var j : int ; j := 1 ; while j <= B do ( (         var k : int ; k := 1 ; while k <= C do ( (     if (i * k > j * j) then     ans := ans + 1 ; else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 3 ;
    var B : int ; B := 2 ;
    var C : int ; C := 2 ;
     OclFile["System.out"].println(countTriplets(A, B, C)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=100000 ;
  static boolean[] prime=new boolean[MAX+1];
  static void SieveOfEratosthenes(){
    for(int i=0 ; i<MAX+1 ; i++){
      prime[i]=true ;
    }
    for(int p=2 ; p*p<=MAX ; p++){
      if(prime[p]==true){
        for(int i=p*p ; i<=MAX ; i+=p)prime[i]=false ;
      }
    }
  }
  static int smallestPrime(int d){
    int l=(int)Math.pow(10,d-1);
    int r=(int)Math.pow(10,d)-1 ;
    for(int i=l ; i<=r ; i++){
      if(prime[i]){
        return i ;
      }
    }
    return-1 ;
  }
  static int largestPrime(int d){
    int l=(int)Math.pow(10,d-1);
    int r=(int)Math.pow(10,d)-1 ;
    for(int i=r ; i>=l ; i--){
      if(prime[i]){
        return i ;
      }
    }
    return-1 ;
  }
  public static void main(String[] args){
    SieveOfEratosthenes();
    int queries[]={
      2,5 };
      int q=queries.length ;
      for(int i=0 ; i<q ; i++){
        System.out.println(smallestPrime(queries[i])+" "+largestPrime(queries[i]));
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100000;
  static   attribute prime : Sequence(boolean) := Integer.subrange(1,MAX + 1)->collect(false);
  static   operation SieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < MAX + 1 do ( (     prime[i+1] := true )  ;     i := i + 1 ) ; 
         var p : int ; p := 2 ; while p * p <= MAX do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * p ; while i <= MAX do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation smallestPrime( d : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 10->pow(d - 1)->oclAsType(int) ;
     var r : int ; r := 10->pow(d)->oclAsType(int) - 1 ;
         var i : int ; i := l ; while i <= r do ( (     if (prime[i+1]) then (     return i ) else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation largestPrime( d : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 10->pow(d - 1)->oclAsType(int) ;
     var r : int ; r := 10->pow(d)->oclAsType(int) - 1 ;
         var i : int ; i := r ; while i >= l do ( (     if (prime[i+1]) then (     return i ) else skip )  ;     i := i - 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes() ; 
     var queries : Sequence(int) ; queries := Sequence{2,5} ;
     var q : int ; q := queries->size() ;
         var i : int ; i := 0 ; while i < q do ( (     OclFile["System.out"].println(smallestPrime(queries[i+1]) + " " + largestPrime(queries[i+1])) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
import java.util.Arrays ;
class Main {
  static final PrintWriter out=new PrintWriter(System.out);
  static final int INF=Integer.MAX_VALUE/2 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      StringTokenizer st=new StringTokenizer(line);
      int n=Integer.parseInt(st.nextToken());
      int m=Integer.parseInt(st.nextToken());
      int[][] tir=new int[m+1][n+1];
      Arrays.fill(tir[m],INF);
      tir[m][n]=0 ;
      int[] d=new int[n];
      int[] c=new int[m];
      for(int i=0 ; i<n ; i++)d[i]=Integer.parseInt(br.readLine());
      for(int i=0 ; i<m ; i++)c[i]=Integer.parseInt(br.readLine());
      for(int i=m-1 ; i>=0 ; i--){
        for(int j=n-1 ; j>=0 ; j--){
          tir[i][j]=Math.min(tir[i+1][j],tir[i+1][j+1]+d[j]*c[i]);
        }
      }
      out.println(tir[0][0]);
      out.flush();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static    attribute INF : int := 2147483647 / 2;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var st : OclIterator ; st := OclIterator.newOclIterator_String(line) ;
     var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var tir : Sequence(Sequence(int)) ; tir := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
    tir[m+1] := tir[m+1]->collect(INF) ; 
    tir[m+1][n+1] := 0 ; 
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     d[i+1] := (br.readLine())->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     c[i+1] := (br.readLine())->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := m - 1 ; while i >= 0 do ( (         var j : int ; j := n - 1 ; while j >= 0 do ( (     tir[i+1][j+1] := Set{tir[i + 1+1][j+1], tir[i + 1+1][j + 1+1] + d[j+1] * c[i+1]}->min() )  ;     j := j - 1 ) )  ;     i := i - 1 ) ; 
    skip ; 
    skip ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  static int[] C,D ;
  static int M,N ;
  static int[][] memo ;
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String[] strs=in.readLine().split(" ");
    N=Integer.parseInt(strs[0]);
    M=Integer.parseInt(strs[1]);
    memo=new int[N][M];
    D=new int[N];
    for(int i=0 ; i<N ; i++){
      D[i]=Integer.parseInt(in.readLine());
    }
    C=new int[M];
    for(int i=0 ; i<M ; i++){
      C[i]=Integer.parseInt(in.readLine());
    }
    System.out.println(func(0,0));
  }
  static int func(int town,int day){
    if(day==M){
      if(town==N){
        return 0 ;
      }
      return Integer.MAX_VALUE>>1 ;
    }
    if(town==N){
      return 0 ;
    }
    if(memo[town][day]!=0)return memo[town][day]+1 ;
    int T1=func(town,day+1);
    int T2=func(town+1,day+1)+D[town]*C[day];
    if(T1<T2){
      memo[town][day]=T1-1 ;
      return T1 ;
    }
    memo[town][day]=T2-1 ;
    return T2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute C : Sequence(int);
  static   attribute M : int;
  static   attribute memo : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var strs : Sequence(String) ; strs := in.readLine()->split(" ") ;
    N := (strs[0+1])->toInteger() ; 
    M := (strs[1+1])->toInteger() ; 
    memo := Integer.subrange(1,N)->collect(Integer.subrange(1,M)->collect(0)) ; 
    D := Integer.subrange(1,N)->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     D[i+1] := (in.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    C := Integer.subrange(1,M)->collect(0) ; 
        var i : int ; i := 0 ; while i < M do ( (     C[i+1] := (in.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(func(0, 0)) ; 
 );
  static   operation func( town : int, day : int) : int
  pre: true
  post: true
  activity: (     if (day = M) then (     if (town = N) then (     return 0 ) else skip ; 
     return (2147483647/(2->pow(1)))->oclAsType(long) ) else skip ; 
     if (town = N) then (     return 0 ) else skip ; 
    if (memo[town+1][day+1] /= 0) then     return memo[town+1][day+1] + 1 else skip ; 
    var T1 : int ; T1 := func(town, day + 1) ;
    var T2 : int ; T2 := func(town + 1, day + 1) + D[town+1] * C[day+1] ;
    if (T1 < T2) then (     memo[town+1][day+1] := T1 - 1 ; 
     return T1 ) else skip ; 
    memo[town+1][day+1] := T2 - 1 ; 
    return T2 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new B().doIt();
  }
  class B {
    int DP(int map[][],int n,int m,int C[],int D[]){
      int length=m-n+1 ;
      for(int i=0 ; i<length ; i++)map[0][i]=C[i]*D[0];
      for(int i=1 ; i<n ; i++){
        for(int j=i ; j<i+length ; j++){
          for(int k=j ; k<i+length ; k++){
            map[i][k]=Math.min(map[i][k],D[i]*C[k]+map[i-1][j-1]);
          }
        }
      }
      int result=Integer.MAX_VALUE ;
      for(int i=0 ; i<m ; i++)result=Math.min(map[n-1][i],result);
      return result ;
    }
    void doIt(){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int D[]=new int[n];
      int C[]=new int[m];
      int map[][]=new int[n][m];
      for(int i=0 ; i<n ; i++)Arrays.fill(map[i],Integer.MAX_VALUE);
      for(int i=0 ; i<n ; i++)D[i]=Integer.parseInt(sc.next());
      for(int i=0 ; i<m ; i++)C[i]=Integer.parseInt(sc.next());
      System.out.println(DP(map,n,m,C,D));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     B.newB().doIt() );
 class B {
   operation DP( map : Sequence(Sequence(int)), n : int, m : int, C : Sequence(int), D : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var length : int ; length := m - n + 1 ;
         var i : int ; i := 0 ; while i < length do (     map[0+1][i+1] := C[i+1] * D[0+1] ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := i ; while j < i + length do ( (         var k : int ; k := j ; while k < i + length do ( (     map[i+1][k+1] := Set{map[i+1][k+1], D[i+1] * C[k+1] + map[i - 1+1][j - 1+1]}->min() )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var result : int ; result := 2147483647 ;
        var i : int ; i := 0 ; while i < m do (     result := Set{map[n - 1+1][i+1], result}->min() ;  ;     i := i + 1 ) ; 
    return result 
 );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var D : Sequence(int) ; D := Integer.subrange(1,n)->collect(0) ;
    var C : Sequence(int) ; C := Integer.subrange(1,m)->collect(0) ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do (     map[i+1] := map[i+1]->collect(2147483647) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     D[i+1] := (sc.getCurrent())->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     C[i+1] := (sc.getCurrent())->toInteger() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(DP(map, n, m, C, D)) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class sub {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    for(int i=0 ; i<n ; i++){
      int a=scan.nextInt();
      int b=scan.nextInt();
      System.out.println(sub(a,b));
    }
  }
  public static int sub(int a,int b){
    int min=Math.min(a,b);
    int max=Math.max(a,b);
    int result=0 ;
    while(min>0){
      result+=max/min ;
      max=max % min ;
      int curr_min=Math.min(min,max);
      int curr_max=Math.max(min,max);
      min=curr_min ;
      max=curr_max ;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class sub {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scan.getCurrent()->toInteger() ;
     var b : int ; b := scan.getCurrent()->toInteger() ;
     OclFile["System.out"].println(sub(a, b)) )  ;     i := i + 1 ) );
  static   operation sub( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var min : int ; min := Set{a, b}->min() ;
     var max : int ; max := Set{a, b}->max() ;
    var result : int ; result := 0 ;
    while (min > 0) do (     result := result+(max / min) ; 
     max := max mod min ; 
    var curr_min : int ; curr_min := Set{min, max}->min() ;
    var curr_max : int ; curr_max := Set{min, max}->max() ;
    min := curr_min ; 
    max := curr_max ; 
 ) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Solution {
  static boolean isExists(int a[],int n){
    Map<Integer,Integer>freq=new HashMap<Integer,Integer>();
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      freq.put(a[i],freq.get(a[i])==null ? 0 : freq.get(a[i])+1);
      sum+=a[i];
    }
    if(sum % 2==0){
      if(freq.get(sum/2)!=null)return true ;
    }
    return false ;
  }
  public static void main(String args[]){
    int a[]={
      5,1,2,2 };
      int n=a.length ;
      if(isExists(a,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation isExists( a : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var freq : Map(int,int) ; freq := Map{} ;
     var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     freq := freq->union(Map{a[i+1] |-> if freq->at(a[i+1]) = null then 0 else freq->at(a[i+1]) + 1 endif}) ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    if (sum mod 2 = 0) then (     if (freq->at(sum / 2) /= null) then     return true else skip ) else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{5,1,2,2} ;
     var n : int ; n := a->size() ;
     if (isExists(a, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    DoProb x=new DoProb();
    int r=x.result(0,0);
    System.out.println(r);
    System.exit(0);
  }
}
class DoProb {
  private int town ;
  private int day ;
  private int[] nD ;
  private int[] mW ;
  private int[][] cost ;
  DoProb(){
    @ SuppressWarnings("resource")Scanner scan=new Scanner(System.in);
    town=scan.nextInt();
    day=scan.nextInt();
    nD=new int[town];
    mW=new int[day];
    for(int i=0 ; i<town ; i++)nD[i]=scan.nextInt();
    for(int i=0 ; i<day ; i++)mW[i]=scan.nextInt();
    cost=new int[town][day];
    for(int i=0 ; i<town ; i++)for(int j=0 ; j<day ; j++)cost[i][j]=-1 ;
  }
  public int result(int start,int currday){
    if(start>=town)return(0);
    if(cost[start][currday]>0)return cost[start][currday];
    int r ;
    int go=result(start+1,currday+1)+(nD[start]*mW[currday]);
    if(day-currday==town-start)r=go ;
    else {
      int wait=result(start,currday+1);
      if(wait<go)r=wait ;
      else r=go ;
    }
    cost[start][currday]=r ;
    return r ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : DoProb ; x := DoProb.newDoProb() ;
     var r : int ; r := x.result(0, 0) ;
     OclFile["System.out"].println(r) ; 
 OclProcess.exit(0) );
}
class DoProb {
   attribute town : int;
   attribute day : int;
   attribute nD : Sequence(int);
   attribute mW : Sequence(int);
   attribute cost : Sequence(Sequence(int));
   static operation newDoProb() : DoProb
  pre: true
  post: true
  activity:
  ( var self : DoProb ;
    self := createDoProb();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     town := scan.getCurrent()->toInteger() ; 
    day := scan.getCurrent()->toInteger() ; 
    nD := Integer.subrange(1,town)->collect(0) ; 
    mW := Integer.subrange(1,day)->collect(0) ; 
        var i : int ; i := 0 ; while i < town do (     nD[i+1] := scan.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < day do (     mW[i+1] := scan.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    cost := Integer.subrange(1,town)->collect(Integer.subrange(1,day)->collect(0)) ; 
        var i : int ; i := 0 ; while i < town do (         var j : int ; j := 0 ; while j < day do (     cost[i+1][j+1] := -1 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
 );
   operation result( start : int, currday : int) : int
  pre: true
  post: true
  activity: (     if (start >= town) then     return (0) else skip ; 
     if (cost[start+1][currday+1] > 0) then     return cost[start+1][currday+1] else skip ; 
    var r : int ;
    var go : int ; go := result(start + 1, currday + 1) + (nD[start+1] * mW[currday+1]) ;
    if (day - currday = town - start) then     r := go else (     var wait : int ; wait := result(start, currday + 1) ;
     if (wait < go) then     r := wait ; else     r := go ; ) ;  
    cost[start+1][currday+1] := r ; 
    return r 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static final int INF=Integer.MAX_VALUE ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String line ;
    String[] words ;
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[] D=new int[N+1];
    int[] C=new int[M+1];
    int[][] DC=new int[D.length][C.length];
    for(int i=1 ; i<=N ; i++){
      D[i]=sc.nextInt();
    }
    for(int i=1 ; i<=M ; i++){
      C[i]=sc.nextInt();
    }
    for(int i=0 ; i<D.length ; i++){
      for(int j=0 ; j<C.length ; j++){
        DC[i][j]=D[i]*C[j];
      }
    }
    int[][] dp=new int[N+1][M+1];
    for(int i=1 ; i<dp.length ; i++){
      Arrays.fill(dp[i],INF);
    }
    for(int i=1 ; i<=N ; i++){
      for(int j=i ; j<=M ; j++){
        dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j-1]+DC[i][j]);
      }
    }
    System.out.println(dp[N][M]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := 2147483647;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : String ;
    var words : Sequence(String) ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var D : Sequence(int) ; D := Integer.subrange(1,N + 1)->collect(0) ;
    var C : Sequence(int) ; C := Integer.subrange(1,M + 1)->collect(0) ;
    var DC : Sequence(Sequence(int)) ; DC := Integer.subrange(1,D->size())->collect(Integer.subrange(1,C->size())->collect(0)) ;
        var i : int ; i := 1 ; while i <= N do ( (     D[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= M do ( (     C[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < D->size() do ( (         var j : int ; j := 0 ; while j < C->size() do ( (     DC[i+1][j+1] := D[i+1] * C[j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,M + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i < dp->size() do ( (     dp[i+1] := dp[i+1]->collect(INF) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := i ; while j <= M do ( (     dp[i+1][j+1] := Set{dp[i+1][j - 1+1], dp[i - 1+1][j - 1+1] + DC[i+1][j+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[N+1][M+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int k=input.nextInt();
    int x=input.nextInt();
    ArrayList<Integer>arr=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      arr.add(input.nextInt());
    }
    for(int i=arr.size()-k ; i<arr.size(); i++){
      arr.set(i,x);
    }
    int sum=0 ;
    for(int i=0 ; i<arr.size(); i++){
      sum+=arr.get(i);
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var k : int ; k := input.getCurrent()->toInteger() ;
    var x : int ; x := input.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr := arr->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := arr->size() - k ; while i < arr->size() do ( (     arr := arr.setAt(i+1,x) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     sum := sum+(arr->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int x=sc.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    if(n<=k){
      System.out.println(n*x);
    }
    else {
      int sum=0 ;
      for(int i=0 ; i<n-k ; i++)sum=sum+a[i];
      sum=sum+k*x ;
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    if (n <= k) then (     OclFile["System.out"].println(n * x) ) else (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n - k do (     sum := sum + a[i+1] ;  ;     i := i + 1 ) ; 
     sum := sum + k * x ; 
     OclFile["System.out"].println(sum) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,k,x ;
    n=sc.nextInt();
    k=sc.nextInt();
    x=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    int sum=0 ;
    for(int i=0 ; i<n-k ; i++)sum+=arr[i];
    sum=sum+k*x ;
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var k : int ;
    var x : int ;
    n := sc.getCurrent()->toInteger() ; 
    k := sc.getCurrent()->toInteger() ; 
    x := sc.getCurrent()->toInteger() ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n - k do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    sum := sum + k * x ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Sheet6ProblemE {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int k=input.nextInt();
    int x=input.nextInt();
    ArrayList<Integer>arr=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      arr.add(input.nextInt());
    }
    for(int i=arr.size()-k ; i<arr.size(); i++){
      arr.set(i,x);
    }
    int sum=0 ;
    for(int i=0 ; i<arr.size(); i++){
      sum+=arr.get(i);
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sheet6ProblemE {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var k : int ; k := input.getCurrent()->toInteger() ;
    var x : int ; x := input.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr := arr->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := arr->size() - k ; while i < arr->size() do ( (     arr := arr.setAt(i+1,x) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     sum := sum+(arr->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import sun.tools.jar.resources.jar ;
public class PA_TrickySum {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    int t=Integer.parseInt(reader.readLine());
    long sum=0,valu=0,result=0 ;
    for(int p=0 ; p<t ; p++){
      long n1=Long.parseLong(reader.readLine());
      sum=n1*(n1+1)/2 ;
      for(long i=1 ; i<n1+1 ; i=(long)i*2){
        valu+=i ;
      }
      result=sum-(valu*2);
      writer.write(""+result);
      writer.newLine();
      valu=0 ;
    }
    writer.newLine();
    writer.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class PA_TrickySum {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var t : int ; t := (reader.readLine())->toInteger() ;
    var sum : long ; sum := 0 ;
    var valu : long ; valu := 0 ;
    var result : long ; result := 0 ;
        var p : int ; p := 0 ; while p < t do ( (     var n1 : long ; n1 := (reader.readLine())->toLong() ;
     sum := n1 * (n1 + 1) / 2 ; 
        var i : long ; i := 1 ; while i < n1 + 1 do ( (     valu := valu+(i) )  ;     i := i->oclAsType(long) * 2 ) ; 
    result := sum - (valu * 2) ; 
    skip ; 
    skip ; 
    valu := 0 ; 
 )  ;     p := p + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import sun.tools.jar.resources.jar ;
public class PA_TrickySum {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    int t=Integer.parseInt(reader.readLine());
    long sum=0,valu=0,result=0 ;
    for(int p=0 ; p<t ; p++){
      long n1=Long.parseLong(reader.readLine());
      sum=n1*(n1+1)/2 ;
      for(long i=1 ; i<n1+1 ; i=(long)i*2){
        valu+=i ;
      }
      result=sum-(valu*2);
      writer.write(""+result);
      writer.newLine();
      valu=0 ;
    }
    writer.newLine();
    writer.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class PA_TrickySum {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var t : int ; t := (reader.readLine())->toInteger() ;
    var sum : long ; sum := 0 ;
    var valu : long ; valu := 0 ;
    var result : long ; result := 0 ;
        var p : int ; p := 0 ; while p < t do ( (     var n1 : long ; n1 := (reader.readLine())->toLong() ;
     sum := n1 * (n1 + 1) / 2 ; 
        var i : long ; i := 1 ; while i < n1 + 1 do ( (     valu := valu+(i) )  ;     i := i->oclAsType(long) * 2 ) ; 
    result := sum - (valu * 2) ; 
    skip ; 
    skip ; 
    valu := 0 ; 
 )  ;     p := p + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TrickySum {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    for(int i=0 ; i<t ; i++){
      long n=scan.nextLong();
      long ans=(1+n)*n/2 ;
      int exp=0 ;
      while(Math.pow(2,exp)<=n){
        ans-=(long)(Math.pow(2,exp))*2 ;
        exp++;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TrickySum {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : long ; n := scan.getCurrent()->toLong() ;
     var ans : long ; ans := (1 + n) * n / 2 ;
    var exp : int ; exp := 0 ;
    while (2->pow(exp) <= n) do (     ans := ans-((2->pow(exp))->oclAsType(long) * 2) ; 
     exp := exp + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int frequencyOfSmallest(int n,int arr[]){
    int mn=arr[0],freq=1 ;
    for(int i=1 ; i<n ; i++){
      if(arr[i]<mn){
        mn=arr[i];
        freq=1 ;
      }
      else if(arr[i]==mn)freq++;
    }
    return freq ;
  }
  public static void main(String[] args){
    int N=5 ;
    int arr[]={
      3,2,3,4,4 };
      System.out.println(frequencyOfSmallest(N,arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation frequencyOfSmallest( n : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var mn : int ; mn := arr[0+1] ;
    var freq : int ; freq := 1 ;
         var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] < mn) then (     mn := arr[i+1] ; 
     freq := 1 ) else     if (arr[i+1] = mn) then     freq := freq + 1 ; else skip ; )  ;     i := i + 1 ) ; 
     return freq );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     var arr : Sequence(int) ; arr := Sequence{3,2,3,4,4} ;
     OclFile["System.out"].println(frequencyOfSmallest(N, arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float areaOfKite(int d1,int d2){
    float area=(d1*d2)/2 ;
    return area ;
  }
  public static void main(String[] args){
    int d1=4,d2=6 ;
    System.out.println("Area of Kite="+areaOfKite(d1,d2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation areaOfKite( d1 : int, d2 : int) : double
  pre: true
  post: true
  activity: (     var area : double ; area := (d1 * d2) / 2 ;
     return area );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d1 : int ; d1 := 4 ;
    var d2 : int ; d2 := 6 ;
     OclFile["System.out"].println("Area of Kite=" + areaOfKite(d1, d2)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class CP {
  public static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(String s)throws FileNotFoundException {
      br=new BufferedReader(new InputStreamReader(new FileInputStream(s)));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
  static private long gcd(long a,long b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  static private void printArrayList(ArrayList<Object>al){
    for(Object i : al){
      System.out.print(i+" ");
    }
    System.out.println();
  }
  static private int digitSum(int n){
    int sum=0 ;
    while(n!=0){
      sum+=n % 10 ;
      n=n/10 ;
    }
    return sum ;
  }
  public static void main(String[] args){
    try {
      Scanner s=new Scanner(System.in);
      StringBuffer sb=new StringBuffer();
      String st=s.next();
      int k=s.nextInt();
      Set<Character>hs=new HashSet<>();
      for(char x : st.toCharArray()){
        hs.add(x);
      }
      if(st.length()<k){
        sb.append("impossible");
      }
      else {
        if(k<=hs.size()){
          sb.append("0\n");
        }
        else sb.append(k-hs.size());
      }
      System.out.println(sb);
    }
    catch(Exception e){
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CP {
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( s : String) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static    operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static    operation printArrayList( al : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     for (i : al) do ( (     OclFile["System.out"].print(i + " ") )  ) ; 
     OclFile["System.out"].println() );
  static    operation digitSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n /= 0) do (     sum := sum+(n mod 10) ; 
     n := n / 10 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
    var st : String ; st := s.getCurrent() ;
    var k : int ; k := s.getCurrent()->toInteger() ;
    var hs : Set(String) ; hs := Set{} ;
    for (x : st->characters()) do ( (     hs := hs->including(x) )  ) ; 
    if (st->size() < k) then (     sb := sb + StringLib.newString("impossible") ) else (     if (k <= hs->size()) then (     sb := sb + StringLib.newString("0\n") ) else     sb := sb + StringLib.newString((k)->char2byte() - hs->size()) ; ) ;  
    OclFile["System.out"].println(sb) ; 
 )   catch (e : ProgramException) do (     OclFile["System.out"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A_Tricky_Sum {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    while(q-->0){
      int n=sc.nextInt();
      long s=0 ;
      int x=(int)(Math.log(n)/Math.log(2));
      x++;
      s=-1*(long)Math.pow(2,x)+2+((long)n*(long)(n+1))/2-(long)Math.pow(2,x);
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Tricky_Sum {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
         while (q > 0) do (        q := q - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : long ; s := 0 ;
    var x : int ; x := ((n)->log() / (2)->log())->oclAsType(int) ;
    x := x + 1 ; 
    s := -1 * 2->pow(x)->oclAsType(long) + 2 + (n->oclAsType(long) * (n + 1)->oclAsType(long)) / 2 - 2->pow(x)->oclAsType(long) ; 
    OclFile["System.out"].println(s) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class javaapplication26 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int l=in.nextInt();
    int[] a=new int[l];
    for(int i=0 ; i<l ; i++){
      a[i]=in.nextInt();
      long n=a[i];
      long sum=(n*(n+1))/2,p=1 ;
      while(p<=n){
        sum-=(p*2);
        p*=2 ;
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class javaapplication26 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,l)->collect(0) ;
         var i : int ; i := 0 ; while i < l do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     var n : long ; n := a[i+1] ;
    var sum : long ; sum := (n * (n + 1)) / 2 ;
    var p : long ; p := 1 ;
    while (p <= n) do (     sum := sum-((p * 2)) ; 
     p := p*(2) ) ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    char ar[]=new char[26];
    for(int i=0 ; i<s.length(); i++){
      char ch=s.charAt(i);
      ar[ch-97]++;
    }
    int cntod=0 ;
    for(int i=0 ; i<26 ; i++){
      if((ar[i] % 2)!=0)cntod++;
    }
    if(cntod==0)System.out.println("First");
    else {
      if(cntod % 2==0){
        System.out.println("Second");
      }
      else {
        System.out.println("First");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
    var ar : Sequence(String) ; ar := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var ch : String ; ch := s->at(i+1) ;
     ar[(ch)->char2byte() - 97+1] := ar[(ch)->char2byte() - 97+1] + 1 )  ;     i := i + 1 ) ; 
    var cntod : int ; cntod := 0 ;
        var i : int ; i := 0 ; while i < 26 do ( (     if ((ar[i+1] mod 2) /= 0) then     cntod := cntod + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (cntod = 0) then     OclFile["System.out"].println("First") else (     if (cntod mod 2 = 0) then (     OclFile["System.out"].println("Second") ) else (     OclFile["System.out"].println("First") ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.math.BigInteger ;
import java.util.*;
public class Codechef {
  public static void main(String[] args)throws NumberFormatException,IOException {
    InputStreamReader inputStreamReader=new InputStreamReader(System.in);
    BufferedReader bufferedReader=new BufferedReader(inputStreamReader);
    PrintWriter writer=new PrintWriter(System.out);
    String str=bufferedReader.readLine();
    Map<Character,Integer>map=new HashMap<>();
    int oddCount=0 ;
    for(int i=0 ; i<str.length(); i++){
      char ch=str.charAt(i);
      if(map.containsKey(ch)){
        map.put(ch,map.get(ch)+1);
      }
      else {
        map.put(ch,1);
      }
    }
    for(Map.Entry<Character,Integer>entry : map.entrySet()){
      if(entry.getValue()% 2!=0){
        oddCount++;
      }
    }
    if(oddCount<=1 || oddCount % 2!=0){
      writer.println("First");
    }
    else {
      writer.println("Second");
    }
    writer.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStreamReader : OclFile ; inputStreamReader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(inputStreamReader) ;
    var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var str : String ; str := bufferedReader.readLine() ;
    var map : Map(String,int) ; map := Map{} ;
    var oddCount : int ; oddCount := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     var ch : String ; ch := str->at(i+1) ;
     if (map->keys()->includes(ch)) then (     map := map->union(Map{ch |-> map->at(ch) + 1}) ) else (     map := map->union(Map{ch |-> 1}) ) )  ;     i := i + 1 ) ; 
    for (entry : map->asSet()) do ( (     if (entry.getValue() mod 2 /= 0) then (     oddCount := oddCount + 1 ) else skip )  ) ; 
    if (oddCount <= 1 or oddCount mod 2 /= 0) then (     skip ) else (     skip ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int reverse(int n){
    int rev=0 ;
    while(n!=0){
      rev=(rev*10)+(n % 10);
      n/=10 ;
    }
    return rev ;
  }
  static void getSum(int n){
    n=reverse(n);
    int sumOdd=0,sumEven=0,c=1 ;
    while(n!=0){
      if(c % 2==0)sumEven+=n % 10 ;
      else sumOdd+=n % 10 ;
      n/=10 ;
      c++;
    }
    System.out.println("Sum odd="+sumOdd);
    System.out.println("Sum even="+sumEven);
  }
  public static void main(String args[]){
    int n=457892 ;
    getSum(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation reverse( n : int) : int
  pre: true
  post: true
  activity: (     var rev : int ; rev := 0 ;
     while (n /= 0) do (     rev := (rev * 10) + (n mod 10) ; 
     n := n/(10) ) ; 
     return rev );
  static   operation getSum( n : int) : void
  pre: true
  post: true
  activity: (     n := reverse(n) ; 
     var sumOdd : int ; sumOdd := 0 ;
    var sumEven : int ; sumEven := 0 ;
    var c : int ; c := 1 ;
    while (n /= 0) do (     if (c mod 2 = 0) then     sumEven := sumEven+(n mod 10) else     sumOdd := sumOdd+(n mod 10) ; ;  
     n := n/(10) ; 
     c := c + 1 ) ; 
    OclFile["System.out"].println("Sum odd=" + sumOdd) ; 
    OclFile["System.out"].println("Sum even=" + sumEven) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 457892 ;
     execute getSum(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void disp(int row_no,int block){
    System.out.print(row_no*block);
  }
  static int row(int ht,int h){
    return ht/h ;
  }
  static void calculate(int l,int w,int h,int a,int ht){
    int no_block=(4*a)/l ;
    int row_no ;
    if(h<w)row_no=row(ht,w);
    else row_no=row(ht,h);
    disp(row_no,no_block);
  }
  public static void main(String[] args){
    int l=50,w=20,h=35 ;
    int a=700 ;
    int ht=140 ;
    calculate(l,w,h,a,ht);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation disp( row_no : int, block : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(row_no * block) );
  static   operation row( ht : int, h : int) : int
  pre: true
  post: true
  activity: (     return ht / h );
  static   operation calculate( l : int, w : int, h : int, a : int, ht : int) : void
  pre: true
  post: true
  activity: (     var no_block : int ; no_block := (4 * a) / l ;
     var row_no : int ;
     if (h < w) then     row_no := row(ht, w) else     row_no := row(ht, h) ; ;  
     execute disp(row_no, no_block) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 50 ;
    var w : int ; w := 20 ;
    var h : int ; h := 35 ;
     var a : int ; a := 700 ;
     var ht : int ; ht := 140 ;
     execute calculate(l, w, h, a, ht) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String bin[]={
    "000","001","010","011","100","101","110","111" };
    static int maxFreq(String s){
      String binary="" ;
      for(int i=0 ; i<s.length(); i++){
        binary+=bin[s.charAt(i)-'0'];
      }
      binary=binary.substring(0,binary.length()-1);
      int count=1,prev=-1,i,j=0 ;
      for(i=binary.length()-1 ; i>=0 ; i--,j++)if(binary.charAt(i)=='1'){
        count=Math.max(count,j-prev);
        prev=j ;
      }
      return count ;
    }
    public static void main(String[] args){
      String octal="13" ;
      System.out.println(maxFreq(octal));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute bin : String := Sequence{"000","001","010","011","100","101","110","111"};
  static   operation maxFreq( s : String) : int
  pre: true
  post: true
  activity: (     var binary : String ; binary := "" ;
         var i : int ; i := 0 ; while i < s->size() do ( (     binary := binary+(bin[s->at(i+1) - ('0')->char2byte()+1]) )  ;     i := i + 1 ) ; 
    binary := binary.subrange(0+1,binary->size() - 1) ; 
    var count : int ; count := 1 ;
    var prev : int ; prev := -1 ;
    var i : int ;
    var j : int ; j := 0 ;
        i := binary->size() - 1 ; while i >= 0 do (     if (binary->at(i+1) = '1') then (     count := Set{count, j - prev}->max() ; 
     prev := j ) else skip ;  ;     i := i - 1 ;     j := j + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var octal : String ; octal := "13" ;
     OclFile["System.out"].println(maxFreq(octal)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isVowel(char c){
    return(c=='a' || c=='e' || c=='i' || c=='o' || c=='u');
  }
  static String encryptString(char[] s,int n,int k){
    int[] cv=new int[n];
    int[] cc=new int[n];
    if(isVowel(s[0]))cv[0]=1 ;
    else cc[0]=1 ;
    for(int i=1 ; i<n ; i++){
      cv[i]=cv[i-1]+(isVowel(s[i])==true ? 1 : 0);
      cc[i]=cc[i-1]+(isVowel(s[i])==true ? 0 : 1);
    }
    String ans="" ;
    int prod=0 ;
    prod=cc[k-1]*cv[k-1];
    ans+=String.valueOf(prod);
    for(int i=k ; i<s.length ; i++){
      prod=(cc[i]-cc[i-k])*(cv[i]-cv[i-k]);
      ans+=String.valueOf(prod);
    }
    return ans ;
  }
  public static void main(String[] args){
    String s="hello" ;
    int n=s.length();
    int k=2 ;
    System.out.print(encryptString(s.toCharArray(),n,k)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isVowel( c : String) : boolean
  pre: true
  post: true
  activity: (     return (c = 'a' or c = 'e' or c = 'i' or c = 'o' or c = 'u') );
  static   operation encryptString( s : Sequence(String), n : int, k : int) : String
  pre: true
  post: true
  activity: (     var cv : Sequence(int) ; cv := Integer.subrange(1,n)->collect(0) ;
     var cc : Sequence(int) ; cc := Integer.subrange(1,n)->collect(0) ;
    if (isVowel(s[0+1])) then     cv[0+1] := 1 else     cc[0+1] := 1 ; ;  
        var i : int ; i := 1 ; while i < n do ( (     cv[i+1] := cv[i - 1+1] + (if isVowel(s[i+1]) = true then 1 else 0 endif) ; 
     cc[i+1] := cc[i - 1+1] + (if isVowel(s[i+1]) = true then 0 else 1 endif) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "" ;
    var prod : int ; prod := 0 ;
    prod := cc[k - 1+1] * cv[k - 1+1] ; 
    ans := ans+(((prod) + "")) ; 
        var i : int ; i := k ; while i < s->size() do ( (     prod := (cc[i+1] - cc[i - k+1]) * (cv[i+1] - cv[i - k+1]) ; 
     ans := ans+(((prod) + "")) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "hello" ;
     var n : int ; n := s->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].print(encryptString(s->characters(), n, k) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float harmonicMean(int arr[],int freq[],int n){
    float sum=0,frequency_sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum=sum+(float)freq[i]/arr[i];
      frequency_sum=frequency_sum+freq[i];
    }
    return(frequency_sum/sum);
  }
  public static void main(String args[]){
    int num[]={
      13,14,15,16,17 };
      int freq[]={
        2,5,13,7,3 };
        int n=num.length ;
        System.out.println(harmonicMean(num,freq,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation harmonicMean( arr : Sequence(int), freq : Sequence(int), n : int) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
    var frequency_sum : double ; frequency_sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum + freq[i+1]->oclAsType(double) / arr[i+1] ; 
     frequency_sum := frequency_sum + freq[i+1] )  ;     i := i + 1 ) ; 
     return (frequency_sum / sum) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : Sequence(int) ; num := Sequence{13,14,15,16,17} ;
     var freq : Sequence(int) ; freq := Sequence{2,5,13,7,3} ;
     var n : int ; n := num->size() ;
     OclFile["System.out"].println(harmonicMean(num, freq, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float polyarea(float n,float a){
    if(a<0 && n<0)return-1 ;
    float A=(a*a*n)/(float)(4*Math.tan((180/n)*3.14159/180));
    return A ;
  }
  public static void main(String[] args){
    float a=9,n=6 ;
    System.out.println(polyarea(n,a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation polyarea( n : double, a : double) : double
  pre: true
  post: true
  activity: (     if (a < 0 & n < 0) then     return -1 else skip ; 
     var A : double ; A := (a * a * n) / (4 * ((180 / n) * 3.14159 / 180)->tan())->oclAsType(double) ;
     return A );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 9 ;
    var n : double ; n := 6 ;
     OclFile["System.out"].println(polyarea(n, a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Improve {
  static int calculateSquareSum(int n){
    if(n<=0)return 0 ;
    int fibo[]=new int[n+1];
    fibo[0]=0 ;
    fibo[1]=1 ;
    int sum=(fibo[0]*fibo[0])+(fibo[1]*fibo[1]);
    for(int i=2 ; i<=n ; i++){
      fibo[i]=fibo[i-1]+fibo[i-2];
      sum+=(fibo[i]*fibo[i]);
    }
    return sum ;
  }
  public static void main(String args[]){
    int n=6 ;
    System.out.println("Sum of squares of Fibonacci numbers is : "+calculateSquareSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class Improve {
  static   operation calculateSquareSum( n : int) : int
  pre: true
  post: true
  activity: (     if (n <= 0) then     return 0 else skip ; 
     var fibo : Sequence(int) ; fibo := Integer.subrange(1,n + 1)->collect(0) ;
    fibo[0+1] := 0 ; 
    fibo[1+1] := 1 ; 
    var sum : int ; sum := (fibo[0+1] * fibo[0+1]) + (fibo[1+1] * fibo[1+1]) ;
        var i : int ; i := 2 ; while i <= n do ( (     fibo[i+1] := fibo[i - 1+1] + fibo[i - 2+1] ; 
     sum := sum+((fibo[i+1] * fibo[i+1])) )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println("Sum of squares of Fibonacci numbers is : " + calculateSquareSum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DistributedPeople {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=input.nextInt();
    }
    int ans=0 ;
    for(int i=1 ; i<n-1 ; i++){
      if(arr[i]==0 && arr[i-1]==1 && arr[i+1]==1){
        ans++;
        arr[i+1]=0 ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class DistributedPeople {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < n - 1 do ( (     if (arr[i+1] = 0 & arr[i - 1+1] = 1 & arr[i + 1+1] = 1) then (     ans := ans + 1 ; 
     arr[i + 1+1] := 0 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int xorOfArray(int arr[],int n){
    int xor_arr=0 ;
    for(int i=0 ; i<n ; i++){
      xor_arr=xor_arr ^ arr[i];
    }
    return xor_arr ;
  }
  public static void main(String[] args){
    int arr[]={
      3,9,12,13,15 };
      int n=arr.length ;
      System.out.println(xorOfArray(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation xorOfArray( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var xor_arr : int ; xor_arr := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     xor_arr := MathLib.bitwiseXor(xor_arr,arr[i+1]) )  ;     i := i + 1 ) ; 
     return xor_arr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,9,12,13,15} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(xorOfArray(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int TEN=10 ;
  static void updateFreq(int n,int[] freq){
    while(n>0){
      int digit=n % TEN ;
      freq[digit]++;
      n/=TEN ;
    }
  }
  static boolean areAnagrams(int a,int b){
    int[] freqA=new int[TEN];
    int[] freqB=new int[TEN];
    updateFreq(a,freqA);
    updateFreq(b,freqB);
    for(int i=0 ; i<TEN ; i++){
      if(freqA[i]!=freqB[i])return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    int a=204,b=240 ;
    if(areAnagrams(a,b))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute TEN : int := 10;
  static   operation updateFreq( n : int, freq : Sequence(int)) : void
  pre: true
  post: true
  activity: (     while (n > 0) do (     var digit : int ; digit := n mod TEN ;
     freq[digit+1] := freq[digit+1] + 1 ; 
     n := n/(TEN) ) );
  static   operation areAnagrams( a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     var freqA : Sequence(int) ; freqA := Integer.subrange(1,TEN)->collect(0) ;
     var freqB : Sequence(int) ; freqB := Integer.subrange(1,TEN)->collect(0) ;
    execute updateFreq(a, freqA) ; 
    execute updateFreq(b, freqB) ; 
        var i : int ; i := 0 ; while i < TEN do ( (     if (freqA[i+1] /= freqB[i+1]) then     return false else skip )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 204 ;
    var b : int ; b := 240 ;
     if (areAnagrams(a, b)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long evenFib(int n){
    if(n<1)return n ;
    if(n==1)return 2 ;
    return((4*evenFib(n-1))+evenFib(n-2));
  }
  public static void main(String[] args){
    int n=7 ;
    System.out.println(evenFib(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation evenFib( n : int) : long
  pre: true
  post: true
  activity: (     if (n < 1) then     return n else skip ; 
     if (n = 1) then     return 2 else skip ; 
     return ((4 * evenFib(n - 1)) + evenFib(n - 2)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     OclFile["System.out"].println(evenFib(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minOperations(int N){
    double x=Math.log(N)/Math.log(2);
    int ans=(int)(Math.ceil(x));
    return ans ;
  }
  public static void main(String[] args){
    int N=10 ;
    System.out.println(minOperations(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minOperations( N : int) : int
  pre: true
  post: true
  activity: (     var x : double ; x := (N)->log() / (2)->log() ;
     var ans : int ; ans := ((x)->ceil())->oclAsType(int) ;
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 10 ;
     OclFile["System.out"].println(minOperations(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[] t=new long[N];
    long[] a=new long[N];
    for(int i=0 ; i<N ; i++){
      t[i]=sc.nextLong();
      a[i]=sc.nextLong();
    }
    long[] dp=new long[N];
    dp[0]=1 ;
    for(int i=1 ; i<N ; i++){
      long takahashi=(t[i-1]*dp[i-1]+t[i]-1)/t[i];
      long aoki=(a[i-1]*dp[i-1]+a[i]-1)/a[i];
      dp[i]=Math.max(takahashi,aoki);
    }
    System.out.println((t[N-1]+a[N-1])*dp[N-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var t : Sequence(long) ; t := Integer.subrange(1,N)->collect(0) ;
    var a : Sequence(long) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     t[i+1] := sc.getCurrent()->toLong() ; 
     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var dp : Sequence(long) ; dp := Integer.subrange(1,N)->collect(0) ;
    dp[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < N do ( (     var takahashi : long ; takahashi := (t[i - 1+1] * dp[i - 1+1] + t[i+1] - 1) / t[i+1] ;
     var aoki : long ; aoki := (a[i - 1+1] * dp[i - 1+1] + a[i+1] - 1) / a[i+1] ;
     dp[i+1] := Set{takahashi, aoki}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((t[N - 1+1] + a[N - 1+1]) * dp[N - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=false ;
  private static PrintWriter _err=new PrintWriter(System.err);
  private void solve(Scanner sc,PrintWriter out){
    int N=sc.nextInt();
    long[] count=new long[2];
    for(int i=0 ; i<N ; ++i){
      int T=sc.nextInt();
      int A=sc.nextInt();
      if(i==0){
        count[0]=T ;
        count[1]=A ;
        continue ;
      }
      long n=Math.max((count[0]+T-1)/T,(count[1]+A-1)/A);
      count[0]=T*n ;
      count[1]=A*n ;
    }
    out.println((count[0]+count[1]));
  }
  private long C(long n,long r){
    long res=1 ;
    for(long i=n ; i>n-r ; --i){
      res*=i ;
    }
    for(long i=r ; i>1 ; --i){
      res/=i ;
    }
    return res ;
  }
  private long P(long n,long r){
    long res=1 ;
    for(long i=n ; i>n-r ; --i){
      res*=i ;
    }
    return res ;
  }
  public static void main(String[] args){
    long S=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    new Main().solve(sc,out);
    out.flush();
    long G=System.currentTimeMillis();
    if(elapsed){
      _err.println((G-S)+"ms");
    }
    _err.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := false;
  static   attribute _err : OclFile := OclFile.newOclFile_Write(OclFile["System.err"]);
   operation solve( sc : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.nextInt() ;
     var count : Sequence(long) ; count := Integer.subrange(1,2)->collect(0) ;
         var i : int ; i := 0 ; while i < N do ( (     var T : int ; T := sc.nextInt() ;
     var A : int ; A := sc.nextInt() ;
    if (i = 0) then (     count[0+1] := T ; 
     count[1+1] := A ; 
     continue ) else skip ; 
    var n : long ; n := Set{(count[0+1] + T - 1) / T, (count[1+1] + A - 1) / A}->max() ;
    count[0+1] := T * n ; 
    count[1+1] := A * n ; 
 )  ;     i := i + 1 ) ; 
     out.println((count[0+1] + count[1+1])) );
   operation C( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res*(i) )  ;     i := i - 1 ) ; 
         var i : long ; i := r ; while i > 1 do ( (     res := res/(i) )  ;     i := i - 1 ) ; 
     return res );
   operation P( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res*(i) )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    Main.newMain().solve(sc, out) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class codeforces {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if((n &(n-1))==0)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseAnd(n,(n - 1))) = 0) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] $){
    Scanner sc=new Scanner(in);
    int n=sc.nextInt();
    long[] T=new long[n];
    long[] A=new long[n];
    for(int i=0 ; i<n ; i++){
      T[i]=sc.nextInt();
      A[i]=sc.nextInt();
    }
    for(int i=1 ; i<n ; i++){
      if(A[i-1]>A[i] || T[i-1]>T[i]){
        long k=max(ceil(A[i-1],A[i]),ceil(T[i-1],T[i]));
        A[i]*=k ;
        T[i]*=k ;
      }
    }
    out.println(A[n-1]+T[n-1]);
  }
  static long ceil(long a,long b){
    return a % b==0 ? a/b : a/b+1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var T : Sequence(long) ; T := Integer.subrange(1,n)->collect(0) ;
    var A : Sequence(long) ; A := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     T[i+1] := sc.getCurrent()->toInteger() ; 
     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (A[i - 1+1] > A[i+1] or T[i - 1+1] > T[i+1]) then (     var k : long ; k := max(ceil(A[i - 1+1], A[i+1]), ceil(T[i - 1+1], T[i+1])) ;
     A[i+1] := A[i+1]*(k) ; 
     T[i+1] := T[i+1]*(k) ) else skip )  ;     i := i + 1 ) ; 
    out.println(A[n - 1+1] + T[n - 1+1]) ; 
 );
  static   operation ceil( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return if a mod b = 0 then a / b else a / b + 1 endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static Scanner sc=new Scanner(System.in);
  public static void main(String[] args)throws Exception {
    int n=sc.nextInt();
    long t=sc.nextLong();
    long a=sc.nextLong();
    long nt=0,na=0 ;
    for(int i=1 ; i<n ; i++){
      nt=sc.nextLong();
      na=sc.nextLong();
      long m=Math.max((t-1)/nt+1,(a-1)/na+1);
      t=nt*m ;
      a=na*m ;
    }
    System.out.println(t+a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var t : long ; t := sc.getCurrent()->toLong() ;
    var a : long ; a := sc.getCurrent()->toLong() ;
    var nt : long ; nt := 0 ;
    var na : long ; na := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     nt := sc.getCurrent()->toLong() ; 
     na := sc.getCurrent()->toLong() ; 
    var m : long ; m := Set{(t - 1) / nt + 1, (a - 1) / na + 1}->max() ;
    t := nt * m ; 
    a := na * m ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(t + a) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class GFG {
  static String check(int k,int d0,int d1){
    int s=(2*(d0+d1))% 10+(4*(d0+d1))% 10+(8*(d0+d1))% 10+(6*(d0+d1))% 10 ;
    int a=(k-3)% 4 ;
    int x=0 ;
    switch(a){
      case 0 : x=0 ;
      break ;
      case 1 : x=(2*(d0+d1))% 10 ;
      break ;
      case 2 : x=(2*(d0+d1))% 10+(4*(d0+d1))% 10 ;
      break ;
      case 3 : x=(2*(d0+d1))% 10+(4*(d0+d1))% 10+(8*(d0+d1))% 10 ;
      break ;
    }
    int sum=d0+d1+(((k-3)/4)*s+x);
    if(sum % 3==0)return "YES" ;
    return "NO" ;
  }
  public static void main(String[] args){
    int k,d0,d1 ;
    k=13 ;
    d0=8 ;
    d1=1 ;
    System.out.println(check(k,d0,d1));
    k=5 ;
    d0=3 ;
    d1=4 ;
    System.out.println(check(k,d0,d1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( k : int, d0 : int, d1 : int) : String
  pre: true
  post: true
  activity: (     var s : int ; s := (2 * (d0 + d1)) mod 10 + (4 * (d0 + d1)) mod 10 + (8 * (d0 + d1)) mod 10 + (6 * (d0 + d1)) mod 10 ;
     var a : int ; a := (k - 3) mod 4 ;
    var x : int ; x := 0 ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (a) ; 
       if _switchval = 0 then
     x := 0 ; 
    break 
   else skip ;
       if _switchval = 1 then
     x := (2 * (d0 + d1)) mod 10 ; 
    break 
   else skip ;
       if _switchval = 2 then
     x := (2 * (d0 + d1)) mod 10 + (4 * (d0 + d1)) mod 10 ; 
    break 
   else skip ;
       if _switchval = 3 then
     x := (2 * (d0 + d1)) mod 10 + (4 * (d0 + d1)) mod 10 + (8 * (d0 + d1)) mod 10 ; 
    break 
   else skip ;
 )
    var sum : int ; sum := d0 + d1 + (((k - 3) / 4) * s + x) ;
    if (sum mod 3 = 0) then     return "YES" else skip ; 
    return "NO" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ;
    var d0 : int ;
    var d1 : int ;
     k := 13 ; 
    d0 := 8 ; 
    d1 := 1 ; 
    OclFile["System.out"].println(check(k, d0, d1)) ; 
    k := 5 ; 
    d0 := 3 ; 
    d1 := 4 ; 
    OclFile["System.out"].println(check(k, d0, d1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int val(char c){
    if(c>='0' && c<='9')return(int)c-'0' ;
    else return(int)c-'A'+10 ;
  }
  static int toDeci(String str,int base){
    int len=str.length();
    int power=1 ;
    int num=0 ;
    int i ;
    for(i=len-1 ; i>=0 ; i--){
      if(val(str.charAt(i))>=base){
        return-1 ;
      }
      num+=val(str.charAt(i))*power ;
      power=power*base ;
    }
    return num ;
  }
  static void checkCorrespond(String[] str,int x){
    int counter=0 ;
    int n=str.length ;
    for(int i=0 ; i<n ; i++){
      for(int j=2 ; j<=36 ; j++){
        if(toDeci(str[i],j)==x){
          counter++;
          break ;
        }
      }
    }
    if(counter==n)System.out.print("YES"+"\n");
    else System.out.print("NO"+"\n");
  }
  public static void main(String[] args){
    int x=16 ;
    String[] str={
      "10000","20","16" };
      checkCorrespond(str,x);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation val( c : String) : int
  pre: true
  post: true
  activity: (     if (c >= '0' & c <= '9') then     return c->oclAsType(int) - ('0')->char2byte() else     return c->oclAsType(int) - ('A')->char2byte() + 10 );
  static   operation toDeci( str : String, base : int) : int
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     var power : int ; power := 1 ;
    var num : int ; num := 0 ;
    var i : int ;
        i := len - 1 ; while i >= 0 do ( (     if (val(str->at(i+1)) >= base) then (     return -1 ) else skip ; 
     num := num+(val(str->at(i+1)) * power) ; 
     power := power * base )  ;     i := i - 1 ) ; 
    return num 
 );
  static   operation checkCorrespond( str : Sequence(String), x : int) : void
  pre: true
  post: true
  activity: (     var counter : int ; counter := 0 ;
     var n : int ; n := str->size() ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 2 ; while j <= 36 do ( (     if (toDeci(str[i+1], j) = x) then (     counter := counter + 1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (counter = n) then     OclFile["System.out"].print("YES" + "\n") ; else     OclFile["System.out"].print("NO" + "\n") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 16 ;
     var str : Sequence(String) ; str := Sequence{"10000","20","16"} ;
     execute checkCorrespond(str, x) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Practice {
  static Scanner scn ;
  static StringBuilder sb ;
  public static void main(String[] ScoobyDoobyDo){
    scn=new Scanner(System.in);
    sb=new StringBuilder();
    int t=scn.nextInt();
    for(int tests=0 ; tests<t ; tests++)solve();
    System.out.println(sb);
  }
  public static void solve(){
    int l1=scn.nextInt(),r1=scn.nextInt();
    int l2=scn.nextInt(),r2=scn.nextInt();
    for(int i=l1 ; i<=r1 ; i++){
      for(int j=l2 ; j<=r2 ; j++){
        if(i!=j){
          sb.append(i+" "+j+"\n");
          return ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   attribute scn : OclFile;
  static   attribute sb : String;
  static   operation main( ScoobyDoobyDo : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scn := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     sb := StringLib.newString() ; 
    var t : int ; t := scn.getCurrent()->toInteger() ;
        var tests : int ; tests := 0 ; while tests < t do (     execute solve() ;  ;     tests := tests + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var l1 : int ; l1 := scn.getCurrent()->toInteger() ;
    var r1 : int ; r1 := scn.getCurrent()->toInteger() ;
     var l2 : int ; l2 := scn.getCurrent()->toInteger() ;
    var r2 : int ; r2 := scn.getCurrent()->toInteger() ;
         var i : int ; i := l1 ; while i <= r1 do ( (         var j : int ; j := l2 ; while j <= r2 do ( (     if (i /= j) then (     sb := sb + StringLib.newString(i + " " + j + "\n") ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t--!=0){
      long l1=s.nextLong();
      long r1=s.nextLong();
      long l2=s.nextLong();
      long r2=s.nextLong();
      long min=Math.min(l1,r1);
      long max=Math.max(l2,r2);
      if(min==max){
        System.out.println(Math.max(l1,r1)+" "+Math.max(l2,r2));
      }
      else {
        System.out.println(min+" "+max);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var l1 : long ; l1 := s.getCurrent()->toLong() ;
     var r1 : long ; r1 := s.getCurrent()->toLong() ;
    var l2 : long ; l2 := s.getCurrent()->toLong() ;
    var r2 : long ; r2 := s.getCurrent()->toLong() ;
    var min : long ; min := Set{l1, r1}->min() ;
    var max : long ; max := Set{l2, r2}->max() ;
    if (min = max) then (     OclFile["System.out"].println(Set{l1, r1}->max() + " " + Set{l2, r2}->max()) ) else (     OclFile["System.out"].println(min + " " + max) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static final int N=9 ;
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    char c[]=new char[N];
    String end="123456780" ;
    String puzzle="" ;
    int index[]={
      1,-1,-3,3 };
      HashMap<String,Integer>hash=new HashMap<String,Integer>();
      Queue<String>queue=new ArrayDeque<String>();
      for(int i=0 ; i<N ; i++){
        c[i]+=(char)(sc.nextInt()+48);
        puzzle+=c[i];
      }
      queue.add(puzzle);
      hash.put(puzzle,0);
      while(! queue.isEmpty()){
        String comfirm=queue.remove();
        if(comfirm.equals(end)){
          System.out.println(hash.get(comfirm));
          break ;
        }
        StringBuffer s=new StringBuffer(comfirm);
        int vacancy=s.indexOf("0");
        for(int i=0 ; i<4 ; i++){
          if(vacancy+index[i]>=0 && vacancy+index[i]<N){
            if(!((index[i]==-1)&&((index[i]+vacancy)% 3==2))&& !((index[i]==1)&&((index[i]+vacancy)% 3==0))){
              s.setCharAt(vacancy,s.charAt(vacancy+index[i]));
              s.setCharAt(vacancy+index[i],'0');
              if(! hash.containsKey(s.toString())){
                queue.add(s.toString());
                hash.put(s.toString(),hash.get(comfirm)+1);
              }
              s.setCharAt(vacancy+index[i],s.charAt(vacancy));
              s.setCharAt(vacancy,'0');
            }
          }
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute N : int := 9;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : Sequence(String) ; c := Integer.subrange(1,N)->collect(0) ;
    var end : String ; end := "123456780" ;
    var puzzle : String ; puzzle := "" ;
    var index : Sequence(int) ; index := Sequence{1,-1,-3,3} ;
    var hash : Map(String,int) ; hash := Map{} ;
    var queue : Sequence(String) ; queue := ArrayDeque<String>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < N do ( (     c[i+1] := c[i+1]+((sc.getCurrent()->toInteger() + 48)->oclAsType(String)) ; 
     puzzle := puzzle+(c[i+1]) )  ;     i := i + 1 ) ; 
    queue := queue->including(puzzle) ; 
    hash := hash->union(Map{puzzle |-> 0}) ; 
    while (not(queue->isEmpty())) do (     var comfirm : String ; comfirm := queue.remove() ;
     if (comfirm = end) then (     OclFile["System.out"].println(hash->at(comfirm)) ; 
     break ) else skip ; 
    var s : String ; s := StringLib.newString(comfirm) ;
    var vacancy : int ; vacancy := s->indexOf("0")-1 ;
        var i : int ; i := 0 ; while i < 4 do ( (     if (vacancy + index[i+1] >= 0 & vacancy + index[i+1] < N) then (     if (not(((index[i+1] = -1) & ((index[i+1] + vacancy) mod 3 = 2))) & not(((index[i+1] = 1) & ((index[i+1] + vacancy) mod 3 = 0)))) then (     s := s.setAt(vacancy+1, s->at(vacancy + index[i+1]+1)) ; 
     s := s.setAt(vacancy + index[i+1]+1, '0') ; 
    if (not(hash->keys()->includes(s+""))) then (     queue := queue->including(s+"") ; 
     hash := hash->union(Map{s+"" |-> hash->at(comfirm) + 1}) ) else skip ; 
    s := s.setAt(vacancy + index[i+1]+1, s->at(vacancy+1)) ; 
    s := s.setAt(vacancy+1, '0') ; 
 ) else skip ) else skip )  ;     i := i + 1 ) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p171 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p171().run());
  }
  private static final int LENGTH=20 ;
  private static final int BASE=10 ;
  private static final int MODULUS=Library.pow(10,9);
  public String run(){
    int MAX_SQR_DIGIT_SUM=(BASE-1)*(BASE-1)*LENGTH ;
    long[][] sum=new long[LENGTH+1][MAX_SQR_DIGIT_SUM+1];
    long[][] count=new long[LENGTH+1][MAX_SQR_DIGIT_SUM+1];
    count[0][0]=1 ;
    for(int i=1 ; i<=LENGTH ; i++){
      for(int j=0 ; j<BASE ; j++){
        for(int k=0 ; k+j*j<=MAX_SQR_DIGIT_SUM ; k++){
          sum[i][k+j*j]=(sum[i][k+j*j]+sum[i-1][k]+Library.powMod(BASE,i-1,MODULUS)*j % MODULUS*count[i-1][k])% MODULUS ;
          count[i][k+j*j]=(count[i][k+j*j]+count[i-1][k])% MODULUS ;
        }
      }
    }
    long s=0 ;
    for(int i=1 ; i*i<=MAX_SQR_DIGIT_SUM ; i++)s=(s+sum[LENGTH][i*i])% MODULUS ;
    return String.format("%09d",s);
  }
}
------------------------------------------------------------
OCL File:
---------
class p171 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p171.newp171().run()) );
  static    attribute LENGTH : int := 20;
  static    attribute BASE : int := 10;
  static    attribute MODULUS : int := Library.pow(10, 9);
   operation run() : String
  pre: true
  post: true
  activity: (     var MAX_SQR_DIGIT_SUM : int ; MAX_SQR_DIGIT_SUM := (BASE - 1) * (BASE - 1) * LENGTH ;
     var sum : Sequence(Sequence(long)) ; sum := Integer.subrange(1,LENGTH + 1)->collect(Integer.subrange(1,MAX_SQR_DIGIT_SUM + 1)->collect(0)) ;
    var count : Sequence(Sequence(long)) ; count := Integer.subrange(1,LENGTH + 1)->collect(Integer.subrange(1,MAX_SQR_DIGIT_SUM + 1)->collect(0)) ;
    count[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= LENGTH do ( (         var j : int ; j := 0 ; while j < BASE do ( (         var k : int ; k := 0 ; while k + j * j <= MAX_SQR_DIGIT_SUM do ( (     sum[i+1][k + j * j+1] := (sum[i+1][k + j * j+1] + sum[i - 1+1][k+1] + Library.powMod(BASE, i - 1, MODULUS) * j mod MODULUS * count[i - 1+1][k+1]) mod MODULUS ; 
     count[i+1][k + j * j+1] := (count[i+1][k + j * j+1] + count[i - 1+1][k+1]) mod MODULUS )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var s : long ; s := 0 ;
        var i : int ; i := 1 ; while i * i <= MAX_SQR_DIGIT_SUM do (     s := (s + sum[LENGTH+1][i * i+1]) mod MODULUS ;  ;     i := i + 1 ) ; 
    return StringLib.format("%09d",Sequence{s}) 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] d=new int[n];
    Arrays.setAll(d,i->sc.nextInt());
    Arrays.sort(d);
    System.out.println(d[n/2]-d[n/2-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
setAll(d, lambda i : OclAny in sc.getCurrent()->toInteger()) ; 
    d := d->sort() ; 
    OclFile["System.out"].println(d[n / 2+1] - d[n / 2 - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException,InterruptedException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    Arrays.sort(a);
    int mid=a[(n-1)/2];
    int midone=a[((n-1)/2)+1];
    out.println(midone-mid);
    out.flush();
  }
}
class Scanner {
  StringTokenizer st ;
  BufferedReader br ;
  public Scanner(InputStream system){
    br=new BufferedReader(new InputStreamReader(system));
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String nextLine()throws IOException {
    return br.readLine();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public char nextChar()throws IOException {
    return next().charAt(0);
  }
  public Long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
  public void waitForInput()throws InterruptedException {
    Thread.sleep(3000);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var mid : int ; mid := a[(n - 1) / 2+1] ;
    var midone : int ; midone := a[((n - 1) / 2) + 1+1] ;
    skip ; 
    skip ; 
 );
}
class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( system : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(system);
    return self );
  operation initialise( system : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(system)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
   operation waitForInput() : void
  pre: true
  post: true
  activity: (     OclProcess.sleep(3000) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class pre598 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 boolean isFill(boolean flag[]){
    boolean f=true ;
    for(int i=1 ; i<flag.length ; i++){
      f &=flag[i];
      if(! f)return false ;
    }
    return true ;
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int n=obj.nextInt(),point=0 ;
    boolean flag[]=new boolean[n+1];
    Arrays.fill(flag,false);
    for(int i=0 ; i<=9000000 ; i++){
      point=(point+i)% n ;
      flag[point+1]=true ;
      if(isFill(flag)){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre598 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation isFill( flag : Sequence(boolean)) : boolean
  pre: true
  post: true
  activity: (     var f : boolean ; f := true ;
         var i : int ; i := 1 ; while i < flag->size() do ( (     f := MathLib.bitwiseAnd(f, flag[i+1]) ; 
     if (not(f)) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var n : int ; n := obj.nextInt() ;
    var point : int ; point := 0 ;
    var flag : Sequence(boolean) ; flag := Integer.subrange(1,n + 1)->collect(false) ;
    flag := flag->collect(false) ; 
        var i : int ; i := 0 ; while i <= 9000000 do ( (     point := (point + i) mod n ; 
     flag[point + 1+1] := true ; 
     if (isFill(flag)) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.io.BufferedOutputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    try(BufferedInputStream in=new BufferedInputStream(System.in);
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out))){
      Scanner sc=new Scanner(in);
      int n=sc.nextInt();
      int[] vs=new int[n];
      for(int i=0 ; i<vs.length ; i++)vs[i]=sc.nextInt();
      Arrays.sort(vs);
      out.println(vs[vs.length/2]-vs[vs.length/2-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
 (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var vs : Sequence(int) ; vs := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < vs->size() do (     vs[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    vs := vs->sort() ; 
    skip ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.lang.reflect.Array ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static final int MAX=100100 ;
  InputStream in=System.in ;
  PrintStream out=System.out ;
  public void _main(String[] args){
    Scanner sc=new Scanner(in);
    int N=sc.nextInt();
    int d[]=new int[N];
    for(int i=0 ; i<N ; i++)d[i]=sc.nextInt();
    Arrays.sort(d);
    if((N & 1)==1){
      out.println("0");
      return ;
    }
    int mid=N/2 ;
    out.println(d[mid]-d[mid-1]);
  }
  public static void main(String[] args){
    new Main()._main(args);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 100100;
   attribute in : OclFile := OclFile["System.in"];
   attribute out : OclFile := OclFile["System.out"];
   operation _main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var d : Sequence(int) ; d := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     d[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    d := d->sort() ; 
    if ((MathLib.bitwiseAnd(N,1)) = 1) then (     skip ; 
     return ) else skip ; 
    var mid : int ; mid := N / 2 ;
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain()._main(args) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int[] n=new int[in.nextInt()];
    for(int i=0 ; i<n.length ; i++){
      n[i]=in.nextInt();
    }
    Arrays.sort(n);
    final int left=n[n.length/2-1];
    final int right=n[n.length/2];
    if(left==right){
      System.out.println(0);
      return ;
    }
    System.out.println(right-left);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var n : Sequence(int) ; n := Integer.subrange(1,in.getCurrent()->toInteger())->collect(0) ;
        var i : int ; i := 0 ; while i < n->size() do ( (     n[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    n := n->sort() ; 
    var left : int ; left := n[n->size() / 2 - 1+1] ;
    var right : int ; right := n[n->size() / 2+1] ;
    if (left = right) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    OclFile["System.out"].println(right - left) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    Set<Integer>S=new HashSet<>();
    int q=Integer.parseInt(in.next());
    for(int i=0 ; i<q ; i++){
      int odr=Integer.parseInt(in.next());
      if(odr==0){
        int x=Integer.parseInt(in.next());
        S.add(x);
        out.println(S.size());
      }
      else if(odr==1){
        int x=Integer.parseInt(in.next());
        out.println((S.contains(x))? 1 : 0);
      }
      else {
        int x=Integer.parseInt(in.next());
        S.remove(x);
      }
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var S : Set(int) ; S := Set{} ;
    var q : int ; q := (in.getCurrent())->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var odr : int ; odr := (in.getCurrent())->toInteger() ;
     if (odr = 0) then (     var x : int ; x := (in.getCurrent())->toInteger() ;
     S := S->including(x) ; 
     skip ) else     if (odr = 1) then (     var x : int ; x := (in.getCurrent())->toInteger() ;
     skip ) else (     var x : int ; x := (in.getCurrent())->toInteger() ;
     S := S->excludingAt(x+1) ) ;  )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B770 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char[] S=in.next().toCharArray();
    long maxNumber=Long.parseLong(new String(S));
    long max=sumOfDigits(maxNumber);
    S[S.length-1]='9' ;
    for(int pos=S.length-2 ; pos>=0 ; pos--){
      if(S[pos]!='0'){
        S[pos]--;
        long number=Long.parseLong(new String(S));
        int sum=sumOfDigits(number);
        if(sum>max){
          max=sum ;
          maxNumber=number ;
        }
      }
      S[pos]='9' ;
    }
    System.out.println(maxNumber);
  }
  static int sumOfDigits(long number){
    int result=0 ;
    while(number!=0){
      result+=number % 10 ;
      number/=10 ;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B770 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : Sequence(String) ; S := in.getCurrent()->characters() ;
    var maxNumber : long ; maxNumber := (StringLib.newString(S))->toLong() ;
    var max : long ; max := sumOfDigits(maxNumber) ;
    S[S->size() - 1+1] := '9' ; 
        var pos : int ; pos := S->size() - 2 ; while pos >= 0 do ( (     if (S[pos+1] /= '0') then (     S[pos+1] := S[pos+1] - 1 ; 
     var number : long ; number := (StringLib.newString(S))->toLong() ;
     var sum : int ; sum := sumOfDigits(number) ;
     if (sum > max) then (     max := sum ; 
     maxNumber := number ) else skip ) else skip ; 
     S[pos+1] := '9' )  ;     pos := pos - 1 ) ; 
    OclFile["System.out"].println(maxNumber) ; 
 );
  static   operation sumOfDigits( number : long) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     while (number /= 0) do (     result := result+(number mod 10) ; 
     number := number/(10) ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  static Scanner InData=new Scanner(System.in);
  static HashSet<Integer>S=new HashSet<Integer>();
  public static void main(String[] args){
    getQuery();
  }
  private static void getQuery(){
    int qNum=InData.nextInt();
    int qType,qVal ;
    for(int indexOfQuery=0 ; indexOfQuery<qNum ; indexOfQuery++){
      qType=InData.nextInt();
      qVal=InData.nextInt();
      ;
      doQuery(qType,qVal);
    }
  }
  private static void doQuery(int type,int val){
    switch(type){
      case 0 : S.add(val);
      System.out.println(S.size());
      break ;
      case 1 : System.out.println(S.contains(val)? 1 : 0);
      break ;
      case 2 : S.remove(val);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute InData : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute S : Set(int) := Set{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute getQuery() );
  static   operation getQuery() : void
  pre: true
  post: true
  activity: (     var qNum : int ; qNum := InData.getCurrent()->toInteger() ;
     var qType : int ;
    var qVal : int ;
         var indexOfQuery : int ; indexOfQuery := 0 ; while indexOfQuery < qNum do ( (     qType := InData.getCurrent()->toInteger() ; 
     qVal := InData.getCurrent()->toInteger() ; 
     execute doQuery(qType, qVal) )  ;     indexOfQuery := indexOfQuery + 1 ) );
  static   operation doQuery( type : int, val : int) : void
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (type) ; 
       if _switchval = 0 then
     S := S->including(val) ; 
    OclFile["System.out"].println(S->size()) ; 
    break 
   else skip ;
       if _switchval = 1 then
     OclFile["System.out"].println(if S->includes(val) then 1 else 0 endif) ; 
    break 
   else skip ;
       if _switchval = 2 then
     S := S->excludingFirst(val) ; 
   else skip ;
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    HashSet<Integer>list=new HashSet<Integer>();
    for(int i=0 ; i<n ; i++){
      int a=scan.nextInt();
      int b=scan.nextInt();
      if(a==0){
        list.add(b);
        System.out.println(list.size());
      }
      else if(a==1){
        System.out.println(list.contains(b)? "1" : "0");
      }
      else if(a==2){
        list.remove(b);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
     var list : Set(int) ; list := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scan.getCurrent()->toInteger() ;
     var b : int ; b := scan.getCurrent()->toInteger() ;
     if (a = 0) then (     list := list->including(b) ; 
     OclFile["System.out"].println(list->size()) ) else     if (a = 1) then (     OclFile["System.out"].println(if list->includes(b) then "1" else "0" endif) ) else     if (a = 2) then (     list := list->excludingAt(b+1) ) else skip ; ;  )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int times=sc.nextInt();
      Set<Long>set=new HashSet<Long>();
      for(int i=0 ; i<times ; i++){
        int query=sc.nextInt();
        long x=sc.nextLong();
        switch(query){
          case 0 : set.add(x);
          System.out.println(set.size());
          break ;
          case 1 : if(set.contains(x)){
            System.out.println(1);
          }
          else System.out.println(0);
          break ;
          case 2 : set.remove(x);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var times : int ; times := sc.getCurrent()->toInteger() ;
     var set : Set(long) ; set := Set{} ;
         var i : int ; i := 0 ; while i < times do ( (     var query : int ; query := sc.getCurrent()->toInteger() ;
     var x : long ; x := sc.getCurrent()->toLong() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (query) ; 
       if _switchval = 0 then
     set := set->including(x) ; 
    OclFile["System.out"].println(set->size()) ; 
    break 
   else skip ;
       if _switchval = 1 then
     if (set->includes(x)) then (     OclFile["System.out"].println(1) ) else     OclFile["System.out"].println(0) ; ;  
    break 
   else skip ;
       if _switchval = 2 then
     set := set->excludingAt(x+1) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] arg){
    HashSet<Integer>ht=new HashSet<Integer>();
    Scanner sc=new Scanner(System.in);
    int cnt=sc.nextInt();
    for(int i=0 ; i<cnt ; i++){
      int cmt=sc.nextInt();
      switch(cmt){
        case 0 : int num=sc.nextInt();
        if(! ht.contains(num))ht.add(num);
        System.out.println(ht.size());
        break ;
        case 1 : int num2=sc.nextInt();
        int cnt2=0 ;
        if(ht.contains(num2))cnt2=1 ;
        System.out.println(cnt2);
        break ;
        case 2 : int num3=sc.nextInt();
        ht.remove(num3);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ht : Set(int) ; ht := Set{} ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cnt : int ; cnt := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < cnt do ( (     var cmt : int ; cmt := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (cmt) ; 
       if _switchval = 0 then
     var num : int ; num := sc.getCurrent()->toInteger() ;
    if (not(ht->includes(num))) then     ht := ht->including(num) ; else skip ; 
    OclFile["System.out"].println(ht->size()) ; 
    break 
   else skip ;
       if _switchval = 1 then
     var num2 : int ; num2 := sc.getCurrent()->toInteger() ;
    var cnt2 : int ; cnt2 := 0 ;
    if (ht->includes(num2)) then     cnt2 := 1 ; else skip ; 
    OclFile["System.out"].println(cnt2) ; 
    break 
   else skip ;
       if _switchval = 2 then
     var num3 : int ; num3 := sc.getCurrent()->toInteger() ;
    ht := ht->excludingAt(num3+1) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test172 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int min=in.nextInt();
      int sum=min ;
      for(int i=0 ; i<n-1 ; i++){
        int a=in.nextInt();
        sum+=a ;
        if(a<min){
          min=a ;
        }
      }
      System.out.println(sum-(min*n));
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test172 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var min : int ; min := in.getCurrent()->toInteger() ;
    var sum : int ; sum := min ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     sum := sum+(a) ; 
     if (a < min) then (     min := a ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum - (min * n)) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int check(int num){
    int digitSum=0 ;
    while(num>0){
      digitSum=digitSum+num % 10 ;
      num=num/10 ;
    }
    int temp=digitSum ;
    int reverseDigitSum=0 ;
    while(temp>0){
      int rem=temp % 10 ;
      reverseDigitSum=reverseDigitSum*10+rem ;
      temp=temp/10 ;
    }
    int number=digitSum*reverseDigitSum ;
    return number ;
  }
  public static void main(String args[]){
    int num=1729 ;
    int x=check(num);
    if(num==x)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation check( num : int) : int
  pre: true
  post: true
  activity: (     var digitSum : int ; digitSum := 0 ;
     while (num > 0) do (     digitSum := digitSum + num mod 10 ; 
     num := num / 10 ) ; 
    var temp : int ; temp := digitSum ;
    var reverseDigitSum : int ; reverseDigitSum := 0 ;
    while (temp > 0) do (     var rem : int ; rem := temp mod 10 ;
     reverseDigitSum := reverseDigitSum * 10 + rem ; 
     temp := temp / 10 ) ; 
    var number : int ; number := digitSum * reverseDigitSum ;
    return number 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 1729 ;
     var x : int ; x := check(num) ;
     if (num = x) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int arr[]={
    12,3,4,15 };
    static int sum(){
      int sum=0 ;
      int i ;
      for(i=0 ; i<arr.length ; i++)sum+=arr[i];
      return sum ;
    }
    public static void main(String[] args){
      System.out.println("Sum of given array is "+sum());
    }
  }

------------------------------------------------------------
OCL File:
---------
class Test {
  static   attribute arr : int := Sequence{12,3,4,15};
  static   operation sum() : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var i : int ;
         i := 0 ; while i < arr->size() do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Sum of given array is " + sum()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int ways(int n){
    int first=2 ;
    int second=3 ;
    int res=0 ;
    for(int i=3 ; i<=n ; i++){
      res=first+second ;
      first=second ;
      second=res ;
    }
    return res ;
  }
  public static void main(String[] args){
    int n=7 ;
    System.out.print("Total ways are: "+ways(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation ways( n : int) : int
  pre: true
  post: true
  activity: (     var first : int ; first := 2 ;
     var second : int ; second := 3 ;
    var res : int ; res := 0 ;
        var i : int ; i := 3 ; while i <= n do ( (     res := first + second ; 
     first := second ; 
     second := res )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     OclFile["System.out"].print("Total ways are: " + ways(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void find(int ar[],int k){
    int sum=0 ;
    for(int i=0 ; i<k ; i++){
      int max=0 ;
      int idx=-1 ;
      for(int j=0 ; j<ar.length ; j++){
        if(ar[j]>max){
          max=ar[j];
          idx=j ;
        }
      }
      sum+=max ;
      ar[idx]=-1 ;
    }
    for(int i=ar.length-1 ; i>=0 ; i--){
      if(ar[i]==-1){
        ar[i]=0 ;
        break ;
      }
    }
    ar[ar.length-1]=-1 ;
    int cnt=0 ;
    System.out.println(sum);
    for(int i=0 ; i<ar.length ; i++){
      cnt++;
      if(ar[i]==-1){
        System.out.print(cnt+" ");
        cnt=0 ;
      }
    }
  }
  public static void main(String[] args){
    try {
      System.setIn(new FileInputStream("input.txt"));
      System.setOut(new PrintStream(new FileOutputStream("output.txt")));
    }
    catch(Exception e){
      System.err.println("Error");
    }
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int ar[]=new int[n];
    for(int i=0 ; i<n ; i++){
      ar[i]=sc.nextInt();
    }
    find(ar,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation find( ar : Sequence(int), k : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < k do ( (     var max : int ; max := 0 ;
     var idx : int ; idx := -1 ;
        var j : int ; j := 0 ; while j < ar->size() do ( (     if (ar[j+1] > max) then (     max := ar[j+1] ; 
     idx := j ) else skip )  ;     j := j + 1 ) ; 
    sum := sum+(max) ; 
    ar[idx+1] := -1 ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := ar->size() - 1 ; while i >= 0 do ( (     if (ar[i+1] = -1) then (     ar[i+1] := 0 ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    ar[ar->size() - 1+1] := -1 ; 
    var cnt : int ; cnt := 0 ;
    OclFile["System.out"].println(sum) ; 
        var i : int ; i := 0 ; while i < ar->size() do ( (     cnt := cnt + 1 ; 
     if (ar[i+1] = -1) then (     OclFile["System.out"].print(cnt + " ") ; 
     cnt := 0 ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) )   catch (e : ProgramException) do (     OclFile["System.err"].println("Error") )
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute find(ar, k) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class demo {
  static float pi=3.14159f ;
  public static float volume(float r,float R,float h){
    return(float)1/3*pi*h*(r*r+R*R+r*R);
  }
  public static float curved_surface_area(float r,float R,float l){
    return pi*l*(R+r);
  }
  public static float total_surface_area(float r,float R,float l,float h){
    return pi*l*(R+r)+pi*(r*r+R*R);
  }
  public static void main(String args[]){
    float small_radius=3 ;
    float big_radius=8 ;
    float slant_height=13 ;
    float height=12 ;
    System.out.print("Volume Of Frustum of Cone : ");
    System.out.println(volume(small_radius,big_radius,height));
    System.out.print("Curved Surface Area Of"+" Frustum of Cone : ");
    System.out.println(curved_surface_area(small_radius,big_radius,slant_height));
    System.out.print("Total Surface Area Of"+" Frustum of Cone : ");
    System.out.println(total_surface_area(small_radius,big_radius,slant_height,height));
  }
}
------------------------------------------------------------
OCL File:
---------
class demo {
  static   attribute pi : double := 3.14159f;
  static   operation volume( r : double, R : double, h : double) : double
  pre: true
  post: true
  activity: (     return 1->oclAsType(double) / 3 * pi * h * (r * r + R * R + r * R) );
  static   operation curved_surface_area( r : double, R : double, l : double) : double
  pre: true
  post: true
  activity: (     return pi * l * (R + r) );
  static   operation total_surface_area( r : double, R : double, l : double, h : double) : double
  pre: true
  post: true
  activity: (     return pi * l * (R + r) + pi * (r * r + R * R) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var small_radius : double ; small_radius := 3 ;
     var big_radius : double ; big_radius := 8 ;
    var slant_height : double ; slant_height := 13 ;
    var height : double ; height := 12 ;
    OclFile["System.out"].print("Volume Of Frustum of Cone : ") ; 
    OclFile["System.out"].println(volume(small_radius, big_radius, height)) ; 
    OclFile["System.out"].print("Curved Surface Area Of" + " Frustum of Cone : ") ; 
    OclFile["System.out"].println(curved_surface_area(small_radius, big_radius, slant_height)) ; 
    OclFile["System.out"].print("Total Surface Area Of" + " Frustum of Cone : ") ; 
    OclFile["System.out"].println(total_surface_area(small_radius, big_radius, slant_height, height)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long max=sc.nextLong();
    long cur=max ;
    long div=10 ;
    while(cur>=div){
      long mod=cur % div ;
      if(mod!=div-1)cur-=(mod+1);
      if(sum(cur)>sum(max))max=cur ;
      div*=10 ;
    }
    System.out.println(max);
  }
  private static int sum(long x){
    int sum=0 ;
    while(x>0){
      sum+=x % 10 ;
      x/=10 ;
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var max : long ; max := sc.getCurrent()->toLong() ;
    var cur : long ; cur := max ;
    var div : long ; div := 10 ;
    while (cur >= div) do (     var mod : long ; mod := cur mod div ;
     if (mod /= div - 1) then     cur := cur-((mod + 1)) ; else skip ; 
     if (sum(cur) > sum(max)) then     max := cur ; else skip ; 
     div := div*(10) ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static   operation sum( x : long) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (x > 0) do (     sum := sum+(x mod 10) ; 
     x := x/(10) ) ; 
     return sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int digitSum(int n){
    int sum=0 ;
    while(n>0){
      sum+=(n % 10);
      n/=10 ;
    }
    return sum ;
  }
  static boolean isPalindrome(int n){
    int divisor=1 ;
    while(n/divisor>=10)divisor*=10 ;
    while(n!=0){
      int leading=n/divisor ;
      int trailing=n % 10 ;
      if(leading!=trailing)return false ;
      n=(n % divisor)/10 ;
      divisor=divisor/100 ;
    }
    return true ;
  }
  static boolean isDigitSumPalindrome(int n){
    int sum=digitSum(n);
    if(isPalindrome(sum))return true ;
    return false ;
  }
  public static void main(String[] args){
    int n=56 ;
    if(isDigitSumPalindrome(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation digitSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n > 0) do (     sum := sum+((n mod 10)) ; 
     n := n/(10) ) ; 
     return sum );
  static   operation isPalindrome( n : int) : boolean
  pre: true
  post: true
  activity: (     var divisor : int ; divisor := 1 ;
     while (n / divisor >= 10) do     divisor := divisor*(10) ; ; 
     while (n /= 0) do (     var leading : int ; leading := n / divisor ;
     var trailing : int ; trailing := n mod 10 ;
    if (leading /= trailing) then     return false else skip ; 
    n := (n mod divisor) / 10 ; 
    divisor := divisor / 100 ; 
 ) ; 
     return true );
  static   operation isDigitSumPalindrome( n : int) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := digitSum(n) ;
     if (isPalindrome(sum)) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 56 ;
     if (isDigitSumPalindrome(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PizzaForces {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    while(test>0){
      long n=sc.nextLong();
      long ans=0 ;
      if(n<=6)System.out.println("15");
      else {
        if(n % 2==1)n++;
        n=n/2 ;
        ans=(long)(n*5);
        System.out.println(ans);
      }
      test--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PizzaForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
     while (test > 0) do (     var n : long ; n := sc.getCurrent()->toLong() ;
     var ans : long ; ans := 0 ;
     if (n <= 6) then     OclFile["System.out"].println("15") else (     if (n mod 2 = 1) then     n := n + 1 ; else skip ; 
     n := n / 2 ; 
     ans := (n * 5)->oclAsType(long) ; 
     OclFile["System.out"].println(ans) ) ;  
     test := test - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    long t=sc.nextLong();
    while(t-->0){
      long n=sc.nextLong();
      if(n<=6){
        System.out.println(15);
      }
      else {
        if(n % 2==0)System.out.println((n/2)*5);
        else System.out.println((n/2+1)*5);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : long ; t := sc.getCurrent()->toLong() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := sc.getCurrent()->toLong() ;
     if (n <= 6) then (     OclFile["System.out"].println(15) ) else (     if (n mod 2 = 0) then     OclFile["System.out"].println((n / 2) * 5) ; else     OclFile["System.out"].println((n / 2 + 1) * 5) ; ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class T1555A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      long n=in.nextLong();
      long n6=0 ;
      int n8=0 ;
      int n10=0 ;
      if(n>6){
        n6=n/6 ;
        long remainder=n % 6 ;
        if(remainder==0){
        }
        else if(remainder<=2){
          n8++;
          n6--;
        }
        else if(remainder<=4){
          n10++;
          n6--;
        }
        else {
          n6++;
        }
      }
      else {
        n6=1 ;
      }
      long result=n6*15+n8*20+n10*25 ;
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class T1555A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : long ; n := in.getCurrent()->toLong() ;
     var n6 : long ; n6 := 0 ;
    var n8 : int ; n8 := 0 ;
    var n10 : int ; n10 := 0 ;
    if (n > 6) then (     n6 := n / 6 ; 
     var remainder : long ; remainder := n mod 6 ;
     if (remainder = 0) then skip else     if (remainder <= 2) then (     n8 := n8 + 1 ; 
     n6 := n6 - 1 ) else     if (remainder <= 4) then (     n10 := n10 + 1 ; 
     n6 := n6 - 1 ) else (     n6 := n6 + 1 ) ;  ;  ) else (     n6 := 1 ) ;  
    var result : long ; result := n6 * 15 + n8 * 20 + n10 * 25 ;
    OclFile["System.out"].println(result) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A55 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    boolean[] visited=new boolean[N];
    int pos=0 ;
    for(int i=1 ; i<=N*N ; i++){
      visited[pos]=true ;
      pos+=i ;
      pos %=N ;
    }
    boolean answer=true ;
    for(boolean b : visited){
      if(! b){
        answer=false ;
      }
    }
    System.out.println(answer ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A55 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,N)->collect(false) ;
    var pos : int ; pos := 0 ;
        var i : int ; i := 1 ; while i <= N * N do ( (     visited[pos+1] := true ; 
     pos := pos+(i) ; 
     pos := pos mod N )  ;     i := i + 1 ) ; 
    var answer : boolean ; answer := true ;
    for (b : visited) do ( (     if (not(b)) then (     answer := false ) else skip )  ) ; 
    OclFile["System.out"].println(if answer then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static float getPercentile(int rank,int students){
    float result=(float)(students-rank)/students*100 ;
    return result ;
  }
  public static void main(String[] args){
    int your_rank=805 ;
    int total_students=97481 ;
    System.out.print(getPercentile(your_rank,total_students));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getPercentile( rank : int, students : int) : double
  pre: true
  post: true
  activity: (     var result : double ; result := (students - rank)->oclAsType(double) / students * 100 ;
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var your_rank : int ; your_rank := 805 ;
     var total_students : int ; total_students := 97481 ;
     OclFile["System.out"].print(getPercentile(your_rank, total_students)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPrime(int n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  public static void main(String[] args){
    int n=17 ;
    if(isPrime(n)&&(n % 16==1)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do ( (     if (n mod i = 0 or n mod (i + 2) = 0) then (     return false ) else skip )  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 17 ;
     if (isPrime(n) & (n mod 16 = 1)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPrime(int n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  public static void main(String[] args){
    int n=13 ;
    if(isPrime(n)&&(n % 4==1)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do ( (     if (n mod i = 0 or n mod (i + 2) = 0) then (     return false ) else skip )  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 13 ;
     if (isPrime(n) & (n mod 4 = 1)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPrime(int n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static boolean isPowerOfTwo(int n){
    return n!=0 &&((n &(n-1))==0);
  }
  public static void main(String[] args){
    int n=43 ;
    if(isPrime(n)&&(isPowerOfTwo(n*3-1))){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do ( (     if (n mod i = 0 or n mod (i + 2) = 0) then (     return false ) else skip )  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation isPowerOfTwo( n : int) : boolean
  pre: true
  post: true
  activity: (     return n /= 0 & ((n & (n - 1)) = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 43 ;
     if (isPrime(n) & (isPowerOfTwo(n * 3 - 1))) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static double aver(int[] arr){
    int sum=0 ;
    for(int i=0 ; i<arr.length ; i++){
      sum=sum+arr[i];
    }
    return sum/arr.length ;
  }
  public static int fac(int x){
    int sum=1 ;
    while(x>0){
      sum=sum*x ;
      x=x-1 ;
    }
    return sum ;
  }
  public static int comb(int x,int y){
    int sum=0 ;
    sum=fac(x);
    int temp=(fac(y)*fac(x-y));
    return sum/temp ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n>0){
      int[] arr=new int[3];
      int max=0 ;
      int count=0 ;
      for(int i=0 ; i<arr.length ; i++){
        arr[i]=sc.nextInt();
        if(arr[i]>max)max=arr[i];
      }
      for(int i=0 ; i<arr.length ; i++){
        if(arr[i]==max)count+=1 ;
        arr[i]=max-arr[i]+1 ;
      }
      for(int i=0 ; i<arr.length ; i++){
        if(arr[i]==1 && max!=0 && count==1)System.out.print(0+" ");
        else System.out.print(arr[i]+" ");
      }
      System.out.println();
      n=n-1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation aver( arr : Sequence(int)) : double
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     sum := sum + arr[i+1] )  ;     i := i + 1 ) ; 
     return sum / arr->size() );
  static   operation fac( x : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 1 ;
     while (x > 0) do (     sum := sum * x ; 
     x := x - 1 ) ; 
     return sum );
  static   operation comb( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     sum := fac(x) ; 
     var temp : int ; temp := (fac(y) * fac(x - y)) ;
     return sum / temp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     while (n > 0) do (     var arr : Sequence(int) ; arr := Integer.subrange(1,3)->collect(0) ;
     var max : int ; max := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr[i+1] > max) then     max := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = max) then     count := count+(1) ; else skip ; 
     arr[i+1] := max - arr[i+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = 1 & max /= 0 & count = 1) then     OclFile["System.out"].print(0 + " ") ; else     OclFile["System.out"].print(arr[i+1] + " ") ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    n := n - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Elections {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int max=Math.max(a,Math.max(b,c));
      if(a==b && b==c){
        System.out.println(1+" "+1+" "+1);
      }
      else if(a>b && a>c){
        System.out.println((0)+" "+((max-b)+1)+" "+((max-c)+1));
      }
      else if(b>a && b>c){
        System.out.println(((max-a)+1)+" "+(0)+" "+((max-c)+1));
      }
      else if(c>a && c>b){
        System.out.println(((max-a)+1)+" "+((max-b)+1)+" "+(0));
      }
      else if(a==max && b==max){
        System.out.println(1+" "+1+" "+((max-c)+1));
      }
      else if(a==max && c==max){
        System.out.println(1+" "+((max-b)+1)+" "+1);
      }
      else if(b==max && c==max){
        System.out.println(((max-a)+1)+" "+1+" "+1);
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Elections {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var max : int ; max := Set{a, Set{b, c}->max()}->max() ;
    if (a = b & b = c) then (     OclFile["System.out"].println(1 + " " + 1 + " " + 1) ) else     if (a > b & a > c) then (     OclFile["System.out"].println((0) + " " + ((max - b) + 1) + " " + ((max - c) + 1)) ) else     if (b > a & b > c) then (     OclFile["System.out"].println(((max - a) + 1) + " " + (0) + " " + ((max - c) + 1)) ) else     if (c > a & c > b) then (     OclFile["System.out"].println(((max - a) + 1) + " " + ((max - b) + 1) + " " + (0)) ) else     if (a = max & b = max) then (     OclFile["System.out"].println(1 + " " + 1 + " " + ((max - c) + 1)) ) else     if (a = max & c = max) then (     OclFile["System.out"].println(1 + " " + ((max - b) + 1) + " " + 1) ) else     if (b = max & c = max) then (     OclFile["System.out"].println(((max - a) + 1) + " " + 1 + " " + 1) ) else skip ; ;  ;  ;  ;  ;  ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt(),k=sc.nextInt();
    if(n>m){
      System.out.println("YES");
      return ;
    }
    int[] a=new int[n],b=new int[m];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    for(int j=0 ; j<m ; j++){
      b[j]=sc.nextInt();
    }
    Arrays.sort(a);
    Arrays.sort(b);
    for(int i=n-1,j=m-1 ; i>=0 && j>=0 ; i--,j--){
      if(a[i]>b[j]){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    if (n > m) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < m do ( (     b[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
        var i : int ; i := n - 1 ;
    var j : int ; j := m - 1 ; while i >= 0 & j >= 0 do ( (     if (a[i+1] > b[j+1]) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     i := i - 1 ;     j := j - 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test186 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int a[]=new int[3];
      int max=0 ;
      for(int i=0 ; i<3 ; i++){
        a[i]=in.nextInt();
        if(a[i]>max){
          max=a[i];
        }
      }
      int sum=0 ;
      for(int i=0 ; i<3 ; i++){
        if(a[i]==max){
          sum++;
        }
      }
      if(sum==1){
        for(int i=0 ; i<3 ; i++){
          if(a[i]!=max)System.out.print((max-a[i]+1)+" ");
          else System.out.print((max-a[i])+" ");
        }
      }
      else {
        for(int i=0 ; i<3 ; i++){
          System.out.print((max-a[i]+1)+" ");
        }
      }
      System.out.println();
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test186 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
     var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     if (a[i+1] > max) then (     max := a[i+1] ) else skip )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (a[i+1] = max) then (     sum := sum + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (sum = 1) then (         var i : int ; i := 0 ; while i < 3 do ( (     if (a[i+1] /= max) then     OclFile["System.out"].print((max - a[i+1] + 1) + " ") ; else     OclFile["System.out"].print((max - a[i+1]) + " ") ; )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < 3 do ( (     OclFile["System.out"].print((max - a[i+1] + 1) + " ") )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println() ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1593A_Election {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      List<Integer>list=new ArrayList<>();
      for(int i=0 ; i<3 ; i++){
        list.add(input.nextInt());
      }
      input.nextLine();
      int max=Collections.max(list);
      int maxCount=Collections.frequency(list,max);
      if(maxCount==3){
        System.out.println("1 1 1");
        continue ;
      }
      List<Integer>result=new ArrayList<>();
      for(int i : list){
        if(maxCount==2 && i==max){
          result.add(1);
        }
        else if(maxCount==1 && i==max){
          result.add(0);
        }
        else {
          result.add(max-i+1);
        }
      }
      System.out.println(result.toString().replaceAll("[\\[\\],] ",""));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1593A_Election {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var list : Sequence(int) ; list := Sequence{} ;
         var i : int ; i := 0 ; while i < 3 do ( (     list := list->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    skip ; 
    var max : int ; max := .max(list) ;
    var maxCount : int ; maxCount := .frequency(list, max) ;
    if (maxCount = 3) then (     OclFile["System.out"].println("1 1 1") ; 
     continue ) else skip ; 
    var result : Sequence(int) ; result := Sequence{} ;
    for (i : list) do ( (     if (maxCount = 2 & i = max) then (     result := result->including(1) ) else     if (maxCount = 1 & i = max) then (     result := result->including(0) ) else (     result := result->including(max - i + 1) ) ;  )  ) ; 
    OclFile["System.out"].println(result+"".replaceAllMatches("[\\[\\],] ", "" )) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int countOfSubstringWithKOnes(String s,int K){
    int N=s.length();
    int res=0 ;
    int countOfOne=0 ;
    int[] freq=new int[N+1];
    freq[0]=1 ;
    for(int i=0 ; i<N ; i++){
      countOfOne+=(s.charAt(i)-'0');
      if(countOfOne>=K){
        res+=freq[countOfOne-K];
      }
      freq[countOfOne]++;
    }
    return res ;
  }
  static public void main(String[] args){
    String s="10010" ;
    int K=1 ;
    System.out.println(countOfSubstringWithKOnes(s,K));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countOfSubstringWithKOnes( s : String, K : int) : int
  pre: true
  post: true
  activity: (     var N : int ; N := s->size() ;
     var res : int ; res := 0 ;
    var countOfOne : int ; countOfOne := 0 ;
    var freq : Sequence(int) ; freq := Integer.subrange(1,N + 1)->collect(0) ;
    freq[0+1] := 1 ; 
        var i : int ; i := 0 ; while i < N do ( (     countOfOne := countOfOne+((s->at(i+1) - ('0')->char2byte())) ; 
     if (countOfOne >= K) then (     res := res+(freq[countOfOne - K+1]) ) else skip ; 
     freq[countOfOne+1] := freq[countOfOne+1] + 1 )  ;     i := i + 1 ) ; 
    return res 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "10010" ;
     var K : int ; K := 1 ;
     OclFile["System.out"].println(countOfSubstringWithKOnes(s, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n,i=1,k=0,p=1 ;
    boolean flag=true ;
    int[] a=new int[1000];
    n=scan.nextInt();
    i=0 ;
    while(k<=n){
      i+=k ;
      if(i>=n){
        while(!(i<n))i=i-n ;
      }
++a[i];
++k ;
    }
    for(i=0 ; i<n ; ++i)if(a[i]==0){
      flag=false ;
      break ;
    }
    if(flag)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var i : int ; i := 1 ;
    var k : int ; k := 0 ;
    var p : int ; p := 1 ;
    var flag : boolean ; flag := true ;
    var a : Sequence(int) ; a := Integer.subrange(1,1000)->collect(0) ;
    n := scan.getCurrent()->toInteger() ; 
    i := 0 ; 
    while (k <= n) do (     i := i+(k) ; 
     if (i >= n) then (     while (not((i < n))) do     i := i - n ; ) else skip ; 
     a[i+1] := a[i+1] + 1 ; 
     k := k + 1 ) ; 
        i := 0 ; while i < n do (     if (a[i+1] = 0) then (     flag := false ; 
     break ) else skip ;  ;     i := i + 1 ) ; 
    if (flag) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  static int kth(int arr1[],int arr2[],int m,int n,int k){
    int[] sorted1=new int[m+n];
    int i=0,j=0,d=0 ;
    while(i<m && j<n){
      if(arr1[i]<arr2[j])sorted1[d++]=arr1[i++];
      else sorted1[d++]=arr2[j++];
    }
    while(i<m)sorted1[d++]=arr1[i++];
    while(j<n)sorted1[d++]=arr2[j++];
    return sorted1[k-1];
  }
  public static void main(String[] args){
    int arr1[]={
      2,3,6,7,9 };
      int arr2[]={
        1,4,8,10 };
        int k=5 ;
        System.out.print(kth(arr1,arr2,5,4,k));
      }
    }

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation kth( arr1 : Sequence(int), arr2 : Sequence(int), m : int, n : int, k : int) : int
  pre: true
  post: true
  activity: (     var sorted1 : Sequence(int) ; sorted1 := Integer.subrange(1,m + n)->collect(0) ;
     var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    var d : int ; d := 0 ;
    while (i < m & j < n) do (     if (arr1[i+1] < arr2[j+1]) then       sorted1[d+1] := arr1[i+1]  ; d := d + 1  ; i := i + 1 ; else       sorted1[d+1] := arr2[j+1]  ; d := d + 1  ; j := j + 1 ; ) ; 
    while (i < m) do       sorted1[d+1] := arr1[i+1]  ; d := d + 1  ; i := i + 1 ; ; 
    while (j < n) do       sorted1[d+1] := arr2[j+1]  ; d := d + 1  ; j := j + 1 ; ; 
    return sorted1[k - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{2,3,6,7,9} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{1,4,8,10} ;
     var k : int ; k := 5 ;
     OclFile["System.out"].print(kth(arr1, arr2, 5, 4, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static final int MAX=256 ;
  static int freq[][];
  static void preCalculate(String str,int n){
    freq[(int)str.charAt(0)][0]=1 ;
    for(int i=1 ; i<n ; i++){
      char ch=str.charAt(i);
      for(int j=0 ; j<MAX ; j++){
        char charToUpdate=(char)j ;
        if(charToUpdate==ch)freq[j][i]=freq[j][i-1]+1 ;
        else freq[j][i]=freq[j][i-1];
      }
    }
  }
  static int getFrequency(char ch,int l,int r){
    if(l==0)return freq[(int)ch][r];
    else return(freq[(int)ch][r]-freq[(int)ch][l-1]);
  }
  static String firstNonRepeating(String str,int n,int l,int r){
    for(int i=l ; i<r ; i++){
      char ch=str.charAt(i);
      if(getFrequency(ch,l,r)==1)return(""+ch);
    }
    return "-1" ;
  }
  public static void main(String[] args){
    String str="GeeksForGeeks" ;
    int n=str.length();
    int queries[][]={
      {
        0,3 },{
          2,3 },{
            5,12 }
          };
          int q=queries.length ;
          freq=new int[MAX][n];
          preCalculate(str,n);
          for(int i=0 ; i<q ; i++){
            System.out.println(firstNonRepeating(str,n,queries[i][0],queries[i][1]));
          }
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 256;
  static   attribute freq : Sequence(Sequence(int));
  static   operation preCalculate( str : String, n : int) : void
  pre: true
  post: true
  activity: (     freq[str->at(0+1)->oclAsType(int)+1][0+1] := 1 ; 
         var i : int ; i := 1 ; while i < n do ( (     var ch : String ; ch := str->at(i+1) ;
         var j : int ; j := 0 ; while j < MAX do ( (     var charToUpdate : String ; charToUpdate := j->oclAsType(String) ;
     if (charToUpdate = ch) then     freq[j+1][i+1] := freq[j+1][i - 1+1] + 1 ; else     freq[j+1][i+1] := freq[j+1][i - 1+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation getFrequency( ch : String, l : int, r : int) : int
  pre: true
  post: true
  activity: (     if (l = 0) then     return freq[(ch)->char2byte()+1][r+1] else     return (freq[(ch)->char2byte()+1][r+1] - freq[(ch)->char2byte()+1][l - 1+1]) );
  static   operation firstNonRepeating( str : String, n : int, l : int, r : int) : String
  pre: true
  post: true
  activity: (         var i : int ; i := l ; while i < r do ( (     var ch : String ; ch := str->at(i+1) ;
     if (getFrequency(ch, l, r) = 1) then     return ("" + ch) else skip )  ;     i := i + 1 ) ; 
     return "-1" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GeeksForGeeks" ;
     var n : int ; n := str->size() ;
    var queries : Sequence(Sequence(int)) ; queries := Sequence{Sequence{0,3},Sequence{2,3},Sequence{5,12}} ;
    var q : int ; q := queries->size() ;
    freq := Integer.subrange(1,MAX)->collect(Integer.subrange(1,n)->collect(0)) ; 
    execute preCalculate(str, n) ; 
        var i : int ; i := 0 ; while i < q do ( (     OclFile["System.out"].println(firstNonRepeating(str, n, queries[i+1][0+1], queries[i+1][1+1])) )  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static final int MAX=256 ;
  static int freq[][];
  static void preCalculate(String str,int n){
    freq[(int)str.charAt(0)][0]=1 ;
    for(int i=1 ; i<n ; i++){
      char ch=str.charAt(i);
      for(int j=0 ; j<MAX ; j++){
        char charToUpdate=(char)j ;
        if(charToUpdate==ch)freq[j][i]=freq[j][i-1]+1 ;
        else freq[j][i]=freq[j][i-1];
      }
    }
  }
  static int getFrequency(char ch,int l,int r){
    if(l==0)return freq[(int)ch][r];
    else return(freq[(int)ch][r]-freq[(int)ch][l-1]);
  }
  static String lastNonRepeating(String str,int n,int l,int r){
    for(int i=r ; i>=l ; i--){
      char ch=str.charAt(i);
      if(getFrequency(ch,l,r)==1)return(""+ch);
    }
    return "-1" ;
  }
  public static void main(String[] args){
    String str="GeeksForGeeks" ;
    int n=str.length();
    int queries[][]={
      {
        2,9 },{
          2,3 },{
            0,12 }
          };
          int q=queries.length ;
          freq=new int[MAX][n];
          preCalculate(str,n);
          for(int i=0 ; i<q ; i++){
            System.out.println(lastNonRepeating(str,n,queries[i][0],queries[i][1]));
          }
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 256;
  static   attribute freq : Sequence(Sequence(int));
  static   operation preCalculate( str : String, n : int) : void
  pre: true
  post: true
  activity: (     freq[str->at(0+1)->oclAsType(int)+1][0+1] := 1 ; 
         var i : int ; i := 1 ; while i < n do ( (     var ch : String ; ch := str->at(i+1) ;
         var j : int ; j := 0 ; while j < MAX do ( (     var charToUpdate : String ; charToUpdate := j->oclAsType(String) ;
     if (charToUpdate = ch) then     freq[j+1][i+1] := freq[j+1][i - 1+1] + 1 ; else     freq[j+1][i+1] := freq[j+1][i - 1+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation getFrequency( ch : String, l : int, r : int) : int
  pre: true
  post: true
  activity: (     if (l = 0) then     return freq[(ch)->char2byte()+1][r+1] else     return (freq[(ch)->char2byte()+1][r+1] - freq[(ch)->char2byte()+1][l - 1+1]) );
  static   operation lastNonRepeating( str : String, n : int, l : int, r : int) : String
  pre: true
  post: true
  activity: (         var i : int ; i := r ; while i >= l do ( (     var ch : String ; ch := str->at(i+1) ;
     if (getFrequency(ch, l, r) = 1) then     return ("" + ch) else skip )  ;     i := i - 1 ) ; 
     return "-1" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GeeksForGeeks" ;
     var n : int ; n := str->size() ;
    var queries : Sequence(Sequence(int)) ; queries := Sequence{Sequence{2,9},Sequence{2,3},Sequence{0,12}} ;
    var q : int ; q := queries->size() ;
    freq := Integer.subrange(1,MAX)->collect(Integer.subrange(1,n)->collect(0)) ; 
    execute preCalculate(str, n) ; 
        var i : int ; i := 0 ; while i < q do ( (     OclFile["System.out"].println(lastNonRepeating(str, n, queries[i+1][0+1], queries[i+1][1+1])) )  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static void divide(int a,int b){
    for(int i=2 ; i<=Math.min(a,b); i++){
      while(a % i==0 && b % i==0){
        a=a/i ;
        b=b/i ;
      }
    }
    System.out.println("A="+a+",B="+b);
  }
  public static void main(String args[]){
    int A=10,B=15 ;
    divide(A,B);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation divide( a : int, b : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i <= Set{a, b}->min() do ( (     while (a mod i = 0 & b mod i = 0) do (     a := a / i ; 
     b := b / i ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("A=" + a + ",B=" + b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 10 ;
    var B : int ; B := 15 ;
     execute divide(A, B) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector ;
class GFG {
  static Vector<Integer>permutation=new Vector<>();
  static void printPermutation(){
    permutation.stream().forEach((i)->{
      System.out.print(i+" ");
    }
);
  }
  static int give_random_number(int l,int r){
    int x=(int)(Math.random()%(r-l+1)+l);
    return x ;
  }
  static void generate_random_permutation(int l,int r){
    if(l>r)return ;
    int n=give_random_number(l,r);
    permutation.add(n);
    generate_random_permutation(l,n-1);
    generate_random_permutation(n+1,r);
  }
  public static void main(String[] args){
    int l=5 ;
    int r=15 ;
    generate_random_permutation(l,r);
    printPermutation();
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute permutation : Sequence(int) := Sequence{};
  static   operation printPermutation() : void
  pre: true
  post: true
  activity: (     for i : permutation do
    (    skip) );
  static   operation give_random_number( l : int, r : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := (MathLib.random() mod (r - l + 1) + l)->oclAsType(int) ;
     return x );
  static   operation generate_random_permutation( l : int, r : int) : void
  pre: true
  post: true
  activity: (     if (l > r) then     return else skip ; 
     var n : int ; n := give_random_number(l, r) ;
    permutation := permutation->including(n) ; 
    execute generate_random_permutation(l, n - 1) ; 
    execute generate_random_permutation(n + 1, r) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 5 ;
     var r : int ; r := 15 ;
     execute generate_random_permutation(l, r) ; 
     execute printPermutation() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    long N=sc.nextLong();
    long D=sc.nextLong();
    long ans ;
    if(D==1){
      ans=N*(N-1)/2 ;
    }
    else {
      long dense=N-D ;
      ans=dense*(dense-1)/2 ;
      ans+=2*dense ;
      ans+=D-2 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := sc.getCurrent()->toLong() ;
     var D : long ; D := sc.getCurrent()->toLong() ;
    var ans : long ;
    if (D = 1) then (     ans := N * (N - 1) / 2 ) else (     var dense : long ; dense := N - D ;
     ans := dense * (dense - 1) / 2 ; 
     ans := ans+(2 * dense) ; 
     ans := ans+(D - 2) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Game23 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int no=sc.nextInt();
    int dest=sc.nextInt();
    int res=-1 ;
    if(no==dest){
      System.out.println("0");
    }
    else if(dest % no==0){
      res=0 ;
      int d=dest/no ;
      while(d % 2==0){
        d=d/2 ;
        res++;
      }
      while(d % 3==0){
        d=d/3 ;
        res++;
      }
      if(d!=1)res=-1 ;
      System.out.println(res);
    }
    else {
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Game23 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var no : int ; no := sc.getCurrent()->toInteger() ;
    var dest : int ; dest := sc.getCurrent()->toInteger() ;
    var res : int ; res := -1 ;
    if (no = dest) then (     OclFile["System.out"].println("0") ) else     if (dest mod no = 0) then (     res := 0 ; 
     var d : int ; d := dest / no ;
    while (d mod 2 = 0) do (     d := d / 2 ; 
     res := res + 1 ) ; 
    while (d mod 3 = 0) do (     d := d / 3 ; 
     res := res + 1 ) ; 
    if (d /= 1) then     res := -1 ; else skip ; 
    OclFile["System.out"].println(res) ; 
 ) else (     OclFile["System.out"].println(res) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int k=sc.nextInt();
    int[] arr1=new int[n];
    int[] arr2=new int[m];
    for(int i=0 ; i<n ; i++){
      arr1[i]=sc.nextInt();
    }
    for(int i=0 ; i<m ; i++){
      arr2[i]=sc.nextInt();
    }
    Arrays.sort(arr1);
    Arrays.sort(arr2);
    int t1=0 ;
    int t2=0 ;
    int p2=m-1 ;
    for(int p1=n-1 ; p1>=0 ; p1--){
      t1++;
      while(p2>=0 && arr2[p2]>=arr1[p1]){
        t2++;
        p2--;
      }
      if(t1>t2){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr1[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     arr2[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr1 := arr1->sort() ; 
    arr2 := arr2->sort() ; 
    var t1 : int ; t1 := 0 ;
    var t2 : int ; t2 := 0 ;
    var p2 : int ; p2 := m - 1 ;
        var p1 : int ; p1 := n - 1 ; while p1 >= 0 do ( (     t1 := t1 + 1 ; 
     while (p2 >= 0 & arr2[p2+1] >= arr1[p1+1]) do (     t2 := t2 + 1 ; 
     p2 := p2 - 1 ) ; 
     if (t1 > t2) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     p1 := p1 - 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static long start ;
  static long target ;
  static long sum ;
  static boolean flag ;
  static int cou ;
  static int ans ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    start=in.nextInt();
    target=in.nextInt();
    solution1(start,target,cou);
    if(flag){
      System.out.println(ans);
    }
    else System.out.println(-1);
  }
  static void solution1(long start,long target,int cou){
    if(start<=target){
      if(start<target){
        cou++;
      }
      else if(start==target){
        flag=true ;
        ans=cou ;
      }
    }
    else {
      cou=0 ;
      return ;
    }
    solution1(start*2,target,cou);
    solution1(start*3,target,cou);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute start : long;
  static   attribute target : long;
  static   attribute sum : long;
  static   attribute flag : boolean;
  static   attribute cou : int;
  static   attribute ans : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     start := in.getCurrent()->toInteger() ; 
    target := in.getCurrent()->toInteger() ; 
    execute solution1(start, target, cou) ; 
    if (flag) then (     OclFile["System.out"].println(ans) ) else     OclFile["System.out"].println(-1) ; ;  
 );
  static   operation solution1( start : long, target : long, cou : int) : void
  pre: true
  post: true
  activity: (     if (start <= target) then (     if (start < target) then (     cou := cou + 1 ) else     if (start = target) then (     flag := true ; 
     ans := cou ) else skip ; ) else (     cou := 0 ; 
     return ) ;  
     execute solution1(start * 2, target, cou) ; 
     execute solution1(start * 3, target, cou) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NumberWay {
  public void input(int number1,int number2){
    int count=0 ;
    boolean b=true ;
    while(true){
      if(number1==number2){
        break ;
      }
      int n=number1*2 ;
      int n2=number1*3 ;
      if(number2 % n==0){
        count++;
        number1=n ;
      }
      else if(number2 % n2==0){
        count++;
        number1=n2 ;
      }
      else {
        b=false ;
        break ;
      }
    }
    if(b==true){
      System.out.println(count);
    }
    else {
      System.out.println(-1);
    }
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    NumberWay instance=new NumberWay();
    int n1=input.nextInt();
    int n2=input.nextInt();
    instance.input(n1,n2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class NumberWay {
   operation input( number1 : int, number2 : int) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var b : boolean ; b := true ;
     while (true) do (     if (number1 = number2) then (     break ) else skip ; 
     var n : int ; n := number1 * 2 ;
     var n2 : int ; n2 := number1 * 3 ;
     if (number2 mod n = 0) then (     count := count + 1 ; 
     number1 := n ) else     if (number2 mod n2 = 0) then (     count := count + 1 ; 
     number1 := n2 ) else (     b := false ; 
     break ) ;  ) ; 
     if (b = true) then (     OclFile["System.out"].println(count) ) else (     OclFile["System.out"].println(-1) ) );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var instance : NumberWay ; instance := NumberWay.newNumberWay() ;
    var n1 : int ; n1 := input.getCurrent()->toInteger() ;
    var n2 : int ; n2 := input.getCurrent()->toInteger() ;
    instance.input(n1, n2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean productEqual(int n){
    if(n<10)return false ;
    int prodOdd=1,prodEven=1 ;
    while(n>0){
      int digit=n % 10 ;
      prodOdd*=digit ;
      n/=10 ;
      if(n==0)break ;
      digit=n % 10 ;
      prodEven*=digit ;
      n/=10 ;
    }
    if(prodEven==prodOdd)return true ;
    return false ;
  }
  public static void main(String args[]){
    int n=4324 ;
    if(productEqual(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation productEqual( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n < 10) then     return false else skip ; 
     var prodOdd : int ; prodOdd := 1 ;
    var prodEven : int ; prodEven := 1 ;
    while (n > 0) do (     var digit : int ; digit := n mod 10 ;
     prodOdd := prodOdd*(digit) ; 
    n := n/(10) ; 
    if (n = 0) then     break else skip ; 
    digit := n mod 10 ; 
    prodEven := prodEven*(digit) ; 
    n := n/(10) ; 
 ) ; 
    if (prodEven = prodOdd) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4324 ;
     if (productEqual(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Sol {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    if(n>m)System.out.print("-1");
    else if(n==m)System.out.print("0");
    else {
      int ans=find(n,m,0);
      if(ans==Integer.MAX_VALUE)System.out.print("-1");
      else {
        System.out.print(ans);
      }
    }
  }
  public static int find(int n,int m,int count){
    if(n==m)return count ;
    if(n>m)return Integer.MAX_VALUE ;
    return Math.min(find(2*n,m,count+1),find(3*n,m,count+1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sol {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     if (n > m) then     OclFile["System.out"].print("-1") ; else     if (n = m) then     OclFile["System.out"].print("0") else (     var ans : int ; ans := find(n, m, 0) ;
     if (ans = 2147483647) then     OclFile["System.out"].print("-1") ; else (     OclFile["System.out"].print(ans) ) ) ;  );
  static   operation find( n : int, m : int, count : int) : int
  pre: true
  post: true
  activity: (     if (n = m) then     return count else skip ; 
     if (n > m) then     return 2147483647 else skip ; 
     return Set{find(2 * n, m, count + 1), find(3 * n, m, count + 1)}->min() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MainClass {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    int m=Integer.parseInt(st.nextToken());
    int cnt=0 ;
    boolean flag=false ;
    if(m % n!=0){
      System.out.println(-1);
      return ;
    }
    int temp=m/n ;
    while(temp>1){
      if(temp % 3==0){
        temp/=3 ;
      }
      else if(temp % 2==0){
        temp/=2 ;
      }
      else {
        flag=true ;
        break ;
      }
      cnt++;
    }
    if(temp!=1)flag=true ;
    if(flag){
      System.out.println(-1);
    }
    else {
      System.out.println(cnt);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var cnt : int ; cnt := 0 ;
    var flag : boolean ; flag := false ;
    if (m mod n /= 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var temp : int ; temp := m / n ;
    while (temp > 1) do (     if (temp mod 3 = 0) then (     temp := temp/(3) ) else     if (temp mod 2 = 0) then (     temp := temp/(2) ) else (     flag := true ; 
     break ) ;  ;  
     cnt := cnt + 1 ) ; 
    if (temp /= 1) then     flag := true ; else skip ; 
    if (flag) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(cnt) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int rock=sc.nextInt();
      int paper=sc.nextInt();
      int scissor=sc.nextInt();
      sc.nextLine();
      int f=0 ;
      char ans[]=new char[n];
      int k=0 ;
      Arrays.fill(ans,'1');
      String s=sc.nextLine();
      for(int i=0 ; i<n ; i++){
        char c=s.charAt(i);
        if(c=='R'){
          if(paper>0){
            paper--;
            ans[i]=('P');
          }
          else {
            f++;
          }
        }
        else if(c=='P'){
          if(scissor>0){
            scissor--;
            ans[i]=('S');
          }
          else {
            f++;
          }
        }
        else if(c=='S'){
          if(rock>0){
            rock--;
            ans[i]=('R');
          }
          else {
            f++;
          }
        }
      }
      StringBuffer ans1=new StringBuffer();
      for(int i=0 ; i<n ; i++){
        if(ans[i]=='1' && rock>0){
          ans[i]='R' ;
          rock--;
        }
        else if(ans[i]=='1' && paper>0){
          ans[i]='P' ;
          paper--;
        }
        else if(ans[i]=='1' && scissor>0){
          ans[i]='S' ;
          scissor--;
        }
        ans1.append(ans[i]);
      }
      double x=Double.valueOf(n)/2 ;
      if(f<=x){
        System.out.println("Yes");
        System.out.println(ans1.toString());
      }
      else System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var rock : int ; rock := sc.getCurrent()->toInteger() ;
    var paper : int ; paper := sc.getCurrent()->toInteger() ;
    var scissor : int ; scissor := sc.getCurrent()->toInteger() ;
    skip ; 
    var f : int ; f := 0 ;
    var ans : Sequence(String) ; ans := Integer.subrange(1,n)->collect(0) ;
    var k : int ; k := 0 ;
    ans := ans->collect('1') ; 
    var s : String ; s := sc.nextLine() ;
        var i : int ; i := 0 ; while i < n do ( (     var c : String ; c := s->at(i+1) ;
     if (c = 'R') then (     if (paper > 0) then (     paper := paper - 1 ; 
     ans[i+1] := ('P') ) else (     f := f + 1 ) ) else     if (c = 'P') then (     if (scissor > 0) then (     scissor := scissor - 1 ; 
     ans[i+1] := ('S') ) else (     f := f + 1 ) ) else     if (c = 'S') then (     if (rock > 0) then (     rock := rock - 1 ; 
     ans[i+1] := ('R') ) else (     f := f + 1 ) ) else skip ; ;  )  ;     i := i + 1 ) ; 
    var ans1 : String ; ans1 := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     if (ans[i+1] = '1' & rock > 0) then (     ans[i+1] := 'R' ; 
     rock := rock - 1 ) else     if (ans[i+1] = '1' & paper > 0) then (     ans[i+1] := 'P' ; 
     paper := paper - 1 ) else     if (ans[i+1] = '1' & scissor > 0) then (     ans[i+1] := 'S' ; 
     scissor := scissor - 1 ) else skip ; ;  ;  
     ans1 := ans1 + StringLib.newString(ans[i+1]) )  ;     i := i + 1 ) ; 
    var x : double ; x := (n)->toReal() / 2 ;
    if (f <= x) then (     OclFile["System.out"].println("Yes") ; 
     OclFile["System.out"].println(ans1+"") ) else     OclFile["System.out"].println("No") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int n=sc.nextInt();
    int[] p=new int[n];
    for(int i=0 ; i<n ; i++){
      p[i]=sc.nextInt();
    }
    int a=0 ;
    while(true){
      int check=x-a ;
      boolean ju=true ;
      for(int i=0 ; i<n ; i++){
        if(check==p[i]){
          ju=false ;
          break ;
        }
      }
      if(ju==true){
        System.out.println(check);
        return ;
      }
      check=x+a ;
      for(int i=0 ; i<n ; i++){
        if(check==p[i]){
          ju=true ;
          break ;
        }
      }
      if(ju==false){
        System.out.println(check);
        return ;
      }
      a++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var a : int ; a := 0 ;
    while (true) do (     var check : int ; check := x - a ;
     var ju : boolean ; ju := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (check = p[i+1]) then (     ju := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (ju = true) then (     OclFile["System.out"].println(check) ; 
     return ) else skip ; 
    check := x + a ; 
        var i : int ; i := 0 ; while i < n do ( (     if (check = p[i+1]) then (     ju := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (ju = false) then (     OclFile["System.out"].println(check) ; 
     return ) else skip ; 
    a := a + 1 ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static PrintWriter out=new PrintWriter((System.out));
  public static void main(String args[])throws IOException {
    Kioken sc=new Kioken();
    int k=sc.nextInt();
    int n=sc.nextInt();
    HashSet<Integer>set=new HashSet<>();
    for(int x=0 ; x<n ; x++){
      set.add(sc.nextInt());
    }
    int d=0 ;
    int ans=0 ;
    while(true){
      if(! set.contains(k-d)){
        ans=k-d ;
        break ;
      }
      if(! set.contains(k+d)){
        ans=k+d ;
        break ;
      }
      d++;
    }
    out.println(ans);
    out.close();
  }
  public static void kamehameha(){
  }
  static class Kioken {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(Exception e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return br.readLine();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return null ;
    }
    public boolean hasNext(){
      String next=null ;
      try {
        next=br.readLine();
      }
      catch(Exception e){
      }
      if(next==null){
        return false ;
      }
      st=new StringTokenizer(next);
      return true ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write((OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : Kioken ; sc := Kioken.newKioken() ;
     var k : int ; k := sc.nextInt() ;
    var n : int ; n := sc.nextInt() ;
    var set : Set(int) ; set := Set{} ;
        var x : int ; x := 0 ; while x < n do ( (     set := set->including(sc.nextInt()) )  ;     x := x + 1 ) ; 
    var d : int ; d := 0 ;
    var ans : int ; ans := 0 ;
    while (true) do (     if (not(set->includes(k - d))) then (     ans := k - d ; 
     break ) else skip ; 
     if (not(set->includes(k + d))) then (     ans := k + d ; 
     break ) else skip ; 
     d := d + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation kamehameha() : void
  pre: true
  post: true
  activity: skip;
  static class Kioken {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return null );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     var next : String ; next := null ;
     try (     next := br.readLine() )   catch (e : ProgramException) do skip
    if (next = null) then (     return false ) else skip ; 
    st := OclIterator.newOclIterator_String(next) ; 
    return true 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int x=Integer.parseInt(scan.next());
    int n=Integer.parseInt(scan.next());
    if(n==0){
      System.out.println(x);
      scan.close();
      return ;
    }
    Set<Integer>set=new HashSet<Integer>();
    for(int i=0 ; i<n ; i++){
      set.add(Integer.parseInt(scan.next()));
    }
    scan.close();
    int a=x ;
    int b=x ;
    while(true){
      if(! set.contains(b)){
        System.out.println(b);
        return ;
      }
      if(! set.contains(a)){
        System.out.println(a);
        return ;
      }
      a++;
      b--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := (scan.getCurrent())->toInteger() ;
    var n : int ; n := (scan.getCurrent())->toInteger() ;
    if (n = 0) then (     OclFile["System.out"].println(x) ; 
     skip ; 
     return ) else skip ; 
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     set := set->including((scan.getCurrent())->toInteger()) )  ;     i := i + 1 ) ; 
    skip ; 
    var a : int ; a := x ;
    var b : int ; b := x ;
    while (true) do (     if (not(set->includes(b))) then (     OclFile["System.out"].println(b) ; 
     return ) else skip ; 
     if (not(set->includes(a))) then (     OclFile["System.out"].println(a) ; 
     return ) else skip ; 
     a := a + 1 ; 
     b := b - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Integer target=new Integer(Integer.parseInt(sc.next()));
    int n=Integer.parseInt(sc.next());
    if(n==0){
      System.out.println(target);
      return ;
    }
    Integer x[]=new Integer[n];
    for(int i=0 ; i<n ; i++){
      x[i]=new Integer(Integer.parseInt(sc.next()));
    }
    if(! Arrays.asList(x).contains(target)){
      System.out.println(target);
      return ;
    }
    Arrays.sort(x);
    int index=Arrays.asList(x).indexOf(target);
    int now=target.intValue();
    int minus=0 ;
    while(now<=x[x.length-1] .intValue()){
      minus++;
      now=target.intValue()-minus ;
      if(! Arrays.asList(x).contains(new Integer(now))){
        break ;
      }
    }
    now=target.intValue();
    int plus=0 ;
    while(x[0] .intValue()<=now){
      plus++;
      now=target.intValue()+plus ;
      if(! Arrays.asList(x).contains(new Integer(now))){
        break ;
      }
    }
    if(minus<=plus){
      System.out.println(target.intValue()-minus);
    }
    else {
      System.out.println(target.intValue()+plus);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var target : int ; target := ("" + ((sc.getCurrent())->toInteger()))->toInteger() ;
    var n : int ; n := (sc.getCurrent())->toInteger() ;
    if (n = 0) then (     OclFile["System.out"].println(target) ; 
     return ) else skip ; 
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := ("" + ((sc.getCurrent())->toInteger()))->toInteger() )  ;     i := i + 1 ) ; 
    if (not(x->includes(target))) then (     OclFile["System.out"].println(target) ; 
     return ) else skip ; 
    x := x->sort() ; 
    var index : int ; index := x->indexOf(target)-1 ;
    var now : int ; now := target->oclAsType(int) ;
    var minus : int ; minus := 0 ;
    while (now <= x[x->size() - 1+1]->oclAsType(int)) do (     minus := minus + 1 ; 
     now := target->oclAsType(int) - minus ; 
     if (not(x->includes(("" + (now))->toInteger()))) then (     break ) else skip ) ; 
    now := target->oclAsType(int) ; 
    var plus : int ; plus := 0 ;
    while (x[0+1]->oclAsType(int) <= now) do (     plus := plus + 1 ; 
     now := target->oclAsType(int) + plus ; 
     if (not(x->includes(("" + (now))->toInteger()))) then (     break ) else skip ) ; 
    if (minus <= plus) then (     OclFile["System.out"].println(target->oclAsType(int) - minus) ) else (     OclFile["System.out"].println(target->oclAsType(int) + plus) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Cl297 {
  public static void main(String[] args){
    Scanner sc=new Scanner(new InputStreamReader(System.in));
    while(sc.hasNext()){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int k=sc.nextInt();
      int[] arr1=new int[n];
      int[] arr2=new int[m];
      for(int i=0 ; i<n ; i++){
        arr1[i]=sc.nextInt();
      }
      for(int i=0 ; i<m ; i++){
        arr2[i]=sc.nextInt();
      }
      if(n>m)System.out.println("YES");
      else {
        Arrays.sort(arr1);
        Arrays.sort(arr2);
        boolean success=false ;
        for(int i=n-1,j=m-1 ; i>=0 && j>=0 ; i--,j--){
          if(arr1[i]>arr2[j]){
            success=true ;
            break ;
          }
        }
        System.out.println(success ? "YES" : "NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cl297 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr1[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     arr2[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (n > m) then     OclFile["System.out"].println("YES") else (     arr1 := arr1->sort() ; 
     arr2 := arr2->sort() ; 
    var success : boolean ; success := false ;
        var i : int ; i := n - 1 ;
    var j : int ; j := m - 1 ; while i >= 0 & j >= 0 do ( (     if (arr1[i+1] > arr2[j+1]) then (     success := true ; 
     break ) else skip )  ;     i := i - 1 ;     j := j - 1 ) ; 
    OclFile["System.out"].println(if success then "YES" else "NO" endif) ; 
 ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int n=sc.nextInt();
    List<Integer>list=new ArrayList<>();
    int ans=x ;
    for(int i=0 ; i<n ; i++){
      list.add(sc.nextInt());
    }
    for(int dif=0 ; dif<=n ; dif++){
      if(! list.contains(x-dif)){
        ans=x-dif ;
        break ;
      }
      if(! list.contains(x+dif)){
        ans=x+dif ;
        break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
    var ans : int ; ans := x ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var dif : int ; dif := 0 ; while dif <= n do ( (     if (not(list->includes(x - dif))) then (     ans := x - dif ; 
     break ) else skip ; 
     if (not(list->includes(x + dif))) then (     ans := x + dif ; 
     break ) else skip )  ;     dif := dif + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner((System.in));
    int N=sc.nextInt();
    long ans=1 ;
    int y=0 ;
    int[] s=new int[N+1];
    for(int i=2 ; i<=N ; i++){
      y=i ;
      for(int j=2 ; j<=i ; j++){
        while(y % j==0){
          y=y/j ;
          s[j]=s[j]+1 ;
        }
      }
    }
    for(int i=0 ; i<=N ; i++){
      if(s[i]!=0){
        ans=ans*(s[i]+1);
        ans=ans % 1000000007 ;
      }
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read((OclFile["System.in"])) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var ans : long ; ans := 1 ;
    var y : int ; y := 0 ;
    var s : Sequence(int) ; s := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 2 ; while i <= N do ( (     y := i ; 
         var j : int ; j := 2 ; while j <= i do ( (     while (y mod j = 0) do (     y := y / j ; 
     s[j+1] := s[j+1] + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= N do ( (     if (s[i+1] /= 0) then (     ans := ans * (s[i+1] + 1) ; 
     ans := ans mod 1000000007 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import static javafx.application.Platform.exit ;
public class NewClass25 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    int z=in.nextInt();
    String x[][]=new String[t][z];
    int b=0 ;
    int w=0 ;
    int c=0 ;
    int g=0 ;
    for(int i=0 ; i<t ; i++){
      for(int j=0 ; j<z ; j++){
        String colour=in.next();
        if(colour.equals("C")|| colour.equals("M")|| colour.equals("Y")){
          c=1 ;
          break ;
        }
      }
      if(c==1){
        break ;
      }
    }
    if(c==1){
      System.out.println("#Color");
    }
    else {
      System.out.println("#Black&White");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass25 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var z : int ; z := in.getCurrent()->toInteger() ;
    var x : Sequence(Sequence(String)) ; x := Integer.subrange(1,t)->collect(Integer.subrange(1,z)->collect(null)) ;
    var b : int ; b := 0 ;
    var w : int ; w := 0 ;
    var c : int ; c := 0 ;
    var g : int ; g := 0 ;
        var i : int ; i := 0 ; while i < t do ( (         var j : int ; j := 0 ; while j < z do ( (     var colour : String ; colour := in.getCurrent() ;
     if (colour = "C" or colour = "M" or colour = "Y") then (     c := 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (c = 1) then (     break ) else skip )  ;     i := i + 1 ) ; 
    if (c = 1) then (     OclFile["System.out"].println("#Color") ) else (     OclFile["System.out"].println("#Black&White") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    char a[][]=new char[n][m];
    int c1=0,c=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        a[i][j]=sc.next().charAt(0);
        c1++;
      }
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(a[i][j]=='W' || a[i][j]=='G' || a[i][j]=='B')c++;
      }
    }
    if(c1==c)System.out.println("#Black&White");
    else System.out.println("#Color");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var c1 : int ; c1 := 0 ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     a[i+1][j+1] := sc.getCurrent()->at(0+1) ; 
     c1 := c1 + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (a[i+1][j+1] = 'W' or a[i+1][j+1] = 'G' or a[i+1][j+1] = 'B') then     c := c + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (c1 = c) then     OclFile["System.out"].println("#Black&White") else     OclFile["System.out"].println("#Color") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF707_D2_A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    for(int i=0 ; i<n*m ; i++){
      char ch=scanner.next().charAt(0);
      if(ch=='C' || ch=='M' || ch=='Y'){
        System.out.println("#Color");
        System.exit(0);
      }
    }
    System.out.println("#Black&White");
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF707_D2_A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n * m do ( (     var ch : String ; ch := scanner.getCurrent()->at(0+1) ;
     if (ch = 'C' or ch = 'M' or ch = 'Y') then (     OclFile["System.out"].println("#Color") ; 
 OclProcess.exit(0) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("#Black&White") ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.System.*;
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    int flag_b=0 ;
    int flag_c=0 ;
    String[][] arr=new String[x][y];
    for(int i=0 ; i<x ; i++){
      for(int j=0 ; j<y ; j++){
        arr[i][j]=sc.next();
      }
    }
    for(int i=0 ; i<x ; i++){
      for(int j=0 ; j<y ; j++){
        if(arr[i][j] .equals("C")|| arr[i][j] .equals("M")|| arr[i][j] .equals("Y")){
          flag_c=1 ;
          break ;
        }
      }
    }
    if(flag_c==1)out.println("#Color");
    else out.println("#Black&White");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var flag_b : int ; flag_b := 0 ;
    var flag_c : int ; flag_c := 0 ;
    var arr : Sequence(Sequence(String)) ; arr := Integer.subrange(1,x)->collect(Integer.subrange(1,y)->collect(null)) ;
        var i : int ; i := 0 ; while i < x do ( (         var j : int ; j := 0 ; while j < y do ( (     arr[i+1][j+1] := sc.getCurrent() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < x do ( (         var j : int ; j := 0 ; while j < y do ( (     if (arr[i+1][j+1] = "C" or arr[i+1][j+1] = "M" or arr[i+1][j+1] = "Y") then (     flag_c := 1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (flag_c = 1) then     out.println("#Color") else     out.println("#Black&White") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
class GFG {
  static int exponent(int A,int B){
    if(A==0)return 0 ;
    if(B==0)return 1 ;
    int y ;
    if(B % 2==0){
      y=exponent(A,B/2);
      y=(y*y);
    }
    else {
      y=A ;
      y=(y*exponent(A,B-1));
    }
    return y ;
  }
  static int sum(int k,int n){
    int sum=exponent(k,n+1)-exponent(k-1,n+1);
    return sum ;
  }
  public static void main(String[] args){
    int n=3 ;
    int K=3 ;
    System.out.println(sum(K,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation exponent( A : int, B : int) : int
  pre: true
  post: true
  activity: (     if (A = 0) then     return 0 else skip ; 
     if (B = 0) then     return 1 else skip ; 
    var y : int ;
    if (B mod 2 = 0) then (     y := exponent(A, B / 2) ; 
     y := (y * y) ) else (     y := A ; 
     y := (y * exponent(A, B - 1)) ) ;  
    return y 
 );
  static   operation sum( k : int, n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := exponent(k, n + 1) - exponent(k - 1, n + 1) ;
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var K : int ; K := 3 ;
     OclFile["System.out"].println(sum(K, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    sc.close();
    for(int i=0 ; (2*i)<s.length(); i++){
      System.out.print(s.charAt(2*i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
     skip ; 
         var i : int ; i := 0 ; while (2 * i) < s->size() do ( (     OclFile["System.out"].print(s->at(2 * i+1)) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String[] str=in.readLine().split("");
    for(int i=0 ; i<str.length ; i=i+2){
      System.out.print(str[i]);
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := in.readLine()->split("") ;
         var i : int ; i := 0 ; while i < str->size() do ( (     OclFile["System.out"].print(str[i+1]) )  ;     i := i + 2 ) ; 
     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    String s=sc.next();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<s.length(); i+=2){
      sb.append(s.charAt(i));
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := sc.getCurrent() ;
     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < s->size() do ( (     sb := sb + StringLib.newString(s->at(i+1)) )  ;     i := i+(2) ) ; 
     OclFile["System.out"].println(sb) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  public static void main(String[] $){
    char[] v=new java.util.Scanner(System.in).next().toCharArray();
    for(int i=0 ; i<v.length ; i+=2)System.out.print(v[i]);
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var v : Sequence(String) ; v := Scanner.newScanner(OclFile["System.in"]).next()->characters() ;
         var i : int ; i := 0 ; while i < v->size() do (     OclFile["System.out"].print(v[i+1]) ;  ;     i := i+(2) ) ; 
     OclFile["System.out"].println() );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    Pair[] pairs=new Pair[n];
    for(int i=0 ; i<n ; i++){
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      pairs[i]=new Pair(a,b);
    }
    Arrays.sort(pairs);
    PriorityQueue<Pair>pq=new PriorityQueue<Pair>();
    long sum=0 ;
    long ret=0 ;
    for(int i=0 ; i<n ; i++){
      pq.offer(new Pair(pairs[i] .s,pairs[i] .f));
      sum+=pairs[i] .f ;
      while(! pq.isEmpty()&& pq.peek().f*pq.size()<sum)sum-=pq.poll().s ;
      ret=Math.max(ret,pq.size());
    }
    System.out.println(ret);
  }
  class Pair implements Comparable<Pair>{
    long f,s ;
    @ Override public String toString(){
      return "Pair[f="+f+",s="+s+"] " ;
    }
    public Pair(long f,long s){
      super();
      this.f=f ;
      this.s=s ;
    }
    @ Override public int compareTo(Pair o){
      return(int)(f-o.f);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var pairs : Sequence(Map) ; pairs := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
     pairs[i+1] := Map(a, b) )  ;     i := i + 1 ) ; 
    pairs := pairs->sort() ; 
    var pq : Sequence(Map) ; pq := Sequence{} ;
    var sum : long ; sum := 0 ;
    var ret : long ; ret := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     pq := pq->including(Map(pairs[i+1].s, pairs[i+1].f)) ; 
     sum := sum+(pairs[i+1].f) ; 
     while (not(pq->isEmpty()) & pq->min().f * pq->size() < sum) do     sum := sum-(pq->min().s) ; ; 
     ret := Set{ret, pq->size()}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ret) ; 
 );
 class Pair implements Comparable<Map> {
   attribute f : long;
      operation toString() : String
  pre: true
  post: true
  activity: (     return "Pair[f=" + f + ",s=" + s + "] " );
   static operation newPair( f : long, s : long) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(f, s);
    return self );
  operation initialise( f : long, s : long) : void
  pre: true  post: true
  activity: (     execute super() ; 
     self.f := f ; 
     self.s := s );
      operation compareTo( o : Map) : int
  pre: true
  post: true
  activity: (     return (f - o.f)->oclAsType(int) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Map.Entry ;
import java.util.Scanner ;
import java.util.TreeMap ;
class Main {
  static boolean ip(long x){
    if(x==1)return false ;
    for(long i=2 ; i*i<=x ; i++)if(x % i==0)return false ;
    return true ;
  }
  static LinkedList<Long>fact(long n){
    long tn=n ;
    LinkedList<Long>factorize=new LinkedList<Long>();
    if(ip(n)){
      factorize.add(n);
      n/=n ;
    }
    for(long i=2 ; i<=tn ; i++){
      if(n==1)break ;
      if(ip(i)){
        while(n % i==0){
          factorize.add(i);
          n/=i ;
        }
      }
    }
    return factorize ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    TreeMap<Long,Long>map=new TreeMap<Long,Long>();
    for(long i=2 ; i<=N ; i++){
      LinkedList<Long>tmp=fact(i);
      for(long t : tmp){
        map.put(t,(map.containsKey(t))? map.get(t)+1 : 1);
      }
    }
    long ans=1 ;
    for(Entry<Long,Long>ent : map.entrySet()){
      ans*=ent.getValue()+1 ;
      ans %=(1000000000+7);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation ip( x : long) : boolean
  pre: true
  post: true
  activity: (     if (x = 1) then     return false else skip ; 
         var i : long ; i := 2 ; while i * i <= x do (     if (x mod i = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation fact( n : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var tn : long ; tn := n ;
     var factorize : Sequence(long) ; factorize := Sequence{} ;
    if (ip(n)) then (     factorize := factorize->including(n) ; 
     n := n/(n) ) else skip ; 
        var i : long ; i := 2 ; while i <= tn do ( (     if (n = 1) then     break else skip ; 
     if (ip(i)) then (     while (n mod i = 0) do (     factorize := factorize->including(i) ; 
     n := n/(i) ) ) else skip )  ;     i := i + 1 ) ; 
    return factorize 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    var map : Map(long,long) ; map := Map{} ;
        var i : long ; i := 2 ; while i <= N do ( (     var tmp : Sequence(long) ; tmp := fact(i) ;
     for (t : tmp) do ( (     map := map->union(Map{t |-> if (map->keys()->includes(t)) then map->at(t) + 1 else 1 endif}) )  ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 1 ;
    for (ent : map->asSet()) do ( (     ans := ans*(ent.getValue() + 1) ; 
     ans := ans mod (1000000000 + 7) )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    int oddC=0 ;
    if(S.length()% 2==0){
      oddC=S.length()/2 ;
    }
    else {
      oddC=S.length()/2+1 ;
    }
    String odd[]=new String[oddC];
    for(int i=0 ; i<oddC ; i++){
      odd[i]=S.substring(2*i,2*i+1);
    }
    for(int i=0 ; i<oddC ; i++){
      System.out.print(odd[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    var oddC : int ; oddC := 0 ;
    if (S->size() mod 2 = 0) then (     oddC := S->size() / 2 ) else (     oddC := S->size() / 2 + 1 ) ;  
    var odd : Sequence(String) ; odd := Integer.subrange(1,oddC)->collect(null) ;
        var i : int ; i := 0 ; while i < oddC do ( (     odd[i+1] := S.subrange(2 * i+1,2 * i + 1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < oddC do ( (     OclFile["System.out"].print(odd[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int[] pref=new int[100001];
  static int checkPalindrome(int num){
    String str=String.valueOf(num);
    int l=0,r=str.length()-1 ;
    while(l<r){
      if(str.charAt(l)!=str.charAt(r)){
        return 0 ;
      }
      l++;
      r--;
    }
    return num ;
  }
  static void preCompute(){
    for(int i=1 ; i<=100000 ; ++i){
      pref[i]=pref[i-1]+checkPalindrome(i);
    }
  }
  static void printSum(int L,int R){
    System.out.print(pref[R]-pref[L-1]+"\n");
  }
  static void printSumPalindromic(int arr[][],int Q){
    preCompute();
    for(int i=0 ; i<Q ; i++){
      printSum(arr[i][0],arr[i][1]);
    }
  }
  public static void main(String[] args){
    int Q=2 ;
    int arr[][]={
      {
        10,13 },{
          12,21 }
        };
        printSumPalindromic(arr,Q);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute pref : Sequence(int) := Integer.subrange(1,100001)->collect(0);
  static   operation checkPalindrome( num : int) : int
  pre: true
  post: true
  activity: (     var str : String ; str := ((num) + "") ;
     var l : int ; l := 0 ;
    var r : int ; r := str->size() - 1 ;
     while (l < r) do (     if (str->at(l+1) /= str->at(r+1)) then (     return 0 ) else skip ; 
     l := l + 1 ; 
     r := r - 1 ) ; 
     return num );
  static   operation preCompute() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= 100000 do ( (     pref[i+1] := pref[i - 1+1] + checkPalindrome(i) )  ;     i := i + 1 ) );
  static   operation printSum( L : int, R : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(pref[R+1] - pref[L - 1+1] + "\n") );
  static   operation printSumPalindromic( arr : Sequence(Sequence(int)), Q : int) : void
  pre: true
  post: true
  activity: (     execute preCompute() ; 
         var i : int ; i := 0 ; while i < Q do ( (     execute printSum(arr[i+1][0+1], arr[i+1][1+1]) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Q : int ; Q := 2 ;
     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{10,13},Sequence{12,21}} ;
     execute printSumPalindromic(arr, Q) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  static Scanner scan=new Scanner(System.in);
  static long H=scan.nextLong();
  static long min=0 ;
  static Set<Long>memo=new HashSet<Long>();
  static Map<Long,Long>me=new HashMap<Long,Long>();
  static ArrayList<Long>meno=new ArrayList<Long>();
  static Set<Boolean>cheak=new HashSet<Boolean>();
  public static void main(String[] args){
    System.out.println(monster(H));
  }
  private static long monster(long h){
    if(h==1){
      return 1 ;
    }
    else {
      long k=h/2 ;
      return 1+2*monster(k);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute H : long := scan.getCurrent()->toLong();
  static   attribute min : long := 0;
  static   attribute memo : Set(long) := Set{};
  static   attribute me : Map(long,long) := Map{};
  static   attribute meno : Sequence(long) := Sequence{};
  static   attribute cheak : Set(Boolean) := Set{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(monster(H)) );
  static   operation monster( h : long) : long
  pre: true
  post: true
  activity: (     if (h = 1) then (     return 1 ) else (     var k : long ; k := h / 2 ;
     return 1 + 2 * monster(k) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.BufferedReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.io.IOException ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.math.BigInteger ;
public class Main {
  static InputReader in=new InputReader(System.in);
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    long n=in.nextLong();
    long sum=1 ;
    long count=1 ;
    while(n>1){
      sum+=Math.pow(2,count);
++count ;
      n/=2 ;
    }
    out.println(sum);
    out.close();
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return null ;
    }
    public boolean hasNext(){
      String next=null ;
      try {
        next=reader.readLine();
      }
      catch(Exception e){
      }
      if(next==null){
        return false ;
      }
      tokenizer=new StringTokenizer(next);
      return true ;
    }
    public BigInteger nextBigInteger(){
      return new BigInteger(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : InputReader := InputReader.newInputReader(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := in.nextLong() ;
     var sum : long ; sum := 1 ;
    var count : long ; count := 1 ;
    while (n > 1) do (     sum := sum+(2->pow(count)) ; 
     count := count + 1 ; 
     n := n/(2) ) ; 
    skip ; 
    skip ; 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return null );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     var next : String ; next := null ;
     try (     next := reader.readLine() )   catch (e : ProgramException) do skip
    if (next = null) then (     return false ) else skip ; 
    tokenizer := OclIterator.newOclIterator_String(next) ; 
    return true 
 );
   operation nextBigInteger() : long
  pre: true
  post: true
  activity: (     return long(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  final static long MOD=1000000007 ;
  public static void main(String[] args)throws Exception {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String W=in.readLine();
    long H=Long.parseLong(W);
    ;
    long X=H ;
    long n=1 ;
    while(X!=1){
      X=X/2 ;
      n++;
    }
    System.out.println((long)Math.pow(2,n)-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : long := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var W : String ; W := in.readLine() ;
    var H : long ; H := (W)->toLong() ;
    var X : long ; X := H ;
    var n : long ; n := 1 ;
    while (X /= 1) do (     X := X / 2 ; 
     n := n + 1 ) ; 
    OclFile["System.out"].println(2->pow(n)->oclAsType(long) - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PipedInputStream ;
import java.util.*;
public class Main {
  private static final int MOD=(int)Math.pow(10,9);
  private static final int[][] DIRS={
    {
      0,1 },{
        0,-1 },{
          1,0 },{
-1,0 }
          };
          public static void main(String[] args){
            FastReader sc=new FastReader();
            long m=sc.nextLong();
            int pow=(int)(Math.log(m)/Math.log(2))+1 ;
            long res=(long)Math.pow(2.0,pow*1.0)-1L ;
            System.out.println(res);
            System.exit(0);
          }
          static private class Point {
            public int x ;
            public int y ;
            Point(int x,int y){
              this.x=x ;
              this.y=y ;
            }
          }
          static private long gcd(long m,long n){
            if(m<n){
              return gcd(n,m);
            }
            if(m % n==0){
              return n ;
            }
            return gcd(n,m % n);
          }
          static class FastReader {
            BufferedReader br ;
            StringTokenizer st ;
            public FastReader(){
              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 ;
            }
          }
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 10->pow(9)->oclAsType(int);
  static    attribute DIRS : Sequence(Sequence(int)) := Sequence{Sequence{0,1},Sequence{0,-1},Sequence{1,0},Sequence{-1,0}};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var m : long ; m := sc.nextLong() ;
    var pow : int ; pow := ((m)->log() / (2)->log())->oclAsType(int) + 1 ;
    var res : long ; res := 2.0->pow(pow * 1.0)->oclAsType(long) - 1L ;
    OclFile["System.out"].println(res) ; 
OclProcess.exit(0) ; 
 );
  static  class Point {
   attribute x : int;
   attribute y : int;
   static operation newPoint( x : int, y : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}
  static    operation gcd( m : long, n : long) : long
  pre: true
  post: true
  activity: (     if (m < n) then (     return gcd(n, m) ) else skip ; 
     if (m mod n = 0) then (     return n ) else skip ; 
     return gcd(n, m mod n) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static long f(long X){
    if(X==1){
      return 1 ;
    }
    long H=X/2 ;
    return 2*f(H)+1 ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long H=sc.nextLong();
    System.out.println(f(H));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation f( X : long) : long
  pre: true
  post: true
  activity: (     if (X = 1) then (     return 1 ) else skip ; 
     var H : long ; H := X / 2 ;
     return 2 * f(H) + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : long ; H := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println(f(H)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  final static long MODULO=1_000_000_000+7 ;
  static ArrayList<Integer>divs ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long K=sc.nextLong();
    divs=new ArrayList<>();
    for(int i=1 ; i*i<=N ; ++i){
      if(N % i==0){
        divs.add(i);
        if(i*i!=N){
          divs.add(N/i);
        }
      }
    }
    Collections.sort(divs);
    HashMap<Integer,Long>dp=new HashMap<>();
    for(int d : divs){
      dp.put(d,pow(K,(d+1)/2));
      for(int i=0 ; divs.get(i)<d ; ++i){
        if(d % divs.get(i)==0)dp.put(d,(dp.get(d)-dp.get(divs.get(i))+MODULO)% MODULO);
      }
    }
    long ans=0 ;
    for(int d : divs){
      ans=(ans+dp.get(d)*(d % 2==0 ? d/2 : d))% MODULO ;
    }
    System.out.println(ans);
  }
  static class Div {
    int div ;
    int num ;
    public Div(int div,int num){
      this.div=div ;
      this.num=num ;
    }
  }
  static long pow(long a,long n){
    long ret=1 ;
    for(; n>0 ; n>>=1,a=(a*a)% MODULO){
      if(n % 2==1){
        ret=(ret*a)% MODULO ;
      }
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MODULO : long := 1_000_000_000 + 7;
  static   attribute divs : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : long ; K := sc.getCurrent()->toLong() ;
    divs := Sequence{} ; 
        var i : int ; i := 1 ; while i * i <= N do ( (     if (N mod i = 0) then (     divs := divs->including(i) ; 
     if (i * i /= N) then (     divs := divs->including(N / i) ) else skip ) else skip )  ;     i := i + 1 ) ; 
    divs := divs->sort() ; 
    var dp : Map(int,long) ; dp := Map{} ;
    for (d : divs) do ( (     dp := dp->union(Map{d |-> pow(K, (d + 1) / 2)}) ; 
         var i : int ; i := 0 ; while divs->at(i+1) < d do ( (     if (d mod divs->at(i+1) = 0) then     dp := dp->union(Map{d |-> (dp->at(d) - dp->at(divs->at(i+1)) + MODULO) mod MODULO}) ; else skip )  ;     i := i + 1 ) )  ) ; 
    var ans : long ; ans := 0 ;
    for (d : divs) do ( (     ans := (ans + dp->at(d) * (if d mod 2 = 0 then d / 2 else d endif)) mod MODULO )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class Div {
   attribute div : int;
   attribute num : int;
   static operation newDiv( div : int, num : int) : Div
  pre: true
  post: true
  activity:
  ( var self : Div ;
    self := createDiv();
    self.initialise(div, num);
    return self );
  operation initialise( div : int, num : int) : void
  pre: true  post: true
  activity: (     self.div := div ; 
     self.num := num );
}
  static   operation pow( a : long, n : long) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := 1 ;
       while n > 0 do ( (     if (n mod 2 = 1) then (     ret := (ret * a) mod MODULO ) else skip )  ;     n := n/(2->pow(1)) ;     a := (a * a) mod MODULO ) ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static final long MOD=1_000_000_007 ;
  public static void main(String[] args){
    long N=sc.nextInt();
    long K=sc.nextInt();
    if(N==1){
      System.out.println(K);
      return ;
    }
    ArrayList<Long>divisor=new ArrayList<>();
    for(long i=2 ; i*i<=N ; i++){
      if(N % i!=0)continue ;
      divisor.add(i);
      if(i*i!=N){
        divisor.add(N/i);
      }
    }
    divisor.add(N);
    Collections.sort(divisor);
    HashMap<Long,Long>map=new HashMap<>();
    map.put(1L,K);
    for(long d : divisor){
      long add=pow(K,(d+1)/2)-K ;
      for(long i=2 ; i*i<=d ; i++){
        if(d % i!=0)continue ;
        add+=MOD-map.get(i);
        if(i*i!=d)add+=MOD-map.get(d/i);
      }
      map.put(d,add % MOD);
    }
    long ans=0 ;
    for(long k : map.keySet()){
      ans+=(k % 2==0 ? k/2 : k)*map.get(k);
    }
    System.out.println(ans % MOD);
  }
  static long pow(long base,long p){
    if(p==0)return 1 ;
    if(p==1)return base ;
    long ret=pow(base,p/2);
    ret=ret*ret % MOD ;
    if(p % 2==1){
      ret=ret*base % MOD ;
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute MOD : long := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := sc.getCurrent()->toInteger() ;
     var K : long ; K := sc.getCurrent()->toInteger() ;
    if (N = 1) then (     OclFile["System.out"].println(K) ; 
     return ) else skip ; 
    var divisor : Sequence(long) ; divisor := Sequence{} ;
        var i : long ; i := 2 ; while i * i <= N do ( (     if (N mod i /= 0) then     continue else skip ; 
     divisor := divisor->including(i) ; 
     if (i * i /= N) then (     divisor := divisor->including(N / i) ) else skip )  ;     i := i + 1 ) ; 
    divisor := divisor->including(N) ; 
    divisor := divisor->sort() ; 
    var map : Map(long,long) ; map := Map{} ;
    map := map->union(Map{1L |-> K}) ; 
    for (d : divisor) do ( (     var add : long ; add := pow(K, (d + 1) / 2) - K ;
         var i : long ; i := 2 ; while i * i <= d do ( (     if (d mod i /= 0) then     continue else skip ; 
     add := add+(MOD - map->at(i)) ; 
     if (i * i /= d) then     add := add+(MOD - map->at(d / i)) ; else skip )  ;     i := i + 1 ) ; 
     map := map->union(Map{d |-> add mod MOD}) )  ) ; 
    var ans : long ; ans := 0 ;
    for (k : map->keys()) do ( (     ans := ans+((if k mod 2 = 0 then k / 2 else k endif) * map->at(k)) )  ) ; 
    OclFile["System.out"].println(ans mod MOD) ; 
 );
  static   operation pow( base : long, p : long) : long
  pre: true
  post: true
  activity: (     if (p = 0) then     return 1 else skip ; 
     if (p = 1) then     return base else skip ; 
    var ret : long ; ret := pow(base, p / 2) ;
    ret := ret * ret mod MOD ; 
    if (p mod 2 = 1) then (     ret := ret * base mod MOD ) else skip ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static int N=3 ;
  static void interchangeDiagonals(int array[][]){
    for(int i=0 ; i<N ; ++i)if(i!=N/2){
      int temp=array[i][i];
      array[i][i]=array[i][N-i-1];
      array[i][N-i-1]=temp ;
    }
    for(int i=0 ; i<N ; ++i){
      for(int j=0 ; j<N ; ++j)System.out.print(array[i][j]+" ");
      System.out.println();
    }
  }
  public static void main(String[] args){
    int array[][]={
      {
        4,5,6 },{
          1,2,3 },{
            7,8,9 }
          };
          interchangeDiagonals(array);
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 3;
  static   operation interchangeDiagonals( array : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do (     if (i /= N / 2) then (     var temp : int ; temp := array[i+1][i+1] ;
     array[i+1][i+1] := array[i+1][N - i - 1+1] ; 
     array[i+1][N - i - 1+1] := temp ) else skip ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do (     OclFile["System.out"].print(array[i+1][j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var array : Sequence(Sequence(int)) ; array := Sequence{Sequence{4,5,6},Sequence{1,2,3},Sequence{7,8,9}} ;
     execute interchangeDiagonals(array) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class gfg {
  static boolean isSubArray(int A[],int B[],int n,int m){
    int i=0,j=0 ;
    while(i<n && j<m){
      if(A[i]==B[j]){
        i++;
        j++;
        if(j==m)return true ;
      }
      else {
        i=i-j+1 ;
        j=0 ;
      }
    }
    return false ;
  }
  public static void main(String arr[]){
    int A[]={
      2,3,0,5,1,1,2 };
      int n=A.length ;
      int B[]={
        3,0,5,1 };
        int m=B.length ;
        if(isSubArray(A,B,n,m))System.out.println("YES");
        else System.out.println("NO");
      }
    }

------------------------------------------------------------
OCL File:
---------
class gfg {
  static   operation isSubArray( A : Sequence(int), B : Sequence(int), n : int, m : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var j : int ; j := 0 ;
     while (i < n & j < m) do (     if (A[i+1] = B[j+1]) then (     i := i + 1 ; 
     j := j + 1 ; 
     if (j = m) then     return true else skip ) else (     i := i - j + 1 ; 
     j := 0 ) ) ; 
     return false );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{2,3,0,5,1,1,2} ;
     var n : int ; n := A->size() ;
    var B : Sequence(int) ; B := Sequence{3,0,5,1} ;
    var m : int ; m := B->size() ;
    if (isSubArray(A, B, n, m)) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    long mod=(long)Math.pow(10,9)+7 ;
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long ans=1 ;
    HashMap<Long,Integer>map=new HashMap<Long,Integer>();
    for(long i=2 ; i<=n ; i++){
      map=factorization(map,i);
    }
    for(Map.Entry<Long,Integer>e : map.entrySet()){
      if(e.getKey()==1){
        continue ;
      }
      ans*=(e.getValue()+1);
      ans %=mod ;
    }
    System.out.println(ans);
  }
  static HashMap<Long,Integer>factorization(HashMap<Long,Integer>ret,long x){
    int div2=0 ;
    while(x % 2==0){
      x/=2 ;
      div2++;
    }
    if(div2!=0){
      if(ret.containsKey(2L)){
        ret.put(2L,ret.get(2L)+div2);
      }
      else {
        ret.put(2L,div2);
      }
    }
    long d=3 ;
    while(x/d>=d){
      int cnt=0 ;
      while(x % d==0){
        cnt++;
        x/=d ;
      }
      if(cnt!=0){
        if(ret.containsKey(d)){
          ret.put(d,ret.get(d)+cnt);
        }
        else {
          ret.put(d,cnt);
        }
      }
      d+=2 ;
    }
    if(ret.containsKey(x)){
      ret.put(x,ret.get(x)+1);
    }
    else {
      ret.put(x,1);
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mod : long ; mod := 10->pow(9)->oclAsType(long) + 7 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : long ; n := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 1 ;
    var map : Map(long,int) ; map := Map{} ;
        var i : long ; i := 2 ; while i <= n do ( (     map := factorization(map, i) )  ;     i := i + 1 ) ; 
    for (e : map->asSet()) do ( (     if (e.getKey() = 1) then (     continue ) else skip ; 
     ans := ans*((e.getValue() + 1)) ; 
     ans := ans mod mod )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation factorization( ret : Map(long,int), x : long) : Map(long,int)
  pre: true
  post: true
  activity: (     var div2 : int ; div2 := 0 ;
     while (x mod 2 = 0) do (     x := x/(2) ; 
     div2 := div2 + 1 ) ; 
    if (div2 /= 0) then (     if (ret.containsKey(2L)) then (     ret := ret->union(Map{2L |-> ret->at(2L+1) + div2}) ) else (     ret := ret->union(Map{2L |-> div2}) ) ) else skip ; 
    var d : long ; d := 3 ;
    while (x / d >= d) do (     var cnt : int ; cnt := 0 ;
     while (x mod d = 0) do (     cnt := cnt + 1 ; 
     x := x/(d) ) ; 
     if (cnt /= 0) then (     if (ret.containsKey(d)) then (     ret := ret->union(Map{d |-> ret->at(d+1) + cnt}) ) else (     ret := ret->union(Map{d |-> cnt}) ) ) else skip ; 
     d := d+(2) ) ; 
    if (ret.containsKey(x)) then (     ret := ret->union(Map{x |-> ret->at(x+1) + 1}) ) else (     ret := ret->union(Map{x |-> 1}) ) ;  
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    Pair[] pairs=new Pair[n];
    for(int i=0 ; i<n ; i++){
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      pairs[i]=new Pair(a,b);
    }
    Arrays.sort(pairs);
    PriorityQueue<Pair>pq=new PriorityQueue<Pair>();
    long sum=0 ;
    long ret=0 ;
    for(Pair p : pairs){
      pq.offer(new Pair(p.s,p.f));
      sum+=p.f ;
      while(! pq.isEmpty()){
        Pair pair=pq.peek();
        long a=pair.f*pq.size();
        if(a>=sum)break ;
        sum-=pq.poll().s ;
      }
      ret=Math.max(ret,pq.size());
    }
    System.out.println(ret);
  }
  class Pair implements Comparable<Pair>{
    long f,s ;
    @ Override public String toString(){
      return "Pair[f="+f+",s="+s+"] " ;
    }
    public Pair(long f,long s){
      super();
      this.f=f ;
      this.s=s ;
    }
    @ Override public int compareTo(Pair o){
      return(int)(f-o.f);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var pairs : Sequence(Map) ; pairs := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
     pairs[i+1] := Map(a, b) )  ;     i := i + 1 ) ; 
    pairs := pairs->sort() ; 
    var pq : Sequence(Map) ; pq := Sequence{} ;
    var sum : long ; sum := 0 ;
    var ret : long ; ret := 0 ;
    for (p : pairs) do ( (     pq := pq->including(Map(p.s, p.f)) ; 
     sum := sum+(p.f) ; 
     while (not(pq->isEmpty())) do (     var pair : Map ; pair := pq->min() ;
     var a : long ; a := pair.f * pq->size() ;
     if (a >= sum) then     break else skip ; 
     sum := sum-(pq->min().s) ) ; 
     ret := Set{ret, pq->size()}->max() )  ) ; 
    OclFile["System.out"].println(ret) ; 
 );
 class Pair implements Comparable<Map> {
   attribute f : long;
      operation toString() : String
  pre: true
  post: true
  activity: (     return "Pair[f=" + f + ",s=" + s + "] " );
   static operation newPair( f : long, s : long) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(f, s);
    return self );
  operation initialise( f : long, s : long) : void
  pre: true  post: true
  activity: (     execute super() ; 
     self.f := f ; 
     self.s := s );
      operation compareTo( o : Map) : int
  pre: true
  post: true
  activity: (     return (f - o.f)->oclAsType(int) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class P1065A {
  public static void main(String[] args)throws IOException {
    BufferedReader io=new BufferedReader(new InputStreamReader(System.in));
    Integer cnt=Integer.valueOf(io.readLine());
    List<Long>rs=new ArrayList<Long>();
    while(cnt>0){
      cnt--;
      String[] input=io.readLine().split(" ");
      Long s=Long.valueOf(input[0]);
      Long a=Long.valueOf(input[1]);
      Long b=Long.valueOf(input[2]);
      Long c=Long.valueOf(input[3]);
      Long tmp=s/c ;
      tmp=(tmp/a)*b+tmp ;
      rs.add(tmp);
    }
    for(Long long1 : rs){
      System.out.println(long1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P1065A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var cnt : int ; cnt := (io.readLine())->toInteger() ;
    var rs : Sequence(long) ; rs := Sequence{} ;
    while (cnt > 0) do (     cnt := cnt - 1 ; 
     var input : Sequence(String) ; input := io.readLine()->split(" ") ;
    var s : long ; s := (input[0+1])->toLong() ;
    var a : long ; a := (input[1+1])->toLong() ;
    var b : long ; b := (input[2+1])->toLong() ;
    var c : long ; c := (input[3+1])->toLong() ;
    var tmp : long ; tmp := s / c ;
    tmp := (tmp / a) * b + tmp ; 
    rs := rs->including(tmp) ; 
 ) ; 
    for (long1 : rs) do ( (     OclFile["System.out"].println(long1) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class21 {
  public static void main(String arg[]){
    Scanner input=new Scanner(System.in);
    int p=input.nextInt();
    while(p-->0){
      long v,d,e,f ;
      v=input.nextLong();
      d=input.nextLong();
      e=input.nextLong();
      f=input.nextLong();
      v/=f ;
      long x=v/d ;
      v %=d ;
      long ans=x*(d+e);
      ans+=v ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class21 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : int ; p := input.getCurrent()->toInteger() ;
         while (p > 0) do (        p := p - 1 ;     skip ; (     var v : long ;
    var d : long ;
    var e : long ;
    var f : long ;
     v := input.getCurrent()->toLong() ; 
    d := input.getCurrent()->toLong() ; 
    e := input.getCurrent()->toLong() ; 
    f := input.getCurrent()->toLong() ; 
    v := v/(f) ; 
    var x : long ; x := v / d ;
    v := v mod d ; 
    var ans : long ; ans := x * (d + e) ;
    ans := ans+(v) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1065A_VasyaandChocolate {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=input.nextInt();
    while(test-->0){
      long s=input.nextLong();
      long a=input.nextLong();
      long b=input.nextLong();
      long c=input.nextLong();
      long capable=s/c ;
      long bought=capable/a ;
      long result=capable+(bought*b);
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1065A_VasyaandChocolate {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := input.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var s : long ; s := input.getCurrent()->toLong() ;
     var a : long ; a := input.getCurrent()->toLong() ;
    var b : long ; b := input.getCurrent()->toLong() ;
    var c : long ; c := input.getCurrent()->toLong() ;
    var capable : long ; capable := s / c ;
    var bought : long ; bought := capable / a ;
    var result : long ; result := capable + (bought * b) ;
    OclFile["System.out"].println(result) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=100000 ;
  static boolean[] prime=new boolean[100002];
  static void SieveOfEratosthenes(){
    for(int p=2 ; p*p<=MAX ; p++)if(prime[p]==false)for(int i=p*2 ; i<=MAX ; i+=p)prime[i]=true ;
  }
  static int superpower(int n){
    SieveOfEratosthenes();
    int superPower=0,factor=0 ;
    int i=2 ;
    while(n>1 && i<=MAX){
      if(! prime[i]){
        factor=0 ;
        while(n % i==0 && n>1){
          factor++;
          n=n/i ;
        }
        if(superPower<factor)superPower=factor ;
      }
      i++;
    }
    return superPower ;
  }
  public static void main(String[] args){
    int n=256 ;
    System.out.println(superpower(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100000;
  static   attribute prime : Sequence(boolean) := Integer.subrange(1,100002)->collect(false);
  static   operation SieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (         var p : int ; p := 2 ; while p * p <= MAX do (     if (prime[p+1] = false) then         var i : int ; i := p * 2 ; while i <= MAX do (     prime[i+1] := true ;  ;     i := i+(p) ) ; else skip ;  ;     p := p + 1 ) );
  static   operation superpower( n : int) : int
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes() ; 
     var superPower : int ; superPower := 0 ;
    var factor : int ; factor := 0 ;
    var i : int ; i := 2 ;
    while (n > 1 & i <= MAX) do (     if (not(prime[i+1])) then (     factor := 0 ; 
     while (n mod i = 0 & n > 1) do (     factor := factor + 1 ; 
     n := n / i ) ; 
     if (superPower < factor) then     superPower := factor ; else skip ) else skip ; 
     i := i + 1 ) ; 
    return superPower 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 256 ;
     OclFile["System.out"].println(superpower(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class solution {
  static void printSubArrays(int[] arr,int start,int end){
    if(end==arr.length)return ;
    else if(start>end)printSubArrays(arr,0,end+1);
    else {
      System.out.print("[");
      for(int i=start ; i<end ; i++){
        System.out.print(arr[i]+",");
      }
      System.out.println(arr[end]+"] ");
      printSubArrays(arr,start+1,end);
    }
    return ;
  }
  public static void main(String args[]){
    int[] arr={
      1,2,3 };
      printSubArrays(arr,0,0);
    }
  }

------------------------------------------------------------
OCL File:
---------
class solution {
  static   operation printSubArrays( arr : Sequence(int), start : int, end : int) : void
  pre: true
  post: true
  activity: (     if (end = arr->size()) then     return else     if (start > end) then     execute printSubArrays(arr, 0, end + 1) else (     OclFile["System.out"].print("[") ; 
         var i : int ; i := start ; while i < end do ( (     OclFile["System.out"].print(arr[i+1] + ",") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(arr[end+1] + "] ") ; 
     execute printSubArrays(arr, start + 1, end) ) ;  ;  
     return );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3} ;
     execute printSubArrays(arr, 0, 0) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static boolean isDivisible999(String num){
    int n=num.length();
    if(n==0 && num.charAt(0)=='0')return true ;
    if(n % 3==1)num="00"+num ;
    if(n % 3==2)num="0"+num ;
    int gSum=0 ;
    for(int i=0 ; i<n ; i++){
      int group=0 ;
      group+=(num.charAt(i++)-'0')*100 ;
      group+=(num.charAt(i++)-'0')*10 ;
      group+=num.charAt(i)-'0' ;
      gSum+=group ;
    }
    if(gSum>1000){
      num=Integer.toString(gSum);
      n=num.length();
      gSum=isDivisible999(num)? 1 : 0 ;
    }
    return(gSum==999);
  }
  public static void main(String args[]){
    String num="1998" ;
    System.out.println(isDivisible999(num)? "Divisible" : "Not divisible");
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation isDivisible999( num : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := num->size() ;
     if (n = 0 & num->at(0+1) = '0') then     return true else skip ; 
    if (n mod 3 = 1) then     num := "00" + num ; else skip ; 
    if (n mod 3 = 2) then     num := "0" + num ; else skip ; 
    var gSum : int ; gSum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var group : int ; group := 0 ;
     group := group+((num->at(i+1) - ('0')->char2byte()) * 100) ; 
    group := group+((num->at(i+1) - ('0')->char2byte()) * 10) ; 
    group := group+(num->at(i+1) - ('0')->char2byte()) ; 
    gSum := gSum+(group) ; 
 )  ;     i := i + 1 ) ; 
    if (gSum > 1000) then (     num := ((gSum) + "") ; 
     n := num->size() ; 
     gSum := if isDivisible999(num) then 1 else 0 endif ) else skip ; 
    return (gSum = 999) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : String ; num := "1998" ;
     OclFile["System.out"].println(if isDivisible999(num) then "Divisible" else "Not divisible" endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Straight_A {
  public static void main(String[] args){
    java.util.Scanner kbd=new java.util.Scanner(System.in);
    int n=kbd.nextInt();
    int k=kbd.nextInt();
    int[] marks=new int[n];
    int c=0 ;
    double cur_gr=0 ;
    int total=0 ;
    for(int i=0 ; i<n ; i++){
      marks[i]=kbd.nextInt();
      total+=marks[i];
      cur_gr=Math.round(total/n);
    }
    double r=0 ;
    do {
      r=Math.round(((double)total+(c*k))/(n));
      c++;
      n++;
    }
    while(r<k);
    System.out.println(c-1);
  }
}
------------------------------------------------------------
OCL File:
---------
class Straight_A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var kbd : Scanner ; kbd := Scanner.newScanner(OclFile["System.in"]) ;
     var n : int ; n := kbd.nextInt() ;
    var k : int ; k := kbd.nextInt() ;
    var marks : Sequence(int) ; marks := Integer.subrange(1,n)->collect(0) ;
    var c : int ; c := 0 ;
    var cur_gr : double ; cur_gr := 0 ;
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     marks[i+1] := kbd.nextInt() ; 
     total := total+(marks[i+1]) ; 
     cur_gr := (total / n)->round() )  ;     i := i + 1 ) ; 
    var r : double ; r := 0 ;
  while true do ((     r := ((total->oclAsType(double) + (c * k)) / (n))->round() ; 
     c := c + 1 ; 
     n := n + 1 ) ;
    if (r < k) then skip else break) ; 
    OclFile["System.out"].println(c - 1) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class P810A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=scan.nextInt();
    int total=0 ;
    for(int i=0 ; i<n ; i++)total+=arr[i];
    for(int i=0 ; ; i++){
      if((int)Math.round(total*1.0/(n+i))==k){
        System.out.println(i);
        return ;
      }
      total+=k ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P810A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := scan.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < n do (     total := total+(arr[i+1]) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while true do ( (     if ((total * 1.0 / (n + i))->round()->oclAsType(int) = k) then (     OclFile["System.out"].println(i) ; 
     return ) else skip ; 
     total := total+(k) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
public class My25goal {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int k=s.nextInt();
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      int z=s.nextInt();
      sum+=z ;
    }
    double an=sum/(double)n ;
    double q ;
    if(Math.round(an)==k){
      q=0 ;
    }
    else {
      q=((n*(k-0.5))-sum)/0.5 ;
    }
    int answer=(int)q ;
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class My25goal {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var k : int ; k := s.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var z : int ; z := s.getCurrent()->toInteger() ;
     sum := sum+(z) )  ;     i := i + 1 ) ; 
    var an : double ; an := sum / n->oclAsType(double) ;
    var q : double ;
    if ((an)->round() = k) then (     q := 0 ) else (     q := ((n * (k - 0.5)) - sum) / 0.5 ) ;  
    var answer : int ; answer := q->oclAsType(int) ;
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  private void solve(Scanner in,PrintWriter out){
    int N=in.nextInt();
    int[] primes=getPrimes(N+1);
    TreeMap<Integer,Integer>count=new TreeMap<>();
    for(int n=1 ; n<=N ; n++){
      int x=n ;
      for(int prime : primes){
        while(x % prime==0){
          Integer c=count.get(prime);
          if(c==null)count.put(prime,1);
          else count.put(prime,c+1);
          x/=prime ;
        }
        if(x==1)break ;
      }
    }
    int MOD=(int)(1e9+7);
    long ans=1 ;
    for(Map.Entry<Integer,Integer>entry : count.entrySet()){
      ans*=(entry.getValue()+1);
      ans %=MOD ;
    }
    out.println(ans);
  }
  public static int[] getPrimes(int N){
    ArrayList<Integer>primes=new ArrayList<>();
    boolean[] isComposite=new boolean[N+1];
    primes.add(2);
    for(int i=3 ; i<=N ; i+=2)if(! isComposite[i]){
      primes.add(i);
      for(int j=i*2 ; j<=N ; j+=i){
        isComposite[j]=true ;
      }
    }
    int[] array=new int[primes.size()];
    for(int i=0 ; i<primes.size(); i++){
      array[i]=primes.get(i);
    }
    return array ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    new Main().solve(in,out);
    in.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve( in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.nextInt() ;
     var primes : Sequence(int) ; primes := getPrimes(N + 1) ;
    var count : Map(int,int) ; count := Map{} ;
        var n : int ; n := 1 ; while n <= N do ( (     var x : int ; x := n ;
     for (prime : primes) do ( (     while (x mod prime = 0) do (     var c : int ; c := count->at(prime) ;
     if (c = null) then     count := count->union(Map{prime |-> 1}) else     count := count->union(Map{prime |-> c + 1}) ; ;  
     x := x/(prime) ) ; 
     if (x = 1) then     break else skip )  ) )  ;     n := n + 1 ) ; 
    var MOD : int ; MOD := (1e9 + 7)->oclAsType(int) ;
    var ans : long ; ans := 1 ;
    for (entry : count->asSet()) do ( (     ans := ans*((entry.getValue() + 1)) ; 
     ans := ans mod MOD )  ) ; 
    out.println(ans) ; 
 );
  static   operation getPrimes( N : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var primes : Sequence(int) ; primes := Sequence{} ;
     var isComposite : Sequence(boolean) ; isComposite := Integer.subrange(1,N + 1)->collect(false) ;
    primes := primes->including(2) ; 
        var i : int ; i := 3 ; while i <= N do (     if (not(isComposite[i+1])) then (     primes := primes->including(i) ; 
         var j : int ; j := i * 2 ; while j <= N do ( (     isComposite[j+1] := true )  ;     j := j+(i) ) ) else skip ;  ;     i := i+(2) ) ; 
    var array : Sequence(int) ; array := Integer.subrange(1,primes->size())->collect(0) ;
        var i : int ; i := 0 ; while i < primes->size() do ( (     array[i+1] := primes->at(i+1) )  ;     i := i + 1 ) ; 
    return array 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    Main.newMain().solve(in, out) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javax.print.DocFlavor ;
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    InputReader in=new InputReader();
    PrintWriter out=new PrintWriter(System.out);
    int test_cases=1 ;
    Solver s=new Solver();
    for(int i=test_cases ; i>=1 ; i--){
      s.solve(1,in,out);
    }
    out.close();
  }
}
class Solver {
  void solve(int test_number,InputReader in,PrintWriter out)throws IOException {
    int n=in.nextInt();
    int k=in.nextInt();
    double sum=0 ;
    double size=n ;
    for(int i=0 ; i<n ; i++){
      sum+=in.nextDouble();
    }
    int c=0 ;
    while(Math.round(sum/size)<k){
      c++;
      sum+=k ;
      size++;
    }
    out.println(c);
  }
}
class InputReader {
  BufferedReader br ;
  StringTokenizer st ;
  public InputReader(){
    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 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : InputReader ; in := InputReader.newInputReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test_cases : int ; test_cases := 1 ;
    var s : Solver ; s := Solver.newSolver() ;
        var i : int ; i := test_cases ; while i >= 1 do ( (     s.solve(1, in, out) )  ;     i := i - 1 ) ; 
    skip ; 
 );
}
class Solver {
   operation solve( test_number : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var k : int ; k := in.nextInt() ;
    var sum : double ; sum := 0 ;
    var size : double ; size := n ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(in.nextDouble()) )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
    while ((sum / size)->round() < k) do (     c := c + 1 ; 
     sum := sum+(k) ; 
     size := size + 1 ) ; 
    skip ; 
 );
}
class InputReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newInputReader() : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  class B implements Comparable<B>{
    int a,b ;
    public B(int a,int b){
      this.a=a ;
      this.b=b ;
    }
    public int compareTo(B o){
      return o.b-b ;
    }
  }
  int n ;
  B[] r ;
  boolean ok(int x){
    if(x==0)return true ;
    PriorityQueue<B>q=new PriorityQueue<B>(x,new Comparator<B>(){
      public int compare(B o1,B o2){
        return o2.a-o1.a ;
      }
    }
);
    long A=0 ;
    for(int i=0 ; i<x-1 ; i++){
      A+=r[i] .a ;
      q.add(r[i]);
    }
    for(int i=x-1 ; i<n ; i++){
      long w=(long)x*r[i] .b-r[i] .a ;
      if(A<=w)return true ;
      A+=r[i] .a ;
      q.add(r[i]);
      A-=q.poll().a ;
    }
    return false ;
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    r=new B[n];
    for(int i=0 ; i<n ; i++)r[i]=new B(sc.nextInt(),sc.nextInt());
    Arrays.sort(r);
    int L=0,R=n ;
    while(R-L>1){
      int m=(L+R)/2 ;
      if(ok(m))L=m ;
      else R=m ;
    }
    System.out.println(ok(R)? R : L);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class B implements Comparable<B> {
   attribute a : int;
   static operation newB( a : int, b : int) : B
  pre: true
  post: true
  activity:
  ( var self : B ;
    self := createB();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
   operation compareTo( o : B) : int
  pre: true
  post: true
  activity: (     return o.b - b );
}
   attribute n : int;
   attribute r : Sequence(B);
   operation ok( x : int) : boolean
  pre: true
  post: true
  activity: (     if (x = 0) then     return true else skip ; 
     var q : Sequence(B) ; q := Sequence{} ;
    var A : long ; A := 0 ;
        var i : int ; i := 0 ; while i < x - 1 do ( (     A := A+(r[i+1].a) ; 
     q := q->including(r[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := x - 1 ; while i < n do ( (     var w : long ; w := x->oclAsType(long) * r[i+1].b - r[i+1].a ;
     if (A <= w) then     return true else skip ; 
    A := A+(r[i+1].a) ; 
    q := q->including(r[i+1]) ; 
    A := A-(q->min().a) ; 
 )  ;     i := i + 1 ) ; 
    return false 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    r := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do (     r[i+1] := B.newB(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    r := r->sort() ; 
    var L : int ; L := 0 ;
    var R : int ; R := n ;
    while (R - L > 1) do (     var m : int ; m := (L + R) / 2 ;
     if (ok(m)) then     L := m ; else     R := m ; ) ; 
    OclFile["System.out"].println(if ok(R) then R else L endif) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Straight_A {
  public static void main(String[] args){
    java.util.Scanner kbd=new java.util.Scanner(System.in);
    int n=kbd.nextInt();
    int k=kbd.nextInt();
    int[] marks=new int[n];
    int ctr=0 ;
    int total=0 ;
    double r=0 ;
    for(int i=0 ; i<n ; i++){
      marks[i]=kbd.nextInt();
      total+=marks[i];
    }
    do {
      r=Math.round(((double)total+(ctr*k))/(n+ctr));
      ctr++;
    }
    while(r<k);
    System.out.println(ctr-1);
  }
}
------------------------------------------------------------
OCL File:
---------
class Straight_A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var kbd : Scanner ; kbd := Scanner.newScanner(OclFile["System.in"]) ;
     var n : int ; n := kbd.nextInt() ;
    var k : int ; k := kbd.nextInt() ;
    var marks : Sequence(int) ; marks := Integer.subrange(1,n)->collect(0) ;
    var ctr : int ; ctr := 0 ;
    var total : int ; total := 0 ;
    var r : double ; r := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     marks[i+1] := kbd.nextInt() ; 
     total := total+(marks[i+1]) )  ;     i := i + 1 ) ; 
  while true do ((     r := ((total->oclAsType(double) + (ctr * k)) / (n + ctr))->round() ; 
     ctr := ctr + 1 ) ;
    if (r < k) then skip else break) ; 
    OclFile["System.out"].println(ctr - 1) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static void main(String[] args){
    double n=5,a=2 ;
    System.out.println(sumOfSeries(a,n));
  }
  static double sumOfSeries(double a,double n){
    double res=0,prev=1 ;
    for(int i=1 ; i<=n ; i++){
      prev*=(a/i);
      res=res+prev ;
    }
    return(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 5 ;
    var a : double ; a := 2 ;
     OclFile["System.out"].println(sumOfSeries(a, n)) );
  static   operation sumOfSeries( a : double, n : double) : double
  pre: true
  post: true
  activity: (     var res : double ; res := 0 ;
    var prev : double ; prev := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (     prev := prev*((a / i)) ; 
     res := res + prev )  ;     i := i + 1 ) ; 
     return (res) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printTheArray(int arr[],int n){
    for(int i=0 ; i<n ; i++){
      System.out.print(arr[i]+" ");
    }
    System.out.println();
  }
  static void generateAllBinaryStrings(int n,int arr[],int i){
    if(i==n){
      printTheArray(arr,n);
      return ;
    }
    arr[i]=0 ;
    generateAllBinaryStrings(n,arr,i+1);
    arr[i]=1 ;
    generateAllBinaryStrings(n,arr,i+1);
  }
  public static void main(String args[]){
    int n=4 ;
    int[] arr=new int[n];
    generateAllBinaryStrings(n,arr,0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printTheArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation generateAllBinaryStrings( n : int, arr : Sequence(int), i : int) : void
  pre: true
  post: true
  activity: (     if (i = n) then (     execute printTheArray(arr, n) ; 
     return ) else skip ; 
     arr[i+1] := 0 ; 
    execute generateAllBinaryStrings(n, arr, i + 1) ; 
    arr[i+1] := 1 ; 
    execute generateAllBinaryStrings(n, arr, i + 1) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
     execute generateAllBinaryStrings(n, arr, 0) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int numberSequence(int n){
    int num=(int)(Math.pow(4,n)-Math.pow(2,n))-1 ;
    return num ;
  }
  public static void main(String args[]){
    int n=4 ;
    System.out.println(numberSequence(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation numberSequence( n : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := (4->pow(n) - 2->pow(n))->oclAsType(int) - 1 ;
     return num );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(numberSequence(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int minMoves(int arr[],int n){
    int expectedItem=n ;
    for(int i=n-1 ; i>=0 ; i--){
      if(arr[i]==expectedItem)expectedItem--;
    }
    return expectedItem ;
  }
  public static void main(String[] args){
    int arr[]={
      4,3,2,1 };
      int n=arr.length ;
      System.out.println(minMoves(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minMoves( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var expectedItem : int ; expectedItem := n ;
         var i : int ; i := n - 1 ; while i >= 0 do ( (     if (arr[i+1] = expectedItem) then     expectedItem := expectedItem - 1 ; else skip )  ;     i := i - 1 ) ; 
     return expectedItem );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,3,2,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minMoves(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int largestGCDSubsequence(int arr[],int n){
    int ans=0 ;
    int maxele=Arrays.stream(arr).max().getAsInt();
    ;
    for(int i=2 ; i<=maxele ; ++i){
      int count=0 ;
      for(int j=0 ; j<n ; ++j){
        if(arr[j] % i==0)++count ;
      }
      ans=Math.max(ans,count);
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      3,6,2,5,4 };
      int size=arr.length ;
      System.out.println(largestGCDSubsequence(arr,size));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation largestGCDSubsequence( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var maxele : int ; maxele := stream(arr).max().getAsInt() ;
        var i : int ; i := 2 ; while i <= maxele do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (arr[j+1] mod i = 0) then     count := count + 1 ; else skip )  ;     j := j + 1 ) ; 
     ans := Set{ans, count}->max() )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,6,2,5,4} ;
     var size : int ; size := arr->size() ;
     OclFile["System.out"].println(largestGCDSubsequence(arr, size)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int calculateSum(int n){
    int a1=1,a2=2 ;
    int r=2 ;
    int d=1 ;
    return(n)*(2*a1+(n-1)*d)/2+a2*(int)(Math.pow(r,n)-1)/(r-1);
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.print("Sum="+calculateSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculateSum( n : int) : int
  pre: true
  post: true
  activity: (     var a1 : int ; a1 := 1 ;
    var a2 : int ; a2 := 2 ;
     var r : int ; r := 2 ;
     var d : int ; d := 1 ;
     return (n) * (2 * a1 + (n - 1) * d) / 2 + a2 * (r->pow(n) - 1)->oclAsType(int) / (r - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].print("Sum=" + calculateSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int N=gi();
    Map<Integer,Long>m=new HashMap<Integer,Long>();
    for(int i=1 ; i<=N ; i++){
      List<Integer>l=insuB(i);
      for(Integer n : l){
        if(m.containsKey(n)){
          m.put(n,m.get(n)+1);
        }
        else {
          m.put(n,1l);
        }
      }
    }
    long ans=1 ;
    for(Map.Entry<Integer,Long>e : m.entrySet()){
      ans*=(e.getValue()+1);
      ans=ans % 1000000007 ;
    }
    System.out.println(ans);
  }
  public static List<Integer>insuB(int n){
    List<Integer>l=new ArrayList<Integer>();
    int i=2 ;
    while(n!=1){
      if(n % i==0){
        l.add(i);
        n/=i ;
      }
      else {
        i++;
      }
    }
    return l ;
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : int ; N := gi() ;
    var m : Map(int,long) ; m := Map{} ;
        var i : int ; i := 1 ; while i <= N do ( (     var l : Sequence(int) ; l := insuB(i) ;
     for (n : l) do ( (     if (m->keys()->includes(n)) then (     m := m->union(Map{n |-> m->at(n) + 1}) ) else (     m := m->union(Map{n |-> 1l}) ) )  ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 1 ;
    for (e : m->asSet()) do ( (     ans := ans*((e.getValue() + 1)) ; 
     ans := ans mod 1000000007 )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation insuB( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     var i : int ; i := 2 ;
     while (n /= 1) do (     if (n mod i = 0) then (     l := l->including(i) ; 
     n := n/(i) ) else (     i := i + 1 ) ) ; 
     return l );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void count(String str1,String str2){
    int c=0,j=0 ;
    for(int i=0 ; i<str1.length(); i++){
      if(str2.indexOf(str1.charAt(i))>=0){
        c+=1 ;
      }
    }
    System.out.println("No.of matching characters are: "+c);
  }
  public static void main(String[] args){
    String str1="aabcddekll12@" ;
    String str2="bb2211@55k" ;
    count(str1,str2);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation count( str1 : String, str2 : String) : void
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
    var j : int ; j := 0 ;
         var i : int ; i := 0 ; while i < str1->size() do ( (     if (str2->indexOf(str1->at(i+1))-1 >= 0) then (     c := c+(1) ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("No.of matching characters are: " + c) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "aabcddekll12@" ;
     var str2 : String ; str2 := "bb2211@55k" ;
     execute count(str1, str2) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BeltedRooms {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt(),i,c=0 ;
      String s=in.next();
      if(! s.contains(">")|| ! s.contains("<")){
        c=n ;
      }
      else {
        for(i=0 ; i<n ; i++)if(s.charAt(i)=='-' || s.charAt((i+1)% n)=='-')c++;
      }
      System.out.println(c);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class BeltedRooms {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
    var i : int ;
    var c : int ; c := 0 ;
     var s : String ; s := in.getCurrent() ;
     if (not(s->includes(">")) or not(s->includes("<"))) then (     c := n ) else (         i := 0 ; while i < n do (     if (s->at(i+1) = '-' or s->at((i + 1) mod n+1) = '-') then     c := c + 1 ; else skip ;  ;     i := i + 1 ) ) ;  
     OclFile["System.out"].println(c) ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewProblem {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    String start=s.next();
    String end=s.next();
    int n=start.length();
    int k=s.nextInt();
    int amount=0 ;
    for(int i=1 ; i<n ; i++){
      String str=start.substring(i,n)+start.substring(0,i);
      if(str.equals(end))amount++;
    }
    if(amount==0 && ! start.equals(end)){
      System.out.println(0);
      System.exit(0);
    }
    long x=0 ;
    for(int i=0 ; i<k ; i++){
      if(i % 2==0)x=(x*(n-1)+1)% 1000000007 ;
      else x=(x*(n-1)-1)% 1000000007 ;
    }
    long ans=amount*x ;
    if(start.equals(end)){
      if(k % 2==0)ans+=x+1 ;
      else ans+=x-1 ;
    }
    System.out.println(ans % 1000000007);
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewProblem {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var start : String ; start := s.getCurrent() ;
    var end : String ; end := s.getCurrent() ;
    var n : int ; n := start->size() ;
    var k : int ; k := s.getCurrent()->toInteger() ;
    var amount : int ; amount := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     var str : String ; str := start.subrange(i+1,n) + start.subrange(0+1,i) ;
     if (str = end) then     amount := amount + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (amount = 0 & not(start = end)) then (     OclFile["System.out"].println(0) ; 
 OclProcess.exit(0) ) else skip ; 
    var x : long ; x := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     if (i mod 2 = 0) then     x := (x * ((n)->char2byte() - 1) + 1) mod 1000000007 ; else     x := (x * ((n)->char2byte() - 1) - 1) mod 1000000007 ; )  ;     i := i + 1 ) ; 
    var ans : long ; ans := amount * x ;
    if (start = end) then (     if (k mod 2 = 0) then     ans := ans+(x + 1) ; else     ans := ans+((x)->char2byte() - 1) ; ) else skip ; 
    OclFile["System.out"].println(ans mod 1000000007) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxDivide(int a,int b){
    while(a % b==0)a=a/b ;
    return a ;
  }
  static int isUgly(int no){
    no=maxDivide(no,2);
    no=maxDivide(no,3);
    no=maxDivide(no,5);
    return(no==1)? 1 : 0 ;
  }
  static int getNthUglyNo(int n){
    int i=1 ;
    int count=1 ;
    while(n>count){
      i++;
      if(isUgly(i)==1)count++;
    }
    return i ;
  }
  public static void main(String args[]){
    int no=getNthUglyNo(150);
    System.out.println("150th ugly "+"no.is "+no);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxDivide( a : int, b : int) : int
  pre: true
  post: true
  activity: (     while (a mod b = 0) do     a := a / b ; ; 
     return a );
  static   operation isUgly( no : int) : int
  pre: true
  post: true
  activity: (     no := maxDivide(no, 2) ; 
     no := maxDivide(no, 3) ; 
     no := maxDivide(no, 5) ; 
     return if (no = 1) then 1 else 0 endif );
  static   operation getNthUglyNo( n : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 1 ;
     var count : int ; count := 1 ;
     while (n > count) do (     i := i + 1 ; 
     if (isUgly(i) = 1) then     count := count + 1 ; else skip ) ; 
     return i );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var no : int ; no := getNthUglyNo(150) ;
     OclFile["System.out"].println("150th ugly " + "no.is " + no) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
import java.io.*;
public class codeHundredSixty {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=input.nextInt();
      int[] arrayOne=new int[n];
      long sum=0 ;
      int countZ=0 ;
      int countO=0 ;
      for(int i=0 ; i<n ; i++){
        arrayOne[i]=input.nextInt();
        if(arrayOne[i]==1){
          countO++;
        }
        else {
          countZ++;
        }
        if(i % 2==0){
          sum+=arrayOne[i];
        }
        else {
          sum-=arrayOne[i];
        }
      }
      int k=n/2 ;
      if(sum==0){
        System.out.println(n);
        for(int i=0 ; i<n ; i++){
          System.out.print(arrayOne[i]+" ");
        }
        System.out.println();
      }
      else {
        if(countZ>=countO){
          System.out.println(k);
          for(int i=0 ; i<k ; i++){
            System.out.print(0+" ");
          }
          System.out.println();
        }
        else {
          int v=countO-(countO % 2);
          System.out.println(v);
          for(int i=0 ; i<v ; i++){
            System.out.print(1+" ");
          }
          System.out.println();
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var arrayOne : Sequence(int) ; arrayOne := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
    var countZ : int ; countZ := 0 ;
    var countO : int ; countO := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arrayOne[i+1] := input.getCurrent()->toInteger() ; 
     if (arrayOne[i+1] = 1) then (     countO := countO + 1 ) else (     countZ := countZ + 1 ) ;  
     if (i mod 2 = 0) then (     sum := sum+(arrayOne[i+1]) ) else (     sum := sum-(arrayOne[i+1]) ) )  ;     i := i + 1 ) ; 
    var k : int ; k := n / 2 ;
    if (sum = 0) then (     OclFile["System.out"].println(n) ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arrayOne[i+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) else (     if (countZ >= countO) then (     OclFile["System.out"].println(k) ; 
         var i : int ; i := 0 ; while i < k do ( (     OclFile["System.out"].print(0 + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) else (     var v : int ; v := countO - (countO mod 2) ;
     OclFile["System.out"].println(v) ; 
         var i : int ; i := 0 ; while i < v do ( (     OclFile["System.out"].print(1 + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ) ;  
 )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      int even=0 ;
      int odd=0 ;
      for(int i=0 ; i<n ; i++){
        if(i % 2==0){
          even+=arr[i];
        }
        else {
          odd+=arr[i];
        }
      }
      if(even==odd){
        System.out.println(n);
        for(int elem : arr){
          System.out.print(elem+" ");
        }
        System.out.println();
      }
      else {
        int ones=0 ;
        int zeroes=0 ;
        for(int elem : arr){
          if(elem==1){
            ones++;
          }
          else {
            zeroes++;
          }
        }
        if(ones>zeroes){
          if(ones % 2==1){
            ones--;
          }
          System.out.println(ones);
          for(int i=0 ; i<ones ; i++){
            System.out.print(1+" ");
          }
          System.out.println();
        }
        else {
          System.out.println(n/2);
          for(int i=0 ; i<n/2 ; i++){
            System.out.print(0+" ");
          }
          System.out.println();
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var even : int ; even := 0 ;
    var odd : int ; odd := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then (     even := even+(arr[i+1]) ) else (     odd := odd+(arr[i+1]) ) )  ;     i := i + 1 ) ; 
    if (even = odd) then (     OclFile["System.out"].println(n) ; 
     for (elem : arr) do ( (     OclFile["System.out"].print(elem + " ") )  ) ; 
     OclFile["System.out"].println() ) else (     var ones : int ; ones := 0 ;
     var zeroes : int ; zeroes := 0 ;
     for (elem : arr) do ( (     if (elem = 1) then (     ones := ones + 1 ) else (     zeroes := zeroes + 1 ) )  ) ; 
     if (ones > zeroes) then (     if (ones mod 2 = 1) then (     ones := ones - 1 ) else skip ; 
     OclFile["System.out"].println(ones) ; 
         var i : int ; i := 0 ; while i < ones do ( (     OclFile["System.out"].print(1 + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) else (     OclFile["System.out"].println(n / 2) ; 
         var i : int ; i := 0 ; while i < n / 2 do ( (     OclFile["System.out"].print(0 + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MinimumX(int a,int b,int c,int k){
    int x=Integer.MAX_VALUE ;
    if(k<=c)return 0 ;
    int h=k-c ;
    int l=0 ;
    while(l<=h){
      int m=(l+h)/2 ;
      if((a*m*m)+(b*m)>(k-c)){
        x=Math.min(x,m);
        h=m-1 ;
      }
      else if((a*m*m)+(b*m)<(k-c))l=m+1 ;
      else return m ;
    }
    return x ;
  }
  public static void main(String[] args){
    int a=3,b=2,c=4,k=15 ;
    System.out.println(MinimumX(a,b,c,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation MinimumX( a : int, b : int, c : int, k : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := 2147483647 ;
     if (k <= c) then     return 0 else skip ; 
    var h : int ; h := k - c ;
    var l : int ; l := 0 ;
    while (l <= h) do (     var m : int ; m := (l + h) / 2 ;
     if ((a * m * m) + (b * m) > (k - c)) then (     x := Set{x, m}->min() ; 
     h := m - 1 ) else     if ((a * m * m) + (b * m) < (k - c)) then     l := m + 1 else     return m ;  ) ; 
    return x 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var b : int ; b := 2 ;
    var c : int ; c := 4 ;
    var k : int ; k := 15 ;
     OclFile["System.out"].println(MinimumX(a, b, c, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minLettersNeeded(int n){
    if(n % 26==0)return(n/26);
    else return((n/26)+1);
  }
  public static void main(String args[]){
    int n=52 ;
    System.out.print(minLettersNeeded(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minLettersNeeded( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 26 = 0) then     return (n / 26) else     return ((n / 26) + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 52 ;
     OclFile["System.out"].print(minLettersNeeded(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      int k=in.nextInt();
      int[] arr=new int[26];
      int[] arr2=new int[26];
      in.nextLine();
      String s=in.nextLine();
      char[] chars=s.toCharArray();
      for(char c : chars){
        arr[c-'a']++;
      }
      StringBuilder ans=new StringBuilder();
      int i ;
      for(i=1 ; i<25 ; i++)arr[i]=Math.min(arr[i],arr[i-1]);
      arr[Math.min(25,n/k)]=0 ;
      for(i=Math.min(24,n/k-1); i>=0 ; i--)arr2[i]=arr[i]-arr[i+1];
      for(i=0 ; i<25 ; i++)if(arr2[i]==0)break ;
      int h=0 ;
      for(i=Math.min(25,n/k-1); i>=0 ; i--){
        if(k>=arr2[i]){
          int q=arr2[i];
          while((q--)>0)System.out.print((char)('a'+i+1));
          k-=arr2[i];
        }
        else while(k-->0)System.out.print((char)('a'+i+1));
      }
      while(k-->0)System.out.print((char)('a'+i+1));
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,26)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,26)->collect(0) ;
    skip ; 
    var s : String ; s := in.nextLine() ;
    var chars : Sequence(String) ; chars := s->characters() ;
    for (c : chars) do ( (     arr[c - ('a')->char2byte()+1] := arr[c - ('a')->char2byte()+1] + 1 )  ) ; 
    var ans : String ; ans := StringLib.newString() ;
    var i : int ;
        i := 1 ; while i < 25 do (     arr[i+1] := Set{arr[i+1], arr[(i)->char2byte() - 1+1]}->min() ;  ;     i := i + 1 ) ; 
    arr[Set{25, n / k}->min()+1] := 0 ; 
        i := Set{24, n / k - 1}->min() ; while i >= 0 do (     arr2[i+1] := arr[i+1] - arr[i + 1+1] ;  ;     i := i - 1 ) ; 
        i := 0 ; while i < 25 do (     if (arr2[i+1] = 0) then     break else skip ;  ;     i := i + 1 ) ; 
    var h : int ; h := 0 ;
        i := Set{25, n / k - 1}->min() ; while i >= 0 do ( (     if (k >= arr2[i+1]) then (     var q : int ; q := arr2[i+1] ;
         while ((q) > 0) do (        skip ;     skip ;     OclFile["System.out"].print(('a' + i + 1)->oclAsType(String)) ; ;  ) ;  
     k := k-(arr2[i+1]) ) else         while (k > 0) do (        k := k - 1 ;     skip ;     OclFile["System.out"].print(('a' + i + 1)->oclAsType(String)) ; ;  ) ;  )  ;     i := i - 1 ) ; 
        while (k > 0) do (        k := k - 1 ;     skip ;     OclFile["System.out"].print(('a' + i + 1)->oclAsType(String)) ; ;  ) ;  
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    if(Math.max(3*a/10,a-a*c/250)>Math.max(3*b/10,b-b*d/250)){
      System.out.println("Misha");
    }
    else if(Math.max(3*a/10,a-a*c/250)<Math.max(3*b/10,b-b*d/250)){
      System.out.println("Vasya");
    }
    else {
      System.out.println("Tie");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    if (Set{3 * a / 10, a - a * c / 250}->max() > Set{3 * b / 10, b - b * d / 250}->max()) then (     OclFile["System.out"].println("Misha") ) else     if (Set{3 * a / 10, a - a * c / 250}->max() < Set{3 * b / 10, b - b * d / 250}->max()) then (     OclFile["System.out"].println("Vasya") ) else (     OclFile["System.out"].println("Tie") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      int n=Integer.parseInt(br.readLine());
      if(n==0)break ;
      int key[]=new int[n];
      String str[]=br.readLine().split(" ");
      for(int i=0 ; i<n ; i++){
        key[i]=Integer.parseInt(str[i]);
      }
      char c[]=br.readLine().toCharArray();
      int keyCount=0 ;
      for(int i=0 ; i<c.length ; i++){
        for(int j=0 ; j<key[keyCount]; j++){
          if(c[i]==97)c[i]=90 ;
          else if(c[i]==65)c[i]=122 ;
          else c[i]-=1 ;
        }
        if(keyCount==key.length-1){
          keyCount=0 ;
        }
        else {
          keyCount++;
        }
      }
      for(int i=0 ; i<c.length ; i++)System.out.print(c[i]);
      System.out.print("\n");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var n : int ; n := (br.readLine())->toInteger() ;
     if (n = 0) then     break else skip ; 
    var key : Sequence(int) ; key := Integer.subrange(1,n)->collect(0) ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < n do ( (     key[i+1] := (str[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var c : Sequence(String) ; c := br.readLine()->characters() ;
    var keyCount : int ; keyCount := 0 ;
        var i : int ; i := 0 ; while i < c->size() do ( (         var j : int ; j := 0 ; while j < key[keyCount+1] do ( (     if (c[i+1] = 97) then     c[i+1] := 90 ; else     if (c[i+1] = 65) then     c[i+1] := 122 else     c[i+1] := c[i+1]-(1) ; ;  )  ;     j := j + 1 ) ; 
     if (keyCount = key->size() - 1) then (     keyCount := 0 ) else (     keyCount := keyCount + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < c->size() do (     OclFile["System.out"].print(c[i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("\n") ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    int b=in.nextInt();
    int c=in.nextInt();
    int d=in.nextInt();
    int Misha=Math.max((3*a)/10,a-((a*c)/250));
    int Vasya=Math.max((3*b)/10,b-((b*d)/250));
    if(Misha>Vasya)System.out.println("Misha");
    else if(Misha<Vasya)System.out.println("Vasya");
    else System.out.println("Tie");
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var Misha : int ; Misha := Set{(3 * a) / 10, a - ((a * c) / 250)}->max() ;
    var Vasya : int ; Vasya := Set{(3 * b) / 10, b - ((b * d) / 250)}->max() ;
    if (Misha > Vasya) then     OclFile["System.out"].println("Misha") else     if (Misha < Vasya) then     OclFile["System.out"].println("Vasya") else     OclFile["System.out"].println("Tie") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.lang.Math ;
public class contest {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    int fa=3*a/10 ;
    int fa1=a-(a/250)*c ;
    int fans=fa>fa1 ? fa : fa1 ;
    int fb=(3*b)/10 ;
    int fb1=b-(b/250)*d ;
    int fbans=fb>fb1 ? fb : fb1 ;
    if(fans==fbans){
      System.out.println("Tie");
    }
    else {
      System.out.println(fans>fbans ? "Misha" : "Vasya");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class contest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var fa : int ; fa := 3 * a / 10 ;
    var fa1 : int ; fa1 := a - (a / 250) * c ;
    var fans : int ; fans := if fa > fa1 then fa else fa1 endif ;
    var fb : int ; fb := (3 * b) / 10 ;
    var fb1 : int ; fb1 := b - (b / 250) * d ;
    var fbans : int ; fbans := if fb > fb1 then fb else fb1 endif ;
    if (fans = fbans) then (     OclFile["System.out"].println("Tie") ) else (     OclFile["System.out"].println(if fans > fbans then "Misha" else "Vasya" endif) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder();
    int a=fs.nextInt(),b=fs.nextInt(),c=fs.nextInt(),d=fs.nextInt();
    int n=Math.max((3*a)/10,a-(a/250*c));
    int m=Math.max((3*b)/10,b-(b/250*d));
    if(n==m)out.print("Tie");
    else out.print((n>m)? "Misha" : "Vasya");
    out.close();
  }
  static int isPerfectSquare(int x){
    if(x>=0){
      int sr=(int)Math.sqrt(x);
      if((sr*sr)==x)return sr ;
      else return 0 ;
    }
    return 0 ;
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    Long[] readArray(int n){
      Long[] a=new Long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    var a : int ; a := fs.nextInt() ;
    var b : int ; b := fs.nextInt() ;
    var c : int ; c := fs.nextInt() ;
    var d : int ; d := fs.nextInt() ;
    var n : int ; n := Set{(3 * a) / 10, (a)->char2byte() - (a / 250 * c)}->max() ;
    var m : int ; m := Set{(3 * b) / 10, (b)->char2byte() - (b / 250 * d)}->max() ;
    if (n = m) then     skip else     skip ; ;  
    skip ; 
 );
  static   operation isPerfectSquare( x : int) : int
  pre: true
  post: true
  activity: (     if (x >= 0) then (     var sr : int ; sr := (x)->sqrt()->oclAsType(int) ;
     if ((sr * sr) = x) then     return sr else     return 0 ) else skip ; 
     return 0 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class _1157B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] num=sc.next().toCharArray();
    int[] map=new int[10];
    for(int i=1 ; i<=9 ; i++)map[i]=sc.nextInt();
    int idx=n ;
    for(int i=0 ; i<n ; i++){
      int digit=num[i]-'0' ;
      if(map[digit]>digit){
        idx=i ;
        break ;
      }
    }
    for(int i=idx ; i<num.length ; i++){
      int digit=num[i]-'0' ;
      if(map[digit]<digit)break ;
      num[i]=(char)(map[digit]+'0');
    }
    for(int i=0 ; i<n ; i++)System.out.print(num[i]);
  }
  public static int gcd(int a,int b){
    return(a==0)? b : gcd(b % a,a);
  }
  static int power(int x,int y){
    int ans=1 ;
    while(y>0){
      if((y & 1)!=0)ans*=x ;
      y=y>>1 ;
      x*=x ;
    }
    return ans ;
  }
  public static List<Integer>sieve(int n){
    List<Integer>primes=new LinkedList<>();
    boolean[] composite=new boolean[n+1];
    for(int i=2 ; i*i<=n ; i++)for(int j=i*i ; j<=n && ! composite[i]; j+=i)composite[j]=true ;
    for(int j=2 ; j<composite.length ; j++)if(! composite[j])primes.add(j);
    return primes ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1157B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var num : Sequence(String) ; num := sc.getCurrent()->characters() ;
    var map : Sequence(int) ; map := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 1 ; while i <= 9 do (     map[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var idx : int ; idx := n ;
        var i : int ; i := 0 ; while i < n do ( (     var digit : int ; digit := num[i+1] - ('0')->char2byte() ;
     if (map[digit+1] > digit) then (     idx := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := idx ; while i < num->size() do ( (     var digit : int ; digit := num[i+1] - ('0')->char2byte() ;
     if (map[digit+1] < digit) then     break else skip ; 
     num[i+1] := (map[digit+1] + '0')->oclAsType(String) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(num[i+1]) ;  ;     i := i + 1 ) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if (a = 0) then b else gcd(b mod a, a) endif );
  static   operation power( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
     while (y > 0) do (     if ((y & 1) /= 0) then     ans := ans*(x) ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := x*(x) ) ; 
     return ans );
  static   operation sieve( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var primes : Sequence(int) ; primes := Sequence{} ;
     var composite : Sequence(boolean) ; composite := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 2 ; while i * i <= n do (         var j : int ; j := i * i ; while j <= n & not(composite[i+1]) do (     composite[j+1] := true ;  ;     j := j+(i) ) ;  ;     i := i + 1 ) ; 
        var j : int ; j := 2 ; while j < composite->size() do (     if (not(composite[j+1])) then     primes := primes->including(j) ; else skip ;  ;     j := j + 1 ) ; 
    return primes 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  long MOD=(long)1e9+7 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    long[][][] dp=new long[N+1][N+1][K+1];
    dp[0][0][0]=1 ;
    for(int i=1 ; i<=N ; i++){
      for(int j=0 ; j<=N ; j++){
        for(int k=0 ; k<=K ; k++){
          if(0>k-2*j || k-2*j>K)continue ;
          dp[i][j][k]=(2*j+1)*dp[i-1][j][k-2*j];
          if(j<N)dp[i][j][k]+=(j+1)*(j+1)*dp[i-1][j+1][k-2*j];
          if(j>0)dp[i][j][k]+=dp[i-1][j-1][k-2*j];
          dp[i][j][k] %=MOD ;
        }
      }
    }
    System.out.println(dp[N][0][K]);
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute MOD : long := 1e9->oclAsType(long) + 7;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var dp : Sequence(Sequence(Sequence(long))) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(Integer.subrange(1,K + 1)->collect(0))) ;
    dp[0+1][0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := 0 ; while j <= N do ( (         var k : int ; k := 0 ; while k <= K do ( (     if (0 > k - 2 * j or k - 2 * j > K) then     continue else skip ; 
     dp[i+1][j+1][k+1] := (2 * j + 1) * dp[i - 1+1][j+1][k - 2 * j+1] ; 
    if (j < N) then     dp[i+1][j+1][k+1] := dp[i+1][j+1][k+1]+((j + 1) * (j + 1) * dp[i - 1+1][j + 1+1][k - 2 * j+1]) ; else skip ; 
    if (j > 0) then     dp[i+1][j+1][k+1] := dp[i+1][j+1][k+1]+(dp[i - 1+1][j - 1+1][k - 2 * j+1]) ; else skip ; 
    dp[i+1][j+1][k+1] := dp[i+1][j+1][k+1] mod MOD ; 
 )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[N+1][0+1][K+1]) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
public class Main {
  Scanner sc ;
  int N ;
  int K ;
  long[][][] dp ;
  public Main(){
    sc=new Scanner(System.in);
  }
  private void calc(){
    long mod=1000000007L ;
    dp=new long[N+1][N+1][K+1];
    dp[0][0][0]=1 ;
    for(int i=1 ; i<=N ; i++){
      for(int j=0 ; j<=i ; j++){
        for(int k=2*j ; k<=K ; k++){
          if(j>0)dp[i][j][k]=dp[i-1][j-1][k-2*j];
          dp[i][j][k]=(dp[i][j][k]+(2*j+1)*dp[i-1][j][k-2*j])% mod ;
          if(j<N)dp[i][j][k]=(dp[i][j][k]+(j+1)*(j+1)*dp[i-1][j+1][k-2*j])% mod ;
        }
      }
    }
  }
  private void out(Object o){
    System.out.println(o);
    System.out.flush();
  }
  private void input(){
    N=sc.nextInt();
    K=sc.nextInt();
  }
  private void output(){
    out(dp[N][0][K]);
  }
  public static void main(String[] args){
    Main m=new Main();
    m.input();
    m.calc();
    m.output();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute N : int;
   attribute K : int;
   attribute dp : Sequence(Sequence(Sequence(long)));
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation calc() : void
  pre: true
  post: true
  activity: (     var mod : long ; mod := 1000000007L ;
     dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(Integer.subrange(1,K + 1)->collect(0))) ; 
     dp[0+1][0+1][0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := 0 ; while j <= i do ( (         var k : int ; k := 2 * j ; while k <= K do ( (     if (j > 0) then     dp[i+1][j+1][k+1] := dp[i - 1+1][j - 1+1][k - 2 * j+1] ; else skip ; 
     dp[i+1][j+1][k+1] := (dp[i+1][j+1][k+1] + (2 * j + 1) * dp[i - 1+1][j+1][k - 2 * j+1]) mod mod ; 
     if (j < N) then     dp[i+1][j+1][k+1] := (dp[i+1][j+1][k+1] + (j + 1) * (j + 1) * dp[i - 1+1][j + 1+1][k - 2 * j+1]) mod mod ; else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
   operation out( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) ; 
     OclFile["System.out"].flush() );
   operation input() : void
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     K := sc.getCurrent()->toInteger() );
   operation output() : void
  pre: true
  post: true
  activity: (     execute out(dp[N+1][0+1][K+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.input() ; 
     m.calc() ; 
     m.output() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static final int MODULUS=1_000_000_007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    System.out.println(solve(n,k));
    sc.close();
  }
  static int solve(int n,int k){
    int[][][] wayNums=new int[n+1][n+1][k+1];
    wayNums[0][0][0]=1 ;
    for(int i=1 ; i<=n ; ++i){
      for(int j=0 ; j<=n ; ++j){
        for(int p=0 ; p<=k ; ++p){
          wayNums[i][j][p]=addMod(addMod(multiplyMod(2*j+1,getWayNum(wayNums,i-1,j,p-2*j)),multiplyMod((j+1)*(j+1),getWayNum(wayNums,i-1,j+1,p-2*j))),getWayNum(wayNums,i-1,j-1,p-2*j));
        }
      }
    }
    return wayNums[n][0][k];
  }
  static int getWayNum(int[][][] wayNums,int seenNum,int unpairNum,int oddness){
    int n=wayNums.length-1 ;
    return(unpairNum==-1 || unpairNum==n+1 || oddness<0)? 0 : wayNums[seenNum][unpairNum][oddness];
  }
  static int addMod(int x,int y){
    return(x+y)% MODULUS ;
  }
  static int multiplyMod(int x,int y){
    return(int)((long)x*y % MODULUS);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MODULUS : int := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(solve(n, k)) ; 
    skip ; 
 );
  static   operation solve( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var wayNums : Sequence(Sequence(Sequence(int))) ; wayNums := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(Integer.subrange(1,k + 1)->collect(0))) ;
     wayNums[0+1][0+1][0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= n do ( (         var p : int ; p := 0 ; while p <= k do ( (     wayNums[i+1][j+1][p+1] := addMod(addMod(multiplyMod(2 * j + 1, getWayNum(wayNums, i - 1, j, p - 2 * j)), multiplyMod((j + 1) * (j + 1), getWayNum(wayNums, i - 1, j + 1, p - 2 * j))), getWayNum(wayNums, i - 1, j - 1, p - 2 * j)) )  ;     p := p + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return wayNums[n+1][0+1][k+1] );
  static   operation getWayNum( wayNums : Sequence(Sequence(Sequence(int))), seenNum : int, unpairNum : int, oddness : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := wayNums->size() - 1 ;
     return if (unpairNum = -1 or unpairNum = n + 1 or oddness < 0) then 0 else wayNums[seenNum+1][unpairNum+1][oddness+1] endif );
  static   operation addMod( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return (x + y) mod MODULUS );
  static   operation multiplyMod( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return (x->oclAsType(long) * y mod MODULUS)->oclAsType(int) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int K=scanner.nextInt();
    long M=1_000_000_007 ;
    long[][][] dp=new long[N+1][N+1][K+1];
    dp[0][0][0]=1 ;
    for(int i=1 ; i<=N ; i++)for(int j=0 ; j<=i ; j++)for(int k=2*j ; k<=K ; k++){
      if(j>0)dp[i][j][k]=dp[i-1][j-1][k-2*j];
      dp[i][j][k]+=(2*j+1)*dp[i-1][j][k-2*j] % M ;
      if(dp[i][j][k]>=M)dp[i][j][k]-=M ;
      if(j<N)dp[i][j][k]+=(j+1)*(j+1)*dp[i-1][j+1][k-2*j] % M ;
      if(dp[i][j][k]>=M)dp[i][j][k]-=M ;
    }
    System.out.println(dp[N][0][K]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var K : int ; K := scanner.getCurrent()->toInteger() ;
    var M : long ; M := 1_000_000_007 ;
    var dp : Sequence(Sequence(Sequence(long))) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(Integer.subrange(1,K + 1)->collect(0))) ;
    dp[0+1][0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= N do (         var j : int ; j := 0 ; while j <= i do (         var k : int ; k := 2 * j ; while k <= K do ( (     if (j > 0) then     dp[i+1][j+1][k+1] := dp[i - 1+1][j - 1+1][k - 2 * j+1] ; else skip ; 
     dp[i+1][j+1][k+1] := dp[i+1][j+1][k+1]+((2 * j + 1) * dp[i - 1+1][j+1][k - 2 * j+1] mod M) ; 
    if (dp[i+1][j+1][k+1] >= M) then     dp[i+1][j+1][k+1] := dp[i+1][j+1][k+1]-(M) ; else skip ; 
    if (j < N) then     dp[i+1][j+1][k+1] := dp[i+1][j+1][k+1]+((j + 1) * (j + 1) * dp[i - 1+1][j + 1+1][k - 2 * j+1] mod M) ; else skip ; 
    if (dp[i+1][j+1][k+1] >= M) then     dp[i+1][j+1][k+1] := dp[i+1][j+1][k+1]-(M) ; else skip ; 
 )  ;     k := k + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[N+1][0+1][K+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=Integer.parseInt(sc.next());
    int B=Integer.parseInt(sc.next());
    sc.close();
    if(Math.abs(A-B)<2){
      System.out.println("Yay!");
    }
    else {
      System.out.println(":(");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := (sc.getCurrent())->toInteger() ;
    var B : int ; B := (sc.getCurrent())->toInteger() ;
    skip ; 
    if (if A - B < 0 then -(A - B) else A - B endif < 2) then (     OclFile["System.out"].println("Yay!") ) else (     OclFile["System.out"].println(":(") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  private static final int N=100 ;
  private static int c2d(final char ch){
    return(Character.isLowerCase(ch)? ch-'a' : 26+ch-'A');
  }
  private static char d2c(int d){
    return(d<26 ?(char)(d+'a'):(char)(d-26+'A'));
  }
  public void run(final java.util.Scanner sc,final java.io.PrintStream out){
    int[] k=new int[N];
    int i ;
    for(; ; ){
      String s ;
      int n ;
      n=sc.nextInt();
      if(n==0)break ;
      for(i=0 ; i<n ; ++i)k[i]=sc.nextInt();
      s=sc.next();
      for(i=0 ; i<s.length(); ++i)out.print(d2c((c2d(s.charAt(i))+52-k[i % n])% 52));
      out.println();
    }
  }
  public static void main(final String[] args){
(new Main()).run(new java.util.Scanner(System.in),System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static    attribute N : int := 100;
  static   operation c2d( ch : String) : int
  pre: true
  post: true
  activity: (     return (if (ch->toLowerCase() = ch) then ch - ('a')->char2byte() else 26 + ch - ('A')->char2byte() endif) );
  static   operation d2c( d : int) : String
  pre: true
  post: true
  activity: (     return (if d < 26 then (d + 'a')->oclAsType(String) else (d - 26 + 'A')->oclAsType(String) endif) );
   operation run( sc : Scanner, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var k : Sequence(int) ; k := Integer.subrange(1,N)->collect(0) ;
     var i : int ;
       while true do ( (     var s : String ;
     var n : int ;
    n := sc.nextInt() ; 
    if (n = 0) then     break else skip ; 
        i := 0 ; while i < n do (     k[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
    s := sc.next() ; 
        i := 0 ; while i < s->size() do (     out.print(d2c((c2d(s->at(i+1)) + 52 - k[i mod n+1]) mod 52)) ;  ;     i := i + 1 ) ; 
    out.println() ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(Scanner.newScanner(OclFile["System.in"]), OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws Exception {
    String line=readLine();
    StringTokenizer st=new StringTokenizer(line," ");
    Integer a=Integer.parseInt(st.nextToken());
    Integer b=Integer.parseInt(st.nextToken());
    if((a<=8)&&(b<=8)){
      System.out.println("Yay!");
    }
    else {
      System.out.println(":(");
    }
  }
  private static String readLine()throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    return br.readLine();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var line : String ; line := readLine() ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String_String(line, " ") ;
    var a : int ; a := (st.next())->toInteger() ;
    var b : int ; b := (st.next())->toInteger() ;
    if ((a <= 8) & (b <= 8)) then (     OclFile["System.out"].println("Yay!") ) else (     OclFile["System.out"].println(":(") ) ;  
 );
  static   operation readLine() : String
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     return br.readLine() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
import static java.lang.Math.max ;
public class Main {
  static StringTokenizer cin ;
  static PrintWriter out=new PrintWriter(System.out);
  static final void in_init()throws Exception {
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder s=new StringBuilder();
    while(true){
      String st=bf.readLine();
      if(st==null){
        break ;
      }
      s.append(' ');
      s.append(st);
    }
    cin=new StringTokenizer(s.toString());
  }
  static final int getInt()throws Exception {
    return Integer.parseInt(cin.nextToken());
  }
  public static void main(String[] args)throws Exception {
    in_init();
    int a=getInt(),b=getInt();
    if(a+b==16){
      if(a!=b){
        out.println(":(");
      }
      else {
        out.println("Yay!");
      }
    }
    else {
      if(max(a,b)*2<=16){
        out.println("Yay!");
      }
      else {
        out.println(":(");
      }
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute cin : OclIterator;
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static    operation in_init() : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := StringLib.newString() ;
     while (true) do (     var st : String ; st := bf.readLine() ;
     if (st = null) then (     break ) else skip ; 
     s := s + StringLib.newString(' ') ; 
     s := s + StringLib.newString(st) ) ; 
     cin := OclIterator.newOclIterator_String(s+"") );
  static    operation getInt() : int
  pre: true
  post: true
  activity: (     return (cin.next())->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute in_init() ; 
     var a : int ; a := getInt() ;
    var b : int ; b := getInt() ;
     if (a + b = 16) then (     if (a /= b) then (     skip ) else (     skip ) ) else (     if (Set{a, b}->max() * 2 <= 16) then (     skip ) else (     skip ) ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] tmp=br.readLine().split(" ");
    int a=Integer.parseInt(tmp[0]);
    int b=Integer.parseInt(tmp[1]);
    if(a>8 || b>8)System.out.println(":(");
    else System.out.println("Yay!");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmp : Sequence(String) ; tmp := br.readLine()->split(" ") ;
    var a : int ; a := (tmp[0+1])->toInteger() ;
    var b : int ; b := (tmp[1+1])->toInteger() ;
    if (a > 8 or b > 8) then     OclFile["System.out"].println(":(") else     OclFile["System.out"].println("Yay!") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    for(int i=1 ; i<=16 ; i++){
      if(i % 2==0){
        a--;
      }
      else {
        b--;
      }
    }
    if(a<=0 && b<=0){
      System.out.println("Yay!");
    }
    else {
      System.out.println(":(");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= 16 do ( (     if (i mod 2 = 0) then (     a := a - 1 ) else (     b := b - 1 ) )  ;     i := i + 1 ) ; 
    if (a <= 0 & b <= 0) then (     OclFile["System.out"].println("Yay!") ) else (     OclFile["System.out"].println(":(") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    System.out.println(a>b ? a-1 : a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if a > b then a - 1 else a endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemB {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    char s[]=br.readLine().toCharArray();
    int arr[]=new int[10];
    String line[]=br.readLine().split(" ");
    for(int i=1 ; i<10 ; i++)arr[i]=Integer.parseInt(line[i-1]);
    boolean ok=true ;
    for(int i=0 ; i<n ; i++){
      int curr=s[i]-'0' ;
      if(curr<arr[curr]){
        while(i<n && s[i]-'0'<=arr[s[i]-'0']){
          s[i]=(char)(arr[s[i]-'0']+'0');
          i++;
        }
        break ;
      }
    }
    System.out.println(String.copyValueOf(s));
  }
  public static void sort(int arr[]){
    ArrayList<Integer>list=new ArrayList<>();
    for(int it : arr)list.add(it);
    Collections.sort(list);
    for(int i=0 ; i<arr.length ; i++)arr[i]=list.get(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var s : Sequence(String) ; s := br.readLine()->characters() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,10)->collect(0) ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
        var i : int ; i := 1 ; while i < 10 do (     arr[i+1] := (line[(i)->char2byte() - 1+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var ok : boolean ; ok := true ;
        var i : int ; i := 0 ; while i < n do ( (     var curr : int ; curr := s[i+1] - ('0')->char2byte() ;
     if (curr < arr[curr+1]) then (     while (i < n & s[i+1] - ('0')->char2byte() <= arr[s[i+1] - ('0')->char2byte()+1]) do (     s[i+1] := (arr[s[i+1] - ('0')->char2byte()+1] + '0')->oclAsType(String) ; 
     i := i + 1 ) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((s)->sum()) ; 
 );
  static   operation sort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     for (it : arr) do (     list := list->including(it) ;  ) ; 
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < arr->size() do (     arr[i+1] := list->at(i+1) ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(1,in,out);
    out.close();
  }
  static class Task {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int a=in.nextInt();
      int b=in.nextInt();
      if(a>b){
        out.println(a-1);
      }
      else {
        out.println(a);
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.nextInt() ;
     var b : int ; b := in.nextInt() ;
     if (a > b) then (     skip ) else (     skip ) );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String[] str=in.readLine().split(" ");
    int a=Integer.parseInt(str[0]);
    int b=Integer.parseInt(str[1]);
    if(a==b)System.out.println(a);
    else if(a<b)System.out.println(a);
    else System.out.println(a-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := in.readLine()->split(" ") ;
    var a : int ; a := (str[0+1])->toInteger() ;
    var b : int ; b := (str[1+1])->toInteger() ;
    if (a = b) then     OclFile["System.out"].println(a) else     if (a < b) then     OclFile["System.out"].println(a) else     OclFile["System.out"].println(a - 1) ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws Exception {
    String line=readLine();
    StringTokenizer st=new StringTokenizer(line," ");
    int a=Integer.parseInt(st.nextToken());
    int b=Integer.parseInt(st.nextToken());
    if(a>b){
      System.out.println(String.valueOf(a-1));
    }
    else {
      System.out.println(String.valueOf(a));
    }
  }
  private static String readLine()throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    return br.readLine();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var line : String ; line := readLine() ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String_String(line, " ") ;
    var a : int ; a := (st.next())->toInteger() ;
    var b : int ; b := (st.next())->toInteger() ;
    if (a > b) then (     OclFile["System.out"].println(((a - 1) + "")) ) else (     OclFile["System.out"].println(((a) + "")) ) ;  
 );
  static   operation readLine() : String
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     return br.readLine() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ABC096A solver=new ABC096A();
    solver.solve(1,in,out);
    out.close();
  }
  static class ABC096A {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int a=in.nextInt();
      int b=in.nextInt();
      int ans=(a-1)+(a<=b ? 1 : 0);
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ABC096A ; solver := ABC096A.newABC096A() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ABC096A {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
     var ans : int ; ans := (a - 1) + (if a <= b then 1 else 0 endif) ;
     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      int n=scanner.nextInt(),mn=Integer.MAX_VALUE ;
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=scanner.nextInt();
        mn=Math.min(arr[i],mn);
      }
      int ans=0 ;
      for(int num : arr){
        ans+=(num-mn);
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var mn : int ; mn := 2147483647 ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scanner.getCurrent()->toInteger() ; 
     mn := Set{arr[i+1], mn}->min() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (num : arr) do ( (     ans := ans+((num - mn)) )  ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    UnionFind uf=new UnionFind();
    for(int ai : a){
      int value=ai ;
      for(int i=2 ; i*i<=ai ; i++){
        if(value % i==0){
          uf.unite(ai,i);
          while(value % i==0)value/=i ;
        }
      }
      if(value!=1){
        uf.unite(ai,value);
      }
    }
    int[] asorted=a.clone();
    Arrays.sort(asorted);
    for(int i=0 ; i<n ; i++){
      if(! uf.isSameRoot(a[i],asorted[i])){
        System.out.println(0);
        return ;
      }
    }
    System.out.println(1);
  }
}
class UnionFind {
  int[] data=new int[100010];
  UnionFind(){
    for(int i=0 ; i<100010 ; i++){
      data[i]=i ;
    }
  }
  void unite(int left,int right){
    data[root(left)]=root(right);
  }
  int root(int i){
    if(data[i]==i)return i ;
    else return data[i]=root(data[i]);
  }
  boolean isSameRoot(int x,int y){
    return root(x)==root(y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var uf : UnionFind ; uf := UnionFind.newUnionFind() ;
    for (ai : a) do ( (     var value : int ; value := ai ;
         var i : int ; i := 2 ; while i * i <= ai do ( (     if (value mod i = 0) then (     uf.unite(ai, i) ; 
     while (value mod i = 0) do     value := value/(i) ; ) else skip )  ;     i := i + 1 ) ; 
     if (value /= 1) then (     uf.unite(ai, value) ) else skip )  ) ; 
    var asorted : Sequence(int) ; asorted := a->copy() ;
    asorted := asorted->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (not(uf.isSameRoot(a[i+1], asorted[i+1]))) then (     OclFile["System.out"].println(0) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(1) ; 
 );
}
class UnionFind {
   attribute data : Sequence(int) := Integer.subrange(1,100010)->collect(0);
   static operation newUnionFind() : UnionFind
  pre: true
  post: true
  activity:
  ( var self : UnionFind ;
    self := createUnionFind();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (         var i : int ; i := 0 ; while i < 100010 do ( (     data[i+1] := i )  ;     i := i + 1 ) );
   operation unite( left : int, right : int) : void
  pre: true
  post: true
  activity: (     data[root(left)+1] := root(right) );
   operation root( i : int) : int
  pre: true
  post: true
  activity: (     if (data[i+1] = i) then     return i else     return data[i+1] );
   operation isSameRoot( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return root(x) = root(y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int ways(String s,int n){
    int dp[][]=new int[n][n];
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++){
      dp[i][j]=0 ;
    }
    for(int i=0 ; i<n ; i++)dp[0][i]=1 ;
    for(int i=1 ; i<n ; i++){
      String temp="" ;
      for(int j=i ; j<n ; j++){
        temp+=s.charAt(j);
        String test="" ;
        for(int k=i-1 ; k>=0 ; k--){
          test+=s.charAt(k);
          if(test.compareTo(temp)<0){
            dp[i][j]+=dp[k][i-1];
          }
        }
      }
    }
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      ans+=dp[i][n-1];
    }
    return ans ;
  }
  public static void main(String[] args){
    String s="aabc" ;
    int n=s.length();
    System.out.println(ways(s,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation ways( s : String, n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do ( (     dp[i+1][j+1] := 0 )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     dp[0+1][i+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     var temp : String ; temp := "" ;
         var j : int ; j := i ; while j < n do ( (     temp := temp+(s->at(j+1)) ; 
     var test : String ; test := "" ;
         var k : int ; k := i - 1 ; while k >= 0 do ( (     test := test+(s->at(k+1)) ; 
     if (test->compareTo(temp) < 0) then (     dp[i+1][j+1] := dp[i+1][j+1]+(dp[k+1][i - 1+1]) ) else skip )  ;     k := k - 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans+(dp[i+1][n - 1+1]) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "aabc" ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].println(ways(s, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.lang.Math ;
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Random ;
import java.util.StringTokenizer ;
public class Main {
  public static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  public static char different(String s1,String s2,int i){
    char check[]={
      'a','b','c' };
      for(char ch : check){
        if(ch!=s1.charAt(i)&& ch!=s2.charAt(i)){
          return ch ;
        }
      }
      return 'z' ;
    }
    public static void main(String[] args)throws java.lang.Exception {
      FastScanner fs=new FastScanner();
      PrintWriter out=new PrintWriter(System.out);
      int t=fs.nextInt();
      while(t-->0){
        int n=fs.nextInt();
        long x=1 ;
        for(int i=1 ; i<=n ; i++){
          x*=2 ;
        }
        out.println(x-1);
      }
      out.close();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   operation different( s1 : String, s2 : String, i : int) : String
  pre: true
  post: true
  activity: (     var check : Sequence(String) ; check := Sequence{'a','b','c'} ;
     for (ch : check) do ( (     if (ch /= s1->at(i+1) & ch /= s2->at(i+1)) then (     return ch ) else skip )  ) ; 
     return 'z' );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := fs.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := fs.nextInt() ;
     var x : long ; x := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (     x := x*(2) )  ;     i := i + 1 ) ; 
     skip ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class C {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      System.out.println((int)Math.pow(2,n)-1+1-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     OclFile["System.out"].println(2->pow(n)->oclAsType(int) - 1 + 1 - 1) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemB {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    String s=br.readLine();
    int arr[]=new int[10];
    String line[]=br.readLine().split(" ");
    for(int i=1 ; i<10 ; i++)arr[i]=Integer.parseInt(line[i-1]);
    boolean ok=true ;
    for(int i=0 ; i<n ; i++){
      int curr=s.charAt(i)-'0' ;
      if(curr<arr[curr] && ok){
        while(i<n && curr<=arr[curr]){
          sb.append(arr[curr]);
          i++;
          curr=i<n ?(s.charAt(i)-'0'):-1 ;
        }
        i--;
        ok=false ;
      }
      else {
        sb.append(s.charAt(i));
      }
    }
    System.out.println(sb);
  }
  public static void sort(int arr[]){
    ArrayList<Integer>list=new ArrayList<>();
    for(int it : arr)list.add(it);
    Collections.sort(list);
    for(int i=0 ; i<arr.length ; i++)arr[i]=list.get(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var s : String ; s := br.readLine() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,10)->collect(0) ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
        var i : int ; i := 1 ; while i < 10 do (     arr[i+1] := (line[(i)->char2byte() - 1+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var ok : boolean ; ok := true ;
        var i : int ; i := 0 ; while i < n do ( (     var curr : int ; curr := s->at(i+1) - ('0')->char2byte() ;
     if (curr < arr[curr+1] & ok) then (     while (i < n & curr <= arr[curr+1]) do (     sb := sb + StringLib.newString(arr[curr+1]) ; 
     i := i + 1 ; 
     curr := if i < n then (s->at(i+1) - ('0')->char2byte()) else -1 endif ) ; 
     i := i - 1 ; 
     ok := false ) else (     sb := sb + StringLib.newString(s->at(i+1)) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
  static   operation sort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     for (it : arr) do (     list := list->including(it) ;  ) ; 
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < arr->size() do (     arr[i+1] := list->at(i+1) ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class C {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      System.out.println((int)Math.pow(2,n)-2+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     OclFile["System.out"].println(2->pow(n)->oclAsType(int) - 2 + 1) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test280 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      System.out.println((int)Math.pow(2,in.nextInt())-1);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test280 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     OclFile["System.out"].println(2->pow(in.getCurrent()->toInteger())->oclAsType(int) - 1) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isOdd(int[] arr,int n){
    int l,r,flag=0,flag1=0,sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=arr[i];
      if(arr[i] % 2==0 && flag==0){
        flag=1 ;
        l=arr[i];
      }
      if(arr[i] % 2!=0 && flag1==0){
        r=arr[i];
        flag1=1 ;
      }
    }
    if(sum % 2!=0){
      return true ;
    }
    else {
      if(flag1==1 && flag==1)return true ;
      else return false ;
    }
  }
  public static void main(String[] args){
    int ar[]={
      5,4,4,5,1,3 };
      int n=ar.length ;
      boolean res=isOdd(ar,n);
      if(res==true)System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isOdd( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var l : int ;
    var r : int ;
    var flag : int ; flag := 0 ;
    var flag1 : int ; flag1 := 0 ;
    var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(arr[i+1]) ; 
     if (arr[i+1] mod 2 = 0 & flag = 0) then (     flag := 1 ; 
     l := arr[i+1] ) else skip ; 
     if (arr[i+1] mod 2 /= 0 & flag1 = 0) then (     r := arr[i+1] ; 
     flag1 := 1 ) else skip )  ;     i := i + 1 ) ; 
     if (sum mod 2 /= 0) then (     return true ) else (     if (flag1 = 1 & flag = 1) then     return true else     return false ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ar : Sequence(int) ; ar := Sequence{5,4,4,5,1,3} ;
     var n : int ; n := ar->size() ;
     var res : boolean ; res := isOdd(ar, n) ;
     if (res = true) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayDeque ;
import java.util.Deque ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String stations="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" ;
    while(true){
      int n=scanner.nextInt();
      if(n==0){
        break ;
      }
      Deque<Integer>deque=new ArrayDeque<Integer>();
      for(int i=0 ; i<n ; i++){
        deque.addFirst(scanner.nextInt());
      }
      String list=scanner.next();
      for(int i=0 ; i<list.length(); i++){
        int s=stations.indexOf(list.substring(i,i+1));
        int key=deque.pollLast();
        deque.addFirst(key);
        s-=key ;
        if(s<0){
          s+=52 ;
        }
        System.out.print(stations.substring(s,s+1));
      }
      System.out.print("\n");
    }
  }
  static int nextInt(){
    int c ;
    try {
      c=System.in.read();
      while(c!='-' &&(c<'0' || c>'9'))c=System.in.read();
      if(c=='-')return-nextInt();
      int res=0 ;
      while(c>='0' && c<='9'){
        res=res*10+c-'0' ;
        c=System.in.read();
      }
      return res ;
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var stations : String ; stations := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var deque : Sequence(int) ; deque := ArrayDeque<int>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < n do ( (     deque := deque->prepend(scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var list : String ; list := scanner.getCurrent() ;
        var i : int ; i := 0 ; while i < list->size() do ( (     var s : int ; s := stations->indexOf(list.subrange(i+1,i + 1))-1 ;
     var key : int ; key := deque->last() ;
    deque := deque->prepend(key) ; 
    s := s-(key) ; 
    if (s < 0) then (     s := s+(52) ) else skip ; 
    OclFile["System.out"].print(stations.subrange(s+1,s + 1)) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("\n") ; 
 ) );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     var c : int ;
     try (     c := OclFile["System.in"].read() ; 
     while (c /= '-' & (c < '0' or c > '9')) do     c := OclFile["System.in"].read() ; ; 
    if (c = '-') then     return -nextInt() else skip ; 
    var res : int ; res := 0 ;
    while (c >= '0' & c <= '9') do (     res := res * 10 + c - ('0')->char2byte() ; 
     c := OclFile["System.in"].read() ) ; 
    return res 
 )   catch (e : IOException) do (     e.printStackTrace() )
     return -1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      int k=sc.nextInt();
      sc.nextLine();
      String val=sc.nextLine();
      int i=0,j=val.length()-1 ;
      while(k>0){
        if(val.charAt(i)!=val.charAt(j))break ;
        k--;
        i++;
        j--;
      }
      if(k>0)System.out.println("NO");
      else if(i>j){
        System.out.println("NO");
      }
      else System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    skip ; 
    var val : String ; val := sc.nextLine() ;
    var i : int ; i := 0 ;
    var j : int ; j := val->size() - 1 ;
    while (k > 0) do (     if (val->at(i+1) /= val->at(j+1)) then     break else skip ; 
     k := k - 1 ; 
     i := i + 1 ; 
     j := j - 1 ) ; 
    if (k > 0) then     OclFile["System.out"].println("NO") else     if (i > j) then (     OclFile["System.out"].println("NO") ) else     OclFile["System.out"].println("YES") ; ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      int k=sc.nextInt();
      String s=sc.next();
      if(k==0){
        System.out.println("YES");
      }
      else if(n % 2==0 && k==n/2){
        System.out.println("NO");
      }
      else {
        String ans="YES" ;
        for(int i=0 ; i<k ; i++){
          if(s.charAt(i)!=s.charAt(n-i-1)){
            ans="NO" ;
            break ;
          }
        }
        System.out.println(ans);
      }
      t--;
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    if (k = 0) then (     OclFile["System.out"].println("YES") ) else     if (n mod 2 = 0 & k = n / 2) then (     OclFile["System.out"].println("NO") ) else (     var ans : String ; ans := "YES" ;
         var i : int ; i := 0 ; while i < k do ( (     if (s->at(i+1) /= s->at(n - (i)->char2byte() - 1+1)) then (     ans := "NO" ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) ) ;  ;  
    t := t - 1 ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  static int maxCommonFactors(int a,int b){
    int __gcd=gcd(a,b);
    int ans=1 ;
    for(int i=2 ; i*i<=__gcd ; i++){
      if(__gcd % i==0){
        ans++;
        while(__gcd % i==0)__gcd/=i ;
      }
    }
    if(__gcd!=1)ans++;
    return ans ;
  }
  public static void main(String[] args){
    int a=12,b=18 ;
    System.out.println(maxCommonFactors(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation maxCommonFactors( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var __gcd : int ; __gcd := gcd(a, b) ;
     var ans : int ; ans := 1 ;
        var i : int ; i := 2 ; while i * i <= __gcd do ( (     if (__gcd mod i = 0) then (     ans := ans + 1 ; 
     while (__gcd mod i = 0) do     __gcd := __gcd/(i) ; ) else skip )  ;     i := i + 1 ) ; 
    if (__gcd /= 1) then     ans := ans + 1 ; else skip ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 12 ;
    var b : int ; b := 18 ;
     OclFile["System.out"].println(maxCommonFactors(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static boolean allCharactersSame(String s){
    int n=s.length();
    for(int i=1 ; i<n ; i++)if(s.charAt(i)!=s.charAt(0))return false ;
    return true ;
  }
  static public void main(String[] args){
    String s="aaa" ;
    if(allCharactersSame(s))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation allCharactersSame( s : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
         var i : int ; i := 1 ; while i < n do (     if (s->at(i+1) /= s->at(0+1)) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "aaa" ;
     if (allCharactersSame(s)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class CardGame {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    while(t-->0){
      int n,a,b ;
      StringTokenizer st=new StringTokenizer(br.readLine());
      n=Integer.parseInt(st.nextToken());
      a=Integer.parseInt(st.nextToken());
      b=Integer.parseInt(st.nextToken());
      int ma,mb,ta=0,tb=0 ;
      st=new StringTokenizer(br.readLine());
      for(int i=0 ; i<a ; i++){
        ma=Integer.parseInt(st.nextToken());
        ;
        if(ma>ta)ta=ma ;
      }
      st=new StringTokenizer(br.readLine());
      for(int i=0 ; i<b ; i++){
        mb=Integer.parseInt(st.nextToken());
        ;
        if(mb>tb)tb=mb ;
      }
      System.out.println((ta>tb)? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CardGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ;
    var a : int ;
    var b : int ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    n := (st.next())->toInteger() ; 
    a := (st.next())->toInteger() ; 
    b := (st.next())->toInteger() ; 
    var ma : int ;
    var mb : int ;
    var ta : int ; ta := 0 ;
    var tb : int ; tb := 0 ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < a do ( (     ma := (st.next())->toInteger() ; 
     if (ma > ta) then     ta := ma ; else skip )  ;     i := i + 1 ) ; 
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < b do ( (     mb := (st.next())->toInteger() ; 
     if (mb > tb) then     tb := mb ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if (ta > tb) then "YES" else "NO" endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Comparator ;
import java.util.List ;
import java.util.StringTokenizer ;
public class CardGame {
  public static class ListComparator implements Comparator<List<Integer>>{
    @ Override public int compare(List<Integer>l1,List<Integer>l2){
      for(int i=0 ; i<l1.size(); ++i){
        if(l1.get(i).compareTo(l2.get(i))!=0){
          return l1.get(i).compareTo(l2.get(i));
        }
      }
      return 0 ;
    }
  }
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    int T=Integer.parseInt(f.readLine());
    for(int i=0 ; i<T ; i++){
      StringTokenizer st=new StringTokenizer(f.readLine());
      int N=Integer.parseInt(st.nextToken());
      int a=Integer.parseInt(st.nextToken());
      int b=Integer.parseInt(st.nextToken());
      boolean check=false ;
      StringTokenizer ab=new StringTokenizer(f.readLine());
      for(int j=0 ; j<a ; j++){
        int c=Integer.parseInt(ab.nextToken());
        if(c==N){
          check=true ;
          break ;
        }
      }
      f.readLine();
      if(check){
        out.println("YES");
      }
      else {
        out.println("NO");
      }
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CardGame {
  static class ListComparator implements Function(<Sequence(int)>,(<Sequence(int)>,boolean)) {
      operation compare( l1 : Sequence(int), l2 : Sequence(int)) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < l1->size() do ( (     if (l1->at(i+1)->compareTo(l2->at(i+1)) /= 0) then (     return l1->at(i+1)->compareTo(l2->at(i+1)) ) else skip )  ;     i := i + 1 ) ; 
     return 0 );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := (f.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < T do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
     var N : int ; N := (st.next())->toInteger() ;
    var a : int ; a := (st.next())->toInteger() ;
    var b : int ; b := (st.next())->toInteger() ;
    var check : boolean ; check := false ;
    var ab : OclIterator ; ab := OclIterator.newOclIterator_String(f.readLine()) ;
        var j : int ; j := 0 ; while j < a do ( (     var c : int ; c := (ab.next())->toInteger() ;
     if (c = N) then (     check := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    skip ; 
    if (check) then (     skip ) else (     skip ) ;  
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Problem1 {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int n=Integer.parseInt(f.readLine());
    String str=f.readLine();
    int[] func=new int[10];
    StringTokenizer st=new StringTokenizer(f.readLine());
    for(int i=0 ; i<9 ; i++){
      func[i+1]=Integer.parseInt(st.nextToken());
    }
    StringBuilder nstr=new StringBuilder();
    boolean on=false ;
    for(int i=0 ; i<n ; i++){
      int val=str.charAt(i)-'0' ;
      if(on==false){
        if(func[val]>val){
          on=true ;
          nstr.append(func[val]);
        }
        else {
          nstr.append(val);
        }
      }
      else {
        if(func[val]>=val){
          nstr.append(func[val]);
        }
        else {
          int j=i ;
          while(j<n){
            nstr.append(str.charAt(j));
            j++;
          }
          break ;
        }
      }
    }
    out.println(nstr);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := (f.readLine())->toInteger() ;
    var str : String ; str := f.readLine() ;
    var func : Sequence(int) ; func := Integer.subrange(1,10)->collect(0) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
        var i : int ; i := 0 ; while i < 9 do ( (     func[i + 1+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    var nstr : String ; nstr := StringLib.newString() ;
    var on : boolean ; on := false ;
        var i : int ; i := 0 ; while i < n do ( (     var val : int ; val := str->at(i+1) - ('0')->char2byte() ;
     if (on = false) then (     if (func[val+1] > val) then (     on := true ; 
     nstr := nstr + StringLib.newString(func[val+1]) ) else (     nstr := nstr + StringLib.newString(val) ) ) else (     if (func[val+1] >= val) then (     nstr := nstr + StringLib.newString(func[val+1]) ) else (     var j : int ; j := i ;
     while (j < n) do (     nstr := nstr + StringLib.newString(str->at(j+1)) ; 
     j := j + 1 ) ; 
     break ) ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  static void printUnsorted(int arr[],int n){
    int s=0,e=n-1,i,max,min ;
    for(s=0 ; s<n-1 ; s++){
      if(arr[s]>arr[s+1])break ;
    }
    if(s==n-1){
      System.out.println("The complete array is sorted");
      return ;
    }
    for(e=n-1 ; e>0 ; e--){
      if(arr[e]<arr[e-1])break ;
    }
    max=arr[s];
    min=arr[s];
    for(i=s+1 ; i<=e ; i++){
      if(arr[i]>max)max=arr[i];
      if(arr[i]<min)min=arr[i];
    }
    for(i=0 ; i<s ; i++){
      if(arr[i]>min){
        s=i ;
        break ;
      }
    }
    for(i=n-1 ; i>=e+1 ; i--){
      if(arr[i]<max){
        e=i ;
        break ;
      }
    }
    System.out.println(" The unsorted subarray which"+" makes the given array sorted lies"+"  between the indices "+s+" and "+e);
    return ;
  }
  public static void main(String args[]){
    int arr[]={
      10,12,20,30,25,40,32,31,35,50,60 };
      int arr_size=arr.length ;
      printUnsorted(arr,arr_size);
    }
  }

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation printUnsorted( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var s : int ; s := 0 ;
    var e : int ; e := n - 1 ;
    var i : int ;
    var max : int ;
    var min : int ;
         s := 0 ; while s < n - 1 do ( (     if (arr[s+1] > arr[s + 1+1]) then     break else skip )  ;     s := s + 1 ) ; 
    if (s = n - 1) then (     OclFile["System.out"].println("The complete array is sorted") ; 
     return ) else skip ; 
        e := n - 1 ; while e > 0 do ( (     if (arr[e+1] < arr[e - 1+1]) then     break else skip )  ;     e := e - 1 ) ; 
    max := arr[s+1] ; 
    min := arr[s+1] ; 
        i := s + 1 ; while i <= e do ( (     if (arr[i+1] > max) then     max := arr[i+1] ; else skip ; 
     if (arr[i+1] < min) then     min := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
        i := 0 ; while i < s do ( (     if (arr[i+1] > min) then (     s := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        i := n - 1 ; while i >= e + 1 do ( (     if (arr[i+1] < max) then (     e := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(" The unsorted subarray which" + " makes the given array sorted lies" + "  between the indices " + s + " and " + e) ; 
    return 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,12,20,30,25,40,32,31,35,50,60} ;
     var arr_size : int ; arr_size := arr->size() ;
     execute printUnsorted(arr, arr_size) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class QQQ {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    int c=1 ;
    int[] a=new int[t];
    int[] k=new int[t+1];
    int k1=0 ;
    for(int i=0 ; i<t ; i++){
      a[i]=in.nextInt();
    }
    for(int i=1 ; i<t ; i++){
      if(a[i]>=a[i-1]){
        c++;
      }
      else {
        k[k1++]=c ;
        c=1 ;
      }
    }
    k[t]=c ;
    Arrays.sort(k);
    System.out.println(k[k.length-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class QQQ {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var c : int ; c := 1 ;
    var a : Sequence(int) ; a := Integer.subrange(1,t)->collect(0) ;
    var k : Sequence(int) ; k := Integer.subrange(1,t + 1)->collect(0) ;
    var k1 : int ; k1 := 0 ;
        var i : int ; i := 0 ; while i < t do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < t do ( (     if (a[i+1] >= a[i - 1+1]) then (     c := c + 1 ) else (      k[k1+1] := c  ; k1 := k1 + 1 ; 
     c := 1 ) )  ;     i := i + 1 ) ; 
    k[t+1] := c ; 
    k := k->sort() ; 
    OclFile["System.out"].println(k[k->size() - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  Scanner sc=new Scanner(System.in);
  HashMap<String,Integer>map=new HashMap<String,Integer>();
  String[] stations={
    "a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z" };
    public void run(){
      for(int i=0 ; i<52 ; i++){
        map.put(stations[i],i);
      }
      while(true){
        int n=sc.nextInt();
        if(n==0)break ;
        calc(n);
      }
    }
    public void calc(int n){
      int[] k=new int[100];
      for(int i=0 ; i<n ; i++){
        k[i]=sc.nextInt();
      }
      String s=sc.next();
      int len=s.length();
      int knum=0 ;
      for(int i=0 ; i<len ; i++){
        String sta=s.substring(i,i+1);
        int stanum=map.get(sta);
        stanum-=k[knum];
        if(stanum<0)stanum+=52 ;
        System.out.print(stations[stanum]);
        knum++;
        if(knum==n)knum=0 ;
      }
      System.out.println();
    }
    public static void main(String[] args){
      new Main().run();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute map : Map(String,int) := Map{};
   attribute stations : Sequence(String) := Sequence{"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};
   operation run() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 52 do ( (     map := map->union(Map{stations[i+1] |-> i}) )  ;     i := i + 1 ) ; 
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
     execute calc(n) ) );
   operation calc( n : int) : void
  pre: true
  post: true
  activity: (     var k : Sequence(int) ; k := Integer.subrange(1,100)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     k[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var s : String ; s := sc.getCurrent() ;
    var len : int ; len := s->size() ;
    var knum : int ; knum := 0 ;
        var i : int ; i := 0 ; while i < len do ( (     var sta : String ; sta := s.subrange(i+1,i + 1) ;
     var stanum : int ; stanum := map->at(sta) ;
    stanum := stanum-(k[knum+1]) ; 
    if (stanum < 0) then     stanum := stanum+(52) ; else skip ; 
    OclFile["System.out"].print(stations[stanum+1]) ; 
    knum := knum + 1 ; 
    if (knum = n) then     knum := 0 ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf580A {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=input.nextInt();
    int count=1 ;
    int max=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if(a[i]<=a[i+1])count++;
      else {
        if(count>max)max=count ;
        count=1 ;
      }
    }
    System.out.println(max<count ? count : max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf580A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := input.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var count : int ; count := 1 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (a[i+1] <= a[i + 1+1]) then     count := count + 1 ; else (     if (count > max) then     max := count ; else skip ; 
     count := 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if max < count then count else max endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf580A {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=input.nextInt();
    int count=1 ;
    int max=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if(a[i]<=a[i+1])count++;
      else {
        if(count>max)max=count ;
        count=1 ;
      }
    }
    System.out.println(max<count ? count : max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf580A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := input.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var count : int ; count := 1 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (a[i+1] <= a[i + 1+1]) then     count := count + 1 ; else (     if (count > max) then     max := count ; else skip ; 
     count := 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if max < count then count else max endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long arr[]=new long[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextLong();
    int count=1 ;
    int max=1 ;
    for(int i=1 ; i<n ; i++){
      if(arr[i]>=arr[i-1])count++;
      else count=1 ;
      max=Math.max(max,count);
    }
    System.out.print(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var count : int ; count := 1 ;
    var max : int ; max := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] >= arr[i - 1+1]) then     count := count + 1 else     count := 1 ; ;  
     max := Set{max, count}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sin=new Scanner(System.in);
    int L=sin.nextInt();
    int D=sin.nextInt();
    int result=L/D+L % D ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sin : OclFile ; sin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var L : int ; L := sin.getCurrent()->toInteger() ;
    var D : int ; D := sin.getCurrent()->toInteger() ;
    var result : int ; result := L / D + L mod D ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    line=br.readLine();
    int D,L ;
    D=parseInt(line.substring(0,line.indexOf(' ')));
    L=parseInt(line.substring(line.indexOf(' ')+1));
    int[] dp=new int[D+1];
    for(int i=0 ; i<=D ; i++){
      if(i<L)dp[i]=i ;
      else dp[i]=Integer.MAX_VALUE ;
    }
    for(int i=L ; i<=D ; i++){
      dp[i]=Math.min(dp[i],dp[i-L]+1);
    }
    System.out.println(dp[D]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    line := br.readLine() ; 
    var D : int ;
    var L : int ;
    D := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    L := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,D + 1)->collect(0) ;
        var i : int ; i := 0 ; while i <= D do ( (     if (i < L) then     dp[i+1] := i ; else     dp[i+1] := 2147483647 ; )  ;     i := i + 1 ) ; 
        var i : int ; i := L ; while i <= D do ( (     dp[i+1] := Set{dp[i+1], dp[i - L+1] + 1}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[D+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args){
    BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    String str="" ;
    StringTokenizer stk ;
    int DIST,M_JUMP ;
    try {
      str=bfr.readLine();
      if(str==""){
        System.exit(0);
      }
      stk=new StringTokenizer(str," ");
      DIST=Integer.parseInt(stk.nextToken());
      M_JUMP=Integer.parseInt(stk.nextToken());
      int d_jk=DIST/M_JUMP ;
      int kaisu=d_jk+((DIST-(M_JUMP*d_jk))/1);
      System.out.println(kaisu);
    }
    catch(IOException e){
      System.exit(0);
    }
    catch(NumberFormatException e){
      System.exit(0);
    }
    catch(NullPointerException e){
      System.exit(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bfr : OclFile ; bfr := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := "" ;
    var stk : OclIterator ;
    var DIST : int ;
    var M_JUMP : int ;
    try (     str := bfr.readLine() ; 
     if (str = "") then ( OclProcess.exit(0) ) else skip ; 
    stk := OclIterator.newOclIterator_String_String(str, " ") ; 
    DIST := (stk.next())->toInteger() ; 
    M_JUMP := (stk.next())->toInteger() ; 
    var d_jk : int ; d_jk := DIST / M_JUMP ;
    var kaisu : int ; kaisu := d_jk + ((DIST - (M_JUMP * d_jk)) / 1) ;
    OclFile["System.out"].println(kaisu) ; 
 )   catch (e : IOException) do ( OclProcess.exit(0) )
   catch (e : IncorrectElementException) do ( OclProcess.exit(0) )
  catch (e : NullAccessException) do ( OclProcess.exit(0) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int gole=sc.nextInt();
    int big=sc.nextInt();
    int ans=(gole/big)+(gole % big);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var gole : int ; gole := sc.getCurrent()->toInteger() ;
     var big : int ; big := sc.getCurrent()->toInteger() ;
     var ans : int ; ans := (gole / big) + (gole mod big) ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(is);
    String str ;
    while((str=br.readLine())!=null){
      String[] sp=str.split(" ");
      int D=Integer.parseInt(sp[0]);
      int L=Integer.parseInt(sp[1]);
      if(D % L==0){
        System.out.println(D/L);
      }
      else {
        System.out.println(D/L+D % L);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(is) ;
     var str : String ;
         str := br.readLine() ;
    while ((str) /= null) do (    skip ; (     var sp : Sequence(String) ; sp := str->split(" ") ;
     var D : int ; D := (sp[0+1])->toInteger() ;
     var L : int ; L := (sp[1+1])->toInteger() ;
     if (D mod L = 0) then (     OclFile["System.out"].println(D / L) ) else (     OclFile["System.out"].println(D / L + D mod L) ) ) ;     str := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution16 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    int[] arr=new int[9];
    for(int i=0 ; i<9 ; i++){
      arr[i]=sc.nextInt();
    }
    int id1=0 ;
    int id2=s.length();
    StringBuilder str=new StringBuilder();
    for(int i=0 ; i<s.length(); i++){
      char ch=s.charAt(i);
      int x=Character.getNumericValue(ch);
      if(x<arr[x-1]){
        id1=i ;
        break ;
      }
    }
    for(int i=id1 ; i<s.length(); i++){
      char ch=s.charAt(i);
      int x=Character.getNumericValue(ch);
      if(x>arr[x-1]){
        id2=i ;
        break ;
      }
    }
    for(int i=0 ; i<id1 ; i++){
      char ch=s.charAt(i);
      int x=Character.getNumericValue(ch);
      str.append(x);
    }
    for(int i=id1 ; i<id2 ; i++){
      char ch=s.charAt(i);
      int x=Character.getNumericValue(ch);
      str.append(arr[x-1]);
    }
    for(int i=id2 ; i<s.length(); i++){
      char ch=s.charAt(i);
      int x=Character.getNumericValue(ch);
      str.append(x);
    }
    System.out.println(str.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution16 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,9)->collect(0) ;
        var i : int ; i := 0 ; while i < 9 do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var id1 : int ; id1 := 0 ;
    var id2 : int ; id2 := s->size() ;
    var str : String ; str := StringLib.newString() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var ch : String ; ch := s->at(i+1) ;
     var x : int ; x := ("" + ch)->toInteger() ;
     if (x < arr[(x)->char2byte() - 1+1]) then (     id1 := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := id1 ; while i < s->size() do ( (     var ch : String ; ch := s->at(i+1) ;
     var x : int ; x := ("" + ch)->toInteger() ;
     if (x > arr[(x)->char2byte() - 1+1]) then (     id2 := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < id1 do ( (     var ch : String ; ch := s->at(i+1) ;
     var x : int ; x := ("" + ch)->toInteger() ;
     str := str + StringLib.newString(x) )  ;     i := i + 1 ) ; 
        var i : int ; i := id1 ; while i < id2 do ( (     var ch : String ; ch := s->at(i+1) ;
     var x : int ; x := ("" + ch)->toInteger() ;
     str := str + StringLib.newString(arr[(x)->char2byte() - 1+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := id2 ; while i < s->size() do ( (     var ch : String ; ch := s->at(i+1) ;
     var x : int ; x := ("" + ch)->toInteger() ;
     str := str + StringLib.newString(x) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(str+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package cj2015.qr ;
import java.io.*;
import java.util.*;
public class B {
  Scanner sc ;
  PrintWriter pw ;
  int D ;
  int[] P ;
  public static void main(String[] args)throws Exception {
    String filePrefix=args.length>0 ? args[0] : "B-large" ;
    try {
      new B().run(filePrefix);
    }
    catch(Exception e){
      System.err.println(e);
    }
  }
  public void run(String filePrefix)throws Exception {
    sc=new Scanner(new FileReader(filePrefix+".in"));
    pw=new PrintWriter(new FileWriter(filePrefix+".out"));
    int ntest=sc.nextInt();
    for(int test=1 ; test<=ntest ; test++){
      read(sc);
      pw.print("Case #"+test+": ");
      System.out.print("Case #"+test+": ");
      solve();
    }
    System.out.println("Finished.");
    sc.close();
    pw.close();
  }
  void read(Scanner sc){
    D=sc.nextInt();
    P=new int[D];
    for(int i=0 ; i<D ; i++)P[i]=sc.nextInt();
  }
  void print(Object s){
    pw.print(s);
    System.out.print(s);
  }
  void println(Object s){
    pw.println(s);
    System.out.println(s);
  }
  public void solve(){
    final int INF=1000000 ;
    int min=INF ;
    for(int x=1 ; x<=1000 ; x++){
      int time=0 ;
      for(int i=0 ; i<D ; i++)time+=(P[i]+x-1)/x-1 ;
      min=Math.min(min,time+x);
    }
    println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
   attribute sc : OclFile;
   attribute pw : OclFile;
   attribute D : int;
   attribute P : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var filePrefix : String ; filePrefix := if args->size() > 0 then args[0+1] else "B-large" endif ;
     try (     B.newB().run(filePrefix) )   catch (e : ProgramException) do (     OclFile["System.err"].println(e) )
 );
   operation run( filePrefix : String) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(filePrefix + ".in")) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(filePrefix + ".out")) ; 
    var ntest : int ; ntest := sc.getCurrent()->toInteger() ;
        var test : int ; test := 1 ; while test <= ntest do ( (     execute read(sc) ; 
     skip ; 
     OclFile["System.out"].print("Case #" + test + ": ") ; 
     execute solve() )  ;     test := test + 1 ) ; 
    OclFile["System.out"].println("Finished.") ; 
    skip ; 
    skip ; 
 );
   operation read( sc : OclFile) : void
  pre: true
  post: true
  activity: (     D := sc.getCurrent()->toInteger() ; 
     P := Integer.subrange(1,D)->collect(0) ; 
         var i : int ; i := 0 ; while i < D do (     P[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) );
   operation print( s : OclAny) : void
  pre: true
  post: true
  activity: (     skip ; 
     OclFile["System.out"].print(s) );
   operation println( s : OclAny) : void
  pre: true
  post: true
  activity: (     skip ; 
     OclFile["System.out"].println(s) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var INF : int ; INF := 1000000 ;
     var min : int ; min := INF ;
         var x : int ; x := 1 ; while x <= 1000 do ( (     var time : int ; time := 0 ;
         var i : int ; i := 0 ; while i < D do (     time := time+((P[i+1] + x - 1) / x - 1) ;  ;     i := i + 1 ) ; 
     min := Set{min, time + x}->min() )  ;     x := x + 1 ) ; 
     execute println(min) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    String cs="" ;
    for(int i=0 ; i<26 ; i++)cs+=(char)('a'+i);
    for(int i=0 ; i<26 ; i++)cs+=(char)('A'+i);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      String code=sc.next();
      String ret="" ;
      for(int i=0 ; i<code.length(); i++){
        int p=0 ;
        for(; p<cs.length(); p++)if(cs.charAt(p)==code.charAt(i))break ;
        ret+=cs.charAt((p+cs.length()-a[i % a.length])% cs.length());
      }
      System.out.println(ret);
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cs : String ; cs := "" ;
        var i : int ; i := 0 ; while i < 26 do (     cs := cs+(('a' + i)->oclAsType(String)) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 26 do (     cs := cs+(('A' + i)->oclAsType(String)) ;  ;     i := i + 1 ) ; 
      while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var code : String ; code := sc.getCurrent() ;
    var ret : String ; ret := "" ;
        var i : int ; i := 0 ; while i < code->size() do ( (     var p : int ; p := 0 ;
       while p < cs->size() do (     if (cs->at(p+1) = code->at(i+1)) then     break else skip ;  ;     p := p + 1 ) ; 
     ret := ret+(cs->at((p + cs->size() - a[i mod a->size()+1]) mod cs->size()+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ret) ; 
 )  ) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedWriter ;
import java.io.File ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.util.Scanner ;
public class B {
  static final String FILENAME="B-large" ;
  static final String IN=FILENAME+".in" ;
  static final String OUT=FILENAME+".out" ;
  Scanner sc ;
  BufferedWriter out ;
  static final int MAXP=1000 ;
  private int divideTime(int[] num,int limit){
    int time=0 ;
    for(int i=limit+1 ; i<=MAXP ; i++){
      time+=num[i]*((i-1)/limit);
    }
    return time ;
  }
  private void solve()throws IOException {
    int ans=Integer.MAX_VALUE ;
    int d=sc.nextInt();
    int[] num=new int[MAXP+1];
    for(int i=0 ; i<d ; i++){
      num[sc.nextInt()]++;
    }
    for(int limit=1 ; limit<=MAXP ; limit++){
      int cur=divideTime(num,limit)+limit ;
      if(ans>cur){
        ans=cur ;
      }
    }
    out.write(Integer.toString(ans));
    out.newLine();
    out.flush();
  }
  private void run()throws IOException {
    sc=new Scanner(new File(IN));
    out=new BufferedWriter(new FileWriter(OUT));
    int t=sc.nextInt();
    for(int i=1 ; i<=t ; i++){
      out.write("Case #"+i+": ");
      solve();
    }
    sc.close();
    out.close();
  }
  public static void main(String args[])throws Exception {
    new B().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static    attribute FILENAME : String := "B-large";
  static    attribute IN : String := FILENAME + ".in";
  static    attribute OUT : String := FILENAME + ".out";
   attribute sc : OclFile;
   attribute out : OclFile;
  static    attribute MAXP : int := 1000;
   operation divideTime( num : Sequence(int), limit : int) : int
  pre: true
  post: true
  activity: (     var time : int ; time := 0 ;
         var i : int ; i := limit + 1 ; while i <= MAXP do ( (     time := time+(num[i+1] * ((i - 1) / limit)) )  ;     i := i + 1 ) ; 
     return time );
   operation solve() : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := 2147483647 ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
    var num : Sequence(int) ; num := Integer.subrange(1,MAXP + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < d do ( (     num[sc.getCurrent()->toInteger()+1] := num[sc.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
        var limit : int ; limit := 1 ; while limit <= MAXP do ( (     var cur : int ; cur := divideTime(num, limit) + limit ;
     if (ans > cur) then (     ans := cur ) else skip )  ;     limit := limit + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile(IN)) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile(OUT))) ; 
    var t : int ; t := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= t do ( (     skip ; 
     execute solve() )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     B.newB().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.concurrent.*;
public class B {
  int n ;
  int[] a ;
  String solve(){
    Arrays.sort(a);
    int m=a[n-1];
    int ans=m ;
    for(int k=1 ; k<=m ; k++){
      int divs=0 ;
      for(int x : a){
        divs+=(x-1)/k ;
      }
      ans=Math.min(ans,k+divs);
    }
    return ""+ans ;
  }
  public B(Scanner in){
    n=in.nextInt();
    a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
  }
  private static String fileName=B.class.getSimpleName().replaceFirst("_.*","").toLowerCase();
  private static String inputFileName=fileName+".in" ;
  private static String outputFileName=fileName+".out" ;
  public static void main(String[] args)throws IOException,InterruptedException,ExecutionException {
    ExecutorService executor=Executors.newFixedThreadPool(4);
    Locale.setDefault(Locale.US);
    Scanner in=new Scanner(new File(inputFileName));
    PrintWriter out=new PrintWriter(outputFileName);
    int tests=in.nextInt();
    in.nextLine();
    @ SuppressWarnings("unchecked")Future<String>[] outputs=new Future[tests];
    for(int t=0 ; t<tests ; t++){
      final B testCase=new B(in);
      final int testCaseNumber=t ;
      outputs[t]=executor.submit(new Callable<String>(){
        @ Override public String call(){
          String answer=testCase.solve();
          String printed="Case #"+(testCaseNumber+1)+": "+answer ;
          System.out.println(printed);
          return printed ;
        }
      }
);
    }
    for(int t=0 ; t<tests ; t++){
      out.println(outputs[t] .get());
    }
    in.close();
    out.close();
    executor.shutdown();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
   attribute n : int;
   attribute a : Sequence(int);
   operation solve() : String
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var m : int ; m := a[n - 1+1] ;
    var ans : int ; ans := m ;
        var k : int ; k := 1 ; while k <= m do ( (     var divs : int ; divs := 0 ;
     for (x : a) do ( (     divs := divs+((x - 1) / k) )  ) ; 
     ans := Set{ans, k + divs}->min() )  ;     k := k + 1 ) ; 
    return "" + ans 
 );
   static operation newB( in : OclFile) : B
  pre: true
  post: true
  activity:
  ( var self : B ;
    self := createB();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     n := in.nextInt() ; 
     a := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.nextInt() )  ;     i := i + 1 ) );
  static   attribute fileName : String := OclType["B"].getSimpleName().replaceFirstMatch("_.*", "")->toLowerCase();
  static   attribute inputFileName : String := fileName + ".in";
  static   attribute outputFileName : String := fileName + ".out";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var executor : ExecutorService ; executor := Executors.newFixedThreadPool(4) ;
     Locale.setDefault(Locale.US) ; 
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile(inputFileName)) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile(outputFileName)) ;
    var tests : int ; tests := in.getCurrent()->toInteger() ;
    skip ; 
    var outputs : Sequence(Future<String>) ; outputs := Integer.subrange(1,tests)->collect(null) ;
        var t : int ; t := 0 ; while t < tests do ( (     var testCase : B ; testCase := B.newB(in) ;
     var testCaseNumber : int ; testCaseNumber := t ;
     outputs[t+1] := executor.submit(Callable<String>.newCallable()) )  ;     t := t + 1 ) ; 
        var t : int ; t := 0 ; while t < tests do ( (     skip )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
    executor.shutdown() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class InfinitePancakes {
  static final String filename="C:/Users/Kevin/algs4/CodeJam/InfinitePancakes/B-large.in" ;
  static final String output="largeoutput.txt" ;
  public static int howLong(int[] cakecounts){
    if(cakecounts.length<4)return cakecounts.length-1 ;
    int ret=Integer.MAX_VALUE ;
    for(int maxsize=2 ; maxsize<cakecounts.length ; ++maxsize){
      int[] cakes=Arrays.copyOf(cakecounts,cakecounts.length);
      int numspec=0 ;
      int maxstack=cakecounts.length-1 ;
      while(maxstack>maxsize){
        while(cakes[maxstack]>0){
          cakes[maxstack]--;
          cakes[maxstack-maxsize]++;
          cakes[maxsize]++;
          numspec++;
        }
        maxstack--;
      }
      ret=Math.min(ret,maxsize+numspec);
    }
    return ret ;
  }
  public static void main(String[] args){
    try {
      Scanner sc=new Scanner(new FileInputStream(new File(filename)));
      int no_of_times=sc.nextInt();
      for(int i=0 ; i<no_of_times ; ++i){
        int D=sc.nextInt();
        int[] platenumbers=new int[D];
        int maxnumber=0 ;
        for(int j=0 ; j<D ; ++j){
          platenumbers[j]=sc.nextInt();
          maxnumber=Math.max(maxnumber,platenumbers[j]);
        }
        int[] cakecounts=new int[maxnumber+1];
        for(int j=0 ; j<D ; ++j){
          cakecounts[platenumbers[j] ]++;
        }
        FileOutputStream fos=new FileOutputStream(output,true);
        fos.write(("Case #"+(i+1)+": "+howLong(cakecounts)+"\n").getBytes());
        fos.close();
      }
      sc.close();
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class InfinitePancakes {
  static    attribute filename : String := "C:/Users/Kevin/algs4/CodeJam/InfinitePancakes/B-large.in";
  static    attribute output : String := "largeoutput.txt";
  static   operation howLong( cakecounts : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (cakecounts->size() < 4) then     return cakecounts->size() - 1 else skip ; 
     var ret : int ; ret := 2147483647 ;
         var maxsize : int ; maxsize := 2 ; while maxsize < cakecounts->size() do ( (     var cakes : Sequence(int) ; cakes := cakecounts.subrange(1,cakecounts->size()) ;
     var numspec : int ; numspec := 0 ;
    var maxstack : int ; maxstack := cakecounts->size() - 1 ;
    while (maxstack > maxsize) do (     while (cakes[maxstack+1] > 0) do (     cakes[maxstack+1] := cakes[maxstack+1] - 1 ; 
     cakes[maxstack - maxsize+1] := cakes[maxstack - maxsize+1] + 1 ; 
     cakes[maxsize+1] := cakes[maxsize+1] + 1 ; 
     numspec := numspec + 1 ) ; 
     maxstack := maxstack - 1 ) ; 
    ret := Set{ret, maxsize + numspec}->min() ; 
 )  ;     maxsize := maxsize + 1 ) ; 
     return ret );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(filename))) ;
     var no_of_times : int ; no_of_times := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < no_of_times do ( (     var D : int ; D := sc.getCurrent()->toInteger() ;
     var platenumbers : Sequence(int) ; platenumbers := Integer.subrange(1,D)->collect(0) ;
    var maxnumber : int ; maxnumber := 0 ;
        var j : int ; j := 0 ; while j < D do ( (     platenumbers[j+1] := sc.getCurrent()->toInteger() ; 
     maxnumber := Set{maxnumber, platenumbers[j+1]}->max() )  ;     j := j + 1 ) ; 
    var cakecounts : Sequence(int) ; cakecounts := Integer.subrange(1,maxnumber + 1)->collect(0) ;
        var j : int ; j := 0 ; while j < D do ( (     cakecounts[platenumbers[j+1]+1] := cakecounts[platenumbers[j+1]+1] + 1 )  ;     j := j + 1 ) ; 
    var fos : OclFile ; fos := OclFile.newOclFile_Write(output, true) ;
    skip ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
     skip )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package gcj2015.qualif ;
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
import java.util.logging.Level ;
import java.util.logging.Logger ;
public class ExoB {
  public static void main(final String[] args){
    final String base="/home/jean/gcj2015/q/ExoB/" ;
    final String input=base+"b1.in" ;
    final String output=base+"b2.out" ;
    try {
      final Scanner sc=new Scanner(new FileReader(input));
      final PrintWriter pw=new PrintWriter(output);
      final int n=sc.nextInt();
      sc.nextLine();
      for(int c=0 ; c<n ; c++){
        System.out.println("Test case "+(c+1)+"...");
        pw.print("Case #"+(c+1)+": ");
        test3(sc,pw);
        pw.println();
      }
      pw.println();
      pw.flush();
      pw.close();
      sc.close();
    }
    catch(final FileNotFoundException ex){
      Logger.getLogger(ExoB.class.getName()).log(Level.SEVERE,null,ex);
    }
  }
  private static void test3(final Scanner sc,final PrintWriter pw){
    final int D=sc.nextInt();
    List<Integer>nums=new ArrayList<Integer>();
    for(int i=0 ; i<D ; i++){
      nums.add(sc.nextInt());
    }
    int max=Collections.max(nums);
    int bt=max ;
    for(int m=1 ; m<=max ; m++){
      System.out.println("for m="+m);
      int t=m ;
      for(int k : nums){
        if(k!=0)t+=(k % m==0)?(k/m)-1 : k/m ;
      }
      System.out.println("t="+t);
      if(t<bt){
        bt=t ;
      }
    }
    pw.print(bt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ExoB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var base : String ; base := "/home/jean/gcj2015/q/ExoB/" ;
     var input : String ; input := base + "b1.in" ;
     var output : String ; output := base + "b2.out" ;
     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(input))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile(output)) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
        var c : int ; c := 0 ; while c < n do ( (     OclFile["System.out"].println("Test case " + (c + 1) + "...") ; 
     skip ; 
     execute test3(sc, pw) ; 
     skip )  ;     c := c + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 )   catch (ex : FileNotFoundException) do (     Logger.getLogger(OclType["ExoB"].getName()).log(Level.SEVERE, null, ex) )
 );
  static   operation test3( sc : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var D : int ; D := sc.getCurrent()->toInteger() ;
     var nums : Sequence(int) ; nums := Sequence{} ;
        var i : int ; i := 0 ; while i < D do ( (     nums := nums->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var max : int ; max := .max(nums) ;
    var bt : int ; bt := max ;
        var m : int ; m := 1 ; while m <= max do ( (     OclFile["System.out"].println("for m=" + m) ; 
     var t : int ; t := m ;
    for (k : nums) do ( (     if (k /= 0) then     t := t+(if (k mod m = 0) then (k / m) - 1 else k / m endif) ; else skip )  ) ; 
    OclFile["System.out"].println("t=" + t) ; 
    if (t < bt) then (     bt := t ) else skip ; 
 )  ;     m := m + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.run();
  }
  ArrayList<ArrayList<Integer>>g=new ArrayList<>();
  int V=100005 ;
  boolean used[];
  int cnt[];
  private void dfs(int n){
    ArrayDeque<Integer>st=new ArrayDeque<>();
    st.add(n);
    used[n]=true ;
    cnt[n/V]++;
    while(! st.isEmpty()){
      int s=st.pop();
      ArrayList<Integer>l=g.get(s);
      for(int i=0 ; i<l.size(); i++){
        int t=l.get(i);
        if(! used[t]){
          used[t]=true ;
          cnt[t/V]++;
          st.add(t);
        }
      }
    }
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<V*2 ; i++)g.add(new ArrayList<>());
    used=new boolean[V*2];
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      y+=V ;
      g.get(x).add(y);
      g.get(y).add(x);
    }
    long ans=0 ;
    for(int i=0 ; i<V*2 ; i++){
      if(! used[i]){
        used[i]=true ;
        cnt=new int[2];
        dfs(i);
        ans+=(long)cnt[0]*cnt[1];
      }
    }
    ans-=n ;
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.run() );
   attribute g : Sequence(Sequence(int)) := Sequence{};
   attribute V : int := 100005;
   attribute used : Sequence(boolean);
   attribute cnt : Sequence(int);
   operation dfs( n : int) : void
  pre: true
  post: true
  activity: (     var st : Sequence(int) ; st := ArrayDeque<OclAny>.newArrayDeque() ;
     st := st->including(n) ; 
    used[n+1] := true ; 
    cnt[n / V+1] := cnt[n / V+1] + 1 ; 
    while (not(st->isEmpty())) do (     var s : int ; s := st->last() ;
     var l : Sequence(int) ; l := g->at(s+1) ;
         var i : int ; i := 0 ; while i < l->size() do ( (     var t : int ; t := l->at(i+1) ;
     if (not(used[t+1])) then (     used[t+1] := true ; 
     cnt[t / V+1] := cnt[t / V+1] + 1 ; 
     st := st->including(t) ) else skip )  ;     i := i + 1 ) ) ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < V * 2 do (     g := g->including(Sequence{}) ;  ;     i := i + 1 ) ; 
    used := Integer.subrange(1,V * 2)->collect(false) ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    y := y+(V) ; 
    g->at(x+1)->excludes(y) ; 
    g->at(y+1)->excludes(x) ; 
 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < V * 2 do ( (     if (not(used[i+1])) then (     used[i+1] := true ; 
     cnt := Integer.subrange(1,2)->collect(0) ; 
     execute dfs(i) ; 
     ans := ans+(cnt[0+1]->oclAsType(long) * cnt[1+1]) ) else skip )  ;     i := i + 1 ) ; 
    ans := ans-(n) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    Node[] nodes=new Node[200_001];
    for(int i=0 ; i<200_001 ; i++)nodes[i]=new Node(i);
    int N=scanner.nextInt();
    for(int i=0 ; i<N ; i++){
      int x=scanner.nextInt();
      int y=scanner.nextInt()+100_000 ;
      nodes[x] .adjacents.add(nodes[y]);
      nodes[y] .adjacents.add(nodes[x]);
    }
    boolean[] visited=new boolean[200_001];
    long res=0 ;
    for(int i=0 ; i<200_001 ; i++){
      if(! visited[i]){
        Result result=new Result();
        dfs(nodes[i],visited,result);
        res+=(long)result.nx*result.ny-result.m/2 ;
      }
    }
    System.out.println(res);
  }
  private static void dfs(Node node,boolean[] visited,Result result){
    visited[node.id]=true ;
    if(node.id<=100_000)result.nx++;
    else result.ny++;
    for(Node n : node.adjacents){
      result.m++;
      if(! visited[n.id]){
        dfs(n,visited,result);
      }
    }
  }
  private static class Result {
    int nx ;
    int ny ;
    int m ;
  }
  private static class Node {
    private final int id ;
    private List<Node>adjacents=new ArrayList<>();
    public Node(int id){
      this.id=id ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var nodes : Sequence(Node) ; nodes := Integer.subrange(1,200_001)->collect(null) ;
        var i : int ; i := 0 ; while i < 200_001 do (     nodes[i+1] := Node.newNode(i) ;  ;     i := i + 1 ) ; 
    var N : int ; N := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < N do ( (     var x : int ; x := scanner.getCurrent()->toInteger() ;
     var y : int ; y := scanner.getCurrent()->toInteger() + 100_000 ;
     nodes[x+1].adjacents->excludes(nodes[y+1]) ; 
     nodes[y+1].adjacents->excludes(nodes[x+1]) )  ;     i := i + 1 ) ; 
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,200_001)->collect(false) ;
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < 200_001 do ( (     if (not(visited[i+1])) then (     var result : Result ; result := Result.newResult() ;
     execute dfs(nodes[i+1], visited, result) ; 
     res := res+(result.nx->oclAsType(long) * result.ny - result.m / 2) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static   operation dfs( node : Node, visited : Sequence(boolean), result : Result) : void
  pre: true
  post: true
  activity: (     visited[node.id+1] := true ; 
     if (node.id <= 100_000) then     result.nx := result.nx + 1 else     result.ny := result.ny + 1 ; ;  
     for (n : node.adjacents) do ( (     result.m := result.m + 1 ; 
     if (not(visited[n.id+1])) then (     execute dfs(n, visited, result) ) else skip )  ) );
  static class Result {
   attribute nx : int;
   attribute ny : int;
   attribute m : int;
}
  static class Node {
   attribute id : int;
   attribute adjacents : Sequence(Node) := Sequence{};
   static operation newNode( id : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(id);
    return self );
  operation initialise( id : int) : void
  pre: true  post: true
  activity: (     self.id := id );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class IsDivisible {
  static boolean check(String str){
    int n=str.length();
    if((str.charAt(n-1)-'0')% 2!=0)return false ;
    int digitSum=0 ;
    for(int i=0 ; i<n ; i++)digitSum+=(str.charAt(i)-'0');
    return(digitSum % 3==0);
  }
  public static void main(String[] args){
    String str="1332" ;
    if(check(str))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class IsDivisible {
  static   operation check( str : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     if ((str->at(n - 1+1) - ('0')->char2byte()) mod 2 /= 0) then     return false else skip ; 
    var digitSum : int ; digitSum := 0 ;
        var i : int ; i := 0 ; while i < n do (     digitSum := digitSum+((str->at(i+1) - ('0')->char2byte())) ;  ;     i := i + 1 ) ; 
    return (digitSum mod 3 = 0) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "1332" ;
     if (check(str)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class IsDivisible {
  static boolean check(String str){
    int n=str.length();
    int digitSum=0 ;
    for(int i=0 ; i<n ; i++)digitSum+=(str.charAt(i)-'0');
    return(digitSum % 9==0);
  }
  public static void main(String[] args){
    String str="99333" ;
    if(check(str))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class IsDivisible {
  static   operation check( str : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var digitSum : int ; digitSum := 0 ;
         var i : int ; i := 0 ; while i < n do (     digitSum := digitSum+((str->at(i+1) - ('0')->char2byte())) ;  ;     i := i + 1 ) ; 
     return (digitSum mod 9 = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "99333" ;
     if (check(str)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public List<String>letterCasePermutation(String S){
    List<StringBuilder>ans=new ArrayList();
    ans.add(new StringBuilder());
    for(char c : S.toCharArray()){
      int n=ans.size();
      if(Character.isLetter(c)){
        for(int i=0 ; i<n ; ++i){
          ans.add(new StringBuilder(ans.get(i)));
          ans.get(i).append(Character.toLowerCase(c));
          ans.get(n+i).append(Character.toUpperCase(c));
        }
      }
      else {
        for(int i=0 ; i<n ; ++i)ans.get(i).append(c);
      }
    }
    List<String>finalans=new ArrayList();
    for(StringBuilder sb : ans)finalans.add(sb.toString());
    return finalans ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation letterCasePermutation( S : String) : Sequence(String)
  pre: true
  post: true
  activity: (     var ans : Sequence(String) ; ans := Sequence{} ;
     ans := ans->including(StringLib.newString()) ; 
    for (c : S->characters()) do ( (     var n : int ; n := ans->size() ;
     if ((c + "")->isMatch("[a-zA-Z]")) then (         var i : int ; i := 0 ; while i < n do ( (     ans := ans->including(StringLib.newString(ans->at(i+1))) ; 
     ans := ans->at(i+1) + StringLib.newString((c + "")->toLowerCase()) ; 
     ans := ans->at(n + i+1) + StringLib.newString((c + "")->toUpperCase()) )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < n do (     ans := ans->at(i+1) + StringLib.newString(c) ;  ;     i := i + 1 ) ) )  ) ; 
    var finalans : Sequence(String) ; finalans := Sequence{} ;
    for (sb : ans) do (     finalans := finalans->including(sb+"") ;  ) ; 
    return finalans 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    FFrogJump solver=new FFrogJump();
    solver.solve(1,in,out);
    out.close();
  }
  static class FFrogJump {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      long[] arr=new long[n];
      for(int i=0 ; i<n ; i++)arr[i]=in.nextLong();
      long res=solveMeOk(n,arr);
      out.println(res);
    }
    private long solveMeOk(int n,long[] arr){
      HashSet<Integer>used=new HashSet<>();
      long res=0 ;
      for(int c=1 ; c<n ; c++){
        used=new HashSet<>();
        long score=0 ;
        res=Math.max(res,score);
        used.add(0);
        used.add(n-1);
        for(int k=1 ; k*c<n-1 ; k++){
          if(n-1-k*c<c)break ;
          if(k*c==n-1-k*c)break ;
          if(used.contains(k*c)|| used.contains(n-1-k*c))break ;
          score+=arr[k*c]+arr[n-1-k*c];
          used.add(k*c);
          used.add(n-1-k*c);
          res=Math.max(score,res);
        }
      }
      return res ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : FFrogJump ; solver := FFrogJump.newFFrogJump() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class FFrogJump {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := in.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var res : long ; res := solveMeOk(n, arr) ;
    skip ; 
 );
   operation solveMeOk( n : int, arr : Sequence(long)) : long
  pre: true
  post: true
  activity: (     var used : Set(int) ; used := Set{} ;
     var res : long ; res := 0 ;
         var c : int ; c := 1 ; while c < n do ( (     used := Set{} ; 
     var score : long ; score := 0 ;
    res := Set{res, score}->max() ; 
    used := used->including(0) ; 
    used := used->including(n - 1) ; 
        var k : int ; k := 1 ; while k * c < n - 1 do ( (     if (n - 1 - k * c < c) then     break else skip ; 
     if (k * c = n - 1 - k * c) then     break else skip ; 
    if (used->includes(k * c) or used->includes(n - 1 - k * c)) then     break else skip ; 
    score := score+(arr[k * c+1] + arr[n - 1 - k * c+1]) ; 
    used := used->including(k * c) ; 
    used := used->including(n - 1 - k * c) ; 
    res := Set{score, res}->max() ; 
 )  ;     k := k + 1 ) ; 
 )  ;     c := c + 1 ) ; 
     return res );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void checkEVENodd(int arr[],int n,int l,int r){
    if(arr[r]==1)System.out.println("odd");
    else System.out.println("even");
  }
  public static void main(String[] args){
    int arr[]={
      1,1,0,1 };
      int n=arr.length ;
      checkEVENodd(arr,n,1,3);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkEVENodd( arr : Sequence(int), n : int, l : int, r : int) : void
  pre: true
  post: true
  activity: (     if (arr[r+1] = 1) then     OclFile["System.out"].println("odd") ; else     OclFile["System.out"].println("even") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,0,1} ;
     var n : int ; n := arr->size() ;
     execute checkEVENodd(arr, n, 1, 3) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Gfg {
  static int countDigits(int n){
    return(int)(n*Math.log10(2)+1);
  }
  public static void main(String args[]){
    int n=5 ;
    System.out.println(countDigits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Gfg {
  static   operation countDigits( n : int) : int
  pre: true
  post: true
  activity: (     return (n * (2)->log10() + 1)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(countDigits(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPerfectSquare(int N){
    double sr=Math.sqrt(N);
    return(sr-Math.floor(sr))==0 ;
  }
  static void BetrothedNumbers(int n,int m){
    int Sum1=1 ;
    int Sum2=1 ;
    for(int i=2 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        Sum1+=i+(isPerfectSquare(n)? 0 : n/i);
      }
    }
    for(int i=2 ; i<=Math.sqrt(m); i++){
      if(m % i==0){
        Sum2+=i+(isPerfectSquare(m)? 0 : m/i);
      }
    }
    if((n+1==Sum2)&&(m+1==Sum1)){
      System.out.print("YES"+"\n");
    }
    else {
      System.out.print("NO"+"\n");
    }
  }
  public static void main(String[] args){
    int N=9504 ;
    int M=20734 ;
    BetrothedNumbers(N,M);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPerfectSquare( N : int) : boolean
  pre: true
  post: true
  activity: (     var sr : double ; sr := (N)->sqrt() ;
     return (sr - (sr)->floor()) = 0 );
  static   operation BetrothedNumbers( n : int, m : int) : void
  pre: true
  post: true
  activity: (     var Sum1 : int ; Sum1 := 1 ;
     var Sum2 : int ; Sum2 := 1 ;
        var i : int ; i := 2 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     Sum1 := Sum1+(i + (if isPerfectSquare(n) then 0 else n / i endif)) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= (m)->sqrt() do ( (     if (m mod i = 0) then (     Sum2 := Sum2+(i + (if isPerfectSquare(m) then 0 else m / i endif)) ) else skip )  ;     i := i + 1 ) ; 
    if ((n + 1 = Sum2) & (m + 1 = Sum1)) then (     OclFile["System.out"].print("YES" + "\n") ) else (     OclFile["System.out"].print("NO" + "\n") ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 9504 ;
     var M : int ; M := 20734 ;
     execute BetrothedNumbers(N, M) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p214 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p214().run());
  }
  private static final int LIMIT=40000000 ;
  public String run(){
    int[] totient=Library.listTotients(LIMIT-1);
    int[] totientChainLength=new int[totient.length];
    totientChainLength[0]=0 ;
    long sum=0 ;
    for(int i=1 ; i<totient.length ; i++){
      int chainlen=totientChainLength[totient[i] ]+1 ;
      totientChainLength[i]=chainlen ;
      if(chainlen==25 && totient[i]==i-1)sum+=i ;
    }
    return Long.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
class p214 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p214.newp214().run()) );
  static    attribute LIMIT : int := 40000000;
   operation run() : String
  pre: true
  post: true
  activity: (     var totient : Sequence(int) ; totient := Library.listTotients(LIMIT - 1) ;
     var totientChainLength : Sequence(int) ; totientChainLength := Integer.subrange(1,totient->size())->collect(0) ;
    totientChainLength[0+1] := 0 ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 1 ; while i < totient->size() do ( (     var chainlen : int ; chainlen := totientChainLength[totient[i+1]+1] + 1 ;
     totientChainLength[i+1] := chainlen ; 
     if (chainlen = 25 & totient[i+1] = i - 1) then     sum := sum+(i) ; else skip )  ;     i := i + 1 ) ; 
    return ((sum) + "") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class LastMinuteEnhancements {
  public static void main(String[] args)throws Exception {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    StringTokenizer st=new StringTokenizer(in.readLine());
    int t=Integer.parseInt(st.nextToken());
    for(int i=0 ; i<t ; i++){
      StringTokenizer st1=new StringTokenizer(in.readLine());
      int n=Integer.parseInt(st1.nextToken());
      StringTokenizer st2=new StringTokenizer(in.readLine());
      int[] array=new int[n];
      for(int j=0 ; j<n ; j++){
        array[j]=Integer.parseInt(st2.nextToken());
      }
      Arrays.sort(array);
      array[n-1]++;
      int cnt=1 ;
      for(int k=n-2 ; k>=0 ; k--){
        if(array[k]+1<array[k+1]){
          cnt++;
          array[k]++;
        }
        else if(array[k]!=array[k+1]){
          cnt++;
        }
      }
      out.println(cnt);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class LastMinuteEnhancements {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(in.readLine()) ;
    var t : int ; t := (st.next())->toInteger() ;
        var i : int ; i := 0 ; while i < t do ( (     var st1 : OclIterator ; st1 := OclIterator.newOclIterator_String(in.readLine()) ;
     var n : int ; n := (st1.next())->toInteger() ;
    var st2 : OclIterator ; st2 := OclIterator.newOclIterator_String(in.readLine()) ;
    var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     array[j+1] := (st2.next())->toInteger() )  ;     j := j + 1 ) ; 
    array := array->sort() ; 
    array[n - 1+1] := array[n - 1+1] + 1 ; 
    var cnt : int ; cnt := 1 ;
        var k : int ; k := n - 2 ; while k >= 0 do ( (     if (array[k+1] + 1 < array[k + 1+1]) then (     cnt := cnt + 1 ; 
     array[k+1] := array[k+1] + 1 ) else     if (array[k+1] /= array[k + 1+1]) then (     cnt := cnt + 1 ) else skip ; )  ;     k := k - 1 ) ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Set ;
public class LastMinuteEnhancements {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(reader.readLine());
    while(t>0){
      int n=Integer.parseInt(reader.readLine());
      String[] data=reader.readLine().split("\\s+");
      int[] nums=new int[n];
      Set<Integer>set=new HashSet<>();
      for(int i=0 ; i<n ; i++){
        nums[i]=Integer.parseInt(data[i]);
        set.add(nums[i]);
      }
      Arrays.sort(nums);
      System.out.println(new LastMinuteEnhancements().maxNotes(nums,set));
      t--;
    }
  }
  private int maxNotes(int[] nums,Set<Integer>set){
    int n=nums.length ;
    for(int i=n-1 ; i>=0 ; i--){
      int temp=nums[i]+1 ;
      if(! set.contains(temp)){
        set.add(temp);
        set.remove(nums[i]);
      }
      else set.add(nums[i]);
    }
    return set.size();
  }
}
------------------------------------------------------------
OCL File:
---------
 class LastMinuteEnhancements {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (reader.readLine())->toInteger() ;
     while (t > 0) do (     var n : int ; n := (reader.readLine())->toInteger() ;
     var data : Sequence(String) ; data := reader.readLine()->split("\\s+") ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := (data[i+1])->toInteger() ; 
     set := set->including(nums[i+1]) )  ;     i := i + 1 ) ; 
    nums := nums->sort() ; 
    OclFile["System.out"].println(LastMinuteEnhancements.newLastMinuteEnhancements().maxNotes(nums, set)) ; 
    t := t - 1 ; 
 ) );
   operation maxNotes( nums : Sequence(int), set : Set(int)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := nums->size() ;
         var i : int ; i := n - 1 ; while i >= 0 do ( (     var temp : int ; temp := nums[i+1] + 1 ;
     if (not(set->includes(temp))) then (     set := set->including(temp) ; 
     set := set->excludingFirst(nums[i+1]) ) else     set := set->including(nums[i+1]) ; )  ;     i := i - 1 ) ; 
     return set->size() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    while(t-->0){
      int n=Integer.parseInt(br.readLine());
      String[] str=br.readLine().split(" ");
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=Integer.parseInt(str[i]);
      }
      HashSet<Integer>set=new HashSet<>();
      for(int i=0 ; i<n ; i++){
        int num=arr[i];
        if(set.contains(num)){
          set.add(num+1);
        }
        else {
          set.add(num);
        }
      }
      System.out.println(set.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (str[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := arr[i+1] ;
     if (set->includes(num)) then (     set := set->including(num + 1) ) else (     set := set->including(num) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(set->size()) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      int answer=0 ;
      int last=0 ;
      for(int n=0 ; n<N ; n++){
        int x=in.nextInt();
        if(last<x){
          last=x ;
          answer++;
        }
        else if(last==x){
          last=x+1 ;
          answer++;
        }
      }
      pw.println(answer);
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var answer : int ; answer := 0 ;
    var last : int ; last := 0 ;
        var n : int ; n := 0 ; while n < N do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     if (last < x) then (     last := x ; 
     answer := answer + 1 ) else     if (last = x) then (     last := x + 1 ; 
     answer := answer + 1 ) else skip ; )  ;     n := n + 1 ) ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static void solve(int n){
    int[][] jpeg=new int[n][n];
    int x=0 ;
    int y=0 ;
    boolean ascending=true ;
    for(int i=1 ; i<=n*n ; i++){
      jpeg[x][y]=i ;
      if(ascending && y==0 && x!=n-1){
        x+=1 ;
        ascending=false ;
      }
      else if((! ascending)&& x==0 && y!=n-1){
        y+=1 ;
        ascending=true ;
      }
      else if(ascending && x==n-1){
        y+=1 ;
        ascending=false ;
      }
      else if((! ascending)&& y==n-1){
        x+=1 ;
        ascending=true ;
      }
      else if(ascending){
        x+=1 ;
        y-=1 ;
      }
      else {
        x-=1 ;
        y+=1 ;
      }
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        System.out.printf("%3d",jpeg[j][i]);
      }
      System.out.println("");
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int times=1 ;
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      System.out.printf("Case %d:\n",times);
      solve(n);
      times+=1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( n : int) : void
  pre: true
  post: true
  activity: (     var jpeg : Sequence(Sequence(int)) ; jpeg := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
     var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var ascending : boolean ; ascending := true ;
        var i : int ; i := 1 ; while i <= n * n do ( (     jpeg[x+1][y+1] := i ; 
     if (ascending & y = 0 & x /= n - 1) then (     x := x+(1) ; 
     ascending := false ) else     if ((not(ascending)) & x = 0 & y /= n - 1) then (     y := y+(1) ; 
     ascending := true ) else     if (ascending & x = n - 1) then (     y := y+(1) ; 
     ascending := false ) else     if ((not(ascending)) & y = n - 1) then (     x := x+(1) ; 
     ascending := true ) else     if (ascending) then (     x := x+(1) ; 
     y := y-(1) ) else (     x := x-(1) ; 
     y := y+(1) ) ;  ;  ;  ;  )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     OclFile["System.out"].printf("%3d", jpeg[j+1][i+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var times : int ; times := 1 ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    OclFile["System.out"].printf("Case %d:\n", times) ; 
    execute solve(n) ; 
    times := times+(1) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static int C=1 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    for(int n=sc.nextInt(); n!=0 ; n=sc.nextInt())solve(n);
  }
  private static void solve(int n){
    int[][] ns=new int[n][n];
    int inc=1 ;
    for(int i=0 ; i<n ; i++){
      if(i % 2==0){
        for(int j=i ; j>=0 ; j--){
          ns[j][i-j]=inc++;
        }
      }
      else {
        for(int j=0 ; j<=i ; j++){
          ns[j][i-j]=inc++;
        }
      }
    }
    for(int i=n ; i<2*(n-1)+1 ; i++){
      if(i % 2==1){
        for(int j=i-n+1 ; j<n ; j++){
          ns[j][i-j]=inc++;
        }
      }
      else {
        for(int j=n-1 ; j>=i-n+1 ; j--){
          ns[j][i-j]=inc++;
        }
      }
    }
    System.out.printf("Case %d:\n",C++);
    for(int[] as : ns){
      for(int a : as){
        System.out.printf("%3d",a);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute C : int := 1;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var n : int ; n := sc.getCurrent()->toInteger() ; while n /= 0 do (     execute solve(n) ;  ;     n := sc.getCurrent()->toInteger() ) );
  static   operation solve( n : int) : void
  pre: true
  post: true
  activity: (     var ns : Sequence(Sequence(int)) ; ns := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
     var inc : int ; inc := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then (         var j : int ; j := i ; while j >= 0 do ( (      ns[j+1][i - j+1] := inc  ; inc := inc + 1 )  ;     j := j - 1 ) ) else (         var j : int ; j := 0 ; while j <= i do ( (      ns[j+1][i - j+1] := inc  ; inc := inc + 1 )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := n ; while i < 2 * (n - 1) + 1 do ( (     if (i mod 2 = 1) then (         var j : int ; j := i - n + 1 ; while j < n do ( (      ns[j+1][i - j+1] := inc  ; inc := inc + 1 )  ;     j := j + 1 ) ) else (         var j : int ; j := n - 1 ; while j >= i - n + 1 do ( (      ns[j+1][i - j+1] := inc  ; inc := inc + 1 )  ;     j := j - 1 ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("Case %d:\n", C) ; 
    for (as : ns) do ( (     for (a : as) do ( (     OclFile["System.out"].printf("%3d", a) )  ) ; 
     OclFile["System.out"].println() )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static final Integer END_FLAG=Integer.valueOf(0);
  static Scanner in=new Scanner(System.in);
  static Integer nextValue ;
  public static void main(String[] args){
    int caseNum=0 ;
    do {
      int n=(nextValue!=null)? nextValue : in.nextInt();
      printCase(++caseNum);
      int[][] jpeg=new int[n][n];
      int x=0 ;
      final int lastX=n*n ;
      final int lastIndex=n-1 ;
      int column=0,row=0 ;
      int nextStartColumn=0,nextStartRow=0,d=1 ;
      while(x<lastX){
        column=nextStartColumn ;
        row=nextStartRow ;
        while(0<=column && column<n && 0<=row && row<n){
          jpeg[column][row]=++x ;
          nextStartColumn=column ;
          nextStartRow=row ;
          column-=d ;
          row+=d ;
        }
        if(nextStartColumn==lastIndex ||(nextStartColumn==0 && nextStartRow!=lastIndex)){
          nextStartRow++;
        }
        else if(nextStartRow==lastIndex ||(nextStartRow==0 && nextStartColumn!=lastIndex)){
          nextStartColumn++;
        }
        d=-d ;
      }
      for(column=0 ; column<n ; column++){
        for(row=0 ; row<n ; row++){
          System.out.printf("%3d",jpeg[column][row]);
          if(row==lastIndex){
            System.out.println();
          }
        }
      }
      nextValue=Integer.valueOf(in.next());
    }
    while(! nextValue.equals(END_FLAG));
  }
  private static void printCase(int caseNum){
    System.out.print("Case ");
    System.out.print(caseNum);
    System.out.println(':');
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute END_FLAG : int := (0)->toInteger();
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute nextValue : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var caseNum : int ; caseNum := 0 ;
   while true do ((     var n : int ; n := if (nextValue /= null) then nextValue else in.getCurrent()->toInteger() endif ;
     execute printCase((caseNum + 1)) ; 
    var jpeg : Sequence(Sequence(int)) ; jpeg := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var x : int ; x := 0 ;
    var lastX : int ; lastX := n * n ;
    var lastIndex : int ; lastIndex := n - 1 ;
    var column : int ; column := 0 ;
    var row : int ; row := 0 ;
    var nextStartColumn : int ; nextStartColumn := 0 ;
    var nextStartRow : int ; nextStartRow := 0 ;
    var d : int ; d := 1 ;
    while (x < lastX) do (     column := nextStartColumn ; 
     row := nextStartRow ; 
    while (0 <= column & column < n & 0 <= row & row < n) do (         x := x + 1 ;
 jpeg[column+1][row+1] := x  ; 
     nextStartColumn := column ; 
    nextStartRow := row ; 
    column := column-(d) ; 
    row := row+(d) ; 
 ) ; 
    if (nextStartColumn = lastIndex or (nextStartColumn = 0 & nextStartRow /= lastIndex)) then (     nextStartRow := nextStartRow + 1 ) else     if (nextStartRow = lastIndex or (nextStartRow = 0 & nextStartColumn /= lastIndex)) then (     nextStartColumn := nextStartColumn + 1 ) else skip ; ;  
    d := -d ; 
 ) ; 
        column := 0 ; while column < n do ( (         row := 0 ; while row < n do ( (     OclFile["System.out"].printf("%3d", jpeg[column+1][row+1]) ; 
     if (row = lastIndex) then (     OclFile["System.out"].println() ) else skip )  ;     row := row + 1 ) )  ;     column := column + 1 ) ; 
    nextValue := (in.getCurrent())->toInteger() ; 
 ) ;
    if (not(nextValue = END_FLAG)) then skip else break) );
  static   operation printCase( caseNum : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("Case ") ; 
     OclFile["System.out"].print(caseNum) ; 
     OclFile["System.out"].println(':') );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemB {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=scn.nextInt();
    }
    int ans=arr[0]+1 ;
    for(int i=1 ; i<arr.length ; i++){
      ans+=Math.abs(arr[i]-arr[i-1])+2 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := scn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := arr[0+1] + 1 ;
        var i : int ; i := 1 ; while i < arr->size() do ( (     ans := ans+(if arr[i+1] - arr[i - 1+1] < 0 then -(arr[i+1] - arr[i - 1+1]) else arr[i+1] - arr[i - 1+1] endif + 2) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String str=br.readLine();
      String[] split=str.split(" ",0);
      int w=Integer.parseInt(split[0]);
      int h=Integer.parseInt(split[1]);
      int x=Integer.parseInt(split[2]);
      int y=Integer.parseInt(split[3]);
      int r=Integer.parseInt(split[4]);
      if((x-r>=0)&&(x+r<=w)&&(y-r>=0)&&(y+r<=h)){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
    catch(Exception e){
      System.out.println("??¨??????");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var str : String ; str := br.readLine() ;
     var split : Sequence(String) ; split := str->split(" ") ;
    var w : int ; w := (split[0+1])->toInteger() ;
    var h : int ; h := (split[1+1])->toInteger() ;
    var x : int ; x := (split[2+1])->toInteger() ;
    var y : int ; y := (split[3+1])->toInteger() ;
    var r : int ; r := (split[4+1])->toInteger() ;
    if ((x - r >= 0) & (x + r <= w) & (y - r >= 0) & (y + r <= h)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 )   catch (e : ProgramException) do (     OclFile["System.out"].println("??�??????") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      int[] s=IntStream.range(0,n).map(i->scanner.nextInt()).toArray();
      long max=0L ;
      for(int c=1 ; c<n-1 ; c++){
        Set<Integer>set=new HashSet<>();
        long sum=0L ;
        for(int k=1 ; k*c<n-1 ; k++){
          if((n-1-c*k<=c)|| set.contains(n-1-k*c)|| set.contains(k*c)|| n-1-k*c==k*c){
            break ;
          }
          sum=sum+s[n-1-k*c]+s[k*c];
          max=Math.max(max,sum);
          set.add(n-1-k*c);
          set.add(k*c);
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var s : Sequence(int) ; s := Integer.subrange(0, n-1)->collect( _x1 | (lambda i : OclAny in scanner.getCurrent()->toInteger())->apply(_x1) )->asSequence() ;
    var max : long ; max := 0L ;
        var c : int ; c := 1 ; while c < n - 1 do ( (     var set : Set(int) ; set := Set{} ;
     var sum : long ; sum := 0L ;
         var k : int ; k := 1 ; while k * c < n - 1 do ( (     if ((n - 1 - c * k <= c) or set->includes(n - 1 - k * c) or set->includes(k * c) or n - 1 - k * c = k * c) then (     break ) else skip ; 
     sum := sum + s[n - 1 - k * c+1] + s[k * c+1] ; 
    max := Set{max, sum}->max() ; 
    set := set->including(n - 1 - k * c) ; 
    set := set->including(k * c) ; 
 )  ;     k := k + 1 ) )  ;     c := c + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.util.Arrays.*;
import static java.lang.Math.*;
public class Main {
  static int tc ;
  public static void main(String[] args){
    for(tc=1 ; read(); tc++){
      solve();
    }
  }
  static int N ;
  static Scanner sc=new Scanner(System.in);
  static boolean read(){
    N=sc.nextInt();
    if(N==0)return false ;
    return true ;
  }
  static void solve(){
    int val=1 ;
    int[][] jpeg=new int[100][100];
    jpeg[0][0]=val++;
    int m=0,x=1,y=0 ;
    for(int i=1 ; i<N*2 ; i++){
      if(i<N-1){
        if(i % 2==0){
          for(; y>=0 ; x++,y--){
            jpeg[y][x]=val++;
          }
        }
        else {
          for(; x>=0 ; x--,y++){
            jpeg[y][x]=val++;
          }
        }
      }
      else {
        if(i % 2==0){
          for(; x<N ; x++,y--){
            jpeg[y][x]=val++;
          }
        }
        else {
          for(; y<N ; x--,y++){
            jpeg[y][x]=val++;
          }
        }
      }
      if(i<N-1){
        if(i % 2==0){
          y++;
        }
        else {
          x++;
        }
      }
      else {
        if(i % 2==0){
          x--;
          y+=2 ;
        }
        else {
          x+=2 ;
          y--;
        }
      }
    }
    System.out.println("Case "+tc+":");
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        System.out.printf("%3d",jpeg[i][j]);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute tc : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         tc := 1 ; while read() do ( (     execute solve() )  ;     tc := tc + 1 ) );
  static   attribute N : int;
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     if (N = 0) then     return false else skip ; 
     return true );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var val : int ; val := 1 ;
     var jpeg : Sequence(Sequence(int)) ; jpeg := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(0)) ;
     jpeg[0+1][0+1] := val  ; val := val + 1 ; 
    var m : int ; m := 0 ;
    var x : int ; x := 1 ;
    var y : int ; y := 0 ;
        var i : int ; i := 1 ; while i < N * 2 do ( (     if (i < N - 1) then (     if (i mod 2 = 0) then (       while y >= 0 do ( (      jpeg[y+1][x+1] := val  ; val := val + 1 )  ;     x := x + 1 ;     y := y - 1 ) ) else (       while x >= 0 do ( (      jpeg[y+1][x+1] := val  ; val := val + 1 )  ;     x := x - 1 ;     y := y + 1 ) ) ) else (     if (i mod 2 = 0) then (       while x < N do ( (      jpeg[y+1][x+1] := val  ; val := val + 1 )  ;     x := x + 1 ;     y := y - 1 ) ) else (       while y < N do ( (      jpeg[y+1][x+1] := val  ; val := val + 1 )  ;     x := x - 1 ;     y := y + 1 ) ) ) ;  
     if (i < N - 1) then (     if (i mod 2 = 0) then (     y := y + 1 ) else (     x := x + 1 ) ) else (     if (i mod 2 = 0) then (     x := x - 1 ; 
     y := y+(2) ) else (     x := x+(2) ; 
     y := y - 1 ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Case " + tc + ":") ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     OclFile["System.out"].printf("%3d", jpeg[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int input=Integer.parseInt(reader.readLine());
    int cases=1 ;
    while(input>0){
      int[][] arr=new int[input][input];
      int x=0,y=0 ;
      int count=1 ;
      boolean mode=false ;
      while(x<input && y<input){
        arr[x][y]=count ;
        if(mode){
          x--;
          y++;
        }
        else {
          y--;
          x++;
        }
        if(x>=input){
          x--;
          y++;
          y++;
          mode=! mode ;
        }
        else if(y>=input){
          y--;
          x++;
          x++;
          mode=! mode ;
        }
        if(x<0){
          x++;
          mode=! mode ;
        }
        else if(y<0){
          y++;
          mode=! mode ;
        }
        count++;
      }
      sb.append("Case "+cases+":\n");
      for(int i=0 ; i<input ; i++){
        for(int j=0 ; j<input ; j++){
          sb.append(String.format("%3d",arr[j][i]));
        }
        sb.append("\n");
      }
      input=Integer.parseInt(reader.readLine());
      cases++;
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var input : int ; input := (reader.readLine())->toInteger() ;
    var cases : int ; cases := 1 ;
    while (input > 0) do (     var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,input)->collect(Integer.subrange(1,input)->collect(0)) ;
     var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var count : int ; count := 1 ;
    var mode : boolean ; mode := false ;
    while (x < input & y < input) do (     arr[x+1][y+1] := count ; 
     if (mode) then (     x := x - 1 ; 
     y := y + 1 ) else (     y := y - 1 ; 
     x := x + 1 ) ;  
    if (x >= input) then (     x := x - 1 ; 
     y := y + 1 ; 
     y := y + 1 ; 
     mode := not(mode) ) else     if (y >= input) then (     y := y - 1 ; 
     x := x + 1 ; 
     x := x + 1 ; 
     mode := not(mode) ) else skip ; ;  
    if (x < 0) then (     x := x + 1 ; 
     mode := not(mode) ) else     if (y < 0) then (     y := y + 1 ; 
     mode := not(mode) ) else skip ; ;  
    count := count + 1 ; 
 ) ; 
    sb := sb + StringLib.newString("Case " + cases + ":\n") ; 
        var i : int ; i := 0 ; while i < input do ( (         var j : int ; j := 0 ; while j < input do ( (     sb := sb + StringLib.newString(StringLib.format("%3d",Sequence{arr[j+1][i+1]})) )  ;     j := j + 1 ) ; 
     sb := sb + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    input := (reader.readLine())->toInteger() ; 
    cases := cases + 1 ; 
 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class circle {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,i,r,s ;
    long a[];
    n=sc.nextInt();
    a=new long[n];
    PriorityQueue<Long>pq=new PriorityQueue<>(Collections.reverseOrder());
    for(i=0 ; i<n ; i++)pq.add(sc.nextLong());
    r=0 ;
    s=n-1 ;
    i=1 ;
    while(r<=s && pq.size()>0){
      if(i % 2==1)a[s--]=pq.poll();
      else a[r++]=pq.poll();
      i++;
    }
    for(i=0 ; i<n ; i++){
      if(i==0){
        if(a[0]>=a[1]+a[n-1])break ;
      }
      else if(i==n-1){
        if(a[n-1]>=a[0]+a[n-2])break ;
      }
      else if(a[i]>=a[i-1]+a[i+1])break ;
    }
    if(i!=n)System.out.println("NO");
    else {
      System.out.println("YES");
      for(i=0 ; i<n ; i++)System.out.print(a[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class circle {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var i : int ;
    var r : int ;
    var s : int ;
    var a : Sequence(long) ;
    n := sc.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
    var pq : Sequence(long) ; pq := Sequence{}->union(reverseOrder()) ;
        i := 0 ; while i < n do (     pq := pq->including(sc.getCurrent()->toLong()) ;  ;     i := i + 1 ) ; 
    r := 0 ; 
    s := n - 1 ; 
    i := 1 ; 
    while (r <= s & pq->size() > 0) do (     if (i mod 2 = 1) then     a[s+1] := pq->min() ;     pq := pq->sort()->tail() else     a[r+1] := pq->min() ;     pq := pq->sort()->tail() ; ;  
     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     if (i = 0) then (     if (a[0+1] >= a[1+1] + a[n - 1+1]) then     break else skip ) else     if (i = n - 1) then (     if (a[n - 1+1] >= a[0+1] + a[n - 2+1]) then     break else skip ) else     if (a[i+1] >= a[i - 1+1] + a[i + 1+1]) then     break else skip ; ;  )  ;     i := i + 1 ) ; 
    if (i /= n) then     OclFile["System.out"].println("NO") else (     OclFile["System.out"].println("YES") ; 
         i := 0 ; while i < n do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class circle {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,i,r,s ;
    long a[];
    n=sc.nextInt();
    a=new long[n];
    PriorityQueue<Long>pq=new PriorityQueue<>(Collections.reverseOrder());
    for(i=0 ; i<n ; i++)pq.add(sc.nextLong());
    r=0 ;
    s=n-1 ;
    i=1 ;
    while(r<=s && pq.size()>0){
      if(i % 2==1)a[s--]=pq.poll();
      else a[r++]=pq.poll();
      i++;
    }
    for(i=0 ; i<n ; i++){
      if(i==0){
        if(a[0]>=a[1]+a[n-1])break ;
      }
      else if(i==n-1){
        if(a[n-1]>=a[0]+a[n-2])break ;
      }
      else if(a[i]>=a[i-1]+a[i+1])break ;
    }
    if(i!=n)System.out.println("NO");
    else {
      System.out.println("YES");
      for(i=0 ; i<n ; i++)System.out.print(a[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class circle {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var i : int ;
    var r : int ;
    var s : int ;
    var a : Sequence(long) ;
    n := sc.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
    var pq : Sequence(long) ; pq := Sequence{}->union(reverseOrder()) ;
        i := 0 ; while i < n do (     pq := pq->including(sc.getCurrent()->toLong()) ;  ;     i := i + 1 ) ; 
    r := 0 ; 
    s := n - 1 ; 
    i := 1 ; 
    while (r <= s & pq->size() > 0) do (     if (i mod 2 = 1) then     a[s+1] := pq->min() ;     pq := pq->sort()->tail() else     a[r+1] := pq->min() ;     pq := pq->sort()->tail() ; ;  
     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     if (i = 0) then (     if (a[0+1] >= a[1+1] + a[n - 1+1]) then     break else skip ) else     if (i = n - 1) then (     if (a[n - 1+1] >= a[0+1] + a[n - 2+1]) then     break else skip ) else     if (a[i+1] >= a[i - 1+1] + a[i + 1+1]) then     break else skip ; ;  )  ;     i := i + 1 ) ; 
    if (i /= n) then     OclFile["System.out"].println("NO") else (     OclFile["System.out"].println("YES") ; 
         i := 0 ; while i < n do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int XorSum(int arr[],int n){
    int result=0 ;
    for(int i=0 ; i<n ; i++){
      int k=0 ;
      for(int j=1 ; j<=arr[i]; j++)k ^=arr[i];
      result+=k ;
    }
    return result ;
  }
  public static void main(String args[]){
    int arr[]={
      1,2,6,3,4,5 };
      int n=arr.length ;
      System.out.println(XorSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation XorSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var k : int ; k := 0 ;
         var j : int ; j := 1 ; while j <= arr[i+1] do (     k := MathLib.bitwiseXor(k,arr[i+1]) ;  ;     j := j + 1 ) ; 
     result := result+(k) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,6,3,4,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(XorSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findGreatest(int[] arr,int n){
    int result=-1 ;
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n-1 ; j++)for(int k=j+1 ; k<n ; k++)if(arr[j]*arr[k]==arr[i])result=Math.max(result,arr[i]);
    return result ;
  }
  static public void main(String[] args){
    int[] arr={
      30,10,9,3,35 };
      int n=arr.length ;
      System.out.println(findGreatest(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findGreatest( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := -1 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n - 1 do (         var k : int ; k := j + 1 ; while k < n do (     if (arr[j+1] * arr[k+1] = arr[i+1]) then     result := Set{result, arr[i+1]}->max() ; else skip ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return result );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{30,10,9,3,35} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findGreatest(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public final class cp {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    void close()throws IOException {
      br.close();
    }
  }
  public static void main(String[] args)throws IOException {
    FastReader r=new FastReader();
    PrintWriter w=new PrintWriter(System.out,true);
    int n=r.nextInt();
    String str=r.next();
    int max,j ;
    String res="" ;
    int[] freq ;
    boolean flag=false ;
    for(int i=0 ; i<n ; i++){
      max=Integer.MIN_VALUE ;
      freq=new int[26];
      for(j=i ; j<n ; j++){
        int val=str.charAt(j)-'a' ;
        freq[val]++;
        if(freq[val]>max){
          max=freq[val];
        }
        if(max<=(j-i+1)>>1){
          res=str.substring(i,j+1);
          flag=true ;
          break ;
        }
      }
      if(flag)break ;
    }
    w.println((res.equals("")? "NO" : "YES\n"+res));
    r.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : FastReader ; r := FastReader.newFastReader() ;
     var w : OclFile ; w := OclFile.newOclFile_Write(OclFile["System.out"], true) ;
    var n : int ; n := r.nextInt() ;
    var str : String ; str := r.next() ;
    var max : int ;
    var j : int ;
    var res : String ; res := "" ;
    var freq : Sequence(int) ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < n do ( (     max := -2147483648 ; 
     freq := Integer.subrange(1,26)->collect(0) ; 
         j := i ; while j < n do ( (     var val : int ; val := str->at(j+1) - ('a')->char2byte() ;
     freq[val+1] := freq[val+1] + 1 ; 
     if (freq[val+1] > max) then (     max := freq[val+1] ) else skip ; 
     if (max <= (((j)->char2byte() - i + 1)/(2->pow(1)))->oclAsType(long)) then (     res := str.subrange(i+1,j + 1) ; 
     flag := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (flag) then     break else skip )  ;     i := i + 1 ) ; 
    skip ; 
    r.close() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    String s=sc.next();
    int flag=0 ;
    String ans="" ;
    for(int i=0 ; i<s.length()-1 ; i++){
      if(s.charAt(i)!=s.charAt(i+1)){
        flag=1 ;
        ans+=s.charAt(i);
        ans+=s.charAt(i+1);
        break ;
      }
    }
    if(flag==0){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var flag : int ; flag := 0 ;
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < s->size() - 1 do ( (     if (s->at(i+1) /= s->at(i + 1+1)) then (     flag := 1 ; 
     ans := ans+(s->at(i+1)) ; 
     ans := ans+(s->at(i + 1+1)) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 0) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(ans) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sc.nextInt();
    String s=sc.next();
    System.out.println(solve(s));
    sc.close();
  }
  static String solve(String s){
    for(int i=0 ; i<s.length()-1 ; i++){
      if(s.charAt(i)!=s.charAt(i+1)){
        return String.format("YES\n%s",s.substring(i,i+2));
      }
    }
    return "NO" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var s : String ; s := sc.getCurrent() ;
    OclFile["System.out"].println(solve(s)) ; 
    skip ; 
 );
  static   operation solve( s : String) : String
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() - 1 do ( (     if (s->at(i+1) /= s->at(i + 1+1)) then (     return StringLib.format("YES\n%s",Sequence{s.subrange(i+1,i + 2)}) ) else skip )  ;     i := i + 1 ) ; 
     return "NO" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.math.BigInteger ;
import java.time.chrono.MinguoChronology ;
public class Main {
  static InputReader in ;
  static PrintWriter out ;
  static class Solution {
    void solve()throws IOException {
      int W=in.nextInt();
      int H=in.nextInt();
      int x=in.nextInt();
      int y=in.nextInt();
      int r=in.nextInt();
      if(x<r || y<r || y>H-r || x>W-r){
        out.println("No");
      }
      else {
        out.println("Yes");
      }
    }
  }
  public static void main(String[] args)throws IOException {
    in=new InputReader(System.in);
    out=new PrintWriter(System.out);
    Solution solver=new Solution();
    solver.solve();
    out.close();
  }
  static class InputReader {
    public BufferedReader br ;
    public StringTokenizer st ;
    public InputReader(InputStream stream){
      br=new BufferedReader(new InputStreamReader(stream));
    }
    public int nextInt()throws IOException {
      while(st==null || ! st.hasMoreTokens()){
        st=new StringTokenizer(br.readLine());
      }
      return Integer.parseInt(st.nextToken());
    }
    public long nextLong()throws IOException {
      while(st==null || ! st.hasMoreTokens()){
        st=new StringTokenizer(br.readLine());
      }
      return Long.parseLong(st.nextToken());
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens()){
        st=new StringTokenizer(br.readLine());
      }
      return st.nextToken();
    }
    public double nextDouble()throws IOException {
      while(st==null || ! st.hasMoreTokens()){
        st=new StringTokenizer(br.readLine());
      }
      return Double.parseDouble(st.nextToken());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : InputReader;
  static   attribute out : OclFile;
  static class Solution {
   operation solve() : void
  pre: true
  post: true
  activity: (     var W : int ; W := in.nextInt() ;
     var H : int ; H := in.nextInt() ;
    var x : int ; x := in.nextInt() ;
    var y : int ; y := in.nextInt() ;
    var r : int ; r := in.nextInt() ;
    if (x < r or y < r or y > H - r or x > W - r) then (     skip ) else (     skip ) ;  
 );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := InputReader.newInputReader(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    var solver : Solution ; solver := Solution.newSolution() ;
    solver.solve() ; 
    skip ; 
 );
  static class InputReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return (st.next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return (st.next())->toLong() );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return (st.next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.max ;
import static java.lang.Math.min ;
public class Codeforces {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      this.br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(this.st==null || ! this.st.hasMoreElements()){
        try {
          this.st=new StringTokenizer(this.br.readLine());
        }
        catch(IOException var2){
          var2.printStackTrace();
        }
      }
      return this.st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(this.next());
    }
    long nextLong(){
      return Long.parseLong(this.next());
    }
    double nextDouble(){
      return Double.parseDouble(this.next());
    }
    String nextLine(){
      String var1="" ;
      try {
        if(this.st.hasMoreTokens()){
          var1=this.st.nextToken("\n");
        }
        else {
          var1=this.br.readLine();
        }
      }
      catch(IOException var3){
        var3.printStackTrace();
      }
      return var1 ;
    }
  }
  public static void main(String[] args)throws Exception {
    solve();
  }
  public static void solve(){
    FastReader in=new FastReader();
    int n=in.nextInt();
    String s=in.next();
    boolean f=true ;
    for(int i=1 ; i<n ; i++){
      if(s.charAt(i-1)!=s.charAt(i)){
        System.out.println("YES");
        System.out.println(""+s.charAt(i-1)+s.charAt(i));
        f=false ;
        break ;
      }
    }
    if(f)System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (self.st = null or not(self.st.hasNext())) do (     try (     self.st := OclIterator.newOclIterator_String(self.br.readLine()) )   catch (var2 : IOException) do (     var2.printStackTrace() )
 ) ; 
     return self.st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (self.next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (self.next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (self.next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var var1 : String ; var1 := "" ;
     try (     if (self.st.hasNext()) then (     var1 := self.st.nextToken("\n") ) else (     var1 := self.br.readLine() ) )   catch (var3 : IOException) do (     var3.printStackTrace() )
     return var1 );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var n : int ; n := in.nextInt() ;
    var s : String ; s := in.next() ;
    var f : boolean ; f := true ;
        var i : int ; i := 1 ; while i < n do ( (     if (s->at(i - 1+1) /= s->at(i+1)) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println("" + s->at(i - 1+1) + s->at(i+1)) ; 
     f := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (f) then     OclFile["System.out"].println("NO") ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    ArrayList<Integer>s=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      s.add(sc.nextInt());
    }
    long score=0 ;
    for(int c=1 ; c<=N-1 ; c++){
      long tmp=0 ;
      Set<Integer>t=new HashSet<Integer>();
      for(int k=0 ; k*c<N-1 ; k++){
        if((N-1)-k*c<=c)break ;
        if(t.contains(k*c))break ;
        tmp+=s.get(k*c);
        t.add(k*c);
        if(t.contains((N-1)-k*c))break ;
        tmp+=s.get((N-1)-k*c);
        t.add((N-1)-k*c);
        score=Math.max(score,tmp);
      }
    }
    System.out.println(score);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var s : Sequence(int) ; s := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     s := s->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var score : long ; score := 0 ;
        var c : int ; c := 1 ; while c <= N - 1 do ( (     var tmp : long ; tmp := 0 ;
     var t : Set(int) ; t := Set{} ;
         var k : int ; k := 0 ; while k * c < N - 1 do ( (     if ((N - 1) - k * c <= c) then     break else skip ; 
     if (t->includes(k * c)) then     break else skip ; 
    tmp := tmp+(s->at(k * c+1)) ; 
    t := t->including(k * c) ; 
    if (t->includes((N - 1) - k * c)) then     break else skip ; 
    tmp := tmp+(s->at((N - 1) - k * c+1)) ; 
    t := t->including((N - 1) - k * c) ; 
    score := Set{score, tmp}->max() ; 
 )  ;     k := k + 1 ) )  ;     c := c + 1 ) ; 
    OclFile["System.out"].println(score) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static final int MAX=256 ;
  static boolean compare(char arr1[],char arr2[]){
    for(int i=0 ; i<MAX ; i++)if(arr1[i]!=arr2[i])return false ;
    return true ;
  }
  static void search(String pat,String txt){
    int M=pat.length();
    int N=txt.length();
    char[] countP=new char[MAX];
    char[] countTW=new char[MAX];
    for(int i=0 ; i<M ; i++){
(countP[pat.charAt(i)])++;
(countTW[txt.charAt(i)])++;
    }
    for(int i=M ; i<N ; i++){
      if(compare(countP,countTW))System.out.println("Found at Index "+(i-M));
(countTW[txt.charAt(i)])++;
      countTW[txt.charAt(i-M)]--;
    }
    if(compare(countP,countTW))System.out.println("Found at Index "+(N-M));
  }
  public static void main(String args[]){
    String txt="BACDGABCDA" ;
    String pat="ABCD" ;
    search(pat,txt);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 256;
  static   operation compare( arr1 : Sequence(String), arr2 : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < MAX do (     if (arr1[i+1] /= arr2[i+1]) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation search( pat : String, txt : String) : void
  pre: true
  post: true
  activity: (     var M : int ; M := pat->size() ;
     var N : int ; N := txt->size() ;
    var countP : Sequence(String) ; countP := Integer.subrange(1,MAX)->collect(0) ;
    var countTW : Sequence(String) ; countTW := Integer.subrange(1,MAX)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     (countP[pat->at(i+1)+1]) := (countP[pat->at(i+1)+1]) + 1 ; 
     (countTW[txt->at(i+1)+1]) := (countTW[txt->at(i+1)+1]) + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := M ; while i < N do ( (     if (compare(countP, countTW)) then     OclFile["System.out"].println("Found at Index " + (i - M)) ; else skip ; 
     (countTW[txt->at(i+1)+1]) := (countTW[txt->at(i+1)+1]) + 1 ; 
     countTW[txt->at(i - M+1)+1] := countTW[txt->at(i - M+1)+1] - 1 )  ;     i := i + 1 ) ; 
    if (compare(countP, countTW)) then     OclFile["System.out"].println("Found at Index " + (N - M)) ; else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var txt : String ; txt := "BACDGABCDA" ;
     var pat : String ; pat := "ABCD" ;
     execute search(pat, txt) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int MOD=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    long xSum=0 ;
    long ySum=0 ;
    for(int i=0 ; i<n ; i++){
      xSum=(xSum+(2*i-n+1)*sc.nextLong())% MOD ;
    }
    for(int i=0 ; i<m ; i++){
      ySum=(ySum+(2*i-m+1)*sc.nextLong())% MOD ;
    }
    System.out.println((((xSum*ySum)% MOD)+MOD)% MOD);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var xSum : long ; xSum := 0 ;
    var ySum : long ; ySum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     xSum := (xSum + (2 * i - n + 1) * sc.getCurrent()->toLong()) mod MOD )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     ySum := (ySum + (2 * i - m + 1) * sc.getCurrent()->toLong()) mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((((xSum * ySum) mod MOD) + MOD) mod MOD) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  static Scanner scanner=new Scanner();
  static long mod=1000000007 ;
  public static void main(String[] $){
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    long[] x=new long[n];
    long[] y=new long[m];
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      x[i]=scanner.nextInt();
      if(i>0){
        x[i]-=sum ;
      }
      sum+=x[i];
    }
    sum=0 ;
    for(int i=0 ; i<m ; i++){
      y[i]=scanner.nextInt();
      if(i>0){
        y[i]-=sum ;
      }
      sum+=y[i];
    }
    long c=0 ;
    for(int i=1 ; i<m ; i++){
      c=(c+y[i]*i % mod*(m-i)% mod)% mod ;
    }
    long ans=0 ;
    for(int i=1 ; i<n ; i++){
      ans=(ans+c*x[i] % mod*i % mod*(n-i)% mod)% mod ;
    }
    System.out.println(ans);
  }
  static class Scanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),32768);
    StringTokenizer tokenizer ;
    String next(){
      try {
        while(tokenizer==null || ! tokenizer.hasMoreTokens()){
          tokenizer=new StringTokenizer(reader.readLine());
        }
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := (arguments ( ));
  static   attribute mod : long := 1000000007;
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
    var x : Sequence(long) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(long) ; y := Integer.subrange(1,m)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := scanner.getCurrent()->toInteger() ; 
     if (i > 0) then (     x[i+1] := x[i+1]-(sum) ) else skip ; 
     sum := sum+(x[i+1]) )  ;     i := i + 1 ) ; 
    sum := 0 ; 
        var i : int ; i := 0 ; while i < m do ( (     y[i+1] := scanner.getCurrent()->toInteger() ; 
     if (i > 0) then (     y[i+1] := y[i+1]-(sum) ) else skip ; 
     sum := sum+(y[i+1]) )  ;     i := i + 1 ) ; 
    var c : long ; c := 0 ;
        var i : int ; i := 1 ; while i < m do ( (     c := (c + y[i+1] * i mod mod * (m - i) mod mod) mod mod )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     ans := (ans + c * x[i+1] mod mod * i mod mod * (n - i) mod mod) mod mod )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class Scanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 32768);
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (e : IOException) do (     error ProgramException(e) )
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public final class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int m=s.nextInt();
    long mod=1000000000+7 ;
    long[] x=new long[n];
    for(int i=0 ; i<n ; i++){
      x[i]=s.nextInt();
    }
    long[] y=new long[m];
    for(int i=0 ; i<m ; i++){
      y[i]=s.nextInt();
    }
    long sum_interval=0 ;
    long before_inteval=0 ;
    for(int i=1 ; i<m ; i++){
      long interval=y[i]-y[i-1];
      long now=before_inteval+(interval*i)% mod ;
      before_inteval=now ;
      sum_interval+=now ;
    }
    sum_interval=sum_interval % mod ;
    long result=0 ;
    long before_sum=0 ;
    for(int i=1 ; i<n ; i++){
      long x1=x[i];
      long x2=x[i-1];
      long xint=x1-x2 ;
      long now=xint*sum_interval ;
      long r=(now % mod*i)% mod+before_sum ;
      before_sum=r ;
      result+=r ;
    }
    System.out.print(result % mod);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var m : int ; m := s.getCurrent()->toInteger() ;
    var mod : long ; mod := 1000000000 + 7 ;
    var x : Sequence(long) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var y : Sequence(long) ; y := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     y[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum_interval : long ; sum_interval := 0 ;
    var before_inteval : long ; before_inteval := 0 ;
        var i : int ; i := 1 ; while i < m do ( (     var interval : long ; interval := y[i+1] - y[i - 1+1] ;
     var now : long ; now := before_inteval + (interval * i) mod mod ;
     before_inteval := now ; 
     sum_interval := sum_interval+(now) )  ;     i := i + 1 ) ; 
    sum_interval := sum_interval mod mod ; 
    var result : long ; result := 0 ;
    var before_sum : long ; before_sum := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     var x1 : long ; x1 := x[i+1] ;
     var x2 : long ; x2 := x[i - 1+1] ;
    var xint : long ; xint := x1 - x2 ;
    var now : long ; now := xint * sum_interval ;
    var r : long ; r := (now mod mod * i) mod mod + before_sum ;
    before_sum := r ; 
    result := result+(r) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(result mod mod) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    int n=Integer.parseInt(sa[0]);
    int m=Integer.parseInt(sa[1]);
    sa=br.readLine().split(" ");
    long[] x=new long[n];
    for(int i=0 ; i<n ; i++){
      x[i]=Integer.parseInt(sa[i]);
    }
    sa=br.readLine().split(" ");
    long[] y=new long[m];
    for(int i=0 ; i<m ; i++){
      y[i]=Integer.parseInt(sa[i]);
    }
    br.close();
    int mod=1000000007 ;
    long xx=0 ;
    for(int i=0 ; i<n ; i++){
      xx+=i*x[i]-(n-i-1)*x[i];
      xx %=mod ;
    }
    long yy=0 ;
    for(int i=0 ; i<m ; i++){
      yy+=i*y[i]-(m-i-1)*y[i];
      yy %=mod ;
    }
    long ans=xx*yy % mod ;
    if(ans<0){
      ans+=mod ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var n : int ; n := (sa[0+1])->toInteger() ;
    var m : int ; m := (sa[1+1])->toInteger() ;
    sa := br.readLine()->split(" ") ; 
    var x : Sequence(long) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := (sa[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    sa := br.readLine()->split(" ") ; 
    var y : Sequence(long) ; y := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     y[i+1] := (sa[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var mod : int ; mod := 1000000007 ;
    var xx : long ; xx := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     xx := xx+(i * x[i+1] - (n - i - 1) * x[i+1]) ; 
     xx := xx mod mod )  ;     i := i + 1 ) ; 
    var yy : long ; yy := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     yy := yy+(i * y[i+1] - (m - i - 1) * y[i+1]) ; 
     yy := yy mod mod )  ;     i := i + 1 ) ; 
    var ans : long ; ans := xx * yy mod mod ;
    if (ans < 0) then (     ans := ans+(mod) ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    new Main().run();
  }
  long MODULO=1_000_000_000+7 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    long[] x=new long[n];
    long[] y=new long[m];
    for(int i=0 ; i<n ; ++i){
      x[i]=sc.nextLong();
    }
    for(int j=0 ; j<m ; ++j){
      y[j]=sc.nextLong();
    }
    System.out.println(sum(x)*sum(y)% MODULO);
  }
  long sum(long[] arr){
    int n=arr.length ;
    long ret=0 ;
    long s=0 ;
    for(long v : arr){
      s=(s+v-arr[0])% MODULO ;
    }
    for(int i=0 ; i<arr.length ; ++i){
      ret=(ret+s)% MODULO ;
      if(i+1<arr.length)s=(s-(n-1)*(arr[i+1]-arr[i])% MODULO+MODULO)% MODULO ;
--n ;
    }
    return ret ;
  }
  void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute MODULO : long := 1_000_000_000 + 7;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : Sequence(long) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(long) ; y := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < m do ( (     y[j+1] := sc.getCurrent()->toLong() )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(sum(x) * sum(y) mod MODULO) ; 
 );
   operation sum( arr : Sequence(long)) : long
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
     var ret : long ; ret := 0 ;
    var s : long ; s := 0 ;
    for (v : arr) do ( (     s := (s + v - arr[0+1]) mod MODULO )  ) ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (     ret := (ret + s) mod MODULO ; 
     if (i + 1 < arr->size()) then     s := (s - (n - 1) * (arr[i + 1+1] - arr[i+1]) mod MODULO + MODULO) mod MODULO ; else skip ; 
     n := n - 1 )  ;     i := i + 1 ) ; 
    return ret 
 );
   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Solution {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    long k=Long.parseLong(st.nextToken());
    if(n==1)out.println("1");
    else {
      long[] tab=new long[n];
      tab[0]=(long)0 ;
      tab[1]=(long)0 ;
      for(int i=2 ; i<n ; i++){
        tab[i]=tab[i-1];
        tab[i]+=tab[i-2]+(long)1 ;
      }
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=i+1 ;
      for(int i=0 ; i<n-1 ; i++){
        long cnt=tab[n-i-1]+1 ;
        if(cnt<k){
          k-=cnt ;
          int d=a[i];
          a[i]=a[i+1];
          a[i+1]=d ;
          i++;
          if(k==1)break ;
          continue ;
        }
        if(k==1)break ;
      }
      for(int i=0 ; i<n-1 ; i++)out.print(a[i]+" ");
      out.println(a[n-1]);
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var k : long ; k := (st.next())->toLong() ;
    if (n = 1) then     skip else (     var tab : Sequence(long) ; tab := Integer.subrange(1,n)->collect(0) ;
     tab[0+1] := 0->oclAsType(long) ; 
    tab[1+1] := 0->oclAsType(long) ; 
        var i : int ; i := 2 ; while i < n do ( (     tab[i+1] := tab[i - 1+1] ; 
     tab[i+1] := tab[i+1]+(tab[i - 2+1] + 1->oclAsType(long)) )  ;     i := i + 1 ) ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := i + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var cnt : long ; cnt := tab[n - i - 1+1] + 1 ;
     if (cnt < k) then (     k := k-(cnt) ; 
     var d : int ; d := a[i+1] ;
    a[i+1] := a[i + 1+1] ; 
    a[i + 1+1] := d ; 
    i := i + 1 ; 
    if (k = 1) then     break else skip ; 
    continue 
 ) else skip ; 
     if (k = 1) then     break else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do (     skip ;  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.System.out ;
public class Main {
  public static void main(String[] args){
    String str=new java.util.Scanner(System.in).nextLine();
    String[] tmp=str.split(" ");
    int W=Integer.parseInt(tmp[0]);
    int H=Integer.parseInt(tmp[1]);
    int x=Integer.parseInt(tmp[2]);
    int y=Integer.parseInt(tmp[3]);
    int r=Integer.parseInt(tmp[4]);
    if(r<=x && x<=(W-r)&& r<=y && y<=(H-r)){
      out.println("Yes");
    }
    else {
      out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := Scanner.newScanner(OclFile["System.in"]).nextLine() ;
     var tmp : Sequence(String) ; tmp := str->split(" ") ;
    var W : int ; W := (tmp[0+1])->toInteger() ;
    var H : int ; H := (tmp[1+1])->toInteger() ;
    var x : int ; x := (tmp[2+1])->toInteger() ;
    var y : int ; y := (tmp[3+1])->toInteger() ;
    var r : int ; r := (tmp[4+1])->toInteger() ;
    if (r <= x & x <= (W - r) & r <= y & y <= (H - r)) then (     out.println("Yes") ) else (     out.println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.LinkedHashMap ;
import java.util.Scanner ;
public class B46 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    LinkedHashMap<String,Integer>n=new LinkedHashMap<String,Integer>();
    n.put("S",sc.nextInt());
    n.put("M",sc.nextInt());
    n.put("L",sc.nextInt());
    n.put("XL",sc.nextInt());
    n.put("XXL",sc.nextInt());
    int k=sc.nextInt();
    for(int i=0 ; i<k ; i++){
      String size=sc.next();
      if(n.get(size)>0){
        System.out.println(size);
        n.put(size,n.get(size)-1);
      }
      else {
        ArrayList<String>keys=new ArrayList<String>(n.keySet());
        boolean found=false ;
        int ind=0 ;
        int d=1 ;
        while(true){
          ind=keys.indexOf(size)+d ;
          if(ind<keys.size()){
            if(n.get(keys.get(ind))>0){
              System.out.println(keys.get(ind));
              n.put(keys.get(ind),n.get(keys.get(ind))-1);
              found=true ;
              break ;
            }
          }
          if(! found && keys.indexOf(size)-d>=0){
            ind=keys.indexOf(size)-d ;
            if(n.get(keys.get(ind))>0){
              System.out.println(keys.get(ind));
              n.put(keys.get(ind),n.get(keys.get(ind))-1);
              break ;
            }
          }
          d++;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B46 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : Map(String,int) ; n := Map{} ;
    n := n->union(Map{"S" |-> sc.getCurrent()->toInteger()}) ; 
    n := n->union(Map{"M" |-> sc.getCurrent()->toInteger()}) ; 
    n := n->union(Map{"L" |-> sc.getCurrent()->toInteger()}) ; 
    n := n->union(Map{"XL" |-> sc.getCurrent()->toInteger()}) ; 
    n := n->union(Map{"XXL" |-> sc.getCurrent()->toInteger()}) ; 
    var k : int ; k := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < k do ( (     var size : String ; size := sc.getCurrent() ;
     if (n->at(size) > 0) then (     OclFile["System.out"].println(size) ; 
     n := n->union(Map{size |-> n->at(size) - 1}) ) else (     var keys : Sequence(String) ; keys := Sequence{}->union(n->keys()) ;
     var found : boolean ; found := false ;
    var ind : int ; ind := 0 ;
    var d : int ; d := 1 ;
    while (true) do (     ind := keys->indexOf(size)-1 + d ; 
     if (ind < keys->size()) then (     if (n->at(keys->at(ind+1)) > 0) then (     OclFile["System.out"].println(keys->at(ind+1)) ; 
     n := n->union(Map{keys->at(ind+1) |-> n->at(keys->at(ind+1)) - 1}) ; 
     found := true ; 
     break ) else skip ) else skip ; 
     if (not(found) & keys->indexOf(size)-1 - d >= 0) then (     ind := keys->indexOf(size)-1 - d ; 
     if (n->at(keys->at(ind+1)) > 0) then (     OclFile["System.out"].println(keys->at(ind+1)) ; 
     n := n->union(Map{keys->at(ind+1) |-> n->at(keys->at(ind+1)) - 1}) ; 
     break ) else skip ) else skip ; 
     d := d + 1 ) ; 
 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    FFrogJump solver=new FFrogJump();
    solver.solve(1,in,out);
    out.close();
  }
  static class FFrogJump {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      long[] arr=new long[n];
      for(int i=0 ; i<n ; i++)arr[i]=in.nextLong();
      long res=solveMe2(n,arr);
      out.println(res);
    }
    private long solveMe2(int n,long[] s){
      long max=0 ;
      long[] dp=new long[n+1];
      for(int d=1 ; d<n ; d++){
        int maxn=n-d ;
        if((n-1)% d==0)maxn=n/2 ;
        for(int k=1 ; k*d<maxn ; k++){
          dp[k]=dp[k-1]+s[k*d]+s[n-1-k*d];
          max=Math.max(max,dp[k]);
        }
      }
      return max ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : FFrogJump ; solver := FFrogJump.newFFrogJump() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class FFrogJump {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := in.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var res : long ; res := solveMe2(n, arr) ;
    skip ; 
 );
   operation solveMe2( n : int, s : Sequence(long)) : long
  pre: true
  post: true
  activity: (     var max : long ; max := 0 ;
     var dp : Sequence(long) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
         var d : int ; d := 1 ; while d < n do ( (     var maxn : int ; maxn := n - d ;
     if ((n - 1) mod d = 0) then     maxn := n / 2 ; else skip ; 
         var k : int ; k := 1 ; while k * d < maxn do ( (     dp[k+1] := dp[k - 1+1] + s[k * d+1] + s[n - 1 - k * d+1] ; 
     max := Set{max, dp[k+1]}->max() )  ;     k := k + 1 ) )  ;     d := d + 1 ) ; 
     return max );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T[]=new int[5];
    String str[]={
      "S","M","L","XL","XXL" };
      for(int i=0 ; i<5 ; i++){
        T[i]=sc.nextInt();
      }
      int n=sc.nextInt();
      for(int i=0 ; i<n ; i++){
        String s=sc.next();
        int sum=0 ;
        if(s.equals("S"))sum=0 ;
        else if(s.equals("M"))sum=1 ;
        else if(s.equals("L"))sum=2 ;
        else if(s.equals("XL"))sum=3 ;
        else if(s.equals("XXL"))sum=4 ;
        if(T[sum]>0){
          System.out.println(str[sum]);
          T[sum]--;
        }
        else {
          int step=1,left=1,right=1 ;
          while(true){
            if(step==1){
              if(sum+right<5 && T[sum+right]>0){
                System.out.println(str[sum+right]);
                T[sum+right]--;
                break ;
              }
              else {
                step=2 ;
                right++;
              }
            }
            else {
              if(sum-left>=0 && T[sum-left]>0){
                System.out.println(str[sum-left]);
                T[sum-left]--;
                break ;
              }
              else {
                step=1 ;
                left++;
              }
            }
          }
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : Sequence(int) ; T := Integer.subrange(1,5)->collect(0) ;
    var str : Sequence(String) ; str := Sequence{"S","M","L","XL","XXL"} ;
        var i : int ; i := 0 ; while i < 5 do ( (     T[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
     var sum : int ; sum := 0 ;
     if (s = "S") then     sum := 0 else     if (s = "M") then     sum := 1 else     if (s = "L") then     sum := 2 else     if (s = "XL") then     sum := 3 else     if (s = "XXL") then     sum := 4 ; else skip ; ;  ;  ;  ;  
     if (T[sum+1] > 0) then (     OclFile["System.out"].println(str[sum+1]) ; 
     T[sum+1] := T[sum+1] - 1 ) else (     var step : int ; step := 1 ;
    var left : int ; left := 1 ;
    var right : int ; right := 1 ;
     while (true) do (     if (step = 1) then (     if (sum + right < 5 & T[sum + right+1] > 0) then (     OclFile["System.out"].println(str[sum + right+1]) ; 
     T[sum + right+1] := T[sum + right+1] - 1 ; 
     break ) else (     step := 2 ; 
     right := right + 1 ) ) else (     if ((sum)->char2byte() - left >= 0 & T[(sum)->char2byte() - left+1] > 0) then (     OclFile["System.out"].println(str[(sum)->char2byte() - left+1]) ; 
     T[(sum)->char2byte() - left+1] := T[(sum)->char2byte() - left+1] - 1 ; 
     break ) else (     step := 1 ; 
     left := left + 1 ) ) ) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class ArrayRearrangment {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    while(q-->0){
      int n=sc.nextInt(),x=sc.nextInt(),flag=0 ;
      List<Integer>list=new ArrayList<>();
      List<Integer>list1=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        list.add(sc.nextInt());
      }
      for(int i=0 ; i<n ; i++){
        list1.add(sc.nextInt());
      }
      Collections.sort(list);
      Collections.reverse(list1);
      for(int i=0 ; i<n ; i++){
        if(list.get(i)+list1.get(i)>x){
          flag=1 ;
          break ;
        }
      }
      if(flag==1){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ArrayRearrangment {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
         while (q > 0) do (        q := q - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var flag : int ; flag := 0 ;
     var list : Sequence(int) ; list := Sequence{} ;
    var list1 : Sequence(int) ; list1 := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     list1 := list1->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    list1 := list1->reverse() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (list->at(i+1) + list1->at(i+1) > x) then (     flag := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 1) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int testCases=scanner.nextInt();
    for(int i=0 ; i<testCases ; i++){
      int len=scanner.nextInt();
      int x=scanner.nextInt();
      int[] a=new int[len];
      int[] b=new int[len];
      for(int j=0 ; j<a.length ; j++){
        a[j]=scanner.nextInt();
      }
      for(int j=0 ; j<b.length ; j++){
        b[j]=scanner.nextInt();
      }
      int tmp ;
      for(int k=0 ; k<len ; k++){
        for(int l=k ; l<len ; l++){
          if(a[k]<=x){
            tmp=b[k];
            b[k]=b[l];
            b[l]=tmp ;
          }
        }
      }
      boolean flag=true ;
      for(int z=0 ; z<len ; z++){
        if(a[z]+b[z]>x){
          flag=false ;
          break ;
        }
      }
      if(flag){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < testCases do ( (     var len : int ; len := scanner.getCurrent()->toInteger() ;
     var x : int ; x := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,len)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,len)->collect(0) ;
        var j : int ; j := 0 ; while j < a->size() do ( (     a[j+1] := scanner.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < b->size() do ( (     b[j+1] := scanner.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    var tmp : int ;
        var k : int ; k := 0 ; while k < len do ( (         var l : int ; l := k ; while l < len do ( (     if (a[k+1] <= x) then (     tmp := b[k+1] ; 
     b[k+1] := b[l+1] ; 
     b[l+1] := tmp ) else skip )  ;     l := l + 1 ) )  ;     k := k + 1 ) ; 
    var flag : boolean ; flag := true ;
        var z : int ; z := 0 ; while z < len do ( (     if (a[z+1] + b[z+1] > x) then (     flag := false ; 
     break ) else skip )  ;     z := z + 1 ) ; 
    if (flag) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int solve(int n){
    int ans=(n*n/4);
    return ans ;
  }
  public static void main(String args[]){
    int n=10 ;
    System.out.println(solve(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := (n * n / 4) ;
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(solve(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A {
  public static void main(String args[]){
    Scanner Sc=new Scanner(System.in);
    int t=Sc.nextInt();
    while(t-->0){
      int n=Sc.nextInt();
      int size=2*n ;
      counter=0 ;
      helper("(",1,0,size,n);
    }
  }
  static int counter ;
  static void helper(String str,int o,int c,int size,int n){
    if(counter==n)return ;
    if(o>n || c>n)return ;
    if(o==c &&(o+c)==size){
      counter++;
      System.out.println(str);
      return ;
    }
    helper(str+'(',o+1,c,size,n);
    helper(str+')',o,c+1,size,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Sc : OclFile ; Sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := Sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := Sc.getCurrent()->toInteger() ;
     var size : int ; size := 2 * n ;
     counter := 0 ; 
     execute helper("(", 1, 0, size, n) ) ;  ) );
  static   attribute counter : int;
  static   operation helper( str : String, o : int, c : int, size : int, n : int) : void
  pre: true
  post: true
  activity: (     if (counter = n) then     return else skip ; 
     if (o > n or c > n) then     return else skip ; 
    if (o = c & (o + c) = size) then (     counter := counter + 1 ; 
     OclFile["System.out"].println(str) ; 
     return ) else skip ; 
    execute helper(str + '(', o + 1, c, size, n) ; 
    execute helper(str + ')', o, c + 1, size, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A1574 {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      int n=input.nextInt();
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<2*n-1 ; j++){
          if(j<n){
            System.out.print("(");
          }
          else {
            System.out.print(")");
          }
          if(j==i){
            System.out.print(")");
          }
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1574 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var tt : int ; tt := 0 ; while tt < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 2 * n - 1 do ( (     if (j < n) then (     OclFile["System.out"].print("(") ) else (     OclFile["System.out"].print(")") ) ;  
     if (j = i) then (     OclFile["System.out"].print(")") ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) )  ;     tt := tt + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int Valid(int a,int b,int c,int d){
    if(a+b+c+d==360)return 1 ;
    return 0 ;
  }
  public static void main(String[] args){
    int a=80,b=70,c=100,d=110 ;
    if(Valid(a,b,c,d)==1)System.out.println("Valid quadilateral");
    else System.out.println("Invalid quadilateral");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Valid( a : int, b : int, c : int, d : int) : int
  pre: true
  post: true
  activity: (     if (a + b + c + d = 360) then     return 1 else skip ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 80 ;
    var b : int ; b := 70 ;
    var c : int ; c := 100 ;
    var d : int ; d := 110 ;
     if (Valid(a, b, c, d) = 1) then     OclFile["System.out"].println("Valid quadilateral") ; else     OclFile["System.out"].println("Invalid quadilateral") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    int x,y,r,w,h ;
    String s="No" ;
    Scanner sc=new Scanner(System.in);
    w=sc.nextInt();
    h=sc.nextInt();
    x=sc.nextInt();
    y=sc.nextInt();
    r=sc.nextInt();
    if(h-y-r>=0 && y-r>=0 && w-x-r>=0 && x-r>=0)s="Yes" ;
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ;
    var y : int ;
    var r : int ;
    var w : int ;
    var h : int ;
     var s : String ; s := "No" ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    w := sc.getCurrent()->toInteger() ; 
    h := sc.getCurrent()->toInteger() ; 
    x := sc.getCurrent()->toInteger() ; 
    y := sc.getCurrent()->toInteger() ; 
    r := sc.getCurrent()->toInteger() ; 
    if (h - y - r >= 0 & y - r >= 0 & w - x - r >= 0 & x - r >= 0) then     s := "Yes" ; else skip ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution20200410 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    double R=scanner.nextDouble();
    double r=scanner.nextDouble();
    double angle=360.0/(n*2);
    double minR=r/Math.sin(Math.toRadians(angle))+r ;
    if(n==1){
      if(R>=r){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    else if(n==2){
      if(R>=r*2){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    else {
      if(R>=minR){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution20200410 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var R : double ; R := scanner.getCurrent()->toReal() ;
    var r : double ; r := scanner.getCurrent()->toReal() ;
    var angle : double ; angle := 360.0 / (n * 2) ;
    var minR : double ; minR := r / ((0.017453292519943295*(angle)))->sin() + r ;
    if (n = 1) then (     if (R >= r) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else     if (n = 2) then (     if (R >= r * 2) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else (     if (R >= minR) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test10 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int dishCount=sc.nextInt();
    int desk=sc.nextInt();
    int dishR=sc.nextInt();
    double angle=360.0/(dishCount*2);
    double minR=dishR/Math.sin(Math.toRadians(angle))+dishR ;
    if(dishCount==1){
      if(desk>=dishR){
        System.out.println("YES");
        return ;
      }
      else {
        System.out.println("NO");
        return ;
      }
    }
    if(dishCount==2){
      if(2*dishR<=desk){
        System.out.println("YES");
        return ;
      }
      else {
        System.out.println("NO");
        return ;
      }
    }
    if(desk>=minR){
      System.out.println("YES");
      return ;
    }
    else {
      System.out.println("NO");
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test10 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dishCount : int ; dishCount := sc.getCurrent()->toInteger() ;
    var desk : int ; desk := sc.getCurrent()->toInteger() ;
    var dishR : int ; dishR := sc.getCurrent()->toInteger() ;
    var angle : double ; angle := 360.0 / (dishCount * 2) ;
    var minR : double ; minR := dishR / ((0.017453292519943295*(angle)))->sin() + dishR ;
    if (dishCount = 1) then (     if (desk >= dishR) then (     OclFile["System.out"].println("YES") ; 
     return ) else (     OclFile["System.out"].println("NO") ; 
     return ) ) else skip ; 
    if (dishCount = 2) then (     if (2 * dishR <= desk) then (     OclFile["System.out"].println("YES") ; 
     return ) else (     OclFile["System.out"].println("NO") ; 
     return ) ) else skip ; 
    if (desk >= minR) then (     OclFile["System.out"].println("YES") ; 
     return ) else (     OclFile["System.out"].println("NO") ; 
     return ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  private static class InputReader {
    private BufferedReader br=null ;
    private StringTokenizer tokenizer=null ;
    public InputReader(InputStream is){
      super();
      this.br=new BufferedReader(new InputStreamReader(is));
    }
    public String nextLine(){
      try {
        return br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
        throw new RuntimeException(e);
      }
    }
    public String next(){
      for(; tokenizer==null || ! tokenizer.hasMoreTokens(); ){
        tokenizer=new StringTokenizer(nextLine());
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
  }
  public static void main(String[] args){
    InputReader in=new InputReader(System.in);
    int n=in.nextInt();
    double R=in.nextDouble();
    double r=in.nextDouble();
    if(n>1){
      if(R>=r/Math.sin(Math.toRadians(360.0/n/2))+r){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    else {
      if(R>=r || n<=0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class InputReader {
   attribute br : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newInputReader( is : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     execute super() ; 
     self.br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do (     e.printStackTrace() ; 
     error ProgramException(e) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (       while tokenizer = null or not(tokenizer.hasNext()) do ( (     tokenizer := OclIterator.newOclIterator_String(nextLine()) )  ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : InputReader ; in := InputReader.newInputReader(OclFile["System.in"]) ;
     var n : int ; n := in.nextInt() ;
    var R : double ; R := in.nextDouble() ;
    var r : double ; r := in.nextDouble() ;
    if (n > 1) then (     if (R >= r / ((0.017453292519943295*(360.0 / n / 2)))->sin() + r) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else (     if (R >= r or n <= 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    boolean go=false ;
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      if(go==true)System.out.println();
      go=true ;
      int max=0 ;
      int[] sum=new int[n];
      String[] name=new String[n];
      for(int i=0 ; i<n ; i++){
        name[i]=sc.next();
        sum[i]=sc.nextInt()*3+sc.nextInt()*0+sc.nextInt()*1 ;
        max=Math.max(max,sum[i]);
      }
      for(int i=max ; i>=0 ; i--){
        for(int j=0 ; j<n ; j++){
          if(sum[j]==i)System.out.println(name[j]+","+sum[j]);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var go : boolean ; go := false ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    if (go = true) then     OclFile["System.out"].println() ; else skip ; 
    go := true ; 
    var max : int ; max := 0 ;
    var sum : Sequence(int) ; sum := Integer.subrange(1,n)->collect(0) ;
    var name : Sequence(String) ; name := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     name[i+1] := sc.getCurrent() ; 
     sum[i+1] := sc.getCurrent()->toInteger() * 3 + sc.getCurrent()->toInteger() * 0 + sc.getCurrent()->toInteger() * 1 ; 
     max := Set{max, sum[i+1]}->max() )  ;     i := i + 1 ) ; 
        var i : int ; i := max ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < n do ( (     if (sum[j+1] = i) then     OclFile["System.out"].println(name[j+1] + "," + sum[j+1]) ; else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    long[] s=new long[N];
    for(int i=0 ; i<N ; i++)s[i]=scanner.nextInt();
    long[] u=new long[N];
    long[] v=new long[N];
    for(int i=1 ; i<N ; i++){
      long t=s[i]+s[N-i-1];
      for(int j=1 ; (long)j*j<=i ; j++){
        if(i % j==0){
          if((i<N/2 ||(N-1)% j!=0)&& N-i-1>j){
            u[j]+=t ;
            v[j]=Math.max(v[j],u[j]);
          }
          if(i!=j*j){
            int k=i/j ;
            if((i<N/2 ||(N-1)% k!=0)&& N-i-1>k){
              u[k]+=t ;
              v[k]=Math.max(v[k],u[k]);
            }
          }
        }
      }
    }
    long max=0 ;
    for(int i=0 ; i<N ; i++)max=Math.max(max,v[i]);
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var s : Sequence(long) ; s := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     s[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var u : Sequence(long) ; u := Integer.subrange(1,N)->collect(0) ;
    var v : Sequence(long) ; v := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 1 ; while i < N do ( (     var t : long ; t := s[i+1] + s[N - i - 1+1] ;
         var j : int ; j := 1 ; while j->oclAsType(long) * j <= i do ( (     if (i mod j = 0) then (     if ((i < N / 2 or (N - 1) mod j /= 0) & N - i - 1 > j) then (     u[j+1] := u[j+1]+(t) ; 
     v[j+1] := Set{v[j+1], u[j+1]}->max() ) else skip ; 
     if (i /= j * j) then (     var k : int ; k := i / j ;
     if ((i < N / 2 or (N - 1) mod k /= 0) & N - i - 1 > k) then (     u[k+1] := u[k+1]+(t) ; 
     v[k+1] := Set{v[k+1], u[k+1]}->max() ) else skip ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : long ; max := 0 ;
        var i : int ; i := 0 ; while i < N do (     max := Set{max, v[i+1]}->max() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test3 {
  public static void main(String[] args){
    int n ;
    double R,r ;
    double eps=1e-10 ;
    double PI=Math.acos(-1);
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      n=in.nextInt();
      R=in.nextInt();
      r=in.nextInt();
      if(n==1){
        if(R>=r)System.out.println("YES");
        else System.out.println("NO");
        continue ;
      }
      double tmp=Math.asin(r/(R-r));
      if(PI/tmp-n>-eps)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     var R : double ;
    var r : double ;
    var eps : double ; eps := 1e-10 ;
    var PI : double ; PI := (-1)->acos() ;
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (in.hasNext()) do (     n := in.getCurrent()->toInteger() ; 
     R := in.getCurrent()->toInteger() ; 
    r := in.getCurrent()->toInteger() ; 
    if (n = 1) then (     if (R >= r) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
     continue ) else skip ; 
    var tmp : double ; tmp := (r / (R - r))->asin() ;
    if (PI / tmp - n > -eps) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ProblemK {
  public static int n ;
  public static int R ;
  public static int r ;
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    n=input.nextInt();
    R=input.nextInt();
    r=input.nextInt();
    if(n==1){
      System.out.println(r<=R ? "YES" : "NO");
    }
    else if(n==2){
      System.out.println(r*2<=R ? "YES" : "NO");
    }
    else {
      double x=Math.PI/n ;
      double r1=R*Math.sin(x)/(1+Math.sin(x));
      System.out.println(r<=r1+0.000000001 ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemK {
  static   attribute n : int;
  static   attribute R : int;
  static   attribute r : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := input.getCurrent()->toInteger() ; 
    R := input.getCurrent()->toInteger() ; 
    r := input.getCurrent()->toInteger() ; 
    if (n = 1) then (     OclFile["System.out"].println(if r <= R then "YES" else "NO" endif) ) else     if (n = 2) then (     OclFile["System.out"].println(if r * 2 <= R then "YES" else "NO" endif) ) else (     var x : double ; x := 3.141592653589793 / n ;
     var r1 : double ; r1 := R * (x)->sin() / (1 + (x)->sin()) ;
     OclFile["System.out"].println(if r <= r1 + 0.000000001 then "YES" else "NO" endif) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt(),M=sc.nextInt();
    int key[][]=new int[M][2];
    for(int i=0 ; i<M ; i++){
      int a=sc.nextInt(),b=sc.nextInt();
      int s=0 ;
      for(int j=0 ; j<b ; j++){
        int c=sc.nextInt()-1 ;
        s |=1<<c ;
      }
      key[i][0]=s ;
      key[i][1]=a ;
    }
    sc.close();
    int dp[]=new int[1<<N];
    int INF=Integer.MAX_VALUE/2 ;
    Arrays.fill(dp,INF);
    dp[0]=0 ;
    for(int i=0 ; i<(1<<N); i++){
      for(int j=0 ; j<M ; j++){
        int keyOpenNum=key[j][0];
        int keyCost=key[j][1];
        int nextOpenNum=i | keyOpenNum ;
        dp[nextOpenNum]=Math.min(dp[nextOpenNum],dp[i]+keyCost);
      }
    }
    int ans=(dp[(1<<N)-1]==INF)?-1 : dp[(1<<N)-1];
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var key : Sequence(Sequence(int)) ; key := Integer.subrange(1,M)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < M do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
     var s : int ; s := 0 ;
        var j : int ; j := 0 ; while j < b do ( (     var c : int ; c := sc.getCurrent()->toInteger() - 1 ;
     s := MathLib.bitwiseOr(s, (1*(2->pow(c)))->oclAsType(long)) )  ;     j := j + 1 ) ; 
    key[i+1][0+1] := s ; 
    key[i+1][1+1] := a ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,(1*(2->pow(N)))->oclAsType(long))->collect(0) ;
    var INF : int ; INF := 2147483647 / 2 ;
    dp := dp->collect(INF) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < ((1*(2->pow(N)))->oclAsType(long)) do ( (         var j : int ; j := 0 ; while j < M do ( (     var keyOpenNum : int ; keyOpenNum := key[j+1][0+1] ;
     var keyCost : int ; keyCost := key[j+1][1+1] ;
     var nextOpenNum : int ; nextOpenNum := MathLib.bitwiseOr(i,keyOpenNum) ;
     dp[nextOpenNum+1] := Set{dp[nextOpenNum+1], dp[i+1] + keyCost}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := if (dp[((1*(2->pow(N)))->oclAsType(long)) - 1+1] = INF) then -1 else dp[((1*(2->pow(N)))->oclAsType(long)) - 1+1] endif ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    try(Scanner scan=new Scanner(System.in)){
      int N=scan.nextInt();
      int M=scan.nextInt();
      int[] dp=new int[1<<N];
      for(int i=0 ; i<1<<N ; ++i)dp[i]=1001001 ;
      List<List<Integer>>key=new ArrayList<>();
      for(int i=0 ; i<M ; i++){
        int v=scan.nextInt();
        int keyNum=scan.nextInt();
        int s=0 ;
        for(int j=0 ; j<keyNum ; j++){
          int c=scan.nextInt();
          c--;
          s |=1<<c ;
        }
        List<Integer>a=Arrays.asList(v,s);
        key.add(a);
      }
      dp[0]=0 ;
      for(int s=0 ; s<1<<N ; s++){
        for(int i=0 ; i<M ; i++){
          int t=s | key.get(i).get(1);
          int v=key.get(i).get(0);
          dp[t]=Math.min(dp[t],v+dp[s]);
        }
      }
      int ans=dp[(1<<N)-1];
      if(ans==1001001){
        System.out.println(-1);
      }
      else {
        System.out.println(ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := scan.getCurrent()->toInteger() ;
     var M : int ; M := scan.getCurrent()->toInteger() ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,(1*(2->pow(N)))->oclAsType(long))->collect(0) ;
        var i : int ; i := 0 ; while i < (1*(2->pow(N)))->oclAsType(long) do (     dp[i+1] := 1001001 ;  ;     i := i + 1 ) ; 
    var key : Sequence(Sequence(int)) ; key := Sequence{} ;
        var i : int ; i := 0 ; while i < M do ( (     var v : int ; v := scan.getCurrent()->toInteger() ;
     var keyNum : int ; keyNum := scan.getCurrent()->toInteger() ;
    var s : int ; s := 0 ;
        var j : int ; j := 0 ; while j < keyNum do ( (     var c : int ; c := scan.getCurrent()->toInteger() ;
     c := c - 1 ; 
     s := MathLib.bitwiseOr(s, (1*(2->pow(c)))->oclAsType(long)) )  ;     j := j + 1 ) ; 
    var a : Sequence(int) ; a := Sequence{v,s} ;
    key := key->including(a) ; 
 )  ;     i := i + 1 ) ; 
    dp[0+1] := 0 ; 
        var s : int ; s := 0 ; while s < (1*(2->pow(N)))->oclAsType(long) do ( (         var i : int ; i := 0 ; while i < M do ( (     var t : int ; t := MathLib.bitwiseOr(s,key->at(i+1)->at(1+1)) ;
     var v : int ; v := key->at(i+1)->at(0+1) ;
     dp[t+1] := Set{dp[t+1], v + dp[s+1]}->min() )  ;     i := i + 1 ) )  ;     s := s + 1 ) ; 
    var ans : int ; ans := dp[((1*(2->pow(N)))->oclAsType(long)) - 1+1] ;
    if (ans = 1001001) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(ans) ) ;  
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int M=scan.nextInt();
    int p=power(2,N);
    int[] dp=new int[p];
    for(int i=0 ; i<p ; i++){
      dp[i]=1_000_000_000 ;
    }
    dp[0]=0 ;
    for(int i=0 ; i<M ; i++){
      int a=scan.nextInt();
      int b=scan.nextInt();
      int[] c_list=new int[b];
      for(int j=0 ; j<b ; j++){
        c_list[j]=scan.nextInt();
      }
      int c=0 ;
      for(int item : c_list){
        c+=power(2,item-1);
      }
      for(int k=0 ; k<p ; k++){
        if(dp[k | c]>dp[k]+a){
          dp[k | c]=dp[k]+a ;
        }
      }
    }
    if(dp[dp.length-1]==1_000_000_000){
      System.out.println(-1);
    }
    else {
      System.out.println(dp[dp.length-1]);
    }
  }
  public static int power(int n,int m){
    int res=1 ;
    if(m==0){
      return 1 ;
    }
    else {
      if(n==0){
        return 0 ;
      }
      else {
        for(int i=0 ; i<m ; i++){
          res=res*n ;
        }
        return res ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var M : int ; M := scan.getCurrent()->toInteger() ;
    var p : int ; p := power(2, N) ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,p)->collect(0) ;
        var i : int ; i := 0 ; while i < p do ( (     dp[i+1] := 1_000_000_000 )  ;     i := i + 1 ) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < M do ( (     var a : int ; a := scan.getCurrent()->toInteger() ;
     var b : int ; b := scan.getCurrent()->toInteger() ;
    var c_list : Sequence(int) ; c_list := Integer.subrange(1,b)->collect(0) ;
        var j : int ; j := 0 ; while j < b do ( (     c_list[j+1] := scan.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    var c : int ; c := 0 ;
    for (item : c_list) do ( (     c := c+(power(2, item - 1)) )  ) ; 
        var k : int ; k := 0 ; while k < p do ( (     if (dp[MathLib.bitwiseOr(k,c)+1] > dp[k+1] + a) then (     dp[MathLib.bitwiseOr(k,c)+1] := dp[k+1] + a ) else skip )  ;     k := k + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    if (dp[dp->size() - 1+1] = 1_000_000_000) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(dp[dp->size() - 1+1]) ) ;  
 );
  static   operation power( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     if (m = 0) then (     return 1 ) else (     if (n = 0) then (     return 0 ) else (         var i : int ; i := 0 ; while i < m do ( (     res := res * n )  ;     i := i + 1 ) ; 
     return res ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static boolean isInOut_Circle(int[] pos){
    int[] sq_pos={
      pos[0],pos[1] };
      int[] ci_pos={
        pos[2],pos[3] };
        int rad=pos[4];
        if(((ci_pos[0]-rad)<0)||((ci_pos[0]+rad)>sq_pos[0])){
          return false ;
        }
        else if(((ci_pos[1]-rad)<0)||((ci_pos[1]+rad)>sq_pos[1])){
          return false ;
        }
        else {
          return true ;
        }
      }
      public static void main(String[] args){
        Scanner stdIn=new Scanner(System.in);
        int inNum[]=new int[5];
        for(int i=0 ; i<inNum.length ; i++){
          inNum[i]=stdIn.nextInt();
        }
        if(isInOut_Circle(inNum)){
          System.out.println("Yes");
        }
        else {
          System.out.println("No");
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation isInOut_Circle( pos : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var sq_pos : Sequence(int) ; sq_pos := Sequence{pos[0+1],pos[1+1]} ;
     var ci_pos : Sequence(int) ; ci_pos := Sequence{pos[2+1],pos[3+1]} ;
     var rad : int ; rad := pos[4+1] ;
     if (((ci_pos[0+1] - rad) < 0) or ((ci_pos[0+1] + rad) > sq_pos[0+1])) then (     return false ) else     if (((ci_pos[1+1] - rad) < 0) or ((ci_pos[1+1] + rad) > sq_pos[1+1])) then (     return false ) else (     return true ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inNum : Sequence(int) ; inNum := Integer.subrange(1,5)->collect(0) ;
         var i : int ; i := 0 ; while i < inNum->size() do ( (     inNum[i+1] := stdIn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     if (isInOut_Circle(inNum)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] a=new int[m];
    int[] b=new int[m];
    int[] c=new int[m];
    boolean[] u=new boolean[n];
    for(int i=0 ; i<m ; i++){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
      for(int j=0 ; j<b[i]; j++){
        int t=sc.nextInt()-1 ;
        c[i]=c[i] |(1<<t);
        u[t]=true ;
      }
    }
    boolean able=true ;
    for(int i=0 ; i<n ; i++){
      if(! u[i]){
        able=false ;
        break ;
      }
    }
    if(able){
      int max=1<<n ;
      int[] dp=new int[max];
      Arrays.fill(dp,Integer.MAX_VALUE);
      dp[0]=0 ;
      for(int i=0 ; i<m ; i++){
        for(int j=0 ; j<max ; j++){
          if((j & c[i])==c[i] || dp[j]==Integer.MAX_VALUE)continue ;
          int next=j | c[i];
          if(dp[j]+a[i]<dp[next])dp[next]=dp[j]+a[i];
        }
      }
      System.out.println(dp[max-1]);
    }
    else {
      System.out.println(-1);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,m)->collect(0) ;
    var u : Sequence(boolean) ; u := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() ; 
         var j : int ; j := 0 ; while j < b[i+1] do ( (     var t : int ; t := sc.getCurrent()->toInteger() - 1 ;
     c[i+1] := c[i+1] or ((1*(2->pow(t)))->oclAsType(long)) ; 
     u[t+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var able : boolean ; able := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (not(u[i+1])) then (     able := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (able) then (     var max : int ; max := (1*(2->pow(n)))->oclAsType(long) ;
     var dp : Sequence(int) ; dp := Integer.subrange(1,max)->collect(0) ;
    dp := dp->collect(2147483647) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j < max do ( (     if ((MathLib.bitwiseAnd(j,c[i+1])) = c[i+1] or dp[j+1] = 2147483647) then     continue else skip ; 
     var next : int ; next := MathLib.bitwiseOr(j,c[i+1]) ;
     if (dp[j+1] + a[i+1] < dp[next+1]) then     dp[next+1] := dp[j+1] + a[i+1] ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[max - 1+1]) ; 
 ) else (     OclFile["System.out"].println(-1) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[] a=new int[M];
    int[] b=new int[M];
    int[] c=new int[M];
    for(int i=0 ; i<M ; i++){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
      for(int j=0 ; j<b[i]; j++){
        int t=sc.nextInt();
        t--;
        c[i]+=1<<t ;
      }
    }
    int INF=Integer.MAX_VALUE/2 ;
    int[][] dp=new int[M+1][1<<N];
    for(int[] d : dp){
      Arrays.fill(d,INF);
    }
    dp[0][0]=0 ;
    for(int idxKey=0 ; idxKey<M ; idxKey++){
      for(int j=0 ; j<(1<<N); j++){
        dp[idxKey+1][j]=Math.min(dp[idxKey+1][j],dp[idxKey][j]);
        int nj=j | c[idxKey];
        dp[idxKey+1][nj]=Math.min(dp[idxKey+1][nj],dp[idxKey][j]+a[idxKey]);
      }
    }
    int ans=(dp[M][(1<<N)-1]<INF)? dp[M][(1<<N)-1] :-1 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,M)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,M)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() ; 
         var j : int ; j := 0 ; while j < b[i+1] do ( (     var t : int ; t := sc.getCurrent()->toInteger() ;
     t := t - 1 ; 
     c[i+1] := c[i+1]+((1*(2->pow(t)))->oclAsType(long)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var INF : int ; INF := 2147483647 / 2 ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,M + 1)->collect(Integer.subrange(1,(1*(2->pow(N)))->oclAsType(long))->collect(0)) ;
    for (d : dp) do ( (     d := d->collect(INF) )  ) ; 
    dp[0+1][0+1] := 0 ; 
        var idxKey : int ; idxKey := 0 ; while idxKey < M do ( (         var j : int ; j := 0 ; while j < ((1*(2->pow(N)))->oclAsType(long)) do ( (     dp[idxKey + 1+1][j+1] := Set{dp[idxKey + 1+1][j+1], dp[idxKey+1][j+1]}->min() ; 
     var nj : int ; nj := MathLib.bitwiseOr(j,c[idxKey+1]) ;
     dp[idxKey + 1+1][nj+1] := Set{dp[idxKey + 1+1][nj+1], dp[idxKey+1][j+1] + a[idxKey+1]}->min() )  ;     j := j + 1 ) )  ;     idxKey := idxKey + 1 ) ; 
    var ans : int ; ans := if (dp[M+1][((1*(2->pow(N)))->oclAsType(long)) - 1+1] < INF) then dp[M+1][((1*(2->pow(N)))->oclAsType(long)) - 1+1] else -1 endif ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=100001 ;
  static int[] prime=new int[MAX+1];
  static int[] countdiv=new int[MAX+1];
  static void SieveOfEratosthenes(){
    for(int i=2 ; i*i<=MAX ; ++i){
      if(prime[i]==0)for(int j=i*2 ;
      j<=MAX ;
      j+=i)prime[j]=i ;
    }
    for(int i=1 ; i<MAX ; ++i)if(prime[i]==0)prime[i]=i ;
  }
  static int largestGCDSubsequence(int arr[],int n){
    int ans=0 ;
    for(int i=0 ; i<n ; ++i){
      int element=arr[i];
      while(element>1){
        int div=prime[element];
++countdiv[div];
        ans=Math.max(ans,countdiv[div]);
        while(element % div==0)element/=div ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    SieveOfEratosthenes();
    int arr[]={
      10,15,7,25,9,35 };
      int size=arr.length ;
      System.out.println(largestGCDSubsequence(arr,size));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100001;
  static   attribute prime : Sequence(int) := Integer.subrange(1,MAX + 1)->collect(0);
  static   attribute countdiv : Sequence(int) := Integer.subrange(1,MAX + 1)->collect(0);
  static   operation SieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= MAX do ( (     if (prime[i+1] = 0) then         var j : int ; j := i * 2 ; while j <= MAX do (     prime[j+1] := i ;  ;     j := j+(i) ) ; else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i < MAX do (     if (prime[i+1] = 0) then     prime[i+1] := i ; else skip ;  ;     i := i + 1 ) );
  static   operation largestGCDSubsequence( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var element : int ; element := arr[i+1] ;
     while (element > 1) do (     var div : int ; div := prime[element+1] ;
     countdiv[div+1] := countdiv[div+1] + 1 ; 
     ans := Set{ans, countdiv[div+1]}->max() ; 
     while (element mod div = 0) do     element := element/(div) ; ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes() ; 
     var arr : Sequence(int) ; arr := Sequence{10,15,7,25,9,35} ;
     var size : int ; size := arr->size() ;
     OclFile["System.out"].println(largestGCDSubsequence(arr, size)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int Count(String s,int pos){
    int c=s.charAt(pos-1);
    int counter=0 ;
    for(int i=0 ; i<pos-1 ; i++){
      if(s.charAt(i)==c)counter=counter+1 ;
    }
    return counter ;
  }
  public static void main(String[] args){
    String s="abacsddaa" ;
    int pos ;
    int n=s.length();
    int query[]={
      9,3,2 };
      int Q=query.length ;
      for(int i=0 ; i<Q ; i++){
        pos=query[i];
        System.out.println(Count(s,pos));
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Count( s : String, pos : int) : int
  pre: true
  post: true
  activity: (     var c : int ; c := s->at(pos - 1+1) ;
     var counter : int ; counter := 0 ;
         var i : int ; i := 0 ; while i < pos - 1 do ( (     if (s->at(i+1) = c) then     counter := counter + 1 ; else skip )  ;     i := i + 1 ) ; 
     return counter );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abacsddaa" ;
     var pos : int ;
    var n : int ; n := s->size() ;
    var query : Sequence(int) ; query := Sequence{9,3,2} ;
    var Q : int ; Q := query->size() ;
        var i : int ; i := 0 ; while i < Q do ( (     pos := query[i+1] ; 
     OclFile["System.out"].println(Count(s, pos)) )  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class AlarmClock {
  public static void main(String[] args){
    Scanner iScanner=new Scanner(System.in);
    int test=iScanner.nextInt();
    while(test>0){
      test--;
      long a=iScanner.nextLong();
      long b=iScanner.nextLong();
      long c=iScanner.nextLong();
      long d=iScanner.nextLong();
      if(b>=a){
        System.out.println(b);
      }
      else {
        if(d>=c)System.out.println("-1");
        else {
          long rest=a-b ;
          long restAlarm=c-d ;
          long totalRest=0 ;
          if(rest % restAlarm!=0)totalRest=(rest/restAlarm)+1 ;
          else totalRest=rest/restAlarm ;
          System.out.println(b+totalRest*c);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AlarmClock {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var iScanner : OclFile ; iScanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := iScanner.getCurrent()->toInteger() ;
     while (test > 0) do (     test := test - 1 ; 
     var a : long ; a := iScanner.getCurrent()->toLong() ;
    var b : long ; b := iScanner.getCurrent()->toLong() ;
    var c : long ; c := iScanner.getCurrent()->toLong() ;
    var d : long ; d := iScanner.getCurrent()->toLong() ;
    if (b >= a) then (     OclFile["System.out"].println(b) ) else (     if (d >= c) then     OclFile["System.out"].println("-1") ; else (     var rest : long ; rest := a - b ;
     var restAlarm : long ; restAlarm := c - d ;
    var totalRest : long ; totalRest := 0 ;
    if (rest mod restAlarm /= 0) then     totalRest := (rest / restAlarm) + 1 else     totalRest := rest / restAlarm ; ;  
    OclFile["System.out"].println(b + totalRest * c) ; 
 ) ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void perfectSquares(float l,float r){
    int number=(int)Math.ceil(Math.sqrt(l));
    int n2=number*number ;
    number=(number*2)+1 ;
    while((n2>=l && n2<=r)){
      System.out.print(n2+" ");
      n2=n2+number ;
      number+=2 ;
    }
  }
  public static void main(String[] args){
    int l=2,r=24 ;
    perfectSquares(l,r);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation perfectSquares( l : double, r : double) : void
  pre: true
  post: true
  activity: (     var number : int ; number := ((l)->sqrt())->ceil()->oclAsType(int) ;
     var n2 : int ; n2 := number * number ;
     number := (number * 2) + 1 ; 
     while ((n2 >= l & n2 <= r)) do (     OclFile["System.out"].print(n2 + " ") ; 
     n2 := n2 + number ; 
     number := number+(2) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 2 ;
    var r : int ; r := 24 ;
     execute perfectSquares(l, r) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class apples {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
    char nextchar(){
      char ch=' ' ;
      try {
        ch=(char)br.read();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return ch ;
    }
  }
  public static void main(String[] args){
    FastReader x=new FastReader();
    StringBuilder str=new StringBuilder();
    int t=x.nextInt();
    while(t>0){
      long a=x.nextLong();
      long b=x.nextLong();
      long c=x.nextLong();
      long d=x.nextLong();
      long res=0 ;
      if(a<=b){
        res=b ;
      }
      else if(c<=d){
        res=-1 ;
      }
      else {
        res+=b ;
        a-=b ;
        long k=c-d ;
        k=(long)Math.ceil((double)a/(double)k);
        res+=k*c ;
      }
      str.append(res);
      str.append("\n");
      t--;
    }
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class apples {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextchar() : String
  pre: true
  post: true
  activity: (     var ch : String ; ch := ' ' ;
     try (     ch := br.read()->oclAsType(String) )   catch (e : IOException) do (     e.printStackTrace() )
     return ch );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : FastReader ; x := FastReader.newFastReader() ;
     var str : String ; str := StringLib.newString() ;
    var t : int ; t := x.nextInt() ;
    while (t > 0) do (     var a : long ; a := x.nextLong() ;
     var b : long ; b := x.nextLong() ;
    var c : long ; c := x.nextLong() ;
    var d : long ; d := x.nextLong() ;
    var res : long ; res := 0 ;
    if (a <= b) then (     res := b ) else     if (c <= d) then (     res := -1 ) else (     res := res+(b) ; 
     a := a-(b) ; 
    var k : long ; k := c - d ;
    k := (a->oclAsType(double) / k->oclAsType(double))->ceil()->oclAsType(long) ; 
    res := res+(k * c) ; 
 ) ;  ;  
    str := str + StringLib.newString(res) ; 
    str := str + StringLib.newString("\n") ; 
    t := t - 1 ; 
 ) ; 
    OclFile["System.out"].println(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      long a=sc.nextLong();
      long b=sc.nextLong();
      long c=sc.nextLong();
      long d=sc.nextLong();
      if(b>=a){
        System.out.println(b);
      }
      else if(c<=d){
        System.out.println(-1);
      }
      else {
        long cnt=c-d ;
        long ans=(a-b)/cnt ;
        if((a-b)% cnt!=0)ans++;
        System.out.println(b+(ans*c));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
    var c : long ; c := sc.getCurrent()->toLong() ;
    var d : long ; d := sc.getCurrent()->toLong() ;
    if (b >= a) then (     OclFile["System.out"].println(b) ) else     if (c <= d) then (     OclFile["System.out"].println(-1) ) else (     var cnt : long ; cnt := c - d ;
     var ans : long ; ans := (a - b) / cnt ;
     if ((a - b) mod cnt /= 0) then     ans := ans + 1 ; else skip ; 
     OclFile["System.out"].println(b + (ans * c)) ) ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Map.Entry ;
public class FindDuplicatedInArray {
  public static void main(String[] args){
    int arr[]={
      12,11,40,12,5,6,5,12,11 };
      int n=arr.length ;
      printDuplicates(arr,n);
    }
    private static void printDuplicates(int[] arr,int n){
      Map<Integer,Integer>map=new HashMap<>();
      int count=0 ;
      boolean dup=false ;
      for(int i=0 ; i<n ; i++){
        if(map.containsKey(arr[i])){
          count=map.get(arr[i]);
          map.put(arr[i],count+1);
        }
        else {
          map.put(arr[i],1);
        }
      }
      for(Entry<Integer,Integer>entry : map.entrySet()){
        if(entry.getValue()>1){
          System.out.print(entry.getKey()+" ");
          dup=true ;
        }
      }
      if(! dup){
        System.out.println("-1");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class FindDuplicatedInArray {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,11,40,12,5,6,5,12,11} ;
     var n : int ; n := arr->size() ;
     execute printDuplicates(arr, n) );
  static   operation printDuplicates( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var map : Map(int,int) ; map := Map{} ;
     var count : int ; count := 0 ;
    var dup : boolean ; dup := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (map->keys()->includes(arr[i+1])) then (     count := map->at(arr[i+1]) ; 
     map := map->union(Map{arr[i+1] |-> count + 1}) ) else (     map := map->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    for (entry : map->asSet()) do ( (     if (entry.getValue() > 1) then (     OclFile["System.out"].print(entry.getKey() + " ") ; 
     dup := true ) else skip )  ) ; 
    if (not(dup)) then (     OclFile["System.out"].println("-1") ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static MyScanner scanner ;
  public static void main(String[] args){
    Main instance=new Main();
    scanner=instance.new MyScanner();
    instance.solve();
  }
  private void solve(){
    try {
      int N=scanner.nextInt();
      int kisu=0,gusu=0 ;
      for(int i=0 ; i<N ; i++){
        long ai=scanner.nextLong();
        if(ai % 2==0){
          gusu++;
        }
        else {
          kisu++;
        }
      }
      gusu+=kisu/2 ;
      kisu=kisu-kisu/2*2 ;
      if(kisu==0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  private class MyScanner {
    String[] s ;
    int i ;
    BufferedReader br ;
    String reg=" " ;
    MyScanner(){
      s=new String[0];
      i=0 ;
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public String next()throws IOException {
      if(i<s.length)return s[i++];
      String line=br.readLine();
      while(line.equals("")){
        line=br.readLine();
      }
      s=line.split(reg,0);
      i=0 ;
      return s[i++];
    }
    public int nextInt()throws NumberFormatException,IOException {
      return Integer.parseInt(next());
    }
    public double nextDouble()throws NumberFormatException,IOException {
      return Double.parseDouble(next());
    }
    public long nextLong()throws NumberFormatException,IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : MyScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var instance : Main ; instance := Main.newMain() ;
     scanner := (instance).newMyScanner() ; 
     instance.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     try (     var N : int ; N := scanner.nextInt() ;
     var kisu : int ; kisu := 0 ;
    var gusu : int ; gusu := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var ai : long ; ai := scanner.nextLong() ;
     if (ai mod 2 = 0) then (     gusu := gusu + 1 ) else (     kisu := kisu + 1 ) )  ;     i := i + 1 ) ; 
    gusu := gusu+(kisu / 2) ; 
    kisu := kisu - kisu / 2 * 2 ; 
    if (kisu = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
 class MyScanner {
   attribute s : Sequence(String);
   attribute i : int;
   attribute br : OclFile;
   attribute reg : String := " ";
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     s := Integer.subrange(1,0)->collect(null) ; 
     i := 0 ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (i < s->size()) then     return s[i+1] else skip ; 
     var line : String ; line := br.readLine() ;
    while (line = "") do (     line := br.readLine() ) ; 
    s := line->split(reg) ; 
    i := 0 ; 
    return s[i+1] 
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPrime(int n){
    if(n<=1)return false ;
    for(int i=2 ; i<n ; i++)if(n % i==0)return false ;
    return true ;
  }
  static int findPrime(int n){
    int num=n+1 ;
    while(num>0){
      if(isPrime(num))return num ;
      num=num+1 ;
    }
    return 0 ;
  }
  static int minNumber(int arr[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=arr[i];
    if(isPrime(sum))return 0 ;
    int num=findPrime(sum);
    return num-sum ;
  }
  public static void main(String[] args){
    int arr[]={
      2,4,6,8,12 };
      int n=arr.length ;
      System.out.println(minNumber(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
         var i : int ; i := 2 ; while i < n do (     if (n mod i = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation findPrime( n : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := n + 1 ;
     while (num > 0) do (     if (isPrime(num)) then     return num else skip ; 
     num := num + 1 ) ; 
     return 0 );
  static   operation minNumber( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    if (isPrime(sum)) then     return 0 else skip ; 
    var num : int ; num := findPrime(sum) ;
    return num - sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,6,8,12} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minNumber(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Scanner ;
class Main {
  public static void main(String args[])throws IOException {
    @ SuppressWarnings("resource")Scanner cin=new Scanner(System.in);
    ArrayList<String>inLines=new ArrayList<String>();
    for(; cin.hasNext(); ){
      inLines.add(cin.nextLine());
    }
    Solver solver=new Solver();
    solver.solve(inLines);
  }
}
class Solver {
  public void solve(ArrayList<String>inLines){
    int N=Integer.parseInt(inLines.get(0));
    String[] strArr=inLines.get(1).split(" ");
    boolean ans=true ;
    for(int i=0 ; i<N ; i++){
      if(Long.parseLong(strArr[i])% 2==1)ans=! ans ;
    }
    if(ans)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inLines : Sequence(String) ; inLines := Sequence{} ;
      while cin.hasNext() do ( (     inLines := inLines->including(cin.nextLine()) )  ) ; 
    var solver : Solver ; solver := Solver.newSolver() ;
    solver.solve(inLines) ; 
 );
}
class Solver {
   operation solve( inLines : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := (inLines->at(0+1))->toInteger() ;
     var strArr : Sequence(String) ; strArr := inLines->at(1+1)->split(" ") ;
    var ans : boolean ; ans := true ;
        var i : int ; i := 0 ; while i < N do ( (     if ((strArr[i+1])->toLong() mod 2 = 1) then     ans := not(ans) ; else skip )  ;     i := i + 1 ) ; 
    if (ans) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  private static final int MOD=(int)Math.pow(10,9);
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    int[] count=new int[2];
    for(int i=0 ; i<n ; i++){
      count[sc.nextInt()% 2]++;
    }
    while(count[0]>1 || count[1]>1){
      if(count[0]>=2){
        count[0]--;
      }
      if(count[1]>=2){
        count[1]-=2 ;
        count[0]++;
      }
    }
    if((count[0]==0 && count[1]==1)||(count[0]==1 && count[1]==0)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
  private static int findDigit(int num){
    int res=0 ;
    while(num>0){
      res+=(num % 10);
      num/=10 ;
    }
    return res ;
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 10->pow(9)->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : int ; n := sc.nextInt() ;
    var count : Sequence(int) ; count := Integer.subrange(1,2)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     count[sc.nextInt() mod 2+1] := count[sc.nextInt() mod 2+1] + 1 )  ;     i := i + 1 ) ; 
    while (count[0+1] > 1 or count[1+1] > 1) do (     if (count[0+1] >= 2) then (     count[0+1] := count[0+1] - 1 ) else skip ; 
     if (count[1+1] >= 2) then (     count[1+1] := count[1+1]-(2) ; 
     count[0+1] := count[0+1] + 1 ) else skip ) ; 
    if ((count[0+1] = 0 & count[1+1] = 1) or (count[0+1] = 1 & count[1+1] = 0)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
  static   operation findDigit( num : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     while (num > 0) do (     res := res+((num mod 10)) ; 
     num := num/(10) ) ; 
     return res );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.Closeable ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.LinkedList ;
import java.util.PriorityQueue ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    final Scanner sc=new Scanner(System.in);
    final int N=sc.nextInt();
    int odd=0,even=0 ;
    for(int i=0 ; i<N ; i++){
      final long input=sc.nextLong();
      if(input % 2==0){
        even++;
      }
      else {
        odd++;
      }
    }
    if(odd % 2==1){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
    }
  }
  public static class Scanner implements Closeable {
    private BufferedReader br ;
    private StringTokenizer tok ;
    public Scanner(InputStream is)throws IOException {
      br=new BufferedReader(new InputStreamReader(is));
    }
    private void getLine()throws IOException {
      while(! hasNext()){
        tok=new StringTokenizer(br.readLine());
      }
    }
    private boolean hasNext(){
      return tok!=null && tok.hasMoreTokens();
    }
    public String next()throws IOException {
      getLine();
      return tok.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public int[] nextIntArray(int n)throws IOException {
      final int[] ret=new int[n];
      for(int i=0 ; i<n ; i++){
        ret[i]=this.nextInt();
      }
      return ret ;
    }
    public void close()throws IOException {
      br.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var odd : int ; odd := 0 ;
    var even : int ; even := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var input : long ; input := sc.getCurrent()->toLong() ;
     if (input mod 2 = 0) then (     even := even + 1 ) else (     odd := odd + 1 ) )  ;     i := i + 1 ) ; 
    if (odd mod 2 = 1) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 );
  static class Scanner implements Closeable {
   attribute br : OclFile;
   attribute tok : OclIterator;
   static operation newScanner( is : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
   operation getLine() : void
  pre: true
  post: true
  activity: (     while (not(hasNext())) do (     tok := OclIterator.newOclIterator_String(br.readLine()) ) );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return tok /= null & tok.hasNext() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute getLine() ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ret : Sequence(int) ; ret := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     ret[i+1] := self.nextInt() )  ;     i := i + 1 ) ; 
     return ret );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  void solve()throws IOException {
    int n=ni();
    int[] a=nia(n);
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i] % 2==1)cnt++;
    }
    if(cnt % 2==1){
      out.println("NO");
    }
    else {
      out.println("YES");
    }
  }
  String ns()throws IOException {
    while(! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine()," ");
    }
    return tok.nextToken();
  }
  int ni()throws IOException {
    return Integer.parseInt(ns());
  }
  long nl()throws IOException {
    return Long.parseLong(ns());
  }
  double nd()throws IOException {
    return Double.parseDouble(ns());
  }
  String[] nsa(int n)throws IOException {
    String[] res=new String[n];
    for(int i=0 ; i<n ; i++){
      res[i]=ns();
    }
    return res ;
  }
  int[] nia(int n)throws IOException {
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=ni();
    }
    return res ;
  }
  long[] nla(int n)throws IOException {
    long[] res=new long[n];
    for(int i=0 ; i<n ; i++){
      res[i]=nl();
    }
    return res ;
  }
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  public static void main(String[] args)throws IOException {
    in=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(System.out);
    tok=new StringTokenizer("");
    Main main=new Main();
    main.solve();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := ni() ;
     var a : Sequence(int) ; a := nia(n) ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] mod 2 = 1) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (cnt mod 2 = 1) then (     out.println("NO") ) else (     out.println("YES") ) ;  
 );
   operation ns() : String
  pre: true
  post: true
  activity: (     while (not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String_String(in.readLine(), " ") ) ; 
     return tok.next() );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (ns())->toInteger() );
   operation nl() : long
  pre: true
  post: true
  activity: (     return (ns())->toLong() );
   operation nd() : double
  pre: true
  post: true
  activity: (     return (ns())->toReal() );
   operation nsa( n : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var res : Sequence(String) ; res := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := ns() )  ;     i := i + 1 ) ; 
     return res );
   operation nia( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := ni() )  ;     i := i + 1 ) ; 
     return res );
   operation nla( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var res : Sequence(long) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := nl() )  ;     i := i + 1 ) ; 
     return res );
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    tok := OclIterator.newOclIterator_String("") ; 
    var main : Main ; main := Main.newMain() ;
    main.solve() ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findMissingUtil(int arr[],int low,int high,int diff){
    if(high<=low)return Integer.MAX_VALUE ;
    int mid=low+(high-low)/2 ;
    if(arr[mid+1]-arr[mid]!=diff)return(arr[mid]+diff);
    if(mid>0 && arr[mid]-arr[mid-1]!=diff)return(arr[mid-1]+diff);
    if(arr[mid]==arr[0]+mid*diff)return findMissingUtil(arr,mid+1,high,diff);
    return findMissingUtil(arr,low,mid-1,diff);
  }
  static int findMissing(int arr[],int n){
    int diff=(arr[n-1]-arr[0])/n ;
    return findMissingUtil(arr,0,n-1,diff);
  }
  public static void main(String[] args){
    int arr[]={
      2,4,8,10,12,14 };
      int n=arr.length ;
      System.out.println("The missing element is "+findMissing(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMissingUtil( arr : Sequence(int), low : int, high : int, diff : int) : int
  pre: true
  post: true
  activity: (     if (high <= low) then     return 2147483647 else skip ; 
     var mid : int ; mid := low + (high - low) / 2 ;
    if (arr[mid + 1+1] - arr[mid+1] /= diff) then     return (arr[mid+1] + diff) else skip ; 
    if (mid > 0 & arr[mid+1] - arr[mid - 1+1] /= diff) then     return (arr[mid - 1+1] + diff) else skip ; 
    if (arr[mid+1] = arr[0+1] + mid * diff) then     return findMissingUtil(arr, mid + 1, high, diff) else skip ; 
    return findMissingUtil(arr, low, mid - 1, diff) 
 );
  static   operation findMissing( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var diff : int ; diff := (arr[n - 1+1] - arr[0+1]) / n ;
     return findMissingUtil(arr, 0, n - 1, diff) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,8,10,12,14} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("The missing element is " + findMissing(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
class GFG {
  static boolean CheckArray(int arr[],int n){
    int prod=1 ;
    ArrayList<Integer>freq=new ArrayList<>();
    for(int i=0 ; i<n ; ++i){
      freq.add(arr[i]);
      prod*=arr[i];
    }
    int root=(int)Math.sqrt(prod);
    if(root*root==prod){
      if(freq.contains(root)& freq.lastIndexOf(root)!=(freq.size())){
        return true ;
      }
    }
    return false ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,12,3,2 };
      int n=arr.length ;
      if(CheckArray(arr,n)){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation CheckArray( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var prod : int ; prod := 1 ;
     var freq : Sequence(int) ; freq := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     freq := freq->including(arr[i+1]) ; 
     prod := prod*(arr[i+1]) )  ;     i := i + 1 ) ; 
    var root : int ; root := (prod)->sqrt()->oclAsType(int) ;
    if (root * root = prod) then (     if (freq->includes(root) & freq->lastIndexOf(root)-1 /= (freq->size())) then (     return true ) else skip ) else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,12,3,2} ;
     var n : int ; n := arr->size() ;
     if (CheckArray(arr, n)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int[] a=new int[n];
    Arrays.setAll(a,i->in.nextInt());
    int ans=Integer.MAX_VALUE ;
    int T=0 ;
    for(int k=1 ; k<=100 ; k++){
      int res=0 ;
      for(int i=0 ; i<n ; i++){
        if(k==a[i])continue ;
        int v1=Math.abs((k+1)-a[i]);
        int v2=Math.abs((k-1)-a[i]);
        res+=Math.min(v1,v2);
      }
      if(ans>res){
        ans=res ;
        T=k ;
      }
    }
    pw.println(T+" "+ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
setAll(a, lambda i : OclAny in in.getCurrent()->toInteger()) ; 
    var ans : int ; ans := 2147483647 ;
    var T : int ; T := 0 ;
        var k : int ; k := 1 ; while k <= 100 do ( (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (k = a[i+1]) then     continue else skip ; 
     var v1 : int ; v1 := if (k + 1) - a[i+1] < 0 then -((k + 1) - a[i+1]) else (k + 1) - a[i+1] endif ;
     var v2 : int ; v2 := if (k - 1) - a[i+1] < 0 then -((k - 1) - a[i+1]) else (k - 1) - a[i+1] endif ;
     res := res+(Set{v1, v2}->min()) )  ;     i := i + 1 ) ; 
     if (ans > res) then (     ans := res ; 
     T := k ) else skip )  ;     k := k + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    Arrays.sort(a);
    int cost=0 ;
    int ans1=0 ;
    int ans=Integer.MAX_VALUE ;
    for(int i=a[0]; i<=a[n-1]; i++){
      int t=i ;
      cost=0 ;
      for(int j=0 ; j<n ; j++){
        if(Math.abs(t-a[j])>1){
          cost+=Math.abs(t-a[j])-1 ;
        }
      }
      if(cost<ans){
        ans=cost ;
        ans1=t ;
      }
    }
    System.out.println(ans1+" "+ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var cost : int ; cost := 0 ;
    var ans1 : int ; ans1 := 0 ;
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := a[0+1] ; while i <= a[n - 1+1] do ( (     var t : int ; t := i ;
     cost := 0 ; 
         var j : int ; j := 0 ; while j < n do ( (     if (if t - a[j+1] < 0 then -(t - a[j+1]) else t - a[j+1] endif > 1) then (     cost := cost+(if t - a[j+1] < 0 then -(t - a[j+1]) else t - a[j+1] endif - 1) ) else skip )  ;     j := j + 1 ) ; 
     if (cost < ans) then (     ans := cost ; 
     ans1 := t ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans1 + " " + ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SalemAndSticks {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    int ans=Integer.MAX_VALUE,t=0 ;
    for(int i=1 ; i<=100 ; i++){
      int sum=0 ;
      for(int j=0 ; j<n ; j++){
        if(arr[j]>i)sum+=(arr[j]-(i+1));
        else if(arr[j]<i)sum+=(i-1-arr[j]);
      }
      if(sum<ans){
        ans=sum ;
        t=i ;
      }
    }
    System.out.println(t+" "+ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class SalemAndSticks {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
    var t : int ; t := 0 ;
        var i : int ; i := 1 ; while i <= 100 do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (arr[j+1] > i) then     sum := sum+((arr[j+1] - (i + 1))) ; else     if (arr[j+1] < i) then     sum := sum+((i - 1 - arr[j+1])) ; else skip ; )  ;     j := j + 1 ) ; 
     if (sum < ans) then (     ans := sum ; 
     t := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(t + " " + ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    String[] bit=new String[10];
    bit[0]="0111111" ;
    bit[1]="0000110" ;
    bit[2]="1011011" ;
    bit[3]="1001111" ;
    bit[4]="1100110" ;
    bit[5]="1101101" ;
    bit[6]="1111101" ;
    bit[7]="0100111" ;
    bit[8]="1111111" ;
    bit[9]="1101111" ;
    int n,x ;
    String[] segment=new String[2];
    while(true){
      try {
        n=Integer.parseInt(reader.readLine());
        if(n==-1)break ;
        segment[0]="0000000" ;
        for(int i=0 ; i<n ; i++){
          segment[1]="" ;
          x=Integer.parseInt(reader.readLine());
          for(int j=0 ; j<7 ; j++)segment[1]+=String.valueOf(Integer.parseInt(String.valueOf(segment[0] .charAt(j)))^ Integer.parseInt(String.valueOf(bit[x] .charAt(j))));
          System.out.println(segment[1]);
          segment[0]=bit[x];
        }
      }
      catch(IOException e){
      }
    }
    try {
      reader.close();
    }
    catch(IOException e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bit : Sequence(String) ; bit := Integer.subrange(1,10)->collect(null) ;
    bit[0+1] := "0111111" ; 
    bit[1+1] := "0000110" ; 
    bit[2+1] := "1011011" ; 
    bit[3+1] := "1001111" ; 
    bit[4+1] := "1100110" ; 
    bit[5+1] := "1101101" ; 
    bit[6+1] := "1111101" ; 
    bit[7+1] := "0100111" ; 
    bit[8+1] := "1111111" ; 
    bit[9+1] := "1101111" ; 
    var n : int ;
    var x : int ;
    var segment : Sequence(String) ; segment := Integer.subrange(1,2)->collect(null) ;
    while (true) do (     try (     n := (reader.readLine())->toInteger() ; 
     if (n = -1) then     break else skip ; 
     segment[0+1] := "0000000" ; 
         var i : int ; i := 0 ; while i < n do ( (     segment[1+1] := "" ; 
     x := (reader.readLine())->toInteger() ; 
        var j : int ; j := 0 ; while j < 7 do (     segment[1+1] := segment[1+1]+(((MathLib.bitwiseXor((((segment[0+1]->at(j+1)) + ""))->toInteger(),(((bit[x+1]->at(j+1)) + ""))->toInteger())) + "")) ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(segment[1+1]) ; 
    segment[0+1] := bit[x+1] ; 
 )  ;     i := i + 1 ) )   catch (e : IOException) do skip
 ) ; 
    try (     skip )   catch (e : IOException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String str=in.readLine();
    String[] vowel={
      "w","","k","s","t","n","h","m","y","r" };
      for(int i=0 ; i<str.length(); i+=2){
        char m=str.charAt(i);
        char c=str.charAt(i+1);
        if(m=='0' && c=='U'){
          System.out.print("nn");
        }
        else {
          System.out.print(vowel[m-'0']);
          switch(c){
            case 'T' : System.out.print('a');
            break ;
            case 'L' : System.out.print('i');
            break ;
            case 'U' : System.out.print('u');
            break ;
            case 'R' : System.out.print('e');
            break ;
            case 'D' : System.out.print('o');
            break ;
          }
        }
      }
      System.out.println();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := in.readLine() ;
    var vowel : Sequence(String) ; vowel := Sequence{"w","","k","s","t","n","h","m","y","r"} ;
        var i : int ; i := 0 ; while i < str->size() do ( (     var m : String ; m := str->at(i+1) ;
     var c : String ; c := str->at(i + 1+1) ;
     if (m = '0' & c = 'U') then (     OclFile["System.out"].print("nn") ) else (     OclFile["System.out"].print(vowel[(m)->char2byte() - ('0')->char2byte()+1]) ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
       if _switchval = 'T' then
     OclFile["System.out"].print('a') ; 
    break 
   else skip ;
       if _switchval = 'L' then
     OclFile["System.out"].print('i') ; 
    break 
   else skip ;
       if _switchval = 'U' then
     OclFile["System.out"].print('u') ; 
    break 
   else skip ;
       if _switchval = 'R' then
     OclFile["System.out"].print('e') ; 
    break 
   else skip ;
       if _switchval = 'D' then
     OclFile["System.out"].print('o') ; 
    break 
   else skip ;
 )
 ) )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.geom.*;
public class Main {
  String[][] table={
    {
      "wa","","nn","","wo" },{
        "a","i","u","e","o" },{
          "ka","ki","ku","ke","ko" },{
            "sa","si","su","se","so" },{
              "ta","ti","tu","te","to" },{
                "na","ni","nu","ne","no" },{
                  "ha","hi","hu","he","ho" },{
                    "ma","mi","mu","me","mo" },{
                      "ya","","yu","","yo" },{
                        "ra","ri","ru","re","ro" },};
                        String order="TLURD" ;
                        private void doit(){
                          Scanner sc=new Scanner(System.in);
                          while(sc.hasNext()){
                            String s=sc.next();
                            for(int i=0 ; i<s.length(); i+=2){
                              char c1=s.charAt(i);
                              char c2=s.charAt(i+1);
                              int num1=c1-'0' ;
                              int num2=order.indexOf(c2+"");
                              System.out.print(table[num1][num2]);
                            }
                            System.out.println();
                          }
                        }
                        private void debug(Object...o){
                          System.out.println("debug="+Arrays.deepToString(o));
                        }
                        public static void main(String[] args){
                          new Main().doit();
                        }
                      }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute table : Sequence(Sequence(String)) := Sequence{Sequence{"wa","","nn","","wo"},Sequence{"a","i","u","e","o"},Sequence{"ka","ki","ku","ke","ko"},Sequence{"sa","si","su","se","so"},Sequence{"ta","ti","tu","te","to"},Sequence{"na","ni","nu","ne","no"},Sequence{"ha","hi","hu","he","ho"},Sequence{"ma","mi","mu","me","mo"},Sequence{"ya","","yu","","yo"},Sequence{"ra","ri","ru","re","ro"},};
   attribute order : String := "TLURD";
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var s : String ; s := sc.getCurrent() ;
         var i : int ; i := 0 ; while i < s->size() do ( (     var c1 : String ; c1 := s->at(i+1) ;
     var c2 : String ; c2 := s->at(i + 1+1) ;
    var num1 : int ; num1 := (c1)->char2byte() - ('0')->char2byte() ;
    var num2 : int ; num2 := order->indexOf(c2 + "")-1 ;
    OclFile["System.out"].print(table[num1+1][num2+1]) ; 
 )  ;     i := i+(2) ) ; 
     OclFile["System.out"].println() ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String args[])throws IOException {
    InputStreamReader in=new InputStreamReader(System.in);
    BufferedReader bf=new BufferedReader(in);
    String str=bf.readLine();
    char[] ch=str.toCharArray();
    for(int i=0 ; i<ch.length/2 ; i++){
      output(Integer.parseInt(""+ch[i*2]),ch[i*2+1]);
    }
    System.out.println();
  }
  static void output(int i,char c){
    switch(i){
      case 0 : if(c=='T'){
        System.out.print("wa");
      }
      else if(c=='U'){
        System.out.print("nn");
      }
      else if(c=='D'){
        System.out.print("wo");
      }
      return ;
      case 1 : break ;
      case 2 : System.out.print("k");
      break ;
      case 3 : System.out.print("s");
      break ;
      case 4 : System.out.print("t");
      break ;
      case 5 : System.out.print("n");
      break ;
      case 6 : System.out.print("h");
      break ;
      case 7 : System.out.print("m");
      break ;
      case 8 : System.out.print("y");
      break ;
      case 9 : System.out.print("r");
      break ;
    }
    switch(c){
      case 'T' : System.out.print("a");
      return ;
      case 'L' : System.out.print("i");
      return ;
      case 'U' : System.out.print("u");
      return ;
      case 'R' : System.out.print("e");
      return ;
      case 'D' : System.out.print("o");
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var bf : OclFile ; bf := OclFile.newOclFile_Read(in) ;
    var str : String ; str := bf.readLine() ;
    var ch : Sequence(String) ; ch := str->characters() ;
        var i : int ; i := 0 ; while i < ch->size() / 2 do ( (     execute output(("" + ch[i * 2+1])->toInteger(), ch[i * 2 + 1+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation output( i : int, c : String) : void
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (i) ; 
       if _switchval = 0 then
     if (c = 'T') then (     OclFile["System.out"].print("wa") ) else     if (c = 'U') then (     OclFile["System.out"].print("nn") ) else     if (c = 'D') then (     OclFile["System.out"].print("wo") ) else skip ; ;  ;  
    return 
   else skip ;
       if _switchval = 1 then
     break 
   else skip ;
       if _switchval = 2 then
     OclFile["System.out"].print("k") ; 
    break 
   else skip ;
       if _switchval = 3 then
     OclFile["System.out"].print("s") ; 
    break 
   else skip ;
       if _switchval = 4 then
     OclFile["System.out"].print("t") ; 
    break 
   else skip ;
       if _switchval = 5 then
     OclFile["System.out"].print("n") ; 
    break 
   else skip ;
       if _switchval = 6 then
     OclFile["System.out"].print("h") ; 
    break 
   else skip ;
       if _switchval = 7 then
     OclFile["System.out"].print("m") ; 
    break 
   else skip ;
       if _switchval = 8 then
     OclFile["System.out"].print("y") ; 
    break 
   else skip ;
       if _switchval = 9 then
     OclFile["System.out"].print("r") ; 
    break 
   else skip ;
 )
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
       if _switchval = 'T' then
     OclFile["System.out"].print("a") ; 
    return 
   else skip ;
       if _switchval = 'L' then
     OclFile["System.out"].print("i") ; 
    return 
   else skip ;
       if _switchval = 'U' then
     OclFile["System.out"].print("u") ; 
    return 
   else skip ;
       if _switchval = 'R' then
     OclFile["System.out"].print("e") ; 
    return 
   else skip ;
       if _switchval = 'D' then
     OclFile["System.out"].print("o") ; 
    return 
   else skip ;
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    String[] s={
      "a","i","u","e","o" };
      String[] b={
        "w","a","k","s","t","n","h","m","y","r" };
        char[] r=sc.next().toCharArray();
        StringBuilder res=new StringBuilder();
        for(int i=0 ; i<r.length ; i+=2){
          int id=r[i]-'0' ;
          int x=r[i+1]=='T' ? 0 : r[i+1]=='L' ? 1 : r[i+1]=='U' ? 2 : r[i+1]=='R' ? 3 : 4 ;
          if(id==1)res.append(s[x]);
          else if(id==0){
            if(x==0)res.append("wa");
            else if(x==2)res.append("nn");
            else res.append("wo");
          }
          else res.append(b[id]+s[x]);
        }
        System.out.println(res);
      }
      public static void main(String[] args){
        new Main().run();
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := Sequence{"a","i","u","e","o"} ;
    var b : Sequence(String) ; b := Sequence{"w","a","k","s","t","n","h","m","y","r"} ;
    var r : Sequence(String) ; r := sc.getCurrent()->characters() ;
    var res : String ; res := StringLib.newString() ;
        var i : int ; i := 0 ; while i < r->size() do ( (     var id : int ; id := r[i+1] - ('0')->char2byte() ;
     var x : int ; x := if r[i + 1+1] = 'T' then 0 else if r[i + 1+1] = 'L' then 1 else if r[i + 1+1] = 'U' then 2 else if r[i + 1+1] = 'R' then 3 else 4 endif endif endif endif ;
     if (id = 1) then     res := res + StringLib.newString(s[x+1]) ; else     if (id = 0) then (     if (x = 0) then     res := res + StringLib.newString("wa") ; else     if (x = 2) then     res := res + StringLib.newString("nn") else     res := res + StringLib.newString("wo") ; ;  ) else     res := res + StringLib.newString(b[id+1] + s[x+1]) ; ;  )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    int k ;
    String c ;
    String str="" ;
    try {
      str=new BufferedReader(new InputStreamReader(System.in)).readLine();
    }
    catch(IOException e){
      e.printStackTrace();
    }
    String result="" ;
    for(int i=0 ; i<str.length()/2 ; i++){
      k=Integer.parseInt(str.substring(2*i,2*i+1));
      c=str.substring(2*i+1,2*(i+1));
      result+=translator(k,c);
    }
    System.out.println(result);
  }
  private static String translator(int k,String c){
    String result="" ;
    int[] nums={
      0,1,2,3,4,5,6,7,8,9 };
      String[] cons={
        "w","","k","s","t","n","h","m","y","r" };
        String[] dir={
          "T","L","U","R","D" };
          String[] vowel={
            "a","i","u","e","o" };
            if(k==0 && c.equals("U")){
              result+="nn" ;
            }
            else {
              for(int i=0 ; i<nums.length ; i++){
                if(nums[i]==k){
                  result+=cons[i];
                }
              }
              for(int i=0 ; i<dir.length ; i++){
                if(c.equals(dir[i])){
                  result+=vowel[i];
                }
              }
            }
            return result ;
          }
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ;
     var c : String ;
    var str : String ; str := "" ;
    try (     str := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])).readLine() )   catch (e : IOException) do (     e.printStackTrace() )
    var result : String ; result := "" ;
        var i : int ; i := 0 ; while i < str->size() / 2 do ( (     k := (str.subrange(2 * i+1,2 * i + 1))->toInteger() ; 
     c := str.subrange(2 * i + 1+1,2 * (i + 1)) ; 
     result := result+(translator(k, c)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation translator( k : int, c : String) : String
  pre: true
  post: true
  activity: (     var result : String ; result := "" ;
     var nums : Sequence(int) ; nums := Sequence{0,1,2,3,4,5,6,7,8,9} ;
    var cons : Sequence(String) ; cons := Sequence{"w","","k","s","t","n","h","m","y","r"} ;
    var dir : Sequence(String) ; dir := Sequence{"T","L","U","R","D"} ;
    var vowel : Sequence(String) ; vowel := Sequence{"a","i","u","e","o"} ;
    if (k = 0 & c = "U") then (     result := result+("nn") ) else (         var i : int ; i := 0 ; while i < nums->size() do ( (     if (nums[i+1] = k) then (     result := result+(cons[i+1]) ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < dir->size() do ( (     if (c = dir[i+1]) then (     result := result+(vowel[i+1]) ) else skip )  ;     i := i + 1 ) ) ;  
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int Square(int row,int column,int moves){
    int a=0,b=0,c=0,d=0,total=0 ;
    a=row-moves ;
    b=row+moves ;
    c=column-moves ;
    d=column+moves ;
    if(a<1)a=1 ;
    if(c<1)c=1 ;
    if(b>8)b=8 ;
    if(d>8)d=8 ;
    total=(b-a+1)*(d-c+1)-1 ;
    return total ;
  }
  public static void main(String[] args){
    int R=4,C=5,M=2 ;
    System.out.println(Square(R,C,M));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Square( row : int, column : int, moves : int) : int
  pre: true
  post: true
  activity: (     var a : int ; a := 0 ;
    var b : int ; b := 0 ;
    var c : int ; c := 0 ;
    var d : int ; d := 0 ;
    var total : int ; total := 0 ;
     a := row - moves ; 
    b := row + moves ; 
    c := column - moves ; 
    d := column + moves ; 
    if (a < 1) then     a := 1 ; else skip ; 
    if (c < 1) then     c := 1 ; else skip ; 
    if (b > 8) then     b := 8 ; else skip ; 
    if (d > 8) then     d := 8 ; else skip ; 
    total := (b - a + 1) * (d - c + 1) - 1 ; 
    return total 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var R : int ; R := 4 ;
    var C : int ; C := 5 ;
    var M : int ; M := 2 ;
     OclFile["System.out"].println(Square(R, C, M)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static PrintWriter out=new PrintWriter(System.out);
  static Scanner in=new Scanner(System.in);
  static BufferedReader re=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter wr=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws IOException {
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int T=in.nextInt();
    while(T>0){
      long a=in.nextLong();
      long b=in.nextLong();
      long c=in.nextLong();
      long res=(a+2*b+3*c)% 2 ;
      out.println(res);
      T--;
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute re : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute wr : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
     while (T > 0) do (     var a : long ; a := in.getCurrent()->toLong() ;
     var b : long ; b := in.getCurrent()->toLong() ;
    var c : long ; c := in.getCurrent()->toLong() ;
    var res : long ; res := (a + 2 * b + 3 * c) mod 2 ;
    skip ; 
    T := T - 1 ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findNumbers(int N){
    int i=1 ;
    while(i<=N){
      System.out.print((i*i*i)+" ");
      i++;
    }
  }
  public static void main(String[] args){
    int N=4 ;
    findNumbers(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNumbers( N : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 1 ;
     while (i <= N) do (     OclFile["System.out"].print((i * i * i) + " ") ; 
     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     execute findNumbers(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int powmod(int x,int y,int p){
    int res=1 ;
    x=x % p ;
    while(y>0){
      if((y & 1)>0)res=(res*x)% p ;
      y=y>>1 ;
      x=(x*x)% p ;
    }
    return res ;
  }
  static int discreteLogarithm(int a,int b,int m){
    int n=(int)(Math.sqrt(m)+1);
    int[] value=new int[m];
    for(int i=n ; i>=1 ; --i)value[powmod(a,i*n,m)]=i ;
    for(int j=0 ; j<n ; ++j){
      int cur=(powmod(a,j,m)*b)% m ;
      if(value[cur]>0){
        int ans=value[cur]*n-j ;
        if(ans<m)return ans ;
      }
    }
    return-1 ;
  }
  public static void main(String[] args){
    int a=2,b=3,m=5 ;
    System.out.println(discreteLogarithm(a,b,m));
    a=3 ;
    b=7 ;
    m=11 ;
    System.out.println(discreteLogarithm(a,b,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation powmod( x : int, y : int, p : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     if ((y & 1) > 0) then     res := (res * x) mod p ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res );
  static   operation discreteLogarithm( a : int, b : int, m : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := ((m)->sqrt() + 1)->oclAsType(int) ;
     var value : Sequence(int) ; value := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := n ; while i >= 1 do (     value[powmod(a, i * n, m)+1] := i ;  ;     i := i - 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     var cur : int ; cur := (powmod(a, j, m) * b) mod m ;
     if (value[cur+1] > 0) then (     var ans : int ; ans := value[cur+1] * n - j ;
     if (ans < m) then     return ans else skip ) else skip )  ;     j := j + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2 ;
    var b : int ; b := 3 ;
    var m : int ; m := 5 ;
     OclFile["System.out"].println(discreteLogarithm(a, b, m)) ; 
    a := 3 ; 
    b := 7 ; 
    m := 11 ; 
    OclFile["System.out"].println(discreteLogarithm(a, b, m)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int Circumference(int l,int w){
    return(2*(l+w));
  }
  static public void main(String[] args){
    int l=8,w=4 ;
    int c=Circumference(l,w);
    System.out.println("Circumference of "+"a rectangle is "+c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Circumference( l : int, w : int) : int
  pre: true
  post: true
  activity: (     return (2 * (l + w)) );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 8 ;
    var w : int ; w := 4 ;
     var c : int ; c := Circumference(l, w) ;
     OclFile["System.out"].println("Circumference of " + "a rectangle is " + c) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Test {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int n ;
    while(t--!=0){
      n=sc.nextInt();
      int count=0 ;
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      Arrays.sort(arr);
      for(int i=0 ; i<n ; i++){
        count+=arr[i]-arr[0];
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     var n : int ;
         while (t /= 0) do (    skip ; (     n := sc.getCurrent()->toInteger() ; 
     var count : int ; count := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     count := count+(arr[i+1] - arr[0+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double edgeDisjoint(int n){
    double result=0 ;
    result=Math.floor(n/2);
    return result ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println((int)edgeDisjoint(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation edgeDisjoint( n : int) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
     result := (n / 2)->floor() ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(edgeDisjoint(n)->oclAsType(int)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
public class B792 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int K=in.nextInt();
    int[] A=new int[K];
    for(int k=0 ; k<K ; k++){
      A[k]=in.nextInt();
    }
    List<Integer>list=new LinkedList<>();
    for(int n=1 ; n<=N ; n++){
      list.add(n);
    }
    StringBuilder output=new StringBuilder();
    int pos=0 ;
    for(int k=0 ; k<K ; k++){
      pos+=A[k];
      pos %=list.size();
      output.append(list.get(pos)).append(' ');
      list.remove(pos);
    }
    System.out.println(output);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B792 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,K)->collect(0) ;
        var k : int ; k := 0 ; while k < K do ( (     A[k+1] := in.getCurrent()->toInteger() )  ;     k := k + 1 ) ; 
    var list : Sequence(int) ; list := Sequence{} ;
        var n : int ; n := 1 ; while n <= N do ( (     list := list->including(n) )  ;     n := n + 1 ) ; 
    var output : String ; output := StringLib.newString() ;
    var pos : int ; pos := 0 ;
        var k : int ; k := 0 ; while k < K do ( (     pos := pos+(A[k+1]) ; 
     pos := pos mod list->size() ; 
     output := output + StringLib.newString(list->at(pos+1)) + StringLib.newString(' ') ; 
     list := list->excludingAt(pos+1) )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(output) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.io.InputStreamReader ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
import java.util.*;
import java.math.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 long[] ans=new long[100001];
  public static void main(String[] args)throws java.lang.Exception {
    FastReader sc=new FastReader();
    PrintWriter pw=new PrintWriter(System.out);
    int t=1 ;
    while(t-->0){
      int n=sc.nextInt(),k=sc.nextInt();
      int a[]=new int[k],c=1 ;
      for(int i=0 ; i<k ; i++){
        a[i]=sc.nextInt();
      }
      List<Integer>l=new ArrayList<>();
      for(int i=0 ; i<n ; i++)l.add(i+1);
      int pos=0 ;
      for(int i=0 ; i<k ; i++){
        int nxt=(pos+a[i])% l.size();
        int d=l.remove(nxt);
        pw.print(d+" ");
        pos=nxt ;
      }
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   attribute ans : Sequence(long) := Integer.subrange(1,100001)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := 1 ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.nextInt() ;
    var k : int ; k := sc.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,k)->collect(0) ;
    var c : int ; c := 1 ;
        var i : int ; i := 0 ; while i < k do ( (     a[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    var l : Sequence(int) ; l := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     l := l->including(i + 1) ;  ;     i := i + 1 ) ; 
    var pos : int ; pos := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     var nxt : int ; nxt := (pos + a[i+1]) mod l->size() ;
     var d : int ; d := l->at(nxt+1) ;
     skip ; 
     pos := nxt )  ;     i := i + 1 ) ; 
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    int k=Integer.parseInt(st.nextToken());
    StringBuilder sb=new StringBuilder();
    st=new StringTokenizer(br.readLine());
    int[] ar=new int[k];
    for(int i=0 ; i<k ; i++){
      ar[i]=Integer.parseInt(st.nextToken());
    }
    List<Integer>people=new LinkedList<>();
    for(int i=0 ; i<n ; i++){
      people.add(i+1);
    }
    int ptr=0 ;
    for(int i=0 ; i<k ; i++){
      int times=ar[i];
      ptr=(ptr+times)% people.size();
      sb.append(people.get(ptr)).append(" ");
      people.remove(ptr);
      if(ptr==people.size()+1){
        ptr=0 ;
      }
    }
    System.out.println(sb);
  }
  public static void swap(int[] ar,int i,int j){
    int temp=ar[i];
    ar[i]=ar[j];
    ar[j]=temp ;
  }
  public static class Pair {
    int x ;
    int y ;
    Pair(int x,int y){
      this.x=x ;
      this.y=y ;
    }
    public int getX(){
      return x ;
    }
    public int getY(){
      return y ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var k : int ; k := (st.next())->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    var ar : Sequence(int) ; ar := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     ar[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    var people : Sequence(int) ; people := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     people := people->including(i + 1) )  ;     i := i + 1 ) ; 
    var ptr : int ; ptr := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     var times : int ; times := ar[i+1] ;
     ptr := (ptr + times) mod people->size() ; 
    sb := sb + StringLib.newString(people->at(ptr+1)) + StringLib.newString(" ") ; 
    people := people->excludingAt(ptr+1) ; 
    if (ptr = people->size() + 1) then (     ptr := 0 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
  static   operation swap( ar : Sequence(int), i : int, j : int) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := ar[i+1] ;
     ar[i+1] := ar[j+1] ; 
     ar[j+1] := temp );
  static class Pair {
   attribute x : int;
   attribute y : int;
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation getX() : int
  pre: true
  post: true
  activity: (     return x );
   operation getY() : int
  pre: true
  post: true
  activity: (     return y );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sum[]=new int[1000005];
  static int toInt(char x){
    return x-'0' ;
  }
  static void prepareSum(String s){
    sum[0]=0 ;
    for(int i=0 ; i<s.length(); i++){
      sum[i+1]=sum[i]+toInt(s.charAt(i));
    }
  }
  static void query(int l,int r){
    if((sum[r+1]-sum[l])% 3==0){
      System.out.println("Divisible by 3");
    }
    else {
      System.out.println("Not divisible by 3");
    }
  }
  public static void main(String[] args){
    String n="12468236544" ;
    prepareSum(n);
    query(0,1);
    query(1,2);
    query(3,6);
    query(0,10);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute sum : int := Integer.subrange(1,1000005)->collect(0);
  static   operation toInt( x : String) : int
  pre: true
  post: true
  activity: (     return x - ('0')->char2byte() );
  static   operation prepareSum( s : String) : void
  pre: true
  post: true
  activity: (     sum[0+1] := 0 ; 
         var i : int ; i := 0 ; while i < s->size() do ( (     sum[i + 1+1] := sum[i+1] + toInt(s->at(i+1)) )  ;     i := i + 1 ) );
  static   operation query( l : int, r : int) : void
  pre: true
  post: true
  activity: (     if ((sum[r + 1+1] - sum[l+1]) mod 3 = 0) then (     OclFile["System.out"].println("Divisible by 3") ) else (     OclFile["System.out"].println("Not divisible by 3") ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : String ; n := "12468236544" ;
     execute prepareSum(n) ; 
    execute query(0, 1) ; 
    execute query(1, 2) ; 
    execute query(3, 6) ; 
    execute query(0, 10) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public final class p124 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p124().run());
  }
  private static final int LIMIT=100000 ;
  public String run(){
    int[] rads=new int[LIMIT+1];
    Arrays.fill(rads,1,rads.length,1);
    for(int i=2 ; i<rads.length ; i++){
      if(rads[i]==1){
        for(int j=i ; j<rads.length ; j+=i)rads[j]*=i ;
      }
    }
    IntPair[] data=new IntPair[LIMIT];
    for(int i=0 ; i<data.length ; i++)data[i]=new IntPair(rads[i+1],i+1);
    Arrays.sort(data);
    return Integer.toString(data[10000-1] .b);
  }
  private static final class IntPair implements Comparable<IntPair>{
    public final int a ;
    public final int b ;
    public IntPair(int a,int b){
      this.a=a ;
      this.b=b ;
    }
    public int compareTo(IntPair other){
      if(a!=other.a)return Integer.compare(a,other.a);
      else return Integer.compare(b,other.b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class p124 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p124.newp124().run()) );
  static    attribute LIMIT : int := 100000;
   operation run() : String
  pre: true
  post: true
  activity: (     var rads : Sequence(int) ; rads := Integer.subrange(1,LIMIT + 1)->collect(0) ;
     rads := rads->collect(1) ; 
        var i : int ; i := 2 ; while i < rads->size() do ( (     if (rads[i+1] = 1) then (         var j : int ; j := i ; while j < rads->size() do (     rads[j+1] := rads[j+1]*(i) ;  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    var data : Sequence(IntPair) ; data := Integer.subrange(1,LIMIT)->collect(null) ;
        var i : int ; i := 0 ; while i < data->size() do (     data[i+1] := IntPair.newIntPair(rads[i + 1+1], i + 1) ;  ;     i := i + 1 ) ; 
    data := data->sort() ; 
    return ((data[10000 - 1+1].b) + "") 
 );
  static  class IntPair implements Comparable<IntPair> {
   attribute a : int;
   attribute b : int;
   static operation newIntPair( a : int, b : int) : IntPair
  pre: true
  post: true
  activity:
  ( var self : IntPair ;
    self := createIntPair();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
   operation compareTo( other : IntPair) : int
  pre: true
  post: true
  activity: (     if (a /= other.a) then     return compare(a, other.a) else     return compare(b, other.b) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MyClass {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String s[]=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      long x=Long.parseLong(s[i]);
      if(x<15){
        System.out.println("NO");
        continue ;
      }
      x=x % 14 ;
      if(x>=1 && x<=6){
        System.out.println("YES");
      }
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
         var i : int ; i := 0 ; while i < n do ( (     var x : long ; x := (s[i+1])->toLong() ;
     if (x < 15) then (     OclFile["System.out"].println("NO") ; 
     continue ) else skip ; 
     x := x mod 14 ; 
     if (x >= 1 & x <= 6) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Samyak {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long x=sc.nextLong();
      long temp=x/14 ;
      temp=temp*14 ;
      if(x-temp<=6 && x-temp>0 && x>14){
        System.out.println("YES");
      }
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Samyak {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x : long ; x := sc.getCurrent()->toLong() ;
     var temp : long ; temp := x / 14 ;
     temp := temp * 14 ; 
     if (x - temp <= 6 & x - temp > 0 & x > 14) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    int m=stdIn.nextInt();
    int[] money=new int[10];
    int[] ans=new int[n];
    int min=10000 ;
    int minNumber=-1 ;
    for(int i=0 ; i<10 ; i++){
      money[i]=stdIn.nextInt();
      if(money[i]<min){
        min=money[i];
        minNumber=i ;
      }
    }
    Arrays.fill(ans,minNumber);
    if((m-=money[minNumber]*n)<0){
      System.out.println("NA");
      return ;
    }
    for(int i=0 ; i<10 ; i++){
      for(int j=0 ; j<n ; j++){
        if(((m-money[i]+money[ans[j] ])>=0)&&(i<ans[j])){
          m=m-money[i]+money[ans[j] ];
          ans[j]=i ;
        }
      }
    }
    Arrays.sort(ans);
    for(int i=0 ; i<n ; i++){
      System.out.print(ans[i]);
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var m : int ; m := stdIn.getCurrent()->toInteger() ;
    var money : Sequence(int) ; money := Integer.subrange(1,10)->collect(0) ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
    var min : int ; min := 10000 ;
    var minNumber : int ; minNumber := -1 ;
        var i : int ; i := 0 ; while i < 10 do ( (     money[i+1] := stdIn.getCurrent()->toInteger() ; 
     if (money[i+1] < min) then (     min := money[i+1] ; 
     minNumber := i ) else skip )  ;     i := i + 1 ) ; 
    ans := ans->collect(minNumber) ; 
    if ((m) < 0) then (     OclFile["System.out"].println("NA") ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < n do ( (     if (((m - money[i+1] + money[ans[j+1]+1]) >= 0) & (i < ans[j+1])) then (     m := m - money[i+1] + money[ans[j+1]+1] ; 
     ans[j+1] := i ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    ans := ans->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(ans[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    long M=sc.nextLong();
    if(N>=M/2){
      System.out.println(M/2);
      return ;
    }
    System.out.println(N+(M-2*N)/4);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    var M : long ; M := sc.getCurrent()->toLong() ;
    if (N >= M / 2) then (     OclFile["System.out"].println(M / 2) ; 
     return ) else skip ; 
    OclFile["System.out"].println(N + (M - 2 * N) / 4) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int compositeProduct(int arr[],int n){
    int max_val=Arrays.stream(arr).max().getAsInt();
    boolean[] prime=new boolean[max_val+1];
    Arrays.fill(prime,true);
    prime[0]=true ;
    prime[1]=true ;
    for(int p=2 ; p*p<=max_val ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=max_val ; i+=p){
          prime[i]=false ;
        }
      }
    }
    int product=1 ;
    for(int i=0 ; i<n ; i++){
      if(! prime[arr[i] ]){
        product*=arr[i];
      }
    }
    return product ;
  }
  public static void main(String[] args){
    int arr[]={
      2,3,4,5,6,7 };
      int n=arr.length ;
      System.out.println(compositeProduct(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation compositeProduct( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max_val : int ; max_val := stream(arr).max().getAsInt() ;
     var prime : Sequence(boolean) ; prime := Integer.subrange(1,max_val + 1)->collect(false) ;
    prime := prime->collect(true) ; 
    prime[0+1] := true ; 
    prime[1+1] := true ; 
        var p : int ; p := 2 ; while p * p <= max_val do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= max_val do ( (     prime[i+1] := false )  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var product : int ; product := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (not(prime[arr[i+1]+1])) then (     product := product*(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    return product 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4,5,6,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(compositeProduct(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main implements Runnable {
  private void solve()throws IOException {
    long N=nextLong();
    long M=nextLong();
    long low=0L ;
    long high=1_000_000_000_000_00L ;
    long best=0L ;
    while(low<=high){
      long mid=low+(high-low)/2L ;
      if(can(mid,N,M)){
        best=Math.max(best,mid);
        low=mid+1 ;
      }
      else high=mid-1 ;
    }
    writer.println(best);
  }
  private boolean can(long packs,long n,long m){
    if(m/2<packs)return false ;
    m-=packs*2L ;
    if(n>=packs)return true ;
    long need=0L ;
    if(n<packs){
      need+=(packs-n)*2L ;
    }
    return m>=need ;
  }
  public static void main(String[] args){
    new Main().run();
  }
  BufferedReader reader ;
  StringTokenizer tokenizer ;
  PrintWriter writer ;
  public void run(){
    try {
      reader=new BufferedReader(new InputStreamReader(System.in));
      tokenizer=null ;
      writer=new PrintWriter(System.out);
      solve();
      reader.close();
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  short nextShort()throws IOException {
    return Short.parseShort(nextToken());
  }
  String nextToken()throws IOException {
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : long ; N := nextLong() ;
     var M : long ; M := nextLong() ;
    var low : long ; low := 0L ;
    var high : long ; high := 1_000_000_000_000_00L ;
    var best : long ; best := 0L ;
    while (low <= high) do (     var mid : long ; mid := low + (high - low) / 2L ;
     if (can(mid, N, M)) then (     best := Set{best, mid}->max() ; 
     low := mid + 1 ) else     high := mid - 1 ; ) ; 
    writer.println(best) ; 
 );
   operation can( packs : long, n : long, m : long) : boolean
  pre: true
  post: true
  activity: (     if (m / 2 < packs) then     return false else skip ; 
     m := m-(packs * 2L) ; 
    if (n >= packs) then     return true else skip ; 
    var need : long ; need := 0L ;
    if (n < packs) then (     need := need+((packs - n) * 2L) ) else skip ; 
    return m >= need 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   attribute writer : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     try (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := null ; 
    writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Stack ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long m=sc.nextLong();
    long ans=0 ;
    if(2*n<=m){
      ans+=n ;
      m-=2*n ;
      ans+=m/4 ;
    }
    else {
      if(m % 2!=0){
        ans=(m-1)/2 ;
      }
      else {
        ans=m/2 ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var m : long ; m := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
    if (2 * n <= m) then (     ans := ans+(n) ; 
     m := m-(2 * n) ; 
     ans := ans+(m / 4) ) else (     if (m mod 2 /= 0) then (     ans := (m - 1) / 2 ) else (     ans := m / 2 ) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    long M=sc.nextLong();
    if(N*2>M)System.out.println(M/2);
    else System.out.println((N*2+M)/4);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
     var M : long ; M := sc.getCurrent()->toLong() ;
     if (N * 2 > M) then     OclFile["System.out"].println(M / 2) ; else     OclFile["System.out"].println((N * 2 + M) / 4) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    long n=gl();
    long m=gl();
    if(n>=Math.floorDiv(m,2)){
      System.out.println(Math.floorDiv(m,2));
    }
    else {
      long c=n ;
      m-=2*n ;
      c+=Math.floorDiv(m,4);
      System.out.println(c);
    }
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : long ; n := gl() ;
     var m : long ; m := gl() ;
     if (n >= floorDiv(m, 2)) then (     OclFile["System.out"].println(floorDiv(m, 2)) ) else (     var c : long ; c := n ;
     m := m-(2 * n) ; 
     c := c+(floorDiv(m, 4)) ; 
     OclFile["System.out"].println(c) ) );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printFirstNegativeInteger(int arr[],int n,int k){
    LinkedList<Integer>Di=new LinkedList<>();
    int i ;
    for(i=0 ; i<k ; i++)if(arr[i]<0)Di.add(i);
    for(; i<n ; i++){
      if(! Di.isEmpty())System.out.print(arr[Di.peek()]+" ");
      else System.out.print("0"+" ");
      while((! Di.isEmpty())&& Di.peek()<(i-k+1))Di.remove();
      if(arr[i]<0)Di.add(i);
    }
    if(! Di.isEmpty())System.out.print(arr[Di.peek()]+" ");
    else System.out.print("0"+" ");
  }
  public static void main(String[] args){
    int arr[]={
      12,-1,-7,8,-15,30,16,28 };
      int n=arr.length ;
      int k=3 ;
      printFirstNegativeInteger(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printFirstNegativeInteger( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var Di : Sequence(int) ; Di := Sequence{} ;
     var i : int ;
        i := 0 ; while i < k do (     if (arr[i+1] < 0) then     Di := Di->including(i) ; else skip ;  ;     i := i + 1 ) ; 
      while i < n do ( (     if (not(Di->isEmpty())) then     OclFile["System.out"].print(arr[Di->min()+1] + " ") else     OclFile["System.out"].print("0" + " ") ; ;  
     while ((not(Di->isEmpty())) & Di->min() < (i - k + 1)) do     Di := Di.remove() ; ; 
     if (arr[i+1] < 0) then     Di := Di->including(i) ; else skip )  ;     i := i + 1 ) ; 
    if (not(Di->isEmpty())) then     OclFile["System.out"].print(arr[Di->min()+1] + " ") else     OclFile["System.out"].print("0" + " ") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,-1,-7,8,-15,30,16,28} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     execute printFirstNegativeInteger(arr, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    int[] v=new int[N];
    for(int i=0 ; i<N ; ++i){
      v[i]=sc.nextInt();
    }
    ArrayList<Integer>ans=new ArrayList<Integer>();
    for(int i=1 ; i<=(int)Math.sqrt(v[0]); ++i){
      if(v[0] % i!=0)continue ;
      boolean ok=true ;
      for(int j=1 ; j<N ; ++j){
        if(v[j] % i!=0){
          ok=false ;
          break ;
        }
      }
      if(ok)ans.add(i);
      if(i*i!=v[0]){
        ok=true ;
        for(int j=1 ; j<N ; ++j){
          if(v[j] %(v[0]/i)!=0){
            ok=false ;
            break ;
          }
        }
        if(ok)ans.add(v[0]/i);
      }
    }
    Collections.sort(ans);
    for(int a : ans){
      System.out.println(a);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var v : Sequence(int) ; v := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     v[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Sequence{} ;
        var i : int ; i := 1 ; while i <= (v[0+1])->sqrt()->oclAsType(int) do ( (     if (v[0+1] mod i /= 0) then     continue else skip ; 
     var ok : boolean ; ok := true ;
        var j : int ; j := 1 ; while j < N do ( (     if (v[j+1] mod i /= 0) then (     ok := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (ok) then     ans := ans->including(i) ; else skip ; 
    if (i * i /= v[0+1]) then (     ok := true ; 
         var j : int ; j := 1 ; while j < N do ( (     if (v[j+1] mod (v[0+1] / i) /= 0) then (     ok := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (ok) then     ans := ans->including(v[0+1] / i) ; else skip ) else skip ; 
 )  ;     i := i + 1 ) ; 
    ans := ans->sort() ; 
    for (a : ans) do ( (     OclFile["System.out"].println(a) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args){
    BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    String str="" ;
    StringTokenizer stk ;
    try {
      str=bfr.readLine();
      if(str==null){
        System.exit(0);
      }
      int suuji=Integer.parseInt(str);
      str=bfr.readLine();
      if(str==null){
        System.exit(0);
      }
      stk=new StringTokenizer(str," ");
      int[] moto=new int[suuji];
      int minimum=99999999 ;
      int aa=0 ;
      while(stk.hasMoreTokens()){
        moto[aa]=Integer.parseInt(stk.nextToken());
        aa++;
      }
      List<Integer>yakusu=new ArrayList<>();
      for(int i=0 ; i<suuji ; i++){
        if(minimum>moto[i]){
          minimum=moto[i];
        }
      }
      int[] amari=new int[suuji];
      int amariwa=0 ;
      for(int i=1 ; i<=minimum ; i++){
        for(int j=0 ; j<suuji ; j++){
          amari[j]=moto[j] % i ;
          amariwa+=amari[j];
        }
        if(amariwa==0){
          yakusu.add(i);
        }
        amariwa=0 ;
      }
      for(Integer s : yakusu){
        System.out.println(s);
      }
    }
    catch(IOException e){
    }
    catch(NumberFormatException er){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bfr : OclFile ; bfr := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := "" ;
     var stk : OclIterator ;
     try (     str := bfr.readLine() ; 
     if (str = null) then ( OclProcess.exit(0) ) else skip ; 
    var suuji : int ; suuji := (str)->toInteger() ;
    str := bfr.readLine() ; 
    if (str = null) then ( OclProcess.exit(0) ) else skip ; 
    stk := OclIterator.newOclIterator_String_String(str, " ") ; 
    var moto : Sequence(int) ; moto := Integer.subrange(1,suuji)->collect(0) ;
    var minimum : int ; minimum := 99999999 ;
    var aa : int ; aa := 0 ;
    while (stk.hasNext()) do (     moto[aa+1] := (stk.next())->toInteger() ; 
     aa := aa + 1 ) ; 
    var yakusu : Sequence(int) ; yakusu := Sequence{} ;
        var i : int ; i := 0 ; while i < suuji do ( (     if (minimum > moto[i+1]) then (     minimum := moto[i+1] ) else skip )  ;     i := i + 1 ) ; 
    var amari : Sequence(int) ; amari := Integer.subrange(1,suuji)->collect(0) ;
    var amariwa : int ; amariwa := 0 ;
        var i : int ; i := 1 ; while i <= minimum do ( (         var j : int ; j := 0 ; while j < suuji do ( (     amari[j+1] := moto[j+1] mod i ; 
     amariwa := amariwa+(amari[j+1]) )  ;     j := j + 1 ) ; 
     if (amariwa = 0) then (     yakusu := yakusu->including(i) ) else skip ; 
     amariwa := 0 )  ;     i := i + 1 ) ; 
    for (s : yakusu) do ( (     OclFile["System.out"].println(s) )  ) ; 
 )   catch (e : IOException) do skip
   catch (er : IncorrectElementException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
class Main {
  static int gcd(int a,int b){
    return b==0 ? a : gcd(b,a % b);
  }
  public static void main(String[] args){
    BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
    try {
      int n=Integer.valueOf(sc.readLine());
      String[] st=sc.readLine().split(" ");
      int map[]=new int[n];
      for(int i=0 ; i<n ; i++)map[i]=Integer.valueOf(st[i]);
      int c=gcd(Math.max(map[0],map[1]),Math.min(map[0],map[1]));
      if(n==3)c=gcd(Math.max(c,map[2]),Math.min(c,map[2]));
      for(int i=1 ; i<=c ; i++)if(c % i==0)System.out.println(i);
    }
    catch(Exception e){
      System.out.println("Error");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var n : int ; n := (sc.readLine())->toInteger() ;
     var st : Sequence(String) ; st := sc.readLine()->split(" ") ;
    var map : Sequence(int) ; map := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     map[i+1] := (st[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var c : int ; c := gcd(Set{map[0+1], map[1+1]}->max(), Set{map[0+1], map[1+1]}->min()) ;
    if (n = 3) then     c := gcd(Set{c, map[2+1]}->max(), Set{c, map[2+1]}->min()) ; else skip ; 
        var i : int ; i := 1 ; while i <= c do (     if (c mod i = 0) then     OclFile["System.out"].println(i) ; else skip ;  ;     i := i + 1 ) ; 
 )   catch (e : ProgramException) do (     OclFile["System.out"].println("Error") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.BufferedReader ;
public class Main {
  static int gcd(int a,int b){
    return b==0 ? a : gcd(b,a % b);
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int num=Integer.valueOf(br.readLine());
    String[] inputs=br.readLine().split(" ");
    int[] input=new int[num];
    for(int i=0 ; i<num ; i++)input[i]=Integer.valueOf(inputs[i]);
    int GCD=gcd(Math.max(input[0],input[1]),Math.min(input[0],input[1]));
    if(num==3)GCD=gcd(Math.max(GCD,input[2]),Math.min(GCD,input[2]));
    for(int i=1 ; i<=GCD ; i++){
      if((GCD % i)==0)System.out.println(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var num : int ; num := (br.readLine())->toInteger() ;
    var inputs : Sequence(String) ; inputs := br.readLine()->split(" ") ;
    var input : Sequence(int) ; input := Integer.subrange(1,num)->collect(0) ;
        var i : int ; i := 0 ; while i < num do (     input[i+1] := (inputs[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var GCD : int ; GCD := gcd(Set{input[0+1], input[1+1]}->max(), Set{input[0+1], input[1+1]}->min()) ;
    if (num = 3) then     GCD := gcd(Set{GCD, input[2+1]}->max(), Set{GCD, input[2+1]}->min()) ; else skip ; 
        var i : int ; i := 1 ; while i <= GCD do ( (     if ((GCD mod i) = 0) then     OclFile["System.out"].println(i) ; else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class SubsetMex {
  public static void main(String[] args){
    Scanner iScanner=new Scanner(System.in);
    int test=iScanner.nextInt();
    while(test>0){
      test--;
      int n=iScanner.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=iScanner.nextInt();
      }
      Arrays.sort(arr);
      int min=arr[0];
      int max=arr[n-1];
      int count=0 ;
      int[] arr2=new int[max+2];
      for(int i=0 ; i<max+2 ; i++)arr2[i]=0 ;
      if(min==0){
        for(int i=0 ; i<n ; i++)arr2[arr[i] ]++;
        int a=0 ;
        int b=0 ;
        for(int i=0 ; i<max+2 ; i++){
          if(arr2[i]==0){
            a=i ;
            break ;
          }
          arr2[i]=arr2[i]-1 ;
        }
        for(int i=0 ; i<max+2 ; i++){
          if(arr2[i]==0){
            b=i ;
            break ;
          }
        }
        System.out.println(a+b);
      }
      else System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SubsetMex {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var iScanner : OclFile ; iScanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := iScanner.getCurrent()->toInteger() ;
     while (test > 0) do (     test := test - 1 ; 
     var n : int ; n := iScanner.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := iScanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var min : int ; min := arr[0+1] ;
    var max : int ; max := arr[n - 1+1] ;
    var count : int ; count := 0 ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,max + 2)->collect(0) ;
        var i : int ; i := 0 ; while i < max + 2 do (     arr2[i+1] := 0 ;  ;     i := i + 1 ) ; 
    if (min = 0) then (         var i : int ; i := 0 ; while i < n do (     arr2[arr[i+1]+1] := arr2[arr[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
     var a : int ; a := 0 ;
    var b : int ; b := 0 ;
        var i : int ; i := 0 ; while i < max + 2 do ( (     if (arr2[i+1] = 0) then (     a := i ; 
     break ) else skip ; 
     arr2[i+1] := arr2[i+1] - 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < max + 2 do ( (     if (arr2[i+1] = 0) then (     b := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a + b) ; 
 ) else     OclFile["System.out"].println(0) ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    int intx=0 ;
    int inty=0 ;
    int intWork=0 ;
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      while(true){
        String strLine=br.readLine();
        if(strLine!=null){
          String[] strNumList=strLine.split(" ",0);
          intx=Integer.parseInt(strNumList[0]);
          inty=Integer.parseInt(strNumList[1]);
          if(intx!=0 || inty!=0){
            if(intx>inty){
              intWork=intx ;
              intx=inty ;
              inty=intWork ;
            }
            System.out.println(intx+" "+inty);
          }
          else {
            break ;
          }
        }
        else {
          break ;
        }
      }
    }
    catch(IOException e1){
      System.out.println(e1);
    }
    catch(NumberFormatException e2){
      System.out.println(e2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var intx : int ; intx := 0 ;
     var inty : int ; inty := 0 ;
     var intWork : int ; intWork := 0 ;
     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var strLine : String ; strLine := br.readLine() ;
     if (strLine /= null) then (     var strNumList : Sequence(String) ; strNumList := strLine->split(" ") ;
     intx := (strNumList[0+1])->toInteger() ; 
     inty := (strNumList[1+1])->toInteger() ; 
     if (intx /= 0 or inty /= 0) then (     if (intx > inty) then (     intWork := intx ; 
     intx := inty ; 
     inty := intWork ) else skip ; 
     OclFile["System.out"].println(intx + " " + inty) ) else (     break ) ) else (     break ) ) )   catch (e1 : IOException) do (     OclFile["System.out"].println(e1) )
   catch (e2 : IncorrectElementException) do (     OclFile["System.out"].println(e2) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static void kou2(int a,int b){
    int min=Math.min(a,b);
    for(int i=1 ; i<=min ; i++){
      if(a % i+b % i==0)System.out.println(i);
    }
  }
  private static void kou3(int a,int b,int c){
    int min=Math.min(c,Math.min(a,b));
    for(int i=1 ; i<=min ; i++){
      if(a % i+b % i+c % i==0)System.out.println(i);
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a,b,c ;
    a=sc.nextInt();
    b=sc.nextInt();
    if(n==3){
      c=sc.nextInt();
      kou3(a,b,c);
    }
    if(n==2)kou2(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation kou2( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var min : int ; min := Set{a, b}->min() ;
         var i : int ; i := 1 ; while i <= min do ( (     if (a mod i + b mod i = 0) then     OclFile["System.out"].println(i) ; else skip )  ;     i := i + 1 ) );
  static   operation kou3( a : int, b : int, c : int) : void
  pre: true
  post: true
  activity: (     var min : int ; min := Set{c, Set{a, b}->min()}->min() ;
         var i : int ; i := 1 ; while i <= min do ( (     if (a mod i + b mod i + c mod i = 0) then     OclFile["System.out"].println(i) ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ;
    var b : int ;
    var c : int ;
    a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    if (n = 3) then (     c := sc.getCurrent()->toInteger() ; 
     execute kou3(a, b, c) ) else skip ; 
    if (n = 2) then     execute kou2(a, b) ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static String name ;
  static int num ;
  public static void main(String[] args){
    for(int i=0 ; i<9 ; i++){
      read_and_solve();
    }
  }
  static void read_and_solve(){
    int res=0 ;
    int temp=0 ;
    name=sc.next();
    num=sc.nextInt();
    temp=num ;
    res=num*200 ;
    num=sc.nextInt();
    res=res+num*300 ;
    num=num+temp ;
    System.out.println(name+" "+num+" "+res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute name : String;
  static   attribute num : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 9 do ( (     execute read_and_solve() )  ;     i := i + 1 ) );
  static   operation read_and_solve() : void
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     var temp : int ; temp := 0 ;
    name := sc.getCurrent() ; 
    num := sc.getCurrent()->toInteger() ; 
    temp := num ; 
    res := num * 200 ; 
    num := sc.getCurrent()->toInteger() ; 
    res := res + num * 300 ; 
    num := num + temp ; 
    OclFile["System.out"].println(name + " " + num + " " + res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int a,b ;
    for(; sc.hasNext(); ){
      out.print(sc.next()+" ");
      a=sc.nextInt();
      b=sc.nextInt();
      out.println((a+b)+" "+(200*a+300*b));
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var a : int ;
    var b : int ;
       while sc.hasNext() do ( (     out.print(sc.next() + " ") ; 
     a := sc.nextInt() ; 
     b := sc.nextInt() ; 
     out.println((a + b) + " " + (200 * a + 300 * b)) )  ) ; 
     sc.close() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int[] Fee={
    200,300 };
    public static int Num_Classes=9 ;
    public static void main(String[] args){
      Scanner sc=new Scanner(System.in);
      String[] className=new String[Num_Classes];
      int[][] visitors=new int[Num_Classes][2];
      for(int i=0 ; i<Num_Classes ; i++){
        className[i]=sc.next();
        visitors[i][0]=sc.nextInt();
        visitors[i][1]=sc.nextInt();
      }
      sc.close();
      int[][] data=new int[Num_Classes][2];
      for(int i=0 ; i<Num_Classes ; i++){
        data[i][0]=visitors[i][0]+visitors[i][1];
        data[i][1]=visitors[i][0]*Fee[0]+visitors[i][1]*Fee[1];
      }
      for(int i=0 ; i<Num_Classes ; i++){
        System.out.printf("%s %d %d\n",className[i],data[i][0],data[i][1]);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute Fee : Sequence(int) := Sequence{200,300};
  static   attribute Num_Classes : int := 9;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var className : Sequence(String) ; className := Integer.subrange(1,Num_Classes)->collect(null) ;
    var visitors : Sequence(Sequence(int)) ; visitors := Integer.subrange(1,Num_Classes)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < Num_Classes do ( (     className[i+1] := sc.getCurrent() ; 
     visitors[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     visitors[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var data : Sequence(Sequence(int)) ; data := Integer.subrange(1,Num_Classes)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < Num_Classes do ( (     data[i+1][0+1] := visitors[i+1][0+1] + visitors[i+1][1+1] ; 
     data[i+1][1+1] := visitors[i+1][0+1] * Fee[0+1] + visitors[i+1][1+1] * Fee[1+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Num_Classes do ( (     OclFile["System.out"].printf("%s %d %d\n", className[i+1], data[i+1][0+1], data[i+1][1+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
class Class_Visitor {
  private String class_name ;
  private int visitor_am ;
  private int visitor_pm ;
  Class_Visitor(String class_name,int visitor_am,int visitor_pm){
    setClass_name(class_name);
    setVisitor_am(visitor_am);
    setVisitor_pm(visitor_pm);
  }
  public void setClass_name(String class_name){
    this.class_name=class_name ;
  }
  public void setVisitor_am(int visitor_am){
    this.visitor_am=visitor_am ;
  }
  public void setVisitor_pm(int visitor_pm){
    this.visitor_pm=visitor_pm ;
  }
  public String getClass_name(){
    return class_name ;
  }
  public int getVisitor_am(){
    return visitor_am ;
  }
  public int getVisitor_pm(){
    return visitor_pm ;
  }
}
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    ArrayList<Class_Visitor>vis=new ArrayList<Class_Visitor>();
    for(int i=0 ; i<9 ; i++){
      String[] data=sc.nextLine().split(" ");
      Class_Visitor c_v=new Class_Visitor(data[0],Integer.parseInt(data[1]),Integer.parseInt(data[2]));
      vis.add(c_v);
      String c_name=vis.get(i).getClass_name();
      int v_sum=vis.get(i).getVisitor_am()+vis.get(i).getVisitor_pm();
      int f_sum=200*vis.get(i).getVisitor_am()+300*vis.get(i).getVisitor_pm();
      System.out.printf("%s %d %d\n",c_name,v_sum,f_sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Class_Visitor {
   attribute class_name : String;
   attribute visitor_am : int;
   attribute visitor_pm : int;
   static operation newClass_Visitor( class_name : String, visitor_am : int, visitor_pm : int) : Class_Visitor
  pre: true
  post: true
  activity:
  ( var self : Class_Visitor ;
    self := createClass_Visitor();
    self.initialise(class_name, visitor_am,visitor_pm);
    return self );
  operation initialise( class_name : String, visitor_am : int, visitor_pm : int) : void
  pre: true  post: true
  activity: (     execute setClass_name(class_name) ; 
     execute setVisitor_am(visitor_am) ; 
     execute setVisitor_pm(visitor_pm) );
   operation setClass_name( class_name : String) : void
  pre: true
  post: true
  activity: (     self.class_name := class_name );
   operation setVisitor_am( visitor_am : int) : void
  pre: true
  post: true
  activity: (     self.visitor_am := visitor_am );
   operation setVisitor_pm( visitor_pm : int) : void
  pre: true
  post: true
  activity: (     self.visitor_pm := visitor_pm );
   operation getClass_name() : String
  pre: true
  post: true
  activity: (     return class_name );
   operation getVisitor_am() : int
  pre: true
  post: true
  activity: (     return visitor_am );
   operation getVisitor_pm() : int
  pre: true
  post: true
  activity: (     return visitor_pm );
}
class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var vis : Sequence(Class_Visitor) ; vis := Sequence{} ;
         var i : int ; i := 0 ; while i < 9 do ( (     var data : Sequence(String) ; data := sc.nextLine()->split(" ") ;
     var c_v : Class_Visitor ; c_v := Class_Visitor.newClass_Visitor(data[0+1], (data[1+1])->toInteger(), (data[2+1])->toInteger()) ;
    vis := vis->including(c_v) ; 
    var c_name : String ; c_name := vis->at(i+1).getClass_name() ;
    var v_sum : int ; v_sum := vis->at(i+1).getVisitor_am() + vis->at(i+1).getVisitor_pm() ;
    var f_sum : int ; f_sum := 200 * vis->at(i+1).getVisitor_am() + 300 * vis->at(i+1).getVisitor_pm() ;
    OclFile["System.out"].printf("%s %d %d\n", c_name, v_sum, f_sum) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      String s=sc.next();
      int a=sc.nextInt();
      int b=sc.nextInt();
      System.out.println(s+" "+(a+b)+" "+(a*200+b*300));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var s : String ; s := sc.getCurrent() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(s + " " + (a + b) + " " + (a * 200 + b * 300)) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    double xp1,xp2,yp1,yp2 ;
    int q ;
    double[] xp,yp ;
    double ansx,ansy,t ;
    int i ;
    xp1=sc.nextDouble();
    yp1=sc.nextDouble();
    xp2=sc.nextDouble();
    yp2=sc.nextDouble();
    q=sc.nextInt();
    xp=new double[q];
    yp=new double[q];
    for(i=0 ; i<q ; i++){
      xp[i]=sc.nextDouble();
      yp[i]=sc.nextDouble();
    }
    sc.close();
    for(i=0 ; i<q ; i++){
      t=(xp2-xp1)*(xp[i]-xp1)+(yp2-yp1)*(yp[i]-yp1);
      t=t/((xp2-xp1)*(xp2-xp1)+(yp2-yp1)*(yp2-yp1));
      ansx=xp1+t*(xp2-xp1);
      ansx=ansx+(ansx-xp[i]);
      ;
      ansy=yp1+t*(yp2-yp1);
      ansy=ansy+(ansy-yp[i]);
      System.out.printf("%.10f %.10f%n",ansx,ansy);
    }
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var xp1 : double ;
    var xp2 : double ;
    var yp1 : double ;
    var yp2 : double ;
    var q : int ;
    var xp : Sequence(double) ;
    var yp : Sequence(double) ;
    var ansx : double ;
    var ansy : double ;
    var t : double ;
    var i : int ;
    xp1 := sc.nextDouble() ; 
    yp1 := sc.nextDouble() ; 
    xp2 := sc.nextDouble() ; 
    yp2 := sc.nextDouble() ; 
    q := sc.nextInt() ; 
    xp := Integer.subrange(1,q)->collect(0.0) ; 
    yp := Integer.subrange(1,q)->collect(0.0) ; 
        i := 0 ; while i < q do ( (     xp[i+1] := sc.nextDouble() ; 
     yp[i+1] := sc.nextDouble() )  ;     i := i + 1 ) ; 
    sc.close() ; 
        i := 0 ; while i < q do ( (     t := (xp2 - xp1) * (xp[i+1] - xp1) + (yp2 - yp1) * (yp[i+1] - yp1) ; 
     t := t / ((xp2 - xp1) * (xp2 - xp1) + (yp2 - yp1) * (yp2 - yp1)) ; 
    ansx := xp1 + t * (xp2 - xp1) ; 
    ansx := ansx + (ansx - xp[i+1]) ; 
    ansy := yp1 + t * (yp2 - yp1) ; 
    ansy := ansy + (ansy - yp[i+1]) ; 
    OclFile["System.out"].printf("%.10f %.10f%n", ansx, ansy) ; 
 )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Point2D ;
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new AOJCGL_1B().doIt();
  }
  class AOJCGL_1B {
    void doIt(){
      Point2D p0=new Point2D.Double(in.nextDouble(),in.nextDouble());
      Point2D p1=new Point2D.Double(in.nextDouble(),in.nextDouble());
      int q=in.nextInt();
      for(int i=0 ; i<q ; i++){
        Point2D p2=new Point2D.Double(in.nextDouble(),in.nextDouble());
        Point2D result=getVerticalPoint(p0,p1,p2);
        double dx=result.getX()-p2.getX();
        double dy=result.getY()-p2.getY();
        double tx=dx+result.getX();
        double ty=dy+result.getY();
        System.out.printf("%.9f %.9f\n",tx,ty);
      }
    }
    private Point2D getVerticalPoint(Point2D p0,Point2D p1,Point2D p2){
      double kyori=p0.distance(p1);
      double angle=angle(p0,p1,p2);
      double t=p0.distance(p2)*Math.cos(angle);
      Point2D result=new Point2D.Double(p0.getX()+(p1.getX()-p0.getX())*t/kyori,p0.getY()+(p1.getY()-p0.getY())*t/kyori);
      return result ;
    }
    private double angle(Point2D p0,Point2D p1,Point2D p2){
      return Math.atan2(p2.getY()-p0.getY(),p2.getX()-p0.getX())-Math.atan2(p1.getY()-p0.getY(),p1.getX()-p0.getX());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     AOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B()B.newAOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B()B().doIt() ;B.newAOJCGL    AOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B()B.newAOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B()B().doIt() ;B().doIt()B.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B()B.newAOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B()B().doIt() ;B.newAOJCGL    AOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B()B.newAOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B()B().doIt() ;B().doIt()B()B.newAOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B()B.newAOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B()B().doIt() ;B.newAOJCGL    AOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B()B.newAOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B()B().doIt() ;B().doIt()B.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B()B.newAOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B()B().doIt() ;B.newAOJCGL    AOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B()B.newAOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B.newAOJCGL    AOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B.newAOJCGLAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B.newAOJCGLAOJCGL_1B.newAOJCGL_1B().doIt()B()B().doIt() ; 
B().doIt()B()B().doIt() ;B().doIt()B()B().doIt() );
 class AOJCGL_1B {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var p0 : Point2D ; p0 := Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal()) ;
     var p1 : Point2D ; p1 := Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal()) ;
     var q : int ; q := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < q do ( (     var p2 : Point2D ; p2 := Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal()) ;
     var result : Point2D ; result := getVerticalPoint(p0, p1, p2) ;
    var dx : double ; dx := result.getX() - p2.getX() ;
    var dy : double ; dy := result.getY() - p2.getY() ;
    var tx : double ; tx := dx + result.getX() ;
    var ty : double ; ty := dy + result.getY() ;
    OclFile["System.out"].printf("%.9f %.9f\n", tx, ty) ; 
 )  ;     i := i + 1 ) );
   operation getVerticalPoint( p0 : Point2D, p1 : Point2D, p2 : Point2D) : Point2D
  pre: true
  post: true
  activity: (     var kyori : double ; kyori := p0.distance(p1) ;
     var angle : double ; angle := angle(p0, p1, p2) ;
    var t : double ; t := p0.distance(p2) * (angle)->cos() ;
    var result : Point2D ; result := Double.newDouble(p0.getX() + (p1.getX() - p0.getX()) * t / kyori, p0.getY() + (p1.getY() - p0.getY()) * t / kyori) ;
    return result 
 );
   operation angle( p0 : Point2D, p1 : Point2D, p2 : Point2D) : double
  pre: true
  post: true
  activity: (     return atan2(p2.getY() - p0.getY(), p2.getX() - p0.getX()) - atan2(p1.getY() - p0.getY(), p1.getX() - p0.getX()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void calc(double x1,double y1,double x2,double y2,double px,double py){
    if(y1==y2)System.out.println(px+" "+(py-2*(py-y1)));
    else if(x1==x2)System.out.println((px-2*(px-x1))+" "+py);
    else {
      double katamuki1=(y2-y1)/(x2-x1);
      double seppen1=-1.0*katamuki1*x1+y1 ;
      double katamuki2=-1.0/katamuki1 ;
      double seppen2=-1.0*katamuki2*px+py ;
      double ansx=(seppen2-seppen1)/(katamuki1-katamuki2);
      double ansy=ansx*katamuki1+seppen1 ;
      System.out.println((px-2*(px-ansx))+" "+(py-2*(py-ansy)));
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x1=sc.nextInt();
    int y1=sc.nextInt();
    int x2=sc.nextInt();
    int y2=sc.nextInt();
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      int px=sc.nextInt();
      int py=sc.nextInt();
      calc((double)x1,(double)y1,(double)x2,(double)y2,(double)px,(double)py);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation calc( x1 : double, y1 : double, x2 : double, y2 : double, px : double, py : double) : void
  pre: true
  post: true
  activity: (     if (y1 = y2) then     OclFile["System.out"].println(px + " " + (py - 2 * (py - y1))) ; else     if (x1 = x2) then     OclFile["System.out"].println((px - 2 * (px - x1)) + " " + py) else (     var katamuki1 : double ; katamuki1 := (y2 - y1) / (x2 - x1) ;
     var seppen1 : double ; seppen1 := -1.0 * katamuki1 * x1 + y1 ;
    var katamuki2 : double ; katamuki2 := -1.0 / katamuki1 ;
    var seppen2 : double ; seppen2 := -1.0 * katamuki2 * px + py ;
    var ansx : double ; ansx := (seppen2 - seppen1) / (katamuki1 - katamuki2) ;
    var ansy : double ; ansy := ansx * katamuki1 + seppen1 ;
    OclFile["System.out"].println((px - 2 * (px - ansx)) + " " + (py - 2 * (py - ansy))) ; 
 ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : int ; x1 := sc.getCurrent()->toInteger() ;
    var y1 : int ; y1 := sc.getCurrent()->toInteger() ;
    var x2 : int ; x2 := sc.getCurrent()->toInteger() ;
    var y2 : int ; y2 := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var px : int ; px := sc.getCurrent()->toInteger() ;
     var py : int ; py := sc.getCurrent()->toInteger() ;
     execute calc(x1->oclAsType(double), y1->oclAsType(double), x2->oclAsType(double), y2->oclAsType(double), px->oclAsType(double), py->oclAsType(double)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String args[]){
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    int as[]=new int[n];
    int i,h ;
    for(i=0 ; i<n ; i++)as[i]=sc.nextInt();
    long t=0 ;
    h=0 ;
    for(i=0 ; i<n ; i++){
      if(as[i]>h)t+=(1+as[i]-h);
      else if(as[i]==h)t++;
      else t+=(h-as[i]+1);
      h=as[i];
      if(i!=n-1)t++;
    }
    System.out.println(t);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : int ; n := sc.nextInt() ;
    var as : Sequence(int) ; as := Integer.subrange(1,n)->collect(0) ;
    var i : int ;
    var h : int ;
        i := 0 ; while i < n do (     as[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
    var t : long ; t := 0 ;
    h := 0 ; 
        i := 0 ; while i < n do ( (     if (as[i+1] > h) then     t := t+((1 + as[i+1] - h)) else     if (as[i+1] = h) then     t := t + 1 else     t := t+((h - as[i+1] + 1)) ; ;  ;  
     h := as[i+1] ; 
     if (i /= n - 1) then     t := t + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(t) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.System.out ;
import static java.util.Arrays.asList ;
import java.io.File ;
import java.util.Scanner ;
public class Main extends BaseExe {
  public static void main(String[] args){
    new Main().exeSysIn();
  }
  @ Override protected void execute()throws Exception {
    String data ;
    while(! "0 0".equals(data=nextLine())){
      StringBuffer sb=new StringBuffer();
      asList(data.split(" ")).stream().map(Integer :: parseInt).sorted().forEach(num->sb.append(num+" "));
      out.println(sb.substring(0,sb.length()-1).toString());
    }
  }
}
abstract class BaseExe {
  private Scanner scan ;
  private String inData ;
  public void exeSysIn(){
    try(Scanner scan=new Scanner(System.in)){
      exeCtrl(scan);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  public void exeFileIn(String inDataPath){
    try(Scanner scan=new Scanner(new File(inDataPath))){
      exeCtrl(scan);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  private void exeCtrl(Scanner scan)throws Exception {
    this.scan=scan ;
    execute();
  }
  protected abstract void execute()throws Exception ;
  protected String nextLine(){
    return scan.nextLine();
  }
  protected boolean judgeInData(){
    return hasNextLine()&& isNotEmptyInData();
  }
  protected boolean hasNextLine(){
    return scan.hasNextLine();
  }
  protected boolean isNotEmptyInData(){
    inData=nextLine();
    return ! inData.isEmpty();
  }
  protected String getInData()throws Exception {
    if(inData.isEmpty())throw new Exception("inData is Empty.");
    return inData ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends BaseExe {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().exeSysIn() );
      operation execute() : void
  pre: true
  post: true
  activity: (     var data : String ;
     while (not("0 0" = data)) do (     var sb : String ; sb := StringLib.newString() ;
     for num : asList(data->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->sort() do
    (    sb := sb + StringLib.newString(num + " ")) ; 
     out.println(sb.subrange(0+1,sb->size() - 1)+"") ) );
}
class BaseExe {
   attribute scan : OclFile;
   attribute inData : String;
   operation exeSysIn() : void
  pre: true
  post: true
  activity: (     try (    var scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     execute exeCtrl(scan) ))   catch (e : ProgramException) do (     e.printStackTrace() )
  );
   operation exeFileIn( inDataPath : String) : void
  pre: true
  post: true
  activity: (     try (    var scan : OclFile := OclFile.newOclFile_Read(OclFile(inDataPath)) ;
 (     execute exeCtrl(scan) ))   catch (e : ProgramException) do (     e.printStackTrace() )
  );
   operation exeCtrl( scan : OclFile) : void
  pre: true
  post: true
  activity: (     self.scan := scan ; 
     execute execute() );
      operation execute() : void
  pre: true
  post: true;
     operation nextLine() : String
  pre: true
  post: true
  activity: (     return scan.nextLine() );
     operation judgeInData() : boolean
  pre: true
  post: true
  activity: (     return hasNextLine() & isNotEmptyInData() );
     operation hasNextLine() : boolean
  pre: true
  post: true
  activity: (     return scan.hasNextLine() );
     operation isNotEmptyInData() : boolean
  pre: true
  post: true
  activity: (     inData := nextLine() ; 
     return not(inData->isEmpty()) );
     operation getInData() : String
  pre: true
  post: true
  activity: (     if (inData->isEmpty()) then     error ProgramException("inData is Empty.") ; else skip ; 
     return inData );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SubMex {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt(),i,j=0,k=0,a[]=new int[101];
      for(i=0 ; i<n ; i++)a[in.nextInt()]++;
      while(a[j]>0)a[j++]--;
      while(a[k]>0)a[k++]--;
      System.out.println(j+k);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class SubMex {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
    var i : int ;
    var j : int ; j := 0 ;
    var k : int ; k := 0 ;
    var a : Sequence(void) ; a := Integer.subrange(1,101)->collect(0) ;
         i := 0 ; while i < n do (     a[in.getCurrent()->toInteger()+1] := a[in.getCurrent()->toInteger()+1] + 1 ;  ;     i := i + 1 ) ; 
    while (a[j+1] > 0) do     a[j+1] := a[j+1] - 1 ; ; 
    while (a[k+1] > 0) do     a[k+1] := a[k+1] - 1 ; ; 
    OclFile["System.out"].println(j + k) ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    double x=scan.nextDouble();
    double y=scan.nextDouble();
    double xx=scan.nextDouble();
    double yy=scan.nextDouble();
    int qer=scan.nextInt();
    double xxx=0 ;
    double yyy=0 ;
    xxx=xx-x ;
    yyy=yy-y ;
    double xp[]=new double[qer];
    double yp[]=new double[qer];
    double ansx[]=new double[qer];
    double ansy[]=new double[qer];
    for(int i=0 ; i<qer ; i++){
      xp[i]=scan.nextDouble();
      yp[i]=scan.nextDouble();
      double xxxx=x-xp[i];
      double yyyy=y-yp[i];
      ansx[i]=x-xxx*(xxxx*xxx+yyyy*yyy)/(xxx*xxx+yyy*yyy);
      ansy[i]=y-yyy*(xxxx*xxx+yyyy*yyy)/(xxx*xxx+yyy*yyy);
      ansx[i]=2*ansx[i]-xp[i];
      ansy[i]=2*ansy[i]-yp[i];
      System.out.println(ansx[i]+" "+ansy[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : double ; x := scan.getCurrent()->toReal() ;
    var y : double ; y := scan.getCurrent()->toReal() ;
    var xx : double ; xx := scan.getCurrent()->toReal() ;
    var yy : double ; yy := scan.getCurrent()->toReal() ;
    var qer : int ; qer := scan.getCurrent()->toInteger() ;
    var xxx : double ; xxx := 0 ;
    var yyy : double ; yyy := 0 ;
    xxx := xx - x ; 
    yyy := yy - y ; 
    var xp : Sequence(double) ; xp := Integer.subrange(1,qer)->collect(0.0) ;
    var yp : Sequence(double) ; yp := Integer.subrange(1,qer)->collect(0.0) ;
    var ansx : Sequence(double) ; ansx := Integer.subrange(1,qer)->collect(0.0) ;
    var ansy : Sequence(double) ; ansy := Integer.subrange(1,qer)->collect(0.0) ;
        var i : int ; i := 0 ; while i < qer do ( (     xp[i+1] := scan.getCurrent()->toReal() ; 
     yp[i+1] := scan.getCurrent()->toReal() ; 
    var xxxx : double ; xxxx := x - xp[i+1] ;
    var yyyy : double ; yyyy := y - yp[i+1] ;
    ansx[i+1] := x - xxx * (xxxx * xxx + yyyy * yyy) / (xxx * xxx + yyy * yyy) ; 
    ansy[i+1] := y - yyy * (xxxx * xxx + yyyy * yyy) / (xxx * xxx + yyy * yyy) ; 
    ansx[i+1] := 2 * ansx[i+1] - xp[i+1] ; 
    ansy[i+1] := 2 * ansy[i+1] - yp[i+1] ; 
    OclFile["System.out"].println(ansx[i+1] + " " + ansy[i+1]) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    double x1,y1,x2,y2,xq,yq,ax,ay ;
    double m1,m2,l1,l2 ;
    int q ;
    x1=scan.nextDouble();
    y1=scan.nextDouble();
    x2=scan.nextDouble();
    y2=scan.nextDouble();
    m1=(y2-y1)/(x2-x1);
    l1=y1-(m1*x1);
    m2=-1.0/m1 ;
    q=scan.nextInt();
    for(int i=0 ; i<q ; i++){
      xq=scan.nextDouble();
      yq=scan.nextDouble();
      if(x1==x2){
        ax=x1 ;
        ay=yq ;
      }
      else if(y1==y2){
        ax=xq ;
        ay=y1 ;
      }
      else {
        l2=yq-(m2*xq);
        ax=(l2-l1)/(m1-m2);
        ay=(l2*m1-l1*m2)/(m1-m2);
      }
      System.out.println(ax+" "+ay);
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : double ;
    var y1 : double ;
    var x2 : double ;
    var y2 : double ;
    var xq : double ;
    var yq : double ;
    var ax : double ;
    var ay : double ;
    var m1 : double ;
    var m2 : double ;
    var l1 : double ;
    var l2 : double ;
    var q : int ;
    x1 := scan.getCurrent()->toReal() ; 
    y1 := scan.getCurrent()->toReal() ; 
    x2 := scan.getCurrent()->toReal() ; 
    y2 := scan.getCurrent()->toReal() ; 
    m1 := (y2 - y1) / (x2 - x1) ; 
    l1 := y1 - (m1 * x1) ; 
    m2 := -1.0 / m1 ; 
    q := scan.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < q do ( (     xq := scan.getCurrent()->toReal() ; 
     yq := scan.getCurrent()->toReal() ; 
     if (x1 = x2) then (     ax := x1 ; 
     ay := yq ) else     if (y1 = y2) then (     ax := xq ; 
     ay := y1 ) else (     l2 := yq - (m2 * xq) ; 
     ax := (l2 - l1) / (m1 - m2) ; 
     ay := (l2 * m1 - l1 * m2) / (m1 - m2) ) ;  ;  
     OclFile["System.out"].println(ax + " " + ay) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.awt.geom.Point2D ;
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new AOJCGL_1C().doIt();
  }
  class AOJCGL_1C {
    private Point2D projection(Line2D l,Point2D p2){
      double kyori=l.getP1().distance(l.getP2());
      double angle=angle(l.getP1(),l.getP2(),p2);
      double t=l.getP1().distance(p2)*Math.cos(angle);
      Point2D result=new Point2D.Double(l.getP1().getX()+(l.getP2().getX()-l.getP1().getX())*t/kyori,l.getP1().getY()+(l.getP2().getY()-l.getP1().getY())*t/kyori);
      return result ;
    }
    private double angle(Point2D p0,Point2D p1,Point2D p2){
      return Math.atan2(p2.getY()-p0.getY(),p2.getX()-p0.getX())-Math.atan2(p1.getY()-p0.getY(),p1.getX()-p0.getX());
    }
    void doIt(){
      Point2D p0=new Point2D.Double(in.nextDouble(),in.nextDouble());
      Point2D p1=new Point2D.Double(in.nextDouble(),in.nextDouble());
      int q=in.nextInt();
      for(int i=0 ; i<q ; i++){
        Point2D p2=new Point2D.Double(in.nextDouble(),in.nextDouble());
        Point2D ans=projection(new Line2D.Double(p0,p1),p2);
        System.out.printf("%.9f %.9f\n",ans.getX(),ans.getY());
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     AOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C()C.newAOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C()C().doIt() ;C.newAOJCGL    AOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C()C.newAOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C()C().doIt() ;C().doIt()C.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C()C.newAOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C()C().doIt() ;C.newAOJCGL    AOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C()C.newAOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C()C().doIt() ;C().doIt()C()C.newAOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C()C.newAOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C()C().doIt() ;C.newAOJCGL    AOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C()C.newAOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C()C().doIt() ;C().doIt()C.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C()C.newAOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C()C().doIt() ;C.newAOJCGL    AOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C()C.newAOJCGLAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C.newAOJCGLAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C.newAOJCGL    AOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C.newAOJCGLAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C.newAOJCGLAOJCGL_1C.newAOJCGL_1C().doIt()C()C().doIt() ; 
C().doIt()C()C().doIt() ;C().doIt()C()C().doIt() );
 class AOJCGL_1C {
   operation projection( l : Line2D, p2 : Point2D) : Point2D
  pre: true
  post: true
  activity: (     var kyori : double ; kyori := l.getP1().distance(l.getP2()) ;
     var angle : double ; angle := angle(l.getP1(), l.getP2(), p2) ;
    var t : double ; t := l.getP1().distance(p2) * (angle)->cos() ;
    var result : Point2D ; result := Double.newDouble(l.getP1().getX() + (l.getP2().getX() - l.getP1().getX()) * t / kyori, l.getP1().getY() + (l.getP2().getY() - l.getP1().getY()) * t / kyori) ;
    return result 
 );
   operation angle( p0 : Point2D, p1 : Point2D, p2 : Point2D) : double
  pre: true
  post: true
  activity: (     return atan2(p2.getY() - p0.getY(), p2.getX() - p0.getX()) - atan2(p1.getY() - p0.getY(), p1.getX() - p0.getX()) );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var p0 : Point2D ; p0 := Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal()) ;
     var p1 : Point2D ; p1 := Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal()) ;
     var q : int ; q := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < q do ( (     var p2 : Point2D ; p2 := Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal()) ;
     var ans : Point2D ; ans := projection(Double.newDouble(p0, p1), p2) ;
     OclFile["System.out"].printf("%.9f %.9f\n", ans.getX(), ans.getY()) )  ;     i := i + 1 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void calc(double x1,double y1,double x2,double y2,double px,double py){
    if(y1==y2)System.out.println(px+" "+y1);
    else if(x1==x2)System.out.println(x1+" "+py);
    else {
      double katamuki1=(y2-y1)/(x2-x1);
      double seppen1=-katamuki1*x1+y1 ;
      double katamuki2=-1.0/katamuki1 ;
      double seppen2=-katamuki2*px+py ;
      double ansx=(seppen2-seppen1)/(katamuki1-katamuki2);
      double ansy=ansx*katamuki1+seppen1 ;
      System.out.println(ansx+" "+ansy);
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x1=sc.nextInt();
    int y1=sc.nextInt();
    int x2=sc.nextInt();
    int y2=sc.nextInt();
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      int px=sc.nextInt();
      int py=sc.nextInt();
      calc((double)x1,(double)y1,(double)x2,(double)y2,(double)px,(double)py);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation calc( x1 : double, y1 : double, x2 : double, y2 : double, px : double, py : double) : void
  pre: true
  post: true
  activity: (     if (y1 = y2) then     OclFile["System.out"].println(px + " " + y1) ; else     if (x1 = x2) then     OclFile["System.out"].println(x1 + " " + py) else (     var katamuki1 : double ; katamuki1 := (y2 - y1) / (x2 - x1) ;
     var seppen1 : double ; seppen1 := -katamuki1 * x1 + y1 ;
    var katamuki2 : double ; katamuki2 := -1.0 / katamuki1 ;
    var seppen2 : double ; seppen2 := -katamuki2 * px + py ;
    var ansx : double ; ansx := (seppen2 - seppen1) / (katamuki1 - katamuki2) ;
    var ansy : double ; ansy := ansx * katamuki1 + seppen1 ;
    OclFile["System.out"].println(ansx + " " + ansy) ; 
 ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x1 : int ; x1 := sc.getCurrent()->toInteger() ;
    var y1 : int ; y1 := sc.getCurrent()->toInteger() ;
    var x2 : int ; x2 := sc.getCurrent()->toInteger() ;
    var y2 : int ; y2 := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var px : int ; px := sc.getCurrent()->toInteger() ;
     var py : int ; py := sc.getCurrent()->toInteger() ;
     execute calc(x1->oclAsType(double), y1->oclAsType(double), x2->oclAsType(double), y2->oclAsType(double), px->oclAsType(double), py->oclAsType(double)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    double xp1,xp2,yp1,yp2 ;
    int q ;
    double[] xp,yp ;
    double ansx,ansy,t ;
    int i ;
    xp1=sc.nextDouble();
    yp1=sc.nextDouble();
    xp2=sc.nextDouble();
    yp2=sc.nextDouble();
    q=sc.nextInt();
    xp=new double[q];
    yp=new double[q];
    for(i=0 ; i<q ; i++){
      xp[i]=sc.nextDouble();
      yp[i]=sc.nextDouble();
    }
    sc.close();
    for(i=0 ; i<q ; i++){
      t=(xp2-xp1)*(xp[i]-xp1)+(yp2-yp1)*(yp[i]-yp1);
      t=t/((xp2-xp1)*(xp2-xp1)+(yp2-yp1)*(yp2-yp1));
      ansx=xp1+t*(xp2-xp1);
      ansy=yp1+t*(yp2-yp1);
      System.out.printf("%.10f %.10f%n",ansx,ansy);
    }
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var xp1 : double ;
    var xp2 : double ;
    var yp1 : double ;
    var yp2 : double ;
    var q : int ;
    var xp : Sequence(double) ;
    var yp : Sequence(double) ;
    var ansx : double ;
    var ansy : double ;
    var t : double ;
    var i : int ;
    xp1 := sc.nextDouble() ; 
    yp1 := sc.nextDouble() ; 
    xp2 := sc.nextDouble() ; 
    yp2 := sc.nextDouble() ; 
    q := sc.nextInt() ; 
    xp := Integer.subrange(1,q)->collect(0.0) ; 
    yp := Integer.subrange(1,q)->collect(0.0) ; 
        i := 0 ; while i < q do ( (     xp[i+1] := sc.nextDouble() ; 
     yp[i+1] := sc.nextDouble() )  ;     i := i + 1 ) ; 
    sc.close() ; 
        i := 0 ; while i < q do ( (     t := (xp2 - xp1) * (xp[i+1] - xp1) + (yp2 - yp1) * (yp[i+1] - yp1) ; 
     t := t / ((xp2 - xp1) * (xp2 - xp1) + (yp2 - yp1) * (yp2 - yp1)) ; 
    ansx := xp1 + t * (xp2 - xp1) ; 
    ansy := yp1 + t * (yp2 - yp1) ; 
    OclFile["System.out"].printf("%.10f %.10f%n", ansx, ansy) ; 
 )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Initials {
  public static void printInitials(String str){
    int len=str.length();
    str=str.trim();
    String t="" ;
    for(int i=0 ; i<len ; i++){
      char ch=str.charAt(i);
      if(ch!=' '){
        t=t+ch ;
      }
      else {
        System.out.print(Character.toUpperCase(t.charAt(0))+".");
        t="" ;
      }
    }
    String temp="" ;
    for(int j=0 ; j<t.length(); j++){
      if(j==0)temp=temp+Character.toUpperCase(t.charAt(0));
      else temp=temp+Character.toLowerCase(t.charAt(j));
    }
    System.out.println(temp);
  }
  public static void main(String[] args){
    String str="ishita bhuiya" ;
    printInitials(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Initials {
  static   operation printInitials( str : String) : void
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     str := str->trim() ; 
    var t : String ; t := "" ;
        var i : int ; i := 0 ; while i < len do ( (     var ch : String ; ch := str->at(i+1) ;
     if (ch /= ' ') then (     t := t + ch ) else (     OclFile["System.out"].print((t->at(0+1) + "")->toUpperCase() + ".") ; 
     t := "" ) )  ;     i := i + 1 ) ; 
    var temp : String ; temp := "" ;
        var j : int ; j := 0 ; while j < t->size() do ( (     if (j = 0) then     temp := temp + (t->at(0+1) + "")->toUpperCase() ; else     temp := temp + (t->at(j+1) + "")->toLowerCase() ; )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(temp) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "ishita bhuiya" ;
     execute printInitials(str) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int max_sum(int arr[],int n,int k){
    int dp[]=new int[n];
    dp[0]=Math.max(0,arr[0]);
    int i=1 ;
    while(i<k){
      dp[i]=Math.max(dp[i-1],arr[i]);
      i++;
    }
    i=k ;
    while(i<n){
      dp[i]=Math.max(dp[i-1],arr[i]+dp[i-k]);
      i++;
    }
    return dp[n-1];
  }
  public static void main(String[] args){
    int arr[]={
      1,2,-2,4,3,1 };
      int n=arr.length ;
      int k=4 ;
      System.out.println(max_sum(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation max_sum( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
     dp[0+1] := Set{0, arr[0+1]}->max() ; 
    var i : int ; i := 1 ;
    while (i < k) do (     dp[i+1] := Set{dp[i - 1+1], arr[i+1]}->max() ; 
     i := i + 1 ) ; 
    i := k ; 
    while (i < n) do (     dp[i+1] := Set{dp[i - 1+1], arr[i+1] + dp[i - k+1]}->max() ; 
     i := i + 1 ) ; 
    return dp[n - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,-2,4,3,1} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 4 ;
     OclFile["System.out"].println(max_sum(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Run {
  public static int[] getMin(char[][] grid,boolean forCol){
    int n=grid.length ;
    int m=grid[0] .length ;
    int[] ans ;
    if(! forCol){
      ans=new int[n];
      int i=0 ;
      for(char[] row : grid){
        int currAns=m ;
        for(char c : row){
          if(c=='*')--currAns ;
        }
        ans[i]=currAns ;
++i ;
      }
    }
    else {
      ans=new int[m];
      for(int j=0 ; j<m ; j++){
        int currAns=n ;
        for(char[] chars : grid){
          if(chars[j]=='*')--currAns ;
        }
        ans[j]=currAns ;
      }
    }
    return ans ;
  }
  public static void main(String[] Z)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder op=new StringBuilder();
    int k=Integer.parseInt(br.readLine());
    StringBuilder s=new StringBuilder(k);
    int dig=1 ;
    while(s.length()<k){
      s.append(dig);
++dig ;
    }
    op.append(s.charAt(k-1));
    System.out.println(op);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Run {
  static   operation getMin( grid : Sequence(Sequence(String)), forCol : boolean) : Sequence(int)
  pre: true
  post: true
  activity: (     var n : int ; n := grid->size() ;
     var m : int ; m := grid[0+1]->size() ;
    var ans : Sequence(int) ;
    if (not(forCol)) then (     ans := Integer.subrange(1,n)->collect(0) ; 
     var i : int ; i := 0 ;
     for (row : grid) do ( (     var currAns : int ; currAns := m ;
     for (c : row) do ( (     if (c = '*') then     currAns := currAns - 1 ; else skip )  ) ; 
     ans[i+1] := currAns ; 
     i := i + 1 )  ) ) else (     ans := Integer.subrange(1,m)->collect(0) ; 
         var j : int ; j := 0 ; while j < m do ( (     var currAns : int ; currAns := n ;
     for (chars : grid) do ( (     if (chars[j+1] = '*') then     currAns := currAns - 1 ; else skip )  ) ; 
     ans[j+1] := currAns )  ;     j := j + 1 ) ) ;  
    return ans 
 );
  static   operation main( Z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var op : String ; op := StringLib.newString() ;
    var k : int ; k := (br.readLine())->toInteger() ;
    var s : String ; s := StringLib.newString(k) ;
    var dig : int ; dig := 1 ;
    while (s->size() < k) do (     s := s + StringLib.newString(dig) ; 
     dig := dig + 1 ) ; 
    op := op + StringLib.newString(s->at((k)->char2byte() - 1+1)) ; 
    OclFile["System.out"].println(op) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayList<Integer>x=new ArrayList<Integer>();
    ArrayList<Integer>y=new ArrayList<Integer>();
    int a,b ;
    while(true){
      a=sc.nextInt();
      b=sc.nextInt();
      if(a==0 && b==0)break ;
      x.add(a);
      y.add(b);
    }
    int temp ;
    int i ;
    for(i=0 ; i<x.size(); i++){
      int val1=x.get(i);
      int val2=y.get(i);
      if(val1>val2){
        temp=val2 ;
        val2=val1 ;
        val1=temp ;
      }
      System.out.println(val1+" "+val2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : Sequence(int) ; x := Sequence{} ;
    var y : Sequence(int) ; y := Sequence{} ;
    var a : int ;
    var b : int ;
    while (true) do (     a := sc.getCurrent()->toInteger() ; 
     b := sc.getCurrent()->toInteger() ; 
    if (a = 0 & b = 0) then     break else skip ; 
    x := x->including(a) ; 
    y := y->including(b) ; 
 ) ; 
    var temp : int ;
    var i : int ;
        i := 0 ; while i < x->size() do ( (     var val1 : int ; val1 := x->at(i+1) ;
     var val2 : int ; val2 := y->at(i+1) ;
     if (val1 > val2) then (     temp := val2 ; 
     val2 := val1 ; 
     val1 := temp ) else skip ; 
     OclFile["System.out"].println(val1 + " " + val2) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class A_1177 {
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int k=sc.nextInt();
    String s="" ;
    for(int i=1 ; i<=k ; i++){
      s+=String.valueOf(i);
    }
    System.out.println(s.charAt(k-1));
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_1177 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var k : int ; k := sc.nextInt() ;
    var s : String ; s := "" ;
        var i : int ; i := 1 ; while i <= k do ( (     s := s+(((i) + "")) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s->at(k - 1+1)) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return (str) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SubsetMex {
  public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    String num=scanner.nextLine();
    int n=Integer.parseInt(num);
    int count=0 ;
    String arr[]=new String[n];
    for(int i=0 ; i<n ; i++){
      scanner.nextLine();
      arr[i]=scanner.nextLine();
    }
    for(int i=0 ; i<n ; i++){
      String numsAsStringArr[]=arr[i] .split(" ");
      int[] numArr=new int[numsAsStringArr.length];
      int index=0 ;
      for(String str : numsAsStringArr){
        numArr[index++]=Integer.parseInt(str);
      }
      System.out.println(calculateMex(numArr));
    }
  }
  static int calculateMex(int[] arr){
    int mex=0 ;
    int count[]=new int[101];
    for(int val : arr){
      count[val]++;
    }
    boolean addToFirstSubSet=true,addToSecondSubset=true ;
    for(int i=0 ; i<count.length ; i++){
      if(addToFirstSubSet){
        if(count[i]>=1){
          count[i]--;
        }
        else {
          mex+=i ;
          addToFirstSubSet=false ;
        }
      }
      if(addToSecondSubset){
        if(count[i]>=1){
          count[i]--;
        }
        else {
          mex+=i ;
          addToSecondSubset=false ;
        }
      }
    }
    return mex ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class SubsetMex {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : String ; num := scanner.nextLine() ;
    var n : int ; n := (num)->toInteger() ;
    var count : int ; count := 0 ;
    var arr : Sequence(String) ; arr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     skip ; 
     arr[i+1] := scanner.nextLine() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var numsAsStringArr : Sequence(String) ; numsAsStringArr := arr[i+1]->split(" ") ;
     var numArr : Sequence(int) ; numArr := Integer.subrange(1,numsAsStringArr->size())->collect(0) ;
    var index : int ; index := 0 ;
    for (str : numsAsStringArr) do ( (      numArr[index+1] := (str)->toInteger()  ; index := index + 1 )  ) ; 
    OclFile["System.out"].println(calculateMex(numArr)) ; 
 )  ;     i := i + 1 ) ; 
 );
  static   operation calculateMex( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var mex : int ; mex := 0 ;
     var count : Sequence(int) ; count := Integer.subrange(1,101)->collect(0) ;
    for (val : arr) do ( (     count[val+1] := count[val+1] + 1 )  ) ; 
    var addToFirstSubSet : boolean ; addToFirstSubSet := true ;
    var addToSecondSubset : boolean ; addToSecondSubset := true ;
        var i : int ; i := 0 ; while i < count->size() do ( (     if (addToFirstSubSet) then (     if (count[i+1] >= 1) then (     count[i+1] := count[i+1] - 1 ) else (     mex := mex+(i) ; 
     addToFirstSubSet := false ) ) else skip ; 
     if (addToSecondSubset) then (     if (count[i+1] >= 1) then (     count[i+1] := count[i+1] - 1 ) else (     mex := mex+(i) ; 
     addToSecondSubset := false ) ) else skip )  ;     i := i + 1 ) ; 
    return mex 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Long ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int k=input.nextInt();
    String str=" " ;
    for(int i=1 ; i<=k ; i++)str+=i ;
    System.out.println(str.charAt(k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := input.getCurrent()->toInteger() ;
    var str : String ; str := " " ;
        var i : int ; i := 1 ; while i <= k do (     str := str+(i) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(str->at(k+1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Digits_Sequence {
  static Scanner sc=new Scanner(System.in);
  static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args){
    int k=sc.nextInt();
    String string="" ;
    for(int i=1 ; i<9999 ; i++){
      string=string+i+"" ;
    }
    System.out.println(string.charAt(k-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Digits_Sequence {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := sc.getCurrent()->toInteger() ;
     var string : String ; string := "" ;
         var i : int ; i := 1 ; while i < 9999 do ( (     string := string + i + "" )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(string->at(k - 1+1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countX(int a,int b){
    if(b>a)return 0 ;
    else if(a==b)return-1 ;
    else {
      int x=a-b,ans=0 ;
      for(int i=1 ; i*i<=x ; i++){
        if(x % i==0){
          int d1=i,d2=b-1 ;
          if(i*i!=x)d2=x/i ;
          if(d1>b)ans++;
          if(d2>b)ans++;
        }
      }
      return ans ;
    }
  }
  static public void main(String args[]){
    int a=21,b=5 ;
    System.out.println(countX(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countX( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b > a) then     return 0 else     if (a = b) then     return -1 else (     var x : int ; x := a - b ;
    var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i * i <= x do ( (     if (x mod i = 0) then (     var d1 : int ; d1 := i ;
    var d2 : int ; d2 := b - 1 ;
     if (i * i /= x) then     d2 := x / i ; else skip ; 
     if (d1 > b) then     ans := ans + 1 ; else skip ; 
     if (d2 > b) then     ans := ans + 1 ; else skip ) else skip )  ;     i := i + 1 ) ; 
     return ans ) ;  );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 21 ;
    var b : int ; b := 5 ;
     OclFile["System.out"].println(countX(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    ArrayList<Pair>[] g=new ArrayList[n];
    for(int i=0 ; i<n ; i++){
      g[i]=new ArrayList<>();
    }
    for(int i=0 ; i<m ; i++){
      int l=sc.nextInt()-1 ;
      int r=sc.nextInt()-1 ;
      int d=sc.nextInt();
      g[l] .add(new Pair(r,d));
      g[r] .add(new Pair(l,-d));
    }
    int[] p=new int[n];
    boolean[] used=new boolean[n];
    boolean ans=true ;
    for(int i=0 ; i<n ; i++){
      if(used[i])continue ;
      ArrayDeque<Integer>q=new ArrayDeque<>();
      q.add(i);
      used[i]=true ;
      while(! q.isEmpty()){
        int v=q.poll();
        for(Pair na : g[v]){
          int nv=na.x,nd=na.y ;
          if(used[nv]){
            if(p[nv]!=p[v]+nd){
              ans=false ;
              break ;
            }
          }
          else {
            p[nv]=p[v]+nd ;
            used[nv]=true ;
            q.add(nv);
          }
        }
        if(! ans)break ;
      }
      if(! ans)break ;
    }
    System.out.println(ans ? "Yes" : "No");
    sc.close();
  }
  static class Pair {
    final int x ;
    final int y ;
    Pair(int x,int y){
      this.x=x ;
      this.y=y ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var g : Sequence(Sequence(Map)) ; g := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     g[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var l : int ; l := sc.getCurrent()->toInteger() - 1 ;
     var r : int ; r := sc.getCurrent()->toInteger() - 1 ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    g[l+1]->excludes(Map(r, d)) ; 
    g[r+1]->excludes(Map(l, -d)) ; 
 )  ;     i := i + 1 ) ; 
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    var used : Sequence(boolean) ; used := Integer.subrange(1,n)->collect(false) ;
    var ans : boolean ; ans := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (used[i+1]) then     continue else skip ; 
     var q : Sequence(int) ; q := ArrayDeque<OclAny>.newArrayDeque() ;
    q := q->including(i) ; 
    used[i+1] := true ; 
    while (not(q->isEmpty())) do (     var v : int ; v := q->min() ;
     for (na : g[v+1]) do ( (     var nv : int ; nv := na.x ;
    var nd : int ; nd := na.y ;
     if (used[nv+1]) then (     if (p[nv+1] /= p[v+1] + nd) then (     ans := false ; 
     break ) else skip ) else (     p[nv+1] := p[v+1] + nd ; 
     used[nv+1] := true ; 
     q := q->including(nv) ) )  ) ; 
     if (not(ans)) then     break else skip ) ; 
    if (not(ans)) then     break else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if ans then "Yes" else "No" endif) ; 
    skip ; 
 );
  static class Pair {
   attribute x : int;
   attribute y : int;
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int[] belongs=null ;
  static int[] states=null ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int m=Integer.parseInt(sc.next());
    states=new int[n];
    belongs=new int[n];
    for(int i=0 ; i<n ; i++){
      belongs[i]=i ;
      states[i]=0 ;
    }
    for(int i=0 ; i<m ; i++){
      int l=Integer.parseInt(sc.next())-1 ;
      int r=Integer.parseInt(sc.next())-1 ;
      int d=Integer.parseInt(sc.next());
      if(! merge(l,r,d)){
        System.out.println("No");
        sc.close();
        return ;
      }
    }
    System.out.println("Yes");
    sc.close();
  }
  public static int updateBelongs(int a){
    if(a==belongs[a]){
      return a ;
    }
    else {
      int temp=belongs[a];
      belongs[a]=updateBelongs(belongs[a]);
      states[a]+=states[temp];
      return belongs[a];
    }
  }
  public static boolean merge(int l,int r,int d){
    int lb=updateBelongs(l);
    int rb=updateBelongs(r);
    if(lb==rb){
      return states[r]==states[l]+d ;
    }
    else {
      belongs[rb]=lb ;
      states[rb]=states[l]+d-states[r];
      return true ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute belongs : Sequence(int) := null;
  static   attribute states : Sequence(int) := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var m : int ; m := (sc.getCurrent())->toInteger() ;
    states := Integer.subrange(1,n)->collect(0) ; 
    belongs := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     belongs[i+1] := i ; 
     states[i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var l : int ; l := (sc.getCurrent())->toInteger() - 1 ;
     var r : int ; r := (sc.getCurrent())->toInteger() - 1 ;
     var d : int ; d := (sc.getCurrent())->toInteger() ;
     if (not(merge(l, r, d))) then (     OclFile["System.out"].println("No") ; 
     skip ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Yes") ; 
    skip ; 
 );
  static   operation updateBelongs( a : int) : int
  pre: true
  post: true
  activity: (     if (a = belongs[a+1]) then (     return a ) else (     var temp : int ; temp := belongs[a+1] ;
     belongs[a+1] := updateBelongs(belongs[a+1]) ; 
     states[a+1] := states[a+1]+(states[temp+1]) ; 
     return belongs[a+1] ) );
  static   operation merge( l : int, r : int, d : int) : boolean
  pre: true
  post: true
  activity: (     var lb : int ; lb := updateBelongs(l) ;
     var rb : int ; rb := updateBelongs(r) ;
     if (lb = rb) then (     return states[r+1] = states[l+1] + d ) else (     belongs[rb+1] := lb ; 
     states[rb+1] := states[l+1] + d - states[r+1] ; 
     return true ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int M=scanner.nextInt();
    Node[] nodes=new Node[N];
    for(int i=0 ; i<N ; i++)nodes[i]=new Node();
    for(int i=0 ; i<M ; i++){
      int l=scanner.nextInt()-1 ;
      int r=scanner.nextInt()-1 ;
      int d=scanner.nextInt();
      nodes[l] .edges.add(new Edge(nodes[r],d));
      nodes[r] .edges.add(new Edge(nodes[l],-d));
    }
    for(Node node : nodes){
      if(! node.visited){
        if(! dfs(node)){
          System.out.println("No");
          return ;
        }
      }
    }
    System.out.println("Yes");
  }
  private static boolean dfs(Node node){
    node.visited=true ;
    for(Edge edge : node.edges){
      Node a=edge.to ;
      if(! a.visited){
        a.pos=node.pos+edge.dist ;
        if(! dfs(a))return false ;
      }
      else if(a.pos!=node.pos+edge.dist){
        return false ;
      }
    }
    return true ;
  }
  private static class Node {
    private int pos ;
    private List<Edge>edges=new ArrayList<>();
    private boolean visited ;
  }
  private static class Edge {
    private final Node to ;
    private final int dist ;
    private Edge(Node to,int dist){
      this.to=to ;
      this.dist=dist ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var M : int ; M := scanner.getCurrent()->toInteger() ;
    var nodes : Sequence(Node) ; nodes := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do (     nodes[i+1] := Node.newNode() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var l : int ; l := scanner.getCurrent()->toInteger() - 1 ;
     var r : int ; r := scanner.getCurrent()->toInteger() - 1 ;
    var d : int ; d := scanner.getCurrent()->toInteger() ;
    nodes[l+1].edges->excludes(Edge.newEdge(nodes[r+1], d)) ; 
    nodes[r+1].edges->excludes(Edge.newEdge(nodes[l+1], -d)) ; 
 )  ;     i := i + 1 ) ; 
    for (node : nodes) do ( (     if (not(node.visited)) then (     if (not(dfs(node))) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ) else skip )  ) ; 
    OclFile["System.out"].println("Yes") ; 
 );
  static   operation dfs( node : Node) : boolean
  pre: true
  post: true
  activity: (     node.visited := true ; 
     for (edge : node.edges) do ( (     var a : Node ; a := edge.to ;
     if (not(a.visited)) then (     a.pos := node.pos + edge.dist ; 
     if (not(dfs(a))) then     return false else skip ) else     if (a.pos /= node.pos + edge.dist) then (     return false ) else skip ; )  ) ; 
     return true );
  static class Node {
   attribute pos : int;
   attribute edges : Sequence(Edge) := Sequence{};
   attribute visited : boolean;
}
  static class Edge {
   attribute to : Node;
   attribute dist : int;
   static operation newEdge( to : Node, dist : int) : Edge
  pre: true
  post: true
  activity:
  ( var self : Edge ;
    self := createEdge();
    self.initialise(to, dist);
    return self );
  operation initialise( to : Node, dist : int) : void
  pre: true  post: true
  activity: (     self.to := to ; 
     self.dist := dist );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int nA=sc.nextInt();
      int nB=sc.nextInt();
      int k=sc.nextInt();
      int m=sc.nextInt();
      int[] a=new int[nA];
      int[] b=new int[nB];
      for(int i=0 ; i<nA ; i++)a[i]=sc.nextInt();
      for(int i=0 ; i<nB ; i++)b[i]=sc.nextInt();
      if(a[k-1]<b[nB-m])System.out.println("YES");
      else System.out.println("NO");
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var nA : int ; nA := sc.getCurrent()->toInteger() ;
    var nB : int ; nB := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,nA)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,nB)->collect(0) ;
        var i : int ; i := 0 ; while i < nA do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < nB do (     b[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    if (a[k - 1+1] < b[nB - m+1]) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MainClass {
  public static void main(String[] agrs){
    Scanner sc=new Scanner(System.in);
    int nA=sc.nextInt();
    int nB=sc.nextInt();
    int k=sc.nextInt();
    int m=sc.nextInt();
    int[] a=new int[nA];
    int[] b=new int[nB];
    for(int i=0 ; i<nA ; i++)a[i]=sc.nextInt();
    for(int i=0 ; i<nB ; i++)b[i]=sc.nextInt();
    if(a[k-1]<b[nB-m])System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var nA : int ; nA := sc.getCurrent()->toInteger() ;
    var nB : int ; nB := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,nA)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,nB)->collect(0) ;
        var i : int ; i := 0 ; while i < nA do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < nB do (     b[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    if (a[k - 1+1] < b[nB - m+1]) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int x,y,temp ;
    for(int in_counta=0 ; in_counta<3000 ; in_counta++){
      x=scanner.nextInt();
      y=scanner.nextInt();
      if(x==0 && y==0){
        scanner.close();
        break ;
      }
      if(x>y){
        temp=x ;
        x=y ;
        y=temp ;
      }
      System.out.println(x+" "+y);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ;
    var y : int ;
    var temp : int ;
         var in_counta : int ; in_counta := 0 ; while in_counta < 3000 do ( (     x := scanner.getCurrent()->toInteger() ; 
     y := scanner.getCurrent()->toInteger() ; 
    if (x = 0 & y = 0) then (     skip ; 
     break ) else skip ; 
    if (x > y) then (     temp := x ; 
     x := y ; 
     y := temp ) else skip ; 
    OclFile["System.out"].println(x + " " + y) ; 
 )  ;     in_counta := in_counta + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Ishu {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int na,nb,k,m,i ;
    int[] A=new int[100000];
    int[] B=new int[100000];
    na=scan.nextInt();
    nb=scan.nextInt();
    k=scan.nextInt();
    m=scan.nextInt();
    for(i=0 ; i<na ; ++i)A[i]=scan.nextInt();
    for(i=0 ; i<nb ; ++i)B[i]=scan.nextInt();
    if(A[k-1]<B[nb-m])System.out.println("Yes ");
    else System.out.println("No ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ishu {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var na : int ;
    var nb : int ;
    var k : int ;
    var m : int ;
    var i : int ;
    var A : Sequence(int) ; A := Integer.subrange(1,100000)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,100000)->collect(0) ;
    na := scan.getCurrent()->toInteger() ; 
    nb := scan.getCurrent()->toInteger() ; 
    k := scan.getCurrent()->toInteger() ; 
    m := scan.getCurrent()->toInteger() ; 
        i := 0 ; while i < na do (     A[i+1] := scan.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < nb do (     B[i+1] := scan.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    if (A[k - 1+1] < B[nb - m+1]) then     OclFile["System.out"].println("Yes ") else     OclFile["System.out"].println("No ") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    int i=0 ;
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    int b=in.nextInt();
    int[] arr=new int[a];
    int[] nums=new int[b];
    int k=in.nextInt();
    int m=in.nextInt();
    for(i=0 ; i<arr.length ; i++){
      arr[i]=in.nextInt();
    }
    for(int j=0 ; j<nums.length ; j++){
      nums[j]=in.nextInt();
    }
    if(arr[k-1]<nums[b-m]){
      System.out.println("YES");
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,a)->collect(0) ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,b)->collect(0) ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
        i := 0 ; while i < arr->size() do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < nums->size() do ( (     nums[j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    if (arr[k - 1+1] < nums[b - m+1]) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    char[] s=sc.next().toCharArray();
    int len=s.length ;
    char prev=s[0];
    int cnt=1 ;
    ArrayList<Integer>li=new ArrayList<Integer>();
    long n=sc.nextLong();
    for(int i=1 ; i<len ; i++){
      if(prev==s[i]){
        cnt++;
      }
      else {
        li.add(cnt);
        cnt=1 ;
        prev=s[i];
      }
    }
    li.add(cnt);
    long ans=0 ;
    if(li.size()==1){
      ans=(li.get(0)*n)/2 ;
    }
    else if(s[0]==s[len-1]){
      int cf=li.get(0);
      int cl=li.get(li.size()-1);
      for(int i=1 ; i<li.size()-1 ; i++){
        ans+=li.get(i)/2*n ;
      }
      ans+=cf/2+cl/2+(cf+cl)/2*(n-1);
    }
    else {
      for(int i : li){
        ans+=i/2*n ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var len : int ; len := s->size() ;
    var prev : String ; prev := s[0+1] ;
    var cnt : int ; cnt := 1 ;
    var li : Sequence(int) ; li := Sequence{} ;
    var n : long ; n := sc.getCurrent()->toLong() ;
        var i : int ; i := 1 ; while i < len do ( (     if (prev = s[i+1]) then (     cnt := cnt + 1 ) else (     li := li->including(cnt) ; 
     cnt := 1 ; 
     prev := s[i+1] ) )  ;     i := i + 1 ) ; 
    li := li->including(cnt) ; 
    var ans : long ; ans := 0 ;
    if (li->size() = 1) then (     ans := (li->at(0+1) * n) / 2 ) else     if (s[0+1] = s[len - 1+1]) then (     var cf : int ; cf := li->at(0+1) ;
     var cl : int ; cl := li->at(li->size() - 1+1) ;
         var i : int ; i := 1 ; while i < li->size() - 1 do ( (     ans := ans+(li->at(i+1) / 2 * n) )  ;     i := i + 1 ) ; 
     ans := ans+(cf / 2 + cl / 2 + (cf + cl) / 2 * (n - 1)) ) else (     for (i : li) do ( (     ans := ans+(i / 2 * n) )  ) ) ;  ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    long A=s.nextLong(),B=s.nextLong(),C=s.nextLong();
    if(A==0 && B==0){
      System.out.println(C==0 ?-1 : 0);
    }
    else if(A==0){
      System.out.println(1);
      System.out.println(1.0*-C/B);
    }
    else {
      long discriminant=B*B-4*A*C ;
      if(discriminant<0)System.out.println(0);
      else if(discriminant==0){
        System.out.println(1);
        System.out.println(1.0*-B/(2.0*A));
      }
      else {
        System.out.println(2);
        double num1=(-B-Math.sqrt(discriminant))/(2.0*A);
        double num2=(-B+Math.sqrt(discriminant))/(2.0*A);
        if(num1<num2){
          System.out.println(num1);
          System.out.println(num2);
        }
        else {
          System.out.println(num2);
          System.out.println(num1);
        }
      }
    }
    s.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : long ; A := s.getCurrent()->toLong() ;
    var B : long ; B := s.getCurrent()->toLong() ;
    var C : long ; C := s.getCurrent()->toLong() ;
     if (A = 0 & B = 0) then (     OclFile["System.out"].println(if C = 0 then -1 else 0 endif) ) else     if (A = 0) then (     OclFile["System.out"].println(1) ; 
     OclFile["System.out"].println(1.0 * -C / B) ) else (     var discriminant : long ; discriminant := B * B - 4 * A * C ;
     if (discriminant < 0) then     OclFile["System.out"].println(0) ; else     if (discriminant = 0) then (     OclFile["System.out"].println(1) ; 
     OclFile["System.out"].println(1.0 * -B / (2.0 * A)) ) else (     OclFile["System.out"].println(2) ; 
     var num1 : double ; num1 := (-B - (discriminant)->sqrt()) / (2.0 * A) ;
     var num2 : double ; num2 := (-B + (discriminant)->sqrt()) / (2.0 * A) ;
     if (num1 < num2) then (     OclFile["System.out"].println(num1) ; 
     OclFile["System.out"].println(num2) ) else (     OclFile["System.out"].println(num2) ; 
     OclFile["System.out"].println(num1) ) ) ;  ) ;  ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    double a=sc.nextDouble();
    double b=sc.nextDouble();
    double c=sc.nextDouble();
    if(a==0 && b!=0){
      double ans=-(c/b);
      System.out.format("1\n%.5f",ans);
    }
    else if(a==0 && b==0 && c==0){
      System.out.println("-1");
    }
    else if(a==0 && b==0 && c!=0){
      System.out.println("0");
    }
    else {
      double r1,r2 ;
      double det=b*b-4*a*c ;
      if(det>0){
        System.out.println("2");
        r1=(-b+Math.sqrt(det))/(2*a);
        r2=(-b-Math.sqrt(det))/(2*a);
        double x=(r1<r2)? r1 : r2 ;
        double y=(r1>r2)? r1 : r2 ;
        System.out.format("%.5f\n%.5f\n",x,y);
      }
      else if(det==0){
        r1=(-b+Math.sqrt(det))/(2*a);
        System.out.format("1\n%.5f",r1);
      }
      else System.out.println("0");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : double ; a := sc.getCurrent()->toReal() ;
    var b : double ; b := sc.getCurrent()->toReal() ;
    var c : double ; c := sc.getCurrent()->toReal() ;
    if (a = 0 & b /= 0) then (     var ans : double ; ans := -(c / b) ;
     OclFile["System.out"].format("1\n%.5f", ans) ) else     if (a = 0 & b = 0 & c = 0) then (     OclFile["System.out"].println("-1") ) else     if (a = 0 & b = 0 & c /= 0) then (     OclFile["System.out"].println("0") ) else (     var r1 : double ;
    var r2 : double ;
     var det : double ; det := b * b - 4 * a * c ;
     if (det > 0) then (     OclFile["System.out"].println("2") ; 
     r1 := (-b + (det)->sqrt()) / (2 * a) ; 
    r2 := (-b - (det)->sqrt()) / (2 * a) ; 
    var x : double ; x := if (r1 < r2) then r1 else r2 endif ;
    var y : double ; y := if (r1 > r2) then r1 else r2 endif ;
    OclFile["System.out"].format("%.5f\n%.5f\n", x, y) ; 
 ) else     if (det = 0) then (     r1 := (-b + (det)->sqrt()) / (2 * a) ; 
     OclFile["System.out"].format("1\n%.5f", r1) ) else     OclFile["System.out"].println("0") ; ;  ) ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double average(int a[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=a[i];
    return sum/n ;
  }
  public static void main(String[] args){
    int arr[]={
      10,2,3,4,5,6,7,8,9 };
      int n=arr.length ;
      System.out.println(average(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation average( a : Sequence(int), n : int) : double
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+(a[i+1]) ;  ;     i := i + 1 ) ; 
     return sum / n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,2,3,4,5,6,7,8,9} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(average(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class Test {
  static String isKSortedArray(int arr[],int n,int k){
    int aux[]=new int[n];
    for(int i=0 ; i<n ; i++)aux[i]=arr[i];
    Arrays.sort(aux);
    for(int i=0 ; i<n ; i++){
      int j=Arrays.binarySearch(aux,arr[i]);
      if(Math.abs(i-j)>k)return "No" ;
    }
    return "Yes" ;
  }
  public static void main(String args[]){
    int arr[]={
      3,2,1,5,6,4 };
      int k=2 ;
      System.out.println("Is it a k sorted array ?: "+isKSortedArray(arr,arr.length,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation isKSortedArray( arr : Sequence(int), n : int, k : int) : String
  pre: true
  post: true
  activity: (     var aux : Sequence(int) ; aux := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     aux[i+1] := arr[i+1] ;  ;     i := i + 1 ) ; 
    aux := aux->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     var j : int ; j := (aux->indexOf(arr[i+1]) - 1) ;
     if (if i - j < 0 then -(i - j) else i - j endif > k) then     return "No" else skip )  ;     i := i + 1 ) ; 
    return "Yes" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,2,1,5,6,4} ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println("Is it a k sorted array ?: " + isKSortedArray(arr, arr->size(), k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int nCr(int n,int k){
    int C[][]=new int[n+1][k+1];
    int i,j ;
    for(i=0 ; i<=n ; i++){
      for(j=0 ; j<=Math.min(i,k); j++){
        if(j==0 || j==i)C[i][j]=1 ;
        else C[i][j]=C[i-1][j-1]+C[i-1][j];
      }
    }
    return C[n][k];
  }
  static double resultOfAllSubsets(int arr[],int N){
    double result=0.0 ;
    int sum=0 ;
    for(int i=0 ; i<N ; i++)sum+=arr[i];
    for(int n=1 ; n<=N ; n++)result+=(double)(sum*(nCr(N-1,n-1)))/n ;
    return result ;
  }
  public static void main(String[] args){
    int arr[]={
      2,3,5,7 };
      int N=arr.length ;
      System.out.println(resultOfAllSubsets(arr,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nCr( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var C : Sequence(Sequence(int)) ; C := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,k + 1)->collect(0)) ;
     var i : int ;
    var j : int ;
         i := 0 ; while i <= n do ( (         j := 0 ; while j <= Set{i, k}->min() do ( (     if (j = 0 or j = i) then     C[i+1][j+1] := 1 ; else     C[i+1][j+1] := C[i - 1+1][j - 1+1] + C[i - 1+1][j+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return C[n+1][k+1] );
  static   operation resultOfAllSubsets( arr : Sequence(int), N : int) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0.0 ;
     var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
        var n : int ; n := 1 ; while n <= N do (     result := result+((sum * (nCr(N - 1, n - 1)))->oclAsType(double) / n) ;  ;     n := n + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,5,7} ;
     var N : int ; N := arr->size() ;
     OclFile["System.out"].println(resultOfAllSubsets(arr, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static long productPrimeFactors(int n){
    long product=1 ;
    if(n % 2==0){
      product*=2 ;
      while(n % 2==0)n=n/2 ;
    }
    for(int i=3 ; i<=Math.sqrt(n); i=i+2){
      if(n % i==0){
        product=product*i ;
        while(n % i==0)n=n/i ;
      }
    }
    if(n>2)product=product*n ;
    return product ;
  }
  public static void main(String[] args){
    int n=44 ;
    System.out.print(productPrimeFactors(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation productPrimeFactors( n : int) : long
  pre: true
  post: true
  activity: (     var product : long ; product := 1 ;
     if (n mod 2 = 0) then (     product := product*(2) ; 
     while (n mod 2 = 0) do     n := n / 2 ; ) else skip ; 
        var i : int ; i := 3 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     product := product * i ; 
     while (n mod i = 0) do     n := n / i ; ) else skip )  ;     i := i + 2 ) ; 
    if (n > 2) then     product := product * n ; else skip ; 
    return product 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 44 ;
     OclFile["System.out"].print(productPrimeFactors(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int temp=0 ;
    String s=in.next();
    for(int i=0 ; i<n-1 ; i++){
      if(s.charAt(i)==s.charAt(i+1)){
        temp++;
      }
    }
    System.out.println(temp);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var temp : int ; temp := 0 ;
    var s : String ; s := in.getCurrent() ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (s->at(i+1) = s->at(i + 1+1)) then (     temp := temp + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(temp) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str ;
    String[] arrStr ;
    StringBuilder output=new StringBuilder();
    int a,b ;
    try {
      while(true){
        str=br.readLine();
        if(str.equals("0 0")){
          break ;
        }
        arrStr=str.split(" ");
        a=Integer.parseInt(arrStr[0]);
        b=Integer.parseInt(arrStr[1]);
        if(a<b){
          output.append(a).append(" ").append(b).append("\n");
        }
        else {
          output.append(b).append(" ").append(a).append("\n");
        }
      }
      System.out.print(output.toString());
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ;
    var arrStr : Sequence(String) ;
    var output : String ; output := StringLib.newString() ;
    var a : int ;
    var b : int ;
    try (     while (true) do (     str := br.readLine() ; 
     if (str = "0 0") then (     break ) else skip ; 
    arrStr := str->split(" ") ; 
    a := (arrStr[0+1])->toInteger() ; 
    b := (arrStr[1+1])->toInteger() ; 
    if (a < b) then (     output := output + StringLib.newString(a) + StringLib.newString(" ") + StringLib.newString(b) + StringLib.newString("\n") ) else (     output := output + StringLib.newString(b) + StringLib.newString(" ") + StringLib.newString(a) + StringLib.newString("\n") ) ;  
 ) ; 
     OclFile["System.out"].print(output+"") )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Stones_on_the_Table {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    String s=scan.next();
    char[] array=new char[n];
    for(int i=0 ; i<n ; i++){
      array[i]=s.charAt(i);
    }
    int counter=0 ;
    int R=0 ;
    int G=0 ;
    int B=0 ;
    for(int i=0 ; i<n ; i++){
      counter++;
      if(n>1){
        if(array[i]=='R' && array[counter]=='R'){
          R++;
        }
        else if(array[i]=='G' && array[counter]=='G'){
          G++;
        }
        else if(array[i]=='B' && array[counter]=='B'){
          B++;
        }
        if(counter==n-1){
          break ;
        }
      }
      else {
        R=0 ;
        G=0 ;
        B=0 ;
      }
    }
    int max=R+G+B ;
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Stones_on_the_Table {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var s : String ; s := scan.getCurrent() ;
    var array : Sequence(String) ; array := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := s->at(i+1) )  ;     i := i + 1 ) ; 
    var counter : int ; counter := 0 ;
    var R : int ; R := 0 ;
    var G : int ; G := 0 ;
    var B : int ; B := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     counter := counter + 1 ; 
     if (n > 1) then (     if (array[i+1] = 'R' & array[counter+1] = 'R') then (     R := R + 1 ) else     if (array[i+1] = 'G' & array[counter+1] = 'G') then (     G := G + 1 ) else     if (array[i+1] = 'B' & array[counter+1] = 'B') then (     B := B + 1 ) else skip ; ;  ;  
     if (counter = n - 1) then (     break ) else skip ) else (     R := 0 ; 
     G := 0 ; 
     B := 0 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := R + G + B ;
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Rough {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String name=sc.next();
    char c[]=name.toCharArray();
    int count=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if(c[i]==c[i+1]){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Rough {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var name : String ; name := sc.getCurrent() ;
    var c : Sequence(String) ; c := name->characters() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (c[i+1] = c[i + 1+1]) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Codeforces {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    String str=input.next();
    int count=0,first=0,second=1,i=1 ;
    while(i<str.length()){
      if(str.charAt(first)==str.charAt(second))count++;
      i++;
      first++;
      second++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var str : String ; str := input.getCurrent() ;
    var count : int ; count := 0 ;
    var first : int ; first := 0 ;
    var second : int ; second := 1 ;
    var i : int ; i := 1 ;
    while (i < str->size()) do (     if (str->at(first+1) = str->at(second+1)) then     count := count + 1 ; else skip ; 
     i := i + 1 ; 
     first := first + 1 ; 
     second := second + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    AConnectionAndDisconnection solver=new AConnectionAndDisconnection();
    solver.solve(1,in,out);
    out.close();
  }
  static class AConnectionAndDisconnection {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      String s=in.next();
      int k=in.nextInt();
      int from=-1 ;
      int to=s.length();
      for(int i=1 ; i<s.length(); i++){
        if(s.charAt(i)!=s.charAt(0)){
          from=i ;
          break ;
        }
      }
      if(from==-1){
        long ans=1L*s.length()*k/2 ;
        out.println(ans);
        return ;
      }
      for(int i=1 ; i<s.length(); i++){
        if(s.charAt(i)!=s.charAt(0)){
          to=i+1 ;
        }
      }
      long ans=0 ;
      for(int i=from ; i<to ; i++){
        if(i<s.length()&& s.charAt(i)==s.charAt(i-1)){
          ans+=k ;
          i++;
        }
      }
      int pref=from ;
      int suff=(s.length()-to);
      ans+=pref/2 ;
      ans+=suff/2 ;
      ans+=1L*(pref+suff)/2*(k-1);
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : AConnectionAndDisconnection ; solver := AConnectionAndDisconnection.newAConnectionAndDisconnection() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class AConnectionAndDisconnection {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.getCurrent() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var from : int ; from := -1 ;
    var to : int ; to := s->size() ;
        var i : int ; i := 1 ; while i < s->size() do ( (     if (s->at(i+1) /= s->at(0+1)) then (     from := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (from = -1) then (     var ans : long ; ans := 1L * s->size() * k / 2 ;
     skip ; 
     return ) else skip ; 
        var i : int ; i := 1 ; while i < s->size() do ( (     if (s->at(i+1) /= s->at(0+1)) then (     to := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := from ; while i < to do ( (     if (i < s->size() & s->at(i+1) = s->at(i - 1+1)) then (     ans := ans+(k) ; 
     i := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    var pref : int ; pref := from ;
    var suff : int ; suff := (s->size() - to) ;
    ans := ans+(pref / 2) ; 
    ans := ans+(suff / 2) ; 
    ans := ans+(1L * (pref + suff) / 2 * ((k)->char2byte() - 1)) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int numStones=in.nextInt();
    char[] stonesColor=in.next().toCharArray();
    char previousColor=stonesColor[0];
    int ans=0 ;
    for(int i=1 ; i<numStones ; i++){
      char currentColor=stonesColor[i];
      if(currentColor==previousColor)ans++;
      previousColor=currentColor ;
    }
    out.println(ans);
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new FileReader("sub.in"));
      }
      catch(FileNotFoundException ex){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException ex){
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException ex){
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var numStones : int ; numStones := in.nextInt() ;
    var stonesColor : Sequence(String) ; stonesColor := in.next()->characters() ;
    var previousColor : String ; previousColor := stonesColor[0+1] ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < numStones do ( (     var currentColor : String ; currentColor := stonesColor[i+1] ;
     if (currentColor = previousColor) then     ans := ans + 1 ; else skip ; 
     previousColor := currentColor )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("sub.in"))) )   catch (ex : FileNotFoundException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (ex : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (ex : IOException) do skip
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] nums=new int[n];
      int count=0 ;
      for(int i=0 ; i<n ; i++){
        nums[i]=sc.nextInt();
        if(nums[i]<0){
          count++;
          nums[i]=-nums[i];
        }
      }
      int i=0 ;
      while(count-->0){
        nums[i]=-nums[i];
        i++;
      }
      int flag=0 ;
      for(int j=1 ; j<n ; j++){
        if(nums[j]<nums[j-1]){
          flag++;
        }
      }
      if(flag==0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := sc.getCurrent()->toInteger() ; 
     if (nums[i+1] < 0) then (     count := count + 1 ; 
     nums[i+1] := -nums[i+1] ) else skip )  ;     i := i + 1 ) ; 
    var i : int ; i := 0 ;
        while (count > 0) do (        count := count - 1 ;     skip ; (     nums[i+1] := -nums[i+1] ; 
     i := i + 1 ) ;  ) ;  
    var flag : int ; flag := 0 ;
        var j : int ; j := 1 ; while j < n do ( (     if (nums[j+1] < nums[j - 1+1]) then (     flag := flag + 1 ) else skip )  ;     j := j + 1 ) ; 
    if (flag = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int tc=sc.nextInt();
    for(int test=1 ; test<=tc ; test++){
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
      int i=0,j=0 ;
      while(i<n){
        if(arr[i]<0){
          arr[j++]*=-1 ;
          arr[i]*=-1 ;
        }
        i++;
      }
      if(isSorted(arr)){
        pw.println("YES");
      }
      else pw.println("NO");
    }
    pw.flush();
  }
  private static boolean isSorted(int[] arr){
    for(int i=1 ; i<arr.length ; i++)if(arr[i]<arr[i-1])return false ;
    return true ;
  }
  static class Scanner {
    BufferedReader br ;
    StringTokenizer st ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(FileReader f){
      br=new BufferedReader(f);
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public int[] nextIntArr(int n)throws IOException {
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=Integer.parseInt(next());
      }
      return arr ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var tc : int ; tc := sc.getCurrent()->toInteger() ;
        var test : int ; test := 1 ; while test <= tc do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    while (i < n) do (     if (arr[i+1] < 0) then (     arr[j+1] := arr[j+1]*(-1) ; 
     arr[i+1] := arr[i+1]*(-1) ) else skip ; 
     i := i + 1 ) ; 
    if (isSorted(arr)) then (     skip ) else     skip ; ;  
 )  ;     test := test + 1 ) ; 
    skip ; 
 );
  static   operation isSorted( arr : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < arr->size() do (     if (arr[i+1] < arr[i - 1+1]) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static class Scanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( f : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(f) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArr( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (next())->toInteger() )  ;     i := i + 1 ) ; 
     return arr );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int k=in.nextInt();
      Integer[] a=new Integer[n];
      for(int i=0 ; i<n ; i++)a[i]=in.nextInt();
      Arrays.sort(a);
      int num=n ;
      int num1=1 ;
      for(int i=1 ; i<n ; i++){
        if(a[i]>a[i-1] && a[i]<=a[i-1]+k)num-=num1 ;
        else if(a[i] .equals(a[i-1]))num1++;
        if(! a[i] .equals(a[i-1]))num1=1 ;
      }
      out.println(num);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var k : int ; k := in.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.nextInt() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var num : int ; num := n ;
    var num1 : int ; num1 := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] > a[i - 1+1] & a[i+1] <= a[i - 1+1] + k) then     num := num-(num1) else     if (a[i+1] = a[i - 1+1]) then     num1 := num1 + 1 ; else skip ; ;  
     if (not(a[i+1] = a[i - 1+1])) then     num1 := 1 ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int power(int x,int y){
    if(y==0)return 1 ;
    else if(y % 2==0)return power(x,y/2)*power(x,y/2);
    else return x*power(x,y/2)*power(x,y/2);
  }
  public static void main(String[] args){
    int x=2 ;
    int y=3 ;
    System.out.printf("%d",power(x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation power( x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (y = 0) then     return 1 else     if (y mod 2 = 0) then     return power(x, y / 2) * power(x, y / 2) else     return x * power(x, y / 2) * power(x, y / 2) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 2 ;
     var y : int ; y := 3 ;
     OclFile["System.out"].printf("%d", power(x, y)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int charVal(String s,int i){
    if(s.charAt(i)=='0'){
      return 0 ;
    }
    else if(s.charAt(i)=='1'){
      return 1 ;
    }
    else {
      return 2 ;
    }
  }
  static int countMinimalReplacements(String s,int i,int prev,int dp[][],int n){
    if(i==n){
      return 0 ;
    }
    if(dp[i][prev]!=-1){
      return dp[i][prev];
    }
    int val=charVal(s,i);
    int ans=Integer.MAX_VALUE ;
    if(val==prev){
      val=0 ;
      for(int cur=0 ; cur<=2 ; cur++){
        if(cur==prev){
          continue ;
        }
        val=1+countMinimalReplacements(s,i+1,cur,dp,n);
        ans=Math.min(ans,val);
      }
    }
    else {
      ans=countMinimalReplacements(s,i+1,val,dp,n);
    }
    return dp[i][val]=ans ;
  }
  public static void main(String[] args){
    String s="201220211" ;
    int n=s.length();
    int dp[][]=new int[n][3];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<3 ; j++){
        dp[i][j]=-1 ;
      }
    }
    int val=charVal(s,0);
    System.out.println(countMinimalReplacements(s,1,val,dp,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation charVal( s : String, i : int) : int
  pre: true
  post: true
  activity: (     if (s->at(i+1) = '0') then (     return 0 ) else     if (s->at(i+1) = '1') then (     return 1 ) else (     return 2 ) ;  );
  static   operation countMinimalReplacements( s : String, i : int, prev : int, dp : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     if (i = n) then (     return 0 ) else skip ; 
     if (dp[i+1][prev+1] /= -1) then (     return dp[i+1][prev+1] ) else skip ; 
    var val : int ; val := charVal(s, i) ;
    var ans : int ; ans := 2147483647 ;
    if (val = prev) then (     val := 0 ; 
         var cur : int ; cur := 0 ; while cur <= 2 do ( (     if (cur = prev) then (     continue ) else skip ; 
     val := 1 + countMinimalReplacements(s, i + 1, cur, dp, n) ; 
     ans := Set{ans, val}->min() )  ;     cur := cur + 1 ) ) else (     ans := countMinimalReplacements(s, i + 1, val, dp, n) ) ;  
    return dp[i+1][val+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "201220211" ;
     var n : int ; n := s->size() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 3 do ( (     dp[i+1][j+1] := -1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var val : int ; val := charVal(s, 0) ;
    OclFile["System.out"].println(countMinimalReplacements(s, 1, val, dp, n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    String[] strarr=new String[] {
      "FILIPINO","JAPANESE","KOREAN" };
      Scanner s=new Scanner(System.in);
      int t=s.nextInt();
      int indexWord=0 ;
      for(int i=0 ; i<t ; i++){
        String s1=s.next();
        if(s1.endsWith("po")){
          indexWord=0 ;
        }
        else if(s1.endsWith("mnida")){
          indexWord=2 ;
        }
        else {
          indexWord=1 ;
        }
        System.out.println(strarr[indexWord]);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var strarr : Sequence(String) ; strarr := Sequence{"FILIPINO","JAPANESE","KOREAN"} ;
     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var t : int ; t := s.getCurrent()->toInteger() ;
    var indexWord : int ; indexWord := 0 ;
        var i : int ; i := 0 ; while i < t do ( (     var s1 : String ; s1 := s.getCurrent() ;
     if (s1->hasSuffix("po")) then (     indexWord := 0 ) else     if (s1->hasSuffix("mnida")) then (     indexWord := 2 ) else (     indexWord := 1 ) ;  ;  
     OclFile["System.out"].println(strarr[indexWord+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int xorRange(int pre[],int l,int r){
    int cntOnes=pre[r];
    if(l-1>=0)cntOnes-=pre[l-1];
    if(cntOnes % 2==0)return 0 ;
    else return 1 ;
  }
  static void performQueries(int queries[][],int q,int a[],int n){
    int[] pre=new int[n];
    pre[0]=a[0];
    for(int i=1 ; i<n ; i++)pre[i]=pre[i-1]+a[i];
    for(int i=0 ; i<q ; i++)System.out.println(xorRange(pre,queries[i][0],queries[i][1]));
  }
  public static void main(String[] args){
    int a[]={
      1,0,1,1,0,1,1 };
      int n=a.length ;
      int queries[][]={
        {
          0,3 },{
            0,2 }
          };
          int q=queries.length ;
          performQueries(queries,q,a,n);
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation xorRange( pre : Sequence(int), l : int, r : int) : int
  pre: true
  post: true
  activity: (     var cntOnes : int ; cntOnes := pre[r+1] ;
     if (l - 1 >= 0) then     cntOnes := cntOnes-(pre[l - 1+1]) ; else skip ; 
     if (cntOnes mod 2 = 0) then     return 0 else     return 1 );
  static   operation performQueries( queries : Sequence(Sequence(int)), q : int, a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var pre : Sequence(int) ; pre := Integer.subrange(1,n)->collect(0) ;
     pre[0+1] := a[0+1] ; 
         var i : int ; i := 1 ; while i < n do (     pre[i+1] := pre[i - 1+1] + a[i+1] ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < q do (     OclFile["System.out"].println(xorRange(pre, queries[i+1][0+1], queries[i+1][1+1])) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,0,1,1,0,1,1} ;
     var n : int ; n := a->size() ;
    var queries : Sequence(Sequence(int)) ; queries := Sequence{Sequence{0,3},Sequence{0,2}} ;
    var q : int ; q := queries->size() ;
    execute performQueries(queries, q, a, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class ProblemC {
  public static void main(String[] args)throws Exception {
    try(Scanner sc=new Scanner(System.in)){
      int cases=sc.nextInt();
      for(int caseNum=1 ; caseNum<=cases ; caseNum++){
        solve(sc,caseNum);
      }
    }
  }
  static void solve(Scanner sc,int caseNum){
    int N=sc.nextInt();
    int K=sc.nextInt();
    double U=sc.nextDouble();
    double[] P=new double[N];
    for(int i=0 ; i<N ; i++){
      P[i]=sc.nextDouble();
    }
    Arrays.sort(P);
    double eps=1e-8 ;
    for(int i=0 ; i<N-1 ; i++){
      double add=P[i+1]-P[i];
      if(add*(i+1)>U+eps){
        for(int j=0 ; j<=i ; j++){
          P[j]+=U/(i+1);
        }
        U=0 ;
        break ;
      }
      else {
        for(int j=0 ; j<=i ; j++){
          P[j]+=add ;
        }
        U-=add*(i+1);
      }
    }
    if(U>0){
      for(int j=0 ; j<N ; j++){
        P[j]+=U/N ;
      }
    }
    double res=1 ;
    for(int j=0 ; j<N ; j++){
      res*=P[j];
    }
    System.out.printf("Case #%d: %.8f\n",caseNum,res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemC {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var cases : int ; cases := sc.getCurrent()->toInteger() ;
         var caseNum : int ; caseNum := 1 ; while caseNum <= cases do ( (     execute solve(sc, caseNum) )  ;     caseNum := caseNum + 1 ) ))  );
  static   operation solve( sc : OclFile, caseNum : int) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    var U : double ; U := sc.getCurrent()->toReal() ;
    var P : Sequence(double) ; P := Integer.subrange(1,N)->collect(0.0) ;
        var i : int ; i := 0 ; while i < N do ( (     P[i+1] := sc.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
    P := P->sort() ; 
    var eps : double ; eps := 1e-8 ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     var add : double ; add := P[i + 1+1] - P[i+1] ;
     if (add * (i + 1) > U + eps) then (         var j : int ; j := 0 ; while j <= i do ( (     P[j+1] := P[j+1]+(U / (i + 1)) )  ;     j := j + 1 ) ; 
     U := 0 ; 
     break ) else (         var j : int ; j := 0 ; while j <= i do ( (     P[j+1] := P[j+1]+(add) )  ;     j := j + 1 ) ; 
     U := U-(add * (i + 1)) ) )  ;     i := i + 1 ) ; 
    if (U > 0) then (         var j : int ; j := 0 ; while j < N do ( (     P[j+1] := P[j+1]+(U / N) )  ;     j := j + 1 ) ) else skip ; 
    var res : double ; res := 1 ;
        var j : int ; j := 0 ; while j < N do ( (     res := res*(P[j+1]) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].printf("Case #%d: %.8f\n", caseNum, res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round1c ;
import java.util.Arrays ;
public class ProbC extends Prob {
  void setup(){
    bin=true ;
    bout=true ;
    in="C-small-1-attempt0.in" ;
    out="cout.txt" ;
  }
  @ Override public void main(){
    setup();
    reDirect();
    int T=scanner.nextInt();
    for(int cas=1 ; cas<=T ; cas++){
      double ans=run();
      System.out.println(String.format("Case #%d: %f",cas,ans));
    }
  }
  double run(){
    int n=scanner.nextInt();
    int k=scanner.nextInt();
    double u=scanner.nextDouble();
    double[] p=new double[n];
    for(int i=0 ; i<n ; i++){
      p[i]=scanner.nextDouble();
    }
    Arrays.sort(p);
    double limit=-1 ;
    for(int i=0 ; i<n ; i++){
      if(i==n-1 ||(p[i+1]-p[i])*(i+1)>u){
        limit=u/(i+1)+p[i];
        break ;
      }
      else {
        u-=(p[i+1]-p[i])*(i+1);
      }
    }
    double poss=1 ;
    for(int i=0 ; i<n ; i++){
      if(p[i]<limit)poss*=limit ;
      else poss*=p[i];
    }
    return poss ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProbC extends Prob {
   operation setup() : void
  pre: true
  post: true
  activity: (     bin := true ; 
     bout := true ; 
     in := "C-small-1-attempt0.in" ; 
     out := "cout.txt" );
      operation main() : void
  pre: true
  post: true
  activity: (     execute setup() ; 
     execute reDirect() ; 
     var T : int ; T := scanner.nextInt() ;
         var cas : int ; cas := 1 ; while cas <= T do ( (     var ans : double ; ans := run() ;
     OclFile["System.out"].println(StringLib.format("Case #%d: %f",Sequence{cas,ans})) )  ;     cas := cas + 1 ) );
   operation run() : double
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.nextInt() ;
     var k : int ; k := scanner.nextInt() ;
    var u : double ; u := scanner.nextDouble() ;
    var p : Sequence(double) ; p := Integer.subrange(1,n)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := scanner.nextDouble() )  ;     i := i + 1 ) ; 
    p := p->sort() ; 
    var limit : double ; limit := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i = n - 1 or (p[i + 1+1] - p[i+1]) * (i + 1) > u) then (     limit := u / (i + 1) + p[i+1] ; 
     break ) else (     u := u-((p[i + 1+1] - p[i+1]) * (i + 1)) ) )  ;     i := i + 1 ) ; 
    var poss : double ; poss := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (p[i+1] < limit) then     poss := poss*(limit) ; else     poss := poss*(p[i+1]) ; )  ;     i := i + 1 ) ; 
    return poss 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package gcj2017.r1c ;
import java.io.*;
import java.util.Arrays ;
import java.util.Scanner ;
public class Training {
  static PrintWriter out ;
  public static void main(String[] args)throws IOException {
    String name="gcj2017/r1c/C-small-1" ;
    Scanner s=new Scanner(new File(name+".in"));
    int count=s.nextInt();
    out=new PrintWriter(new BufferedWriter(new FileWriter(name+".out")));
    for(int ii=1 ; ii<=count ; ii++){
      out.print("Case #"+ii+": ");
      int n=s.nextInt();
      int k=s.nextInt();
      double u=s.nextDouble();
      double[] p=new double[n];
      for(int i=0 ; i<n ; i++){
        p[i]=s.nextDouble();
      }
      double res=solve(n,k,u,p);
      out.print(String.format("%.8f",res));
      out.println();
    }
    out.close();
  }
  static double solve(int n,int k,double u,double[] p){
    Arrays.sort(p);
    while(u>0.000000001){
      double min=p[0];
      int ni=n ;
      double np=1 ;
      for(int i=1 ; i<n ; i++){
        if(p[i]==min){
          continue ;
        }
        np=p[i];
        ni=i ;
        break ;
      }
      if(ni*(np-min)<=u){
        for(int i=0 ; i<ni ; i++){
          p[i]=np ;
        }
        u-=ni*(np-min);
      }
      else {
        double d=u/ni ;
        for(int i=0 ; i<ni ; i++){
          p[i]+=d ;
        }
        u=0 ;
      }
    }
    double res=1 ;
    for(int i=0 ; i<n ; i++){
      res*=p[i];
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Training {
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var name : String ; name := "gcj2017/r1c/C-small-1" ;
     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile(name + ".in")) ;
    var count : int ; count := s.getCurrent()->toInteger() ;
    out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(name + ".out"))) ; 
        var ii : int ; ii := 1 ; while ii <= count do ( (     skip ; 
     var n : int ; n := s.getCurrent()->toInteger() ;
    var k : int ; k := s.getCurrent()->toInteger() ;
    var u : double ; u := s.getCurrent()->toReal() ;
    var p : Sequence(double) ; p := Integer.subrange(1,n)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := s.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
    var res : double ; res := solve(n, k, u, p) ;
    skip ; 
    skip ; 
 )  ;     ii := ii + 1 ) ; 
    skip ; 
 );
  static   operation solve( n : int, k : int, u : double, p : Sequence(double)) : double
  pre: true
  post: true
  activity: (     p := p->sort() ; 
     while (u > 0.000000001) do (     var min : double ; min := p[0+1] ;
     var ni : int ; ni := n ;
    var np : double ; np := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     if (p[i+1] = min) then (     continue ) else skip ; 
     np := p[i+1] ; 
     ni := i ; 
     break )  ;     i := i + 1 ) ; 
    if (ni * (np - min) <= u) then (         var i : int ; i := 0 ; while i < ni do ( (     p[i+1] := np )  ;     i := i + 1 ) ; 
     u := u-(ni * (np - min)) ) else (     var d : double ; d := u / ni ;
         var i : int ; i := 0 ; while i < ni do ( (     p[i+1] := p[i+1]+(d) )  ;     i := i + 1 ) ; 
     u := 0 ) ;  
 ) ; 
    var res : double ; res := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     res := res*(p[i+1]) )  ;     i := i + 1 ) ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    boolean first=true ;
    for(; sc.hasNext(); ){
      int n=sc.nextInt();
      if(n==0)break ;
      if(first)first=false ;
      else System.out.println();
      T[] ts=new T[n];
      for(int i=0 ; i<n ; i++){
        T t=new T();
        t.id=i ;
        t.name=sc.next();
        int win=sc.nextInt();
        int lose=sc.nextInt();
        int draw=sc.nextInt();
        t.point=win*3+draw*1 ;
        ts[i]=t ;
      }
      Arrays.sort(ts);
      for(T t : ts){
        System.out.println(t.name+","+t.point);
      }
    }
  }
  class T implements Comparable<T>{
    String name ;
    int id ;
    int point ;
    @ Override public int compareTo(T o){
      if(point!=o.point)return-(point-o.point);
      return(id-o.id);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var first : boolean ; first := true ;
       while sc.hasNext() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    if (first) then     first := false else     OclFile["System.out"].println() ; ;  
    var ts : Sequence(T) ; ts := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var t : T ; t := T.newT() ;
     t.id := i ; 
    t.name := sc.getCurrent() ; 
    var win : int ; win := sc.getCurrent()->toInteger() ;
    var lose : int ; lose := sc.getCurrent()->toInteger() ;
    var draw : int ; draw := sc.getCurrent()->toInteger() ;
    t.point := win * 3 + draw * 1 ; 
    ts[i+1] := t ; 
 )  ;     i := i + 1 ) ; 
    ts := ts->sort() ; 
    for (t : ts) do ( (     OclFile["System.out"].println(t.name + "," + t.point) )  ) ; 
 )  ) );
 class T implements Comparable<T> {
   attribute name : String;
   attribute id : int;
   attribute point : int;
      operation compareTo( o : T) : int
  pre: true
  post: true
  activity: (     if (point /= o.point) then     return -(point - o.point) else skip ; 
     return (id - o.id) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  static Scanner scanner=new Scanner();
  static long mod=1000000007 ;
  public static void main(String[] $){
    char[] s=scanner.next().toCharArray();
    char[] s2=Arrays.copyOf(s,s.length);
    long k=scanner.nextInt();
    long count=0 ;
    char first=s[0];
    boolean all=true ;
    for(int i=1 ; i<s.length ; i++){
      all &=first==s[i];
    }
    if(all){
      System.out.println(s.length*k/2);
    }
    else {
      int start=0 ;
      if(s[0]==s[s.length-1]){
        start++;
        while(s[start]==s[start-1]){
          start++;
        }
      }
      for(int i=0 ; i<s.length ; i++){
        if(s[(i+start)% s.length]==s[(i+start+1)% s.length]){
          s[(i+start+1)% s.length]='\0' ;
          count++;
        }
      }
      count*=k-1 ;
      for(int i=1 ; i<s.length ; i++){
        if(s2[i-1]==s2[i]){
          s2[i]='\0' ;
          count++;
        }
      }
      System.out.println(count);
    }
  }
  static class Scanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),1<<15);
    StringTokenizer tokenizer ;
    String next(){
      try {
        while(tokenizer==null || ! tokenizer.hasMoreTokens()){
          tokenizer=new StringTokenizer(reader.readLine());
        }
      }
      catch(IOException ignored){
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := (arguments ( ));
  static   attribute mod : long := 1000000007;
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := scanner.getCurrent()->characters() ;
     var s2 : Sequence(String) ; s2 := s.subrange(1,s->size()) ;
    var k : long ; k := scanner.getCurrent()->toInteger() ;
    var count : long ; count := 0 ;
    var first : String ; first := s[0+1] ;
    var all : boolean ; all := true ;
        var i : int ; i := 1 ; while i < s->size() do ( (     all := MathLib.bitwiseAnd(all, first = s[i+1]) )  ;     i := i + 1 ) ; 
    if (all) then (     OclFile["System.out"].println(s->size() * k / 2) ) else (     var start : int ; start := 0 ;
     if (s[0+1] = s[s->size() - 1+1]) then (     start := start + 1 ; 
     while (s[start+1] = s[start - 1+1]) do (     start := start + 1 ) ) else skip ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s[(i + start) mod s->size()+1] = s[(i + start + 1) mod s->size()+1]) then (     s[(i + start + 1) mod s->size()+1] := '\0' ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    count := count*(k - 1) ; 
        var i : int ; i := 1 ; while i < s->size() do ( (     if (s2[i - 1+1] = s2[i+1]) then (     s2[i+1] := '\0' ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;  
 );
  static class Scanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (1*(2->pow(15)))->oclAsType(long));
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (ignored : IOException) do skip
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(new File("output.txt"));
    int T=in.nextInt();
    for(int t=1 ; t<=T ; t++){
      int n=in.nextInt();
      int k=in.nextInt();
      double budget=in.nextDouble();
      double[] p=new double[n];
      for(int i=0 ; i<n ; i++){
        p[i]=in.nextDouble();
      }
      out.println("Case #"+t+": "+calc(p,budget));
    }
    out.close();
  }
  static double calc(double[] p,double budget){
    double ans=1.0 ;
    int n=p.length ;
    Arrays.sort(p);
    for(int i=0 ; i<n-1 ; i++){
      double d=p[i+1]-p[i];
      double need=d*(i+1);
      if(budget<need){
        double minP=p[i]+budget/(i+1);
        for(int j=0 ; j<=i ; j++){
          ans*=minP ;
        }
        for(int j=i+1 ; j<n ; j++){
          ans*=p[j];
        }
        return ans ;
      }
      budget-=need ;
    }
    double minP=p[n-1]+budget/n ;
    return Math.pow(minP,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("output.txt")) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= T do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var budget : double ; budget := in.getCurrent()->toReal() ;
    var p : Sequence(double) ; p := Integer.subrange(1,n)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := in.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation calc( p : Sequence(double), budget : double) : double
  pre: true
  post: true
  activity: (     var ans : double ; ans := 1.0 ;
     var n : int ; n := p->size() ;
    p := p->sort() ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var d : double ; d := p[i + 1+1] - p[i+1] ;
     var need : double ; need := d * (i + 1) ;
     if (budget < need) then (     var minP : double ; minP := p[i+1] + budget / (i + 1) ;
         var j : int ; j := 0 ; while j <= i do ( (     ans := ans*(minP) )  ;     j := j + 1 ) ; 
         var j : int ; j := i + 1 ; while j < n do ( (     ans := ans*(p[j+1]) )  ;     j := j + 1 ) ; 
     return ans ) else skip ; 
     budget := budget-(need) )  ;     i := i + 1 ) ; 
    var minP : double ; minP := p[n - 1+1] + budget / n ;
    return minP->pow(n) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new FileReader("C-small-1-attempt2.in"));
    BufferedWriter bw=new BufferedWriter(new FileWriter("solve.txt"));
    int T=Integer.parseInt(br.readLine().trim());
    StringTokenizer s ;
    for(int t=1 ; t<=T ; t++){
      s=new StringTokenizer(br.readLine().trim());
      int N=Integer.parseInt(s.nextToken());
      int K=Integer.parseInt(s.nextToken());
      double[] arr=new double[N];
      double U=Double.parseDouble(br.readLine().trim());
      s=new StringTokenizer(br.readLine().trim());
      for(int i=0 ; i<N ; i++){
        arr[i]=Double.parseDouble(s.nextToken());
      }
      Arrays.sort(arr);
      double pro=0 ;
      for(int i=0 ; i<N ; i++){
        if(i!=N-1){
          if(U>((i+1)*(arr[i+1]-arr[i]))){
            U-=((i+1)*(arr[i+1]-arr[i]));
          }
          else {
            pro=Math.pow((arr[i]+(U/(i+1))),i+1);
            for(int j=i+1 ; j<N ; j++){
              pro*=arr[j];
            }
            break ;
          }
        }
        else {
          pro=Math.pow((U/N)+arr[i],N);
        }
      }
      bw.write("Case #"+t+": ");
      bw.write(String.format("%.6f\n",pro));
    }
    br.close();
    bw.close();
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("C-small-1-attempt2.in"))) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("solve.txt"))) ;
    var T : int ; T := (br.readLine()->trim())->toInteger() ;
    var s : OclIterator ;
        var t : int ; t := 1 ; while t <= T do ( (     s := OclIterator.newOclIterator_String(br.readLine()->trim()) ; 
     var N : int ; N := (s.next())->toInteger() ;
    var K : int ; K := (s.next())->toInteger() ;
    var arr : Sequence(double) ; arr := Integer.subrange(1,N)->collect(0.0) ;
    var U : double ; U := (br.readLine()->trim())->toReal() ;
    s := OclIterator.newOclIterator_String(br.readLine()->trim()) ; 
        var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := (s.next())->toReal() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var pro : double ; pro := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (i /= N - 1) then (     if (U > ((i + 1) * (arr[i + 1+1] - arr[i+1]))) then (     U := U-(((i + 1) * (arr[i + 1+1] - arr[i+1]))) ) else (     pro := (arr[i+1] + (U / (i + 1)))->pow(i + 1) ; 
         var j : int ; j := i + 1 ; while j < N do ( (     pro := pro*(arr[j+1]) )  ;     j := j + 1 ) ; 
     break ) ) else (     pro := (U / N) + arr[i+1]->pow(N) ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printArray(int[] A,int n,int K){
    int minEle=Integer.MAX_VALUE,maxEle=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      minEle=Math.min(minEle,A[i]);
      maxEle=Math.max(maxEle,A[i]);
    }
    if(K!=0){
      if(K % 2==1){
        for(int i=0 ; i<n ; i++)A[i]=maxEle-A[i];
      }
      else {
        for(int i=0 ; i<n ; i++)A[i]=A[i]-minEle ;
      }
    }
    for(int i=0 ; i<n ; i++)System.out.print(A[i]+" ");
  }
  public static void main(String[] args){
    int[] arr={
      4,8,12,16 };
      int K=4 ;
      int N=arr.length ;
      printArray(arr,N,K);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printArray( A : Sequence(int), n : int, K : int) : void
  pre: true
  post: true
  activity: (     var minEle : int ; minEle := 2147483647 ;
    var maxEle : int ; maxEle := 2147483647 ;
         var i : int ; i := 0 ; while i < n do ( (     minEle := Set{minEle, A[i+1]}->min() ; 
     maxEle := Set{maxEle, A[i+1]}->max() )  ;     i := i + 1 ) ; 
     if (K /= 0) then (     if (K mod 2 = 1) then (         var i : int ; i := 0 ; while i < n do (     A[i+1] := maxEle - A[i+1] ;  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < n do (     A[i+1] := A[i+1] - minEle ;  ;     i := i + 1 ) ) ) else skip ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(A[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,8,12,16} ;
     var K : int ; K := 4 ;
     var N : int ; N := arr->size() ;
     execute printArray(arr, N, K) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      String str=in.next();
      int a=str.length();
      if(str.substring(str.length()-2,str.length()).equals("po")){
        System.out.println("FILIPINO");
      }
      else if(str.substring(a-4,a).equals("desu")|| str.substring(a-4,a).equals("masu")){
        System.out.println("JAPANESE");
      }
      else if(str.substring(a-5,a).equals("mnida")){
        System.out.println("KOREAN");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := in.getCurrent() ;
     var a : int ; a := str->size() ;
     if (str.subrange(str->size() - 2+1,str->size()) = "po") then (     OclFile["System.out"].println("FILIPINO") ) else     if (str.subrange((a)->char2byte() - 4+1,a) = "desu" or str.subrange((a)->char2byte() - 4+1,a) = "masu") then (     OclFile["System.out"].println("JAPANESE") ) else     if (str.subrange((a)->char2byte() - 5+1,a) = "mnida") then (     OclFile["System.out"].println("KOREAN") ) else skip ; ;  )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int max=1200 ;
    boolean[] p=new boolean[max];
    for(int i=2 ; i<max ; i++)p[i]=true ;
    for(int i=2 ; i<Math.sqrt(max); i++){
      if(! p[i*i])continue ;
      for(int j=i*i ; j<max ; j+=i)p[j]=false ;
    }
    int[][] dp=new int[max][15];
    dp[0][0]=1 ;
    for(int k=1 ; k<max ; k++){
      if(! p[k])continue ;
      for(int i=max-1 ; i>=0 ; i--){
        if(i-k<0)continue ;
        for(int j=14 ; j>=1 ; j--){
          dp[i][j]+=dp[i-k][j-1];
        }
      }
    }
    while(true){
      int n=sc.nextInt(),K=sc.nextInt();
      if(n==0 && K==0)break ;
      System.out.println(dp[n][K]);
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var max : int ; max := 1200 ;
    var p : Sequence(boolean) ; p := Integer.subrange(1,max)->collect(false) ;
        var i : int ; i := 2 ; while i < max do (     p[i+1] := true ;  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i < (max)->sqrt() do ( (     if (not(p[i * i+1])) then     continue else skip ; 
         var j : int ; j := i * i ; while j < max do (     p[j+1] := false ;  ;     j := j+(i) ) )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,max)->collect(Integer.subrange(1,15)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var k : int ; k := 1 ; while k < max do ( (     if (not(p[k+1])) then     continue else skip ; 
         var i : int ; i := max - 1 ; while i >= 0 do ( (     if (i - k < 0) then     continue else skip ; 
         var j : int ; j := 14 ; while j >= 1 do ( (     dp[i+1][j+1] := dp[i+1][j+1]+(dp[i - k+1][j - 1+1]) )  ;     j := j - 1 ) )  ;     i := i - 1 ) )  ;     k := k + 1 ) ; 
    while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
     if (n = 0 & K = 0) then     break else skip ; 
     OclFile["System.out"].println(dp[n+1][K+1]) ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int[] p=new int[1130];
  static int pnum ;
  static int[][][] dp ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    calcPrimes();
    int n=sc.nextInt();
    int k=sc.nextInt();
    while(n!=0){
      dp=new int[1121][15][188];
      for(int i=0 ; i<=n ; i++)for(int j=0 ; j<=k ; j++)for(int l=0 ; l<188 ; l++)dp[i][j][l]=-1 ;
      System.out.println(solve(n,k,0));
      n=sc.nextInt();
      k=sc.nextInt();
    }
  }
  public static int solve(int n,int k,int idx){
    if(n==0 && k==0){
      return 1 ;
    }
    else if(n==0 || k==0){
      return 0 ;
    }
    if(dp[n][k][idx]>=0){
      return dp[n][k][idx];
    }
    int res=0 ;
    for(int i=idx ; i<pnum ; i++){
      if(p[i]>n){
        break ;
      }
      else {
        res+=solve(n-p[i],k-1,i+1);
      }
    }
    return dp[n][k][idx]=res ;
  }
  public static void calcPrimes(){
    p[0]=2 ;
    pnum=1 ;
    for(int i=3 ; i<=1120 ; i+=2){
      boolean add=true ;
      for(int j=0 ; j<pnum ; j++){
        if(p[j]*p[j]>i){
          break ;
        }
        if(i % p[j]==0){
          add=false ;
          break ;
        }
      }
      if(add){
        p[pnum++]=i ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute p : Sequence(int) := Integer.subrange(1,1130)->collect(0);
  static   attribute pnum : int;
  static   attribute dp : Sequence(Sequence(Sequence(int)));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute calcPrimes() ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    while (n /= 0) do (     dp := Integer.subrange(1,1121)->collect(Integer.subrange(1,15)->collect(Integer.subrange(1,188)->collect(0))) ; 
         var i : int ; i := 0 ; while i <= n do (         var j : int ; j := 0 ; while j <= k do (         var l : int ; l := 0 ; while l < 188 do (     dp[i+1][j+1][l+1] := -1 ;  ;     l := l + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(n, k, 0)) ; 
    n := sc.getCurrent()->toInteger() ; 
    k := sc.getCurrent()->toInteger() ; 
 ) ; 
 );
  static   operation solve( n : int, k : int, idx : int) : int
  pre: true
  post: true
  activity: (     if (n = 0 & k = 0) then (     return 1 ) else     if (n = 0 or k = 0) then (     return 0 ) else skip ; ;  
     if (dp[n+1][k+1][idx+1] >= 0) then (     return dp[n+1][k+1][idx+1] ) else skip ; 
    var res : int ; res := 0 ;
        var i : int ; i := idx ; while i < pnum do ( (     if (p[i+1] > n) then (     break ) else (     res := res+(solve(n - p[i+1], k - 1, i + 1)) ) )  ;     i := i + 1 ) ; 
    return dp[n+1][k+1][idx+1] 
 );
  static   operation calcPrimes() : void
  pre: true
  post: true
  activity: (     p[0+1] := 2 ; 
     pnum := 1 ; 
         var i : int ; i := 3 ; while i <= 1120 do ( (     var add : boolean ; add := true ;
         var j : int ; j := 0 ; while j < pnum do ( (     if (p[j+1] * p[j+1] > i) then (     break ) else skip ; 
     if (i mod p[j+1] = 0) then (     add := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (add) then (      p[pnum+1] := i  ; pnum := pnum + 1 ) else skip )  ;     i := i+(2) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.geom.*;
import java.io.*;
public class Main {
  int[][] dp ;
  int MAX=1120 ;
  int K=14 ;
  boolean[] isprime ;
  private void doit(){
    Scanner sc=new Scanner(System.in);
    isprime=new boolean[MAX+1];
    eratos();
    dp=new int[K+1][MAX+1];
    dp();
    while(true){
      int n=sc.nextInt();
      int k=sc.nextInt();
      if((n | k)==0)break ;
      int ans=dp[k][n];
      System.out.println(ans);
    }
  }
  private void dp(){
    for(int i=1 ; i<=MAX ; i++){
      dp[1][i]=isprime[i] ? 1 : 0 ;
    }
    for(int i=MAX ; i>=2 ; i--){
      if(! isprime[i])continue ;
      for(int j=MAX ; j>=i ; j--){
        for(int k=K-1 ; k>=1 ; k--){
          if(k==1 && j==i)continue ;
          if(j+i>MAX)continue ;
          dp[k+1][j+i]+=dp[k][j];
        }
      }
    }
  }
  private void eratos(){
    Arrays.fill(isprime,true);
    isprime[0]=false ;
    isprime[1]=false ;
    for(int i=2 ; i*i<=MAX ; i++){
      if(isprime[i]){
        for(int j=i*2 ; j<=MAX ; j+=i){
          isprime[j]=false ;
        }
      }
    }
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute dp : Sequence(Sequence(int));
   attribute MAX : int := 1120;
   attribute K : int := 14;
   attribute isprime : Sequence(boolean);
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     isprime := Integer.subrange(1,MAX + 1)->collect(false) ; 
    execute eratos() ; 
    dp := Integer.subrange(1,K + 1)->collect(Integer.subrange(1,MAX + 1)->collect(0)) ; 
    execute dp() ; 
    while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,k)) = 0) then     break else skip ; 
    var ans : int ; ans := dp[k+1][n+1] ;
    OclFile["System.out"].println(ans) ; 
 ) ; 
 );
   operation dp() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= MAX do ( (     dp[1+1][i+1] := if isprime[i+1] then 1 else 0 endif )  ;     i := i + 1 ) ; 
         var i : int ; i := MAX ; while i >= 2 do ( (     if (not(isprime[i+1])) then     continue else skip ; 
         var j : int ; j := MAX ; while j >= i do ( (         var k : int ; k := K - 1 ; while k >= 1 do ( (     if (k = 1 & j = i) then     continue else skip ; 
     if (j + i > MAX) then     continue else skip ; 
     dp[k + 1+1][j + i+1] := dp[k + 1+1][j + i+1]+(dp[k+1][j+1]) )  ;     k := k - 1 ) )  ;     j := j - 1 ) )  ;     i := i - 1 ) );
   operation eratos() : void
  pre: true
  post: true
  activity: (     isprime := isprime->collect(true) ; 
     isprime[0+1] := false ; 
     isprime[1+1] := false ; 
         var i : int ; i := 2 ; while i * i <= MAX do ( (     if (isprime[i+1]) then (         var j : int ; j := i * 2 ; while j <= MAX do ( (     isprime[j+1] := false )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  int nn=1121 ;
  int kk=15 ;
  int dp[][]=new int[nn][kk];
  Main(){
    sc=new Scanner(System.in);
    dp[0][0]=1 ;
    boolean pp[]=new boolean[nn];
    Arrays.fill(pp,true);
    pp[0]=false ;
    pp[1]=false ;
    pp[2]=true ;
    for(int i=0 ; i<nn ; i++){
      if(pp[i]){
        for(int j=i<<1 ; j<nn ; j+=i){
          pp[j]=false ;
        }
      }
    }
    for(int k=0 ; k<nn ; k++){
      if(! pp[k]){
        continue ;
      }
      for(int i=nn-1 ; i>=k ; i--){
        for(int j=14 ; j>0 ; j--){
          dp[i][j]+=dp[i-k][j-1];
        }
      }
    }
  }
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      int k=sc.nextInt();
      if(n+k==0){
        break ;
      }
      System.out.println(dp[n][k]);
    }
  }
  public static void main(String args[]){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute nn : int := 1121;
   attribute kk : int := 15;
   attribute dp : int := Integer.subrange(1,nn)->collect(Integer.subrange(1,kk)->collect(0));
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     dp[0+1][0+1] := 1 ; 
    var pp : Sequence(boolean) ; pp := Integer.subrange(1,nn)->collect(false) ;
    pp := pp->collect(true) ; 
    pp[0+1] := false ; 
    pp[1+1] := false ; 
    pp[2+1] := true ; 
        var i : int ; i := 0 ; while i < nn do ( (     if (pp[i+1]) then (         var j : int ; j := (i*(2->pow(1)))->oclAsType(long) ; while j < nn do ( (     pp[j+1] := false )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < nn do ( (     if (not(pp[k+1])) then (     continue ) else skip ; 
         var i : int ; i := nn - 1 ; while i >= k do ( (         var j : int ; j := 14 ; while j > 0 do ( (     dp[i+1][j+1] := dp[i+1][j+1]+(dp[i - k+1][j - 1+1]) )  ;     j := j - 1 ) )  ;     i := i - 1 ) )  ;     k := k + 1 ) ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     if (n + k = 0) then (     break ) else skip ; 
     OclFile["System.out"].println(dp[n+1][k+1]) )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=64 ;
  static int maxOR(int L,int R){
    if(L==R){
      return L ;
    }
    int ans=0 ;
    for(int i=MAX-1 ; i>=0 ; i--){
      int p,lbit,rbit ;
      p=1<<i ;
      lbit=(L>>i)& 1 ;
      rbit=(R>>i)& 1 ;
      if((rbit==1)&&(lbit==0)){
        ans+=(p<<1)-1 ;
        break ;
      }
      if(rbit==1){
        ans+=p ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int L=4,R=5 ;
    System.out.println(maxOR(L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 64;
  static   operation maxOR( L : int, R : int) : int
  pre: true
  post: true
  activity: (     if (L = R) then (     return L ) else skip ; 
     var ans : int ; ans := 0 ;
         var i : int ; i := MAX - 1 ; while i >= 0 do ( (     var p : int ;
    var lbit : int ;
    var rbit : int ;
     p := (1*(2->pow(i)))->oclAsType(long) ; 
    lbit := ((L/(2->pow(i)))->oclAsType(long)) & 1 ; 
    rbit := ((R/(2->pow(i)))->oclAsType(long)) & 1 ; 
    if ((rbit = 1) & (lbit = 0)) then (     ans := ans+(((p*(2->pow(1)))->oclAsType(long)) - 1) ; 
     break ) else skip ; 
    if (rbit = 1) then (     ans := ans+(p) ) else skip ; 
 )  ;     i := i - 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 4 ;
    var R : int ; R := 5 ;
     OclFile["System.out"].println(maxOR(L, R)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main p=new Main();
  }
  public Main(){
    Scanner sc=new Scanner(System.in);
    alphav=new boolean[11];
    while(true){
      String s=sc.next();
      if(s.equals("#"))break ;
      solve(s);
    }
  }
  public void solve(String s){
    String[] fs=s.split("=");
    boolean res=true ;
    for(int i=0 ; i<(1<<11); i++){
      for(int j=0 ; j<alphav.length ; j++)alphav[j]=(i &(1<<j))>0 ;
      cur=0 ;
      f=fs[0];
      boolean r0=fomula();
      cur=0 ;
      f=fs[1];
      boolean r1=fomula();
      if(r0!=r1){
        res=false ;
        break ;
      }
    }
    System.out.println(res ? "YES" : "NO");
  }
  boolean[] alphav ;
  String f ;
  int cur=0 ;
  private boolean fomula(){
    boolean ret=false ;
    char nc=nextc();
    if('a'<=nc && nc<='k')return alphav[nc-'a'];
    switch(nc){
      case 'T' : ret=true ;
      break ;
      case 'F' : ret=false ;
      break ;
      case '-' : ret=! fomula();
      break ;
      case '(' : ret=fomula();
      nc=nextc();
      switch(nc){
        case '*' : ret &=fomula();
        break ;
        case '+' : ret |=fomula();
        break ;
        case '-' : nextc();
        ret=!(! fomula()&& ret);
        break ;
      }
      nextc();
      break ;
    }
    return ret ;
  }
  private char nextc(){
    char c=f.charAt(cur);
    cur++;
    return c ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : Main ; p := Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     alphav := Integer.subrange(1,11)->collect(false) ; 
     while (true) do (     var s : String ; s := sc.getCurrent() ;
     if (s = "#") then     break else skip ; 
     execute solve(s) ) );
   operation solve( s : String) : void
  pre: true
  post: true
  activity: (     var fs : Sequence(String) ; fs := s->split("=") ;
     var res : boolean ; res := true ;
         var i : int ; i := 0 ; while i < ((1*(2->pow(11)))->oclAsType(long)) do ( (         var j : int ; j := 0 ; while j < alphav->size() do (     alphav[j+1] := (MathLib.bitwiseAnd(i,((1*(2->pow(j)))->oclAsType(long)))) > 0 ;  ;     j := j + 1 ) ; 
     cur := 0 ; 
    f := fs[0+1] ; 
    var r0 : boolean ; r0 := fomula() ;
    cur := 0 ; 
    f := fs[1+1] ; 
    var r1 : boolean ; r1 := fomula() ;
    if (r0 /= r1) then (     res := false ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if res then "YES" else "NO" endif) );
   attribute alphav : Sequence(boolean);
   attribute f : String;
   attribute cur : int := 0;
   operation fomula() : boolean
  pre: true
  post: true
  activity: (     var ret : boolean ; ret := false ;
     var nc : String ; nc := nextc() ;
    if ('a' <= nc & nc <= 'k') then     return alphav[(nc)->char2byte() - ('a')->char2byte()+1] else skip ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (nc) ; 
       if _switchval = 'T' then
     ret := true ; 
    break 
   else skip ;
       if _switchval = 'F' then
     ret := false ; 
    break 
   else skip ;
       if _switchval = '-' then
     ret := not(fomula()) ; 
    break 
   else skip ;
       if _switchval = '(' then
     ret := fomula() ; 
    nc := nextc() ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (nc) ; 
       if _switchval = '*' then
     ret := MathLib.bitwiseAnd(ret, fomula()) ; 
    break 
   else skip ;
       if _switchval = '+' then
     ret := MathLib.bitwiseOr(ret, fomula()) ; 
    break 
   else skip ;
       if _switchval = '-' then
     execute nextc() ; 
    ret := not((not(fomula()) & ret)) ; 
    break 
   else skip ;
 )
    execute nextc() ; 
    break 
   else skip ;
 )
    return ret 
 );
   operation nextc() : String
  pre: true
  post: true
  activity: (     var c : String ; c := f->at(cur+1) ;
     cur := cur + 1 ; 
     return c );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    solve(System.in,System.out);
  }
  static void solve(InputStream is,PrintStream os){
    Scanner scan=new Scanner(is);
    String S=scan.next();
    long K=scan.nextLong();
    char sChar[]=S.toCharArray();
    char prevChar=sChar[0];
    long count=0 ;
    long tempCount=1 ;
    long tempFirstGpCount=0 ;
    boolean lastChanged=false ;
    boolean isAllSame=true ;
    for(int i=1 ; i<sChar.length ; i++){
      if(prevChar==sChar[i]){
        tempCount++;
        if(i==sChar.length-1){
          if((tempCount)% 2==0)lastChanged=true ;
          count+=Math.floor((tempCount)/2.0);
        }
      }
      else {
        if(isAllSame){
          tempFirstGpCount=tempCount ;
        }
        isAllSame=false ;
        prevChar=sChar[i];
        count+=Math.floor((tempCount)/2.0);
        tempCount=1 ;
      }
    }
    if(sChar.length!=1){
      if(! lastChanged && sChar[0]==sChar[sChar.length-1]){
        if(isAllSame){
          if(K % 2==0){
            count=(count+1)*2-1 ;
            os.println(count*(K/2));
          }
          else {
            long originCount=count ;
            count=(count+1)*2-1 ;
            os.println(count*Double.valueOf(Math.floor(K/2.0)).intValue()+originCount);
          }
        }
        else {
          if(tempFirstGpCount % 2==1){
            count++;
            os.println(count*K-1);
          }
          else {
            os.println(count*K);
          }
        }
      }
      else os.println(count*K);
    }
    else os.println(Double.valueOf(Math.floor(K/2.0)).intValue());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation solve( is : OclFile, os : OclFile) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(is) ;
     var S : String ; S := scan.getCurrent() ;
    var K : long ; K := scan.getCurrent()->toLong() ;
    var sChar : Sequence(String) ; sChar := S->characters() ;
    var prevChar : String ; prevChar := sChar[0+1] ;
    var count : long ; count := 0 ;
    var tempCount : long ; tempCount := 1 ;
    var tempFirstGpCount : long ; tempFirstGpCount := 0 ;
    var lastChanged : boolean ; lastChanged := false ;
    var isAllSame : boolean ; isAllSame := true ;
        var i : int ; i := 1 ; while i < sChar->size() do ( (     if (prevChar = sChar[i+1]) then (     tempCount := tempCount + 1 ; 
     if (i = sChar->size() - 1) then (     if ((tempCount) mod 2 = 0) then     lastChanged := true ; else skip ; 
     count := count+(((tempCount) / 2.0)->floor()) ) else skip ) else (     if (isAllSame) then (     tempFirstGpCount := tempCount ) else skip ; 
     isAllSame := false ; 
    prevChar := sChar[i+1] ; 
    count := count+(((tempCount) / 2.0)->floor()) ; 
    tempCount := 1 ; 
 ) )  ;     i := i + 1 ) ; 
    if (sChar->size() /= 1) then (     if (not(lastChanged) & sChar[0+1] = sChar[sChar->size() - 1+1]) then (     if (isAllSame) then (     if (K mod 2 = 0) then (     count := (count + 1) * 2 - 1 ; 
     os.println(count * (K / 2)) ) else (     var originCount : long ; originCount := count ;
     count := (count + 1) * 2 - 1 ; 
     os.println(count * ((K / 2.0)->floor())->toReal()->oclAsType(int) + originCount) ) ) else (     if (tempFirstGpCount mod 2 = 1) then (     count := count + 1 ; 
     os.println(count * K - 1) ) else (     os.println(count * K) ) ) ) else     os.println(count * K) ; ) else     os.println(((K / 2.0)->floor())->toReal()->oclAsType(int)) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
import java.awt.geom.*;
import java.io.*;
public class Main {
  static int id ;
  static String S ;
  static int V ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      S=sc.next();
      if(S.equals("#"))break ;
      boolean ans=true ;
      for(V=0 ; V<(1<<12); V++){
        id=0 ;
        ans &=equation();
        if(! ans)break ;
      }
      System.out.println(ans ? "YES" : "NO");
    }
  }
  static boolean equation(){
    boolean a=formula();
    id++;
    boolean b=formula();
    return a==b ;
  }
  static boolean formula(){
    if(S.charAt(id)=='T'){
      id++;
      return true ;
    }
    if(S.charAt(id)=='F'){
      id++;
      return false ;
    }
    for(int i=0 ; i<12 ; i++){
      if(S.charAt(id)==(char)('a'+i)){
        id++;
        return(V &(1<<i))!=0 ;
      }
    }
    if(S.charAt(id)=='-'){
      id++;
      return ! formula();
    }
    if(S.charAt(id)=='('){
      id++;
      boolean A=formula();
      char B=S.charAt(id);
      if(B=='-'){
        id++;
      }
      id++;
      boolean C=formula();
      id++;
      if(B=='-'){
        if(A && ! C)return false ;
        return true ;
      }
      if(B=='+'){
        return A | C ;
      }
      if(B=='*'){
        return A & C ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute id : int;
  static   attribute S : String;
  static   attribute V : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     S := sc.getCurrent() ; 
     if (S = "#") then     break else skip ; 
    var ans : boolean ; ans := true ;
        V := 0 ; while V < ((1*(2->pow(12)))->oclAsType(long)) do ( (     id := 0 ; 
     ans := MathLib.bitwiseAnd(ans, equation()) ; 
     if (not(ans)) then     break else skip )  ;     V := V + 1 ) ; 
    OclFile["System.out"].println(if ans then "YES" else "NO" endif) ; 
 ) );
  static   operation equation() : boolean
  pre: true
  post: true
  activity: (     var a : boolean ; a := formula() ;
     id := id + 1 ; 
     var b : boolean ; b := formula() ;
     return a = b );
  static   operation formula() : boolean
  pre: true
  post: true
  activity: (     if (S->at(id+1) = 'T') then (     id := id + 1 ; 
     return true ) else skip ; 
     if (S->at(id+1) = 'F') then (     id := id + 1 ; 
     return false ) else skip ; 
        var i : int ; i := 0 ; while i < 12 do ( (     if (S->at(id+1) = ('a' + i)->oclAsType(String)) then (     id := id + 1 ; 
     return (MathLib.bitwiseAnd(V,((1*(2->pow(i)))->oclAsType(long)))) /= 0 ) else skip )  ;     i := i + 1 ) ; 
    if (S->at(id+1) = '-') then (     id := id + 1 ; 
     return not(formula()) ) else skip ; 
    if (S->at(id+1) = '(') then (     id := id + 1 ; 
     var A : boolean ; A := formula() ;
    var B : String ; B := S->at(id+1) ;
    if (B = '-') then (     id := id + 1 ) else skip ; 
    id := id + 1 ; 
    var C : boolean ; C := formula() ;
    id := id + 1 ; 
    if (B = '-') then (     if (A & not(C)) then     return false else skip ; 
     return true ) else skip ; 
    if (B = '+') then (     return MathLib.bitwiseOr(A,C) ) else skip ; 
    if (B = '*') then (     return MathLib.bitwiseAnd(A,C) ) else skip ; 
 ) else skip ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  boolean[] assign ;
  char[] s ;
  int idx ;
  char get(){
    return s[idx++];
  }
  String s1,s2 ;
  boolean f(int k){
    if(k==11){
      s=s1.toCharArray();
      idx=0 ;
      boolean f1=formula();
      s=s2.toCharArray();
      idx=0 ;
      return f1==formula();
    }
    assign[k]=false ;
    if(! f(k+1))return false ;
    assign[k]=true ;
    return f(k+1);
  }
  boolean formula(){
    char ch=get();
    if(ch=='('){
      boolean f1=formula();
      ch=get();
      if(ch=='*'){
        boolean f2=formula();
        get();
        return f1 && f2 ;
      }
      else if(ch=='+'){
        boolean f2=formula();
        get();
        return f1 || f2 ;
      }
      else {
        get();
        boolean f2=formula();
        get();
        return ! f1 || f2 ;
      }
    }
    else if(ch=='-'){
      return ! formula();
    }
    else if(ch=='T'){
      return true ;
    }
    else if(ch=='F'){
      return false ;
    }
    else return assign[ch-'a'];
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    assign=new boolean[11];
    for(; ; ){
      String t=sc.next();
      if("#".equals(t))break ;
      String[] tt=t.split("=");
      s1=tt[0]+"$" ;
      s2=tt[1]+"$" ;
      System.out.println(f(0)? "YES" : "NO");
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute assign : Sequence(boolean);
   attribute s : Sequence(String);
   attribute idx : int;
   operation get() : String
  pre: true
  post: true
  activity: (     return s[idx+1] );
   attribute s1 : String;
   operation f( k : int) : boolean
  pre: true
  post: true
  activity: (     if (k = 11) then (     s := s1->characters() ; 
     idx := 0 ; 
    var f1 : boolean ; f1 := formula() ;
    s := s2->characters() ; 
    idx := 0 ; 
    return f1 = formula() 
 ) else skip ; 
     assign[k+1] := false ; 
    if (not(f(k + 1))) then     return false else skip ; 
    assign[k+1] := true ; 
    return f(k + 1) 
 );
   operation formula() : boolean
  pre: true
  post: true
  activity: (     var ch : String ; ch := get() ;
     if (ch = '(') then (     var f1 : boolean ; f1 := formula() ;
     ch := get() ; 
     if (ch = '*') then (     var f2 : boolean ; f2 := formula() ;
     execute get() ; 
     return f1 & f2 ) else     if (ch = '+') then (     var f2 : boolean ; f2 := formula() ;
     execute get() ; 
     return f1 or f2 ) else (     execute get() ; 
     var f2 : boolean ; f2 := formula() ;
     execute get() ; 
     return not(f1) or f2 ) ;  ) else     if (ch = '-') then (     return not(formula()) ) else     if (ch = 'T') then (     return true ) else     if (ch = 'F') then (     return false ) else     return assign[(ch)->char2byte() - ('a')->char2byte()+1] ;  ;  ;  );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     assign := Integer.subrange(1,11)->collect(false) ; 
       while true do ( (     var t : String ; t := sc.getCurrent() ;
     if ("#" = t) then     break else skip ; 
    var tt : Sequence(String) ; tt := t->split("=") ;
    s1 := tt[0+1] + "$" ; 
    s2 := tt[1+1] + "$" ; 
    OclFile["System.out"].println(if f(0) then "YES" else "NO" endif) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; tc++){
      String s=sc.next();
      System.out.println(solve(s));
    }
    sc.close();
  }
  static String solve(String s){
    if(s.endsWith("po")){
      return "FILIPINO" ;
    }
    else if(s.endsWith("mnida")){
      return "KOREAN" ;
    }
    else {
      return "JAPANESE" ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var s : String ; s := sc.getCurrent() ;
     OclFile["System.out"].println(solve(s)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( s : String) : String
  pre: true
  post: true
  activity: (     if (s->hasSuffix("po")) then (     return "FILIPINO" ) else     if (s->hasSuffix("mnida")) then (     return "KOREAN" ) else (     return "JAPANESE" ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  static int findSplit(int[] arr,int n){
    int i ;
    int preSum=0 ;
    int ind1=-1,ind2=-1 ;
    int S ;
    S=arr[0];
    for(i=1 ; i<n ; i++)S+=arr[i];
    if(S % 3!=0)return 0 ;
    int S1=S/3 ;
    int S2=2*S1 ;
    for(i=0 ; i<n ; i++){
      preSum+=arr[i];
      if(preSum % S1==0 && ind1==-1)ind1=i ;
      else if(preSum % S2==0){
        ind2=i ;
        break ;
      }
    }
    if(ind1!=-1 && ind2!=-1){
      System.out.print("("+ind1+","+ind2+")");
      return 1 ;
    }
    return 0 ;
  }
  public static void main(String args[]){
    int[] arr={
      1,3,4,0,4 };
      int n=arr.length ;
      if(findSplit(arr,n)==0)System.out.print("-1");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSplit( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
     var preSum : int ; preSum := 0 ;
    var ind1 : int ; ind1 := -1 ;
    var ind2 : int ; ind2 := -1 ;
    var S : int ;
    S := arr[0+1] ; 
        i := 1 ; while i < n do (     S := S+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    if (S mod 3 /= 0) then     return 0 else skip ; 
    var S1 : int ; S1 := S / 3 ;
    var S2 : int ; S2 := 2 * S1 ;
        i := 0 ; while i < n do ( (     preSum := preSum+(arr[i+1]) ; 
     if (preSum mod S1 = 0 & ind1 = -1) then     ind1 := i ; else     if (preSum mod S2 = 0) then (     ind2 := i ; 
     break ) else skip ; )  ;     i := i + 1 ) ; 
    if (ind1 /= -1 & ind2 /= -1) then (     OclFile["System.out"].print("(" + ind1 + "," + ind2 + ")") ; 
     return 1 ) else skip ; 
    return 0 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,4,0,4} ;
     var n : int ; n := arr->size() ;
     if (findSplit(arr, n) = 0) then     OclFile["System.out"].print("-1") ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int NoofTriplets(int N,int K){
    int[] cnt=new int[K];
    Arrays.fill(cnt,0,cnt.length,0);
    for(int i=1 ; i<=N ; i+=1){
      cnt[i % K]+=1 ;
    }
    if((K & 1)!=0){
      return cnt[0]*cnt[0]*cnt[0];
    }
    else {
      return(cnt[0]*cnt[0]*cnt[0]+cnt[K/2]*cnt[K/2]*cnt[K/2]);
    }
  }
  public static void main(String[] args){
    int N=3,K=2 ;
    System.out.println(NoofTriplets(N,K));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation NoofTriplets( N : int, K : int) : int
  pre: true
  post: true
  activity: (     var cnt : Sequence(int) ; cnt := Integer.subrange(1,K)->collect(0) ;
     cnt := cnt->collect(0) ; 
         var i : int ; i := 1 ; while i <= N do ( (     cnt[i mod K+1] := cnt[i mod K+1]+(1) )  ;     i := i+(1) ) ; 
     if ((K & 1) /= 0) then (     return cnt[0+1] * cnt[0+1] * cnt[0+1] ) else (     return (cnt[0+1] * cnt[0+1] * cnt[0+1] + cnt[K / 2+1] * cnt[K / 2+1] * cnt[K / 2+1]) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
    var K : int ; K := 2 ;
     OclFile["System.out"].println(NoofTriplets(N, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printTwoSetBitNums(int n){
    int x=1 ;
    while(n>0){
      int y=0 ;
      while(y<x){
        System.out.print(((1<<x)+(1<<y))+" ");
        n--;
        if(n==0)return ;
        y++;
      }
      x++;
    }
  }
  public static void main(String[] args){
    int n=4 ;
    printTwoSetBitNums(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printTwoSetBitNums( n : int) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 1 ;
     while (n > 0) do (     var y : int ; y := 0 ;
     while (y < x) do (     OclFile["System.out"].print((((1*(2->pow(x)))->oclAsType(long)) + ((1*(2->pow(y)))->oclAsType(long))) + " ") ; 
     n := n - 1 ; 
     if (n = 0) then     return else skip ; 
     y := y + 1 ) ; 
     x := x + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     execute printTwoSetBitNums(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int KnapSack(int val[],int wt[],int n,int W){
    int[] dp=new int[W+1];
    Arrays.fill(dp,0);
    for(int i=0 ; i<n ; i++)for(int j=W ; j>=wt[i]; j--)dp[j]=Math.max(dp[j],val[i]+dp[j-wt[i] ]);
    return dp[W];
  }
  public static void main(String[] args){
    int val[]={
      7,8,4 },wt[]={
        3,8,6 },W=10,n=3 ;
        System.out.println(KnapSack(val,wt,n,W));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation KnapSack( val : Sequence(int), wt : Sequence(int), n : int, W : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,W + 1)->collect(0) ;
     dp := dp->collect(0) ; 
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := W ; while j >= wt[i+1] do (     dp[j+1] := Set{dp[j+1], val[i+1] + dp[j - wt[i+1]+1]}->max() ;  ;     j := j - 1 ) ;  ;     i := i + 1 ) ; 
     return dp[W+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var val : Sequence(void) ; val := Sequence{7,8,4} ;
    var wt : Sequence(void) ; wt := Sequence{3,8,6} ;
    var W : int ; W := 10 ;
    var n : int ; n := 3 ;
     OclFile["System.out"].println(KnapSack(val, wt, n, W)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int twoEggDrop(int k){
    return(int)Math.ceil((-1.0+Math.sqrt(1+8*k))/2.0);
  }
  public static void main(String[] args){
    int k=100 ;
    System.out.println(twoEggDrop(k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation twoEggDrop( k : int) : int
  pre: true
  post: true
  activity: (     return ((-1.0 + (1 + 8 * k)->sqrt()) / 2.0)->ceil()->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 100 ;
     OclFile["System.out"].println(twoEggDrop(k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int nextPerfectSquare(int N){
    int nextN=(int)Math.floor(Math.sqrt(N))+1 ;
    return nextN*nextN ;
  }
  public static void main(String args[]){
    int n=35 ;
    System.out.println(nextPerfectSquare(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nextPerfectSquare( N : int) : int
  pre: true
  post: true
  activity: (     var nextN : int ; nextN := ((N)->sqrt())->floor()->oclAsType(int) + 1 ;
     return nextN * nextN );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 35 ;
     OclFile["System.out"].println(nextPerfectSquare(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.math.BigDecimal ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int x=in.nextInt();
    int y=in.nextInt();
    System.out.print(x/y+" "+x % y);
    System.out.printf(" %5.8f\n",(double)x/y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := in.getCurrent()->toInteger() ;
    var y : int ; y := in.getCurrent()->toInteger() ;
    OclFile["System.out"].print(x / y + " " + x mod y) ; 
    OclFile["System.out"].printf(" %5.8f\n", x->oclAsType(double) / y) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Random ;
import java.util.Scanner ;
public class Main {
  static long minChange(String S){
    long c=0 ;
    for(int i=S.length()-1 ; i>0 ; --i){
      if(S.charAt(i)==S.charAt(i-1)){
++c ;
--i ;
      }
    }
    return c ;
  }
  static long solve(String S,long T){
    long ret=0 ;
    if(S.charAt(S.length()-1)==S.charAt(0)){
      char c=S.charAt(0);
      boolean oneChar=true ;
      for(int i=1 ; i<S.length(); ++i){
        if(S.charAt(i)!=c){
          oneChar=false ;
        }
      }
      if(oneChar){
        T=T*S.length();
        ret=T/2 ;
      }
      else {
        String S_n='_'+S.substring(1);
        long l1=minChange(S)+minChange(S_n)*(T-1)+T-1 ;
        String S_n2=S.substring(0,S.length()-1)+'_' ;
        long l2=minChange(S)+minChange(S_n2)*(T-1)+T-1 ;
        ret=Math.min(l1,l2);
      }
    }
    else {
      ret=minChange(S)*T ;
    }
    return ret ;
  }
  static long solveSmall(String S,long T){
    String r="" ;
    for(int t=0 ; t<T ; ++t){
      r=r+S ;
    }
    return minChange(r);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    long T=sc.nextLong();
    long ret=solve(S,T);
    System.out.println(ret);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation minChange( S : String) : long
  pre: true
  post: true
  activity: (     var c : long ; c := 0 ;
         var i : int ; i := S->size() - 1 ; while i > 0 do ( (     if (S->at(i+1) = S->at(i - 1+1)) then (     c := c + 1 ; 
     i := i - 1 ) else skip )  ;     i := i - 1 ) ; 
     return c );
  static   operation solve( S : String, T : long) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := 0 ;
     if (S->at(S->size() - 1+1) = S->at(0+1)) then (     var c : String ; c := S->at(0+1) ;
     var oneChar : boolean ; oneChar := true ;
         var i : int ; i := 1 ; while i < S->size() do ( (     if (S->at(i+1) /= c) then (     oneChar := false ) else skip )  ;     i := i + 1 ) ; 
     if (oneChar) then (     T := T * S->size() ; 
     ret := T / 2 ) else (     var S_n : String ; S_n := '_' + S.subrange(1+1,1) ;
     var l1 : long ; l1 := minChange(S) + minChange(S_n) * (T - 1) + T - 1 ;
    var S_n2 : String ; S_n2 := S.subrange(0+1,S->size() - 1) + '_' ;
    var l2 : long ; l2 := minChange(S) + minChange(S_n2) * (T - 1) + T - 1 ;
    ret := Set{l1, l2}->min() ; 
 ) ) else (     ret := minChange(S) * T ) ;  
     return ret );
  static   operation solveSmall( S : String, T : long) : long
  pre: true
  post: true
  activity: (     var r : String ; r := "" ;
         var t : int ; t := 0 ; while t < T do ( (     r := r + S )  ;     t := t + 1 ) ; 
     return minChange(r) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    var T : long ; T := sc.getCurrent()->toLong() ;
    var ret : long ; ret := solve(S, T) ;
    OclFile["System.out"].println(ret) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    String num=br.readLine();
    String[] set=num.split(" ");
    int a=Integer.parseInt(set[0]);
    int b=Integer.parseInt(set[1]);
    int c=a/b ;
    int d=a % b ;
    String f=String.format("%.5f",((double)a/(double)b));
    System.out.println(sb.append(c).append(" ").append(d).append(" ").append(f));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var num : String ; num := br.readLine() ;
    var set : Sequence(String) ; set := num->split(" ") ;
    var a : int ; a := (set[0+1])->toInteger() ;
    var b : int ; b := (set[1+1])->toInteger() ;
    var c : int ; c := a / b ;
    var d : int ; d := a mod b ;
    var f : String ; f := StringLib.format("%.5f",Sequence{(a->oclAsType(double) / b->oclAsType(double))}) ;
    OclFile["System.out"].println(sb + StringLib.newString(c) + StringLib.newString(" ") + StringLib.newString(d) + StringLib.newString(" ") + StringLib.newString(f)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int a=scan.nextInt();
    int b=scan.nextInt();
    scan.close();
    int t1=a/b ;
    int t2=a % b ;
    double t3=(double)a/b ;
    if(b==1){
      System.out.println(t1+" "+t2+" "+t1);
    }
    else {
      System.out.println(t1+" "+t2+" "+BigDecimal.valueOf(t3).toPlainString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    skip ; 
    var t1 : int ; t1 := a / b ;
    var t2 : int ; t2 := a mod b ;
    var t3 : double ; t3 := a->oclAsType(double) / b ;
    if (b = 1) then (     OclFile["System.out"].println(t1 + " " + t2 + " " + t1) ) else (     OclFile["System.out"].println(t1 + " " + t2 + " " + (t3 + "")->toReal().toPlainString()) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findSum(int[] arr,int n,int left,int right){
    int k=right-left ;
    int d=arr[1]-arr[0];
    int ans=arr[left-1]*(k+1);
    ans=ans+(d*(k*(k+1)))/2 ;
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      2,4,6,8,10,12,14,16 };
      int queries=3 ;
      int q[][]={
        {
          2,4 },{
            2,6 },{
              5,6 }
            };
            int n=arr.length ;
            for(int i=0 ; i<queries ; i++)System.out.print(findSum(arr,n,q[i][0],q[i][1])+"\n");
          }
        }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findSum( arr : Sequence(int), n : int, left : int, right : int) : int
  pre: true
  post: true
  activity: (     var k : int ; k := right - left ;
     var d : int ; d := arr[1+1] - arr[0+1] ;
    var ans : int ; ans := arr[left - 1+1] * (k + 1) ;
    ans := ans + (d * (k * (k + 1))) / 2 ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,6,8,10,12,14,16} ;
     var queries : int ; queries := 3 ;
    var q : Sequence(Sequence(int)) ; q := Sequence{Sequence{2,4},Sequence{2,6},Sequence{5,6}} ;
    var n : int ; n := arr->size() ;
        var i : int ; i := 0 ; while i < queries do (     OclFile["System.out"].print(findSum(arr, n, q[i+1][0+1], q[i+1][1+1]) + "\n") ;  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.text.DecimalFormat ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long a=scanner.nextInt();
    long b=scanner.nextInt();
    scanner.close();
    DecimalFormat df=new DecimalFormat("0.00000");
    System.out.println((a/b)+" "+(a % b)+" "+df.format(((double)a/b)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := scanner.getCurrent()->toInteger() ;
    var b : long ; b := scanner.getCurrent()->toInteger() ;
    skip ; 
    var df : DecimalFormat ; df := DecimalFormat.newDecimalFormat("0.00000") ;
    OclFile["System.out"].println((a / b) + " " + (a mod b) + " " + df.format((a->oclAsType(double) / b))) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws Exception {
    String str[],ans ;
    int a,b ;
    int d,r ;
    String f ;
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    str=br.readLine().split(" ");
    a=Integer.parseInt(str[0]);
    b=Integer.parseInt(str[1]);
    d=a/b ;
    r=a % b ;
    f=String.format("%.5f",((double)a/(double)b));
    System.out.println(d+" "+r+" "+f);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ;
    var ans : String ;
     var a : int ;
    var b : int ;
    var d : int ;
    var r : int ;
    var f : String ;
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    str := br.readLine()->split(" ") ; 
    a := (str[0+1])->toInteger() ; 
    b := (str[1+1])->toInteger() ; 
    d := a / b ; 
    r := a mod b ; 
    f := StringLib.format("%.5f",Sequence{(a->oclAsType(double) / b->oclAsType(double))}) ; 
    OclFile["System.out"].println(d + " " + r + " " + f) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  final static double eps=(double)1e-6 ;
  static double getArea(double base,double hypotenuse){
    double height=Math.sqrt(hypotenuse*hypotenuse-base*base);
    return 0.5*base*height ;
  }
  static void printRightAngleTriangle(int hypotenuse,int area){
    int hsquare=hypotenuse*hypotenuse ;
    double sideForMaxArea=Math.sqrt(hsquare/2.0);
    double maxArea=getArea(sideForMaxArea,hypotenuse);
    if(area>maxArea){
      System.out.print("Not possible");
      return ;
    }
    double low=0.0 ;
    double high=sideForMaxArea ;
    double base=0 ;
    while(Math.abs(high-low)>eps){
      base=(low+high)/2.0 ;
      if(getArea(base,hypotenuse)>=area){
        high=base ;
      }
      else {
        low=base ;
      }
    }
    double height=Math.sqrt(hsquare-base*base);
    System.out.println(Math.round(base)+" "+Math.round(height));
  }
  static public void main(String[] args){
    int hypotenuse=5 ;
    int area=6 ;
    printRightAngleTriangle(hypotenuse,area);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute eps : double := 1e-6->oclAsType(double);
  static   operation getArea( base : double, hypotenuse : double) : double
  pre: true
  post: true
  activity: (     var height : double ; height := (hypotenuse * hypotenuse - base * base)->sqrt() ;
     return 0.5 * base * height );
  static   operation printRightAngleTriangle( hypotenuse : int, area : int) : void
  pre: true
  post: true
  activity: (     var hsquare : int ; hsquare := hypotenuse * hypotenuse ;
     var sideForMaxArea : double ; sideForMaxArea := (hsquare / 2.0)->sqrt() ;
    var maxArea : double ; maxArea := getArea(sideForMaxArea, hypotenuse) ;
    if (area > maxArea) then (     OclFile["System.out"].print("Not possible") ; 
     return ) else skip ; 
    var low : double ; low := 0.0 ;
    var high : double ; high := sideForMaxArea ;
    var base : double ; base := 0 ;
    while (if high - low < 0 then -(high - low) else high - low endif > eps) do (     base := (low + high) / 2.0 ; 
     if (getArea(base, hypotenuse) >= area) then (     high := base ) else (     low := base ) ) ; 
    var height : double ; height := (hsquare - base * base)->sqrt() ;
    OclFile["System.out"].println((base)->round() + " " + (height)->round()) ; 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var hypotenuse : int ; hypotenuse := 5 ;
     var area : int ; area := 6 ;
     execute printRightAngleTriangle(hypotenuse, area) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Ishu {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int i,no4=0,no7=0,max=0,min=0 ;
    String a,b ;
    a=scan.next();
    b=scan.next();
    for(i=0 ; i<a.length(); ++i){
      if(!(a.substring(i,i+1).equals(b.substring(i,i+1)))){
        if(a.substring(i,i+1).equals("4"))no4++;
        else no7++;
      }
    }
    max=no4>=no7 ? no4 : no7 ;
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ishu {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ;
    var no4 : int ; no4 := 0 ;
    var no7 : int ; no7 := 0 ;
    var max : int ; max := 0 ;
    var min : int ; min := 0 ;
    var a : String ;
    var b : String ;
    a := scan.getCurrent() ; 
    b := scan.getCurrent() ; 
        i := 0 ; while i < a->size() do ( (     if (not((a.subrange(i+1,i + 1) = b.subrange(i+1,i + 1)))) then (     if (a.subrange(i+1,i + 1) = "4") then     no4 := no4 + 1 ; else     no7 := no7 + 1 ; ) else skip )  ;     i := i + 1 ) ; 
    max := if no4 >= no7 then no4 else no7 endif ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF145A extends PrintWriter {
  CF145A(){
    super(System.out,true);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    CF145A o=new CF145A();
    o.main();
    o.flush();
  }
  void main(){
    byte[] aa=sc.next().getBytes();
    byte[] bb=sc.next().getBytes();
    int n=aa.length,n47=0,n74=0 ;
    for(int i=0 ; i<n ; i++){
      byte a=aa[i];
      byte b=bb[i];
      if(a=='4' && b=='7')n47++;
      else if(a=='7' && b=='4')n74++;
    }
    println(Math.max(n47,n74));
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF145A extends OclFile {
   static operation newCF145A() : CF145A
  pre: true
  post: true
  activity:
  ( var self : CF145A ;
    self := createCF145A();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"], true) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : CF145A ; o := CF145A.newCF145A() ;
     o.main() ; 
     o.flush() );
   operation main() : void
  pre: true
  post: true
  activity: (     var aa : Sequence(int) ; aa := sc.getCurrent()->characters()->collect( _c | _c->char2byte() ) ;
     var bb : Sequence(int) ; bb := sc.getCurrent()->characters()->collect( _c | _c->char2byte() ) ;
    var n : int ; n := aa->size() ;
    var n47 : int ; n47 := 0 ;
    var n74 : int ; n74 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := aa[i+1] ;
     var b : int ; b := bb[i+1] ;
     if (a = '4' & b = '7') then     n47 := n47 + 1 ; else     if (a = '7' & b = '4') then     n74 := n74 + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    execute println(Set{n47, n74}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CF_145A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String temp=in.nextLine();
    char[] a=temp.toCharArray();
    temp=in.nextLine();
    char[] b=temp.toCharArray();
    int aNum7s=0 ;
    int bNum7s=0 ;
    int numDiffs=0 ;
    for(int i=0 ; i<a.length ; i++){
      if(a[i]=='7'){
        aNum7s++;
      }
      if(b[i]=='7'){
        bNum7s++;
      }
      if(a[i]!=b[i]){
        numDiffs++;
      }
    }
    int numOps=(Math.abs(aNum7s-bNum7s)+numDiffs)/2 ;
    System.out.println(numOps);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF_145A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var temp : String ; temp := in.nextLine() ;
    var a : Sequence(String) ; a := temp->characters() ;
    temp := in.nextLine() ; 
    var b : Sequence(String) ; b := temp->characters() ;
    var aNum7s : int ; aNum7s := 0 ;
    var bNum7s : int ; bNum7s := 0 ;
    var numDiffs : int ; numDiffs := 0 ;
        var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] = '7') then (     aNum7s := aNum7s + 1 ) else skip ; 
     if (b[i+1] = '7') then (     bNum7s := bNum7s + 1 ) else skip ; 
     if (a[i+1] /= b[i+1]) then (     numDiffs := numDiffs + 1 ) else skip )  ;     i := i + 1 ) ; 
    var numOps : int ; numOps := (if aNum7s - bNum7s < 0 then -(aNum7s - bNum7s) else aNum7s - bNum7s endif + numDiffs) / 2 ;
    OclFile["System.out"].println(numOps) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    char[] list1=scanner.next().toCharArray();
    char[] list2=scanner.next().toCharArray();
    char[] temp1=list1.clone();
    char[] temp2=list2.clone();
    int numDif1=0 ;
    int numDif2=0 ;
    int count=0 ;
    Arrays.sort(list1);
    Arrays.sort(list2);
    for(int i=0 ; i<list1.length ; i++){
      if(list1[i]!=list2[i]){
        numDif1++;
      }
    }
    count=numDif1 ;
    int i=0 ;
    while(count>0){
      if(temp1[i]=='7' && temp2[i]=='4'){
        temp1[i]='4' ;
        count--;
      }
      else if(temp1[i]=='4' && temp2[i]=='7'){
        temp1[i]='7' ;
        count--;
      }
      i++;
    }
    for(int k=0 ; k<temp1.length ; k++){
      if(temp1[k]!=temp2[k]){
        numDif2++;
      }
    }
    System.out.println((int)(numDif1+Math.ceil(numDif2/2.0)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list1 : Sequence(String) ; list1 := scanner.getCurrent()->characters() ;
    var list2 : Sequence(String) ; list2 := scanner.getCurrent()->characters() ;
    var temp1 : Sequence(String) ; temp1 := list1->copy() ;
    var temp2 : Sequence(String) ; temp2 := list2->copy() ;
    var numDif1 : int ; numDif1 := 0 ;
    var numDif2 : int ; numDif2 := 0 ;
    var count : int ; count := 0 ;
    list1 := list1->sort() ; 
    list2 := list2->sort() ; 
        var i : int ; i := 0 ; while i < list1->size() do ( (     if (list1[i+1] /= list2[i+1]) then (     numDif1 := numDif1 + 1 ) else skip )  ;     i := i + 1 ) ; 
    count := numDif1 ; 
    var i : int ; i := 0 ;
    while (count > 0) do (     if (temp1[i+1] = '7' & temp2[i+1] = '4') then (     temp1[i+1] := '4' ; 
     count := count - 1 ) else     if (temp1[i+1] = '4' & temp2[i+1] = '7') then (     temp1[i+1] := '7' ; 
     count := count - 1 ) else skip ; ;  
     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < temp1->size() do ( (     if (temp1[k+1] /= temp2[k+1]) then (     numDif2 := numDif2 + 1 ) else skip )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println((numDif1 + (numDif2 / 2.0)->ceil())->oclAsType(int)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Contest666B {
  public static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int n=Integer.parseInt(br.readLine());
    long[] test=Arrays.stream(br.readLine().split(" ")).mapToLong(Long :: parseLong).toArray();
    Arrays.sort(test);
    long ans1=0,ans2=0,ans3=0 ;
    long c1=(long)Math.ceil(Math.pow((double)test[n-1],(double)1/(n-1)));
    long c2=(long)Math.floor(Math.pow((double)test[n-1],(double)1/(n-1)));
    for(int i=0 ; i<n ; i++){
      if(test[i]!=(long)Math.pow(c1,i)){
        ans1+=Math.abs(test[i]-(long)Math.pow(c1,i));
      }
      if(test[i]!=(long)Math.pow(c2,i)){
        ans2+=Math.abs(test[i]-(long)Math.pow(c2,i));
      }
    }
    if(ans1<0){
      pw.println(ans2);
    }
    else if(ans2<0){
      pw.println(ans1);
    }
    else {
      pw.println(Math.min(ans1,ans2));
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Contest666B {
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var test : Sequence(long) ; test := stream(br.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toLong())->apply(_x1) )->asSequence() ;
    test := test->sort() ; 
    var ans1 : long ; ans1 := 0 ;
    var ans2 : long ; ans2 := 0 ;
    var ans3 : long ; ans3 := 0 ;
    var c1 : long ; c1 := (test[n - 1+1]->oclAsType(double)->pow(1->oclAsType(double) / (n - 1)))->ceil()->oclAsType(long) ;
    var c2 : long ; c2 := (test[n - 1+1]->oclAsType(double)->pow(1->oclAsType(double) / (n - 1)))->floor()->oclAsType(long) ;
        var i : int ; i := 0 ; while i < n do ( (     if (test[i+1] /= c1->pow(i)->oclAsType(long)) then (     ans1 := ans1+(if test[i+1] - c1->pow(i)->oclAsType(long) < 0 then -(test[i+1] - c1->pow(i)->oclAsType(long)) else test[i+1] - c1->pow(i)->oclAsType(long) endif) ) else skip ; 
     if (test[i+1] /= c2->pow(i)->oclAsType(long)) then (     ans2 := ans2+(if test[i+1] - c2->pow(i)->oclAsType(long) < 0 then -(test[i+1] - c2->pow(i)->oclAsType(long)) else test[i+1] - c2->pow(i)->oclAsType(long) endif) ) else skip )  ;     i := i + 1 ) ; 
    if (ans1 < 0) then (     skip ) else     if (ans2 < 0) then (     skip ) else (     skip ) ;  ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().solver();
  }
  void solver(){
    Scanner sc=new Scanner(System.in);
    while(true){
      long a=sc.nextLong();
      long b=sc.nextLong();
      long p=sc.nextLong();
      if(a==0 && b==0 && p==0)break ;
      long[] dp=new long[111111];
      dp[0]=1 ;
      long ans=0 ;
      for(long i=a ; i<=b ; i++){
        if(i>a){
          dp[(int)(i-a)]+=dp[(int)(i-a-1)];
        }
        ans+=dp[(int)(i-a)];
        ans %=p ;
        for(long j=i ; j<=b ; j*=10){
          long t=1 ;
          while(t<=j)t*=10 ;
          long l=Math.max(i-a+1,j-a),r=Math.min(b-a+1,t-a);
          dp[(int)l]+=dp[(int)(i-a)];
          dp[(int)r]-=dp[(int)(i-a)];
          dp[(int)l] %=p ;
          dp[(int)r] %=p ;
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solver() );
   operation solver() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
    var p : long ; p := sc.getCurrent()->toLong() ;
    if (a = 0 & b = 0 & p = 0) then     break else skip ; 
    var dp : Sequence(long) ; dp := Integer.subrange(1,111111)->collect(0) ;
    dp[0+1] := 1 ; 
    var ans : long ; ans := 0 ;
        var i : long ; i := a ; while i <= b do ( (     if (i > a) then (     dp[(i - a)->oclAsType(int)+1] := dp[(i - a)->oclAsType(int)+1]+(dp[(i - a - 1)->oclAsType(int)+1]) ) else skip ; 
     ans := ans+(dp[(i - a)->oclAsType(int)+1]) ; 
     ans := ans mod p ; 
         var j : long ; j := i ; while j <= b do ( (     var t : long ; t := 1 ;
     while (t <= j) do     t := t*(10) ; ; 
    var l : long ; l := Set{i - a + 1, j - a}->max() ;
    var r : long ; r := Set{b - a + 1, t - a}->min() ;
    dp[l->oclAsType(int)+1] := dp[l->oclAsType(int)+1]+(dp[(i - a)->oclAsType(int)+1]) ; 
    dp[r->oclAsType(int)+1] := dp[r->oclAsType(int)+1]-(dp[(i - a)->oclAsType(int)+1]) ; 
    dp[l->oclAsType(int)+1] := dp[l->oclAsType(int)+1] mod p ; 
    dp[r->oclAsType(int)+1] := dp[r->oclAsType(int)+1] mod p ; 
 )  ;     j := j*(10) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Candies {
  public static void main(String...strings){
    try(Scanner sc=new Scanner(System.in)){
      int testCase=sc.nextInt();
      for(int i=0 ; i<testCase ; i++){
        int numbersCount=sc.nextInt();
        int[] array=new int[numbersCount];
        for(int m=0 ; m<numbersCount ; m++){
          array[m]=sc.nextInt();
        }
        int minNumber=array[0];
        int candiesToEat=0 ;
        for(int j=0 ; j<numbersCount ; j++){
          if(array[j]<minNumber){
            minNumber=array[j];
          }
        }
        for(int n : array){
          if(n>minNumber){
            candiesToEat+=(n-minNumber);
          }
        }
        System.out.println(candiesToEat);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Candies {
  static   operation main( strings : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var testCase : int ; testCase := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < testCase do ( (     var numbersCount : int ; numbersCount := sc.getCurrent()->toInteger() ;
     var array : Sequence(int) ; array := Integer.subrange(1,numbersCount)->collect(0) ;
        var m : int ; m := 0 ; while m < numbersCount do ( (     array[m+1] := sc.getCurrent()->toInteger() )  ;     m := m + 1 ) ; 
    var minNumber : int ; minNumber := array[0+1] ;
    var candiesToEat : int ; candiesToEat := 0 ;
        var j : int ; j := 0 ; while j < numbersCount do ( (     if (array[j+1] < minNumber) then (     minNumber := array[j+1] ) else skip )  ;     j := j + 1 ) ; 
    for (n : array) do ( (     if (n > minNumber) then (     candiesToEat := candiesToEat+((n - minNumber)) ) else skip )  ) ; 
    OclFile["System.out"].println(candiesToEat) ; 
 )  ;     i := i + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void findNormal(int A,int x,int y){
    int dif=A-x*2 ;
    if(y==(2*x-x*x)){
      if(dif<0)System.out.print((0-dif)+"y="+"x"+((0-x)+(y*dif)));
      else if(dif>0)System.out.print(dif+"y="+"-x+"+(x+dif*y));
      else System.out.print("x="+x);
    }
    else System.out.println("Not possible");
  }
  public static void main(String[] args){
    int A=2,x=2,y=0 ;
    findNormal(A,x,y);
    ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNormal( A : int, x : int, y : int) : void
  pre: true
  post: true
  activity: (     var dif : int ; dif := A - x * 2 ;
     if (y = (2 * x - x * x)) then (     if (dif < 0) then     OclFile["System.out"].print((0 - dif) + "y=" + "x" + ((0 - x) + (y * dif))) ; else     if (dif > 0) then     OclFile["System.out"].print(dif + "y=" + "-x+" + (x + dif * y)) else     OclFile["System.out"].print("x=" + x) ; ;  ) else     OclFile["System.out"].println("Not possible") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 2 ;
    var x : int ; x := 2 ;
    var y : int ; y := 0 ;
     execute findNormal(A, x, y) ; 
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void pattern(){
    int i,j,k=0,spaces=1,n=7 ;
    for(i=n ; i>=1 ; i--){
      for(j=1 ; j<=i ; j++){
        System.out.print(i);
      }
      if(i!=n){
        for(k=1 ; k<=spaces ; k++){
          System.out.print(" ");
        }
        spaces=spaces+2 ;
      }
      for(j=i ; j>=1 ; j--){
        if(j!=n)System.out.print(i);
      }
      System.out.println();
    }
    spaces=spaces-4 ;
    for(i=2 ; i<=n ; i++){
      for(j=1 ; j<=i ; j++){
        System.out.print(i);
      }
      if(i!=n){
        for(k=1 ; k<=spaces ; k++){
          System.out.printf(" ");
        }
        spaces=spaces-2 ;
      }
      for(j=i ; j>=1 ; j--){
        if(j!=n)System.out.print(i);
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    pattern();
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pattern() : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var k : int ; k := 0 ;
    var spaces : int ; spaces := 1 ;
    var n : int ; n := 7 ;
         i := n ; while i >= 1 do ( (         j := 1 ; while j <= i do ( (     OclFile["System.out"].print(i) )  ;     j := j + 1 ) ; 
     if (i /= n) then (         k := 1 ; while k <= spaces do ( (     OclFile["System.out"].print(" ") )  ;     k := k + 1 ) ; 
     spaces := spaces + 2 ) else skip ; 
         j := i ; while j >= 1 do ( (     if (j /= n) then     OclFile["System.out"].print(i) ; else skip )  ;     j := j - 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i - 1 ) ; 
     spaces := spaces - 4 ; 
         i := 2 ; while i <= n do ( (         j := 1 ; while j <= i do ( (     OclFile["System.out"].print(i) )  ;     j := j + 1 ) ; 
     if (i /= n) then (         k := 1 ; while k <= spaces do ( (     OclFile["System.out"].printf(" ") )  ;     k := k + 1 ) ; 
     spaces := spaces - 2 ) else skip ; 
         j := i ; while j >= 1 do ( (     if (j /= n) then     OclFile["System.out"].print(i) ; else skip )  ;     j := j - 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute pattern() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int x=Integer.parseInt(sc.next());
    int y=Integer.parseInt(sc.next());
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    int c=Integer.parseInt(sc.next());
    Integer[] p=new Integer[a];
    Integer[] q=new Integer[b];
    Integer[] r=new Integer[c];
    Arrays.setAll(p,i->Integer.parseInt(sc.next()));
    Arrays.setAll(q,i->Integer.parseInt(sc.next()));
    Arrays.setAll(r,i->Integer.parseInt(sc.next()));
    PriorityQueue<Integer>eat=new PriorityQueue<>();
    Arrays.sort(p,Collections.reverseOrder());
    for(int i=0 ; i<x ; i++){
      eat.add(p[i]);
    }
    Arrays.sort(q,Collections.reverseOrder());
    for(int i=0 ; i<y ; i++){
      eat.add(q[i]);
    }
    for(int num : r){
      eat.add(num);
      eat.poll();
    }
    long result=eat.stream().mapToLong(i->i).sum();
    System.out.println(result);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := (sc.getCurrent())->toInteger() ;
    var y : int ; y := (sc.getCurrent())->toInteger() ;
    var a : int ; a := (sc.getCurrent())->toInteger() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    var c : int ; c := (sc.getCurrent())->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,a)->collect(null) ;
    var q : Sequence(int) ; q := Integer.subrange(1,b)->collect(null) ;
    var r : Sequence(int) ; r := Integer.subrange(1,c)->collect(null) ;
setAll(p, lambda i : OclAny in (sc.getCurrent())->toInteger()) ; 
setAll(q, lambda i : OclAny in (sc.getCurrent())->toInteger()) ; 
setAll(r, lambda i : OclAny in (sc.getCurrent())->toInteger()) ; 
    var eat : Sequence(int) ; eat := Sequence{} ;
    p := OclComparator.sortWith(p, reverseOrder()) ; 
        var i : int ; i := 0 ; while i < x do ( (     eat := eat->including(p[i+1]) )  ;     i := i + 1 ) ; 
    q := OclComparator.sortWith(q, reverseOrder()) ; 
        var i : int ; i := 0 ; while i < y do ( (     eat := eat->including(q[i+1]) )  ;     i := i + 1 ) ; 
    for (num : r) do ( (     eat := eat->including(num) ; 
     eat := eat->sort()->tail() )  ) ; 
    var result : long ; result := eat->collect( _x1 | (lambda i : OclAny in i)->apply(_x1) )->sum() ;
    OclFile["System.out"].println(result) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javax.swing.plaf.basic.BasicInternalFrameTitlePane ;
import java.io.*;
import java.math.*;
import java.nio.Buffer ;
import java.sql.SQLSyntaxErrorException ;
import java.util.*;
import java.text.*;
import java.util.regex.Pattern ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int X=cin.nextInt();
    int Y=cin.nextInt();
    int A=cin.nextInt();
    int B=cin.nextInt();
    int C=cin.nextInt();
    Integer[] num=new Integer[A];
    Integer[] num1=new Integer[B];
    Integer[] num2=new Integer[C+X+Y];
    for(int i=0 ; i<A ; i++){
      num[i]=cin.nextInt();
    }
    Arrays.sort(num,0,A,Collections.reverseOrder());
    for(int i=0 ; i<B ; i++){
      num1[i]=cin.nextInt();
    }
    Arrays.sort(num1,0,B,Collections.reverseOrder());
    for(int i=0 ; i<C ; i++){
      num2[i]=cin.nextInt();
    }
    for(int i=C ; i<C+X ; i++){
      num2[i]=num[i-C];
    }
    for(int i=C+X ; i<C+X+Y ; i++){
      num2[i]=num1[i-C-X];
    }
    Arrays.sort(num2,0,C+X+Y,Collections.reverseOrder());
    long sum=0 ;
    for(int i=0 ; i<X+Y ; i++){
      sum+=num2[i];
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : int ; X := cin.getCurrent()->toInteger() ;
    var Y : int ; Y := cin.getCurrent()->toInteger() ;
    var A : int ; A := cin.getCurrent()->toInteger() ;
    var B : int ; B := cin.getCurrent()->toInteger() ;
    var C : int ; C := cin.getCurrent()->toInteger() ;
    var num : Sequence(int) ; num := Integer.subrange(1,A)->collect(null) ;
    var num1 : Sequence(int) ; num1 := Integer.subrange(1,B)->collect(null) ;
    var num2 : Sequence(int) ; num2 := Integer.subrange(1,C + X + Y)->collect(null) ;
        var i : int ; i := 0 ; while i < A do ( (     num[i+1] := cin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    num, 0, A, reverseOrder() := num, 0, A, reverseOrder()->sort() ; 
        var i : int ; i := 0 ; while i < B do ( (     num1[i+1] := cin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    num1, 0, B, reverseOrder() := num1, 0, B, reverseOrder()->sort() ; 
        var i : int ; i := 0 ; while i < C do ( (     num2[i+1] := cin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := C ; while i < C + X do ( (     num2[i+1] := num[i - C+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := C + X ; while i < C + X + Y do ( (     num2[i+1] := num1[i - C - X+1] )  ;     i := i + 1 ) ; 
    num2, 0, C + X + Y, reverseOrder() := num2, 0, C + X + Y, reverseOrder()->sort() ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < X + Y do ( (     sum := sum+(num2[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int x=cin.nextInt();
    int y=cin.nextInt();
    int A=cin.nextInt();
    int B=cin.nextInt();
    int C=cin.nextInt();
    Integer[] a=new Integer[A];
    Integer[] b=new Integer[B];
    Integer[] c=new Integer[C+x+y];
    for(int i=0 ; i<A ; i++){
      a[i]=cin.nextInt();
    }
    Arrays.sort(a,0,A,Collections.reverseOrder());
    for(int i=0 ; i<B ; i++){
      b[i]=cin.nextInt();
    }
    Arrays.sort(b,0,B,Collections.reverseOrder());
    for(int i=0 ; i<C ; i++){
      c[i]=cin.nextInt();
    }
    for(int i=C ; i<C+x ; i++){
      c[i]=a[i-C];
    }
    for(int i=C+x ; i<C+x+y ; i++){
      c[i]=b[i-C-x];
    }
    Arrays.sort(c,0,C+x+y,Collections.reverseOrder());
    long ans=0 ;
    for(int i=0 ; i<x+y ; i++){
      ans+=c[i];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := cin.getCurrent()->toInteger() ;
    var y : int ; y := cin.getCurrent()->toInteger() ;
    var A : int ; A := cin.getCurrent()->toInteger() ;
    var B : int ; B := cin.getCurrent()->toInteger() ;
    var C : int ; C := cin.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,A)->collect(null) ;
    var b : Sequence(int) ; b := Integer.subrange(1,B)->collect(null) ;
    var c : Sequence(int) ; c := Integer.subrange(1,C + x + y)->collect(null) ;
        var i : int ; i := 0 ; while i < A do ( (     a[i+1] := cin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a, 0, A, reverseOrder() := a, 0, A, reverseOrder()->sort() ; 
        var i : int ; i := 0 ; while i < B do ( (     b[i+1] := cin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    b, 0, B, reverseOrder() := b, 0, B, reverseOrder()->sort() ; 
        var i : int ; i := 0 ; while i < C do ( (     c[i+1] := cin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := C ; while i < C + x do ( (     c[i+1] := a[i - C+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := C + x ; while i < C + x + y do ( (     c[i+1] := b[i - C - x+1] )  ;     i := i + 1 ) ; 
    c, 0, C + x + y, reverseOrder() := c, 0, C + x + y, reverseOrder()->sort() ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < x + y do ( (     ans := ans+(c[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
import java.util.List ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    List<Integer>A=new ArrayList<>();
    List<Integer>B=new ArrayList<>();
    List<Integer>C=new ArrayList<>();
    for(int i=0 ; i<a ; i++){
      A.add(sc.nextInt());
    }
    for(int i=0 ; i<b ; i++){
      B.add(sc.nextInt());
    }
    for(int i=0 ; i<c ; i++){
      C.add(sc.nextInt());
    }
    Collections.sort(A,Collections.reverseOrder());
    Collections.sort(B,Collections.reverseOrder());
    for(int i=0 ; i<x ; i++){
      C.add(A.get(i));
    }
    for(int i=0 ; i<y ; i++){
      C.add(B.get(i));
    }
    long ans=0 ;
    Collections.sort(C,Collections.reverseOrder());
    for(int i=0 ; i<x+y ; i++){
      ans+=C.get(i);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Sequence{} ;
    var B : Sequence(int) ; B := Sequence{} ;
    var C : Sequence(int) ; C := Sequence{} ;
        var i : int ; i := 0 ; while i < a do ( (     A := A->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < b do ( (     B := B->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < c do ( (     C := C->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    A, reverseOrder() := A, reverseOrder()->sort() ; 
    B, reverseOrder() := B, reverseOrder()->sort() ; 
        var i : int ; i := 0 ; while i < x do ( (     C := C->including(A->at(i+1)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < y do ( (     C := C->including(B->at(i+1)) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    C, reverseOrder() := C, reverseOrder()->sort() ; 
        var i : int ; i := 0 ; while i < x + y do ( (     ans := ans+(C->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int X=sc.nextInt();
    int Y=sc.nextInt();
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    Integer red[]=new Integer[A];
    Integer green[]=new Integer[B];
    Integer clear[]=new Integer[C];
    for(int i=0 ; i<A ; i++){
      red[i]=sc.nextInt();
    }
    for(int i=0 ; i<B ; i++){
      green[i]=sc.nextInt();
    }
    for(int i=0 ; i<C ; i++){
      clear[i]=sc.nextInt();
    }
    Arrays.sort(red,Collections.reverseOrder());
    Arrays.sort(green,Collections.reverseOrder());
    Integer apple[]=new Integer[X+Y+C];
    for(int i=0 ; i<X ; i++)apple[i]=red[i];
    for(int i=0 ; i<Y ; i++)apple[i+X]=green[i];
    for(int i=0 ; i<C ; i++)apple[i+X+Y]=clear[i];
    Arrays.sort(apple,Collections.reverseOrder());
    long sum=0 ;
    for(int i=0 ; i<X+Y ; i++){
      sum+=apple[i];
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : int ; X := sc.getCurrent()->toInteger() ;
    var Y : int ; Y := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var red : Sequence(int) ; red := Integer.subrange(1,A)->collect(null) ;
    var green : Sequence(int) ; green := Integer.subrange(1,B)->collect(null) ;
    var clear : Sequence(int) ; clear := Integer.subrange(1,C)->collect(null) ;
        var i : int ; i := 0 ; while i < A do ( (     red[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < B do ( (     green[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < C do ( (     clear[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    red := OclComparator.sortWith(red, reverseOrder()) ; 
    green := OclComparator.sortWith(green, reverseOrder()) ; 
    var apple : Sequence(int) ; apple := Integer.subrange(1,X + Y + C)->collect(null) ;
        var i : int ; i := 0 ; while i < X do (     apple[i+1] := red[i+1] ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Y do (     apple[i + X+1] := green[i+1] ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < C do (     apple[i + X + Y+1] := clear[i+1] ;  ;     i := i + 1 ) ; 
    apple := OclComparator.sortWith(apple, reverseOrder()) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < X + Y do ( (     sum := sum+(apple[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static long answer(long n){
    long m=2 ;
    long ans=1 ;
    long r=1 ;
    while(r<n){
      r=((long)Math.pow(2,m)-1)*((long)Math.pow(2,m-1));
      if(r<n)ans=r ;
      m++;
    }
    return ans ;
  }
  public static void main(String args[]){
    long n=7 ;
    System.out.println(answer(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation answer( n : long) : long
  pre: true
  post: true
  activity: (     var m : long ; m := 2 ;
     var ans : long ; ans := 1 ;
    var r : long ; r := 1 ;
    while (r < n) do (     r := (2->pow(m)->oclAsType(long) - 1) * (2->pow(m - 1)->oclAsType(long)) ; 
     if (r < n) then     ans := r ; else skip ; 
     m := m + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 7 ;
     OclFile["System.out"].println(answer(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void nPermute(char[] str,int n){
    Arrays.sort(str);
    int i=1 ;
    do {
      if(i==n)break ;
      i++;
    }
    while(next_permutation(str));
    System.out.println(String.valueOf(str));
  }
  static boolean next_permutation(char[] p){
    for(int a=p.length-2 ; a>=0 ; --a)if(p[a]<p[a+1])for(int b=p.length-1 ; ; --b)if(p[b]>p[a]){
      char t=p[a];
      p[a]=p[b];
      p[b]=t ;
      for(++a,b=p.length-1 ; a<b ; ++a,--b){
        t=p[a];
        p[a]=p[b];
        p[b]=t ;
      }
      return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    String str="GEEKSFORGEEKS" ;
    int n=100 ;
    nPermute(str.toCharArray(),n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nPermute( str : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (     str := str->sort() ; 
     var i : int ; i := 1 ;
   while true do ((     if (i = n) then     break else skip ; 
     i := i + 1 ) ;
    if (next_permutation(str)) then skip else break) ; 
     OclFile["System.out"].println(((str) + "")) );
  static   operation next_permutation( p : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (         var a : int ; a := p->size() - 2 ; while a >= 0 do (     if (p[a+1] < p[a + 1+1]) then         var b : int ; b := p->size() - 1 ; while true do (     if (p[b+1] > p[a+1]) then (     var t : String ; t := p[a+1] ;
     p[a+1] := p[b+1] ; 
    p[b+1] := t ; 
        a := a + 1 ;     b := p->size() - 1 ; while a < b do ( (     t := p[a+1] ; 
     p[a+1] := p[b+1] ; 
     p[b+1] := t )  ;     a := a + 1 ;     b := b - 1 ) ; 
    return true 
 ) else skip ;  ;     b := b - 1 ) ; else skip ;  ;     a := a - 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GEEKSFORGEEKS" ;
     var n : int ; n := 100 ;
     execute nPermute(str->characters(), n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.max ;
import static java.lang.Math.min ;
import static java.lang.Math.abs ;
import static java.lang.System.out ;
import java.util.*;
import java.io.*;
import java.math.*;
public class x930B {
  public static void main(String hi[])throws Exception {
    BufferedReader infile=new BufferedReader(new InputStreamReader(System.in));
    char[] arr=infile.readLine().toCharArray();
    int N=arr.length ;
    int[][][] guesses=new int[26][N][26];
    for(int head=0 ; head<N ; head++)for(int i=1 ; i<N ; i++){
      int loc=(head+i)% N ;
      guesses[arr[head]-'a'][i][arr[loc]-'a']++;
    }
    int[] freq=new int[26];
    for(char c : arr)freq[c-'a']++;
    double res=0.0 ;
    for(int a=0 ; a<26 ; a++){
      int[][] grid=guesses[a];
      double temp=0.0 ;
      for(int i=0 ; i<N ; i++){
        int cnt=0 ;
        int total=0 ;
        for(int b=0 ; b<26 ; b++){
          if(grid[i][b]==1)cnt++;
          total+=grid[i][b];
        }
        if(total>0)temp=max(temp,1.0*cnt/total);
      }
      res+=(1.0*freq[a]/N)*temp ;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class x930B {
  static   operation main( hi : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var infile : OclFile ; infile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var arr : Sequence(String) ; arr := infile.readLine()->characters() ;
    var N : int ; N := arr->size() ;
    var guesses : Sequence(Sequence(Sequence(int))) ; guesses := Integer.subrange(1,26)->collect(Integer.subrange(1,N)->collect(Integer.subrange(1,26)->collect(0))) ;
        var head : int ; head := 0 ; while head < N do (         var i : int ; i := 1 ; while i < N do ( (     var loc : int ; loc := (head + i) mod N ;
     guesses[arr[head+1] - ('a')->char2byte()+1][i+1][arr[loc+1] - ('a')->char2byte()+1] := guesses[arr[head+1] - ('a')->char2byte()+1][i+1][arr[loc+1] - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ;  ;     head := head + 1 ) ; 
    var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
    for (c : arr) do (     freq[c - ('a')->char2byte()+1] := freq[c - ('a')->char2byte()+1] + 1 ;  ) ; 
    var res : double ; res := 0.0 ;
        var a : int ; a := 0 ; while a < 26 do ( (     var grid : Sequence(Sequence(int)) ; grid := guesses[a+1] ;
     var temp : double ; temp := 0.0 ;
         var i : int ; i := 0 ; while i < N do ( (     var cnt : int ; cnt := 0 ;
     var total : int ; total := 0 ;
         var b : int ; b := 0 ; while b < 26 do ( (     if (grid[i+1][b+1] = 1) then     cnt := cnt + 1 ; else skip ; 
     total := total+(grid[i+1][b+1]) )  ;     b := b + 1 ) ; 
     if (total > 0) then     temp := Set{temp, 1.0 * cnt / total}->max() ; else skip )  ;     i := i + 1 ) ; 
     res := res+((1.0 * freq[a+1] / N) * temp) )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maxResult(int n,int a,int b,int c){
    int maxVal=0 ;
    for(int i=0 ; i<=n ; i+=a)for(int j=0 ; j<=n-i ; j+=b){
      float z=(n-(i+j))/c ;
      if(Math.floor(z)==Math.ceil(z)){
        int x=i/a ;
        int y=j/b ;
        maxVal=Math.max(maxVal,x+y+(int)z);
      }
    }
    return maxVal ;
  }
  public static void main(String args[]){
    int n=10,a=5,b=3,c=4 ;
    System.out.println(maxResult(n,a,b,c));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxResult( n : int, a : int, b : int, c : int) : int
  pre: true
  post: true
  activity: (     var maxVal : int ; maxVal := 0 ;
         var i : int ; i := 0 ; while i <= n do (         var j : int ; j := 0 ; while j <= n - i do ( (     var z : double ; z := (n - (i + j)) / c ;
     if ((z)->floor() = (z)->ceil()) then (     var x : int ; x := i / a ;
     var y : int ; y := j / b ;
     maxVal := Set{maxVal, x + y + z->oclAsType(int)}->max() ) else skip )  ;     j := j+(b) ) ;  ;     i := i+(a) ) ; 
     return maxVal );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
    var a : int ; a := 5 ;
    var b : int ; b := 3 ;
    var c : int ; c := 4 ;
     OclFile["System.out"].println(maxResult(n, a, b, c)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int H=gi();
    int W=gi();
    int k=0 ;
    for(int i=0 ; i<H ; i++){
      String s=gs();
      for(int j=0 ; j<W ; j++){
        char c=s.charAt(j);
        if(c=='#')k++;
      }
    }
    if(k==H+W-1){
      System.out.println("Possible");
    }
    else {
      System.out.println("Impossible");
    }
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var H : int ; H := gi() ;
    var W : int ; W := gi() ;
    var k : int ; k := 0 ;
        var i : int ; i := 0 ; while i < H do ( (     var s : String ; s := gs() ;
         var j : int ; j := 0 ; while j < W do ( (     var c : String ; c := s->at(j+1) ;
     if (c = '#') then     k := k + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (k = H + W - 1) then (     OclFile["System.out"].println("Possible") ) else (     OclFile["System.out"].println("Impossible") ) ;  
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int h ;
  static int w ;
  static char[][] road ;
  public static void main(String[] args){
    h=sc.nextInt();
    w=sc.nextInt();
    road=new char[h][w];
    for(int y=0 ; y<h ; ++y)road[y]=sc.next().toCharArray();
    dfs(0,0);
    String ans=(hasVisitedAllGrids())? "Possible" : "Impossible" ;
    System.out.println(ans);
  }
  static int[] dy={
    0,1 };
    static int[] dx={
      1,0 };
      static void dfs(int y,int x){
        road[y][x]='!' ;
        for(int i=0 ; i<2 ; ++i){
          int ty=y+dy[i];
          int tx=x+dx[i];
          if(isOutside(ty,tx)|| road[ty][tx]!='#')continue ;
          dfs(ty,tx);
          return ;
        }
      }
      static boolean isOutside(int y,int x){
        return(y<0 || h<=y || x<0 || w<=x);
      }
      static boolean hasVisitedAllGrids(){
        for(int y=0 ; y<h ; ++y){
          for(int x=0 ; x<w ; ++x){
            if(road[y][x]=='#')return false ;
          }
        }
        return true ;
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute h : int;
  static   attribute w : int;
  static   attribute road : Sequence(Sequence(String));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     h := sc.getCurrent()->toInteger() ; 
     w := sc.getCurrent()->toInteger() ; 
    road := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ; 
        var y : int ; y := 0 ; while y < h do (     road[y+1] := sc.getCurrent()->characters() ;  ;     y := y + 1 ) ; 
    execute dfs(0, 0) ; 
    var ans : String ; ans := if (hasVisitedAllGrids()) then "Possible" else "Impossible" endif ;
    OclFile["System.out"].println(ans) ; 
 );
  static   attribute dy : Sequence(int) := Sequence{0,1};
  static   attribute dx : Sequence(int) := Sequence{1,0};
  static   operation dfs( y : int, x : int) : void
  pre: true
  post: true
  activity: (     road[y+1][x+1] := '!' ; 
         var i : int ; i := 0 ; while i < 2 do ( (     var ty : int ; ty := y + dy[i+1] ;
     var tx : int ; tx := x + dx[i+1] ;
    if (isOutside(ty, tx) or road[ty+1][tx+1] /= '#') then     continue else skip ; 
    execute dfs(ty, tx) ; 
    return 
 )  ;     i := i + 1 ) );
  static   operation isOutside( y : int, x : int) : boolean
  pre: true
  post: true
  activity: (     return (y < 0 or h <= y or x < 0 or w <= x) );
  static   operation hasVisitedAllGrids() : boolean
  pre: true
  post: true
  activity: (         var y : int ; y := 0 ; while y < h do ( (         var x : int ; x := 0 ; while x < w do ( (     if (road[y+1][x+1] = '#') then     return false else skip )  ;     x := x + 1 ) )  ;     y := y + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static int w,h ;
  private static char[][] grid ;
  private static int count ;
  private static boolean valid ;
  private static void dfs(int x,int y,int len){
    if(x==w-1 && y==h-1){
      if(len==count)valid=true ;
      return ;
    }
    if(x<w-1 && grid[y][x+1]=='#'){
      dfs(x+1,y,len+1);
    }
    if(y<h-1 && grid[y+1][x]=='#'){
      dfs(x,y+1,len+1);
    }
  }
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    h=input.nextInt();
    w=input.nextInt();
    input.nextLine();
    grid=new char[h][];
    for(int y=0 ; y<h ; y++){
      grid[y]=input.nextLine().toCharArray();
      for(int x=0 ; x<w ; x++){
        if(grid[y][x]=='#')count++;
      }
    }
    if(grid[0][0]!='#'){
      System.out.println("Impossible");
      return ;
    }
    valid=false ;
    dfs(0,0,1);
    System.out.println(valid ? "Possible" : "Impossible");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute w : int;
  static   attribute grid : Sequence(Sequence(String));
  static   attribute count : int;
  static   attribute valid : boolean;
  static   operation dfs( x : int, y : int, len : int) : void
  pre: true
  post: true
  activity: (     if (x = w - 1 & y = h - 1) then (     if (len = count) then     valid := true ; else skip ; 
     return ) else skip ; 
     if (x < w - 1 & grid[y+1][x + 1+1] = '#') then (     execute dfs(x + 1, y, len + 1) ) else skip ; 
     if (y < h - 1 & grid[y + 1+1][x+1] = '#') then (     execute dfs(x, y + 1, len + 1) ) else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     h := input.getCurrent()->toInteger() ; 
    w := input.getCurrent()->toInteger() ; 
    skip ; 
    grid := Integer.subrange(1,h)->collect(Sequence{}) ; 
        var y : int ; y := 0 ; while y < h do ( (     grid[y+1] := input.nextLine()->characters() ; 
         var x : int ; x := 0 ; while x < w do ( (     if (grid[y+1][x+1] = '#') then     count := count + 1 ; else skip )  ;     x := x + 1 ) )  ;     y := y + 1 ) ; 
    if (grid[0+1][0+1] /= '#') then (     OclFile["System.out"].println("Impossible") ; 
     return ) else skip ; 
    valid := false ; 
    execute dfs(0, 0, 1) ; 
    OclFile["System.out"].println(if valid then "Possible" else "Impossible" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int h=s.nextInt();
    int w=s.nextInt();
    boolean[][] visited=new boolean[h+1][w+1];
    for(int i=0 ; i<h ; i++){
      String line=s.next();
      for(int j=0 ; j<w ; j++){
        visited[i][j]=line.charAt(j)=='#' ;
      }
    }
    int pi=0 ;
    int pj=0 ;
    while(pi!=h-1 || pj!=w-1){
      visited[pi][pj]=false ;
      if(visited[pi][pj+1]){
        pj++;
      }
      else if(visited[pi+1][pj]){
        pi++;
      }
      else {
        throw new RuntimeException("No destination");
      }
      for(int i=0 ; i<h ; i++){
        for(int j=0 ; j<w ; j++){
          if(i<pi || j<pj){
            if(visited[i][j]){
              System.out.println("Impossible");
              return ;
            }
          }
        }
      }
    }
    System.out.println("Possible");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := s.getCurrent()->toInteger() ;
    var w : int ; w := s.getCurrent()->toInteger() ;
    var visited : Sequence(Sequence(boolean)) ; visited := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(false)) ;
        var i : int ; i := 0 ; while i < h do ( (     var line : String ; line := s.getCurrent() ;
         var j : int ; j := 0 ; while j < w do ( (     visited[i+1][j+1] := line->at(j+1) = '#' )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var pi : int ; pi := 0 ;
    var pj : int ; pj := 0 ;
    while (pi /= h - 1 or pj /= w - 1) do (     visited[pi+1][pj+1] := false ; 
     if (visited[pi+1][pj + 1+1]) then (     pj := pj + 1 ) else     if (visited[pi + 1+1][pj+1]) then (     pi := pi + 1 ) else (     error ProgramException("No destination") ) ;  ;  
         var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (i < pi or j < pj) then (     if (visited[i+1][j+1]) then (     OclFile["System.out"].println("Impossible") ; 
     return ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) ; 
    OclFile["System.out"].println("Possible") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    int h=sc.nextInt();
    int w=sc.nextInt();
    char[][] map=new char[h][w];
    for(int i=0 ; i<h ; i++){
      map[i]=sc.next().toCharArray();
    }
    int cnt=0 ;
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        if(map[i][j]=='#'){
          cnt++;
        }
      }
    }
    System.out.println((cnt==h+w-1)? "Possible" : "Impossible");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(String)) ; map := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (     map[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (map[i+1][j+1] = '#') then (     cnt := cnt + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if (cnt = h + w - 1) then "Possible" else "Impossible" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p116 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p116().run());
  }
  private static final int LENGTH=50 ;
  public String run(){
    return Long.toString(countWays(LENGTH,2)+countWays(LENGTH,3)+countWays(LENGTH,4));
  }
  private static long countWays(int length,int m){
    long[] ways=new long[length+1];
    ways[0]=1 ;
    for(int n=1 ; n<=length ; n++){
      ways[n]+=ways[n-1];
      if(n>=m)ways[n]+=ways[n-m];
    }
    return ways[length]-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p116 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p116.newp116().run()) );
  static    attribute LENGTH : int := 50;
   operation run() : String
  pre: true
  post: true
  activity: (     return ((countWays(LENGTH, 2) + countWays(LENGTH, 3) + countWays(LENGTH, 4)) + "") );
  static   operation countWays( length : int, m : int) : long
  pre: true
  post: true
  activity: (     var ways : Sequence(long) ; ways := Integer.subrange(1,length + 1)->collect(0) ;
     ways[0+1] := 1 ; 
         var n : int ; n := 1 ; while n <= length do ( (     ways[n+1] := ways[n+1]+(ways[n - 1+1]) ; 
     if (n >= m) then     ways[n+1] := ways[n+1]+(ways[n - m+1]) ; else skip )  ;     n := n + 1 ) ; 
     return ways[length+1] - 1 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean check(int arr[],int n){
    int k=Integer.MIN_VALUE ;
    int r=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      k=Math.max(k,arr[i]);
      r=Math.min(r,arr[i]);
    }
    k+=1 ;
    for(int i=0 ; i<n ; i++)arr[i]=k-arr[i];
    for(int i=0 ; i<n ; i++){
      if(Math.abs(arr[i])-1<n && arr[Math.abs(arr[i])-1]>0){
        arr[Math.abs(arr[i])-1]=-arr[Math.abs(arr[i])-1];
      }
    }
    int flag=0 ;
    for(int i=0 ; i<=k-r-1 ; i++){
      if(arr[i]>0){
        flag=1 ;
        break ;
      }
    }
    return flag==0 ;
  }
  public static void main(String[] args){
    int arr[]={
      5,2,3,6,4,4,6,6 };
      int n=arr.length ;
      if(check(arr,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var k : int ; k := -2147483648 ;
     var r : int ; r := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     k := Set{k, arr[i+1]}->max() ; 
     r := Set{r, arr[i+1]}->min() )  ;     i := i + 1 ) ; 
    k := k+(1) ; 
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := k - arr[i+1] ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif - 1 < n & arr[if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif - 1+1] > 0) then (     arr[if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif - 1+1] := -arr[if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif - 1+1] ) else skip )  ;     i := i + 1 ) ; 
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i <= k - r - 1 do ( (     if (arr[i+1] > 0) then (     flag := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    return flag = 0 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,2,3,6,4,4,6,6} ;
     var n : int ; n := arr->size() ;
     if (check(arr, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minReplacement(String s,int len){
    int ans=0 ;
    for(int i=0 ; i<len ; i++){
      if(i % 2==0 && s.charAt(i)=='1')ans++;
      if(i % 2==1 && s.charAt(i)=='0')ans++;
    }
    return Math.min(ans,len-ans);
  }
  public static void main(String args[]){
    String s="1100" ;
    int len=s.length();
    System.out.print(minReplacement(s,len));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minReplacement( s : String, len : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < len do ( (     if (i mod 2 = 0 & s->at(i+1) = '1') then     ans := ans + 1 ; else skip ; 
     if (i mod 2 = 1 & s->at(i+1) = '0') then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
     return Set{ans, len - ans}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "1100" ;
     var len : int ; len := s->size() ;
     OclFile["System.out"].print(minReplacement(s, len)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void right_left(int a[],int n){
    Map<Integer,Integer>total=new HashMap<>();
    Map<Integer,Integer>left=new HashMap<>();
    for(int i=0 ; i<n ; i++)total.put(a[i],total.get(a[i])==null ? 1 : total.get(a[i])+1);
    for(int i=0 ; i<n ; i++){
      System.out.print((total.get(a[i])-1-(2*(left.containsKey(a[i])==true ? left.get(a[i]): 0)))+" ");
      left.put(a[i],left.get(a[i])==null ? 1 : left.get(a[i])+1);
    }
  }
  public static void main(String[] args){
    int a[]={
      1,2,3,2,1 };
      int n=a.length ;
      right_left(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation right_left( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var total : Map(int,int) ; total := Map{} ;
     var left : Map(int,int) ; left := Map{} ;
         var i : int ; i := 0 ; while i < n do (     total := total->union(Map{a[i+1] |-> if total->at(a[i+1]) = null then 1 else total->at(a[i+1]) + 1 endif}) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print((total->at(a[i+1]) - 1 - (2 * (if left->keys()->includes(a[i+1]) = true then left->at(a[i+1]) else 0 endif))) + " ") ; 
     left := left->union(Map{a[i+1] |-> if left->at(a[i+1]) = null then 1 else left->at(a[i+1]) + 1 endif}) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,2,1} ;
     var n : int ; n := a->size() ;
     execute right_left(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long calculateSum(int n,int k){
    long res=1 ;
    long MOD=1000000007 ;
    for(int i=0 ; i<k ; i++){
      res=(res*n)% MOD ;
    }
    return res ;
  }
  public static void main(String[] args){
    int n=4 ;
    int k=3 ;
    System.out.print(calculateSum(n,k));
  }
};
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation calculateSum( n : int, k : int) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     var MOD : long ; MOD := 1000000007 ;
         var i : int ; i := 0 ; while i < k do ( (     res := (res * n) mod MOD )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var k : int ; k := 3 ;
     OclFile["System.out"].print(calculateSum(n, k)) );
}
 ;

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  private static void sort(int[] a){
    for(int i=0 ; i<a.length-1 ; i++){
      for(int j=a.length-1 ; j>i ; j--){
        if(a[j]>a[j-1]){
          int t=a[j];
          a[j]=a[j-1];
          a[j-1]=t ;
        }
      }
    }
  }
  private static void print_hill(int[] a){
    for(int i=0 ; i<3 ; i++){
      System.out.println(a[i]);
    }
  }
  public static void main(String args[])throws IOException {
    int hills[]=new int[10];
    InputStreamReader inp=new InputStreamReader(System.in);
    BufferedReader bre=new BufferedReader(inp);
    int n ;
    for(int i=0 ; i<10 ; i++){
      String num=bre.readLine();
      n=Integer.parseInt(num);
      hills[i]=n ;
    }
    sort(hills);
    print_hill(hills);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < a->size() - 1 do ( (         var j : int ; j := a->size() - 1 ; while j > i do ( (     if (a[j+1] > a[j - 1+1]) then (     var t : int ; t := a[j+1] ;
     a[j+1] := a[j - 1+1] ; 
     a[j - 1+1] := t ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) );
  static   operation print_hill( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 3 do ( (     OclFile["System.out"].println(a[i+1]) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var hills : Sequence(int) ; hills := Integer.subrange(1,10)->collect(0) ;
     var inp : OclFile ; inp := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var bre : OclFile ; bre := OclFile.newOclFile_Read(inp) ;
    var n : int ;
        var i : int ; i := 0 ; while i < 10 do ( (     var num : String ; num := bre.readLine() ;
     n := (num)->toInteger() ; 
     hills[i+1] := n )  ;     i := i + 1 ) ; 
    execute sort(hills) ; 
    execute print_hill(hills) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.HashMap ;
public class Problem {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    char[] arr=reader.readLine().toCharArray();
    int n=arr.length ;
    HashMap<Character,ArrayList<Integer>>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      char x=arr[i];
      map.putIfAbsent(x,new ArrayList<>());
      ArrayList<Integer>list=map.get(x);
      list.add(i);
      map.replace(x,list);
    }
    double res=0 ;
    for(char elem : map.keySet()){
      int most=0,sum=map.get(elem).size();
      for(int j=1 ; j<n ; j++){
        HashMap<Character,Integer>amount=new HashMap<>();
        for(int i : map.get(elem)){
          int ind=(i+j)% n ;
          char x=arr[ind];
          amount.putIfAbsent(x,0);
          amount.replace(x,amount.get(x)+1);
        }
        int ones=0 ;
        for(char item : amount.keySet()){
          if(amount.get(item)==1)ones++;
        }
        most=Math.max(most,ones);
      }
      res+=((most/(double)sum)*(sum/(double)n));
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var arr : Sequence(String) ; arr := reader.readLine()->characters() ;
    var n : int ; n := arr->size() ;
    var map : Map(String,Sequence(int)) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : String ; x := arr[i+1] ;
     if map->keys()->includes(x) then skip else map := map->union(Map{x |-> Sequence{}}) ; 
    var list : Sequence(int) ; list := map->at(x) ;
    list := list->including(i) ; 
    map := map.replace(x, list) ; 
 )  ;     i := i + 1 ) ; 
    var res : double ; res := 0 ;
    for (elem : map->keys()) do ( (     var most : int ; most := 0 ;
    var sum : int ; sum := map->at(elem)->size() ;
         var j : int ; j := 1 ; while j < n do ( (     var amount : Map(String,int) ; amount := Map{} ;
     for (i : map->at(elem)) do ( (     var ind : int ; ind := (i + j) mod n ;
     var x : String ; x := arr[ind+1] ;
     if amount->keys()->includes(x) then skip else amount := amount->union(Map{x |-> 0}) ; 
     amount := amount.replace(x, amount->at(x) + 1) )  ) ; 
    var ones : int ; ones := 0 ;
    for (item : amount->keys()) do ( (     if (amount->at(item) = 1) then     ones := ones + 1 ; else skip )  ) ; 
    most := Set{most, ones}->max() ; 
 )  ;     j := j + 1 ) ; 
     res := res+(((most / sum->oclAsType(double)) * (sum / n->oclAsType(double)))) )  ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public Main(){
  }
  public static void main(String[] args){
    new Main().solve();
  }
  private Scanner sc ;
  private void solve(){
    sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
    }
    boolean flag=true ;
    int cnt=0 ;
    int i=0 ;
    while(flag){
      flag=false ;
      for(int j=N-1 ; j>=i+1 ; j--){
        if(A[j]<A[j-1]){
          int tmp=A[j-1];
          A[j-1]=A[j];
          A[j]=tmp ;
          flag=true ;
          cnt++;
        }
      }
      i++;
    }
    String ans="" ;
    for(int num : A){
      ans+=num ;
      ans+=" " ;
    }
    System.out.println(ans.trim());
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   attribute sc : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := true ;
    var cnt : int ; cnt := 0 ;
    var i : int ; i := 0 ;
    while (flag) do (     flag := false ; 
         var j : int ; j := N - 1 ; while j >= i + 1 do ( (     if (A[j+1] < A[j - 1+1]) then (     var tmp : int ; tmp := A[j - 1+1] ;
     A[j - 1+1] := A[j+1] ; 
    A[j+1] := tmp ; 
    flag := true ; 
    cnt := cnt + 1 ; 
 ) else skip )  ;     j := j - 1 ) ; 
     i := i + 1 ) ; 
    var ans : String ; ans := "" ;
    for (num : A) do ( (     ans := ans+(num) ; 
     ans := ans+(" ") )  ) ; 
    OclFile["System.out"].println(ans->trim()) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    int[] ar=new int[n];
    for(int i=0 ; i<n ; i++){
      ar[i]=sc.nextInt();
    }
    boolean F=true ;
    int j=0 ;
    int times=0 ;
    while(F==true){
      F=false ;
      for(int i=n-1 ; i>=j+1 ; i--){
        if(ar[i]<ar[i-1]){
          int temp=ar[i];
          ar[i]=ar[i-1];
          ar[i-1]=temp ;
          times++;
          F=true ;
        }
      }
      j++;
    }
    for(int x=0 ; x<n ; x++){
      out.print((x==0 ? "" : " ")+ar[x]);
    }
    out.println();
    out.println(times);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var F : boolean ; F := true ;
    var j : int ; j := 0 ;
    var times : int ; times := 0 ;
    while (F = true) do (     F := false ; 
         var i : int ; i := n - 1 ; while i >= j + 1 do ( (     if (ar[i+1] < ar[i - 1+1]) then (     var temp : int ; temp := ar[i+1] ;
     ar[i+1] := ar[i - 1+1] ; 
    ar[i - 1+1] := temp ; 
    times := times + 1 ; 
    F := true ; 
 ) else skip )  ;     i := i - 1 ) ; 
     j := j + 1 ) ; 
        var x : int ; x := 0 ; while x < n do ( (     out.print((if x = 0 then "" else " " endif) + ar[x+1]) )  ;     x := x + 1 ) ; 
    out.println() ; 
    out.println(times) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] strs=br.readLine().split(" ");
    int[] inputData=new int[n];
    for(int i=0 ; i<n ; i++){
      inputData[i]=Integer.parseInt(strs[i]);
    }
    int swapCnt=bubbleSort(inputData,n);
    printArray(inputData);
    System.out.println(swapCnt);
  }
  public static int bubbleSort(int[] A,int N){
    int swapCnt=0 ;
    boolean flag=true ;
    while(flag){
      flag=false ;
      for(int i=N-1 ; i>0 ; i--){
        if(A[i]<A[i-1]){
          int temp=A[i];
          A[i]=A[i-1];
          A[i-1]=temp ;
          swapCnt++;
          flag=true ;
        }
      }
    }
    return swapCnt ;
  }
  public static void printArray(int[] target){
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<target.length ; i++){
      sb.append(target[i]);
      if(i<target.length-1){
        sb.append(" ");
      }
    }
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var strs : Sequence(String) ; strs := br.readLine()->split(" ") ;
    var inputData : Sequence(int) ; inputData := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     inputData[i+1] := (strs[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var swapCnt : int ; swapCnt := bubbleSort(inputData, n) ;
    execute printArray(inputData) ; 
    OclFile["System.out"].println(swapCnt) ; 
 );
  static   operation bubbleSort( A : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var swapCnt : int ; swapCnt := 0 ;
     var flag : boolean ; flag := true ;
     while (flag) do (     flag := false ; 
         var i : int ; i := N - 1 ; while i > 0 do ( (     if (A[i+1] < A[i - 1+1]) then (     var temp : int ; temp := A[i+1] ;
     A[i+1] := A[i - 1+1] ; 
    A[i - 1+1] := temp ; 
    swapCnt := swapCnt + 1 ; 
    flag := true ; 
 ) else skip )  ;     i := i - 1 ) ) ; 
     return swapCnt );
  static   operation printArray( target : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < target->size() do ( (     sb := sb + StringLib.newString(target[i+1]) ; 
     if (i < target->size() - 1) then (     sb := sb + StringLib.newString(" ") ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sb+"") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args){
    BufferedReader kb=new BufferedReader(new InputStreamReader(System.in));
    try {
      int n=Integer.parseInt(kb.readLine());
      String[] nums=kb.readLine().split(" ");
      int[] A=new int[n];
      int i,j ;
      for(i=0 ; i<n ; i++){
        A[i]=Integer.parseInt(nums[i]);
      }
      int cnt=0 ;
      cnt=bubbleSort(A,n);
      StringBuilder output=new StringBuilder(200+1);
      for(i=0 ; i<n ; i++){
        output.append(A[i]);
        output.append(" ");
      }
      output.deleteCharAt(output.lastIndexOf(" "));
      System.out.println(output);
      System.out.println(cnt);
      kb.close();
    }
    catch(IOException e){
      System.err.println(e);
    }
  }
  static int bubbleSort(int[] A,int n){
    int tmp ;
    int i,j,cnt ;
    cnt=0 ;
    for(i=0 ; i<n ; i++){
      for(j=n-1 ; i<j ; j--){
        if(A[j]<A[j-1]){
          tmp=A[j-1];
          A[j-1]=A[j];
          A[j]=tmp ;
          cnt++;
        }
      }
    }
    return cnt ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var kb : OclFile ; kb := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var n : int ; n := (kb.readLine())->toInteger() ;
     var nums : Sequence(String) ; nums := kb.readLine()->split(" ") ;
    var A : Sequence(int) ; A := Integer.subrange(1,n)->collect(0) ;
    var i : int ;
    var j : int ;
        i := 0 ; while i < n do ( (     A[i+1] := (nums[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    cnt := bubbleSort(A, n) ; 
    var output : String ; output := StringLib.newString(200 + 1) ;
        i := 0 ; while i < n do ( (     output := output + StringLib.newString(A[i+1]) ; 
     output := output + StringLib.newString(" ") )  ;     i := i + 1 ) ; 
    output := output->excludingAt(output->lastIndexOf(" ")-1+1) ; 
    OclFile["System.out"].println(output) ; 
    OclFile["System.out"].println(cnt) ; 
    skip ; 
 )   catch (e : IOException) do (     OclFile["System.err"].println(e) )
 );
  static   operation bubbleSort( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var tmp : int ;
     var i : int ;
    var j : int ;
    var cnt : int ;
    cnt := 0 ; 
        i := 0 ; while i < n do ( (         j := n - 1 ; while i < j do ( (     if (A[j+1] < A[j - 1+1]) then (     tmp := A[j - 1+1] ; 
     A[j - 1+1] := A[j+1] ; 
     A[j+1] := tmp ; 
     cnt := cnt + 1 ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    return cnt 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args){
    BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    String str="" ;
    StringTokenizer stk ;
    int[] arrays ;
    int youso=0 ;
    int counter=0 ;
    try {
      str=bfr.readLine();
      youso=Integer.parseInt(str);
      arrays=new int[youso];
      str=bfr.readLine();
      stk=new StringTokenizer(str," ");
      while(stk.hasMoreTokens()){
        arrays[counter]=Integer.parseInt(stk.nextToken());
        counter++;
      }
      Bubble(arrays);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  static void Bubble(int[] a){
    int tmp1,tmp2=0 ;
    int ookisa=a.length ;
    int kaisu=0 ;
    for(int i=0 ; i<ookisa-1 ; i++){
      for(int j=ookisa-1 ; j>=i+1 ; j--){
        if(a[j]<a[j-1]){
          tmp1=a[j];
          tmp2=a[j-1];
          a[j]=tmp2 ;
          a[j-1]=tmp1 ;
          kaisu++;
        }
      }
    }
    String moji="" ;
    for(int i=0 ; i<ookisa-1 ; i++){
      moji=moji+a[i]+" " ;
    }
    moji=moji+a[ookisa-1];
    System.out.println(moji);
    System.out.println(kaisu);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bfr : OclFile ; bfr := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := "" ;
    var stk : OclIterator ;
    var arrays : Sequence(int) ;
    var youso : int ; youso := 0 ;
    var counter : int ; counter := 0 ;
    try (     str := bfr.readLine() ; 
     youso := (str)->toInteger() ; 
    arrays := Integer.subrange(1,youso)->collect(0) ; 
    str := bfr.readLine() ; 
    stk := OclIterator.newOclIterator_String_String(str, " ") ; 
    while (stk.hasNext()) do (     arrays[counter+1] := (stk.next())->toInteger() ; 
     counter := counter + 1 ) ; 
    execute Bubble(arrays) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
  static   operation Bubble( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var tmp1 : int ;
    var tmp2 : int ; tmp2 := 0 ;
     var ookisa : int ; ookisa := a->size() ;
    var kaisu : int ; kaisu := 0 ;
        var i : int ; i := 0 ; while i < ookisa - 1 do ( (         var j : int ; j := ookisa - 1 ; while j >= i + 1 do ( (     if (a[j+1] < a[j - 1+1]) then (     tmp1 := a[j+1] ; 
     tmp2 := a[j - 1+1] ; 
    a[j+1] := tmp2 ; 
    a[j - 1+1] := tmp1 ; 
    kaisu := kaisu + 1 ; 
 ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    var moji : String ; moji := "" ;
        var i : int ; i := 0 ; while i < ookisa - 1 do ( (     moji := moji + a[i+1] + " " )  ;     i := i + 1 ) ; 
    moji := moji + a[ookisa - 1+1] ; 
    OclFile["System.out"].println(moji) ; 
    OclFile["System.out"].println(kaisu) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int countPattern(int n,String pat){
    int pattern_int=0 ;
    int power_two=1 ;
    int all_ones=0 ;
    for(int i=pat.length()-1 ; i>=0 ; i--){
      int current_bit=pat.charAt(i)-'0' ;
      pattern_int+=(power_two*current_bit);
      all_ones=all_ones+power_two ;
      power_two=power_two*2 ;
    }
    int count=0 ;
    while(n!=0 && n>=pattern_int){
      if((n & all_ones)==pattern_int){
        count++;
      }
      n=n>>1 ;
    }
    return count ;
  }
  public static void main(String args[]){
    int n=500 ;
    String pat="10" ;
    System.out.println(countPattern(n,pat));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation countPattern( n : int, pat : String) : int
  pre: true
  post: true
  activity: (     var pattern_int : int ; pattern_int := 0 ;
     var power_two : int ; power_two := 1 ;
    var all_ones : int ; all_ones := 0 ;
        var i : int ; i := pat->size() - 1 ; while i >= 0 do ( (     var current_bit : int ; current_bit := pat->at(i+1) - ('0')->char2byte() ;
     pattern_int := pattern_int+((power_two * current_bit)) ; 
     all_ones := all_ones + power_two ; 
     power_two := power_two * 2 )  ;     i := i - 1 ) ; 
    var count : int ; count := 0 ;
    while (n /= 0 & n >= pattern_int) do (     if ((n & all_ones) = pattern_int) then (     count := count + 1 ) else skip ; 
     n := (n/(2->pow(1)))->oclAsType(long) ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 500 ;
     var pat : String ; pat := "10" ;
     OclFile["System.out"].println(countPattern(n, pat)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int m=sc.nextInt();
    int n=sc.nextInt();
    int[] mCnt=new int[m];
    int totalCnt=0 ;
    for(int i=0 ; i<n ; i++){
      int temp=sc.nextInt()-1 ;
      mCnt[temp]++;
      if(mCnt[temp]==1){
        totalCnt++;
      }
      if(totalCnt<m){
        System.out.print(0);
      }
      else {
        System.out.print(1);
        totalCnt=0 ;
        for(int j=0 ; j<m ; j++){
          mCnt[j]--;
          if(mCnt[j]>=1){
            totalCnt++;
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class test2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var mCnt : Sequence(int) ; mCnt := Integer.subrange(1,m)->collect(0) ;
    var totalCnt : int ; totalCnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : int ; temp := sc.getCurrent()->toInteger() - 1 ;
     mCnt[temp+1] := mCnt[temp+1] + 1 ; 
     if (mCnt[temp+1] = 1) then (     totalCnt := totalCnt + 1 ) else skip ; 
     if (totalCnt < m) then (     OclFile["System.out"].print(0) ) else (     OclFile["System.out"].print(1) ; 
     totalCnt := 0 ; 
         var j : int ; j := 0 ; while j < m do ( (     mCnt[j+1] := mCnt[j+1] - 1 ; 
     if (mCnt[j+1] >= 1) then (     totalCnt := totalCnt + 1 ) else skip )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    HashMap<Integer,Integer>map=new HashMap<>();
    StringBuffer strbuf=new StringBuffer();
    int n=in.nextInt(),m=in.nextInt();
    for(int i=0 ; i<m ; i++){
      int key=in.nextInt();
      if(! map.containsKey(key)){
        map.put(key,1);
      }
      else {
        int val=map.get(key);
        map.put(key,++val);
      }
      if(map.size()==n){
        for(int j=1 ; j<=n ; j++){
          int temp=map.get(j);
          if(map.put(j,--temp)==1){
            map.remove(j);
          }
        }
        strbuf.append(1);
      }
      else {
        strbuf.append(0);
      }
    }
    System.out.print(strbuf.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var map : Map(int,int) ; map := Map{} ;
    var strbuf : String ; strbuf := StringLib.newString() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     var key : int ; key := in.getCurrent()->toInteger() ;
     if (not(map->keys()->includes(key))) then (     map := map->union(Map{key |-> 1}) ) else (     var val : int ; val := map->at(key) ;
     map := map->union(Map{key |-> (val + 1)}) ) ;  
     if (map.size() = n) then (         var j : int ; j := 1 ; while j <= n do ( (     var temp : int ; temp := map->at(j) ;
     if (map->at(j) = 1) then (     map := map->antirestrict(Set{j}) ) else skip )  ;     j := j + 1 ) ; 
     strbuf := strbuf + StringLib.newString(1) ) else (     strbuf := strbuf + StringLib.newString(0) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(strbuf+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Fibonacci {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=sc.nextInt();
    int m=sc.nextInt();
    HashMap<Integer,Integer>count=new HashMap<>();
    StringBuilder res=new StringBuilder();
    while(m-->0){
      int cur=sc.nextInt();
      if(count.containsKey(cur)){
        count.put(cur,count.get(cur)+1);
      }
      else {
        count.put(cur,1);
      }
      if(count.size()==n){
        res.append("1");
        for(int i=1 ; i<=n ; i++){
          count.put(i,count.get(i)-1);
          if(count.get(i)==0){
            count.remove(i);
          }
        }
      }
      else {
        res.append("0");
      }
    }
    pw.println(res);
    pw.flush();
  }
  static class Scanner {
    BufferedReader br ;
    StringTokenizer st ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(FileReader f){
      br=new BufferedReader(f);
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public int[] nextIntArr(int n)throws IOException {
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=Integer.parseInt(next());
      }
      return arr ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Fibonacci {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var count : Map(int,int) ; count := Map{} ;
    var res : String ; res := StringLib.newString() ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     var cur : int ; cur := sc.getCurrent()->toInteger() ;
     if (count->keys()->includes(cur)) then (     count := count->union(Map{cur |-> count->at(cur) + 1}) ) else (     count := count->union(Map{cur |-> 1}) ) ;  
     if (count.size() = n) then (     res := res + StringLib.newString("1") ; 
         var i : int ; i := 1 ; while i <= n do ( (     count := count->union(Map{i |-> count->at(i) - 1}) ; 
     if (count->at(i) = 0) then (     count := count->antirestrict(Set{i}) ) else skip )  ;     i := i + 1 ) ) else (     res := res + StringLib.newString("0") ) ) ;  ) ;  
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( f : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(f) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArr( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (next())->toInteger() )  ;     i := i + 1 ) ; 
     return arr );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int[] Num ;
    Num=new int[11];
    Scanner n=new Scanner(System.in);
    for(int i=0 ; i<10 ; i++){
      Num[i]=n.nextInt();
    }
    for(int a=9 ; a>=0 ; a--){
      for(int b=0 ; b<a ; b++){
        if(Num[b]<Num[b+1]){
          Num[10]=Num[b];
          Num[b]=Num[b+1];
          Num[b+1]=Num[10];
        }
      }
    }
    System.out.println(Num[0]);
    System.out.println(Num[1]);
    System.out.println(Num[2]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Num : Sequence(int) ;
     Num := Integer.subrange(1,11)->collect(0) ; 
    var n : OclFile ; n := OclFile.newOclFile_Read(OclFile["System.in"]) ;
        var i : int ; i := 0 ; while i < 10 do ( (     Num[i+1] := n.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var a : int ; a := 9 ; while a >= 0 do ( (         var b : int ; b := 0 ; while b < a do ( (     if (Num[b+1] < Num[b + 1+1]) then (     Num[10+1] := Num[b+1] ; 
     Num[b+1] := Num[b + 1+1] ; 
     Num[b + 1+1] := Num[10+1] ) else skip )  ;     b := b + 1 ) )  ;     a := a - 1 ) ; 
    OclFile["System.out"].println(Num[0+1]) ; 
    OclFile["System.out"].println(Num[1+1]) ; 
    OclFile["System.out"].println(Num[2+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findNumber(int n){
    int num=n-1 ;
    num=2*(int)Math.pow(4,num);
    num=(int)Math.floor(num/3.0);
    return num ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(findNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNumber( n : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := n - 1 ;
     num := 2 * 4->pow(num)->oclAsType(int) ; 
     num := (num / 3.0)->floor()->oclAsType(int) ; 
     return num );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(findNumber(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
class GFG {
  static int countIntervals(int[][] arr,int V,int N){
    int count=0 ;
    int li,ri ;
    for(int i=0 ; i<N ; i++){
      li=arr[i][0];
      ri=arr[i][1];
      if(V>=li && V<=ri)count++;
    }
    return count ;
  }
  public static void main(String args[]){
    int[][] arr={
      {
        1,10 },{
          5,10 },{
            15,25 },{
              7,12 },{
                20,25 }
              };
              int V=7 ;
              int N=arr.length ;
              System.out.println(countIntervals(arr,V,N));
            }
          }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countIntervals( arr : Sequence(Sequence(int)), V : int, N : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var li : int ;
    var ri : int ;
         var i : int ; i := 0 ; while i < N do ( (     li := arr[i+1][0+1] ; 
     ri := arr[i+1][1+1] ; 
     if (V >= li & V <= ri) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,10},Sequence{5,10},Sequence{15,25},Sequence{7,12},Sequence{20,25}} ;
     var V : int ; V := 7 ;
     var N : int ; N := arr->size() ;
     OclFile["System.out"].println(countIntervals(arr, V, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int multiply(int x,int y){
    if(y==0)return 0 ;
    if(y>0)return(x+multiply(x,y-1));
    if(y<0)return-multiply(x,-y);
    return-1 ;
  }
  public static void main(String[] args){
    System.out.print("\n"+multiply(5,-11));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation multiply( x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (y = 0) then     return 0 else skip ; 
     if (y > 0) then     return (x + multiply(x, y - 1)) else skip ; 
     if (y < 0) then     return -multiply(x, -y) else skip ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("\n" + multiply(5, -11)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int sz=(int)1e3 ;
  static HashSet<Integer>fib=new HashSet<Integer>();
  static void fibonacci(){
    int prev=0,curr=1,len=2 ;
    fib.add(prev);
    fib.add(curr);
    while(len<=sz){
      int temp=curr+prev ;
      fib.add(temp);
      prev=curr ;
      curr=temp ;
      len++;
    }
  }
  static void printArray(int arr[],int len){
    for(int i=0 ; i<len ; i++){
      System.out.print(arr[i]+" ");
    }
  }
  static void removeFibonacci(int arr[],int len){
    fibonacci();
    for(int i=0 ; i<len ; i++){
      if(fib.contains(arr[i])){
        for(int j=i ; j<len-1 ; j++){
          arr[j]=arr[j+1];
        }
        i--;
        len--;
      }
    }
    printArray(arr,len);
  }
  public static void main(String[] args){
    int arr[]={
      4,6,5,3,8,7,10,11,14,15 };
      int len=arr.length ;
      removeFibonacci(arr,len);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute sz : int := 1e3->oclAsType(int);
  static   attribute fib : Set(int) := Set{};
  static   operation fibonacci() : void
  pre: true
  post: true
  activity: (     var prev : int ; prev := 0 ;
    var curr : int ; curr := 1 ;
    var len : int ; len := 2 ;
     fib := fib->including(prev) ; 
     fib := fib->including(curr) ; 
     while (len <= sz) do (     var temp : int ; temp := curr + prev ;
     fib := fib->including(temp) ; 
    prev := curr ; 
    curr := temp ; 
    len := len + 1 ; 
 ) );
  static   operation printArray( arr : Sequence(int), len : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < len do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
  static   operation removeFibonacci( arr : Sequence(int), len : int) : void
  pre: true
  post: true
  activity: (     execute fibonacci() ; 
         var i : int ; i := 0 ; while i < len do ( (     if (fib->includes(arr[i+1])) then (         var j : int ; j := i ; while j < len - 1 do ( (     arr[j+1] := arr[j + 1+1] )  ;     j := j + 1 ) ; 
     i := i - 1 ; 
     len := len - 1 ) else skip )  ;     i := i + 1 ) ; 
     execute printArray(arr, len) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,6,5,3,8,7,10,11,14,15} ;
     var len : int ; len := arr->size() ;
     execute removeFibonacci(arr, len) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minAbsDiff(int n){
    int left=1<<((int)Math.floor(Math.log(n)/Math.log(2)));
    int right=left*2 ;
    return Math.min((n-left),(right-n));
  }
  public static void main(String[] args){
    int n=15 ;
    System.out.println(minAbsDiff(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minAbsDiff( n : int) : int
  pre: true
  post: true
  activity: (     var left : int ; left := (1*(2->pow((((n)->log() / (2)->log())->floor()->oclAsType(int)))))->oclAsType(long) ;
     var right : int ; right := left * 2 ;
     return Set{(n - left), (right - n)}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     OclFile["System.out"].println(minAbsDiff(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static void bitonicGenerator(int arr[],int n){
    int i=1 ;
    int j=n-1 ;
    if(j % 2!=0)j--;
    while(i<j){
      arr=swap(arr,i,j);
      i+=2 ;
      j-=2 ;
    }
    Arrays.sort(arr,0,(n+1)/2);
    Arrays.sort(arr,(n+1)/2,n);
    int low=(n+1)/2,high=n-1 ;
    while(low<high){
      Integer temp=arr[low];
      arr[low]=arr[high];
      arr[high]=temp ;
      low++;
      high--;
    }
  }
  static int[] swap(int[] arr,int i,int j){
    int temp=arr[i];
    arr[i]=arr[j];
    arr[j]=temp ;
    return arr ;
  }
  public static void main(String[] args){
    int arr[]={
      1,5,8,9,6,7,3,4,2,0 };
      int n=arr.length ;
      bitonicGenerator(arr,n);
      for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation bitonicGenerator( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 1 ;
     var j : int ; j := n - 1 ;
    if (j mod 2 /= 0) then     j := j - 1 ; else skip ; 
    while (i < j) do (     arr := swap(arr, i, j) ; 
     i := i+(2) ; 
     j := j-(2) ) ; 
    arr := arr.subrange(1,0)^(arr.subrange(0+1,(n + 1) / 2)->sort())^arr.subrange((n + 1) / 2+1,arr.size) ; 
    arr := arr.subrange(1,(n + 1) / 2)^(arr.subrange((n + 1) / 2+1,n)->sort())^arr.subrange(n+1,arr.size) ; 
    var low : int ; low := (n + 1) / 2 ;
    var high : int ; high := n - 1 ;
    while (low < high) do (     var temp : int ; temp := arr[low+1] ;
     arr[low+1] := arr[high+1] ; 
    arr[high+1] := temp ; 
    low := low + 1 ; 
    high := high - 1 ; 
 ) ; 
 );
  static   operation swap( arr : Sequence(int), i : int, j : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := arr[j+1] ; 
     arr[j+1] := temp ; 
     return arr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,8,9,6,7,3,4,2,0} ;
     var n : int ; n := arr->size() ;
     execute bitonicGenerator(arr, n) ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int n=5 ;
  static void printSumSimple(int mat[][],int k){
    if(k>n)return ;
    for(int i=0 ; i<n-k+1 ; i++){
      for(int j=0 ; j<n-k+1 ; j++){
        int sum=0 ;
        for(int p=i ; p<k+i ; p++)for(int q=j ; q<k+j ; q++)sum+=mat[p][q];
        System.out.print(sum+" ");
      }
      System.out.println();
    }
  }
  public static void main(String arg[]){
    int mat[][]={
      {
        1,1,1,1,1 },{
          2,2,2,2,2 },{
            3,3,3,3,3 },{
              4,4,4,4,4 },{
                5,5,5,5,5 }
              };
              int k=3 ;
              printSumSimple(mat,k);
            }
          }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute n : int := 5;
  static   operation printSumSimple( mat : Sequence(Sequence(int)), k : int) : void
  pre: true
  post: true
  activity: (     if (k > n) then     return else skip ; 
         var i : int ; i := 0 ; while i < n - k + 1 do ( (         var j : int ; j := 0 ; while j < n - k + 1 do ( (     var sum : int ; sum := 0 ;
         var p : int ; p := i ; while p < k + i do (         var q : int ; q := j ; while q < k + j do (     sum := sum+(mat[p+1][q+1]) ;  ;     q := q + 1 ) ;  ;     p := p + 1 ) ; 
     OclFile["System.out"].print(sum + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,1,1,1,1},Sequence{2,2,2,2,2},Sequence{3,3,3,3,3},Sequence{4,4,4,4,4},Sequence{5,5,5,5,5}} ;
     var k : int ; k := 3 ;
     execute printSumSimple(mat, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.BigDecimal ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    System.out.println(a+b-1);
    int i=1 ;
    while(i<=b){
      System.out.println("1 "+i);
      i++;
    }
    i=2 ;
    while(i<=a){
      System.out.println(i+" 1");
      i++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(a + b - 1) ; 
    var i : int ; i := 1 ;
    while (i <= b) do (     OclFile["System.out"].println("1 " + i) ; 
     i := i + 1 ) ; 
    i := 2 ; 
    while (i <= a) do (     OclFile["System.out"].println(i + " 1") ; 
     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  @ SuppressWarnings("resource")public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),m=in.nextInt();
    System.out.println(n+m-1);
    for(int i=0 ; i<m ; i++)System.out.println("1 "+(i+1));
    for(int i=1 ; i<n ; i++)System.out.println((i+1)+" "+m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    OclFile["System.out"].println(n + m - 1) ; 
        var i : int ; i := 0 ; while i < m do (     OclFile["System.out"].println("1 " + (i + 1)) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do (     OclFile["System.out"].println((i + 1) + " " + m) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
import java.io.*;
public class CielDancing {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    int n=sc.nextInt();
    int m=sc.nextInt();
    boolean b[]=new boolean[n];
    boolean g[]=new boolean[m];
    int i=0,j=0 ;
    int count=0 ;
    while(i<n || j<m){
      if((i<n && b[i]==false)||(j<m && g[j]==false)){
        sb.append((i==n ? i :(i+1))+" "+(j+1)+"\n");
        count++;
        if(i<n)b[i]=true ;
        if(j<m)g[j]=true ;
      }
      else {
        if(i<n && b[i]==true)i++;
        else j++;
      }
    }
    System.out.println(count);
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class CielDancing {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var b : Sequence(boolean) ; b := Integer.subrange(1,n)->collect(false) ;
    var g : Sequence(boolean) ; g := Integer.subrange(1,m)->collect(false) ;
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    var count : int ; count := 0 ;
    while (i < n or j < m) do (     if ((i < n & b[i+1] = false) or (j < m & g[j+1] = false)) then (     sb := sb + StringLib.newString((if i = n then i else (i + 1) endif) + " " + (j + 1) + "\n") ; 
     count := count + 1 ; 
     if (i < n) then     b[i+1] := true ; else skip ; 
     if (j < m) then     g[j+1] := true ; else skip ) else (     if (i < n & b[i+1] = true) then     i := i + 1 ; else     j := j + 1 ; ) ) ; 
    OclFile["System.out"].println(count) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    int[] data=new int[10];
    final String BR=System.getProperty("line.separator");
    int first=0,second=0,third=0 ;
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    for(int i=0 ; i<10 ; i++){
      data[i]=Integer.parseInt(in.readLine());
    }
    for(int datum : data){
      int temp1=0,temp2=0 ;
      for(int j=1 ; j<=3 ; j++){
        if(first<datum){
          temp1=first ;
          temp2=second ;
          first=datum ;
          second=temp1 ;
          third=temp2 ;
          break ;
        }
        if(second<datum){
          temp2=second ;
          second=datum ;
          third=temp2 ;
          break ;
        }
        if(third<datum){
          third=datum ;
        }
      }
    }
    System.out.println(first+BR+second+BR+third);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var data : Sequence(int) ; data := Integer.subrange(1,10)->collect(0) ;
     var BR : String ; BR := OclProcess.getEnvironmentProperty("line.separator") ;
    var first : int ; first := 0 ;
    var second : int ; second := 0 ;
    var third : int ; third := 0 ;
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
        var i : int ; i := 0 ; while i < 10 do ( (     data[i+1] := (in.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    for (datum : data) do ( (     var temp1 : int ; temp1 := 0 ;
    var temp2 : int ; temp2 := 0 ;
         var j : int ; j := 1 ; while j <= 3 do ( (     if (first < datum) then (     temp1 := first ; 
     temp2 := second ; 
    first := datum ; 
    second := temp1 ; 
    third := temp2 ; 
    break 
 ) else skip ; 
     if (second < datum) then (     temp2 := second ; 
     second := datum ; 
     third := temp2 ; 
     break ) else skip ; 
     if (third < datum) then (     third := datum ) else skip )  ;     j := j + 1 ) )  ) ; 
    OclFile["System.out"].println(first + BR + second + BR + third) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int a ;
    int i ;
    char[] ch ;
    int x ;
    String[] c={
      "0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F",};
      String s="" ;
      if(n==0){
        System.out.println(1);
      }
      else {
        while(n!=0){
          a=n % 16 ;
          s=c[a]+s ;
          n=n/16 ;
        }
        ch=s.toCharArray();
        x=0 ;
        for(i=0 ; i<s.length(); i++){
          if(ch[i]=='0' || ch[i]=='4' || ch[i]=='6' || ch[i]=='9' || ch[i]=='A' || ch[i]=='D'){
            x++;
          }
          else if(ch[i]=='8' || ch[i]=='B'){
            x+=2 ;
          }
        }
        System.out.println(x);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var a : int ;
    var i : int ;
    var ch : Sequence(String) ;
    var x : int ;
    var c : Sequence(String) ; c := Sequence{"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F",} ;
    var s : String ; s := "" ;
    if (n = 0) then (     OclFile["System.out"].println(1) ) else (     while (n /= 0) do (     a := n mod 16 ; 
     s := c[a+1] + s ; 
     n := n / 16 ) ; 
     ch := s->characters() ; 
    x := 0 ; 
        i := 0 ; while i < s->size() do ( (     if (ch[i+1] = '0' or ch[i+1] = '4' or ch[i+1] = '6' or ch[i+1] = '9' or ch[i+1] = 'A' or ch[i+1] = 'D') then (     x := x + 1 ) else     if (ch[i+1] = '8' or ch[i+1] = 'B') then (     x := x+(2) ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(x) ; 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int a ;
    int i ;
    char[] ch ;
    int x ;
    String[] c={
      "0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F",};
      String s="" ;
      if(n==0){
        System.out.println(1);
      }
      else {
        while(n!=0){
          a=n % 16 ;
          s=c[a]+s ;
          n=n/16 ;
        }
        ch=s.toCharArray();
        x=0 ;
        for(i=0 ; i<s.length(); i++){
          if(ch[i]=='0' || ch[i]=='4' || ch[i]=='6' || ch[i]=='9' || ch[i]=='A' || ch[i]=='D'){
            x++;
          }
          else if(ch[i]=='8' || ch[i]=='B'){
            x+=2 ;
          }
        }
        System.out.println(x);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var a : int ;
    var i : int ;
    var ch : Sequence(String) ;
    var x : int ;
    var c : Sequence(String) ; c := Sequence{"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F",} ;
    var s : String ; s := "" ;
    if (n = 0) then (     OclFile["System.out"].println(1) ) else (     while (n /= 0) do (     a := n mod 16 ; 
     s := c[a+1] + s ; 
     n := n / 16 ) ; 
     ch := s->characters() ; 
    x := 0 ; 
        i := 0 ; while i < s->size() do ( (     if (ch[i+1] = '0' or ch[i+1] = '4' or ch[i+1] = '6' or ch[i+1] = '9' or ch[i+1] = 'A' or ch[i+1] = 'D') then (     x := x + 1 ) else     if (ch[i+1] = '8' or ch[i+1] = 'B') then (     x := x+(2) ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(x) ; 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int msbPos(long n){
    int msb_p=-1 ;
    while(n>0){
      n=n>>1 ;
      msb_p++;
    }
    return msb_p ;
  }
  static long andOperator(long x,long y){
    long res=0 ;
    while(x>0 && y>0){
      int msb_p1=msbPos(x);
      int msb_p2=msbPos(y);
      if(msb_p1!=msb_p2)break ;
      long msb_val=(1<<msb_p1);
      res=res+msb_val ;
      x=x-msb_val ;
      y=y-msb_val ;
    }
    return res ;
  }
  public static void main(String[] args){
    long x=10,y=15 ;
    System.out.print(andOperator(x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation msbPos( n : long) : int
  pre: true
  post: true
  activity: (     var msb_p : int ; msb_p := -1 ;
     while (n > 0) do (     n := (n/(2->pow(1)))->oclAsType(long) ; 
     msb_p := msb_p + 1 ) ; 
     return msb_p );
  static   operation andOperator( x : long, y : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 0 ;
     while (x > 0 & y > 0) do (     var msb_p1 : int ; msb_p1 := msbPos(x) ;
     var msb_p2 : int ; msb_p2 := msbPos(y) ;
    if (msb_p1 /= msb_p2) then     break else skip ; 
    var msb_val : long ; msb_val := ((1*(2->pow(msb_p1)))->oclAsType(long)) ;
    res := res + msb_val ; 
    x := x - msb_val ; 
    y := y - msb_val ; 
 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : long ; x := 10 ;
    var y : long ; y := 15 ;
     OclFile["System.out"].print(andOperator(x, y)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int a ;
    int i ;
    char[] ch ;
    int x ;
    String[] c={
      "0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F",};
      String s="" ;
      if(n==0){
        System.out.println(1);
      }
      else {
        while(n!=0){
          a=n % 16 ;
          s=c[a]+s ;
          n=n/16 ;
        }
        ch=s.toCharArray();
        x=0 ;
        for(i=0 ; i<s.length(); i++){
          if(ch[i]=='0' || ch[i]=='4' || ch[i]=='6' || ch[i]=='9' || ch[i]=='A' || ch[i]=='D'){
            x++;
          }
          else if(ch[i]=='8' || ch[i]=='B'){
            x+=2 ;
          }
        }
        System.out.println(x);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var a : int ;
    var i : int ;
    var ch : Sequence(String) ;
    var x : int ;
    var c : Sequence(String) ; c := Sequence{"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F",} ;
    var s : String ; s := "" ;
    if (n = 0) then (     OclFile["System.out"].println(1) ) else (     while (n /= 0) do (     a := n mod 16 ; 
     s := c[a+1] + s ; 
     n := n / 16 ) ; 
     ch := s->characters() ; 
    x := 0 ; 
        i := 0 ; while i < s->size() do ( (     if (ch[i+1] = '0' or ch[i+1] = '4' or ch[i+1] = '6' or ch[i+1] = '9' or ch[i+1] = 'A' or ch[i+1] = 'D') then (     x := x + 1 ) else     if (ch[i+1] = '8' or ch[i+1] = 'B') then (     x := x+(2) ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(x) ; 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int numOfWhiteHats(int arr[],int n){
    int freq[]=new int[n+1];
    Arrays.fill(freq,0);
    for(int i=0 ; i<n ; i++){
      if(arr[i]>=n)return-1 ;
      freq[arr[i] ]++;
    }
    int diffFreq=0 ;
    for(int i=n-1 ; i>=0 ; i--)if(freq[i]>0)diffFreq++;
    if(diffFreq==1 && freq[n-1]==n)return n ;
    if(diffFreq==1 && freq[0]==n)return 0 ;
    if(diffFreq!=2)return-1 ;
    int k ;
    for(k=n-1 ; k>=1 ; k--)if(freq[k]>0)break ;
    if(freq[k-1]==k && freq[k]+k==n)return freq[k-1];
    else return-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      2,2,2,3,3 };
      int n=arr.length ;
      System.out.print(numOfWhiteHats(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation numOfWhiteHats( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,n + 1)->collect(0) ;
     freq := freq->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] >= n) then     return -1 else skip ; 
     freq[arr[i+1]+1] := freq[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var diffFreq : int ; diffFreq := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do (     if (freq[i+1] > 0) then     diffFreq := diffFreq + 1 ; else skip ;  ;     i := i - 1 ) ; 
    if (diffFreq = 1 & freq[n - 1+1] = n) then     return n else skip ; 
    if (diffFreq = 1 & freq[0+1] = n) then     return 0 else skip ; 
    if (diffFreq /= 2) then     return -1 else skip ; 
    var k : int ;
        k := n - 1 ; while k >= 1 do (     if (freq[k+1] > 0) then     break else skip ;  ;     k := k - 1 ) ; 
    if (freq[k - 1+1] = k & freq[k+1] + k = n) then     return freq[k - 1+1] else     return -1 ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,2,2,3,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(numOfWhiteHats(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean canBeBalanced(String s,int n){
    int count=0,count_1=0 ;
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='(')count++;
      else count--;
      count_1=Math.min(count_1,count);
    }
    if(count_1>=-1 && count==0)return true ;
    return false ;
  }
  public static void main(String[] args){
    String s="())()(" ;
    int n=s.length();
    if(canBeBalanced(s,n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation canBeBalanced( s : String, n : int) : boolean
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
    var count    var count    var count :  ; count := 0 :  ; count    var count :  ; count := 0 := 0 : int ; count    var count    var count :  ; count := 0 :  ; count    var count :  ; count := 0 := 0 := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = '(') then     count := count + 1 else     count := count - 1 ; ;  
     countcount    countcount    if (s->at(i+1) = '(') then     count := count + 1 else     count := count - 1 ; ;  
 := Set{countSet{countcount    if (s->at(i+1) = '(') then     count := count + 1 else     count := count - 1 ; ;  
, count}->min(), count}->min() ; := Set{countSet{countcount    countcount    if (s->at(i+1) = '(') then     count := count + 1 else     count := count - 1 ; ;  
 := Set{countSet{countcount    if (s->at(i+1) = '(') then     count := count + 1 else     count := count - 1 ; ;  
, count}->min(), count}->min() ;, count}->min(), count}->min() )  ;     i := i + 1 ) ; 
     if (count_1 >= -1 & count = 0) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "())()(" ;
     var n : int ; n := s->size() ;
     if (canBeBalanced(s, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    int arr[][]=new int[(int)(2*(1e5)+1)][31];
    int ans=Integer.bitCount((int)1e9);
    int x=1 ;
    int presum[]=new int[(int)(2*1e5)+1];
    for(int i=1 ; i<arr.length ; i++){
      for(int j=0 ; j<arr[i] .length ; j++){
        if((i & 1<<j)==0)arr[i][j]=1 ;
        else arr[i][j]=0 ;
        arr[i][j]+=arr[i-1][j];
      }
    }
    while(t-->0){
      StringTokenizer st=new StringTokenizer(br.readLine());
      int l=Integer.parseInt(st.nextToken());
      int r=Integer.parseInt(st.nextToken());
      int min=Integer.MAX_VALUE ;
      for(int i=0 ; i<31 ; i++){
        min=Math.min(min,arr[r][i]-arr[l-1][i]);
      }
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,(2 * (1e5) + 1)->oclAsType(int))->collect(Integer.subrange(1,31)->collect(0)) ;
    var ans : int ; ans := bitCount(1e9->oclAsType(int)) ;
    var x : int ; x := 1 ;
    var presum : Sequence(int) ; presum := Integer.subrange(1,(2 * 1e5)->oclAsType(int) + 1)->collect(0) ;
        var i : int ; i := 1 ; while i < arr->size() do ( (         var j : int ; j := 0 ; while j < arr[i+1]->size() do ( (     if ((MathLib.bitwiseAnd(i,(1*(2->pow(j)))->oclAsType(long))) = 0) then     arr[i+1][j+1] := 1 else     arr[i+1][j+1] := 0 ; ;  
     arr[i+1][j+1] := arr[i+1][j+1]+(arr[i - 1+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        while (t > 0) do (        t := t - 1 ;     skip ; (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var l : int ; l := (st.next())->toInteger() ;
    var r : int ; r := (st.next())->toInteger() ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < 31 do ( (     min := Set{min, arr[r+1][i+1] - arr[l - 1+1][i+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String minInt(String str){
    String s="" ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)>='5'){
        s+=(char)(('9'-str.charAt(i))+'0');
      }
      else {
        s+=str.charAt(i);
      }
    }
    if(str.charAt(0)=='0')s+='9' ;
    return s ;
  }
  public static void main(String[] args){
    String str="589" ;
    System.out.println(minInt(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minInt( str : String) : String
  pre: true
  post: true
  activity: (     var s : String ; s := "" ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) >= '5') then (     s := s+(((('9')->char2byte() - str->at(i+1)) + '0')->oclAsType(String)) ) else (     s := s+(str->at(i+1)) ) )  ;     i := i + 1 ) ; 
     if (str->at(0+1) = '0') then     s := s+('9') ; else skip ; 
     return s );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "589" ;
     OclFile["System.out"].println(minInt(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class A {
  private String solve()throws IOException {
    int n=nextInt();
    long[] x=new long[n];
    long[] y=new long[n];
    for(int i=0 ; i<n ; i++){
      x[i]=nextInt();
    }
    for(int i=0 ; i<n ; i++){
      y[i]=nextInt();
    }
    Arrays.sort(x);
    Arrays.sort(y);
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      ans+=x[i]*y[n-1-i];
    }
    return ""+ans ;
  }
  private BufferedReader reader ;
  private StringTokenizer tt=new StringTokenizer("");
  private String nextToken()throws IOException {
    while(! tt.hasMoreTokens()){
      tt=new StringTokenizer(reader.readLine());
    }
    return tt.nextToken();
  }
  private int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  private void run()throws IOException {
    reader=new BufferedReader(new FileReader("A-large.in"));
    PrintWriter writer=new PrintWriter(new File("A-large.out"));
    try {
      int n=nextInt();
      for(int i=0 ; i<n ; i++){
        writer.print("Case #"+(i+1)+": ");
        writer.print(solve());
        writer.println();
      }
    }
    finally {
      reader.close();
      writer.close();
    }
  }
  public static void main(String[] args){
    try {
      new A().run();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   operation solve() : String
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var x : Sequence(long) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(long) ; y := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := nextInt() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     y[i+1] := nextInt() )  ;     i := i + 1 ) ; 
    x := x->sort() ; 
    y := y->sort() ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans+(x[i+1] * y[n - 1 - i+1]) )  ;     i := i + 1 ) ; 
    return "" + ans 
 );
   attribute reader : OclFile;
   attribute tt : OclIterator := OclIterator.newOclIterator_String("");
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (not(tt.hasNext())) do (     tt := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tt.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation run() : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("A-large.in"))) ; 
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile("A-large.out")) ;
     try (     var n : int ; n := nextInt() ;
         var i : int ; i := 0 ; while i < n do ( (     skip ; 
     skip ; 
     skip )  ;     i := i + 1 ) )   finally (     skip ; 
     skip )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     A.newA().run() )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
public class P1 {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new FileReader("p1.in"));
    String line="" ;
    int t=Integer.parseInt(br.readLine());
    FileWriter out=new FileWriter("p1.out");
    for(int i=0 ; i<t ; i++){
      int n=Integer.parseInt(br.readLine());
      String v1=br.readLine();
      String v2=br.readLine();
      String[] vv1=v1.split("\\s+");
      String[] vv2=v2.split("\\s+");
      List<Long>iv1=s2l(vv1);
      List<Long>iv2=s2l(vv2);
      Collections.sort(iv1);
      Collections.sort(iv2);
      if(iv1.size()!=iv2.size())System.out.println("Oops!");
      long res=0 ;
      for(int j=0 ; j<iv1.size(); j++){
        System.out.println(iv1.get(j)+"*"+iv2.get(iv1.size()-1-j));
        res+=iv1.get(j)*iv2.get(iv1.size()-1-j);
      }
      out.write("Case #"+(i+1)+": "+res+"\n");
      System.out.println(res);
    }
    br.close();
    out.close();
  }
  private static List<Long>s2l(String[] vv1){
    List<Long>ret=new ArrayList<Long>(vv1.length);
    for(int i=0 ; i<vv1.length ; i++)ret.add(Long.parseLong(vv1[i]));
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class P1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("p1.in"))) ;
     var line : String ; line := "" ;
    var t : int ; t := (br.readLine())->toInteger() ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("p1.out")) ;
        var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := (br.readLine())->toInteger() ;
     var v1 : String ; v1 := br.readLine() ;
    var v2 : String ; v2 := br.readLine() ;
    var vv1 : Sequence(String) ; vv1 := v1->split("\\s+") ;
    var vv2 : Sequence(String) ; vv2 := v2->split("\\s+") ;
    var iv1 : Sequence(long) ; iv1 := s2l(vv1) ;
    var iv2 : Sequence(long) ; iv2 := s2l(vv2) ;
    iv1 := iv1->sort() ; 
    iv2 := iv2->sort() ; 
    if (iv1->size() /= iv2->size()) then     OclFile["System.out"].println("Oops!") ; else skip ; 
    var res : long ; res := 0 ;
        var j : int ; j := 0 ; while j < iv1->size() do ( (     OclFile["System.out"].println(iv1->at(j+1) + "*" + iv2->at(iv1->size() - 1 - j+1)) ; 
     res := res+(iv1->at(j+1) * iv2->at(iv1->size() - 1 - j+1)) )  ;     j := j + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(res) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation s2l( vv1 : Sequence(String)) : Sequence(long)
  pre: true
  post: true
  activity: (     var ret : Sequence(long) ; ret := Sequence{}->union(vv1->size()) ;
         var i : int ; i := 0 ; while i < vv1->size() do (     ret := ret->including((vv1[i+1])->toLong()) ;  ;     i := i + 1 ) ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
import java.io.*;
class Main {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      int[] mt=new int[10];
      for(int i=0 ; i<10 ; i++){
        mt[i]=Integer.parseInt(br.readLine());
      }
      Arrays.stream(mt).boxed().sorted(Comparator.reverseOrder()).limit(3).forEach(System.out :: println);
    }
    catch(IOException e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var mt : Sequence(int) ; mt := Integer.subrange(1,10)->collect(0) ;
         var i : int ; i := 0 ; while i < 10 do ( (     mt[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
     for _forEach : stream(mt)->sort().subrange(1,3) do
    (    skip ;) )   catch (e : IOException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class SolutionA implements Runnable {
  public static void main(String[] args){
    new Thread(new SolutionA()).run();
  }
  public void run(){
    try {
      Locale.setDefault(Locale.US);
      br=new BufferedReader(new FileReader(FILENAME+".in"));
      out=new PrintWriter(FILENAME+".out");
      solve();
      out.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  BufferedReader br ;
  PrintWriter out ;
  StringTokenizer st ;
  boolean eof ;
  String nextToken(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
        eof=true ;
        return "0" ;
      }
    }
    return st.nextToken();
  }
  int nextInt(){
    return Integer.parseInt(nextToken());
  }
  long nextLong(){
    return Long.parseLong(nextToken());
  }
  double nextDouble(){
    return Double.parseDouble(nextToken());
  }
  private static final String FILENAME="A-large" ;
  public void solve()throws IOException {
    int testsn=nextInt();
    for(int test=0 ; test<testsn ; test++){
      out.print("Case #"+(test+1)+": ");
      int n=nextInt();
      long[] a=new long[n];
      long[] b=new long[n];
      for(int i=0 ; i<n ; i++){
        a[i]=nextLong();
      }
      for(int i=0 ; i<n ; i++){
        b[i]=nextLong();
      }
      Arrays.sort(a);
      Arrays.sort(b);
      long ans=0 ;
      for(int i=0 ; i<n ; i++){
        ans+=a[i]*b[n-1-i];
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SolutionA implements Runnable {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(SolutionA.newSolutionA()).run() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     Locale.setDefault(Locale.US) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(FILENAME + ".in")) ; 
    out := OclFile.newOclFile_Write(FILENAME + ".out") ; 
    execute solve() ; 
    out.close() ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
   attribute br : OclFile;
   attribute out : OclFile;
   attribute st : OclIterator;
   attribute eof : boolean;
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     eof := true ; 
     return "0" )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
  static    attribute FILENAME : String := "A-large";
   operation solve() : void
  pre: true
  post: true
  activity: (     var testsn : int ; testsn := nextInt() ;
         var test : int ; test := 0 ; while test < testsn do ( (     skip ; 
     var n : int ; n := nextInt() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := nextLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := nextLong() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans+(a[i+1] * b[n - 1 - i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     test := test + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MinimumProduct {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int numCases=in.nextInt();
    for(int i=0 ; i<numCases ; i++)doCase(i+1,in);
  }
  private static void doCase(int caseNum,Scanner in){
    int dims=in.nextInt();
    List<Integer>v1=new ArrayList<Integer>(dims);
    for(int i=0 ; i<dims ; i++)v1.add(in.nextInt());
    Collections.sort(v1);
    List<Integer>v2=new ArrayList<Integer>(dims);
    for(int i=0 ; i<dims ; i++)v2.add(in.nextInt());
    Collections.sort(v2,new Comparator<Integer>(){
      @ Override public int compare(Integer o1,Integer o2){
        return-o1.compareTo(o2);
      }
    }
);
    long prod=0 ;
    for(int i=0 ; i<dims ; i++)prod+=v1.get(i)*(long)v2.get(i);
    System.out.println("Case #"+caseNum+": "+prod);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MinimumProduct {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numCases : int ; numCases := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < numCases do (     execute doCase(i + 1, in) ;  ;     i := i + 1 ) );
  static   operation doCase( caseNum : int, in : OclFile) : void
  pre: true
  post: true
  activity: (     var dims : int ; dims := in.getCurrent()->toInteger() ;
     var v1 : Sequence(int) ; v1 := Sequence{} ;
        var i : int ; i := 0 ; while i < dims do (     v1 := v1->including(in.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    v1 := v1->sort() ; 
    var v2 : Sequence(int) ; v2 := Sequence{} ;
        var i : int ; i := 0 ; while i < dims do (     v2 := v2->including(in.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    v2, OclComparator<int>.newOclComparator() := v2, OclComparator<int>.newOclComparator()->sort() ; 
    var prod : long ; prod := 0 ;
        var i : int ; i := 0 ; while i < dims do (     prod := prod+(v1->at(i+1) * v2->at(i+1)->oclAsType(long)) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Case #" + caseNum + ": " + prod) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Solution implements Runnable {
  private static final String INPUT_FILE_NAME="a.big.in.txt" ;
  private static final String OUTPUT_FILE_NAME="a.big.out.txt" ;
  private BufferedReader rd ;
  private PrintWriter wr ;
  public static void main(String[] args){
    new Thread(new Solution()).start();
  }
  public void run(){
    try {
      solve();
    }
    catch(IOException e){
      throw new RuntimeException(e);
    }
  }
  void solve()throws IOException {
    rd=new BufferedReader(new FileReader(Solution.INPUT_FILE_NAME));
    wr=new PrintWriter(Solution.OUTPUT_FILE_NAME);
    String line=rd.readLine();
    StringTokenizer st=new StringTokenizer(line);
    int nn=Integer.parseInt(st.nextToken());
    for(int ii=0 ; ii<nn ; ++ii){
      subSolve(ii);
    }
    rd.close();
    wr.close();
  }
  private void subSolve(int ii)throws IOException {
    String line=rd.readLine();
    StringTokenizer st=new StringTokenizer(line);
    int n=Integer.parseInt(st.nextToken());
    long[] a=new long[n];
    long[] b=new long[n];
    line=rd.readLine();
    st=new StringTokenizer(line);
    for(int i=0 ; i<n ; ++i){
      a[i]=Long.parseLong(st.nextToken());
    }
    line=rd.readLine();
    st=new StringTokenizer(line);
    for(int i=0 ; i<n ; ++i){
      b[i]=Long.parseLong(st.nextToken());
    }
    Arrays.sort(a);
    Arrays.sort(b);
    long result=0 ;
    for(int i=0 ; i<n ; ++i){
      result+=(a[i]*b[n-i-1]);
    }
    wr.println(String.format("Case #%d: %d",ii+1,result));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution implements Runnable {
  static    attribute INPUT_FILE_NAME : String := "a.big.in.txt";
  static    attribute OUTPUT_FILE_NAME : String := "a.big.out.txt";
   attribute rd : OclFile;
   attribute wr : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(Solution.newSolution()).start() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     execute solve() )   catch (e : IOException) do (     error ProgramException(e) )
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     rd := OclFile.newOclFile_Read(OclFile.newOclFile_Read(Solution.INPUT_FILE_NAME)) ; 
     wr := OclFile.newOclFile_Write(Solution.OUTPUT_FILE_NAME) ; 
    var line : String ; line := rd.readLine() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(line) ;
    var nn : int ; nn := (st.next())->toInteger() ;
        var ii : int ; ii := 0 ; while ii < nn do ( (     execute subSolve(ii) )  ;     ii := ii + 1 ) ; 
    skip ; 
    skip ; 
 );
   operation subSolve( ii : int) : void
  pre: true
  post: true
  activity: (     var line : String ; line := rd.readLine() ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(line) ;
    var n : int ; n := (st.next())->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
    line := rd.readLine() ; 
    st := OclIterator.newOclIterator_String(line) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (st.next())->toLong() )  ;     i := i + 1 ) ; 
    line := rd.readLine() ; 
    st := OclIterator.newOclIterator_String(line) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := (st.next())->toLong() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    var result : long ; result := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     result := result+((a[i+1] * b[n - i - 1+1])) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public int lengthOfLastWord(final String a){
    boolean char_flag=false ;
    int len=0 ;
    for(int i=a.length()-1 ; i>=0 ; i--){
      if(Character.isLetter(a.charAt(i))){
        char_flag=true ;
        len++;
      }
      else {
        if(char_flag==true)return len ;
      }
    }
    return len ;
  }
  public static void main(String[] args){
    String input="Geeks For Geeks  " ;
    GFG gfg=new GFG();
    System.out.println("The length of last word is "+gfg.lengthOfLastWord(input));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
   operation lengthOfLastWord( a : String) : int
  pre: true
  post: true
  activity: (     var char_flag : boolean ; char_flag := false ;
     var len : int ; len := 0 ;
         var i : int ; i := a->size() - 1 ; while i >= 0 do ( (     if ((a->at(i+1) + "")->isMatch("[a-zA-Z]")) then (     char_flag := true ; 
     len := len + 1 ) else (     if (char_flag = true) then     return len else skip ) )  ;     i := i - 1 ) ; 
     return len );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : String ; input := "Geeks For Geeks  " ;
     var gfg : GFG ; gfg := GFG.newGFG() ;
     OclFile["System.out"].println("The length of last word is " + gfg.lengthOfLastWord(input)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAX=100001 ;
  static int prefix[]=new int[MAX];
  static void sieve_modified(){
    for(int i=1 ; i<MAX ; i+=2){
      for(int j=i ; j<MAX ; j+=i)prefix[j]+=i ;
    }
    for(int i=1 ; i<MAX ; i++)prefix[i]+=prefix[i-1];
  }
  static int sumOddFactors(int L,int R){
    return(prefix[R]-prefix[L-1]);
  }
  public static void main(String[] args){
    sieve_modified();
    int l=6,r=10 ;
    System.out.println(sumOddFactors(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100001;
  static   attribute prefix : int := Integer.subrange(1,MAX)->collect(0);
  static   operation sieve_modified() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < MAX do ( (         var j : int ; j := i ; while j < MAX do (     prefix[j+1] := prefix[j+1]+(i) ;  ;     j := j+(i) ) )  ;     i := i+(2) ) ; 
         var i : int ; i := 1 ; while i < MAX do (     prefix[i+1] := prefix[i+1]+(prefix[i - 1+1]) ;  ;     i := i + 1 ) );
  static   operation sumOddFactors( L : int, R : int) : int
  pre: true
  post: true
  activity: (     return (prefix[R+1] - prefix[L - 1+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute sieve_modified() ; 
     var l : int ; l := 6 ;
    var r : int ; r := 10 ;
     OclFile["System.out"].println(sumOddFactors(l, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test170 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      if(in.nextInt()% 4==0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test170 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     if (in.getCurrent()->toInteger() mod 4 = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1369A_FashionableLee {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int sides=parseInt(input.nextLine());
      if(sides % 4==0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1369A_FashionableLee {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var sides : int ; sides := parseInt(input.nextLine()) ;
     if (sides mod 4 = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class codforce {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    while(a-->0){
      int s=sc.nextInt();
      if(s % 4==0){
        System.out.println("YES");
      }
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codforce {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
         while (a > 0) do (        a := a - 1 ;     skip ; (     var s : int ; s := sc.getCurrent()->toInteger() ;
     if (s mod 4 = 0) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Fashionablee {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      if(n % 4==0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Fashionablee {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n mod 4 = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
     t := t - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class rotate {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int a=in.nextInt();
      if(a % 4==0){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class rotate {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := in.getCurrent()->toInteger() ;
     if (a mod 4 = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
import java.util.Arrays ;
import java.util.Collections ;
class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    Integer[] mountains=new Integer[10];
    for(int i=0 ; i<10 ; i++){
      mountains[i]=sc.nextInt();
    }
    Arrays.sort(mountains,Collections.reverseOrder());
    StringBuilder sb=new StringBuilder("");
    for(int i=0 ; i<3 ; i++){
      sb.append(mountains[i]);
      sb.append('\n');
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var mountains : Sequence(int) ; mountains := Integer.subrange(1,10)->collect(null) ;
        var i : int ; i := 0 ; while i < 10 do ( (     mountains[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    mountains := OclComparator.sortWith(mountains, reverseOrder()) ; 
    var sb : String ; sb := StringLib.newString("") ;
        var i : int ; i := 0 ; while i < 3 do ( (     sb := sb + StringLib.newString(mountains[i+1]) ; 
     sb := sb + StringLib.newString('
') )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    waterLily1199B();
  }
  public static void waterLily1199B(){
    Scanner scan=new Scanner(System.in);
    long h=scan.nextLong();
    long l=scan.nextLong();
    double l2=l*l ;
    double h2=h*h ;
    double twoh=2*h ;
    System.out.println((l2-h2)/(twoh));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute waterLily1199B() );
  static   operation waterLily1199B() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : long ; h := scan.getCurrent()->toLong() ;
    var l : long ; l := scan.getCurrent()->toLong() ;
    var l2 : double ; l2 := l * l ;
    var h2 : double ; h2 := h * h ;
    var twoh : double ; twoh := 2 * h ;
    OclFile["System.out"].println((l2 - h2) / (twoh)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    double H=sc.nextDouble();
    double L=sc.nextDouble();
    System.out.println((L*L-H*H)/(2*H));
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : double ; H := sc.getCurrent()->toReal() ;
    var L : double ; L := sc.getCurrent()->toReal() ;
    OclFile["System.out"].println((L * L - H * H) / (2 * H)) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class IntInput {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    double h=in.nextDouble(),l=in.nextDouble();
    System.out.println((l*l-h*h)/(2*h));
  }
}
------------------------------------------------------------
OCL File:
---------
 class IntInput {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : double ; h := in.getCurrent()->toReal() ;
    var l : double ; l := in.getCurrent()->toReal() ;
     OclFile["System.out"].println((l * l - h * h) / (2 * h)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int findDigits(int n){
    if(n<0)return 0 ;
    if(n<=1)return 1 ;
    double digits=0 ;
    for(int i=2 ; i<=n ; i++)digits+=Math.log10(i);
    return(int)(Math.floor(digits))+1 ;
  }
  public static void main(String[] args){
    System.out.println(findDigits(1));
    System.out.println(findDigits(5));
    System.out.println(findDigits(10));
    System.out.println(findDigits(120));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findDigits( n : int) : int
  pre: true
  post: true
  activity: (     if (n < 0) then     return 0 else skip ; 
     if (n <= 1) then     return 1 else skip ; 
    var digits : double ; digits := 0 ;
        var i : int ; i := 2 ; while i <= n do (     digits := digits+((i)->log10()) ;  ;     i := i + 1 ) ; 
    return ((digits)->floor())->oclAsType(int) + 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(findDigits(1)) ; 
     OclFile["System.out"].println(findDigits(5)) ; 
     OclFile["System.out"].println(findDigits(10)) ; 
     OclFile["System.out"].println(findDigits(120)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int R=sc.nextInt();
    double X=sc.nextInt();
    double Y=sc.nextInt();
    int N=sc.nextInt();
    int sum=0 ;
    for(int i=0 ; i<N ; ++i){
      int P=sc.nextInt();
      double x1=R*Math.cos(Math.PI/2-sum/100.0*Math.PI*2);
      double y1=R*Math.sin(Math.PI/2-sum/100.0*Math.PI*2);
      sum+=P ;
      double x2=R*Math.cos(Math.PI/2-sum/100.0*Math.PI*2);
      double y2=R*Math.sin(Math.PI/2-sum/100.0*Math.PI*2);
      double SO=Math.PI*R*R*P/100.0 ;
      double DS1=area(0,0,x2,y2,X,Y);
      double DS2=area(0,0,X,Y,x1,y1);
      double SN=SO+DS1+DS2 ;
      if(i!=0)System.out.print(" ");
      System.out.print((int)(100*SN/SO));
    }
    System.out.println();
  }
  static double area(double x0,double y0,double x1,double y1,double x2,double y2){
    double dx1=x1-x0 ;
    double dy1=y1-y0 ;
    double dx2=x2-x0 ;
    double dy2=y2-y0 ;
    return(-dy2*dx1+dy1*dx2)/2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var R : int ; R := sc.getCurrent()->toInteger() ;
     var X : double ; X := sc.getCurrent()->toInteger() ;
    var Y : double ; Y := sc.getCurrent()->toInteger() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var P : int ; P := sc.getCurrent()->toInteger() ;
     var x1 : double ; x1 := R * (3.141592653589793 / 2 - sum / 100.0 * 3.141592653589793 * 2)->cos() ;
    var y1 : double ; y1 := R * (3.141592653589793 / 2 - sum / 100.0 * 3.141592653589793 * 2)->sin() ;
    sum := sum+(P) ; 
    var x2 : double ; x2 := R * (3.141592653589793 / 2 - sum / 100.0 * 3.141592653589793 * 2)->cos() ;
    var y2 : double ; y2 := R * (3.141592653589793 / 2 - sum / 100.0 * 3.141592653589793 * 2)->sin() ;
    var SO : double ; SO := 3.141592653589793 * R * R * P / 100.0 ;
    var DS1 : double ; DS1 := area(0, 0, x2, y2, X, Y) ;
    var DS2 : double ; DS2 := area(0, 0, X, Y, x1, y1) ;
    var SN : double ; SN := SO + DS1 + DS2 ;
    if (i /= 0) then     OclFile["System.out"].print(" ") ; else skip ; 
    OclFile["System.out"].print((100 * SN / SO)->oclAsType(int)) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation area( x0 : double, y0 : double, x1 : double, y1 : double, x2 : double, y2 : double) : double
  pre: true
  post: true
  activity: (     var dx1 : double ; dx1 := x1 - x0 ;
     var dy1 : double ; dy1 := y1 - y0 ;
    var dx2 : double ; dx2 := x2 - x0 ;
    var dy2 : double ; dy2 := y2 - y0 ;
    return (-dy2 * dx1 + dy1 * dx2) / 2 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Queue ;
import java.util.Scanner ;
class Graph2 {
  int totalVertex ;
  Queue<Integer>toVisit ;
  int[] distance ;
  public LinkedList<LinkedList<Integer>>adjList ;
  public Graph2(){
    totalVertex=0 ;
  }
  public void loadAdjList(){
    Scanner in=new Scanner(System.in);
    totalVertex=in.nextInt();
    toVisit=new LinkedList<Integer>();
    distance=new int[totalVertex];
    adjList=new LinkedList<LinkedList<Integer>>();
    for(int i=0 ; i<totalVertex ; i++){
      LinkedList<Integer>tmp=new LinkedList<Integer>();
      int idx1=in.nextInt()-1 ;
      int degree=in.nextInt();
      for(int j=0 ; j<degree ; j++){
        int idx2=in.nextInt()-1 ;
        tmp.add(idx2);
      }
      adjList.add(tmp);
    }
    for(int i=1 ; i<totalVertex ; i++){
      distance[i]=Integer.MAX_VALUE ;
    }
    in.close();
  }
  public void BFS(int v){
    toVisit.add(v);
    while(! toVisit.isEmpty()){
      int next=toVisit.remove();
      for(int neighbor : adjList.get(next)){
        if(! toVisit.contains(neighbor)){
          if(distance[neighbor]>distance[next]+1){
            toVisit.add(neighbor);
            distance[neighbor]=distance[next]+1 ;
          }
        }
      }
    }
  }
  public void SearchGraph(){
    BFS(0);
    for(int i=0 ; i<totalVertex ; i++){
      if(distance[i]==Integer.MAX_VALUE){
        distance[i]=-1 ;
      }
      System.out.println(i+1+" "+distance[i]);
    }
  }
}
public class Main {
  public static void main(String argv[]){
    Graph2 g=new Graph2();
    g.loadAdjList();
    g.SearchGraph();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Graph2 {
   attribute totalVertex : int;
   attribute toVisit : Sequence(int);
   attribute distance : Sequence(int);
   attribute adjList : Sequence(Sequence(int));
   static operation newGraph2() : Graph2
  pre: true
  post: true
  activity:
  ( var self : Graph2 ;
    self := createGraph2();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     totalVertex := 0 );
   operation loadAdjList() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     totalVertex := in.getCurrent()->toInteger() ; 
    toVisit := Sequence{} ; 
    distance := Integer.subrange(1,totalVertex)->collect(0) ; 
    adjList := Sequence{} ; 
        var i : int ; i := 0 ; while i < totalVertex do ( (     var tmp : Sequence(int) ; tmp := Sequence{} ;
     var idx1 : int ; idx1 := in.getCurrent()->toInteger() - 1 ;
    var degree : int ; degree := in.getCurrent()->toInteger() ;
        var j : int ; j := 0 ; while j < degree do ( (     var idx2 : int ; idx2 := in.getCurrent()->toInteger() - 1 ;
     tmp := tmp->including(idx2) )  ;     j := j + 1 ) ; 
    adjList := adjList->including(tmp) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < totalVertex do ( (     distance[i+1] := 2147483647 )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation BFS( v : int) : void
  pre: true
  post: true
  activity: (     toVisit := toVisit->including(v) ; 
     while (not(toVisit->isEmpty())) do (     var next : int ; next := toVisit.remove() ;
     for (neighbor : adjList->at(next+1)) do ( (     if (not(toVisit->includes(neighbor))) then (     if (distance[neighbor+1] > distance[next+1] + 1) then (     toVisit := toVisit->including(neighbor) ; 
     distance[neighbor+1] := distance[next+1] + 1 ) else skip ) else skip )  ) ) );
   operation SearchGraph() : void
  pre: true
  post: true
  activity: (     execute BFS(0) ; 
         var i : int ; i := 0 ; while i < totalVertex do ( (     if (distance[i+1] = 2147483647) then (     distance[i+1] := -1 ) else skip ; 
     OclFile["System.out"].println(i + 1 + " " + distance[i+1]) )  ;     i := i + 1 ) );
}
class Main {
  static   operation main( argv : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : Graph2 ; g := Graph2.newGraph2() ;
     g.loadAdjList() ; 
     g.SearchGraph() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int[] check ;
  static int[][] graph ;
  static int[] dis ;
  static int n ;
  final static int MAX=100 ;
  public static void main(String[] args){
    int i,j,s,pn,num ;
    Scanner sca=new Scanner(System.in);
    n=sca.nextInt();
    check=new int[MAX+1];
    dis=new int[MAX+1];
    graph=new int[MAX+1][MAX+1];
    for(i=1 ; i<=n ; i++){
      num=sca.nextInt();
      pn=sca.nextInt();
      for(j=0 ; j<pn ; j++){
        s=sca.nextInt();
        graph[num][s]=1 ;
      }
    }
    breadthexpl(1);
  }
  public static void breadthexpl(int now){
    int i,j,hz ;
    Queue<Integer>que=new ArrayDeque<>();
    que.offer(now);
    while(que.peek()!=null){
      hz=que.poll();
      for(j=1 ; j<=n ; j++){
        if(graph[hz][j]!=0 && check[j]==0){
          check[j]=2 ;
          dis[j]=dis[hz]+1 ;
          if(dis[hz]==-1 && dis[j]!=-1)dis[hz]++;
          que.offer(j);
        }
        check[hz]=1 ;
      }
    }
    for(i=1 ; i<=n ; i++){
      if(check[i]==0)dis[i]=-1 ;
      System.out.println(i+" "+dis[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute check : Sequence(int);
  static   attribute graph : Sequence(Sequence(int));
  static   attribute dis : Sequence(int);
  static   attribute n : int;
  static   attribute MAX : int := 100;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var s : int ;
    var pn : int ;
    var num : int ;
     var sca : OclFile ; sca := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := sca.getCurrent()->toInteger() ; 
    check := Integer.subrange(1,MAX + 1)->collect(0) ; 
    dis := Integer.subrange(1,MAX + 1)->collect(0) ; 
    graph := Integer.subrange(1,MAX + 1)->collect(Integer.subrange(1,MAX + 1)->collect(0)) ; 
        i := 1 ; while i <= n do ( (     num := sca.getCurrent()->toInteger() ; 
     pn := sca.getCurrent()->toInteger() ; 
         j := 0 ; while j < pn do ( (     s := sca.getCurrent()->toInteger() ; 
     graph[num+1][s+1] := 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    execute breadthexpl(1) ; 
 );
  static   operation breadthexpl( now : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var hz : int ;
     var que : Sequence(int) ; que := ArrayDeque<OclAny>.newArrayDeque() ;
    que := que->including(now) ; 
    while (que->min() /= null) do (     hz := que->min() ;     que := que->sort()->tail() ; 
         j := 1 ; while j <= n do ( (     if (graph[hz+1][j+1] /= 0 & check[j+1] = 0) then (     check[j+1] := 2 ; 
     dis[j+1] := dis[hz+1] + 1 ; 
     if (dis[hz+1] = -1 & dis[j+1] /= -1) then     dis[hz+1] := dis[hz+1] + 1 ; else skip ; 
     que := que->including(j) ) else skip ; 
     check[hz+1] := 1 )  ;     j := j + 1 ) ) ; 
        i := 1 ; while i <= n do ( (     if (check[i+1] = 0) then     dis[i+1] := -1 ; else skip ; 
     OclFile["System.out"].println(i + " " + dis[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Iterator ;
import java.util.LinkedList ;
import java.util.Scanner ;
import java.util.Queue ;
import java.util.Arrays ;
class GraphBFS {
  private int totalVertex ;
  private LinkedList<LinkedList<Integer>>adjList ;
  public GraphBFS(){
    totalVertex=0 ;
  }
  public void loadAdjList(){
    Scanner in=new Scanner(System.in);
    totalVertex=in.nextInt();
    adjList=new LinkedList<LinkedList<Integer>>();
    for(int i=0 ; i<totalVertex ; i++){
      LinkedList<Integer>tmp=new LinkedList<Integer>();
      int idx1=in.nextInt()-1 ;
      int degree=in.nextInt();
      for(int j=0 ; j<degree ; j++){
        int idx2=in.nextInt();
        tmp.add(idx2);
      }
      adjList.add(tmp);
    }
    in.close();
  }
  public int[] BFS(int start){
    Queue<Integer>Q=new LinkedList<>();
    int[] Dist=new int[totalVertex];
    Arrays.fill(Dist,-1);
    Q.add(start);
    Dist[start-1]=0 ;
    while(Q.size()>0){
      int v=Q.remove();
      Iterator<Integer>it=adjList.get(v-1).iterator();
      while(it.hasNext()){
        int tmp=it.next();
        if(Dist[tmp-1]==-1){
          Q.add(tmp);
          Dist[tmp-1]=Dist[v-1]+1 ;
        }
      }
    }
    return Dist ;
  }
  public void printDist(int start){
    int[] Dist=BFS(start);
    for(int i=0 ; i<totalVertex ; i++){
      System.out.println((i+1)+" "+Dist[i]);
    }
  }
}
public class Main {
  public static void main(String argv[]){
    GraphBFS g=new GraphBFS();
    g.loadAdjList();
    g.printDist(1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GraphBFS {
   attribute totalVertex : int;
   attribute adjList : Sequence(Sequence(int));
   static operation newGraphBFS() : GraphBFS
  pre: true
  post: true
  activity:
  ( var self : GraphBFS ;
    self := createGraphBFS();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     totalVertex := 0 );
   operation loadAdjList() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     totalVertex := in.getCurrent()->toInteger() ; 
    adjList := Sequence{} ; 
        var i : int ; i := 0 ; while i < totalVertex do ( (     var tmp : Sequence(int) ; tmp := Sequence{} ;
     var idx1 : int ; idx1 := in.getCurrent()->toInteger() - 1 ;
    var degree : int ; degree := in.getCurrent()->toInteger() ;
        var j : int ; j := 0 ; while j < degree do ( (     var idx2 : int ; idx2 := in.getCurrent()->toInteger() ;
     tmp := tmp->including(idx2) )  ;     j := j + 1 ) ; 
    adjList := adjList->including(tmp) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation BFS( start : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var Q : Sequence(int) ; Q := Sequence{} ;
     var Dist : Sequence(int) ; Dist := Integer.subrange(1,totalVertex)->collect(0) ;
    Dist := Dist->collect(-1) ; 
    Q := Q->including(start) ; 
    Dist[start - 1+1] := 0 ; 
    while (Q->size() > 0) do (     var v : int ; v := Q.remove() ;
     var it : OclIterator ; it := adjList->at(v - 1+1)->iterator() ;
     while (it.hasNext()) do (     var tmp : int ; tmp := it.next() ;
     if (Dist[tmp - 1+1] = -1) then (     Q := Q->including(tmp) ; 
     Dist[tmp - 1+1] := Dist[v - 1+1] + 1 ) else skip ) ) ; 
    return Dist 
 );
   operation printDist( start : int) : void
  pre: true
  post: true
  activity: (     var Dist : Sequence(int) ; Dist := BFS(start) ;
         var i : int ; i := 0 ; while i < totalVertex do ( (     OclFile["System.out"].println((i + 1) + " " + Dist[i+1]) )  ;     i := i + 1 ) );
}
class Main {
  static   operation main( argv : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : GraphBFS ; g := GraphBFS.newGraphBFS() ;
     g.loadAdjList() ; 
     g.printDist(1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayDeque ;
import java.util.Arrays ;
import java.util.Deque ;
class Main {
  static int n ;
  static int[] v ;
  static int[][] graph ;
  static int time ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    n=Integer.parseInt(br.readLine());
    graph=new int[n][n];
    v=new int[n];
    Arrays.fill(v,Integer.MAX_VALUE);
    for(int i=0 ; i<n ; i++){
      String[] u_k_v=br.readLine().split(" ");
      int u=Integer.parseInt(u_k_v[0]);
      for(int k=0 ; k<Integer.parseInt(u_k_v[1]); k++){
        graph[u-1][Integer.parseInt(u_k_v[2+k])-1]=1 ;
      }
    }
    Deque<Integer>q=new ArrayDeque<>();
    q.offer(0);
    v[0]=0 ;
    while(!(q.isEmpty())){
      int node=q.poll();
      for(int j=0 ; j<n ; j++){
        if(graph[node][j]==1 && v[j]>v[node]+1){
          v[j]=v[node]+1 ;
          q.offer(j);
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      if(!(i==0)){
        System.out.println((i+1)+" "+(v[i]==Integer.MAX_VALUE ? "-1" : v[i]));
      }
      else {
        System.out.println((i+1)+" "+v[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute v : Sequence(int);
  static   attribute graph : Sequence(Sequence(int));
  static   attribute time : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     n := (br.readLine())->toInteger() ; 
    graph := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
    v := Integer.subrange(1,n)->collect(0) ; 
    v := v->collect(2147483647) ; 
        var i : int ; i := 0 ; while i < n do ( (     var u_k_v : Sequence(String) ; u_k_v := br.readLine()->split(" ") ;
     var u : int ; u := (u_k_v[0+1])->toInteger() ;
         var k : int ; k := 0 ; while k < (u_k_v[1+1])->toInteger() do ( (     graph[u - 1+1][(u_k_v[2 + k+1])->toInteger() - 1+1] := 1 )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    var q : Sequence(int) ; q := ArrayDeque<OclAny>.newArrayDeque() ;
    q := q->including(0) ; 
    v[0+1] := 0 ; 
    while (not((q->isEmpty()))) do (     var node : int ; node := q->min() ;
         var j : int ; j := 0 ; while j < n do ( (     if (graph[node+1][j+1] = 1 & v[j+1] > v[node+1] + 1) then (     v[j+1] := v[node+1] + 1 ; 
     q := q->including(j) ) else skip )  ;     j := j + 1 ) ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (not((i = 0))) then (     OclFile["System.out"].println((i + 1) + " " + (if v[i+1] = 2147483647 then "-1" else v[i+1] endif)) ) else (     OclFile["System.out"].println((i + 1) + " " + v[i+1]) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static final int N=100 ;
  static final int NOT_VISITED=-1 ;
  static int n ;
  static int[][] mat=new int[N][N];
  static Queue<Integer>q=new ArrayDeque<Integer>();
  static int[] d=new int[N];
  public static void main(String[] args){
    read();
    init();
    bfs();
    out();
  }
  static void read(){
    int u,k,v ;
    n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      u=sc.nextInt();
      k=sc.nextInt();
      for(int j=0 ; j<k ; j++){
        v=sc.nextInt();
        mat[u-1][v-1]=1 ;
      }
    }
  }
  static void init(){
    for(int i=0 ; i<n ; i++){
      d[i]=NOT_VISITED ;
    }
    d[0]=0 ;
  }
  static void bfs(){
    q.add(0);
    while(! q.isEmpty()){
      int e=q.element();
      q.remove();
      for(int i=0 ; i<n ; i++){
        if(mat[e][i]==1){
          if(d[i]==NOT_VISITED){
            d[i]=d[e]+1 ;
            q.add(i);
          }
        }
      }
    }
  }
  static void out(){
    for(int i=0 ; i<n ; i++){
      System.out.println(String.format("%d %d",i+1,d[i]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute N : int := 100;
  static    attribute NOT_VISITED : int := -1;
  static   attribute n : int;
  static   attribute mat : Sequence(Sequence(int)) := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0));
  static   attribute q : Sequence(int) := ArrayDeque<int>.newArrayDeque();
  static   attribute d : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute read() ; 
     execute init() ; 
     execute bfs() ; 
     execute out() );
  static   operation read() : void
  pre: true
  post: true
  activity: (     var u : int ;
    var k : int ;
    var v : int ;
     n := sc.getCurrent()->toInteger() ; 
         var i : int ; i := 0 ; while i < n do ( (     u := sc.getCurrent()->toInteger() ; 
     k := sc.getCurrent()->toInteger() ; 
         var j : int ; j := 0 ; while j < k do ( (     v := sc.getCurrent()->toInteger() ; 
     mat[u - 1+1][v - 1+1] := 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation init() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     d[i+1] := NOT_VISITED )  ;     i := i + 1 ) ; 
     d[0+1] := 0 );
  static   operation bfs() : void
  pre: true
  post: true
  activity: (     q := q->including(0) ; 
     while (not(q->isEmpty())) do (     var e : int ; e := q.element() ;
     q := q.remove() ; 
         var i : int ; i := 0 ; while i < n do ( (     if (mat[e+1][i+1] = 1) then (     if (d[i+1] = NOT_VISITED) then (     d[i+1] := d[e+1] + 1 ; 
     q := q->including(i) ) else skip ) else skip )  ;     i := i + 1 ) ) );
  static   operation out() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(StringLib.format("%d %d",Sequence{i + 1,d[i+1]})) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int fact(int n){
    int ans=1 ;
    for(int i=1 ; i<=n ; i++)ans=ans*i ;
    return(ans);
  }
  static int numberOfPossiblePallindrome(String str,int n){
    Map<Character,Integer>mp=new HashMap<>();
    for(int i=0 ; i<n ; i++)mp.put(str.charAt(i),mp.get(str.charAt(i))==null ? 1 : mp.get(str.charAt(i))+1);
    int k=0 ;
    int num=0 ;
    int den=1 ;
    int fi ;
    for(Map.Entry<Character,Integer>it : mp.entrySet()){
      if(it.getValue()% 2==0)fi=it.getValue()/2 ;
      else {
        fi=(it.getValue()-1)/2 ;
        k++;
      }
      num=num+fi ;
      den=den*fact(fi);
    }
    if(num!=0)num=fact(num);
    int ans=num/den ;
    if(k!=0){
      ans=ans*k ;
    }
    return(ans);
  }
  public static void main(String[] args){
    String str="ababab" ;
    int n=str.length();
    System.out.println(numberOfPossiblePallindrome(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fact( n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
         var i : int ; i := 1 ; while i <= n do (     ans := ans * i ;  ;     i := i + 1 ) ; 
     return (ans) );
  static   operation numberOfPossiblePallindrome( str : String, n : int) : int
  pre: true
  post: true
  activity: (     var mp : Map(String,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do (     mp := mp->union(Map{str->at(i+1) |-> if mp->at(str->at(i+1)) = null then 1 else mp->at(str->at(i+1)) + 1 endif}) ;  ;     i := i + 1 ) ; 
    var k : int ; k := 0 ;
    var num : int ; num := 0 ;
    var den : int ; den := 1 ;
    var fi : int ;
    for (it : mp->asSet()) do ( (     if (it.getValue() mod 2 = 0) then     fi := it.getValue() / 2 else (     fi := (it.getValue() - 1) / 2 ; 
     k := k + 1 ) ;  
     num := num + fi ; 
     den := den * fact(fi) )  ) ; 
    if (num /= 0) then     num := fact(num) ; else skip ; 
    var ans : int ; ans := num / den ;
    if (k /= 0) then (     ans := ans * k ) else skip ; 
    return (ans) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "ababab" ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].println(numberOfPossiblePallindrome(str, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Solution {
  static float largestCube(float r){
    if(r<0)return-1 ;
    float a=(2*r)/(float)Math.sqrt(3);
    return a ;
  }
  public static void main(String args[]){
    float r=5 ;
    System.out.println(largestCube(r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation largestCube( r : double) : double
  pre: true
  post: true
  activity: (     if (r < 0) then     return -1 else skip ; 
     var a : double ; a := (2 * r) / (3)->sqrt()->oclAsType(double) ;
     return a );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : double ; r := 5 ;
     OclFile["System.out"].println(largestCube(r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int numberOfPaths(int m,int n){
    int path=1 ;
    for(int i=n ; i<(m+n-1); i++){
      path*=i ;
      path/=(i-n+1);
    }
    return path ;
  }
  public static void main(String[] args){
    System.out.println(numberOfPaths(3,3));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation numberOfPaths( m : int, n : int) : int
  pre: true
  post: true
  activity: (     var path : int ; path := 1 ;
         var i : int ; i := n ; while i < (m + n - 1) do ( (     path := path*(i) ; 
     path := path/((i - n + 1)) )  ;     i := i + 1 ) ; 
     return path );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(numberOfPaths(3, 3)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
import java.util.Set ;
import static java.lang.Integer.parseInt ;
public class Main {
  static final long B=37 ;
  static final long Binv=1495681951922396077L ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    line=br.readLine();
    int n,m ;
    n=parseInt(line.substring(0,line.indexOf(' ')));
    m=parseInt(line.substring(line.indexOf(' ')+1));
    char[] s=br.readLine().toCharArray();
    int l=0,r=0 ;
    long hash=s[0];
    Set<Long>hashs=new HashSet<>();
    for(int i=0 ; i<m ; i++){
      switch(br.readLine()){
        case "L++" : hash-=s[l]*power(B,r-l);
        l++;
        break ;
        case "L--" : l--;
        hash+=s[l]*power(B,r-l);
        break ;
        case "R++" : r++;
        hash=hash*B+s[r];
        break ;
        case "R--" : hash=(hash-s[r])*Binv ;
        r--;
        break ;
      }
      hashs.add(hash);
    }
    System.out.println(hashs.size());
  }
  static long power(long m,long n){
    if(n==0)return 1 ;
    if(n % 2==0){
      return power(m*m,n/2);
    }
    else {
      return power(m*m,n/2)*m ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute B : long := 37;
  static    attribute Binv : long := 1495681951922396077L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    line := br.readLine() ; 
    var n : int ;
    var m : int ;
    n := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    m := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var s : Sequence(String) ; s := br.readLine()->characters() ;
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    var hash : long ; hash := s[0+1] ;
    var hashs : Set(long) ; hashs := Set{} ;
        var i : int ; i := 0 ; while i < m do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (br.readLine()) ; 
       if _switchval = "L++" then
     hash := hash-(s[l+1] * power(B, r - l)) ; 
    l := l + 1 ; 
    break 
   else skip ;
       if _switchval = "L--" then
     l := l - 1 ; 
    hash := hash+(s[l+1] * power(B, r - l)) ; 
    break 
   else skip ;
       if _switchval = "R++" then
     r := r + 1 ; 
    hash := hash * B + s[r+1] ; 
    break 
   else skip ;
       if _switchval = "R--" then
     hash := (hash - s[r+1]) * Binv ; 
    r := r - 1 ; 
    break 
   else skip ;
 )
     hashs := hashs->including(hash) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(hashs->size()) ; 
 );
  static   operation power( m : long, n : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     if (n mod 2 = 0) then (     return power(m * m, n / 2) ) else (     return power(m * m, n / 2) * m ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static final long B=1000000007L ;
  public static long inv(long a,long p){
    return(a==1 ? 1 :(1-p*inv(p % a,a))/a+p);
  }
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    final int n=sc.nextInt();
    final int m=sc.nextInt();
    String str=sc.next();
    char[] input=str.toCharArray();
    HashSet<Long>set=new HashSet<Long>();
    long[] pow=new long[n+1];
    pow[0]=1L ;
    for(int i=1 ; i<=n ; i++){
      pow[i]=(pow[i-1]*B);
    }
    long[] hash_p=new long[n+1];
    hash_p[0]=0 ;
    for(int i=0 ; i<n ; i++){
      hash_p[i+1]=(hash_p[i]*B+(input[i]-'a'+1));
    }
    int l=0,r=0 ;
    long hash=input[l];
    for(int i=0 ; i<m ; i++){
      String in=sc.next();
      if("L++".equals(in)){
        l++;
      }
      else if("L--".equals(in)){
        l--;
      }
      else if("R++".equals(in)){
        r++;
      }
      else if("R--".equals(in)){
        r--;
      }
      hash=hash_p[r+1]-hash_p[l]*pow[r+1-l];
      if(! set.contains(hash)){
        set.add(hash);
      }
      else {
      }
    }
    System.out.println(set.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute B : long := 1000000007L;
  static   operation inv( a : long, p : long) : long
  pre: true
  post: true
  activity: (     return (if a = 1 then 1 else (1 - p * inv(p mod a, a)) / a + p endif) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var str : String ; str := sc.getCurrent() ;
    var input : Sequence(String) ; input := str->characters() ;
    var set : Set(long) ; set := Set{} ;
    var pow : Sequence(long) ; pow := Integer.subrange(1,n + 1)->collect(0) ;
    pow[0+1] := 1L ; 
        var i : int ; i := 1 ; while i <= n do ( (     pow[i+1] := (pow[i - 1+1] * B) )  ;     i := i + 1 ) ; 
    var hash_p : Sequence(long) ; hash_p := Integer.subrange(1,n + 1)->collect(0) ;
    hash_p[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     hash_p[i + 1+1] := (hash_p[i+1] * B + (input[i+1] - ('a')->char2byte() + 1)) )  ;     i := i + 1 ) ; 
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    var hash : long ; hash := input[l+1] ;
        var i : int ; i := 0 ; while i < m do ( (     var in : String ; in := sc.getCurrent() ;
     if ("L++" = in) then (     l := l + 1 ) else     if ("L--" = in) then (     l := l - 1 ) else     if ("R++" = in) then (     r := r + 1 ) else     if ("R--" = in) then (     r := r - 1 ) else skip ; ;  ;  ;  
     hash := hash_p[r + 1+1] - hash_p[l+1] * pow[r + 1 - l+1] ; 
     if (not(set->includes(hash))) then (     set := set->including(hash) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(set->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    boolean control=false ;
    int num ;
    while((num=Integer.valueOf(br.readLine()))!=0){
      if(control)System.out.println();
      Table[] table=new Table[num];
      for(int i=0 ; i<num ; i++){
        String[] input=br.readLine().split(" ",4);
        String country=input[0];
        int score=Integer.valueOf(input[1])*3+Integer.valueOf(input[3]);
        table[i]=new Table(country,score);
      }
      Arrays.sort(table);
      for(Table a : table){
        System.out.println(a);
      }
      control=true ;
    }
  }
}
class Table implements Comparable {
  String country ;
  int score ;
  Table(String c,int s){
    this.country=c ;
    this.score=s ;
  }
  public String toString(){
    return this.country+","+this.score ;
  }
  public int compareTo(Object object){
    Table comp=(Table)object ;
    if(this.score<comp.score)return 1 ;
    else if(this.score>comp.score)return-1 ;
    else return 0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var control : boolean ; control := false ;
     var num : int ;
         num := (br.readLine())->toInteger() ;
    while ((num) /= 0) do (    skip ; (     if (control) then     OclFile["System.out"].println() ; else skip ; 
     var table : Sequence(Table) ; table := Integer.subrange(1,num)->collect(null) ;
        var i : int ; i := 0 ; while i < num do ( (     var input : Sequence(String) ; input := br.readLine()->split(" ") ;
     var country : String ; country := input[0+1] ;
     var score : int ; score := (input[1+1])->toInteger() * 3 + (input[3+1])->toInteger() ;
     table[i+1] := Table.newTable(country, score) )  ;     i := i + 1 ) ; 
    table := table->sort() ; 
    for (a : table) do ( (     OclFile["System.out"].println(a) )  ) ; 
    control := true ; 
 ) ;     num := (br.readLine())->toInteger() ;
 ) );
}
class Table implements OclAny {
   attribute country : String;
   attribute score : int;
   static operation newTable( c : String, s : int) : Table
  pre: true
  post: true
  activity:
  ( var self : Table ;
    self := createTable();
    self.initialise(c, s);
    return self );
  operation initialise( c : String, s : int) : void
  pre: true  post: true
  activity: (     self.country := c ; 
     self.score := s );
   operation toString() : String
  pre: true
  post: true
  activity: (     return self.country + "," + self.score );
   operation compareTo( object : OclAny) : int
  pre: true
  post: true
  activity: (     var comp : Table ; comp := object->oclAsType(Table) ;
     if (self.score < comp.score) then     return 1 else     if (self.score > comp.score) then     return -1 else     return 0 ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
class GFG {
  static void partSort(int[] arr,int N,int a,int b){
    int l=Math.min(a,b);
    int r=Math.max(a,b);
    int[] temp=new int[r-l+1];
    int j=0 ;
    for(int i=l ; i<=r ; i++){
      temp[j]=arr[i];
      j++;
    }
    Arrays.sort(temp);
    j=0 ;
    for(int i=l ; i<=r ; i++){
      arr[i]=temp[j];
      j++;
    }
    for(int i=0 ; i<N ; i++){
      System.out.print(arr[i]+" ");
    }
  }
  public static void main(String args[]){
    int[] arr={
      7,8,4,5,2 };
      int a=1,b=4 ;
      int N=arr.length ;
      partSort(arr,N,a,b);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation partSort( arr : Sequence(int), N : int, a : int, b : int) : void
  pre: true
  post: true
  activity: (     var l : int ; l := Set{a, b}->min() ;
     var r : int ; r := Set{a, b}->max() ;
    var temp : Sequence(int) ; temp := Integer.subrange(1,r - l + 1)->collect(0) ;
    var j : int ; j := 0 ;
        var i : int ; i := l ; while i <= r do ( (     temp[j+1] := arr[i+1] ; 
     j := j + 1 )  ;     i := i + 1 ) ; 
    temp := temp->sort() ; 
    j := 0 ; 
        var i : int ; i := l ; while i <= r do ( (     arr[i+1] := temp[j+1] ; 
     j := j + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{7,8,4,5,2} ;
     var a : int ; a := 1 ;
    var b : int ; b := 4 ;
     var N : int ; N := arr->size() ;
     execute partSort(arr, N, a, b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void removeElements(int[] arr,int n){
    int[] brr=new int[n];
    int l=1 ;
    brr[0]=arr[0];
    for(int i=1 ; i<n ; i++){
      if(brr[l-1]<=arr[i]){
        brr[l]=arr[i];
        l++;
      }
    }
    for(int i=0 ; i<l ; i++)System.out.print(brr[i]+" ");
  }
  static public void main(String[] args){
    int[] arr={
      10,12,9,10,2,13,14 };
      int n=arr.length ;
      removeElements(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation removeElements( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var brr : Sequence(int) ; brr := Integer.subrange(1,n)->collect(0) ;
     var l : int ; l := 1 ;
    brr[0+1] := arr[0+1] ; 
        var i : int ; i := 1 ; while i < n do ( (     if (brr[l - 1+1] <= arr[i+1]) then (     brr[l+1] := arr[i+1] ; 
     l := l + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < l do (     OclFile["System.out"].print(brr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,12,9,10,2,13,14} ;
     var n : int ; n := arr->size() ;
     execute removeElements(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class Node {
    int elementID ;
    int stepsToeliminate ;
    public Node(int elementID,int stepsToeliminate){
      super();
      this.elementID=elementID ;
      this.stepsToeliminate=stepsToeliminate ;
    }
  };
  static void minSteps(int arr[],int N){
    Stack<Node>s=new Stack<Node>();
    s.add(new Node(0,-1));
    int maxStepsToeliminate=-1 ;
    for(int i=1 ; i<N ; i++){
      int stepsToeliminate=1 ;
      while(! s.isEmpty()){
        if(arr[s.peek().elementID]>=arr[i]){
          stepsToeliminate=Math.max(stepsToeliminate,s.peek().stepsToeliminate+1);
          s.pop();
        }
        else {
          break ;
        }
      }
      if(s.isEmpty()){
        stepsToeliminate=-1 ;
      }
      maxStepsToeliminate=Math.max(maxStepsToeliminate,stepsToeliminate);
      s.add(new Node(i,stepsToeliminate));
    }
    System.out.print((maxStepsToeliminate<0 ? 0 : maxStepsToeliminate)+"\n");
  }
  public static void main(String[] args){
    int arr[]={
      3,2,1,7,5 };
      int size=arr.length ;
      minSteps(arr,size);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Node {
   attribute elementID : int;
   attribute stepsToeliminate : int;
   static operation newNode( elementID : int, stepsToeliminate : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(elementID, stepsToeliminate);
    return self );
  operation initialise( elementID : int, stepsToeliminate : int) : void
  pre: true  post: true
  activity: (     execute super() ; 
     self.elementID := elementID ; 
     self.stepsToeliminate := stepsToeliminate );
}
  static   operation minSteps( arr : Sequence(int), N : int) : void
  pre: true
  post: true
  activity: (     var s : Sequence(Node) ; s := Sequence{} ;
     s := s->including(Node.newNode(0, -1)) ; 
    var maxStepsToeliminate : int ; maxStepsToeliminate := -1 ;
        var i : int ; i := 1 ; while i < N do ( (     var stepsToeliminate : int ; stepsToeliminate := 1 ;
     while (not(s->isEmpty())) do (     if (arr[s->min().elementID+1] >= arr[i+1]) then (     stepsToeliminate := Set{stepsToeliminate, s->min().stepsToeliminate + 1}->max() ; 
     s := s->front() ) else (     break ) ) ; 
    if (s->isEmpty()) then (     stepsToeliminate := -1 ) else skip ; 
    maxStepsToeliminate := Set{maxStepsToeliminate, stepsToeliminate}->max() ; 
    s := s->including(Node.newNode(i, stepsToeliminate)) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print((if maxStepsToeliminate < 0 then 0 else maxStepsToeliminate endif) + "\n") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,2,1,7,5} ;
     var size : int ; size := arr->size() ;
     execute minSteps(arr, size) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B499 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    ArrayList<String>arr=new ArrayList<String>();
    String[][] w=new String[m][2];
    String s="" ;
    for(int k=0 ; k<m ; k++){
      for(int y=0 ; y<2 ; y++){
        w[k][y]=sc.next();
      }
    }
    for(int i=0 ; i<n ; i++){
      arr.add(i,sc.next());
    }
    for(int k=0 ; k<n ; k++){
      for(int x=0 ; x<m ; x++){
        if(arr.get(k).equals(w[x][0])){
          if(w[x][0] .length()<=w[x][1] .length()){
            s=w[x][0];
            arr.set(k,s);
          }
          else {
            s=w[x][1];
            arr.set(k,s);
          }
          break ;
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(arr.get(i)+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B499 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := Sequence{} ;
    var w : Sequence(Sequence(String)) ; w := Integer.subrange(1,m)->collect(Integer.subrange(1,2)->collect(null)) ;
    var s : String ; s := "" ;
        var k : int ; k := 0 ; while k < m do ( (         var y : int ; y := 0 ; while y < 2 do ( (     w[k+1][y+1] := sc.getCurrent() )  ;     y := y + 1 ) )  ;     k := k + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr := arr.insertAt(i+1,sc.getCurrent()) )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < n do ( (         var x : int ; x := 0 ; while x < m do ( (     if (arr->at(k+1) = w[x+1][0+1]) then (     if (w[x+1][0+1]->size() <= w[x+1][1+1]->size()) then (     s := w[x+1][0+1] ; 
     arr := arr.setAt(k+1,s) ) else (     s := w[x+1][1+1] ; 
     arr := arr.setAt(k+1,s) ) ;  
     break ) else skip )  ;     x := x + 1 ) )  ;     k := k + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr->at(i+1) + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int size=sc.nextInt();
    int arr[]=new int[size+1];
    for(int i=1 ; i<=size ; i++)arr[i]=sc.nextInt();
    System.out.println(split(arr,1,size));
  }
  public static int split(int arr[],int s,int m){
    if(s==m)return 1 ;
    int half=(m-s+1)>>1 ;
    int mid=half+s ;
    int ans1=split(arr,s,mid-1);
    int ans2=split(arr,mid,m);
    if(arr[mid]>=arr[mid-1] && ans1==ans2 && ans1==half)return ans1+ans2 ;
    else if(ans1>ans2)return ans1 ;
    else return ans2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var size : int ; size := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,size + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= size do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(split(arr, 1, size)) ; 
 );
  static   operation split( arr : Sequence(int), s : int, m : int) : int
  pre: true
  post: true
  activity: (     if (s = m) then     return 1 else skip ; 
     var half : int ; half := ((m - s + 1)/(2->pow(1)))->oclAsType(long) ;
    var mid : int ; mid := half + s ;
    var ans1 : int ; ans1 := split(arr, s, mid - 1) ;
    var ans2 : int ; ans2 := split(arr, mid, m) ;
    if (arr[mid+1] >= arr[mid - 1+1] & ans1 = ans2 & ans1 = half) then     return ans1 + ans2 else     if (ans1 > ans2) then     return ans1 else     return ans2 ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class lecture {
  public static void main(String[] args){
    String original=null,second=null ;
    int numOfWords,numOfLine ;
    Scanner scan=new Scanner(System.in);
    numOfWords=scan.nextInt();
    numOfLine=scan.nextInt();
    Map<String,String>wordSets=new HashMap<>();
    StringBuilder result=new StringBuilder();
    for(int i=0 ; i<numOfLine ; i++){
      original=scan.next();
      second=scan.next();
      wordSets.put(original,(original.length()<=second.length())? original : second);
    }
    for(int k=0 ; k<numOfWords ; k++){
      String temp ;
      temp=wordSets.get(scan.next());
      result.append(temp+" ");
    }
    System.out.println(result.toString().trim());
  }
}
------------------------------------------------------------
OCL File:
---------
 class lecture {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var original : String ; original := null ;
    var second : String ; second := null ;
     var numOfWords : int ;
    var numOfLine : int ;
    var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    numOfWords := scan.getCurrent()->toInteger() ; 
    numOfLine := scan.getCurrent()->toInteger() ; 
    var wordSets : Map(String,String) ; wordSets := Map{} ;
    var result : String ; result := StringLib.newString() ;
        var i : int ; i := 0 ; while i < numOfLine do ( (     original := scan.getCurrent() ; 
     second := scan.getCurrent() ; 
     wordSets := wordSets->union(Map{original |-> if (original->size() <= second->size()) then original else second endif}) )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < numOfWords do ( (     var temp : String ;
     temp := wordSets->at(scan.getCurrent()) ; 
     result := result + StringLib.newString(temp + " ") )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(result+""->trim()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Lecture {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int profWords=scn.nextInt();
    int dictWords=scn.nextInt();
    HashMap<String,Integer>first=new HashMap<>();
    HashMap<String,Integer>second=new HashMap<>();
    HashMap<String,String>correlation1=new HashMap<>();
    HashMap<String,String>correlation2=new HashMap<>();
    for(int i=0 ; i<dictWords ; i++){
      String one=scn.next();
      String two=scn.next();
      first.put(one,one.length());
      second.put(two,two.length());
      correlation1.put(one,two);
      correlation2.put(two,one);
    }
    String[] input=new String[profWords];
    String[] output=new String[profWords];
    for(int i=0 ; i<profWords ; i++){
      input[i]=scn.next();
      if(first.containsKey(input[i])){
        String correspondingSecondLang=correlation1.get(input[i]);
        if(first.get(input[i])>second.get(correspondingSecondLang)){
          output[i]=correspondingSecondLang ;
        }
        else {
          output[i]=input[i];
        }
      }
      else {
        String correspondingFirstLang=correlation2.get(input[i]);
        if(first.get(correspondingFirstLang)<=second.get(input[i])){
          output[i]=correspondingFirstLang ;
        }
        else {
          output[i]=input[i];
        }
      }
    }
    for(int i=0 ; i<profWords ; i++){
      System.out.print(output[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Lecture {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var profWords : int ; profWords := scn.getCurrent()->toInteger() ;
    var dictWords : int ; dictWords := scn.getCurrent()->toInteger() ;
    var first : Map(String,int) ; first := Map{} ;
    var second : Map(String,int) ; second := Map{} ;
    var correlation1 : Map(String,String) ; correlation1 := Map{} ;
    var correlation2 : Map(String,String) ; correlation2 := Map{} ;
        var i : int ; i := 0 ; while i < dictWords do ( (     var one : String ; one := scn.getCurrent() ;
     var two : String ; two := scn.getCurrent() ;
    first := first->union(Map{one |-> one->size()}) ; 
    second := second->union(Map{two |-> two->size()}) ; 
    correlation1 := correlation1->union(Map{one |-> two}) ; 
    correlation2 := correlation2->union(Map{two |-> one}) ; 
 )  ;     i := i + 1 ) ; 
    var input : Sequence(String) ; input := Integer.subrange(1,profWords)->collect(null) ;
    var output : Sequence(String) ; output := Integer.subrange(1,profWords)->collect(null) ;
        var i : int ; i := 0 ; while i < profWords do ( (     input[i+1] := scn.getCurrent() ; 
     if (first->keys()->includes(input[i+1])) then (     var correspondingSecondLang : String ; correspondingSecondLang := correlation1->at(input[i+1]) ;
     if (first->at(input[i+1]) > second->at(correspondingSecondLang)) then (     output[i+1] := correspondingSecondLang ) else (     output[i+1] := input[i+1] ) ) else (     var correspondingFirstLang : String ; correspondingFirstLang := correlation2->at(input[i+1]) ;
     if (first->at(correspondingFirstLang) <= second->at(input[i+1])) then (     output[i+1] := correspondingFirstLang ) else (     output[i+1] := input[i+1] ) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < profWords do ( (     OclFile["System.out"].print(output[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.io.IOException ;
import java.util.HashMap ;
public class Answer {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=sc.nextInt();
    int m=sc.nextInt();
    HashMap<String,String>hm=new HashMap<>();
    for(int i=0 ; i<m ; i++){
      hm.put(sc.next(),sc.next());
    }
    for(int i=0 ; i<n ; i++){
      String s=sc.next();
      if(s.length()<=hm.get(s).length())pw.print(s);
      else pw.print(hm.get(s));
      if(i!=n-1)pw.print(" ");
    }
    pw.flush();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Answer {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var hm : Map(String,String) ; hm := Map{} ;
        var i : int ; i := 0 ; while i < m do ( (     hm := hm->union(Map{sc.getCurrent() |-> sc.getCurrent()}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
     if (s->size() <= hm->at(s)->size()) then     skip else     skip ; ;  
     if (i /= n - 1) then     skip ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Dragons {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter p=new PrintWriter(System.out);
    HashMap<String,String>hm=new HashMap<>();
    StringBuilder sb=new StringBuilder();
    int n=in.nextInt();
    int m=in.nextInt();
    for(int i=0 ; i<m ; i++){
      hm.put(in.next(),in.next());
    }
    for(int i=0 ; i<n ; i++){
      String s=in.next();
      if(s.length()>hm.get(s).length()){
        sb.append(hm.get(s)+" ");
      }
      else {
        sb.append(s+" ");
      }
    }
    p.println(sb);
    p.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Dragons {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : OclFile ; p := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var hm : Map(String,String) ; hm := Map{} ;
    var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     hm := hm->union(Map{in.getCurrent() |-> in.getCurrent()}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := in.getCurrent() ;
     if (s->size() > hm->at(s)->size()) then (     sb := sb + StringLib.newString(hm->at(s) + " ") ) else (     sb := sb + StringLib.newString(s + " ") ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean check(int H,int S){
    return H*H>=4*S ;
  }
  static int findPairs(int H[],int n,int S[],int m){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(check(H[i],S[j]))count++;
      }
    }
    return count ;
  }
  public static void main(String args[]){
    int H[]={
      1,6,4 };
      int n=H.length ;
      int S[]={
        23,3,42,14 };
        int m=S.length ;
        System.out.println(findPairs(H,n,S,m));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation check( H : int, S : int) : boolean
  pre: true
  post: true
  activity: (     return H * H >= 4 * S );
  static   operation findPairs( H : Sequence(int), n : int, S : Sequence(int), m : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (check(H[i+1], S[j+1])) then     count := count + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var H : Sequence(int) ; H := Sequence{1,6,4} ;
     var n : int ; n := H->size() ;
    var S : Sequence(int) ; S := Sequence{23,3,42,14} ;
    var m : int ; m := S->size() ;
    OclFile["System.out"].println(findPairs(H, n, S, m)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GFG {
  static void Print3Smallest(int array[],int n){
    int firstmin=Integer.MAX_VALUE ;
    int secmin=Integer.MAX_VALUE ;
    int thirdmin=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(array[i]<firstmin){
        thirdmin=secmin ;
        secmin=firstmin ;
        firstmin=array[i];
      }
      else if(array[i]<secmin){
        thirdmin=secmin ;
        secmin=array[i];
      }
      else if(array[i]<thirdmin)thirdmin=array[i];
    }
    System.out.println("First min="+firstmin);
    System.out.println("Second min="+secmin);
    System.out.println("Third min="+thirdmin);
  }
  public static void main(String[] args){
    int array[]={
      4,9,1,32,12 };
      int n=array.length ;
      Print3Smallest(array,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Print3Smallest( array : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var firstmin : int ; firstmin := 2147483647 ;
     var secmin : int ; secmin := 2147483647 ;
    var thirdmin : int ; thirdmin := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     if (array[i+1] < firstmin) then (     thirdmin := secmin ; 
     secmin := firstmin ; 
     firstmin := array[i+1] ) else     if (array[i+1] < secmin) then (     thirdmin := secmin ; 
     secmin := array[i+1] ) else     if (array[i+1] < thirdmin) then     thirdmin := array[i+1] ; else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("First min=" + firstmin) ; 
    OclFile["System.out"].println("Second min=" + secmin) ; 
    OclFile["System.out"].println("Third min=" + thirdmin) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Sequence{4,9,1,32,12} ;
     var n : int ; n := array->size() ;
     execute Print3Smallest(array, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    char[] garlands=st.nextToken().toCharArray();
    int[] counts=new int[4];
    char[] colors=new char[4];
    for(int i=0 ; i<garlands.length ; i++){
      char current=garlands[i];
      if(current=='!'){
        counts[i % 4]++;
        continue ;
      }
      colors[i % 4]=current ;
    }
    for(int i=0 ; i<4 ; i++){
      if((int)colors[i]!=0)continue ;
      colors[i]=(char)((int)colors[0]+(int)colors[1]+(int)colors[2]+(int)colors[3]);
      break ;
    }
    char[] c={
      'R','B','Y','G' };
      for(int i=0 ; i<4 ; i++){
        for(int j=0 ; j<4 ; j++){
          if(colors[j]==c[i]){
            System.out.print(counts[j]+" ");
            break ;
          }
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var garlands : Sequence(String) ; garlands := st.next()->characters() ;
    var counts : Sequence(int) ; counts := Integer.subrange(1,4)->collect(0) ;
    var colors : Sequence(String) ; colors := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < garlands->size() do ( (     var current : String ; current := garlands[i+1] ;
     if (current = '!') then (     counts[i mod 4+1] := counts[i mod 4+1] + 1 ; 
     continue ) else skip ; 
     colors[i mod 4+1] := current )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 4 do ( (     if (colors[i+1]->oclAsType(int) /= 0) then     continue else skip ; 
     colors[i+1] := (colors[0+1]->oclAsType(int) + colors[1+1]->oclAsType(int) + colors[2+1]->oclAsType(int) + colors[3+1]->oclAsType(int))->oclAsType(String) ; 
     break )  ;     i := i + 1 ) ; 
    var c : Sequence(String) ; c := Sequence{'R','B','Y','G'} ;
        var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < 4 do ( (     if (colors[j+1] = c[i+1]) then (     OclFile["System.out"].print(counts[j+1] + " ") ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scanner.nextInt();
    }
    Arrays.sort(a);
    for(int j=n-1 ; j>=0 ; j--){
      int t=(int)Math.sqrt(a[j]);
      if((t*t)!=a[j]){
        System.out.println(a[j]);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
        var j : int ; j := n - 1 ; while j >= 0 do ( (     var t : int ; t := (a[j+1])->sqrt()->oclAsType(int) ;
     if ((t * t) /= a[j+1]) then (     OclFile["System.out"].println(a[j+1]) ; 
     break ) else skip )  ;     j := j - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Blown758B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    StringBuffer sb=new StringBuffer(s);
    int size=s.length();
    int kr=0 ;
    int kb=0 ;
    int ky=0 ;
    int kg=0 ;
    if(s.contains("!")==false){
      System.out.println("0 0 0 0");
      return ;
    }
    String s2=s.substring(0,4);
    int index=0 ;
    for(int i=0 ; i<4 ; i++){
      if(s2.charAt(i)=='!'){
        for(int j=i+4 ; j<size ; j+=4){
          if(s.charAt(j)!='!')index=j ;
        }
        s2=s2.substring(0,i)+s.charAt(index)+s2.substring(i+1);
      }
    }
    for(int i=0,j=0 ; i<size ; i++,j++){
      if(i % 4==0)j=0 ;
      if(s.charAt(i)=='!'){
        if(s2.charAt(j)=='R')kr++;
        else if(s2.charAt(j)=='B')kb++;
        else if(s2.charAt(j)=='Y')ky++;
        else kg++;
      }
    }
    System.out.println(kr+" "+kb+" "+ky+" "+kg);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Blown758B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
    var sb : String ; sb := StringLib.newString(s) ;
    var size : int ; size := s->size() ;
    var kr : int ; kr := 0 ;
    var kb : int ; kb := 0 ;
    var ky : int ; ky := 0 ;
    var kg : int ; kg := 0 ;
    if (s->includes("!") = false) then (     OclFile["System.out"].println("0 0 0 0") ; 
     return ) else skip ; 
    var s2 : String ; s2 := s.subrange(0+1,4) ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     if (s2->at(i+1) = '!') then (         var j : int ; j := i + 4 ; while j < size do ( (     if (s->at(j+1) /= '!') then     index := j ; else skip )  ;     j := j+(4) ) ; 
     s2 := s2.subrange(0+1,i) + s->at(index+1) + s2.subrange(i + 1+1,i + 1) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ;
    var j : int ; j := 0 ; while i < size do ( (     if (i mod 4 = 0) then     j := 0 ; else skip ; 
     if (s->at(i+1) = '!') then (     if (s2->at(j+1) = 'R') then     kr := kr + 1 ; else     if (s2->at(j+1) = 'B') then     kb := kb + 1 else     if (s2->at(j+1) = 'Y') then     ky := ky + 1 else     kg := kg + 1 ; ;  ;  ) else skip )  ;     i := i + 1 ;     j := j + 1 ) ; 
    OclFile["System.out"].println(kr + " " + kb + " " + ky + " " + kg) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int dayofweek(int d,int m,int y){
    int t[]={
      0,3,2,5,0,3,5,1,4,6,2,4 };
      y-=(m<3)? 1 : 0 ;
      return(y+y/4-y/100+y/400+t[m-1]+d)% 7 ;
    }
    public static void main(String arg[]){
      int day=dayofweek(30,8,2010);
      System.out.print(day);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation dayofweek( d : int, m : int, y : int) : int
  pre: true
  post: true
  activity: (     var t : Sequence(int) ; t := Sequence{0,3,2,5,0,3,5,1,4,6,2,4} ;
     y := y-(if (m < 3) then 1 else 0 endif) ; 
     return (y + y / 4 - y / 100 + y / 400 + t[m - 1+1] + d) mod 7 );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var day : int ; day := dayofweek(30, 8, 2010) ;
     OclFile["System.out"].print(day) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ThanosSort {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    if(n==1){
      System.out.println(1);
    }
    else {
      boolean flag=true ;
      for(int i=0 ; i<n-1 ; i++){
        if(arr[i]>arr[i+1]){
          flag=false ;
        }
      }
      if(! flag){
        System.out.println(sortItOut(arr,0,n-1));
      }
      else {
        System.out.println(n);
      }
    }
  }
  private static int sortItOut(int arr[],int i,int j){
    if(i==j){
      return 1 ;
    }
    int mid=(i+j)/2 ;
    int max1=sortItOut(arr,i,mid);
    int max2=sortItOut(arr,mid+1,j);
    if(arr[mid]<=arr[mid+1] &&(mid+1-i==max1)&&(j-mid==max2)){
      return max1+max2 ;
    }
    else {
      return Math.max(max1,max2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ThanosSort {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (n = 1) then (     OclFile["System.out"].println(1) ) else (     var flag : boolean ; flag := true ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] > arr[i + 1+1]) then (     flag := false ) else skip )  ;     i := i + 1 ) ; 
     if (not(flag)) then (     OclFile["System.out"].println(sortItOut(arr, 0, n - 1)) ) else (     OclFile["System.out"].println(n) ) ) ;  
 );
  static   operation sortItOut( arr : Sequence(int), i : int, j : int) : int
  pre: true
  post: true
  activity: (     if (i = j) then (     return 1 ) else skip ; 
     var mid : int ; mid := (i + j) / 2 ;
    var max1 : int ; max1 := sortItOut(arr, i, mid) ;
    var max2 : int ; max2 := sortItOut(arr, mid + 1, j) ;
    if (arr[mid+1] <= arr[mid + 1+1] & (mid + 1 - i = max1) & (j - mid = max2)) then (     return max1 + max2 ) else (     return Set{max1, max2}->max() ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  static int powerNumbers(int n){
    HashSet<Integer>v=new HashSet<Integer>();
    v.add(1);
    for(int i=2 ; i*i<=n ; i++){
      int j=i*i ;
      v.add(j);
      while(j*i<=n){
        v.add(j*i);
        j=j*i ;
      }
    }
    return v.size();
  }
  public static void main(String args[]){
    System.out.print(powerNumbers(50));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation powerNumbers( n : int) : int
  pre: true
  post: true
  activity: (     var v : Set(int) ; v := Set{} ;
     v := v->including(1) ; 
         var i : int ; i := 2 ; while i * i <= n do ( (     var j : int ; j := i * i ;
     v := v->including(j) ; 
     while (j * i <= n) do (     v := v->including(j * i) ; 
     j := j * i ) )  ;     i := i + 1 ) ; 
     return v->size() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(powerNumbers(50)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean productDivisible(int n,int k){
    int product=1,position=1 ;
    while(n>0){
      if(position % 2==0){
        product*=n % 10 ;
      }
      n=n/10 ;
      position++;
    }
    if(product % k==0){
      return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    int n=321922 ;
    int k=3 ;
    if(productDivisible(n,k)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation productDivisible( n : int, k : int) : boolean
  pre: true
  post: true
  activity: (     var product : int ; product := 1 ;
    var position : int ; position := 1 ;
     while (n > 0) do (     if (position mod 2 = 0) then (     product := product*(n mod 10) ) else skip ; 
     n := n / 10 ; 
     position := position + 1 ) ; 
     if (product mod k = 0) then (     return true ) else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 321922 ;
     var k : int ; k := 3 ;
     if (productDivisible(n, k)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isDivisibleBy10(char bin[],int n){
    if(bin[n-1]=='1')return false ;
    int sum=0 ;
    for(int i=n-2 ; i>=0 ; i--){
      if(bin[i]=='1'){
        int posFromRight=n-i-1 ;
        if(posFromRight % 4==1)sum=sum+2 ;
        else if(posFromRight % 4==2)sum=sum+4 ;
        else if(posFromRight % 4==3)sum=sum+8 ;
        else if(posFromRight % 4==0)sum=sum+6 ;
      }
    }
    if(sum % 10==0)return true ;
    return false ;
  }
  static boolean isDivisibleBy20(char bin[],int n){
    if(bin[n-1]=='1')return false ;
    return isDivisibleBy10(bin,n-1);
  }
  public static void main(String args[]){
    char bin[]="101000".toCharArray();
    int n=bin.length ;
    if(isDivisibleBy20(bin,n-1))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isDivisibleBy10( bin : Sequence(String), n : int) : boolean
  pre: true
  post: true
  activity: (     if (bin[n - 1+1] = '1') then     return false else skip ; 
     var sum : int ; sum := 0 ;
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (bin[i+1] = '1') then (     var posFromRight : int ; posFromRight := n - i - 1 ;
     if (posFromRight mod 4 = 1) then     sum := sum + 2 ; else     if (posFromRight mod 4 = 2) then     sum := sum + 4 else     if (posFromRight mod 4 = 3) then     sum := sum + 8 else     if (posFromRight mod 4 = 0) then     sum := sum + 6 ; else skip ; ;  ;  ) else skip )  ;     i := i - 1 ) ; 
    if (sum mod 10 = 0) then     return true else skip ; 
    return false 
 );
  static   operation isDivisibleBy20( bin : Sequence(String), n : int) : boolean
  pre: true
  post: true
  activity: (     if (bin[n - 1+1] = '1') then     return false else skip ; 
     return isDivisibleBy10(bin, n - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bin : Sequence(String) ; bin := "101000"->characters() ;
     var n : int ; n := bin->size() ;
     if (isDivisibleBy20(bin, (n)->char2byte() - 1)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void halfsquare(int n,int x,int y){
    int half=n/2 ;
    if((half==x || half==x-1)&&(half==y || half==y-1))System.out.println("NO");
    else System.out.println("YES");
  }
  public static void main(String[] args){
    int n=100 ;
    int x=51,y=100 ;
    halfsquare(n,x,y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation halfsquare( n : int, x : int, y : int) : void
  pre: true
  post: true
  activity: (     var half : int ; half := n / 2 ;
     if ((half = x or half = x - 1) & (half = y or half = y - 1)) then     OclFile["System.out"].println("NO") ; else     OclFile["System.out"].println("YES") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 100 ;
     var x : int ; x := 51 ;
    var y : int ; y := 100 ;
     execute halfsquare(n, x, y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s1="Sunny" ;
    String s2="Cloudy" ;
    String s3="Rainy" ;
    String s=sc.next();
    String ans="" ;
    if(s.equals(s1))ans=s2 ;
    else if(s.equals(s2))ans=s3 ;
    else if(s.equals(s3))ans=s1 ;
    sc.close();
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := "Sunny" ;
    var s2 : String ; s2 := "Cloudy" ;
    var s3 : String ; s3 := "Rainy" ;
    var s : String ; s := sc.getCurrent() ;
    var ans : String ; ans := "" ;
    if (s = s1) then     ans := s2 else     if (s = s2) then     ans := s3 else     if (s = s3) then     ans := s1 ; else skip ; ;  ;  
    skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static final String SUUNY="Sunny" ;
  public static final String CLOUDY="Cloudy" ;
  public static final String RAINY="Rainy" ;
  static Main instance=new Main();
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String str=scan.next();
    String result=null ;
    if(str.equals(SUUNY)){
      result=CLOUDY ;
    }
    else if(str.equals(CLOUDY)){
      result=RAINY ;
    }
    else if(str.equals(RAINY)){
      result=SUUNY ;
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute SUUNY : String := "Sunny";
  static    attribute CLOUDY : String := "Cloudy";
  static    attribute RAINY : String := "Rainy";
  static   attribute instance : Main := Main.newMain();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := scan.getCurrent() ;
    var result : String ; result := null ;
    if (str = SUUNY) then (     result := CLOUDY ) else     if (str = CLOUDY) then (     result := RAINY ) else     if (str = RAINY) then (     result := SUUNY ) else skip ; ;  ;  
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    String[] weather={
      "Sunny","Cloudy","Rainy" };
      Scanner sc=new Scanner(System.in);
      String S=sc.next();
      sc.close();
      TommorowWeather(0,weather,S);
    }
    public static void TommorowWeather(int index,String[] weather,String S){
      if(index>=3){
        return ;
      }
      if(S.equals(weather[index])){
        int ans=index+1 ;
        if(ans>=3){
          ans=0 ;
        }
        System.out.println(weather[ans]);
        return ;
      }
      TommorowWeather(index+1,weather,S);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var weather : Sequence(String) ; weather := Sequence{"Sunny","Cloudy","Rainy"} ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var S : String ; S := sc.getCurrent() ;
    skip ; 
    execute TommorowWeather(0, weather, S) ; 
 );
  static   operation TommorowWeather( index : int, weather : Sequence(String), S : String) : void
  pre: true
  post: true
  activity: (     if (index >= 3) then (     return ) else skip ; 
     if (S = weather[index+1]) then (     var ans : int ; ans := index + 1 ;
     if (ans >= 3) then (     ans := 0 ) else skip ; 
     OclFile["System.out"].println(weather[ans+1]) ; 
     return ) else skip ; 
     execute TommorowWeather(index + 1, weather, S) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner scan=new Scanner(System.in);
    String S=scan.next();
    String[] tenki={
      "Sunny","Cloudy","Rainy" };
      String rlt="" ;
      if(S.equals(tenki[0])){
        rlt=tenki[1];
      }
      if(S.equals(tenki[1])){
        rlt=tenki[2];
      }
      if(S.equals(tenki[2])){
        rlt=tenki[0];
      }
      System.out.println(rlt);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := scan.getCurrent() ;
    var tenki : Sequence(String) ; tenki := Sequence{"Sunny","Cloudy","Rainy"} ;
    var rlt : String ; rlt := "" ;
    if (S = tenki[0+1]) then (     rlt := tenki[1+1] ) else skip ; 
    if (S = tenki[1+1]) then (     rlt := tenki[2+1] ) else skip ; 
    if (S = tenki[2+1]) then (     rlt := tenki[0+1] ) else skip ; 
    OclFile["System.out"].println(rlt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long number=sc.nextLong();
    long maxNumber=Long.MIN_VALUE ;
    while(number--!=0){
      long temp=sc.nextLong();
      if(! getNumber(temp)){
        maxNumber=Math.max(maxNumber,temp);
      }
    }
    System.out.print(maxNumber);
  }
  private static boolean getNumber(long n){
    return Math.sqrt(n)% 1==0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : long ; number := sc.getCurrent()->toLong() ;
    var maxNumber : long ; maxNumber := "-9223372036854775808"->toLong() ;
        while (number /= 0) do (    skip ; (     var temp : long ; temp := sc.getCurrent()->toLong() ;
     if (not(getNumber(temp))) then (     maxNumber := Set{maxNumber, temp}->max() ) else skip ) ;  ) ;  
    OclFile["System.out"].print(maxNumber) ; 
 );
  static   operation getNumber( n : long) : boolean
  pre: true
  post: true
  activity: (     return (n)->sqrt() mod 1 = 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    System.out.println(new Main().weather_prediction(scanner.nextLine()));
    scanner.close();
  }
  public String weather_prediction(String weather){
    String[] predictions={
      "Sunny","Cloudy","Rainy" };
      int i ;
      for(i=0 ; i<3 ; i++){
        if(weather.equals(predictions[i])){
          break ;
        }
      }
      return predictions[(i+1)% 3];
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println(Main.newMain().weather_prediction(scanner.nextLine())) ; 
     skip );
   operation weather_prediction( weather : String) : String
  pre: true
  post: true
  activity: (     var predictions : Sequence(String) ; predictions := Sequence{"Sunny","Cloudy","Rainy"} ;
     var i : int ;
         i := 0 ; while i < 3 do ( (     if (weather = predictions[i+1]) then (     break ) else skip )  ;     i := i + 1 ) ; 
     return predictions[(i + 1) mod 3+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class Solution {
  public static void main(String[] args){
    boolean debug=false ;
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=input.nextInt();
    }
    int begin=0 ;
    int end=n ;
    int mid=n/2 ;
    boolean isSorted=true ;
    int value=0 ;
    while(true){
      mid=(end+begin)/2 ;
      isSorted=true ;
      for(int i=begin ; i<end-1 ; i++){
        if(a[i+1]<a[i]){
          isSorted=false ;
          break ;
        }
      }
      if(isSorted){
        value=end-begin ;
        break ;
      }
      else {
        int maxCountFirst=-1 ;
        int count=1 ;
        for(int i=begin ; i<mid-1 ; i++){
          if(a[i+1]<a[i]){
            if(count>maxCountFirst)maxCountFirst=count ;
            count=1 ;
          }
          else {
            count++;
          }
        }
        if(count>maxCountFirst)maxCountFirst=count ;
        int maxCountLast=-1 ;
        count=1 ;
        for(int i=mid ; i<end-1 ; i++){
          if(a[i+1]<a[i]){
            if(count>maxCountLast)maxCountLast=count ;
            count=1 ;
          }
          else {
            count++;
          }
        }
        if(count>maxCountLast)maxCountLast=count ;
        if(maxCountFirst>=maxCountLast){
          end=mid ;
        }
        else {
          begin=mid ;
        }
      }
    }
    System.out.println(value);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var debug : boolean ; debug := false ;
     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := input.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var begin : int ; begin := 0 ;
    var end : int ; end := n ;
    var mid : int ; mid := n / 2 ;
    var isSorted : boolean ; isSorted := true ;
    var value : int ; value := 0 ;
    while (true) do (     mid := (end + begin) / 2 ; 
     isSorted := true ; 
         var i : int ; i := begin ; while i < end - 1 do ( (     if (a[i + 1+1] < a[i+1]) then (     isSorted := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (isSorted) then (     value := end - begin ; 
     break ) else (     var maxCountFirst : int ; maxCountFirst := -1 ;
     var count : int ; count := 1 ;
        var i : int ; i := begin ; while i < mid - 1 do ( (     if (a[i + 1+1] < a[i+1]) then (     if (count > maxCountFirst) then     maxCountFirst := count ; else skip ; 
     count := 1 ) else (     count := count + 1 ) )  ;     i := i + 1 ) ; 
    if (count > maxCountFirst) then     maxCountFirst := count ; else skip ; 
    var maxCountLast : int ; maxCountLast := -1 ;
    count := 1 ; 
        var i : int ; i := mid ; while i < end - 1 do ( (     if (a[i + 1+1] < a[i+1]) then (     if (count > maxCountLast) then     maxCountLast := count ; else skip ; 
     count := 1 ) else (     count := count + 1 ) )  ;     i := i + 1 ) ; 
    if (count > maxCountLast) then     maxCountLast := count ; else skip ; 
    if (maxCountFirst >= maxCountLast) then (     end := mid ) else (     begin := mid ) ;  
 ) ) ; 
    OclFile["System.out"].println(value) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int gcd(int a,int b){
    int c ;
    while(a!=0){
      c=a ;
      a=b % a ;
      b=c ;
    }
    return b ;
  }
  static void forbenius(int X,int Y){
    if(gcd(X,Y)!=1){
      System.out.println("NA");
      return ;
    }
    int A=(X*Y)-(X+Y);
    int N=(X-1)*(Y-1)/2 ;
    System.out.println("Largest Amount="+A);
    System.out.println("Total Count="+N);
  }
  public static void main(String[] args){
    int X=2,Y=5 ;
    forbenius(X,Y);
    X=5 ;
    Y=10 ;
    System.out.println();
    forbenius(X,Y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var c : int ;
     while (a /= 0) do (     c := a ; 
     a := b mod a ; 
     b := c ) ; 
     return b );
  static   operation forbenius( X : int, Y : int) : void
  pre: true
  post: true
  activity: (     if (gcd(X, Y) /= 1) then (     OclFile["System.out"].println("NA") ; 
     return ) else skip ; 
     var A : int ; A := (X * Y) - (X + Y) ;
    var N : int ; N := (X - 1) * (Y - 1) / 2 ;
    OclFile["System.out"].println("Largest Amount=" + A) ; 
    OclFile["System.out"].println("Total Count=" + N) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 2 ;
    var Y : int ; Y := 5 ;
     execute forbenius(X, Y) ; 
    X := 5 ; 
    Y := 10 ; 
    OclFile["System.out"].println() ; 
    execute forbenius(X, Y) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void reverse(int a[]){
    int i,k,n=a.length ;
    int t ;
    for(i=0 ; i<n/2 ; i++){
      t=a[i];
      a[i]=a[n-i-1];
      a[n-i-1]=t ;
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,5,8,9,6,7,3,4,2,0 };
      int n=arr.length ;
      Arrays.sort(arr);
      reverse(arr);
      System.out.println("Array after sorting : \n");
      for(int i=0 ; i<n ; ++i){
        System.out.print(arr[i]+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation reverse( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var k : int ;
    var n : int ; n := a->size() ;
     var t : int ;
         i := 0 ; while i < n / 2 do ( (     t := a[i+1] ; 
     a[i+1] := a[n - i - 1+1] ; 
     a[n - i - 1+1] := t )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,8,9,6,7,3,4,2,0} ;
     var n : int ; n := arr->size() ;
    arr := arr->sort() ; 
    execute reverse(arr) ; 
    OclFile["System.out"].println("Array after sorting : \n") ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import static java.lang.Math.pow ;
public class A {
  static void bestApproximate(int x[],int y[]){
    int n=x.length ;
    double m,c,sum_x=0,sum_y=0,sum_xy=0,sum_x2=0 ;
    for(int i=0 ; i<n ; i++){
      sum_x+=x[i];
      sum_y+=y[i];
      sum_xy+=x[i]*y[i];
      sum_x2+=pow(x[i],2);
    }
    m=(n*sum_xy-sum_x*sum_y)/(n*sum_x2-pow(sum_x,2));
    c=(sum_y-m*sum_x)/n ;
    System.out.println("m="+m);
    System.out.println("c="+c);
  }
  public static void main(String args[]){
    int x[]={
      1,2,3,4,5 };
      int y[]={
        14,27,40,55,68 };
        bestApproximate(x,y);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation bestApproximate( x : Sequence(int), y : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := x->size() ;
     var m : double ;
    var c : double ;
    var sum_x : double ; sum_x := 0 ;
    var sum_y : double ; sum_y := 0 ;
    var sum_xy : double ; sum_xy := 0 ;
    var sum_x2 : double ; sum_x2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum_x := sum_x+(x[i+1]) ; 
     sum_y := sum_y+(y[i+1]) ; 
     sum_xy := sum_xy+(x[i+1] * y[i+1]) ; 
     sum_x2 := sum_x2+(pow(x[i+1], 2)) )  ;     i := i + 1 ) ; 
    m := (n * sum_xy - sum_x * sum_y) / (n * sum_x2 - pow(sum_x, 2)) ; 
    c := (sum_y - m * sum_x) / n ; 
    OclFile["System.out"].println("m=" + m) ; 
    OclFile["System.out"].println("c=" + c) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : Sequence(int) ; x := Sequence{1,2,3,4,5} ;
     var y : Sequence(int) ; y := Sequence{14,27,40,55,68} ;
     execute bestApproximate(x, y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class Node {
    int data ;
    Node next ;
  };
  static Node head ;
  static void push(Node head_ref,int new_data){
    Node new_node=new Node();
    new_node.data=new_data ;
    new_node.next=(head_ref);
(head_ref)=new_node ;
    head=head_ref ;
  }
  static int productOfLastN_NodesUtil(Node head,int n){
    if(n<=0)return 0 ;
    Stack<Integer>st=new Stack<Integer>();
    int prod=1 ;
    while(head!=null){
      st.push(head.data);
      head=head.next ;
    }
    while(n-->0){
      prod*=st.peek();
      st.pop();
    }
    return prod ;
  }
  public static void main(String[] args){
    head=null ;
    push(head,12);
    push(head,4);
    push(head,8);
    push(head,6);
    push(head,10);
    int n=2 ;
    System.out.println(productOfLastN_NodesUtil(head,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   attribute head : Node;
  static   operation push( head_ref : Node, new_data : int) : void
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode() ;
     new_node.data := new_data ; 
    new_node.next := (head_ref) ; 
    (head_ref) := new_node ; 
    head := head_ref ; 
 );
  static   operation productOfLastN_NodesUtil( head : Node, n : int) : int
  pre: true
  post: true
  activity: (     if (n <= 0) then     return 0 else skip ; 
     var st : Sequence(int) ; st := Sequence{} ;
    var prod : int ; prod := 1 ;
    while (head /= null) do (     st := st->append(head.data) ; 
     head := head.next ) ; 
        while (n > 0) do (        n := n - 1 ;     skip ; (     prod := prod*(st->min()) ; 
     st := st->front() ) ;  ) ;  
    return prod 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     head := null ; 
     execute push(head, 12) ; 
    execute push(head, 4) ; 
    execute push(head, 8) ; 
    execute push(head, 6) ; 
    execute push(head, 10) ; 
    var n : int ; n := 2 ;
    OclFile["System.out"].println(productOfLastN_NodesUtil(head, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
class GFG {
  static int modExp(int a,int b){
    int result=1 ;
    while(b>0){
      if(b==1)result=result*a ;
      a=a*a ;
      b/=2 ;
    }
    return result ;
  }
  static int check(int num){
    if(num==1 || num<3)return-1 ;
    else if(num % 4==0)return modExp(num/4,4);
    else if(num % 6==0)return modExp(num/3,2)*modExp(num/6,2);
    else if(num % 10==0)return modExp(num/5,2)*(num/10)*(num/2);
    else return-1 ;
  }
  public static void main(String[] args){
    int num=10 ;
    System.out.print(check(num));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation modExp( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 1 ;
     while (b > 0) do (     if (b = 1) then     result := result * a ; else skip ; 
     a := a * a ; 
     b := b/(2) ) ; 
     return result );
  static   operation check( num : int) : int
  pre: true
  post: true
  activity: (     if (num = 1 or num < 3) then     return -1 else     if (num mod 4 = 0) then     return modExp(num / 4, 4) else     if (num mod 6 = 0) then     return modExp(num / 3, 2) * modExp(num / 6, 2) else     if (num mod 10 = 0) then     return modExp(num / 5, 2) * (num / 10) * (num / 2) else     return -1 ;  ;  ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 10 ;
     OclFile["System.out"].print(check(num)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class DLL {
  Node head ;
  class Node {
    int data ;
    Node prev ;
    Node next ;
    Node(int d){
      data=d ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class DLL {
   attribute head : Node;
 class Node {
   attribute data : int;
   attribute prev : Node;
   attribute next : Node;
   static operation newNode( d : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(d);
    return self );
  operation initialise( d : int) : void
  pre: true  post: true
  activity: (     data := d );
}
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findMaxDiff(int arr[],int n){
    if(n<2){
      System.out.print("Invalid ");
      return 0 ;
    }
    int res=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)if(res<(arr[i]-arr[j]-i+j))res=(arr[i]-arr[j]-i+j);
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      9,15,4,12,13 };
      int n=arr.length ;
      System.out.print(findMaxDiff(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMaxDiff( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n < 2) then (     OclFile["System.out"].print("Invalid ") ; 
     return 0 ) else skip ; 
     var res : int ; res := -2147483648 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (     if (res < (arr[i+1] - arr[j+1] - i + j)) then     res := (arr[i+1] - arr[j+1] - i + j) ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{9,15,4,12,13} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(findMaxDiff(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class GFG {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a,b,i,j,flag ;
    System.out.printf("Enter lower bound of the interval: ");
    a=sc.nextInt();
    System.out.printf("\nEnter upper bound of the interval: ");
    b=sc.nextInt();
    System.out.printf("\nPrime numbers between %d and %d are: ",a,b);
    if(a==1){
      System.out.println(a);
      a++;
      if(b>=2){
        System.out.println(a);
        a++;
      }
    }
    if(a==2)System.out.println(a);
    if(a % 2==0)a++;
    for(i=a ; i<=b ; i=i+2){
      flag=1 ;
      for(j=2 ; j*j<=i ; ++j){
        if(i % j==0){
          flag=0 ;
          break ;
        }
      }
      if(flag==1)System.out.println(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ;
    var b : int ;
    var i : int ;
    var j : int ;
    var flag : int ;
    OclFile["System.out"].printf("Enter lower bound of the interval: ") ; 
    a := sc.getCurrent()->toInteger() ; 
    OclFile["System.out"].printf("\nEnter upper bound of the interval: ") ; 
    b := sc.getCurrent()->toInteger() ; 
    OclFile["System.out"].printf("\nPrime numbers between %d and %d are: ", a, b) ; 
    if (a = 1) then (     OclFile["System.out"].println(a) ; 
     a := a + 1 ; 
     if (b >= 2) then (     OclFile["System.out"].println(a) ; 
     a := a + 1 ) else skip ) else skip ; 
    if (a = 2) then     OclFile["System.out"].println(a) ; else skip ; 
    if (a mod 2 = 0) then     a := a + 1 ; else skip ; 
        i := a ; while i <= b do ( (     flag := 1 ; 
         j := 2 ; while j * j <= i do ( (     if (i mod j = 0) then (     flag := 0 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (flag = 1) then     OclFile["System.out"].println(i) ; else skip )  ;     i := i + 2 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class GFG {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a,b,i,j,flag ;
    System.out.printf("Enter lower bound of the interval: ");
    a=sc.nextInt();
    System.out.printf("\nEnter upper bound of the interval: ");
    b=sc.nextInt();
    System.out.printf("\nPrime numbers between %d and %d are: ",a,b);
    for(i=a ; i<=b ; i++){
      if(i==1 || i==0)continue ;
      flag=1 ;
      for(j=2 ; j<=i/2 ; ++j){
        if(i % j==0){
          flag=0 ;
          break ;
        }
      }
      if(flag==1)System.out.println(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ;
    var b : int ;
    var i : int ;
    var j : int ;
    var flag : int ;
    OclFile["System.out"].printf("Enter lower bound of the interval: ") ; 
    a := sc.getCurrent()->toInteger() ; 
    OclFile["System.out"].printf("\nEnter upper bound of the interval: ") ; 
    b := sc.getCurrent()->toInteger() ; 
    OclFile["System.out"].printf("\nPrime numbers between %d and %d are: ", a, b) ; 
        i := a ; while i <= b do ( (     if (i = 1 or i = 0) then     continue else skip ; 
     flag := 1 ; 
         j := 2 ; while j <= i / 2 do ( (     if (i mod j = 0) then (     flag := 0 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (flag = 1) then     OclFile["System.out"].println(i) ; else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int size=Integer.valueOf(in.nextLine());
    int[] arr=new int[size];
    String[] s=in.nextLine().split(" ");
    for(int i=0 ; i<s.length ; i++){
      arr[i]=Integer.parseInt(s[i]);
    }
    Arrays.sort(arr);
    int index=0 ;
    int cur=1 ;
    int max=Integer.MIN_VALUE ;
    while(index<arr.length){
      while(index<arr.length && cur*cur>arr[index]){
        if(arr[index]!=(cur-1)*(cur-1)){
          max=Math.max(max,arr[index]);
        }
        index++;
      }
      cur++;
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var size : int ; size := (in.nextLine())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
    var s : Sequence(String) ; s := in.nextLine()->split(" ") ;
        var i : int ; i := 0 ; while i < s->size() do ( (     arr[i+1] := (s[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var index : int ; index := 0 ;
    var cur : int ; cur := 1 ;
    var max : int ; max := -2147483648 ;
    while (index < arr->size()) do (     while (index < arr->size() & cur * cur > arr[index+1]) do (     if (arr[index+1] /= (cur - 1) * (cur - 1)) then (     max := Set{max, arr[index+1]}->max() ) else skip ; 
     index := index + 1 ) ; 
     cur := cur + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static int printKDistinct(int arr[],int n,int k){
    Map<Integer,Integer>h=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      if(h.containsKey(arr[i]))h.put(arr[i],h.get(arr[i])+1);
      else h.put(arr[i],1);
    }
    if(h.size()<k)return-1 ;
    int dist_count=0 ;
    for(int i=0 ; i<n ; i++){
      if(h.get(arr[i])==1)dist_count++;
      if(dist_count==k)return arr[i];
    }
    return-1 ;
  }
  public static void main(String[] args){
    int ar[]={
      1,2,1,3,4,2 };
      int n=ar.length ;
      System.out.println(printKDistinct(ar,n,2));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation printKDistinct( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var h : Map(int,int) ; h := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (h->keys()->includes(arr[i+1])) then     h := h->union(Map{arr[i+1] |-> h->at(arr[i+1]) + 1}) ; else     h := h->union(Map{arr[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
    if (h.size() < k) then     return -1 else skip ; 
    var dist_count : int ; dist_count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (h->at(arr[i+1]) = 1) then     dist_count := dist_count + 1 ; else skip ; 
     if (dist_count = k) then     return arr[i+1] else skip )  ;     i := i + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ar : Sequence(int) ; ar := Sequence{1,2,1,3,4,2} ;
     var n : int ; n := ar->size() ;
     OclFile["System.out"].println(printKDistinct(ar, n, 2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  final static int MAX=100 ;
  static void smallestInRow(int mat[][],int n,int m){
    System.out.print(" { ");
    for(int i=0 ; i<n ; i++){
      int minm=mat[i][0];
      for(int j=1 ; j<m ; j++){
        if(mat[i][j]<minm){
          minm=mat[i][j];
        }
      }
      System.out.print(minm+",");
    }
    System.out.println("}");
  }
  static void smallestInCol(int mat[][],int n,int m){
    System.out.print(" { ");
    for(int i=0 ; i<m ; i++){
      int minm=mat[0][i];
      for(int j=1 ; j<n ; j++){
        if(mat[j][i]<minm){
          minm=mat[j][i];
        }
      }
      System.out.print(minm+",");
    }
    System.out.print("}");
  }
  public static void main(String args[]){
    int n=3,m=3 ;
    int mat[][]={
      {
        2,1,7 },{
          3,7,2 },{
            5,4,9 }
          };
          System.out.print("Minimum element of each row is ");
          smallestInRow(mat,n,m);
          System.out.print("\nMinimum element of each column is ");
          smallestInCol(mat,n,m);
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100;
  static   operation smallestInRow( mat : Sequence(Sequence(int)), n : int, m : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(" { ") ; 
         var i : int ; i := 0 ; while i < n do ( (     var minm : int ; minm := mat[i+1][0+1] ;
         var j : int ; j := 1 ; while j < m do ( (     if (mat[i+1][j+1] < minm) then (     minm := mat[i+1][j+1] ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print(minm + ",") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("}") );
  static   operation smallestInCol( mat : Sequence(Sequence(int)), n : int, m : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(" { ") ; 
         var i : int ; i := 0 ; while i < m do ( (     var minm : int ; minm := mat[0+1][i+1] ;
         var j : int ; j := 1 ; while j < n do ( (     if (mat[j+1][i+1] < minm) then (     minm := mat[j+1][i+1] ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print(minm + ",") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("}") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
    var m : int ; m := 3 ;
     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{2,1,7},Sequence{3,7,2},Sequence{5,4,9}} ;
    OclFile["System.out"].print("Minimum element of each row is ") ; 
    execute smallestInRow(mat, n, m) ; 
    OclFile["System.out"].print("\nMinimum element of each column is ") ; 
    execute smallestInCol(mat, n, m) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minAbsDiff(int n){
    int mod=n % 4 ;
    if(mod==0 || mod==3){
      return 0 ;
    }
    return 1 ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(minAbsDiff(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minAbsDiff( n : int) : int
  pre: true
  post: true
  activity: (     var mod : int ; mod := n mod 4 ;
     if (mod = 0 or mod = 3) then (     return 0 ) else skip ; 
     return 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(minAbsDiff(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(true){
      int n=stdIn.nextInt();
      int k=stdIn.nextInt();
      int s=stdIn.nextInt();
      if(n==0 && k==0 && s==0)break ;
      int ans=solve(n,k,s);
      System.out.println(ans);
    }
  }
  public static int solve(int n,int k,int s){
    int ret=0 ;
    for(int i=n ; i>0 ; i--){
      ret+=solv(n,k-1,s-i,i);
    }
    return ret ;
  }
  public static int solv(int n,int k,int s,int l){
    if(s<0)return 0 ;
    if(s==0 && k==0)return 1 ;
    if(s==0 && k>0)return 0 ;
    if(s!=0 && k<0)return 0 ;
    int ret=0 ;
    for(int i=l-1 ; i>0 ; i--){
      ret+=solv(n,k-1,s-i,i);
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     var k : int ; k := stdIn.getCurrent()->toInteger() ;
    var s : int ; s := stdIn.getCurrent()->toInteger() ;
    if (n = 0 & k = 0 & s = 0) then     break else skip ; 
    var ans : int ; ans := solve(n, k, s) ;
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation solve( n : int, k : int, s : int) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
         var i : int ; i := n ; while i > 0 do ( (     ret := ret+(solv(n, k - 1, s - i, i)) )  ;     i := i - 1 ) ; 
     return ret );
  static   operation solv( n : int, k : int, s : int, l : int) : int
  pre: true
  post: true
  activity: (     if (s < 0) then     return 0 else skip ; 
     if (s = 0 & k = 0) then     return 1 else skip ; 
    if (s = 0 & k > 0) then     return 0 else skip ; 
    if (s /= 0 & k < 0) then     return 0 else skip ; 
    var ret : int ; ret := 0 ;
        var i : int ; i := l - 1 ; while i > 0 do ( (     ret := ret+(solv(n, k - 1, s - i, i)) )  ;     i := i - 1 ) ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static int[][][] dp ;
  static boolean solve(){
    int N=in.nextInt();
    int K=in.nextInt();
    int S=in.nextInt();
    if(N+K+S==0)return false ;
    dp=new int[11][30][200];
    dp[0][0][0]=1 ;
    for(int i=0 ; i<10 ; i++){
      for(int j=0 ; j<30 ; j++){
        for(int k=0 ; k<200 ; k++){
          for(int l=j+1 ; l<=N ; l++){
            if(k+l<200)dp[i+1][l][k+l]+=dp[i][j][k];
          }
        }
      }
    }
    int ans=0 ;
    for(int j=1 ; j<=N ; j++){
      ans+=dp[K][j][S];
    }
    out.println(ans);
    return true ;
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    while(solve());
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   attribute dp : Sequence(Sequence(Sequence(int)));
  static   operation solve() : boolean
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
     var K : int ; K := in.getCurrent()->toInteger() ;
    var S : int ; S := in.getCurrent()->toInteger() ;
    if (N + K + S = 0) then     return false else skip ; 
    dp := Integer.subrange(1,11)->collect(Integer.subrange(1,30)->collect(Integer.subrange(1,200)->collect(0))) ; 
    dp[0+1][0+1][0+1] := 1 ; 
        var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < 30 do ( (         var k : int ; k := 0 ; while k < 200 do ( (         var l : int ; l := j + 1 ; while l <= N do ( (     if (k + l < 200) then     dp[i + 1+1][l+1][k + l+1] := dp[i + 1+1][l+1][k + l+1]+(dp[i+1][j+1][k+1]) ; else skip )  ;     l := l + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var j : int ; j := 1 ; while j <= N do ( (     ans := ans+(dp[K+1][j+1][S+1]) )  ;     j := j + 1 ) ; 
    skip ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    while (solve()) do  ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,k,s,i,j ;
    for(; ; ){
      n=sc.nextInt();
      k=sc.nextInt();
      s=sc.nextInt();
      if(n==0 && k==0 && s==0)break ;
      out.println(solve(n,k,s));
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
  private static int solve(int n,int k,int s){
    if(k==0 && s==0)return 1 ;
    if(n==0)return 0 ;
    return solve(n-1,k-1,s-n)+solve(n-1,k,s);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var k : int ;
    var s : int ;
    var i : int ;
    var j : int ;
       while true do ( (     n := sc.nextInt() ; 
     k := sc.nextInt() ; 
    s := sc.nextInt() ; 
    if (n = 0 & k = 0 & s = 0) then     break else skip ; 
    out.println(solve(n, k, s)) ; 
 )  ) ; 
     sc.close() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
  static   operation solve( n : int, k : int, s : int) : int
  pre: true
  post: true
  activity: (     if (k = 0 & s = 0) then     return 1 else skip ; 
     if (n = 0) then     return 0 else skip ; 
     return solve(n - 1, k - 1, s - n) + solve(n - 1, k, s) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class Main {
  public static final int N_MAX=20+1 ;
  public static final int K_MAX=10+1 ;
  public static final int S_MAX=155+1 ;
  public static int memo(final int n,final int k,final int s,int[][][] memo){
    if(memo[n][k][s]>=0){
      return memo[n][k][s];
    }
    else if(k==0 && s==0){
      return memo[n][k][s]=1 ;
    }
    else if(k==0){
      return memo[n][k][s]=0 ;
    }
    int ret=0 ;
    for(int next_use_value=1 ; next_use_value<=n ; next_use_value++){
      if(s<next_use_value){
        break ;
      }
      ret+=memo(next_use_value-1,k-1,s-next_use_value,memo);
    }
    return memo[n][k][s]=ret ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[][][] memo=new int[N_MAX][K_MAX][S_MAX];
    for(int n=0 ; n<N_MAX ; n++){
      for(int k=0 ; k<K_MAX ; k++){
        for(int s=0 ; s<S_MAX ; s++){
          memo[n][k][s]=-1 ;
        }
      }
    }
    while(true){
      final int n=sc.nextInt();
      final int k=sc.nextInt();
      final int s=sc.nextInt();
      if(n==0 && k==0 && s==0){
        break ;
      }
      System.out.println(memo(n,k,s,memo));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute N_MAX : int := 20 + 1;
  static    attribute K_MAX : int := 10 + 1;
  static    attribute S_MAX : int := 155 + 1;
  static   operation memo( n : int, k : int, s : int, memo : Sequence(Sequence(Sequence(int)))) : int
  pre: true
  post: true
  activity: (     if (memo[n+1][k+1][s+1] >= 0) then (     return memo[n+1][k+1][s+1] ) else     if (k = 0 & s = 0) then (     return memo[n+1][k+1][s+1] ) else     if (k = 0) then (     return memo[n+1][k+1][s+1] ) else skip ; ;  ;  
     var ret : int ; ret := 0 ;
         var next_use_value : int ; next_use_value := 1 ; while next_use_value <= n do ( (     if (s < next_use_value) then (     break ) else skip ; 
     ret := ret+(memo(next_use_value - 1, k - 1, s - next_use_value, memo)) )  ;     next_use_value := next_use_value + 1 ) ; 
     return memo[n+1][k+1][s+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var memo : Sequence(Sequence(Sequence(int))) ; memo := Integer.subrange(1,N_MAX)->collect(Integer.subrange(1,K_MAX)->collect(Integer.subrange(1,S_MAX)->collect(0))) ;
         var n : int ; n := 0 ; while n < N_MAX do ( (         var k : int ; k := 0 ; while k < K_MAX do ( (         var s : int ; s := 0 ; while s < S_MAX do ( (     memo[n+1][k+1][s+1] := -1 )  ;     s := s + 1 ) )  ;     k := k + 1 ) )  ;     n := n + 1 ) ; 
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    if (n = 0 & k = 0 & s = 0) then (     break ) else skip ; 
    OclFile["System.out"].println(memo(n, k, s, memo)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static int countP(int n,int k){
    if(n==0 || k==0 || k>n)return 0 ;
    if(k==1 || k==n)return 1 ;
    return(k*countP(n-1,k)+countP(n-1,k-1));
  }
  public static void main(String args[]){
    System.out.println(countP(3,2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countP( n : int, k : int) : int
  pre: true
  post: true
  activity: (     if (n = 0 or k = 0 or k > n) then     return 0 else skip ; 
     if (k = 1 or k = n) then     return 1 else skip ; 
     return (k * countP(n - 1, k) + countP(n - 1, k - 1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(countP(3, 2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char arr[][]=new char[3][3];
    for(int i=0 ; i<3 ; i++){
      String str=sc.nextLine();
      arr[i][0]=str.charAt(0);
      arr[i][1]=str.charAt(1);
      arr[i][2]=str.charAt(2);
    }
    int flag=0 ;
    if(arr[0][0]==arr[2][2] && arr[0][2]==arr[2][0] && arr[1][0]==arr[1][2] && arr[0][1]==arr[2][1]){
      flag=1 ;
    }
    if(flag==1){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(Sequence(String)) ; arr := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < 3 do ( (     var str : String ; str := sc.nextLine() ;
     arr[i+1][0+1] := str->at(0+1) ; 
     arr[i+1][1+1] := str->at(1+1) ; 
     arr[i+1][2+1] := str->at(2+1) )  ;     i := i + 1 ) ; 
    var flag : int ; flag := 0 ;
    if (arr[0+1][0+1] = arr[2+1][2+1] & arr[0+1][2+1] = arr[2+1][0+1] & arr[1+1][0+1] = arr[1+1][2+1] & arr[0+1][1+1] = arr[2+1][1+1]) then (     flag := 1 ) else skip ; 
    if (flag = 1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class SuperAgent {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    char[][] A=new char[3][3];
    for(int x=0 ; x<3 ; x++){
      String s=scan.nextLine();
      for(int y=0 ; y<3 ; y++){
        A[x][y]=s.charAt(y);
      }
    }
    String res="YES" ;
    if(A[0][0]!=A[2][2]){
      res="NO" ;
    }
    if(A[2][0]!=A[0][2]){
      res="NO" ;
    }
    if(A[0][1]!=A[2][1]){
      res="NO" ;
    }
    if(A[1][0]!=A[1][2]){
      res="NO" ;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class SuperAgent {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : Sequence(Sequence(String)) ; A := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
        var x : int ; x := 0 ; while x < 3 do ( (     var s : String ; s := scan.nextLine() ;
         var y : int ; y := 0 ; while y < 3 do ( (     A[x+1][y+1] := s->at(y+1) )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
    var res : String ; res := "YES" ;
    if (A[0+1][0+1] /= A[2+1][2+1]) then (     res := "NO" ) else skip ; 
    if (A[2+1][0+1] /= A[0+1][2+1]) then (     res := "NO" ) else skip ; 
    if (A[0+1][1+1] /= A[2+1][1+1]) then (     res := "NO" ) else skip ; 
    if (A[1+1][0+1] /= A[1+1][2+1]) then (     res := "NO" ) else skip ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.geom.Rectangle2D ;
public class Main {
  private static final double EPS=1e-10 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextDouble()){
      double x,y,w,h ;
      x=sc.nextDouble()-EPS ;
      y=sc.nextDouble()-EPS ;
      w=sc.nextDouble()-x+EPS ;
      h=sc.nextDouble()-y+EPS ;
      Rectangle2D r=new Rectangle2D.Double(x,y,w,h);
      x=sc.nextDouble();
      y=sc.nextDouble();
      w=sc.nextDouble()-x ;
      h=sc.nextDouble()-y ;
      System.out.println(r.intersects(x,y,w,h)? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute EPS : double := 1e-10;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextDouble()) do (     var x : double ;
    var y : double ;
    var w : double ;
    var h : double ;
     x := sc.getCurrent()->toReal() - EPS ; 
    y := sc.getCurrent()->toReal() - EPS ; 
    w := sc.getCurrent()->toReal() - x + EPS ; 
    h := sc.getCurrent()->toReal() - y + EPS ; 
    var r : Rectangle2D ; r := Double.newDouble(x, y, w, h) ;
    x := sc.getCurrent()->toReal() ; 
    y := sc.getCurrent()->toReal() ; 
    w := sc.getCurrent()->toReal() - x ; 
    h := sc.getCurrent()->toReal() - y ; 
    OclFile["System.out"].println(if r.intersects(x, y, w, h) then "YES" else "NO" endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
import java.math.MathContext ;
import java.util.Arrays ;
public class JavaApplication4 {
  public static boolean issorted(int arr[]){
    boolean sorted=true ;
    for(int i=1 ; i<arr.length ; i++){
      if(arr[i-1]>arr[i]){
        sorted=false ;
        break ;
      }
    }
    return sorted ;
  }
  public static int muchsorted(int arr[]){
    int max=0,sortedlength=1 ;
    for(int i=1 ; i<arr.length ; i++){
      if(arr[i-1]<=arr[i]){
        sortedlength++;
      }
      else {
        max=(max<sortedlength ? sortedlength : max);
        sortedlength=1 ;
      }
    }
    return max>=sortedlength ? max : sortedlength ;
  }
  public static int loop(int arr[]){
    if(issorted(arr)){
      System.out.println(arr.length);
    }
    else {
      loop((muchsorted(Arrays.copyOfRange(arr,0,arr.length/2))>muchsorted(Arrays.copyOfRange(arr,arr.length/2,arr.length))? Arrays.copyOfRange(arr,0,arr.length/2): Arrays.copyOfRange(arr,arr.length/2,arr.length)));
    }
    return arr.length ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n,arr[];
    n=in.nextInt();
    arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
    }
    loop(arr);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication4 {
  static   operation issorted( arr : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var sorted : boolean ; sorted := true ;
         var i : int ; i := 1 ; while i < arr->size() do ( (     if (arr[i - 1+1] > arr[i+1]) then (     sorted := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     return sorted );
  static   operation muchsorted( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var max : int ; max := 0 ;
    var sortedlength : int ; sortedlength := 1 ;
         var i : int ; i := 1 ; while i < arr->size() do ( (     if (arr[i - 1+1] <= arr[i+1]) then (     sortedlength := sortedlength + 1 ) else (     max := (if max < sortedlength then sortedlength else max endif) ; 
     sortedlength := 1 ) )  ;     i := i + 1 ) ; 
     return if max >= sortedlength then max else sortedlength endif );
  static   operation loop( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (issorted(arr)) then (     OclFile["System.out"].println(arr->size()) ) else (     execute loop((if muchsorted(arr.subrange(0+1,arr->size() / 2)) > muchsorted(arr.subrange(arr->size() / 2+1,arr->size())) then arr.subrange(0+1,arr->size() / 2) else arr.subrange(arr->size() / 2+1,arr->size()) endif)) ) ;  
     return arr->size() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var arr : Sequence(void) ;
    n := in.getCurrent()->toInteger() ; 
    arr := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute loop(arr) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countSolutions(int a){
    int count=Integer.bitCount(a);
    count=(int)Math.pow(2,count);
    return count ;
  }
  public static void main(String[] args){
    int a=3 ;
    System.out.println(countSolutions(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSolutions( a : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := bitCount(a) ;
     count := 2->pow(count)->oclAsType(int) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
     OclFile["System.out"].println(countSolutions(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class No2_9_17 {
  public static void main(String[] args){
    char[][] a=new char[3][3];
    Scanner c=new Scanner(System.in);
    for(int i=0 ; i<3 ; i++){
      String str=c.next();
      a[i]=str.toCharArray();
    }
    if(a[0][0]==a[2][2] && a[0][1]==a[2][1] && a[0][2]==a[2][0] && a[1][0]==a[1][2]){
      System.out.println("YES");
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class No2_9_17 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
     var c : OclFile ; c := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var i : int ; i := 0 ; while i < 3 do ( (     var str : String ; str := c.getCurrent() ;
     a[i+1] := str->characters() )  ;     i := i + 1 ) ; 
     if (a[0+1][0+1] = a[2+1][2+1] & a[0+1][1+1] = a[2+1][1+1] & a[0+1][2+1] = a[2+1][0+1] & a[1+1][0+1] = a[1+1][2+1]) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    Character[] pressed=new Character[9];
    for(int i=0 ; i<3 ; i++){
      String line=in.nextLine().trim();
      pressed[i*3]=line.charAt(0);
      pressed[i*3+1]=line.charAt(1);
      pressed[i*3+2]=line.charAt(2);
    }
    boolean result=true ;
    for(int i=0 ; i<4 ; i++){
      if(pressed[i]!=pressed[8-i]){
        result=false ;
      }
    }
    System.out.println(result ? "YES" : "NO");
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pressed : Sequence(String) ; pressed := Integer.subrange(1,9)->collect(null) ;
        var i : int ; i := 0 ; while i < 3 do ( (     var line : String ; line := in.nextLine()->trim() ;
     pressed[i * 3+1] := line->at(0+1) ; 
     pressed[i * 3 + 1+1] := line->at(1+1) ; 
     pressed[i * 3 + 2+1] := line->at(2+1) )  ;     i := i + 1 ) ; 
    var result : boolean ; result := true ;
        var i : int ; i := 0 ; while i < 4 do ( (     if (pressed[i+1] /= pressed[8 - i+1]) then (     result := false ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if result then "YES" else "NO" endif) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SuperAgent {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String one=in.nextLine();
    String two=in.nextLine();
    String three=in.nextLine();
    String all=one+two+three ;
    int n=all.length();
    char[] reverse=new char[n];
    for(int i=0 ; i<n ; i++){
      reverse[n-i-1]=all.charAt(i);
    }
    String res=String.copyValueOf(reverse);
    if(all.equals(res)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SuperAgent {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var one : String ; one := in.nextLine() ;
    var two : String ; two := in.nextLine() ;
    var three : String ; three := in.nextLine() ;
    var all : String ; all := one + two + three ;
    var n : int ; n := all->size() ;
    var reverse : Sequence(String) ; reverse := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     reverse[(n)->char2byte() - i - 1+1] := all->at(i+1) )  ;     i := i + 1 ) ; 
    var res : String ; res := (reverse)->sum() ;
    if (all = res) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int calculate(String N){
    int len=N.length();
    int l=(len)/2 ;
    int count=0 ;
    for(int i=1 ; i<=l ; i++){
      String s=N.substring(0,i);
      int l1=s.length();
      String t=N.substring(i,l1+i);
      if(s.charAt(0)=='0' || t.charAt(0)=='0')continue ;
      if(s.compareTo(t)==0)count++;
    }
    return count ;
  }
  public static void main(String[] args){
    String N="2202200" ;
    System.out.print(calculate(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculate( N : String) : int
  pre: true
  post: true
  activity: (     var len : int ; len := N->size() ;
     var l : int ; l := (len) / 2 ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= l do ( (     var s : String ; s := N.subrange(0+1,i) ;
     var l1 : int ; l1 := s->size() ;
    var t : String ; t := N.subrange(i+1,l1 + i) ;
    if (s->at(0+1) = '0' or t->at(0+1) = '0') then     continue else skip ; 
    if (s->compareTo(t) = 0) then     count := count + 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : String ; N := "2202200" ;
     OclFile["System.out"].print(calculate(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int N=Integer.parseInt(s.next());
    int Q=Integer.parseInt(s.next());
    int[] ar=new int[N];
    TreeSet<Integer>set=new TreeSet<Integer>();
    int max_val=0 ;
    for(int i=0 ; i<N ; i++){
      int c=Integer.parseInt(s.next());
      ar[i]=c ;
      set.add(c);
      max_val=Math.max(max_val,c);
    }
    for(int i=0 ; i<Q ; i++){
      int q=Integer.parseInt(s.next());
      int ans=0 ;
      if(q<100){
        for(int j=0 ; j<N ; j++){
          ans=Math.max(ans,ar[j] % q);
        }
      }
      else {
        for(int j=q ; j<=max_val ; j+=q){
          Integer v=set.lower(j);
          if(v==null)continue ;
          ans=Math.max(ans,(int)(v)% q);
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (s.getCurrent())->toInteger() ;
    var Q : int ; Q := (s.getCurrent())->toInteger() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,N)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
    var max_val : int ; max_val := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var c : int ; c := (s.getCurrent())->toInteger() ;
     ar[i+1] := c ; 
     set := set->including(c) ; 
     max_val := Set{max_val, c}->max() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Q do ( (     var q : int ; q := (s.getCurrent())->toInteger() ;
     var ans : int ; ans := 0 ;
     if (q < 100) then (         var j : int ; j := 0 ; while j < N do ( (     ans := Set{ans, ar[j+1] mod q}->max() )  ;     j := j + 1 ) ) else (         var j : int ; j := q ; while j <= max_val do ( (     var v : int ; v := set.lower(j) ;
     if (v = null) then     continue else skip ; 
     ans := Set{ans, (v)->oclAsType(int) mod q}->max() )  ;     j := j+(q) ) ) ;  
     OclFile["System.out"].println(ans) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int N=parseInt(line.substring(0,line.indexOf(' ')));
      int Q=parseInt(line.substring(line.indexOf(' ')+1));
      boolean[] cs=new boolean[300001];
      int max=0 ;
      StringTokenizer st=new StringTokenizer(br.readLine());
      while(st.hasMoreTokens()){
        int c=parseInt(st.nextToken());
        cs[c]=true ;
        max=Math.max(max,c);
      }
      for(int i=0 ; i<Q ; i++){
        int q=parseInt(br.readLine());
        int j=q-1 ;
        found : for(;
        j>=1 ;
        j--){
          for(int k=j ; k<=max ; k+=q){
            if(cs[k])break found ;
          }
        }
        System.out.println(j);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var N : int ; N := parseInt(line.subrange(0+1,line->indexOf(' ')-1)) ;
     var Q : int ; Q := parseInt(line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1)) ;
    var cs : Sequence(boolean) ; cs := Integer.subrange(1,300001)->collect(false) ;
    var max : int ; max := 0 ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    while (st.hasNext()) do (     var c : int ; c := parseInt(st.next()) ;
     cs[c+1] := true ; 
     max := Set{max, c}->max() ) ; 
        var i : int ; i := 0 ; while i < Q do ( (     var q : int ; q := parseInt(br.readLine()) ;
     var j : int ; j := q - 1 ;
       while j >= 1 do ( (         var k : int ; k := j ; while k <= max do ( (     if (cs[k+1]) then     break else skip )  ;     k := k+(q) ) )  ;     j := j - 1 ) ; 
     OclFile["System.out"].println(j) )  ;     i := i + 1 ) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static final int MAX=300000 ;
  boolean[] T ;
  int[] L ;
  void solve(){
    int N,Q,q,x ;
    T=new boolean[MAX+1];
    L=new int[MAX+1];
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    Q=sc.nextInt();
    for(int i=0 ; i<N ; i++){
      x=sc.nextInt();
      T[x]=true ;
    }
    int m=0 ;
    for(int i=1 ; i<=MAX ; i++){
      L[i]=m ;
      if(T[i])m=i ;
    }
    for(int i=0 ; i<Q ; i++){
      q=sc.nextInt();
      int maxv=0 ;
      int cur=m ;
      while(cur>0){
        int p=cur % q ;
        maxv=Math.max(maxv,p);
        if(cur-p<0)break ;
        cur=L[cur-p];
      }
      System.out.println(maxv);
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 300000;
   attribute T : Sequence(boolean);
   attribute L : Sequence(int);
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : int ;
    var Q : int ;
    var q : int ;
    var x : int ;
     T := Integer.subrange(1,MAX + 1)->collect(false) ; 
    L := Integer.subrange(1,MAX + 1)->collect(0) ; 
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    N := sc.getCurrent()->toInteger() ; 
    Q := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < N do ( (     x := sc.getCurrent()->toInteger() ; 
     T[x+1] := true )  ;     i := i + 1 ) ; 
    var m : int ; m := 0 ;
        var i : int ; i := 1 ; while i <= MAX do ( (     L[i+1] := m ; 
     if (T[i+1]) then     m := i ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Q do ( (     q := sc.getCurrent()->toInteger() ; 
     var maxv : int ; maxv := 0 ;
    var cur : int ; cur := m ;
    while (cur > 0) do (     var p : int ; p := cur mod q ;
     maxv := Set{maxv, p}->max() ; 
     if (cur - p < 0) then     break else skip ; 
     cur := L[cur - p+1] ) ; 
    OclFile["System.out"].println(maxv) ; 
 )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static int search(int[] c,int lt){
    for(int i=lt ; i>=0 ; i--){
      if(Arrays.binarySearch(c,i)>=0){
        return Arrays.binarySearch(c,i);
      }
    }
    return-1 ;
  }
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int N=stdIn.nextInt();
    int Q=stdIn.nextInt();
    int[] c=new int[N];
    for(int i=0 ; i<N ; i++){
      c[i]=stdIn.nextInt();
    }
    Arrays.sort(c);
    for(int i=0 ; i<Q ; i++){
      int max=0 ;
      int q=stdIn.nextInt();
      for(int j=c.length-1 ; j>=0 ; j--){
        if(c[j] % q>max)max=c[j] % q ;
        int tmp=search(c,c[j]-c[j] % q-1);
        if(tmp==-1){
          break ;
        }
        else {
          j=tmp+1 ;
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation search( c : Sequence(int), lt : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := lt ; while i >= 0 do ( (     if ((c->indexOf(i) - 1) >= 0) then (     return (c->indexOf(i) - 1) ) else skip )  ;     i := i - 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := stdIn.getCurrent()->toInteger() ;
    var Q : int ; Q := stdIn.getCurrent()->toInteger() ;
    var c : Sequence(int) ; c := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     c[i+1] := stdIn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    c := c->sort() ; 
        var i : int ; i := 0 ; while i < Q do ( (     var max : int ; max := 0 ;
     var q : int ; q := stdIn.getCurrent()->toInteger() ;
         var j : int ; j := c->size() - 1 ; while j >= 0 do ( (     if (c[j+1] mod q > max) then     max := c[j+1] mod q ; else skip ; 
     var tmp : int ; tmp := search(c, c[j+1] - c[j+1] mod q - 1) ;
     if (tmp = -1) then (     break ) else (     j := tmp + 1 ) )  ;     j := j - 1 ) ; 
     OclFile["System.out"].println(max) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int q=scanner.nextInt();
    boolean[] b=new boolean[300001];
    while(n-->0){
      b[scanner.nextInt()]=true ;
    }
    loop : while(q-->0){
      int m=scanner.nextInt();
      for(int res=m-1 ; res>=0 ; res--){
        for(int i=res ; i<=300000 ; i+=m){
          if(b[i]){
            System.out.println(res);
            continue loop ;
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var q : int ; q := scanner.getCurrent()->toInteger() ;
    var b : Sequence(boolean) ; b := Integer.subrange(1,300001)->collect(false) ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     b[scanner.getCurrent()->toInteger()+1] := true ) ;  ) ;  
        while (q > 0) do (        q := q - 1 ;     skip ; (     var m : int ; m := scanner.getCurrent()->toInteger() ;
         var res : int ; res := m - 1 ; while res >= 0 do ( (         var i : int ; i := res ; while i <= 300000 do ( (     if (b[i+1]) then (     OclFile["System.out"].println(res) ; 
     continue ) else skip )  ;     i := i+(m) ) )  ;     res := res - 1 ) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static int getThanosArray(int[] arr,int low,int high){
    if(low==high){
      return 1 ;
    }
    int half=(high-low+1)>>1 ;
    int m=low+half ;
    int ans1=getThanosArray(arr,low,m-1);
    int ans2=getThanosArray(arr,m,high);
    return arr[m]>=arr[m-1] && ans1==ans2 && ans1==half ? ans1+ans2 : Math.max(ans1,ans2);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      arr[i]=sc.nextInt();
    }
    System.out.println(getThanosArray(arr,1,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation getThanosArray( arr : Sequence(int), low : int, high : int) : int
  pre: true
  post: true
  activity: (     if (low = high) then (     return 1 ) else skip ; 
     var half : int ; half := ((high - low + 1)/(2->pow(1)))->oclAsType(long) ;
    var m : int ; m := low + half ;
    var ans1 : int ; ans1 := getThanosArray(arr, low, m - 1) ;
    var ans2 : int ; ans2 := getThanosArray(arr, m, high) ;
    return if arr[m+1] >= arr[m - 1+1] & ans1 = ans2 & ans1 = half then ans1 + ans2 else Set{ans1, ans2}->max() endif 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(getThanosArray(arr, 1, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class pair {
    int first,second ;
    pair(){
      first=0 ;
      second=0 ;
    }
  }
  static void printIndices(int n,pair a[]){
    for(int i=0 ; i<n ; i++)System.out.print(a[i] .second+" ");
    System.out.println();
  }
  static class sort implements Comparator<pair>{
    public int compare(pair a,pair b){
      return a.first<b.first ?-1 : 1 ;
    }
  }
  static void printPermutations(int n,int a[],int k){
    pair arr[]=new pair[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=new pair();
      arr[i] .first=a[i];
      arr[i] .second=i ;
    }
    Arrays.sort(arr,new sort());
    int count=1 ;
    for(int i=1 ; i<n ; i++)if(arr[i] .first==arr[i-1] .first)count++;
    if(count<k){
      System.out.print("-1");
      return ;
    }
    for(int i=0 ; i<k-1 ; i++){
      printIndices(n,arr);
      for(int j=1 ; j<n ; j++){
        if(arr[j] .first==arr[j-1] .first){
          pair t=arr[j];
          arr[j]=arr[j-1];
          arr[j-1]=t ;
          break ;
        }
      }
    }
    printIndices(n,arr);
  }
  public static void main(String arsg[]){
    int a[]={
      1,3,3,1 };
      int n=a.length ;
      int k=3 ;
      printPermutations(n,a,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class pair {
   attribute first : int;
   static operation newpair() : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     first := 0 ; 
     second := 0 );
}
  static   operation printIndices( n : int, a : Sequence(pair)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(a[i+1]->at("second") + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static class sort implements Function(<pair>,(<pair>,boolean)) {
   operation compare( a : pair, b : pair) : int
  pre: true
  post: true
  activity: (     return if a->at("first") < b->at("first") then -1 else 1 endif );
}
  static   operation printPermutations( n : int, a : Sequence(int), k : int) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(pair) ; arr := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := pair.newpair() ; 
     arr[i+1]->at("first") := a[i+1] ; 
     arr[i+1]->at("second") := i )  ;     i := i + 1 ) ; 
    arr := OclComparator.sortWith(arr, sort.newsort()) ; 
    var count : int ; count := 1 ;
        var i : int ; i := 1 ; while i < n do (     if (arr[i+1]->at("first") = arr[i - 1+1]->at("first")) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
    if (count < k) then (     OclFile["System.out"].print("-1") ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < k - 1 do ( (     execute printIndices(n, arr) ; 
         var j : int ; j := 1 ; while j < n do ( (     if (arr[j+1]->at("first") = arr[j - 1+1]->at("first")) then (     var t : pair ; t := arr[j+1] ;
     arr[j+1] := arr[j - 1+1] ; 
     arr[j - 1+1] := t ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    execute printIndices(n, arr) ; 
 );
  static   operation main( arsg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,3,3,1} ;
     var n : int ; n := a->size() ;
     var k : int ; k := 3 ;
     execute printPermutations(n, a, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Solution {
  static PrintWriter pw ;
  static FastScanner s ;
  public static void main(String[] args)throws Exception {
    pw=new PrintWriter(System.out);
    s=new FastScanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      long n=s.nextLong();
      long m=s.nextLong();
      long ans=(n*(n+1))/2 ;
      ans--;
      ans*=m ;
      ans+=(m*(m+1))/2 ;
      pw.println(ans);
    }
    pw.flush();
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public FastScanner(String s)throws Exception {
    br=new BufferedReader(new FileReader(new File(s)));
  }
  public String next()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(next());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute pw : OclFile;
  static   attribute s : FastScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     pw := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     s := FastScanner.newFastScanner(OclFile["System.in"]) ; 
    var t : int ; t := s.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := s.nextLong() ;
     var m : long ; m := s.nextLong() ;
    var ans : long ; ans := (n * (n + 1)) / 2 ;
    ans := ans - 1 ; 
    ans := ans*(m) ; 
    ans := ans+((m * (m + 1)) / 2) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int countNumbers(int n){
    int c=0 ;
    int limit=(int)Math.sqrt(n);
    int prime[]=new int[limit+1];
    for(int i=1 ; i<=limit ; i++){
      prime[i]=i ;
    }
    for(int i=2 ; i*i<=limit ; i++){
      if(prime[i]==i){
        for(int j=i*i ; j<=limit ; j+=i){
          if(prime[j]==j){
            prime[j]=i ;
          }
        }
      }
    }
    for(int i=2 ; i<=limit ; i++){
      int p=prime[i];
      int q=prime[i/prime[i] ];
      if(p*q==i && q!=1 && p!=q){
        c+=1 ;
      }
      else if(prime[i]==i){
        if(Math.pow(i,8)<=n){
          c+=1 ;
        }
      }
    }
    return c ;
  }
  public static void main(String[] args){
    int n=1000 ;
    System.out.println(countNumbers(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countNumbers( n : int) : int
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
     var limit : int ; limit := (n)->sqrt()->oclAsType(int) ;
    var prime : Sequence(int) ; prime := Integer.subrange(1,limit + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= limit do ( (     prime[i+1] := i )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i * i <= limit do ( (     if (prime[i+1] = i) then (         var j : int ; j := i * i ; while j <= limit do ( (     if (prime[j+1] = j) then (     prime[j+1] := i ) else skip )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= limit do ( (     var p : int ; p := prime[i+1] ;
     var q : int ; q := prime[i / prime[i+1]+1] ;
     if (p * q = i & q /= 1 & p /= q) then (     c := c+(1) ) else     if (prime[i+1] = i) then (     if (i->pow(8) <= n) then (     c := c+(1) ) else skip ) else skip ; )  ;     i := i + 1 ) ; 
    return c 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1000 ;
     OclFile["System.out"].println(countNumbers(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static int solve(int n,int m,int k){
    int t=n/k ;
    if(m<=t)return m ;
    m=m-t ;
    if(m %(k-1)==0)m=m/(k-1);
    else m=m/(k-1)+1 ;
    return t-m ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int k=sc.nextInt();
      System.out.println(solve(n,m,k));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation solve( n : int, m : int, k : int) : int
  pre: true
  post: true
  activity: (     var t : int ; t := n / k ;
     if (m <= t) then     return m else skip ; 
    m := m - t ; 
    if (m mod (k - 1) = 0) then     m := m / (k - 1) else     m := m / (k - 1) + 1 ; ;  
    return t - m 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(n, m, k)) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public final class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    for(int t=1 ; t<=T ; t++){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int k=sc.nextInt();
      int c=n/k ;
      if(m<=c){
        System.out.println(m);
      }
      else {
        m-=c ;
        k--;
        int rem_max=(int)Math.ceil((double)m/k);
        System.out.println(Math.max(0,c-rem_max));
      }
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var t : int ; t := 1 ; while t <= T do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var c : int ; c := n / k ;
    if (m <= c) then (     OclFile["System.out"].println(m) ) else (     m := m-(c) ; 
     k := k - 1 ; 
     var rem_max : int ; rem_max := (m->oclAsType(double) / k)->ceil()->oclAsType(int) ;
     OclFile["System.out"].println(Set{0, c - rem_max}->max()) ) ;  
 )  ;     t := t + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    while(t-->0){
      int n=scan.nextInt();
      int m=scan.nextInt();
      int k=scan.nextInt();
      int a=n/k ;
      if(a>=m){
        System.out.println(m);
      }
      else {
        int d=a ;
        int e=(int)Math.ceil(1.0*(m-a)/(k-1));
        System.out.println(d-e);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var m : int ; m := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var a : int ; a := n / k ;
    if (a >= m) then (     OclFile["System.out"].println(m) ) else (     var d : int ; d := a ;
     var e : int ; e := (1.0 * (m - a) / (k - 1))->ceil()->oclAsType(int) ;
     OclFile["System.out"].println(d - e) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int k=sc.nextInt();
      if(m==0)System.out.println(0);
      else if(m<=n/k)System.out.println(m);
      else {
        int left=m-(n/k);
        int other=(int)(Math.ceil(1.0*left/(k-1)));
        System.out.println((n/k)-other);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     if (m = 0) then     OclFile["System.out"].println(0) ; else     if (m <= n / k) then     OclFile["System.out"].println(m) else (     var left : int ; left := m - (n / k) ;
     var other : int ; other := ((1.0 * left / (k - 1))->ceil())->oclAsType(int) ;
     OclFile["System.out"].println((n / k) - other) ) ;  )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt(),Q=sc.nextInt();
    int A[]=new int[Q],B[]=new int[N];
    for(int i=0 ; i<Q ; i++)A[i]=sc.nextInt();
    for(int i=0 ; i<Q ; i++){
      for(int j=0 ; j<N ; j++){
        int r=sc.nextInt();
        if(A[i]==r)B[j]++;
        else B[A[i]-1]++;
      }
    }
    for(int i=0 ; i<N ; i++)System.out.println(B[i]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var Q : int ; Q := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,Q)->collect(0) ;
    var B : Sequence(void) ; B := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < Q do (     A[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Q do ( (         var j : int ; j := 0 ; while j < N do ( (     var r : int ; r := sc.getCurrent()->toInteger() ;
     if (A[i+1] = r) then     B[j+1] := B[j+1] + 1 ; else     B[A[i+1] - 1+1] := B[A[i+1] - 1+1] + 1 ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do (     OclFile["System.out"].println(B[i+1]) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    int N=parseInt(br.readLine());
    int[] points=new int[N+1];
    int M=parseInt(br.readLine());
    int[] targets=new int[M];
    StringTokenizer st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<M ; i++){
      targets[i]=parseInt(st.nextToken());
    }
    for(int i=0 ; i<M ; i++){
      st=new StringTokenizer(br.readLine());
      for(int j=0 ; j<N ; j++){
        int a=parseInt(st.nextToken());
        if(a==targets[i]){
          points[j+1]++;
        }
        else {
          points[targets[i] ]++;
        }
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int i=1 ; i<N+1 ; i++){
      sb.append(points[i]).append("\n");
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var N : int ; N := parseInt(br.readLine()) ;
    var points : Sequence(int) ; points := Integer.subrange(1,N + 1)->collect(0) ;
    var M : int ; M := parseInt(br.readLine()) ;
    var targets : Sequence(int) ; targets := Integer.subrange(1,M)->collect(0) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < M do ( (     targets[i+1] := (st.next() + "")->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
         var j : int ; j := 0 ; while j < N do ( (     var a : int ; a := parseInt(st.next()) ;
     if (a = targets[i+1]) then (     points[j + 1+1] := points[j + 1+1] + 1 ) else (     points[targets[i+1]+1] := points[targets[i+1]+1] + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 1 ; while i < N + 1 do ( (     sb := sb + StringLib.newString(points[i+1]) + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
class Main {
  static final PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=Integer.parseInt(line);
      int m=Integer.parseInt(br.readLine());
      int[] t=new int[m];
      int[] p=new int[n];
      int[][] sel=new int[m][n];
      StringTokenizer st1=new StringTokenizer(br.readLine());
      for(int i=0 ; i<m ; i++)t[i]=Integer.parseInt(st1.nextToken());
      for(int i=0 ; i<m ; i++){
        StringTokenizer st2=new StringTokenizer(br.readLine());
        for(int j=0 ; j<n ; j++){
          sel[i][j]=Integer.parseInt(st2.nextToken());
        }
      }
      for(int i=0 ; i<m ; i++){
        int cnt=n ;
        for(int j=0 ; j<n ; j++){
          if(sel[i][j]==t[i]){
            p[j]++;
            cnt--;
          }
        }
        p[t[i]-1]+=cnt ;
      }
      for(int i=0 ; i<n ; i++)out.println(p[i]);
      out.flush();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := (line)->toInteger() ;
     var m : int ; m := (br.readLine())->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,m)->collect(0) ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    var sel : Sequence(Sequence(int)) ; sel := Integer.subrange(1,m)->collect(Integer.subrange(1,n)->collect(0)) ;
    var st1 : OclIterator ; st1 := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < m do (     t[i+1] := (st1.next())->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var st2 : OclIterator ; st2 := OclIterator.newOclIterator_String(br.readLine()) ;
         var j : int ; j := 0 ; while j < n do ( (     sel[i+1][j+1] := (st2.next())->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var cnt : int ; cnt := n ;
         var j : int ; j := 0 ; while j < n do ( (     if (sel[i+1][j+1] = t[i+1]) then (     p[j+1] := p[j+1] + 1 ; 
     cnt := cnt - 1 ) else skip )  ;     j := j + 1 ) ; 
     p[t[i+1] - 1+1] := p[t[i+1] - 1+1]+(cnt) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     skip ;  ;     i := i + 1 ) ; 
    skip ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static int toggleLastMBits(int n,int m){
    int num=(1<<m)-1 ;
    return(n ^ num);
  }
  public static void main(String argc[]){
    int n=107 ;
    int m=4 ;
    n=toggleLastMBits(n,m);
    System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation toggleLastMBits( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := ((1*(2->pow(m)))->oclAsType(long)) - 1 ;
     return (n xor num) );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 107 ;
     var m : int ; m := 4 ;
     n := toggleLastMBits(n, m) ; 
     OclFile["System.out"].println(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int human=sc.nextInt();
    int playedgame=sc.nextInt();
    int[] points=new int[human];
    int[] tag=new int[playedgame];
    int missct=0 ;
    for(int i=0 ; i<playedgame ; i++)tag[i]=sc.nextInt();
    for(int target : tag){
      for(int i=0 ; i<human ; i++){
        int vote=sc.nextInt();
        if(vote-1==target-1)points[i]++;
        else missct++;
      }
      points[target-1]+=missct ;
      missct=0 ;
    }
    for(int pt : points)System.out.println(pt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var human : int ; human := sc.getCurrent()->toInteger() ;
    var playedgame : int ; playedgame := sc.getCurrent()->toInteger() ;
    var points : Sequence(int) ; points := Integer.subrange(1,human)->collect(0) ;
    var tag : Sequence(int) ; tag := Integer.subrange(1,playedgame)->collect(0) ;
    var missct : int ; missct := 0 ;
        var i : int ; i := 0 ; while i < playedgame do (     tag[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    for (target : tag) do ( (         var i : int ; i := 0 ; while i < human do ( (     var vote : int ; vote := sc.getCurrent()->toInteger() ;
     if (vote - 1 = target - 1) then     points[i+1] := points[i+1] + 1 ; else     missct := missct + 1 ; )  ;     i := i + 1 ) ; 
     points[target - 1+1] := points[target - 1+1]+(missct) ; 
     missct := 0 )  ) ; 
    for (pt : points) do (     OclFile["System.out"].println(pt) ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static Scanner s=new Scanner(System.in);
  public static void main(String[] args){
    int[] points=new int[s.nextInt()];
    int[] targets=new int[s.nextInt()];
    for(int i=0 ; i<targets.length ; i++)targets[i]=s.nextInt();
    int c ;
    for(int t : targets){
      c=0 ;
      for(int j=0 ; j<points.length ; ++j){
        if(t==s.nextInt())points[j]++;
        else c++;
      }
      points[t-1]+=c ;
    }
    for(int i : points)System.out.println(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var points : Sequence(int) ; points := Integer.subrange(1,s.getCurrent()->toInteger())->collect(0) ;
     var targets : Sequence(int) ; targets := Integer.subrange(1,s.getCurrent()->toInteger())->collect(0) ;
        var i : int ; i := 0 ; while i < targets->size() do (     targets[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var c : int ;
    for (t : targets) do ( (     c := 0 ; 
         var j : int ; j := 0 ; while j < points->size() do ( (     if (t = s.getCurrent()->toInteger()) then     points[j+1] := points[j+1] + 1 ; else     c := c + 1 ; )  ;     j := j + 1 ) ; 
     points[t - 1+1] := points[t - 1+1]+(c) )  ) ; 
    for (i : points) do (     OclFile["System.out"].println(i) ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int tc=input.nextInt();
    work : while(tc-->0){
      long n=input.nextLong();
      long m=input.nextLong()-1L ;
      long first=(m*(m+1))/2 ;
      m++;
      first+=((n*(n+1L))/2L)*m ;
      System.out.println(first);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := input.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : long ; n := input.getCurrent()->toLong() ;
     var m : long ; m := input.getCurrent()->toLong() - 1L ;
    var first : long ; first := (m * (m + 1)) / 2 ;
    m := m + 1 ; 
    first := first+(((n * (n + 1L)) / 2L) * m) ; 
    OclFile["System.out"].println(first) ; 
 ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String smallestPoss(String s,int n){
    String ans="" ;
    int arr[]=new int[10];
    for(int i=0 ; i<n ; i++){
      arr[s.charAt(i)-48]++;
    }
    for(int i=0 ; i<10 ; i++){
      for(int j=0 ; j<arr[i]; j++)ans=ans+String.valueOf(i);
    }
    return ans ;
  }
  public static void main(String[] args){
    int N=15 ;
    String K="325343273113434" ;
    System.out.print(smallestPoss(K,N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation smallestPoss( s : String, n : int) : String
  pre: true
  post: true
  activity: (     var ans : String ; ans := "" ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[s->at(i+1) - 48+1] := arr[s->at(i+1) - 48+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < arr[i+1] do (     ans := ans + ((i) + "") ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 15 ;
     var K : String ; K := "325343273113434" ;
     OclFile["System.out"].print(smallestPoss(K, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Assignment2 {
  static Long n ;
  static Set<Long>s ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextLong();
    s=new HashSet<>();
    for(int i=1 ; i<10 ; i++)for(int j=0 ; j<10 ; j++)find(i,j,0L);
    System.out.println(s.size()-1);
  }
  public static void find(int x,int y,Long c){
    s.add(c);
    Long xx=x+10*c ;
    Long yy=y+10*c ;
    if(xx<=n && xx!=0)find(x,y,xx);
    if(yy<=n && yy!=0)find(x,y,yy);
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Assignment2 {
  static   attribute n : long;
  static   attribute s : Set(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toLong() ; 
    s := Set{} ; 
        var i : int ; i := 1 ; while i < 10 do (         var j : int ; j := 0 ; while j < 10 do (     execute find(i, j, 0L) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s->size() - 1) ; 
 );
  static   operation find( x : int, y : int, c : long) : void
  pre: true
  post: true
  activity: (     s := s->including(c) ; 
     var xx : long ; xx := x + 10 * c ;
    var yy : long ; yy := y + 10 * c ;
    if (xx <= n & xx /= 0) then     execute find(x, y, xx) ; else skip ; 
    if (yy <= n & yy /= 0) then     execute find(x, y, yy) ; else skip ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
import java.util.Set ;
import java.util.StringTokenizer ;
public class UndoubtedlyLuckyNumbers {
  public void solve(){
    FastScanner in=new FastScanner(System.in);
    int n=in.nextInt();
    Set<Integer>set=new HashSet<>();
    for(int x=0 ; x<10 ; x++){
      for(int y=x+1 ; y<10 ; y++){
        for(int L=1 ; L<10 ; L++){
          for(int mask=0 ; mask<1<<L ; mask++){
            int m=0 ;
            for(int i=0 ; i<L ; i++){
              m*=10 ;
              if((1 &(mask>>i))==0)m+=x ;
              else m+=y ;
            }
            if(m>0 && m<=n)set.add(m);
          }
        }
      }
    }
    if(n==1000000000)set.add(1000000000);
    System.out.println(set.size());
  }
  public static void main(String[] args){
    UndoubtedlyLuckyNumbers x=new UndoubtedlyLuckyNumbers();
    x.solve();
  }
  private class FastScanner {
    public BufferedReader r ;
    public StringTokenizer st=null ;
    public FastScanner(InputStream stream){
      r=new BufferedReader(new InputStreamReader(stream),32728);
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(r.readLine());
        }
        catch(IOException e){
          throw new RuntimeException();
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public Long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class UndoubtedlyLuckyNumbers {
   operation solve() : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var n : int ; n := in.nextInt() ;
    var set : Set(int) ; set := Set{} ;
        var x : int ; x := 0 ; while x < 10 do ( (         var y : int ; y := x + 1 ; while y < 10 do ( (         var L : int ; L := 1 ; while L < 10 do ( (         var mask : int ; mask := 0 ; while mask < (1*(2->pow(L)))->oclAsType(long) do ( (     var m : int ; m := 0 ;
         var i : int ; i := 0 ; while i < L do ( (     m := m*(10) ; 
     if ((MathLib.bitwiseAnd(1,((mask/(2->pow(i)))->oclAsType(long)))) = 0) then     m := m+(x) ; else     m := m+(y) ; )  ;     i := i + 1 ) ; 
     if (m > 0 & m <= n) then     set := set->including(m) ; else skip )  ;     mask := mask + 1 ) )  ;     L := L + 1 ) )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
    if (n = 1000000000) then     set := set->including(1000000000) ; else skip ; 
    OclFile["System.out"].println(set->size()) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : UndoubtedlyLuckyNumbers ; x := UndoubtedlyLuckyNumbers.newUndoubtedlyLuckyNumbers() ;
     x.solve() );
 class FastScanner {
   attribute r : OclFile;
   attribute st : OclIterator := null;
   static operation newFastScanner( stream : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32728) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(r.readLine()) )   catch (e : IOException) do (     error ProgramException() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MrKitayutasGift {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String s=scan.nextLine();
    char[] letter=new char[26];
    for(char c='a' ; c<='z' ; c++)letter[c-'a']=c ;
    for(int i=0 ; i<=s.length(); i++){
      for(int j=0 ; j<26 ; j++){
        String curr=s.substring(0,i)+letter[j]+s.substring(i,s.length());
        if(check(curr)){
          System.out.println(curr);
          return ;
        }
      }
    }
    System.out.println("NA");
  }
  static boolean check(String s){
    for(int i=0 ; i<s.length(); i++)if(s.charAt(i)!=s.charAt(s.length()-i-1))return false ;
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class MrKitayutasGift {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scan.nextLine() ;
    var letter : Sequence(String) ; letter := Integer.subrange(1,26)->collect(0) ;
        var c : String ; c := 'a' ; while c <= 'z' do (     letter[(c)->char2byte() - ('a')->char2byte()+1] := c ;  ;     c := c + 1 ) ; 
        var i : int ; i := 0 ; while i <= s->size() do ( (         var j : int ; j := 0 ; while j < 26 do ( (     var curr : String ; curr := s.subrange(0+1,i) + letter[j+1] + s.subrange(i+1,s->size()) ;
     if (check(curr)) then (     OclFile["System.out"].println(curr) ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NA") ; 
 );
  static   operation check( s : String) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() do (     if (s->at(i+1) /= s->at(s->size() - (i)->char2byte() - 1+1)) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test505A {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String str=input.nextLine();
    String result=null ;
    for(char c='a' ; c<='z' ; c++){
      for(int i=0 ; i<=str.length(); i++){
        StringBuffer sb=new StringBuffer();
        if(i==0){
          sb.append(c);
          sb.append(str);
        }
        else if(i==str.length()){
          sb.append(str);
          sb.append(c);
        }
        else {
          sb.append(str.substring(0,i));
          sb.append(c);
          sb.append(str.substring(i,str.length()));
        }
        String newStr=sb.toString();
        String reverseStr=sb.reverse().toString();
        if(newStr.equals(reverseStr)){
          result=reverseStr ;
          break ;
        }
      }
    }
    if(result!=null){
      System.out.println(result);
    }
    else {
      System.out.println("NA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test505A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := input.nextLine() ;
    var result : String ; result := null ;
        var c : String ; c := 'a' ; while c <= 'z' do ( (         var i : int ; i := 0 ; while i <= str->size() do ( (     var sb : String ; sb := StringLib.newString() ;
     if (i = 0) then (     sb := sb + StringLib.newString(c) ; 
     sb := sb + StringLib.newString(str) ) else     if (i = str->size()) then (     sb := sb + StringLib.newString(str) ; 
     sb := sb + StringLib.newString(c) ) else (     sb := sb + StringLib.newString(str.subrange(0+1,i)) ; 
     sb := sb + StringLib.newString(c) ; 
     sb := sb + StringLib.newString(str.subrange(i+1,str->size())) ) ;  ;  
    var newStr : String ; newStr := sb+"" ;
    var reverseStr : String ; reverseStr := sb->reverse()+"" ;
    if (newStr = reverseStr) then (     result := reverseStr ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) )  ;     c := c + 1 ) ; 
    if (result /= null) then (     OclFile["System.out"].println(result) ) else (     OclFile["System.out"].println("NA") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p123 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p123().run());
  }
  private static final int PRIME_LIMIT=1000000 ;
  private static final long THRESHOLD=10000000000L ;
  public String run(){
    int[] primes=Library.listPrimes(PRIME_LIMIT);
    for(int n=5 ; n<=primes.length ; n+=2){
      long rem=(long)n*primes[n-1]*2 ;
      if(rem>THRESHOLD)return Integer.toString(n);
    }
    throw new AssertionError("Not found");
  }
}
------------------------------------------------------------
OCL File:
---------
class p123 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p123.newp123().run()) );
  static    attribute PRIME_LIMIT : int := 1000000;
  static    attribute THRESHOLD : long := 10000000000L;
   operation run() : String
  pre: true
  post: true
  activity: (     var primes : Sequence(int) ; primes := Library.listPrimes(PRIME_LIMIT) ;
         var n : int ; n := 5 ; while n <= primes->size() do ( (     var rem : long ; rem := n->oclAsType(long) * primes[n - 1+1] * 2 ;
     if (rem > THRESHOLD) then     return ((n) + "") else skip )  ;     n := n+(2) ) ; 
     error AssertionException("Not found") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
import static java.lang.Double.parseDouble ;
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
public class Main {
  static BufferedWriter of=null ;
  static {
    try {
      of=new BufferedWriter(new FileWriter(new File("filee.txt")));
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  private static BufferedWriter ifile=null ;
  static {
    try {
      ifile=new BufferedWriter(new FileWriter(String.valueOf(System.in)));
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  private static final BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
  private static final Fast in=new Fast();
  public static void main(String[] args)throws IOException {
    String s=in.next();
    int c1=0 ;
    int c2=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='-')c1++;
      else c2++;
    }
    if(c2==0)System.out.println("YES");
    else if(c1 % c2==0)System.out.println("YES");
    else System.out.println("NO");
  }
  public static class Fast {
    BufferedReader br ;
    StringTokenizer st ;
    public Fast(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public Fast(FileReader f){
      br=new BufferedReader(f);
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return parseInt(next());
    }
    public long nextLong()throws IOException {
      return parseLong(next());
    }
    public double nextDouble()throws IOException {
      return parseDouble(next());
    }
    public float nextFloat()throws IOException {
      return Float.parseFloat(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute of : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     try (     of := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile("filee.txt"))) )   catch (e : IOException) do (     e.printStackTrace() )
;
  static   attribute ifile : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     try (     ifile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(((OclFile["System.in"]) + ""))) )   catch (e : IOException) do (     e.printStackTrace() )
;
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static    attribute in : Fast := Fast.newFast();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.next() ;
     var c1 : int ; c1 := 0 ;
    var c2 : int ; c2 := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '-') then     c1 := c1 + 1 ; else     c2 := c2 + 1 ; )  ;     i := i + 1 ) ; 
    if (c2 = 0) then     OclFile["System.out"].println("YES") else     if (c1 mod c2 = 0) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  ;  
 );
  static class Fast {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFast() : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   static operation newFast( f : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(f) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next() + "")->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return parseDouble(next()) );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf1672b {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      String s=sc.next();
      int a=0,b=0 ;
      boolean f=true ;
      for(char ch : s.toCharArray()){
        if(ch=='A'){
          a++;
        }
        else {
          b++;
          if(a<b){
            System.out.println("NO");
            f=false ;
            break ;
          }
        }
      }
      if(f){
        if(b!=0 && s.charAt(s.length()-1)=='B'){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1672b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : String ; s := sc.getCurrent() ;
     var a : int ; a := 0 ;
    var b : int ; b := 0 ;
    var f : boolean ; f := true ;
    for (ch : s->characters()) do ( (     if (ch = 'A') then (     a := a + 1 ) else (     b := b + 1 ; 
     if (a < b) then (     OclFile["System.out"].println("NO") ; 
     f := false ; 
     break ) else skip ) )  ) ; 
    if (f) then (     if (b /= 0 & s->at(s->size() - 1+1) = 'B') then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else skip ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String a=in.nextLine();
    int b=a.length();
    int x=0,y=0 ;
    for(int i=0 ; i<b ; i++){
      char c=a.charAt(i);
      if(c==45){
        x++;
      }
      else if(c==111){
        y++;
      }
    }
    if(y==0){
      System.out.println("YES");
    }
    else {
      if(x % y==0){
        System.out.println("YES");
      }
      else if(y==1){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := in.nextLine() ;
    var b : int ; b := a->size() ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
        var i : int ; i := 0 ; while i < b do ( (     var c : String ; c := a->at(i+1) ;
     if (c = 45) then (     x := x + 1 ) else     if (c = 111) then (     y := y + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    if (y = 0) then (     OclFile["System.out"].println("YES") ) else (     if (x mod y = 0) then (     OclFile["System.out"].println("YES") ) else     if (y = 1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.nextLine();
    int l=s.length();
    int a=0,b=0 ;
    for(int i=0 ; i<l ; i++){
      if(s.charAt(i)=='-')a++;
      else b++;
    }
    if(b!=0){
      if(a % b==0)System.out.println("YES");
      else System.out.println("NO");
    }
    else System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.nextLine() ;
    var l : int ; l := s->size() ;
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
        var i : int ; i := 0 ; while i < l do ( (     if (s->at(i+1) = '-') then     a := a + 1 ; else     b := b + 1 ; )  ;     i := i + 1 ) ; 
    if (b /= 0) then (     if (a mod b = 0) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) else     OclFile["System.out"].println("YES") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Beta {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int a=0,b=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='o')a++;
      else if(s.charAt(i)=='-')b++;
    }
    if(a==0)System.out.println("YES");
    else if(b % a==0)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Beta {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'o') then     a := a + 1 ; else     if (s->at(i+1) = '-') then     b := b + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    if (a = 0) then     OclFile["System.out"].println("YES") else     if (b mod a = 0) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      long n=sc.nextLong();
      long m=sc.nextLong();
      long sum=0 ;
      for(int i=0 ; i<m ; i++){
        sum+=(i+1);
      }
      for(int i=1 ; i<n ; i++){
        sum+=(i+1)*m ;
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : long ; n := sc.getCurrent()->toLong() ;
     var m : long ; m := sc.getCurrent()->toLong() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     sum := sum+((i + 1)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     sum := sum+((i + 1) * m) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static public int n ;
  static int[] A=new int[50];
  static int[] B=new int[50];
  public Boolean fun(Long bit){
    boolean[][] arr=new boolean[51][51];
    for(int i=0 ; i<=50 ; i++){
      arr[i][i]=true ;
    }
    for(int i=1 ; i<=50 ; i++){
      if((bit &(1L<<i))!=0){
        for(int j=0 ; j<=50 ; j++){
          arr[j][j % i]=true ;
        }
      }
    }
    for(int k=0 ; k<=50 ; k++){
      for(int i=0 ; i<=50 ; i++){
        for(int j=0 ; j<=50 ; j++){
          arr[i][j] |=arr[i][k] & arr[k][j];
        }
      }
    }
    Boolean flag=true ;
    for(int i=0 ; i<n ; i++){
      if(! arr[A[i] ][B[i] ])flag=false ;
    }
    return flag ;
  }
  public void solve(){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      A[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      B[i]=sc.nextInt();
    }
    Long ans=(1L<<51)-1 ;
    if(! fun(ans)){
      System.out.println(-1);
      return ;
    }
    for(int i=51 ; i>=0 ; i--){
      Long tmp=ans & ~(1L<<i);
      if(fun(tmp))ans=tmp ;
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    new Main().solve();
  }
};
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute n : int;
  static   attribute A : Sequence(int) := Integer.subrange(1,50)->collect(0);
  static   attribute B : Sequence(int) := Integer.subrange(1,50)->collect(0);
   operation fun( bit : long) : Boolean
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(boolean)) ; arr := Integer.subrange(1,51)->collect(Integer.subrange(1,51)->collect(false)) ;
         var i : int ; i := 0 ; while i <= 50 do ( (     arr[i+1][i+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 50 do ( (     if ((bit & ((1L*(2->pow(i)))->oclAsType(long))) /= 0) then (         var j : int ; j := 0 ; while j <= 50 do ( (     arr[j+1][j mod i+1] := true )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k <= 50 do ( (         var i : int ; i := 0 ; while i <= 50 do ( (         var j : int ; j := 0 ; while j <= 50 do ( (     arr[i+1][j+1] := MathLib.bitwiseOr(arr[i+1][j+1], arr[i+1][k+1] & arr[k+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    var flag : Boolean ; flag := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (not(arr[A[i+1]+1][B[i+1]+1])) then     flag := false ; else skip )  ;     i := i + 1 ) ; 
    return flag 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     B[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := ((1L*(2->pow(51)))->oclAsType(long)) - 1 ;
    if (not(fun(ans))) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
        var i : int ; i := 51 ; while i >= 0 do ( (     var tmp : long ; tmp := MathLib.bitwiseAnd(ans,-(((1L*(2->pow(i)))->oclAsType(long)) + 1)) ;
     if (fun(tmp)) then     ans := tmp ; else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}
;

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static public int n ;
  static int[] A=new int[50];
  static int[] B=new int[50];
  public Boolean fun(Long bit){
    boolean[][] arr=new boolean[51][51];
    for(int i=0 ; i<=50 ; i++){
      arr[i][i]=true ;
    }
    for(int i=1 ; i<=50 ; i++){
      if((bit &(1L<<i))!=0){
        for(int j=0 ; j<=50 ; j++){
          arr[j][j % i]=true ;
        }
      }
    }
    for(int k=0 ; k<=50 ; k++){
      for(int i=0 ; i<=50 ; i++){
        for(int j=0 ; j<=50 ; j++){
          arr[i][j] |=arr[i][k] & arr[k][j];
        }
      }
    }
    Boolean flag=true ;
    for(int i=0 ; i<n ; i++){
      if(! arr[A[i] ][B[i] ])flag=false ;
    }
    return flag ;
  }
  public void solve(){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      A[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      B[i]=sc.nextInt();
    }
    Long ans=(1L<<50)-1 ;
    if(! fun(ans)){
      System.out.println(-1);
      return ;
    }
    for(int i=50 ; i>=0 ; i--){
      Long tmp=ans & ~(1L<<i);
      if(fun(tmp))ans=tmp ;
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    new Main().solve();
  }
};
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute n : int;
  static   attribute A : Sequence(int) := Integer.subrange(1,50)->collect(0);
  static   attribute B : Sequence(int) := Integer.subrange(1,50)->collect(0);
   operation fun( bit : long) : Boolean
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(boolean)) ; arr := Integer.subrange(1,51)->collect(Integer.subrange(1,51)->collect(false)) ;
         var i : int ; i := 0 ; while i <= 50 do ( (     arr[i+1][i+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 50 do ( (     if ((bit & ((1L*(2->pow(i)))->oclAsType(long))) /= 0) then (         var j : int ; j := 0 ; while j <= 50 do ( (     arr[j+1][j mod i+1] := true )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k <= 50 do ( (         var i : int ; i := 0 ; while i <= 50 do ( (         var j : int ; j := 0 ; while j <= 50 do ( (     arr[i+1][j+1] := MathLib.bitwiseOr(arr[i+1][j+1], arr[i+1][k+1] & arr[k+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    var flag : Boolean ; flag := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (not(arr[A[i+1]+1][B[i+1]+1])) then     flag := false ; else skip )  ;     i := i + 1 ) ; 
    return flag 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     B[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := ((1L*(2->pow(50)))->oclAsType(long)) - 1 ;
    if (not(fun(ans))) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
        var i : int ; i := 50 ; while i >= 0 do ( (     var tmp : long ; tmp := MathLib.bitwiseAnd(ans,-(((1L*(2->pow(i)))->oclAsType(long)) + 1)) ;
     if (fun(tmp)) then     ans := tmp ; else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}
;

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int INT_SIZE=32 ;
  static class TrieNode {
    int value ;
    TrieNode[] arr=new TrieNode[2];
    public TrieNode(){
      value=0 ;
      arr[0]=null ;
      arr[1]=null ;
    }
  }
  static TrieNode root ;
  static void insert(int pre_xor){
    TrieNode temp=root ;
    for(int i=INT_SIZE-1 ; i>=0 ; i--){
      int val=(pre_xor &(1<<i))>=1 ? 1 : 0 ;
      if(temp.arr[val]==null)temp.arr[val]=new TrieNode();
      temp=temp.arr[val];
    }
    temp.value=pre_xor ;
  }
  static int query(int pre_xor){
    TrieNode temp=root ;
    for(int i=INT_SIZE-1 ; i>=0 ; i--){
      int val=(pre_xor &(1<<i))>=1 ? 1 : 0 ;
      if(temp.arr[1-val]!=null)temp=temp.arr[1-val];
      else if(temp.arr[val]!=null)temp=temp.arr[val];
    }
    return pre_xor ^(temp.value);
  }
  static int maxSubarrayXOR(int arr[],int n){
    root=new TrieNode();
    insert(0);
    int result=Integer.MIN_VALUE ;
    int pre_xor=0 ;
    for(int i=0 ; i<n ; i++){
      pre_xor=pre_xor ^ arr[i];
      insert(pre_xor);
      result=Math.max(result,query(pre_xor));
    }
    return result ;
  }
  public static void main(String args[]){
    int arr[]={
      8,1,2,12 };
      int n=arr.length ;
      System.out.println("Max subarray XOR is "+maxSubarrayXOR(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute INT_SIZE : int := 32;
  static class TrieNode {
   attribute value : int;
   attribute arr : Sequence(TrieNode) := Integer.subrange(1,2)->collect(null);
   static operation newTrieNode() : TrieNode
  pre: true
  post: true
  activity:
  ( var self : TrieNode ;
    self := createTrieNode();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     value := 0 ; 
     arr[0+1] := null ; 
     arr[1+1] := null );
}
  static   attribute root : TrieNode;
  static   operation insert( pre_xor : int) : void
  pre: true
  post: true
  activity: (     var temp : TrieNode ; temp := root ;
         var i : int ; i := INT_SIZE - 1 ; while i >= 0 do ( (     var val : int ; val := if (MathLib.bitwiseAnd(pre_xor,((1*(2->pow(i)))->oclAsType(long)))) >= 1 then 1 else 0 endif ;
     if (temp.arr[val+1] = null) then     temp.arr[val+1] := TrieNode.newTrieNode() ; else skip ; 
     temp := temp.arr[val+1] )  ;     i := i - 1 ) ; 
     temp.value := pre_xor );
  static   operation query( pre_xor : int) : int
  pre: true
  post: true
  activity: (     var temp : TrieNode ; temp := root ;
         var i : int ; i := INT_SIZE - 1 ; while i >= 0 do ( (     var val : int ; val := if (MathLib.bitwiseAnd(pre_xor,((1*(2->pow(i)))->oclAsType(long)))) >= 1 then 1 else 0 endif ;
     if (temp.arr[1 - val+1] /= null) then     temp := temp.arr[1 - val+1] ; else     if (temp.arr[val+1] /= null) then     temp := temp.arr[val+1] ; else skip ; )  ;     i := i - 1 ) ; 
     return pre_xor xor (temp.value) );
  static   operation maxSubarrayXOR( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     root := TrieNode.newTrieNode() ; 
     execute insert(0) ; 
    var result : int ; result := -2147483648 ;
    var pre_xor : int ; pre_xor := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     pre_xor := MathLib.bitwiseXor(pre_xor,arr[i+1]) ; 
     execute insert(pre_xor) ; 
     result := Set{result, query(pre_xor)}->max() )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,1,2,12} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Max subarray XOR is " + maxSubarrayXOR(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    ArrayList<Integer>arr=new ArrayList<>(100);
    Integer n=scanner.nextInt();
    Integer one=1,lar=1 ;
    for(int i=0 ; i<n ; i++){
      arr.add(scanner.nextInt());
      if(arr.get(i)==1)one=i ;
      if(arr.get(i)==n)lar=i ;
    }
    ArrayList<Integer>ans=new ArrayList<>(5);
    ans.add(one);
    ans.add(n-one-1);
    ans.add(lar);
    ans.add(n-lar-1);
    Integer Answer=0 ;
    for(int i=0 ; i<4 ; i++){
      if(Answer<ans.get(i))Answer=ans.get(i);
    }
    System.out.println(Answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(int) ; arr := Sequence{} ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var one : int ; one := 1 ;
    var lar : int ; lar := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     arr := arr->including(scanner.getCurrent()->toInteger()) ; 
     if (arr->at(i+1) = 1) then     one := i ; else skip ; 
     if (arr->at(i+1) = n) then     lar := i ; else skip )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Sequence{} ;
    ans := ans->including(one) ; 
    ans := ans->including(n - one - 1) ; 
    ans := ans->including(lar) ; 
    ans := ans->including(n - lar - 1) ; 
    var Answer : int ; Answer := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     if (Answer < ans->at(i+1)) then     Answer := ans->at(i+1) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.Reader ;
import java.util.StringTokenizer ;
public class Main {
  public Main(){
    FastScanner input=new FastScanner(System.in);
    int n=input.nextInt();
    int[] arr=new int[n];
    int minIndex=0 ;
    int maxIndex=0 ;
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=input.nextInt();
      if(arr[i]>arr[maxIndex]){
        maxIndex=i ;
      }
      if(arr[i]<arr[minIndex]){
        minIndex=i ;
      }
    }
    int maxMin=Math.max(minIndex,n-minIndex-1);
    int maxMax=Math.max(maxIndex,n-maxIndex-1);
    System.out.println(Math.max(maxMin,maxMax));
  }
  public static void main(String[] args){
    new Main();
  }
  class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(Reader in){
      br=new BufferedReader(in);
    }
    public FastScanner(InputStream in){
      this(new InputStreamReader(in));
    }
    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 long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var n : int ; n := input.nextInt() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var minIndex : int ; minIndex := 0 ;
    var maxIndex : int ; maxIndex := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := input.nextInt() ; 
     if (arr[i+1] > arr[maxIndex+1]) then (     maxIndex := i ) else skip ; 
     if (arr[i+1] < arr[minIndex+1]) then (     minIndex := i ) else skip )  ;     i := i + 1 ) ; 
    var maxMin : int ; maxMin := Set{minIndex, n - minIndex - 1}->max() ;
    var maxMax : int ; maxMax := Set{maxIndex, n - maxIndex - 1}->max() ;
    OclFile["System.out"].println(Set{maxMin, maxMax}->max()) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
 class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(in) );
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     execute this(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class test {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int n=Integer.parseInt(br.readLine());
    int[] a=new int[n];
    String[] input=br.readLine().split(" ");
    int minIndex=0 ;
    int maxIndex=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(input[i]);
      if(a[i]==1)minIndex=i ;
      else if(a[i]==n)maxIndex=i ;
    }
    minIndex++;
    maxIndex++;
    if(minIndex>maxIndex){
      pw.println(Math.max(n-maxIndex,minIndex-1));
    }
    else {
      pw.println(Math.max(maxIndex-1,n-minIndex));
    }
    pw.flush();
    pw.close();
    br.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var input : Sequence(String) ; input := br.readLine()->split(" ") ;
    var minIndex : int ; minIndex := 0 ;
    var maxIndex : int ; maxIndex := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (input[i+1])->toInteger() ; 
     if (a[i+1] = 1) then     minIndex := i ; else     if (a[i+1] = n) then     maxIndex := i ; else skip ; )  ;     i := i + 1 ) ; 
    minIndex := minIndex + 1 ; 
    maxIndex := maxIndex + 1 ; 
    if (minIndex > maxIndex) then (     skip ) else (     skip ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class loveAAB {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t,ca=0 ;
    boolean kq ;
    t=Integer.parseInt(sc.nextLine());
    String a ;
    String b ;
    while(t--!=0){
      a=sc.nextLine();
      kq=true ;
      ca=0 ;
      for(int i=0 ; i<a.length(); i++){
        if(a.charAt(i)=='A'){
          ca++;
        }
        if(a.charAt(i)=='B'){
          ca--;
          if(ca<0){
            kq=false ;
          }
        }
      }
      if(a.charAt(0)=='B'){
        kq=false ;
      }
      if(a.charAt(a.length()-1)=='A'){
        kq=false ;
      }
      if(kq==false){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class loveAAB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ;
    var ca : int ; ca := 0 ;
    var kq : boolean ;
    t := (sc.nextLine())->toInteger() ; 
    var a : String ;
    var b : String ;
        while (t /= 0) do (    skip ; (     a := sc.nextLine() ; 
     kq := true ; 
    ca := 0 ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     if (a->at(i+1) = 'A') then (     ca := ca + 1 ) else skip ; 
     if (a->at(i+1) = 'B') then (     ca := ca - 1 ; 
     if (ca < 0) then (     kq := false ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (a->at(0+1) = 'B') then (     kq := false ) else skip ; 
    if (a->at(a->size() - 1+1) = 'A') then (     kq := false ) else skip ; 
    if (kq = false) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication111 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    int least=10000 ;
    int most=0 ;
    int leastId=0 ;
    int mostId=0 ;
    for(int i=0 ; i<num ; i++){
      int h=sc.nextInt();
      if(h<least){
        least=h ;
        leastId=i ;
      }
      if(h>most){
        most=h ;
        mostId=i ;
      }
    }
    if(Math.abs(mostId-leastId)==num-2){
      System.out.println(Math.abs(mostId-leastId)+1);
    }
    else if(Math.abs(mostId-leastId)==num-1){
      System.out.println(Math.abs(mostId-leastId));
    }
    else {
      System.out.println(Math.abs(mostId-leastId)+Math.max(Math.min((num-1)-mostId,(num-1)-leastId),Math.min(mostId,leastId)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication111 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
    var least : int ; least := 10000 ;
    var most : int ; most := 0 ;
    var leastId : int ; leastId := 0 ;
    var mostId : int ; mostId := 0 ;
        var i : int ; i := 0 ; while i < num do ( (     var h : int ; h := sc.getCurrent()->toInteger() ;
     if (h < least) then (     least := h ; 
     leastId := i ) else skip ; 
     if (h > most) then (     most := h ; 
     mostId := i ) else skip )  ;     i := i + 1 ) ; 
    if (if mostId - leastId < 0 then -(mostId - leastId) else mostId - leastId endif = num - 2) then (     OclFile["System.out"].println(if mostId - leastId < 0 then -(mostId - leastId) else mostId - leastId endif + 1) ) else     if (if mostId - leastId < 0 then -(mostId - leastId) else mostId - leastId endif = num - 1) then (     OclFile["System.out"].println(if mostId - leastId < 0 then -(mostId - leastId) else mostId - leastId endif) ) else (     OclFile["System.out"].println(if mostId - leastId < 0 then -(mostId - leastId) else mostId - leastId endif + Set{Set{(num - 1) - mostId, (num - 1) - leastId}->min(), Set{mostId, leastId}->min()}->max()) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class pair {
    int first,second ;
    public pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static int sumSubarrayMins(int A[],int n){
    int[] left=new int[n];
    int[] right=new int[n];
    Stack<pair>s1=new Stack<pair>();
    Stack<pair>s2=new Stack<pair>();
    for(int i=0 ; i<n ; ++i){
      int cnt=1 ;
      while(! s1.isEmpty()&&(s1.peek().first)>A[i]){
        cnt+=s1.peek().second ;
        s1.pop();
      }
      s1.push(new pair(A[i],cnt));
      left[i]=cnt ;
    }
    for(int i=n-1 ; i>=0 ; --i){
      int cnt=1 ;
      while(! s2.isEmpty()&&(s2.peek().first)>=A[i]){
        cnt+=s2.peek().second ;
        s2.pop();
      }
      s2.push(new pair(A[i],cnt));
      right[i]=cnt ;
    }
    int result=0 ;
    for(int i=0 ; i<n ; ++i)result=(result+A[i]*left[i]*right[i]);
    return result ;
  }
  public static void main(String[] args){
    int A[]={
      3,1,2,4 };
      int n=A.length ;
      System.out.println(sumSubarrayMins(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class pair {
   attribute first : int;
   static operation newpair( first : int, second : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation sumSubarrayMins( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var left : Sequence(int) ; left := Integer.subrange(1,n)->collect(0) ;
     var right : Sequence(int) ; right := Integer.subrange(1,n)->collect(0) ;
    var s1 : Sequence(pair) ; s1 := Sequence{} ;
    var s2 : Sequence(pair) ; s2 := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var cnt : int ; cnt := 1 ;
     while (not(s1->isEmpty()) & (s1->min()->at("first")) > A[i+1]) do (     cnt := cnt+(s1->min()->at("second")) ; 
     s1 := s1->front() ) ; 
     s1 := s1->append(pair.newpair(A[i+1], cnt)) ; 
     left[i+1] := cnt )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     var cnt : int ; cnt := 1 ;
     while (not(s2->isEmpty()) & (s2->min()->at("first")) >= A[i+1]) do (     cnt := cnt+(s2->min()->at("second")) ; 
     s2 := s2->front() ) ; 
     s2 := s2->append(pair.newpair(A[i+1], cnt)) ; 
     right[i+1] := cnt )  ;     i := i - 1 ) ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < n do (     result := (result + A[i+1] * left[i+1] * right[i+1]) ;  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{3,1,2,4} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].println(sumSubarrayMins(A, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Numbers {
  static boolean isValid(int n,int d){
    int digit=n % 10 ;
    int sum=digit ;
    if(digit==d)return false ;
    n/=10 ;
    while(n>0){
      digit=n % 10 ;
      if(digit==d || digit<=sum)return false ;
      else {
        sum+=digit ;
        n/=10 ;
      }
    }
    return true ;
  }
  static void printGoodNumber(int L,int R,int d){
    for(int i=L ; i<=R ; i++){
      if(isValid(i,d))System.out.print(i+" ");
    }
  }
  public static void main(String[] args){
    int L=410,R=520,d=3 ;
    printGoodNumber(L,R,d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Numbers {
  static   operation isValid( n : int, d : int) : boolean
  pre: true
  post: true
  activity: (     var digit : int ; digit := n mod 10 ;
     var sum : int ; sum := digit ;
    if (digit = d) then     return false else skip ; 
    n := n/(10) ; 
    while (n > 0) do (     digit := n mod 10 ; 
     if (digit = d or digit <= sum) then     return false else (     sum := sum+(digit) ; 
     n := n/(10) ) ) ; 
    return true 
 );
  static   operation printGoodNumber( L : int, R : int, d : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := L ; while i <= R do ( (     if (isValid(i, d)) then     OclFile["System.out"].print(i + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 410 ;
    var R : int ; R := 520 ;
    var d : int ; d := 3 ;
     execute printGoodNumber(L, R, d) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int N=Integer.parseInt(br.readLine());
    int count=0 ;
    for(int i=1 ; i<=N ; i+=2){
      int divisor=0 ;
      for(int j=1 ; j<=i ; j++){
        if(i % j==0){
          divisor++;
        }
      }
      if(divisor==8)count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var N : int ; N := (br.readLine())->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     var divisor : int ; divisor := 0 ;
         var j : int ; j := 1 ; while j <= i do ( (     if (i mod j = 0) then (     divisor := divisor + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (divisor = 8) then     count := count + 1 ; else skip )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class cdf802a {
  public static void main(String args[])throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    for(int i=0 ; i<t ; i++){
      String s=br.readLine();
      String str[]=s.split(" ");
      int n=Integer.parseInt(str[0]);
      int m=Integer.parseInt(str[1]);
      long ans=0 ;
      ans+=(m*(m+1))/2 ;
      for(int j=2 ; j<=n ; j++)ans+=m*j ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cdf802a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var s : String ; s := br.readLine() ;
     var str : Sequence(String) ; str := s->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var m : int ; m := (str[1+1])->toInteger() ;
    var ans : long ; ans := 0 ;
    ans := ans+((m * (m + 1)) / 2) ; 
        var j : int ; j := 2 ; while j <= n do (     ans := ans+(m * j) ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    int ans=0 ;
    for(int i=8 ; i<=N ; i++){
      if(i % 2==1 && yaku(i)==8){
        ans++;
      }
    }
    System.out.println(ans);
  }
  public static int yaku(int N){
    int yaku=0 ;
    for(int i=1 ; i<=N ; i++){
      if(N % i==0){
        yaku++;
      }
    }
    return yaku ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 8 ; while i <= N do ( (     if (i mod 2 = 1 & yaku(i) = 8) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) );
  static   operation yaku( N : int) : int
  pre: true
  post: true
  activity: (     var yaku : int ; yaku := 0 ;
         var i : int ; i := 1 ; while i <= N do ( (     if (N mod i = 0) then (     yaku := yaku + 1 ) else skip )  ;     i := i + 1 ) ; 
     return yaku );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n<105){
      System.out.println(0);
    }
    else if(n<135){
      System.out.println(1);
    }
    else if(n<165){
      System.out.println(2);
    }
    else if(n<189){
      System.out.println(3);
    }
    else if(n<195){
      System.out.println(4);
    }
    else {
      System.out.println(5);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n < 105) then (     OclFile["System.out"].println(0) ) else     if (n < 135) then (     OclFile["System.out"].println(1) ) else     if (n < 165) then (     OclFile["System.out"].println(2) ) else     if (n < 189) then (     OclFile["System.out"].println(3) ) else     if (n < 195) then (     OclFile["System.out"].println(4) ) else (     OclFile["System.out"].println(5) ) ;  ;  ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in))){
      final String s=reader.readLine();
      int N=Integer.parseInt(s);
      int ans=0 ;
      for(int i=1 ; i<=N ; i++){
        int cnt=0 ;
        for(int j=1 ; j<=i ; j++){
          if(i % 2==1 && i % j==0)cnt++;
        }
        if(cnt==8)ans++;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var s : String ; s := reader.readLine() ;
     var N : int ; N := (s)->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     var cnt : int ; cnt := 0 ;
         var j : int ; j := 1 ; while j <= i do ( (     if (i mod 2 = 1 & i mod j = 0) then     cnt := cnt + 1 ; else skip )  ;     j := j + 1 ) ; 
     if (cnt = 8) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),cnt=1,tmp ;
    if(n<105){
      System.out.println(0);
      return ;
    }
    for(int m=107 ; m<=n ; m+=2){
      tmp=1 ;
      for(int k=3 ; k<=m ; k+=2){
        if(m % k==0)tmp++;
      }
      if(tmp==8)cnt++;
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var cnt : int ; cnt := 1 ;
    var tmp : int ;
    if (n < 105) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
        var m : int ; m := 107 ; while m <= n do ( (     tmp := 1 ; 
         var k : int ; k := 3 ; while k <= m do ( (     if (m mod k = 0) then     tmp := tmp + 1 ; else skip )  ;     k := k+(2) ) ; 
     if (tmp = 8) then     cnt := cnt + 1 ; else skip )  ;     m := m+(2) ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.pow ;
class Test {
  static void nthprimedigitsnumber(long n){
    long len=1 ;
    long prev_count=0 ;
    while(true){
      long curr_count=(long)(prev_count+pow(4,len));
      if(prev_count<n && curr_count>=n)break ;
      len++;
      prev_count=curr_count ;
    }
    for(int i=1 ; i<=len ; i++){
      for(long j=1 ; j<=4 ; j++){
        if(prev_count+pow(4,len-i)<n)prev_count+=pow(4,len-i);
        else {
          if(j==1)System.out.print("2");
          else if(j==2)System.out.print("3");
          else if(j==3)System.out.print("5");
          else if(j==4)System.out.print("7");
          break ;
        }
      }
    }
    System.out.println();
  }
  public static void main(String args[]){
    nthprimedigitsnumber(10);
    nthprimedigitsnumber(21);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation nthprimedigitsnumber( n : long) : void
  pre: true
  post: true
  activity: (     var len : long ; len := 1 ;
     var prev_count : long ; prev_count := 0 ;
    while (true) do (     var curr_count : long ; curr_count := (prev_count + pow(4, len))->oclAsType(long) ;
     if (prev_count < n & curr_count >= n) then     break else skip ; 
     len := len + 1 ; 
     prev_count := curr_count ) ; 
        var i : int ; i := 1 ; while i <= len do ( (         var j : long ; j := 1 ; while j <= 4 do ( (     if (prev_count + pow(4, len - i) < n) then     prev_count := prev_count+(pow(4, len - i)) ; else (     if (j = 1) then     OclFile["System.out"].print("2") else     if (j = 2) then     OclFile["System.out"].print("3") else     if (j = 3) then     OclFile["System.out"].print("5") else     if (j = 4) then     OclFile["System.out"].print("7") ; else skip ; ;  ;  ;  
     break ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute nthprimedigitsnumber(10) ; 
     execute nthprimedigitsnumber(21) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String first_subString(String s){
    int n=s.length(),c=0 ;
    String s1,s2 ;
    HashMap<String,Integer>mpp=new HashMap<String,Integer>();
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)==' ' || s.charAt(i)=='#'){
        s1=s.substring(c,i);
        mpp.put(s1,1);
        c=i+1 ;
      }
    }
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)==' '){
        continue ;
      }
      for(int j=0 ; j<n ; j++){
        if(s.charAt(i)==' '){
          break ;
        }
        s1=s.substring(i,j-i+1);
        s2=s1 ;
        s1=reverse(s1);
        if(mpp.containsKey(s1)){
          return s2 ;
        }
      }
    }
    return "-1" ;
  }
  static String reverse(String input){
    char[] a=input.toCharArray();
    int l,r=a.length-1 ;
    for(l=0 ; l<r ; l++,r--){
      char temp=a[l];
      a[l]=a[r];
      a[r]=temp ;
    }
    return String.valueOf(a);
  }
  public static void main(String[] args){
    String s,s1 ;
    s="mango is sweet when nam en tastes it#" ;
    s1=first_subString(s);
    System.out.print(s1+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation first_subString( s : String) : String
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
    var c : int ; c := 0 ;
     var s1 : String ;
    var s2 : String ;
    var mpp : Map(String,int) ; mpp := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = ' ' or s->at(i+1) = '#') then (     s1 := s.subrange(c+1,i) ; 
     mpp := mpp->union(Map{s1 |-> 1}) ; 
     c := i + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = ' ') then (     continue ) else skip ; 
         var j : int ; j := 0 ; while j < n do ( (     if (s->at(i+1) = ' ') then (     break ) else skip ; 
     s1 := s.subrange(i+1,j - i + 1) ; 
    s2 := s1 ; 
    s1 := reverse(s1) ; 
    if (mpp->keys()->includes(s1)) then (     return s2 ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return "-1" 
 );
  static   operation reverse( input : String) : String
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := input->characters() ;
     var l : int ;
    var r : int ; r := a->size() - 1 ;
         l := 0 ; while l < r do ( (     var temp : String ; temp := a[l+1] ;
     a[l+1] := a[r+1] ; 
     a[r+1] := temp )  ;     l := l + 1 ;     r := r - 1 ) ; 
     return (a)->sum()  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ;
    var s1 : String ;
     s := "mango is sweet when nam en tastes it#" ; 
     s1 := first_subString(s) ; 
     OclFile["System.out"].print(s1 + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      char[] string=in.next().toCharArray();
      int left=0 ;
      int right=0 ;
      int min=Integer.MAX_VALUE ;
      Map<Character,Integer>unique=new HashMap<>();
      while(right<string.length){
        while(right<string.length && unique.size()<3){
          unique.merge(string[right],1,Integer :: sum);
          right++;
        }
        while(left<right && unique.size()==3){
          min=Math.min(min,right-left);
          unique.merge(string[left],-1,Integer :: sum);
          if(unique.get(string[left])==0){
            unique.remove(string[left]);
          }
          left++;
        }
      }
      System.out.println(min==Integer.MAX_VALUE ? 0 : min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var string : Sequence(String) ; string := in.getCurrent()->characters() ;
     var left : int ; left := 0 ;
    var right : int ; right := 0 ;
    var min : int ; min := 2147483647 ;
    var unique : Map(String,int) ; unique := Map{} ;
    while (right < string->size()) do (     while (right < string->size() & unique.size() < 3) do (     unique := unique.merge(string[right+1], 1, lambda _pars : OclAny in Integer.newInteger().sum(_pars)) ; 
     right := right + 1 ) ; 
     while (left < right & unique.size() = 3) do (     min := Set{min, right - left}->min() ; 
     unique := unique.merge(string[left+1], -1, lambda _pars : OclAny in Integer.newInteger().sum(_pars)) ; 
     if (unique->at(string[left+1]) = 0) then (     unique := unique->antirestrict(Set{string[left+1]}) ) else skip ; 
     left := left + 1 ) ) ; 
    OclFile["System.out"].println(if min = 2147483647 then 0 else min endif) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int runs=sc.nextInt();
    while(runs-->0){
      String in=sc.next();
      char[] arr=in.toCharArray();
      int n=arr.length ;
      int[] last=new int[] {
-n,-n,-n };
        int min=Integer.MAX_VALUE ;
        for(int i=0 ; i<arr.length ; i++){
          last[arr[i]-'1']=i ;
          int dist=1+i-Math.min(Math.min(last[0],last[1]),last[2]);
          min=Math.min(min,dist);
        }
        System.out.println(min>arr.length ? 0 : min);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var runs : int ; runs := sc.getCurrent()->toInteger() ;
         while (runs > 0) do (        runs := runs - 1 ;     skip ; (     var in : String ; in := sc.getCurrent() ;
     var arr : Sequence(String) ; arr := in->characters() ;
    var n : int ; n := arr->size() ;
    var last : Sequence(int) ; last := Sequence{-n,-n,-n} ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     last[arr[i+1] - ('1')->char2byte()+1] := i ; 
     var dist : int ; dist := 1 + i - Set{Set{last[0+1], last[1+1]}->min(), last[2+1]}->min() ;
     min := Set{min, dist}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if min > arr->size() then 0 else min endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Practice {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    for(int i=0 ; i<n ; i++){
      String num=scan.next();
      int i1=-1 ;
      int i2=-1 ;
      int i3=-1 ;
      int ans=0 ;
      for(int j=0 ; j<num.length(); j++){
        if(num.charAt(j)=='1'){
          i1=j ;
        }
        else if(num.charAt(j)=='2'){
          i2=j ;
        }
        else {
          i3=j ;
        }
        if(i1!=-1 && i2!=-1 && i3!=-1){
          int b=Math.max(i1,Math.max(i2,i3))-Math.min(i1,Math.min(i2,i3))+1 ;
          if(ans==0){
            ans=b ;
          }
          else {
            ans=Math.min(ans,b);
          }
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var num : String ; num := scan.getCurrent() ;
     var i1 : int ; i1 := -1 ;
    var i2 : int ; i2 := -1 ;
    var i3 : int ; i3 := -1 ;
    var ans : int ; ans := 0 ;
        var j : int ; j := 0 ; while j < num->size() do ( (     if (num->at(j+1) = '1') then (     i1 := j ) else     if (num->at(j+1) = '2') then (     i2 := j ) else (     i3 := j ) ;  ;  
     if (i1 /= -1 & i2 /= -1 & i3 /= -1) then (     var b : int ; b := Set{i1, Set{i2, i3}->max()}->max() - Set{i1, Set{i2, i3}->min()}->min() + 1 ;
     if (ans = 0) then (     ans := b ) else (     ans := Set{ans, b}->min() ) ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf1354B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    for(int i=0 ; i<t ; i++){
      String in=scan.next();
      int i1=-1 ;
      int i2=-1 ;
      int i3=-1 ;
      int ans=0 ;
      for(int j=0 ; j<in.length(); j++){
        if(in.charAt(j)=='1'){
          i1=j ;
        }
        else if(in.charAt(j)=='2'){
          i2=j ;
        }
        else {
          i3=j ;
        }
        if(i1!=-1 && i2!=-1 && i3!=-1){
          if(ans==0){
            ans=Math.max(Math.max(i1,i2),i3)-Math.min(Math.min(i1,i2),i3)+1 ;
          }
          else {
            ans=Math.min(ans,Math.max(Math.max(i1,i2),i3)-Math.min(Math.min(i1,i2),i3)+1);
          }
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1354B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var in : String ; in := scan.getCurrent() ;
     var i1 : int ; i1 := -1 ;
    var i2 : int ; i2 := -1 ;
    var i3 : int ; i3 := -1 ;
    var ans : int ; ans := 0 ;
        var j : int ; j := 0 ; while j < in->size() do ( (     if (in->at(j+1) = '1') then (     i1 := j ) else     if (in->at(j+1) = '2') then (     i2 := j ) else (     i3 := j ) ;  ;  
     if (i1 /= -1 & i2 /= -1 & i3 /= -1) then (     if (ans = 0) then (     ans := Set{Set{i1, i2}->max(), i3}->max() - Set{Set{i1, i2}->min(), i3}->min() + 1 ) else (     ans := Set{ans, Set{Set{i1, i2}->max(), i3}->max() - Set{Set{i1, i2}->min(), i3}->min() + 1}->min() ) ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class SeatingOnBus {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int m=Integer.parseInt(str[1]);
    int bus[][]=new int[n][4];
    int person=1 ;
    int currentRow=0 ;
    while((person<=m)&& currentRow<n){
      bus[currentRow][0]=person ;
      person++;
      if(person<=m){
        bus[currentRow][3]=person ;
        person++;
      }
      currentRow++;
    }
    currentRow=0 ;
    while((person<=m)&& currentRow<n){
      bus[currentRow][1]=person ;
      person++;
      if(person<=m){
        bus[currentRow][2]=person ;
        person++;
      }
      currentRow++;
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      if(bus[i][1]!=0){
        sb.append(bus[i][1]);
        sb.append(" ");
      }
      if(bus[i][0]!=0){
        sb.append(bus[i][0]);
        sb.append(" ");
      }
      if(bus[i][2]!=0){
        sb.append(bus[i][2]);
        sb.append(" ");
      }
      if(bus[i][3]!=0){
        sb.append(bus[i][3]);
        sb.append(" ");
      }
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class SeatingOnBus {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var m : int ; m := (str[1+1])->toInteger() ;
    var bus : Sequence(Sequence(int)) ; bus := Integer.subrange(1,n)->collect(Integer.subrange(1,4)->collect(0)) ;
    var person : int ; person := 1 ;
    var currentRow : int ; currentRow := 0 ;
    while ((person <= m) & currentRow < n) do (     bus[currentRow+1][0+1] := person ; 
     person := person + 1 ; 
     if (person <= m) then (     bus[currentRow+1][3+1] := person ; 
     person := person + 1 ) else skip ; 
     currentRow := currentRow + 1 ) ; 
    currentRow := 0 ; 
    while ((person <= m) & currentRow < n) do (     bus[currentRow+1][1+1] := person ; 
     person := person + 1 ; 
     if (person <= m) then (     bus[currentRow+1][2+1] := person ; 
     person := person + 1 ) else skip ; 
     currentRow := currentRow + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     if (bus[i+1][1+1] /= 0) then (     sb := sb + StringLib.newString(bus[i+1][1+1]) ; 
     sb := sb + StringLib.newString(" ") ) else skip ; 
     if (bus[i+1][0+1] /= 0) then (     sb := sb + StringLib.newString(bus[i+1][0+1]) ; 
     sb := sb + StringLib.newString(" ") ) else skip ; 
     if (bus[i+1][2+1] /= 0) then (     sb := sb + StringLib.newString(bus[i+1][2+1]) ; 
     sb := sb + StringLib.newString(" ") ) else skip ; 
     if (bus[i+1][3+1] /= 0) then (     sb := sb + StringLib.newString(bus[i+1][3+1]) ; 
     sb := sb + StringLib.newString(" ") ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int N=1000005 ;
  static long MAX=(long)1e18 ;
  static Vector<Long>powers=new Vector<>();
  static TreeSet<Long>squares=new TreeSet<>();
  static TreeSet<Long>s=new TreeSet<>();
  static void powersPrecomputation(){
    for(long i=2 ; i<N ; i++){
      squares.add(i*i);
      if(squares.contains(i))continue ;
      long temp=i ;
      while(i*i<=MAX/temp){
        temp*=(i*i);
        s.add(temp);
      }
    }
    for(long x : s)powers.add(x);
  }
  static long calculateAnswer(long L,long R){
    powersPrecomputation();
    long perfectSquares=(long)(Math.floor(Math.sqrt(R))-Math.floor(Math.sqrt(L-1)));
    long high=Collections.binarySearch(powers,R);
    long low=Collections.binarySearch(powers,L);
    long perfectPowers=perfectSquares+(high-low);
    long ans=(R-L+1)-perfectPowers ;
    return ans ;
  }
  public static void main(String[] args){
    long L=13,R=20 ;
    System.out.println(calculateAnswer(L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 1000005;
  static   attribute MAX : long := 1e18->oclAsType(long);
  static   attribute powers : Sequence(long) := Sequence{};
  static   attribute squares : Set(long) := Set{};
  static   attribute s : Set(long) := Set{};
  static   operation powersPrecomputation() : void
  pre: true
  post: true
  activity: (         var i : long ; i := 2 ; while i < N do ( (     squares := squares->including(i * i) ; 
     if (squares->includes(i)) then     continue else skip ; 
     var temp : long ; temp := i ;
     while (i * i <= MAX / temp) do (     temp := temp*((i * i)) ; 
     s := s->including(temp) ) )  ;     i := i + 1 ) ; 
     for (x : s) do (     powers := powers->including(x) ;  ) );
  static   operation calculateAnswer( L : long, R : long) : long
  pre: true
  post: true
  activity: (     execute powersPrecomputation() ; 
     var perfectSquares : long ; perfectSquares := (((R)->sqrt())->floor() - ((L - 1)->sqrt())->floor())->oclAsType(long) ;
    var high : long ; high := .binarySearch(powers, R) ;
    var low : long ; low := .binarySearch(powers, L) ;
    var perfectPowers : long ; perfectPowers := perfectSquares + (high - low) ;
    var ans : long ; ans := (R - L + 1) - perfectPowers ;
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : long ; L := 13 ;
    var R : long ; R := 20 ;
     OclFile["System.out"].println(calculateAnswer(L, R)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class SeatingOnBus {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int m=Integer.parseInt(str[1]);
    int bus[][]=new int[n][4];
    int person=1 ;
    int currentRow=0 ;
    while((person<=m)&& currentRow<n){
      bus[currentRow][0]=person ;
      person++;
      if(person<=m){
        bus[currentRow][3]=person ;
        person++;
      }
      currentRow++;
    }
    currentRow=0 ;
    while((person<=m)&& currentRow<n){
      bus[currentRow][1]=person ;
      person++;
      if(person<=m){
        bus[currentRow][2]=person ;
        person++;
      }
      currentRow++;
    }
    StringBuffer sb=new StringBuffer();
    for(int i=0 ; i<n ; i++){
      if(bus[i][1]!=0){
        sb.append(bus[i][1]);
        sb.append(" ");
      }
      if(bus[i][0]!=0){
        sb.append(bus[i][0]);
        sb.append(" ");
      }
      if(bus[i][2]!=0){
        sb.append(bus[i][2]);
        sb.append(" ");
      }
      if(bus[i][3]!=0){
        sb.append(bus[i][3]);
        sb.append(" ");
      }
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class SeatingOnBus {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var m : int ; m := (str[1+1])->toInteger() ;
    var bus : Sequence(Sequence(int)) ; bus := Integer.subrange(1,n)->collect(Integer.subrange(1,4)->collect(0)) ;
    var person : int ; person := 1 ;
    var currentRow : int ; currentRow := 0 ;
    while ((person <= m) & currentRow < n) do (     bus[currentRow+1][0+1] := person ; 
     person := person + 1 ; 
     if (person <= m) then (     bus[currentRow+1][3+1] := person ; 
     person := person + 1 ) else skip ; 
     currentRow := currentRow + 1 ) ; 
    currentRow := 0 ; 
    while ((person <= m) & currentRow < n) do (     bus[currentRow+1][1+1] := person ; 
     person := person + 1 ; 
     if (person <= m) then (     bus[currentRow+1][2+1] := person ; 
     person := person + 1 ) else skip ; 
     currentRow := currentRow + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     if (bus[i+1][1+1] /= 0) then (     sb := sb + StringLib.newString(bus[i+1][1+1]) ; 
     sb := sb + StringLib.newString(" ") ) else skip ; 
     if (bus[i+1][0+1] /= 0) then (     sb := sb + StringLib.newString(bus[i+1][0+1]) ; 
     sb := sb + StringLib.newString(" ") ) else skip ; 
     if (bus[i+1][2+1] /= 0) then (     sb := sb + StringLib.newString(bus[i+1][2+1]) ; 
     sb := sb + StringLib.newString(" ") ) else skip ; 
     if (bus[i+1][3+1] /= 0) then (     sb := sb + StringLib.newString(bus[i+1][3+1]) ; 
     sb := sb + StringLib.newString(" ") ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class SeatingOnBus {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int m=Integer.parseInt(str[1]);
    int bus[][]=new int[n][4];
    int person=1 ;
    int currentRow=0 ;
    while((person<=m)&& currentRow<n){
      bus[currentRow][0]=person ;
      person++;
      if(person<=m){
        bus[currentRow][3]=person ;
        person++;
      }
      currentRow++;
    }
    currentRow=0 ;
    while((person<=m)&& currentRow<n){
      bus[currentRow][1]=person ;
      person++;
      if(person<=m){
        bus[currentRow][2]=person ;
        person++;
      }
      currentRow++;
    }
    for(int i=0 ; i<n ; i++){
      if(bus[i][1]!=0){
        System.out.print(bus[i][1]+" ");
      }
      if(bus[i][0]!=0){
        System.out.print(bus[i][0]+" ");
      }
      if(bus[i][2]!=0){
        System.out.print(bus[i][2]+" ");
      }
      if(bus[i][3]!=0){
        System.out.print(bus[i][3]+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SeatingOnBus {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var m : int ; m := (str[1+1])->toInteger() ;
    var bus : Sequence(Sequence(int)) ; bus := Integer.subrange(1,n)->collect(Integer.subrange(1,4)->collect(0)) ;
    var person : int ; person := 1 ;
    var currentRow : int ; currentRow := 0 ;
    while ((person <= m) & currentRow < n) do (     bus[currentRow+1][0+1] := person ; 
     person := person + 1 ; 
     if (person <= m) then (     bus[currentRow+1][3+1] := person ; 
     person := person + 1 ) else skip ; 
     currentRow := currentRow + 1 ) ; 
    currentRow := 0 ; 
    while ((person <= m) & currentRow < n) do (     bus[currentRow+1][1+1] := person ; 
     person := person + 1 ; 
     if (person <= m) then (     bus[currentRow+1][2+1] := person ; 
     person := person + 1 ) else skip ; 
     currentRow := currentRow + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (bus[i+1][1+1] /= 0) then (     OclFile["System.out"].print(bus[i+1][1+1] + " ") ) else skip ; 
     if (bus[i+1][0+1] /= 0) then (     OclFile["System.out"].print(bus[i+1][0+1] + " ") ) else skip ; 
     if (bus[i+1][2+1] /= 0) then (     OclFile["System.out"].print(bus[i+1][2+1] + " ") ) else skip ; 
     if (bus[i+1][3+1] /= 0) then (     OclFile["System.out"].print(bus[i+1][3+1] + " ") ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.stream.Collectors ;
import java.util.stream.Stream ;
public class CodeForces {
  public static final int BUFFERSIZE=512000 ;
  private static Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in),BUFFERSIZE));
  private static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out,BUFFERSIZE));
  public static void solve()throws Exception {
    int n=in.nextInt();
    int m=in.nextInt();
    final int inOrder[]={
      1,1+2*n,2+2*n,2 };
      final int outOrder[]={
        1,0,2,3 };
        for(int i=0 ; i<n ; i++){
          for(int j=0 ; j<4 ; j++){
            int seatIn=inOrder[outOrder[j] ]+i*2 ;
            if(seatIn>m)continue ;
            System.out.print(seatIn+" ");
          }
        }
      }
      public static void main(String args[])throws Exception {
        in.init(System.in);
        solve();
        out.close();
      }
      public static class in {
        static BufferedReader reader ;
        static StringTokenizer tokenizer ;
        static void init(InputStream input){
          reader=new BufferedReader(new InputStreamReader(input),BUFFERSIZE);
          tokenizer=new StringTokenizer("");
        }
        static String next()throws IOException {
          while(! tokenizer.hasMoreTokens())tokenizer=new StringTokenizer(reader.readLine());
          return tokenizer.nextToken();
        }
        static int nextInt()throws IOException {
          return Integer.parseInt(next());
        }
        static double nextDouble()throws IOException {
          return Double.parseDouble(next());
        }
        static long nextLong()throws IOException {
          return Long.parseLong(next());
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static    attribute BUFFERSIZE : int := 512000;
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), BUFFERSIZE));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"], BUFFERSIZE));
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var m : int ; m := in.nextInt() ;
    var inOrder : Sequence(int) ; inOrder := Sequence{1,1 + 2 * n,2 + 2 * n,2} ;
    var outOrder : Sequence(int) ; outOrder := Sequence{1,0,2,3} ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 4 do ( (     var seatIn : int ; seatIn := inOrder[outOrder[j+1]+1] + i * 2 ;
     if (seatIn > m) then     continue else skip ; 
     OclFile["System.out"].print(seatIn + " ") )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in.init(OclFile["System.in"]) ; 
     execute solve() ; 
     skip );
  static class in {
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   operation init( input : OclFile) : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(input), BUFFERSIZE) ; 
     tokenizer := OclIterator.newOclIterator_String("") );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ; ; 
     return tokenizer.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxAND(int L,int R){
    int maximum=L & R ;
    for(int i=L ; i<R ; i++)for(int j=i+1 ; j<=R ; j++)maximum=Math.max(maximum,(i & j));
    return maximum ;
  }
  public static void main(String[] args){
    int L=1,R=632 ;
    System.out.println(maxAND(L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxAND( L : int, R : int) : int
  pre: true
  post: true
  activity: (     var maximum : int ; maximum := MathLib.bitwiseAnd(L,R) ;
         var i : int ; i := L ; while i < R do (         var j : int ; j := i + 1 ; while j <= R do (     maximum := Set{maximum, (MathLib.bitwiseAnd(i,j))}->max() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return maximum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 1 ;
    var R : int ; R := 632 ;
     OclFile["System.out"].println(maxAND(L, R)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
class GFG {
  static int countConsecutive(int n){
    String s=Integer.toString(n);
    int count=0 ;
    for(int i=0 ; i<s.length()-1 ; i++)if(s.charAt(i)==s.charAt(i+1))count++;
    return count ;
  }
  public static void main(String args[]){
    int n=44522255 ;
    System.out.println(countConsecutive(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countConsecutive( n : int) : int
  pre: true
  post: true
  activity: (     var s : String ; s := ((n) + "") ;
     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < s->size() - 1 do (     if (s->at(i+1) = s->at(i + 1+1)) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 44522255 ;
     OclFile["System.out"].println(countConsecutive(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int Minimum_Operations(int[] a,int n){
    int[] np=new int[n+1];
    np[n]=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      np[i]=np[i+1];
      if(a[i]<=0)np[i]++;
    }
    int pos=0 ;
    int ans=n ;
    for(int i=0 ; i<n-1 ; i++){
      if(a[i]>=0)pos++;
      ans=Math.min(ans,pos+np[i+1]);
    }
    return ans ;
  }
  public static void main(String args[]){
    int[] a={
-1,0,1,2 };
      int n=a.length ;
      System.out.print(Minimum_Operations(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Minimum_Operations( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var np : Sequence(int) ; np := Integer.subrange(1,n + 1)->collect(0) ;
     np[n+1] := 0 ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     np[i+1] := np[i + 1+1] ; 
     if (a[i+1] <= 0) then     np[i+1] := np[i+1] + 1 ; else skip )  ;     i := i - 1 ) ; 
    var pos : int ; pos := 0 ;
    var ans : int ; ans := n ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (a[i+1] >= 0) then     pos := pos + 1 ; else skip ; 
     ans := Set{ans, pos + np[i + 1+1]}->min() )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{-1,0,1,2} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(Minimum_Operations(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int K=sc.nextInt();
    for(int i=0 ; i<K ; i++){
      if(A+i<=B){
        System.out.println(A+i);
      }
    }
    for(int j=K-1 ; j>=0 ; j--){
      if(B-j>A+K-1){
        System.out.println(B-j);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < K do ( (     if (A + i <= B) then (     OclFile["System.out"].println(A + i) ) else skip )  ;     i := i + 1 ) ; 
        var j : int ; j := K - 1 ; while j >= 0 do ( (     if (B - j > A + K - 1) then (     OclFile["System.out"].println(B - j) ) else skip )  ;     j := j - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    HashSet<Integer>values=new HashSet<>();
    Scanner input=new Scanner(System.in);
    int a=input.nextInt();
    int b=input.nextInt();
    int k=input.nextInt();
    int acopy=a ;
    StringBuilder out=new StringBuilder();
    for(int i=0 ; i<k && acopy<=b ; i++){
      out.append(acopy).append("\n");
      values.add(acopy);
      acopy++;
    }
    int secandCopy=Math.max(a,b-k)+1 ;
    for(int i=0 ; i<k && secandCopy<=b ; i++){
      if(! values.contains(secandCopy)){
        out.append(secandCopy).append("\n");
        values.add(secandCopy);
      }
      secandCopy++;
    }
    System.out.print(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var values : Set(int) ; values := Set{} ;
     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var a : int ; a := input.getCurrent()->toInteger() ;
    var b : int ; b := input.getCurrent()->toInteger() ;
    var k : int ; k := input.getCurrent()->toInteger() ;
    var acopy : int ; acopy := a ;
    var out : String ; out := StringLib.newString() ;
        var i : int ; i := 0 ; while i < k & acopy <= b do ( (     out := out + StringLib.newString(acopy) + StringLib.newString("\n") ; 
     values := values->including(acopy) ; 
     acopy := acopy + 1 )  ;     i := i + 1 ) ; 
    var secandCopy : int ; secandCopy := Set{a, b - k}->max() + 1 ;
        var i : int ; i := 0 ; while i < k & secandCopy <= b do ( (     if (not(values->includes(secandCopy))) then (     out := out + StringLib.newString(secandCopy) + StringLib.newString("\n") ; 
     values := values->including(secandCopy) ) else skip ; 
     secandCopy := secandCopy + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String args[]){
    FastReader sc=new FastReader();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int k=sc.nextInt();
    int i=a ;
    for(; i<a+k && i<=b ; i++){
      if(i<=b)System.out.println(i);
    }
    i--;
    for(int j=b-k+1 ; j<=b ; j++){
      if(i<j)System.out.println(j);
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var a : int ; a := sc.nextInt() ;
    var b : int ; b := sc.nextInt() ;
    var k : int ; k := sc.nextInt() ;
    var i : int ; i := a ;
      while i < a + k & i <= b do ( (     if (i <= b) then     OclFile["System.out"].println(i) ; else skip )  ;     i := i + 1 ) ; 
    i := i - 1 ; 
        var j : int ; j := b - k + 1 ; while j <= b do ( (     if (i < j) then     OclFile["System.out"].println(j) ; else skip )  ;     j := j + 1 ) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long A=in.nextLong();
    long B=in.nextLong();
    long K=in.nextLong();
    long a=A ;
    long cnt=0 ;
    if(K>B-A){
      K=B-A+1 ;
    }
    while(cnt<K){
      System.out.println(a);
      a++;
      cnt++;
    }
    long cnt2=0 ;
    long b=B-K+1 ;
    while(cnt2<K){
      if(b>=a){
        System.out.println(b);
      }
      cnt2++;
      b++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : long ; A := in.getCurrent()->toLong() ;
    var B : long ; B := in.getCurrent()->toLong() ;
    var K : long ; K := in.getCurrent()->toLong() ;
    var a : long ; a := A ;
    var cnt : long ; cnt := 0 ;
    if (K > B - A) then (     K := B - A + 1 ) else skip ; 
    while (cnt < K) do (     OclFile["System.out"].println(a) ; 
     a := a + 1 ; 
     cnt := cnt + 1 ) ; 
    var cnt2 : long ; cnt2 := 0 ;
    var b : long ; b := B - K + 1 ;
    while (cnt2 < K) do (     if (b >= a) then (     OclFile["System.out"].println(b) ) else skip ; 
     cnt2 := cnt2 + 1 ; 
     b := b + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int k=sc.nextInt();
    if((b-a)<2*k){
      for(int i=a ; i<=b ; i++){
        System.out.println(i);
      }
    }
    else {
      List<Integer>list=new ArrayList<>();
      for(int i=0 ; i<k ; i++){
        list.add(a+i);
        list.add(b-i);
      }
      Collections.sort(list);
      for(int i=0 ; i<list.size(); i++){
        System.out.println(list.get(i));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    if ((b - a) < 2 * k) then (         var i : int ; i := a ; while i <= b do ( (     OclFile["System.out"].println(i) )  ;     i := i + 1 ) ) else (     var list : Sequence(int) ; list := Sequence{} ;
         var i : int ; i := 0 ; while i < k do ( (     list := list->including(a + i) ; 
     list := list->including(b - i) )  ;     i := i + 1 ) ; 
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < list->size() do ( (     OclFile["System.out"].println(list->at(i+1)) )  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.LinkedHashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Map.Entry ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int count=0 ;
    while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      if(count!=0){
        System.out.println();
      }
      Map<String,Integer>map=new LinkedHashMap<String,Integer>();
      List<Integer>list=new ArrayList<Integer>();
      while(n-->0){
        String str=scanner.next();
        int a=scanner.nextInt();
        scanner.next();
        int b=scanner.nextInt();
        int c=a*3+b ;
        map.put(str,c);
        list.add(c);
      }
      Collections.sort(list);
      for(int i=list.size()-1 ; i>=0 ; i--){
        String delete="" ;
        for(Entry<String,Integer>entry : map.entrySet()){
          if(entry.getValue()==list.get(i)){
            System.out.println(entry.getKey()+","+entry.getValue());
            delete=entry.getKey();
            break ;
          }
        }
        map.remove(delete);
      }
      count++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := 0 ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    if (count /= 0) then (     OclFile["System.out"].println() ) else skip ; 
    var map : Map(String,int) ; map := Map{} ;
    var list : Sequence(int) ; list := Sequence{} ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var str : String ; str := scanner.getCurrent() ;
     var a : int ; a := scanner.getCurrent()->toInteger() ;
    skip ; 
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var c : int ; c := a * 3 + b ;
    map := map->union(Map{str |-> c}) ; 
    list := list->including(c) ; 
 ) ;  ) ;  
    list := list->sort() ; 
        var i : int ; i := list->size() - 1 ; while i >= 0 do ( (     var delete : String ; delete := "" ;
     for (entry : map->asSet()) do ( (     if (entry.getValue() = list->at(i+1)) then (     OclFile["System.out"].println(entry.getKey() + "," + entry.getValue()) ; 
     delete := entry.getKey() ; 
     break ) else skip )  ) ; 
     map := map->antirestrict(Set{delete}) )  ;     i := i - 1 ) ; 
    count := count + 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static long dp[][]=new long[1000][1000];
  static long sum(int a[],int i,int j){
    long ans=0 ;
    for(int m=i ; m<=j ; m++)ans=(ans+a[m])% 100 ;
    return ans ;
  }
  static long solve(int a[],int i,int j){
    if(i==j)return 0 ;
    if(dp[i][j]!=-1)return dp[i][j];
    dp[i][j]=100000000 ;
    for(int k=i ; k<j ; k++){
      dp[i][j]=Math.min(dp[i][j],(solve(a,i,k)+solve(a,k+1,j)+(sum(a,i,k)*sum(a,k+1,j))));
    }
    return dp[i][j];
  }
  static void intialize(int n){
    for(int i=0 ; i<=n ; i++)for(int j=0 ; j<=n ; j++)dp[i][j]=-1 ;
  }
  public static void main(String args[]){
    int a[]={
      40,60,20 };
      int n=a.length ;
      intialize(n);
      System.out.println(solve(a,0,n-1));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute dp : long := Integer.subrange(1,1000)->collect(Integer.subrange(1,1000)->collect(0));
  static   operation sum( a : Sequence(int), i : int, j : int) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
         var m : int ; m := i ; while m <= j do (     ans := (ans + a[m+1]) mod 100 ;  ;     m := m + 1 ) ; 
     return ans );
  static   operation solve( a : Sequence(int), i : int, j : int) : long
  pre: true
  post: true
  activity: (     if (i = j) then     return 0 else skip ; 
     if (dp[i+1][j+1] /= -1) then     return dp[i+1][j+1] else skip ; 
    dp[i+1][j+1] := 100000000 ; 
        var k : int ; k := i ; while k < j do ( (     dp[i+1][j+1] := Set{dp[i+1][j+1], (solve(a, i, k) + solve(a, k + 1, j) + (sum(a, i, k) * sum(a, k + 1, j)))}->min() )  ;     k := k + 1 ) ; 
    return dp[i+1][j+1] 
 );
  static   operation intialize( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= n do (         var j : int ; j := 0 ; while j <= n do (     dp[i+1][j+1] := -1 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{40,60,20} ;
     var n : int ; n := a->size() ;
     execute intialize(n) ; 
     OclFile["System.out"].println(solve(a, 0, n - 1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    FastReader in=new FastReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,FastReader in,PrintWriter out){
      int n=in.nextInt();
      int[][] mat=new int[n][n];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          mat[i][j]=in.nextInt();
        }
      }
      int res=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          int col=0,raw=0 ;
          for(int k=0 ; k<n ; k++){
            col+=mat[i][k];
            raw+=mat[k][j];
          }
          if(col<raw)res++;
        }
      }
      out.println(res);
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    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());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : FastReader ; in := FastReader.newFastReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : FastReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var mat : Sequence(Sequence(int)) ; mat := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     mat[i+1][j+1] := in.nextInt() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     var col : int ; col := 0 ;
    var raw : int ; raw := 0 ;
         var k : int ; k := 0 ; while k < n do ( (     col := col+(mat[i+1][k+1]) ; 
     raw := raw+(mat[k+1][j+1]) )  ;     k := k + 1 ) ; 
     if (col < raw) then     res := res + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   static operation newFastReader( is : OclFile) : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileInputStream ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Scanner ;
import java.io.*;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner read=new Scanner(System.in);
    int n=read.nextInt(),arr[][]=new int[n][n],col[]=new int[n],row[]=new int[n],c=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        arr[i][j]=read.nextInt();
        row[i]+=arr[i][j];
        col[j]+=arr[i][j];
      }
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(col[i]>row[j])c++;
      }
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : OclFile ; read := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := read.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(void)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var col : Sequence(void) ; col := Integer.subrange(1,n)->collect(0) ;
    var row : Sequence(void) ; row := Integer.subrange(1,n)->collect(0) ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     arr[i+1][j+1] := read.getCurrent()->toInteger() ; 
     row[i+1] := row[i+1]+(arr[i+1][j+1]) ; 
     col[j+1] := col[j+1]+(arr[i+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (col[i+1] > row[j+1]) then     c := c + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void findAngle(int n){
    int interiorAngle,exteriorAngle ;
    interiorAngle=(n-2)*180/n ;
    exteriorAngle=360/n ;
    System.out.println("Interior angle: "+interiorAngle);
    System.out.println("Exterior angle: "+exteriorAngle);
  }
  public static void main(String[] args){
    int n=10 ;
    findAngle(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findAngle( n : int) : void
  pre: true
  post: true
  activity: (     var interiorAngle : int ;
    var exteriorAngle : int ;
     interiorAngle := (n - 2) * 180 / n ; 
    exteriorAngle := 360 / n ; 
    OclFile["System.out"].println("Interior angle: " + interiorAngle) ; 
    OclFile["System.out"].println("Exterior angle: " + exteriorAngle) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     execute findAngle(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int[] cols=new int[n];
      int[] rows=new int[n];
      for(int i=0 ; i<n ; ++i){
        for(int j=0 ; j<n ; ++j){
          int tmp=in.nextInt();
          rows[i]+=tmp ;
          cols[j]+=tmp ;
        }
      }
      int ans=0 ;
      for(int i=0 ; i<n ; ++i)for(int j=0 ; j<n ; ++j)if(cols[j]>rows[i])++ans ;
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var cols : Sequence(int) ; cols := Integer.subrange(1,n)->collect(0) ;
    var rows : Sequence(int) ; rows := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     var tmp : int ; tmp := in.getCurrent()->toInteger() ;
     rows[i+1] := rows[i+1]+(tmp) ; 
     cols[j+1] := cols[j+1]+(tmp) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (     if (cols[j+1] > rows[i+1]) then     ans := ans + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    int size=Integer.parseInt(reader.readLine());
    int[][] grid=new int[size][size];
    StringTokenizer tok ;
    for(int i=0 ; i<size ; i++){
      tok=new StringTokenizer(reader.readLine());
      for(int j=0 ; j<grid[i] .length ; j++){
        grid[i][j]=Integer.parseInt(tok.nextToken());
      }
    }
    int[] col=new int[size],row=new int[size];
    for(int i=0 ; i<size ; i++){
      for(int j=0 ; j<size ; j++){
        row[i]+=grid[i][j];
        col[j]+=grid[i][j];
      }
    }
    int count=0 ;
    for(int i=0 ; i<size ; i++){
      for(int j=0 ; j<size ; j++){
        if(col[i]>row[j])count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var size : int ; size := (reader.readLine())->toInteger() ;
    var grid : Sequence(Sequence(int)) ; grid := Integer.subrange(1,size)->collect(Integer.subrange(1,size)->collect(0)) ;
    var tok : OclIterator ;
        var i : int ; i := 0 ; while i < size do ( (     tok := OclIterator.newOclIterator_String(reader.readLine()) ; 
         var j : int ; j := 0 ; while j < grid[i+1]->size() do ( (     grid[i+1][j+1] := (tok.next())->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var col : Sequence(int) ; col := Integer.subrange(1,size)->collect(0) ;
    var row : Sequence(int) ; row := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < size do ( (         var j : int ; j := 0 ; while j < size do ( (     row[i+1] := row[i+1]+(grid[i+1][j+1]) ; 
     col[j+1] := col[j+1]+(grid[i+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < size do ( (         var j : int ; j := 0 ; while j < size do ( (     if (col[i+1] > row[j+1]) then     count := count + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String toNegativeBase(int n,int negBase){
    if(n==0)return "0" ;
    String converted="" ;
    while(n!=0){
      int remainder=n % negBase ;
      n/=negBase ;
      if(remainder<0){
        remainder+=(-negBase);
        n+=1 ;
      }
      converted=String.valueOf(remainder)+converted ;
    }
    return converted ;
  }
  public static void main(String[] args){
    int n=13 ;
    int negBase=-2 ;
    System.out.print(toNegativeBase(n,negBase));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation toNegativeBase( n : int, negBase : int) : String
  pre: true
  post: true
  activity: (     if (n = 0) then     return "0" else skip ; 
     var converted : String ; converted := "" ;
     while (n /= 0) do (     var remainder : int ; remainder := n mod negBase ;
     n := n/(negBase) ; 
     if (remainder < 0) then (     remainder := remainder+((-negBase)) ; 
     n := n+(1) ) else skip ; 
     converted := ((remainder) + "") + converted ) ; 
     return converted );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 13 ;
     var negBase : int ; negBase := -2 ;
     OclFile["System.out"].print(toNegativeBase(n, negBase)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String line=sc.nextLine();
    String[] s=line.split(" ",0);
    int n=s.length ;
    int num[]=new int[n];
    for(int i=0 ; i<n ; i++){
      num[i]=Integer.parseInt(s[i]);
    }
    Arrays.sort(num);
    int ans=0 ;
    for(int i=0 ; i<n-1 ; i++){
      ans+=num[i+1]-num[i];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : String ; line := sc.nextLine() ;
    var s : Sequence(String) ; s := line->split(" ") ;
    var n : int ; n := s->size() ;
    var num : Sequence(int) ; num := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     num[i+1] := (s[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    num := num->sort() ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     ans := ans+(num[i + 1+1] - num[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    ArrayList<Integer>listA=new ArrayList<Integer>();
    Map<Integer,Integer>map=new HashMap<Integer,Integer>();
    listA.add(a);
    listA.add(b);
    listA.add(c);
    ArrayList<Integer>listB=new ArrayList<Integer>(new HashSet<>(listA));
    Collections.sort(listB);
    int cost=0 ;
    for(int i=1 ; i<listB.size(); i++){
      int tmp=listB.get(i-1)-listB.get(i);
      cost=cost+Math.abs(tmp);
    }
    System.out.println(cost);
    sc.close();
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var listA : Sequence(int) ; listA := Sequence{} ;
    var map : Map(int,int) ; map := Map{} ;
    listA := listA->including(a) ; 
    listA := listA->including(b) ; 
    listA := listA->including(c) ; 
    var listB : Sequence(int) ; listB := Sequence{}->union(Set{}->union(listA)) ;
    listB := listB->sort() ; 
    var cost : int ; cost := 0 ;
        var i : int ; i := 1 ; while i < listB->size() do ( (     var tmp : int ; tmp := listB->at(i - 1+1) - listB->at(i+1) ;
     cost := cost + if tmp < 0 then -(tmp) else tmp endif )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cost) ; 
    skip ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static long N ;
  static int M ;
  static int A ;
  static long B ;
  static long C ;
  static int[][] map ;
  static int min=9999999 ;
  static int[] moto=new int[3];
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    moto[0]=scanner.nextInt();
    moto[1]=scanner.nextInt();
    moto[2]=scanner.nextInt();
    Arrays.sort(moto);
    System.out.println((moto[1]-moto[0])+(moto[2]-moto[1]));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : long;
  static   attribute M : int;
  static   attribute A : int;
  static   attribute B : long;
  static   attribute C : long;
  static   attribute map : Sequence(Sequence(int));
  static   attribute min : int := 9999999;
  static   attribute moto : Sequence(int) := Integer.subrange(1,3)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     moto[0+1] := scanner.getCurrent()->toInteger() ; 
    moto[1+1] := scanner.getCurrent()->toInteger() ; 
    moto[2+1] := scanner.getCurrent()->toInteger() ; 
    moto := moto->sort() ; 
    OclFile["System.out"].println((moto[1+1] - moto[0+1]) + (moto[2+1] - moto[1+1])) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner Cf=new Scanner(System.in);
    int[] A=new int[3];
    A[0]=Cf.nextInt();
    A[1]=Cf.nextInt();
    A[2]=Cf.nextInt();
    Solver(A);
    Cf.close();
  }
  public static void Solver(int[] A){
    Arrays.sort(A);
    int diff=0 ;
    for(int i=1 ; i<A.length ; i++){
      diff=Math.abs(A[i]-A[i-1])+diff ;
    }
    System.out.println(diff);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Cf : OclFile ; Cf := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : Sequence(int) ; A := Integer.subrange(1,3)->collect(0) ;
    A[0+1] := Cf.getCurrent()->toInteger() ; 
    A[1+1] := Cf.getCurrent()->toInteger() ; 
    A[2+1] := Cf.getCurrent()->toInteger() ; 
    execute Solver(A) ; 
    skip ; 
 );
  static   operation Solver( A : Sequence(int)) : void
  pre: true
  post: true
  activity: (     A := A->sort() ; 
     var diff : int ; diff := 0 ;
         var i : int ; i := 1 ; while i < A->size() do ( (     diff := if A[i+1] - A[i - 1+1] < 0 then -(A[i+1] - A[i - 1+1]) else A[i+1] - A[i - 1+1] endif + diff )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(diff) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] ary=new int[3];
    ary[0]=sc.nextInt();
    ary[1]=sc.nextInt();
    ary[2]=sc.nextInt();
    if(ary[0]>ary[1]){
      int cap=ary[0];
      ary[0]=ary[1];
      ary[1]=cap ;
    }
    if(ary[1]>ary[2]){
      int cap=ary[1];
      ary[1]=ary[2];
      ary[2]=cap ;
    }
    if(ary[0]>ary[1]){
      int cap=ary[0];
      ary[0]=ary[1];
      ary[1]=cap ;
    }
    int cost=0 ;
    cost+=Math.abs(ary[1]-ary[0]);
    cost+=Math.abs(ary[2]-ary[1]);
    System.out.println(cost);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ary : Sequence(int) ; ary := Integer.subrange(1,3)->collect(0) ;
    ary[0+1] := sc.getCurrent()->toInteger() ; 
    ary[1+1] := sc.getCurrent()->toInteger() ; 
    ary[2+1] := sc.getCurrent()->toInteger() ; 
    if (ary[0+1] > ary[1+1]) then (     var cap : int ; cap := ary[0+1] ;
     ary[0+1] := ary[1+1] ; 
     ary[1+1] := cap ) else skip ; 
    if (ary[1+1] > ary[2+1]) then (     var cap : int ; cap := ary[1+1] ;
     ary[1+1] := ary[2+1] ; 
     ary[2+1] := cap ) else skip ; 
    if (ary[0+1] > ary[1+1]) then (     var cap : int ; cap := ary[0+1] ;
     ary[0+1] := ary[1+1] ; 
     ary[1+1] := cap ) else skip ; 
    var cost : int ; cost := 0 ;
    cost := cost+(if ary[1+1] - ary[0+1] < 0 then -(ary[1+1] - ary[0+1]) else ary[1+1] - ary[0+1] endif) ; 
    cost := cost+(if ary[2+1] - ary[1+1] < 0 then -(ary[2+1] - ary[1+1]) else ary[2+1] - ary[1+1] endif) ; 
    OclFile["System.out"].println(cost) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static void printArray(int arr[],int size){
    for(int i=0 ; i<size ; i++)System.out.print(arr[i]+" ");
    System.out.println();
    return ;
  }
  static void printSequencesRecur(int arr[],int n,int k,int index){
    int i ;
    if(k==0){
      printArray(arr,index);
    }
    if(k>0){
      for(i=1 ; i<=n ; ++i){
        arr[index]=i ;
        printSequencesRecur(arr,n,k-1,index+1);
      }
    }
  }
  static void printSequences(int n,int k){
    int arr[]=new int[k];
    printSequencesRecur(arr,n,k,0);
    return ;
  }
  public static void main(String[] args){
    int n=3 ;
    int k=2 ;
    printSequences(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation printArray( arr : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < size do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ; 
     return );
  static   operation printSequencesRecur( arr : Sequence(int), n : int, k : int, index : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
     if (k = 0) then (     execute printArray(arr, index) ) else skip ; 
     if (k > 0) then (         i := 1 ; while i <= n do ( (     arr[index+1] := i ; 
     execute printSequencesRecur(arr, n, k - 1, index + 1) )  ;     i := i + 1 ) ) else skip );
  static   operation printSequences( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,k)->collect(0) ;
     execute printSequencesRecur(arr, n, k, 0) ; 
     return );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var k : int ; k := 2 ;
     execute printSequences(n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int RSF(int n){
    while(n>=10){
      int x=n ;
      int l=0 ;
      while(n>0){
        n=n/10 ;
        l++;
      }
      int a[]=new int[l];
      int i=l-1 ;
      while(x>0){
        a[i]=x % 10 ;
        x=x/10 ;
        i--;
      }
      for(int j=0 ; j<l-1 ; j++){
        n=n*10+Math.abs(a[j]-a[j+1]);
      }
    }
    return n ;
  }
  public static void main(String[] arg){
    int n=6972 ;
    int ans=RSF(n);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation RSF( n : int) : int
  pre: true
  post: true
  activity: (     while (n >= 10) do (     var x : int ; x := n ;
     var l : int ; l := 0 ;
    while (n > 0) do (     n := n / 10 ; 
     l := l + 1 ) ; 
    var a : Sequence(int) ; a := Integer.subrange(1,l)->collect(0) ;
    var i : int ; i := l - 1 ;
    while (x > 0) do (     a[i+1] := x mod 10 ; 
     x := x / 10 ; 
     i := i - 1 ) ; 
        var j : int ; j := 0 ; while j < l - 1 do ( (     n := n * 10 + if a[j+1] - a[j + 1+1] < 0 then -(a[j+1] - a[j + 1+1]) else a[j+1] - a[j + 1+1] endif )  ;     j := j + 1 ) ; 
 ) ; 
     return n );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6972 ;
     var ans : int ; ans := RSF(n) ;
     OclFile["System.out"].println(ans) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void nDigitPerfectSquares(int n){
    int smallest=(int)Math.pow(Math.ceil(Math.sqrt(Math.pow(10,n-1))),2);
    System.out.print(smallest+" ");
    int largest=(int)Math.pow(Math.ceil(Math.sqrt(Math.pow(10,n)))-1,2);
    System.out.print(largest);
  }
  public static void main(String args[]){
    int n=4 ;
    nDigitPerfectSquares(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nDigitPerfectSquares( n : int) : void
  pre: true
  post: true
  activity: (     var smallest : int ; smallest := ((10->pow(n - 1))->sqrt())->ceil()->pow(2)->oclAsType(int) ;
     OclFile["System.out"].print(smallest + " ") ; 
     var largest : int ; largest := ((10->pow(n))->sqrt())->ceil() - 1->pow(2)->oclAsType(int) ;
     OclFile["System.out"].print(largest) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     execute nDigitPerfectSquares(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Node {
    int data ;
    Node next ;
  };
  static Node circular(Node head){
    Node start=head ;
    while(head.next!=null)head=head.next ;
    head.next=start ;
    return start ;
  }
  static Node push(Node head,int data){
    Node newNode=new Node();
    newNode.data=data ;
    newNode.next=(head);
(head)=newNode ;
    return head ;
  }
  static void displayList(Node node){
    Node start=node ;
    while(node.next!=start){
      System.out.print(" "+node.data);
      node=node.next ;
    }
    System.out.print(" "+node.data);
  }
  public static void main(String args[]){
    Node head=null ;
    head=push(head,15);
    head=push(head,14);
    head=push(head,13);
    head=push(head,22);
    head=push(head,17);
    circular(head);
    System.out.print("Display list: \n");
    displayList(head);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   operation circular( head : Node) : Node
  pre: true
  post: true
  activity: (     var start : Node ; start := head ;
     while (head.next /= null) do     head := head.next ; ; 
     head.next := start ; 
     return start );
  static   operation push( head : Node, data : int) : Node
  pre: true
  post: true
  activity: (     var newNode : Node ; newNode := Node.newNode() ;
     newNode.data := data ; 
    newNode.next := (head) ; 
    (head) := newNode ; 
    return head 
 );
  static   operation displayList( node : Node) : void
  pre: true
  post: true
  activity: (     var start : Node ; start := node ;
     while (node.next /= start) do (     OclFile["System.out"].print(" " + node.data) ; 
     node := node.next ) ; 
     OclFile["System.out"].print(" " + node.data) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := null ;
     head := push(head, 15) ; 
    head := push(head, 14) ; 
    head := push(head, 13) ; 
    head := push(head, 22) ; 
    head := push(head, 17) ; 
    execute circular(head) ; 
    OclFile["System.out"].print("Display list: \n") ; 
    execute displayList(head) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public String licenseKeyFormatting(String s,int k){
    StringBuilder sb=new StringBuilder();
    for(int i=s.length()-1 ; i>=0 ; i--)if(s.charAt(i)!='-')sb.append(sb.length()%(k+1)==k ? '-' : "").append(s.charAt(i));
    return sb.reverse().toString().toUpperCase();
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation licenseKeyFormatting( s : String, k : int) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := s->size() - 1 ; while i >= 0 do (     if (s->at(i+1) /= '-') then     sb := sb + StringLib.newString(if sb->size() mod (k + 1) = k then '-' else "" endif) + StringLib.newString(s->at(i+1)) ; else skip ;  ;     i := i - 1 ) ; 
     return sb->reverse()+""->toUpperCase() );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double EPS=1E-15 ;
  static double findMinValue(double arr[],double n){
    double sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=(double)Math.log10(arr[i])+EPS ;
    double xl=(double)(sum/n+EPS);
    double res=Math.pow((double)10.0,(double)xl)+EPS ;
    return(double)Math.ceil(res+EPS);
  }
  public static void main(String[] args){
    double arr[]={
      4,2,1,10,6 };
      double n=arr.length ;
      System.out.println(findMinValue(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute EPS : double := 1E-15;
  static   operation findMinValue( arr : Sequence(double), n : double) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+((arr[i+1])->log10()->oclAsType(double) + EPS) ;  ;     i := i + 1 ) ; 
    var xl : double ; xl := (sum / n + EPS)->oclAsType(double) ;
    var res : double ; res := 10.0->oclAsType(double)->pow(xl->oclAsType(double)) + EPS ;
    return (res + EPS)->ceil()->oclAsType(double) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(double) ; arr := Sequence{4,2,1,10,6} ;
     var n : double ; n := arr->size() ;
     OclFile["System.out"].println(findMinValue(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GfG {
  static int digroot(int n){
    int root=0 ;
    while(n>0 || root>9){
      if(n==0){
        n=root ;
        root=0 ;
      }
      root+=n % 10 ;
      n/=10 ;
    }
    return root ;
  }
  public static void main(String argc[]){
    int n=65785412 ;
    System.out.println(digroot(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation digroot( n : int) : int
  pre: true
  post: true
  activity: (     var root : int ; root := 0 ;
     while (n > 0 or root > 9) do (     if (n = 0) then (     n := root ; 
     root := 0 ) else skip ; 
     root := root+(n mod 10) ; 
     n := n/(10) ) ; 
     return root );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 65785412 ;
     OclFile["System.out"].println(digroot(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str[]=br.readLine().split(" ");
    int m=Integer.parseInt(str[0]);
    int n=Integer.parseInt(str[1]);
    ArrayList<Integer>ans=new ArrayList<Integer>();
    if(check(m,n,ans)){
      System.out.println("YES");
      System.out.println(ans.size());
      for(int i=ans.size()-1 ; i>=0 ; i--)System.out.print(ans.get(i)+" ");
    }
    else {
      System.out.println("NO");
    }
  }
  public static boolean check(int m,int n,ArrayList<Integer>ans){
    if(m==n){
      ans.add(m);
      return true ;
    }
    else if(n<m)return false ;
    if(n % 10==1){
      ans.add(n);
      n=n/10 ;
    }
    else if(n % 2==0){
      ans.add(n);
      n=n/2 ;
    }
    else return false ;
    return check(m,n,ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var m : int ; m := (str[0+1])->toInteger() ;
    var n : int ; n := (str[1+1])->toInteger() ;
    var ans : Sequence(int) ; ans := Sequence{} ;
    if (check(m, n, ans)) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(ans->size()) ; 
         var i : int ; i := ans->size() - 1 ; while i >= 0 do (     OclFile["System.out"].print(ans->at(i+1) + " ") ;  ;     i := i - 1 ) ) else (     OclFile["System.out"].println("NO") ) ;  
 );
  static   operation check( m : int, n : int, ans : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     if (m = n) then (     ans := ans->including(m) ; 
     return true ) else     if (n < m) then     return false else skip ; ;  
     if (n mod 10 = 1) then (     ans := ans->including(n) ; 
     n := n / 10 ) else     if (n mod 2 = 0) then (     ans := ans->including(n) ; 
     n := n / 2 ) else     return false ;  ;  
     return check(m, n, ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int a=in.nextInt(),b=in.nextInt();
    ArrayList<Integer>list=new ArrayList<>();
    list.add(b);
    while(b>a){
      if(b % 2==0){
        b/=2 ;
      }
      else if(b % 10==1){
        b=(b-1)/10 ;
      }
      else {
        break ;
      }
      list.add(b);
    }
    if(a==b){
      pw.println("YES");
      Collections.sort(list);
      Collections.reverse(list);
      pw.println(list.size());
      for(int i=list.size()-1 ; i>=0 ; i--){
        pw.print(list.get(i)+" ");
      }
    }
    else {
      pw.println("NO");
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
    list := list->including(b) ; 
    while (b > a) do (     if (b mod 2 = 0) then (     b := b/(2) ) else     if (b mod 10 = 1) then (     b := (b - 1) / 10 ) else (     break ) ;  ;  
     list := list->including(b) ) ; 
    if (a = b) then (     skip ; 
     list := list->sort() ; 
    list := list->reverse() ; 
    skip ; 
        var i : int ; i := list->size() - 1 ; while i >= 0 do ( (     skip )  ;     i := i - 1 ) ; 
 ) else (     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class transformationab {
  public static void printSpace(List<Integer>out){
    for(int i=out.size()-1 ; i>=0 ; i--){
      System.out.print(out.get(i)+" ");
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int start=sc.nextInt();
    int end=sc.nextInt();
    if(start<0 || end<0){
      System.out.println("NO");
      return ;
    }
    List<Integer>out=new ArrayList();
    out.add(end);
    while(end>0){
      if(end % 2==0){
        out.add(end/2);
        end=end/2 ;
      }
      else if((end-1)% 10==0){
        out.add((end-1)/10);
        end-=1 ;
        end=end/10 ;
      }
      else {
        break ;
      }
      if(start==end){
        break ;
      }
    }
    if(out.get(out.size()-1)!=start){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
      System.out.println(out.size());
      printSpace(out);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class transformationab {
  static   operation printSpace( out : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := out->size() - 1 ; while i >= 0 do ( (     OclFile["System.out"].print(out->at(i+1) + " ") )  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var start : int ; start := sc.getCurrent()->toInteger() ;
    var end : int ; end := sc.getCurrent()->toInteger() ;
    if (start < 0 or end < 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    var out : Sequence(int) ; out := Sequence{} ;
    out := out->including(end) ; 
    while (end > 0) do (     if (end mod 2 = 0) then (     out := out->including(end / 2) ; 
     end := end / 2 ) else     if ((end - 1) mod 10 = 0) then (     out := out->including((end - 1) / 10) ; 
     end := end-(1) ; 
     end := end / 10 ) else (     break ) ;  ;  
     if (start = end) then (     break ) else skip ) ; 
    if (out->at(out->size() - 1+1) /= start) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(out->size()) ; 
     execute printSpace(out) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.*;
public class Main {
  public static void printAllValue(long a,long b,List<Long>temp){
    if(a==b){
      temp.add(a);
      System.out.println("YES");
      System.out.println(temp.size());
      for(int i=0 ; i<temp.size(); i++){
        System.out.print(temp.get(i)+" ");
      }
      return ;
    }
    if(a>b){
      return ;
    }
    temp.add(a);
    printAllValue(2*a,b,temp);
    printAllValue((10*a)+1,b,temp);
    temp.remove(temp.size()-1);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a=sc.nextLong();
    long b=sc.nextLong();
    List<Long>temp=new ArrayList();
    printAllValue(a,b,temp);
    if(temp.size()==0){
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation printAllValue( a : long, b : long, temp : Sequence(long)) : void
  pre: true
  post: true
  activity: (     if (a = b) then (     temp->excludes(a) ; 
     OclFile["System.out"].println("YES") ; 
    OclFile["System.out"].println(temp->size()) ; 
        var i : int ; i := 0 ; while i < temp->size() do ( (     OclFile["System.out"].print(temp->at(i+1) + " ") )  ;     i := i + 1 ) ; 
    return 
 ) else skip ; 
     if (a > b) then (     return ) else skip ; 
    temp->excludes(a) ; 
    execute printAllValue(2 * a, b, temp) ; 
    execute printAllValue((10 * a) + 1, b, temp) ; 
    temp := temp->excludingFirst(temp->size() - 1) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var temp : Sequence(long) ; temp := Sequence{} ;
    execute printAllValue(a, b, temp) ; 
    if (temp->size() = 0) then (     OclFile["System.out"].println("NO") ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class test {
  static List<Long>result=new ArrayList<Long>();
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    Boolean isValid=transform(a,b,new ArrayList<Long>());
    if(isValid){
      System.out.println("YES");
      System.out.println(result.size());
      for(Long val : result){
        System.out.print(val+" ");
      }
    }
    else {
      System.out.println("NO");
    }
  }
  private static boolean transform(long curr,long target,List<Long>temp){
    if(curr>target){
      return false ;
    }
    if(curr==target){
      temp.add(curr);
      result=new ArrayList(temp);
      return true ;
    }
    temp.add(curr);
    boolean path1=transform(curr*2,target,temp);
    boolean path2=transform(curr*10+1,target,temp);
    temp.remove(temp.size()-1);
    return path1 || path2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   attribute result : Sequence(long) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var isValid : Boolean ; isValid := transform(a, b, Sequence{}) ;
    if (isValid) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(result->size()) ; 
     for (val : result) do ( (     OclFile["System.out"].print(val + " ") )  ) ) else (     OclFile["System.out"].println("NO") ) ;  
 );
  static   operation transform( curr : long, target : long, temp : Sequence(long)) : boolean
  pre: true
  post: true
  activity: (     if (curr > target) then (     return false ) else skip ; 
     if (curr = target) then (     temp->excludes(curr) ; 
     result := Sequence{}->union(temp) ; 
     return true ) else skip ; 
    temp->excludes(curr) ; 
    var path1 : boolean ; path1 := transform(curr * 2, target, temp) ;
    var path2 : boolean ; path2 := transform(curr * 10 + 1, target, temp) ;
    temp := temp->excludingFirst(temp->size() - 1) ; 
    return path1 or path2 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A {
  public static void main(String[] args){
    new A().solve();
  }
  Scanner in ;
  private void solve(){
    in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      List<String>message=new ArrayList<>(Arrays.asList(in.next().split("")));
      identifyMessage(message,n);
    }
  }
  private void identifyMessage(List<String>list,int n){
    Collections.reverse(list);
    int leftSymbols=0 ;
    for(String character : list){
      if(character.equals(")")){
++leftSymbols ;
      }
      else {
        break ;
      }
    }
    System.out.println(leftSymbols>(n-leftSymbols)? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     A.newA().solve() );
   attribute in : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var message : Sequence(String) ; message := Sequence{}->union(in.getCurrent()->split("")) ;
     execute identifyMessage(message, n) ) ;  ) );
   operation identifyMessage( list : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (     list := list->reverse() ; 
     var leftSymbols : int ; leftSymbols := 0 ;
     for (character : list) do ( (     if (character = ")") then (     leftSymbols := leftSymbols + 1 ) else (     break ) )  ) ; 
     OclFile["System.out"].println(if leftSymbols > (n - leftSymbols) then "Yes" else "No" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int k_sum(int a[],int n,int k){
    int r=0,sum=0 ;
    int ans=0 ;
    for(int l=0 ; l<n ; l++){
      while(sum<k){
        if(r==n)break ;
        else {
          sum+=a[r];
          r++;
        }
      }
      if(sum<k)break ;
      ans+=n-r+1 ;
      sum-=a[l];
    }
    return ans ;
  }
  public static void main(String[] args){
    int a[]={
      6,1,2,7 },k=10 ;
      int n=a.length ;
      System.out.println(k_sum(a,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation k_sum( a : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var r : int ; r := 0 ;
    var sum : int ; sum := 0 ;
     var ans : int ; ans := 0 ;
         var l : int ; l := 0 ; while l < n do ( (     while (sum < k) do (     if (r = n) then     break else (     sum := sum+(a[r+1]) ; 
     r := r + 1 ) ) ; 
     if (sum < k) then     break else skip ; 
     ans := ans+(n - r + 1) ; 
     sum := sum-(a[l+1]) )  ;     l := l + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{6,1,2,7} ;
    var k : int ; k := 10 ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(k_sum(a, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static char getChar(String str){
    int sum=0 ;
    for(int i=0 ; i<str.length(); i++){
      sum+=(str.charAt(i)-'a'+1);
    }
    if(sum % 26==0)return 'z' ;
    else {
      sum=sum % 26 ;
      return(char)('a'+sum-1);
    }
  }
  public static void main(String[] args){
    String str="gfg" ;
    System.out.println(getChar(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getChar( str : String) : String
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     sum := sum+((str->at(i+1) - ('a')->char2byte() + 1)) )  ;     i := i + 1 ) ; 
     if (sum mod 26 = 0) then     return 'z' else (     sum := sum mod 26 ; 
     return ('a' + sum - 1)->oclAsType(String) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "gfg" ;
     OclFile["System.out"].println(getChar(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int sumNth(int A[],int B[],int m,int n){
    int res=0 ;
    if(n==1){
      for(int i=0 ; i<m ; i++)res=res+A[i];
    }
    else if(n==2){
      for(int i=0 ; i<m ; i++)res=res+B[i]*m ;
    }
    else {
      int f[]=new int[n];
      f[0]=0 ;
      f[1]=1 ;
      for(int i=2 ; i<n ; i++)f[i]=f[i-1]+f[i-2];
      for(int i=0 ; i<m ; i++){
        res=res+(m*(B[i]*f[n-1]))+(m*(A[i]*f[n-2]));
      }
    }
    return res ;
  }
  public static void main(String args[]){
    int A[]={
      1,2,3 };
      int B[]={
        4,5,6 };
        int n=3 ;
        int m=A.length ;
        System.out.println(sumNth(A,B,m,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumNth( A : Sequence(int), B : Sequence(int), m : int, n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     if (n = 1) then (         var i : int ; i := 0 ; while i < m do (     res := res + A[i+1] ;  ;     i := i + 1 ) ) else     if (n = 2) then (         var i : int ; i := 0 ; while i < m do (     res := res + B[i+1] * m ;  ;     i := i + 1 ) ) else (     var f : Sequence(int) ; f := Integer.subrange(1,n)->collect(0) ;
     f[0+1] := 0 ; 
    f[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < n do (     f[i+1] := f[i - 1+1] + f[i - 2+1] ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     res := res + (m * (B[i+1] * f[n - 1+1])) + (m * (A[i+1] * f[n - 2+1])) )  ;     i := i + 1 ) ; 
 ) ;  ;  
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{1,2,3} ;
     var B : Sequence(int) ; B := Sequence{4,5,6} ;
    var n : int ; n := 3 ;
    var m : int ; m := A->size() ;
    OclFile["System.out"].println(sumNth(A, B, m, n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void odd_even(int arr[],int n){
    Vector<Integer>odd_indexes=new Vector<Integer>();
    Vector<Integer>even_indexes=new Vector<Integer>();
    for(int i=0 ; i<n ; i++){
      if(i % 2==0)odd_indexes.add(arr[i]);
      else even_indexes.add(arr[i]);
    }
    Collections.sort(odd_indexes);
    Collections.sort(even_indexes);
    for(int i=0 ; i<odd_indexes.size(); i++)System.out.print(odd_indexes.get(i)+" ");
    for(int i=0 ; i<even_indexes.size(); i++)System.out.print(even_indexes.get(i)+" ");
  }
  public static void main(String[] args){
    int arr[]={
      3,2,7,6,8 };
      int n=arr.length ;
      odd_even(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation odd_even( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var odd_indexes : Sequence(int) ; odd_indexes := Sequence{} ;
     var even_indexes : Sequence(int) ; even_indexes := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then     odd_indexes := odd_indexes->including(arr[i+1]) ; else     even_indexes := even_indexes->including(arr[i+1]) ; )  ;     i := i + 1 ) ; 
    odd_indexes := odd_indexes->sort() ; 
    even_indexes := even_indexes->sort() ; 
        var i : int ; i := 0 ; while i < odd_indexes->size() do (     OclFile["System.out"].print(odd_indexes->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < even_indexes->size() do (     OclFile["System.out"].print(even_indexes->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,2,7,6,8} ;
     var n : int ; n := arr->size() ;
     execute odd_even(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static void printFirstNegativeInteger(int arr[],int n,int k){
    boolean flag ;
    for(int i=0 ; i<(n-k+1); i++){
      flag=false ;
      for(int j=0 ; j<k ; j++){
        if(arr[i+j]<0){
          System.out.print((arr[i+j])+" ");
          flag=true ;
          break ;
        }
      }
      if(! flag)System.out.print("0"+" ");
    }
  }
  public static void main(String args[]){
    int arr[]={
      12,-1,-7,8,-15,30,16,28 };
      int n=arr.length ;
      int k=3 ;
      printFirstNegativeInteger(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation printFirstNegativeInteger( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var flag : boolean ;
         var i : int ; i := 0 ; while i < (n - k + 1) do ( (     flag := false ; 
         var j : int ; j := 0 ; while j < k do ( (     if (arr[i + j+1] < 0) then (     OclFile["System.out"].print((arr[i + j+1]) + " ") ; 
     flag := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (not(flag)) then     OclFile["System.out"].print("0" + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,-1,-7,8,-15,30,16,28} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     execute printFirstNegativeInteger(arr, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Prefix {
  static void fillPrefixSum(int arr[],int n,int prefixSum[]){
    prefixSum[0]=arr[0];
    for(int i=1 ; i<n ; ++i)prefixSum[i]=prefixSum[i-1]+arr[i];
  }
  public static void main(String[] args){
    int arr[]={
      10,4,16,20 };
      int n=arr.length ;
      int prefixSum[]=new int[n];
      fillPrefixSum(arr,n,prefixSum);
      for(int i=0 ; i<n ; i++)System.out.print(prefixSum[i]+" ");
      System.out.println("");
    }
  }

------------------------------------------------------------
OCL File:
---------
class Prefix {
  static   operation fillPrefixSum( arr : Sequence(int), n : int, prefixSum : Sequence(int)) : void
  pre: true
  post: true
  activity: (     prefixSum[0+1] := arr[0+1] ; 
         var i : int ; i := 1 ; while i < n do (     prefixSum[i+1] := prefixSum[i - 1+1] + arr[i+1] ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,4,16,20} ;
     var n : int ; n := arr->size() ;
    var prefixSum : Sequence(int) ; prefixSum := Integer.subrange(1,n)->collect(0) ;
    execute fillPrefixSum(arr, n, prefixSum) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(prefixSum[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String format="%.6f %.6f%n" ;
    while((line=br.readLine())!=null){
      String[] input=line.split(",");
      double x1=Double.parseDouble(input[0]);
      double y1=Double.parseDouble(input[1]);
      double x2=Double.parseDouble(input[2]);
      double y2=Double.parseDouble(input[3]);
      double xq=Double.parseDouble(input[4]);
      double yq=Double.parseDouble(input[5]);
      if(x1==x2){
        double x=(x1-xq)+x1 ;
        System.out.printf(format,x,yq);
      }
      else if(y1==y2){
        double y=(y1-yq)+y1 ;
        System.out.printf(format,xq,y);
      }
      else {
        double alpha=(y2-y1)/(x2-x1);
        double x=((1-alpha*alpha)*xq+2*alpha*yq+2*alpha*alpha*x1-2*alpha*y1)/(alpha*alpha+1);
        double y=(xq-x)/alpha+yq ;
        System.out.printf(format,x,y);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var format : String ; format := "%.6f %.6f%n" ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     var input : Sequence(String) ; input := line->split(",") ;
     var x1 : double ; x1 := (input[0+1])->toReal() ;
    var y1 : double ; y1 := (input[1+1])->toReal() ;
    var x2 : double ; x2 := (input[2+1])->toReal() ;
    var y2 : double ; y2 := (input[3+1])->toReal() ;
    var xq : double ; xq := (input[4+1])->toReal() ;
    var yq : double ; yq := (input[5+1])->toReal() ;
    if (x1 = x2) then (     var x : double ; x := (x1 - xq) + x1 ;
     OclFile["System.out"].printf(format, x, yq) ) else     if (y1 = y2) then (     var y : double ; y := (y1 - yq) + y1 ;
     OclFile["System.out"].printf(format, xq, y) ) else (     var alpha : double ; alpha := (y2 - y1) / (x2 - x1) ;
     var x : double ; x := ((1 - alpha * alpha) * xq + 2 * alpha * yq + 2 * alpha * alpha * x1 - 2 * alpha * y1) / (alpha * alpha + 1) ;
     var y : double ; y := (xq - x) / alpha + yq ;
     OclFile["System.out"].printf(format, x, y) ) ;  ;  
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Point2D ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    Point2D.Double p1,p2,q,r ;
    String st[];
    while(sc.hasNext()){
      st=sc.next().split(",");
      p1=new Point2D.Double(Double.valueOf(st[0]),Double.valueOf(st[1]));
      p2=new Point2D.Double(Double.valueOf(st[2]),Double.valueOf(st[3]));
      q=new Point2D.Double(Double.valueOf(st[4]),Double.valueOf(st[5]));
      r=new Point2D.Double();
      if(p1.x==p2.x){
        r.x=p1.x+p1.x-q.x ;
        r.y=q.y ;
      }
      else if(p1.y==p2.y){
        r.x=q.x ;
        r.y=p1.y+p1.y-q.y ;
      }
      else {
        double a1,b1,a2,b2 ;
        double x,y ;
        a1=(p2.y-p1.y)/(p2.x-p1.x);
        b1=p1.y-a1*p1.x ;
        a2=-1.0/a1 ;
        b2=q.y-a2*q.x ;
        x=(b2-b1)/(a1-a2);
        y=a1*x+b1 ;
        r.x=x+x-q.x ;
        r.y=y+y-q.y ;
      }
      System.out.println(r.x+" "+r.y);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p1 : Double ;
    var p2 : Double ;
    var q : Double ;
    var r : Double ;
     var st : Sequence(String) ;
     while (sc.hasNext()) do (     st := sc.getCurrent()->split(",") ; 
     p1 := Double.newDouble((st[0+1])->toReal(), (st[1+1])->toReal()) ; 
    p2 := Double.newDouble((st[2+1])->toReal(), (st[3+1])->toReal()) ; 
    q := Double.newDouble((st[4+1])->toReal(), (st[5+1])->toReal()) ; 
    r := Double.newDouble() ; 
    if (p1.x = p2.x) then (     r.x := p1.x + p1.x - q.x ; 
     r.y := q.y ) else     if (p1.y = p2.y) then (     r.x := q.x ; 
     r.y := p1.y + p1.y - q.y ) else (     var a1 : double ;
    var b1 : double ;
    var a2 : double ;
    var b2 : double ;
     var x : double ;
    var y : double ;
    a1 := (p2.y - p1.y) / (p2.x - p1.x) ; 
    b1 := p1.y - a1 * p1.x ; 
    a2 := -1.0 / a1 ; 
    b2 := q.y - a2 * q.x ; 
    x := ((b2)->char2byte() - (b1)->char2byte()) / ((a1)->char2byte() - (a2)->char2byte()) ; 
    y := a1 * x + b1 ; 
    r.x := x + x - q.x ; 
    r.y := y + y - q.y ; 
 ) ;  ;  
    OclFile["System.out"].println(r.x + " " + r.y) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Pair {
  double x ;
  double y ;
  Pair(double x,double y){
    this.x=x ;
    this.y=y ;
  }
}
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(stdIn.hasNext()){
      String[] str=stdIn.next().split(",");
      Pair[] p=new Pair[3];
      for(int i=0 ; i<3 ; ++i){
        p[i]=new Pair(Double.parseDouble(str[2*i]),Double.parseDouble(str[2*i+1]));
      }
      if(p[0] .y==p[1] .y){
        System.out.println(p[2] .x+" "+(p[0] .y-(p[2] .y-p[0] .y)));
      }
      else if(p[0] .x==p[1] .x){
        System.out.println((p[0] .x+(p[0] .x-p[2] .x))+" "+p[2] .y);
      }
      else {
        double a1=(p[1] .y-p[0] .y)/(p[1] .x-p[0] .x);
        double b1=p[0] .y-a1*p[0] .x ;
        double a2=-1/a1 ;
        double b2=p[2] .y-a2*p[2] .x ;
        double x=(b1-b2)/(a2-a1);
        double y=a2*x+b2 ;
        double dx=x-p[2] .x ;
        double dy=y-p[2] .y ;
        System.out.println((x+dx)+" "+(y+dy));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Pair {
   attribute x : double;
   attribute y : double;
   static operation newPair( x : double, y : double) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (stdIn.hasNext()) do (     var str : Sequence(String) ; str := stdIn.getCurrent()->split(",") ;
     var p : Sequence(Map) ; p := Integer.subrange(1,3)->collect(null) ;
         var i : int ; i := 0 ; while i < 3 do ( (     p[i+1] := Map((str[2 * i+1])->toReal(), (str[2 * i + 1+1])->toReal()) )  ;     i := i + 1 ) ; 
     if (p[0+1].y = p[1+1].y) then (     OclFile["System.out"].println(p[2+1].x + " " + (p[0+1].y - (p[2+1].y - p[0+1].y))) ) else     if (p[0+1].x = p[1+1].x) then (     OclFile["System.out"].println((p[0+1].x + (p[0+1].x - p[2+1].x)) + " " + p[2+1].y) ) else (     var a1 : double ; a1 := (p[1+1].y - p[0+1].y) / (p[1+1].x - p[0+1].x) ;
     var b1 : double ; b1 := p[0+1].y - a1 * p[0+1].x ;
    var a2 : double ; a2 := -1 / a1 ;
    var b2 : double ; b2 := p[2+1].y - a2 * p[2+1].x ;
    var x : double ; x := (b1 - b2) / (a2 - a1) ;
    var y : double ; y := a2 * x + b2 ;
    var dx : double ; dx := x - p[2+1].x ;
    var dy : double ; dy := y - p[2+1].y ;
    OclFile["System.out"].println((x + dx) + " " + (y + dy)) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    String line=null ;
    while((line=reader.readLine())!=null){
      if(line.isEmpty()){
        continue ;
      }
      String[] values=line.split(",");
      double x1=Double.parseDouble(values[0]);
      double y1=Double.parseDouble(values[1]);
      double x2=Double.parseDouble(values[2]);
      double y2=Double.parseDouble(values[3]);
      double xq=Double.parseDouble(values[4]);
      double yq=Double.parseDouble(values[5]);
      double xr=-xq ;
      double yr=yq ;
      if(x1!=x2){
        double a=(y2-y1)/(x2-x1);
        xr=-2.0*a/(1+a*a)*(y1-yq-a*(x1-xq))+xq ;
        yr=2.0/(1+a*a)*(y1-yq-a*(x1-xq))+yq ;
      }
      out.println(xr+" "+yr);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     var line : String ; line := null ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->isEmpty()) then (     continue ) else skip ; 
     var values : Sequence(String) ; values := line->split(",") ;
    var x1 : double ; x1 := (values[0+1])->toReal() ;
    var y1 : double ; y1 := (values[1+1])->toReal() ;
    var x2 : double ; x2 := (values[2+1])->toReal() ;
    var y2 : double ; y2 := (values[3+1])->toReal() ;
    var xq : double ; xq := (values[4+1])->toReal() ;
    var yq : double ; yq := (values[5+1])->toReal() ;
    var xr : double ; xr := -xq ;
    var yr : double ; yr := yq ;
    if (x1 /= x2) then (     var a : double ; a := (y2 - y1) / (x2 - x1) ;
     xr := -2.0 * a / (1 + a * a) * (y1 - yq - a * (x1 - xq)) + xq ; 
     yr := 2.0 / (1 + a * a) * (y1 - yq - a * (x1 - xq)) + yq ) else skip ; 
    out.println(xr + " " + yr) ; 
 ) ;     line := reader.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  void fib(int f[]){
    f[0]=0 ;
    f[1]=1 ;
    for(int i=2 ; i<=59 ; i++)f[i]=(f[i-1]+f[i-2])% 10 ;
  }
  int findLastDigit(long n){
    int f[]=new int[60];
    fib(f);
    int index=(int)(n % 60L);
    return f[index];
  }
  public static void main(String[] args){
    long n ;
    GFG ob=new GFG();
    n=1 ;
    System.out.println(ob.findLastDigit(n));
    n=61 ;
    System.out.println(ob.findLastDigit(n));
    n=7 ;
    System.out.println(ob.findLastDigit(n));
    n=67 ;
    System.out.println(ob.findLastDigit(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
   operation fib( f : Sequence(int)) : void
  pre: true
  post: true
  activity: (     f[0+1] := 0 ; 
     f[1+1] := 1 ; 
         var i : int ; i := 2 ; while i <= 59 do (     f[i+1] := (f[i - 1+1] + f[i - 2+1]) mod 10 ;  ;     i := i + 1 ) );
   operation findLastDigit( n : long) : int
  pre: true
  post: true
  activity: (     var f : Sequence(int) ; f := Integer.subrange(1,60)->collect(0) ;
     execute fib(f) ; 
     var index : int ; index := (n mod 60L)->oclAsType(int) ;
     return f[index+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ;
     var ob : GFG ; ob := GFG.newGFG() ;
    n := 1 ; 
    OclFile["System.out"].println(ob.findLastDigit(n)) ; 
    n := 61 ; 
    OclFile["System.out"].println(ob.findLastDigit(n)) ; 
    n := 7 ; 
    OclFile["System.out"].println(ob.findLastDigit(n)) ; 
    n := 67 ; 
    OclFile["System.out"].println(ob.findLastDigit(n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=null ;
    try {
      sc=new Scanner(System.in);
      int countRectangle=0 ;
      int countRhombus=0 ;
      while(sc.hasNextLine()){
        String[] input=sc.nextLine().split(",");
        int[] sides=convertToInt(input);
        if(isRectangle(sides)){
          countRectangle++;
        }
        else if(isRhombus(sides)){
          countRhombus++;
        }
      }
      System.out.println(countRectangle);
      System.out.println(countRhombus);
    }
    finally {
      sc.close();
    }
  }
  public static boolean isRectangle(int[] side){
    return square(side[0])+square(side[1])==square(side[2]);
  }
  public static boolean isRhombus(int[] side){
    return side[0]==side[1];
  }
  public static int square(int n){
    return n*n ;
  }
  public static int[] convertToInt(String[] strings){
    int[] ints=new int[3];
    for(int i=0 ; i<ints.length ; i++){
      ints[i]=Integer.parseInt(strings[i]);
    }
    return ints ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := null ;
     try (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var countRectangle : int ; countRectangle := 0 ;
    var countRhombus : int ; countRhombus := 0 ;
    while (sc.hasNextLine()) do (     var input : Sequence(String) ; input := sc.nextLine()->split(",") ;
     var sides : Sequence(int) ; sides := convertToInt(input) ;
     if (isRectangle(sides)) then (     countRectangle := countRectangle + 1 ) else     if (isRhombus(sides)) then (     countRhombus := countRhombus + 1 ) else skip ; ) ; 
    OclFile["System.out"].println(countRectangle) ; 
    OclFile["System.out"].println(countRhombus) ; 
 )   finally (     skip )
 );
  static   operation isRectangle( side : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     return square(side[0+1]) + square(side[1+1]) = square(side[2+1]) );
  static   operation isRhombus( side : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     return side[0+1] = side[1+1] );
  static   operation square( n : int) : int
  pre: true
  post: true
  activity: (     return n * n );
  static   operation convertToInt( strings : Sequence(String)) : Sequence(int)
  pre: true
  post: true
  activity: (     var ints : Sequence(int) ; ints := Integer.subrange(1,3)->collect(0) ;
         var i : int ; i := 0 ; while i < ints->size() do ( (     ints[i+1] := (strings[i+1])->toInteger() )  ;     i := i + 1 ) ; 
     return ints );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      double x[]=new double[3];
      double y[]=new double[3];
      String[] str=sc.next().split(",");
      for(int i=0 ; i<3 ; i++){
        x[i]=Double.parseDouble(str[2*i]);
        y[i]=Double.parseDouble(str[2*i+1]);
      }
      double dx=x[1]-x[0];
      double dy=y[1]-y[0];
      double rety=(x[2]-2*x[0])*dx*dy-(y[2]-2*y[0])*dx*dx+dy*dx*x[2]+dy*dy*y[2];
      double retx=(y[2]-2*y[0])*dx*dy-(x[2]-2*x[0])*dy*dy+dx*dx*x[2]+dx*dy*y[2];
      rety/=dx*dx+dy*dy ;
      retx/=dx*dx+dy*dy ;
      System.out.println(retx+" "+rety);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var x : Sequence(double) ; x := Integer.subrange(1,3)->collect(0.0) ;
     var y : Sequence(double) ; y := Integer.subrange(1,3)->collect(0.0) ;
    var str : Sequence(String) ; str := sc.getCurrent()->split(",") ;
        var i : int ; i := 0 ; while i < 3 do ( (     x[i+1] := (str[2 * i+1])->toReal() ; 
     y[i+1] := (str[2 * i + 1+1])->toReal() )  ;     i := i + 1 ) ; 
    var dx : double ; dx := x[1+1] - x[0+1] ;
    var dy : double ; dy := y[1+1] - y[0+1] ;
    var rety : double ; rety := (x[2+1] - 2 * x[0+1]) * dx * dy - (y[2+1] - 2 * y[0+1]) * dx * dx + dy * dx * x[2+1] + dy * dy * y[2+1] ;
    var retx : double ; retx := (y[2+1] - 2 * y[0+1]) * dx * dy - (x[2+1] - 2 * x[0+1]) * dy * dy + dx * dx * x[2+1] + dx * dy * y[2+1] ;
    rety := rety/(dx * dx + dy * dy) ; 
    retx := retx/(dx * dx + dy * dy) ; 
    OclFile["System.out"].println(retx + " " + rety) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class cobb {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    int tcase=Integer.parseInt(f.readLine());
    for(int p=0 ; p<tcase ; p++){
      StringTokenizer st1=new StringTokenizer(f.readLine());
      int n=Integer.parseInt(st1.nextToken());
      int k=Integer.parseInt(st1.nextToken());
      long[] vals=new long[n];
      StringTokenizer st=new StringTokenizer(f.readLine());
      for(int i=0 ; i<n ; i++){
        vals[i]=Long.parseLong(st.nextToken());
      }
      long ans=Long.MIN_VALUE ;
      int start=Math.max(0,n-201);
      for(int i=start ; i<n ; i++){
        for(int j=i+1 ; j<n ; j++){
          ans=Math.max(ans,((long)(i+1)*(long)(j+1))-k*(vals[i] | vals[j]));
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cobb {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tcase : int ; tcase := (f.readLine())->toInteger() ;
         var p : int ; p := 0 ; while p < tcase do ( (     var st1 : OclIterator ; st1 := OclIterator.newOclIterator_String(f.readLine()) ;
     var n : int ; n := (st1.next())->toInteger() ;
    var k : int ; k := (st1.next())->toInteger() ;
    var vals : Sequence(long) ; vals := Integer.subrange(1,n)->collect(0) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
        var i : int ; i := 0 ; while i < n do ( (     vals[i+1] := (st.next())->toLong() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := "-9223372036854775808"->toLong() ;
    var start : int ; start := Set{0, n - 201}->max() ;
        var i : int ; i := start ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     ans := Set{ans, ((i + 1)->oclAsType(long) * (j + 1)->oclAsType(long)) - k * (MathLib.bitwiseOr(vals[i+1],vals[j+1]))}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     p := p + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class new1 {
  public static void main(String[] args)throws IOException {
    FastReader s=new FastReader();
    int t=s.nextInt();
    for(int z=0 ; z<t ; z++){
      int n=s.nextInt();
      int k=s.nextInt();
      int[] arr=new int[n];
      long max=Integer.MIN_VALUE ;
      for(int i=0 ; i<n ; i++)arr[i]=s.nextInt();
      for(int i=n-1 ; i>=Math.max(0,n-210); i--){
        for(int j=n-1 ; j>=Math.max(0,n-210); j--){
          if(i==j)continue ;
          long val=(i+1)*(long)(j+1)-k*(long)(arr[i] | arr[j]);
          max=Math.max(max,val);
        }
      }
      System.out.println(max);
    }
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    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();
  }
  public 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 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class new1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : FastReader ; s := FastReader.newFastReader() ;
     var t : int ; t := s.nextInt() ;
         var z : int ; z := 0 ; while z < t do ( (     var n : int ; n := s.nextInt() ;
     var k : int ; k := s.nextInt() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var max : long ; max := -2147483648 ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := s.nextInt() ;  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= Set{0, n - 210}->max() do ( (         var j : int ; j := n - 1 ; while j >= Set{0, n - 210}->max() do ( (     if (i = j) then     continue else skip ; 
     var val : long ; val := (i + 1) * (j + 1)->oclAsType(long) - k * (MathLib.bitwiseOr(arr[i+1],arr[j+1]))->oclAsType(long) ;
     max := Set{max, val}->max() )  ;     j := j - 1 ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(max) ; 
 )  ;     z := z + 1 ) );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public List<Integer>findDisappearedNumbers(int[] nums){
    List<Integer>ret=new ArrayList<Integer>();
    for(int i=0 ; i<nums.length ; i++){
      int val=Math.abs(nums[i])-1 ;
      if(nums[val]>0){
        nums[val]=-nums[val];
      }
    }
    for(int i=0 ; i<nums.length ; i++){
      if(nums[i]>0){
        ret.add(i+1);
      }
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation findDisappearedNumbers( nums : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var ret : Sequence(int) ; ret := Sequence{} ;
         var i : int ; i := 0 ; while i < nums->size() do ( (     var val : int ; val := if nums[i+1] < 0 then -(nums[i+1]) else nums[i+1] endif - 1 ;
     if (nums[val+1] > 0) then (     nums[val+1] := -nums[val+1] ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < nums->size() do ( (     if (nums[i+1] > 0) then (     ret := ret->including(i + 1) ) else skip )  ;     i := i + 1 ) ; 
     return ret );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  public static int findMaxValue(){
    int res=2 ;
    long fact=2 ;
    while(true){
      if(fact<0)break ;
      res++;
      fact=fact*res ;
    }
    return res-1 ;
  }
  public static void main(String[] args){
    System.out.println("Maximum value of"+" integer "+findMaxValue());
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMaxValue() : int
  pre: true
  post: true
  activity: (     var res : int ; res := 2 ;
     var fact : long ; fact := 2 ;
     while (true) do (     if (fact < 0) then     break else skip ; 
     res := res + 1 ; 
     fact := fact * res ) ; 
     return res - 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Maximum value of" + " integer " + findMaxValue()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static String[] a ;
  static String[] b ;
  static String temp ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    a=scanner.nextLine().split(" ");
    b=scanner.nextLine().split(" ");
    char[] c={
      'E','E','E','N','W','W','W','S' };
      boolean flag=false ;
      for(int i=0 ; i<3 ; i++){
        for(char d : c){
          roll(d);
          if(Arrays.equals(a,b)){
            flag=true ;
            break ;
          }
        }
      }
      if(flag)System.out.println("Yes");
      else System.out.println("No");
    }
    public static void roll(char c){
      switch(c){
        case 'E' : temp=a[0];
        a[0]=a[3];
        a[3]=a[5];
        a[5]=a[2];
        a[2]=temp ;
        break ;
        case 'N' : temp=a[0];
        a[0]=a[1];
        a[1]=a[5];
        a[5]=a[4];
        a[4]=temp ;
        break ;
        case 'W' : temp=a[0];
        a[0]=a[2];
        a[2]=a[5];
        a[5]=a[3];
        a[3]=temp ;
        break ;
        default : temp=a[0];
        a[0]=a[4];
        a[4]=a[5];
        a[5]=a[1];
        a[1]=temp ;
        break ;
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a : Sequence(String);
  static   attribute b : Sequence(String);
  static   attribute temp : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     a := scanner.nextLine()->split(" ") ; 
    b := scanner.nextLine()->split(" ") ; 
    var c : Sequence(String) ; c := Sequence{'E','E','E','N','W','W','W','S'} ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < 3 do ( (     for (d : c) do ( (     execute roll(d) ; 
     if (a = b) then (     flag := true ; 
     break ) else skip )  ) )  ;     i := i + 1 ) ; 
    if (flag) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
  static   operation roll( c : String) : void
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
       if _switchval = 'E' then
     temp := a[0+1] ; 
    a[0+1] := a[3+1] ; 
    a[3+1] := a[5+1] ; 
    a[5+1] := a[2+1] ; 
    a[2+1] := temp ; 
    break 
   else skip ;
       if _switchval = 'N' then
     temp := a[0+1] ; 
    a[0+1] := a[1+1] ; 
    a[1+1] := a[5+1] ; 
    a[5+1] := a[4+1] ; 
    a[4+1] := temp ; 
    break 
   else skip ;
       if _switchval = 'W' then
     temp := a[0+1] ; 
    a[0+1] := a[2+1] ; 
    a[2+1] := a[5+1] ; 
    a[5+1] := a[3+1] ; 
    a[3+1] := temp ; 
    break 
   else skip ;
       if true then
     temp := a[0+1] ; 
    a[0+1] := a[4+1] ; 
    a[4+1] := a[5+1] ; 
    a[5+1] := a[1+1] ; 
    a[1+1] := temp ; 
    break 
   else skip ;
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
public class Main {
  public static void main(String[] args)throws Exception {
    String[] strRing={
      "24532453","64136413","56215621","51265126","63146314","54235423" };
      String strT,strS,strB ;
      int nE=0,nW=0 ;
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String[] strValue=br.readLine().split(" ");
      HashMap<String,String>map=new HashMap<String,String>();
      for(int i=0 ; i<6 ; i++){
        map.put(strValue[i],Integer.toString(i+1));
      }
      String[] str=br.readLine().split(" ");
      strT=map.get(str[0]);
      strS=map.get(str[1]);
      strB=Integer.toString(7-Integer.parseInt(strT));
      String strBST=strB+strS+strT ;
      for(int i=0 ; i<6 ; i++){
        if(-1<strRing[i] .indexOf(strBST)){
          nE=i ;
          nW=5-i ;
        }
      }
      if(strValue[nE] .equals(str[2])&& strValue[nW] .equals(str[3])){
        int nB=Integer.parseInt(strB);
        System.out.println(strValue[nB-1] .equals(str[5])? "Yes" : "No");
      }
      else {
        System.out.println("No");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var strRing : Sequence(String) ; strRing := Sequence{"24532453","64136413","56215621","51265126","63146314","54235423"} ;
     var strT : String ;
    var strS : String ;
    var strB : String ;
    var nE : int ; nE := 0 ;
    var nW : int ; nW := 0 ;
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var strValue : Sequence(String) ; strValue := br.readLine()->split(" ") ;
    var map : Map(String,String) ; map := Map{} ;
        var i : int ; i := 0 ; while i < 6 do ( (     map := map->union(Map{strValue[i+1] |-> ((i + 1) + "")}) )  ;     i := i + 1 ) ; 
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    strT := map->at(str[0+1]) ; 
    strS := map->at(str[1+1]) ; 
    strB := ((7 - (strT)->toInteger()) + "") ; 
    var strBST : String ; strBST := strB + strS + strT ;
        var i : int ; i := 0 ; while i < 6 do ( (     if (-1 < strRing[i+1]->indexOf(strBST)-1) then (     nE := i ; 
     nW := 5 - (i)->char2byte() ) else skip )  ;     i := i + 1 ) ; 
    if (strValue[nE+1] = str[2+1] & strValue[nW+1] = str[3+1]) then (     var nB : int ; nB := (strB)->toInteger() ;
     OclFile["System.out"].println(if strValue[nB - 1+1] = str[5+1] then "Yes" else "No" endif) ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int a[],b[];
    a=new int[7];
    b=new int[7];
    int h ;
    boolean flag=false ;
    for(int i=1 ; i<7 ; i++){
      a[i]=scan.nextInt();
    }
    for(int i=1 ; i<7 ; i++){
      b[i]=scan.nextInt();
    }
    for(int i=0 ; i<6 ; i++){
      for(int j=0 ; j<4 ; j++){
        if(flag==true)break ;
        h=a[2];
        a[2]=a[3];
        a[3]=a[5];
        a[5]=a[4];
        a[4]=h ;
        flag=Arrays.equals(a,b);
      }
      if(i==0 || i==4){
        h=a[1];
        a[1]=a[3];
        a[3]=a[6];
        a[6]=a[4];
        a[4]=h ;
      }
      else {
        h=a[1];
        a[1]=a[2];
        a[2]=a[6];
        a[6]=a[5];
        a[5]=h ;
      }
    }
    if(flag==true){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ;
    var b : Sequence(void) ;
    a := Integer.subrange(1,7)->collect(0) ; 
    b := Integer.subrange(1,7)->collect(0) ; 
    var h : int ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 1 ; while i < 7 do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < 7 do ( (     b[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 6 do ( (         var j : int ; j := 0 ; while j < 4 do ( (     if (flag = true) then     break else skip ; 
     h := a[2+1] ; 
    a[2+1] := a[3+1] ; 
    a[3+1] := a[5+1] ; 
    a[5+1] := a[4+1] ; 
    a[4+1] := h ; 
    flag := a = b ; 
 )  ;     j := j + 1 ) ; 
     if (i = 0 or i = 4) then (     h := a[1+1] ; 
     a[1+1] := a[3+1] ; 
    a[3+1] := a[6+1] ; 
    a[6+1] := a[4+1] ; 
    a[4+1] := h ; 
 ) else (     h := a[1+1] ; 
     a[1+1] := a[2+1] ; 
    a[2+1] := a[6+1] ; 
    a[6+1] := a[5+1] ; 
    a[5+1] := h ; 
 ) )  ;     i := i + 1 ) ; 
    if (flag = true) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class P1411A {
  public static void main(String[] args)throws IOException {
    BufferedReader io=new BufferedReader(new InputStreamReader(System.in));
    Integer cnt=Integer.valueOf(io.readLine());
    List<String>rs=new ArrayList<String>();
    while(cnt>0){
      cnt--;
      Integer len=Integer.valueOf(io.readLine());
      String input=io.readLine();
      Integer tmp=0 ;
      for(int i=input.length()-1 ; i>=0 ; i--){
        if(input.charAt(i)==')'){
          tmp++;
        }
        else {
          break ;
        }
      }
      if(len-tmp>=tmp){
        rs.add("NO");
      }
      else {
        rs.add("YES");
      }
    }
    for(String string : rs){
      System.out.println(string);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P1411A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var cnt : int ; cnt := (io.readLine())->toInteger() ;
    var rs : Sequence(String) ; rs := Sequence{} ;
    while (cnt > 0) do (     cnt := cnt - 1 ; 
     var len : int ; len := (io.readLine())->toInteger() ;
    var input : String ; input := io.readLine() ;
    var tmp : int ; tmp := 0 ;
        var i : int ; i := input->size() - 1 ; while i >= 0 do ( (     if (input->at(i+1) = ')') then (     tmp := tmp + 1 ) else (     break ) )  ;     i := i - 1 ) ; 
    if (len - (tmp)->char2byte() >= tmp) then (     rs := rs->including("NO") ) else (     rs := rs->including("YES") ) ;  
 ) ; 
    for (string : rs) do ( (     OclFile["System.out"].println(string) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static String[] a ;
  static String[] b ;
  static String temp ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    a=scanner.nextLine().split(" ");
    b=scanner.nextLine().split(" ");
    char[] c={
      'E','E','E','N','W','W','W','S' };
      boolean flag=false ;
      for(int i=0 ; i<3 ; i++){
        for(char d : c){
          roll(d);
          if(Arrays.equals(a,b)){
            flag=true ;
            break ;
          }
        }
      }
      if(flag)System.out.println("Yes");
      else System.out.println("No");
    }
    public static void roll(char c){
      switch(c){
        case 'E' : temp=a[0];
        a[0]=a[3];
        a[3]=a[5];
        a[5]=a[2];
        a[2]=temp ;
        break ;
        case 'N' : temp=a[0];
        a[0]=a[1];
        a[1]=a[5];
        a[5]=a[4];
        a[4]=temp ;
        break ;
        case 'W' : temp=a[0];
        a[0]=a[2];
        a[2]=a[5];
        a[5]=a[3];
        a[3]=temp ;
        break ;
        default : temp=a[0];
        a[0]=a[4];
        a[4]=a[5];
        a[5]=a[1];
        a[1]=temp ;
        break ;
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a : Sequence(String);
  static   attribute b : Sequence(String);
  static   attribute temp : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     a := scanner.nextLine()->split(" ") ; 
    b := scanner.nextLine()->split(" ") ; 
    var c : Sequence(String) ; c := Sequence{'E','E','E','N','W','W','W','S'} ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < 3 do ( (     for (d : c) do ( (     execute roll(d) ; 
     if (a = b) then (     flag := true ; 
     break ) else skip )  ) )  ;     i := i + 1 ) ; 
    if (flag) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
  static   operation roll( c : String) : void
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
       if _switchval = 'E' then
     temp := a[0+1] ; 
    a[0+1] := a[3+1] ; 
    a[3+1] := a[5+1] ; 
    a[5+1] := a[2+1] ; 
    a[2+1] := temp ; 
    break 
   else skip ;
       if _switchval = 'N' then
     temp := a[0+1] ; 
    a[0+1] := a[1+1] ; 
    a[1+1] := a[5+1] ; 
    a[5+1] := a[4+1] ; 
    a[4+1] := temp ; 
    break 
   else skip ;
       if _switchval = 'W' then
     temp := a[0+1] ; 
    a[0+1] := a[2+1] ; 
    a[2+1] := a[5+1] ; 
    a[5+1] := a[3+1] ; 
    a[3+1] := temp ; 
    break 
   else skip ;
       if true then
     temp := a[0+1] ; 
    a[0+1] := a[4+1] ; 
    a[4+1] := a[5+1] ; 
    a[5+1] := a[1+1] ; 
    a[1+1] := temp ; 
    break 
   else skip ;
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
import java.util.regex.Pattern ;
import java.util.regex.Matcher ;
class Main {
  public static int calc_plastic(int l1,int l2,int d){
    int l1a,l2a,da ;
    l1a=(int)Math.pow(l1,2);
    l2a=(int)Math.pow(l2,2);
    da=(int)Math.pow(d,2);
    if(l1==l2)return 2 ;
    else if(l1a+l2a==da)return 1 ;
    return 0 ;
  }
  public static void plastic(ArrayList<Integer>list){
    int oblong=0,diamond=0 ;
    int len1,len2,diag,res ;
    for(int i=0 ; i<list.size()/3 ; i++){
      len1=list.get(i*3);
      len2=list.get(i*3+1);
      diag=list.get(i*3+2);
      res=calc_plastic(len1,len2,diag);
      if(res==1)oblong++;
      else if(res==2)diamond++;
    }
    System.out.println(oblong);
    System.out.println(diamond);
  }
  public static void main(String args[])throws IOException {
    String str ;
    ArrayList<Integer>inp=new ArrayList<Integer>();
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      str=scan.next();
      String[] strAry=new String[str.length()];
      strAry=str.split(",");
      for(int j=0 ; j<strAry.length ; j++){
        Pattern p=Pattern.compile("[0-9]*");
        Matcher m=p.matcher(strAry[j]);
        if(m.find()){
          int x=Integer.valueOf(m.group(0)).intValue();
          inp.add(x);
        }
      }
    }
    plastic(inp);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation calc_plastic( l1 : int, l2 : int, d : int) : int
  pre: true
  post: true
  activity: (     var l1a : int ;
    var l2a : int ;
    var da : int ;
     l1a := l1->pow(2)->oclAsType(int) ; 
    l2a := l2->pow(2)->oclAsType(int) ; 
    da := d->pow(2)->oclAsType(int) ; 
    if (l1 = l2) then     return 2 else     if (l1a + l2a = da) then     return 1 else skip ; ;  
    return 0 
 );
  static   operation plastic( list : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var oblong : int ; oblong := 0 ;
    var diamond : int ; diamond := 0 ;
     var len1 : int ;
    var len2 : int ;
    var diag : int ;
    var res : int ;
        var i : int ; i := 0 ; while i < list->size() / 3 do ( (     len1 := list->at(i * 3+1) ; 
     len2 := list->at(i * 3 + 1+1) ; 
    diag := list->at(i * 3 + 2+1) ; 
    res := calc_plastic(len1, len2, diag) ; 
    if (res = 1) then     oblong := oblong + 1 else     if (res = 2) then     diamond := diamond + 1 ; else skip ; ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(oblong) ; 
    OclFile["System.out"].println(diamond) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ;
     var inp : Sequence(int) ; inp := Sequence{} ;
    var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (scan.hasNext()) do (     str := scan.getCurrent() ; 
     var strAry : Sequence(String) ; strAry := Integer.subrange(1,str->size())->collect(null) ;
     strAry := str->split(",") ; 
         var j : int ; j := 0 ; while j < strAry->size() do ( (     var p : OclRegex ; p := OclRegex.compile("[0-9]*") ;
     var m : OclRegex ; m := p.matcher(strAry[j+1]) ;
     if (m.nextMatch()) then (     var x : int ; x := (m.group(0))->toInteger()->oclAsType(int) ;
     inp := inp->including(x) ) else skip )  ;     j := j + 1 ) ) ; 
    execute plastic(inp) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static int count(String s,char value){
    int cnt=0 ;
    for(int i=0 ; i<s.length(); i++)if(s.charAt(i)==value)cnt++;
    return cnt ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      HashSet<Integer>ss=new HashSet<>();
      for(int i=0 ; i<n ; i++){
        int k=sc.nextInt();
        if(ss.contains(k)){
          ss.add(-k);
        }
        else ss.add(k);
      }
      System.out.println(ss.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation count( s : String, value : String) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < s->size() do (     if (s->at(i+1) = value) then     cnt := cnt + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ss : Set(int) ; ss := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     var k : int ; k := sc.getCurrent()->toInteger() ;
     if (ss->includes(k)) then (     ss := ss->including(-k) ) else     ss := ss->including(k) ; )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ss->size()) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedHashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class A1616 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      int n=scanner.nextInt();
      Set<Integer>set=new LinkedHashSet<Integer>();
      for(int i=0 ; i<n ; i++){
        int a=scanner.nextInt();
        if(set.contains(a)){
          set.add(-a);
        }
        else {
          set.add(a);
        }
      }
      System.out.println(set.size());
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1616 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var set : Set(int) ; set := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     if (set->includes(a)) then (     set := set->including(-a) ) else (     set := set->including(a) ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(set->size()) ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class A1616 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    while(test-->0){
      int n=sc.nextInt();
      HashSet<Integer>hs=new HashSet<>();
      for(int i=0 ; i<n ; i++){
        int k=sc.nextInt();
        if(hs.contains(k))hs.add(-k);
        hs.add(k);
      }
      System.out.println(hs.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1616 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var hs : Set(int) ; hs := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     var k : int ; k := sc.getCurrent()->toInteger() ;
     if (hs->includes(k)) then     hs := hs->including(-k) ; else skip ; 
     hs := hs->including(k) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(hs->size()) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        int n=sc.nextInt();
        long arr[]=new long[n];
        Set<Long>set=new HashSet<>();
        for(int i=0 ; i<n ; i++){
          arr[i]=sc.nextInt();
          if(set.contains(arr[i])){
            arr[i]*=-1 ;
            set.add(arr[i]);
          }
          else {
            set.add(arr[i]);
          }
        }
        System.out.println(set.size());
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
    var set : Set(long) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (set->includes(arr[i+1])) then (     arr[i+1] := arr[i+1]*(-1) ; 
     set := set->including(arr[i+1]) ) else (     set := set->including(arr[i+1]) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(set->size()) ; 
 ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class pair {
    int first,second ;
    public pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static void primesieve(boolean[] prime){
    prime[1]=false ;
    for(int p=2 ; p*p<=650 ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=650 ; i+=p)prime[i]=false ;
      }
    }
  }
  static pair sum_sqsum(int n){
    int sum=0 ;
    int sqsum=0 ;
    int x ;
    while(n>0){
      x=n % 10 ;
      sum+=x ;
      sqsum+=x*x ;
      n/=10 ;
    }
    return(new pair(sum,sqsum));
  }
  static int countnumber(int L,int R){
    boolean[] prime=new boolean[651];
    Arrays.fill(prime,true);
    primesieve(prime);
    int cnt=0 ;
    for(int i=L ; i<=R ; i++){
      pair digit=sum_sqsum(i);
      if(prime[digit.first] && prime[digit.second]){
        cnt+=1 ;
      }
    }
    return cnt ;
  }
  public static void main(String[] args){
    int L=10 ;
    int R=20 ;
    System.out.println(countnumber(L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class pair {
   attribute first : int;
   static operation newpair( first : int, second : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation primesieve( prime : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p <= 650 do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= 650 do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation sum_sqsum( n : int) : pair
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var sqsum : int ; sqsum := 0 ;
    var x : int ;
    while (n > 0) do (     x := n mod 10 ; 
     sum := sum+(x) ; 
     sqsum := sqsum+(x * x) ; 
     n := n/(10) ) ; 
    return (pair.newpair(sum, sqsum)) 
 );
  static   operation countnumber( L : int, R : int) : int
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,651)->collect(false) ;
     prime := prime->collect(true) ; 
    execute primesieve(prime) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := L ; while i <= R do ( (     var digit : pair ; digit := sum_sqsum(i) ;
     if (prime[digit->at("first")+1] & prime[digit->at("second")+1]) then (     cnt := cnt+(1) ) else skip )  ;     i := i + 1 ) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 10 ;
     var R : int ; R := 20 ;
     OclFile["System.out"].println(countnumber(L, R)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  static void printRepeating(Integer[] arr,int size){
    SortedSet<Integer>s=new TreeSet<>();
    Collections.addAll(s,arr);
    System.out.print(s);
  }
  public static void main(String args[]){
    Integer[] arr={
      1,3,2,2,1 };
      int n=arr.length ;
      printRepeating(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printRepeating( arr : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
 addAll(s, arr) ; 
     OclFile["System.out"].print(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,2,2,1} ;
     var n : int ; n := arr->size() ;
     execute printRepeating(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public final class p225 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p225().run());
  }
  private static final int INDEX=124 ;
  public String run(){
    int count=0 ;
    for(int i=1 ; ; i+=2){
      if(! hasTribonacciMultiple(i)){
        count++;
        if(count==INDEX)return Integer.toString(i);
      }
    }
  }
  private static boolean hasTribonacciMultiple(int modulus){
    int[] slow={
      1,1,1 };
      int[] fast=slow.clone();
      for(boolean head=true ; ; head=false){
        if(slow[0] % modulus==0)return true ;
        if(! head && Arrays.equals(slow,fast))return false ;
        tribonacci(slow,modulus);
        tribonacci(fast,modulus);
        tribonacci(fast,modulus);
      }
    }
    private static void tribonacci(int[] state,int mod){
      int a=state[0];
      int b=state[1];
      int c=state[2];
      state[0]=b ;
      state[1]=c ;
      state[2]=(a+b+c)% mod ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class p225 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p225.newp225().run()) );
  static    attribute INDEX : int := 124;
   operation run() : String
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while true do ( (     if (not(hasTribonacciMultiple(i))) then (     count := count + 1 ; 
     if (count = INDEX) then     return ((i) + "") else skip ) else skip )  ;     i := i+(2) ) );
  static   operation hasTribonacciMultiple( modulus : int) : boolean
  pre: true
  post: true
  activity: (     var slow : Sequence(int) ; slow := Sequence{1,1,1} ;
     var fast : Sequence(int) ; fast := slow->copy() ;
         var head : boolean ; head := true ; while true do ( (     if (slow[0+1] mod modulus = 0) then     return true else skip ; 
     if (not(head) & slow = fast) then     return false else skip ; 
    execute tribonacci(slow, modulus) ; 
    execute tribonacci(fast, modulus) ; 
    execute tribonacci(fast, modulus) ; 
 )  ;     head := false ) );
  static   operation tribonacci( state : Sequence(int), mod : int) : void
  pre: true
  post: true
  activity: (     var a : int ; a := state[0+1] ;
     var b : int ; b := state[1+1] ;
    var c : int ; c := state[2+1] ;
    state[0+1] := b ; 
    state[1+1] := c ; 
    state[2+1] := (a + b + c) mod mod ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GfG {
  static void solution(int a,int b,int n){
    for(int i=0 ; i*a<=n ; i++){
      if((n-(i*a))% b==0){
        System.out.println("x="+i+",y="+(n-(i*a))/b);
        return ;
      }
    }
    System.out.println("No solution");
  }
  public static void main(String[] args){
    int a=2,b=3,n=7 ;
    solution(a,b,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation solution( a : int, b : int, n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i * a <= n do ( (     if ((n - (i * a)) mod b = 0) then (     OclFile["System.out"].println("x=" + i + ",y=" + (n - (i * a)) / b) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("No solution") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2 ;
    var b : int ; b := 3 ;
    var n : int ; n := 7 ;
     execute solution(a, b, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder();
    int t=fs.nextInt();
    while(t-->0){
      int n=fs.nextInt();
      String s=fs.next();
      int ch=0 ;
      for(int i=n-1 ; i>=0 ; i--){
        if(s.charAt(i)!=')')break ;
        ch++;
      }
      sb.append((ch>n-ch)? "Yes" : "No").append("\n");
    }
    out.print(sb);
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long[] readArray(int n){
      long[] a=new long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    var t : int ; t := fs.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := fs.nextInt() ;
     var s : String ; s := fs.next() ;
    var ch : int ; ch := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (s->at(i+1) /= ')') then     break else skip ; 
     ch := ch + 1 )  ;     i := i - 1 ) ; 
    sb := sb + StringLib.newString(if (ch > n - (ch)->char2byte()) then "Yes" else "No" endif) + StringLib.newString("\n") ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class HighSchool987B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long x=in.nextInt();
    long y=in.nextInt();
    long x_y=(long)Math.pow(x,y);
    long y_x=(long)Math.pow(y,x);
    if(x_y>y_x){
      System.out.println('>');
      return ;
    }
    else if(x_y<y_x){
      System.out.println('<');
      return ;
    }
    else if(x==y || x_y==y_x && x_y<999999999){
      System.out.println('=');
      return ;
    }
    if(x>y)System.out.println('<');
    else System.out.println('>');
  }
}
------------------------------------------------------------
OCL File:
---------
 class HighSchool987B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := in.getCurrent()->toInteger() ;
    var y : long ; y := in.getCurrent()->toInteger() ;
    var x_y : long ; x_y := x->pow(y)->oclAsType(long) ;
    var y_x : long ; y_x := y->pow(x)->oclAsType(long) ;
    if (x_y > y_x) then (     OclFile["System.out"].println('>') ; 
     return ) else     if (x_y < y_x) then (     OclFile["System.out"].println('<') ; 
     return ) else     if (x = y or x_y = y_x & x_y < 999999999) then (     OclFile["System.out"].println('=') ; 
     return ) else skip ; ;  ;  
    if (x > y) then     OclFile["System.out"].println('<') else     OclFile["System.out"].println('>') ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int x=sc.nextInt();
      int y=sc.nextInt();
      double xy=Math.log(x)*y ;
      double yx=Math.log(y)*x ;
      if(xy>yx){
        System.out.println(">");
      }
      else if(xy<yx){
        System.out.println("<");
      }
      else {
        System.out.println("=");
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var xy : double ; xy := (x)->log() * y ;
    var yx : double ; yx := (y)->log() * x ;
    if (xy > yx) then (     OclFile["System.out"].println(">") ) else     if (xy < yx) then (     OclFile["System.out"].println("<") ) else (     OclFile["System.out"].println("=") ) ;  ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    int[] aParam=null ;
    int nSquare=0 ;
    int nDia=0 ;
    while((aParam=parseParam())!=null){
      if(aParam[0]!=0 && aParam[1]!=0 && aParam[2]!=0){
        if(aParam[0]==aParam[1]){
          nDia++;
        }
        if((aParam[0]*aParam[0]+aParam[1]*aParam[1])==aParam[2]*aParam[2]){
          nSquare++;
        }
      }
    }
    System.out.println(nSquare);
    System.out.println(nDia);
  }
  private static int[] parseParam(){
    int[] aParam=null ;
    String strIn=null ;
    if((strIn=parseStdin())!=null){
      String[] aN=strIn.split(",");
      aParam=new int[3];
      aParam[0]=Integer.parseInt(aN[0]);
      aParam[1]=Integer.parseInt(aN[1]);
      aParam[2]=Integer.parseInt(aN[2]);
    }
    return aParam ;
  }
  private static String parseStdin(){
    String strNum=null ;
    try {
      String line=br.readLine();
      if(line!=null){
        if(! line.isEmpty()){
          strNum=line ;
        }
      }
    }
    catch(IOException e){
    }
    return strNum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var aParam : Sequence(int) ; aParam := null ;
     var nSquare : int ; nSquare := 0 ;
    var nDia : int ; nDia := 0 ;
        aParam := parseParam() ;
    while ((aParam) /= null) do (    skip ; (     if (aParam[0+1] /= 0 & aParam[1+1] /= 0 & aParam[2+1] /= 0) then (     if (aParam[0+1] = aParam[1+1]) then (     nDia := nDia + 1 ) else skip ; 
     if ((aParam[0+1] * aParam[0+1] + aParam[1+1] * aParam[1+1]) = aParam[2+1] * aParam[2+1]) then (     nSquare := nSquare + 1 ) else skip ) else skip ) ;     aParam := parseParam() ;
 ) ;  
    OclFile["System.out"].println(nSquare) ; 
    OclFile["System.out"].println(nDia) ; 
 );
  static   operation parseParam() : Sequence(int)
  pre: true
  post: true
  activity: (     var aParam : Sequence(int) ; aParam := null ;
     var strIn : String ; strIn := null ;
     if ((strIn) /= null) then (     var aN : Sequence(String) ; aN := strIn->split(",") ;
     aParam := Integer.subrange(1,3)->collect(0) ; 
    aParam[0+1] := (aN[0+1])->toInteger() ; 
    aParam[1+1] := (aN[1+1])->toInteger() ; 
    aParam[2+1] := (aN[2+1])->toInteger() ; 
 ) else skip ; 
     return aParam );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var strNum : String ; strNum := null ;
     try (     var line : String ; line := br.readLine() ;
     if (line /= null) then (     if (not(line->isEmpty())) then (     strNum := line ) else skip ) else skip )   catch (e : IOException) do skip
     return strNum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int x=sc.nextInt();
      int y=sc.nextInt();
      double xy=Math.log(x)/x ;
      double yx=Math.log(y)/y ;
      if(xy>yx){
        System.out.println(">");
      }
      else if(xy<yx){
        System.out.println("<");
      }
      else {
        System.out.println("=");
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var xy : double ; xy := (x)->log() / x ;
    var yx : double ; yx := (y)->log() / y ;
    if (xy > yx) then (     OclFile["System.out"].println(">") ) else     if (xy < yx) then (     OclFile["System.out"].println("<") ) else (     OclFile["System.out"].println("=") ) ;  ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import static java.lang.System.out ;
public class pre124 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    double x=obj.nextInt(),y=obj.nextInt();
    if(Double.compare(x,1d)==0 && Double.compare(y,1d)==0){
      out.println("=");
      return ;
    }
    int com=Double.compare(y/x,Math.log(y)/Math.log(x));
    String ans=com==0 ? "=" :(com>0)? ">" : "<" ;
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre124 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var x : double ; x := obj.nextInt() ;
    var y : double ; y := obj.nextInt() ;
    if ((x)->compareTo(1d) = 0 & (y)->compareTo(1d) = 0) then (     out.println("=") ; 
     return ) else skip ; 
    var com : int ; com := (y / x)->compareTo((y)->log() / (x)->log()) ;
    var ans : String ; ans := if com = 0 then "=" else if (com > 0) then ">" else "<" endif endif ;
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long n,d ;
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long a=in.nextLong(),b=in.nextLong();
    double apow=b*Math.log(a);
    double bpow=a*Math.log(b);
    if(a==b){
      pw.println("=");
    }
    else {
      if(apow==bpow){
        pw.println("=");
      }
      else if(apow<bpow){
        pw.println("<");
      }
      else {
        pw.println(">");
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : long ; a := in.getCurrent()->toLong() ;
    var b : long ; b := in.getCurrent()->toLong() ;
    var apow : double ; apow := b * (a)->log() ;
    var bpow : double ; bpow := a * (b)->log() ;
    if (a = b) then (     skip ) else (     if (apow = bpow) then (     skip ) else     if (apow < bpow) then (     skip ) else (     skip ) ;  ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int N=parseInt(br.readLine());
    String S=br.readLine();
    int ans=S.indexOf("xx")+1 ;
    System.out.println(ans>0 ? ans : N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var N : int ; N := parseInt(br.readLine()) ;
    var S : String ; S := br.readLine() ;
    var ans : int ; ans := S->indexOf("xx")-1 + 1 ;
    OclFile["System.out"].println(if ans > 0 then ans else N endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int i ;
    String str=sc.next();
    for(i=0 ; i<n-1 ; i++){
      if((str.charAt(i)=='x')&&(str.charAt(i+1)=='x'))break ;
    }
    System.out.println(i+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var i : int ;
    var str : String ; str := sc.getCurrent() ;
        i := 0 ; while i < n - 1 do ( (     if ((str->at(i+1) = 'x') & (str->at(i + 1+1) = 'x')) then     break else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(i + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.nextLine());
    String line=sc.nextLine();
    int count=0 ;
    int answer=n ;
    for(int i=0 ; i<n ; i++){
      if(line.charAt(i)=='x'){
        count+=1 ;
      }
      else {
        count=0 ;
      }
      if(count==2){
        answer=i ;
        break ;
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.nextLine())->toInteger() ;
    var line : String ; line := sc.nextLine() ;
    var count : int ; count := 0 ;
    var answer : int ; answer := n ;
        var i : int ; i := 0 ; while i < n do ( (     if (line->at(i+1) = 'x') then (     count := count+(1) ) else (     count := 0 ) ;  
     if (count = 2) then (     answer := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] s=sc.next().toCharArray();
    boolean lastWrong=false ;
    int ans=n ;
    for(int i=0 ; i<n ; i++){
      if(s[i]=='o'){
        lastWrong=false ;
      }
      else {
        if(lastWrong){
          ans=i ;
          break ;
        }
        lastWrong=true ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var lastWrong : boolean ; lastWrong := false ;
    var ans : int ; ans := n ;
        var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] = 'o') then (     lastWrong := false ) else (     if (lastWrong) then (     ans := i ; 
     break ) else skip ; 
     lastWrong := true ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.*;
public class akarshanand2810 {
  public static void main(String[] args)throws IOException {
    solve();
  }
  public static void solve()throws IOException {
    Reader sc=new Reader();
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    char[] arr=sc.next().toCharArray();
    int cnt=0 ;
    List<Integer>idx=new ArrayList<>();
    for(int i=0 ; i<n-1 ; i=i+2){
      if(arr[i]==arr[i+1]){
        cnt++;
        idx.add(i);
      }
    }
    System.out.println(cnt);
    for(int index : idx){
      if(arr[index]=='a')arr[index]='b' ;
      else arr[index]='a' ;
    }
    out.println(new String(arr));
    out.flush();
  }
  static class Reader {
    BufferedReader br ;
    StringTokenizer st ;
    public Reader(){
      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 {
        if(st.hasMoreTokens())str=st.nextToken("\n");
        else str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class akarshanand2810 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
    var cnt : int ; cnt := 0 ;
    var idx : Sequence(int) ; idx := Sequence{} ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] = arr[i + 1+1]) then (     cnt := cnt + 1 ; 
     idx := idx->including(i) ) else skip )  ;     i := i + 2 ) ; 
    OclFile["System.out"].println(cnt) ; 
    for (index : idx) do ( (     if (arr[index+1] = 'a') then     arr[index+1] := 'b' ; else     arr[index+1] := 'a' ; )  ) ; 
    skip ; 
    skip ; 
 );
  static class Reader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newReader() : Reader
  pre: true
  post: true
  activity:
  ( var self : Reader ;
    self := createReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then     str := st.nextToken("\n") ; else     str := br.readLine() ; )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] arr=sc.next().toCharArray();
    char prev='o' ;
    for(int i=1 ; i<n ; i++){
      if(arr[i]=='x' && arr[i-1]=='x'){
        System.out.println(i);
        return ;
      }
    }
    System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
    var prev : String ; prev := 'o' ;
        var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] = 'x' & arr[(i)->char2byte() - 1+1] = 'x') then (     OclFile["System.out"].println(i) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int H=sc.nextInt();
    int W=sc.nextInt();
    boolean[][] a=new boolean[H][W];
    for(int i=0 ; i<H ; i++){
      String str=sc.next();
      for(int j=0 ; j<W ; j++)a[i][j]=str.charAt(j)=='#' ;
    }
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        pw.print((i==0 ||(i<H-1 &&(j % 2==0 || a[i][j])))? '#' : '.');
      }
      pw.println();
    }
    pw.println();
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        pw.print((i==H-1 ||(i>0 &&(j % 2==1 || a[i][j])))? '#' : '.');
      }
      pw.println();
    }
    sc.close();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(boolean)) ; a := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(false)) ;
        var i : int ; i := 0 ; while i < H do ( (     var str : String ; str := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < W do (     a[i+1][j+1] := str->at(j+1) = '#' ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     skip )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     skip )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    char[][] reds=new char[h][w];
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        if(j==0 ||(j!=w-1 && i % 2==0)){
          reds[i][j]='#' ;
        }
        else {
          reds[i][j]='.' ;
        }
      }
    }
    StringBuilder red=new StringBuilder();
    StringBuilder blue=new StringBuilder();
    char[][] blues=new char[h][w];
    for(int i=0 ; i<h ; i++){
      char[] line=sc.next().toCharArray();
      for(int j=0 ; j<w ; j++){
        if(reds[i][j]=='#'){
          blues[i][j]='.' ;
        }
        else {
          blues[i][j]='#' ;
        }
        if(line[j]=='#'){
          reds[i][j]='#' ;
          blues[i][j]='#' ;
        }
      }
      red.append(new String(reds[i])).append("\n");
      blue.append(new String(blues[i])).append("\n");
    }
    System.out.println(red);
    System.out.print(blue);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var reds : Sequence(Sequence(String)) ; reds := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (j = 0 or (j /= w - 1 & i mod 2 = 0)) then (     reds[i+1][j+1] := '#' ) else (     reds[i+1][j+1] := '.' ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var red : String ; red := StringLib.newString() ;
    var blue : String ; blue := StringLib.newString() ;
    var blues : Sequence(Sequence(String)) ; blues := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (     var line : Sequence(String) ; line := sc.getCurrent()->characters() ;
         var j : int ; j := 0 ; while j < w do ( (     if (reds[i+1][j+1] = '#') then (     blues[i+1][j+1] := '.' ) else (     blues[i+1][j+1] := '#' ) ;  
     if (line[j+1] = '#') then (     reds[i+1][j+1] := '#' ; 
     blues[i+1][j+1] := '#' ) else skip )  ;     j := j + 1 ) ; 
     red := red + StringLib.newString(StringLib.newString(reds[i+1])) + StringLib.newString("\n") ; 
     blue := blue + StringLib.newString(StringLib.newString(blues[i+1])) + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(red) ; 
    OclFile["System.out"].print(blue) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int rectangle,rhomboid ;
  static String line ;
  static String[] input=new String[3];
  public static void main(String[] args){
    while(read()){
      slove();
    }
    System.out.println(rectangle);
    System.out.println(rhomboid);
  }
  static boolean read(){
    line=sc.nextLine();
    if(sc.hasNext()==false)return false ;
    input=line.split(",");
    return true ;
  }
  static void slove(){
    int w,h,diagonal ;
    String tmp ;
    tmp=input[0];
    w=Integer.parseInt(tmp);
    tmp=input[1];
    h=Integer.parseInt(tmp);
    tmp=input[2];
    diagonal=Integer.parseInt(tmp);
    if(w==h){
      if(w*w+h*h!=diagonal*diagonal)rhomboid++;
    }
    else {
      if(w*w+h*h==diagonal*diagonal)rectangle++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute rectangle : int;
  static   attribute line : String;
  static   attribute input : Sequence(String) := Integer.subrange(1,3)->collect(null);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (read()) do (     execute slove() ) ; 
     OclFile["System.out"].println(rectangle) ; 
     OclFile["System.out"].println(rhomboid) );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     line := sc.nextLine() ; 
     if (sc.hasNext() = false) then     return false else skip ; 
     input := line->split(",") ; 
     return true );
  static   operation slove() : void
  pre: true
  post: true
  activity: (     var w : int ;
    var h : int ;
    var diagonal : int ;
     var tmp : String ;
    tmp := input[0+1] ; 
    w := (tmp)->toInteger() ; 
    tmp := input[1+1] ; 
    h := (tmp)->toInteger() ; 
    tmp := input[2+1] ; 
    diagonal := (tmp)->toInteger() ; 
    if (w = h) then (     if (w * w + h * h /= diagonal * diagonal) then     rhomboid := rhomboid + 1 ; else skip ) else (     if (w * w + h * h = diagonal * diagonal) then     rectangle := rectangle + 1 ; else skip ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int MOD=1000000007 ;
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    boolean[][] redField=new boolean[h][w];
    for(int i=0 ; i<h ; i++){
      if(i % 2==0){
        redField[i][0]=true ;
      }
      else {
        for(int j=0 ; j<w-1 ; j++){
          redField[i][j]=true ;
        }
      }
    }
    boolean[][] blueField=new boolean[h][w];
    for(int i=0 ; i<h ; i++){
      if(i % 2==1){
        blueField[i][w-1]=true ;
      }
      else {
        for(int j=1 ; j<w ; j++){
          blueField[i][j]=true ;
        }
      }
    }
    StringBuilder blueOut=new StringBuilder();
    StringBuilder redOut=new StringBuilder();
    for(int i=0 ; i<h ; i++){
      char[] arr=sc.next().toCharArray();
      for(int j=0 ; j<w ; j++){
        if(arr[j]=='#'){
          redField[i][j]=true ;
          blueField[i][j]=true ;
        }
        if(redField[i][j]){
          redOut.append("#");
        }
        else {
          redOut.append(".");
        }
        if(blueField[i][j]){
          blueOut.append("#");
        }
        else {
          blueOut.append(".");
        }
      }
      redOut.append("\n");
      blueOut.append("\n");
    }
    System.out.println(redOut);
    System.out.print(blueOut);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var redField : Sequence(Sequence(boolean)) ; redField := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(false)) ;
        var i : int ; i := 0 ; while i < h do ( (     if (i mod 2 = 0) then (     redField[i+1][0+1] := true ) else (         var j : int ; j := 0 ; while j < w - 1 do ( (     redField[i+1][j+1] := true )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
    var blueField : Sequence(Sequence(boolean)) ; blueField := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(false)) ;
        var i : int ; i := 0 ; while i < h do ( (     if (i mod 2 = 1) then (     blueField[i+1][w - 1+1] := true ) else (         var j : int ; j := 1 ; while j < w do ( (     blueField[i+1][j+1] := true )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
    var blueOut : String ; blueOut := StringLib.newString() ;
    var redOut : String ; redOut := StringLib.newString() ;
        var i : int ; i := 0 ; while i < h do ( (     var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
         var j : int ; j := 0 ; while j < w do ( (     if (arr[j+1] = '#') then (     redField[i+1][j+1] := true ; 
     blueField[i+1][j+1] := true ) else skip ; 
     if (redField[i+1][j+1]) then (     redOut := redOut + StringLib.newString("#") ) else (     redOut := redOut + StringLib.newString(".") ) ;  
     if (blueField[i+1][j+1]) then (     blueOut := blueOut + StringLib.newString("#") ) else (     blueOut := blueOut + StringLib.newString(".") ) )  ;     j := j + 1 ) ; 
     redOut := redOut + StringLib.newString("\n") ; 
     blueOut := blueOut + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(redOut) ; 
    OclFile["System.out"].print(blueOut) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner in=new Scanner(System.in)){
      new Main().solve(in);
    }
  }
  private void solve(Scanner in){
    int H=in.nextInt(),W=in.nextInt();
    char[][] a=new char[H][W];
    for(int i=0 ; i<H ; i++){
      a[i]=in.next().toCharArray();
    }
    char[][] r=new char[H][W];
    char[][] b=new char[H][W];
    for(int i=0 ; i<H ; i++){
      Arrays.fill(r[i],DOT);
      Arrays.fill(b[i],DOT);
      r[i][0]=SHA ;
      b[i][W-1]=SHA ;
      for(int j=1 ; j<W-1 ; j++){
        r[i][j]=(i % 2==0)? SHA : DOT ;
        b[i][j]=(i % 2==1)? SHA : DOT ;
      }
    }
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        if(a[i][j]==SHA){
          r[i][j]=SHA ;
          b[i][j]=SHA ;
        }
      }
    }
    show(r);
    System.out.println();
    show(b);
  }
  private static final char DOT='.',SHA='#' ;
  private void show(char[][] cs){
    for(int i=0 ; i<cs.length ; i++){
      System.out.println(new String(cs[i]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     Main.newMain().solve(in) ))  );
   operation solve( in : OclFile) : void
  pre: true
  post: true
  activity: (     var H : int ; H := in.getCurrent()->toInteger() ;
    var W : int ; W := in.getCurrent()->toInteger() ;
     var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var i : int ; i := 0 ; while i < H do ( (     a[i+1] := in.getCurrent()->characters() )  ;     i := i + 1 ) ; 
    var r : Sequence(Sequence(String)) ; r := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
    var b : Sequence(Sequence(String)) ; b := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var i : int ; i := 0 ; while i < H do ( (     r[i+1] := r[i+1]->collect(DOT) ; 
     b[i+1] := b[i+1]->collect(DOT) ; 
    r[i+1][0+1] := SHA ; 
    b[i+1][W - 1+1] := SHA ; 
        var j : int ; j := 1 ; while j < W - 1 do ( (     r[i+1][j+1] := if (i mod 2 = 0) then SHA else DOT endif ; 
     b[i+1][j+1] := if (i mod 2 = 1) then SHA else DOT endif )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (a[i+1][j+1] = SHA) then (     r[i+1][j+1] := SHA ; 
     b[i+1][j+1] := SHA ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    execute show(r) ; 
    OclFile["System.out"].println() ; 
    execute show(b) ; 
 );
  static    attribute DOT : String := '.';
   operation show( cs : Sequence(Sequence(String))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < cs->size() do ( (     OclFile["System.out"].println(StringLib.newString(cs[i+1])) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    char[][] a=new char[H][W];
    for(int i=0 ; i<H ; ++i){
      a[i]=sc.next().toCharArray();
    }
    for(int i=0 ; i<H ; ++i){
      for(int j=0 ; j<W ; ++j){
        if(j!=W-1 &&(j==0 || a[i][j]=='#' || i % 2==0)){
          System.out.print('#');
        }
        else {
          System.out.print('.');
        }
      }
      System.out.println();
    }
    System.out.println();
    for(int i=0 ; i<H ; ++i){
      for(int j=0 ; j<W ; ++j){
        if(j!=0 &&(j==W-1 || a[i][j]=='#' || i % 2==1)){
          System.out.print('#');
        }
        else {
          System.out.print('.');
        }
      }
      System.out.println();
    }
  }
  void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var i : int ; i := 0 ; while i < H do ( (     a[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (j /= W - 1 & (j = 0 or a[i+1][j+1] = '#' or i mod 2 = 0)) then (     OclFile["System.out"].print('#') ) else (     OclFile["System.out"].print('.') ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (j /= 0 & (j = W - 1 or a[i+1][j+1] = '#' or i mod 2 = 1)) then (     OclFile["System.out"].print('#') ) else (     OclFile["System.out"].print('.') ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int unitDigitXRaisedY(int x,int y){
    int res=1 ;
    for(int i=0 ; i<y ; i++)res=(res*x)% 10 ;
    return res ;
  }
  public static void main(String args[])throws IOException {
    System.out.println(unitDigitXRaisedY(4,2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation unitDigitXRaisedY( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
         var i : int ; i := 0 ; while i < y do (     res := (res * x) mod 10 ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(unitDigitXRaisedY(4, 2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class FafaAndHisCompany {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int X=0 ;
    for(int l=1 ; l<=N/2 ; l++){
      if(N % l==0){
        X++;
      }
    }
    System.out.println(X);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class FafaAndHisCompany {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var X : int ; X := 0 ;
        var l : int ; l := 1 ; while l <= N / 2 do ( (     if (N mod l = 0) then (     X := X + 1 ) else skip )  ;     l := l + 1 ) ; 
    OclFile["System.out"].println(X) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cp {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x ;
    int counter=0 ;
    x=sc.nextInt();
    for(int i=1 ; i<=x/2 ; i++){
      if(x % i==0){
        counter++;
      }
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ;
    var counter : int ; counter := 0 ;
    x := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i <= x / 2 do ( (     if (x mod i = 0) then (     counter := counter + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] arr=sc.next().toCharArray();
    int cnt=0 ;
    List<Integer>idx=new ArrayList<>();
    for(int i=0 ; i<n-1 ; i=i+2){
      if(arr[i]==arr[i+1]){
        cnt++;
        idx.add(i);
      }
    }
    System.out.println(cnt);
    for(int index : idx){
      if(arr[index]=='a')arr[index]='b' ;
      else arr[index]='a' ;
    }
    System.out.println(new String(arr));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
    var cnt : int ; cnt := 0 ;
    var idx : Sequence(int) ; idx := Sequence{} ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] = arr[i + 1+1]) then (     cnt := cnt + 1 ; 
     idx := idx->including(i) ) else skip )  ;     i := i + 2 ) ; 
    OclFile["System.out"].println(cnt) ; 
    for (index : idx) do ( (     if (arr[index+1] = 'a') then     arr[index+1] := 'b' ; else     arr[index+1] := 'a' ; )  ) ; 
    OclFile["System.out"].println(StringLib.newString(arr)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static int solve(int n){
    int count=0 ;
    for(int i=1 ; i<=n/2 ; i++){
      if((n-i)% i==0)count++;
    }
    return count ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n ;
    n=sc.nextInt();
    System.out.println(solve(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i <= n / 2 do ( (     if ((n - i) mod i = 0) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
     n := sc.getCurrent()->toInteger() ; 
     OclFile["System.out"].println(solve(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Fafa_and_his_Company {
  public static void main(String[] args){
    int n,count=0 ;
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    for(int i=1 ; i<=n/2 ; i++){
      if(n % i==0)count++;
    }
    System.out.print(count);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Fafa_and_his_Company {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var count : int ; count := 0 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i <= n / 2 do ( (     if (n mod i = 0) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(count) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_Fafa_and_his_Company {
  public static void main(String[] args){
    Scanner sn=new Scanner(System.in);
    int n=sn.nextInt();
    int count=0 ;
    for(int i=1 ; i<n ; i++){
      int rem=n-i ;
      if(rem % i==0)count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Fafa_and_his_Company {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sn : OclFile ; sn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sn.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     var rem : int ; rem := n - i ;
     if (rem mod i = 0) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class Pairs_of_toys {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    FastReader sc=new FastReader();
    long n=sc.nextLong();
    long k=sc.nextLong();
    {
      System.out.print(Math.max(0,Math.min(n,k-1)-k/2));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Pairs_of_toys {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : long ; n := sc.nextLong() ;
     var k : long ; k := sc.nextLong() ;
 (     OclFile["System.out"].print(Set{0, Set{n, k - 1}->min() - k / 2}->max()) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int maxValue(int a[],int n){
    HashMap<Integer,Integer>first=new HashMap<>();
    HashMap<Integer,Integer>last=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      first.put(a[i],0);
      last.put(a[i],0);
    }
    int[] pr=new int[n];
    pr[0]=a[0];
    for(int i=1 ; i<n ; i++){
      pr[i]=pr[i-1]+a[i];
      if(Integer.parseInt(String.valueOf(first.get(a[i])))==0)first.put(a[i],i);
      last.put(a[i],i);
    }
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      int start=Integer.parseInt(String.valueOf(first.get(a[i])));
      int end=Integer.parseInt(String.valueOf(last.get(a[i])));
      if(start!=0)ans=Math.max(ans,pr[end]-pr[start-1]);
    }
    return ans ;
  }
  public static void main(String args[]){
    int[] arr={
      1,3,5,2,4,18,2,3 };
      int n=arr.length ;
      System.out.print(maxValue(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxValue( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var first : Map(int,int) ; first := Map{} ;
     var last : Map(int,int) ; last := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     first := first->union(Map{a[i+1] |-> 0}) ; 
     last := last->union(Map{a[i+1] |-> 0}) )  ;     i := i + 1 ) ; 
    var pr : Sequence(int) ; pr := Integer.subrange(1,n)->collect(0) ;
    pr[0+1] := a[0+1] ; 
        var i : int ; i := 1 ; while i < n do ( (     pr[i+1] := pr[i - 1+1] + a[i+1] ; 
     if ((((first->at(a[i+1])) + ""))->toInteger() = 0) then     first := first->union(Map{a[i+1] |-> i}) ; else skip ; 
     last := last->union(Map{a[i+1] |-> i}) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var start : int ; start := (((first->at(a[i+1])) + ""))->toInteger() ;
     var end : int ; end := (((last->at(a[i+1])) + ""))->toInteger() ;
     if (start /= 0) then     ans := Set{ans, pr[end+1] - pr[start - 1+1]}->max() ; else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,5,2,4,18,2,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(maxValue(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long s1=scanner.nextLong();
    long s2=scanner.nextLong();
    if(s2==1 || s2==2){
      System.out.println(0);
      System.exit(0);
    }
    if(s1*2>=s2+1){
      if(s2>s1+1){
        double t1=s2-s1 ;
        double t2=s1 ;
        double mx=Math.ceil((t2-t1)/2);
        System.out.printf("%.0f",mx);
      }
      else {
        double t1=1 ;
        double t2=s2-1 ;
        double mx=Math.ceil((t2-t1)/2);
        System.out.printf("%.0f",mx);
      }
    }
    else System.out.println(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : long ; s1 := scanner.getCurrent()->toLong() ;
    var s2 : long ; s2 := scanner.getCurrent()->toLong() ;
    if (s2 = 1 or s2 = 2) then (     OclFile["System.out"].println(0) ; 
 OclProcess.exit(0) ) else skip ; 
    if (s1 * 2 >= s2 + 1) then (     if (s2 > s1 + 1) then (     var t1 : double ; t1 := s2 - s1 ;
     var t2 : double ; t2 := s1 ;
     var mx : double ; mx := ((t2 - t1) / 2)->ceil() ;
     OclFile["System.out"].printf("%.0f", mx) ) else (     var t1 : double ; t1 := 1 ;
     var t2 : double ; t2 := s2 - 1 ;
     var mx : double ; mx := ((t2 - t1) / 2)->ceil() ;
     OclFile["System.out"].printf("%.0f", mx) ) ) else     OclFile["System.out"].println(0) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long k=sc.nextLong();
    long half=k/2 ;
    if(n<half){
      System.out.println("0");
    }
    else System.out.println((Math.min(n,k-1))-half);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var half : long ; half := k / 2 ;
    if (n < half) then (     OclFile["System.out"].println("0") ) else     OclFile["System.out"].println((Set{n, k - 1}->min()) - half) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void checkCollision(int a,int b,int c,int x,int y,int radius){
    double dist=(Math.abs(a*x+b*y+c))/Math.sqrt(a*a+b*b);
    if(radius==dist)System.out.println("Touch");
    else if(radius>dist)System.out.println("Intersect");
    else System.out.println("Outside");
  }
  public static void main(String[] args){
    int radius=5 ;
    int x=0,y=0 ;
    int a=3,b=4,c=25 ;
    checkCollision(a,b,c,x,y,radius);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkCollision( a : int, b : int, c : int, x : int, y : int, radius : int) : void
  pre: true
  post: true
  activity: (     var dist : double ; dist := (if a * x + b * y + c < 0 then -(a * x + b * y + c) else a * x + b * y + c endif) / (a * a + b * b)->sqrt() ;
     if (radius = dist) then     OclFile["System.out"].println("Touch") ; else     if (radius > dist) then     OclFile["System.out"].println("Intersect") else     OclFile["System.out"].println("Outside") ; ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var radius : int ; radius := 5 ;
     var x : int ; x := 0 ;
    var y : int ; y := 0 ;
     var a : int ; a := 3 ;
    var b : int ; b := 4 ;
    var c : int ; c := 25 ;
     execute checkCollision(a, b, c, x, y, radius) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Long n=sc.nextLong();
    Long k=sc.nextLong();
    if(n==1){
      System.out.println(0);
      return ;
    }
    Long max=(k*(k-1))/2 ;
    if(n>1+max){
      System.out.println(-1);
      return ;
    }
    else if(n==1+max){
      System.out.println(k-1);
      return ;
    }
    Long l=2L ;
    Long h=k ;
    Long ans=k+1 ;
    boolean exact=false ;
    while(l<=h){
      Long mid=l+(h-l)/2 ;
      Long all=((k-mid+1)*(mid+k))/2 ;
      all-=(k-mid+1);
      Long rem=n-(all+1);
      if(rem<0){
        l=mid+1 ;
      }
      else if(rem<mid-1){
        ans=mid ;
        if(rem==0){
          exact=true ;
          break ;
        }
        l=mid+1 ;
      }
      else {
        h=mid-1 ;
      }
    }
    int add=exact ? 0 : 1 ;
    System.out.println((k-ans+1)+add);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    if (n = 1) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var max : long ; max := (k * (k - 1)) / 2 ;
    if (n > 1 + max) then (     OclFile["System.out"].println(-1) ; 
     return ) else     if (n = 1 + max) then (     OclFile["System.out"].println(k - 1) ; 
     return ) else skip ; ;  
    var l : long ; l := 2L ;
    var h : long ; h := k ;
    var ans : long ; ans := k + 1 ;
    var exact : boolean ; exact := false ;
    while (l <= h) do (     var mid : long ; mid := l + (h - l) / 2 ;
     var all : long ; all := ((k - mid + 1) * (mid + k)) / 2 ;
    all := all-((k - mid + 1)) ; 
    var rem : long ; rem := n - (all + 1) ;
    if (rem < 0) then (     l := mid + 1 ) else     if (rem < mid - 1) then (     ans := mid ; 
     if (rem = 0) then (     exact := true ; 
     break ) else skip ; 
     l := mid + 1 ) else (     h := mid - 1 ) ;  ;  
 ) ; 
    var add : int ; add := if exact then 0 else 1 endif ;
    OclFile["System.out"].println((k - ans + 1) + add) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    String nextLine()throws IOException {
      return br.readLine();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  static FastScanner in=new FastScanner();
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException {
    long n=in.nextLong(),k=in.nextLong();
    out.println(bs(n,k));
    out.close();
  }
  public static long bs(long n,long k){
    long sum=((k*(k+1))/2)-(k-1);
    if(n==1)return 0 ;
    if(sum<n)return-1 ;
    long l=1,r=k-1,mid,temp ;
    while(l<=r){
      mid=(l+r)/2 ;
      long temp2=k-mid ;
      long temp3=(((temp2*(temp2+1))/2)-(temp2));
      temp=sum-temp3 ;
      if(temp>n)r=mid-1 ;
      else if(temp==n)return mid ;
      else l=mid+1 ;
    }
    return l ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   attribute in : FastScanner := FastScanner.newFastScanner();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := in.nextLong() ;
    var k : long ; k := in.nextLong() ;
     skip ; 
     skip );
  static   operation bs( n : long, k : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := ((k * (k + 1)) / 2) - (k - 1) ;
     if (n = 1) then     return 0 else skip ; 
    if (sum < n) then     return -1 else skip ; 
    var l : long ; l := 1 ;
    var r : long ; r := k - 1 ;
    var mid : long ;
    var temp : long ;
    while (l <= r) do (     mid := (l + r) / 2 ; 
     var temp2 : long ; temp2 := k - mid ;
    var temp3 : long ; temp3 := (((temp2 * (temp2 + 1)) / 2) - (temp2)) ;
    temp := sum - temp3 ; 
    if (temp > n) then     r := mid - 1 else     if (temp = n) then     return mid else     l := mid + 1 ; ;  ;  
 ) ; 
    return l 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class general {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] arr=sc.next().toCharArray();
    int cnt=0 ;
    List<Integer>idx=new ArrayList<>();
    for(int i=0 ; i<n-1 ; i=i+2){
      if(arr[i]==arr[i+1]){
        cnt++;
        idx.add(i);
      }
    }
    System.out.println(cnt);
    for(int index : idx){
      if(arr[index]=='a')arr[index]='b' ;
      else arr[index]='a' ;
    }
    System.out.println(new String(arr));
  }
}
------------------------------------------------------------
OCL File:
---------
 class general {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
    var cnt : int ; cnt := 0 ;
    var idx : Sequence(int) ; idx := Sequence{} ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] = arr[i + 1+1]) then (     cnt := cnt + 1 ; 
     idx := idx->including(i) ) else skip )  ;     i := i + 2 ) ; 
    OclFile["System.out"].println(cnt) ; 
    for (index : idx) do ( (     if (arr[index+1] = 'a') then     arr[index+1] := 'b' ; else     arr[index+1] := 'a' ; )  ) ; 
    OclFile["System.out"].println(StringLib.newString(arr)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean DivisibleBy41(int first,int second,int c,int n){
    int digit[]=new int[n];
    digit[0]=first ;
    digit[1]=second ;
    for(int i=2 ; i<n ; i++)digit[i]=(digit[i-1]*c+digit[i-2])% 10 ;
    int ans=digit[0];
    for(int i=1 ; i<n ; i++)ans=(ans*10+digit[i])% 41 ;
    if(ans % 41==0)return true ;
    else return false ;
  }
  public static void main(String[] args){
    int first=1,second=2,c=1,n=3 ;
    if(DivisibleBy41(first,second,c,n))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation DivisibleBy41( first : int, second : int, c : int, n : int) : boolean
  pre: true
  post: true
  activity: (     var digit : Sequence(int) ; digit := Integer.subrange(1,n)->collect(0) ;
     digit[0+1] := first ; 
    digit[1+1] := second ; 
        var i : int ; i := 2 ; while i < n do (     digit[i+1] := (digit[i - 1+1] * c + digit[i - 2+1]) mod 10 ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := digit[0+1] ;
        var i : int ; i := 1 ; while i < n do (     ans := (ans * 10 + digit[i+1]) mod 41 ;  ;     i := i + 1 ) ; 
    if (ans mod 41 = 0) then     return true else     return false ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var first : int ; first := 1 ;
    var second : int ; second := 2 ;
    var c : int ; c := 1 ;
    var n : int ; n := 3 ;
     if (DivisibleBy41(first, second, c, n)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.run();
  }
  int f[]={
-1,2,5,5,4,5,6,3,7,6 };
    public void run(){
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int m=sc.nextInt();
      int a[]=new int[m];
      for(int i=0 ; i<m ; i++){
        a[i]=sc.nextInt();
      }
      Arrays.sort(a);
      int dp[]=new int[n+1];
      Arrays.fill(dp,-1);
      dp[0]=0 ;
      for(int i=1 ; i<=n ; i++){
        for(int j=0 ; j<m ; j++){
          if(i-f[a[j] ]>=0 && dp[i-f[a[j] ] ]>=0){
            dp[i]=Math.max(dp[i],dp[i-f[a[j] ] ]+1);
          }
        }
      }
      int keta=dp[n];
      int rem=n ;
      StringBuilder sb=new StringBuilder();
      while(rem>0){
        for(int i=m-1 ; i>=0 ; i--){
          if(rem-f[a[i] ]>=0 && keta==dp[rem-f[a[i] ] ]+1){
            sb.append(a[i]);
            keta--;
            rem-=f[a[i] ];
            break ;
          }
        }
      }
      System.out.println(sb);
      sc.close();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.run() );
   attribute f : int := Sequence{-1,2,5,5,4,5,6,3,7,6};
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
    dp := dp->collect(-1) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (i - f[a[j+1]+1] >= 0 & dp[i - f[a[j+1]+1]+1] >= 0) then (     dp[i+1] := Set{dp[i+1], dp[i - f[a[j+1]+1]+1] + 1}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var keta : int ; keta := dp[n+1] ;
    var rem : int ; rem := n ;
    var sb : String ; sb := StringLib.newString() ;
    while (rem > 0) do (         var i : int ; i := m - 1 ; while i >= 0 do ( (     if (rem - f[a[i+1]+1] >= 0 & keta = dp[rem - f[a[i+1]+1]+1] + 1) then (     sb := sb + StringLib.newString(a[i+1]) ; 
     keta := keta - 1 ; 
     rem := rem-(f[a[i+1]+1]) ; 
     break ) else skip )  ;     i := i - 1 ) ) ; 
    OclFile["System.out"].println(sb) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  static long t[];
  static long l[];
  static long h[];
  public static void main(String[] args)throws IOException {
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in),1);
    String s ;
    String sl[];
    int d[]=new int[10];
    int c[]={
      999999,2,5,5,4,5,6,3,7,6 };
      for(int i=0 ; i<=9 ; i++){
        d[i]=999999 ;
      }
      s=r.readLine();
      sl=s.split(" ");
      int n=Integer.parseInt(sl[0]);
      int m=Integer.parseInt(sl[1]);
      s=r.readLine();
      sl=s.split(" ");
      for(int i=0 ; i<m ; i++){
        int v=Integer.parseInt(sl[i]);
        d[v]=c[v];
      }
      int dp[]=new int[n+1];
      for(int i=1 ; i<=n ; i++){
        dp[i]=-999999 ;
        for(int j=1 ; j<=9 ; j++){
          if(i-d[j]>=0 && dp[i-d[j] ]>=0){
            dp[i]=Math.max(dp[i],dp[i-d[j] ]+1);
          }
        }
      }
      int z=dp[n];
      int q=n ;
      while(q>0){
        for(int i=9 ; 1<=i ; i--){
          if(q-d[i]>=0 && dp[q-d[i] ]==dp[q]-1){
            System.out.print(i);
            q-=d[i];
            break ;
          }
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute t : Sequence(long);
  static   attribute l : Sequence(long);
  static   attribute h : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 1) ;
     var s : String ;
    var sl : Sequence(String) ;
    var d : Sequence(int) ; d := Integer.subrange(1,10)->collect(0) ;
    var c : Sequence(int) ; c := Sequence{999999,2,5,5,4,5,6,3,7,6} ;
        var i : int ; i := 0 ; while i <= 9 do ( (     d[i+1] := 999999 )  ;     i := i + 1 ) ; 
    s := r.readLine() ; 
    sl := s->split(" ") ; 
    var n : int ; n := (sl[0+1])->toInteger() ;
    var m : int ; m := (sl[1+1])->toInteger() ;
    s := r.readLine() ; 
    sl := s->split(" ") ; 
        var i : int ; i := 0 ; while i < m do ( (     var v : int ; v := (sl[i+1])->toInteger() ;
     d[v+1] := c[v+1] )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     dp[i+1] := -999999 ; 
         var j : int ; j := 1 ; while j <= 9 do ( (     if (i - d[j+1] >= 0 & dp[i - d[j+1]+1] >= 0) then (     dp[i+1] := Set{dp[i+1], dp[i - d[j+1]+1] + 1}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var z : int ; z := dp[n+1] ;
    var q : int ; q := n ;
    while (q > 0) do (         var i : int ; i := 9 ; while 1 <= i do ( (     if (q - d[i+1] >= 0 & dp[q - d[i+1]+1] = dp[q+1] - 1) then (     OclFile["System.out"].print(i) ; 
     q := q-(d[i+1]) ; 
     break ) else skip )  ;     i := i - 1 ) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    List<BigInteger>dp=new ArrayList<BigInteger>();
    Map<Integer,Integer>mp=new HashMap<Integer,Integer>();
    int n=sc.nextInt();
    int m=sc.nextInt();
    for(int i=1 ; i<=m ; i++){
      int a=sc.nextInt();
      switch(a){
        case 1 : mp.put(a,2);
        break ;
        case 2 : case 3 : case 5 : mp.put(a,5);
        break ;
        case 4 : mp.put(a,4);
        break ;
        case 6 : case 9 : mp.put(a,6);
        break ;
        case 7 : mp.put(a,3);
        break ;
        case 8 : mp.put(a,7);
        break ;
      }
    }
    for(int i=0 ; i<=n+10 ; i++){
      dp.add(BigInteger.valueOf(0L));
    }
    BigInteger ten=BigInteger.valueOf(10);
    for(int i=0 ; i<n ; i++){
      if(i!=0 && dp.get(i).equals(BigInteger.valueOf(0L)))continue ;
      for(Map.Entry<Integer,Integer>entry : mp.entrySet()){
        int pos=i+entry.getValue();
        BigInteger tmp=dp.get(pos);
        BigInteger now=dp.get(i).multiply(ten).add(BigInteger.valueOf(entry.getKey()));
        if(now.compareTo(tmp)>0){
          dp.set(pos,now);
        }
      }
    }
    System.out.println(dp.get(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dp : Sequence(long) ; dp := Sequence{} ;
    var mp : Map(int,int) ; mp := Map{} ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= m do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (a) ; 
       if _switchval = 1 then
     mp := mp->union(Map{a |-> 2}) ; 
    break 
   else skip ;
    if _switchval = 2 or _switchval = 3 or _switchval = 5 then
    mp := mp->union(Map{a |-> 5}) ; 
    break 
   else skip ;
       if _switchval = 4 then
     mp := mp->union(Map{a |-> 4}) ; 
    break 
   else skip ;
    if _switchval = 6 or _switchval = 9 then
    mp := mp->union(Map{a |-> 6}) ; 
    break 
   else skip ;
       if _switchval = 7 then
     mp := mp->union(Map{a |-> 3}) ; 
    break 
   else skip ;
       if _switchval = 8 then
     mp := mp->union(Map{a |-> 7}) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= n + 10 do ( (     dp := dp->including((0L + "")->toLong()) )  ;     i := i + 1 ) ; 
    var ten : long ; ten := (10 + "")->toLong() ;
        var i : int ; i := 0 ; while i < n do ( (     if (i /= 0 & dp->at(i+1) = (0L + "")->toLong()) then     continue else skip ; 
     for (entry : mp->asSet()) do ( (     var pos : int ; pos := i + entry.getValue() ;
     var tmp : long ; tmp := dp->at(pos+1) ;
     var now : long ; now := dp->at(i+1).multiply(ten)->excludes((entry.getKey() + "")->toLong()) ;
     if (now->compareTo(tmp) > 0) then (     dp := dp.setAt(pos+1,now) ) else skip )  ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp->at(n+1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int INF=100000000 ;
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] dp=new int[n+1];
    int[] a=new int[m];
    for(int i=0 ; i<m ; i++){
      a[i]=sc.nextInt();
    }
    int[] cost={
      0,2,5,5,4,5,6,3,7,6 };
      Arrays.sort(a);
      Arrays.fill(dp,-INF);
      dp[0]=0 ;
      for(int i=1 ; i<=n ; i++){
        for(int j=m-1 ; j>=0 ; j--){
          if(i-cost[a[j] ]<0)continue ;
          else dp[i]=Math.max(dp[i],dp[i-cost[a[j] ] ]+1);
        }
      }
      StringBuilder ans=new StringBuilder();
      while(n!=0){
        for(int j=m-1 ; j>=0 ; j--){
          if(cost[a[j] ]>n)continue ;
          if(dp[n-cost[a[j] ] ]==dp[n]-1){
            ans.append(a[j]);
            n-=cost[a[j] ];
            break ;
          }
        }
      }
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var INF : int ; INF := 100000000 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cost : Sequence(int) ; cost := Sequence{0,2,5,5,4,5,6,3,7,6} ;
    a := a->sort() ; 
    dp := dp->collect(-INF) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := m - 1 ; while j >= 0 do ( (     if (i - cost[a[j+1]+1] < 0) then     continue else     dp[i+1] := Set{dp[i+1], dp[i - cost[a[j+1]+1]+1] + 1}->max() ; )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := StringLib.newString() ;
    while (n /= 0) do (         var j : int ; j := m - 1 ; while j >= 0 do ( (     if (cost[a[j+1]+1] > n) then     continue else skip ; 
     if (dp[n - cost[a[j+1]+1]+1] = dp[n+1] - 1) then (     ans := ans + StringLib.newString(a[j+1]) ; 
     n := n-(cost[a[j+1]+1]) ; 
     break ) else skip )  ;     j := j - 1 ) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
public class GFG {
  static int getPairs(int a[],int n){
    HashSet<Integer>visited1=new HashSet<Integer>();
    int un[]=new int[n];
    un[n-1]=0 ;
    int count=0 ;
    for(int i=n-1 ; i>0 ; i--){
      if(visited1.contains(a[i]))un[i-1]=count ;
      else un[i-1]=++count ;
      visited1.add(a[i]);
    }
    HashSet<Integer>visited2=new HashSet<Integer>();
    int answer=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if(visited2.contains(a[i]))continue ;
      answer+=un[i];
      visited2.add(a[i]);
    }
    return answer ;
  }
  public static void main(String[] args){
    int a[]={
      1,2,2,4,2,5,3,5 };
      int n=a.length ;
      System.out.println(getPairs(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getPairs( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var visited1 : Set(int) ; visited1 := Set{} ;
     var un : Sequence(int) ; un := Integer.subrange(1,n)->collect(0) ;
    un[n - 1+1] := 0 ; 
    var count : int ; count := 0 ;
        var i : int ; i := n - 1 ; while i > 0 do ( (     if (visited1->includes(a[i+1])) then     un[i - 1+1] := count else         count := count + 1 ;
 un[i - 1+1] := count  ; ;  
     visited1 := visited1->including(a[i+1]) )  ;     i := i - 1 ) ; 
    var visited2 : Set(int) ; visited2 := Set{} ;
    var answer : int ; answer := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (visited2->includes(a[i+1])) then     continue else skip ; 
     answer := answer+(un[i+1]) ; 
     visited2 := visited2->including(a[i+1]) )  ;     i := i + 1 ) ; 
    return answer 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,2,4,2,5,3,5} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(getPairs(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Integer[] cost_array={
      2,5,5,4,5,6,3,7,6 };
      List<Integer>cost=Arrays.asList(cost_array);
      Scanner sc=new Scanner(System.in);
      int n=Integer.parseInt(sc.next());
      int m=Integer.parseInt(sc.next());
      List<Integer>aArray=new ArrayList<>();
      for(int i=0 ; i<m ; i++){
        aArray.add(Integer.parseInt(sc.next()));
      }
      String[] dp=new String[n+1];
      dp[0]="" ;
      for(int i=0 ; i<=n ; i++){
        for(int a : aArray){
          if(cost.get(a-1)<=i && dp[i-cost.get(a-1)]!=null){
            dp[i]=func2(dp[i-cost.get(a-1)]+a,dp[i]);
          }
        }
      }
      System.out.println(dp[n]);
    }
    public static String func2(String x,String y){
      if(y==null){
        return x ;
      }
      else if(x.length()>y.length()){
        return x ;
      }
      else if(x.length()<y.length()){
        return y ;
      }
      else {
        for(int i=0 ; i<x.length(); i++){
          if(x.charAt(i)>y.charAt(i)){
            return x ;
          }
          else if(x.charAt(i)<y.charAt(i)){
            return y ;
          }
        }
        return x ;
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cost_array : Sequence(int) ; cost_array := Sequence{2,5,5,4,5,6,3,7,6} ;
     var cost : Sequence(int) ; cost := cost_array ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := (sc.getCurrent())->toInteger() ;
    var m : int ; m := (sc.getCurrent())->toInteger() ;
    var aArray : Sequence(int) ; aArray := Sequence{} ;
        var i : int ; i := 0 ; while i < m do ( (     aArray := aArray->including((sc.getCurrent())->toInteger()) )  ;     i := i + 1 ) ; 
    var dp : Sequence(String) ; dp := Integer.subrange(1,n + 1)->collect(null) ;
    dp[0+1] := "" ; 
        var i : int ; i := 0 ; while i <= n do ( (     for (a : aArray) do ( (     if (cost->at(a - 1+1) <= i & dp[i - cost->at(a - 1+1)+1] /= null) then (     dp[i+1] := func2(dp[i - cost->at(a - 1+1)+1] + a, dp[i+1]) ) else skip )  ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[n+1]) ; 
 );
  static   operation func2( x : String, y : String) : String
  pre: true
  post: true
  activity: (     if (y = null) then (     return x ) else     if (x->size() > y->size()) then (     return x ) else     if (x->size() < y->size()) then (     return y ) else (         var i : int ; i := 0 ; while i < x->size() do ( (     if (x->at(i+1) > y->at(i+1)) then (     return x ) else     if (x->at(i+1) < y->at(i+1)) then (     return y ) else skip ; )  ;     i := i + 1 ) ; 
     return x ) ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int Case=1 ;
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      double a[][]=new double[n][2];
      for(int i=0 ; i<n ; i++){
        a[i][0]=sc.nextDouble();
        a[i][1]=sc.nextDouble();
      }
      double area=0 ;
      for(int i=0 ; i<n-1 ; i++)area+=(a[i][0]*a[i+1][1]-a[i][1]*a[i+1][0])/2 ;
      area+=(a[n-1][0]*a[0][1]-a[n-1][1]*a[0][0])/2 ;
      System.out.printf("%d %.1f\n",Case++,-area);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var Case : int ; Case := 1 ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var a : Sequence(Sequence(double)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1][0+1] := sc.getCurrent()->toReal() ; 
     a[i+1][1+1] := sc.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
    var area : double ; area := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do (     area := area+((a[i+1][0+1] * a[i + 1+1][1+1] - a[i+1][1+1] * a[i + 1+1][0+1]) / 2) ;  ;     i := i + 1 ) ; 
    area := area+((a[n - 1+1][0+1] * a[0+1][1+1] - a[n - 1+1][1+1] * a[0+1][0+1]) / 2) ; 
    OclFile["System.out"].printf("%d %.1f\n", Case, -area) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n ;
    double[] x,y ;
    int i,j ;
    double sum,ax,ay,bx,by ;
    for(j=1 ; ; ){
      n=sc.nextInt();
      if(n==0)break ;
      x=new double[n];
      y=new double[n];
      for(i=0 ; i<n ; i++){
        x[i]=sc.nextDouble();
        y[i]=sc.nextDouble();
      }
      sum=0.0 ;
      for(i=0 ; i<n-2 ; i++){
        ax=x[i+1]-x[0];
        ay=y[i+1]-y[0];
        bx=x[i+2]-x[0];
        by=y[i+2]-y[0];
        sum+=(ax*by-ay*bx)/2.0 ;
      }
      System.out.printf("%d %.1f%n",j++,-sum);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var x : Sequence(double) ;
    var y : Sequence(double) ;
    var i : int ;
    var j : int ;
    var sum : double ;
    var ax : double ;
    var ay : double ;
    var bx : double ;
    var by : double ;
        j := 1 ; while true do ( (     n := sc.nextInt() ; 
     if (n = 0) then     break else skip ; 
    x := Integer.subrange(1,n)->collect(0.0) ; 
    y := Integer.subrange(1,n)->collect(0.0) ; 
        i := 0 ; while i < n do ( (     x[i+1] := sc.nextDouble() ; 
     y[i+1] := sc.nextDouble() )  ;     i := i + 1 ) ; 
    sum := 0.0 ; 
        i := 0 ; while i < n - 2 do ( (     ax := x[i + 1+1] - x[0+1] ; 
     ay := y[i + 1+1] - y[0+1] ; 
    bx := x[i + 2+1] - x[0+1] ; 
    by := y[i + 2+1] - y[0+1] ; 
    sum := sum+((ax * by - ay * bx) / 2.0) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%d %.1f%n", j, -sum) ; 
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    int j=1 ;
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in),1);
    while(true){
      ArrayList<Integer>x=new ArrayList<>();
      ArrayList<Integer>y=new ArrayList<>();
      int n=Integer.parseInt(br.readLine());
      if(n==0){
        break ;
      }
      for(int i=0 ; i<n ; i++){
        String st=br.readLine();
        String[] num=st.split(" ",0);
        x.add(Integer.parseInt(num[0]));
        y.add(Integer.parseInt(num[1]));
      }
      int s=0 ;
      for(int i=0 ; i<n ; i++){
        if(i!=n-1){
          s+=(x.get(i)*y.get(i+1)-x.get(i+1)*y.get(i));
        }
        else {
          s+=(x.get(i)*y.get(0)-x.get(0)*y.get(i));
        }
      }
      double S=Math.abs(s)/2.0 ;
      System.out.print(j+" ");
      System.out.printf("%.1f",S);
      System.out.println("");
      String musi=br.readLine();
      j++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var j : int ; j := 1 ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 1) ;
     while (true) do (     var x : Sequence(int) ; x := Sequence{} ;
     var y : Sequence(int) ; y := Sequence{} ;
    var n : int ; n := (br.readLine())->toInteger() ;
    if (n = 0) then (     break ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     var st : String ; st := br.readLine() ;
     var num : Sequence(String) ; num := st->split(" ") ;
     x := x->including((num[0+1])->toInteger()) ; 
     y := y->including((num[1+1])->toInteger()) )  ;     i := i + 1 ) ; 
    var s : int ; s := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i /= n - 1) then (     s := s+((x->at(i+1) * y->at(i + 1+1) - x->at(i + 1+1) * y->at(i+1))) ) else (     s := s+((x->at(i+1) * y->at(0+1) - x->at(0+1) * y->at(i+1))) ) )  ;     i := i + 1 ) ; 
    var S : double ; S := if s < 0 then -(s) else s endif / 2.0 ;
    OclFile["System.out"].print(j + " ") ; 
    OclFile["System.out"].printf("%.1f", S) ; 
    OclFile["System.out"].println("") ; 
    var musi : String ; musi := br.readLine() ;
    j := j + 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class ProblemA {
  static HashSet<Character>set[];
  static boolean ok=false ;
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    String s=br.readLine();
    int count=0 ;
    for(int i=0 ; i<=n-2 ; i+=2){
      if(s.charAt(i)!=s.charAt(i+1))sb.append(s.charAt(i)+""+s.charAt(i+1));
      else {
        count++;
        sb.append("ab");
      }
    }
    System.out.println(count);
    System.out.println(sb);
  }
  public static boolean same(char c,char d){
    return set[0] .contains(c)&& set[0] .contains(d)||(set[1] .contains(c)&& set[1] .contains(d));
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
  static   attribute set : Sequence(Set(String));
  static   attribute ok : boolean := false;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var s : String ; s := br.readLine() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i <= (n)->char2byte() - 2 do ( (     if (s->at(i+1) /= s->at(i + 1+1)) then     sb := sb + StringLib.newString(s->at(i+1) + "" + s->at(i + 1+1)) ; else (     count := count + 1 ; 
     sb := sb + StringLib.newString("ab") ) )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(count) ; 
    OclFile["System.out"].println(sb) ; 
 );
  static   operation same( c : String, d : String) : boolean
  pre: true
  post: true
  activity: (     return set[0+1]->includes(c) & set[0+1]->includes(d) or (set[1+1]->includes(c) & set[1+1]->includes(d)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testnum=0 ;
    while(true){
      testnum++;
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      Vector2[] r=new Vector2[n];
      for(int i=0 ; i<n ; i++){
        r[i]=new Vector2(sc.nextInt(),sc.nextInt());
      }
      double sum=0 ;
      for(int i=0 ; i<n ; i++){
        Vector2 r1=r[i];
        Vector2 r2=r[(i+1)% n];
        sum+=r1.cross(r2)/2 ;
      }
      System.out.println(testnum+" "+Math.abs(sum));
    }
  }
}
class Vector2 {
  public double x ;
  public double y ;
  public Vector2(double x,double y){
    this.x=x ;
    this.y=y ;
  }
  public double dot(Vector2 v){
    return this.x*v.x+this.y*v.y ;
  }
  public double cross(Vector2 v){
    return this.x*v.y-this.y*v.x ;
  }
  public double norm(){
    return Math.sqrt(this.x*this.x+this.y*this.y);
  }
  public Vector2 normalize(){
    return divide(norm());
  }
  public Vector2 add(Vector2 v){
    return new Vector2(x+v.x,y+v.y);
  }
  public Vector2 subtract(Vector2 v){
    return new Vector2(x-v.x,y-v.y);
  }
  public Vector2 multiply(double k){
    return new Vector2(x*k,y*k);
  }
  public Vector2 divide(double k){
    return new Vector2(x/k,y/k);
  }
  public String toString(){
    return "("+this.x+","+this.y+")" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testnum : int ; testnum := 0 ;
     while (true) do (     testnum := testnum + 1 ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    if (n = 0) then (     break ) else skip ; 
    var r : Sequence(Vector2) ; r := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     r[i+1] := Vector2.newVector2(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var sum : double ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var r1 : Vector2 ; r1 := r[i+1] ;
     var r2 : Vector2 ; r2 := r[(i + 1) mod n+1] ;
     sum := sum+(r1.cross(r2) / 2) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(testnum + " " + if sum < 0 then -(sum) else sum endif) ; 
 ) );
}
class Vector2 {
   attribute x : double;
   attribute y : double;
   static operation newVector2( x : double, y : double) : Vector2
  pre: true
  post: true
  activity:
  ( var self : Vector2 ;
    self := createVector2();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation dot( v : Vector2) : double
  pre: true
  post: true
  activity: (     return self.x * v.x + self.y * v.y );
   operation cross( v : Vector2) : double
  pre: true
  post: true
  activity: (     return self.x * v.y - self.y * v.x );
   operation norm() : double
  pre: true
  post: true
  activity: (     return (self.x * self.x + self.y * self.y)->sqrt() );
   operation normalize() : Vector2
  pre: true
  post: true
  activity: (     return divide(norm()) );
   operation add( v : Vector2) : Vector2
  pre: true
  post: true
  activity: (     return Vector2.newVector2(x + v.x, y + v.y) );
   operation subtract( v : Vector2) : Vector2
  pre: true
  post: true
  activity: (     return Vector2.newVector2(x - v.x, y - v.y) );
   operation multiply( k : double) : Vector2
  pre: true
  post: true
  activity: (     return Vector2.newVector2(x * k, y * k) );
   operation divide( k : double) : Vector2
  pre: true
  post: true
  activity: (     return Vector2.newVector2(x / k, y / k) );
   operation toString() : String
  pre: true
  post: true
  activity: (     return "(" + self.x + "," + self.y + ")" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.*;
import java.util.Scanner ;
public class Main {
  private static double solve(int n,Point[] points){
    double sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(i==n-1){
        sum+=points[i] .getX()*points[0] .getY()-points[0] .getX()*points[i] .getY();
      }
      else {
        sum+=points[i] .getX()*points[i+1] .getY()-points[i+1] .getX()*points[i] .getY();
      }
    }
    return Math.abs(sum)/2 ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=1 ;
    while(true){
      int n=Integer.parseInt(sc.nextLine());
      if(n==0)break ;
      Point[] points=new Point[n];
      for(int i=0 ; i<n ; i++){
        points[i]=new Point();
        String[] xy=sc.nextLine().split(" ");
        points[i] .setLocation(Integer.parseInt(xy[0]),Integer.parseInt(xy[1]));
      }
      double sum=solve(n,points);
      System.out.println((t++)+" "+String.format("%.1f",sum));
      sc.nextLine();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( n : int, points : Sequence(Point)) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (i = n - 1) then (     sum := sum+(points[i+1].getX() * points[0+1].getY() - points[0+1].getX() * points[i+1].getY()) ) else (     sum := sum+(points[i+1].getX() * points[i + 1+1].getY() - points[i + 1+1].getX() * points[i+1].getY()) ) )  ;     i := i + 1 ) ; 
     return if sum < 0 then -(sum) else sum endif / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
     while (true) do (     var n : int ; n := (sc.nextLine())->toInteger() ;
     if (n = 0) then     break else skip ; 
    var points : Sequence(Point) ; points := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     points[i+1] := Point.newPoint() ; 
     var xy : Sequence(String) ; xy := sc.nextLine()->split(" ") ;
     points[i+1].setLocation((xy[0+1])->toInteger(), (xy[1+1])->toInteger()) )  ;     i := i + 1 ) ; 
    var sum : double ; sum := solve(n, points) ;
    OclFile["System.out"].println((t) + " " + StringLib.format("%.1f",Sequence{sum})) ; 
    skip ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x=sc.nextInt();
    int[] l=new int[n];
    int[] d=new int[n+1];
    d[0]=0 ;
    for(int i=0 ; i<n ; i++){
      l[i]=sc.nextInt();
    }
    int count=1 ;
    for(int i=1 ; i<n+1 ; i++){
      d[i]=d[i-1]+l[i-1];
      if(d[i]<=x)count++;
    }
    System.out.println(count);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Integer.subrange(1,n)->collect(0) ;
    var d : Sequence(int) ; d := Integer.subrange(1,n + 1)->collect(0) ;
    d[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     l[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 1 ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     d[i+1] := d[i - 1+1] + l[i - 1+1] ; 
     if (d[i+1] <= x) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Set ;
import java.util.StringTokenizer ;
public class Main {
  private static final int MOD=(int)Math.pow(10,9);
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    int x=sc.nextInt();
    int res=0 ;
    int[] d=new int[n+1];
    for(int i=0 ; i<n ; i++){
      int ls=sc.nextInt();
      d[i+1]=ls+d[i];
      if(d[i+1]<=x){
        res++;
      }
    }
    System.out.println(res+1);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 10->pow(9)->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : int ; n := sc.nextInt() ;
    var x : int ; x := sc.nextInt() ;
    var res : int ; res := 0 ;
    var d : Sequence(int) ; d := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var ls : int ; ls := sc.nextInt() ;
     d[i + 1+1] := ls + d[i+1] ; 
     if (d[i + 1+1] <= x) then (     res := res + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res + 1) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BBounding solver=new BBounding();
    solver.solve(1,in,out);
    out.close();
  }
  static class BBounding {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int x=in.nextInt();
      int d=0 ;
      int count=1 ;
      for(int i=0 ; i<n ; i++){
        int temp=in.nextInt();
        d+=temp ;
        if(d<=x)count++;
        else break ;
      }
      out.println(count);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BBounding ; solver := BBounding.newBBounding() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BBounding {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var x : int ; x := in.nextInt() ;
    var d : int ; d := 0 ;
    var count : int ; count := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : int ; temp := in.nextInt() ;
     d := d+(temp) ; 
     if (d <= x) then     count := count + 1 ; else     break )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    MyReader r=new MyReader();
    int N,X ;
    {
      int[] a=r.ii();
      N=a[0];
      X=a[1];
    }
    int[] L=r.ii();
    int y=0 ;
    for(int i=0 ; i<N ; i++){
      y+=L[i];
      if(X<y){
        println(i+1);
        return ;
      }
    }
    println(N+1);
  }
  static void print(Object o){
    System.out.print(o.toString());
  }
  static void println(Object o){
    System.out.println(o.toString());
  }
  static int Int(String s){
    return Integer.parseInt(s);
  }
  static long Long(String s){
    return Long.parseLong(s);
  }
  static class MyReader extends BufferedReader {
    MyReader(){
      super(new InputStreamReader(System.in));
    }
    String s()throws IOException {
      return readLine();
    }
    String[] ss()throws IOException {
      return s().split(" ");
    }
    int i()throws IOException {
      return Int(s());
    }
    int[] ii()throws IOException {
      String[] ss=ss();
      int size=ss.length ;
      int[] ii=new int[size];
      for(int j=0 ; j<size ; j++)ii[j]=Int(ss[j]);
      return ii ;
    }
    long l()throws IOException {
      return Long(s());
    }
    long[] ll()throws IOException {
      String[] ss=ss();
      int size=ss.length ;
      long[] ll=new long[size];
      for(int j=0 ; j<size ; j++)ll[j]=Long(ss[j]);
      return ll ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : MyReader ; r := MyReader.newMyReader() ;
     var N : int ;
    var X : int ;
(     var a : Sequence(int) ; a := r.ii() ;
     N := a[0+1] ; 
     X := a[1+1] ) 
    var L : Sequence(int) ; L := r.ii() ;
    var y : int ; y := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     y := y+(L[i+1]) ; 
     if (X < y) then (     execute println(i + 1) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    execute println(N + 1) ; 
 );
  static   operation print( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o+"") );
  static   operation println( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o+"") );
  static   operation Int( s : String) : int
  pre: true
  post: true
  activity: (     return (s)->toInteger() );
  static   operation Long( s : String) : long
  pre: true
  post: true
  activity: (     return (s)->toLong() );
  static class MyReader extends OclFile {
   static operation newMyReader() : MyReader
  pre: true
  post: true
  activity:
  ( var self : MyReader ;
    self := createMyReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation s() : String
  pre: true
  post: true
  activity: (     return readLine() );
   operation ss() : Sequence(String)
  pre: true
  post: true
  activity: (     return s()->split(" ") );
   operation i() : int
  pre: true
  post: true
  activity: (     return Int(s()) );
   operation ii() : Sequence(int)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var size : int ; size := ss->size() ;
    var ii : Sequence(int) ; ii := Integer.subrange(1,size)->collect(0) ;
        var j : int ; j := 0 ; while j < size do (     ii[j+1] := Int(ss[j+1]) ;  ;     j := j + 1 ) ; 
    return ii 
 );
   operation l() : long
  pre: true
  post: true
  activity: (     return Long(s()) );
   operation ll() : Sequence(long)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var size : int ; size := ss->size() ;
    var ll : Sequence(long) ; ll := Integer.subrange(1,size)->collect(0) ;
        var j : int ; j := 0 ; while j < size do (     ll[j+1] := Long(ss[j+1]) ;  ;     j := j + 1 ) ; 
    return ll 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isTwoAlter(String s){
    for(int i=0 ; i<s.length()-2 ; i++){
      if(s.charAt(i)!=s.charAt(i+2)){
        return false ;
      }
    }
    if(s.charAt(0)==s.charAt(1))return false ;
    return true ;
  }
  public static void main(String[] args){
    String str="ABAB" ;
    if(isTwoAlter(str))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isTwoAlter( s : String) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() - 2 do ( (     if (s->at(i+1) /= s->at(i + 2+1)) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     if (s->at(0+1) = s->at(1+1)) then     return false else skip ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "ABAB" ;
     if (isTwoAlter(str)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] arg){
    try(Scanner scanner=new Scanner(System.in)){
      int[] input=Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
      int n=input[0];
      int x=input[1];
      int sum=0 ;
      int count=1 ;
      for(int i : Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer :: parseInt).toArray()){
        sum+=i ;
        if(sum>x)break ;
        count++;
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var input : Sequence(int) ; input := stream(scanner.nextLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
     var n : int ; n := input[0+1] ;
    var x : int ; x := input[1+1] ;
    var sum : int ; sum := 0 ;
    var count : int ; count := 1 ;
    for (i : stream(scanner.nextLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence()) do ( (     sum := sum+(i) ; 
     if (sum > x) then     break else skip ; 
     count := count + 1 )  ) ; 
    OclFile["System.out"].println(count) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A758 {
  static Scanner sc=new Scanner();
  public static void main(String[] args){
    solve();
  }
  public static void solve(){
    int n=sc.nextInt();
    int[] arr=new int[n];
    int result=0,max=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      if(max<=arr[i])max=arr[i];
    }
    for(int j=0 ; j<n ; j++){
      result+=max-arr[j];
    }
    System.out.print(result);
  }
  static class Scanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A758 {
  static   attribute sc : OclFile := (arguments ( ));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var result : int ; result := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (max <= arr[i+1]) then     max := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     result := result+(max - arr[j+1]) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].print(result) ; 
 );
  static class Scanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Today {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
    }
    Arrays.sort(arr);
    int max=arr[n-1];
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      ans+=max-arr[i];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Today {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var max : int ; max := arr[n - 1+1] ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans+(max - arr[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1216A_Prefixes {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int len=input.nextInt();
    char[] str=input.next().toCharArray();
    int count=0 ;
    for(int i=0 ; i<len ; i+=2){
      if(str[i]==str[i+1]){
        str[i]=str[i]=='a' ? 'b' : 'a' ;
        count++;
      }
    }
    System.out.println(count);
    System.out.println(Arrays.toString(str).replaceAll("[\\[\\],] ",""));
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1216A_Prefixes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := input.getCurrent()->toInteger() ;
    var str : Sequence(String) ; str := input.getCurrent()->characters() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < len do ( (     if (str[i+1] = str[i + 1+1]) then (     str[i+1] := if str[i+1] = 'a' then 'b' else 'a' endif ; 
     count := count + 1 ) else skip )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(count) ; 
    OclFile["System.out"].println((str + "").replaceAllMatches("[\\[\\],] ", "" )) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    TreeSet<Integer>s=new TreeSet<>();
    if(n==1){
      System.out.println(0);
      return ;
    }
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr);
    int max=arr[n-1];
    long sum=0 ;
    for(int i=0 ; i<n-1 ; i++){
      sum+=max-arr[i];
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Set(int) ; s := Set{} ;
    if (n = 1) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var max : int ; max := arr[n - 1+1] ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     sum := sum+(max - arr[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class problems {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int citizens=input.nextInt(),theMax=0,sum=0 ;
    int ar[]=new int[citizens];
    for(int i=0 ; i<citizens ; i++){
      ar[i]=input.nextInt();
      if(theMax<ar[i]){
        theMax=ar[i];
      }
    }
    for(int i=0 ; i<citizens ; i++){
      if(ar[i]<=theMax){
        sum=sum+theMax-ar[i];
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class problems {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var citizens : int ; citizens := input.getCurrent()->toInteger() ;
    var theMax : int ; theMax := 0 ;
    var sum : int ; sum := 0 ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,citizens)->collect(0) ;
        var i : int ; i := 0 ; while i < citizens do ( (     ar[i+1] := input.getCurrent()->toInteger() ; 
     if (theMax < ar[i+1]) then (     theMax := ar[i+1] ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < citizens do ( (     if (ar[i+1] <= theMax) then (     sum := sum + theMax - ar[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    int max=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      max=Math.max(arr[i],max);
    }
    long min=0 ;
    for(int j=0 ; j<n ; j++){
      min+=Math.abs(arr[j]-max);
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     max := Set{arr[i+1], max}->max() )  ;     i := i + 1 ) ; 
    var min : long ; min := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     min := min+(if arr[j+1] - max < 0 then -(arr[j+1] - max) else arr[j+1] - max endif) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testcases=sc.nextInt();
    int hour ;
    int minute ;
    for(int i=0 ; i<testcases ; i++){
      hour=sc.nextInt();
      int hoursto=24-hour ;
      int minutes1=hoursto*60 ;
      minute=sc.nextInt();
      int totaltimeto=minutes1-minute ;
      System.out.println(totaltimeto);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testcases : int ; testcases := sc.getCurrent()->toInteger() ;
    var hour : int ;
    var minute : int ;
        var i : int ; i := 0 ; while i < testcases do ( (     hour := sc.getCurrent()->toInteger() ; 
     var hoursto : int ; hoursto := 24 - hour ;
    var minutes1 : int ; minutes1 := hoursto * 60 ;
    minute := sc.getCurrent()->toInteger() ; 
    var totaltimeto : int ; totaltimeto := minutes1 - minute ;
    OclFile["System.out"].println(totaltimeto) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf1283A {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    int h,m,min ;
    for(int i=1 ; i<=t ; i++){
      h=input.nextInt();
      m=input.nextInt();
      min=60-m ;
      if(++h<24)min+=(24-h)*60 ;
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1283A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
     var h : int ;
    var m : int ;
    var min : int ;
         var i : int ; i := 1 ; while i <= t do ( (     h := input.getCurrent()->toInteger() ; 
     m := input.getCurrent()->toInteger() ; 
    min := 60 - m ; 
    if ((h + 1) < 24) then     min := min+((24 - h) * 60) ; else skip ; 
    OclFile["System.out"].println(min) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf1283A {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    int h,m,min ;
    for(int i=1 ; i<=t ; i++){
      h=input.nextInt();
      m=input.nextInt();
      min=60-m ;
      if(++h<24)min+=(24-h)*60 ;
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1283A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
     var h : int ;
    var m : int ;
    var min : int ;
         var i : int ; i := 1 ; while i <= t do ( (     h := input.getCurrent()->toInteger() ; 
     m := input.getCurrent()->toInteger() ; 
    min := 60 - m ; 
    if ((h + 1) < 24) then     min := min+((24 - h) * 60) ; else skip ; 
    OclFile["System.out"].println(min) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class newYear {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    while(a-->0){
      int hour=in.nextInt();
      int minutes=in.nextInt();
      int h=0 ;
      int m=0 ;
      while(hour<23){
        h++;
        hour++;
      }
      while(minutes<60){
        m++;
        minutes++;
      }
      System.out.println((h*60)+m);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class newYear {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
         while (a > 0) do (        a := a - 1 ;     skip ; (     var hour : int ; hour := in.getCurrent()->toInteger() ;
     var minutes : int ; minutes := in.getCurrent()->toInteger() ;
    var h : int ; h := 0 ;
    var m : int ; m := 0 ;
    while (hour < 23) do (     h := h + 1 ; 
     hour := hour + 1 ) ; 
    while (minutes < 60) do (     m := m + 1 ; 
     minutes := minutes + 1 ) ; 
    OclFile["System.out"].println((h * 60) + m) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n ;
    int[] w,d ;
    String[] name ;
    int i,j,tmp ;
    String st ;
    n=sc.nextInt();
    for(; ; ){
      w=new int[n];
      d=new int[n];
      name=new String[n];
      for(i=0 ; i<n ; i++){
        name[i]=sc.next();
        w[i]=sc.nextInt();
        d[i]=sc.nextInt();
        d[i]=sc.nextInt();
        d[i]+=3*w[i];
      }
      for(i=0 ; i<n-1 ; i++){
        for(j=0 ; j<n-1-i ; j++){
          if(d[j]<d[j+1]){
            st=name[j];
            name[j]=name[j+1];
            name[j+1]=st ;
            tmp=d[j];
            d[j]=d[j+1];
            d[j+1]=tmp ;
          }
        }
      }
      for(i=0 ; i<n ; i++)System.out.println(name[i]+","+d[i]);
      n=sc.nextInt();
      if(n==0)break ;
      else System.out.println();
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var w : Sequence(int) ;
    var d : Sequence(int) ;
    var name : Sequence(String) ;
    var i : int ;
    var j : int ;
    var tmp : int ;
    var st : String ;
    n := sc.nextInt() ; 
      while true do ( (     w := Integer.subrange(1,n)->collect(0) ; 
     d := Integer.subrange(1,n)->collect(0) ; 
    name := Integer.subrange(1,n)->collect(null) ; 
        i := 0 ; while i < n do ( (     name[i+1] := sc.next() ; 
     w[i+1] := sc.nextInt() ; 
    d[i+1] := sc.nextInt() ; 
    d[i+1] := sc.nextInt() ; 
    d[i+1] := d[i+1]+(3 * w[i+1]) ; 
 )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n - 1 do ( (         j := 0 ; while j < n - 1 - i do ( (     if (d[j+1] < d[j + 1+1]) then (     st := name[j+1] ; 
     name[j+1] := name[j + 1+1] ; 
    name[j + 1+1] := st ; 
    tmp := d[j+1] ; 
    d[j+1] := d[j + 1+1] ; 
    d[j + 1+1] := tmp ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do (     OclFile["System.out"].println(name[i+1] + "," + d[i+1]) ;  ;     i := i + 1 ) ; 
    n := sc.nextInt() ; 
    if (n = 0) then     break else     OclFile["System.out"].println() ; ;  
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findRemainder(int n){
    int l=n % 10 ;
    while(n>=10)n/=10 ;
    int f=n ;
    int remainder=f % l ;
    System.out.println(remainder);
  }
  public static void main(String[] args){
    int n=5223 ;
    findRemainder(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findRemainder( n : int) : void
  pre: true
  post: true
  activity: (     var l : int ; l := n mod 10 ;
     while (n >= 10) do     n := n/(10) ; ; 
    var f : int ; f := n ;
    var remainder : int ; remainder := f mod l ;
    OclFile["System.out"].println(remainder) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5223 ;
     execute findRemainder(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NEWYEAR {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    for(int i=1 ; i<=T ; i++){
      int h=sc.nextInt();
      int m=sc.nextInt();
      int x=(24-h)*60-m ;
      System.out.println(x);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NEWYEAR {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= T do ( (     var h : int ; h := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     var x : int ; x := (24 - h) * 60 - m ;
     OclFile["System.out"].println(x) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long discard_count=0 ;
  static long power(long a,long n){
    if(n==0)return 1 ;
    long p=power(a,n/2);
    p=p*p ;
    if(n % 2==1)p=p*a ;
    return p ;
  }
  static void solve(int i,int n,float sum,float k,float[] a,float[] prefix){
    if(sum>k){
      discard_count+=power(2,n-i);
      return ;
    }
    if(i==n)return ;
    float rem=prefix[n-1]-prefix[i];
    if(sum+a[i]+rem>k)solve(i+1,n,sum+a[i],k,a,prefix);
    if(sum+rem>k)solve(i+1,n,sum,k,a,prefix);
  }
  static int countSubsequences(int[] arr,int n,long K){
    float sum=0.0f ;
    float k=(float)Math.log(K);
    float[] prefix=new float[n];
    float[] a=new float[n];
    for(int i=0 ; i<n ; i++){
      a[i]=(float)Math.log(arr[i]);
      sum+=a[i];
    }
    prefix[0]=a[0];
    for(int i=1 ; i<n ; i++){
      prefix[i]=prefix[i-1]+a[i];
    }
    long total=power(2,n)-1 ;
    if(sum<=k){
      return(int)total ;
    }
    solve(0,n,0.0f,k,a,prefix);
    return(int)(total-discard_count);
  }
  public static void main(String[] args){
    int arr[]={
      4,8,7,2 };
      int n=arr.length ;
      long k=50 ;
      System.out.print(countSubsequences(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute discard_count : long := 0;
  static   operation power( a : long, n : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     var p : long ; p := power(a, n / 2) ;
    p := p * p ; 
    if (n mod 2 = 1) then     p := p * a ; else skip ; 
    return p 
 );
  static   operation solve( i : int, n : int, sum : double, k : double, a : Sequence(double), prefix : Sequence(double)) : void
  pre: true
  post: true
  activity: (     if (sum > k) then (     discard_count := discard_count+(power(2, n - i)) ; 
     return ) else skip ; 
     if (i = n) then     return else skip ; 
    var rem : double ; rem := prefix[n - 1+1] - prefix[i+1] ;
    if (sum + a[i+1] + rem > k) then     execute solve(i + 1, n, sum + a[i+1], k, a, prefix) ; else skip ; 
    if (sum + rem > k) then     execute solve(i + 1, n, sum, k, a, prefix) ; else skip ; 
 );
  static   operation countSubsequences( arr : Sequence(int), n : int, K : long) : int
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0.0f ;
     var k : double ; k := (K)->log()->oclAsType(double) ;
    var prefix : Sequence(double) ; prefix := Integer.subrange(1,n)->collect(0.0) ;
    var a : Sequence(double) ; a := Integer.subrange(1,n)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (arr[i+1])->log()->oclAsType(double) ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    prefix[0+1] := a[0+1] ; 
        var i : int ; i := 1 ; while i < n do ( (     prefix[i+1] := prefix[i - 1+1] + a[i+1] )  ;     i := i + 1 ) ; 
    var total : long ; total := power(2, n) - 1 ;
    if (sum <= k) then (     return total->oclAsType(int) ) else skip ; 
    execute solve(0, n, 0.0f, k, a, prefix) ; 
    return (total - discard_count)->oclAsType(int) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,8,7,2} ;
     var n : int ; n := arr->size() ;
     var k : long ; k := 50 ;
     OclFile["System.out"].print(countSubsequences(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      final int n=sc.nextInt();
      if(n==0){
        break ;
      }
      for(int i=0 ; i<n ; i++){
        int pm=sc.nextInt(),pe=sc.nextInt(),pj=sc.nextInt();
        if(Math.max(Math.max(pm,pe),pj)==100){
          System.out.println("A");
        }
        else if((pm+pe)/2>=90){
          System.out.println("A");
        }
        else if((pm+pe+pj)/3>=80){
          System.out.println("A");
        }
        else if((pm+pe+pj)/3>=70){
          System.out.println("B");
        }
        else if((pm+pe+pj)/3>=50 && Math.max(pm,pe)>=80){
          System.out.println("B");
        }
        else {
          System.out.println("C");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     var pm : int ; pm := sc.getCurrent()->toInteger() ;
    var pe : int ; pe := sc.getCurrent()->toInteger() ;
    var pj : int ; pj := sc.getCurrent()->toInteger() ;
     if (Set{Set{pm, pe}->max(), pj}->max() = 100) then (     OclFile["System.out"].println("A") ) else     if ((pm + pe) / 2 >= 90) then (     OclFile["System.out"].println("A") ) else     if ((pm + pe + pj) / 3 >= 80) then (     OclFile["System.out"].println("A") ) else     if ((pm + pe + pj) / 3 >= 70) then (     OclFile["System.out"].println("B") ) else     if ((pm + pe + pj) / 3 >= 50 & Set{pm, pe}->max() >= 80) then (     OclFile["System.out"].println("B") ) else (     OclFile["System.out"].println("C") ) ;  ;  ;  ;  )  ;     i := i + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    StringBuilder sb=new StringBuilder();
    while(!(line=br.readLine()).equals("0")){
      int n=Integer.parseInt(line);
      for(int i=0 ; i<n ; ++i){
        StringTokenizer st=new StringTokenizer(br.readLine());
        int pm=Integer.parseInt(st.nextToken());
        int pe=Integer.parseInt(st.nextToken());
        int pj=Integer.parseInt(st.nextToken());
        int sum=pm+pe+pj ;
        char rank='C' ;
        if(pm>99 || pe>99 || pj>99){
          rank='A' ;
        }
        else if(sum>239 || sum-pj>179){
          rank='A' ;
        }
        else if(sum>209){
          rank='B' ;
        }
        else if(sum>149 &&(pm>79 || pe>79)){
          rank='B' ;
        }
        sb.append(rank).append('\n');
      }
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
    var sb : String ; sb := StringLib.newString() ;
    while (not((line) = "0")) do (     var n : int ; n := (line)->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var pm : int ; pm := (st.next())->toInteger() ;
    var pe : int ; pe := (st.next())->toInteger() ;
    var pj : int ; pj := (st.next())->toInteger() ;
    var sum : int ; sum := pm + pe + pj ;
    var rank : String ; rank := 'C' ;
    if (pm > 99 or pe > 99 or pj > 99) then (     rank := 'A' ) else     if (sum > 239 or sum - pj > 179) then (     rank := 'A' ) else     if (sum > 209) then (     rank := 'B' ) else     if (sum > 149 & (pm > 79 or pe > 79)) then (     rank := 'B' ) else skip ; ;  ;  ;  
    sb := sb + StringLib.newString(rank) + StringLib.newString('
') ; 
 )  ;     i := i + 1 ) ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,pm,pe,pj ;
    for(; ; ){
      n=sc.nextInt();
      if(n==0)break ;
      for(; n-->0 ; out.println(solve(pm,pe,pj))){
        pm=sc.nextInt();
        pe=sc.nextInt();
        pj=sc.nextInt();
      }
    }
    sc.close();
  }
  private static String solve(int m,int e,int j){
    if(m==100)return "A" ;
    if(e==100)return "A" ;
    if(j==100)return "A" ;
    if(m+e>=180)return "A" ;
    if(m+e+j>=240)return "A" ;
    if(m+e+j>=210)return "B" ;
    if(m+e+j>=150 && m>=80)return "B" ;
    if(m+e+j>=150 && e>=80)return "B" ;
    return "C" ;
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var pm : int ;
    var pe : int ;
    var pj : int ;
       while true do ( (     n := sc.nextInt() ; 
     if (n = 0) then     break else skip ; 
       while n > 0 do ( (     pm := sc.nextInt() ; 
     pe := sc.nextInt() ; 
     pj := sc.nextInt() )  ;     out.println(solve(pm, pe, pj)) ) )  ) ; 
     sc.close() );
  static   operation solve( m : int, e : int, j : int) : String
  pre: true
  post: true
  activity: (     if (m = 100) then     return "A" else skip ; 
     if (e = 100) then     return "A" else skip ; 
    if (j = 100) then     return "A" else skip ; 
    if (m + e >= 180) then     return "A" else skip ; 
    if (m + e + j >= 240) then     return "A" else skip ; 
    if (m + e + j >= 210) then     return "B" else skip ; 
    if (m + e + j >= 150 & m >= 80) then     return "B" else skip ; 
    if (m + e + j >= 150 & e >= 80) then     return "B" else skip ; 
    return "C" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.regex.Matcher ;
import java.util.regex.Pattern ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      for(int i=0 ; i<n ; i++){
        int a=sc.nextInt();
        int b=sc.nextInt();
        int c=sc.nextInt();
        char ans=0 ;
        if(ans==0){
          if(a>=100 || b>=100 || c>=100)ans='A' ;
        }
        if(ans==0){
          if(a+b>=180)ans='A' ;
        }
        if(ans==0){
          if(a+b+c>=240)ans='A' ;
        }
        if(ans==0){
          if(a+b+c>=210)ans='B' ;
        }
        if(ans==0){
          if(a+b+c>=150 &&(a>=80 || b>=80))ans='B' ;
        }
        if(ans==0){
          ans='C' ;
        }
        System.out.println(ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var ans : String ; ans := 0 ;
    if (ans = 0) then (     if (a >= 100 or b >= 100 or c >= 100) then     ans := 'A' ; else skip ) else skip ; 
    if (ans = 0) then (     if (a + b >= 180) then     ans := 'A' ; else skip ) else skip ; 
    if (ans = 0) then (     if (a + b + c >= 240) then     ans := 'A' ; else skip ) else skip ; 
    if (ans = 0) then (     if (a + b + c >= 210) then     ans := 'B' ; else skip ) else skip ; 
    if (ans = 0) then (     if (a + b + c >= 150 & (a >= 80 or b >= 80)) then     ans := 'B' ; else skip ) else skip ; 
    if (ans = 0) then (     ans := 'C' ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      for(int i=0 ; i<n ; i++){
        int[] score=new int[3];
        for(int j=0 ; j<3 ; j++)score[j]=sc.nextInt();
        if(score[0]==100 || score[1]==100 || score[2]==100 || score[0]+score[1]>=180 || score[0]+score[1]+score[2]>=240){
          System.out.println("A");
        }
        else if(score[0]+score[1]+score[2]>=210 ||(score[0]+score[1]+score[2]>=150 &&(score[0]>=80 || score[1]>=80))){
          System.out.println("B");
        }
        else System.out.println("C");
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     var score : Sequence(int) ; score := Integer.subrange(1,3)->collect(0) ;
         var j : int ; j := 0 ; while j < 3 do (     score[j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ; 
     if (score[0+1] = 100 or score[1+1] = 100 or score[2+1] = 100 or score[0+1] + score[1+1] >= 180 or score[0+1] + score[1+1] + score[2+1] >= 240) then (     OclFile["System.out"].println("A") ) else     if (score[0+1] + score[1+1] + score[2+1] >= 210 or (score[0+1] + score[1+1] + score[2+1] >= 150 & (score[0+1] >= 80 or score[1+1] >= 80))) then (     OclFile["System.out"].println("B") ) else     OclFile["System.out"].println("C") ; ;  )  ;     i := i + 1 ) )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int k=sc.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      Arrays.sort(arr);
      System.out.println(arr[n-k]);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    OclFile["System.out"].println(arr[n - k+1]) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr);
    System.out.println(arr[n-k]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    OclFile["System.out"].println(arr[n - k+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int k=scanner.nextInt();
    Integer[] a=new Integer[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scanner.nextInt();
    }
    Arrays.sort(a,new P6974Cmp());
    System.out.println(a[k-1]);
  }
}
class P6974Cmp implements Comparator<Integer>{
  @ Override public int compare(Integer o1,Integer o2){
    return o2-o1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := OclComparator.sortWith(a, P6974Cmp.newP6974Cmp()) ; 
    OclFile["System.out"].println(a[k - 1+1]) ; 
 );
}
class P6974Cmp implements Function(<int>,(<int>,boolean)) {
      operation compare( o1 : int, o2 : int) : int
  pre: true
  post: true
  activity: (     return o2 - o1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Ex1 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int length=in.nextInt();
      int balance=in.nextInt();
      String s=in.next();
      int val=0 ;
      int min=0 ;
      int max=0 ;
      int counter=0 ;
      for(int i=0 ; i<length ; i++){
        if((s.charAt(i)=='0')){
          val++;
        }
        else {
          val--;
        }
        min=Math.min(val,min);
        max=Math.max(val,max);
      }
      if(val==0 && balance>=min && balance<=max){
        System.out.println("-1");
        continue ;
      }
      else if(val==0){
        System.out.println("0");
        continue ;
      }
      int totalVal=val ;
      val=0 ;
      if(balance==0){
        counter++;
      }
      for(int i=0 ; i<length ; i++){
        if((s.charAt(i)=='0')){
          val++;
        }
        else {
          val--;
        }
        if((balance-val)% totalVal==0 &&(balance-val)/totalVal>=0){
          counter++;
        }
      }
      System.out.println(counter);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ex1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var length : int ; length := in.getCurrent()->toInteger() ;
     var balance : int ; balance := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var val : int ; val := 0 ;
    var min : int ; min := 0 ;
    var max : int ; max := 0 ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < length do ( (     if ((s->at(i+1) = '0')) then (     val := val + 1 ) else (     val := val - 1 ) ;  
     min := Set{val, min}->min() ; 
     max := Set{val, max}->max() )  ;     i := i + 1 ) ; 
    if (val = 0 & balance >= min & balance <= max) then (     OclFile["System.out"].println("-1") ; 
     continue ) else     if (val = 0) then (     OclFile["System.out"].println("0") ; 
     continue ) else skip ; ;  
    var totalVal : int ; totalVal := val ;
    val := 0 ; 
    if (balance = 0) then (     counter := counter + 1 ) else skip ; 
        var i : int ; i := 0 ; while i < length do ( (     if ((s->at(i+1) = '0')) then (     val := val + 1 ) else (     val := val - 1 ) ;  
     if ((balance - (val)->char2byte()) mod totalVal = 0 & (balance - (val)->char2byte()) / totalVal >= 0) then (     counter := counter + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    String[] names=new String[] {
      "Sheldon","Leonard","Penny","Rajesh","Howard" };
      long N=in.nextLong();
      long round=5 ;
      while(N>round){
        N-=round ;
        round*=2 ;
      }
      long sectionLength=round/5 ;
      int person=(int)((N-1)/sectionLength);
      pw.println(names[person]);
      pw.close();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var names : Sequence(String) ; names := Sequence{"Sheldon","Leonard","Penny","Rajesh","Howard"} ;
    var N : long ; N := in.getCurrent()->toLong() ;
    var round : long ; round := 5 ;
    while (N > round) do (     N := N-(round) ; 
     round := round*(2) ) ; 
    var sectionLength : long ; sectionLength := round / 5 ;
    var person : int ; person := ((N - 1) / sectionLength)->oclAsType(int) ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Node {
    int data ;
    Node left ;
    Node right ;
  };
  static Node newNode(int data){
    Node node=new Node();
    node.data=data ;
    node.left=null ;
    node.right=null ;
    return node ;
  }
  static void inorder(Node root){
    if(root==null)return ;
    inorder(root.left);
    System.out.print(root.data+" ");
    inorder(root.right);
  }
  static int isIdentical(Node root1,Node root2){
    if(root1==null && root2==null)return 1 ;
    else if(root1!=null && root2==null)return 0 ;
    else if(root1==null && root2!=null)return 0 ;
    else {
      if(root1.data==root2.data && isIdentical(root1.left,root2.left)==1 && isIdentical(root1.right,root2.right)==1)return 1 ;
      else return 0 ;
    }
  }
  public static void main(String[] args){
    Node root1=newNode(5);
    Node root2=newNode(5);
    root1.left=newNode(3);
    root1.right=newNode(8);
    root1.left.left=newNode(2);
    root1.left.right=newNode(4);
    root2.left=newNode(3);
    root2.right=newNode(8);
    root2.left.left=newNode(2);
    root2.left.right=newNode(4);
    if(isIdentical(root1,root2)==1)System.out.print("Both BSTs are identical");
    else System.out.print("BSTs are not identical");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute left : Node;
   attribute right : Node;
}
  static   operation newNode( data : int) : Node
  pre: true
  post: true
  activity: (     var node : Node ; node := Node.newNode() ;
     node.data := data ; 
    node.left := null ; 
    node.right := null ; 
    return node 
 );
  static   operation inorder( root : Node) : void
  pre: true
  post: true
  activity: (     if (root = null) then     return else skip ; 
     execute inorder(root.left) ; 
     OclFile["System.out"].print(root.data + " ") ; 
     execute inorder(root.right) );
  static   operation isIdentical( root1 : Node, root2 : Node) : int
  pre: true
  post: true
  activity: (     if (root1 = null & root2 = null) then     return 1 else     if (root1 /= null & root2 = null) then     return 0 else     if (root1 = null & root2 /= null) then     return 0 else (     if (root1.data = root2.data & isIdentical(root1.left, root2.left) = 1 & isIdentical(root1.right, root2.right) = 1) then     return 1 else     return 0 ) ;  ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var root1 : Node ; root1 := newNode(5) ;
     var root2 : Node ; root2 := newNode(5) ;
    root1.left := newNode(3) ; 
    root1.right := newNode(8) ; 
    root1.left.left := newNode(2) ; 
    root1.left.right := newNode(4) ; 
    root2.left := newNode(3) ; 
    root2.right := newNode(8) ; 
    root2.left.left := newNode(2) ; 
    root2.left.right := newNode(4) ; 
    if (isIdentical(root1, root2) = 1) then     OclFile["System.out"].print("Both BSTs are identical") else     OclFile["System.out"].print("BSTs are not identical") ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  static int search(int arr[],int l,int h,int key){
    if(l>h)return-1 ;
    int mid=(l+h)/2 ;
    if(arr[mid]==key)return mid ;
    if(arr[l]<=arr[mid]){
      if(key>=arr[l] && key<=arr[mid])return search(arr,l,mid-1,key);
      return search(arr,mid+1,h,key);
    }
    if(key>=arr[mid] && key<=arr[h])return search(arr,mid+1,h,key);
    return search(arr,l,mid-1,key);
  }
  public static void main(String args[]){
    int arr[]={
      4,5,6,7,8,9,1,2,3 };
      int n=arr.length ;
      int key=6 ;
      int i=search(arr,0,n-1,key);
      if(i!=-1)System.out.println("Index: "+i);
      else System.out.println("Key not found");
    }
  }

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation search( arr : Sequence(int), l : int, h : int, key : int) : int
  pre: true
  post: true
  activity: (     if (l > h) then     return -1 else skip ; 
     var mid : int ; mid := (l + h) / 2 ;
    if (arr[mid+1] = key) then     return mid else skip ; 
    if (arr[l+1] <= arr[mid+1]) then (     if (key >= arr[l+1] & key <= arr[mid+1]) then     return search(arr, l, mid - 1, key) else skip ; 
     return search(arr, mid + 1, h, key) ) else skip ; 
    if (key >= arr[mid+1] & key <= arr[h+1]) then     return search(arr, mid + 1, h, key) else skip ; 
    return search(arr, l, mid - 1, key) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,5,6,7,8,9,1,2,3} ;
     var n : int ; n := arr->size() ;
    var key : int ; key := 6 ;
    var i : int ; i := search(arr, 0, n - 1, key) ;
    if (i /= -1) then     OclFile["System.out"].println("Index: " + i) else     OclFile["System.out"].println("Key not found") ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static void fillWithFreq(int arr[],int n){
    int temp[]=new int[n];
    Arrays.fill(temp,0);
    for(int i=0 ; i<n ; i++)temp[arr[i] ]+=1 ;
    for(int i=0 ; i<n ; i++)arr[i]=temp[i];
  }
  public static void main(String[] args){
    int arr[]={
      5,2,3,4,5,5,4,5,6,7 };
      int n=arr.length ;
      fillWithFreq(arr,n);
      for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fillWithFreq( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(int) ; temp := Integer.subrange(1,n)->collect(0) ;
     temp := temp->collect(0) ; 
         var i : int ; i := 0 ; while i < n do (     temp[arr[i+1]+1] := temp[arr[i+1]+1]+(1) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do (     arr[i+1] := temp[i+1] ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,2,3,4,5,5,4,5,6,7} ;
     var n : int ; n := arr->size() ;
     execute fillWithFreq(arr, n) ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void convert_To_Len_th_base(int n,int arr[],int len,int L){
    for(int i=0 ; i<L ; i++){
      System.out.print(arr[n % len]);
      n/=len ;
    }
    System.out.println();
  }
  static void print(int arr[],int len,int L){
    for(int i=0 ; i<(int)Math.pow(len,L); i++){
      convert_To_Len_th_base(i,arr,len,L);
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3 };
      int len=arr.length ;
      int L=2 ;
      print(arr,len,L);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation convert_To_Len_th_base( n : int, arr : Sequence(int), len : int, L : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < L do ( (     OclFile["System.out"].print(arr[n mod len+1]) ; 
     n := n/(len) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation print( arr : Sequence(int), len : int, L : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < len->pow(L)->oclAsType(int) do ( (     execute convert_To_Len_th_base(i, arr, len, L) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3} ;
     var len : int ; len := arr->size() ;
     var L : int ; L := 2 ;
     execute print(arr, len, L) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int nodes=input.nextInt();
    int edges=input.nextInt();
    int[] arr=new int[nodes];
    for(int i=0 ; i<edges ; i++){
      int n1=input.nextInt();
      int n2=input.nextInt();
      arr[n1-1]++;
      arr[n2-1]++;
    }
    int deg1=0 ;
    int deg2=0 ;
    int deg3=0 ;
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]==1){
        deg1++;
      }
      else if(arr[i]==2){
        deg2++;
      }
      else if(arr[i]==nodes-1){
        deg3++;
      }
      else {
        System.out.println("unknown topology");
        return ;
      }
    }
    if(deg2==nodes){
      System.out.println("ring topology");
    }
    else if(deg2==nodes-2 && deg1==2){
      System.out.println("bus topology");
    }
    else if(deg3==1 && deg1==nodes-1){
      System.out.println("star topology");
    }
    else {
      System.out.println("unknown topology");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var nodes : int ; nodes := input.getCurrent()->toInteger() ;
    var edges : int ; edges := input.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,nodes)->collect(0) ;
        var i : int ; i := 0 ; while i < edges do ( (     var n1 : int ; n1 := input.getCurrent()->toInteger() ;
     var n2 : int ; n2 := input.getCurrent()->toInteger() ;
     arr[n1 - 1+1] := arr[n1 - 1+1] + 1 ; 
     arr[n2 - 1+1] := arr[n2 - 1+1] + 1 )  ;     i := i + 1 ) ; 
    var deg1 : int ; deg1 := 0 ;
    var deg2 : int ; deg2 := 0 ;
    var deg3 : int ; deg3 := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = 1) then (     deg1 := deg1 + 1 ) else     if (arr[i+1] = 2) then (     deg2 := deg2 + 1 ) else     if (arr[i+1] = nodes - 1) then (     deg3 := deg3 + 1 ) else (     OclFile["System.out"].println("unknown topology") ; 
     return ) ;  ;  )  ;     i := i + 1 ) ; 
    if (deg2 = nodes) then (     OclFile["System.out"].println("ring topology") ) else     if (deg2 = nodes - 2 & deg1 = 2) then (     OclFile["System.out"].println("bus topology") ) else     if (deg3 = 1 & deg1 = nodes - 1) then (     OclFile["System.out"].println("star topology") ) else (     OclFile["System.out"].println("unknown topology") ) ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    int[] x=new int[n+1];
    int[] y=new int[n+1];
    int two=0,one=0 ;
    for(int j=0 ; j<m ; j++){
      int a=sc.nextInt(),b=sc.nextInt();
      x[a]++;
      x[b]++;
      y[a]=b ;
      y[b]=a ;
    }
    int max=0 ;
    for(int i=1 ; i<=n ; i++){
      if(x[i]==1)one++;
      else if(x[i]==2)two++;
      max=Math.max(max,x[i]);
    }
    if(max==m)System.out.println("star topology");
    else if(two==n)System.out.println("ring topology");
    else if(two==n-2 && one==2)System.out.println("bus topology");
    else System.out.println("unknown topology");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n + 1)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n + 1)->collect(0) ;
    var two : int ; two := 0 ;
    var one : int ; one := 0 ;
        var j : int ; j := 0 ; while j < m do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
     x[a+1] := x[a+1] + 1 ; 
    x[b+1] := x[b+1] + 1 ; 
    y[a+1] := b ; 
    y[b+1] := a ; 
 )  ;     j := j + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (x[i+1] = 1) then     one := one + 1 else     if (x[i+1] = 2) then     two := two + 1 ; else skip ; ;  
     max := Set{max, x[i+1]}->max() )  ;     i := i + 1 ) ; 
    if (max = m) then     OclFile["System.out"].println("star topology") else     if (two = n) then     OclFile["System.out"].println("ring topology") else     if (two = n - 2 & one = 2) then     OclFile["System.out"].println("bus topology") else     OclFile["System.out"].println("unknown topology") ; ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B2 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] data=new int[n];
    int max=0 ;
    int twoTimes=0 ;
    for(int i=0 ; i<m ; i++){
      int k=sc.nextInt();
      int v=sc.nextInt();
      data[k-1]++;
      data[v-1]++;
      if(data[k-1]==2)twoTimes++;
      if(data[v-1]==2)twoTimes++;
      max=Math.max(max,data[k-1]);
      max=Math.max(max,data[v-1]);
    }
    if(max==2 && twoTimes==n){
      System.out.println("ring topology");
    }
    else if(max==2 && twoTimes==n-2){
      System.out.println("bus topology");
    }
    else if(max==m){
      System.out.println("star topology");
    }
    else {
      System.out.println("unknown topology");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var data : Sequence(int) ; data := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := 0 ;
    var twoTimes : int ; twoTimes := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var k : int ; k := sc.getCurrent()->toInteger() ;
     var v : int ; v := sc.getCurrent()->toInteger() ;
    data[k - 1+1] := data[k - 1+1] + 1 ; 
    data[v - 1+1] := data[v - 1+1] + 1 ; 
    if (data[k - 1+1] = 2) then     twoTimes := twoTimes + 1 ; else skip ; 
    if (data[v - 1+1] = 2) then     twoTimes := twoTimes + 1 ; else skip ; 
    max := Set{max, data[k - 1+1]}->max() ; 
    max := Set{max, data[v - 1+1]}->max() ; 
 )  ;     i := i + 1 ) ; 
    if (max = 2 & twoTimes = n) then (     OclFile["System.out"].println("ring topology") ) else     if (max = 2 & twoTimes = n - 2) then (     OclFile["System.out"].println("bus topology") ) else     if (max = m) then (     OclFile["System.out"].println("star topology") ) else (     OclFile["System.out"].println("unknown topology") ) ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.*;
public class Codeforces {
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  PrintWriter out=new PrintWriter(System.out);
  StringTokenizer st=new StringTokenizer("");
  String next(){
    if(! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
      }
    }
    return st.nextToken();
  }
  int nextInt(){
    return Integer.parseInt(next());
  }
  public static void main(String[] args){
    new Codeforces().solve();
  }
  Node node[];
  void solve(){
    int n=nextInt(),m=nextInt();
    node=new Node[n+1];
    for(int i=0 ; i<n+1 ; i++)node[i]=new Node();
    for(int i=0 ; i<m ; i++){
      int a=nextInt(),b=nextInt();
      node[a] .adj.add(b);
      node[b] .adj.add(a);
    }
    int res[]=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      res[i]=node[i] .adj.size();
    }
    int notOne=0,two=0,one=0,zero=0 ;
    for(int i : res){
      if(i==0)zero++;
      if(i!=1){
        notOne++;
      }
      if(i==2)two++;
      if(i==1)one++;
    }
    notOne--;
    if(two==n){
      out.println("ring topology");
    }
    else if(one==2 && two==n-2){
      out.println("bus topology");
    }
    else if(notOne==1 && one==n-1){
      out.println("star topology");
    }
    else {
      out.println("unknown topology");
    }
    out.close();
  }
}
class Node {
  List<Integer>adj=new ArrayList<>();
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     if (not(st.hasNext())) then (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do skip
 ) else skip ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Codeforces.newCodeforces().solve() );
   attribute node : Sequence(Node);
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
    var m : int ; m := nextInt() ;
     node := Integer.subrange(1,n + 1)->collect(null) ; 
        var i : int ; i := 0 ; while i < n + 1 do (     node[i+1] := Node.newNode() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := nextInt() ;
    var b : int ; b := nextInt() ;
     node[a+1].adj->excludes(b) ; 
     node[b+1].adj->excludes(a) )  ;     i := i + 1 ) ; 
    var res : Sequence(int) ; res := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     res[i+1] := node[i+1].adj->size() )  ;     i := i + 1 ) ; 
    var notOne : int ; notOne := 0 ;
    var two : int ; two := 0 ;
    var one : int ; one := 0 ;
    var zero : int ; zero := 0 ;
    for (i : res) do ( (     if (i = 0) then     zero := zero + 1 ; else skip ; 
     if (i /= 1) then (     notOne := notOne + 1 ) else skip ; 
     if (i = 2) then     two := two + 1 ; else skip ; 
     if (i = 1) then     one := one + 1 ; else skip )  ) ; 
    notOne := notOne - 1 ; 
    if (two = n) then (     skip ) else     if (one = 2 & two = n - 2) then (     skip ) else     if (notOne = 1 & one = n - 1) then (     skip ) else (     skip ) ;  ;  ;  
    skip ; 
 );
}
class Node {
   attribute adj : Sequence(int) := Sequence{};
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long max_gcd(long n,long p){
    int count=0 ;
    long gcd=1 ;
    while(p % 2==0){
      p>>=1 ;
      count++;
    }
    if(count>0)gcd*=(long)Math.pow(2,count/n);
    for(long i=3 ; i<=Math.sqrt(p); i+=2){
      count=0 ;
      while(p % i==0){
        count++;
        p=p/i ;
      }
      if(count>0){
        gcd*=(long)Math.pow(i,count/n);
      }
    }
    if(p>2)gcd*=(long)Math.pow(p,1/n);
    return gcd ;
  }
  public static void main(String[] args){
    long n=3 ;
    long p=80 ;
    System.out.println(max_gcd(n,p));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation max_gcd( n : long, p : long) : long
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var gcd : long ; gcd := 1 ;
    while (p mod 2 = 0) do (     p := p/(2->pow(1)) ; 
     count := count + 1 ) ; 
    if (count > 0) then     gcd := gcd*(2->pow(count / n)->oclAsType(long)) ; else skip ; 
        var i : long ; i := 3 ; while i <= (p)->sqrt() do ( (     count := 0 ; 
     while (p mod i = 0) do (     count := count + 1 ; 
     p := p / i ) ; 
     if (count > 0) then (     gcd := gcd*(i->pow(count / n)->oclAsType(long)) ) else skip )  ;     i := i+(2) ) ; 
    if (p > 2) then     gcd := gcd*(p->pow(1 / n)->oclAsType(long)) ; else skip ; 
    return gcd 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 3 ;
     var p : long ; p := 80 ;
     OclFile["System.out"].println(max_gcd(n, p)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maxArea(float perimeter){
    int length=(int)Math.ceil(perimeter/4);
    int breadth=(int)Math.floor(perimeter/4);
    return length*breadth ;
  }
  public static void main(String[] args){
    float n=38 ;
    System.out.println("Maximum Area="+maxArea(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxArea( perimeter : double) : int
  pre: true
  post: true
  activity: (     var length : int ; length := (perimeter / 4)->ceil()->oclAsType(int) ;
     var breadth : int ; breadth := (perimeter / 4)->floor()->oclAsType(int) ;
     return length * breadth );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 38 ;
     OclFile["System.out"].println("Maximum Area=" + maxArea(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=s.nextInt();
    Arrays.sort(a);
    int c=0 ;
    int st=0 ;
    for(int i=0,j=n-1 ; i<n ; i++,j--){
      if(a[j]==2 && a[i]+a[j]==3){
        c++;
      }
      else {
        st=i ;
        break ;
      }
    }
    int one=0 ;
    for(int i=st ; i<n ; i++){
      if(a[i]==1)one++;
      else break ;
    }
    System.out.println(c+one/3);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var c : int ; c := 0 ;
    var st : int ; st := 0 ;
        var i : int ; i := 0 ;
    var j : int ; j := n - 1 ; while i < n do ( (     if (a[j+1] = 2 & a[i+1] + a[j+1] = 3) then (     c := c + 1 ) else (     st := i ; 
     break ) )  ;     i := i + 1 ;     j := j - 1 ) ; 
    var one : int ; one := 0 ;
        var i : int ; i := st ; while i < n do ( (     if (a[i+1] = 1) then     one := one + 1 ; else     break )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c + one / 3) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] arr=sc.next().toCharArray();
    int[] leftJ=new int[n+2];
    int[] rightI=new int[n+2];
    for(int i=1 ; i<=n ; i++){
      leftJ[i]=leftJ[i-1];
      if(arr[i-1]=='J'){
        leftJ[i]++;
      }
      rightI[n-i+1]=rightI[n-i+2];
      if(arr[n-i]=='I'){
        rightI[n-i+1]++;
      }
    }
    long sumI=0 ;
    long sumJ=0 ;
    long maxO=0 ;
    long total=0 ;
    for(int i=1 ; i<=n ; i++){
      long tmp ;
      if(arr[i-1]=='O'){
        tmp=leftJ[i-1]*rightI[i+1];
        total+=tmp ;
        sumJ+=(leftJ[i-1]+1)*rightI[i+1];
        sumI+=leftJ[i-1]*(rightI[i+1]+1);
      }
      else {
        tmp=leftJ[i-1]*rightI[i];
      }
      maxO=Math.max(maxO,tmp);
    }
    total+=maxO ;
    total=Math.max(total,sumJ);
    total=Math.max(total,sumI);
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
    var leftJ : Sequence(int) ; leftJ := Integer.subrange(1,n + 2)->collect(0) ;
    var rightI : Sequence(int) ; rightI := Integer.subrange(1,n + 2)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     leftJ[i+1] := leftJ[i - 1+1] ; 
     if (arr[i - 1+1] = 'J') then (     leftJ[i+1] := leftJ[i+1] + 1 ) else skip ; 
     rightI[n - i + 1+1] := rightI[n - i + 2+1] ; 
     if (arr[n - i+1] = 'I') then (     rightI[n - i + 1+1] := rightI[n - i + 1+1] + 1 ) else skip )  ;     i := i + 1 ) ; 
    var sumI : long ; sumI := 0 ;
    var sumJ : long ; sumJ := 0 ;
    var maxO : long ; maxO := 0 ;
    var total : long ; total := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var tmp : long ;
     if (arr[i - 1+1] = 'O') then (     tmp := leftJ[i - 1+1] * rightI[i + 1+1] ; 
     total := total+(tmp) ; 
     sumJ := sumJ+((leftJ[i - 1+1] + 1) * rightI[i + 1+1]) ; 
     sumI := sumI+(leftJ[i - 1+1] * (rightI[i + 1+1] + 1)) ) else (     tmp := leftJ[i - 1+1] * rightI[i+1] ) ;  
     maxO := Set{maxO, tmp}->max() )  ;     i := i + 1 ) ; 
    total := total+(maxO) ; 
    total := Set{total, sumJ}->max() ; 
    total := Set{total, sumI}->max() ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DoubleCola {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    long n=s.nextLong();
    long m=5 ;
    long k=0 ;
    while(k+m<n){
      k+=m ;
      m*=2 ;
    }
    long x=n-k ;
    long y=m/5 ;
    if(x<=y)System.out.println("Sheldon");
    else if(x<=2*y)System.out.println("Leonard");
    else if(x<=3*y)System.out.println("Penny");
    else if(x<=4*y)System.out.println("Rajesh");
    else System.out.println("Howard");
  }
}
------------------------------------------------------------
OCL File:
---------
 class DoubleCola {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := s.getCurrent()->toLong() ;
    var m : long ; m := 5 ;
    var k : long ; k := 0 ;
    while (k + m < n) do (     k := k+(m) ; 
     m := m*(2) ) ; 
    var x : long ; x := n - k ;
    var y : long ; y := m / 5 ;
    if (x <= y) then     OclFile["System.out"].println("Sheldon") else     if (x <= 2 * y) then     OclFile["System.out"].println("Leonard") else     if (x <= 3 * y) then     OclFile["System.out"].println("Penny") else     if (x <= 4 * y) then     OclFile["System.out"].println("Rajesh") else     OclFile["System.out"].println("Howard") ; ;  ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    int ones=0,twos=0 ;
    for(int i=0 ; i<n ; ++i)if(sc.nextInt()==1)++ones ;
    else++twos ;
    int ans=Math.min(ones,twos);
    ones-=ans ;
    ans+=ones/3 ;
    out.println(ans);
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var ones : int ; ones := 0 ;
    var twos : int ; twos := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (sc.getCurrent()->toInteger() = 1) then     ones := ones + 1 else     twos := twos + 1 ; ;   ;     i := i + 1 ) ; 
    var ans : int ; ans := Set{ones, twos}->min() ;
    ones := ones-(ans) ; 
    ans := ans+(ones / 3) ; 
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] a=new int[n];
    int[] b=new int[2];
    int i ;
    for(i=0 ; i<n ; i++){
      a[i]=input.nextInt();
      b[a[i]-1]++;
    }
    if(b[1]>=b[0]){
      System.out.println(b[0]);
    }
    else {
      System.out.println((b[0]-b[1])/3+b[1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,2)->collect(0) ;
    var i : int ;
        i := 0 ; while i < n do ( (     a[i+1] := input.getCurrent()->toInteger() ; 
     b[a[i+1] - 1+1] := b[a[i+1] - 1+1] + 1 )  ;     i := i + 1 ) ; 
    if (b[1+1] >= b[0+1]) then (     OclFile["System.out"].println(b[0+1]) ) else (     OclFile["System.out"].println((b[0+1] - b[1+1]) / 3 + b[1+1]) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=s.nextInt();
    int one=0,two=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]==1)one++;
      else two++;
    }
    int c=0 ;
    if(one>=two){
      c=two ;
      c+=(one-two)/3 ;
    }
    else {
      c=one ;
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var one : int ; one := 0 ;
    var two : int ; two := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = 1) then     one := one + 1 ; else     two := two + 1 ; )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
    if (one >= two) then (     c := two ; 
     c := c+((one - two) / 3) ) else (     c := one ) ;  
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc ;
  public static void main(String[] args){
    sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    long[] H=new long[N];
    for(int i=0 ; i<N ; i++){
      H[i]=sc.nextLong();
    }
    if(N==K){
      System.out.println("0");
      return ;
    }
    long[][] dp=new long[N][N-K+1];
    for(int i=0 ; i<N ; i++){
      dp[i][0]=0 ;
      dp[i][1]=H[i];
    }
    for(int l=2 ; l<=N-K ; l++){
      for(int k=0 ; k<N ; k++){
        if(k+1>=l){
          long min=-1 ;
          for(int i=0 ; i<k ; i++){
            if(dp[i][l-1]!=-1){
              long tmp=dp[i][l-1]+Math.max(0,H[k]-H[i]);
              if(min==-1 || tmp<min){
                min=tmp ;
              }
            }
          }
          dp[k][l]=min ;
        }
        else {
          dp[k][l]=-1 ;
        }
      }
    }
    long result=-1 ;
    for(int i=(N-K)-1 ; i<N ; i++){
      if(result==-1 || dp[i][N-K]<result){
        result=dp[i][N-K];
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var H : Sequence(long) ; H := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     H[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    if (N = K) then (     OclFile["System.out"].println("0") ; 
     return ) else skip ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,N)->collect(Integer.subrange(1,N - K + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     dp[i+1][0+1] := 0 ; 
     dp[i+1][1+1] := H[i+1] )  ;     i := i + 1 ) ; 
        var l : int ; l := 2 ; while l <= N - K do ( (         var k : int ; k := 0 ; while k < N do ( (     if (k + 1 >= l) then (     var min : long ; min := -1 ;
         var i : int ; i := 0 ; while i < k do ( (     if (dp[i+1][l - 1+1] /= -1) then (     var tmp : long ; tmp := dp[i+1][l - 1+1] + Set{0, H[k+1] - H[i+1]}->max() ;
     if (min = -1 or tmp < min) then (     min := tmp ) else skip ) else skip )  ;     i := i + 1 ) ; 
     dp[k+1][l+1] := min ) else (     dp[k+1][l+1] := -1 ) )  ;     k := k + 1 ) )  ;     l := l + 1 ) ; 
    var result : long ; result := -1 ;
        var i : int ; i := (N - K) - 1 ; while i < N do ( (     if (result = -1 or dp[i+1][N - K+1] < result) then (     result := dp[i+1][N - K+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int K=scanner.nextInt();
    int[] h=new int[N+1];
    for(int i=1 ; i<=N ; i++)h[i]=scanner.nextInt();
    long[][] dp=new long[N+1][N+1];
    final long INF=1_000_000_000_000L ;
    for(int i=0 ; i<=N ; i++)for(int j=0 ; j<=N ; j++)dp[i][j]=INF ;
    dp[0][0]=0 ;
    for(int i=1 ; i<=N ; i++){
      for(int j=1 ; j<=i ; j++){
        for(int k=0 ; k<i ; k++)dp[i][j]=Math.min(dp[i][j],dp[k][j-1]+Math.max(h[i]-h[k],0));
      }
    }
    long min=INF ;
    for(int i=0 ; i<=N ; i++)min=Math.min(min,dp[i][N-K]);
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var K : int ; K := scanner.getCurrent()->toInteger() ;
    var h : Sequence(int) ; h := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do (     h[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
    var INF : long ; INF := 1_000_000_000_000L ;
        var i : int ; i := 0 ; while i <= N do (         var j : int ; j := 0 ; while j <= N do (     dp[i+1][j+1] := INF ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := 1 ; while j <= i do ( (         var k : int ; k := 0 ; while k < i do (     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[k+1][j - 1+1] + Set{h[i+1] - h[k+1], 0}->max()}->min() ;  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var min : long ; min := INF ;
        var i : int ; i := 0 ; while i <= N do (     min := Set{min, dp[i+1][N - K+1]}->min() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  Scanner sc ;
  int N,K ;
  int[] H ;
  long[][] dp ;
  long[] s ;
  private void calc(){
    sc=new Scanner(System.in);
    N=sc.nextInt();
    K=sc.nextInt();
    H=new int[N+2];
    s=new long[N+2];
    for(int i=1 ; i<N+1 ; i++){
      H[i]=sc.nextInt();
      s[i]=s[i-1]+Math.abs(H[i-1]-H[i]);
    }
    s[N+1]=s[N]+Math.abs(H[N]-H[N+1]);
    dp=new long[N+2][K+1];
    for(int i=0 ; i<N+2 ; i++){
      for(int k=0 ; k<K+1 ; k++){
        int lp=Math.min(K,Math.min(N-i,K-k));
        for(int c=0 ; c<=lp ; c++){
          long d=s[i+c+1]-s[i]-Math.abs(H[i]-H[i+c+1]);
          dp[i+c+1][k+c]=Math.max(dp[i+c+1][k+c],dp[i][k]+d);
        }
      }
    }
    System.out.println(s[N+1]/2-dp[N+1][K]/2);
  }
  public static void main(String[] args){
    new Main().calc();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute N : int;
   attribute H : Sequence(int);
   attribute dp : Sequence(Sequence(long));
   attribute s : Sequence(long);
   operation calc() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     N := sc.getCurrent()->toInteger() ; 
    K := sc.getCurrent()->toInteger() ; 
    H := Integer.subrange(1,N + 2)->collect(0) ; 
    s := Integer.subrange(1,N + 2)->collect(0) ; 
        var i : int ; i := 1 ; while i < N + 1 do ( (     H[i+1] := sc.getCurrent()->toInteger() ; 
     s[i+1] := s[i - 1+1] + if H[i - 1+1] - H[i+1] < 0 then -(H[i - 1+1] - H[i+1]) else H[i - 1+1] - H[i+1] endif )  ;     i := i + 1 ) ; 
    s[N + 1+1] := s[N+1] + if H[N+1] - H[N + 1+1] < 0 then -(H[N+1] - H[N + 1+1]) else H[N+1] - H[N + 1+1] endif ; 
    dp := Integer.subrange(1,N + 2)->collect(Integer.subrange(1,K + 1)->collect(0)) ; 
        var i : int ; i := 0 ; while i < N + 2 do ( (         var k : int ; k := 0 ; while k < K + 1 do ( (     var lp : int ; lp := Set{K, Set{N - i, K - k}->min()}->min() ;
         var c : int ; c := 0 ; while c <= lp do ( (     var d : long ; d := s[i + c + 1+1] - s[i+1] - if H[i+1] - H[i + c + 1+1] < 0 then -(H[i+1] - H[i + c + 1+1]) else H[i+1] - H[i + c + 1+1] endif ;
     dp[i + c + 1+1][k + c+1] := Set{dp[i + c + 1+1][k + c+1], dp[i+1][k+1] + d}->max() )  ;     c := c + 1 ) )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s[N + 1+1] / 2 - dp[N + 1+1][K+1] / 2) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().calc() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static long[][] dp ;
  static int[] arr ;
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    dp=new long[k+1][n+2];
    arr=new int[n+2];
    for(int i=1 ; i<=n ; i++){
      arr[i]=sc.nextInt();
    }
    System.out.println(dfw(k,n+1));
  }
  static long dfw(int count,int idx){
    if(idx<1){
      return 0 ;
    }
    if(dp[count][idx]!=0){
      return dp[count][idx];
    }
    long ans=Long.MAX_VALUE ;
    for(int i=0 ; i<=count && i<=idx-1 ; i++){
      ans=Math.min(ans,dfw(count-i,idx-1-i)+Math.max(0,arr[idx]-arr[idx-1-i]));
    }
    dp[count][idx]=ans ;
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dp : Sequence(Sequence(long));
  static   attribute arr : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    dp := Integer.subrange(1,k + 1)->collect(Integer.subrange(1,n + 2)->collect(0)) ; 
    arr := Integer.subrange(1,n + 2)->collect(0) ; 
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dfw(k, n + 1)) ; 
 );
  static   operation dfw( count : int, idx : int) : long
  pre: true
  post: true
  activity: (     if (idx < 1) then (     return 0 ) else skip ; 
     if (dp[count+1][idx+1] /= 0) then (     return dp[count+1][idx+1] ) else skip ; 
    var ans : long ; ans := "9223372036854775807"->toLong() ;
        var i : int ; i := 0 ; while i <= count & i <= idx - 1 do ( (     ans := Set{ans, dfw(count - i, idx - 1 - i) + Set{0, arr[idx+1] - arr[idx - 1 - i+1]}->max()}->min() )  ;     i := i + 1 ) ; 
    dp[count+1][idx+1] := ans ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int K=scanner.nextInt();
    int[] h=new int[N+1];
    for(int i=1 ; i<=N ; i++)h[i]=scanner.nextInt();
    long[][] dp=new long[N+1][N+1];
    final long INF=1_000_000_000_000L ;
    for(int i=0 ; i<=N ; i++)for(int j=0 ; j<=N ; j++)dp[i][j]=INF ;
    dp[0][0]=0 ;
    for(int i=1 ; i<=N ; i++){
      for(int j=1 ; j<=i ; j++){
        for(int k=0 ; k<i ; k++)dp[i][j]=Math.min(dp[i][j],dp[k][j-1]+Math.max(h[i]-h[k],0));
      }
    }
    long min=INF ;
    for(int i=0 ; i<=N ; i++)for(int j=N-K ; j<=N ; j++)min=Math.min(min,dp[i][j]);
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var K : int ; K := scanner.getCurrent()->toInteger() ;
    var h : Sequence(int) ; h := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do (     h[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
    var INF : long ; INF := 1_000_000_000_000L ;
        var i : int ; i := 0 ; while i <= N do (         var j : int ; j := 0 ; while j <= N do (     dp[i+1][j+1] := INF ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := 1 ; while j <= i do ( (         var k : int ; k := 0 ; while k < i do (     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[k+1][j - 1+1] + Set{h[i+1] - h[k+1], 0}->max()}->min() ;  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var min : long ; min := INF ;
        var i : int ; i := 0 ; while i <= N do (         var j : int ; j := N - K ; while j <= N do (     min := Set{min, dp[i+1][j+1]}->min() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    double[] a=new double[n];
    int[] b=new int[n];
    double[] c=new double[n];
    Arrays.setAll(a,i->sc.nextInt());
    Arrays.setAll(b,i->sc.nextInt());
    Arrays.setAll(c,i->sc.nextInt());
    Arrays.sort(a);
    Arrays.sort(b);
    Arrays.sort(c);
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      int idxA=~ Arrays.binarySearch(a,b[i]-0.1);
      if(idxA<0)continue ;
      long numA=idxA ;
      int idxC=~ Arrays.binarySearch(c,b[i]+0.1);
      if(idxC<0)continue ;
      long numC=n-idxC ;
      ans+=numA*numC ;
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(double) ; a := Integer.subrange(1,n)->collect(0.0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(double) ; c := Integer.subrange(1,n)->collect(0.0) ;
setAll(a, lambda i : OclAny in sc.getCurrent()->toInteger()) ; 
setAll(b, lambda i : OclAny in sc.getCurrent()->toInteger()) ; 
setAll(c, lambda i : OclAny in sc.getCurrent()->toInteger()) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    c := c->sort() ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var idxA : int ; idxA := -((a->indexOf(b[i+1] - 0.1) - 1) + 1) ;
     if (idxA < 0) then     continue else skip ; 
    var numA : long ; numA := idxA ;
    var idxC : int ; idxC := -((c->indexOf(b[i+1] + 0.1) - 1) + 1) ;
    if (idxC < 0) then     continue else skip ; 
    var numC : long ; numC := n - idxC ;
    ans := ans+(numA * numC) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String str=scan.next();
    int num_1=Integer.parseInt(str);
    str=scan.next();
    int num_2=Integer.parseInt(str);
    str=scan.next();
    int num_3=Integer.parseInt(str);
    if(num_1==7){
      if(num_2==5 && num_3==5){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    else if(num_2==7){
      if(num_1==5 && num_3==5){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    else if(num_3==7){
      if(num_2==5 && num_1==5){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := scan.getCurrent() ;
    var num    var numint : String ; numint := (str)->toInteger() : int ; num    var numint : String ; numint := (str)->toInteger() := (str)->toInteger() ;
    str := scan.getCurrent() ; 
    var num(str)->toInteger() : int ; num(str)->toInteger() := (str)->toInteger() ;
    str := scan.getCurrent() ; 
    var num_3 : int ; num_3 := (str)->toInteger() ;
    if (num_1 = 7) then (     if (num5 = 5 & num(     OclFile["System.out"].println("NO") ) = 5) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else     if (num7 = 7) then (     if (num    if (num    if (num(num7 = 7) = 5 & num(     OclFile["System.out"].println("NO") ) = 5) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 = 5 & num(     OclFile["System.out"].println("NO") ) = 5) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  = 5 & num(     OclFile["System.out"].println("NO") ) = 5) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else     if (num_3 = 7) then (     if (num5 = 5 & num    if (num5 = 5 & num    if (num5 = 5 & num_1 = 5) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 = 5) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  = 5) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else skip ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CSnukeFestival solver=new CSnukeFestival();
    solver.solve(1,in,out);
    out.close();
  }
  static class CSnukeFestival {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int[] a=new int[n];
      int[] b=new int[n];
      int[] c=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=in.nextInt();
      for(int i=0 ; i<n ; i++)b[i]=in.nextInt();
      for(int i=0 ; i<n ; i++)c[i]=in.nextInt();
      Arrays.sort(a);
      Arrays.sort(b);
      Arrays.sort(c);
      long sum=0 ;
      for(int i=0 ; i<n ; i++){
        int ng=-1 ;
        int ok=a.length ;
        while(Math.abs(ok-ng)>1){
          int mid=(ok+ng)/2 ;
          if(a[mid]>=b[i]){
            ok=mid ;
          }
          else {
            ng=mid ;
          }
        }
        long cnta=ok ;
        ng=-1 ;
        ok=c.length ;
        while(Math.abs(ok-ng)>1){
          int mid=(ok+ng)/2 ;
          if(c[mid]>b[i]){
            ok=mid ;
          }
          else {
            ng=mid ;
          }
        }
        long cntc=n-1-ng ;
        sum+=cnta*cntc ;
      }
      out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CSnukeFestival ; solver := CSnukeFestival.newCSnukeFestival() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CSnukeFestival {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     b[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     c[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    c := c->sort() ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var ng : int ; ng := -1 ;
     var ok : int ; ok := a->size() ;
    while (if ok - ng < 0 then -(ok - ng) else ok - ng endif > 1) do (     var mid : int ; mid := (ok + ng) / 2 ;
     if (a[mid+1] >= b[i+1]) then (     ok := mid ) else (     ng := mid ) ) ; 
    var cnta : long ; cnta := ok ;
    ng := -1 ; 
    ok := c->size() ; 
    while (if ok - ng < 0 then -(ok - ng) else ok - ng endif > 1) do (     var mid : int ; mid := (ok + ng) / 2 ;
     if (c[mid+1] > b[i+1]) then (     ok := mid ) else (     ng := mid ) ) ; 
    var cntc : long ; cntc := n - 1 - ng ;
    sum := sum+(cnta * cntc) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findSumofEle(int[] arr1,int m,int[] arr2,int n,int k){
    float arraySum=0 ;
    for(int i=0 ; i<n ; i++)arraySum+=arr2[i];
    float mean=arraySum/n ;
    int sumOfElements=0 ;
    float difference=0 ;
    for(int i=0 ; i<m ; i++){
      difference=arr1[i]-mean ;
      if((difference<0)&&(k>(-1)*difference)){
        sumOfElements+=arr1[i];
      }
      if((difference>=0)&&(k>difference)){
        sumOfElements+=arr1[i];
      }
    }
    return sumOfElements ;
  }
  public static void main(String[] args){
    int[] arr1={
      1,2,3,4,7,9 };
      int[] arr2={
        0,1,2,1,1,4 };
        int k=2 ;
        int m=arr1.length ;
        int n=arr2.length ;
        System.out.println(findSumofEle(arr1,m,arr2,n,k));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findSumofEle( arr1 : Sequence(int), m : int, arr2 : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var arraySum : double ; arraySum := 0 ;
         var i : int ; i := 0 ; while i < n do (     arraySum := arraySum+(arr2[i+1]) ;  ;     i := i + 1 ) ; 
    var mean : double ; mean := arraySum / n ;
    var sumOfElements : int ; sumOfElements := 0 ;
    var difference : double ; difference := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     difference := arr1[i+1] - mean ; 
     if ((difference < 0) & (k > (-1) * difference)) then (     sumOfElements := sumOfElements+(arr1[i+1]) ) else skip ; 
     if ((difference >= 0) & (k > difference)) then (     sumOfElements := sumOfElements+(arr1[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    return sumOfElements 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{1,2,3,4,7,9} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{0,1,2,1,1,4} ;
    var k : int ; k := 2 ;
    var m : int ; m := arr1->size() ;
    var n : int ; n := arr2->size() ;
    OclFile["System.out"].println(findSumofEle(arr1, m, arr2, n, k)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  private static long lowerBound(long[] x,long bj){
    int leftIdx=-1 ;
    int rightIdx=x.length ;
    while(rightIdx-leftIdx>1){
      int middleIdx=(leftIdx+rightIdx)/2 ;
      if(bj<=x[middleIdx]){
        rightIdx=middleIdx ;
        continue ;
      }
      leftIdx=middleIdx ;
    }
    return rightIdx ;
  }
  private static long upperBound(long[] x,long bj){
    int leftIdx=-1 ;
    int rightIdx=x.length ;
    while(rightIdx-leftIdx>1){
      int middleIdx=(leftIdx+rightIdx)/2 ;
      if(bj<x[middleIdx]){
        rightIdx=middleIdx ;
        continue ;
      }
      leftIdx=middleIdx ;
    }
    return rightIdx ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] a=new long[n];
    long[] b=new long[n];
    long[] c=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
    }
    for(int i=0 ; i<n ; i++){
      b[i]=sc.nextLong();
    }
    for(int i=0 ; i<n ; i++){
      c[i]=sc.nextLong();
    }
    Arrays.sort(a);
    Arrays.sort(b);
    Arrays.sort(c);
    long count=0 ;
    for(int j=0 ; j<n ; j++){
      long bj=b[j];
      long aiCount=lowerBound(a,bj);
      long ckCount=n-upperBound(c,bj);
      count+=aiCount*ckCount ;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation lowerBound( x : Sequence(long), bj : long) : long
  pre: true
  post: true
  activity: (     var leftIdx : int ; leftIdx := -1 ;
     var rightIdx : int ; rightIdx := x->size() ;
     while (rightIdx - leftIdx > 1) do (     var middleIdx : int ; middleIdx := (leftIdx + rightIdx) / 2 ;
     if (bj <= x[middleIdx+1]) then (     rightIdx := middleIdx ; 
     continue ) else skip ; 
     leftIdx := middleIdx ) ; 
     return rightIdx );
  static   operation upperBound( x : Sequence(long), bj : long) : long
  pre: true
  post: true
  activity: (     var leftIdx : int ; leftIdx := -1 ;
     var rightIdx : int ; rightIdx := x->size() ;
     while (rightIdx - leftIdx > 1) do (     var middleIdx : int ; middleIdx := (leftIdx + rightIdx) / 2 ;
     if (bj < x[middleIdx+1]) then (     rightIdx := middleIdx ; 
     continue ) else skip ; 
     leftIdx := middleIdx ) ; 
     return rightIdx );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(long) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    c := c->sort() ; 
    var count : long ; count := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     var bj : long ; bj := b[j+1] ;
     var aiCount : long ; aiCount := lowerBound(a, bj) ;
     var ckCount : long ; ckCount := n - upperBound(c, bj) ;
     count := count+(aiCount * ckCount) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      Integer[] a=new Integer[n],b=new Integer[n],c=new Integer[n];
      IntStream.range(0,n).forEach(i->a[i]=scanner.nextInt());
      IntStream.range(0,n).forEach(i->b[i]=scanner.nextInt());
      IntStream.range(0,n).forEach(i->c[i]=scanner.nextInt());
      Arrays.sort(a);
      Arrays.sort(c);
      System.out.println(IntStream.range(0,n).mapToLong(i->getLessCount(b[i],a)*getGreaterCount(b[i],c)).sum());
    }
  }
  private static long getLessCount(int i,Integer[] a){
    int result=Arrays.binarySearch(a,i,(x,y)->(x.compareTo(y)>=0)? 1 :-1);
    if(result<0){
      result=~ result ;
    }
    return result ;
  }
  private static long getGreaterCount(int i,Integer[] a){
    int result=Arrays.binarySearch(a,i,(x,y)->(x.compareTo(y)>0)? 1 :-1);
    if(result<0){
      result=~ result ;
    }
    return a.length-result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(null) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(null) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(null) ;
    for i : Integer.subrange(0, n-1) do
    (    a[i+1] := scanner.getCurrent()->toInteger()) ; 
    for i : Integer.subrange(0, n-1) do
    (    b[i+1] := scanner.getCurrent()->toInteger()) ; 
    for i : Integer.subrange(0, n-1) do
    (    c[i+1] := scanner.getCurrent()->toInteger()) ; 
    a := a->sort() ; 
    c := c->sort() ; 
    OclFile["System.out"].println(Integer.subrange(0, n-1)->collect( _x1 | (lambda i : OclAny in getLessCount(b[i+1], a) * getGreaterCount(b[i+1], c))->apply(_x1) )->sum()) ; 
 ))  );
  static   operation getLessCount( i : int, a : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var result : int ; result := (a->indexOf(lambda (x , y) : OclAny in if (x->compareTo(y) >= 0) then 1 else -1 endif) - 1) ;
     if (result < 0) then (     result := -(result + 1) ) else skip ; 
     return result );
  static   operation getGreaterCount( i : int, a : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var result : int ; result := (a->indexOf(lambda (x , y) : OclAny in if (x->compareTo(y) > 0) then 1 else -1 endif) - 1) ;
     if (result < 0) then (     result := -(result + 1) ) else skip ; 
     return a->size() - result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().execute();
  }
  public void execute(){
    Scanner sc=new Scanner(System.in);
    final int N=sc.nextInt();
    sc.nextLine();
    int A[]=new int[N];
    int B[]=new int[N];
    int C[]=new int[N];
    String[] a1An=sc.nextLine().split(" ");
    String[] b1Bn=sc.nextLine().split(" ");
    String[] c1Cn=sc.nextLine().split(" ");
    for(int i=0 ; i<N ; i++){
      A[i]=Integer.parseInt(a1An[i]);
      B[i]=Integer.parseInt(b1Bn[i]);
      C[i]=Integer.parseInt(c1Cn[i]);
    }
    Arrays.sort(A);
    Arrays.sort(B);
    Arrays.sort(C);
    long[] cntB=new long[N];
    int aIx=0 ;
    for(int i=0 ; i<N ; i++){
      int b=B[i];
      while(aIx<A.length && A[aIx]<b){
        aIx++;
      }
      cntB[i]=aIx ;
    }
    long[] cntC=new long[N];
    int bIx=0 ;
    long total=0 ;
    for(int i=0 ; i<N ; i++){
      int c=C[i];
      long subTotal=(i==0)? 0 : cntC[i-1];
      while(bIx<B.length && B[bIx]<c){
        subTotal+=cntB[bIx];
        bIx++;
      }
      cntC[i]=subTotal ;
      total+=subTotal ;
    }
    System.out.println(total);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().execute() );
   operation execute() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    skip ; 
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,N)->collect(0) ;
    var C : Sequence(int) ; C := Integer.subrange(1,N)->collect(0) ;
    var a1An : Sequence(String) ; a1An := sc.nextLine()->split(" ") ;
    var b1Bn : Sequence(String) ; b1Bn := sc.nextLine()->split(" ") ;
    var c1Cn : Sequence(String) ; c1Cn := sc.nextLine()->split(" ") ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := (a1An[i+1])->toInteger() ; 
     B[i+1] := (b1Bn[i+1])->toInteger() ; 
     C[i+1] := (c1Cn[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    B := B->sort() ; 
    C := C->sort() ; 
    var cntB : Sequence(long) ; cntB := Integer.subrange(1,N)->collect(0) ;
    var aIx : int ; aIx := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var b : int ; b := B[i+1] ;
     while (aIx < A->size() & A[aIx+1] < b) do (     aIx := aIx + 1 ) ; 
     cntB[i+1] := aIx )  ;     i := i + 1 ) ; 
    var cntC : Sequence(long) ; cntC := Integer.subrange(1,N)->collect(0) ;
    var bIx : int ; bIx := 0 ;
    var total : long ; total := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var c : int ; c := C[i+1] ;
     var subTotal : long ; subTotal := if (i = 0) then 0 else cntC[i - 1+1] endif ;
    while (bIx < B->size() & B[bIx+1] < c) do (     subTotal := subTotal+(cntB[bIx+1]) ; 
     bIx := bIx + 1 ) ; 
    cntC[i+1] := subTotal ; 
    total := total+(subTotal) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double calculate_angle(int n,int i,int j,int k){
    int x,y ;
    if(i<j)x=j-i ;
    else x=j+n-i ;
    if(j<k)y=k-j ;
    else y=k+n-j ;
    double ang1=(180*x)/n ;
    double ang2=(180*y)/n ;
    double ans=180-ang1-ang2 ;
    return ans ;
  }
  public static void main(String[] args){
    int n=5 ;
    int a1=1 ;
    int a2=2 ;
    int a3=5 ;
    System.out.println((int)calculate_angle(n,a1,a2,a3));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation calculate_angle( n : int, i : int, j : int, k : int) : double
  pre: true
  post: true
  activity: (     var x : int ;
    var y : int ;
     if (i < j) then     x := j - i else     x := j + n - i ; ;  
    if (j < k) then     y := k - j else     y := k + n - j ; ;  
    var ang1 : double ; ang1 := (180 * x) / n ;
    var ang2 : double ; ang2 := (180 * y) / n ;
    var ans : double ; ans := 180 - ang1 - ang2 ;
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var a1 : int ; a1 := 1 ;
    var a2 : int ; a2 := 2 ;
    var a3 : int ; a3 := 5 ;
    OclFile["System.out"].println(calculate_angle(n, a1, a2, a3)->oclAsType(int)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int solve(int[] arr,int n){
    int k=arr.length ;
    int mp[]=new int[n+2];
    for(int i=0 ; i<=n ; i++){
      mp[i]=0 ;
    }
    for(int i=0 ; i<k ; i++){
      mp[arr[i] ]=1 ;
    }
    int leftSegment=arr[0]-1 ;
    for(int i=1 ; i<k ; i++){
      leftSegment=Math.max(leftSegment,arr[i]-arr[i-1]-1);
    }
    int rightSegment=n-arr[k-1];
    int maxSegment=Math.max(leftSegment,rightSegment);
    int tim ;
    if((maxSegment & 1)==1)tim=(maxSegment/2)+1 ;
    else tim=maxSegment/2 ;
    return tim ;
  }
  public static void main(String[] args){
    int N=5 ;
    int arr[]={
      1,4 };
      System.out.println(solve(arr,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var k : int ; k := arr->size() ;
     var mp : Sequence(int) ; mp := Integer.subrange(1,n + 2)->collect(0) ;
        var i : int ; i := 0 ; while i <= n do ( (     mp[i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do ( (     mp[arr[i+1]+1] := 1 )  ;     i := i + 1 ) ; 
    var leftSegment : int ; leftSegment := arr[0+1] - 1 ;
        var i : int ; i := 1 ; while i < k do ( (     leftSegment := Set{leftSegment, arr[i+1] - arr[i - 1+1] - 1}->max() )  ;     i := i + 1 ) ; 
    var rightSegment : int ; rightSegment := n - arr[k - 1+1] ;
    var maxSegment : int ; maxSegment := Set{leftSegment, rightSegment}->max() ;
    var tim : int ;
    if ((MathLib.bitwiseAnd(maxSegment,1)) = 1) then     tim := (maxSegment / 2) + 1 else     tim := maxSegment / 2 ; ;  
    return tim 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     var arr : Sequence(int) ; arr := Sequence{1,4} ;
     OclFile["System.out"].println(solve(arr, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findCombinationsUtil(int arr[],int index,int n,int red_num){
    HashSet<Integer>s=new HashSet<>();
    int sum=0 ;
    if(red_num<0){
      return ;
    }
    if(red_num==0){
      for(int i=0 ; i<index ; i++){
        s.add(arr[i]);
      }
      for(Integer itr : s){
        sum=sum+itr ;
      }
      if(sum==n){
        for(Integer i : s){
          System.out.print(i+" ");
        }
        System.out.println();
        return ;
      }
    }
    int prev=(index==0)? 1 : arr[index-1];
    for(int k=prev ; k<=n ; k++){
      if(index<n){
        arr[index]=k ;
        findCombinationsUtil(arr,index+1,n,red_num-k);
      }
    }
  }
  static void findCombinations(int n){
    int[] a=new int[n];
    findCombinationsUtil(a,0,n,n);
  }
  public static void main(String arr[]){
    int n=7 ;
    findCombinations(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findCombinationsUtil( arr : Sequence(int), index : int, n : int, red_num : int) : void
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
     var sum : int ; sum := 0 ;
    if (red_num < 0) then (     return ) else skip ; 
    if (red_num = 0) then (         var i : int ; i := 0 ; while i < index do ( (     s := s->including(arr[i+1]) )  ;     i := i + 1 ) ; 
     for (itr : s) do ( (     sum := sum + itr )  ) ; 
     if (sum = n) then (     for (i : s) do ( (     OclFile["System.out"].print(i + " ") )  ) ; 
     OclFile["System.out"].println() ; 
     return ) else skip ) else skip ; 
    var prev : int ; prev := if (index = 0) then 1 else arr[index - 1+1] endif ;
        var k : int ; k := prev ; while k <= n do ( (     if (index < n) then (     arr[index+1] := k ; 
     execute findCombinationsUtil(arr, index + 1, n, red_num - k) ) else skip )  ;     k := k + 1 ) ; 
 );
  static   operation findCombinations( n : int) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
     execute findCombinationsUtil(a, 0, n, n) );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     execute findCombinations(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
import java.io.*;
public class codeHundredSixty {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=input.nextInt();
      int[] arrayOne=new int[n];
      for(int i=0 ; i<n ; i++){
        arrayOne[i]=input.nextInt();
      }
      Arrays.sort(arrayOne);
      if(arrayOne[0]<0){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
        System.out.println(101);
        for(int i=0 ; i<=100 ; i++){
          System.out.print(i+" ");
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var arrayOne : Sequence(int) ; arrayOne := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arrayOne[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arrayOne := arrayOne->sort() ; 
    if (arrayOne[0+1] < 0) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(101) ; 
         var i : int ; i := 0 ; while i <= 100 do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ;  
 )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
import java.io.*;
public class codeHundredSixty {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=input.nextInt();
      int[] arrayOne=new int[n];
      for(int i=0 ; i<n ; i++){
        arrayOne[i]=input.nextInt();
      }
      Arrays.sort(arrayOne);
      if(arrayOne[0]<0){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
        System.out.println(101);
        for(int i=0 ; i<=100 ; i++){
          System.out.print(i+" ");
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var arrayOne : Sequence(int) ; arrayOne := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arrayOne[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arrayOne := arrayOne->sort() ; 
    if (arrayOne[0+1] < 0) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(101) ; 
         var i : int ; i := 0 ; while i <= 100 do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ;  
 )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.Collectors ;
public class A1536 {
  public static void solve(List<Integer>input){
    for(int num : input){
      if(num<0){
        System.out.println("NO");
        return ;
      }
    }
    Set<Integer>set=new HashSet<>(input);
    for(int i=0 ; i<input.size(); i++){
      for(int j=0 ; j<input.size(); j++){
        if(input.size()>300){
          System.out.println("NO");
          return ;
        }
        if(i==j){
          continue ;
        }
        int dist=Math.abs(input.get(i)-input.get(j));
        if(! set.contains(dist)){
          set.add(dist);
          input.add(dist);
        }
      }
    }
    System.out.println("YES");
    System.out.println(input.size());
    System.out.println(input.stream().map(Object :: toString).collect(Collectors.joining(" ")));
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=scanner.nextInt();
      List<Integer>input=new ArrayList<>();
      for(int j=0 ; j<n ; j++){
        input.add(scanner.nextInt());
      }
      solve(input);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1536 {
  static   operation solve( input : Sequence(int)) : void
  pre: true
  post: true
  activity: (     for (num : input) do ( (     if (num < 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ) ; 
     var set : Set(int) ; set := Set{}->union(input) ;
        var i : int ; i := 0 ; while i < input->size() do ( (         var j : int ; j := 0 ; while j < input->size() do ( (     if (input->size() > 300) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
     if (i = j) then (     continue ) else skip ; 
     var dist : int ; dist := if input->at(i+1) - input->at(j+1) < 0 then -(input->at(i+1) - input->at(j+1)) else input->at(i+1) - input->at(j+1) endif ;
     if (not(set->includes(dist))) then (     set := set->including(dist) ; 
     input->excludes(dist) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
    OclFile["System.out"].println(input->size()) ; 
    OclFile["System.out"].println(input->collect( _x1 | (lambda _pars : OclAny in Object.newObject().toString(_pars))->apply(_x1) ).collect(Collectors.joining(" "))) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var input : Sequence(int) ; input := Sequence{} ;
         var j : int ; j := 0 ; while j < n do ( (     input := input->including(scanner.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
     execute solve(input) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.Collectors ;
public class A1536 {
  public static void solve(List<Integer>input){
    Set<Integer>set=new HashSet<>(input);
    for(int i=0 ; i<input.size(); i++){
      for(int j=0 ; j<input.size(); j++){
        if(input.size()>300){
          System.out.println("NO");
          return ;
        }
        if(i==j){
          continue ;
        }
        int dist=Math.abs(input.get(i)-input.get(j));
        if(! set.contains(dist)){
          set.add(dist);
          input.add(dist);
        }
      }
    }
    System.out.println("YES");
    System.out.println(input.size());
    System.out.println(input.stream().map(Object :: toString).collect(Collectors.joining(" ")));
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=scanner.nextInt();
      List<Integer>input=new ArrayList<>();
      for(int j=0 ; j<n ; j++){
        input.add(scanner.nextInt());
      }
      solve(input);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1536 {
  static   operation solve( input : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var set : Set(int) ; set := Set{}->union(input) ;
         var i : int ; i := 0 ; while i < input->size() do ( (         var j : int ; j := 0 ; while j < input->size() do ( (     if (input->size() > 300) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
     if (i = j) then (     continue ) else skip ; 
     var dist : int ; dist := if input->at(i+1) - input->at(j+1) < 0 then -(input->at(i+1) - input->at(j+1)) else input->at(i+1) - input->at(j+1) endif ;
     if (not(set->includes(dist))) then (     set := set->including(dist) ; 
     input->excludes(dist) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
    OclFile["System.out"].println(input->size()) ; 
    OclFile["System.out"].println(input->collect( _x1 | (lambda _pars : OclAny in Object.newObject().toString(_pars))->apply(_x1) ).collect(Collectors.joining(" "))) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var input : Sequence(int) ; input := Sequence{} ;
         var j : int ; j := 0 ; while j < n do ( (     input := input->including(scanner.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
     execute solve(input) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int CountWays(int n,boolean flag){
    if(n==0)return 1 ;
    int sum=0 ;
    if(flag==false && n>1)sum=sum+CountWays(n-1,false)+CountWays(n-2,true);
    else sum=sum+CountWays(n-1,false);
    return sum ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(CountWays(n,false));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation CountWays( n : int, flag : boolean) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     var sum : int ; sum := 0 ;
     if (flag = false & n > 1) then     sum := sum + CountWays(n - 1, false) + CountWays(n - 2, true) else     sum := sum + CountWays(n - 1, false) ; ;  
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(CountWays(n, false)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
class GFG {
  static int KthMinValAfterMconcatenate(int[] A,int N,int M,int K){
    ArrayList V=new ArrayList();
    for(int i=0 ; i<M ; i++){
      for(int j=0 ; j<N ; j++){
        V.add(A[j]);
      }
    }
    Collections.sort(V);
    return((int)V.get(K-1));
  }
  public static void main(String[] args){
    int[] A={
      3,1,2 };
      int M=3,K=4 ;
      int N=A.length ;
      System.out.println(KthMinValAfterMconcatenate(A,N,M,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation KthMinValAfterMconcatenate( A : Sequence(int), N : int, M : int, K : int) : int
  pre: true
  post: true
  activity: (     var V : Sequence ; V := Sequence{} ;
         var i : int ; i := 0 ; while i < M do ( (         var j : int ; j := 0 ; while j < N do ( (     V := V->including(A[j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     V := V->sort() ; 
     return (V->at(K - 1+1)->oclAsType(int)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{3,1,2} ;
     var M : int ; M := 3 ;
    var K : int ; K := 4 ;
     var N : int ; N := A->size() ;
     OclFile["System.out"].println(KthMinValAfterMconcatenate(A, N, M, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayDeque ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  private static BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  private static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int start=sc.nextInt();
    int target=sc.nextInt();
    boolean[] vis=new boolean[20005];
    Queue<Integer>queue=new ArrayDeque<>();
    queue.offer(start);
    vis[start]=true ;
    int step=0 ;
    a : while(! queue.isEmpty()){
      int n=queue.size();
      for(int i=0 ; i<n ; i++){
        int poll=queue.poll();
        if(poll==target){
          break a ;
        }
        if(poll*2<20005 && ! vis[poll*2]){
          vis[poll*2]=true ;
          queue.offer(poll*2);
        }
        if(poll-1>0 && ! vis[poll-1]){
          vis[poll-1]=true ;
          queue.offer(poll-1);
        }
      }
      step++;
    }
    System.out.println(step);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : int ; start := sc.getCurrent()->toInteger() ;
     var target : int ; target := sc.getCurrent()->toInteger() ;
    var vis : Sequence(boolean) ; vis := Integer.subrange(1,20005)->collect(false) ;
    var queue : Sequence(int) ; queue := ArrayDeque<OclAny>.newArrayDeque() ;
    queue := queue->including(start) ; 
    vis[start+1] := true ; 
    var step : int ; step := 0 ;
    while (not(queue->isEmpty())) do (     var n : int ; n := queue->size() ;
         var i : int ; i := 0 ; while i < n do ( (     var poll : int ; poll := queue->min() ;
     if (poll = target) then (     break ) else skip ; 
     if (poll * 2 < 20005 & not(vis[poll * 2+1])) then (     vis[poll * 2+1] := true ; 
     queue := queue->including(poll * 2) ) else skip ; 
     if (poll - 1 > 0 & not(vis[poll - 1+1])) then (     vis[poll - 1+1] := true ; 
     queue := queue->including(poll - 1) ) else skip )  ;     i := i + 1 ) ; 
     step := step + 1 ) ; 
    OclFile["System.out"].println(step) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextInt(),m=sc.nextInt();
    if(n>=m)System.out.println(n-m);
    else {
      int res=0 ;
      while(n<m){
        if(m % 2!=0)m++;
        else m/=2 ;
        res++;
      }
      System.out.println(res+n-m);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toInteger() ;
    var m : long ; m := sc.getCurrent()->toInteger() ;
     if (n >= m) then     OclFile["System.out"].println(n - m) ; else (     var res : int ; res := 0 ;
     while (n < m) do (     if (m mod 2 /= 0) then     m := m + 1 else     m := m/(2) ; ;  
     res := res + 1 ) ; 
     OclFile["System.out"].println(res + n - m) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static int minClicks(int n,int m){
    int clicks=0 ;
    while(m>n){
      if(m % 2==0){
        m/=2 ;
        clicks++;
      }
      else {
        m++;
        m/=2 ;
        clicks+=2 ;
      }
    }
    while(m!=n){
      m++;
      clicks++;
    }
    return clicks ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    String[] input=bufferedReader.readLine().split(" ");
    System.out.println(minClicks(Integer.parseInt(input[0]),Integer.parseInt(input[1])));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation minClicks( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var clicks : int ; clicks := 0 ;
     while (m > n) do (     if (m mod 2 = 0) then (     m := m/(2) ; 
     clicks := clicks + 1 ) else (     m := m + 1 ; 
     m := m/(2) ; 
     clicks := clicks+(2) ) ) ; 
     while (m /= n) do (     m := m + 1 ; 
     clicks := clicks + 1 ) ; 
     return clicks );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : Sequence(String) ; input := bufferedReader.readLine()->split(" ") ;
     OclFile["System.out"].println(minClicks((input[0+1])->toInteger(), (input[1+1])->toInteger())) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int sum=0 ;
    while(b>a){
      if(b % 2==0){
        b/=2 ;
        sum++;
      }
      else {
        b+=1 ;
        sum++;
      }
    }
    System.out.println(sum+(a-b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    while (b > a) do (     if (b mod 2 = 0) then (     b := b/(2) ; 
     sum := sum + 1 ) else (     b := b+(1) ; 
     sum := sum + 1 ) ) ; 
    OclFile["System.out"].println(sum + (a - b)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  private static BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  private static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int target=sc.nextInt();
    int start=sc.nextInt();
    int step=0 ;
    while(true){
      if(target>=start){
        step+=target-start ;
        break ;
      }
      else {
        if(start % 2==0){
          start/=2 ;
          step++;
        }
        else {
          start++;
          step++;
        }
        if(start==target)break ;
      }
    }
    System.out.println(step);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var target : int ; target := sc.getCurrent()->toInteger() ;
     var start : int ; start := sc.getCurrent()->toInteger() ;
    var step : int ; step := 0 ;
    while (true) do (     if (target >= start) then (     step := step+(target - start) ; 
     break ) else (     if (start mod 2 = 0) then (     start := start/(2) ; 
     step := step + 1 ) else (     start := start + 1 ; 
     step := step + 1 ) ;  
     if (start = target) then     break else skip ) ) ; 
    OclFile["System.out"].println(step) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int numberOfSolutions(int n){
    int c=0 ;
    while(n>0){
      c+=n % 2 ;
      n/=2 ;
    }
    return(int)Math.pow(2,c);
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(numberOfSolutions(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation numberOfSolutions( n : int) : int
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
     while (n > 0) do (     c := c+(n mod 2) ; 
     n := n/(2) ) ; 
     return 2->pow(c)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(numberOfSolutions(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    int e=sc.nextInt();
    int f=sc.nextInt();
    Dice dice=new Dice(a,b,c,d,e,f);
    String cmd=sc.next();
    for(int i=0 ; i<cmd.length(); i++){
      switch(cmd.charAt(i)){
        case 'N' : dice=dice.rollToN();
        break ;
        case 'S' : dice=dice.rollToS();
        break ;
        case 'W' : dice=dice.rollToW();
        break ;
        case 'E' : dice=dice.rollToE();
        break ;
      }
    }
    System.out.println(dice.getTop());
  }
  private static class Dice {
    private int t ;
    private int s ;
    private int e ;
    private int w ;
    private int n ;
    private int b ;
    public Dice(int t,int s,int e,int w,int n,int b){
      this.t=t ;
      this.s=s ;
      this.e=e ;
      this.w=w ;
      this.n=n ;
      this.b=b ;
    }
    public Dice rollToN(){
      return new Dice(s,b,e,w,t,n);
    }
    public Dice rollToS(){
      return new Dice(n,t,e,w,b,s);
    }
    public Dice rollToW(){
      return new Dice(e,s,b,t,n,w);
    }
    public Dice rollToE(){
      return new Dice(w,s,t,b,n,e);
    }
    public int getTop(){
      return t ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var e : int ; e := sc.getCurrent()->toInteger() ;
    var f : int ; f := sc.getCurrent()->toInteger() ;
    var dice : Dice ; dice := Dice.newDice(a, b, c, d, e, f) ;
    var cmd : String ; cmd := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < cmd->size() do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (cmd->at(i+1)) ; 
       if _switchval = 'N' then
     dice := dice.rollToN() ; 
    break 
   else skip ;
       if _switchval = 'S' then
     dice := dice.rollToS() ; 
    break 
   else skip ;
       if _switchval = 'W' then
     dice := dice.rollToW() ; 
    break 
   else skip ;
       if _switchval = 'E' then
     dice := dice.rollToE() ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dice.getTop()) ; 
 );
  static class Dice {
   attribute t : int;
   attribute s : int;
   attribute e : int;
   attribute w : int;
   attribute n : int;
   attribute b : int;
   static operation newDice( t : int, s : int, e : int, w : int, n : int, b : int) : Dice
  pre: true
  post: true
  activity:
  ( var self : Dice ;
    self := createDice();
    self.initialise(t, s,e,w,n,b);
    return self );
  operation initialise( t : int, s : int, e : int, w : int, n : int, b : int) : void
  pre: true  post: true
  activity: (     self.t := t ; 
     self.s := s ; 
    self.e := e ; 
    self.w := w ; 
    self.n := n ; 
    self.b := b ; 
 );
   operation rollToN() : Dice
  pre: true
  post: true
  activity: (     return Dice.newDice(s, b, e, w, t, n) );
   operation rollToS() : Dice
  pre: true
  post: true
  activity: (     return Dice.newDice(n, t, e, w, b, s) );
   operation rollToW() : Dice
  pre: true
  post: true
  activity: (     return Dice.newDice(e, s, b, t, n, w) );
   operation rollToE() : Dice
  pre: true
  post: true
  activity: (     return Dice.newDice(w, s, t, b, n, e) );
   operation getTop() : int
  pre: true
  post: true
  activity: (     return t );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedOutputStream ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Map ;
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
import java.util.TreeMap ;
public class Practice1 {
  public static void main(String[] args){
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    int x=sc.nextInt();
    long[] arr=new long[n];
    long sum=n-1 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextLong();
      sum+=arr[i];
    }
    if(x==sum){
      out.println("YES");
    }
    else {
      out.println("NO");
    }
    out.close();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var sc : FastReader ; sc := FastReader.newFastReader() ;
    var n : int ; n := sc.nextInt() ;
    var x : int ; x := sc.nextInt() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := n - 1 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.nextLong() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    if (x = sum) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JapaneseCrosswordSrikesBack {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long n=in.nextLong();
    long x=in.nextLong();
    long[] a=new long[(int)n];
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextLong();
      sum+=a[i];
    }
    if(x-sum-n+1==0)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class JapaneseCrosswordSrikesBack {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toLong() ;
    var x : long ; x := in.getCurrent()->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n->oclAsType(int))->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toLong() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    if (x - sum - n + 1 = 0) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long n=in.nextLong(),x=in.nextLong();
    long[] a=new long[(int)n];
    Arrays.setAll(a,i->in.nextLong());
    long totoal=0 ;
    for(int i=0 ; i<n-1 ; i++){
      totoal+=(a[i]+1);
    }
    totoal+=a[(int)n-1];
    if(totoal==x)pw.println("YES");
    else pw.println("NO");
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := in.getCurrent()->toLong() ;
    var x : long ; x := in.getCurrent()->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n->oclAsType(int))->collect(0) ;
setAll(a, lambda i : OclAny in in.getCurrent()->toLong()) ; 
    var totoal : long ; totoal := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     totoal := totoal+((a[i+1] + 1)) )  ;     i := i + 1 ) ; 
    totoal := totoal+(a[n->oclAsType(int) - 1+1]) ; 
    if (totoal = x) then     skip else     skip ; ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  static int MaxSumDifference(Integer[] a,int n){
    List<Integer>finalSequence=new ArrayList<Integer>();
    Arrays.sort(a);
    for(int i=0 ; i<n/2 ; ++i){
      finalSequence.add(a[i]);
      finalSequence.add(a[n-i-1]);
    }
    if(n % 2!=0)finalSequence.add(a[n/2]);
    int MaximumSum=0 ;
    for(int i=0 ; i<n-1 ; ++i){
      MaximumSum=MaximumSum+Math.abs(finalSequence.get(i)-finalSequence.get(i+1));
    }
    MaximumSum=MaximumSum+Math.abs(finalSequence.get(n-1)-finalSequence.get(0));
    return MaximumSum ;
  }
  public static void main(String args[]){
    Integer[] a={
      1,2,4,8 };
      int n=a.length ;
      System.out.print(MaxSumDifference(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MaxSumDifference( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var finalSequence : Sequence(int) ; finalSequence := Sequence{} ;
     a := a->sort() ; 
        var i : int ; i := 0 ; while i < n / 2 do ( (     finalSequence := finalSequence->including(a[i+1]) ; 
     finalSequence := finalSequence->including(a[n - i - 1+1]) )  ;     i := i + 1 ) ; 
    if (n mod 2 /= 0) then     finalSequence := finalSequence->including(a[n / 2+1]) ; else skip ; 
    var MaximumSum : int ; MaximumSum := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     MaximumSum := MaximumSum + if finalSequence->at(i+1) - finalSequence->at(i + 1+1) < 0 then -(finalSequence->at(i+1) - finalSequence->at(i + 1+1)) else finalSequence->at(i+1) - finalSequence->at(i + 1+1) endif )  ;     i := i + 1 ) ; 
    MaximumSum := MaximumSum + if finalSequence->at(n - 1+1) - finalSequence->at(0+1) < 0 then -(finalSequence->at(n - 1+1) - finalSequence->at(0+1)) else finalSequence->at(n - 1+1) - finalSequence->at(0+1) endif ; 
    return MaximumSum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,4,8} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(MaxSumDifference(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p005 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p005().run());
  }
  public String run(){
    BigInteger allLcm=BigInteger.ONE ;
    for(int i=1 ; i<=20 ; i++)allLcm=lcm(BigInteger.valueOf(i),allLcm);
    return allLcm.toString();
  }
  private static BigInteger lcm(BigInteger x,BigInteger y){
    return x.divide(x.gcd(y)).multiply(y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p005 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p005.newp005().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var allLcm : long ; allLcm := 1 ;
         var i : int ; i := 1 ; while i <= 20 do (     allLcm := lcm((i + "")->toLong(), allLcm) ;  ;     i := i + 1 ) ; 
     return allLcm+"" );
  static   operation lcm( x : long, y : long) : long
  pre: true
  post: true
  activity: (     return x.divide(x.gcd(y)).multiply(y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int Profit(int costPrice,int sellingPrice){
    int profit=(sellingPrice-costPrice);
    return profit ;
  }
  static int Loss(int costPrice,int sellingPrice){
    int Loss=(costPrice-sellingPrice);
    return Loss ;
  }
  public static void main(String[] args){
    int costPrice=1500,sellingPrice=2000 ;
    if(sellingPrice==costPrice)System.out.println("No profit nor Loss");
    else if(sellingPrice>costPrice)System.out.println(Profit(costPrice,sellingPrice)+" Profit ");
    else System.out.println(Loss(costPrice,sellingPrice)+" Loss ");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Profit( costPrice : int, sellingPrice : int) : int
  pre: true
  post: true
  activity: (     var profit : int ; profit := (sellingPrice - costPrice) ;
     return profit );
  static   operation Loss( costPrice : int, sellingPrice : int) : int
  pre: true
  post: true
  activity: (     var Loss : int ; Loss := (costPrice - sellingPrice) ;
     return Loss );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var costPrice : int ; costPrice := 1500 ;
    var sellingPrice : int ; sellingPrice := 2000 ;
     if (sellingPrice = costPrice) then     OclFile["System.out"].println("No profit nor Loss") ; else     if (sellingPrice > costPrice) then     OclFile["System.out"].println(Profit(costPrice, sellingPrice) + " Profit ") else     OclFile["System.out"].println(Loss(costPrice, sellingPrice) + " Loss ") ; ;  );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication40 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int numOfEntrance=sc.nextInt();
    int herEnterance=sc.nextInt();
    int count=sc.nextInt();
    int num=herEnterance+(numOfEntrance+count);
    while(num>numOfEntrance){
      num-=numOfEntrance ;
    }
    while(num<=0){
      num+=numOfEntrance ;
    }
    System.out.println(num);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication40 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numOfEntrance : int ; numOfEntrance := sc.getCurrent()->toInteger() ;
    var herEnterance : int ; herEnterance := sc.getCurrent()->toInteger() ;
    var count : int ; count := sc.getCurrent()->toInteger() ;
    var num : int ; num := herEnterance + (numOfEntrance + count) ;
    while (num > numOfEntrance) do (     num := num-(numOfEntrance) ) ; 
    while (num <= 0) do (     num := num+(numOfEntrance) ) ; 
    OclFile["System.out"].println(num) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));
    int n=in.nextInt();
    int a=in.nextInt();
    int b=in.nextInt();
    int res=(a+b)% n ;
    if(b<=0){
      if(res<=0)res+=n ;
      pw.println(res);
    }
    else {
      if(res==0)pw.println(n);
      else pw.println(res);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var res : int ; res := (a + b) mod n ;
    if (b <= 0) then (     if (res <= 0) then     res := res+(n) ; else skip ; 
     skip ) else (     if (res = 0) then     skip ; else     skip ; ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long n=in.nextLong(),a=in.nextLong(),b=in.nextLong();
    System.out.println(((a-1+b)% n+n)% n+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toLong() ;
    var a : long ; a := in.getCurrent()->toLong() ;
    var b : long ; b := in.getCurrent()->toLong() ;
     OclFile["System.out"].println(((a - 1 + b) mod n + n) mod n + 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Set<Integer>set=new HashSet<Integer>();
    int s=sc.nextInt();
    set.add(s);
    int before=s ;
    for(int i=2 ; ; i++){
      if(set.contains(f(before))){
        System.out.println(i);
        break ;
      }
      else {
        before=f(before);
        set.add(before);
      }
    }
  }
  static int f(int x){
    if(x % 2==0){
      return x/2 ;
    }
    else {
      return(x*3+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var set : Set(int) ; set := Set{} ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    set := set->including(s) ; 
    var before : int ; before := s ;
        var i : int ; i := 2 ; while true do ( (     if (set->includes(f(before))) then (     OclFile["System.out"].println(i) ; 
     break ) else (     before := f(before) ; 
     set := set->including(before) ) )  ;     i := i + 1 ) ; 
 );
  static   operation f( x : int) : int
  pre: true
  post: true
  activity: (     if (x mod 2 = 0) then (     return x / 2 ) else (     return (x * 3 + 1) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int[] a=new int[7];
    for(int i=1 ; i<7 ; i++){
      a[i]=sc.nextInt();
    }
    char[] b=sc.next().toCharArray();
    for(int j=0 ; j<b.length ; j++){
      if(b[j]=='S'){
        a[0]=a[2];
        a[2]=a[1];
        a[1]=a[5];
        a[5]=a[6];
        a[6]=a[0];
      }
      else if(b[j]=='N'){
        a[0]=a[2];
        a[2]=a[6];
        a[6]=a[5];
        a[5]=a[1];
        a[1]=a[0];
      }
      else if(b[j]=='W'){
        a[0]=a[1];
        a[1]=a[3];
        a[3]=a[6];
        a[6]=a[4];
        a[4]=a[0];
      }
      else {
        a[0]=a[1];
        a[1]=a[4];
        a[4]=a[6];
        a[6]=a[3];
        a[3]=a[0];
      }
    }
    sc.close();
    System.out.println(a[1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,7)->collect(0) ;
        var i : int ; i := 1 ; while i < 7 do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var b : Sequence(String) ; b := sc.getCurrent()->characters() ;
        var j : int ; j := 0 ; while j < b->size() do ( (     if (b[j+1] = 'S') then (     a[0+1] := a[2+1] ; 
     a[2+1] := a[1+1] ; 
    a[1+1] := a[5+1] ; 
    a[5+1] := a[6+1] ; 
    a[6+1] := a[0+1] ; 
 ) else     if (b[j+1] = 'N') then (     a[0+1] := a[2+1] ; 
     a[2+1] := a[6+1] ; 
    a[6+1] := a[5+1] ; 
    a[5+1] := a[1+1] ; 
    a[1+1] := a[0+1] ; 
 ) else     if (b[j+1] = 'W') then (     a[0+1] := a[1+1] ; 
     a[1+1] := a[3+1] ; 
    a[3+1] := a[6+1] ; 
    a[6+1] := a[4+1] ; 
    a[4+1] := a[0+1] ; 
 ) else (     a[0+1] := a[1+1] ; 
     a[1+1] := a[4+1] ; 
    a[4+1] := a[6+1] ; 
    a[6+1] := a[3+1] ; 
    a[3+1] := a[0+1] ; 
 ) ;  ;  )  ;     j := j + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(a[1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    Solver solver=new Solver();
    solver.init();
    solver.readHead(in.readLine());
  }
}
class Solver {
  int N ;
  int cnt ;
  public void init(){
    N=0 ;
    cnt=0 ;
  }
  public void readHead(String str){
    String[] strArr=str.split(" ");
    int s=Integer.parseInt(strArr[0]);
    HashSet<Integer>f=new HashSet<Integer>();
    f.add(s);
    int ans=2 ;
    for(int a=s ; ; ans++){
      if(a % 2==0)a=a/2 ;
      else a=3*a+1 ;
      if(f.contains(a))break ;
      f.add(a);
    }
    System.out.println(ans);
  }
  public boolean hasNext(){
    return cnt<N ;
  }
  public void readBody(String str){
    cnt++;
  }
  public void solve(){
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var solver : Solver ; solver := Solver.newSolver() ;
     solver.init() ; 
     solver.readHead(in.readLine()) );
}
class Solver {
   attribute N : int;
   attribute cnt : int;
   operation init() : void
  pre: true
  post: true
  activity: (     N := 0 ; 
     cnt := 0 );
   operation readHead( str : String) : void
  pre: true
  post: true
  activity: (     var strArr : Sequence(String) ; strArr := str->split(" ") ;
     var s : int ; s := (strArr[0+1])->toInteger() ;
    var f : Set(int) ; f := Set{} ;
    f := f->including(s) ; 
    var ans : int ; ans := 2 ;
        var a : int ; a := s ; while true do ( (     if (a mod 2 = 0) then     a := a / 2 else     a := 3 * a + 1 ; ;  
     if (f->includes(a)) then     break else skip ; 
     f := f->including(a) )  ;     ans := ans + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return cnt < N );
   operation readBody( str : String) : void
  pre: true
  post: true
  activity: (     cnt := cnt + 1 );
   operation solve() : void
  pre: true
  post: true
  activity: skip;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
class Main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int s=scn.nextInt();
    ArrayList<Integer>element=new ArrayList<Integer>();
    for(int i=1 ; ; ){
      if(i==1){
        element.add(s);
      }
      else {
        if(s % 2==1){
          s=odd(s);
        }
        else {
          s=even(s);
        }
        if(element.indexOf(s)==-1){
          element.add(s);
        }
        else {
          System.out.println(i);
          break ;
        }
      }
      i++;
    }
  }
  public static int even(int n){
    return n/2 ;
  }
  public static int odd(int n){
    return 3*n+1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : int ; s := scn.getCurrent()->toInteger() ;
     var element : Sequence(int) ; element := Sequence{} ;
         var i : int ; i := 1 ; while true do ( (     if (i = 1) then (     element := element->including(s) ) else (     if (s mod 2 = 1) then (     s := odd(s) ) else (     s := even(s) ) ;  
     if (element->indexOf(s)-1 = -1) then (     element := element->including(s) ) else (     OclFile["System.out"].println(i) ; 
     break ) ) ;  
     i := i + 1 )  ) );
  static   operation even( n : int) : int
  pre: true
  post: true
  activity: (     return n / 2 );
  static   operation odd( n : int) : int
  pre: true
  post: true
  activity: (     return 3 * n + 1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    boolean sw=false ;
    int answer=0 ;
    List<Integer>a=new ArrayList<Integer>();
    int s ;
    int n=1 ;
    int ai=0 ;
    int count=0 ;
    Scanner sc=new Scanner(System.in);
    s=sc.nextInt();
    while(sw==false){
      if(count==0){
        a.add(s);
        count++;
      }
      else {
        n=a.get(count-1);
        if(n % 2==0){
          ai=n/2 ;
          a.add(ai);
        }
        else {
          ai=3*n+1 ;
          a.add(ai);
        }
        count++;
      }
      for(int i=0 ; i<count-1 ; i++){
        if(a.get(i)==ai){
          answer=a.size();
          sw=true ;
        }
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sw : boolean ; sw := false ;
     var answer : int ; answer := 0 ;
    var a : Sequence(int) ; a := Sequence{} ;
    var s : int ;
    var n : int ; n := 1 ;
    var ai : int ; ai := 0 ;
    var count : int ; count := 0 ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    s := sc.getCurrent()->toInteger() ; 
    while (sw = false) do (     if (count = 0) then (     a := a->including(s) ; 
     count := count + 1 ) else (     n := a->at(count - 1+1) ; 
     if (n mod 2 = 0) then (     ai := n / 2 ; 
     a := a->including(ai) ) else (     ai := 3 * n + 1 ; 
     a := a->including(ai) ) ;  
     count := count + 1 ) ;  
         var i : int ; i := 0 ; while i < count - 1 do ( (     if (a->at(i+1) = ai) then (     answer := a->size() ; 
     sw := true ) else skip )  ;     i := i + 1 ) ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int count=1 ;
    int i=0 ;
    int ans=0 ;
    int[] hairetu=new int[1000000];
    hairetu[count-1]=n ;
    while(count<1000000){
      if(hairetu[count-1] % 2==0){
        hairetu[count]=hairetu[count-1]/2 ;
      }
      else {
        hairetu[count]=3*hairetu[count-1]+1 ;
      }
      count++;
    }
    for(i=0 ; i<1000000 ; i++){
      if(hairetu[i]==4){
        ans=i ;
        break ;
      }
      else if(hairetu[i]==2){
        ans=i ;
        break ;
      }
      else if(hairetu[i]==1){
        ans=i ;
        break ;
      }
      else {
        continue ;
      }
    }
    System.out.println(ans+4);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var count : int ; count := 1 ;
    var i : int ; i := 0 ;
    var ans : int ; ans := 0 ;
    var hairetu : Sequence(int) ; hairetu := Integer.subrange(1,1000000)->collect(0) ;
    hairetu[count - 1+1] := n ; 
    while (count < 1000000) do (     if (hairetu[count - 1+1] mod 2 = 0) then (     hairetu[count+1] := hairetu[count - 1+1] / 2 ) else (     hairetu[count+1] := 3 * hairetu[count - 1+1] + 1 ) ;  
     count := count + 1 ) ; 
        i := 0 ; while i < 1000000 do ( (     if (hairetu[i+1] = 4) then (     ans := i ; 
     break ) else     if (hairetu[i+1] = 2) then (     ans := i ; 
     break ) else     if (hairetu[i+1] = 1) then (     ans := i ; 
     break ) else (     continue ) ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans + 4) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int reverse(int n){
    int rev=0 ;
    while(n>0){
      int d=n % 10 ;
      rev=rev*10+d ;
      n=n/10 ;
    }
    return rev ;
  }
  static boolean isPalin(int n){
    return(n==reverse(n));
  }
  static int countDigits(int n){
    int c=0 ;
    while(n>0){
      n=n/10 ;
      c++;
    }
    return c ;
  }
  static int countPalinDigits(int[] arr,int n){
    int s=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]<10 || isPalin(arr[i])){
        s+=countDigits(arr[i]);
      }
    }
    return s ;
  }
  public static void main(String[] args){
    int[] arr={
      121,56,434 };
      int n=arr.length ;
      System.out.println(countPalinDigits(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation reverse( n : int) : int
  pre: true
  post: true
  activity: (     var rev : int ; rev := 0 ;
     while (n > 0) do (     var d : int ; d := n mod 10 ;
     rev := rev * 10 + d ; 
     n := n / 10 ) ; 
     return rev );
  static   operation isPalin( n : int) : boolean
  pre: true
  post: true
  activity: (     return (n = reverse(n)) );
  static   operation countDigits( n : int) : int
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
     while (n > 0) do (     n := n / 10 ; 
     c := c + 1 ) ; 
     return c );
  static   operation countPalinDigits( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var s : int ; s := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] < 10 or isPalin(arr[i+1])) then (     s := s+(countDigits(arr[i+1])) ) else skip )  ;     i := i + 1 ) ; 
     return s );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{121,56,434} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countPalinDigits(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int N=sc.nextInt();
      int M=sc.nextInt();
      if(N==0)break ;
      int ans=0 ;
      int price=M/N ;
      for(int i=0 ; i<N ; i++){
        int a=sc.nextInt();
        if(a<price)ans+=a ;
        else ans+=price ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var M : int ; M := sc.getCurrent()->toInteger() ;
    if (N = 0) then     break else skip ; 
    var ans : int ; ans := 0 ;
    var price : int ; price := M / N ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (a < price) then     ans := ans+(a) ; else     ans := ans+(price) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws java.io.IOException {
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      final Map<String,Double>map=new HashMap<String,Double>();
      String[] seed=new String[n];
      for(int i=0 ; i<n ; i++){
        String L=sc.next();
        seed[i]=L ;
        int P=sc.nextInt();
        int A=sc.nextInt();
        int B=sc.nextInt();
        int C=sc.nextInt();
        int D=sc.nextInt();
        int E=sc.nextInt();
        int F=sc.nextInt();
        int S=sc.nextInt();
        int M=sc.nextInt();
        int t=A+B+C+M*(D+E);
        int inc=(M*F*S-P);
        double ef=1.0*inc/t ;
        map.put(L,ef);
      }
      Arrays.sort(seed);
      Arrays.sort(seed,new Comparator<String>(){
        public int compare(String a,String b){
          return map.get(b)-map.get(a)>0 ? 1 :-1 ;
        }
      }
);
      for(int i=0 ; i<n ; i++){
        System.out.println(seed[i]);
      }
      System.out.println(("#"));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var map : Map(String,double) ; map := Map{} ;
    var seed : Sequence(String) ; seed := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var L : String ; L := sc.getCurrent() ;
     seed[i+1] := L ; 
    var P : int ; P := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var D : int ; D := sc.getCurrent()->toInteger() ;
    var E : int ; E := sc.getCurrent()->toInteger() ;
    var F : int ; F := sc.getCurrent()->toInteger() ;
    var S : int ; S := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var t : int ; t := A + B + C + M * (D + E) ;
    var inc : int ; inc := (M * F * S - (P)->char2byte()) ;
    var ef : double ; ef := 1.0 * inc / t ;
    map := map->union(Map{L |-> ef}) ; 
 )  ;     i := i + 1 ) ; 
    seed := seed->sort() ; 
    seed := OclComparator.sortWith(seed, OclComparator<String>.newOclComparator()) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(seed[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(("#")) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static final String END_OF_DATASET="#" ;
  public static void main(String[] args){
    try(Scanner scn=new Scanner(System.in)){
      int n ;
      while((n=scn.nextInt())>0){
        ArrayList<Plant>plants=new ArrayList<>();
        while(n-->0){
          String name=scn.next();
          int cost=scn.nextInt();
          int firstTime=scn.nextInt()+scn.nextInt()+scn.nextInt();
          int latterTime=scn.nextInt()+scn.nextInt();
          int amount=scn.nextInt();
          int price=scn.nextInt();
          int count=scn.nextInt();
          double profit=amount*price*count-cost ;
          double efficiency=profit/(firstTime+latterTime*count);
          plants.add(new Plant(name,efficiency));
        }
        Collections.sort(plants);
        for(Plant plant : plants){
          System.out.println(plant);
        }
        System.out.println(END_OF_DATASET);
      }
    }
  }
}
class Plant implements Comparable<Plant>{
  private String name ;
  private double efficiency ;
  public Plant(String name,double efficiency){
    this.name=name ;
    this.efficiency=efficiency ;
  }
  public int compareTo(Plant another){
    int rslt ;
    if(this.efficiency<another.efficiency){
      rslt=1 ;
    }
    else if(this.efficiency>another.efficiency){
      rslt=-1 ;
    }
    else {
      rslt=this.name.compareTo(another.name);
    }
    return rslt ;
  }
  @ Override public String toString(){
    return name ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute END_OF_DATASET : String := "#";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ;
         n := scn.getCurrent()->toInteger() ;
    while ((n) > 0) do (        skip ;     skip ; (     var plants : Sequence(Plant) ; plants := Sequence{} ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var name : String ; name := scn.getCurrent() ;
     var cost : int ; cost := scn.getCurrent()->toInteger() ;
    var firstTime : int ; firstTime := scn.getCurrent()->toInteger() + scn.getCurrent()->toInteger() + scn.getCurrent()->toInteger() ;
    var latterTime : int ; latterTime := scn.getCurrent()->toInteger() + scn.getCurrent()->toInteger() ;
    var amount : int ; amount := scn.getCurrent()->toInteger() ;
    var price : int ; price := scn.getCurrent()->toInteger() ;
    var count : int ; count := scn.getCurrent()->toInteger() ;
    var profit : double ; profit := amount * price * count - (cost)->char2byte() ;
    var efficiency : double ; efficiency := profit / (firstTime + latterTime * count) ;
    plants := plants->including(Plant.newPlant(name, efficiency)) ; 
 ) ;  ) ;  
    plants := plants->sort() ; 
    for (plant : plants) do ( (     OclFile["System.out"].println(plant) )  ) ; 
    OclFile["System.out"].println(END_OF_DATASET) ; 
 ) ;     n := scn.getCurrent()->toInteger() ;
 ) ))  );
}
class Plant implements Comparable<Plant> {
   attribute name : String;
   attribute efficiency : double;
   static operation newPlant( name : String, efficiency : double) : Plant
  pre: true
  post: true
  activity:
  ( var self : Plant ;
    self := createPlant();
    self.initialise(name, efficiency);
    return self );
  operation initialise( name : String, efficiency : double) : void
  pre: true  post: true
  activity: (     self.name := name ; 
     self.efficiency := efficiency );
   operation compareTo( another : Plant) : int
  pre: true
  post: true
  activity: (     var rslt : int ;
     if (self.efficiency < another.efficiency) then (     rslt := 1 ) else     if (self.efficiency > another.efficiency) then (     rslt := -1 ) else (     rslt := self.name->compareTo(another.name) ) ;  ;  
     return rslt );
      operation toString() : String
  pre: true
  post: true
  activity: (     return name );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  static class State implements Comparable<State>{
    String name ;
    double cost ;
    State(String name,double cost){
      this.name=name ;
      this.cost=cost ;
    }
    public int compareTo(State s){
      if(s.cost==this.cost){
        return this.name.compareTo(s.name);
      }
      else if(this.cost>s.cost){
        return-1 ;
      }
      else {
        return 1 ;
      }
    }
  }
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      while(sc.hasNext()){
        int N=sc.nextInt();
        if(N==0)break ;
        PriorityQueue<State>pq=new PriorityQueue<State>();
        for(int i=0 ; i<N ; i++){
          String name=sc.next();
          int p=sc.nextInt();
          int a=sc.nextInt();
          int b=sc.nextInt();
          int c=sc.nextInt();
          int d=sc.nextInt();
          int e=sc.nextInt();
          int f=sc.nextInt();
          int s=sc.nextInt();
          int m=sc.nextInt();
          int turn1=a+b+c+d+e ;
          int turn2=d+e ;
          int benefit=f*s*m-p ;
          double cost=1.0*benefit/(double)(turn1+(m-1)*turn2);
          pq.add(new State(name,cost));
        }
        for(int i=0 ; i<N ; i++){
          State st=pq.remove();
          System.out.println(st.name);
        }
        System.out.println("#");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class State implements Comparable<State> {
   attribute name : String;
   attribute cost : double;
   static operation newState( name : String, cost : double) : State
  pre: true
  post: true
  activity:
  ( var self : State ;
    self := createState();
    self.initialise(name, cost);
    return self );
  operation initialise( name : String, cost : double) : void
  pre: true  post: true
  activity: (     self.name := name ; 
     self.cost := cost );
   operation compareTo( s : State) : int
  pre: true
  post: true
  activity: (     if (s.cost = self.cost) then (     return self.name->compareTo(s.name) ) else     if (self.cost > s.cost) then (     return -1 ) else (     return 1 ) ;  );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (sc.hasNext()) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then     break else skip ; 
    var pq : Sequence(State) ; pq := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var name : String ; name := sc.getCurrent() ;
     var p : int ; p := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var e : int ; e := sc.getCurrent()->toInteger() ;
    var f : int ; f := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var turn1 : int ; turn1 := a + b + c + d + e ;
    var turn2 : int ; turn2 := d + e ;
    var benefit : int ; benefit := f * s * m - (p)->char2byte() ;
    var cost : double ; cost := 1.0 * benefit / (turn1 + (m - 1) * turn2)->oclAsType(double) ;
    pq := pq->including(State.newState(name, cost)) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var st : State ; st := pq.remove() ;
     OclFile["System.out"].println(st.name) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("#") ; 
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static private int[] dice=new int[6];
  static public int checkUpper(){
    return dice[0];
  }
  static public void move(String order){
    for(Character s : order.toCharArray()){
      int buf ;
      switch(s){
        case 'N' : {
          buf=dice[0];
          dice[0]=dice[1];
          dice[1]=dice[5];
          dice[5]=dice[4];
          dice[4]=buf ;
          break ;
        }
        case 'E' : {
          buf=dice[0];
          dice[0]=dice[3];
          dice[3]=dice[5];
          dice[5]=dice[2];
          dice[2]=buf ;
          break ;
        }
        case 'W' : {
          buf=dice[0];
          dice[0]=dice[2];
          dice[2]=dice[5];
          dice[5]=dice[3];
          dice[3]=buf ;
          break ;
        }
        case 'S' : {
          buf=dice[0];
          dice[0]=dice[4];
          dice[4]=dice[5];
          dice[5]=dice[1];
          dice[1]=buf ;
          break ;
        }
      }
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] nums=new int[6];
    for(int i=0 ; i<6 ; i++){
      nums[i]=sc.nextInt();
    }
    String order=sc.next();
    sc.close();
    dice=nums ;
    move(order);
    System.out.println(checkUpper());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute dice : Sequence(int) := Integer.subrange(1,6)->collect(0);
  static    operation checkUpper() : int
  pre: true
  post: true
  activity: (     return dice[0+1] );
  static    operation move( order : String) : void
  pre: true
  post: true
  activity: (     for (s : order->characters()) do ( (     var buf : int ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (s) ; 
       if _switchval = 'N' then
 (     buf := dice[0+1] ; 
     dice[0+1] := dice[1+1] ; 
    dice[1+1] := dice[5+1] ; 
    dice[5+1] := dice[4+1] ; 
    dice[4+1] := buf ; 
    break 
 ) 
   else skip ;
       if _switchval = 'E' then
 (     buf := dice[0+1] ; 
     dice[0+1] := dice[3+1] ; 
    dice[3+1] := dice[5+1] ; 
    dice[5+1] := dice[2+1] ; 
    dice[2+1] := buf ; 
    break 
 ) 
   else skip ;
       if _switchval = 'W' then
 (     buf := dice[0+1] ; 
     dice[0+1] := dice[2+1] ; 
    dice[2+1] := dice[5+1] ; 
    dice[5+1] := dice[3+1] ; 
    dice[3+1] := buf ; 
    break 
 ) 
   else skip ;
       if _switchval = 'S' then
 (     buf := dice[0+1] ; 
     dice[0+1] := dice[4+1] ; 
    dice[4+1] := dice[5+1] ; 
    dice[5+1] := dice[1+1] ; 
    dice[1+1] := buf ; 
    break 
 ) 
   else skip ;
 )
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var nums : Sequence(int) ; nums := Integer.subrange(1,6)->collect(0) ;
        var i : int ; i := 0 ; while i < 6 do ( (     nums[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var order : String ; order := sc.getCurrent() ;
    skip ; 
    dice := nums ; 
    execute move(order) ; 
    OclFile["System.out"].println(checkUpper()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] z){
    Scanner s=new Scanner(System.in);
    String L ;
    for(int t,i ; (t=s.nextInt())>0 ; System.out.println(L+"#")){
      List<String[]>l=new ArrayList<String[]>();
      for(; t-->0 ; ){
        L=s.next();
        int[] x=new int[9];
        for(i=0 ; i<9 ; ++i)x[i]=s.nextInt();
        l.add(new String[] {
          L,""+(double)(x[6]*x[8]*x[7]-x[0])/(x[1]+x[2]+x[3]+(x[4]+x[5])*x[8])}
);
        }
        Collections.sort(l,new Comparator<String[]>(){
          public int compare(String[] a,String[] b){
            int i=new Double(b[1]).compareTo(new Double(a[1]));
            return i==0 ? a[0] .compareTo(b[0]): i ;
          }
        }
);
        L="" ;
        for(String[] y : l)L+=y[0]+"\n" ;
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var L : String ;
         var t : int ;
    var i : int ; while (t) > 0 do ( (     var l : Sequence(Sequence(String)) ; l := Sequence{} ;
       while t > 0 do ( (     L := s.getCurrent() ; 
     var x : Sequence(int) ; x := Integer.subrange(1,9)->collect(0) ;
         i := 0 ; while i < 9 do (     x[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
     l := l->including(Sequence{L,"" + (x[6+1] * x[8+1] * x[7+1] - x[0+1])->oclAsType(double) / (x[1+1] + x[2+1] + x[3+1] + (x[4+1] + x[5+1]) * x[8+1])}) )  ) ; 
    l, OclComparator<Sequence(String)>.newOclComparator() := l, OclComparator<Sequence(String)>.newOclComparator()->sort() ; 
    L := "" ; 
    for (y : l) do (     L := L+(y[0+1] + "\n") ;  ) ; 
 )  ;     OclFile["System.out"].println(L + "#") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int inputs=in.nextInt();
    Q : for(int _=1 ;
    _<=inputs ;
    _++){
      int a=in.nextInt();
      int b=in.nextInt();
      double exp=2+b ;
      double[] prob=new double[a+1];
      prob[0]=1 ;
      for(int i=0 ; i<a ; i++){
        prob[i+1]=prob[i]*(in.nextDouble());
      }
      double exp2=prob[a]*(b-a+1)+(1-prob[a])*(2*b-a+2);
      if(exp2<exp)exp=exp2 ;
      exp2=0 ;
      for(int i=0 ; i<a ; i++){
        exp2=prob[i]*(2*(a-i)+(b-a)+1)+(1-prob[i])*((2*(a-i)+(b-a)+1)+b+1);
        if(exp2<exp)exp=exp2 ;
      }
      System.out.printf("Case #"+_+": %.6f\n",exp);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inputs : int ; inputs := in.getCurrent()->toInteger() ;
         var _ : int ; _ := 1 ; while _ <= inputs do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    var exp : double ; exp := 2 + b ;
    var prob : Sequence(double) ; prob := Integer.subrange(1,a + 1)->collect(0.0) ;
    prob[0+1] := 1 ; 
        var i : int ; i := 0 ; while i < a do ( (     prob[i + 1+1] := prob[i+1] * (in.getCurrent()->toReal()) )  ;     i := i + 1 ) ; 
    var exp2 : double ; exp2 := prob[a+1] * (b - a + 1) + (1 - prob[a+1]) * (2 * b - a + 2) ;
    if (exp2 < exp) then     exp := exp2 ; else skip ; 
    exp2 := 0 ; 
        var i : int ; i := 0 ; while i < a do ( (     exp2 := prob[i+1] * (2 * (a - i) + (b - a) + 1) + (1 - prob[i+1]) * ((2 * (a - i) + (b - a) + 1) + b + 1) ; 
     if (exp2 < exp) then     exp := exp2 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("Case #" + _ + ": %.6f\n", exp) ; 
 )  ;     _ := _ + 1 ) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class PasswordProblem {
  void solve()throws Exception {
    int a=nextInt();
    int b=nextInt();
    double[] p=new double[a];
    for(int i=0 ; i<a ; i++){
      p[i]=nextDouble();
    }
    double[] prob=p.clone();
    for(int i=1 ; i<a ; i++){
      prob[i]=prob[i-1]*prob[i];
    }
    double ans=b+2 ;
    for(int i=a-1 ; i>=0 ; i--){
      double curAns=(a-i-1)+(b-i-1)+1+(1-prob[i])*(b+1);
      ans=Math.min(ans,curAns);
    }
    out.println(ans);
  }
  void run(){
    try {
      in=new BufferedReader(new FileReader("input.txt"));
      out=new PrintWriter("output.txt");
      int tests=nextInt();
      for(int i=0 ; i<tests ; i++){
        out.print("Case #"+(i+1)+": ");
        solve();
      }
      out.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  BufferedReader in ;
  StringTokenizer st ;
  PrintWriter out ;
  final String filename=new String("PasswordProblem").toLowerCase();
  String nextToken()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(in.readLine());
    return st.nextToken();
  }
  int nextInt()throws Exception {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws Exception {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws Exception {
    return Double.parseDouble(nextToken());
  }
  public static void main(String[] args){
    new PasswordProblem().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class PasswordProblem {
   operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ; a := nextInt() ;
     var b : int ; b := nextInt() ;
    var p : Sequence(double) ; p := Integer.subrange(1,a)->collect(0.0) ;
        var i : int ; i := 0 ; while i < a do ( (     p[i+1] := nextDouble() )  ;     i := i + 1 ) ; 
    var prob : Sequence(double) ; prob := p->copy() ;
        var i : int ; i := 1 ; while i < a do ( (     prob[i+1] := prob[i - 1+1] * prob[i+1] )  ;     i := i + 1 ) ; 
    var ans : double ; ans := b + 2 ;
        var i : int ; i := a - 1 ; while i >= 0 do ( (     var curAns : double ; curAns := (a - i - 1) + (b - i - 1) + 1 + (1 - prob[i+1]) * (b + 1) ;
     ans := Set{ans, curAns}->min() )  ;     i := i - 1 ) ; 
    out.println(ans) ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ; 
    var tests : int ; tests := nextInt() ;
        var i : int ; i := 0 ; while i < tests do ( (     out.print("Case #" + (i + 1) + ": ") ; 
     execute solve() )  ;     i := i + 1 ) ; 
    out.close() ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
   attribute in : OclFile;
   attribute st : OclIterator;
   attribute out : OclFile;
   attribute filename : String := StringLib.newString("PasswordProblem")->toLowerCase();
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(in.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     PasswordProblem.newPasswordProblem().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.math.MathContext ;
import java.math.RoundingMode ;
import java.util.Arrays ;
import java.util.Scanner ;
public class A {
  private static Scanner sc ;
  private static long start ;
  public static void main(String[] args){
    sc=new Scanner(System.in);
    int t=sc.nextInt();
    sc.nextLine();
    for(int i=0 ; i<t ; i++){
      start=System.currentTimeMillis();
      System.out.printf("Case #%d: %s\n",i+1,exec());
      long end=System.currentTimeMillis();
    }
  }
  private static final MathContext ROUND_CONTEXT=new MathContext(8,RoundingMode.HALF_EVEN);
  public static String exec(){
    int a=sc.nextInt();
    int b=sc.nextInt();
    BigDecimal[] bd=new BigDecimal[a];
    for(int i=0 ; i<a ; i++)bd[i]=new BigDecimal(sc.next());
    BigDecimal[] rs=new BigDecimal[a+2];
    rs[0]=new BigDecimal(b+2);
    int backspacesNeeded=a ;
    double runningChance=1.0 ;
    for(int i=0 ; i<a ; i++){
      int charsNeededOnSuccess=backspacesNeeded+b-i+1 ;
      int charsNeededOnFail=charsNeededOnSuccess+b+1 ;
      double onSuccess=runningChance*charsNeededOnSuccess ;
      double onFail=(1.0-runningChance)*charsNeededOnFail ;
      rs[i+1]=new BigDecimal(onSuccess+onFail);
      runningChance*=bd[i] .doubleValue();
      backspacesNeeded--;
    }
    rs[a+1]=new BigDecimal((runningChance*(b-a+1))+((1.0-runningChance)*(b-a+1+b+1)));
    Arrays.sort(rs);
    BigDecimal result=rs[0];
    return String.format("%.06f",result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute sc : OclFile;
  static   attribute start : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var t : int ; t := sc.getCurrent()->toInteger() ;
     skip ; 
         var i : int ; i := 0 ; while i < t do ( (     start := OclDate.getSystemTime() ; 
     OclFile["System.out"].printf("Case #%d: %s\n", i + 1, exec()) ; 
     var end : long ; end := OclDate.getSystemTime() )  ;     i := i + 1 ) );
  static    attribute ROUND_CONTEXT : MathContext := MathContext.newMathContext(8, RoundingMode.HALF_EVEN);
  static   operation exec() : String
  pre: true
  post: true
  activity: (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var bd : Sequence(double) ; bd := Integer.subrange(1,a)->collect(null) ;
        var i : int ; i := 0 ; while i < a do (     bd[i+1] := double(sc.getCurrent()) ;  ;     i := i + 1 ) ; 
    var rs : Sequence(double) ; rs := Integer.subrange(1,a + 2)->collect(null) ;
    rs[0+1] := double(b + 2) ; 
    var backspacesNeeded : int ; backspacesNeeded := a ;
    var runningChance : double ; runningChance := 1.0 ;
        var i : int ; i := 0 ; while i < a do ( (     var charsNeededOnSuccess : int ; charsNeededOnSuccess := backspacesNeeded + b - i + 1 ;
     var charsNeededOnFail : int ; charsNeededOnFail := charsNeededOnSuccess + b + 1 ;
    var onSuccess : double ; onSuccess := runningChance * charsNeededOnSuccess ;
    var onFail : double ; onFail := (1.0 - runningChance) * charsNeededOnFail ;
    rs[i + 1+1] := double(onSuccess + onFail) ; 
    runningChance := runningChance*(bd[i+1]->oclAsType(double)) ; 
    backspacesNeeded := backspacesNeeded - 1 ; 
 )  ;     i := i + 1 ) ; 
    rs[a + 1+1] := double((runningChance * (b - a + 1)) + ((1.0 - runningChance) * (b - a + 1 + b + 1))) ; 
    rs := rs->sort() ; 
    var result : double ; result := rs[0+1] ;
    return StringLib.format("%.06f",Sequence{result}) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.lang.Math ;
class GFG {
  public static int lenoflongestnonpalindrome(String s){
    int max1=1,len=0 ;
    char[] new_str=s.toCharArray();
    for(int i=0 ; i<new_str.length-1 ; i++){
      if(new_str[i]==new_str[i+1])len=0 ;
      else if(i>0 &&(new_str[i+1]==new_str[i-1]))len=1 ;
      else len++;
      max1=Math.max(max1,len+1);
    }
    if(max1==1)return 0 ;
    else return max1 ;
  }
  public static void main(String[] args){
    String s="synapse" ;
    System.out.println(lenoflongestnonpalindrome(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation lenoflongestnonpalindrome( s : String) : int
  pre: true
  post: true
  activity: (     var max1 : int ; max1 := 1 ;
    var len : int ; len := 0 ;
     var new_str : Sequence(String) ; new_str := s->characters() ;
         var i : int ; i := 0 ; while i < new_str->size() - 1 do ( (     if (new_str[i+1] = new_str[i + 1+1]) then     len := 0 else     if (i > 0 & (new_str[i + 1+1] = new_str[i - 1+1])) then     len := 1 else     len := len + 1 ; ;  ;  
     max1 := Set{max1, len + 1}->max() )  ;     i := i + 1 ) ; 
     if (max1 = 1) then     return 0 else     return max1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "synapse" ;
     OclFile["System.out"].println(lenoflongestnonpalindrome(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class A {
  static double[] logP=new double[1<<17];
  public static void main(String[] args)throws Exception {
    Scanner s=new Scanner(new File("A.in"));
    PrintWriter out=new PrintWriter(new File("A.out"));
    int T=s.nextInt();
    for(int tc=1 ; tc<=T ; tc++){
      out.print("Case #"+tc+": ");
      int A=s.nextInt(),B=s.nextInt();
      double best=A+B+1 ;
      logP[0]=Math.log(s.nextDouble());
      best=Math.min(best,(2*(A-1)+(B-A)+1)+(B+1)-(B+1)*Math.exp(logP[0]));
      for(int i=1 ; i<A ; i++){
        logP[i]=logP[i-1]+Math.log(s.nextDouble());
        best=Math.min(best,(2*(A-1-i)+(B-A)+1)+(B+1)-(B+1)*Math.exp(logP[i]));
      }
      best=Math.min(best,B+2);
      out.println(best);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute logP : Sequence(double) := Integer.subrange(1,(1*(2->pow(17)))->oclAsType(long))->collect(0.0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile("A.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("A.out")) ;
    var T : int ; T := s.getCurrent()->toInteger() ;
        var tc : int ; tc := 1 ; while tc <= T do ( (     skip ; 
     var A : int ; A := s.getCurrent()->toInteger() ;
    var B : int ; B := s.getCurrent()->toInteger() ;
    var best : double ; best := A + B + 1 ;
    logP[0+1] := (s.getCurrent()->toReal())->log() ; 
    best := Set{best, (2 * (A - 1) + (B - A) + 1) + (B + 1) - (B + 1) * (logP[0+1])->exp()}->min() ; 
        var i : int ; i := 1 ; while i < A do ( (     logP[i+1] := logP[i - 1+1] + (s.getCurrent()->toReal())->log() ; 
     best := Set{best, (2 * (A - 1 - i) + (B - A) + 1) + (B + 1) - (B + 1) * (logP[i+1])->exp()}->min() )  ;     i := i + 1 ) ; 
    best := Set{best, B + 2}->min() ; 
    skip ; 
 )  ;     tc := tc + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Vector<Long>pr=new Vector<>();
  static boolean prime[]=new boolean[10000000+1];
  static void sieve(long n){
    for(int i=2 ; i<=n ; i+=1){
      prime[i]=true ;
    }
    for(int p=2 ; (int)p*(int)p<=n ; p++){
      if(prime[p]==true){
        for(int i=(int)p*(int)p ; i<=n ; i+=p)prime[i]=false ;
      }
    }
    for(int p=2 ; p<=n ; p++)if(prime[p])pr.add((long)p);
  }
  static long SemiPrimeSum(long N){
    long ans=0 ;
    for(int i=0 ; i<pr.size(); i+=1){
      for(int j=i ; j<pr.size(); j+=1){
        if((long)pr.get(i)*(long)pr.get(j)>N)break ;
        ans+=(long)pr.get(i)*(long)pr.get(j);
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    long N=6 ;
    sieve(N);
    System.out.println(SemiPrimeSum(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute pr : Sequence(long) := Sequence{};
  static   attribute prime : boolean := Integer.subrange(1,10000000 + 1)->collect(false);
  static   operation sieve( n : long) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i <= n do ( (     prime[i+1] := true )  ;     i := i+(1) ) ; 
         var p : int ; p := 2 ; while p->oclAsType(int) * p->oclAsType(int) <= n do ( (     if (prime[p+1] = true) then (         var i : int ; i := p->oclAsType(int) * p->oclAsType(int) ; while i <= n do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
         var p : int ; p := 2 ; while p <= n do (     if (prime[p+1]) then     pr := pr->including(p->oclAsType(long)) ; else skip ;  ;     p := p + 1 ) );
  static   operation SemiPrimeSum( N : long) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
         var i : int ; i := 0 ; while i < pr->size() do ( (         var j : int ; j := i ; while j < pr->size() do ( (     if (pr->at(i+1)->oclAsType(long) * pr->at(j+1)->oclAsType(long) > N) then     break else skip ; 
     ans := ans+(pr->at(i+1)->oclAsType(long) * pr->at(j+1)->oclAsType(long)) )  ;     j := j+(1) ) )  ;     i := i+(1) ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := 6 ;
     execute sieve(N) ; 
     OclFile["System.out"].println(SemiPrimeSum(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.nio.charset.MalformedInputException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter o=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt(),k=sc.nextInt(),m=2 ;
      if(n % 2==0){
        o.println(n+k*2);
      }
      else {
        while(n % m!=0){
          m++;
        }
        o.println(n+m+k*2-2);
      }
    }
    o.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var o : OclFile ; o := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var m : int ; m := 2 ;
     if (n mod 2 = 0) then (     skip ) else (     while (n mod m /= 0) do (     m := m + 1 ) ; 
     skip ) ) ;  ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class App {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=s.nextInt();
      int k=s.nextInt();
      if(n % 2==0)System.out.println(n+2*k);
      else {
        int val=n ;
        for(int j=3 ; j*j<=n ; j+=2){
          if(n % j==0){
            val=j ;
            break ;
          }
        }
        System.out.println(n+val+(2*(k-1)));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := s.getCurrent()->toInteger() ;
     var k : int ; k := s.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then     OclFile["System.out"].println(n + 2 * k) ; else (     var val : int ; val := n ;
         var j : int ; j := 3 ; while j * j <= n do ( (     if (n mod j = 0) then (     val := j ; 
     break ) else skip )  ;     j := j+(2) ) ; 
     OclFile["System.out"].println(n + val + (2 * (k - 1))) ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int T=sc.nextInt();
    int S=sc.nextInt();
    int E=sc.nextInt();
    int W=sc.nextInt();
    int N=sc.nextInt();
    int B=sc.nextInt();
    String[] ss=sc.next().split("");
    for(int i=0 ; i<ss.length ; i++){
      if(ss[i] .equals("N")){
        int[] temp={
          T,S,E,W,N,B };
          T=temp[1];
          N=temp[0];
          B=temp[4];
          S=temp[5];
        }
        else if(ss[i] .equals("E")){
          int[] temp={
            T,S,E,W,N,B };
            T=temp[3];
            E=temp[0];
            B=temp[2];
            W=temp[5];
          }
          else if(ss[i] .equals("S")){
            int[] temp={
              T,S,E,W,N,B };
              T=temp[4];
              N=temp[5];
              B=temp[1];
              S=temp[0];
            }
            else if(ss[i] .equals("W")){
              int[] temp={
                T,S,E,W,N,B };
                T=temp[2];
                E=temp[5];
                B=temp[3];
                W=temp[0];
              }
            }
            System.out.println(T);
          }
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := sc.getCurrent()->toInteger() ;
     var S : int ; S := sc.getCurrent()->toInteger() ;
    var E : int ; E := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var ss : Sequence(String) ; ss := sc.getCurrent()->split("") ;
        var i : int ; i := 0 ; while i < ss->size() do ( (     if (ss[i+1] = "N") then (     var temp : Sequence(int) ; temp := Sequence{T,S,E,W,N,B} ;
     T := temp[1+1] ; 
    N := temp[0+1] ; 
    B := temp[4+1] ; 
    S := temp[5+1] ; 
 ) else     if (ss[i+1] = "E") then (     var temp : Sequence(int) ; temp := Sequence{T,S,E,W,N,B} ;
     T := temp[3+1] ; 
    E := temp[0+1] ; 
    B := temp[2+1] ; 
    W := temp[5+1] ; 
 ) else     if (ss[i+1] = "S") then (     var temp : Sequence(int) ; temp := Sequence{T,S,E,W,N,B} ;
     T := temp[4+1] ; 
    N := temp[5+1] ; 
    B := temp[1+1] ; 
    S := temp[0+1] ; 
 ) else     if (ss[i+1] = "W") then (     var temp : Sequence(int) ; temp := Sequence{T,S,E,W,N,B} ;
     T := temp[2+1] ; 
    E := temp[5+1] ; 
    B := temp[3+1] ; 
    W := temp[0+1] ; 
 ) else skip ; ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(T) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.*;
public class App {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws Exception {
    if(System.getProperty("ONLINE_JUDGE")==null){
      File inputFile=new File("/Users/vipinjain/self/cp/input.txt");
      File outputFile=new File("/Users/vipinjain/self/cp/output.txt");
      br=new BufferedReader(new FileReader(inputFile));
      bw=new BufferedWriter(new FileWriter(outputFile));
    }
    int tests ;
    tests=Integer.parseInt(br.readLine());
    while(tests-->0){
      solve();
    }
    bw.flush();
    bw.close();
    br.close();
  }
  static void solve()throws Exception {
    String[] tmp=br.readLine().split(" ");
    long n=Long.parseLong(tmp[0]);
    long k=Long.parseLong(tmp[1]);
    long minDivisor=minDivisor(n);
    n+=minDivisor ;
    k--;
    if(k>0){
      n=n+2*k ;
    }
    bw.write(n+"");
    bw.write("\n");
  }
  static int gcd(int a,int b){
    if(a==0){
      return b ;
    }
    return gcd(b % a,a);
  }
  static boolean isPrime(long n){
    for(long i=2 ; i*i<=n ; i++){
      if(n % i==0){
        return false ;
      }
    }
    return true ;
  }
  static long minDivisor(long n){
    for(long i=2 ; i*i<=n ; ++i){
      if(n % i==0){
        return i ;
      }
    }
    return n ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null) then (     var inputFile : OclFile ; inputFile := OclFile("/Users/vipinjain/self/cp/input.txt") ;
     var outputFile : OclFile ; outputFile := OclFile("/Users/vipinjain/self/cp/output.txt") ;
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputFile)) ; 
     bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputFile)) ) else skip ; 
     var tests : int ;
    tests := (br.readLine())->toInteger() ; 
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var tmp : Sequence(String) ; tmp := br.readLine()->split(" ") ;
     var n : long ; n := (tmp[0+1])->toLong() ;
    var k : long ; k := (tmp[1+1])->toLong() ;
    var minDivisor : long ; minDivisor := minDivisor(n) ;
    n := n+(minDivisor) ; 
    k := k - 1 ; 
    if (k > 0) then (     n := n + 2 * k ) else skip ; 
    skip ; 
    skip ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then (     return b ) else skip ; 
     return gcd(b mod a, a) );
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (         var i : long ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation minDivisor( n : long) : long
  pre: true
  post: true
  activity: (         var i : long ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     return i ) else skip )  ;     i := i + 1 ) ; 
     return n );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      long a=sc.nextLong();
      long b=sc.nextLong();
      long i=2 ;
      while(i*i<=a){
        if(a % i==0){
          break ;
        }
        i++;
      }
      if(a % 2==0){
        System.out.println(a+(2*b));
      }
      else {
        if(a % i!=0)a+=a ;
        else a+=i ;
        a+=(2*(b-1));
        System.out.println(a);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
    var i : long ; i := 2 ;
    while (i * i <= a) do (     if (a mod i = 0) then (     break ) else skip ; 
     i := i + 1 ) ; 
    if (a mod 2 = 0) then (     OclFile["System.out"].println(a + (2 * b)) ) else (     if (a mod i /= 0) then     a := a+(a) else     a := a+(i) ; ;  
     a := a+((2 * (b - 1))) ; 
     OclFile["System.out"].println(a) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B {
  static Scanner in ;
  public static void main(String[] args){
    in=new Scanner(System.in);
    int T=in.nextInt();
    for(int C=1 ; C<=T ; C++){
      System.out.println("Case #"+C+": "+solve());
    }
  }
  public static String solve(){
    String out="" ;
    int B=in.nextInt();
    long M=in.nextLong()-1 ;
    String binary="" ;
    while(M>0){
      binary+=M % 2 ;
      M=M/2 ;
    }
    System.err.println(binary);
    if(binary.length()>B-2){
      out="IMPOSSIBLE" ;
    }
    else {
      out="POSSIBLE" ;
      for(int i=0 ; i<B ; i++){
        String line="" ;
        for(int j=0 ; j<=i ; j++){
          line+="0" ;
        }
        for(int j=0 ; j<B-2-i ; j++){
          line+="1" ;
        }
        if(i<B-1){
          if(i==0){
            line+="1" ;
          }
          else if(i-1<binary.length()){
            line+=binary.charAt(i-1);
          }
          else {
            line+="0" ;
          }
        }
        out+="\n"+line ;
      }
    }
    return out ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute in : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var T : int ; T := in.getCurrent()->toInteger() ;
         var C : int ; C := 1 ; while C <= T do ( (     OclFile["System.out"].println("Case #" + C + ": " + solve()) )  ;     C := C + 1 ) );
  static   operation solve() : String
  pre: true
  post: true
  activity: (     var out : String ; out := "" ;
     var B : int ; B := in.getCurrent()->toInteger() ;
    var M : long ; M := in.getCurrent()->toLong() - 1 ;
    var binary : String ; binary := "" ;
    while (M > 0) do (     binary := binary+(M mod 2) ; 
     M := M / 2 ) ; 
    OclFile["System.err"].println(binary) ; 
    if (binary->size() > (B)->char2byte() - 2) then (     out := "IMPOSSIBLE" ) else (     out := "POSSIBLE" ; 
         var i : int ; i := 0 ; while i < B do ( (     var line : String ; line := "" ;
         var j : int ; j := 0 ; while j <= i do ( (     line := line+("0") )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < (B)->char2byte() - 2 - (i)->char2byte() do ( (     line := line+("1") )  ;     j := j + 1 ) ; 
    if (i < (B)->char2byte() - 1) then (     if (i = 0) then (     line := line+("1") ) else     if ((i)->char2byte() - 1 < binary->size()) then (     line := line+(binary->at((i)->char2byte() - 1+1)) ) else (     line := line+("0") ) ;  ) else skip ; 
    out := out+("\n" + line) ; 
 )  ;     i := i + 1 ) ) ;  
    return out 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileInputStream ;
import java.io.FileOutputStream ;
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    for(int x=1 ; x<=t ; ++x){
      int b=scanner.nextInt();
      long m=scanner.nextLong();
      System.out.print("Case #"+x+": ");
      if(m>Math.pow(2,b-2)){
        System.out.print("IMPOSSIBLE\n");
        continue ;
      }
      else System.out.print("POSSIBLE\n");
      int[][] slides=new int[b][b];
      for(int i=0 ; i<b ; ++i){
        for(int j=i+1 ; j<b ; ++j){
          slides[i][j]=1 ;
        }
      }
      String str=Long.toBinaryString(m-1)+"" ;
      if(str.equals("0"))str="" ;
      while(str.length()<b-1){
        str="0"+str ;
      }
      str+="1" ;
      System.out.println(str);
      for(int i=1 ; i<b ; ++i){
        for(int j=0 ; j<b ; ++j){
          System.out.print(slides[i][j]);
        }
        System.out.print("\n");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         var x : int ; x := 1 ; while x <= t do ( (     var b : int ; b := scanner.getCurrent()->toInteger() ;
     var m : long ; m := scanner.getCurrent()->toLong() ;
    OclFile["System.out"].print("Case #" + x + ": ") ; 
    if (m > 2->pow(b - 2)) then (     OclFile["System.out"].print("IMPOSSIBLE\n") ; 
     continue ) else     OclFile["System.out"].print("POSSIBLE\n") ; ;  
    var slides : Sequence(Sequence(int)) ; slides := Integer.subrange(1,b)->collect(Integer.subrange(1,b)->collect(0)) ;
        var i : int ; i := 0 ; while i < b do ( (         var j : int ; j := i + 1 ; while j < b do ( (     slides[i+1][j+1] := 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var str : String ; str := (MathLib.decimal2binary(m - 1) + "") + "" ;
    if (str = "0") then     str := "" ; else skip ; 
    while (str->size() < b - 1) do (     str := "0" + str ) ; 
    str := str+("1") ; 
    OclFile["System.out"].println(str) ; 
        var i : int ; i := 1 ; while i < b do ( (         var j : int ; j := 0 ; while j < b do ( (     OclFile["System.out"].print(slides[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) ; 
 )  ;     x := x + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class B {
  public static void main(String[] args){
    new B().run();
  }
  BufferedReader br ;
  StringTokenizer in ;
  PrintWriter out ;
  public String nextToken()throws IOException {
    while(in==null || ! in.hasMoreTokens()){
      in=new StringTokenizer(br.readLine());
    }
    return in.nextToken();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  public void solve()throws IOException {
    int n=nextInt();
    long b=nextLong();
    if(b>1L<<(n-2)){
      out.println("IMPOSSIBLE");
      return ;
    }
    int[][] a=new int[n][n];
    for(int i=1 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        a[i][j]=1 ;
      }
    }
    b--;
    a[0][n-1]=1 ;
    for(int i=n-2 ; i>=0 ; i--){
      if(b % 2==1){
        a[0][i]=1 ;
      }
      b/=2 ;
    }
    out.println("POSSIBLE");
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        out.print(a[i][j]);
      }
      out.println();
    }
  }
  public void run(){
    try {
      br=new BufferedReader(new FileReader("input.txt"));
      out=new PrintWriter("output.txt");
      int t=nextInt();
      for(int i=0 ; i<t ; i++){
        out.print(String.format("Case #%d: ",i+1));
        solve();
      }
      out.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     B.newB().run() );
   attribute br : OclFile;
   attribute in : OclIterator;
   attribute out : OclFile;
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (in = null or not(in.hasNext())) do (     in := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return in.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var b : long ; b := nextLong() ;
    if (b > (1L*(2->pow((n - 2))))->oclAsType(long)) then (     skip ; 
     return ) else skip ; 
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     a[i+1][j+1] := 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    b := b - 1 ; 
    a[0+1][n - 1+1] := 1 ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (b mod 2 = 1) then (     a[0+1][i+1] := 1 ) else skip ; 
     b := b/(2) )  ;     i := i - 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     skip )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ; 
    var t : int ; t := nextInt() ;
        var i : int ; i := 0 ; while i < t do ( (     skip ; 
     execute solve() )  ;     i := i + 1 ) ; 
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  static int N ;
  static int ans ;
  public static void main(String...orange)throws Exception {
    Scanner input=new Scanner(System.in);
    int numCases=input.nextInt();
    for(int n=0 ; n<numCases ; n++){
      int B=input.nextInt();
      long M=input.nextLong();
      if(M>(1L<<(B-2))){
        System.out.printf("Case #%d: IMPOSSIBLE\n",n+1);
        continue ;
      }
      boolean[][] slides=new boolean[B][B];
      if(M==(1L<<(B-2))){
        for(int i=0 ; i<B ; i++)for(int j=i+1 ; j<B ; j++)slides[i][j]=true ;
      }
      for(int i=0 ; i+1<B ; i++)for(int j=i+1 ; j+1<B ; j++)slides[i][j]=true ;
      for(int i=0 ; i+2<B ; i++)if((M &(1L<<i))>0)slides[i+1][B-1]=true ;
      System.out.printf("Case #%d: POSSIBLE\n",n+1);
      for(int i=0 ; i<B ; i++){
        for(int j=0 ; j<B ; j++)System.out.print(slides[i][j] ? '1' : '0');
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute N : int;
  static   attribute ans : int;
  static   operation main( orange : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numCases : int ; numCases := input.getCurrent()->toInteger() ;
         var n : int ; n := 0 ; while n < numCases do ( (     var B : int ; B := input.getCurrent()->toInteger() ;
     var M : long ; M := input.getCurrent()->toLong() ;
    if (M > ((1L*(2->pow((B - 2))))->oclAsType(long))) then (     OclFile["System.out"].printf("Case #%d: IMPOSSIBLE\n", n + 1) ; 
     continue ) else skip ; 
    var slides : Sequence(Sequence(boolean)) ; slides := Integer.subrange(1,B)->collect(Integer.subrange(1,B)->collect(false)) ;
    if (M = ((1L*(2->pow((B - 2))))->oclAsType(long))) then (         var i : int ; i := 0 ; while i < B do (         var j : int ; j := i + 1 ; while j < B do (     slides[i+1][j+1] := true ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ) else skip ; 
        var i : int ; i := 0 ; while i + 1 < B do (         var j : int ; j := i + 1 ; while j + 1 < B do (     slides[i+1][j+1] := true ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i + 2 < B do (     if ((MathLib.bitwiseAnd(M,((1L*(2->pow(i)))->oclAsType(long)))) > 0) then     slides[i + 1+1][B - 1+1] := true ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("Case #%d: POSSIBLE\n", n + 1) ; 
        var i : int ; i := 0 ; while i < B do ( (         var j : int ; j := 0 ; while j < B do (     OclFile["System.out"].print(if slides[i+1][j+1] then '1' else '0' endif) ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 )  ;     n := n + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int k=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; ++i){
        a[i]=sc.nextInt();
      }
      System.out.println(solve(a,k));
    }
    sc.close();
  }
  static String solve(int[] a,int k){
    for(int i=0 ; i<a.length-1 ; ++i){
      while(a[i]!=0 && k!=0){
--a[i];
++a[a.length-1];
--k ;
      }
    }
    return Arrays.stream(a).mapToObj(String :: valueOf).collect(Collectors.joining(" "));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(a, k)) ; 
 )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : Sequence(int), k : int) : String
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < a->size() - 1 do ( (     while (a[i+1] /= 0 & k /= 0) do (     a[i+1] := a[i+1] - 1 ; 
     a[a->size() - 1+1] := a[a->size() - 1+1] + 1 ; 
     k := k - 1 ) )  ;     i := i + 1 ) ; 
     return stream(a).mapToObj(lambda _pars : OclAny in String.newString().valueOf(_pars)).collect(Collectors.joining(" ")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package Round1 ;
import java.io.*;
public class B {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new FileReader("/Users/chao/Downloads/B-large.in"));
    FileWriter out=new FileWriter("/Users/chao/Desktop/B-large.txt");
    String s=in.readLine();
    int m=Integer.parseInt(s);
    for(int cases=1 ; cases<=m ; cases++){
      String[] ss=in.readLine().split(" ");
      int B=Integer.parseInt(ss[0]);
      long M=Long.parseLong(ss[1]);
      out.write("Case #"+cases+": ");
      int n=B ;
      long max=pow(B-2);
      if(max>=M){
        out.write("POSSIBLE\n");
        int[][] map=new int[n][n];
        for(int i=1 ; i<n ; i++){
          for(int j=i+1 ; j<n ; j++){
            map[i][j]=1 ;
          }
        }
        for(int k=1 ; k<n ; k++){
          if(k!=n-1)max=max/2 ;
          if(max<=M){
            M-=max ;
            map[0][k]=1 ;
          }
        }
        for(int i=0 ; i<n ; i++){
          for(int j=0 ; j<n ; j++){
            out.write(""+map[i][j]);
          }
          out.write("\n");
        }
      }
      else {
        out.write("IMPOSSIBLE\n");
      }
    }
    in.close();
    out.flush();
    out.close();
  }
  private static long pow(int n){
    long x=1 ;
    for(int i=0 ; i<n ; i++){
      x*=2 ;
    }
    return x ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("/Users/chao/Downloads/B-large.in"))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("/Users/chao/Desktop/B-large.txt")) ;
    var s : String ; s := in.readLine() ;
    var m : int ; m := (s)->toInteger() ;
        var cases : int ; cases := 1 ; while cases <= m do ( (     var ss : Sequence(String) ; ss := in.readLine()->split(" ") ;
     var B : int ; B := (ss[0+1])->toInteger() ;
    var M : long ; M := (ss[1+1])->toLong() ;
    skip ; 
    var n : int ; n := B ;
    var max : long ; max := pow(B - 2) ;
    if (max >= M) then (     skip ; 
     var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     map[i+1][j+1] := 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var k : int ; k := 1 ; while k < n do ( (     if (k /= n - 1) then     max := max / 2 ; else skip ; 
     if (max <= M) then (     M := M-(max) ; 
     map[0+1][k+1] := 1 ) else skip )  ;     k := k + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     skip )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
 ) else (     skip ) ;  
 )  ;     cases := cases + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation pow( n : int) : long
  pre: true
  post: true
  activity: (     var x : long ; x := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     x := x*(2) )  ;     i := i + 1 ) ; 
     return x );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPrime(int N){
    if(N<2)return false ;
    if(N<4)return true ;
    if((N & 1)==0)return false ;
    if(N % 3==0)return false ;
    int curr=5,s=(int)Math.sqrt(N);
    while(curr<=s){
      if(N % curr==0)return false ;
      curr+=2 ;
      if(N % curr==0)return false ;
      curr+=4 ;
    }
    return true ;
  }
  static boolean check(int s,int p,int prefix_sum[],int n){
    boolean satisfies=true ;
    for(int i=0 ; i<n ; i++){
      if(i+s-1>=n)break ;
      if(prefix_sum[i+s-1]-(i-1>=0 ? prefix_sum[i-1] : 0)<p)satisfies=false ;
    }
    return satisfies ;
  }
  static int minimumWindowSize(int x,int y,int p){
    int[] prefix_sum=new int[y-x+1];
    for(int i=x ; i<=y ; i++){
      if(isPrime(i))prefix_sum[i-x]=1 ;
    }
    for(int i=1 ; i<y-x+1 ; i++)prefix_sum[i]+=prefix_sum[i-1];
    int low=1,high=y-x+1 ;
    int mid ;
    while(high-low>1){
      mid=(low+high)/2 ;
      if(check(mid,p,prefix_sum,y-x+1)){
        high=mid ;
      }
      else low=mid ;
    }
    if(check(low,p,prefix_sum,y-x+1))return low ;
    return high ;
  }
  public static void main(String[] args){
    int x=12 ;
    int y=42 ;
    int p=3 ;
    System.out.print(minimumWindowSize(x,y,p));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPrime( N : int) : boolean
  pre: true
  post: true
  activity: (     if (N < 2) then     return false else skip ; 
     if (N < 4) then     return true else skip ; 
    if ((N & 1) = 0) then     return false else skip ; 
    if (N mod 3 = 0) then     return false else skip ; 
    var curr : int ; curr := 5 ;
    var s : int ; s := (N)->sqrt()->oclAsType(int) ;
    while (curr <= s) do (     if (N mod curr = 0) then     return false else skip ; 
     curr := curr+(2) ; 
     if (N mod curr = 0) then     return false else skip ; 
     curr := curr+(4) ) ; 
    return true 
 );
  static   operation check( s : int, p : int, prefix_sum : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var satisfies : boolean ; satisfies := true ;
         var i : int ; i := 0 ; while i < n do ( (     if (i + s - 1 >= n) then     break else skip ; 
     if (prefix_sum[i + s - 1+1] - (if i - 1 >= 0 then prefix_sum[i - 1+1] else 0 endif) < p) then     satisfies := false ; else skip )  ;     i := i + 1 ) ; 
     return satisfies );
  static   operation minimumWindowSize( x : int, y : int, p : int) : int
  pre: true
  post: true
  activity: (     var prefix_sum : Sequence(int) ; prefix_sum := Integer.subrange(1,y - x + 1)->collect(0) ;
         var i : int ; i := x ; while i <= y do ( (     if (isPrime(i)) then     prefix_sum[i - x+1] := 1 ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < y - x + 1 do (     prefix_sum[i+1] := prefix_sum[i+1]+(prefix_sum[i - 1+1]) ;  ;     i := i + 1 ) ; 
    var low : int ; low := 1 ;
    var high : int ; high := y - x + 1 ;
    var mid : int ;
    while (high - low > 1) do (     mid := (low + high) / 2 ; 
     if (check(mid, p, prefix_sum, y - x + 1)) then (     high := mid ) else     low := mid ; ) ; 
    if (check(low, p, prefix_sum, y - x + 1)) then     return low else skip ; 
    return high 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 12 ;
     var y : int ; y := 42 ;
     var p : int ; p := 3 ;
     OclFile["System.out"].print(minimumWindowSize(x, y, p)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
import java.io.*;
class GFG {
  static boolean checkPerfectSquare(double n){
    double d=Math.sqrt(n);
    if(d*d==n)return true ;
    return false ;
  }
  static int largestPerfectSquareNumber(int a[],double n){
    int maxi=-1 ;
    for(int i=0 ; i<n ; i++){
      if(checkPerfectSquare(a[i]))maxi=Math.max(a[i],maxi);
    }
    return maxi ;
  }
  public static void main(String[] args){
    int[] a={
      16,20,25,2,3,10 };
      double n=a.length ;
      System.out.println(largestPerfectSquareNumber(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkPerfectSquare( n : double) : boolean
  pre: true
  post: true
  activity: (     var d : double ; d := (n)->sqrt() ;
     if (d * d = n) then     return true else skip ; 
     return false );
  static   operation largestPerfectSquareNumber( a : Sequence(int), n : double) : int
  pre: true
  post: true
  activity: (     var maxi : int ; maxi := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (checkPerfectSquare(a[i+1])) then     maxi := Set{a[i+1], maxi}->max() ; else skip )  ;     i := i + 1 ) ; 
     return maxi );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{16,20,25,2,3,10} ;
     var n : double ; n := a->size() ;
     OclFile["System.out"].println(largestPerfectSquareNumber(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class node {
    int data ;
    node next ;
  }
  static node add(int data){
    node newnode=new node();
    newnode.data=data ;
    newnode.next=null ;
    return newnode ;
  }
  static void printArr(int a[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(a[i]+" ");
  }
  static int findlength(node head){
    node curr=head ;
    int cnt=0 ;
    while(curr!=null){
      cnt++;
      curr=curr.next ;
    }
    return cnt ;
  }
  static void convertArr(node head){
    int len=findlength(head);
    int[] arr=new int[len];
    int index=0 ;
    node curr=head ;
    while(curr!=null){
      arr[index++]=curr.data ;
      curr=curr.next ;
    }
    printArr(arr,len);
  }
  public static void main(String[] args){
    node head=new node();
    head=add(1);
    head.next=add(2);
    head.next.next=add(3);
    head.next.next.next=add(4);
    head.next.next.next.next=add(5);
    convertArr(head);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class node {
   attribute data : int;
   attribute next : node;
}
  static   operation add( data : int) : node
  pre: true
  post: true
  activity: (     var newnode : node ; newnode := node.newnode() ;
     newnode.data := data ; 
     newnode.next := null ; 
     return newnode );
  static   operation printArr( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation findlength( head : node) : int
  pre: true
  post: true
  activity: (     var curr : node ; curr := head ;
     var cnt : int ; cnt := 0 ;
     while (curr /= null) do (     cnt := cnt + 1 ; 
     curr := curr.next ) ; 
     return cnt );
  static   operation convertArr( head : node) : void
  pre: true
  post: true
  activity: (     var len : int ; len := findlength(head) ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,len)->collect(0) ;
    var index : int ; index := 0 ;
    var curr : node ; curr := head ;
    while (curr /= null) do (      arr[index+1] := curr.data  ; index := index + 1 ; 
     curr := curr.next ) ; 
    execute printArr(arr, len) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : node ; head := node.newnode() ;
     head := add(1) ; 
    head.next := add(2) ; 
    head.next.next := add(3) ; 
    head.next.next.next := add(4) ; 
    head.next.next.next.next := add(5) ; 
    execute convertArr(head) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int compress(char[] chars){
    int anchor=0,write=0 ;
    for(int read=0 ; read<chars.length ; read++){
      if(read+1==chars.length || chars[read+1]!=chars[read]){
        chars[write++]=chars[anchor];
        if(read>anchor){
          for(char c :(""+(read-anchor+1)).toCharArray()){
            chars[write++]=c ;
          }
        }
        anchor=read+1 ;
      }
    }
    return write ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation compress( chars : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var anchor : int ; anchor := 0 ;
    var write : int ; write := 0 ;
         var read : int ; read := 0 ; while read < chars->size() do ( (     if (read + 1 = chars->size() or chars[read + 1+1] /= chars[read+1]) then (      chars[write+1] := chars[anchor+1]  ; write := write + 1 ; 
     if (read > anchor) then (     for (c : ("" + (read - anchor + 1))->characters()) do ( (      chars[write+1] := c  ; write := write + 1 )  ) ) else skip ; 
     anchor := read + 1 ) else skip )  ;     read := read + 1 ) ; 
     return write );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void checkPalindrome(int num){
    String str=Integer.toString(num);
    int l=0,r=str.length()-1 ;
    while(l<r){
      if(str.charAt(l)!=str.charAt(r)){
        System.out.print("No");
        return ;
      }
      l++;
      r--;
    }
    System.out.print("Yes");
    return ;
  }
  public static void main(String args[]){
    int n=19,k=3 ;
    checkPalindrome(n+k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkPalindrome( num : int) : void
  pre: true
  post: true
  activity: (     var str : String ; str := ((num) + "") ;
     var l : int ; l := 0 ;
    var r : int ; r := str->size() - 1 ;
    while (l < r) do (     if (str->at(l+1) /= str->at(r+1)) then (     OclFile["System.out"].print("No") ; 
     return ) else skip ; 
     l := l + 1 ; 
     r := r - 1 ) ; 
    OclFile["System.out"].print("Yes") ; 
    return 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 19 ;
    var k : int ; k := 3 ;
     execute checkPalindrome(n + k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isVowel(char c){
    return(c=='a' || c=='e' || c=='i' || c=='o' || c=='u');
  }
  static int countSubstringsUtil(char[] s){
    int count=0 ;
    Map<Character,Integer>mp=new HashMap<>();
    int n=s.length ;
    int start=0 ;
    for(int i=0 ; i<n ; i++){
      if(mp.containsKey(s[i])){
        mp.put(s[i],mp.get(s[i])+1);
      }
      else {
        mp.put(s[i],1);
      }
      while(mp.containsKey('a')&& mp.containsKey('e')&& mp.containsKey('i')&& mp.containsKey('o')&& mp.containsKey('u')&& mp.get('a')>0 && mp.get('e')>0 && mp.get('i')>0 && mp.get('o')>0 && mp.get('u')>0){
        count+=n-i ;
        mp.put(s[start],mp.get(s[start])-1);
        start++;
      }
    }
    return count ;
  }
  static int countSubstrings(String s){
    int count=0 ;
    String temp="" ;
    for(int i=0 ; i<s.length(); i++){
      if(isVowel(s.charAt(i))){
        temp+=s.charAt(i);
      }
      else {
        if(temp.length()>0)count+=countSubstringsUtil(temp.toCharArray());
        temp="" ;
      }
    }
    if(temp.length()>0)count+=countSubstringsUtil(temp.toCharArray());
    return count ;
  }
  public static void main(String[] args){
    String s="aeouisddaaeeiouua" ;
    System.out.println(countSubstrings(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isVowel( c : String) : boolean
  pre: true
  post: true
  activity: (     return (c = 'a' or c = 'e' or c = 'i' or c = 'o' or c = 'u') );
  static   operation countSubstringsUtil( s : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var mp : Map(String,int) ; mp := Map{} ;
    var n : int ; n := s->size() ;
    var start : int ; start := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (mp->keys()->includes(s[i+1])) then (     mp := mp->union(Map{s[i+1] |-> mp->at(s[i+1]) + 1}) ) else (     mp := mp->union(Map{s[i+1] |-> 1}) ) ;  
     while (mp->keys()->includes('a') & mp->keys()->includes('e') & mp->keys()->includes('i') & mp->keys()->includes('o') & mp->keys()->includes('u') & mp->at('a') > 0 & mp->at('e') > 0 & mp->at('i') > 0 & mp->at('o') > 0 & mp->at('u') > 0) do (     count := count+(n - i) ; 
     mp := mp->union(Map{s[start+1] |-> mp->at(s[start+1]) - 1}) ; 
     start := start + 1 ) )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation countSubstrings( s : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var temp : String ; temp := "" ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (isVowel(s->at(i+1))) then (     temp := temp+(s->at(i+1)) ) else (     if (temp->size() > 0) then     count := count+(countSubstringsUtil(temp->characters())) ; else skip ; 
     temp := "" ) )  ;     i := i + 1 ) ; 
    if (temp->size() > 0) then     count := count+(countSubstringsUtil(temp->characters())) ; else skip ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "aeouisddaaeeiouua" ;
     OclFile["System.out"].println(countSubstrings(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class CF239B {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int q=s.nextInt();
    String str=s.next();
    while(q-->0){
      int[] count=new int[10];
      StringBuilder sb=new StringBuilder("");
      int l=s.nextInt()-1 ;
      int r=s.nextInt()-1 ;
      int pointer=0 ;
      sb=sb.append(str.substring(l,r+1));
      boolean flag1=false,flag2=false ;
      while(pointer>=0 && pointer<sb.length()){
        if(sb.charAt(pointer)=='0'){
          count[0]++;
          sb.deleteCharAt(pointer);
          if(flag2)pointer-=1 ;
        }
        else if(sb.charAt(pointer)>='1' && sb.charAt(pointer)<='9'){
          count[sb.charAt(pointer)-'0']++;
          sb.replace(pointer,pointer+1,Character.toString((char)((int)sb.charAt(pointer)-1)));
          if(flag2)pointer-=1 ;
          else pointer+=1 ;
        }
        else {
          int intial=pointer ;
          if(sb.charAt(pointer)=='>'){
            flag1=true ;
            flag2=false ;
          }
          else {
            flag1=false ;
            flag2=true ;
          }
          pointer+=(flag1 ? 1 :-1);
          if(pointer>=0 && pointer<sb.length()&&(sb.charAt(pointer)=='>' || sb.charAt(pointer)=='<')){
            sb.deleteCharAt(intial);
            if(flag1)pointer-=1 ;
          }
        }
      }
      for(int i=0 ; i<10 ; i++){
        System.out.print(count[i]+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF239B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var q : int ; q := s.getCurrent()->toInteger() ;
    var str : String ; str := s.getCurrent() ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     var count : Sequence(int) ; count := Integer.subrange(1,10)->collect(0) ;
     var sb : String ; sb := StringLib.newString("") ;
    var l : int ; l := s.getCurrent()->toInteger() - 1 ;
    var r : int ; r := s.getCurrent()->toInteger() - 1 ;
    var pointer : int ; pointer := 0 ;
    sb := sb + StringLib.newString(str.subrange(l+1,r + 1)) ;     sb := sb + StringLib.newString(str.subrange(l+1,r + 1)) ; 
    var flag1 : boolean ; flag1 := false ;
    var flag2 : boolean ; flag2 := false ;
    while (pointer >= 0 & pointer < sb->size()) do (     if (sb->at(pointer+1) = '0') then (     count[0+1] := count[0+1] + 1 ; 
     sb := sb->excludingAt(pointer+1) ; 
     if (flag2) then     pointer := pointer-(1) ; else skip ) else     if (sb->at(pointer+1) >= '1' & sb->at(pointer+1) <= '9') then (     count[sb->at(pointer+1) - ('0')->char2byte()+1] := count[sb->at(pointer+1) - ('0')->char2byte()+1] + 1 ; 
     sb.replace(pointer, pointer + 1, ((sb->at(pointer+1)->oclAsType(int) - 1)->oclAsType(String) + "")) ; 
     if (flag2) then     pointer := pointer-(1) ; else     pointer := pointer+(1) ; ) else (     var intial : int ; intial := pointer ;
     if (sb->at(pointer+1) = '>') then (     flag1 := true ; 
     flag2 := false ) else (     flag1 := false ; 
     flag2 := true ) ;  
     pointer := pointer+((if flag1 then 1 else -1 endif)) ; 
     if (pointer >= 0 & pointer < sb->size() & (sb->at(pointer+1) = '>' or sb->at(pointer+1) = '<')) then (     sb := sb->excludingAt(intial+1) ; 
     if (flag1) then     pointer := pointer-(1) ; else skip ) else skip ) ;  ) ; 
        var i : int ; i := 0 ; while i < 10 do ( (     OclFile["System.out"].print(count[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int setAllBitsAfterMSB(int n){
    n |=n>>1 ;
    n |=n>>2 ;
    n |=n>>4 ;
    n |=n>>8 ;
    n |=n>>16 ;
    return n ;
  }
  static int toggle(int n){
    n=n ^ setAllBitsAfterMSB(n);
    return n ;
  }
  public static void main(String arg[]){
    int n=10 ;
    n=toggle(n);
    System.out.print(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation setAllBitsAfterMSB( n : int) : int
  pre: true
  post: true
  activity: (     n := MathLib.bitwiseOr(n, (n/(2->pow(1)))->oclAsType(long)) ; 
     n := MathLib.bitwiseOr(n, (n/(2->pow(2)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(4)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(8)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(16)))->oclAsType(long)) ; 
    return n 
 );
  static   operation toggle( n : int) : int
  pre: true
  post: true
  activity: (     n := n xor setAllBitsAfterMSB(n) ; 
     return n );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     n := toggle(n) ; 
     OclFile["System.out"].print(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Data {
    double x,y ;
    public Data(double x,double y){
      super();
      this.x=x ;
      this.y=y ;
    }
  };
  static double inv_interpolate(Data[] d,int n,double y){
    double x=0 ;
    int i,j ;
    for(i=0 ; i<n ; i++){
      double xi=d[i] .x ;
      for(j=0 ; j<n ; j++){
        if(j!=i){
          xi=xi*(y-d[j] .y)/(d[i] .y-d[j] .y);
        }
      }
      x+=xi ;
    }
    return x ;
  }
  public static void main(String[] args){
    Data[] d={
      new Data(1.27,2.3),new Data(2.25,2.95),new Data(2.5,3.5),new Data(3.6,5.1)};
      int n=4 ;
      double y=4.5 ;
      System.out.printf("Value of x at y=4.5 : %.5f",inv_interpolate(d,n,y));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Data {
   attribute x : double;
   static operation newData( x : double, y : double) : Data
  pre: true
  post: true
  activity:
  ( var self : Data ;
    self := createData();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     execute super() ; 
     self.x := x ; 
     self.y := y );
}
  static   operation inv_interpolate( d : Sequence(Data), n : int, y : double) : double
  pre: true
  post: true
  activity: (     var x : double ; x := 0 ;
     var i : int ;
    var j : int ;
         i := 0 ; while i < n do ( (     var xi : double ; xi := d[i+1].x ;
         j := 0 ; while j < n do ( (     if (j /= i) then (     xi := xi * (y - d[j+1].y) / (d[i+1].y - d[j+1].y) ) else skip )  ;     j := j + 1 ) ; 
     x := x+(xi) )  ;     i := i + 1 ) ; 
     return x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : Sequence(Data) ; d := Sequence{Data.newData(1.27, 2.3),Data.newData(2.25, 2.95),Data.newData(2.5, 3.5),Data.newData(3.6, 5.1)} ;
     var n : int ; n := 4 ;
     var y : double ; y := 4.5 ;
     OclFile["System.out"].printf("Value of x at y=4.5 : %.5f", inv_interpolate(d, n, y)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findElement(int arr[],int n){
    int prefixMul[]=new int[n];
    prefixMul[0]=arr[0];
    for(int i=1 ; i<n ; i++)prefixMul[i]=prefixMul[i-1]*arr[i];
    int suffixMul[]=new int[n];
    suffixMul[n-1]=arr[n-1];
    for(int i=n-2 ; i>=0 ; i--)suffixMul[i]=suffixMul[i+1]*arr[i];
    for(int i=1 ; i<n-1 ; i++)if(prefixMul[i]==suffixMul[i])return arr[i];
    return-1 ;
  }
  public static void main(String args[]){
    int arr[]={
      2,3,4,1,4,6 };
      int n=arr.length ;
      System.out.println(findElement(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findElement( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var prefixMul : Sequence(int) ; prefixMul := Integer.subrange(1,n)->collect(0) ;
     prefixMul[0+1] := arr[0+1] ; 
        var i : int ; i := 1 ; while i < n do (     prefixMul[i+1] := prefixMul[i - 1+1] * arr[i+1] ;  ;     i := i + 1 ) ; 
    var suffixMul : Sequence(int) ; suffixMul := Integer.subrange(1,n)->collect(0) ;
    suffixMul[n - 1+1] := arr[n - 1+1] ; 
        var i : int ; i := n - 2 ; while i >= 0 do (     suffixMul[i+1] := suffixMul[i + 1+1] * arr[i+1] ;  ;     i := i - 1 ) ; 
        var i : int ; i := 1 ; while i < n - 1 do (     if (prefixMul[i+1] = suffixMul[i+1]) then     return arr[i+1] else skip ;  ;     i := i + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4,1,4,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findElement(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static float ellipse(float l,float b){
    if(l<0 || b<0)return-1 ;
    float x=(float)(3.14*l*b)/4 ;
    return x ;
  }
  public static void main(String args[]){
    float a=5,b=3 ;
    System.out.println(ellipse(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation ellipse( l : double, b : double) : double
  pre: true
  post: true
  activity: (     if (l < 0 or b < 0) then     return -1 else skip ; 
     var x : double ; x := (3.14 * l * b)->oclAsType(double) / 4 ;
     return x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 5 ;
    var b : double ; b := 3 ;
     OclFile["System.out"].println(ellipse(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int numberOfDays(int a,int b,int n){
    int Days=b*(n+a)/(a+b);
    return Days ;
  }
  public static void main(String[] args){
    int a=10,b=20,n=5 ;
    System.out.println(numberOfDays(a,b,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation numberOfDays( a : int, b : int, n : int) : int
  pre: true
  post: true
  activity: (     var Days : int ; Days := b * (n + a) / (a + b) ;
     return Days );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 10 ;
    var b : int ; b := 20 ;
    var n : int ; n := 5 ;
     OclFile["System.out"].println(numberOfDays(a, b, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class hw13 {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    {
    }
    {
      int t=scan.nextInt();
      while(t-->0){
        int n=scan.nextInt();
        String in=scan.next();
        int letter=in.charAt(0);
        StringBuilder toPrint=new StringBuilder();
        toPrint.append(in.charAt(0));
        for(int i=1 ; i<n ; i++){
          if(letter>in.charAt(i)&& i==1){
            letter=in.charAt(i);
            toPrint.append(in.charAt(i));
          }
          else if(letter>=in.charAt(i)&& i>1){
            letter=in.charAt(i);
            toPrint.append(in.charAt(i));
          }
          else {
            break ;
          }
        }
        StringBuilder rev=new StringBuilder(toPrint.reverse());
        toPrint.reverse();
        toPrint.append(rev);
        System.out.println(toPrint);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class hw13 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 skip 
 (     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var in : String ; in := scan.getCurrent() ;
    var letter : int ; letter := in->at(0+1) ;
    var toPrint : String ; toPrint := StringLib.newString() ;
    toPrint := toPrint + StringLib.newString(in->at(0+1)) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (letter > in->at(i+1) & i = 1) then (     letter := in->at(i+1) ; 
     toPrint := toPrint + StringLib.newString(in->at(i+1)) ) else     if (letter >= in->at(i+1) & i > 1) then (     letter := in->at(i+1) ; 
     toPrint := toPrint + StringLib.newString(in->at(i+1)) ) else (     break ) ;  )  ;     i := i + 1 ) ; 
    var rev : String ; rev := StringLib.newString(toPrint->reverse()) ;
    toPrint := toPrint->reverse() ; 
    toPrint := toPrint + StringLib.newString(rev) ; 
    OclFile["System.out"].println(toPrint) ; 
 ) ;  ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int nonDecNums(int n){
    int[][] a=new int[n+1][10];
    for(int i=0 ; i<=9 ; i++)a[0][i]=1 ;
    for(int i=1 ; i<=n ; i++)a[i][9]=1 ;
    for(int i=1 ; i<=n ; i++)for(int j=8 ; j>=0 ; j--)a[i][j]=a[i-1][j]+a[i][j+1];
    return a[n][0];
  }
  public static void main(String[] args){
    int n=2 ;
    System.out.println("Non-decreasing digits="+nonDecNums(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nonDecNums( n : int) : int
  pre: true
  post: true
  activity: (     var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,10)->collect(0)) ;
         var i : int ; i := 0 ; while i <= 9 do (     a[0+1][i+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (     a[i+1][9+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (         var j : int ; j := 8 ; while j >= 0 do (     a[i+1][j+1] := a[i - 1+1][j+1] + a[i+1][j + 1+1] ;  ;     j := j - 1 ) ;  ;     i := i + 1 ) ; 
    return a[n+1][0+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println("Non-decreasing digits=" + nonDecNums(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf1616B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    while(t-->0){
      int n=scan.nextInt();
      char[] charArr=scan.next().toCharArray();
      if(n>1 && charArr[0]==charArr[1]){
        String ans=""+charArr[0]+charArr[0];
        System.out.println(ans);
      }
      else {
        int dummy=0 ;
        for(int i=1 ; i<n ; i++){
          if(charArr[i]<=charArr[i-1]){
            dummy=i ;
          }
          else {
            break ;
          }
        }
        StringBuilder out=new StringBuilder();
        for(int i=0 ; i<=dummy ; i++){
          out.append(charArr[i]);
        }
        StringBuilder str1=new StringBuilder(out.reverse());
        out.reverse().append(str1);
        System.out.println(out);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1616B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var charArr : Sequence(String) ; charArr := scan.getCurrent()->characters() ;
     if (n > 1 & charArr[0+1] = charArr[1+1]) then (     var ans : String ; ans := "" + charArr[0+1] + charArr[0+1] ;
     OclFile["System.out"].println(ans) ) else (     var dummy : int ; dummy := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     if (charArr[i+1] <= charArr[i - 1+1]) then (     dummy := i ) else (     break ) )  ;     i := i + 1 ) ; 
    var out : String ; out := StringLib.newString() ;
        var i : int ; i := 0 ; while i <= dummy do ( (     out := out + StringLib.newString(charArr[i+1]) )  ;     i := i + 1 ) ; 
    var str1 : String ; str1 := StringLib.newString(out->reverse()) ;
    out := out->reverse() + StringLib.newString(str1) ; 
    OclFile["System.out"].println(out) ; 
 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf1616B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    for(int i=0 ; i<n ; i++){
      int x=scan.nextInt();
      String str=scan.next();
      StringBuilder str2=new StringBuilder();
      char min='z'+1 ;
      char prevMin=min ;
      for(int y=0 ; y<x ; y++){
        char c=str.charAt(y);
        if(c<min){
          prevMin=min ;
          min=c ;
          str2.append(c);
        }
        else if(c==min){
          boolean found=false ;
          if(prevMin>c && prevMin!='z'+1){
            str2.append(c);
            found=true ;
          }
          if(! found){
            break ;
          }
        }
        else {
          break ;
        }
      }
      System.out.print(str2);
      System.out.print(str2.reverse());
      System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1616B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := scan.getCurrent()->toInteger() ;
     var str : String ; str := scan.getCurrent() ;
    var str2 : String ; str2 := StringLib.newString() ;
    var min : String ; min := 'z' + 1 ;
    var prevMin : String ; prevMin := min ;
        var y : int ; y := 0 ; while y < x do ( (     var c : String ; c := str->at(y+1) ;
     if (c < min) then (     prevMin := min ; 
     min := c ; 
     str2 := str2 + StringLib.newString(c) ) else     if (c = min) then (     var found : boolean ; found := false ;
     if (prevMin > c & prevMin /= 'z' + 1) then (     str2 := str2 + StringLib.newString(c) ; 
     found := true ) else skip ; 
     if (not(found)) then (     break ) else skip ) else (     break ) ;  )  ;     y := y + 1 ) ; 
    OclFile["System.out"].print(str2) ; 
    OclFile["System.out"].print(str2->reverse()) ; 
    OclFile["System.out"].println("") ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int t=1 ; t<=test ; t++){
      int n=in.nextInt();
      String s=in.next();
      char ch=s.charAt(0);
      int count=0 ;
      for(int i=1 ; i<s.length(); i++){
        if(s.charAt(i)<s.charAt(i-1)|| s.charAt(i)==s.charAt(i-1)&& i>1){
          count=i ;
          ch=s.charAt(i);
        }
        else {
          break ;
        }
      }
      for(int i=0 ; i<=count ; i++){
        pw.print(s.charAt(i));
      }
      for(int i=count ; i>=0 ; i--){
        pw.print(s.charAt(i));
      }
      pw.println();
    }
    pw.close();
  }
  public static String rev(String s){
    StringBuilder sb=new StringBuilder(s);
    sb=sb.reverse();
    String r=sb.toString();
    return r ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= test do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var s : String ; s := in.getCurrent() ;
    var ch : String ; ch := s->at(0+1) ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < s->size() do ( (     if (s->at(i+1) < s->at(i - 1+1) or s->at(i+1) = s->at(i - 1+1) & i > 1) then (     count := i ; 
     ch := s->at(i+1) ) else (     break ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= count do ( (     skip )  ;     i := i + 1 ) ; 
        var i : int ; i := count ; while i >= 0 do ( (     skip )  ;     i := i - 1 ) ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation rev( s : String) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString(s) ;
     sb := sb->reverse() ;     sb := sb->reverse() ; 
     var r : String ; r := sb+"" ;
     return r );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int MAX=100005 ;
  static HashSet<Integer>fibonacci=new HashSet<Integer>();
  static void createHash(){
    int prev=0,curr=1 ;
    fibonacci.add(prev);
    fibonacci.add(curr);
    while(curr<=MAX){
      int temp=curr+prev ;
      fibonacci.add(temp);
      prev=curr ;
      curr=temp ;
    }
  }
  static boolean checkArray(int arr[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)if(fibonacci.contains(arr[i]))sum+=arr[i];
    if(fibonacci.contains(sum))return true ;
    return false ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,4,8,2 };
      int n=arr.length ;
      createHash();
      if(checkArray(arr,n))System.out.print("Yes");
      else System.out.print("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX : int := 100005;
  static   attribute fibonacci : Set(int) := Set{};
  static   operation createHash() : void
  pre: true
  post: true
  activity: (     var prev : int ; prev := 0 ;
    var curr : int ; curr := 1 ;
     fibonacci := fibonacci->including(prev) ; 
     fibonacci := fibonacci->including(curr) ; 
     while (curr <= MAX) do (     var temp : int ; temp := curr + prev ;
     fibonacci := fibonacci->including(temp) ; 
     prev := curr ; 
     curr := temp ) );
  static   operation checkArray( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     if (fibonacci->includes(arr[i+1])) then     sum := sum+(arr[i+1]) ; else skip ;  ;     i := i + 1 ) ; 
     if (fibonacci->includes(sum)) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,4,8,2} ;
     var n : int ; n := arr->size() ;
     execute createHash() ; 
     if (checkArray(arr, n)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static int solve(int health[],int n){
    int currentgcd=gcd(health[0],health[1]);
    for(int i=2 ; i<n ; ++i){
      currentgcd=gcd(currentgcd,health[i]);
    }
    return currentgcd ;
  }
  public static void main(String args[]){
    int health[]={
      4,6,8,12 };
      int n=health.length ;
      System.out.println(solve(health,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation solve( health : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var currentgcd : int ; currentgcd := gcd(health[0+1], health[1+1]) ;
         var i : int ; i := 2 ; while i < n do ( (     currentgcd := gcd(currentgcd, health[i+1]) )  ;     i := i + 1 ) ; 
     return currentgcd );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var health : Sequence(int) ; health := Sequence{4,6,8,12} ;
     var n : int ; n := health->size() ;
     OclFile["System.out"].println(solve(health, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float squarearea(float r){
    if(r<0)return-1 ;
    float a=4*(float)(Math.pow(r,2)/5);
    return a ;
  }
  public static void main(String[] args){
    float r=5 ;
    System.out.println(squarearea(r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation squarearea( r : double) : double
  pre: true
  post: true
  activity: (     if (r < 0) then     return -1 else skip ; 
     var a : double ; a := 4 * (r->pow(2) / 5)->oclAsType(double) ;
     return a );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : double ; r := 5 ;
     OclFile["System.out"].println(squarearea(r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GFG {
  static class Graph {
    int V ;
    LinkedList<Integer>[] adj ;
    Graph(int V){
      this.V=V ;
      adj=new LinkedList[V];
      for(int i=0 ; i<adj.length ; i++)adj[i]=new LinkedList<Integer>();
    }
    void addEdge(int v,int w){
      adj[v] .add(w);
    }
    void DFSUtil(int s,Vector<Boolean>visited){
      Stack<Integer>stack=new Stack<>();
      stack.push(s);
      while(stack.empty()==false){
        s=stack.peek();
        stack.pop();
        if(visited.get(s)==false){
          System.out.print(s+" ");
          visited.set(s,true);
        }
        Iterator<Integer>itr=adj[s] .iterator();
        while(itr.hasNext()){
          int v=itr.next();
          if(! visited.get(v))stack.push(v);
        }
      }
    }
    void DFS(){
      Vector<Boolean>visited=new Vector<Boolean>(V);
      for(int i=0 ; i<V ; i++)visited.add(false);
      for(int i=0 ; i<V ; i++)if(! visited.get(i))DFSUtil(i,visited);
    }
  }
  public static void main(String[] args){
    Graph g=new Graph(5);
    g.addEdge(1,0);
    g.addEdge(2,1);
    g.addEdge(3,4);
    g.addEdge(4,0);
    System.out.println("Following is Depth First Traversal");
    g.DFS();
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Graph {
   attribute V : int;
   attribute adj : Sequence(Sequence(int));
   static operation newGraph( V : int) : Graph
  pre: true
  post: true
  activity:
  ( var self : Graph ;
    self := createGraph();
    self.initialise(V);
    return self );
  operation initialise( V : int) : void
  pre: true  post: true
  activity: (     self.V := V ; 
     adj := Integer.subrange(1,V)->collect(null) ; 
         var i : int ; i := 0 ; while i < adj->size() do (     adj[i+1] := Sequence{} ;  ;     i := i + 1 ) );
   operation addEdge( v : int, w : int) : void
  pre: true
  post: true
  activity: (     adj[v+1]->excludes(w) );
   operation DFSUtil( s : int, visited : Sequence(Boolean)) : void
  pre: true
  post: true
  activity: (     var stack : Sequence(int) ; stack := Sequence{} ;
     stack := stack->append(s) ; 
     while (stack->isEmpty() = false) do (     s := stack->min() ; 
     stack := stack->front() ; 
    if (visited->at(s+1) = false) then (     OclFile["System.out"].print(s + " ") ; 
     visited := visited.setAt(s+1, true) ) else skip ; 
    var itr : OclIterator ; itr := adj[s+1]->iterator() ;
    while (itr.hasNext()) do (     var v : int ; v := itr.next() ;
     if (not(visited->at(v+1))) then     stack := stack->append(v) ; else skip ) ; 
 ) );
   operation DFS() : void
  pre: true
  post: true
  activity: (     var visited : Sequence(Boolean) ; visited := Sequence{} ;
         var i : int ; i := 0 ; while i < V do (     visited := visited->including(false) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < V do (     if (not(visited->at(i+1))) then     execute DFSUtil(i, visited) ; else skip ;  ;     i := i + 1 ) );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : Graph ; g := Graph.newGraph(5) ;
     g.addEdge(1, 0) ; 
    g.addEdge(2, 1) ; 
    g.addEdge(3, 4) ; 
    g.addEdge(4, 0) ; 
    OclFile["System.out"].println("Following is Depth First Traversal") ; 
    g.DFS() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GFG {
  static class Graph {
    int V ;
    LinkedList<Integer>[] adj ;
    Graph(int V){
      this.V=V ;
      adj=new LinkedList[V];
      for(int i=0 ; i<adj.length ; i++)adj[i]=new LinkedList<Integer>();
    }
    void addEdge(int v,int w){
      adj[v] .add(w);
    }
    void DFS(int s){
      Vector<Boolean>visited=new Vector<Boolean>(V);
      for(int i=0 ; i<V ; i++)visited.add(false);
      Stack<Integer>stack=new Stack<>();
      stack.push(s);
      while(stack.empty()==false){
        s=stack.peek();
        stack.pop();
        if(visited.get(s)==false){
          System.out.print(s+" ");
          visited.set(s,true);
        }
        Iterator<Integer>itr=adj[s] .iterator();
        while(itr.hasNext()){
          int v=itr.next();
          if(! visited.get(v))stack.push(v);
        }
      }
    }
  }
  public static void main(String[] args){
    Graph g=new Graph(5);
    g.addEdge(1,0);
    g.addEdge(0,2);
    g.addEdge(2,1);
    g.addEdge(0,3);
    g.addEdge(1,4);
    System.out.println("Following is the Depth First Traversal");
    g.DFS(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Graph {
   attribute V : int;
   attribute adj : Sequence(Sequence(int));
   static operation newGraph( V : int) : Graph
  pre: true
  post: true
  activity:
  ( var self : Graph ;
    self := createGraph();
    self.initialise(V);
    return self );
  operation initialise( V : int) : void
  pre: true  post: true
  activity: (     self.V := V ; 
     adj := Integer.subrange(1,V)->collect(null) ; 
         var i : int ; i := 0 ; while i < adj->size() do (     adj[i+1] := Sequence{} ;  ;     i := i + 1 ) );
   operation addEdge( v : int, w : int) : void
  pre: true
  post: true
  activity: (     adj[v+1]->excludes(w) );
   operation DFS( s : int) : void
  pre: true
  post: true
  activity: (     var visited : Sequence(Boolean) ; visited := Sequence{} ;
         var i : int ; i := 0 ; while i < V do (     visited := visited->including(false) ;  ;     i := i + 1 ) ; 
    var stack : Sequence(int) ; stack := Sequence{} ;
    stack := stack->append(s) ; 
    while (stack->isEmpty() = false) do (     s := stack->min() ; 
     stack := stack->front() ; 
    if (visited->at(s+1) = false) then (     OclFile["System.out"].print(s + " ") ; 
     visited := visited.setAt(s+1,true) ) else skip ; 
    var itr : OclIterator ; itr := adj[s+1]->iterator() ;
    while (itr.hasNext()) do (     var v : int ; v := itr.next() ;
     if (not(visited->at(v+1))) then     stack := stack->append(v) ; else skip ) ; 
 ) ; 
 );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : Graph ; g := Graph.newGraph(5) ;
     g.addEdge(1, 0) ; 
    g.addEdge(0, 2) ; 
    g.addEdge(2, 1) ; 
    g.addEdge(0, 3) ; 
    g.addEdge(1, 4) ; 
    OclFile["System.out"].println("Following is the Depth First Traversal") ; 
    g.DFS(0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class MainClass {
  public static void main(String[] agrs){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] lst=new int[n];
    for(int i=0 ; i<n ; i++)lst[i]=sc.nextInt();
    int res=0 ;
    for(int i=1 ; i<n-1 ; i++){
      if(lst[i]==0 && lst[i-1]==1 && lst[i+1]==1){
        res+=1 ;
        if(i<=n-4){
          if(lst[i+2]==0 && lst[i+3]==1){
            i+=3 ;
          }
        }
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var lst : Sequence(int) ; lst := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     lst[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 1 ; while i < n - 1 do ( (     if (lst[i+1] = 0 & lst[i - 1+1] = 1 & lst[i + 1+1] = 1) then (     res := res+(1) ; 
     if (i <= n - 4) then (     if (lst[i + 2+1] = 0 & lst[i + 3+1] = 1) then (     i := i+(3) ) else skip ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    TreeSet<Integer>plusSet=new TreeSet<>();
    TreeSet<Integer>minusOneSet=new TreeSet<>();
    TreeMap<Integer,Integer>minusMap=new TreeMap<>();
    for(int i=1 ; i<=n ; i++){
      int x=sc.nextInt();
      if(x>1){
        plusSet.add(i);
      }
      else if(x==-1){
        minusOneSet.add(i);
      }
      else if(x<-1){
        minusMap.put(i,x);
      }
    }
    if(minusMap.size()% 2==1){
      if(minusOneSet.size()>0){
        plusSet.addAll(minusMap.keySet());
        plusSet.add(minusOneSet.first());
      }
      else {
        int min=Integer.MAX_VALUE ;
        int minIdx=0 ;
        for(Map.Entry<Integer,Integer>entry : minusMap.entrySet()){
          if(min>=entry.getValue()){
            min=entry.getValue();
            minIdx=entry.getKey();
          }
        }
        minusMap.remove(minIdx);
        plusSet.addAll(minusMap.keySet());
      }
    }
    else {
      plusSet.addAll(minusMap.keySet());
    }
    StringBuilder sb=new StringBuilder();
    sb.append(plusSet.size()).append("\n");
    for(int x : plusSet){
      sb.append(x).append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var plusSet : Set(int) ; plusSet := Set{} ;
    var minusOneSet : Set(int) ; minusOneSet := Set{} ;
    var minusMap : Map(int,int) ; minusMap := Map{} ;
        var i : int ; i := 1 ; while i <= n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x > 1) then (     plusSet := plusSet->including(i) ) else     if (x = -1) then (     minusOneSet := minusOneSet->including(i) ) else     if (x < -1) then (     minusMap := minusMap->union(Map{i |-> x}) ) else skip ; ;  )  ;     i := i + 1 ) ; 
    if (minusMap.size() mod 2 = 1) then (     if (minusOneSet->size() > 0) then (     plusSet := plusSet->union(minusMap->keys()) ; 
     plusSet := plusSet->including(minusOneSet->first()) ) else (     var min : int ; min := 2147483647 ;
     var minIdx : int ; minIdx := 0 ;
    for (entry : minusMap->asSet()) do ( (     if (min >= entry.getValue()) then (     min := entry.getValue() ; 
     minIdx := entry.getKey() ) else skip )  ) ; 
    minusMap := minusMap->antirestrict(Set{minIdx}) ; 
    plusSet := plusSet->union(minusMap->keys()) ; 
 ) ) else (     plusSet := plusSet->union(minusMap->keys()) ) ;  
    var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString(plusSet->size()) + StringLib.newString("\n") ; 
    for (x : plusSet) do ( (     sb := sb + StringLib.newString(x) + StringLib.newString("\n") )  ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class29 {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      HashSet<Long>st=new HashSet<>();
      int i,flag=0 ;
      long a[]=new long[n];
      int vis[]=new int[n];
      for(i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
        long val=(i+a[i])% n ;
        if(val<0){
          val+=n ;
        }
        vis[(int)val]=1 ;
      }
      for(i=0 ; i<n ; i++){
        if(vis[i]==0){
          flag=1 ;
          break ;
        }
      }
      if(flag==0)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class29 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var st : Set(long) ; st := Set{} ;
    var i : int ;
    var flag : int ; flag := 0 ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var vis : Sequence(int) ; vis := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     var val : long ; val := (i + a[i+1]) mod n ;
     if (val < 0) then (     val := val+(n) ) else skip ; 
     vis[val->oclAsType(int)+1] := 1 )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     if (vis[i+1] = 0) then (     flag := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 0) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.awt.geom.Point2D ;
import java.awt.geom.Point2D.Double ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
import java.util.TreeSet ;
import java.lang.Object ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new D().doIt();
  }
  class D {
    ArrayList<ArrayList<Integer>>array=new ArrayList<ArrayList<Integer>>();
    void doIt(){
      String str=sc.next();
      int length=str.length();
      for(int c=0 ; c<26 ; c++){
        array.add(new ArrayList<Integer>());
      }
      for(int i=0 ; i<length ; i++){
        array.get(str.charAt(i)-'a').add(i);
      }
      int s=-1 ;
      int g=-1 ;
      for(int c=0 ; c<26 ; c++){
        ArrayList<Integer>array2=new ArrayList<Integer>();
        array2=array.get(c);
        int length2=array2.size();
        if(length2>1){
          for(int i=1 ; i<length2 ; i++){
            if(array2.get(i)-array2.get(i-1)<=2){
              s=array2.get(i-1)+1 ;
              g=array2.get(i)+1 ;
            }
          }
        }
      }
      System.out.println(s+" "+g);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     D.newD().doIt() );
 class D {
   attribute array : Sequence(Sequence(int)) := Sequence{};
   operation doIt() : void
  pre: true
  post: true
  activity: (     var str : String ; str := sc.getCurrent() ;
     var length : int ; length := str->size() ;
        var c : int ; c := 0 ; while c < 26 do ( (     array := array->including(Sequence{}) )  ;     c := c + 1 ) ; 
        var i : int ; i := 0 ; while i < length do ( (     array->at(str->at(i+1) - ('a')->char2byte()+1)->excludes(i) )  ;     i := i + 1 ) ; 
    var s : int ; s := -1 ;
    var g : int ; g := -1 ;
        var c : int ; c := 0 ; while c < 26 do ( (     var array2 : Sequence(int) ; array2 := Sequence{} ;
     array2 := array->at(c+1) ; 
     var length2 : int ; length2 := array2->size() ;
     if (length2 > 1) then (         var i : int ; i := 1 ; while i < length2 do ( (     if (array2->at(i+1) - array2->at(i - 1+1) <= 2) then (     s := array2->at(i - 1+1) + 1 ; 
     g := array2->at(i+1) + 1 ) else skip )  ;     i := i + 1 ) ) else skip )  ;     c := c + 1 ) ; 
    OclFile["System.out"].println(s + " " + g) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int ngs=s.length();
    int[][] unko=new int[26][ngs+1];
    for(int i=0 ; i<26 ; i++){
      for(int j=0 ; j<=ngs ; j++){
        unko[i][j]=0 ;
      }
    }
    for(int i=0 ; i<ngs ; i++){
      unko[s.charAt(i)-97][i+1]++;
    }
    for(int i=0 ; i<26 ; i++){
      for(int j=1 ; j<=ngs ; j++){
        unko[i][j]=unko[i][j]+unko[i][j-1];
      }
    }
    int l=0 ;
    int r=0 ;
    int tmp=0 ;
    for(int i=0 ; i<26 ; i++){
      for(int j=0 ; j<=ngs-2 ; j++){
        if(unko[i][j+2]-unko[i][j]==2){
          System.out.println(j+1+" "+(j+2));
          System.exit(0);
        }
      }
      for(int j=0 ; j<=ngs-3 ; j++){
        if(unko[i][j+3]-unko[i][j]>=2){
          System.out.println(j+1+" "+(j+3));
          System.exit(0);
        }
      }
    }
    System.out.println(-1+" "+-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var ngs : int ; ngs := s->size() ;
    var unko : Sequence(Sequence(int)) ; unko := Integer.subrange(1,26)->collect(Integer.subrange(1,ngs + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < 26 do ( (         var j : int ; j := 0 ; while j <= ngs do ( (     unko[i+1][j+1] := 0 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < ngs do ( (     unko[s->at(i+1) - 97+1][i + 1+1] := unko[s->at(i+1) - 97+1][i + 1+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 26 do ( (         var j : int ; j := 1 ; while j <= ngs do ( (     unko[i+1][j+1] := unko[i+1][j+1] + unko[i+1][j - 1+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    var tmp : int ; tmp := 0 ;
        var i : int ; i := 0 ; while i < 26 do ( (         var j : int ; j := 0 ; while j <= (ngs)->char2byte() - 2 do ( (     if (unko[i+1][j + 2+1] - unko[i+1][j+1] = 2) then (     OclFile["System.out"].println(j + 1 + " " + (j + 2)) ; 
 OclProcess.exit(0) ) else skip )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j <= (ngs)->char2byte() - 3 do ( (     if (unko[i+1][j + 3+1] - unko[i+1][j+1] >= 2) then (     OclFile["System.out"].println(j + 1 + " " + (j + 3)) ; 
 OclProcess.exit(0) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(-1 + " " + -1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public void main(Scanner sc){
    char s[]=sc.next().toCharArray();
    int len=s.length ;
    int a=-1 ;
    int b=-1 ;
    for(int i=0 ; i<len-1 ; i++){
      if(s[i]==s[i+1]){
        a=i+1 ;
        b=i+2 ;
        break ;
      }
      if(i+2<len && s[i]==s[i+2]){
        a=i+1 ;
        b=i+3 ;
        break ;
      }
    }
    System.out.println(a+" "+b);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    new Main().main(sc);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := sc.next()->characters() ;
     var len : int ; len := s->size() ;
    var a : int ; a := -1 ;
    var b : int ; b := -1 ;
        var i : int ; i := 0 ; while i < (len)->char2byte() - 1 do ( (     if (s[i+1] = s[i + 1+1]) then (     a := i + 1 ; 
     b := i + 2 ; 
     break ) else skip ; 
     if (i + 2 < len & s[i+1] = s[i + 2+1]) then (     a := i + 1 ; 
     b := i + 3 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a + " " + b) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Main.newMain().main(sc) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner scanner=new Scanner(System.in);
    solve(scanner);
  }
  static void solve(Scanner scanner){
    String s=scanner.nextLine();
    if(s.charAt(0)==s.charAt(1)){
      System.out.printf("%d %d\n",1,2);
      return ;
    }
    for(int i=0 ; i<s.length()-2 ; i++){
      char c1=s.charAt(i);
      char c2=s.charAt(i+1);
      char c3=s.charAt(i+2);
      if(c1==c2 || c1==c3 || c2==c3){
        System.out.printf("%d %d\n",i+1,i+3);
        return ;
      }
    }
    System.out.printf("%d %d\n",-1,-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute solve(scanner) );
  static   operation solve( scanner : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := scanner.nextLine() ;
     if (s->at(0+1) = s->at(1+1)) then (     OclFile["System.out"].printf("%d %d\n", 1, 2) ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < s->size() - 2 do ( (     var c1 : String ; c1 := s->at(i+1) ;
     var c2 : String ; c2 := s->at(i + 1+1) ;
     var c3 : String ; c3 := s->at(i + 2+1) ;
     if (c1 = c2 or c1 = c3 or c2 = c3) then (     OclFile["System.out"].printf("%d %d\n", i + 1, i + 3) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].printf("%d %d\n", -1, -1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void sequence(int n){
    int f[]=new int[n+1];
    f[0]=0 ;
    f[1]=1 ;
    f[2]=1 ;
    System.out.print(f[1]+" "+f[2]+" ");
    for(int i=3 ; i<=n ; i++){
      f[i]=f[f[i-1] ]+f[i-f[i-1] ];
      System.out.print(f[i]+" ");
    }
  }
  public static void main(String[] args){
    int n=13 ;
    sequence(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sequence( n : int) : void
  pre: true
  post: true
  activity: (     var f : Sequence(int) ; f := Integer.subrange(1,n + 1)->collect(0) ;
     f[0+1] := 0 ; 
    f[1+1] := 1 ; 
    f[2+1] := 1 ; 
    OclFile["System.out"].print(f[1+1] + " " + f[2+1] + " ") ; 
        var i : int ; i := 3 ; while i <= n do ( (     f[i+1] := f[f[i - 1+1]+1] + f[i - f[i - 1+1]+1] ; 
     OclFile["System.out"].print(f[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 13 ;
     execute sequence(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B855 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    long P=in.nextLong();
    long Q=in.nextLong();
    long R=in.nextLong();
    long[] A=new long[N];
    for(int n=0 ; n<N ; n++){
      A[n]=in.nextInt();
    }
    long[] maxP=new long[N];
    maxP[0]=P*A[0];
    for(int n=1 ; n<N ; n++){
      maxP[n]=Math.max(maxP[n-1],P*A[n]);
    }
    long[] maxQ=new long[N];
    maxQ[0]=maxP[0]+Q*A[0];
    for(int n=1 ; n<N ; n++){
      maxQ[n]=Math.max(maxQ[n-1],Q*A[n]+maxP[n]);
    }
    long answer=maxQ[0]+R*A[0];
    for(int n=1 ; n<N ; n++){
      answer=Math.max(answer,R*A[n]+maxQ[n]);
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B855 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var P : long ; P := in.getCurrent()->toLong() ;
    var Q : long ; Q := in.getCurrent()->toLong() ;
    var R : long ; R := in.getCurrent()->toLong() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var maxP : Sequence(long) ; maxP := Integer.subrange(1,N)->collect(0) ;
    maxP[0+1] := P * A[0+1] ; 
        var n : int ; n := 1 ; while n < N do ( (     maxP[n+1] := Set{maxP[n - 1+1], P * A[n+1]}->max() )  ;     n := n + 1 ) ; 
    var maxQ : Sequence(long) ; maxQ := Integer.subrange(1,N)->collect(0) ;
    maxQ[0+1] := maxP[0+1] + Q * A[0+1] ; 
        var n : int ; n := 1 ; while n < N do ( (     maxQ[n+1] := Set{maxQ[n - 1+1], Q * A[n+1] + maxP[n+1]}->max() )  ;     n := n + 1 ) ; 
    var answer : long ; answer := maxQ[0+1] + R * A[0+1] ;
        var n : int ; n := 1 ; while n < N do ( (     answer := Set{answer, R * A[n+1] + maxQ[n+1]}->max() )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p063 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p063().run());
  }
  public String run(){
    int count=0 ;
    for(int n=1 ; n<=9 ; n++){
      for(int k=1 ; k<=21 ; k++){
        if(BigInteger.valueOf(n).pow(k).toString().length()==k)count++;
      }
    }
    return Integer.toString(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p063 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p063.newp063().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var n : int ; n := 1 ; while n <= 9 do ( (         var k : int ; k := 1 ; while k <= 21 do ( (     if ((n + "")->toLong().pow(k)+""->size() = k) then     count := count + 1 ; else skip )  ;     k := k + 1 ) )  ;     n := n + 1 ) ; 
     return ((count) + "") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static void main(String[] args){
    double n=12 ;
    System.out.println(Math.sqrt(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 12 ;
     OclFile["System.out"].println((n)->sqrt()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double findSum(long n){
    return Math.sqrt(3)*(n*(n+1)/2);
  }
  public static void main(String[] args){
    long n=10 ;
    System.out.println(findSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSum( n : long) : double
  pre: true
  post: true
  activity: (     return (3)->sqrt() * (n * (n + 1) / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 10 ;
     OclFile["System.out"].println(findSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      while(sc.hasNext()){
        int m=sc.nextInt();
        int nmin=sc.nextInt();
        int nmax=sc.nextInt();
        if(m+nmin+nmax==0)break ;
        int[] p=new int[m+1];
        for(int i=1 ; i<=m ; i++){
          p[i]=sc.nextInt();
        }
        int gap=0 ;
        int n=0 ;
        for(int i=nmin ; i<=nmax ; i++){
          if(gap<=p[i]-p[i+1] && n<i){
            gap=p[i]-p[i+1];
            n=i ;
          }
        }
        System.out.println(n);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (sc.hasNext()) do (     var m : int ; m := sc.getCurrent()->toInteger() ;
     var nmin : int ; nmin := sc.getCurrent()->toInteger() ;
    var nmax : int ; nmax := sc.getCurrent()->toInteger() ;
    if (m + nmin + nmax = 0) then     break else skip ; 
    var p : Sequence(int) ; p := Integer.subrange(1,m + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= m do ( (     p[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var gap : int ; gap := 0 ;
    var n : int ; n := 0 ;
        var i : int ; i := nmin ; while i <= nmax do ( (     if (gap <= p[i+1] - p[i + 1+1] & n < i) then (     gap := p[i+1] - p[i + 1+1] ; 
     n := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n) ; 
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class C16 {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t>0){
      int n=s.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=s.nextInt();
      HashSet<Integer>h=new HashSet<>();
      for(int i=0 ; i<n ; i++){
        if(a[i]<0)h.add((i+(n-((-1*a[i])% n)))% n);
        else h.add((i+(a[i] % n))% n);
      }
      if(h.size()==n)System.out.println("YES");
      else System.out.println("NO");
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C16 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := s.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var h : Set(int) ; h := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] < 0) then     h := h->including((i + (n - ((-1 * a[i+1]) mod n))) mod n) ; else     h := h->including((i + (a[i+1] mod n)) mod n) ; )  ;     i := i + 1 ) ; 
    if (h->size() = n) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int alternate(int a,int b,int x){
    return x=a ^ b ^ x ;
  }
  public static void main(String[] args){
    int a=-10 ;
    int b=15 ;
    int x=a ;
    System.out.print("x is : "+x);
    x=alternate(a,b,x);
    System.out.print("\nAfter exchange ");
    System.out.print("\nx is : "+x);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation alternate( a : int, b : int, x : int) : int
  pre: true
  post: true
  activity: (     return x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := -10 ;
     var b : int ; b := 15 ;
    var x : int ; x := a ;
    OclFile["System.out"].print("x is : " + x) ; 
    x := alternate(a, b, x) ; 
    OclFile["System.out"].print("\nAfter exchange ") ; 
    OclFile["System.out"].print("\nx is : " + x) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
class GFG {
  public static int findNth(int n){
    int nthElement=19+(n-1)*9 ;
    int outliersCount=(int)Math.log10(nthElement)-1 ;
    nthElement+=9*outliersCount ;
    return nthElement ;
  }
  public static void main(String[] args){
    System.out.println(findNth(5));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNth( n : int) : int
  pre: true
  post: true
  activity: (     var nthElement : int ; nthElement := 19 + (n - 1) * 9 ;
     var outliersCount : int ; outliersCount := (nthElement)->log10()->oclAsType(int) - 1 ;
     nthElement := nthElement+(9 * outliersCount) ; 
     return nthElement );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(findNth(5)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  public static double per(double a,double b){
    return(a+b);
  }
  public static double area(double s){
    return(s/2);
  }
  public static void main(String[] args){
    double a=7,b=8,s=10 ;
    System.out.println(per(a,b));
    System.out.println(area(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation per( a : double, b : double) : double
  pre: true
  post: true
  activity: (     return (a + b) );
  static   operation area( s : double) : double
  pre: true
  post: true
  activity: (     return (s / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 7 ;
    var b : double ; b := 8 ;
    var s : double ; s := 10 ;
     OclFile["System.out"].println(per(a, b)) ; 
     OclFile["System.out"].println(area(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Solution {
  static boolean isBinary(int n){
    while(n!=0){
      int temp=n % 10 ;
      if(temp!=0 && temp!=1){
        return false ;
      }
      n=n/10 ;
    }
    return true ;
  }
  static void formBinaryStr(int n,int a[]){
    boolean flag=true ;
    String s="" ;
    for(int i=0 ; i<n ; i++){
      if(isBinary(a[i]))s+=""+a[i];
      else {
        flag=false ;
        break ;
      }
    }
    if(flag)System.out.print(s+"\n");
    else System.out.print("-1\n");
  }
  public static void main(String args[]){
    int a[]={
      10,1,0,11,10 };
      int N=a.length ;
      formBinaryStr(N,a);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation isBinary( n : int) : boolean
  pre: true
  post: true
  activity: (     while (n /= 0) do (     var temp : int ; temp := n mod 10 ;
     if (temp /= 0 & temp /= 1) then (     return false ) else skip ; 
     n := n / 10 ) ; 
     return true );
  static   operation formBinaryStr( n : int, a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var flag : boolean ; flag := true ;
     var s : String ; s := "" ;
         var i : int ; i := 0 ; while i < n do ( (     if (isBinary(a[i+1])) then     s := s+("" + a[i+1]) ; else (     flag := false ; 
     break ) )  ;     i := i + 1 ) ; 
     if (flag) then     OclFile["System.out"].print(s + "\n") ; else     OclFile["System.out"].print("-1\n") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{10,1,0,11,10} ;
     var N : int ; N := a->size() ;
     execute formBinaryStr(N, a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.List ;
class GFG {
  static int getMax(int[] A){
    int max=Integer.MIN_VALUE ;
    for(int i : A){
      max=Math.max(max,i);
    }
    return max ;
  }
  static int calculateAND(int arr[],int n){
    int max_val=getMax(arr);
    boolean prime[]=new boolean[max_val+1];
    int i ;
    for(i=0 ; i<max_val+1 ; i++)prime[i]=true ;
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=max_val ; p++){
      if(prime[p]==true){
        for(i=p*2 ; i<=max_val ; i+=p)prime[i]=false ;
      }
    }
    int S1=0,S2=0 ;
    for(i=0 ; i<n ; i++){
      if(prime[arr[i] ]){
        S1+=arr[i];
      }
      else if(arr[i]!=1){
        S2+=arr[i];
      }
    }
    return(S1 & S2);
  }
  public static void main(String[] args){
    int arr[]={
      3,4,6,7 };
      int n=arr.length ;
      System.out.println(calculateAND(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getMax( A : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var max : int ; max := -2147483648 ;
     for (i : A) do ( (     max := Set{max, i}->max() )  ) ; 
     return max );
  static   operation calculateAND( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max_val : int ; max_val := getMax(arr) ;
     var prime : Sequence(boolean) ; prime := Integer.subrange(1,max_val + 1)->collect(false) ;
    var i : int ;
        i := 0 ; while i < max_val + 1 do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
    prime[0+1] := false ; 
    prime[1+1] := false ; 
        var p : int ; p := 2 ; while p * p <= max_val do ( (     if (prime[p+1] = true) then (         i := p * 2 ; while i <= max_val do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var S1 : int ; S1 := 0 ;
    var S2 : int ; S2 := 0 ;
        i := 0 ; while i < n do ( (     if (prime[arr[i+1]+1]) then (     S1 := S1+(arr[i+1]) ) else     if (arr[i+1] /= 1) then (     S2 := S2+(arr[i+1]) ) else skip ; )  ;     i := i + 1 ) ; 
    return (MathLib.bitwiseAnd(S1,S2)) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,4,6,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(calculateAND(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] a=new int[n];
      int[] b=new int[n];
      int suma=0 ;
      int sumb=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
        b[i]=sc.nextInt();
        suma+=a[i];
        sumb+=b[i];
      }
      Arrays.sort(a);
      Arrays.sort(b);
      int W=0 ;
      if(suma-a[n-1]<a[n-1])W=a[n-1]-(suma-a[n-1]);
      if(W==0){
        System.out.println(suma+sumb);
      }
      else {
        int[][] dp=new int[n][W+1];
        for(int i=0 ; i<n-1 ; i++){
          for(int j=0 ; j<=W ; j++){
            if(j<b[i])dp[i+1][j]=dp[i][j];
            else dp[i+1][j]=Math.max(dp[i][j],dp[i][j-b[i] ]+b[i]);
          }
        }
        System.out.println(2*a[n-1]+(sumb-dp[n-1][W]));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var suma : int ; suma := 0 ;
    var sumb : int ; sumb := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() ; 
     suma := suma+(a[i+1]) ; 
     sumb := sumb+(b[i+1]) )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    var W : int ; W := 0 ;
    if (suma - a[n - 1+1] < a[n - 1+1]) then     W := a[n - 1+1] - (suma - a[n - 1+1]) ; else skip ; 
    if (W = 0) then (     OclFile["System.out"].println(suma + sumb) ) else (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,W + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := 0 ; while j <= W do ( (     if (j < b[i+1]) then     dp[i + 1+1][j+1] := dp[i+1][j+1] ; else     dp[i + 1+1][j+1] := Set{dp[i+1][j+1], dp[i+1][j - b[i+1]+1] + b[i+1]}->max() ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(2 * a[n - 1+1] + (sumb - dp[n - 1+1][W+1])) ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] r=new int[n],w=new int[n];
      int max=0,p=0,sumr=0,sumw=0 ;
      for(int i=0 ; i<n ; i++){
        r[i]=sc.nextInt();
        w[i]=sc.nextInt();
        if(r[i]>max){
          max=r[i];
          p=i ;
        }
        sumr+=r[i];
        sumw+=w[i];
      }
      if(sumr-max>=max){
        System.out.println((sumr+sumw));
      }
      else {
        boolean[] dp=new boolean[2*max-sumr+1];
        dp[0]=true ;
        for(int i=0 ; i<n ; i++)if(i!=p)for(int j=2*max-sumr ; j>=w[i]; j--)dp[j] |=dp[j-w[i] ];
        for(p=2*max-sumr ; ! dp[p]; p--);
        System.out.println((2*max+sumw-p));
      }
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var r : Sequence(int) ; r := Integer.subrange(1,n)->collect(0) ;
    var w : Sequence(int) ; w := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := 0 ;
    var p : int ; p := 0 ;
    var sumr : int ; sumr := 0 ;
    var sumw : int ; sumw := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     r[i+1] := sc.getCurrent()->toInteger() ; 
     w[i+1] := sc.getCurrent()->toInteger() ; 
    if (r[i+1] > max) then (     max := r[i+1] ; 
     p := i ) else skip ; 
    sumr := sumr+(r[i+1]) ; 
    sumw := sumw+(w[i+1]) ; 
 )  ;     i := i + 1 ) ; 
    if (sumr - max >= max) then (     OclFile["System.out"].println((sumr + sumw)) ) else (     var dp : Sequence(boolean) ; dp := Integer.subrange(1,2 * max - sumr + 1)->collect(false) ;
     dp[0+1] := true ; 
        var i : int ; i := 0 ; while i < n do (     if (i /= p) then         var j : int ; j := 2 * max - sumr ; while j >= w[i+1] do (     dp[j+1] := MathLib.bitwiseOr(dp[j+1], dp[j - w[i+1]+1]) ;  ;     j := j - 1 ) ; else skip ;  ;     i := i + 1 ) ; 
        p := 2 * max - sumr ; while not(dp[p+1]) do (   ;     p := p - 1 ) ; 
    OclFile["System.out"].println((2 * max + sumw - p)) ; 
 ) ;  
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int r[]=new int[n];
      int w[]=new int[n];
      int sumr=0,sumw=0,rmax=0,maxindex=-1 ;
      for(int i=0 ; i<n ; i++){
        r[i]=sc.nextInt();
        w[i]=sc.nextInt();
        sumr+=r[i];
        sumw+=w[i];
        if(rmax<r[i]){
          rmax=r[i];
          maxindex=i ;
        }
      }
      if(rmax<=(sumr-rmax)){
        System.out.println(sumr+sumw);
      }
      else {
        boolean dp[][]=new boolean[n+1][sumw+1];
        for(int i=0 ; i<n+1 ; i++){
          Arrays.fill(dp[i],false);
        }
        dp[0][0]=true ;
        for(int i=0 ; i<n ; i++){
          for(int j=0 ; j<=sumw ; j++){
            if(dp[i][j]){
              dp[i+1][j]=true ;
              if(i!=maxindex)dp[i+1][j+w[i] ]=true ;
            }
          }
        }
        int max=0 ;
        int wait=rmax-(sumr-rmax);
        for(int i=0 ; i<=n ; i++){
          for(int j=0 ; j<=sumw ; j++){
            if(dp[i][j]){
              if(j<=wait && max<j){
                max=j ;
              }
            }
          }
        }
        System.out.println(2*rmax+(sumw-max));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var r : Sequence(int) ; r := Integer.subrange(1,n)->collect(0) ;
    var w : Sequence(int) ; w := Integer.subrange(1,n)->collect(0) ;
    var sumr : int ; sumr := 0 ;
    var sumw : int ; sumw := 0 ;
    var rmax : int ; rmax := 0 ;
    var maxindex : int ; maxindex := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     r[i+1] := sc.getCurrent()->toInteger() ; 
     w[i+1] := sc.getCurrent()->toInteger() ; 
    sumr := sumr+(r[i+1]) ; 
    sumw := sumw+(w[i+1]) ; 
    if (rmax < r[i+1]) then (     rmax := r[i+1] ; 
     maxindex := i ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (rmax <= (sumr - rmax)) then (     OclFile["System.out"].println(sumr + sumw) ) else (     var dp : Sequence(Sequence(boolean)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,sumw + 1)->collect(false)) ;
         var i : int ; i := 0 ; while i < n + 1 do ( (     dp[i+1] := dp[i+1]->collect(false) )  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := true ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j <= sumw do ( (     if (dp[i+1][j+1]) then (     dp[i + 1+1][j+1] := true ; 
     if (i /= maxindex) then     dp[i + 1+1][j + w[i+1]+1] := true ; else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var wait : int ; wait := rmax - (sumr - rmax) ;
        var i : int ; i := 0 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= sumw do ( (     if (dp[i+1][j+1]) then (     if (j <= wait & max < j) then (     max := j ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(2 * rmax + (sumw - max)) ; 
 ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    while(true){
      int N=sc.nextInt();
      if(N==0)break ;
      Book[] books=new Book[N];
      for(int i=0 ; i<N ; ++i){
        int r=sc.nextInt();
        int w=sc.nextInt();
        books[i]=new Book(r,w);
      }
      Arrays.sort(books);
      int sumR=0 ;
      int sumW=0 ;
      for(int i=0 ; i<N ; ++i){
        sumR+=books[i] .r ;
        sumW+=books[i] .w ;
      }
      int maxR=books[N-1] .r ;
      if(sumR-maxR<maxR){
        int early=early(books,maxR-(sumR-maxR));
        System.out.println(Math.max(sumR+sumW,maxR*2+sumW-early));
      }
      else {
        System.out.println(sumR+sumW);
      }
    }
  }
  static int early(Book[] books,int time){
    boolean[] ok=new boolean[time+1];
    ok[0]=true ;
    for(int i=0 ; i<books.length-1 ; ++i){
      int w=books[i] .w ;
      for(int j=time ; j-w>=0 ; --j){
        if(ok[j-w])ok[j]=true ;
      }
    }
    for(int i=time ; i>=0 ; --i){
      if(ok[i])return i ;
    }
    return 0 ;
  }
  static class Book implements Comparable<Book>{
    int r,w ;
    public Book(int r,int w){
      this.r=r ;
      this.w=w ;
    }
    public int compareTo(Book o){
      return this.r-o.r ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then     break else skip ; 
    var books : Sequence(Book) ; books := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     var r : int ; r := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
     books[i+1] := Book.newBook(r, w) )  ;     i := i + 1 ) ; 
    books := books->sort() ; 
    var sumR : int ; sumR := 0 ;
    var sumW : int ; sumW := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     sumR := sumR+(books[i+1].r) ; 
     sumW := sumW+(books[i+1].w) )  ;     i := i + 1 ) ; 
    var maxR : int ; maxR := books[N - 1+1].r ;
    if (sumR - maxR < maxR) then (     var early : int ; early := early(books, maxR - (sumR - maxR)) ;
     OclFile["System.out"].println(Set{sumR + sumW, maxR * 2 + sumW - early}->max()) ) else (     OclFile["System.out"].println(sumR + sumW) ) ;  
 ) );
  static   operation early( books : Sequence(Book), time : int) : int
  pre: true
  post: true
  activity: (     var ok : Sequence(boolean) ; ok := Integer.subrange(1,time + 1)->collect(false) ;
     ok[0+1] := true ; 
        var i : int ; i := 0 ; while i < books->size() - 1 do ( (     var w : int ; w := books[i+1].w ;
         var j : int ; j := time ; while j - w >= 0 do ( (     if (ok[j - w+1]) then     ok[j+1] := true ; else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := time ; while i >= 0 do ( (     if (ok[i+1]) then     return i else skip )  ;     i := i - 1 ) ; 
    return 0 
 );
  static class Book implements Comparable<Book> {
   attribute r : int;
   static operation newBook( r : int, w : int) : Book
  pre: true
  post: true
  activity:
  ( var self : Book ;
    self := createBook();
    self.initialise(r, w);
    return self );
  operation initialise( r : int, w : int) : void
  pre: true  post: true
  activity: (     self.r := r ; 
     self.w := w );
   operation compareTo( o : Book) : int
  pre: true
  post: true
  activity: (     return self.r - o.r );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int findIndex(String str){
    int len=str.length();
    int open[]=new int[len+1];
    int close[]=new int[len+1];
    int index=-1 ;
    open[0]=0 ;
    close[len]=0 ;
    if(str.charAt(0)=='(')open[1]=1 ;
    if(str.charAt(len-1)==')')close[len-1]=1 ;
    for(int i=1 ; i<len ; i++){
      if(str.charAt(i)=='(')open[i+1]=open[i]+1 ;
      else open[i+1]=open[i];
    }
    for(int i=len-2 ; i>=0 ; i--){
      if(str.charAt(i)==')')close[i]=close[i+1]+1 ;
      else close[i]=close[i+1];
    }
    if(open[len]==0)return len ;
    if(close[0]==0)return 0 ;
    for(int i=0 ; i<=len ; i++)if(open[i]==close[i])index=i ;
    return index ;
  }
  public static void main(String[] args){
    String str="(()))(()()())))" ;
    System.out.println(findIndex(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findIndex( str : String) : int
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     var open : Sequence(int) ; open := Integer.subrange(1,len + 1)->collect(0) ;
    var close : Sequence(int) ; close := Integer.subrange(1,len + 1)->collect(0) ;
    var index : int ; index := -1 ;
    open[0+1] := 0 ; 
    close[len+1] := 0 ; 
    if (str->at(0+1) = '(') then     open[1+1] := 1 ; else skip ; 
    if (str->at(len - 1+1) = ')') then     close[len - 1+1] := 1 ; else skip ; 
        var i : int ; i := 1 ; while i < len do ( (     if (str->at(i+1) = '(') then     open[i + 1+1] := open[i+1] + 1 ; else     open[i + 1+1] := open[i+1] ; )  ;     i := i + 1 ) ; 
        var i : int ; i := len - 2 ; while i >= 0 do ( (     if (str->at(i+1) = ')') then     close[i+1] := close[i + 1+1] + 1 ; else     close[i+1] := close[i + 1+1] ; )  ;     i := i - 1 ) ; 
    if (open[len+1] = 0) then     return len else skip ; 
    if (close[0+1] = 0) then     return 0 else skip ; 
        var i : int ; i := 0 ; while i <= len do (     if (open[i+1] = close[i+1]) then     index := i ; else skip ;  ;     i := i + 1 ) ; 
    return index 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "(()))(()()())))" ;
     OclFile["System.out"].println(findIndex(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static int n ;
  static long a[];
  static long mod=0 ;
  static long mod_add(long a,long b){
    a=a % mod ;
    b=b % mod ;
    return(((a+b)% mod)+mod)% mod ;
  }
  static void solve(){
    HashMap<Long,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++)map.put((a[i]+i)% n,map.getOrDefault((a[i]+i)% n,0)+1);
    int res=0 ;
    for(int x : map.values()){
      int cnt=x ;
      res+=((cnt*(cnt-1))/2);
    }
    if(res>0)str.append("NO\n");
    else str.append("YES\n");
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    int q1=Integer.parseInt(bf.readLine().trim());
    while(q1-->0){
      n=Integer.parseInt(bf.readLine().trim());
      String s[]=bf.readLine().trim().split("\\s+");
      a=new long[n];
      for(int i=0 ; i<n ; i++){
        a[i]=Long.parseLong(s[i]);
        mod=n ;
        a[i]=mod_add(a[i],n);
      }
      solve();
    }
    pw.println(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute n : int;
  static   attribute a : Sequence(long);
  static   attribute mod : long := 0;
  static   operation mod_add( a : long, b : long) : long
  pre: true
  post: true
  activity: (     a := a mod mod ; 
     b := b mod mod ; 
     return (((a + b) mod mod) + mod) mod mod );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var map : Map(long,int) ; map := Map{} ;
         var i : int ; i := 0 ; while i < n do (     map := map->union(Map{(a[i+1] + i) mod n |-> (if map->keys()->contains((a[i+1] + i) mod n) then map->at((a[i+1] + i) mod n) else 0 endif) + 1}) ;  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    for (x : map->values()) do ( (     var cnt : int ; cnt := x ;
     res := res+(((cnt * (cnt - 1)) / 2)) )  ) ; 
    if (res > 0) then     str := str + StringLib.newString("NO\n") else     str := str + StringLib.newString("YES\n") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var q1 : int ; q1 := (bf.readLine()->trim())->toInteger() ;
        while (q1 > 0) do (        q1 := q1 - 1 ;     skip ; (     n := (bf.readLine()->trim())->toInteger() ; 
     var s : Sequence(String) ; s := bf.readLine()->trim()->split("\\s+") ;
    a := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (s[i+1])->toLong() ; 
     mod := n ; 
     a[i+1] := mod_add(a[i+1], n) )  ;     i := i + 1 ) ; 
    execute solve() ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int sumOfDigit(int K){
    int sod=0 ;
    while(K!=0){
      sod+=K % 10 ;
      K/=10 ;
    }
    return sod ;
  }
  static int totalNumbersWithSpecificDifference(int N,int diff){
    int low=1,high=N ;
    while(low<=high){
      int mid=(low+high)/2 ;
      if(mid-sumOfDigit(mid)<diff)low=mid+1 ;
      else high=mid-1 ;
    }
    return(N-high);
  }
  public static void main(String args[]){
    int N=13 ;
    int diff=2 ;
    System.out.println(totalNumbersWithSpecificDifference(N,diff));
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation sumOfDigit( K : int) : int
  pre: true
  post: true
  activity: (     var sod : int ; sod := 0 ;
     while (K /= 0) do (     sod := sod+(K mod 10) ; 
     K := K/(10) ) ; 
     return sod );
  static   operation totalNumbersWithSpecificDifference( N : int, diff : int) : int
  pre: true
  post: true
  activity: (     var low : int ; low := 1 ;
    var high : int ; high := N ;
     while (low <= high) do (     var mid : int ; mid := (low + high) / 2 ;
     if (mid - sumOfDigit(mid) < diff) then     low := mid + 1 ; else     high := mid - 1 ; ) ; 
     return (N - high) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 13 ;
     var diff : int ; diff := 2 ;
     OclFile["System.out"].println(totalNumbersWithSpecificDifference(N, diff)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round1 ;
import java.io.BufferedOutputStream ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Kattio extends PrintWriter {
  public Kattio(InputStream i){
    super(new BufferedOutputStream(System.out));
    r=new BufferedReader(new InputStreamReader(i));
  }
  public Kattio(InputStream i,OutputStream o){
    super(new BufferedOutputStream(o));
    r=new BufferedReader(new InputStreamReader(i));
  }
  public boolean hasMoreTokens(){
    return peekToken()!=null ;
  }
  public int getInt(){
    return Integer.parseInt(nextToken());
  }
  public double getDouble(){
    return Double.parseDouble(nextToken());
  }
  public long getLong(){
    return Long.parseLong(nextToken());
  }
  public String getWord(){
    return nextToken();
  }
  private BufferedReader r ;
  private String line ;
  private StringTokenizer st ;
  private String token ;
  private String peekToken(){
    if(token==null)try {
      while(st==null || ! st.hasMoreTokens()){
        line=r.readLine();
        if(line==null)return null ;
        st=new StringTokenizer(line);
      }
      token=st.nextToken();
    }
    catch(IOException e){
    }
    return token ;
  }
  private String nextToken(){
    String ans=peekToken();
    token=null ;
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Kattio extends OclFile {
   static operation newKattio( i : OclFile) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(i);
    return self );
  operation initialise( i : OclFile) : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(i)) );
   static operation newKattio( i : OclFile, o : OclFile) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(i, o);
    return self );
  operation initialise( i : OclFile, o : OclFile) : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Write(o)) ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(i)) );
   operation hasMoreTokens() : boolean
  pre: true
  post: true
  activity: (     return peekToken() /= null );
   operation getInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation getDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
   operation getLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation getWord() : String
  pre: true
  post: true
  activity: (     return nextToken() );
   attribute r : OclFile;
   attribute line : String;
   attribute st : OclIterator;
   attribute token : String;
   operation peekToken() : String
  pre: true
  post: true
  activity: (     if (token = null) then     try (     while (st = null or not(st.hasNext())) do (     line := r.readLine() ; 
     if (line = null) then     return null else skip ; 
     st := OclIterator.newOclIterator_String(line) ) ; 
     token := st.next() )   catch (e : IOException) do skip
 else skip ; 
     return token );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     var ans : String ; ans := peekToken() ;
     token := null ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int numOfsubarrays(int arr[],int n){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int product=arr[i];
      int sum=arr[i];
      for(int j=i+1 ; j<n ; j++){
        if(product==sum)count++;
        product*=arr[j];
        sum+=arr[j];
      }
      if(product==sum)count++;
    }
    return count ;
  }
  public static void main(String args[]){
    int arr[]={
      1,3,2 };
      int n=arr.length ;
      System.out.println(numOfsubarrays(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation numOfsubarrays( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var product : int ; product := arr[i+1] ;
     var sum : int ; sum := arr[i+1] ;
         var j : int ; j := i + 1 ; while j < n do ( (     if (product = sum) then     count := count + 1 ; else skip ; 
     product := product*(arr[j+1]) ; 
     sum := sum+(arr[j+1]) )  ;     j := j + 1 ) ; 
     if (product = sum) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(numOfsubarrays(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=s.nextInt();
    }
    int count=0 ;
    int num=1 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]==num){
        count++;
        num++;
      }
    }
    if(count==0){
      count=-1 ;
    }
    else {
      count=n-count ;
    }
    System.out.println(count);
    s.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var num : int ; num := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = num) then (     count := count + 1 ; 
     num := num + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (count = 0) then (     count := -1 ) else (     count := n - count ) ;  
    OclFile["System.out"].println(count) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    Solver solver=new Solver();
    solver.init();
    solver.readHead(in.readLine());
    solver.readA(in.readLine());
  }
}
class Solver {
  int N ;
  int cnt ;
  public void init(){
    N=0 ;
    cnt=0 ;
  }
  public void readHead(String str){
    String[] strArr=str.split("\\s+");
    N=Integer.parseInt(strArr[0]);
  }
  public void readA(String str){
    String[] strArr=str.split("\\s+");
    boolean ok=false ;
    int n=1 ;
    for(int i=0 ; i<N ; i++){
      int a=Integer.parseInt(strArr[i]);
      if(a==n){
        ok=true ;
        n++;
      }
    }
    if(ok)System.out.println(N-n+1);
    else System.out.println(-1);
  }
  public boolean hasNext(){
    return cnt<N ;
  }
  public void readBody(String str){
    cnt++;
  }
  public void solve(){
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var solver : Solver ; solver := Solver.newSolver() ;
    solver.init() ; 
    solver.readHead(in.readLine()) ; 
    solver.readA(in.readLine()) ; 
 );
}
class Solver {
   attribute N : int;
   attribute cnt : int;
   operation init() : void
  pre: true
  post: true
  activity: (     N := 0 ; 
     cnt := 0 );
   operation readHead( str : String) : void
  pre: true
  post: true
  activity: (     var strArr : Sequence(String) ; strArr := str->split("\\s+") ;
     N := (strArr[0+1])->toInteger() );
   operation readA( str : String) : void
  pre: true
  post: true
  activity: (     var strArr : Sequence(String) ; strArr := str->split("\\s+") ;
     var ok : boolean ; ok := false ;
    var n : int ; n := 1 ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := (strArr[i+1])->toInteger() ;
     if (a = n) then (     ok := true ; 
     n := n + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (ok) then     OclFile["System.out"].println(N - n + 1) else     OclFile["System.out"].println(-1) ; ;  
 );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return cnt < N );
   operation readBody( str : String) : void
  pre: true
  post: true
  activity: (     cnt := cnt + 1 );
   operation solve() : void
  pre: true
  post: true
  activity: skip;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Iterator ;
import java.util.List ;
import java.util.ListIterator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    List<Integer>a=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      a.add(Integer.parseInt(sc.next()));
    }
    Iterator<Integer>it=a.iterator();
    int total=0 ;
    int index=1 ;
    while(it.hasNext()){
      int i=it.next();
      if(i==index){
        index++;
      }
      else {
        total++;
      }
    }
    if(total==n){
      System.out.println(-1);
    }
    else {
      System.out.println(total);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     a := a->including((sc.getCurrent())->toInteger()) )  ;     i := i + 1 ) ; 
    var it : OclIterator ; it := a->iterator() ;
    var total : int ; total := 0 ;
    var index : int ; index := 1 ;
    while (it.hasNext()) do (     var i : int ; i := it.next() ;
     if (i = index) then (     index := index + 1 ) else (     total := total + 1 ) ) ; 
    if (total = n) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(total) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] bricknumber=new int[N];
    int[] index=new int[N+2];
    int[] check=new int[N+2];
    int last=N ;
    for(int h=0 ; h<N ; h++){
      bricknumber[h]=sc.nextInt();
    }
    check[1]=0 ;
    for(int k=0 ; k<=N ; k++){
      index[k]=-1 ;
    }
    for(int i=1 ; i<=N ; i++){
      for(int j=check[i]; j<N ; j++){
        if(bricknumber[j]==i){
          index[i]=j ;
          check[i+1]=j ;
          break ;
        }
      }
      if(index[i]==-1){
        last=i-1 ;
        break ;
      }
    }
    if(last==0){
      last=N+1 ;
    }
    System.out.println(N-last);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var bricknumber : Sequence(int) ; bricknumber := Integer.subrange(1,N)->collect(0) ;
    var index : Sequence(int) ; index := Integer.subrange(1,N + 2)->collect(0) ;
    var check : Sequence(int) ; check := Integer.subrange(1,N + 2)->collect(0) ;
    var last : int ; last := N ;
        var h : int ; h := 0 ; while h < N do ( (     bricknumber[h+1] := sc.getCurrent()->toInteger() )  ;     h := h + 1 ) ; 
    check[1+1] := 0 ; 
        var k : int ; k := 0 ; while k <= N do ( (     index[k+1] := -1 )  ;     k := k + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := check[i+1] ; while j < N do ( (     if (bricknumber[j+1] = i) then (     index[i+1] := j ; 
     check[i + 1+1] := j ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (index[i+1] = -1) then (     last := i - 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (last = 0) then (     last := N + 1 ) else skip ; 
    OclFile["System.out"].println(N - last) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] tmpArray=br.readLine().split(" ");
    int input[]=new int[n];
    for(int i=0 ; i<n ; i++){
      input[i]=Integer.parseInt(tmpArray[i]);
    }
    int target=1 ;
    int length=0 ;
    for(int i=0 ; i<n ; i++){
      if(input[i]==target){
        target++;
        length++;
      }
    }
    System.out.println(length>0 ? n-length :-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
    var input : Sequence(int) ; input := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     input[i+1] := (tmpArray[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var target : int ; target := 1 ;
    var length : int ; length := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (input[i+1] = target) then (     target := target + 1 ; 
     length := length + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if length > 0 then n - length else -1 endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    TreeSet<Long>nums=new TreeSet<>();
    for(long i=2 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        nums.add(-i);
        nums.add(-n/i);
      }
    }
    int max=nums.size()+1 ;
    int min=0 ;
    HashSet<Long>used=new HashSet<>();
    for(long x : nums){
      if(used.contains(-x)){
        continue ;
      }
      min++;
      for(long i=2 ; i<=Math.sqrt(-x); i++){
        if(-x % i==0){
          used.add(i);
          used.add(-x/i);
        }
      }
    }
    if(min==0){
      min++;
    }
    System.out.println(min+" "+max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var nums : Set(long) ; nums := Set{} ;
        var i : long ; i := 2 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     nums := nums->including(-i) ; 
     nums := nums->including(-n / i) ) else skip )  ;     i := i + 1 ) ; 
    var max : int ; max := nums->size() + 1 ;
    var min : int ; min := 0 ;
    var used : Set(long) ; used := Set{} ;
    for (x : nums) do ( (     if (used->includes(-x)) then (     continue ) else skip ; 
     min := min + 1 ; 
         var i : long ; i := 2 ; while i <= (-x)->sqrt() do ( (     if (-x mod i = 0) then (     used := used->including(i) ; 
     used := used->including(-x / i) ) else skip )  ;     i := i + 1 ) )  ) ; 
    if (min = 0) then (     min := min + 1 ) else skip ; 
    OclFile["System.out"].println(min + " " + max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long m=sc.nextLong();
    long min=Math.max(0,n-2*m);
    long vertex=1 ;
    long rem=m ;
    while(rem>0){
      long d=Math.min(vertex,rem);
      vertex++;
      rem-=d ;
    }
    long max=n-(vertex==1 ? 0 : vertex);
    System.out.println(min+" "+max);
    sc.close();
    writer.flush();
    writer.close();
    reader.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : long ; n := sc.getCurrent()->toLong() ;
    var m : long ; m := sc.getCurrent()->toLong() ;
    var min : long ; min := Set{0, n - 2 * m}->max() ;
    var vertex : long ; vertex := 1 ;
    var rem : long ; rem := m ;
    while (rem > 0) do (     var d : long ; d := Set{vertex, rem}->min() ;
     vertex := vertex + 1 ; 
     rem := rem-(d) ) ; 
    var max : long ; max := n - (if vertex = 1 then 0 else vertex endif) ;
    OclFile["System.out"].println(min + " " + max) ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=false ;
  private static PrintWriter _err=new PrintWriter(System.err);
  private void solve(Scanner sc,PrintWriter out){
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    if(a==7 && b==5 && c==5 || a==5 && b==7 && c==5 || a==5 && b==5 && c==7){
      out.println("YES");
    }
    else {
      out.println("NO");
    }
  }
  private long C(long n,long r){
    long res=1 ;
    for(long i=n ; i>n-r ; --i){
      res*=i ;
    }
    for(long i=r ; i>1 ; --i){
      res/=i ;
    }
    return res ;
  }
  private long P(long n,long r){
    long res=1 ;
    for(long i=n ; i>n-r ; --i){
      res*=i ;
    }
    return res ;
  }
  private long ceil2pow(long n){
    if(n==0){
      return 1 ;
    }
    n--;
    n |=(n>>>1);
    n |=(n>>>2);
    n |=(n>>>4);
    n |=(n>>>8);
    n |=(n>>>16);
    n++;
    return n ;
  }
  public static void main(String[] args){
    long S=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    new Main().solve(sc,out);
    out.flush();
    long G=System.currentTimeMillis();
    if(elapsed){
      _err.println((G-S)+"ms");
    }
    _err.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := false;
  static   attribute _err : OclFile := OclFile.newOclFile_Write(OclFile["System.err"]);
   operation solve( sc : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.nextInt() ;
     var b : int ; b := sc.nextInt() ;
     var c : int ; c := sc.nextInt() ;
     if (a = 7 & b = 5 & c = 5 or a = 5 & b = 7 & c = 5 or a = 5 & b = 5 & c = 7) then (     out.println("YES") ) else (     out.println("NO") ) );
   operation C( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res*(i) )  ;     i := i - 1 ) ; 
         var i : long ; i := r ; while i > 1 do ( (     res := res/(i) )  ;     i := i - 1 ) ; 
     return res );
   operation P( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res*(i) )  ;     i := i - 1 ) ; 
     return res );
   operation ceil2pow( n : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then (     return 1 ) else skip ; 
     n := n - 1 ; 
    n := MathLib.bitwiseOr(n, ((n/(2->pow(1)))->oclAsType(long))) ; 
    n := MathLib.bitwiseOr(n, ((n/(2->pow(2)))->oclAsType(long))) ; 
    n := MathLib.bitwiseOr(n, ((n/(2->pow(4)))->oclAsType(long))) ; 
    n := MathLib.bitwiseOr(n, ((n/(2->pow(8)))->oclAsType(long))) ; 
    n := MathLib.bitwiseOr(n, ((n/(2->pow(16)))->oclAsType(long))) ; 
    n := n + 1 ; 
    return n 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    Main.newMain().solve(sc, out) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      long a=sc.nextLong(),b=sc.nextLong();
      long min=Math.max(a-2*b,0);
      long check=0 ;
      while(check*(check-1)/2<b){
        check++;
      }
      long max=a-check ;
      System.out.println(min+" "+max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
     var min : long ; min := Set{a - 2 * b, 0}->max() ;
    var check : long ; check := 0 ;
    while (check * (check - 1) / 2 < b) do (     check := check + 1 ) ; 
    var max : long ; max := a - check ;
    OclFile["System.out"].println(min + " " + max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  private static final FastReader fr=new FastReader();
  public static void main(String[] args)throws IOException {
    BufferedWriter output=new BufferedWriter(new OutputStreamWriter(System.out));
    StringBuilder sb=new StringBuilder();
    int n=fr.nextInt();
    long m=fr.nextLong();
    long lo=1,hi=100001 ;
    long min=Math.max(0,n-2*m);
    while(lo<=hi){
      long mid=(lo+hi)/2 ;
      if(mid*(mid-1)/2==m){
        lo=mid ;
        break ;
      }
      if(mid*(mid-1)/2>m)hi=mid-1 ;
      else lo=mid+1 ;
    }
    long max=n-lo ;
    if(m==0){
      min=n ;
      max=n ;
    }
    sb.append(min).append(" ").append(max);
    output.write(sb.toString());
    output.flush();
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    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 {
      if(st.hasMoreTokens()){
        str=st.nextToken("\n");
      }
      else {
        str=br.readLine();
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return str ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static    attribute fr : FastReader := FastReader.newFastReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var output : OclFile ; output := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := fr.nextInt() ;
    var m : long ; m := fr.nextLong() ;
    var lo : long ; lo := 1 ;
    var hi : long ; hi := 100001 ;
    var min : long ; min := Set{0, (n)->char2byte() - 2 * m}->max() ;
    while (lo <= hi) do (     var mid : long ; mid := (lo + hi) / 2 ;
     if (mid * (mid - 1) / 2 = m) then (     lo := mid ; 
     break ) else skip ; 
     if (mid * (mid - 1) / 2 > m) then     hi := mid - 1 ; else     lo := mid + 1 ; ) ; 
    var max : long ; max := (n)->char2byte() - lo ;
    if (m = 0) then (     min := n ; 
     max := n ) else skip ; 
    sb := sb + StringLib.newString(min) + StringLib.newString(" ") + StringLib.newString(max) ; 
    skip ; 
    skip ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Random ;
import java.util.Scanner ;
public class EqualSums2 {
  public static void main(final String...args)throws IOException {
    final String fname="C-large" ;
    final Scanner sc=new Scanner(new File(fname+".in"));
    final PrintWriter pw=new PrintWriter(fname+".out");
    final int t=sc.nextInt();
    for(int i=1 ; i<=t ; ++i){
      System.out.println(i);
      final int n=sc.nextInt();
      final long[] a=new long[n];
      for(int j=0 ; j<n ; ++j){
        a[j]=sc.nextLong();
      }
      final Random rnd=new Random();
      final Map<Long,Long>m=new HashMap<Long,Long>();
      long s1=-1 ;
      long s2=-1 ;
      while(true){
        long j=rnd.nextLong();
        if(j<0){
          continue ;
        }
        long x=j ;
        int k=0 ;
        long s=0 ;
        while(x>0){
          if((x & 1)!=0){
            s+=a[k];
          }
          x>>=1 ;
++k ;
        }
        final Long b=m.get(s);
        if(b==null){
          m.put(s,j);
        }
        else if(b!=j){
          s1=b ;
          s2=j ;
          break ;
        }
      }
      pw.println("Case #"+i+":");
      int k=0 ;
      while(s1>0){
        if((s1 & 1)!=0){
          pw.print(a[k]+" ");
        }
        s1>>=1 ;
++k ;
      }
      pw.println();
      k=0 ;
      while(s2>0){
        if((s2 & 1)!=0){
          pw.print(a[k]+" ");
        }
        s2>>=1 ;
++k ;
      }
      pw.println();
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class EqualSums2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fname : String ; fname := "C-large" ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile(fname + ".in")) ;
    var pw : OclFile ; pw := OclFile.newOclFile_Write(fname + ".out") ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= t do ( (     OclFile["System.out"].println(i) ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     a[j+1] := sc.getCurrent()->toLong() )  ;     j := j + 1 ) ; 
    var rnd : OclRandom ; rnd := OclRandom.newOclRandom() ;
    var m : Map(long,long) ; m := Map{} ;
    var s1 : long ; s1 := -1 ;
    var s2 : long ; s2 := -1 ;
    while (true) do (     var j : long ; j := rnd.nextLong() ;
     if (j < 0) then (     continue ) else skip ; 
    var x : long ; x := j ;
    var k : int ; k := 0 ;
    var s : long ; s := 0 ;
    while (x > 0) do (     if ((MathLib.bitwiseAnd(x,1)) /= 0) then (     s := s+(a[k+1]) ) else skip ; 
     x := x/(2->pow(1)) ; 
     k := k + 1 ) ; 
    var b : long ; b := m->at(s) ;
    if (b = null) then (     m := m->union(Map{s |-> j}) ) else     if (b /= j) then (     s1 := b ; 
     s2 := j ; 
     break ) else skip ; ;  
 ) ; 
    skip ; 
    var k : int ; k := 0 ;
    while (s1 > 0) do (     if ((MathLib.bitwiseAnd(s1,1)) /= 0) then (     skip ) else skip ; 
     s1 := s1/(2->pow(1)) ; 
     k := k + 1 ) ; 
    skip ; 
    k := 0 ; 
    while (s2 > 0) do (     if ((MathLib.bitwiseAnd(s2,1)) /= 0) then (     skip ) else skip ; 
     s2 := s2/(2->pow(1)) ; 
     k := k + 1 ) ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int getMaxNum(int a,int b,int c){
    if(b % c==0)return b ;
    int x=((b/c)*c);
    if(x>=a && x<=b)return x ;
    else return-1 ;
  }
  public static void main(String[] args){
    int a=2,b=10,c=3 ;
    System.out.println(getMaxNum(a,b,c));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getMaxNum( a : int, b : int, c : int) : int
  pre: true
  post: true
  activity: (     if (b mod c = 0) then     return b else skip ; 
     var x : int ; x := ((b / c) * c) ;
     if (x >= a & x <= b) then     return x else     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2 ;
    var b : int ; b := 10 ;
    var c : int ; c := 3 ;
     OclFile["System.out"].println(getMaxNum(a, b, c)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem3 {
  static int Cmtoinch(int cm){
    int inch=(int)(cm/3);
    double modl=cm % 3 ;
    if(modl>=2){
      inch++;
    }
    return inch ;
  }
  public static void main(String[] arr){
    Scanner sc=new Scanner(System.in);
    int cm=sc.nextInt();
    int inches=Cmtoinch(cm);
    int feet=inches/12 ;
    int op=12*feet ;
    int returned=inches-op ;
    System.out.println(feet+" "+returned);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem3 {
  static   operation Cmtoinch( cm : int) : int
  pre: true
  post: true
  activity: (     var inch : int ; inch := (cm / 3)->oclAsType(int) ;
     var modl : double ; modl := cm mod 3 ;
     if (modl >= 2) then (     inch := inch + 1 ) else skip ; 
     return inch );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cm : int ; cm := sc.getCurrent()->toInteger() ;
    var inches : int ; inches := Cmtoinch(cm) ;
    var feet : int ; feet := inches / 12 ;
    var op : int ; op := 12 * feet ;
    var returned : int ; returned := inches - op ;
    OclFile["System.out"].println(feet + " " + returned) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A125 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int feet=N/36 ;
    N %=36 ;
    int inches=N/3 ;
    N %=3 ;
    if(N==2){
      inches++;
    }
    if(inches==12){
      inches=0 ;
      feet++;
    }
    System.out.println(feet+" "+inches);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A125 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var feet : int ; feet := N / 36 ;
    N := N mod 36 ; 
    var inches : int ; inches := N / 3 ;
    N := N mod 3 ; 
    if (N = 2) then (     inches := inches + 1 ) else skip ; 
    if (inches = 12) then (     inches := 0 ; 
     feet := feet + 1 ) else skip ; 
    OclFile["System.out"].println(feet + " " + inches) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.List ;
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.Map.Entry ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.Stack ;
import java.util.StringTokenizer ;
import java.util.TreeMap ;
import java.util.Vector ;
public class Main {
  public static void main(String[] args)throws IOException {
    FastScanner sc=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    int inch=(int)(Math.round(n*1.0/3));
    System.out.println(inch/12+" "+(inch % 12));
  }
  public static long gcd(long x,long y){
    if(x==0)return y ;
    if(y==0)return x ;
    return gcd(y,x % y);
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(){
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public FastScanner(String s){
    try {
      br=new BufferedReader(new FileReader(s));
    }
    catch(FileNotFoundException e){
      e.printStackTrace();
    }
  }
  String nextToken(){
    while(st==null || ! st.hasMoreElements()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
    }
    return st.nextToken();
  }
  int nextInt(){
    return Integer.parseInt(nextToken());
  }
  long nextLong(){
    return Long.parseLong(nextToken());
  }
  double nextDouble(){
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.nextInt() ;
    var inch : int ; inch := ((n * 1.0 / 3)->round())->oclAsType(int) ;
    OclFile["System.out"].println(inch / 12 + " " + (inch mod 12)) ; 
 );
  static   operation gcd( x : long, y : long) : long
  pre: true
  post: true
  activity: (     if (x = 0) then     return y else skip ; 
     if (y = 0) then     return x else skip ; 
     return gcd(y, x mod y) );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
 );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem3 {
  public static void main(String[] args){
    Scanner n=new Scanner(System.in);
    float s=n.nextLong();
    int inches=Math.round(s/3);
    int foot=inches/12 ;
    System.out.println(foot+" "+(inches-foot*12));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : OclFile ; n := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : double ; s := n.getCurrent()->toLong() ;
    var inches : int ; inches := (s / 3)->round() ;
    var foot : int ; foot := inches / 12 ;
    OclFile["System.out"].println(foot + " " + (inches - foot * 12)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int c ;
  static int HailstoneNumbers(int N){
    System.out.print(N+" ");
    if(N==1 && c==0){
      return c ;
    }
    else if(N==1 && c!=0){
      c++;
      return c ;
    }
    else if(N % 2==0){
      c++;
      HailstoneNumbers(N/2);
    }
    else if(N % 2!=0){
      c++;
      HailstoneNumbers(3*N+1);
    }
    return c ;
  }
  public static void main(String[] args){
    int N=7 ;
    int x ;
    x=HailstoneNumbers(N);
    System.out.println();
    System.out.println("Number of Steps: "+x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute c : int;
  static   operation HailstoneNumbers( N : int) : int
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(N + " ") ; 
     if (N = 1 & c = 0) then (     return c ) else     if (N = 1 & c /= 0) then (     c := c + 1 ; 
     return c ) else     if (N mod 2 = 0) then (     c := c + 1 ; 
     execute HailstoneNumbers(N / 2) ) else     if (N mod 2 /= 0) then (     c := c + 1 ; 
     execute HailstoneNumbers(3 * N + 1) ) else skip ; ;  ;  ;  
     return c );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 7 ;
     var x : int ;
    x := HailstoneNumbers(N) ; 
    OclFile["System.out"].println() ; 
    OclFile["System.out"].println("Number of Steps: " + x) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    Pair[] p=new Pair[n];
    for(int i=0 ; i<n ; i++)p[i]=new Pair(scanner.nextInt(),scanner.nextInt());
    Arrays.sort(p);
    int ans=1<<25 ;
    for(int i=1 ; i<n-1 ; i++)for(int j=i ; j>=0 ; j--){
      int dx=p[i+1] .x-p[j] .x ;
      int dy=p[i+1] .y-p[j] .y ;
      if(dx*dx>=ans)break ;
      ans=Math.min(ans,dx*dx+dy*dy);
    }
    System.out.println(ans);
  }
  class Pair implements Comparable<Pair>{
    int x,y ;
    @ Override public String toString(){
      return "Pair[x="+x+",y="+y+"] " ;
    }
    public Pair(int x,int y){
      super();
      this.x=x ;
      this.y=y ;
    }
    @ Override public int compareTo(Pair o){
      return x-o.x ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var p : Sequence(Map) ; p := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     p[i+1] := Map(scanner.getCurrent()->toInteger(), scanner.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    p := p->sort() ; 
    var ans : int ; ans := (1*(2->pow(25)))->oclAsType(long) ;
        var i : int ; i := 1 ; while i < n - 1 do (         var j : int ; j := i ; while j >= 0 do ( (     var dx : int ; dx := p[i + 1+1].x - p[j+1].x ;
     var dy : int ; dy := p[i + 1+1].y - p[j+1].y ;
     if (dx * dx >= ans) then     break else skip ; 
     ans := Set{ans, dx * dx + dy * dy}->min() )  ;     j := j - 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
 class Pair implements Comparable<Map> {
   attribute x : int;
      operation toString() : String
  pre: true
  post: true
  activity: (     return "Pair[x=" + x + ",y=" + y + "] " );
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     execute super() ; 
     self.x := x ; 
     self.y := y );
      operation compareTo( o : Map) : int
  pre: true
  post: true
  activity: (     return x - o.x );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class29 {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      HashSet<Long>st=new HashSet<>();
      int i ;
      long a[]=new long[n];
      for(i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      for(i=1 ; i<=n ; i++){
        long val=((long)i+a[i % n])% n ;
        if(val<0){
          val+=n ;
        }
        st.add(val);
      }
      if(st.size()==n)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class29 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var st : Set(long) ; st := Set{} ;
    var i : int ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        i := 1 ; while i <= n do ( (     var val : long ; val := (i->oclAsType(long) + a[i mod n+1]) mod n ;
     if (val < 0) then (     val := val+(n) ) else skip ; 
     st := st->including(val) )  ;     i := i + 1 ) ; 
    if (st->size() = n) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      while(scanner.hasNextLine()){
        int n=Integer.valueOf(scanner.nextLine());
        int[][] data=new int[n][2];
        for(int i=0 ; i<n ; i++){
          String[] tmp=scanner.nextLine().split(" ");
          data[i][0]=Integer.valueOf(tmp[0]);
          data[i][1]=Integer.valueOf(tmp[1]);
        }
        solver(data);
      }
    }
  }
  private static void solver(int[][] data){
    int ans=Integer.MAX_VALUE ;
    int diffX=Integer.MAX_VALUE ;
    Arrays.parallelSort(data,new Comparator<int[]>(){
      @ Override public int compare(int[] o1,int[] o2){
        return Integer.compare(o1[0],o2[0]);
      }
    }
);
    for(int i=0 ; i<data.length ; i++){
      for(int j=i+1 ; j<data.length ; j++){
        if(diffX<Math.abs(data[i][0]-data[j][0])){
          break ;
        }
        int tmp=(data[i][0]-data[j][0])*(data[i][0]-data[j][0])+(data[i][1]-data[j][1])*(data[i][1]-data[j][1]);
        if(ans>tmp){
          ans=tmp ;
          diffX=(int)Math.sqrt(ans);
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (scanner.hasNextLine()) do (     var n : int ; n := (scanner.nextLine())->toInteger() ;
     var data : Sequence(Sequence(int)) ; data := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do ( (     var tmp : Sequence(String) ; tmp := scanner.nextLine()->split(" ") ;
     data[i+1][0+1] := (tmp[0+1])->toInteger() ; 
     data[i+1][1+1] := (tmp[1+1])->toInteger() )  ;     i := i + 1 ) ; 
     execute solver(data) ) ))  );
  static   operation solver( data : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := 2147483647 ;
     var diffX : int ; diffX := 2147483647 ;
    data := data->sort() ; 
        var i : int ; i := 0 ; while i < data->size() do ( (         var j : int ; j := i + 1 ; while j < data->size() do ( (     if (diffX < if data[i+1][0+1] - data[j+1][0+1] < 0 then -(data[i+1][0+1] - data[j+1][0+1]) else data[i+1][0+1] - data[j+1][0+1] endif) then (     break ) else skip ; 
     var tmp : int ; tmp := (data[i+1][0+1] - data[j+1][0+1]) * (data[i+1][0+1] - data[j+1][0+1]) + (data[i+1][1+1] - data[j+1][1+1]) * (data[i+1][1+1] - data[j+1][1+1]) ;
     if (ans > tmp) then (     ans := tmp ; 
     diffX := (ans)->sqrt()->oclAsType(int) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int min=Integer.MAX_VALUE ;
    int[][] p=new int[n][2];
    for(int i=0 ; i<n ; i++){
      p[i][0]=sc.nextInt();
      p[i][1]=sc.nextInt();
    }
    Arrays.sort(p,new Comparator<int[]>(){
      public int compare(int[] a,int[] b){
        return a[0]-b[0];
      }
    }
);
    for(int i=1 ; i<n ; i++){
      min=Math.min(min,(p[i][0]-p[i-1][0])*(p[i][0]-p[i-1][0])+(p[i][1]-p[i-1][1])*(p[i][1]-p[i-1][1]));
    }
    Arrays.sort(p,new Comparator<int[]>(){
      public int compare(int[] a,int[] b){
        return a[1]-b[1];
      }
    }
);
    for(int i=1 ; i<n ; i++){
      min=Math.min(min,(p[i][0]-p[i-1][0])*(p[i][0]-p[i-1][0])+(p[i][1]-p[i-1][1])*(p[i][1]-p[i-1][1]));
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var min : int ; min := 2147483647 ;
    var p : Sequence(Sequence(int)) ; p := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     p[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    p := OclComparator.sortWith(p, OclComparator<Sequence(int)>.newOclComparator()) ; 
        var i : int ; i := 1 ; while i < n do ( (     min := Set{min, (p[i+1][0+1] - p[i - 1+1][0+1]) * (p[i+1][0+1] - p[i - 1+1][0+1]) + (p[i+1][1+1] - p[i - 1+1][1+1]) * (p[i+1][1+1] - p[i - 1+1][1+1])}->min() )  ;     i := i + 1 ) ; 
    p := OclComparator.sortWith(p, OclComparator<Sequence(int)>.newOclComparator()) ; 
        var i : int ; i := 1 ; while i < n do ( (     min := Set{min, (p[i+1][0+1] - p[i - 1+1][0+1]) * (p[i+1][0+1] - p[i - 1+1][0+1]) + (p[i+1][1+1] - p[i - 1+1][1+1]) * (p[i+1][1+1] - p[i - 1+1][1+1])}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Comparator ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int n=parseInt(br.readLine());
    long[][] a=new long[n][2];
    for(int i=0 ; i<n ; i++){
      line=br.readLine();
      a[i][0]=parseInt(line.substring(0,line.indexOf(' ')));
      a[i][1]=parseInt(line.substring(line.indexOf(' ')+1));
    }
    Arrays.sort(a,new Comparator<long[]>(){
      @ Override public int compare(long[] o1,long[] o2){
        return Long.compare(o1[0],o2[0]);
      }
    }
);
    double L=Long.MAX_VALUE ;
    long SQ=Long.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      for(int j=i-1 ; j>=0 ; j--){
        if(a[i][0]-a[j][0]>=L)break ;
        long sq=(a[i][0]-a[j][0])*(a[i][0]-a[j][0])+(a[i][1]-a[j][1])*(a[i][1]-a[j][1]);
        if(sq<SQ){
          SQ=sq ;
          L=Math.sqrt(SQ);
        }
      }
    }
    System.out.println(SQ);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var n : int ; n := parseInt(br.readLine()) ;
    var a : Sequence(Sequence(long)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     line := br.readLine() ; 
     a[i+1][0+1] := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
     a[i+1][1+1] := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() )  ;     i := i + 1 ) ; 
    a := OclComparator.sortWith(a, OclComparator<Sequence(long)>.newOclComparator()) ; 
    var L : double ; L := "9223372036854775807"->toLong() ;
    var SQ : long ; SQ := "9223372036854775807"->toLong() ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i - 1 ; while j >= 0 do ( (     if (a[i+1][0+1] - a[j+1][0+1] >= L) then     break else skip ; 
     var sq : long ; sq := (a[i+1][0+1] - a[j+1][0+1]) * (a[i+1][0+1] - a[j+1][0+1]) + (a[i+1][1+1] - a[j+1][1+1]) * (a[i+1][1+1] - a[j+1][1+1]) ;
     if (sq < SQ) then (     SQ := sq ; 
     L := (SQ)->sqrt() ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(SQ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class C implements Runnable {
  private final int MAX_VALUE=100000*20+10 ;
  private String IFILE="C-small-attempt0.in" ;
  private Scanner in ;
  private PrintWriter out ;
  public void Run()throws IOException {
    in=new Scanner(new File(IFILE));
    out=new PrintWriter("output.txt");
    int ntest=in.nextInt();
    for(int test=1 ; test<=ntest ; test++){
      out.println("Case #"+test+":");
      int n=in.nextInt();
      int[] mas=new int[n];
      for(int i=0 ; i<n ; i++)mas[i]=in.nextInt();
      Arrays.sort(mas);
      int[] f=new int[MAX_VALUE];
      Arrays.fill(f,-1);
      f[0]=0 ;
      boolean ok=false ;
      for(int i=0 ; i<n ; i++){
        for(int d=MAX_VALUE-1 ; d>=0 ; d--){
          if(f[d]==-1)continue ;
          int dd=d+mas[i];
          if(f[dd]!=-1){
            ok=true ;
            int z=dd ;
            while(z!=0){
              if(z!=dd)out.print(" ");
              out.print(mas[f[z] ]);
              z-=mas[f[z] ];
            }
            out.println();
            out.print(mas[i]);
            z=d ;
            while(z!=0){
              out.print(" "+mas[f[z] ]);
              z-=mas[f[z] ];
            }
            out.println();
            break ;
          }
          else f[dd]=i ;
        }
        if(ok)break ;
      }
      if(! ok)out.println("Impossible");
    }
    in.close();
    out.close();
  }
  public void run(){
    try {
      Run();
    }
    catch(IOException e){
    }
  }
  public static void main(String[] args)throws IOException {
    new C().Run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C implements Runnable {
   attribute MAX_VALUE : int := 100000 * 20 + 10;
   attribute IFILE : String := "C-small-attempt0.in";
   attribute in : OclFile;
   attribute out : OclFile;
   operation Run() : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile(IFILE)) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ; 
    var ntest : int ; ntest := in.getCurrent()->toInteger() ;
        var test : int ; test := 1 ; while test <= ntest do ( (     skip ; 
     var n : int ; n := in.getCurrent()->toInteger() ;
    var mas : Sequence(int) ; mas := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     mas[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    mas := mas->sort() ; 
    var f : Sequence(int) ; f := Integer.subrange(1,MAX_VALUE)->collect(0) ;
    f := f->collect(-1) ; 
    f[0+1] := 0 ; 
    var ok : boolean ; ok := false ;
        var i : int ; i := 0 ; while i < n do ( (         var d : int ; d := MAX_VALUE - 1 ; while d >= 0 do ( (     if (f[d+1] = -1) then     continue else skip ; 
     var dd : int ; dd := d + mas[i+1] ;
     if (f[dd+1] /= -1) then (     ok := true ; 
     var z : int ; z := dd ;
    while (z /= 0) do (     if (z /= dd) then     skip ; else skip ; 
     skip ; 
     z := z-(mas[f[z+1]+1]) ) ; 
    skip ; 
    skip ; 
    z := d ; 
    while (z /= 0) do (     skip ; 
     z := z-(mas[f[z+1]+1]) ) ; 
    skip ; 
    break 
 ) else     f[dd+1] := i ; )  ;     d := d - 1 ) ; 
     if (ok) then     break else skip )  ;     i := i + 1 ) ; 
    if (not(ok)) then     skip ; else skip ; 
 )  ;     test := test + 1 ) ; 
    skip ; 
    skip ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     execute Run() )   catch (e : IOException) do skip
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     C.newC().Run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Comparator ;
class Point {
  int x ;
  int y ;
  Point(int x,int y){
    this.x=x ;
    this.y=y ;
  }
  int distance(Point p){
    return(p.x-this.x)*(p.x-this.x)+(p.y-this.y)*(p.y-this.y);
  }
}
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    Point[] p=new Point[n];
    String[] line=new String[2];
    for(int i=0 ; i<n ; i++){
      line=br.readLine().split(" ");
      p[i]=new Point(Integer.parseInt(line[0]),Integer.parseInt(line[1]));
    }
    Arrays.sort(p,new Comparator<Point>(){
      public int compare(Point p1,Point p2){
        return p1.x-p2.x ;
      }
    }
);
    int result=Integer.MAX_VALUE ;
    for(int i=1 ; i<n ; i++){
      for(int j=i-1 ; j>=0 ; j--){
        if(p[i] .x-p[j] .x>=Math.sqrt(result))break ;
        result=Math.min(result,p[i] .distance(p[j]));
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Point {
   attribute x : int;
   attribute y : int;
   static operation newPoint( x : int, y : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation distance( p : Point) : int
  pre: true
  post: true
  activity: (     return (p.x - self.x) * (p.x - self.x) + (p.y - self.y) * (p.y - self.y) );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var p : Sequence(Point) ; p := Integer.subrange(1,n)->collect(null) ;
    var line : Sequence(String) ; line := Integer.subrange(1,2)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     line := br.readLine()->split(" ") ; 
     p[i+1] := Point.newPoint((line[0+1])->toInteger(), (line[1+1])->toInteger()) )  ;     i := i + 1 ) ; 
    p := OclComparator.sortWith(p, OclComparator<Point>.newOclComparator()) ; 
    var result : int ; result := 2147483647 ;
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := i - 1 ; while j >= 0 do ( (     if (p[i+1].x - p[j+1].x >= (result)->sqrt()) then     break else skip ; 
     result := Set{result, p[i+1].distance(p[j+1])}->min() )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int binaryGap(int N){
    int last=-1,ans=0 ;
    for(int i=0 ; i<32 ; ++i)if(((N>>i)& 1)>0){
      if(last>=0)ans=Math.max(ans,i-last);
      last=i ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation binaryGap( N : int) : int
  pre: true
  post: true
  activity: (     var last : int ; last := -1 ;
    var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < 32 do (     if ((((N/(2->pow(i)))->oclAsType(long)) & 1) > 0) then (     if (last >= 0) then     ans := Set{ans, i - last}->max() ; else skip ; 
     last := i ) else skip ;  ;     i := i + 1 ) ; 
     return ans );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ImportantExam {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int snoozeInterval=scanner.nextInt(),hh=scanner.nextInt(),mm=scanner.nextInt();
    int noOfTimeSnooze=0 ;
    boolean flag=true ;
    while(flag){
      if(hh==7 || hh==17 || mm==7 || mm % 10==7){
        flag=false ;
        System.out.println(noOfTimeSnooze);
      }
      mm-=snoozeInterval ;
      noOfTimeSnooze++;
      if(mm<0){
        mm+=60 ;
        hh-=1 ;
        if(hh<0)hh=23 ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ImportantExam {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var snoozeInterval : int ; snoozeInterval := scanner.getCurrent()->toInteger() ;
    var hh : int ; hh := scanner.getCurrent()->toInteger() ;
    var mm : int ; mm := scanner.getCurrent()->toInteger() ;
    var noOfTimeSnooze : int ; noOfTimeSnooze := 0 ;
    var flag : boolean ; flag := true ;
    while (flag) do (     if (hh = 7 or hh = 17 or mm = 7 or mm mod 10 = 7) then (     flag := false ; 
     OclFile["System.out"].println(noOfTimeSnooze) ) else skip ; 
     mm := mm-(snoozeInterval) ; 
     noOfTimeSnooze := noOfTimeSnooze + 1 ; 
     if (mm < 0) then (     mm := mm+(60) ; 
     hh := hh-(1) ; 
     if (hh < 0) then     hh := 23 ; else skip ) else skip ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JamieAndAlarmSnooze {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int hh=sc.nextInt();
    int mm=sc.nextInt();
    int time=hh*60+mm ;
    for(int i=0 ; ; i++){
      int hours=time/60,minutes=time % 60 ;
      if(hours/10==7 || hours % 10==7 || minutes/10==7 || minutes % 10==7){
        System.out.println(i);
        return ;
      }
      time=(time-x+1440)% 1440 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JamieAndAlarmSnooze {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var hh : int ; hh := sc.getCurrent()->toInteger() ;
    var mm : int ; mm := sc.getCurrent()->toInteger() ;
    var time : int ; time := hh * 60 + mm ;
        var i : int ; i := 0 ; while true do ( (     var hours : int ; hours := time / 60 ;
    var minutes : int ; minutes := time mod 60 ;
     if (hours / 10 = 7 or hours mod 10 = 7 or minutes / 10 = 7 or minutes mod 10 = 7) then (     OclFile["System.out"].println(i) ; 
     return ) else skip ; 
     time := (time - x + 1440) mod 1440 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] arg){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int hh=sc.nextInt();
    int mm=sc.nextInt();
    boolean check=true ;
    int cnt=0 ;
    while(check){
      int MMlnum=mm % 10 ;
      int HHlnum=hh % 10 ;
      if(MMlnum==7 || HHlnum==7){
        System.out.println(cnt);
        check=false ;
        break ;
      }
      int tmpMM=mm-x ;
      if(tmpMM>=0){
        mm-=x ;
        cnt++;
      }
      else {
        mm=60+tmpMM ;
        if(hh!=00)hh--;
        else hh=23 ;
        cnt++;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var hh : int ; hh := sc.getCurrent()->toInteger() ;
    var mm : int ; mm := sc.getCurrent()->toInteger() ;
    var check : boolean ; check := true ;
    var cnt : int ; cnt := 0 ;
    while (check) do (     var MMlnum : int ; MMlnum := mm mod 10 ;
     var HHlnum : int ; HHlnum := hh mod 10 ;
    if (MMlnum = 7 or HHlnum = 7) then (     OclFile["System.out"].println(cnt) ; 
     check := false ; 
     break ) else skip ; 
    var tmpMM : int ; tmpMM := mm - x ;
    if (tmpMM >= 0) then (     mm := mm-(x) ; 
     cnt := cnt + 1 ) else (     mm := 60 + tmpMM ; 
     if (hh /= 00) then     hh := hh - 1 else     hh := 23 ; ;  
     cnt := cnt + 1 ) ;  
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int x,h,m,totalminutes ;
    x=sc.nextInt();
    h=sc.nextInt();
    m=sc.nextInt();
    totalminutes=h*60+m ;
    for(int i=0 ; ; i++){
      h=totalminutes/60 ;
      m=totalminutes % 60 ;
      if(h/10==7 || h % 10==7 || m/10==7 || m % 10==7){
        System.out.print(i);
        break ;
      }
      totalminutes=(totalminutes-x+1440)% 1440 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ;
    var h : int ;
    var m : int ;
    var totalminutes : int ;
    x := sc.getCurrent()->toInteger() ; 
    h := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
    totalminutes := h * 60 + m ; 
        var i : int ; i := 0 ; while true do ( (     h := totalminutes / 60 ; 
     m := totalminutes mod 60 ; 
     if (h / 10 = 7 or h mod 10 = 7 or m / 10 = 7 or m mod 10 = 7) then (     OclFile["System.out"].print(i) ; 
     break ) else skip ; 
     totalminutes := (totalminutes - x + 1440) mod 1440 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
class Solution {
  public int minMoves(int[] nums){
    if(nums.length==0)return 0 ;
    Arrays.sort(nums);
    int min_num=nums[0];
    int ans=0 ;
    for(int num : nums){
      ans+=num-min_num ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
   operation minMoves( nums : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (nums->size() = 0) then     return 0 else skip ; 
     nums := nums->sort() ; 
    var min_num : int ; min_num := nums[0+1] ;
    var ans : int ; ans := 0 ;
    for (num : nums) do ( (     ans := ans+(num - min_num) )  ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class aaaauxiliary {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int gap,hh,mm,ans=0 ;
    boolean flag=false ;
    gap=sc.nextInt();
    hh=sc.nextInt();
    mm=sc.nextInt();
    sc.close();
    while(! flag){
      if(hh % 10==7 || hh/10==7 || mm % 10==7 || mm/10==7){
        System.out.println(ans);
        flag=true ;
      }
      else if(mm-gap>=0){
        mm-=gap ;
        ans++;
      }
      else {
        mm-=gap ;
        mm+=60 ;
        hh--;
        if(hh==-1){
          hh=23 ;
        }
        ans++;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class aaaauxiliary {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var gap : int ;
    var hh : int ;
    var mm : int ;
    var ans : int ; ans := 0 ;
    var flag : boolean ; flag := false ;
    gap := sc.getCurrent()->toInteger() ; 
    hh := sc.getCurrent()->toInteger() ; 
    mm := sc.getCurrent()->toInteger() ; 
    skip ; 
    while (not(flag)) do (     if (hh mod 10 = 7 or hh / 10 = 7 or mm mod 10 = 7 or mm / 10 = 7) then (     OclFile["System.out"].println(ans) ; 
     flag := true ) else     if (mm - gap >= 0) then (     mm := mm-(gap) ; 
     ans := ans + 1 ) else (     mm := mm-(gap) ; 
     mm := mm+(60) ; 
    hh := hh - 1 ; 
    if (hh = -1) then (     hh := 23 ) else skip ; 
    ans := ans + 1 ; 
 ) ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean canFormTeam(int n,int m){
    if(n>=1 && m>=2)return true ;
    if(m>=1 && n>=2)return true ;
    return false ;
  }
  static int maxTeams(int n,int m){
    int count=0 ;
    while(canFormTeam(n,m)){
      if(n>m){
        n-=2 ;
        m-=1 ;
      }
      else {
        m-=2 ;
        n-=1 ;
      }
      count++;
    }
    return count ;
  }
  public static void main(String args[]){
    int n=4,m=5 ;
    System.out.println(maxTeams(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation canFormTeam( n : int, m : int) : boolean
  pre: true
  post: true
  activity: (     if (n >= 1 & m >= 2) then     return true else skip ; 
     if (m >= 1 & n >= 2) then     return true else skip ; 
     return false );
  static   operation maxTeams( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (canFormTeam(n, m)) do (     if (n > m) then (     n := n-(2) ; 
     m := m-(1) ) else (     m := m-(2) ; 
     n := n-(1) ) ;  
     count := count + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
    var m : int ; m := 5 ;
     OclFile["System.out"].println(maxTeams(n, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long binomialCoeff(int n,int k){
    long res=1 ;
    if(k>n-k)k=n-k ;
    for(int i=0 ; i<k ; ++i){
      res*=(n-i);
      res/=(i+1);
    }
    return res ;
  }
  static long catalan(int n){
    long c=binomialCoeff(2*n,n);
    return c/(n+1);
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(catalan(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation binomialCoeff( n : int, k : int) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     if (k > n - k) then     k := n - k ; else skip ; 
         var i : int ; i := 0 ; while i < k do ( (     res := res*((n - i)) ; 
     res := res/((i + 1)) )  ;     i := i + 1 ) ; 
     return res );
  static   operation catalan( n : int) : long
  pre: true
  post: true
  activity: (     var c : long ; c := binomialCoeff(2 * n, n) ;
     return c / (n + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(catalan(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long binomialCoeff(int n,int k){
    long res=1 ;
    if(k>n-k){
      k=n-k ;
    }
    for(int i=0 ; i<k ; ++i){
      res*=(n-i);
      res/=(i+1);
    }
    return res ;
  }
  static long catalan(int n){
    long c=binomialCoeff(2*n,n);
    return c/(n+1);
  }
  public static void main(String[] args){
    for(int i=0 ; i<10 ; i++){
      System.out.print(catalan(i)+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation binomialCoeff( n : int, k : int) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     if (k > n - k) then (     k := n - k ) else skip ; 
         var i : int ; i := 0 ; while i < k do ( (     res := res*((n - i)) ; 
     res := res/((i + 1)) )  ;     i := i + 1 ) ; 
     return res );
  static   operation catalan( n : int) : long
  pre: true
  post: true
  activity: (     var c : long ; c := binomialCoeff(2 * n, n) ;
     return c / (n + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 10 do ( (     OclFile["System.out"].print(catalan(i) + " ") )  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.LinkedHashSet ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Set ;
public class CsAcademy {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int n=cin.nextInt();
    Set<Integer>prime=new LinkedHashSet<>();
    for(int i=2 ; i<=3000 ; i++){
      if(isPrime(i)){
        prime.add(i);
      }
    }
    int ans=0 ;
    for(int i=2 ; i<=n ; i++){
      int temp=0 ;
      for(Integer pr : prime){
        if(i % pr==0){
          temp++;
        }
      }
      if(temp==2)ans++;
    }
    System.out.println(ans);
  }
  public static boolean isPrime(int x){
    for(int i=2 ; i*i<=x ; i++){
      if(x % i==0)return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class CsAcademy {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := cin.getCurrent()->toInteger() ;
    var prime : Set(int) ; prime := Set{} ;
        var i : int ; i := 2 ; while i <= 3000 do ( (     if (isPrime(i)) then (     prime := prime->including(i) ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 2 ; while i <= n do ( (     var temp : int ; temp := 0 ;
     for (pr : prime) do ( (     if (i mod pr = 0) then (     temp := temp + 1 ) else skip )  ) ; 
     if (temp = 2) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation isPrime( x : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= x do ( (     if (x mod i = 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class RemoveDuplicates {
  void removeDuplicates(String str){
    LinkedHashSet<Character>lhs=new LinkedHashSet<>();
    for(int i=0 ; i<str.length(); i++)lhs.add(str.charAt(i));
    for(Character ch : lhs)System.out.print(ch);
  }
  public static void main(String args[]){
    String str="geeksforgeeks" ;
    RemoveDuplicates r=new RemoveDuplicates();
    r.removeDuplicates(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class RemoveDuplicates {
   operation removeDuplicates( str : String) : void
  pre: true
  post: true
  activity: (     var lhs : Set(String) ; lhs := Set{} ;
         var i : int ; i := 0 ; while i < str->size() do (     lhs := lhs->including(str->at(i+1)) ;  ;     i := i + 1 ) ; 
     for (ch : lhs) do (     OclFile["System.out"].print(ch) ;  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var r : RemoveDuplicates ; r := RemoveDuplicates.newRemoveDuplicates() ;
     r.removeDuplicates(str) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static final Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
  public static final PrintStream out=System.out ;
  public static void main(String[] args){
    int N=in.nextInt();
    Map<String,Integer>found=new HashMap<>();
    long result=0 ;
    for(int i=0 ; i<N ; i++){
      String input=in.next();
      String data=new String(input.chars().sorted().toArray(),0,input.length());
      result+=found.merge(data,1,(x,y)->x+y)-1 ;
    }
    out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])));
  static    attribute out : OclFile := OclFile["System.out"];
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
     var found : Map(String,int) ; found := Map{} ;
    var result : long ; result := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var input : String ; input := in.getCurrent() ;
     var data : String ; data := StringLib.newString(input.chars()->sort()->asSequence(), 0, input->size()) ;
     result := result+(found.merge(data, 1, lambda (x , y) : OclAny in x + y) - 1) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    String[] words=new String[N];
    for(int i=0 ; i<words.length ; i++)words[i]=in.next();
    Map<String,Long>cnt=new HashMap<>();
    for(String word : words){
      char[] arr=word.toCharArray();
      Arrays.sort(arr);
      String sorted=String.valueOf(arr);
      cnt.put(sorted,cnt.getOrDefault(sorted,(long)0)+1);
    }
    long res=0 ;
    for(Long i : cnt.values())res+=i*(i-1)/2 ;
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var words : Sequence(String) ; words := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < words->size() do (     words[i+1] := in.getCurrent() ;  ;     i := i + 1 ) ; 
    var cnt : Map(String,long) ; cnt := Map{} ;
    for (word : words) do ( (     var arr : Sequence(String) ; arr := word->characters() ;
     arr := arr->sort() ; 
     var sorted : String ; sorted := (arr)->sum()  ;
     cnt := cnt->union(Map{sorted |-> (if cnt->keys()->contains(sorted) then cnt->at(sorted) else 0->oclAsType(long) endif) + 1}) )  ) ; 
    var res : long ; res := 0 ;
    for (i : cnt->values()) do (     res := res+(i * (i - 1) / 2) ;  ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.function.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer in=new StringTokenizer("");
    int n=Integer.parseInt(br.readLine());
    Map<String,Long>mp=new HashMap<>();
    Consumer<String>fun=(s)->mp.put(s,mp.getOrDefault(s,0L)+1L);
    for(int i=0 ; i<n ; i++)fun.accept(Arrays.toString(br.readLine().chars().mapToObj(it->(char)it).sorted().toArray()));
    System.out.println(mp.values().stream().mapToLong(it->it*(it-1)/2).sum());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var in : OclIterator ; in := OclIterator.newOclIterator_String("") ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var mp : Map(String,long) ; mp := Map{} ;
    var fun : Function(<String>, void) ; fun := lambda s : OclAny in mp->at(s) ;
        var i : int ; i := 0 ; while i < n do (     fun->apply((br.readLine().chars().mapToObj(lambda it : OclAny in it->oclAsType(String))->sort()->asSequence() + "")) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(mp->values()->collect( _x1 | (lambda it : OclAny in it * (it - 1) / 2)->apply(_x1) )->sum()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a=sc.nextLong();
    long b=sc.nextLong();
    if(a<=0 && b>=0 || a<=0 && b>=0){
      System.out.println("Zero");
    }
    else if(a<0 && b<0){
      System.out.println(((b-a+1)% 2==0)? "Positive" : "Negative");
    }
    else if(a>0 && b>0){
      System.out.println("Positive");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
     if (a <= 0 & b >= 0 or a <= 0 & b >= 0) then (     OclFile["System.out"].println("Zero") ) else     if (a < 0 & b < 0) then (     OclFile["System.out"].println(if ((b - a + 1) mod 2 = 0) then "Positive" else "Negative" endif) ) else     if (a > 0 & b > 0) then (     OclFile["System.out"].println("Positive") ) else skip ; ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc ;
  Map<String,Integer>h ;
  int N ;
  public Main(){
    sc=new Scanner(System.in);
  }
  private void calc(){
    N=sc.nextInt();
    h=new HashMap<>();
    for(int i=0 ; i<N ; i++){
      char[] cs=sc.next().toCharArray();
      Arrays.sort(cs);
      String s=new String(cs);
      h.put(s,h.getOrDefault(s,0)+1);
    }
    long result=0L ;
    for(String s : h.keySet()){
      int cnt=h.get(s);
      if(cnt<=1)continue ;
      result=result+((long)cnt)*(cnt-1)/2 ;
    }
    out(result);
  }
  private void out(Object o){
    System.out.println(o);
    System.out.flush();
  }
  public static void main(String[] args){
    Main m=new Main();
    m.calc();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute h : Map(String,int);
   attribute N : int;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation calc() : void
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     h := Map{} ; 
        var i : int ; i := 0 ; while i < N do ( (     var cs : Sequence(String) ; cs := sc.getCurrent()->characters() ;
     cs := cs->sort() ; 
     var s : String ; s := StringLib.newString(cs) ;
     h := h->union(Map{s |-> (if h->keys()->contains(s) then h->at(s) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var result : long ; result := 0L ;
    for (s : h->keys()) do ( (     var cnt : int ; cnt := h->at(s) ;
     if (cnt <= 1) then     continue else skip ; 
     result := result + (cnt->oclAsType(long)) * (cnt - 1) / 2 )  ) ; 
    execute out(result) ; 
 );
   operation out( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) ; 
     OclFile["System.out"].flush() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.calc() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int getPosition(int a[],int n,int m){
    for(int i=0 ; i<n ; i++){
      a[i]=(a[i]/m+(a[i] % m));
    }
    int ans=-1,max=-1 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(max<a[i]){
        max=a[i];
        ans=i ;
      }
    }
    return ans+1 ;
  }
  public static void main(String args[]){
    int a[]={
      2,5,4 };
      int n=a.length ;
      int m=2 ;
      System.out.println(getPosition(a,n,m));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation getPosition( a : Sequence(int), n : int, m : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (a[i+1] / m + (a[i+1] mod m)) )  ;     i := i + 1 ) ; 
     var ans : int ; ans := -1 ;
    var max : int ; max := -1 ;
         var i : int ; i := n - 1 ; while i >= 0 do ( (     if (max < a[i+1]) then (     max := a[i+1] ; 
     ans := i ) else skip )  ;     i := i - 1 ) ; 
     return ans + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,5,4} ;
     var n : int ; n := a->size() ;
     var m : int ; m := 2 ;
     OclFile["System.out"].println(getPosition(a, n, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int days[]={
    31,28,31,30,31,30,31,31,30,31,30,31 };
    static int dayOfYear(String date){
      int year=Integer.parseInt(date.substring(0,4));
      int month=Integer.parseInt(date.substring(5,7));
      int day=Integer.parseInt(date.substring(8));
      if(month>2 && year % 4==0 &&(year % 100!=0 || year % 400==0)){
++day ;
      }
      while(--month>0){
        day=day+days[month-1];
      }
      return day ;
    }
    public static void main(String[] args){
      String date="2019-01-09" ;
      System.out.println(dayOfYear(date));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute days : int := Sequence{31,28,31,30,31,30,31,31,30,31,30,31};
  static   operation dayOfYear( date : String) : int
  pre: true
  post: true
  activity: (     var year : int ; year := (date.subrange(0+1,4))->toInteger() ;
     var month : int ; month := (date.subrange(5+1,7))->toInteger() ;
    var day : int ; day := (date.subrange(8+1,8))->toInteger() ;
    if (month > 2 & year mod 4 = 0 & (year mod 100 /= 0 or year mod 400 = 0)) then (     day := day + 1 ) else skip ; 
        month := month - 1 ;
    while ((month - 1) > 0) do (        month := month - 1 ;     skip ; (     day := day + days[month - 1+1] ) ;     month := month - 1 ;
 ) ;  
    return day 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var date : String ; date := "2019-01-09" ;
     OclFile["System.out"].println(dayOfYear(date)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test215 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      if(n % 2==0){
        for(int i=1 ; i<=n ; i++){
          if(i % 2==0){
            System.out.print((i-1)+" ");
          }
          else {
            System.out.print((i+1)+" ");
          }
        }
      }
      else {
        for(int i=1 ; i<=n-3 ; i++){
          if(i % 2==0){
            System.out.print((i-1)+" ");
          }
          else {
            System.out.print((i+1)+" ");
          }
        }
        System.out.print(n+" ");
        System.out.print((n-2)+" ");
        System.out.print((n-1)+" ");
      }
      System.out.println();
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test215 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (         var i : int ; i := 1 ; while i <= n do ( (     if (i mod 2 = 0) then (     OclFile["System.out"].print((i - 1) + " ") ) else (     OclFile["System.out"].print((i + 1) + " ") ) )  ;     i := i + 1 ) ) else (         var i : int ; i := 1 ; while i <= n - 3 do ( (     if (i mod 2 = 0) then (     OclFile["System.out"].print((i - 1) + " ") ) else (     OclFile["System.out"].print((i + 1) + " ") ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(n + " ") ; 
     OclFile["System.out"].print((n - 2) + " ") ; 
     OclFile["System.out"].print((n - 1) + " ") ) ;  
     OclFile["System.out"].println() )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1541A_PrettyPermutations {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int num=parseInt(input.nextLine());
      if(num==2){
        System.out.println("2 1");
      }
      else {
        String result="" ;
        if(num % 2==0){
          for(int i=1 ; i<=num ; i++){
            if(i % 2==1){
              result+=i+1+" " ;
            }
            else {
              result+=i-1+" " ;
            }
          }
        }
        else {
          result="3 1 2 " ;
          for(int i=4 ; i<=num ; i++){
            if(i % 2==0){
              result+=i+1+" " ;
            }
            else {
              result+=i-1+" " ;
            }
          }
        }
        System.out.println(result.trim());
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1541A_PrettyPermutations {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var num : int ; num := parseInt(input.nextLine()) ;
     if (num = 2) then (     OclFile["System.out"].println("2 1") ) else (     var result : String ; result := "" ;
     if (num mod 2 = 0) then (         var i : int ; i := 1 ; while i <= num do ( (     if (i mod 2 = 1) then (     result := result+(i + 1 + " ") ) else (     result := result+((i)->char2byte() - 1 + " ") ) )  ;     i := i + 1 ) ) else (     result := "3 1 2 " ; 
         var i : int ; i := 4 ; while i <= num do ( (     if (i mod 2 = 0) then (     result := result+(i + 1 + " ") ) else (     result := result+((i)->char2byte() - 1 + " ") ) )  ;     i := i + 1 ) ) ;  
     OclFile["System.out"].println(result->trim()) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Pretty_Permutations {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testcase=sc.nextInt();
    while(testcase!=0){
      testcase--;
      int num=sc.nextInt();
      for(int i=2 ; i<=num ; i+=2){
        if(num % 2==1 && i>num-3){
          System.out.print(i+" "+(i+1)+" "+(i-1));
        }
        else if(i % 2==0)System.out.print(i+" "+(i-1));
        if(i<=num-1)System.out.print(" ");
      }
      if(testcase>0)System.out.println();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Pretty_Permutations {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testcase : int ; testcase := sc.getCurrent()->toInteger() ;
     while (testcase /= 0) do (     testcase := testcase - 1 ; 
     var num : int ; num := sc.getCurrent()->toInteger() ;
         var i : int ; i := 2 ; while i <= num do ( (     if (num mod 2 = 1 & i > num - 3) then (     OclFile["System.out"].print(i + " " + (i + 1) + " " + (i - 1)) ) else     if (i mod 2 = 0) then     OclFile["System.out"].print(i + " " + (i - 1)) ; else skip ; ;  
     if (i <= num - 1) then     OclFile["System.out"].print(" ") ; else skip )  ;     i := i+(2) ) ; 
     if (testcase > 0) then     OclFile["System.out"].println() ; else skip ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Pretty_Permutations {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testcase=sc.nextInt();
    while(testcase!=0){
      testcase--;
      int num=sc.nextInt();
      for(int i=2 ; i<=num ; i+=2){
        if(num % 2==1 && i>num-3){
          System.out.print(i+" "+(i+1)+" "+(i-1));
        }
        else if(i % 2==0)System.out.print(i+" "+(i-1));
        if(i<=num-1)System.out.print(" ");
      }
      if(testcase>0)System.out.println();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Pretty_Permutations {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testcase : int ; testcase := sc.getCurrent()->toInteger() ;
     while (testcase /= 0) do (     testcase := testcase - 1 ; 
     var num : int ; num := sc.getCurrent()->toInteger() ;
         var i : int ; i := 2 ; while i <= num do ( (     if (num mod 2 = 1 & i > num - 3) then (     OclFile["System.out"].print(i + " " + (i + 1) + " " + (i - 1)) ) else     if (i mod 2 = 0) then     OclFile["System.out"].print(i + " " + (i - 1)) ; else skip ; ;  
     if (i <= num - 1) then     OclFile["System.out"].print(" ") ; else skip )  ;     i := i+(2) ) ; 
     if (testcase > 0) then     OclFile["System.out"].println() ; else skip ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int cnt=0 ;
  static Vector<Vector<Integer>>graph=new Vector<Vector<Integer>>();
  static Vector<String>weight=new Vector<String>();
  static boolean isPalindrome(String x){
    int n=x.length();
    for(int i=0 ; i<n/2 ; i++){
      if(x.charAt(i)!=x.charAt(n-1-i))return false ;
    }
    return true ;
  }
  static void dfs(int node,int parent){
    String x=weight.get(node);
    if(isPalindrome(x))cnt+=1 ;
    for(int i=0 ; i<graph.get(node).size(); i++){
      if(graph.get(node).get(i)==parent)continue ;
      dfs(graph.get(node).get(i),node);
    }
  }
  public static void main(String args[]){
    weight.add("");
    weight.add("abc");
    weight.add("aba");
    weight.add("bcb");
    weight.add("moh");
    weight.add("aa");
    for(int i=0 ; i<100 ; i++)graph.add(new Vector<Integer>());
    graph.get(1).add(2);
    graph.get(2).add(3);
    graph.get(2).add(4);
    graph.get(1).add(5);
    dfs(1,1);
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute cnt : int := 0;
  static   attribute graph : Sequence(Sequence(int)) := Sequence{};
  static   attribute weight : Sequence(String) := Sequence{};
  static   operation isPalindrome( x : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := x->size() ;
         var i : int ; i := 0 ; while i < n / 2 do ( (     if (x->at(i+1) /= x->at(n - 1 - i+1)) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation dfs( node : int, parent : int) : void
  pre: true
  post: true
  activity: (     var x : String ; x := weight->at(node+1) ;
     if (isPalindrome(x)) then     cnt := cnt+(1) ; else skip ; 
         var i : int ; i := 0 ; while i < graph->at(node+1)->size() do ( (     if (graph->at(node+1)->at(i+1) = parent) then     continue else skip ; 
     execute dfs(graph->at(node+1)->at(i+1), node) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     weight := weight->including("") ; 
     weight := weight->including("abc") ; 
    weight := weight->including("aba") ; 
    weight := weight->including("bcb") ; 
    weight := weight->including("moh") ; 
    weight := weight->including("aa") ; 
        var i : int ; i := 0 ; while i < 100 do (     graph := graph->including(Sequence{}) ;  ;     i := i + 1 ) ; 
    graph->at(1+1)->excludes(2) ; 
    graph->at(2+1)->excludes(3) ; 
    graph->at(2+1)->excludes(4) ; 
    graph->at(1+1)->excludes(5) ; 
    execute dfs(1, 1) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n-->0){
      boolean[] used=new boolean[14];
      boolean ans=false ;
      for(int i=0 ; i<6 ; i++){
        used[sc.nextInt()]=true ;
      }
      if(used[1]==used[13])ans=! used[1];
      else {
        int l=6,r=8 ;
        boolean t=false ;
        for(; ; ){
          if(t==used[1]){
            if(used[r] ^ t)r++;
            else if(used[l] ^ t)l--;
          }
          else {
            if(used[l] ^ t)l--;
            else if(used[r] ^ t)r++;
          }
          if(r==13){
            ans=! used[1];
            break ;
          }
          if(l==1){
            ans=used[1];
            break ;
          }
          t=! t ;
        }
      }
      System.out.println(ans ? "yes" : "no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var used : Sequence(boolean) ; used := Integer.subrange(1,14)->collect(false) ;
     var ans : boolean ; ans := false ;
        var i : int ; i := 0 ; while i < 6 do ( (     used[sc.getCurrent()->toInteger()+1] := true )  ;     i := i + 1 ) ; 
    if (used[1+1] = used[13+1]) then     ans := not(used[1+1]) else (     var l : int ; l := 6 ;
    var r : int ; r := 8 ;
     var t : boolean ; t := false ;
       while true do ( (     if (t = used[1+1]) then (     if (used[r+1] xor t) then     r := r + 1 ; else     if (used[l+1] xor t) then     l := l - 1 ; else skip ; ) else (     if (used[l+1] xor t) then     l := l - 1 ; else     if (used[r+1] xor t) then     r := r + 1 ; else skip ; ) ;  
     if (r = 13) then (     ans := not(used[1+1]) ; 
     break ) else skip ; 
     if (l = 1) then (     ans := used[1+1] ; 
     break ) else skip ; 
     t := not(t) )  ) ) ;  
    OclFile["System.out"].println(if ans then "yes" else "no" endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int a=Integer.parseInt(st.nextToken());
    int b=Integer.parseInt(st.nextToken());
    if(a<=0 && 0<=b){
      System.out.println("Zero");
    }
    else if(0<=a && 0<=b){
      System.out.println("Positive");
    }
    else {
      System.out.println((Math.abs(b)-Math.abs(a)+1)% 2==0 ? "Positive" : "Negative");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var a : int ; a := (st.next())->toInteger() ;
    var b : int ; b := (st.next())->toInteger() ;
    if (a <= 0 & 0 <= b) then (     OclFile["System.out"].println("Zero") ) else     if (0 <= a & 0 <= b) then (     OclFile["System.out"].println("Positive") ) else (     OclFile["System.out"].println(if (if b < 0 then -(b) else b endif - if a < 0 then -(a) else a endif + 1) mod 2 = 0 then "Positive" else "Negative" endif) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n-->0){
      boolean[] used=new boolean[14];
      boolean ans=false ;
      for(int i=0 ; i<6 ; i++){
        used[sc.nextInt()]=true ;
      }
      if(used[1]==used[13])ans=! used[1];
      else {
        int l=6,r=8 ;
        boolean t=false ;
        for(; ; ){
          if(t==used[1]){
            if(used[r] ^ t)r++;
            else if(used[l] ^ t)l--;
          }
          else {
            if(used[l] ^ t)l--;
            else if(used[r] ^ t)r++;
          }
          if(r==13 || l==1){
            ans=used[1] ^ r==13 ;
            break ;
          }
          t=! t ;
        }
      }
      System.out.println(ans ? "yes" : "no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var used : Sequence(boolean) ; used := Integer.subrange(1,14)->collect(false) ;
     var ans : boolean ; ans := false ;
        var i : int ; i := 0 ; while i < 6 do ( (     used[sc.getCurrent()->toInteger()+1] := true )  ;     i := i + 1 ) ; 
    if (used[1+1] = used[13+1]) then     ans := not(used[1+1]) else (     var l : int ; l := 6 ;
    var r : int ; r := 8 ;
     var t : boolean ; t := false ;
       while true do ( (     if (t = used[1+1]) then (     if (used[r+1] xor t) then     r := r + 1 ; else     if (used[l+1] xor t) then     l := l - 1 ; else skip ; ) else (     if (used[l+1] xor t) then     l := l - 1 ; else     if (used[r+1] xor t) then     r := r + 1 ; else skip ; ) ;  
     if (r = 13 or l = 1) then (     ans := used[1+1] xor r = 13 ; 
     break ) else skip ; 
     t := not(t) )  ) ) ;  
    OclFile["System.out"].println(if ans then "yes" else "no" endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n-->0){
      boolean[] used=new boolean[14];
      boolean ans=false ;
      for(int i=0 ; i<6 ; i++){
        used[sc.nextInt()]=true ;
      }
      if(used[1]==used[13])ans=! used[1];
      else {
        int[] r={
          6,8 };
          boolean t=false ;
          for(; ; ){
            int a=t==used[1] ? 1 : 0 ;
            int b=(a+1)% 2 ;
            if(used[r[a] ] ^ t)r[a]+=a==1 ? 1 :-1 ;
            else if(used[r[b] ] ^ t)r[b]+=b==1 ? 1 :-1 ;
            if(r[1]==13 || r[0]==1){
              ans=used[1] ^ r[1]==13 ;
              break ;
            }
            t=! t ;
          }
        }
        System.out.println(ans ? "yes" : "no");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var used : Sequence(boolean) ; used := Integer.subrange(1,14)->collect(false) ;
     var ans : boolean ; ans := false ;
        var i : int ; i := 0 ; while i < 6 do ( (     used[sc.getCurrent()->toInteger()+1] := true )  ;     i := i + 1 ) ; 
    if (used[1+1] = used[13+1]) then     ans := not(used[1+1]) else (     var r : Sequence(int) ; r := Sequence{6,8} ;
     var t : boolean ; t := false ;
       while true do ( (     var a : int ; a := if t = used[1+1] then 1 else 0 endif ;
     var b : int ; b := (a + 1) mod 2 ;
    if (used[r[a+1]+1] xor t) then     r[a+1] := r[a+1]+(if a = 1 then 1 else -1 endif) else     if (used[r[b+1]+1] xor t) then     r[b+1] := r[b+1]+(if b = 1 then 1 else -1 endif) ; else skip ; ;  
    if (r[1+1] = 13 or r[0+1] = 1) then (     ans := used[1+1] xor r[1+1] = 13 ; 
     break ) else skip ; 
    t := not(t) ; 
 )  ) ) ;  
    OclFile["System.out"].println(if ans then "yes" else "no" endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math ;
public class Main {
  public static void main(String[] args){
    long count=0 ;
    double quo=1 ;
    int quo_max_n=0 ;
    Scanner scan=new Scanner(System.in);
    double t=0 ;
    t=scan.nextLong();
    for(int n=0 ; ; n++){
      if(t<(Math.pow(3,n)-Math.pow(3,n-1)-2)){
        quo_max_n=n-2 ;
        break ;
      }
    }
    count=quo_max_n+1 ;
    quo=Math.pow(3,quo_max_n);
    for(double tmp=t-(Math.pow(3,count)-1)/2 ; tmp>0 ; count++){
      if(tmp>=(quo-1)*3/2){
        tmp=tmp-quo ;
        continue ;
      }
      if(tmp<(quo-1)*3/2){
        quo=quo/3 ;
        tmp=tmp-quo ;
        continue ;
      }
    }
    if(t==0){
      count=0 ;
    }
    System.out.println(count);
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
     var quo : double ; quo := 1 ;
    var quo_max_n : int ; quo_max_n := 0 ;
    var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var t : double ; t := 0 ;
    t := scan.getCurrent()->toLong() ; 
        var n : int ; n := 0 ; while true do ( (     if (t < (3->pow(n) - 3->pow(n - 1) - 2)) then (     quo_max_n := n - 2 ; 
     break ) else skip )  ;     n := n + 1 ) ; 
    count := quo_max_n + 1 ; 
    quo := 3->pow(quo_max_n) ; 
        var tmp : double ; tmp := t - (3->pow(count) - 1) / 2 ; while tmp > 0 do ( (     if (tmp >= (quo - 1) * 3 / 2) then (     tmp := tmp - quo ; 
     continue ) else skip ; 
     if (tmp < (quo - 1) * 3 / 2) then (     quo := quo / 3 ; 
     tmp := tmp - quo ; 
     continue ) else skip )  ;     count := count + 1 ) ; 
    if (t = 0) then (     count := 0 ) else skip ; 
    OclFile["System.out"].println(count) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.stream.Collectors ;
public class Main {
  static final char[] VALUES={
    'S','E','T' };
    public static void main(String[] args){
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      sc.nextInt();
      String[] cards=new String[n];
      for(int i=0 ; i<cards.length ; ++i){
        cards[i]=sc.next();
      }
      System.out.println(solve(cards));
      sc.close();
    }
    static int solve(String[] cards){
      Set<String>cardSet=Arrays.stream(cards).collect(Collectors.toSet());
      int result=0 ;
      for(int i=0 ; i<cards.length ; ++i){
        for(int j=i+1 ; j<cards.length ; ++j){
          if(cardSet.contains(computeTarget(cards[i],cards[j]))){
++result ;
          }
        }
      }
      result/=3 ;
      return result ;
    }
    static String computeTarget(String card1,String card2){
      StringBuilder result=new StringBuilder();
      for(int i=0 ; i<card1.length(); ++i){
        char ch1=card1.charAt(i);
        char ch2=card2.charAt(i);
        char ch ;
        if(ch1==ch2){
          ch=ch1 ;
        }
        else {
          for(int j=0 ; ; ++j){
            if(VALUES[j]!=ch1 && VALUES[j]!=ch2){
              ch=VALUES[j];
              break ;
            }
          }
        }
        result.append(ch);
      }
      return result.toString();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute VALUES : Sequence(String) := Sequence{'S','E','T'};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
    var cards : Sequence(String) ; cards := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < cards->size() do ( (     cards[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(cards)) ; 
    skip ; 
 );
  static   operation solve( cards : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var cardSet : Set(String) ; cardSet := stream(cards).collect(Collectors.toSet()) ;
     var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < cards->size() do ( (         var j : int ; j := i + 1 ; while j < cards->size() do ( (     if (cardSet->includes(computeTarget(cards[i+1], cards[j+1]))) then (     result := result + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    result := result/(3) ; 
    return result 
 );
  static   operation computeTarget( card1 : String, card2 : String) : String
  pre: true
  post: true
  activity: (     var result : String ; result := StringLib.newString() ;
         var i : int ; i := 0 ; while i < card1->size() do ( (     var ch1 : String ; ch1 := card1->at(i+1) ;
     var ch2 : String ; ch2 := card2->at(i+1) ;
    var ch : String ;
    if (ch1 = ch2) then (     ch := ch1 ) else (         var j : int ; j := 0 ; while true do ( (     if (VALUES[j+1] /= ch1 & VALUES[j+1] /= ch2) then (     ch := VALUES[j+1] ; 
     break ) else skip )  ;     j := j + 1 ) ) ;  
    result := result + StringLib.newString(ch) ; 
 )  ;     i := i + 1 ) ; 
     return result+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static int mat[][]=new int[105][105];
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      int w=in.nextInt(),h=in.nextInt();
      if(w==0 && h==0)return ;
      int sx=in.nextInt(),sy=in.nextInt();
      int gx=in.nextInt(),gy=in.nextInt();
      int n=in.nextInt();
      for(int i=0 ; i<105 ; i++)for(int j=0 ; j<105 ; j++)mat[i][j]=-1 ;
      for(int i=0 ; i<n ; i++){
        int c=in.nextInt(),d=in.nextInt(),x=in.nextInt(),y=in.nextInt();
        if(d==1){
          for(int j=0 ; j<2 ; j++)for(int k=0 ; k<4 ; k++)mat[x+j][y+k]=c ;
        }
        else {
          for(int j=0 ; j<4 ; j++)for(int k=0 ; k<2 ; k++)mat[x+j][y+k]=c ;
        }
      }
      if(mat[sx][sy]==-1){
        System.out.println("NG");
        continue ;
      }
      dfs(sx,sy,mat[sx][sy]);
      System.out.println((mat[gx][gy]==-2)? "OK" : "NG");
    }
  }
  static void dfs(int i,int j,int col){
    if(mat[i][j]!=col)return ;
    mat[i][j]=-2 ;
    dfs(i+1,j,col);
    dfs(i,j+1,col);
    dfs(i-1,j,col);
    dfs(i,j-1,col);
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mat : int := Integer.subrange(1,105)->collect(Integer.subrange(1,105)->collect(0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var w : int ; w := in.getCurrent()->toInteger() ;
    var h : int ; h := in.getCurrent()->toInteger() ;
     if (w = 0 & h = 0) then     return else skip ; 
    var sx : int ; sx := in.getCurrent()->toInteger() ;
    var sy : int ; sy := in.getCurrent()->toInteger() ;
    var gx : int ; gx := in.getCurrent()->toInteger() ;
    var gy : int ; gy := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < 105 do (         var j : int ; j := 0 ; while j < 105 do (     mat[i+1][j+1] := -1 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var c : int ; c := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
    var y : int ; y := in.getCurrent()->toInteger() ;
     if (d = 1) then (         var j : int ; j := 0 ; while j < 2 do (         var k : int ; k := 0 ; while k < 4 do (     mat[x + j+1][y + k+1] := c ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ) else (         var j : int ; j := 0 ; while j < 4 do (         var k : int ; k := 0 ; while k < 2 do (     mat[x + j+1][y + k+1] := c ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
    if (mat[sx+1][sy+1] = -1) then (     OclFile["System.out"].println("NG") ; 
     continue ) else skip ; 
    execute dfs(sx, sy, mat[sx+1][sy+1]) ; 
    OclFile["System.out"].println(if (mat[gx+1][gy+1] = -2) then "OK" else "NG" endif) ; 
 )  ) );
  static   operation dfs( i : int, j : int, col : int) : void
  pre: true
  post: true
  activity: (     if (mat[i+1][j+1] /= col) then     return else skip ; 
     mat[i+1][j+1] := -2 ; 
    execute dfs(i + 1, j, col) ; 
    execute dfs(i, j + 1, col) ; 
    execute dfs(i - 1, j, col) ; 
    execute dfs(i, j - 1, col) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static Scanner input=new Scanner(System.in);
  public static void main(String[] args){
    int primes=0,count=0,n=input.nextInt();
    if(n<=2){
      System.out.println(0);
    }
    else {
      for(int i=3 ; i<=n ; i++){
        for(int j=2 ; j<i ; j++){
          if(i % j==0)if(isPrime(j)){
            count++;
          }
        }
        if(count==2)primes++;
        count=0 ;
      }
      System.out.println(primes);
    }
  }
  static boolean isPrime(int num){
    if(num==1){
      return true ;
    }
    else if(num<1)return false ;
    for(int i=2 ; i<=num/2 ; i++){
      if((num % i)==0)return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute input : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var primes : int ; primes := 0 ;
    var count : int ; count := 0 ;
    var n : int ; n := input.getCurrent()->toInteger() ;
     if (n <= 2) then (     OclFile["System.out"].println(0) ) else (         var i : int ; i := 3 ; while i <= n do ( (         var j : int ; j := 2 ; while j < i do ( (     if (i mod j = 0) then     if (isPrime(j)) then (     count := count + 1 ) else skip ; else skip )  ;     j := j + 1 ) ; 
     if (count = 2) then     primes := primes + 1 ; else skip ; 
     count := 0 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(primes) ) );
  static   operation isPrime( num : int) : boolean
  pre: true
  post: true
  activity: (     if (num = 1) then (     return true ) else     if (num < 1) then     return false else skip ; ;  
         var i : int ; i := 2 ; while i <= num / 2 do ( (     if ((num mod i) = 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int gcd(int a,int b){
    if(a==0 || b==0)return 0 ;
    if(a==b)return a ;
    if(a>b)return gcd(a-b,b);
    return gcd(a,b-a);
  }
  public static void main(String[] args){
    int a=98,b=56 ;
    System.out.println("GCD of "+a+" and "+b+" is "+gcd(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0 or b = 0) then     return 0 else skip ; 
     if (a = b) then     return a else skip ; 
     if (a > b) then     return gcd(a - b, b) else skip ; 
     return gcd(a, b - a) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 98 ;
    var b : int ; b := 56 ;
     OclFile["System.out"].println("GCD of " + a + " and " + b + " is " + gcd(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  public static void main(String[] args){
    int a=98,b=56 ;
    System.out.println("GCD of "+a+" and "+b+" is "+gcd(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 98 ;
    var b : int ; b := 56 ;
     OclFile["System.out"].println("GCD of " + a + " and " + b + " is " + gcd(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    if(a==b)return a ;
    if(a>b)return gcd(a-b,b);
    return gcd(a,b-a);
  }
  public static void main(String[] args){
    int a=98,b=56 ;
    System.out.println("GCD of "+a+" and "+b+" is "+gcd(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
    if (a = b) then     return a else skip ; 
    if (a > b) then     return gcd(a - b, b) else skip ; 
    return gcd(a, b - a) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 98 ;
    var b : int ; b := 56 ;
     OclFile["System.out"].println("GCD of " + a + " and " + b + " is " + gcd(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int a=scanner.nextInt();
    int b=scanner.nextInt();
    if(a>0){
      System.out.println("Positive");
    }
    else if(b>=0){
      System.out.println("Zero");
    }
    else if((b-a+1)% 2==0){
      System.out.println("Positive");
    }
    else {
      System.out.println("Negative");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
     if (a > 0) then (     OclFile["System.out"].println("Positive") ) else     if (b >= 0) then (     OclFile["System.out"].println("Zero") ) else     if ((b - a + 1) mod 2 = 0) then (     OclFile["System.out"].println("Positive") ) else (     OclFile["System.out"].println("Negative") ) ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static int lcm(int a,int b){
    return(a*b)/gcd(a,b);
  }
  public static void main(String[] args){
    int a=15,b=20 ;
    System.out.println("LCM of "+a+" and "+b+" is "+lcm(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return (a * b) / gcd(a, b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 15 ;
    var b : int ; b := 20 ;
     OclFile["System.out"].println("LCM of " + a + " and " + b + " is " + lcm(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  public static void main(String[] args){
    int a=98,b=56 ;
    System.out.println("GCD of "+a+" and "+b+" is "+gcd(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 98 ;
    var b : int ; b := 56 ;
     OclFile["System.out"].println("GCD of " + a + " and " + b + " is " + gcd(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static int lcm(int a,int b){
    return(a*b)/gcd(a,b);
  }
  public static void main(String[] args){
    int a=15,b=20 ;
    System.out.println("LCM of "+a+" and "+b+" is "+lcm(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return (a * b) / gcd(a, b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 15 ;
    var b : int ; b := 20 ;
     OclFile["System.out"].println("LCM of " + a + " and " + b + " is " + lcm(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p188 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p188().run());
  }
  public String run(){
    return Integer.toString(tetrationMod(1777,1855,Library.pow(10,8)));
  }
  private static int tetrationMod(int x,int y,int m){
    if(y==1)return x % m ;
    else return Library.powMod(x,tetrationMod(x,y-1,Library.totient(m)),m);
  }
}
------------------------------------------------------------
OCL File:
---------
class p188 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p188.newp188().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     return ((tetrationMod(1777, 1855, Library.pow(10, 8))) + "") );
  static   operation tetrationMod( x : int, y : int, m : int) : int
  pre: true
  post: true
  activity: (     if (y = 1) then     return x mod m else     return Library.powMod(x, tetrationMod(x, y - 1, Library.totient(m)), m) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int min_sum(int n,int k,int a[]){
    Arrays.sort(a);
    if(a[0]<0)return-1 ;
    if(k==0){
      if(a[0]==a[n-1])return(n*a[0]);
      else return-1 ;
    }
    else {
      int f=0 ;
      for(int i=1 ; i<n ; i++){
        int p=a[i]-a[0];
        if(p % k==0)continue ;
        else {
          f=1 ;
          break ;
        }
      }
      if(f>0)return-1 ;
      else {
        if(k==1)return n ;
        else return(n*(a[0] % k));
      }
    }
  }
  public static void main(String[] args){
    int arr[]={
      2,3,4,5 };
      int K=1 ;
      int N=arr.length ;
      System.out.println(min_sum(N,K,arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation min_sum( n : int, k : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     if (a[0+1] < 0) then     return -1 else skip ; 
     if (k = 0) then (     if (a[0+1] = a[n - 1+1]) then     return (n * a[0+1]) else     return -1 ) else (     var f : int ; f := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     var p : int ; p := a[i+1] - a[0+1] ;
     if (p mod k = 0) then     continue else (     f := 1 ; 
     break ) )  ;     i := i + 1 ) ; 
     if (f > 0) then     return -1 else (     if (k = 1) then     return n else     return (n * (a[0+1] mod k)) ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4,5} ;
     var K : int ; K := 1 ;
     var N : int ; N := arr->size() ;
     OclFile["System.out"].println(min_sum(N, K, arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public ListNode removeNthFromEnd(ListNode head,int n){
    ListNode slow,fast,curr ;
    slow=head ;
    fast=head ;
    for(int i=0 ; i<n ; i++)fast=fast.next ;
    if(fast==null){
      head=head.next ;
      return head ;
    }
    while(fast.next!=null){
      fast=fast.next ;
      slow=slow.next ;
    }
    curr=slow.next ;
    slow.next=curr.next ;
    return head ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation removeNthFromEnd( head : ListNode, n : int) : ListNode
  pre: true
  post: true
  activity: (     var slow : ListNode ;
    var fast : ListNode ;
    var curr : ListNode ;
     slow := head ; 
    fast := head ; 
        var i : int ; i := 0 ; while i < n do (     fast := fast.next ;  ;     i := i + 1 ) ; 
    if (fast = null) then (     head := head.next ; 
     return head ) else skip ; 
    while (fast.next /= null) do (     fast := fast.next ; 
     slow := slow.next ) ; 
    curr := slow.next ; 
    slow.next := curr.next ; 
    return head 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String findMaxLenEven(String str){
    int n=str.length();
    int i=0 ;
    int currlen=0 ;
    int maxlen=0 ;
    int st=-1 ;
    while(i<n){
      if(str.charAt(i)==' '){
        if(currlen % 2==0){
          if(maxlen<currlen){
            maxlen=currlen ;
            st=i-currlen ;
          }
        }
        currlen=0 ;
      }
      else {
        currlen++;
      }
      i++;
    }
    if(currlen % 2==0){
      if(maxlen<currlen){
        maxlen=currlen ;
        st=i-currlen ;
      }
    }
    if(st==-1)return "-1" ;
    return str.substring(st,st+maxlen);
  }
  public static void main(String args[]){
    String str="this is a test string" ;
    System.out.println(findMaxLenEven(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMaxLenEven( str : String) : String
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var i : int ; i := 0 ;
    var currlen : int ; currlen := 0 ;
    var maxlen : int ; maxlen := 0 ;
    var st : int ; st := -1 ;
    while (i < n) do (     if (str->at(i+1) = ' ') then (     if (currlen mod 2 = 0) then (     if (maxlen < currlen) then (     maxlen := currlen ; 
     st := i - currlen ) else skip ) else skip ; 
     currlen := 0 ) else (     currlen := currlen + 1 ) ;  
     i := i + 1 ) ; 
    if (currlen mod 2 = 0) then (     if (maxlen < currlen) then (     maxlen := currlen ; 
     st := i - currlen ) else skip ) else skip ; 
    if (st = -1) then     return "-1" else skip ; 
    return str.subrange(st+1,st + maxlen) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "this is a test string" ;
     OclFile["System.out"].println(findMaxLenEven(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class H_Almost_Prime {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    int n=sc.nextInt();
    int ans=0 ;
    for(int i=6 ; i<=n ; i++){
      int temp=i ;
      int count=0 ;
      for(int j=2 ; j*j<=temp ; j++){
        if(temp % j==0){
          count++;
          while(temp % j==0)temp/=j ;
        }
      }
      if(temp>1)count++;
      if(count==2)ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class H_Almost_Prime {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 6 ; while i <= n do ( (     var temp : int ; temp := i ;
     var count : int ; count := 0 ;
        var j : int ; j := 2 ; while j * j <= temp do ( (     if (temp mod j = 0) then (     count := count + 1 ; 
     while (temp mod j = 0) do     temp := temp/(j) ; ) else skip )  ;     j := j + 1 ) ; 
    if (temp > 1) then     count := count + 1 ; else skip ; 
    if (count = 2) then     ans := ans + 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int pairsInSortedRotated(int arr[],int n,int x){
    int i ;
    for(i=0 ; i<n-1 ; i++)if(arr[i]>arr[i+1])break ;
    int l=(i+1)% n ;
    int r=i ;
    int cnt=0 ;
    while(l!=r){
      if(arr[l]+arr[r]==x){
        cnt++;
        if(l==(r-1+n)% n){
          return cnt ;
        }
        l=(l+1)% n ;
        r=(r-1+n)% n ;
      }
      else if(arr[l]+arr[r]<x)l=(l+1)% n ;
      else r=(n+r-1)% n ;
    }
    return cnt ;
  }
  public static void main(String[] args){
    int arr[]={
      11,15,6,7,9,10 };
      int sum=16 ;
      int n=arr.length ;
      System.out.println(pairsInSortedRotated(arr,n,sum));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pairsInSortedRotated( arr : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
         i := 0 ; while i < n - 1 do (     if (arr[i+1] > arr[i + 1+1]) then     break else skip ;  ;     i := i + 1 ) ; 
    var l : int ; l := (i + 1) mod n ;
    var r : int ; r := i ;
    var cnt : int ; cnt := 0 ;
    while (l /= r) do (     if (arr[l+1] + arr[r+1] = x) then (     cnt := cnt + 1 ; 
     if (l = (r - 1 + n) mod n) then (     return cnt ) else skip ; 
     l := (l + 1) mod n ; 
     r := (r - 1 + n) mod n ) else     if (arr[l+1] + arr[r+1] < x) then     l := (l + 1) mod n else     r := (n + r - 1) mod n ; ;  ) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{11,15,6,7,9,10} ;
     var sum : int ; sum := 16 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(pairsInSortedRotated(arr, n, sum)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p129 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p129().run());
  }
  private static final int LIMIT=Library.pow(10,6);
  public String run(){
    for(int n=LIMIT ; ; n++){
      if(findLeastDivisibleRepunit(n)>LIMIT)return Integer.toString(n);
    }
  }
  private static int findLeastDivisibleRepunit(int n){
    if(n % 2==0 || n % 5==0)return 0 ;
    if(n>Integer.MAX_VALUE/10)throw new IllegalArgumentException("Arithmetic overflow");
    int sum=1 ;
    int pow=1 ;
    int k=1 ;
    while(sum % n!=0){
      k++;
      pow=pow*10 % n ;
      sum=(sum+pow)% n ;
    }
    return k ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p129 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p129.newp129().run()) );
  static    attribute LIMIT : int := Library.pow(10, 6);
   operation run() : String
  pre: true
  post: true
  activity: (         var n : int ; n := LIMIT ; while true do ( (     if (findLeastDivisibleRepunit(n) > LIMIT) then     return ((n) + "") else skip )  ;     n := n + 1 ) );
  static   operation findLeastDivisibleRepunit( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 = 0 or n mod 5 = 0) then     return 0 else skip ; 
     if (n > 2147483647 / 10) then     error IllegalArgumentException.newIllegalArgumentException("Arithmetic overflow") ; else skip ; 
    var sum : int ; sum := 1 ;
    var pow : int ; pow := 1 ;
    var k : int ; k := 1 ;
    while (sum mod n /= 0) do (     k := k + 1 ; 
     pow := pow * 10 mod n ; 
     sum := (sum + pow) mod n ) ; 
    return k 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  BufferedReader br ;
  PrintWriter out ;
  StringTokenizer st ;
  boolean eof ;
  void solve()throws IOException {
    int a=nextInt();
    int b=nextInt();
    if(a<=0 && b>=0){
      out.println("Zero");
      return ;
    }
    int cnt=a>0 ? 0 :(b-a+1);
    out.println(cnt % 2==1 ? "Negative" : "Positive");
  }
  Main()throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(System.out);
    solve();
    out.close();
  }
  public static void main(String[] args)throws IOException {
    new Main();
  }
  String nextToken(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
        eof=true ;
        return null ;
      }
    }
    return st.nextToken();
  }
  String nextString(){
    try {
      return br.readLine();
    }
    catch(IOException e){
      eof=true ;
      return null ;
    }
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute br : OclFile;
   attribute out : OclFile;
   attribute st : OclIterator;
   attribute eof : boolean;
   operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ; a := nextInt() ;
     var b : int ; b := nextInt() ;
    if (a <= 0 & b >= 0) then (     skip ; 
     return ) else skip ; 
    var cnt : int ; cnt := if a > 0 then 0 else (b - a + 1) endif ;
    skip ; 
 );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     execute solve() ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     eof := true ; 
     return null )
 ) ; 
     return st.next() );
   operation nextString() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do (     eof := true ; 
     return null )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getPassingCars(int A[],int n){
    int countOne=0,result=0 ;
    while(n>=1){
      if(A[n-1]==1)countOne++;
      else result+=countOne ;
      n--;
    }
    return result ;
  }
  public static void main(String[] args){
    int A[]={
      0,1,0,1,1 };
      int n=A.length ;
      System.out.println(getPassingCars(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getPassingCars( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var countOne : int ; countOne := 0 ;
    var result : int ; result := 0 ;
     while (n >= 1) do (     if (A[n - 1+1] = 1) then     countOne := countOne + 1 else     result := result+(countOne) ; ;  
     n := n - 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{0,1,0,1,1} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].println(getPassingCars(A, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p046 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p046().run());
  }
  public String run(){
    for(int i=9 ; ; i+=2){
      if(! satisfiesConjecture(i))return Integer.toString(i);
    }
  }
  private static boolean satisfiesConjecture(int n){
    if(n % 2==0 || Library.isPrime(n))return true ;
    for(int i=1 ; i*i*2<=n ; i++){
      if(Library.isPrime(n-i*i*2))return true ;
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p046 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p046.newp046().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (         var i : int ; i := 9 ; while true do ( (     if (not(satisfiesConjecture(i))) then     return ((i) + "") else skip )  ;     i := i+(2) ) );
  static   operation satisfiesConjecture( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n mod 2 = 0 or Library.isPrime(n)) then     return true else skip ; 
         var i : int ; i := 1 ; while i * i * 2 <= n do ( (     if (Library.isPrime(n - i * i * 2)) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BlockAdventure {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    for(int t=in.nextInt(); t>0 ; t--){
      int n=in.nextInt();
      int m=in.nextInt();
      int k=in.nextInt();
      int prev=in.nextInt();
      boolean answer=true ;
      for(int i=1 ; i<n ; i++){
        int next=in.nextInt();
        m+=prev-Math.max(0,(next-k));
        prev=next ;
        if(m<0){
          answer=false ;
        }
      }
      System.out.println(answer ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BlockAdventure {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var t : int ; t := in.getCurrent()->toInteger() ; while t > 0 do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var prev : int ; prev := in.getCurrent()->toInteger() ;
    var answer : boolean ; answer := true ;
        var i : int ; i := 1 ; while i < n do ( (     var next : int ; next := in.getCurrent()->toInteger() ;
     m := m+(prev - Set{0, (next - k)}->max()) ; 
     prev := next ; 
     if (m < 0) then (     answer := false ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if answer then "YES" else "NO" endif) ; 
 )  ;     t := t - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class climb {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t,j,n,m,k,i,h[],d ;
    t=sc.nextInt();
    for(j=1 ; j<=t ; j++){
      n=sc.nextInt();
      m=sc.nextInt();
      k=sc.nextInt();
      h=new int[n];
      for(i=0 ; i<n ; i++)h[i]=sc.nextInt();
      for(i=0 ; i<n-1 ; i++){
        if(h[i+1]>=h[i]){
          d=h[i+1]-h[i];
          if(d>k){
            if(d-k<=m)m=m-d+k ;
            else break ;
          }
          else {
            d=k-d ;
            m=m+Math.min(d,h[i]);
          }
        }
        else {
          d=h[i]-h[i+1];
          m=m+d+Math.min(k,h[i+1]);
        }
      }
      if(i!=n-1)System.out.println("NO");
      else System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class climb {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ;
    var j : int ;
    var n : int ;
    var m : int ;
    var k : int ;
    var i : int ;
    var h : Sequence(void) ;
    var d : int ;
     t := sc.getCurrent()->toInteger() ; 
         j := 1 ; while j <= t do ( (     n := sc.getCurrent()->toInteger() ; 
     m := sc.getCurrent()->toInteger() ; 
    k := sc.getCurrent()->toInteger() ; 
    h := Integer.subrange(1,n)->collect(0) ; 
        i := 0 ; while i < n do (     h[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n - 1 do ( (     if (h[i + 1+1] >= h[i+1]) then (     d := h[i + 1+1] - h[i+1] ; 
     if (d > k) then (     if (d - k <= m) then     m := m - d + k ; else     break ) else (     d := k - d ; 
     m := m + Set{d, h[i+1]}->min() ) ) else (     d := h[i+1] - h[i + 1+1] ; 
     m := m + d + Set{k, h[i + 1+1]}->min() ) )  ;     i := i + 1 ) ; 
    if (i /= n - 1) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  
 )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BlockAdventure {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    for(int t=in.nextInt(); t>0 ; t--){
      int n=in.nextInt();
      int m=in.nextInt();
      int k=in.nextInt();
      int prev=in.nextInt();
      boolean answer=true ;
      for(int i=1 ; i<n ; i++){
        int next=in.nextInt();
        m+=prev-Math.max(0,(next-k));
        prev=next ;
        if(m<0){
          answer=false ;
        }
      }
      System.out.println(answer ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BlockAdventure {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var t : int ; t := in.getCurrent()->toInteger() ; while t > 0 do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var prev : int ; prev := in.getCurrent()->toInteger() ;
    var answer : boolean ; answer := true ;
        var i : int ; i := 1 ; while i < n do ( (     var next : int ; next := in.getCurrent()->toInteger() ;
     m := m+(prev - Set{0, (next - k)}->max()) ; 
     prev := next ; 
     if (m < 0) then (     answer := false ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if answer then "YES" else "NO" endif) ; 
 )  ;     t := t - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BlockAdventure {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    for(int t=in.nextInt(); t>0 ; t--){
      int n=in.nextInt();
      int m=in.nextInt();
      int k=in.nextInt();
      int prev=in.nextInt();
      boolean answer=true ;
      for(int i=1 ; i<n ; i++){
        int next=in.nextInt();
        m+=prev-Math.max(0,(next-k));
        prev=next ;
        if(m<0){
          answer=false ;
        }
      }
      System.out.println(answer ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BlockAdventure {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var t : int ; t := in.getCurrent()->toInteger() ; while t > 0 do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var prev : int ; prev := in.getCurrent()->toInteger() ;
    var answer : boolean ; answer := true ;
        var i : int ; i := 1 ; while i < n do ( (     var next : int ; next := in.getCurrent()->toInteger() ;
     m := m+(prev - Set{0, (next - k)}->max()) ; 
     prev := next ; 
     if (m < 0) then (     answer := false ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if answer then "YES" else "NO" endif) ; 
 )  ;     t := t - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Run {
  public static void main(String[] Z)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder op=new StringBuilder();
    StringTokenizer stz ;
    int T=Integer.parseInt(br.readLine());
    while(T-->0){
      stz=new StringTokenizer(br.readLine());
      int n=Integer.parseInt(stz.nextToken());
      int m=Integer.parseInt(stz.nextToken());
      int k=Integer.parseInt(stz.nextToken());
      int[] arr=new int[n];
      stz=new StringTokenizer(br.readLine());
      for(int i=0 ; i<n ; i++){
        arr[i]=Integer.parseInt(stz.nextToken());
      }
      boolean poss=true ;
      for(int i=0 ; i<n-1 ; i++){
        int now=arr[i];
        int next=arr[i+1];
        if(now<next){
          if(next-now>k){
            if(m>=(next-now-k))m-=next-now-k ;
            else {
              poss=false ;
              break ;
            }
          }
          else {
            int add=now-next+k ;
            if(add>now)add=now ;
            m+=add ;
          }
        }
        else {
          int add=now-next+k ;
          if(add>now)add=now ;
          m+=add ;
        }
      }
      if(poss)op.append("YES\n");
      else op.append("NO\n");
    }
    System.out.println(op);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Run {
  static   operation main( Z : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var op : String ; op := StringLib.newString() ;
    var stz : OclIterator ;
    var T : int ; T := (br.readLine())->toInteger() ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     stz := OclIterator.newOclIterator_String(br.readLine()) ; 
     var n : int ; n := (stz.next())->toInteger() ;
    var m : int ; m := (stz.next())->toInteger() ;
    var k : int ; k := (stz.next())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    stz := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (stz.next())->toInteger() )  ;     i := i + 1 ) ; 
    var poss : boolean ; poss := true ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var now : int ; now := arr[i+1] ;
     var next : int ; next := arr[i + 1+1] ;
     if (now < next) then (     if (next - now > k) then (     if (m >= (next - now - k)) then     m := m-(next - now - k) ; else (     poss := false ; 
     break ) ) else (     var add : int ; add := now - next + k ;
     if (add > now) then     add := now ; else skip ; 
     m := m+(add) ) ) else (     var add : int ; add := now - next + k ;
     if (add > now) then     add := now ; else skip ; 
     m := m+(add) ) )  ;     i := i + 1 ) ; 
    if (poss) then     op := op + StringLib.newString("YES\n") else     op := op + StringLib.newString("NO\n") ; ;  
 ) ;  ) ;  
    OclFile["System.out"].println(op) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMinRemoval(int arr[],int n){
    int temp,value=0 ;
    int maximum=0 ;
    if(n==1)return 0 ;
    for(int i=0 ; i<n ; i++){
      if(i!=0 && i!=n-1){
        value=value+Math.abs(arr[i]-arr[i+1]);
        temp=Math.abs(arr[i]-arr[i+1])+Math.abs(arr[i]-arr[i-1])-Math.abs(arr[i-1]-arr[i+1]);
      }
      else if(i==0){
        value=value+Math.abs(arr[i]-arr[i+1]);
        temp=Math.abs(arr[i]-arr[i+1]);
      }
      else temp=Math.abs(arr[i]-arr[i-1]);
      maximum=Math.max(maximum,temp);
    }
    return(value-maximum);
  }
  public static void main(String[] args){
    int arr[]={
      1,5,3,2,10 };
      int n=arr.length ;
      System.out.print(findMinRemoval(arr,n)+"\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMinRemoval( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var temp : int ;
    var value : int ; value := 0 ;
     var maximum : int ; maximum := 0 ;
    if (n = 1) then     return 0 else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i /= 0 & i /= n - 1) then (     value := value + if arr[i+1] - arr[i + 1+1] < 0 then -(arr[i+1] - arr[i + 1+1]) else arr[i+1] - arr[i + 1+1] endif ; 
     temp := if arr[i+1] - arr[i + 1+1] < 0 then -(arr[i+1] - arr[i + 1+1]) else arr[i+1] - arr[i + 1+1] endif + if arr[i+1] - arr[i - 1+1] < 0 then -(arr[i+1] - arr[i - 1+1]) else arr[i+1] - arr[i - 1+1] endif - if arr[i - 1+1] - arr[i + 1+1] < 0 then -(arr[i - 1+1] - arr[i + 1+1]) else arr[i - 1+1] - arr[i + 1+1] endif ) else     if (i = 0) then (     value := value + if arr[i+1] - arr[i + 1+1] < 0 then -(arr[i+1] - arr[i + 1+1]) else arr[i+1] - arr[i + 1+1] endif ; 
     temp := if arr[i+1] - arr[i + 1+1] < 0 then -(arr[i+1] - arr[i + 1+1]) else arr[i+1] - arr[i + 1+1] endif ) else     temp := if arr[i+1] - arr[i - 1+1] < 0 then -(arr[i+1] - arr[i - 1+1]) else arr[i+1] - arr[i - 1+1] endif ; ;  ;  
     maximum := Set{maximum, temp}->max() )  ;     i := i + 1 ) ; 
    return (value - maximum) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,3,2,10} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(findMinRemoval(arr, n) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class A_Almost_Prime {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int N=reader.nextInt();
    boolean isPrime[]=new boolean[N+1];
    for(int i=2 ; i<=N ; i++){
      isPrime[i]=true ;
    }
    isPrime[0]=false ;
    isPrime[1]=false ;
    int[] factors=new int[N+1];
    for(int i=1 ; i<=N ; i++){
      if(isPrime[i]==true){
        factors[i]++;
        for(int j=2*i ; j<=N ; j+=i){
          factors[j]++;
          isPrime[j]=false ;
        }
      }
    }
    int count=0 ;
    for(int i=0 ; i<=N ; i++){
      if(factors[i]==2){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Almost_Prime {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var N : int ; N := reader.nextInt() ;
    var isPrime : Sequence(boolean) ; isPrime := Integer.subrange(1,N + 1)->collect(false) ;
        var i : int ; i := 2 ; while i <= N do ( (     isPrime[i+1] := true )  ;     i := i + 1 ) ; 
    isPrime[0+1] := false ; 
    isPrime[1+1] := false ; 
    var factors : Sequence(int) ; factors := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do ( (     if (isPrime[i+1] = true) then (     factors[i+1] := factors[i+1] + 1 ; 
         var j : int ; j := 2 * i ; while j <= N do ( (     factors[j+1] := factors[j+1] + 1 ; 
     isPrime[j+1] := false )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i <= N do ( (     if (factors[i+1] = 2) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void find(int n){
    String[] arr=new String[n+1];
    arr[0]="" ;
    int size=1,m=1 ;
    while(size<=n){
      for(int i=0 ; i<m &&(size+i)<=n ; i++)arr[size+i]="3"+arr[size-m+i];
      for(int i=0 ; i<m &&(size+m+i)<=n ; i++)arr[size+m+i]="4"+arr[size-m+i];
      m=m<<1 ;
      size=size+m ;
    }
    System.out.println(arr[n]);
  }
  public static void main(String[] args){
    for(int i=0 ; i<16 ; i++)find(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation find( n : int) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Integer.subrange(1,n + 1)->collect(null) ;
     arr[0+1] := "" ; 
    var size : int ; size := 1 ;
    var m : int ; m := 1 ;
    while (size <= n) do (         var i : int ; i := 0 ; while i < m & (size + i) <= n do (     arr[size + i+1] := "3" + arr[size - m + i+1] ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < m & (size + m + i) <= n do (     arr[size + m + i+1] := "4" + arr[size - m + i+1] ;  ;     i := i + 1 ) ; 
     m := (m*(2->pow(1)))->oclAsType(long) ; 
     size := size + m ) ; 
    OclFile["System.out"].println(arr[n+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 16 do (     execute find(i) ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.Math.*;
import static java.lang.System.*;
public class Main {
  public static void main(String[] args){
    int i,j ;
    Scanner sc=new Scanner(in);
    int a=parseInt(sc.next());
    int b=parseInt(sc.next());
    sc.close();
    String[] s={
      "Positive","Zero","Negative" };
      int ans=0 ;
      if(a>0 && b>0){
        ans=0 ;
      }
      else if(a<=0 && b>=0){
        ans=1 ;
      }
      else if(a<0 && b<0){
        int c=b-a ;
        if(c % 2==0){
          ans=2 ;
        }
        else {
          ans=0 ;
        }
      }
      out.println(s[ans]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
    var a : int ; a := parseInt(sc.getCurrent()) ;
    var b : int ; b := parseInt(sc.getCurrent()) ;
    skip ; 
    var s : Sequence(String) ; s := Sequence{"Positive","Zero","Negative"} ;
    var ans : int ; ans := 0 ;
    if (a > 0 & b > 0) then (     ans := 0 ) else     if (a <= 0 & b >= 0) then (     ans := 1 ) else     if (a < 0 & b < 0) then (     var c : int ; c := b - a ;
     if (c mod 2 = 0) then (     ans := 2 ) else (     ans := 0 ) ) else skip ; ;  ;  
    out.println(s[ans+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String maxValue(char[] a,char[] b){
    Arrays.sort(b);
    int n=a.length ;
    int m=b.length ;
    int j=m-1 ;
    for(int i=0 ; i<n ; i++){
      if(j<0)break ;
      if(b[j]>a[i]){
        a[i]=b[j];
        j--;
      }
    }
    return String.valueOf(a);
  }
  public static void main(String[] args){
    String a="1234" ;
    String b="4321" ;
    System.out.print(maxValue(a.toCharArray(),b.toCharArray()));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxValue( a : Sequence(String), b : Sequence(String)) : String
  pre: true
  post: true
  activity: (     b := b->sort() ; 
     var n : int ; n := a->size() ;
    var m : int ; m := b->size() ;
    var j : int ; j := m - 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (j < 0) then     break else skip ; 
     if (b[j+1] > a[i+1]) then (     a[i+1] := b[j+1] ; 
     j := j - 1 ) else skip )  ;     i := i + 1 ) ; 
    return ((a) + "") 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ; a := "1234" ;
     var b : String ; b := "4321" ;
     OclFile["System.out"].print(maxValue(a->characters(), b->characters())) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javafx.util.Pair ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<Pair<Integer,Integer>>N_arr=new ArrayList<Pair<Integer,Integer>>();
    ArrayList<Pair<Integer,Integer>>P_arr=new ArrayList<Pair<Integer,Integer>>();
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt(),a=sc.nextInt();
      if(x<0)N_arr.add(new Pair<>(x,a));
      else P_arr.add(new Pair<>(x,a));
    }
    Collections.sort(N_arr,Comparator.comparing(p->-p.getKey()));
    Collections.sort(P_arr,Comparator.comparing(p->p.getKey()));
    int sum=0 ;
    if(N_arr.size()==P_arr.size()){
      for(int i=0 ; i<N_arr.size(); i++)sum+=N_arr.get(i).getValue()+P_arr.get(i).getValue();
    }
    else if(N_arr.size()<P_arr.size()){
      for(int i=0 ; i<N_arr.size(); i++)sum+=N_arr.get(i).getValue()+P_arr.get(i).getValue();
      sum+=P_arr.get(N_arr.size()).getValue();
    }
    else {
      for(int i=0 ; i<P_arr.size(); i++)sum+=N_arr.get(i).getValue()+P_arr.get(i).getValue();
      sum+=N_arr.get(P_arr.size()).getValue();
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var N_arr : Sequence(Map(String,OclAny)) ; N_arr := Sequence{} ;
    var P_arr : Sequence(Map(String,OclAny)) ; P_arr := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
     if (x < 0) then     N_arr := N_arr->including(Tuple(x, a)) ; else     P_arr := P_arr->including(Tuple(x, a)) ; )  ;     i := i + 1 ) ; 
    N_arr, Comparator.comparing(lambda p : OclAny in -p.getKey()) := N_arr, Comparator.comparing(lambda p : OclAny in -p.getKey())->sort() ; 
    P_arr, Comparator.comparing(lambda p : OclAny in p.getKey()) := P_arr, Comparator.comparing(lambda p : OclAny in p.getKey())->sort() ; 
    var sum : int ; sum := 0 ;
    if (N_arr->size() = P_arr->size()) then (         var i : int ; i := 0 ; while i < N_arr->size() do (     sum := sum+(N_arr->at(i+1).getValue() + P_arr->at(i+1).getValue()) ;  ;     i := i + 1 ) ) else     if (N_arr->size() < P_arr->size()) then (         var i : int ; i := 0 ; while i < N_arr->size() do (     sum := sum+(N_arr->at(i+1).getValue() + P_arr->at(i+1).getValue()) ;  ;     i := i + 1 ) ; 
     sum := sum+(P_arr->at(N_arr->size()+1).getValue()) ) else (         var i : int ; i := 0 ; while i < P_arr->size() do (     sum := sum+(N_arr->at(i+1).getValue() + P_arr->at(i+1).getValue()) ;  ;     i := i + 1 ) ; 
     sum := sum+(N_arr->at(P_arr->size()+1).getValue()) ) ;  ;  
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Car {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr1=new int[n+1];
    int[] arr2=new int[n+1];
    int count=0 ;
    int numNeg=0 ;
    int numPos=0 ;
    for(int i=0 ; i<n ; i++){
      arr1[i]=sc.nextInt();
      arr2[i]=sc.nextInt();
      if(arr1[i]<0)numNeg++;
      else numPos++;
    }
    arr1[n]=0 ;
    arr2[n]=0 ;
    int temp=0 ;
    for(int i=0 ; i<n+1 ; i++){
      for(int j=0 ; j<i ; j++){
        if(arr1[i]<arr1[j]){
          temp=arr1[i];
          arr1[i]=arr1[j];
          arr1[j]=temp ;
          temp=arr2[i];
          arr2[i]=arr2[j];
          arr2[j]=temp ;
        }
      }
    }
    int index=Arrays.binarySearch(arr1,0);
    int i ;
    for(i=1 ; i<=Math.min(numNeg,numPos); i++){
      count+=arr2[index+i]+arr2[index-i];
    }
    if(numNeg>numPos)count+=arr2[index-i];
    if(numPos>numNeg)count+=arr2[index+i];
    System.out.print(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Car {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n + 1)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,n + 1)->collect(0) ;
    var count : int ; count := 0 ;
    var numNeg : int ; numNeg := 0 ;
    var numPos : int ; numPos := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr1[i+1] := sc.getCurrent()->toInteger() ; 
     arr2[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr1[i+1] < 0) then     numNeg := numNeg + 1 ; else     numPos := numPos + 1 ; )  ;     i := i + 1 ) ; 
    arr1[n+1] := 0 ; 
    arr2[n+1] := 0 ; 
    var temp : int ; temp := 0 ;
        var i : int ; i := 0 ; while i < n + 1 do ( (         var j : int ; j := 0 ; while j < i do ( (     if (arr1[i+1] < arr1[j+1]) then (     temp := arr1[i+1] ; 
     arr1[i+1] := arr1[j+1] ; 
    arr1[j+1] := temp ; 
    temp := arr2[i+1] ; 
    arr2[i+1] := arr2[j+1] ; 
    arr2[j+1] := temp ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var index : int ; index := (arr1->indexOf(0) - 1) ;
    var i : int ;
        i := 1 ; while i <= Set{numNeg, numPos}->min() do ( (     count := count+(arr2[index + i+1] + arr2[index - i+1]) )  ;     i := i + 1 ) ; 
    if (numNeg > numPos) then     count := count+(arr2[index - i+1]) ; else skip ; 
    if (numPos > numNeg) then     count := count+(arr2[index + i+1]) ; else skip ; 
    OclFile["System.out"].print(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  static class Node {
    Long index ;
    Long data ;
    public Node(Long index,Long data){
      this.index=index ;
      this.data=data ;
    }
  }
  static Queue<Node>q1 ;
  static Queue<Node>q2 ;
  static Node temp ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    q1=new PriorityQueue<>((o1,o2)->(int)(o2.index-o1.index));
    q2=new PriorityQueue<>((o1,o2)->(int)(o1.index-o2.index));
    for(int i=0 ; i<N ; i++){
      Long index=sc.nextLong();
      Long data=sc.nextLong();
      temp=new Node(index,data);
      if(index<0){
        q1.add(temp);
      }
      else {
        q2.add(temp);
      }
    }
    int len1=q1.size();
    int len2=q2.size();
    Long res=0L ;
    if(len1<len2){
      while(! q1.isEmpty()){
        res+=q1.poll().data ;
        res+=q2.poll().data ;
      }
      res+=q2.poll().data ;
    }
    else if(len1>len2){
      while(! q2.isEmpty()){
        res+=q1.poll().data ;
        res+=q2.poll().data ;
      }
      res+=q1.poll().data ;
    }
    else {
      while(! q1.isEmpty()&& ! q2.isEmpty()){
        res+=q1.poll().data ;
        res+=q2.poll().data ;
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Node {
   attribute index : long;
   attribute data : long;
   static operation newNode( index : long, data : long) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(index, data);
    return self );
  operation initialise( index : long, data : long) : void
  pre: true  post: true
  activity: (     self.index := index ; 
     self.data := data );
}
  static   attribute q1 : Sequence(Node);
  static   attribute q2 : Sequence(Node);
  static   attribute temp : Node;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    q1 := Sequence{}->union(lambda (o1 , o2) : OclAny in (o2.index - o1.index)->oclAsType(int)) ; 
    q2 := Sequence{}->union(lambda (o1 , o2) : OclAny in (o1.index - o2.index)->oclAsType(int)) ; 
        var i : int ; i := 0 ; while i < N do ( (     var index : long ; index := sc.getCurrent()->toLong() ;
     var data : long ; data := sc.getCurrent()->toLong() ;
     temp := Node.newNode(index, data) ; 
     if (index < 0) then (     q1 := q1->including(temp) ) else (     q2 := q2->including(temp) ) )  ;     i := i + 1 ) ; 
    var len1 : int ; len1 := q1->size() ;
    var len2 : int ; len2 := q2->size() ;
    var res : long ; res := 0L ;
    if (len1 < len2) then (     while (not(q1->isEmpty())) do (     res := res+(q1->min().data) ; 
     res := res+(q2->min().data) ) ; 
     res := res+(q2->min().data) ) else     if (len1 > len2) then (     while (not(q2->isEmpty())) do (     res := res+(q1->min().data) ; 
     res := res+(q2->min().data) ) ; 
     res := res+(q1->min().data) ) else (     while (not(q1->isEmpty()) & not(q2->isEmpty())) do (     res := res+(q1->min().data) ; 
     res := res+(q2->min().data) ) ) ;  ;  
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
class GFG {
  static float geometricMean(int arr[],int n){
    float product=1 ;
    for(int i=0 ; i<n ; i++)product=product*arr[i];
    float gm=(float)Math.pow(product,(float)1/n);
    return gm ;
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3,4,5,6,7,8 };
      int n=arr.length ;
      System.out.println(geometricMean(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation geometricMean( arr : Sequence(int), n : int) : double
  pre: true
  post: true
  activity: (     var product : double ; product := 1 ;
         var i : int ; i := 0 ; while i < n do (     product := product * arr[i+1] ;  ;     i := i + 1 ) ; 
     var gm : double ; gm := product->pow(1->oclAsType(double) / n)->oclAsType(double) ;
     return gm );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6,7,8} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(geometricMean(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    long[] a=new long[n];
    int mod=(int)Math.pow(10,9)+7 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt()% mod ;
    }
    Arrays.sort(a);
    int left=0 ;
    int right=n-1 ;
    long ans=k % 2==0 ? 1 : a[right--];
    int c=1 ;
    if(ans<0)c=-1 ;
    while(k>=2){
      if(c*a[left]*a[left+1]>c*a[right]*a[right-1]){
        ans=ans*a[left] % mod ;
        ans=ans*a[left+1] % mod ;
        left+=2 ;
      }
      else {
        ans=ans*a[right] % mod ;
        ans=ans*a[right-1] % mod ;
        right-=2 ;
      }
      k-=2 ;
    }
    if(ans<0)ans+=mod ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var mod : int ; mod := 10->pow(9)->oclAsType(int) + 7 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() mod mod )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var left : int ; left := 0 ;
    var right : int ; right := n - 1 ;
    var ans : long ; ans := if k mod 2 = 0 then 1 else a[right+1] endif ;
    var c : int ; c := 1 ;
    if (ans < 0) then     c := -1 ; else skip ; 
    while (k >= 2) do (     if (c * a[left+1] * a[left + 1+1] > c * a[right+1] * a[right - 1+1]) then (     ans := ans * a[left+1] mod mod ; 
     ans := ans * a[left + 1+1] mod mod ; 
     left := left+(2) ) else (     ans := ans * a[right+1] mod mod ; 
     ans := ans * a[right - 1+1] mod mod ; 
     right := right-(2) ) ;  
     k := k-(2) ) ; 
    if (ans < 0) then     ans := ans+(mod) ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int MOD=(int)1e9+7 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int k=Integer.parseInt(sc.next());
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Long.parseLong(sc.next());
    }
    Arrays.sort(a);
    int l=0 ;
    int r=n-1 ;
    long ans=k % 2==0 ? 1 : a[r--];
    int b=ans<=0 ?-1 : 1 ;
    while(k>1){
      long m=a[l]*a[l+1];
      long p=a[r]*a[r-1];
      if(m*b>=p*b){
        ans=ans*(m % MOD)% MOD ;
        l+=2 ;
      }
      else {
        ans=ans*(p % MOD)% MOD ;
        r-=2 ;
      }
      k-=2 ;
    }
    System.out.println((ans+MOD)% MOD);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1e9->oclAsType(int) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var k : int ; k := (sc.getCurrent())->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sc.getCurrent())->toLong() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var l : int ; l := 0 ;
    var r : int ; r := n - 1 ;
    var ans : long ; ans := if k mod 2 = 0 then 1 else a[r+1] endif ;
    var b : int ; b := if ans <= 0 then -1 else 1 endif ;
    while (k > 1) do (     var m : long ; m := a[l+1] * a[l + 1+1] ;
     var p : long ; p := a[r+1] * a[r - 1+1] ;
     if (m * b >= p * b) then (     ans := ans * (m mod MOD) mod MOD ; 
     l := l+(2) ) else (     ans := ans * (p mod MOD) mod MOD ; 
     r := r-(2) ) ;  
     k := k-(2) ) ; 
    OclFile["System.out"].println((ans + MOD) mod MOD) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Pattern {
  static void display(int n){
    int i,j,k ;
    for(i=1 ; i<=n ; i++){
      for(j=1,k=i ; j<=i ; j++,k--){
        if(k % 2==0){
          System.out.print(j);
        }
        else {
          System.out.print("*");
        }
      }
      System.out.print("\n");
    }
  }
  public static void main(String[] args){
    int n=5 ;
    display(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Pattern {
  static   operation display( n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var k : int ;
         i := 1 ; while i <= n do ( (         j := 1 ;     k := i ; while j <= i do ( (     if (k mod 2 = 0) then (     OclFile["System.out"].print(j) ) else (     OclFile["System.out"].print("*") ) )  ;     j := j + 1 ;     k := k - 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute display(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class CountXor {
  static int countXorPair(int arr[],int n){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++)if((arr[i] ^ arr[j])% 2==1)count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3 };
      System.out.println(countXorPair(arr,arr.length));
    }
  }

------------------------------------------------------------
OCL File:
---------
class CountXor {
  static   operation countXorPair( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do (     if ((arr[i+1] xor arr[j+1]) mod 2 = 1) then     count := count + 1 ; else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3} ;
     OclFile["System.out"].println(countXorPair(arr, arr->size())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigDecimal ;
import java.math.MathContext ;
import java.util.*;
public class ProblemB {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    String line[]=br.readLine().split(" ");
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=Integer.parseInt(line[i]);
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==0 && i-1>=0 && arr[i-1]==1 && i+1<n && arr[i+1]==1){
        arr[i+1]=0 ;
        ans++;
      }
    }
    System.out.println(ans);
  }
  public static int gcd(int a,int b){
    return b==0 ? a : gcd(b,a % b);
  }
  public static void sort(int arr[]){
    ArrayList<Integer>list=new ArrayList<>();
    for(int it : arr)list.add(it);
    Collections.sort(list);
    for(int i=0 ; i<list.size(); i++)arr[i]=list.get(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := (line[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 0 & i - 1 >= 0 & arr[i - 1+1] = 1 & i + 1 < n & arr[i + 1+1] = 1) then (     arr[i + 1+1] := 0 ; 
     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
  static   operation sort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     for (it : arr) do (     list := list->including(it) ;  ) ; 
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < list->size() do (     arr[i+1] := list->at(i+1) ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  private static int N=0 ;
  private static long MOD=1000000007L ;
  private static List<Map<String,Long>>memo=new ArrayList<Map<String,Long>>();
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    for(int i=0 ; i<=N ; i++){
      memo.add(new HashMap<String,Long>());
    }
    System.out.println(dfs(0,"TTT"));
  }
  private static boolean ok(String last4){
    for(int i=0 ; i<4 ; i++){
      char[] t=last4.toCharArray();
      if(i>=1){
        char buf=t[i-1];
        t[i-1]=t[i];
        t[i]=buf ;
      }
      if(String.valueOf(t).indexOf("AGC")>=0){
        return false ;
      }
    }
    return true ;
  }
  private static long dfs(int cur,String last3){
    if(memo.get(cur).containsKey(last3)){
      return memo.get(cur).get(last3);
    }
    if(cur==N){
      return 1 ;
    }
    long ret=0 ;
    char[] cList={
      'A','C','G','T' };
      for(char c : cList){
        if(ok(last3+c)){
          ret=(ret+dfs(cur+1,last3.substring(1)+c))% MOD ;
        }
      }
      memo.get(cur).put(last3,ret);
      return ret ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int := 0;
  static   attribute MOD : long := 1000000007L;
  static   attribute memo : Sequence(Map(String,long)) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
         var i : int ; i := 0 ; while i <= N do ( (     memo := memo->including(Map{}) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(dfs(0, "TTT")) );
  static   operation ok( last4 : String) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 4 do ( (     var t : Sequence(String) ; t := last4->characters() ;
     if (i >= 1) then (     var buf : String ; buf := t[i - 1+1] ;
     t[i - 1+1] := t[i+1] ; 
     t[i+1] := buf ) else skip ; 
     if ((t)->sum() ->indexOf("AGC")-1 >= 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation dfs( cur : int, last3 : String) : long
  pre: true
  post: true
  activity: (     if (memo->at(cur+1).containsKey(last3)) then (     return memo->at(cur+1)->at(last3+1) ) else skip ; 
     if (cur = N) then (     return 1 ) else skip ; 
    var ret : long ; ret := 0 ;
    var cList : Sequence(String) ; cList := Sequence{'A','C','G','T'} ;
    for (c : cList) do ( (     if (ok(last3 + c)) then (     ret := (ret + dfs(cur + 1, last3.subrange(1+1,1) + c)) mod MOD ) else skip )  ) ; 
    memo := memo->at(cur+1)->union(Map{last3 |-> ret}) ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class geeks {
  public static int firstSetBit(int n){
    int x=n &(n-1);
    return(n ^ x);
  }
  public static void main(String[] args){
    int n=12 ;
    System.out.println(firstSetBit(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class geeks {
  static   operation firstSetBit( n : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := MathLib.bitwiseAnd(n,(n - 1)) ;
     return (n xor x) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     OclFile["System.out"].println(firstSetBit(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static void main(String args[]){
    float x1=1,x2=3,x3=6 ;
    float y1=2,y2=-4,y3=-7 ;
    float x=(x1+x2+x3)/3 ;
    float y=(y1+y2+y3)/3 ;
    System.out.println("Centroid="+"("+x+","+y+")");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x1 : double ; x1 := 1 ;
    var x2 : double ; x2 := 3 ;
    var x3 : double ; x3 := 6 ;
     var y1 : double ; y1 := 2 ;
    var y2 : double ; y2 := -4 ;
    var y3 : double ; y3 := -7 ;
    var x : double ; x := (x1 + x2 + x3) / 3 ;
    var y : double ; y := (y1 + y2 + y3) / 3 ;
    OclFile["System.out"].println("Centroid=" + "(" + x + "," + y + ")") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static double Square(double n,double i,double j){
    double mid=(i+j)/2 ;
    double mul=mid*mid ;
    if((mul==n)||(Math.abs(mul-n)<0.00001))return mid ;
    else if(mul<n)return Square(n,mid,j);
    else return Square(n,i,mid);
  }
  static void findSqrt(double n){
    double i=1 ;
    boolean found=false ;
    while(! found){
      if(i*i==n){
        System.out.println(i);
        found=true ;
      }
      else if(i*i>n){
        double res=Square(n,i-1,i);
        System.out.printf("%.5f",res);
        found=true ;
      }
      i++;
    }
  }
  public static void main(String[] args){
    double n=3 ;
    findSqrt(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Square( n : double, i : double, j : double) : double
  pre: true
  post: true
  activity: (     var mid : double ; mid := (i + j) / 2 ;
     var mul : double ; mul := mid * mid ;
     if ((mul = n) or (if mul - n < 0 then -(mul - n) else mul - n endif < 0.00001)) then     return mid else     if (mul < n) then     return Square(n, mid, j) else     return Square(n, i, mid) ;  );
  static   operation findSqrt( n : double) : void
  pre: true
  post: true
  activity: (     var i : double ; i := 1 ;
     var found : boolean ; found := false ;
     while (not(found)) do (     if (i * i = n) then (     OclFile["System.out"].println(i) ; 
     found := true ) else     if (i * i > n) then (     var res : double ; res := Square(n, i - 1, i) ;
     OclFile["System.out"].printf("%.5f", res) ; 
     found := true ) else skip ; ;  
     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 3 ;
     execute findSqrt(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int[] a ;
  static int[] b ;
  static boolean[] k ;
  static int z ;
  static void dfs(int x,int pa,int pb){
    if(x==9){
      z+=pb<pa ? 1 : 0 ;
      return ;
    }
    for(int i=0 ; i<9 ; i++){
      if(k[i])continue ;
      k[i]=true ;
      dfs(x+1,pa+(b[x]<a[i] ? a[i]+b[x] : 0),pb+(b[x]<a[i] ? 0 : a[i]+b[x]));
      k[i]=false ;
    }
  }
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int N=sc.nextInt();
      while(N--!=0){
        a=new int[9];
        b=new int[9];
        k=new boolean[9];
        for(int i=0 ; i<9 ; i++)a[i]=sc.nextInt();
        for(int i=0 ; i<9 ; i++)b[i]=sc.nextInt();
        z=0 ;
        dfs(0,0,0);
        int bb=9*8*7*6*5*4*3*2*1 ;
        double t=z*1.0/bb ;
        System.out.printf("%.5f %.5f\n",t,1-t);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a : Sequence(int);
  static   attribute b : Sequence(int);
  static   attribute k : Sequence(boolean);
  static   attribute z : int;
  static   operation dfs( x : int, pa : int, pb : int) : void
  pre: true
  post: true
  activity: (     if (x = 9) then (     z := z+(if pb < pa then 1 else 0 endif) ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < 9 do ( (     if (k[i+1]) then     continue else skip ; 
     k[i+1] := true ; 
     execute dfs(x + 1, pa + (if b[x+1] < a[i+1] then a[i+1] + b[x+1] else 0 endif), pb + (if b[x+1] < a[i+1] then 0 else a[i+1] + b[x+1] endif)) ; 
     k[i+1] := false )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := sc.getCurrent()->toInteger() ;
         while (N /= 0) do (    skip ; (     a := Integer.subrange(1,9)->collect(0) ; 
     b := Integer.subrange(1,9)->collect(0) ; 
    k := Integer.subrange(1,9)->collect(false) ; 
        var i : int ; i := 0 ; while i < 9 do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 9 do (     b[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    z := 0 ; 
    execute dfs(0, 0, 0) ; 
    var bb : int ; bb := 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1 ;
    var t : double ; t := z * 1.0 / bb ;
    OclFile["System.out"].printf("%.5f %.5f\n", t, 1 - t) ; 
 ) ;  ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.util.Arrays.*;
import static java.lang.Math.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int S,T ;
  static void f(int sum,int[] a,int[] b){
    if(a.length==0){
      if(sum>=0)S++;
      T++;
      return ;
    }
    int[] na=new int[a.length-1];
    for(int i=0 ; i<a.length-1 ; i++)na[i]=a[i+1];
    for(int i=0 ; i<b.length ; i++){
      int[] nb=new int[b.length-1];
      int p=0 ;
      for(int k=0 ; k<b.length ; k++){
        if(i==k)continue ;
        nb[p]=b[k];
        p++;
      }
      int win=a[0]>b[i] ? a[0]+b[i] :-(a[0]+b[i]);
      f(sum+win,na,nb);
    }
  }
  public static void main(String[] args){
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int[] a=new int[9],b=new int[9];
      for(int j=0 ; j<9 ; j++)a[j]=sc.nextInt();
      for(int j=0 ; j<9 ; j++)b[j]=sc.nextInt();
      S=0 ;
      T=0 ;
      f(0,a,b);
      double p=(double)S/(double)T ;
      System.out.printf("%.5f %.5f",p,(1.0-p));
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute S : int;
  static   operation f( sum : int, a : Sequence(int), b : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (a->size() = 0) then (     if (sum >= 0) then     S := S + 1 ; else skip ; 
     T := T + 1 ; 
     return ) else skip ; 
     var na : Sequence(int) ; na := Integer.subrange(1,a->size() - 1)->collect(0) ;
         var i : int ; i := 0 ; while i < a->size() - 1 do (     na[i+1] := a[i + 1+1] ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < b->size() do ( (     var nb : Sequence(int) ; nb := Integer.subrange(1,b->size() - 1)->collect(0) ;
     var p : int ; p := 0 ;
        var k : int ; k := 0 ; while k < b->size() do ( (     if (i = k) then     continue else skip ; 
     nb[p+1] := b[k+1] ; 
     p := p + 1 )  ;     k := k + 1 ) ; 
    var win : int ; win := if a[0+1] > b[i+1] then a[0+1] + b[i+1] else -(a[0+1] + b[i+1]) endif ;
    execute f(sum + win, na, nb) ; 
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : Sequence(int) ; a := Integer.subrange(1,9)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,9)->collect(0) ;
         var j : int ; j := 0 ; while j < 9 do (     a[j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < 9 do (     b[j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ; 
    S := 0 ; 
    T := 0 ; 
    execute f(0, a, b) ; 
    var p : double ; p := S->oclAsType(double) / T->oclAsType(double) ;
    OclFile["System.out"].printf("%.5f %.5f", p, (1.0 - p)) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int[] G=new int[9];
  public static int[] J=new int[9];
  public static int[] G2=new int[9];
  public static boolean[] used=new boolean[9];
  public static int win=0 ;
  public static int lose=0 ;
  public static int draw=0 ;
  public static void main(String[] args){
    doIt();
  }
  public static void doIt(){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    for(int i=0 ; i<num ; i++){
      for(int j=0 ; j<9 ; j++){
        G[j]=sc.nextInt();
      }
      for(int j=0 ; j<9 ; j++){
        J[j]=sc.nextInt();
      }
      win=0 ;
      lose=0 ;
      draw=0 ;
      setOrder(0);
      double g=(double)win/(double)(win+lose+draw);
      double j=(double)lose/(double)(win+lose+draw);
      System.out.printf("%.5f %.5f\n",g,j);
    }
  }
  public static void battle(){
    int g=0,j=0 ;
    for(int i=0 ; i<9 ; i++){
      if(G2[i]<J[i]){
        j+=G2[i]+J[i];
      }
      else {
        g+=G2[i]+J[i];
      }
    }
    if(j>g){
      lose++;
    }
    else if(g>j){
      win++;
    }
    else {
      draw++;
    }
  }
  public static void setOrder(int depth){
    if(depth==9){
      battle();
    }
    for(int i=0 ; i<9 ; i++){
      if(used[i]==false){
        used[i]=true ;
        G2[depth]=G[i];
        setOrder(depth+1);
        used[i]=false ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute G : Sequence(int) := Integer.subrange(1,9)->collect(0);
  static   attribute J : Sequence(int) := Integer.subrange(1,9)->collect(0);
  static   attribute G2 : Sequence(int) := Integer.subrange(1,9)->collect(0);
  static   attribute used : Sequence(boolean) := Integer.subrange(1,9)->collect(false);
  static   attribute win : int := 0;
  static   attribute lose : int := 0;
  static   attribute draw : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doIt() );
  static   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < num do ( (         var j : int ; j := 0 ; while j < 9 do ( (     G[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < 9 do ( (     J[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    win := 0 ; 
    lose := 0 ; 
    draw := 0 ; 
    execute setOrder(0) ; 
    var g : double ; g := win->oclAsType(double) / (win + lose + draw)->oclAsType(double) ;
    var j : double ; j := lose->oclAsType(double) / (win + lose + draw)->oclAsType(double) ;
    OclFile["System.out"].printf("%.5f %.5f\n", g, j) ; 
 )  ;     i := i + 1 ) );
  static   operation battle() : void
  pre: true
  post: true
  activity: (     var g : int ; g := 0 ;
    var j : int ; j := 0 ;
         var i : int ; i := 0 ; while i < 9 do ( (     if (G2[i+1] < J[i+1]) then (     j := j+(G2[i+1] + J[i+1]) ) else (     g := g+(G2[i+1] + J[i+1]) ) )  ;     i := i + 1 ) ; 
     if (j > g) then (     lose := lose + 1 ) else     if (g > j) then (     win := win + 1 ) else (     draw := draw + 1 ) ;  );
  static   operation setOrder( depth : int) : void
  pre: true
  post: true
  activity: (     if (depth = 9) then (     execute battle() ) else skip ; 
         var i : int ; i := 0 ; while i < 9 do ( (     if (used[i+1] = false) then (     used[i+1] := true ; 
     G2[depth+1] := G[i+1] ; 
     execute setOrder(depth + 1) ; 
     used[i+1] := false ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.function.Consumer ;
import java.util.stream.IntStream ;
public class Main {
  static void swap(int a[],int l,int r){
    int tmp=a[l];
    a[l]=a[r];
    a[r]=tmp ;
  }
  static void perm(int[] a,int loc,int len,Consumer<int[]>f){
    if(loc+1==len){
      f.accept(a);
      return ;
    }
    perm(a,loc+1,len,f);
    for(int i=loc+1 ; i<a.length ; i++){
      swap(a,loc,i);
      perm(a,loc+1,len,f);
      swap(a,loc,i);
    }
  }
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      for(int i=0 ; i<n ; i++){
        int[] gates=IntStream.range(0,9).map(d->sc.nextInt()).toArray();
        int[] jackies=IntStream.range(0,9).map(d->sc.nextInt()).toArray();
        int[] counts=new int[2];
        perm(gates,0,9,(int[] g)->{
          int gp=0,jp=0 ;
          for(int j=0 ; j<9 ; j++){
            if(g[j]>jackies[j]){
              gp+=(g[j]+jackies[j]);
            }
            else {
              jp+=(jackies[j]+g[j]);
            }
          }
          if(gp>jp){
            counts[0]++;
          }
          else {
            counts[1]++;
          }
        }
);
        double total=counts[0]+counts[1];
        System.out.printf("%.5f %.5f\n",counts[0]/total,counts[1]/total);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation swap( a : Sequence(int), l : int, r : int) : void
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := a[l+1] ;
     a[l+1] := a[r+1] ; 
     a[r+1] := tmp );
  static   operation perm( a : Sequence(int), loc : int, len : int, f : Function(<Sequence(int)>, void)) : void
  pre: true
  post: true
  activity: (     if (loc + 1 = len) then (     f->apply(a) ; 
     return ) else skip ; 
     execute perm(a, loc + 1, len, f) ; 
         var i : int ; i := loc + 1 ; while i < a->size() do ( (     execute swap(a, loc, i) ; 
     execute perm(a, loc + 1, len, f) ; 
     execute swap(a, loc, i) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var gates : Sequence(int) ; gates := Integer.subrange(0, 9-1)->collect( _x1 | (lambda d : OclAny in sc.getCurrent()->toInteger())->apply(_x1) )->asSequence() ;
     var jackies : Sequence(int) ; jackies := Integer.subrange(0, 9-1)->collect( _x1 | (lambda d : OclAny in sc.getCurrent()->toInteger())->apply(_x1) )->asSequence() ;
    var counts : Sequence(int) ; counts := Integer.subrange(1,2)->collect(0) ;
    execute perm(gates, 0, 9, lambda  g : Sequence(int) : OclAny in (     var gp : int ; gp := 0 ;
    var jp : int ; jp := 0 ;
         var j : int ; j := 0 ; while j < 9 do ( (     if (g[j+1] > jackies[j+1]) then (     gp := gp+((g[j+1] + jackies[j+1])) ) else (     jp := jp+((jackies[j+1] + g[j+1])) ) )  ;     j := j + 1 ) ; 
     if (gp > jp) then (     counts[0+1] := counts[0+1] + 1 ) else (     counts[1+1] := counts[1+1] + 1 ) )) ; 
    var total : double ; total := counts[0+1] + counts[1+1] ;
    OclFile["System.out"].printf("%.5f %.5f\n", counts[0+1] / total, counts[1+1] / total) ; 
 )  ;     i := i + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Combination {
  static void combinationUtil(int arr[],int data[],int start,int end,int index,int r){
    if(index==r){
      for(int j=0 ; j<r ; j++)System.out.print(data[j]+" ");
      System.out.println("");
      return ;
    }
    for(int i=start ; i<=end && end-i+1>=r-index ; i++){
      data[index]=arr[i];
      combinationUtil(arr,data,i+1,end,index+1,r);
    }
  }
  static void printCombination(int arr[],int n,int r){
    int data[]=new int[r];
    combinationUtil(arr,data,0,n-1,0,r);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5 };
      int r=3 ;
      int n=arr.length ;
      printCombination(arr,n,r);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Combination {
  static   operation combinationUtil( arr : Sequence(int), data : Sequence(int), start : int, end : int, index : int, r : int) : void
  pre: true
  post: true
  activity: (     if (index = r) then (         var j : int ; j := 0 ; while j < r do (     OclFile["System.out"].print(data[j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("") ; 
     return ) else skip ; 
         var i : int ; i := start ; while i <= end & end - i + 1 >= r - index do ( (     data[index+1] := arr[i+1] ; 
     execute combinationUtil(arr, data, i + 1, end, index + 1, r) )  ;     i := i + 1 ) );
  static   operation printCombination( arr : Sequence(int), n : int, r : int) : void
  pre: true
  post: true
  activity: (     var data : Sequence(int) ; data := Integer.subrange(1,r)->collect(0) ;
     execute combinationUtil(arr, data, 0, n - 1, 0, r) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var r : int ; r := 3 ;
     var n : int ; n := arr->size() ;
     execute printCombination(arr, n, r) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Combination {
  static void combinationUtil(int arr[],int n,int r,int index,int data[],int i){
    if(index==r){
      for(int j=0 ; j<r ; j++)System.out.print(data[j]+" ");
      System.out.println("");
      return ;
    }
    if(i>=n)return ;
    data[index]=arr[i];
    combinationUtil(arr,n,r,index+1,data,i+1);
    combinationUtil(arr,n,r,index,data,i+1);
  }
  static void printCombination(int arr[],int n,int r){
    int data[]=new int[r];
    combinationUtil(arr,n,r,0,data,0);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5 };
      int r=3 ;
      int n=arr.length ;
      printCombination(arr,n,r);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Combination {
  static   operation combinationUtil( arr : Sequence(int), n : int, r : int, index : int, data : Sequence(int), i : int) : void
  pre: true
  post: true
  activity: (     if (index = r) then (         var j : int ; j := 0 ; while j < r do (     OclFile["System.out"].print(data[j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("") ; 
     return ) else skip ; 
     if (i >= n) then     return else skip ; 
    data[index+1] := arr[i+1] ; 
    execute combinationUtil(arr, n, r, index + 1, data, i + 1) ; 
    execute combinationUtil(arr, n, r, index, data, i + 1) ; 
 );
  static   operation printCombination( arr : Sequence(int), n : int, r : int) : void
  pre: true
  post: true
  activity: (     var data : Sequence(int) ; data := Integer.subrange(1,r)->collect(0) ;
     execute combinationUtil(arr, n, r, 0, data, 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var r : int ; r := 3 ;
     var n : int ; n := arr->size() ;
     execute printCombination(arr, n, r) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int bitwiseAndOdd(int n){
    int result=1 ;
    for(int i=3 ; i<=n ; i=i+2){
      result=(result & i);
    }
    return result ;
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(bitwiseAndOdd(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation bitwiseAndOdd( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 1 ;
         var i : int ; i := 3 ; while i <= n do ( (     result := (MathLib.bitwiseAnd(result,i)) )  ;     i := i + 2 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(bitwiseAndOdd(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int MAX_CHAR=256 ;
  static int maximumChars(String str){
    int n=str.length();
    int res=-1 ;
    int[] firstInd=new int[MAX_CHAR];
    for(int i=0 ; i<MAX_CHAR ; i++)firstInd[i]=-1 ;
    for(int i=0 ; i<n ; i++){
      int first_ind=firstInd[str.charAt(i)];
      if(first_ind==-1)firstInd[str.charAt(i)]=i ;
      else res=Math.max(res,Math.abs(i-first_ind-1));
    }
    return res ;
  }
  static public void main(String[] args){
    String str="abba" ;
    System.out.println(maximumChars(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX_CHAR : int := 256;
  static   operation maximumChars( str : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var res : int ; res := -1 ;
    var firstInd : Sequence(int) ; firstInd := Integer.subrange(1,MAX_CHAR)->collect(0) ;
        var i : int ; i := 0 ; while i < MAX_CHAR do (     firstInd[i+1] := -1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var first_ind : int ; first_ind := firstInd[str->at(i+1)+1] ;
     if (first_ind = -1) then     firstInd[str->at(i+1)+1] := i ; else     res := Set{res, if i - first_ind - 1 < 0 then -(i - first_ind - 1) else i - first_ind - 1 endif}->max() ; )  ;     i := i + 1 ) ; 
    return res 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abba" ;
     OclFile["System.out"].println(maximumChars(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static void findTangent(int A,int x,int y){
    int dif=A-x*2 ;
    if(y==(2*x-x*x)){
      if(dif<0)System.out.println("y="+dif+"x"+(x*dif+y));
      else if(dif>0)System.out.println("y="+dif+"x+"+-x*dif+y);
      else System.out.println("Not possible");
    }
  }
  public static void main(String args[]){
    int A=2,x=2,y=0 ;
    findTangent(A,x,y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findTangent( A : int, x : int, y : int) : void
  pre: true
  post: true
  activity: (     var dif : int ; dif := A - x * 2 ;
     if (y = (2 * x - x * x)) then (     if (dif < 0) then     OclFile["System.out"].println("y=" + dif + "x" + (x * dif + y)) ; else     if (dif > 0) then     OclFile["System.out"].println("y=" + dif + "x+" + -x * dif + y) else     OclFile["System.out"].println("Not possible") ; ;  ) else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 2 ;
    var x : int ; x := 2 ;
    var y : int ; y := 0 ;
     execute findTangent(A, x, y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean areElementsContiguous(int arr[],int n){
    int max=Integer.MIN_VALUE ;
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      max=Math.max(max,arr[i]);
      min=Math.min(min,arr[i]);
    }
    int m=max-min+1 ;
    if(m>n)return false ;
    boolean visited[]=new boolean[n];
    for(int i=0 ; i<n ; i++)visited[arr[i]-min]=true ;
    for(int i=0 ; i<m ; i++)if(visited[i]==false)return false ;
    return true ;
  }
  public static void main(String[] args){
    int arr[]={
      5,2,3,6,4,4,6,6 };
      int n=arr.length ;
      if(areElementsContiguous(arr,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation areElementsContiguous( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var max : int ; max := -2147483648 ;
     var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     max := Set{max, arr[i+1]}->max() ; 
     min := Set{min, arr[i+1]}->min() )  ;     i := i + 1 ) ; 
    var m : int ; m := max - min + 1 ;
    if (m > n) then     return false else skip ; 
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n do (     visited[arr[i+1] - min+1] := true ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     if (visited[i+1] = false) then     return false else skip ;  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,2,3,6,4,4,6,6} ;
     var n : int ; n := arr->size() ;
     if (areElementsContiguous(arr, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Fast f=new Fast(System.in);
    int t=f.nextInt();
    while(t--!=0){
      int n=f.nextInt();
      int max=Integer.MIN_VALUE,min=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; i++){
        int x=f.nextInt();
        if(x>max)max=x ;
        if(x<min)min=x ;
      }
      System.out.println(max-min);
    }
    System.out.flush();
    System.out.close();
  }
}
class Fast {
  StringTokenizer st ;
  BufferedReader br ;
  public Fast(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public Fast(String file)throws IOException {
    br=new BufferedReader(new FileReader(file));
  }
  public Fast(FileReader r){
    br=new BufferedReader(r);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String readAllLines(BufferedReader reader)throws IOException {
    StringBuilder content=new StringBuilder();
    String line ;
    while((line=reader.readLine())!=null){
      content.append(line);
      content.append(System.lineSeparator());
    }
    return content.toString();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public int[] nextIntArray(int n)throws IOException {
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : Fast ; f := Fast.newFast(OclFile["System.in"]) ;
     var t : int ; t := f.nextInt() ;
        while (t /= 0) do (    skip ; (     var n : int ; n := f.nextInt() ;
     var max : int ; max := -2147483648 ;
    var min : int ; min := 2147483647 ;
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := f.nextInt() ;
     if (x > max) then     max := x ; else skip ; 
     if (x < min) then     min := x ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(max - min) ) ;  ) ;  
    OclFile["System.out"].flush() ; 
    OclFile["System.out"].close() ; 
 );
}
class Fast {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newFast( s : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFast( file : String) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   static operation newFast( r : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(r);
    return self );
  operation initialise( r : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(r) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation readAllLines( reader : OclFile) : String
  pre: true
  post: true
  activity: (     var content : String ; content := StringLib.newString() ;
     var line : String ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     content := content + StringLib.newString(line) ; 
     content := content + StringLib.newString(lineSeparator()) ) ;     line := reader.readLine() ;
 ) ;  
     return content+"" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Fast f=new Fast(System.in);
    int t=f.nextInt();
    while(t--!=0){
      int n=f.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=f.nextInt();
      Arrays.sort(arr);
      System.out.println(arr[arr.length-1]-arr[0]);
    }
    System.out.flush();
    System.out.close();
  }
}
class Fast {
  StringTokenizer st ;
  BufferedReader br ;
  public Fast(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public Fast(String file)throws IOException {
    br=new BufferedReader(new FileReader(file));
  }
  public Fast(FileReader r){
    br=new BufferedReader(r);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String readAllLines(BufferedReader reader)throws IOException {
    StringBuilder content=new StringBuilder();
    String line ;
    while((line=reader.readLine())!=null){
      content.append(line);
      content.append(System.lineSeparator());
    }
    return content.toString();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public int[] nextIntArray(int n)throws IOException {
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : Fast ; f := Fast.newFast(OclFile["System.in"]) ;
     var t : int ; t := f.nextInt() ;
        while (t /= 0) do (    skip ; (     var n : int ; n := f.nextInt() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := f.nextInt() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    OclFile["System.out"].println(arr[arr->size() - 1+1] - arr[0+1]) ; 
 ) ;  ) ;  
    OclFile["System.out"].flush() ; 
    OclFile["System.out"].close() ; 
 );
}
class Fast {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newFast( s : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFast( file : String) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   static operation newFast( r : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(r);
    return self );
  operation initialise( r : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(r) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation readAllLines( reader : OclFile) : String
  pre: true
  post: true
  activity: (     var content : String ; content := StringLib.newString() ;
     var line : String ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     content := content + StringLib.newString(line) ; 
     content := content + StringLib.newString(lineSeparator()) ) ;     line := reader.readLine() ;
 ) ;  
     return content+"" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t--!=0){
      int n=in.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=in.nextInt();
      Arrays.sort(arr);
      System.out.println(arr[arr.length-1]-arr[0]);
    }
    System.out.flush();
    System.out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
        while (t /= 0) do (    skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    OclFile["System.out"].println(arr[arr->size() - 1+1] - arr[0+1]) ; 
 ) ;  ) ;  
    OclFile["System.out"].flush() ; 
    OclFile["System.out"].close() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static void dfs(){
  }
  static PrintWriter out=new PrintWriter(System.out);
  static Scanner in=new Scanner(System.in);
  static BufferedReader re=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter wr=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws IOException {
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int T=in.nextInt();
    while(T>0){
      int n=in.nextInt();
      int max=0 ;
      int min=2100000000 ;
      for(int i=0 ; i<n ; i++){
        int x=in.nextInt();
        if(x>max)max=x ;
        if(x<min)min=x ;
      }
      out.println(max-min);
      T--;
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation dfs() : void
  pre: true
  post: true
  activity: skip;
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute re : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute wr : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
     while (T > 0) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var max : int ; max := 0 ;
    var min : int ; min := 2100000000 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     if (x > max) then     max := x ; else skip ; 
     if (x < min) then     min := x ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
    T := T - 1 ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countRotationsDivBy8(String n){
    int len=n.length();
    int count=0 ;
    if(len==1){
      int oneDigit=n.charAt(0)-'0' ;
      if(oneDigit % 8==0)return 1 ;
      return 0 ;
    }
    if(len==2){
      int first=(n.charAt(0)-'0')*10+(n.charAt(1)-'0');
      int second=(n.charAt(1)-'0')*10+(n.charAt(0)-'0');
      if(first % 8==0)count++;
      if(second % 8==0)count++;
      return count ;
    }
    int threeDigit ;
    for(int i=0 ; i<(len-2); i++){
      threeDigit=(n.charAt(i)-'0')*100+(n.charAt(i+1)-'0')*10+(n.charAt(i+2)-'0');
      if(threeDigit % 8==0)count++;
    }
    threeDigit=(n.charAt(len-1)-'0')*100+(n.charAt(0)-'0')*10+(n.charAt(1)-'0');
    if(threeDigit % 8==0)count++;
    threeDigit=(n.charAt(len-2)-'0')*100+(n.charAt(len-1)-'0')*10+(n.charAt(0)-'0');
    if(threeDigit % 8==0)count++;
    return count ;
  }
  public static void main(String[] args){
    String n="43262488612" ;
    System.out.println("Rotations: "+countRotationsDivBy8(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countRotationsDivBy8( n : String) : int
  pre: true
  post: true
  activity: (     var len : int ; len := n->size() ;
     var count : int ; count := 0 ;
    if (len = 1) then (     var oneDigit : int ; oneDigit := n->at(0+1) - ('0')->char2byte() ;
     if (oneDigit mod 8 = 0) then     return 1 else skip ; 
     return 0 ) else skip ; 
    if (len = 2) then (     var first : int ; first := (n->at(0+1) - ('0')->char2byte()) * 10 + (n->at(1+1) - ('0')->char2byte()) ;
     var second : int ; second := (n->at(1+1) - ('0')->char2byte()) * 10 + (n->at(0+1) - ('0')->char2byte()) ;
    if (first mod 8 = 0) then     count := count + 1 ; else skip ; 
    if (second mod 8 = 0) then     count := count + 1 ; else skip ; 
    return count 
 ) else skip ; 
    var threeDigit : int ;
        var i : int ; i := 0 ; while i < (len - 2) do ( (     threeDigit := (n->at(i+1) - ('0')->char2byte()) * 100 + (n->at(i + 1+1) - ('0')->char2byte()) * 10 + (n->at(i + 2+1) - ('0')->char2byte()) ; 
     if (threeDigit mod 8 = 0) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    threeDigit := (n->at(len - 1+1) - ('0')->char2byte()) * 100 + (n->at(0+1) - ('0')->char2byte()) * 10 + (n->at(1+1) - ('0')->char2byte()) ; 
    if (threeDigit mod 8 = 0) then     count := count + 1 ; else skip ; 
    threeDigit := (n->at(len - 2+1) - ('0')->char2byte()) * 100 + (n->at(len - 1+1) - ('0')->char2byte()) * 10 + (n->at(0+1) - ('0')->char2byte()) ; 
    if (threeDigit mod 8 = 0) then     count := count + 1 ; else skip ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : String ; n := "43262488612" ;
     OclFile["System.out"].println("Rotations: " + countRotationsDivBy8(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int max_element(int a[]){
    int m=a[0];
    for(int i=0 ; i<a.length ; i++)m=Math.max(a[i],m);
    return m ;
  }
  static int primeCount(int arr[],int n){
    int max_val=max_element(arr);
    boolean prime[]=new boolean[max_val+1];
    for(int p=0 ; p<=max_val ; p++)prime[p]=true ;
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=max_val ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=max_val ; i+=p)prime[i]=false ;
      }
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++)if(prime[arr[i] ])count++;
    return count ;
  }
  static int[] getPrefixArray(int arr[],int n,int pre[]){
    pre[0]=arr[0];
    for(int i=1 ; i<n ; i++){
      pre[i]=pre[i-1]+arr[i];
    }
    return pre ;
  }
  public static void main(String args[]){
    int arr[]={
      1,4,8,4 };
      int n=arr.length ;
      int pre[]=new int[n];
      pre=getPrefixArray(arr,n,pre);
      System.out.println(primeCount(pre,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation max_element( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var m : int ; m := a[0+1] ;
         var i : int ; i := 0 ; while i < a->size() do (     m := Set{a[i+1], m}->max() ;  ;     i := i + 1 ) ; 
     return m );
  static   operation primeCount( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max_val : int ; max_val := max_element(arr) ;
     var prime : Sequence(boolean) ; prime := Integer.subrange(1,max_val + 1)->collect(false) ;
        var p : int ; p := 0 ; while p <= max_val do (     prime[p+1] := true ;  ;     p := p + 1 ) ; 
    prime[0+1] := false ; 
    prime[1+1] := false ; 
        var p : int ; p := 2 ; while p * p <= max_val do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= max_val do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (prime[arr[i+1]+1]) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation getPrefixArray( arr : Sequence(int), n : int, pre : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     pre[0+1] := arr[0+1] ; 
         var i : int ; i := 1 ; while i < n do ( (     pre[i+1] := pre[i - 1+1] + arr[i+1] )  ;     i := i + 1 ) ; 
     return pre );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,4,8,4} ;
     var n : int ; n := arr->size() ;
    var pre : Sequence(int) ; pre := Integer.subrange(1,n)->collect(0) ;
    pre := getPrefixArray(arr, n, pre) ; 
    OclFile["System.out"].println(primeCount(pre, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void interLeaveQueue(Queue<Integer>q){
    if(q.size()% 2!=0)System.out.println("Input even number of integers.");
    Stack<Integer>s=new Stack<>();
    int halfSize=q.size()/2 ;
    for(int i=0 ; i<halfSize ; i++){
      s.push(q.peek());
      q.poll();
    }
    while(! s.empty()){
      q.add(s.peek());
      s.pop();
    }
    for(int i=0 ; i<halfSize ; i++){
      q.add(q.peek());
      q.poll();
    }
    for(int i=0 ; i<halfSize ; i++){
      s.push(q.peek());
      q.poll();
    }
    while(! s.empty()){
      q.add(s.peek());
      s.pop();
      q.add(q.peek());
      q.poll();
    }
  }
  public static void main(String[] args){
    Queue<Integer>q=new java.util.LinkedList<>();
    q.add(11);
    q.add(12);
    q.add(13);
    q.add(14);
    q.add(15);
    q.add(16);
    q.add(17);
    q.add(18);
    q.add(19);
    q.add(20);
    interLeaveQueue(q);
    int length=q.size();
    for(int i=0 ; i<length ; i++){
      System.out.print(q.peek()+" ");
      q.poll();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation interLeaveQueue( q : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (q->size() mod 2 /= 0) then     OclFile["System.out"].println("Input even number of integers.") ; else skip ; 
     var s : Sequence(int) ; s := Sequence{} ;
    var halfSize : int ; halfSize := q->size() / 2 ;
        var i : int ; i := 0 ; while i < halfSize do ( (     s := s->append(q->min()) ; 
     q := q->sort()->tail() )  ;     i := i + 1 ) ; 
    while (not(s->isEmpty())) do (     q->excludes(s->min()) ; 
     s := s->front() ) ; 
        var i : int ; i := 0 ; while i < halfSize do ( (     q->excludes(q->min()) ; 
     q := q->sort()->tail() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < halfSize do ( (     s := s->append(q->min()) ; 
     q := q->sort()->tail() )  ;     i := i + 1 ) ; 
    while (not(s->isEmpty())) do (     q->excludes(s->min()) ; 
     s := s->front() ; 
     q->excludes(q->min()) ; 
     q := q->sort()->tail() ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var q : Sequence(int) ; q := LinkedList<OclAny>.newLinkedList() ;
     q := q->including(11) ; 
    q := q->including(12) ; 
    q := q->including(13) ; 
    q := q->including(14) ; 
    q := q->including(15) ; 
    q := q->including(16) ; 
    q := q->including(17) ; 
    q := q->including(18) ; 
    q := q->including(19) ; 
    q := q->including(20) ; 
    execute interLeaveQueue(q) ; 
    var length : int ; length := q->size() ;
        var i : int ; i := 0 ; while i < length do ( (     OclFile["System.out"].print(q->min() + " ") ; 
     q := q->sort()->tail() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int numberOfTestCases=sc.nextInt();
    List<Case>testCases=new ArrayList<>();
    for(int i=0 ; i<numberOfTestCases ; i++){
      int numberOfFloors=sc.nextInt();
      int currentFloor=sc.nextInt();
      int numberOfClosedFloors=sc.nextInt();
      testCases.add(new Case(numberOfFloors,currentFloor,numberOfClosedFloors));
      for(int j=0 ; j<testCases.get(i).numberOfClosedFloors ; j++){
        testCases.get(i).closedFloors.add(sc.nextInt());
      }
    }
    for(Case t : testCases){
      int i=0 ;
      while(true){
        int up=t.currentFloor+i ;
        int down=t.currentFloor-i ;
        if((up<=t.numberOfFloors &&(! t.closedFloors.contains(up))||(down>0 && ! t.closedFloors.contains(down)))){
          System.out.println(i);
          break ;
        }
        i++;
      }
    }
  }
}
class Case {
  int numberOfFloors ;
  int currentFloor ;
  int numberOfClosedFloors ;
  Set<Integer>closedFloors ;
  public Case(int numberOfFloors,int currentFloor,int numberOfClosedFloors){
    this.numberOfFloors=numberOfFloors ;
    this.currentFloor=currentFloor ;
    this.numberOfClosedFloors=numberOfClosedFloors ;
    this.closedFloors=new HashSet<>();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numberOfTestCases : int ; numberOfTestCases := sc.getCurrent()->toInteger() ;
    var testCases : Sequence(Case) ; testCases := Sequence{} ;
        var i : int ; i := 0 ; while i < numberOfTestCases do ( (     var numberOfFloors : int ; numberOfFloors := sc.getCurrent()->toInteger() ;
     var currentFloor : int ; currentFloor := sc.getCurrent()->toInteger() ;
    var numberOfClosedFloors : int ; numberOfClosedFloors := sc.getCurrent()->toInteger() ;
    testCases := testCases->including(Case.newCase(numberOfFloors, currentFloor, numberOfClosedFloors)) ; 
        var j : int ; j := 0 ; while j < testCases->at(i+1).numberOfClosedFloors do ( (     testCases->at(i+1).closedFloors->excludes(sc.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    for (t : testCases) do ( (     var i : int ; i := 0 ;
     while (true) do (     var up : int ; up := t.currentFloor + i ;
     var down : int ; down := t.currentFloor - i ;
     if ((up <= t.numberOfFloors & (not(t.closedFloors->includes(up))) or (down > 0 & not(t.closedFloors->includes(down))))) then (     OclFile["System.out"].println(i) ; 
     break ) else skip ; 
     i := i + 1 ) )  ) ; 
 );
}
class Case {
   attribute numberOfFloors : int;
   attribute currentFloor : int;
   attribute numberOfClosedFloors : int;
   attribute closedFloors : Set(int);
   static operation newCase( numberOfFloors : int, currentFloor : int, numberOfClosedFloors : int) : Case
  pre: true
  post: true
  activity:
  ( var self : Case ;
    self := createCase();
    self.initialise(numberOfFloors, currentFloor,numberOfClosedFloors);
    return self );
  operation initialise( numberOfFloors : int, currentFloor : int, numberOfClosedFloors : int) : void
  pre: true  post: true
  activity: (     self.numberOfFloors := numberOfFloors ; 
     self.currentFloor := currentFloor ; 
     self.numberOfClosedFloors := numberOfClosedFloors ; 
     self.closedFloors := Set{} );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class KefaAndCompany {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str[]=br.readLine().trim().split(" ");
    int n=Integer.parseInt(str[0]);
    int k=Integer.parseInt(str[1]);
    long pf[]=new long[n];
    ArrayList<Kefa>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      String input[]=br.readLine().trim().split(" ");
      int money=Integer.parseInt(input[0]);
      int friend=Integer.parseInt(input[1]);
      list.add(new Kefa(money,friend));
    }
    Collections.sort(list,new KefaCmp());
    long ans=0 ;
    int s=0,e=0 ;
    long sum=0 ;
    while(e<n){
      if(list.get(e).money-list.get(s).money<k){
        sum+=list.get(e).friend ;
        e++;
      }
      else {
        sum-=list.get(s).friend ;
        s++;
      }
      ans=Math.max(ans,sum);
    }
    System.out.println(ans);
  }
}
class Kefa {
  int money ;
  int friend ;
  Kefa(int money,int friend){
    this.money=money ;
    this.friend=friend ;
  }
}
class KefaCmp implements Comparator<Kefa>{
  @ Override public int compare(Kefa o1,Kefa o2){
    return o1.money-o2.money ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class KefaAndCompany {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->trim()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var k : int ; k := (str[1+1])->toInteger() ;
    var pf : Sequence(long) ; pf := Integer.subrange(1,n)->collect(0) ;
    var list : Sequence(Kefa) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var input : Sequence(String) ; input := br.readLine()->trim()->split(" ") ;
     var money : int ; money := (input[0+1])->toInteger() ;
     var friend : int ; friend := (input[1+1])->toInteger() ;
     list := list->including(Kefa.newKefa(money, friend)) )  ;     i := i + 1 ) ; 
    list, KefaCmp.newKefaCmp() := list, KefaCmp.newKefaCmp()->sort() ; 
    var ans : long ; ans := 0 ;
    var s : int ; s := 0 ;
    var e : int ; e := 0 ;
    var sum : long ; sum := 0 ;
    while (e < n) do (     if (list->at(e+1).money - list->at(s+1).money < k) then (     sum := sum+(list->at(e+1).friend) ; 
     e := e + 1 ) else (     sum := sum-(list->at(s+1).friend) ; 
     s := s + 1 ) ;  
     ans := Set{ans, sum}->max() ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}
class Kefa {
   attribute money : int;
   attribute friend : int;
   static operation newKefa( money : int, friend : int) : Kefa
  pre: true
  post: true
  activity:
  ( var self : Kefa ;
    self := createKefa();
    self.initialise(money, friend);
    return self );
  operation initialise( money : int, friend : int) : void
  pre: true  post: true
  activity: (     self.money := money ; 
     self.friend := friend );
}
class KefaCmp implements Function(<Kefa>,(<Kefa>,boolean)) {
      operation compare( o1 : Kefa, o2 : Kefa) : int
  pre: true
  post: true
  activity: (     return o1.money - o2.money );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int GCD(int a,int b){
    if(b==0)return a ;
    return GCD(b,a % b);
  }
  static void findRatio(int m,int n){
    int Am=m-5,An=n-5 ;
    int numerator=Am/GCD(Am,An);
    int denominator=An/GCD(Am,An);
    System.out.println(numerator+"/"+denominator);
  }
  public static void main(String args[]){
    int m=10,n=20 ;
    findRatio(m,n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation GCD( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return GCD(b, a mod b) );
  static   operation findRatio( m : int, n : int) : void
  pre: true
  post: true
  activity: (     var Am : int ; Am := m - 5 ;
    var An : int ; An := n - 5 ;
     var numerator : int ; numerator := Am / GCD(Am, An) ;
     var denominator : int ; denominator := An / GCD(Am, An) ;
     OclFile["System.out"].println(numerator + "/" + denominator) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 10 ;
    var n : int ; n := 20 ;
     execute findRatio(m, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  public static double M_E=2.71828182845904523536 ;
  public static double M_PI=3.141592654 ;
  static long findDigits(int n){
    if(n<0)return 0 ;
    if(n<=1)return 1 ;
    double x=(n*Math.log10(n/M_E)+Math.log10(2*M_PI*n)/2.0);
    return(long)Math.floor(x)+1 ;
  }
  public static void main(String[] args){
    System.out.println(findDigits(1));
    System.out.println(findDigits(50000000));
    System.out.println(findDigits(1000000000));
    System.out.println(findDigits(120));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute M_E : double := 2.71828182845904523536;
  static   attribute M_PI : double := 3.141592654;
  static   operation findDigits( n : int) : long
  pre: true
  post: true
  activity: (     if (n < 0) then     return 0 else skip ; 
     if (n <= 1) then     return 1 else skip ; 
     var x : double ; x := (n * (n / M_E)->log10() + (2 * M_PI * n)->log10() / 2.0) ;
     return (x)->floor()->oclAsType(long) + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(findDigits(1)) ; 
     OclFile["System.out"].println(findDigits(50000000)) ; 
     OclFile["System.out"].println(findDigits(1000000000)) ; 
     OclFile["System.out"].println(findDigits(120)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void count_(int count[],int e){
    boolean hash[]=new boolean[10];
    while(e>0){
      if(hash[e % 10]==false)count[e % 10]++;
      hash[e % 10]=true ;
      e/=10 ;
    }
  }
  static void find_subsequence(int arr[],int n){
    int count[]=new int[10];
    for(int i=0 ; i<n ; i++){
      count_(count,arr[i]);
    }
    int longest=0 ;
    for(int i=0 ; i<10 ; i++)longest=Math.max(count[i],longest);
    System.out.print(longest);
  }
  public static void main(String[] args){
    int arr[]={
      11,12,23,74,13 };
      int n=arr.length ;
      find_subsequence(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count_( count : Sequence(int), e : int) : void
  pre: true
  post: true
  activity: (     var hash : Sequence(boolean) ; hash := Integer.subrange(1,10)->collect(false) ;
     while (e > 0) do (     if (hash[e mod 10+1] = false) then     count[e mod 10+1] := count[e mod 10+1] + 1 ; else skip ; 
     hash[e mod 10+1] := true ; 
     e := e/(10) ) );
  static   operation find_subsequence( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,10)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     execute count_(count, arr[i+1]) )  ;     i := i + 1 ) ; 
    var longest : int ; longest := 0 ;
        var i : int ; i := 0 ; while i < 10 do (     longest := Set{count[i+1], longest}->max() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(longest) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{11,12,23,74,13} ;
     var n : int ; n := arr->size() ;
     execute find_subsequence(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int find_sum(int n,int k){
    int total_sum=(n*(n+1))/2 ;
    int power=k ;
    while(power<=n){
      total_sum-=power ;
      power*=k ;
    }
    return total_sum ;
  }
  public static void main(String[] args){
    int n=11,k=2 ;
    System.out.println(find_sum(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation find_sum( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var total_sum : int ; total_sum := (n * (n + 1)) / 2 ;
     var power : int ; power := k ;
     while (power <= n) do (     total_sum := total_sum-(power) ; 
     power := power*(k) ) ; 
     return total_sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 11 ;
    var k : int ; k := 2 ;
     OclFile["System.out"].println(find_sum(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int FirstDigit(int arr[],int n){
    double S=0 ;
    for(int i=0 ; i<n ; i++)S=S+Math.log10(arr[i]*1.0);
    double fract_S=S-Math.floor(S);
    int ans=(int)Math.pow(10,fract_S);
    return ans ;
  }
  public static void main(String args[]){
    int arr[]={
      5,8,3,7 };
      System.out.println(FirstDigit(arr,arr.length));
    }
  }

------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation FirstDigit( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var S : double ; S := 0 ;
         var i : int ; i := 0 ; while i < n do (     S := S + (arr[i+1] * 1.0)->log10() ;  ;     i := i + 1 ) ; 
    var fract_S : double ; fract_S := S - (S)->floor() ;
    var ans : int ; ans := 10->pow(fract_S)->oclAsType(int) ;
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,8,3,7} ;
     OclFile["System.out"].println(FirstDigit(arr, arr->size())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findSum(int arr[],int n,int k){
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] % k==0){
        sum+=arr[i];
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      15,16,10,9,6,7,17 };
      int n=arr.length ;
      int k=3 ;
      System.out.println(findSum(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSum( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod k = 0) then (     sum := sum+(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{15,16,10,9,6,7,17} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println(findSum(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package c_2015 ;
import java.util.Scanner ;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int kases=in.nextInt();
    for(int kas=1 ; kas<=kases ; kas++){
      int K=in.nextInt();
      int L=in.nextInt();
      int S=in.nextInt();
      String keyboard=in.next();
      String target=in.next();
      int[] keys=new int[26];
      for(int i=0 ; i<K ; i++)keys[keyboard.charAt(i)-'A']++;
      boolean possible=true ;
      for(int i=0 ; i<L ; i++)if(keys[target.charAt(i)-'A']==0)possible=false ;
      if(! possible){
        System.out.println("Case #"+kas+": 0.0");
        continue ;
      }
      int[] EV=new int[S];
      int p ;
      outer : for(p=L-1 ;
      p>0 ;
      p--){
        for(int i=0 ; i<p ; i++){
          if(target.charAt(i)!=target.charAt(L-p+i))continue outer ;
        }
        break ;
      }
      int max=(S-p)/(L-p);
      double prob_word=1 ;
      for(int i=0 ; i<L ; i++){
        prob_word*=keys[target.charAt(i)-'A']/(0.0+K);
      }
      System.out.println("Case #"+kas+": "+(max-prob_word*(S-L+1)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var kases : int ; kases := in.getCurrent()->toInteger() ;
         var kas : int ; kas := 1 ; while kas <= kases do ( (     var K : int ; K := in.getCurrent()->toInteger() ;
     var L : int ; L := in.getCurrent()->toInteger() ;
    var S : int ; S := in.getCurrent()->toInteger() ;
    var keyboard : String ; keyboard := in.getCurrent() ;
    var target : String ; target := in.getCurrent() ;
    var keys : Sequence(int) ; keys := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < K do (     keys[keyboard->at(i+1) - ('A')->char2byte()+1] := keys[keyboard->at(i+1) - ('A')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    var possible : boolean ; possible := true ;
        var i : int ; i := 0 ; while i < L do (     if (keys[target->at(i+1) - ('A')->char2byte()+1] = 0) then     possible := false ; else skip ;  ;     i := i + 1 ) ; 
    if (not(possible)) then (     OclFile["System.out"].println("Case #" + kas + ": 0.0") ; 
     continue ) else skip ; 
    var EV : Sequence(int) ; EV := Integer.subrange(1,S)->collect(0) ;
    var p : int ;
        p := L - 1 ; while p > 0 do ( (         var i : int ; i := 0 ; while i < p do ( (     if (target->at(i+1) /= target->at(L - p + i+1)) then     continue else skip )  ;     i := i + 1 ) ; 
     break )  ;     p := p - 1 ) ; 
    var max : int ; max := (S - p) / (L - p) ;
    var prob_word : double ; prob_word := 1 ;
        var i : int ; i := 0 ; while i < L do ( (     prob_word := prob_word*(keys[target->at(i+1) - ('A')->char2byte()+1] / (0.0 + K)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Case #" + kas + ": " + (max - prob_word * (S - L + 1))) ; 
 )  ;     kas := kas + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.util.LinkedList ;
public class TypewriterMonkey {
  public static void main(String[] args)throws NumberFormatException,IOException {
    FileReader input=new FileReader(args[0]);
    BufferedReader buffer=new BufferedReader(input);
    int max=Integer.parseInt(buffer.readLine().trim());
    for(int i=1 ; i<=max ; i++){
      System.out.println("Case #"+i+": "+solve(buffer));
    }
  }
  public static double solve(BufferedReader buffer)throws NumberFormatException,IOException {
    String[] split=buffer.readLine().trim().split("\\s+");
    int K=Integer.parseInt(split[0]);
    int L=Integer.parseInt(split[1]);
    int S=Integer.parseInt(split[2]);
    String keys=buffer.readLine().trim();
    String target=buffer.readLine().trim();
    int differentStrings=(int)Math.pow(K,S);
    int max=0 ;
    int sum=0 ;
    for(int i=0 ; i<differentStrings ; i++){
      int number=i ;
      String result=new String();
      for(int j=0 ; j<S ; j++){
        result=result.concat(""+keys.charAt(number % K));
        number/=K ;
      }
      int count=0 ;
      int from=0 ;
      while((from=result.indexOf(target,from)+1)>0){
        count++;
      }
      sum+=count ;
      if(count>max)max=count ;
    }
    return 1.0*max-1.0*sum/differentStrings ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class TypewriterMonkey {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(args[0+1]) ;
     var buffer : OclFile ; buffer := OclFile.newOclFile_Read(input) ;
     var max : int ; max := (buffer.readLine()->trim())->toInteger() ;
         var i : int ; i := 1 ; while i <= max do ( (     OclFile["System.out"].println("Case #" + i + ": " + solve(buffer)) )  ;     i := i + 1 ) );
  static   operation solve( buffer : OclFile) : double
  pre: true
  post: true
  activity: (     var split : Sequence(String) ; split := buffer.readLine()->trim()->split("\\s+") ;
     var K : int ; K := (split[0+1])->toInteger() ;
    var L : int ; L := (split[1+1])->toInteger() ;
    var S : int ; S := (split[2+1])->toInteger() ;
    var keys : String ; keys := buffer.readLine()->trim() ;
    var target : String ; target := buffer.readLine()->trim() ;
    var differentStrings : int ; differentStrings := K->pow(S)->oclAsType(int) ;
    var max : int ; max := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < differentStrings do ( (     var number : int ; number := i ;
     var result : String ; result := StringLib.newString() ;
        var j : int ; j := 0 ; while j < S do ( (     result := result+"" + keys->at(number mod K+1) ; 
     number := number/(K) )  ;     j := j + 1 ) ; 
    var count : int ; count := 0 ;
    var from : int ; from := 0 ;
        from := result.subrange(from+1)->indexOf(target+"") + from - 1  + 1 ;
    while ((from) > 0) do (        skip ;     skip ; (     count := count + 1 ) ;     from := result.subrange(from+1)->indexOf(target+"") + from - 1  + 1 ;
 ) ;  
    sum := sum+(count) ; 
    if (count > max) then     max := count ; else skip ; 
 )  ;     i := i + 1 ) ; 
    return 1.0 * max - 1.0 * sum / differentStrings 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public final class B {
  public static void main(final String...args){
    final Scanner sc=new Scanner(System.in);
    final int t=sc.nextInt();
    for(int i=0 ; i<t ; ++i){
      System.out.println(String.format("Case #%d: %.7f",i+1,testcase(sc)));
    }
  }
  private static double testcase(final Scanner sc){
    final int k=sc.nextInt();
    final int l=sc.nextInt();
    final int s=sc.nextInt();
    final String keyboard=sc.next();
    final String text=sc.next();
    final int[] perm=new int[s];
    Arrays.fill(perm,0);
    int maxOccurences=0 ;
    double sum=0.0 ;
    double denominator=0 ;
    do {
      final StringBuilder builder=new StringBuilder(s);
      for(int i=0 ; i<s ; ++i){
        builder.append(keyboard.charAt(perm[i]));
      }
      final String result=builder.toString();
      int howMany=0 ;
      for(int i=0 ; i<s-l+1 ; ++i){
        if(result.substring(i,i+l).equals(text)){
++howMany ;
        }
      }
      maxOccurences=Math.max(maxOccurences,howMany);
      sum+=howMany ;
++denominator ;
    }
    while(nextPermutation(perm,k));
    return maxOccurences-(sum/denominator);
  }
  private static boolean nextPermutation(final int[] perm,final int k){
    int i=0 ;
    while(i<perm.length && perm[i]==k-1){
      perm[i]=0 ;
++i ;
    }
    if(i==perm.length){
      return false ;
    }
++perm[i];
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     OclFile["System.out"].println(StringLib.format("Case #%d: %.7f",Sequence{i + 1,testcase(sc)})) )  ;     i := i + 1 ) );
  static   operation testcase( sc : OclFile) : double
  pre: true
  post: true
  activity: (     var k : int ; k := sc.getCurrent()->toInteger() ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var keyboard : String ; keyboard := sc.getCurrent() ;
    var text : String ; text := sc.getCurrent() ;
    var perm : Sequence(int) ; perm := Integer.subrange(1,s)->collect(0) ;
    perm := perm->collect(0) ; 
    var maxOccurences : int ; maxOccurences := 0 ;
    var sum : double ; sum := 0.0 ;
    var denominator : double ; denominator := 0 ;
  while true do ((     var builder : String ; builder := StringLib.newString(s) ;
         var i : int ; i := 0 ; while i < s do ( (     builder := builder + StringLib.newString(keyboard->at(perm[i+1]+1)) )  ;     i := i + 1 ) ; 
    var result : String ; result := builder+"" ;
    var howMany : int ; howMany := 0 ;
        var i : int ; i := 0 ; while i < s - l + 1 do ( (     if (result.subrange(i+1,i + l) = text) then (     howMany := howMany + 1 ) else skip )  ;     i := i + 1 ) ; 
    maxOccurences := Set{maxOccurences, howMany}->max() ; 
    sum := sum+(howMany) ; 
    denominator := denominator + 1 ; 
 ) ;
    if (nextPermutation(perm, k)) then skip else break) ; 
    return maxOccurences - (sum / denominator) 
 );
  static   operation nextPermutation( perm : Sequence(int), k : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     while (i < perm->size() & perm[i+1] = k - 1) do (     perm[i+1] := 0 ; 
     i := i + 1 ) ; 
    if (i = perm->size()) then (     return false ) else skip ; 
    perm[i+1] := perm[i+1] + 1 ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class SolutionB {
  static Scanner scan=new Scanner(System.in);
  static PrintStream out=System.out ;
  private static void solve(){
    int K=scan.nextInt(),L=scan.nextInt(),S=scan.nextInt();
    String keys=scan.next();
    String word=scan.next();
    int[] keyCounts=new int[26];
    for(char c : keys.toCharArray()){
      int k=(int)(c-'A');
      keyCounts[k]++;
    }
    int idx=1 ;
    while(idx<L){
      if(word.substring(0,L-idx).equals(word.substring(idx)))break ;
++idx ;
    }
    int totalB=(idx==L)? S/L :(S-L)/idx+1 ;
    double percentage=1 ;
    for(char c : word.toCharArray()){
      int k=(int)(c-'A');
      int cnt=keyCounts[k];
      if(cnt==0){
        out.println("0.0");
        return ;
      }
      percentage*=(double)cnt/K ;
    }
    out.println(totalB-percentage*(S-L+1));
  }
  public static void main(String[] args){
    int T=scan.nextInt();
    for(int i=1 ; i<=T ; ++i){
      out.print("Case #"+i+": ");
      solve();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SolutionB {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile["System.out"];
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var K : int ; K := scan.getCurrent()->toInteger() ;
    var L : int ; L := scan.getCurrent()->toInteger() ;
    var S : int ; S := scan.getCurrent()->toInteger() ;
     var keys : String ; keys := scan.getCurrent() ;
    var word : String ; word := scan.getCurrent() ;
    var keyCounts : Sequence(int) ; keyCounts := Integer.subrange(1,26)->collect(0) ;
    for (c : keys->characters()) do ( (     var k : int ; k := (c - ('A')->char2byte())->oclAsType(int) ;
     keyCounts[k+1] := keyCounts[k+1] + 1 )  ) ; 
    var idx : int ; idx := 1 ;
    while (idx < L) do (     if (word.subrange(0+1,L - idx) = word.subrange(idx+1,idx)) then     break else skip ; 
     idx := idx + 1 ) ; 
    var totalB : int ; totalB := if (idx = L) then S / L else (S - L) / idx + 1 endif ;
    var percentage : double ; percentage := 1 ;
    for (c : word->characters()) do ( (     var k : int ; k := (c - ('A')->char2byte())->oclAsType(int) ;
     var cnt : int ; cnt := keyCounts[k+1] ;
     if (cnt = 0) then (     skip ; 
     return ) else skip ; 
     percentage := percentage*(cnt->oclAsType(double) / K) )  ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := scan.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= T do ( (     skip ; 
     execute solve() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line=br.readLine();
    String[] list=line.split(" ");
    int x=Integer.parseInt(list[0]);
    int a=Integer.parseInt(list[1]);
    int y=Integer.parseInt(list[2]);
    String h="NO" ;
    if(x==5 | x==7 | a==5 | a==7 | y==5 | y==7){
      if(x+y+a==17){
        h="YES" ;
      }
    }
    System.out.println(h);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := br.readLine() ;
    var list : Sequence(String) ; list := line->split(" ") ;
    var x : int ; x := (list[0+1])->toInteger() ;
    var a : int ; a := (list[1+1])->toInteger() ;
    var y : int ; y := (list[2+1])->toInteger() ;
    var h : String ; h := "NO" ;
    if (x = 5 or x = 7 or a = 5 or a = 7 or y = 5 or y = 7) then (     if (x + y + a = 17) then (     h := "YES" ) else skip ) else skip ; 
    OclFile["System.out"].println(h) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication91 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num1=sc.nextInt();
    int num2=sc.nextInt();
    int counter=0 ;
    ArrayList<Integer>arr=new ArrayList<>();
    for(int i=0 ; i<num1 ; i++){
      arr.add(0);
    }
    for(int i=0 ; i<num2 ; i++){
      int num3=sc.nextInt();
      int num4=sc.nextInt();
      int num5=sc.nextInt();
      arr.set(num3-1,arr.get(num3-1)+num5);
      arr.set(num4-1,arr.get(num4-1)-num5);
    }
    for(int i=0 ; i<num1 ; i++){
      counter+=Math.abs(arr.get(i));
    }
    System.out.println(counter/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication91 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num1 : int ; num1 := sc.getCurrent()->toInteger() ;
    var num2 : int ; num2 := sc.getCurrent()->toInteger() ;
    var counter : int ; counter := 0 ;
    var arr : Sequence(int) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < num1 do ( (     arr := arr->including(0) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < num2 do ( (     var num3 : int ; num3 := sc.getCurrent()->toInteger() ;
     var num4 : int ; num4 := sc.getCurrent()->toInteger() ;
    var num5 : int ; num5 := sc.getCurrent()->toInteger() ;
    arr := arr.setAt(num3 - 1+1,arr->at(num3 - 1+1) + num5) ; 
    arr := arr.setAt(num4 - 1+1,arr->at(num4 - 1+1) - num5) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < num1 do ( (     counter := counter+(if arr->at(i+1) < 0 then -(arr->at(i+1)) else arr->at(i+1) endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] debt=new int[n+1];
    int[] owe=new int[n+1];
    for(int i=0 ; i<m ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      debt[b]+=c ;
      owe[a]+=c ;
    }
    int sum=0 ;
    for(int i=1 ; i<=n ; i++){
      if(debt[i]<owe[i]){
        int diff=owe[i]-debt[i];
        sum+=diff ;
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var debt : Sequence(int) ; debt := Integer.subrange(1,n + 1)->collect(0) ;
    var owe : Sequence(int) ; owe := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    debt[b+1] := debt[b+1]+(c) ; 
    owe[a+1] := owe[a+1]+(c) ; 
 )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (debt[i+1] < owe[i+1]) then (     var diff : int ; diff := owe[i+1] - debt[i+1] ;
     sum := sum+(diff) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int sum=0 ;
    int[] debt=new int[n+1];
    for(int i=0 ; i<m ; i++){
      int x=in.nextInt();
      int y=in.nextInt();
      int d=in.nextInt();
      debt[x]+=d ;
      debt[y]-=d ;
    }
    for(int i=1 ; i<=n ; i++){
      if(debt[i]>0)sum+=debt[i];
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var debt : Sequence(int) ; debt := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var y : int ; y := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    debt[x+1] := debt[x+1]+(d) ; 
    debt[y+1] := debt[y+1]-(d) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (debt[i+1] > 0) then     sum := sum+(debt[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  public static int MAXN=1000001 ;
  public static int[] spf=new int[MAXN];
  static void sieve(){
    for(int i=1 ; i<MAXN ; i++)spf[i]=i ;
    for(int i=4 ; i<MAXN ; i+=2)spf[i]=2 ;
    for(int i=3 ; i*i<MAXN ; i++){
      if(spf[i]==i){
        for(int j=i*i ; j<MAXN ; j+=i)if(spf[j]==j)spf[j]=i ;
      }
    }
  }
  static int countSubArray(int arr[],int n){
    int[] ind=new int[MAXN];
    Arrays.fill(ind,-1);
    int count=0 ;
    int last_ind=0 ;
    for(int i=0 ; i<n ; ++i){
      while(arr[i]>1){
        int div=spf[arr[i] ];
        last_ind=Math.max(last_ind,ind[div]);
        ind[div]=i+1 ;
        arr[i]/=div ;
      }
      count+=i-last_ind+1 ;
    }
    return count ;
  }
  public static void main(String[] args){
    sieve();
    int arr[]={
      2,3,9 };
      int n=arr.length ;
      System.out.println(countSubArray(arr,n));
      int arr1[]={
        2,3,5,15,7,2 };
        int n1=arr1.length ;
        System.out.println(countSubArray(arr1,n1));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAXN : int := 1000001;
  static   attribute spf : Sequence(int) := Integer.subrange(1,MAXN)->collect(0);
  static   operation sieve() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < MAXN do (     spf[i+1] := i ;  ;     i := i + 1 ) ; 
         var i : int ; i := 4 ; while i < MAXN do (     spf[i+1] := 2 ;  ;     i := i+(2) ) ; 
         var i : int ; i := 3 ; while i * i < MAXN do ( (     if (spf[i+1] = i) then (         var j : int ; j := i * i ; while j < MAXN do (     if (spf[j+1] = j) then     spf[j+1] := i ; else skip ;  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) );
  static   operation countSubArray( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ind : Sequence(int) ; ind := Integer.subrange(1,MAXN)->collect(0) ;
     ind := ind->collect(-1) ; 
    var count : int ; count := 0 ;
    var last_ind : int ; last_ind := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     while (arr[i+1] > 1) do (     var div : int ; div := spf[arr[i+1]+1] ;
     last_ind := Set{last_ind, ind[div+1]}->max() ; 
     ind[div+1] := i + 1 ; 
     arr[i+1] := arr[i+1]/(div) ) ; 
     count := count+(i - last_ind + 1) )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute sieve() ; 
     var arr : Sequence(int) ; arr := Sequence{2,3,9} ;
    var n : int ; n := arr->size() ;
    OclFile["System.out"].println(countSubArray(arr, n)) ; 
    var arr1 : Sequence(int) ; arr1 := Sequence{2,3,5,15,7,2} ;
    var n1 : int ; n1 := arr1->size() ;
    OclFile["System.out"].println(countSubArray(arr1, n1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if(n==0 && m==0)break ;
      int[] ns=new int[n];
      int[] ms=new int[m];
      int nsum=0 ;
      int msum=0 ;
      for(int i=0 ; i<n ; i++){
        ns[i]=sc.nextInt();
        nsum+=ns[i];
      }
      for(int i=0 ; i<m ; i++){
        ms[i]=sc.nextInt();
        msum+=ms[i];
      }
      int sn=-1 ;
      int sm=-1 ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<m ; j++){
          if(nsum-ns[i]+ms[j]==msum-ms[j]+ns[i]){
            if(sn==-1){
              sn=ns[i];
              sm=ms[j];
            }
            else if(ns[i]+ms[j]<sn+sm){
              sn=ns[i];
              sm=ms[j];
            }
          }
        }
      }
      System.out.println(sn==-1 ? sn : sn+" "+sm);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if (n = 0 & m = 0) then     break else skip ; 
    var ns : Sequence(int) ; ns := Integer.subrange(1,n)->collect(0) ;
    var ms : Sequence(int) ; ms := Integer.subrange(1,m)->collect(0) ;
    var nsum : int ; nsum := 0 ;
    var msum : int ; msum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ns[i+1] := sc.getCurrent()->toInteger() ; 
     nsum := nsum+(ns[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     ms[i+1] := sc.getCurrent()->toInteger() ; 
     msum := msum+(ms[i+1]) )  ;     i := i + 1 ) ; 
    var sn : int ; sn := -1 ;
    var sm : int ; sm := -1 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (nsum - ns[i+1] + ms[j+1] = msum - ms[j+1] + ns[i+1]) then (     if (sn = -1) then (     sn := ns[i+1] ; 
     sm := ms[j+1] ) else     if (ns[i+1] + ms[j+1] < sn + sm) then (     sn := ns[i+1] ; 
     sm := ms[j+1] ) else skip ; ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if sn = -1 then sn else sn + " " + sm endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,m,i,j,sumt,sumh,tt,th ;
    int[] st,sh ;
    for(; ; ){
      n=sc.nextInt();
      m=sc.nextInt();
      if(n==0 && m==0)break ;
      st=new int[n];
      sh=new int[m];
      sumt=0 ;
      sumh=0 ;
      tt=201 ;
      th=201 ;
      for(i=0 ; i<n ; i++){
        st[i]=sc.nextInt();
        sumt+=st[i];
      }
      for(i=0 ; i<m ; i++){
        sh[i]=sc.nextInt();
        sumh+=sh[i];
      }
      for(i=0 ; i<n ; i++)for(j=0 ; j<m ; j++){
        if(sumt-2*st[i]==sumh-2*sh[j] && tt+th>st[i]+sh[j]){
          tt=st[i];
          th=sh[j];
        }
      }
      if(tt!=201 && th!=201)out.println(tt+" "+th);
      else out.println("-1");
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var m : int ;
    var i : int ;
    var j : int ;
    var sumt : int ;
    var sumh : int ;
    var tt : int ;
    var th : int ;
    var st : Sequence(int) ;
    var sh : Sequence(int) ;
      while true do ( (     n := sc.nextInt() ; 
     m := sc.nextInt() ; 
    if (n = 0 & m = 0) then     break else skip ; 
    st := Integer.subrange(1,n)->collect(0) ; 
    sh := Integer.subrange(1,m)->collect(0) ; 
    sumt := 0 ; 
    sumh := 0 ; 
    tt := 201 ; 
    th := 201 ; 
        i := 0 ; while i < n do ( (     st[i+1] := sc.nextInt() ; 
     sumt := sumt+(st[i+1]) )  ;     i := i + 1 ) ; 
        i := 0 ; while i < m do ( (     sh[i+1] := sc.nextInt() ; 
     sumh := sumh+(sh[i+1]) )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do (         j := 0 ; while j < m do ( (     if (sumt - 2 * st[i+1] = sumh - 2 * sh[j+1] & tt + th > st[i+1] + sh[j+1]) then (     tt := st[i+1] ; 
     th := sh[j+1] ) else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    if (tt /= 201 & th /= 201) then     out.println(tt + " " + th) else     out.println("-1") ; ;  
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      String line=sc.nextLine();
      if(line.equals("0 0")){
        return ;
      }
      int countCard1=Integer.valueOf(line.split(" ")[0]);
      int countCard2=Integer.valueOf(line.split(" ")[1]);
      int[] arrCard1=new int[countCard1];
      int[] arrCard2=new int[countCard2];
      int totalVal1=0 ;
      int totalVal2=0 ;
      for(int i=0 ; i<countCard1 ; i++){
        arrCard1[i]=Integer.valueOf(sc.nextLine());
        totalVal1+=arrCard1[i];
      }
      for(int i=0 ; i<countCard2 ; i++){
        arrCard2[i]=Integer.valueOf(sc.nextLine());
        totalVal2+=arrCard2[i];
      }
      if((totalVal1+totalVal2)% 2!=0){
        System.out.println("-1");
      }
      else {
        int avg=(totalVal1+totalVal2)/2 ;
        int missingValue1=avg-totalVal1 ;
        String result=null ;
        Integer minResult=null ;
        for(Integer number1 : arrCard1){
          for(Integer number2 : arrCard2){
            if(number1+missingValue1==number2){
              if(minResult==null || number1+number2<minResult){
                result=number1+" "+number2 ;
                minResult=number1+number2 ;
              }
            }
          }
        }
        if(result==null){
          System.out.println("-1");
        }
        else {
          System.out.println(result);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var line : String ; line := sc.nextLine() ;
     if (line = "0 0") then (     return ) else skip ; 
    var countCard1 : int ; countCard1 := (line->split(" ")[0+1])->toInteger() ;
    var countCard2 : int ; countCard2 := (line->split(" ")[1+1])->toInteger() ;
    var arrCard1 : Sequence(int) ; arrCard1 := Integer.subrange(1,countCard1)->collect(0) ;
    var arrCard2 : Sequence(int) ; arrCard2 := Integer.subrange(1,countCard2)->collect(0) ;
    var totalVal1 : int ; totalVal1 := 0 ;
    var totalVal2 : int ; totalVal2 := 0 ;
        var i : int ; i := 0 ; while i < countCard1 do ( (     arrCard1[i+1] := (sc.nextLine())->toInteger() ; 
     totalVal1 := totalVal1+(arrCard1[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < countCard2 do ( (     arrCard2[i+1] := (sc.nextLine())->toInteger() ; 
     totalVal2 := totalVal2+(arrCard2[i+1]) )  ;     i := i + 1 ) ; 
    if ((totalVal1 + totalVal2) mod 2 /= 0) then (     OclFile["System.out"].println("-1") ) else (     var avg : int ; avg := (totalVal1 + totalVal2) / 2 ;
     var missingValue1 : int ; missingValue1 := avg - totalVal1 ;
    var result : String ; result := null ;
    var minResult : int ; minResult := null ;
    for (number1 : arrCard1) do ( (     for (number2 : arrCard2) do ( (     if (number1 + missingValue1 = number2) then (     if (minResult = null or number1 + number2 < minResult) then (     result := number1 + " " + number2 ; 
     minResult := number1 + number2 ) else skip ) else skip )  ) )  ) ; 
    if (result = null) then (     OclFile["System.out"].println("-1") ) else (     OclFile["System.out"].println(result) ) ;  
 ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.awt.geom.Point2D ;
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    while(sc.hasNext()){
      new aoj1153().doIt();
    }
  }
  class aoj1153 {
    String ans(int a[],int b[]){
      int asum=0 ;
      int bsum=0 ;
      int sum=Integer.MAX_VALUE ;
      for(int i=0 ; i<a.length ; i++)asum=asum+a[i];
      for(int i=0 ; i<b.length ; i++)bsum=bsum+b[i];
      String result="-1" ;
      for(int i=0 ; i<a.length ; i++){
        for(int j=0 ; j<b.length ; j++){
          if(asum-a[i]+b[j]==bsum-b[j]+a[i]){
            if(a[i]+b[j]<sum){
              result=a[i]+" "+b[j];
              sum=a[i]+b[j];
            }
          }
        }
      }
      return result ;
    }
    void doIt(){
      while(true){
        int n=sc.nextInt();
        int m=sc.nextInt();
        if(n+m==0)break ;
        int a[]=new int[n];
        int b[]=new int[m];
        for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
        for(int i=0 ; i<m ; i++)b[i]=sc.nextInt();
        System.out.println(ans(a,b));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     while (sc.hasNext()) do (     aoj1153.newaoj1153().doIt() ) );
 class aoj1153 {
   operation ans( a : Sequence(int), b : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var asum : int ; asum := 0 ;
     var bsum : int ; bsum := 0 ;
    var sum : int ; sum := 2147483647 ;
        var i : int ; i := 0 ; while i < a->size() do (     asum := asum + a[i+1] ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < b->size() do (     bsum := bsum + b[i+1] ;  ;     i := i + 1 ) ; 
    var result : String ; result := "-1" ;
        var i : int ; i := 0 ; while i < a->size() do ( (         var j : int ; j := 0 ; while j < b->size() do ( (     if (asum - a[i+1] + b[j+1] = bsum - b[j+1] + a[i+1]) then (     if (a[i+1] + b[j+1] < sum) then (     result := a[i+1] + " " + b[j+1] ; 
     sum := a[i+1] + b[j+1] ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return result 
 );
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if (n + m = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     b[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans(a, b)) ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      int n=in.nextInt(),m=in.nextInt();
      if(n==0 && m==0)break ;
      int as[]=new int[n],bs[]=new int[m];
      for(int i=0 ; i<n ; i++)as[i]=in.nextInt();
      for(int i=0 ; i<m ; i++)bs[i]=in.nextInt();
      int totalA=0,totalB=0 ;
      int a=-1,b=-1,s=1<<29 ;
      for(int i=0 ; i<n ; i++)totalA+=as[i];
      for(int i=0 ; i<m ; i++)totalB+=bs[i];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<m ; j++){
          if(as[i]+bs[j]<s && totalA-as[i]+bs[j]==totalB-bs[j]+as[i]){
            s=as[i]+bs[j];
            a=as[i];
            b=bs[j];
          }
        }
      }
      if(a<0)System.out.println(-1);
      else System.out.println(a+" "+b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
     if (n = 0 & m = 0) then     break else skip ; 
    var as : Sequence(int) ; as := Integer.subrange(1,n)->collect(0) ;
    var bs : Sequence(void) ; bs := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     as[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     bs[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var totalA : int ; totalA := 0 ;
    var totalB : int ; totalB := 0 ;
    var a : int ; a := -1 ;
    var b : int ; b := -1 ;
    var s : int ; s := (1*(2->pow(29)))->oclAsType(long) ;
        var i : int ; i := 0 ; while i < n do (     totalA := totalA+(as[i+1]) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     totalB := totalB+(bs[i+1]) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (as[i+1] + bs[j+1] < s & totalA - as[i+1] + bs[j+1] = totalB - bs[j+1] + as[i+1]) then (     s := as[i+1] + bs[j+1] ; 
     a := as[i+1] ; 
     b := bs[j+1] ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (a < 0) then     OclFile["System.out"].println(-1) else     OclFile["System.out"].println(a + " " + b) ; ;  
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int fixedPoint(int[] A){
    int l=0 ;
    int h=A.length ;
    while(l<=h){
      int mid=(l+h)/2 ;
      if(A[mid]>mid)h=mid-1 ;
      else if(A[mid]<mid)l=mid+1 ;
      else return mid ;
    }
    return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation fixedPoint( A : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
     var h : int ; h := A->size() ;
     while (l <= h) do (     var mid : int ; mid := (l + h) / 2 ;
     if (A[mid+1] > mid) then     h := mid - 1 ; else     if (A[mid+1] < mid) then     l := mid + 1 else     return mid ;  ) ; 
     return -1 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int d=sc.nextInt();
    Pair[] ar=new Pair[n];
    for(int i=0 ; i<n ; i++){
      ar[i]=new Pair(sc.nextInt(),sc.nextInt());
    }
    Arrays.sort(ar);
    long sum=0,res=-1l ;
    int start=0 ;
    int end=0 ;
    while(end<n){
      if(ar[end] .x-ar[start] .x<d){
        sum+=ar[end] .y ;
        end++;
      }
      else {
        sum-=ar[start] .y ;
        start++;
      }
      res=Math.max(res,sum);
    }
    System.out.println(res);
  }
}
class Pair implements Comparable<Pair>{
  int x ;
  int y ;
  Pair(int x,int y){
    this.x=x ;
    this.y=y ;
  }
  public int compareTo(Pair that){
    return this.x-that.x ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var ar : Sequence(Map) ; ar := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := Map(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    ar := ar->sort() ; 
    var sum : long ; sum := 0 ;
    var res : long ; res := -1l ;
    var start : int ; start := 0 ;
    var end : int ; end := 0 ;
    while (end < n) do (     if (ar[end+1].x - ar[start+1].x < d) then (     sum := sum+(ar[end+1].y) ; 
     end := end + 1 ) else (     sum := sum-(ar[start+1].y) ; 
     start := start + 1 ) ;  
     res := Set{res, sum}->max() ) ; 
    OclFile["System.out"].println(res) ; 
 );
}
class Pair implements Comparable<Map> {
   attribute x : int;
   attribute y : int;
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation compareTo( that : Map) : int
  pre: true
  post: true
  activity: (     return self.x - that.x );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int INF=1<<24 ;
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    int cost[][]=new int[n][n];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        cost[i][j]=stdIn.nextInt();
      }
    }
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        ans+=Math.min(cost[i][j],cost[j][i]);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute INF : int := (1*(2->pow(24)))->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var cost : Sequence(Sequence(int)) ; cost := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     cost[i+1][j+1] := stdIn.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     ans := ans+(Set{cost[i+1][j+1], cost[j+1][i+1]}->min()) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    SightseeingTour solver=new SightseeingTour();
    solver.solve(1,in,out);
    out.close();
  }
  static class SightseeingTour {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int N=in.nextInt();
      int[][] C=new int[N][N];
      for(int i=0 ; i<N ; i++){
        for(int j=0 ; j<N ; j++){
          C[i][j]=in.nextInt();
        }
      }
      long ans=0 ;
      for(int i=0 ; i<N ; i++){
        for(int j=i ; j<N ; j++){
          ans+=Math.min(C[i][j],C[j][i]);
        }
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : SightseeingTour ; solver := SightseeingTour.newSightseeingTour() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class SightseeingTour {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
     var C : Sequence(Sequence(int)) ; C := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     C[i+1][j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := i ; while j < N do ( (     ans := ans+(Set{C[i+1][j+1], C[j+1][i+1]}->min()) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int[][] data=new int[n][n];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          data[i][j]=sc.nextInt();
        }
      }
      long sum=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=i+1 ; j<n ; j++){
          sum+=Math.min(data[i][j],data[j][i]);
        }
      }
      System.out.println(sum);
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var data : Sequence(Sequence(int)) ; data := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     data[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     sum := sum+(Set{data[i+1][j+1], data[j+1][i+1]}->min()) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  Scanner sc=new Scanner(in);
  void run(){
    int n=sc.nextInt();
    int[][] mat=new int[n][n];
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)mat[i][j]=sc.nextInt();
    long res=0 ;
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        res+=Math.min(mat[i][j],mat[j][i]);
      }
    }
    out.println(res);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var mat : Sequence(Sequence(int)) ; mat := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (     mat[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     res := res+(Set{mat[i+1][j+1], mat[j+1][i+1]}->min()) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    out.println(res) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int N=3 ;
  static void multiply(int mat[][],int res[][]){
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        res[i][j]=0 ;
        for(int k=0 ; k<N ; k++)res[i][j]+=mat[i][k]*mat[k][j];
      }
    }
  }
  static boolean InvolutoryMatrix(int mat[][]){
    int res[][]=new int[N][N];
    multiply(mat,res);
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        if(i==j && res[i][j]!=1)return false ;
        if(i!=j && res[i][j]!=0)return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    int mat[][]={
      {
        1,0,0 },{
          0,-1,0 },{
            0,0,-1 }
          };
          if(InvolutoryMatrix(mat))System.out.println("Involutory Matrix");
          else System.out.println("Not Involutory Matrix");
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 3;
  static   operation multiply( mat : Sequence(Sequence(int)), res : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     res[i+1][j+1] := 0 ; 
         var k : int ; k := 0 ; while k < N do (     res[i+1][j+1] := res[i+1][j+1]+(mat[i+1][k+1] * mat[k+1][j+1]) ;  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation InvolutoryMatrix( mat : Sequence(Sequence(int))) : boolean
  pre: true
  post: true
  activity: (     var res : Sequence(Sequence(int)) ; res := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
     execute multiply(mat, res) ; 
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     if (i = j & res[i+1][j+1] /= 1) then     return false else skip ; 
     if (i /= j & res[i+1][j+1] /= 0) then     return false else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,0,0},Sequence{0,-1,0},Sequence{0,0,-1}} ;
     if (InvolutoryMatrix(mat)) then     OclFile["System.out"].println("Involutory Matrix") ; else     OclFile["System.out"].println("Not Involutory Matrix") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public void run(){
    int n=sc.nextInt();
    calc(n);
  }
  public void calc(int n){
    int[][] costs=new int[n][n];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        costs[i][j]=sc.nextInt();
      }
    }
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        sum+=Math.min(costs[i][j],costs[j][i]);
      }
    }
    System.out.println(sum);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     execute calc(n) );
   operation calc( n : int) : void
  pre: true
  post: true
  activity: (     var costs : Sequence(Sequence(int)) ; costs := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     costs[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     sum := sum+(Set{costs[i+1][j+1], costs[j+1][i+1]}->min()) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int remAnagram(String str1,String str2){
    int count1[]=new int[26];
    int count2[]=new int[26];
    for(int i=0 ; i<str1.length(); i++)count1[str1.charAt(i)-'a']++;
    for(int i=0 ; i<str2.length(); i++)count2[str2.charAt(i)-'a']++;
    int result=0 ;
    for(int i=0 ; i<26 ; i++)result+=Math.abs(count1[i]-count2[i]);
    return result ;
  }
  public static void main(String[] args){
    String str1="bcadeh",str2="hea" ;
    System.out.println(remAnagram(str1,str2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation remAnagram( str1 : String, str2 : String) : int
  pre: true
  post: true
  activity: (     var count1 : Sequence(int) ; count1 := Integer.subrange(1,26)->collect(0) ;
     var count2 : Sequence(int) ; count2 := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < str1->size() do (     count1[str1->at(i+1) - ('a')->char2byte()+1] := count1[str1->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < str2->size() do (     count2[str2->at(i+1) - ('a')->char2byte()+1] := count2[str2->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < 26 do (     result := result+(if count1[i+1] - count2[i+1] < 0 then -(count1[i+1] - count2[i+1]) else count1[i+1] - count2[i+1] endif) ;  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "bcadeh" ;
    var str2 : String ; str2 := "hea" ;
     OclFile["System.out"].println(remAnagram(str1, str2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static double polyarea(double n,double r){
    if(r<0 && n<0)return-1 ;
    double A=((r*r*n)*Math.sin((360/n)*3.14159/180))/2 ;
    return A ;
  }
  public static void main(String[] args){
    float r=9,n=6 ;
    System.out.println(polyarea(n,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation polyarea( n : double, r : double) : double
  pre: true
  post: true
  activity: (     if (r < 0 & n < 0) then     return -1 else skip ; 
     var A : double ; A := ((r * r * n) * ((360 / n) * 3.14159 / 180)->sin()) / 2 ;
     return A );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : double ; r := 9 ;
    var n : double ; n := 6 ;
     OclFile["System.out"].println(polyarea(n, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class code {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int t=sc.nextInt();
    while(t-->0){
      solve();
    }
  }
  static void solve(){
    String s=sc.next();
    Set<Character>ori=new HashSet<>();
    for(int i=0 ; i<s.length(); i++){
      ori.add(s.charAt(i));
    }
    if(ori.size()==1 || ori.size()==s.length()){
      System.out.println("Yes");
      return ;
    }
    int n=ori.size();
    ori.clear();
    int i=0,j=0 ;
    while(j<s.length()){
      ori.add(s.charAt(j));
      if(j-i+1==n){
        if(ori.size()<n){
          System.out.println("no");
          return ;
        }
        else {
          ori.remove(s.charAt(i++));
        }
      }
      j++;
    }
    System.out.println("Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class code {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var s : String ; s := sc.getCurrent() ;
     var ori : Set(String) ; ori := Set{} ;
        var i : int ; i := 0 ; while i < s->size() do ( (     ori := ori->including(s->at(i+1)) )  ;     i := i + 1 ) ; 
    if (ori->size() = 1 or ori->size() = s->size()) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
    var n : int ; n := ori->size() ;
    ori := ori->intersection(Set{}) ; 
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    while (j < s->size()) do (     ori := ori->including(s->at(j+1)) ; 
     if (j - i + 1 = n) then (     if (ori->size() < n) then (     OclFile["System.out"].println("no") ; 
     return ) else (     ori := ori->excludingFirst(s->at(i+1)) ) ) else skip ; 
     j := j + 1 ) ; 
    OclFile["System.out"].println("Yes") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      String s=sc.next();
      Set<Character>chars=new HashSet<Character>();
      for(int i=0 ; i<s.length(); i++){
        chars.add(s.charAt(i));
      }
      int condi=0 ;
      int k=chars.size();
      for(int i=0 ; i<s.length()-k ; i++){
        if(s.charAt(i)!=s.charAt(i+k)){
          condi=1 ;
        }
      }
      if(condi==1){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var s : String ; s := sc.getCurrent() ;
     var chars : Set(String) ; chars := Set{} ;
        var i : int ; i := 0 ; while i < s->size() do ( (     chars := chars->including(s->at(i+1)) )  ;     i := i + 1 ) ; 
    var condi : int ; condi := 0 ;
    var k : int ; k := chars->size() ;
        var i : int ; i := 0 ; while i < s->size() - k do ( (     if (s->at(i+1) /= s->at(i + k+1)) then (     condi := 1 ) else skip )  ;     i := i + 1 ) ; 
    if (condi = 1) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Kefa {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int d=sc.nextInt();
    Pair[] pairs=new Pair[n];
    for(int i=0 ; i<n ; i++){
      long x=sc.nextLong();
      long y=sc.nextLong();
      pairs[i]=new Pair(x,y);
    }
    Arrays.sort(pairs,new cmp());
    int start=0 ;
    int end=0 ;
    long sum=0 ;
    long max=0 ;
    while(end<n){
      if((pairs[start] .x-pairs[end] .x)<d){
        sum+=pairs[end] .y ;
        end++;
      }
      else {
        max=Math.max(sum,max);
        sum-=pairs[start] .y ;
        start++;
      }
    }
    max=Math.max(max,sum);
    System.out.println(max);
  }
}
class Pair {
  long x ;
  long y ;
  Pair(long x,long y){
    this.x=x ;
    this.y=y ;
  }
}
class cmp implements Comparator<Pair>{
  public int compare(Pair p1,Pair p2){
    if(p1.x<p2.x){
      return 1 ;
    }
    else if(p1.x==p2.x){
      return 0 ;
    }
    return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Kefa {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var pairs : Sequence(Map) ; pairs := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : long ; x := sc.getCurrent()->toLong() ;
     var y : long ; y := sc.getCurrent()->toLong() ;
     pairs[i+1] := Map(x, y) )  ;     i := i + 1 ) ; 
    pairs := OclComparator.sortWith(pairs, cmp.newcmp()) ; 
    var start : int ; start := 0 ;
    var end : int ; end := 0 ;
    var sum : long ; sum := 0 ;
    var max : long ; max := 0 ;
    while (end < n) do (     if ((pairs[start+1].x - pairs[end+1].x) < d) then (     sum := sum+(pairs[end+1].y) ; 
     end := end + 1 ) else (     max := Set{sum, max}->max() ; 
     sum := sum-(pairs[start+1].y) ; 
     start := start + 1 ) ) ; 
    max := Set{max, sum}->max() ; 
    OclFile["System.out"].println(max) ; 
 );
}
class Pair {
   attribute x : long;
   attribute y : long;
   static operation newPair( x : long, y : long) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : long, y : long) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}
class cmp implements Function(<Map>,(<Map>,boolean)) {
   operation compare( p1 : Map, p2 : Map) : int
  pre: true
  post: true
  activity: (     if (p1.x < p2.x) then (     return 1 ) else     if (p1.x = p2.x) then (     return 0 ) else skip ; ;  
     return -1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int surfaceArea(int b,int s){
    return 2*b*s+(int)Math.pow(b,2);
  }
  public static void main(String[] args){
    int b=3,s=4 ;
    System.out.println(surfaceArea(b,s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation surfaceArea( b : int, s : int) : int
  pre: true
  post: true
  activity: (     return 2 * b * s + b->pow(2)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var b : int ; b := 3 ;
    var s : int ; s := 4 ;
     OclFile["System.out"].println(surfaceArea(b, s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int count(String s,int len){
    int MAX=1000 ;
    int cur=0,dig=0 ;
    int[] sum=new int[MAX];
    int[][] dp=new int[MAX][3];
    dp[0][0]=1 ;
    for(int i=1 ; i<=len ; i++){
      dig=(int)(s.charAt(i-1))-48 ;
      cur+=dig ;
      cur %=3 ;
      sum[i]=cur ;
      dp[i][0]=dp[i-1][0];
      dp[i][1]=dp[i-1][1];
      dp[i][2]=dp[i-1][2];
      dp[i][sum[i] ]++;
    }
    int ans=0,dprev=0,value=0,dprev2=0 ;
    for(int i=1 ; i<=len ; i++){
      dig=(int)(s.charAt(i-1))-48 ;
      if(dig==8)ans++;
      if(i-2>=0){
        dprev=(int)(s.charAt(i-2))-48 ;
        value=dprev*10+dig ;
        if((value % 8==0)&&(value % 3!=0))ans++;
      }
      if(i-3>=0){
        dprev2=(int)(s.charAt(i-3))-48 ;
        dprev=(int)(s.charAt(i-2))-48 ;
        value=dprev2*100+dprev*10+dig ;
        if(value % 8!=0)continue ;
        ans+=(i-2);
        ans-=(dp[i-3][sum[i] ]);
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    String str="6564525600" ;
    int len=str.length();
    System.out.println(count(str,len));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count( s : String, len : int) : int
  pre: true
  post: true
  activity: (     var MAX : int ; MAX := 1000 ;
     var cur : int ; cur := 0 ;
    var dig : int ; dig := 0 ;
    var sum : Sequence(int) ; sum := Integer.subrange(1,MAX)->collect(0) ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,MAX)->collect(Integer.subrange(1,3)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= len do ( (     dig := (s->at(i - 1+1))->oclAsType(int) - 48 ; 
     cur := cur+(dig) ; 
    cur := cur mod 3 ; 
    sum[i+1] := cur ; 
    dp[i+1][0+1] := dp[i - 1+1][0+1] ; 
    dp[i+1][1+1] := dp[i - 1+1][1+1] ; 
    dp[i+1][2+1] := dp[i - 1+1][2+1] ; 
    dp[i+1][sum[i+1]+1] := dp[i+1][sum[i+1]+1] + 1 ; 
 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var dprev : int ; dprev := 0 ;
    var value : int ; value := 0 ;
    var dprev2 : int ; dprev2 := 0 ;
        var i : int ; i := 1 ; while i <= len do ( (     dig := (s->at(i - 1+1))->oclAsType(int) - 48 ; 
     if (dig = 8) then     ans := ans + 1 ; else skip ; 
     if (i - 2 >= 0) then (     dprev := (s->at(i - 2+1))->oclAsType(int) - 48 ; 
     value := dprev * 10 + dig ; 
     if ((value mod 8 = 0) & (value mod 3 /= 0)) then     ans := ans + 1 ; else skip ) else skip ; 
     if (i - 3 >= 0) then (     dprev2 := (s->at(i - 3+1))->oclAsType(int) - 48 ; 
     dprev := (s->at(i - 2+1))->oclAsType(int) - 48 ; 
    value := dprev2 * 100 + dprev * 10 + dig ; 
    if (value mod 8 /= 0) then     continue else skip ; 
    ans := ans+((i - 2)) ; 
    ans := ans-((dp[i - 3+1][sum[i+1]+1])) ; 
 ) else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "6564525600" ;
     var len : int ; len := str->size() ;
     OclFile["System.out"].println(count(str, len)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A332 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    char[] S=in.next().toCharArray();
    int pos=N ;
    int answer=0 ;
    while(pos<S.length){
      if(S[pos-1]==S[pos-2] && S[pos-2]==S[pos-3]){
        answer++;
      }
      pos+=N ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A332 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var S : Sequence(String) ; S := in.getCurrent()->characters() ;
    var pos : int ; pos := N ;
    var answer : int ; answer := 0 ;
    while (pos < S->size()) do (     if (S[pos - 1+1] = S[pos - 2+1] & S[pos - 2+1] = S[pos - 3+1]) then (     answer := answer + 1 ) else skip ; 
     pos := pos+(N) ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    FastScanner input=new FastScanner();
    int n=input.nextInt();
    String s=input.next();
    int count=0 ;
    for(int i=0 ; i<s.length(); i+=n){
      if(i>=4 &&(s.charAt(i-1)==s.charAt(i-2))&&(s.charAt(i-2)==s.charAt(i-3))){
        count++;
      }
    }
    System.out.println(count);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var n : int ; n := input.nextInt() ;
    var s : String ; s := input.next() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (i >= 4 & (s->at(i - 1+1) = s->at(i - 2+1)) & (s->at(i - 2+1) = s->at(i - 3+1))) then (     count := count + 1 ) else skip )  ;     i := i+(n) ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
public class crazy_number {
  public static int first(int n){
    int a=n ;
    int c=1 ;
    while(a!=0){
      a/=10 ;
      c=c*10 ;
    }
    c=c/10 ;
    int fi=n/c ;
    return fi ;
  }
  public static boolean prime(int n){
    switch(n){
      case 2 : return true ;
      case 3 : return true ;
      case 5 : return true ;
      case 7 : return true ;
      default : return false ;
    }
  }
  public static void check(int n,int k){
    int l=n % 10 ;
    int f=first(n);
    boolean lp=prime(l);
    boolean fp=prime(f);
    if(lp && fp){
      if(l+f<k)System.out.println("Yes");
      else System.out.println("No");
    }
    else {
      System.out.println("No");
    }
  }
  public static void main(String args[]){
    int n=322223 ;
    int k=10 ;
    check(n,k);
    n=62531561 ;
    k=15 ;
    check(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class crazy_number {
  static   operation first( n : int) : int
  pre: true
  post: true
  activity: (     var a : int ; a := n ;
     var c : int ; c := 1 ;
    while (a /= 0) do (     a := a/(10) ; 
     c := c * 10 ) ; 
    c := c / 10 ; 
    var fi : int ; fi := n / c ;
    return fi 
 );
  static   operation prime( n : int) : boolean
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (n) ; 
       if _switchval = 2 then
     return true 
   else skip ;
       if _switchval = 3 then
     return true 
   else skip ;
       if _switchval = 5 then
     return true 
   else skip ;
       if _switchval = 7 then
     return true 
   else skip ;
       if true then
     return false 
   else skip ;
 )
 );
  static   operation check( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var l : int ; l := n mod 10 ;
     var f : int ; f := first(n) ;
    var lp : boolean ; lp := prime(l) ;
    var fp : boolean ; fp := prime(f) ;
    if (lp & fp) then (     if (l + f < k) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; ) else (     OclFile["System.out"].println("No") ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 322223 ;
     var k : int ; k := 10 ;
    execute check(n, k) ; 
    n := 62531561 ; 
    k := 15 ; 
    execute check(n, k) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ADownTheHatch solver=new ADownTheHatch();
    solver.solve(1,in,out);
    out.close();
  }
  static class ADownTheHatch {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      char[] s=in.next().toCharArray();
      int answer=0 ;
      for(int i=0 ; i<s.length ; i+=n){
        if(i>=3 && s[i-1]==s[i-2] && s[i-2]==s[i-3])answer++;
      }
      out.println(answer);
    }
  }
  static class InputReader {
    public final BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ADownTheHatch ; solver := ADownTheHatch.newADownTheHatch() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ADownTheHatch {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var s : Sequence(String) ; s := in.next()->characters() ;
    var answer : int ; answer := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (i >= 3 & s[i - 1+1] = s[i - 2+1] & s[i - 2+1] = s[i - 3+1]) then     answer := answer + 1 ; else skip )  ;     i := i+(n) ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A332 {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    StringTokenizer st ;
    int n=Integer.parseInt(br.readLine());
    String s=br.readLine();
    int ans=0 ;
    for(int i=n ; i<s.length(); i+=n){
      if(s.charAt(i-1)==s.charAt(i-2)&& s.charAt(i-1)==s.charAt(i-3)){
        ans++;
      }
    }
    pw.println(ans);
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A332 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var st : OclIterator ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var s : String ; s := br.readLine() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := n ; while i < s->size() do ( (     if (s->at(i - 1+1) = s->at(i - 2+1) & s->at(i - 1+1) = s->at(i - 3+1)) then (     ans := ans + 1 ) else skip )  ;     i := i+(n) ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static void sortString(String str){
    char[] arr=str.toCharArray();
    Arrays.sort(arr);
    System.out.print(String.valueOf(arr));
  }
  public static void main(String[] args){
    String s="geeksforgeeks" ;
    sortString(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sortString( str : String) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := str->characters() ;
     arr := arr->sort() ; 
     OclFile["System.out"].print((arr)->sum() ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     execute sortString(s) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
  static void solve(int n){
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=i+1 ;
    }
    out.println(n);
    print1DArray(arr);
    for(int t=1 ; t<n ; t++){
      int temp=arr[t];
      arr[t]=arr[t-1];
      arr[t-1]=temp ;
      print1DArray(arr);
    }
  }
  static void print1DArray(int[] arr){
    for(int i=0 ; i<arr.length ; i++){
      out.print(arr[i]);
      if(i<arr.length-1){
        out.print(' ');
      }
    }
    out.print('\n');
  }
  public static void main(String[] args){
    MyScanner scanner=new MyScanner();
    int testCount=scanner.nextInt();
    for(int testIdx=1 ; testIdx<=testCount ; testIdx++){
      int n=scanner.nextInt();
      solve(n);
    }
    out.close();
  }
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation solve( n : int) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := i + 1 )  ;     i := i + 1 ) ; 
    skip ; 
    execute print1DArray(arr) ; 
        var t : int ; t := 1 ; while t < n do ( (     var temp : int ; temp := arr[t+1] ;
     arr[t+1] := arr[t - 1+1] ; 
     arr[t - 1+1] := temp ; 
     execute print1DArray(arr) )  ;     t := t + 1 ) ; 
 );
  static   operation print1DArray( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < arr->size() do ( (     skip ; 
     if (i < arr->size() - 1) then (     skip ) else skip )  ;     i := i + 1 ) ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : MyScanner ; scanner := MyScanner.newMyScanner() ;
     var testCount : int ; testCount := scanner.nextInt() ;
         var testIdx : int ; testIdx := 1 ; while testIdx <= testCount do ( (     var n : int ; n := scanner.nextInt() ;
     execute solve(n) )  ;     testIdx := testIdx + 1 ) ; 
     skip );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float findArea(float a){
    float area ;
    area=(float)(5*Math.sqrt(3)*a*a);
    return area ;
  }
  static float findVolume(float a){
    float volume ;
    volume=(float)(((float)5/12)*(3+Math.sqrt(5))*a*a*a);
    return volume ;
  }
  public static void main(String[] args){
    float a=5 ;
    System.out.println("Area: "+findArea(a));
    System.out.println("Volume: "+findVolume(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findArea( a : double) : double
  pre: true
  post: true
  activity: (     var area : double ;
     area := (5 * (3)->sqrt() * a * a)->oclAsType(double) ; 
     return area );
  static   operation findVolume( a : double) : double
  pre: true
  post: true
  activity: (     var volume : double ;
     volume := ((5->oclAsType(double) / 12) * (3 + (5)->sqrt()) * a * a * a)->oclAsType(double) ; 
     return volume );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 5 ;
     OclFile["System.out"].println("Area: " + findArea(a)) ; 
     OclFile["System.out"].println("Volume: " + findVolume(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Solution {
  public static void main(String[] args)throws IOException {
    BufferedWriter output=new BufferedWriter(new OutputStreamWriter(System.out));
    FastReader fr=new FastReader();
    int test_cases=fr.nextInt();
    StringBuilder sb=new StringBuilder();
    for(int test=1 ; test<=test_cases ; test++){
      int n=fr.nextInt();
      sb.append(n).append("\n");
      for(int fixed=n ; fixed>0 ; fixed--){
        int number=1 ;
        for(int i=1 ; i<=n ; i++){
          if(i==fixed)sb.append(n).append(" ");
          else {
            sb.append(number).append(" ");
            number++;
          }
        }
        sb.append("\n");
      }
    }
    output.write(sb.toString());
    output.flush();
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    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 {
      if(st.hasMoreTokens()){
        str=st.nextToken("\n");
      }
      else {
        str=br.readLine();
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return str ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var output : OclFile ; output := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var fr : FastReader ; fr := FastReader.newFastReader() ;
    var test_cases : int ; test_cases := fr.nextInt() ;
    var sb : String ; sb := StringLib.newString() ;
        var test : int ; test := 1 ; while test <= test_cases do ( (     var n : int ; n := fr.nextInt() ;
     sb := sb + StringLib.newString(n) + StringLib.newString("\n") ; 
         var fixed : int ; fixed := n ; while fixed > 0 do ( (     var number : int ; number := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (     if (i = fixed) then     sb := sb + StringLib.newString(n) + StringLib.newString(" ") ; else (     sb := sb + StringLib.newString(number) + StringLib.newString(" ") ; 
     number := number + 1 ) )  ;     i := i + 1 ) ; 
     sb := sb + StringLib.newString("\n") )  ;     fixed := fixed - 1 ) )  ;     test := test + 1 ) ; 
    skip ; 
    skip ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Solution {
  static PrintWriter pw ;
  static FastScanner s ;
  static int[] a ;
  public static void main(String[] args)throws Exception {
    pw=new PrintWriter(System.out);
    s=new FastScanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      pw.println(n);
      a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=i+1 ;
      }
      for(int i=1 ; i<n ; i++){
        printArray();
        swap(i,i-1);
      }
      printArray();
    }
    pw.flush();
  }
  public static void printArray(){
    for(int i=0 ; i<a.length ; i++)pw.print(a[i]+" ");
    pw.println();
  }
  public static void swap(int i,int j){
    int temp=a[i];
    a[i]=a[j];
    a[j]=temp ;
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public FastScanner(String s)throws Exception {
    br=new BufferedReader(new FileReader(new File(s)));
  }
  public String next()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(next());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute pw : OclFile;
  static   attribute s : FastScanner;
  static   attribute a : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     pw := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     s := FastScanner.newFastScanner(OclFile["System.in"]) ; 
    var t : int ; t := s.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.nextInt() ;
     skip ; 
    a := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := i + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     execute printArray() ; 
     execute swap(i, i - 1) )  ;     i := i + 1 ) ; 
    execute printArray() ; 
 ) ;  ) ;  
    skip ; 
 );
  static   operation printArray() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < a->size() do (     skip ;  ;     i := i + 1 ) ; 
     skip );
  static   operation swap( i : int, j : int) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := a[i+1] ;
     a[i+1] := a[j+1] ; 
     a[j+1] := temp );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static Scanner inp=new Scanner(System.in);
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String args[]){
    Main g=new Main();
    g.main();
    out.close();
  }
  void main(){
    int n=inp.nextInt();
    int m=inp.nextInt();
    int q=inp.nextInt();
    int r[]=new int[n+1];
    int c[]=new int[m+1];
    HashSet<Long>set=new HashSet<>();
    while(q-->0){
      int x=inp.nextInt();
      int y=inp.nextInt();
      set.add(hash(x,y));
      r[x]++;
      c[y]++;
    }
    int maxX=0,maxY=0 ;
    for(int i=0 ; i<=n ; i++){
      maxX=Math.max(maxX,r[i]);
    }
    for(int i=0 ; i<=m ; i++){
      maxY=Math.max(maxY,c[i]);
    }
    int gg=maxX+maxY-1 ;
    ArrayList<Integer>xs=new ArrayList<>();
    ArrayList<Integer>ys=new ArrayList<>();
    for(int i=0 ; i<=n ; i++){
      if(r[i]==maxX)xs.add(i);
    }
    for(int i=0 ; i<=m ; i++){
      if(c[i]==maxY)ys.add(i);
    }
    loop : for(int x : xs){
      for(int y : ys){
        if(! set.contains(hash(x,y))){
          gg++;
          break loop ;
        }
      }
    }
    System.out.println(gg);
  }
  static long hash(int x,int y){
    return x*1000000000l+y ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute inp : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : Main ; g := Main.newMain() ;
     g.main() ; 
     skip );
   operation main() : void
  pre: true
  post: true
  activity: (     var n : int ; n := inp.getCurrent()->toInteger() ;
     var m : int ; m := inp.getCurrent()->toInteger() ;
    var q : int ; q := inp.getCurrent()->toInteger() ;
    var r : Sequence(int) ; r := Integer.subrange(1,n + 1)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,m + 1)->collect(0) ;
    var set : Set(long) ; set := Set{} ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     var x : int ; x := inp.getCurrent()->toInteger() ;
     var y : int ; y := inp.getCurrent()->toInteger() ;
    set := set->including(hash(x, y)) ; 
    r[x+1] := r[x+1] + 1 ; 
    c[y+1] := c[y+1] + 1 ; 
 ) ;  ) ;  
    var maxX : int ; maxX := 0 ;
    var maxY : int ; maxY := 0 ;
        var i : int ; i := 0 ; while i <= n do ( (     maxX := Set{maxX, r[i+1]}->max() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= m do ( (     maxY := Set{maxY, c[i+1]}->max() )  ;     i := i + 1 ) ; 
    var gg : int ; gg := maxX + maxY - 1 ;
    var xs : Sequence(int) ; xs := Sequence{} ;
    var ys : Sequence(int) ; ys := Sequence{} ;
        var i : int ; i := 0 ; while i <= n do ( (     if (r[i+1] = maxX) then     xs := xs->including(i) ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= m do ( (     if (c[i+1] = maxY) then     ys := ys->including(i) ; else skip )  ;     i := i + 1 ) ; 
    for (x : xs) do ( (     for (y : ys) do ( (     if (not(set->includes(hash(x, y)))) then (     gg := gg + 1 ; 
     break ) else skip )  ) )  ) ; 
    OclFile["System.out"].println(gg) ; 
 );
  static   operation hash( x : int, y : int) : long
  pre: true
  post: true
  activity: (     return x * 1000000000l + y );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] head=br.readLine().split(" ");
    int h=Integer.parseInt(head[0]);
    int w=Integer.parseInt(head[1]);
    int m=Integer.parseInt(head[2]);
    int[] sum_h=new int[h];
    int[] sum_w=new int[w];
    int[][] bombs=new int[m][2];
    for(int i=0 ; i<m ; i++){
      String[] line=br.readLine().split(" ");
      bombs[i][0]=Integer.parseInt(line[0])-1 ;
      bombs[i][1]=Integer.parseInt(line[1])-1 ;
      sum_h[bombs[i][0] ]++;
      sum_w[bombs[i][1] ]++;
    }
    br.close();
    int max_sum_h=0 ;
    int max_cnt_h=0 ;
    for(int i=0 ; i<h ; i++){
      if(max_sum_h<sum_h[i]){
        max_sum_h=sum_h[i];
        max_cnt_h=1 ;
      }
      else if(max_sum_h==sum_h[i]){
        max_cnt_h++;
      }
    }
    int max_sum_w=0 ;
    int max_cnt_w=0 ;
    for(int i=0 ; i<w ; i++){
      if(max_sum_w<sum_w[i]){
        max_sum_w=sum_w[i];
        max_cnt_w=1 ;
      }
      else if(max_sum_w==sum_w[i]){
        max_cnt_w++;
      }
    }
    long max_bombs_pos_nominee=(long)max_cnt_h*max_cnt_w ;
    for(int i=0 ; i<m ; i++){
      if(sum_h[bombs[i][0] ]==max_sum_h && sum_w[bombs[i][1] ]==max_sum_w){
        max_bombs_pos_nominee--;
      }
    }
    if(max_bombs_pos_nominee==0){
      System.out.println(max_sum_h+max_sum_w-1);
    }
    else {
      System.out.println(max_sum_h+max_sum_w);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var head : Sequence(String) ; head := br.readLine()->split(" ") ;
    var h : int ; h := (head[0+1])->toInteger() ;
    var w : int ; w := (head[1+1])->toInteger() ;
    var m : int ; m := (head[2+1])->toInteger() ;
    var sum_h : Sequence(int) ; sum_h := Integer.subrange(1,h)->collect(0) ;
    var sum_w : Sequence(int) ; sum_w := Integer.subrange(1,w)->collect(0) ;
    var bombs : Sequence(Sequence(int)) ; bombs := Integer.subrange(1,m)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
     bombs[i+1][0+1] := (line[0+1])->toInteger() - 1 ; 
    bombs[i+1][1+1] := (line[1+1])->toInteger() - 1 ; 
    sum_h[bombs[i+1][0+1]+1] := sum_h[bombs[i+1][0+1]+1] + 1 ; 
    sum_w[bombs[i+1][1+1]+1] := sum_w[bombs[i+1][1+1]+1] + 1 ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    var max_sum_h : int ; max_sum_h := 0 ;
    var max_cnt_h : int ; max_cnt_h := 0 ;
        var i : int ; i := 0 ; while i < h do ( (     if (max_sum_h < sum_h[i+1]) then (     max_sum_h := sum_h[i+1] ; 
     max_cnt_h := 1 ) else     if (max_sum_h = sum_h[i+1]) then (     max_cnt_h := max_cnt_h + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    var max_sum_w : int ; max_sum_w := 0 ;
    var max_cnt_w : int ; max_cnt_w := 0 ;
        var i : int ; i := 0 ; while i < w do ( (     if (max_sum_w < sum_w[i+1]) then (     max_sum_w := sum_w[i+1] ; 
     max_cnt_w := 1 ) else     if (max_sum_w = sum_w[i+1]) then (     max_cnt_w := max_cnt_w + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    var max_bombs_pos_nominee : long ; max_bombs_pos_nominee := max_cnt_h->oclAsType(long) * max_cnt_w ;
        var i : int ; i := 0 ; while i < m do ( (     if (sum_h[bombs[i+1][0+1]+1] = max_sum_h & sum_w[bombs[i+1][1+1]+1] = max_sum_w) then (     max_bombs_pos_nominee := max_bombs_pos_nominee - 1 ) else skip )  ;     i := i + 1 ) ; 
    if (max_bombs_pos_nominee = 0) then (     OclFile["System.out"].println(max_sum_h + max_sum_w - 1) ) else (     OclFile["System.out"].println(max_sum_h + max_sum_w) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    int k=scan.nextInt();
    Map<Integer,Integer>xM=new HashMap();
    Map<Integer,Integer>yM=new HashMap();
    Set<String>S=new HashSet();
    for(int i=1 ; i<=k ; i++){
      int x=scan.nextInt();
      int y=scan.nextInt();
      xM.put(x,xM.getOrDefault(x,0)+1);
      yM.put(y,yM.getOrDefault(y,0)+1);
      String st=x+"-"+y ;
      S.add(st);
    }
    int mxNum=0 ;
    for(int val : xM.values())mxNum=Math.max(mxNum,val);
    int myNum=0 ;
    for(int val : yM.values())myNum=Math.max(myNum,val);
    List<Integer>listx=new ArrayList();
    for(int key : xM.keySet()){
      if(xM.get(key)==mxNum)listx.add(key);
    }
    List<Integer>listy=new ArrayList();
    for(int key : yM.keySet()){
      if(yM.get(key)==myNum)listy.add(key);
    }
    int ans=mxNum+myNum-1 ;
    for(int i=0 ; i<listx.size(); i++){
      for(int j=0 ; j<listy.size(); j++){
        String st=listx.get(i)+"-"+listy.get(j);
        if(S.contains(st)==false){
          System.out.println(ans+1);
          return ;
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var xM : Map(int,int) ; xM := Map{} ;
    var yM : Map(int,int) ; yM := Map{} ;
    var S : Set(String) ; S := Set{} ;
        var i : int ; i := 1 ; while i <= k do ( (     var x : int ; x := scan.getCurrent()->toInteger() ;
     var y : int ; y := scan.getCurrent()->toInteger() ;
    xM := xM->union(Map{x |-> (if xM->keys()->contains(x) then xM->at(x) else 0 endif) + 1}) ; 
    yM := yM->union(Map{y |-> (if yM->keys()->contains(y) then yM->at(y) else 0 endif) + 1}) ; 
    var st : String ; st := x + "-" + y ;
    S := S->including(st) ; 
 )  ;     i := i + 1 ) ; 
    var mxNum : int ; mxNum := 0 ;
    for (val : xM->values()) do (     mxNum := Set{mxNum, val}->max() ;  ) ; 
    var myNum : int ; myNum := 0 ;
    for (val : yM->values()) do (     myNum := Set{myNum, val}->max() ;  ) ; 
    var listx : Sequence(int) ; listx := Sequence{} ;
    for (key : xM->keys()) do ( (     if (xM->at(key) = mxNum) then     listx := listx->including(key) ; else skip )  ) ; 
    var listy : Sequence(int) ; listy := Sequence{} ;
    for (key : yM->keys()) do ( (     if (yM->at(key) = myNum) then     listy := listy->including(key) ; else skip )  ) ; 
    var ans : int ; ans := mxNum + myNum - 1 ;
        var i : int ; i := 0 ; while i < listx->size() do ( (         var j : int ; j := 0 ; while j < listy->size() do ( (     var st : String ; st := listx->at(i+1) + "-" + listy->at(j+1) ;
     if (S->includes(st) = false) then (     OclFile["System.out"].println(ans + 1) ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner keyboard=new Scanner(System.in);
    int H=keyboard.nextInt();
    int W=keyboard.nextInt();
    int M=keyboard.nextInt();
    HashMap<Long,Integer>Bakuha=new HashMap<Long,Integer>();
    long MaxH=3*100000 ;
    int[] sumH=new int[H];
    int[] sumW=new int[W];
    int SH=0 ;
    int SW=0 ;
    for(int i=0 ; i<M ; i++){
      int inH=keyboard.nextInt()-1 ;
      int inW=keyboard.nextInt()-1 ;
      Bakuha.put((inH*MaxH)+inW,1);
      sumH[inH]++;
      sumW[inW]++;
      if(sumH[inH]>=SH){
        SH=sumH[inH];
      }
      if(sumW[inW]>=SW){
        SW=sumW[inW];
      }
    }
    ArrayList<Integer>SHindex=new ArrayList<Integer>();
    ArrayList<Integer>SWindex=new ArrayList<Integer>();
    for(int h=0 ; h<H ; h++){
      if(sumH[h]==SH){
        SHindex.add(h);
      }
    }
    for(int w=0 ; w<W ; w++){
      if(sumW[w]==SW){
        SWindex.add(w);
      }
    }
    int ans=SH+SW-1 ;
    if((long)SHindex.size()*SWindex.size()>M){
      ans=SH+SW ;
    }
    else {
      for(int i=0 ; i<SHindex.size(); i++){
        for(int j=0 ; j<SWindex.size(); j++){
          if(! Bakuha.containsKey(SHindex.get(i)*MaxH+SWindex.get(j))){
            ans=SH+SW ;
          }
        }
      }
    }
    System.out.print(ans);
    keyboard.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var keyboard : OclFile ; keyboard := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := keyboard.getCurrent()->toInteger() ;
    var W : int ; W := keyboard.getCurrent()->toInteger() ;
    var M : int ; M := keyboard.getCurrent()->toInteger() ;
    var Bakuha : Map(long,int) ; Bakuha := Map{} ;
    var MaxH : long ; MaxH := 3 * 100000 ;
    var sumH : Sequence(int) ; sumH := Integer.subrange(1,H)->collect(0) ;
    var sumW : Sequence(int) ; sumW := Integer.subrange(1,W)->collect(0) ;
    var SH : int ; SH := 0 ;
    var SW : int ; SW := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     var inH : int ; inH := keyboard.getCurrent()->toInteger() - 1 ;
     var inW : int ; inW := keyboard.getCurrent()->toInteger() - 1 ;
    Bakuha := Bakuha->union(Map{(inH * MaxH) + inW |-> 1}) ; 
    sumH[inH+1] := sumH[inH+1] + 1 ; 
    sumW[inW+1] := sumW[inW+1] + 1 ; 
    if (sumH[inH+1] >= SH) then (     SH := sumH[inH+1] ) else skip ; 
    if (sumW[inW+1] >= SW) then (     SW := sumW[inW+1] ) else skip ; 
 )  ;     i := i + 1 ) ; 
    var SHindex : Sequence(int) ; SHindex := Sequence{} ;
    var SWindex : Sequence(int) ; SWindex := Sequence{} ;
        var h : int ; h := 0 ; while h < H do ( (     if (sumH[h+1] = SH) then (     SHindex := SHindex->including(h) ) else skip )  ;     h := h + 1 ) ; 
        var w : int ; w := 0 ; while w < W do ( (     if (sumW[w+1] = SW) then (     SWindex := SWindex->including(w) ) else skip )  ;     w := w + 1 ) ; 
    var ans : int ; ans := SH + SW - 1 ;
    if (SHindex->size()->oclAsType(long) * SWindex->size() > M) then (     ans := SH + SW ) else (         var i : int ; i := 0 ; while i < SHindex->size() do ( (         var j : int ; j := 0 ; while j < SWindex->size() do ( (     if (not(Bakuha->keys()->includes(SHindex->at(i+1) * MaxH + SWindex->at(j+1)))) then (     ans := SH + SW ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].print(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import static java.lang.Math.PI ;
import static java.lang.Math.sqrt ;
import static java.lang.Math.acos ;
class Test {
  static int lengthSquare(Point p1,Point p2){
    int xDiff=p1.x-p2.x ;
    int yDiff=p1.y-p2.y ;
    return xDiff*xDiff+yDiff*yDiff ;
  }
  static void printAngle(Point A,Point B,Point C){
    int a2=lengthSquare(B,C);
    int b2=lengthSquare(A,C);
    int c2=lengthSquare(A,B);
    float a=(float)sqrt(a2);
    float b=(float)sqrt(b2);
    float c=(float)sqrt(c2);
    float alpha=(float)acos((b2+c2-a2)/(2*b*c));
    float betta=(float)acos((a2+c2-b2)/(2*a*c));
    float gamma=(float)acos((a2+b2-c2)/(2*a*b));
    alpha=(float)(alpha*180/PI);
    betta=(float)(betta*180/PI);
    gamma=(float)(gamma*180/PI);
    System.out.println("alpha : "+alpha);
    System.out.println("betta : "+betta);
    System.out.println("gamma : "+gamma);
  }
  public static void main(String[] args){
    Point A=new Point(0,0);
    Point B=new Point(0,1);
    Point C=new Point(1,0);
    printAngle(A,B,C);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation lengthSquare( p1 : Point, p2 : Point) : int
  pre: true
  post: true
  activity: (     var xDiff : int ; xDiff := p1.x - p2.x ;
     var yDiff : int ; yDiff := p1.y - p2.y ;
     return xDiff * xDiff + yDiff * yDiff );
  static   operation printAngle( A : Point, B : Point, C : Point) : void
  pre: true
  post: true
  activity: (     var a2 : int ; a2 := lengthSquare(B, C) ;
     var b2 : int ; b2 := lengthSquare(A, C) ;
    var c2 : int ; c2 := lengthSquare(A, B) ;
    var a : double ; a := sqrt(a2)->oclAsType(double) ;
    var b : double ; b := sqrt(b2)->oclAsType(double) ;
    var c : double ; c := sqrt(c2)->oclAsType(double) ;
    var alpha : double ; alpha := acos((b2 + c2 - a2) / (2 * b * c))->oclAsType(double) ;
    var betta : double ; betta := acos((a2 + c2 - b2) / (2 * a * c))->oclAsType(double) ;
    var gamma : double ; gamma := acos((a2 + b2 - c2) / (2 * a * b))->oclAsType(double) ;
    alpha := (alpha * 180 / PI)->oclAsType(double) ; 
    betta := (betta * 180 / PI)->oclAsType(double) ; 
    gamma := (gamma * 180 / PI)->oclAsType(double) ; 
    OclFile["System.out"].println("alpha : " + alpha) ; 
    OclFile["System.out"].println("betta : " + betta) ; 
    OclFile["System.out"].println("gamma : " + gamma) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Point ; A := Point.newPoint(0, 0) ;
     var B : Point ; B := Point.newPoint(0, 1) ;
     var C : Point ; C := Point.newPoint(1, 0) ;
     execute printAngle(A, B, C) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printNumber(int n){
    int count[]=new int[10];
    while(n>0){
      count[n % 10]++;
      n/=10 ;
    }
    for(int i=1 ; i<10 ; i++){
      for(int j=0 ; j<count[i]*i ; j++)System.out.print(i);
    }
  }
  public static void main(String[] args){
    int n=3225 ;
    printNumber(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printNumber( n : int) : void
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,10)->collect(0) ;
     while (n > 0) do (     count[n mod 10+1] := count[n mod 10+1] + 1 ; 
     n := n/(10) ) ; 
         var i : int ; i := 1 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < count[i+1] * i do (     OclFile["System.out"].print(i) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3225 ;
     execute printNumber(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getMax(int[] Arr){
    int max=Arr[0];
    for(int i=1 ; i<Arr.length ; i++)if(Arr[i]>max)max=Arr[i];
    return max ;
  }
  static int maxPrimefactorNum(int N){
    int[] arr=new int[N+1];
    for(int i=2 ; i*i<=N ; i++){
      if(arr[i]==0)for(int j=2*i ;
      j<=N ;
      j+=i)arr[j]++;
      arr[i]=1 ;
    }
    return getMax(arr);
  }
  public static void main(String[] args){
    int N=40 ;
    System.out.println(maxPrimefactorNum(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getMax( Arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var max : int ; max := Arr[0+1] ;
         var i : int ; i := 1 ; while i < Arr->size() do (     if (Arr[i+1] > max) then     max := Arr[i+1] ; else skip ;  ;     i := i + 1 ) ; 
     return max );
  static   operation maxPrimefactorNum( N : int) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,N + 1)->collect(0) ;
         var i : int ; i := 2 ; while i * i <= N do ( (     if (arr[i+1] = 0) then         var j : int ; j := 2 * i ; while j <= N do (     arr[j+1] := arr[j+1] + 1 ;  ;     j := j+(i) ) ; else skip ; 
     arr[i+1] := 1 )  ;     i := i + 1 ) ; 
     return getMax(arr) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 40 ;
     OclFile["System.out"].println(maxPrimefactorNum(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int prev=Integer.MAX_VALUE ;
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      if(x<=prev){
        count++;
      }
      prev=x ;
    }
    System.out.println(count);
    System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var prev : int ; prev := 2147483647 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x <= prev) then (     count := count + 1 ) else skip ; 
     prev := x )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    OclFile["System.out"].println(n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p205 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p205().run());
  }
  private static final int[] PYRAMIDAL_DIE_PDF={
    0,1,1,1,1 };
    private static final int[] CUBIC_DIE_PDF={
      0,1,1,1,1,1,1 };
      public String run(){
        int[] ninePyramidalPdf={
          1 };
          for(int i=0 ; i<9 ; i++)ninePyramidalPdf=convolve(ninePyramidalPdf,PYRAMIDAL_DIE_PDF);
          int[] sixCubicPdf={
            1 };
            for(int i=0 ; i<6 ; i++)sixCubicPdf=convolve(sixCubicPdf,CUBIC_DIE_PDF);
            long numer=0 ;
            for(int i=0 ; i<ninePyramidalPdf.length ; i++)numer+=(long)ninePyramidalPdf[i]*sum(sixCubicPdf,0,i);
            long denom=(long)sum(ninePyramidalPdf,0,ninePyramidalPdf.length)*sum(sixCubicPdf,0,sixCubicPdf.length);
            return String.format("%.7f",(double)numer/denom);
          }
          private static int[] convolve(int[] a,int[] b){
            int[] c=new int[a.length+b.length-1];
            for(int i=0 ; i<a.length ; i++){
              for(int j=0 ; j<b.length ; j++)c[i+j]+=a[i]*b[j];
            }
            return c ;
          }
          private static int sum(int[] array,int start,int end){
            int sum=0 ;
            for(int i=start ; i<end ; i++)sum+=array[i];
            return sum ;
          }
        }

------------------------------------------------------------
OCL File:
---------
class p205 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p205.newp205().run()) );
  static    attribute PYRAMIDAL_DIE_PDF : Sequence(int) := Sequence{0,1,1,1,1};
  static    attribute CUBIC_DIE_PDF : Sequence(int) := Sequence{0,1,1,1,1,1,1};
   operation run() : String
  pre: true
  post: true
  activity: (     var ninePyramidalPdf : Sequence(int) ; ninePyramidalPdf := Sequence{1} ;
         var i : int ; i := 0 ; while i < 9 do (     ninePyramidalPdf := convolve(ninePyramidalPdf, PYRAMIDAL_DIE_PDF) ;  ;     i := i + 1 ) ; 
    var sixCubicPdf : Sequence(int) ; sixCubicPdf := Sequence{1} ;
        var i : int ; i := 0 ; while i < 6 do (     sixCubicPdf := convolve(sixCubicPdf, CUBIC_DIE_PDF) ;  ;     i := i + 1 ) ; 
    var numer : long ; numer := 0 ;
        var i : int ; i := 0 ; while i < ninePyramidalPdf->size() do (     numer := numer+(ninePyramidalPdf[i+1]->oclAsType(long) * sum(sixCubicPdf, 0, i)) ;  ;     i := i + 1 ) ; 
    var denom : long ; denom := sum(ninePyramidalPdf, 0, ninePyramidalPdf->size())->oclAsType(long) * sum(sixCubicPdf, 0, sixCubicPdf->size()) ;
    return StringLib.format("%.7f",Sequence{numer->oclAsType(double) / denom}) 
 );
  static   operation convolve( a : Sequence(int), b : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var c : Sequence(int) ; c := Integer.subrange(1,a->size() + b->size() - 1)->collect(0) ;
         var i : int ; i := 0 ; while i < a->size() do ( (         var j : int ; j := 0 ; while j < b->size() do (     c[i + j+1] := c[i + j+1]+(a[i+1] * b[j+1]) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return c );
  static   operation sum( array : Sequence(int), start : int, end : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := start ; while i < end do (     sum := sum+(array[i+1]) ;  ;     i := i + 1 ) ; 
     return sum );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++)nums[i]=sc.nextInt();
    int ans=1 ;
    for(int i=0 ; i<n-1 ; i++){
      if(nums[i]>=nums[i+1])ans++;
    }
    System.out.println(ans);
    System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     nums[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (nums[i+1] >= nums[i + 1+1]) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    OclFile["System.out"].println(n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    for(int i=0 ; i<T ; i++){
      int size=sc.nextInt();
      int[] arr=new int[size];
      for(int j=0 ; j<size ; j++){
        arr[j]=sc.nextInt();
      }
      for(int j=size-2 ; j>=0 ; j--){
        arr[j]=Math.max(arr[j],arr[j+1]);
      }
      int ans=0 ;
      int ele=arr[size-1];
      for(int j=size-2 ; j>=0 ; j--){
        if(ele!=arr[j]){
          ele=arr[j];
          ans++;
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < T do ( (     var size : int ; size := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
        var j : int ; j := 0 ; while j < size do ( (     arr[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
        var j : int ; j := size - 2 ; while j >= 0 do ( (     arr[j+1] := Set{arr[j+1], arr[j + 1+1]}->max() )  ;     j := j - 1 ) ; 
    var ans : int ; ans := 0 ;
    var ele : int ; ele := arr[size - 1+1] ;
        var j : int ; j := size - 2 ; while j >= 0 do ( (     if (ele /= arr[j+1]) then (     ele := arr[j+1] ; 
     ans := ans + 1 ) else skip )  ;     j := j - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    sc.nextLine();
    while(t--!=0){
      int n=sc.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      int cnt=0 ;
      int max=arr[n-1];
      for(int i=n-2 ; i>=0 ; i--){
        if(arr[i]>max){
          max=arr[i];
          cnt++;
        }
      }
      System.out.println(cnt);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     skip ; 
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    var max : int ; max := arr[n - 1+1] ;
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (arr[i+1] > max) then (     max := arr[i+1] ; 
     cnt := cnt + 1 ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class MaxevenSum {
  static int maxEvenSum(int arr[],int n){
    int pos_sum=0 ;
    for(int i=0 ; i<n ; ++i)if(arr[i]>0)pos_sum+=arr[i];
    if(pos_sum % 2==0)return pos_sum ;
    int ans=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; ++i){
      if(arr[i] % 2!=0){
        if(arr[i]>0)ans=ans>(pos_sum-arr[i])? ans :(pos_sum-arr[i]);
        else ans=ans>(pos_sum+arr[i])? ans :(pos_sum+arr[i]);
      }
    }
    return ans ;
  }
  public static void main(String s[]){
    int a[]={
-2,2,-3,1 };
      System.out.println(maxEvenSum(a,a.length));
    }
  }

------------------------------------------------------------
OCL File:
---------
class MaxevenSum {
  static   operation maxEvenSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var pos_sum : int ; pos_sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     if (arr[i+1] > 0) then     pos_sum := pos_sum+(arr[i+1]) ; else skip ;  ;     i := i + 1 ) ; 
    if (pos_sum mod 2 = 0) then     return pos_sum else skip ; 
    var ans : int ; ans := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 /= 0) then (     if (arr[i+1] > 0) then     ans := if ans > (pos_sum - arr[i+1]) then ans else (pos_sum - arr[i+1]) endif ; else     ans := if ans > (pos_sum + arr[i+1]) then ans else (pos_sum + arr[i+1]) endif ; ) else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( s : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{-2,2,-3,1} ;
     OclFile["System.out"].println(maxEvenSum(a, a->size())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public TreeNode convertBST(TreeNode root){
    int sum=0 ;
    TreeNode node=root ;
    Stack<TreeNode>stack=new Stack<TreeNode>();
    while(! stack.isEmpty()|| node!=null){
      while(node!=null){
        stack.add(node);
        node=node.right ;
      }
      node=stack.pop();
      sum+=node.val ;
      node.val=sum ;
      node=node.left ;
    }
    return root ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation convertBST( root : TreeNode) : TreeNode
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var node : TreeNode ; node := root ;
    var stack : Sequence(TreeNode) ; stack := Sequence{} ;
    while (not(stack->isEmpty()) or node /= null) do (     while (node /= null) do (     stack := stack->including(node) ; 
     node := node.right ) ; 
     node := stack->last() ;     stack := stack->front() ; 
    sum := sum+(node.val) ; 
    node.val := sum ; 
    node := node.left ; 
 ) ; 
    return root 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  static FastScanner in=new FastScanner();
  static PrintWriter out=new PrintWriter(System.out);
  static HashMap<Integer,Integer>map ;
  public static void main(String[] args){
    BigInteger big=new BigInteger("0");
    char[] s=in.next().toCharArray();
    BigInteger temp=new BigInteger("2");
    for(int i=0 ; i<s.length ; i++){
      if(s[i]=='1'){
        big=big.add(temp.pow(s.length-i-1));
      }
    }
    temp=BigInteger.ONE ;
    long count=0 ;
    BigInteger four=new BigInteger("4");
    while(temp.compareTo(big)<0){
      count++;
      temp=temp.multiply(four);
    }
    out.println(count);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   attribute in : FastScanner := FastScanner.newFastScanner();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute map : Map(int,int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var big : long ; big := long("0") ;
     var s : Sequence(String) ; s := in.next()->characters() ;
    var temp : long ; temp := long("2") ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s[i+1] = '1') then (     big := big->excludes(temp.pow(s->size() - i - 1)) ) else skip )  ;     i := i + 1 ) ; 
    temp := 1 ; 
    var count : long ; count := 0 ;
    var four : long ; four := long("4") ;
    while (temp->compareTo(big) < 0) do (     count := count + 1 ; 
     temp := temp.multiply(four) ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int n=input.nextInt();
    ArrayDeque<Integer>q=new ArrayDeque<>();
    for(int i=0 ; i<n ; i++){
      int value=input.nextInt();
      if(q.contains(value)){
        q.remove(value);
        q.add(value);
      }
      else q.add(value);
    }
    System.out.println(q.size());
    while(! q.isEmpty()){
      System.out.print(q.pollFirst()+" ");
    }
    System.out.println("");
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var n : int ; n := input.nextInt() ;
    var q : Sequence(int) ; q := ArrayDeque<OclAny>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < n do ( (     var value : int ; value := input.nextInt() ;
     if (q->includes(value)) then (     q := q->excludingAt(value+1) ; 
     q := q->including(value) ) else     q := q->including(value) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(q->size()) ; 
    while (not(q->isEmpty())) do (     OclFile["System.out"].print(q->first() + " ") ) ; 
    OclFile["System.out"].println("") ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Point2D ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    for(int i=0 ; i<n ; i++){
      String[] strArray=br.readLine().split(" ");
      Point2D.Double o1=new Point2D.Double(Double.parseDouble(strArray[0]),Double.parseDouble(strArray[1]));
      double r1=Double.parseDouble(strArray[2]);
      Point2D.Double o2=new Point2D.Double(Double.parseDouble(strArray[3]),Double.parseDouble(strArray[4]));
      double r2=Double.parseDouble(strArray[5]);
      double dist=o1.distance(o2);
      int result ;
      if(dist>r1+r2){
        result=0 ;
      }
      else if(r1>=r2 && r1>dist+r2){
        result=2 ;
      }
      else if(r1<r2 && r2>dist+r1){
        result=-2 ;
      }
      else {
        result=1 ;
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var strArray : Sequence(String) ; strArray := br.readLine()->split(" ") ;
     var o1 : Double ; o1 := Double.newDouble((strArray[0+1])->toReal(), (strArray[1+1])->toReal()) ;
    var r1 : double ; r1 := (strArray[2+1])->toReal() ;
    var o2 : Double ; o2 := Double.newDouble((strArray[3+1])->toReal(), (strArray[4+1])->toReal()) ;
    var r2 : double ; r2 := (strArray[5+1])->toReal() ;
    var dist : double ; dist := o1.distance(o2) ;
    var result : int ;
    if (dist > r1 + r2) then (     result := 0 ) else     if (r1 >= r2 & r1 > dist + r2) then (     result := 2 ) else     if (r1 < r2 & r2 > dist + r1) then (     result := -2 ) else (     result := 1 ) ;  ;  ;  
    OclFile["System.out"].println(result) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printRepeatingEven(int arr[],int n){
    long _xor=0L ;
    long pos ;
    for(int i=0 ; i<n ; ++i){
      pos=1<<arr[i];
      _xor ^=pos ;
    }
    for(int i=0 ; i<n ; ++i){
      pos=1<<arr[i];
      if(!((pos & _xor)!=0)){
        System.out.print(arr[i]+" ");
        _xor ^=pos ;
      }
    }
  }
  public static void main(String args[]){
    int arr[]={
      9,12,23,10,12,12,15,23,14,12,15 };
      int n=arr.length ;
      printRepeatingEven(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printRepeatingEven( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var _xor : long ; _xor := 0L ;
     var pos : long ;
         var i : int ; i := 0 ; while i < n do ( (     pos := (1*(2->pow(arr[i+1])))->oclAsType(long) ; 
     _xor := MathLib.bitwiseXor(_xor,pos) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     pos := (1*(2->pow(arr[i+1])))->oclAsType(long) ; 
     if (not(((MathLib.bitwiseAnd(pos,_xor)) /= 0))) then (     OclFile["System.out"].print(arr[i+1] + " ") ; 
     _xor := MathLib.bitwiseXor(_xor,pos) ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{9,12,23,10,12,12,15,23,14,12,15} ;
     var n : int ; n := arr->size() ;
     execute printRepeatingEven(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean checkFibinnary(int n){
    int prev_last=0 ;
    while(n!=0){
      if((n & 1)!=0 && prev_last!=0)return false ;
      prev_last=n & 1 ;
      n>>=1 ;
    }
    return true ;
  }
  public static void main(String[] args){
    int n=10 ;
    if(checkFibinnary(n)==true)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkFibinnary( n : int) : boolean
  pre: true
  post: true
  activity: (     var prev_last : int ; prev_last := 0 ;
     while (n /= 0) do (     if ((n & 1) /= 0 & prev_last /= 0) then     return false else skip ; 
     prev_last := n & 1 ; 
     n := n/(2->pow(1)) ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     if (checkFibinnary(n) = true) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  public static void main(String args[]){
    int N=6 ;
    int Even=N/2 ;
    int Odd=N-Even ;
    System.out.println(Even*Odd);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 6 ;
     var Even : int ; Even := N / 2 ;
     var Odd : int ; Odd := N - Even ;
     OclFile["System.out"].println(Even * Odd) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt(),m=scan.nextInt();
    int[] finv=new int[n+1];
    Arrays.fill(finv,-1);
    for(int i=0 ; i<n ; i++){
      int v=scan.nextInt();
      if(finv[v]>=0)finv[v]=0 ;
      else finv[v]=i+1 ;
    }
    int[] ans=new int[m];
    String str="Possible" ;
    for(int i=0 ; i<m ; i++){
      int v=scan.nextInt();
      if(v>n || v<1 || finv[v]==-1){
        str="Impossible" ;
        break ;
      }
      if(finv[v]==0){
        str="Ambiguity" ;
      }
      else {
        ans[i]=finv[v];
      }
    }
    System.out.println(str);
    if(str.equals("Possible")){
      for(int i=0 ; i<m ; i++){
        System.out.print(ans[i]);
        System.out.print(" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var finv : Sequence(int) ; finv := Integer.subrange(1,n + 1)->collect(0) ;
    finv := finv->collect(-1) ; 
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := scan.getCurrent()->toInteger() ;
     if (finv[v+1] >= 0) then     finv[v+1] := 0 ; else     finv[v+1] := i + 1 ; )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,m)->collect(0) ;
    var str : String ; str := "Possible" ;
        var i : int ; i := 0 ; while i < m do ( (     var v : int ; v := scan.getCurrent()->toInteger() ;
     if (v > n or v < 1 or finv[v+1] = -1) then (     str := "Impossible" ; 
     break ) else skip ; 
     if (finv[v+1] = 0) then (     str := "Ambiguity" ) else (     ans[i+1] := finv[v+1] ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(str) ; 
    if (str = "Possible") then (         var i : int ; i := 0 ; while i < m do ( (     OclFile["System.out"].print(ans[i+1]) ; 
     OclFile["System.out"].print(" ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.TreeSet ;
public class test12 {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    TreeSet<Integer>check=new TreeSet();
    int n=s.nextInt();
    int m=s.nextInt();
    int[] ind=new int[1000000];
    int[] l=new int[1000000];
    int[] withindex=new int[1000000];
    boolean impossible=false ;
    boolean ambiguity=false ;
    for(int i=1 ; i<=n ; i++){
      int x=s.nextInt();
      check.add(x);
      ind[x]=i ;
      l[x]++;
    }
    for(int i=0 ; i<m ; i++){
      int x=s.nextInt();
      if(! check.contains(x))impossible=true ;
      if(l[x]>1)ambiguity=true ;
      withindex[i]=x ;
    }
    if(impossible)System.out.println("Impossible");
    else if(ambiguity)System.out.println("Ambiguity");
    else {
      System.out.println("Possible");
      for(int i=0 ; i<m ; i++){
        System.out.print(ind[withindex[i] ]+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class test12 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var check : Set(int) ; check := Set{} ;
    var n : int ; n := s.getCurrent()->toInteger() ;
    var m : int ; m := s.getCurrent()->toInteger() ;
    var ind : Sequence(int) ; ind := Integer.subrange(1,1000000)->collect(0) ;
    var l : Sequence(int) ; l := Integer.subrange(1,1000000)->collect(0) ;
    var withindex : Sequence(int) ; withindex := Integer.subrange(1,1000000)->collect(0) ;
    var impossible : boolean ; impossible := false ;
    var ambiguity : boolean ; ambiguity := false ;
        var i : int ; i := 1 ; while i <= n do ( (     var x : int ; x := s.getCurrent()->toInteger() ;
     check := check->including(x) ; 
     ind[x+1] := i ; 
     l[x+1] := l[x+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := s.getCurrent()->toInteger() ;
     if (not(check->includes(x))) then     impossible := true ; else skip ; 
     if (l[x+1] > 1) then     ambiguity := true ; else skip ; 
     withindex[i+1] := x )  ;     i := i + 1 ) ; 
    if (impossible) then     OclFile["System.out"].println("Impossible") else     if (ambiguity) then     OclFile["System.out"].println("Ambiguity") else (     OclFile["System.out"].println("Possible") ; 
         var i : int ; i := 0 ; while i < m do ( (     OclFile["System.out"].print(ind[withindex[i+1]+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    int[] f=new int[n];
    int[] b=new int[m];
    int[] a=new int[m];
    int[] c=new int[n];
    int i ;
    int j=0 ;
    for(i=0 ; i<n ; i++){
      f[i]=scanner.nextInt();
      if(c[f[i]-1]!=0){
        c[f[i]-1]=-1 ;
      }
      else {
        c[f[i]-1]=i+1 ;
      }
    }
    for(i=0 ; i<m ; i++){
      b[i]=scanner.nextInt();
      if(c[b[i]-1]==0){
        System.out.println("Impossible");
        return ;
      }
      else {
        a[i]=c[b[i]-1];
      }
      if(a[i]==-1){
        j++;
      }
    }
    if(j==0){
      System.out.println("Possible");
      for(i=0 ; i<m ; i++){
        System.out.printf(a[i]+" ");
      }
    }
    else {
      System.out.println("Ambiguity");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var f : Sequence(int) ; f := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    var i : int ;
    var j : int ; j := 0 ;
        i := 0 ; while i < n do ( (     f[i+1] := scanner.getCurrent()->toInteger() ; 
     if (c[f[i+1] - 1+1] /= 0) then (     c[f[i+1] - 1+1] := -1 ) else (     c[f[i+1] - 1+1] := i + 1 ) )  ;     i := i + 1 ) ; 
        i := 0 ; while i < m do ( (     b[i+1] := scanner.getCurrent()->toInteger() ; 
     if (c[b[i+1] - 1+1] = 0) then (     OclFile["System.out"].println("Impossible") ; 
     return ) else (     a[i+1] := c[b[i+1] - 1+1] ) ;  
     if (a[i+1] = -1) then (     j := j + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (j = 0) then (     OclFile["System.out"].println("Possible") ; 
         i := 0 ; while i < m do ( (     OclFile["System.out"].printf(a[i+1] + " ") )  ;     i := i + 1 ) ) else (     OclFile["System.out"].println("Ambiguity") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printDistinct(int arr[],int n){
    for(int i=0 ; i<n ; i++){
      int j ;
      for(j=0 ; j<i ; j++)if(arr[i]==arr[j])break ;
      if(i==j)System.out.print(arr[i]+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      6,10,5,4,9,120,4,6,10 };
      int n=arr.length ;
      printDistinct(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printDistinct( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var j : int ;
         j := 0 ; while j < i do (     if (arr[i+1] = arr[j+1]) then     break else skip ;  ;     j := j + 1 ) ; 
     if (i = j) then     OclFile["System.out"].print(arr[i+1] + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,10,5,4,9,120,4,6,10} ;
     var n : int ; n := arr->size() ;
     execute printDistinct(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
class GFG {
  public static int breakEvenPoint(int exp1,int S,int M){
    double earn=S-M ;
    double exp=exp1 ;
    double res=Math.ceil(exp/earn);
    int res1=(int)res ;
    return res1 ;
  }
  public static void main(String[] args){
    int exp=3550,S=90,M=65 ;
    System.out.println(breakEvenPoint(exp,S,M));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation breakEvenPoint( exp1 : int, S : int, M : int) : int
  pre: true
  post: true
  activity: (     var earn : double ; earn := S - M ;
     var exp : double ; exp := exp1 ;
    var res : double ; res := (exp / earn)->ceil() ;
    var res1 : int ; res1 := res->oclAsType(int) ;
    return res1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var exp : int ; exp := 3550 ;
    var S : int ; S := 90 ;
    var M : int ; M := 65 ;
     OclFile["System.out"].println(breakEvenPoint(exp, S, M)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class B451 {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] temp=br.readLine().split(" ");
    int n=Integer.parseInt(temp[0]);
    int[] arr=new int[n];
    temp=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(temp[i]);
    }
    int i=1,left=-1,right=-1,min=Integer.MIN_VALUE ;
    boolean found=false,printedNO=false ;
    while(i<arr.length){
      if(min>arr[i]){
        System.out.println("no");
        printedNO=true ;
        break ;
      }
      if(arr[i]<arr[i-1]){
        if(found){
          System.out.println("no");
          printedNO=true ;
          break ;
        }
        else {
          found=true ;
          left=i-1 ;
          right=i ;
          min=arr[i-1];
          while(left>0 && arr[left]==arr[left-1]){
            left--;
          }
          while(right<arr.length && arr[right]<=arr[right-1]){
            right++;
          }
          right--;
          if(left>0 && arr[right]<arr[left-1]){
            System.out.println("no");
            printedNO=true ;
            break ;
          }
          i=right ;
        }
      }
      i++;
    }
    if(left==-1){
      left=0 ;
      right=0 ;
    }
    if(! printedNO){
      System.out.println("yes");
      System.out.println((left+1)+" "+(right+1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B451 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
    var n : int ; n := (temp[0+1])->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    temp := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (temp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var i : int ; i := 1 ;
    var left : int ; left := -1 ;
    var right : int ; right := -1 ;
    var min : int ; min := -2147483648 ;
    var found : boolean ; found := false ;
    var printedNO : boolean ; printedNO := false ;
    while (i < arr->size()) do (     if (min > arr[i+1]) then (     OclFile["System.out"].println("no") ; 
     printedNO := true ; 
     break ) else skip ; 
     if (arr[i+1] < arr[i - 1+1]) then (     if (found) then (     OclFile["System.out"].println("no") ; 
     printedNO := true ; 
     break ) else (     found := true ; 
     left := i - 1 ; 
    right := i ; 
    min := arr[i - 1+1] ; 
    while (left > 0 & arr[left+1] = arr[left - 1+1]) do (     left := left - 1 ) ; 
    while (right < arr->size() & arr[right+1] <= arr[right - 1+1]) do (     right := right + 1 ) ; 
    right := right - 1 ; 
    if (left > 0 & arr[right+1] < arr[left - 1+1]) then (     OclFile["System.out"].println("no") ; 
     printedNO := true ; 
     break ) else skip ; 
    i := right ; 
 ) ) else skip ; 
     i := i + 1 ) ; 
    if (left = -1) then (     left := 0 ; 
     right := 0 ) else skip ; 
    if (not(printedNO)) then (     OclFile["System.out"].println("yes") ; 
     OclFile["System.out"].println((left + 1) + " " + (right + 1)) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class B451 {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] temp=br.readLine().split(" ");
    int n=Integer.parseInt(temp[0]);
    int[] arr=new int[n];
    temp=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(temp[i]);
    }
    int i=0,left=-1,right=-1,min=Integer.MIN_VALUE ;
    boolean found=false,printedNO=false ;
    while(i<arr.length-1){
      if(min>arr[i]){
        System.out.println("no");
        printedNO=true ;
        break ;
      }
      if(arr[i+1]<arr[i]){
        if(found){
          System.out.println("no");
          printedNO=true ;
          break ;
        }
        else {
          found=true ;
          left=i ;
          right=i ;
          min=arr[i];
          while(left>0 && arr[left]==arr[left-1]){
            left--;
          }
          while(right<arr.length-1 && arr[right]>=arr[right+1]){
            right++;
          }
          if(right<arr.length-1 && arr[right+1]<min){
            System.out.println("no");
            printedNO=true ;
            break ;
          }
          if(left>0 && arr[right]<arr[left-1]){
            System.out.println("no");
            printedNO=true ;
            break ;
          }
          i=right ;
        }
      }
      i++;
    }
    if(left==-1){
      left=0 ;
      right=0 ;
    }
    if(! printedNO){
      System.out.println("yes");
      System.out.println((left+1)+" "+(right+1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B451 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
    var n : int ; n := (temp[0+1])->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    temp := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (temp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var i : int ; i := 0 ;
    var left : int ; left := -1 ;
    var right : int ; right := -1 ;
    var min : int ; min := -2147483648 ;
    var found : boolean ; found := false ;
    var printedNO : boolean ; printedNO := false ;
    while (i < arr->size() - 1) do (     if (min > arr[i+1]) then (     OclFile["System.out"].println("no") ; 
     printedNO := true ; 
     break ) else skip ; 
     if (arr[i + 1+1] < arr[i+1]) then (     if (found) then (     OclFile["System.out"].println("no") ; 
     printedNO := true ; 
     break ) else (     found := true ; 
     left := i ; 
    right := i ; 
    min := arr[i+1] ; 
    while (left > 0 & arr[left+1] = arr[left - 1+1]) do (     left := left - 1 ) ; 
    while (right < arr->size() - 1 & arr[right+1] >= arr[right + 1+1]) do (     right := right + 1 ) ; 
    if (right < arr->size() - 1 & arr[right + 1+1] < min) then (     OclFile["System.out"].println("no") ; 
     printedNO := true ; 
     break ) else skip ; 
    if (left > 0 & arr[right+1] < arr[left - 1+1]) then (     OclFile["System.out"].println("no") ; 
     printedNO := true ; 
     break ) else skip ; 
    i := right ; 
 ) ) else skip ; 
     i := i + 1 ) ; 
    if (left = -1) then (     left := 0 ; 
     right := 0 ) else skip ; 
    if (not(printedNO)) then (     OclFile["System.out"].println("yes") ; 
     OclFile["System.out"].println((left + 1) + " " + (right + 1)) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.Integer.parseInt ;
public class c {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder out=new StringBuilder();
    StringTokenizer tk ;
    int n=parseInt(in.readLine());
    int[] a=new int[n];
    int[] b=new int[n];
    tk=new StringTokenizer(in.readLine());
    for(int i=0 ; i<n ; i++){
      a[i]=parseInt(tk.nextToken());
      b[i]=a[i];
    }
    Arrays.sort(b);
    int l=-1,r=-1 ;
    for(int i=0 ; i<n ; i++)if(a[i]!=b[i]){
      l=i ;
      break ;
    }
    for(int i=n-1 ; i>=0 ; i--)if(a[i]!=b[i]){
      r=i ;
      break ;
    }
    if(l==-1){
      System.out.println("yes\n1 1");
      return ;
    }
    reverse(a,l,r);
    for(int i=0 ; i<n ; i++){
      if(a[i]!=b[i]){
        System.out.println("no");
        return ;
      }
    }
    System.out.println("yes");
    System.out.println((l+1)+" "+(r+1));
  }
  static void reverse(int[] a,int l,int r){
    int[] t=new int[a.length];
    for(int i=l,j=r ; i<=r ; i++,j--){
      t[i]=a[j];
    }
    for(int i=l ; i<=r ; i++)a[i]=t[i];
  }
}
------------------------------------------------------------
OCL File:
---------
 class c {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : String ; out := StringLib.newString() ;
    var tk : OclIterator ;
    var n : int ; n := parseInt(in.readLine()) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    tk := OclIterator.newOclIterator_String(in.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (tk.next() + "")->toInteger() ; 
     b[i+1] := a[i+1] )  ;     i := i + 1 ) ; 
    b := b->sort() ; 
    var l : int ; l := -1 ;
    var r : int ; r := -1 ;
        var i : int ; i := 0 ; while i < n do (     if (a[i+1] /= b[i+1]) then (     l := i ; 
     break ) else skip ;  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do (     if (a[i+1] /= b[i+1]) then (     r := i ; 
     break ) else skip ;  ;     i := i - 1 ) ; 
    if (l = -1) then (     OclFile["System.out"].println("yes\n1 1") ; 
     return ) else skip ; 
    execute reverse(a, l, r) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] /= b[i+1]) then (     OclFile["System.out"].println("no") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("yes") ; 
    OclFile["System.out"].println((l + 1) + " " + (r + 1)) ; 
 );
  static   operation reverse( a : Sequence(int), l : int, r : int) : void
  pre: true
  post: true
  activity: (     var t : Sequence(int) ; t := Integer.subrange(1,a->size())->collect(0) ;
         var i : int ; i := l ;
    var j : int ; j := r ; while i <= r do ( (     t[i+1] := a[j+1] )  ;     i := i + 1 ;     j := j - 1 ) ; 
         var i : int ; i := l ; while i <= r do (     a[i+1] := t[i+1] ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p133 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p133().run());
  }
  public String run(){
    long sum=0 ;
    for(int p : Library.listPrimes(100000)){
      if(p==2 || p==5 || ! hasDivisibleRepunit(p))sum+=p ;
    }
    return Long.toString(sum);
  }
  private static final BigInteger EXPONENT=BigInteger.TEN.pow(16);
  private static boolean hasDivisibleRepunit(int p){
    return(BigInteger.TEN.modPow(EXPONENT,BigInteger.valueOf(p*9)).intValue()-1)/9 % p==0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class p133 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p133.newp133().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     for (p : Library.listPrimes(100000)) do ( (     if (p = 2 or p = 5 or not(hasDivisibleRepunit(p))) then     sum := sum+(p) ; else skip )  ) ; 
     return ((sum) + "") );
  static    attribute EXPONENT : long := 10.pow(16);
  static   operation hasDivisibleRepunit( p : int) : boolean
  pre: true
  post: true
  activity: (     return (10.modPow(EXPONENT, (p * 9 + "")->toLong())->oclAsType(int) - 1) / 9 mod p = 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class sort_check1 {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String inp[];
    int n=Integer.parseInt(in.readLine());
    int a[]=new int[n];
    inp=in.readLine().split(" ");
    for(int i=0 ; i<n ; i++)a[i]=Integer.parseInt(inp[i]);
    int ind=0,in2=0 ;
    boolean f1=true,f2=true ;
    for(int i=1 ; i<n ; i++){
      if(a[i]<a[i-1]){
        if(f2){
          f2=false ;
          ind=i-1 ;
          while(i<n && a[i]<a[i-1])i++;
          if((i<n && a[ind]>a[i])||(ind>0 && a[ind-1]>a[i-1]))f1=false ;
          else in2=i-1 ;
          i--;
        }
        else f1=false ;
      }
    }
    if(f1){
      System.out.println("yes");
      System.out.println(ind+1+" "+(in2+1));
    }
    else System.out.println("no");
  }
}
------------------------------------------------------------
OCL File:
---------
 class sort_check1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var inp : Sequence(String) ;
    var n : int ; n := (in.readLine())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    inp := in.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (inp[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var ind : int ; ind := 0 ;
    var in2 : int ; in2 := 0 ;
    var f1 : boolean ; f1 := true ;
    var f2 : boolean ; f2 := true ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] < a[i - 1+1]) then (     if (f2) then (     f2 := false ; 
     ind := i - 1 ; 
    while (i < n & a[i+1] < a[i - 1+1]) do     i := i + 1 ; ; 
    if ((i < n & a[ind+1] > a[i+1]) or (ind > 0 & a[ind - 1+1] > a[i - 1+1])) then     f1 := false else     in2 := i - 1 ; ;  
    i := i - 1 ; 
 ) else     f1 := false ; ) else skip )  ;     i := i + 1 ) ; 
    if (f1) then (     OclFile["System.out"].println("yes") ; 
     OclFile["System.out"].println(ind + 1 + " " + (in2 + 1)) ) else     OclFile["System.out"].println("no") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int solve(int M,int N,int s){
    if(N % s==0){
      N=N/s ;
    }
    else {
      N=(N/s)+1 ;
    }
    if(M % s==0){
      M=M/s ;
    }
    else {
      M=(M/s)+1 ;
    }
    return M*N ;
  }
  public static void main(String args[]){
    int N=12,M=13,s=4 ;
    System.out.println(solve(M,N,s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( M : int, N : int, s : int) : int
  pre: true
  post: true
  activity: (     if (N mod s = 0) then (     N := N / s ) else (     N := (N / s) + 1 ) ;  
     if (M mod s = 0) then (     M := M / s ) else (     M := (M / s) + 1 ) ;  
     return M * N );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 12 ;
    var M : int ; M := 13 ;
    var s : int ; s := 4 ;
     OclFile["System.out"].println(solve(M, N, s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int __gcd(int a,int b){
    if(a==0 || b==0)return 0 ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static int lcm(int a,int b){
    return(a*b)/__gcd(a,b);
  }
  static void printArray(int a[],int n){
    System.out.print(a[0]+" ");
    for(int i=0 ; i<n-1 ; i++)System.out.print(lcm(a[i],a[i+1])+" ");
    System.out.print(a[n-1]);
  }
  public static void main(String[] args){
    int a[]={
      1,2,3 };
      int n=a.length ;
      printArray(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0 or b = 0) then     return 0 else skip ; 
     if (a = b) then     return a else skip ; 
     if (a > b) then     return __gcd(a - b, b) else skip ; 
     return __gcd(a, b - a) );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return (a * b) / __gcd(a, b) );
  static   operation printArray( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(a[0+1] + " ") ; 
         var i : int ; i := 0 ; while i < n - 1 do (     OclFile["System.out"].print(lcm(a[i+1], a[i + 1+1]) + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(a[n - 1+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3} ;
     var n : int ; n := a->size() ;
     execute printArray(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPowerful(int n){
    while(n % 2==0){
      int power=0 ;
      while(n % 2==0){
        n/=2 ;
        power++;
      }
      if(power==1)return false ;
    }
    for(int factor=3 ; factor<=Math.sqrt(n); factor+=2){
      int power=0 ;
      while(n % factor==0){
        n=n/factor ;
        power++;
      }
      if(power==1)return false ;
    }
    return(n==1);
  }
  public static void main(String[] args){
    if(isPowerful(20))System.out.print("YES\n");
    else System.out.print("NO\n");
    if(isPowerful(27))System.out.print("YES\n");
    else System.out.print("NO\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPowerful( n : int) : boolean
  pre: true
  post: true
  activity: (     while (n mod 2 = 0) do (     var power : int ; power := 0 ;
     while (n mod 2 = 0) do (     n := n/(2) ; 
     power := power + 1 ) ; 
     if (power = 1) then     return false else skip ) ; 
         var factor : int ; factor := 3 ; while factor <= (n)->sqrt() do ( (     var power : int ; power := 0 ;
     while (n mod factor = 0) do (     n := n / factor ; 
     power := power + 1 ) ; 
     if (power = 1) then     return false else skip )  ;     factor := factor+(2) ) ; 
     return (n = 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (isPowerful(20)) then     OclFile["System.out"].print("YES\n") else     OclFile["System.out"].print("NO\n") ; ;  
     if (isPowerful(27)) then     OclFile["System.out"].print("YES\n") ; else     OclFile["System.out"].print("NO\n") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  private static final char[] MODES={
    'L','D','U','R' };
    public static void main(String[] args){
      try(Scanner scanner=new Scanner(System.in)){
        int n=scanner.nextInt();
        int[] u=new int[n],v=new int[n];
        IntStream.range(0,n).forEach(i->{
          int x=scanner.nextInt(),y=scanner.nextInt();
          u[i]=x+y ;
          v[i]=x-y ;
        }
);
        int r=u[0] & 1 ;
        for(int i=1 ; i<n ; i++){
          if(r!=(u[i] & 1)){
            System.out.println("-1");
            return ;
          }
        }
        r=1-r ;
        int m=31 ;
        System.out.println(m+r);
        StringBuilder answer=new StringBuilder();
        if(r>0){
          answer.append("1").append(" ");
        }
        IntStream.range(0,m).forEach(i->answer.append(1<<i).append(" "));
        answer.deleteCharAt(answer.length()-1);
        System.out.println(answer.toString());
        long base=(1L<<m)-1-r ;
        for(int i=0 ; i<n ; i++){
          StringBuilder sb=new StringBuilder();
          if(r>0){
            sb.append('R');
          }
          long uBase=(u[i]+base)>>1,vBase=(v[i]+base)>>1 ;
          for(int j=0 ; j<m ; j++){
            int u1=(int)(uBase & 1L)<<1 ;
            int v1=(int)(vBase & 1L);
            sb.append(MODES[u1+v1]);
            uBase>>=1 ;
            vBase>>=1 ;
          }
          System.out.println(sb.toString());
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MODES : Sequence(String) := Sequence{'L','D','U','R'};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var u : Sequence(int) ; u := Integer.subrange(1,n)->collect(0) ;
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
    for i : Integer.subrange(0, n-1) do
    (    skip) ; 
    var r : int ; r := MathLib.bitwiseAnd(u[0+1],1) ;
        var i : int ; i := 1 ; while i < n do ( (     if (r /= (u[i+1] & 1)) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    r := 1 - r ; 
    var m : int ; m := 31 ;
    OclFile["System.out"].println(m + r) ; 
    var answer : String ; answer := StringLib.newString() ;
    if (r > 0) then (     answer := answer + StringLib.newString("1") + StringLib.newString(" ") ) else skip ; 
    for i : Integer.subrange(0, m-1) do
    (    answer := answer + StringLib.newString((1*(2->pow(i)))->oclAsType(long)) + StringLib.newString(" ")) ; 
    answer := answer->excludingAt(answer->size() - 1+1) ; 
    OclFile["System.out"].println(answer+"") ; 
    var base : long ; base := ((1L*(2->pow(m)))->oclAsType(long)) - 1 - r ;
        var i : int ; i := 0 ; while i < n do ( (     var sb : String ; sb := StringLib.newString() ;
     if (r > 0) then (     sb := sb + StringLib.newString('R') ) else skip ; 
    var uBase : long ; uBase := ((u[i+1] + base)/(2->pow(1)))->oclAsType(long) ;
    var vBase : long ; vBase := ((v[i+1] + base)/(2->pow(1)))->oclAsType(long) ;
        var j : int ; j := 0 ; while j < m do ( (     var u1 : int ; u1 := ((MathLib.bitwiseAnd(uBase,1L))->oclAsType(int)*(2->pow(1)))->oclAsType(long) ;
     var v1 : int ; v1 := (MathLib.bitwiseAnd(vBase,1L))->oclAsType(int) ;
    sb := sb + StringLib.newString(MODES[u1 + v1+1]) ; 
    uBase := uBase/(2->pow(1)) ; 
    vBase := vBase/(2->pow(1)) ; 
 )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  private static final char[] MODES={
    'L','D','U','R' };
    public static void main(String[] args){
      try(Scanner scanner=new Scanner(System.in)){
        int n=scanner.nextInt();
        int[] u=new int[n],v=new int[n];
        IntStream.range(0,n).forEach(i->{
          int x=scanner.nextInt(),y=scanner.nextInt();
          u[i]=x+y ;
          v[i]=x-y ;
        }
);
        int r=u[0] & 1 ;
        for(int i=1 ; i<n ; i++){
          if(r!=(u[i] & 1)){
            System.out.println("-1");
            return ;
          }
        }
        r=1-r ;
        int m=31 ;
        System.out.println(m+r);
        StringBuilder answer=new StringBuilder();
        if(r>0){
          answer.append("1").append(" ");
        }
        IntStream.range(0,m).forEach(i->answer.append(1<<i).append(" "));
        answer.deleteCharAt(answer.length()-1);
        System.out.println(answer.toString());
        long base=(1L<<m)-1-r ;
        for(int i=0 ; i<n ; i++){
          StringBuilder sb=new StringBuilder();
          if(r>0){
            sb.append('R');
          }
          long uBase=(u[i]+base)>>1,vBase=(v[i]+base)>>1 ;
          for(int j=0 ; j<m ; j++){
            int u1=(int)(uBase & 1L)<<1 ;
            int v1=(int)(vBase & 1L);
            sb.append(MODES[u1+v1]);
            uBase>>=1 ;
            vBase>>=1 ;
          }
          System.out.println(sb.toString());
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MODES : Sequence(String) := Sequence{'L','D','U','R'};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var u : Sequence(int) ; u := Integer.subrange(1,n)->collect(0) ;
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
    for i : Integer.subrange(0, n-1) do
    (    skip) ; 
    var r : int ; r := MathLib.bitwiseAnd(u[0+1],1) ;
        var i : int ; i := 1 ; while i < n do ( (     if (r /= (u[i+1] & 1)) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    r := 1 - r ; 
    var m : int ; m := 31 ;
    OclFile["System.out"].println(m + r) ; 
    var answer : String ; answer := StringLib.newString() ;
    if (r > 0) then (     answer := answer + StringLib.newString("1") + StringLib.newString(" ") ) else skip ; 
    for i : Integer.subrange(0, m-1) do
    (    answer := answer + StringLib.newString((1*(2->pow(i)))->oclAsType(long)) + StringLib.newString(" ")) ; 
    answer := answer->excludingAt(answer->size() - 1+1) ; 
    OclFile["System.out"].println(answer+"") ; 
    var base : long ; base := ((1L*(2->pow(m)))->oclAsType(long)) - 1 - r ;
        var i : int ; i := 0 ; while i < n do ( (     var sb : String ; sb := StringLib.newString() ;
     if (r > 0) then (     sb := sb + StringLib.newString('R') ) else skip ; 
    var uBase : long ; uBase := ((u[i+1] + base)/(2->pow(1)))->oclAsType(long) ;
    var vBase : long ; vBase := ((v[i+1] + base)/(2->pow(1)))->oclAsType(long) ;
        var j : int ; j := 0 ; while j < m do ( (     var u1 : int ; u1 := ((MathLib.bitwiseAnd(uBase,1L))->oclAsType(int)*(2->pow(1)))->oclAsType(long) ;
     var v1 : int ; v1 := (MathLib.bitwiseAnd(vBase,1L))->oclAsType(int) ;
    sb := sb + StringLib.newString(MODES[u1 + v1+1]) ; 
    uBase := uBase/(2->pow(1)) ; 
    vBase := vBase/(2->pow(1)) ; 
 )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int rightmostNonZero(int a[],int n){
    int c5=0 ;
    for(int i=0 ; i<n ; i++){
      while(a[i]>0 && a[i] % 5==0){
        a[i]/=5 ;
        c5++;
      }
    }
    for(int i=0 ; i<n ; i++){
      while(c5!=0 && a[i]>0 &&(a[i] & 1)==0){
        a[i]>>=1 ;
        c5--;
      }
    }
    int ans=1 ;
    for(int i=0 ; i<n ; i++){
      ans=(ans*a[i] % 10)% 10 ;
    }
    if(c5!=0)ans=(ans*5)% 10 ;
    if(ans!=0)return ans ;
    return-1 ;
  }
  public static void main(String args[]){
    int a[]={
      7,42,11,64 };
      int n=a.length ;
      System.out.println(rightmostNonZero(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation rightmostNonZero( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var c5 : int ; c5 := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     while (a[i+1] > 0 & a[i+1] mod 5 = 0) do (     a[i+1] := a[i+1]/(5) ; 
     c5 := c5 + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     while (c5 /= 0 & a[i+1] > 0 & (a[i+1] & 1) = 0) do (     a[i+1] := a[i+1]/(2->pow(1)) ; 
     c5 := c5 - 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     ans := (ans * a[i+1] mod 10) mod 10 )  ;     i := i + 1 ) ; 
    if (c5 /= 0) then     ans := (ans * 5) mod 10 ; else skip ; 
    if (ans /= 0) then     return ans else skip ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{7,42,11,64} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(rightmostNonZero(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Mridul6 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    int i=-1 ;
    while(i!=n-1){
      i=i+1 ;
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr);
    int u=0 ;
    int v=1 ;
    int z=2 ;
    while(z<=n-1){
      if(arr[u]+arr[v]>arr[z] && arr[u]+arr[z]>arr[v] && arr[v]+arr[z]>arr[u]){
        System.out.println("YES");
        break ;
      }
      else {
        u=u+1 ;
        v=v+1 ;
        z=z+1 ;
      }
    }
    if(z==n){
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mridul6 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var i : int ; i := -1 ;
    while (i /= n - 1) do (     i := i + 1 ; 
     arr[i+1] := sc.getCurrent()->toInteger() ) ; 
    arr := arr->sort() ; 
    var u : int ; u := 0 ;
    var v : int ; v := 1 ;
    var z : int ; z := 2 ;
    while (z <= n - 1) do (     if (arr[u+1] + arr[v+1] > arr[z+1] & arr[u+1] + arr[z+1] > arr[v+1] & arr[v+1] + arr[z+1] > arr[u+1]) then (     OclFile["System.out"].println("YES") ; 
     break ) else (     u := u + 1 ; 
     v := v + 1 ; 
     z := z + 1 ) ) ; 
    if (z = n) then (     OclFile["System.out"].println("NO") ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    Arrays.sort(a);
    int h=0 ;
    for(int i=n ; i>=3 ; i--){
      if(a[i-1]+a[i-2]>a[i-3] && a[i-1]+a[i-3]>a[i-2] && a[i-3]+a[i-2]>a[i-1]){
        h++;
        break ;
      }
    }
    if(h==1){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var h : int ; h := 0 ;
        var i : int ; i := n ; while i >= 3 do ( (     if (a[i - 1+1] + a[i - 2+1] > a[i - 3+1] & a[i - 1+1] + a[i - 3+1] > a[i - 2+1] & a[i - 3+1] + a[i - 2+1] > a[i - 1+1]) then (     h := h + 1 ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    if (h = 1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int tc=scanner.nextInt();
    int a[]=new int[tc];
    for(int i=0 ; i<tc ; i++){
      a[i]=scanner.nextInt();
    }
    Arrays.sort(a);
    int c=0 ;
    for(int i=0 ; i<tc ; i++){
      while(i<(tc-2)){
        if(a[i]+a[i+1]>a[i+2]){
          c++;
        }
        i++;
      }
    }
    if(c>0){
      System.out.println("YES");
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,tc)->collect(0) ;
        var i : int ; i := 0 ; while i < tc do ( (     a[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < tc do ( (     while (i < (tc - 2)) do (     if (a[i+1] + a[i + 1+1] > a[i + 2+1]) then (     c := c + 1 ) else skip ; 
     i := i + 1 ) )  ;     i := i + 1 ) ; 
    if (c > 0) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long arr[]=new long[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextLong();
    Arrays.sort(arr);
    int a=0 ;
    int b=1 ;
    int c=2 ;
    while(c<n){
      if(arr[a]+arr[b]>arr[c] && arr[a]+arr[c]>arr[b] && arr[a]+arr[c]>arr[b]){
        System.out.print("YES");
        System.exit(0);
      }
      else {
        a++;
        b++;
        c++;
      }
    }
    System.out.print("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var a : int ; a := 0 ;
    var b : int ; b := 1 ;
    var c : int ; c := 2 ;
    while (c < n) do (     if (arr[a+1] + arr[b+1] > arr[c+1] & arr[a+1] + arr[c+1] > arr[b+1] & arr[a+1] + arr[c+1] > arr[b+1]) then (     OclFile["System.out"].print("YES") ; 
 OclProcess.exit(0) ) else (     a := a + 1 ; 
     b := b + 1 ; 
     c := c + 1 ) ) ; 
    OclFile["System.out"].print("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p206 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p206().run());
  }
  public String run(){
    long n=1000000000 ;
    int[] ndigits=new int[10];
    int[] n2digits=new int[19];
    long temp=n ;
    for(int i=0 ; i<ndigits.length ; i++,temp/=10)ndigits[i]=(int)(temp % 10);
    temp=n*n ;
    for(int i=0 ; i<n2digits.length ; i++,temp/=10)n2digits[i]=(int)(temp % 10);
    while(! isConcealedSquare(n2digits)){
      add20n(ndigits,n2digits);
      add10Pow(n2digits,2);
      n+=10 ;
      add10Pow(ndigits,1);
    }
    return Long.toString(n);
  }
  private static boolean isConcealedSquare(int[] n){
    for(int i=1 ; i<=9 ; i++){
      if(n[20-i*2]!=i)return false ;
    }
    return n[0]==0 ;
  }
  private static void add10Pow(int[] n,int i){
    while(n[i]==9){
      n[i]=0 ;
      i++;
    }
    n[i]++;
  }
  private static void add20n(int[] n,int[] n2){
    int carry=0 ;
    int i ;
    for(i=0 ; i<n.length ; i++){
      int sum=n[i]*2+n2[i+1]+carry ;
      n2[i+1]=sum % 10 ;
      carry=sum/10 ;
    }
    for(i++; carry>0 ; i++){
      int sum=n2[i]+carry ;
      n2[i]=sum % 10 ;
      carry=sum/10 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class p206 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p206.newp206().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var n : long ; n := 1000000000 ;
     var ndigits : Sequence(int) ; ndigits := Integer.subrange(1,10)->collect(0) ;
    var n2digits : Sequence(int) ; n2digits := Integer.subrange(1,19)->collect(0) ;
    var temp : long ; temp := n ;
        var i : int ; i := 0 ; while i < ndigits->size() do (     ndigits[i+1] := (temp mod 10)->oclAsType(int) ;  ;     i := i + 1 ;     temp := temp/(10) ) ; 
    temp := n * n ; 
        var i : int ; i := 0 ; while i < n2digits->size() do (     n2digits[i+1] := (temp mod 10)->oclAsType(int) ;  ;     i := i + 1 ;     temp := temp/(10) ) ; 
    while (not(isConcealedSquare(n2digits))) do (     execute add20n(ndigits, n2digits) ; 
     execute add10Pow(n2digits, 2) ; 
     n := n+(10) ; 
     execute add10Pow(ndigits, 1) ) ; 
    return ((n) + "") 
 );
  static   operation isConcealedSquare( n : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= 9 do ( (     if (n[20 - i * 2+1] /= i) then     return false else skip )  ;     i := i + 1 ) ; 
     return n[0+1] = 0 );
  static   operation add10Pow( n : Sequence(int), i : int) : void
  pre: true
  post: true
  activity: (     while (n[i+1] = 9) do (     n[i+1] := 0 ; 
     i := i + 1 ) ; 
     n[i+1] := n[i+1] + 1 );
  static   operation add20n( n : Sequence(int), n2 : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var carry : int ; carry := 0 ;
     var i : int ;
         i := 0 ; while i < n->size() do ( (     var sum : int ; sum := n[i+1] * 2 + n2[i + 1+1] + carry ;
     n2[i + 1+1] := sum mod 10 ; 
     carry := sum / 10 )  ;     i := i + 1 ) ; 
         i := i + 1 ; while carry > 0 do ( (     var sum : int ; sum := n2[i+1] + carry ;
     n2[i+1] := sum mod 10 ; 
     carry := sum / 10 )  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in).useDelimiter("[,\n] ");
    int sum=0 ;
    int n=0 ;
    int total=0 ;
    while(true){
      try {
        int value=sc.nextInt();
        int amount=sc.nextInt();
        sum+=value*amount ;
        total+=amount ;
        n++;
      }
      catch(Exception e){
        break ;
      }
    }
    System.out.println(sum);
    System.out.println(Math.round((double)total/n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]).useDelimiter("[,\n] ") ;
     var sum : int ; sum := 0 ;
    var n : int ; n := 0 ;
    var total : int ; total := 0 ;
    while (true) do (     try (     var value : int ; value := sc.getCurrent()->toInteger() ;
     var amount : int ; amount := sc.getCurrent()->toInteger() ;
    sum := sum+(value * amount) ; 
    total := total+(amount) ; 
    n := n + 1 ; 
 )   catch (e : ProgramException) do (     break )
 ) ; 
    OclFile["System.out"].println(sum) ; 
    OclFile["System.out"].println((total->oclAsType(double) / n)->round()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static int lcm(int a,int b){
    return(a*b)/gcd(a,b);
  }
  static int countPairs(int arr[],int n){
    int ans=0 ;
    for(int i=0 ; i<n ; i++)for(int j=i+1 ; j<n ; j++)if(lcm(arr[i],arr[j])==gcd(arr[i],arr[j]))ans++;
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      1,1,1 };
      int n=arr.length ;
      System.out.print(countPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return (a * b) / gcd(a, b) );
  static   operation countPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i + 1 ; while j < n do (     if (lcm(arr[i+1], arr[j+1]) = gcd(arr[i+1], arr[j+1])) then     ans := ans + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(countPairs(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static boolean isDivisibleRec(int x,int a,int b,int n){
    if(x>n)return false ;
    if(n % x==0)return true ;
    return(isDivisibleRec(x*10+a,a,b,n)|| isDivisibleRec(x*10+b,a,b,n));
  }
  static boolean isDivisible(int a,int b,int n){
    return isDivisibleRec(a,a,b,n)|| isDivisibleRec(b,a,b,n);
  }
  public static void main(String args[]){
    int a=3,b=5,n=53 ;
    if(isDivisible(a,b,n))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation isDivisibleRec( x : int, a : int, b : int, n : int) : boolean
  pre: true
  post: true
  activity: (     if (x > n) then     return false else skip ; 
     if (n mod x = 0) then     return true else skip ; 
     return (isDivisibleRec(x * 10 + a, a, b, n) or isDivisibleRec(x * 10 + b, a, b, n)) );
  static   operation isDivisible( a : int, b : int, n : int) : boolean
  pre: true
  post: true
  activity: (     return isDivisibleRec(a, a, b, n) or isDivisibleRec(b, a, b, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var b : int ; b := 5 ;
    var n : int ; n := 53 ;
     if (isDivisible(a, b, n)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int h=scanner.nextInt();
      int w=scanner.nextInt();
      int n=scanner.nextInt();
      if((h | w | n)==0)break ;
      int[][] map=new int[h+1][w+1];
      map[0][0]=--n ;
      for(int i=0 ; i<h ; i++)for(int j=0 ; j<w ; j++){
        int m=scanner.nextInt();
        map[i][j+1]+=(map[i][j]+(m & 1))/2 ;
        map[i+1][j]+=(map[i][j]+(m ^ 1))/2 ;
        map[i][j]=(map[i][j]+m)% 2 ;
      }
      int px=0 ;
      int py=0 ;
      while(px<w && py<h){
        if(map[py][px]==1)px++;
        else py++;
      }
      System.out.println((py+1)+" "+(px+1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var h : int ; h := scanner.getCurrent()->toInteger() ;
     var w : int ; w := scanner.getCurrent()->toInteger() ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(h,w),n)) = 0) then     break else skip ; 
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(0)) ;
        n := n - 1 ;
 map[0+1][0+1] := n  ; 
        var i : int ; i := 0 ; while i < h do (         var j : int ; j := 0 ; while j < w do ( (     var m : int ; m := scanner.getCurrent()->toInteger() ;
     map[i+1][j + 1+1] := map[i+1][j + 1+1]+((map[i+1][j+1] + (MathLib.bitwiseAnd(m,1))) / 2) ; 
     map[i + 1+1][j+1] := map[i + 1+1][j+1]+((map[i+1][j+1] + (MathLib.bitwiseXor(m,1))) / 2) ; 
     map[i+1][j+1] := (map[i+1][j+1] + m) mod 2 )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var px : int ; px := 0 ;
    var py : int ; py := 0 ;
    while (px < w & py < h) do (     if (map[py+1][px+1] = 1) then     px := px + 1 ; else     py := py + 1 ; ) ; 
    OclFile["System.out"].println((py + 1) + " " + (px + 1)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int h=scanner.nextInt();
      int w=scanner.nextInt();
      int n=scanner.nextInt();
      if((h | w | n)==0)break ;
      int[][] map=new int[h+1][w+1];
      map[0][0]=--n ;
      boolean[][] b=new boolean[h][w];
      for(int i=0 ; i<h ; i++)for(int j=0 ; j<w ; j++){
        int m=scanner.nextInt();
        map[i][j+1]+=(map[i][j]+(m & 1))/2 ;
        map[i+1][j]+=(map[i][j]+(m ^ 1))/2 ;
        b[i][j]=(map[i][j]+m)% 2==1 ;
      }
      int px=0 ;
      int py=0 ;
      while(px<w && py<h){
        if(b[py][px])px++;
        else py++;
      }
      System.out.println((py+1)+" "+(px+1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var h : int ; h := scanner.getCurrent()->toInteger() ;
     var w : int ; w := scanner.getCurrent()->toInteger() ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(h,w),n)) = 0) then     break else skip ; 
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w + 1)->collect(0)) ;
        n := n - 1 ;
 map[0+1][0+1] := n  ; 
    var b : Sequence(Sequence(boolean)) ; b := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(false)) ;
        var i : int ; i := 0 ; while i < h do (         var j : int ; j := 0 ; while j < w do ( (     var m : int ; m := scanner.getCurrent()->toInteger() ;
     map[i+1][j + 1+1] := map[i+1][j + 1+1]+((map[i+1][j+1] + (MathLib.bitwiseAnd(m,1))) / 2) ; 
     map[i + 1+1][j+1] := map[i + 1+1][j+1]+((map[i+1][j+1] + (MathLib.bitwiseXor(m,1))) / 2) ; 
     b[i+1][j+1] := (map[i+1][j+1] + m) mod 2 = 1 )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var px : int ; px := 0 ;
    var py : int ; py := 0 ;
    while (px < w & py < h) do (     if (b[py+1][px+1]) then     px := px + 1 ; else     py := py + 1 ; ) ; 
    OclFile["System.out"].println((py + 1) + " " + (px + 1)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    while(true){
      int H=sc.nextInt();
      int W=sc.nextInt();
      int N=sc.nextInt();
      if(N==0)break ;
      boolean[][] dir=new boolean[H][W];
      sc.nextLine();
      for(int i=0 ; i<H ; ++i){
        String line=sc.nextLine();
        for(int j=0 ; j<W ; ++j){
          dir[i][j]=line.charAt(j*2)=='1' ;
        }
      }
      int[][] count=new int[H+1][W+1];
      count[0][0]=N-1 ;
      for(int i=0 ; i<H ; ++i){
        for(int j=0 ; j<W ; ++j){
          count[i+1][j]+=count[i][j]/2 ;
          count[i][j+1]+=count[i][j]/2 ;
          if(count[i][j] % 2==1){
            if(dir[i][j]){
              count[i][j+1]+=1 ;
            }
            else {
              count[i+1][j]+=1 ;
            }
            dir[i][j]=! dir[i][j];
          }
        }
      }
      int r=0 ;
      int c=0 ;
      while(r<H && c<W){
        if(dir[r][c]){
++c ;
        }
        else {
++r ;
        }
      }
      System.out.println((r+1)+" "+(c+1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var H : int ; H := sc.getCurrent()->toInteger() ;
     var W : int ; W := sc.getCurrent()->toInteger() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    if (N = 0) then     break else skip ; 
    var dir : Sequence(Sequence(boolean)) ; dir := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(false)) ;
    skip ; 
        var i : int ; i := 0 ; while i < H do ( (     var line : String ; line := sc.nextLine() ;
         var j : int ; j := 0 ; while j < W do ( (     dir[i+1][j+1] := line->at(j * 2+1) = '1' )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : Sequence(Sequence(int)) ; count := Integer.subrange(1,H + 1)->collect(Integer.subrange(1,W + 1)->collect(0)) ;
    count[0+1][0+1] := N - 1 ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     count[i + 1+1][j+1] := count[i + 1+1][j+1]+(count[i+1][j+1] / 2) ; 
     count[i+1][j + 1+1] := count[i+1][j + 1+1]+(count[i+1][j+1] / 2) ; 
     if (count[i+1][j+1] mod 2 = 1) then (     if (dir[i+1][j+1]) then (     count[i+1][j + 1+1] := count[i+1][j + 1+1]+(1) ) else (     count[i + 1+1][j+1] := count[i + 1+1][j+1]+(1) ) ;  
     dir[i+1][j+1] := not(dir[i+1][j+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var r : int ; r := 0 ;
    var c : int ; c := 0 ;
    while (r < H & c < W) do (     if (dir[r+1][c+1]) then (     c := c + 1 ) else (     r := r + 1 ) ) ; 
    OclFile["System.out"].println((r + 1) + " " + (c + 1)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int countToMake0lternate(String s){
    int result=0 ;
    for(int i=0 ; i<(s.length()-1); i++)if(s.charAt(i)==s.charAt(i+1))result++;
    return result ;
  }
  static public void main(String[] args){
    System.out.println(countToMake0lternate("000111"));
    System.out.println(countToMake0lternate("11111"));
    System.out.println(countToMake0lternate("01010101"));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countToMake0lternate( s : String) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < (s->size() - 1) do (     if (s->at(i+1) = s->at(i + 1+1)) then     result := result + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return result );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(countToMake0lternate("000111")) ; 
     OclFile["System.out"].println(countToMake0lternate("11111")) ; 
     OclFile["System.out"].println(countToMake0lternate("01010101")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Solution {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int x=sc.nextInt();
      System.out.println(x*2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(x * 2) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] arg){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt(),x=sc.nextInt();
      System.out.println(2*x);
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(2 * x) ; 
     t := t - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static float findArea(float a,float b,float c){
    if(a<0 || b<0 || c<0 ||(a+b<=c)|| a+c<=b || b+c<=a){
      System.out.println("Not a valid triangle");
      System.exit(0);
    }
    float s=(a+b+c)/2 ;
    return(float)Math.sqrt(s*(s-a)*(s-b)*(s-c));
  }
  public static void main(String[] args){
    float a=3.0f ;
    float b=4.0f ;
    float c=5.0f ;
    System.out.println("Area is "+findArea(a,b,c));
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation findArea( a : double, b : double, c : double) : double
  pre: true
  post: true
  activity: (     if (a < 0 or b < 0 or c < 0 or (a + b <= c) or a + c <= b or b + c <= a) then (     OclFile["System.out"].println("Not a valid triangle") ; 
 OclProcess.exit(0) ) else skip ; 
     var s : double ; s := (a + b + c) / 2 ;
     return (s * (s - a) * (s - b) * (s - c))->sqrt()->oclAsType(double) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 3.0f ;
     var b : double ; b := 4.0f ;
     var c : double ; c := 5.0f ;
     OclFile["System.out"].println("Area is " + findArea(a, b, c)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int l=sc.nextInt();
    int idx=0 ;
    int prev=sc.nextInt();
    for(int i=1 ; i<n ; i++){
      int x=sc.nextInt();
      if(x+prev>=l){
        idx=i ;
        break ;
      }
      prev=x ;
    }
    if(idx==0){
      System.out.println("Impossible");
    }
    else {
      StringBuilder sb=new StringBuilder();
      sb.append("Possible").append("\n");
      for(int i=1 ; i<idx ; i++){
        sb.append(i).append("\n");
      }
      for(int i=n-1 ; i>idx ; i--){
        sb.append(i).append("\n");
      }
      sb.append(idx);
      System.out.println(sb);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var idx : int ; idx := 0 ;
    var prev : int ; prev := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x + prev >= l) then (     idx := i ; 
     break ) else skip ; 
     prev := x )  ;     i := i + 1 ) ; 
    if (idx = 0) then (     OclFile["System.out"].println("Impossible") ) else (     var sb : String ; sb := StringLib.newString() ;
     sb := sb + StringLib.newString("Possible") + StringLib.newString("\n") ; 
        var i : int ; i := 1 ; while i < idx do ( (     sb := sb + StringLib.newString(i) + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i > idx do ( (     sb := sb + StringLib.newString(i) + StringLib.newString("\n") )  ;     i := i - 1 ) ; 
    sb := sb + StringLib.newString(idx) ; 
    OclFile["System.out"].println(sb) ; 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws Exception {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(is);
    String input[]=br.readLine().split(" ");
    int count=Integer.parseInt(input[0]);
    int maxLength=Integer.parseInt(input[1]);
    String input2[]=br.readLine().split(" ");
    ArrayList<Integer>result=new ArrayList<Integer>();
    for(int i=0 ; i<count ; i++){
      if(i+1>=count){
        break ;
      }
      int num=Integer.parseInt(input2[i]);
      int num2=Integer.parseInt(input2[i+1]);
      if(num+num2>=maxLength){
        for(int j=0 ; j<i ; j++){
          result.add(j+1);
        }
        for(int n=count-1 ; n>i+1 ; n--){
          result.add(n);
        }
        result.add(i+1);
        System.out.println("Possible");
        for(int re : result){
          System.out.println(re);
        }
        return ;
      }
    }
    System.out.println("Impossible");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(is) ;
    var input : Sequence(String) ; input := br.readLine()->split(" ") ;
    var count : int ; count := (input[0+1])->toInteger() ;
    var maxLength : int ; maxLength := (input[1+1])->toInteger() ;
    var input2 : Sequence(String) ; input2 := br.readLine()->split(" ") ;
    var result : Sequence(int) ; result := Sequence{} ;
        var i : int ; i := 0 ; while i < count do ( (     if (i + 1 >= count) then (     break ) else skip ; 
     var num : int ; num := (input2[i+1])->toInteger() ;
     var num2 : int ; num2 := (input2[i + 1+1])->toInteger() ;
     if (num + num2 >= maxLength) then (         var j : int ; j := 0 ; while j < i do ( (     result := result->including(j + 1) )  ;     j := j + 1 ) ; 
         var n : int ; n := (count)->char2byte() - 1 ; while n > i + 1 do ( (     result := result->including(n) )  ;     n := n - 1 ) ; 
    result := result->including(i + 1) ; 
    OclFile["System.out"].println("Possible") ; 
    for (re : result) do ( (     OclFile["System.out"].println(re) )  ) ; 
    return 
 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Impossible") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
import java.lang.Math ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    ArrayList<Integer>list=new ArrayList<>();
    int sum=0 ;
    for(int i=0 ; i<6 ; i++){
      int _l=input.nextInt();
      list.add(_l);
      sum+=_l ;
    }
    int i,j,k ;
    for(i=0 ; i<4 ; i++){
      for(j=i+1 ; j<5 ; j++){
        for(k=j+1 ; k<6 ; k++){
          int sum1=list.get(i)+list.get(j)+list.get(k);
          if(sum1==sum-sum1){
            System.out.println("YES");
            return ;
          }
        }
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(int) ; list := Sequence{} ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 6 do ( (     var _l : int ; _l := input.getCurrent()->toInteger() ;
     list := list->including(_l) ; 
     sum := sum+(_l) )  ;     i := i + 1 ) ; 
    var i : int ;
    var j : int ;
    var k : int ;
        i := 0 ; while i < 4 do ( (         j := i + 1 ; while j < 5 do ( (         k := j + 1 ; while k < 6 do ( (     var sum1 : int ; sum1 := list->at(i+1) + list->at(j+1) + list->at(k+1) ;
     if (sum1 = sum - sum1) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class1 {
  public static void main(String arg[]){
    Scanner input=new Scanner(System.in);
    long n=input.nextLong();
    long m=input.nextLong();
    long k=input.nextLong();
    long l=input.nextLong();
    long x=l+k ;
    long s=x % m ;
    x=x/m ;
    if(s!=0){
      x=x+1 ;
    }
    if(x*m>n || k+l>n){
      System.out.println(-1);
    }
    else {
      System.out.println(x);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class1 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := input.getCurrent()->toLong() ;
    var m : long ; m := input.getCurrent()->toLong() ;
    var k : long ; k := input.getCurrent()->toLong() ;
    var l : long ; l := input.getCurrent()->toLong() ;
    var x : long ; x := l + k ;
    var s : long ; s := x mod m ;
    x := x / m ; 
    if (s /= 0) then (     x := x + 1 ) else skip ; 
    if (x * m > n or k + l > n) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(x) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class ContestReader {
  private BufferedReader reader ;
  private StringTokenizer tokenizer ;
  ContestReader(InputStream in){
    reader=new BufferedReader(new InputStreamReader(in));
  }
  public String next(){
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        tokenizer=new java.util.StringTokenizer(reader.readLine());
      }
      catch(Exception e){
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
  public double nextDouble(){
    return Double.parseDouble(next());
  }
}
public class Main {
  private static ArrayList<String>solve(long l,long[] as){
    ArrayList<String>answer=new ArrayList<String>();
    for(int i=1 ; i<as.length ; i++){
      if(as[i-1]+as[i]>=l){
        answer.add("Possible");
        for(int k=1 ; k<i ; k++){
          answer.add(""+k);
        }
        for(int k=as.length-1 ; k>i ; k--){
          answer.add(""+k);
        }
        answer.add(""+i);
        return answer ;
      }
    }
    answer.add("Impossible");
    return answer ;
  }
  private static void execute(ContestReader reader,PrintWriter out){
    int n=reader.nextInt();
    long l=reader.nextLong();
    long[] as=new long[n];
    for(int i=0 ; i<n ; i++){
      as[i]=reader.nextLong();
    }
    ArrayList<String>answer=solve(l,as);
    for(String s : answer){
      out.println(s);
    }
  }
  public static void main(String[] args){
    ContestReader reader=new ContestReader(System.in);
    PrintWriter out=new PrintWriter(System.out);
    execute(reader,out);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ContestReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newContestReader( in : OclFile) : ContestReader
  pre: true
  post: true
  activity:
  ( var self : ContestReader ;
    self := createContestReader();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := StringTokenizer.newStringTokenizer(reader.readLine()) )   catch (e : ProgramException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
class Main {
  static   operation solve( l : long, as : Sequence(long)) : Sequence(String)
  pre: true
  post: true
  activity: (     var answer : Sequence(String) ; answer := Sequence{} ;
         var i : int ; i := 1 ; while i < as->size() do ( (     if (as[i - 1+1] + as[i+1] >= l) then (     answer := answer->including("Possible") ; 
         var k : int ; k := 1 ; while k < i do ( (     answer := answer->including("" + k) )  ;     k := k + 1 ) ; 
        var k : int ; k := as->size() - 1 ; while k > i do ( (     answer := answer->including("" + k) )  ;     k := k - 1 ) ; 
    answer := answer->including("" + i) ; 
    return answer 
 ) else skip )  ;     i := i + 1 ) ; 
     answer := answer->including("Impossible") ; 
     return answer );
  static   operation execute( reader : ContestReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := reader.getCurrent()->toInteger() ;
     var l : long ; l := reader.getCurrent()->toLong() ;
    var as : Sequence(long) ; as := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     as[i+1] := reader.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var answer : Sequence(String) ; answer := solve(l, as) ;
    for (s : answer) do ( (     out.println(s) )  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : ContestReader ; reader := ContestReader.newContestReader(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     execute execute(reader, out) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static void solve(){
    int n=in.nextInt();
    int l=in.nextInt();
    int[] a=new int[n];
    int p=-1 ;
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
      if(i!=0){
        if(a[i]+a[i-1]>=l)p=i-1 ;
      }
    }
    if(p>=0){
      out.println("Possible");
      for(int i=0 ; i<p ; i++){
        out.println(i+1);
      }
      for(int i=n-1 ; i>p ; i--){
        out.println(i);
      }
    }
    else {
      out.println("Impossible");
    }
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    solve();
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var l : int ; l := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var p : int ; p := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     if (i /= 0) then (     if (a[i+1] + a[i - 1+1] >= l) then     p := i - 1 ; else skip ) else skip )  ;     i := i + 1 ) ; 
    if (p >= 0) then (     skip ; 
         var i : int ; i := 0 ; while i < p do ( (     skip )  ;     i := i + 1 ) ; 
         var i : int ; i := n - 1 ; while i > p do ( (     skip )  ;     i := i - 1 ) ) else (     skip ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    execute solve() ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=scan.nextInt();
    int L=scan.nextInt();
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++){
      a[i]=scan.nextInt();
    }
    boolean found=false ;
    int left=0 ;
    for(int i=0 ; i<N-1 ; i++){
      if(L<=a[i]+a[i+1]){
        found=true ;
        left=i ;
        break ;
      }
    }
    if(! found){
      System.out.println("Impossible");
      return ;
    }
    System.out.println("Possible");
    for(int i=0 ; i<left ; i++){
      System.out.println(i+1);
    }
    for(int i=N-1 ; left<i ; i--){
      System.out.println(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var L : int ; L := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var found : boolean ; found := false ;
    var left : int ; left := 0 ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     if (L <= a[i+1] + a[i + 1+1]) then (     found := true ; 
     left := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (not(found)) then (     OclFile["System.out"].println("Impossible") ; 
     return ) else skip ; 
    OclFile["System.out"].println("Possible") ; 
        var i : int ; i := 0 ; while i < left do ( (     OclFile["System.out"].println(i + 1) )  ;     i := i + 1 ) ; 
        var i : int ; i := N - 1 ; while left < i do ( (     OclFile["System.out"].println(i) )  ;     i := i - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAX=100000000 ;
  static boolean prime[]=new boolean[MAX+1];
  static void SieveOfEratosthenes(){
    for(int i=0 ; i<prime.length ; i++){
      prime[i]=true ;
    }
    prime[1]=false ;
    for(int p=2 ; p*p<=MAX ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=MAX ; i+=p){
          prime[i]=false ;
        }
      }
    }
  }
  static void find_Prime(int sum){
    for(int i=sum/2 ; i>1 ; i--){
      if(prime[i] && prime[sum-i]){
        System.out.println(i+" "+(sum-i));
        return ;
      }
    }
    System.out.println("Cannot be represented as sum of two primes");
  }
  public static void main(String[] args){
    SieveOfEratosthenes();
    int sum=1002 ;
    find_Prime(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 100000000;
  static   attribute prime : boolean := Integer.subrange(1,MAX + 1)->collect(false);
  static   operation SieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < prime->size() do ( (     prime[i+1] := true )  ;     i := i + 1 ) ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p <= MAX do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= MAX do ( (     prime[i+1] := false )  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation find_Prime( sum : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := sum / 2 ; while i > 1 do ( (     if (prime[i+1] & prime[sum - i+1]) then (     OclFile["System.out"].println(i + " " + (sum - i)) ; 
     return ) else skip )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println("Cannot be represented as sum of two primes") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes() ; 
     var sum : int ; sum := 1002 ;
     execute find_Prime(sum) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TheUselessToy {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char s=sc.next().charAt(0);
    char e=sc.next().charAt(0);
    int n=sc.nextInt();
    n=n % 4 ;
    if(n==2 || s==e){
      System.out.println("undefined");
      return ;
    }
    char[] cw={
      '<','^','>','v' };
      char[] ccw={
        '<','v','>','^' };
        for(int i=0 ; i<4 ; i++)if(cw[i]==s)if(cw[(i+n)% 4]==e){
          System.out.println("cw");
          return ;
        }
        for(int i=0 ; i<4 ; i++)if(ccw[i]==s)if(ccw[(i+n)% 4]==e){
          System.out.println("ccw");
          return ;
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class TheUselessToy {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent()->at(0+1) ;
    var e : String ; e := sc.getCurrent()->at(0+1) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    n := n mod 4 ; 
    if (n = 2 or s = e) then (     OclFile["System.out"].println("undefined") ; 
     return ) else skip ; 
    var cw : Sequence(String) ; cw := Sequence{'<','^','>','v'} ;
    var ccw : Sequence(String) ; ccw := Sequence{'<','v','>','^'} ;
        var i : int ; i := 0 ; while i < 4 do (     if (cw[i+1] = s) then     if (cw[(i + n) mod 4+1] = e) then (     OclFile["System.out"].println("cw") ; 
     return ) else skip ; else skip ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 4 do (     if (ccw[i+1] = s) then     if (ccw[(i + n) mod 4+1] = e) then (     OclFile["System.out"].println("ccw") ; 
     return ) else skip ; else skip ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s1=in.next(),s2=in.next();
    int n=in.nextInt();
    n %=4 ;
    int c1=0,c2=0 ;
    switch(s1){
      case "^" : c1=0 ;
      break ;
      case ">" : c1=1 ;
      break ;
      case "v" : c1=2 ;
      break ;
      default : c1=3 ;
    }
    switch(s2){
      case "^" : c2=0 ;
      break ;
      case ">" : c2=1 ;
      break ;
      case "v" : c2=2 ;
      break ;
      default : c2=3 ;
    }
    int cw=c2-c1,ccw=c1-c2 ;
    if(((cw==-ccw)&&(Math.abs(cw)==2))||(cw==ccw)){
      System.out.println("undefined");
      return ;
    }
    if(cw<0){
      cw=4+cw ;
    }
    if(cw!=n){
      System.out.println("ccw");
    }
    else {
      System.out.println("cw");
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := in.getCurrent() ;
    var s2 : String ; s2 := in.getCurrent() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    n := n mod 4 ; 
    var c1 : int ; c1 := 0 ;
    var c2 : int ; c2 := 0 ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (s1) ; 
       if _switchval = "^" then
     c1 := 0 ; 
    break 
   else skip ;
       if _switchval = ">" then
     c1 := 1 ; 
    break 
   else skip ;
       if _switchval = "v" then
     c1 := 2 ; 
    break 
   else skip ;
       if true then
     c1 := 3 ; 
   else skip ;
 )
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (s2) ; 
       if _switchval = "^" then
     c2 := 0 ; 
    break 
   else skip ;
       if _switchval = ">" then
     c2 := 1 ; 
    break 
   else skip ;
       if _switchval = "v" then
     c2 := 2 ; 
    break 
   else skip ;
       if true then
     c2 := 3 ; 
   else skip ;
 )
    var cw : int ; cw := c2 - c1 ;
    var ccw : int ; ccw := c1 - c2 ;
    if (((cw = -ccw) & (if cw < 0 then -(cw) else cw endif = 2)) or (cw = ccw)) then (     OclFile["System.out"].println("undefined") ; 
     return ) else skip ; 
    if (cw < 0) then (     cw := 4 + cw ) else skip ; 
    if (cw /= n) then (     OclFile["System.out"].println("ccw") ) else (     OclFile["System.out"].println("cw") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.util.Scanner ;
import java.util.Arrays ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(isr);
    String buf ;
    String minStr=null ;
    try {
      int len=Integer.parseInt(br.readLine());
      int i=0 ;
      int list[]=new int[len];
      buf=br.readLine();
      Scanner scanner=new Scanner(buf);
      while(scanner.hasNext()){
        list[i++]=Integer.parseInt(scanner.next());
      }
      Arrays.sort(list);
      for(i=0 ; i<len ; i++){
        System.out.print(list[i]);
        if(i<len-1){
          System.out.print(" ");
        }
      }
      System.out.print("\n");
    }
    catch(IOException e){
      System.out.println("Read error.");
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
    var buf : String ;
    var minStr : String ; minStr := null ;
    try (     var len : int ; len := (br.readLine())->toInteger() ;
     var i : int ; i := 0 ;
    var list : Sequence(int) ; list := Integer.subrange(1,len)->collect(0) ;
    buf := br.readLine() ; 
    var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile.newOclFile(buf)) ;
    while (scanner.hasNext()) do (      list[i+1] := (scanner.getCurrent())->toInteger()  ; i := i + 1 ) ; 
    list := list->sort() ; 
        i := 0 ; while i < len do ( (     OclFile["System.out"].print(list[i+1]) ; 
     if (i < (len)->char2byte() - 1) then (     OclFile["System.out"].print(" ") ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("\n") ; 
 )   catch (e : IOException) do (     OclFile["System.out"].println("Read error.") ; 
     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=br.readLine();
    int n=Integer.parseInt(str);
    int intArray[]=new int[n];
    str=br.readLine();
    String numArray[]=str.split(" ");
    for(int i=0 ; i<n ; i++){
      intArray[i]=Integer.parseInt(numArray[i]);
    }
    Arrays.sort(intArray);
    for(int i=0 ; i<n ; i++){
      if(i!=(n-1)){
        System.out.print(intArray[i]+" ");
      }
      else {
        System.out.println(intArray[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := br.readLine() ;
    var n : int ; n := (str)->toInteger() ;
    var intArray : Sequence(int) ; intArray := Integer.subrange(1,n)->collect(0) ;
    str := br.readLine() ; 
    var numArray : Sequence(String) ; numArray := str->split(" ") ;
        var i : int ; i := 0 ; while i < n do ( (     intArray[i+1] := (numArray[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    intArray := intArray->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i /= ((n)->char2byte() - 1)) then (     OclFile["System.out"].print(intArray[i+1] + " ") ) else (     OclFile["System.out"].println(intArray[i+1]) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Iterator ;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<Integer>list=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      list.add(sc.nextInt());
    }
    Collections.sort(list);
    Iterator<Integer>iter=list.iterator();
    while(iter.hasNext()){
      System.out.print(iter.next());
      if(iter.hasNext()){
        System.out.print(" ");
      }
    }
    System.out.print("\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var iter : OclIterator ; iter := list->iterator() ;
    while (iter.hasNext()) do (     OclFile["System.out"].print(iter.next()) ; 
     if (iter.hasNext()) then (     OclFile["System.out"].print(" ") ) else skip ) ; 
    OclFile["System.out"].print("\n") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    itcast : while(sc.hasNext()){
      int[] arr=new int[6];
      int ans=0 ;
      for(int i=0 ; i<6 ; i++){
        arr[i]=sc.nextInt();
        ans+=arr[i];
      }
      for(int i=1 ; i<arr.length ; i++){
        for(int j=i+1 ; j<arr.length ; j++){
          int temp=arr[0]+arr[i]+arr[j];
          if(temp==ans-temp){
            System.out.println("YES");
            continue itcast ;
          }
        }
      }
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var arr : Sequence(int) ; arr := Integer.subrange(1,6)->collect(0) ;
     var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 6 do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     ans := ans+(arr[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < arr->size() do ( (         var j : int ; j := i + 1 ; while j < arr->size() do ( (     var temp : int ; temp := arr[0+1] + arr[i+1] + arr[j+1] ;
     if (temp = ans - temp) then (     OclFile["System.out"].println("YES") ; 
     continue ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 ) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int num[]=new int[n];
    for(int i=0 ; i<n ; i++)num[i]=sc.nextInt();
    if(n!=1)sort(num,0,n-1);
    for(int i=0 ; i<n-1 ; i++)System.out.print(num[i]+" ");
    System.out.println(num[n-1]);
  }
  static void sort(int[] num,int l,int r){
    double pivot=pivot(num,l,r);
    int left_end=l,right_end=r ;
    int temp ;
    if(pivot!=-1){
      while(l<=r){
        while(num[l]<pivot && l<=right_end)l++;
        while(num[r]>=pivot && r>=left_end)r--;
        if(l>r)break ;
        temp=num[l];
        num[l]=num[r];
        num[r]=temp ;
      }
      if(left_end!=r)sort(num,left_end,r);
      if(right_end!=l)sort(num,l,right_end);
    }
  }
  static double pivot(int[] num,int l,int r){
    for(int i=l ; i<=r ; i++){
      if(num[i]!=num[l]){
        if(num[i]>num[l]){
          return num[i];
        }
        else {
          return num[l];
        }
      }
    }
    return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var num : Sequence(int) ; num := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     num[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    if (n /= 1) then     execute sort(num, 0, n - 1) ; else skip ; 
        var i : int ; i := 0 ; while i < n - 1 do (     OclFile["System.out"].print(num[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(num[n - 1+1]) ; 
 );
  static   operation sort( num : Sequence(int), l : int, r : int) : void
  pre: true
  post: true
  activity: (     var pivot : double ; pivot := pivot(num, l, r) ;
     var left_end : int ; left_end := l ;
    var right_end : int ; right_end := r ;
     var temp : int ;
     if (pivot /= -1) then (     while (l <= r) do (     while (num[l+1] < pivot & l <= right_end) do     l := l + 1 ; ; 
     while (num[r+1] >= pivot & r >= left_end) do     r := r - 1 ; ; 
    if (l > r) then     break else skip ; 
    temp := num[l+1] ; 
    num[l+1] := num[r+1] ; 
    num[r+1] := temp ; 
 ) ; 
     if (left_end /= r) then     execute sort(num, left_end, r) ; else skip ; 
     if (right_end /= l) then     execute sort(num, l, right_end) ; else skip ) else skip );
  static   operation pivot( num : Sequence(int), l : int, r : int) : double
  pre: true
  post: true
  activity: (         var i : int ; i := l ; while i <= r do ( (     if (num[i+1] /= num[l+1]) then (     if (num[i+1] > num[l+1]) then (     return num[i+1] ) else (     return num[l+1] ) ) else skip )  ;     i := i + 1 ) ; 
     return -1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String args[]){
    FastScanner input=new FastScanner();
    long coins=input.nextLong();
    long friends=input.nextLong();
    long sizeofhis=input.nextLong();
    long mustholdthis=input.nextLong();
    long d=(mustholdthis+sizeofhis+friends-1)/friends ;
    if(coins<(d*friends)){
      System.out.println("-1");
    }
    else {
      System.out.println(d);
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
        }
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
    String nextLine()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var coins : long ; coins := input.nextLong() ;
    var friends : long ; friends := input.nextLong() ;
    var sizeofhis : long ; sizeofhis := input.nextLong() ;
    var mustholdthis : long ; mustholdthis := input.nextLong() ;
    var d : long ; d := (mustholdthis + sizeofhis + friends - 1) / friends ;
    if (coins < (d * friends)) then (     OclFile["System.out"].println("-1") ) else (     OclFile["System.out"].println(d) ) ;  
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int[] ary=new int[n];
    String[] line=br.readLine().split(" ");
    for(int i=0 ; i<line.length ; i++)ary[i]=Integer.parseInt(line[i]);
    Arrays.sort(ary);
    StringBuilder sb=new StringBuilder();
    for(int a : ary)sb.append(a).append(' ');
    System.out.println(sb.deleteCharAt(sb.length()-1).toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var ary : Sequence(int) ; ary := Integer.subrange(1,n)->collect(0) ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < line->size() do (     ary[i+1] := (line[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    ary := ary->sort() ; 
    var sb : String ; sb := StringLib.newString() ;
    for (a : ary) do (     sb := sb + StringLib.newString(a) + StringLib.newString(' ') ;  ) ; 
    OclFile["System.out"].println(sb->excludingAt(sb->size() - 1+1)+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
class GFG {
  public static int partition(Integer[] arr,int l,int r){
    int x=arr[r],i=l ;
    for(int j=l ; j<=r-1 ; j++){
      if(arr[j]<=x){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp ;
        i++;
      }
    }
    int temp=arr[i];
    arr[i]=arr[r];
    arr[r]=temp ;
    return i ;
  }
  public static int kthSmallest(Integer[] arr,int l,int r,int k){
    if(k>0 && k<=r-l+1){
      int pos=partition(arr,l,r);
      if(pos-l==k-1)return arr[pos];
      if(pos-l>k-1)return kthSmallest(arr,l,pos-1,k);
      return kthSmallest(arr,pos+1,r,k-pos+l-1);
    }
    return Integer.MAX_VALUE ;
  }
  public static void main(String[] args){
    Integer arr[]=new Integer[] {
      12,3,5,7,4,19,26 };
      int k=3 ;
      System.out.print("K'th smallest element is "+kthSmallest(arr,0,arr.length-1,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation partition( arr : Sequence(int), l : int, r : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := arr[r+1] ;
    var i : int ; i := l ;
         var j : int ; j := l ; while j <= r - 1 do ( (     if (arr[j+1] <= x) then (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := arr[j+1] ; 
     arr[j+1] := temp ; 
     i := i + 1 ) else skip )  ;     j := j + 1 ) ; 
    var temp : int ; temp := arr[i+1] ;
    arr[i+1] := arr[r+1] ; 
    arr[r+1] := temp ; 
    return i 
 );
  static   operation kthSmallest( arr : Sequence(int), l : int, r : int, k : int) : int
  pre: true
  post: true
  activity: (     if (k > 0 & k <= r - l + 1) then (     var pos : int ; pos := partition(arr, l, r) ;
     if (pos - l = k - 1) then     return arr[pos+1] else skip ; 
     if (pos - l > k - 1) then     return kthSmallest(arr, l, pos - 1, k) else skip ; 
     return kthSmallest(arr, pos + 1, r, k - pos + l - 1) ) else skip ; 
     return 2147483647 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,3,5,7,4,19,26} ;
     var k : int ; k := 3 ;
     OclFile["System.out"].print("K'th smallest element is " + kthSmallest(arr, 0, arr->size() - 1, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int m=sc.nextInt();
    int f=sc.nextInt();
    int r=sc.nextInt();
    StringBuffer sb=new StringBuffer();
    while(m+f+r!=-3){
      if(m==-1 || f==-1)sb.append("F\n");
      else if(m+f>=80)sb.append("A\n");
      else if(m+f>=65)sb.append("B\n");
      else if(m+f>=50)sb.append("C\n");
      else if(m+f>=30){
        if(r>=50)sb.append("C\n");
        else sb.append("D\n");
      }
      else sb.append("F\n");
      m=sc.nextInt();
      f=sc.nextInt();
      r=sc.nextInt();
    }
    System.out.print(sb);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var f : int ; f := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
    while (m + f + r /= -3) do (     if (m = -1 or f = -1) then     sb := sb + StringLib.newString("F\n") else     if (m + f >= 80) then     sb := sb + StringLib.newString("A\n") else     if (m + f >= 65) then     sb := sb + StringLib.newString("B\n") else     if (m + f >= 50) then     sb := sb + StringLib.newString("C\n") else     if (m + f >= 30) then (     if (r >= 50) then     sb := sb + StringLib.newString("C\n") ; else     sb := sb + StringLib.newString("D\n") ; ) else     sb := sb + StringLib.newString("F\n") ; ;  ;  ;  ;  ;  
     m := sc.getCurrent()->toInteger() ; 
     f := sc.getCurrent()->toInteger() ; 
     r := sc.getCurrent()->toInteger() ) ; 
    OclFile["System.out"].print(sb) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String line=null ;
      while(!(line=br.readLine()).equals("-1-1-1")){
        String[] str=line.split(" ");
        int m=Integer.parseInt(str[0]);
        int f=Integer.parseInt(str[1]);
        int r=Integer.parseInt(str[2]);
        String Grade ;
        if(m==-1 || f==-1){
          Grade="F" ;
        }
        else if(m+f>=80){
          Grade="A" ;
        }
        else if(m+f>=65){
          Grade="B" ;
        }
        else if(m+f>=50){
          Grade="C" ;
        }
        else if(m+f>=30){
          Grade="D" ;
          if(r>=50){
            Grade="C" ;
          }
        }
        else {
          Grade="F" ;
        }
        System.out.println(Grade);
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var line : String ; line := null ;
     while (not((line) = "-1-1-1")) do (     var str : Sequence(String) ; str := line->split(" ") ;
     var m : int ; m := (str[0+1])->toInteger() ;
    var f : int ; f := (str[1+1])->toInteger() ;
    var r : int ; r := (str[2+1])->toInteger() ;
    var Grade : String ;
    if (m = -1 or f = -1) then (     Grade := "F" ) else     if (m + f >= 80) then (     Grade := "A" ) else     if (m + f >= 65) then (     Grade := "B" ) else     if (m + f >= 50) then (     Grade := "C" ) else     if (m + f >= 30) then (     Grade := "D" ; 
     if (r >= 50) then (     Grade := "C" ) else skip ) else (     Grade := "F" ) ;  ;  ;  ;  ;  
    OclFile["System.out"].println(Grade) ; 
 ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    @ SuppressWarnings("resource")Scanner sc2=new Scanner(System.in);
    while(true){
      if(sc2.hasNextLine()){
        String[] s=sc2.nextLine().split("[\\s]+");
        int m=Integer.parseInt(s[0]);
        int f=Integer.parseInt(s[1]);
        int r=Integer.parseInt(s[2]);
        int n=m+f ;
        if(m==-1 && f==-1 && r==-1)break ;
        else {
          if((m | f)==-1)System.out.println("F");
          else if(n>=80)System.out.println("A");
          else if(n<80 && n>=65)System.out.println("B");
          else if(n<65 && n>=50)System.out.println("C");
          else if(n<50 && n>=30){
            if(r>=50)System.out.println("C");
            else {
              System.out.println("D");
            }
          }
          else if(n<30)System.out.println("F");
        }
      }
      else {
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc2 : OclFile ; sc2 := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     if (sc2.hasNextLine()) then (     var s : Sequence(String) ; s := sc2.nextLine()->split("[\\s]+") ;
     var m : int ; m := (s[0+1])->toInteger() ;
    var f : int ; f := (s[1+1])->toInteger() ;
    var r : int ; r := (s[2+1])->toInteger() ;
    var n : int ; n := m + f ;
    if (m = -1 & f = -1 & r = -1) then     break else (     if ((MathLib.bitwiseOr(m,f)) = -1) then     OclFile["System.out"].println("F") ; else     if (n >= 80) then     OclFile["System.out"].println("A") else     if (n < 80 & n >= 65) then     OclFile["System.out"].println("B") else     if (n < 65 & n >= 50) then     OclFile["System.out"].println("C") else     if (n < 50 & n >= 30) then (     if (r >= 50) then     OclFile["System.out"].println("C") ; else (     OclFile["System.out"].println("D") ) ) else     if (n < 30) then     OclFile["System.out"].println("F") ; else skip ; ;  ;  ;  ;  ) ;  
 ) else (     break ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    printAnswer();
  }
  private static void printAnswer(){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String dataset=br.readLine();
      while(dataset!=null){
        String[] grades=dataset.split(" ",0);
        int middleResult=Integer.parseInt(grades[0]);
        int termendResult=Integer.parseInt(grades[1]);
        int makeupResult=Integer.parseInt(grades[2]);
        if(makeupResult==-1 && termendResult==-1 && middleResult==-1){
          break ;
        }
        outputGrade(middleResult,termendResult,makeupResult);
        dataset=br.readLine();
      }
    }
    catch(IOException e){
    }
  }
  private static void outputGrade(int middleResult,int termendResult,int makeupResult){
    if(middleResult==-1 || termendResult==-1){
      System.out.println("F");
    }
    else if(middleResult+termendResult>=80){
      System.out.println("A");
    }
    else if(middleResult+termendResult>=65){
      System.out.println("B");
    }
    else if(middleResult+termendResult>=50){
      System.out.println("C");
    }
    else if(middleResult+termendResult>=30){
      if(makeupResult>=50){
        System.out.println("C");
      }
      else {
        System.out.println("D");
      }
    }
    else {
      System.out.println("F");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute printAnswer() );
  static   operation printAnswer() : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var dataset : String ; dataset := br.readLine() ;
     while (dataset /= null) do (     var grades : Sequence(String) ; grades := dataset->split(" ") ;
     var middleResult : int ; middleResult := (grades[0+1])->toInteger() ;
    var termendResult : int ; termendResult := (grades[1+1])->toInteger() ;
    var makeupResult : int ; makeupResult := (grades[2+1])->toInteger() ;
    if (makeupResult = -1 & termendResult = -1 & middleResult = -1) then (     break ) else skip ; 
    execute outputGrade(middleResult, termendResult, makeupResult) ; 
    dataset := br.readLine() ; 
 ) )   catch (e : IOException) do skip
 );
  static   operation outputGrade( middleResult : int, termendResult : int, makeupResult : int) : void
  pre: true
  post: true
  activity: (     if (middleResult = -1 or termendResult = -1) then (     OclFile["System.out"].println("F") ) else     if (middleResult + termendResult >= 80) then (     OclFile["System.out"].println("A") ) else     if (middleResult + termendResult >= 65) then (     OclFile["System.out"].println("B") ) else     if (middleResult + termendResult >= 50) then (     OclFile["System.out"].println("C") ) else     if (middleResult + termendResult >= 30) then (     if (makeupResult >= 50) then (     OclFile["System.out"].println("C") ) else (     OclFile["System.out"].println("D") ) ) else (     OclFile["System.out"].println("F") ) ;  ;  ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int midExam=-1,finalExam=-1,supple=-1,sumExam=0 ;
    char grade=0 ;
    for(; ; ){
      try {
        midExam=in.nextInt();
        finalExam=in.nextInt();
        supple=in.nextInt();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      if(midExam==-1 && finalExam==-1 && supple==-1)break ;
      sumExam=midExam+finalExam ;
      if(midExam==-1 || finalExam==-1 || sumExam<30)grade='F' ;
      else if(sumExam>=80)grade='A' ;
      else if(sumExam>=65)grade='B' ;
      else if(sumExam>=50 || supple>=50)grade='C' ;
      else grade='D' ;
      System.out.println(grade);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var midExam : int ; midExam := -1 ;
    var finalExam : int ; finalExam := -1 ;
    var supple : int ; supple := -1 ;
    var sumExam : int ; sumExam := 0 ;
     var grade : String ; grade := 0 ;
       while true do ( (     try (     midExam := in.getCurrent()->toInteger() ; 
     finalExam := in.getCurrent()->toInteger() ; 
     supple := in.getCurrent()->toInteger() )   catch (e : ProgramException) do (     e.printStackTrace() )
     if (midExam = -1 & finalExam = -1 & supple = -1) then     break else skip ; 
    sumExam := midExam + finalExam ; 
    if (midExam = -1 or finalExam = -1 or sumExam < 30) then     grade := 'F' else     if (sumExam >= 80) then     grade := 'A' else     if (sumExam >= 65) then     grade := 'B' else     if (sumExam >= 50 or supple >= 50) then     grade := 'C' else     grade := 'D' ; ;  ;  ;  ;  
    OclFile["System.out"].println(grade) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static int minJumps(int arr[],int N){
    int MAX=1000000 ;
    int[] fib=new int[30];
    fib[0]=0 ;
    fib[1]=1 ;
    for(int i=2 ; i<30 ; i++)fib[i]=fib[i-1]+fib[i-2];
    int[] DP=new int[N+2];
    DP[0]=0 ;
    for(int i=1 ; i<=N+1 ; i++)DP[i]=MAX ;
    for(int i=1 ; i<=N+1 ; i++){
      for(int j=1 ; j<30 ; j++){
        if((i==N+1 || arr[i-1]==1)&& i-fib[j]>=0)DP[i]=Math.min(DP[i],1+DP[i-fib[j] ]);
      }
    }
    if(DP[N+1]!=MAX)return DP[N+1];
    else return-1 ;
  }
  public static void main(String[] args){
    int[] arr=new int[] {
      0,0,0,1,1,0,1,0,0,0,0 };
      int n=11 ;
      int ans=minJumps(arr,n);
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minJumps( arr : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var MAX : int ; MAX := 1000000 ;
     var fib : Sequence(int) ; fib := Integer.subrange(1,30)->collect(0) ;
    fib[0+1] := 0 ; 
    fib[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < 30 do (     fib[i+1] := fib[i - 1+1] + fib[i - 2+1] ;  ;     i := i + 1 ) ; 
    var DP : Sequence(int) ; DP := Integer.subrange(1,N + 2)->collect(0) ;
    DP[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= N + 1 do (     DP[i+1] := MAX ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N + 1 do ( (         var j : int ; j := 1 ; while j < 30 do ( (     if ((i = N + 1 or arr[i - 1+1] = 1) & i - fib[j+1] >= 0) then     DP[i+1] := Set{DP[i+1], 1 + DP[i - fib[j+1]+1]}->min() ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (DP[N + 1+1] /= MAX) then     return DP[N + 1+1] else     return -1 ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,0,0,1,1,0,1,0,0,0,0} ;
     var n : int ; n := 11 ;
     var ans : int ; ans := minJumps(arr, n) ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNextInt()){
      int a[]=new int[6];
      int he=0 ;
      for(int i=0 ; i<6 ; i++){
        a[i]=in.nextInt();
        he=he+a[i];
      }
      boolean f=false ;
      int avg=he/2 ;
      if(he % 2!=0){
        System.out.println("NO");
        break ;
      }
      for(int i=0 ; i<4 ; i++){
        for(int j=i+1 ; j<5 ; j++){
          for(int k=j+1 ; k<6 ; k++){
            if(a[i]+a[j]+a[k]==avg){
              f=true ;
              break ;
            }
          }
        }
      }
      if(f==true){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNextInt()) do (     var a : Sequence(int) ; a := Integer.subrange(1,6)->collect(0) ;
     var he : int ; he := 0 ;
        var i : int ; i := 0 ; while i < 6 do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     he := he + a[i+1] )  ;     i := i + 1 ) ; 
    var f : boolean ; f := false ;
    var avg : int ; avg := he / 2 ;
    if (he mod 2 /= 0) then (     OclFile["System.out"].println("NO") ; 
     break ) else skip ; 
        var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := i + 1 ; while j < 5 do ( (         var k : int ; k := j + 1 ; while k < 6 do ( (     if (a[i+1] + a[j+1] + a[k+1] = avg) then (     f := true ; 
     break ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (f = true) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static boolean findPattern(int n){
    int prev=n % 2 ;
    n=n/2 ;
    while(n>0){
      int curr=n % 2 ;
      if(curr==prev)return false ;
      prev=curr ;
      n=n/2 ;
    }
    return true ;
  }
  public static void main(String args[]){
    int n=10 ;
    System.out.println(findPattern(n)? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation findPattern( n : int) : boolean
  pre: true
  post: true
  activity: (     var prev : int ; prev := n mod 2 ;
     n := n / 2 ; 
     while (n > 0) do (     var curr : int ; curr := n mod 2 ;
     if (curr = prev) then     return false else skip ; 
     prev := curr ; 
     n := n / 2 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(if findPattern(n) then "Yes" else "No" endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  static int findMaximum(int arr[],int low,int high){
    if(low==high)return arr[low];
    if((high==low+1)&& arr[low]>=arr[high])return arr[low];
    if((high==low+1)&& arr[low]<arr[high])return arr[high];
    int mid=(low+high)/2 ;
    if(arr[mid]>arr[mid+1] && arr[mid]>arr[mid-1])return arr[mid];
    if(arr[mid]>arr[mid+1] && arr[mid]<arr[mid-1])return findMaximum(arr,low,mid-1);
    else return findMaximum(arr,mid+1,high);
  }
  public static void main(String[] args){
    int arr[]={
      1,3,50,10,9,7,6 };
      int n=arr.length ;
      System.out.println("The maximum element is "+findMaximum(arr,0,n-1));
    }
  }

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation findMaximum( arr : Sequence(int), low : int, high : int) : int
  pre: true
  post: true
  activity: (     if (low = high) then     return arr[low+1] else skip ; 
     if ((high = low + 1) & arr[low+1] >= arr[high+1]) then     return arr[low+1] else skip ; 
    if ((high = low + 1) & arr[low+1] < arr[high+1]) then     return arr[high+1] else skip ; 
    var mid : int ; mid := (low + high) / 2 ;
    if (arr[mid+1] > arr[mid + 1+1] & arr[mid+1] > arr[mid - 1+1]) then     return arr[mid+1] else skip ; 
    if (arr[mid+1] > arr[mid + 1+1] & arr[mid+1] < arr[mid - 1+1]) then     return findMaximum(arr, low, mid - 1) else     return findMaximum(arr, mid + 1, high) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,50,10,9,7,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("The maximum element is " + findMaximum(arr, 0, n - 1)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import javax.lang.model.util.ElementScanner6 ;
public class ques1 {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    long n=scn.nextLong();
    long m=scn.nextLong();
    long k=scn.nextLong();
    long l=scn.nextLong();
    long val=1+(l+k-1)/m ;
    long c=val*m ;
    if(c>n){
      System.out.println(-1);
    }
    else {
      System.out.println(val);
    }
  }
  public static boolean isPrime(int n){
    boolean ans=true ;
    for(int i=2 ; i*i<=n ; i++){
      if(n % i==0){
        ans=false ;
        break ;
      }
    }
    if(ans==true)return true ;
    else return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ques1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := scn.getCurrent()->toLong() ;
    var m : long ; m := scn.getCurrent()->toLong() ;
    var k : long ; k := scn.getCurrent()->toLong() ;
    var l : long ; l := scn.getCurrent()->toLong() ;
    var val : long ; val := 1 + (l + k - 1) / m ;
    var c : long ; c := val * m ;
    if (c > n) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(val) ) ;  
 );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     var ans : boolean ; ans := true ;
         var i : int ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     ans := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (ans = true) then     return true else     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayList<Integer>array=new ArrayList<>();
    int number=sc.nextInt();
    for(int i=0 ; i<number ; i++){
      array.add(sc.nextInt());
    }
    int total=0 ;
    for(int i=0 ; i<array.size(); i++){
      for(int j=1+i ; j<array.size(); j++){
        total+=array.get(i)*array.get(j);
      }
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var array : Sequence(int) ; array := Sequence{} ;
    var number : int ; number := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < number do ( (     array := array->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < array->size() do ( (         var j : int ; j := 1 + i ; while j < array->size() do ( (     total := total+(array->at(i+1) * array->at(j+1)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer root ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(root==null || ! root.hasMoreTokens()){
        try {
          root=new StringTokenizer(br.readLine());
        }
        catch(Exception r){
          r.printStackTrace();
        }
      }
      return root.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(Exception r){
        r.printStackTrace();
      }
      return str ;
    }
  }
  public static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
  static long mod=(long)(1e9+7);
  static long cf=998244353 ;
  static final int MAX=100000 ;
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    int[] a=new int[n];
    long sum=0 ;
    for(int i=0 ; i<n ; ++i){
      a[i]=sc.nextInt();
      sum+=a[i];
    }
    long ans=0 ;
    for(int i=0 ; i<n ; ++i){
      sum-=a[i];
      ans+=a[i]*sum ;
    }
    out.print(ans);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute root : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (root = null or not(root.hasNext())) do (     try (     root := OclIterator.newOclIterator_String(br.readLine()) )   catch (r : ProgramException) do (     r.printStackTrace() )
 ) ; 
     return root.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (r : ProgramException) do (     r.printStackTrace() )
     return str );
}
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute mod : long := (1e9 + 7)->oclAsType(long);
  static   attribute cf : long := 998244353;
  static    attribute MAX : int := 100000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : int ; n := sc.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.nextInt() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum-(a[i+1]) ; 
     ans := ans+(a[i+1] * sum) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class Main {
  public static void main(String[] args)throws Exception {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader reader=new BufferedReader(is);
    List<String>mylist=new ArrayList<>();
    String strinput=reader.readLine();
    while(strinput!=null){
      mylist.add(strinput);
      strinput=reader.readLine();
    }
    String arr01[]=mylist.get(0).split(" ");
    String arr02[]=mylist.get(1).split(" ");
    int n=Integer.valueOf(arr01[0]);
    int mysum=0 ;
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        mysum+=Integer.valueOf(arr02[i])*Integer.valueOf(arr02[j]);
      }
    }
    System.out.println(mysum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(is) ;
    var mylist : Sequence(String) ; mylist := Sequence{} ;
    var strinput : String ; strinput := reader.readLine() ;
    while (strinput /= null) do (     mylist := mylist->including(strinput) ; 
     strinput := reader.readLine() ) ; 
    var arr01 : Sequence(String) ; arr01 := mylist->at(0+1)->split(" ") ;
    var arr02 : Sequence(String) ; arr02 := mylist->at(1+1)->split(" ") ;
    var n : int ; n := (arr01[0+1])->toInteger() ;
    var mysum : int ; mysum := 0 ;
        var i : int ; i := 0 ; while i < (n)->char2byte() - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     mysum := mysum+((arr02[i+1])->toInteger() * (arr02[j+1])->toInteger()) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(mysum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int count=0 ;
    boolean sw=false ;
    int max=Integer.MIN_VALUE ;
    int min=Integer.MAX_VALUE ;
    double dMax=Double.MIN_VALUE ;
    double dMin=Double.MAX_VALUE ;
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int d[]=new int[n];
    for(int i=0 ; i<n ; ++i)d[i]=sc.nextInt();
    int ans=0 ;
    for(int i=0 ; i<n ; ++i){
      for(int j=0 ; j<n ; ++j){
        if(j==i)continue ;
        ans+=d[i]*d[j];
      }
    }
    ans/=2 ;
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var sw : boolean ; sw := false ;
    var max : int ; max := -2147483648 ;
    var min : int ; min := 2147483647 ;
    var dMax : double ; dMax := 2->pow(-1074) ;
    var dMin : double ; dMin := (2 - 2->pow(-52))*(2->pow(1023)) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     d[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (j = i) then     continue else skip ; 
     ans := ans+(d[i+1] * d[j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    ans := ans/(2) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=sc.nextInt();
    }
    int total=0 ;
    for(int i=0 ; i<arr.length ; i++){
      for(int j=i+1 ; j<arr.length ; j++){
        total+=arr[i]*arr[j];
      }
    }
    System.out.println(total);
    bw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (         var j : int ; j := i + 1 ; while j < arr->size() do ( (     total := total+(arr[i+1] * arr[j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class B {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(f.readLine());
    int t=Integer.parseInt(st.nextToken());
    for(int i=0 ; i<t ; i++){
      st=new StringTokenizer(f.readLine());
      solve(Integer.parseInt(st.nextToken()),Integer.parseInt(st.nextToken()),Integer.parseInt(st.nextToken()),Integer.parseInt(st.nextToken()),Integer.parseInt(st.nextToken()));
    }
  }
  static void solve(int n,int u,int r,int d,int l){
    for(int i=0 ; i<2 ; i++){
      for(int j=0 ; j<2 ; j++){
        for(int k=0 ; k<2 ; k++){
          for(int m=0 ; m<2 ; m++){
            int u1=i+j ;
            int r1=k+j ;
            int d1=k+m ;
            int l1=i+m ;
            if(u>=u1 && u-u1<=n-2){
              if(l>=l1 && l-l1<=n-2){
                if(d>=d1 && d-d1<=n-2){
                  if(r>=r1 && r-r1<=n-2){
                    System.out.println("YES");
                    return ;
                  }
                }
              }
            }
          }
        }
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
     var t : int ; t := (st.next())->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     st := OclIterator.newOclIterator_String(f.readLine()) ; 
     execute solve((st.next())->toInteger(), (st.next())->toInteger(), (st.next())->toInteger(), (st.next())->toInteger(), (st.next())->toInteger()) )  ;     i := i + 1 ) );
  static   operation solve( n : int, u : int, r : int, d : int, l : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 2 do ( (         var j : int ; j := 0 ; while j < 2 do ( (         var k : int ; k := 0 ; while k < 2 do ( (         var m : int ; m := 0 ; while m < 2 do ( (     var u1 : int ; u1 := i + j ;
     var r1 : int ; r1 := k + j ;
    var d1 : int ; d1 := k + m ;
    var l1 : int ; l1 := i + m ;
    if (u >= u1 & u - u1 <= n - 2) then (     if (l >= l1 & l - l1 <= n - 2) then (     if (d >= d1 & d - d1 <= n - 2) then (     if (r >= r1 & r - r1 <= n - 2) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ) else skip ) else skip ; 
 )  ;     m := m + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("NO") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int number_of_teams(int M){
    int N1,N2,sqr ;
    sqr=(int)Math.sqrt(1+(8*M));
    N1=(1+sqr)/2 ;
    N2=(1-sqr)/2 ;
    if(N1>0)return N1 ;
    return N2 ;
  }
  public static void main(String[] args){
    int M=45 ;
    System.out.println(number_of_teams(M));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation number_of_teams( M : int) : int
  pre: true
  post: true
  activity: (     var N1 : int ;
    var N2 : int ;
    var sqr : int ;
     sqr := (1 + (8 * M))->sqrt()->oclAsType(int) ; 
    N1 := (1 + sqr) / 2 ; 
    N2 := (1 - sqr) / 2 ; 
    if (N1 > 0) then     return N1 else skip ; 
    return N2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var M : int ; M := 45 ;
     OclFile["System.out"].println(number_of_teams(M)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solveA();
  }
  private void solveA(){
    Scanner sc=new Scanner(System.in);
    char nums[]=sc.nextLine().toCharArray();
    int five=0 ;
    int seven=0 ;
    for(char c : nums){
      if(Character.getNumericValue(c)==5){
        five++;
      }
      else if(Character.getNumericValue(c)==7){
        seven++;
      }
    }
    if(five==2 && seven==1){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
  private void solveB(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println(N);
  }
  private void solveC(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println(N);
  }
  private void solveD(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println(N);
  }
  private void solveE(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println(N);
  }
  private void solveF(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solveA() );
   operation solveA() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var nums : Sequence(String) ; nums := sc.nextLine()->characters() ;
    var five : int ; five := 0 ;
    var seven : int ; seven := 0 ;
    for (c : nums) do ( (     if (("" + c)->toInteger() = 5) then (     five := five + 1 ) else     if (("" + c)->toInteger() = 7) then (     seven := seven + 1 ) else skip ; )  ) ; 
    if (five = 2 & seven = 1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
   operation solveB() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N) );
   operation solveC() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N) );
   operation solveD() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N) );
   operation solveE() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N) );
   operation solveF() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Node {
    int data ;
    Node next ;
  };
  static Node addToEmpty(Node head,int data){
    if(head!=null)return head ;
    Node temp=new Node();
    temp.data=data ;
    head=temp ;
    head.next=head ;
    return head ;
  }
  static Node addBegin(Node head,int data){
    if(head==null)return addToEmpty(head,data);
    Node temp=new Node();
    temp.data=data ;
    temp.next=head.next ;
    head.next=temp ;
    return head ;
  }
  static void traverse(Node head){
    Node p ;
    if(head==null){
      System.out.print("List is empty.");
      return ;
    }
    p=head ;
    do {
      System.out.print(p.data+" ");
      p=p.next ;
    }
    while(p!=head);
  }
  static Node exchangeNodes(Node head){
    Node p=head ;
    while(p.next.next!=head)p=p.next ;
    p.next.next=head.next ;
    head.next=p.next ;
    p.next=head ;
    head=head.next ;
    return head ;
  }
  public static void main(String args[]){
    int i ;
    Node head=null ;
    head=addToEmpty(head,6);
    for(i=5 ; i>0 ; i--)head=addBegin(head,i);
    System.out.print("List Before: ");
    traverse(head);
    System.out.println();
    System.out.print("List After: ");
    head=exchangeNodes(head);
    traverse(head);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   operation addToEmpty( head : Node, data : int) : Node
  pre: true
  post: true
  activity: (     if (head /= null) then     return head else skip ; 
     var temp : Node ; temp := Node.newNode() ;
    temp.data := data ; 
    head := temp ; 
    head.next := head ; 
    return head 
 );
  static   operation addBegin( head : Node, data : int) : Node
  pre: true
  post: true
  activity: (     if (head = null) then     return addToEmpty(head, data) else skip ; 
     var temp : Node ; temp := Node.newNode() ;
    temp.data := data ; 
    temp.next := head.next ; 
    head.next := temp ; 
    return head 
 );
  static   operation traverse( head : Node) : void
  pre: true
  post: true
  activity: (     var p : Node ;
     if (head = null) then (     OclFile["System.out"].print("List is empty.") ; 
     return ) else skip ; 
     p := head ; 
   while true do ((     OclFile["System.out"].print(p.data + " ") ; 
     p := p.next ) ;
    if (p /= head) then skip else break) );
  static   operation exchangeNodes( head : Node) : Node
  pre: true
  post: true
  activity: (     var p : Node ; p := head ;
     while (p.next.next /= head) do     p := p.next ; ; 
    p.next.next := head.next ; 
    head.next := p.next ; 
    p.next := head ; 
    head := head.next ; 
    return head 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
     var head : Node ; head := null ;
    head := addToEmpty(head, 6) ; 
        i := 5 ; while i > 0 do (     head := addBegin(head, i) ;  ;     i := i - 1 ) ; 
    OclFile["System.out"].print("List Before: ") ; 
    execute traverse(head) ; 
    OclFile["System.out"].println() ; 
    OclFile["System.out"].print("List After: ") ; 
    head := exchangeNodes(head) ; 
    execute traverse(head) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static double circlearea(double a){
    if(a<0)return-1 ;
    double A=(3.14*3*Math.pow(a,2))/4 ;
    return A ;
  }
  public static void main(String arr[]){
    double a=4 ;
    System.out.println(circlearea(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation circlearea( a : double) : double
  pre: true
  post: true
  activity: (     if (a < 0) then     return -1 else skip ; 
     var A : double ; A := (3.14 * 3 * a->pow(2)) / 4 ;
     return A );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 4 ;
     OclFile["System.out"].println(circlearea(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int search(int ar[],int size){
    int a=0,b=size-1 ;
    int mid=0 ;
    while((b-a)>1){
      mid=(a+b)/2 ;
      if((ar[a]-a)!=(ar[mid]-mid))b=mid ;
      else if((ar[b]-b)!=(ar[mid]-mid))a=mid ;
    }
    return(ar[mid]+1);
  }
  public static void main(String[] args){
    int ar[]={
      1,2,3,4,5,6,8 };
      int size=ar.length ;
      System.out.println("Missing number: "+search(ar,size));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation search( ar : Sequence(int), size : int) : int
  pre: true
  post: true
  activity: (     var a : int ; a := 0 ;
    var b : int ; b := size - 1 ;
     var mid : int ; mid := 0 ;
     while ((b - a) > 1) do (     mid := (a + b) / 2 ; 
     if ((ar[a+1] - a) /= (ar[mid+1] - mid)) then     b := mid ; else     if ((ar[b+1] - b) /= (ar[mid+1] - mid)) then     a := mid ; else skip ; ) ; 
     return (ar[mid+1] + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ar : Sequence(int) ; ar := Sequence{1,2,3,4,5,6,8} ;
     var size : int ; size := ar->size() ;
     OclFile["System.out"].println("Missing number: " + search(ar, size)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.math.BigInteger ;
public class Birthday {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    String[] temp=br.readLine().split(" ");
    long n=Long.parseLong(temp[0]);
    long m=Long.parseLong(temp[1]);
    long k=Long.parseLong(temp[2]);
    long l=Long.parseLong(temp[3]);
    if(k+l>n){
      pr.println(-1);
      return ;
    }
    long req=k+l ;
    long min=req/m+(req % m==0 ? 0 : 1);
    BigInteger x=new BigInteger(String.valueOf(min));
    BigInteger M=new BigInteger((String.valueOf(m)));
    BigInteger pro=x.multiply(M);
    BigInteger N=new BigInteger(String.valueOf(n));
    if(pro.compareTo(N)==1){
      pr.println(-1);
      return ;
    }
    pr.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Birthday {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
     var n : long ; n := (temp[0+1])->toLong() ;
    var m : long ; m := (temp[1+1])->toLong() ;
    var k : long ; k := (temp[2+1])->toLong() ;
    var l : long ; l := (temp[3+1])->toLong() ;
    if (k + l > n) then (     skip ; 
     return ) else skip ; 
    var req : long ; req := k + l ;
    var min : long ; min := req / m + (if req mod m = 0 then 0 else 1 endif) ;
    var x : long ; x := long(((min) + "")) ;
    var M : long ; M := long((((m) + ""))) ;
    var pro : long ; pro := x.multiply(M) ;
    var N : long ; N := long(((n) + "")) ;
    if (pro->compareTo(N) = 1) then (     skip ; 
     return ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class fiverow {
  static char[][] board ;
  public static void main(String[] args){
    board=new char[10][10];
    Scanner s=new Scanner(System.in);
    boolean done=false ;
    for(int i=0 ; i<10 ; i++){
      String temp=s.next();
      for(int j=0 ; j<10 ; j++){
        board[i][j]=temp.charAt(j);
      }
    }
    for(int i=0 ; i<10 ; i++){
      for(int j=0 ; j<10 ; j++){
        if(board[i][j]=='X'){
          if(traverse(i,j,-1,0)|| traverse(i,j,1,0)|| traverse(i,j,0,-1)|| traverse(i,j,0,1)|| traverse(i,j,-1,-1)|| traverse(i,j,1,-1)|| traverse(i,j,1,1)|| traverse(i,j,-1,1)){
            System.out.println("YES");
            done=true ;
            break ;
          }
        }
      }
      if(done)break ;
    }
    if(! done)System.out.println("NO");
  }
  public static boolean traverse(int x,int y,int dx,int dy){
    int count=0 ;
    boolean empty=false ;
    while(x>=0 && x<10 && y>=0 && y<10){
      if(x+dx>=0 && y+dy>=0 && x+dx<10 && y+dy<10 && board[x+dx][y+dy]=='X')count++;
      else if(x+dx>=0 && y+dy>=0 && x+dx<10 && y+dy<10 && board[x+dx][y+dy]=='.' && ! empty){
        count++;
        empty=true ;
      }
      else break ;
      x+=dx ;
      y+=dy ;
    }
    if(count==4)return true ;
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class fiverow {
  static   attribute board : Sequence(Sequence(String));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     board := Integer.subrange(1,10)->collect(Integer.subrange(1,10)->collect(0)) ; 
     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var done : boolean ; done := false ;
        var i : int ; i := 0 ; while i < 10 do ( (     var temp : String ; temp := s.getCurrent() ;
         var j : int ; j := 0 ; while j < 10 do ( (     board[i+1][j+1] := temp->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < 10 do ( (     if (board[i+1][j+1] = 'X') then (     if (traverse(i, j, -1, 0) or traverse(i, j, 1, 0) or traverse(i, j, 0, -1) or traverse(i, j, 0, 1) or traverse(i, j, -1, -1) or traverse(i, j, 1, -1) or traverse(i, j, 1, 1) or traverse(i, j, -1, 1)) then (     OclFile["System.out"].println("YES") ; 
     done := true ; 
     break ) else skip ) else skip )  ;     j := j + 1 ) ; 
     if (done) then     break else skip )  ;     i := i + 1 ) ; 
    if (not(done)) then     OclFile["System.out"].println("NO") ; else skip ; 
 );
  static   operation traverse( x : int, y : int, dx : int, dy : int) : boolean
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var empty : boolean ; empty := false ;
    while (x >= 0 & x < 10 & y >= 0 & y < 10) do (     if (x + dx >= 0 & y + dy >= 0 & x + dx < 10 & y + dy < 10 & board[x + dx+1][y + dy+1] = 'X') then     count := count + 1 else     if (x + dx >= 0 & y + dy >= 0 & x + dx < 10 & y + dy < 10 & board[x + dx+1][y + dy+1] = '.' & not(empty)) then (     count := count + 1 ; 
     empty := true ) else     break ;  ;  
     x := x+(dx) ; 
     y := y+(dy) ) ; 
    if (count = 4) then     return true else skip ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPerfectCube(int x){
    long cr=Math.round(Math.cbrt(x));
    return(cr*cr*cr==x);
  }
  static void checkCube(int a,int b){
    String s1=Integer.toString(a);
    String s2=Integer.toString(b);
    int c=Integer.parseInt(s1+s2);
    if(isPerfectCube(c)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
  public static void main(String[] args){
    int a=6 ;
    int b=4 ;
    checkCube(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPerfectCube( x : int) : boolean
  pre: true
  post: true
  activity: (     var cr : long ; cr := ((x)->cbrt())->round() ;
     return (cr * cr * cr = x) );
  static   operation checkCube( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := ((a) + "") ;
     var s2 : String ; s2 := ((b) + "") ;
     var c : int ; c := (s1 + s2)->toInteger() ;
     if (isPerfectCube(c)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 6 ;
     var b : int ; b := 4 ;
     execute checkCube(a, b) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    for(int i=0 ; i<1000 ; ++i){
      System.out.println("Hello World");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 1000 do ( (     OclFile["System.out"].println("Hello World") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Collections ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String input=br.readLine();
    for(int i=0 ; i<1000 ; i++){
      System.out.println("Hello World");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : String ; input := br.readLine() ;
         var i : int ; i := 0 ; while i < 1000 do ( (     OclFile["System.out"].println("Hello World") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public static void main(String[] args){
    final String str="Hello World" ;
    final int max=1000 ;
    for(int i=0 ; i<max ; i++){
      System.out.println(str);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "Hello World" ;
     var max : int ; max := 1000 ;
         var i : int ; i := 0 ; while i < max do ( (     OclFile["System.out"].println(str) )  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    for(int i=0 ; i<1000 ; i++){
      System.out.println("Hello World");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var i : int ; i := 0 ; while i < 1000 do ( (     OclFile["System.out"].println("Hello World") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long mod=(long)(1e9+7);
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int a[]=new int[6];
    int sum=0 ;
    for(int i=0 ; i<6 ; i++){
      a[i]=in.nextInt();
      sum+=a[i];
    }
    boolean flag=false ;
    for(int i=0 ; i<4 ; i++){
      for(int j=i+1 ; j<5 ; j++){
        for(int k=j+1 ; k<6 ; k++){
          int s=a[i]+a[j]+a[k];
          if(sum-s==s){
            flag=true ;
            break ;
          }
        }
      }
    }
    if(flag){
      pw.println("YES");
    }
    else {
      pw.println("NO");
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := (1e9 + 7)->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : Sequence(int) ; a := Integer.subrange(1,6)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 6 do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := i + 1 ; while j < 5 do ( (         var k : int ; k := j + 1 ; while k < 6 do ( (     var s : int ; s := a[i+1] + a[j+1] + a[k+1] ;
     if (sum - s = s) then (     flag := true ; 
     break ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (flag) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public static void main(String[] args){
    int L=0 ;
    while(L<1000){
      System.out.println("Hello World");
      L++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 0 ;
     while (L < 1000) do (     OclFile["System.out"].println("Hello World") ; 
     L := L + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
class GFG {
  static int countNum(int arr[],int n){
    HashSet<Integer>s=new HashSet<>();
    int count=0,maxm=Integer.MIN_VALUE,minm=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      s.add(arr[i]);
      if(arr[i]<minm)minm=arr[i];
      if(arr[i]>maxm)maxm=arr[i];
    }
    for(int i=minm ; i<=maxm ; i++)if(! s.contains(i))count++;
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      3,5,8,6 };
      int n=arr.length ;
      System.out.println(countNum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countNum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
     var count : int ; count := 0 ;
    var maxm : int ; maxm := -2147483648 ;
    var minm : int ; minm := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     s := s->including(arr[i+1]) ; 
     if (arr[i+1] < minm) then     minm := arr[i+1] ; else skip ; 
     if (arr[i+1] > maxm) then     maxm := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := minm ; while i <= maxm do (     if (not(s->includes(i))) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,5,8,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countNum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder s1=new StringBuilder(sc.next());
    StringBuilder s2=new StringBuilder();
    int n=sc.nextInt();
    int rev=0 ;
    for(int i=0 ; i<n ; i++){
      int q=sc.nextInt();
      if(q==1){
        rev=1-rev ;
      }
      else {
        int f=sc.nextInt();
        String c=sc.next();
        if(f==1 && rev==0 || f==2 && rev==1){
          s2.append(c);
        }
        else {
          s1.append(c);
        }
      }
    }
    if(rev==0){
      System.out.println(s2.reverse().append(s1));
    }
    else {
      System.out.println(s2.reverse().append(s1).reverse());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := StringLib.newString(sc.getCurrent()) ;
    var s2 : String ; s2 := StringLib.newString() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var rev : int ; rev := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var q : int ; q := sc.getCurrent()->toInteger() ;
     if (q = 1) then (     rev := 1 - rev ) else (     var f : int ; f := sc.getCurrent()->toInteger() ;
     var c : String ; c := sc.getCurrent() ;
     if (f = 1 & rev = 0 or f = 2 & rev = 1) then (     s2 := s2 + StringLib.newString(c) ) else (     s1 := s1 + StringLib.newString(c) ) ) )  ;     i := i + 1 ) ; 
    if (rev = 0) then (     OclFile["System.out"].println(s2->reverse() + StringLib.newString(s1)) ) else (     OclFile["System.out"].println(s2->reverse() + StringLib.newString(s1)->reverse()) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.ArrayDeque ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    DStringFormation solver=new DStringFormation();
    solver.solve(1,in,out);
    out.close();
  }
  static class DStringFormation {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      String s=in.next();
      ArrayDeque<String>ad=new ArrayDeque<>();
      boolean isFirst=true ;
      ad.addLast(s);
      int q=in.nextInt();
      for(int i=0 ; i<q ; i++){
        int num=in.nextInt();
        if(num==1){
          isFirst=! isFirst ;
        }
        else {
          boolean fir=in.nextInt()==1 ;
          String t=in.next();
          if(fir ^ isFirst){
            ad.addLast(t);
          }
          else {
            ad.addFirst(t);
          }
        }
      }
      StringBuffer sb=new StringBuffer();
      while(! ad.isEmpty()){
        sb.append(ad.pollFirst());
      }
      if(isFirst){
        out.println(sb.toString());
      }
      else {
        out.println(sb.reverse().toString());
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : DStringFormation ; solver := DStringFormation.newDStringFormation() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class DStringFormation {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.getCurrent() ;
     var ad : Sequence(String) ; ad := ArrayDeque<OclAny>.newArrayDeque() ;
    var isFirst : boolean ; isFirst := true ;
    ad := ad->append(s) ; 
    var q : int ; q := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var num : int ; num := in.getCurrent()->toInteger() ;
     if (num = 1) then (     isFirst := not(isFirst) ) else (     var fir : boolean ; fir := in.getCurrent()->toInteger() = 1 ;
     var t : String ; t := in.getCurrent() ;
     if (MathLib.bitwiseXor(fir,isFirst)) then (     ad := ad->append(t) ) else (     ad := ad->prepend(t) ) ) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    while (not(ad->isEmpty())) do (     sb := sb + StringLib.newString(ad->first()) ) ; 
    if (isFirst) then (     skip ) else (     skip ) ;  
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findRoots(int b,int c){
    int a=1 ;
    int d=b*b-4*a*c ;
    double sqrt_val=Math.sqrt(Math.abs(d));
    if(d>0){
      double x=-b+sqrt_val ;
      double y=-b-sqrt_val ;
      int root1=(int)(x)/(2*a);
      int root2=(int)(y)/(2*a);
      if(root1+root2==-1*b && root1*root2==c)System.out.print(root1+","+root2);
      else System.out.print(-1);
    }
    else if(d==0){
      int root=-b/(2*a);
      if(root+root==-1*b && root*root==c)System.out.print(root+","+root);
      else System.out.print(-1);
    }
    else {
      System.out.print(-1);
    }
    System.out.println();
  }
  public static void main(String[] args){
    int S=5,P=6 ;
    findRoots(-S,P);
    S=5 ;
    P=9 ;
    findRoots(-S,P);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findRoots( b : int, c : int) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 1 ;
     var d : int ; d := b * b - 4 * a * c ;
    var sqrt_val : double ; sqrt_val := (if d < 0 then -(d) else d endif)->sqrt() ;
    if (d > 0) then (     var x : double ; x := -b + sqrt_val ;
     var y : double ; y := -b - sqrt_val ;
    var root1 : int ; root1 := (x)->oclAsType(int) / (2 * a) ;
    var root2 : int ; root2 := (y)->oclAsType(int) / (2 * a) ;
    if (root1 + root2 = -1 * b & root1 * root2 = c) then     OclFile["System.out"].print(root1 + "," + root2) else     OclFile["System.out"].print(-1) ; ;  
 ) else     if (d = 0) then (     var root : int ; root := -b / (2 * a) ;
     if (root + root = -1 * b & root * root = c) then     OclFile["System.out"].print(root + "," + root) ; else     OclFile["System.out"].print(-1) ; ) else (     OclFile["System.out"].print(-1) ) ;  ;  
    OclFile["System.out"].println() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : int ; S := 5 ;
    var P : int ; P := 6 ;
     execute findRoots(-S, P) ; 
    S := 5 ; 
    P := 9 ; 
    execute findRoots(-S, P) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s=br.readLine();
    StringBuilder left=new StringBuilder();
    StringBuilder right=new StringBuilder();
    int q=Integer.parseInt(br.readLine());
    int reverse=0 ;
    for(int i=0 ; i<q ; i++){
      String[] query=br.readLine().split(" ");
      if("1".equals(query[0])){
        reverse=(reverse+1)% 2 ;
      }
      else {
        if(("1".equals(query[1])&& reverse==0)||("2".equals(query[1])&& reverse==1)){
          left.insert(0,query[2]);
        }
        else {
          right.append(query[2]);
        }
      }
    }
    br.close();
    String str=left.toString()+s+right.toString();
    if(reverse==0){
      System.out.println(str);
    }
    else {
      System.out.println(new StringBuilder(str).reverse().toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := br.readLine() ;
    var left : String ; left := StringLib.newString() ;
    var right : String ; right := StringLib.newString() ;
    var q : int ; q := (br.readLine())->toInteger() ;
    var reverse : int ; reverse := 0 ;
        var i : int ; i := 0 ; while i < q do ( (     var query : Sequence(String) ; query := br.readLine()->split(" ") ;
     if ("1" = query[0+1]) then (     reverse := (reverse + 1) mod 2 ) else (     if (("1" = query[1+1] & reverse = 0) or ("2" = query[1+1] & reverse = 1)) then (     left := left.insertAt(0+1, StringLib.newString(query[2+1])) ) else (     right := right + StringLib.newString(query[2+1]) ) ) )  ;     i := i + 1 ) ; 
    skip ; 
    var str : String ; str := left+"" + s + right+"" ;
    if (reverse = 0) then (     OclFile["System.out"].println(str) ) else (     OclFile["System.out"].println(StringLib.newString(str)->reverse()+"") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static long q ;
  static String s ;
  static String t ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    s=sc.next();
    q=sc.nextInt();
    t="" ;
    StringBuffer sbs=new StringBuffer(s);
    StringBuffer sbt=new StringBuffer(t);
    StringBuffer tmp ;
    for(int i=0 ; i<q ; i++){
      if(sc.nextInt()==1){
        tmp=sbs ;
        sbs=sbt ;
        sbt=tmp ;
      }
      else {
        if(sc.nextInt()==1){
          sbt.append(sc.next());
        }
        else {
          sbs.append(sc.next());
        }
      }
    }
    System.out.println(sbt.reverse().append(sbs));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute q : long;
  static   attribute s : String;
  static   attribute t : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     s := sc.getCurrent() ; 
    q := sc.getCurrent()->toInteger() ; 
    t := "" ; 
    var sbs : String ; sbs := StringLib.newString(s) ;
    var sbt : String ; sbt := StringLib.newString(t) ;
    var tmp : String ;
        var i : int ; i := 0 ; while i < q do ( (     if (sc.getCurrent()->toInteger() = 1) then (     tmp := sbs ; 
     sbs := sbt ; 
     sbt := tmp ) else (     if (sc.getCurrent()->toInteger() = 1) then (     sbt := sbt + StringLib.newString(sc.getCurrent()) ) else (     sbs := sbs + StringLib.newString(sc.getCurrent()) ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sbt->reverse() + StringLib.newString(sbs)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader in=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(in);
    StringBuilder sb=new StringBuilder(br.readLine());
    int q=Integer.parseInt(br.readLine());
    String A=new String();
    int orderFlg=0 ;
    StringBuilder sb0=new StringBuilder();
    StringBuilder sb1=new StringBuilder();
    StringBuilder sb2=new StringBuilder();
    A=sb.toString();
    for(int i=0 ; i<q ; i++){
      String tmp=br.readLine();
      if(tmp.length()==1){
        orderFlg++;
      }
      else {
        String data=tmp.substring(tmp.length()-1);
        if(tmp.contains("1")){
          if(orderFlg % 2==0){
            sb1.insert(0,data);
          }
          else {
            sb2.append(data);
          }
        }
        else {
          if(orderFlg % 2==0){
            sb2.append(data);
          }
          else {
            sb1.insert(0,data);
          }
        }
      }
    }
    sb0.append(sb1+A+sb2);
    if((orderFlg>0)&&(orderFlg % 2==1)){
      sb0.reverse();
    }
    System.out.print(sb0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(in) ;
    var sb : String ; sb := StringLib.newString(br.readLine()) ;
    var q : int ; q := (br.readLine())->toInteger() ;
    var A : String ; A := StringLib.newString() ;
    var orderFlg : int ; orderFlg := 0 ;
    var sb0 : String ; sb0 := StringLib.newString() ;
    var sb1 : String ; sb1 := StringLib.newString() ;
    var sb2 : String ; sb2 := StringLib.newString() ;
    A := sb+"" ; 
        var i : int ; i := 0 ; while i < q do ( (     var tmp : String ; tmp := br.readLine() ;
     if (tmp->size() = 1) then (     orderFlg := orderFlg + 1 ) else (     var data : String ; data := tmp.subrange(tmp->size() - 1+1,tmp->size() - 1) ;
     if (tmp->includes("1")) then (     if (orderFlg mod 2 = 0) then (     sb1 := sb1.insertAt(0+1, StringLib.newString(data)) ) else (     sb2 := sb2 + StringLib.newString(data) ) ) else (     if (orderFlg mod 2 = 0) then (     sb2 := sb2 + StringLib.newString(data) ) else (     sb1 := sb1.insertAt(0+1, StringLib.newString(data)) ) ) ) )  ;     i := i + 1 ) ; 
    sb0 := sb0 + StringLib.newString(sb1 + A + sb2) ; 
    if ((orderFlg > 0) & (orderFlg mod 2 = 1)) then (     sb0 := sb0->reverse() ) else skip ; 
    OclFile["System.out"].print(sb0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
public class Solution {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int k=scan.nextInt();
    scan.nextLine();
    Map<Integer,Integer>count=new HashMap<>();
    String result="YES" ;
    for(int i=0 ; i<4 ; i++){
      String s=scan.nextLine();
      for(int j=0 ; j<4 ; j++){
        char ch=s.charAt(j);
        if(ch=='.')continue ;
        int num=Integer.parseInt(String.valueOf(ch));
        if(! count.containsKey(num)){
          count.put(num,0);
        }
        int c=count.get(num);
        if(c==2*k){
          result="NO" ;
          break ;
        }
        else {
          count.put(num,c+1);
        }
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := scan.getCurrent()->toInteger() ;
    skip ; 
    var count : Map(int,int) ; count := Map{} ;
    var result : String ; result := "YES" ;
        var i : int ; i := 0 ; while i < 4 do ( (     var s : String ; s := scan.nextLine() ;
         var j : int ; j := 0 ; while j < 4 do ( (     var ch : String ; ch := s->at(j+1) ;
     if (ch = '.') then     continue else skip ; 
    var num : int ; num := (((ch) + ""))->toInteger() ;
    if (not(count->keys()->includes(num))) then (     count := count->union(Map{num |-> 0}) ) else skip ; 
    var c : int ; c := count->at(num) ;
    if (c = 2 * k) then (     result := "NO" ; 
     break ) else (     count := count->union(Map{num |-> c + 1}) ) ;  
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import java.util.StringTokenizer ;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    FastReader fs=new FastReader();
    int l=fs.nextInt();
    HashMap<Integer,Integer>hs=new HashMap<>();
    for(int i=0 ; i<4 ; i++){
      String k=fs.nextLine();
      for(char ch : k.toCharArray()){
        if(ch>='0' && ch<='9'){
          hs.putIfAbsent((int)ch,0);
          hs.put((int)ch,hs.get((int)ch)+1);
        }
      }
    }
    boolean flag=true ;
    for(Integer key : hs.keySet()){
      if(hs.get(key)>l*2){
        flag=false ;
        break ;
      }
    }
    if(flag){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastReader ; fs := FastReader.newFastReader() ;
     var l : int ; l := fs.nextInt() ;
    var hs : Map(int,int) ; hs := Map{} ;
        var i : int ; i := 0 ; while i < 4 do ( (     var k : String ; k := fs.nextLine() ;
     for (ch : k->characters()) do ( (     if (ch >= '0' & ch <= '9') then (     if hs->keys()->includes(ch->oclAsType(int)) then skip else hs := hs->union(Map{ch->oclAsType(int) |-> 0}) ; 
     hs := hs->union(Map{ch->oclAsType(int) |-> hs->at(ch->oclAsType(int)) + 1}) ) else skip )  ) )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := true ;
    for (key : hs->keys()) do ( (     if (hs->at(key) > l * 2) then (     flag := false ; 
     break ) else skip )  ) ; 
    if (flag) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  private static int _popcnt32(long number){
    int counter=0 ;
    while(number>0){
      if(number % 2==1){
        counter++;
      }
      number=number/2 ;
    }
    return counter ;
  }
  static long maximize(long a){
    int n=_popcnt32(a);
    long res=0 ;
    for(int i=1 ; i<=n ; i++)res=(int)res |(1<<(32-i));
    return Math.abs(res);
  }
  public static void main(String args[]){
    long a=1 ;
    System.out.print(maximize(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation _popcnt32( number : long) : int
  pre: true
  post: true
  activity: (     var counter : int ; counter := 0 ;
     while (number > 0) do (     if (number mod 2 = 1) then (     counter := counter + 1 ) else skip ; 
     number := number / 2 ) ; 
     return counter );
  static   operation maximize( a : long) : long
  pre: true
  post: true
  activity: (     var n : int ; n := _popcnt32(a) ;
     var res : long ; res := 0 ;
         var i : int ; i := 1 ; while i <= n do (     res := MathLib.bitwiseOr(res->oclAsType(int),((1*(2->pow((32 - i))))->oclAsType(long))) ;  ;     i := i + 1 ) ; 
     return if res < 0 then -(res) else res endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ; a := 1 ;
     OclFile["System.out"].print(maximize(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class beats {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int k=in.nextInt();
    k=2*k ;
    String s[]=new String[4];
    for(int i=0 ; i<4 ; i++)s[i]=in.next();
    int n[]=new int[10];
    for(int i=0 ; i<4 ; i++){
      for(int j=0 ; j<4 ; j++){
        if(s[i] .charAt(j)>='0' && s[i] .charAt(j)<='9')n[s[i] .charAt(j)-48]++;
      }
    }
    boolean ans=true ;
    for(int i=1 ; i<10 ; i++)if(n[i]>k){
      ans=false ;
      break ;
    }
    if(ans)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class beats {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    k := 2 * k ; 
    var s : Sequence(String) ; s := Integer.subrange(1,4)->collect(null) ;
        var i : int ; i := 0 ; while i < 4 do (     s[i+1] := in.getCurrent() ;  ;     i := i + 1 ) ; 
    var n : Sequence(int) ; n := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < 4 do ( (     if (s[i+1]->at(j+1) >= '0' & s[i+1]->at(j+1) <= '9') then     n[s[i+1]->at(j+1) - 48+1] := n[s[i+1]->at(j+1) - 48+1] + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : boolean ; ans := true ;
        var i : int ; i := 1 ; while i < 10 do (     if (n[i+1] > k) then (     ans := false ; 
     break ) else skip ;  ;     i := i + 1 ) ; 
    if (ans) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication56 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    ArrayList<Integer>arr=new ArrayList<>();
    for(int i=0 ; i<4 ; i++){
      String h=sc.next();
      if(h.equals("....")){
      }
      else {
        for(int s=0 ; s<h.length(); s++){
          if(h.charAt(s)=='.'){
          }
          else {
            int k=Integer.parseInt(String.valueOf(h.charAt(s)));
            arr.add(k);
          }
        }
      }
    }
    if(arr.size()==0){
      System.out.println("YES");
    }
    else {
      Collections.sort(arr);
      int counter=1 ;
      int counte=0 ;
      int nm=arr.get(0);
      for(int i=1 ; i<arr.size(); i++){
        if(arr.get(i)==nm){
          counter++;
          if(counter>(num*2)){
            counte++;
          }
        }
        else {
          nm=arr.get(i);
          if(counter>(num*2)){
            counte++;
          }
          counter=1 ;
        }
      }
      if(counte>0){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication56 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < 4 do ( (     var h : String ; h := sc.getCurrent() ;
     if (h = "....") then skip else (         var s : int ; s := 0 ; while s < h->size() do ( (     if (h->at(s+1) = '.') then skip else (     var k : int ; k := (((h->at(s+1)) + ""))->toInteger() ;
     arr := arr->including(k) ) )  ;     s := s + 1 ) ) )  ;     i := i + 1 ) ; 
    if (arr->size() = 0) then (     OclFile["System.out"].println("YES") ) else (     arr := arr->sort() ; 
     var counter : int ; counter := 1 ;
    var counte : int ; counte := 0 ;
    var nm : int ; nm := arr->at(0+1) ;
        var i : int ; i := 1 ; while i < arr->size() do ( (     if (arr->at(i+1) = nm) then (     counter := counter + 1 ; 
     if (counter > (num * 2)) then (     counte := counte + 1 ) else skip ) else (     nm := arr->at(i+1) ; 
     if (counter > (num * 2)) then (     counte := counte + 1 ) else skip ; 
     counter := 1 ) )  ;     i := i + 1 ) ; 
    if (counte > 0) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int calculate(int ar[],int size){
    int count=0 ;
    for(int i=0 ; i<size ; i++)if(ar[i] % 2==0 && ar[i]!=0 && ar[i]!=2)count++;
    return count ;
  }
  public static void main(String[] args){
    int a[]={
      1,3,4,6 };
      int size=a.length ;
      System.out.print(calculate(a,size));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculate( ar : Sequence(int), size : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < size do (     if (ar[i+1] mod 2 = 0 & ar[i+1] /= 0 & ar[i+1] /= 2) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,3,4,6} ;
     var size : int ; size := a->size() ;
     OclFile["System.out"].print(calculate(a, size)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  void printArr(int b[],int n){
    for(int i=0 ; i<n ; i++){
      System.out.print(" "+b[i]+" ");
    }
  }
  void ModifiedArray(int a[],int n){
    int l=0,r=Integer.MAX_VALUE ;
    int[] b=new int[n];
    for(int i=0 ; i<n/2 ; i++){
      b[i]=Math.max(l,a[i]-r);
      b[n-i-1]=a[i]-b[i];
      l=b[i];
      r=b[n-i-1];
    }
    printArr(b,n);
  }
  public static void main(String args[]){
    int a[]={
      5,6 };
      int n=a.length ;
      solution s=new solution();
      s.ModifiedArray(a,2*n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution {
   operation printArr( b : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(" " + b[i+1] + " ") )  ;     i := i + 1 ) );
   operation ModifiedArray( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
    var r : int ; r := 2147483647 ;
     var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n / 2 do ( (     b[i+1] := Set{l, a[i+1] - r}->max() ; 
     b[n - i - 1+1] := a[i+1] - b[i+1] ; 
     l := b[i+1] ; 
     r := b[n - i - 1+1] )  ;     i := i + 1 ) ; 
     execute printArr(b, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{5,6} ;
     var n : int ; n := a->size() ;
     var s : solution ; s := solution.newsolution() ;
     s.ModifiedArray(a, 2 * n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class CountXor {
  static int countXorPair(int arr[],int n){
    int odd=0,even=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] % 2==0)even++;
      else odd++;
    }
    return odd*even ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3 };
      System.out.println(countXorPair(arr,arr.length));
    }
  }

------------------------------------------------------------
OCL File:
---------
class CountXor {
  static   operation countXorPair( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var odd : int ; odd := 0 ;
    var even : int ; even := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 = 0) then     even := even + 1 ; else     odd := odd + 1 ; )  ;     i := i + 1 ) ; 
     return odd * even );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3} ;
     OclFile["System.out"].println(countXorPair(arr, arr->size())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isShuffledSubString(String A,String B){
    int n=A.length();
    int m=B.length();
    if(n>m){
      return false ;
    }
    else {
      A=sort(A);
      for(int i=0 ; i<m ; i++){
        if(i+n-1>=m)return false ;
        String str="" ;
        for(int j=0 ; j<n ; j++)str+=B.charAt(i+j);
        str=sort(str);
        if(str.equals(A))return true ;
      }
    }
    return false ;
  }
  static String sort(String inputString){
    char tempArray[]=inputString.toCharArray();
    Arrays.sort(tempArray);
    return String.valueOf(tempArray);
  }
  public static void main(String[] args){
    String str1="geekforgeeks" ;
    String str2="ekegorfkeegsgeek" ;
    boolean a=isShuffledSubString(str1,str2);
    if(a)System.out.print("YES");
    else System.out.print("NO");
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isShuffledSubString( A : String, B : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := A->size() ;
     var m : int ; m := B->size() ;
     if (n > m) then (     return false ) else (     A := sort(A) ; 
         var i : int ; i := 0 ; while i < m do ( (     if (i + n - 1 >= m) then     return false else skip ; 
     var str : String ; str := "" ;
        var j : int ; j := 0 ; while j < n do (     str := str+(B->at(i + j+1)) ;  ;     j := j + 1 ) ; 
    str := sort(str) ; 
    if (str = A) then     return true else skip ; 
 )  ;     i := i + 1 ) ) ;  
     return false );
  static   operation sort( inputString : String) : String
  pre: true
  post: true
  activity: (     var tempArray : Sequence(String) ; tempArray := inputString->characters() ;
     tempArray := tempArray->sort() ; 
     return ((tempArray) + "") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "geekforgeeks" ;
     var str2 : String ; str2 := "ekegorfkeegsgeek" ;
    var a : boolean ; a := isShuffledSubString(str1, str2) ;
    if (a) then     OclFile["System.out"].print("YES") else     OclFile["System.out"].print("NO") ; ;  
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Sheet6ProblemB {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    boolean good=false ;
    for(int i=0 ; i<n ; i++)if(input.nextInt()==1){
      good=true ;
      break ;
    }
    System.out.println(good ? "-1" : "1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sheet6ProblemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var good : boolean ; good := false ;
        var i : int ; i := 0 ; while i < n do (     if (input.getCurrent()->toInteger() = 1) then (     good := true ; 
     break ) else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if good then "-1" else "1" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    boolean good=false ;
    for(int i=0 ; i<n ; i++)if(input.nextInt()==1){
      good=true ;
      break ;
    }
    System.out.println(good ? "-1" : "1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var good : boolean ; good := false ;
        var i : int ; i := 0 ; while i < n do (     if (input.getCurrent()->toInteger() = 1) then (     good := true ; 
     break ) else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if good then "-1" else "1" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long mod=(long)(1e9+7);
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int a[]=new int[n];
    boolean flag=false ;
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
      if(a[i]==1){
        flag=true ;
      }
    }
    if(flag){
      pw.println(-1);
    }
    else {
      pw.println(1);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := (1e9 + 7)->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     if (a[i+1] = 1) then (     flag := true ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int cnt_neg ;
  static boolean exists_zero ;
  static void preProcess(int[] arr,int n){
    for(int i=0 ; i<n ; i++){
      if(arr[i]<0)cnt_neg++;
      if(arr[i]==0)exists_zero=true ;
    }
  }
  static boolean isPossible(int k){
    if(! exists_zero){
      if(k>=cnt_neg &&(k-cnt_neg)% 2==0)return true ;
      else return false ;
    }
    else {
      if(k>=cnt_neg)return true ;
      else return false ;
    }
  }
  public static void main(String[] args){
    int arr[]={
-1,2,-3,4,5 };
      int n=arr.length ;
      preProcess(arr,n);
      int queries[]={
        1,2,3,4 };
        int q=arr.length ;
        for(int i=0 ; i<q ; i++){
          if(isPossible(queries[i]))System.out.println("Yes");
          else System.out.println("No");
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute cnt_neg : int;
  static   attribute exists_zero : boolean;
  static   operation preProcess( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] < 0) then     cnt_neg := cnt_neg + 1 ; else skip ; 
     if (arr[i+1] = 0) then     exists_zero := true ; else skip )  ;     i := i + 1 ) );
  static   operation isPossible( k : int) : boolean
  pre: true
  post: true
  activity: (     if (not(exists_zero)) then (     if (k >= cnt_neg & (k - cnt_neg) mod 2 = 0) then     return true else     return false ) else (     if (k >= cnt_neg) then     return true else     return false ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-1,2,-3,4,5} ;
     var n : int ; n := arr->size() ;
    execute preProcess(arr, n) ; 
    var queries : Sequence(int) ; queries := Sequence{1,2,3,4} ;
    var q : int ; q := arr->size() ;
        var i : int ; i := 0 ; while i < q do ( (     if (isPossible(queries[i+1])) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF_1712_A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int k=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      int counter=0 ;
      for(int i=k ; i<n ; i++){
        if(a[i]<=k)counter++;
      }
      System.out.println(counter);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF_1712_A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var counter : int ; counter := 0 ;
        var i : int ; i := k ; while i < n do ( (     if (a[i+1] <= k) then     counter := counter + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class Node {
    int data ;
    Node next ;
    Node(int data){
      this.data=data ;
      this.next=null ;
    }
  };
  static class treeNode {
    int data ;
    treeNode left ;
    treeNode right ;
    treeNode(int data){
      this.data=data ;
      this.left=null ;
      this.right=null ;
    }
  };
  static void print(Node head){
    if(head==null){
      return ;
    }
    Node temp=head ;
    while(temp!=null){
      System.out.print(temp.data+" ");
      temp=temp.next ;
    }
  }
  static Node sortedList(Node head,treeNode root){
    if(root==null){
      return head ;
    }
    head=sortedList(head,root.left);
    Node newNode=new Node(root.data);
    Node temp=head ;
    Node prev=null ;
    if(temp==null){
      head=newNode ;
    }
    else {
      while(temp!=null){
        if(temp.data>root.data){
          break ;
        }
        else {
          prev=temp ;
          temp=temp.next ;
        }
      }
      if(temp==null){
        prev.next=newNode ;
      }
      else {
        if(prev==null){
          newNode.next=temp ;
          head=newNode ;
        }
        else {
          newNode.next=temp ;
          prev.next=newNode ;
        }
      }
    }
    head=sortedList(head,root.right);
    return head ;
  }
  public static void main(String[] args){
    treeNode root=new treeNode(10);
    root.left=new treeNode(15);
    root.right=new treeNode(2);
    root.left.left=new treeNode(1);
    root.left.right=new treeNode(5);
    Node head=sortedList(null,root);
    print(head);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
   static operation newNode( data : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(data);
    return self );
  operation initialise( data : int) : void
  pre: true  post: true
  activity: (     self.data := data ; 
     self.next := null );
}
  static class treeNode {
   attribute data : int;
   attribute left : treeNode;
   attribute right : treeNode;
   static operation newtreeNode( data : int) : treeNode
  pre: true
  post: true
  activity:
  ( var self : treeNode ;
    self := createtreeNode();
    self.initialise(data);
    return self );
  operation initialise( data : int) : void
  pre: true  post: true
  activity: (     self.data := data ; 
     self.left := null ; 
     self.right := null );
}
  static   operation print( head : Node) : void
  pre: true
  post: true
  activity: (     if (head = null) then (     return ) else skip ; 
     var temp : Node ; temp := head ;
     while (temp /= null) do (     OclFile["System.out"].print(temp.data + " ") ; 
     temp := temp.next ) );
  static   operation sortedList( head : Node, root : treeNode) : Node
  pre: true
  post: true
  activity: (     if (root = null) then (     return head ) else skip ; 
     head := sortedList(head, root.left) ; 
    var newNode : Node ; newNode := Node.newNode(root.data) ;
    var temp : Node ; temp := head ;
    var prev : Node ; prev := null ;
    if (temp = null) then (     head := newNode ) else (     while (temp /= null) do (     if (temp.data > root.data) then (     break ) else (     prev := temp ; 
     temp := temp.next ) ) ; 
     if (temp = null) then (     prev.next := newNode ) else (     if (prev = null) then (     newNode.next := temp ; 
     head := newNode ) else (     newNode.next := temp ; 
     prev.next := newNode ) ) ) ;  
    head := sortedList(head, root.right) ; 
    return head 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var root : treeNode ; root := treeNode.newtreeNode(10) ;
     root.left := treeNode.newtreeNode(15) ; 
    root.right := treeNode.newtreeNode(2) ; 
    root.left.left := treeNode.newtreeNode(1) ; 
    root.left.right := treeNode.newtreeNode(5) ; 
    var head : Node ; head := sortedList(null, root) ;
    execute print(head) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int areCornerEqual(String s){
    int n=s.length();
    if(n<2)return-1 ;
    if(s.charAt(0)==s.charAt(n-1))return 1 ;
    else return 0 ;
  }
  public static void main(String[] args){
    String s="GfG" ;
    int res=areCornerEqual(s);
    if(res==-1)System.out.println("Invalid Input");
    else if(res==1)System.out.println("Equal");
    else System.out.println("Not Equal");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation areCornerEqual( s : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     if (n < 2) then     return -1 else skip ; 
     if (s->at(0+1) = s->at(n - 1+1)) then     return 1 else     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "GfG" ;
     var res : int ; res := areCornerEqual(s) ;
     if (res = -1) then     OclFile["System.out"].println("Invalid Input") ; else     if (res = 1) then     OclFile["System.out"].println("Equal") else     OclFile["System.out"].println("Not Equal") ; ;  );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final double EPSILON=0.001 ;
  static double func(double x){
    return x*x*x-x*x+2 ;
  }
  static double derivFunc(double x){
    return 3*x*x-2*x ;
  }
  static void newtonRaphson(double x){
    double h=func(x)/derivFunc(x);
    while(Math.abs(h)>=EPSILON){
      h=func(x)/derivFunc(x);
      x=x-h ;
    }
    System.out.print("The value of the"+" root is : "+Math.round(x*100.0)/100.0);
  }
  public static void main(String[] args){
    double x0=-20 ;
    newtonRaphson(x0);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute EPSILON : double := 0.001;
  static   operation func( x : double) : double
  pre: true
  post: true
  activity: (     return x * x * x - x * x + 2 );
  static   operation derivFunc( x : double) : double
  pre: true
  post: true
  activity: (     return 3 * x * x - 2 * x );
  static   operation newtonRaphson( x : double) : void
  pre: true
  post: true
  activity: (     var h : double ; h := func(x) / derivFunc(x) ;
     while (if h < 0 then -(h) else h endif >= EPSILON) do (     h := func(x) / derivFunc(x) ; 
     x := x - h ) ; 
     OclFile["System.out"].print("The value of the" + " root is : " + (x * 100.0)->round() / 100.0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x0 : double ; x0 := -20 ;
     execute newtonRaphson(x0) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class A {
  public static void main(String[] args)throws IOException {
    Scanner scanner=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=scanner.nextInt();
    int mx=Integer.MIN_VALUE ;
    Map<String,Integer>map=new HashMap<>();
    List<String>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      String name=scanner.next();
      int score=scanner.nextInt();
      Integer oldScore=map.get(name);
      int newScore=score ;
      if(oldScore!=null)newScore=oldScore+score ;
      map.put(name,newScore);
      list.add(name+":"+newScore);
    }
    for(Map.Entry<String,Integer>entry : map.entrySet()){
      if(entry.getValue()>mx){
        mx=entry.getValue();
      }
    }
    for(String round : list){
      String name=round.split(":")[0];
      int score=Integer.parseInt(round.split(":")[1]);
      if(score>=mx && mx==map.get(name)){
        out.println(name);
        out.flush();
        out.close();
        return ;
      }
    }
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var mx : int ; mx := -2147483648 ;
    var map : Map(String,int) ; map := Map{} ;
    var list : Sequence(String) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var name : String ; name := scanner.getCurrent() ;
     var score : int ; score := scanner.getCurrent()->toInteger() ;
    var oldScore : int ; oldScore := map->at(name) ;
    var newScore : int ; newScore := score ;
    if (oldScore /= null) then     newScore := oldScore + score ; else skip ; 
    map := map->union(Map{name |-> newScore}) ; 
    list := list->including(name + ":" + newScore) ; 
 )  ;     i := i + 1 ) ; 
    for (entry : map->asSet()) do ( (     if (entry.getValue() > mx) then (     mx := entry.getValue() ) else skip )  ) ; 
    for (round : list) do ( (     var name : String ; name := round->split(":")[0+1] ;
     var score : int ; score := (round->split(":")[1+1])->toInteger() ;
     if (score >= mx & mx = map->at(name)) then (     skip ; 
     skip ; 
     skip ; 
     return ) else skip )  ) ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int ans=Integer.MIN_VALUE ;
    Map<String,Integer>mp=new HashMap<>();
    int[] sum=new int[n];
    String[] s=new String[n];
    for(int i=0 ; i<n ; i++){
      s[i]=sc.next();
      sum[i]=sc.nextInt();
      if(mp.containsKey(s[i])){
        sum[i]+=mp.get(s[i]);
        mp.put(s[i],sum[i]);
      }
      else {
        mp.put(s[i],sum[i]);
      }
    }
    ans=Collections.max(mp.values());
    for(int i=0 ; i<n ; i++){
      if(ans==mp.get(s[i])&& sum[i]>=ans){
        System.out.println(s[i]);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := -2147483648 ;
    var mp : Map(String,int) ; mp := Map{} ;
    var sum : Sequence(int) ; sum := Integer.subrange(1,n)->collect(0) ;
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := sc.getCurrent() ; 
     sum[i+1] := sc.getCurrent()->toInteger() ; 
     if (mp->keys()->includes(s[i+1])) then (     sum[i+1] := sum[i+1]+(mp->at(s[i+1])) ; 
     mp := mp->union(Map{s[i+1] |-> sum[i+1]}) ) else (     mp := mp->union(Map{s[i+1] |-> sum[i+1]}) ) )  ;     i := i + 1 ) ; 
    ans :=  mp->values()->max() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (ans = mp->at(s[i+1]) & sum[i+1] >= ans) then (     OclFile["System.out"].println(s[i+1]) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(new InputStreamReader(new BufferedInputStream(System.in)));
    int n=in.nextInt(),num[]=new int[n+1];
    String s[]=new String[n+1];
    HashMap<String,Integer>mp=new HashMap<>(),mp2=new HashMap<>();
    for(int i=1 ; i<=n ; i++){
      String name=in.next();
      int tmp=in.nextInt();
      mp2.put(name,mp2.getOrDefault(name,0)+tmp);
      if(mp.containsKey(name)){
        int index=mp.get(name);
        num[i]=num[index]+tmp ;
      }
      else num[i]=tmp ;
      mp.put(name,i);
      s[i]=name ;
    }
    int ans=Collections.max(mp2.values());
    for(int i=1 ; i<=n ; i++){
      if(mp2.get(s[i])==ans && ans<=num[i]){
        System.out.print(s[i]);
        break ;
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var num : Sequence(void) ; num := Integer.subrange(1,n + 1)->collect(0) ;
    var s : Sequence(String) ; s := Integer.subrange(1,n + 1)->collect(null) ;
    var mp : Map(String,int) ; mp := Map{} ;
    var mp2 : Map(String,int) ; mp2 := Map{} ;
        var i : int ; i := 1 ; while i <= n do ( (     var name : String ; name := in.getCurrent() ;
     var tmp : int ; tmp := in.getCurrent()->toInteger() ;
    mp2 := mp2->union(Map{name |-> mp2->at(name, 0+1) + tmp}) ; 
    if (mp->keys()->includes(name)) then (     var index : int ; index := mp->at(name) ;
     num[i+1] := num[index+1] + tmp ) else     num[i+1] := tmp ; ;  
    mp := mp->union(Map{name |-> i}) ; 
    s[i+1] := name ; 
 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := .max(mp2.allInstances()) ;
        var i : int ; i := 1 ; while i <= n do ( (     if (mp2->at(s[i+1]+1) = ans & ans <= num[i+1]) then (     OclFile["System.out"].print(s[i+1]) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countSubArrays(int arr[],int n,int x){
    int len=0 ;
    int count=0 ;
    int binaryArr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      if(arr[i]<=x)binaryArr[i]=1 ;
      else binaryArr[i]=0 ;
    }
    for(int i=0 ; i<n ; i++){
      if(binaryArr[i]==1){
        int j ;
        for(j=i+1 ; j<n ; j++)if(binaryArr[j]!=1)break ;
        len=j-i ;
        count+=(len)*(len+1)/2 ;
        i=j ;
      }
    }
    return count ;
  }
  public static void main(String args[]){
    int arr[]={
      1,5,7,8,2,3,9 };
      int x=6 ;
      int n=arr.length ;
      System.out.println(countSubArrays(arr,n,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSubArrays( arr : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var len : int ; len := 0 ;
     var count : int ; count := 0 ;
    var binaryArr : Sequence(int) ; binaryArr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] <= x) then     binaryArr[i+1] := 1 ; else     binaryArr[i+1] := 0 ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (binaryArr[i+1] = 1) then (     var j : int ;
         j := i + 1 ; while j < n do (     if (binaryArr[j+1] /= 1) then     break else skip ;  ;     j := j + 1 ) ; 
    len := j - i ; 
    count := count+((len) * (len + 1) / 2) ; 
    i := j ; 
 ) else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,7,8,2,3,9} ;
     var x : int ; x := 6 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countSubArrays(arr, n, x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  static void printArr(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  static void generateArr(int arr[],int n){
    boolean flip=true ;
    for(int i=0 ; i<n ; i++){
      if((arr[i] & 1)!=0){
        if(flip ^=true)System.out.print((int)(Math.ceil(arr[i]/2.0))+" ");
        else System.out.print((int)(Math.floor(arr[i]/2.0))+" ");
      }
      else {
        System.out.print(arr[i]/2+" ");
      }
    }
  }
  public static void main(String[] args){
    int arr[]={
      3,-5,-7,9,2,-2 };
      int n=arr.length ;
      generateArr(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation generateArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var flip : boolean ; flip := true ;
         var i : int ; i := 0 ; while i < n do ( (     if ((arr[i+1] & 1) /= 0) then (     if (flip) then     OclFile["System.out"].print(((arr[i+1] / 2.0)->ceil())->oclAsType(int) + " ") ; else     OclFile["System.out"].print(((arr[i+1] / 2.0)->floor())->oclAsType(int) + " ") ; ) else (     OclFile["System.out"].print(arr[i+1] / 2 + " ") ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,-5,-7,9,2,-2} ;
     var n : int ; n := arr->size() ;
     execute generateArr(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
class GFG {
  static int sumofsquare(int n){
    int[][] C=new int[n+1][n+1];
    int i,j ;
    for(i=0 ; i<=n ; i++){
      for(j=0 ; j<=min(i,n); j++){
        if(j==0 || j==i)C[i][j]=1 ;
        else C[i][j]=C[i-1][j-1]+C[i-1][j];
      }
    }
    int sum=0 ;
    for(i=0 ; i<=n ; i++)sum+=(C[n][i]*C[n][i]);
    return sum ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(sumofsquare(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumofsquare( n : int) : int
  pre: true
  post: true
  activity: (     var C : Sequence(Sequence(int)) ; C := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
     var i : int ;
    var j : int ;
        i := 0 ; while i <= n do ( (         j := 0 ; while j <= Set{i, n}->min() do ( (     if (j = 0 or j = i) then     C[i+1][j+1] := 1 ; else     C[i+1][j+1] := C[i - 1+1][j - 1+1] + C[i - 1+1][j+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        i := 0 ; while i <= n do (     sum := sum+((C[n+1][i+1] * C[n+1][i+1])) ;  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(sumofsquare(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int lengthOfSmallestSubsequence(int K,int[] v){
    Queue<Integer>pq=new PriorityQueue<Integer>(Collections.reverseOrder());
    for(int i=0 ; i<v.length ; i++){
      pq.add(v[i]);
    }
    int sum=0,count=0 ;
    while(! pq.isEmpty()&& sum<K){
      sum+=pq.peek();
      pq.remove();
      count++;
    }
    if(sum<K){
      return-1 ;
    }
    return count ;
  }
  public static void main(String[] args){
    int[] v={
      2,3,1,5,6,3,7,9,14,10,2,5 };
      int K=35 ;
      System.out.print(lengthOfSmallestSubsequence(K,v));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation lengthOfSmallestSubsequence( K : int, v : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var pq : Sequence(int) ; pq := Sequence{}->union(reverseOrder()) ;
         var i : int ; i := 0 ; while i < v->size() do ( (     pq := pq->including(v[i+1]) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var count : int ; count := 0 ;
    while (not(pq->isEmpty()) & sum < K) do (     sum := sum+(pq->min()) ; 
     pq := pq.remove() ; 
     count := count + 1 ) ; 
    if (sum < K) then (     return -1 ) else skip ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Sequence{2,3,1,5,6,3,7,9,14,10,2,5} ;
     var K : int ; K := 35 ;
     OclFile["System.out"].print(lengthOfSmallestSubsequence(K, v)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class cdf813a {
  public static void main(String args[])throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    for(int i=0 ; i<t ; i++){
      String s=br.readLine();
      String str[]=s.split(" ");
      int n=Integer.parseInt(str[0]);
      int k=Integer.parseInt(str[1]);
      s=br.readLine();
      String ss[]=s.split(" ");
      int ans=0 ;
      for(int j=0 ; j<k ; j++){
        int a=Integer.parseInt(ss[j]);
        if(a>k)ans++;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cdf813a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var s : String ; s := br.readLine() ;
     var str : Sequence(String) ; str := s->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var k : int ; k := (str[1+1])->toInteger() ;
    s := br.readLine() ; 
    var ss : Sequence(String) ; ss := s->split(" ") ;
    var ans : int ; ans := 0 ;
        var j : int ; j := 0 ; while j < k do ( (     var a : int ; a := (ss[j+1])->toInteger() ;
     if (a > k) then     ans := ans + 1 ; else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String countnndSay(int n){
    if(n==1)return "1" ;
    if(n==2)return "11" ;
    String str="11" ;
    for(int i=3 ; i<=n ; i++){
      str+='$' ;
      int len=str.length();
      int cnt=1 ;
      String tmp="" ;
      char[] arr=str.toCharArray();
      for(int j=1 ; j<len ; j++){
        if(arr[j]!=arr[j-1]){
          tmp+=cnt+0 ;
          tmp+=arr[j-1];
          cnt=1 ;
        }
        else cnt++;
      }
      str=tmp ;
    }
    return str ;
  }
  public static void main(String[] args){
    int N=3 ;
    System.out.println(countnndSay(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countnndSay( n : int) : String
  pre: true
  post: true
  activity: (     if (n = 1) then     return "1" else skip ; 
     if (n = 2) then     return "11" else skip ; 
    var str : String ; str := "11" ;
        var i : int ; i := 3 ; while i <= n do ( (     str := str+('$') ; 
     var len : int ; len := str->size() ;
    var cnt : int ; cnt := 1 ;
    var tmp : String ; tmp := "" ;
    var arr : Sequence(String) ; arr := str->characters() ;
        var j : int ; j := 1 ; while j < len do ( (     if (arr[j+1] /= arr[j - 1+1]) then (     tmp := tmp+(cnt + 0) ; 
     tmp := tmp+(arr[j - 1+1]) ; 
     cnt := 1 ) else     cnt := cnt + 1 ; )  ;     j := j + 1 ) ; 
    str := tmp ; 
 )  ;     i := i + 1 ) ; 
    return str 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
     OclFile["System.out"].println(countnndSay(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int largestPalindrome(int n){
    if(n==1){
      return 9 ;
    }
    int upperBound=(int)Math.pow(10,n)-1,lowerBound=upperBound/10 ;
    long maxNumber=(long)upperBound*(long)upperBound ;
    int firstHalf=(int)(maxNumber/(long)Math.pow(10,n));
    boolean palindromFound=false ;
    long palindrom=0 ;
    while(! palindromFound){
      palindrom=createPalindrom(firstHalf);
      for(long i=upperBound ; upperBound>lowerBound ; i--){
        if(palindrom/i>maxNumber || i*i<palindrom){
          break ;
        }
        if(palindrom % i==0){
          palindromFound=true ;
          break ;
        }
      }
      firstHalf--;
    }
    return(int)(palindrom % 1337);
  }
  private long createPalindrom(long num){
    String str=num+new StringBuilder().append(num).reverse().toString();
    return Long.parseLong(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation largestPalindrome( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then (     return 9 ) else skip ; 
     var upperBound : int ; upperBound := 10->pow(n)->oclAsType(int) - 1 ;
    var lowerBound : int ; lowerBound := upperBound / 10 ;
    var maxNumber : long ; maxNumber := upperBound->oclAsType(long) * upperBound->oclAsType(long) ;
    var firstHalf : int ; firstHalf := (maxNumber / 10->pow(n)->oclAsType(long))->oclAsType(int) ;
    var palindromFound : boolean ; palindromFound := false ;
    var palindrom : long ; palindrom := 0 ;
    while (not(palindromFound)) do (     palindrom := createPalindrom(firstHalf) ; 
         var i : long ; i := upperBound ; while upperBound > lowerBound do ( (     if (palindrom / i > maxNumber or i * i < palindrom) then (     break ) else skip ; 
     if (palindrom mod i = 0) then (     palindromFound := true ; 
     break ) else skip )  ;     i := i - 1 ) ; 
     firstHalf := firstHalf - 1 ) ; 
    return (palindrom mod 1337)->oclAsType(int) 
 );
   operation createPalindrom( num : long) : long
  pre: true
  post: true
  activity: (     var str : String ; str := num + StringLib.newString() + StringLib.newString(num)->reverse()+"" ;
     return (str)->toLong() );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main implements Runnable {
  public Scanner in ;
  public PrintWriter out ;
  Main()throws IOException {
    in=new Scanner(new File("in"));
    out=new PrintWriter(new File("out"));
  }
  void close()throws IOException {
    out.close();
  }
  public void run(){
    int tn=in.nextInt();
    for(int test=1 ; test<=tn ; test++){
      int n=in.nextInt();
      double[] x=new double[n];
      double[] y=new double[n];
      double[] r=new double[n];
      for(int i=0 ; i<n ; i++){
        x[i]=in.nextDouble();
        y[i]=in.nextDouble();
        r[i]=in.nextDouble();
      }
      double res=1E100 ;
      if(n==1){
        res=r[0];
      }
      else if(n==2){
        res=Math.max(r[0],r[1]);
      }
      else {
        for(int i=0 ; i<3 ; i++){
          int j=(i+1)% 3 ;
          int k=(i+2)% 3 ;
          res=Math.min(res,Math.max(r[i],0.5*(Math.hypot(x[j]-x[k],y[j]-y[k])+r[j]+r[k])));
        }
      }
      out.println("Case #"+test+": "+res);
    }
    try {
      close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  public static void main(String[] args)throws IOException {
    new Thread(new Main()).start();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
   attribute in : OclFile;
   attribute out : OclFile;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile("in")) ; 
     out := OclFile.newOclFile_Write(OclFile("out")) );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
   operation run() : void
  pre: true
  post: true
  activity: (     var tn : int ; tn := in.getCurrent()->toInteger() ;
         var test : int ; test := 1 ; while test <= tn do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var x : Sequence(double) ; x := Integer.subrange(1,n)->collect(0.0) ;
    var y : Sequence(double) ; y := Integer.subrange(1,n)->collect(0.0) ;
    var r : Sequence(double) ; r := Integer.subrange(1,n)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := in.getCurrent()->toReal() ; 
     y[i+1] := in.getCurrent()->toReal() ; 
     r[i+1] := in.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
    var res : double ; res := 1E100 ;
    if (n = 1) then (     res := r[0+1] ) else     if (n = 2) then (     res := Set{r[0+1], r[1+1]}->max() ) else (         var i : int ; i := 0 ; while i < 3 do ( (     var j : int ; j := (i + 1) mod 3 ;
     var k : int ; k := (i + 2) mod 3 ;
     res := Set{res, Set{r[i+1], 0.5 * (hypot(x[j+1] - x[k+1], y[j+1] - y[k+1]) + r[j+1] + r[k+1])}->max()}->min() )  ;     i := i + 1 ) ) ;  ;  
    skip ; 
 )  ;     test := test + 1 ) ; 
     try (     execute close() )   catch (e : IOException) do (     e.printStackTrace() )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(Main.newMain()).start() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileOutputStream ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.PrintStream ;
public class D {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new FileReader("D-small.in"));
    PrintStream ps=new PrintStream(new FileOutputStream("D-small.out"));
    int cases=Integer.parseInt(br.readLine());
    for(int itr=1 ; itr<=cases ; itr++){
      int flowers=Integer.parseInt(br.readLine());
      int[] x=new int[flowers];
      int[] y=new int[flowers];
      int[] r=new int[flowers];
      for(int i=0 ; i<flowers ; i++){
        String[] sp=br.readLine().split(" ");
        x[i]=Integer.parseInt(sp[0]);
        y[i]=Integer.parseInt(sp[1]);
        r[i]=Integer.parseInt(sp[2]);
      }
      double out=0 ;
      if(flowers<3)out=Math.max(r[0],r[flowers-1]);
      else {
        out=1e100 ;
        for(int i=0 ; i<flowers ; i++){
          int j=(i==0)? 1 : 0 ;
          int k=(i==2)? 1 : 2 ;
          double d=Math.sqrt((x[j]-x[k])*(x[j]-x[k])+(y[j]-y[k])*(y[j]-y[k]));
          out=Math.min(out,Math.max(r[i],(d+r[j]+r[k])/2));
        }
      }
      ps.println("Case #"+itr+": "+out);
    }
    br.close();
    ps.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("D-small.in"))) ;
     var ps : OclFile ; ps := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("D-small.out"))) ;
    var cases : int ; cases := (br.readLine())->toInteger() ;
        var itr : int ; itr := 1 ; while itr <= cases do ( (     var flowers : int ; flowers := (br.readLine())->toInteger() ;
     var x : Sequence(int) ; x := Integer.subrange(1,flowers)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,flowers)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,flowers)->collect(0) ;
        var i : int ; i := 0 ; while i < flowers do ( (     var sp : Sequence(String) ; sp := br.readLine()->split(" ") ;
     x[i+1] := (sp[0+1])->toInteger() ; 
     y[i+1] := (sp[1+1])->toInteger() ; 
     r[i+1] := (sp[2+1])->toInteger() )  ;     i := i + 1 ) ; 
    var out : double ; out := 0 ;
    if (flowers < 3) then     out := Set{r[0+1], r[flowers - 1+1]}->max() else (     out := 1e100 ; 
         var i : int ; i := 0 ; while i < flowers do ( (     var j : int ; j := if (i = 0) then 1 else 0 endif ;
     var k : int ; k := if (i = 2) then 1 else 2 endif ;
     var d : double ; d := ((x[j+1] - x[k+1]) * (x[j+1] - x[k+1]) + (y[j+1] - y[k+1]) * (y[j+1] - y[k+1]))->sqrt() ;
     out := Set{out, Set{r[i+1], (d + r[j+1] + r[k+1]) / 2}->max()}->min() )  ;     i := i + 1 ) ) ;  
    skip ; 
 )  ;     itr := itr + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class x {
  public static void main(String args[])throws Exception {
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int tt=1 ; tt<=t ; tt++){
      int n=in.nextInt();
      int[] x=new int[n],y=new int[n],r=new int[n];
      for(int i=0 ; i<n ; i++){
        x[i]=in.nextInt();
        y[i]=in.nextInt();
        r[i]=in.nextInt();
      }
      double ans=-1 ;
      if(n==1)ans=r[0];
      else if(n==2)ans=Math.max(r[0],r[1]);
      else if(n==3){
        ans=Math.max(r[0],0.5*(Math.hypot(x[2]-x[1],y[2]-y[1])+r[1]+r[2]));
        ans=Math.min(ans,Math.max(r[1],0.5*(Math.hypot(x[2]-x[0],y[2]-y[0])+r[0]+r[2])));
        ans=Math.min(ans,Math.max(r[2],0.5*(Math.hypot(x[1]-x[0],y[1]-y[0])+r[0]+r[1])));
      }
      System.out.println("Case #"+tt+": "+ans);
    };
  };
};
------------------------------------------------------------
OCL File:
---------
 class x {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var tt : int ; tt := 1 ; while tt <= t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := in.getCurrent()->toInteger() ; 
     y[i+1] := in.getCurrent()->toInteger() ; 
     r[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : double ; ans := -1 ;
    if (n = 1) then     ans := r[0+1] else     if (n = 2) then     ans := Set{r[0+1], r[1+1]}->max() else     if (n = 3) then (     ans := Set{r[0+1], 0.5 * (hypot(x[2+1] - x[1+1], y[2+1] - y[1+1]) + r[1+1] + r[2+1])}->max() ; 
     ans := Set{ans, Set{r[1+1], 0.5 * (hypot(x[2+1] - x[0+1], y[2+1] - y[0+1]) + r[0+1] + r[2+1])}->max()}->min() ; 
     ans := Set{ans, Set{r[2+1], 0.5 * (hypot(x[1+1] - x[0+1], y[1+1] - y[0+1]) + r[0+1] + r[1+1])}->max()}->min() ) else skip ; ;  ;  
    OclFile["System.out"].println("Case #" + tt + ": " + ans) ; 
 )  ;     tt := tt + 1 ) ; 
  );
}
;

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int totalSumDivisibleByNum(int digit,int number){
    int firstnum=(int)Math.pow(10,digit-1);
    int lastnum=(int)Math.pow(10,digit);
    firstnum=(firstnum-firstnum % number)+number ;
    lastnum=(lastnum-lastnum % number);
    int count=((lastnum-firstnum)/number+1);
    return((lastnum+firstnum)*count)/2 ;
  }
  public static void main(String[] args){
    int n=3,number=7 ;
    System.out.println(totalSumDivisibleByNum(n,number));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation totalSumDivisibleByNum( digit : int, number : int) : int
  pre: true
  post: true
  activity: (     var firstnum : int ; firstnum := 10->pow(digit - 1)->oclAsType(int) ;
     var lastnum : int ; lastnum := 10->pow(digit)->oclAsType(int) ;
    firstnum := (firstnum - firstnum mod number) + number ; 
    lastnum := (lastnum - lastnum mod number) ; 
    var count : int ; count := ((lastnum - firstnum) / number + 1) ;
    return ((lastnum + firstnum) * count) / 2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
    var number : int ; number := 7 ;
     OclFile["System.out"].println(totalSumDivisibleByNum(n, number)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int numberofterm(int digit,int number){
    int firstnum=(int)Math.pow(10,digit-1);
    int lastnum=(int)Math.pow(10,digit);
    firstnum=(firstnum-firstnum % number)+number ;
    lastnum=(lastnum-lastnum % number);
    return((lastnum-firstnum)/number+1);
  }
  public static void main(String[] args){
    int n=3 ;
    int number=7 ;
    System.out.println(numberofterm(n,number));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation numberofterm( digit : int, number : int) : int
  pre: true
  post: true
  activity: (     var firstnum : int ; firstnum := 10->pow(digit - 1)->oclAsType(int) ;
     var lastnum : int ; lastnum := 10->pow(digit)->oclAsType(int) ;
    firstnum := (firstnum - firstnum mod number) + number ; 
    lastnum := (lastnum - lastnum mod number) ; 
    return ((lastnum - firstnum) / number + 1) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var number : int ; number := 7 ;
     OclFile["System.out"].println(numberofterm(n, number)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class SecondProjectkoi {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int san=in.nextInt();
    ArrayList<Integer>array=new ArrayList<>();
    for(int i=0 ; i<san ; i++){
      array.add(in.nextInt());
    }
    Collections.reverse(array);
    array=removeDuplicate(array);
    Collections.reverse(array);
    System.out.println(array.size());
    for(int i=0 ; i<array.size(); i++){
      System.out.print(array.get(i)+" ");
    }
  }
  static ArrayList<Integer>removeDuplicate(ArrayList<Integer>array){
    ArrayList<Integer>withoutDup=new ArrayList<>();
    for(int i=0 ; i<array.size(); i++){
      if(! withoutDup.contains(array.get(i)))withoutDup.add(array.get(i));
    }
    return withoutDup ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class SecondProjectkoi {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var san : int ; san := in.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Sequence{} ;
        var i : int ; i := 0 ; while i < san do ( (     array := array->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    array := array->reverse() ; 
    array := removeDuplicate(array) ; 
    array := array->reverse() ; 
    OclFile["System.out"].println(array->size()) ; 
        var i : int ; i := 0 ; while i < array->size() do ( (     OclFile["System.out"].print(array->at(i+1) + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation removeDuplicate( array : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var withoutDup : Sequence(int) ; withoutDup := Sequence{} ;
         var i : int ; i := 0 ; while i < array->size() do ( (     if (not(withoutDup->includes(array->at(i+1)))) then     withoutDup := withoutDup->including(array->at(i+1)) ; else skip )  ;     i := i + 1 ) ; 
     return withoutDup );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Book[] books=new Book[n];
    for(int i=0 ; i<n ; i++){
      books[i]=new Book(sc.next(),sc.next(),sc.next());
    }
    int q=sc.nextInt();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<q ; i++){
      if(i!=0){
        sb.append("\n");
      }
      String tQuery=sc.next();
      String aQuery=sc.next();
      String from=sc.next();
      String to=sc.next();
      for(int j=0 ; j<n ; j++){
        if(books[j] .isHit(tQuery,aQuery,from,to)){
          sb.append(books[j] .title).append("\n");
        }
      }
    }
    System.out.print(sb);
  }
  static class Book {
    String title ;
    String author ;
    String date ;
    public Book(String title,String author,String date){
      this.title=title ;
      this.author=author ;
      this.date=date ;
    }
    public boolean isHit(String tQuery,String aQuery,String from,String to){
      if(! tQuery.equals("*")){
        if(! title.contains(tQuery)){
          return false ;
        }
      }
      if(! aQuery.equals("*")){
        if(! author.contains(aQuery)){
          return false ;
        }
      }
      if(! from.equals("*")){
        if(date.compareTo(from)<0){
          return false ;
        }
      }
      if(! to.equals("*")){
        if(date.compareTo(to)>0){
          return false ;
        }
      }
      return true ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var books : Sequence(Book) ; books := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     books[i+1] := Book.newBook(sc.getCurrent(), sc.getCurrent(), sc.getCurrent()) )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < q do ( (     if (i /= 0) then (     sb := sb + StringLib.newString("\n") ) else skip ; 
     var tQuery : String ; tQuery := sc.getCurrent() ;
    var aQuery : String ; aQuery := sc.getCurrent() ;
    var from : String ; from := sc.getCurrent() ;
    var to : String ; to := sc.getCurrent() ;
        var j : int ; j := 0 ; while j < n do ( (     if (books[j+1].isHit(tQuery, aQuery, from, to)) then (     sb := sb + StringLib.newString(books[j+1].title) + StringLib.newString("\n") ) else skip )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
  static class Book {
   attribute title : String;
   attribute author : String;
   attribute date : String;
   static operation newBook( title : String, author : String, date : String) : Book
  pre: true
  post: true
  activity:
  ( var self : Book ;
    self := createBook();
    self.initialise(title, author,date);
    return self );
  operation initialise( title : String, author : String, date : String) : void
  pre: true  post: true
  activity: (     self.title := title ; 
     self.author := author ; 
     self.date := date );
   operation isHit( tQuery : String, aQuery : String, from : String, to : String) : boolean
  pre: true
  post: true
  activity: (     if (not(tQuery = "*")) then (     if (not(title->includes(tQuery))) then (     return false ) else skip ) else skip ; 
     if (not(aQuery = "*")) then (     if (not(author->includes(aQuery))) then (     return false ) else skip ) else skip ; 
    if (not(from = "*")) then (     if (date->compareTo(from) < 0) then (     return false ) else skip ) else skip ; 
    if (not(to = "*")) then (     if (date->compareTo(to) > 0) then (     return false ) else skip ) else skip ; 
    return true 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  boolean[][] M ;
  int n ;
  boolean color[];
  int d[];
  int f[];
  private void run(){
    Scanner scanner=new Scanner(System.in);
    n=scanner.nextInt();
    M=new boolean[n][n];
    color=new boolean[n];
    d=new int[n];
    f=new int[n];
    for(int i=0 ; i<n ; i++){
      int u=scanner.nextInt();
      int k=scanner.nextInt();
      u--;
      for(int j=0 ; j<k ; j++){
        int v=scanner.nextInt();
        v--;
        M[u][v]=true ;
      }
    }
    dfs();
  }
  private void dfs(){
    for(int u=0 ; u<n ; u++){
      if(! color[u])dfs_visit(u);
    }
    for(int u=0 ; u<n ; u++){
      System.out.printf("%d %d %d\n",u+1,d[u],f[u]);
    }
  }
  int tt=1 ;
  private void dfs_visit(int u){
    color[u]=true ;
    d[u]=tt++;
    for(int v=0 ; v<n ; v++){
      if(! M[u][v])continue ;
      if(! color[v]){
        dfs_visit(v);
      }
    }
    f[u]=tt++;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute M : Sequence(Sequence(boolean));
   attribute n : int;
   attribute color : Sequence(boolean);
   attribute d : Sequence(int);
   attribute f : Sequence(int);
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := scanner.getCurrent()->toInteger() ; 
    M := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ; 
    color := Integer.subrange(1,n)->collect(false) ; 
    d := Integer.subrange(1,n)->collect(0) ; 
    f := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     var u : int ; u := scanner.getCurrent()->toInteger() ;
     var k : int ; k := scanner.getCurrent()->toInteger() ;
     u := u - 1 ; 
         var j : int ; j := 0 ; while j < k do ( (     var v : int ; v := scanner.getCurrent()->toInteger() ;
     v := v - 1 ; 
     M[u+1][v+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    execute dfs() ; 
 );
   operation dfs() : void
  pre: true
  post: true
  activity: (         var u : int ; u := 0 ; while u < n do ( (     if (not(color[u+1])) then     execute dfs_visit(u) ; else skip )  ;     u := u + 1 ) ; 
         var u : int ; u := 0 ; while u < n do ( (     OclFile["System.out"].printf("%d %d %d\n", u + 1, d[u+1], f[u+1]) )  ;     u := u + 1 ) );
   attribute tt : int := 1;
   operation dfs_visit( u : int) : void
  pre: true
  post: true
  activity: (     color[u+1] := true ; 
      d[u+1] := tt  ; tt := tt + 1 ; 
         var v : int ; v := 0 ; while v < n do ( (     if (not(M[u+1][v+1])) then     continue else skip ; 
     if (not(color[v+1])) then (     execute dfs_visit(v) ) else skip )  ;     v := v + 1 ) ; 
      f[u+1] := tt  ; tt := tt + 1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Solution {
  static PrintWriter pw ;
  static FastScanner s ;
  public static void main(String[] args)throws Exception {
    pw=new PrintWriter(System.out);
    s=new FastScanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int k=s.nextInt();
      int count=0 ;
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=s.nextInt();
      }
      for(int i=0 ; i<k ; i++){
        if(a[i]>k)count++;
      }
      pw.println(count);
    }
    pw.flush();
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public FastScanner(String s)throws Exception {
    br=new BufferedReader(new FileReader(new File(s)));
  }
  public String next()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(next());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute pw : OclFile;
  static   attribute s : FastScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     pw := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     s := FastScanner.newFastScanner(OclFile["System.in"]) ; 
    var t : int ; t := s.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.nextInt() ;
     var k : int ; k := s.nextInt() ;
    var count : int ; count := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := s.nextInt() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do ( (     if (a[i+1] > k) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int[][] a=new int[n+1][n+2];
    for(int i=0 ; i<n ; i++){
      String[] str=br.readLine().split(" ");
      int u=Integer.parseInt(str[0]);
      for(int j=2 ; j<str.length ; j++){
        a[u][j-1]=Integer.parseInt(str[j]);
      }
    }
    int[] d=new int[n+1];
    int[] f=new int[n+1];
    int t=0 ;
    int[] st=new int[n];
    int p=0 ;
    for(int i=1 ; i<=n ; i++){
      if(d[i]!=0){
        continue ;
      }
      p=0 ;
      st[p]=i ;
      while(p>=0){
        int pn=st[p];
        if(d[pn]==0){
          t+=1 ;
          d[pn]=t ;
        }
        int nn ;
        do {
          a[pn][0]+=1 ;
          nn=a[pn][a[pn][0] ];
        }
        while(d[nn]!=0);
        if(nn!=0){
          p+=1 ;
          st[p]=nn ;
        }
        else if(f[pn]==0){
          t+=1 ;
          f[pn]=t ;
          p-=1 ;
        }
        else {
          p-=1 ;
        }
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int i=1 ; i<=n ; i++){
      sb.append(i+" "+d[i]+" "+f[i]+"\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     var u : int ; u := (str[0+1])->toInteger() ;
         var j : int ; j := 2 ; while j < str->size() do ( (     a[u+1][j - 1+1] := (str[j+1])->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var d : Sequence(int) ; d := Integer.subrange(1,n + 1)->collect(0) ;
    var f : Sequence(int) ; f := Integer.subrange(1,n + 1)->collect(0) ;
    var t : int ; t := 0 ;
    var st : Sequence(int) ; st := Integer.subrange(1,n)->collect(0) ;
    var p : int ; p := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (d[i+1] /= 0) then (     continue ) else skip ; 
     p := 0 ; 
     st[p+1] := i ; 
     while (p >= 0) do (     var pn : int ; pn := st[p+1] ;
     if (d[pn+1] = 0) then (     t := t+(1) ; 
     d[pn+1] := t ) else skip ; 
    var nn : int ;
  while true do ((     a[pn+1][0+1] := a[pn+1][0+1]+(1) ; 
     nn := a[pn+1][a[pn+1][0+1]+1] ) ;
    if (d[nn+1] /= 0) then skip else break) ; 
    if (nn /= 0) then (     p := p+(1) ; 
     st[p+1] := nn ) else     if (f[pn+1] = 0) then (     t := t+(1) ; 
     f[pn+1] := t ; 
     p := p-(1) ) else (     p := p-(1) ) ;  ;  
 ) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 1 ; while i <= n do ( (     sb := sb + StringLib.newString(i + " " + d[i+1] + " " + f[i+1] + "\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Graph2 {
  private int totalVertex ;
  boolean[] explore ;
  int[] firstDisc ;
  int[] endTime ;
  int count=0 ;
  private LinkedList<LinkedList<Integer>>adjList ;
  public Graph2(){
    totalVertex=0 ;
  }
  public LinkedList<LinkedList<Integer>>loadAdjList(){
    Scanner in=new Scanner(System.in);
    totalVertex=in.nextInt();
    explore=new boolean[totalVertex+1];
    firstDisc=new int[totalVertex+1];
    endTime=new int[totalVertex+1];
    adjList=new LinkedList<LinkedList<Integer>>();
    for(int i=0 ; i<totalVertex ; i++){
      LinkedList<Integer>tmp=new LinkedList<Integer>();
      int idx1=in.nextInt();
      int degree=in.nextInt();
      for(int j=0 ; j<degree ; j++){
        int idx2=in.nextInt();
        tmp.add(idx2);
      }
      adjList.add(tmp);
    }
    in.close();
    return adjList ;
  }
  public void recurse(LinkedList<LinkedList<Integer>>G,int v){
    if(! explore[v]){
      explore[v]=true ;
      count++;
      firstDisc[v]=count ;
      for(int e : G.get(v-1)){
        recurse(G,e);
      }
      count++;
      endTime[v]=count ;
    }
  }
  void print(){
    for(int i=1 ; i<=totalVertex ; i++){
      System.out.println(i+" "+firstDisc[i]+" "+endTime[i]);
    }
  }
}
public class Main {
  public static void main(String argv[]){
    Graph2 g=new Graph2();
    LinkedList<LinkedList<Integer>>matrix=g.loadAdjList();
    for(int i=1 ; i<=matrix.size(); i++){
      g.recurse(matrix,i);
    }
    g.print();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Graph2 {
   attribute totalVertex : int;
   attribute explore : Sequence(boolean);
   attribute firstDisc : Sequence(int);
   attribute endTime : Sequence(int);
   attribute count : int := 0;
   attribute adjList : Sequence(Sequence(int));
   static operation newGraph2() : Graph2
  pre: true
  post: true
  activity:
  ( var self : Graph2 ;
    self := createGraph2();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     totalVertex := 0 );
   operation loadAdjList() : Sequence(Sequence(int))
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     totalVertex := in.getCurrent()->toInteger() ; 
    explore := Integer.subrange(1,totalVertex + 1)->collect(false) ; 
    firstDisc := Integer.subrange(1,totalVertex + 1)->collect(0) ; 
    endTime := Integer.subrange(1,totalVertex + 1)->collect(0) ; 
    adjList := Sequence{} ; 
        var i : int ; i := 0 ; while i < totalVertex do ( (     var tmp : Sequence(int) ; tmp := Sequence{} ;
     var idx1 : int ; idx1 := in.getCurrent()->toInteger() ;
    var degree : int ; degree := in.getCurrent()->toInteger() ;
        var j : int ; j := 0 ; while j < degree do ( (     var idx2 : int ; idx2 := in.getCurrent()->toInteger() ;
     tmp := tmp->including(idx2) )  ;     j := j + 1 ) ; 
    adjList := adjList->including(tmp) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    return adjList 
 );
   operation recurse( G : Sequence(Sequence(int)), v : int) : void
  pre: true
  post: true
  activity: (     if (not(explore[v+1])) then (     explore[v+1] := true ; 
     count := count + 1 ; 
    firstDisc[v+1] := count ; 
    for (e : G->at(v - 1+1)) do ( (     execute recurse(G, e) )  ) ; 
    count := count + 1 ; 
    endTime[v+1] := count ; 
 ) else skip );
   operation print() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= totalVertex do ( (     OclFile["System.out"].println(i + " " + firstDisc[i+1] + " " + endTime[i+1]) )  ;     i := i + 1 ) );
}
class Main {
  static   operation main( argv : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : Graph2 ; g := Graph2.newGraph2() ;
     var matrix : Sequence(Sequence(int)) ; matrix := g.loadAdjList() ;
         var i : int ; i := 1 ; while i <= matrix->size() do ( (     g.recurse(matrix, i) )  ;     i := i + 1 ) ; 
     g.print() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int N=100 ;
  static int WHITE=0 ;
  static int GRAY=1 ;
  static int BLACK=2 ;
  static int n ;
  static int[][] M=new int[N][N];
  static int[] color=new int[N];
  static int[] d=new int[N];
  static int[] f=new int[N];
  static int tt ;
  public static void dfsVisit(int u){
    int v ;
    color[u]=GRAY ;
    d[u]=++tt ;
    for(v=0 ; v<n ; v++){
      if(M[u][v]==0)continue ;
      if(color[v]==WHITE){
        dfsVisit(v);
      }
    }
    color[u]=BLACK ;
    f[u]=++tt ;
  }
  public static void dfs(){
    int u ;
    for(u=0 ; u<n ; u++)color[u]=WHITE ;
    tt=0 ;
    for(u=0 ; u<n ; u++){
      if(color[u]==WHITE)dfsVisit(u);
    }
    for(u=0 ; u<n ; u++){
      System.out.println((u+1)+" "+d[u]+" "+f[u]);
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int u,v,k,i,j ;
    n=sc.nextInt();
    for(i=0 ; i<n ; i++){
      for(j=0 ; j<n ; j++)M[i][j]=0 ;
    }
    for(i=0 ; i<n ; i++){
      u=sc.nextInt();
      k=sc.nextInt();
      u--;
      for(j=0 ; j<k ; j++){
        v=sc.nextInt();
        v--;
        M[u][v]=1 ;
      }
    }
    dfs();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int := 100;
  static   attribute WHITE : int := 0;
  static   attribute GRAY : int := 1;
  static   attribute BLACK : int := 2;
  static   attribute n : int;
  static   attribute M : Sequence(Sequence(int)) := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0));
  static   attribute color : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static   attribute d : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static   attribute f : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static   attribute tt : int;
  static   operation dfsVisit( u : int) : void
  pre: true
  post: true
  activity: (     var v : int ;
     color[u+1] := GRAY ; 
        tt := tt + 1 ;
 d[u+1] := tt  ; 
        v := 0 ; while v < n do ( (     if (M[u+1][v+1] = 0) then     continue else skip ; 
     if (color[v+1] = WHITE) then (     execute dfsVisit(v) ) else skip )  ;     v := v + 1 ) ; 
    color[u+1] := BLACK ; 
        tt := tt + 1 ;
 f[u+1] := tt  ; 
 );
  static   operation dfs() : void
  pre: true
  post: true
  activity: (     var u : int ;
         u := 0 ; while u < n do (     color[u+1] := WHITE ;  ;     u := u + 1 ) ; 
    tt := 0 ; 
        u := 0 ; while u < n do ( (     if (color[u+1] = WHITE) then     execute dfsVisit(u) ; else skip )  ;     u := u + 1 ) ; 
        u := 0 ; while u < n do ( (     OclFile["System.out"].println((u + 1) + " " + d[u+1] + " " + f[u+1]) )  ;     u := u + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var u : int ;
    var v : int ;
    var k : int ;
    var i : int ;
    var j : int ;
    n := sc.getCurrent()->toInteger() ; 
        i := 0 ; while i < n do ( (         j := 0 ; while j < n do (     M[i+1][j+1] := 0 ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     u := sc.getCurrent()->toInteger() ; 
     k := sc.getCurrent()->toInteger() ; 
     u := u - 1 ; 
         j := 0 ; while j < k do ( (     v := sc.getCurrent()->toInteger() ; 
     v := v - 1 ; 
     M[u+1][v+1] := 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    execute dfs() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Stack ;
public class Main {
  public static void main(String[] args){
    try(Scanner scan=new Scanner(System.in)){
      int n=scan.nextInt();
      int[][] map=new int[n][n];
      int[] state=new int[n];
      int[] discovery=new int[n];
      int[] finish=new int[n];
      for(int i=0 ; i<n ; i++){
        int from=scan.nextInt()-1 ;
        int m=scan.nextInt();
        for(int j=0 ; j<m ; j++){
          int to=scan.nextInt()-1 ;
          map[from][to]=1 ;
        }
      }
      int time=0 ;
      for(int i=0 ; i<n ; i++){
        if(state[i]>=1)continue ;
        time++;
        Stack<Integer>stack=new Stack<>();
        stack.push(i);
        state[i]=1 ;
        discovery[i]=time ;
        while(! stack.isEmpty()){
          int now=stack.peek();
          time++;
          boolean findConnect=false ;
          for(int j=0 ; j<n ; j++){
            if(now==j)continue ;
            if(map[now][j]==1 && state[j]==0){
              stack.push(j);
              state[j]=1 ;
              discovery[j]=time ;
              findConnect=true ;
              break ;
            }
          }
          if(! findConnect){
            stack.pop();
            state[now]=2 ;
            finish[now]=time ;
          }
        }
      }
      for(int i=0 ; i<n ; i++){
        System.out.println((i+1)+" "+discovery[i]+" "+finish[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var state : Sequence(int) ; state := Integer.subrange(1,n)->collect(0) ;
    var discovery : Sequence(int) ; discovery := Integer.subrange(1,n)->collect(0) ;
    var finish : Sequence(int) ; finish := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var from : int ; from := scan.getCurrent()->toInteger() - 1 ;
     var m : int ; m := scan.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < m do ( (     var to : int ; to := scan.getCurrent()->toInteger() - 1 ;
     map[from+1][to+1] := 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var time : int ; time := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (state[i+1] >= 1) then     continue else skip ; 
     time := time + 1 ; 
    var stack : Sequence(int) ; stack := Sequence{} ;
    stack := stack->append(i) ; 
    state[i+1] := 1 ; 
    discovery[i+1] := time ; 
    while (not(stack->isEmpty())) do (     var now : int ; now := stack->min() ;
     time := time + 1 ; 
    var findConnect : boolean ; findConnect := false ;
        var j : int ; j := 0 ; while j < n do ( (     if (now = j) then     continue else skip ; 
     if (map[now+1][j+1] = 1 & state[j+1] = 0) then (     stack := stack->append(j) ; 
     state[j+1] := 1 ; 
    discovery[j+1] := time ; 
    findConnect := true ; 
    break 
 ) else skip )  ;     j := j + 1 ) ; 
    if (not(findConnect)) then (     stack := stack->front() ; 
     state[now+1] := 2 ; 
     finish[now+1] := time ) else skip ; 
 ) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println((i + 1) + " " + discovery[i+1] + " " + finish[i+1]) )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void swap(int[] a,int i,int j){
    int temp=a[i];
    a[i]=a[j];
    a[j]=temp ;
  }
  static void printArray(int[] a,int n){
    for(int i=0 ; i<n ; i++)System.out.print(a[i]+" ");
    System.out.println();
  }
  public static void main(String args[]){
    int[] arr={
      1,-3,5,6,-3,6,7,-4,9,10 };
      int n=arr.length ;
      printArray(arr,n);
      for(int i=0 ; i<n ; i++){
        if(arr[i]>=0 && i % 2==1){
          for(int j=i+1 ; j<n ; j++){
            if(arr[j]<0 && j % 2==0){
              swap(arr,i,j);
              break ;
            }
          }
        }
        else if(arr[i]<0 && i % 2==0){
          for(int j=i+1 ; j<n ; j++){
            if(arr[j]>=0 && j % 2==1){
              swap(arr,i,j);
              break ;
            }
          }
        }
      }
      printArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation swap( a : Sequence(int), i : int, j : int) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := a[i+1] ;
     a[i+1] := a[j+1] ; 
     a[j+1] := temp );
  static   operation printArray( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,-3,5,6,-3,6,7,-4,9,10} ;
     var n : int ; n := arr->size() ;
    execute printArray(arr, n) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] >= 0 & i mod 2 = 1) then (         var j : int ; j := i + 1 ; while j < n do ( (     if (arr[j+1] < 0 & j mod 2 = 0) then (     execute swap(arr, i, j) ; 
     break ) else skip )  ;     j := j + 1 ) ) else     if (arr[i+1] < 0 & i mod 2 = 0) then (         var j : int ; j := i + 1 ; while j < n do ( (     if (arr[j+1] >= 0 & j mod 2 = 1) then (     execute swap(arr, i, j) ; 
     break ) else skip )  ;     j := j + 1 ) ) else skip ; )  ;     i := i + 1 ) ; 
    execute printArray(arr, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class CodeForces {
  public static void main(String[] args)throws Exception {
    Scanner input=new Scanner(new File("input.txt"));
    PrintWriter out=new PrintWriter(new File("output.txt"));
    String s=input.next();
    int a=input.nextInt();
    if(s.equals("front")){
      if(a==1){
        out.println("L");
      }
      else {
        out.println("R");
      }
    }
    else {
      if(a==1){
        out.println("R");
      }
      else {
        out.println("L");
      }
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile("input.txt")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("output.txt")) ;
    var s : String ; s := input.getCurrent() ;
    var a : int ; a := input.getCurrent()->toInteger() ;
    if (s = "front") then (     if (a = 1) then (     skip ) else (     skip ) ) else (     if (a = 1) then (     skip ) else (     skip ) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try {
      FileReader input=new FileReader("input.txt");
      FileWriter output=new FileWriter("output.txt");
      PrintWriter out=new PrintWriter(output);
      Scanner sc=new Scanner(input);
      String ent=sc.next();
      int rail=sc.nextInt();
      if(ent.equals("back")){
        rail=rail-1 ;
      }
      out.print((rail==1)? "L" : "R");
      out.flush();
      out.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile("input.txt")) ;
     var output : OclFile ; output := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(output) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(input) ;
    var ent : String ; ent := sc.getCurrent() ;
    var rail : int ; rail := sc.getCurrent()->toInteger() ;
    if (ent = "back") then (     rail := (rail)->char2byte() - 1 ) else skip ; 
    skip ; 
    skip ; 
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner s=new Scanner(new File("input.txt"));
    String door=s.next();
    int rail=s.nextInt()-1 ;
    if("back".equals(door)){
      rail=1-rail ;
    }
    PrintWriter out=new PrintWriter(new File("output.txt"));
    out.println((rail==0)? "L" : "R");
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile("input.txt")) ;
     var door : String ; door := s.getCurrent() ;
    var rail : int ; rail := s.getCurrent()->toInteger() - 1 ;
    if ("back" = door) then (     rail := 1 - (rail)->char2byte() ) else skip ; 
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("output.txt")) ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader bf=new BufferedReader(new FileReader("input.txt"));
    PrintWriter pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    String dis=bf.readLine();
    int rail=Integer.parseInt(bf.readLine());
    if((dis.equals("front")&& rail==1)||(dis.equals("back")&& rail==2))pw.write("L");
    else if((dis.equals("front")&& rail==2)||(dis.equals("back")&& rail==1))pw.write("R");
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ;
    var dis : String ; dis := bf.readLine() ;
    var rail : int ; rail := (bf.readLine())->toInteger() ;
    if ((dis = "front" & rail = 1) or (dis = "back" & rail = 2)) then     skip else     if ((dis = "front" & rail = 2) or (dis = "back" & rail = 1)) then     skip ; else skip ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int product(int x,int y){
    if(x<y)return product(y,x);
    else if(y!=0)return(x+product(x,y-1));
    else return 0 ;
  }
  public static void main(String[] args){
    int x=5,y=2 ;
    System.out.println(product(x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation product( x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (x < y) then     return product(y, x) else     if (y /= 0) then     return (x + product(x, y - 1)) else     return 0 ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 5 ;
    var y : int ; y := 2 ;
     OclFile["System.out"].println(product(x, y)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    ArrayList<Integer[]>inputList=new ArrayList<>();
    while(input.ready()){
      final String[] inputStrArray=input.readLine().split(",");
      final Integer[] inputIntArray={
        Integer.parseInt(inputStrArray[0]),Integer.parseInt(inputStrArray[1])};
        inputList.add(inputIntArray);
      }
      final int[] ans=solver(inputList);
      System.out.println(ans[0]);
      System.out.println(ans[1]);
    }
    private static int[] solver(ArrayList<Integer[]>list){
      int prodSum=0 ;
      double sum=0 ;
      for(Integer[] each : list){
        prodSum+=each[0]*each[1];
        sum+=each[1];
      }
      final int[] ret={
        prodSum,(int)Math.round(sum/list.size())};
        return ret ;
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var inputList : Sequence(Sequence(int)) ; inputList := Sequence{} ;
    while (input.canRead()) do (     var inputStrArray : Sequence(String) ; inputStrArray := input.readLine()->split(",") ;
     var inputIntArray : Sequence(int) ; inputIntArray := Sequence{(inputStrArray[0+1])->toInteger(),(inputStrArray[1+1])->toInteger()} ;
     inputList := inputList->including(inputIntArray) ) ; 
    var ans : Sequence(int) ; ans := solver(inputList) ;
    OclFile["System.out"].println(ans[0+1]) ; 
    OclFile["System.out"].println(ans[1+1]) ; 
 );
  static   operation solver( list : Sequence(Sequence(int))) : Sequence(int)
  pre: true
  post: true
  activity: (     var prodSum : int ; prodSum := 0 ;
     var sum : double ; sum := 0 ;
    for (each : list) do ( (     prodSum := prodSum+(each[0+1] * each[1+1]) ; 
     sum := sum+(each[1+1]) )  ) ; 
    var ret : Sequence(int) ; ret := Sequence{prodSum,(sum / list->size())->round()->oclAsType(int)} ;
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication38 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num1=sc.nextInt();
    int num2=sc.nextInt();
    int counter=0 ;
    while(num1!=0 && num2!=0){
      if(num1==1 && num2==1){
        break ;
      }
      if(num1<=num2){
        num1++;
        num2-=2 ;
      }
      else {
        num1-=2 ;
        num2++;
      }
      counter++;
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication38 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num1 : int ; num1 := sc.getCurrent()->toInteger() ;
    var num2 : int ; num2 := sc.getCurrent()->toInteger() ;
    var counter : int ; counter := 0 ;
    while (num1 /= 0 & num2 /= 0) do (     if (num1 = 1 & num2 = 1) then (     break ) else skip ; 
     if (num1 <= num2) then (     num1 := num1 + 1 ; 
     num2 := num2-(2) ) else (     num1 := num1-(2) ; 
     num2 := num2 + 1 ) ;  
     counter := counter + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Program {
  public static void main(String[] args)throws FileNotFoundException {
    File file=new File("input.txt");
    String rails="" ;
    String door="" ;
    BufferedReader br=new BufferedReader(new FileReader(file));
    try {
      door=br.readLine();
      rails=br.readLine();
    }
    catch(IOException e){
      e.printStackTrace();
    }
    int rail=Integer.parseInt(rails);
    switch(rail){
      case 1 : if(door.equals("front")){
        try {
          FileWriter fw=new FileWriter("output.txt");
          fw.write("L");
          fw.close();
        }
        catch(Exception e){
          System.out.println(e);
        }
      }
      else {
        try {
          FileWriter fw=new FileWriter("output.txt");
          fw.write("R");
          fw.close();
        }
        catch(Exception e){
          e.printStackTrace();
        }
      }
      break ;
      case 2 : if(door.equals("front")){
        try {
          FileWriter fw=new FileWriter("output.txt");
          fw.write("R");
          fw.close();
        }
        catch(Exception e){
          e.printStackTrace();
        }
      }
      else {
        try {
          FileWriter fw=new FileWriter("output.txt");
          fw.write("L");
          fw.close();
        }
        catch(Exception e){
          e.printStackTrace();
        }
      }
      break ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Program {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var file : OclFile ; file := OclFile("input.txt") ;
     var rails : String ; rails := "" ;
    var door : String ; door := "" ;
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) ;
    try (     door := br.readLine() ; 
     rails := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
    var rail : int ; rail := (rails)->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (rail) ; 
       if _switchval = 1 then
     if (door = "front") then (     try (     var fw : OclFile ; fw := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
     skip ; 
     skip )   catch (e : ProgramException) do (     OclFile["System.out"].println(e) )
 ) else (     try (     var fw : OclFile ; fw := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
     skip ; 
     skip )   catch (e : ProgramException) do (     e.printStackTrace() )
 ) ;  
    break 
   else skip ;
       if _switchval = 2 then
     if (door = "front") then (     try (     var fw : OclFile ; fw := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
     skip ; 
     skip )   catch (e : ProgramException) do (     e.printStackTrace() )
 ) else (     try (     var fw : OclFile ; fw := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
     skip ; 
     skip )   catch (e : ProgramException) do (     e.printStackTrace() )
 ) ;  
    break 
   else skip ;
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static String newString(String s){
    int l=s.length();
    int freq[]=new int[26];
    for(int i=0 ; i<l ; i++){
      freq[s.charAt(i)-'a']+=1 ;
    }
    String ans="" ;
    for(int i=0 ; i<26 ; i++){
      for(int j=0 ; j<freq[i]; j++){
        ans+=(char)(97+i);
      }
    }
    return ans ;
  }
  public static void main(String args[]){
    String s="aabab" ;
    System.out.println(newString(s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation newString( s : String) : String
  pre: true
  post: true
  activity: (     var l : int ; l := s->size() ;
     var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < l do ( (     freq[s->at(i+1) - ('a')->char2byte()+1] := freq[s->at(i+1) - ('a')->char2byte()+1]+(1) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < 26 do ( (         var j : int ; j := 0 ; while j < freq[i+1] do ( (     ans := ans+((97 + i)->oclAsType(String)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "aabab" ;
     OclFile["System.out"].println(newString(s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int l=sc.nextInt();
    sc.close();
    String s=Integer.toBinaryString(l);
    int num1=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='1')num1++;
    }
    System.out.println((s.length())+" "+((s.length()-1)*2+num1-1));
    for(int i=0 ; i<s.length()-1 ; i++){
      System.out.println((i+1)+" "+(i+2)+" 0");
      System.out.println((i+1)+" "+(i+2)+" "+(int)(Math.pow(2,i)));
    }
    int tmp=(int)(Math.pow(2,s.length()-1));
    for(int i=1 ; i<s.length(); i++){
      if(s.charAt(i)=='1'){
        System.out.println((s.length()-i)+" "+(s.length())+" "+tmp);
        tmp+=(int)(Math.pow(2,s.length()-i-1));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    skip ; 
    var s : String ; s := (MathLib.decimal2binary(l) + "") ;
    var num1 : int ; num1 := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '1') then     num1 := num1 + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((s->size()) + " " + ((s->size() - 1) * 2 + num1 - 1)) ; 
        var i : int ; i := 0 ; while i < s->size() - 1 do ( (     OclFile["System.out"].println((i + 1) + " " + (i + 2) + " 0") ; 
     OclFile["System.out"].println((i + 1) + " " + (i + 2) + " " + (2->pow(i))->oclAsType(int)) )  ;     i := i + 1 ) ; 
    var tmp : int ; tmp := (2->pow(s->size() - 1))->oclAsType(int) ;
        var i : int ; i := 1 ; while i < s->size() do ( (     if (s->at(i+1) = '1') then (     OclFile["System.out"].println((s->size() - i) + " " + (s->size()) + " " + tmp) ; 
     tmp := tmp+((2->pow(s->size() - i - 1))->oclAsType(int)) ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long num_1=scanner.nextLong();
    long num_2=num_1 % 10 ;
    long num_3=num_1/10 ;
    if(num_2>=5)num_3++;
    num_1=num_3*10 ;
    System.out.println(num_1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num    var numlong : OclFile ; numlong := scanner.getCurrent()->toLong() : long ; num    var numlong : OclFile ; numlong := scanner.getCurrent()->toLong() := scanner.getCurrent()->toLong() ;
    var numnum    var numnumlong mod 10 : long ; numnumlong mod 10 := numnumnumnumnumlong mod 10 mod 10 mod 10 mod 10 : long ; numnum    var numnumlong mod 10 : long ; numnumlong mod 10 := numnumnumnumnumlong mod 10 mod 10 mod 10 mod 10 := numnumnumnumnum    var numnumlong mod 10 : long ; numnumlong mod 10 := numnumnumnumnumlong mod 10 mod 10 mod 10 mod 10 mod 10 mod 10 ;
    var num_3 : long ; num_3 := numnumnumnum_3 / 10 / 10 ;
    if (num5 >= 5) then     num_3 := num_3 + 1 ; else skip ; 
    numnum_1 := num_3 * 10 ; 
    OclFile["System.out"].println(num(numOclFile["System.out"].println(num(num_1)))) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import java.io.*;
public class Hello {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long n=in.nextLong();
    if(n % 10==0){
      pw.println(n);
    }
    else {
      long rem=n % 10 ;
      if(rem<5){
        pw.println(n-rem);
      }
      else {
        long v=10-rem ;
        pw.println(n+v);
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hello {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := in.getCurrent()->toLong() ;
    if (n mod 10 = 0) then (     skip ) else (     var rem : long ; rem := n mod 10 ;
     if (rem < 5) then (     skip ) else (     var v : long ; v := 10 - rem ;
     skip ) ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class RoundInt {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int i=n % 10 ;
    if(i<=5)n-=i ;
    else n+=(10-i);
    System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class RoundInt {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var i : int ; i := n mod 10 ;
    if (i <= 5) then     n := n-(i) else     n := n+((10 - i)) ; ;  
    OclFile["System.out"].println(n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Joysticks {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int first=sc.nextInt();
    int second=sc.nextInt();
    if(first>second){
      int temp=first ;
      first=second ;
      second=temp ;
    }
    int ans=0 ;
    while(first>0 && second>1){
      ans++;
      first++;
      second-=2 ;
      if(first>second){
        int temp=first ;
        first=second ;
        second=temp ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Joysticks {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var first : int ; first := sc.getCurrent()->toInteger() ;
    var second : int ; second := sc.getCurrent()->toInteger() ;
    if (first > second) then (     var temp : int ; temp := first ;
     first := second ; 
     second := temp ) else skip ; 
    var ans : int ; ans := 0 ;
    while (first > 0 & second > 1) do (     ans := ans + 1 ; 
     first := first + 1 ; 
     second := second-(2) ; 
     if (first > second) then (     var temp : int ; temp := first ;
     first := second ; 
     second := temp ) else skip ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int XorSum(int arr[],int n){
    int result=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] % 2!=0)result+=arr[i];
    }
    return result ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,6,3,4,5 };
      int n=arr.length ;
      System.out.println(XorSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation XorSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 /= 0) then     result := result+(arr[i+1]) ; else skip )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,6,3,4,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(XorSum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class RoundInt {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int i=n % 10 ;
    if(i<=5)n-=i ;
    else n+=(10-i);
    System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class RoundInt {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var i : int ; i := n mod 10 ;
    if (i <= 5) then     n := n-(i) else     n := n+((10 - i)) ; ;  
    OclFile["System.out"].println(n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int findSum(int N){
    return(N*(N+1)*(2*N-5)+4*N)/2 ;
  }
  public static void main(String arr[]){
    int N=3 ;
    System.out.println(findSum(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation findSum( N : int) : int
  pre: true
  post: true
  activity: (     return (N * (N + 1) * (2 * N - 5) + 4 * N) / 2 );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
     OclFile["System.out"].println(findSum(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static int findSum(int N){
    return(2*N*(N+1)*(4*N+17)+54*N)/6 ;
  }
  public static void main(String arr[]){
    int N=4 ;
    System.out.println(findSum(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation findSum( N : int) : int
  pre: true
  post: true
  activity: (     return (2 * N * (N + 1) * (4 * N + 17) + 54 * N) / 6 );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(findSum(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int fib[]=new int[100005];
  static void computeFibonacci(){
    fib[0]=1 ;
    fib[1]=1 ;
    for(int i=2 ; i<100005 ; i++){
      fib[i]=fib[i-1]+fib[i-2];
    }
  }
  static int countString(String str){
    int ans=1 ;
    int cnt=1 ;
    for(int i=1 ; i<str.length(); i++){
      if(str.charAt(i)==str.charAt(i-1)){
        cnt++;
      }
      else {
        ans=ans*fib[cnt];
        cnt=1 ;
      }
    }
    ans=ans*fib[cnt];
    return ans ;
  }
  public static void main(String[] args){
    String str="abdllldefkkkk" ;
    computeFibonacci();
    System.out.println(countString(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute fib : int := Integer.subrange(1,100005)->collect(0);
  static   operation computeFibonacci() : void
  pre: true
  post: true
  activity: (     fib[0+1] := 1 ; 
     fib[1+1] := 1 ; 
         var i : int ; i := 2 ; while i < 100005 do ( (     fib[i+1] := fib[i - 1+1] + fib[i - 2+1] )  ;     i := i + 1 ) );
  static   operation countString( str : String) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
     var cnt : int ; cnt := 1 ;
        var i : int ; i := 1 ; while i < str->size() do ( (     if (str->at(i+1) = str->at(i - 1+1)) then (     cnt := cnt + 1 ) else (     ans := ans * fib[cnt+1] ; 
     cnt := 1 ) )  ;     i := i + 1 ) ; 
    ans := ans * fib[cnt+1] ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abdllldefkkkk" ;
     execute computeFibonacci() ; 
     OclFile["System.out"].println(countString(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int n=3 ;
  static class Pair {
    int first,second ;
    Pair(int a,int b){
      first=a ;
      second=b ;
    }
  }
  static int minSteps(int arr[][]){
    boolean v[][]=new boolean[n][n];
    Queue<Pair>q=new LinkedList<Pair>();
    q.add(new Pair(0,0));
    int depth=0 ;
    while(q.size()!=0){
      int x=q.size();
      while(x-->0){
        Pair y=q.peek();
        int i=y.first,j=y.second ;
        q.remove();
        if(v[i][j])continue ;
        if(i==n-1 && j==n-1)return depth ;
        v[i][j]=true ;
        if(i+arr[i][j]<n)q.add(new Pair(i+arr[i][j],j));
        if(j+arr[i][j]<n)q.add(new Pair(i,j+arr[i][j]));
      }
      depth++;
    }
    return-1 ;
  }
  public static void main(String args[]){
    int arr[][]={
      {
        1,1,1 },{
          1,1,1 },{
            1,1,1 }
          };
          System.out.println(minSteps(arr));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute n : int := 3;
  static class Pair {
   attribute first : int;
   static operation newPair( a : int, b : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     first := a ; 
     second := b );
}
  static   operation minSteps( arr : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var v : Sequence(Sequence(boolean)) ; v := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ;
     var q : Sequence(Map) ; q := Sequence{} ;
    q := q->including(Map(0, 0)) ; 
    var depth : int ; depth := 0 ;
    while (q->size() /= 0) do (     var x : int ; x := q->size() ;
         while (x > 0) do (        x := x - 1 ;     skip ; (     var y : Map ; y := q->min() ;
     var i : int ; i := y->at("first") ;
    var j : int ; j := y->at("second") ;
    q := q.remove() ; 
    if (v[i+1][j+1]) then     continue else skip ; 
    if (i = n - 1 & j = n - 1) then     return depth else skip ; 
    v[i+1][j+1] := true ; 
    if (i + arr[i+1][j+1] < n) then     q := q->including(Map(i + arr[i+1][j+1], j)) ; else skip ; 
    if (j + arr[i+1][j+1] < n) then     q := q->including(Map(i, j + arr[i+1][j+1])) ; else skip ; 
 ) ;  ) ;  
     depth := depth + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,1,1},Sequence{1,1,1},Sequence{1,1,1}} ;
     OclFile["System.out"].println(minSteps(arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void reArrange(String words[],int n){
    HashMap<String,Integer>freq=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      freq.put(words[i],(i+1));
    }
    Arrays.sort(words);
    for(int i=0 ; i<n ; i++)System.out.print(freq.get(words[i])+" ");
  }
  public static void main(String[] args){
    String words[]={
      "live","place","travel","word","sky" };
      int n=words.length ;
      reArrange(words,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation reArrange( words : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (     var freq : Map(String,int) ; freq := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     freq := freq->union(Map{words[i+1] |-> (i + 1)}) )  ;     i := i + 1 ) ; 
     words := words->sort() ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(freq->at(words[i+1]) + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var words : Sequence(String) ; words := Sequence{"live","place","travel","word","sky"} ;
     var n : int ; n := words->size() ;
     execute reArrange(words, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void find_Solution(double x,int n){
    double sum=x,e=2,o=1,p=1 ;
    for(int i=2 ; i<=n ; i++){
      p+=2 ;
      sum+=(double)(o/e)*(double)(Math.pow(x,p)/p);
      o=o*(o+2);
      e=e*(e+2);
    }
    System.out.println(sum);
  }
  public static void main(String[] args){
    double x=-0.5 ;
    if(Math.abs(x)>=1){
      System.out.println("Invalid Input");
    }
    int n=8 ;
    find_Solution(x,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation find_Solution( x : double, n : int) : void
  pre: true
  post: true
  activity: (     var sum : double ; sum := x ;
    var e : double ; e := 2 ;
    var o : double ; o := 1 ;
    var p : double ; p := 1 ;
         var i : int ; i := 2 ; while i <= n do ( (     p := p+(2) ; 
     sum := sum+((o / e)->oclAsType(double) * (x->pow(p) / p)->oclAsType(double)) ; 
     o := o * (o + 2) ; 
     e := e * (e + 2) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sum) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : double ; x := -0.5 ;
     if (if x < 0 then -(x) else x endif >= 1) then (     OclFile["System.out"].println("Invalid Input") ) else skip ; 
     var n : int ; n := 8 ;
     execute find_Solution(x, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int[][] orders=new int[n][2];
    for(int i=0 ; i<n ; i++){
      String[] values=br.readLine().split(" ");
      orders[i][0]=Integer.parseInt(values[0]);
      orders[i][1]=Integer.parseInt(values[1]);
    }
    Arrays.sort(orders,(a,b)->(a[1]-b[1]));
    int ans=0 ;
    int last=0 ;
    for(int i=0 ; i<n ; i++){
      if(orders[i][0]>last){
        ans++;
        last=orders[i][1];
      }
    }
    System.out.println(ans);
    br.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var orders : Sequence(Sequence(int)) ; orders := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var values : Sequence(String) ; values := br.readLine()->split(" ") ;
     orders[i+1][0+1] := (values[0+1])->toInteger() ; 
     orders[i+1][1+1] := (values[1+1])->toInteger() )  ;     i := i + 1 ) ; 
    orders := OclComparator.sortWith(orders, lambda (a , b) : OclAny in (a[1+1] - b[1+1])) ; 
    var ans : int ; ans := 0 ;
    var last : int ; last := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (orders[i+1][0+1] > last) then (     ans := ans + 1 ; 
     last := orders[i+1][1+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class B_Restaurant {
  static Scanner in=new Scanner(System.in);
  static class Restrurent implements Comparable<Restrurent>{
    long start,end ;
    public Restrurent(long start,long end){
      this.start=start ;
      this.end=end ;
    }
    @ Override public int compareTo(Restrurent t){
      if(this.end>t.end){
        return 1 ;
      }
      else if(this.end<t.end){
        return-1 ;
      }
      return 0 ;
    }
    @ Override public String toString(){
      return "Restrurent{"+"start="+start+",end="+end+'}' ;
    }
  }
  public static void main(String[] amit){
    int n=in.nextInt();
    Restrurent a[]=new Restrurent[n];
    for(int i=0 ; i<n ; i++){
      a[i]=new Restrurent(in.nextLong(),in.nextLong());
    }
    Arrays.sort(a);
    int ans=1 ;
    for(int i=0 ; i<n-1 ; i++){
      int index=i ;
      while(i+1<n && a[index] .end>=a[i+1] .start){
        i++;
      }
      if(i>=n){
        break ;
      }
      if(i+1<n && a[index] .end<=a[i+1] .start){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Restaurant {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static class Restrurent implements Comparable<Restrurent> {
   attribute start : long;
   static operation newRestrurent( start : long, end : long) : Restrurent
  pre: true
  post: true
  activity:
  ( var self : Restrurent ;
    self := createRestrurent();
    self.initialise(start, end);
    return self );
  operation initialise( start : long, end : long) : void
  pre: true  post: true
  activity: (     self.start := start ; 
     self.end := end );
      operation compareTo( t : Restrurent) : int
  pre: true
  post: true
  activity: (     if (self.end > t.end) then (     return 1 ) else     if (self.end < t.end) then (     return -1 ) else skip ; ;  
     return 0 );
      operation toString() : String
  pre: true
  post: true
  activity: (     return "Restrurent{" + "start=" + start + ",end=" + end + '}' );
}
  static   operation main( amit : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(Restrurent) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := Restrurent.newRestrurent(in.getCurrent()->toLong(), in.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var index : int ; index := i ;
     while (i + 1 < n & a[index+1].end >= a[i + 1+1].start) do (     i := i + 1 ) ; 
     if (i >= n) then (     break ) else skip ; 
     if (i + 1 < n & a[index+1].end <= a[i + 1+1].start) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Joysticks {
  static MyScanner sc ;
  public static void main(String[] args){
    sc=new MyScanner();
    out=new PrintWriter(new BufferedOutputStream(System.out));
    int a1=sc.nextInt(),a2=sc.nextInt();
    if(a1<2 && a2<2){
      out.println("0");
    }
    else {
      int count=0 ;
      while(a1>0 && a2>0){
        if(a1>a2){
          a2+=1 ;
          a1-=2 ;
        }
        else {
          a1+=1 ;
          a2-=2 ;
        }
        count++;
      }
      out.println(count);
    }
    out.close();
  }
  public static void printArr(int[] arr){
    for(int x : arr)out.print(x+' ');
    out.println();
  }
  public static int[] readArr(int n){
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    return arr ;
  }
  public static PrintWriter out ;
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Joysticks {
  static   attribute sc : MyScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := MyScanner.newMyScanner() ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var a1 : int ; a1 := sc.nextInt() ;
    var a2 : int ; a2 := sc.nextInt() ;
    if (a1 < 2 & a2 < 2) then (     out.println("0") ) else (     var count : int ; count := 0 ;
     while (a1 > 0 & a2 > 0) do (     if (a1 > a2) then (     a2 := a2+(1) ; 
     a1 := a1-(2) ) else (     a1 := a1+(1) ; 
     a2 := a2-(2) ) ;  
     count := count + 1 ) ; 
     out.println(count) ) ;  
    out.close() ; 
 );
  static   operation printArr( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     for (x : arr) do (     out.print(x + ' ') ;  ) ; 
     out.println() );
  static   operation readArr( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
     return arr );
  static   attribute out : OclFile;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class SortExample {
  static void mySort(Integer[] arr){
    int n=arr.length ;
    Arrays.sort(arr,0,n/2);
    Arrays.sort(arr,n/2,n);
    int low=n/2,high=n-1 ;
    while(low<high){
      Integer temp=arr[low];
      arr[low]=arr[high];
      arr[high]=temp ;
      low++;
      high--;
    }
  }
  public static void main(String[] args){
    Integer[] arr={
      5,4,6,2,1,3,8,9,7 };
      mySort(arr);
      System.out.printf("Modified arr[] : %s",Arrays.toString(arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class SortExample {
  static   operation mySort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
     arr := arr.subrange(1,0)^(arr.subrange(0+1,n / 2)->sort())^arr.subrange(n / 2+1,arr.size) ; 
    arr := arr.subrange(1,n / 2)^(arr.subrange(n / 2+1,n)->sort())^arr.subrange(n+1,arr.size) ; 
    var low : int ; low := n / 2 ;
    var high : int ; high := n - 1 ;
    while (low < high) do (     var temp : int ; temp := arr[low+1] ;
     arr[low+1] := arr[high+1] ; 
    arr[high+1] := temp ; 
    low := low + 1 ; 
    high := high - 1 ; 
 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,4,6,2,1,3,8,9,7} ;
     execute mySort(arr) ; 
     OclFile["System.out"].printf("Modified arr[] : %s", (arr + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class probB {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    ArrayList<Character>vowels=new ArrayList<Character>();
    vowels.add('a');
    vowels.add('e');
    vowels.add('i');
    vowels.add('o');
    vowels.add('u');
    int c1=0,c2=0,c3=0,c4=0 ;
    String s1=in.next();
    String s2=in.next();
    boolean flag=true ;
    if(s1.length()==s2.length()){
      for(int i=0 ; i<s1.length(); i++){
        if(vowels.contains(s1.charAt(i))&& vowels.contains(s2.charAt(i))){
          continue ;
        }
        else if(! vowels.contains(s1.charAt(i))&& ! vowels.contains(s2.charAt(i))){
          continue ;
        }
        else {
          flag=false ;
        }
      }
      if(flag){
        pw.println("Yes");
      }
      else {
        pw.println("No");
      }
    }
    else {
      pw.println("No");
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class probB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var vowels : Sequence(String) ; vowels := Sequence{} ;
    vowels := vowels->including('a') ; 
    vowels := vowels->including('e') ; 
    vowels := vowels->including('i') ; 
    vowels := vowels->including('o') ; 
    vowels := vowels->including('u') ; 
    var c1 : int ; c1 := 0 ;
    var c2 : int ; c2 := 0 ;
    var c3 : int ; c3 := 0 ;
    var c4 : int ; c4 := 0 ;
    var s1 : String ; s1 := in.getCurrent() ;
    var s2 : String ; s2 := in.getCurrent() ;
    var flag : boolean ; flag := true ;
    if (s1->size() = s2->size()) then (         var i : int ; i := 0 ; while i < s1->size() do ( (     if (vowels->includes(s1->at(i+1)) & vowels->includes(s2->at(i+1))) then (     continue ) else     if (not(vowels->includes(s1->at(i+1))) & not(vowels->includes(s2->at(i+1)))) then (     continue ) else (     flag := false ) ;  )  ;     i := i + 1 ) ; 
     if (flag) then (     skip ) else (     skip ) ) else (     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class Main {
  static class Pair {
    int first ;
    int second ;
    public Pair(int x,int y){
      this.first=x ;
      this.second=y ;
    }
  }
  static void min_subarray(int[] a,int n){
    Stack<Pair>st=new Stack<Pair>();
    for(int i=0 ; i<n ; ++i){
      int count=1 ;
      while(st.empty()==false && st.peek().first>a[i]){
        count+=st.peek().second ;
        st.pop();
      }
      st.push(new Pair(a[i],count));
      System.out.print(count+" ");
    }
  }
  public static void main(String[] args){
    int[] a={
      5,4,3,2,1 };
      int n=a.length ;
      min_subarray(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Pair {
   attribute first : int;
   attribute second : int;
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self->at("first") := x ; 
     self->at("second") := y );
}
  static   operation min_subarray( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var st : Sequence(Map) ; st := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     var count : int ; count := 1 ;
     while (st->isEmpty() = false & st->min()->at("first") > a[i+1]) do (     count := count+(st->min()->at("second")) ; 
     st := st->front() ) ; 
     st := st->append(Map(a[i+1], count)) ; 
     OclFile["System.out"].print(count + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{5,4,3,2,1} ;
     var n : int ; n := a->size() ;
     execute min_subarray(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getMin(int arr[],int n,int k){
    int res=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] % k==0){
        res=Math.min(res,arr[i]);
      }
    }
    return res ;
  }
  static int getMax(int arr[],int n,int k){
    int res=Integer.MIN_VALUE ;
    for(int i=1 ; i<n ; i++){
      if(arr[i] % k==0){
        res=Math.max(res,arr[i]);
      }
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      10,1230,45,67,1 };
      int k=10 ;
      int n=arr.length ;
      System.out.println("Minimum element of array which is divisible by k: "+getMin(arr,n,k));
      System.out.println("Maximum element of array which is divisible by k: "+getMax(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getMin( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 2147483647 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod k = 0) then (     res := Set{res, arr[i+1]}->min() ) else skip )  ;     i := i + 1 ) ; 
     return res );
  static   operation getMax( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := -2147483648 ;
         var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] mod k = 0) then (     res := Set{res, arr[i+1]}->max() ) else skip )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,1230,45,67,1} ;
     var k : int ; k := 10 ;
    var n : int ; n := arr->size() ;
    OclFile["System.out"].println("Minimum element of array which is divisible by k: " + getMin(arr, n, k)) ; 
    OclFile["System.out"].println("Maximum element of array which is divisible by k: " + getMax(arr, n, k)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    for(int i=0 ; i<1000 ; i++){
      char[] cs=in.readLine().toCharArray();
      boolean isPass=true ;
      for(int n=1 ; n<cs.length && isPass ; n++){
        char now=cs[n-1];
        char next=cs[n];
        isPass &=(now+1==next &&(now!='C' && now!='F'))||('G'>now &&((char)(now+3)==next))||('C'<now && now-3==next)||(now-1==next &&(now-'A')% 3!=0);
      }
      if(isPass){
        System.out.println(cs);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
         var i : int ; i := 0 ; while i < 1000 do ( (     var cs : Sequence(String) ; cs := in.readLine()->characters() ;
     var isPass : boolean ; isPass := true ;
         var n : int ; n := 1 ; while n < cs->size() & isPass do ( (     var now : String ; now := cs[n - 1+1] ;
     var next : String ; next := cs[n+1] ;
     isPass := MathLib.bitwiseAnd(isPass, (now + 1 = next & (now /= 'C' & now /= 'F')) or ('G' > now & ((now + 3)->oclAsType(String) = next)) or ('C' < now & (now)->char2byte() - 3 = next) or ((now)->char2byte() - 1 = next & ((now)->char2byte() - ('A')->char2byte()) mod 3 /= 0)) )  ;     n := n + 1 ) ; 
     if (isPass) then (     OclFile["System.out"].println(cs) ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    Boolean[][] check=new Boolean[9][9];
    for(int i=0 ; i<9 ; i++){
      for(int j=0 ; j<9 ; j++){
        check[i][j]=false ;
      }
    }
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<3 ; j++){
        if(i+1<3){
          check[i*3+j][(i+1)*3+j]=true ;
          check[(i+1)*3+j][i*3+j]=true ;
        }
        if(i-1>=0){
          check[i*3+j][(i-1)*3+j]=true ;
          check[(i-1)*3+j][i*3+j]=true ;
        }
        if(j+1<3){
          check[i*3+j][i*3+j+1]=true ;
          check[i*3+j+1][i*3+j]=true ;
        }
        if(j-1>=0){
          check[i*3+j][i*3+j-1]=true ;
          check[i*3+j-1][i*3+j]=true ;
        }
      }
    }
    for(int i=0 ; i<1000 ; i++){
      String S=sc.next();
      int now=S.charAt(0)-'A' ;
      boolean f=true ;
      for(int j=1 ; j<S.length(); j++){
        int next=S.charAt(j)-'A' ;
        if(check[now][next]){
          now=next ;
          continue ;
        }
        else {
          f=false ;
          break ;
        }
      }
      if(f){
        System.out.println(S);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var check : Sequence(Sequence(Boolean)) ; check := Integer.subrange(1,9)->collect(Integer.subrange(1,9)->collect(null)) ;
        var i : int ; i := 0 ; while i < 9 do ( (         var j : int ; j := 0 ; while j < 9 do ( (     check[i+1][j+1] := false )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     if (i + 1 < 3) then (     check[i * 3 + j+1][(i + 1) * 3 + j+1] := true ; 
     check[(i + 1) * 3 + j+1][i * 3 + j+1] := true ) else skip ; 
     if (i - 1 >= 0) then (     check[i * 3 + j+1][(i - 1) * 3 + j+1] := true ; 
     check[(i - 1) * 3 + j+1][i * 3 + j+1] := true ) else skip ; 
     if (j + 1 < 3) then (     check[i * 3 + j+1][i * 3 + j + 1+1] := true ; 
     check[i * 3 + j + 1+1][i * 3 + j+1] := true ) else skip ; 
     if (j - 1 >= 0) then (     check[i * 3 + j+1][i * 3 + j - 1+1] := true ; 
     check[i * 3 + j - 1+1][i * 3 + j+1] := true ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 1000 do ( (     var S : String ; S := sc.getCurrent() ;
     var now : int ; now := S->at(0+1) - ('A')->char2byte() ;
    var f : boolean ; f := true ;
        var j : int ; j := 1 ; while j < S->size() do ( (     var next : int ; next := S->at(j+1) - ('A')->char2byte() ;
     if (check[now+1][next+1]) then (     now := next ; 
     continue ) else (     f := false ; 
     break ) )  ;     j := j + 1 ) ; 
    if (f) then (     OclFile["System.out"].println(S) ) else skip ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static final int NUM=1000 ;
  private static int[][] graph={
    {
      0 },{
        1,0 },{
          0,1,0 },{
            1,0,0,0 },{
              0,1,0,1,0 },{
                0,0,1,0,1,0 },{
                  0,0,0,1,0,0,0 },{
                    0,0,0,0,1,0,1,0 },{
                      0,0,0,0,0,1,0,1,0 },};
                      private static boolean check(String str){
                        char[] array=str.toCharArray();
                        for(int i=0 ; i<array.length-1 ; i++)if(! neighbor(array[i],array[i+1]))return false ;
                        return true ;
                      }
                      private static boolean neighbor(char p,char n){
                        if(p<n)return graph[n-'A'][p-'A']==1 ;
                        else return graph[p-'A'][n-'A']==1 ;
                      }
                      public static void main(String[] args)throws IOException {
                        BufferedReader br=new BufferedReader(new InputStreamReader(System.in),1);
                        for(int i=0 ; i<NUM ; i++){
                          String s=br.readLine();
                          if(check(s))System.out.println(s);
                        }
                      }
                    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute NUM : int := 1000;
  static   attribute graph : Sequence(Sequence(int)) := Sequence{Sequence{0},Sequence{1,0},Sequence{0,1,0},Sequence{1,0,0,0},Sequence{0,1,0,1,0},Sequence{0,0,1,0,1,0},Sequence{0,0,0,1,0,0,0},Sequence{0,0,0,0,1,0,1,0},Sequence{0,0,0,0,0,1,0,1,0},};
  static   operation check( str : String) : boolean
  pre: true
  post: true
  activity: (     var array : Sequence(String) ; array := str->characters() ;
         var i : int ; i := 0 ; while i < array->size() - 1 do (     if (not(neighbor(array[i+1], array[i + 1+1]))) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation neighbor( p : String, n : String) : boolean
  pre: true
  post: true
  activity: (     if (p < n) then     return graph[n - ('A')->char2byte()+1][p - ('A')->char2byte()+1] = 1 else     return graph[p - ('A')->char2byte()+1][n - ('A')->char2byte()+1] = 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 1) ;
         var i : int ; i := 0 ; while i < NUM do ( (     var s : String ; s := br.readLine() ;
     if (check(s)) then     OclFile["System.out"].println(s) ; else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    for(int i=0 ; i<1000 ; i++){
      String s=sc.next();
      boolean flag=true ;
      if(s.length()>1){
        for(int j=1 ; j<s.length(); j++){
          int pre=s.codePointAt(j-1);
          int nex=s.codePointAt(j);
          if(pre==69 && nex % 2==0)continue ;
          if(pre % 2==0 && nex==69)continue ;
          if(pre==65 &&(nex==66 || nex==68))continue ;
          if(pre==66 &&(nex==65 || nex==67))continue ;
          if(pre==67 &&(nex==66 || nex==70))continue ;
          if(pre==68 &&(nex==65 || nex==71))continue ;
          if(pre==70 &&(nex==67 || nex==73))continue ;
          if(pre==71 &&(nex==68 || nex==72))continue ;
          if(pre==72 &&(nex==71 || nex==73))continue ;
          if(pre==73 &&(nex==70 || nex==72))continue ;
          flag=false ;
          break ;
        }
      }
      if(flag==true)System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var i : int ; i := 0 ; while i < 1000 do ( (     var s : String ; s := sc.getCurrent() ;
     var flag : boolean ; flag := true ;
     if (s->size() > 1) then (         var j : int ; j := 1 ; while j < s->size() do ( (     var pre : int ; pre := s.codePointAt(j - 1) ;
     var nex : int ; nex := s.codePointAt(j) ;
    if (pre = 69 & nex mod 2 = 0) then     continue else skip ; 
    if (pre mod 2 = 0 & nex = 69) then     continue else skip ; 
    if (pre = 65 & (nex = 66 or nex = 68)) then     continue else skip ; 
    if (pre = 66 & (nex = 65 or nex = 67)) then     continue else skip ; 
    if (pre = 67 & (nex = 66 or nex = 70)) then     continue else skip ; 
    if (pre = 68 & (nex = 65 or nex = 71)) then     continue else skip ; 
    if (pre = 70 & (nex = 67 or nex = 73)) then     continue else skip ; 
    if (pre = 71 & (nex = 68 or nex = 72)) then     continue else skip ; 
    if (pre = 72 & (nex = 71 or nex = 73)) then     continue else skip ; 
    if (pre = 73 & (nex = 70 or nex = 72)) then     continue else skip ; 
    flag := false ; 
    break 
 )  ;     j := j + 1 ) ) else skip ; 
     if (flag = true) then     OclFile["System.out"].println(s) ; else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args)throws IOException {
    int dx[]={
      0,1,0,-1 };
      int dy[]={
        1,0,-1,0 };
        BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
        for(int i=0 ; i<1000 ; i++){
          String line=in.readLine();
          boolean ok=true ;
          int p=(int)(line.charAt(0)-'A');
          for(int j=1 ; j<line.length(); j++){
            boolean ok2=false ;
            for(int k=0 ; k<4 ; k++){
              int nx=p % 3+dx[k];
              int ny=p/3+dy[k];
              if(!(0<=nx && nx<3 && 0<=ny && ny<3))continue ;
              if((char)((nx+ny*3)+'A')==line.charAt(j))ok2=true ;
            }
            if(! ok2){
              ok=false ;
              break ;
            }
            p=(int)(line.charAt(j)-'A');
          }
          if(ok)System.out.println(line);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var dx : Sequence(int) ; dx := Sequence{0,1,0,-1} ;
     var dy : Sequence(int) ; dy := Sequence{1,0,-1,0} ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
         var i : int ; i := 0 ; while i < 1000 do ( (     var line : String ; line := in.readLine() ;
     var ok : boolean ; ok := true ;
    var p : int ; p := (line->at(0+1) - ('A')->char2byte())->oclAsType(int) ;
        var j : int ; j := 1 ; while j < line->size() do ( (     var ok2 : boolean ; ok2 := false ;
         var k : int ; k := 0 ; while k < 4 do ( (     var nx : int ; nx := p mod 3 + dx[k+1] ;
     var ny : int ; ny := p / 3 + dy[k+1] ;
     if (not((0 <= nx & nx < 3 & 0 <= ny & ny < 3))) then     continue else skip ; 
     if (((nx + ny * 3) + 'A')->oclAsType(String) = line->at(j+1)) then     ok2 := true ; else skip )  ;     k := k + 1 ) ; 
     if (not(ok2)) then (     ok := false ; 
     break ) else skip ; 
     p := (line->at(j+1) - ('A')->char2byte())->oclAsType(int) )  ;     j := j + 1 ) ; 
    if (ok) then     OclFile["System.out"].println(line) ; else skip ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maxSumArrangement(int A[],int R[][],int N,int M){
    int count[]=new int[N];
    int i ;
    for(i=0 ; i<M ; ++i){
      int l=R[i][0],r=R[i][1]+1 ;
      l--;
      r--;
      count[l]++;
      if(r<N)count[r]--;
    }
    for(i=1 ; i<N ; ++i){
      count[i]+=count[i-1];
    }
    int ans=0 ;
    Arrays.sort(count);
    Arrays.sort(A);
    for(i=N-1 ; i>=0 ; --i){
      ans+=A[i]*count[i];
    }
    return ans ;
  }
  public static void main(String[] args){
    int A[]={
      2,6,10,1,5,6 };
      int R[][]={
        {
          1,3 },{
            4,6 },{
              3,4 }
            };
            int N=A.length ;
            int M=R.length ;
            System.out.print(maxSumArrangement(A,R,N,M));
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSumArrangement( A : Sequence(int), R : Sequence(Sequence(int)), N : int, M : int) : int
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,N)->collect(0) ;
     var i : int ;
        i := 0 ; while i < M do ( (     var l : int ; l := R[i+1][0+1] ;
    var r : int ; r := R[i+1][1+1] + 1 ;
     l := l - 1 ; 
    r := r - 1 ; 
    count[l+1] := count[l+1] + 1 ; 
    if (r < N) then     count[r+1] := count[r+1] - 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
        i := 1 ; while i < N do ( (     count[i+1] := count[i+1]+(count[i - 1+1]) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    count := count->sort() ; 
    A := A->sort() ; 
        i := N - 1 ; while i >= 0 do ( (     ans := ans+(A[i+1] * count[i+1]) )  ;     i := i - 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{2,6,10,1,5,6} ;
     var R : Sequence(Sequence(int)) ; R := Sequence{Sequence{1,3},Sequence{4,6},Sequence{3,4}} ;
    var N : int ; N := A->size() ;
    var M : int ; M := R->size() ;
    OclFile["System.out"].print(maxSumArrangement(A, R, N, M)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int a=in.nextInt(),b=in.nextInt();
    int c=0 ;
    if(a==1 && b==1){
      pw.println(0);
    }
    else {
      while(a>=1 || b>=1){
        if(a>=b){
          b++;
          a-=2 ;
        }
        else {
          a++;
          b-=2 ;
        }
        if(a<=0 || b<=0){
          c++;
          break ;
        }
        c++;
      }
      pw.println(c);
    }
    pw.close();
  }
  static void swap(int a,int b){
    int t=b ;
    b=a ;
    a=t ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
    if (a = 1 & b = 1) then (     skip ) else (     while (a >= 1 or b >= 1) do (     if (a >= b) then (     b := b + 1 ; 
     a := a-(2) ) else (     a := a + 1 ; 
     b := b-(2) ) ;  
     if (a <= 0 or b <= 0) then (     c := c + 1 ; 
     break ) else skip ; 
     c := c + 1 ) ; 
     skip ) ;  
    skip ; 
 );
  static   operation swap( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var t : int ; t := b ;
     b := a ; 
     a := t );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void product_subarrays(int arr[],int n){
    int product=1 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i ; j<n ; j++){
        product*=arr[j];
      }
    }
    System.out.println(product+"\n");
  }
  public static void main(String args[]){
    int arr[]={
      10,3,7 };
      int n=arr.length ;
      product_subarrays(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation product_subarrays( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var product : int ; product := 1 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i ; while j < n do ( (     product := product*(arr[j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(product + "\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,3,7} ;
     var n : int ; n := arr->size() ;
     execute product_subarrays(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    double max=Double.MIN_VALUE,min=Double.MAX_VALUE ;
    String line="" ;
    while((line=br.readLine())!=null){
      double data=Double.parseDouble(line);
      max=Math.max(max,data);
      min=Math.min(min,data);
    }
    System.out.println(max-min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var max : double ; max := 2->pow(-1074) ;
    var min : double ; min := (2 - 2->pow(-52))*(2->pow(1023)) ;
    var line : String ; line := "" ;
        line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     var data : double ; data := (line)->toReal() ;
     max := Set{max, data}->max() ; 
     min := Set{min, data}->min() ) ;     line := br.readLine() ;
 ) ;  
    OclFile["System.out"].println(max - min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Hashtable ;
import java.util.Stack ;
import java.util.StringTokenizer ;
import java.util.TreeMap ;
public class A {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    String s=sc.next();
    String t=sc.next();
    boolean answer=true ;
    if(s.length()!=t.length()){
      answer=false ;
    }
    else {
      for(int i=0 ; i<s.length(); i++){
        char c=s.charAt(i);
        char k=t.charAt(i);
        boolean first=(c=='a' || c=='e' || c=='i' || c=='o' || c=='u');
        boolean second=(k=='a' || k=='e' || k=='i' || k=='o' || k=='u');
        if(first!=second){
          answer=false ;
        }
      }
    }
    System.out.println(answer ? "Yes" : "No");
  }
}
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 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var s : String ; s := sc.next() ;
    var t : String ; t := sc.next() ;
    var answer : boolean ; answer := true ;
    if (s->size() /= t->size()) then (     answer := false ) else (         var i : int ; i := 0 ; while i < s->size() do ( (     var c : String ; c := s->at(i+1) ;
     var k : String ; k := t->at(i+1) ;
    var first : boolean ; first := (c = 'a' or c = 'e' or c = 'i' or c = 'o' or c = 'u') ;
    var second : boolean ; second := (k = 'a' or k = 'e' or k = 'i' or k = 'o' or k = 'u') ;
    if (first /= second) then (     answer := false ) else skip ; 
 )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(if answer then "Yes" else "No" endif) ; 
 );
}
class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.System.*;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws Exception {
    ArrayList<Double>d=new ArrayList<>();
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String buf ;
    while(true){
      buf=br.readLine();
      if(buf==null)break ;
      d.add(Double.parseDouble(buf));
    }
    double max=d.stream().max((a,b)->a.compareTo(b)).get();
    double min=d.stream().min((a,b)->a.compareTo(b)).get();
    out.println(max-min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : Sequence(double) ; d := Sequence{} ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var buf : String ;
    while (true) do (     buf := br.readLine() ; 
     if (buf = null) then     break else skip ; 
     d := d->including((buf)->toReal()) ) ; 
    var max : double ; max := d->max().get() ;
    var min : double ; min := d->min().get() ;
    out.println((max)->char2byte() - min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    double h,max,min ;
    h=sc.nextDouble();
    max=h ;
    min=h ;
    for(; sc.hasNext(); ){
      h=sc.nextDouble();
      if(max<h)max=h ;
      if(min>h)min=h ;
    }
    out.printf("%f%n",max-min);
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var h : double ;
    var max : double ;
    var min : double ;
    h := sc.nextDouble() ; 
    max := h ; 
    min := h ; 
      while sc.hasNext() do ( (     h := sc.nextDouble() ; 
     if (max < h) then     max := h ; else skip ; 
     if (min > h) then     min := h ; else skip )  ) ; 
    out.printf("%f%n", max - min) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    double h,max=0,min=Double.MAX_VALUE ;
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      h=sc.nextDouble();
      if(max<h){
        max=h ;
      }
      if(min>h){
        min=h ;
      }
    }
    System.out.println(max-min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var h : double ;
    var max : double ; max := 0 ;
    var min : double ; min := (2 - 2->pow(-52))*(2->pow(1023)) ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     h := sc.getCurrent()->toReal() ; 
     if (max < h) then (     max := h ) else skip ; 
     if (min > h) then (     min := h ) else skip ) ; 
     OclFile["System.out"].println(max - min) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.util.Arrays.*;
import static java.lang.Math.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    double[] tmp=new double[100000];
    int cnt=0 ;
    while(sc.hasNextDouble()){
      tmp[cnt++]=sc.nextDouble();
    }
    double[] ds=new double[cnt];
    for(int i=0 ; i<cnt ; i++)ds[i]=tmp[i];
    sort(ds);
    System.out.println(ds[cnt-1]-ds[0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var tmp : Sequence(double) ; tmp := Integer.subrange(1,100000)->collect(0.0) ;
     var cnt : int ; cnt := 0 ;
    while (sc.hasNextDouble()) do (      tmp[cnt+1] := sc.getCurrent()->toReal()  ; cnt := cnt + 1 ) ; 
    var ds : Sequence(double) ; ds := Integer.subrange(1,cnt)->collect(0.0) ;
        var i : int ; i := 0 ; while i < cnt do (     ds[i+1] := tmp[i+1] ;  ;     i := i + 1 ) ; 
    execute sort(ds) ; 
    OclFile["System.out"].println(ds[cnt - 1+1] - ds[0+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int[] print_num={
    0,1,2,3,4,5,6,7,8,9,5,4,3,2,1 };
    public static void main(String[] args){
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      for(int i=0 ; i<n ; i++){
        int from=sc.nextInt();
        int to=sc.nextInt();
        if(from>to){
          if(from<=5){
            from=15-from ;
            to=15-to ;
          }
          else if(to<=5){
            to=15-to ;
          }
          else {
            to+=15 ;
          }
        }
        boolean first=true ;
        for(int j=from ; j<=to ; j++){
          System.out.print((first ? "" : " ")+print_num[j>=15 ? j-15 : j]);
          if(first){
            first=false ;
          }
        }
        System.out.println();
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute print_num : Sequence(int) := Sequence{0,1,2,3,4,5,6,7,8,9,5,4,3,2,1};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var from : int ; from := sc.getCurrent()->toInteger() ;
     var to : int ; to := sc.getCurrent()->toInteger() ;
    if (from > to) then (     if (from <= 5) then (     from := 15 - from ; 
     to := 15 - to ) else     if (to <= 5) then (     to := 15 - to ) else (     to := to+(15) ) ;  ) else skip ; 
    var first : boolean ; first := true ;
        var j : int ; j := from ; while j <= to do ( (     OclFile["System.out"].print((if first then "" else " " endif) + print_num[if j >= 15 then j - 15 else j endif+1]) ; 
     if (first) then (     first := false ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  List<Integer>solve(int start,int arrival){
    final int[] busLine={
      0,1,2,3,4,5,6,7,8,9,5,4,3,2,1,0,1,2,3,4,5,6,7,8,9 };
      int len=busLine.length ;
      List<Integer>route=new ArrayList<Integer>();
      boolean riding=false ;
      for(int i=0 ; i<len ; ++i){
        if(busLine[i]==start){
          route.clear();
          riding=true ;
        }
        route.add(busLine[i]);
        if(riding && busLine[i]==arrival){
          break ;
        }
      }
      return route ;
    }
    void io(){
      Scanner s=new Scanner(System.in);
      int n=s.nextInt();
      for(int i=0 ; i<n ; ++i){
        boolean first=true ;
        for(int route : solve(s.nextInt(),s.nextInt())){
          if(first){
            first=false ;
          }
          else {
            System.out.print(" ");
          }
          System.out.print(route);
        }
        System.out.println();
      }
      s.close();
    }
    public static void main(String[] args){
      new Main().io();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve( start : int, arrival : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var busLine : Sequence(int) ; busLine := Sequence{0,1,2,3,4,5,6,7,8,9,5,4,3,2,1,0,1,2,3,4,5,6,7,8,9} ;
     var len : int ; len := busLine->size() ;
    var route : Sequence(int) ; route := Sequence{} ;
    var riding : boolean ; riding := false ;
        var i : int ; i := 0 ; while i < len do ( (     if (busLine[i+1] = start) then (     route := route->intersection(Set{}) ; 
     riding := true ) else skip ; 
     route := route->including(busLine[i+1]) ; 
     if (riding & busLine[i+1] = arrival) then (     break ) else skip )  ;     i := i + 1 ) ; 
    return route 
 );
   operation io() : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var first : boolean ; first := true ;
     for (route : solve(s.getCurrent()->toInteger(), s.getCurrent()->toInteger())) do ( (     if (first) then (     first := false ) else (     OclFile["System.out"].print(" ") ) ;  
     OclFile["System.out"].print(route) )  ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().io() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    PrintWriter out=new PrintWriter(System.out);
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    for(int i=0 ; i<n ; i++){
      byte s=Byte.parseByte(scan.next());
      byte g=Byte.parseByte(scan.next());
      if(s<g || s<=5)out.println(range(s,g));
      else {
        if(g>=6)out.println(range(s,9)+" "+range(5,0)+" "+range(1,g));
        else out.println(range(s,9)+" "+range(5,g));
      }
    }
    out.flush();
  }
  static String range(int p,int q){
    int d=p<q ? 1 :-1 ;
    String mes="" ;
    for(int i=p ; i!=q ; i+=d){
      mes+=i+" " ;
    }
    return mes+q ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var s : int ; s := (scan.getCurrent())->toInteger() ;
     var g : int ; g := (scan.getCurrent())->toInteger() ;
     if (s < g or s <= 5) then     skip ; else (     if (g >= 6) then     skip ; else     skip ; ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation range( p : int, q : int) : String
  pre: true
  post: true
  activity: (     var d : int ; d := if p < q then 1 else -1 endif ;
     var mes : String ; mes := "" ;
         var i : int ; i := p ; while i /= q do ( (     mes := mes+(i + " ") )  ;     i := i+(d) ) ; 
     return mes + q );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int[] xorQueries(int[] arr,int[][] queries){
    int[] res=new int[queries.length],q ;
    for(int i=1 ; i<arr.length ; i++)arr[i] ^=arr[i-1];
    for(int i=0 ; i<queries.length ; i++){
      q=queries[i];
      res[i]=q[0]>0 ? arr[q[0]-1] ^ arr[q[1] ] : arr[q[1] ];
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation xorQueries( arr : Sequence(int), queries : Sequence(Sequence(int))) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,queries->size())->collect(0) ;
    var q : Sequence(int) ;
         var i : int ; i := 1 ; while i < arr->size() do (     arr[i+1] := MathLib.bitwiseXor(arr[i+1],arr[i - 1+1]) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < queries->size() do ( (     q := queries[i+1] ; 
     res[i+1] := if q[0+1] > 0 then arr[q[0+1] - 1+1] xor arr[q[1+1]+1] else arr[q[1+1]+1] endif )  ;     i := i + 1 ) ; 
     return res );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.ArrayList ;
import java.util.Collection ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    int t=sc.nextInt();
    for(int ttt=0 ; ttt<t ; ttt++){
      int from=sc.nextInt();
      int to=sc.nextInt();
      int[] a=solve(from,to);
      System.out.print(a[0]);
      for(int i=1 ; i<a.length ; i++)System.out.print(" "+a[i]);
      System.out.println();
    }
  }
  int[] solve(int from,int to){
    int[] st={
      0,1,2,3,4,5,6,7,8,9,5,4,3,2,1,0,1,2,3,4,5,6,7,8,9,5,4,3,2,1,};
      ArrayList<Integer>ans=null ;
      for(int i=0 ; i<st.length/2 ; i++){
        if(st[i]==from){
          ArrayList<Integer>cur=new ArrayList<Integer>();
          int x=i ;
          while(st[x]!=to){
            cur.add(st[x]);
            x++;
          }
          cur.add(to);
          if(ans==null || ans.size()>cur.size()){
            ans=cur ;
          }
        }
      }
      return toIntArray(ans);
    }
    public static<T>int[] toIntArray(Collection<T>src){
      int[] res=new int[src.size()];
      int p=0 ;
      for(T x : src)res[p++]=(Integer)x ;
      return res ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
         var ttt : int ; ttt := 0 ; while ttt < t do ( (     var from : int ; from := sc.getCurrent()->toInteger() ;
     var to : int ; to := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := solve(from, to) ;
    OclFile["System.out"].print(a[0+1]) ; 
        var i : int ; i := 1 ; while i < a->size() do (     OclFile["System.out"].print(" " + a[i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     ttt := ttt + 1 ) );
   operation solve( from : int, to : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var st : Sequence(int) ; st := Sequence{0,1,2,3,4,5,6,7,8,9,5,4,3,2,1,0,1,2,3,4,5,6,7,8,9,5,4,3,2,1,} ;
     var ans : Sequence(int) ; ans := null ;
         var i : int ; i := 0 ; while i < st->size() / 2 do ( (     if (st[i+1] = from) then (     var cur : Sequence(int) ; cur := Sequence{} ;
     var x : int ; x := i ;
    while (st[x+1] /= to) do (     cur := cur->including(st[x+1]) ; 
     x := x + 1 ) ; 
    cur := cur->including(to) ; 
    if (ans = null or ans->size() > cur->size()) then (     ans := cur ) else skip ; 
 ) else skip )  ;     i := i + 1 ) ; 
     return toIntArray(ans) );
  static   operation toIntArray<T>( src : Sequence(T)) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,src->size())->collect(0) ;
     var p : int ; p := 0 ;
     for (x : src) do (      res[p+1] := x->oclAsType(int)  ; p := p + 1 ;  ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  final static int[] route={
    0,1,2,3,4,5,6,7,8,9,5,4,3,2,1 };
    public static void main(String[] args)throws IOException {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String line="" ;
      while((line=br.readLine())!=null && ! line.isEmpty()){
        int n=Integer.parseInt(line);
        int s,g,step1,step2 ;
        for(int i=0 ; i<n ; ++i){
          line=br.readLine();
          s=Integer.parseInt(line.substring(0,line.indexOf(' ')));
          g=Integer.parseInt(line.substring(line.indexOf(' ')+1));
          step1=0 ;
          step2=Integer.MAX_VALUE ;
          StringBuilder sb1=new StringBuilder();
          StringBuilder sb2=new StringBuilder();
          for(int j=s ; ; j++){
            if(j>14){
              j-=15 ;
            }
++step1 ;
            sb1.append(route[j]+" ");
            if(route[j]==g){
              break ;
            }
          }
          if(s<=5){
            s=15-s ;
            step2=0 ;
            for(int j=s ; ; j++){
              if(j>14){
                j-=15 ;
              }
++step2 ;
              sb2.append(route[j]+" ");
              if(route[j]==g){
                break ;
              }
            }
          }
          if(step1<=step2){
            System.out.println(sb1.substring(0,sb1.length()-1).toString());
          }
          else {
            System.out.println(sb2.substring(0,sb2.length()-1).toString());
          }
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute route : Sequence(int) := Sequence{0,1,2,3,4,5,6,7,8,9,5,4,3,2,1};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := (line)->toInteger() ;
     var s : int ;
    var g : int ;
    var step1 : int ;
    var step2 : int ;
         var i : int ; i := 0 ; while i < n do ( (     line := br.readLine() ; 
     s := (line.subrange(0+1,line->indexOf(' ')-1))->toInteger() ; 
    g := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1))->toInteger() ; 
    step1 := 0 ; 
    step2 := 2147483647 ; 
    var sb1 : String ; sb1 := StringLib.newString() ;
    var sb2 : String ; sb2 := StringLib.newString() ;
        var j : int ; j := s ; while true do ( (     if (j > 14) then (     j := j-(15) ) else skip ; 
     step1 := step1 + 1 ; 
     sb1 := sb1 + StringLib.newString(route[j+1] + " ") ; 
     if (route[j+1] = g) then (     break ) else skip )  ;     j := j + 1 ) ; 
    if (s <= 5) then (     s := 15 - s ; 
     step2 := 0 ; 
         var j : int ; j := s ; while true do ( (     if (j > 14) then (     j := j-(15) ) else skip ; 
     step2 := step2 + 1 ; 
     sb2 := sb2 + StringLib.newString(route[j+1] + " ") ; 
     if (route[j+1] = g) then (     break ) else skip )  ;     j := j + 1 ) ) else skip ; 
    if (step1 <= step2) then (     OclFile["System.out"].println(sb1.subrange(0+1,sb1->size() - 1)+"") ) else (     OclFile["System.out"].println(sb2.subrange(0+1,sb2->size() - 1)+"") ) ;  
 )  ;     i := i + 1 ) ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findNumber(int n){
    int x=(int)Math.floor((-1+Math.sqrt(1+8*n-8))/2);
    int base=(x*(x+1))/2+1 ;
    return n-base+1 ;
  }
  public static void main(String[] args){
    int n=55 ;
    System.out.println(findNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNumber( n : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := ((-1 + (1 + 8 * n - 8)->sqrt()) / 2)->floor()->oclAsType(int) ;
     var base : int ; base := (x * (x + 1)) / 2 + 1 ;
     return n - base + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 55 ;
     OclFile["System.out"].println(findNumber(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Example {
  static long[][] dp ;
  static int mod=1000000000+7 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String t=sc.next();
    if(s.length()!=t.length()){
      System.out.println("NO");
      return ;
    }
    String vo="aeiou" ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)!=t.charAt(i)){
        if(vo.contains(String.valueOf(s.charAt(i)))&& ! vo.contains(String.valueOf(t.charAt(i)))){
          System.out.println("NO");
          return ;
        }
        else if(! vo.contains(String.valueOf(s.charAt(i)))&& vo.contains(String.valueOf(t.charAt(i)))){
          System.out.println("NO");
          return ;
        }
      }
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Example {
  static   attribute dp : Sequence(Sequence(long));
  static   attribute mod : int := 1000000000 + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    if (s->size() /= t->size()) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    var vo : String ; vo := "aeiou" ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) /= t->at(i+1)) then (     if (vo->includes(((s->at(i+1)) + "")) & not(vo->includes(((t->at(i+1)) + "")))) then (     OclFile["System.out"].println("NO") ; 
     return ) else     if (not(vo->includes(((s->at(i+1)) + ""))) & vo->includes(((t->at(i+1)) + ""))) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void evenOddInsertionSort(int arr[],int n){
    for(int i=2 ; i<n ; i++){
      int j=i-2 ;
      int temp=arr[i];
      if(((i+1)& 1)==1){
        while(j>=0 && temp>=arr[j]){
          arr[j+2]=arr[j];
          j-=2 ;
        }
        arr[j+2]=temp ;
      }
      else {
        while(j>=0 && temp<=arr[j]){
          arr[j+2]=arr[j];
          j-=2 ;
        }
        arr[j+2]=temp ;
      }
    }
  }
  static void printArray(int arr[],int n){
    for(int i=0 ; i<n ; i++){
      System.out.printf("%d ",arr[i]);
    }
    System.out.printf("\n");
  }
  public static void main(String[] args){
    int arr[]={
      12,11,13,5,6 };
      int n=arr.length ;
      evenOddInsertionSort(arr,n);
      printArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation evenOddInsertionSort( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i < n do ( (     var j : int ; j := i - 2 ;
     var temp : int ; temp := arr[i+1] ;
     if (((i + 1) & 1) = 1) then (     while (j >= 0 & temp >= arr[j+1]) do (     arr[j + 2+1] := arr[j+1] ; 
     j := j-(2) ) ; 
     arr[j + 2+1] := temp ) else (     while (j >= 0 & temp <= arr[j+1]) do (     arr[j + 2+1] := arr[j+1] ; 
     j := j-(2) ) ; 
     arr[j + 2+1] := temp ) )  ;     i := i + 1 ) );
  static   operation printArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].printf("%d ", arr[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].printf("\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,11,13,5,6} ;
     var n : int ; n := arr->size() ;
     execute evenOddInsertionSort(arr, n) ; 
     execute printArray(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    new Main().solve();
  }
  void solve(){
    Scanner cin=new Scanner(System.in);
    int MAX=1<<15 ;
    MAX+=1 ;
    int[][] dp=new int[MAX][5];
    dp[0][0]=1 ;
    for(int i=1 ; i*i<=MAX ; i++){
      int a=i*i ;
      for(int j=0 ; j+a<MAX ; j++){
        for(int k=0 ; k<4 ; k++){
          dp[j+a][k+1]+=dp[j][k];
        }
      }
    }
    while(true){
      int n=cin.nextInt();
      if(n==0)return ;
      int ret=0 ;
      for(int i=0 ; i<5 ; i++)ret+=dp[n][i];
      System.out.println(ret);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var MAX : int ; MAX := (1*(2->pow(15)))->oclAsType(long) ;
    MAX := MAX+(1) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,MAX)->collect(Integer.subrange(1,5)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i * i <= MAX do ( (     var a : int ; a := i * i ;
         var j : int ; j := 0 ; while j + a < MAX do ( (         var k : int ; k := 0 ; while k < 4 do ( (     dp[j + a+1][k + 1+1] := dp[j + a+1][k + 1+1]+(dp[j+1][k+1]) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    while (true) do (     var n : int ; n := cin.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var ret : int ; ret := 0 ;
        var i : int ; i := 0 ; while i < 5 do (     ret := ret+(dp[n+1][i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ret) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int n ;
  int max=1<<15 ;
  void solve(){
    Scanner sc=new Scanner(System.in);
    int[] cnt=new int[max+1];
    for(int i=1 ; i*i<=max ; i++){
      cnt[i*i]++;
      for(int j=i ; j*j+i*i<=max ; j++){
        cnt[i*i+j*j]++;
        for(int k=j ; k*k+j*j+i*i<=max ; k++){
          cnt[i*i+j*j+k*k]++;
          for(int l=k ; l*l+k*k+j*j+i*i<=max ; l++){
            cnt[i*i+j*j+k*k+l*l]++;
          }
        }
      }
    }
    while(true){
      n=sc.nextInt();
      if(n==0)break ;
      System.out.println(cnt[n]);
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute max : int := (1*(2->pow(15)))->oclAsType(long);
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cnt : Sequence(int) ; cnt := Integer.subrange(1,max + 1)->collect(0) ;
         var i : int ; i := 1 ; while i * i <= max do ( (     cnt[i * i+1] := cnt[i * i+1] + 1 ; 
         var j : int ; j := i ; while j * j + i * i <= max do ( (     cnt[i * i + j * j+1] := cnt[i * i + j * j+1] + 1 ; 
         var k : int ; k := j ; while k * k + j * j + i * i <= max do ( (     cnt[i * i + j * j + k * k+1] := cnt[i * i + j * j + k * k+1] + 1 ; 
         var l : int ; l := k ; while l * l + k * k + j * j + i * i <= max do ( (     cnt[i * i + j * j + k * k + l * l+1] := cnt[i * i + j * j + k * k + l * l+1] + 1 )  ;     l := l + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     while (true) do (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
     OclFile["System.out"].println(cnt[n+1]) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
class Main {
  public static Scanner sc=new Scanner(in);
  public static Random rand=new Random();
  public void run(){
    TCase : while(true){
      int n=sc.nextInt();
      if(n==0)return ;
      int res=0 ;
      for(int a=0 ; a*a<=n ; a++)for(int b=a ; a*a+b*b<=n ; b++)for(int c=b ; a*a+b*b+c*c<=n ; c++)for(int d=c ; a*a+b*b+c*c+d*d<=n ; d++){
        if(a*a+b*b+c*c+d*d==n)res++;
      }
      ln(res);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  public int[] nextIntArray(int n){
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=sc.nextInt();
    }
    return res ;
  }
  public static void pr(Object o){
    out.print(o);
  }
  public static void ln(Object o){
    out.println(o);
  }
  public static void ln(){
    out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(in);
  static   attribute rand : OclRandom := OclRandom.newOclRandom();
   operation run() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var res : int ; res := 0 ;
        var a : int ; a := 0 ; while a * a <= n do (         var b : int ; b := a ; while a * a + b * b <= n do (         var c : int ; c := b ; while a * a + b * b + c * c <= n do (         var d : int ; d := c ; while a * a + b * b + c * c + d * d <= n do ( (     if (a * a + b * b + c * c + d * d = n) then     res := res + 1 ; else skip )  ;     d := d + 1 ) ;  ;     c := c + 1 ) ;  ;     b := b + 1 ) ;  ;     a := a + 1 ) ; 
    execute ln(res) ; 
 ) ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return res );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     out.println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class Main {
  private static int n ;
  private static int rec(int sum,int pre,int cnt){
    if(sum>n)return 0 ;
    if(sum==n)return 1 ;
    if(cnt>=3){
      int dif=n-sum ;
      int res=(int)Math.sqrt(dif);
      if(res>=pre){
        if(res*res==dif)return 1 ;
      }
      return 0 ;
    }
    int counter=0 ;
    for(int i=pre ; sum+Math.pow(i,2)<=n ; i++){
      counter+=rec(sum+i*i,i,cnt+1);
    }
    return counter ;
  }
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      n=Integer.parseInt(in.readLine());
      if(n==0)break ;
      System.out.println(rec(0,1,0));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   operation rec( sum : int, pre : int, cnt : int) : int
  pre: true
  post: true
  activity: (     if (sum > n) then     return 0 else skip ; 
     if (sum = n) then     return 1 else skip ; 
    if (cnt >= 3) then (     var dif : int ; dif := n - sum ;
     var res : int ; res := (dif)->sqrt()->oclAsType(int) ;
     if (res >= pre) then (     if (res * res = dif) then     return 1 else skip ) else skip ; 
     return 0 ) else skip ; 
    var counter : int ; counter := 0 ;
        var i : int ; i := pre ; while sum + i->pow(2) <= n do ( (     counter := counter+(rec(sum + i * i, i, cnt + 1)) )  ;     i := i + 1 ) ; 
    return counter 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     n := (in.readLine())->toInteger() ; 
     if (n = 0) then     break else skip ; 
     OclFile["System.out"].println(rec(0, 1, 0)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static final int MAX=2<<15 ;
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    ArrayList<Integer>list=new ArrayList<Integer>();
    for(int i=1 ; ; i++){
      final int s=i*i ;
      if(s>MAX){
        break ;
      }
      list.add(s);
    }
    final int size=list.size();
    int[] count=new int[MAX+1];
    for(int i=0 ; i<size ; i++){
      final int v1=list.get(i);
      count[v1]++;
      for(int j=i ; j<size ; j++){
        final int v2=v1+list.get(j);
        if(v2>MAX){
          break ;
        }
        count[v2]++;
        for(int k=j ; k<size ; k++){
          final int v3=v2+list.get(k);
          if(v3>MAX){
            break ;
          }
          count[v3]++;
          for(int l=k ; l<size ; l++){
            final int v4=v3+list.get(l);
            if(v4>MAX){
              break ;
            }
            count[v4]++;
          }
        }
      }
    }
    while(true){
      final int n=sc.nextInt();
      if(n==0){
        break ;
      }
      System.out.println(count[n]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := (2*(2->pow(15)))->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 1 ; while true do ( (     var s : int ; s := i * i ;
     if (s > MAX) then (     break ) else skip ; 
     list := list->including(s) )  ;     i := i + 1 ) ; 
    var size : int ; size := list->size() ;
    var count : Sequence(int) ; count := Integer.subrange(1,MAX + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < size do ( (     var v1 : int ; v1 := list->at(i+1) ;
     count[v1+1] := count[v1+1] + 1 ; 
         var j : int ; j := i ; while j < size do ( (     var v2 : int ; v2 := v1 + list->at(j+1) ;
     if (v2 > MAX) then (     break ) else skip ; 
     count[v2+1] := count[v2+1] + 1 ; 
         var k : int ; k := j ; while k < size do ( (     var v3 : int ; v3 := v2 + list->at(k+1) ;
     if (v3 > MAX) then (     break ) else skip ; 
     count[v3+1] := count[v3+1] + 1 ; 
         var l : int ; l := k ; while l < size do ( (     var v4 : int ; v4 := v3 + list->at(l+1) ;
     if (v4 > MAX) then (     break ) else skip ; 
     count[v4+1] := count[v4+1] + 1 )  ;     l := l + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
     OclFile["System.out"].println(count[n+1]) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    List<Integer>list=new ArrayList<Integer>();
    list.add(scanner.nextInt());
    list.add(scanner.nextInt());
    list.add(scanner.nextInt());
    if(list.contains(5)){
      list.remove(list.indexOf(5));
    }
    if(list.contains(7)){
      list.remove(list.indexOf(7));
    }
    if(list.contains(5)){
      list.remove(list.indexOf(5));
    }
    if(list.size()==0){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(int) ; list := Sequence{} ;
    list := list->including(scanner.getCurrent()->toInteger()) ; 
    list := list->including(scanner.getCurrent()->toInteger()) ; 
    list := list->including(scanner.getCurrent()->toInteger()) ; 
    if (list->includes(5)) then (     list := list->excludingFirst(list->indexOf(5)-1) ) else skip ; 
    if (list->includes(7)) then (     list := list->excludingFirst(list->indexOf(7)-1) ) else skip ; 
    if (list->includes(5)) then (     list := list->excludingFirst(list->indexOf(5)-1) ) else skip ; 
    if (list->size() = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.LinkedList ;
import java.util.Queue ;
import java.util.Scanner ;
public class PingPong {
  static class Interval {
    int a,b ;
    public Interval(int a,int b){
      this.a=a ;
      this.b=b ;
    }
  }
  static boolean bfs(int a,int b){
    Queue<Integer>q=new LinkedList<>();
    q.add(a);
    boolean[] visited=new boolean[list.size()];
    while(! q.isEmpty()){
      int temp=q.poll();
      if(temp==b)return true ;
      visited[temp]=true ;
      int x=list.get(temp).a ;
      int y=list.get(temp).b ;
      for(int i=0 ; i<visited.length ; i++){
        Interval z=list.get(i);
        if(((x>z.a && x<z.b)||(y>z.a && y<z.b))&& ! visited[i])q.add(i);
      }
    }
    return false ;
  }
  static ArrayList<Interval>list ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=Integer.parseInt(in.nextLine());
    list=new ArrayList<Interval>();
    for(int i=0 ; i<n ; i++){
      String[] s=in.nextLine().split(" ");
      int des=Integer.parseInt(s[0]);
      int a=Integer.parseInt(s[1]);
      int b=Integer.parseInt(s[2]);
      if(des==1)list.add(new Interval(a,b));
      else {
        if(bfs(a-1,b-1))System.out.println("YES");
        else System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PingPong {
  static class Interval {
   attribute a : int;
   static operation newInterval( a : int, b : int) : Interval
  pre: true
  post: true
  activity:
  ( var self : Interval ;
    self := createInterval();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
}
  static   operation bfs( a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     var q : Sequence(int) ; q := Sequence{} ;
     q := q->including(a) ; 
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,list->size())->collect(false) ;
    while (not(q->isEmpty())) do (     var temp : int ; temp := q->min() ;
     if (temp = b) then     return true else skip ; 
    visited[temp+1] := true ; 
    var x : int ; x := list->at(temp+1).a ;
    var y : int ; y := list->at(temp+1).b ;
        var i : int ; i := 0 ; while i < visited->size() do ( (     var z : Interval ; z := list->at(i+1) ;
     if (((x > z.a & x < z.b) or (y > z.a & y < z.b)) & not(visited[i+1])) then     q := q->including(i) ; else skip )  ;     i := i + 1 ) ; 
 ) ; 
    return false 
 );
  static   attribute list : Sequence(Interval);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (in.nextLine())->toInteger() ;
     list := Sequence{} ; 
         var i : int ; i := 0 ; while i < n do ( (     var s : Sequence(String) ; s := in.nextLine()->split(" ") ;
     var des : int ; des := (s[0+1])->toInteger() ;
    var a : int ; a := (s[1+1])->toInteger() ;
    var b : int ; b := (s[2+1])->toInteger() ;
    if (des = 1) then     list := list->including(Interval.newInterval(a, b)) else (     if (bfs(a - 1, b - 1)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.List ;
import java.util.ArrayList ;
public class PingPong {
  public static List<Interval>list=new ArrayList<>();
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int line_num=in.nextInt();
    for(int i=0 ; i<line_num ; i++){
      int type=in.nextInt();
      if(type==1){
        list.add(new Interval(in.nextInt(),in.nextInt()));
      }
      else {
        Interval a=list.get(in.nextInt()-1);
        Interval b=list.get(in.nextInt()-1);
        for(int j=0 ; j<list.size(); j++)list.get(j).checked=false ;
        if(check(a,b)){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
    }
  }
  public static boolean check(Interval a,Interval b){
    if(a.low>b.low && a.low<b.high || a.high>b.low && a.high<b.high)return true ;
    for(int i=0 ; i<list.size(); i++){
      Interval temp=list.get(i);
      if(! temp.checked &&(a.low>temp.low && a.low<temp.high || a.high>temp.low && a.high<temp.high)){
        temp.checked=true ;
        if(check(temp,b))return true ;
      }
    }
    return false ;
  }
  public static class Interval {
    int low ;
    int high ;
    public boolean checked ;
    Interval(int low,int high){
      this.low=low ;
      this.high=high ;
      checked=false ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PingPong {
  static   attribute list : Sequence(Interval) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line_num : int ; line_num := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < line_num do ( (     var type : int ; type := in.getCurrent()->toInteger() ;
     if (type = 1) then (     list := list->including(Interval.newInterval(in.getCurrent()->toInteger(), in.getCurrent()->toInteger())) ) else (     var a : Interval ; a := list->at(in.getCurrent()->toInteger() - 1+1) ;
     var b : Interval ; b := list->at(in.getCurrent()->toInteger() - 1+1) ;
         var j : int ; j := 0 ; while j < list->size() do (     list->at(j+1).checked := false ;  ;     j := j + 1 ) ; 
     if (check(a, b)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) )  ;     i := i + 1 ) );
  static   operation check( a : Interval, b : Interval) : boolean
  pre: true
  post: true
  activity: (     if (a.low > b.low & a.low < b.high or a.high > b.low & a.high < b.high) then     return true else skip ; 
         var i : int ; i := 0 ; while i < list->size() do ( (     var temp : Interval ; temp := list->at(i+1) ;
     if (not(temp.checked) & (a.low > temp.low & a.low < temp.high or a.high > temp.low & a.high < temp.high)) then (     temp.checked := true ; 
     if (check(temp, b)) then     return true else skip ) else skip )  ;     i := i + 1 ) ; 
     return false );
  static class Interval {
   attribute low : int;
   attribute high : int;
   attribute checked : boolean;
   static operation newInterval( low : int, high : int) : Interval
  pre: true
  post: true
  activity:
  ( var self : Interval ;
    self := createInterval();
    self.initialise(low, high);
    return self );
  operation initialise( low : int, high : int) : void
  pre: true  post: true
  activity: (     self.low := low ; 
     self.high := high ; 
     checked := false );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class B320 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    List<Interval>list=new ArrayList<>();
    for(int n=1 ; n<=N ; n++){
      int type=in.nextInt();
      if(type==1){
        Interval interval=new Interval();
        interval.from=in.nextInt();
        interval.to=in.nextInt();
        interval.id=list.size();
        list.add(interval);
      }
      else {
        int start=in.nextInt()-1 ;
        int end=in.nextInt()-1 ;
        Interval startInterval=list.get(start);
        visit(startInterval,list,n);
        boolean possible=list.get(end).lastSeen==n ;
        System.out.println(possible ? "YES" : "NO");
      }
    }
  }
  static void visit(Interval current,List<Interval>list,int queryNo){
    current.lastSeen=queryNo ;
    for(Interval next : list){
      if(next.lastSeen!=queryNo){
        if((next.from<current.from && current.from<next.to)||(next.from<current.to && current.to<next.to)){
          visit(next,list,queryNo);
        }
      }
    }
  }
  static class Interval {
    int from ;
    int to ;
    int lastSeen ;
    int id ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B320 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
     var list : Sequence(Interval) ; list := Sequence{} ;
         var n : int ; n := 1 ; while n <= N do ( (     var type : int ; type := in.getCurrent()->toInteger() ;
     if (type = 1) then (     var interval : Interval ; interval := Interval.newInterval() ;
     interval.from := in.getCurrent()->toInteger() ; 
    interval.to := in.getCurrent()->toInteger() ; 
    interval.id := list->size() ; 
    list := list->including(interval) ; 
 ) else (     var start : int ; start := in.getCurrent()->toInteger() - 1 ;
     var end : int ; end := in.getCurrent()->toInteger() - 1 ;
    var startInterval : Interval ; startInterval := list->at(start+1) ;
    execute visit(startInterval, list, n) ; 
    var possible : boolean ; possible := list->at(end+1).lastSeen = n ;
    OclFile["System.out"].println(if possible then "YES" else "NO" endif) ; 
 ) )  ;     n := n + 1 ) );
  static   operation visit( current : Interval, list : Sequence(Interval), queryNo : int) : void
  pre: true
  post: true
  activity: (     current.lastSeen := queryNo ; 
     for (next : list) do ( (     if (next.lastSeen /= queryNo) then (     if ((next.from < current.from & current.from < next.to) or (next.from < current.to & current.to < next.to)) then (     execute visit(next, list, queryNo) ) else skip ) else skip )  ) );
  static class Interval {
   attribute from : int;
   attribute to : int;
   attribute lastSeen : int;
   attribute id : int;
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String t=sc.next();
    char[] vow={
      'a','e','i','o','u' };
      if(s.length()!=t.length())System.out.println("NO");
      else {
        for(int i=0 ; i<s.length(); i++){
          boolean check_s=false,check_t=false ;
          for(int j=0 ; j<5 ; j++){
            if(s.charAt(i)==vow[j]){
              check_s=true ;
              break ;
            }
          }
          for(int j=0 ; j<5 ; j++){
            if(t.charAt(i)==vow[j]){
              check_t=true ;
              break ;
            }
          }
          if(check_s!=check_t){
            System.out.println("NO");
            return ;
          }
        }
        System.out.println("YES");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var vow : Sequence(String) ; vow := Sequence{'a','e','i','o','u'} ;
    if (s->size() /= t->size()) then     OclFile["System.out"].println("NO") else (         var i : int ; i := 0 ; while i < s->size() do ( (     var check_s : boolean ; check_s := false ;
    var check_t : boolean ; check_t := false ;
         var j : int ; j := 0 ; while j < 5 do ( (     if (s->at(i+1) = vow[j+1]) then (     check_s := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < 5 do ( (     if (t->at(i+1) = vow[j+1]) then (     check_t := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (check_s /= check_t) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("YES") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class PingPong {
  static class pair {
    int x ;
    int y ;
    public pair(int x,int y){
      this.x=x ;
      this.y=y ;
    }
    public int getX(){
      return x ;
    }
    public int getY(){
      return y ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<pair>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      int q=sc.nextInt();
      int x=sc.nextInt();
      int y=sc.nextInt();
      if(q==1){
        pair p=new pair(x,y);
        list.add(p);
      }
      else {
        boolean[] visited=new boolean[list.size()];
        search(x-1,list,visited);
        if(visited[y-1]){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
    }
  }
  private static void search(int i,ArrayList<pair>list,boolean[] visited){
    pair curr=list.get(i);
    visited[i]=true ;
    for(int j=0 ; j<list.size(); j++){
      if(! visited[j]){
        if(curr.getX()>list.get(j).getX()&& curr.getX()<list.get(j).getY()){
          search(j,list,visited);
        }
        else if(curr.getY()>list.get(j).getX()&& curr.getY()<list.get(j).getY()){
          search(j,list,visited);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PingPong {
  static class pair {
   attribute x : int;
   attribute y : int;
   static operation newpair( x : int, y : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation getX() : int
  pre: true
  post: true
  activity: (     return x );
   operation getY() : int
  pre: true
  post: true
  activity: (     return y );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var list : Sequence(pair) ; list := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     var q : int ; q := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     if (q = 1) then (     var p : pair ; p := pair.newpair(x, y) ;
     list := list->including(p) ) else (     var visited : Sequence(boolean) ; visited := Integer.subrange(1,list->size())->collect(false) ;
     execute search(x - 1, list, visited) ; 
     if (visited[y - 1+1]) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) )  ;     i := i + 1 ) );
  static   operation search( i : int, list : Sequence(pair), visited : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (     var curr : pair ; curr := list->at(i+1) ;
     visited[i+1] := true ; 
         var j : int ; j := 0 ; while j < list->size() do ( (     if (not(visited[j+1])) then (     if (curr.getX() > list->at(j+1).getX() & curr.getX() < list->at(j+1).getY()) then (     execute search(j, list, visited) ) else     if (curr.getY() > list->at(j+1).getX() & curr.getY() < list->at(j+1).getY()) then (     execute search(j, list, visited) ) else skip ; ) else skip )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
public final class p062 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p062().run());
  }
  public String run(){
    int numDigits=0 ;
    Map<String,Integer>lowest=new HashMap<>();
    Map<String,Integer>counts=new HashMap<>();
    for(int i=0 ; ; i++){
      String numClass=getCubeNumberClass(i);
      if(numClass.length()>numDigits){
        int min=Integer.MAX_VALUE ;
        for(String nc : counts.keySet()){
          if(counts.get(nc)==5)min=Math.min(lowest.get(nc),min);
        }
        if(min!=Integer.MAX_VALUE)return cube(min).toString();
        lowest.clear();
        counts.clear();
        numDigits=numClass.length();
      }
      if(! lowest.containsKey(numClass)){
        lowest.put(numClass,i);
        counts.put(numClass,0);
      }
      counts.put(numClass,counts.get(numClass)+1);
    }
  }
  private static String getCubeNumberClass(int x){
    char[] digits=cube(x).toString().toCharArray();
    Arrays.sort(digits);
    return new String(digits);
  }
  private static BigInteger cube(int x){
    return BigInteger.valueOf(x).pow(3);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p062 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p062.newp062().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var numDigits : int ; numDigits := 0 ;
     var lowest : Map(String,int) ; lowest := Map{} ;
     var counts : Map(String,int) ; counts := Map{} ;
         var i : int ; i := 0 ; while true do ( (     var numClass : String ; numClass := getCubeNumberClass(i) ;
     if (numClass->size() > numDigits) then (     var min : int ; min := 2147483647 ;
     for (nc : counts->keys()) do ( (     if (counts->at(nc) = 5) then     min := Set{lowest->at(nc), min}->min() ; else skip )  ) ; 
    if (min /= 2147483647) then     return cube(min)+"" else skip ; 
    lowest := lowest->intersection(Map{}) ; 
    counts := counts->intersection(Map{}) ; 
    numDigits := numClass->size() ; 
 ) else skip ; 
     if (not(lowest->keys()->includes(numClass))) then (     lowest := lowest->union(Map{numClass |-> i}) ; 
     counts := counts->union(Map{numClass |-> 0}) ) else skip ; 
     counts := counts->union(Map{numClass |-> counts->at(numClass) + 1}) )  ;     i := i + 1 ) );
  static   operation getCubeNumberClass( x : int) : String
  pre: true
  post: true
  activity: (     var digits : Sequence(String) ; digits := cube(x)+""->characters() ;
     digits := digits->sort() ; 
     return StringLib.newString(digits) );
  static   operation cube( x : int) : long
  pre: true
  post: true
  activity: (     return (x + "")->toLong().pow(3) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  final long MOD=1000000007 ;
  void solve(){
    Scanner scan=new Scanner(System.in);
    long n=scan.nextInt();
    System.out.println((pow(10,n)-(2*pow(9,n))% MOD+pow(8,n))% MOD);
  }
  long pow(long x,long n){
    if(n==0)return 1 ;
    long ret=pow(x*x % MOD,n/2);
    if((n & 1)==1)ret=ret*x % MOD+MOD ;
    return ret ;
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute MOD : long := 1000000007;
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := scan.getCurrent()->toInteger() ;
     OclFile["System.out"].println((pow(10, n) - (2 * pow(9, n)) mod MOD + pow(8, n)) mod MOD) );
   operation pow( x : long, n : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     var ret : long ; ret := pow(x * x mod MOD, n / 2) ;
     if ((MathLib.bitwiseAnd(n,1)) = 1) then     ret := ret * x mod MOD + MOD ; else skip ; 
     return ret );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[])throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=Integer.valueOf(sc.nextLine().trim());
    List<Boolean>list0=Arrays.asList(false,false);
    int mod=1000000007 ;
    Map<List<Boolean>,Long>map=new HashMap<>();
    map.put(list0,1L);
    for(int j=0 ; j<n ; j++){
      Map<List<Boolean>,Long>map2=new HashMap<>();
      for(List<Boolean>list : map.keySet()){
        List<Boolean>list1=Arrays.asList(true,list.get(1).booleanValue());
        long d=map2.getOrDefault(list1,0L)+map.get(list).longValue();
        map2.put(list1,d % mod);
        list1=Arrays.asList(list.get(0).booleanValue(),true);
        d=map2.getOrDefault(list1,0L)+map.get(list).longValue();
        map2.put(list1,d % mod);
        list1=list ;
        d=map2.getOrDefault(list1,0L)+map.get(list).longValue()*8 ;
        map2.put(list1,d % mod);
      }
      map=map2 ;
    }
    List<Boolean>list2=Arrays.asList(true,true);
    long d=map.getOrDefault(list2,0L);
    System.out.println(d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.nextLine()->trim())->toInteger() ;
    var list0 : Sequence(Boolean) ; list0 := Sequence{false,false} ;
    var mod : int ; mod := 1000000007 ;
    var map : Map(Sequence(Boolean),long) ; map := Map{} ;
    map := map->union(Map{list0 |-> 1L}) ; 
        var j : int ; j := 0 ; while j < n do ( (     var map2 : Map(Sequence(Boolean),long) ; map2 := Map{} ;
     for (list : map->keys()) do ( (     var list1 : Sequence(Boolean) ; list1 := Sequence{true,list->at(1+1)} ;
     var d : long ; d := (if map2->keys()->contains(list1) then map2->at(list1) else 0L endif) + map->at(list)->oclAsType(long) ;
    map2 := map2->union(Map{list1 |-> d mod mod}) ; 
    list1 := Sequence{list->at(0+1),true} ; 
    d := (if map2->keys()->contains(list1) then map2->at(list1) else 0L endif) + map->at(list)->oclAsType(long) ; 
    map2 := map2->union(Map{list1 |-> d mod mod}) ; 
    list1 := list ; 
    d := (if map2->keys()->contains(list1) then map2->at(list1) else 0L endif) + map->at(list)->oclAsType(long) * 8 ; 
    map2 := map2->union(Map{list1 |-> d mod mod}) ; 
 )  ) ; 
     map := map2 )  ;     j := j + 1 ) ; 
    var list2 : Sequence(Boolean) ; list2 := Sequence{true,true} ;
    var d : long ; d := (if map->keys()->contains(list2) then map->at(list2) else 0L endif) ;
    OclFile["System.out"].println(d) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public class Main {
  final private static BigInteger BIG_8=BigInteger.valueOf(8);
  final private static BigInteger BIG_9=BigInteger.valueOf(9);
  final private static BigInteger BIG_2=BigInteger.valueOf(2);
  public static void main(String[] args){
    var sc=new java.util.Scanner(System.in);
    var n=sc.nextInt();
    var m=BigInteger.valueOf(1000000000+7);
    var all=BigInteger.TEN.pow(n);
    var all9=BIG_9.pow(n);
    var all8=BIG_8.pow(n);
    var etc=all9.multiply(BIG_2).subtract(all8);
    System.out.println(all.subtract(etc).mod(m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute BIG_8 : long := (8 + "")->toLong();
  static   attribute BIG_9 : long := (9 + "")->toLong();
  static   attribute BIG(2 + "")->toLong() : long := (2 + "")->toLong();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : var ; sc := Scanner.newScanner(OclFile["System.in"]) ;
     var n : var ; n := sc.nextInt() ;
    var m : var ; m := (1000000000 + 7 + "")->toLong() ;
    var all : var ; all := 10.pow(n) ;
    var all9 : var ; all9 := BIG_9.pow(n) ;
    var all8 : var ; all8 := BIG_8.pow(n) ;
    var etc : var ; etc := all9.multiply(BIGmultiply(BIGsubtract(all8))).subtract(all8) ;
    OclFile["System.out"].println(all.subtract(etc).mod(m)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import java.util.*;
import java.awt.Point ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner input=new Scanner(System.in);
    while(input.hasNext()){
      long n=input.nextLong();
      long len=n ;
      long mod=1000000007 ;
      long ans=0 ;
      long tot=1 ;
      int ct=0 ;
      while(ct!=n){
        tot=(tot*10)% mod ;
        ct++;
      }
      ct=0 ;
      long no_zero=1 ;
      while(ct!=n){
        no_zero=(no_zero*9)% mod ;
        ct++;
      }
      ct=0 ;
      long none=1 ;
      while(ct!=n){
        none=(none*8)% mod ;
        ct++;
      }
      System.out.println((tot-no_zero-no_zero+none+2*mod)% mod);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (input.hasNext()) do (     var n : long ; n := input.getCurrent()->toLong() ;
     var len : long ; len := n ;
    var mod : long ; mod := 1000000007 ;
    var ans : long ; ans := 0 ;
    var tot : long ; tot := 1 ;
    var ct : int ; ct := 0 ;
    while (ct /= n) do (     tot := (tot * 10) mod mod ; 
     ct := ct + 1 ) ; 
    ct := 0 ; 
    var no_zero : long ; no_zero := 1 ;
    while (ct /= n) do (     no_zero := (no_zero * 9) mod mod ; 
     ct := ct + 1 ) ; 
    ct := 0 ; 
    var none : long ; none := 1 ;
    while (ct /= n) do (     none := (none * 8) mod mod ; 
     ct := ct + 1 ) ; 
    OclFile["System.out"].println((tot - no_zero - no_zero + none + 2 * mod) mod mod) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    BigInteger md=BigInteger.valueOf(1000000007);
    BigInteger ten=BigInteger.valueOf(10);
    BigInteger nine=BigInteger.valueOf(9);
    BigInteger eight=BigInteger.valueOf(8);
    BigInteger n=BigInteger.valueOf(N);
    BigInteger sub1=ten.modPow(n,md);
    sub1=sub1.subtract(eight.modPow(n,md));
    BigInteger sub2=nine.modPow(n,md);
    sub2=sub2.subtract(eight.modPow(n,md));
    sub1=sub1.subtract(sub2.multiply(BigInteger.valueOf(2)));
    sub1=sub1.mod(md);
    System.out.println(sub1.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var md : long ; md := (1000000007 + "")->toLong() ;
    var ten : long ; ten := (10 + "")->toLong() ;
    var nine : long ; nine := (9 + "")->toLong() ;
    var eight : long ; eight := (8 + "")->toLong() ;
    var n : long ; n := (N + "")->toLong() ;
    var sub1 : long ; sub1 := ten.modPow(n, md) ;
    sub1 := sub1.subtract(eight.modPow(n, md)) ; 
    var sub2 : long ; sub2 := nine.modPow(n, md) ;
    sub2 := sub2.subtract(eight.modPow(n, md)) ; 
    sub1 := sub1.subtract(sub2.multiply((2 + "")->toLong())) ; 
    sub1 := sub1.mod(md) ; 
    OclFile["System.out"].println(sub1+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.Map ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int all=0 ;
    int dn=0 ;
    int tyo=0 ;
    int ei=0 ;
    while(sc.hasNext()){
      ArrayList<Integer>len=new ArrayList<Integer>(3);
      for(int i=0 ; i<3 ; i++){
        len.add(sc.nextInt());
      }
      Collections.sort(len,Collections.reverseOrder());
      if(len.get(0)>=len.get(1)+len.get(2)){
        System.out.println(all+" "+tyo+" "+ei+" "+dn);
        return ;
      }
      all++;
      int a=len.get(0)*len.get(0);
      int bc=len.get(1)*len.get(1)+len.get(2)*len.get(2);
      if(a<bc){
        ei++;
      }
      else if(a>bc){
        dn++;
      }
      else {
        tyo++;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var all : int ; all := 0 ;
    var dn : int ; dn := 0 ;
    var tyo : int ; tyo := 0 ;
    var ei : int ; ei := 0 ;
    while (sc.hasNext()) do (     var len : Sequence(int) ; len := Sequence{} ;
         var i : int ; i := 0 ; while i < 3 do ( (     len := len->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    len, reverseOrder() := len, reverseOrder()->sort() ; 
    if (len->at(0+1) >= len->at(1+1) + len->at(2+1)) then (     OclFile["System.out"].println(all + " " + tyo + " " + ei + " " + dn) ; 
     return ) else skip ; 
    all := all + 1 ; 
    var a : int ; a := len->at(0+1) * len->at(0+1) ;
    var bc : int ; bc := len->at(1+1) * len->at(1+1) + len->at(2+1) * len->at(2+1) ;
    if (a < bc) then (     ei := ei + 1 ) else     if (a > bc) then (     dn := dn + 1 ) else (     tyo := tyo + 1 ) ;  ;  
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int[] ans=new int[4];
    while(true){
      StringTokenizer st=new StringTokenizer(reader.readLine());
      int[] a=new int[3];
      Arrays.fill(a,Integer.MAX_VALUE);
      for(int i=0 ; i<3 ; i++){
        int tmp=Integer.parseInt(st.nextToken());
        if(tmp<a[0]){
          a[2]=a[1];
          a[1]=a[0];
          a[0]=tmp ;
        }
        else if(tmp<a[1]){
          a[2]=a[1];
          a[1]=tmp ;
        }
        else if(tmp<a[2]){
          a[2]=tmp ;
        }
      }
      int ret=findTriangleType(a);
      if(ret==-1)break ;
      ans[0]++;
      ans[ret]++;
    }
    reader.close();
    System.out.print(ans[0]);
    for(int i=1 ; i<4 ; i++){
      System.out.print(" "+ans[i]);
    }
    System.out.println();
  }
  private static int findTriangleType(int[] a){
    int ret=-1 ;
    int n1,n2,n3 ;
    n1=a[0];
    n2=a[1];
    n3=a[2];
    if(n1+n2<=n3){
      ret=-1 ;
    }
    else if(n1*n1+n2*n2==n3*n3){
      ret=1 ;
    }
    else if(n1*n1+n2*n2>n3*n3){
      ret=2 ;
    }
    else {
      ret=3 ;
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var ans : Sequence(int) ; ans := Integer.subrange(1,4)->collect(0) ;
    while (true) do (     var st : OclIterator ; st := OclIterator.newOclIterator_String(reader.readLine()) ;
     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
    a := a->collect(2147483647) ; 
        var i : int ; i := 0 ; while i < 3 do ( (     var tmp : int ; tmp := (st.next())->toInteger() ;
     if (tmp < a[0+1]) then (     a[2+1] := a[1+1] ; 
     a[1+1] := a[0+1] ; 
     a[0+1] := tmp ) else     if (tmp < a[1+1]) then (     a[2+1] := a[1+1] ; 
     a[1+1] := tmp ) else     if (tmp < a[2+1]) then (     a[2+1] := tmp ) else skip ; ;  )  ;     i := i + 1 ) ; 
    var ret : int ; ret := findTriangleType(a) ;
    if (ret = -1) then     break else skip ; 
    ans[0+1] := ans[0+1] + 1 ; 
    ans[ret+1] := ans[ret+1] + 1 ; 
 ) ; 
    skip ; 
    OclFile["System.out"].print(ans[0+1]) ; 
        var i : int ; i := 1 ; while i < 4 do ( (     OclFile["System.out"].print(" " + ans[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation findTriangleType( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := -1 ;
     var n1 : int ;
    var n2 : int ;
    var n3 : int ;
    n1 := a[0+1] ; 
    n2 := a[1+1] ; 
    n3 := a[2+1] ; 
    if (n1 + n2 <= n3) then (     ret := -1 ) else     if (n1 * n1 + n2 * n2 = n3 * n3) then (     ret := 1 ) else     if (n1 * n1 + n2 * n2 > n3 * n3) then (     ret := 2 ) else (     ret := 3 ) ;  ;  ;  
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static PrintStream so=System.out ;
  public static void main(String[] args)throws InterruptedException {
    Map<TRIANGLE_KIND,Integer>counter=new HashMap<>();
    int totalCount=0 ;
    counter.put(TRIANGLE_KIND.RIGHT,0);
    counter.put(TRIANGLE_KIND.ACUTE_ANGLED,0);
    counter.put(TRIANGLE_KIND.OBTUSE_ANGLED,0);
    while(true){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      TRIANGLE_KIND kind=kind(a,b,c);
      if(kind==TRIANGLE_KIND.NOT_TRIANGLE)break ;
      totalCount++;
      counter.put(kind,counter.get(kind)+1);
    }
    so.println(totalCount+" "+counter.get(TRIANGLE_KIND.RIGHT)+" "+counter.get(TRIANGLE_KIND.ACUTE_ANGLED)+" "+counter.get(TRIANGLE_KIND.OBTUSE_ANGLED));
  }
  static TRIANGLE_KIND kind(int a,int b,int c){
    int max=Math.max(a,Math.max(b,c));
    int min=Math.min(a,Math.min(b,c));
    int mid=a+b+c-(min+max);
    if(max>=min+mid)return TRIANGLE_KIND.NOT_TRIANGLE ;
    int d=max*max-(min*min+mid*mid);
    return d==0 ? TRIANGLE_KIND.RIGHT : d>0 ? TRIANGLE_KIND.OBTUSE_ANGLED : TRIANGLE_KIND.ACUTE_ANGLED ;
  }
  enum TRIANGLE_KIND {
    NOT_TRIANGLE(0),RIGHT(1),ACUTE_ANGLED(2),OBTUSE_ANGLED(3);
    int num ;
    TRIANGLE_KIND(int i){
      this.num=i ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute so : OclFile := OclFile["System.out"];
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var counter : Map(TRIANGLE_KIND,int) ; counter := Map{} ;
     var totalCount : int ; totalCount := 0 ;
    counter := counter->union(Map{TRIANGLE_KIND.RIGHT |-> 0}) ; 
    counter := counter->union(Map{TRIANGLE_KIND.ACUTE_ANGLED |-> 0}) ; 
    counter := counter->union(Map{TRIANGLE_KIND.OBTUSE_ANGLED |-> 0}) ; 
    while (true) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var kind : TRIANGLE_KIND ; kind := kind(a, b, c) ;
    if (kind = TRIANGLE_KIND.NOT_TRIANGLE) then     break else skip ; 
    totalCount := totalCount + 1 ; 
    counter := counter->union(Map{kind |-> counter->at(kind) + 1}) ; 
 ) ; 
    skip ; 
 );
  static   operation kind( a : int, b : int, c : int) : TRIANGLE_KIND
  pre: true
  post: true
  activity: (     var max : int ; max := Set{a, Set{b, c}->max()}->max() ;
     var min : int ; min := Set{a, Set{b, c}->min()}->min() ;
    var mid : int ; mid := a + b + c - (min + max) ;
    if (max >= min + mid) then     return TRIANGLE_KIND.NOT_TRIANGLE else skip ; 
    var d : int ; d := max * max - (min * min + mid * mid) ;
    return if d = 0 then TRIANGLE_KIND.RIGHT else if d > 0 then TRIANGLE_KIND.OBTUSE_ANGLED else TRIANGLE_KIND.ACUTE_ANGLED endif endif 
 );
   class TRIANGLE_KIND {     static attribute NOT_TRIANGLE : SelfClass := SelfClass.newSelfClass(0);
    static attribute RIGHT : SelfClass := SelfClass.newSelfClass(1);
    static attribute ACUTE_ANGLED : SelfClass := SelfClass.newSelfClass(2);
    static attribute OBTUSE_ANGLED : SelfClass := SelfClass.newSelfClass(3);
   attribute num : int;
   static operation newTRIANGLE_KIND( i : int) : TRIANGLE_KIND
  pre: true
  post: true
  activity:
  ( var self : TRIANGLE_KIND ;
    self := createTRIANGLE_KIND();
    self.initialise(i);
    return self );
  operation initialise( i : int) : void
  pre: true  post: true
  activity: (     self.num := i );
  }
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean isTriPerfect(int n){
    int sum=1+n ;
    int i=2 ;
    while(i*i<=n){
      if(n % i==0){
        if(n/i==i)sum=sum+i ;
        else sum=sum+i+n/i ;
      }
      i+=1 ;
    }
    if(sum==3*n & n!=1)return true ;
    else return false ;
  }
  public static void main(String[] args){
    int n=120 ;
    if(isTriPerfect(n))System.out.println(n+" is a Triperfect number");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isTriPerfect( n : int) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 1 + n ;
     var i : int ; i := 2 ;
     while (i * i <= n) do (     if (n mod i = 0) then (     if (n / i = i) then     sum := sum + i ; else     sum := sum + i + n / i ; ) else skip ; 
     i := i+(1) ) ; 
     if (sum = 3 * n & n /= 1) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 120 ;
     if (isTriPerfect(n)) then     OclFile["System.out"].println(n + " is a Triperfect number") ; else skip );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int[] tris=new int[4];
  public static void main(String[] args){
    judgeTypes();
    dispResult();
  }
  private static void dispResult(){
    System.out.printf("%d %d %d %d\n",tris[0],tris[1],tris[2],tris[3]);
  }
  private static void judgeTypes(){
    int[] s=new int[3];
    do {
      for(int i=0 ; i<3 ; i++){
        s[i]=sc.nextInt();
      }
      Arrays.sort(s);
      if(s[2]>=s[0]+s[1]){
        break ;
      }
      else if(Math.pow(s[0],2)+Math.pow(s[1],2)-Math.pow(s[2],2)==0){
        tris[0]++;
        tris[1]++;
      }
      else if(Math.pow(s[0],2)+Math.pow(s[1],2)-Math.pow(s[2],2)>0){
        tris[0]++;
        tris[2]++;
      }
      else if(Math.pow(s[0],2)+Math.pow(s[1],2)-Math.pow(s[2],2)<0){
        tris[0]++;
        tris[3]++;
      }
    }
    while(true);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute tris : Sequence(int) := Integer.subrange(1,4)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute judgeTypes() ; 
     execute dispResult() );
  static   operation dispResult() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].printf("%d %d %d %d\n", tris[0+1], tris[1+1], tris[2+1], tris[3+1]) );
  static   operation judgeTypes() : void
  pre: true
  post: true
  activity: (     var s : Sequence(int) ; s := Integer.subrange(1,3)->collect(0) ;
   while true do ((         var i : int ; i := 0 ; while i < 3 do ( (     s[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     s := s->sort() ; 
     if (s[2+1] >= s[0+1] + s[1+1]) then (     break ) else     if (s[0+1]->pow(2) + s[1+1]->pow(2) - s[2+1]->pow(2) = 0) then (     tris[0+1] := tris[0+1] + 1 ; 
     tris[1+1] := tris[1+1] + 1 ) else     if (s[0+1]->pow(2) + s[1+1]->pow(2) - s[2+1]->pow(2) > 0) then (     tris[0+1] := tris[0+1] + 1 ; 
     tris[2+1] := tris[2+1] + 1 ) else     if (s[0+1]->pow(2) + s[1+1]->pow(2) - s[2+1]->pow(2) < 0) then (     tris[0+1] := tris[0+1] + 1 ; 
     tris[3+1] := tris[3+1] + 1 ) else skip ; ;  ;  ) ;
    if (true) then skip else break) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNextInt()){
      int n=in.nextInt();
      int m=in.nextInt();
      int a[]=new int[n];
      int b[]=new int[m];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      for(int i=0 ; i<m ; i++){
        b[i]=in.nextInt();
      }
      Arrays.sort(a);
      Arrays.sort(b);
      int s=0 ;
      int tep=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<m ; j++){
          if(a[i]==b[j]){
            s=a[i];
            tep=1 ;
            break ;
          }
        }
        if(tep==1)break ;
      }
      if(tep==1)System.out.println(s);
      else {
        if(a[0]>b[0])System.out.println(b[0]+""+a[0]);
        else System.out.println(a[0]+""+b[0]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNextInt()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    var s : int ; s := 0 ;
    var tep : int ; tep := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (a[i+1] = b[j+1]) then (     s := a[i+1] ; 
     tep := 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (tep = 1) then     break else skip )  ;     i := i + 1 ) ; 
    if (tep = 1) then     OclFile["System.out"].println(s) else (     if (a[0+1] > b[0+1]) then     OclFile["System.out"].println(b[0+1] + "" + a[0+1]) ; else     OclFile["System.out"].println(a[0+1] + "" + b[0+1]) ; ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int[] s1=new int[10];
    int[] s2=new int[10];
    int[] s=new int[10];
    for(int i=0 ; i<n ; i++){
      int a=in.nextInt();
      s1[a]++;
      s[a]++;
    }
    for(int i=0 ; i<m ; i++){
      int b=in.nextInt();
      s2[b]++;
      s[b]++;
    }
    int res=0 ;
    int f=0 ;
    for(int i=1 ; i<=9 ; i++){
      if(s[i]>=2){
        res=i ;
        f=1 ;
      }
      if(f==1){
        break ;
      }
    }
    if(f==0){
      for(int i=1 ; i<=9 ; i++){
        for(int j=1 ; j<=9 ; j++){
          if(s1[i]!=0 && s2[j]!=0){
            f=1 ;
            if(i!=j){
              if(i<j){
                res=i*10+j ;
              }
              else {
                res=j*10+i ;
              }
            }
            else {
              res=i ;
            }
          }
          if(f==1){
            break ;
          }
        }
        if(f==1){
          break ;
        }
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var s1 : Sequence(int) ; s1 := Integer.subrange(1,10)->collect(0) ;
    var s2 : Sequence(int) ; s2 := Integer.subrange(1,10)->collect(0) ;
    var s : Sequence(int) ; s := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     s1[a+1] := s1[a+1] + 1 ; 
     s[a+1] := s[a+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var b : int ; b := in.getCurrent()->toInteger() ;
     s2[b+1] := s2[b+1] + 1 ; 
     s[b+1] := s[b+1] + 1 )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    var f : int ; f := 0 ;
        var i : int ; i := 1 ; while i <= 9 do ( (     if (s[i+1] >= 2) then (     res := i ; 
     f := 1 ) else skip ; 
     if (f = 1) then (     break ) else skip )  ;     i := i + 1 ) ; 
    if (f = 0) then (         var i : int ; i := 1 ; while i <= 9 do ( (         var j : int ; j := 1 ; while j <= 9 do ( (     if (s1[i+1] /= 0 & s2[j+1] /= 0) then (     f := 1 ; 
     if (i /= j) then (     if (i < j) then (     res := i * 10 + j ) else (     res := j * 10 + i ) ) else (     res := i ) ) else skip ; 
     if (f = 1) then (     break ) else skip )  ;     j := j + 1 ) ; 
     if (f = 1) then (     break ) else skip )  ;     i := i + 1 ) ) else skip ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printPossible(int a,int b,int c){
    if((a+b+c)% 2!=0 || a+b<c)System.out.println("NO");
    else System.out.println("YES");
  }
  public static void main(String[] args){
    int a=2,b=4,c=2 ;
    printPossible(a,b,c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printPossible( a : int, b : int, c : int) : void
  pre: true
  post: true
  activity: (     if ((a + b + c) mod 2 /= 0 or a + b < c) then     OclFile["System.out"].println("NO") ; else     OclFile["System.out"].println("YES") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2 ;
    var b : int ; b := 4 ;
    var c : int ; c := 2 ;
     execute printPossible(a, b, c) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class GFG {
  public static int countOccurence(int n,int[] arr,int k){
    int cnt,ans=0 ;
    HashMap<Integer,Boolean>hash=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      cnt=0 ;
      if(hash.get(arr[i])!=null && hash.get(arr[i])==true)continue ;
      hash.put(arr[i],true);
      for(int j=i+1 ; j<n ; j++){
        if(arr[j]==arr[i])cnt++;
        if(cnt>=k)break ;
      }
      if(cnt>=k)ans++;
    }
    return ans ;
  }
  public static void main(String[] args){
    int[] arr={
      1,2,1,3 };
      int n=arr.length ;
      int k=1 ;
      System.out.println(countOccurence(n,arr,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countOccurence( n : int, arr : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ;
    var ans : int ; ans := 0 ;
     var hash : Map(int,Boolean) ; hash := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     cnt := 0 ; 
     if (hash->at(arr[i+1]) /= null & hash->at(arr[i+1]) = true) then     continue else skip ; 
    hash := hash->union(Map{arr[i+1] |-> true}) ; 
        var j : int ; j := i + 1 ; while j < n do ( (     if (arr[j+1] = arr[i+1]) then     cnt := cnt + 1 ; else skip ; 
     if (cnt >= k) then     break else skip )  ;     j := j + 1 ) ; 
    if (cnt >= k) then     ans := ans + 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,1,3} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 1 ;
     OclFile["System.out"].println(countOccurence(n, arr, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int R=3,C=3 ;
  static boolean safe(int x,int y){
    if(x<R && y<C && x>=0 && y>=0)return true ;
    return false ;
  }
  static class pair<T,R>{
    T first ;
    R second ;
    pair(T t,R r){
      first=t ;
      second=r ;
    }
  }
  static int matrixJump(int M[][],int R1,int C1){
    Queue<pair<Integer,pair<Integer,Integer>>>q=new LinkedList<>();
    q.add(new pair(1,new pair(R1,C1)));
    while(q.size()>0){
      int x=q.peek().second.first ;
      int y=q.peek().second.second ;
      int no_of_cells=q.peek().first ;
      q.remove();
      if(x==R-1 && y==C-1)return no_of_cells ;
      int v=M[x][y];
      if(safe(x+v,y))q.add(new pair(no_of_cells+1,new pair(x+v,y)));
      if(safe(x,y+v))q.add(new pair(no_of_cells+1,new pair(x,y+v)));
    }
    return-1 ;
  }
  public static void main(String ars[]){
    int M[][]={
      {
        2,4,2 },{
          5,3,8 },{
            1,1,1 }
          };
          System.out.print(matrixJump(M,0,0));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute R : int := 3;
  static   operation safe( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     if (x < R & y < C & x >= 0 & y >= 0) then     return true else skip ; 
     return false );
  static class pair<T,R> {
   attribute first : T;
   attribute second : R;
   static operation newpair( t : T, r : R) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(t, r);
    return self );
  operation initialise( t : T, r : R) : void
  pre: true  post: true
  activity: (     first := t ; 
     second := r );
}
  static   operation matrixJump( M : Sequence(Sequence(int)), R1 : int, C1 : int) : int
  pre: true
  post: true
  activity: (     var q : Sequence(pair<int,pair<int,int>>) ; q := Sequence{} ;
     q := q->including(pair.newpair(1, pair.newpair(R1, C1))) ; 
     while (q->size() > 0) do (     var x : int ; x := q->min()->at("second")->at("first") ;
     var y : int ; y := q->min()->at("second")->at("second") ;
    var no_of_cells : int ; no_of_cells := q->min()->at("first") ;
    q := q.remove() ; 
    if (x = R - 1 & y = C - 1) then     return no_of_cells else skip ; 
    var v : int ; v := M[x+1][y+1] ;
    if (safe(x + v, y)) then     q := q->including(pair.newpair(no_of_cells + 1, pair.newpair(x + v, y))) ; else skip ; 
    if (safe(x, y + v)) then     q := q->including(pair.newpair(no_of_cells + 1, pair.newpair(x, y + v))) ; else skip ; 
 ) ; 
     return -1 );
  static   operation main( ars : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var M : Sequence(Sequence(int)) ; M := Sequence{Sequence{2,4,2},Sequence{5,3,8},Sequence{1,1,1}} ;
     OclFile["System.out"].print(matrixJump(M, 0, 0)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int __builtin_popcount(int n){
    int count=0 ;
    while(n>0){
      count+=n & 1 ;
      n>>=1 ;
    }
    return count ;
  }
  static void countEvenOdd(int arr[],int n,int K){
    int even=0,odd=0 ;
    for(int i=0 ; i<n ; i++){
      int x=__builtin_popcount(arr[i]);
      if(x % 2==0)even++;
      else odd++;
    }
    int y ;
    y=__builtin_popcount(K);
    if((y & 1)!=0){
      System.out.println("Even="+odd+",Odd="+even);
    }
    else {
      System.out.println("Even="+even+",Odd="+odd);
    }
  }
  public static void main(String[] args){
    int arr[]={
      4,2,15,9,8,8 };
      int K=3 ;
      int n=arr.length ;
      countEvenOdd(arr,n,K);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation __builtin_popcount( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     count := count+(n & 1) ; 
     n := n/(2->pow(1)) ) ; 
     return count );
  static   operation countEvenOdd( arr : Sequence(int), n : int, K : int) : void
  pre: true
  post: true
  activity: (     var even : int ; even := 0 ;
    var odd : int ; odd := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := __builtin_popcount(arr[i+1]) ;
     if (x mod 2 = 0) then     even := even + 1 ; else     odd := odd + 1 ; )  ;     i := i + 1 ) ; 
    var y : int ;
    y := __builtin_popcount(K) ; 
    if ((MathLib.bitwiseAnd(y,1)) /= 0) then (     OclFile["System.out"].println("Even=" + odd + ",Odd=" + even) ) else (     OclFile["System.out"].println("Even=" + even + ",Odd=" + odd) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,2,15,9,8,8} ;
     var K : int ; K := 3 ;
     var n : int ; n := arr->size() ;
     execute countEvenOdd(arr, n, K) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    shuffleHashing();
  }
  public static void shuffleHashing(){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    for(int i=0 ; i<t ; i++){
      String match="NO" ;
      String p=scan.next();
      String h=scan.next();
      int plen=p.length();
      int hlen=h.length();
      char[] pchar=p.toCharArray();
      Arrays.sort(pchar);
      String pout=new String(pchar);
      for(int j=0 ; j<=hlen-plen ; j++){
        String sub=h.substring(j,j+plen);
        char[] substr=sub.toCharArray();
        Arrays.sort(substr);
        String hsubstr=new String(substr);
        if(pout.equals(hsubstr)){
          match="YES" ;
          break ;
        }
      }
      System.out.println(match);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute shuffleHashing() );
  static   operation shuffleHashing() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var match : String ; match := "NO" ;
     var p : String ; p := scan.getCurrent() ;
    var h : String ; h := scan.getCurrent() ;
    var plen : int ; plen := p->size() ;
    var hlen : int ; hlen := h->size() ;
    var pchar : Sequence(String) ; pchar := p->characters() ;
    pchar := pchar->sort() ; 
    var pout : String ; pout := StringLib.newString(pchar) ;
        var j : int ; j := 0 ; while j <= hlen - (plen)->char2byte() do ( (     var sub : String ; sub := h.subrange(j+1,j + plen) ;
     var substr : Sequence(String) ; substr := sub->characters() ;
    substr := substr->sort() ; 
    var hsubstr : String ; hsubstr := StringLib.newString(substr) ;
    if (pout = hsubstr) then (     match := "YES" ; 
     break ) else skip ; 
 )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(match) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    shuffleHashing();
  }
  public static void shuffleHashing(){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    for(int i=0 ; i<t ; i++){
      String match="NO" ;
      String p=scan.next();
      String h=scan.next();
      int plen=p.length();
      int hlen=h.length();
      for(int j=0 ; j<=hlen-plen ; j++){
        if(strCheck(p,h.substring(j,j+plen))){
          match="YES" ;
          break ;
        }
      }
      System.out.println(match);
    }
  }
  public static boolean strCheck(String str1,String str2){
    int[] a=new int[26];
    for(int i=0 ; i<str1.length(); i++){
      a[str1.charAt(i)-97]++;
    }
    for(int i=0 ; i<str2.length(); i++){
      a[str2.charAt(i)-97]--;
    }
    for(int i=0 ; i<a.length ; i++){
      if(a[i]!=0)return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute shuffleHashing() );
  static   operation shuffleHashing() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var match : String ; match := "NO" ;
     var p : String ; p := scan.getCurrent() ;
    var h : String ; h := scan.getCurrent() ;
    var plen : int ; plen := p->size() ;
    var hlen : int ; hlen := h->size() ;
        var j : int ; j := 0 ; while j <= hlen - (plen)->char2byte() do ( (     if (strCheck(p, h.subrange(j+1,j + plen))) then (     match := "YES" ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(match) ; 
 )  ;     i := i + 1 ) );
  static   operation strCheck( str1 : String, str2 : String) : boolean
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,26)->collect(0) ;
         var i : int ; i := 0 ; while i < str1->size() do ( (     a[str1->at(i+1) - 97+1] := a[str1->at(i+1) - 97+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < str2->size() do ( (     a[str2->at(i+1) - 97+1] := a[str2->at(i+1) - 97+1] - 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] /= 0) then     return false else skip )  ;     i := i + 1 ) ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static String sorted(String s){
    char[] a=s.toCharArray();
    List<Integer>mylist=new ArrayList<>();
    for(char c : a)mylist.add((int)c);
    Collections.sort(mylist);
    String ns="" ;
    for(int i : mylist)ns+=(char)i+"" ;
    return ns ;
  }
  public static boolean solve(String p,String h){
    for(int i=0 ; i<h.length(); i++){
      for(int j=i ; j<h.length(); j++){
        if((j-i)+1==p.length()){
          String ns=h.substring(i,j+1);
          if(sorted(ns).equals(sorted(p))){
            return true ;
          }
        }
      }
    }
    return false ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      String p=sc.next();
      String h=sc.next();
      if(solve(p,h)==true)System.out.println("YES");
      else System.out.println("NO");
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation sorted( s : String) : String
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := s->characters() ;
     var mylist : Sequence(int) ; mylist := Sequence{} ;
    for (c : a) do (     mylist := mylist->including(c->oclAsType(int)) ;  ) ; 
    mylist := mylist->sort() ; 
    var ns : String ; ns := "" ;
    for (i : mylist) do (     ns := ns+(i->oclAsType(String) + "") ;  ) ; 
    return ns 
 );
  static   operation solve( p : String, h : String) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < h->size() do ( (         var j : int ; j := i ; while j < h->size() do ( (     if ((j - (i)->char2byte()) + 1 = p->size()) then (     var ns : String ; ns := h.subrange(i+1,j + 1) ;
     if (sorted(ns) = sorted(p)) then (     return true ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var p : String ; p := sc.getCurrent() ;
     var h : String ; h := sc.getCurrent() ;
     if (solve(p, h) = true) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
     t := t - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.Math ;
class Multipy {
  static void modify(int arr[],int n){
    if(n<=1)return ;
    int prev=arr[0];
    arr[0]=arr[0]*arr[1];
    for(int i=1 ; i<n-1 ; i++){
      int curr=arr[i];
      arr[i]=prev*arr[i+1];
      prev=curr ;
    }
    arr[n-1]=prev*arr[n-1];
  }
  public static void main(String[] args){
    int arr[]={
      2,3,4,5,6 };
      int n=arr.length ;
      modify(arr,n);
      for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Multipy {
  static   operation modify( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     if (n <= 1) then     return else skip ; 
     var prev : int ; prev := arr[0+1] ;
    arr[0+1] := arr[0+1] * arr[1+1] ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     var curr : int ; curr := arr[i+1] ;
     arr[i+1] := prev * arr[i + 1+1] ; 
     prev := curr )  ;     i := i + 1 ) ; 
    arr[n - 1+1] := prev * arr[n - 1+1] ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4,5,6} ;
     var n : int ; n := arr->size() ;
     execute modify(arr, n) ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int n ;
  static int m ;
  static int[][] table=new int[9][9];
  static int ans ;
  static boolean check(int team){
    int win=0 ;
    int lose=0 ;
    for(int i=0 ; i<n ; i++){
      if(table[team][i]>0)win++;
      else if(table[team][i]<0)lose++;
    }
    return win<=(n-1)/2 & lose<=(n-1)/2 ;
  }
  static void dfs(int cnt){
    if(cnt==n*n){
      ans++;
      return ;
    }
    int team=cnt/n ;
    int against=cnt % n ;
    if(table[team][against]==2 || table[team][against]==-2 || team>=against){
      if(check(team))dfs(cnt+1);
      return ;
    }
    table[team][against]=1 ;
    table[against][team]=-1 ;
    if(check(team))dfs(cnt+1);
    table[team][against]=-1 ;
    table[against][team]=1 ;
    if(check(team))dfs(cnt+1);
    table[team][against]=0 ;
    table[against][team]=0 ;
    return ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    while(n!=0){
      m=sc.nextInt();
      for(int i=0 ; i<9 ; i++){
        Arrays.fill(table[i],0);
      }
      for(int i=0 ; i<m ; i++){
        int x=sc.nextInt()-1 ;
        int y=sc.nextInt()-1 ;
        table[x][y]=2 ;
        table[y][x]=-2 ;
      }
      ans=0 ;
      dfs(0);
      System.out.println(ans);
      n=sc.nextInt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute m : int;
  static   attribute table : Sequence(Sequence(int)) := Integer.subrange(1,9)->collect(Integer.subrange(1,9)->collect(0));
  static   attribute ans : int;
  static   operation check( team : int) : boolean
  pre: true
  post: true
  activity: (     var win : int ; win := 0 ;
     var lose : int ; lose := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (table[team+1][i+1] > 0) then     win := win + 1 ; else     if (table[team+1][i+1] < 0) then     lose := lose + 1 ; else skip ; )  ;     i := i + 1 ) ; 
     return win <= (n - 1) / 2 & lose <= (n - 1) / 2 );
  static   operation dfs( cnt : int) : void
  pre: true
  post: true
  activity: (     if (cnt = n * n) then (     ans := ans + 1 ; 
     return ) else skip ; 
     var team : int ; team := cnt / n ;
    var against : int ; against := cnt mod n ;
    if (table[team+1][against+1] = 2 or table[team+1][against+1] = -2 or team >= against) then (     if (check(team)) then     execute dfs(cnt + 1) ; else skip ; 
     return ) else skip ; 
    table[team+1][against+1] := 1 ; 
    table[against+1][team+1] := -1 ; 
    if (check(team)) then     execute dfs(cnt + 1) ; else skip ; 
    table[team+1][against+1] := -1 ; 
    table[against+1][team+1] := 1 ; 
    if (check(team)) then     execute dfs(cnt + 1) ; else skip ; 
    table[team+1][against+1] := 0 ; 
    table[against+1][team+1] := 0 ; 
    return 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
     while (n /= 0) do (     m := sc.getCurrent()->toInteger() ; 
         var i : int ; i := 0 ; while i < 9 do ( (     table[i+1] := table[i+1]->collect(0) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
     var y : int ; y := sc.getCurrent()->toInteger() - 1 ;
     table[x+1][y+1] := 2 ; 
     table[y+1][x+1] := -2 )  ;     i := i + 1 ) ; 
    ans := 0 ; 
    execute dfs(0) ; 
    OclFile["System.out"].println(ans) ; 
    n := sc.getCurrent()->toInteger() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  static int n ;
  static int m ;
  static int[][] result ;
  static int count ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      n=sc.nextInt();
      if(n==0){
        System.exit(0);
      }
      m=sc.nextInt();
      result=new int[n][n];
      for(int i=0 ; i<m ; i++){
        int x=sc.nextInt()-1 ;
        int y=sc.nextInt()-1 ;
        result[x][y]=1 ;
        result[y][x]=-1 ;
      }
      count=0 ;
      dfs(0,1);
      System.out.println(count);
    }
  }
  static void dfs(int x,int y){
    if(y==n){
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        sum+=result[x][i];
      }
      if(sum==0){
        if(x<n-1){
          dfs(x+1,x+2);
        }
        else {
          count++;
        }
      }
      return ;
    }
    if(x==y || result[x][y]!=0){
      dfs(x,y+1);
    }
    else {
      result[x][y]=1 ;
      result[y][x]=-1 ;
      dfs(x,y+1);
      result[x][y]=-1 ;
      result[y][x]=1 ;
      dfs(x,y+1);
      result[x][y]=0 ;
      result[y][x]=0 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute m : int;
  static   attribute result : Sequence(Sequence(int));
  static   attribute count : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then ( OclProcess.exit(0) ) else skip ; 
    m := sc.getCurrent()->toInteger() ; 
    result := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
     var y : int ; y := sc.getCurrent()->toInteger() - 1 ;
     result[x+1][y+1] := 1 ; 
     result[y+1][x+1] := -1 )  ;     i := i + 1 ) ; 
    count := 0 ; 
    execute dfs(0, 1) ; 
    OclFile["System.out"].println(count) ; 
 ) );
  static   operation dfs( x : int, y : int) : void
  pre: true
  post: true
  activity: (     if (y = n) then (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(result[x+1][i+1]) )  ;     i := i + 1 ) ; 
     if (sum = 0) then (     if (x < n - 1) then (     execute dfs(x + 1, x + 2) ) else (     count := count + 1 ) ) else skip ; 
     return ) else skip ; 
     if (x = y or result[x+1][y+1] /= 0) then (     execute dfs(x, y + 1) ) else (     result[x+1][y+1] := 1 ; 
     result[y+1][x+1] := -1 ; 
    execute dfs(x, y + 1) ; 
    result[x+1][y+1] := -1 ; 
    result[y+1][x+1] := 1 ; 
    execute dfs(x, y + 1) ; 
    result[x+1][y+1] := 0 ; 
    result[y+1][x+1] := 0 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      int m=sc.nextInt();
      int map[][]=new int[n][n];
      for(int i=0 ; i<m ; i++){
        int x=sc.nextInt()-1 ;
        int y=sc.nextInt()-1 ;
        map[x][y]=1 ;
        map[y][x]=-1 ;
      }
      System.out.println(dfs(map,0,1,0));
    }
  }
  int dfs(int map[][],int x,int y,int count){
    if(x>=map.length){
      return 1 ;
    }
    if(y>=map[x] .length){
      int ss=0 ;
      for(int s : map[x]){
        ss+=s ;
      }
      if(ss==0){
        return dfs(map,x+1,x+2,count);
      }
      else {
        return 0 ;
      }
    }
    if(map[x][y]!=0){
      return dfs(map,x,y+1,count);
    }
    int res=0 ;
    map[x][y]=1 ;
    map[y][x]=-1 ;
    res+=dfs(map,x,y+1,count);
    map[x][y]=-1 ;
    map[y][x]=1 ;
    res+=dfs(map,x,y+1,count);
    map[x][y]=0 ;
    map[y][x]=0 ;
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
     var y : int ; y := sc.getCurrent()->toInteger() - 1 ;
     map[x+1][y+1] := 1 ; 
     map[y+1][x+1] := -1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dfs(map, 0, 1, 0)) ; 
 )  ) );
   operation dfs( map : Sequence(Sequence(int)), x : int, y : int, count : int) : int
  pre: true
  post: true
  activity: (     if (x >= map->size()) then (     return 1 ) else skip ; 
     if (y >= map[x+1]->size()) then (     var ss : int ; ss := 0 ;
     for (s : map[x+1]) do ( (     ss := ss+(s) )  ) ; 
     if (ss = 0) then (     return dfs(map, x + 1, x + 2, count) ) else (     return 0 ) ) else skip ; 
    if (map[x+1][y+1] /= 0) then (     return dfs(map, x, y + 1, count) ) else skip ; 
    var res : int ; res := 0 ;
    map[x+1][y+1] := 1 ; 
    map[y+1][x+1] := -1 ; 
    res := res+(dfs(map, x, y + 1, count)) ; 
    map[x+1][y+1] := -1 ; 
    map[y+1][x+1] := 1 ; 
    res := res+(dfs(map, x, y + 1, count)) ; 
    map[x+1][y+1] := 0 ; 
    map[y+1][x+1] := 0 ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int summation(int n){
    int abs_sum=n*(n+1)/2 ;
    int sign=n+1 % 2==0 ? 1 :-1 ;
    int result_sum=sign*abs_sum ;
    return result_sum ;
  }
  public static void main(String[] args){
    int N=2 ;
    System.out.println(summation(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation summation( n : int) : int
  pre: true
  post: true
  activity: (     var abs_sum : int ; abs_sum := n * (n + 1) / 2 ;
     var sign : int ; sign := if n + 1 mod 2 = 0 then 1 else -1 endif ;
     var result_sum : int ; result_sum := sign * abs_sum ;
     return result_sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 2 ;
     OclFile["System.out"].println(summation(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Mridul4 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int hund=0,twoh=0 ;
    int[] arr=new int[n];
    int i=-1 ;
    while(i!=n-1){
      i=i+1 ;
      arr[i]=sc.nextInt();
    }
    int sum=0 ;
    i=-1 ;
    while(i!=n-1){
      i=i+1 ;
      sum=sum+arr[i];
      if(arr[i]==100){
        hund=hund+1 ;
      }
      else {
        twoh=twoh+1 ;
      }
    }
    if((sum/100)% 2!=0){
      System.out.println("NO");
    }
    else {
      if(hund % 2==0 && twoh % 2==0){
        System.out.println("YES");
      }
      else if(hund==0 && twoh % 2!=0){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mridul4 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var hund : int ; hund := 0 ;
    var twoh : int ; twoh := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var i : int ; i := -1 ;
    while (i /= n - 1) do (     i := i + 1 ; 
     arr[i+1] := sc.getCurrent()->toInteger() ) ; 
    var sum : int ; sum := 0 ;
    i := -1 ; 
    while (i /= n - 1) do (     i := i + 1 ; 
     sum := sum + arr[i+1] ; 
     if (arr[i+1] = 100) then (     hund := hund + 1 ) else (     twoh := twoh + 1 ) ) ; 
    if ((sum / 100) mod 2 /= 0) then (     OclFile["System.out"].println("NO") ) else (     if (hund mod 2 = 0 & twoh mod 2 = 0) then (     OclFile["System.out"].println("YES") ) else     if (hund = 0 & twoh mod 2 /= 0) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int h=0 ;
    int d=0 ;
    for(int i=0 ; i<n ; i++){
      int v=sc.nextInt();
      if(v==100){
        h++;
      }
      else {
        d++;
      }
    }
    if((h & 1)!=0 ||(h==0 &&(d & 1)!=0)){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var h : int ; h := 0 ;
    var d : int ; d := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := sc.getCurrent()->toInteger() ;
     if (v = 100) then (     h := h + 1 ) else (     d := d + 1 ) )  ;     i := i + 1 ) ; 
    if ((MathLib.bitwiseAnd(h,1)) /= 0 or (h = 0 & (MathLib.bitwiseAnd(d,1)) /= 0)) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class AKitaharaHarukisGift {
  public static void main(String[] args)throws IOException {
    BufferedReader buf=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(buf.readLine());
    String[] inp=buf.readLine().split(" ");
    int c2=0,c1=0 ;
    for(String s : inp){
      int r=Integer.parseInt(s);
      if(r==200)c2++;
      else c1++;
    }
    c2=c2 % 2 ;
    if(c2==1 && c1>=2){
      c2=0 ;
      c1-=2 ;
    }
    c1=c1 % 2 ;
    if(c1==0 && c2==0)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class AKitaharaHarukisGift {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var buf : OclFile ; buf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (buf.readLine())->toInteger() ;
    var inp : Sequence(String) ; inp := buf.readLine()->split(" ") ;
    var c2 : int ; c2 := 0 ;
    var c1 : int ; c1 := 0 ;
    for (s : inp) do ( (     var r : int ; r := (s)->toInteger() ;
     if (r = 200) then     c2 := c2 + 1 ; else     c1 := c1 + 1 ; )  ) ; 
    c2 := c2 mod 2 ; 
    if (c2 = 1 & c1 >= 2) then (     c2 := 0 ; 
     c1 := c1-(2) ) else skip ; 
    c1 := c1 mod 2 ; 
    if (c1 = 0 & c2 = 0) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    if(n==1){
      System.out.println("NO");
      System.exit(0);
    }
    int sum=0 ;
    boolean x=true ;
    for(int i=0 ; i<n-1 ; i++){
      if(arr[i]!=arr[i+1])x=false ;
    }
    for(int i=0 ; i<n ; i++)sum+=arr[i];
    if((sum/2)% 100==0){
      if(x==true && n % 2!=0){
        System.out.println("NO");
        System.exit(0);
      }
      System.out.println("YES");
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    if (n = 1) then (     OclFile["System.out"].println("NO") ; 
 OclProcess.exit(0) ) else skip ; 
    var sum : int ; sum := 0 ;
    var x : boolean ; x := true ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] /= arr[i + 1+1]) then     x := false ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    if ((sum / 2) mod 100 = 0) then (     if (x = true & n mod 2 /= 0) then (     OclFile["System.out"].println("NO") ; 
 OclProcess.exit(0) ) else skip ; 
     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int N=2005 ;
  static Set<Integer>ans=new LinkedHashSet<Integer>();
  static void dfs(int num,int left,int ct){
    if(ct>=15)return ;
    if(left==0)ans.add(num);
    for(int i=0 ; i<=Math.min(left,9); i++)dfs(num*10+i,left-i,ct+1);
  }
  static int getKthNum(int m,int k){
    dfs(0,m,0);
    int ct=0 ;
    for(int it : ans){
      ct++;
      if(ct==k){
        return it ;
      }
    }
    return-1 ;
  }
  public static void main(String[] args){
    int m=5,k=3 ;
    System.out.println(getKthNum(m,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 2005;
  static   attribute ans : Set(int) := Set{};
  static   operation dfs( num : int, left : int, ct : int) : void
  pre: true
  post: true
  activity: (     if (ct >= 15) then     return else skip ; 
     if (left = 0) then     ans := ans->including(num) ; else skip ; 
         var i : int ; i := 0 ; while i <= Set{left, 9}->min() do (     execute dfs(num * 10 + i, left - i, ct + 1) ;  ;     i := i + 1 ) );
  static   operation getKthNum( m : int, k : int) : int
  pre: true
  post: true
  activity: (     execute dfs(0, m, 0) ; 
     var ct : int ; ct := 0 ;
     for (it : ans) do ( (     ct := ct + 1 ; 
     if (ct = k) then (     return it ) else skip )  ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 5 ;
    var k : int ; k := 3 ;
     OclFile["System.out"].println(getKthNum(m, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Art[] arts=new Art[n];
    for(int i=0 ; i<n ; i++){
      arts[i]=new Art(sc.nextLong(),sc.nextInt());
    }
    Arrays.sort(arts);
    long[] values=new long[n+1];
    long max=Long.MIN_VALUE ;
    long min=Long.MAX_VALUE ;
    for(int i=1 ; i<=n ; i++){
      values[i]=arts[i-1] .value+values[i-1];
      min=Math.min(min,values[i-1]-arts[i-1] .size);
      max=Math.max(max,values[i]-arts[i-1] .size-min);
    }
    System.out.println(max);
  }
  static class Art implements Comparable<Art>{
    long size ;
    int value ;
    public Art(long size,int value){
      this.size=size ;
      this.value=value ;
    }
    public int compareTo(Art another){
      if(size==another.size){
        return 0 ;
      }
      else if(size<another.size){
        return-1 ;
      }
      else {
        return 1 ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arts : Sequence(Art) ; arts := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     arts[i+1] := Art.newArt(sc.getCurrent()->toLong(), sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    arts := arts->sort() ; 
    var values : Sequence(long) ; values := Integer.subrange(1,n + 1)->collect(0) ;
    var max : long ; max := "-9223372036854775808"->toLong() ;
    var min : long ; min := "9223372036854775807"->toLong() ;
        var i : int ; i := 1 ; while i <= n do ( (     values[i+1] := arts[i - 1+1].value + values[i - 1+1] ; 
     min := Set{min, values[i - 1+1] - arts[i - 1+1].size}->min() ; 
     max := Set{max, values[i+1] - arts[i - 1+1].size - min}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static class Art implements Comparable<Art> {
   attribute size : long;
   attribute value : int;
   static operation newArt( size : long, value : int) : Art
  pre: true
  post: true
  activity:
  ( var self : Art ;
    self := createArt();
    self.initialise(size, value);
    return self );
  operation initialise( size : long, value : int) : void
  pre: true  post: true
  activity: (     self.size := size ; 
     self.value := value );
   operation compareTo( another : Art) : int
  pre: true
  post: true
  activity: (     if (size = another.size) then (     return 0 ) else     if (size < another.size) then (     return -1 ) else (     return 1 ) ;  );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int N ;
  static int M ;
  static int V ;
  static int P ;
  static Long[] A ;
  public static boolean isOK(int index){
    long max=(long)A[index]+M ;
    long tmp=(long)(P-1)+(long)((long)N-index)-(long)V ;
    if(max<(long)A[P-1])return false ;
    if(tmp>=0){
      if(max>=(long)A[P-1])return true ;
      else return false ;
    }
    else {
      long sum=0L ;
      for(int i=P-1 ; i<index ; i++){
        sum=sum+(long)A[i];
      }
      if((sum-tmp*M)<=max*(index-(P-1)))return true ;
      else return false ;
    }
  }
  public static int binary_search(){
    long right=P-1 ;
    long left=N ;
    while(Math.abs(right-left)>1){
      long mid=left+(right-left)/2 ;
      if(isOK((int)mid))right=mid ;
      else left=mid ;
    }
    return(int)right ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    N=Integer.parseInt(sc.next());
    M=Integer.parseInt(sc.next());
    V=Integer.parseInt(sc.next());
    P=Integer.parseInt(sc.next());
    A=new Long[N];
    for(int i=0 ; i<N ; i++){
      A[i]=Long.parseLong(sc.next());
    }
    Arrays.sort(A,(o1,o2)->Long.compare(o2,o1));
    System.out.println(binary_search()+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute M : int;
  static   attribute V : int;
  static   attribute P : int;
  static   attribute A : Sequence(long);
  static   operation isOK( index : int) : boolean
  pre: true
  post: true
  activity: (     var max : long ; max := A[index+1]->oclAsType(long) + M ;
     var tmp : long ; tmp := (P - 1)->oclAsType(long) + (N->oclAsType(long) - index)->oclAsType(long) - V->oclAsType(long) ;
     if (max < A[P - 1+1]->oclAsType(long)) then     return false else skip ; 
     if (tmp >= 0) then (     if (max >= A[P - 1+1]->oclAsType(long)) then     return true else     return false ) else (     var sum : long ; sum := 0L ;
         var i : int ; i := P - 1 ; while i < index do ( (     sum := sum + A[i+1]->oclAsType(long) )  ;     i := i + 1 ) ; 
     if ((sum - tmp * M) <= max * (index - (P - 1))) then     return true else     return false ) );
  static   operation binary_search() : int
  pre: true
  post: true
  activity: (     var right : long ; right := P - 1 ;
     var left : long ; left := N ;
     while (if right - left < 0 then -(right - left) else right - left endif > 1) do (     var mid : long ; mid := left + (right - left) / 2 ;
     if (isOK(mid->oclAsType(int))) then     right := mid ; else     left := mid ; ) ; 
     return right->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := (sc.getCurrent())->toInteger() ; 
    M := (sc.getCurrent())->toInteger() ; 
    V := (sc.getCurrent())->toInteger() ; 
    P := (sc.getCurrent())->toInteger() ; 
    A := Integer.subrange(1,N)->collect(null) ; 
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := (sc.getCurrent())->toLong() )  ;     i := i + 1 ) ; 
    A := OclComparator.sortWith(A, lambda (o1 , o2) : OclAny in compare(o2, o1)) ; 
    OclFile["System.out"].println(binary_search() + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void makePolygon(double a){
    double n=360/(180-a);
    if(n==(int)n)System.out.println("YES");
    else System.out.println("NO");
  }
  public static void main(String[] args){
    double a=90 ;
    makePolygon(a);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation makePolygon( a : double) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 360 / (180 - a) ;
     if (n = n->oclAsType(int)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 90 ;
     execute makePolygon(a) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAXN=100000 ;
  static int MOD=1000000007 ;
  static long fact[]=new long[MAXN];
  static void factorial(){
    fact[0]=1 ;
    for(int i=1 ; i<MAXN ; i++)fact[i]=(fact[i-1]*i)% MOD ;
  }
  static long power(long x,long y,long p){
    long res=1 ;
    x=x % p ;
    while(y>0){
      if(y % 2==1)res=(res*x)% p ;
      y=y>>1 ;
      x=(x*x)% p ;
    }
    return res ;
  }
  static long modInverse(long x,long p){
    return power(x,p-2,p);
  }
  static long countDifferentNumbers(long arr[],long P){
    factorial();
    long res=0,X=0 ;
    for(int i=0 ; i<10 ; i++)X+=arr[i];
    res=fact[(int)X];
    for(int i=0 ; i<10 ; i++){
      if(arr[i]>1)res=(res*modInverse(fact[(int)arr[i] ],P))% P ;
    }
    return res ;
  }
  public static void main(String[] args){
    long arr[]={
      1,0,2,0,0,7,4,0,0,3 };
      System.out.println(countDifferentNumbers(arr,MOD));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAXN : int := 100000;
  static   attribute MOD : int := 1000000007;
  static   attribute fact : long := Integer.subrange(1,MAXN)->collect(0);
  static   operation factorial() : void
  pre: true
  post: true
  activity: (     fact[0+1] := 1 ; 
         var i : int ; i := 1 ; while i < MAXN do (     fact[i+1] := (fact[i - 1+1] * i) mod MOD ;  ;     i := i + 1 ) );
  static   operation power( x : long, y : long, p : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     if (y mod 2 = 1) then     res := (res * x) mod p ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res );
  static   operation modInverse( x : long, p : long) : long
  pre: true
  post: true
  activity: (     return power(x, p - 2, p) );
  static   operation countDifferentNumbers( arr : Sequence(long), P : long) : long
  pre: true
  post: true
  activity: (     execute factorial() ; 
     var res : long ; res := 0 ;
    var X : long ; X := 0 ;
        var i : int ; i := 0 ; while i < 10 do (     X := X+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    res := fact[X->oclAsType(int)+1] ; 
        var i : int ; i := 0 ; while i < 10 do ( (     if (arr[i+1] > 1) then     res := (res * modInverse(fact[arr[i+1]->oclAsType(int)+1], P)) mod P ; else skip )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(long) ; arr := Sequence{1,0,2,0,0,7,4,0,0,3} ;
     OclFile["System.out"].println(countDifferentNumbers(arr, MOD)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class GFG {
  public static void sortSquares(int arr[]){
    int n=arr.length ;
    for(int i=0 ; i<n ; i++)arr[i]=arr[i]*arr[i];
    Arrays.sort(arr);
  }
  public static void main(String[] args){
    int arr[]={
-6,-3,-1,2,4,5 };
      int n=arr.length ;
      System.out.println("Before sort ");
      for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
      sortSquares(arr);
      System.out.println("");
      System.out.println("After Sort ");
      for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sortSquares( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
         var i : int ; i := 0 ; while i < n do (     arr[i+1] := arr[i+1] * arr[i+1] ;  ;     i := i + 1 ) ; 
     arr := arr->sort() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-6,-3,-1,2,4,5} ;
     var n : int ; n := arr->size() ;
    OclFile["System.out"].println("Before sort ") ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
    execute sortSquares(arr) ; 
    OclFile["System.out"].println("") ; 
    OclFile["System.out"].println("After Sort ") ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void main(String args[]){
    int marks[]={
      25,65,46,98,78,65 };
      int max_marks=marks.length*100 ;
      int total=0 ;
      char grade='F' ;
      for(int i=0 ; i<marks.length ; i++){
        total+=marks[i];
      }
      double percentage=((double)(total)/max_marks)*100 ;
      if(percentage>=90){
        grade='A' ;
      }
      else {
        if(percentage>=80 && percentage<=89){
          grade='B' ;
        }
        else {
          if(percentage>=60 && percentage<=79){
            grade='C' ;
          }
          else {
            if(percentage>=33 && percentage<=59){
              grade='D' ;
            }
            else {
              grade='F' ;
            }
          }
        }
      }
      System.out.println(grade);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var marks : Sequence(int) ; marks := Sequence{25,65,46,98,78,65} ;
     var max_marks : int ; max_marks := marks->size() * 100 ;
    var total : int ; total := 0 ;
    var grade : String ; grade := 'F' ;
        var i : int ; i := 0 ; while i < marks->size() do ( (     total := total+(marks[i+1]) )  ;     i := i + 1 ) ; 
    var percentage : double ; percentage := ((total)->oclAsType(double) / max_marks) * 100 ;
    if (percentage >= 90) then (     grade := 'A' ) else (     if (percentage >= 80 & percentage <= 89) then (     grade := 'B' ) else (     if (percentage >= 60 & percentage <= 79) then (     grade := 'C' ) else (     if (percentage >= 33 & percentage <= 59) then (     grade := 'D' ) else (     grade := 'F' ) ) ) ) ;  
    OclFile["System.out"].println(grade) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static int getMaxLength(int arr[]){
    int l=arr.length ;
    int i=0,maxlen=0 ;
    while(i<l){
      int j=i ;
      while(i+1<l &&(Math.abs(arr[i]-arr[i+1])==1 || Math.abs(arr[i]-arr[i+1])==0)){
        i++;
      }
      int currLen=i-j+1 ;
      if(maxlen<currLen)maxlen=currLen ;
      if(j==i)i++;
    }
    maxlen=(maxlen==1)? 0 : maxlen ;
    return maxlen ;
  }
  public static void main(String[] args){
    int arr[]={
      2,4 };
      System.out.print(getMaxLength(arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getMaxLength( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var l : int ; l := arr->size() ;
     var i : int ; i := 0 ;
    var maxlen : int ; maxlen := 0 ;
    while (i < l) do (     var j : int ; j := i ;
     while (i + 1 < l & (if arr[i+1] - arr[i + 1+1] < 0 then -(arr[i+1] - arr[i + 1+1]) else arr[i+1] - arr[i + 1+1] endif = 1 or if arr[i+1] - arr[i + 1+1] < 0 then -(arr[i+1] - arr[i + 1+1]) else arr[i+1] - arr[i + 1+1] endif = 0)) do (     i := i + 1 ) ; 
    var currLen : int ; currLen := i - j + 1 ;
    if (maxlen < currLen) then     maxlen := currLen ; else skip ; 
    if (j = i) then     i := i + 1 ; else skip ; 
 ) ; 
    maxlen := if (maxlen = 1) then 0 else maxlen endif ; 
    return maxlen 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4} ;
     OclFile["System.out"].print(getMaxLength(arr)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static long subarrayXor(int arr[],int n,int m){
    long ans=0 ;
    int[] xorArr=new int[n];
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    xorArr[0]=arr[0];
    for(int i=1 ; i<n ; i++)xorArr[i]=xorArr[i-1] ^ arr[i];
    for(int i=0 ; i<n ; i++){
      int tmp=m ^ xorArr[i];
      ans=ans+(mp.containsKey(tmp)==false ? 0 :((long)mp.get(tmp)));
      if(xorArr[i]==m)ans++;
      if(mp.containsKey(xorArr[i]))mp.put(xorArr[i],mp.get(xorArr[i])+1);
      else mp.put(xorArr[i],1);
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      4,2,2,6,4 };
      int n=arr.length ;
      int m=6 ;
      System.out.print("Number of subarrays having given XOR is "+subarrayXor(arr,n,m));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation subarrayXor( arr : Sequence(int), n : int, m : int) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
     var xorArr : Sequence(int) ; xorArr := Integer.subrange(1,n)->collect(0) ;
    var mp : Map(int,int) ; mp := Map{} ;
    xorArr[0+1] := arr[0+1] ; 
        var i : int ; i := 1 ; while i < n do (     xorArr[i+1] := xorArr[i - 1+1] xor arr[i+1] ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var tmp : int ; tmp := MathLib.bitwiseXor(m,xorArr[i+1]) ;
     ans := ans + (if mp->keys()->includes(tmp) = false then 0 else (mp->at(tmp)->oclAsType(long)) endif) ; 
     if (xorArr[i+1] = m) then     ans := ans + 1 ; else skip ; 
     if (mp->keys()->includes(xorArr[i+1])) then     mp := mp->union(Map{xorArr[i+1] |-> mp->at(xorArr[i+1]) + 1}) ; else     mp := mp->union(Map{xorArr[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,2,2,6,4} ;
     var n : int ; n := arr->size() ;
     var m : int ; m := 6 ;
     OclFile["System.out"].print("Number of subarrays having given XOR is " + subarrayXor(arr, n, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  public static int nth_term(int n){
    int a=1,b=1,c=1 ;
    for(int i=0 ; i<n ; i++){
      c=a+b ;
      a=b ;
      b=c ;
    }
    return c ;
  }
  public static void main(String[] args){
    int n=10 ;
    int c=nth_term(n);
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation nth_term( n : int) : int
  pre: true
  post: true
  activity: (     var a : int ; a := 1 ;
    var b : int ; b := 1 ;
    var c : int ; c := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     c := a + b ; 
     a := b ; 
     b := c )  ;     i := i + 1 ) ; 
     return c );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     var c : int ; c := nth_term(n) ;
     OclFile["System.out"].println(c) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int factorial(int n){
    int result=1 ;
    for(int i=1 ; i<=n ; i++)result=result*i ;
    return result ;
  }
  static int nCr(int n,int r){
    return factorial(n)/(factorial(r)*factorial(n-r));
  }
  static int calculate_result(int n){
    int result=2*nCr((n-2),(n/2-1));
    return result ;
  }
  public static void main(String[] args){
    int a=2,b=4 ;
    System.out.println(calculate_result(2*a));
    System.out.print(calculate_result(2*b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation factorial( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 1 ;
         var i : int ; i := 1 ; while i <= n do (     result := result * i ;  ;     i := i + 1 ) ; 
     return result );
  static   operation nCr( n : int, r : int) : int
  pre: true
  post: true
  activity: (     return factorial(n) / (factorial(r) * factorial(n - r)) );
  static   operation calculate_result( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 2 * nCr((n - 2), (n / 2 - 1)) ;
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 2 ;
    var b : int ; b := 4 ;
     OclFile["System.out"].println(calculate_result(2 * a)) ; 
     OclFile["System.out"].print(calculate_result(2 * b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int[] arr=new int[7];
      for(int j=0 ; j<7 ; j++){
        arr[j]=sc.nextInt();
      }
      int sum=arr[6]-(arr[0]+arr[1]);
      System.out.println(arr[0]+" "+arr[1]+" "+sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var arr : Sequence(int) ; arr := Integer.subrange(1,7)->collect(0) ;
         var j : int ; j := 0 ; while j < 7 do ( (     arr[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
     var sum : int ; sum := arr[6+1] - (arr[0+1] + arr[1+1]) ;
     OclFile["System.out"].println(arr[0+1] + " " + arr[1+1] + " " + sum) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test199 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int a[]=new int[7];
      for(int i=0 ; i<7 ; i++){
        a[i]=in.nextInt();
      }
      System.out.println(a[0]+" "+a[1]+" "+(a[6]-a[0]-a[1]));
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test199 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var a : Sequence(int) ; a := Integer.subrange(1,7)->collect(0) ;
         var i : int ; i := 0 ; while i < 7 do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(a[0+1] + " " + a[1+1] + " " + (a[6+1] - a[0+1] - a[1+1])) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.System.*;
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(in);
    int num=Integer.parseInt(sc.nextLine());
    int[] arr=new int[num];
    ArrayList<Integer>arl=new ArrayList<Integer>();
    for(int i=0 ; i<num ; i++){
      arr[i]=Integer.parseInt(sc.next());
    }
    for(int j=arr.length-1 ; j>=0 ; j--){
      if(! arl.contains(arr[j])){
        arl.add(arr[j]);
      }
    }
    out.println(arl.size());
    for(int x=arl.size()-1 ; x>=0 ; x--){
      out.print(arl.get(x)+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var num : int ; num := (sc.nextLine())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,num)->collect(0) ;
    var arl : Sequence(int) ; arl := Sequence{} ;
        var i : int ; i := 0 ; while i < num do ( (     arr[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
        var j : int ; j := arr->size() - 1 ; while j >= 0 do ( (     if (not(arl->includes(arr[j+1]))) then (     arl := arl->including(arr[j+1]) ) else skip )  ;     j := j - 1 ) ; 
    out.println(arl->size()) ; 
        var x : int ; x := arl->size() - 1 ; while x >= 0 do ( (     out.print(arl->at(x+1) + " ") )  ;     x := x - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    long M=scanner.nextInt();
    long V=scanner.nextInt();
    int P=scanner.nextInt();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++)A[i]=scanner.nextInt();
    Arrays.sort(A);
    reverse(A);
    long[] cum=new long[N];
    for(int i=1 ; i<N ; i++)cum[i]=cum[i-1]+A[i-1];
    int left=0 ;
    int right=N ;
    while(right-left>1){
      int mid=(right+left)/2 ;
      if(possible(N,M,V,P,A,cum,mid)){
        left=mid ;
      }
      else {
        right=mid ;
      }
    }
    System.out.println(right);
  }
  private static boolean possible(int N,long M,long V,int P,int[] A,long[] cum,int i){
    if(i<P)return true ;
    if(A[i]+M<A[P-1])return false ;
    return M*(P-1+N-i)+(i-P+1)*(A[i]+M)-(cum[i]-cum[P-1])>=M*V ;
  }
  private static void reverse(int[] a){
    int i=0 ;
    int j=a.length-1 ;
    while(i<j){
      int tmp=a[i];
      a[i]=a[j];
      a[j]=tmp ;
      i++;
      j--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var M : long ; M := scanner.getCurrent()->toInteger() ;
    var V : long ; V := scanner.getCurrent()->toInteger() ;
    var P : int ; P := scanner.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     A[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    execute reverse(A) ; 
    var cum : Sequence(long) ; cum := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 1 ; while i < N do (     cum[i+1] := cum[i - 1+1] + A[i - 1+1] ;  ;     i := i + 1 ) ; 
    var left : int ; left := 0 ;
    var right : int ; right := N ;
    while (right - left > 1) do (     var mid : int ; mid := (right + left) / 2 ;
     if (possible(N, M, V, P, A, cum, mid)) then (     left := mid ) else (     right := mid ) ) ; 
    OclFile["System.out"].println(right) ; 
 );
  static   operation possible( N : int, M : long, V : long, P : int, A : Sequence(int), cum : Sequence(long), i : int) : boolean
  pre: true
  post: true
  activity: (     if (i < P) then     return true else skip ; 
     if (A[i+1] + M < A[P - 1+1]) then     return false else skip ; 
     return M * (P - 1 + N - i) + (i - P + 1) * (A[i+1] + M) - (cum[i+1] - cum[P - 1+1]) >= M * V );
  static   operation reverse( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var j : int ; j := a->size() - 1 ;
     while (i < j) do (     var tmp : int ; tmp := a[i+1] ;
     a[i+1] := a[j+1] ; 
    a[j+1] := tmp ; 
    i := i + 1 ; 
    j := j - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    int sum=0,c=0 ;
    double o=0 ;
    for(; sc.hasNextLine(); c++){
      String buf=sc.nextLine();
      Scanner m=new Scanner(buf.replace(',',' '));
      int a=m.nextInt();
      int b=m.nextInt();
      sum+=a*b ;
      o+=b ;
    }
    System.out.println(sum+"\n"+(int)(o/c+0.5));
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
    var c : int ; c := 0 ;
     var o : double ; o := 0 ;
       while sc.hasNextLine() do ( (     var buf : String ; buf := sc.nextLine() ;
     var m : OclFile ; m := OclFile.newOclFile_Read(buf.replace(',', ' ')) ;
    var a : int ; a := m.getCurrent()->toInteger() ;
    var b : int ; b := m.getCurrent()->toInteger() ;
    sum := sum+(a * b) ; 
    o := o+(b) ; 
 )  ;     c := c + 1 ) ; 
     OclFile["System.out"].println(sum + "\n" + (o / c + 0.5)->oclAsType(int)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CP19 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),t=sc.nextInt(),k=0,pos=1 ;
    sc.nextLine();
    int arr[]=new int[n];
    for(int i=0 ; i<n-1 ; i++){
      arr[i]=sc.nextInt();
    }
    while(pos<t){
      k=pos+arr[pos-1];
      pos=k ;
    }
    if(pos==t){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CP19 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var k : int ; k := 0 ;
    var pos : int ; pos := 1 ;
    skip ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    while (pos < t) do (     k := pos + arr[pos - 1+1] ; 
     pos := k ) ; 
    if (pos = t) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1618A_PolycarpandSumsofSubsequences {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      List<Integer>list=new LinkedList<>();
      for(int i=0 ; i<7 ; i++){
        list.add(input.nextInt());
      }
      input.nextLine();
      list.remove(Integer.valueOf(list.get(0)+list.get(1)));
      list.remove(Integer.valueOf(list.get(0)+list.get(2)));
      list.remove(Integer.valueOf(list.get(1)+list.get(2)));
      list.remove(Integer.valueOf(list.get(1)+list.get(2)+list.get(0)));
      System.out.println(list.toString().replaceAll("[\\[\\],] ",""));
      Collections.sort(list);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1618A_PolycarpandSumsofSubsequences {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var list : Sequence(int) ; list := Sequence{} ;
         var i : int ; i := 0 ; while i < 7 do ( (     list := list->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    skip ; 
    list := list->excludingFirst((list->at(0+1) + list->at(1+1))->toInteger()) ; 
    list := list->excludingFirst((list->at(0+1) + list->at(2+1))->toInteger()) ; 
    list := list->excludingFirst((list->at(1+1) + list->at(2+1))->toInteger()) ; 
    list := list->excludingFirst((list->at(1+1) + list->at(2+1) + list->at(0+1))->toInteger()) ; 
    OclFile["System.out"].println(list+"".replaceAllMatches("[\\[\\],] ", "" )) ; 
    list := list->sort() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Vector ;
public class PolycarpandSumsofSubsequences {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int tc=sc.nextInt();
    for(int i=0 ; i<tc ; i++){
      Vector<Integer>vec=new Vector<Integer>();
      for(int j=0 ; j<7 ; j++){
        int in=sc.nextInt();
        vec.add(in);
      }
      System.out.println(vec.get(0)+" "+vec.get(1)+" "+(vec.get(6)-vec.get(0)-vec.get(1)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PolycarpandSumsofSubsequences {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < tc do ( (     var vec : Sequence(int) ; vec := Sequence{} ;
         var j : int ; j := 0 ; while j < 7 do ( (     var in : int ; in := sc.getCurrent()->toInteger() ;
     vec := vec->including(in) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(vec->at(0+1) + " " + vec->at(1+1) + " " + (vec->at(6+1) - vec->at(0+1) - vec->at(1+1))) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Geeks {
  static float maxVol(float P,float A){
    float l=(float)(P-Math.sqrt(P*P-24*A))/12 ;
    float V=(float)(l*(A/2.0-l*(P/4.0-l)));
    return V ;
  }
  public static void main(String args[]){
    float P=20,A=16 ;
    System.out.println(maxVol(P,A));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Geeks {
  static   operation maxVol( P : double, A : double) : double
  pre: true
  post: true
  activity: (     var l : double ; l := (P - (P * P - 24 * A)->sqrt())->oclAsType(double) / 12 ;
     var V : double ; V := (l * (A / 2.0 - l * (P / 4.0 - l)))->oclAsType(double) ;
     return V );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var P : double ; P := 20 ;
    var A : double ; A := 16 ;
     OclFile["System.out"].println(maxVol(P, A)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  static int[][] dp ;
  static char[] in1,in2 ;
  final static int BIG_PRIME=1000000007 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    in1=br.readLine().toCharArray();
    in2=br.readLine().toCharArray();
    dp=new int[in1.length][in2.length];
    for(int[] i : dp){
      Arrays.fill(i,-1);
    }
    System.out.println(search(0,0)% BIG_PRIME);
  }
  static int search(int i,int j){
    int count=0 ;
    if(j==in2.length)return 1 ;
    if(i==in1.length)return 0 ;
    if(dp[i][j]!=-1){
      return dp[i][j];
    }
    else if(in1[i]==in2[j]){
      count=search(i+1,j+1)% BIG_PRIME+search(i+1,j)% BIG_PRIME ;
    }
    else {
      count=search(i+1,j)% BIG_PRIME ;
    }
    return dp[i][j]=count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dp : Sequence(Sequence(int));
  static   attribute in1 : Sequence(String);
  static   attribute BIG_PRIME : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     in1 := br.readLine()->characters() ; 
    in2 := br.readLine()->characters() ; 
    dp := Integer.subrange(1,in1->size())->collect(Integer.subrange(1,in2->size())->collect(0)) ; 
    for (i : dp) do ( (     i := i->collect(-1) )  ) ; 
    OclFile["System.out"].println(search(0, 0) mod BIG_PRIME) ; 
 );
  static   operation search( i : int, j : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     if (j = in2->size()) then     return 1 else skip ; 
    if (i = in1->size()) then     return 0 else skip ; 
    if (dp[i+1][j+1] /= -1) then (     return dp[i+1][j+1] ) else     if (in1[i+1] = in2[j+1]) then (     count := search(i + 1, j + 1) mod BIG_PRIME + search(i + 1, j) mod BIG_PRIME ) else (     count := search(i + 1, j) mod BIG_PRIME ) ;  ;  
    return dp[i+1][j+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean checkpossible(int mask,int arr[],int prefix[],int n,int k){
    int i,j ;
    boolean dp[][]=new boolean[n+1][k+1];
    for(i=0 ; i<n+1 ; i++){
      for(j=0 ; j<k+1 ; j++){
        dp[i][j]=false ;
      }
    }
    dp[0][0]=true ;
    for(i=1 ; i<=n ; i++){
      for(j=1 ; j<=k ; j++){
        for(int l=i-1 ; l>=0 ; --l){
          if(dp[l][j-1] &&(((prefix[i]-prefix[l])& mask)==mask)){
            dp[i][j]=true ;
            break ;
          }
        }
      }
    }
    return dp[n][k];
  }
  static int Partition(int arr[],int n,int k){
    int prefix[]=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      prefix[i]=prefix[i-1]+arr[i];
    }
    int LOGS=20 ;
    int ans=0 ;
    for(int i=LOGS ; i>=0 ; --i){
      if(checkpossible(ans |(1<<i),arr,prefix,n,k)){
        ans=ans |(1<<i);
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      0,1,2,7,10,23,21,6,8,7,3 },k=2 ;
      int n=arr.length-1 ;
      System.out.println(Partition(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkpossible( mask : int, arr : Sequence(int), prefix : Sequence(int), n : int, k : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var dp : Sequence(Sequence(boolean)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,k + 1)->collect(false)) ;
        i := 0 ; while i < n + 1 do ( (         j := 0 ; while j < k + 1 do ( (     dp[i+1][j+1] := false )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := true ; 
        i := 1 ; while i <= n do ( (         j := 1 ; while j <= k do ( (         var l : int ; l := i - 1 ; while l >= 0 do ( (     if (dp[l+1][j - 1+1] & (((prefix[i+1] - prefix[l+1]) & mask) = mask)) then (     dp[i+1][j+1] := true ; 
     break ) else skip )  ;     l := l - 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return dp[n+1][k+1] 
 );
  static   operation Partition( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var prefix : Sequence(int) ; prefix := Integer.subrange(1,n + 1)->collect(0) ;
         var i : int ; i := 1 ; while i <= n do ( (     prefix[i+1] := prefix[i - 1+1] + arr[i+1] )  ;     i := i + 1 ) ; 
    var LOGS : int ; LOGS := 20 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := LOGS ; while i >= 0 do ( (     if (checkpossible(MathLib.bitwiseOr(ans,((1*(2->pow(i)))->oclAsType(long))), arr, prefix, n, k)) then (     ans := MathLib.bitwiseOr(ans,((1*(2->pow(i)))->oclAsType(long))) ) else skip )  ;     i := i - 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,1,2,7,10,23,21,6,8,7,3} ;
    var k : int ; k := 2 ;
     var n : int ; n := arr->size() - 1 ;
     OclFile["System.out"].println(Partition(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Gfg1 {
  static int Log2n(int n){
    return(n>1)? 1+Log2n(n/2): 0 ;
  }
  public static void main(String args[]){
    int n=32 ;
    System.out.println(Log2n(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class Gfg1 {
  static   operation Log2n( n : int) : int
  pre: true
  post: true
  activity: (     return if (n > 1) then 1 + Log2n(n / 2) else 0 endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 32 ;
     OclFile["System.out"].println(Log2n(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class TestSubString {
  public static void main(String[] args){
    int n ;
    Map<Integer,Integer>store=new HashMap<Integer,Integer>();
    Scanner scanner=new Scanner(System.in);
    n=scanner.nextInt();
    int[] a=new int[n];
    int[] b=new int[n];
    int[] sort=new int[n];
    int[] count=new int[1000004];
    for(int i=0 ; i<n ; i++){
      a[i]=scanner.nextInt();
      b[i]=scanner.nextInt();
      store.put(a[i],b[i]);
      count[a[i] ]++;
      count[b[i] ]++;
    }
    int[] uniq=new int[2];
    int j=0 ;
    for(int i=0 ; i<count.length ; i++){
      if(count[i]==1)uniq[j++]=i ;
      if(j==2)break ;
    }
    for(int i=0 ; i<a.length ; i++){
      if(a[i]==uniq[0]){
        sort[0]=uniq[0];
        break ;
      }
      else {
        sort[0]=uniq[1];
      }
    }
    sort[1]=store.get(0);
    for(int i=0 ; i<n ; i++){
      if(i<n-2){
        sort[i+2]=store.get(sort[i]);
      }
      System.out.print(sort[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TestSubString {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     var store : Map(int,int) ; store := Map{} ;
    var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := scanner.getCurrent()->toInteger() ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var sort : Sequence(int) ; sort := Integer.subrange(1,n)->collect(0) ;
    var count : Sequence(int) ; count := Integer.subrange(1,1000004)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() ; 
     b[i+1] := scanner.getCurrent()->toInteger() ; 
    store := store->union(Map{a[i+1] |-> b[i+1]}) ; 
    count[a[i+1]+1] := count[a[i+1]+1] + 1 ; 
    count[b[i+1]+1] := count[b[i+1]+1] + 1 ; 
 )  ;     i := i + 1 ) ; 
    var uniq : Sequence(int) ; uniq := Integer.subrange(1,2)->collect(0) ;
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < count->size() do ( (     if (count[i+1] = 1) then      uniq[j+1] := i  ; j := j + 1 ; else skip ; 
     if (j = 2) then     break else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] = uniq[0+1]) then (     sort[0+1] := uniq[0+1] ; 
     break ) else (     sort[0+1] := uniq[1+1] ) )  ;     i := i + 1 ) ; 
    sort[1+1] := store->at(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i < n - 2) then (     sort[i + 2+1] := store->at(sort[i+1]) ) else skip ; 
     OclFile["System.out"].print(sort[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMinimumK(int a[],int n,int s){
    int maximum=a[0];
    for(int i=0 ; i<n ; i++){
      maximum=Math.max(maximum,a[i]);
    }
    int low=1,high=maximum+1 ;
    int ans=high ;
    while(low<=high){
      int mid=(low+high)/2 ;
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        sum+=(int)(a[i]/mid);
      }
      if(sum>s)low=mid+1 ;
      else {
        ans=Math.min(ans,mid);
        high=mid-1 ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int a[]={
      10,7,8,10,12,19 };
      int n=a.length ;
      int s=27 ;
      System.out.println(findMinimumK(a,n,s));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMinimumK( a : Sequence(int), n : int, s : int) : int
  pre: true
  post: true
  activity: (     var maximum : int ; maximum := a[0+1] ;
         var i : int ; i := 0 ; while i < n do ( (     maximum := Set{maximum, a[i+1]}->max() )  ;     i := i + 1 ) ; 
    var low : int ; low := 1 ;
    var high : int ; high := maximum + 1 ;
    var ans : int ; ans := high ;
    while (low <= high) do (     var mid : int ; mid := (low + high) / 2 ;
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+((a[i+1] / mid)->oclAsType(int)) )  ;     i := i + 1 ) ; 
     if (sum > s) then     low := mid + 1 ; else (     ans := Set{ans, mid}->min() ; 
     high := mid - 1 ) ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{10,7,8,10,12,19} ;
     var n : int ; n := a->size() ;
     var s : int ; s := 27 ;
     OclFile["System.out"].println(findMinimumK(a, n, s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static int longOddEvenIncSeq(int arr[],int n){
    int[] lioes=new int[n];
    int maxLen=0 ;
    for(int i=0 ; i<n ; i++)lioes[i]=1 ;
    for(int i=1 ; i<n ; i++)for(int j=0 ; j<i ; j++)if(arr[i]>arr[j] &&(arr[i]+arr[j])% 2!=0 && lioes[i]<lioes[j]+1)lioes[i]=lioes[j]+1 ;
    for(int i=0 ; i<n ; i++)if(maxLen<lioes[i])maxLen=lioes[i];
    return maxLen ;
  }
  public static void main(String argc[]){
    int[] arr=new int[] {
      1,12,2,22,5,30,31,14,17,11 };
      int n=10 ;
      System.out.println("Longest Increasing Odd"+" Even Subsequence: "+longOddEvenIncSeq(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation longOddEvenIncSeq( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var lioes : Sequence(int) ; lioes := Integer.subrange(1,n)->collect(0) ;
     var maxLen : int ; maxLen := 0 ;
        var i : int ; i := 0 ; while i < n do (     lioes[i+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do (         var j : int ; j := 0 ; while j < i do (     if (arr[i+1] > arr[j+1] & (arr[i+1] + arr[j+1]) mod 2 /= 0 & lioes[i+1] < lioes[j+1] + 1) then     lioes[i+1] := lioes[j+1] + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     if (maxLen < lioes[i+1]) then     maxLen := lioes[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    return maxLen 
 );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,12,2,22,5,30,31,14,17,11} ;
     var n : int ; n := 10 ;
     OclFile["System.out"].println("Longest Increasing Odd" + " Even Subsequence: " + longOddEvenIncSeq(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Map.Entry ;
class GFG {
  static int mostFrequent(int arr[],int n){
    Map<Integer,Integer>hp=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      int key=arr[i];
      if(hp.containsKey(key)){
        int freq=hp.get(key);
        freq++;
        hp.put(key,freq);
      }
      else {
        hp.put(key,1);
      }
    }
    int max_count=0,res=-1 ;
    for(Entry<Integer,Integer>val : hp.entrySet()){
      if(max_count<val.getValue()){
        res=val.getKey();
        max_count=val.getValue();
      }
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      1,5,2,1,3,2,1 };
      int n=arr.length ;
      System.out.println(mostFrequent(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation mostFrequent( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var hp : Map(int,int) ; hp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     var key : int ; key := arr[i+1] ;
     if (hp->keys()->includes(key)) then (     var freq : int ; freq := hp->at(key) ;
     freq := freq + 1 ; 
     hp := hp->union(Map{key |-> freq}) ) else (     hp := hp->union(Map{key |-> 1}) ) )  ;     i := i + 1 ) ; 
    var max_count : int ; max_count := 0 ;
    var res : int ; res := -1 ;
    for (val : hp->asSet()) do ( (     if (max_count < val.getValue()) then (     res := val.getKey() ; 
     max_count := val.getValue() ) else skip )  ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,2,1,3,2,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(mostFrequent(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    long M=scanner.nextInt();
    long V=scanner.nextInt();
    int P=scanner.nextInt();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++)A[i]=scanner.nextInt();
    Arrays.sort(A);
    reverse(A);
    long[] cum=new long[N];
    for(int i=1 ; i<N ; i++)cum[i]=cum[i-1]+A[i-1];
    int count=P ;
    for(int i=P ; i<N && A[i]+M>=A[P-1]; i++)if(M*(P-1+N-i)+(i-P+1)*(A[i]+M)-(cum[i]-cum[P-1])>=M*V)count++;
    System.out.println(count);
  }
  private static void reverse(int[] a){
    int i=0 ;
    int j=a.length-1 ;
    while(i<j){
      int tmp=a[i];
      a[i]=a[j];
      a[j]=tmp ;
      i++;
      j--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var M : long ; M := scanner.getCurrent()->toInteger() ;
    var V : long ; V := scanner.getCurrent()->toInteger() ;
    var P : int ; P := scanner.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     A[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    execute reverse(A) ; 
    var cum : Sequence(long) ; cum := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 1 ; while i < N do (     cum[i+1] := cum[i - 1+1] + A[i - 1+1] ;  ;     i := i + 1 ) ; 
    var count : int ; count := P ;
        var i : int ; i := P ; while i < N & A[i+1] + M >= A[P - 1+1] do (     if (M * (P - 1 + N - i) + (i - P + 1) * (A[i+1] + M) - (cum[i+1] - cum[P - 1+1]) >= M * V) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation reverse( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var j : int ; j := a->size() - 1 ;
     while (i < j) do (     var tmp : int ; tmp := a[i+1] ;
     a[i+1] := a[j+1] ; 
    a[j+1] := tmp ; 
    i := i + 1 ; 
    j := j - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class SumOfSeries {
  static int fact(int n){
    if(n==1)return 1 ;
    return n*fact(n-1);
  }
  static double sum(int x,int n){
    double total=1.0 ;
    for(int i=1 ; i<=n ; i++){
      total=total+(Math.pow(x,i)/fact(i+1));
    }
    return total ;
  }
  public static void main(String[] args){
    int x=5,n=4 ;
    System.out.print("Sum is: "+sum(x,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class SumOfSeries {
  static   operation fact( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 1 else skip ; 
     return n * fact(n - 1) );
  static   operation sum( x : int, n : int) : double
  pre: true
  post: true
  activity: (     var total : double ; total := 1.0 ;
         var i : int ; i := 1 ; while i <= n do ( (     total := total + (x->pow(i) / fact(i + 1)) )  ;     i := i + 1 ) ; 
     return total );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 5 ;
    var n : int ; n := 4 ;
     OclFile["System.out"].print("Sum is: " + sum(x, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1543 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      long A=in.nextLong();
      long B=in.nextLong();
      long diff=Math.abs(B-A);
      long max ;
      long steps ;
      if(diff==0){
        max=0 ;
        steps=0 ;
      }
      else {
        max=diff ;
        long rest=A % diff ;
        steps=Math.min(rest,diff-rest);
      }
      System.out.println(max+" "+steps);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1543 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var A : long ; A := in.getCurrent()->toLong() ;
     var B : long ; B := in.getCurrent()->toLong() ;
    var diff : long ; diff := if B - A < 0 then -(B - A) else B - A endif ;
    var max : long ;
    var steps : long ;
    if (diff = 0) then (     max := 0 ; 
     steps := 0 ) else (     max := diff ; 
     var rest : long ; rest := A mod diff ;
     steps := Set{rest, diff - rest}->min() ) ;  
    OclFile["System.out"].println(max + " " + steps) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
import java.io.*;
public class codeHundredSixty {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      long a=input.nextLong();
      long b=input.nextLong();
      if(a==b){
        System.out.println("0 0");
      }
      else {
        long gabe=Math.abs(a-b);
        long tim=Math.min(gabe-a % gabe,a % gabe);
        System.out.println(gabe+" "+tim);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var a : long ; a := input.getCurrent()->toLong() ;
     var b : long ; b := input.getCurrent()->toLong() ;
     if (a = b) then (     OclFile["System.out"].println("0 0") ) else (     var gabe : long ; gabe := if a - b < 0 then -(a - b) else a - b endif ;
     var tim : long ; tim := Set{gabe - a mod gabe, a mod gabe}->min() ;
     OclFile["System.out"].println(gabe + " " + tim) ) )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class prg {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long a=sc.nextLong();
      long b=sc.nextLong();
      long max=Math.max(a,b);
      long min=Math.min(a,b);
      long g=max-min ;
      long r=0 ;
      if(min==g || min==0 || g==0){
        r=0 ;
      }
      else {
        r=Math.min(min,Math.min(g-min % g,min % g));
      }
      System.out.println(g+" "+r);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class prg {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
    var max : long ; max := Set{a, b}->max() ;
    var min : long ; min := Set{a, b}->min() ;
    var g : long ; g := max - min ;
    var r : long ; r := 0 ;
    if (min = g or min = 0 or g = 0) then (     r := 0 ) else (     r := Set{min, Set{g - min mod g, min mod g}->min()}->min() ) ;  
    OclFile["System.out"].println(g + " " + r) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long a=sc.nextLong();
      long b=sc.nextLong();
      if(a==b)System.out.println(0+" "+0);
      else {
        long diff=Math.abs(a-b);
        System.out.print(diff+" ");
        long ans=Math.min(a % diff,diff-a % diff);
        System.out.println(ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
     if (a = b) then     OclFile["System.out"].println(0 + " " + 0) ; else (     var diff : long ; diff := if a - b < 0 then -(a - b) else a - b endif ;
     OclFile["System.out"].print(diff + " ") ; 
     var ans : long ; ans := Set{a mod diff, diff - a mod diff}->min() ;
     OclFile["System.out"].println(ans) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] p=new int[n];
    HashMap<Integer,Integer>hm=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      p[i]=sc.nextInt();
      hm.put(p[i],i);
    }
    sc.close();
    int[] a=new int[n];
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=20000*i+hm.get(i+1)+1 ;
      b[i]=20000*(n-i)+1 ;
    }
    StringBuilder sba=new StringBuilder();
    StringBuilder sbb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      sba.append(a[i]+" ");
      sbb.append(b[i]+" ");
    }
    System.out.println(sba.toString());
    System.out.println(sbb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    var hm : Map(int,int) ; hm := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := sc.getCurrent()->toInteger() ; 
     hm := hm->union(Map{p[i+1] |-> i}) )  ;     i := i + 1 ) ; 
    skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := 20000 * i + hm->at(i + 1) + 1 ; 
     b[i+1] := 20000 * (n - i) + 1 )  ;     i := i + 1 ) ; 
    var sba : String ; sba := StringLib.newString() ;
    var sbb : String ; sbb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     sba := sba + StringLib.newString(a[i+1] + " ") ; 
     sbb := sbb + StringLib.newString(b[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sba+"") ; 
    OclFile["System.out"].println(sbb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    int n=Integer.parseInt(sa[0]);
    sa=br.readLine().split(" ");
    int[] p=new int[n];
    for(int i=0 ; i<n ; i++){
      p[i]=Integer.parseInt(sa[i])-1 ;
    }
    br.close();
    int[] d=new int[n];
    for(int i=0 ; i<n ; i++){
      d[p[i] ]=i ;
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      sb.append(20000*(i+1)+d[i]).append(' ');
    }
    sb.deleteCharAt(sb.length()-1);
    System.out.println(sb.toString());
    sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      sb.append(400000000-20000*i).append(' ');
    }
    sb.deleteCharAt(sb.length()-1);
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var n : int ; n := (sa[0+1])->toInteger() ;
    sa := br.readLine()->split(" ") ; 
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := (sa[i+1])->toInteger() - 1 )  ;     i := i + 1 ) ; 
    skip ; 
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     d[p[i+1]+1] := i )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     sb := sb + StringLib.newString(20000 * (i + 1) + d[i+1]) + StringLib.newString(' ') )  ;     i := i + 1 ) ; 
    sb := sb->excludingAt(sb->size() - 1+1) ; 
    OclFile["System.out"].println(sb+"") ; 
    sb := StringLib.newString() ; 
        var i : int ; i := 0 ; while i < n do ( (     sb := sb + StringLib.newString(400000000 - 20000 * i) + StringLib.newString(' ') )  ;     i := i + 1 ) ; 
    sb := sb->excludingAt(sb->size() - 1+1) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=false ;
  private void solve(Scanner sc,PrintWriter out){
    int N=sc.nextInt();
    int[] p=new int[N];
    for(int i=0 ; i<N ; ++i){
      p[i]=sc.nextInt()-1 ;
    }
    int[] r=new int[N];
    for(int i=0 ; i<N ; ++i){
      r[p[i] ]=i+1 ;
    }
    int[] a=new int[N];
    int[] b=new int[N];
    for(int i=0 ; i<N ; ++i){
      a[i]=N*(i+1);
      b[i]=N*(N-i-1)+r[i];
    }
    for(int i=0 ; i<N ; ++i){
      if(i>0){
        out.print(" ");
      }
      out.print(a[i]);
    }
    out.println();
    for(int i=0 ; i<N ; ++i){
      if(i>0){
        out.print(" ");
      }
      out.print(b[i]);
    }
    out.println();
  }
  public static void main(String[] args){
    long S=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    new Main().solve(sc,out);
    out.flush();
    long G=System.currentTimeMillis();
    if(elapsed){
      System.err.println((G-S)+"ms");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := false;
   operation solve( sc : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.nextInt() ;
     var p : Sequence(int) ; p := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     p[i+1] := sc.nextInt() - 1 )  ;     i := i + 1 ) ; 
    var r : Sequence(int) ; r := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     r[p[i+1]+1] := i + 1 )  ;     i := i + 1 ) ; 
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := N * (i + 1) ; 
     b[i+1] := N * (N - i - 1) + r[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (i > 0) then (     out.print(" ") ) else skip ; 
     out.print(a[i+1]) )  ;     i := i + 1 ) ; 
    out.println() ; 
        var i : int ; i := 0 ; while i < N do ( (     if (i > 0) then (     out.print(" ") ) else skip ; 
     out.print(b[i+1]) )  ;     i := i + 1 ) ; 
    out.println() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    Main.newMain().solve(sc, out) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     OclFile["System.err"].println((G - S) + "ms") ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] $){
    int n=scanner.nextInt();
    int[] a=new int[n];
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=i+1 ;
      b[i]=n-i ;
    }
    for(int i=0 ; i<n ; i++){
      int p=scanner.nextInt()-1 ;
      for(int j=0 ; j<=p ; j++){
        b[j]+=i ;
      }
      for(int j=p ; j<n ; j++){
        a[j]+=i ;
      }
    }
    Arrays.stream(a).forEach(System.out :: println);
    Arrays.stream(b).forEach(System.out :: println);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := i + 1 ; 
     b[i+1] := n - i )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var p : int ; p := scanner.getCurrent()->toInteger() - 1 ;
         var j : int ; j := 0 ; while j <= p do ( (     b[j+1] := b[j+1]+(i) )  ;     j := j + 1 ) ; 
         var j : int ; j := p ; while j < n do ( (     a[j+1] := a[j+1]+(i) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    for _forEach : stream(a) do
    (    skip ;) ; 
    for _forEach : stream(b) do
    (    skip ;) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A500 {
  public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int c=scanner.nextInt();
    int arr[]=new int[n];
    for(int i=1 ; i<n ; i++){
      arr[i]=scanner.nextInt();
      arr[i]+=i ;
    }
    boolean myb=false ;
    for(int cnt=arr[1]; cnt<=n ; cnt=arr[cnt]){
      if(arr[n-1]<c || cnt>c)break ;
      if(cnt==c){
        myb=true ;
        break ;
      }
    }
    System.out.println(myb ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A500 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 1 ; while i < n do ( (     arr[i+1] := scanner.getCurrent()->toInteger() ; 
     arr[i+1] := arr[i+1]+(i) )  ;     i := i + 1 ) ; 
    var myb : boolean ; myb := false ;
        var cnt : int ; cnt := arr[1+1] ; while cnt <= n do ( (     if (arr[n - 1+1] < c or cnt > c) then     break else skip ; 
     if (cnt = c) then (     myb := true ; 
     break ) else skip )  ;     cnt := arr[cnt+1] ) ; 
    OclFile["System.out"].println(if myb then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  private static final int BASE=30000 ;
  private static final int MAX_N=20000 ;
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int[] p=new int[n];
    for(int i=0 ; i<n ; i++){
      p[i]=s.nextInt();
    }
    int[] a=new int[n];
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=1+BASE*i ;
      b[i]=BASE*(n-i);
    }
    for(int i=0 ; i<n ; i++){
      a[p[i]-1]+=i ;
    }
    System.out.print(a[0]);
    for(int i=1 ; i<n ; i++){
      System.out.print(" ");
      System.out.print(a[i]);
    }
    System.out.println();
    System.out.print(b[0]);
    for(int i=1 ; i<n ; i++){
      System.out.print(" ");
      System.out.print(b[i]);
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BASE : int := 30000;
  static    attribute MAX_N : int := 20000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := 1 + BASE * i ; 
     b[i+1] := BASE * (n - i) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[p[i+1] - 1+1] := a[p[i+1] - 1+1]+(i) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(a[0+1]) ; 
        var i : int ; i := 1 ; while i < n do ( (     OclFile["System.out"].print(" ") ; 
     OclFile["System.out"].print(a[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    OclFile["System.out"].print(b[0+1]) ; 
        var i : int ; i := 1 ; while i < n do ( (     OclFile["System.out"].print(" ") ; 
     OclFile["System.out"].print(b[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=100 ;
  static void spiralFill(int m,int n,int a[][]){
    int val=1 ;
    int k=0,l=0 ;
    while(k<m && l<n){
      for(int i=l ; i<n ; ++i){
        a[k][i]=val++;
      }
      k++;
      for(int i=k ; i<m ; ++i){
        a[i][n-1]=val++;
      }
      n--;
      if(k<m){
        for(int i=n-1 ; i>=l ; --i){
          a[m-1][i]=val++;
        }
        m--;
      }
      if(l<n){
        for(int i=m-1 ; i>=k ; --i){
          a[i][l]=val++;
        }
        l++;
      }
    }
  }
  public static void main(String[] args){
    int m=4,n=4 ;
    int a[][]=new int[MAX][MAX];
    spiralFill(m,n,a);
    for(int i=0 ; i<m ; i++){
      for(int j=0 ; j<n ; j++){
        System.out.print(a[i][j]+" ");
      }
      System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100;
  static   operation spiralFill( m : int, n : int, a : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var val : int ; val := 1 ;
     var k : int ; k := 0 ;
    var l : int ; l := 0 ;
     while (k < m & l < n) do (         var i : int ; i := l ; while i < n do ( (      a[k+1][i+1] := val  ; val := val + 1 )  ;     i := i + 1 ) ; 
     k := k + 1 ; 
        var i : int ; i := k ; while i < m do ( (      a[i+1][n - 1+1] := val  ; val := val + 1 )  ;     i := i + 1 ) ; 
    n := n - 1 ; 
    if (k < m) then (         var i : int ; i := n - 1 ; while i >= l do ( (      a[m - 1+1][i+1] := val  ; val := val + 1 )  ;     i := i - 1 ) ; 
     m := m - 1 ) else skip ; 
    if (l < n) then (         var i : int ; i := m - 1 ; while i >= k do ( (      a[i+1][l+1] := val  ; val := val + 1 )  ;     i := i - 1 ) ; 
     l := l + 1 ) else skip ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 4 ;
    var n : int ; n := 4 ;
     var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,MAX)->collect(Integer.subrange(1,MAX)->collect(0)) ;
     execute spiralFill(m, n, a) ; 
         var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j < n do ( (     OclFile["System.out"].print(a[i+1][j+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("") )  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p250 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p250().run());
  }
  private static final long MODULUS=10000000000000000L ;
  public String run(){
    long[] numSubsets=new long[250];
    numSubsets[0]=1 ;
    for(int i=1 ; i<=250250 ; i++){
      int temp=Library.powMod(i,i,250);
      long[] newArray=new long[numSubsets.length];
      for(int j=0 ; j<250 ; j++)newArray[(j+temp)% 250]=(numSubsets[j]+numSubsets[(j+temp)% 250])% MODULUS ;
      numSubsets=newArray ;
    }
    return Long.toString((numSubsets[0]-1+MODULUS)% MODULUS);
  }
}
------------------------------------------------------------
OCL File:
---------
class p250 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p250.newp250().run()) );
  static    attribute MODULUS : long := 10000000000000000L;
   operation run() : String
  pre: true
  post: true
  activity: (     var numSubsets : Sequence(long) ; numSubsets := Integer.subrange(1,250)->collect(0) ;
     numSubsets[0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= 250250 do ( (     var temp : int ; temp := Library.powMod(i, i, 250) ;
     var newArray : Sequence(long) ; newArray := Integer.subrange(1,numSubsets->size())->collect(0) ;
         var j : int ; j := 0 ; while j < 250 do (     newArray[(j + temp) mod 250+1] := (numSubsets[j+1] + numSubsets[(j + temp) mod 250+1]) mod MODULUS ;  ;     j := j + 1 ) ; 
     numSubsets := newArray )  ;     i := i + 1 ) ; 
     return (((numSubsets[0+1] - 1 + MODULUS) mod MODULUS) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int pref[]=new int[10000];
  static int isPerfect(int n){
    int sum=1 ;
    for(int i=2 ; i*i<=n ; i++){
      if(n % i==0){
        if(i*i!=n)sum=sum+i+n/i ;
        else sum=sum+i ;
      }
    }
    if(sum==n && n!=1)return n ;
    return 0 ;
  }
  static void precomputation(){
    for(int i=1 ; i<10000 ; ++i){
      pref[i]=pref[i-1]+isPerfect(i);
    }
  }
  public static void main(String[] args){
    int L=6,R=28 ;
    precomputation();
    System.out.println(pref[R]-pref[L-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute pref : int := Integer.subrange(1,10000)->collect(0);
  static   operation isPerfect( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 1 ;
         var i : int ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     if (i * i /= n) then     sum := sum + i + n / i ; else     sum := sum + i ; ) else skip )  ;     i := i + 1 ) ; 
     if (sum = n & n /= 1) then     return n else skip ; 
     return 0 );
  static   operation precomputation() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < 10000 do ( (     pref[i+1] := pref[i - 1+1] + isPerfect(i) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 6 ;
    var R : int ; R := 28 ;
     execute precomputation() ; 
     OclFile["System.out"].println(pref[R+1] - pref[L - 1+1]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Solution {
  public static void main(String[] args)throws Exception {
    try {
      System.setIn(new FileInputStream("input.txt"));
      System.setOut(new PrintStream(new FileOutputStream("output.txt")));
    }
    catch(Exception e){
      System.err.println("Error");
    }
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    while(t-->0){
      String str=br.readLine();
      boolean f=true ;
      int n=str.length();
      for(int i=0 ; i<n-1 ; i++){
        int sum=str.charAt(i)-'0'+str.charAt(i+1)-'0' ;
        if(sum>9){
          f=false ;
          break ;
        }
      }
      if(f){
        int sum=str.charAt(0)-'0'+str.charAt(1)-'0' ;
        System.out.println(sum+str.substring(2));
      }
      else {
        for(int i=n-2 ; i>=0 ; i--){
          int sum=str.charAt(i)-'0'+str.charAt(i+1)-'0' ;
          if(sum>9){
            System.out.println(str.substring(0,i)+sum+str.substring(i+2));
            break ;
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) )   catch (e : ProgramException) do (     OclFile["System.err"].println("Error") )
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var str : String ; str := br.readLine() ;
     var f : boolean ; f := true ;
    var n : int ; n := str->size() ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var sum : int ; sum := str->at(i+1) - ('0')->char2byte() + str->at(i + 1+1) - ('0')->char2byte() ;
     if (sum > 9) then (     f := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (f) then (     var sum : int ; sum := str->at(0+1) - ('0')->char2byte() + str->at(1+1) - ('0')->char2byte() ;
     OclFile["System.out"].println(sum + str.subrange(2+1,2)) ) else (         var i : int ; i := n - 2 ; while i >= 0 do ( (     var sum : int ; sum := str->at(i+1) - ('0')->char2byte() + str->at(i + 1+1) - ('0')->char2byte() ;
     if (sum > 9) then (     OclFile["System.out"].println(str.subrange(0+1,i) + sum + str.subrange(i + 2+1,i + 2)) ; 
     break ) else skip )  ;     i := i - 1 ) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int t=0 ; t<test ; t++){
      String s=in.next();
      boolean flag=false ;
      int idx=-1 ;
      int summmm=0 ;
      for(int i=s.length()-1 ; i>0 ; i--){
        int sum=s.charAt(i)-'0'+(s.charAt(i-1)-'0');
        summmm=sum ;
        if(sum>9){
          flag=true ;
          summmm=sum ;
          idx=i ;
          break ;
        }
      }
      if(flag){
        pw.println(s.substring(0,idx-1)+""+summmm+""+s.substring(idx+1,s.length()));
      }
      else {
        if(s.length()<=2){
          int a=s.charAt(0)-'0'+s.charAt(1)-'0' ;
          pw.println(a);
        }
        else {
          pw.print(summmm);
          for(int i=2 ; i<s.length(); i++){
            pw.print(s.charAt(i));
          }
          pw.println();
        }
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
  private static boolean isSorted(int[] arr){
    for(int i=1 ; i<arr.length ; i++)if(arr[i]<arr[i-1])return false ;
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < test do ( (     var s : String ; s := in.getCurrent() ;
     var flag : boolean ; flag := false ;
    var idx : int ; idx := -1 ;
    var summmm : int ; summmm := 0 ;
        var i : int ; i := s->size() - 1 ; while i > 0 do ( (     var sum : int ; sum := s->at(i+1) - ('0')->char2byte() + (s->at(i - 1+1) - ('0')->char2byte()) ;
     summmm := sum ; 
     if (sum > 9) then (     flag := true ; 
     summmm := sum ; 
     idx := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    if (flag) then (     skip ) else (     if (s->size() <= 2) then (     var a : int ; a := s->at(0+1) - ('0')->char2byte() + s->at(1+1) - ('0')->char2byte() ;
     skip ) else (     skip ; 
         var i : int ; i := 2 ; while i < s->size() do ( (     skip )  ;     i := i + 1 ) ; 
     skip ) ) ;  
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
  static   operation isSorted( arr : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < arr->size() do (     if (arr[i+1] < arr[i - 1+1]) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  static Scanner in=new Scanner(System.in);
  void solve(){
    int N=in.nextInt();
    int[] s=new int[N];
    int X=0 ;
    for(int i=0 ; i<N ; ++i){
      s[i]=in.nextInt();
      X+=s[i];
    }
    for(int i=0 ; i<N ; ++i){
      double a=0.0 ;
      double b=1.0 ;
      for(int q=0 ; q<100 ; ++q){
        double c=(a+b)/2 ;
        double val=s[i]+c*X ;
        double used=c*X ;
        for(int j=0 ; j<N ; ++j){
          if(i==j)continue ;
          if(s[j]>=val)continue ;
          used+=val-s[j];
        }
        if(used>=X){
          b=c ;
        }
        else {
          a=c ;
        }
      }
      System.out.print(String.format(" %.6f",100*a).replace(",","."));
    }
    System.out.println();
  }
  public static void main(String[] args){
    int T=in.nextInt();
    for(int i=1 ; i<=T ; ++i){
      System.out.print("Case #"+i+":");
      new A().solve();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
     var s : Sequence(int) ; s := Integer.subrange(1,N)->collect(0) ;
    var X : int ; X := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     s[i+1] := in.getCurrent()->toInteger() ; 
     X := X+(s[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var a : double ; a := 0.0 ;
     var b : double ; b := 1.0 ;
         var q : int ; q := 0 ; while q < 100 do ( (     var c : double ; c := (a + b) / 2 ;
     var val : double ; val := s[i+1] + c * X ;
    var used : double ; used := c * X ;
        var j : int ; j := 0 ; while j < N do ( (     if (i = j) then     continue else skip ; 
     if (s[j+1] >= val) then     continue else skip ; 
     used := used+(val - s[j+1]) )  ;     j := j + 1 ) ; 
    if (used >= X) then (     b := c ) else (     a := c ) ;  
 )  ;     q := q + 1 ) ; 
     OclFile["System.out"].print(StringLib.format(" %.6f",Sequence{100 * a}).replace(",", ".")) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := in.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= T do ( (     OclFile["System.out"].print("Case #" + i + ":") ; 
     A.newA().solve() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A implements Runnable {
  private String IFILE="A-large.in" ;
  private Scanner in ;
  private PrintWriter out ;
  public void Run()throws IOException {
    in=new Scanner(new File(IFILE));
    out=new PrintWriter("output.txt");
    int ntest=in.nextInt();
    for(int test=1 ; test<=ntest ; test++){
      out.print("Case #"+test+": ");
      int n=in.nextInt();
      int[] mas=new int[n];
      for(int i=0 ; i<n ; i++)mas[i]=in.nextInt();
      int sum=0 ;
      for(int i=0 ; i<n ; i++)sum+=mas[i];
      double[] f=new double[n];
      for(int i=0 ; i<n ; i++)f[i]=(mas[i]+0.0)/sum ;
      for(int i=0 ; i<n ; i++){
        double min=0.0 ;
        double max=1.0 ;
        while(max-min>1e-14){
          double v=(min+max)/2.0 ;
          double cv=f[i]+v ;
          double q=0.0 ;
          for(int j=0 ; j<n ; j++)if(i!=j)q+=Math.max(cv-f[j],0);
          if(q<1.0-v)min=v ;
          else max=v ;
        }
        out.print(" "+100.0*max);
      }
      out.println();
    }
    in.close();
    out.close();
  }
  public void run(){
    try {
      Run();
    }
    catch(IOException e){
    }
  }
  public static void main(String[] args)throws IOException {
    new A().Run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A implements Runnable {
   attribute IFILE : String := "A-large.in";
   attribute in : OclFile;
   attribute out : OclFile;
   operation Run() : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile(IFILE)) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ; 
    var ntest : int ; ntest := in.getCurrent()->toInteger() ;
        var test : int ; test := 1 ; while test <= ntest do ( (     skip ; 
     var n : int ; n := in.getCurrent()->toInteger() ;
    var mas : Sequence(int) ; mas := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     mas[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (     sum := sum+(mas[i+1]) ;  ;     i := i + 1 ) ; 
    var f : Sequence(double) ; f := Integer.subrange(1,n)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do (     f[i+1] := (mas[i+1] + 0.0) / sum ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var min : double ; min := 0.0 ;
     var max : double ; max := 1.0 ;
     while (max - min > 1e-14) do (     var v : double ; v := (min + max) / 2.0 ;
     var cv : double ; cv := f[i+1] + v ;
    var q : double ; q := 0.0 ;
        var j : int ; j := 0 ; while j < n do (     if (i /= j) then     q := q+(Set{cv - f[j+1], 0}->max()) ; else skip ;  ;     j := j + 1 ) ; 
    if (q < 1.0 - v) then     min := v else     max := v ; ;  
 ) ; 
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     test := test + 1 ) ; 
    skip ; 
    skip ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     execute Run() )   catch (e : IOException) do skip
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     A.newA().Run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round1 ;
import java.io.FileInputStream ;
import java.io.FileNotFoundException ;
import java.io.FileOutputStream ;
public class A {
  public static void main(String[] args)throws FileNotFoundException {
    Kattio io ;
    io=new Kattio(new FileInputStream("src/round1/A-large-0.in"),new FileOutputStream("src/round1/A-large-0.out"));
    int cases=io.getInt();
    for(int i=1 ; i<=cases ; i++){
      io.print("Case #"+i+": ");
      new A().solve(io);
    }
    io.close();
  }
  private void solve(Kattio io){
    int n=io.getInt(),sum=0 ;
    int s[]=new int[n];
    for(int i=0 ; i<n ; i++){
      s[i]=io.getInt();
      sum+=s[i];
    }
    for(int i=0 ; i<n ; i++){
      double lo=0.0,hi=1.0 ;
      for(int j=0 ; j<200 ; j++){
        double x=(lo+hi)/2 ;
        double isc=s[i]+sum*x ;
        double left=1-x ;
        for(int k=0 ; k<n ; k++){
          if(k==i || s[k]>isc)continue ;
          double y=(isc-s[k])/sum ;
          left-=y ;
        }
        if(left<0){
          hi=x ;
        }
        else {
          lo=x ;
        }
      }
      if(i>0){
        io.print(' ');
      }
      io.print(lo*100.0);
    }
    io.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : Kattio ;
     io := Kattio.newKattio(OclFile.newOclFile_Read(OclFile.newOclFile("src/round1/A-large-0.in")), OclFile.newOclFile_Write(OclFile.newOclFile("src/round1/A-large-0.out"))) ; 
    var cases : int ; cases := io.getInt() ;
        var i : int ; i := 1 ; while i <= cases do ( (     io.print("Case #" + i + ": ") ; 
     A.newA().solve(io) )  ;     i := i + 1 ) ; 
    io.close() ; 
 );
   operation solve( io : Kattio) : void
  pre: true
  post: true
  activity: (     var n : int ; n := io.getInt() ;
    var sum : int ; sum := 0 ;
     var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := io.getInt() ; 
     sum := sum+(s[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var lo : double ; lo := 0.0 ;
    var hi : double ; hi := 1.0 ;
         var j : int ; j := 0 ; while j < 200 do ( (     var x : double ; x := (lo + hi) / 2 ;
     var isc : double ; isc := s[i+1] + sum * x ;
    var left : double ; left := 1 - x ;
        var k : int ; k := 0 ; while k < n do ( (     if (k = i or s[k+1] > isc) then     continue else skip ; 
     var y : double ; y := (isc - s[k+1]) / sum ;
     left := left-(y) )  ;     k := k + 1 ) ; 
    if (left < 0) then (     hi := x ) else (     lo := x ) ;  
 )  ;     j := j + 1 ) ; 
     if (i > 0) then (     io.print(' ') ) else skip ; 
     io.print(lo * 100.0) )  ;     i := i + 1 ) ; 
    io.println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.max ;
import java.io.*;
import java.util.*;
public class SafetyInNumbers {
  public static void main(String[] args)throws Throwable {
    Scanner in=new Scanner(new File("safety.in"));
    PrintWriter out=new PrintWriter("safety.out");
    int testCount=Integer.parseInt(in.nextLine().trim());
    for(int i=0 ; i<testCount ; i++){
      out.print("Case #"+(i+1)+":");
      solve(in,out);
    }
    out.close();
  }
  static void solve(Scanner in,PrintWriter out){
    int n=in.nextInt();
    double[] answer=new double[n];
    int sum=0 ;
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
      sum+=a[i];
    }
    for(int i=0 ; i<n ; i++){
      double l=0 ;
      double r=1 ;
      for(int j=0 ; j<100 ; j++){
        double m=(l+r)*.5 ;
        double currentMan=a[i]+m*sum ;
        double all=m ;
        for(int k=0 ; k<n ; k++){
          if(k==i){
            continue ;
          }
          all+=max(0,(currentMan-a[k])/sum);
        }
        if(all>1){
          r=m ;
        }
        else {
          l=m ;
        }
      }
      answer[i]=(l+r)*50 ;
    }
    for(double e : answer){
      out.print(" "+e);
    }
    out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class SafetyInNumbers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("safety.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("safety.out")) ;
    var testCount : int ; testCount := (in.nextLine()->trim())->toInteger() ;
        var i : int ; i := 0 ; while i < testCount do ( (     skip ; 
     execute solve(in, out) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation solve( in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var answer : Sequence(double) ; answer := Integer.subrange(1,n)->collect(0.0) ;
    var sum : int ; sum := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var l : double ; l := 0 ;
     var r : double ; r := 1 ;
         var j : int ; j := 0 ; while j < 100 do ( (     var m : double ; m := (l + r) * .5 ;
     var currentMan : double ; currentMan := a[i+1] + m * sum ;
    var all : double ; all := m ;
        var k : int ; k := 0 ; while k < n do ( (     if (k = i) then (     continue ) else skip ; 
     all := all+(Set{0, (currentMan - a[k+1]) / sum}->max()) )  ;     k := k + 1 ) ; 
    if (all > 1) then (     r := m ) else (     l := m ) ;  
 )  ;     j := j + 1 ) ; 
     answer[i+1] := (l + r) * 50 )  ;     i := i + 1 ) ; 
    for (e : answer) do ( (     skip )  ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class newYearTransportation1000 {
  public static boolean dfs(int currpos,int[] arr,int target){
    if(currpos==target)return true ;
    if(currpos==arr.length+1)return false ;
    boolean teleport=dfs(currpos+arr[currpos-1],arr,target);
    if(teleport)return true ;
    return false ;
  }
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int goal=sc.nextInt();
    int[] arr=new int[n-1];
    for(int i=0 ; i<n-1 ; i++)arr[i]=sc.nextInt();
    boolean isFound=dfs(1,arr,goal);
    if(isFound)System.out.println("YES");
    else System.out.println("NO");
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class newYearTransportation1000 {
  static   operation dfs( currpos : int, arr : Sequence(int), target : int) : boolean
  pre: true
  post: true
  activity: (     if (currpos = target) then     return true else skip ; 
     if (currpos = arr->size() + 1) then     return false else skip ; 
    var teleport : boolean ; teleport := dfs(currpos + arr[currpos - 1+1], arr, target) ;
    if (teleport) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var goal : int ; goal := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n - 1 do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var isFound : boolean ; isFound := dfs(1, arr, goal) ;
    if (isFound) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.text.DecimalFormat ;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class A {
  public static void main(String[] args)throws FileNotFoundException {
    in=new Scanner(new InputStreamReader(new FileInputStream("a_in.txt")));
    out=new PrintStream(new BufferedOutputStream(new FileOutputStream("a_out.txt")));
    int n=in.nextInt();
    in.nextLine();
    int t=1 ;
    while(n-->0)new A().solveProblem(t++);
    out.close();
  }
  static Scanner in=new Scanner(new InputStreamReader(System.in));
  static PrintStream out=new PrintStream(new BufferedOutputStream(System.out));
  public void solveProblem(int nr){
    out.print("Case #"+nr+": ");
    int n=in.nextInt();
    double[] p=new double[n];
    for(int i=0 ; i<n ; i++)p[i]=in.nextInt();
    double som=0 ;
    for(double pp : p)som+=(double)pp ;
    for(int i=0 ; i<n ; i++){
      double lo=0.0 ;
      double hi=1.;
      for(int l=0 ; l<500 ; l++){
        double mid=(lo+hi)/2.0 ;
        double eind=p[i]+mid*som ;
        double tot=mid ;
        for(int j=0 ; j<n ; j++){
          if(i==j)continue ;
          if(p[j]>=eind-eps)continue ;
          tot+=(eind-p[j])/som ;
        }
        if(tot>1.0)hi=mid ;
        else lo=mid ;
      }
      double ou=(100.0*lo);
      if(ou<eps)ou=0.0 ;
      out.print(ou);
      if(i==n-1)out.println();
      else out.print(" ");
    }
    System.err.println("Case #"+nr+" solved");
  }
  double eps=1e-9 ;
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("a_in.txt")))) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("a_out.txt")))) ; 
    var n : int ; n := in.nextInt() ;
    in.nextLine() ; 
    var t : int ; t := 1 ;
        while (n > 0) do (        n := n - 1 ;     skip ;     A.newA().solveProblem(t) ; ;  ) ;  
    out.close() ; 
 );
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
   operation solveProblem( nr : int) : void
  pre: true
  post: true
  activity: (     skip ; 
     var n : int ; n := in.getCurrent()->toInteger() ;
    var p : Sequence(double) ; p := Integer.subrange(1,n)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do (     p[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var som : double ; som := 0 ;
    for (pp : p) do (     som := som+(pp->oclAsType(double)) ;  ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var lo : double ; lo := 0.0 ;
     var hi : double ; hi := 1. ;
        var l : int ; l := 0 ; while l < 500 do ( (     var mid : double ; mid := (lo + hi) / 2.0 ;
     var eind : double ; eind := p[i+1] + mid * som ;
    var tot : double ; tot := mid ;
        var j : int ; j := 0 ; while j < n do ( (     if (i = j) then     continue else skip ; 
     if (p[j+1] >= eind - eps) then     continue else skip ; 
     tot := tot+((eind - p[j+1]) / som) )  ;     j := j + 1 ) ; 
    if (tot > 1.0) then     hi := mid else     lo := mid ; ;  
 )  ;     l := l + 1 ) ; 
    var ou : double ; ou := (100.0 * lo) ;
    if (ou < eps) then     ou := 0.0 ; else skip ; 
    skip ; 
    if (i = n - 1) then     skip else     skip ; ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.err"].println("Case #" + nr + " solved") ; 
 );
   attribute eps : double := 1e-9;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int lds(Integer arr[],int n){
    Integer lds[]=new Integer[n];
    lds[0]=1 ;
    for(int i=1 ; i<n ; i++){
      lds[i]=1 ;
      for(int j=0 ; j<i ; j++)if(lds[j]!=0 && arr[i] % arr[j]==0)lds[i]=Math.max(lds[i],lds[j]+1);
    }
    int max=(int)Collections.max(Arrays.asList(lds));
    return max ;
  }
  public static void main(String args[]){
    Integer arr[]={
      2,11,16,12,36,60,71,17,29,144,288,129,432,993 };
      int n=arr.length ;
      System.out.println("Length of lds is "+lds(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation lds( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var lds : Sequence(int) ; lds := Integer.subrange(1,n)->collect(null) ;
     lds[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < n do ( (     lds[i+1] := 1 ; 
         var j : int ; j := 0 ; while j < i do (     if (lds[j+1] /= 0 & arr[i+1] mod arr[j+1] = 0) then     lds[i+1] := Set{lds[i+1], lds[j+1] + 1}->max() ; else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := .max(lds)->oclAsType(int) ;
    return max 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,11,16,12,36,60,71,17,29,144,288,129,432,993} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Length of lds is " + lds(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n ;
    int d ;
    int l ;
    n=scanner.nextInt();
    d=scanner.nextInt();
    l=scanner.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=d>0 ? l : 1 ;
      d=arr[i]-d ;
    }
    arr[n-1]-=d ;
    if(arr[n-1]<=0 || arr[n-1]>l)System.out.println("-1");
    else for(int i=0 ;
    i<n ;
    i++)System.out.printf("%d ",arr[i]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var d : int ;
    var l : int ;
    n := scanner.getCurrent()->toInteger() ; 
    d := scanner.getCurrent()->toInteger() ; 
    l := scanner.getCurrent()->toInteger() ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := if d > 0 then l else 1 endif ; 
     d := arr[i+1] - d )  ;     i := i + 1 ) ; 
    arr[n - 1+1] := arr[n - 1+1]-(d) ; 
    if (arr[n - 1+1] <= 0 or arr[n - 1+1] > l) then     OclFile["System.out"].println("-1") else         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].printf("%d ", arr[i+1]) ;  ;     i := i + 1 ) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int r0=sc.nextInt();
      int w0=sc.nextInt();
      int c=sc.nextInt();
      int r=sc.nextInt();
      if((r0 | w0 | c | r)==0){
        break ;
      }
      int k=w0*c ;
      int i=0 ;
      while(r0<k){
        i++;
        r0+=r ;
      }
      System.out.println(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var r0 : int ; r0 := sc.getCurrent()->toInteger() ;
     var w0 : int ; w0 := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(MathLib.bitwiseOr(r0,w0),c),r)) = 0) then (     break ) else skip ; 
    var k : int ; k := w0 * c ;
    var i : int ; i := 0 ;
    while (r0 < k) do (     i := i + 1 ; 
     r0 := r0+(r) ) ; 
    OclFile["System.out"].println(i) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class CookingCurry {
  int X=0 ;
  double Y=0.0 ;
  double c0 ;
  void calcXY(int r0,int w0,int C,int R){
    c0=r0/w0 ;
    while(r0/w0<C){
++X ;
      r0+=R ;
    }
    System.out.println(X);
    X=0 ;
  }
}
public class Main {
  public static void main(String[] args)throws IOException {
    CookingCurry cc=new CookingCurry();
    int r0=0 ;
    int w0=0 ;
    int C=0 ;
    int R=0 ;
    double Y=0.0 ;
    String str ;
    String recipe[]=new String[4];
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      str=br.readLine();
      recipe=str.split(" ",0);
      r0=Integer.parseInt(recipe[0]);
      w0=Integer.parseInt(recipe[1]);
      C=Integer.parseInt(recipe[2]);
      R=Integer.parseInt(recipe[3]);
      if(r0==0 && w0==0 && C==0 && R==0){
        break ;
      }
      cc.calcXY(r0,w0,C,R);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CookingCurry {
   attribute X : int := 0;
   attribute Y : double := 0.0;
   attribute c0 : double;
   operation calcXY( r0 : int, w0 : int, C : int, R : int) : void
  pre: true
  post: true
  activity: (     c0 := r0 / w0 ; 
     while (r0 / w0 < C) do (     X := X + 1 ; 
     r0 := r0+(R) ) ; 
     OclFile["System.out"].println(X) ; 
     X := 0 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cc : CookingCurry ; cc := CookingCurry.newCookingCurry() ;
     var r0 : int ; r0 := 0 ;
    var w0 : int ; w0 := 0 ;
    var C : int ; C := 0 ;
    var R : int ; R := 0 ;
    var Y : double ; Y := 0.0 ;
    var str : String ;
    var recipe : Sequence(String) ; recipe := Integer.subrange(1,4)->collect(null) ;
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    while (true) do (     str := br.readLine() ; 
     recipe := str->split(" ") ; 
    r0 := (recipe[0+1])->toInteger() ; 
    w0 := (recipe[1+1])->toInteger() ; 
    C := (recipe[2+1])->toInteger() ; 
    R := (recipe[3+1])->toInteger() ; 
    if (r0 = 0 & w0 = 0 & C = 0 & R = 0) then (     break ) else skip ; 
    cc.calcXY(r0, w0, C, R) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static boolean solve(){
    int ri=in.nextInt();
    int wi=in.nextInt();
    int c=in.nextInt();
    int r=in.nextInt();
    if(ri+wi+c+r==0)return false ;
    int l=-1,u=1<<30 ;
    while(u-l>1){
      int m=(l+u)/2 ;
      if(ri+(long)m*r>=(long)wi*c)u=m ;
      else l=m ;
    }
    out.println(u);
    return true ;
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    while(solve());
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : boolean
  pre: true
  post: true
  activity: (     var ri : int ; ri := in.getCurrent()->toInteger() ;
     var wi : int ; wi := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var r : int ; r := in.getCurrent()->toInteger() ;
    if (ri + wi + c + r = 0) then     return false else skip ; 
    var l : int ; l := -1 ;
    var u : int ; u := (1*(2->pow(30)))->oclAsType(long) ;
    while (u - l > 1) do (     var m : int ; m := (l + u) / 2 ;
     if (ri + m->oclAsType(long) * r >= wi->oclAsType(long) * c) then     u := m ; else     l := m ; ) ; 
    skip ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    while (solve()) do  ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Spliterator ;
import java.util.Spliterators ;
import java.util.concurrent.ThreadLocalRandom ;
import java.util.concurrent.atomic.AtomicInteger ;
import java.util.stream.IntStream ;
import java.util.stream.Stream ;
import java.util.stream.StreamSupport ;
public class Main {
  static final Scanner s=new Scanner(System.in);
  static long[] fal_rnd(int size){
    AtomicInteger l=new AtomicInteger(-1),r=new AtomicInteger(size);
    long[] res=new long[size];
    INS(size).unordered().parallel().mapToLong(Long :: parseLong).forEach(v->res[ThreadLocalRandom.current().nextBoolean()? l.incrementAndGet(): r.decrementAndGet()]=v);
    return res ;
  }
  static IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static Stream<String>INS(long size){
    return StreamSupport.stream(Spliterators.spliterator(s,size,Spliterator.NONNULL & Spliterator.IMMUTABLE),false).limit(size);
  }
  public static void main(String[] __){
    long r0,w,c,r ;
    while(true){
      r0=s.nextInt();
      w=s.nextInt();
      c=s.nextInt();
      r=s.nextInt();
      if(r0+w+c+r==0)return ;
      int res=0 ;
      while((r0+res*r)/w<c){
        res++;
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation fal_rnd( size : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var l : int ; l := (-1) ;
    var r : int ; r := (size) ;
     var res : Sequence(long) ; res := Integer.subrange(1,size)->collect(0) ;
     for v : INS(size)->collect( _x1 | (lambda _s : String in _s->toLong())->apply(_x1) ) do
    (    res[if MathLib.nextBoolean() then l+1 else r-1 endif+1] := v) ; 
     return res );
  static   operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static   operation INS( size : long) : Stream<String>
  pre: true
  post: true
  activity: (     return (OclIterator.newOclIterator_Sequence(s)).elements.subrange(1,size) );
  static   operation main( __ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r0 : long ;
    var w : long ;
    var c : long ;
    var r : long ;
     while (true) do (     r0 := s.getCurrent()->toInteger() ; 
     w := s.getCurrent()->toInteger() ; 
    c := s.getCurrent()->toInteger() ; 
    r := s.getCurrent()->toInteger() ; 
    if (r0 + w + c + r = 0) then     return else skip ; 
    var res : int ; res := 0 ;
    while ((r0 + res * r) / w < c) do (     res := res + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CurryMaking solver=new CurryMaking();
    solver.solve(1,in,out);
    out.close();
  }
  static class CurryMaking {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int r0=in.nextInt(),w0=in.nextInt(),c=in.nextInt(),r=in.nextInt();
      while(r0!=0 && w0!=0 && c!=0 && r!=0){
        int ans=0 ;
        while(r0<c*w0){
          r0+=r ;
          ans++;
        }
        out.println(ans);
        r0=in.nextInt();
        w0=in.nextInt();
        c=in.nextInt();
        r=in.nextInt();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CurryMaking ; solver := CurryMaking.newCurryMaking() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CurryMaking {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var r0 : int ; r0 := in.getCurrent()->toInteger() ;
    var w0 : int ; w0 := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var r : int ; r := in.getCurrent()->toInteger() ;
     while (r0 /= 0 & w0 /= 0 & c /= 0 & r /= 0) do (     var ans : int ; ans := 0 ;
     while (r0 < c * w0) do (     r0 := r0+(r) ; 
     ans := ans + 1 ) ; 
    skip ; 
    r0 := in.getCurrent()->toInteger() ; 
    w0 := in.getCurrent()->toInteger() ; 
    c := in.getCurrent()->toInteger() ; 
    r := in.getCurrent()->toInteger() ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class BornThisWay {
  static int bn(long[] a,long key){
    int l=0 ;
    int r=a.length-1 ;
    int res=0 ;
    while(l<=r){
      int mid=(l+r)/2 ;
      if(a[mid]<=key){
        l=mid+1 ;
        if(a[mid]==key){
--mid ;
        }
        res=Math.max(res,mid);
      }
      else {
        r=mid-1 ;
      }
    }
    return res ;
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    long t1=scan.nextInt();
    long t2=scan.nextInt();
    int k=scan.nextInt();
    long[] a=new long[n+1];
    long[] b=new long[m+1];
    for(int i=0 ; i<n ; i++){
      a[i]=scan.nextInt()+t1 ;
    }
    b[0]=0 ;
    for(int i=1 ; i<=m ; i++){
      b[i]=scan.nextInt();
    }
    if(n<=k || m<=k){
      System.out.println("-1");
      return ;
    }
    int res=0 ;
    for(int i=0 ; i<=Math.min(n,k); i++){
      int ind=bn(b,a[i]);
      int p=k-(i+1);
      res=Math.max(res,ind+p);
    }
    try {
      System.out.println(b[res+2]+t2);
    }
    catch(Exception e){
      System.out.println("-1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BornThisWay {
  static   operation bn( a : Sequence(long), key : long) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
     var r : int ; r := a->size() - 1 ;
    var res : int ; res := 0 ;
    while (l <= r) do (     var mid : int ; mid := (l + r) / 2 ;
     if (a[mid+1] <= key) then (     l := mid + 1 ; 
     if (a[mid+1] = key) then (     mid := mid - 1 ) else skip ; 
     res := Set{res, mid}->max() ) else (     r := mid - 1 ) ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var t1 : long ; t1 := scan.getCurrent()->toInteger() ;
    var t2 : long ; t2 := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,m + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() + t1 )  ;     i := i + 1 ) ; 
    b[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= m do ( (     b[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (n <= k or m <= k) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i <= Set{n, k}->min() do ( (     var ind : int ; ind := bn(b, a[i+1]) ;
     var p : int ; p := k - (i + 1) ;
     res := Set{res, ind + p}->max() )  ;     i := i + 1 ) ; 
    try (     OclFile["System.out"].println(b[res + 2+1] + t2) )   catch (e : ProgramException) do (     OclFile["System.out"].println("-1") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findMissing(int a[],int b[],int n,int m){
    for(int i=0 ; i<n ; i++){
      int j ;
      for(j=0 ; j<m ; j++)if(a[i]==b[j])break ;
      if(j==m)System.out.print(a[i]+" ");
    }
  }
  public static void main(String[] args){
    int a[]={
      1,2,6,3,4,5 };
      int b[]={
        2,4,3,1,0 };
        int n=a.length ;
        int m=b.length ;
        findMissing(a,b,n,m);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMissing( a : Sequence(int), b : Sequence(int), n : int, m : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var j : int ;
         j := 0 ; while j < m do (     if (a[i+1] = b[j+1]) then     break else skip ;  ;     j := j + 1 ) ; 
     if (j = m) then     OclFile["System.out"].print(a[i+1] + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,6,3,4,5} ;
     var b : Sequence(int) ; b := Sequence{2,4,3,1,0} ;
    var n : int ; n := a->size() ;
    var m : int ; m := b->size() ;
    execute findMissing(a, b, n, m) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class demo1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    int res=1 ;
    int s=0 ;
    for(int i=1 ; i<n ; i++){
      int x=sc.nextInt();
      if(res==i){
        res+=x ;
        if(res==t){
          s=1 ;
          break ;
        }
      }
    }
    System.out.println(s==1 ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class demo1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var res : int ; res := 1 ;
    var s : int ; s := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (res = i) then (     res := res+(x) ; 
     if (res = t) then (     s := 1 ; 
     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if s = 1 then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    int min=Integer.MAX_VALUE ;
    for(int i=n ; i>=1 ; i--){
      int[] y=new int[4];
      int[] x=new int[4];
      int[][] map=new int[(n/i)+((n % i!=0)? 1 : 0)][i];
      int nowx=0 ;
      int nowy=0 ;
      for(int j=0 ; j<n ; j++){
        if(j+1==a){
          y[0]=nowy ;
          x[0]=nowx ;
        }
        if(j+1==b){
          y[1]=nowy ;
          x[1]=nowx ;
        }
        if(j+1==c){
          y[2]=nowy ;
          x[2]=nowx ;
        }
        if(j+1==d){
          y[3]=nowy ;
          x[3]=nowx ;
        }
        nowx++;
        if(nowx==i){
          nowx=0 ;
          nowy=nowy+1 ;
        }
      }
      min=Math.min(min,Math.abs(x[0]-x[1])+Math.abs(y[0]-y[1])+Math.abs(x[2]-x[3])+Math.abs(y[2]-y[3]));
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := n ; while i >= 1 do ( (     var y : Sequence(int) ; y := Integer.subrange(1,4)->collect(0) ;
     var x : Sequence(int) ; x := Integer.subrange(1,4)->collect(0) ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,(n / i) + (if (n mod i /= 0) then 1 else 0 endif))->collect(Integer.subrange(1,i)->collect(0)) ;
    var nowx : int ; nowx := 0 ;
    var nowy : int ; nowy := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     if (j + 1 = a) then (     y[0+1] := nowy ; 
     x[0+1] := nowx ) else skip ; 
     if (j + 1 = b) then (     y[1+1] := nowy ; 
     x[1+1] := nowx ) else skip ; 
    if (j + 1 = c) then (     y[2+1] := nowy ; 
     x[2+1] := nowx ) else skip ; 
    if (j + 1 = d) then (     y[3+1] := nowy ; 
     x[3+1] := nowx ) else skip ; 
    nowx := nowx + 1 ; 
    if (nowx = i) then (     nowx := 0 ; 
     nowy := nowy + 1 ) else skip ; 
 )  ;     j := j + 1 ) ; 
    min := Set{min, if x[0+1] - x[1+1] < 0 then -(x[0+1] - x[1+1]) else x[0+1] - x[1+1] endif + if y[0+1] - y[1+1] < 0 then -(y[0+1] - y[1+1]) else y[0+1] - y[1+1] endif + if x[2+1] - x[3+1] < 0 then -(x[2+1] - x[3+1]) else x[2+1] - x[3+1] endif + if y[2+1] - y[3+1] < 0 then -(y[2+1] - y[3+1]) else y[2+1] - y[3+1] endif}->min() ; 
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,i,j,tmp ;
    int[] a=new int[4];
    int[] d=new int[4];
    n=sc.nextInt();
    for(i=0 ; i<4 ; i++)a[i]=sc.nextInt()-1 ;
    int min=100000 ;
    for(i=1 ; i<=n ; i++){
      for(j=0 ; j<4 ; j+=2){
        d[j]=a[j]/i-a[j+1]/i ;
        d[j+1]=a[j] % i-a[j+1] % i ;
      }
      for(j=0 ; j<4 ; j++)if(d[j]<0)d[j]*=-1 ;
      if(min>d[0]+d[1]+d[2]+d[3])min=d[0]+d[1]+d[2]+d[3];
    }
    out.println(min);
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var i : int ;
    var j : int ;
    var tmp : int ;
    var a : Sequence(int) ; a := Integer.subrange(1,4)->collect(0) ;
    var d : Sequence(int) ; d := Integer.subrange(1,4)->collect(0) ;
    n := sc.nextInt() ; 
        i := 0 ; while i < 4 do (     a[i+1] := sc.nextInt() - 1 ;  ;     i := i + 1 ) ; 
    var min : int ; min := 100000 ;
        i := 1 ; while i <= n do ( (         j := 0 ; while j < 4 do ( (     d[j+1] := a[j+1] / i - a[j + 1+1] / i ; 
     d[j + 1+1] := a[j+1] mod i - a[j + 1+1] mod i )  ;     j := j+(2) ) ; 
         j := 0 ; while j < 4 do (     if (d[j+1] < 0) then     d[j+1] := d[j+1]*(-1) ; else skip ;  ;     j := j + 1 ) ; 
     if (min > d[0+1] + d[1+1] + d[2+1] + d[3+1]) then     min := d[0+1] + d[1+1] + d[2+1] + d[3+1] ; else skip )  ;     i := i + 1 ) ; 
    out.println(min) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.geom.*;
public class Main {
  double EPS=1.0e-08 ;
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int[][] data=new int[2][2];
      for(int i=0 ; i<2 ; i++){
        for(int j=0 ; j<2 ; j++){
          data[i][j]=sc.nextInt()-1 ;
        }
      }
      int min=1<<24 ;
      for(int i=1 ; i<=n ; i++){
        int sum=0 ;
        for(int j=0 ; j<2 ; j++){
          int pos1=data[j][0];
          int x1=pos1 % i ;
          int y1=pos1/i ;
          int pos2=data[j][1];
          int x2=pos2 % i ;
          int y2=pos2/i ;
          sum+=Math.abs(x1-x2)+Math.abs(y1-y2);
        }
        min=Math.min(min,sum);
      }
      System.out.println(min);
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute EPS : double := 1.0e-08;
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var data : Sequence(Sequence(int)) ; data := Integer.subrange(1,2)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < 2 do ( (         var j : int ; j := 0 ; while j < 2 do ( (     data[i+1][j+1] := sc.getCurrent()->toInteger() - 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var min : int ; min := (1*(2->pow(24)))->oclAsType(long) ;
        var i : int ; i := 1 ; while i <= n do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < 2 do ( (     var pos1 : int ; pos1 := data[j+1][0+1] ;
     var x1 : int ; x1 := pos1 mod i ;
    var y1 : int ; y1 := pos1 / i ;
    var pos2 : int ; pos2 := data[j+1][1+1] ;
    var x2 : int ; x2 := pos2 mod i ;
    var y2 : int ; y2 := pos2 / i ;
    sum := sum+(if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif + if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif) ; 
 )  ;     j := j + 1 ) ; 
     min := Set{min, sum}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class magicwizard {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int d=sc.nextInt();
    int le=sc.nextInt();
    int m[]=new int[100];
    for(int i=0 ; i<n-1 ; i++){
      m[i]=d>0 ? le : 1 ;
      d=m[i]-d ;
    }
    m[n-1]=d ;
    if(m[n-1]>le || m[n-1]<1){
      System.out.println(-1);
    }
    else {
      for(int i=0 ; i<n ; i++){
        System.out.print(m[i]+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class magicwizard {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var le : int ; le := sc.getCurrent()->toInteger() ;
    var m : Sequence(int) ; m := Integer.subrange(1,100)->collect(0) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     m[i+1] := if d > 0 then le else 1 endif ; 
     d := m[i+1] - d )  ;     i := i + 1 ) ; 
    m[n - 1+1] := d ; 
    if (m[n - 1+1] > le or m[n - 1+1] < 1) then (     OclFile["System.out"].println(-1) ) else (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(m[i+1] + " ") )  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int n,a,b,c,d ;
    n=parseInt(br.readLine());
    line=br.readLine();
    a=parseInt(line.substring(0,line.indexOf(' ')));
    b=parseInt(line.substring(line.indexOf(' ')+1));
    line=br.readLine();
    c=parseInt(line.substring(0,line.indexOf(' ')));
    d=parseInt(line.substring(line.indexOf(' ')+1));
    int min=Integer.MAX_VALUE ;
    for(int w=1 ; w<=n ; w++){
      int[] pa=new int[] {
(a-1)% w,(a-1)/w };
        int[] pb=new int[] {
(b-1)% w,(b-1)/w };
          int[] pc=new int[] {
(c-1)% w,(c-1)/w };
            int[] pd=new int[] {
(d-1)% w,(d-1)/w };
              int _min=0 ;
              _min+=Math.abs(pa[0]-pb[0]);
              _min+=Math.abs(pa[1]-pb[1]);
              _min+=Math.abs(pc[0]-pd[0]);
              _min+=Math.abs(pc[1]-pd[1]);
              min=Math.min(min,_min);
            }
            System.out.println(min);
          }
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var n : int ;
    var a : int ;
    var b : int ;
    var c : int ;
    var d : int ;
    n := (br.readLine() + "")->toInteger() ; 
    line := br.readLine() ; 
    a := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    b := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    line := br.readLine() ; 
    c := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    d := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var min : int ; min := 2147483647 ;
        var w : int ; w := 1 ; while w <= n do ( (     var pa : Sequence(int) ; pa := Sequence{(a - 1) mod w,(a - 1) / w} ;
     var pb : Sequence(int) ; pb := Sequence{(b - 1) mod w,(b - 1) / w} ;
    var pc : Sequence(int) ; pc := Sequence{(c - 1) mod w,(c - 1) / w} ;
    var pd : Sequence(int) ; pd := Sequence{(d - 1) mod w,(d - 1) / w} ;
    var _min : int ; _min := 0 ;
    _min := _min+(if pa[0+1] - pb[0+1] < 0 then -(pa[0+1] - pb[0+1]) else pa[0+1] - pb[0+1] endif) ; 
    _min := _min+(if pa[1+1] - pb[1+1] < 0 then -(pa[1+1] - pb[1+1]) else pa[1+1] - pb[1+1] endif) ; 
    _min := _min+(if pc[0+1] - pd[0+1] < 0 then -(pc[0+1] - pd[0+1]) else pc[0+1] - pd[0+1] endif) ; 
    _min := _min+(if pc[1+1] - pd[1+1] < 0 then -(pc[1+1] - pd[1+1]) else pc[1+1] - pd[1+1] endif) ; 
    min := Set{min, _min}->min() ; 
 )  ;     w := w + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean checkEquality(String s){
    return(s.charAt(0)==s.charAt(s.length()-1));
  }
  static int countSubstringWithEqualEnds(String s){
    int result=0 ;
    int n=s.length();
    for(int i=0 ; i<n ; i++)for(int len=1 ; len<=n-i ; len++)if(checkEquality(s.substring(i,i+len)))result++;
    return result ;
  }
  public static void main(String args[]){
    String s="abcab" ;
    System.out.println(countSubstringWithEqualEnds(s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkEquality( s : String) : boolean
  pre: true
  post: true
  activity: (     return (s->at(0+1) = s->at(s->size() - 1+1)) );
  static   operation countSubstringWithEqualEnds( s : String) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var n : int ; n := s->size() ;
         var i : int ; i := 0 ; while i < n do (         var len : int ; len := 1 ; while len <= n - i do (     if (checkEquality(s.subrange(i+1,i + len))) then     result := result + 1 ; else skip ;  ;     len := len + 1 ) ;  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abcab" ;
     OclFile["System.out"].println(countSubstringWithEqualEnds(s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class b351 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int ar[]=new int[n];
    for(int i=0 ; i<n ; i++){
      ar[i]=in.nextInt();
    }
    int inversions=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i-1 ; j>=0 ; j--){
        if(ar[i]<ar[j])inversions++;
        mxInv++;
      }
    }
    int turn=0,ans=0 ;
    while(inversions!=0){
      if(turn==0){
        ans++;
        inversions--;
      }
      else {
        if(inversions==mxInv){
          inversions--;
          ans++;
        }
        else {
          inversions--;
          ans+=3 ;
        }
      }
      turn ^=1 ;
    }
    System.out.println(ans);
  }
  static int mxInv=0 ;
}
------------------------------------------------------------
OCL File:
---------
 class b351 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var inversions : int ; inversions := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i - 1 ; while j >= 0 do ( (     if (ar[i+1] < ar[j+1]) then     inversions := inversions + 1 ; else skip ; 
     mxInv := mxInv + 1 )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    var turn : int ; turn := 0 ;
    var ans : int ; ans := 0 ;
    while (inversions /= 0) do (     if (turn = 0) then (     ans := ans + 1 ; 
     inversions := inversions - 1 ) else (     if (inversions = mxInv) then (     inversions := inversions - 1 ; 
     ans := ans + 1 ) else (     inversions := inversions - 1 ; 
     ans := ans+(3) ) ) ;  
     turn := MathLib.bitwiseXor(turn,1) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   attribute mxInv : int := 0;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(reader.readLine());
    int[] arr=new int[n];
    StringTokenizer sToken=new StringTokenizer(reader.readLine());
    int inversions=0 ;
    for(int i=0 ; i<n ; i++){
      int x=Integer.parseInt(sToken.nextToken());
      arr[i]=x ;
      for(int j=0 ; j<i ; j++){
        if(arr[i]<arr[j])inversions++;
      }
    }
    if(inversions % 2==0)System.out.println(inversions*2+".000000");
    else System.out.println(inversions*2-1+".000000");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (reader.readLine())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sToken : OclIterator ; sToken := OclIterator.newOclIterator_String(reader.readLine()) ;
    var inversions : int ; inversions := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := (sToken.next())->toInteger() ;
     arr[i+1] := x ; 
         var j : int ; j := 0 ; while j < i do ( (     if (arr[i+1] < arr[j+1]) then     inversions := inversions + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (inversions mod 2 = 0) then     OclFile["System.out"].println(inversions * 2 + ".000000") else     OclFile["System.out"].println(inversions * 2 - 1 + ".000000") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    int ans=0 ;
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s=br.readLine();
    int n=Integer.parseInt(s);
    String line=br.readLine();
    String[] strings=line.trim().split(" ");
    int[] p=new int[3005];
    for(int i=0 ; i<n ; i++){
      p[i]=Integer.parseInt(strings[i]);
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<i ; j++){
        if(p[i]<p[j]){
          ans++;
        }
      }
    }
    if(ans % 2==0){
      ans=2*ans ;
    }
    else {
      ans=2*ans-1 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var s : String ; s := br.readLine() ;
    var n : int ; n := (s)->toInteger() ;
    var line : String ; line := br.readLine() ;
    var strings : Sequence(String) ; strings := line->trim()->split(" ") ;
    var p : Sequence(int) ; p := Integer.subrange(1,3005)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := (strings[i+1])->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < i do ( (     if (p[i+1] < p[j+1]) then (     ans := ans + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (ans mod 2 = 0) then (     ans := 2 * ans ) else (     ans := 2 * ans - 1 ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    int N=parseInt(br.readLine());
    int[] a=new int[N];
    StringTokenizer st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<N ; i++){
      a[i]=parseInt(st.nextToken());
    }
    int[] indeg=new int[N];
    boolean[] used=new boolean[N];
    for(int i=0 ; i<N ; i++){
      indeg[(i+a[i])% N]++;
    }
    for(int i=0 ; i<N ; i++){
      int j=i ;
      while(! used[j] && indeg[j]==0){
        used[j]=true ;
        j=(j+a[j])% N ;
        indeg[j]--;
      }
    }
    System.out.println(Arrays.stream(indeg).filter(x->x!=0).count());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var N : int ; N := parseInt(br.readLine()) ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := (st.next() + "")->toInteger() )  ;     i := i + 1 ) ; 
    var indeg : Sequence(int) ; indeg := Integer.subrange(1,N)->collect(0) ;
    var used : Sequence(boolean) ; used := Integer.subrange(1,N)->collect(false) ;
        var i : int ; i := 0 ; while i < N do ( (     indeg[(i + a[i+1]) mod N+1] := indeg[(i + a[i+1]) mod N+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var j : int ; j := i ;
     while (not(used[j+1]) & indeg[j+1] = 0) do (     used[j+1] := true ; 
     j := (j + a[j+1]) mod N ; 
     indeg[j+1] := indeg[j+1] - 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(stream(indeg)->select( _x1 | (lambda x : OclAny in x /= 0)->apply(_x1) )->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1304A_TwoRabbits {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      int x=input.nextInt();
      int y=input.nextInt();
      int a=input.nextInt();
      int b=input.nextInt();
      input.nextLine();
      final int result=(y-x)%(a+b);
      if(result==0){
        System.out.println((y-x)/(a+b));
      }
      else {
        System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1304A_TwoRabbits {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var x : int ; x := input.getCurrent()->toInteger() ;
     var y : int ; y := input.getCurrent()->toInteger() ;
    var a : int ; a := input.getCurrent()->toInteger() ;
    var b : int ; b := input.getCurrent()->toInteger() ;
    skip ; 
    var result : int ; result := (y - x) mod (a + b) ;
    if (result = 0) then (     OclFile["System.out"].println((y - x) / (a + b)) ) else (     OclFile["System.out"].println(-1) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TwoRabbits {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      int a=sc.nextInt();
      int b=sc.nextInt();
      if((y-x)%(a+b)==0){
        System.out.println((y-x)/(a+b));
      }
      else System.out.println("-1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TwoRabbits {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    if ((y - x) mod (a + b) = 0) then (     OclFile["System.out"].println((y - x) / (a + b)) ) else     OclFile["System.out"].println("-1") ; ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_Two_Rabbits {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int x=sc.nextInt();
      int y=sc.nextInt();
      int a=sc.nextInt();
      int b=sc.nextInt();
      System.out.println(solve(x,y,a,b));
    }
    sc.close();
  }
  static int solve(int x,int y,int a,int b){
    return((y-x)%(a+b)==0)?((y-x)/(a+b)):-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Two_Rabbits {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(solve(x, y, a, b)) ; 
 )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( x : int, y : int, a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if ((y - x) mod (a + b) = 0) then ((y - x) / (a + b)) else -1 endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test284 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int x=in.nextInt();
      int y=in.nextInt();
      int a=in.nextInt();
      int b=in.nextInt();
      if((y-x)%(b+a)==0){
        System.out.println((y-x)/(b+a));
      }
      else {
        System.out.println(-1);
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test284 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var y : int ; y := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    if ((y - x) mod (b + a) = 0) then (     OclFile["System.out"].println((y - x) / (b + a)) ) else (     OclFile["System.out"].println(-1) ) ;  
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class prg {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int x=sc.nextInt();
      int y=sc.nextInt();
      System.out.println(1+" "+1+" "+n+" "+m);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class prg {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(1 + " " + 1 + " " + n + " " + m) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BadBoy {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int count=scanner.nextInt();
    for(int k=0 ; k<count ; k++){
      int n=scanner.nextInt();
      int m=scanner.nextInt();
      int i=scanner.nextInt();
      int j=scanner.nextInt();
      if((i==1 && j==1)||(i==n && j==m)){
        System.out.println("1 "+m+" "+n+" 1");
      }
      else {
        System.out.println("1  1 "+n+" "+m);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BadBoy {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := scanner.getCurrent()->toInteger() ;
         var k : int ; k := 0 ; while k < count do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
    var i : int ; i := scanner.getCurrent()->toInteger() ;
    var j : int ; j := scanner.getCurrent()->toInteger() ;
    if ((i = 1 & j = 1) or (i = n & j = m)) then (     OclFile["System.out"].println("1 " + m + " " + n + " 1") ) else (     OclFile["System.out"].println("1  1 " + n + " " + m) ) ;  
 )  ;     k := k + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.List ;
import java.util.ArrayList ;
public class Bad_Boy {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int tests=scanner.nextInt();
    int[][] arr ;
    int farY=0,farX=0 ;
    for(int i=0 ; i<tests ; i++){
      int n=scanner.nextInt();
      int m=scanner.nextInt();
      int posY=scanner.nextInt();
      int posX=scanner.nextInt();
      System.out.println("1 1 "+n+" "+m);
    }
  }
  static void sort(int[] arrInput){
    List<Integer>list=new ArrayList<Integer>();
    for(int i : arrInput){
      list.add(i);
    }
    Collections.sort(list);
    for(int i=0 ; i<arrInput.length ; i++){
      arrInput[i]=list.get(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Bad_Boy {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tests : int ; tests := scanner.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ;
    var farY : int ; farY := 0 ;
    var farX : int ; farX := 0 ;
        var i : int ; i := 0 ; while i < tests do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
    var posY : int ; posY := scanner.getCurrent()->toInteger() ;
    var posX : int ; posX := scanner.getCurrent()->toInteger() ;
    OclFile["System.out"].println("1 1 " + n + " " + m) ; 
 )  ;     i := i + 1 ) ; 
 );
  static   operation sort( arrInput : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     for (i : arrInput) do ( (     list := list->including(i) )  ) ; 
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < arrInput->size() do ( (     arrInput[i+1] := list->at(i+1) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.Set ;
public class Codeforces {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int t=1 ;
    t=sc.nextInt();
    while(t-->0){
      solve();
    }
  }
  private static void solve(){
    int m=sc.nextInt();
    int n=sc.nextInt();
    int i=sc.nextInt();
    int j=sc.nextInt();
    if((i==1 && j==1)||(i==m && j==n)){
      System.out.println(1+" "+n+" "+m+" "+1);
    }
    else {
      System.out.println(1+" "+1+" "+m+" "+n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
     t := sc.getCurrent()->toInteger() ; 
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var m : int ; m := sc.getCurrent()->toInteger() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var i : int ; i := sc.getCurrent()->toInteger() ;
    var j : int ; j := sc.getCurrent()->toInteger() ;
    if ((i = 1 & j = 1) or (i = m & j = n)) then (     OclFile["System.out"].println(1 + " " + n + " " + m + " " + 1) ) else (     OclFile["System.out"].println(1 + " " + 1 + " " + m + " " + n) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public final class Test {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt(),m=sc.nextInt(),i=sc.nextInt(),j=sc.nextInt();
      int d1=Math.abs(1-i)+Math.abs(1-j),d2=Math.abs(1-i)+Math.abs(m-j),d3=Math.abs(n-i)+Math.abs(1-j),d4=Math.abs(n-i)+Math.abs(j-m);
      if(Math.max(d1,d2)>=Math.max(d3,d4)){
        if(d1>=d2){
          System.out.print("1 1 ");
          if(i==n && j==m)System.out.println(1+" "+m);
          else {
            System.out.println(n+" "+m);
          }
        }
        else {
          System.out.print("1 "+m);
          if(i==n && j==1){
            System.out.println(" "+n+" "+m);
          }
          else System.out.println(" "+n+" 1");
        }
      }
      else {
        if(d3>=d4){
          System.out.print(n+" 1 ");
          if(i==1 && j==m){
            System.out.println(n+" "+m);
          }
          else {
            System.out.println("1 "+m);
          }
        }
        else {
          System.out.print(n+" "+m);
          if(i==1 && j==1){
            System.out.println(" 1 "+m);
          }
          else {
            System.out.println(" 1 1");
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var i : int ; i := sc.getCurrent()->toInteger() ;
    var j : int ; j := sc.getCurrent()->toInteger() ;
     var d1 : int ; d1 := if 1 - i < 0 then -(1 - i) else 1 - i endif + if 1 - j < 0 then -(1 - j) else 1 - j endif ;
    var d2 : int ; d2 := if 1 - i < 0 then -(1 - i) else 1 - i endif + if m - j < 0 then -(m - j) else m - j endif ;
    var d3 : int ; d3 := if n - i < 0 then -(n - i) else n - i endif + if 1 - j < 0 then -(1 - j) else 1 - j endif ;
    var d4 : int ; d4 := if n - i < 0 then -(n - i) else n - i endif + if j - m < 0 then -(j - m) else j - m endif ;
     if (Set{d1, d2}->max() >= Set{d3, d4}->max()) then (     if (d1 >= d2) then (     OclFile["System.out"].print("1 1 ") ; 
     if (i = n & j = m) then     OclFile["System.out"].println(1 + " " + m) ; else (     OclFile["System.out"].println(n + " " + m) ) ) else (     OclFile["System.out"].print("1 " + m) ; 
     if (i = n & j = 1) then (     OclFile["System.out"].println(" " + n + " " + m) ) else     OclFile["System.out"].println(" " + n + " 1") ; ) ) else (     if (d3 >= d4) then (     OclFile["System.out"].print(n + " 1 ") ; 
     if (i = 1 & j = m) then (     OclFile["System.out"].println(n + " " + m) ) else (     OclFile["System.out"].println("1 " + m) ) ) else (     OclFile["System.out"].print(n + " " + m) ; 
     if (i = 1 & j = 1) then (     OclFile["System.out"].println(" 1 " + m) ) else (     OclFile["System.out"].println(" 1 1") ) ) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int z=sc.nextInt();
    int w=sc.nextInt();
    List<Integer>a=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      a.add(sc.nextInt());
    }
    if(n==1){
      System.out.println(Math.abs(w-a.get(0)));
      return ;
    }
    int ans1=Math.abs(a.get(n-2)-a.get(n-1));
    int ans2=Math.abs(w-a.get(n-1));
    System.out.println(Math.max(ans1,ans2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var z : int ; z := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     a := a->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    if (n = 1) then (     OclFile["System.out"].println(if w - a->at(0+1) < 0 then -(w - a->at(0+1)) else w - a->at(0+1) endif) ; 
     return ) else skip ; 
    var ans1 : int ; ans1 := if a->at(n - 2+1) - a->at(n - 1+1) < 0 then -(a->at(n - 2+1) - a->at(n - 1+1)) else a->at(n - 2+1) - a->at(n - 1+1) endif ;
    var ans2 : int ; ans2 := if w - a->at(n - 1+1) < 0 then -(w - a->at(n - 1+1)) else w - a->at(n - 1+1) endif ;
    OclFile["System.out"].println(Set{ans1, ans2}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a=sc.nextLong();
    long b=sc.nextLong();
    long ans=func(a-1)^ func(b);
    System.out.println(ans);
    sc.close();
  }
  public static long func(long n){
    if(n<=0)return 0 ;
    if(n % 2==0){
      return n ^(n % 4==0 ? 0 : 1);
    }
    else {
      return(n+1)% 4==0 ? 0 : 1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var ans : long ; ans := MathLib.bitwiseXor(func(a - 1),func(b)) ;
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
  static   operation func( n : long) : long
  pre: true
  post: true
  activity: (     if (n <= 0) then     return 0 else skip ; 
     if (n mod 2 = 0) then (     return n xor (if n mod 4 = 0 then 0 else 1 endif) ) else (     return if (n + 1) mod 4 = 0 then 0 else 1 endif ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long a=Long.parseLong(scanner.next());
    long b=Long.parseLong(scanner.next());
    scanner.close();
    long count=0 ;
    long sum=(b-a+1)/2 ;
    if((b-a+1)% 2!=0)sum+=a % 2 ;
    if(sum % 2!=0)count+=1 ;
    for(long i=2 ; i<b*2 ; i*=2){
      long c=0 ;
      long r1=a %(i*2);
      if(r1>=i)c+=(i*2)-r1 ;
      long r2=b %(i*2);
      if(r2>=i)c+=r2-(i*2-1);
      if(c % 2!=0){
        count+=i ;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := (scanner.getCurrent())->toLong() ;
    var b : long ; b := (scanner.getCurrent())->toLong() ;
    skip ; 
    var count : long ; count := 0 ;
    var sum : long ; sum := (b - a + 1) / 2 ;
    if ((b - a + 1) mod 2 /= 0) then     sum := sum+(a mod 2) ; else skip ; 
    if (sum mod 2 /= 0) then     count := count+(1) ; else skip ; 
        var i : long ; i := 2 ; while i < b * 2 do ( (     var c : long ; c := 0 ;
     var r1 : long ; r1 := a mod (i * 2) ;
    if (r1 >= i) then     c := c+((i * 2) - r1) ; else skip ; 
    var r2 : long ; r2 := b mod (i * 2) ;
    if (r2 >= i) then     c := c+(r2 - (i * 2 - 1)) ; else skip ; 
    if (c mod 2 /= 0) then (     count := count+(i) ) else skip ; 
 )  ;     i := i*(2) ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str[]=br.readLine().split(" ");
    long a=Long.parseLong(str[0]);
    long b=Long.parseLong(str[1]);
    System.out.println(f(a-1)^ f(b));
  }
  static long f(long n){
    if(n<0){
      return 0 ;
    }
    if(n % 4==0){
      return n ;
    }
    else if(n % 4==1){
      return 1 ;
    }
    else if(n % 4==2){
      return 1 ^ n ;
    }
    else {
      return 0 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var a : long ; a := (str[0+1])->toLong() ;
    var b : long ; b := (str[1+1])->toLong() ;
    OclFile["System.out"].println(f((a)->char2byte() - 1) xor f(b)) ; 
 );
  static   operation f( n : long) : long
  pre: true
  post: true
  activity: (     if (n < 0) then (     return 0 ) else skip ; 
     if (n mod 4 = 0) then (     return n ) else     if (n mod 4 = 1) then (     return 1 ) else     if (n mod 4 = 2) then (     return MathLib.bitwiseXor(1,n) ) else (     return 0 ) ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static final long x=62L ;
  public static final long one=1L ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    final long a=scanner.nextLong();
    final long b=scanner.nextLong();
    final long n=b-a+1 ;
    long result=0 ;
    for(int i=0 ; i<x ; i++){
      long T=one<<i+1 ;
      long ra=a % T ;
      long r=n % T ;
      if(i==0){
        long ones=calcOnes(T,ra,r);
        ones+=n/T ;
        result=result ^((ones % 2)<<i);
        continue ;
      }
      long ones=calcOnes(T,ra,r);
      result ^=((ones % 2)<<i);
    }
    System.out.println(result);
    scanner.close();
  }
  public static long calcOnes(long T,long ra,long r){
    long zero2ra=Math.max(0,ra-T/2);
    long zero2raPr ;
    if(r+ra>T){
      zero2raPr=T/2+Math.max(0,(r+ra-T)-T/2);
    }
    else {
      zero2raPr=Math.max(0,ra+r-T/2);
    }
    long ones=zero2raPr-zero2ra ;
    return ones ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute x : long := 62L;
  static    attribute one : long := 1L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := scanner.getCurrent()->toLong() ;
    var b : long ; b := scanner.getCurrent()->toLong() ;
    var n : long ; n := b - a + 1 ;
    var result : long ; result := 0 ;
        var i : int ; i := 0 ; while i < x do ( (     var T : long ; T := (one*(2->pow(i + 1)))->oclAsType(long) ;
     var ra : long ; ra := a mod T ;
    var r : long ; r := n mod T ;
    if (i = 0) then (     var ones : long ; ones := calcOnes(T, ra, r) ;
     ones := ones+(n / T) ; 
     result := MathLib.bitwiseXor(result,(((ones mod 2)*(2->pow(i)))->oclAsType(long))) ; 
     continue ) else skip ; 
    var ones : long ; ones := calcOnes(T, ra, r) ;
    result := MathLib.bitwiseXor(result,(((ones mod 2)*(2->pow(i)))->oclAsType(long))) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
    skip ; 
 );
  static   operation calcOnes( T : long, ra : long, r : long) : long
  pre: true
  post: true
  activity: (     var zero2ra : long ; zero2ra := Set{0, ra - T / 2}->max() ;
     var zero2raPr : long ;
    if (r + ra > T) then (     zero2raPr := T / 2 + Set{0, (r + ra - T) - T / 2}->max() ) else (     zero2raPr := Set{0, ra + r - T / 2}->max() ) ;  
    var ones : long ; ones := zero2raPr - zero2ra ;
    return ones 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    long A=gl();
    long B=gl();
    long a=f(A-1);
    long b=f(B);
    System.out.print(a ^ b);
  }
  public static long f(long n){
    if(n<=0)return 0 ;
    if(n==1)return 1 ;
    if(n==2)return 3 ;
    if(n==3)return 0 ;
    long i=2 ;
    while(i<=n){
      i=i*2 ;
    }
    i=i/2 ;
    long ret=0 ;
    if((n-i)% 2==0){
      ret+=i ;
    }
    ret=ret+f(n-i);
    return ret ;
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var A : long ; A := gl() ;
    var B : long ; B := gl() ;
    var a : long ; a := f(A - 1) ;
    var b : long ; b := f(B) ;
    OclFile["System.out"].print(MathLib.bitwiseXor(a,b)) ; 
 );
  static   operation f( n : long) : long
  pre: true
  post: true
  activity: (     if (n <= 0) then     return 0 else skip ; 
     if (n = 1) then     return 1 else skip ; 
    if (n = 2) then     return 3 else skip ; 
    if (n = 3) then     return 0 else skip ; 
    var i : long ; i := 2 ;
    while (i <= n) do (     i := i * 2 ) ; 
    i := i / 2 ; 
    var ret : long ; ret := 0 ;
    if ((n - i) mod 2 = 0) then (     ret := ret+(i) ) else skip ; 
    ret := ret + f(n - i) ; 
    return ret 
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int findEqualPoint(int arr[],int n){
    int distArr[]=new int[n];
    int i=0,di=0 ;
    while(i<n){
      distArr[di++]=i++;
      while(i<n && arr[i]==arr[i-1])i++;
    }
    return(di & 1)!=0 ? distArr[di>>1] :-1 ;
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3,4,4,5,6,6,6,7 };
      int index=findEqualPoint(arr,arr.length);
      System.out.println(index!=-1 ? "Equal Point="+arr[index] : "Equal Point does not exists");
    }
  }

------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation findEqualPoint( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var distArr : Sequence(int) ; distArr := Integer.subrange(1,n)->collect(0) ;
     var i : int ; i := 0 ;
    var di : int ; di := 0 ;
     while (i < n) do (       distArr[di+1] := i  ; di := di + 1  ; i := i + 1 ; 
     while (i < n & arr[i+1] = arr[i - 1+1]) do     i := i + 1 ; ) ; 
     return if (MathLib.bitwiseAnd(di,1)) /= 0 then distArr[(di/(2->pow(1)))->oclAsType(long)+1] else -1 endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,4,5,6,6,6,7} ;
     var index : int ; index := findEqualPoint(arr, arr->size()) ;
     OclFile["System.out"].println(if index /= -1 then "Equal Point=" + arr[index+1] else "Equal Point does not exists" endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isMember(int a,int d,int x){
    if(d==0)return(x==a);
    return((x-a)% d==0 &&(x-a)/d>=0);
  }
  public static void main(String args[]){
    int a=1,x=7,d=3 ;
    if(isMember(a,d,x))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isMember( a : int, d : int, x : int) : boolean
  pre: true
  post: true
  activity: (     if (d = 0) then     return (x = a) else skip ; 
     return ((x - a) mod d = 0 & (x - a) / d >= 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 1 ;
    var x : int ; x := 7 ;
    var d : int ; d := 3 ;
     if (isMember(a, d, x)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    long ans=0 ;
    long[] max=new long[4];
    long[] min=new long[4];
    for(int i=0 ; i<4 ; i++){
      max[i]=Long.MIN_VALUE ;
      min[i]=Long.MAX_VALUE ;
    }
    for(int i=0 ; i<n ; i++){
      long x=scanner.nextLong();
      long y=scanner.nextLong();
      for(int j=0 ; j<4 ; j++){
        long tmp_x=(j>>1)==1 ?-x : x ;
        long tmp_y=(j & 1)==1 ?-y : y ;
        long tmp=tmp_x+tmp_y ;
        min[j]=Math.min(min[j],tmp);
        max[j]=Math.max(max[j],tmp);
        ans=Math.max(ans,max[j]-min[j]);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var ans : long ; ans := 0 ;
    var max : Sequence(long) ; max := Integer.subrange(1,4)->collect(0) ;
    var min : Sequence(long) ; min := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     max[i+1] := "-9223372036854775808"->toLong() ; 
     min[i+1] := "9223372036854775807"->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : long ; x := scanner.getCurrent()->toLong() ;
     var y : long ; y := scanner.getCurrent()->toLong() ;
         var j : int ; j := 0 ; while j < 4 do ( (     var tmp_x : long ; tmp_x := if ((j/(2->pow(1)))->oclAsType(long)) = 1 then -x else x endif ;
     var tmp_y : long ; tmp_y := if (MathLib.bitwiseAnd(j,1)) = 1 then -y else y endif ;
    var tmp : long ; tmp := tmp_x + tmp_y ;
    min[j+1] := Set{min[j+1], tmp}->min() ; 
    max[j+1] := Set{max[j+1], tmp}->max() ; 
    ans := Set{ans, max[j+1] - min[j+1]}->max() ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] x=new int[n];
    int[] y=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=sc.nextInt();
      y[i]=sc.nextInt();
    }
    long result=0 ;
    long[] A=new long[n];
    long[] B=new long[n];
    for(int i=0 ; i<n ; i++){
      A[i]=x[i]-y[i];
      B[i]=x[i]+y[i];
    }
    Arrays.sort(A);
    Arrays.sort(B);
    result=max(A[n-1]-A[0],B[n-1]-B[0]);
    System.out.println(result);
  }
  public static class Scanner {
    private BufferedReader br ;
    private StringTokenizer tok ;
    public Scanner(InputStream is)throws IOException {
      br=new BufferedReader(new InputStreamReader(is));
    }
    private void getLine()throws IOException {
      while(! hasNext())tok=new StringTokenizer(br.readLine());
    }
    private boolean hasNext(){
      return tok!=null && tok.hasMoreTokens();
    }
    public String next()throws IOException {
      getLine();
      return tok.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     y[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var result : long ; result := 0 ;
    var A : Sequence(long) ; A := Integer.subrange(1,n)->collect(0) ;
    var B : Sequence(long) ; B := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := x[i+1] - y[i+1] ; 
     B[i+1] := x[i+1] + y[i+1] )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    B := B->sort() ; 
    result := Set{A[n - 1+1] - A[0+1], B[n - 1+1] - B[0+1]}->max() ; 
    OclFile["System.out"].println(result) ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute tok : OclIterator;
   static operation newScanner( is : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
   operation getLine() : void
  pre: true
  post: true
  activity: (     while (not(hasNext())) do     tok := OclIterator.newOclIterator_String(br.readLine()) ; );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return tok /= null & tok.hasNext() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute getLine() ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int[] x=new int[n];
    int[] y=new int[n];
    for(int i=0 ; i<n ; i++){
      String[] sa=br.readLine().split(" ");
      int a=Integer.parseInt(sa[0]);
      int b=Integer.parseInt(sa[1]);
      x[i]=a+b ;
      y[i]=a-b ;
    }
    br.close();
    Arrays.sort(x);
    Arrays.sort(y);
    System.out.println(Math.max(x[n-1]-x[0],y[n-1]-y[0]));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
     var a : int ; a := (sa[0+1])->toInteger() ;
    var b : int ; b := (sa[1+1])->toInteger() ;
    x[i+1] := a + b ; 
    y[i+1] := a - b ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    x := x->sort() ; 
    y := y->sort() ; 
    OclFile["System.out"].println(Set{x[n - 1+1] - x[0+1], y[n - 1+1] - y[0+1]}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    int N=parseInt(br.readLine());
    int[] a=new int[N];
    StringTokenizer st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<N ; i++){
      a[i]=parseInt(st.nextToken());
    }
    int[] indeg=new int[N];
    boolean[] used=new boolean[N];
    for(int i=0 ; i<N ; i++){
      indeg[(i+a[i])% N]++;
    }
    for(int i=0 ; i<N ; i++){
      int j=i ;
      while(! used[j] && indeg[j]==0){
        used[j]=true ;
        j=(j+a[j])% N ;
        indeg[j]--;
      }
    }
    int count=0 ;
    for(int i=0 ; i<N ; i++){
      if(indeg[i]!=0)count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var N : int ; N := parseInt(br.readLine()) ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := (st.next() + "")->toInteger() )  ;     i := i + 1 ) ; 
    var indeg : Sequence(int) ; indeg := Integer.subrange(1,N)->collect(0) ;
    var used : Sequence(boolean) ; used := Integer.subrange(1,N)->collect(false) ;
        var i : int ; i := 0 ; while i < N do ( (     indeg[(i + a[i+1]) mod N+1] := indeg[(i + a[i+1]) mod N+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var j : int ; j := i ;
     while (not(used[j+1]) & indeg[j+1] = 0) do (     used[j+1] := true ; 
     j := (j + a[j+1]) mod N ; 
     indeg[j+1] := indeg[j+1] - 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (indeg[i+1] /= 0) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc ;
  public static void main(String[] args){
    new Main().execute();
  }
  public void execute(){
    this.sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[][] points=new int[n][4];
    int maxi_2=-1 ;
    int mini_2=-1 ;
    int maxi_3=-1 ;
    int mini_3=-1 ;
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      points[i][0]=x ;
      points[i][1]=y ;
      points[i][2]=x+y ;
      points[i][3]=x-y ;
      if(maxi_2==-1 || points[maxi_2][2]<points[i][2]){
        maxi_2=i ;
      }
      if(maxi_3==-1 || points[maxi_3][3]<points[i][3]){
        maxi_3=i ;
      }
      if(mini_2==-1 || points[mini_2][2]>points[i][2]){
        mini_2=i ;
      }
      if(mini_3==-1 || points[mini_3][3]>points[i][3]){
        mini_3=i ;
      }
    }
    int a=(points[maxi_2][2]-points[mini_2][2]);
    int b=(points[maxi_3][3]-points[mini_3][3]);
    System.out.println(a<b ? b : a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().execute() );
   operation execute() : void
  pre: true
  post: true
  activity: (     self.sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var points : Sequence(Sequence(int)) ; points := Integer.subrange(1,n)->collect(Integer.subrange(1,4)->collect(0)) ;
    var maxi-1 : int ; maxi-1 := -1 ;
    var mini-1 : int ; mini-1 := -1 ;
    var maxi_3 : int ; maxi_3 := -1 ;
    var mini_3 : int ; mini_3 := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    points[i+1][0+1] := x ; 
    points[i+1][1+1] := y ; 
    points[i+1][2+1] := x + y ; 
    points[i+1][3+1] := x - y ; 
    if (maxi-1 = -1 or points[maxi2+1][2+1] < points[i+1][2+1]) then (     maxii := i ) else skip ; 
    if (maxi_3 = -1 or points[maxi_3+1][3+1] < points[i+1][3+1]) then (     maxi_3 := i ) else skip ; 
    if (mini-1 = -1 or points[mini2+1][2+1] > points[i+1][2+1]) then (     minii := i ) else skip ; 
    if (mini_3 = -1 or points[mini_3+1][3+1] > points[i+1][3+1]) then (     mini_3 := i ) else skip ; 
 )  ;     i := i + 1 ) ; 
    var a : int ; a := (points[maximaxi2+1][2+1] - points[minimini2+1][2+1]) ;
    var b : int ; b := (points[maxi_3+1][3+1] - points[mini_3+1][3+1]) ;
    OclFile["System.out"].println(if a < b then b else a endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  long MOD=1000000000+7 ;
  private void slove(){
    int n=sc.nextInt();
    long[][] a=new long[n][2];
    for(int i=0 ; i<n ; i++){
      a[i][0]=sc.nextLong();
      a[i][1]=sc.nextLong();
    }
    long ans=Long.MIN_VALUE ;
    for(int k=0 ; k<(1<<2); k++){
      long mi=Long.MAX_VALUE ;
      long ma=Long.MIN_VALUE ;
      for(int i=0 ; i<n ; i++){
        long tmp=0 ;
        for(int j=0 ; j<2 ; j++)if((k &(1<<j))>0)tmp+=a[i][j];
        else tmp-=a[i][j];
        ma=Math.max(ma,tmp);
        mi=Math.min(mi,tmp);
      }
      ans=Math.max(ans,ma-mi);
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    new Main().slove();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute MOD : long := 1000000000 + 7;
   operation slove() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(Sequence(long)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1][0+1] := sc.getCurrent()->toLong() ; 
     a[i+1][1+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := "-9223372036854775808"->toLong() ;
        var k : int ; k := 0 ; while k < ((1*(2->pow(2)))->oclAsType(long)) do ( (     var mi : long ; mi := "9223372036854775807"->toLong() ;
     var ma : long ; ma := "-9223372036854775808"->toLong() ;
         var i : int ; i := 0 ; while i < n do ( (     var tmp : long ; tmp := 0 ;
         var j : int ; j := 0 ; while j < 2 do (     if ((MathLib.bitwiseAnd(k,((1*(2->pow(j)))->oclAsType(long)))) > 0) then     tmp := tmp+(a[i+1][j+1]) else     tmp := tmp-(a[i+1][j+1]) ; ;   ;     j := j + 1 ) ; 
     ma := Set{ma, tmp}->max() ; 
     mi := Set{mi, tmp}->min() )  ;     i := i + 1 ) ; 
     ans := Set{ans, ma - mi}->max() )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().slove() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] hs=new int[n+1];
      for(int i=0 ; i<=n ; i++){
        hs[i]=sc.nextInt();
      }
      for(int i=0 ; i<=n ; i++){
        int d=0 ;
        if(i<2)d=hs[i+2]-hs[i+1];
        else {
          d=hs[i-1]-hs[i-2];
        }
        boolean flag=true ;
        for(int j=0 ; j<n ; j++){
          int dd=0 ;
          if(j==i)if(j!=0)dd=hs[j+1]-hs[j-1];
          else continue ;
          else if(j+1==i){
            continue ;
          }
          else dd=hs[j+1]-hs[j];
          if(dd!=d){
            flag=false ;
            break ;
          }
        }
        if(flag){
          System.out.println(hs[i]);
          i=n+1 ;
        }
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var hs : Sequence(int) ; hs := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i <= n do ( (     hs[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= n do ( (     var d : int ; d := 0 ;
     if (i < 2) then     d := hs[i + 2+1] - hs[i + 1+1] else (     d := hs[i - 1+1] - hs[i - 2+1] ) ;  
    var flag : boolean ; flag := true ;
        var j : int ; j := 0 ; while j < n do ( (     var dd : int ; dd := 0 ;
     if (j = i) then     if (j /= 0) then     dd := hs[j + 1+1] - hs[j - 1+1] ; else     continue else     if (j + 1 = i) then (     continue ) else     dd := hs[j + 1+1] - hs[j+1] ; ;  ;  
     if (dd /= d) then (     flag := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (flag) then (     OclFile["System.out"].println(hs[i+1]) ; 
     i := n + 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    int n,growth ;
    while(!(line=br.readLine()).equals("0")){
      n=Integer.parseInt(line);
      line=br.readLine();
      growth=getGrowthRate(line);
      System.out.println(find(n,growth,line));
    }
  }
  static int getGrowthRate(String progression){
    int h1,h2,result=0 ;
    int[] g=new int[4];
    StringTokenizer st=new StringTokenizer(progression);
    h1=Integer.parseInt(st.nextToken());
    for(int i=0 ; i<4 ; i++){
      h2=Integer.parseInt(st.nextToken());
      g[i]=h2-h1 ;
      h1=h2 ;
    }
    Arrays.sort(g);
    for(int i=0 ; i<3 ; i++){
      if(g[i]==g[i+1])result=g[i];
    }
    return result ;
  }
  static int find(int n,int growth,String progression){
    int h0,h1,h2,result=0 ;
    StringTokenizer st=new StringTokenizer(progression);
    h1=Integer.parseInt(st.nextToken());
    for(int i=0 ; i<n ; i++){
      h2=Integer.parseInt(st.nextToken());
      if(h1+growth!=h2){
        if(i==n-1){
          result=h2 ;
          break ;
        }
        h0=h1 ;
        h1=h2 ;
        h2=Integer.parseInt(st.nextToken());
        if(h1+growth!=h2){
          result=h1 ;
          break ;
        }
        else {
          result=h0 ;
          break ;
        }
      }
      else {
        h1=h2 ;
      }
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
     var n : int ;
    var growth : int ;
     while (not((line) = "0")) do (     n := (line)->toInteger() ; 
     line := br.readLine() ; 
     growth := getGrowthRate(line) ; 
     OclFile["System.out"].println(find(n, growth, line)) ) );
  static   operation getGrowthRate( progression : String) : int
  pre: true
  post: true
  activity: (     var h1 : int ;
    var h2 : int ;
    var result : int ; result := 0 ;
     var g : Sequence(int) ; g := Integer.subrange(1,4)->collect(0) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(progression) ;
    h1 := (st.next())->toInteger() ; 
        var i : int ; i := 0 ; while i < 4 do ( (     h2 := (st.next())->toInteger() ; 
     g[i+1] := h2 - h1 ; 
     h1 := h2 )  ;     i := i + 1 ) ; 
    g := g->sort() ; 
        var i : int ; i := 0 ; while i < 3 do ( (     if (g[i+1] = g[i + 1+1]) then     result := g[i+1] ; else skip )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation find( n : int, growth : int, progression : String) : int
  pre: true
  post: true
  activity: (     var h0 : int ;
    var h1 : int ;
    var h2 : int ;
    var result : int ; result := 0 ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(progression) ;
    h1 := (st.next())->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     h2 := (st.next())->toInteger() ; 
     if (h1 + growth /= h2) then (     if (i = (n)->char2byte() - 1) then (     result := h2 ; 
     break ) else skip ; 
     h0 := h1 ; 
    h1 := h2 ; 
    h2 := (st.next())->toInteger() ; 
    if (h1 + growth /= h2) then (     result := h1 ; 
     break ) else (     result := h0 ; 
     break ) ;  
 ) else (     h1 := h2 ) )  ;     i := i + 1 ) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  int ni(){
    return sc.nextInt();
  }
  final int INF=1<<30 ;
  int solve(int h[],int n){
    for(int skip=0 ; skip<=n ; ++skip){
      int diff=INF,dh=INF,prev=INF ;
      boolean ac=true ;
      for(int i=0 ; i<=n ; ++i){
        if(i==skip)continue ;
        if(prev!=INF){
          if(diff==INF){
            diff=prev-h[i];
          }
          else {
            dh=prev-h[i];
            if(dh!=diff){
              ac=false ;
              break ;
            }
          }
        }
        prev=h[i];
      }
      if(ac)return h[skip];
    }
    return-1 ;
  }
  void io(){
    int n ;
    sc=new Scanner(System.in);
    while((n=ni())!=0){
      int h[]=new int[n+1];
      for(int i=0 ; i<n+1 ; ++i){
        h[i]=ni();
      }
      System.out.println(solve(h,n));
    }
    sc.close();
  }
  public static void main(String[] args){
    new Main().io();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
   attribute INF : int := (1*(2->pow(30)))->oclAsType(long);
   operation solve( h : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (         var skip : int ; skip := 0 ; while skip <= n do ( (     var diff : int ; diff := INF ;
    var dh : int ; dh := INF ;
    var prev : int ; prev := INF ;
     var ac : boolean ; ac := true ;
         var i : int ; i := 0 ; while i <= n do ( (     if (i = skip) then     continue else skip ; 
     if (prev /= INF) then (     if (diff = INF) then (     diff := prev - h[i+1] ) else (     dh := prev - h[i+1] ; 
     if (dh /= diff) then (     ac := false ; 
     break ) else skip ) ) else skip ; 
     prev := h[i+1] )  ;     i := i + 1 ) ; 
     if (ac) then     return h[skip+1] else skip )  ;     skip := skip + 1 ) ; 
     return -1 );
   operation io() : void
  pre: true
  post: true
  activity: (     var n : int ;
     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
         n := ni() ;
    while ((n) /= 0) do (    skip ; (     var h : Sequence(int) ; h := Integer.subrange(1,n + 1)->collect(0) ;
         var i : int ; i := 0 ; while i < n + 1 do ( (     h[i+1] := ni() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(solve(h, n)) ) ;     n := ni() ;
 ) ;  
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().io() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class WeirdSubtractionProcess {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long a=in.nextLong(),b=in.nextLong();
    while(true){
      if(a==0 || b==0)break ;
      if(a>=2*b){
        a=a %(2*b);
        continue ;
      }
      if(b>=2*a){
        b=b %(2*a);
        continue ;
      }
      break ;
    }
    pw.println(a+" "+b);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class WeirdSubtractionProcess {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : long ; a := in.getCurrent()->toLong() ;
    var b : long ; b := in.getCurrent()->toLong() ;
    while (true) do (     if (a = 0 or b = 0) then     break else skip ; 
     if (a >= 2 * b) then (     a := a mod (2 * b) ; 
     continue ) else skip ; 
     if (b >= 2 * a) then (     b := b mod (2 * a) ; 
     continue ) else skip ; 
     break ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      int N[]=new int[n+1];
      for(int i=0 ; i<n+1 ; i++){
        N[i]=sc.nextInt();
      }
      bi : for(int i=0 ;
      i<n+1 ;
      i++){
        List<Integer>tousa=new ArrayList<Integer>();
        for(int p=0 ; p<n+1 ; p++){
          tousa.add(N[p]);
        }
        tousa.remove(i);
        for(int p=0 ; p<n-2 ; p++){
          if(tousa.get(p)-tousa.get(p+1)!=tousa.get(p+1)-tousa.get(p+2)){
            continue bi ;
          }
        }
        System.out.println(N[i]);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var N : Sequence(int) ; N := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n + 1 do ( (     N[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n + 1 do ( (     var tousa : Sequence(int) ; tousa := Sequence{} ;
         var p : int ; p := 0 ; while p < n + 1 do ( (     tousa := tousa->including(N[p+1]) )  ;     p := p + 1 ) ; 
    tousa := tousa->excludingAt(i+1) ; 
        var p : int ; p := 0 ; while p < n - 2 do ( (     if (tousa->at(p+1) - tousa->at(p + 1+1) /= tousa->at(p + 1+1) - tousa->at(p + 2+1)) then (     continue ) else skip )  ;     p := p + 1 ) ; 
    OclFile["System.out"].println(N[i+1]) ; 
    break 
 )  ;     i := i + 1 ) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float cyl(float r,float R,float h){
    if(h<0 && r<0 && R<0)return-1 ;
    float r1=r ;
    float h1=h ;
    float V=(float)(3.14*Math.pow(r1,2)*h1);
    return V ;
  }
  public static void main(String[] args){
    float r=7,R=11,h=6 ;
    System.out.print(cyl(r,R,h));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation cyl( r : double, R : double, h : double) : double
  pre: true
  post: true
  activity: (     if (h < 0 & r < 0 & R < 0) then     return -1 else skip ; 
     var r1 : double ; r1 := r ;
    var h1 : double ; h1 := h ;
    var V : double ; V := (3.14 * r1->pow(2) * h1)->oclAsType(double) ;
    return V 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : double ; r := 7 ;
    var R : double ; R := 11 ;
    var h : double ; h := 6 ;
     OclFile["System.out"].print(cyl(r, R, h)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int findMissing(int arr[],int n){
    int l=0,h=n-1 ;
    int mid ;
    while(h>l){
      mid=l+(h-l)/2 ;
      if(arr[mid]-mid==arr[0]){
        if(arr[mid+1]-arr[mid]>1)return arr[mid]+1 ;
        else {
          l=mid+1 ;
        }
      }
      else {
        if(arr[mid]-arr[mid-1]>1)return arr[mid]-1 ;
        else {
          h=mid-1 ;
        }
      }
    }
    return-1 ;
  }
  public static void main(String args[]){
    int arr[]={
-9,-8,-7,-5,-4,-3,-2,-1,0 };
      int n=arr.length ;
      System.out.print(findMissing(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMissing( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
    var h : int ; h := n - 1 ;
     var mid : int ;
     while (h > l) do (     mid := l + (h - l) / 2 ; 
     if (arr[mid+1] - mid = arr[0+1]) then (     if (arr[mid + 1+1] - arr[mid+1] > 1) then     return arr[mid+1] + 1 else (     l := mid + 1 ) ) else (     if (arr[mid+1] - arr[mid - 1+1] > 1) then     return arr[mid+1] - 1 else (     h := mid - 1 ) ) ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-9,-8,-7,-5,-4,-3,-2,-1,0} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(findMissing(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    int N=parseInt(br.readLine());
    int[] a=new int[N];
    StringTokenizer st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<N ; i++){
      a[i]=parseInt(st.nextToken());
    }
    int[] indeg=new int[N];
    boolean[] used=new boolean[N];
    for(int i=0 ; i<N ; i++){
      indeg[(i+a[i])% N]++;
    }
    for(int i=0 ; i<N ; i++){
      int j=i ;
      while(! used[j] && indeg[j]==0){
        used[j]=true ;
        j=(j+a[j])% N ;
        indeg[j]--;
      }
    }
    int count=0 ;
    for(int i=0 ; i<N ; i++){
      if(indeg[i]!=0)count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var N : int ; N := parseInt(br.readLine()) ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := (st.next() + "")->toInteger() )  ;     i := i + 1 ) ; 
    var indeg : Sequence(int) ; indeg := Integer.subrange(1,N)->collect(0) ;
    var used : Sequence(boolean) ; used := Integer.subrange(1,N)->collect(false) ;
        var i : int ; i := 0 ; while i < N do ( (     indeg[(i + a[i+1]) mod N+1] := indeg[(i + a[i+1]) mod N+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var j : int ; j := i ;
     while (not(used[j+1]) & indeg[j+1] = 0) do (     used[j+1] := true ; 
     j := (j + a[j+1]) mod N ; 
     indeg[j+1] := indeg[j+1] - 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (indeg[i+1] /= 0) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double areaCube(double a){
    return(a*a*a);
  }
  static double surfaceCube(double a){
    return(6*a*a);
  }
  public static void main(String[] args){
    double a=5 ;
    System.out.println("Area="+areaCube(a));
    System.out.println("Total surface area="+surfaceCube(a));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation areaCube( a : double) : double
  pre: true
  post: true
  activity: (     return (a * a * a) );
  static   operation surfaceCube( a : double) : double
  pre: true
  post: true
  activity: (     return (6 * a * a) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 5 ;
     OclFile["System.out"].println("Area=" + areaCube(a)) ; 
     OclFile["System.out"].println("Total surface area=" + surfaceCube(a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class geeks {
  public static int sumoflength(int[] arr,int n){
    Set<Integer>s=new HashSet<>();
    int j=0,ans=0 ;
    for(int i=0 ; i<n ; i++){
      while(j<n && ! s.contains(arr[j])){
        s.add(arr[i]);
        j++;
      }
      ans+=((j-i)*(j-i+1))/2 ;
      s.remove(arr[i]);
    }
    return ans ;
  }
  public static void main(String[] args){
    int[] arr={
      1,2,3,4 };
      int n=arr.length ;
      System.out.println(sumoflength(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class geeks {
  static   operation sumoflength( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
     var j : int ; j := 0 ;
    var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     while (j < n & not(s->includes(arr[j+1]))) do (     s := s->including(arr[i+1]) ; 
     j := j + 1 ) ; 
     ans := ans+(((j - i) * (j - i + 1)) / 2) ; 
     s := s->excludingFirst(arr[i+1]) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(sumoflength(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void KthCharacter(int m,int n,int k){
    int distance=(int)Math.pow(2,n);
    int Block_number=k/distance ;
    int remaining=k % distance ;
    int s[]=new int[32];
    int x=0 ;
    for(; m>0 ; x++){
      s[x]=m % 2 ;
      m=m/2 ;
    }
    int root=s[x-1-Block_number];
    if(remaining==0){
      System.out.println(root);
      return ;
    }
    Boolean flip=true ;
    while(remaining>1){
      if((remaining & 1)>0){
        flip=! flip ;
      }
      remaining=remaining>>1 ;
    }
    if(flip){
      System.out.println((root>0)? 0 : 1);
    }
    else {
      System.out.println(root);
    }
  }
  public static void main(String[] args){
    int m=5,k=5,n=3 ;
    KthCharacter(m,n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation KthCharacter( m : int, n : int, k : int) : void
  pre: true
  post: true
  activity: (     var distance : int ; distance := 2->pow(n)->oclAsType(int) ;
     var Block_number : int ; Block_number := k / distance ;
    var remaining : int ; remaining := k mod distance ;
    var s : Sequence(int) ; s := Integer.subrange(1,32)->collect(0) ;
    var x : int ; x := 0 ;
      while m > 0 do ( (     s[x+1] := m mod 2 ; 
     m := m / 2 )  ;     x := x + 1 ) ; 
    var root : int ; root := s[x - 1 - Block_number+1] ;
    if (remaining = 0) then (     OclFile["System.out"].println(root) ; 
     return ) else skip ; 
    var flip : Boolean ; flip := true ;
    while (remaining > 1) do (     if ((MathLib.bitwiseAnd(remaining,1)) > 0) then (     flip := not(flip) ) else skip ; 
     remaining := (remaining/(2->pow(1)))->oclAsType(long) ) ; 
    if (flip) then (     OclFile["System.out"].println(if (root > 0) then 0 else 1 endif) ) else (     OclFile["System.out"].println(root) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 5 ;
    var k : int ; k := 5 ;
    var n : int ; n := 3 ;
     execute KthCharacter(m, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static long NthTerm(long n){
    long x=(3*n*n)% 1000000009 ;
    return(x-n+1000000009)% 1000000009 ;
  }
  public static void main(String args[]){
    long N=4 ;
    System.out.println(NthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation NthTerm( n : long) : long
  pre: true
  post: true
  activity: (     var x : long ; x := (3 * n * n) mod 1000000009 ;
     return (x - n + 1000000009) mod 1000000009 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := 4 ;
     OclFile["System.out"].println(NthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean inProportion(int[] arr){
    int n=4 ;
    Arrays.sort(arr);
    long extremes=(long)arr[0]*(long)arr[3];
    long means=(long)arr[1]*(long)arr[2];
    if(extremes==means)return true ;
    return false ;
  }
  public static void main(String args[]){
    int arr[]={
      1,2,4,2 };
      if(inProportion(arr))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation inProportion( arr : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     arr := arr->sort() ; 
    var extremes : long ; extremes := arr[0+1]->oclAsType(long) * arr[3+1]->oclAsType(long) ;
    var means : long ; means := arr[1+1]->oclAsType(long) * arr[2+1]->oclAsType(long) ;
    if (extremes = means) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,4,2} ;
     if (inProportion(arr)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int n ;
  static int solve(int i,int x,int dp[][]){
    if(i<0){
      return x==3 ? 1 : 0 ;
    }
    if(dp[i][x]!=-1){
      return dp[i][x];
    }
    dp[i][x]=solve(i-1,0,dp);
    dp[i][x]+=solve(i-1,x+1,dp);
    return dp[i][x];
  }
  public static void main(String[] args){
    n=4 ;
    int dp[][]=new int[n][4];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<4 ; j++){
        dp[i][j]=-1 ;
      }
    }
    for(int i=0 ; i<n ; i++){
      dp[i][3]=(1<<(i+1));
    }
    System.out.print(solve(n-1,0,dp));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute n : int;
  static   operation solve( i : int, x : int, dp : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     if (i < 0) then (     return if x = 3 then 1 else 0 endif ) else skip ; 
     if (dp[i+1][x+1] /= -1) then (     return dp[i+1][x+1] ) else skip ; 
    dp[i+1][x+1] := solve(i - 1, 0, dp) ; 
    dp[i+1][x+1] := dp[i+1][x+1]+(solve(i - 1, x + 1, dp)) ; 
    return dp[i+1][x+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := 4 ; 
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,4)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 4 do ( (     dp[i+1][j+1] := -1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     dp[i+1][3+1] := ((1*(2->pow((i + 1))))->oclAsType(long)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(solve(n - 1, 0, dp)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.nio.charset.MalformedInputException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
import java.util.HashSet ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter o=new PrintWriter(System.out);
    long n=sc.nextLong();
    long m=sc.nextLong();
    while(n>0 && m>0){
      long g=Math.max(n,m);
      if(g>=2*Math.min(n,m)){
        g %=(2*Math.min(n,m));
      }
      else {
        break ;
      }
      if(n>=m){
        n=g ;
      }
      else {
        m=g ;
      }
    }
    o.println(n+" "+m);
    o.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var o : OclFile ; o := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := sc.getCurrent()->toLong() ;
    var m : long ; m := sc.getCurrent()->toLong() ;
    while (n > 0 & m > 0) do (     var g : long ; g := Set{n, m}->max() ;
     if (g >= 2 * Set{n, m}->min()) then (     g := g mod (2 * Set{n, m}->min()) ) else (     break ) ;  
     if (n >= m) then (     n := g ) else (     m := g ) ) ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public void solver(){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      TreeMap<Integer,Integer>map=new TreeMap<>();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
        if(map.containsKey(a[i])){
          map.put(a[i],map.get(a[i])+1);
        }
        else {
          map.put(a[i],1);
        }
      }
      for(int key : map.keySet()){
        System.out.print(key+" ");
        map.put(key,map.get(key)-1);
      }
      for(int key : map.keySet()){
        for(int i=1 ; i<=map.get(key); i++){
          System.out.print(key+" ");
        }
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    Solution sol=new Solution();
    sol.solver();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
   operation solver() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var map : Map(int,int) ; map := Map{} ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (map->keys()->includes(a[i+1])) then (     map := map->union(Map{a[i+1] |-> map->at(a[i+1]) + 1}) ) else (     map := map->union(Map{a[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    for (key : map->keys()) do ( (     OclFile["System.out"].print(key + " ") ; 
     map := map->union(Map{key |-> map->at(key) - 1}) )  ) ; 
    for (key : map->keys()) do ( (         var i : int ; i := 1 ; while i <= map->at(key) do ( (     OclFile["System.out"].print(key + " ") )  ;     i := i + 1 ) )  ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sol : Solution ; sol := Solution.newSolution() ;
     sol.solver() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class test311 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int a[]=new int[101];
      int b[]=new int[n];
      int c[]=new int[n];
      int m=0 ;
      for(int i=0 ; i<n ; i++){
        int x=in.nextInt();
        a[x]++;
        b[i]=x ;
        if(a[x]>1){
          c[m++]=x ;
        }
      }
      Arrays.sort(b);
      for(int i=0 ; i<n ; i++){
        if(i==0){
          System.out.print(b[i]+" ");
        }
        if(i>0 && b[i-1]!=b[i]){
          System.out.print(b[i]+" ");
        }
      }
      for(int i=0 ; i<m ; i++){
        System.out.print(c[i]+" ");
      }
      System.out.println();
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test311 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,101)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    var m : int ; m := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     a[x+1] := a[x+1] + 1 ; 
     b[i+1] := x ; 
     if (a[x+1] > 1) then (      c[m+1] := x  ; m := m + 1 ) else skip )  ;     i := i + 1 ) ; 
    b := b->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i = 0) then (     OclFile["System.out"].print(b[i+1] + " ") ) else skip ; 
     if (i > 0 & b[i - 1+1] /= b[i+1]) then (     OclFile["System.out"].print(b[i+1] + " ") ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     OclFile["System.out"].print(c[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m[]=new int[n],l[]=new int[n],c=0 ;
    boolean[] t=new boolean[n];
    for(int i=0 ; i<n ; i++){
      m[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++)l[(i+m[i])% n]++;
    for(int i=0 ; i<n ; i++){
      int j=i ;
      while(! t[j] && l[j]==0){
        t[j]=true ;
        j=(j+m[j])% n ;
        l[j]--;
      }
    }
    for(int i : l)c+=i>0 ? 1 : 0 ;
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : Sequence(void) ; m := Integer.subrange(1,n)->collect(0) ;
    var l : Sequence(void) ; l := Integer.subrange(1,n)->collect(0) ;
    var c : int ; c := 0 ;
    var t : Sequence(boolean) ; t := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     m[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     l[(i + m[i+1]) mod n+1] := l[(i + m[i+1]) mod n+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var j : int ; j := i ;
     while (not(t[j+1]) & l[j+1] = 0) do (     t[j+1] := true ; 
     j := (j + m[j+1]) mod n ; 
     l[j+1] := l[j+1] - 1 ) )  ;     i := i + 1 ) ; 
    for (i : l) do (     c := c+(if i > 0 then 1 else 0 endif) ;  ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String LexicographicalMaxString(String str){
    String mx="" ;
    for(int i=0 ; i<str.length(); ++i){
      if(mx.compareTo(str.substring(i))<=0){
        mx=str.substring(i);
      }
    }
    return mx ;
  }
  public static void main(String[] args){
    String str="ababaa" ;
    System.out.println(LexicographicalMaxString(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation LexicographicalMaxString( str : String) : String
  pre: true
  post: true
  activity: (     var mx : String ; mx := "" ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (mx->compareTo(str.subrange(i+1,i)) <= 0) then (     mx := str.subrange(i+1,i) ) else skip )  ;     i := i + 1 ) ; 
     return mx );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "ababaa" ;
     OclFile["System.out"].println(LexicographicalMaxString(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int __gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static int MinDeletion(int a[],int n){
    int gcd=0 ;
    for(int i=0 ; i<n ; i++)gcd=__gcd(gcd,a[i]);
    if(gcd>1)return-1 ;
    else return 0 ;
  }
  public static void main(String[] args){
    int a[]={
      3,6,12,81,9 };
      int n=a.length ;
      System.out.print(MinDeletion(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
    if (a = b) then     return a else skip ; 
    if (a > b) then     return __gcd(a - b, b) else skip ; 
    return __gcd(a, b - a) 
 );
  static   operation MinDeletion( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var gcd : int ; gcd := 0 ;
         var i : int ; i := 0 ; while i < n do (     gcd := __gcd(gcd, a[i+1]) ;  ;     i := i + 1 ) ; 
     if (gcd > 1) then     return -1 else     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{3,6,12,81,9} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(MinDeletion(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    final int A=1000005 ;
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    int c[]=new int[A];
    int b ;
    String ans="pairwise coprime" ;
    for(int i=0 ; i<A ; i++){
      c[i]=0 ;
    }
    for(int i=0 ; i<n ; i++){
      b=sc.nextInt();
      c[b]+=1 ;
    }
    for(int i=2 ; i<A ; i++){
      int cnt=0 ;
      for(int j=i ; j<A ; j+=i){
        cnt+=c[j];
      }
      if(cnt==n){
        ans="not coprime" ;
        break ;
      }
      else if(cnt>1){
        ans="setwise coprime" ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 1000005 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,A)->collect(0) ;
    var b : int ;
    var ans : String ; ans := "pairwise coprime" ;
        var i : int ; i := 0 ; while i < A do ( (     c[i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b := sc.getCurrent()->toInteger() ; 
     c[b+1] := c[b+1]+(1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i < A do ( (     var cnt : int ; cnt := 0 ;
         var j : int ; j := i ; while j < A do ( (     cnt := cnt+(c[j+1]) )  ;     j := j+(i) ) ; 
     if (cnt = n) then (     ans := "not coprime" ; 
     break ) else     if (cnt > 1) then (     ans := "setwise coprime" ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import javafx.util.Pair ;
class GFG {
  static int getPairs(int arr[],int n){
    HashSet<Pair>h=new HashSet<Pair>();
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        Pair<Integer,Integer>p=new Pair<>(arr[i],arr[j]);
        h.add(p);
      }
    }
    return h.size();
  }
  public static void main(String[] args){
    int arr[]={
      1,2,2,4,2,5,3,5 };
      int n=arr.length ;
      System.out.println(getPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var h : Set(Map) ; h := Set{} ;
         var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var p : Map(String,OclAny) ; p := Tuple(arr[i+1], arr[j+1]) ;
     h := h->including(p) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return h->size() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,2,4,2,5,3,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(getPairs(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemB {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int test=Integer.parseInt(br.readLine());
    while(test-->0){
      int n=Integer.parseInt(br.readLine());
      String line[]=br.readLine().split(" ");
      Integer arr[]=new Integer[n];
      for(int i=0 ; i<n ; i++)arr[i]=Integer.parseInt(line[i]);
      int pos=0 ;
      ArrayList<Integer>list=new ArrayList<>(Arrays.asList(arr));
      while(pos<n){
        int index=list.indexOf(Collections.min(list.subList(pos,n)));
        int value=list.get(index);
        list.remove(index);
        list.add(pos,value);
        if(pos==index)pos=index+1 ;
        else pos=index ;
      }
      for(int it : list)sb.append(it+" ");
      sb.append("\n");
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var test : int ; test := (br.readLine())->toInteger() ;
        while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := (line[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var pos : int ; pos := 0 ;
    var list : Sequence(int) ; list := Sequence{}->union(arr) ;
    while (pos < n) do (     var index : int ; index := list->indexOf(list.subrange(pos+1,n)->min())-1 ;
     var value : int ; value := list->at(index+1) ;
    list := list->excludingAt(index+1) ; 
    list := list.insertAt(pos+1,value) ; 
    if (pos = index) then     pos := index + 1 else     pos := index ; ;  
 ) ; 
    for (it : list) do (     sb := sb + StringLib.newString(it + " ") ;  ) ; 
    sb := sb + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemB {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int test=Integer.parseInt(br.readLine());
    while(test-->0){
      int n=Integer.parseInt(br.readLine());
      String line[]=br.readLine().split(" ");
      Integer arr[]=new Integer[n];
      for(int i=0 ; i<n ; i++)arr[i]=Integer.parseInt(line[i]);
      int pos=0 ;
      ArrayList<Integer>list=new ArrayList<>(Arrays.asList(arr));
      while(pos<n){
        int index=list.indexOf(Collections.min(list.subList(pos,n)));
        int value=list.get(index);
        list.remove(index);
        list.add(pos,value);
        if(pos==index)pos=index+1 ;
        else pos=index ;
      }
      for(int it : list)sb.append(it+" ");
      sb.append("\n");
    }
    System.out.println(sb);
  }
  public static void swap(int i,int j,int arr[]){
    int t=arr[j];
    arr[j]=arr[i];
    arr[i]=t ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var test : int ; test := (br.readLine())->toInteger() ;
        while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := (line[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var pos : int ; pos := 0 ;
    var list : Sequence(int) ; list := Sequence{}->union(arr) ;
    while (pos < n) do (     var index : int ; index := list->indexOf(list.subrange(pos+1,n)->min())-1 ;
     var value : int ; value := list->at(index+1) ;
    list := list->excludingAt(index+1) ; 
    list := list.insertAt(pos+1,value) ; 
    if (pos = index) then     pos := index + 1 else     pos := index ; ;  
 ) ; 
    for (it : list) do (     sb := sb + StringLib.newString(it + " ") ;  ) ; 
    sb := sb + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
  static   operation swap( i : int, j : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := arr[j+1] ;
     arr[j+1] := arr[i+1] ; 
     arr[i+1] := t );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemB {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int test=Integer.parseInt(br.readLine());
    while(test-->0){
      int n=Integer.parseInt(br.readLine());
      String line[]=br.readLine().split(" ");
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=Integer.parseInt(line[i]);
      int index=0,j=0,have=n-1 ;
      for(int i=0 ; i<n ; i++){
        j=index ;
        for(; j<n ; j++){
          if(arr[j]==i+1){
            int min=Math.min(have,Math.min(j-i,j-index));
            have-=min ;
            int curr=j ;
            index=index==j ? j+1 : j ;
            while(min-->0){
              swap(curr,curr-1,arr);
              curr--;
            }
          }
        }
      }
      for(int it : arr)sb.append(it+" ");
      sb.append("\n");
    }
    System.out.println(sb);
  }
  public static void swap(int i,int j,int arr[]){
    int t=arr[j];
    arr[j]=arr[i];
    arr[i]=t ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var test : int ; test := (br.readLine())->toInteger() ;
        while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := (line[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var index : int ; index := 0 ;
    var j : int ; j := 0 ;
    var have : int ; have := n - 1 ;
        var i : int ; i := 0 ; while i < n do ( (     j := index ; 
       while j < n do ( (     if (arr[j+1] = i + 1) then (     var min : int ; min := Set{have, Set{j - i, j - index}->min()}->min() ;
     have := have-(min) ; 
    var curr : int ; curr := j ;
    index := if index = j then j + 1 else j endif ; 
        while (min > 0) do (        min := min - 1 ;     skip ; (     execute swap(curr, curr - 1, arr) ; 
     curr := curr - 1 ) ;  ) ;  
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    for (it : arr) do (     sb := sb + StringLib.newString(it + " ") ;  ) ; 
    sb := sb + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
  static   operation swap( i : int, j : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := arr[j+1] ;
     arr[j+1] := arr[i+1] ; 
     arr[i+1] := t );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class B_Minimize_the_Permutation {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    for(int tc=0 ; tc<q ; tc++){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; i++){
        a[i]=sc.nextInt();
      }
      System.out.println(solve(a));
    }
    sc.close();
  }
  static String solve(int[] a){
    int[] indices=new int[a.length+1];
    for(int i=0 ; i<a.length ; i++){
      indices[a[i] ]=i ;
    }
    int minIndex=0 ;
    for(int value=1 ; value<=a.length ; value++){
      int nextMinIndex=Math.max(minIndex,indices[value]);
      for(int j=indices[value]-1 ; j>=minIndex ; j--){
        if(a[j]>a[j+1]){
          swap(a,indices,j,j+1);
        }
      }
      minIndex=nextMinIndex ;
    }
    return Arrays.stream(a).mapToObj(String :: valueOf).collect(Collectors.joining(" "));
  }
  static void swap(int[] a,int[] indices,int index1,int index2){
    swapInArray(indices,a[index1],a[index2]);
    swapInArray(a,index1,index2);
  }
  static void swapInArray(int[] p,int i1,int i2){
    int temp=p[i1];
    p[i1]=p[i2];
    p[i2]=temp ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Minimize_the_Permutation {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < q do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(solve(a)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var indices : Sequence(int) ; indices := Integer.subrange(1,a->size() + 1)->collect(0) ;
         var i : int ; i := 0 ; while i < a->size() do ( (     indices[a[i+1]+1] := i )  ;     i := i + 1 ) ; 
    var minIndex : int ; minIndex := 0 ;
        var value : int ; value := 1 ; while value <= a->size() do ( (     var nextMinIndex : int ; nextMinIndex := Set{minIndex, indices[value+1]}->max() ;
         var j : int ; j := indices[value+1] - 1 ; while j >= minIndex do ( (     if (a[j+1] > a[j + 1+1]) then (     execute swap(a, indices, j, j + 1) ) else skip )  ;     j := j - 1 ) ; 
     minIndex := nextMinIndex )  ;     value := value + 1 ) ; 
    return stream(a).mapToObj(lambda _pars : OclAny in String.newString().valueOf(_pars)).collect(Collectors.joining(" ")) 
 );
  static   operation swap( a : Sequence(int), indices : Sequence(int), index1 : int, index2 : int) : void
  pre: true
  post: true
  activity: (     execute swapInArray(indices, a[index1+1], a[index2+1]) ; 
     execute swapInArray(a, index1, index2) );
  static   operation swapInArray( p : Sequence(int), i1 : int, i2 : int) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := p[i1+1] ;
     p[i1+1] := p[i2+1] ; 
     p[i2+1] := temp );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      long n=sc.nextLong();
      long m=sc.nextLong();
      while(n>0 && m>0){
        if(n>=2*m)n %=2*m ;
        else if(m>=2*n)m %=2*n ;
        else break ;
      }
      System.out.print(n+" "+m);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var m : long ; m := sc.getCurrent()->toLong() ;
    while (n > 0 & m > 0) do (     if (n >= 2 * m) then     n := n mod 2 * m ; else     if (m >= 2 * n) then     m := m mod 2 * n else     break ;  ) ; 
    OclFile["System.out"].print(n + " " + m) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.HashSet ;
import java.util.Set ;
public class MinimizeThePermutation {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t!=0){
      solve(br,pr);
      t--;
    }
    pr.flush();
    pr.close();
  }
  static Set<Integer>used ;
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    used=new HashSet<>();
    String[] temp=br.readLine().split(" ");
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=Integer.parseInt(temp[i]);
    }
    for(int i=0 ; i<n ; i++){
      if(used.contains(i)){
        continue ;
      }
      int rightMin=nums[i];
      int minIndex=i ;
      for(int j=i+1 ; j<n ; j++){
        if(nums[j]<rightMin){
          minIndex=j ;
          rightMin=nums[j];
        }
      }
      if(minIndex!=i){
        swap(nums,i,minIndex);
      }
    }
    for(int i : nums){
      pr.print(i+" ");
    }
    pr.print('\n');
  }
  public static void swap(int[] nums,int i,int j){
    while(j!=i){
      used.add(j-1);
      nums[j] ^=nums[j-1];
      nums[j-1] ^=nums[j];
      nums[j] ^=nums[j-1];
      j--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MinimizeThePermutation {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
    while (t /= 0) do (     execute solve(br, pr) ; 
     t := t - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   attribute used : Set(int);
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     used := Set{} ; 
    var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := (temp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (used->includes(i)) then (     continue ) else skip ; 
     var rightMin : int ; rightMin := nums[i+1] ;
    var minIndex : int ; minIndex := i ;
        var j : int ; j := i + 1 ; while j < n do ( (     if (nums[j+1] < rightMin) then (     minIndex := j ; 
     rightMin := nums[j+1] ) else skip )  ;     j := j + 1 ) ; 
    if (minIndex /= i) then (     execute swap(nums, i, minIndex) ) else skip ; 
 )  ;     i := i + 1 ) ; 
    for (i : nums) do ( (     skip )  ) ; 
    skip ; 
 );
  static   operation swap( nums : Sequence(int), i : int, j : int) : void
  pre: true
  post: true
  activity: (     while (j /= i) do (     used := used->including(j - 1) ; 
     nums[j+1] := MathLib.bitwiseXor(nums[j+1],nums[j - 1+1]) ; 
    nums[j - 1+1] := MathLib.bitwiseXor(nums[j - 1+1],nums[j+1]) ; 
    nums[j+1] := MathLib.bitwiseXor(nums[j+1],nums[j - 1+1]) ; 
    j := j - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.math.RoundingMode ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=null ;
    try {
      sc=new Scanner(System.in);
      Map<Integer,Integer>map=new HashMap<Integer,Integer>();
      while(sc.hasNextLine()){
        String[] s=sc.nextLine().split(",");
        map.put(Integer.parseInt(s[0]),Integer.parseInt(s[1]));
      }
      int totalPrice=0 ;
      int totalQuantity=0 ;
      for(int unitPrice : map.keySet()){
        int quantity=map.get(unitPrice);
        totalPrice+=unitPrice*quantity ;
        totalQuantity+=quantity ;
      }
      int quantityAve=new BigDecimal(totalQuantity).divide(new BigDecimal(map.size()),RoundingMode.HALF_UP).intValue();
      System.out.println(totalPrice);
      System.out.println(quantityAve);
    }
    finally {
      sc.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := null ;
     try (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var map : Map(int,int) ; map := Map{} ;
    while (sc.hasNextLine()) do (     var s : Sequence(String) ; s := sc.nextLine()->split(",") ;
     map := map->union(Map{(s[0+1])->toInteger() |-> (s[1+1])->toInteger()}) ) ; 
    var totalPrice : int ; totalPrice := 0 ;
    var totalQuantity : int ; totalQuantity := 0 ;
    for (unitPrice : map->keys()) do ( (     var quantity : int ; quantity := map->at(unitPrice) ;
     totalPrice := totalPrice+(unitPrice * quantity) ; 
     totalQuantity := totalQuantity+(quantity) )  ) ; 
    var quantityAve : int ; quantityAve := double(totalQuantity).divide(double(map.size()), RoundingMode.HALF_UP)->oclAsType(int) ;
    OclFile["System.out"].println(totalPrice) ; 
    OclFile["System.out"].println(quantityAve) ; 
 )   finally (     skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isTriangular(int num){
    if(num<0)return false ;
    int c=(-2*num);
    int b=1,a=1 ;
    int d=(b*b)-(4*a*c);
    if(d<0)return false ;
    float root1=(-b+(float)Math.sqrt(d))/(2*a);
    float root2=(-b-(float)Math.sqrt(d))/(2*a);
    if(root1>0 && Math.floor(root1)==root1)return true ;
    if(root2>0 && Math.floor(root2)==root2)return true ;
    return false ;
  }
  public static void main(String[] args){
    int num=55 ;
    if(isTriangular(num))System.out.println("The number is"+" a triangular number");
    else System.out.println("The number "+"is NOT a triangular number");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isTriangular( num : int) : boolean
  pre: true
  post: true
  activity: (     if (num < 0) then     return false else skip ; 
     var c : int ; c := (-2 * num) ;
    var b : int ; b := 1 ;
    var a : int ; a := 1 ;
    var d : int ; d := (b * b) - (4 * a * c) ;
    if (d < 0) then     return false else skip ; 
    var root1 : double ; root1 := (-b + (d)->sqrt()->oclAsType(double)) / (2 * a) ;
    var root2 : double ; root2 := (-b - (d)->sqrt()->oclAsType(double)) / (2 * a) ;
    if (root1 > 0 & (root1)->floor() = root1) then     return true else skip ; 
    if (root2 > 0 & (root2)->floor() = root2) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 55 ;
     if (isTriangular(num)) then     OclFile["System.out"].println("The number is" + " a triangular number") ; else     OclFile["System.out"].println("The number " + "is NOT a triangular number") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.io.*;
class GFG {
  public static void digit_product_Sum(int N){
    int a[]=new int[N+1];
    int product=1 ;
    a[0]=1 ;
    for(int i=1 ; i<=N ; i++){
      product=a[i-1]/10 ;
      if(product==0)product=1 ;
      else product=a[i-1] % 10 ;
      int val=a[i-1]/10 ;
      if(val==0)val=a[i-1];
      a[i]=a[i-1]+(val*product);
    }
    for(int i=0 ; i<N ; i++)System.out.print(a[i]+" ");
  }
  public static void main(String[] args){
    int N=10 ;
    digit_product_Sum(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation digit_product_Sum( N : int) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,N + 1)->collect(0) ;
     var product : int ; product := 1 ;
    a[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= N do ( (     product := a[i - 1+1] / 10 ; 
     if (product = 0) then     product := 1 else     product := a[i - 1+1] mod 10 ; ;  
    var val : int ; val := a[i - 1+1] / 10 ;
    if (val = 0) then     val := a[i - 1+1] ; else skip ; 
    a[i+1] := a[i - 1+1] + (val * product) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 10 ;
     execute digit_product_Sum(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMax(int num){
    byte size_of_int=4 ;
    int num_copy=num ;
    int j=size_of_int*8-1 ;
    int i=0 ;
    while(i<j){
      int m=(num_copy>>i)& 1 ;
      int n=(num_copy>>j)& 1 ;
      if(m>n){
        int x=(1<<i | 1<<j);
        num=num ^ x ;
      }
      i++;
      j--;
    }
    return num ;
  }
  static public void main(String[] args){
    int num=4 ;
    System.out.println(findMax(num));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMax( num : int) : int
  pre: true
  post: true
  activity: (     var size_of_int : int ; size_of_int := 4 ;
     var num_copy : int ; num_copy := num ;
    var j : int ; j := size_of_int * 8 - 1 ;
    var i : int ; i := 0 ;
    while (i < j) do (     var m : int ; m := MathLib.bitwiseAnd(((num_copy/(2->pow(i)))->oclAsType(long)),1) ;
     var n : int ; n := MathLib.bitwiseAnd(((num_copy/(2->pow(j)))->oclAsType(long)),1) ;
    if (m > n) then (     var x : int ; x := (MathLib.bitwiseOr((1*(2->pow(i)))->oclAsType(long),(1*(2->pow(j)))->oclAsType(long))) ;
     num := num xor x ) else skip ; 
    i := i + 1 ; 
    j := j - 1 ; 
 ) ; 
    return num 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 4 ;
     OclFile["System.out"].println(findMax(num)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int sumDigits(int n){
    int digit_sum=0 ;
    while(n>0){
      digit_sum+=n % 10 ;
      n/=10 ;
    }
    return digit_sum ;
  }
  static int productOfNumbers(int[] arr,int n){
    int sum=Integer.MIN_VALUE ;
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        int product=arr[i]*arr[j];
        sum=Math.max(sum,sumDigits(product));
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int[] arr={
      4,3,5 };
      int n=arr.length ;
      System.out.print(productOfNumbers(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumDigits( n : int) : int
  pre: true
  post: true
  activity: (     var digit_sum : int ; digit_sum := 0 ;
     while (n > 0) do (     digit_sum := digit_sum+(n mod 10) ; 
     n := n/(10) ) ; 
     return digit_sum );
  static   operation productOfNumbers( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := -2147483648 ;
         var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var product : int ; product := arr[i+1] * arr[j+1] ;
     sum := Set{sum, sumDigits(product)}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,3,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(productOfNumbers(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findMinX(int num[],int rem[],int k){
    int x=1 ;
    while(true){
      int j ;
      for(j=0 ; j<k ; j++)if(x % num[j]!=rem[j])break ;
      if(j==k)return x ;
      x++;
    }
  }
  public static void main(String args[]){
    int num[]={
      3,4,5 };
      int rem[]={
        2,3,1 };
        int k=num.length ;
        System.out.println("x is "+findMinX(num,rem,k));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMinX( num : Sequence(int), rem : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := 1 ;
     while (true) do (     var j : int ;
         j := 0 ; while j < k do (     if (x mod num[j+1] /= rem[j+1]) then     break else skip ;  ;     j := j + 1 ) ; 
     if (j = k) then     return x else skip ; 
     x := x + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : Sequence(int) ; num := Sequence{3,4,5} ;
     var rem : Sequence(int) ; rem := Sequence{2,3,1} ;
     var k : int ; k := num->size() ;
     OclFile["System.out"].println("x is " + findMinX(num, rem, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class KthDivisor {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    String[] temp=br.readLine().split(" ");
    long n=Long.parseLong(temp[0]);
    int k=Integer.parseInt(temp[1]);
    List<Long>smaller=new ArrayList<>();
    List<Long>bigger=new ArrayList<>();
    for(long i=1 ; i*i<=n ; i++){
      if(n % i!=0){
        continue ;
      }
      smaller.add(i);
      if(n/i!=i){
        bigger.add(n/i);
      }
    }
    Collections.reverse(bigger);
    if(smaller.size()+bigger.size()<k){
      pr.println(-1);
      return ;
    }
    smaller.addAll(bigger);
    pr.println(smaller.get(k-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class KthDivisor {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
     var n : long ; n := (temp[0+1])->toLong() ;
    var k : int ; k := (temp[1+1])->toInteger() ;
    var smaller : Sequence(long) ; smaller := Sequence{} ;
    var bigger : Sequence(long) ; bigger := Sequence{} ;
        var i : long ; i := 1 ; while i * i <= n do ( (     if (n mod i /= 0) then (     continue ) else skip ; 
     smaller := smaller->including(i) ; 
     if (n / i /= i) then (     bigger := bigger->including(n / i) ) else skip )  ;     i := i + 1 ) ; 
    bigger := bigger->reverse() ; 
    if (smaller->size() + bigger->size() < k) then (     skip ; 
     return ) else skip ; 
    smaller := smaller->union(bigger) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Kthdivisor1 {
  public static void main(String args[]){
    int i,j,k,t ;
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    k=sc.nextInt();
    ArrayList<Long>list=new ArrayList<>();
    int count=0,flag=0 ;
    int sqrt=(int)Math.sqrt(n);
    long val=0 ;
    HashSet<Long>hs=new HashSet<>();
    for(i=1 ; i<=sqrt ; i++){
      if(n % i==0){
        hs.add((long)i);
        list.add((long)i);
        count++;
        if(count==k){
          val=i ;
          flag=1 ;
          break ;
        }
      }
    }
    if(flag==0){
      for(i=list.size()-1 ; i>=0 ; i--){
        if(hs.contains(n/list.get(i))){
          continue ;
        }
        count++;
        if(count==k){
          val=n/list.get(i);
          flag=1 ;
          break ;
        }
      }
    }
    if(flag==0){
      System.out.println("-1");
    }
    else {
      System.out.println(val);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Kthdivisor1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var k : int ;
    var t : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : long ; n := sc.getCurrent()->toLong() ;
    k := sc.getCurrent()->toInteger() ; 
    var list : Sequence(long) ; list := Sequence{} ;
    var count : int ; count := 0 ;
    var flag : int ; flag := 0 ;
    var sqrt : int ; sqrt := (n)->sqrt()->oclAsType(int) ;
    var val : long ; val := 0 ;
    var hs : Set(long) ; hs := Set{} ;
        i := 1 ; while i <= sqrt do ( (     if (n mod i = 0) then (     hs := hs->including(i->oclAsType(long)) ; 
     list := list->including(i->oclAsType(long)) ; 
     count := count + 1 ; 
     if (count = k) then (     val := i ; 
     flag := 1 ; 
     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 0) then (         i := list->size() - 1 ; while i >= 0 do ( (     if (hs->includes(n / list->at(i+1))) then (     continue ) else skip ; 
     count := count + 1 ; 
     if (count = k) then (     val := n / list->at(i+1) ; 
     flag := 1 ; 
     break ) else skip )  ;     i := i - 1 ) ) else skip ; 
    if (flag = 0) then (     OclFile["System.out"].println("-1") ) else (     OclFile["System.out"].println(val) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeforces762A {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    long n=Long.parseLong(st.nextToken());
    int k=Integer.parseInt(st.nextToken());
    ArrayList<Long>factors=getFactors(n);
    if(k>factors.size()){
      System.out.println(-1);
    }
    else {
      System.out.println(factors.get(k-1));
    }
  }
  static ArrayList<Long>getFactors(long n){
    ArrayList<Long>factors=new ArrayList<>();
    for(long i=1 ; i<=n/i ; ++i){
      if(n % i==0){
        factors.add(i);
        if(i!=n/i){
          factors.add(n/i);
        }
      }
    }
    Collections.sort(factors);
    return factors ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces762A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : long ; n := (st.next())->toLong() ;
    var k : int ; k := (st.next())->toInteger() ;
    var factors : Sequence(long) ; factors := getFactors(n) ;
    if (k > factors->size()) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(factors->at(k - 1+1)) ) ;  
 );
  static   operation getFactors( n : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var factors : Sequence(long) ; factors := Sequence{} ;
         var i : long ; i := 1 ; while i <= n / i do ( (     if (n mod i = 0) then (     factors := factors->including(i) ; 
     if (i /= n / i) then (     factors := factors->including(n / i) ) else skip ) else skip )  ;     i := i + 1 ) ; 
     factors := factors->sort() ; 
     return factors );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
import static java.lang.System.out ;
public class pre41 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    long n=obj.nextLong();
    int k=obj.nextInt();
    TreeSet<Long>set=new TreeSet<>();
    set.add(1l);
    for(long i=2 ; i*i<=n ; i++){
      if(n % i==0){
        set.add(n/i);
        set.add(i);
      }
    }
    set.add(n);
    if(k>set.size())out.println(-1);
    else out.println((long)set.toArray()[k-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre41 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var n : long ; n := obj.nextLong() ;
    var k : int ; k := obj.nextInt() ;
    var set : Set(long) ; set := Set{} ;
    set := set->including(1l) ; 
        var i : long ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     set := set->including(n / i) ; 
     set := set->including(i) ) else skip )  ;     i := i + 1 ) ; 
    set := set->including(n) ; 
    if (k > set->size()) then     out.println(-1) else     out.println(set->asSequence()[k - 1+1]->oclAsType(long)) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long n=in.nextLong();
    long k=in.nextLong();
    Vector<Long>vec=new Vector<>();
    for(long i=1 ; i*i<=n ; i++){
      if(n % i==0){
        vec.add(i);
        if(i!=n/i){
          vec.add(n/i);
        }
      }
    }
    Collections.sort(vec);
    if(k>vec.size())System.out.println(-1);
    else System.out.println(vec.get((int)(k-1)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toLong() ;
    var k : long ; k := in.getCurrent()->toLong() ;
    var vec : Sequence(long) ; vec := Sequence{} ;
        var i : long ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     vec := vec->including(i) ; 
     if (i /= n / i) then (     vec := vec->including(n / i) ) else skip ) else skip )  ;     i := i + 1 ) ; 
    vec := vec->sort() ; 
    if (k > vec->size()) then     OclFile["System.out"].println(-1) else     OclFile["System.out"].println(vec->at((k - 1)->oclAsType(int)+1)) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder res=new StringBuilder();
    int n=fs.nextInt();
    Set<Integer>set=new LinkedHashSet<>();
    int[] a=fs.readArray(n);
    for(int i=n-1 ; i>=0 ; i--){
      set.add(a[i]);
    }
    ArrayList<Integer>list=new ArrayList<>();
    for(int i : set)list.add(i);
    Collections.reverse(list);
    out.println(list.size());
    for(int i=0 ; i<list.size(); i++){
      out.print(list.get(i)+" ");
    }
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var res : String ; res := StringLib.newString() ;
    var n : int ; n := fs.nextInt() ;
    var set : Set(int) ; set := Set{} ;
    var a : Sequence(int) ; a := fs.readArray(n) ;
        var i : int ; i := (n)->char2byte() - 1 ; while i >= 0 do ( (     set := set->including(a[i+1]) )  ;     i := i - 1 ) ; 
    var list : Sequence(int) ; list := Sequence{} ;
    for (i : set) do (     list := list->including(i) ;  ) ; 
    list := list->reverse() ; 
    skip ; 
        var i : int ; i := 0 ; while i < list->size() do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printNumberWithDR(int k,int d){
    if(d==0 && k!=1)System.out.print("-1");
    else {
      System.out.print(d);
      k--;
      while(k-->0)System.out.print("0");
    }
  }
  public static void main(String[] args){
    int k=4,d=4 ;
    printNumberWithDR(k,d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printNumberWithDR( k : int, d : int) : void
  pre: true
  post: true
  activity: (     if (d = 0 & k /= 1) then     OclFile["System.out"].print("-1") ; else (     OclFile["System.out"].print(d) ; 
     k := k - 1 ; 
         while (k > 0) do (        k := k - 1 ;     skip ;     OclFile["System.out"].print("0") ; ;  ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 4 ;
    var d : int ; d := 4 ;
     execute printNumberWithDR(k, d) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a ;
    long b ;
    a=sc.nextLong();
    b=sc.nextLong();
    while(!(a==0 || b==0)){
      if(a>=(2*b))a=a-(a/(2*b))*(2*b);
      else {
        if(b>=(2*a))b=b-(b/(2*a))*(2*a);
        else break ;
      }
    }
    System.out.println(a+" "+b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ;
    var b : long ;
    a := sc.getCurrent()->toLong() ; 
    b := sc.getCurrent()->toLong() ; 
    while (not((a = 0 or b = 0))) do (     if (a >= (2 * b)) then     a := a - (a / (2 * b)) * (2 * b) ; else (     if (b >= (2 * a)) then     b := b - (b / (2 * a)) * (2 * a) ; else     break ) ) ; 
    OclFile["System.out"].println(a + " " + b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=1000000 ;
  static ArrayList<Integer>primes=new ArrayList<Integer>();
  static void Sieve(){
    int n=MAX ;
    int nNew=(int)Math.sqrt(n);
    int[] marked=new int[n/2+500];
    for(int i=1 ; i<=(nNew-1)/2 ; i++)for(int j=(i*(i+1))<<1 ; j<=n/2 ; j=j+2*i+1)marked[j]=1 ;
    primes.add(2);
    for(int i=1 ; i<=n/2 ; i++)if(marked[i]==0)primes.add(2*i+1);
  }
  static int binarySearch(int left,int right,int n){
    if(left<=right){
      int mid=(left+right)/2 ;
      if(mid==0 || mid==primes.size()-1)return primes.get(mid);
      if(primes.get(mid)==n)return primes.get(mid-1);
      if(primes.get(mid)<n && primes.get(mid+1)>n)return primes.get(mid);
      if(n<primes.get(mid))return binarySearch(left,mid-1,n);
      else return binarySearch(mid+1,right,n);
    }
    return 0 ;
  }
  public static void main(String[] args){
    Sieve();
    int n=17 ;
    System.out.println(binarySearch(0,primes.size()-1,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 1000000;
  static   attribute primes : Sequence(int) := Sequence{};
  static   operation Sieve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := MAX ;
     var nNew : int ; nNew := (n)->sqrt()->oclAsType(int) ;
    var marked : Sequence(int) ; marked := Integer.subrange(1,n / 2 + 500)->collect(0) ;
        var i : int ; i := 1 ; while i <= (nNew - 1) / 2 do (         var j : int ; j := ((i * (i + 1))*(2->pow(1)))->oclAsType(long) ; while j <= n / 2 do (     marked[j+1] := 1 ;  ;     j := j + 2 * i + 1 ) ;  ;     i := i + 1 ) ; 
    primes := primes->including(2) ; 
        var i : int ; i := 1 ; while i <= n / 2 do (     if (marked[i+1] = 0) then     primes := primes->including(2 * i + 1) ; else skip ;  ;     i := i + 1 ) ; 
 );
  static   operation binarySearch( left : int, right : int, n : int) : int
  pre: true
  post: true
  activity: (     if (left <= right) then (     var mid : int ; mid := (left + right) / 2 ;
     if (mid = 0 or mid = primes->size() - 1) then     return primes->at(mid+1) else skip ; 
    if (primes->at(mid+1) = n) then     return primes->at(mid - 1+1) else skip ; 
    if (primes->at(mid+1) < n & primes->at(mid + 1+1) > n) then     return primes->at(mid+1) else skip ; 
    if (n < primes->at(mid+1)) then     return binarySearch(left, mid - 1, n) else     return binarySearch(mid + 1, right, n) ;  
 ) else skip ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute Sieve() ; 
     var n : int ; n := 17 ;
     OclFile["System.out"].println(binarySearch(0, primes->size() - 1, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean valid(int[] cnt){
    for(int i=0 ; i<26 ; i++){
      if(cnt[i]>=2)return false ;
    }
    return true ;
  }
  static String getGoodString(String ss,int n){
    char[] s=ss.toCharArray();
    if(n<26)return "-1" ;
    int[] cnt=new int[27];
    for(int i=25 ; i<n ; i++){
      for(int j=i ; j>=i-25 ; j--){
        if(s[j]!='?')cnt[((int)s[j]-(int)'a')]++;
      }
      if(valid(cnt)){
        int cur=0 ;
        while(cnt[cur]>0)cur++;
        for(int j=i-25 ; j<=i ; j++){
          if(s[j]=='?'){
            s[j]=(char)(cur+(int)('a'));
            cur++;
            while(cnt[cur]>0)cur++;
          }
        }
        return new String(s);
      }
    }
    return "-1" ;
  }
  public static void main(String[] args){
    String s="abcdefghijkl?nopqrstuvwxy?" ;
    int n=s.length();
    System.out.println(getGoodString(s,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation valid( cnt : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 26 do ( (     if (cnt[i+1] >= 2) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation getGoodString( ss : String, n : int) : String
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := ss->characters() ;
     if (n < 26) then     return "-1" else skip ; 
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,27)->collect(0) ;
        var i : int ; i := 25 ; while i < n do ( (         var j : int ; j := i ; while j >= i - 25 do ( (     if (s[j+1] /= '?') then     cnt[(s[j+1]->oclAsType(int) - ('a')->char2byte())+1] := cnt[(s[j+1]->oclAsType(int) - ('a')->char2byte())+1] + 1 ; else skip )  ;     j := j - 1 ) ; 
     if (valid(cnt)) then (     var cur : int ; cur := 0 ;
     while (cnt[cur+1] > 0) do     cur := cur + 1 ; ; 
         var j : int ; j := i - 25 ; while j <= i do ( (     if (s[j+1] = '?') then (     s[j+1] := (cur + ('a')->oclAsType(int))->oclAsType(String) ; 
     cur := cur + 1 ; 
     while (cnt[cur+1] > 0) do     cur := cur + 1 ; ) else skip )  ;     j := j + 1 ) ; 
     return StringLib.newString(s) ) else skip )  ;     i := i + 1 ) ; 
    return "-1" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abcdefghijkl?nopqrstuvwxy?" ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].println(getGoodString(s, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Set ;
class GFG {
  static boolean isBinary(int number){
    Set<Integer>set=new HashSet<>();
    while(number>0){
      int digit=number % 10 ;
      set.add(digit);
      number/=10 ;
    }
    set.remove(0);
    set.remove(1);
    if(set.size()==0){
      return true ;
    }
    return false ;
  }
  public static void main(String a[]){
    int n=1000111 ;
    System.out.println(isBinary(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isBinary( number : int) : boolean
  pre: true
  post: true
  activity: (     var set : Set(int) ; set := Set{} ;
     while (number > 0) do (     var digit : int ; digit := number mod 10 ;
     set := set->including(digit) ; 
     number := number/(10) ) ; 
    set := set->excludingAt(0+1) ; 
    set := set->excludingAt(1+1) ; 
    if (set->size() = 0) then (     return true ) else skip ; 
    return false 
 );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1000111 ;
     OclFile["System.out"].println(isBinary(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Demo {
  public static int longestSubarray(int[] input){
    int prev=-1 ;
    int current,next ;
    int prevCount=0,currentCount=1 ;
    int longest=1 ;
    current=input[0];
    for(int i=1 ; i<input.length ; i++){
      next=input[i];
      if(next==current){
        currentCount++;
      }
      else if(next==prev){
        prevCount+=currentCount ;
        prev=current ;
        current=next ;
        currentCount=1 ;
      }
      else {
        longest=Math.max(longest,currentCount+prevCount);
        prev=current ;
        prevCount=currentCount ;
        current=next ;
        currentCount=1 ;
      }
    }
    return Math.max(longest,currentCount+prevCount);
  }
  public static void main(String[] args){
    int[] input={
      5,5,6,7,6 };
      System.out.println(longestSubarray(input));
    }
  }

------------------------------------------------------------
OCL File:
---------
class Demo {
  static   operation longestSubarray( input : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var prev : int ; prev := -1 ;
     var current : int ;
    var next : int ;
    var prevCount : int ; prevCount := 0 ;
    var currentCount : int ; currentCount := 1 ;
    var longest : int ; longest := 1 ;
    current := input[0+1] ; 
        var i : int ; i := 1 ; while i < input->size() do ( (     next := input[i+1] ; 
     if (next = current) then (     currentCount := currentCount + 1 ) else     if (next = prev) then (     prevCount := prevCount+(currentCount) ; 
     prev := current ; 
     current := next ; 
     currentCount := 1 ) else (     longest := Set{longest, currentCount + prevCount}->max() ; 
     prev := current ; 
    prevCount := currentCount ; 
    current := next ; 
    currentCount := 1 ; 
 ) ;  )  ;     i := i + 1 ) ; 
    return Set{longest, currentCount + prevCount}->max() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : Sequence(int) ; input := Sequence{5,5,6,7,6} ;
     OclFile["System.out"].println(longestSubarray(input)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void alphabetPattern(int N){
    int index,side_index ;
    int Top=1,Bottom=1,Diagonal=N-1 ;
    for(index=0 ; index<N ; index++)System.out.print(Top+++" ");
    System.out.println();
    for(index=1 ; index<N-1 ; index++){
      for(side_index=0 ; side_index<2*(N-index-1); side_index++)System.out.print(" ");
      System.out.print(Diagonal--);
      System.out.println();
    }
    for(index=0 ; index<N ; index++)System.out.print(Bottom+++" ");
  }
  public static void main(String args[]){
    int N=5 ;
    alphabetPattern(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation alphabetPattern( N : int) : void
  pre: true
  post: true
  activity: (     var index : int ;
    var side_index : int ;
     var Top : int ; Top := 1 ;
    var Bottom : int ; Bottom := 1 ;
    var Diagonal : int ; Diagonal := N - 1 ;
        index := 0 ; while index < N do (     OclFile["System.out"].print(Top + " ") ;  ;     index := index + 1 ) ; 
    OclFile["System.out"].println() ; 
        index := 1 ; while index < N - 1 do ( (         side_index := 0 ; while side_index < 2 * (N - index - 1) do (     OclFile["System.out"].print(" ") ;  ;     side_index := side_index + 1 ) ; 
     OclFile["System.out"].print(Diagonal) ; 
     OclFile["System.out"].println() )  ;     index := index + 1 ) ; 
        index := 0 ; while index < N do (     OclFile["System.out"].print(Bottom + " ") ;  ;     index := index + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     execute alphabetPattern(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minRotation(int input,int unlock_code){
    int rotation=0 ;
    int input_digit,code_digit ;
    while(input>0 || unlock_code>0){
      input_digit=input % 10 ;
      code_digit=unlock_code % 10 ;
      rotation+=Math.min(Math.abs(input_digit-code_digit),10-Math.abs(input_digit-code_digit));
      input/=10 ;
      unlock_code/=10 ;
    }
    return rotation ;
  }
  public static void main(String[] args){
    int input=28756 ;
    int unlock_code=98234 ;
    System.out.println("Minimum Rotation="+minRotation(input,unlock_code));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minRotation( input : int, unlock_code : int) : int
  pre: true
  post: true
  activity: (     var rotation : int ; rotation := 0 ;
     var input_digit : int ;
    var code_digit : int ;
     while (input > 0 or unlock_code > 0) do (     input_digit := input mod 10 ; 
     code_digit := unlock_code mod 10 ; 
    rotation := rotation+(Set{if input_digit - code_digit < 0 then -(input_digit - code_digit) else input_digit - code_digit endif, 10 - if input_digit - code_digit < 0 then -(input_digit - code_digit) else input_digit - code_digit endif}->min()) ; 
    input := input/(10) ; 
    unlock_code := unlock_code/(10) ; 
 ) ; 
     return rotation );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : int ; input := 28756 ;
     var unlock_code : int ; unlock_code := 98234 ;
     OclFile["System.out"].println("Minimum Rotation=" + minRotation(input, unlock_code)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class pre5 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int tc=obj.nextInt();
    while(tc--!=0){
      int n=obj.nextInt(),arr[]=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=obj.nextInt();
      Arrays.sort(arr);
      int i=0,j=n-1 ;
      ArrayList<Integer>ans=new ArrayList<>();
      while(i<=j){
        if(i==j){
          ans.add(arr[i]);
          break ;
        }
        ans.add(arr[j]);
        ans.add(arr[i]);
        i++;
        j--;
      }
      for(int ii=ans.size()-1 ; ii>=0 ; ii--)out.print(ans.get(ii)+" ");
      out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre5 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var tc : int ; tc := obj.nextInt() ;
         while (tc /= 0) do (    skip ; (     var n : int ; n := obj.nextInt() ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     arr[i+1] := obj.nextInt() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var i : int ; i := 0 ;
    var j : int ; j := n - 1 ;
    var ans : Sequence(int) ; ans := Sequence{} ;
    while (i <= j) do (     if (i = j) then (     ans := ans->including(arr[i+1]) ; 
     break ) else skip ; 
     ans := ans->including(arr[j+1]) ; 
    ans := ans->including(arr[i+1]) ; 
    i := i + 1 ; 
    j := j - 1 ; 
 ) ; 
        var ii : int ; ii := ans->size() - 1 ; while ii >= 0 do (     out.print(ans->at(ii+1) + " ") ;  ;     ii := ii - 1 ) ; 
    out.println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; ++i){
        a[i]=in.nextInt();
      }
      Arrays.sort(a);
      int[] b=new int[n];
      int c=0 ;
      for(int i=0 ; i<(n+1)/2 ; ++i){
        if(i!=n-i-1){
          b[c++]=a[i];
          b[c++]=a[n-i-1];
        }
        else {
          b[c++]=a[i];
        }
      }
      for(int i=n-1 ; i>=0 ; --i){
        System.out.print(b[i]+" ");
      }
      System.out.print("\n");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < (n + 1) / 2 do ( (     if (i /= n - i - 1) then (      b[c+1] := a[i+1]  ; c := c + 1 ; 
      b[c+1] := a[n - i - 1+1]  ; c := c + 1 ) else (      b[c+1] := a[i+1]  ; c := c + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     OclFile["System.out"].print(b[i+1] + " ") )  ;     i := i - 1 ) ; 
    OclFile["System.out"].print("\n") ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.nio.Buffer ;
import java.util.*;
public class Main2 {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int testCases=sc.nextInt();
    while(testCases-->0){
      int length=sc.nextInt();
      int[] array=new int[length];
      for(int i=0 ; i<length ; i++){
        array[i]=sc.nextInt();
      }
      Arrays.sort(array);
      LinkedList<Integer>output=new LinkedList<>();
      boolean min=true ;
      int i=0 ;
      int j=length-1 ;
      while(i<=j){
        if(min){
          output.addFirst(array[i]);
          i++;
        }
        else {
          output.addFirst(array[j]);
          j--;
        }
        min=! min ;
      }
      int k=0 ;
      for(int element : output){
        if(k!=0)System.out.print(" ");
        System.out.print(element);
        k++;
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := sc.getCurrent()->toInteger() ;
         while (testCases > 0) do (        testCases := testCases - 1 ;     skip ; (     var length : int ; length := sc.getCurrent()->toInteger() ;
     var array : Sequence(int) ; array := Integer.subrange(1,length)->collect(0) ;
        var i : int ; i := 0 ; while i < length do ( (     array[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    array := array->sort() ; 
    var output : Sequence(int) ; output := Sequence{} ;
    var min : boolean ; min := true ;
    var i : int ; i := 0 ;
    var j : int ; j := length - 1 ;
    while (i <= j) do (     if (min) then (     output := output->prepend(array[i+1]) ; 
     i := i + 1 ) else (     output := output->prepend(array[j+1]) ; 
     j := j - 1 ) ;  
     min := not(min) ) ; 
    var k : int ; k := 0 ;
    for (element : output) do ( (     if (k /= 0) then     OclFile["System.out"].print(" ") ; else skip ; 
     OclFile["System.out"].print(element) ; 
     k := k + 1 )  ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int N=3 ;
  static void rotateMatrix(int mat[][]){
    for(int i=N-1 ; i>=0 ; i--){
      for(int j=N-1 ; j>=0 ; j--)System.out.print(mat[i][j]+" ");
      System.out.println();
    }
  }
  public static void main(String[] args){
    int[][] mat={
      {
        1,2,3 },{
          4,5,6 },{
            7,8,9 }
          };
          rotateMatrix(mat);
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 3;
  static   operation rotateMatrix( mat : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := N - 1 ; while i >= 0 do ( (         var j : int ; j := N - 1 ; while j >= 0 do (     OclFile["System.out"].print(mat[i+1][j+1] + " ") ;  ;     j := j - 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,2,3},Sequence{4,5,6},Sequence{7,8,9}} ;
     execute rotateMatrix(mat) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  void run(){
    for(; ; ){
      int H=ni();
      if(H==0){
        break ;
      }
      int[][] field=new int[H][5];
      for(int i=0 ; i<H ; ++i){
        for(int j=0 ; j<5 ; ++j){
          field[i][j]=ni();
        }
      }
      int ans=0 ;
      for(; ; ){
        int sum=0 ;
        for(int i=0 ; i<H ; ++i){
          for(int j=0 ; j<3 ; ++j){
            int v=field[i][j];
            boolean del=true ;
            for(int k=1 ; k<3 ; ++k){
              del &=field[i][j+k]==v ;
            }
            if(del){
              for(int k=0 ; j+k<5 ; ++k){
                if(field[i][j+k]!=v){
                  break ;
                }
                sum+=v ;
                field[i][j+k]=0 ;
                for(int l=i ; 0<l ; --l){
                  field[l][j+k]=field[l-1][j+k];
                }
                field[0][j+k]=0 ;
              }
              break ;
            }
          }
        }
        if(sum==0){
          break ;
        }
        ans+=sum ;
      }
      System.out.println(ans);
    }
  }
  Main(){
    sc=new Scanner(System.in);
  }
  int ni(){
    return sc.nextInt();
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var H : int ; H := ni() ;
     if (H = 0) then (     break ) else skip ; 
    var field : Sequence(Sequence(int)) ; field := Integer.subrange(1,H)->collect(Integer.subrange(1,5)->collect(0)) ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < 5 do ( (     field[i+1][j+1] := ni() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
      while true do ( (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < 3 do ( (     var v : int ; v := field[i+1][j+1] ;
     var del : boolean ; del := true ;
         var k : int ; k := 1 ; while k < 3 do ( (     del := MathLib.bitwiseAnd(del, field[i+1][j + k+1] = v) )  ;     k := k + 1 ) ; 
     if (del) then (         var k : int ; k := 0 ; while j + k < 5 do ( (     if (field[i+1][j + k+1] /= v) then (     break ) else skip ; 
     sum := sum+(v) ; 
    field[i+1][j + k+1] := 0 ; 
        var l : int ; l := i ; while 0 < l do ( (     field[l+1][j + k+1] := field[l - 1+1][j + k+1] )  ;     l := l - 1 ) ; 
    field[0+1][j + k+1] := 0 ; 
 )  ;     k := k + 1 ) ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (sum = 0) then (     break ) else skip ; 
     ans := ans+(sum) )  ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ) );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Countdown {
  private static BigInteger revertNum(BigInteger input){
    StringBuilder stringBuilder=new StringBuilder(input.toString());
    stringBuilder.reverse();
    return new BigInteger(String.valueOf(stringBuilder));
  }
  private static int clock(int a,BigInteger b){
    int i=0 ;
    int count=0 ;
    if(b.equals(BigInteger.ZERO)){
      return 0 ;
    }
    while(i<a){
      BigInteger temp=b.mod(BigInteger.valueOf(10));
      if(! temp.equals(BigInteger.valueOf(0))){
        count++;
        b=b.subtract(BigInteger.valueOf(1));
      }
      else {
        i++;
        b=revertNum(b);
        count++;
      }
      if(b.equals(BigInteger.ZERO)){
        break ;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int len=scanner.nextInt();
    while(len-->0){
      int a=scanner.nextInt();
      BigInteger b=scanner.nextBigInteger();
      System.out.println(clock(a,b));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Countdown {
  static   operation revertNum( input : long) : long
  pre: true
  post: true
  activity: (     var stringBuilder : String ; stringBuilder := StringLib.newString(input+"") ;
     stringBuilder := stringBuilder->reverse() ; 
     return long(((stringBuilder) + "")) );
  static   operation clock( a : int, b : long) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var count : int ; count := 0 ;
    if (b = 0) then (     return 0 ) else skip ; 
    while (i < a) do (     var temp : long ; temp := b.mod((10 + "")->toLong()) ;
     if (not(temp = (0 + "")->toLong())) then (     count := count + 1 ; 
     b := b.subtract((1 + "")->toLong()) ) else (     i := i + 1 ; 
     b := revertNum(b) ; 
     count := count + 1 ) ;  
     if (b = 0) then (     break ) else skip ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := scanner.getCurrent()->toInteger() ;
         while (len > 0) do (        len := len - 1 ;     skip ; (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : long ; b := scanner.nextBigInteger() ;
     OclFile["System.out"].println(clock(a, b)) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    while(h!=0){
      int[][] s=new int[h+1][5];
      for(int i=1 ; i<=h ; i++){
        for(int j=0 ; j<5 ; j++){
          s[i][j]=sc.nextInt();
        }
      }
      int res=0 ;
      boolean flg=true ;
      while(flg){
        flg=false ;
        for(int i=1 ; i<=h ; i++){
          for(int j=0 ; j<3 ; j++){
            int cnt=1 ;
            for(int k=j+1 ; k<5 ; k++){
              if(s[i][j]>0 && s[i][j]==s[i][k]){
                cnt=cnt+1 ;
              }
              else {
                break ;
              }
            }
            if(cnt>2){
              flg=true ;
              res+=s[i][j]*cnt ;
              for(int k=j ; k<j+cnt ; k++){
                for(int l=i ; l>0 ; l--){
                  s[l][k]=s[l-1][k];
                }
              }
              break ;
            }
          }
        }
      }
      System.out.println(res);
      h=sc.nextInt();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
     while (h /= 0) do (     var s : Sequence(Sequence(int)) ; s := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,5)->collect(0)) ;
         var i : int ; i := 1 ; while i <= h do ( (         var j : int ; j := 0 ; while j < 5 do ( (     s[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    var flg : boolean ; flg := true ;
    while (flg) do (     flg := false ; 
         var i : int ; i := 1 ; while i <= h do ( (         var j : int ; j := 0 ; while j < 3 do ( (     var cnt : int ; cnt := 1 ;
         var k : int ; k := j + 1 ; while k < 5 do ( (     if (s[i+1][j+1] > 0 & s[i+1][j+1] = s[i+1][k+1]) then (     cnt := cnt + 1 ) else (     break ) )  ;     k := k + 1 ) ; 
     if (cnt > 2) then (     flg := true ; 
     res := res+(s[i+1][j+1] * cnt) ; 
         var k : int ; k := j ; while k < j + cnt do ( (         var l : int ; l := i ; while l > 0 do ( (     s[l+1][k+1] := s[l - 1+1][k+1] )  ;     l := l - 1 ) )  ;     k := k + 1 ) ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) ; 
    OclFile["System.out"].println(res) ; 
    h := sc.getCurrent()->toInteger() ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  int ex(int src,int ratio){
    return(src*(100+ratio))/100 ;
  }
  void run(){
    for(; ; ){
      int h=ni();
      if(h==0){
        break ;
      }
      int[][] f=new int[h][5];
      for(int i=0 ; i<h ; ++i){
        for(int j=0 ; j<5 ; ++j){
          f[i][j]=ni();
        }
      }
      int score=0 ;
      for(; ; ){
        int cnt=0 ;
        for(int i=0 ; i<h ; ++i){
          for(int j=0 ; j<3 ; ++j){
            int v=f[i][j];
            boolean flag=true ;
            for(int k=0 ; k<3 ; ++k){
              flag &=f[i][j+k]==v ;
            }
            if(flag){
              for(int k=j ; k<5 ; ++k){
                if(f[i][k]!=v){
                  break ;
                }
                cnt+=v ;
                for(int l=i ; l>0 ; --l){
                  f[l][k]=f[l-1][k];
                }
                f[0][k]=0 ;
              }
              break ;
            }
          }
        }
        if(cnt==0){
          break ;
        }
        score+=cnt ;
      }
      System.out.println(score);
    }
  }
  Main(){
    sc=new Scanner(System.in);
  }
  int ni(){
    return sc.nextInt();
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   operation ex( src : int, ratio : int) : int
  pre: true
  post: true
  activity: (     return (src * (100 + ratio)) / 100 );
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var h : int ; h := ni() ;
     if (h = 0) then (     break ) else skip ; 
    var f : Sequence(Sequence(int)) ; f := Integer.subrange(1,h)->collect(Integer.subrange(1,5)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < 5 do ( (     f[i+1][j+1] := ni() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var score : int ; score := 0 ;
      while true do ( (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < 3 do ( (     var v : int ; v := f[i+1][j+1] ;
     var flag : boolean ; flag := true ;
         var k : int ; k := 0 ; while k < 3 do ( (     flag := MathLib.bitwiseAnd(flag, f[i+1][j + k+1] = v) )  ;     k := k + 1 ) ; 
     if (flag) then (         var k : int ; k := j ; while k < 5 do ( (     if (f[i+1][k+1] /= v) then (     break ) else skip ; 
     cnt := cnt+(v) ; 
         var l : int ; l := i ; while l > 0 do ( (     f[l+1][k+1] := f[l - 1+1][k+1] )  ;     l := l - 1 ) ; 
     f[0+1][k+1] := 0 )  ;     k := k + 1 ) ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (cnt = 0) then (     break ) else skip ; 
     score := score+(cnt) )  ) ; 
    OclFile["System.out"].println(score) ; 
 )  ) );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int H ;
  static int[][] stone=new int[11][6];
  static int search(){
    int len ;
    int point=0 ;
    for(int row=0 ; row<H ; row++){
      for(int col=0 ; col<=2 ; col++){
        for(len=1 ; col+len<=4 ; len++){
          if(stone[row][col]!=stone[row][col+len]){
            break ;
          }
        }
        if(len<=2){
          continue ;
        }
        point+=stone[row][col]*len ;
        for(int i=0 ; i<len ; i++){
          stone[row][col+i]=0 ;
        }
      }
    }
    return point ;
  }
  static void change(){
    for(int col=0 ; col<5 ; col++){
      for(int min=1 ; min<H ; min++){
        for(int row=H-1 ; row>=min ; row--){
          if(stone[row][col]==0){
            stone[row][col]=stone[row-1][col];
            stone[row-1][col]=0 ;
          }
        }
      }
    }
  }
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      while(sc.hasNext()){
        H=sc.nextInt();
        if(H==0)break ;
        for(int i=0 ; i<H ; i++){
          for(int j=0 ; j<5 ; j++){
            stone[i][j]=sc.nextInt();
          }
        }
        int sum=0 ;
        int cont ;
        while(true){
          cont=search();
          if(cont==0){
            System.out.println(sum);
            break ;
          }
          sum+=cont ;
          change();
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute H : int;
  static   attribute stone : Sequence(Sequence(int)) := Integer.subrange(1,11)->collect(Integer.subrange(1,6)->collect(0));
  static   operation search() : int
  pre: true
  post: true
  activity: (     var len : int ;
     var point : int ; point := 0 ;
         var row : int ; row := 0 ; while row < H do ( (         var col : int ; col := 0 ; while col <= 2 do ( (         len := 1 ; while col + len <= 4 do ( (     if (stone[row+1][col+1] /= stone[row+1][col + len+1]) then (     break ) else skip )  ;     len := len + 1 ) ; 
     if (len <= 2) then (     continue ) else skip ; 
     point := point+(stone[row+1][col+1] * len) ; 
         var i : int ; i := 0 ; while i < len do ( (     stone[row+1][col + i+1] := 0 )  ;     i := i + 1 ) )  ;     col := col + 1 ) )  ;     row := row + 1 ) ; 
     return point );
  static   operation change() : void
  pre: true
  post: true
  activity: (         var col : int ; col := 0 ; while col < 5 do ( (         var min : int ; min := 1 ; while min < H do ( (         var row : int ; row := H - 1 ; while row >= min do ( (     if (stone[row+1][col+1] = 0) then (     stone[row+1][col+1] := stone[row - 1+1][col+1] ; 
     stone[row - 1+1][col+1] := 0 ) else skip )  ;     row := row - 1 ) )  ;     min := min + 1 ) )  ;     col := col + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (sc.hasNext()) do (     H := sc.getCurrent()->toInteger() ; 
     if (H = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < 5 do ( (     stone[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var cont : int ;
    while (true) do (     cont := search() ; 
     if (cont = 0) then (     OclFile["System.out"].println(sum) ; 
     break ) else skip ; 
     sum := sum+(cont) ; 
     execute change() ) ; 
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int a[];
  static int search(int a[],int k,int x){
    int j ;
    for(j=k-1 ; j>-1 ; j--){
      if(a[j]==x)return j ;
    }
    return-1 ;
  }
  static void genArray(int[] arr,int N){
    for(int i=0 ; i<N-1 ; i++){
      if(search(arr,i,arr[i])==-1)arr[i+1]=0 ;
      else arr[i+1]=(i-search(arr,i,arr[i]));
    }
  }
  public static void main(String[] args){
    int N=5 ;
    int size=N+1 ;
    int a[]=new int[N];
    genArray(a,N);
    for(int i=0 ; i<N ; i++)System.out.print(a[i]+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute a : Sequence(int);
  static   operation search( a : Sequence(int), k : int, x : int) : int
  pre: true
  post: true
  activity: (     var j : int ;
         j := k - 1 ; while j > -1 do ( (     if (a[j+1] = x) then     return j else skip )  ;     j := j - 1 ) ; 
     return -1 );
  static   operation genArray( arr : Sequence(int), N : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N - 1 do ( (     if (search(arr, i, arr[i+1]) = -1) then     arr[i + 1+1] := 0 ; else     arr[i + 1+1] := (i - search(arr, i, arr[i+1])) ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     var size : int ; size := N + 1 ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    execute genArray(a, N) ; 
        var i : int ; i := 0 ; while i < N do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int ans=0 ;
  static Vector<Vector<Integer>>graph=new Vector<Vector<Integer>>();
  static Vector<Integer>weight=new Vector<Integer>();
  static boolean isEvenParity(int x){
    int parity=0 ;
    while(x!=0){
      x=x &(x-1);
      parity++;
    }
    if(parity % 2==0)return true ;
    else return false ;
  }
  static void dfs(int node,int parent){
    if(isEvenParity(weight.get(node)))ans+=1 ;
    for(int i=0 ; i<graph.get(node).size(); i++){
      if(graph.get(node).get(i)==parent)continue ;
      dfs(graph.get(node).get(i),node);
    }
  }
  public static void main(String args[]){
    weight.add(0);
    weight.add(5);
    weight.add(10);
    ;
    weight.add(11);
    ;
    weight.add(8);
    weight.add(6);
    for(int i=0 ; i<100 ; i++)graph.add(new Vector<Integer>());
    graph.get(1).add(2);
    graph.get(2).add(3);
    graph.get(2).add(4);
    graph.get(1).add(5);
    dfs(1,1);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute ans : int := 0;
  static   attribute graph : Sequence(Sequence(int)) := Sequence{};
  static   attribute weight : Sequence(int) := Sequence{};
  static   operation isEvenParity( x : int) : boolean
  pre: true
  post: true
  activity: (     var parity : int ; parity := 0 ;
     while (x /= 0) do (     x := x & (x - 1) ; 
     parity := parity + 1 ) ; 
     if (parity mod 2 = 0) then     return true else     return false );
  static   operation dfs( node : int, parent : int) : void
  pre: true
  post: true
  activity: (     if (isEvenParity(weight->at(node+1))) then     ans := ans+(1) ; else skip ; 
         var i : int ; i := 0 ; while i < graph->at(node+1)->size() do ( (     if (graph->at(node+1)->at(i+1) = parent) then     continue else skip ; 
     execute dfs(graph->at(node+1)->at(i+1), node) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     weight := weight->including(0) ; 
     weight := weight->including(5) ; 
    weight := weight->including(10) ; 
    weight := weight->including(11) ; 
    weight := weight->including(8) ; 
    weight := weight->including(6) ; 
        var i : int ; i := 0 ; while i < 100 do (     graph := graph->including(Sequence{}) ;  ;     i := i + 1 ) ; 
    graph->at(1+1)->excludes(2) ; 
    graph->at(2+1)->excludes(3) ; 
    graph->at(2+1)->excludes(4) ; 
    graph->at(1+1)->excludes(5) ; 
    execute dfs(1, 1) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isVowel(char c){
    return(c=='a' || c=='A' || c=='e' || c=='E' || c=='i' || c=='I' || c=='o' || c=='O' || c=='u' || c=='U');
  }
  static String reverseVowel(String str){
    int i=0 ;
    int j=str.length()-1 ;
    char[] str1=str.toCharArray();
    while(i<j){
      if(! isVowel(str1[i])){
        i++;
        continue ;
      }
      if(! isVowel(str1[j])){
        j--;
        continue ;
      }
      char t=str1[i];
      str1[i]=str1[j];
      str1[j]=t ;
      i++;
      j--;
    }
    String str2=String.copyValueOf(str1);
    return str2 ;
  }
  public static void main(String[] args){
    String str="hello world" ;
    System.out.println(reverseVowel(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isVowel( c : String) : boolean
  pre: true
  post: true
  activity: (     return (c = 'a' or c = 'A' or c = 'e' or c = 'E' or c = 'i' or c = 'I' or c = 'o' or c = 'O' or c = 'u' or c = 'U') );
  static   operation reverseVowel( str : String) : String
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var j : int ; j := str->size() - 1 ;
    var str1 : Sequence(String) ; str1 := str->characters() ;
    while (i < j) do (     if (not(isVowel(str1[i+1]))) then (     i := i + 1 ; 
     continue ) else skip ; 
     if (not(isVowel(str1[j+1]))) then (     j := j - 1 ; 
     continue ) else skip ; 
    var t : String ; t := str1[i+1] ;
    str1[i+1] := str1[j+1] ; 
    str1[j+1] := t ; 
    i := i + 1 ; 
    j := j - 1 ; 
 ) ; 
    var str2 : String ; str2 := (str1)->sum() ;
    return str2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "hello world" ;
     OclFile["System.out"].println(reverseVowel(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static boolean areAllBitsSet(long n){
    if(n==0)return false ;
    if(((n+1)& n)==0)return true ;
    return false ;
  }
  public static boolean isOnesComplementOfOther(long a,long b){
    return areAllBitsSet(a ^ b);
  }
  public static void main(String argc[]){
    long a=10,b=5 ;
    if(isOnesComplementOfOther(a,b))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation areAllBitsSet( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n = 0) then     return false else skip ; 
     if (((n + 1) & n) = 0) then     return true else skip ; 
     return false );
  static   operation isOnesComplementOfOther( a : long, b : long) : boolean
  pre: true
  post: true
  activity: (     return areAllBitsSet(a xor b) );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ; a := 10 ;
    var b : long ; b := 5 ;
     if (isOnesComplementOfOther(a, b)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int SIZE=26 ;
  static void SieveOfEratosthenes(boolean[] prime,int p_size){
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=p_size ; p++){
      if(prime[p]){
        for(int i=p*2 ; i<p_size ; i+=p)prime[i]=false ;
      }
    }
  }
  static void printChar(String str,int n){
    boolean[] prime=new boolean[n+1];
    for(int i=0 ; i<n+1 ; i++)prime[i]=true ;
    SieveOfEratosthenes(prime,str.length()+1);
    int[] freq=new int[SIZE];
    for(int i=0 ; i<SIZE ; i++)freq[i]=0 ;
    for(int i=0 ; i<n ; i++)freq[str.charAt(i)-'a']++;
    for(int i=0 ; i<n ; i++){
      if(prime[freq[str.charAt(i)-'a'] ]){
        System.out.print(str.charAt(i));
      }
    }
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    int n=str.length();
    printChar(str,n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute SIZE : int := 26;
  static   operation SieveOfEratosthenes( prime : Sequence(boolean), p_size : int) : void
  pre: true
  post: true
  activity: (     prime[0+1] := false ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p <= p_size do ( (     if (prime[p+1]) then (         var i : int ; i := p * 2 ; while i < p_size do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation printChar( str : String, n : int) : void
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,n + 1)->collect(false) ;
         var i : int ; i := 0 ; while i < n + 1 do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
    execute SieveOfEratosthenes(prime, str->size() + 1) ; 
    var freq : Sequence(int) ; freq := Integer.subrange(1,SIZE)->collect(0) ;
        var i : int ; i := 0 ; while i < SIZE do (     freq[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     freq[str->at(i+1) - ('a')->char2byte()+1] := freq[str->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (prime[freq[str->at(i+1) - ('a')->char2byte()+1]+1]) then (     OclFile["System.out"].print(str->at(i+1)) ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var n : int ; n := str->size() ;
     execute printChar(str, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int p=sc.nextInt();
    System.out.println(p/500*500);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : int ; p := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(p / 500 * 500) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    InputReader in=new InputReader();
    int N=in.nextInt();
    int M=in.nextInt();
    int[] A=new int[N];
    int[] B=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=in.nextInt();
    }
    for(int i=0 ; i<N ; i++){
      B[i]=in.nextInt();
    }
    Arrays.sort(A);
    Arrays.sort(B);
    int ans=Integer.MAX_VALUE ;
    for(int i=0 ; i<N ; i++){
      int x=0 ;
      if(A[0]<B[i]){
        x=B[i]-A[0];
      }
      else if(A[0]>B[i]){
        x=M-A[0]+B[i];
      }
      boolean flag=true ;
      for(int j=0 ; j<N ; j++){
        if((A[j]+x)% M!=B[(i+j)% N]){
          flag=false ;
          break ;
        }
      }
      if(flag){
        ans=Math.min(ans,x);
      }
    }
    System.out.println(ans);
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer st ;
    public InputReader(){
      reader=new BufferedReader(new InputStreamReader(System.in));
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        st=new StringTokenizer(nextLine());
      }
      return st.nextToken();
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return null ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : InputReader ; in := InputReader.newInputReader() ;
     var N : int ; N := in.nextInt() ;
    var M : int ; M := in.nextInt() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     B[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    B := B->sort() ; 
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i < N do ( (     var x : int ; x := 0 ;
     if (A[0+1] < B[i+1]) then (     x := B[i+1] - A[0+1] ) else     if (A[0+1] > B[i+1]) then (     x := M - A[0+1] + B[i+1] ) else skip ; ;  
    var flag : boolean ; flag := true ;
        var j : int ; j := 0 ; while j < N do ( (     if ((A[j+1] + x) mod M /= B[(i + j) mod N+1]) then (     flag := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (flag) then (     ans := Set{ans, x}->min() ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute st : OclIterator;
   static operation newInputReader() : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(nextLine()) ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class B1269 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int mod=in.nextInt();
    int[] A=new int[N];
    for(int n=0 ; n<N ; n++){
      A[n]=in.nextInt();
    }
    Map<Integer,Integer>targetMap=new HashMap<>();
    for(int n=0 ; n<N ; n++){
      int b=in.nextInt();
      int count=targetMap.getOrDefault(b,0);
      targetMap.put(b,count+1);
    }
    int minShift=Integer.MAX_VALUE ;
    for(int target : targetMap.keySet()){
      int shift=target-A[0];
      if(shift<0)shift+=mod ;
      Map<Integer,Integer>map=new HashMap<>();
      for(int a : A){
        int b=(a+shift)% mod ;
        int count=map.getOrDefault(b,0);
        map.put(b,count+1);
      }
      boolean ok=true ;
      for(Map.Entry<Integer,Integer>entry : map.entrySet()){
        if(! entry.getValue().equals(targetMap.getOrDefault(entry.getKey(),0))){
          ok=false ;
          break ;
        }
      }
      if(ok){
        minShift=Math.min(minShift,shift);
      }
    }
    System.out.println(minShift);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1269 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var mod : int ; mod := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var targetMap : Map(int,int) ; targetMap := Map{} ;
        var n : int ; n := 0 ; while n < N do ( (     var b : int ; b := in.getCurrent()->toInteger() ;
     var count : int ; count := (if targetMap->keys()->contains(b) then targetMap->at(b) else 0 endif) ;
     targetMap := targetMap->union(Map{b |-> count + 1}) )  ;     n := n + 1 ) ; 
    var minShift : int ; minShift := 2147483647 ;
    for (target : targetMap->keys()) do ( (     var shift : int ; shift := target - A[0+1] ;
     if (shift < 0) then     shift := shift+(mod) ; else skip ; 
    var map : Map(int,int) ; map := Map{} ;
    for (a : A) do ( (     var b : int ; b := (a + shift) mod mod ;
     var count : int ; count := (if map->keys()->contains(b) then map->at(b) else 0 endif) ;
     map := map->union(Map{b |-> count + 1}) )  ) ; 
    var ok : boolean ; ok := true ;
    for (entry : map->asSet()) do ( (     if (not(entry.getValue() = (if targetMap->keys()->contains(entry.getKey()) then targetMap->at(entry.getKey()) else 0 endif))) then (     ok := false ; 
     break ) else skip )  ) ; 
    if (ok) then (     minShift := Set{minShift, shift}->min() ) else skip ; 
 )  ) ; 
    OclFile["System.out"].println(minShift) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ACountdown solver=new ACountdown();
    solver.solve(1,in,out);
    out.close();
  }
  static class ACountdown {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int t=in.nextInt();
      while(t-->0){
        int n=in.nextInt();
        char[] ar=in.next().toCharArray();
        int res=0 ;
        for(char c : ar){
          res+=c-48 ;
          if(c!='0')res++;
        }
        if(ar[n-1]!='0')res--;
        out.println(res);
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ACountdown ; solver := ACountdown.newACountdown() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ACountdown {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var t : int ; t := in.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.nextInt() ;
     var ar : Sequence(String) ; ar := in.next()->characters() ;
    var res : int ; res := 0 ;
    for (c : ar) do ( (     res := res+(c - 48) ; 
     if (c /= '0') then     res := res + 1 ; else skip )  ) ; 
    if (ar[n - 1+1] /= '0') then     res := res - 1 ; else skip ; 
    skip ; 
 ) ;  ) );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Main(){
  }
  public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    int a=0 ;
    int b=0 ;
    int c=0 ;
    int tmpB=0 ;
    int tmpC=0 ;
    a=scanner.nextInt();
    b=scanner.nextInt();
    c=scanner.nextInt();
    if(a>b){
      tmpB=b ;
      b=a ;
      a=tmpB ;
    }
    if(b>c){
      tmpC=c ;
      c=b ;
      b=tmpC ;
    }
    if(a>b){
      tmpB=b ;
      b=a ;
      a=tmpB ;
    }
    System.out.println(a+" "+b+" "+c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := 0 ;
    var b : int ; b := 0 ;
    var c : int ; c := 0 ;
    var tmpB : int ; tmpB := 0 ;
    var tmpC : int ; tmpC := 0 ;
    a := scanner.getCurrent()->toInteger() ; 
    b := scanner.getCurrent()->toInteger() ; 
    c := scanner.getCurrent()->toInteger() ; 
    if (a > b) then (     tmpB := b ; 
     b := a ; 
     a := tmpB ) else skip ; 
    if (b > c) then (     tmpC := c ; 
     c := b ; 
     b := tmpC ) else skip ; 
    if (a > b) then (     tmpB := b ; 
     b := a ; 
     a := tmpB ) else skip ; 
    OclFile["System.out"].println(a + " " + b + " " + c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
public class Main {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      InputData inputData=new InputData(br);
      Processing processing=new Processing(inputData);
      System.out.println(processing.getResult());
    }
    catch(IOException | NumberFormatException e){
      System.err.println(e.getLocalizedMessage());
    }
  }
}
class InputData {
  private Integer a ;
  private Integer b ;
  private Integer c ;
  public InputData(BufferedReader br)throws IOException {
    String line=br.readLine().trim();
    String[] values=line.split(" ");
    this.a=Integer.valueOf(values[0]);
    this.b=Integer.valueOf(values[1]);
    this.c=Integer.valueOf(values[2]);
  }
  public Integer getA(){
    return a ;
  }
  public void setA(Integer a){
    this.a=a ;
  }
  public Integer getB(){
    return b ;
  }
  public void setB(Integer b){
    this.b=b ;
  }
  public Integer getC(){
    return c ;
  }
  public void setC(Integer c){
    this.c=c ;
  }
}
class Processing {
  private InputData inputData ;
  public Processing(InputData inputData){
    this.inputData=inputData ;
  }
  public String getResult(){
    String result=null ;
    List<Integer>list=new ArrayList<>();
    list.add(this.inputData.getA());
    list.add(this.inputData.getB());
    list.add(this.inputData.getC());
    Collections.sort(list);
    StringBuilder sb=new StringBuilder();
    for(Integer i : list){
      sb.append(i);
      sb.append(" ");
    }
    result=sb.toString().trim();
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var inputData : InputData ; inputData := InputData.newInputData(br) ;
     var processing : Processing ; processing := Processing.newProcessing(inputData) ;
     OclFile["System.out"].println(processing.getResult()) )   catch (e : OclException) do (     OclFile["System.err"].println(e.getLocalizedMessage()) )
 );
}
class InputData {
   attribute a : int;
   attribute b : int;
   attribute c : int;
   static operation newInputData( br : OclFile) : InputData
  pre: true
  post: true
  activity:
  ( var self : InputData ;
    self := createInputData();
    self.initialise(br);
    return self );
  operation initialise( br : OclFile) : void
  pre: true  post: true
  activity: (     var line : String ; line := br.readLine()->trim() ;
     var values : Sequence(String) ; values := line->split(" ") ;
    self.a := (values[0+1])->toInteger() ; 
    self.b := (values[1+1])->toInteger() ; 
    self.c := (values[2+1])->toInteger() ; 
 );
   operation getA() : int
  pre: true
  post: true
  activity: (     return a );
   operation setA( a : int) : void
  pre: true
  post: true
  activity: (     self.a := a );
   operation getB() : int
  pre: true
  post: true
  activity: (     return b );
   operation setB( b : int) : void
  pre: true
  post: true
  activity: (     self.b := b );
   operation getC() : int
  pre: true
  post: true
  activity: (     return c );
   operation setC( c : int) : void
  pre: true
  post: true
  activity: (     self.c := c );
}
class Processing {
   attribute inputData : InputData;
   static operation newProcessing( inputData : InputData) : Processing
  pre: true
  post: true
  activity:
  ( var self : Processing ;
    self := createProcessing();
    self.initialise(inputData);
    return self );
  operation initialise( inputData : InputData) : void
  pre: true  post: true
  activity: (     self.inputData := inputData );
   operation getResult() : String
  pre: true
  post: true
  activity: (     var result : String ; result := null ;
     var list : Sequence(int) ; list := Sequence{} ;
    list := list->including(self.inputData.getA()) ; 
    list := list->including(self.inputData.getB()) ; 
    list := list->including(self.inputData.getC()) ; 
    list := list->sort() ; 
    var sb : String ; sb := StringLib.newString() ;
    for (i : list) do ( (     sb := sb + StringLib.newString(i) ; 
     sb := sb + StringLib.newString(" ") )  ) ; 
    result := sb+""->trim() ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  Scanner sc=new Scanner(System.in);
  void main(){
    int[] a=new int[3];
    for(int i=0 ; i<3 ; i++)a[i]=sc.nextInt();
    for(int i=0 ; i<2 ; i++){
      int min=i ;
      for(int j=i ; j<3 ; j++){
        if(a[min]>a[j]){
          int c=a[min];
          a[min]=a[j];
          a[j]=c ;
        }
      }
    }
    for(int i=0 ; i<2 ; i++)System.out.print(a[i]+" ");
    System.out.println(a[2]);
  }
  public static void main(String[] ag){
    new Main().main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation main() : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
         var i : int ; i := 0 ; while i < 3 do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 2 do ( (     var min : int ; min := i ;
         var j : int ; j := i ; while j < 3 do ( (     if (a[min+1] > a[j+1]) then (     var c : int ; c := a[min+1] ;
     a[min+1] := a[j+1] ; 
     a[j+1] := c ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 2 do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a[2+1]) ; 
 );
  static   operation main( ag : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().main() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public static void main(String[] args){
    String input=new java.util.Scanner(System.in).nextLine();
    String[] words=input.split("\\s");
    int[] data=new int[3];
    for(int i=0 ; i<words.length ; i++){
      data[i]=Integer.parseInt(words[i]);
    }
    for(int i=0 ; i<data.length-1 ; i++){
      for(int j=0 ; j<(data.length-1)-i ; j++){
        if(data[j]>data[j+1]){
          int temp=data[j];
          data[j]=data[j+1];
          data[j+1]=temp ;
        }
      }
    }
    for(int i=0 ; i<data.length ; i++){
      System.out.print(data[i]);
      if(i!=(data.length-1)){
        System.out.print(" ");
      }
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : String ; input := Scanner.newScanner(OclFile["System.in"]).nextLine() ;
     var words : Sequence(String) ; words := input->split("\\s") ;
    var data : Sequence(int) ; data := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < words->size() do ( (     data[i+1] := (words[i+1])->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < data->size() - 1 do ( (         var j : int ; j := 0 ; while j < (data->size() - 1) - i do ( (     if (data[j+1] > data[j + 1+1]) then (     var temp : int ; temp := data[j+1] ;
     data[j+1] := data[j + 1+1] ; 
     data[j + 1+1] := temp ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < data->size() do ( (     OclFile["System.out"].print(data[i+1]) ; 
     if (i /= (data->size() - 1)) then (     OclFile["System.out"].print(" ") ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(isr);
    String strNum=br.readLine();
    String[] strNumList=strNum.split(" ");
    Arrays.sort(strNumList);
    int intNumSmall=Integer.parseInt(strNumList[0]);
    int intNumMiddle=Integer.parseInt(strNumList[1]);
    int intNumlarge=Integer.parseInt(strNumList[2]);
    System.out.println(intNumSmall+" "+intNumMiddle+" "+intNumlarge);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
    var strNum : String ; strNum := br.readLine() ;
    var strNumList : Sequence(String) ; strNumList := strNum->split(" ") ;
    strNumList := strNumList->sort() ; 
    var intNumSmall : int ; intNumSmall := (strNumList[0+1])->toInteger() ;
    var intNumMiddle : int ; intNumMiddle := (strNumList[1+1])->toInteger() ;
    var intNumlarge : int ; intNumlarge := (strNumList[2+1])->toInteger() ;
    OclFile["System.out"].println(intNumSmall + " " + intNumMiddle + " " + intNumlarge) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    boolean[] primes=new boolean[50001];
    Arrays.fill(primes,true);
    for(int i=2 ; i<50001 ; i++){
      if(primes[i]){
        for(int j=2 ; j<=50000/i ; j++){
          if(primes[i*j]){
            primes[i*j]=false ;
          }
        }
      }
    }
    while(!(line=br.readLine()).equals("0")){
      int n=Integer.parseInt(line);
      int c=0 ;
      for(int i=2 ; i<=n/2 ; i++){
        if(primes[i] && primes[n-i]){
          c++;
        }
      }
      System.out.println(c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
    var primes : Sequence(boolean) ; primes := Integer.subrange(1,50001)->collect(false) ;
    primes := primes->collect(true) ; 
        var i : int ; i := 2 ; while i < 50001 do ( (     if (primes[i+1]) then (         var j : int ; j := 2 ; while j <= 50000 / i do ( (     if (primes[i * j+1]) then (     primes[i * j+1] := false ) else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    while (not((line) = "0")) do (     var n : int ; n := (line)->toInteger() ;
     var c : int ; c := 0 ;
         var i : int ; i := 2 ; while i <= n / 2 do ( (     if (primes[i+1] & primes[n - i+1]) then (     c := c + 1 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(c) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Arrays ;
class Main {
  private static final int M=50000 ;
  public static void main(String args[]){
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(isr);
    String buf ;
    int list[]=new int[M+1];
    for(int i=2 ; i<=M ; i++)list[i]=0 ;
    for(int i=2 ; i<=M ; i++){
      for(int j=2 ; i*j<=M ; j++){
        list[i*j]=1 ;
      }
    }
    int count[]=new int[M+1];
    Arrays.fill(count,0);
    for(int i=2 ; i<M/2 ; i++){
      if(list[i]==0){
        for(int j=i ; j<M ; j++){
          if(i+j>M)break ;
          if(list[j]==0)count[i+j]++;
        }
      }
    }
    try {
      while((buf=br.readLine()).equals("0")==false){
        int n=Integer.parseInt(buf);
        System.out.println(count[n]);
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute M : int := 50000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
    var buf : String ;
    var list : Sequence(int) ; list := Integer.subrange(1,M + 1)->collect(0) ;
        var i : int ; i := 2 ; while i <= M do (     list[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= M do ( (         var j : int ; j := 2 ; while i * j <= M do ( (     list[i * j+1] := 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : Sequence(int) ; count := Integer.subrange(1,M + 1)->collect(0) ;
    count := count->collect(0) ; 
        var i : int ; i := 2 ; while i < M / 2 do ( (     if (list[i+1] = 0) then (         var j : int ; j := i ; while j < M do ( (     if (i + j > M) then     break else skip ; 
     if (list[j+1] = 0) then     count[i + j+1] := count[i + j+1] + 1 ; else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    try (         buf := br.readLine() ;
    while ((buf) = "0" = false) do (        buf := br.readLine() ;
    (buf) = "0" ;     skip ; (     var n : int ; n := (buf)->toInteger() ;
     OclFile["System.out"].println(count[n+1]) ) ;     buf := br.readLine() ;
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextInt()){
      int N=sc.nextInt();
      System.out.println(N-(N % 500));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextInt()) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N - (N mod 500)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  static int N=50001 ;
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int[] p ;
    int pn,i,j,n,count,l,m,r ;
    p=new int[N/6];
    pn=getprime(p);
    for(; ; ){
      n=sc.nextInt();
      if(n==0)break ;
      count=0 ;
      for(i=0 ; i<pn && p[i]<=n/2 ; i++){
        l=0 ;
        r=pn-1 ;
        for(; l<=r ; ){
          m=(l+r)/2 ;
          if(p[i]+p[m]<n)l=m+1 ;
          else if(p[i]+p[m]>n)r=m-1 ;
          else {
            count++;
            break ;
          }
        }
      }
      out.println(count);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
  private static int getprime(int[] p){
    int i,j,count=0 ;
    boolean[] e ;
    e=new boolean[N];
    e[0]=true ;
    e[1]=true ;
    for(i=2 ; i<N ; i++)if(! e[i]){
      p[count++]=i ;
      for(j=i*2 ; j<N ; j+=i)e[j]=true ;
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   attribute N : int := 50001;
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var p : Sequence(int) ;
    var pn : int ;
    var i : int ;
    var j : int ;
    var n : int ;
    var count : int ;
    var l : int ;
    var m : int ;
    var r : int ;
    p := Integer.subrange(1,N / 6)->collect(0) ; 
    pn := getprime(p) ; 
      while true do ( (     n := sc.nextInt() ; 
     if (n = 0) then     break else skip ; 
    count := 0 ; 
        i := 0 ; while i < pn & p[i+1] <= n / 2 do ( (     l := 0 ; 
     r := pn - 1 ; 
       while l <= r do ( (     m := (l + r) / 2 ; 
     if (p[i+1] + p[m+1] < n) then     l := m + 1 ; else     if (p[i+1] + p[m+1] > n) then     r := m - 1 else (     count := count + 1 ; 
     break ) ;  )  ) )  ;     i := i + 1 ) ; 
    out.println(count) ; 
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
  static   operation getprime( p : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var count : int ; count := 0 ;
     var e : Sequence(boolean) ;
    e := Integer.subrange(1,N)->collect(false) ; 
    e[0+1] := true ; 
    e[1+1] := true ; 
        i := 2 ; while i < N do (     if (not(e[i+1])) then (      p[count+1] := i  ; count := count + 1 ; 
         j := i * 2 ; while j < N do (     e[j+1] := true ;  ;     j := j+(i) ) ) else skip ;  ;     i := i + 1 ) ; 
    return count 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static boolean[] sieve(int n){
    boolean[] isPrime=new boolean[n];
    Arrays.fill(isPrime,true);
    int lim=(int)Math.sqrt(n);
    for(int i=4 ; i<isPrime.length ; i+=2)isPrime[i]=false ;
    for(int i=3 ; i<=lim ; i+=2){
      for(int j=3 ; i*j<isPrime.length ; j+=2)isPrime[i*j]=false ;
    }
    return isPrime ;
  }
  public static int solve(int n){
    int cnt=0 ;
    boolean[] prime=sieve(n);
    if(prime[n-2])cnt++;
    for(int i=3 ; i<=n/2 ; i+=2){
      if(! prime[i])continue ;
      if(prime[n-i]){
        cnt++;
      }
    }
    return cnt ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      int num=Integer.parseInt(br.readLine());
      if(num==0)break ;
      System.out.println(solve(num));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation sieve( n : int) : Sequence(boolean)
  pre: true
  post: true
  activity: (     var isPrime : Sequence(boolean) ; isPrime := Integer.subrange(1,n)->collect(false) ;
     isPrime := isPrime->collect(true) ; 
    var lim : int ; lim := (n)->sqrt()->oclAsType(int) ;
        var i : int ; i := 4 ; while i < isPrime->size() do (     isPrime[i+1] := false ;  ;     i := i+(2) ) ; 
        var i : int ; i := 3 ; while i <= lim do ( (         var j : int ; j := 3 ; while i * j < isPrime->size() do (     isPrime[i * j+1] := false ;  ;     j := j+(2) ) )  ;     i := i+(2) ) ; 
    return isPrime 
 );
  static   operation solve( n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var prime : Sequence(boolean) ; prime := sieve(n) ;
    if (prime[n - 2+1]) then     cnt := cnt + 1 ; else skip ; 
        var i : int ; i := 3 ; while i <= n / 2 do ( (     if (not(prime[i+1])) then     continue else skip ; 
     if (prime[n - i+1]) then (     cnt := cnt + 1 ) else skip )  ;     i := i+(2) ) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var num : int ; num := (br.readLine())->toInteger() ;
     if (num = 0) then     break else skip ; 
     OclFile["System.out"].println(solve(num)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.awt.geom.Point2D ;
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new aoj0056().doIt();
  }
  class aoj0056 {
    ArrayList<Integer>array=new ArrayList<Integer>();
    void eratos(){
      int MAX=50000 ;
      boolean[] isprime=new boolean[MAX+1];
      Arrays.fill(isprime,true);
      isprime[0]=false ;
      isprime[1]=false ;
      for(int i=0 ; i*i<=MAX ; i++){
        if(isprime[i]){
          for(int j=i*2 ; j<=MAX ; j+=i){
            isprime[j]=false ;
          }
        }
      }
      for(int i=0 ; i<=MAX ; i++){
        if(isprime[i])array.add(i);
      }
    }
    int ans[]=new int[50001];
    int ans2[]=new int[50001];
    void DP(){
      for(int i=0 ; i<array.size(); i++){
        ans2[array.get(i)]++;
      }
      for(int i=0 ; i<=array.size(); i++){
        for(int j=i ; j<array.size(); j++){
          if(array.get(i)+array.get(j)<=50000){
            ans[array.get(i)+array.get(j)]=ans[array.get(i)+array.get(j)]+ans2[array.get(i)];
          }
          else break ;
        }
      }
    }
    void doIt(){
      eratos();
      DP();
      while(true){
        int n=sc.nextInt();
        if(n==0)break ;
        System.out.println(ans[n]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     aoj0056.newaoj0056().doIt() );
 class aoj0056 {
   attribute array : Sequence(int) := Sequence{};
   operation eratos() : void
  pre: true
  post: true
  activity: (     var MAX : int ; MAX := 50000 ;
     var isprime : Sequence(boolean) ; isprime := Integer.subrange(1,MAX + 1)->collect(false) ;
    isprime := isprime->collect(true) ; 
    isprime[0+1] := false ; 
    isprime[1+1] := false ; 
        var i : int ; i := 0 ; while i * i <= MAX do ( (     if (isprime[i+1]) then (         var j : int ; j := i * 2 ; while j <= MAX do ( (     isprime[j+1] := false )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= MAX do ( (     if (isprime[i+1]) then     array := array->including(i) ; else skip )  ;     i := i + 1 ) ; 
 );
   attribute ans : int := Integer.subrange(1,50001)->collect(0);
   attribute ans2 : int := Integer.subrange(1,50001)->collect(0);
   operation DP() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < array->size() do ( (     ans2[array->at(i+1)+1] := ans2[array->at(i+1)+1] + 1 )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i <= array->size() do ( (         var j : int ; j := i ; while j < array->size() do ( (     if (array->at(i+1) + array->at(j+1) <= 50000) then (     ans[array->at(i+1) + array->at(j+1)+1] := ans[array->at(i+1) + array->at(j+1)+1] + ans2[array->at(i+1)+1] ) else     break )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
   operation doIt() : void
  pre: true
  post: true
  activity: (     execute eratos() ; 
     execute DP() ; 
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
     OclFile["System.out"].println(ans[n+1]) ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.nio.charset.MalformedInputException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter o=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      String s=sc.next();
      char c=s.charAt(n-1);
      int h=0 ;
      int sum=0 ;
      if(c!='0'){
        h--;
      }
      for(int i=0 ; i<n ; i++){
        char f=s.charAt(i);
        if(f!='0'){
          h++;
        }
        sum+=(int)f-48 ;
      }
      o.println(sum+h);
    }
    o.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var o : OclFile ; o := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
    var c : String ; c := s->at(n - 1+1) ;
    var h : int ; h := 0 ;
    var sum : int ; sum := 0 ;
    if (c /= '0') then (     h := h - 1 ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     var f : String ; f := s->at(i+1) ;
     if (f /= '0') then (     h := h + 1 ) else skip ; 
     sum := sum+((f)->char2byte() - 48) )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Arrays ;
import java.util.Scanner ;
public class ProblemA {
  public static void main(String[] args)throws Exception {
    try(Scanner sc=new Scanner(System.in)){
      int cases=sc.nextInt();
      for(int caseNum=1 ; caseNum<=cases ; caseNum++){
        solve(sc,caseNum);
      }
    }
  }
  static void solve(Scanner sc,int caseNum){
    int N=sc.nextInt();
    int K=sc.nextInt();
    P[] ps=new P[N];
    for(int i=0 ; i<N ; i++){
      ps[i]=new P(sc.nextInt(),sc.nextInt());
    }
    Arrays.sort(ps);
    double max=-1 ;
    for(int i=0 ; i<N-K+1 ; i++){
      P[] ps2=Arrays.copyOfRange(ps,i+1,N);
      Arrays.sort(ps2,(p1,p2)->(Long.compare(p2.H*p2.R,p1.H*p1.R)));
      double area=Math.PI*ps[i] .R*ps[i] .R ;
      area+=Math.PI*ps[i] .H*ps[i] .R*2 ;
      for(int j=0 ; j<K-1 ; j++){
        area+=Math.PI*ps2[j] .H*ps2[j] .R*2 ;
      }
      max=Math.max(area,max);
    }
    System.out.printf("Case #%d: %.8f\n",caseNum,max);
  }
  static class P implements Comparable<P>{
    long R,H ;
    public P(long r,long h){
      super();
      R=r ;
      H=h ;
    }
    @ Override public int compareTo(P arg0){
      return Long.compare(arg0.R,R);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var cases : int ; cases := sc.getCurrent()->toInteger() ;
         var caseNum : int ; caseNum := 1 ; while caseNum <= cases do ( (     execute solve(sc, caseNum) )  ;     caseNum := caseNum + 1 ) ))  );
  static   operation solve( sc : OclFile, caseNum : int) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    var ps : Sequence(P) ; ps := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     ps[i+1] := P.newP(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    ps := ps->sort() ; 
    var max : double ; max := -1 ;
        var i : int ; i := 0 ; while i < N - K + 1 do ( (     var ps2 : Sequence(P) ; ps2 := ps.subrange(i + 1+1,N) ;
     ps2 := OclComparator.sortWith(ps2, lambda (p1 , p2) : OclAny in (compare(p2.H * p2.R, p1.H * p1.R))) ; 
    var area : double ; area := 3.141592653589793 * ps[i+1].R * ps[i+1].R ;
    area := area+(3.141592653589793 * ps[i+1].H * ps[i+1].R * 2) ; 
        var j : int ; j := 0 ; while j < K - 1 do ( (     area := area+(3.141592653589793 * ps2[j+1].H * ps2[j+1].R * 2) )  ;     j := j + 1 ) ; 
    max := Set{area, max}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("Case #%d: %.8f\n", caseNum, max) ; 
 );
  static class P implements Comparable<P> {
   attribute R : long;
   static operation newP( r : long, h : long) : P
  pre: true
  post: true
  activity:
  ( var self : P ;
    self := createP();
    self.initialise(r, h);
    return self );
  operation initialise( r : long, h : long) : void
  pre: true  post: true
  activity: (     execute super() ; 
     R := r ; 
     H := h );
      operation compareTo( arg0 : P) : int
  pre: true
  post: true
  activity: (     return compare(arg0.R, R) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round1c ;
import java.util.ArrayList ;
import java.util.List ;
public class ProbA extends Prob {
  void setup(){
    bin=true ;
    bout=true ;
    in="A-large.in" ;
    out="aout-large.txt" ;
  }
  @ Override public void main(){
    setup();
    reDirect();
    int T=scanner.nextInt();
    for(int cas=1 ; cas<=T ; cas++){
      double ans=run();
      System.out.println(String.format("Case #%d: %.9f",cas,ans));
    }
  }
  double run(){
    int n=scanner.nextInt();
    int k=scanner.nextInt();
    int[][] pancake=new int[n][2];
    for(int i=0 ; i<n ; i++){
      pancake[i][0]=scanner.nextInt();
      pancake[i][1]=scanner.nextInt();
    }
    double ans=0 ;
    for(int i=0 ; i<n ; i++){
      double curr=calcSide(pancake[i])+calcArea(pancake[i][0]);
      List<Double>arr=new ArrayList<>();
      for(int j=0 ; j<n ; j++)if(j!=i){
        if(pancake[j][0]<=pancake[i][0]){
          arr.add(calcSide(pancake[j]));
        }
      }
      if(arr.size()<k-1){
        continue ;
      }
      arr.sort((a,b)->-Double.compare(a,b));
      for(int j=0 ; j<k-1 ; j++){
        curr+=arr.get(j);
      }
      if(curr>ans){
        ans=curr ;
      }
    }
    return ans ;
  }
  private double calcSide(int[] pancake){
    double r=(double)pancake[0];
    double h=(double)pancake[1];
    return 2.0*r*h*Math.PI ;
  }
  private double calcArea(int r){
    return Math.PI*(double)r*(double)r ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProbA extends Prob {
   operation setup() : void
  pre: true
  post: true
  activity: (     bin := true ; 
     bout := true ; 
     in := "A-large.in" ; 
     out := "aout-large.txt" );
      operation main() : void
  pre: true
  post: true
  activity: (     execute setup() ; 
     execute reDirect() ; 
     var T : int ; T := scanner.nextInt() ;
         var cas : int ; cas := 1 ; while cas <= T do ( (     var ans : double ; ans := run() ;
     OclFile["System.out"].println(StringLib.format("Case #%d: %.9f",Sequence{cas,ans})) )  ;     cas := cas + 1 ) );
   operation run() : double
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.nextInt() ;
     var k : int ; k := scanner.nextInt() ;
    var pancake : Sequence(Sequence(int)) ; pancake := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     pancake[i+1][0+1] := scanner.nextInt() ; 
     pancake[i+1][1+1] := scanner.nextInt() )  ;     i := i + 1 ) ; 
    var ans : double ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var curr : double ; curr := calcSide(pancake[i+1]) + calcArea(pancake[i+1][0+1]) ;
     var arr : Sequence(double) ; arr := Sequence{} ;
        var j : int ; j := 0 ; while j < n do (     if (j /= i) then (     if (pancake[j+1][0+1] <= pancake[i+1][0+1]) then (     arr := arr->including(calcSide(pancake[j+1])) ) else skip ) else skip ;  ;     j := j + 1 ) ; 
    if (arr->size() < k - 1) then (     continue ) else skip ; 
    arr := arr.sort(lambda (a , b) : OclAny in -(a)->compareTo(b)) ; 
        var j : int ; j := 0 ; while j < k - 1 do ( (     curr := curr+(arr->at(j+1)) )  ;     j := j + 1 ) ; 
    if (curr > ans) then (     ans := curr ) else skip ; 
 )  ;     i := i + 1 ) ; 
    return ans 
 );
   operation calcSide( pancake : Sequence(int)) : double
  pre: true
  post: true
  activity: (     var r : double ; r := pancake[0+1]->oclAsType(double) ;
     var h : double ; h := pancake[1+1]->oclAsType(double) ;
     return 2.0 * r * h * 3.141592653589793 );
   operation calcArea( r : int) : double
  pre: true
  post: true
  activity: (     return 3.141592653589793 * r->oclAsType(double) * r->oclAsType(double) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class A {
  static Pancake[] p ;
  static Double[][] memo ;
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(new File("A.in"));
    PrintWriter out=new PrintWriter(new File("A.out"));
    int T=sc.nextInt();
    for(int t=1 ; t<=T ; t++){
      int N=sc.nextInt();
      int K=sc.nextInt();
      memo=new Double[N+1][K+1];
      p=new Pancake[N];
      for(int a=0 ; a<N ; a++){
        p[a]=new Pancake(sc.nextInt(),sc.nextInt());
      }
      Arrays.sort(p);
      double ans=DP(N-1,K);
      System.out.printf("Case #%d: %.12f%n",t,ans);
      out.printf("Case #%d: %.12f%n",t,ans);
    }
    out.close();
  }
  private static double DP(int i,int k){
    if(i<0 || k<=0)return 0 ;
    if(memo[i][k]!=null)return memo[i][k];
    double ans=DP(i-1,k-1);
    if(k==1){
      ans+=Math.PI*p[i] .R*p[i] .R ;
    }
    ans+=2.0*Math.PI*p[i] .R*p[i] .H ;
    ans=Math.max(ans,DP(i-1,k));
    return memo[i][k]=ans ;
  }
  static class Pancake implements Comparable<Pancake>{
    int R,H ;
    Pancake(int a,int b){
      R=a ;
      H=b ;
    }
    @ Override public int compareTo(Pancake that){
      return(that.R-this.R);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute p : Sequence(Pancake);
  static   attribute memo : Sequence(Sequence(double));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile("A.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("A.out")) ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= T do ( (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    memo := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,K + 1)->collect(null)) ; 
    p := Integer.subrange(1,N)->collect(null) ; 
        var a : int ; a := 0 ; while a < N do ( (     p[a+1] := Pancake.newPancake(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) )  ;     a := a + 1 ) ; 
    p := p->sort() ; 
    var ans : double ; ans := DP(N - 1, K) ;
    OclFile["System.out"].printf("Case #%d: %.12f%n", t, ans) ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation DP( i : int, k : int) : double
  pre: true
  post: true
  activity: (     if (i < 0 or k <= 0) then     return 0 else skip ; 
     if (memo[i+1][k+1] /= null) then     return memo[i+1][k+1] else skip ; 
    var ans : double ; ans := DP(i - 1, k - 1) ;
    if (k = 1) then (     ans := ans+(3.141592653589793 * p[i+1].R * p[i+1].R) ) else skip ; 
    ans := ans+(2.0 * 3.141592653589793 * p[i+1].R * p[i+1].H) ; 
    ans := Set{ans, DP(i - 1, k)}->max() ; 
    return memo[i+1][k+1] 
 );
  static class Pancake implements Comparable<Pancake> {
   attribute R : int;
   static operation newPancake( a : int, b : int) : Pancake
  pre: true
  post: true
  activity:
  ( var self : Pancake ;
    self := createPancake();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     R := a ; 
     H := b );
      operation compareTo( that : Pancake) : int
  pre: true
  post: true
  activity: (     return (that.R - self.R) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countWays(String str,int m){
    HashSet<Character>set=new HashSet<Character>();
    for(int i=0 ; i<str.length(); i++)set.add(str.charAt(i));
    int result=0 ;
    for(int i=1 ; i<str.length(); i++){
      HashMap<Character,Integer>first_map=new HashMap<Character,Integer>();
      HashMap<Character,Integer>second_map=new HashMap<Character,Integer>();
      for(int j=0 ; j<i ; j++){
        if(first_map.containsKey(str.charAt(j)))first_map.put(str.charAt(j),(first_map.get(str.charAt(j))+1));
        else first_map.put(str.charAt(j),1);
      }
      for(int k=i ; k<str.length(); k++){
        if(second_map.containsKey(str.charAt(k)))second_map.put(str.charAt(k),(second_map.get(str.charAt(k))+1));
        else second_map.put(str.charAt(k),1);
      }
      Iterator itr=set.iterator();
      int total_count=0 ;
      while(itr.hasNext()){
        int first_count=0,second_count=0 ;
        char ch=(char)itr.next();
        if(first_map.containsKey(ch))first_count=first_map.get(ch);
        if(second_map.containsKey(ch))second_count=second_map.get(ch);
        if(first_count==second_count && first_count!=0)total_count+=1 ;
      }
      if(total_count>=m)result+=1 ;
    }
    return result ;
  }
  public static void main(String[] args){
    String str="aabbccaa" ;
    int m=2 ;
    System.out.println(countWays(str,m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countWays( str : String, m : int) : int
  pre: true
  post: true
  activity: (     var set : Set(String) ; set := Set{} ;
         var i : int ; i := 0 ; while i < str->size() do (     set := set->including(str->at(i+1)) ;  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
        var i : int ; i := 1 ; while i < str->size() do ( (     var first_map : Map(String,int) ; first_map := Map{} ;
     var second_map : Map(String,int) ; second_map := Map{} ;
        var j : int ; j := 0 ; while j < i do ( (     if (first_map->keys()->includes(str->at(j+1))) then     first_map := first_map->union(Map{str->at(j+1) |-> (first_map->at(str->at(j+1)) + 1)}) ; else     first_map := first_map->union(Map{str->at(j+1) |-> 1}) ; )  ;     j := j + 1 ) ; 
        var k : int ; k := i ; while k < str->size() do ( (     if (second_map->keys()->includes(str->at(k+1))) then     second_map := second_map->union(Map{str->at(k+1) |-> (second_map->at(str->at(k+1)) + 1)}) ; else     second_map := second_map->union(Map{str->at(k+1) |-> 1}) ; )  ;     k := k + 1 ) ; 
    var itr : OclIterator ; itr := set->iterator() ;
    var total_count : int ; total_count := 0 ;
    while (itr.hasNext()) do (     var first_count : int ; first_count := 0 ;
    var second_count : int ; second_count := 0 ;
     var ch : String ; ch := itr.next()->oclAsType(String) ;
    if (first_map->keys()->includes(ch)) then     first_count := first_map->at(ch) ; else skip ; 
    if (second_map->keys()->includes(ch)) then     second_count := second_map->at(ch) ; else skip ; 
    if (first_count = second_count & first_count /= 0) then     total_count := total_count+(1) ; else skip ; 
 ) ; 
    if (total_count >= m) then     result := result+(1) ; else skip ; 
 )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "aabbccaa" ;
     var m : int ; m := 2 ;
     OclFile["System.out"].println(countWays(str, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] aArr=new int[n];
    for(int i=0 ; i<n ; i++){
      aArr[i]=sc.nextInt();
    }
    HashMap<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(map.containsKey(aArr[i])){
        map.put(aArr[i],map.get(aArr[i])+1);
      }
      else {
        map.put(aArr[i],1);
      }
    }
    int res=0 ;
    for(Map.Entry<Integer,Integer>entry : map.entrySet()){
      if(entry.getValue()% 2==1)res++;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var aArr : Sequence(int) ; aArr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     aArr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (map->keys()->includes(aArr[i+1])) then (     map := map->union(Map{aArr[i+1] |-> map->at(aArr[i+1]) + 1}) ) else (     map := map->union(Map{aArr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    for (entry : map->asSet()) do ( (     if (entry.getValue() mod 2 = 1) then     res := res + 1 ; else skip )  ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import java.util.Set ;
import java.util.HashSet ;
class Main {
  public static void main(String...args)throws IOException {
    FastScanner fs=new FastScanner();
    Set<Long>dic=new HashSet<Long>();
    int n=fs.nextInt();
    for(int i=0 ; i<n ; i++){
      long l=fs.nextLong();
      if(dic.contains(l))dic.remove(l);
      else dic.add(l);
    }
    System.out.println(dic.size());
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(String s){
    try {
      br=new BufferedReader(new FileReader(s));
    }
    catch(FileNotFoundException e){
      e.printStackTrace();
    }
  }
  public FastScanner(){
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  String nextToken(){
    while(st==null || ! st.hasMoreElements()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
    }
    return st.nextToken();
  }
  String nextLine(){
    String line="" ;
    try {
      line=br.readLine();
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return line ;
  }
  int nextInt(){
    return Integer.parseInt(nextToken());
  }
  long nextLong(){
    return Long.parseLong(nextToken());
  }
  double nextDouble(){
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var dic : Set(long) ; dic := Set{} ;
    var n : int ; n := fs.nextInt() ;
        var i : int ; i := 0 ; while i < n do ( (     var l : long ; l := fs.nextLong() ;
     if (dic->includes(l)) then     dic := dic->excludingAt(l+1) ; else     dic := dic->including(l) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dic->size()) ; 
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
 );
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var line : String ; line := "" ;
     try (     line := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return line );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        int x ;
        if(j<a ^ i<b){
          x=1 ;
        }
        else {
          x=0 ;
        }
        sb.append(x);
      }
      sb.append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     var x : int ;
     if (j < a xor i < b) then (     x := 1 ) else (     x := 0 ) ;  
     sb := sb + StringLib.newString(x) )  ;     j := j + 1 ) ; 
     sb := sb + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int count=sc.nextInt();
    HashSet<String>set=new HashSet<>();
    for(int i=0 ; i<count ; i++){
      String num=sc.next();
      if(set.contains(num))set.remove(num);
      else set.add(num);
    }
    System.out.println(set.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := sc.getCurrent()->toInteger() ;
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := 0 ; while i < count do ( (     var num : String ; num := sc.getCurrent() ;
     if (set->includes(num)) then     set := set->excludingFirst(num) ; else     set := set->including(num) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(set->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Integer>sheetInfo=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      sheetInfo.add(sc.nextInt());
    }
    Collections.sort(sheetInfo);
    int answer=0 ;
    int numberCount=1 ;
    int beforeNumber=sheetInfo.get(0);
    for(int i=1 ; i<n ; i++){
      if(beforeNumber==sheetInfo.get(i)){
        numberCount++;
        if(i==n-1){
          if(numberCount % 2==1){
            answer++;
          }
        }
      }
      else {
        if(numberCount % 2==1){
          answer++;
        }
        numberCount=1 ;
        beforeNumber=sheetInfo.get(i);
        if(i==n-1){
          answer++;
        }
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var sheetInfo : Sequence(int) ; sheetInfo := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     sheetInfo := sheetInfo->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    sheetInfo := sheetInfo->sort() ; 
    var answer : int ; answer := 0 ;
    var numberCount : int ; numberCount := 1 ;
    var beforeNumber : int ; beforeNumber := sheetInfo->at(0+1) ;
        var i : int ; i := 1 ; while i < n do ( (     if (beforeNumber = sheetInfo->at(i+1)) then (     numberCount := numberCount + 1 ; 
     if (i = n - 1) then (     if (numberCount mod 2 = 1) then (     answer := answer + 1 ) else skip ) else skip ) else (     if (numberCount mod 2 = 1) then (     answer := answer + 1 ) else skip ; 
     numberCount := 1 ; 
     beforeNumber := sheetInfo->at(i+1) ; 
     if (i = n - 1) then (     answer := answer + 1 ) else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    Main m=new Main(sc);
    m.show(m.solve());
    sc.close();
  }
  Scanner sc ;
  int N ;
  int[] A ;
  Main(Scanner sc){
    this.sc=sc ;
    this.N=sc.nextInt();
    A=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
    }
  }
  private int solve(){
    int answer=0 ;
    Arrays.sort(A);
    int count=0 ;
    int s=A[0];
    for(int i=0 ; i<N ; i++){
      if(A[i]==s){
        count++;
      }
      else {
        s=A[i];
        if(count % 2==1){
          answer++;
        }
        count=1 ;
      }
    }
    if(count % 2==1){
      answer++;
    }
    return answer ;
  }
  public void show(int answer){
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : Main ; m := Main.newMain(sc) ;
     m.show(m.solve()) ; 
     skip );
   attribute sc : OclFile;
   attribute N : int;
   attribute A : Sequence(int);
   static operation newMain( sc : OclFile) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(sc);
    return self );
  operation initialise( sc : OclFile) : void
  pre: true  post: true
  activity: (     self.sc := sc ; 
     self.N := sc.getCurrent()->toInteger() ; 
     A := Integer.subrange(1,N)->collect(0) ; 
         var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) );
   operation solve() : int
  pre: true
  post: true
  activity: (     var answer : int ; answer := 0 ;
     A := A->sort() ; 
    var count : int ; count := 0 ;
    var s : int ; s := A[0+1] ;
        var i : int ; i := 0 ; while i < N do ( (     if (A[i+1] = s) then (     count := count + 1 ) else (     s := A[i+1] ; 
     if (count mod 2 = 1) then (     answer := answer + 1 ) else skip ; 
     count := 1 ) )  ;     i := i + 1 ) ; 
    if (count mod 2 = 1) then (     answer := answer + 1 ) else skip ; 
    return answer 
 );
   operation show( answer : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(answer) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getMSB(int n){
    n |=n>>1 ;
    n |=n>>2 ;
    n |=n>>4 ;
    n |=n>>8 ;
    n |=n>>16 ;
    return((n+1)>>2);
  }
  static void multiply(int F[][],int M[][]){
    int x=F[0][0]*M[0][0]+F[0][1]*M[1][0];
    int y=F[0][0]*M[0][1]+F[0][1]*M[1][1];
    int z=F[1][0]*M[0][0]+F[1][1]*M[1][0];
    int w=F[1][0]*M[0][1]+F[1][1]*M[1][1];
    F[0][0]=x ;
    F[0][1]=y ;
    F[1][0]=z ;
    F[1][1]=w ;
  }
  static void power(int F[][],int n){
    if(n==0 || n==1)return ;
    int[][] M={
      {
        1,1 },{
          1,0 }
        };
        for(int m=getMSB(n); m>0 ; m=m>>1){
          multiply(F,F);
          if((n & m)>0){
            multiply(F,M);
          }
        }
      }
      static int fib(int n){
        int[][] F={
          {
            1,1 },{
              1,0 }
            };
            if(n==0)return 0 ;
            power(F,n-1);
            return F[0][0];
          }
          public static void main(String[] args){
            int n=6 ;
            System.out.println(fib(n));
          }
        }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getMSB( n : int) : int
  pre: true
  post: true
  activity: (     n := MathLib.bitwiseOr(n, (n/(2->pow(1)))->oclAsType(long)) ; 
     n := MathLib.bitwiseOr(n, (n/(2->pow(2)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(4)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(8)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(16)))->oclAsType(long)) ; 
    return (((n + 1)/(2->pow(2)))->oclAsType(long)) 
 );
  static   operation multiply( F : Sequence(Sequence(int)), M : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var x : int ; x := F[0+1][0+1] * M[0+1][0+1] + F[0+1][1+1] * M[1+1][0+1] ;
     var y : int ; y := F[0+1][0+1] * M[0+1][1+1] + F[0+1][1+1] * M[1+1][1+1] ;
    var z : int ; z := F[1+1][0+1] * M[0+1][0+1] + F[1+1][1+1] * M[1+1][0+1] ;
    var w : int ; w := F[1+1][0+1] * M[0+1][1+1] + F[1+1][1+1] * M[1+1][1+1] ;
    F[0+1][0+1] := x ; 
    F[0+1][1+1] := y ; 
    F[1+1][0+1] := z ; 
    F[1+1][1+1] := w ; 
 );
  static   operation power( F : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (     if (n = 0 or n = 1) then     return else skip ; 
     var M : Sequence(Sequence(int)) ; M := Sequence{Sequence{1,1},Sequence{1,0}} ;
         var m : int ; m := getMSB(n) ; while m > 0 do ( (     execute multiply(F, F) ; 
     if ((n & m) > 0) then (     execute multiply(F, M) ) else skip )  ;     m := (m/(2->pow(1)))->oclAsType(long) ) );
  static   operation fib( n : int) : int
  pre: true
  post: true
  activity: (     var F : Sequence(Sequence(int)) ; F := Sequence{Sequence{1,1},Sequence{1,0}} ;
     if (n = 0) then     return 0 else skip ; 
     execute power(F, n - 1) ; 
     return F[0+1][0+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(fib(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long mod=(long)(1e9+7);
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int t=1 ; t<=test ; t++){
      int n=in.nextInt();
      ArrayList<Integer>list=new ArrayList<>();
      long sum=0 ;
      for(int i=0 ; i<n ; i++){
        long v=in.nextLong();
        if(v<=2048){
          sum+=v ;
        }
      }
      if(sum>=2048){
        pw.println("YES");
      }
      else {
        pw.println("NO");
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := (1e9 + 7)->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= test do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var list : Sequence(int) ; list := Sequence{} ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var v : long ; v := in.getCurrent()->toLong() ;
     if (v <= 2048) then (     sum := sum+(v) ) else skip )  ;     i := i + 1 ) ; 
    if (sum >= 2048) then (     skip ) else (     skip ) ;  
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class fibonacci {
  static int fib(int n){
    int F[][]=new int[][] {
      {
        1,1 },{
          1,0 }
        };
        if(n==0)return 0 ;
        power(F,n-1);
        return F[0][0];
      }
      static void multiply(int F[][],int M[][]){
        int x=F[0][0]*M[0][0]+F[0][1]*M[1][0];
        int y=F[0][0]*M[0][1]+F[0][1]*M[1][1];
        int z=F[1][0]*M[0][0]+F[1][1]*M[1][0];
        int w=F[1][0]*M[0][1]+F[1][1]*M[1][1];
        F[0][0]=x ;
        F[0][1]=y ;
        F[1][0]=z ;
        F[1][1]=w ;
      }
      static void power(int F[][],int n){
        int i ;
        int M[][]=new int[][] {
          {
            1,1 },{
              1,0 }
            };
            for(i=2 ; i<=n ; i++)multiply(F,M);
          }
          public static void main(String args[]){
            int n=9 ;
            System.out.println(fib(n));
          }
        }

------------------------------------------------------------
OCL File:
---------
class fibonacci {
  static   operation fib( n : int) : int
  pre: true
  post: true
  activity: (     var F : Sequence(Sequence(int)) ; F := Sequence{Sequence{1,1},Sequence{1,0}} ;
     if (n = 0) then     return 0 else skip ; 
     execute power(F, n - 1) ; 
     return F[0+1][0+1] );
  static   operation multiply( F : Sequence(Sequence(int)), M : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var x : int ; x := F[0+1][0+1] * M[0+1][0+1] + F[0+1][1+1] * M[1+1][0+1] ;
     var y : int ; y := F[0+1][0+1] * M[0+1][1+1] + F[0+1][1+1] * M[1+1][1+1] ;
    var z : int ; z := F[1+1][0+1] * M[0+1][0+1] + F[1+1][1+1] * M[1+1][0+1] ;
    var w : int ; w := F[1+1][0+1] * M[0+1][1+1] + F[1+1][1+1] * M[1+1][1+1] ;
    F[0+1][0+1] := x ; 
    F[0+1][1+1] := y ; 
    F[1+1][0+1] := z ; 
    F[1+1][1+1] := w ; 
 );
  static   operation power( F : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
     var M : Sequence(Sequence(int)) ; M := Sequence{Sequence{1,1},Sequence{1,0}} ;
         i := 2 ; while i <= n do (     execute multiply(F, M) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     OclFile["System.out"].println(fib(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class fibonacci {
  static int fib(int n){
    int F[][]=new int[][] {
      {
        1,1 },{
          1,0 }
        };
        if(n==0)return 0 ;
        power(F,n-1);
        return F[0][0];
      }
      static void multiply(int F[][],int M[][]){
        int x=F[0][0]*M[0][0]+F[0][1]*M[1][0];
        int y=F[0][0]*M[0][1]+F[0][1]*M[1][1];
        int z=F[1][0]*M[0][0]+F[1][1]*M[1][0];
        int w=F[1][0]*M[0][1]+F[1][1]*M[1][1];
        F[0][0]=x ;
        F[0][1]=y ;
        F[1][0]=z ;
        F[1][1]=w ;
      }
      static void power(int F[][],int n){
        if(n==0 || n==1)return ;
        int M[][]=new int[][] {
          {
            1,1 },{
              1,0 }
            };
            power(F,n/2);
            multiply(F,F);
            if(n % 2!=0)multiply(F,M);
          }
          public static void main(String args[]){
            int n=9 ;
            System.out.println(fib(n));
          }
        }

------------------------------------------------------------
OCL File:
---------
class fibonacci {
  static   operation fib( n : int) : int
  pre: true
  post: true
  activity: (     var F : Sequence(Sequence(int)) ; F := Sequence{Sequence{1,1},Sequence{1,0}} ;
     if (n = 0) then     return 0 else skip ; 
     execute power(F, n - 1) ; 
     return F[0+1][0+1] );
  static   operation multiply( F : Sequence(Sequence(int)), M : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var x : int ; x := F[0+1][0+1] * M[0+1][0+1] + F[0+1][1+1] * M[1+1][0+1] ;
     var y : int ; y := F[0+1][0+1] * M[0+1][1+1] + F[0+1][1+1] * M[1+1][1+1] ;
    var z : int ; z := F[1+1][0+1] * M[0+1][0+1] + F[1+1][1+1] * M[1+1][0+1] ;
    var w : int ; w := F[1+1][0+1] * M[0+1][1+1] + F[1+1][1+1] * M[1+1][1+1] ;
    F[0+1][0+1] := x ; 
    F[0+1][1+1] := y ; 
    F[1+1][0+1] := z ; 
    F[1+1][1+1] := w ; 
 );
  static   operation power( F : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (     if (n = 0 or n = 1) then     return else skip ; 
     var M : Sequence(Sequence(int)) ; M := Sequence{Sequence{1,1},Sequence{1,0}} ;
    execute power(F, n / 2) ; 
    execute multiply(F, F) ; 
    if (n mod 2 /= 0) then     execute multiply(F, M) ; else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     OclFile["System.out"].println(fib(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void multiply(int F[][],int M[][]){
    int x=F[0][0]*M[0][0]+F[0][1]*M[1][0];
    int y=F[0][0]*M[0][1]+F[0][1]*M[1][1];
    int z=F[1][0]*M[0][0]+F[1][1]*M[1][0];
    int w=F[1][0]*M[0][1]+F[1][1]*M[1][1];
    F[0][0]=x ;
    F[0][1]=y ;
    F[1][0]=z ;
    F[1][1]=w ;
  }
  static void power(int F[][],int n){
    int i ;
    int M[][]={
      {
        1,1 },{
          1,0 }
        };
        for(i=2 ; i<=n ; i++)multiply(F,M);
      }
      static int fib(int n){
        int F[][]={
          {
            1,1 },{
              1,0 }
            };
            if(n==0)return 0 ;
            power(F,n-1);
            return F[0][0];
          }
          static int leonardo(int n){
            if(n==0 || n==1)return 1 ;
            return 2*fib(n+1)-1 ;
          }
          public static void main(String args[]){
            System.out.println(leonardo(3));
          }
        }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation multiply( F : Sequence(Sequence(int)), M : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var x : int ; x := F[0+1][0+1] * M[0+1][0+1] + F[0+1][1+1] * M[1+1][0+1] ;
     var y : int ; y := F[0+1][0+1] * M[0+1][1+1] + F[0+1][1+1] * M[1+1][1+1] ;
    var z : int ; z := F[1+1][0+1] * M[0+1][0+1] + F[1+1][1+1] * M[1+1][0+1] ;
    var w : int ; w := F[1+1][0+1] * M[0+1][1+1] + F[1+1][1+1] * M[1+1][1+1] ;
    F[0+1][0+1] := x ; 
    F[0+1][1+1] := y ; 
    F[1+1][0+1] := z ; 
    F[1+1][1+1] := w ; 
 );
  static   operation power( F : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
     var M : Sequence(Sequence(int)) ; M := Sequence{Sequence{1,1},Sequence{1,0}} ;
         i := 2 ; while i <= n do (     execute multiply(F, M) ;  ;     i := i + 1 ) );
  static   operation fib( n : int) : int
  pre: true
  post: true
  activity: (     var F : Sequence(Sequence(int)) ; F := Sequence{Sequence{1,1},Sequence{1,0}} ;
     if (n = 0) then     return 0 else skip ; 
     execute power(F, n - 1) ; 
     return F[0+1][0+1] );
  static   operation leonardo( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0 or n = 1) then     return 1 else skip ; 
     return 2 * fib(n + 1) - 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(leonardo(3)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void multiply(int F[][],int M[][]){
    int x=F[0][0]*M[0][0]+F[0][1]*M[1][0];
    int y=F[0][0]*M[0][1]+F[0][1]*M[1][1];
    int z=F[1][0]*M[0][0]+F[1][1]*M[1][0];
    int w=F[1][0]*M[0][1]+F[1][1]*M[1][1];
    F[0][0]=x ;
    F[0][1]=y ;
    F[1][0]=z ;
    F[1][1]=w ;
  }
  static void power(int F[][],int n){
    if(n==0 || n==1){
      return ;
    }
    int M[][]={
      {
        1,1 },{
          1,0 }
        };
        power(F,n/2);
        multiply(F,F);
        if(n % 2!=0){
          multiply(F,M);
        }
      }
      static int countWays(int n){
        int F[][]={
          {
            1,1 },{
              1,0 }
            };
            if(n==0){
              return 0 ;
            }
            power(F,n);
            return F[0][0];
          }
          public static void main(String[] args){
            int n=5 ;
            System.out.println(countWays(n));
          }
        }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation multiply( F : Sequence(Sequence(int)), M : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var x : int ; x := F[0+1][0+1] * M[0+1][0+1] + F[0+1][1+1] * M[1+1][0+1] ;
     var y : int ; y := F[0+1][0+1] * M[0+1][1+1] + F[0+1][1+1] * M[1+1][1+1] ;
    var z : int ; z := F[1+1][0+1] * M[0+1][0+1] + F[1+1][1+1] * M[1+1][0+1] ;
    var w : int ; w := F[1+1][0+1] * M[0+1][1+1] + F[1+1][1+1] * M[1+1][1+1] ;
    F[0+1][0+1] := x ; 
    F[0+1][1+1] := y ; 
    F[1+1][0+1] := z ; 
    F[1+1][1+1] := w ; 
 );
  static   operation power( F : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (     if (n = 0 or n = 1) then (     return ) else skip ; 
     var M : Sequence(Sequence(int)) ; M := Sequence{Sequence{1,1},Sequence{1,0}} ;
    execute power(F, n / 2) ; 
    execute multiply(F, F) ; 
    if (n mod 2 /= 0) then (     execute multiply(F, M) ) else skip ; 
 );
  static   operation countWays( n : int) : int
  pre: true
  post: true
  activity: (     var F : Sequence(Sequence(int)) ; F := Sequence{Sequence{1,1},Sequence{1,0}} ;
     if (n = 0) then (     return 0 ) else skip ; 
     execute power(F, n) ; 
     return F[0+1][0+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(countWays(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n ;
    double[] x,y ;
    int i,j ;
    double s1x,s1y,s2x,s2y,sjx,sjy,max,l ;
    n=sc.nextInt();
    x=new double[n];
    y=new double[n];
    for(i=0 ; i<n ; i++){
      x[i]=sc.nextDouble();
      y[i]=sc.nextDouble();
    }
    max=0.0 ;
    for(i=0 ; i<n ; i++){
      s1x=y[(i-1+n)% n]-y[i];
      s1y=-x[(i-1+n)% n]+x[i];
      s2x=-y[(i+1)% n]+y[i];
      s2y=x[(i+1)% n]-x[i];
      for(j=i+1 ; j<n ; j++){
        if(s1x*s2y-s2x*s1y==0.0)break ;
        sjx=x[j]-x[i];
        sjy=y[j]-y[i];
        if((s1x*sjy-sjx*s1y)*(s2x*sjy-s2y*sjy)<=0){
          l=sjx*sjx+sjy*sjy ;
          if(l>max)max=l ;
        }
      }
    }
    System.out.println(Math.sqrt(max));
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var x : Sequence(double) ;
    var y : Sequence(double) ;
    var i : int ;
    var j : int ;
    var s1x : double ;
    var s1y : double ;
    var s2x : double ;
    var s2y : double ;
    var sjx : double ;
    var sjy : double ;
    var max : double ;
    var l : double ;
    n := sc.nextInt() ; 
    x := Integer.subrange(1,n)->collect(0.0) ; 
    y := Integer.subrange(1,n)->collect(0.0) ; 
        i := 0 ; while i < n do ( (     x[i+1] := sc.nextDouble() ; 
     y[i+1] := sc.nextDouble() )  ;     i := i + 1 ) ; 
    max := 0.0 ; 
        i := 0 ; while i < n do ( (     s1x := y[(i - 1 + n) mod n+1] - y[i+1] ; 
     s1y := -x[(i - 1 + n) mod n+1] + x[i+1] ; 
    s2x := -y[(i + 1) mod n+1] + y[i+1] ; 
    s2y := x[(i + 1) mod n+1] - x[i+1] ; 
        j := i + 1 ; while j < n do ( (     if (s1x * s2y - s2x * s1y = 0.0) then     break else skip ; 
     sjx := x[j+1] - x[i+1] ; 
     sjy := y[j+1] - y[i+1] ; 
     if ((s1x * sjy - sjx * s1y) * (s2x * sjy - s2y * sjy) <= 0) then (     l := sjx * sjx + sjy * sjy ; 
     if (l > max) then     max := l ; else skip ) else skip )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((max)->sqrt()) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  static final PrintStream out=System.out ;
  static final Scanner sc=new Scanner(System.in);
  static final long Mod=1000_000_007L ;
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
    System.exit(0);
  }
  void solve(){
    int H=nextInt();
    int W=nextInt();
    int A=W-nextInt();
    int B=H-nextInt();
    int[][] map=new int[H][W];
    int[] h=new int[H];
    int[] w=new int[W];
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        if(h[i]<A && w[j]<B){
          map[i][j]=1 ;
          h[i]++;
          w[j]++;
        }
      }
    }
    int cntA=0,cntB=0 ;
    for(int i=0 ; i<H ; i++){
      if(h[i]==A)cntA++;
    }
    for(int j=0 ; j<W ; j++){
      if(w[j]==B)cntB++;
    }
    if(cntA!=B || cntB!=A){
      out.println("No");
      return ;
    }
    StringBuilder buf=new StringBuilder();
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        buf.append(map[i][j]);
      }
      buf.append(System.getProperty("line.separator"));
    }
    out.print(buf);
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
  public String next(){
    return sc.next();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute out : OclFile := OclFile["System.out"];
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute Mod : long := 1000_000_007L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() ; 
 OclProcess.exit(0) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var H : int ; H := nextInt() ;
     var W : int ; W := nextInt() ;
    var A : int ; A := W - nextInt() ;
    var B : int ; B := H - nextInt() ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
    var h : Sequence(int) ; h := Integer.subrange(1,H)->collect(0) ;
    var w : Sequence(int) ; w := Integer.subrange(1,W)->collect(0) ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (h[i+1] < A & w[j+1] < B) then (     map[i+1][j+1] := 1 ; 
     h[i+1] := h[i+1] + 1 ; 
     w[j+1] := w[j+1] + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var cntA : int ; cntA := 0 ;
    var cntB : int ; cntB := 0 ;
        var i : int ; i := 0 ; while i < H do ( (     if (h[i+1] = A) then     cntA := cntA + 1 ; else skip )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < W do ( (     if (w[j+1] = B) then     cntB := cntB + 1 ; else skip )  ;     j := j + 1 ) ; 
    if (cntA /= B or cntB /= A) then (     skip ; 
     return ) else skip ; 
    var buf : String ; buf := StringLib.newString() ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     buf := buf + StringLib.newString(map[i+1][j+1]) )  ;     j := j + 1 ) ; 
     buf := buf + StringLib.newString(OclProcess.getEnvironmentProperty("line.separator")) )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation next() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String str=in.next();
    String left=str.substring(0,str.indexOf("|"));
    String right=str.substring(str.indexOf("|")+1);
    String s=in.next();
    for(int i=0 ; i<s.length(); i++){
      if(left.length()<=right.length())left+=s.charAt(i);
      else right+=s.charAt(i);
    }
    System.out.println(left.length()==right.length()? left+"|"+right : "Impossible");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := in.getCurrent() ;
    var left : String ; left := str.subrange(0+1,str->indexOf("|")-1) ;
    var right : String ; right := str.subrange(str->indexOf("|")-1 + 1+1,str->indexOf("|")-1 + 1) ;
    var s : String ; s := in.getCurrent() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (left->size() <= right->size()) then     left := left+(s->at(i+1)) ; else     right := right+(s->at(i+1)) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if left->size() = right->size() then left + "|" + right else "Impossible" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String scale=sc.nextLine();
    String weights=sc.nextLine();
    int size=scale.length();
    int index=scale.indexOf('|');
    int left=index ;
    int right=size-left-1 ;
    int diff=Math.abs(left-right);
    if(weights.length()<diff){
      System.out.println("Impossible");
    }
    else {
      int rem=weights.length()-diff ;
      if(rem % 2!=0){
        System.out.println("Impossible");
      }
      else {
        left=(left<right)? diff+rem/2 : rem/2 ;
        StringBuilder ans=new StringBuilder("");
        int i ;
        for(i=0 ; i<left ; i++){
          ans.append(weights.charAt(i));
        }
        ans.append(scale);
        for(i=left ; i<weights.length(); i++){
          ans.append(weights.charAt(i));
        }
        System.out.println(ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var scale : String ; scale := sc.nextLine() ;
    var weights : String ; weights := sc.nextLine() ;
    var size : int ; size := scale->size() ;
    var index : int ; index := scale->indexOf('|')-1 ;
    var left : int ; left := index ;
    var right : int ; right := (size)->char2byte() - left - 1 ;
    var diff : int ; diff := if left - right < 0 then -(left - right) else left - right endif ;
    if (weights->size() < diff) then (     OclFile["System.out"].println("Impossible") ) else (     var rem : int ; rem := weights->size() - diff ;
     if (rem mod 2 /= 0) then (     OclFile["System.out"].println("Impossible") ) else (     left := if (left < right) then diff + rem / 2 else rem / 2 endif ; 
     var ans : String ; ans := StringLib.newString("") ;
    var i : int ;
        i := 0 ; while i < left do ( (     ans := ans + StringLib.newString(weights->at(i+1)) )  ;     i := i + 1 ) ; 
    ans := ans + StringLib.newString(scale) ; 
        i := left ; while i < weights->size() do ( (     ans := ans + StringLib.newString(weights->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.IllegalFormatCodePointException ;
import java.util.Scanner ;
public class Main {
  static ArrayList md=new ArrayList();
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String n=in.next();
    String v=in.next();
    int sec ;
    String a,b ;
    int count=0 ;
    for(int i=0 ; i<n.length(); i++){
      if(! Character.isLetter(n.charAt(i))){
        break ;
      }
      else count++;
    }
    sec=n.length()-count-1 ;
    a=n.substring(0,count);
    b=n.substring(count+1,n.length());
    if(a.length()==b.length()&& v.length()% 2!=0){
      System.out.println("Impossible");
    }
    else if((a.length()+b.length()+v.length())% 2!=0){
      System.out.println("Impossible");
    }
    else if(Math.abs(a.length()-b.length())>v.length()){
      System.out.println("Impossible");
    }
    else {
      for(int i=0 ; i<v.length(); i++){
        if(a.length()>b.length()){
          b+=v.charAt(i);
        }
        else a+=v.charAt(i);
      }
      System.out.println(a+"|"+b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute md : Sequence := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : String ; n := in.getCurrent() ;
    var v : String ; v := in.getCurrent() ;
    var sec : int ;
    var a : String ;
    var b : String ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n->size() do ( (     if (not((n->at(i+1) + "")->isMatch("[a-zA-Z]"))) then (     break ) else     count := count + 1 ; )  ;     i := i + 1 ) ; 
    sec := n->size() - (count)->char2byte() - 1 ; 
    a := n.subrange(0+1,count) ; 
    b := n.subrange(count + 1+1,n->size()) ; 
    if (a->size() = b->size() & v->size() mod 2 /= 0) then (     OclFile["System.out"].println("Impossible") ) else     if ((a->size() + b->size() + v->size()) mod 2 /= 0) then (     OclFile["System.out"].println("Impossible") ) else     if (if a->size() - b->size() < 0 then -(a->size() - b->size()) else a->size() - b->size() endif > v->size()) then (     OclFile["System.out"].println("Impossible") ) else (         var i : int ; i := 0 ; while i < v->size() do ( (     if (a->size() > b->size()) then (     b := b+(v->at(i+1)) ) else     a := a+(v->at(i+1)) ; )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(a + "|" + b) ) ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.LinkedList ;
public class CF382_D2_A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String init=scanner.nextLine();
    String left=scanner.nextLine();
    LinkedList<Character>leftScale=new LinkedList<>();
    LinkedList<Character>rightScale=new LinkedList<>();
    boolean visited=false ;
    for(int i=0 ; i<init.length(); i++){
      if(init.charAt(i)=='|'){
        visited=true ;
        continue ;
      }
      if(visited){
        rightScale.add(init.charAt(i));
      }
      else {
        leftScale.add(init.charAt(i));
      }
    }
    LinkedList<Character>leftWeight=new LinkedList<>();
    for(int i=0 ; i<left.length(); i++){
      leftWeight.add(left.charAt(i));
    }
    while(! leftWeight.isEmpty()){
      if(leftScale.size()>rightScale.size()){
        rightScale.add(leftWeight.removeFirst());
      }
      else if(leftScale.size()<rightScale.size()){
        leftScale.add(leftWeight.removeFirst());
      }
      else {
        rightScale.add(leftWeight.removeFirst());
      }
    }
    if(leftScale.size()==rightScale.size()){
      for(int i=0 ; i<rightScale.size(); i++){
        System.out.print(leftScale.get(i));
      }
      System.out.print("|");
      for(int i=0 ; i<rightScale.size(); i++){
        System.out.print(rightScale.get(i));
      }
    }
    else {
      System.out.println("Impossible");
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF382_D2_A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var init : String ; init := scanner.nextLine() ;
    var left : String ; left := scanner.nextLine() ;
    var leftScale : Sequence(String) ; leftScale := Sequence{} ;
    var rightScale : Sequence(String) ; rightScale := Sequence{} ;
    var visited : boolean ; visited := false ;
        var i : int ; i := 0 ; while i < init->size() do ( (     if (init->at(i+1) = '|') then (     visited := true ; 
     continue ) else skip ; 
     if (visited) then (     rightScale := rightScale->including(init->at(i+1)) ) else (     leftScale := leftScale->including(init->at(i+1)) ) )  ;     i := i + 1 ) ; 
    var leftWeight : Sequence(String) ; leftWeight := Sequence{} ;
        var i : int ; i := 0 ; while i < left->size() do ( (     leftWeight := leftWeight->including(left->at(i+1)) )  ;     i := i + 1 ) ; 
    while (not(leftWeight->isEmpty())) do (     if (leftScale->size() > rightScale->size()) then (     rightScale := rightScale->including(leftWeight->first()) ) else     if (leftScale->size() < rightScale->size()) then (     leftScale := leftScale->including(leftWeight->first()) ) else (     rightScale := rightScale->including(leftWeight->first()) ) ;  ) ; 
    if (leftScale->size() = rightScale->size()) then (         var i : int ; i := 0 ; while i < rightScale->size() do ( (     OclFile["System.out"].print(leftScale->at(i+1)) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("|") ; 
         var i : int ; i := 0 ; while i < rightScale->size() do ( (     OclFile["System.out"].print(rightScale->at(i+1)) )  ;     i := i + 1 ) ) else (     OclFile["System.out"].println("Impossible") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static int n ;
  static int k ;
  static int[] a ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    k=sc.nextInt();
    a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    Arrays.sort(a);
    if(check(0)){
      System.out.println(0);
      System.exit(0);
    }
    if(! check(n-1)){
      System.out.println(n);
      System.exit(0);
    }
    int hi=n-1 ;
    int lo=0 ;
    while(hi-lo>1){
      int mid=(lo+hi)/2 ;
      if(check(mid))hi=mid ;
      else lo=mid ;
    }
    System.out.println(hi);
  }
  static boolean check(int idx){
    int cur=a[idx];
    boolean[] range=new boolean[k+1];
    range[0]=true ;
    for(int i=0 ; i<n ; i++){
      if(i==idx)continue ;
      int now=a[i];
      for(int j=k ; j>=now ; j--){
        if(range[j-now]){
          range[j]=true ;
          if(k-cur<=j && j<k)return true ;
        }
      }
    }
    for(int j=Math.max(0,k-cur); j<k ; j++){
      if(range[j])return true ;
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute k : int;
  static   attribute a : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    k := sc.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    if (check(0)) then (     OclFile["System.out"].println(0) ; 
 OclProcess.exit(0) ) else skip ; 
    if (not(check(n - 1))) then (     OclFile["System.out"].println(n) ; 
 OclProcess.exit(0) ) else skip ; 
    var hi : int ; hi := n - 1 ;
    var lo : int ; lo := 0 ;
    while (hi - lo > 1) do (     var mid : int ; mid := (lo + hi) / 2 ;
     if (check(mid)) then     hi := mid ; else     lo := mid ; ) ; 
    OclFile["System.out"].println(hi) ; 
 );
  static   operation check( idx : int) : boolean
  pre: true
  post: true
  activity: (     var cur : int ; cur := a[idx+1] ;
     var range : Sequence(boolean) ; range := Integer.subrange(1,k + 1)->collect(false) ;
    range[0+1] := true ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i = idx) then     continue else skip ; 
     var now : int ; now := a[i+1] ;
         var j : int ; j := k ; while j >= now do ( (     if (range[j - now+1]) then (     range[j+1] := true ; 
     if (k - cur <= j & j < k) then     return true else skip ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
        var j : int ; j := Set{0, k - cur}->max() ; while j < k do ( (     if (range[j+1]) then     return true else skip )  ;     j := j + 1 ) ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter o=new PrintWriter(System.out);
    int T=sc.nextInt();
    while(T-->0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        if(arr[i]<=2048){
          sum+=arr[i];
        }
      }
      if(sum>=2048){
        o.println("YES");
      }
      else {
        o.println("NO");
      }
    }
    o.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var o : OclFile ; o := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] <= 2048) then (     sum := sum+(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    if (sum >= 2048) then (     skip ) else (     skip ) ;  
 ) ;  ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++)a[i]=sc.nextInt();
    Arrays.sort(a);
    int min=-1 ;
    int max=N ;
    while(min+1<max){
      int mid=(min+max)/2 ;
      boolean[] visited=new boolean[K];
      visited[0]=true ;
      for(int i=0 ; i<N ; i++){
        if(i==mid)continue ;
        for(int j=K-1 ; j>=0 ; j--)if(visited[j] && j+a[i]<K)visited[j+a[i] ]=true ;
      }
      boolean ok=false ;
      for(int i=K-1 ; i+a[mid]>=K && i>=0 ; i--)if(visited[i]){
        ok=true ;
        break ;
      }
      if(ok){
        max=mid ;
      }
      else {
        min=mid ;
      }
    }
    System.out.println(max);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var min : int ; min := -1 ;
    var max : int ; max := N ;
    while (min + 1 < max) do (     var mid : int ; mid := (min + max) / 2 ;
     var visited : Sequence(boolean) ; visited := Integer.subrange(1,K)->collect(false) ;
    visited[0+1] := true ; 
        var i : int ; i := 0 ; while i < N do ( (     if (i = mid) then     continue else skip ; 
         var j : int ; j := K - 1 ; while j >= 0 do (     if (visited[j+1] & j + a[i+1] < K) then     visited[j + a[i+1]+1] := true ; else skip ;  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    var ok : boolean ; ok := false ;
        var i : int ; i := K - 1 ; while i + a[mid+1] >= K & i >= 0 do (     if (visited[i+1]) then (     ok := true ; 
     break ) else skip ;  ;     i := i - 1 ) ; 
    if (ok) then (     max := mid ) else (     min := mid ) ;  
 ) ; 
    OclFile["System.out"].println(max) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    long[] a=new long[N];
    for(int i=0 ; i<N ; ++i){
      a[i]=sc.nextLong();
    }
    Arrays.sort(a);
    boolean[] vis=new boolean[K];
    vis[0]=true ;
    int ok=N ;
    for(int i=N-1 ; i>=0 ; --i){
      for(int j=K-1 ; j>=0 ; --j){
        if(! vis[j])continue ;
        if(j+a[i]>=K)ok=i ;
        else {
          vis[(int)(j+a[i])]=true ;
        }
      }
    }
    System.out.println(ok);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var vis : Sequence(boolean) ; vis := Integer.subrange(1,K)->collect(false) ;
    vis[0+1] := true ; 
    var ok : int ; ok := N ;
        var i : int ; i := N - 1 ; while i >= 0 do ( (         var j : int ; j := K - 1 ; while j >= 0 do ( (     if (not(vis[j+1])) then     continue else skip ; 
     if (j + a[i+1] >= K) then     ok := i ; else (     vis[(j + a[i+1])->oclAsType(int)+1] := true ) )  ;     j := j - 1 ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ok) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test168 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      char s[]=in.next().toCharArray();
      int sum=0 ;
      for(int i=0 ; i<s.length ; i++){
        if(s[i]=='B'){
          sum++;
        }
      }
      if(sum*2==s.length){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test168 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var s : Sequence(String) ; s := in.getCurrent()->characters() ;
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s[i+1] = 'B') then (     sum := sum + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (sum * 2 = s->size()) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Casimir {
  int number ;
  HashMap<Character,Integer>mapList=new HashMap<>();
  public Casimir(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  public void inputInMap(String s){
    mapList.put('A',0);
    mapList.put('B',0);
    mapList.put('C',0);
    for(int i=0 ; i<s.length(); i++){
      mapList.replace(s.charAt(i),mapList.get(s.charAt(i)),mapList.get(s.charAt(i))+1);
    }
  }
  public void input(String s){
    inputInMap(s);
    if(mapList.get('A')+mapList.get('C')==mapList.get('B')){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
    mapList.clear();
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    Casimir instance=new Casimir(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      String s=input.next();
      instance.input(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Casimir {
   attribute number : int;
   attribute mapList : Map(String,int) := Map{};
   static operation newCasimir( number : int) : Casimir
  pre: true
  post: true
  activity:
  ( var self : Casimir ;
    self := createCasimir();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
   operation inputInMap( s : String) : void
  pre: true
  post: true
  activity: (     mapList := mapList->union(Map{'A' |-> 0}) ; 
     mapList := mapList->union(Map{'B' |-> 0}) ; 
     mapList := mapList->union(Map{'C' |-> 0}) ; 
         var i : int ; i := 0 ; while i < s->size() do ( (     mapList := mapList.replace(s->at(i+1), mapList->at(s->at(i+1)), mapList->at(s->at(i+1)) + 1) )  ;     i := i + 1 ) );
   operation input( s : String) : void
  pre: true
  post: true
  activity: (     execute inputInMap(s) ; 
     if (mapList->at('A') + mapList->at('C') = mapList->at('B')) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
     mapList := mapList->intersection(Map{}) );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
     var instance : Casimir ; instance := Casimir.newCasimir(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var s : String ; s := input.getCurrent() ;
     instance.input(s) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  int[][] dig_num={
    {
      0,1,1,1,1,1,1 },{
        0,0,0,0,1,1,0 },{
          1,0,1,1,0,1,1 },{
            1,0,0,1,1,1,1 },{
              1,1,0,0,1,1,0 },{
                1,1,0,1,1,0,1 },{
                  1,1,1,1,1,0,1 },{
                    0,1,0,0,1,1,1 },{
                      1,1,1,1,1,1,1 },{
                        1,1,0,1,1,1,1 },{
                          0,0,0,0,0,0,0 }
                        };
                        void run(){
                          Scanner sc=new Scanner(System.in);
                          for(; ; ){
                            int n=sc.nextInt();
                            if(n==-1)break ;
                            int[] num=new int[7];
                            int p=10 ;
                            for(int i=0 ; i<n ; i++){
                              int dig=sc.nextInt();
                              for(int j=0 ; j<7 ; j++){
                                num[j]=(dig_num[p][j]+dig_num[dig][j])% 2 ;
                                System.out.print(num[j]);
                              }
                              System.out.println();
                              p=dig ;
                            }
                          }
                        }
                        public static void main(String[] args){
                          new Main().run();
                        }
                      }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute dig_num : Sequence(Sequence(int)) := Sequence{Sequence{0,1,1,1,1,1,1},Sequence{0,0,0,0,1,1,0},Sequence{1,0,1,1,0,1,1},Sequence{1,0,0,1,1,1,1},Sequence{1,1,0,0,1,1,0},Sequence{1,1,0,1,1,0,1},Sequence{1,1,1,1,1,0,1},Sequence{0,1,0,0,1,1,1},Sequence{1,1,1,1,1,1,1},Sequence{1,1,0,1,1,1,1},Sequence{0,0,0,0,0,0,0}};
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = -1) then     break else skip ; 
    var num : Sequence(int) ; num := Integer.subrange(1,7)->collect(0) ;
    var p : int ; p := 10 ;
        var i : int ; i := 0 ; while i < n do ( (     var dig : int ; dig := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < 7 do ( (     num[j+1] := (dig_num[p+1][j+1] + dig_num[dig+1][j+1]) mod 2 ; 
     OclFile["System.out"].print(num[j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() ; 
     p := dig )  ;     i := i + 1 ) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int a=0,b=0,c=0 ;
      String s=sc.next();
      for(int j=0 ; j<s.length(); j++){
        if(s.charAt(j)=='A')a++;
        else if(s.charAt(j)=='B')b++;
        else c++;
      }
      if(a+c==b)System.out.println("YES");
      else System.out.println("NO");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : int ; a := 0 ;
    var b : int ; b := 0 ;
    var c : int ; c := 0 ;
     var s : String ; s := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < s->size() do ( (     if (s->at(j+1) = 'A') then     a := a + 1 ; else     if (s->at(j+1) = 'B') then     b := b + 1 else     c := c + 1 ; ;  )  ;     j := j + 1 ) ; 
     if (a + c = b) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1579A_CasimirsStringSolitaire {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      String str=input.nextLine();
      int As=0 ;
      int Bs=0 ;
      int Cs=0 ;
      for(char c : str.toCharArray()){
        if(c=='A'){
          As++;
        }
        else if(c=='B'){
          Bs++;
        }
        else if(c=='C'){
          Cs++;
        }
      }
      if(As+Cs==Bs){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1579A_CasimirsStringSolitaire {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var str : String ; str := input.nextLine() ;
     var As : int ; As := 0 ;
    var Bs : int ; Bs := 0 ;
    var Cs : int ; Cs := 0 ;
    for (c : str->characters()) do ( (     if (c = 'A') then (     As := As + 1 ) else     if (c = 'B') then (     Bs := Bs + 1 ) else     if (c = 'C') then (     Cs := Cs + 1 ) else skip ; ;  )  ) ; 
    if (As + Cs = Bs) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX_CHAR=256 ;
  static int fact(int n){
    return(n<=1)? 1 : n*fact(n-1);
  }
  static void populateAndIncreaseCount(int[] count,char[] str){
    int i ;
    for(i=0 ; i<str.length ; ++i)++count[str[i] ];
    for(i=1 ; i<MAX_CHAR ; ++i)count[i]+=count[i-1];
  }
  static void updatecount(int[] count,char ch){
    int i ;
    for(i=ch ; i<MAX_CHAR ; ++i)--count[i];
  }
  static int findRank(char[] str){
    int len=str.length ;
    int mul=fact(len);
    int rank=1,i ;
    int count[]=new int[MAX_CHAR];
    populateAndIncreaseCount(count,str);
    for(i=0 ; i<len ; ++i){
      mul/=len-i ;
      rank+=count[str[i]-1]*mul ;
      updatecount(count,str[i]);
    }
    return rank ;
  }
  public static void main(String args[]){
    char str[]="string".toCharArray();
    System.out.println(findRank(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX_CHAR : int := 256;
  static   operation fact( n : int) : int
  pre: true
  post: true
  activity: (     return if (n <= 1) then 1 else n * fact(n - 1) endif );
  static   operation populateAndIncreaseCount( count : Sequence(int), str : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
         i := 0 ; while i < str->size() do (     count[str[i+1]+1] := count[str[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
         i := 1 ; while i < MAX_CHAR do (     count[i+1] := count[i+1]+(count[i - 1+1]) ;  ;     i := i + 1 ) );
  static   operation updatecount( count : Sequence(int), ch : String) : void
  pre: true
  post: true
  activity: (     var i : int ;
         i := ch ; while i < MAX_CHAR do (     count[i+1] := count[i+1] - 1 ;  ;     i := i + 1 ) );
  static   operation findRank( str : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     var mul : int ; mul := fact(len) ;
    var rank : int ; rank := 1 ;
    var i : int ;
    var count : Sequence(int) ; count := Integer.subrange(1,MAX_CHAR)->collect(0) ;
    execute populateAndIncreaseCount(count, str) ; 
        i := 0 ; while i < len do ( (     mul := mul/(len - i) ; 
     rank := rank+(count[str[i+1] - 1+1] * mul) ; 
     execute updatecount(count, str[i+1]) )  ;     i := i + 1 ) ; 
    return rank 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := "string"->characters() ;
     OclFile["System.out"].println(findRank(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int trailingZeroes(int n){
    int cnt=0 ;
    while(n>0){
      n/=5 ;
      cnt+=n ;
    }
    return cnt ;
  }
  static void binarySearch(int n){
    int low=0 ;
    int high=1000000 ;
    while(low<high){
      int mid=(low+high)/2 ;
      int count=trailingZeroes(mid);
      if(count<n)low=mid+1 ;
      else high=mid ;
    }
    int result[]=new int[1000];
    int k=0 ;
    while(trailingZeroes(low)==n){
      result[k]=low ;
      k++;
      low++;
    }
    for(int i=0 ; i<k ; i++)System.out.print(result[i]+" ");
  }
  public static void main(String args[]){
    int n=3 ;
    binarySearch(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation trailingZeroes( n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     while (n > 0) do (     n := n/(5) ; 
     cnt := cnt+(n) ) ; 
     return cnt );
  static   operation binarySearch( n : int) : void
  pre: true
  post: true
  activity: (     var low : int ; low := 0 ;
     var high : int ; high := 1000000 ;
    while (low < high) do (     var mid : int ; mid := (low + high) / 2 ;
     var count : int ; count := trailingZeroes(mid) ;
     if (count < n) then     low := mid + 1 ; else     high := mid ; ) ; 
    var result : Sequence(int) ; result := Integer.subrange(1,1000)->collect(0) ;
    var k : int ; k := 0 ;
    while (trailingZeroes(low) = n) do (     result[k+1] := low ; 
     k := k + 1 ; 
     low := low + 1 ) ; 
        var i : int ; i := 0 ; while i < k do (     OclFile["System.out"].print(result[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     execute binarySearch(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Count {
  public static int MDAS_Factorial(int N){
    if(N<=2)return N ;
    if(N<=4)return(N+3);
    if((N-4)% 4==0)return(N+1);
    else if((N-4)% 4<=2)return(N+2);
    else return(N-1);
  }
  public static void main(String[] args){
    int N=4 ;
    System.out.println(MDAS_Factorial(N));
    N=10 ;
    System.out.println(MDAS_Factorial(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Count {
  static   operation MDAS_Factorial( N : int) : int
  pre: true
  post: true
  activity: (     if (N <= 2) then     return N else skip ; 
     if (N <= 4) then     return (N + 3) else skip ; 
     if ((N - 4) mod 4 = 0) then     return (N + 1) else     if ((N - 4) mod 4 <= 2) then     return (N + 2) else     return (N - 1) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(MDAS_Factorial(N)) ; 
     N := 10 ; 
     OclFile["System.out"].println(MDAS_Factorial(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=br.readLine();
    System.out.println(str.toUpperCase());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := br.readLine() ;
     OclFile["System.out"].println(str->toUpperCase()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.nio.charset.MalformedInputException ;
import java.util.StringTokenizer ;
import java.util.ArrayList ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter o=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int k=sc.nextInt();
      int sum=0 ;
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
        sum+=arr[i];
      }
      o.println(Math.min(sum,k));
    }
    o.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var o : OclFile ; o := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    String str ;
    char[] ch ;
    int i,n,m ;
    n='a'-'A' ;
    str=sc.nextLine();
    m=str.length();
    ch=new char[m];
    for(i=0 ; i<m ; i++){
      ch[i]=str.charAt(i);
      if(ch[i]>='a' && ch[i]<='z'){
        ch[i]-=n ;
      }
    }
    for(i=0 ; i<m ; i++){
      System.out.print(ch[i]);
    }
    System.out.println();
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var str : String ;
    var ch : Sequence(String) ;
    var i : int ;
    var n : int ;
    var m : int ;
    n := ('a')->char2byte() - ('A')->char2byte() ; 
    str := sc.nextLine() ; 
    m := str->size() ; 
    ch := Integer.subrange(1,m)->collect(0) ; 
        i := 0 ; while i < m do ( (     ch[i+1] := str->at(i+1) ; 
     if (ch[i+1] >= 'a' & ch[i+1] <= 'z') then (     ch[i+1] := ch[i+1]-(n) ) else skip )  ;     i := i + 1 ) ; 
        i := 0 ; while i < m do ( (     OclFile["System.out"].print(ch[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  Scanner sc=new Scanner(System.in);
  public void run(){
    ln(sc.nextLine().toUpperCase());
  }
  public static void main(String[] args){
    new Main().run();
  }
  public static void pr(Object o){
    System.out.print(o);
  }
  public static void ln(Object o){
    System.out.println(o);
  }
  public static void ln(){
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     execute ln(sc.nextLine()->toUpperCase()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    StringTokenizer st ;
    try {
      char c ;
      String line ;
      line=br.readLine();
      for(int i=0 ; i<line.length(); i++){
        c=line.charAt(i);
        if(Character.isLowerCase(c)){
          c=Character.toUpperCase(c);
        }
        sb.append(c);
      }
      System.out.println(sb.toString());
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
     var st : OclIterator ;
     try (     var c : String ;
     var line : String ;
    line := br.readLine() ; 
        var i : int ; i := 0 ; while i < line->size() do ( (     c := line->at(i+1) ; 
     if ((c->toLowerCase() = c)) then (     c := (c + "")->toUpperCase() ) else skip ; 
     sb := sb + StringLib.newString(c) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  private static int[] a ;
  private static int[][] dp ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int z=sc.nextInt();
    int w=sc.nextInt();
    a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    dp=new int[n+1][2];
    for(int i=0 ; i<=n ; i++){
      Arrays.fill(dp[i],-1);
    }
    System.out.println(dfs(0,0,z,w));
  }
  private static int dfs(int current,int who,int z,int w){
    if(current>=a.length){
      dp[current][who]=Math.abs(z-w);
      return dp[current][who];
    }
    if(dp[current][who]>=0)return dp[current][who];
    int score ;
    if(who==0){
      score=Integer.MIN_VALUE ;
      for(int k=current ; k<a.length ; k++){
        score=Math.max(score,dfs(k+1,1,a[k],w));
      }
    }
    else {
      score=Integer.MAX_VALUE ;
      for(int k=current ; k<a.length ; k++){
        score=Math.min(score,dfs(k+1,0,z,a[k]));
      }
    }
    dp[current][who]=score ;
    return dp[current][who];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a : Sequence(int);
  static   attribute dp : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var z : int ; z := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    a := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,2)->collect(0)) ; 
        var i : int ; i := 0 ; while i <= n do ( (     dp[i+1] := dp[i+1]->collect(-1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dfs(0, 0, z, w)) ; 
 );
  static   operation dfs( current : int, who : int, z : int, w : int) : int
  pre: true
  post: true
  activity: (     if (current >= a->size()) then (     dp[current+1][who+1] := if z - w < 0 then -(z - w) else z - w endif ; 
     return dp[current+1][who+1] ) else skip ; 
     if (dp[current+1][who+1] >= 0) then     return dp[current+1][who+1] else skip ; 
    var score : int ;
    if (who = 0) then (     score := -2147483648 ; 
         var k : int ; k := current ; while k < a->size() do ( (     score := Set{score, dfs(k + 1, 1, a[k+1], w)}->max() )  ;     k := k + 1 ) ) else (     score := 2147483647 ; 
         var k : int ; k := current ; while k < a->size() do ( (     score := Set{score, dfs(k + 1, 0, z, a[k+1])}->min() )  ;     k := k + 1 ) ) ;  
    dp[current+1][who+1] := score ; 
    return dp[current+1][who+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str ;
    try {
      while((str=br.readLine())!=null){
        char[] ch=str.toCharArray();
        for(int i=0 ; i<ch.length ; i++){
          if('a'<=ch[i] && 'z'>=ch[i]){
            ch[i]-=32 ;
          }
        }
        System.out.println(ch);
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ;
     try (         str := br.readLine() ;
    while ((str) /= null) do (    skip ; (     var ch : Sequence(String) ; ch := str->characters() ;
         var i : int ; i := 0 ; while i < ch->size() do ( (     if ('a' <= ch[i+1] & 'z' >= ch[i+1]) then (     ch[i+1] := ch[i+1]-(32) ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ch) ) ;     str := br.readLine() ;
 ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static boolean search(long a[],int k){
    int start=0 ;
    int end=a.length-1 ;
    while(true){
      if(a[start]==k || a[end]==k)return true ;
      else {
        int mid=(start+end)/2 ;
        if(a[mid]==k)return true ;
        else if(a[mid]>k)end=mid ;
        else start=mid ;
      }
      if(start+1>=end)return false ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long a[]=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextLong();
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      int k=sc.nextInt();
      if(search(a,k))System.out.println(1);
      else System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation search( a : Sequence(long), k : int) : boolean
  pre: true
  post: true
  activity: (     var start : int ; start := 0 ;
     var end : int ; end := a->size() - 1 ;
     while (true) do (     if (a[start+1] = k or a[end+1] = k) then     return true else (     var mid : int ; mid := (start + end) / 2 ;
     if (a[mid+1] = k) then     return true else     if (a[mid+1] > k) then     end := mid else     start := mid ; ;  ) ;  
     if (start + 1 >= end) then     return false else skip ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var k : int ; k := sc.getCurrent()->toInteger() ;
     if (search(a, k)) then     OclFile["System.out"].println(1) ; else     OclFile["System.out"].println(0) ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=Integer.parseInt(in.next()),A[]=new int[n];
    for(int i=0 ; i<n ; i++)A[i]=Integer.parseInt(in.next());
    int q=Integer.parseInt(in.next());
    for(int i=0 ; i<q ; i++){
      int key=Integer.parseInt(in.next());
      if(Arrays.binarySearch(A,key)>=0){
        out.println(1);
      }
      else {
        out.println(0);
      }
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (in.getCurrent())->toInteger() ;
    var A : Sequence(void) ; A := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     A[i+1] := (in.getCurrent())->toInteger() ;  ;     i := i + 1 ) ; 
    var q : int ; q := (in.getCurrent())->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var key : int ; key := (in.getCurrent())->toInteger() ;
     if ((A->indexOf(key) - 1) >= 0) then (     skip ) else (     skip ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void nibutan(int array[],int length,int num){
    int pos=-1 ;
    int lower=0 ;
    int upper=length-1 ;
    while(lower<=upper){
      int mid=(lower+upper)/2 ;
      if(array[mid]==num){
        pos=mid ;
        break ;
      }
      else if(array[mid]<num){
        lower=mid+1 ;
      }
      else {
        upper=mid-1 ;
      }
    }
    if(pos!=-1){
      System.out.println(1);
    }
    else {
      System.out.println(0);
    }
  }
  public static void main(String args[]){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    int a[]=new int[n];
    int count=1 ;
    a[0]=stdIn.nextInt();
    for(int i=1 ; i<n ; i++){
      int num=stdIn.nextInt();
      if(a[count-1]!=num){
        a[count++]=num ;
      }
    }
    int q=stdIn.nextInt();
    for(int i=0 ; i<q ; i++){
      int k=stdIn.nextInt();
      nibutan(a,count,k);
    }
    stdIn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation nibutan( array : Sequence(int), length : int, num : int) : void
  pre: true
  post: true
  activity: (     var pos : int ; pos := -1 ;
     var lower : int ; lower := 0 ;
    var upper : int ; upper := length - 1 ;
    while (lower <= upper) do (     var mid : int ; mid := (lower + upper) / 2 ;
     if (array[mid+1] = num) then (     pos := mid ; 
     break ) else     if (array[mid+1] < num) then (     lower := mid + 1 ) else (     upper := mid - 1 ) ;  ) ; 
    if (pos /= -1) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(0) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var count : int ; count := 1 ;
    a[0+1] := stdIn.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i < n do ( (     var num : int ; num := stdIn.getCurrent()->toInteger() ;
     if (a[count - 1+1] /= num) then (      a[count+1] := num  ; count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    var q : int ; q := stdIn.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var k : int ; k := stdIn.getCurrent()->toInteger() ;
     execute nibutan(a, count, k) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args)throws InterruptedException {
    Scanner s=new Scanner(System.in);
    int listLen=Integer.parseInt(s.nextLine());
    Thread.sleep(1);
    HashMap<Integer,Boolean>map=new HashMap<>(listLen*2);
    for(int i=0 ; i<listLen ; ++i){
      map.put(Integer.parseInt(s.next()),true);
    }
    StringBuilder sb=new StringBuilder(listLen*2);
    int numQueries=s.nextInt();
    for(int i=0 ; i<numQueries ; ++i){
      int x=s.nextInt();
      sb.append(map.get(x)!=null ? "1\n" : "0\n");
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var listLen : int ; listLen := (s.nextLine())->toInteger() ;
    OclProcess.sleep(1) ; 
    var map : Map(int,Boolean) ; map := Map{}->union(listLen * 2) ;
        var i : int ; i := 0 ; while i < listLen do ( (     map := map->union(Map{(s.getCurrent())->toInteger() |-> true}) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString(listLen * 2) ;
    var numQueries : int ; numQueries := s.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < numQueries do ( (     var x : int ; x := s.getCurrent()->toInteger() ;
     sb := sb + StringLib.newString(if map->at(x) /= null then "1\n" else "0\n" endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static StringBuilder sb ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sb=new StringBuilder();
    int num=sc.nextInt();
    ArrayList<Integer>array=new ArrayList<>();
    for(int i=0 ; i<num ; i++){
      array.add(sc.nextInt());
    }
    int num_query=sc.nextInt();
    for(int i=0 ; i<num_query ; i++){
      int key=sc.nextInt();
      if(Collections.binarySearch(array,key)<0)sb.append(0).append("\n");
      else sb.append(1).append("\n");
    }
    System.out.print(sb);
    sc.close();
  }
  public static int binarySearch(List<Integer>list,int key){
    int lower=0 ;
    int middle=-1 ;
    int upper=list.size();
    while(upper>lower+1){
      middle=lower+(upper-lower)/2 ;
      if(list.get(middle)>key)upper=middle ;
      else lower=middle ;
    }
    return upper ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sb : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     sb := StringLib.newString() ; 
    var num : int ; num := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Sequence{} ;
        var i : int ; i := 0 ; while i < num do ( (     array := array->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var num_query : int ; num_query := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < num_query do ( (     var key : int ; key := sc.getCurrent()->toInteger() ;
     if ((array->indexOf(key) - 1) < 0) then     sb := sb + StringLib.newString(0) + StringLib.newString("\n") ; else     sb := sb + StringLib.newString(1) + StringLib.newString("\n") ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
    skip ; 
 );
  static   operation binarySearch( list : Sequence(int), key : int) : int
  pre: true
  post: true
  activity: (     var lower : int ; lower := 0 ;
     var middle : int ; middle := -1 ;
    var upper : int ; upper := list->size() ;
    while (upper > lower + 1) do (     middle := lower + (upper - lower) / 2 ; 
     if (list->at(middle+1) > key) then     upper := middle ; else     lower := middle ; ) ; 
    return upper 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1398B_SubstringRemoval {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      String str=input.nextLine().replaceAll("0+"," ").trim();
      List<String>list=new ArrayList<>(Arrays.asList(str.split(" ")));
      Collections.sort(list,Collections.reverseOrder());
      int result=0 ;
      for(int i=0 ; i<list.size(); i+=2){
        result+=list.get(i).length();
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1398B_SubstringRemoval {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var str : String ; str := input.nextLine().replaceAllMatches("0+", " " )->trim() ;
     var list : Sequence(String) ; list := Sequence{}->union(str->split(" ")) ;
    list, reverseOrder() := list, reverseOrder()->sort() ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < list->size() do ( (     result := result+(list->at(i+1)->size()) )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(result) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    int t=nextInt();
    for(int i=0 ; i<t ; i++){
      int n=nextInt();
      int m=nextInt();
      int[] c=new int[n];
      int sum=0 ;
      for(int j=0 ; j<n ; j++){
        c[j]=nextInt();
        sum+=c[j];
      }
      System.out.println(Math.min(sum,m));
    }
  }
  static class Edge implements Comparable<Edge>{
    int first,second ;
    public Edge(int first,int second){
      this.first=first ;
      this.second=second ;
    }
    @ Override public int compareTo(Edge o){
      if(first!=o.first)return Integer.compare(first,o.first);
      return Integer.compare(second,o.second);
    }
  }
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter out=new PrintWriter(System.out);
  static StringTokenizer in=new StringTokenizer("");
  public static String nextToken()throws IOException {
    while(in==null || ! in.hasMoreTokens()){
      in=new StringTokenizer(br.readLine());
    }
    return in.nextToken();
  }
  public static int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public static double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  public static long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := nextInt() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := nextInt() ;
     var m : int ; m := nextInt() ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     c[j+1] := nextInt() ; 
     sum := sum+(c[j+1]) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(Set{sum, m}->min()) ; 
 )  ;     i := i + 1 ) );
  static class Edge implements Comparable<Edge> {
   attribute first : int;
   static operation newEdge( first : int, second : int) : Edge
  pre: true
  post: true
  activity:
  ( var self : Edge ;
    self := createEdge();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
      operation compareTo( o : Edge) : int
  pre: true
  post: true
  activity: (     if (first /= o->at("first")) then     return compare(first, o->at("first")) else skip ; 
     return compare(second, o->at("second")) );
}
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclIterator := OclIterator.newOclIterator_String("");
  static   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (in = null or not(in.hasNext())) do (     in := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return in.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class SubstringRemovalGame {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    ArrayList<Integer>con=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      String str=br.readLine();
      int count=0 ;
      int tempcount=0 ;
      if(str.charAt(0)=='0')str=str.substring(1);
      str=str+"0" ;
      for(int j=0 ; j<str.length(); j++){
        if(str.charAt(j)=='1')tempcount++;
        else {
          if(tempcount>0){
            con.add(tempcount);
          }
          tempcount=0 ;
        }
      }
      Collections.sort(con,Collections.reverseOrder());
      for(int j=0 ; j<con.size(); j+=2)count=count+con.get(j);
      System.out.println(count);
      con.clear();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SubstringRemovalGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
     var con : Sequence(int) ; con := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := br.readLine() ;
     var count : int ; count := 0 ;
    var tempcount : int ; tempcount := 0 ;
    if (str->at(0+1) = '0') then     str := str.subrange(1+1,1) ; else skip ; 
    str := str + "0" ; 
        var j : int ; j := 0 ; while j < str->size() do ( (     if (str->at(j+1) = '1') then     tempcount := tempcount + 1 ; else (     if (tempcount > 0) then (     con := con->including(tempcount) ) else skip ; 
     tempcount := 0 ) )  ;     j := j + 1 ) ; 
    con, reverseOrder() := con, reverseOrder()->sort() ; 
        var j : int ; j := 0 ; while j < con->size() do (     count := count + con->at(j+1) ;  ;     j := j+(2) ) ; 
    OclFile["System.out"].println(count) ; 
    con := con->intersection(Set{}) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class test296 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      char x[]=in.next().toCharArray();
      int a[]=new int[x.length];
      int sum=0,k=0 ;
      for(int i=0 ; i<x.length ; i++){
        if(x[i]=='1'){
          sum++;
        }
        else {
          a[k++]=sum ;
          sum=0 ;
        }
      }
      if(sum>0){
        for(int i=0 ; i<x.length ; i++){
          if(a[i]==0){
            a[i]=sum ;
            break ;
          }
        }
      }
      Arrays.sort(a);
      int m=0 ;
      for(int i=x.length-1 ; i>=0 && a[i]>=0 ; i-=2){
        m+=a[i];
      }
      System.out.println(m);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test296 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var x : Sequence(String) ; x := in.getCurrent()->characters() ;
     var a : Sequence(int) ; a := Integer.subrange(1,x->size())->collect(0) ;
    var sum : int ; sum := 0 ;
    var k : int ; k := 0 ;
        var i : int ; i := 0 ; while i < x->size() do ( (     if (x[i+1] = '1') then (     sum := sum + 1 ) else (      a[k+1] := sum  ; k := k + 1 ; 
     sum := 0 ) )  ;     i := i + 1 ) ; 
    if (sum > 0) then (         var i : int ; i := 0 ; while i < x->size() do ( (     if (a[i+1] = 0) then (     a[i+1] := sum ; 
     break ) else skip )  ;     i := i + 1 ) ) else skip ; 
    a := a->sort() ; 
    var m : int ; m := 0 ;
        var i : int ; i := x->size() - 1 ; while i >= 0 & a[i+1] >= 0 do ( (     m := m+(a[i+1]) )  ;     i := i-(2) ) ; 
    OclFile["System.out"].println(m) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String[] inputArr=sc.nextLine().split(" ");
    sc.close();
    int h=Integer.parseInt(inputArr[0]);
    int w=Integer.parseInt(inputArr[1]);
    int a=Integer.parseInt(inputArr[2]);
    int b=Integer.parseInt(inputArr[3]);
    int hMinasB=h-b ;
    int wMinasA=w-a ;
    String zeroFirstStr="" ;
    String oneFirstStr="" ;
    for(int i=0 ; i<wMinasA ; i++){
      zeroFirstStr+="0" ;
      oneFirstStr+="1" ;
    }
    for(int i=0 ; i<a ; i++){
      zeroFirstStr+="1" ;
      oneFirstStr+="0" ;
    }
    for(int i=0 ; i<b ; i++){
      System.out.println(zeroFirstStr);
    }
    for(int i=0 ; i<hMinasB ; i++){
      System.out.println(oneFirstStr);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inputArr : Sequence(String) ; inputArr := sc.nextLine()->split(" ") ;
    skip ; 
    var h : int ; h := (inputArr[0+1])->toInteger() ;
    var w : int ; w := (inputArr[1+1])->toInteger() ;
    var a : int ; a := (inputArr[2+1])->toInteger() ;
    var b : int ; b := (inputArr[3+1])->toInteger() ;
    var hMinasB : int ; hMinasB := h - b ;
    var wMinasA : int ; wMinasA := w - a ;
    var zeroFirstStr : String ; zeroFirstStr := "" ;
    var oneFirstStr : String ; oneFirstStr := "" ;
        var i : int ; i := 0 ; while i < wMinasA do ( (     zeroFirstStr := zeroFirstStr+("0") ; 
     oneFirstStr := oneFirstStr+("1") )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a do ( (     zeroFirstStr := zeroFirstStr+("1") ; 
     oneFirstStr := oneFirstStr+("0") )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < b do ( (     OclFile["System.out"].println(zeroFirstStr) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < hMinasB do ( (     OclFile["System.out"].println(oneFirstStr) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Queue ;
import java.util.Arrays ;
public class GFG {
  static int minimumBox(int[] arr,int n){
    Queue<Integer>q=new LinkedList<>();
    Arrays.sort(arr);
    q.add(arr[0]);
    for(int i=1 ; i<n ; i++){
      int now=q.element();
      if(arr[i]>=2*now)q.remove();
      q.add(arr[i]);
    }
    return q.size();
  }
  public static void main(String args[]){
    int[] arr={
      4,1,2,8 };
      int n=arr.length ;
      System.out.println(minimumBox(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumBox( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var q : Sequence(int) ; q := Sequence{} ;
     arr := arr->sort() ; 
    q := q->including(arr[0+1]) ; 
        var i : int ; i := 1 ; while i < n do ( (     var now : int ; now := q.element() ;
     if (arr[i+1] >= 2 * now) then     q := q.remove() ; else skip ; 
     q := q->including(arr[i+1]) )  ;     i := i + 1 ) ; 
    return q->size() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,1,2,8} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minimumBox(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
import java.util.Scanner ;
public class ndtu {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int test=in.nextInt();
    for(int q=0 ; q<test ; q++){
      int n=in.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=in.nextInt();
      }
      HashMap<Integer,Integer>maps=new HashMap<>();
      int anss[]=new int[n];
      for(int i=0 ; i<n ; i++){
        if(! maps.containsKey(arr[i])){
          anss[arr[i]-1]=1 ;
          maps.put(arr[i],i);
        }
        else {
          if((i-maps.get(arr[i]))% 2!=0){
            anss[arr[i]-1]++;
          }
          maps.put(arr[i],i);
        }
      }
      for(int i=0 ; i<anss.length ; i++){
        System.out.print(anss[i]+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ndtu {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := in.getCurrent()->toInteger() ;
         var q : int ; q := 0 ; while q < test do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var maps : Map(int,int) ; maps := Map{} ;
    var anss : Sequence(int) ; anss := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     if (not(maps->keys()->includes(arr[i+1]))) then (     anss[arr[i+1] - 1+1] := 1 ; 
     maps := maps->union(Map{arr[i+1] |-> i}) ) else (     if ((i - maps->at(arr[i+1])) mod 2 /= 0) then (     anss[arr[i+1] - 1+1] := anss[arr[i+1] - 1+1] + 1 ) else skip ; 
     maps := maps->union(Map{arr[i+1] |-> i}) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < anss->size() do ( (     OclFile["System.out"].print(anss[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     q := q + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      int odd[]=new int[n+1];
      int even[]=new int[n+1];
      for(int i=0 ; i<n ; i++){
        if(i % 2==0){
          even[arr[i] ]=odd[arr[i] ]+1 ;
        }
        else {
          odd[arr[i] ]=even[arr[i] ]+1 ;
        }
      }
      for(int i=1 ; i<=n ; i++){
        System.out.print(Math.max(even[i],odd[i])+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var odd : Sequence(int) ; odd := Integer.subrange(1,n + 1)->collect(0) ;
    var even : Sequence(int) ; even := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then (     even[arr[i+1]+1] := odd[arr[i+1]+1] + 1 ) else (     odd[arr[i+1]+1] := even[arr[i+1]+1] + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].print(Set{even[i+1], odd[i+1]}->max() + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B809 {
  public static void main(String ar[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      int n=sc.nextInt();
      int c[]=new int[n];
      int fir[]=new int[n];
      int count[]=new int[n];
      int maxCount[]=new int[n];
      for(int i=0 ; i<n ; i++){
        fir[i]=-1 ;
      }
      for(int i=0 ; i<n ; i++){
        c[i]=sc.nextInt();
        if(fir[c[i]-1]==-1){
          fir[c[i]-1]=i ;
        }
      }
      boolean flag=true ;
      for(int i=0 ; i<n ; i++){
        int dif=i-fir[c[i]-1];
        if(dif>=0 &&(dif % 2!=0 || dif==0)){
          count[c[i]-1]++;
          if(count[c[i]-1]>maxCount[c[i]-1]){
            maxCount[c[i]-1]=count[c[i]-1];
          }
          fir[c[i]-1]=i ;
        }
      }
      for(int i=0 ; i<n ; i++){
        System.out.print(maxCount[i]+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B809 {
  static   operation main( ar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tt : int ; tt := 0 ; while tt < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    var fir : Sequence(int) ; fir := Integer.subrange(1,n)->collect(0) ;
    var count : Sequence(int) ; count := Integer.subrange(1,n)->collect(0) ;
    var maxCount : Sequence(int) ; maxCount := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     fir[i+1] := -1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := sc.getCurrent()->toInteger() ; 
     if (fir[c[i+1] - 1+1] = -1) then (     fir[c[i+1] - 1+1] := i ) else skip )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < n do ( (     var dif : int ; dif := i - fir[c[i+1] - 1+1] ;
     if (dif >= 0 & (dif mod 2 /= 0 or dif = 0)) then (     count[c[i+1] - 1+1] := count[c[i+1] - 1+1] + 1 ; 
     if (count[c[i+1] - 1+1] > maxCount[c[i+1] - 1+1]) then (     maxCount[c[i+1] - 1+1] := count[c[i+1] - 1+1] ) else skip ; 
     fir[c[i+1] - 1+1] := i ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(maxCount[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     tt := tt + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int SieveOfAtkin(int limit){
    if(limit>2)System.out.print(2+" ");
    if(limit>3)System.out.print(3+" ");
    boolean sieve[]=new boolean[limit];
    for(int i=0 ; i<limit ; i++)sieve[i]=false ;
    for(int x=1 ; x*x<limit ; x++){
      for(int y=1 ; y*y<limit ; y++){
        int n=(4*x*x)+(y*y);
        if(n<=limit &&(n % 12==1 || n % 12==5))sieve[n] ^=true ;
        n=(3*x*x)+(y*y);
        if(n<=limit && n % 12==7)sieve[n] ^=true ;
        n=(3*x*x)-(y*y);
        if(x>y && n<=limit && n % 12==11)sieve[n] ^=true ;
      }
    }
    for(int r=5 ; r*r<limit ; r++){
      if(sieve[r]){
        for(int i=r*r ; i<limit ; i+=r*r)sieve[i]=false ;
      }
    }
    for(int a=5 ; a<limit ; a++)if(sieve[a])System.out.print(a+" ");
    return 0 ;
  }
  public static void main(String[] args){
    int limit=20 ;
    SieveOfAtkin(limit);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation SieveOfAtkin( limit : int) : int
  pre: true
  post: true
  activity: (     if (limit > 2) then     OclFile["System.out"].print(2 + " ") ; else skip ; 
     if (limit > 3) then     OclFile["System.out"].print(3 + " ") ; else skip ; 
    var sieve : Sequence(boolean) ; sieve := Integer.subrange(1,limit)->collect(false) ;
        var i : int ; i := 0 ; while i < limit do (     sieve[i+1] := false ;  ;     i := i + 1 ) ; 
        var x : int ; x := 1 ; while x * x < limit do ( (         var y : int ; y := 1 ; while y * y < limit do ( (     var n : int ; n := (4 * x * x) + (y * y) ;
     if (n <= limit & (n mod 12 = 1 or n mod 12 = 5)) then     sieve[n+1] := MathLib.bitwiseXor(sieve[n+1],true) ; else skip ; 
    n := (3 * x * x) + (y * y) ; 
    if (n <= limit & n mod 12 = 7) then     sieve[n+1] := MathLib.bitwiseXor(sieve[n+1],true) ; else skip ; 
    n := (3 * x * x) - (y * y) ; 
    if (x > y & n <= limit & n mod 12 = 11) then     sieve[n+1] := MathLib.bitwiseXor(sieve[n+1],true) ; else skip ; 
 )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
        var r : int ; r := 5 ; while r * r < limit do ( (     if (sieve[r+1]) then (         var i : int ; i := r * r ; while i < limit do (     sieve[i+1] := false ;  ;     i := i+(r * r) ) ) else skip )  ;     r := r + 1 ) ; 
        var a : int ; a := 5 ; while a < limit do (     if (sieve[a+1]) then     OclFile["System.out"].print(a + " ") ; else skip ;  ;     a := a + 1 ) ; 
    return 0 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var limit : int ; limit := 20 ;
     execute SieveOfAtkin(limit) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMinimumZ(int n,int a,int b){
    if(a>b){
      swap(a,b);
    }
    int distClock=b-a ;
    int distAntiClock=(a-1)+(n-b+1);
    int minDist=Math.min(distClock,distAntiClock);
    if(minDist==1){
      return 3 ;
    }
    return minDist ;
  }
  private static void swap(int x,int y){
    int temp=x ;
    x=y ;
    y=temp ;
  }
  public static void main(String[] args){
    int n=4,a=1,b=2 ;
    System.out.println(findMinimumZ(n,a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMinimumZ( n : int, a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a > b) then (     execute swap(a, b) ) else skip ; 
     var distClock : int ; distClock := b - a ;
    var distAntiClock : int ; distAntiClock := (a - 1) + (n - b + 1) ;
    var minDist : int ; minDist := Set{distClock, distAntiClock}->min() ;
    if (minDist = 1) then (     return 3 ) else skip ; 
    return minDist 
 );
  static   operation swap( x : int, y : int) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := x ;
     x := y ; 
     y := temp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
    var a : int ; a := 1 ;
    var b : int ; b := 2 ;
     OclFile["System.out"].println(findMinimumZ(n, a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  static int N=3 ;
  static double calcDeterminant(int arr[]){
    double determinant=0 ;
    for(int i=0 ; i<N ; i++){
      determinant+=Math.pow(arr[i],3);
    }
    determinant-=3*arr[0]*arr[1]*arr[2];
    return determinant ;
  }
  static public void main(String args[]){
    int[] arr={
      4,5,3 };
      System.out.println(calcDeterminant(arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 3;
  static   operation calcDeterminant( arr : Sequence(int)) : double
  pre: true
  post: true
  activity: (     var determinant : double ; determinant := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     determinant := determinant+(arr[i+1]->pow(3)) )  ;     i := i + 1 ) ; 
     determinant := determinant-(3 * arr[0+1] * arr[1+1] * arr[2+1]) ; 
     return determinant );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,5,3} ;
     OclFile["System.out"].println(calcDeterminant(arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public int[] AllIndexesRecursive(int input[],int x,int start){
    if(start==input.length){
      int[] ans=new int[0];
      return ans ;
    }
    int[] smallIndex=AllIndexesRecursive(input,x,start+1);
    if(input[start]==x){
      int[] myAns=new int[smallIndex.length+1];
      myAns[0]=start ;
      for(int i=0 ; i<smallIndex.length ; i++){
        myAns[i+1]=smallIndex[i];
      }
      return myAns ;
    }
    else {
      return smallIndex ;
    }
  }
  public int[] AllIndexes(int input[],int x){
    return AllIndexesRecursive(input,x,0);
  }
  public static void main(String args[]){
    GFG g=new GFG();
    int arr[]={
      1,2,3,2,2,5 },x=2 ;
      int output[]=g.AllIndexes(arr,x);
      for(int i=0 ; i<output.length ; i++){
        System.out.print(output[i]+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
   operation AllIndexesRecursive( input : Sequence(int), x : int, start : int) : Sequence(int)
  pre: true
  post: true
  activity: (     if (start = input->size()) then (     var ans : Sequence(int) ; ans := Integer.subrange(1,0)->collect(0) ;
     return ans ) else skip ; 
     var smallIndex : Sequence(int) ; smallIndex := AllIndexesRecursive(input, x, start + 1) ;
     if (input[start+1] = x) then (     var myAns : Sequence(int) ; myAns := Integer.subrange(1,smallIndex->size() + 1)->collect(0) ;
     myAns[0+1] := start ; 
         var i : int ; i := 0 ; while i < smallIndex->size() do ( (     myAns[i + 1+1] := smallIndex[i+1] )  ;     i := i + 1 ) ; 
     return myAns ) else (     return smallIndex ) );
   operation AllIndexes( input : Sequence(int), x : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return AllIndexesRecursive(input, x, 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : GFG ; g := GFG.newGFG() ;
     var arr : Sequence(int) ; arr := Sequence{1,2,3,2,2,5} ;
    var x : int ; x := 2 ;
     var output : Sequence(int) ; output := g.AllIndexes(arr, x) ;
         var i : int ; i := 0 ; while i < output->size() do ( (     OclFile["System.out"].print(output[i+1] + " ") )  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int ans=0 ;
      int L=sc.nextInt(),v=sc.nextInt(),l=sc.nextInt(),r=sc.nextInt();
      ans=L/v ;
      ans=ans-((int)(r/v)-(int)(l/v));
      if(l % v==0)ans--;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var ans : int ; ans := 0 ;
     var L : int ; L := sc.getCurrent()->toInteger() ;
    var v : int ; v := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    ans := L / v ; 
    ans := ans - ((r / v)->oclAsType(int) - (l / v)->oclAsType(int)) ; 
    if (l mod v = 0) then     ans := ans - 1 ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static void LeibnizHarmonicTriangle(int n){
    int C[][]=new int[n+1][n+1];
    for(int i=0 ; i<=n ; i++){
      for(int j=0 ; j<=Math.min(i,n); j++){
        if(j==0 || j==i)C[i][j]=1 ;
        else C[i][j]=C[i-1][j-1]+C[i-1][j];
      }
    }
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=i ; j++)System.out.print("1/"+i*C[i-1][j-1]+" ");
      System.out.println();
    }
  }
  public static void main(String args[]){
    int n=4 ;
    LeibnizHarmonicTriangle(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation LeibnizHarmonicTriangle( n : int) : void
  pre: true
  post: true
  activity: (     var C : Sequence(Sequence(int)) ; C := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= Set{i, n}->min() do ( (     if (j = 0 or j = i) then     C[i+1][j+1] := 1 ; else     C[i+1][j+1] := C[i - 1+1][j - 1+1] + C[i - 1+1][j+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= i do (     OclFile["System.out"].print("1/" + i * C[i - 1+1][j - 1+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     execute LeibnizHarmonicTriangle(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    int[] sum=new int[2];
    int[] table=null ;
    int nCnt=0 ;
    while((table=parseHanbai())!=null){
      sum[0]+=table[0]*table[1];
      sum[1]+=table[1];
      nCnt++;
    }
    if(nCnt>0){
      System.out.println(sum[0]);
      System.out.println((int)Math.round((double)sum[1]/(double)nCnt));
    }
  }
  private static int[] parseHanbai(){
    String strIn=null ;
    int[] table=null ;
    if((strIn=parseStdin())!=null){
      String[] line=strIn.split(",");
      table=new int[2];
      table[0]=Integer.parseInt(line[0]);
      table[1]=Integer.parseInt(line[1]);
    }
    return table ;
  }
  private static String parseStdin(){
    String strNum=null ;
    try {
      String line=br.readLine();
      if(line!=null){
        if(! line.isEmpty()){
          strNum=line ;
        }
      }
    }
    catch(IOException e){
    }
    return strNum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sum : Sequence(int) ; sum := Integer.subrange(1,2)->collect(0) ;
     var table : Sequence(int) ; table := null ;
    var nCnt : int ; nCnt := 0 ;
        table := parseHanbai() ;
    while ((table) /= null) do (    skip ; (     sum[0+1] := sum[0+1]+(table[0+1] * table[1+1]) ; 
     sum[1+1] := sum[1+1]+(table[1+1]) ; 
     nCnt := nCnt + 1 ) ;     table := parseHanbai() ;
 ) ;  
    if (nCnt > 0) then (     OclFile["System.out"].println(sum[0+1]) ; 
     OclFile["System.out"].println((sum[1+1]->oclAsType(double) / nCnt->oclAsType(double))->round()->oclAsType(int)) ) else skip ; 
 );
  static   operation parseHanbai() : Sequence(int)
  pre: true
  post: true
  activity: (     var strIn : String ; strIn := null ;
     var table : Sequence(int) ; table := null ;
     if ((strIn) /= null) then (     var line : Sequence(String) ; line := strIn->split(",") ;
     table := Integer.subrange(1,2)->collect(0) ; 
     table[0+1] := (line[0+1])->toInteger() ; 
     table[1+1] := (line[1+1])->toInteger() ) else skip ; 
     return table );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var strNum : String ; strNum := null ;
     try (     var line : String ; line := br.readLine() ;
     if (line /= null) then (     if (not(line->isEmpty())) then (     strNum := line ) else skip ) else skip )   catch (e : IOException) do skip
     return strNum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    solve(System.in,System.out);
  }
  static void solve(InputStream is,PrintStream os){
    Scanner sc=new Scanner(is);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int[] r=new int[h];
    int[] c=new int[w];
    int[][] matrix=new int[h][w];
    for(int y=0 ; y<h ; y++){
      for(int x=0 ; x<w ; x++){
        if((r[y]<w-a)&&(c[x]<h-b)){
          matrix[y][x]=1 ;
          r[y]++;
          c[x]++;
        }
      }
    }
    for(int i=0 ; i<h ; i++){
      if(r[i]!=a && r[i]!=w-a){
        os.println("No");
        return ;
      }
    }
    for(int i=0 ; i<w ; i++){
      if(c[i]!=b && c[i]!=h-b){
        os.println("No");
        return ;
      }
    }
    for(int y=0 ; y<h ; y++){
      StringBuilder s=new StringBuilder();
      for(int x=0 ; x<w ; x++){
        s.append(matrix[y][x]);
      }
      os.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation solve( is : OclFile, os : OclFile) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(is) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var r : Sequence(int) ; r := Integer.subrange(1,h)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,w)->collect(0) ;
    var matrix : Sequence(Sequence(int)) ; matrix := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var y : int ; y := 0 ; while y < h do ( (         var x : int ; x := 0 ; while x < w do ( (     if ((r[y+1] < w - a) & (c[x+1] < h - b)) then (     matrix[y+1][x+1] := 1 ; 
     r[y+1] := r[y+1] + 1 ; 
     c[x+1] := c[x+1] + 1 ) else skip )  ;     x := x + 1 ) )  ;     y := y + 1 ) ; 
        var i : int ; i := 0 ; while i < h do ( (     if (r[i+1] /= a & r[i+1] /= w - a) then (     os.println("No") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < w do ( (     if (c[i+1] /= b & c[i+1] /= h - b) then (     os.println("No") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
        var y : int ; y := 0 ; while y < h do ( (     var s : String ; s := StringLib.newString() ;
         var x : int ; x := 0 ; while x < w do ( (     s := s + StringLib.newString(matrix[y+1][x+1]) )  ;     x := x + 1 ) ; 
     os.println(s) )  ;     y := y + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printpascalmatrix(int n){
    int C[][]=new int[2*n+1][2*n+1];
    for(int i=0 ; i<=2*n ; i++){
      for(int j=0 ; j<=Math.min(i,2*n); j++){
        if(j==0 || j==i)C[i][j]=1 ;
        else C[i][j]=C[i-1][j-1]+C[i-1][j];
      }
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++)System.out.print(C[i+j][i]+" ");
      System.out.println();
    }
  }
  public static void main(String[] args){
    int n=5 ;
    printpascalmatrix(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printpascalmatrix( n : int) : void
  pre: true
  post: true
  activity: (     var C : Sequence(Sequence(int)) ; C := Integer.subrange(1,2 * n + 1)->collect(Integer.subrange(1,2 * n + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i <= 2 * n do ( (         var j : int ; j := 0 ; while j <= Set{i, 2 * n}->min() do ( (     if (j = 0 or j = i) then     C[i+1][j+1] := 1 ; else     C[i+1][j+1] := C[i - 1+1][j - 1+1] + C[i - 1+1][j+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do (     OclFile["System.out"].print(C[i + j+1][i+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute printpascalmatrix(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findK(int n,int k){
    int pos ;
    if(n % 2==0){
      pos=n/2 ;
    }
    else {
      pos=(n/2)+1 ;
    }
    if(k<=pos){
      return(k*2-1);
    }
    else return((k-pos)*2);
  }
  static int countSetBits(int n,int k){
    int kth=findK(n,k);
    int count=0 ;
    while(kth>0){
      count+=kth & 1 ;
      kth>>=1 ;
    }
    return count ;
  }
  public static void main(String[] args){
    int n=18,k=12 ;
    System.out.println(countSetBits(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findK( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var pos : int ;
     if (n mod 2 = 0) then (     pos := n / 2 ) else (     pos := (n / 2) + 1 ) ;  
     if (k <= pos) then (     return (k * 2 - 1) ) else     return ((k - pos) * 2) );
  static   operation countSetBits( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var kth : int ; kth := findK(n, k) ;
     var count : int ; count := 0 ;
     while (kth > 0) do (     count := count+(MathLib.bitwiseAnd(kth,1)) ; 
     kth := kth/(2->pow(1)) ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 18 ;
    var k : int ; k := 12 ;
     OclFile["System.out"].println(countSetBits(n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String args[])throws IOException {
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int m=scn.nextInt();
    int mex=Integer.MAX_VALUE ;
    for(int i=0 ; i<m ; i++){
      int a=scn.nextInt();
      int b=scn.nextInt();
      mex=Math.min(mex,b-a+1);
    }
    System.out.println(mex);
    int x=0 ;
    for(int i=0 ; i<n ; i++){
      System.out.print(x+" ");
      x++;
      if(x==mex){
        x=0 ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var m : int ; m := scn.getCurrent()->toInteger() ;
    var mex : int ; mex := 2147483647 ;
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := scn.getCurrent()->toInteger() ;
     var b : int ; b := scn.getCurrent()->toInteger() ;
     mex := Set{mex, b - a + 1}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(mex) ; 
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(x + " ") ; 
     x := x + 1 ; 
     if (x = mex) then (     x := 0 ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt();
    int m=in.nextInt();
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<m ; i++){
      int l=in.nextInt();
      int r=in.nextInt();
      min=Math.min(min,r-l+1);
    }
    out.println(min);
    int a=0 ;
    for(int i=0 ; i<n ; i++){
      out.print(a+" ");
      a++;
      if(a==min)a=0 ;
    }
    out.println();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < m do ( (     var l : int ; l := in.getCurrent()->toInteger() ;
     var r : int ; r := in.getCurrent()->toInteger() ;
     min := Set{min, r - l + 1}->min() )  ;     i := i + 1 ) ; 
    skip ; 
    var a : int ; a := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     skip ; 
     a := a + 1 ; 
     if (a = min) then     a := 0 ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public final class Main {
  static int n,m ;
  public static void main(String[] args)throws Exception {
    FastReader sc=new FastReader();
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    n=sc.nextInt();
    m=sc.nextInt();
    int min=1<<30 ;
    for(int i=0 ; i<m ; ++i){
      int l=sc.nextInt();
      int r=sc.nextInt();
      min=Math.min(min,r-l+1);
    }
    bw.write(min+"\n");
    for(int i=0 ; i<n ; ++i){
      bw.write(i % min+" ");
    }
    bw.flush();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    n := sc.nextInt() ; 
    m := sc.nextInt() ; 
    var min : int ; min := (1*(2->pow(30)))->oclAsType(long) ;
        var i : int ; i := 0 ; while i < m do ( (     var l : int ; l := sc.nextInt() ;
     var r : int ; r := sc.nextInt() ;
     min := Set{min, r - l + 1}->min() )  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < n do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector ;
import static java.lang.Math.sqrt ;
class GFG {
  static final int MAX=10000 ;
  static Vector<Integer>primes=new Vector<Integer>(MAX+1);
  static void sieveSundaram(){
    boolean marked[]=new boolean[MAX/2+1];
    for(int i=1 ; i<=(sqrt(MAX)-1)/2 ; i++)for(int j=(i*(i+1))<<1 ; j<=MAX/2 ; j=j+2*i+1)marked[j]=true ;
    primes.add(2);
    for(int i=1 ; i<=MAX/2 ; i++)if(marked[i]==false)primes.add(2*i+1);
  }
  static boolean isEquidigital(int n){
    if(n==1)return true ;
    int original_no=n ;
    int sumDigits=0 ;
    while(original_no>0){
      sumDigits++;
      original_no=original_no/10 ;
    }
    int pDigit=0,count_exp=0,p=0 ;
    for(int i=0 ; primes.elementAt(i)<=n/2 ; i++){
      while(n % primes.elementAt(i)==0){
        p=primes.elementAt(i);
        n=n/p ;
        count_exp++;
      }
      while(p>0){
        pDigit++;
        p=p/10 ;
      }
      while(count_exp>1){
        pDigit++;
        count_exp=count_exp/10 ;
      }
    }
    if(n!=1){
      while(n>0){
        pDigit++;
        n=n/10 ;
      }
    }
    return(pDigit==sumDigits);
  }
  public static void main(String[] args){
    sieveSundaram();
    System.out.println("Printing first few Equidigital Numbers"+" using isEquidigital()");
    for(int i=1 ; i<20 ; i++)if(isEquidigital(i))System.out.print(i+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX : int := 10000;
  static   attribute primes : Sequence(int) := Sequence{}->union(MAX + 1);
  static   operation sieveSundaram() : void
  pre: true
  post: true
  activity: (     var marked : Sequence(boolean) ; marked := Integer.subrange(1,MAX / 2 + 1)->collect(false) ;
         var i : int ; i := 1 ; while i <= (sqrt(MAX) - 1) / 2 do (         var j : int ; j := ((i * (i + 1))*(2->pow(1)))->oclAsType(long) ; while j <= MAX / 2 do (     marked[j+1] := true ;  ;     j := j + 2 * i + 1 ) ;  ;     i := i + 1 ) ; 
     primes := primes->including(2) ; 
         var i : int ; i := 1 ; while i <= MAX / 2 do (     if (marked[i+1] = false) then     primes := primes->including(2 * i + 1) ; else skip ;  ;     i := i + 1 ) );
  static   operation isEquidigital( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 1) then     return true else skip ; 
     var original_no : int ; original_no := n ;
    var sumDigits : int ; sumDigits := 0 ;
    while (original_no > 0) do (     sumDigits := sumDigits + 1 ; 
     original_no := original_no / 10 ) ; 
    var pDigit : int ; pDigit := 0 ;
    var count_exp : int ; count_exp := 0 ;
    var p : int ; p := 0 ;
        var i : int ; i := 0 ; while primes->at(i+1) <= n / 2 do ( (     while (n mod primes->at(i+1) = 0) do (     p := primes->at(i+1) ; 
     n := n / p ; 
     count_exp := count_exp + 1 ) ; 
     while (p > 0) do (     pDigit := pDigit + 1 ; 
     p := p / 10 ) ; 
     while (count_exp > 1) do (     pDigit := pDigit + 1 ; 
     count_exp := count_exp / 10 ) )  ;     i := i + 1 ) ; 
    if (n /= 1) then (     while (n > 0) do (     pDigit := pDigit + 1 ; 
     n := n / 10 ) ) else skip ; 
    return (pDigit = sumDigits) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute sieveSundaram() ; 
     OclFile["System.out"].println("Printing first few Equidigital Numbers" + " using isEquidigital()") ; 
         var i : int ; i := 1 ; while i < 20 do (     if (isEquidigital(i)) then     OclFile["System.out"].print(i + " ") ; else skip ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CandySplit {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new FileReader("C-large(1).in"));
      int T=Integer.parseInt(br.readLine());
      PrintWriter pw=new PrintWriter(new FileWriter("output"));
      for(int I=1 ; I<=T ; I++){
        int N=Integer.parseInt(br.readLine());
        int small=Integer.MAX_VALUE,tot=0,xor=0 ;
        StringTokenizer st=new StringTokenizer(br.readLine()," ",false);
        for(int i=0 ; i<N ; i++){
          int k=Integer.parseInt(st.nextToken());
          if(k<small)small=k ;
          tot+=k ;
          xor=xor ^ k ;
        }
        if(xor!=0)pw.println("Case #"+I+": NO");
        else pw.println("Case #"+I+": "+(tot-small));
      }
      br.close();
      pw.flush();
      pw.close();
    }
    catch(IOException ie){
      ie.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CandySplit {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("C-large(1).in"))) ;
     var T : int ; T := (br.readLine())->toInteger() ;
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output"))) ;
        var I : int ; I := 1 ; while I <= T do ( (     var N : int ; N := (br.readLine())->toInteger() ;
     var small : int ; small := 2147483647 ;
    var tot : int ; tot := 0 ;
    var xor : int ; xor := 0 ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String_String(br.readLine(), " ", false) ;
        var i : int ; i := 0 ; while i < N do ( (     var k : int ; k := (st.next())->toInteger() ;
     if (k < small) then     small := k ; else skip ; 
     tot := tot+(k) ; 
     xor := MathLib.bitwiseXor(xor,k) )  ;     i := i + 1 ) ; 
    if (xor /= 0) then     skip else     skip ; ;  
 )  ;     I := I + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 )   catch (ie : IOException) do (     ie.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.util.Arrays ;
public class C {
  public String solve(int[] a){
    Arrays.sort(a);
    int n=a.length ;
    int total=0 ;
    int xor=0 ;
    for(int i=0 ; i<n ; i++){
      xor ^=a[i];
      total+=a[i];
    }
    if(xor!=0){
      return "NO\n" ;
    }
    total-=a[0];
    return total+"\n" ;
  }
  public String runInput(BufferedReader br)throws IOException {
    int n=Integer.parseInt(br.readLine().trim());
    String[] items=br.readLine().trim().split("\\s+");
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(items[i]);
    }
    return solve(a);
  }
  public static void main(String[] args){
    C c=new C();
    try {
      c.parseFile("C-sample");
      c.parseFile("C-small-attempt0");
      c.parseFile("C-large");
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  public void parseFile(String filePrefix)throws IOException {
    String fileIn=filePrefix+".in" ;
    String fileOut=filePrefix+".out" ;
    BufferedReader br=new BufferedReader(new FileReader(fileIn));
    BufferedWriter bw=new BufferedWriter(new FileWriter(fileOut));
    int n=Integer.parseInt(br.readLine());
    for(int i=1 ; i<=n ; i++){
      String ret="Case #"+i+": " ;
      ret+=runInput(br);
      System.out.print(ret);
      bw.write(ret);
    }
    br.close();
    bw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
   operation solve( a : Sequence(int)) : String
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var n : int ; n := a->size() ;
    var total : int ; total := 0 ;
    var xor : int ; xor := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     xor := MathLib.bitwiseXor(xor,a[i+1]) ; 
     total := total+(a[i+1]) )  ;     i := i + 1 ) ; 
    if (xor /= 0) then (     return "NO\n" ) else skip ; 
    total := total-(a[0+1]) ; 
    return total + "\n" 
 );
   operation runInput( br : OclFile) : String
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine()->trim())->toInteger() ;
     var items : Sequence(String) ; items := br.readLine()->trim()->split("\\s+") ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (items[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    return solve(a) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var c : C ; c := C.newC() ;
     try (     c.parseFile("C-sample") ; 
     c.parseFile("C-small-attempt0") ; 
     c.parseFile("C-large") )   catch (e : IOException) do (     e.printStackTrace() )
 );
   operation parseFile( filePrefix : String) : void
  pre: true
  post: true
  activity: (     var fileIn : String ; fileIn := filePrefix + ".in" ;
     var fileOut : String ; fileOut := filePrefix + ".out" ;
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(fileIn))) ;
    var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile(fileOut))) ;
    var n : int ; n := (br.readLine())->toInteger() ;
        var i : int ; i := 1 ; while i <= n do ( (     var ret : String ; ret := "Case #" + i + ": " ;
     ret := ret+(runInput(br)) ; 
     OclFile["System.out"].print(ret) ; 
     skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class C {
  private static Scanner sc ;
  public static void main(String[] args){
    sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++)System.out.printf("Case #%d: %s\n",i+1,exec());
  }
  private static String exec(){
    int n=sc.nextInt();
    int[] candy=new int[n];
    for(int i=0 ; i<n ; i++)candy[i]=sc.nextInt();
    return calc(candy);
  }
  private static String calc(int[] candy){
    int xor=0 ;
    int smallest=Integer.MAX_VALUE ;
    int sum=0 ;
    for(int c : candy){
      if(smallest>c)smallest=c ;
      xor ^=c ;
      sum+=c ;
    }
    if(xor!=0)return "NO" ;
    return ""+(sum-smallest);
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do (     OclFile["System.out"].printf("Case #%d: %s\n", i + 1, exec()) ;  ;     i := i + 1 ) );
  static   operation exec() : String
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var candy : Sequence(int) ; candy := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     candy[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
     return calc(candy) );
  static   operation calc( candy : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var xor : int ; xor := 0 ;
     var smallest : int ; smallest := 2147483647 ;
    var sum : int ; sum := 0 ;
    for (c : candy) do ( (     if (smallest > c) then     smallest := c ; else skip ; 
     xor := MathLib.bitwiseXor(xor,c) ; 
     sum := sum+(c) )  ) ; 
    if (xor /= 0) then     return "NO" else skip ; 
    return "" + (sum - smallest) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  static long mod=(long)(1e9+7);
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int t=1 ; t<=test ; t++){
      int length=in.nextInt(),v=in.nextInt(),left=in.nextInt(),right=in.nextInt();
      int total=length/v ;
      int rig=right/v ;
      int lef=(left-1)/v ;
      pw.println(total-rig+lef);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := (1e9 + 7)->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= test do ( (     var length : int ; length := in.getCurrent()->toInteger() ;
    var v : int ; v := in.getCurrent()->toInteger() ;
    var left : int ; left := in.getCurrent()->toInteger() ;
    var right : int ; right := in.getCurrent()->toInteger() ;
     var total : int ; total := length / v ;
    var rig : int ; rig := right / v ;
    var lef : int ; lef := (left - 1) / v ;
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedWriter ;
import java.io.IOException ;
import java.io.OutputStreamWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    int H=sc.nextInt();
    int W=sc.nextInt();
    int A=sc.nextInt();
    int B=sc.nextInt();
    if(W<2*A || H<2*B){
      System.out.println(-1);
      return ;
    }
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        if((i<B && j<A)||(i>=B)&&(j>=A))bw.write("0");
        else bw.write("1");
      }
      bw.newLine();
    }
    bw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    if (W < 2 * A or H < 2 * B) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if ((i < B & j < A) or (i >= B) & (j >= A)) then     skip ; else     skip ; )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.*;
import java.io.*;
import java.math.*;
import java.util.*;
import java.util.regex.*;
import static java.lang.Math.*;
public class C_small {
  public static void main(String[] args)throws Exception {
    new C_small();
  }
  public C_small()throws Exception {
    line=br.readLine();
    st=new StringTokenizer(line);
    int caseCount=Integer.parseInt(st.nextToken());
    for(int caseNum=1 ; caseNum<=caseCount ; caseNum++){
      String ans=null ;
      int N=Integer.parseInt(br.readLine());
      int total=0 ;
      int xor=0 ;
      int min=1<<30 ;
      line=br.readLine();
      st=new StringTokenizer(line);
      for(int i=0 ; i<N ; i++){
        int v=Integer.parseInt(st.nextToken());
        xor ^=v ;
        total+=v ;
        min=min(min,v);
      }
      if(xor!=0)ans="NO" ;
      else {
        ans=total-min+"" ;
      }
      buf.append(String.format("Case #%d: %s\n",caseNum,ans));
    }
    System.out.print(buf);
  }
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  String line ;
  StringTokenizer st ;
  StringBuilder buf=new StringBuilder();
  public static void debug(Object...arr){
    System.err.println(Arrays.deepToString(arr));
  }
}
------------------------------------------------------------
OCL File:
---------
 class C_small {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( C_small.newC_small() );
   static operation newC_small() : C_small
  pre: true
  post: true
  activity:
  ( var self : C_small ;
    self := createC_small();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     line := br.readLine() ; 
     st := OclIterator.newOclIterator_String(line) ; 
    var caseCount : int ; caseCount := (st.next())->toInteger() ;
        var caseNum : int ; caseNum := 1 ; while caseNum <= caseCount do ( (     var ans : String ; ans := null ;
     var N : int ; N := (br.readLine())->toInteger() ;
    var total : int ; total := 0 ;
    var xor : int ; xor := 0 ;
    var min : int ; min := (1*(2->pow(30)))->oclAsType(long) ;
    line := br.readLine() ; 
    st := OclIterator.newOclIterator_String(line) ; 
        var i : int ; i := 0 ; while i < N do ( (     var v : int ; v := (st.next())->toInteger() ;
     xor := MathLib.bitwiseXor(xor,v) ; 
     total := total+(v) ; 
     min := Set{min, v}->min() )  ;     i := i + 1 ) ; 
    if (xor /= 0) then     ans := "NO" else (     ans := total - min + "" ) ;  
    buf := buf + StringLib.newString(StringLib.format("Case #%d: %s\n",Sequence{caseNum,ans})) ; 
 )  ;     caseNum := caseNum + 1 ) ; 
    OclFile["System.out"].print(buf) ; 
 );
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute line : String;
   attribute st : OclIterator;
   attribute buf : String := StringLib.newString();
  static   operation debug( arr : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((arr + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class C {
  private BufferedReader in ;
  private PrintWriter out ;
  private StringTokenizer st ;
  C()throws IOException {
    in=new BufferedReader(new FileReader("C.large.in"));
    out=new PrintWriter("C.large.out");
    eat("");
    int T=nextInt();
    for(int t=1 ; t<=T ; t++){
      int N=nextInt(),xor=0,sum=0,m=1000001,c ;
      for(int i=0 ; i<N ; i++){
        c=nextInt();
        xor ^=c ;
        sum+=c ;
        m=Math.min(m,c);
      }
      out.print("Case #"+t+": ");
      if(xor!=0){
        out.println("NO");
      }
      else {
        out.println(sum-m);
      }
    }
    in.close();
    out.close();
  }
  private void eat(String str){
    st=new StringTokenizer(str);
  }
  String next()throws IOException {
    while(! st.hasMoreTokens()){
      String line=in.readLine();
      if(line==null){
        return null ;
      }
      eat(line);
    }
    return st.nextToken();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public static void main(String[] args)throws IOException {
    new C();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
   attribute in : OclFile;
   attribute out : OclFile;
   attribute st : OclIterator;
   static operation newC() : C
  pre: true
  post: true
  activity:
  ( var self : C ;
    self := createC();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("C.large.in"))) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile("C.large.out")) ; 
    execute eat("") ; 
    var T : int ; T := nextInt() ;
        var t : int ; t := 1 ; while t <= T do ( (     var N : int ; N := nextInt() ;
    var xor : int ; xor := 0 ;
    var sum : int ; sum := 0 ;
    var m : int ; m := 1000001 ;
    var c : int ;
         var i : int ; i := 0 ; while i < N do ( (     c := nextInt() ; 
     xor := MathLib.bitwiseXor(xor,c) ; 
     sum := sum+(c) ; 
     m := Set{m, c}->min() )  ;     i := i + 1 ) ; 
     skip ; 
     if (xor /= 0) then (     skip ) else (     skip ) )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
 );
   operation eat( str : String) : void
  pre: true
  post: true
  activity: (     st := OclIterator.newOclIterator_String(str) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     var line : String ; line := in.readLine() ;
     if (line = null) then (     return null ) else skip ; 
     execute eat(line) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( C.newC() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printPrevSmaller(int[] arr,int n){
    System.out.print("_,");
    for(int i=1 ; i<n ; i++){
      int j ;
      for(j=i-1 ; j>=0 ; j--){
        if(arr[j]<arr[i]){
          System.out.print(arr[j]+",");
          break ;
        }
      }
      if(j==-1)System.out.print("_,");
    }
  }
  public static void main(String[] args){
    int[] arr={
      1,3,0,2,5 };
      int n=arr.length ;
      printPrevSmaller(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printPrevSmaller( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("_,") ; 
         var i : int ; i := 1 ; while i < n do ( (     var j : int ;
         j := i - 1 ; while j >= 0 do ( (     if (arr[j+1] < arr[i+1]) then (     OclFile["System.out"].print(arr[j+1] + ",") ; 
     break ) else skip )  ;     j := j - 1 ) ; 
     if (j = -1) then     OclFile["System.out"].print("_,") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,0,2,5} ;
     var n : int ; n := arr->size() ;
     execute printPrevSmaller(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Solution {
  static PrintWriter pw ;
  static FastScanner s ;
  public static void main(String[] args)throws Exception {
    pw=new PrintWriter(System.out);
    s=new FastScanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=s.nextInt();
      }
      boolean flag=true ;
      for(int i=1 ; i<n ; i++){
        if(a[i] % a[0]!=0){
          flag=false ;
          break ;
        }
      }
      if(flag)pw.println("YES");
      else pw.println("NO");
    }
    pw.flush();
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public FastScanner(String s)throws Exception {
    br=new BufferedReader(new FileReader(new File(s)));
  }
  public String next()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(next());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute pw : OclFile;
  static   attribute s : FastScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     pw := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     s := FastScanner.newFastScanner(OclFile["System.in"]) ; 
    var t : int ; t := s.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := s.nextInt() )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := true ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] mod a[0+1] /= 0) then (     flag := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then     skip else     skip ; ;  
 ) ;  ) ;  
    skip ; 
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static boolean check(int a[]){
    for(int i=0 ; i<a.length-1 ; i++){
      if(a[i]>a[i+1]){
      }
      else {
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=input.nextInt();
      }
      for(int i=1 ; i<n ; i++){
        if(a[i] % a[0]!=0){
          System.out.println("NO");
          continue work ;
        }
      }
      System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation check( a : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < a->size() - 1 do ( (     if (a[i+1] > a[i + 1+1]) then skip else (     return false ) )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := input.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] mod a[0+1] /= 0) then (     OclFile["System.out"].println("NO") ; 
     continue ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static boolean check(int a[]){
    for(int i=0 ; i<a.length-1 ; i++){
      if(a[i]>a[i+1]){
      }
      else {
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=input.nextInt();
      }
      if(check(a)|| a[0]>a[1] || a[1] % a[0]!=0){
        System.out.println("NO");
      }
      else {
        int first=a[0];
        boolean firstcondition=true ;
        for(int i=1 ; i<n ; i++){
          if(a[i] % first!=0){
            firstcondition=false ;
          }
        }
        if(firstcondition){
          System.out.println("YES");
          continue work ;
        }
        if(n==2){
          System.out.println("NO");
          continue work ;
        }
        int dif=a[1] % a[0];
        for(int i=1 ; i<n && dif!=0 ; i++){
          if(a[i] % dif!=0){
            System.out.println("NO");
            continue work ;
          }
        }
        if(dif!=0)System.out.println("YES");
        else {
          System.out.println("NO");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation check( a : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < a->size() - 1 do ( (     if (a[i+1] > a[i + 1+1]) then skip else (     return false ) )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := input.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     if (check(a) or a[0+1] > a[1+1] or a[1+1] mod a[0+1] /= 0) then (     OclFile["System.out"].println("NO") ) else (     var first : int ; first := a[0+1] ;
     var firstcondition : boolean ; firstcondition := true ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] mod first /= 0) then (     firstcondition := false ) else skip )  ;     i := i + 1 ) ; 
    if (firstcondition) then (     OclFile["System.out"].println("YES") ; 
     continue ) else skip ; 
    if (n = 2) then (     OclFile["System.out"].println("NO") ; 
     continue ) else skip ; 
    var dif : int ; dif := a[1+1] mod a[0+1] ;
        var i : int ; i := 1 ; while i < n & dif /= 0 do ( (     if (a[i+1] mod dif /= 0) then (     OclFile["System.out"].println("NO") ; 
     continue ) else skip )  ;     i := i + 1 ) ; 
    if (dif /= 0) then     OclFile["System.out"].println("YES") else (     OclFile["System.out"].println("NO") ) ;  
 ) ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      boolean flag=false ;
      for(int i=1 ; i<n ; i++){
        if(arr[i] % arr[0]!=0){
          flag=true ;
          break ;
        }
      }
      if(flag)System.out.println("NO");
      else System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := false ;
        var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] mod arr[0+1] /= 0) then (     flag := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1708_DifferenceOperations {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=input.nextInt();
    while(test-->0){
      int len=input.nextInt();
      int first=input.nextInt();
      boolean flag=true ;
      for(int i=1 ; i<len ; i++){
        int num=input.nextInt();
        if(num % first!=0){
          flag=false ;
        }
      }
      if(flag){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1708_DifferenceOperations {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := input.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var len : int ; len := input.getCurrent()->toInteger() ;
     var first : int ; first := input.getCurrent()->toInteger() ;
    var flag : boolean ; flag := true ;
        var i : int ; i := 1 ; while i < len do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
     if (num mod first /= 0) then (     flag := false ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAX=100 ;
  static boolean checkBisymmetric(int m[][],int n){
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<i ; j++)if(m[i][j]!=m[j][i])return false ;
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n-i ; j++)if(m[i][j]!=m[n-j-1][n-i-1])return false ;
    return true ;
  }
  public static void main(String[] args){
    int n=3 ;
    int m[][]={
      {
        1,2,3 },{
          2,5,2 },{
            3,2,1 }
          };
          if(checkBisymmetric(m,n))System.out.println("Yes");
          else System.out.println("No");
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100;
  static   operation checkBisymmetric( m : Sequence(Sequence(int)), n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < i do (     if (m[i+1][j+1] /= m[j+1][i+1]) then     return false else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n - i do (     if (m[i+1][j+1] /= m[n - j - 1+1][n - i - 1+1]) then     return false else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var m : Sequence(Sequence(int)) ; m := Sequence{Sequence{1,2,3},Sequence{2,5,2},Sequence{3,2,1}} ;
     if (checkBisymmetric(m, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int __gcd(int a,int b){
    if(a==0)return b ;
    return __gcd(b % a,a);
  }
  static int minimumMoves(int A[],int N){
    int one=0 ;
    for(int i=0 ; i<N ; i++)if(A[i]==1)one++;
    if(one!=0)return N-one ;
    int minimum=Integer.MAX_VALUE ;
    for(int i=0 ; i<N ; i++){
      int g=A[i];
      for(int j=i+1 ; j<N ; j++){
        g=__gcd(A[j],g);
        if(g==1){
          minimum=Math.min(minimum,j-i);
          break ;
        }
      }
    }
    if(minimum==Integer.MAX_VALUE)return-1 ;
    else return N+minimum-1 ;
  }
  public static void main(String[] args){
    int A[]={
      2,4,3,9 };
      int N=A.length ;
      System.out.print(minimumMoves(A,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return __gcd(b mod a, a) );
  static   operation minimumMoves( A : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var one : int ; one := 0 ;
         var i : int ; i := 0 ; while i < N do (     if (A[i+1] = 1) then     one := one + 1 ; else skip ;  ;     i := i + 1 ) ; 
    if (one /= 0) then     return N - one else skip ; 
    var minimum : int ; minimum := 2147483647 ;
        var i : int ; i := 0 ; while i < N do ( (     var g : int ; g := A[i+1] ;
         var j : int ; j := i + 1 ; while j < N do ( (     g := __gcd(A[j+1], g) ; 
     if (g = 1) then (     minimum := Set{minimum, j - i}->min() ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (minimum = 2147483647) then     return -1 else     return N + minimum - 1 ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{2,4,3,9} ;
     var N : int ; N := A->size() ;
     OclFile["System.out"].print(minimumMoves(A, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int getProduct(int n){
    int product=1 ;
    while(n!=0){
      product=product*(n % 10);
      n=n/10 ;
    }
    return product ;
  }
  public static void main(String[] args){
    int n=4513 ;
    System.out.println(getProduct(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getProduct( n : int) : int
  pre: true
  post: true
  activity: (     var product : int ; product := 1 ;
     while (n /= 0) do (     product := product * (n mod 10) ; 
     n := n / 10 ) ; 
     return product );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4513 ;
     OclFile["System.out"].println(getProduct(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=sc.nextInt();
    }
    int[] ans=result(arr);
    System.out.println(ans.length);
    for(int i=ans.length-1 ; i>=0 ; i--){
      System.out.print(ans[i]+" ");
    }
  }
  private static int[] result(int[] arr){
    ArrayList<Integer>help=new ArrayList<>();
    for(int i=arr.length-1 ; i>=0 ; i--){
      if(help.contains(arr[i])){
      }
      else {
        help.add(arr[i]);
      }
    }
    int[] ans=new int[help.size()];
    for(int i=0 ; i<ans.length ; i++){
      ans[i]=help.get(i);
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := result(arr) ;
    OclFile["System.out"].println(ans->size()) ; 
        var i : int ; i := ans->size() - 1 ; while i >= 0 do ( (     OclFile["System.out"].print(ans[i+1] + " ") )  ;     i := i - 1 ) ; 
 );
  static   operation result( arr : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var help : Sequence(int) ; help := Sequence{} ;
         var i : int ; i := arr->size() - 1 ; while i >= 0 do ( (     if (help->includes(arr[i+1])) then skip else (     help := help->including(arr[i+1]) ) )  ;     i := i - 1 ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,help->size())->collect(0) ;
        var i : int ; i := 0 ; while i < ans->size() do ( (     ans[i+1] := help->at(i+1) )  ;     i := i + 1 ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigDecimal ;
import java.math.MathContext ;
import java.util.*;
public class ProblemD {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int test=Integer.parseInt(br.readLine());
    while(test-->0){
      String line[]=br.readLine().split(" ");
      int n=Integer.parseInt(line[0]);
      int v=Integer.parseInt(line[1]);
      int l=Integer.parseInt(line[2]);
      int r=Integer.parseInt(line[3]);
      int count=l/v,count2=r/v ;
      if(l % v==0)count--;
      System.out.println((n/v)-(count2-count));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemD {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
     var test : int ; test := (br.readLine())->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
     var n : int ; n := (line[0+1])->toInteger() ;
    var v : int ; v := (line[1+1])->toInteger() ;
    var l : int ; l := (line[2+1])->toInteger() ;
    var r : int ; r := (line[3+1])->toInteger() ;
    var count : int ; count := l / v ;
    var count2 : int ; count2 := r / v ;
    if (l mod v = 0) then     count := count - 1 ; else skip ; 
    OclFile["System.out"].println((n / v) - (count2 - count)) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      char[] red=scanner.next().toCharArray();
      if(red[0]=='-')break ;
      char[] green=scanner.next().toCharArray();
      char[] x=scanner.next().toCharArray();
      int p=0,pr=0,pg=1 ;
      char c=green[0];
      while(p<x.length){
        if(c==x[p]){
          c=red[pr++];
          p++;
        }
        else {
          System.out.print(c);
          c=green[pg++];
        }
      }
      System.out.println(c+String.valueOf(green).substring(pg));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var red : Sequence(String) ; red := scanner.getCurrent()->characters() ;
     if (red[0+1] = '-') then     break else skip ; 
    var green : Sequence(String) ; green := scanner.getCurrent()->characters() ;
    var x : Sequence(String) ; x := scanner.getCurrent()->characters() ;
    var p : int ; p := 0 ;
    var pr : int ; pr := 0 ;
    var pg : int ; pg := 1 ;
    var c : String ; c := green[0+1] ;
    while (p < x->size()) do (     if (c = x[p+1]) then (      c := red[pr+1]  ; pr := pr + 1 ; 
     p := p + 1 ) else (     OclFile["System.out"].print(c) ; 
      c := green[pg+1]  ; pg := pg + 1 ) ) ; 
    OclFile["System.out"].println(c + (green)->sum() .subrange(pg+1,pg)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(true){
      String str1=sc.next();
      if(str1.equals("-"))break ;
      LinkedList<Character>red=new LinkedList<Character>();
      LinkedList<Character>green=new LinkedList<Character>();
      LinkedList<Character>bottom=new LinkedList<Character>();
      LinkedList<Character>ans=new LinkedList<Character>();
      for(int i=0 ; i<str1.length(); i++){
        red.addFirst(str1.charAt(i));
      }
      str1=sc.next();
      for(int i=0 ; i<str1.length(); i++){
        green.addFirst(str1.charAt(i));
      }
      str1=sc.next();
      for(int i=0 ; i<str1.length(); i++){
        bottom.addFirst(str1.charAt(i));
      }
      char cand=green.removeLast();
      while(! red.isEmpty()|| ! green.isEmpty()){
        if(bottom.contains(cand)){
          cand=red.removeLast();
        }
        else {
          ans.addLast(cand);
          cand=green.removeLast();
        }
      }
      if(! bottom.contains(cand)){
        ans.addLast(cand);
      }
      for(int i=0 ; i<ans.size(); i++){
        System.out.print(ans.get(i));
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var str1 : String ; str1 := sc.getCurrent() ;
     if (str1 = "-") then     break else skip ; 
    var red : Sequence(String) ; red := Sequence{} ;
    var green : Sequence(String) ; green := Sequence{} ;
    var bottom : Sequence(String) ; bottom := Sequence{} ;
    var ans : Sequence(String) ; ans := Sequence{} ;
        var i : int ; i := 0 ; while i < str1->size() do ( (     red := red->prepend(str1->at(i+1)) )  ;     i := i + 1 ) ; 
    str1 := sc.getCurrent() ; 
        var i : int ; i := 0 ; while i < str1->size() do ( (     green := green->prepend(str1->at(i+1)) )  ;     i := i + 1 ) ; 
    str1 := sc.getCurrent() ; 
        var i : int ; i := 0 ; while i < str1->size() do ( (     bottom := bottom->prepend(str1->at(i+1)) )  ;     i := i + 1 ) ; 
    var cand : String ; cand := green->last() ;
    while (not(red->isEmpty()) or not(green->isEmpty())) do (     if (bottom->includes(cand)) then (     cand := red->last() ;     red := red->front() ) else (     ans := ans->append(cand) ; 
     cand := green->last() ;     green := green->front() ) ) ; 
    if (not(bottom->includes(cand))) then (     ans := ans->append(cand) ) else skip ; 
        var i : int ; i := 0 ; while i < ans->size() do ( (     OclFile["System.out"].print(ans->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.CharArrayReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.LinkedList ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while(!(line=br.readLine()).equals("-")){
      LinkedList<Character>rightword=new LinkedList<Character>();
      LinkedList<Character>downword=new LinkedList<Character>();
      Character center ;
      ArrayList<Character>right=new ArrayList<Character>();
      LinkedList<Character>down=new LinkedList<Character>();
      for(char c : line.toCharArray()){
        downword.add(c);
      }
      for(char c : br.readLine().toCharArray()){
        rightword.add(c);
      }
      for(char c : br.readLine().toCharArray()){
        down.add(c);
      }
      center=rightword.removeFirst();
      while(center!=null){
        if(! down.isEmpty()){
          if(down.peekFirst().equals(center)){
            down.removeFirst();
            if(! downword.isEmpty())center=downword.removeFirst();
            else center=null ;
          }
          else {
            right.add(center);
            if(! rightword.isEmpty())center=rightword.removeFirst();
            else center=null ;
          }
        }
        else {
          right.add(center);
          if(! rightword.isEmpty())center=rightword.removeFirst();
          else center=null ;
        }
      }
      StringBuilder sb=new StringBuilder();
      for(char c : right){
        sb.append(c);
      }
      System.out.println(sb.toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
     while (not((line) = "-")) do (     var rightword : Sequence(String) ; rightword := Sequence{} ;
     var downword : Sequence(String) ; downword := Sequence{} ;
    var center : String ;
    var right : Sequence(String) ; right := Sequence{} ;
    var down : Sequence(String) ; down := Sequence{} ;
    for (c : line->characters()) do ( (     downword := downword->including(c) )  ) ; 
    for (c : br.readLine()->characters()) do ( (     rightword := rightword->including(c) )  ) ; 
    for (c : br.readLine()->characters()) do ( (     down := down->including(c) )  ) ; 
    center := rightword->first() ;     rightword := rightword->tail() ; 
    while (center /= null) do (     if (not(down->isEmpty())) then (     if (down.peekFirst() = center) then (     down := down->tail() ; 
     if (not(downword->isEmpty())) then     center := downword->first() ;     downword := downword->tail() ; else     center := null ; ) else (     right := right->including(center) ; 
     if (not(rightword->isEmpty())) then     center := rightword->first() ;     rightword := rightword->tail() ; else     center := null ; ) ) else (     right := right->including(center) ; 
     if (not(rightword->isEmpty())) then     center := rightword->first() ;     rightword := rightword->tail() ; else     center := null ; ) ) ; 
    var sb : String ; sb := StringLib.newString() ;
    for (c : right) do ( (     sb := sb + StringLib.newString(c) )  ) ; 
    OclFile["System.out"].println(sb+"") ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      String in=sc.next();
      if("-".equals(in)){
        break ;
      }
      LinkedList<Character>red=new LinkedList<Character>();
      LinkedList<Character>green=new LinkedList<Character>();
      for(char c : in.toCharArray()){
        red.add(c);
      }
      for(char c : sc.next().toCharArray()){
        green.add(c);
      }
      LinkedList<Character>right=new LinkedList<Character>();
      char[] down=sc.next().toCharArray();
      char center=green.poll();
      final int size=green.size()+red.size();
      int cur_d=0 ;
      for(int count=0 ; count<size ; count++){
        if(cur_d<down.length && down[cur_d]==center){
          center=red.poll();
          cur_d++;
        }
        else {
          right.add(center);
          center=green.poll();
        }
      }
      right.add(center);
      for(char r : right){
        System.out.print(r);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var in : String ; in := sc.getCurrent() ;
     if ("-" = in) then (     break ) else skip ; 
    var red : Sequence(String) ; red := Sequence{} ;
    var green : Sequence(String) ; green := Sequence{} ;
    for (c : in->characters()) do ( (     red := red->including(c) )  ) ; 
    for (c : sc.getCurrent()->characters()) do ( (     green := green->including(c) )  ) ; 
    var right : Sequence(String) ; right := Sequence{} ;
    var down : Sequence(String) ; down := sc.getCurrent()->characters() ;
    var center : String ; center := green->min() ;
    var size : int ; size := green->size() + red->size() ;
    var cur_d : int ; cur_d := 0 ;
        var count : int ; count := 0 ; while count < size do ( (     if (cur_d < down->size() & down[cur_d+1] = center) then (     center := red->min() ;     red := red->sort()->tail() ; 
     cur_d := cur_d + 1 ) else (     right := right->including(center) ; 
     center := green->min() ;     green := green->sort()->tail() ) )  ;     count := count + 1 ) ; 
    right := right->including(center) ; 
    for (r : right) do ( (     OclFile["System.out"].print(r) )  ) ; 
    OclFile["System.out"].println() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      while(true){
        String[] s=new String[4];
        s[0]=br.readLine();
        if(s[0] .charAt(0)=='-'){
          break ;
        }
        s[1]=br.readLine();
        s[2]=br.readLine();
        s[3]="" ;
        int[] c={
          0,0,0,1 };
          for(int i=0 ; i<s[0] .length()+s[1] .length(); i++){
            if(s[2] .charAt(c[2])==(s[c[3] ] .charAt(c[c[3] ]))){
              c[c[3] ]++;
              c[3]=0 ;
              c[2]++;
            }
            else {
              s[3]=s[3]+s[c[3] ] .charAt(c[c[3] ]);
              c[c[3] ]++;
              c[3]=1 ;
            }
            if(c[2]>=s[2] .length()){
              s[3]=s[3]+s[c[3] ] .charAt(c[c[3] ])+s[1] .substring(c[1]);
              break ;
            }
          }
          System.out.println(s[3]);
        }
        br.close();
      }
      catch(Exception e){
        e.printStackTrace();
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var s : Sequence(String) ; s := Integer.subrange(1,4)->collect(null) ;
     s[0+1] := br.readLine() ; 
    if (s[0+1]->at(0+1) = '-') then (     break ) else skip ; 
    s[1+1] := br.readLine() ; 
    s[2+1] := br.readLine() ; 
    s[3+1] := "" ; 
    var c : Sequence(int) ; c := Sequence{0,0,0,1} ;
        var i : int ; i := 0 ; while i < s[0+1]->size() + s[1+1]->size() do ( (     if (s[2+1]->at(c[2+1]+1) = (s[c[3+1]+1]->at(c[c[3+1]+1]+1))) then (     c[c[3+1]+1] := c[c[3+1]+1] + 1 ; 
     c[3+1] := 0 ; 
     c[2+1] := c[2+1] + 1 ) else (     s[3+1] := s[3+1] + s[c[3+1]+1]->at(c[c[3+1]+1]+1) ; 
     c[c[3+1]+1] := c[c[3+1]+1] + 1 ; 
     c[3+1] := 1 ) ;  
     if (c[2+1] >= s[2+1]->size()) then (     s[3+1] := s[3+1] + s[c[3+1]+1]->at(c[c[3+1]+1]+1) + s[1+1].subrange(c[1+1]+1,c[1+1]) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s[3+1]) ; 
 ) ; 
     skip )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findMinimumOperation(int n,int d,int arrays[][]){
    int cnt=0 ;
    int first=Integer.MIN_VALUE,end=Integer.MAX_VALUE ;
    while(n>0){
      int arr[]={
        arrays[cnt][0],arrays[cnt][1] };
        Arrays.sort(arr);
        first=Math.max(first,arr[0]);
        end=Math.min(end,arr[1]);
        cnt++;
        n--;
      }
      if(first>end)System.out.print("-1");
      else {
        if(d>=first && d<=end){
          System.out.print("0");
        }
        else System.out.print(Math.min(Math.abs(first-d),Math.abs(d-end)));
      }
    }
    public static void main(String[] args){
      int n=3,d=3 ;
      int arrays[][]={
        {
          0,7 },{
            2,14 },{
              4,6 }
            };
            findMinimumOperation(n,d,arrays);
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMinimumOperation( n : int, d : int, arrays : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var first : int ; first := -2147483648 ;
    var end : int ; end := 2147483647 ;
     while (n > 0) do (     var arr : Sequence(int) ; arr := Sequence{arrays[cnt+1][0+1],arrays[cnt+1][1+1]} ;
     arr := arr->sort() ; 
    first := Set{first, arr[0+1]}->max() ; 
    end := Set{end, arr[1+1]}->min() ; 
    cnt := cnt + 1 ; 
    n := n - 1 ; 
 ) ; 
     if (first > end) then     OclFile["System.out"].print("-1") ; else (     if (d >= first & d <= end) then (     OclFile["System.out"].print("0") ) else     OclFile["System.out"].print(Set{if first - d < 0 then -(first - d) else first - d endif, if d - end < 0 then -(d - end) else d - end endif}->min()) ; ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
    var d : int ; d := 3 ;
     var arrays : Sequence(Sequence(int)) ; arrays := Sequence{Sequence{0,7},Sequence{2,14},Sequence{4,6}} ;
     execute findMinimumOperation(n, d, arrays) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findTransitionPoint(int arr[],int n){
    for(int i=0 ; i<n ; i++)if(arr[i]==1)return i ;
    return-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      0,0,0,0,1,1 };
      int n=arr.length ;
      int point=findTransitionPoint(arr,n);
      if(point>=0)System.out.print("Transition point is "+point);
      else System.out.print("There is no transition point");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findTransitionPoint( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     if (arr[i+1] = 1) then     return i else skip ;  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,0,0,0,1,1} ;
     var n : int ; n := arr->size() ;
     var point : int ; point := findTransitionPoint(arr, n) ;
     if (point >= 0) then     OclFile["System.out"].print("Transition point is " + point) ; else     OclFile["System.out"].print("There is no transition point") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class ProblemA {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int test=Integer.parseInt(br.readLine());
    while(test-->0){
      int n=Integer.parseInt(br.readLine());
      String line[]=br.readLine().split(" ");
      int sum=0 ;
      for(int i=0 ; i<n ; i++)sum+=Integer.parseInt(line[i]);
      int ans=sum/n ;
      if(sum % n!=0)ans=(sum+n-1)/n ;
      sb.append(ans);
      sb.append("\n");
    }
    System.out.println(sb);
  }
  public static int abs(int a,int b){
    return Math.abs(a-b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var test : int ; test := (br.readLine())->toInteger() ;
        while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (     sum := sum+((line[i+1])->toInteger()) ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := sum / n ;
    if (sum mod n /= 0) then     ans := (sum + n - 1) / n ; else skip ; 
    sb := sb + StringLib.newString(ans) ; 
    sb := sb + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
  static   operation abs( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if a - b < 0 then -(a - b) else a - b endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class s {
  public static void main(String[] args){
    Scanner In=new Scanner(System.in);
    int t=In.nextInt();
    while(t>0){
      int n=In.nextInt();
      long x[]=new long[n];
      long sum=0 ;
      for(int i=0 ; i<n ; i++){
        x[i]=In.nextLong();
        sum=sum+x[i];
      }
      long ans=sum/n ;
      while(ans*n<sum){
        ans+=1 ;
      }
      System.out.println(ans);
      t--;
    }
    In.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class s {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var In : OclFile ; In := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := In.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := In.getCurrent()->toInteger() ;
     var x : Sequence(long) ; x := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := In.getCurrent()->toLong() ; 
     sum := sum + x[i+1] )  ;     i := i + 1 ) ; 
    var ans : long ; ans := sum / n ;
    while (ans * n < sum) do (     ans := ans+(1) ) ; 
    OclFile["System.out"].println(ans) ; 
    t := t - 1 ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class demo {
  public static void main(String[] args){
    try {
      Scanner sc=new Scanner(System.in);
      int q=sc.nextInt();
      while(q-->0){
        int n=sc.nextInt();
        int[] arr=new int[n];
        int sum=0 ;
        for(int i=0 ; i<n ; i++){
          arr[i]=sc.nextInt();
          sum+=arr[i];
        }
        System.out.println((int)Math.ceil((double)sum/(double)n));
      }
    }
    catch(Exception e){
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class demo {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
         while (q > 0) do (        q := q - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((sum->oclAsType(double) / n->oclAsType(double))->ceil()->oclAsType(int)) ; 
 ) ;  ) )   catch (e : ProgramException) do (     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.nio.charset.MalformedInputException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter o=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int l=sc.nextInt();
      int u=sc.nextInt();
      int lr=sc.nextInt();
      int r=sc.nextInt();
      int h=lr/u*u ;
      int z=l/u ;
      if(lr % u!=0){
        h+=u ;
      }
      int g=r/u*u ;
      int f=(g-h)/u+1 ;
      o.println(z-f);
    }
    o.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var o : OclFile ; o := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var u : int ; u := sc.getCurrent()->toInteger() ;
    var lr : int ; lr := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var h : int ; h := lr / u * u ;
    var z : int ; z := l / u ;
    if (lr mod u /= 0) then (     h := h+(u) ) else skip ; 
    var g : int ; g := r / u * u ;
    var f : int ; f := (g - h) / u + 1 ;
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Equalize {
  int number ;
  public Equalize(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  static int priceTotal=0 ;
  public void input(int numberProduct,int price,int index){
    if(index==0){
      priceTotal=0 ;
    }
    priceTotal+=price ;
    if(index==numberProduct-1){
      if(((double)priceTotal/numberProduct)% 1!=0){
        System.out.println((priceTotal/numberProduct)+1);
      }
      else {
        System.out.println(priceTotal/numberProduct);
      }
    }
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    Equalize instance=new Equalize(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      int num=input.nextInt();
      for(int k=0 ; k<num ; k++){
        int n=input.nextInt();
        instance.input(num,n,k);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Equalize {
   attribute number : int;
   static operation newEqualize( number : int) : Equalize
  pre: true
  post: true
  activity:
  ( var self : Equalize ;
    self := createEqualize();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
  static   attribute priceTotal : int := 0;
   operation input( numberProduct : int, price : int, index : int) : void
  pre: true
  post: true
  activity: (     if (index = 0) then (     priceTotal := 0 ) else skip ; 
     priceTotal := priceTotal+(price) ; 
     if (index = numberProduct - 1) then (     if ((priceTotal->oclAsType(double) / numberProduct) mod 1 /= 0) then (     OclFile["System.out"].println((priceTotal / numberProduct) + 1) ) else (     OclFile["System.out"].println(priceTotal / numberProduct) ) ) else skip );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
     var instance : Equalize ; instance := Equalize.newEqualize(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
         var k : int ; k := 0 ; while k < num do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     instance.input(num, n, k) )  ;     k := k + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      int[] a=new int[n],b=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
        b[i]=sc.nextInt();
      }
      if(n % 2!=0){
        System.out.println(1);
        continue ;
      }
      Arrays.sort(a);
      Arrays.sort(b);
      System.out.println((long)(a[n/2]-a[n/2-1]+1)*(b[n/2]-b[n/2-1]+1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (n mod 2 /= 0) then (     OclFile["System.out"].println(1) ; 
     continue ) else skip ; 
    a := a->sort() ; 
    b := b->sort() ; 
    OclFile["System.out"].println((a[n / 2+1] - a[n / 2 - 1+1] + 1)->oclAsType(long) * (b[n / 2+1] - b[n / 2 - 1+1] + 1)) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class A {
  static StringBuffer str=new StringBuffer();
  static int n ;
  static long x[],y[];
  static void solve(){
    Arrays.sort(x);
    Arrays.sort(y);
    if(n % 2==0){
      long xc=x[n/2]-x[n/2-1]+1 ;
      long yc=y[n/2]-y[n/2-1]+1 ;
      str.append(xc*yc).append("\n");
    }
    else str.append("1\n");
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    int q1=Integer.parseInt(bf.readLine().trim());
    while(q1-->0){
      n=Integer.parseInt(bf.readLine().trim());
      x=new long[n];
      y=new long[n];
      for(int i=0 ; i<n ; i++){
        String s[]=bf.readLine().trim().split("\\s+");
        long u=Long.parseLong(s[0]);
        long v=Long.parseLong(s[1]);
        x[i]=u ;
        y[i]=v ;
      }
      solve();
    }
    pw.println(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   attribute str : String := StringLib.newString();
  static   attribute n : int;
  static   attribute x : long;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     x := x->sort() ; 
     y := y->sort() ; 
     if (n mod 2 = 0) then (     var xc : long ; xc := x[n / 2+1] - x[n / 2 - 1+1] + 1 ;
     var yc : long ; yc := y[n / 2+1] - y[n / 2 - 1+1] + 1 ;
     str := str + StringLib.newString(xc * yc) + StringLib.newString("\n") ) else     str := str + StringLib.newString("1\n") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var q1 : int ; q1 := (bf.readLine()->trim())->toInteger() ;
        while (q1 > 0) do (        q1 := q1 - 1 ;     skip ; (     n := (bf.readLine()->trim())->toInteger() ; 
     x := Integer.subrange(1,n)->collect(0) ; 
    y := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     var s : Sequence(String) ; s := bf.readLine()->trim()->split("\\s+") ;
     var u : long ; u := (s[0+1])->toLong() ;
    var v : long ; v := (s[1+1])->toLong() ;
    x[i+1] := u ; 
    y[i+1] := v ; 
 )  ;     i := i + 1 ) ; 
    execute solve() ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] x=new int[n+1];
      int[] y=new int[n+1];
      for(int i=1 ; i<=n ; i++){
        x[i]=sc.nextInt();
        y[i]=sc.nextInt();
      }
      if(n % 2!=0){
        System.out.println(1);
        continue ;
      }
      Arrays.sort(x,1,n+1);
      Arrays.sort(y,1,n+1);
      long a=x[n/2+1]-x[n/2]+1 ;
      long b=y[n/2+1]-y[n/2]+1 ;
      System.out.println(a*b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : Sequence(int) ; x := Integer.subrange(1,n + 1)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     y[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (n mod 2 /= 0) then (     OclFile["System.out"].println(1) ; 
     continue ) else skip ; 
    x := x.subrange(1,1)^(x.subrange(1+1,n + 1)->sort())^x.subrange(n + 1+1,x.size) ; 
    y := y.subrange(1,1)^(y.subrange(1+1,n + 1)->sort())^y.subrange(n + 1+1,y.size) ; 
    var a : long ; a := x[n / 2 + 1+1] - x[n / 2+1] + 1 ;
    var b : long ; b := y[n / 2 + 1+1] - y[n / 2+1] + 1 ;
    OclFile["System.out"].println(a * b) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    main : while(t-->0){
      int n=in.nextInt();
      long[] xs=new long[n];
      long[] ys=new long[n];
      for(int i=0 ; i<n ; i++){
        xs[i]=in.nextInt();
        ys[i]=in.nextInt();
      }
      Arrays.sort(xs);
      Arrays.sort(ys);
      System.out.println((xs[n/2]-xs[(n-1)/2]+1)*(ys[n/2]-ys[(n-1)/2]+1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var xs : Sequence(long) ; xs := Integer.subrange(1,n)->collect(0) ;
    var ys : Sequence(long) ; ys := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     xs[i+1] := in.getCurrent()->toInteger() ; 
     ys[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    xs := xs->sort() ; 
    ys := ys->sort() ; 
    OclFile["System.out"].println((xs[n / 2+1] - xs[(n - 1) / 2+1] + 1) * (ys[n / 2+1] - ys[(n - 1) / 2+1] + 1)) ; 
 ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static long cal(long S1,long S2,long S3){
    return Math.max(Math.abs(S1-S2),Math.max(Math.abs(S2-S3),Math.abs(S3-S1)));
  }
  public static long search(long H,long W){
    long min=Long.MAX_VALUE ;
    for(int h=1 ; h<H ; h++){
      long S1=h*W ;
      long H1=H-h ;
      long H2=H1/2 ;
      long H3=H1-H2 ;
      long S2=H2*W ;
      long S3=H3*W ;
      long score=cal(S1,S2,S3);
      if(score<min){
        min=score ;
      }
      long W2=W/2 ;
      long W3=W-W2 ;
      S2=H1*W2 ;
      S3=H1*W3 ;
      score=cal(S1,S2,S3);
      if(score<min){
        min=score ;
      }
    }
    return min ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long H=sc.nextLong();
    long W=sc.nextLong();
    System.out.println(Math.min(search(H,W),search(W,H)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation cal( S1 : long, S2 : long, S3 : long) : long
  pre: true
  post: true
  activity: (     return Set{if S1 - S2 < 0 then -(S1 - S2) else S1 - S2 endif, Set{if S2 - S3 < 0 then -(S2 - S3) else S2 - S3 endif, if S3 - S1 < 0 then -(S3 - S1) else S3 - S1 endif}->max()}->max() );
  static   operation search( H : long, W : long) : long
  pre: true
  post: true
  activity: (     var min : long ; min := "9223372036854775807"->toLong() ;
         var h : int ; h := 1 ; while h < H do ( (     var S1 : long ; S1 := h * W ;
     var H1 : long ; H1 := H - h ;
    var H2 : long ; H2 := H1 / 2 ;
    var H3 : long ; H3 := H1 - H2 ;
    var S2 : long ; S2 := H2 * W ;
    var S3 : long ; S3 := H3 * W ;
    var score : long ; score := cal(S1, S2, S3) ;
    if (score < min) then (     min := score ) else skip ; 
    var W2 : long ; W2 := W / 2 ;
    var W3 : long ; W3 := W - W2 ;
    S2 := H1 * W2 ; 
    S3 := H1 * W3 ; 
    score := cal(S1, S2, S3) ; 
    if (score < min) then (     min := score ) else skip ; 
 )  ;     h := h + 1 ) ; 
     return min );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : long ; H := sc.getCurrent()->toLong() ;
     var W : long ; W := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println(Set{search(H, W), search(W, H)}->min()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    int sub1 ;
    int sub2 ;
    int ans ;
    int A ;
    int B ;
    int C ;
    int H_mod3=H % 3 ;
    int W_mod3=W % 3 ;
    if(H_mod3==0){
      sub1=0 ;
    }
    else if(H_mod3==1){
      A=H/3*W ;
      B=(H-H/3)*(W/2);
      C=H*W-A-B ;
      sub1=C-A ;
      if(W<sub1){
        sub1=W ;
      }
    }
    else {
      A=(H/3+1)*W ;
      B=(H-H/3-1)*(W/2);
      C=H*W-A-B ;
      sub1=A-B ;
      if(W<sub1){
        sub1=W ;
      }
    }
    if(W_mod3==0){
      sub2=0 ;
    }
    else if(W_mod3==1){
      A=W/3*H ;
      B=(W-W/3)*(H/2);
      C=H*W-A-B ;
      sub2=C-A ;
      if(H<sub2){
        sub2=H ;
      }
    }
    else {
      A=(W/3+1)*H ;
      B=(W-W/3-1)*(H/2);
      C=H*W-A-B ;
      sub2=A-B ;
      if(H<sub2){
        sub2=H ;
      }
    }
    if(sub1<sub2){
      ans=sub1 ;
    }
    else {
      ans=sub2 ;
    }
    System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var sub1 : int ;
    var sub2 : int ;
    var ans : int ;
    var A : int ;
    var B : int ;
    var C : int ;
    var H_mod3 : int ; H_mod3 := H mod 3 ;
    var W_mod3 : int ; W_mod3 := W mod 3 ;
    if (H_mod3 = 0) then (     sub1 := 0 ) else     if (H_mod3 = 1) then (     A := H / 3 * W ; 
     B := (H - H / 3) * (W / 2) ; 
    C := H * W - A - B ; 
    sub1 := C - A ; 
    if (W < sub1) then (     sub1 := W ) else skip ; 
 ) else (     A := (H / 3 + 1) * W ; 
     B := (H - H / 3 - 1) * (W / 2) ; 
    C := H * W - A - B ; 
    sub1 := A - B ; 
    if (W < sub1) then (     sub1 := W ) else skip ; 
 ) ;  ;  
    if (W_mod3 = 0) then (     sub2 := 0 ) else     if (W_mod3 = 1) then (     A := W / 3 * H ; 
     B := (W - W / 3) * (H / 2) ; 
    C := H * W - A - B ; 
    sub2 := C - A ; 
    if (H < sub2) then (     sub2 := H ) else skip ; 
 ) else (     A := (W / 3 + 1) * H ; 
     B := (W - W / 3 - 1) * (H / 2) ; 
    C := H * W - A - B ; 
    sub2 := A - B ; 
    if (H < sub2) then (     sub2 := H ) else skip ; 
 ) ;  ;  
    if (sub1 < sub2) then (     ans := sub1 ) else (     ans := sub2 ) ;  
    OclFile["System.out"].print(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      words=line.split(" ");
      int b,r,g,c,s,t ;
      b=parseInt(words[0]);
      r=parseInt(words[1]);
      g=parseInt(words[2]);
      c=parseInt(words[3]);
      s=parseInt(words[4]);
      t=parseInt(words[5]);
      if((b | r | g | c | s | t)==0)break ;
      int sum=100 ;
      sum-=(b+r+g+c+s)*3 ;
      sum-=((b*5)+(r*3))*2 ;
      sum-=(t-(b+r+g+c+(s*2)+(b*5)+(r*3)))*3 ;
      sum+=b*(1+5)*15 ;
      sum+=r*(1+3)*15 ;
      sum+=g*7 ;
      sum+=c*2 ;
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     words := line->split(" ") ; 
     var b : int ;
    var r : int ;
    var g : int ;
    var c : int ;
    var s : int ;
    var t : int ;
    b := (words[0+1] + "")->toInteger() ; 
    r := (words[1+1] + "")->toInteger() ; 
    g := (words[2+1] + "")->toInteger() ; 
    c := (words[3+1] + "")->toInteger() ; 
    s := (words[4+1] + "")->toInteger() ; 
    t := (words[5+1] + "")->toInteger() ; 
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(MathLib.bitwiseOr(MathLib.bitwiseOr(MathLib.bitwiseOr(b,r),g),c),s),t)) = 0) then     break else skip ; 
    var sum : int ; sum := 100 ;
    sum := sum-((b + r + g + c + s) * 3) ; 
    sum := sum-(((b * 5) + (r * 3)) * 2) ; 
    sum := sum-((t - (b + r + g + c + (s * 2) + (b * 5) + (r * 3))) * 3) ; 
    sum := sum+(b * (1 + 5) * 15) ; 
    sum := sum+(r * (1 + 3) * 15) ; 
    sum := sum+(g * 7) ; 
    sum := sum+(c * 2) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] $){
    Scanner sc=new Scanner(in);
    long[] l=new long[2];
    l[0]=sc.nextLong();
    l[1]=sc.nextLong();
    long ans=l[0]*l[1];
    long[] s=new long[3];
    for(int i=0 ; i<2 ; i++){
      for(int j=1 ; j<=l[i]; j++){
        s[0]=(long)j*l[abs(1-i)];
        s[1]=(l[i]-(long)j)/2*l[abs(1-i)];
        s[2]=l[0]*l[1]-s[0]-s[1];
        Arrays.sort(s);
        ans=min(ans,s[2]-s[0]);
        s[0]=(long)j*l[abs(1-i)];
        s[1]=l[abs(1-i)]/2*(l[i]-(long)j);
        s[2]=l[0]*l[1]-s[0]-s[1];
        Arrays.sort(s);
        ans=min(s[2]-s[0],ans);
      }
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var l : Sequence(long) ; l := Integer.subrange(1,2)->collect(0) ;
    l[0+1] := sc.getCurrent()->toLong() ; 
    l[1+1] := sc.getCurrent()->toLong() ; 
    var ans : long ; ans := l[0+1] * l[1+1] ;
    var s : Sequence(long) ; s := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 do ( (         var j : int ; j := 1 ; while j <= l[i+1] do ( (     s[0+1] := j->oclAsType(long) * l[abs(1 - i)+1] ; 
     s[1+1] := (l[i+1] - j->oclAsType(long)) / 2 * l[abs(1 - i)+1] ; 
    s[2+1] := l[0+1] * l[1+1] - s[0+1] - s[1+1] ; 
    s := s->sort() ; 
    ans := Set{ans, s[2+1] - s[0+1]}->min() ; 
    s[0+1] := j->oclAsType(long) * l[abs(1 - i)+1] ; 
    s[1+1] := l[abs(1 - i)+1] / 2 * (l[i+1] - j->oclAsType(long)) ; 
    s[2+1] := l[0+1] * l[1+1] - s[0+1] - s[1+1] ; 
    s := s->sort() ; 
    ans := Set{s[2+1] - s[0+1], ans}->min() ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  private static java.util.Scanner scanner=new java.util.Scanner(System.in);
  public static void main(String[] args){
    long h=scanner.nextInt(),w=scanner.nextInt();
    long size1,size2,size3,ans=Integer.MAX_VALUE ;
    for(int i=0 ; i<2 ; i++){
      for(int j=1 ; j<h ; j++){
        size1=j*w ;
        size2=(h-j)*(w/2);
        size3=(h-j)*(w-(w/2));
        ans=Math.min(ans,Math.max(Math.max(size1,size2),size3)-Math.min(Math.min(size1,size2),size3));
        size2=(h-j)/2*w ;
        size3=(h-j-((h-j)/2))*w ;
        ans=Math.min(ans,Math.max(Math.max(size1,size2),size3)-Math.min(Math.min(size1,size2),size3));
      }
      long t=w ;
      w=h ;
      h=t ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   attribute scanner : Scanner := Scanner.newScanner(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var h : long ; h := scanner.nextInt() ;
    var w : long ; w := scanner.nextInt() ;
     var size1 : long ;
    var size2 : long ;
    var size3 : long ;
    var ans : long ; ans := 2147483647 ;
         var i : int ; i := 0 ; while i < 2 do ( (         var j : int ; j := 1 ; while j < h do ( (     size1 := j * w ; 
     size2 := (h - j) * (w / 2) ; 
    size3 := (h - j) * (w - (w / 2)) ; 
    ans := Set{ans, Set{Set{size1, size2}->max(), size3}->max() - Set{Set{size1, size2}->min(), size3}->min()}->min() ; 
    size2 := (h - j) / 2 * w ; 
    size3 := (h - j - ((h - j) / 2)) * w ; 
    ans := Set{ans, Set{Set{size1, size2}->max(), size3}->max() - Set{Set{size1, size2}->min(), size3}->min()}->min() ; 
 )  ;     j := j + 1 ) ; 
     var t : long ; t := w ;
     w := h ; 
     h := t )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static long DIFF=1000000 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    if(h % 3==0 || w % 3==0){
      System.out.println(0);
      return ;
    }
    checkDevide1(h,w);
    checkDevide1(w,h);
    checkDevide2(h,w);
    checkDevide2(w,h);
    System.out.println(DIFF);
  }
  static void checkDevide1(int height,int width){
    for(int h=1 ; h<height-1 ; h++){
      long restHeight=height-h ;
      long h1=restHeight/2 ;
      long h2=restHeight-h1 ;
      long one=(long)h*width ;
      long two=h1*width ;
      long three=h2*width ;
      long max=Math.max(Math.max(one,two),three);
      long min=Math.min(Math.min(one,two),three);
      DIFF=Math.min(DIFF,(max-min));
    }
  }
  static void checkDevide2(int height,int width){
    for(int h=1 ; h<height ; h++){
      long restHeight=height-h ;
      long w1=width/2 ;
      long w2=width-w1 ;
      long one=(long)h*width ;
      long two=restHeight*w1 ;
      long three=restHeight*w2 ;
      long max=Math.max(Math.max(one,two),three);
      long min=Math.min(Math.min(one,two),three);
      DIFF=Math.min(DIFF,(max-min));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute DIFF : long := 1000000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    if (h mod 3 = 0 or w mod 3 = 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    execute checkDevide1(h, w) ; 
    execute checkDevide1(w, h) ; 
    execute checkDevide2(h, w) ; 
    execute checkDevide2(w, h) ; 
    OclFile["System.out"].println(DIFF) ; 
 );
  static   operation checkDevide1( height : int, width : int) : void
  pre: true
  post: true
  activity: (         var h : int ; h := 1 ; while h < height - 1 do ( (     var restHeight : long ; restHeight := height - h ;
     var h1 : long ; h1 := restHeight / 2 ;
    var h2 : long ; h2 := restHeight - h1 ;
    var one : long ; one := h->oclAsType(long) * width ;
    var two : long ; two := h1 * width ;
    var three : long ; three := h2 * width ;
    var max : long ; max := Set{Set{one, two}->max(), three}->max() ;
    var min : long ; min := Set{Set{one, two}->min(), three}->min() ;
    DIFF := Set{DIFF, (max - min)}->min() ; 
 )  ;     h := h + 1 ) );
  static   operation checkDevide2( height : int, width : int) : void
  pre: true
  post: true
  activity: (         var h : int ; h := 1 ; while h < height do ( (     var restHeight : long ; restHeight := height - h ;
     var w1 : long ; w1 := width / 2 ;
    var w2 : long ; w2 := width - w1 ;
    var one : long ; one := h->oclAsType(long) * width ;
    var two : long ; two := restHeight * w1 ;
    var three : long ; three := restHeight * w2 ;
    var max : long ; max := Set{Set{one, two}->max(), three}->max() ;
    var min : long ; min := Set{Set{one, two}->min(), three}->min() ;
    DIFF := Set{DIFF, (max - min)}->min() ; 
 )  ;     h := h + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int ans=0 ;
      int L=sc.nextInt(),v=sc.nextInt(),l=sc.nextInt(),r=sc.nextInt();
      ans=L/v ;
      ans=ans-((int)(r/v)-(int)(l/v));
      if(l % v==0)ans--;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var ans : int ; ans := 0 ;
     var L : int ; L := sc.getCurrent()->toInteger() ;
    var v : int ; v := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    ans := L / v ; 
    ans := ans - ((r / v)->oclAsType(int) - (l / v)->oclAsType(int)) ; 
    if (l mod v = 0) then     ans := ans - 1 ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Series {
  static int term(int n){
    int x=(((1)+(int)Math.sqrt(1+(8*n)))/2);
    return x ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(term(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Series {
  static   operation term( n : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := (((1) + (1 + (8 * n))->sqrt()->oclAsType(int)) / 2) ;
     return x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(term(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class MaximumAbsoluteDifference {
  private static int maxDistance(int[] array){
    int max1=Integer.MIN_VALUE ;
    int min1=Integer.MAX_VALUE ;
    int max2=Integer.MIN_VALUE ;
    int min2=Integer.MAX_VALUE ;
    for(int i=0 ; i<array.length ; i++){
      max1=Math.max(max1,array[i]+i);
      min1=Math.min(min1,array[i]+i);
      max2=Math.max(max2,array[i]-i);
      min2=Math.min(min2,array[i]-i);
    }
    return Math.max(max1-min1,max2-min2);
  }
  public static void main(String[] args){
    int[] array={
-70,-64,-6,-56,64,61,-57,16,48,-98 };
      System.out.println(maxDistance(array));
    }
  }

------------------------------------------------------------
OCL File:
---------
class MaximumAbsoluteDifference {
  static   operation maxDistance( array : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var max1 : int ; max1 := -2147483648 ;
     var min1 : int ; min1 := 2147483647 ;
    var max2 : int ; max2 := -2147483648 ;
    var min2 : int ; min2 := 2147483647 ;
        var i : int ; i := 0 ; while i < array->size() do ( (     max1 := Set{max1, array[i+1] + i}->max() ; 
     min1 := Set{min1, array[i+1] + i}->min() ; 
     max2 := Set{max2, array[i+1] - i}->max() ; 
     min2 := Set{min2, array[i+1] - i}->min() )  ;     i := i + 1 ) ; 
    return Set{max1 - min1, max2 - min2}->max() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Sequence{-70,-64,-6,-56,64,61,-57,16,48,-98} ;
     OclFile["System.out"].println(maxDistance(array)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Graph {
  static void addEdge(ArrayList<ArrayList<Integer>>adj,int u,int v){
    adj.get(u).add(v);
    adj.get(v).add(u);
  }
  static void printGraph(ArrayList<ArrayList<Integer>>adj){
    for(int i=0 ; i<adj.size(); i++){
      System.out.println("\nAdjacency list of vertex"+i);
      for(int j=0 ; j<adj.get(i).size(); j++){
        System.out.print("->"+adj.get(i).get(j));
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    int V=5 ;
    ArrayList<ArrayList<Integer>>adj=new ArrayList<ArrayList<Integer>>(V);
    for(int i=0 ; i<V ; i++)adj.add(new ArrayList<Integer>());
    addEdge(adj,0,1);
    addEdge(adj,0,4);
    addEdge(adj,1,2);
    addEdge(adj,1,3);
    addEdge(adj,1,4);
    addEdge(adj,2,3);
    addEdge(adj,3,4);
    printGraph(adj);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Graph {
  static   operation addEdge( adj : Sequence(Sequence(int)), u : int, v : int) : void
  pre: true
  post: true
  activity: (     adj->at(u+1)->excludes(v) ; 
     adj->at(v+1)->excludes(u) );
  static   operation printGraph( adj : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < adj->size() do ( (     OclFile["System.out"].println("\nAdjacency list of vertex" + i) ; 
         var j : int ; j := 0 ; while j < adj->at(i+1)->size() do ( (     OclFile["System.out"].print("->" + adj->at(i+1)->at(j+1)) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var V : int ; V := 5 ;
     var adj : Sequence(Sequence(int)) ; adj := Sequence{} ;
        var i : int ; i := 0 ; while i < V do (     adj := adj->including(Sequence{}) ;  ;     i := i + 1 ) ; 
    execute addEdge(adj, 0, 1) ; 
    execute addEdge(adj, 0, 4) ; 
    execute addEdge(adj, 1, 2) ; 
    execute addEdge(adj, 1, 3) ; 
    execute addEdge(adj, 1, 4) ; 
    execute addEdge(adj, 2, 3) ; 
    execute addEdge(adj, 3, 4) ; 
    execute printGraph(adj) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class GFG {
  static void twoWaySort(int arr[],int n){
    for(int i=0 ; i<n ; i++)if((arr[i] & 1)!=0)arr[i]*=-1 ;
    Arrays.sort(arr);
    for(int i=0 ; i<n ; i++)if((arr[i] & 1)!=0)arr[i]*=-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      1,3,2,7,5,4 };
      twoWaySort(arr,arr.length);
      System.out.println(Arrays.toString(arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation twoWaySort( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     if ((arr[i+1] & 1) /= 0) then     arr[i+1] := arr[i+1]*(-1) ; else skip ;  ;     i := i + 1 ) ; 
     arr := arr->sort() ; 
         var i : int ; i := 0 ; while i < n do (     if ((arr[i+1] & 1) /= 0) then     arr[i+1] := arr[i+1]*(-1) ; else skip ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,2,7,5,4} ;
     execute twoWaySort(arr, arr->size()) ; 
     OclFile["System.out"].println((arr + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    solve();
  }
  public static void solve(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    double[] a=new double[n];
    double[] b=new double[n];
    HashMap<Double,Integer>ans=new HashMap<Double,Integer>();
    int[] count=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextDouble();
      b[i]=a[i];
    }
    Arrays.sort(a);
    for(int i=0 ; i<n-1 ; i++){
      if(a[i]==a[i+1]){
        count[i]=Math.max(1,count[i]);
        count[i+1]=count[i]+1 ;
      }
    }
    for(int i=n-1 ; i>=0 ; i--){
      if(count[i]==0){
        ans.put(a[i],3*i);
      }
      else {
        ans.put(a[i],3*(i-count[i]+1)+(count[i]-1));
        i-=count[i]-1 ;
      }
    }
    for(int i=0 ; i<n ; i++){
      System.out.println(ans.get(b[i]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(double) ; a := Integer.subrange(1,n)->collect(0.0) ;
    var b : Sequence(double) ; b := Integer.subrange(1,n)->collect(0.0) ;
    var ans : Map(double,int) ; ans := Map{} ;
    var count : Sequence(int) ; count := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toReal() ; 
     b[i+1] := a[i+1] )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (a[i+1] = a[i + 1+1]) then (     count[i+1] := Set{1, count[i+1]}->max() ; 
     count[i + 1+1] := count[i+1] + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (count[i+1] = 0) then (     ans := ans->union(Map{a[i+1] |-> 3 * i}) ) else (     ans := ans->union(Map{a[i+1] |-> 3 * (i - count[i+1] + 1) + (count[i+1] - 1)}) ; 
     i := i-(count[i+1] - 1) ) )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(ans->at(b[i+1])) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    solve();
  }
  public static void solve(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    int[] score=new int[4001];
    for(int i=0 ; i<n ; i++){
      String s=sc.next();
      int counter=3 ;
      for(int j=0 ; j<s.length(); j++){
        if(j==1){
          continue ;
        }
        a[i]+=(int)Math.pow(10,counter)*((int)s.charAt(j)-(int)'0');
        counter--;
      }
    }
    for(int i=0 ; i<n ; i++){
      score[a[i] ]++;
    }
    int now=0 ;
    for(int i=0 ; i<=4000 ; i++){
      if(score[i]!=0){
        int tmp=score[i]-1+3*now ;
        now+=score[i];
        score[i]=tmp ;
      }
    }
    for(int i=0 ; i<n ; i++){
      System.out.println(score[a[i] ]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var score : Sequence(int) ; score := Integer.subrange(1,4001)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
     var counter : int ; counter := 3 ;
         var j : int ; j := 0 ; while j < s->size() do ( (     if (j = 1) then (     continue ) else skip ; 
     a[i+1] := a[i+1]+(10->pow(counter)->oclAsType(int) * (s->at(j+1)->oclAsType(int) - ('0')->char2byte())) ; 
     counter := counter - 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     score[a[i+1]+1] := score[a[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var now : int ; now := 0 ;
        var i : int ; i := 0 ; while i <= 4000 do ( (     if (score[i+1] /= 0) then (     var tmp : int ; tmp := score[i+1] - 1 + 3 * now ;
     now := now+(score[i+1]) ; 
     score[i+1] := tmp ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(score[a[i+1]+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int b=sc.nextInt();
      int r=sc.nextInt();
      int g=sc.nextInt();
      int c=sc.nextInt();
      int s=sc.nextInt();
      int t=sc.nextInt();
      if((b | r | g | c | s)==0)break ;
      long cnt=100 ;
      cnt+=b*15+5*b*15 ;
      cnt+=r*15+3*r*15 ;
      cnt+=g*7 ;
      cnt+=c*2 ;
      cnt+=3*s ;
      cnt-=t*3 ;
      cnt+=5*b+3*r ;
      System.out.println(cnt);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var b : int ; b := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var g : int ; g := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(MathLib.bitwiseOr(MathLib.bitwiseOr(b,r),g),c),s)) = 0) then     break else skip ; 
    var cnt : long ; cnt := 100 ;
    cnt := cnt+(b * 15 + 5 * b * 15) ; 
    cnt := cnt+(r * 15 + 3 * r * 15) ; 
    cnt := cnt+(g * 7) ; 
    cnt := cnt+(c * 2) ; 
    cnt := cnt+(3 * s) ; 
    cnt := cnt-(t * 3) ; 
    cnt := cnt+(5 * b + 3 * r) ; 
    OclFile["System.out"].println(cnt) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPalindrome(String s){
    int i=0 ;
    int j=s.length()-1 ;
    while(i<j){
      if(s.charAt(i)!=s.charAt(j))return false ;
      i++;
      j--;
    }
    return true ;
  }
  static int getIndex(String S1,String S2,int n){
    String S="" ;
    for(int i=0 ; i<n ; i++){
      S=S+S1.charAt(i);
      String Temp="" ;
      for(int j=i+1 ; j<n ; j++)Temp+=S2.charAt(j);
      if(isPalindrome(S+Temp)){
        return i ;
      }
    }
    return-1 ;
  }
  public static void main(String[] args){
    String S1="abcdf",S2="sfgba" ;
    int n=S1.length();
    System.out.println(getIndex(S1,S2,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPalindrome( s : String) : boolean
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var j : int ; j := s->size() - 1 ;
     while (i < j) do (     if (s->at(i+1) /= s->at(j+1)) then     return false else skip ; 
     i := i + 1 ; 
     j := j - 1 ) ; 
     return true );
  static   operation getIndex( S1 : String, S2 : String, n : int) : int
  pre: true
  post: true
  activity: (     var S : String ; S := "" ;
         var i : int ; i := 0 ; while i < n do ( (     S := S + S1->at(i+1) ; 
     var Temp : String ; Temp := "" ;
         var j : int ; j := i + 1 ; while j < n do (     Temp := Temp+(S2->at(j+1)) ;  ;     j := j + 1 ) ; 
     if (isPalindrome(S + Temp)) then (     return i ) else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S1 : String ; S1 := "abcdf" ;
    var S2 : String ; S2 := "sfgba" ;
     var n : int ; n := S1->size() ;
     OclFile["System.out"].println(getIndex(S1, S2, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.regex.Pattern ;
import java.util.regex.Matcher ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    Pattern p=Pattern.compile("\\s[A-Za-z]*\\s");
    Matcher m=p.matcher(s);
    if(m.find()){
      System.out.println("A"+m.group().charAt(1)+"C");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var p : OclRegex ; p := OclRegex.compile("\\s[A-Za-z]*\\s") ;
    var m : OclRegex ; m := p.matcher(s) ;
    if (m.nextMatch()) then (     OclFile["System.out"].println("A" + m.group()->at(1+1) + "C") ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tokenizer=new StringTokenizer(input.readLine());
    StringBuilder output=new StringBuilder();
    while(tokenizer.hasMoreTokens())output.append(tokenizer.nextToken().charAt(0));
    System.out.println(output);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tokenizer : OclIterator ; tokenizer := OclIterator.newOclIterator_String(input.readLine()) ;
    var output : String ; output := StringLib.newString() ;
    while (tokenizer.hasNext()) do     output := output + StringLib.newString(tokenizer.next()->at(0+1)) ; ; 
    OclFile["System.out"].println(output) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String a=sc.next();
    String b=sc.next();
    String c=sc.next();
    String x=a.substring(0,1);
    String y=b.substring(0,1);
    String z=c.substring(0,1);
    x=x.toUpperCase();
    y=y.toUpperCase();
    z=z.toUpperCase();
    System.out.print(x);
    System.out.print(y);
    System.out.print(z);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := sc.getCurrent() ;
    var b : String ; b := sc.getCurrent() ;
    var c : String ; c := sc.getCurrent() ;
    var x : String ; x := a.subrange(0+1,1) ;
    var y : String ; y := b.subrange(0+1,1) ;
    var z : String ; z := c.subrange(0+1,1) ;
    x := x->toUpperCase() ; 
    y := y->toUpperCase() ; 
    z := z->toUpperCase() ; 
    OclFile["System.out"].print(x) ; 
    OclFile["System.out"].print(y) ; 
    OclFile["System.out"].print(z) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class407 {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int ans=3 ;
    if(k==1 || k==n){
      ans+=(n-1)*3 ;
    }
    else {
      ans+=Math.min(k-1,n-k)*3+Math.min(k-1,n-k)+Math.max(n-k,k-1)*3 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class class407 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 3 ;
    if (k = 1 or k = n) then (     ans := ans+((n - 1) * 3) ) else (     ans := ans+(Set{k - 1, n - k}->min() * 3 + Set{k - 1, n - k}->min() + Set{n - k, k - 1}->max() * 3) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String string=sc.nextLine();
    String[] strings=string.split(" ");
    System.out.println(strings[0] .substring(0,1)+strings[1] .substring(0,1)+strings[2] .substring(0,1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var string : String ; string := sc.nextLine() ;
     var strings : Sequence(String) ; strings := string->split(" ") ;
     OclFile["System.out"].println(strings[0+1].subrange(0+1,1) + strings[1+1].subrange(0+1,1) + strings[2+1].subrange(0+1,1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line=br.readLine();
    String[] ana=new String[4];
    ana=line.split(" ");
    String a=ana[1] .substring(0,1);
    System.out.println("A"+a+"C");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := br.readLine() ;
    var ana : Sequence(String) ; ana := Integer.subrange(1,4)->collect(null) ;
    ana := line->split(" ") ; 
    var a : String ; a := ana[1+1].subrange(0+1,1) ;
    OclFile["System.out"].println("A" + a + "C") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sumArr(int arr[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=arr[i];
    return sum ;
  }
  static int sumModArr(int arr[],int n){
    int subSum=arr[n-1];
    for(int i=n-2 ; i>=0 ; i--){
      int curr=arr[i];
      arr[i]-=subSum ;
      subSum+=curr ;
    }
    return sumArr(arr,n);
  }
  public static void main(String[] args){
    int[] arr={
      40,25,12,10 };
      int n=arr.length ;
      System.out.println(sumModArr(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumArr( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation sumModArr( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var subSum : int ; subSum := arr[n - 1+1] ;
         var i : int ; i := n - 2 ; while i >= 0 do ( (     var curr : int ; curr := arr[i+1] ;
     arr[i+1] := arr[i+1]-(subSum) ; 
     subSum := subSum+(curr) )  ;     i := i - 1 ) ; 
     return sumArr(arr, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{40,25,12,10} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(sumModArr(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMax(int arr[],int low,int high){
    if(high<low)return arr[0];
    if(high==low)return arr[low];
    int mid=low+(high-low)/2 ;
    if(mid<high && arr[mid+1]<arr[mid]){
      return arr[mid];
    }
    if(mid>low && arr[mid]<arr[mid-1]){
      return arr[mid-1];
    }
    if(arr[low]>arr[mid]){
      return findMax(arr,low,mid-1);
    }
    else {
      return findMax(arr,mid+1,high);
    }
  }
  public static void main(String[] args){
    int arr[]={
      5,6,1,2,3,4 };
      int n=arr.length ;
      System.out.println(findMax(arr,0,n-1));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMax( arr : Sequence(int), low : int, high : int) : int
  pre: true
  post: true
  activity: (     if (high < low) then     return arr[0+1] else skip ; 
     if (high = low) then     return arr[low+1] else skip ; 
    var mid : int ; mid := low + (high - low) / 2 ;
    if (mid < high & arr[mid + 1+1] < arr[mid+1]) then (     return arr[mid+1] ) else skip ; 
    if (mid > low & arr[mid+1] < arr[mid - 1+1]) then (     return arr[mid - 1+1] ) else skip ; 
    if (arr[low+1] > arr[mid+1]) then (     return findMax(arr, low, mid - 1) ) else (     return findMax(arr, mid + 1, high) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,6,1,2,3,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMax(arr, 0, n - 1)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  static int findCount(int m,int n){
    int num1=0 ;
    for(int i=0 ; i<m ; i++)num1=(num1*10)+9 ;
    int num2=0 ;
    for(int i=0 ; i<(m-1); i++)num2=(num2*10)+9 ;
    return((num1/n)-(num2/n));
  }
  public static void main(String[] args){
    int m=2,n=6 ;
    System.out.println(findCount(m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation findCount( m : int, n : int) : int
  pre: true
  post: true
  activity: (     var num1 : int ; num1 := 0 ;
         var i : int ; i := 0 ; while i < m do (     num1 := (num1 * 10) + 9 ;  ;     i := i + 1 ) ; 
    var num2 : int ; num2 := 0 ;
        var i : int ; i := 0 ; while i < (m - 1) do (     num2 := (num2 * 10) + 9 ;  ;     i := i + 1 ) ; 
    return ((num1 / n) - (num2 / n)) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 2 ;
    var n : int ; n := 6 ;
     OclFile["System.out"].println(findCount(m, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static class Node {
    int data ;
    Node next ;
  }
  static Node head=null ;
  static void push(int new_data){
    Node new_node=new Node();
    new_node.data=new_data ;
    new_node.next=(head);
(head)=new_node ;
  }
  static Node reverseList(Node head){
    Stack<Node>stk=new Stack<Node>();
    Node ptr=head ;
    while(ptr.next!=null){
      stk.push(ptr);
      ptr=ptr.next ;
    }
    head=ptr ;
    while(! stk.isEmpty()){
      ptr.next=stk.peek();
      ptr=ptr.next ;
      stk.pop();
    }
    ptr.next=null ;
    return head ;
  }
  static void printList(Node head){
    while(head!=null){
      System.out.print(head.data+" ");
      head=head.next ;
    }
  }
  public static void main(String[] args){
    push(5);
    push(4);
    push(3);
    push(2);
    push(1);
    head=reverseList(head);
    printList(head);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   attribute head : Node := null;
  static   operation push( new_data : int) : void
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode() ;
     new_node.data := new_data ; 
     new_node.next := (head) ; 
     (head) := new_node );
  static   operation reverseList( head : Node) : Node
  pre: true
  post: true
  activity: (     var stk : Sequence(Node) ; stk := Sequence{} ;
     var ptr : Node ; ptr := head ;
    while (ptr.next /= null) do (     stk := stk->append(ptr) ; 
     ptr := ptr.next ) ; 
    head := ptr ; 
    while (not(stk->isEmpty())) do (     ptr.next := stk->min() ; 
     ptr := ptr.next ; 
     stk := stk->front() ) ; 
    ptr.next := null ; 
    return head 
 );
  static   operation printList( head : Node) : void
  pre: true
  post: true
  activity: (     while (head /= null) do (     OclFile["System.out"].print(head.data + " ") ; 
     head := head.next ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute push(5) ; 
     execute push(4) ; 
    execute push(3) ; 
    execute push(2) ; 
    execute push(1) ; 
    head := reverseList(head) ; 
    execute printList(head) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int d=sc.nextInt();
    Map<Integer,Integer>hs=new HashMap<>();
    Map<Integer,Integer>ws=new HashMap<>();
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        int x=sc.nextInt()-1 ;
        hs.put(x,i);
        ws.put(x,j);
      }
    }
    int maxSteps=(h*w/d)+1 ;
    int[][] costs=new int[d][maxSteps];
    for(int i=0 ; i<d ; i++){
      int ihPrev=hs.get(i);
      int iwPrev=ws.get(i);
      int steps=1 ;
      while(steps<maxSteps){
        if(i+steps*d>h*w-1)break ;
        int ih=hs.get(i+steps*d);
        int iw=ws.get(i+steps*d);
        costs[i][steps]=Math.abs(ih-ihPrev)+Math.abs(iw-iwPrev)+costs[i][steps-1];
        ihPrev=ih ;
        iwPrev=iw ;
        steps++;
      }
    }
    int q=sc.nextInt();
    StringBuilder sb=new StringBuilder();
    while(q-->0){
      int l=sc.nextInt()-1 ;
      int r=sc.nextInt()-1 ;
      sb.append(costs[r % d][r/d]-costs[l % d][l/d]);
      sb.append("\n");
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var hs : Map(int,int) ; hs := Map{} ;
    var ws : Map(int,int) ; ws := Map{} ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
     hs := hs->union(Map{x |-> i}) ; 
     ws := ws->union(Map{x |-> j}) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var maxSteps : int ; maxSteps := (h * w / d) + 1 ;
    var costs : Sequence(Sequence(int)) ; costs := Integer.subrange(1,d)->collect(Integer.subrange(1,maxSteps)->collect(0)) ;
        var i : int ; i := 0 ; while i < d do ( (     var ihPrev : int ; ihPrev := hs->at(i) ;
     var iwPrev : int ; iwPrev := ws->at(i) ;
     var steps : int ; steps := 1 ;
     while (steps < maxSteps) do (     if (i + steps * d > h * w - 1) then     break else skip ; 
     var ih : int ; ih := hs->at(i + steps * d) ;
    var iw : int ; iw := ws->at(i + steps * d) ;
    costs[i+1][steps+1] := if ih - ihPrev < 0 then -(ih - ihPrev) else ih - ihPrev endif + if iw - iwPrev < 0 then -(iw - iwPrev) else iw - iwPrev endif + costs[i+1][steps - 1+1] ; 
    ihPrev := ih ; 
    iwPrev := iw ; 
    steps := steps + 1 ; 
 ) )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     var l : int ; l := sc.getCurrent()->toInteger() - 1 ;
     var r : int ; r := sc.getCurrent()->toInteger() - 1 ;
     sb := sb + StringLib.newString(costs[r mod d+1][r / d+1] - costs[l mod d+1][l / d+1]) ; 
     sb := sb + StringLib.newString("\n") ) ;  ) ;  
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.ArrayList ;
import java.util.HashMap ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    int D=sc.nextInt();
    int[][] A=new int[H][W];
    HashMap<Integer,ArrayList<Integer>>map=new HashMap<>();
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        A[i][j]=sc.nextInt();
        ArrayList<Integer>list=new ArrayList<Integer>();
        list.add(i);
        list.add(j);
        map.put(A[i][j],list);
      }
    }
    long[] d=new long[H*W+1];
    for(int i=1 ; i<=H*W ; i++){
      if(i<=D){
        d[i]=0 ;
      }
      else {
        ArrayList<Integer>listx=map.get(i);
        ArrayList<Integer>listy=map.get(i-D);
        d[i]=d[i-D]+Math.abs(listx.get(0)-listy.get(0))+Math.abs(listx.get(1)-listy.get(1));
      }
    }
    int Q=sc.nextInt();
    int[] L=new int[Q];
    int[] R=new int[Q];
    for(int i=0 ; i<Q ; i++){
      L[i]=sc.nextInt();
      R[i]=sc.nextInt();
      System.out.println(d[R[i] ]-d[L[i] ]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var D : int ; D := sc.getCurrent()->toInteger() ;
    var A : Sequence(Sequence(int)) ; A := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
    var map : Map(int,Sequence(int)) ; map := Map{} ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     A[i+1][j+1] := sc.getCurrent()->toInteger() ; 
     var list : Sequence(int) ; list := Sequence{} ;
    list := list->including(i) ; 
    list := list->including(j) ; 
    map := map->union(Map{A[i+1][j+1] |-> list}) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var d : Sequence(long) ; d := Integer.subrange(1,H * W + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= H * W do ( (     if (i <= D) then (     d[i+1] := 0 ) else (     var listx : Sequence(int) ; listx := map->at(i) ;
     var listy : Sequence(int) ; listy := map->at(i - D) ;
     d[i+1] := d[i - D+1] + if listx->at(0+1) - listy->at(0+1) < 0 then -(listx->at(0+1) - listy->at(0+1)) else listx->at(0+1) - listy->at(0+1) endif + if listx->at(1+1) - listy->at(1+1) < 0 then -(listx->at(1+1) - listy->at(1+1)) else listx->at(1+1) - listy->at(1+1) endif ) )  ;     i := i + 1 ) ; 
    var Q : int ; Q := sc.getCurrent()->toInteger() ;
    var L : Sequence(int) ; L := Integer.subrange(1,Q)->collect(0) ;
    var R : Sequence(int) ; R := Integer.subrange(1,Q)->collect(0) ;
        var i : int ; i := 0 ; while i < Q do ( (     L[i+1] := sc.getCurrent()->toInteger() ; 
     R[i+1] := sc.getCurrent()->toInteger() ; 
     OclFile["System.out"].println(d[R[i+1]+1] - d[L[i+1]+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int H=in.nextInt();
    int W=in.nextInt();
    int D=in.nextInt();
    Point[] ary=new Point[H*W+1];
    int[] save=new int[H*W+1];
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        int ind=in.nextInt();
        ary[ind]=new Point(i+1,j+1);
      }
    }
    for(int i=1 ; i<=H*W-D ; i++){
      save[i]=getPoints(ary[i] .x,ary[i] .y,ary[i+D] .x,ary[i+D] .y);
      if(i-D>0)save[i]+=save[i-D];
    }
    int Q=in.nextInt();
    while(Q-->0){
      int total=0 ;
      int L=in.nextInt();
      int R=in.nextInt();
      if(L==R){
        System.out.println(0);
        continue ;
      }
      if(L-D>0)System.out.println(save[R-D]-save[L-D]);
      else System.out.println(save[R-D]);
    }
  }
  public static int getPoints(int i,int j,int x,int y){
    return Math.abs(x-i)+Math.abs(y-j);
  }
  public static class Point {
    int x,y ;
    public Point(int x,int y){
      this.x=x ;
      this.y=y ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := in.getCurrent()->toInteger() ;
    var W : int ; W := in.getCurrent()->toInteger() ;
    var D : int ; D := in.getCurrent()->toInteger() ;
    var ary : Sequence(Point) ; ary := Integer.subrange(1,H * W + 1)->collect(null) ;
    var save : Sequence(int) ; save := Integer.subrange(1,H * W + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     var ind : int ; ind := in.getCurrent()->toInteger() ;
     ary[ind+1] := Point.newPoint(i + 1, j + 1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= H * W - D do ( (     save[i+1] := getPoints(ary[i+1].x, ary[i+1].y, ary[i + D+1].x, ary[i + D+1].y) ; 
     if (i - D > 0) then     save[i+1] := save[i+1]+(save[i - D+1]) ; else skip )  ;     i := i + 1 ) ; 
    var Q : int ; Q := in.getCurrent()->toInteger() ;
        while (Q > 0) do (        Q := Q - 1 ;     skip ; (     var total : int ; total := 0 ;
     var L : int ; L := in.getCurrent()->toInteger() ;
    var R : int ; R := in.getCurrent()->toInteger() ;
    if (L = R) then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
    if (L - D > 0) then     OclFile["System.out"].println(save[R - D+1] - save[L - D+1]) else     OclFile["System.out"].println(save[R - D+1]) ; ;  
 ) ;  ) ;  
 );
  static   operation getPoints( i : int, j : int, x : int, y : int) : int
  pre: true
  post: true
  activity: (     return if x - i < 0 then -(x - i) else x - i endif + if y - j < 0 then -(y - j) else y - j endif );
  static class Point {
   attribute x : int;
   static operation newPoint( x : int, y : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    int D=sc.nextInt();
    int A[][]=new int[H][W];
    int rA[][]=new int[H*W+1][2];
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        int x=sc.nextInt();
        A[i][j]=x ;
        rA[x][0]=i ;
        rA[x][1]=j ;
      }
    }
    long cost[]=new long[H*W+1];
    for(int a=1 ; a<=H*W ; a++){
      if(a+D>H*W)break ;
      int i=rA[a][0];
      int j=rA[a][1];
      int x=rA[a+D][0];
      int y=rA[a+D][1];
      cost[a+D]=cost[a]+(long)Math.abs(i-x)+(long)Math.abs(j-y);
    }
    int Q=sc.nextInt();
    for(int i=0 ; i<Q ; i++){
      int L=sc.nextInt();
      int R=sc.nextInt();
      System.out.println(cost[R]-cost[L]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var D : int ; D := sc.getCurrent()->toInteger() ;
    var A : Sequence(Sequence(int)) ; A := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
    var rA : Sequence(Sequence(int)) ; rA := Integer.subrange(1,H * W + 1)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     A[i+1][j+1] := x ; 
     rA[x+1][0+1] := i ; 
     rA[x+1][1+1] := j )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var cost : Sequence(long) ; cost := Integer.subrange(1,H * W + 1)->collect(0) ;
        var a : int ; a := 1 ; while a <= H * W do ( (     if (a + D > H * W) then     break else skip ; 
     var i : int ; i := rA[a+1][0+1] ;
    var j : int ; j := rA[a+1][1+1] ;
    var x : int ; x := rA[a + D+1][0+1] ;
    var y : int ; y := rA[a + D+1][1+1] ;
    cost[a + D+1] := cost[a+1] + if i - x < 0 then -(i - x) else i - x endif->oclAsType(long) + if j - y < 0 then -(j - y) else j - y endif->oclAsType(long) ; 
 )  ;     a := a + 1 ) ; 
    var Q : int ; Q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < Q do ( (     var L : int ; L := sc.getCurrent()->toInteger() ;
     var R : int ; R := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(cost[R+1] - cost[L+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Div2B {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    FastReader fsr=new FastReader();
    int n=fsr.nextInt();
    int k=fsr.nextInt();
    solution(n,k,out);
    out.flush();
    out.close();
  }
  private static void solution(int n,int k,PrintWriter out){
    int num_moves=n+(n+1)+(n-1);
    if(1<k && k<n){
      num_moves+=Math.min(k-1,n-k);
    }
    out.println(num_moves);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Div2B {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var fsr : FastReader ; fsr := FastReader.newFastReader() ;
    var n : int ; n := fsr.nextInt() ;
    var k : int ; k := fsr.nextInt() ;
    execute solution(n, k, out) ; 
    skip ; 
    skip ; 
 );
  static   operation solution( n : int, k : int, out : OclFile) : void
  pre: true
  post: true
  activity: (     var num_moves : int ; num_moves := n + (n + 1) + (n - 1) ;
     if (1 < k & k < n) then (     num_moves := num_moves+(Set{k - 1, n - k}->min()) ) else skip ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=Integer.parseInt(sc.next());
    int w=Integer.parseInt(sc.next());
    int d=Integer.parseInt(sc.next());
    int n=h*w ;
    Data[] data=new Data[n+1];
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        int a=Integer.parseInt(sc.next());
        data[a]=new Data(i+1,j+1);
      }
    }
    int[] sum=new int[n+1];
    for(int i=d+1 ; i<=n ; i++){
      int p=data[i] .geth()-data[i-d] .geth();
      int q=data[i] .getw()-data[i-d] .getw();
      int P=Math.abs(p);
      int Q=Math.abs(q);
      sum[i]=sum[i-d]+P+Q ;
    }
    int q=Integer.parseInt(sc.next());
    int[] ans=new int[q];
    for(int i=0 ; i<q ; i++){
      int l=Integer.parseInt(sc.next());
      int r=Integer.parseInt(sc.next());
      ans[i]=sum[r]-sum[l];
    }
    for(int i=0 ; i<q ; i++){
      System.out.println(ans[i]);
    }
  }
}
class Data {
  private int h ;
  private int w ;
  public Data(int h,int w){
    this.h=h ;
    this.w=w ;
  }
  public int geth(){
    return h ;
  }
  public int getw(){
    return w ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := (sc.getCurrent())->toInteger() ;
    var w : int ; w := (sc.getCurrent())->toInteger() ;
    var d : int ; d := (sc.getCurrent())->toInteger() ;
    var n : int ; n := h * w ;
    var data : Sequence(Data) ; data := Integer.subrange(1,n + 1)->collect(null) ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     var a : int ; a := (sc.getCurrent())->toInteger() ;
     data[a+1] := Data.newData(i + 1, j + 1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : Sequence(int) ; sum := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := d + 1 ; while i <= n do ( (     var p : int ; p := data[i+1].geth() - data[i - d+1].geth() ;
     var q : int ; q := data[i+1].getw() - data[i - d+1].getw() ;
    var P : int ; P := if p < 0 then -(p) else p endif ;
    var Q : int ; Q := if q < 0 then -(q) else q endif ;
    sum[i+1] := sum[i - d+1] + P + Q ; 
 )  ;     i := i + 1 ) ; 
    var q : int ; q := (sc.getCurrent())->toInteger() ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,q)->collect(0) ;
        var i : int ; i := 0 ; while i < q do ( (     var l : int ; l := (sc.getCurrent())->toInteger() ;
     var r : int ; r := (sc.getCurrent())->toInteger() ;
     ans[i+1] := sum[r+1] - sum[l+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     OclFile["System.out"].println(ans[i+1]) )  ;     i := i + 1 ) ; 
 );
}
class Data {
   attribute h : int;
   attribute w : int;
   static operation newData( h : int, w : int) : Data
  pre: true
  post: true
  activity:
  ( var self : Data ;
    self := createData();
    self.initialise(h, w);
    return self );
  operation initialise( h : int, w : int) : void
  pre: true  post: true
  activity: (     self.h := h ; 
     self.w := w );
   operation geth() : int
  pre: true
  post: true
  activity: (     return h );
   operation getw() : int
  pre: true
  post: true
  activity: (     return w );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main implements Runnable {
  private static int MOD=1_000_000_007 ;
  public static void main(String[] args){
    Thread thread=new Thread(null,new Main(),"",32*1024*1024);
    thread.start();
  }
  @ Override public void run(){
    final Scanner scanner=new Scanner(System.in);
    solve(scanner);
  }
  static void solve(Scanner scanner){
    String s=scanner.next();
    String t=scanner.next();
    System.out.println(t+s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
  static   attribute MOD : int := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var thread : OclProcess ; thread := OclProcess.newOclProcess(null, Main.newMain(), "", 32 * 1024 * 1024) ;
     thread.start() );
      operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute solve(scanner) );
  static   operation solve( scanner : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := scanner.getCurrent() ;
     var t : String ; t := scanner.getCurrent() ;
     OclFile["System.out"].println(t + s) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class Main {
  public static void main(String[] args)throws Exception {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader reader=new BufferedReader(is);
    List<String>mylist=new ArrayList<>();
    String strinput=reader.readLine();
    while(strinput!=null){
      mylist.add(strinput);
      strinput=reader.readLine();
    }
    String arr01[]=mylist.get(0).split(" ");
    String s=arr01[0];
    String t=arr01[1];
    System.out.println(t+s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(is) ;
    var mylist : Sequence(String) ; mylist := Sequence{} ;
    var strinput : String ; strinput := reader.readLine() ;
    while (strinput /= null) do (     mylist := mylist->including(strinput) ; 
     strinput := reader.readLine() ) ; 
    var arr01 : Sequence(String) ; arr01 := mylist->at(0+1)->split(" ") ;
    var s : String ; s := arr01[0+1] ;
    var t : String ; t := arr01[1+1] ;
    OclFile["System.out"].println(t + s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    String S=scan.next();
    String T=scan.next();
    System.out.println(T+S);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var S : String ; S := scan.getCurrent() ;
     var T : String ; T := scan.getCurrent() ;
     OclFile["System.out"].println(T + S) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String str=input.readLine();
      String str_ary[]=str.split(" ");
      if(str_ary[0] .equals("0")&& str_ary[1] .equals("0")&& str_ary[2] .equals("0")&& str_ary[3] .equals("0")&& str_ary[4] .equals("0")&& str_ary[5] .equals("0"))break ;
      int x[]=new int[6];
      for(int i=0 ; i<6 ; i++){
        x[i]=Integer.parseInt(str_ary[i]);
      }
      int score=15*(x[0]+x[1])+15*(x[0]*5+x[1]*3)+7*x[2]+2*x[3]+100-3*(x[5]-x[4]-(x[0]*5+x[1]*3))-2*(x[0]*5+x[1]*3);
      System.out.println(score);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var str : String ; str := input.readLine() ;
     var str_ary : Sequence(String) ; str_ary := str->split(" ") ;
    if (str_ary[0+1] = "0" & str_ary[1+1] = "0" & str_ary[2+1] = "0" & str_ary[3+1] = "0" & str_ary[4+1] = "0" & str_ary[5+1] = "0") then     break else skip ; 
    var x : Sequence(int) ; x := Integer.subrange(1,6)->collect(0) ;
        var i : int ; i := 0 ; while i < 6 do ( (     x[i+1] := (str_ary[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var score : int ; score := 15 * (x[0+1] + x[1+1]) + 15 * (x[0+1] * 5 + x[1+1] * 3) + 7 * x[2+1] + 2 * x[3+1] + 100 - 3 * (x[5+1] - x[4+1] - (x[0+1] * 5 + x[1+1] * 3)) - 2 * (x[0+1] * 5 + x[1+1] * 3) ;
    OclFile["System.out"].println(score) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner stdIn=new Scanner(System.in);
    String S=stdIn.next();
    String T=stdIn.next();
    System.out.println(T+S);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := stdIn.getCurrent() ;
     var T : String ; T := stdIn.getCurrent() ;
     OclFile["System.out"].println(T + S) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S,T ;
    S=sc.next();
    T=sc.next();
    String ans=T+S ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ;
    var T : String ;
    S := sc.getCurrent() ; 
    T := sc.getCurrent() ; 
    var ans : String ; ans := T + S ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int getCount(int a,int b,int c){
    int count=0 ;
    for(int i=1 ; i<=81 ; i++){
      int cr=b*(int)Math.pow(i,a)+c ;
      int tmp=cr ;
      int sm=0 ;
      while(tmp!=0){
        sm+=tmp % 10 ;
        tmp/=10 ;
      }
      if(sm==i && cr<1e9)count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int a=3,b=2,c=8 ;
    System.out.println(getCount(a,b,c));
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation getCount( a : int, b : int, c : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i <= 81 do ( (     var cr : int ; cr := b * i->pow(a)->oclAsType(int) + c ;
     var tmp : int ; tmp := cr ;
    var sm : int ; sm := 0 ;
    while (tmp /= 0) do (     sm := sm+(tmp mod 10) ; 
     tmp := tmp/(10) ) ; 
    if (sm = i & cr < 1e9) then     count := count + 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var b : int ; b := 2 ;
    var c : int ; c := 8 ;
     OclFile["System.out"].println(getCount(a, b, c)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPowerOfK(int n,int k){
    boolean oneSeen=false ;
    while(n>0){
      int digit=n % k ;
      if(digit>1)return false ;
      if(digit==1){
        if(oneSeen)return false ;
        oneSeen=true ;
      }
      n/=k ;
    }
    return true ;
  }
  public static void main(String[] args){
    int n=64,k=4 ;
    if(isPowerOfK(n,k))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPowerOfK( n : int, k : int) : boolean
  pre: true
  post: true
  activity: (     var oneSeen : boolean ; oneSeen := false ;
     while (n > 0) do (     var digit : int ; digit := n mod k ;
     if (digit > 1) then     return false else skip ; 
     if (digit = 1) then (     if (oneSeen) then     return false else skip ; 
     oneSeen := true ) else skip ; 
     n := n/(k) ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 64 ;
    var k : int ; k := 4 ;
     if (isPowerOfK(n, k)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.*;
public class GFG {
  static int getOccurence(int n,int d){
    int result=0 ;
    int itr=d ;
    while(itr<=n){
      if(itr % 10==d)result++;
      if(itr!=0 && itr/10==d){
        result++;
        itr++;
      }
      else if(itr/10==d-1)itr=itr+(10-d);
      else itr=itr+10 ;
    }
    return result ;
  }
  public static void main(String[] args){
    int n=11,d=1 ;
    System.out.println(getOccurence(n,d));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getOccurence( n : int, d : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var itr : int ; itr := d ;
     while (itr <= n) do (     if (itr mod 10 = d) then     result := result + 1 ; else skip ; 
     if (itr /= 0 & itr / 10 = d) then (     result := result + 1 ; 
     itr := itr + 1 ) else     if (itr / 10 = d - 1) then     itr := itr + (10 - d) else     itr := itr + 10 ; ;  ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 11 ;
    var d : int ; d := 1 ;
     OclFile["System.out"].println(getOccurence(n, d)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
public class Main {
  static ArrayList<Integer>adjList[];
  static double ans[];
  static int cnt[];
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner();
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    adjList=new ArrayList[n];
    for(int i=0 ; i<n ; i++)adjList[i]=new ArrayList<>();
    for(int i=1 ; i<n ; i++)adjList[sc.nextInt()-1] .add(i);
    cnt=new int[n];
    preprocess(0);
    ans=new double[n];
    dfs(0,0);
    for(double x : ans)out.print(x+" ");
    out.flush();
    out.close();
  }
  static void dfs(int u,int p){
    if(u==0)ans[u]=1 ;
    else ans[u]=ans[p]+0.5*(1+cnt[p]-cnt[u]);
    for(int v : adjList[u])dfs(v,u);
  }
  static void preprocess(int u){
    cnt[u]=1 ;
    for(int v : adjList[u]){
      preprocess(v);
      cnt[u]+=cnt[v];
    }
  }
  static class Scanner {
    BufferedReader br ;
    StringTokenizer st ;
    Scanner(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute adjList : Sequence(Sequence(int));
  static   attribute ans : Sequence(double);
  static   attribute cnt : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := (arguments ( )) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    adjList := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do (     adjList[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do (     adjList[sc.getCurrent()->toInteger() - 1+1]->excludes(i) ;  ;     i := i + 1 ) ; 
    cnt := Integer.subrange(1,n)->collect(0) ; 
    execute preprocess(0) ; 
    ans := Integer.subrange(1,n)->collect(0.0) ; 
    execute dfs(0, 0) ; 
    for (x : ans) do (     skip ;  ) ; 
    skip ; 
    skip ; 
 );
  static   operation dfs( u : int, p : int) : void
  pre: true
  post: true
  activity: (     if (u = 0) then     ans[u+1] := 1 else     ans[u+1] := ans[p+1] + 0.5 * (1 + cnt[p+1] - cnt[u+1]) ; ;  
     for (v : adjList[u+1]) do (     execute dfs(v, u) ;  ) );
  static   operation preprocess( u : int) : void
  pre: true
  post: true
  activity: (     cnt[u+1] := 1 ; 
     for (v : adjList[u+1]) do ( (     execute preprocess(v) ; 
     cnt[u+1] := cnt[u+1]+(cnt[v+1]) )  ) );
  static class Scanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newScanner() : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter o=new PrintWriter(System.out);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int h=Math.min(n-k,k-1)+3*n ;
    o.println(h);
    o.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var o : OclFile ; o := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var h : int ; h := Set{n - k, k - 1}->min() + 3 * n ;
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
public final class p115 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p115().run());
  }
  private static final int M=50 ;
  public String run(){
    List<Long>ways=new ArrayList<>();
    ways.add(1L);
    for(int n=1 ; ; n++){
      long sum=ways.get(n-1);
      for(int k=M ; k<n ; k++)sum+=ways.get(n-k-1);
      if(n>=M)sum++;
      ways.add(sum);
      if(sum>1000000)return Long.toString(n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class p115 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p115.newp115().run()) );
  static    attribute M : int := 50;
   operation run() : String
  pre: true
  post: true
  activity: (     var ways : Sequence(long) ; ways := Sequence{} ;
     ways := ways->including(1L) ; 
         var n : int ; n := 1 ; while true do ( (     var sum : long ; sum := ways->at(n - 1+1) ;
         var k : int ; k := M ; while k < n do (     sum := sum+(ways->at(n - k - 1+1)) ;  ;     k := k + 1 ) ; 
    if (n >= M) then     sum := sum + 1 ; else skip ; 
    ways := ways->including(sum) ; 
    if (sum > 1000000) then     return ((n) + "") else skip ; 
 )  ;     n := n + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class Main {
  public static int inf=(int)1e9+7 ;
  public static void main(String[] args)throws IOException,InterruptedException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    for(int i=0 ; i<m ; i++){
      int l=sc.nextInt();
      int r=sc.nextInt();
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      if((i & 1)==0){
        sb.append("0");
      }
      else {
        sb.append("1");
      }
    }
    System.out.println(sb.toString());
    sc.close();
    writer.flush();
    writer.close();
    reader.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute inf : int := 1e9->oclAsType(int) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     if ((MathLib.bitwiseAnd(i,1)) = 0) then (     sb := sb + StringLib.newString("0") ) else (     sb := sb + StringLib.newString("1") ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Contest_yandexA {
  static final int MAXN=(int)1e6 ;
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int m=input.nextInt();
    for(int i=0 ; i<m ; i++){
      int l=input.nextInt();
      int r=input.nextInt();
    }
    for(int i=1 ; i<=n ; i++){
      System.out.print((i % 2)+"");
    }
  }
  public static long gcd(long a,long b){
    if(b==0){
      return a ;
    }
    return gcd(b,a % b);
  }
}
class Pair implements Comparable<Pair>{
  int x ;
  int w ;
  int idx ;
  Pair(int x,int w,int idx){
    this.x=x ;
    this.w=w ;
    this.idx=idx ;
  }
  @ Override public int compareTo(Pair p){
    return this.w-p.w ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Contest_yandexA {
  static    attribute MAXN : int := 1e6->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var m : int ; m := input.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     var l : int ; l := input.getCurrent()->toInteger() ;
     var r : int ; r := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].print((i mod 2) + "") )  ;     i := i + 1 ) ; 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else skip ; 
     return gcd(b, a mod b) );
}
class Pair implements Comparable<Map> {
   attribute x : int;
   attribute w : int;
   attribute idx : int;
   static operation newPair( x : int, w : int, idx : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, w,idx);
    return self );
  operation initialise( x : int, w : int, idx : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.w := w ; 
     self.idx := idx );
      operation compareTo( p : Map) : int
  pre: true
  post: true
  activity: (     return self.w - p.w );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ColoredBalls {
  public static int mod=1000000007 ;
  public static int MAXN=1010 ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out,true);
    long[][] comb=new long[MAXN][MAXN];
    comb[0][0]=1 ;
    for(int i=1 ; i<MAXN ; i++){
      comb[i][0]=1 ;
      for(int j=1 ; j<=i ; j++){
        comb[i][j]=(comb[i-1][j]+comb[i-1][j-1])% mod ;
      }
    }
    int K=in.nextInt();
    int[] color=new int[K];
    for(int i=0 ; i<K ; i++)color[i]=in.nextInt();
    long res=1 ;
    int total=0 ;
    for(int i=0 ; i<K ; i++){
      res=(res*comb[total+color[i]-1][color[i]-1])% mod ;
      total+=color[i];
    }
    out.println(res);
    out.close();
    System.exit(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ColoredBalls {
  static   attribute mod : int := 1000000007;
  static   attribute MAXN : int := 1010;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"], true) ;
    var comb : Sequence(Sequence(long)) ; comb := Integer.subrange(1,MAXN)->collect(Integer.subrange(1,MAXN)->collect(0)) ;
    comb[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i < MAXN do ( (     comb[i+1][0+1] := 1 ; 
         var j : int ; j := 1 ; while j <= i do ( (     comb[i+1][j+1] := (comb[i - 1+1][j+1] + comb[i - 1+1][j - 1+1]) mod mod )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var K : int ; K := in.getCurrent()->toInteger() ;
    var color : Sequence(int) ; color := Integer.subrange(1,K)->collect(0) ;
        var i : int ; i := 0 ; while i < K do (     color[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var res : long ; res := 1 ;
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < K do ( (     res := (res * comb[total + color[i+1] - 1+1][color[i+1] - 1+1]) mod mod ; 
     total := total+(color[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
OclProcess.exit(0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int N=in.nextInt();
    ArrayList<Integer>ans=new ArrayList<>();
    for(int n=0 ; n<N ; n++){
      ans.add(n % 2);
    }
    for(int i : ans)pw.print(i);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var ans : Sequence(int) ; ans := Sequence{} ;
        var n : int ; n := 0 ; while n < N do ( (     ans := ans->including(n mod 2) )  ;     n := n + 1 ) ; 
    for (i : ans) do (     skip ;  ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int getHermiteNumber(int n){
    if(n==0)return 1 ;
    else if(n==1)return 1 ;
    else return-2*(n-1)*getHermiteNumber(n-2);
  }
  public static void main(String[] args){
    int n=6 ;
    System.out.println(getHermiteNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getHermiteNumber( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else     if (n = 1) then     return 1 else     return -2 * (n - 1) * getHermiteNumber(n - 2) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(getHermiteNumber(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static void printPowerSet(char[] set,int set_size){
    long pow_set_size=(long)Math.pow(2,set_size);
    int counter,j ;
    for(counter=0 ; counter<pow_set_size ; counter++){
      for(j=0 ; j<set_size ; j++){
        if((counter &(1<<j))>0)System.out.print(set[j]);
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    char[] set={
      'a','b','c' };
      printPowerSet(set,3);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printPowerSet( set : Sequence(String), set_size : int) : void
  pre: true
  post: true
  activity: (     var pow_set_size : long ; pow_set_size := 2->pow(set_size)->oclAsType(long) ;
     var counter : int ;
    var j : int ;
         counter := 0 ; while counter < pow_set_size do ( (         j := 0 ; while j < set_size do ( (     if ((MathLib.bitwiseAnd(counter,((1*(2->pow(j)))->oclAsType(long)))) > 0) then     OclFile["System.out"].print(set[j+1]) ; else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     counter := counter + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var set : Sequence(String) ; set := Sequence{'a','b','c'} ;
     execute printPowerSet(set, 3) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int t=k ;
    if(t<=2*(n-2)){
      System.out.println("YES");
      for(int i=0 ; i<4 ; i++){
        for(int j=0 ; j<n ; j++){
          if(i==0 || i==3 || j==0 || j==n-1 || k==0)System.out.print(".");
          else if(k>=n-2){
            k--;
            System.out.print("#");
          }
          else {
            if(t % 2==1 && j==(n/2)&& k!=0){
              k--;
              System.out.print("#");
            }
            else if(j<=t/2 && k!=0){
              k--;
              System.out.print("#");
            }
            else if(j>=(n-(t/2)-1)&& k!=0){
              k--;
              System.out.print("#");
            }
            else System.out.print(".");
          }
        }
        t=k ;
        System.out.println();
      }
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var t : int ; t := k ;
    if (t <= 2 * (n - 2)) then (     OclFile["System.out"].println("YES") ; 
         var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < n do ( (     if (i = 0 or i = 3 or j = 0 or j = n - 1 or k = 0) then     OclFile["System.out"].print(".") ; else     if (k >= n - 2) then (     k := k - 1 ; 
     OclFile["System.out"].print("#") ) else (     if (t mod 2 = 1 & j = (n / 2) & k /= 0) then (     k := k - 1 ; 
     OclFile["System.out"].print("#") ) else     if (j <= t / 2 & k /= 0) then (     k := k - 1 ; 
     OclFile["System.out"].print("#") ) else     if (j >= (n - (t / 2) - 1) & k /= 0) then (     k := k - 1 ; 
     OclFile["System.out"].print("#") ) else     OclFile["System.out"].print(".") ; ;  ;  ) ;  )  ;     j := j + 1 ) ; 
     t := k ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ) else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javafx.util.Pair ;
import java.util.*;
import java.io.*;
public class marlin {
  public static void main(String[] args){
    Scanner ps=new Scanner(System.in);
    int n=ps.nextInt();
    int k=ps.nextInt();
    System.out.println("YES");
    for(int i=0 ; i<4 ; i++){
      if(i==0 || i==3){
        for(int j=0 ; j<n ; j++){
          System.out.print(".");
        }
      }
      else {
        Set<Integer>colPts=createSymmetry(k,n);
        k-=colPts.size();
        for(int j=0 ; j<n ; j++){
          if(colPts.contains(j)){
            System.out.print("#");
          }
          else {
            System.out.print(".");
          }
        }
      }
      System.out.println();
    }
  }
  public static Set<Integer>createSymmetry(int hotels,int n){
    Set<Integer>colPts=new HashSet<>();
    if(hotels % 2!=0){
      colPts.add(n/2);
--hotels ;
    }
    int leftSide=1 ;
    int rightSide=(n-(leftSide+1));
    while(hotels>0 && leftSide<=rightSide){
      colPts.add(leftSide);
      colPts.add(rightSide);
      rightSide=(n-(++leftSide+1));
      hotels-=2 ;
    }
    return colPts ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class marlin {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ps : OclFile ; ps := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := ps.getCurrent()->toInteger() ;
    var k : int ; k := ps.getCurrent()->toInteger() ;
    OclFile["System.out"].println("YES") ; 
        var i : int ; i := 0 ; while i < 4 do ( (     if (i = 0 or i = 3) then (         var j : int ; j := 0 ; while j < n do ( (     OclFile["System.out"].print(".") )  ;     j := j + 1 ) ) else (     var colPts : Set(int) ; colPts := createSymmetry(k, n) ;
     k := k-(colPts->size()) ; 
         var j : int ; j := 0 ; while j < n do ( (     if (colPts->includes(j)) then (     OclFile["System.out"].print("#") ) else (     OclFile["System.out"].print(".") ) )  ;     j := j + 1 ) ) ;  
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
  static   operation createSymmetry( hotels : int, n : int) : Set(int)
  pre: true
  post: true
  activity: (     var colPts : Set(int) ; colPts := Set{} ;
     if (hotels mod 2 /= 0) then (     colPts := colPts->including(n / 2) ; 
     hotels := hotels - 1 ) else skip ; 
    var leftSide : int ; leftSide := 1 ;
    var rightSide : int ; rightSide := (n - (leftSide + 1)) ;
    while (hotels > 0 & leftSide <= rightSide) do (     colPts := colPts->including(leftSide) ; 
     colPts := colPts->including(rightSide) ; 
         leftSide := leftSide + 1 ;
 rightSide := (n - (leftSide + 1))  ; 
     hotels := hotels-(2) ) ; 
    return colPts 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int K=scan.nextInt();
    printHotels(N,K);
  }
  public static void printHotels(int N,int k){
    StringBuilder sb=new StringBuilder();
    char[][] grid=new char[4][N];
    for(char[] arr : grid){
      Arrays.fill(arr,'.');
    }
    if(k % 2==0){
      k/=2 ;
      for(int i=1 ; i<=k ; i++){
        grid[1][i]='#' ;
        grid[2][i]='#' ;
      }
    }
    else {
      grid[1][N/2]='#' ;
      k--;
      int r=1 ;
      int diff=1 ;
      int mid=N/2 ;
      while(k>0){
        grid[r][mid-diff]='#' ;
        grid[r][mid+diff]='#' ;
        k-=2 ;
        diff++;
        if(diff==mid){
          diff=1 ;
          r=2 ;
        }
      }
    }
    sb.append("YES").append("\n");
    for(int i=0 ; i<4 ; i++){
      for(int j=0 ; j<N ; j++){
        sb.append(grid[i][j]);
      }
      sb.append("\n");
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
     var K : int ; K := scan.getCurrent()->toInteger() ;
     execute printHotels(N, K) );
  static   operation printHotels( N : int, k : int) : void
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     var grid : Sequence(Sequence(String)) ; grid := Integer.subrange(1,4)->collect(Integer.subrange(1,N)->collect(0)) ;
    for (arr : grid) do ( (     arr := arr->collect('.') )  ) ; 
    if (k mod 2 = 0) then (     k := k/(2) ; 
         var i : int ; i := 1 ; while i <= k do ( (     grid[1+1][i+1] := '#' ; 
     grid[2+1][i+1] := '#' )  ;     i := i + 1 ) ) else (     grid[1+1][N / 2+1] := '#' ; 
     k := k - 1 ; 
    var r : int ; r := 1 ;
    var diff : int ; diff := 1 ;
    var mid : int ; mid := N / 2 ;
    while (k > 0) do (     grid[r+1][mid - diff+1] := '#' ; 
     grid[r+1][mid + diff+1] := '#' ; 
    k := k-(2) ; 
    diff := diff + 1 ; 
    if (diff = mid) then (     diff := 1 ; 
     r := 2 ) else skip ; 
 ) ; 
 ) ;  
    sb := sb + StringLib.newString("YES") + StringLib.newString("\n") ; 
        var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < N do ( (     sb := sb + StringLib.newString(grid[i+1][j+1]) )  ;     j := j + 1 ) ; 
     sb := sb + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    StringTokenizer inputString=new StringTokenizer(reader.readLine());
    int t=Integer.parseInt(inputString.nextToken());
    while(t>0){
      StringTokenizer inputString2=new StringTokenizer(reader.readLine());
      long n=Long.parseLong(inputString2.nextToken());
      long m=Long.parseLong(inputString2.nextToken());
      long x=Long.parseLong(inputString2.nextToken());
      long result ;
      long y=x/n ;
      long z=x % n ;
      if(z==0){
        z=n-1 ;
      }
      else {
        z=z-1 ;
        y++;
      }
      if(m==1 || n==1){
        result=x ;
      }
      else {
        result=y+z*m ;
      }
      out.println(result);
      t--;
    }
    reader.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var inputString : OclIterator ; inputString := OclIterator.newOclIterator_String(reader.readLine()) ;
    var t : int ; t := (inputString.next())->toInteger() ;
    while (t > 0) do (     var inputString2 : OclIterator ; inputString2 := OclIterator.newOclIterator_String(reader.readLine()) ;
     var n : long ; n := (inputString2.next())->toLong() ;
    var m : long ; m := (inputString2.next())->toLong() ;
    var x : long ; x := (inputString2.next())->toLong() ;
    var result : long ;
    var y : long ; y := x / n ;
    var z : long ; z := x mod n ;
    if (z = 0) then (     z := n - 1 ) else (     z := z - 1 ; 
     y := y + 1 ) ;  
    if (m = 1 or n = 1) then (     result := x ) else (     result := y + z * m ) ;  
    skip ; 
    t := t - 1 ; 
 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      long x=sc.nextLong();
      long y=sc.nextLong();
      long k=sc.nextLong();
      long g=0 ;
      if((k*(y+1)-1)%(x-1)!=0){
        g++;
      }
      g+=(k*(y+1)-1)/(x-1)+k ;
      out.println(g);
    }
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var x : long ; x := sc.getCurrent()->toLong() ;
     var y : long ; y := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var g : long ; g := 0 ;
    if ((k * (y + 1) - 1) mod (x - 1) /= 0) then (     g := g + 1 ) else skip ; 
    g := g+((k * (y + 1) - 1) / (x - 1) + k) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Question4 {
  public static void main(String[] args){
    int t ;
    long n,m,x ;
    Scanner sc=new Scanner(System.in);
    t=sc.nextInt();
    while(t-->0){
      n=sc.nextLong();
      m=sc.nextLong();
      x=sc.nextLong();
      long col=0,row=0 ;
      if(x % n!=0){
        col=x/n+1 ;
        row=x-n*(x/n);
      }
      else {
        col=x/n ;
        row=n ;
      }
      long num=(row-1)*m+col ;
      System.out.println(num);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Question4 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ;
     var n : long ;
    var m : long ;
    var x : long ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    t := sc.getCurrent()->toInteger() ; 
        while (t > 0) do (        t := t - 1 ;     skip ; (     n := sc.getCurrent()->toLong() ; 
     m := sc.getCurrent()->toLong() ; 
    x := sc.getCurrent()->toLong() ; 
    var col : long ; col := 0 ;
    var row : long ; row := 0 ;
    if (x mod n /= 0) then (     col := x / n + 1 ; 
     row := x - n * (x / n) ) else (     col := x / n ; 
     row := n ) ;  
    var num : long ; num := (row - 1) * m + col ;
    OclFile["System.out"].println(num) ; 
 ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class StrangeTable {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test_cases=sc.nextInt();
    while(test_cases-->0){
      long rows=sc.nextLong();
      long cols=sc.nextLong();
      long x=sc.nextLong();
      long col_pos=(x-1)/rows ;
      long row_pos=(x-1)% rows ;
      long ans=(cols*row_pos)+(col_pos+1);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class StrangeTable {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test_cases : int ; test_cases := sc.getCurrent()->toInteger() ;
         while (test_cases > 0) do (        test_cases := test_cases - 1 ;     skip ; (     var rows : long ; rows := sc.getCurrent()->toLong() ;
     var cols : long ; cols := sc.getCurrent()->toLong() ;
    var x : long ; x := sc.getCurrent()->toLong() ;
    var col_pos : long ; col_pos := (x - 1) / rows ;
    var row_pos : long ; row_pos := (x - 1) mod rows ;
    var ans : long ; ans := (cols * row_pos) + (col_pos + 1) ;
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      @ SuppressWarnings("unused")int n=scanner.nextInt(),z=scanner.nextInt(),w=scanner.nextInt();
      int[] a=IntStream.range(0,n).map(i->scanner.nextInt()).toArray();
      if(1==n){
        System.out.println(Math.abs(a[n-1]-w));
      }
      else {
        System.out.println(Math.max(Math.abs(a[n-1]-w),Math.abs(a[n-1]-a[n-2])));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var z : int ; z := scanner.getCurrent()->toInteger() ;
    var w : int ; w := scanner.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(0, n-1)->collect( _x1 | (lambda i : OclAny in scanner.getCurrent()->toInteger())->apply(_x1) )->asSequence() ;
     if (1 = n) then (     OclFile["System.out"].println(if a[n - 1+1] - w < 0 then -(a[n - 1+1] - w) else a[n - 1+1] - w endif) ) else (     OclFile["System.out"].println(Set{if a[n - 1+1] - w < 0 then -(a[n - 1+1] - w) else a[n - 1+1] - w endif, if a[n - 1+1] - a[n - 2+1] < 0 then -(a[n - 1+1] - a[n - 2+1]) else a[n - 1+1] - a[n - 2+1] endif}->max()) ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n>0){
      int x=sc.nextInt();
      int y=sc.nextInt();
      long z=sc.nextLong();
      long k=0,j=0 ;
      k=(z-1)/x ;
      j=(z-1)% x ;
      long ans=0 ;
      k++;
      ans=(j*y)+k ;
      System.out.println(ans);
      n--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     while (n > 0) do (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var z : long ; z := sc.getCurrent()->toLong() ;
    var k : long ; k := 0 ;
    var j : long ; j := 0 ;
    k := (z - 1) / x ; 
    j := (z - 1) mod x ; 
    var ans : long ; ans := 0 ;
    k := k + 1 ; 
    ans := (j * y) + k ; 
    OclFile["System.out"].println(ans) ; 
    n := n - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test200 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      long a=in.nextLong();
      long b=in.nextLong();
      long c=in.nextLong();
      long k=(c-1)/a+1 ;
      long l=c % a-1 ;
      if(l==-1){
        l+=a ;
      }
      System.out.println((l*b)+k);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test200 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var a : long ; a := in.getCurrent()->toLong() ;
     var b : long ; b := in.getCurrent()->toLong() ;
    var c : long ; c := in.getCurrent()->toLong() ;
    var k : long ; k := (c - 1) / a + 1 ;
    var l : long ; l := c mod a - 1 ;
    if (l = -1) then (     l := l+(a) ) else skip ; 
    OclFile["System.out"].println((l * b) + k) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static int N,K ;
  private static int[][] cum ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    K=sc.nextInt();
    cum=new int[2*K+1][2*K+1];
    for(int i=0 ; i<N ; i++){
      int x=sc.nextInt()%(2*K);
      int y=sc.nextInt()%(2*K);
      String c=sc.next();
      if(c.equals("B")){
        x=(x+K)%(2*K);
      }
      cum[y+1][x+1]++;
    }
    for(int y=0 ; y<2*K ; y++){
      for(int x=0 ; x<2*K ; x++){
        cum[y+1][x+1]+=cum[y][x+1]+cum[y+1][x]-cum[y][x];
      }
    }
    int ans=0 ;
    for(int y=0 ; y<=K ; y++){
      for(int x=0 ; x<=K ; x++){
        int tmp=count(0,0,x,y)+count(x+K,0,2*K,y)+count(x,y,x+K,y+K)+count(0,y+K,x,2*K)+count(x+K,y+K,2*K,2*K);
        ans=Math.max(ans,Math.max(tmp,N-tmp));
      }
    }
    System.out.println(ans);
  }
  private static int count(int x1,int y1,int x2,int y2){
    return cum[y2][x2]-cum[y1][x2]-cum[y2][x1]+cum[y1][x1];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute cum : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
    K := sc.getCurrent()->toInteger() ; 
    cum := Integer.subrange(1,2 * K + 1)->collect(Integer.subrange(1,2 * K + 1)->collect(0)) ; 
        var i : int ; i := 0 ; while i < N do ( (     var x : int ; x := sc.getCurrent()->toInteger() mod (2 * K) ;
     var y : int ; y := sc.getCurrent()->toInteger() mod (2 * K) ;
    var c : String ; c := sc.getCurrent() ;
    if (c = "B") then (     x := (x + K) mod (2 * K) ) else skip ; 
    cum[y + 1+1][x + 1+1] := cum[y + 1+1][x + 1+1] + 1 ; 
 )  ;     i := i + 1 ) ; 
        var y : int ; y := 0 ; while y < 2 * K do ( (         var x : int ; x := 0 ; while x < 2 * K do ( (     cum[y + 1+1][x + 1+1] := cum[y + 1+1][x + 1+1]+(cum[y+1][x + 1+1] + cum[y + 1+1][x+1] - cum[y+1][x+1]) )  ;     x := x + 1 ) )  ;     y := y + 1 ) ; 
    var ans : int ; ans := 0 ;
        var y : int ; y := 0 ; while y <= K do ( (         var x : int ; x := 0 ; while x <= K do ( (     var tmp : int ; tmp := count(0, 0, x, y) + count(x + K, 0, 2 * K, y) + count(x, y, x + K, y + K) + count(0, y + K, x, 2 * K) + count(x + K, y + K, 2 * K, 2 * K) ;
     ans := Set{ans, Set{tmp, N - tmp}->max()}->max() )  ;     x := x + 1 ) )  ;     y := y + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation count( x1 : int, y1 : int, x2 : int, y2 : int) : int
  pre: true
  post: true
  activity: (     return cum[y2+1][x2+1] - cum[y1+1][x2+1] - cum[y2+1][x1+1] + cum[y1+1][x1+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    double[] p=new double[n+1];
    double[] q=new double[n+1];
    for(int i=1 ; i<=n ; i++){
      p[i]=input.nextDouble();
    }
    for(int i=0 ; i<=n ; i++){
      q[i]=input.nextDouble();
    }
    System.out.println(getMinCost(n,p,q));
  }
  private static double getMinCost(int n,double[] p,double[] q){
    double[][] e=new double[n+2][n+1];
    double[][] w=new double[n+2][n+1];
    for(int i=0 ; i<=n ; i++){
      e[i+1][i]=q[i];
      w[i+1][i]=q[i];
    }
    for(int l=1 ; l<=n ; l++){
      for(int i=1 ; i<=n-l+1 ; i++){
        int j=i+l-1 ;
        e[i][j]=Double.MAX_VALUE ;
        w[i][j]=w[i][j-1]+p[j]+q[j];
        for(int k=i ; k<=j ; k++){
          e[i][j]=Math.min(e[i][j],e[i][k-1]+e[k+1][j]+w[i][j]);
        }
      }
    }
    return e[1][n];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var p : Sequence(double) ; p := Integer.subrange(1,n + 1)->collect(0.0) ;
    var q : Sequence(double) ; q := Integer.subrange(1,n + 1)->collect(0.0) ;
        var i : int ; i := 1 ; while i <= n do ( (     p[i+1] := input.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= n do ( (     q[i+1] := input.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(getMinCost(n, p, q)) ; 
 );
  static   operation getMinCost( n : int, p : Sequence(double), q : Sequence(double)) : double
  pre: true
  post: true
  activity: (     var e : Sequence(Sequence(double)) ; e := Integer.subrange(1,n + 2)->collect(Integer.subrange(1,n + 1)->collect(0.0)) ;
     var w : Sequence(Sequence(double)) ; w := Integer.subrange(1,n + 2)->collect(Integer.subrange(1,n + 1)->collect(0.0)) ;
        var i : int ; i := 0 ; while i <= n do ( (     e[i + 1+1][i+1] := q[i+1] ; 
     w[i + 1+1][i+1] := q[i+1] )  ;     i := i + 1 ) ; 
        var l : int ; l := 1 ; while l <= n do ( (         var i : int ; i := 1 ; while i <= n - l + 1 do ( (     var j : int ; j := i + l - 1 ;
     e[i+1][j+1] := (2 - 2->pow(-52))*(2->pow(1023)) ; 
     w[i+1][j+1] := w[i+1][j - 1+1] + p[j+1] + q[j+1] ; 
         var k : int ; k := i ; while k <= j do ( (     e[i+1][j+1] := Set{e[i+1][j+1], e[i+1][k - 1+1] + e[k + 1+1][j+1] + w[i+1][j+1]}->min() )  ;     k := k + 1 ) )  ;     i := i + 1 ) )  ;     l := l + 1 ) ; 
    return e[1+1][n+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static double[] p ;
  private static double[] q ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    p=new double[n+1];
    q=new double[n+1];
    for(int i=1 ; i<=n ; i++){
      p[i]=in.nextDouble();
    }
    for(int i=0 ; i<=n ; i++){
      q[i]=in.nextDouble();
    }
    System.out.println(minimumCost());
  }
  private static double minimumCost(){
    int n=p.length-1 ;
    double[][] weight=new double[n+2][n+1];
    double[][] cost=new double[n+2][n+1];
    for(int i=1 ; i<=n+1 ; i++){
      weight[i][i-1]=q[i-1];
      cost[i][i-1]=q[i-1];
    }
    for(int size=1 ; size<=n ; size++){
      for(int i=1 ; i<=n-size+1 ; i++){
        int j=i+size-1 ;
        cost[i][j]=Double.MAX_VALUE ;
        weight[i][j]=weight[i][j-1]+p[j]+q[j];
        for(int r=i ; r<=j ; r++){
          double testCost=cost[i][r-1]+cost[r+1][j]+weight[i][j];
          if(testCost<cost[i][j]){
            cost[i][j]=testCost ;
          }
        }
      }
    }
    return cost[1][n];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute p : Sequence(double);
  static   attribute q : Sequence(double);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    p := Integer.subrange(1,n + 1)->collect(0.0) ; 
    q := Integer.subrange(1,n + 1)->collect(0.0) ; 
        var i : int ; i := 1 ; while i <= n do ( (     p[i+1] := in.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= n do ( (     q[i+1] := in.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(minimumCost()) ; 
 );
  static   operation minimumCost() : double
  pre: true
  post: true
  activity: (     var n : int ; n := p->size() - 1 ;
     var weight : Sequence(Sequence(double)) ; weight := Integer.subrange(1,n + 2)->collect(Integer.subrange(1,n + 1)->collect(0.0)) ;
    var cost : Sequence(Sequence(double)) ; cost := Integer.subrange(1,n + 2)->collect(Integer.subrange(1,n + 1)->collect(0.0)) ;
        var i : int ; i := 1 ; while i <= n + 1 do ( (     weight[i+1][i - 1+1] := q[i - 1+1] ; 
     cost[i+1][i - 1+1] := q[i - 1+1] )  ;     i := i + 1 ) ; 
        var size : int ; size := 1 ; while size <= n do ( (         var i : int ; i := 1 ; while i <= n - size + 1 do ( (     var j : int ; j := i + size - 1 ;
     cost[i+1][j+1] := (2 - 2->pow(-52))*(2->pow(1023)) ; 
     weight[i+1][j+1] := weight[i+1][j - 1+1] + p[j+1] + q[j+1] ; 
         var r : int ; r := i ; while r <= j do ( (     var testCost : double ; testCost := cost[i+1][r - 1+1] + cost[r + 1+1][j+1] + weight[i+1][j+1] ;
     if (testCost < cost[i+1][j+1]) then (     cost[i+1][j+1] := testCost ) else skip )  ;     r := r + 1 ) )  ;     i := i + 1 ) )  ;     size := size + 1 ) ; 
    return cost[1+1][n+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static double[] p ;
  private static double[] q ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    p=new double[n+1];
    q=new double[n+1];
    for(int i=1 ; i<=n ; i++){
      p[i]=in.nextDouble();
    }
    for(int i=0 ; i<=n ; i++){
      q[i]=in.nextDouble();
    }
    System.out.println(minimumCost());
  }
  private static double minimumCost(){
    int n=p.length-1 ;
    double[][] weight=new double[n+2][n+1];
    double[][] cost=new double[n+2][n+1];
    for(int i=1 ; i<=n+1 ; i++){
      weight[i][i-1]=q[i-1];
      cost[i][i-1]=q[i-1];
    }
    for(int size=1 ; size<=n ; size++){
      for(int i=1 ; i<=n-size+1 ; i++){
        int j=i+size-1 ;
        cost[i][j]=Double.MAX_VALUE ;
        weight[i][j]=weight[i][j-1]+p[j]+q[j];
        for(int r=i ; r<=j ; r++){
          double testCost=cost[i][r-1]+cost[r+1][j]+weight[i][j];
          if(testCost<cost[i][j]){
            cost[i][j]=testCost ;
          }
        }
      }
    }
    return cost[1][n];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute p : Sequence(double);
  static   attribute q : Sequence(double);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    p := Integer.subrange(1,n + 1)->collect(0.0) ; 
    q := Integer.subrange(1,n + 1)->collect(0.0) ; 
        var i : int ; i := 1 ; while i <= n do ( (     p[i+1] := in.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= n do ( (     q[i+1] := in.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(minimumCost()) ; 
 );
  static   operation minimumCost() : double
  pre: true
  post: true
  activity: (     var n : int ; n := p->size() - 1 ;
     var weight : Sequence(Sequence(double)) ; weight := Integer.subrange(1,n + 2)->collect(Integer.subrange(1,n + 1)->collect(0.0)) ;
    var cost : Sequence(Sequence(double)) ; cost := Integer.subrange(1,n + 2)->collect(Integer.subrange(1,n + 1)->collect(0.0)) ;
        var i : int ; i := 1 ; while i <= n + 1 do ( (     weight[i+1][i - 1+1] := q[i - 1+1] ; 
     cost[i+1][i - 1+1] := q[i - 1+1] )  ;     i := i + 1 ) ; 
        var size : int ; size := 1 ; while size <= n do ( (         var i : int ; i := 1 ; while i <= n - size + 1 do ( (     var j : int ; j := i + size - 1 ;
     cost[i+1][j+1] := (2 - 2->pow(-52))*(2->pow(1023)) ; 
     weight[i+1][j+1] := weight[i+1][j - 1+1] + p[j+1] + q[j+1] ; 
         var r : int ; r := i ; while r <= j do ( (     var testCost : double ; testCost := cost[i+1][r - 1+1] + cost[r + 1+1][j+1] + weight[i+1][j+1] ;
     if (testCost < cost[i+1][j+1]) then (     cost[i+1][j+1] := testCost ) else skip )  ;     r := r + 1 ) )  ;     i := i + 1 ) )  ;     size := size + 1 ) ; 
    return cost[1+1][n+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int leastValue(int P,int A,int N,int a[]){
    int ans=-1 ;
    float tmp=Float.MAX_VALUE ;
    for(int i=0 ; i<N ; i++){
      float t=(float)(P-a[i]*0.006);
      if(Math.abs(t-A)<tmp){
        tmp=Math.abs(t-A);
        ans=i ;
      }
    }
    return a[ans];
  }
  public static void main(String[] args){
    int N=2,P=12,A=2005 ;
    int a[]={
      1000,2000 };
      System.out.println(leastValue(P,A,N,a));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation leastValue( P : int, A : int, N : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := -1 ;
     var tmp : double ; tmp := 3.4028234663852886*(10->pow(38)) ;
         var i : int ; i := 0 ; while i < N do ( (     var t : double ; t := (P - a[i+1] * 0.006)->oclAsType(double) ;
     if (if t - A < 0 then -(t - A) else t - A endif < tmp) then (     tmp := if t - A < 0 then -(t - A) else t - A endif ; 
     ans := i ) else skip )  ;     i := i + 1 ) ; 
     return a[ans+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 2 ;
    var P : int ; P := 12 ;
    var A : int ; A := 2005 ;
     var a : Sequence(int) ; a := Sequence{1000,2000} ;
     OclFile["System.out"].println(leastValue(P, A, N, a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    String given=scn.next();
    int count=0 ;
    int count2=0 ;
    for(int i=0 ; i<given.length(); i++){
      if(given.charAt(i)=='1'){
        count2++;
        count=0 ;
        for(int j=i ; j<given.length(); j++){
          if(given.charAt(j)=='0')count++;
        }
        if(count>=6){
          System.out.println("yes");
          break ;
        }
        else {
          System.out.println("no");
          break ;
        }
      }
    }
    if(count2==0){
      System.out.println("no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var given : String ; given := scn.getCurrent() ;
    var count : int ; count := 0 ;
    var count2 : int ; count2 := 0 ;
        var i : int ; i := 0 ; while i < given->size() do ( (     if (given->at(i+1) = '1') then (     count2 := count2 + 1 ; 
     count := 0 ; 
         var j : int ; j := i ; while j < given->size() do ( (     if (given->at(j+1) = '0') then     count := count + 1 ; else skip )  ;     j := j + 1 ) ; 
     if (count >= 6) then (     OclFile["System.out"].println("yes") ; 
     break ) else (     OclFile["System.out"].println("no") ; 
     break ) ) else skip )  ;     i := i + 1 ) ; 
    if (count2 = 0) then (     OclFile["System.out"].println("no") ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void printAllAPTriplets(int[] arr,int n){
    ArrayList<Integer>s=new ArrayList<Integer>();
    for(int i=0 ; i<n-1 ; i++){
      for(int j=i+1 ; j<n ; j++){
        int diff=arr[j]-arr[i];
        boolean exists=s.contains(arr[i]-diff);
        if(exists)System.out.println(arr[i]-diff+" "+arr[i]+" "+arr[j]);
      }
      s.add(arr[i]);
    }
  }
  public static void main(String args[]){
    int[] arr={
      2,6,9,12,17,22,31,32,35,42 };
      int n=arr.length ;
      printAllAPTriplets(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printAllAPTriplets( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var s : Sequence(int) ; s := Sequence{} ;
         var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var diff : int ; diff := arr[j+1] - arr[i+1] ;
     var exists : boolean ; exists := s->includes(arr[i+1] - diff) ;
     if (exists) then     OclFile["System.out"].println(arr[i+1] - diff + " " + arr[i+1] + " " + arr[j+1]) ; else skip )  ;     j := j + 1 ) ; 
     s := s->including(arr[i+1]) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,6,9,12,17,22,31,32,35,42} ;
     var n : int ; n := arr->size() ;
     execute printAllAPTriplets(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAX=100 ;
  static int binomialCoeff(int n,int k){
    int C[]=new int[k+1];
    C[0]=1 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=Math.min(i,k); j>0 ; j--)C[j]=C[j]+C[j-1];
    }
    return C[k];
  }
  static int sumOfproduct(int n){
    return binomialCoeff(2*n,n-1);
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(sumOfproduct(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100;
  static   operation binomialCoeff( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var C : Sequence(int) ; C := Integer.subrange(1,k + 1)->collect(0) ;
     C[0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := Set{i, k}->min() ; while j > 0 do (     C[j+1] := C[j+1] + C[j - 1+1] ;  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
     return C[k+1] );
  static   operation sumOfproduct( n : int) : int
  pre: true
  post: true
  activity: (     return binomialCoeff(2 * n, n - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(sumOfproduct(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ColoredBalls {
  public static int mod=1000000007 ;
  public static int MAXN=1010 ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out,true);
    long[][] comb=new long[MAXN][MAXN];
    comb[0][0]=1 ;
    for(int i=1 ; i<MAXN ; i++){
      comb[i][0]=1 ;
      for(int j=1 ; j<=i ; j++){
        comb[i][j]=(comb[i-1][j]+comb[i-1][j-1])% mod ;
      }
    }
    int K=in.nextInt();
    int[] color=new int[K];
    for(int i=0 ; i<K ; i++)color[i]=in.nextInt();
    long res=1 ;
    int total=0 ;
    for(int i=0 ; i<K ; i++){
      res=(res*comb[total+color[i]-1][color[i]-1])% mod ;
      total+=color[i];
    }
    out.println(res);
    out.close();
    System.exit(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ColoredBalls {
  static   attribute mod : int := 1000000007;
  static   attribute MAXN : int := 1010;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"], true) ;
    var comb : Sequence(Sequence(long)) ; comb := Integer.subrange(1,MAXN)->collect(Integer.subrange(1,MAXN)->collect(0)) ;
    comb[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i < MAXN do ( (     comb[i+1][0+1] := 1 ; 
         var j : int ; j := 1 ; while j <= i do ( (     comb[i+1][j+1] := (comb[i - 1+1][j+1] + comb[i - 1+1][j - 1+1]) mod mod )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var K : int ; K := in.getCurrent()->toInteger() ;
    var color : Sequence(int) ; color := Integer.subrange(1,K)->collect(0) ;
        var i : int ; i := 0 ; while i < K do (     color[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var res : long ; res := 1 ;
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < K do ( (     res := (res * comb[total + color[i+1] - 1+1][color[i+1] - 1+1]) mod mod ; 
     total := total+(color[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
OclProcess.exit(0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      long z=input.nextLong();
      long a[]=new long[n];
      long max=Long.MIN_VALUE ;
      for(int i=0 ; i<n ; i++){
        a[i]=input.nextLong();
        max=Math.max(max,a[i] | z);
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := input.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.getCurrent()->toInteger() ;
     var z : long ; z := input.getCurrent()->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var max : long ; max := "-9223372036854775808"->toLong() ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.getCurrent()->toLong() ; 
     max := Set{max, a[i+1] or z}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      long n=sc.nextInt();
      long z=sc.nextInt();
      long max=0 ;
      for(int i=0 ; i<n ; i++){
        max=Math.max(max,sc.nextInt()| z);
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : long ; n := sc.getCurrent()->toInteger() ;
     var z : long ; z := sc.getCurrent()->toInteger() ;
    var max : long ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     max := Set{max, sc.getCurrent()->toInteger() or z}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewClass_A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0){
      int n=sc.nextInt();
      long z=sc.nextLong();
      long arr[]=new long[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextLong();
      }
      long max=Long.MIN_VALUE ;
      for(int i=0 ; i<n ; i++){
        max=Math.max(max,z | arr[i]);
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass_A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var z : long ; z := sc.getCurrent()->toLong() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var max : long ; max := "-9223372036854775808"->toLong() ;
        var i : int ; i := 0 ; while i < n do ( (     max := Set{max, MathLib.bitwiseOr(z,arr[i+1])}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewClass_A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0){
      int n=sc.nextInt();
      long z=sc.nextLong();
      long arr[]=new long[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextLong();
      }
      long max=Long.MIN_VALUE ;
      for(int i=0 ; i<n ; i++){
        max=Math.max(max,z | arr[i]);
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass_A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var z : long ; z := sc.getCurrent()->toLong() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var max : long ; max := "-9223372036854775808"->toLong() ;
        var i : int ; i := 0 ; while i < n do ( (     max := Set{max, MathLib.bitwiseOr(z,arr[i+1])}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.List ;
public class Main {
  static PrintWriter out=new PrintWriter(System.out);
  static Scanner in=new Scanner(System.in);
  static BufferedReader re=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter wr=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws IOException {
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int T=in.nextInt();
    while(T>0){
      int n=in.nextInt();
      int k=in.nextInt();
      int arr[]=new int[n];
      int max=0 ;
      for(int i=0 ; i<n ; i++){
        arr[i]=in.nextInt();
        arr[i] |=k ;
        if(max<arr[i]){
          max=arr[i];
        }
      }
      out.println(max);
      T--;
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute re : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute wr : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
     while (T > 0) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() ; 
     arr[i+1] := MathLib.bitwiseOr(arr[i+1], k) ; 
     if (max < arr[i+1]) then (     max := arr[i+1] ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    T := T - 1 ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class GFG {
  public static int countOccurence(int n,int[] arr,int k){
    int ans=0 ;
    HashMap<Integer,Boolean>hash=new HashMap<>();
    HashMap<Integer,Integer>occurence=new HashMap<>();
    for(int i=n-1 ; i>=0 ; i--){
      if(hash.get(arr[i])!=null && hash.get(arr[i])==true)continue ;
      if(occurence.get(arr[i])!=null && occurence.get(arr[i])>=k){
        ans++;
        hash.put(arr[i],true);
      }
      else {
        if(occurence.get(arr[i])==null)occurence.put(arr[i],1);
        else {
          int temp=occurence.get(arr[i]);
          occurence.put(arr[i],++temp);
        }
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int[] arr={
      1,2,1,3 };
      int n=arr.length ;
      int k=1 ;
      System.out.println(countOccurence(n,arr,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countOccurence( n : int, arr : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var hash : Map(int,Boolean) ; hash := Map{} ;
    var occurence : Map(int,int) ; occurence := Map{} ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (hash->at(arr[i+1]) /= null & hash->at(arr[i+1]) = true) then     continue else skip ; 
     if (occurence->at(arr[i+1]) /= null & occurence->at(arr[i+1]) >= k) then (     ans := ans + 1 ; 
     hash := hash->union(Map{arr[i+1] |-> true}) ) else (     if (occurence->at(arr[i+1]) = null) then     occurence := occurence->union(Map{arr[i+1] |-> 1}) ; else (     var temp : int ; temp := occurence->at(arr[i+1]) ;
     occurence := occurence->union(Map{arr[i+1] |-> (temp + 1)}) ) ) )  ;     i := i - 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,1,3} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 1 ;
     OclFile["System.out"].println(countOccurence(n, arr, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printArr(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  static void pushBinaryToBorder(int arr[],int n){
    int count1=0 ;
    for(int i=0 ; i<n ; i++)if(arr[i]!=1)arr[count1++]=arr[i];
    while(count1<n)arr[count1++]=1 ;
    int lastNonOne=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(arr[i]==1)continue ;
      if(lastNonOne==0){
        lastNonOne=i ;
      }
      if(arr[i]!=0)arr[lastNonOne--]=arr[i];
    }
    while(lastNonOne>=0)arr[lastNonOne--]=0 ;
  }
  public static void main(String args[]){
    int arr[]={
      1,2,0,0,0,3,6 };
      int n=arr.length ;
      pushBinaryToBorder(arr,n);
      printArr(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation pushBinaryToBorder( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var count1 : int ; count1 := 0 ;
         var i : int ; i := 0 ; while i < n do (     if (arr[i+1] /= 1) then      arr[count1+1] := arr[i+1]  ; count1 := count1 + 1 ; else skip ;  ;     i := i + 1 ) ; 
    while (count1 < n) do      arr[count1+1] := 1  ; count1 := count1 + 1 ; ; 
    var lastNonOne : int ; lastNonOne := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (arr[i+1] = 1) then     continue else skip ; 
     if (lastNonOne = 0) then (     lastNonOne := i ) else skip ; 
     if (arr[i+1] /= 0) then      arr[lastNonOne+1] := arr[i+1]  ; lastNonOne := lastNonOne - 1 ; else skip )  ;     i := i - 1 ) ; 
    while (lastNonOne >= 0) do      arr[lastNonOne+1] := 0  ; lastNonOne := lastNonOne - 1 ; ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,0,0,0,3,6} ;
     var n : int ; n := arr->size() ;
     execute pushBinaryToBorder(arr, n) ; 
     execute printArr(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class question {
  public static void main(String[] args)throws NumberFormatException,IOException {
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int m=sc.nextInt();
    int count=0 ;
    while(true){
      if(a % m==0){
        System.out.println("Yes");
        return ;
      }
      a+=a % m ;
      count++;
      if(count==20)break ;
    }
    System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class question {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    while (true) do (     if (a mod m = 0) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
     a := a+(a mod m) ; 
     count := count + 1 ; 
     if (count = 20) then     break else skip ) ; 
    OclFile["System.out"].println("No") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Solution {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int m=sc.nextInt();
    for(int i=0 ; i<=m ; i++)a=(a*2)% m ;
    System.out.println(a==0 ? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i <= m do (     a := (a * 2) mod m ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if a = 0 then "Yes" else "No" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.nio.charset.MalformedInputException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    String s=sc.next();
    int v=0 ;
    int y=0 ;
    for(int i=0 ; i<s.length(); i++){
      char c=s.charAt(i);
      if(c=='0' && y>0){
        v++;
      }
      if(c=='1'){
        y++;
      }
    }
    if(v>=6){
      out.println("yes");
    }
    else {
      out.println("no");
    }
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : String ; s := sc.getCurrent() ;
    var v : int ; v := 0 ;
    var y : int ; y := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var c : String ; c := s->at(i+1) ;
     if (c = '0' & y > 0) then (     v := v + 1 ) else skip ; 
     if (c = '1') then (     y := y + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (v >= 6) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  static int n ;
  static final int maxn=1000 ;
  static final int mod=1000000007 ;
  static int[] a=new int[maxn+10];
  static long cal(int sum,int x){
    long ans=1 ;
    int n=sum+x-1 ;
    int m=Math.min(sum,n-sum);
    BigInteger fm=BigInteger.ONE ;
    for(int i=1 ; i<=m ; i++){
      fm=fm.multiply(BigInteger.valueOf(n-i+1));
      fm=fm.divide(BigInteger.valueOf(i));
    }
    fm=fm.remainder(BigInteger.valueOf(mod));
    String s=fm.toString();
    ans=Integer.valueOf(s);
    return ans ;
  }
  static long work(){
    long ans=1 ;
    int sum=0 ;
    for(int i=1 ; i<=n ; i++){
      ans=(ans*cal(sum,a[i]))% mod ;
      sum+=a[i];
    }
    return ans ;
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextInt()){
      n=sc.nextInt();
      for(int i=1 ; i<=n ; i++){
        a[i]=sc.nextInt();
      }
      System.out.println(work());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static    attribute maxn : int := 1000;
  static    attribute mod : int := 1000000007;
  static   attribute a : Sequence(int) := Integer.subrange(1,maxn + 10)->collect(0);
  static   operation cal( sum : int, x : int) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
     var n : int ; n := sum + x - 1 ;
    var m : int ; m := Set{sum, n - sum}->min() ;
    var fm : long ; fm := 1 ;
        var i : int ; i := 1 ; while i <= m do ( (     fm := fm.multiply((n - i + 1 + "")->toLong()) ; 
     fm := fm.divide((i + "")->toLong()) )  ;     i := i + 1 ) ; 
    fm := fm.remainder((mod + "")->toLong()) ; 
    var s : String ; s := fm+"" ;
    ans := (s)->toInteger() ; 
    return ans 
 );
  static   operation work() : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     ans := (ans * cal(sum, a[i+1])) mod mod ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextInt()) do (     n := sc.getCurrent()->toInteger() ; 
         var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(work()) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class CF485_D2_A {
  public static void main(String[] args){
    FastScanner scanner=new FastScanner();
    long x=scanner.nextInt();
    int m=scanner.nextInt();
    for(int i=0 ; i<100000 ; i++){
      int mod=(int)(x % m);
      if(mod==0){
        System.out.println("Yes");
        return ;
      }
      x+=mod ;
    }
    System.out.println("No");
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      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 ;
    }
    int[] nextArray(int n){
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=nextInt();
      }
      return arr ;
    }
    Integer[] nextArray(int n,boolean object){
      Integer[] arr=new Integer[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=nextInt();
      }
      return arr ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF485_D2_A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : FastScanner ; scanner := FastScanner.newFastScanner() ;
     var x : long ; x := scanner.nextInt() ;
    var m : int ; m := scanner.nextInt() ;
        var i : int ; i := 0 ; while i < 100000 do ( (     var mod : int ; mod := (x mod m)->oclAsType(int) ;
     if (mod = 0) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
     x := x+(mod) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("No") ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return arr );
   operation nextArray( n : int, object : boolean) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return arr );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int m=sc.nextInt();
    if(x % m==0)System.out.println("Yes");
    else if(m % 2!=0)System.out.println("No");
    else if(m % 2==0){
      while(m % 2==0)m/=2 ;
      if(x % m==0)System.out.println("Yes");
      else System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     if (x mod m = 0) then     OclFile["System.out"].println("Yes") ; else     if (m mod 2 /= 0) then     OclFile["System.out"].println("No") else     if (m mod 2 = 0) then (     while (m mod 2 = 0) do     m := m/(2) ; ; 
     if (x mod m = 0) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; ) else skip ; ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
class GFG {
  static String longestInteger(String str,int l){
    int count=0,max=0,pos=-1,pre_pos,pre_len,len=0 ;
    for(int i=0 ; i<l ; i++){
      pre_pos=pos ;
      pre_len=len ;
      count=0 ;
      len=0 ;
      if(Character.isDigit(str.charAt(i)))pos=i ;
      while(Character.isDigit(str.charAt(i))){
        count++;
        i++;
        len++;
      }
      if(count>max){
        max=count ;
      }
      else {
        pos=pre_pos ;
        len=pre_len ;
      }
    }
    return(str.substring(pos,pos+len));
  }
  public static void main(String[] args){
    String str="geeks100for1234geeks" ;
    int l=str.length();
    System.out.print(longestInteger(str,l));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation longestInteger( str : String, l : int) : String
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
    var max : int ; max := 0 ;
    var pos : int ; pos := -1 ;
    var pre_pos : int ;
    var pre_len : int ;
    var len : int ; len := 0 ;
         var i : int ; i := 0 ; while i < l do ( (     pre_pos := pos ; 
     pre_len := len ; 
    count := 0 ; 
    len := 0 ; 
    if ((str->at(i+1) + "")->isMatch("[0-9]")) then     pos := i ; else skip ; 
    while ((str->at(i+1) + "")->isMatch("[0-9]")) do (     count := count + 1 ; 
     i := i + 1 ; 
     len := len + 1 ) ; 
    if (count > max) then (     max := count ) else (     pos := pre_pos ; 
     len := pre_len ) ;  
 )  ;     i := i + 1 ) ; 
     return (str.subrange(pos+1,pos + len)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeks100for1234geeks" ;
     var l : int ; l := str->size() ;
     OclFile["System.out"].print(longestInteger(str, l)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.ArrayList ;
import java.util.List ;
public class Main {
  public static void main(String[] arg){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    List<String>list=new ArrayList<>();
    for(int i=0 ; i<H ; i++){
      list.add(sc.next());
    }
    for(int j=0 ; j<H ; j++){
      String ans=list.get(j);
      System.out.println(ans);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var list : Sequence(String) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < H do ( (     list := list->including(sc.getCurrent()) )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < H do ( (     var ans : String ; ans := list->at(j+1) ;
     OclFile["System.out"].println(ans) ; 
     OclFile["System.out"].println(ans) )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner s=new Scanner(System.in);
    int x=s.nextInt(),y=s.nextInt();
    while(x--!=0){
      String word=s.next();
      System.out.println(word);
      System.out.println(word);
    }
  }
}
class Scanner {
  StringTokenizer st ;
  BufferedReader br ;
  public Scanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public String nextLine()throws IOException {
    return br.readLine();
  }
  public double nextDouble()throws IOException {
    String x=next();
    StringBuilder sb=new StringBuilder("0");
    double res=0,f=1 ;
    boolean dec=false,neg=false ;
    int start=0 ;
    if(x.charAt(0)=='-'){
      neg=true ;
      start++;
    }
    for(int i=start ; i<x.length(); i++)if(x.charAt(i)=='.'){
      res=Long.parseLong(sb.toString());
      sb=new StringBuilder("0");
      dec=true ;
    }
    else {
      sb.append(x.charAt(i));
      if(dec)f*=10 ;
    }
    res+=Long.parseLong(sb.toString())/f ;
    return res*(neg ?-1 : 1);
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := s.getCurrent()->toInteger() ;
    var y : int ; y := s.getCurrent()->toInteger() ;
         while (x /= 0) do (    skip ; (     var word : String ; word := s.getCurrent() ;
     OclFile["System.out"].println(word) ; 
     OclFile["System.out"].println(word) ) ;  ) );
}
class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     var x : String ; x := next() ;
     var sb : String ; sb := StringLib.newString("0") ;
    var res : double ; res := 0 ;
    var f : double ; f := 1 ;
    var dec : boolean ; dec := false ;
    var neg : boolean ; neg := false ;
    var start : int ; start := 0 ;
    if (x->at(0+1) = '-') then (     neg := true ; 
     start := start + 1 ) else skip ; 
        var i : int ; i := start ; while i < x->size() do (     if (x->at(i+1) = '.') then (     res := (sb+"")->toLong() ; 
     sb := StringLib.newString("0") ; 
     dec := true ) else (     sb := sb + StringLib.newString(x->at(i+1)) ; 
     if (dec) then     f := f*(10) ; else skip ) ;   ;     i := i + 1 ) ; 
    res := res+((sb+"")->toLong() / f) ; 
    return res * (if neg then -1 else 1 endif) 
 );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int h=scanner.nextInt(),w=scanner.nextInt();
      char[][] input=new char[h][];
      IntStream.range(0,h).forEach(i->input[i]=scanner.next().toCharArray());
      char[][] output=new char[2*h][w];
      IntStream.range(0,2*h).forEach(i->IntStream.range(0,w).forEach(j->output[i][j]=input[i/2][j]));
      IntStream.range(0,2*h).forEach(i->System.out.println(output[i]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var h : int ; h := scanner.getCurrent()->toInteger() ;
    var w : int ; w := scanner.getCurrent()->toInteger() ;
     var input : Sequence(Sequence(String)) ; input := Integer.subrange(1,h)->collect(Sequence{}) ;
    for i : Integer.subrange(0, h-1) do
    (    input[i+1] := scanner.getCurrent()->characters()) ; 
    var output : Sequence(Sequence(String)) ; output := Integer.subrange(1,2 * h)->collect(Integer.subrange(1,w)->collect(0)) ;
    for i : Integer.subrange(0, 2 * h-1) do
    (    for j : Integer.subrange(0, w-1) do
    (    output[i+1][j+1] := input[i / 2+1][j+1])) ; 
    for i : Integer.subrange(0, 2 * h-1) do
    (    OclFile["System.out"].println(output[i+1])) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    B solver=new B();
    solver.solve(1,in,out);
    out.close();
  }
  static class B {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int h=in.nextInt();
      int w=in.nextInt();
      in.nextLine();
      while(h-->0){
        String line=in.nextLine();
        out.println(line);
        out.println(line);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : B ; solver := B.newB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class B {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var h : int ; h := in.getCurrent()->toInteger() ;
     var w : int ; w := in.getCurrent()->toInteger() ;
     skip ; 
         while (h > 0) do (        h := h - 1 ;     skip ; (     var line : String ; line := in.nextLine() ;
     skip ; 
     skip ) ;  ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  @ SuppressWarnings("resource")public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    int h=scanner.nextInt();
    int w=scanner.nextInt();
    char[][] c=new char[w][h*2];
    for(int i=0 ; i<h*2 ; i+=2){
      String s=scanner.next();
      for(int j=0 ; j<w ; j++){
        c[j][i]=s.charAt(j);
        c[j][i+1]=c[j][i];
      }
    }
    for(int i=0 ; i<(2*h); i++){
      for(int j=0 ; j<w ; j++){
        System.out.print(c[j][i]);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := scanner.getCurrent()->toInteger() ;
    var w : int ; w := scanner.getCurrent()->toInteger() ;
    var c : Sequence(Sequence(String)) ; c := Integer.subrange(1,w)->collect(Integer.subrange(1,h * 2)->collect(0)) ;
        var i : int ; i := 0 ; while i < h * 2 do ( (     var s : String ; s := scanner.getCurrent() ;
         var j : int ; j := 0 ; while j < w do ( (     c[j+1][i+1] := s->at(j+1) ; 
     c[j+1][i + 1+1] := c[j+1][i+1] )  ;     j := j + 1 ) )  ;     i := i+(2) ) ; 
        var i : int ; i := 0 ; while i < (2 * h) do ( (         var j : int ; j := 0 ; while j < w do ( (     OclFile["System.out"].print(c[j+1][i+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] a=new int[m];
    int[] b=new int[m];
    int[] c=new int[100001];
    for(int i=0 ; i<m ; i++){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
      c[a[i] ]++;
      c[b[i] ]++;
    }
    for(int i=0 ; i<c.length ; i++){
      if(c[i] % 2!=0){
        System.out.println("NO");
        return ;
      }
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,100001)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() ; 
     c[a[i+1]+1] := c[a[i+1]+1] + 1 ; 
     c[b[i+1]+1] := c[b[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < c->size() do ( (     if (c[i+1] mod 2 /= 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main implements Runnable {
  private void solve()throws IOException {
    int N=nextInt();
    int M=nextInt();
    int[] pref=new int[N+3];
    for(int m=0 ; m<M ; ++m){
      int a=nextInt();
      int b=nextInt();
      int min=Math.min(a,b);
      int max=Math.max(a,b);
      pref[min]++;
      pref[max]--;
    }
    for(int i=1 ; i<=N ; ++i){
      pref[i]+=pref[i-1];
    }
    boolean even=true ;
    int s=0 ;
    for(int i=1 ; i<=N ; ++i){
      s+=pref[i];
      even &=(s % 2==0);
    }
    if(even)writer.println("YES");
    else writer.println("NO");
  }
  public static void main(String[] args){
    new Main().run();
  }
  BufferedReader reader ;
  StringTokenizer tokenizer ;
  PrintWriter writer ;
  public void run(){
    try {
      reader=new BufferedReader(new InputStreamReader(System.in));
      tokenizer=null ;
      writer=new PrintWriter(System.out);
      solve();
      reader.close();
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  short nextShort()throws IOException {
    return Short.parseShort(nextToken());
  }
  String nextToken()throws IOException {
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : int ; N := nextInt() ;
     var M : int ; M := nextInt() ;
    var pref : Sequence(int) ; pref := Integer.subrange(1,N + 3)->collect(0) ;
        var m : int ; m := 0 ; while m < M do ( (     var a : int ; a := nextInt() ;
     var b : int ; b := nextInt() ;
    var min : int ; min := Set{a, b}->min() ;
    var max : int ; max := Set{a, b}->max() ;
    pref[min+1] := pref[min+1] + 1 ; 
    pref[max+1] := pref[max+1] - 1 ; 
 )  ;     m := m + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (     pref[i+1] := pref[i+1]+(pref[i - 1+1]) )  ;     i := i + 1 ) ; 
    var even : boolean ; even := true ;
    var s : int ; s := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     s := s+(pref[i+1]) ; 
     even := MathLib.bitwiseAnd(even, (s mod 2 = 0)) )  ;     i := i + 1 ) ; 
    if (even) then     writer.println("YES") else     writer.println("NO") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   attribute writer : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     try (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := null ; 
    writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class A553 {
  static final int mod=1000000007 ;
  static final BigInteger bigMod=BigInteger.valueOf(mod);
  static final long[] modInverse=new long[1001];
  static {
    for(int i=1 ; i<=1000 ; i++){
      modInverse[i]=BigInteger.valueOf(i).modInverse(bigMod).longValue();
    }
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    long sum=0 ;
    long result=1 ;
    for(int n=0 ; n<N ; n++){
      int c=in.nextInt();
      sum+=c ;
      result*=choose(sum-1,c-1);
      result %=mod ;
    }
    System.out.println(result);
  }
  static long choose(long N,int K){
    long result=1 ;
    for(int k=1 ; k<=K ; k++){
      result*=(N+1-k);
      result %=mod ;
      result*=modInverse[k];
      result %=mod ;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A553 {
  static    attribute mod : int := 1000000007;
  static    attribute bigMod : long := (mod + "")->toLong();
  static    attribute modInverse : Sequence(long) := Integer.subrange(1,1001)->collect(0);
  static operation initialiseClass()
  pre: true post: true
  activity:         var i : int ; i := 1 ; while i <= 1000 do ( (     modInverse[i+1] := (i + "")->toLong().modInverse(bigMod)->oclAsType(long) )  ;     i := i + 1 ) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var sum : long ; sum := 0 ;
    var result : long ; result := 1 ;
        var n : int ; n := 0 ; while n < N do ( (     var c : int ; c := in.getCurrent()->toInteger() ;
     sum := sum+(c) ; 
     result := result*(choose(sum - 1, c - 1)) ; 
     result := result mod mod )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation choose( N : long, K : int) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 1 ;
         var k : int ; k := 1 ; while k <= K do ( (     result := result*((N + 1 - k)) ; 
     result := result mod mod ; 
     result := result*(modInverse[k+1]) ; 
     result := result mod mod )  ;     k := k + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner input=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=input.nextInt();
    while(t-->0){
      int n=input.nextInt();
      int[] arr=new int[n];
      long sum=0 ;
      long u=0 ;
      int x=0 ;
      for(int i=0 ; i<n ; i++){
        arr[i]=input.nextInt();
        u+=i ;
        sum+=arr[i];
        if(sum<u){
          x++;
        }
      }
      if(x!=0){
        out.println("NO");
      }
      else {
        out.println("YES");
      }
    }
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := input.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := input.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
    var u : long ; u := 0 ;
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := input.getCurrent()->toInteger() ; 
     u := u+(i) ; 
     sum := sum+(arr[i+1]) ; 
     if (sum < u) then (     x := x + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (x /= 0) then (     skip ) else (     skip ) ;  
 ) ;  ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.System.out ;
public class Main {
  static MyReader in=new MyReader();
  public static void main(String[] args){
    int N=in.i();
    int M=in.i()*2 ;
    boolean[] b=new boolean[N+1];
    int c=0 ;
    for(int i=0 ; i<M ; i++){
      int a=in.i();
      if((b[a]=! b[a]))c++;
      else c--;
    }
    out.println(c==0 ? "YES" : "NO");
  }
}
class MyReader extends BufferedReader {
  char[] cbuf=new char[8192];
  int head=0 ;
  int tail=0 ;
  MyReader(){
    super(new InputStreamReader(System.in));
  }
  char next(){
    if(head==tail){
      try {
        tail=super.read(cbuf,0,cbuf.length);
      }
      catch(IOException e){
        e.printStackTrace();
      }
      head=0 ;
    }
    return cbuf[head++];
  }
  int i(){
    char c=next();
    boolean minus=c=='-' ;
    int n=minus ? 0 : c-'0' ;
    while(true){
      int k=next()-'0' ;
      if(k<0 || 9<k)break ;
      n=10*n+k ;
    }
    return minus ?-n : n ;
  }
  int[] ii(final int N){
    int[] a=new int[N];
    for(int j=0 ; j<a.length ; j++)a[j]=i();
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : MyReader := MyReader.newMyReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.i() ;
     var M : int ; M := in.i() * 2 ;
    var b : Sequence(boolean) ; b := Integer.subrange(1,N + 1)->collect(false) ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     var a : int ; a := in.i() ;
     if ((b[a+1])) then     c := c + 1 ; else     c := c - 1 ; )  ;     i := i + 1 ) ; 
    out.println(if c = 0 then "YES" else "NO" endif) ; 
 );
}
class MyReader extends OclFile {
   attribute cbuf : Sequence(String) := Integer.subrange(1,8192)->collect(0);
   attribute head : int := 0;
   attribute tail : int := 0;
   static operation newMyReader() : MyReader
  pre: true
  post: true
  activity:
  ( var self : MyReader ;
    self := createMyReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (head = tail) then (     try (     tail := super.read(cbuf, 0, cbuf->size()) )   catch (e : IOException) do (     e.printStackTrace() )
     head := 0 ) else skip ; 
     return cbuf[head+1] );
   operation i() : int
  pre: true
  post: true
  activity: (     var c : String ; c := next() ;
     var minus : boolean ; minus := c = '-' ;
    var n : int ; n := if minus then 0 else (c)->char2byte() - ('0')->char2byte() endif ;
    while (true) do (     var k : int ; k := next() - ('0')->char2byte() ;
     if (k < 0 or 9 < k) then     break else skip ; 
     n := 10 * n + k ) ; 
    return if minus then -n else n endif 
 );
   operation ii( N : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
         var j : int ; j := 0 ; while j < a->size() do (     a[j+1] := i() ;  ;     j := j + 1 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[] a=new int[M];
    int[] b=new int[M];
    int[] count=new int[N+1];
    for(int j=1 ; j<=N ; j++){
      count[j]=0 ;
    }
    for(int i=0 ; i<M ; i++){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
      count[a[i] ]++;
      count[b[i] ]++;
    }
    boolean ans=true ;
    for(int j=1 ; j<=N ; j++){
      if(count[j] % 2!=0){
        ans=false ;
        break ;
      }
    }
    if(ans==true){
      System.out.print("YES");
    }
    else {
      System.out.print("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,M)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,M)->collect(0) ;
    var count : Sequence(int) ; count := Integer.subrange(1,N + 1)->collect(0) ;
        var j : int ; j := 1 ; while j <= N do ( (     count[j+1] := 0 )  ;     j := j + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() ; 
     count[a[i+1]+1] := count[a[i+1]+1] + 1 ; 
     count[b[i+1]+1] := count[b[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : boolean ; ans := true ;
        var j : int ; j := 1 ; while j <= N do ( (     if (count[j+1] mod 2 /= 0) then (     ans := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (ans = true) then (     OclFile["System.out"].print("YES") ) else (     OclFile["System.out"].print("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[] a=new int[M];
    int[] b=new int[M];
    for(int i=0 ; i<M ; ++i){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
--a[i];
--b[i];
    }
    solve(N,M,a,b);
  }
  void solve(int N,int M,int[] a,int[] b){
    int[] deg=new int[N];
    for(int i=0 ; i<M ; ++i){
++deg[a[i] ];
++deg[b[i] ];
    }
    boolean f=true ;
    for(int i=0 ; i<N ; ++i){
      f &=deg[i] % 2==0 ;
    }
    System.out.println(f ? "YES" : "NO");
  }
  private static void tr(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,M)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() ; 
     a[i+1] := a[i+1] - 1 ; 
     b[i+1] := b[i+1] - 1 )  ;     i := i + 1 ) ; 
    execute solve(N, M, a, b) ; 
 );
   operation solve( N : int, M : int, a : Sequence(int), b : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var deg : Sequence(int) ; deg := Integer.subrange(1,N)->collect(0) ;
         var i : int ; i := 0 ; while i < M do ( (     deg[a[i+1]+1] := deg[a[i+1]+1] + 1 ; 
     deg[b[i+1]+1] := deg[b[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var f : boolean ; f := true ;
        var i : int ; i := 0 ; while i < N do ( (     f := MathLib.bitwiseAnd(f, deg[i+1] mod 2 = 0) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if f then "YES" else "NO" endif) ; 
 );
  static   operation tr( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.*;
import java.io.*;
import java.util.*;
public class Main {
  boolean[] isprime ;
  ArrayList<Integer>list ;
  int MAX=100000 ;
  private void doit(){
    Scanner sc=new Scanner(System.in);
    init();
    while(true){
      int m=sc.nextInt();
      int a=sc.nextInt();
      int b=sc.nextInt();
      if((m | a | b)==0)break ;
      double ab=(double)a/b ;
      int len=list.size();
      int max=0 ;
      int maxp=-1,maxq=-1 ;
      for(int i=0 ; i<len ; i++){
        int q=list.get(i);
        int p=m/q ;
        if(p<2)continue ;
        while(true){
          if(isprime[p] &&(double)p/q<=1.0)break ;
          p--;
        }
        if((double)p/q<=1.0 &&(double)p/q>=ab){
          if(p*q>max){
            max=p*q ;
            maxp=p ;
            maxq=q ;
          }
        }
      }
      System.out.println(maxp+" "+maxq);
    }
  }
  private void init(){
    isprime=new boolean[MAX+1];
    list=new ArrayList<Integer>();
    Arrays.fill(isprime,true);
    isprime[0]=false ;
    isprime[1]=false ;
    for(int i=2 ; i<=MAX ; i++){
      if(isprime[i]){
        list.add(i);
        for(int j=i+i ; j<=MAX ; j+=i){
          isprime[j]=false ;
        }
      }
    }
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute isprime : Sequence(boolean);
   attribute list : Sequence(int);
   attribute MAX : int := 100000;
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute init() ; 
     while (true) do (     var m : int ; m := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(m,a),b)) = 0) then     break else skip ; 
    var ab : double ; ab := a->oclAsType(double) / b ;
    var len : int ; len := list->size() ;
    var max : int ; max := 0 ;
    var maxp : int ; maxp := -1 ;
    var maxq : int ; maxq := -1 ;
        var i : int ; i := 0 ; while i < len do ( (     var q : int ; q := list->at(i+1) ;
     var p : int ; p := m / q ;
    if (p < 2) then     continue else skip ; 
    while (true) do (     if (isprime[p+1] & p->oclAsType(double) / q <= 1.0) then     break else skip ; 
     p := p - 1 ) ; 
    if (p->oclAsType(double) / q <= 1.0 & p->oclAsType(double) / q >= ab) then (     if (p * q > max) then (     max := p * q ; 
     maxp := p ; 
     maxq := q ) else skip ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(maxp + " " + maxq) ; 
 ) );
   operation init() : void
  pre: true
  post: true
  activity: (     isprime := Integer.subrange(1,MAX + 1)->collect(false) ; 
     list := Sequence{} ; 
    isprime := isprime->collect(true) ; 
    isprime[0+1] := false ; 
    isprime[1+1] := false ; 
        var i : int ; i := 2 ; while i <= MAX do ( (     if (isprime[i+1]) then (     list := list->including(i) ; 
         var j : int ; j := i + i ; while j <= MAX do ( (     isprime[j+1] := false )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrimeNumberGenerator pg=new PrimeNumberGenerator();
    while(true){
      String[] tmpArray=br.readLine().split(" ");
      int m=Integer.parseInt(tmpArray[0]);
      int a=Integer.parseInt(tmpArray[1]);
      int b=Integer.parseInt(tmpArray[2]);
      if(m==0){
        break ;
      }
      int maxArea=0 ;
      int maxI=0,maxJ=0 ;
      for(int i=2 ; i<=Math.sqrt(m); i++){
        if(! pg.isPrime(i)){
          continue ;
        }
        for(int j=i ; i*j<=m ; j++){
          if(! pg.isPrime(j)){
            continue ;
          }
          if(a*j<=b*i && i*j>maxArea){
            maxI=i ;
            maxJ=j ;
            maxArea=i*j ;
          }
        }
      }
      System.out.println(maxI+" "+maxJ);
    }
  }
}
class PrimeNumberGenerator {
  private boolean[] isPrime=new boolean[100001];
  public PrimeNumberGenerator(){
    Arrays.fill(isPrime,true);
    isPrime[0]=false ;
    isPrime[1]=false ;
    isPrime[2]=true ;
    int limit=(int)Math.sqrt(isPrime.length);
    for(int i=3 ; i<=limit ; i+=2){
      if(isPrime[i]==false){
        continue ;
      }
      for(int j=i*2 ; j<=isPrime.length-1 ; j+=i){
        isPrime[j]=false ;
      }
    }
  }
  public boolean isPrime(int index){
    if(index % 2==0 && index!=2){
      return false ;
    }
    return isPrime[index];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pg : PrimeNumberGenerator ; pg := PrimeNumberGenerator.newPrimeNumberGenerator() ;
     while (true) do (     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
     var m : int ; m := (tmpArray[0+1])->toInteger() ;
    var a : int ; a := (tmpArray[1+1])->toInteger() ;
    var b : int ; b := (tmpArray[2+1])->toInteger() ;
    if (m = 0) then (     break ) else skip ; 
    var maxArea : int ; maxArea := 0 ;
    var maxI : int ; maxI := 0 ;
    var maxJ : int ; maxJ := 0 ;
        var i : int ; i := 2 ; while i <= (m)->sqrt() do ( (     if (not(pg.isPrime(i))) then (     continue ) else skip ; 
         var j : int ; j := i ; while i * j <= m do ( (     if (not(pg.isPrime(j))) then (     continue ) else skip ; 
     if (a * j <= b * i & i * j > maxArea) then (     maxI := i ; 
     maxJ := j ; 
     maxArea := i * j ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(maxI + " " + maxJ) ; 
 ) );
}
class PrimeNumberGenerator {
   attribute isPrime : Sequence(boolean) := Integer.subrange(1,100001)->collect(false);
   static operation newPrimeNumberGenerator() : PrimeNumberGenerator
  pre: true
  post: true
  activity:
  ( var self : PrimeNumberGenerator ;
    self := createPrimeNumberGenerator();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     isPrime := isPrime->collect(true) ; 
     isPrime[0+1] := false ; 
    isPrime[1+1] := false ; 
    isPrime[2+1] := true ; 
    var limit : int ; limit := (isPrime->size())->sqrt()->oclAsType(int) ;
        var i : int ; i := 3 ; while i <= limit do ( (     if (isPrime[i+1] = false) then (     continue ) else skip ; 
         var j : int ; j := i * 2 ; while j <= isPrime->size() - 1 do ( (     isPrime[j+1] := false )  ;     j := j+(i) ) )  ;     i := i+(2) ) ; 
 );
   operation isPrime( index : int) : boolean
  pre: true
  post: true
  activity: (     if (index mod 2 = 0 & index /= 2) then (     return false ) else skip ; 
     return isPrime[index+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    ArrayList<Integer>primes=new ArrayList<Integer>();
    primes.add(2);
    for(int i=3 ; i<100000 ; i+=2){
      for(int j=0 ; j<primes.size(); ++j){
        long p=primes.get(j);
        if(p*p>i){
          primes.add(i);
          break ;
        }
        if(i % p==0)break ;
      }
    }
    while(true){
      int M=sc.nextInt();
      if(M==0)break ;
      int A=sc.nextInt();
      int B=sc.nextInt();
      long mp=0 ;
      long mq=0 ;
      for(int i=0 ; i<primes.size(); ++i){
        long q=primes.get(i);
        if(q*2>M)break ;
        int pos=Collections.binarySearch(primes,(int)Math.min((M/q),q));
        if(pos<0)pos=-pos-2 ;
        if(pos>=0){
          long p=primes.get(pos);
          if(p*q<=mp*mq)continue ;
          if(p*B<q*A)continue ;
          mp=p ;
          mq=q ;
        }
      }
      System.out.println(mp+" "+mq);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var primes : Sequence(int) ; primes := Sequence{} ;
     primes := primes->including(2) ; 
         var i : int ; i := 3 ; while i < 100000 do ( (         var j : int ; j := 0 ; while j < primes->size() do ( (     var p : long ; p := primes->at(j+1) ;
     if (p * p > i) then (     primes := primes->including(i) ; 
     break ) else skip ; 
     if (i mod p = 0) then     break else skip )  ;     j := j + 1 ) )  ;     i := i+(2) ) ; 
     while (true) do (     var M : int ; M := sc.getCurrent()->toInteger() ;
     if (M = 0) then     break else skip ; 
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var mp : long ; mp := 0 ;
    var mq : long ; mq := 0 ;
        var i : int ; i := 0 ; while i < primes->size() do ( (     var q : long ; q := primes->at(i+1) ;
     if (q * 2 > M) then     break else skip ; 
    var pos : int ; pos := .binarySearch(primes, Set{(M / q), q}->min()->oclAsType(int)) ;
    if (pos < 0) then     pos := -pos - 2 ; else skip ; 
    if (pos >= 0) then (     var p : long ; p := primes->at(pos+1) ;
     if (p * q <= mp * mq) then     continue else skip ; 
    if (p * B < q * A) then     continue else skip ; 
    mp := p ; 
    mq := q ; 
 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(mp + " " + mq) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p182 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p182().run());
  }
  private static final int P=1009 ;
  private static final int Q=3643 ;
  private static final int TOTIENT=(P-1)*(Q-1);
  public String run(){
    int[] numUnconcealedP=countAllUnconcealed(P);
    int[] numUnconcealedQ=countAllUnconcealed(Q);
    int minUnconcealedP=Integer.MAX_VALUE ;
    for(int x : numUnconcealedP)minUnconcealedP=Math.min(x,minUnconcealedP);
    int minUnconcealedQ=Integer.MAX_VALUE ;
    for(int x : numUnconcealedQ)minUnconcealedQ=Math.min(x,minUnconcealedQ);
    long sum=0 ;
    for(int e=0 ; e<TOTIENT ; e++){
      if(numUnconcealedP[e %(P-1)]==minUnconcealedP && numUnconcealedQ[e %(Q-1)]==minUnconcealedQ)sum+=e ;
    }
    return Long.toString(sum);
  }
  private static int[] countAllUnconcealed(int prime){
    int[] numUnconcealed=new int[prime-1];
    for(int e=0 ; e<numUnconcealed.length ; e++){
      if(Library.gcd(e,prime-1)==1)numUnconcealed[e]=countUnconcealed(prime,e);
      else numUnconcealed[e]=Integer.MAX_VALUE ;
    }
    return numUnconcealed ;
  }
  private static int countUnconcealed(int modulus,int e){
    int count=0 ;
    for(int m=0 ; m<modulus ; m++){
      if(Library.powMod(m,e,modulus)==m)count++;
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p182 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p182.newp182().run()) );
  static    attribute P : int := 1009;
  static    attribute Q : int := 3643;
  static    attribute TOTIENT : int := (P - 1) * (Q - 1);
   operation run() : String
  pre: true
  post: true
  activity: (     var numUnconcealedP : Sequence(int) ; numUnconcealedP := countAllUnconcealed(P) ;
     var numUnconcealedQ : Sequence(int) ; numUnconcealedQ := countAllUnconcealed(Q) ;
    var minUnconcealedP : int ; minUnconcealedP := 2147483647 ;
    for (x : numUnconcealedP) do (     minUnconcealedP := Set{x, minUnconcealedP}->min() ;  ) ; 
    var minUnconcealedQ : int ; minUnconcealedQ := 2147483647 ;
    for (x : numUnconcealedQ) do (     minUnconcealedQ := Set{x, minUnconcealedQ}->min() ;  ) ; 
    var sum : long ; sum := 0 ;
        var e : int ; e := 0 ; while e < TOTIENT do ( (     if (numUnconcealedP[e mod (P - 1)+1] = minUnconcealedP & numUnconcealedQ[e mod (Q - 1)+1] = minUnconcealedQ) then     sum := sum+(e) ; else skip )  ;     e := e + 1 ) ; 
    return ((sum) + "") 
 );
  static   operation countAllUnconcealed( prime : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var numUnconcealed : Sequence(int) ; numUnconcealed := Integer.subrange(1,prime - 1)->collect(0) ;
         var e : int ; e := 0 ; while e < numUnconcealed->size() do ( (     if (Library.gcd(e, prime - 1) = 1) then     numUnconcealed[e+1] := countUnconcealed(prime, e) ; else     numUnconcealed[e+1] := 2147483647 ; )  ;     e := e + 1 ) ; 
     return numUnconcealed );
  static   operation countUnconcealed( modulus : int, e : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var m : int ; m := 0 ; while m < modulus do ( (     if (Library.powMod(m, e, modulus) = m) then     count := count + 1 ; else skip )  ;     m := m + 1 ) ; 
     return count );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  static double PI=3.14159265 ;
  public static double length_rope(double r){
    return((2*PI*r)+6*r);
  }
  public static void main(String[] args){
    double r=7 ;
    System.out.println(length_rope(r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute PI : double := 3.14159265;
  static   operation length_rope( r : double) : double
  pre: true
  post: true
  activity: (     return ((2 * PI * r) + 6 * r) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : double ; r := 7 ;
     OclFile["System.out"].println(length_rope(r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    printAnswer();
  }
  private static void printAnswer(){
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
){
      String dataSet=br.readLine();
      StringBuilder sb=new StringBuilder();
      for(Integer i=0 ; i<dataSet.length(); i++){
        char c=dataSet.charAt(i);
        if(Character.isUpperCase(c)){
          c=Character.toLowerCase(c);
        }
        else {
          c=Character.toUpperCase(c);
        }
        sb.append(c);
      }
      System.out.println(sb);
    }
    catch(IOException e){
      throw new RuntimeException(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute printAnswer() );
  static   operation printAnswer() : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var dataSet : String ; dataSet := br.readLine() ;
     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < dataSet->size() do ( (     var c : String ; c := dataSet->at(i+1) ;
     if ((c->toUpperCase() = c)) then (     c := (c + "")->toLowerCase() ) else (     c := (c + "")->toUpperCase() ) ;  
     sb := sb + StringLib.newString(c) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sb) ))   catch (e : IOException) do (     error ProgramException(e) )
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class CountSubString {
  int countSubStr(char str[],int n){
    int m=0 ;
    for(int i=0 ; i<n ; i++){
      if(str[i]=='1')m++;
    }
    return m*(m-1)/2 ;
  }
  public static void main(String[] args){
    CountSubString count=new CountSubString();
    String string="00100101" ;
    char str[]=string.toCharArray();
    int n=str.length ;
    System.out.println(count.countSubStr(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class CountSubString {
   operation countSubStr( str : Sequence(String), n : int) : int
  pre: true
  post: true
  activity: (     var m : int ; m := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (str[i+1] = '1') then     m := m + 1 ; else skip )  ;     i := i + 1 ) ; 
     return m * (m - 1) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var count : CountSubString ; count := CountSubString.newCountSubString() ;
     var string : String ; string := "00100101" ;
    var str : Sequence(String) ; str := string->characters() ;
    var n : int ; n := str->size() ;
    OclFile["System.out"].println(count.countSubStr(str, n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A_Distance {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int x=s.nextInt();
      int y=s.nextInt();
      if((x+y)% 2==0){
        int sum=(x+y)/2 ;
        int i=0,j=0 ;
        if(x>y){
          i=x-sum ;
          j=sum-i ;
          System.out.println(i+" "+j);
        }
        else {
          j=y-sum ;
          i=sum-j ;
          System.out.println(i+" "+j);
        }
      }
      else {
        System.out.println((-1)+" "+(-1));
      }
    }
  }
};
------------------------------------------------------------
OCL File:
---------
 class A_Distance {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x : int ; x := s.getCurrent()->toInteger() ;
     var y : int ; y := s.getCurrent()->toInteger() ;
     if ((x + y) mod 2 = 0) then (     var sum : int ; sum := (x + y) / 2 ;
     var i : int ; i := 0 ;
    var j : int ; j := 0 ;
     if (x > y) then (     i := x - sum ; 
     j := sum - i ; 
     OclFile["System.out"].println(i + " " + j) ) else (     j := y - sum ; 
     i := sum - j ; 
     OclFile["System.out"].println(i + " " + j) ) ) else (     OclFile["System.out"].println((-1) + " " + (-1)) ) ) ;  ) );
}
;

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      StringBuilder sb=new StringBuilder(br.readLine());
      for(int i=0 ; i<sb.length(); ++i){
        if('a'<=sb.charAt(i)&& sb.charAt(i)<='z'){
          System.out.print((char)(sb.charAt(i)-'a'+'A'));
        }
        else if('A'<=sb.charAt(i)&& sb.charAt(i)<='Z'){
          System.out.print((char)(sb.charAt(i)-'A'+'a'));
        }
        else {
          System.out.print(sb.charAt(i));
        }
      }
      System.out.println("");
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var sb : String ; sb := StringLib.newString(br.readLine()) ;
         var i : int ; i := 0 ; while i < sb->size() do ( (     if ('a' <= sb->at(i+1) & sb->at(i+1) <= 'z') then (     OclFile["System.out"].print((sb->at(i+1) - ('a')->char2byte() + 'A')->oclAsType(String)) ) else     if ('A' <= sb->at(i+1) & sb->at(i+1) <= 'Z') then (     OclFile["System.out"].print((sb->at(i+1) - ('A')->char2byte() + 'a')->oclAsType(String)) ) else (     OclFile["System.out"].print(sb->at(i+1)) ) ;  )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("") )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Character.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    System.out.println(solve(new BufferedReader(new InputStreamReader(System.in)).readLine()));
  }
  public static String solve(String s){
    StringBuilder sb=new StringBuilder(s.length());
    for(int i=0 ; i<s.length(); i++){
      char c=s.charAt(i);
      if(isUpperCase(c))sb.append(toLowerCase(c));
      else if(isLowerCase(c))sb.append(toUpperCase(c));
      else sb.append(c);
    }
    return sb.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(solve(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])).readLine())) );
  static   operation solve( s : String) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString(s->size()) ;
         var i : int ; i := 0 ; while i < s->size() do ( (     var c : String ; c := s->at(i+1) ;
     if (isUpperCase(c)) then     sb := sb + StringLib.newString(toLowerCase(c)) ; else     if (isLowerCase(c)) then     sb := sb + StringLib.newString(toUpperCase(c)) else     sb := sb + StringLib.newString(c) ; ;  )  ;     i := i + 1 ) ; 
     return sb+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  private static final int BIG_LETTER=0 ;
  private static final int LITTLE_LETTER=1 ;
  private static final int OTHERS=2 ;
  private static Scanner sc=new Scanner(System.in);
  private static ArrayList<String>result=new ArrayList<String>();
  public static void main(String[] args){
    String input=getInput();
    setInputStrings(input);
    replaceAllStrings();
    printAllInputStrings();
  }
  private static String getInput(){
    return sc.nextLine();
  }
  private static void setInputStrings(String input){
    String[] strings=input.split(",");
    for(int i=0 ; i<strings.length ; i++){
      result.add(strings[i]);
    }
  }
  private static int isBigLetter(char c){
    if(65<=c && c<=90){
      return BIG_LETTER ;
    }
    else if(97<=c && c<=122){
      return LITTLE_LETTER ;
    }
    else {
      return OTHERS ;
    }
  }
  private static String getReplaceString(String str){
    String resultString=new String();
    for(int i=0 ; i<str.length(); i++){
      String c=String.valueOf(str.charAt(i));
      switch(isBigLetter(c.charAt(0))){
        case BIG_LETTER : resultString=resultString.concat(c.toLowerCase());
        break ;
        case LITTLE_LETTER : resultString=resultString.concat(c.toUpperCase());
        break ;
        case OTHERS : resultString=resultString.concat(c);
        break ;
      }
    }
    return resultString ;
  }
  private static void replaceAllStrings(){
    for(int i=0 ; i<result.size(); i++){
      String str=getReplaceString(result.get(i));
      result.set(i,str);
    }
  }
  private static void printAllInputStrings(){
    for(int i=0 ; i<result.size(); i++){
      System.out.printf("%s",result.get(i));
      if(i<result.size()-1){
        System.out.printf(",");
      }
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BIG_LETTER : int := 0;
  static    attribute LITTLE_LETTER : int := 1;
  static    attribute OTHERS : int := 2;
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute result : Sequence(String) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : String ; input := getInput() ;
     execute setInputStrings(input) ; 
     execute replaceAllStrings() ; 
     execute printAllInputStrings() );
  static   operation getInput() : String
  pre: true
  post: true
  activity: (     return sc.nextLine() );
  static   operation setInputStrings( input : String) : void
  pre: true
  post: true
  activity: (     var strings : Sequence(String) ; strings := input->split(",") ;
         var i : int ; i := 0 ; while i < strings->size() do ( (     result := result->including(strings[i+1]) )  ;     i := i + 1 ) );
  static   operation isBigLetter( c : String) : int
  pre: true
  post: true
  activity: (     if (65 <= c & c <= 90) then (     return BIG_LETTER ) else     if (97 <= c & c <= 122) then (     return LITTLE_LETTER ) else (     return OTHERS ) ;  );
  static   operation getReplaceString( str : String) : String
  pre: true
  post: true
  activity: (     var resultString : String ; resultString := StringLib.newString() ;
         var i : int ; i := 0 ; while i < str->size() do ( (     var c : String ; c := ((str->at(i+1)) + "") ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (isBigLetter(c->at(0+1))) ; 
       if _switchval = BIG_LETTER then
     resultString := resultString+c->toLowerCase() ; 
    break 
   else skip ;
       if _switchval = LITTLE_LETTER then
     resultString := resultString+c->toUpperCase() ; 
    break 
   else skip ;
       if _switchval = OTHERS then
     resultString := resultString+c ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
     return resultString );
  static   operation replaceAllStrings() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < result->size() do ( (     var str : String ; str := getReplaceString(result->at(i+1)) ;
     result := result.setAt(i+1,str) )  ;     i := i + 1 ) );
  static   operation printAllInputStrings() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < result->size() do ( (     OclFile["System.out"].printf("%s", result->at(i+1)) ; 
     if (i < result->size() - 1) then (     OclFile["System.out"].printf(",") ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s=br.readLine();
    StringBuffer sb=new StringBuffer();
    for(int i=0 ; i<s.length(); i++){
      sb.append((s.charAt(i)>='A' && s.charAt(i)<='Z')?(s.charAt(i)-'A'+'a'):(s.charAt(i)-'a'+'A'));
      if(s.charAt(i)>='A' && s.charAt(i)<='Z'){
        System.out.print((char)(s.charAt(i)-'A'+'a'));
      }
      else if(s.charAt(i)>='a' && s.charAt(i)<='z'){
        System.out.print((char)(s.charAt(i)-'a'+'A'));
      }
      else {
        System.out.print(s.charAt(i));
      }
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var s : String ; s := br.readLine() ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     sb := sb + StringLib.newString(if (s->at(i+1) >= 'A' & s->at(i+1) <= 'Z') then (s->at(i+1) - ('A')->char2byte() + 'a') else (s->at(i+1) - ('a')->char2byte() + 'A') endif) ; 
     if (s->at(i+1) >= 'A' & s->at(i+1) <= 'Z') then (     OclFile["System.out"].print((s->at(i+1) - ('A')->char2byte() + 'a')->oclAsType(String)) ) else     if (s->at(i+1) >= 'a' & s->at(i+1) <= 'z') then (     OclFile["System.out"].print((s->at(i+1) - ('a')->char2byte() + 'A')->oclAsType(String)) ) else (     OclFile["System.out"].print(s->at(i+1)) ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1680 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int L1=in.nextInt();
      int R1=in.nextInt();
      int L2=in.nextInt();
      int R2=in.nextInt();
      int L=Math.max(L1,L2);
      int R=Math.min(R1,R2);
      int answer=(L<=R)? L :(L1+L2);
      System.out.println(answer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1680 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var L1 : int ; L1 := in.getCurrent()->toInteger() ;
     var R1 : int ; R1 := in.getCurrent()->toInteger() ;
    var L2 : int ; L2 := in.getCurrent()->toInteger() ;
    var R2 : int ; R2 := in.getCurrent()->toInteger() ;
    var L : int ; L := Set{L1, L2}->max() ;
    var R : int ; R := Set{R1, R2}->min() ;
    var answer : int ; answer := if (L <= R) then L else (L1 + L2) endif ;
    OclFile["System.out"].println(answer) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Codeforces {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int tests=sc.nextInt();
    for(int t=0 ; t<tests ; t++){
      int l1=sc.nextInt();
      int r1=sc.nextInt();
      int l2=sc.nextInt();
      int r2=sc.nextInt();
      if(r1<l2 || l1>r2){
        System.out.println(l1+l2);
      }
      else if(l1>=l2 && l1<=r2){
        System.out.println(l1);
      }
      else {
        System.out.println(l2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tests : int ; tests := sc.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < tests do ( (     var l1 : int ; l1 := sc.getCurrent()->toInteger() ;
     var r1 : int ; r1 := sc.getCurrent()->toInteger() ;
    var l2 : int ; l2 := sc.getCurrent()->toInteger() ;
    var r2 : int ; r2 := sc.getCurrent()->toInteger() ;
    if (r1 < l2 or l1 > r2) then (     OclFile["System.out"].println(l1 + l2) ) else     if (l1 >= l2 & l1 <= r2) then (     OclFile["System.out"].println(l1) ) else (     OclFile["System.out"].println(l2) ) ;  ;  
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.util.regex.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    int l1,l2,r1,r2 ;
    while(t>0){
      t--;
      l1=in.nextInt();
      r1=in.nextInt();
      l2=in.nextInt();
      r2=in.nextInt();
      if(l2>r1 || l1>r2)System.out.println(l1+l2);
      else System.out.println(Math.max(l1,l2));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
     var l1 : int ;
    var l2 : int ;
    var r1 : int ;
    var r2 : int ;
     while (t > 0) do (     t := t - 1 ; 
     l1 := in.getCurrent()->toInteger() ; 
    r1 := in.getCurrent()->toInteger() ; 
    l2 := in.getCurrent()->toInteger() ; 
    r2 := in.getCurrent()->toInteger() ; 
    if (l2 > r1 or l1 > r2) then     OclFile["System.out"].println(l1 + l2) else     OclFile["System.out"].println(Set{l1, l2}->max()) ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int reverseDigits(int num){
    int rev_num=0 ;
    while(num>0){
      rev_num=rev_num*10+num % 10 ;
      num=num/10 ;
    }
    return rev_num ;
  }
  static int isPalindrome(int n){
    int rev_n=reverseDigits(n);
    if(rev_n==n)return 1 ;
    else return 0 ;
  }
  public static void main(String[] args){
    int n=4562 ;
    System.out.println("Is"+n+"a Palindrome number?->"+(isPalindrome(n)==1 ? "true" : "false"));
    n=2002 ;
    System.out.println("Is"+n+"a Palindrome number?->"+(isPalindrome(n)==1 ? "true" : "false"));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation reverseDigits( num : int) : int
  pre: true
  post: true
  activity: (     var rev_num : int ; rev_num := 0 ;
     while (num > 0) do (     rev_num := rev_num * 10 + num mod 10 ; 
     num := num / 10 ) ; 
     return rev_num );
  static   operation isPalindrome( n : int) : int
  pre: true
  post: true
  activity: (     var rev_n : int ; rev_n := reverseDigits(n) ;
     if (rev_n = n) then     return 1 else     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4562 ;
     OclFile["System.out"].println("Is" + n + "a Palindrome number?->" + (if isPalindrome(n) = 1 then "true" else "false" endif)) ; 
     n := 2002 ; 
     OclFile["System.out"].println("Is" + n + "a Palindrome number?->" + (if isPalindrome(n) = 1 then "true" else "false" endif)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Chapter1 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int l1=in.nextInt();
      int r1=in.nextInt();
      int l2=in.nextInt();
      int r2=in.nextInt();
      if(r1<l2 | r2<l1){
        System.out.println(l1+l2);
      }
      else if((l1<=l2)&&(l2<=r1)){
        System.out.println(l2);
      }
      else if((l2<=l1)&&(l1<=r2)){
        System.out.println(l1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Chapter1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var l1 : int ; l1 := in.getCurrent()->toInteger() ;
     var r1 : int ; r1 := in.getCurrent()->toInteger() ;
    var l2 : int ; l2 := in.getCurrent()->toInteger() ;
    var r2 : int ; r2 := in.getCurrent()->toInteger() ;
    if (r1 < l2 or r2 < l1) then (     OclFile["System.out"].println(l1 + l2) ) else     if ((l1 <= l2) & (l2 <= r1)) then (     OclFile["System.out"].println(l2) ) else     if ((l2 <= l1) & (l1 <= r2)) then (     OclFile["System.out"].println(l1) ) else skip ; ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static PrintWriter out=new PrintWriter(System.out);
  static Scanner in=new Scanner(System.in);
  static BufferedReader re=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter wr=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws IOException {
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int T=in.nextInt();
    while(T>0){
      int l=in.nextInt();
      int r=in.nextInt();
      int l1=in.nextInt();
      int r1=in.nextInt();
      int s=Math.max(l,l1);
      if(r>=s && r1>=s){
        out.println(s);
      }
      else {
        out.println((l+l1));
      }
      T--;
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute re : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute wr : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
     while (T > 0) do (     var l : int ; l := in.getCurrent()->toInteger() ;
     var r : int ; r := in.getCurrent()->toInteger() ;
    var l1 : int ; l1 := in.getCurrent()->toInteger() ;
    var r1 : int ; r1 := in.getCurrent()->toInteger() ;
    var s : int ; s := Set{l, l1}->max() ;
    if (r >= s & r1 >= s) then (     skip ) else (     skip ) ;  
    T := T - 1 ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String longestRepeatedSubstring(String str){
    int n=str.length();
    int LCSRe[][]=new int[n+1][n+1];
    String res="" ;
    int res_length=0 ;
    int i,index=0 ;
    for(i=1 ; i<=n ; i++){
      for(int j=i+1 ; j<=n ; j++){
        if(str.charAt(i-1)==str.charAt(j-1)&& LCSRe[i-1][j-1]<(j-i)){
          LCSRe[i][j]=LCSRe[i-1][j-1]+1 ;
          if(LCSRe[i][j]>res_length){
            res_length=LCSRe[i][j];
            index=Math.max(i,index);
          }
        }
        else {
          LCSRe[i][j]=0 ;
        }
      }
    }
    if(res_length>0){
      for(i=index-res_length+1 ; i<=index ; i++){
        res+=str.charAt(i-1);
      }
    }
    return res ;
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    System.out.println(longestRepeatedSubstring(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation longestRepeatedSubstring( str : String) : String
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var LCSRe : Sequence(Sequence(int)) ; LCSRe := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
    var res : String ; res := "" ;
    var res_length : int ; res_length := 0 ;
    var i : int ;
    var index : int ; index := 0 ;
        i := 1 ; while i <= n do ( (         var j : int ; j := i + 1 ; while j <= n do ( (     if (str->at(i - 1+1) = str->at(j - 1+1) & LCSRe[i - 1+1][j - 1+1] < (j - i)) then (     LCSRe[i+1][j+1] := LCSRe[i - 1+1][j - 1+1] + 1 ; 
     if (LCSRe[i+1][j+1] > res_length) then (     res_length := LCSRe[i+1][j+1] ; 
     index := Set{i, index}->max() ) else skip ) else (     LCSRe[i+1][j+1] := 0 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (res_length > 0) then (         i := index - (res_length)->char2byte() + 1 ; while i <= index do ( (     res := res+(str->at(i - 1+1)) )  ;     i := i + 1 ) ) else skip ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     OclFile["System.out"].println(longestRepeatedSubstring(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class contest {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args)throws IOException {
    FastReader sc=new FastReader();
    int t=sc.nextInt();
    while(t-->0){
      int x=sc.nextInt();
      int y=sc.nextInt();
      if((x+y)% 2==1){
        System.out.println("-1-1");
        continue ;
      }
      int d=Math.abs(x+y)/2 ;
      int min=Math.min(x,y);
      int max=Math.max(x,y);
      if(min==x)System.out.println(min+" "+(max-d));
      else System.out.println((max-d)+" "+min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class contest {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var t : int ; t := sc.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x : int ; x := sc.nextInt() ;
     var y : int ; y := sc.nextInt() ;
    if ((x + y) mod 2 = 1) then (     OclFile["System.out"].println("-1-1") ; 
     continue ) else skip ; 
    var d : int ; d := if x + y < 0 then -(x + y) else x + y endif / 2 ;
    var min : int ; min := Set{x, y}->min() ;
    var max : int ; max := Set{x, y}->max() ;
    if (min = x) then     OclFile["System.out"].println(min + " " + (max - d)) else     OclFile["System.out"].println((max - d) + " " + min) ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class x430A {
  public static void main(String hi[])throws Exception {
    BufferedReader infile=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(infile.readLine());
    int N=Integer.parseInt(st.nextToken());
    int M=Integer.parseInt(st.nextToken());
    Pair[] arr=new Pair[N];
    st=new StringTokenizer(infile.readLine());
    for(int i=0 ; i<N ; i++)arr[i]=new Pair(Integer.parseInt(st.nextToken()),i);
    Arrays.sort(arr);
    int tag=0 ;
    int[] res=new int[N];
    for(Pair p : arr){
      res[p.dex]=tag ;
      tag=1-tag ;
    }
    for(int x : res)System.out.print(x+" ");
  }
}
class Pair implements Comparable<Pair>{
  int val ;
  int dex ;
  public Pair(int a,int b){
    val=a ;
    dex=b ;
  }
  public int compareTo(Pair oth){
    return val-oth.val ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class x430A {
  static   operation main( hi : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var infile : OclFile ; infile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(infile.readLine()) ;
    var N : int ; N := (st.next())->toInteger() ;
    var M : int ; M := (st.next())->toInteger() ;
    var arr : Sequence(Map) ; arr := Integer.subrange(1,N)->collect(null) ;
    st := OclIterator.newOclIterator_String(infile.readLine()) ; 
        var i : int ; i := 0 ; while i < N do (     arr[i+1] := Map((st.next())->toInteger(), i) ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var tag : int ; tag := 0 ;
    var res : Sequence(int) ; res := Integer.subrange(1,N)->collect(0) ;
    for (p : arr) do ( (     res[p.dex+1] := tag ; 
     tag := 1 - tag )  ) ; 
    for (x : res) do (     OclFile["System.out"].print(x + " ") ;  ) ; 
 );
}
class Pair implements Comparable<Map> {
   attribute val : int;
   attribute dex : int;
   static operation newPair( a : int, b : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     val := a ; 
     dex := b );
   operation compareTo( oth : Map) : int
  pre: true
  post: true
  activity: (     return val - oth.val );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Ideone {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    Point[] point=new Point[n];
    for(int i=0 ; i<n ; i++){
      point[i]=new Point();
      point[i] .x=sc.nextInt();
      point[i] .ind=i ;
    }
    Arrays.sort(point);
    for(int i=0 ; i<m ; i++){
      sc.nextInt();
      sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      int val=(i % 2==0)? 0 : 1 ;
      point[i] .color=val ;
    }
    int[] color=new int[n];
    for(int i=0 ; i<n ; i++){
      int ind=point[i] .ind ;
      color[ind]=point[i] .color ;
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(color[i]+" ");
    }
    System.out.println();
  }
  static class Point implements Comparable<Point>{
    int x ;
    int ind ;
    int color=0 ;
    public int compareTo(Point a){
      if(this.x>a.x)return 1 ;
      if(this.x<a.x)return-1 ;
      return 0 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ideone {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var point : Sequence(Point) ; point := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     point[i+1] := Point.newPoint() ; 
     point[i+1].x := sc.getCurrent()->toInteger() ; 
     point[i+1].ind := i )  ;     i := i + 1 ) ; 
    point := point->sort() ; 
        var i : int ; i := 0 ; while i < m do ( (     skip ; 
     skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var val : int ; val := if (i mod 2 = 0) then 0 else 1 endif ;
     point[i+1].color := val )  ;     i := i + 1 ) ; 
    var color : Sequence(int) ; color := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var ind : int ; ind := point[i+1].ind ;
     color[ind+1] := point[i+1].color )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(color[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static class Point implements Comparable<Point> {
   attribute x : int;
   attribute ind : int;
   attribute color : int := 0;
   operation compareTo( a : Point) : int
  pre: true
  post: true
  activity: (     if (self.x > a.x) then     return 1 else skip ; 
     if (self.x < a.x) then     return -1 else skip ; 
     return 0 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class pointAndSeg {
  static public void quickSort(int[] a,int[] b,int l,int r){
    int i=l ;
    int j=r ;
    int tmp=a[(i+j)/2];
    do {
      while(a[i]<tmp)i++;
      while(a[j]>tmp)j--;
      if(i<=j){
        int tg=a[i];
        a[i]=a[j];
        a[j]=tg ;
        tg=b[i];
        b[i]=b[j];
        b[j]=tg ;
        i++;
        j--;
      }
    }
    while(i<=j);
    if(l<j)quickSort(a,b,l,j);
    if(i<r)quickSort(a,b,i,r);
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int[] x=new int[n];
    for(int i=0 ; i<n ; i++)x[i]=in.nextInt();
    int[] r=new int[m];
    int[] l=new int[m];
    for(int i=0 ; i<m ; i++){
      l[i]=in.nextInt();
      r[i]=in.nextInt();
    }
    int[] pos=new int[n];
    for(int i=0 ; i<n ; i++)pos[i]=i ;
    quickSort(x,pos,0,n-1);
    int[] result=new int[n];
    for(int i=0 ; i<n ; i++)result[pos[i] ]=i % 2 ;
    for(int i=0 ; i<n ; i++)System.out.print(result[i]+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class pointAndSeg {
  static    operation quickSort( a : Sequence(int), b : Sequence(int), l : int, r : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := l ;
     var j : int ; j := r ;
    var tmp : int ; tmp := a[(i + j) / 2+1] ;
  while true do ((     while (a[i+1] < tmp) do     i := i + 1 ; ; 
     while (a[j+1] > tmp) do     j := j - 1 ; ; 
     if (i <= j) then (     var tg : int ; tg := a[i+1] ;
     a[i+1] := a[j+1] ; 
    a[j+1] := tg ; 
    tg := b[i+1] ; 
    b[i+1] := b[j+1] ; 
    b[j+1] := tg ; 
    i := i + 1 ; 
    j := j - 1 ; 
 ) else skip ) ;
    if (i <= j) then skip else break) ; 
    if (l < j) then     execute quickSort(a, b, l, j) ; else skip ; 
    if (i < r) then     execute quickSort(a, b, i, r) ; else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     x[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var r : Sequence(int) ; r := Integer.subrange(1,m)->collect(0) ;
    var l : Sequence(int) ; l := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     l[i+1] := in.getCurrent()->toInteger() ; 
     r[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var pos : Sequence(int) ; pos := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     pos[i+1] := i ;  ;     i := i + 1 ) ; 
    execute quickSort(x, pos, 0, n - 1) ; 
    var result : Sequence(int) ; result := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     result[pos[i+1]+1] := i mod 2 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(result[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    int[] points=new int[n];
    for(int i=0 ; i<n ; i++){
      points[i]=scan.nextInt();
    }
    int[][] lines=new int[m][2];
    for(int i=0 ; i<m ; i++){
      lines[i][0]=scan.nextInt();
      lines[i][1]=scan.nextInt();
    }
    printPoints(points,lines);
  }
  public static void printPoints(int[] points,int[][] lines){
    StringBuilder sb=new StringBuilder();
    int N=points.length ;
    int[] copy=Arrays.copyOf(points,N);
    int[] map=new int[101];
    Arrays.sort(points);
    for(int i=0 ; i<N ; i++){
      map[points[i] ]=i & 1 ;
    }
    for(int i=0 ; i<N ; i++){
      sb.append(map[copy[i] ]).append(" ");
    }
    sb.append("\n");
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var points : Sequence(int) ; points := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     points[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var lines : Sequence(Sequence(int)) ; lines := Integer.subrange(1,m)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (     lines[i+1][0+1] := scan.getCurrent()->toInteger() ; 
     lines[i+1][1+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute printPoints(points, lines) ; 
 );
  static   operation printPoints( points : Sequence(int), lines : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     var N : int ; N := points->size() ;
    var copy : Sequence(int) ; copy := points.subrange(1,N) ;
    var map : Sequence(int) ; map := Integer.subrange(1,101)->collect(0) ;
    points := points->sort() ; 
        var i : int ; i := 0 ; while i < N do ( (     map[points[i+1]+1] := MathLib.bitwiseAnd(i,1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     sb := sb + StringLib.newString(map[copy[i+1]+1]) + StringLib.newString(" ") )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString("\n") ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.io.IOException ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int M=scanner.nextInt();
      if(M==0)break ;
      Point[] xym=new Point[M];
      for(int i=0 ; i<M ; i++){
        xym[i]=new Point(scanner.nextInt(),scanner.nextInt());
      }
      int N=scanner.nextInt();
      HashSet<Point>ps=new HashSet<Point>();
      for(int i=0 ; i<N ; i++){
        ps.add(new Point(scanner.nextInt(),scanner.nextInt()));
      }
      loop : for(Point p : ps){
        int dx=p.x-xym[0] .x ;
        int dy=p.y-xym[0] .y ;
        for(Point m : xym){
          int nx=m.x+dx ;
          int ny=m.y+dy ;
          if(! ps.contains(new Point(nx,ny))){
            continue loop ;
          }
        }
        System.out.println(dx+" "+dy);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var M : int ; M := scanner.getCurrent()->toInteger() ;
     if (M = 0) then     break else skip ; 
    var xym : Sequence(Point) ; xym := Integer.subrange(1,M)->collect(null) ;
        var i : int ; i := 0 ; while i < M do ( (     xym[i+1] := Point.newPoint(scanner.getCurrent()->toInteger(), scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var N : int ; N := scanner.getCurrent()->toInteger() ;
    var ps : Set(Point) ; ps := Set{} ;
        var i : int ; i := 0 ; while i < N do ( (     ps := ps->including(Point.newPoint(scanner.getCurrent()->toInteger(), scanner.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    for (p : ps) do ( (     var dx : int ; dx := p.x - xym[0+1].x ;
     var dy : int ; dy := p.y - xym[0+1].y ;
    for (m : xym) do ( (     var nx : int ; nx := m.x + dx ;
     var ny : int ; ny := m.y + dy ;
     if (not(ps->includes(Point.newPoint(nx, ny)))) then (     continue ) else skip )  ) ; 
    OclFile["System.out"].println(dx + " " + dy) ; 
    break 
 )  ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    long W=1000001 ;
    while(true){
      int m=sc.nextInt();
      if(m==0)break ;
      long[][] star=new long[m][2];
      for(int i=0 ; i<m ; i++){
        for(int j=0 ; j<2 ; j++){
          star[i][j]=sc.nextLong();
          if(i>0)star[i][j]-=star[0][j];
        }
      }
      Set<Long>set=new HashSet<Long>();
      int n=sc.nextInt();
      long[][] a=new long[n][2];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<2 ; j++){
          a[i][j]=sc.nextLong();
        }
        set.add(a[i][0]*W+a[i][1]);
      }
      for(int i=0 ; i<n ; i++){
        long bx=a[i][0];
        long by=a[i][1];
        boolean f=true ;
        for(int j=1 ; j<m ; j++){
          if(! set.contains((bx+star[j][0])*W+by+star[j][1])){
            f=false ;
            break ;
          }
        }
        if(f){
          System.out.println((bx-star[0][0])+" "+(by-star[0][1]));
          break ;
        }
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var W : long ; W := 1000001 ;
     while (true) do (     var m : int ; m := sc.getCurrent()->toInteger() ;
     if (m = 0) then     break else skip ; 
    var star : Sequence(Sequence(long)) ; star := Integer.subrange(1,m)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j < 2 do ( (     star[i+1][j+1] := sc.getCurrent()->toLong() ; 
     if (i > 0) then     star[i+1][j+1] := star[i+1][j+1]-(star[0+1][j+1]) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var set : Set(long) ; set := Set{} ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(long)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 2 do ( (     a[i+1][j+1] := sc.getCurrent()->toLong() )  ;     j := j + 1 ) ; 
     set := set->including(a[i+1][0+1] * W + a[i+1][1+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var bx : long ; bx := a[i+1][0+1] ;
     var by : long ; by := a[i+1][1+1] ;
    var f : boolean ; f := true ;
        var j : int ; j := 1 ; while j < m do ( (     if (not(set->includes((bx + star[j+1][0+1]) * W + by + star[j+1][1+1]))) then (     f := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (f) then (     OclFile["System.out"].println((bx - star[0+1][0+1]) + " " + (by - star[0+1][1+1])) ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    long monsterHP=scan.nextLong();
    long servalATK=scan.nextLong();
    scan.close();
    long mod=monsterHP % servalATK ;
    long ans=monsterHP/servalATK ;
    if(mod>0){
      ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var monsterHP : long ; monsterHP := scan.getCurrent()->toLong() ;
    var servalATK : long ; servalATK := scan.getCurrent()->toLong() ;
    skip ; 
    var mod : long ; mod := monsterHP mod servalATK ;
    var ans : long ; ans := monsterHP / servalATK ;
    if (mod > 0) then (     ans := ans + 1 ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
class Star {
  public int x,y ;
  Star(int x,int y){
    this.x=x ;
    this.y=y ;
  }
  public boolean equals(Object o){
    Star s=(Star)o ;
    return this.x==s.x && this.y==s.y ;
  }
}
class Main {
  private static ArrayList<Star>target=new ArrayList<Star>(),map=new ArrayList<Star>();
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      target.clear();
      map.clear();
      int m=sc.nextInt();
      if(m==0){
        break ;
      }
      for(int i=0 ; i<m ; i++){
        target.add(new Star(sc.nextInt(),sc.nextInt()));
      }
      int n=sc.nextInt();
      for(int i=0 ; i<n ; i++){
        map.add(new Star(sc.nextInt(),sc.nextInt()));
      }
      Star match_1=target.get(0),match_2 ;
      int diff_x,diff_y ;
      boolean flg ;
      String result="" ;
      for(int i=0 ; i<map.size(); i++){
        match_2=map.get(i);
        diff_x=match_2.x-match_1.x ;
        diff_y=match_2.y-match_1.y ;
        flg=true ;
        for(int j=1 ; j<target.size(); j++){
          Star t=target.get(j);
          if(!(map.contains(new Star(t.x+diff_x,t.y+diff_y)))){
            flg=false ;
            break ;
          }
        }
        if(flg){
          result=diff_x+" "+diff_y ;
          break ;
        }
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Star {
   attribute x : int;
   static operation newStar( x : int, y : int) : Star
  pre: true
  post: true
  activity:
  ( var self : Star ;
    self := createStar();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation equals( o : OclAny) : boolean
  pre: true
  post: true
  activity: (     var s : Star ; s := o->oclAsType(Star) ;
     return self.x = s.x & self.y = s.y );
}
class Main {
  static   attribute target : Sequence(Star) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     target := target->intersection(Set{}) ; 
     map := map->intersection(Set{}) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    if (m = 0) then (     break ) else skip ; 
        var i : int ; i := 0 ; while i < m do ( (     target := target->including(Star.newStar(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     map->excludes(Star.newStar(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var match    var matchStar : int ; matchStar := target->at(0+1) : Star ; match    var matchStar : int ; matchStar := target->at(0+1) := target->at(0+1) ;
    var match    var match    while (true) do (     target := target->intersection(Set{}) ; 
     map := map->intersection(Set{}) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    if (m = 0) then (     break ) else skip ; 
        var i : int ; i := 0 ; while i < m do ( (     target := target->including(Star.newStar(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     map->excludes(Star.newStar(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var match    var matchStar : int ; matchStar := target->at(0+1) : Star ; match    var matchStar : int ; matchStar := target->at(0+1) := target->at(0+1) ;
    var match    var match    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 : int ; match    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := target->at(0+1) ;
    var match    while (true) do (     target := target->intersection(Set{}) ; 
     map := map->intersection(Set{}) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    if (m = 0) then (     break ) else skip ; 
        var i : int ; i := 0 ; while i < m do ( (     target := target->including(Star.newStar(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     map->excludes(Star.newStar(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var match    var matchStar : int ; matchStar := target->at(0+1) : Star ; match    var matchStar : int ; matchStar := target->at(0+1) := target->at(0+1) ;
    var match    var match_1 : int ; match_1 := target->at(0+1) ;
    var match_2 : int : Star ;
    var diff_x : int ;
    var diff_y : int ;
    var flg : boolean ;
    var result : String ; result := "" ;
        var i : int ; i := 0 ; while i < map->size() do ( (     matchmap->at(i+1) := map->at(i+1) ; 
     diff_x := matchx.x - matchmatchmatchx.x.x ; 
    diff_y := matchy.y - matchmatchmatchy.y.y ; 
    flg := true ; 
        var j : int ; j := 1 ; while j < target->size() do ( (     var t : Star ; t := target->at(j+1) ;
     if (not((map->includes(Star.newStar(t.x + diff_x, t.y + diff_y))))) then (     flg := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (flg) then (     result := diff_x + " " + diff_y ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ) ; 
 : int : Star ;
    var diff_x : int ;
    var diff_y : int ;
    var flg : boolean ;
    var result : String ; result := "" ;
        var i : int ; i := 0 ; while i < map->size() do ( (     matchmap->at(i+1) := map->at(i+1) ; 
     diff_x := matchx.x - matchmatchmatchx.x.x ; 
    diff_y := matchy.y - matchmatchmatchy.y.y ; 
    flg := true ; 
        var j : int ; j := 1 ; while j < target->size() do ( (     var t : Star ; t := target->at(j+1) ;
     if (not((map->includes(Star.newStar(t.x + diff_x, t.y + diff_y))))) then (     flg := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (flg) then (     result := diff_x + " " + diff_y ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ) ; : int ; match    while (true) do (     target := target->intersection(Set{}) ; 
     map := map->intersection(Set{}) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    if (m = 0) then (     break ) else skip ; 
        var i : int ; i := 0 ; while i < m do ( (     target := target->including(Star.newStar(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     map->excludes(Star.newStar(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var match    var matchStar : int ; matchStar := target->at(0+1) : Star ; match    var matchStar : int ; matchStar := target->at(0+1) := target->at(0+1) ;
    var match    var match    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 : int ; match    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := target->at(0+1) ;
    var match    while (true) do (     target := target->intersection(Set{}) ; 
     map := map->intersection(Set{}) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    if (m = 0) then (     break ) else skip ; 
        var i : int ; i := 0 ; while i < m do ( (     target := target->including(Star.newStar(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     map->excludes(Star.newStar(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var match    var matchStar : int ; matchStar := target->at(0+1) : Star ; match    var matchStar : int ; matchStar := target->at(0+1) := target->at(0+1) ;
    var match    var match_1 : int ; match_1 := target->at(0+1) ;
    var match_2 : int : Star ;
    var diff_x : int ;
    var diff_y : int ;
    var flg : boolean ;
    var result : String ; result := "" ;
        var i : int ; i := 0 ; while i < map->size() do ( (     matchmap->at(i+1) := map->at(i+1) ; 
     diff_x := matchx.x - matchmatchmatchx.x.x ; 
    diff_y := matchy.y - matchmatchmatchy.y.y ; 
    flg := true ; 
        var j : int ; j := 1 ; while j < target->size() do ( (     var t : Star ; t := target->at(j+1) ;
     if (not((map->includes(Star.newStar(t.x + diff_x, t.y + diff_y))))) then (     flg := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (flg) then (     result := diff_x + " " + diff_y ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ) ; 
 : int : Star ;
    var diff_x : int ;
    var diff_y : int ;
    var flg : boolean ;
    var result : String ; result := "" ;
        var i : int ; i := 0 ; while i < map->size() do ( (     matchmap->at(i+1) := map->at(i+1) ; 
     diff_x := matchx.x - matchmatchmatchx.x.x ; 
    diff_y := matchy.y - matchmatchmatchy.y.y ; 
    flg := true ; 
        var j : int ; j := 1 ; while j < target->size() do ( (     var t : Star ; t := target->at(j+1) ;
     if (not((map->includes(Star.newStar(t.x + diff_x, t.y + diff_y))))) then (     flg := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (flg) then (     result := diff_x + " " + diff_y ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ) ; := target->at(0+1) ;
    var match    while (true) do (     target := target->intersection(Set{}) ; 
     map := map->intersection(Set{}) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    if (m = 0) then (     break ) else skip ; 
        var i : int ; i := 0 ; while i < m do ( (     target := target->including(Star.newStar(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     map->excludes(Star.newStar(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var match    var matchStar : int ; matchStar := target->at(0+1) : Star ; match    var matchStar : int ; matchStar := target->at(0+1) := target->at(0+1) ;
    var match    var match_1 : int ; match_1 := target->at(0+1) ;
    var match_2 : int : Star ;
    var diff_x : int ;
    var diff_y : int ;
    var flg : boolean ;
    var result : String ; result := "" ;
        var i : int ; i := 0 ; while i < map->size() do ( (     matchmap->at(i+1) := map->at(i+1) ; 
     diff_x := matchx.x - matchmatchmatchx.x.x ; 
    diff_y := matchy.y - matchmatchmatchy.y.y ; 
    flg := true ; 
        var j : int ; j := 1 ; while j < target->size() do ( (     var t : Star ; t := target->at(j+1) ;
     if (not((map->includes(Star.newStar(t.x + diff_x, t.y + diff_y))))) then (     flg := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (flg) then (     result := diff_x + " " + diff_y ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ) ; 
 : int : Star ;
    var diff_x : int ;
    var diff_y : int ;
    var flg : boolean ;
    var result : String ; result := "" ;
        var i : int ; i := 0 ; while i < map->size() do ( (     matchmap->at(i+1) := map->at(i+1) ; 
     diff_x := matchx.x - matchmatchmatchx.x.x ; 
    diff_y := matchy.y - matchmatchmatchy.y.y ; 
    flg := true ; 
        var j : int ; j := 1 ; while j < target->size() do ( (     var t : Star ; t := target->at(j+1) ;
     if (not((map->includes(Star.newStar(t.x + diff_x, t.y + diff_y))))) then (     flg := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (flg) then (     result := diff_x + " " + diff_y ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      int m=in.nextInt();
      if(m==0)return ;
      int tx[]=new int[m];
      int ty[]=new int[m];
      for(int i=0 ; i<m ; i++){
        tx[i]=in.nextInt();
        ty[i]=in.nextInt();
      }
      int n=in.nextInt();
      int sorax[]=new int[n];
      int soray[]=new int[n];
      boolean judge[]=new boolean[m];
      boolean cmp=false ;
      judge[0]=true ;
      for(int i=0 ; i<n ; i++){
        sorax[i]=in.nextInt();
        soray[i]=in.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        int toX=sorax[i]-tx[0];
        int toY=soray[i]-ty[0];
        Arrays.fill(judge,false);
        cmp=true ;
        judge[0]=true ;
        for(int j=1 ; j<m ; j++){
          int nx=tx[j]+toX ;
          int ny=ty[j]+toY ;
          for(int k=0 ; k<n ; k++){
            if(nx==sorax[k] && ny==soray[k]){
              judge[j]=true ;
              break ;
            }
          }
        }
        for(int j=0 ; j<m ; j++){
          if(! judge[j]){
            cmp=false ;
            break ;
          }
        }
        if(cmp){
          System.out.println(toX+" "+toY);
          break ;
        }
      }
    }
  }
  static public void debug(Object...o){
    System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var m : int ; m := in.getCurrent()->toInteger() ;
     if (m = 0) then     return else skip ; 
    var tx : Sequence(int) ; tx := Integer.subrange(1,m)->collect(0) ;
    var ty : Sequence(int) ; ty := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     tx[i+1] := in.getCurrent()->toInteger() ; 
     ty[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var n : int ; n := in.getCurrent()->toInteger() ;
    var sorax : Sequence(int) ; sorax := Integer.subrange(1,n)->collect(0) ;
    var soray : Sequence(int) ; soray := Integer.subrange(1,n)->collect(0) ;
    var judge : Sequence(boolean) ; judge := Integer.subrange(1,m)->collect(false) ;
    var cmp : boolean ; cmp := false ;
    judge[0+1] := true ; 
        var i : int ; i := 0 ; while i < n do ( (     sorax[i+1] := in.getCurrent()->toInteger() ; 
     soray[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var toX : int ; toX := sorax[i+1] - tx[0+1] ;
     var toY : int ; toY := soray[i+1] - ty[0+1] ;
    judge := judge->collect(false) ; 
    cmp := true ; 
    judge[0+1] := true ; 
        var j : int ; j := 1 ; while j < m do ( (     var nx : int ; nx := tx[j+1] + toX ;
     var ny : int ; ny := ty[j+1] + toY ;
         var k : int ; k := 0 ; while k < n do ( (     if (nx = sorax[k+1] & ny = soray[k+1]) then (     judge[j+1] := true ; 
     break ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < m do ( (     if (not(judge[j+1])) then (     cmp := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (cmp) then (     OclFile["System.out"].println(toX + " " + toY) ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
 )  ) );
  static    operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    while(true){
      int M=sc.nextInt();
      if(M==0)break ;
      int[] xm=new int[M];
      int[] ym=new int[M];
      for(int i=0 ; i<M ; ++i){
        xm[i]=sc.nextInt();
        ym[i]=sc.nextInt();
      }
      int N=sc.nextInt();
      int[] xn=new int[N];
      int[] yn=new int[N];
      HashSet<Point>ps=new HashSet<Point>();
      for(int i=0 ; i<N ; ++i){
        xn[i]=sc.nextInt();
        yn[i]=sc.nextInt();
        ps.add(new Point(xn[i],yn[i]));
      }
      for(int i=0 ; i<N ; ++i){
        int dx=xn[i]-xm[0];
        int dy=yn[i]-ym[0];
        boolean ok=true ;
        for(int j=0 ; j<M ; ++j){
          if(! ps.contains(new Point(xm[j]+dx,ym[j]+dy))){
            ok=false ;
            break ;
          }
        }
        if(ok){
          System.out.println(dx+" "+dy);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var M : int ; M := sc.getCurrent()->toInteger() ;
     if (M = 0) then     break else skip ; 
    var xm : Sequence(int) ; xm := Integer.subrange(1,M)->collect(0) ;
    var ym : Sequence(int) ; ym := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     xm[i+1] := sc.getCurrent()->toInteger() ; 
     ym[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var xn : Sequence(int) ; xn := Integer.subrange(1,N)->collect(0) ;
    var yn : Sequence(int) ; yn := Integer.subrange(1,N)->collect(0) ;
    var ps : Set(Point) ; ps := Set{} ;
        var i : int ; i := 0 ; while i < N do ( (     xn[i+1] := sc.getCurrent()->toInteger() ; 
     yn[i+1] := sc.getCurrent()->toInteger() ; 
     ps := ps->including(Point.newPoint(xn[i+1], yn[i+1])) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var dx : int ; dx := xn[i+1] - xm[0+1] ;
     var dy : int ; dy := yn[i+1] - ym[0+1] ;
    var ok : boolean ; ok := true ;
        var j : int ; j := 0 ; while j < M do ( (     if (not(ps->includes(Point.newPoint(xm[j+1] + dx, ym[j+1] + dy)))) then (     ok := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (ok) then (     OclFile["System.out"].println(dx + " " + dy) ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findPrevious(char[] number,int n){
    int i,j ;
    for(i=n-1 ; i>0 ; i--){
      if(number[i]<number[i-1]){
        break ;
      }
    }
    if(i==0){
      System.out.print("Previous number is not possible");
      return ;
    }
    int x=number[i-1],greatest=i ;
    for(j=i ; j<n ; j++){
      if(number[j]<x && number[j]>number[greatest]){
        greatest=j ;
      }
    }
    swap(number,greatest,i-1);
    Arrays.sort(number,i,n);
    reverse(number,i,n-1);
    System.out.print("Greatest smaller number with"+"same set of digits is "+String.valueOf(number));
    return ;
  }
  static String swap(char[] ch,int i,int j){
    char temp=ch[i];
    ch[i]=ch[j];
    ch[j]=temp ;
    return String.valueOf(ch);
  }
  static void reverse(char str[],int start,int end){
    char temp ;
    while(start<=end){
      temp=str[start];
      str[start]=str[end];
      str[end]=temp ;
      start++;
      end--;
    }
  }
  public static void main(String[] args){
    String digits="262345" ;
    int n=digits.length();
    findPrevious(digits.toCharArray(),n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findPrevious( number : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := n - 1 ; while i > 0 do ( (     if (number[i+1] < number[i - 1+1]) then (     break ) else skip )  ;     i := i - 1 ) ; 
    if (i = 0) then (     OclFile["System.out"].print("Previous number is not possible") ; 
     return ) else skip ; 
    var x : int ; x := number[i - 1+1] ;
    var greatest : int ; greatest := i ;
        j := i ; while j < n do ( (     if (number[j+1] < x & number[j+1] > number[greatest+1]) then (     greatest := j ) else skip )  ;     j := j + 1 ) ; 
    execute swap(number, greatest, i - 1) ; 
    number := number.subrange(1,i)^(number.subrange(i+1,n)->sort())^number.subrange(n+1,number.size) ; 
    execute reverse(number, i, n - 1) ; 
    OclFile["System.out"].print("Greatest smaller number with" + "same set of digits is " + ((number) + "")) ; 
    return 
 );
  static   operation swap( ch : Sequence(String), i : int, j : int) : String
  pre: true
  post: true
  activity: (     var temp : String ; temp := ch[i+1] ;
     ch[i+1] := ch[j+1] ; 
     ch[j+1] := temp ; 
     return ((ch) + "") );
  static   operation reverse( str : Sequence(String), start : int, end : int) : void
  pre: true
  post: true
  activity: (     var temp : String ;
     while (start <= end) do (     temp := str[start+1] ; 
     str[start+1] := str[end+1] ; 
    str[end+1] := temp ; 
    start := start + 1 ; 
    end := end - 1 ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var digits : String ; digits := "262345" ;
     var n : int ; n := digits->size() ;
     execute findPrevious(digits->characters(), n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.nio.charset.MalformedInputException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int x=sc.nextInt(),y=sc.nextInt();
      if(Math.abs(x+y)% 2!=0){
        out.println(-1+" "+-1);
      }
      else {
        if(x>=y){
          out.println((x+y)/2+" 0");
        }
        else {
          out.println("0 "+(x+y)/2);
        }
      }
    }
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
     if (if x + y < 0 then -(x + y) else x + y endif mod 2 /= 0) then (     skip ) else (     if (x >= y) then (     skip ) else (     skip ) ) ) ;  ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countSubarrWithEqualZeroAndOne(int arr[],int n){
    Map<Integer,Integer>um=new HashMap<>();
    int curr_sum=0 ;
    for(int i=0 ; i<n ; i++){
      curr_sum+=(arr[i]==0)?-1 : arr[i];
      um.put(curr_sum,um.get(curr_sum)==null ? 1 : um.get(curr_sum)+1);
    }
    int count=0 ;
    for(Map.Entry<Integer,Integer>itr : um.entrySet()){
      if(itr.getValue()>1)count+=((itr.getValue()*(itr.getValue()-1))/2);
    }
    if(um.containsKey(0))count+=um.get(0);
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      1,0,0,1,0,1,1 };
      int n=arr.length ;
      System.out.println("Count="+countSubarrWithEqualZeroAndOne(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSubarrWithEqualZeroAndOne( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var um : Map(int,int) ; um := Map{} ;
     var curr_sum : int ; curr_sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     curr_sum := curr_sum+(if (arr[i+1] = 0) then -1 else arr[i+1] endif) ; 
     um := um->union(Map{curr_sum |-> if um->at(curr_sum) = null then 1 else um->at(curr_sum) + 1 endif}) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    for (itr : um->asSet()) do ( (     if (itr.getValue() > 1) then     count := count+(((itr.getValue() * (itr.getValue() - 1)) / 2)) ; else skip )  ) ; 
    if (um->keys()->includes(0)) then     count := count+(um->at(0)) ; else skip ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,0,0,1,0,1,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Count=" + countSubarrWithEqualZeroAndOne(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    System.out.println(solution(n));
  }
  public static int solution(int n){
    HashMap<Integer,Integer>map=new HashMap<>();
    for(int i=2 ; i<10 ; i++){
      map.put(i,4);
    }
    map.put(1,4);
    map.put(10,15);
    map.put(11,4);
    int res=0 ;
    int num=n-10 ;
    if(num>0){
      for(Integer integer : map.keySet()){
        if(integer==num){
          return map.get(integer);
        }
      }
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solution(n)) );
  static   operation solution( n : int) : int
  pre: true
  post: true
  activity: (     var map : Map(int,int) ; map := Map{} ;
         var i : int ; i := 2 ; while i < 10 do ( (     map := map->union(Map{i |-> 4}) )  ;     i := i + 1 ) ; 
    map := map->union(Map{1 |-> 4}) ; 
    map := map->union(Map{10 |-> 15}) ; 
    map := map->union(Map{11 |-> 4}) ; 
    var res : int ; res := 0 ;
    var num : int ; num := n - 10 ;
    if (num > 0) then (     for (integer : map->keys()) do ( (     if (integer = num) then (     return map->at(integer) ) else skip )  ) ) else skip ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int ts=sc.nextInt();
    int x=ts-10 ;
    int count=0 ;
    if(x>=2 && x<=9)count+=4 ;
    else if(x==10)count+=4+4+4+3 ;
    else if(x==11 || x==1)count+=4 ;
    else count=0 ;
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ts : int ; ts := sc.getCurrent()->toInteger() ;
    var x : int ; x := ts - 10 ;
    var count : int ; count := 0 ;
    if (x >= 2 & x <= 9) then     count := count+(4) else     if (x = 10) then     count := count+(4 + 4 + 4 + 3) else     if (x = 11 or x = 1) then     count := count+(4) else     count := 0 ; ;  ;  ;  
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    if(n<=10 || n>21){
      System.out.println(0);
      return ;
    }
    int remain=n-10 ;
    int ans=0 ;
    if(remain==10){
      ans+=3 ;
      ans+=3*4 ;
    }
    else {
      ans+=4 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    if (n <= 10 or n > 21) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var remain : int ; remain := n - 10 ;
    var ans : int ; ans := 0 ;
    if (remain = 10) then (     ans := ans+(3) ; 
     ans := ans+(3 * 4) ) else (     ans := ans+(4) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int[] nums={
      0,4,4,4,4,4,4,4,4,4,15,4 };
      Scanner scanner=new Scanner(System.in);
      while(scanner.hasNext()){
        int num=scanner.nextInt();
        if(num<=10 || num>21){
          System.out.println(0);
        }
        else {
          System.out.println(nums[num-10]);
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var nums : Sequence(int) ; nums := Sequence{0,4,4,4,4,4,4,4,4,4,15,4} ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scanner.hasNext()) do (     var num : int ; num := scanner.getCurrent()->toInteger() ;
     if (num <= 10 or num > 21) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(nums[num - 10+1]) ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  private static class FastScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public FastScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
      tokenizer=null ;
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          return reader.readLine();
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken("\n");
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public int[] nextIntArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    public long[] nextLongArray(int n){
      long[] a=new long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
  }
  public static void main(String[] args){
    FastScanner sc=new FastScanner(System.in);
    int h=sc.nextInt();
    int a=sc.nextInt();
    System.out.println(h % a==0 ? h/a : h/a+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.nextToken("\n") );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var h : int ; h := sc.nextInt() ;
     var a : int ; a := sc.nextInt() ;
     OclFile["System.out"].println(if h mod a = 0 then h / a else h / a + 1 endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.pow ;
class Test {
  static int sumOfTermsInNthRow(int n){
    int sum=(int)(n*(2*pow(n,2)+1));
    return sum ;
  }
  public static void main(String args[]){
    int n=4 ;
    System.out.println("Sum of all the terms in nth row="+sumOfTermsInNthRow(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation sumOfTermsInNthRow( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := (n * (2 * pow(n, 2) + 1))->oclAsType(int) ;
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println("Sum of all the terms in nth row=" + sumOfTermsInNthRow(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int lagDuration(int h1,int m1,int h2,int m2,int k){
    int lag,t1,t2 ;
    t1=(h1+k)*60+m1 ;
    t2=h2*60+m2 ;
    lag=t1-t2 ;
    return lag ;
  }
  public static void main(String args[]){
    int h1=12,m1=0 ;
    int h2=12,m2=58 ;
    int k=1 ;
    int lag=lagDuration(h1,m1,h2,m2,k);
    System.out.println("Lag="+lag+" minutes");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation lagDuration( h1 : int, m1 : int, h2 : int, m2 : int, k : int) : int
  pre: true
  post: true
  activity: (     var lag : int ;
    var t1 : int ;
    var t2 : int ;
     t1 := (h1 + k) * 60 + m1 ; 
    t2 := h2 * 60 + m2 ; 
    lag := t1 - t2 ; 
    return lag 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var h1 : int ; h1 := 12 ;
    var m1 : int ; m1 := 0 ;
     var h2 : int ; h2 := 12 ;
    var m2 : int ; m2 := 58 ;
    var k : int ; k := 1 ;
    var lag : int ; lag := lagDuration(h1, m1, h2, m2, k) ;
    OclFile["System.out"].println("Lag=" + lag + " minutes") ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.*;
public class Main {
  static int INF=1000000000 ;
  static int MAXN=31 ;
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[][] point=new int[n][2];
    for(int i=0 ; i<n ; ++i){
      point[i][0]=input.nextInt();
      point[i][1]=input.nextInt();
    }
    int q=input.nextInt();
    for(int i=0 ; i<q ; ++i){
      int x,y ;
      x=input.nextInt();
      y=input.nextInt();
      System.out.println(checkWithPolygon(x,y,point));
    }
  }
  static int checkWithPolygon(int x,int y,int[][] pol){
    boolean check=false ;
    for(int i=0 ; i<pol.length ; ++i){
      int ax=pol[i][0]-x,ay=pol[i][1]-y ;
      int bx=pol[(i+1)% pol.length][0]-x,by=pol[(i+1)% pol.length][1]-y ;
      if(ay>by){
        int temp=ax ;
        ax=bx ;
        bx=temp ;
        temp=ay ;
        ay=by ;
        by=temp ;
      }
      if(ay<=0 && by>0 && cross(ax,ay,bx,by)<0)check=! check ;
      if(cross(ax,ay,bx,by)==0 && dot(ax,ay,bx,by)<=0)return 1 ;
    }
    return check ? 2 : 0 ;
  }
  static int cross(int ax,int ay,int bx,int by){
    return ax*by-ay*bx ;
  }
  static int dot(int ax,int ay,int bx,int by){
    return ax*bx+ay*by ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute INF : int := 1000000000;
  static   attribute MAXN : int := 31;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var point : Sequence(Sequence(int)) ; point := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     point[i+1][0+1] := input.getCurrent()->toInteger() ; 
     point[i+1][1+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var q : int ; q := input.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var x : int ;
    var y : int ;
     x := input.getCurrent()->toInteger() ; 
     y := input.getCurrent()->toInteger() ; 
     OclFile["System.out"].println(checkWithPolygon(x, y, point)) )  ;     i := i + 1 ) ; 
 );
  static   operation checkWithPolygon( x : int, y : int, pol : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var check : boolean ; check := false ;
         var i : int ; i := 0 ; while i < pol->size() do ( (     var ax : int ; ax := pol[i+1][0+1] - x ;
    var ay : int ; ay := pol[i+1][1+1] - y ;
     var bx : int ; bx := pol[(i + 1) mod pol->size()+1][0+1] - x ;
    var by : int ; by := pol[(i + 1) mod pol->size()+1][1+1] - y ;
    if (ay > by) then (     var temp : int ; temp := ax ;
     ax := bx ; 
    bx := temp ; 
    temp := ay ; 
    ay := by ; 
    by := temp ; 
 ) else skip ; 
    if (ay <= 0 & by > 0 & cross(ax, ay, bx, by) < 0) then     check := not(check) ; else skip ; 
    if (cross(ax, ay, bx, by) = 0 & dot(ax, ay, bx, by) <= 0) then     return 1 else skip ; 
 )  ;     i := i + 1 ) ; 
     return if check then 2 else 0 endif );
  static   operation cross( ax : int, ay : int, bx : int, by : int) : int
  pre: true
  post: true
  activity: (     return ax * by - ay * bx );
  static   operation dot( ax : int, ay : int, bx : int, by : int) : int
  pre: true
  post: true
  activity: (     return ax * bx + ay * by );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void main(String args[]){
    int n=5 ;
    int a[][]={
      {
        1,2,3,4,5 },{
          5,6,7,8,6 },{
            9,5,6,8,7 },{
              2,3,5,6,8 },{
                1,2,3,4,5 }
              };
              int convergingele,mid ;
              int i,j ;
              if(n % 2==0){
                System.out.printf("NULL\n");
              }
              else {
                mid=n/2 ;
                convergingele=a[mid][mid];
                System.out.printf("%d\n",convergingele);
              }
            }
          }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var a : Sequence(Sequence(int)) ; a := Sequence{Sequence{1,2,3,4,5},Sequence{5,6,7,8,6},Sequence{9,5,6,8,7},Sequence{2,3,5,6,8},Sequence{1,2,3,4,5}} ;
    var convergingele : int ;
    var mid : int ;
    var i : int ;
    var j : int ;
    if (n mod 2 = 0) then (     OclFile["System.out"].printf("NULL\n") ) else (     mid := n / 2 ; 
     convergingele := a[mid+1][mid+1] ; 
     OclFile["System.out"].printf("%d\n", convergingele) ) ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.Reader ;
import java.util.StringTokenizer ;
public class Main {
  public Main(){
    FastScanner input=new FastScanner(System.in);
    StringBuilder output=new StringBuilder();
    int t=input.nextInt();
    for(int i=0 ; i<t ; i++){
      int x=input.nextInt();
      int y=input.nextInt();
      int distance=x+y ;
      if(distance % 2==1){
        output.append(-1+" "+-1);
      }
      else {
        if(x % 2==1){
          x++;
        }
        output.append(x/2+" "+y/2);
      }
      output.append("\n");
    }
    System.out.println(output);
  }
  public static void main(String[] args){
    new Main();
  }
  class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(Reader in){
      br=new BufferedReader(in);
    }
    public FastScanner(InputStream in){
      this(new InputStreamReader(in));
    }
    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 long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var output : String ; output := StringLib.newString() ;
    var t : int ; t := input.nextInt() ;
        var i : int ; i := 0 ; while i < t do ( (     var x : int ; x := input.nextInt() ;
     var y : int ; y := input.nextInt() ;
    var distance : int ; distance := x + y ;
    if (distance mod 2 = 1) then (     output := output + StringLib.newString(-1 + " " + -1) ) else (     if (x mod 2 = 1) then (     x := x + 1 ) else skip ; 
     output := output + StringLib.newString(x / 2 + " " + y / 2) ) ;  
    output := output + StringLib.newString("\n") ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(output) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
 class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(in) );
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     execute this(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int[] kWeakestRows(int[][] mat,int k){
    List<Integer>res=new ArrayList<>();
    int col=0 ;
    boolean flag=true ;
    while(col<mat[0] .length && flag){
      for(int i=0 ; i<mat.length ; i++){
        if(res.contains(i))continue ;
        if(mat[i][col]==0)res.add(i);
        if(res.size()==k){
          flag=false ;
          break ;
        }
      }
      col+=1 ;
    }
    if(flag){
      for(int i=0 ; i<mat.length ; i++){
        if(res.contains(i))continue ;
        res.add(i);
        if(res.size()==k)break ;
      }
    }
    int[] ret=new int[k];
    for(int i=0 ; i<k ; i++)ret[i]=res.get(i);
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation kWeakestRows( mat : Sequence(Sequence(int)), k : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Sequence{} ;
     var col : int ; col := 0 ;
    var flag : boolean ; flag := true ;
    while (col < mat[0+1]->size() & flag) do (         var i : int ; i := 0 ; while i < mat->size() do ( (     if (res->includes(i)) then     continue else skip ; 
     if (mat[i+1][col+1] = 0) then     res := res->including(i) ; else skip ; 
     if (res->size() = k) then (     flag := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     col := col+(1) ) ; 
    if (flag) then (         var i : int ; i := 0 ; while i < mat->size() do ( (     if (res->includes(i)) then     continue else skip ; 
     res := res->including(i) ; 
     if (res->size() = k) then     break else skip )  ;     i := i + 1 ) ) else skip ; 
    var ret : Sequence(int) ; ret := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do (     ret[i+1] := res->at(i+1) ;  ;     i := i + 1 ) ; 
    return ret 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static int count(String s,char value){
    int cnt=0 ;
    for(int i=0 ; i<s.length(); i++)if(s.charAt(i)==value)cnt++;
    return cnt ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int od=0,ev=0 ;
    int[] lst=new int[n];
    for(int i=0 ; i<n ; i++){
      lst[i]=sc.nextInt();
      if(lst[i] % 2==1)od++;
      else ev++;
    }
    int k=Math.abs(od-ev)-1 ;
    if(k<=0)System.out.println(0);
    else {
      Arrays.sort(lst);
      int p,res=0 ;
      if(od>ev)p=1 ;
      else p=0 ;
      for(int i=0 ; i<n ; i++){
        if(lst[i] % 2==p){
          res+=lst[i];
          k--;
        }
        if(k==0)break ;
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation count( s : String, value : String) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < s->size() do (     if (s->at(i+1) = value) then     cnt := cnt + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var od : int ; od := 0 ;
    var ev : int ; ev := 0 ;
    var lst : Sequence(int) ; lst := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     lst[i+1] := sc.getCurrent()->toInteger() ; 
     if (lst[i+1] mod 2 = 1) then     od := od + 1 ; else     ev := ev + 1 ; )  ;     i := i + 1 ) ; 
    var k : int ; k := if od - ev < 0 then -(od - ev) else od - ev endif - 1 ;
    if (k <= 0) then     OclFile["System.out"].println(0) else (     lst := lst->sort() ; 
     var p : int ;
    var res : int ; res := 0 ;
    if (od > ev) then     p := 1 else     p := 0 ; ;  
        var i : int ; i := 0 ; while i < n do ( (     if (lst[i+1] mod 2 = p) then (     res := res+(lst[i+1]) ; 
     k := k - 1 ) else skip ; 
     if (k = 0) then     break else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<a.length ; i++){
      a[i]=sc.nextInt();
    }
    System.out.println(solve(a));
    sc.close();
  }
  static int solve(int[] a){
    List<Integer>evens=new ArrayList<>();
    List<Integer>odds=new ArrayList<>();
    for(int ai : a){
      if(ai % 2==0){
        evens.add(ai);
      }
      else {
        odds.add(ai);
      }
    }
    int commonSize=Math.min(evens.size(),odds.size());
    return computeMinSum(evens,evens.size()-commonSize-1)+computeMinSum(odds,odds.size()-commonSize-1);
  }
  static int computeMinSum(List<Integer>numbers,int limitSize){
    return numbers.stream().mapToInt(x->x).sorted().limit(Math.max(0,limitSize)).sum();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(a)) ; 
    skip ; 
 );
  static   operation solve( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var evens : Sequence(int) ; evens := Sequence{} ;
     var odds : Sequence(int) ; odds := Sequence{} ;
    for (ai : a) do ( (     if (ai mod 2 = 0) then (     evens := evens->including(ai) ) else (     odds := odds->including(ai) ) )  ) ; 
    var commonSize : int ; commonSize := Set{evens->size(), odds->size()}->min() ;
    return computeMinSum(evens, evens->size() - commonSize - 1) + computeMinSum(odds, odds->size() - commonSize - 1) 
 );
  static   operation computeMinSum( numbers : Sequence(int), limitSize : int) : int
  pre: true
  post: true
  activity: (     return numbers->collect( _x1 | (lambda x : OclAny in x)->apply(_x1) )->sort().subrange(1,Set{0, limitSize}->max())->sum() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemD {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    String line[]=br.readLine().split(" ");
    int arr[]=new int[n];
    ArrayList<Integer>odd=new ArrayList<>();
    ArrayList<Integer>even=new ArrayList<>();
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(line[i]);
      if(arr[i] % 2==0)even.add(arr[i]);
      else odd.add(arr[i]);
      sum+=arr[i];
    }
    Collections.sort(odd);
    Collections.sort(even);
    int size=Math.min(odd.size(),even.size());
    long summ=0 ;
    for(int i=0 ; i<size+1 ; i++){
      if(odd.size()-1-i>=0)summ+=odd.get(odd.size()-1-i);
      if(even.size()-1-i>=0)summ+=even.get(even.size()-1-i);
    }
    System.out.println(sum-summ);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemD {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var odd : Sequence(int) ; odd := Sequence{} ;
    var even : Sequence(int) ; even := Sequence{} ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (line[i+1])->toInteger() ; 
     if (arr[i+1] mod 2 = 0) then     even := even->including(arr[i+1]) else     odd := odd->including(arr[i+1]) ; ;  
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    odd := odd->sort() ; 
    even := even->sort() ; 
    var size : int ; size := Set{odd->size(), even->size()}->min() ;
    var summ : long ; summ := 0 ;
        var i : int ; i := 0 ; while i < size + 1 do ( (     if (odd->size() - 1 - i >= 0) then     summ := summ+(odd->at(odd->size() - 1 - i+1)) ; else skip ; 
     if (even->size() - 1 - i >= 0) then     summ := summ+(even->at(even->size() - 1 - i+1)) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum - summ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  void solve(InputReader in,PrintWriter out){
    int H=in.nextInt();
    int A=in.nextInt();
    int ans=H/A ;
    if(H % A!=0)++ans ;
    out.println(ans);
  }
  public static void main(String[] args)throws Exception {
    InputReader in=new InputReader(System.in);
    PrintWriter out=new PrintWriter(System.out);
    Main solver=new Main();
    solver.solve(in,out);
    out.close();
  }
  static class InputReader {
    BufferedReader in ;
    StringTokenizer st ;
    public InputReader(InputStream is){
      in=new BufferedReader(new InputStreamReader(is));
    }
    public String next(){
      try {
        while(st==null || ! st.hasMoreTokens()){
          st=new StringTokenizer(in.readLine());
        }
        return st.nextToken();
      }
      catch(Exception e){
        throw new RuntimeException(e);
      }
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var H : int ; H := in.nextInt() ;
     var A : int ; A := in.nextInt() ;
    var ans : int ; ans := H / A ;
    if (H mod A /= 0) then     ans := ans + 1 ; else skip ; 
    out.println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : InputReader ; in := InputReader.newInputReader(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var solver : Main ; solver := Main.newMain() ;
    solver.solve(in, out) ; 
    skip ; 
 );
  static class InputReader {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newInputReader( is : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return st.next() )   catch (e : ProgramException) do (     error ProgramException(e) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int substrDeletion(String str,int len){
    int count0=0,count1=0 ;
    for(int i=0 ; i<len ; i++){
      if(str.charAt(i)=='0')count0++;
      else count1++;
    }
    return Math.min(count0,count1);
  }
  public static void main(String[] args){
    String str="010" ;
    int len=str.length();
    System.out.println(substrDeletion(str,len));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation substrDeletion( str : String, len : int) : int
  pre: true
  post: true
  activity: (     var count0 : int ; count0 := 0 ;
    var count1 : int ; count1 := 0 ;
         var i : int ; i := 0 ; while i < len do ( (     if (str->at(i+1) = '0') then     count0 := count0 + 1 ; else     count1 := count1 + 1 ; )  ;     i := i + 1 ) ; 
     return Set{count0, count1}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "010" ;
     var len : int ; len := str->size() ;
     OclFile["System.out"].println(substrDeletion(str, len)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countWays(int n,int arr[],int len){
    if(n==0)return 1 ;
    int no_ways=0 ;
    for(int i=0 ; i<len ; i++){
      if(n-arr[i]>=0){
        no_ways+=countWays(n-arr[i],arr,len);
      }
    }
    return no_ways ;
  }
  public static void main(String args[]){
    int arr[]={
      1,3,5 };
      int len=arr.length ;
      ;
      int n=5 ;
      System.out.println(countWays(n,arr,len));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countWays( n : int, arr : Sequence(int), len : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     var no_ways : int ; no_ways := 0 ;
         var i : int ; i := 0 ; while i < len do ( (     if (n - arr[i+1] >= 0) then (     no_ways := no_ways+(countWays(n - arr[i+1], arr, len)) ) else skip )  ;     i := i + 1 ) ; 
     return no_ways );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,5} ;
     var len : int ; len := arr->size() ;
    var n : int ; n := 5 ;
    OclFile["System.out"].println(countWays(n, arr, len)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printNcR(int n,int r){
    long p=1,k=1 ;
    if(n-r<r){
      r=n-r ;
    }
    if(r!=0){
      while(r>0){
        p*=n ;
        k*=r ;
        long m=__gcd(p,k);
        p/=m ;
        k/=m ;
        n--;
        r--;
      }
    }
    else {
      p=1 ;
    }
    System.out.println(p);
  }
  static long __gcd(long n1,long n2){
    long gcd=1 ;
    for(int i=1 ; i<=n1 && i<=n2 ; ++i){
      if(n1 % i==0 && n2 % i==0){
        gcd=i ;
      }
    }
    return gcd ;
  }
  public static void main(String[] args){
    int n=50,r=25 ;
    printNcR(n,r);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printNcR( n : int, r : int) : void
  pre: true
  post: true
  activity: (     var p : long ; p := 1 ;
    var k : long ; k := 1 ;
     if (n - r < r) then (     r := n - r ) else skip ; 
     if (r /= 0) then (     while (r > 0) do (     p := p*(n) ; 
     k := k*(r) ; 
    var m : long ; m := __gcd(p, k) ;
    p := p/(m) ; 
    k := k/(m) ; 
    n := n - 1 ; 
    r := r - 1 ; 
 ) ) else (     p := 1 ) ;  
     OclFile["System.out"].println(p) );
  static   operation __gcd( n1 : long, n2 : long) : long
  pre: true
  post: true
  activity: (     var gcd : long ; gcd := 1 ;
         var i : int ; i := 1 ; while i <= n1 & i <= n2 do ( (     if (n1 mod i = 0 & n2 mod i = 0) then (     gcd := i ) else skip )  ;     i := i + 1 ) ; 
     return gcd );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 50 ;
    var r : int ; r := 25 ;
     execute printNcR(n, r) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication90 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    boolean is=true ;
    int last=0 ;
    int counter=0 ;
    while(is){
      int i=s.indexOf("bear",last);
      if(i==-1){
        is=false ;
        System.out.println(counter);
      }
      i+=3 ;
      last++;
      counter+=(s.length()-i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication90 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var is : boolean ; is := true ;
    var last : int ; last := 0 ;
    var counter : int ; counter := 0 ;
    while (is) do (     var i : int ; i := s.subrange(last+1)->indexOf("bear"+"") + last - 1  ;
     if (i = -1) then (     is := false ; 
     OclFile["System.out"].println(counter) ) else skip ; 
    i := i+(3) ; 
    last := last + 1 ; 
    counter := counter+((s->size() - i)) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class App {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    ArrayList<Integer>bIndex=new ArrayList<>();
    for(int i=0 ; i<s.length()-3 ; i++){
      String word=s.substring(i,i+4);
      if(word.equals("bear")){
        bIndex.add(i+1);
      }
    }
    int x=1,ans=0 ;
    for(int i=0 ; i<bIndex.size(); i++){
      int y=s.length()-bIndex.get(i)-2 ;
      if(i>0){
        x=bIndex.get(i-1)+1 ;
      }
      x=bIndex.get(i)-x+1 ;
      ans+=x*y ;
    }
    System.out.println(ans);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
    var bIndex : Sequence(int) ; bIndex := Sequence{} ;
        var i : int ; i := 0 ; while i < s->size() - 3 do ( (     var word : String ; word := s.subrange(i+1,i + 4) ;
     if (word = "bear") then (     bIndex := bIndex->including(i + 1) ) else skip )  ;     i := i + 1 ) ; 
    var x : int ; x := 1 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < bIndex->size() do ( (     var y : int ; y := s->size() - bIndex->at(i+1) - 2 ;
     if (i > 0) then (     x := bIndex->at(i - 1+1) + 1 ) else skip ; 
     x := bIndex->at(i+1) - (x)->char2byte() + 1 ; 
     ans := ans+(x * y) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class OddAndEnds_849A {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    int length=scanner.nextInt();
    int[] sequence=new int[length];
    for(int i=0 ; i<length ; i++){
      sequence[i]=scanner.nextInt();
    }
    if(IsOdd(sequence[0])&& IsOdd(sequence[length-1])&& IsOdd(length)){
      System.out.println("Yes");
    }
    else System.out.println("No");
  }
  public static boolean IsOdd(int number){
    return !(number % 2==0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class OddAndEnds_849A {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var length : int ; length := scanner.getCurrent()->toInteger() ;
     var sequence : Sequence(int) ; sequence := Integer.subrange(1,length)->collect(0) ;
         var i : int ; i := 0 ; while i < length do ( (     sequence[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     if (IsOdd(sequence[0+1]) & IsOdd(sequence[length - 1+1]) & IsOdd(length)) then (     OclFile["System.out"].println("Yes") ) else     OclFile["System.out"].println("No") ; );
  static   operation IsOdd( number : int) : boolean
  pre: true
  post: true
  activity: (     return not((number mod 2 = 0)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    Scanner sc=new Scanner(systemin);
    int N=sc.nextInt();
    Set<Integer>set=new HashSet<>();
    for(int i=0 ; i<N ; i++){
      int a=sc.nextInt();
      set.add(a);
    }
    result.printf("%d\n",set.size());
    sc.close();
    return false ;
  }
  PrintStream log ;
  PrintStream result=System.out ;
  BufferedReader systemin ;
  static Main instance=new Main();
  Main(){
    systemin=new BufferedReader(new InputStreamReader(System.in));
    log=new PrintStream(new OutputStream(){
      public void write(int b){
      }
    }
);
  }
  public static void main(String[] args)throws IOException {
    instance.main();
    instance.systemin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(systemin) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     set := set->including(a) )  ;     i := i + 1 ) ; 
    result.printf("%d\n", set->size()) ; 
    skip ; 
    return false 
 );
   attribute log : OclFile;
   attribute result : OclFile := OclFile["System.out"];
   attribute systemin : OclFile;
  static   attribute instance : Main := Main.newMain();
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     systemin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     log := OclFile.newOclFile_Write(OclFile()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     instance.main() ; 
     instance.systemin.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=in.nextInt();
    if(solve(a,n))pw.println("YES");
    else pw.println("NO");
    pw.close();
  }
  static boolean solve(int[] a,int n){
    if(n % 2!=0 && a[0] % 2!=0 && a[n-1] % 2!=0)return true ;
    return false ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    if (solve(a, n)) then     skip else     skip ; ;  
    skip ; 
 );
  static   operation solve( a : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     if (n mod 2 /= 0 & a[0+1] mod 2 /= 0 & a[n - 1+1] mod 2 /= 0) then     return true else skip ; 
     return false );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ProblemA {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int[] array=new int[n];
    for(int i=0 ; i<n ; i++){
      array[i]=s.nextInt();
    }
    if(n % 2==0){
      System.out.println("No");
    }
    else if(array[0] % 2==0 || array[n-1] % 2==0){
      System.out.println("NO");
    }
    else {
      System.out.println("Yes");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (n mod 2 = 0) then (     OclFile["System.out"].println("No") ) else     if (array[0+1] mod 2 = 0 or array[n - 1+1] mod 2 = 0) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("Yes") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class OddsAndEnds {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    boolean c1=false,c2=false,c3=false ;
    for(int i=1 ; i<=n ; i++){
      int x=sc.nextInt();
      if(i==1)c1=(x & 1)!=0 ;
      if(i==n)c2=(x & 1)!=0 ;
    }
    c3=(n & 1)!=0 ;
    if(c1 && c2 && c3)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class OddsAndEnds {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c1 : boolean ; c1 := false ;
    var c2 : boolean ; c2 := false ;
    var c3 : boolean ; c3 := false ;
        var i : int ; i := 1 ; while i <= n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (i = 1) then     c1 := (MathLib.bitwiseAnd(x,1)) /= 0 ; else skip ; 
     if (i = n) then     c2 := (MathLib.bitwiseAnd(x,1)) /= 0 ; else skip )  ;     i := i + 1 ) ; 
    c3 := (MathLib.bitwiseAnd(n,1)) /= 0 ; 
    if (c1 & c2 & c3) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String[] str=in.readLine().split(" ");
    int h=Integer.parseInt(str[0]);
    int a=Integer.parseInt(str[1]);
    int num=0 ;
    for(int i=1 ; h>0 ; i++){
      h=h-a ;
      num++;
    }
    System.out.println(num);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := in.readLine()->split(" ") ;
    var h : int ; h := (str[0+1])->toInteger() ;
    var a : int ; a := (str[1+1])->toInteger() ;
    var num : int ; num := 0 ;
        var i : int ; i := 1 ; while h > 0 do ( (     h := h - a ; 
     num := num + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(num) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  static int MAX=3000 ;
  public static int smartNumber(int n){
    Integer[] primes=new Integer[MAX];
    Arrays.fill(primes,new Integer(0));
    Vector<Integer>result=new Vector<>();
    for(int i=2 ; i<MAX ; i++){
      if(primes[i]==0){
        primes[i]=1 ;
        for(int j=i*2 ; j<MAX ; j=j+i){
          primes[j]-=1 ;
          if((primes[j]+3)==0)result.add(j);
        }
      }
    }
    Collections.sort(result);
    return result.get(n-1);
  }
  public static void main(String[] args){
    int n=50 ;
    System.out.println(smartNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 3000;
  static   operation smartNumber( n : int) : int
  pre: true
  post: true
  activity: (     var primes : Sequence(int) ; primes := Integer.subrange(1,MAX)->collect(null) ;
     primes := primes->collect(("" + (0))->toInteger()) ; 
    var result : Sequence(int) ; result := Sequence{} ;
        var i : int ; i := 2 ; while i < MAX do ( (     if (primes[i+1] = 0) then (     primes[i+1] := 1 ; 
         var j : int ; j := i * 2 ; while j < MAX do ( (     primes[j+1] := primes[j+1]-(1) ; 
     if ((primes[j+1] + 3) = 0) then     result := result->including(j) ; else skip )  ;     j := j + i ) ) else skip )  ;     i := i + 1 ) ; 
    result := result->sort() ; 
    return result->at(n - 1+1) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 50 ;
     OclFile["System.out"].println(smartNumber(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      double t1=sc.nextDouble();
      double s1=sc.nextDouble();
      double t2=sc.nextDouble();
      double s2=sc.nextDouble();
      if(t1==-1 && s1==-1 && t2==-1 && s2==-1)return ;
      double r=6378.1 ;
      double[] p=pr(t1,s1);
      double[] q=pr(t2,s2);
      double a=p[0]*q[0]+p[1]*q[1]+p[2]*q[2];
      double c=Math.acos(a);
      double ans=r*c ;
      System.out.printf("%d\n",(int)(ans+0.5));
    }
  }
  static double[] pr(double a,double b){
    double x=Math.cos(b/180.0*Math.PI)*Math.cos(a/180.0*Math.PI);
    double y=Math.sin(b/180.0*Math.PI)*Math.cos(a/180.0*Math.PI);
    double z=Math.sin(a/180.0*Math.PI);
    return new double[] {
      x,y,z };
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var t1 : double ; t1 := sc.getCurrent()->toReal() ;
     var s1 : double ; s1 := sc.getCurrent()->toReal() ;
    var t2 : double ; t2 := sc.getCurrent()->toReal() ;
    var s2 : double ; s2 := sc.getCurrent()->toReal() ;
    if (t1 = -1 & s1 = -1 & t2 = -1 & s2 = -1) then     return else skip ; 
    var r : double ; r := 6378.1 ;
    var p : Sequence(double) ; p := pr(t1, s1) ;
    var q : Sequence(double) ; q := pr(t2, s2) ;
    var a : double ; a := p[0+1] * q[0+1] + p[1+1] * q[1+1] + p[2+1] * q[2+1] ;
    var c : double ; c := (a)->acos() ;
    var ans : double ; ans := r * c ;
    OclFile["System.out"].printf("%d\n", (ans + 0.5)->oclAsType(int)) ; 
 ) );
  static   operation pr( a : double, b : double) : Sequence(double)
  pre: true
  post: true
  activity: (     var x : double ; x := (b / 180.0 * 3.141592653589793)->cos() * (a / 180.0 * 3.141592653589793)->cos() ;
     var y : double ; y := (b / 180.0 * 3.141592653589793)->sin() * (a / 180.0 * 3.141592653589793)->cos() ;
     var z : double ; z := (a / 180.0 * 3.141592653589793)->sin() ;
     return Sequence{x,y,z} );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import static java.lang.Math.*;
public class Main {
  double R=6378.1 ;
  double[] get(double n,double e){
    n=n*PI/180 ;
    e=e*PI/180 ;
    return new double[] {
      R*Math.sqrt((1-sin(n)*sin(n)))*sin(e),-R*Math.sqrt((1-sin(n)*sin(n)))*cos(e),R*sin(n)};
    }
    void run(){
      Scanner sc=new Scanner(System.in);
      for(; ; ){
        double n1=sc.nextDouble(),e1=sc.nextDouble(),n2=sc.nextDouble(),e2=sc.nextDouble();
        if(n1==-1 && e1==-1 && n2==-1 && e2==-1)break ;
        double[] a=get(n1,e1),b=get(n2,e2);
        double x=acos((a[0]*b[0]+a[1]*b[1]+a[2]*b[2])/(Math.sqrt(a[0]*a[0]+a[1]*a[1]+a[2]*a[2])*Math.sqrt(b[0]*b[0]+b[1]*b[1]+b[2]*b[2])));
        System.out.printf("%.0f\n",R*x);
      }
    }
    public static void main(String[] args){
      new Main().run();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute R : double := 6378.1;
   operation get( n : double, e : double) : Sequence(double)
  pre: true
  post: true
  activity: (     n := n * PI / 180 ; 
     e := e * PI / 180 ; 
     return Sequence{R * ((1 - sin(n) * sin(n)))->sqrt() * sin(e),-R * ((1 - sin(n) * sin(n)))->sqrt() * cos(e),R * sin(n)} );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n1 : double ; n1 := sc.getCurrent()->toReal() ;
    var e1 : double ; e1 := sc.getCurrent()->toReal() ;
    var n2 : double ; n2 := sc.getCurrent()->toReal() ;
    var e2 : double ; e2 := sc.getCurrent()->toReal() ;
     if (n1 = -1 & e1 = -1 & n2 = -1 & e2 = -1) then     break else skip ; 
    var a : Sequence(double) ; a := get(n1, e1) ;
    var b : Sequence(double) ; b := get(n2, e2) ;
    var x : double ; x := acos((a[0+1] * b[0+1] + a[1+1] * b[1+1] + a[2+1] * b[2+1]) / ((a[0+1] * a[0+1] + a[1+1] * a[1+1] + a[2+1] * a[2+1])->sqrt() * (b[0+1] * b[0+1] + b[1+1] * b[1+1] + b[2+1] * b[2+1])->sqrt())) ;
    OclFile["System.out"].printf("%.0f\n", R * x) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      double a=sc.nextDouble();
      double b=sc.nextDouble();
      double c=sc.nextDouble();
      double d=sc.nextDouble();
      if((a==-1)&&(b==-1)&&(c==-1)&&(d==-1)){
        break ;
      }
      double vz=Math.sin(Math.toRadians(a));
      double vx=Math.cos(Math.toRadians(a))*Math.cos(Math.toRadians(b));
      double vy=Math.cos(Math.toRadians(a))*Math.sin(Math.toRadians(b));
      double wz=Math.sin(Math.toRadians(c));
      double wx=Math.cos(Math.toRadians(c))*Math.cos(Math.toRadians(d));
      double wy=Math.cos(Math.toRadians(c))*Math.sin(Math.toRadians(d));
      double dot=vz*wz+vx*wx+vy*wy ;
      double theta=Math.acos(dot);
      double R=6378.1 ;
      System.out.println((int)(R*theta+0.5));
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var a : double ; a := sc.getCurrent()->toReal() ;
     var b : double ; b := sc.getCurrent()->toReal() ;
    var c : double ; c := sc.getCurrent()->toReal() ;
    var d : double ; d := sc.getCurrent()->toReal() ;
    if ((a = -1) & (b = -1) & (c = -1) & (d = -1)) then (     break ) else skip ; 
    var vz : double ; vz := ((0.017453292519943295*(a)))->sin() ;
    var vx : double ; vx := ((0.017453292519943295*(a)))->cos() * ((0.017453292519943295*(b)))->cos() ;
    var vy : double ; vy := ((0.017453292519943295*(a)))->cos() * ((0.017453292519943295*(b)))->sin() ;
    var wz : double ; wz := ((0.017453292519943295*(c)))->sin() ;
    var wx : double ; wx := ((0.017453292519943295*(c)))->cos() * ((0.017453292519943295*(d)))->cos() ;
    var wy : double ; wy := ((0.017453292519943295*(c)))->cos() * ((0.017453292519943295*(d)))->sin() ;
    var dot : double ; dot := vz * wz + vx * wx + vy * wy ;
    var theta : double ; theta := (dot)->acos() ;
    var R : double ; R := 6378.1 ;
    OclFile["System.out"].println((R * theta + 0.5)->oclAsType(int)) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String args[]){
    try {
      new Main();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  public static double r=6378.1 ;
  public Main()throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=in.readLine())!=null){
      String[] tmp=line.split(" ");
      double hp1=Double.parseDouble(tmp[0]);
      double ep1=Double.parseDouble(tmp[1]);
      double hp2=Double.parseDouble(tmp[2]);
      double ep2=Double.parseDouble(tmp[3]);
      if(hp1==-1.0 && ep1==-1.0 && hp2==-1.0 && ep2==-1.0)break ;
      hp1=2.0*Math.PI*hp1/360.0 ;
      ep1=2.0*Math.PI*ep1/360.0 ;
      hp2=2.0*Math.PI*hp2/360.0 ;
      ep2=2.0*Math.PI*ep2/360.0 ;
      double cosd=Math.sin(hp1)*Math.sin(hp2)+Math.cos(hp1)*Math.cos(hp2)*Math.cos(ep1-ep2);
      double dp=Math.acos(cosd);
      double dist=Math.abs(r*dp);
      System.out.println((int)(dist+0.5));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( Main.newMain() )   catch (e : IOException) do (     e.printStackTrace() )
 );
  static   attribute r : double := 6378.1;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := in.readLine() ;
    while ((line) /= null) do (    skip ; (     var tmp : Sequence(String) ; tmp := line->split(" ") ;
     var hp1 : double ; hp1 := (tmp[0+1])->toReal() ;
    var ep1 : double ; ep1 := (tmp[1+1])->toReal() ;
    var hp2 : double ; hp2 := (tmp[2+1])->toReal() ;
    var ep2 : double ; ep2 := (tmp[3+1])->toReal() ;
    if (hp1 = -1.0 & ep1 = -1.0 & hp2 = -1.0 & ep2 = -1.0) then     break else skip ; 
    hp1 := 2.0 * 3.141592653589793 * hp1 / 360.0 ; 
    ep1 := 2.0 * 3.141592653589793 * ep1 / 360.0 ; 
    hp2 := 2.0 * 3.141592653589793 * hp2 / 360.0 ; 
    ep2 := 2.0 * 3.141592653589793 * ep2 / 360.0 ; 
    var cosd : double ; cosd := (hp1)->sin() * (hp2)->sin() + (hp1)->cos() * (hp2)->cos() * (ep1 - ep2)->cos() ;
    var dp : double ; dp := (cosd)->acos() ;
    var dist : double ; dist := if r * dp < 0 then -(r * dp) else r * dp endif ;
    OclFile["System.out"].println((dist + 0.5)->oclAsType(int)) ; 
 ) ;     line := in.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      double a=sc.nextDouble()*Math.PI/180 ;
      double b=sc.nextDouble()*Math.PI/180 ;
      double c=sc.nextDouble()*Math.PI/180 ;
      double d=sc.nextDouble()*Math.PI/180 ;
      if(b<0 && d<0)break ;
      double x1=Math.cos(a)*Math.cos(b);
      double y1=Math.cos(a)*Math.sin(b);
      double z1=Math.sin(a);
      double x2=Math.cos(c)*Math.cos(d);
      double y2=Math.cos(c)*Math.sin(d);
      double z2=Math.sin(c);
      double s1=Math.sqrt(x1*x1+y1*y1+z1*z1);
      double s2=Math.sqrt(x2*x2+y2*y2+z2*z2);
      double s12=x1*x2+y1*y2+z1*z2 ;
      double rad=Math.acos(s12/(s1*s2));
      System.out.println((int)(6378.1*rad+0.5));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var a : double ; a := sc.getCurrent()->toReal() * 3.141592653589793 / 180 ;
     var b : double ; b := sc.getCurrent()->toReal() * 3.141592653589793 / 180 ;
    var c : double ; c := sc.getCurrent()->toReal() * 3.141592653589793 / 180 ;
    var d : double ; d := sc.getCurrent()->toReal() * 3.141592653589793 / 180 ;
    if (b < 0 & d < 0) then     break else skip ; 
    var x1 : double ; x1 := (a)->cos() * (b)->cos() ;
    var y1 : double ; y1 := (a)->cos() * (b)->sin() ;
    var z1 : double ; z1 := (a)->sin() ;
    var x2 : double ; x2 := (c)->cos() * (d)->cos() ;
    var y2 : double ; y2 := (c)->cos() * (d)->sin() ;
    var z2 : double ; z2 := (c)->sin() ;
    var s1 : double ; s1 := (x1 * x1 + y1 * y1 + z1 * z1)->sqrt() ;
    var s2 : double ; s2 := (x2 * x2 + y2 * y2 + z2 * z2)->sqrt() ;
    var s12 : double ; s12 := x1 * x2 + y1 * y2 + z1 * z2 ;
    var rad : double ; rad := (s12 / (s1 * s2))->acos() ;
    OclFile["System.out"].println((6378.1 * rad + 0.5)->oclAsType(int)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPerfectSquare(double x){
    double sr=Math.sqrt(x);
    return((sr-Math.floor(sr))==0);
  }
  public static void main(String[] args){
    double x=2500 ;
    if(isPerfectSquare(x))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPerfectSquare( x : double) : boolean
  pre: true
  post: true
  activity: (     var sr : double ; sr := (x)->sqrt() ;
     return ((sr - (sr)->floor()) = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : double ; x := 2500 ;
     if (isPerfectSquare(x)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    HashSet<Integer>set=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      set.add(sc.nextInt());
    }
    System.out.println(set.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     set := set->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(set->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class A1546 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      int[] A=new int[N];
      int[] B=new int[N];
      int sumA=0 ;
      int sumB=0 ;
      for(int n=0 ; n<N ; n++){
        int a=in.nextInt();
        sumA+=a ;
        A[n]=a ;
      }
      for(int n=0 ; n<N ; n++){
        int b=in.nextInt();
        sumB+=b ;
        B[n]=b ;
      }
      if(sumA==sumB){
        List<Point>list=new ArrayList<Point>();
        while(true){
          int small=0 ;
          while(small<N && A[small]>=B[small])small++;
          if(small==N)break ;
          int large=0 ;
          while(A[large]<=B[large])large++;
          A[small]++;
          A[large]--;
          list.add(new Point(large,small));
        }
        StringBuilder output=new StringBuilder();
        output.append(list.size());
        for(Point p : list){
          output.append('\n').append(p.x+1).append(' ').append(p.y+1);
        }
        System.out.println(output);
      }
      else {
        System.out.println("-1");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1546 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,N)->collect(0) ;
    var sumA : int ; sumA := 0 ;
    var sumB : int ; sumB := 0 ;
        var n : int ; n := 0 ; while n < N do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     sumA := sumA+(a) ; 
     A[n+1] := a )  ;     n := n + 1 ) ; 
        var n : int ; n := 0 ; while n < N do ( (     var b : int ; b := in.getCurrent()->toInteger() ;
     sumB := sumB+(b) ; 
     B[n+1] := b )  ;     n := n + 1 ) ; 
    if (sumA = sumB) then (     var list : Sequence(Point) ; list := Sequence{} ;
     while (true) do (     var small : int ; small := 0 ;
     while (small < N & A[small+1] >= B[small+1]) do     small := small + 1 ; ; 
    if (small = N) then     break else skip ; 
    var large : int ; large := 0 ;
    while (A[large+1] <= B[large+1]) do     large := large + 1 ; ; 
    A[small+1] := A[small+1] + 1 ; 
    A[large+1] := A[large+1] - 1 ; 
    list := list->including(Point.newPoint(large, small)) ; 
 ) ; 
    var output : String ; output := StringLib.newString() ;
    output := output + StringLib.newString(list->size()) ; 
    for (p : list) do ( (     output := output + StringLib.newString('
') + StringLib.newString(p.x + 1) + StringLib.newString(' ') + StringLib.newString(p.y + 1) )  ) ; 
    OclFile["System.out"].println(output) ; 
 ) else (     OclFile["System.out"].println("-1") ) ;  
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Scanner ;
class Data {
  final int id ;
  final int solved ;
  int rank=0 ;
  public Data(int id,int solved){
    this.id=id ;
    this.solved=solved ;
  }
}
class Main {
  private static void solve(){
    final Scanner scanner=new Scanner(System.in).useDelimiter("[,\\s]+");
    final List<Data>result=new ArrayList<Data>();
    while(true){
      final int id=scanner.nextInt();
      final int solved=scanner.nextInt();
      if(id==0 && solved==0){
        break ;
      }
      result.add(new Data(id,solved));
    }
    Collections.sort(result,new Comparator<Data>(){
      public int compare(Data o1,Data o2){
        return o1.solved==o2.solved ? 0 :(o1.solved>o2.solved ?-1 : 1);
      }
    }
);
    int rank=0 ;
    int solved=0 ;
    for(Data data : result){
      if(data.solved!=solved){
        rank++;
        solved=data.solved ;
      }
      data.rank=rank ;
    }
    Collections.sort(result,new Comparator<Data>(){
      public int compare(Data o1,Data o2){
        return o1.id==o2.id ? 0 :(o1.id>o2.id ? 1 :-1);
      }
    }
);
    while(scanner.hasNextInt()){
      System.out.println(result.get(scanner.nextInt()-1).rank);
    }
  }
  public static void main(String...args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Data {
   attribute id : int;
   attribute solved : int;
   attribute rank : int := 0;
   static operation newData( id : int, solved : int) : Data
  pre: true
  post: true
  activity:
  ( var self : Data ;
    self := createData();
    self.initialise(id, solved);
    return self );
  operation initialise( id : int, solved : int) : void
  pre: true  post: true
  activity: (     self.id := id ; 
     self.solved := solved );
}
class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]).useDelimiter("[,\\s]+") ;
     var result : Sequence(Data) ; result := Sequence{} ;
    while (true) do (     var id : int ; id := scanner.getCurrent()->toInteger() ;
     var solved : int ; solved := scanner.getCurrent()->toInteger() ;
     if (id = 0 & solved = 0) then (     break ) else skip ; 
     result := result->including(Data.newData(id, solved)) ) ; 
    result, OclComparator<Data>.newOclComparator() := result, OclComparator<Data>.newOclComparator()->sort() ; 
    var rank : int ; rank := 0 ;
    var solved : int ; solved := 0 ;
    for (data : result) do ( (     if (data.solved /= solved) then (     rank := rank + 1 ; 
     solved := data.solved ) else skip ; 
     data.rank := rank )  ) ; 
    result, OclComparator<Data>.newOclComparator() := result, OclComparator<Data>.newOclComparator()->sort() ; 
    while (scanner.hasNextInt()) do (     OclFile["System.out"].println(result->at(scanner.getCurrent()->toInteger() - 1+1).rank) ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String read=null ;
    try {
      read=br.readLine();
      br.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
    String str[]=read.split(" ",0);
    int h=Integer.parseInt(str[0]);
    int a=Integer.parseInt(str[1]);
    PrintWriter pw=new PrintWriter(System.out);
    int i=0 ;
    while(h>0){
      h=h-a ;
      i++;
    }
    pw.println(i);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var read : String ; read := null ;
    try (     read := br.readLine() ; 
     skip )   catch (e : IOException) do (     e.printStackTrace() )
    var str : Sequence(String) ; str := read->split(" ") ;
    var h : int ; h := (str[0+1])->toInteger() ;
    var a : int ; a := (str[1+1])->toInteger() ;
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var i : int ; i := 0 ;
    while (h > 0) do (     h := (h)->char2byte() - a ; 
     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
import java.util.HashMap ;
import java.util.Map ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    Map<Integer,Integer>scoreMap=new HashMap<Integer,Integer>();
    int[] occurrences=new int[31];
    while(true){
      String[] values=reader.readLine().split(",");
      int number=Integer.parseInt(values[0]);
      int score=Integer.parseInt(values[1]);
      if(number==0 && score==0){
        break ;
      }
      scoreMap.put(number,score);
      occurrences[score]=1 ;
    }
    while(true){
      String line=reader.readLine();
      if(line==null || line.isEmpty()){
        break ;
      }
      int number=Integer.parseInt(line);
      int score=scoreMap.get(number);
      int rank=0 ;
      for(int i=30 ; i>=score ; i--){
        rank+=occurrences[i];
      }
      out.println(rank);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     var scoreMap : Map(int,int) ; scoreMap := Map{} ;
    var occurrences : Sequence(int) ; occurrences := Integer.subrange(1,31)->collect(0) ;
    while (true) do (     var values : Sequence(String) ; values := reader.readLine()->split(",") ;
     var number : int ; number := (values[0+1])->toInteger() ;
    var score : int ; score := (values[1+1])->toInteger() ;
    if (number = 0 & score = 0) then (     break ) else skip ; 
    scoreMap := scoreMap->union(Map{number |-> score}) ; 
    occurrences[score+1] := 1 ; 
 ) ; 
    while (true) do (     var line : String ; line := reader.readLine() ;
     if (line = null or line->isEmpty()) then (     break ) else skip ; 
    var number : int ; number := (line)->toInteger() ;
    var score : int ; score := scoreMap->at(number) ;
    var rank : int ; rank := 0 ;
        var i : int ; i := 30 ; while i >= score do ( (     rank := rank+(occurrences[i+1]) )  ;     i := i - 1 ) ; 
    out.println(rank) ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
class Team {
  int n,score ;
  Team(int n){
    this.n=n ;
  }
  void AddScore(int s){
    this.score=s ;
  }
  int match(int m[]){
    for(int i=0 ; i<100 ; i++)if(this.score==m[i])return i+1 ;
    return-1 ;
  }
}
class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String buf ;
    try {
      Team team[]=new Team[101];
      int m[]=new int[101];
      int tp=0 ;
      int mp=0 ;
      for(int i=0 ; i<=100 ; i++)m[i]=0 ;
      while((buf=br.readLine()).equals("0,0")==false){
        StringTokenizer st=new StringTokenizer(buf,",");
        team[tp]=new Team(Integer.parseInt(st.nextToken()));
        int d=Integer.parseInt(st.nextToken());
        team[tp++] .AddScore(d);
        if(mp==0){
          m[0]=d ;
          mp++;
        }
        for(int i=0 ; i<=mp ; i++){
          if(d>m[i]){
            for(int j=mp ; j>i ; j--){
              int t=m[j-1];
              m[j-1]=m[j];
              m[j]=t ;
            }
            m[i]=d ;
            mp++;
            break ;
          }
          else if(d==m[i])break ;
        }
      }
      while((buf=br.readLine())!=null){
        for(int i=0 ; i<=100 ; i++){
          if(team[i] .n==Integer.parseInt(buf)){
            System.out.println(team[i] .match(m));
            break ;
          }
        }
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Team {
   attribute n : int;
   static operation newTeam( n : int) : Team
  pre: true
  post: true
  activity:
  ( var self : Team ;
    self := createTeam();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     self.n := n );
   operation AddScore( s : int) : void
  pre: true
  post: true
  activity: (     self.score := s );
   operation match( m : Sequence(int)) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 100 do (     if (self.score = m[i+1]) then     return i + 1 else skip ;  ;     i := i + 1 ) ; 
     return -1 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var buf : String ;
     try (     var team : Sequence(Team) ; team := Integer.subrange(1,101)->collect(null) ;
     var m : Sequence(int) ; m := Integer.subrange(1,101)->collect(0) ;
    var tp : int ; tp := 0 ;
    var mp : int ; mp := 0 ;
        var i : int ; i := 0 ; while i <= 100 do (     m[i+1] := 0 ;  ;     i := i + 1 ) ; 
        buf := br.readLine() ;
    while ((buf) = "0,0" = false) do (        buf := br.readLine() ;
    (buf) = "0,0" ;     skip ; (     var st : OclIterator ; st := OclIterator.newOclIterator_String_String(buf, ",") ;
     team[tp+1] := Team.newTeam((st.next())->toInteger()) ; 
    var d : int ; d := (st.next())->toInteger() ;
    team[tp+1].AddScore(d) ; 
    if (mp = 0) then (     m[0+1] := d ; 
     mp := mp + 1 ) else skip ; 
        var i : int ; i := 0 ; while i <= mp do ( (     if (d > m[i+1]) then (         var j : int ; j := mp ; while j > i do ( (     var t : int ; t := m[j - 1+1] ;
     m[j - 1+1] := m[j+1] ; 
     m[j+1] := t )  ;     j := j - 1 ) ; 
     m[i+1] := d ; 
     mp := mp + 1 ; 
     break ) else     if (d = m[i+1]) then     break else skip ; )  ;     i := i + 1 ) ; 
 ) ;     buf := br.readLine() ;
 ) ;  
        buf := br.readLine() ;
    while ((buf) /= null) do (    skip ; (         var i : int ; i := 0 ; while i <= 100 do ( (     if (team[i+1].n = (buf)->toInteger()) then (     OclFile["System.out"].println(team[i+1].match(m)) ; 
     break ) else skip )  ;     i := i + 1 ) ) ;     buf := br.readLine() ;
 ) ;  
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  private static Scanner sc=new Scanner(System.in);
  ;
  private static String str="" ;
  static int n=0 ;
  static Map<Integer,Set<String>>map=new TreeMap<Integer,Set<String>>();
  public static void main(String[] args){
    for(; !(str=sc.next()).equals("0,0"); ){
      args=str.split(",");
      if(! map.containsKey(n=new Integer(args[1])))map.put(n,new HashSet<String>());
      map.get(n).add(args[0]);
    }
    ans();
  }
  static void ans(){
    for(int i=0 ; sc.hasNext(); System.out.println(i)){
      str=sc.next();
      i=map.size();
      for(int k : map.keySet()){
        if(map.get(k).contains(str))break ;
--i ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute str : String := "";
  static   attribute n : int := 0;
  static   attribute map : Map(int,Set(String)) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (       while not((str) = "0,0") do ( (     args := str->split(",") ; 
     if (not(map->keys()->includes(n))) then     map := map->union(Map{n |-> Set{}}) ; else skip ; 
     map->at(n)->excludes(args[0+1]) )  ) ; 
     execute ans() );
  static   operation ans() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while sc.hasNext() do ( (     str := sc.getCurrent() ; 
     i := map.size() ; 
     for (k : map->keys()) do ( (     if (map->at(k)->includes(str)) then     break else skip ; 
     i := i - 1 )  ) )  ;     OclFile["System.out"].println(i) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();
    HashSet<Integer>scores=new HashSet<Integer>();
    for(; ; ){
      String[] str=sc.next().split(",");
      int a=Integer.parseInt(str[0]),b=Integer.parseInt(str[1]);
      if((a | b)==0)break ;
      map.put(a,b);
      scores.add(b);
    }
    int[] ans=new int[scores.size()];
    int i=0 ;
    for(int a : scores)ans[i++]=a ;
    sort(ans);
    while(sc.hasNext()){
      int q=sc.nextInt();
      System.out.println((ans.length-binarySearch(ans,map.get(q))));
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var map : Map(int,int) ; map := Map{} ;
    var scores : Set(int) ; scores := Set{} ;
      while true do ( (     var str : Sequence(String) ; str := sc.getCurrent()->split(",") ;
     var a : int ; a := (str[0+1])->toInteger() ;
    var b : int ; b := (str[1+1])->toInteger() ;
    if ((MathLib.bitwiseOr(a,b)) = 0) then     break else skip ; 
    map := map->union(Map{a |-> b}) ; 
    scores := scores->including(b) ; 
 )  ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,scores->size())->collect(0) ;
    var i : int ; i := 0 ;
    for (a : scores) do (      ans[i+1] := a  ; i := i + 1 ;  ) ; 
    execute sort(ans) ; 
    while (sc.hasNext()) do (     var q : int ; q := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println((ans->size() - binarySearch(ans, map->at(q)))) ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static final int MAX_CHAR=26 ;
  static int countSubstringWithEqualEnds(String s){
    int result=0 ;
    int n=s.length();
    int[] count=new int[MAX_CHAR];
    for(int i=0 ; i<n ; i++)count[s.charAt(i)-'a']++;
    for(int i=0 ; i<MAX_CHAR ; i++)result+=(count[i]*(count[i]+1)/2);
    return result ;
  }
  public static void main(String args[]){
    String s="abcab" ;
    System.out.println(countSubstringWithEqualEnds(s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX_CHAR : int := 26;
  static   operation countSubstringWithEqualEnds( s : String) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var n : int ; n := s->size() ;
    var count : Sequence(int) ; count := Integer.subrange(1,MAX_CHAR)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     count[s->at(i+1) - ('a')->char2byte()+1] := count[s->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < MAX_CHAR do (     result := result+((count[i+1] * (count[i+1] + 1) / 2)) ;  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abcab" ;
     OclFile["System.out"].println(countSubstringWithEqualEnds(s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Marathon {
  public static void main(String[] args){
    int n ;
    int a[];
    int ans ;
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      ans=0 ;
      int cntOfPairs=0 ;
      n=sc.nextInt();
      a=new int[n];
      for(int j=0 ; j<n ; j++){
        a[j]=sc.nextInt();
      }
      HashMap<Integer,Integer>cntMap=new HashMap();
      for(int j=0 ; j<n ; j++){
        int key=a[j];
        int val=0 ;
        if(cntMap.containsKey(key))val=cntMap.get(key);
        cntMap.put(key,val+1);
        val=cntMap.get(key);
        if(val==3){
          cntMap.put(key,val-2);
        }
      }
      for(Map.Entry<Integer,Integer>map : cntMap.entrySet()){
        if(map.getValue()==1){
          ans++;
        }
        if(map.getValue()==2){
          cntOfPairs++;
        }
      }
      if(cntOfPairs % 2==0){
        ans+=cntOfPairs ;
      }
      else {
        ans+=cntOfPairs-1 ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Marathon {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     var a : Sequence(int) ;
    var ans : int ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < t do ( (     ans := 0 ; 
     var cntOfPairs : int ; cntOfPairs := 0 ;
    n := sc.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
        var j : int ; j := 0 ; while j < n do ( (     a[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    var cntMap : Map(int,int) ; cntMap := Map{} ;
        var j : int ; j := 0 ; while j < n do ( (     var key : int ; key := a[j+1] ;
     var val : int ; val := 0 ;
    if (cntMap->keys()->includes(key)) then     val := cntMap->at(key) ; else skip ; 
    cntMap := cntMap->union(Map{key |-> val + 1}) ; 
    val := cntMap->at(key) ; 
    if (val = 3) then (     cntMap := cntMap->union(Map{key |-> val - 2}) ) else skip ; 
 )  ;     j := j + 1 ) ; 
    for (map : cntMap->asSet()) do ( (     if (map.getValue() = 1) then (     ans := ans + 1 ) else skip ; 
     if (map.getValue() = 2) then (     cntOfPairs := cntOfPairs + 1 ) else skip )  ) ; 
    if (cntOfPairs mod 2 = 0) then (     ans := ans+(cntOfPairs) ) else (     ans := ans+(cntOfPairs - 1) ) ;  
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class abc {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      HashSet<Integer>hs=new HashSet<>();
      for(int i=0 ; i<n ; i++){
        hs.add(in.nextInt());
      }
      int size=hs.size();
      if((n-size)% 2!=0)size--;
      System.out.println(size);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class abc {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var hs : Set(int) ; hs := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     hs := hs->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var size : int ; size := hs->size() ;
    if ((n - size) mod 2 /= 0) then     size := size - 1 ; else skip ; 
    OclFile["System.out"].println(size) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t--!=0){
      int n=s.nextInt();
      int[] arr=new int[n];
      HashMap<Integer,Integer>map=new HashMap<>();
      for(int i=0 ; i<n ; i++){
        arr[i]=s.nextInt();
        if(! map.containsKey(arr[i]))map.put(arr[i],1);
        else {
          int c=map.get(arr[i]);
          c+=1 ;
          map.put(arr[i],c);
        }
      }
      int nu=map.size();
      int nr=n-nu ;
      if(nr % 2==0)System.out.println(nu);
      else System.out.println(nu-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() ; 
     if (not(map->keys()->includes(arr[i+1]))) then     map := map->union(Map{arr[i+1] |-> 1}) ; else (     var c : int ; c := map->at(arr[i+1]) ;
     c := c+(1) ; 
     map := map->union(Map{arr[i+1] |-> c}) ) )  ;     i := i + 1 ) ; 
    var nu : int ; nu := map.size() ;
    var nr : int ; nr := n - nu ;
    if (nr mod 2 = 0) then     OclFile["System.out"].println(nu) else     OclFile["System.out"].println(nu - 1) ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static double[][] nums ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=sc.nextInt();
    }
    Arrays.sort(nums);
    int ans=1 ;
    for(int i=0 ; i<n-1 ; i++){
      if(nums[i]!=nums[i+1])ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute nums : Sequence(Sequence(double));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    nums := nums->sort() ; 
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (nums[i+1] /= nums[i + 1+1]) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Set ;
import java.util.StringTokenizer ;
public class AllDistinct {
  public static void main(String[] args)throws IOException {
    InputStream inputStream=System.in ;
    InputReader in=new InputReader(inputStream);
    BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
    int t=in.nextInt();
    while(t--!=0){
      int n=in.nextInt();
      int duplicates=0 ;
      HashSet<Integer>hs=new HashSet<>();
      for(int idx=0 ; idx<n ; idx++){
        int num=in.nextInt();
        if(hs.contains(num)){
          duplicates++;
        }
        else {
          hs.add(num);
        }
      }
      int ans=hs.size();
      if(duplicates % 2!=0){
        ans--;
      }
      out.write(ans+"\n");
    }
    out.close();
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public int[] readArray(int n){
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=nextInt();
      return arr ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AllDistinct {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var t : int ; t := in.nextInt() ;
        while (t /= 0) do (    skip ; (     var n : int ; n := in.nextInt() ;
     var duplicates : int ; duplicates := 0 ;
    var hs : Set(int) ; hs := Set{} ;
        var idx : int ; idx := 0 ; while idx < n do ( (     var num : int ; num := in.nextInt() ;
     if (hs->includes(num)) then (     duplicates := duplicates + 1 ) else (     hs := hs->including(num) ) )  ;     idx := idx + 1 ) ; 
    var ans : int ; ans := hs->size() ;
    if (duplicates mod 2 /= 0) then (     ans := ans - 1 ) else skip ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     arr[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return arr );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    double[][] aRect=null ;
    while((aRect=parseRect())!=null){
      result(aRect);
    }
  }
  private static double[][] parseRect(){
    double[][] aRect=null ;
    String[] as=null ;
    try {
      String line=br.readLine();
      if(line!=null){
        if(! line.isEmpty()){
          aRect=new double[4][2];
          as=line.split(" ");
          aRect[0][0]=Double.parseDouble(as[0]);
          aRect[0][1]=Double.parseDouble(as[1]);
          aRect[1][0]=Double.parseDouble(as[2]);
          aRect[1][1]=Double.parseDouble(as[3]);
          aRect[2][0]=Double.parseDouble(as[4]);
          aRect[2][1]=Double.parseDouble(as[5]);
          aRect[3][0]=Double.parseDouble(as[6]);
          aRect[3][1]=Double.parseDouble(as[7]);
        }
      }
    }
    catch(NumberFormatException e){
    }
    catch(IOException e){
    }
    return aRect ;
  }
  private static void result(double[][] aRect){
    if(aRect[0][0]>aRect[3][0] || aRect[1][0]<aRect[2][0] || aRect[0][1]>aRect[3][1] || aRect[1][1]<aRect[2][1]){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var aRect : Sequence(Sequence(double)) ; aRect := null ;
         aRect := parseRect() ;
    while ((aRect) /= null) do (    skip ; (     execute result(aRect) ) ;     aRect := parseRect() ;
 ) );
  static   operation parseRect() : Sequence(Sequence(double))
  pre: true
  post: true
  activity: (     var aRect : Sequence(Sequence(double)) ; aRect := null ;
     var as : Sequence(String) ; as := null ;
     try (     var line : String ; line := br.readLine() ;
     if (line /= null) then (     if (not(line->isEmpty())) then (     aRect := Integer.subrange(1,4)->collect(Integer.subrange(1,2)->collect(0.0)) ; 
     as := line->split(" ") ; 
    aRect[0+1][0+1] := (as[0+1])->toReal() ; 
    aRect[0+1][1+1] := (as[1+1])->toReal() ; 
    aRect[1+1][0+1] := (as[2+1])->toReal() ; 
    aRect[1+1][1+1] := (as[3+1])->toReal() ; 
    aRect[2+1][0+1] := (as[4+1])->toReal() ; 
    aRect[2+1][1+1] := (as[5+1])->toReal() ; 
    aRect[3+1][0+1] := (as[6+1])->toReal() ; 
    aRect[3+1][1+1] := (as[7+1])->toReal() ; 
 ) else skip ) else skip )   catch (e : IncorrectElementException) do skip
   catch (e : IOException) do skip
     return aRect );
  static   operation result( aRect : Sequence(Sequence(double))) : void
  pre: true
  post: true
  activity: (     if (aRect[0+1][0+1] > aRect[3+1][0+1] or aRect[1+1][0+1] < aRect[2+1][0+1] or aRect[0+1][1+1] > aRect[3+1][1+1] or aRect[1+1][1+1] < aRect[2+1][1+1]) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(final String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int n=scanner.nextInt();
    scanner.nextInt();
    final int w=scanner.nextInt();
    if(n==1){
      System.out.println(Math.abs(w-scanner.nextInt()));
      return ;
    }
    for(int i=0 ; i<n-2 ; i++){
      scanner.nextInt();
    }
    final int preLast=scanner.nextInt();
    final int last=scanner.nextInt();
    System.out.println(Math.max(Math.abs(w-last),Math.abs(last-preLast)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    skip ; 
    var w : int ; w := scanner.getCurrent()->toInteger() ;
    if (n = 1) then (     OclFile["System.out"].println(if w - scanner.getCurrent()->toInteger() < 0 then -(w - scanner.getCurrent()->toInteger()) else w - scanner.getCurrent()->toInteger() endif) ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < n - 2 do ( (     skip )  ;     i := i + 1 ) ; 
    var preLast : int ; preLast := scanner.getCurrent()->toInteger() ;
    var last : int ; last := scanner.getCurrent()->toInteger() ;
    OclFile["System.out"].println(Set{if w - last < 0 then -(w - last) else w - last endif, if last - preLast < 0 then -(last - preLast) else last - preLast endif}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Marathon {
  public static void main(String[] args){
    int n ;
    int a[];
    int ans ;
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      ans=0 ;
      int cntOfPairs=0 ;
      n=sc.nextInt();
      a=new int[n];
      for(int j=0 ; j<n ; j++){
        a[j]=sc.nextInt();
      }
      HashMap<Integer,Integer>cntMap=new HashMap();
      for(int j=0 ; j<n ; j++){
        int key=a[j];
        cntMap.put(key,cntMap.getOrDefault(key,0)+1);
        int val=cntMap.get(key);
        if(val==3){
          cntMap.put(key,val-2);
        }
      }
      for(Map.Entry<Integer,Integer>map : cntMap.entrySet()){
        if(map.getValue()==1){
          ans++;
        }
        if(map.getValue()==2){
          cntOfPairs++;
        }
      }
      if(cntOfPairs % 2==0){
        ans+=cntOfPairs ;
      }
      else {
        ans+=cntOfPairs-1 ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Marathon {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     var a : Sequence(int) ;
    var ans : int ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < t do ( (     ans := 0 ; 
     var cntOfPairs : int ; cntOfPairs := 0 ;
    n := sc.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
        var j : int ; j := 0 ; while j < n do ( (     a[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    var cntMap : Map(int,int) ; cntMap := Map{} ;
        var j : int ; j := 0 ; while j < n do ( (     var key : int ; key := a[j+1] ;
     cntMap := cntMap->union(Map{key |-> (if cntMap->keys()->contains(key) then cntMap->at(key) else 0 endif) + 1}) ; 
     var val : int ; val := cntMap->at(key) ;
     if (val = 3) then (     cntMap := cntMap->union(Map{key |-> val - 2}) ) else skip )  ;     j := j + 1 ) ; 
    for (map : cntMap->asSet()) do ( (     if (map.getValue() = 1) then (     ans := ans + 1 ) else skip ; 
     if (map.getValue() = 2) then (     cntOfPairs := cntOfPairs + 1 ) else skip )  ) ; 
    if (cntOfPairs mod 2 = 0) then (     ans := ans+(cntOfPairs) ) else (     ans := ans+(cntOfPairs - 1) ) ;  
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int INT_SIZE=32 ;
  static int Right_most_setbit(int num){
    int pos=1 ;
    for(int i=0 ; i<INT_SIZE ; i++){
      if((num &(1<<i))==0)pos++;
      else break ;
    }
    return pos ;
  }
  static int findValueAtK(int n,int m,int k){
    int positionOfRightmostSetbit=Right_most_setbit(k);
    return((m-1)+positionOfRightmostSetbit);
  }
  public static void main(String[] args){
    int k=100,n=9,m=74 ;
    System.out.println(findValueAtK(n,m,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute INT_SIZE : int := 32;
  static   operation Right_most_setbit( num : int) : int
  pre: true
  post: true
  activity: (     var pos : int ; pos := 1 ;
         var i : int ; i := 0 ; while i < INT_SIZE do ( (     if ((num & ((1*(2->pow(i)))->oclAsType(long))) = 0) then     pos := pos + 1 ; else     break )  ;     i := i + 1 ) ; 
     return pos );
  static   operation findValueAtK( n : int, m : int, k : int) : int
  pre: true
  post: true
  activity: (     var positionOfRightmostSetbit : int ; positionOfRightmostSetbit := Right_most_setbit(k) ;
     return ((m - 1) + positionOfRightmostSetbit) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 100 ;
    var n : int ; n := 9 ;
    var m : int ; m := 74 ;
     OclFile["System.out"].println(findValueAtK(n, m, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.io.*;
class GFG {
  static int countSequences(int arr[],int n){
    int count=1 ;
    Arrays.sort(arr);
    for(int i=0 ; i<n-1 ; i++)if(arr[i]+1!=arr[i+1])count++;
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      1,7,3,5,10 };
      int n=arr.length ;
      System.out.println(countSequences(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSequences( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 1 ;
     arr := arr->sort() ; 
         var i : int ; i := 0 ; while i < n - 1 do (     if (arr[i+1] + 1 /= arr[i + 1+1]) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,7,3,5,10} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countSequences(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  static int countNum(int[] arr,int n){
    int count=0 ;
    Arrays.sort(arr);
    for(int i=0 ; i<n-1 ; i++)if(arr[i]!=arr[i+1] && arr[i]!=arr[i+1]-1)count+=arr[i+1]-arr[i]-1 ;
    return count ;
  }
  static public void main(String[] args){
    int[] arr={
      3,5,8,6 };
      int n=arr.length ;
      System.out.println(countNum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countNum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     arr := arr->sort() ; 
         var i : int ; i := 0 ; while i < n - 1 do (     if (arr[i+1] /= arr[i + 1+1] & arr[i+1] /= arr[i + 1+1] - 1) then     count := count+(arr[i + 1+1] - arr[i+1] - 1) ; else skip ;  ;     i := i + 1 ) ; 
     return count );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,5,8,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countNum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int indexOfFirstOne(int arr[],int n){
    for(int i=0 ; i<n ; i++)if(arr[i]==1)return i ;
    return-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      0,0,0,0,0,0,1,1,1,1 };
      int n=arr.length ;
      System.out.println(indexOfFirstOne(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation indexOfFirstOne( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     if (arr[i+1] = 1) then     return i else skip ;  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,0,0,0,0,0,1,1,1,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(indexOfFirstOne(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int toggleLastMBits(int n,int m){
    if(m==0)return n ;
    int num=(1<<m)-1 ;
    return(n ^ num);
  }
  static int largeNumWithNSetAndMUnsetBits(int n,int m){
    int num=(1<<(n+m))-1 ;
    return toggleLastMBits(num,m);
  }
  public static void main(String[] args){
    int n=2,m=2 ;
    System.out.println(largeNumWithNSetAndMUnsetBits(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation toggleLastMBits( n : int, m : int) : int
  pre: true
  post: true
  activity: (     if (m = 0) then     return n else skip ; 
     var num : int ; num := ((1*(2->pow(m)))->oclAsType(long)) - 1 ;
     return (n xor num) );
  static   operation largeNumWithNSetAndMUnsetBits( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := ((1*(2->pow((n + m))))->oclAsType(long)) - 1 ;
     return toggleLastMBits(num, m) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
    var m : int ; m := 2 ;
     OclFile["System.out"].println(largeNumWithNSetAndMUnsetBits(n, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  public boolean isValidNumeric(String str){
    str=str.trim();
    if(str.length()==0)return false ;
    if(str.length()==1 && ! Character.isDigit(str.charAt(0)))return false ;
    if(str.charAt(0)!='+' && str.charAt(0)!='-' && ! Character.isDigit(str.charAt(0))&& str.charAt(0)!='.')return false ;
    boolean flagDotOrE=false ;
    for(int i=1 ; i<str.length(); i++){
      if(! Character.isDigit(str.charAt(i))&& str.charAt(i)!='e' && str.charAt(i)!='.' && str.charAt(i)!='+' && str.charAt(i)!='-')return false ;
      if(str.charAt(i)=='.'){
        if(flagDotOrE==true)return false ;
        if(i+1>=str.length())return false ;
        if(! Character.isDigit(str.charAt(i+1)))return false ;
      }
      else if(str.charAt(i)=='e'){
        flagDotOrE=true ;
        if(! Character.isDigit(str.charAt(i-1)))return false ;
        if(i+1>=str.length())return false ;
        if(! Character.isDigit(str.charAt(i+1))&& str.charAt(i+1)!='+' && str.charAt(i+1)!='-')return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    String input="0.1e10" ;
    GFG gfg=new GFG();
    System.out.println(gfg.isValidNumeric(input));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
   operation isValidNumeric( str : String) : boolean
  pre: true
  post: true
  activity: (     str := str->trim() ; 
     if (str->size() = 0) then     return false else skip ; 
    if (str->size() = 1 & not((str->at(0+1) + "")->isMatch("[0-9]"))) then     return false else skip ; 
    if (str->at(0+1) /= '+' & str->at(0+1) /= '-' & not((str->at(0+1) + "")->isMatch("[0-9]")) & str->at(0+1) /= '.') then     return false else skip ; 
    var flagDotOrE : boolean ; flagDotOrE := false ;
        var i : int ; i := 1 ; while i < str->size() do ( (     if (not((str->at(i+1) + "")->isMatch("[0-9]")) & str->at(i+1) /= 'e' & str->at(i+1) /= '.' & str->at(i+1) /= '+' & str->at(i+1) /= '-') then     return false else skip ; 
     if (str->at(i+1) = '.') then (     if (flagDotOrE = true) then     return false else skip ; 
     if (i + 1 >= str->size()) then     return false else skip ; 
     if (not((str->at(i + 1+1) + "")->isMatch("[0-9]"))) then     return false else skip ) else     if (str->at(i+1) = 'e') then (     flagDotOrE := true ; 
     if (not((str->at(i - 1+1) + "")->isMatch("[0-9]"))) then     return false else skip ; 
     if (i + 1 >= str->size()) then     return false else skip ; 
     if (not((str->at(i + 1+1) + "")->isMatch("[0-9]")) & str->at(i + 1+1) /= '+' & str->at(i + 1+1) /= '-') then     return false else skip ) else skip ; )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : String ; input := "0.1e10" ;
     var gfg : GFG ; gfg := GFG.newGFG() ;
     OclFile["System.out"].println(gfg.isValidNumeric(input)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int mod=(int)(1e9+7);
  static int power(int a,int m1){
    if(m1==0)return 1 ;
    else if(m1==1)return a ;
    else if(m1==2)return(int)((1L*a*a)% mod);
    else if(m1 % 2==1)return(int)((1L*a*power(power(a,m1/2),2))% mod);
    else return power(power(a,m1/2),2)% mod ;
  }
  static int factorial(int x){
    int ans=1 ;
    for(int i=1 ; i<=x ; i++)ans=(int)((1L*ans*i)% mod);
    return ans ;
  }
  static int inverse(int x){
    return power(x,mod-2);
  }
  static int binomial(int n,int r){
    if(r>n)return 0 ;
    int ans=factorial(n);
    ans=(int)((1L*ans*inverse(factorial(r)))% mod);
    ans=(int)((1L*ans*inverse(factorial(n-r)))% mod);
    return ans ;
  }
  static int number_of_sets(int n,int a,int b){
    int ans=power(2,n);
    ans=ans-binomial(n,a);
    if(ans<0)ans+=mod ;
    ans=ans-binomial(n,b);
    ans--;
    if(ans<0)ans+=mod ;
    return ans ;
  }
  public static void main(String[] args){
    int N=4,A=1,B=3 ;
    System.out.print(number_of_sets(N,A,B));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute mod : int := (1e9 + 7)->oclAsType(int);
  static   operation power( a : int, m1 : int) : int
  pre: true
  post: true
  activity: (     if (m1 = 0) then     return 1 else     if (m1 = 1) then     return a else     if (m1 = 2) then     return ((1L * a * a) mod mod)->oclAsType(int) else     if (m1 mod 2 = 1) then     return ((1L * a * power(power(a, m1 / 2), 2)) mod mod)->oclAsType(int) else     return power(power(a, m1 / 2), 2) mod mod ;  ;  ;  );
  static   operation factorial( x : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
         var i : int ; i := 1 ; while i <= x do (     ans := ((1L * ans * i) mod mod)->oclAsType(int) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation inverse( x : int) : int
  pre: true
  post: true
  activity: (     return power(x, mod - 2) );
  static   operation binomial( n : int, r : int) : int
  pre: true
  post: true
  activity: (     if (r > n) then     return 0 else skip ; 
     var ans : int ; ans := factorial(n) ;
    ans := ((1L * ans * inverse(factorial(r))) mod mod)->oclAsType(int) ; 
    ans := ((1L * ans * inverse(factorial(n - r))) mod mod)->oclAsType(int) ; 
    return ans 
 );
  static   operation number_of_sets( n : int, a : int, b : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := power(2, n) ;
     ans := ans - binomial(n, a) ; 
    if (ans < 0) then     ans := ans+(mod) ; else skip ; 
    ans := ans - binomial(n, b) ; 
    ans := ans - 1 ; 
    if (ans < 0) then     ans := ans+(mod) ; else skip ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
    var A : int ; A := 1 ;
    var B : int ; B := 3 ;
     OclFile["System.out"].print(number_of_sets(N, A, B)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  MyScanner in ;
  PrintWriter out ;
  final static String FILENAME="a" ;
  public static void main(String[] args)throws Exception {
    new A().run();
  }
  public void run()throws Exception {
    in=new MyScanner(FILENAME+".in");
    out=new PrintWriter(FILENAME+".out");
    int tests=in.nextInt();
    for(int test=0 ; test<tests ; test++){
      out.println("Case #"+(test+1)+": "+solve());
    }
    out.close();
  }
  public long solve()throws Exception {
    int r=in.nextInt();
    int c=in.nextInt();
    int w=in.nextInt();
    return r*(c/w+w+(c % w==0 ?-1 : 0));
  }
  class MyScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public MyScanner(String file)throws Exception {
      br=new BufferedReader(new FileReader(file));
    }
    String next()throws Exception {
      while((st==null)||(! st.hasMoreTokens())){
        String t=br.readLine();
        if(t==null){
          return null ;
        }
        st=new StringTokenizer(t);
      }
      return st.nextToken();
    }
    int nextInt()throws Exception {
      return Integer.parseInt(next());
    }
    double nextDouble()throws Exception {
      return Double.parseDouble(next());
    }
    boolean nextBoolean()throws Exception {
      return Boolean.parseBoolean(next());
    }
    long nextLong()throws Exception {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   attribute in : MyScanner;
   attribute out : OclFile;
  static   attribute FILENAME : String := "a";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     A.newA().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     in := MyScanner.newMyScanner(FILENAME + ".in") ; 
     out := OclFile.newOclFile_Write(FILENAME + ".out") ; 
    var tests : int ; tests := in.nextInt() ;
        var test : int ; test := 0 ; while test < tests do ( (     skip )  ;     test := test + 1 ) ; 
    skip ; 
 );
   operation solve() : long
  pre: true
  post: true
  activity: (     var r : int ; r := in.nextInt() ;
     var c : int ; c := in.nextInt() ;
     var w : int ; w := in.nextInt() ;
     return r * (c / w + w + (if c mod w = 0 then -1 else 0 endif)) );
 class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner( file : String) : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while ((st = null) or (not(st.hasNext()))) do (     var t : String ; t := br.readLine() ;
     if (t = null) then (     return null ) else skip ; 
     st := OclIterator.newOclIterator_String(t) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextBoolean() : boolean
  pre: true
  post: true
  activity: (     return parseBoolean(next()) );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Solution {
  public String addStrings(String num1,String num2){
    StringBuilder sb=new StringBuilder();
    int carry=0 ;
    for(int i=num1.length()-1,j=num2.length()-1 ; i>=0 || j>=0 || carry==1 ; i--,j--){
      int x=i<0 ? 0 : num1.charAt(i)-'0' ;
      int y=j<0 ? 0 : num2.charAt(j)-'0' ;
      sb.append((x+y+carry)% 10);
      carry=(x+y+carry)/10 ;
    }
    return sb.reverse().toString();
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation addStrings( num1 : String, num2 : String) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     var carry : int ; carry := 0 ;
         var i : int ; i := num1->size() - 1 ;
    var j : int ; j := num2->size() - 1 ; while i >= 0 or j >= 0 or carry = 1 do ( (     var x : int ; x := if i < 0 then 0 else num1->at(i+1) - ('0')->char2byte() endif ;
     var y : int ; y := if j < 0 then 0 else num2->at(j+1) - ('0')->char2byte() endif ;
     sb := sb + StringLib.newString((x + y + carry) mod 10) ; 
     carry := (x + y + carry) / 10 )  ;     i := i - 1 ;     j := j - 1 ) ; 
     return sb->reverse()+"" );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0){
      int n=sc.nextInt();
      int v[]=new int[n];
      for(int i=0 ; i<n ; i++){
        v[i]=sc.nextInt();
      }
      int ans=-1 ;
      for(int j=30 ; j>=0 ; j--){
        int cnt=0 ;
        for(int i=0 ; i<n ; i++){
          if((v[i] &(1<<j))>0)cnt+=1 ;
        }
        if(cnt % 2==0){
          continue ;
        }
        int z=(n-cnt)% 2 ;
        cnt=(cnt+1)/2 ;
        if(cnt % 2==0 && z % 2==1){
          ans=1 ;
          break ;
        }
        else if(cnt % 2==1){
          ans=1 ;
          break ;
        }
        ans=0 ;
        break ;
      }
      String Ans=new String();
      if(ans==-1){
        Ans="DRAW" ;
      }
      else if(ans==0){
        Ans="LOSE" ;
      }
      else {
        Ans="WIN" ;
      }
      System.out.println(Ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     v[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -1 ;
        var j : int ; j := 30 ; while j >= 0 do ( (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if ((v[i+1] & ((1*(2->pow(j)))->oclAsType(long))) > 0) then     cnt := cnt+(1) ; else skip )  ;     i := i + 1 ) ; 
    if (cnt mod 2 = 0) then (     continue ) else skip ; 
    var z : int ; z := (n - cnt) mod 2 ;
    cnt := (cnt + 1) / 2 ; 
    if (cnt mod 2 = 0 & z mod 2 = 1) then (     ans := 1 ; 
     break ) else     if (cnt mod 2 = 1) then (     ans := 1 ; 
     break ) else skip ; ;  
    ans := 0 ; 
    break 
 )  ;     j := j - 1 ) ; 
    var Ans : String ; Ans := StringLib.newString() ;
    if (ans = -1) then (     Ans := "DRAW" ) else     if (ans = 0) then (     Ans := "LOSE" ) else (     Ans := "WIN" ) ;  ;  
    OclFile["System.out"].println(Ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GameGame_1383B {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    StringBuilder output=new StringBuilder();
    while(t-->0){
      int n=Integer.parseInt(br.readLine());
      StringTokenizer st=new StringTokenizer(br.readLine());
      int[] arr=new int[32];
      for(int i=0 ; i<n ; i++){
        int num=Integer.parseInt(st.nextToken());
        for(int j=31 ; j>-1 ; j--){
          if(((num>>j)& 1)==1)arr[j]++;
        }
      }
      output.append(helper(arr,n)+"\n");
    }
    System.out.println(output.toString());
  }
  private static String helper(int[] arr,int n){
    for(int i=31 ; i>-1 ; i--){
      int ones=arr[i],zeros=n-arr[i];
      if(ones % 2==0)continue ;
      if(ones % 4==3 && zeros % 2==0)return "LOSE" ;
      return "WIN" ;
    }
    return "DRAW" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class GameGame_1383B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
    var output : String ; output := StringLib.newString() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,32)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := (st.next())->toInteger() ;
         var j : int ; j := 31 ; while j > -1 do ( (     if ((((num/(2->pow(j)))->oclAsType(long)) & 1) = 1) then     arr[j+1] := arr[j+1] + 1 ; else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    output := output + StringLib.newString(helper(arr, n) + "\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].println(output+"") ; 
 );
  static   operation helper( arr : Sequence(int), n : int) : String
  pre: true
  post: true
  activity: (         var i : int ; i := 31 ; while i > -1 do ( (     var ones : int ; ones := arr[i+1] ;
    var zeros : int ; zeros := (n)->char2byte() - arr[i+1] ;
     if (ones mod 2 = 0) then     continue else skip ; 
     if (ones mod 4 = 3 & zeros mod 2 = 0) then     return "LOSE" else skip ; 
     return "WIN" )  ;     i := i - 1 ) ; 
     return "DRAW" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import static java.lang.System.out ;
public class Scratch {
  public static void main(String[] args){
    Scanner ip=new Scanner(System.in);
    class Pair {
      public int x,y ;
    }
    int n=ip.nextInt(),sum=0,rmx=0,lmx=0,mx=0 ;
    int[] a=new int[n],b=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=ip.nextInt();
      b[i]=ip.nextInt();
      sum+=a[i];
    }
    Pair[] p=new Pair[n];
    for(int i=0 ; i<n ; i++)p[i]=new Pair();
    int j=n-1 ;
    for(int i=0 ; i<n && j>=0 ; j--,i++){
      p[i] .x=rmx ;
      p[j] .y=lmx ;
      rmx=Math.max(rmx,b[i]);
      ;
      lmx=Math.max(lmx,b[j]);
    }
    for(int i=0 ; i<n ; i++){
      out.print((sum-a[i])*(Math.max(p[i] .x,p[i] .y))+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Scratch {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ip : OclFile ; ip := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 class Pair {
   attribute x : int;
}
    var n : int ; n := ip.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var rmx : int ; rmx := 0 ;
    var lmx : int ; lmx := 0 ;
    var mx : int ; mx := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := ip.getCurrent()->toInteger() ; 
     b[i+1] := ip.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    var p : Sequence(Map) ; p := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     p[i+1] := Map() ;  ;     i := i + 1 ) ; 
    var j : int ; j := n - 1 ;
        var i : int ; i := 0 ; while i < n & j >= 0 do ( (     p[i+1].x := rmx ; 
     p[j+1].y := lmx ; 
    rmx := Set{rmx, b[i+1]}->max() ; 
    lmx := Set{lmx, b[j+1]}->max() ; 
 )  ;     j := j - 1 ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     out.print((sum - a[i+1]) * (Set{p[i+1].x, p[i+1].y}->max()) + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class B_Photo_to_Remember {
  static Scanner in=new Scanner(System.in);
  static int n ;
  static int photoSet[][];
  static class element implements Comparable<element>{
    int ai,index ;
    public element(int ai,int index){
      this.ai=ai ;
      this.index=index ;
    }
    public int compareTo(element t){
      return this.ai-t.ai ;
    }
  }
  public static void main(String[] amit){
    n=in.nextInt();
    photoSet=new int[n][2];
    int totalWeidth[]=new int[n];
    element Height[]=new element[n];
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      photoSet[i][0]=in.nextInt();
      photoSet[i][1]=in.nextInt();
      sum+=photoSet[i][0];
      totalWeidth[i]=sum ;
      Height[i]=new element(photoSet[i][1],i);
    }
    Arrays.sort(Height);
    for(int i=0 ; i<n ; i++){
      int weidth,height=Integer.MIN_VALUE ;
      if(i!=Height[n-1] .index){
        height=Height[n-1] .ai ;
      }
      else {
        height=Height[n-2] .ai ;
      }
      weidth=sum-photoSet[i][0];
      System.out.print((weidth*height)+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Photo_to_Remember {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   attribute photoSet : Sequence(Sequence(int));
  static class element implements Comparable<element> {
   attribute ai : int;
   static operation newelement( ai : int, index : int) : element
  pre: true
  post: true
  activity:
  ( var self : element ;
    self := createelement();
    self.initialise(ai, index);
    return self );
  operation initialise( ai : int, index : int) : void
  pre: true  post: true
  activity: (     self.ai := ai ; 
     self.index := index );
   operation compareTo( t : element) : int
  pre: true
  post: true
  activity: (     return self.ai - t.ai );
}
  static   operation main( amit : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := in.getCurrent()->toInteger() ; 
     photoSet := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ; 
    var totalWeidth : Sequence(int) ; totalWeidth := Integer.subrange(1,n)->collect(0) ;
    var Height : Sequence(element) ; Height := Integer.subrange(1,n)->collect(null) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     photoSet[i+1][0+1] := in.getCurrent()->toInteger() ; 
     photoSet[i+1][1+1] := in.getCurrent()->toInteger() ; 
    sum := sum+(photoSet[i+1][0+1]) ; 
    totalWeidth[i+1] := sum ; 
    Height[i+1] := element.newelement(photoSet[i+1][1+1], i) ; 
 )  ;     i := i + 1 ) ; 
    Height := Height->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     var weidth : int ;
    var height : int ; height := -2147483648 ;
     if (i /= Height[n - 1+1].index) then (     height := Height[n - 1+1].ai ) else (     height := Height[n - 2+1].ai ) ;  
     weidth := sum - photoSet[i+1][0+1] ; 
     OclFile["System.out"].print((weidth * height) + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class p522B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),w=0 ;
    int a[]=new int[n],m[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      m[i]=sc.nextInt();
      w+=a[i];
    }
    int b[]=m.clone();
    Arrays.sort(b);
    for(int i=0 ; i<n ; i++){
      int x=w-a[i];
      int h=m[i]==b[n-1] ? b[n-2] : b[n-1];
      System.out.print(x*h+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class p522B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var w : int ; w := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var m : Sequence(void) ; m := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     m[i+1] := sc.getCurrent()->toInteger() ; 
     w := w+(a[i+1]) )  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := m->copy() ;
    b := b->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := w - a[i+1] ;
     var h : int ; h := if m[i+1] = b[n - 1+1] then b[n - 2+1] else b[n - 1+1] endif ;
     OclFile["System.out"].print(x * h + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMod4(String s,int n){
    int k ;
    if(n==1)k=s.charAt(0)-'0' ;
    else k=(s.charAt(n-2)-'0')*10+s.charAt(n-1)-'0' ;
    return(k % 4);
  }
  public static void main(String[] args){
    String s="81" ;
    int n=s.length();
    System.out.println(findMod4(s,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMod4( s : String, n : int) : int
  pre: true
  post: true
  activity: (     var k : int ;
     if (n = 1) then     k := s->at(0+1) - ('0')->char2byte() else     k := (s->at(n - 2+1) - ('0')->char2byte()) * 10 + s->at(n - 1+1) - ('0')->char2byte() ; ;  
     return (k mod 4) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "81" ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].println(findMod4(s, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class notafraid {
  public static void main(String[] args)throws IOException {
    BufferedReader fin=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(fin.readLine());
    int n=Integer.parseInt(st.nextToken());
    int m=Integer.parseInt(st.nextToken());
    boolean traitor=false ;
    for(int i=0 ; i<m ; i++){
      HashSet<Integer>dict=new HashSet<Integer>();
      st=new StringTokenizer(fin.readLine());
      int k=Integer.parseInt(st.nextToken());
      traitor=true ;
      for(int j=0 ; j<k ; j++){
        int input=Integer.parseInt(st.nextToken());
        if(dict.contains(-input)){
          traitor=false ;
          break ;
        }
        else {
          dict.add(input);
        }
      }
      if(traitor){
        break ;
      }
    }
    System.out.println(traitor ? "YES" : "NO");
    fin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class notafraid {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fin : OclFile ; fin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(fin.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var traitor : boolean ; traitor := false ;
        var i : int ; i := 0 ; while i < m do ( (     var dict : Set(int) ; dict := Set{} ;
     st := OclIterator.newOclIterator_String(fin.readLine()) ; 
    var k : int ; k := (st.next())->toInteger() ;
    traitor := true ; 
        var j : int ; j := 0 ; while j < k do ( (     var input : int ; input := (st.next())->toInteger() ;
     if (dict->includes(-input)) then (     traitor := false ; 
     break ) else (     dict := dict->including(input) ) )  ;     j := j + 1 ) ; 
    if (traitor) then (     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if traitor then "YES" else "NO" endif) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),g=sc.nextInt();
    while(g-->0){
      int k=sc.nextInt();
      boolean f=true ;
      Set<Integer>set=new HashSet();
      for(int i=0 ; i<k ; i++){
        int a=sc.nextInt();
        set.add(a);
        if(set.contains(-1*a)){
          f=false ;
        }
      }
      if(f){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var g : int ; g := sc.getCurrent()->toInteger() ;
         while (g > 0) do (        g := g - 1 ;     skip ; (     var k : int ; k := sc.getCurrent()->toInteger() ;
     var f : boolean ; f := true ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < k do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     set := set->including(a) ; 
     if (set->includes(-1 * a)) then (     f := false ) else skip )  ;     i := i + 1 ) ; 
    if (f) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
 ) ;  ) ;  
     OclFile["System.out"].println("NO") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import com.sun.org.apache.bcel.internal.generic.AALOAD ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.math.BigInteger ;
import java.util.*;
import java.util.stream.IntStream ;
import javafx.util.Pair ;
public class Main {
  static void sort(int a[]){
    Random ran=new Random();
    for(int i=0 ; i<a.length ; i++){
      int r=ran.nextInt(a.length);
      int temp=a[r];
      a[r]=a[i];
      a[i]=temp ;
    }
    Arrays.sort(a);
  }
  public static void main(String[] args)throws IOException {
    Scanner input=new Scanner(System.in);
    int n,m ;
    n=input.nextInt();
    m=input.nextInt();
    for(int i=0 ; i<m ; i++){
      int q=input.nextInt();
      TreeSet<Integer>set=new TreeSet<>();
      for(int j=0 ; j<q ; j++){
        int value=input.nextInt();
        set.add(value);
      }
      boolean check=false ;
      for(int j=1 ; j<=n ; j++){
        if(set.contains(j)&& set.contains(-j)){
          check=true ;
        }
      }
      if(! check){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var ran : OclRandom ; ran := OclRandom.newOclRandom() ;
         var i : int ; i := 0 ; while i < a->size() do ( (     var r : int ; r := ran.nextInt(a->size()) ;
     var temp : int ; temp := a[r+1] ;
     a[r+1] := a[i+1] ; 
     a[i+1] := temp )  ;     i := i + 1 ) ; 
     a := a->sort() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var m : int ;
    n := input.getCurrent()->toInteger() ; 
    m := input.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < m do ( (     var q : int ; q := input.getCurrent()->toInteger() ;
     var set : Set(int) ; set := Set{} ;
        var j : int ; j := 0 ; while j < q do ( (     var value : int ; value := input.getCurrent()->toInteger() ;
     set := set->including(value) )  ;     j := j + 1 ) ; 
    var check : boolean ; check := false ;
        var j : int ; j := 1 ; while j <= n do ( (     if (set->includes(j) & set->includes(-j)) then (     check := true ) else skip )  ;     j := j + 1 ) ; 
    if (not(check)) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),g=sc.nextInt();
    while(g-->0){
      int k=sc.nextInt();
      boolean f=true ;
      Set<Integer>set=new HashSet<>();
      for(int i=0 ; i<k ; i++){
        int a=sc.nextInt();
        set.add(a);
        if(set.contains(-1*a))f=false ;
      }
      if(f){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var g : int ; g := sc.getCurrent()->toInteger() ;
         while (g > 0) do (        g := g - 1 ;     skip ; (     var k : int ; k := sc.getCurrent()->toInteger() ;
     var f : boolean ; f := true ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < k do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     set := set->including(a) ; 
     if (set->includes(-1 * a)) then     f := false ; else skip )  ;     i := i + 1 ) ; 
    if (f) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
 ) ;  ) ;  
     OclFile["System.out"].println("NO") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPerfect(int n){
    int sum=1 ;
    for(int i=2 ; i*i<=n ; i++){
      if(n % i==0){
        if(i*i!=n)sum=sum+i+n/i ;
        else sum=sum+i ;
      }
    }
    if(sum==n && n!=1)return true ;
    return false ;
  }
  public static void main(String[] args){
    System.out.println("Below are all perfect"+"numbers till 10000");
    for(int n=2 ; n<10000 ; n++)if(isPerfect(n))System.out.println(n+" is a perfect number");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPerfect( n : int) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 1 ;
         var i : int ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     if (i * i /= n) then     sum := sum + i + n / i ; else     sum := sum + i ; ) else skip )  ;     i := i + 1 ) ; 
     if (sum = n & n /= 1) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Below are all perfect" + "numbers till 10000") ; 
         var n : int ; n := 2 ; while n < 10000 do (     if (isPerfect(n)) then     OclFile["System.out"].println(n + " is a perfect number") ; else skip ;  ;     n := n + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),zero=0 ;
    long[] arr=new long[n];
    long ans=1 ;
    for(int i=0 ; i<n ; ++i){
      arr[i]=in.nextLong();
      if(arr[i]==0)zero=1 ;
    }
    if(zero==1){
      System.out.println("0");
      return ;
    }
    for(int i=0 ; i<n ; ++i){
      if(ans<=1000000000000000000L/arr[i])ans=ans*arr[i];
      else {
        System.out.println("-1");
        return ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var zero : int ; zero := 0 ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
    var ans : long ; ans := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toLong() ; 
     if (arr[i+1] = 0) then     zero := 1 ; else skip )  ;     i := i + 1 ) ; 
    if (zero = 1) then (     OclFile["System.out"].println("0") ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     if (ans <= 1000000000000000000L / arr[i+1]) then     ans := ans * arr[i+1] ; else (     OclFile["System.out"].println("-1") ; 
     return ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.Arrays ;
import java.util.List ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    String line=bufferedReader.readLine();
    int N=Integer.parseInt(line);
    String[] lines=bufferedReader.readLine().split(" ");
    List<String>Astr=Arrays.asList(lines);
    for(String s : Astr){
      if(s.equals("0")){
        System.out.println("0");
        return ;
      }
    }
    List<BigInteger>A=Astr.stream().map(BigInteger :: new).collect(Collectors.toList());
    BigInteger res=new BigInteger("1");
    BigInteger lim=new BigInteger("1000000000000000000");
    for(BigInteger a : A){
      res=res.multiply(a);
      if(res.compareTo(lim)>0){
        System.out.println("-1");
        return ;
      }
    }
    System.out.println(res.compareTo(lim)>0 ? "-1" : res.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := bufferedReader.readLine() ;
    var N : int ; N := (line)->toInteger() ;
    var lines : Sequence(String) ; lines := bufferedReader.readLine()->split(" ") ;
    var Astr : Sequence(String) ; Astr := lines ;
    for (s : Astr) do ( (     if (s = "0") then (     OclFile["System.out"].println("0") ; 
     return ) else skip )  ) ; 
    var A : Sequence(long) ; A := Astr->collect( _x1 | (lambda _pars : OclAny in long.newlong().new(_pars))->apply(_x1) ).collect(Collectors.toList()) ;
    var res : long ; res := long("1") ;
    var lim : long ; lim := long("1000000000000000000") ;
    for (a : A) do ( (     res := res.multiply(a) ; 
     if (res->compareTo(lim) > 0) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip )  ) ; 
    OclFile["System.out"].println(if res->compareTo(lim) > 0 then "-1" else res+"" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s="1" ;
    BigDecimal biga=new BigDecimal(s);
    BigDecimal one=new BigDecimal(s);
    String[] array=new String[n];
    for(int i=0 ; i<n ; i++){
      array[i]=sc.next();
      if(array[i] .equals("0")){
        System.out.println(0);
        sc.close();
        return ;
      }
    }
    for(int i=0 ; i<n ; i++){
      BigDecimal bigb=new BigDecimal(array[i]);
      biga=biga.multiply(bigb);
      if(biga.subtract(one).toString().length()>18){
        System.out.println(-1);
        sc.close();
        return ;
      }
      biga.add(one);
    }
    String aa=biga.toString();
    long bb=Long.parseLong(aa);
    System.out.println(bb);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := "1" ;
    var biga : double ; biga := double(s) ;
    var one : double ; one := double(s) ;
    var array : Sequence(String) ; array := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := sc.getCurrent() ; 
     if (array[i+1] = "0") then (     OclFile["System.out"].println(0) ; 
     skip ; 
     return ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var bigb : double ; bigb := double(array[i+1]) ;
     biga := biga.multiply(bigb) ; 
     if (biga.subtract(one)+""->size() > 18) then (     OclFile["System.out"].println(-1) ; 
     skip ; 
     return ) else skip ; 
     biga->excludes(one) )  ;     i := i + 1 ) ; 
    var aa : String ; aa := biga+"" ;
    var bb : long ; bb := (aa)->toLong() ;
    OclFile["System.out"].println(bb) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    long num[]=new long[N];
    long answer=1 ;
    long max=1000000000000000000L ;
    for(int i=0 ; i<N ; i++){
      num[i]=scan.nextLong();
    }
    Arrays.sort(num);
    for(Long tmp : num){
      if(tmp==0){
        answer=0 ;
        break ;
      }
      else if(tmp<=(max/answer)){
        answer*=tmp ;
      }
      else {
        answer=-1 ;
        break ;
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var num : Sequence(long) ; num := Integer.subrange(1,N)->collect(0) ;
    var answer : long ; answer := 1 ;
    var max : long ; max := 1000000000000000000L ;
        var i : int ; i := 0 ; while i < N do ( (     num[i+1] := scan.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    num := num->sort() ; 
    for (tmp : num) do ( (     if (tmp = 0) then (     answer := 0 ; 
     break ) else     if (tmp <= (max / answer)) then (     answer := answer*(tmp) ) else (     answer := -1 ; 
     break ) ;  )  ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    BigInteger limit=new BigInteger("10").pow(18);
    BigInteger error=new BigInteger("-1");
    int n=sc.nextInt();
    BigInteger result=BigInteger.ONE ;
    for(int i=0 ; i<n ; i++){
      BigInteger a=new BigInteger(sc.next());
      if(a.compareTo(BigInteger.ZERO)==0){
        System.out.println(0);
        return ;
      }
      if(result!=error){
        result=result.multiply(a);
        if(result.compareTo(limit)>0){
          result=error ;
        }
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var limit : long ; limit := long("10").pow(18) ;
    var error : long ; error := long("-1") ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var result : long ; result := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : long ; a := long(sc.getCurrent()) ;
     if (a->compareTo(0) = 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
     if (result /= error) then (     result := result.multiply(a) ; 
     if (result->compareTo(limit) > 0) then (     result := error ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class counting_kangaroos_is_fun {
  public static void main(String[] args){
    Kattio io=new Kattio();
    int n=io.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=io.nextInt();
    }
    Arrays.sort(arr);
    int lo=0 ;
    int hi=n ;
    while(lo<hi){
      int mid=(lo+hi)/2 ;
      if(arr[mid]<=arr[n-1]/2){
        lo=mid+1 ;
      }
      else {
        hi=mid ;
      }
    }
    lo--;
    int pos1=n-1 ;
    int counter=0 ;
    while(lo>=0){
      if(arr[pos1]/2>=arr[lo]){
        counter++;
        pos1--;
        lo--;
      }
      else {
        lo--;
      }
    }
    io.print(Math.max(n-counter,(n-1)/2+1));
    io.close();
  }
  static class Kattio extends PrintWriter {
    private BufferedReader r ;
    private StringTokenizer st ;
    public Kattio(){
      this(System.in,System.out);
    }
    public Kattio(InputStream i,OutputStream o){
      super(o);
      r=new BufferedReader(new InputStreamReader(i));
    }
    public Kattio(String problemName)throws IOException {
      super(problemName+".out");
      r=new BufferedReader(new FileReader(problemName+".in"));
    }
    public String next(){
      try {
        while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(r.readLine());
        return st.nextToken();
      }
      catch(Exception e){
      }
      return null ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class counting_kangaroos_is_fun {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : Kattio ; io := Kattio.newKattio() ;
     var n : int ; n := io.nextInt() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := io.nextInt() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var lo : int ; lo := 0 ;
    var hi : int ; hi := n ;
    while (lo < hi) do (     var mid : int ; mid := (lo + hi) / 2 ;
     if (arr[mid+1] <= arr[n - 1+1] / 2) then (     lo := mid + 1 ) else (     hi := mid ) ) ; 
    lo := lo - 1 ; 
    var pos1 : int ; pos1 := n - 1 ;
    var counter : int ; counter := 0 ;
    while (lo >= 0) do (     if (arr[pos1+1] / 2 >= arr[lo+1]) then (     counter := counter + 1 ; 
     pos1 := pos1 - 1 ; 
     lo := lo - 1 ) else (     lo := lo - 1 ) ) ; 
    io.print(Set{n - counter, (n - 1) / 2 + 1}->max()) ; 
    io.close() ; 
 );
  static class Kattio extends OclFile {
   attribute r : OclFile;
   attribute st : OclIterator;
   static operation newKattio() : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile["System.in"], OclFile["System.out"]) );
   static operation newKattio( i : OclFile, o : OclFile) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(i, o);
    return self );
  operation initialise( i : OclFile, o : OclFile) : void
  pre: true  post: true
  activity: (     execute super(o) ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(i)) );
   static operation newKattio( problemName : String) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(problemName);
    return self );
  operation initialise( problemName : String) : void
  pre: true  post: true
  activity: (     execute super(problemName + ".out") ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(problemName + ".in")) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(r.readLine()) ; ; 
     return st.next() )   catch (e : ProgramException) do skip
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findSet(int arr[],int n,int k,int m){
    Vector<Integer>[] remainder_set=new Vector[k];
    for(int i=0 ; i<k ; i++){
      remainder_set[i]=new Vector<Integer>();
    }
    for(int i=0 ; i<n ; i++){
      int rem=arr[i] % k ;
      remainder_set[rem] .add(arr[i]);
    }
    for(int i=0 ; i<k ; i++){
      if(remainder_set[i] .size()>=m){
        System.out.println("Yes");
        for(int j=0 ; j<m ; j++)System.out.print(remainder_set[i] .get(j)+" ");
        return ;
      }
    }
    System.out.print("No");
  }
  public static void main(String[] args){
    int arr[]={
      5,8,9,12,13,7,11,15 };
      int k=4 ;
      int m=3 ;
      int n=arr.length ;
      findSet(arr,n,k,m);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSet( arr : Sequence(int), n : int, k : int, m : int) : void
  pre: true
  post: true
  activity: (     var remainder_set : Sequence(Sequence(int)) ; remainder_set := Integer.subrange(1,k)->collect(null) ;
         var i : int ; i := 0 ; while i < k do ( (     remainder_set[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var rem : int ; rem := arr[i+1] mod k ;
     remainder_set[rem+1]->excludes(arr[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do ( (     if (remainder_set[i+1]->size() >= m) then (     OclFile["System.out"].println("Yes") ; 
         var j : int ; j := 0 ; while j < m do (     OclFile["System.out"].print(remainder_set[i+1]->at(j+1) + " ") ;  ;     j := j + 1 ) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("No") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,8,9,12,13,7,11,15} ;
     var k : int ; k := 4 ;
    var m : int ; m := 3 ;
    var n : int ; n := arr->size() ;
    execute findSet(arr, n, k, m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findBalance(int x,float bal){
    if(x % 10==0 &&((float)x+1.50)<=bal){
      System.out.printf("%.2f\n",bal-x-1.50);
    }
    else {
      System.out.printf("%.2f\n",bal);
    }
  }
  public static void main(String[] args){
    int x=50 ;
    float bal=(float)100.50 ;
    findBalance(x,bal);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findBalance( x : int, bal : double) : void
  pre: true
  post: true
  activity: (     if (x mod 10 = 0 & (x->oclAsType(double) + 1.50) <= bal) then (     OclFile["System.out"].printf("%.2f\n", bal - x - 1.50) ) else (     OclFile["System.out"].printf("%.2f\n", bal) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 50 ;
     var bal : double ; bal := 100.50->oclAsType(double) ;
     execute findBalance(x, bal) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static boolean divisible(String N,int digit){
    int ans=0 ;
    for(int i=0 ; i<N.length(); i++){
      ans=(ans*10+(N.charAt(i)-'0'));
      ans %=digit ;
    }
    return(ans==0);
  }
  static int allDigits(String N){
    Boolean[] divide=new Boolean[10];
    Arrays.fill(divide,Boolean.FALSE);
    divide[1]=true ;
    for(int digit=2 ; digit<=9 ; digit++){
      if(divisible(N,digit))divide[digit]=true ;
    }
    int result=0 ;
    for(int i=0 ; i<N.length(); i++){
      if(divide[N.charAt(i)-'0']==true)result++;
    }
    return result ;
  }
  public static void main(String args[]){
    String N="122324" ;
    System.out.println(allDigits(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation divisible( N : String, digit : int) : boolean
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < N->size() do ( (     ans := (ans * 10 + (N->at(i+1) - ('0')->char2byte())) ; 
     ans := ans mod digit )  ;     i := i + 1 ) ; 
     return (ans = 0) );
  static   operation allDigits( N : String) : int
  pre: true
  post: true
  activity: (     var divide : Sequence(Boolean) ; divide := Integer.subrange(1,10)->collect(null) ;
     divide := divide->collect(false) ; 
    divide[1+1] := true ; 
        var digit : int ; digit := 2 ; while digit <= 9 do ( (     if (divisible(N, digit)) then     divide[digit+1] := true ; else skip )  ;     digit := digit + 1 ) ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < N->size() do ( (     if (divide[N->at(i+1) - ('0')->char2byte()+1] = true) then     result := result + 1 ; else skip )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : String ; N := "122324" ;
     OclFile["System.out"].println(allDigits(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPower(int n){
    for(int x=2 ; x<=Math.sqrt(n); x++){
      int y=2 ;
      double p=Math.pow(x,y);
      while(p<=n && p>0){
        if(p==n)return true ;
        y++;
        p=Math.pow(x,y);
      }
    }
    return false ;
  }
  public static void main(String[] args){
    for(int i=2 ; i<100 ; i++)if(isPower(i))System.out.print(i+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPower( n : int) : boolean
  pre: true
  post: true
  activity: (         var x : int ; x := 2 ; while x <= (n)->sqrt() do ( (     var y : int ; y := 2 ;
     var p : double ; p := x->pow(y) ;
     while (p <= n & p > 0) do (     if (p = n) then     return true else skip ; 
     y := y + 1 ; 
     p := x->pow(y) ) )  ;     x := x + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i < 100 do (     if (isPower(i)) then     OclFile["System.out"].print(i + " ") ; else skip ;  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int a=0,b=0 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=i+1 ; j<=n ; j++){
        if(i+j==n){
          int numerator=j ;
          int denominator=i ;
          int remainder=numerator % denominator ;
          while(remainder!=0){
            numerator=denominator ;
            denominator=remainder ;
            remainder=numerator % denominator ;
          }
          int gcd=denominator ;
          if(gcd==1){
            a=i ;
            b=j ;
          }
        }
      }
    }
    System.out.printf("%d %d\n",a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i + 1 ; while j <= n do ( (     if (i + j = n) then (     var numerator : int ; numerator := j ;
     var denominator : int ; denominator := i ;
    var remainder : int ; remainder := numerator mod denominator ;
    while (remainder /= 0) do (     numerator := denominator ; 
     denominator := remainder ; 
     remainder := numerator mod denominator ) ; 
    var gcd : int ; gcd := denominator ;
    if (gcd = 1) then (     a := i ; 
     b := j ) else skip ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%d %d\n", a, b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedOutputStream ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class ProblemA {
  public static void main(String[] args)throws IOException {
    ProblemA solver=new ProblemA();
    solver.init();
    solver.solve();
  }
  void init(){
  }
  private void solve()throws IOException {
    Reader in=new Reader(System.in);
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    int T=in.nextInt();
    for(int t=1 ; t<=T ; t++){
      int R=in.nextInt();
      int C=in.nextInt();
      int W=in.nextInt();
      int r=(C/W)*R ;
      r+=(W-1);
      if((C % W)>0)r++;
      out.println("Case #"+t+": "+r);
    }
    out.flush();
    out.close();
  }
  private static class Reader {
    BufferedReader reader ;
    StringTokenizer tokenizer ;
    Reader(InputStream input){
      reader=new BufferedReader(new InputStreamReader(input));
      tokenizer=new StringTokenizer("");
    }
    public void skipLine()throws IOException {
      reader.readLine();
    }
    public String next()throws IOException {
      while(! tokenizer.hasMoreTokens()){
        tokenizer=new StringTokenizer(reader.readLine());
      }
      return tokenizer.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var solver : ProblemA ; solver := ProblemA.newProblemA() ;
     solver.init() ; 
     solver.solve() );
   operation init() : void
  pre: true
  post: true
  activity: skip;
   operation solve() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= T do ( (     var R : int ; R := in.getCurrent()->toInteger() ;
     var C : int ; C := in.getCurrent()->toInteger() ;
    var W : int ; W := in.getCurrent()->toInteger() ;
    var r : int ; r := (C / W) * R ;
    r := r+((W - 1)) ; 
    if ((C mod W) > 0) then     r := r + 1 ; else skip ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class Reader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newReader( input : OclFile) : Reader
  pre: true
  post: true
  activity:
  ( var self : Reader ;
    self := createReader();
    self.initialise(input);
    return self );
  operation initialise( input : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(input)) ; 
     tokenizer := OclIterator.newOclIterator_String("") );
   operation skipLine() : void
  pre: true
  post: true
  activity: (     skip );
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int number=in.nextInt();
    int numerator=number/2 ;
    int denominator=number-numerator ;
    if(numerator==denominator){
      numerator--;
      denominator++;
      if(numerator % 2==0 && denominator % 2==0){
        numerator--;
        denominator++;
      }
    }
    System.out.println(numerator+" "+denominator);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := in.getCurrent()->toInteger() ;
    var numerator : int ; numerator := number / 2 ;
    var denominator : int ; denominator := number - numerator ;
    if (numerator = denominator) then (     numerator := numerator - 1 ; 
     denominator := denominator + 1 ; 
     if (numerator mod 2 = 0 & denominator mod 2 = 0) then (     numerator := numerator - 1 ; 
     denominator := denominator + 1 ) else skip ) else skip ; 
    OclFile["System.out"].println(numerator + " " + denominator) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int ans1=0 ;
    if(n % 2==0 && n % 4!=0){
      ans1=n/2+2 ;
    }
    else {
      ans1=n/2+1 ;
    }
    System.out.println(n-ans1+" "+ans1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var ans1 : int ; ans1 := 0 ;
    if (n mod 2 = 0 & n mod 4 /= 0) then (     ans1 := n / 2 + 2 ) else (     ans1 := n / 2 + 1 ) ;  
    OclFile["System.out"].println(n - ans1 + " " + ans1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int l=sc.nextInt();
      int ans1=0,ans2=0 ;
      for(int i=1 ; i<l-1 ; i++){
        for(int j=i+1 ; j<l ; j++){
          if((gcd(i,j)==1)&&(i+j==l)){
            ans1=i ;
            ans2=j ;
            break ;
          }
        }
      }
      System.out.println(ans1+" "+ans2);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var ans1 : int ; ans1 := 0 ;
    var ans2 : int ; ans2 := 0 ;
        var i : int ; i := 1 ; while i < l - 1 do ( (         var j : int ; j := i + 1 ; while j < l do ( (     if ((gcd(i, j) = 1) & (i + j = l)) then (     ans1 := i ; 
     ans2 := j ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans1 + " " + ans2) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getMinimumSum(int arr[],int n){
    int ans=Integer.MAX_VALUE ;
    for(int i=0 ; i<n-2 ; i++){
      for(int j=i+1 ; j<n-1 ; j++){
        for(int k=j+1 ; k<n ; k++){
          ans=Math.min(ans,arr[i]+arr[j]+arr[k]);
        }
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,-1,5,-2 };
      int n=arr.length ;
      System.out.print(getMinimumSum(arr,n)+"\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getMinimumSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 2147483647 ;
         var i : int ; i := 0 ; while i < n - 2 do ( (         var j : int ; j := i + 1 ; while j < n - 1 do ( (         var k : int ; k := j + 1 ; while k < n do ( (     ans := Set{ans, arr[i+1] + arr[j+1] + arr[k+1]}->min() )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,-1,5,-2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(getMinimumSum(arr, n) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class find {
  public static void main(String args[]){
    int[] arr={
      1,5,7,-1,5 };
      int sum=6 ;
      getPairsCount(arr,sum);
    }
    public static void getPairsCount(int[] arr,int sum){
      int count=0 ;
      for(int i=0 ; i<arr.length ; i++)for(int j=i+1 ; j<arr.length ; j++)if((arr[i]+arr[j])==sum)count++;
      System.out.printf("Count of pairs is %d",count);
    }
  }

------------------------------------------------------------
OCL File:
---------
class find {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,7,-1,5} ;
     var sum : int ; sum := 6 ;
     execute getPairsCount(arr, sum) );
  static   operation getPairsCount( arr : Sequence(int), sum : int) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < arr->size() do (         var j : int ; j := i + 1 ; while j < arr->size() do (     if ((arr[i+1] + arr[j+1]) = sum) then     count := count + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].printf("Count of pairs is %d", count) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int arr[]=new int[] {
    1,20,6,4,5 };
    static int getInvCount(int n){
      int inv_count=0 ;
      for(int i=0 ; i<n-1 ; i++)for(int j=i+1 ; j<n ; j++)if(arr[i]>arr[j])inv_count++;
      return inv_count ;
    }
    public static void main(String[] args){
      System.out.println("Number of inversions are "+getInvCount(arr.length));
    }
  }

------------------------------------------------------------
OCL File:
---------
class Test {
  static   attribute arr : int := Sequence{1,20,6,4,5};
  static   operation getInvCount( n : int) : int
  pre: true
  post: true
  activity: (     var inv_count : int ; inv_count := 0 ;
         var i : int ; i := 0 ; while i < n - 1 do (         var j : int ; j := i + 1 ; while j < n do (     if (arr[i+1] > arr[j+1]) then     inv_count := inv_count + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return inv_count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Number of inversions are " + getInvCount(arr->size())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static Boolean isPalindrome(String str){
    int n=str.length();
    for(int i=0 ; i<n/2 ; i++)if(str.charAt(i)!=str.charAt(n-i-1))return false ;
    return true ;
  }
  static int maxLengthNonPalinSubstring(String str){
    int n=str.length();
    char ch=str.charAt(0);
    int i=1 ;
    for(i=1 ; i<n ; i++)if(str.charAt(i)!=ch)break ;
    if(i==n)return 0 ;
    if(isPalindrome(str))return n-1 ;
    return n ;
  }
  public static void main(String args[]){
    String str="abba" ;
    System.out.println("Maximum Length="+maxLengthNonPalinSubstring(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPalindrome( str : String) : Boolean
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
         var i : int ; i := 0 ; while i < n / 2 do (     if (str->at(i+1) /= str->at(n - i - 1+1)) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation maxLengthNonPalinSubstring( str : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var ch : String ; ch := str->at(0+1) ;
    var i : int ; i := 1 ;
        i := 1 ; while i < n do (     if (str->at(i+1) /= ch) then     break else skip ;  ;     i := i + 1 ) ; 
    if (i = n) then     return 0 else skip ; 
    if (isPalindrome(str)) then     return n - 1 else skip ; 
    return n 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abba" ;
     OclFile["System.out"].println("Maximum Length=" + maxLengthNonPalinSubstring(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int power(int x,int y,int p){
    int res=1 ;
    x=x % p ;
    while(y>0){
      if((y & 1)!=0)res=(res*x)% p ;
      y=y>>1 ;
      x=(x*x)% p ;
    }
    return res ;
  }
  static int NearestElement(int A,int D,int P){
    if(A==0)return 0 ;
    else if(D==0)return-1 ;
    else {
      int X=power(D,P-2,P);
      return(X*(P-A))% P ;
    }
  }
  public static void main(String args[]){
    int A=4,D=9,P=11 ;
    A %=P ;
    D %=P ;
    System.out.println(NearestElement(A,D,P));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation power( x : int, y : int, p : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     if ((y & 1) /= 0) then     res := (res * x) mod p ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res );
  static   operation NearestElement( A : int, D : int, P : int) : int
  pre: true
  post: true
  activity: (     if (A = 0) then     return 0 else     if (D = 0) then     return -1 else (     var X : int ; X := power(D, P - 2, P) ;
     return (X * (P - A)) mod P ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 4 ;
    var D : int ; D := 9 ;
    var P : int ; P := 11 ;
     A := A mod P ; 
     D := D mod P ; 
     OclFile["System.out"].println(NearestElement(A, D, P)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPower(int n){
    for(int x=2 ; x<=Math.sqrt(n); x++){
      int p=x ;
      while(p<=n){
        p=p*x ;
        if(p==n)return true ;
      }
    }
    return false ;
  }
  public static void main(String[] args){
    for(int i=2 ; i<100 ; i++)if(isPower(i))System.out.print(i+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPower( n : int) : boolean
  pre: true
  post: true
  activity: (         var x : int ; x := 2 ; while x <= (n)->sqrt() do ( (     var p : int ; p := x ;
     while (p <= n) do (     p := p * x ; 
     if (p = n) then     return true else skip ) )  ;     x := x + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i < 100 do (     if (isPower(i)) then     OclFile["System.out"].print(i + " ") ; else skip ;  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int Rate(int N1,int N2){
    float rate=(N2-N1)*100/N1 ;
    return(int)rate ;
  }
  public static void main(String[] args){
    int N1=100,N2=120 ;
    System.out.println(Rate(N1,N2)+" %");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Rate( N1 : int, N2 : int) : int
  pre: true
  post: true
  activity: (     var rate : double ; rate := (N2 - N1) * 100 / N1 ;
     return rate->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N1 : int ; N1 := 100 ;
    var N2 : int ; N2 := 120 ;
     OclFile["System.out"].println(Rate(N1, N2) + " %") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1499 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      int n=scanner.nextInt();
      int k1=scanner.nextInt();
      int k2=scanner.nextInt();
      int w=scanner.nextInt();
      int b=scanner.nextInt();
      int min=Math.min(k1,k2);
      int max=Math.max(k1,k2);
      if(min+(max-min)/2>=w &&(n-max)+(max-min)/2>=b){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1499 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var k1 : int ; k1 := scanner.getCurrent()->toInteger() ;
    var k2 : int ; k2 := scanner.getCurrent()->toInteger() ;
    var w : int ; w := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var min : int ; min := Set{k1, k2}->min() ;
    var max : int ; max := Set{k1, k2}->max() ;
    if (min + (max - min) / 2 >= w & (n - max) + (max - min) / 2 >= b) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static void printPalindrome(int n){
    if(n==1){
      System.out.println("Smallest Palindrome: 0");
      System.out.println("Largest Palindrome: 9");
    }
    else {
      System.out.println("Smallest Palindrome: "+(int)(Math.pow(10,n-1))+1);
      System.out.println("Largest Palindrome: "+((int)(Math.pow(10,n))-1));
    }
  }
  public static void main(String[] args){
    int n=4 ;
    printPalindrome(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation printPalindrome( n : int) : void
  pre: true
  post: true
  activity: (     if (n = 1) then (     OclFile["System.out"].println("Smallest Palindrome: 0") ; 
     OclFile["System.out"].println("Largest Palindrome: 9") ) else (     OclFile["System.out"].println("Smallest Palindrome: " + (10->pow(n - 1))->oclAsType(int) + 1) ; 
     OclFile["System.out"].println("Largest Palindrome: " + ((10->pow(n))->oclAsType(int) - 1)) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     execute printPalindrome(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public final class A {
  public static void main(final String...args){
    final Scanner sc=new Scanner(System.in);
    final int t=sc.nextInt();
    for(int i=0 ; i<t ; ++i){
      System.out.println(String.format("Case #%d: %d",i+1,testcase(sc)));
    }
  }
  private static int testcase(final Scanner sc){
    final int r=sc.nextInt();
    final int c=sc.nextInt();
    final int w=sc.nextInt();
    return(c/w)*r+(w-1)+(c % w==0 ? 0 : 1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     OclFile["System.out"].println(StringLib.format("Case #%d: %d",Sequence{i + 1,testcase(sc)})) )  ;     i := i + 1 ) );
  static   operation testcase( sc : OclFile) : int
  pre: true
  post: true
  activity: (     var r : int ; r := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
     return (c / w) * r + (w - 1) + (if c mod w = 0 then 0 else 1 endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1499 {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t--!=0){
      int n=in.nextInt();
      int k1=in.nextInt();
      int k2=in.nextInt();
      int w=in.nextInt();
      int b=in.nextInt();
      if(k1+k2>=2*w &&(n-k1+n-k2)>=2*b){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1499 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k1 : int ; k1 := in.getCurrent()->toInteger() ;
    var k2 : int ; k2 := in.getCurrent()->toInteger() ;
    var w : int ; w := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    if (k1 + k2 >= 2 * w & (n - k1 + n - k2) >= 2 * b) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args){
    new A().solve(System.in,System.out);
  }
  public void solve(InputStream in,OutputStream out){
    InputReader inputReader=new InputReader(in);
    PrintWriter writer=new PrintWriter(new BufferedOutputStream(out));
    int t=inputReader.nextInt();
    for(int t1=0 ; t1<t ; t1++){
      int n=inputReader.nextInt();
      int k1=inputReader.nextInt();
      int k2=inputReader.nextInt();
      int w=inputReader.nextInt();
      int b=inputReader.nextInt();
      boolean result=solve(n,k1,k2,w,b);
      writer.println(result ? "YES" : "NO");
    }
    writer.close();
  }
  public boolean solve(int n,int k1,int k2,int w,int b){
    boolean white=solve(n,k1,k2,w);
    boolean black=solve(n,n-k1,n-k2,b);
    return white && black ;
  }
  private boolean solve(int n,int k1,int k2,int w){
    int minK=Math.min(k1,k2);
    int maxK=Math.max(k1,k2);
    return w<=minK+(maxK-minK)/2 ;
  }
  private static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     A.newA().solve(OclFile["System.in"], OclFile["System.out"]) );
   operation solve( in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var inputReader : InputReader ; inputReader := InputReader.newInputReader(in) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(out)) ;
    var t : int ; t := inputReader.nextInt() ;
        var t1 : int ; t1 := 0 ; while t1 < t do ( (     var n : int ; n := inputReader.nextInt() ;
     var k1 : int ; k1 := inputReader.nextInt() ;
    var k2 : int ; k2 := inputReader.nextInt() ;
    var w : int ; w := inputReader.nextInt() ;
    var b : int ; b := inputReader.nextInt() ;
    var result : boolean ; result := solve(n, k1, k2, w, b) ;
    skip ; 
 )  ;     t1 := t1 + 1 ) ; 
    skip ; 
 );
   operation solve( n : int, k1 : int, k2 : int, w : int, b : int) : boolean
  pre: true
  post: true
  activity: (     var white : boolean ; white := solve(n, k1, k2, w) ;
     var black : boolean ; black := solve(n, n - k1, n - k2, b) ;
     return white & black );
   operation solve( n : int, k1 : int, k2 : int, w : int) : boolean
  pre: true
  post: true
  activity: (     var minK : int ; minK := Set{k1, k2}->min() ;
     var maxK : int ; maxK := Set{k1, k2}->max() ;
     return w <= minK + (maxK - minK) / 2 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Soluton {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t!=0){
      int n=sc.nextInt();
      int a=sc.nextInt();
      int b=sc.nextInt();
      int w=sc.nextInt();
      int c=sc.nextInt();
      int k=(a+b)/2 ;
      int p=((n*2)-(a+b))/2 ;
      if(k>=w && p>=c){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Soluton {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t /= 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var k : int ; k := (a + b) / 2 ;
    var p : int ; p := ((n * 2) - (a + b)) / 2 ;
    if (k >= w & p >= c) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF1499A {
  public static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int test=scanner.nextInt();
    for(int i=0 ; i<test ; i++){
      int n=scanner.nextInt();
      int k1=scanner.nextInt();
      int k2=scanner.nextInt();
      int w=scanner.nextInt();
      int b=scanner.nextInt();
      int totalWhiteArea=k1+k2 ;
      int totalBlackArea=2*n-totalWhiteArea ;
      if(totalWhiteArea>=2*w && totalBlackArea>=2*b)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF1499A {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var test : int ; test := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < test do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var k1 : int ; k1 := scanner.getCurrent()->toInteger() ;
    var k2 : int ; k2 := scanner.getCurrent()->toInteger() ;
    var w : int ; w := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var totalWhiteArea : int ; totalWhiteArea := k1 + k2 ;
    var totalBlackArea : int ; totalBlackArea := 2 * n - totalWhiteArea ;
    if (totalWhiteArea >= 2 * w & totalBlackArea >= 2 * b) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Deque ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner kb=new Scanner(System.in);
    int n=kb.nextInt();
    Deque<Integer>positive=new LinkedList<>();
    Deque<Integer>negative=new LinkedList<>();
    Deque<Integer>zero=new LinkedList<>();
    for(int i=0 ; i<n ; i++){
      int in=kb.nextInt();
      if(in>0)positive.add(in);
      else if(in<0)negative.add(in);
      else zero.add(in);
    }
    if(positive.isEmpty()&& negative.size()>2){
      positive.addLast(negative.pollLast());
      positive.addLast(negative.pollLast());
    }
    if(negative.size()% 2==0){
      zero.addLast(negative.pollLast());
    }
    System.out.print(negative.size()+" ");
    while(! negative.isEmpty())System.out.print(negative.pollFirst()+" ");
    System.out.println();
    System.out.print(positive.size()+" ");
    while(! positive.isEmpty())System.out.print(positive.pollFirst()+" ");
    System.out.println();
    System.out.print(zero.size()+" ");
    while(! zero.isEmpty())System.out.print(zero.pollFirst()+" ");
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var kb : OclFile ; kb := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := kb.getCurrent()->toInteger() ;
    var positive : Sequence(int) ; positive := Sequence{} ;
    var negative : Sequence(int) ; negative := Sequence{} ;
    var zero : Sequence(int) ; zero := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var in : int ; in := kb.getCurrent()->toInteger() ;
     if (in > 0) then     positive := positive->including(in) ; else     if (in < 0) then     negative := negative->including(in) else     zero := zero->including(in) ; ;  )  ;     i := i + 1 ) ; 
    if (positive->isEmpty() & negative->size() > 2) then (     positive := positive->append(negative->last()) ; 
     positive := positive->append(negative->last()) ) else skip ; 
    if (negative->size() mod 2 = 0) then (     zero := zero->append(negative->last()) ) else skip ; 
    OclFile["System.out"].print(negative->size() + " ") ; 
    while (not(negative->isEmpty())) do     OclFile["System.out"].print(negative->first() + " ") ; ; 
    OclFile["System.out"].println() ; 
    OclFile["System.out"].print(positive->size() + " ") ; 
    while (not(positive->isEmpty())) do     OclFile["System.out"].print(positive->first() + " ") ; ; 
    OclFile["System.out"].println() ; 
    OclFile["System.out"].print(zero->size() + " ") ; 
    while (not(zero->isEmpty())) do     OclFile["System.out"].print(zero->first() + " ") ; ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Sheet8ProblemA {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    ArrayList<Integer>neg=new ArrayList<Integer>();
    ArrayList<Integer>pos=new ArrayList<Integer>();
    ArrayList<Integer>zero=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      int a=input.nextInt();
      if(a<0)neg.add(a);
      else if(a>0)pos.add(a);
      else zero.add(a);
    }
    if(pos.isEmpty()){
      for(int i=0 ; i<2 ; i++){
        pos.add(neg.get(0));
        neg.remove(0);
      }
    }
    if(neg.size()% 2==0){
      zero.add(neg.get(0));
      neg.remove(0);
    }
    System.out.print(neg.size()+" ");
    for(int i=0 ; i<neg.size(); i++){
      System.out.print(neg.get(i)+" ");
    }
    System.out.println();
    System.out.print(pos.size()+" ");
    for(int i=0 ; i<pos.size(); i++){
      System.out.print(pos.get(i)+" ");
    }
    System.out.println();
    System.out.print(zero.size()+" ");
    for(int i=0 ; i<zero.size(); i++){
      System.out.print(zero.get(i)+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sheet8ProblemA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var neg : Sequence(int) ; neg := Sequence{} ;
    var pos : Sequence(int) ; pos := Sequence{} ;
    var zero : Sequence(int) ; zero := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := input.getCurrent()->toInteger() ;
     if (a < 0) then     neg := neg->including(a) ; else     if (a > 0) then     pos := pos->including(a) else     zero := zero->including(a) ; ;  )  ;     i := i + 1 ) ; 
    if (pos->isEmpty()) then (         var i : int ; i := 0 ; while i < 2 do ( (     pos := pos->including(neg->at(0+1)) ; 
     neg := neg->excludingAt(0+1) )  ;     i := i + 1 ) ) else skip ; 
    if (neg->size() mod 2 = 0) then (     zero := zero->including(neg->at(0+1)) ; 
     neg := neg->excludingAt(0+1) ) else skip ; 
    OclFile["System.out"].print(neg->size() + " ") ; 
        var i : int ; i := 0 ; while i < neg->size() do ( (     OclFile["System.out"].print(neg->at(i+1) + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    OclFile["System.out"].print(pos->size() + " ") ; 
        var i : int ; i := 0 ; while i < pos->size() do ( (     OclFile["System.out"].print(pos->at(i+1) + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    OclFile["System.out"].print(zero->size() + " ") ; 
        var i : int ; i := 0 ; while i < zero->size() do ( (     OclFile["System.out"].print(zero->at(i+1) + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Solution {
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  static void findTwoNumbers(int sum,int gcd){
    if(__gcd(gcd,sum-gcd)==gcd && sum!=gcd)System.out.println("a="+Math.min(gcd,sum-gcd)+",b="+(int)(sum-Math.min(gcd,sum-gcd)));
    else System.out.println(-1);
  }
  public static void main(String args[]){
    int sum=8 ;
    int gcd=2 ;
    findTwoNumbers(sum,gcd);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation findTwoNumbers( sum : int, gcd : int) : void
  pre: true
  post: true
  activity: (     if (__gcd(gcd, sum - gcd) = gcd & sum /= gcd) then     OclFile["System.out"].println("a=" + Set{gcd, sum - gcd}->min() + ",b=" + (sum - Set{gcd, sum - gcd}->min())->oclAsType(int)) ; else     OclFile["System.out"].println(-1) ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 8 ;
     var gcd : int ; gcd := 2 ;
     execute findTwoNumbers(sum, gcd) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ArrayProduct {
  public static void main(String[] args){
    Scanner keybord=new Scanner(System.in);
    int num=keybord.nextInt();
    int[] intArray=new int[num-1];
    int[] intArrayN=new int[1];
    int[] intArrayP=new int[num-2];
    int[] intArrayZ=new int[num-2];
    int couP=0,couN=0,couZ=0 ;
    for(int index=0 ; index<num ; index++){
      int number=keybord.nextInt();
      if(number==0){
        intArrayZ[couZ++]=number ;
      }
      else if(number>0){
        intArrayP[couP++]=number ;
      }
      else intArray[couN++]=number ;
    }
    intArrayN[0]=intArray[0];
    if(couN % 2==0){
      intArrayZ[couZ++]=intArray[1];
      for(int index=2 ; index<couN ; index++){
        intArrayP[couP++]=intArray[index];
      }
    }
    else {
      for(int index=1 ; index<couN ; index++){
        intArrayP[couP++]=intArray[index];
      }
    }
    System.out.print("1 "+intArrayN[0]+"\n"+couP+" ");
    for(int index=0 ; index<couP ; index++){
      System.out.print(intArrayP[index]+" ");
    }
    System.out.print("\n"+couZ+" ");
    for(int index=0 ; index<couZ ; index++){
      System.out.print(intArrayZ[index]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ArrayProduct {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var keybord : OclFile ; keybord := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := keybord.getCurrent()->toInteger() ;
    var intArray : Sequence(int) ; intArray := Integer.subrange(1,num - 1)->collect(0) ;
    var intArrayN : Sequence(int) ; intArrayN := Integer.subrange(1,1)->collect(0) ;
    var intArrayP : Sequence(int) ; intArrayP := Integer.subrange(1,num - 2)->collect(0) ;
    var intArrayZ : Sequence(int) ; intArrayZ := Integer.subrange(1,num - 2)->collect(0) ;
    var couP : int ; couP := 0 ;
    var couN : int ; couN := 0 ;
    var couZ : int ; couZ := 0 ;
        var index : int ; index := 0 ; while index < num do ( (     var number : int ; number := keybord.getCurrent()->toInteger() ;
     if (number = 0) then (      intArrayZ[couZ+1] := number  ; couZ := couZ + 1 ) else     if (number > 0) then (      intArrayP[couP+1] := number  ; couP := couP + 1 ) else      intArray[couN+1] := number  ; couN := couN + 1 ; ;  )  ;     index := index + 1 ) ; 
    intArrayN[0+1] := intArray[0+1] ; 
    if (couN mod 2 = 0) then (      intArrayZ[couZ+1] := intArray[1+1]  ; couZ := couZ + 1 ; 
         var index : int ; index := 2 ; while index < couN do ( (      intArrayP[couP+1] := intArray[index+1]  ; couP := couP + 1 )  ;     index := index + 1 ) ) else (         var index : int ; index := 1 ; while index < couN do ( (      intArrayP[couP+1] := intArray[index+1]  ; couP := couP + 1 )  ;     index := index + 1 ) ) ;  
    OclFile["System.out"].print("1 " + intArrayN[0+1] + "\n" + couP + " ") ; 
        var index : int ; index := 0 ; while index < couP do ( (     OclFile["System.out"].print(intArrayP[index+1] + " ") )  ;     index := index + 1 ) ; 
    OclFile["System.out"].print("\n" + couZ + " ") ; 
        var index : int ; index := 0 ; while index < couZ do ( (     OclFile["System.out"].print(intArrayZ[index+1] + " ") )  ;     index := index + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int nthElement(int a,int b,int n){
    ArrayList<Integer>seq=new ArrayList<Integer>(n*n+1);
    for(int i=1 ; i<=n ; i++)seq.add(a*i);
    Collections.sort(seq);
    for(int i=1,k=n ; i<=n && k>0 ; i++){
      if(seq.indexOf(b*i)==-1){
        seq.add(b*i);
        Collections.sort(seq);
        k--;
      }
    }
    return seq.get(n-1);
  }
  public static void main(String[] args){
    int a=3,b=5,n=5 ;
    System.out.println(nthElement(a,b,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nthElement( a : int, b : int, n : int) : int
  pre: true
  post: true
  activity: (     var seq : Sequence(int) ; seq := Sequence{}->union(n * n + 1) ;
         var i : int ; i := 1 ; while i <= n do (     seq := seq->including(a * i) ;  ;     i := i + 1 ) ; 
    seq := seq->sort() ; 
        var i : int ; i := 1 ;
    var k : int ; k := n ; while i <= n & k > 0 do ( (     if (seq->indexOf(b * i)-1 = -1) then (     seq := seq->including(b * i) ; 
     seq := seq->sort() ; 
     k := k - 1 ) else skip )  ;     i := i + 1 ) ; 
    return seq->at(n - 1+1) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var b : int ; b := 5 ;
    var n : int ; n := 5 ;
     OclFile["System.out"].println(nthElement(a, b, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_Beautiful_Regional_Contest {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; tc++){
      int n=sc.nextInt();
      int[] p=new int[n];
      for(int i=0 ; i<p.length ; i++){
        p[i]=sc.nextInt();
      }
      System.out.println(solve(p));
    }
    sc.close();
  }
  static String solve(int[] p){
    int bronzeEndIndex=p.length/2-1 ;
    while(bronzeEndIndex>=0 && bronzeEndIndex+1<p.length && p[bronzeEndIndex]==p[bronzeEndIndex+1]){
      bronzeEndIndex--;
    }
    if(bronzeEndIndex<0){
      return "0 0 0" ;
    }
    int goldEndIndex=0 ;
    while(p[goldEndIndex]==p[goldEndIndex+1]){
      goldEndIndex++;
    }
    if(goldEndIndex==bronzeEndIndex){
      return "0 0 0" ;
    }
    int silverEndIndex=goldEndIndex+1 ;
    while(p[silverEndIndex]==p[silverEndIndex+1] || silverEndIndex-goldEndIndex<=goldEndIndex+1){
      if(silverEndIndex==bronzeEndIndex){
        return "0 0 0" ;
      }
      silverEndIndex++;
    }
    if(bronzeEndIndex-silverEndIndex<=goldEndIndex+1){
      return "0 0 0" ;
    }
    return String.format("%d %d %d",goldEndIndex+1,silverEndIndex-goldEndIndex,bronzeEndIndex-silverEndIndex);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Beautiful_Regional_Contest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < p->size() do ( (     p[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(solve(p)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( p : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var bronzeEndIndex : int ; bronzeEndIndex := p->size() / 2 - 1 ;
     while (bronzeEndIndex >= 0 & bronzeEndIndex + 1 < p->size() & p[bronzeEndIndex+1] = p[bronzeEndIndex + 1+1]) do (     bronzeEndIndex := bronzeEndIndex - 1 ) ; 
    if (bronzeEndIndex < 0) then (     return "0 0 0" ) else skip ; 
    var goldEndIndex : int ; goldEndIndex := 0 ;
    while (p[goldEndIndex+1] = p[goldEndIndex + 1+1]) do (     goldEndIndex := goldEndIndex + 1 ) ; 
    if (goldEndIndex = bronzeEndIndex) then (     return "0 0 0" ) else skip ; 
    var silverEndIndex : int ; silverEndIndex := goldEndIndex + 1 ;
    while (p[silverEndIndex+1] = p[silverEndIndex + 1+1] or silverEndIndex - goldEndIndex <= goldEndIndex + 1) do (     if (silverEndIndex = bronzeEndIndex) then (     return "0 0 0" ) else skip ; 
     silverEndIndex := silverEndIndex + 1 ) ; 
    if (bronzeEndIndex - silverEndIndex <= goldEndIndex + 1) then (     return "0 0 0" ) else skip ; 
    return StringLib.format("%d %d %d",Sequence{goldEndIndex + 1,silverEndIndex - goldEndIndex,bronzeEndIndex - silverEndIndex}) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class c1681b {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    while(t--!=0){
      int n=scan.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; ++i){
        a[i]=scan.nextInt();
      }
      int m=scan.nextInt();
      long sum=0 ;
      for(int i=0 ; i<m ; ++i){
        sum+=scan.nextInt();
      }
      System.out.println(a[(int)(sum % n)]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class c1681b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     sum := sum+(scan.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a[(sum mod n)->oclAsType(int)+1]) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Main {
  public void solve(int testNumber,FastScanner in,PrintWriter out){
    out.printf("Case #%d: ",testNumber);
    int r=in.nextInt();
    int c=in.nextInt();
    int w=in.nextInt();
    int addRow=c/w*(r-1);
    int inRow=c/w+w ;
    if(c % w==0)inRow--;
    out.println(addRow+inRow);
  }
  public static void main(String[] args)throws IOException {
    FastScanner in=new FastScanner(new FileInputStream("input.txt"));
    PrintWriter out=new PrintWriter("output.txt");
    int t=in.nextInt();
    for(int test=1 ; test<=t ; test++)new Main().solve(test,in,out);
    in.close();
    out.close();
  }
}
class FastScanner {
  private StringTokenizer tokenizer ;
  private BufferedReader reader ;
  public FastScanner(InputStream inputStream){
    reader=new BufferedReader(new InputStreamReader(inputStream));
  }
  public String next(){
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      String line ;
      try {
        line=reader.readLine();
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
      if(line==null)return null ;
      tokenizer=new StringTokenizer(line);
    }
    return tokenizer.nextToken();
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
  public double nextDouble(){
    return Double.parseDouble(next());
  }
  public String nextLine(){
    String line ;
    try {
      line=reader.readLine();
    }
    catch(IOException e){
      throw new RuntimeException(e);
    }
    tokenizer=null ;
    return line ;
  }
  public void close(){
    try {
      reader.close();
    }
    catch(IOException e){
      throw new RuntimeException(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve( testNumber : int, in : FastScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     out.printf("Case #%d: ", testNumber) ; 
     var r : int ; r := in.nextInt() ;
    var c : int ; c := in.nextInt() ;
    var w : int ; w := in.nextInt() ;
    var addRow : int ; addRow := c / w * (r - 1) ;
    var inRow : int ; inRow := c / w + w ;
    if (c mod w = 0) then     inRow := inRow - 1 ; else skip ; 
    out.println(addRow + inRow) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
    var t : int ; t := in.nextInt() ;
        var test : int ; test := 1 ; while test <= t do (     Main.newMain().solve(test, in, out) ;  ;     test := test + 1 ) ; 
    in.close() ; 
    skip ; 
 );
}
class FastScanner {
   attribute tokenizer : OclIterator;
   attribute reader : OclFile;
   static operation newFastScanner( inputStream : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     var line : String ;
     try (     line := reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
     if (line = null) then     return null else skip ; 
     tokenizer := OclIterator.newOclIterator_String(line) ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var line : String ;
     try (     line := reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
     tokenizer := null ; 
     return line );
   operation close() : void
  pre: true
  post: true
  activity: (     try (     skip )   catch (e : IOException) do (     error ProgramException(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      List<Integer>deck=new LinkedList<>();
      for(long i=0 ; i<n ; i++)deck.add(sc.nextInt());
      int cards=deck.size();
      int m=sc.nextInt();
      long suffles=0 ;
      for(int i=0 ; i<m ; i++)suffles+=sc.nextInt();
      int topCardPos=(int)(suffles-(suffles/cards)*cards);
      System.out.println(deck.get(topCardPos));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var deck : Sequence(int) ; deck := Sequence{} ;
        var i : long ; i := 0 ; while i < n do (     deck := deck->including(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    var cards : int ; cards := deck->size() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var suffles : long ; suffles := 0 ;
        var i : int ; i := 0 ; while i < m do (     suffles := suffles+(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    var topCardPos : int ; topCardPos := (suffles - (suffles / cards) * cards)->oclAsType(int) ;
    OclFile["System.out"].println(deck->at(topCardPos+1)) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class helloworld {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      int m=sc.nextInt();
      int ans=0 ;
      for(int i=0 ; i<m ; i++){
        ans=((ans % n)+(sc.nextInt()% n))% n ;
      }
      int val=ans % n ;
      System.out.println(arr[val]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class helloworld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     ans := ((ans mod n) + (sc.getCurrent()->toInteger() mod n)) mod n )  ;     i := i + 1 ) ; 
    var val : int ; val := ans mod n ;
    OclFile["System.out"].println(arr[val+1]) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=input.nextInt();
      }
      int m=input.nextInt();
      int b[]=new int[m];
      long sum=0 ;
      for(int i=0 ; i<m ; i++){
        b[i]=input.nextInt();
        sum+=b[i];
      }
      int mod=(int)(sum % n);
      System.out.println(a[mod]);
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var tc : int ; tc := input.nextInt() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.nextInt() )  ;     i := i + 1 ) ; 
    var m : int ; m := input.nextInt() ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := input.nextInt() ; 
     sum := sum+(b[i+1]) )  ;     i := i + 1 ) ; 
    var mod : int ; mod := (sum mod n)->oclAsType(int) ;
    OclFile["System.out"].println(a[mod+1]) ; 
 ) ;  ) ;  );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1552 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      int[][] A=new int[N][5];
      for(int n=0 ; n<N ; n++){
        for(int i=0 ; i<5 ; i++){
          A[n][i]=in.nextInt();
        }
      }
      int candidate=0 ;
      for(int n=1 ; n<N ; n++){
        int wins=0 ;
        for(int i=0 ; i<5 ; i++){
          if(A[candidate][i]>A[n][i]){
            wins++;
          }
        }
        if(wins>2){
          candidate=n ;
        }
      }
      boolean beatAll=true ;
      for(int n=0 ; n<N ; n++){
        if(n==candidate)continue ;
        int wins=0 ;
        for(int i=0 ; i<5 ; i++){
          if(A[candidate][i]>A[n][i]){
            wins++;
          }
        }
        if(wins>2){
          beatAll=false ;
          break ;
        }
      }
      System.out.println(beatAll ?(candidate+1):-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1552 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var A : Sequence(Sequence(int)) ; A := Integer.subrange(1,N)->collect(Integer.subrange(1,5)->collect(0)) ;
        var n : int ; n := 0 ; while n < N do ( (         var i : int ; i := 0 ; while i < 5 do ( (     A[n+1][i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) )  ;     n := n + 1 ) ; 
    var candidate : int ; candidate := 0 ;
        var n : int ; n := 1 ; while n < N do ( (     var wins : int ; wins := 0 ;
         var i : int ; i := 0 ; while i < 5 do ( (     if (A[candidate+1][i+1] > A[n+1][i+1]) then (     wins := wins + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (wins > 2) then (     candidate := n ) else skip )  ;     n := n + 1 ) ; 
    var beatAll : boolean ; beatAll := true ;
        var n : int ; n := 0 ; while n < N do ( (     if (n = candidate) then     continue else skip ; 
     var wins : int ; wins := 0 ;
         var i : int ; i := 0 ; while i < 5 do ( (     if (A[candidate+1][i+1] > A[n+1][i+1]) then (     wins := wins + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (wins > 2) then (     beatAll := false ; 
     break ) else skip )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(if beatAll then (candidate + 1) else -1 endif) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class practice {
  public static void main(String[] args)throws Exception {
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int arr[][]=new int[n+1][5+1];
      for(int i=1 ; i<=n ; i++){
        for(int j=1 ; j<=5 ; j++){
          arr[i][j]=s.nextInt();
        }
      }
      int w=1 ;
      for(int i=2 ; i<=n ; i++){
        int p=0 ;
        for(int j=1 ; j<=5 ; j++){
          if(arr[w][j]<arr[i][j]){
            p++;
          }
          else {
            p--;
          }
        }
        if(p<0){
          w=i ;
        }
      }
      boolean k=true ;
      for(int i=1 ; i<=n ; i++){
        if(i==w){
          continue ;
        }
        int p=0 ;
        for(int j=1 ; j<=5 ; j++){
          if(arr[w][j]<arr[i][j]){
            p++;
          }
          else {
            p--;
          }
        }
        if(p<0){
          System.out.println(-1);
          k=false ;
          break ;
        }
      }
      if(k){
        System.out.println(w);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,5 + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= 5 do ( (     arr[i+1][j+1] := s.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var w : int ; w := 1 ;
        var i : int ; i := 2 ; while i <= n do ( (     var p : int ; p := 0 ;
         var j : int ; j := 1 ; while j <= 5 do ( (     if (arr[w+1][j+1] < arr[i+1][j+1]) then (     p := p + 1 ) else (     p := p - 1 ) )  ;     j := j + 1 ) ; 
     if (p < 0) then (     w := i ) else skip )  ;     i := i + 1 ) ; 
    var k : boolean ; k := true ;
        var i : int ; i := 1 ; while i <= n do ( (     if (i = w) then (     continue ) else skip ; 
     var p : int ; p := 0 ;
         var j : int ; j := 1 ; while j <= 5 do ( (     if (arr[w+1][j+1] < arr[i+1][j+1]) then (     p := p + 1 ) else (     p := p - 1 ) )  ;     j := j + 1 ) ; 
     if (p < 0) then (     OclFile["System.out"].println(-1) ; 
     k := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (k) then (     OclFile["System.out"].println(w) ) else skip ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Round0A {
  int cases ;
  long calc(long N){
    boolean seen[]=new boolean[10];
    int nSeen=0 ;
    long x=N ;
    while(true){
      String s=""+x ;
      for(int n=0 ; n<s.length(); n++){
        char c=s.charAt(n);
        if(! seen[c-'0']){
          seen[c-'0']=true ;
          nSeen++;
        }
      }
      if(nSeen==10)break ;
      x+=N ;
    }
    return x ;
  }
  String calcS(long N){
    if(N==0)return "INSOMNIA" ;
    return ""+calc(N);
  }
  void process(Scanner scanner,PrintStream out)throws IOException {
    cases=scanner.nextInt();
    scanner.nextLine();
    for(int curCase=0 ; curCase<cases ; curCase++){
      long N=scanner.nextLong();
      out.println("Case #"+(curCase+1)+": "+calcS(N));
    }
  }
  Round0A()throws IOException {
    Scanner in=new Scanner(new File("C:\\Users\\Olaf\\Downloads\\A-large.in"));
    PrintStream out=new PrintStream("out-A-large.txt");
    process(in,out);
    in.close();
    out.close();
  }
  public static void main(String[] args)throws IOException {
    new Round0A();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Round0A {
   attribute cases : int;
   operation calc( N : long) : long
  pre: true
  post: true
  activity: (     var seen : Sequence(boolean) ; seen := Integer.subrange(1,10)->collect(false) ;
     var nSeen : int ; nSeen := 0 ;
    var x : long ; x := N ;
    while (true) do (     var s : String ; s := "" + x ;
         var n : int ; n := 0 ; while n < s->size() do ( (     var c : String ; c := s->at(n+1) ;
     if (not(seen[(c)->char2byte() - ('0')->char2byte()+1])) then (     seen[(c)->char2byte() - ('0')->char2byte()+1] := true ; 
     nSeen := nSeen + 1 ) else skip )  ;     n := n + 1 ) ; 
     if (nSeen = 10) then     break else skip ; 
     x := x+(N) ) ; 
    return x 
 );
   operation calcS( N : long) : String
  pre: true
  post: true
  activity: (     if (N = 0) then     return "INSOMNIA" else skip ; 
     return "" + calc(N) );
   operation process( scanner : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     cases := scanner.nextInt() ; 
     scanner.nextLine() ; 
         var curCase : int ; curCase := 0 ; while curCase < cases do ( (     var N : long ; N := scanner.nextLong() ;
     out.println("Case #" + (curCase + 1) + ": " + calcS(N)) )  ;     curCase := curCase + 1 ) );
   static operation newRound0A() : Round0A
  pre: true
  post: true
  activity:
  ( var self : Round0A ;
    self := createRound0A();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("C:\\Users\\Olaf\\Downloads\\A-large.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("out-A-large.txt")) ;
    execute process(in, out) ; 
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Round0A.newRound0A() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int d=sc.nextInt();
    int[] p=new int[n];
    for(int i=0 ; i<n ; i++){
      p[i]=sc.nextInt();
    }
    int score=0 ;
    for(int i=0 ; i<n ; i++){
      int s=p[i]-d ;
      if(s>0){
        score+=s ;
      }
    }
    if(score<=0){
      System.out.println("kusoge");
    }
    else {
      System.out.println(score);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var score : int ; score := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var s : int ; s := p[i+1] - d ;
     if (s > 0) then (     score := score+(s) ) else skip )  ;     i := i + 1 ) ; 
    if (score <= 0) then (     OclFile["System.out"].println("kusoge") ) else (     OclFile["System.out"].println(score) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner cin ;
  int N,d ;
  public void solve(){
    cin=new Scanner(System.in);
    N=cin.nextInt();
    d=cin.nextInt();
    int sum=0 ;
    for(int i=0 ; i<N ; i++){
      int p=cin.nextInt()-d ;
      sum+=Math.max(0,p);
    }
    System.out.println(sum==0 ? "kusoge" : sum);
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute cin : OclFile;
   attribute N : int;
   operation solve() : void
  pre: true
  post: true
  activity: (     cin := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     N := cin.getCurrent()->toInteger() ; 
    d := cin.getCurrent()->toInteger() ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var p : int ; p := cin.getCurrent()->toInteger() - d ;
     sum := sum+(Set{0, p}->max()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if sum = 0 then "kusoge" else sum endif) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    try(Scanner sc=new Scanner(System.in)){
      int n=Integer.parseInt(sc.next());
      int d=Integer.parseInt(sc.next());
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        int p=Integer.parseInt(sc.next());
        if(p>d){
          sum+=(p-d);
        }
      }
      if(sum==0){
        System.out.println("kusoge");
      }
      else {
        System.out.println(sum);
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := (sc.getCurrent())->toInteger() ;
     var d : int ; d := (sc.getCurrent())->toInteger() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var p : int ; p := (sc.getCurrent())->toInteger() ;
     if (p > d) then (     sum := sum+((p - d)) ) else skip )  ;     i := i + 1 ) ; 
    if (sum = 0) then (     OclFile["System.out"].println("kusoge") ) else (     OclFile["System.out"].println(sum) ) ;  
 ))  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String line ;
    int N,d ;
    N=sc.nextInt();
    d=sc.nextInt();
    int ans=0 ;
    for(int i=0 ; i<N ; i++){
      ans+=Math.max(sc.nextInt()-d,0);
    }
    System.out.println(ans>0 ? ans : "kusoge");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : String ;
    var N : int ;
    var d : int ;
    N := sc.getCurrent()->toInteger() ; 
    d := sc.getCurrent()->toInteger() ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     ans := ans+(Set{sc.getCurrent()->toInteger() - (d)->char2byte(), 0}->max()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if ans > 0 then ans else "kusoge" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int d=sc.nextInt();
    long total=0 ;
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      if(x>=d){
        total+=x-d ;
      }
    }
    if(total<=0){
      System.out.println("kusoge");
    }
    else {
      System.out.println(total);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var total : long ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x >= d) then (     total := total+(x - d) ) else skip )  ;     i := i + 1 ) ; 
    if (total <= 0) then (     OclFile["System.out"].println("kusoge") ) else (     OclFile["System.out"].println(total) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Node {
    int data ;
    Node next ;
  };
  static Node push(Node head_ref,int data){
    Node ptr1=new Node();
    Node temp=head_ref ;
    ptr1.data=data ;
    ptr1.next=head_ref ;
    if(head_ref!=null){
      while(temp.next!=head_ref)temp=temp.next ;
      temp.next=ptr1 ;
      return head_ref ;
    }
    else ptr1.next=ptr1 ;
    head_ref=ptr1 ;
    return head_ref ;
  }
  static Node deleteNode(Node head_ref,Node del){
    Node temp=head_ref ;
    if(head_ref==del)head_ref=del.next ;
    while(temp.next!=del){
      temp=temp.next ;
    }
    temp.next=del.next ;
    return head_ref ;
  }
  static Node deleteEvenNodes(Node head){
    Node ptr=head ;
    Node next ;
    do {
      if(ptr.data % 2==0)deleteNode(head,ptr);
      next=ptr.next ;
      ptr=next ;
    }
    while(ptr!=head);
    return head ;
  }
  static void printList(Node head){
    Node temp=head ;
    if(head!=null){
      do {
        System.out.printf("%d ",temp.data);
        temp=temp.next ;
      }
      while(temp!=head);
    }
  }
  public static void main(String args[]){
    Node head=null ;
    head=push(head,61);
    head=push(head,12);
    head=push(head,56);
    head=push(head,2);
    head=push(head,11);
    head=push(head,57);
    System.out.println("\nList after deletion : ");
    head=deleteEvenNodes(head);
    printList(head);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   operation push( head_ref : Node, data : int) : Node
  pre: true
  post: true
  activity: (     var ptr1 : Node ; ptr1 := Node.newNode() ;
     var temp : Node ; temp := head_ref ;
    ptr1.data := data ; 
    ptr1.next := head_ref ; 
    if (head_ref /= null) then (     while (temp.next /= head_ref) do     temp := temp.next ; ; 
     temp.next := ptr1 ; 
     return head_ref ) else     ptr1.next := ptr1 ; ;  
    head_ref := ptr1 ; 
    return head_ref 
 );
  static   operation deleteNode( head_ref : Node, del : Node) : Node
  pre: true
  post: true
  activity: (     var temp : Node ; temp := head_ref ;
     if (head_ref = del) then     head_ref := del.next ; else skip ; 
    while (temp.next /= del) do (     temp := temp.next ) ; 
    temp.next := del.next ; 
    return head_ref 
 );
  static   operation deleteEvenNodes( head : Node) : Node
  pre: true
  post: true
  activity: (     var ptr : Node ; ptr := head ;
     var next : Node ;
   while true do ((     if (ptr.data mod 2 = 0) then     execute deleteNode(head, ptr) ; else skip ; 
     next := ptr.next ; 
     ptr := next ) ;
    if (ptr /= head) then skip else break) ; 
     return head );
  static   operation printList( head : Node) : void
  pre: true
  post: true
  activity: (     var temp : Node ; temp := head ;
     if (head /= null) then (   while true do ((     OclFile["System.out"].printf("%d ", temp.data) ; 
     temp := temp.next ) ;
    if (temp /= head) then skip else break) ) else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := null ;
     head := push(head, 61) ; 
    head := push(head, 12) ; 
    head := push(head, 56) ; 
    head := push(head, 2) ; 
    head := push(head, 11) ; 
    head := push(head, 57) ; 
    OclFile["System.out"].println("\nList after deletion : ") ; 
    head := deleteEvenNodes(head) ; 
    execute printList(head) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Pyramid_Pattern {
  static void printPattern(int n){
    int j,k=0 ;
    for(int i=1 ; i<=n ; i++){
      if(i % 2!=0){
        for(j=k+1 ; j<k+i ; j++)System.out.print(j+"*");
        System.out.println(j++);
        k=j ;
      }
      else {
        k=k+i-1 ;
        for(j=k ; j>k-i+1 ; j--)System.out.print(j+"*");
        System.out.println(j);
      }
    }
  }
  public static void main(String args[]){
    int n=5 ;
    printPattern(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class Pyramid_Pattern {
  static   operation printPattern( n : int) : void
  pre: true
  post: true
  activity: (     var j : int ;
    var k : int ; k := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     if (i mod 2 /= 0) then (         j := k + 1 ; while j < k + i do (     OclFile["System.out"].print(j + "*") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(j) ; 
     k := j ) else (     k := k + i - 1 ; 
         j := k ; while j > k - i + 1 do (     OclFile["System.out"].print(j + "*") ;  ;     j := j - 1 ) ; 
     OclFile["System.out"].println(j) ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute printPattern(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean possibleToReach(int a,int b){
    int c=(int)Math.cbrt(a*b);
    int re1=a/c ;
    int re2=b/c ;
    if((re1*re1*re2==a)&&(re2*re2*re1==b))return true ;
    else return false ;
  }
  public static void main(String[] args){
    int A=60,B=450 ;
    if(possibleToReach(A,B))System.out.println("yes");
    else System.out.println("no");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation possibleToReach( a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     var c : int ; c := (a * b)->cbrt()->oclAsType(int) ;
     var re1 : int ; re1 := a / c ;
     var re2 : int ; re2 := b / c ;
     if ((re1 * re1 * re2 = a) & (re2 * re2 * re1 = b)) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 60 ;
    var B : int ; B := 450 ;
     if (possibleToReach(A, B)) then     OclFile["System.out"].println("yes") ; else     OclFile["System.out"].println("no") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void maxSubArraySum(int a[],int size){
    int max_so_far=Integer.MIN_VALUE,max_ending_here=0,start=0,end=0,s=0 ;
    for(int i=0 ; i<size ; i++){
      max_ending_here+=a[i];
      if(max_so_far<max_ending_here){
        max_so_far=max_ending_here ;
        start=s ;
        end=i ;
      }
      if(max_ending_here<0){
        max_ending_here=0 ;
        s=i+1 ;
      }
    }
    System.out.println("Maximum contiguous sum is "+max_so_far);
    System.out.println("Starting index "+start);
    System.out.println("Ending index "+end);
  }
  public static void main(String[] args){
    int a[]={
-2,-3,4,-1,-2,1,5,-3 };
      int n=a.length ;
      maxSubArraySum(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxSubArraySum( a : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (     var max_so_far : int ; max_so_far := -2147483648 ;
    var max_ending_here : int ; max_ending_here := 0 ;
    var start : int ; start := 0 ;
    var end : int ; end := 0 ;
    var s : int ; s := 0 ;
         var i : int ; i := 0 ; while i < size do ( (     max_ending_here := max_ending_here+(a[i+1]) ; 
     if (max_so_far < max_ending_here) then (     max_so_far := max_ending_here ; 
     start := s ; 
     end := i ) else skip ; 
     if (max_ending_here < 0) then (     max_ending_here := 0 ; 
     s := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Maximum contiguous sum is " + max_so_far) ; 
    OclFile["System.out"].println("Starting index " + start) ; 
    OclFile["System.out"].println("Ending index " + end) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{-2,-3,4,-1,-2,1,5,-3} ;
     var n : int ; n := a->size() ;
     execute maxSubArraySum(a, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  static final PrintStream out=System.out ;
  static final Scanner sc=new Scanner(System.in);
  static final long Mod=1000_000_007L ;
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
    System.exit(0);
  }
  void solve(){
    int A=nextInt();
    int B=nextInt();
    int res=-1 ;
    if(A>0 && A<10 && B>0 && B<10)res=A*B ;
    out.println(res);
  }
  public int[] nextIntArray(int n){
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public long[] nextLongArray(int n){
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=nextLong();
    return a ;
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
  public String next(){
    return sc.next();
  }
  long gcd(long m,long n){
    if(m<n)return gcd(n,m);
    if(n==0)return m ;
    return gcd(n,m % n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute out : OclFile := OclFile["System.out"];
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute Mod : long := 1000_000_007L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() ; 
 OclProcess.exit(0) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var A : int ; A := nextInt() ;
     var B : int ; B := nextInt() ;
    var res : int ; res := -1 ;
    if (A > 0 & A < 10 & B > 0 & B < 10) then     res := A * B ; else skip ; 
    skip ; 
 );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation next() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
   operation gcd( m : long, n : long) : long
  pre: true
  post: true
  activity: (     if (m < n) then     return gcd(n, m) else skip ; 
     if (n = 0) then     return m else skip ; 
     return gcd(n, m mod n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package gcj2016.qualif ;
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.logging.Level ;
import java.util.logging.Logger ;
public class ExoA {
  public static void main(final String[] args){
    final String base="/home/jfortin/workspace-gcj/Codejam2016/q/ExoA/" ;
    final String input=base+"b1.in" ;
    final String output=base+"b1.out" ;
    try {
      final Scanner sc=new Scanner(new FileReader(input));
      final PrintWriter pw=new PrintWriter(output);
      final int n=sc.nextInt();
      sc.nextLine();
      for(int c=0 ; c<n ; c++){
        System.out.println("Test case "+(c+1)+"...");
        pw.print("Case #"+(c+1)+": ");
        test(sc,pw);
        pw.println();
      }
      pw.println();
      pw.flush();
      pw.close();
      sc.close();
    }
    catch(final FileNotFoundException ex){
      Logger.getLogger(ExoA.class.getName()).log(Level.SEVERE,null,ex);
    }
  }
  private static void test(final Scanner sc,final PrintWriter pw){
    int N=sc.nextInt();
    if(N==0){
      pw.print("INSOMNIA");
      return ;
    }
    int i=0 ;
    long n=0 ;
    boolean digits[]=new boolean[10];
    while(notFull(digits)){
      i++;
      n+=N ;
      if(i>100000 || n<0){
        pw.print("INSOMNIA");
        return ;
      }
      fillDigits(n,digits);
    }
    pw.print(n);
  }
  private static void fillDigits(long n,final boolean[] digits){
    while(n>0){
      long d=n % 10 ;
      digits[(int)d]=true ;
      n=n/10 ;
    }
  }
  private static boolean notFull(final boolean[] digits){
    for(boolean b : digits){
      if(! b){
        return true ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ExoA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var base : String ; base := "/home/jfortin/workspace-gcj/Codejam2016/q/ExoA/" ;
     var input : String ; input := base + "b1.in" ;
     var output : String ; output := base + "b1.out" ;
     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(input))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile(output)) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
        var c : int ; c := 0 ; while c < n do ( (     OclFile["System.out"].println("Test case " + (c + 1) + "...") ; 
     skip ; 
     execute test(sc, pw) ; 
     skip )  ;     c := c + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 )   catch (ex : FileNotFoundException) do (     Logger.getLogger(OclType["ExoA"].getName()).log(Level.SEVERE, null, ex) )
 );
  static   operation test( sc : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then (     skip ; 
     return ) else skip ; 
    var i : int ; i := 0 ;
    var n : long ; n := 0 ;
    var digits : Sequence(boolean) ; digits := Integer.subrange(1,10)->collect(false) ;
    while (notFull(digits)) do (     i := i + 1 ; 
     n := n+(N) ; 
     if (i > 100000 or n < 0) then (     skip ; 
     return ) else skip ; 
     execute fillDigits(n, digits) ) ; 
    skip ; 
 );
  static   operation fillDigits( n : long, digits : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (     while (n > 0) do (     var d : long ; d := n mod 10 ;
     digits[d->oclAsType(int)+1] := true ; 
     n := n / 10 ) );
  static   operation notFull( digits : Sequence(boolean)) : boolean
  pre: true
  post: true
  activity: (     for (b : digits) do ( (     if (not(b)) then (     return true ) else skip )  ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public int computeMultiplication(int a,int b){
    if(a>9 || b>9 || a==0 || b==0){
      return-1 ;
    }
    return a*b ;
  }
  public static void main(String args[]){
    int a,b ;
    Scanner sc=new Scanner(System.in);
    Main m=new Main();
    a=sc.nextInt();
    b=sc.nextInt();
    System.out.println(m.computeMultiplication(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation computeMultiplication( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a > 9 or b > 9 or a = 0 or b = 0) then (     return -1 ) else skip ; 
     return a * b );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ;
    var b : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var m : Main ; m := Main.newMain() ;
    a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    OclFile["System.out"].println(m.computeMultiplication(a, b)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String input[]=((br.readLine()).trim()).split("\\s+");
    int a=Integer.parseInt(input[0]);
    int b=Integer.parseInt(input[1]);
    if(a>=1 && a<=9 && b>=1 && b<=9){
      System.out.println(a*b);
    }
    else {
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : Sequence(String) ; input := ((br.readLine())->trim())->split("\\s+") ;
    var a : int ; a := (input[0+1])->toInteger() ;
    var b : int ; b := (input[1+1])->toInteger() ;
    if (a >= 1 & a <= 9 & b >= 1 & b <= 9) then (     OclFile["System.out"].println(a * b) ) else (     OclFile["System.out"].println(-1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int result=-1 ;
    if(a<=9 && b<=9)result=a*b ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var result : int ; result := -1 ;
    if (a <= 9 & b <= 9) then     result := a * b ; else skip ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    if(A<=9){
      if(B<=9){
        out.println(A*B);
      }
      else out.println("-1");
    }
    else out.println("-1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
     if (A <= 9) then (     if (B <= 9) then (     out.println(A * B) ) else     out.println("-1") ; ) else     out.println("-1") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    if(A+B>=10)System.out.println("error");
    else System.out.println(A+B);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
     if (A + B >= 10) then     OclFile["System.out"].println("error") ; else     OclFile["System.out"].println(A + B) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(1,in,out);
    out.close();
  }
  static class Task {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int A=in.nextInt();
      int B=in.nextInt();
      if(A+B>=10){
        out.println("error");
      }
      else {
        out.println(A+B);
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var A : int ; A := in.nextInt() ;
     var B : int ; B := in.nextInt() ;
     if (A + B >= 10) then (     skip ) else (     skip ) );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSolutions(int n,int val){
    int total=0 ;
    if(n==1 && val>=0)return 1 ;
    for(int i=0 ; i<=val ; i++){
      total+=countSolutions(n-1,val-i);
    }
    return total ;
  }
  public static void main(String[] args){
    int n=5 ;
    int val=20 ;
    System.out.print(countSolutions(n,val));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSolutions( n : int, val : int) : int
  pre: true
  post: true
  activity: (     var total : int ; total := 0 ;
     if (n = 1 & val >= 0) then     return 1 else skip ; 
         var i : int ; i := 0 ; while i <= val do ( (     total := total+(countSolutions(n - 1, val - i)) )  ;     i := i + 1 ) ; 
     return total );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var val : int ; val := 20 ;
     OclFile["System.out"].print(countSolutions(n, val)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  void solve(){
    int a=inint(),b=inint();
    out.println(a+b>=10 ? "error" : a+b);
  }
  public static Scanner in=new Scanner(System.in);
  public static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    new Main().solve();
    out.flush();
  }
  public int inint(){
    return in.nextInt();
  }
  public long inlong(){
    return in.nextLong();
  }
  public String instr(){
    return in.next();
  }
  public char inchar(){
    return in.next().charAt(0);
  }
  public int[] inintar(int num){
    int[] a=new int[num];
    for(int i=0 ; i<num ; i++){
      a[i]=in.nextInt();
    }
    return a ;
  }
  public char[] incharar(){
    return in.next().toCharArray();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ; a := inint() ;
    var b : int ; b := inint() ;
     out.println(if a + b >= 10 then "error" else a + b endif) );
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() ; 
     skip );
   operation inint() : int
  pre: true
  post: true
  activity: (     return in.getCurrent()->toInteger() );
   operation inlong() : long
  pre: true
  post: true
  activity: (     return in.getCurrent()->toLong() );
   operation instr() : String
  pre: true
  post: true
  activity: (     return in.getCurrent() );
   operation inchar() : String
  pre: true
  post: true
  activity: (     return in.getCurrent()->at(0+1) );
   operation inintar( num : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,num)->collect(0) ;
         var i : int ; i := 0 ; while i < num do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return a );
   operation incharar() : Sequence(String)
  pre: true
  post: true
  activity: (     return in.getCurrent()->characters() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] input=br.readLine().split(" ");
    int a=Integer.parseInt(input[0]);
    int b=Integer.parseInt(input[1]);
    if(a+b>=10){
      System.out.println("error");
    }
    else {
      System.out.println(a+b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : Sequence(String) ; input := br.readLine()->split(" ") ;
    var a : int ; a := (input[0+1])->toInteger() ;
    var b : int ; b := (input[1+1])->toInteger() ;
    if (a + b >= 10) then (     OclFile["System.out"].println("error") ) else (     OclFile["System.out"].println(a + b) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.Stream ;
public class Main {
  public static void main(final String[] args)throws Exception {
    final Scanner sc=new Scanner(System.in);
    final int A=sc.nextInt();
    final int B=sc.nextInt();
    System.out.println(A+B>=10 ? "error" : A+B);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if A + B >= 10 then "error" else A + B endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class countingsheep {
  private static InputReader in ;
  private static PrintWriter out ;
  public static boolean SUBMIT=true ;
  public static final String NAME="A-large" ;
  private static void main2()throws IOException {
    int n=in.nextInt();
    if(n==0){
      out.println("INSOMNIA");
      return ;
    }
    HashSet<Integer>seen=new HashSet<>();
    int cur=n ;
    while(true){
      int m=cur ;
      while(m>0){
        seen.add(m % 10);
        m/=10 ;
      }
      boolean ok=true ;
      for(int i=0 ; i<=9 ; i++){
        if(! seen.contains(i)){
          ok=false ;
        }
      }
      if(ok)break ;
      cur+=n ;
    }
    out.println(cur);
  }
  public static void main(String[] args)throws IOException {
    if(SUBMIT){
      in=new InputReader(new FileInputStream(new File(NAME+".in")));
      out=new PrintWriter(new BufferedWriter(new FileWriter(NAME+".out")));
    }
    else {
      in=new InputReader(System.in);
      out=new PrintWriter(System.out,true);
    }
    int numCases=in.nextInt();
    for(int test=1 ; test<=numCases ; test++){
      out.print("Case #"+test+": ");
      main2();
    }
    out.close();
    System.exit(0);
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class countingsheep {
  static   attribute in : InputReader;
  static   attribute out : OclFile;
  static   attribute SUBMIT : boolean := true;
  static    attribute NAME : String := "A-large";
  static   operation main2() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     if (n = 0) then (     skip ; 
     return ) else skip ; 
    var seen : Set(int) ; seen := Set{} ;
    var cur : int ; cur := n ;
    while (true) do (     var m : int ; m := cur ;
     while (m > 0) do (     seen := seen->including(m mod 10) ; 
     m := m/(10) ) ; 
    var ok : boolean ; ok := true ;
        var i : int ; i := 0 ; while i <= 9 do ( (     if (not(seen->includes(i))) then (     ok := false ) else skip )  ;     i := i + 1 ) ; 
    if (ok) then     break else skip ; 
    cur := cur+(n) ; 
 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (SUBMIT) then (     in := InputReader.newInputReader(OclFile.newOclFile_Read(OclFile(NAME + ".in"))) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(NAME + ".out"))) ) else (     in := InputReader.newInputReader(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"], true) ) ;  
     var numCases : int ; numCases := in.nextInt() ;
        var test : int ; test := 1 ; while test <= numCases do ( (     skip ; 
     execute main2() )  ;     test := test + 1 ) ; 
    skip ; 
OclProcess.exit(0) ; 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class GuessANumber {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String[] s=new String[n];
    long low=-2000000000,high=2000000000 ;
    for(int i=0 ; i<n ; i++){
      String c=sc.next();
      long x=sc.nextLong();
      char res=sc.next().charAt(0);
      if(c.equals(">=")){
        if(res=='Y')low=Math.max(x,low);
        else high=Math.min(x-1,high);
      }
      if(c.equals("<=")){
        if(res=='Y')high=Math.min(x,high);
        else low=Math.max(x+1,low);
      }
      if(c.equals("<")){
        if(res=='Y')high=Math.min(x-1,high);
        else low=Math.max(x,low);
      }
      if(c.equals(">")){
        if(res=='Y')low=Math.max(x+1,low);
        else high=Math.min(x,high);
      }
    }
    if(low>high)System.out.println("Impossible");
    else System.out.println(low);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GuessANumber {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
    var low : long ; low := -2000000000 ;
    var high : long ; high := 2000000000 ;
        var i : int ; i := 0 ; while i < n do ( (     var c : String ; c := sc.getCurrent() ;
     var x : long ; x := sc.getCurrent()->toLong() ;
    var res : String ; res := sc.getCurrent()->at(0+1) ;
    if (c = ">=") then (     if (res = 'Y') then     low := Set{x, low}->max() ; else     high := Set{(x)->char2byte() - 1, high}->min() ; ) else skip ; 
    if (c = "<=") then (     if (res = 'Y') then     high := Set{x, high}->min() ; else     low := Set{x + 1, low}->max() ; ) else skip ; 
    if (c = "<") then (     if (res = 'Y') then     high := Set{(x)->char2byte() - 1, high}->min() ; else     low := Set{x, low}->max() ; ) else skip ; 
    if (c = ">") then (     if (res = 'Y') then     low := Set{x + 1, low}->max() ; else     high := Set{x, high}->min() ; ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (low > high) then     OclFile["System.out"].println("Impossible") else     OclFile["System.out"].println(low) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class contest {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long infinity=Integer.MAX_VALUE ;
    long n_infinity=Integer.MIN_VALUE ;
    long a=n_infinity,b=infinity ;
    int n=sc.nextInt();
    boolean flag=true ;
    for(int i=0 ; i<n ; i++){
      String sign=sc.next();
      long x=sc.nextLong();
      char c=sc.next().charAt(0);
      switch(sign){
        case "<=" : if(c=='Y'){
          if(x<b)b=x ;
        }
        else {
          if(x>=a)a=x+1 ;
        }
        break ;
        case ">=" : if(c=='Y'){
          if(x>a)a=x ;
        }
        else {
          if(x<=b)b=x-1 ;
        }
        break ;
        case "<" : if(c=='Y'){
          if(x<=b)b=x-1 ;
        }
        else {
          if(x>a)a=x ;
        }
        break ;
        case ">" : if(c=='Y'){
          if(x>=a)a=x+1 ;
        }
        else {
          if(x<b)b=x ;
        }
        break ;
      }
    }
    if(a<=b){
      System.out.println((int)(Math.random()*(b-a+1))+a);
    }
    else {
      System.out.println("Impossible");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class contest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var infinity : long ; infinity := 2147483647 ;
    var n_infinity : long ; n_infinity := -2147483648 ;
    var a : long ; a := n_infinity ;
    var b : long ; b := infinity ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < n do ( (     var sign : String ; sign := sc.getCurrent() ;
     var x : long ; x := sc.getCurrent()->toLong() ;
     var c : String ; c := sc.getCurrent()->at(0+1) ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (sign) ; 
       if _switchval = "<=" then
     if (c = 'Y') then (     if (x < b) then     b := x ; else skip ) else (     if (x >= a) then     a := x + 1 ; else skip ) ;  
    break 
   else skip ;
       if _switchval = ">=" then
     if (c = 'Y') then (     if (x > a) then     a := x ; else skip ) else (     if (x <= b) then     b := (x)->char2byte() - 1 ; else skip ) ;  
    break 
   else skip ;
       if _switchval = "<" then
     if (c = 'Y') then (     if (x <= b) then     b := (x)->char2byte() - 1 ; else skip ) else (     if (x > a) then     a := x ; else skip ) ;  
    break 
   else skip ;
       if _switchval = ">" then
     if (c = 'Y') then (     if (x >= a) then     a := x + 1 ; else skip ) else (     if (x < b) then     b := x ; else skip ) ;  
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    if (a <= b) then (     OclFile["System.out"].println((MathLib.random() * (b - a + 1))->oclAsType(int) + a) ) else (     OclFile["System.out"].println("Impossible") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int find_n(int[] a){
    int j=0,k=0,s=0 ;
    int x=Arrays.stream(a).max().getAsInt();
    int y=Arrays.stream(a).min().getAsInt();
    for(int i : a){
      if(a[i]==x){
        s=i ;
        break ;
      }
    }
    for(int i : a){
      if(i!=x && i<=y && i!=0){
        a[j]+=1 ;
        a[s]-=1 ;
        x-=1 ;
        k+=1 ;
        j+=1 ;
      }
      else if(i!=0){
        j+=1 ;
      }
    }
    for(int i : a){
      if(a[i]!=x){
        k=-1 ;
        break ;
      }
    }
    return k ;
  }
  public static void main(String[] args){
    int[] a={
      1,6,1,1,1 };
      System.out.println(find_n(a));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation find_n( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var j : int ; j := 0 ;
    var k : int ; k := 0 ;
    var s : int ; s := 0 ;
     var x : int ; x := stream(a).max().getAsInt() ;
    var y : int ; y := stream(a).min().getAsInt() ;
    for (i : a) do ( (     if (a[i+1] = x) then (     s := i ; 
     break ) else skip )  ) ; 
    for (i : a) do ( (     if (i /= x & i <= y & i /= 0) then (     a[j+1] := a[j+1]+(1) ; 
     a[s+1] := a[s+1]-(1) ; 
    x := x-(1) ; 
    k := k+(1) ; 
    j := j+(1) ; 
 ) else     if (i /= 0) then (     j := j+(1) ) else skip ; )  ) ; 
    for (i : a) do ( (     if (a[i+1] /= x) then (     k := -1 ; 
     break ) else skip )  ) ; 
    return k 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,6,1,1,1} ;
     OclFile["System.out"].println(find_n(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int n=3 ;
  static int[][] dp=new int[n][n];
  static int[][] v=new int[n][n];
  static int minSteps(int i,int j,int arr[][]){
    if(i==n-1 && j==n-1){
      return 0 ;
    }
    if(i>n-1 || j>n-1){
      return 9999999 ;
    }
    if(v[i][j]==1){
      return dp[i][j];
    }
    v[i][j]=1 ;
    dp[i][j]=9999999 ;
    for(int k=Math.max(0,arr[i][j]+j-n+1); k<=Math.min(n-i-1,arr[i][j]); k++){
      dp[i][j]=Math.min(dp[i][j],minSteps(i+k,j+arr[i][j]-k,arr));
    }
    dp[i][j]++;
    return dp[i][j];
  }
  public static void main(String[] args){
    int arr[][]={
      {
        4,1,2 },{
          1,1,1 },{
            2,1,1 }
          };
          int ans=minSteps(0,0,arr);
          if(ans>=9999999){
            System.out.println(-1);
          }
          else {
            System.out.println(ans);
          }
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute n : int := 3;
  static   attribute dp : Sequence(Sequence(int)) := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0));
  static   attribute v : Sequence(Sequence(int)) := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0));
  static   operation minSteps( i : int, j : int, arr : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     if (i = n - 1 & j = n - 1) then (     return 0 ) else skip ; 
     if (i > n - 1 or j > n - 1) then (     return 9999999 ) else skip ; 
    if (v[i+1][j+1] = 1) then (     return dp[i+1][j+1] ) else skip ; 
    v[i+1][j+1] := 1 ; 
    dp[i+1][j+1] := 9999999 ; 
        var k : int ; k := Set{0, arr[i+1][j+1] + j - n + 1}->max() ; while k <= Set{n - i - 1, arr[i+1][j+1]}->min() do ( (     dp[i+1][j+1] := Set{dp[i+1][j+1], minSteps(i + k, j + arr[i+1][j+1] - k, arr)}->min() )  ;     k := k + 1 ) ; 
    dp[i+1][j+1] := dp[i+1][j+1] + 1 ; 
    return dp[i+1][j+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{4,1,2},Sequence{1,1,1},Sequence{2,1,1}} ;
     var ans : int ; ans := minSteps(0, 0, arr) ;
     if (ans >= 9999999) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(ans) ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int n=3 ;
  static int dp[][]=new int[n][n];
  static int[][] v=new int[n][n];
  static int minSteps(int i,int j,int arr[][]){
    if(i==n-1 && j==n-1){
      return 0 ;
    }
    if(i>n-1 || j>n-1){
      return 9999999 ;
    }
    if(v[i][j]==1){
      return dp[i][j];
    }
    v[i][j]=1 ;
    dp[i][j]=1+Math.min(minSteps(i+arr[i][j],j,arr),minSteps(i,j+arr[i][j],arr));
    return dp[i][j];
  }
  public static void main(String[] args){
    int arr[][]={
      {
        2,1,2 },{
          1,1,1 },{
            1,1,1 }
          };
          int ans=minSteps(0,0,arr);
          if(ans>=9999999){
            System.out.println(-1);
          }
          else {
            System.out.println(ans);
          }
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute n : int := 3;
  static   attribute dp : int := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0));
  static   attribute v : Sequence(Sequence(int)) := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0));
  static   operation minSteps( i : int, j : int, arr : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     if (i = n - 1 & j = n - 1) then (     return 0 ) else skip ; 
     if (i > n - 1 or j > n - 1) then (     return 9999999 ) else skip ; 
    if (v[i+1][j+1] = 1) then (     return dp[i+1][j+1] ) else skip ; 
    v[i+1][j+1] := 1 ; 
    dp[i+1][j+1] := 1 + Set{minSteps(i + arr[i+1][j+1], j, arr), minSteps(i, j + arr[i+1][j+1], arr)}->min() ; 
    return dp[i+1][j+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{2,1,2},Sequence{1,1,1},Sequence{1,1,1}} ;
     var ans : int ; ans := minSteps(0, 0, arr) ;
     if (ans >= 9999999) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(ans) ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class LinkedList {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    int t=3 ;
    int n=-1 ;
    int a[][]=new int[100][100];
    do {
      n=(t*(t-1)*(t-2))/6 ;
      t++;
    }
    while(n<=k);
    t=t-2 ;
    for(int i=0 ; i<t ; i++){
      for(int j=0 ; j<t ; j++){
        if(i!=j)a[i][j]=1 ;
      }
    }
    k=k-(t*(t-1)*(t-2))/6 ;
    n=0 ;
    int t1 ;
    if(k>0)t1=1 ;
    else t1=0 ;
    int t2=1 ;
    while(n<k){
      n=(t2*(t2-1))/2 ;
      if(n<=k){
        a[t+t1-1][t2-1]=1 ;
        a[t2-1][t+t1-1]=1 ;
      }
      if(n==k){
        break ;
      }
      else if(n>k){
        t1++;
        n=0 ;
        k=k-((t2-1)*(t2-2))/2 ;
        t2=0 ;
      }
      t2++;
    }
    System.out.println(t+t1);
    for(int i=0 ; i<t+t1 ; i++){
      for(int j=0 ; j<t+t1 ; j++){
        System.out.print(a[i][j]);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class LinkedList {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var t : int ; t := 3 ;
    var n : int ; n := -1 ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(0)) ;
  while true do ((     n := (t * (t - 1) * (t - 2)) / 6 ; 
     t := t + 1 ) ;
    if (n <= k) then skip else break) ; 
    t := t - 2 ; 
        var i : int ; i := 0 ; while i < t do ( (         var j : int ; j := 0 ; while j < t do ( (     if (i /= j) then     a[i+1][j+1] := 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    k := k - (t * (t - 1) * (t - 2)) / 6 ; 
    n := 0 ; 
    var t1 : int ;
    if (k > 0) then     t1 := 1 else     t1 := 0 ; ;  
    var t2 : int ; t2 := 1 ;
    while (n < k) do (     n := (t2 * (t2 - 1)) / 2 ; 
     if (n <= k) then (     a[t + t1 - 1+1][t2 - 1+1] := 1 ; 
     a[t2 - 1+1][t + t1 - 1+1] := 1 ) else skip ; 
     if (n = k) then (     break ) else     if (n > k) then (     t1 := t1 + 1 ; 
     n := 0 ; 
     k := k - ((t2 - 1) * (t2 - 2)) / 2 ; 
     t2 := 0 ) else skip ; ;  
     t2 := t2 + 1 ) ; 
    OclFile["System.out"].println(t + t1) ; 
        var i : int ; i := 0 ; while i < t + t1 do ( (         var j : int ; j := 0 ; while j < t + t1 do ( (     OclFile["System.out"].print(a[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class comp2 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int k=in.nextInt();
    int num=2 ;
    int ans[][]=new int[100][100];
    int i=0 ;
    while(k>0){
      if(k<i){
        i=0 ;
        num++;
      }
      ans[num-1][i]=1 ;
      ans[i][num-1]=1 ;
      k-=i ;
      i++;
      if(i>=num-1 && k>0){
        i=0 ;
        num++;
      }
    }
    System.out.println(num);
    for(int j=0 ; j<num ; j++){
      for(int m=0 ; m<num ; m++){
        System.out.print(ans[j][m]);
      }
      System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class comp2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var num : int ; num := 2 ;
    var ans : Sequence(Sequence(int)) ; ans := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(0)) ;
    var i : int ; i := 0 ;
    while (k > 0) do (     if (k < i) then (     i := 0 ; 
     num := num + 1 ) else skip ; 
     ans[num - 1+1][i+1] := 1 ; 
    ans[i+1][num - 1+1] := 1 ; 
    k := k-(i) ; 
    i := i + 1 ; 
    if (i >= num - 1 & k > 0) then (     i := 0 ; 
     num := num + 1 ) else skip ; 
 ) ; 
    OclFile["System.out"].println(num) ; 
        var j : int ; j := 0 ; while j < num do ( (         var m : int ; m := 0 ; while m < num do ( (     OclFile["System.out"].print(ans[j+1][m+1]) )  ;     m := m + 1 ) ; 
     OclFile["System.out"].println("") )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long mod=(long)(1e9+7);
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int b=((n-11)/2),a=b ;
    char[] s=in.next().toCharArray();
    for(int i=0 ; i<n ; i++){
      if(b==0)break ;
      if(s[i]=='8'){
        s[i]=0 ;
        b--;
      }
    }
    boolean found=false ;
    for(int i=0 ; i<n ; i++){
      if(s[i]==0)continue ;
      if(s[i]=='8'){
        found=true ;
        break ;
      }
      if(a==0)break ;
      else a--;
    }
    if(found)pw.println("YES");
    else pw.println("NO");
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := (1e9 + 7)->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var b : int ; b := ((n - 11) / 2) ;
    var a : int ; a := b ;
    var s : Sequence(String) ; s := in.getCurrent()->characters() ;
        var i : int ; i := 0 ; while i < n do ( (     if (b = 0) then     break else skip ; 
     if (s[i+1] = '8') then (     s[i+1] := 0 ; 
     b := b - 1 ) else skip )  ;     i := i + 1 ) ; 
    var found : boolean ; found := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] = 0) then     continue else skip ; 
     if (s[i+1] = '8') then (     found := true ; 
     break ) else skip ; 
     if (a = 0) then     break else     a := a - 1 ; )  ;     i := i + 1 ) ; 
    if (found) then     skip else     skip ; ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package qualification ;
import java.io.*;
public class A_CountingSheep {
  private static final String FILENAME="data/qualification/A-large" ;
  private static final boolean STANDARD_OUTPUT=false ;
  private static BufferedReader in=null ;
  private static PrintWriter out=null ;
  public static void main(String[] args)throws Throwable {
    try(BufferedReader reader=in=new BufferedReader(new FileReader(FILENAME+".in"))){
      try(PrintWriter writer=out=! STANDARD_OUTPUT ? new PrintWriter(FILENAME+".out"): new PrintWriter(System.out)){
        process();
      }
    }
  }
  private static void process()throws Throwable {
    for(int caseNumber=1,T=Integer.parseInt(in.readLine()); caseNumber<=T ; caseNumber++){
      long N=Long.parseLong(in.readLine());
      long n=0L,m=0L ;
      if(N>0){
        boolean[] visited=new boolean[10];
        int visitedCount=0 ;
        loop : for(n=N ;
        visitedCount<10 ;
        n+=N){
          for(m=n ; m>0 ; m/=10){
            if(! visited[(int)(m % 10)]){
              visited[(int)(m % 10)]=true ;
              visitedCount++;
              if(visitedCount==10)break loop ;
            }
          }
        }
      }
      out.println("Case #"+caseNumber+": "+(n==0L ? "INSOMNIA" : n));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_CountingSheep {
  static    attribute FILENAME : String := "data/qualification/A-large";
  static    attribute STANDARD_OUTPUT : boolean := false;
  static   attribute in : OclFile := null;
  static   attribute out : OclFile := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var reader : OclFile := in ;
 (     try (    var writer : OclFile := out ;
 (     execute process() ))  ))  );
  static   operation process() : void
  pre: true
  post: true
  activity: (         var caseNumber : int ; caseNumber := 1 ;
    var T : int ; T := (in.readLine())->toInteger() ; while caseNumber <= T do ( (     var N : long ; N := (in.readLine())->toLong() ;
     var n : long ; n := 0L ;
    var m : long ; m := 0L ;
     if (N > 0) then (     var visited : Sequence(boolean) ; visited := Integer.subrange(1,10)->collect(false) ;
     var visitedCount : int ; visitedCount := 0 ;
         n := N ; while visitedCount < 10 do ( (         m := n ; while m > 0 do ( (     if (not(visited[(m mod 10)->oclAsType(int)+1])) then (     visited[(m mod 10)->oclAsType(int)+1] := true ; 
     visitedCount := visitedCount + 1 ; 
     if (visitedCount = 10) then     break else skip ) else skip )  ;     m := m/(10) ) )  ;     n := n+(N) ) ; ) else skip ; 
     skip )  ;     caseNumber := caseNumber + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static String telephone8StringGame(int len,String str){
    int petyaTurn=(len-11)/2 ;
    int count8=0 ;
    for(int i=0 ; i<len-10 ; i++){
      if(str.charAt(i)=='8')count8++;
    }
    if(count8>petyaTurn){
      return "YES" ;
    }
    return "NO" ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int len=sc.nextInt();
    String str=sc.next();
    System.out.println(telephone8StringGame(len,str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation telephone8StringGame( len : int, str : String) : String
  pre: true
  post: true
  activity: (     var petyaTurn : int ; petyaTurn := (len - 11) / 2 ;
     var count8 : int ; count8 := 0 ;
        var i : int ; i := 0 ; while i < len - 10 do ( (     if (str->at(i+1) = '8') then     count8 := count8 + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (count8 > petyaTurn) then (     return "YES" ) else skip ; 
    return "NO" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := sc.getCurrent()->toInteger() ;
     var str : String ; str := sc.getCurrent() ;
     OclFile["System.out"].println(telephone8StringGame(len, str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static String telephone8StringGame(int len,String str){
    int petyaTurn=(len-11)/2 ;
    int count8=0 ;
    for(int i=0 ; i<len-10 ; i++){
      if(str.charAt(i)=='8')count8++;
    }
    if(count8<=petyaTurn){
      return "NO" ;
    }
    return "YES" ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int len=sc.nextInt();
    String str=sc.next();
    System.out.println(telephone8StringGame(len,str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation telephone8StringGame( len : int, str : String) : String
  pre: true
  post: true
  activity: (     var petyaTurn : int ; petyaTurn := (len - 11) / 2 ;
     var count8 : int ; count8 := 0 ;
        var i : int ; i := 0 ; while i < len - 10 do ( (     if (str->at(i+1) = '8') then     count8 := count8 + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (count8 <= petyaTurn) then (     return "NO" ) else skip ; 
    return "YES" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := sc.getCurrent()->toInteger() ;
     var str : String ; str := sc.getCurrent() ;
     OclFile["System.out"].println(telephone8StringGame(len, str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sc.nextInt();
    String s=sc.next();
    System.out.println(solve(s)? "YES" : "NO");
    sc.close();
  }
  static boolean solve(String s){
    int round=(s.length()-11)/2 ;
    boolean[] erased=new boolean[s.length()];
    int index=0 ;
    for(int i=0 ; i<round ; i++){
      while(index<erased.length && s.charAt(index)=='8'){
        index++;
      }
      if(index==erased.length){
        return true ;
      }
      erased[index]=true ;
      index++;
    }
    index=0 ;
    for(int i=0 ; i<round ; i++){
      while(index<erased.length &&(erased[index] || s.charAt(index)!='8')){
        index++;
      }
      if(index==erased.length){
        return false ;
      }
      erased[index]=true ;
      index++;
    }
    for(int i=0 ; ; i++){
      if(! erased[i]){
        return s.charAt(i)=='8' ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var s : String ; s := sc.getCurrent() ;
    OclFile["System.out"].println(if solve(s) then "YES" else "NO" endif) ; 
    skip ; 
 );
  static   operation solve( s : String) : boolean
  pre: true
  post: true
  activity: (     var round : int ; round := (s->size() - 11) / 2 ;
     var erased : Sequence(boolean) ; erased := Integer.subrange(1,s->size())->collect(false) ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < round do ( (     while (index < erased->size() & s->at(index+1) = '8') do (     index := index + 1 ) ; 
     if (index = erased->size()) then (     return true ) else skip ; 
     erased[index+1] := true ; 
     index := index + 1 )  ;     i := i + 1 ) ; 
    index := 0 ; 
        var i : int ; i := 0 ; while i < round do ( (     while (index < erased->size() & (erased[index+1] or s->at(index+1) /= '8')) do (     index := index + 1 ) ; 
     if (index = erased->size()) then (     return false ) else skip ; 
     erased[index+1] := true ; 
     index := index + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while true do ( (     if (not(erased[i+1])) then (     return s->at(i+1) = '8' ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
class GFG {
  static float Area(float r){
    if(r<0)return-1 ;
    float x=(2*r)/(float)(Math.sqrt(5));
    float A=0.70477f*(float)(Math.pow(x,2));
    return A ;
  }
  public static void main(String[] args){
    float r=5 ;
    System.out.println(Area(r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Area( r : double) : double
  pre: true
  post: true
  activity: (     if (r < 0) then     return -1 else skip ; 
     var x : double ; x := (2 * r) / ((5)->sqrt())->oclAsType(double) ;
     var A : double ; A := 0.70477f * (x->pow(2))->oclAsType(double) ;
     return A );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : double ; r := 5 ;
     OclFile["System.out"].println(Area(r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countOdd(int n){
    int coun=0,m,j,i ;
    for(i=n-2 ; i>=1 ; i--){
      if(i>=1){
        m=(n-i)/2 ;
        j=(i*(i+1))/2 ;
        coun+=j*m ;
      }
      else {
        m=((n-1)-i)/2 ;
        j=(i*(i+1))/2 ;
        coun+=j*m ;
      }
    }
    return coun ;
  }
  static int countEven(int n){
    int coun=0,m,j,i ;
    for(i=n-2 ; i>=1 ; i--){
      if(i>=1){
        m=((n-1)-i)/2 ;
        j=(i*(i+1))/2 ;
        coun+=j*m ;
      }
      else {
        m=(n-i)/2 ;
        j=(i*(i+1))/2 ;
        coun+=j*m ;
      }
    }
    return coun ;
  }
  public static void main(String[] args){
    int n=5 ;
    if(n>=1)System.out.println(countOdd(n));
    else System.out.println(countEven(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countOdd( n : int) : int
  pre: true
  post: true
  activity: (     var coun : int ; coun := 0 ;
    var m : int ;
    var j : int ;
    var i : int ;
         i := n - 2 ; while i >= 1 do ( (     if (i >= 1) then (     m := (n - i) / 2 ; 
     j := (i * (i + 1)) / 2 ; 
     coun := coun+(j * m) ) else (     m := ((n - 1) - i) / 2 ; 
     j := (i * (i + 1)) / 2 ; 
     coun := coun+(j * m) ) )  ;     i := i - 1 ) ; 
     return coun );
  static   operation countEven( n : int) : int
  pre: true
  post: true
  activity: (     var coun : int ; coun := 0 ;
    var m : int ;
    var j : int ;
    var i : int ;
         i := n - 2 ; while i >= 1 do ( (     if (i >= 1) then (     m := ((n - 1) - i) / 2 ; 
     j := (i * (i + 1)) / 2 ; 
     coun := coun+(j * m) ) else (     m := (n - i) / 2 ; 
     j := (i * (i + 1)) / 2 ; 
     coun := coun+(j * m) ) )  ;     i := i - 1 ) ; 
     return coun );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     if (n >= 1) then     OclFile["System.out"].println(countOdd(n)) ; else     OclFile["System.out"].println(countEven(n)) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void myCopy(char s1[],char s2[],int index){
    s2[index]=s1[index];
    if(index==s1.length-1){
      return ;
    }
    myCopy(s1,s2,index+1);
  }
  public static void main(String[] args){
    char s1[]="GEEKSFORGEEKS".toCharArray();
    char s2[]=new char[s1.length];
    int index=0 ;
    myCopy(s1,s2,index);
    System.out.println(String.valueOf(s2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation myCopy( s1 : Sequence(String), s2 : Sequence(String), index : int) : void
  pre: true
  post: true
  activity: (     s2[index+1] := s1[index+1] ; 
     if (index = s1->size() - 1) then (     return ) else skip ; 
     execute myCopy(s1, s2, index + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : Sequence(String) ; s1 := "GEEKSFORGEEKS"->characters() ;
     var s2 : Sequence(String) ; s2 := Integer.subrange(1,s1->size())->collect(0) ;
    var index : int ; index := 0 ;
    execute myCopy(s1, s2, index) ; 
    OclFile["System.out"].println(((s2) + "")) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static boolean isRotated(String str1,String str2){
    if(str1.length()!=str2.length())return false ;
    String clock_rot="" ;
    String anticlock_rot="" ;
    int len=str2.length();
    anticlock_rot=anticlock_rot+str2.substring(len-2,len)+str2.substring(0,len-2);
    clock_rot=clock_rot+str2.substring(2)+str2.substring(0,2);
    return(str1.equals(clock_rot)|| str1.equals(anticlock_rot));
  }
  public static void main(String[] args){
    String str1="geeks" ;
    String str2="eksge" ;
    System.out.println(isRotated(str1,str2)? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation isRotated( str1 : String, str2 : String) : boolean
  pre: true
  post: true
  activity: (     if (str1->size() /= str2->size()) then     return false else skip ; 
     var clock_rot : String ; clock_rot := "" ;
    var anticlock_rot : String ; anticlock_rot := "" ;
    var len : int ; len := str2->size() ;
    anticlock_rot := anticlock_rot + str2.subrange((len)->char2byte() - 2+1,len) + str2.subrange(0+1,(len)->char2byte() - 2) ; 
    clock_rot := clock_rot + str2.subrange(2+1,2) + str2.subrange(0+1,2) ; 
    return (str1 = clock_rot or str1 = anticlock_rot) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "geeks" ;
     var str2 : String ; str2 := "eksge" ;
     OclFile["System.out"].println(if isRotated(str1, str2) then "Yes" else "No" endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  static boolean isPalindrome(String s){
    String s1="" ;
    int N=s.length();
    for(int i=N-1 ; i>=0 ; i--)s1+=s.charAt(i);
    if(s.equals(s1))return true ;
    return false ;
  }
  static boolean createString(int N){
    String str="" ;
    String s=""+N ;
    String letters="abcdefghij" ;
    int sum=0 ;
    String substr="" ;
    for(int i=0 ; i<s.length(); i++){
      int digit=s.charAt(i)-'0' ;
      substr+=letters.charAt(digit);
      sum+=digit ;
    }
    while(str.length()<=sum){
      str+=substr ;
    }
    str=str.substring(0,sum);
    return isPalindrome(str);
  }
  public static void main(String args[]){
    int N=61 ;
    boolean flag=createString(N);
    if(flag)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPalindrome( s : String) : boolean
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "" ;
     var N : int ; N := s->size() ;
        var i : int ; i := (N)->char2byte() - 1 ; while i >= 0 do (     s1 := s1+(s->at(i+1)) ;  ;     i := i - 1 ) ; 
    if (s = s1) then     return true else skip ; 
    return false 
 );
  static   operation createString( N : int) : boolean
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     var s : String ; s := "" + N ;
    var letters : String ; letters := "abcdefghij" ;
    var sum : int ; sum := 0 ;
    var substr : String ; substr := "" ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var digit : int ; digit := s->at(i+1) - ('0')->char2byte() ;
     substr := substr+(letters->at(digit+1)) ; 
     sum := sum+(digit) )  ;     i := i + 1 ) ; 
    while (str->size() <= sum) do (     str := str+(substr) ) ; 
    str := str.subrange(0+1,sum) ; 
    return isPalindrome(str) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 61 ;
     var flag : boolean ; flag := createString(N) ;
     if (flag) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Sasha_and_One_More_Name {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    String s=scn.next();
    long[] hash=new long[s.length()];
    long p=1 ;
    long mod=1000000007 ;
    long[] pp=new long[s.length()];
    long[] hashs=new long[s.length()];
    for(int i=0 ; i<s.length(); i++){
      long val=((i>0 ? hash[i-1] : 0)+((s.charAt(i)-'a'+1)*p)% mod)% mod ;
      long pre=((i>0 ? hashs[i-1] : 0)*7919)% mod ;
      long sv=(pre+(s.charAt(i)-'a'+1))% mod ;
      hash[i]=val ;
      hashs[i]=sv ;
      pp[i]=p ;
      p=(p*7919)% mod ;
    }
    int n=s.length();
    if(hashs[n-1]!=hash[n-1]){
      System.out.println("Impossible");
    }
    else {
      if(n % 2==0){
        if(s.chars().distinct().count()==1){
          System.out.println("Impossible");
        }
        else {
          boolean got=false ;
          while(n>1){
            if(n % 2==1){
              System.out.println(2);
              return ;
            }
            else {
              if(hash[n/2-1]!=hashs[n/2-1]){
                System.out.println(1);
                return ;
              }
            }
            n/=2 ;
          }
          System.out.println(2);
        }
        return ;
      }
      for(int i=0 ; i<n/2 ; i++){
        if(hash[i]!=hashs[i]){
          System.out.println(2);
          return ;
        }
      }
      System.out.println("Impossible");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sasha_and_One_More_Name {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scn.getCurrent() ;
    var hash : Sequence(long) ; hash := Integer.subrange(1,s->size())->collect(0) ;
    var p : long ; p := 1 ;
    var mod : long ; mod := 1000000007 ;
    var pp : Sequence(long) ; pp := Integer.subrange(1,s->size())->collect(0) ;
    var hashs : Sequence(long) ; hashs := Integer.subrange(1,s->size())->collect(0) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var val : long ; val := ((if i > 0 then hash[i - 1+1] else 0 endif) + ((s->at(i+1) - ('a')->char2byte() + 1) * p) mod mod) mod mod ;
     var pre : long ; pre := ((if i > 0 then hashs[i - 1+1] else 0 endif) * 7919) mod mod ;
    var sv : long ; sv := (pre + (s->at(i+1) - ('a')->char2byte() + 1)) mod mod ;
    hash[i+1] := val ; 
    hashs[i+1] := sv ; 
    pp[i+1] := p ; 
    p := (p * 7919) mod mod ; 
 )  ;     i := i + 1 ) ; 
    var n : int ; n := s->size() ;
    if (hashs[n - 1+1] /= hash[n - 1+1]) then (     OclFile["System.out"].println("Impossible") ) else (     if (n mod 2 = 0) then (     if (s.chars()->asOrderedSet()->size() = 1) then (     OclFile["System.out"].println("Impossible") ) else (     var got : boolean ; got := false ;
     while (n > 1) do (     if (n mod 2 = 1) then (     OclFile["System.out"].println(2) ; 
     return ) else (     if (hash[n / 2 - 1+1] /= hashs[n / 2 - 1+1]) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ) ;  
     n := n/(2) ) ; 
     OclFile["System.out"].println(2) ) ;  
     return ) else skip ; 
         var i : int ; i := 0 ; while i < n / 2 do ( (     if (hash[i+1] /= hashs[i+1]) then (     OclFile["System.out"].println(2) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Impossible") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String string1=in.nextLine();
    System.out.println("Enter the first string: "+string1);
    String string2=in.nextLine();
    System.out.println("Enter the second string :"+string2);
    System.out.println("\nAre both strings same: ");
    if(string1.equals(string2)==true){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var string1 : String ; string1 := in.nextLine() ;
    OclFile["System.out"].println("Enter the first string: " + string1) ; 
    var string2 : String ; string2 := in.nextLine() ;
    OclFile["System.out"].println("Enter the second string :" + string2) ; 
    OclFile["System.out"].println("\nAre both strings same: ") ; 
    if (string1 = string2 = true) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class A {
  static void mark(boolean[] bb,int n){
    if(n>0){
      bb[n % 10]=true ;
      mark(bb,n/10);
    }
  }
  static boolean check(boolean[] bb){
    for(int d=0 ; d<=9 ; d++)if(! bb[d])return false ;
    return true ;
  }
  static int count(int n){
    boolean[] bb=new boolean[10];
    for(int i=1 ; ; i++){
      mark(bb,n*i);
      if(check(bb))return n*i ;
    }
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int T=Integer.parseInt(br.readLine());
    for(int t=1 ; t<=T ; t++){
      int n=Integer.parseInt(br.readLine());
      pw.println("Case #"+t+": "+(n==0 ? "INSOMNIA" : count(n)));
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation mark( bb : Sequence(boolean), n : int) : void
  pre: true
  post: true
  activity: (     if (n > 0) then (     bb[n mod 10+1] := true ; 
     execute mark(bb, n / 10) ) else skip );
  static   operation check( bb : Sequence(boolean)) : boolean
  pre: true
  post: true
  activity: (         var d : int ; d := 0 ; while d <= 9 do (     if (not(bb[d+1])) then     return false else skip ;  ;     d := d + 1 ) ; 
     return true );
  static   operation count( n : int) : int
  pre: true
  post: true
  activity: (     var bb : Sequence(boolean) ; bb := Integer.subrange(1,10)->collect(false) ;
         var i : int ; i := 1 ; while true do ( (     execute mark(bb, n * i) ; 
     if (check(bb)) then     return n * i else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := (br.readLine())->toInteger() ;
        var t : int ; t := 1 ; while t <= T do ( (     var n : int ; n := (br.readLine())->toInteger() ;
     skip )  ;     t := t + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String FirstAndLast(String str){
    String[] arrOfStr=str.split(" ");
    String res="" ;
    for(String a : arrOfStr){
      res+=a.substring(1,a.length()-1)+" " ;
    }
    return res ;
  }
  public static void main(String args[]){
    String str="Geeks for Geeks" ;
    System.out.println(str);
    System.out.println(FirstAndLast(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation FirstAndLast( str : String) : String
  pre: true
  post: true
  activity: (     var arrOfStr : Sequence(String) ; arrOfStr := str->split(" ") ;
     var res : String ; res := "" ;
     for (a : arrOfStr) do ( (     res := res+(a.subrange(1+1,a->size() - 1) + " ") )  ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "Geeks for Geeks" ;
     OclFile["System.out"].println(str) ; 
     OclFile["System.out"].println(FirstAndLast(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String printString(int n,String str){
    String str2="" ;
    int extraChar=n % 26 ;
    if(extraChar>=1){
      for(int i=26-(extraChar+1); i<=25 ; i++){
        str2+=str.charAt(i);
      }
    }
    int countOfStr=n/26 ;
    for(int i=1 ; i<=countOfStr ; i++){
      for(int j=0 ; j<26 ; j++){
        str2+=str.charAt(j);
      }
    }
    return str2 ;
  }
  public static void main(String[] args){
    int n=30 ;
    String str="zyxwvutsrqponmlkjihgfedcba" ;
    System.out.println(printString(n,str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printString( n : int, str : String) : String
  pre: true
  post: true
  activity: (     var str2 : String ; str2 := "" ;
     var extraChar : int ; extraChar := n mod 26 ;
    if (extraChar >= 1) then (         var i : int ; i := 26 - (extraChar + 1) ; while i <= 25 do ( (     str2 := str2+(str->at(i+1)) )  ;     i := i + 1 ) ) else skip ; 
    var countOfStr : int ; countOfStr := n / 26 ;
        var i : int ; i := 1 ; while i <= countOfStr do ( (         var j : int ; j := 0 ; while j < 26 do ( (     str2 := str2+(str->at(j+1)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return str2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 30 ;
     var str : String ; str := "zyxwvutsrqponmlkjihgfedcba" ;
     OclFile["System.out"].println(printString(n, str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double areaOctagon(double side){
    return(float)(2*(1+Math.sqrt(2))*side*side);
  }
  public static void main(String arg[]){
    double side=4 ;
    System.out.print("Area of Regular Octagon="+areaOctagon(side));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation areaOctagon( side : double) : double
  pre: true
  post: true
  activity: (     return (2 * (1 + (2)->sqrt()) * side * side)->oclAsType(double) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var side : double ; side := 4 ;
     OclFile["System.out"].print("Area of Regular Octagon=" + areaOctagon(side)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static String findString(int n,int k){
    String res="" ;
    for(int i=0 ; i<k ; i++)res=res+(char)('a'+i);
    int count=0 ;
    for(int i=0 ; i<n-k ; i++){
      res=res+(char)('a'+count);
      count++;
      if(count==k)count=0 ;
    }
    return res ;
  }
  static public void main(String[] args){
    int n=5,k=2 ;
    System.out.println(findString(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findString( n : int, k : int) : String
  pre: true
  post: true
  activity: (     var res : String ; res := "" ;
         var i : int ; i := 0 ; while i < k do (     res := res + ('a' + i)->oclAsType(String) ;  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n - k do ( (     res := res + ('a' + count)->oclAsType(String) ; 
     count := count + 1 ; 
     if (count = k) then     count := 0 ; else skip )  ;     i := i + 1 ) ; 
    return res 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var k : int ; k := 2 ;
     OclFile["System.out"].println(findString(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String nm[]=br.readLine().split("\\s");
    long n=Long.parseLong(nm[0]);
    long m=Long.parseLong(nm[1]);
    Set<Long>xSet=new HashSet<>();
    Set<Long>ySet=new HashSet<>();
    while(m--!=0){
      String xy[]=br.readLine().split("\\s");
      xSet.add(Long.parseLong(xy[0]));
      ySet.add(Long.parseLong(xy[1]));
      long xSize=xSet.size();
      long ySize=ySet.size();
      System.out.print((n*n)-(xSize*n+ySize*n-xSize*ySize)+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var nm : Sequence(String) ; nm := br.readLine()->split("\\s") ;
    var n : long ; n := (nm[0+1])->toLong() ;
    var m : long ; m := (nm[1+1])->toLong() ;
    var xSet : Set(long) ; xSet := Set{} ;
    var ySet : Set(long) ; ySet := Set{} ;
        while (m /= 0) do (    skip ; (     var xy : Sequence(String) ; xy := br.readLine()->split("\\s") ;
     xSet := xSet->including((xy[0+1])->toLong()) ; 
    ySet := ySet->including((xy[1+1])->toLong()) ; 
    var xSize : long ; xSize := xSet->size() ;
    var ySize : long ; ySize := ySet->size() ;
    OclFile["System.out"].print((n * n) - (xSize * n + ySize * n - xSize * ySize) + " ") ; 
 ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  static HashMap<String,Integer>map ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long n=in.nextLong(),m=in.nextLong();
    long notInAttect=n*n ;
    HashSet<Long>r=new HashSet<>();
    HashSet<Long>c=new HashSet<>();
    for(int i=0 ; i<m ; i++){
      long rr=in.nextLong(),cc=in.nextLong();
      r.add(rr);
      c.add(cc);
      long ans=(n-r.size())*(n-c.size());
      pw.print(ans+" ");
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute map : Map(String,int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := in.getCurrent()->toLong() ;
    var m : long ; m := in.getCurrent()->toLong() ;
    var notInAttect : long ; notInAttect := n * n ;
    var r : Set(long) ; r := Set{} ;
    var c : Set(long) ; c := Set{} ;
        var i : int ; i := 0 ; while i < m do ( (     var rr : long ; rr := in.getCurrent()->toLong() ;
    var cc : long ; cc := in.getCurrent()->toLong() ;
     r := r->including(rr) ; 
    c := c->including(cc) ; 
    var ans : long ; ans := (n - r->size()) * (n - c->size()) ;
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class solution {
  public static void main(String args[]){
    Scanner ourScanner=new Scanner(System.in);
    long size=(long)ourScanner.nextInt();
    int numRooks=ourScanner.nextInt();
    boolean[] rows=new boolean[(int)size];
    boolean[] columns=new boolean[(int)size];
    long uRows=0 ;
    long uCols=0 ;
    for(int i=0 ; i<numRooks ; i++){
      int r=ourScanner.nextInt();
      int c=ourScanner.nextInt();
      if(rows[r-1]!=true){
        rows[r-1]=true ;
        uRows++;
      }
      if(columns[c-1]!=true){
        columns[c-1]=true ;
        uCols++;
      }
      System.out.print((long)(size*size-uRows*size-uCols*size+uRows*uCols)+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ourScanner : OclFile ; ourScanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var size : long ; size := ourScanner.getCurrent()->toInteger()->oclAsType(long) ;
    var numRooks : int ; numRooks := ourScanner.getCurrent()->toInteger() ;
    var rows : Sequence(boolean) ; rows := Integer.subrange(1,size->oclAsType(int))->collect(false) ;
    var columns : Sequence(boolean) ; columns := Integer.subrange(1,size->oclAsType(int))->collect(false) ;
    var uRows : long ; uRows := 0 ;
    var uCols : long ; uCols := 0 ;
        var i : int ; i := 0 ; while i < numRooks do ( (     var r : int ; r := ourScanner.getCurrent()->toInteger() ;
     var c : int ; c := ourScanner.getCurrent()->toInteger() ;
    if (rows[r - 1+1] /= true) then (     rows[r - 1+1] := true ; 
     uRows := uRows + 1 ) else skip ; 
    if (columns[c - 1+1] /= true) then (     columns[c - 1+1] := true ; 
     uCols := uCols + 1 ) else skip ; 
    OclFile["System.out"].print((size * size - uRows * size - uCols * size + uRows * uCols)->oclAsType(long) + " ") ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static boolean is_prime(int num){
    int count=0 ;
    for(int i=1 ; i*i<=(num); i++){
      if((num)% i==0){
        if(i*i!=(num))count+=2 ;
        else count++;
      }
    }
    if(count==2)return true ;
    else return false ;
  }
  static String is_divisible(int n){
    if(n==1){
      return "YES" ;
    }
    else {
      if(is_prime(n+1))return "NO" ;
      else return "YES" ;
    }
  }
  public static void main(String[] args){
    int n ;
    n=3 ;
    System.out.println(is_divisible(n));
    n=4 ;
    System.out.println(is_divisible(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation is_prime( num : int) : boolean
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i * i <= (num) do ( (     if ((num) mod i = 0) then (     if (i * i /= (num)) then     count := count+(2) ; else     count := count + 1 ; ) else skip )  ;     i := i + 1 ) ; 
     if (count = 2) then     return true else     return false );
  static   operation is_divisible( n : int) : String
  pre: true
  post: true
  activity: (     if (n = 1) then (     return "YES" ) else (     if (is_prime(n + 1)) then     return "NO" else     return "YES" ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     n := 3 ; 
    OclFile["System.out"].println(is_divisible(n)) ; 
    n := 4 ; 
    OclFile["System.out"].println(is_divisible(n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static final int OUT=0 ;
  static final int IN=1 ;
  static int countWords(String str){
    int state=OUT ;
    int wc=0 ;
    int i=0 ;
    while(i<str.length()){
      if(str.charAt(i)==' ' || str.charAt(i)=='\n' || str.charAt(i)=='\t')state=OUT ;
      else if(state==OUT){
        state=IN ;
++wc ;
      }
++i ;
    }
    return wc ;
  }
  public static void main(String args[]){
    String str="One two       three\n four\tfive  " ;
    System.out.println("No of words : "+countWords(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute OUT : int := 0;
  static    attribute IN : int := 1;
  static   operation countWords( str : String) : int
  pre: true
  post: true
  activity: (     var state : int ; state := OUT ;
     var wc : int ; wc := 0 ;
    var i : int ; i := 0 ;
    while (i < str->size()) do (     if (str->at(i+1) = ' ' or str->at(i+1) = '
' or str->at(i+1) = '\t') then     state := OUT else     if (state = OUT) then (     state := IN ; 
     wc := wc + 1 ) else skip ; ;  
     i := i + 1 ) ; 
    return wc 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "One two       three\n four\tfive  " ;
     OclFile["System.out"].println("No of words : " + countWords(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=Integer.parseInt(in.next());
    int Z=Integer.parseInt(in.next());
    int W=Integer.parseInt(in.next());
    int x=Z ;
    int y=W ;
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++){
      a[i]=Integer.parseInt(in.next());
    }
    if(2<N){
      x=a[N-2];
      y=a[N-1];
    }
    else {
      x=a[N-1];
    }
    if(Math.abs(x-y)>Math.abs(y-W))System.out.println(Math.abs(x-y));
    else System.out.println(Math.abs(y-W));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (in.getCurrent())->toInteger() ;
    var Z : int ; Z := (in.getCurrent())->toInteger() ;
    var W : int ; W := (in.getCurrent())->toInteger() ;
    var x : int ; x := Z ;
    var y : int ; y := W ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := (in.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    if (2 < N) then (     x := a[N - 2+1] ; 
     y := a[N - 1+1] ) else (     x := a[N - 1+1] ) ;  
    if (if x - y < 0 then -(x - y) else x - y endif > if y - W < 0 then -(y - W) else y - W endif) then     OclFile["System.out"].println(if x - y < 0 then -(x - y) else x - y endif) else     OclFile["System.out"].println(if y - W < 0 then -(y - W) else y - W endif) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float circleradius(float l,float b){
    if(l<0 || b<0)return-1 ;
    float r=(float)((l*b)/(2*Math.sqrt((Math.pow(l,2)+Math.pow(b,2)))));
    return r ;
  }
  public static void main(String[] args){
    float l=5,b=3 ;
    System.out.print(circleradius(l,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation circleradius( l : double, b : double) : double
  pre: true
  post: true
  activity: (     if (l < 0 or b < 0) then     return -1 else skip ; 
     var r : double ; r := ((l * b) / (2 * ((l->pow(2) + b->pow(2)))->sqrt()))->oclAsType(double) ;
     return r );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : double ; l := 5 ;
    var b : double ; b := 3 ;
     OclFile["System.out"].print(circleradius(l, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Hotels {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long d=sc.nextLong();
    long ans=0 ;
    long[] arr=new long[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextLong();
      if(i>=1){
        if(arr[i]-arr[i-1]>2*d)ans+=2 ;
        else if(arr[i]-arr[i-1]==2*d)ans+=1 ;
      }
    }
    System.out.println(ans+2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hotels {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : long ; d := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toLong() ; 
     if (i >= 1) then (     if (arr[i+1] - arr[i - 1+1] > 2 * d) then     ans := ans+(2) ; else     if (arr[i+1] - arr[i - 1+1] = 2 * d) then     ans := ans+(1) ; else skip ; ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans + 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Contest_yandexA {
  static final int MAXN=(int)1e6 ;
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int d=input.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=input.nextInt();
    }
    Arrays.sort(a);
    Set<Integer>set=new HashSet<>();
    for(int i=0 ; i<n-1 ; i++){
      int l=a[i]+d ;
      if(l<=a[i+1] && a[i+1]-l>=d){
        set.add(l);
      }
    }
    for(int i=n-1 ; i>=1 ; i--){
      int l=a[i]-d ;
      if(l>=a[i-1] && l-a[i-1]>=d){
        set.add(l);
      }
    }
    System.out.println(set.size()+2);
  }
  public static long gcd(long a,long b){
    if(b==0){
      return a ;
    }
    return gcd(b,a % b);
  }
}
class Pair implements Comparable<Pair>{
  int x ;
  int w ;
  int idx ;
  Pair(int x,int w,int idx){
    this.x=x ;
    this.w=w ;
    this.idx=idx ;
  }
  @ Override public int compareTo(Pair p){
    return this.w-p.w ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Contest_yandexA {
  static    attribute MAXN : int := 1e6->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var d : int ; d := input.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var l : int ; l := a[i+1] + d ;
     if (l <= a[i + 1+1] & a[i + 1+1] - l >= d) then (     set := set->including(l) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 1 do ( (     var l : int ; l := a[i+1] - d ;
     if (l >= a[i - 1+1] & l - a[i - 1+1] >= d) then (     set := set->including(l) ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(set->size() + 2) ; 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else skip ; 
     return gcd(b, a mod b) );
}
class Pair implements Comparable<Map> {
   attribute x : int;
   attribute w : int;
   attribute idx : int;
   static operation newPair( x : int, w : int, idx : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, w,idx);
    return self );
  operation initialise( x : int, w : int, idx : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.w := w ; 
     self.idx := idx );
      operation compareTo( p : Map) : int
  pre: true
  post: true
  activity: (     return self.w - p.w );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Solution2 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int d=in.nextInt();
    int[] arr=new int[n];
    if(n==1){
      System.out.println(2);
    }
    else {
      Set<Integer>set=new HashSet<Integer>();
      for(int i=0 ; i<n ; i++){
        arr[i]=in.nextInt();
      }
      int a=0 ;
      for(int i=0 ; i<n ; i++){
        if(i==0){
          a=arr[i]+d ;
          if(Math.abs(arr[i+1]-a)>=d){
            set.add(a);
          }
        }
        else if(i==n-1){
          a=arr[i]-d ;
          if(Math.abs(a-arr[i-1])>=d){
            set.add(a);
          }
        }
        else {
          a=arr[i]+d ;
          if(Math.abs(arr[i+1]-a)>=d){
            set.add(a);
          }
          a=arr[i]-d ;
          if(Math.abs(a-arr[i-1])>=d){
            set.add(a);
          }
        }
      }
      System.out.println(set.size()+2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    if (n = 1) then (     OclFile["System.out"].println(2) ) else (     var set : Set(int) ; set := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var a : int ; a := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i = 0) then (     a := arr[i+1] + d ; 
     if (if arr[i + 1+1] - a < 0 then -(arr[i + 1+1] - a) else arr[i + 1+1] - a endif >= d) then (     set := set->including(a) ) else skip ) else     if (i = n - 1) then (     a := arr[i+1] - d ; 
     if (if a - arr[i - 1+1] < 0 then -(a - arr[i - 1+1]) else a - arr[i - 1+1] endif >= d) then (     set := set->including(a) ) else skip ) else (     a := arr[i+1] + d ; 
     if (if arr[i + 1+1] - a < 0 then -(arr[i + 1+1] - a) else arr[i + 1+1] - a endif >= d) then (     set := set->including(a) ) else skip ; 
     a := arr[i+1] - d ; 
     if (if a - arr[i - 1+1] < 0 then -(a - arr[i - 1+1]) else a - arr[i - 1+1] endif >= d) then (     set := set->including(a) ) else skip ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(set->size() + 2) ; 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int d=sc.nextInt();
    int[] x=new int[n];
    for(int i=0 ; i<x.length ; i++){
      x[i]=sc.nextInt();
    }
    System.out.println(solve(x,d));
    sc.close();
  }
  static int solve(int[] x,int d){
    return IntStream.range(1,x.length).map(i->Math.min(2,Math.max(0,(x[i]-d)-(x[i-1]+d)+1))).sum()+2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < x->size() do ( (     x[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(x, d)) ; 
    skip ; 
 );
  static   operation solve( x : Sequence(int), d : int) : int
  pre: true
  post: true
  activity: (     return Integer.subrange(1, x->size()-1)->collect( _x1 | (lambda i : OclAny in Set{2, Set{0, (x[i+1] - d) - (x[i - 1+1] + d) + 1}->max()}->min())->apply(_x1) )->sum() + 2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class SuffixOperations {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t!=0){
      solve(br,pr);
      t--;
    }
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    int[] nums=new int[n];
    String[] temp=br.readLine().split(" ");
    if(n==2){
      pr.println(0);
      return ;
    }
    long sum=0 ;
    long res=Long.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      nums[i]=Integer.parseInt(temp[i]);
      if(i-1>=0){
        sum+=Math.abs(nums[i]-nums[i-1]);
      }
    }
    for(int i=0 ; i<n ; i++){
      int num=nums[i];
      long tempRes=sum-(i>=1 ? Math.abs(nums[i]-nums[i-1]): 0)-(i+1<n ? Math.abs(nums[i+1]-nums[i]): 0);
      if(i>=1){
        long tempRes1=tempRes+(i+1<n ? Math.abs(nums[i+1]-nums[i-1]): 0);
        res=Math.min(res,tempRes1);
      }
      if(i+1<n){
        long tempRes2=tempRes+(i-1>=0 ? Math.abs(nums[i+1]-nums[i-1]): 0);
        res=Math.min(res,tempRes2);
      }
    }
    pr.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class SuffixOperations {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
    while (t /= 0) do (     execute solve(br, pr) ; 
     t := t - 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
    var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
    if (n = 2) then (     skip ; 
     return ) else skip ; 
    var sum : long ; sum := 0 ;
    var res : long ; res := "9223372036854775807"->toLong() ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := (temp[i+1])->toInteger() ; 
     if (i - 1 >= 0) then (     sum := sum+(if nums[i+1] - nums[i - 1+1] < 0 then -(nums[i+1] - nums[i - 1+1]) else nums[i+1] - nums[i - 1+1] endif) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := nums[i+1] ;
     var tempRes : long ; tempRes := sum - (if i >= 1 then if nums[i+1] - nums[i - 1+1] < 0 then -(nums[i+1] - nums[i - 1+1]) else nums[i+1] - nums[i - 1+1] endif else 0 endif) - (if i + 1 < n then if nums[i + 1+1] - nums[i+1] < 0 then -(nums[i + 1+1] - nums[i+1]) else nums[i + 1+1] - nums[i+1] endif else 0 endif) ;
     if (i >= 1) then (     var tempRes1 : long ; tempRes1 := tempRes + (if i + 1 < n then if nums[i + 1+1] - nums[i - 1+1] < 0 then -(nums[i + 1+1] - nums[i - 1+1]) else nums[i + 1+1] - nums[i - 1+1] endif else 0 endif) ;
     res := Set{res, tempRes1}->min() ) else skip ; 
     if (i + 1 < n) then (     var tempRes2 : long ; tempRes2 := tempRes + (if i - 1 >= 0 then if nums[i + 1+1] - nums[i - 1+1] < 0 then -(nums[i + 1+1] - nums[i - 1+1]) else nums[i + 1+1] - nums[i - 1+1] endif else 0 endif) ;
     res := Set{res, tempRes2}->min() ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public static void main(String[] agrs){
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=sc.nextInt();
    for(int z=0 ; z<t ; z++){
      int n=sc.nextInt();
      long[] a=new long[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextLong();
      long[] dif=new long[n];
      boolean first=true ;
      for(int i=1 ; i<n ; i++){
        dif[i]=a[i]-a[i-1];
      }
      long sum=0 ;
      for(int i=1 ; i<n ; i++){
        sum+=(long)Math.abs(dif[i]);
      }
      long min=sum-(long)Math.abs(dif[1]);
      min=(long)Math.min(min,sum-(long)Math.abs(dif[n-1]));
      long var ;
      for(int i=1 ; i<n-1 ; i++){
        var=sum-(long)Math.abs(dif[i])-(long)Math.abs(dif[i+1]);
        var+=(long)Math.abs(dif[i]+dif[i+1]);
        if(var<min)min=var ;
      }
      out.println(min);
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        var z : int ; z := 0 ; while z < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var dif : Sequence(long) ; dif := Integer.subrange(1,n)->collect(0) ;
    var first : boolean ; first := true ;
        var i : int ; i := 1 ; while i < n do ( (     dif[i+1] := a[i+1] - a[i - 1+1] )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     sum := sum+(if dif[i+1] < 0 then -(dif[i+1]) else dif[i+1] endif->oclAsType(long)) )  ;     i := i + 1 ) ; 
    var min : long ; min := sum - if dif[1+1] < 0 then -(dif[1+1]) else dif[1+1] endif->oclAsType(long) ;
    min := Set{min, sum - if dif[n - 1+1] < 0 then -(dif[n - 1+1]) else dif[n - 1+1] endif->oclAsType(long)}->min()->oclAsType(long) ; 
    var var : long ;
        var i : int ; i := 1 ; while i < n - 1 do ( (     var := sum - if dif[i+1] < 0 then -(dif[i+1]) else dif[i+1] endif->oclAsType(long) - if dif[i + 1+1] < 0 then -(dif[i + 1+1]) else dif[i + 1+1] endif->oclAsType(long) ; 
     var := var+(if dif[i+1] + dif[i + 1+1] < 0 then -(dif[i+1] + dif[i + 1+1]) else dif[i+1] + dif[i + 1+1] endif->oclAsType(long)) ; 
     if (var < min) then     min := var ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     z := z + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SuffixOperations {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    while(t-->0){
      int n=scan.nextInt();
      long[] a=new long[n];
      for(int i=0 ; i<n ; i++){
        a[i]=scan.nextInt();
      }
      long[] cost=new long[n];
      long res=0 ;
      for(int i=0 ; i<n-1 ; i++){
        cost[i]=Math.abs(a[i]-a[i+1]);
        res+=cost[i];
      }
      long k=res ;
      for(int i=0 ; i<n ; i++){
        long tRes=k ;
        if(i==0){
          tRes-=cost[i];
        }
        else if(i==n-1){
          tRes-=cost[i-1];
        }
        else {
          tRes=(tRes+Math.abs(a[i-1]-a[i+1]))-((cost[i-1]+cost[i]));
        }
        res=Math.min(res,tRes);
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SuffixOperations {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cost : Sequence(long) ; cost := Integer.subrange(1,n)->collect(0) ;
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     cost[i+1] := if a[i+1] - a[i + 1+1] < 0 then -(a[i+1] - a[i + 1+1]) else a[i+1] - a[i + 1+1] endif ; 
     res := res+(cost[i+1]) )  ;     i := i + 1 ) ; 
    var k : long ; k := res ;
        var i : int ; i := 0 ; while i < n do ( (     var tRes : long ; tRes := k ;
     if (i = 0) then (     tRes := tRes-(cost[i+1]) ) else     if (i = n - 1) then (     tRes := tRes-(cost[i - 1+1]) ) else (     tRes := (tRes + if a[i - 1+1] - a[i + 1+1] < 0 then -(a[i - 1+1] - a[i + 1+1]) else a[i - 1+1] - a[i + 1+1] endif) - ((cost[i - 1+1] + cost[i+1])) ) ;  ;  
     res := Set{res, tRes}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x=sc.nextInt();
    int y=sc.nextInt();
    int min=(int)(Math.ceil(n*y/100d));
    if(x>=min)System.out.print(0);
    else System.out.print(min-x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var min : int ; min := ((n * y / 100d)->ceil())->oclAsType(int) ;
    if (x >= min) then     OclFile["System.out"].print(0) else     OclFile["System.out"].print(min - x) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.OutputStream ;
import java.io.PrintStream ;
import java.util.*;
public class P168A {
  public static void main(String[] args)throws Exception {
    new P168A().run();
  }
  void run()throws Exception {
    Scanner scanner=new Scanner(getInputStream());
    int n=scanner.nextInt();
    int x=scanner.nextInt();
    int y=scanner.nextInt();
    int needed100=Math.max(0,y*n-100*x);
    if(needed100 % 100==0){
      getOutputStream().println(needed100/100);
    }
    else {
      getOutputStream().println(1+needed100/100);
    }
  }
  InputStream getInputStream(){
    return System.in ;
  }
  PrintStream getOutputStream(){
    return System.out ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class P168A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     P168A.newP168A().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(getInputStream()) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var x : int ; x := scanner.getCurrent()->toInteger() ;
    var y : int ; y := scanner.getCurrent()->toInteger() ;
    var needed100 : int ; needed100 := Set{0, y * n - 100 * x}->max() ;
    if (needed100 mod 100 = 0) then (     getOutputStream().println(needed100 / 100) ) else (     getOutputStream().println(1 + needed100 / 100) ) ;  
 );
   operation getInputStream() : OclFile
  pre: true
  post: true
  activity: (     return OclFile["System.in"] );
   operation getOutputStream() : OclFile
  pre: true
  post: true
  activity: (     return OclFile["System.out"] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class RobotCleaner {
  public static int time(int m,int n,int rb,int cb,int rd,int cd){
    int t=0 ;
    int dr=1 ;
    int dc=1 ;
    while(true){
      if(rb==rd || cb==cd)return t ;
      t++;
      if((rb+dr)<=0 ||(rb+dr>m))dr*=-1 ;
      if((cb+dc)<=0 ||(cb+dc>n))dc*=-1 ;
      rb+=dr ;
      cb+=dc ;
    }
  }
  public static void main(String[] args)throws Exception {
    InputStreamReader streamReader=new InputStreamReader(System.in);
    BufferedReader reader=new BufferedReader(streamReader);
    int testCases=Integer.parseInt(reader.readLine());
    while(testCases-->0){
      String input[]=reader.readLine().split(" ");
      int t=time(Integer.parseInt(input[0]),Integer.parseInt(input[1]),Integer.parseInt(input[2]),Integer.parseInt(input[3]),Integer.parseInt(input[4]),Integer.parseInt(input[5]));
      System.out.println(t);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class RobotCleaner {
  static   operation time( m : int, n : int, rb : int, cb : int, rd : int, cd : int) : int
  pre: true
  post: true
  activity: (     var t : int ; t := 0 ;
     var dr : int ; dr := 1 ;
     var dc : int ; dc := 1 ;
     while (true) do (     if (rb = rd or cb = cd) then     return t else skip ; 
     t := t + 1 ; 
    if ((rb + dr) <= 0 or (rb + dr > m)) then     dr := dr*(-1) ; else skip ; 
    if ((cb + dc) <= 0 or (cb + dc > n)) then     dc := dc*(-1) ; else skip ; 
    rb := rb+(dr) ; 
    cb := cb+(dc) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var streamReader : OclFile ; streamReader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(streamReader) ;
     var testCases : int ; testCases := (reader.readLine())->toInteger() ;
         while (testCases > 0) do (        testCases := testCases - 1 ;     skip ; (     var input : Sequence(String) ; input := reader.readLine()->split(" ") ;
     var t : int ; t := time((input[0+1])->toInteger(), (input[1+1])->toInteger(), (input[2+1])->toInteger(), (input[3+1])->toInteger(), (input[4+1])->toInteger(), (input[5+1])->toInteger()) ;
     OclFile["System.out"].println(t) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long m=Long.parseLong(sc.next());
    long n=Long.parseLong(sc.next());
    System.out.println(pow(m,n,1000000007));
  }
  static long pow(long x,long n,long M){
    if(n==0)return 1 ;
    long res=pow(x*x % M,n/2,M);
    if(n % 2==1)res=res*x % M ;
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : long ; m := (sc.getCurrent())->toLong() ;
     var n : long ; n := (sc.getCurrent())->toLong() ;
     OclFile["System.out"].println(pow(m, n, 1000000007)) );
  static   operation pow( x : long, n : long, M : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     var res : long ; res := pow(x * x mod M, n / 2, M) ;
     if (n mod 2 = 1) then     res := res * x mod M ; else skip ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    Main ob=new Main();
    ob.run();
  }
  private void run(){
    int n=nextInt();
    int x=nextInt();
    double y=nextInt()/100.0 ;
    int ans=(int)Math.ceil(n*y)-x ;
    if(ans>=0)out.println(ans);
    else out.println(0);
    out.close();
  }
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer st ;
  PrintWriter out=new PrintWriter(System.out);
  String nextLine(){
    try {
      return br.readLine();
    }
    catch(IOException ex){
      ex.printStackTrace();
    }
    return "" ;
  }
  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());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ob : Main ; ob := Main.newMain() ;
     ob.run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var x : int ; x := nextInt() ;
    var y : double ; y := nextInt() / 100.0 ;
    var ans : int ; ans := (n * y)->ceil()->oclAsType(int) - x ;
    if (ans >= 0) then     out.println(ans) else     out.println(0) ; ;  
    out.close() ; 
 );
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator;
   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (ex : IOException) do (     ex.printStackTrace() )
     return "" );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int x=scn.nextInt();
    int y=scn.nextInt();
    int rq=(int)Math.ceil((y/100.0)*n-x);
    if(rq>=0)System.out.println(rq);
    else System.out.println(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var x : int ; x := scn.getCurrent()->toInteger() ;
    var y : int ; y := scn.getCurrent()->toInteger() ;
    var rq : int ; rq := ((y / 100.0) * n - x)->ceil()->oclAsType(int) ;
    if (rq >= 0) then     OclFile["System.out"].println(rq) else     OclFile["System.out"].println(0) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Magos {
  public static void main(String[] args){
    Scanner entrada=new Scanner(System.in);
    {
      int n,x,y ;
      n=entrada.nextInt();
      x=entrada.nextInt();
      y=entrada.nextInt();
      int clones=(n*y+99)/100-x ;
      if(clones<0){
        clones=0 ;
      }
      System.out.println(clones);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Magos {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var entrada : OclFile ; entrada := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ;
    var x : int ;
    var y : int ;
     n := entrada.getCurrent()->toInteger() ; 
    x := entrada.getCurrent()->toInteger() ; 
    y := entrada.getCurrent()->toInteger() ; 
    var clones : int ; clones := (n * y + 99) / 100 - x ;
    if (clones < 0) then (     clones := 0 ) else skip ; 
    OclFile["System.out"].println(clones) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int n=input.nextInt();
    int m=input.nextInt();
    long a[]=new long[n];
    TreeSet<Integer>set=new TreeSet<>();
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=input.nextLong();
      set.add(i);
      sum+=a[i];
    }
    long setallsame=-1 ;
    for(int i=0 ; i<m ; i++){
      int type=input.nextInt();
      if(type==1){
        int index=input.nextInt()-1 ;
        long value=input.nextLong();
        if(set.contains(index)){
          sum+=(value-a[index]);
          a[index]=value ;
        }
        else {
          set.add(index);
          sum+=(value-setallsame);
          a[index]=value ;
        }
      }
      else {
        long value=input.nextLong();
        setallsame=value ;
        set.clear();
        sum=(n*value);
      }
      System.out.println(sum);
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var n : int ; n := input.nextInt() ;
    var m : int ; m := input.nextInt() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.nextLong() ; 
     set := set->including(i) ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    var setallsame : long ; setallsame := -1 ;
        var i : int ; i := 0 ; while i < m do ( (     var type : int ; type := input.nextInt() ;
     if (type = 1) then (     var index : int ; index := input.nextInt() - 1 ;
     var value : long ; value := input.nextLong() ;
     if (set->includes(index)) then (     sum := sum+((value - a[index+1])) ; 
     a[index+1] := value ) else (     set := set->including(index) ; 
     sum := sum+((value - setallsame)) ; 
     a[index+1] := value ) ) else (     var value : long ; value := input.nextLong() ;
     setallsame := value ; 
     set := set->intersection(Set{}) ; 
     sum := (n * value) ) ;  
     OclFile["System.out"].println(sum) )  ;     i := i + 1 ) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      int l=input.nextInt();
      int r=input.nextInt();
      int ans[]=new int[n+1];
      for(int i=1 ; i<=n ; i++){
        int now=(l % i);
        if(now>0){
          now=i-now ;
        }
        ans[i]=l+now ;
        if(ans[i]>r){
          System.out.println("NO");
          continue work ;
        }
      }
      StringBuilder result=new StringBuilder();
      ;
      result.append("YES\n");
      for(int i=1 ; i<=n ; i++){
        result.append(ans[i]+" ");
      }
      System.out.println(result);
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var tc : int ; tc := input.nextInt() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.nextInt() ;
     var l : int ; l := input.nextInt() ;
    var r : int ; r := input.nextInt() ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     var now : int ; now := (l mod i) ;
     if (now > 0) then (     now := i - now ) else skip ; 
     ans[i+1] := l + now ; 
     if (ans[i+1] > r) then (     OclFile["System.out"].println("NO") ; 
     continue ) else skip )  ;     i := i + 1 ) ; 
    var result : String ; result := StringLib.newString() ;
    result := result + StringLib.newString("YES\n") ; 
        var i : int ; i := 1 ; while i <= n do ( (     result := result + StringLib.newString(ans[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ) ;  ) ;  );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class _1708B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int l=sc.nextInt();
      int r=sc.nextInt();
      Vector<Long>ans=new Vector<>();
      for(int i=1 ; i<=n ; i++){
        long num=((long)Math.ceil(((double)l/i)))*i ;
        if(num>=l && num<=r)ans.add(num);
      }
      if(ans.size()==n){
        System.out.println("YES");
        for(Long i : ans)System.out.print(i+" ");
      }
      else System.out.print("NO");
      System.out.println();
    }
  }
  public static int gcd(int a,int b){
    return(a==0)? b : gcd(b % a,a);
  }
  static int power(int x,int y){
    int ans=1 ;
    while(y>0){
      if((y & 1)!=0)ans*=x ;
      y=y>>1 ;
      x*=x ;
    }
    return ans ;
  }
  public static List<Integer>sieve(int n){
    List<Integer>primes=new LinkedList<>();
    boolean[] composite=new boolean[n+1];
    for(int i=2 ; i*i<=n ; i++)for(int j=i*i ; j<=n && ! composite[i]; j+=i)composite[j]=true ;
    for(int j=2 ; j<composite.length ; j++)if(! composite[j])primes.add(j);
    return primes ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1708B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var ans : Sequence(long) ; ans := Sequence{} ;
        var i : int ; i := 1 ; while i <= n do ( (     var num : long ; num := (((l->oclAsType(double) / i))->ceil()->oclAsType(long)) * i ;
     if (num >= l & num <= r) then     ans := ans->including(num) ; else skip )  ;     i := i + 1 ) ; 
    if (ans->size() = n) then (     OclFile["System.out"].println("YES") ; 
     for (i : ans) do (     OclFile["System.out"].print(i + " ") ;  ) ) else     OclFile["System.out"].print("NO") ; ;  
    OclFile["System.out"].println() ; 
 ) ;  ) );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if (a = 0) then b else gcd(b mod a, a) endif );
  static   operation power( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
     while (y > 0) do (     if ((y & 1) /= 0) then     ans := ans*(x) ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := x*(x) ) ; 
     return ans );
  static   operation sieve( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var primes : Sequence(int) ; primes := Sequence{} ;
     var composite : Sequence(boolean) ; composite := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 2 ; while i * i <= n do (         var j : int ; j := i * i ; while j <= n & not(composite[i+1]) do (     composite[j+1] := true ;  ;     j := j+(i) ) ;  ;     i := i + 1 ) ; 
        var j : int ; j := 2 ; while j < composite->size() do (     if (not(composite[j+1])) then     primes := primes->including(j) ; else skip ;  ;     j := j + 1 ) ; 
    return primes 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    while(t-->0){
      int n=scan.nextInt();
      int l=scan.nextInt();
      int r=scan.nextInt();
      boolean flag=true ;
      int[] arr=new int[n+1];
      for(int i=1 ; i<=n ; i++){
        arr[i]=((l-1)/i+1)*i ;
        if(arr[i]>r){
          flag=false ;
          break ;
        }
      }
      if(flag){
        System.out.println("yes");
        for(int i=1 ; i<=n ; i++)System.out.print(arr[i]+" ");
      }
      else System.out.print("no");
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var l : int ; l := scan.getCurrent()->toInteger() ;
    var r : int ; r := scan.getCurrent()->toInteger() ;
    var flag : boolean ; flag := true ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := ((l - 1) / i + 1) * i ; 
     if (arr[i+1] > r) then (     flag := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then (     OclFile["System.out"].println("yes") ; 
         var i : int ; i := 1 ; while i <= n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ) else     OclFile["System.out"].print("no") ; ;  
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.out ;
public class Main {
  public static void main(String...args){
    Scanner sc=new Scanner(System.in);
    int time=sc.nextInt();
    int h=0 ;
    int m=0 ;
    int s=0 ;
    if(time>=60*60){
      h=time/(60*60);
      time-=60*60*h ;
    }
    if(time>=60){
      m=time/60 ;
      time-=60*m ;
    }
    s=time % 60 ;
    out.println(String.format("%d:%d:%d",h,m,s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var time : int ; time := sc.getCurrent()->toInteger() ;
    var h : int ; h := 0 ;
    var m : int ; m := 0 ;
    var s : int ; s := 0 ;
    if (time >= 60 * 60) then (     h := time / (60 * 60) ; 
     time := time-(60 * 60 * h) ) else skip ; 
    if (time >= 60) then (     m := time / 60 ; 
     time := time-(60 * m) ) else skip ; 
    s := time mod 60 ; 
    out.println(StringLib.format("%d:%d:%d",Sequence{h,m,s})) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class RobotCleaner {
  public static void main(String args[]){
    Scanner e=new Scanner(System.in);
    int t=e.nextInt();
    while(t>0){
      int n=e.nextInt();
      int m=e.nextInt();
      int rb=e.nextInt();
      int cb=e.nextInt();
      int rd=e.nextInt();
      int cd=e.nextInt();
      int x=0,dr=1,dc=1 ;
      while(true){
        if(rb==rd || cb==cd)break ;
        if(rb==n)dr=-1 ;
        if(cb==m)dc=-1 ;
        rb+=dr ;
        cb+=dc ;
        x++;
      }
      System.out.println(x);
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class RobotCleaner {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var e : OclFile ; e := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := e.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := e.getCurrent()->toInteger() ;
     var m : int ; m := e.getCurrent()->toInteger() ;
    var rb : int ; rb := e.getCurrent()->toInteger() ;
    var cb : int ; cb := e.getCurrent()->toInteger() ;
    var rd : int ; rd := e.getCurrent()->toInteger() ;
    var cd : int ; cd := e.getCurrent()->toInteger() ;
    var x : int ; x := 0 ;
    var dr : int ; dr := 1 ;
    var dc : int ; dc := 1 ;
    while (true) do (     if (rb = rd or cb = cd) then     break else skip ; 
     if (rb = n) then     dr := -1 ; else skip ; 
    if (cb = m) then     dc := -1 ; else skip ; 
    rb := rb+(dr) ; 
    cb := cb+(dc) ; 
    x := x + 1 ; 
 ) ; 
    OclFile["System.out"].println(x) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args){
    InputStreamReader sr=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(sr);
    try {
      String str=br.readLine();
      int a=Integer.parseInt(str);
      int h=a/3600 ;
      int m=a % 3600/60 ;
      int s=a % 3600 % 60 ;
      System.out.println(h+":"+m+":"+s);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sr : OclFile ; sr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(sr) ;
     try (     var str : String ; str := br.readLine() ;
     var a : int ; a := (str)->toInteger() ;
    var h : int ; h := a / 3600 ;
    var m : int ; m := a mod 3600 / 60 ;
    var s : int ; s := a mod 3600 mod 60 ;
    OclFile["System.out"].println(h + ":" + m + ":" + s) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
public class Main {
  public static final int M=1000000007 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] t=br.readLine().split(" ");
    int m=Integer.parseInt(t[0]);
    int n=Integer.parseInt(t[1]);
    System.out.println(power(m,n));
  }
  public static long power(int x,int n){
    long res=1 ;
    if(n>0){
      res=power(x,n/2);
      if(n % 2==0)res=(res*res)% M ;
      else res=(((res*res)% M)*x)% M ;
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute M : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : Sequence(String) ; t := br.readLine()->split(" ") ;
    var m : int ; m := (t[0+1])->toInteger() ;
    var n : int ; n := (t[1+1])->toInteger() ;
    OclFile["System.out"].println(power(m, n)) ; 
 );
  static   operation power( x : int, n : int) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     if (n > 0) then (     res := power(x, n / 2) ; 
     if (n mod 2 = 0) then     res := (res * res) mod M ; else     res := (((res * res) mod M) * x) mod M ; ) else skip ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int b=0 ;
    int c=0 ;
    int su=Integer.parseInt(br.readLine());
    if((su>0)&&(86400>su)){
      if(su>=60){
        c=su/60 ;
        su %=60 ;
      }
      if(c>=60){
        b=c/60 ;
        c=c % 60 ;
      }
    }
    System.out.println(b+":"+c+":"+su);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var b : int ; b := 0 ;
    var c : int ; c := 0 ;
    var su : int ; su := (br.readLine())->toInteger() ;
    if ((su > 0) & (86400 > su)) then (     if (su >= 60) then (     c := su / 60 ; 
     su := su mod 60 ) else skip ; 
     if (c >= 60) then (     b := c / 60 ; 
     c := c mod 60 ) else skip ) else skip ; 
    OclFile["System.out"].println(b + ":" + c + ":" + su) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line=br.readLine();
    int num=Integer.parseInt(line);
    int sec=num % 60 ;
    int min=num/60 % 60 ;
    int hour=num/(60*60)% 60 ;
    System.out.println(String.format("%d:%d:%d",hour,min,sec));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := br.readLine() ;
    var num : int ; num := (line)->toInteger() ;
    var sec : int ; sec := num mod 60 ;
    var min : int ; min := num / 60 mod 60 ;
    var hour : int ; hour := num / (60 * 60) mod 60 ;
    OclFile["System.out"].println(StringLib.format("%d:%d:%d",Sequence{hour,min,sec})) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner i=new Scanner(System.in);
    int r=i.nextInt();
    int h=Math.round(r/(60*60));
    int m=Math.round(r %(60*60)/60);
    int s=Math.round(r %(60*60)% 60);
    System.out.println(h+":"+m+":"+s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : OclFile ; i := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := i.getCurrent()->toInteger() ;
    var h : int ; h := (r / (60 * 60))->round() ;
    var m : int ; m := (r mod (60 * 60) / 60)->round() ;
    var s : int ; s := (r mod (60 * 60) mod 60)->round() ;
    OclFile["System.out"].println(h + ":" + m + ":" + s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n ;
    while(true){
      n=sc.nextInt();
      if(n==-1)break ;
      System.out.println(f(n));
    }
  }
  static String f(int n){
    int four[]=new int[10];
    four[0]=1 ;
    String str="" ;
    for(int i=1 ; i<10 ; i++){
      four[i]=four[i-1]*4 ;
    }
    for(int i=9 ; 0<=i ; i--){
      if(four[i]<=n){
        str=str+Integer.toString(n/four[i]);
        n %=four[i];
      }
      else if(! str.equals("")){
        str=str+"0" ;
      }
    }
    if(str.equals("")){
      return "0" ;
    }
    else return str ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
     while (true) do (     n := sc.getCurrent()->toInteger() ; 
     if (n = -1) then     break else skip ; 
     OclFile["System.out"].println(f(n)) ) );
  static   operation f( n : int) : String
  pre: true
  post: true
  activity: (     var four : Sequence(int) ; four := Integer.subrange(1,10)->collect(0) ;
     four[0+1] := 1 ; 
    var str : String ; str := "" ;
        var i : int ; i := 1 ; while i < 10 do ( (     four[i+1] := four[(i)->char2byte() - 1+1] * 4 )  ;     i := i + 1 ) ; 
        var i : int ; i := 9 ; while 0 <= i do ( (     if (four[i+1] <= n) then (     str := str + ((n / four[i+1]) + "") ; 
     n := n mod four[i+1] ) else     if (not(str = "")) then (     str := str + "0" ) else skip ; )  ;     i := i - 1 ) ; 
    if (str = "") then (     return "0" ) else     return str ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      if(n==-1){
        break ;
      }
      println(Integer.toString(n,4));
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = -1) then (     break ) else skip ; 
     execute println(((n) + "")) )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      BigInteger b=sc.nextBigInteger();
      if(b.intValue()==-1)break ;
      System.out.println(b.toString(4));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var b : long ; b := sc.nextBigInteger() ;
     if (b->oclAsType(int) = -1) then     break else skip ; 
     OclFile["System.out"].println(b.toString(4)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      int n=sc.nextInt();
      if(n<0)break ;
      if(n==0){
        System.out.println(0);
      }
      else {
        int p=0 ;
        int[] s=new int[20];
        while(n>0){
          s[p++]=n % 4 ;
          n/=4 ;
        }
        for(int i=p-1 ; i>=0 ; i--){
          System.out.print(s[i]);
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n < 0) then     break else skip ; 
     if (n = 0) then (     OclFile["System.out"].println(0) ) else (     var p : int ; p := 0 ;
     var s : Sequence(int) ; s := Integer.subrange(1,20)->collect(0) ;
    while (n > 0) do (      s[p+1] := n mod 4  ; p := p + 1 ; 
     n := n/(4) ) ; 
        var i : int ; i := p - 1 ; while i >= 0 do ( (     OclFile["System.out"].print(s[i+1]) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println() ; 
 ) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int row=sc.nextInt();
      int col=sc.nextInt();
      int i=sc.nextInt();
      int j=sc.nextInt();
      int fi=sc.nextInt();
      int fj=sc.nextInt();
      int ans=0 ;
      int r=1 ;
      int c=1 ;
      while(true){
        if(i==fi || j==fj){
          break ;
        }
        else {
          if(i+r>row || i+r<1){
            r=r*-1 ;
          }
          if(j+c>col || j+c<1){
            c=c*-1 ;
          }
          i=i+r ;
          j=j+c ;
          ans++;
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var row : int ; row := sc.getCurrent()->toInteger() ;
     var col : int ; col := sc.getCurrent()->toInteger() ;
    var i : int ; i := sc.getCurrent()->toInteger() ;
    var j : int ; j := sc.getCurrent()->toInteger() ;
    var fi : int ; fi := sc.getCurrent()->toInteger() ;
    var fj : int ; fj := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    var r : int ; r := 1 ;
    var c : int ; c := 1 ;
    while (true) do (     if (i = fi or j = fj) then (     break ) else (     if (i + r > row or i + r < 1) then (     r := r * -1 ) else skip ; 
     if (j + c > col or j + c < 1) then (     c := c * -1 ) else skip ; 
    i := i + r ; 
    j := j + c ; 
    ans := ans + 1 ; 
 ) ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GfG {
  public static int mostCommon(int lower,int higher){
    if(lower==higher)return lower ;
    else return 2 ;
  }
  public static void main(String[] args){
    int lower=10 ;
    int higher=20 ;
    System.out.println("The most frequent factor "+mostCommon(lower,higher));
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation mostCommon( lower : int, higher : int) : int
  pre: true
  post: true
  activity: (     if (lower = higher) then     return lower else     return 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var lower : int ; lower := 10 ;
     var higher : int ; higher := 20 ;
     OclFile["System.out"].println("The most frequent factor " + mostCommon(lower, higher)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Node {
    int data ;
    Node left,right ;
    boolean visited ;
  }
  static void postorder(Node head){
    Node temp=head ;
    while(temp!=null && temp.visited==false){
      if(temp.left!=null && temp.left.visited==false)temp=temp.left ;
      else if(temp.right!=null && temp.right.visited==false)temp=temp.right ;
      else {
        System.out.printf("%d ",temp.data);
        temp.visited=true ;
        temp=head ;
      }
    }
  }
  static Node newNode(int data){
    Node node=new Node();
    node.data=data ;
    node.left=null ;
    node.right=null ;
    node.visited=false ;
    return(node);
  }
  public static void main(String[] args){
    Node root=newNode(8);
    root.left=newNode(3);
    root.right=newNode(10);
    root.left.left=newNode(1);
    root.left.right=newNode(6);
    root.left.right.left=newNode(4);
    root.left.right.right=newNode(7);
    root.right.right=newNode(14);
    root.right.right.left=newNode(13);
    postorder(root);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute left : Node;
   attribute visited : boolean;
}
  static   operation postorder( head : Node) : void
  pre: true
  post: true
  activity: (     var temp : Node ; temp := head ;
     while (temp /= null & temp.visited = false) do (     if (temp.left /= null & temp.left.visited = false) then     temp := temp.left ; else     if (temp.right /= null & temp.right.visited = false) then     temp := temp.right else (     OclFile["System.out"].printf("%d ", temp.data) ; 
     temp.visited := true ; 
     temp := head ) ;  ) );
  static   operation newNode( data : int) : Node
  pre: true
  post: true
  activity: (     var node : Node ; node := Node.newNode() ;
     node.data := data ; 
    node.left := null ; 
    node.right := null ; 
    node.visited := false ; 
    return (node) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var root : Node ; root := newNode(8) ;
     root.left := newNode(3) ; 
    root.right := newNode(10) ; 
    root.left.left := newNode(1) ; 
    root.left.right := newNode(6) ; 
    root.left.right.left := newNode(4) ; 
    root.left.right.right := newNode(7) ; 
    root.right.right := newNode(14) ; 
    root.right.right.left := newNode(13) ; 
    execute postorder(root) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    BigInteger m=sc.nextBigInteger();
    BigInteger n=sc.nextBigInteger();
    System.out.println(m.modPow(n,BigInteger.valueOf(1000000007)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : long ; m := sc.nextBigInteger() ;
     var n : long ; n := sc.nextBigInteger() ;
     OclFile["System.out"].println(m.modPow(n, (1000000007 + "")->toLong())) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    HashMap<String,Integer>map=new HashMap<>();
    HashSet<String>set=new HashSet<>();
    for(int i=0 ; i<str.length(); i++){
      String ans="" ;
      ans+=str.charAt(i);
      set.add(ans);
      if(map.get(ans)==null){
        int t=1 ;
        map.put(ans,t);
      }
      else {
        int t=map.get(ans)+1 ;
        map.put(ans,t);
      }
      for(int j=i+1 ; j<str.length(); j++){
        ans+=str.charAt(j);
        set.add(ans);
        int sum=0 ;
        if(map.get(ans)==null){
          sum++;
          map.put(ans,sum);
        }
        else {
          sum=map.get(ans)+1 ;
          map.put(ans,sum);
        }
      }
    }
    int ans=0 ;
    for(String s : set){
      if(map.get(s)>=2){
        if(s.length()>ans){
          ans=s.length();
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var map : Map(String,int) ; map := Map{} ;
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := 0 ; while i < str->size() do ( (     var ans : String ; ans := "" ;
     ans := ans+(str->at(i+1)) ; 
    set := set->including(ans) ; 
    if (map->at(ans) = null) then (     var t : int ; t := 1 ;
     map := map->union(Map{ans |-> t}) ) else (     var t : int ; t := map->at(ans) + 1 ;
     map := map->union(Map{ans |-> t}) ) ;  
        var j : int ; j := i + 1 ; while j < str->size() do ( (     ans := ans+(str->at(j+1)) ; 
     set := set->including(ans) ; 
     var sum : int ; sum := 0 ;
     if (map->at(ans) = null) then (     sum := sum + 1 ; 
     map := map->union(Map{ans |-> sum}) ) else (     sum := map->at(ans) + 1 ; 
     map := map->union(Map{ans |-> sum}) ) )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (s : set) do ( (     if (map->at(s) >= 2) then (     if (s->size() > ans) then (     ans := s->size() ) else skip ) else skip )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
import java.util.StringTokenizer ;
public class Main {
  static int n ;
  static String str ;
  public static void main(String[] args){
    InputReader s=new InputReader();
    str=s.next();
    n=str.length();
    int l=0,r=n ;
    while(l<r){
      int mid=l+r+1>>1 ;
      if(check(mid))l=mid ;
      else r=mid-1 ;
    }
    System.out.println(l);
  }
  static boolean check(int len){
    HashSet<String>set=new HashSet<>();
    for(int i=0 ; i<=n-len ; i++){
      String now=str.substring(i,i+len);
      if(set.contains(now))return true ;
      set.add(now);
    }
    return false ;
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(){
      reader=new BufferedReader(new InputStreamReader(System.in),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute str : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : InputReader ; s := InputReader.newInputReader() ;
     str := s.next() ; 
    n := str->size() ; 
    var l : int ; l := 0 ;
    var r : int ; r := n ;
    while (l < r) do (     var mid : int ; mid := (l + r + 1/(2->pow(1)))->oclAsType(long) ;
     if (check(mid)) then     l := mid ; else     r := mid - 1 ; ) ; 
    OclFile["System.out"].println(l) ; 
 );
  static   operation check( len : int) : boolean
  pre: true
  post: true
  activity: (     var set : Set(String) ; set := Set{} ;
         var i : int ; i := 0 ; while i <= n - len do ( (     var now : String ; now := str.subrange(i+1,i + len) ;
     if (set->includes(now)) then     return true else skip ; 
     set := set->including(now) )  ;     i := i + 1 ) ; 
     return false );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader() : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
import java.util.StringTokenizer ;
public class Main {
  static int n ;
  static String str ;
  public static void main(String[] args){
    InputReader s=new InputReader();
    str=s.next();
    n=str.length();
    int l=0,r=n ;
    while(l<r){
      int mid=l+r+1>>1 ;
      if(check(mid))l=mid ;
      else r=mid-1 ;
    }
    System.out.println(l);
  }
  static boolean check(int len){
    HashSet<String>set=new HashSet<>();
    for(int i=0 ; i<=n-len ; i++){
      String now=str.substring(i,i+len);
      if(set.contains(now))return true ;
      set.add(now);
    }
    return false ;
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(){
      reader=new BufferedReader(new InputStreamReader(System.in),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute str : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : InputReader ; s := InputReader.newInputReader() ;
     str := s.next() ; 
    n := str->size() ; 
    var l : int ; l := 0 ;
    var r : int ; r := n ;
    while (l < r) do (     var mid : int ; mid := (l + r + 1/(2->pow(1)))->oclAsType(long) ;
     if (check(mid)) then     l := mid ; else     r := mid - 1 ; ) ; 
    OclFile["System.out"].println(l) ; 
 );
  static   operation check( len : int) : boolean
  pre: true
  post: true
  activity: (     var set : Set(String) ; set := Set{} ;
         var i : int ; i := 0 ; while i <= n - len do ( (     var now : String ; now := str.subrange(i+1,i + len) ;
     if (set->includes(now)) then     return true else skip ; 
     set := set->including(now) )  ;     i := i + 1 ) ; 
     return false );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader() : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution23A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    int n=s.length(),max=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<=n ; j++){
        String seg=s.substring(i,j);
        if(s.substring(i+1).contains(seg))max=Math.max(max,seg.length());
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution23A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
    var n : int ; n := s->size() ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j <= n do ( (     var seg : String ; seg := s.subrange(i+1,j) ;
     if (s.subrange(i + 1+1,i + 1)->includes(seg)) then     max := Set{max, seg->size()}->max() ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    HashMap<String,Integer>map=new HashMap<>();
    HashSet<String>set=new HashSet<>();
    for(int i=0 ; i<str.length(); i++){
      String ans="" ;
      ans+=str.charAt(i);
      set.add(ans);
      if(map.get(ans)==null){
        int t=1 ;
        map.put(ans,t);
      }
      else {
        int t=map.get(ans)+1 ;
        map.put(ans,t);
      }
      for(int j=i+1 ; j<str.length(); j++){
        ans+=str.charAt(j);
        set.add(ans);
        int sum=0 ;
        if(map.get(ans)==null){
          sum++;
          map.put(ans,sum);
        }
        else {
          sum=map.get(ans)+1 ;
          map.put(ans,sum);
        }
      }
    }
    int ans=0 ;
    for(String s : set){
      if(map.get(s)>=2){
        if(s.length()>ans){
          ans=s.length();
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var map : Map(String,int) ; map := Map{} ;
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := 0 ; while i < str->size() do ( (     var ans : String ; ans := "" ;
     ans := ans+(str->at(i+1)) ; 
    set := set->including(ans) ; 
    if (map->at(ans) = null) then (     var t : int ; t := 1 ;
     map := map->union(Map{ans |-> t}) ) else (     var t : int ; t := map->at(ans) + 1 ;
     map := map->union(Map{ans |-> t}) ) ;  
        var j : int ; j := i + 1 ; while j < str->size() do ( (     ans := ans+(str->at(j+1)) ; 
     set := set->including(ans) ; 
     var sum : int ; sum := 0 ;
     if (map->at(ans) = null) then (     sum := sum + 1 ; 
     map := map->union(Map{ans |-> sum}) ) else (     sum := map->at(ans) + 1 ; 
     map := map->union(Map{ans |-> sum}) ) )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (s : set) do ( (     if (map->at(s) >= 2) then (     if (s->size() > ans) then (     ans := s->size() ) else skip ) else skip )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sum(int N){
    int S1,S2,S3 ;
    S1=((N/3))*(2*3+(N/3-1)*3)/2 ;
    S2=((N/4))*(2*4+(N/4-1)*4)/2 ;
    S3=((N/12))*(2*12+(N/12-1)*12)/2 ;
    return S1+S2-S3 ;
  }
  public static void main(String[] args){
    int N=20 ;
    System.out.print(sum(12));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sum( N : int) : int
  pre: true
  post: true
  activity: (     var S1 : int ;
    var S2 : int ;
    var S3 : int ;
     S1 := ((N / 3)) * (2 * 3 + (N / 3 - 1) * 3) / 2 ; 
    S2 := ((N / 4)) * (2 * 4 + (N / 4 - 1) * 4) / 2 ; 
    S3 := ((N / 12)) * (2 * 12 + (N / 12 - 1) * 12) / 2 ; 
    return S1 + S2 - S3 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 20 ;
     OclFile["System.out"].print(sum(12)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),k=sc.nextInt();
    String s=sc.next();
    int p=0 ;
    while(p<n-1){
      int np=p ;
      for(int i=1 ; i<=k ; i++){
        if(s.charAt(p+i)=='.'){
          np=p+i ;
          break ;
        }
      }
      if(np==p)break ;
      p=np ;
    }
    if(p==n-1)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var p : int ; p := 0 ;
    while (p < n - 1) do (     var np : int ; np := p ;
         var i : int ; i := 1 ; while i <= k do ( (     if (s->at(p + i+1) = '.') then (     np := p + i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (np = p) then     break else skip ; 
     p := np ) ; 
    if (p = n - 1) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    int ans1=100000,ans2=1000000 ;
    for(int i=1 ; i<=n ; i++){
      if(a*i>=n){
        ans1=i*b ;
        break ;
      }
    }
    for(int i=1 ; i<=n ; i++){
      if(c*i>=n){
        ans2=i*d ;
        break ;
      }
    }
    System.out.println(Math.min(ans2,ans1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var ans1 : int ; ans1 := 100000 ;
    var ans2 : int ; ans2 := 1000000 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (a * i >= n) then (     ans1 := i * b ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (c * i >= n) then (     ans2 := i * d ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{ans2, ans1}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    String s=in.next();
    if(! s.contains("#")){
      System.out.println("YES");
      return ;
    }
    char[] c=s.toCharArray();
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      if(c[i]=='#'){
        cnt++;
        if(cnt>=k){
          System.out.println("NO");
          return ;
        }
      }
      else {
        cnt=0 ;
      }
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    if (not(s->includes("#"))) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
    var c : Sequence(String) ; c := s->characters() ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (c[i+1] = '#') then (     cnt := cnt + 1 ; 
     if (cnt >= k) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ) else (     cnt := 0 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),k=sc.nextInt();
    String str=sc.next();
    int max=0 ;
    for(int i=0 ; i<str.length(); ++i){
      if(max>=i && str.charAt(i)=='.'){
        max=Math.max(max,i+k);
      }
    }
    if(max>=n-1){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var str : String ; str := sc.getCurrent() ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (max >= i & str->at(i+1) = '.') then (     max := Set{max, i + k}->max() ) else skip )  ;     i := i + 1 ) ; 
    if (max >= n - 1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean topsyTurvy(char[] str){
    for(int i=0 ; i<str.length ; i++){
      if(str[i]=='2' || str[i]=='4' || str[i]=='5' || str[i]=='6' || str[i]=='7' || str[i]=='9'){
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    String str="1234" ;
    if(topsyTurvy(str.toCharArray()))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation topsyTurvy( str : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < str->size() do ( (     if (str[i+1] = '2' or str[i+1] = '4' or str[i+1] = '5' or str[i+1] = '6' or str[i+1] = '7' or str[i+1] = '9') then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "1234" ;
     if (topsyTurvy(str->characters())) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    int pow2[]=new int[30];
    pow2[0]=1 ;
    for(int i=1 ; i<30 ; i++){
      pow2[i]=2*pow2[i-1];
    }
    int ans=0 ;
    for(int i=0 ; i<N ; i++){
      int ai=Integer.parseInt(sc.next());
      ;
      for(int j=1 ; j<30 ; j++){
        if(ai % pow2[j]!=0){
          ans+=j-1 ;
          break ;
        }
        else if(j==29){
          ans+=29 ;
          break ;
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var pow2 : Sequence(int) ; pow2 := Integer.subrange(1,30)->collect(0) ;
    pow2[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < 30 do ( (     pow2[i+1] := 2 * pow2[i - 1+1] )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var ai : int ; ai := (sc.getCurrent())->toInteger() ;
         var j : int ; j := 1 ; while j < 30 do ( (     if (ai mod pow2[j+1] /= 0) then (     ans := ans+(j - 1) ; 
     break ) else     if (j = 29) then (     ans := ans+(29) ; 
     break ) else skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  private static final int CONST=1000000007 ;
  public static void main(String args[]){
    java.util.Scanner sc=new java.util.Scanner(System.in);
    long M=Integer.parseInt(sc.next());
    long N=Integer.parseInt(sc.next());
    System.out.println(myPow(M,N));
    sc.close();
  }
  private static long myPow(long m,long n){
    if(n==0)return 1 ;
    long res=myPow(m*m % CONST,n/2);
    if(n % 2==1)res=res*m % CONST ;
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static    attribute CONST : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(OclFile["System.in"]) ;
     var M : long ; M := (sc.next())->toInteger() ;
    var N : long ; N := (sc.next())->toInteger() ;
    OclFile["System.out"].println(myPow(M, N)) ; 
    sc.close() ; 
 );
  static   operation myPow( m : long, n : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     var res : long ; res := myPow(m * m mod CONST, n / 2) ;
     if (n mod 2 = 1) then     res := res * m mod CONST ; else skip ; 
     return res );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int countSubstr(String str,int n,char x,char y){
    int tot_count=0 ;
    int count_x=0 ;
    for(int i=0 ; i<n ; i++){
      if(str.charAt(i)==x)count_x++;
      if(str.charAt(i)==y)tot_count+=count_x ;
    }
    return tot_count ;
  }
  public static void main(String args[]){
    String str="abbcaceghcak" ;
    int n=str.length();
    char x='a',y='c' ;
    System.out.print("Count="+countSubstr(str,n,x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSubstr( str : String, n : int, x : String, y : String) : int
  pre: true
  post: true
  activity: (     var tot_count : int ; tot_count := 0 ;
     var count_x : int ; count_x := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (str->at(i+1) = x) then     count_x := count_x + 1 ; else skip ; 
     if (str->at(i+1) = y) then     tot_count := tot_count+(count_x) ; else skip )  ;     i := i + 1 ) ; 
     return tot_count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abbcaceghcak" ;
     var n : int ; n := str->size() ;
     var x : String ; x := 'a' ;
    var y : String ; y := 'c' ;
     OclFile["System.out"].print("Count=" + countSubstr(str, n, x, y)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p145 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p145().run());
  }
  public String run(){
    int sum=0 ;
    for(int digits=1 ; digits<=9 ; digits++){
      if(digits % 2==0)sum+=20*Library.pow(30,digits/2-1);
      else if(digits % 4==3)sum+=100*Library.pow(500,(digits-3)/4);
      else if(digits % 4==1)sum+=0 ;
      else throw new AssertionError();
    }
    return Integer.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
class p145 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p145.newp145().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var digits : int ; digits := 1 ; while digits <= 9 do ( (     if (digits mod 2 = 0) then     sum := sum+(20 * Library.pow(30, digits / 2 - 1)) ; else     if (digits mod 4 = 3) then     sum := sum+(100 * Library.pow(500, (digits - 3) / 4)) else     if (digits mod 4 = 1) then     sum := sum+(0) else     error AssertionException() ; ;  ;  )  ;     digits := digits + 1 ) ; 
     return ((sum) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class C {
  static Scanner scan=new Scanner(System.in);
  public static void main(String[] args){
    int t=scan.nextInt();
    while(t-->0){
      solve();
    }
  }
  public static void solve(){
    int a=scan.nextInt();
    int b=scan.nextInt();
    if(a==b){
      System.out.println(0);
    }
    else {
      int reminder=Math.abs(a-b),answer=0 ;
      answer+=reminder/5 ;
      reminder=reminder % 5 ;
      answer+=reminder/2 ;
      reminder=reminder % 2 ;
      answer+=reminder ;
      System.out.println(answer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ; a := scan.getCurrent()->toInteger() ;
     var b : int ; b := scan.getCurrent()->toInteger() ;
     if (a = b) then (     OclFile["System.out"].println(0) ) else (     var reminder : int ; reminder := if a - b < 0 then -(a - b) else a - b endif ;
    var answer : int ; answer := 0 ;
     answer := answer+(reminder / 5) ; 
    reminder := reminder mod 5 ; 
    answer := answer+(reminder / 2) ; 
    reminder := reminder mod 2 ; 
    answer := answer+(reminder) ; 
    OclFile["System.out"].println(answer) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class After601A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    while(n-->0){
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      int diff=Math.abs(a-b);
      int count=0 ;
      while(diff>0){
        if(diff>=5){
          count+=diff/5 ;
          diff=diff % 5 ;
        }
        else if(diff>=2){
          count+=diff/2 ;
          diff=diff % 2 ;
        }
        else {
          count+=diff/1 ;
          diff=diff % 1 ;
        }
      }
      System.out.println(count);
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class After601A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
    var diff : int ; diff := if a - b < 0 then -(a - b) else a - b endif ;
    var count : int ; count := 0 ;
    while (diff > 0) do (     if (diff >= 5) then (     count := count+(diff / 5) ; 
     diff := diff mod 5 ) else     if (diff >= 2) then (     count := count+(diff / 2) ; 
     diff := diff mod 2 ) else (     count := count+(diff / 1) ; 
     diff := diff mod 1 ) ;  ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=scan.nextInt();
    int K=scan.nextInt();
    int[] A=new int[N];
    int one_position=0 ;
    for(int i=0 ; i<N ; i++){
      A[i]=scan.nextInt();
      if(A[i]==1){
        one_position=i ;
      }
    }
    System.out.println(solve(N,K,A,one_position));
  }
  public static int solve(int N,int K,int[] A,int one_position){
    if(N==K){
      return 1 ;
    }
    int answer=both(N,K,one_position);
    answer=Math.min(answer,left(N,K));
    answer=Math.min(answer,right(N,K));
    return answer ;
  }
  public static int both(int N,int K,int one_position){
    int answer=0 ;
    int current=one_position ;
    while(0<current){
      answer+=1 ;
      current-=(K-1);
    }
    current=one_position ;
    while(current<N-1){
      answer+=1 ;
      current+=(K-1);
    }
    return answer ;
  }
  public static int left(int N,int K){
    int answer=0 ;
    int current=0 ;
    while(current<N-1){
      answer+=1 ;
      current+=(K-1);
    }
    return answer ;
  }
  public static int right(int N,int K){
    int answer=0 ;
    int current=N-1 ;
    while(0<current){
      answer+=1 ;
      current-=(K-1);
    }
    return answer ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var K : int ; K := scan.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var one_position : int ; one_position := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := scan.getCurrent()->toInteger() ; 
     if (A[i+1] = 1) then (     one_position := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(N, K, A, one_position)) ; 
 );
  static   operation solve( N : int, K : int, A : Sequence(int), one_position : int) : int
  pre: true
  post: true
  activity: (     if (N = K) then (     return 1 ) else skip ; 
     var answer : int ; answer := both(N, K, one_position) ;
    answer := Set{answer, left(N, K)}->min() ; 
    answer := Set{answer, right(N, K)}->min() ; 
    return answer 
 );
  static   operation both( N : int, K : int, one_position : int) : int
  pre: true
  post: true
  activity: (     var answer : int ; answer := 0 ;
     var current : int ; current := one_position ;
    while (0 < current) do (     answer := answer+(1) ; 
     current := current-((K - 1)) ) ; 
    current := one_position ; 
    while (current < N - 1) do (     answer := answer+(1) ; 
     current := current+((K - 1)) ) ; 
    return answer 
 );
  static   operation left( N : int, K : int) : int
  pre: true
  post: true
  activity: (     var answer : int ; answer := 0 ;
     var current : int ; current := 0 ;
     while (current < N - 1) do (     answer := answer+(1) ; 
     current := current+((K - 1)) ) ; 
     return answer );
  static   operation right( N : int, K : int) : int
  pre: true
  post: true
  activity: (     var answer : int ; answer := 0 ;
     var current : int ; current := N - 1 ;
     while (0 < current) do (     answer := answer+(1) ; 
     current := current-((K - 1)) ) ; 
     return answer );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int n=sc.nextInt();
  static int a=sc.nextInt();
  static int b=sc.nextInt();
  static int c=sc.nextInt();
  static int d=sc.nextInt();
  public static void main(String[] args){
    pencil();
  }
  private static void pencil(){
    int[] num=new int[] {
      a,c };
      int[] price=new int[] {
        b,d };
        int[] total=new int[2];
        for(int i=0 ; i<2 ; i++){
          if(n % num[i]==0){
            total[i]=price[i]*(n/num[i]);
          }
          else {
            total[i]=price[i]*((n/num[i])+1);
          }
        }
        System.out.println(Math.min(total[0],total[1]));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int := sc.getCurrent()->toInteger();
  static   attribute a : int := sc.getCurrent()->toInteger();
  static   attribute b : int := sc.getCurrent()->toInteger();
  static   attribute c : int := sc.getCurrent()->toInteger();
  static   attribute d : int := sc.getCurrent()->toInteger();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute pencil() );
  static   operation pencil() : void
  pre: true
  post: true
  activity: (     var num : Sequence(int) ; num := Sequence{a,c} ;
     var price : Sequence(int) ; price := Sequence{b,d} ;
    var total : Sequence(int) ; total := Integer.subrange(1,2)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 do ( (     if (n mod num[i+1] = 0) then (     total[i+1] := price[i+1] * (n / num[i+1]) ) else (     total[i+1] := price[i+1] * ((n / num[i+1]) + 1) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{total[0+1], total[1+1]}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(final String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int n=scanner.nextInt();
    final int k=scanner.nextInt();
    if(k>=n){
      System.out.println(1);
    }
    else {
      System.out.println((n-k+k-2)/(k-1)+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var k : int ; k := scanner.getCurrent()->toInteger() ;
     if (k >= n) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println((n - k + k - 2) / (k - 1) + 1) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] p=new int[n];
    for(int i=0 ; i<n ; i++){
      p[i]=sc.nextInt();
    }
    System.out.println((int)Math.ceil((double)(n-1)/(double)(k-1)));
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : int ; n := sc.nextInt() ;
    var k : int ; k := sc.nextInt() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(((n - 1)->oclAsType(double) / (k - 1)->oclAsType(double))->ceil()->oclAsType(int)) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static final Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    int N=scanner.nextInt();
    int K=scanner.nextInt();
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++){
      a[i]=scanner.nextInt();
    }
    int r=N-K ;
    System.out.println(r/(K-1)+1+(r %(K-1)!=0 ? 1 : 0));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := scanner.getCurrent()->toInteger() ;
     var K : int ; K := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var r : int ; r := N - K ;
    OclFile["System.out"].println(r / (K - 1) + 1 + (if r mod (K - 1) /= 0 then 1 else 0 endif)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.util.Collections ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(1,in,out);
    out.close();
  }
  static class Task {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int temp=0 ;
      ArrayList<Integer>a=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        a.add(in.nextInt());
      }
      Collections.sort(a);
      for(int i=0 ; i<n-1 ; i++)temp+=a.get(i);
      if(temp>a.get(n-1))out.println("Yes");
      else out.println("No");
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var temp : int ; temp := 0 ;
    var a : Sequence(int) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     a := a->including(in.nextInt()) )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
        var i : int ; i := 0 ; while i < n - 1 do (     temp := temp+(a->at(i+1)) ;  ;     i := i + 1 ) ; 
    if (temp > a->at(n - 1+1)) then     skip else     skip ; ;  
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  static long mod=1000000007 ;
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    long m,n ;
    m=sc.nextInt();
    n=sc.nextInt();
    System.out.println(power(m,n));
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
  private static long power(long m,long n){
    long q,r ;
    if(n==1)return m ;
    else {
      q=n/2 ;
      r=n % 2 ;
      if(r==0)return(power(((m*m)% mod),q))% mod ;
      else return((power(((m*m)% mod),q))*m)% mod ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   attribute mod : long := 1000000007;
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var m : long ;
    var n : long ;
    m := sc.nextInt() ; 
    n := sc.nextInt() ; 
    OclFile["System.out"].println(power(m, n)) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
  static   operation power( m : long, n : long) : long
  pre: true
  post: true
  activity: (     var q : long ;
    var r : long ;
     if (n = 1) then     return m else (     q := n / 2 ; 
     r := n mod 2 ; 
     if (r = 0) then     return (power(((m * m) mod mod), q)) mod mod else     return ((power(((m * m) mod mod), q)) * m) mod mod ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    int n=sc.nextInt();
    int a[]=new int[n];
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    Arrays.sort(a);
    for(int i=0 ; i<n-1 ; i++){
      sum+=a[i];
    }
    System.out.println(a[n-1]<sum ? "Yes" : "No");
  }
  public static PrintWriter out ;
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var n : int ; n := sc.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if a[n - 1+1] < sum then "Yes" else "No" endif) ; 
 );
  static   attribute out : OclFile;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    List<Integer>list=new ArrayList<Integer>();
    int n=sc.nextInt();
    int count=0 ;
    for(int i=0 ; n>i ; i++){
      int a=sc.nextInt();
      count=count+a ;
      list.add(a);
    }
    int max=Collections.max(list);
    count=count-max ;
    if(count>max){
      System.out.println("Yes");
    }
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(int) ; list := Sequence{} ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while n > i do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     count := count + a ; 
     list := list->including(a) )  ;     i := i + 1 ) ; 
    var max : int ; max := .max(list) ;
    count := count - max ; 
    if (count > max) then (     OclFile["System.out"].println("Yes") ) else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    int[] lengths=new int[n];
    int maxLengths=0 ;
    int sumLengths=0 ;
    for(int i=0 ; i<n ; i++){
      int length=sc.nextInt();
      maxLengths=Math.max(maxLengths,length);
      sumLengths+=length ;
    }
    if((sumLengths-maxLengths)>maxLengths){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : int ; n := sc.nextInt() ;
    var lengths : Sequence(int) ; lengths := Integer.subrange(1,n)->collect(0) ;
    var maxLengths : int ; maxLengths := 0 ;
    var sumLengths : int ; sumLengths := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var length : int ; length := sc.nextInt() ;
     maxLengths := Set{maxLengths, length}->max() ; 
     sumLengths := sumLengths+(length) )  ;     i := i + 1 ) ; 
    if ((sumLengths - maxLengths) > maxLengths) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().solveA();
  }
  private void solveA(){
    Scanner scanner=null ;
    int n=0 ;
    try {
      scanner=new Scanner(System.in);
      n=scanner.nextInt();
      int[] wk=new int[n];
      for(int i=0 ; i<n ; i++){
        wk[i]=scanner.nextInt();
      }
      Arrays.sort(wk);
      int count=0 ;
      for(int i=0 ; i<wk.length-1 ; i++){
        count+=wk[i];
      }
      System.out.println(count<=wk[wk.length-1] ? "No" : "Yes");
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
  private void solveB(){
    Scanner scanner=null ;
    int lineAB=0 ;
    int lineBC=0 ;
    int lineCA=0 ;
    try {
      scanner=new Scanner(System.in);
      lineAB=scanner.nextInt();
      System.out.println("");
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
  private void solveC(){
    Scanner scanner=null ;
    int lineAB=0 ;
    int lineBC=0 ;
    int lineCA=0 ;
    try {
      scanner=new Scanner(System.in);
      lineAB=scanner.nextInt();
      System.out.println("");
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
  private void solveD(){
    Scanner scanner=null ;
    int lineAB=0 ;
    int lineBC=0 ;
    int lineCA=0 ;
    try {
      scanner=new Scanner(System.in);
      lineAB=scanner.nextInt();
      System.out.println("");
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solveA() );
   operation solveA() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var n : int ; n := 0 ;
     try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     n := scanner.getCurrent()->toInteger() ; 
    var wk : Sequence(int) ; wk := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     wk[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    wk := wk->sort() ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < wk->size() - 1 do ( (     count := count+(wk[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if count <= wk[wk->size() - 1+1] then "No" else "Yes" endif) ; 
 )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
   operation solveB() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var lineAB : int ; lineAB := 0 ;
    var lineBC : int ; lineBC := 0 ;
    var lineCA : int ; lineCA := 0 ;
    try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     lineAB := scanner.getCurrent()->toInteger() ; 
     OclFile["System.out"].println("") )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
   operation solveC() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var lineAB : int ; lineAB := 0 ;
    var lineBC : int ; lineBC := 0 ;
    var lineCA : int ; lineCA := 0 ;
    try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     lineAB := scanner.getCurrent()->toInteger() ; 
     OclFile["System.out"].println("") )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
   operation solveD() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var lineAB : int ; lineAB := 0 ;
    var lineBC : int ; lineBC := 0 ;
    var lineCA : int ; lineCA := 0 ;
    try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     lineAB := scanner.getCurrent()->toInteger() ; 
     OclFile["System.out"].println("") )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String args[])throws IOException {
    int Ans=0 ;
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String s1=new String(in.readLine());
    String[] a=s1.split("+");
    int N=Integer.parseInt(a[0]);
    int A=Integer.parseInt(a[1]);
    int B=Integer.parseInt(a[2]);
    int C=Integer.parseInt(a[3]);
    int D=Integer.parseInt(a[4]);
    int n_a=N/A+((N % A)==0 ? 0 : 1);
    int n_c=N/C+((N % C)==0 ? 0 : 1);
    Ans=(n_a*B<n_c*D ? n_a*B : n_c*D);
    System.out.println(Ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Ans : int ; Ans := 0 ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var s1 : String ; s1 := StringLib.newString(in.readLine()) ;
    var a : Sequence(String) ; a := s1->split("+") ;
    var N : int ; N := (a[0+1])->toInteger() ;
    var A : int ; A := (a[1+1])->toInteger() ;
    var B : int ; B := (a[2+1])->toInteger() ;
    var C : int ; C := (a[3+1])->toInteger() ;
    var D : int ; D := (a[4+1])->toInteger() ;
    var n_a : int ; n_a := N / A + (if (N mod A) = 0 then 0 else 1 endif) ;
    var n_c : int ; n_c := N / C + (if (N mod C) = 0 then 0 else 1 endif) ;
    Ans := (if n_a * B < n_c * D then n_a * B else n_c * D endif) ; 
    OclFile["System.out"].println(Ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static int INF=100000001 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int half=n/2 ;
    int[] t=new int[n+2];
    int[][][] dp=new int[2][n+2][2];
    for(int i=0 ; i<n-1 ; i++){
      t[i]=Integer.parseInt(br.readLine());
      for(int j=0 ; j<2 ; j++){
        Arrays.fill(dp[j][i],INF);
      }
    }
    dp[0][0][0]=0 ;
    for(int I=0 ; I<n-1 ; I++){
      int i=I % 2 ;
      int ni=(i+1)% 2 ;
      for(int j=0 ; j<=half ; j++){
        dp[ni][j+1][0]=Math.min(dp[i][j][0],dp[i][j][1]+t[I]);
        dp[ni][j][1]=Math.min(dp[i][j][1],dp[i][j][0]+t[I]);
        Arrays.fill(dp[i][j],INF);
      }
    }
    System.out.println(Math.min(dp[1][half-1][0],dp[1][half-1][1]));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute INF : int := 100000001;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var half : int ; half := n / 2 ;
    var t : Sequence(int) ; t := Integer.subrange(1,n + 2)->collect(0) ;
    var dp : Sequence(Sequence(Sequence(int))) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,n + 2)->collect(Integer.subrange(1,2)->collect(0))) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     t[i+1] := (br.readLine())->toInteger() ; 
         var j : int ; j := 0 ; while j < 2 do ( (     dp[j+1][i+1] := dp[j+1][i+1]->collect(INF) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    dp[0+1][0+1][0+1] := 0 ; 
        var I : int ; I := 0 ; while I < n - 1 do ( (     var i : int ; i := I mod 2 ;
     var ni : int ; ni := (i + 1) mod 2 ;
         var j : int ; j := 0 ; while j <= half do ( (     dp[ni+1][j + 1+1][0+1] := Set{dp[i+1][j+1][0+1], dp[i+1][j+1][1+1] + t[I+1]}->min() ; 
     dp[ni+1][j+1][1+1] := Set{dp[i+1][j+1][1+1], dp[i+1][j+1][0+1] + t[I+1]}->min() ; 
     dp[i+1][j+1] := dp[i+1][j+1]->collect(INF) )  ;     j := j + 1 ) )  ;     I := I + 1 ) ; 
    OclFile["System.out"].println(Set{dp[1+1][half - 1+1][0+1], dp[1+1][half - 1+1][1+1]}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),INF=1<<29 ;
    int[] a=new int[n+2];
    for(int i=1 ; i<n ; i++)a[i]=sc.nextInt();
    int[][][] dp=new int[2][2][n/2+1];
    for(int i=0 ; i<2 ; i++)for(int j=0 ; j<2 ; j++)for(int k=0 ; k<=n/2 ; k++)dp[i][j][k]=INF ;
    dp[0][0][0]=0 ;
    int x=1 ;
    for(int i=1 ; i<=n ; i++,x=1-x)for(int j=0 ; j<2 ; j++){
      int t=Math.min(i,n>>1);
      for(int k=0 ; k<=t ; k++){
        dp[x][0][k]=Math.min(dp[1-x][0][k],dp[1-x][1][k]);
        if(0<k){
          dp[x][1][k]=dp[1-x][0][k-1]+a[i-1]+a[i];
          if(1<k)dp[x][1][k]=Math.min(dp[x][1][k],dp[1-x][1][k-1]-a[i-1]+a[i]);
        }
      }
    }
    System.out.println(Math.min(dp[1-x][0][n/2],dp[1-x][1][n/2]));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var INF : int ; INF := (1*(2->pow(29)))->oclAsType(long) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 2)->collect(0) ;
        var i : int ; i := 1 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(Sequence(int))) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,2)->collect(Integer.subrange(1,n / 2 + 1)->collect(0))) ;
        var i : int ; i := 0 ; while i < 2 do (         var j : int ; j := 0 ; while j < 2 do (         var k : int ; k := 0 ; while k <= n / 2 do (     dp[i+1][j+1][k+1] := INF ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    dp[0+1][0+1][0+1] := 0 ; 
    var x : int ; x := 1 ;
        var i : int ; i := 1 ; while i <= n do (         var j : int ; j := 0 ; while j < 2 do ( (     var t : int ; t := Set{i, (n/(2->pow(1)))->oclAsType(long)}->min() ;
         var k : int ; k := 0 ; while k <= t do ( (     dp[x+1][0+1][k+1] := Set{dp[1 - x+1][0+1][k+1], dp[1 - x+1][1+1][k+1]}->min() ; 
     if (0 < k) then (     dp[x+1][1+1][k+1] := dp[1 - x+1][0+1][k - 1+1] + a[i - 1+1] + a[i+1] ; 
     if (1 < k) then     dp[x+1][1+1][k+1] := Set{dp[x+1][1+1][k+1], dp[1 - x+1][1+1][k - 1+1] - a[i - 1+1] + a[i+1]}->min() ; else skip ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ;  ;     i := i + 1 ;     x := 1 - x ) ; 
    OclFile["System.out"].println(Set{dp[1 - x+1][0+1][n / 2+1], dp[1 - x+1][1+1][n / 2+1]}->min()) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),INF=1<<29 ;
    int[] a=new int[n+2];
    for(int i=1 ; i<n ; i++)a[i]=sc.nextInt();
    int[][][] dp=new int[2][2][n/2+1];
    for(int i=0 ; i<2 ; i++)for(int j=0 ; j<2 ; j++)for(int k=0 ; k<=n/2 ; k++)dp[i][j][k]=INF ;
    dp[0][0][0]=0 ;
    int x=1 ;
    for(int i=1 ; i<=n ; i++,x=1-x)for(int j=0 ; j<2 ; j++){
      int t=Math.min(i,n>>1);
      for(int k=0 ; k<=t ; k++){
        dp[x][0][k]=Math.min(dp[1-x][0][k],dp[1-x][1][k]);
        if(0<k)dp[x][1][k]=Math.min(dp[1-x][0][k-1]+a[i-1]+a[i],dp[1-x][1][k-1]-a[i-1]+a[i]);
      }
    }
    System.out.println(Math.min(dp[1-x][0][n/2],dp[1-x][1][n/2]));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var INF : int ; INF := (1*(2->pow(29)))->oclAsType(long) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 2)->collect(0) ;
        var i : int ; i := 1 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(Sequence(int))) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,2)->collect(Integer.subrange(1,n / 2 + 1)->collect(0))) ;
        var i : int ; i := 0 ; while i < 2 do (         var j : int ; j := 0 ; while j < 2 do (         var k : int ; k := 0 ; while k <= n / 2 do (     dp[i+1][j+1][k+1] := INF ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    dp[0+1][0+1][0+1] := 0 ; 
    var x : int ; x := 1 ;
        var i : int ; i := 1 ; while i <= n do (         var j : int ; j := 0 ; while j < 2 do ( (     var t : int ; t := Set{i, (n/(2->pow(1)))->oclAsType(long)}->min() ;
         var k : int ; k := 0 ; while k <= t do ( (     dp[x+1][0+1][k+1] := Set{dp[1 - x+1][0+1][k+1], dp[1 - x+1][1+1][k+1]}->min() ; 
     if (0 < k) then     dp[x+1][1+1][k+1] := Set{dp[1 - x+1][0+1][k - 1+1] + a[i - 1+1] + a[i+1], dp[1 - x+1][1+1][k - 1+1] - a[i - 1+1] + a[i+1]}->min() ; else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ;  ;     i := i + 1 ;     x := 1 - x ) ; 
    OclFile["System.out"].println(Set{dp[1 - x+1][0+1][n / 2+1], dp[1 - x+1][1+1][n / 2+1]}->min()) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class Main {
  static int n ;
  static int[] D ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int L=scanner.nextInt();
    initSegTree(N);
    int val ;
    for(int i=0 ; i<N ; i++){
      val=scanner.nextInt();
      update(i,val);
    }
    for(int i=0 ; i<=N-L ; i++){
      System.out.print(RMQ(i,i+L-1));
      if(i<N-L)System.out.print(" ");
    }
    System.out.println();
  }
  public static void initSegTree(int _n){
    n=1 ;
    while(n<_n){
      n*=2 ;
    }
    D=new int[2*n-1];
    Arrays.fill(D,Integer.MAX_VALUE);
  }
  public static void update(int i,int val){
    i=i+n-1 ;
    D[i]=val ;
    while(i>0){
      i=(i-1)/2 ;
      D[i]=Math.min(D[2*i+1],D[2*i+2]);
    }
  }
  public static int RMQ(int s,int t){
    return query(s,t+1,0,0,n);
  }
  private static int query(int s,int t,int k,int l,int r){
    if(l>=t || r<=s)return Integer.MAX_VALUE ;
    else if(l>=s && r<=t)return D[k];
    else {
      int left=query(s,t,2*k+1,l,(l+r)/2);
      int right=query(s,t,2*k+2,(l+r)/2,r);
      return Math.min(left,right);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute D : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var L : int ; L := scanner.getCurrent()->toInteger() ;
    execute initSegTree(N) ; 
    var val : int ;
        var i : int ; i := 0 ; while i < N do ( (     val := scanner.getCurrent()->toInteger() ; 
     execute update(i, val) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= N - L do ( (     OclFile["System.out"].print(RMQ(i, i + L - 1)) ; 
     if (i < N - L) then     OclFile["System.out"].print(" ") ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation initSegTree( _n : int) : void
  pre: true
  post: true
  activity: (     n := 1 ; 
     while (n < _n) do (     n := n*(2) ) ; 
     D := Integer.subrange(1,2 * n - 1)->collect(0) ; 
     D := D->collect(2147483647) );
  static   operation update( i : int, val : int) : void
  pre: true
  post: true
  activity: (     i := i + n - 1 ; 
     D[i+1] := val ; 
     while (i > 0) do (     i := (i - 1) / 2 ; 
     D[i+1] := Set{D[2 * i + 1+1], D[2 * i + 2+1]}->min() ) );
  static   operation RMQ( s : int, t : int) : int
  pre: true
  post: true
  activity: (     return query(s, t + 1, 0, 0, n) );
  static   operation query( s : int, t : int, k : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     if (l >= t or r <= s) then     return 2147483647 else     if (l >= s & r <= t) then     return D[k+1] else (     var left : int ; left := query(s, t, 2 * k + 1, l, (l + r) / 2) ;
     var right : int ; right := query(s, t, 2 * k + 2, (l + r) / 2, r) ;
     return Set{left, right}->min() ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int length=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    int left=-1 ;
    int right=left+length-1 ;
    int min=0 ;
    int minIdx=-1 ;
    StringBuilder sb=new StringBuilder();
    while(true){
      left++;
      right++;
      if(right>=n){
        break ;
      }
      if(minIdx<left){
        min=Integer.MAX_VALUE ;
        for(int i=left ; i<=right ; i++){
          if(min>=arr[i]){
            min=arr[i];
            minIdx=i ;
          }
        }
      }
      else {
        if(arr[right]<=min){
          min=arr[right];
          minIdx=right ;
        }
      }
      if(left>0){
        sb.append(" ");
      }
      sb.append(min);
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var length : int ; length := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var left : int ; left := -1 ;
    var right : int ; right := left + length - 1 ;
    var min : int ; min := 0 ;
    var minIdx : int ; minIdx := -1 ;
    var sb : String ; sb := StringLib.newString() ;
    while (true) do (     left := left + 1 ; 
     right := right + 1 ; 
    if (right >= n) then (     break ) else skip ; 
    if (minIdx < left) then (     min := 2147483647 ; 
         var i : int ; i := left ; while i <= right do ( (     if (min >= arr[i+1]) then (     min := arr[i+1] ; 
     minIdx := i ) else skip )  ;     i := i + 1 ) ) else (     if (arr[right+1] <= min) then (     min := arr[right+1] ; 
     minIdx := right ) else skip ) ;  
    if (left > 0) then (     sb := sb + StringLib.newString(" ") ) else skip ; 
    sb := sb + StringLib.newString(min) ; 
 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int L=scan.nextInt();
    int[] a=new int[N];
    TreeMap<Integer,Integer>map=new TreeMap<Integer,Integer>();
    for(int i=0 ; i<N ; i++){
      a[i]=scan.nextInt();
    }
    scan.close();
    for(int i=0 ; i<L ; i++){
      map.merge(a[i],1,(val1,val2)->val1+val2);
    }
    int min=map.firstKey();
    StringBuilder sb=new StringBuilder();
    sb.append(min);
    for(int i=L ; i<N ; i++){
      if(map.get(a[i-L])==1){
        map.remove(a[i-L]);
      }
      else {
        map.merge(a[i-L],-1,(val1,val2)->val1+val2);
      }
      map.merge(a[i],1,(val1,val2)->val1+val2);
      sb.append(" ").append(map.firstKey());
    }
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var L : int ; L := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < L do ( (     map := map.merge(a[i+1], 1, lambda (val1 , val2) : OclAny in val1 + val2) )  ;     i := i + 1 ) ; 
    var min : int ; min := map->keys()->min() ;
    var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString(min) ; 
        var i : int ; i := L ; while i < N do ( (     if (map->at(a[(i)->char2byte() - L+1]) = 1) then (     map := map->antirestrict(Set{a[(i)->char2byte() - L+1]}) ) else (     map := map.merge(a[(i)->char2byte() - L+1], -1, lambda (val1 , val2) : OclAny in val1 + val2) ) ;  
     map := map.merge(a[i+1], 1, lambda (val1 , val2) : OclAny in val1 + val2) ; 
     sb := sb + StringLib.newString(" ") + StringLib.newString(map->keys()->min()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test164 {
  public static void main(String s[]){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int x=in.nextInt();
      int y=in.nextInt();
      int z=in.nextInt();
      if(x==y){
        if(x>=z){
          System.out.println("YES");
          System.out.println(x+" "+z+" "+z);
        }
        else {
          System.out.println("NO");
        }
      }
      else if(x==z){
        if(x>=y){
          System.out.println("YES");
          System.out.println(x+" "+y+" "+y);
        }
        else {
          System.out.println("NO");
        }
      }
      else if(y==z){
        if(z>=x){
          System.out.println("YES");
          System.out.println(y+" "+x+" "+x);
        }
        else {
          System.out.println("NO");
        }
      }
      else {
        System.out.println("NO");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test164 {
  static   operation main( s : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var y : int ; y := in.getCurrent()->toInteger() ;
     var z : int ; z := in.getCurrent()->toInteger() ;
     if (x = y) then (     if (x >= z) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(x + " " + z + " " + z) ) else (     OclFile["System.out"].println("NO") ) ) else     if (x = z) then (     if (x >= y) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(x + " " + y + " " + y) ) else (     OclFile["System.out"].println("NO") ) ) else     if (y = z) then (     if (z >= x) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(y + " " + x + " " + x) ) else (     OclFile["System.out"].println("NO") ) ) else (     OclFile["System.out"].println("NO") ) ;  ;  )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    int A_pensils=0 ;
    int B_pensils=0 ;
    int A_price=0 ;
    int B_price=0 ;
    while(A_pensils<n){
      A_pensils+=a ;
      A_price+=b ;
    }
    while(B_pensils<n){
      B_pensils+=c ;
      B_price+=d ;
    }
    if(A_price<=B_price){
      System.out.println(A_price);
    }
    else {
      System.out.println(B_price);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var A_pensils : int ; A_pensils := 0 ;
    var B_pensils : int ; B_pensils := 0 ;
    var A_price : int ; A_price := 0 ;
    var B_price : int ; B_price := 0 ;
    while (A_pensils < n) do (     A_pensils := A_pensils+(a) ; 
     A_price := A_price+(b) ) ; 
    while (B_pensils < n) do (     B_pensils := B_pensils+(c) ; 
     B_price := B_price+(d) ) ; 
    if (A_price <= B_price) then (     OclFile["System.out"].println(A_price) ) else (     OclFile["System.out"].println(B_price) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class template {
  public static void main(String[] args)throws IOException {
    FastReader fr=new FastReader();
    int t=fr.nextInt();
    while(t-->0){
      int a[]=fr.nextIntArray();
      Arrays.sort(a);
      if(a[1]!=a[2])System.out.println("NO");
      else {
        System.out.println("YES");
        System.out.println(a[0]+" "+a[0]+" "+a[2]);
      }
    }
    fr.close();
  }
  static void printArr(int[] arr){
    for(int i : arr){
      System.out.print(i+" ");
    }
    System.out.println();
  }
  static void printArr(String[] arr){
    for(String s : arr){
      System.out.print(s+" ");
    }
    System.out.println();
  }
}
class FastReader {
  BufferedReader br ;
  public FastReader(){
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  int nextInt()throws IOException {
    return(int)nextLong();
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(br.readLine());
  }
  float nextFloat()throws IOException {
    return(float)nextDouble();
  }
  long nextLong()throws IOException {
    return Long.parseLong(br.readLine());
  }
  String nextLine()throws IOException {
    return br.readLine();
  }
  int[] nextIntArray()throws IOException {
    String s[]=br.readLine().split(" ");
    int arr[]=new int[s.length];
    for(int i=0 ; i<s.length ; i++){
      arr[i]=Integer.parseInt(s[i]);
    }
    return arr ;
  }
  void close()throws IOException {
    br.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class template {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fr : FastReader ; fr := FastReader.newFastReader() ;
     var t : int ; t := fr.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : Sequence(int) ; a := fr.nextIntArray() ;
     a := a->sort() ; 
     if (a[1+1] /= a[2+1]) then     OclFile["System.out"].println("NO") ; else (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(a[0+1] + " " + a[0+1] + " " + a[2+1]) ) ) ;  ) ;  
     fr.close() );
  static   operation printArr( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     for (i : arr) do ( (     OclFile["System.out"].print(i + " ") )  ) ; 
     OclFile["System.out"].println() );
  static   operation printArr( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     for (s : arr) do ( (     OclFile["System.out"].print(s + " ") )  ) ; 
     OclFile["System.out"].println() );
}
class FastReader {
   attribute br : OclFile;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return nextLong()->oclAsType(int) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (br.readLine())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return nextDouble()->oclAsType(double) );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (br.readLine())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextIntArray() : Sequence(int)
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,s->size())->collect(0) ;
         var i : int ; i := 0 ; while i < s->size() do ( (     arr[i+1] := (s[i+1])->toInteger() )  ;     i := i + 1 ) ; 
     return arr );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    InputReader in=new InputReader(inputStream);
    int T=in.nextInt();
    while(T-->0){
      int[] arr=new int[3];
      for(int i=0 ; i<arr.length ; i++){
        arr[i]=in.nextInt();
      }
      Arrays.sort(arr);
      if(arr[1]==arr[2]){
        System.out.println("YES");
        System.out.println(arr[0]+" "+arr[0]+" "+arr[2]);
      }
      else {
        System.out.println("NO");
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
     var T : int ; T := in.nextInt() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     var arr : Sequence(int) ; arr := Integer.subrange(1,3)->collect(0) ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
     arr := arr->sort() ; 
     if (arr[1+1] = arr[2+1]) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(arr[0+1] + " " + arr[0+1] + " " + arr[2+1]) ) else (     OclFile["System.out"].println("NO") ) ) ;  ) );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class EdC {
  public static void main(String[] args)throws Exception {
    int num=998244353 ;
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    int t=Integer.parseInt(bf.readLine());
    for(int i=0 ; i<t ; i++){
      int n=Integer.parseInt(bf.readLine());
      String a=bf.readLine().trim();
      String b=bf.readLine().trim();
      PriorityQueue<String>temp=new PriorityQueue<String>();
      Set<String>used=new HashSet<String>();
      boolean ans=true ;
      for(int j=0 ; j<n ; j++){
        if(a.charAt(j)>b.charAt(j))ans=false ;
        else if(a.charAt(j)<b.charAt(j)){
          String add=a.charAt(j)+""+b.charAt(j)+"" ;
          if(! used.contains(add)){
            temp.add(add);
            used.add(add);
          }
        }
      }
      int count=0 ;
      while(! temp.isEmpty()){
        String j=temp.remove();
        while(! temp.isEmpty()&& temp.peek().charAt(0)==j.charAt(0)){
          String add=temp.remove();
          String adds=j.charAt(1)+""+add.charAt(1)+"" ;
          if(! used.contains(adds)){
            used.add(adds);
            temp.add(adds);
          }
        }
        count++;
      }
      if(ans)out.println(count);
      else out.println(-1);
    }
    out.println();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class EdC {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 998244353 ;
     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (bf.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := (bf.readLine())->toInteger() ;
     var a : String ; a := bf.readLine()->trim() ;
    var b : String ; b := bf.readLine()->trim() ;
    var temp : Sequence(String) ; temp := Sequence{} ;
    var used : Set(String) ; used := Set{} ;
    var ans : boolean ; ans := true ;
        var j : int ; j := 0 ; while j < n do ( (     if (a->at(j+1) > b->at(j+1)) then     ans := false ; else     if (a->at(j+1) < b->at(j+1)) then (     var add : String ; add := a->at(j+1) + "" + b->at(j+1) + "" ;
     if (not(used->includes(add))) then (     temp := temp->including(add) ; 
     used := used->including(add) ) else skip ) else skip ; )  ;     j := j + 1 ) ; 
    var count : int ; count := 0 ;
    while (not(temp->isEmpty())) do (     var j : String ; j := temp.remove() ;
     while (not(temp->isEmpty()) & temp->min()->at(0+1) = j->at(0+1)) do (     var add : String ; add := temp.remove() ;
     var adds : String ; adds := j->at(1+1) + "" + add->at(1+1) + "" ;
     if (not(used->includes(adds))) then (     used := used->including(adds) ; 
     temp := temp->including(adds) ) else skip ) ; 
     count := count + 1 ) ; 
    if (ans) then     skip else     skip ; ;  
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int t=1 ; t<=test ; t++){
      int n=in.nextInt();
      ArrayList<Integer>list=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        list.add(in.nextInt());
      }
      Collections.sort(list);
      int c=0 ;
      int res=0 ;
      for(int i=0 ; i<n ; i++){
        c++;
        if(c==list.get(i)){
          res++;
          c=0 ;
        }
      }
      pw.println(res);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= test do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var c : int ; c := 0 ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     c := c + 1 ; 
     if (c = list->at(i+1)) then (     res := res + 1 ; 
     c := 0 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.nio.Buffer ;
import java.util.*;
public class Main2 {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int testCases=sc.nextInt();
    while(testCases-->0){
      int length=sc.nextInt();
      Integer[] array=new Integer[length];
      for(int i=0 ; i<length ; i++){
        array[i]=sc.nextInt();
      }
      Arrays.sort(array);
      int notUsed=0 ;
      long ans=0 ;
      for(int i=0 ; i<length ; i++){
        int number=array[i];
        int count=0 ;
        while(i<length && number==array[i]){
          i++;
          count++;
        }
        i--;
        int total=count+notUsed ;
        ans+=total/number ;
        notUsed=total % number ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := sc.getCurrent()->toInteger() ;
         while (testCases > 0) do (        testCases := testCases - 1 ;     skip ; (     var length : int ; length := sc.getCurrent()->toInteger() ;
     var array : Sequence(int) ; array := Integer.subrange(1,length)->collect(null) ;
        var i : int ; i := 0 ; while i < length do ( (     array[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    array := array->sort() ; 
    var notUsed : int ; notUsed := 0 ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < length do ( (     var number : int ; number := array[i+1] ;
     var count : int ; count := 0 ;
    while (i < length & number = array[i+1]) do (     i := i + 1 ; 
     count := count + 1 ) ; 
    i := i - 1 ; 
    var total : int ; total := count + notUsed ;
    ans := ans+(total / number) ; 
    notUsed := total mod number ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import static java.lang.Math.max ;
import static java.lang.Math.min ;
import static java.lang.System.out ;
public class pre131 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int tc=obj.nextInt();
    while(tc--!=0){
      int n=obj.nextInt(),arr[]=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=obj.nextInt();
      int ans=0 ;
      Arrays.sort(arr);
      boolean flag[]=new boolean[n];
      for(int i=0 ; i<arr.length ; i++){
        if(! flag[i]){
          int e=0,l=0 ;
          for(int j=i ; j<arr.length ; j++){
            e=Math.max(e,arr[j]);
            l++;
            if(e<=l){
              for(int k=i ; k<=j ; k++){
                flag[k]=true ;
              }
              ans++;
              break ;
            }
          }
        }
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre131 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var tc : int ; tc := obj.nextInt() ;
         while (tc /= 0) do (    skip ; (     var n : int ; n := obj.nextInt() ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     arr[i+1] := obj.nextInt() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    arr := arr->sort() ; 
    var flag : Sequence(boolean) ; flag := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (not(flag[i+1])) then (     var e : int ; e := 0 ;
    var l : int ; l := 0 ;
         var j : int ; j := i ; while j < arr->size() do ( (     e := Set{e, arr[j+1]}->max() ; 
     l := l + 1 ; 
     if (e <= l) then (         var k : int ; k := i ; while k <= j do ( (     flag[k+1] := true )  ;     k := k + 1 ) ; 
     ans := ans + 1 ; 
     break ) else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int numberOfDivisors(int num){
    int c=0 ;
    for(int i=1 ; i<=num ; i++){
      if(num % i==0){
        c+=1 ;
      }
    }
    return c ;
  }
  static int countNumbers(int n){
    int c=0 ;
    for(int i=1 ; i<=n ; i++){
      if(numberOfDivisors(i)==9)c+=1 ;
    }
    return c ;
  }
  public static void main(String[] args){
    int n=1000 ;
    System.out.print(countNumbers(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation numberOfDivisors( num : int) : int
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
         var i : int ; i := 1 ; while i <= num do ( (     if (num mod i = 0) then (     c := c+(1) ) else skip )  ;     i := i + 1 ) ; 
     return c );
  static   operation countNumbers( n : int) : int
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     if (numberOfDivisors(i) = 9) then     c := c+(1) ; else skip )  ;     i := i + 1 ) ; 
     return c );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1000 ;
     OclFile["System.out"].print(countNumbers(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String longestRepeatedSubSeq(String str){
    int n=str.length();
    int[][] dp=new int[n+1][n+1];
    for(int i=0 ; i<=n ; i++)for(int j=0 ; j<=n ; j++)dp[i][j]=0 ;
    for(int i=1 ; i<=n ; i++)for(int j=1 ; j<=n ; j++)if(str.charAt(i-1)==str.charAt(j-1)&& i!=j)dp[i][j]=1+dp[i-1][j-1];
    else dp[i][j]=Math.max(dp[i][j-1],dp[i-1][j]);
    String res="" ;
    int i=n,j=n ;
    while(i>0 && j>0){
      if(dp[i][j]==dp[i-1][j-1]+1){
        res=res+str.charAt(i-1);
        i--;
        j--;
      }
      else if(dp[i][j]==dp[i-1][j])i--;
      else j--;
    }
    String reverse="" ;
    for(int k=res.length()-1 ; k>=0 ; k--){
      reverse=reverse+res.charAt(k);
    }
    return reverse ;
  }
  public static void main(String args[]){
    String str="AABEBCDD" ;
    System.out.println(longestRepeatedSubSeq(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation longestRepeatedSubSeq( str : String) : String
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i <= n do (         var j : int ; j := 0 ; while j <= n do (     dp[i+1][j+1] := 0 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (         var j : int ; j := 1 ; while j <= n do (     if (str->at(i - 1+1) = str->at(j - 1+1) & i /= j) then     dp[i+1][j+1] := 1 + dp[i - 1+1][j - 1+1] else     dp[i+1][j+1] := Set{dp[i+1][j - 1+1], dp[i - 1+1][j+1]}->max() ; ;   ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var res : String ; res := "" ;
    var i : int ; i := n ;
    var j : int ; j := n ;
    while (i > 0 & j > 0) do (     if (dp[i+1][j+1] = dp[(i)->char2byte() - 1+1][(j)->char2byte() - 1+1] + 1) then (     res := res + str->at((i)->char2byte() - 1+1) ; 
     i := i - 1 ; 
     j := j - 1 ) else     if (dp[i+1][j+1] = dp[(i)->char2byte() - 1+1][j+1]) then     i := i - 1 else     j := j - 1 ; ;  ) ; 
    var reverse : String ; reverse := "" ;
        var k : int ; k := res->size() - 1 ; while k >= 0 do ( (     reverse := reverse + res->at(k+1) )  ;     k := k - 1 ) ; 
    return reverse 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "AABEBCDD" ;
     OclFile["System.out"].println(longestRepeatedSubSeq(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean oneDigit(int num){
    return(num>=0 && num<10);
  }
  static boolean isPalUtil(int num,int dupNum){
    if(oneDigit(num))return(num==(dupNum)% 10);
    if(! isPalUtil(num/10,dupNum))return false ;
    dupNum/=10 ;
    return(num % 10==(dupNum)% 10);
  }
  static boolean isPal(int num){
    if(num<0)num=-num ;
    int dupNum=num ;
    return isPalUtil(num,dupNum);
  }
  static void printPalPrimesLessThanN(int n){
    boolean prime[]=new boolean[n+1];
    Arrays.fill(prime,true);
    for(int p=2 ; p*p<=n ; p++){
      if(prime[p]){
        for(int i=p*2 ; i<=n ; i+=p){
          prime[i]=false ;
        }
      }
    }
    for(int p=2 ; p<=n ; p++){
      if(prime[p] && isPal(p)){
        System.out.print(p+" ");
      }
    }
  }
  public static void main(String[] args){
    int n=100 ;
    System.out.printf("Palindromic primes smaller than or "+"equal to %d are :\n",n);
    printPalPrimesLessThanN(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation oneDigit( num : int) : boolean
  pre: true
  post: true
  activity: (     return (num >= 0 & num < 10) );
  static   operation isPalUtil( num : int, dupNum : int) : boolean
  pre: true
  post: true
  activity: (     if (oneDigit(num)) then     return (num = (dupNum) mod 10) else skip ; 
     if (not(isPalUtil(num / 10, dupNum))) then     return false else skip ; 
     dupNum := dupNum/(10) ; 
     return (num mod 10 = (dupNum) mod 10) );
  static   operation isPal( num : int) : boolean
  pre: true
  post: true
  activity: (     if (num < 0) then     num := -num ; else skip ; 
     var dupNum : int ; dupNum := num ;
     return isPalUtil(num, dupNum) );
  static   operation printPalPrimesLessThanN( n : int) : void
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,n + 1)->collect(false) ;
     prime := prime->collect(true) ; 
         var p : int ; p := 2 ; while p * p <= n do ( (     if (prime[p+1]) then (         var i : int ; i := p * 2 ; while i <= n do ( (     prime[i+1] := false )  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
         var p : int ; p := 2 ; while p <= n do ( (     if (prime[p+1] & isPal(p)) then (     OclFile["System.out"].print(p + " ") ) else skip )  ;     p := p + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 100 ;
     OclFile["System.out"].printf("Palindromic primes smaller than or " + "equal to %d are :\n", n) ; 
     execute printPalPrimesLessThanN(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int numTestCases=scanner.nextInt();
    for(int i=0 ; i<numTestCases ; i++){
      int n=scanner.nextInt();
      int[] a=new int[n];
      for(int j=0 ; j<n ; j++){
        a[j]=scanner.nextInt();
      }
      System.out.println(solve(a));
    }
  }
  public static String solve(int[] piles){
    int first=1,second=2,turn=1 ;
    for(int i=0 ; i<piles.length ; i++){
      if(piles[i]==1){
        if(turn==first)turn=second ;
        else turn=first ;
      }
      else {
        if(turn==first)return "First" ;
        else return "Second" ;
      }
    }
    if(piles.length % 2==0)return "Second" ;
    else return "First" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numTestCases : int ; numTestCases := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < numTestCases do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var j : int ; j := 0 ; while j < n do ( (     a[j+1] := scanner.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(solve(a)) )  ;     i := i + 1 ) );
  static   operation solve( piles : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var first : int ; first := 1 ;
    var second : int ; second := 2 ;
    var turn : int ; turn := 1 ;
         var i : int ; i := 0 ; while i < piles->size() do ( (     if (piles[i+1] = 1) then (     if (turn = first) then     turn := second ; else     turn := first ; ) else (     if (turn = first) then     return "First" else     return "Second" ) )  ;     i := i + 1 ) ; 
     if (piles->size() mod 2 = 0) then     return "Second" else     return "First" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double n=sc.nextInt();
    double a=sc.nextInt();
    int b=sc.nextInt();
    double c=sc.nextInt();
    int d=sc.nextInt();
    int x=(int)Math.ceil(n/a);
    int y=(int)Math.ceil(n/c);
    System.out.println(Math.min(x*b,y*d));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : double ; n := sc.getCurrent()->toInteger() ;
    var a : double ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : double ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var x : int ; x := (n / a)->ceil()->oclAsType(int) ;
    var y : int ; y := (n / c)->ceil()->oclAsType(int) ;
    OclFile["System.out"].println(Set{x * b, y * d}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Round658B {
  public static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int t=Integer.parseInt(br.readLine());
    while(t-->0){
      int n=Integer.parseInt(br.readLine());
      int[] piles=Arrays.stream(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
      int count=0 ;
      for(int i=0 ; i<piles.length ; i++){
        if(piles[i]==1){
          count++;
        }
        else {
          break ;
        }
      }
      if(count % 2==0 && count!=n){
        pw.println("First");
      }
      else if(count % 2==1 && count==n){
        pw.println("First");
      }
      else {
        pw.println("Second");
      }
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Round658B {
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (br.readLine())->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
     var piles : Sequence(int) ; piles := stream(br.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < piles->size() do ( (     if (piles[i+1] = 1) then (     count := count + 1 ) else (     break ) )  ;     i := i + 1 ) ; 
    if (count mod 2 = 0 & count /= n) then (     skip ) else     if (count mod 2 = 1 & count = n) then (     skip ) else (     skip ) ;  ;  
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem_1382B {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    int n ;
    for(int i=0 ; i<t ; i++){
      n=scanner.nextInt();
      int[] a=new int[n];
      for(int j=0 ; j<n ; j++){
        a[j]=scanner.nextInt();
      }
      int k=0 ;
      for(int j=0 ; j<n ; j++){
        if(a[j]!=1){
          break ;
        }
        else {
          k++;
        }
      }
      if(k==n){
        if(k % 2==0){
          System.out.println("Second");
        }
        else {
          System.out.println("First");
        }
      }
      else {
        if(k % 2==0){
          System.out.println("First");
        }
        else {
          System.out.println("Second");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem_1382B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
     var n : int ;
         var i : int ; i := 0 ; while i < t do ( (     n := scanner.getCurrent()->toInteger() ; 
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     a[j+1] := scanner.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    var k : int ; k := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     if (a[j+1] /= 1) then (     break ) else (     k := k + 1 ) )  ;     j := j + 1 ) ; 
    if (k = n) then (     if (k mod 2 = 0) then (     OclFile["System.out"].println("Second") ) else (     OclFile["System.out"].println("First") ) ) else (     if (k mod 2 = 0) then (     OclFile["System.out"].println("First") ) else (     OclFile["System.out"].println("Second") ) ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1382 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      int n=scanner.nextInt();
      int firstIndexNon1=n+1 ;
      for(int i=0 ; i<n ; i++){
        if(scanner.nextInt()!=1){
          firstIndexNon1=Math.min(firstIndexNon1,i);
        }
      }
      System.out.println((firstIndexNon1 % 2==0)? "First" : "Second");
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1382 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var firstIndexNon1 : int ; firstIndexNon1 := n + 1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (scanner.getCurrent()->toInteger() /= 1) then (     firstIndexNon1 := Set{firstIndexNon1, i}->min() ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if (firstIndexNon1 mod 2 = 0) then "First" else "Second" endif) ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findSubsequence(int arr[],int n){
    int sign[]=new int[n];
    for(int i=0 ; i<n ; i++){
      if(arr[i]>0)sign[i]=1 ;
      else sign[i]=-1 ;
    }
    int k=0 ;
    int result[]=new int[n];
    for(int i=0 ; i<n ; i++){
      int cur=arr[i];
      int j=i ;
      while(j<n && sign[i]==sign[j]){
        cur=Math.max(cur,arr[j]);
++j ;
      }
      result[k++]=cur ;
      i=j-1 ;
    }
    for(int i=0 ; i<k ; i++)System.out.print(result[i]+" ");
    System.out.print("\n");
  }
  public static void main(String[] args){
    int arr[]={
-4,9,4,11,-5,-17,9,-3,-5,2 };
      int n=arr.length ;
      findSubsequence(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findSubsequence( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var sign : Sequence(int) ; sign := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] > 0) then     sign[i+1] := 1 ; else     sign[i+1] := -1 ; )  ;     i := i + 1 ) ; 
    var k : int ; k := 0 ;
    var result : Sequence(int) ; result := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var cur : int ; cur := arr[i+1] ;
     var j : int ; j := i ;
    while (j < n & sign[i+1] = sign[j+1]) do (     cur := Set{cur, arr[j+1]}->max() ; 
     j := j + 1 ) ; 
     result[k+1] := cur  ; k := k + 1 ; 
    i := j - 1 ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do (     OclFile["System.out"].print(result[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("\n") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-4,9,4,11,-5,-17,9,-3,-5,2} ;
     var n : int ; n := arr->size() ;
     execute findSubsequence(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String str ;
      while((str=br.readLine())!=null){
        String[] num=str.split(" ");
        int guest=Integer.parseInt(num[0]);
        int match=Integer.parseInt(num[1]);
        int[] startTime=new int[guest];
        int[] endTime=new int[guest];
        int[] gapTime=new int[guest-1];
        for(int i=0 ; i<guest ; i++){
          startTime[i]=Integer.parseInt(br.readLine());
          endTime[i]=startTime[i]+1 ;
          if(i==0)continue ;
          gapTime[i-1]=startTime[i]-endTime[i-1];
        }
        Arrays.sort(gapTime);
        int tmp=guest-match ;
        int totalTime=guest ;
        for(int i=0 ; i<tmp ; i++){
          totalTime+=gapTime[i];
        }
        System.out.println(totalTime);
      }
    }
    catch(Exception e){
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ;
         str := br.readLine() ;
    while ((str) /= null) do (    skip ; (     var num : Sequence(String) ; num := str->split(" ") ;
     var guest : int ; guest := (num[0+1])->toInteger() ;
    var match : int ; match := (num[1+1])->toInteger() ;
    var startTime : Sequence(int) ; startTime := Integer.subrange(1,guest)->collect(0) ;
    var endTime : Sequence(int) ; endTime := Integer.subrange(1,guest)->collect(0) ;
    var gapTime : Sequence(int) ; gapTime := Integer.subrange(1,guest - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < guest do ( (     startTime[i+1] := (br.readLine())->toInteger() ; 
     endTime[i+1] := startTime[i+1] + 1 ; 
     if (i = 0) then     continue else skip ; 
     gapTime[i - 1+1] := startTime[i+1] - endTime[i - 1+1] )  ;     i := i + 1 ) ; 
    gapTime := gapTime->sort() ; 
    var tmp : int ; tmp := guest - match ;
    var totalTime : int ; totalTime := guest ;
        var i : int ; i := 0 ; while i < tmp do ( (     totalTime := totalTime+(gapTime[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(totalTime) ; 
 ) ;     str := br.readLine() ;
 ) )   catch (e : ProgramException) do (     OclFile["System.out"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    line=br.readLine();
    int N,K ;
    N=parseInt(line.substring(0,line.indexOf(' ')));
    K=parseInt(line.substring(line.indexOf(' ')+1));
    int[] T=new int[N];
    int[] interval=new int[N-1];
    for(int i=0 ; i<N ; i++){
      T[i]=parseInt(br.readLine());
      if(i>0){
        interval[i-1]=T[i]-T[i-1]-1 ;
      }
    }
    int ans=T[N-1]-T[0]+1 ;
    Arrays.sort(interval);
    for(int i=0,j=N-2 ; i<K-1 ; i++,j--){
      ans-=interval[j];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    line := br.readLine() ; 
    var N : int ;
    var K : int ;
    N := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    K := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var T : Sequence(int) ; T := Integer.subrange(1,N)->collect(0) ;
    var interval : Sequence(int) ; interval := Integer.subrange(1,N - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     T[i+1] := (br.readLine() + "")->toInteger() ; 
     if (i > 0) then (     interval[i - 1+1] := T[i+1] - T[i - 1+1] - 1 ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := T[N - 1+1] - T[0+1] + 1 ;
    interval := interval->sort() ; 
        var i : int ; i := 0 ;
    var j : int ; j := N - 2 ; while i < K - 1 do ( (     ans := ans-(interval[j+1]) )  ;     i := i + 1 ;     j := j - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int prev=sc.nextInt();
    PriorityQueue<Integer>queue=new PriorityQueue<>();
    for(int i=1 ; i<n ; i++){
      int x=sc.nextInt();
      queue.add(x-prev-1);
      prev=x ;
    }
    int sum=n ;
    for(int i=0 ; i<n-k ; i++){
      sum+=queue.poll();
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var prev : int ; prev := sc.getCurrent()->toInteger() ;
    var queue : Sequence(int) ; queue := Sequence{} ;
        var i : int ; i := 1 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     queue := queue->including(x - prev - 1) ; 
     prev := x )  ;     i := i + 1 ) ; 
    var sum : int ; sum := n ;
        var i : int ; i := 0 ; while i < n - k do ( (     sum := sum + queue->min() ;     queue := queue->sort()->tail() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    long[] times=new long[n];
    for(int i=0 ; i<n ; i++){
      times[i]=sc.nextLong();
    }
    ArrayList<Long>arrayList=new ArrayList<>();
    for(int i=0 ; i<n-1 ; i++){
      long l=times[i+1]-(times[i]+1);
      if(l>0)arrayList.add(l);
    }
    arrayList.sort(Comparator.reverseOrder());
    long sum=arrayList.stream().limit(k-1).mapToLong(Long :: longValue).sum();
    System.out.println(times[n-1]-times[0]+1-sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var times : Sequence(long) ; times := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     times[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var arrayList : Sequence(long) ; arrayList := Sequence{} ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var l : long ; l := times[i + 1+1] - (times[i+1] + 1) ;
     if (l > 0) then     arrayList := arrayList->including(l) ; else skip )  ;     i := i + 1 ) ; 
    arrayList := arrayList.sort(Comparator.reverseOrder()) ; 
    var sum : long ; sum := arrayList.subrange(1,k - 1)->collect( _x1 | (lambda _pars : OclAny in Long.newLong().longValue(_pars))->apply(_x1) )->sum() ;
    OclFile["System.out"].println(times[n - 1+1] - times[0+1] + 1 - sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maxProduct(int a[],int n){
    int[] product=new int[n];
    int maxA[]=new int[n];
    int maxProd=0 ;
    int maxArr=0 ;
    for(int i=0 ; i<n ; i++){
      product[i]=a[(i+1)% n]*a[(i+(n-1))% n];
      if(maxProd<product[i]){
        maxProd=product[i];
      }
    }
    return maxProd ;
  }
  public static void main(String[] args){
    int[] a={
      5,6,4,3,2 };
      int n=a.length ;
      System.out.println(maxProduct(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxProduct( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var product : Sequence(int) ; product := Integer.subrange(1,n)->collect(0) ;
     var maxA : Sequence(int) ; maxA := Integer.subrange(1,n)->collect(0) ;
    var maxProd : int ; maxProd := 0 ;
    var maxArr : int ; maxArr := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     product[i+1] := a[(i + 1) mod n+1] * a[(i + (n - 1)) mod n+1] ; 
     if (maxProd < product[i+1]) then (     maxProd := product[i+1] ) else skip )  ;     i := i + 1 ) ; 
    return maxProd 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{5,6,4,3,2} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(maxProduct(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long partitions(int n){
    long p[]=new long[n+1];
    p[0]=1 ;
    for(int i=1 ; i<=n ; ++i){
      int k=1 ;
      while((k*(3*k-1))/2<=i){
        p[i]+=(k % 2!=0 ? 1 :-1)*p[i-(k*(3*k-1))/2];
        if(k>0){
          k*=-1 ;
        }
        else {
          k=1-k ;
        }
      }
    }
    return p[n];
  }
  public static void main(String[] args){
    int N=20 ;
    System.out.println(partitions(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation partitions( n : int) : long
  pre: true
  post: true
  activity: (     var p : Sequence(long) ; p := Integer.subrange(1,n + 1)->collect(0) ;
     p[0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= n do ( (     var k : int ; k := 1 ;
     while ((k * (3 * k - 1)) / 2 <= i) do (     p[i+1] := p[i+1]+((if k mod 2 /= 0 then 1 else -1 endif) * p[i - (k * (3 * k - 1)) / 2+1]) ; 
     if (k > 0) then (     k := k*(-1) ) else (     k := 1 - k ) ) )  ;     i := i + 1 ) ; 
     return p[n+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 20 ;
     OclFile["System.out"].println(partitions(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner scan=new Scanner(System.in);
    while(true){
      int m=scan.nextInt();
      int n_min=scan.nextInt();
      int n_max=scan.nextInt();
      if(m+n_min+n_max==0)break ;
      int[] p=new int[m];
      for(int i=0 ; i<m ; i++){
        p[i]=scan.nextInt();
      }
      int n=0 ;
      int ans=0 ;
      for(int i=0 ; i<m ; i++){
        if(i>=n_min-1 && i<n_max){
          if(n<=p[i]-p[i+1]){
            n=p[i]-p[i+1];
            ans=i+1 ;
          }
        }
      }
      System.out.println(ans);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var m : int ; m := scan.getCurrent()->toInteger() ;
     var n_min : int ; n_min := scan.getCurrent()->toInteger() ;
    var n_max : int ; n_max := scan.getCurrent()->toInteger() ;
    if (m + n_min + n_max = 0) then     break else skip ; 
    var p : Sequence(int) ; p := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     p[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var n : int ; n := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     if (i >= n_min - 1 & i < n_max) then (     if (n <= p[i+1] - p[i + 1+1]) then (     n := p[i+1] - p[i + 1+1] ; 
     ans := i + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int getPrime(int arr[],int n){
    int max_val=Arrays.stream(arr).max().getAsInt();
    Vector<Boolean>prime=new Vector<>(max_val+1);
    for(int i=0 ; i<max_val+1 ; i++)prime.add(i,Boolean.TRUE);
    prime.add(1,Boolean.FALSE);
    prime.add(2,Boolean.FALSE);
    for(int p=2 ; p*p<=max_val ; p++){
      if(prime.get(p)==true){
        for(int i=p*2 ; i<=max_val ; i+=p)prime.add(i,Boolean.FALSE);
      }
    }
    int maximum=-1 ;
    for(int i=0 ; i<n ; i++){
      if(prime.get(arr[i])){
        maximum=Math.max(maximum,arr[i]);
      }
    }
    return maximum ;
  }
  public static void main(String[] args){
    int arr[]={
      2,10,15,7,6,8,13 };
      int n=arr.length ;
      System.out.println(getPrime(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getPrime( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max_val : int ; max_val := stream(arr).max().getAsInt() ;
     var prime : Sequence(Boolean) ; prime := Sequence{}->union(max_val + 1) ;
        var i : int ; i := 0 ; while i < max_val + 1 do (     prime := prime.insertAt(i+1,true) ;  ;     i := i + 1 ) ; 
    prime := prime.insertAt(1+1,false) ; 
    prime := prime.insertAt(2+1,false) ; 
        var p : int ; p := 2 ; while p * p <= max_val do ( (     if (prime->at(p+1) = true) then (         var i : int ; i := p * 2 ; while i <= max_val do (     prime := prime.insertAt(i+1,false) ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var maximum : int ; maximum := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (prime->at(arr[i+1]+1)) then (     maximum := Set{maximum, arr[i+1]}->max() ) else skip )  ;     i := i + 1 ) ; 
    return maximum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,10,15,7,6,8,13} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(getPrime(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countSetBits(int n){
    int count=0 ;
    while(n>0){
      n &=(n-1);
      count++;
    }
    return count ;
  }
  static int totalPairs(int arr[],int n){
    HashMap<Integer,Integer>m=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int count=countSetBits(arr[i]);
      if(m.containsKey(count))m.put(count,m.get(count)+1);
      else m.put(count,1);
    }
    int result=0 ;
    for(Map.Entry<Integer,Integer>entry : m.entrySet()){
      int value=entry.getValue();
      result+=((value*(value-1))/2);
    }
    return result ;
  }
  public static void main(String[] args){
    int arr[]={
      7,5,3,9,1,2 };
      int n=arr.length ;
      System.out.println(totalPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     n := MathLib.bitwiseAnd(n, (n - 1)) ; 
     count := count + 1 ) ; 
     return count );
  static   operation totalPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var m : Map(int,int) ; m := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     var count : int ; count := countSetBits(arr[i+1]) ;
     if (m->keys()->includes(count)) then     m := m->union(Map{count |-> m->at(count) + 1}) ; else     m := m->union(Map{count |-> 1}) ; )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
    for (entry : m->asSet()) do ( (     var value : int ; value := entry.getValue() ;
     result := result+(((value * (value - 1)) / 2)) )  ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{7,5,3,9,1,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(totalPairs(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int inversegrayCode(int n){
    int inv=0 ;
    for(; n!=0 ; n=n>>1)inv ^=n ;
    return inv ;
  }
  public static void main(String[] args){
    int n=15 ;
    System.out.println(inversegrayCode(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation inversegrayCode( n : int) : int
  pre: true
  post: true
  activity: (     var inv : int ; inv := 0 ;
       while n /= 0 do (     inv := MathLib.bitwiseXor(inv,n) ;  ;     n := (n/(2->pow(1)))->oclAsType(long) ) ; 
     return inv );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     OclFile["System.out"].println(inversegrayCode(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countEvenOdd(char num[],int n){
    int even_count=0 ;
    int odd_count=0 ;
    for(int i=0 ; i<n ; i++){
      int x=num[i]-48 ;
      if(x % 2==0)even_count++;
      else odd_count++;
    }
    System.out.println("Even count : "+even_count);
    System.out.println("Odd count : "+odd_count);
    if(even_count % 2==0 && odd_count % 2!=0)return 1 ;
    else return 0 ;
  }
  public static void main(String[] args){
    char num[]={
      1,2,3 };
      int n=num.length ;
      int t=countEvenOdd(num,n);
      if(t==1)System.out.println("YES");
      else System.out.println("NO");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countEvenOdd( num : Sequence(String), n : int) : int
  pre: true
  post: true
  activity: (     var even_count : int ; even_count := 0 ;
     var odd_count : int ; odd_count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := num[i+1] - 48 ;
     if (x mod 2 = 0) then     even_count := even_count + 1 ; else     odd_count := odd_count + 1 ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Even count : " + even_count) ; 
    OclFile["System.out"].println("Odd count : " + odd_count) ; 
    if (even_count mod 2 = 0 & odd_count mod 2 /= 0) then     return 1 else     return 0 ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : Sequence(String) ; num := Sequence{1,2,3} ;
     var n : int ; n := num->size() ;
     var t : int ; t := countEvenOdd(num, n) ;
     if (t = 1) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int NotParallel(int p[][],int n){
    HashMap<Integer,Integer>x_axis=new HashMap<Integer,Integer>();
    HashMap<Integer,Integer>y_axis=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      if(x_axis.containsKey(p[i][0]))x_axis.put(p[i][0],x_axis.get(p[i][0])+1);
      else x_axis.put(p[i][0],1);
      if(y_axis.containsKey(p[i][1]))y_axis.put(p[i][1],y_axis.get(p[i][1])+1);
      else y_axis.put(p[i][1],1);
    }
    int total=(n*(n-1))/2 ;
    for(Map.Entry<Integer,Integer>i : x_axis.entrySet()){
      int c=i.getValue();
      total-=(c*(c-1))/2 ;
    }
    for(Map.Entry<Integer,Integer>i : y_axis.entrySet()){
      int c=i.getValue();
      total-=(c*(c-1))/2 ;
    }
    return total ;
  }
  public static void main(String[] args){
    int p[][]={
      {
        1,2 },{
          1,5 },{
            1,15 },{
              2,10 }
            };
            int n=p.length ;
            System.out.print(NotParallel(p,n));
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation NotParallel( p : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     var x_axis : Map(int,int) ; x_axis := Map{} ;
     var y_axis : Map(int,int) ; y_axis := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (x_axis->keys()->includes(p[i+1][0+1])) then     x_axis := x_axis->union(Map{p[i+1][0+1] |-> x_axis->at(p[i+1][0+1]) + 1}) else     x_axis := x_axis->union(Map{p[i+1][0+1] |-> 1}) ; ;  
     if (y_axis->keys()->includes(p[i+1][1+1])) then     y_axis := y_axis->union(Map{p[i+1][1+1] |-> y_axis->at(p[i+1][1+1]) + 1}) ; else     y_axis := y_axis->union(Map{p[i+1][1+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
    var total : int ; total := (n * (n - 1)) / 2 ;
    for (i : x_axis->asSet()) do ( (     var c : int ; c := i.getValue() ;
     total := total-((c * (c - 1)) / 2) )  ) ; 
    for (i : y_axis->asSet()) do ( (     var c : int ; c := i.getValue() ;
     total := total-((c * (c - 1)) / 2) )  ) ; 
    return total 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : Sequence(Sequence(int)) ; p := Sequence{Sequence{1,2},Sequence{1,5},Sequence{1,15},Sequence{2,10}} ;
     var n : int ; n := p->size() ;
     OclFile["System.out"].print(NotParallel(p, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] a=new int[n-1];
    int[] b=new int[n];
    int i ;
    for(i=0 ; i<n-1 ; i++){
      a[i]=input.nextInt();
      b[a[i]-1]++;
    }
    for(i=0 ; i<n ; i++){
      if(b[i]==0){
        System.out.println(i+1);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n - 1)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var i : int ;
        i := 0 ; while i < n - 1 do ( (     a[i+1] := input.getCurrent()->toInteger() ; 
     b[a[i+1] - 1+1] := b[a[i+1] - 1+1] + 1 )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     if (b[i+1] = 0) then (     OclFile["System.out"].println(i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Forgotten_Episode {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int length_arr=sc.nextInt();
    int num=1 ;
    int total=0 ;
    int[] arr=new int[length_arr-1];
    for(int i=0 ; i<length_arr-1 ; i++){
      arr[i]=sc.nextInt();
    }
    for(int i=0 ; i<length_arr ; i++){
      total+=num ;
      num++;
    }
    for(int i=0 ; i<length_arr-1 ; i++){
      total-=arr[i];
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Forgotten_Episode {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var length_arr : int ; length_arr := sc.getCurrent()->toInteger() ;
    var num : int ; num := 1 ;
    var total : int ; total := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,length_arr - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < length_arr - 1 do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < length_arr do ( (     total := total+(num) ; 
     num := num + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < length_arr - 1 do ( (     total := total-(arr[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int pow(int x,int y){
    if(y==1)return x ;
    if(y==0)return 1 ;
    int temp=pow(x,y/2);
    temp*=temp ;
    if(y % 2==1)temp*=x ;
    return temp ;
  }
  static int noOfPermutations(int[] a,int n){
    if(n==1){
      return 1 ;
    }
    Arrays.sort(a);
    if(a[n-1]==a[n-2]){
      return 0 ;
    }
    int x=0 ;
    for(int i=0 ; i<n-2 ; ++i){
      if(a[i]==a[i+1]){
        if(a[i]==a[i+2]){
          return 0 ;
        }
        x++;
        i++;
      }
    }
    return pow(2,n-2*x-1);
  }
  public static void main(String[] args){
    int a[]={
      1,2,2,3,4 };
      int n=a.length ;
      int num=noOfPermutations(a,n);
      System.out.print(num);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pow( x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (y = 1) then     return x else skip ; 
     if (y = 0) then     return 1 else skip ; 
    var temp : int ; temp := pow(x, y / 2) ;
    temp := temp*(temp) ; 
    if (y mod 2 = 1) then     temp := temp*(x) ; else skip ; 
    return temp 
 );
  static   operation noOfPermutations( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then (     return 1 ) else skip ; 
     a := a->sort() ; 
    if (a[n - 1+1] = a[n - 2+1]) then (     return 0 ) else skip ; 
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < n - 2 do ( (     if (a[i+1] = a[i + 1+1]) then (     if (a[i+1] = a[i + 2+1]) then (     return 0 ) else skip ; 
     x := x + 1 ; 
     i := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    return pow(2, n - 2 * x - 1) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,2,3,4} ;
     var n : int ; n := a->size() ;
     var num : int ; num := noOfPermutations(a, n) ;
     OclFile["System.out"].print(num) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void printArr(int[] arr,int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]);
  }
  public static int compare(int num1,int num2){
    String A=Integer.toString(num1);
    String B=Integer.toString(num2);
    return(A+B).compareTo(B+A);
  }
  public static void printSmallest(int N,int[] arr){
    for(int i=0 ; i<N ; i++){
      for(int j=i+1 ; j<N ; j++){
        if(compare(arr[i],arr[j])>0){
          int temp=arr[i];
          arr[i]=arr[j];
          arr[j]=temp ;
        }
      }
    }
    printArr(arr,N);
  }
  public static void main(String[] args){
    int[] arr={
      5,6,2,9,21,1 };
      int N=arr.length ;
      printSmallest(N,arr);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1]) ;  ;     i := i + 1 ) );
  static   operation compare( num1 : int, num2 : int) : int
  pre: true
  post: true
  activity: (     var A : String ; A := ((num1) + "") ;
     var B : String ; B := ((num2) + "") ;
     return (A + B)->compareTo(B + A) );
  static   operation printSmallest( N : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := i + 1 ; while j < N do ( (     if (compare(arr[i+1], arr[j+1]) > 0) then (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := arr[j+1] ; 
     arr[j+1] := temp ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     execute printArr(arr, N) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,6,2,9,21,1} ;
     var N : int ; N := arr->size() ;
     execute printSmallest(N, arr) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A_Specific_Tastes_of_Andre {
  public static void main(String[] args){
    FastScanner s=new FastScanner();
    StringBuilder res=new StringBuilder();
    int t=s.nextInt();
    int p=0 ;
    while(p<t){
      int n=s.nextInt();
      for(int i=0 ; i<n ; i++){
        res.append("1 ");
      }
      p++;
      res.append("\n");
    }
    System.out.println(res);
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(String s){
      try {
        br=new BufferedReader(new FileReader(s));
      }
      catch(FileNotFoundException e){
        e.printStackTrace();
      }
    }
    public FastScanner(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String nextToken(){
      while(st==null || ! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(nextToken());
    }
    long nextLong(){
      return Long.parseLong(nextToken());
    }
    double nextDouble(){
      return Double.parseDouble(nextToken());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Specific_Tastes_of_Andre {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : FastScanner ; s := FastScanner.newFastScanner() ;
     var res : String ; res := StringLib.newString() ;
    var t : int ; t := s.nextInt() ;
    var p : int ; p := 0 ;
    while (p < t) do (     var n : int ; n := s.nextInt() ;
         var i : int ; i := 0 ; while i < n do ( (     res := res + StringLib.newString("1 ") )  ;     i := i + 1 ) ; 
     p := p + 1 ; 
     res := res + StringLib.newString("\n") ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
 );
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      for(int i=0 ; i<n ; i++)System.out.print("1 ");
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print("1 ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));
    char[] str=in.next().toCharArray();
    int x=0,pos=0 ;
    StringBuilder st=new StringBuilder();
    while(pos<str.length){
      char temp=str[pos+1];
      boolean end=(temp=='/');
      if(end){
        x=x-2 ;
      }
      for(int i=0 ; i<x ; i++){
        st.append(' ');
      }
      st.append('<');
      if(end){
        temp=str[pos+2];
        pos++;
        st.append('/');
      }
      else {
        x+=2 ;
      }
      st.append(temp);
      st.append(">\n");
      pos+=3 ;
    }
    pw.println(st);
    pw.close();
  }
  static void debug(Object...abc){
    System.err.println(Arrays.deepToString(abc));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var str : Sequence(String) ; str := in.getCurrent()->characters() ;
    var x : int ; x := 0 ;
    var pos : int ; pos := 0 ;
    var st : String ; st := StringLib.newString() ;
    while (pos < str->size()) do (     var temp : String ; temp := str[pos + 1+1] ;
     var end : boolean ; end := (temp = '/') ;
    if (end) then (     x := x - 2 ) else skip ; 
        var i : int ; i := 0 ; while i < x do ( (     st := st + StringLib.newString(' ') )  ;     i := i + 1 ) ; 
    st := st + StringLib.newString('<') ; 
    if (end) then (     temp := str[pos + 2+1] ; 
     pos := pos + 1 ; 
     st := st + StringLib.newString('/') ) else (     x := x+(2) ) ;  
    st := st + StringLib.newString(temp) ; 
    st := st + StringLib.newString(">\n") ; 
    pos := pos+(3) ; 
 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( abc : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((abc + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int center_hexadecagonal_num(int n){
    return 8*n*n-8*n+1 ;
  }
  public static void main(String args[]){
    int n=2 ;
    System.out.print(n+"th centered "+"hexadecagonal number: ");
    System.out.println(center_hexadecagonal_num(n));
    n=12 ;
    System.out.print(n+"th centered "+"hexadecagonal number: ");
    System.out.println(center_hexadecagonal_num(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation center_hexadecagonal_num( n : int) : int
  pre: true
  post: true
  activity: (     return 8 * n * n - 8 * n + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].print(n + "th centered " + "hexadecagonal number: ") ; 
    OclFile["System.out"].println(center_hexadecagonal_num(n)) ; 
    n := 12 ; 
    OclFile["System.out"].print(n + "th centered " + "hexadecagonal number: ") ; 
    OclFile["System.out"].println(center_hexadecagonal_num(n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t--!=0){
      int n=in.nextInt();
      for(int i=0 ; i<n ; i++){
        System.out.print(2+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(2 + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF_1438A_SpecificTastesOfAndre {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int count=scanner.nextInt();
    for(int i=0 ; i<count ; i++){
      int number=scanner.nextInt();
      int sumNeed=(int)Math.pow(2,number);
      int sum=0 ;
      for(int j=0 ; j<number ; j++){
        System.out.print(1);
        if(j!=number-1){
          System.out.print(" ");
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF_1438A_SpecificTastesOfAndre {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < count do ( (     var number : int ; number := scanner.getCurrent()->toInteger() ;
     var sumNeed : int ; sumNeed := 2->pow(number)->oclAsType(int) ;
    var sum : int ; sum := 0 ;
        var j : int ; j := 0 ; while j < number do ( (     OclFile["System.out"].print(1) ; 
     if (j /= number - 1) then (     OclFile["System.out"].print(" ") ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public final class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int h=s.nextInt();
    int w=s.nextInt();
    String[] img=new String[h];
    for(int i=0 ; i<h ; i++){
      img[i]=s.next();
    }
    for(int i=0 ; i<w+2 ; i++)System.out.print("#");
    System.out.println();
    for(int i=0 ; i<h ; i++)System.out.println("#"+img[i]+"#");
    for(int i=0 ; i<w+2 ; i++)System.out.print("#");
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := s.getCurrent()->toInteger() ;
    var w : int ; w := s.getCurrent()->toInteger() ;
    var img : Sequence(String) ; img := Integer.subrange(1,h)->collect(null) ;
        var i : int ; i := 0 ; while i < h do ( (     img[i+1] := s.getCurrent() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < w + 2 do (     OclFile["System.out"].print("#") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
        var i : int ; i := 0 ; while i < h do (     OclFile["System.out"].println("#" + img[i+1] + "#") ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < w + 2 do (     OclFile["System.out"].print("#") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    char[][] pixels=new char[H][W];
    for(int r=0 ; r<H ; ++r){
      String line=sc.next();
      for(int c=0 ; c<W ; ++c){
        pixels[r][c]=line.charAt(c);
      }
    }
    System.out.println(solve(pixels));
    sc.close();
  }
  static String solve(char[][] pixels){
    int H=pixels.length ;
    int W=pixels[0] .length ;
    char[][] result=new char[H+2][W+2];
    for(int r=0 ; r<result.length ; ++r){
      for(int c=0 ; c<result[r] .length ; ++c){
        result[r][c]=(r==0 || r==H+1 || c==0 || c==W+1)? '#' : pixels[r-1][c-1];
      }
    }
    return Arrays.stream(result).map(String :: new).collect(Collectors.joining("\n"));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var pixels : Sequence(Sequence(String)) ; pixels := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var r : int ; r := 0 ; while r < H do ( (     var line : String ; line := sc.getCurrent() ;
         var c : int ; c := 0 ; while c < W do ( (     pixels[r+1][c+1] := line->at(c+1) )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    OclFile["System.out"].println(solve(pixels)) ; 
    skip ; 
 );
  static   operation solve( pixels : Sequence(Sequence(String))) : String
  pre: true
  post: true
  activity: (     var H : int ; H := pixels->size() ;
     var W : int ; W := pixels[0+1]->size() ;
    var result : Sequence(Sequence(String)) ; result := Integer.subrange(1,H + 2)->collect(Integer.subrange(1,W + 2)->collect(0)) ;
        var r : int ; r := 0 ; while r < result->size() do ( (         var c : int ; c := 0 ; while c < result[r+1]->size() do ( (     result[r+1][c+1] := if (r = 0 or r = H + 1 or c = 0 or c = W + 1) then '#' else pixels[r - 1+1][(c)->char2byte() - 1+1] endif )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    return stream(result)->collect( _x1 | (lambda _pars : OclAny in String.newString().new(_pars))->apply(_x1) ).collect(Collectors.joining("\n")) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.stream.IntStream ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BPictureFrame solver=new BPictureFrame();
    solver.solve(1,in,out);
    out.close();
  }
  static class BPictureFrame {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int h=in.nextInt(),w=in.nextInt();
      IntStream.range(0,w+2).forEach(x->out.print('#'));
      out.println();
      for(int i=0 ; i<h ; i++){
        out.print('#');
        out.print(in.next());
        out.println('#');
      }
      IntStream.range(0,w+2).forEach(x->out.print('#'));
      out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BPictureFrame ; solver := BPictureFrame.newBPictureFrame() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BPictureFrame {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var h : int ; h := in.getCurrent()->toInteger() ;
    var w : int ; w := in.getCurrent()->toInteger() ;
     for x : Integer.subrange(0, w + 2-1) do
    (    skip) ; 
    skip ; 
        var i : int ; i := 0 ; while i < h do ( (     skip ; 
     skip ; 
     skip )  ;     i := i + 1 ) ; 
    for x : Integer.subrange(0, w + 2-1) do
    (    skip) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int h,w ;
    int i=0 ;
    int j=0 ;
    h=sc.nextInt();
    w=sc.nextInt();
    String str[]=new String[h];
    for(i=0 ; i<h ; i++)str[i]=sc.next();
    for(i=0 ; i<h+2 ; i++){
      for(j=0 ; j<w+2 ; j++){
        if(i==0 || i==h+1)System.out.print("#");
        else {
          if(j==0){
            System.out.print("#");
            System.out.print(str[i-1]);
          }
          if(j==w+1)System.out.print("#");
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ;
    var w : int ;
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    h := sc.getCurrent()->toInteger() ; 
    w := sc.getCurrent()->toInteger() ; 
    var str : Sequence(String) ; str := Integer.subrange(1,h)->collect(null) ;
        i := 0 ; while i < h do (     str[i+1] := sc.getCurrent() ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < h + 2 do ( (         j := 0 ; while j < w + 2 do ( (     if (i = 0 or i = h + 1) then     OclFile["System.out"].print("#") ; else (     if (j = 0) then (     OclFile["System.out"].print("#") ; 
     OclFile["System.out"].print(str[i - 1+1]) ) else skip ; 
     if (j = w + 1) then     OclFile["System.out"].print("#") ; else skip ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    char[][] a=new char[h][w];
    for(int i=0 ; i<h ; i++){
      a[i]=sc.next().toCharArray();
    }
    for(int i=0 ; i<w+2 ; i++){
      System.out.print('#');
    }
    System.out.print("\n");
    for(int i=0 ; i<h ; i++){
      System.out.print('#');
      for(int j=0 ; j<w ; j++){
        System.out.print(a[i][j]);
      }
      System.out.print('#');
      System.out.print("\n");
    }
    for(int i=0 ; i<w+2 ; i++){
      System.out.print('#');
    }
    System.out.print("\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (     a[i+1] := sc.getCurrent()->characters() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < w + 2 do ( (     OclFile["System.out"].print('#') )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("\n") ; 
        var i : int ; i := 0 ; while i < h do ( (     OclFile["System.out"].print('#') ; 
         var j : int ; j := 0 ; while j < w do ( (     OclFile["System.out"].print(a[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print('#') ; 
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < w + 2 do ( (     OclFile["System.out"].print('#') )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("\n") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class MaxSumPath {
  static int maxSum(int[][] mat,int n){
    if(n==1)return mat[0][0];
    int dp[][]=new int[n][n];
    int maxSum=Integer.MIN_VALUE,max ;
    for(int j=0 ; j<n ; j++)dp[n-1][j]=mat[n-1][j];
    for(int i=n-2 ; i>=0 ; i--){
      for(int j=0 ; j<n ; j++){
        max=Integer.MIN_VALUE ;
        if(((j-1)>=0)&&(max<dp[i+1][j-1]))max=dp[i+1][j-1];
        if(((j+1)<n)&&(max<dp[i+1][j+1]))max=dp[i+1][j+1];
        dp[i][j]=mat[i][j]+max ;
      }
    }
    for(int j=0 ; j<n ; j++)if(maxSum<dp[0][j])maxSum=dp[0][j];
    return maxSum ;
  }
  public static void main(String[] args){
    int mat[][]={
      {
        5,6,1,7 },{
-2,10,8,-1 },{
            3,-7,-9,11 },{
              12,-4,2,6 }
            };
            int n=4 ;
            System.out.println("Maximum Sum="+maxSum(mat,n));
          }
        }

------------------------------------------------------------
OCL File:
---------
 class MaxSumPath {
  static   operation maxSum( mat : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return mat[0+1][0+1] else skip ; 
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var maxSum : int ; maxSum := -2147483648 ;
    var max : int ;
        var j : int ; j := 0 ; while j < n do (     dp[n - 1+1][j+1] := mat[n - 1+1][j+1] ;  ;     j := j + 1 ) ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < n do ( (     max := -2147483648 ; 
     if (((j - 1) >= 0) & (max < dp[i + 1+1][j - 1+1])) then     max := dp[i + 1+1][j - 1+1] ; else skip ; 
     if (((j + 1) < n) & (max < dp[i + 1+1][j + 1+1])) then     max := dp[i + 1+1][j + 1+1] ; else skip ; 
     dp[i+1][j+1] := mat[i+1][j+1] + max )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
        var j : int ; j := 0 ; while j < n do (     if (maxSum < dp[0+1][j+1]) then     maxSum := dp[0+1][j+1] ; else skip ;  ;     j := j + 1 ) ; 
    return maxSum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{5,6,1,7},Sequence{-2,10,8,-1},Sequence{3,-7,-9,11},Sequence{12,-4,2,6}} ;
     var n : int ; n := 4 ;
     OclFile["System.out"].println("Maximum Sum=" + maxSum(mat, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  int n ;
  Edges[] g ;
  long[] counter ;
  void run(){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    int q=sc.nextInt();
    g=new Edges[n];
    counter=new long[n];
    for(int i=0 ; i<n ; i++){
      g[i]=new Edges();
    }
    for(int i=0 ; i<n-1 ; i++){
      int a=sc.nextInt()-1,b=sc.nextInt()-1 ;
      g[a] .add(b);
      g[b] .add(a);
    }
    for(int i=0 ; i<q ; i++){
      int p=sc.nextInt()-1,x=sc.nextInt();
      counter[p]+=x ;
    }
    dfs(0,0,new boolean[n]);
    PrintWriter out=new PrintWriter(System.out);
    out.print(counter[0]);
    for(int i=1 ; i<n ; i++){
      out.print(" "+counter[i]);
    }
    out.println();
    out.flush();
  }
  void dfs(int idx,long cnt,boolean[] visited){
    counter[idx]+=cnt ;
    visited[idx]=true ;
    for(int next : g[idx])if(! visited[next]){
      dfs(next,counter[idx],visited);
    }
  }
  class Edges extends ArrayList<Integer>{
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute g : Sequence(Edges);
   attribute counter : Sequence(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
    g := Integer.subrange(1,n)->collect(null) ; 
    counter := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     g[i+1] := Edges.newEdges() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
    var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
     g[a+1]->excludes(b) ; 
     g[b+1]->excludes(a) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var p : int ; p := sc.getCurrent()->toInteger() - 1 ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
     counter[p+1] := counter[p+1]+(x) )  ;     i := i + 1 ) ; 
    execute dfs(0, 0, Integer.subrange(1,n)->collect(false)) ; 
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    skip ; 
        var i : int ; i := 1 ; while i < n do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
   operation dfs( idx : int, cnt : long, visited : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (     counter[idx+1] := counter[idx+1]+(cnt) ; 
     visited[idx+1] := true ; 
     for (next : g[idx+1]) do (     if (not(visited[next+1])) then (     execute dfs(next, counter[idx+1], visited) ) else skip ;  ) );
 class Edges extends Sequence(int) { }
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  private static List<List<Integer>>edge ;
  private static int[] score ;
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=Integer.parseInt(scan.next());
    int q=Integer.parseInt(scan.next());
    edge=new ArrayList<List<Integer>>();
    for(int i=0 ; i<n ; i++){
      edge.add(new ArrayList<Integer>());
    }
    for(int i=0 ; i<n-1 ; i++){
      int a=Integer.parseInt(scan.next());
      int b=Integer.parseInt(scan.next());
      a--;
      b--;
      edge.get(a).add(b);
      edge.get(b).add(a);
    }
    score=new int[n];
    for(int i=0 ; i<q ; i++){
      int p=Integer.parseInt(scan.next());
      int x=Integer.parseInt(scan.next());
      p--;
      score[p]+=x ;
    }
    scan.close();
    dfs(0,0);
    StringBuilder sb=new StringBuilder();
    sb.append(score[0]);
    for(int i=1 ; i<n ; i++){
      sb.append(" ");
      sb.append(score[i]);
    }
    System.out.println(sb.toString());
  }
  private static void dfs(int node,int parent){
    for(int i : edge.get(node)){
      if(i==parent){
        continue ;
      }
      score[i]+=score[node];
      dfs(i,node);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute edge : Sequence(Sequence(int));
  static   attribute score : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (scan.getCurrent())->toInteger() ;
    var q : int ; q := (scan.getCurrent())->toInteger() ;
    edge := Sequence{} ; 
        var i : int ; i := 0 ; while i < n do ( (     edge := edge->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var a : int ; a := (scan.getCurrent())->toInteger() ;
     var b : int ; b := (scan.getCurrent())->toInteger() ;
    a := a - 1 ; 
    b := b - 1 ; 
    edge->at(a+1)->excludes(b) ; 
    edge->at(b+1)->excludes(a) ; 
 )  ;     i := i + 1 ) ; 
    score := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < q do ( (     var p : int ; p := (scan.getCurrent())->toInteger() ;
     var x : int ; x := (scan.getCurrent())->toInteger() ;
     p := p - 1 ; 
     score[p+1] := score[p+1]+(x) )  ;     i := i + 1 ) ; 
    skip ; 
    execute dfs(0, 0) ; 
    var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString(score[0+1]) ; 
        var i : int ; i := 1 ; while i < n do ( (     sb := sb + StringLib.newString(" ") ; 
     sb := sb + StringLib.newString(score[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
  static   operation dfs( node : int, parent : int) : void
  pre: true
  post: true
  activity: (     for (i : edge->at(node+1)) do ( (     if (i = parent) then (     continue ) else skip ; 
     score[i+1] := score[i+1]+(score[node+1]) ; 
     execute dfs(i, node) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int countEleLessThanOrEqual(int arr1[],int arr2[],int m,int n){
    for(int i=0 ; i<m ; i++){
      int count=0 ;
      for(int j=0 ; j<n ; j++)if(arr2[j]<=arr1[i])count++;
      System.out.print(count+" ");
    }
    return m ;
  }
  public static void main(String[] args){
    int arr1[]={
      1,2,3,4,7,9 };
      int arr2[]={
        0,1,2,1,1,4 };
        countEleLessThanOrEqual(arr1,arr2,arr1.length,arr2.length);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countEleLessThanOrEqual( arr1 : Sequence(int), arr2 : Sequence(int), m : int, n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < m do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < n do (     if (arr2[j+1] <= arr1[i+1]) then     count := count + 1 ; else skip ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].print(count + " ") )  ;     i := i + 1 ) ; 
     return m );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{1,2,3,4,7,9} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{0,1,2,1,1,4} ;
     execute countEleLessThanOrEqual(arr1, arr2, arr1->size(), arr2->size()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.nextLine();
    int level=-1 ;
    for(String tok : s.split("<|>")){
      if(tok.isEmpty()){
        continue ;
      }
      if(! tok.startsWith("/")){
        level++;
      }
      for(int i=0 ; i<level ; i++){
        System.out.print("  ");
      }
      System.out.println("<"+tok+">");
      if(tok.startsWith("/")){
        level--;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.nextLine() ;
     var level : int ; level := -1 ;
     for (tok : s->split("<|>")) do ( (     if (tok->isEmpty()) then (     continue ) else skip ; 
     if (not(tok->hasPrefix("/"))) then (     level := level + 1 ) else skip ; 
        var i : int ; i := 0 ; while i < level do ( (     OclFile["System.out"].print("  ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("<" + tok + ">") ; 
    if (tok->hasPrefix("/")) then (     level := level - 1 ) else skip ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.List ;
public class Main {
  static List<List<Integer>>list ;
  static int[] cnt ;
  static int[] ans ;
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    int n=Integer.parseInt(sa[0]);
    int q=Integer.parseInt(sa[1]);
    list=new ArrayList<>(n);
    for(int i=0 ; i<n ; i++){
      list.add(new ArrayList<>());
    }
    for(int i=0 ; i<n-1 ; i++){
      sa=br.readLine().split(" ");
      int a=Integer.parseInt(sa[0])-1 ;
      int b=Integer.parseInt(sa[1])-1 ;
      list.get(a).add(b);
      list.get(b).add(a);
    }
    cnt=new int[n];
    for(int i=0 ; i<q ; i++){
      sa=br.readLine().split(" ");
      int p=Integer.parseInt(sa[0])-1 ;
      int x=Integer.parseInt(sa[1]);
      cnt[p]+=x ;
    }
    br.close();
    ans=new int[n];
    dfs(0,-1,0);
    PrintWriter pw=new PrintWriter(System.out);
    for(int i=0 ; i<n ; i++){
      pw.println(ans[i]);
    }
    pw.flush();
  }
  static void dfs(int x,int p,int v){
    v+=cnt[x];
    ans[x]+=v ;
    for(int next : list.get(x)){
      if(next!=p){
        dfs(next,x,v);
      }
    }
    v-=cnt[x];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute list : Sequence(Sequence(int));
  static   attribute cnt : Sequence(int);
  static   attribute ans : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var n : int ; n := (sa[0+1])->toInteger() ;
    var q : int ; q := (sa[1+1])->toInteger() ;
    list := Sequence{} ; 
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     sa := br.readLine()->split(" ") ; 
     var a : int ; a := (sa[0+1])->toInteger() - 1 ;
    var b : int ; b := (sa[1+1])->toInteger() - 1 ;
    list->at(a+1)->excludes(b) ; 
    list->at(b+1)->excludes(a) ; 
 )  ;     i := i + 1 ) ; 
    cnt := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < q do ( (     sa := br.readLine()->split(" ") ; 
     var p : int ; p := (sa[0+1])->toInteger() - 1 ;
     var x : int ; x := (sa[1+1])->toInteger() ;
     cnt[p+1] := cnt[p+1]+(x) )  ;     i := i + 1 ) ; 
    skip ; 
    ans := Integer.subrange(1,n)->collect(0) ; 
    execute dfs(0, -1, 0) ; 
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
        var i : int ; i := 0 ; while i < n do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation dfs( x : int, p : int, v : int) : void
  pre: true
  post: true
  activity: (     v := v+(cnt[x+1]) ; 
     ans[x+1] := ans[x+1]+(v) ; 
     for (next : list->at(x+1)) do ( (     if (next /= p) then (     execute dfs(next, x, v) ) else skip )  ) ; 
     v := v-(cnt[x+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.*;
import static java.lang.System.*;
import java.io.PrintWriter ;
public class Main {
  static int[] ans ;
  static ArrayList<ArrayList<Integer>>ab ;
  static HashMap<Integer,Integer>px=new HashMap<>();
  public static void main(String[] args){
    int i,j ;
    Scanner sc=new Scanner(in);
    int n=parseInt(sc.next());
    int q=parseInt(sc.next());
    ab=new ArrayList<ArrayList<Integer>>(n+1);
    for(i=0 ; i<=n ; i++){
      ab.add(new ArrayList<Integer>());
    }
    int a,b ;
    for(i=0 ; i<n-1 ; i++){
      a=parseInt(sc.next());
      b=parseInt(sc.next());
      ab.get(a).add(b);
    }
    int x,p ;
    for(i=0 ; i<q ; i++){
      p=parseInt(sc.next());
      x=parseInt(sc.next());
      if(! px.containsKey(p)){
        px.put(p,x);
      }
      else {
        px.put(p,px.get(p)+x);
      }
    }
    sc.close();
    ans=new int[n];
    add(1,0);
    PrintWriter pw=new PrintWriter(out);
    for(i=0 ; i<n ; i++){
      pw.print(ans[i]);
      pw.print(" ");
    }
    pw.flush();
  }
  static void add(int p,int x){
    if(px.containsKey(p)){
      x+=px.get(p);
    }
    ans[p-1]+=x ;
    for(Integer i : ab.get(p)){
      add(i,x);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ans : Sequence(int);
  static   attribute ab : Sequence(Sequence(int));
  static   attribute px : Map(int,int) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
    var n : int ; n := parseInt(sc.getCurrent()) ;
    var q : int ; q := parseInt(sc.getCurrent()) ;
    ab := Sequence{}->union(n + 1) ; 
        i := 0 ; while i <= n do ( (     ab := ab->including(Sequence{}) )  ;     i := i + 1 ) ; 
    var a : int ;
    var b : int ;
        i := 0 ; while i < n - 1 do ( (     a := (sc.getCurrent() + "")->toInteger() ; 
     b := (sc.getCurrent() + "")->toInteger() ; 
     ab->at(a+1)->excludes(b) )  ;     i := i + 1 ) ; 
    var x : int ;
    var p : int ;
        i := 0 ; while i < q do ( (     p := (sc.getCurrent() + "")->toInteger() ; 
     x := (sc.getCurrent() + "")->toInteger() ; 
     if (not(px->keys()->includes(p))) then (     px := px->union(Map{p |-> x}) ) else (     px := px->union(Map{p |-> px->at(p) + x}) ) )  ;     i := i + 1 ) ; 
    skip ; 
    ans := Integer.subrange(1,n)->collect(0) ; 
    execute add(1, 0) ; 
    var pw : OclFile ; pw := OclFile.newOclFile_Write(out) ;
        i := 0 ; while i < n do ( (     skip ; 
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation add( p : int, x : int) : void
  pre: true
  post: true
  activity: (     if (px->keys()->includes(p)) then (     x := x+(px->at(p)) ) else skip ; 
     ans[p - 1+1] := ans[p - 1+1]+(x) ; 
     for (i : ab->at(p+1)) do ( (     execute add(i, x) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
class P {
  int offset ;
  int counter=0 ;
  List<P>links=new ArrayList<>();
}
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String[] line=sc.nextLine().split(" ");
    int N=Integer.parseInt(line[0]);
    int Q=Integer.parseInt(line[1]);
    P[] tree=new P[N];
    for(int i=0 ; i<N ; i++){
      tree[i]=new P();
    }
    for(int i=0 ; i<N-1 ; i++){
      line=sc.nextLine().split(" ");
      int a=Integer.parseInt(line[0]);
      int b=Integer.parseInt(line[1]);
      tree[a-1] .links.add(tree[b-1]);
      tree[b-1] .links.add(tree[a-1]);
    }
    for(int i=0 ; i<Q ; i++){
      line=sc.nextLine().split(" ");
      int p=Integer.parseInt(line[0]);
      int x=Integer.parseInt(line[1]);
      tree[p-1] .offset+=x ;
    }
    dfs(null,tree[0],0);
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<N ; i++){
      sb.append(tree[i] .counter).append(" ");
    }
    System.out.println(sb.toString());
  }
  static void dfs(P parent,P node,int sum){
    sum+=node.offset ;
    node.counter=sum ;
    for(P n : node.links){
      if(n!=parent){
        dfs(node,n,sum);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P {
   attribute offset : int;
   attribute counter : int := 0;
   attribute links : Sequence(P) := Sequence{};
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : Sequence(String) ; line := sc.nextLine()->split(" ") ;
    var N : int ; N := (line[0+1])->toInteger() ;
    var Q : int ; Q := (line[1+1])->toInteger() ;
    var tree : Sequence(P) ; tree := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     tree[i+1] := P.newP() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     line := sc.nextLine()->split(" ") ; 
     var a : int ; a := (line[0+1])->toInteger() ;
    var b : int ; b := (line[1+1])->toInteger() ;
    tree[a - 1+1].links->excludes(tree[b - 1+1]) ; 
    tree[b - 1+1].links->excludes(tree[a - 1+1]) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Q do ( (     line := sc.nextLine()->split(" ") ; 
     var p : int ; p := (line[0+1])->toInteger() ;
     var x : int ; x := (line[1+1])->toInteger() ;
     tree[p - 1+1].offset := tree[p - 1+1].offset+(x) )  ;     i := i + 1 ) ; 
    execute dfs(null, tree[0+1], 0) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < N do ( (     sb := sb + StringLib.newString(tree[i+1].counter) + StringLib.newString(" ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
  static   operation dfs( parent : P, node : P, sum : int) : void
  pre: true
  post: true
  activity: (     sum := sum+(node.offset) ; 
     node.counter := sum ; 
     for (n : node.links) do ( (     if (n /= parent) then (     execute dfs(node, n, sum) ) else skip )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ABC_110_D solver=new ABC_110_D();
    solver.solve(1,in,out);
    out.close();
  }
  static class ABC_110_D {
    int mod=1000000007 ;
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int m=in.nextInt();
      int mNokori=m ;
      long ans=1 ;
      for(int i=2 ; i*i<=mNokori ; i++){
        if(mNokori % i==0){
          int cnt=0 ;
          while(mNokori % i==0){
            cnt++;
            mNokori/=i ;
          }
          ans*=calcComb(cnt+n-1,n-1);
          ans %=mod ;
        }
      }
      if(mNokori!=1){
        ans*=calcComb(n+1-1,n-1);
        ans %=mod ;
      }
      out.print(ans);
    }
    long modpow(long a,int p){
      if(p==0)return 1 ;
      if(p % 2==0){
        int halfP=p/2 ;
        long halfA=modpow(a,halfP);
        return halfA*halfA % mod ;
      }
      else {
        return a*modpow(a,p-1)% mod ;
      }
    }
    long calcComb(int a,int b){
      if(b>a-b)return calcComb(a,a-b);
      long ansMul=1 ;
      long ansDiv=1 ;
      for(int i=0 ; i<b ; i++){
        ansMul*=(a-i);
        ansDiv*=(i+1);
        ansMul %=mod ;
        ansDiv %=mod ;
      }
      long ans=ansMul*modpow(ansDiv,mod-2)% mod ;
      return ans ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ABCsolver10_D ; solver := ABCABCsolver10_D.newABCsolver10_D()10_D.newABCABCsolver10_D.newABCsolver10_D()10_D() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ABC_110_D {
   attribute mod : int := 1000000007;
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var mNokori : int ; mNokori := m ;
    var ans : long ; ans := 1 ;
        var i : int ; i := 2 ; while i * i <= mNokori do ( (     if (mNokori mod i = 0) then (     var cnt : int ; cnt := 0 ;
     while (mNokori mod i = 0) do (     cnt := cnt + 1 ; 
     mNokori := mNokori/(i) ) ; 
     ans := ans*(calcComb(cnt + n - 1, n - 1)) ; 
     ans := ans mod mod ) else skip )  ;     i := i + 1 ) ; 
    if (mNokori /= 1) then (     ans := ans*(calcComb(n + 1 - 1, n - 1)) ; 
     ans := ans mod mod ) else skip ; 
    skip ; 
 );
   operation modpow( a : long, p : int) : long
  pre: true
  post: true
  activity: (     if (p = 0) then     return 1 else skip ; 
     if (p mod 2 = 0) then (     var halfP : int ; halfP := p / 2 ;
     var halfA : long ; halfA := modpow(a, halfP) ;
     return halfA * halfA mod mod ) else (     return a * modpow(a, p - 1) mod mod ) );
   operation calcComb( a : int, b : int) : long
  pre: true
  post: true
  activity: (     if (b > a - b) then     return calcComb(a, a - b) else skip ; 
     var ansMul : long ; ansMul := 1 ;
    var ansDiv : long ; ansDiv := 1 ;
        var i : int ; i := 0 ; while i < b do ( (     ansMul := ansMul*((a - i)) ; 
     ansDiv := ansDiv*((i + 1)) ; 
     ansMul := ansMul mod mod ; 
     ansDiv := ansDiv mod mod )  ;     i := i + 1 ) ; 
    var ans : long ; ans := ansMul * modpow(ansDiv, mod - 2) mod mod ;
    return ans 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static long MOD=(long)Math.pow(10,9)+7 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long m=sc.nextLong();
    long[] kai=new long[1000001];
    kai[0]=1 ;
    for(int i=1 ; i<=1000000 ; i++){
      kai[i]=(kai[i-1]*(long)i)% MOD ;
    }
    HashMap<Long,Long>map=new HashMap<Long,Long>();
    for(long i=2 ; (i*i)<=m ; i++){
      if((m % i)==0){
        long t=0 ;
        while((m % i)==0){
          t++;
          m/=i ;
        }
        map.put(i,t);
      }
    }
    if(m>1)map.put(m,(long)1);
    long ans=1 ;
    for(long key : map.keySet()){
      long s=map.get(key);
      long t1=kai[(int)(s+n-1)];
      long t2=kai[(int)s];
      long t3=kai[(int)(n-1)];
      t2=func(t2,MOD-2);
      t3=func(t3,MOD-2);
      ans=(ans*t1)% MOD ;
      ans=(ans*t2)% MOD ;
      ans=(ans*t3)% MOD ;
    }
    System.out.println(ans);
  }
  public static long func(long a,long x){
    if(x==0)return 1 ;
    if((x % 2)==0){
      long t=func(a,x/2);
      return(t*t)% MOD ;
    }
    else {
      long t=func(a,x/2);
      t=(t*t)% MOD ;
      return(a*t)% MOD ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : long := 10->pow(9)->oclAsType(long) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var m : long ; m := sc.getCurrent()->toLong() ;
    var kai : Sequence(long) ; kai := Integer.subrange(1,1000001)->collect(0) ;
    kai[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= 1000000 do ( (     kai[i+1] := (kai[i - 1+1] * i->oclAsType(long)) mod MOD )  ;     i := i + 1 ) ; 
    var map : Map(long,long) ; map := Map{} ;
        var i : long ; i := 2 ; while (i * i) <= m do ( (     if ((m mod i) = 0) then (     var t : long ; t := 0 ;
     while ((m mod i) = 0) do (     t := t + 1 ; 
     m := m/(i) ) ; 
     map := map->union(Map{i |-> t}) ) else skip )  ;     i := i + 1 ) ; 
    if (m > 1) then     map := map->union(Map{m |-> 1->oclAsType(long)}) ; else skip ; 
    var ans : long ; ans := 1 ;
    for (key : map->keys()) do ( (     var s : long ; s := map->at(key) ;
     var t1 : long ; t1 := kai[(s + n - 1)->oclAsType(int)+1] ;
    var t2 : long ; t2 := kai[s->oclAsType(int)+1] ;
    var t3 : long ; t3 := kai[(n - 1)->oclAsType(int)+1] ;
    t2 := func(t2, MOD - 2) ; 
    t3 := func(t3, MOD - 2) ; 
    ans := (ans * t1) mod MOD ; 
    ans := (ans * t2) mod MOD ; 
    ans := (ans * t3) mod MOD ; 
 )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation func( a : long, x : long) : long
  pre: true
  post: true
  activity: (     if (x = 0) then     return 1 else skip ; 
     if ((x mod 2) = 0) then (     var t : long ; t := func(a, x / 2) ;
     return (t * t) mod MOD ) else (     var t : long ; t := func(a, x / 2) ;
     t := (t * t) mod MOD ; 
     return (a * t) mod MOD ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static long MOD=(long)Math.pow(10,9)+7 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    int[] p=fact(m);
    long ans=1 ;
    for(int i=0 ; i<p.length ; i++){
      ans*=aHb(p[i],n);
      ans %=MOD ;
    }
    System.out.println(ans);
  }
  static int[] fact(int M){
    int[] res=new int[30];
    int index=0 ;
    for(int i=2 ; i<=M ; i++){
      boolean flag=true ;
      while(flag){
        if(M % i==0){
          res[index]++;
          M/=i ;
        }
        else {
          flag=false ;
        }
      }
      if(res[index]>0)index++;
    }
    int[] ans=new int[index];
    for(int i=0 ; i<index ; i++)ans[i]=res[i];
    return ans ;
  }
  static long aHb(long a,long b){
    long x=a+b-1 ;
    long y=b-1 ;
    long MulSum=1,DivSum=1 ;
    for(int i=1 ; i<=y ; i++){
      MulSum*=x-i+1 ;
      MulSum %=MOD ;
      DivSum*=i ;
      DivSum %=MOD ;
    }
    return MulSum*pow(DivSum,MOD-2)% MOD ;
  }
  static long pow(long a,long b){
    if(b==0)return 1 ;
    if(b % 2==0){
      long d=pow(a,b/2);
      return d*d % MOD ;
    }
    else return a*pow(a,b-1)% MOD ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : long := 10->pow(9)->oclAsType(long) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := fact(m) ;
    var ans : long ; ans := 1 ;
        var i : int ; i := 0 ; while i < p->size() do ( (     ans := ans*(aHb(p[i+1], n)) ; 
     ans := ans mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation fact( M : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,30)->collect(0) ;
     var index : int ; index := 0 ;
        var i : int ; i := 2 ; while i <= M do ( (     var flag : boolean ; flag := true ;
     while (flag) do (     if (M mod i = 0) then (     res[index+1] := res[index+1] + 1 ; 
     M := M/(i) ) else (     flag := false ) ) ; 
     if (res[index+1] > 0) then     index := index + 1 ; else skip )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,index)->collect(0) ;
        var i : int ; i := 0 ; while i < index do (     ans[i+1] := res[i+1] ;  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation aHb( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var x : long ; x := a + b - 1 ;
     var y : long ; y := b - 1 ;
    var MulSum : long ; MulSum := 1 ;
    var DivSum : long ; DivSum := 1 ;
        var i : int ; i := 1 ; while i <= y do ( (     MulSum := MulSum*(x - i + 1) ; 
     MulSum := MulSum mod MOD ; 
     DivSum := DivSum*(i) ; 
     DivSum := DivSum mod MOD )  ;     i := i + 1 ) ; 
    return MulSum * pow(DivSum, MOD - 2) mod MOD 
 );
  static   operation pow( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return 1 else skip ; 
     if (b mod 2 = 0) then (     var d : long ; d := pow(a, b / 2) ;
     return d * d mod MOD ) else     return a * pow(a, b - 1) mod MOD );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int mod=1_000_000_007 ;
    ArrayList<Integer>b=new ArrayList<>();
    int tmp=m ;
    for(int i=2 ; i*i<=m ; i++){
      if(tmp % i==0){
        int cnt=0 ;
        while(tmp % i==0){
          cnt++;
          tmp/=i ;
        }
        b.add(cnt);
      }
    }
    if(tmp!=1)b.add(1);
    Mod_nCr mn=new Mod_nCr(mod,200000);
    long ans=1 ;
    for(int cnt : b){
      long res=mn.nCr(n+cnt-1,cnt);
      ans*=res ;
      ans %=mod ;
    }
    System.out.println(ans);
  }
}
class Mod_nCr {
  int mod ;
  long[] fact ;
  long[] rfact ;
  public Mod_nCr(int mod,int max){
    this.mod=mod ;
    fact=new long[max];
    rfact=new long[max];
    fact[0]=1 ;
    rfact[0]=1 ;
    for(int i=1 ; i<max ; i++){
      fact[i]=(fact[i-1]*i)% mod ;
      rfact[i]=mod_inverse(fact[i],mod);
    }
  }
  private long mod_pow(long x,long p,long m){
    long a=1 ;
    while(p>0){
      if(p % 2==1){
        a=a*x % m ;
      }
      x=x*x % m ;
      p/=2 ;
    }
    return a ;
  }
  private long mod_inverse(long a,long m){
    return mod_pow(a,m-2,m);
  }
  public long nCr(int n,int r){
    return fact[n]*rfact[r] % mod*rfact[n-r] % mod ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var mod : int ; mod := 1_000_000_007 ;
    var b : Sequence(int) ; b := Sequence{} ;
    var tmp : int ; tmp := m ;
        var i : int ; i := 2 ; while i * i <= m do ( (     if (tmp mod i = 0) then (     var cnt : int ; cnt := 0 ;
     while (tmp mod i = 0) do (     cnt := cnt + 1 ; 
     tmp := tmp/(i) ) ; 
     b := b->including(cnt) ) else skip )  ;     i := i + 1 ) ; 
    if (tmp /= 1) then     b := b->including(1) ; else skip ; 
    var mn : Mod_nCr ; mn := Mod_nCr.newMod_nCr(mod, 200000) ;
    var ans : long ; ans := 1 ;
    for (cnt : b) do ( (     var res : long ; res := mn.nCr(n + cnt - 1, cnt) ;
     ans := ans*(res) ; 
     ans := ans mod mod )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}
class Mod_nCr {
   attribute mod : int;
   attribute fact : Sequence(long);
   attribute rfact : Sequence(long);
   static operation newMod_nCr( mod : int, max : int) : Mod_nCr
  pre: true
  post: true
  activity:
  ( var self : Mod_nCr ;
    self := createMod_nCr();
    self.initialise(mod, max);
    return self );
  operation initialise( mod : int, max : int) : void
  pre: true  post: true
  activity: (     self.mod := mod ; 
     fact := Integer.subrange(1,max)->collect(0) ; 
    rfact := Integer.subrange(1,max)->collect(0) ; 
    fact[0+1] := 1 ; 
    rfact[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < max do ( (     fact[i+1] := (fact[i - 1+1] * i) mod mod ; 
     rfact[i+1] := mod_inverse(fact[i+1], mod) )  ;     i := i + 1 ) ; 
 );
   operation mod_pow( x : long, p : long, m : long) : long
  pre: true
  post: true
  activity: (     var a : long ; a := 1 ;
     while (p > 0) do (     if (p mod 2 = 1) then (     a := a * x mod m ) else skip ; 
     x := x * x mod m ; 
     p := p/(2) ) ; 
     return a );
   operation mod_inverse( a : long, m : long) : long
  pre: true
  post: true
  activity: (     return mod_pow(a, m - 2, m) );
   operation nCr( n : int, r : int) : long
  pre: true
  post: true
  activity: (     return fact[n+1] * rfact[r+1] mod mod * rfact[n - r+1] mod mod );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=sc.nextInt();
    long[] arr=new long[N];
    long[] res=new long[N];
    for(int i=0 ; i<N ; i++){
      arr[i]=2*sc.nextInt();
    }
    int test=0 ;
    long sum=0 ;
    for(int j=0 ; j<N ; j++){
      if(test==0){
        sum=sum+arr[j];
        test=1 ;
      }
      else {
        sum=sum-arr[j];
        test=0 ;
      }
    }
    long first=sum/2 ;
    for(int i=0 ; i<N ; i++){
      long temp=first ;
      first=arr[i]-first ;
      res[i]=temp ;
    }
    for(int i=0 ; i<N ; i++){
      System.out.print(res[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,N)->collect(0) ;
    var res : Sequence(long) ; res := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := 2 * sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var test : int ; test := 0 ;
    var sum : long ; sum := 0 ;
        var j : int ; j := 0 ; while j < N do ( (     if (test = 0) then (     sum := sum + arr[j+1] ; 
     test := 1 ) else (     sum := sum - arr[j+1] ; 
     test := 0 ) )  ;     j := j + 1 ) ; 
    var first : long ; first := sum / 2 ;
        var i : int ; i := 0 ; while i < N do ( (     var temp : long ; temp := first ;
     first := arr[i+1] - first ; 
     res[i+1] := temp )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].print(res[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long Q=sc.nextLong();
    long H=sc.nextLong();
    long S=sc.nextLong();
    long D=sc.nextLong();
    long N=sc.nextLong();
    long onePrice=Math.min(Math.min(Q*4,H*2),S);
    if((double)onePrice<=(double)D/2){
      out.println(N*onePrice);
    }
    else {
      out.println((N/2)*D+(N % 2)*onePrice);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var Q : long ; Q := sc.getCurrent()->toLong() ;
    var H : long ; H := sc.getCurrent()->toLong() ;
    var S : long ; S := sc.getCurrent()->toLong() ;
    var D : long ; D := sc.getCurrent()->toLong() ;
    var N : long ; N := sc.getCurrent()->toLong() ;
    var onePrice : long ; onePrice := Set{Set{Q * 4, H * 2}->min(), S}->min() ;
    if (onePrice->oclAsType(double) <= D->oclAsType(double) / 2) then (     out.println(N * onePrice) ) else (     out.println((N / 2) * D + (N mod 2) * onePrice) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  final int MOD=1000000007 ;
  final int MAX=Integer.MAX_VALUE ;
  final long LMAX=Long.MAX_VALUE ;
  final int LEN=100000 ;
  void doIt(){
    int n=sc.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    int left=0,mid=a[0]/2,right=a[0];
    while(true){
      List<Integer>li=new ArrayList<>();
      int[] _a=a.clone();
      _a[0]-=mid ;
      _a[n-1]-=mid ;
      li.add(mid);
      for(int j=0 ; j<n-1 ; j++){
        int num=_a[j];
        _a[j]-=num ;
        _a[j+1]-=num ;
        li.add(num);
      }
      if(_a[n-1]==0){
        for(int i : li){
          System.out.print(i*2+" ");
        }
        System.out.println();
        return ;
      }
      else if(_a[n-1]<0){
        right=mid-1 ;
        mid=(right+left)/2 ;
      }
      else {
        left=mid+1 ;
        mid=(right+left)/2 ;
      }
    }
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute MOD : int := 1000000007;
   attribute MAX : int := 2147483647;
   attribute LMAX : long := "9223372036854775807"->toLong();
   attribute LEN : int := 100000;
   operation doIt() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var left : int ; left := 0 ;
    var mid : int ; mid := a[0+1] / 2 ;
    var right : int ; right := a[0+1] ;
    while (true) do (     var li : Sequence(int) ; li := Sequence{} ;
     var _a : Sequence(int) ; _a := a->copy() ;
    _a[0+1] := _a[0+1]-(mid) ; 
    _a[n - 1+1] := _a[n - 1+1]-(mid) ; 
    li := li->including(mid) ; 
        var j : int ; j := 0 ; while j < n - 1 do ( (     var num : int ; num := _a[j+1] ;
     _a[j+1] := _a[j+1]-(num) ; 
     _a[j + 1+1] := _a[j + 1+1]-(num) ; 
     li := li->including(num) )  ;     j := j + 1 ) ; 
    if (_a[n - 1+1] = 0) then (     for (i : li) do ( (     OclFile["System.out"].print(i * 2 + " ") )  ) ; 
     OclFile["System.out"].println() ; 
     return ) else     if (_a[n - 1+1] < 0) then (     right := mid - 1 ; 
     mid := (right + left) / 2 ) else (     left := mid + 1 ; 
     mid := (right + left) / 2 ) ;  ;  
 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String s=input.next();
    char[] ch=s.toCharArray();
    int i ;
    int j ;
    String x="" ;
    int h=-1 ;
    String y="" ;
    for(i=0 ; i<s.length(); i++){
      if(ch[i]!='>'){
        x=x+ch[i];
      }
      else {
        x=x+ch[i];
        if(x.length()==3){
          h++;
          for(j=1 ; j<=2*h ; j++){
            System.out.print(" ");
          }
          System.out.println(x);
        }
        else {
          for(j=1 ; j<=2*h ; j++){
            System.out.print(" ");
          }
          System.out.println(x);
          h--;
        }
        x="" ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := input.getCurrent() ;
    var ch : Sequence(String) ; ch := s->characters() ;
    var i : int ;
    var j : int ;
    var x : String ; x := "" ;
    var h : int ; h := -1 ;
    var y : String ; y := "" ;
        i := 0 ; while i < s->size() do ( (     if (ch[i+1] /= '>') then (     x := x + ch[i+1] ) else (     x := x + ch[i+1] ; 
     if (x->size() = 3) then (     h := h + 1 ; 
         j := 1 ; while j <= 2 * h do ( (     OclFile["System.out"].print(" ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(x) ) else (         j := 1 ; while j <= 2 * h do ( (     OclFile["System.out"].print(" ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(x) ; 
     h := h - 1 ) ;  
     x := "" ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int x1=0 ;
    int mae=0 ;
    int ato=0 ;
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(sc.next());
      if(i % 2==0){
        x1+=a[i];
      }
      else {
        x1-=a[i];
      }
    }
    System.out.println(x1);
    mae=x1 ;
    for(int i=0 ; i<n-1 ; i++){
      ato=2*a[i]-mae ;
      System.out.println(ato);
      mae=ato ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var x1 : int ; x1 := 0 ;
    var mae : int ; mae := 0 ;
    var ato : int ; ato := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sc.getCurrent())->toInteger() ; 
     if (i mod 2 = 0) then (     x1 := x1+(a[i+1]) ) else (     x1 := x1-(a[i+1]) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(x1) ; 
    mae := x1 ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     ato := 2 * a[i+1] - mae ; 
     OclFile["System.out"].println(ato) ; 
     mae := ato )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] dam=new int[n+1];
    int[] rain=new int[n+1];
    for(int i=0 ; i<n ; ++i){
      dam[i]=sc.nextInt();
    }
    dam[n]=dam[0];
    for(int i=0 ; i<n ; ++i){
      if(i % 2==0){
        rain[0]+=dam[i];
      }
      else {
        rain[0]-=dam[i];
      }
    }
    for(int i=1 ; i<n ; ++i){
      rain[i]=dam[i-1]*2-rain[i-1];
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; ++i){
      sb.append(rain[i]);
      if(i!=n-1){
        sb.append(" ");
      }
    }
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var dam : Sequence(int) ; dam := Integer.subrange(1,n + 1)->collect(0) ;
    var rain : Sequence(int) ; rain := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     dam[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    dam[n+1] := dam[0+1] ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then (     rain[0+1] := rain[0+1]+(dam[i+1]) ) else (     rain[0+1] := rain[0+1]-(dam[i+1]) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     rain[i+1] := dam[i - 1+1] * 2 - rain[i - 1+1] )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     sb := sb + StringLib.newString(rain[i+1]) ; 
     if (i /= n - 1) then (     sb := sb + StringLib.newString(" ") ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] dams=new int[N];
    long allSum=0 ;
    for(int i=0 ; i<N ; i++){
      dams[i]=sc.nextInt();
      allSum+=(long)dams[i];
    }
    long[] rains=new long[N];
    long sumWithoutX0=0 ;
    for(int i=1 ; i<N ; i+=2){
      sumWithoutX0+=(long)dams[i]*2 ;
    }
    rains[0]=allSum-sumWithoutX0 ;
    System.out.print(rains[0]+" ");
    for(int i=1 ; i<N ; i++){
      rains[i]=2*dams[i-1]-rains[i-1];
      System.out.print(rains[i]+" ");
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var dams : Sequence(int) ; dams := Integer.subrange(1,N)->collect(0) ;
    var allSum : long ; allSum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     dams[i+1] := sc.getCurrent()->toInteger() ; 
     allSum := allSum+(dams[i+1]->oclAsType(long)) )  ;     i := i + 1 ) ; 
    var rains : Sequence(long) ; rains := Integer.subrange(1,N)->collect(0) ;
    var sumWithoutX0 : long ; sumWithoutX0 := 0 ;
        var i : int ; i := 1 ; while i < N do ( (     sumWithoutX0 := sumWithoutX0+(dams[i+1]->oclAsType(long) * 2) )  ;     i := i+(2) ) ; 
    rains[0+1] := allSum - sumWithoutX0 ; 
    OclFile["System.out"].print(rains[0+1] + " ") ; 
        var i : int ; i := 1 ; while i < N do ( (     rains[i+1] := 2 * dams[i - 1+1] - rains[i - 1+1] ; 
     OclFile["System.out"].print(rains[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package gcj2009.qual ;
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class A {
  static final int INF=1<<20 ;
  static char[][] css ;
  public void run(){
    char[] key=sc.next().toCharArray();
    boolean[][] b=new boolean[L][127];
    for(int i=0,j=0 ; i<key.length ; i++,j++)if(key[i]=='(')while(key[++i]!=')')b[j][key[i] ]=true ;
    else b[j][key[i] ]=true ;
    int ans=0 ;
    loop : for(char[] cs : css){
      for(int i=0 ; i<L ; i++)if(! b[i][cs[i] ])continue loop ;
      ans++;
    }
    System.out.println(ans);
  }
  public static void main(String...args){
    try {
      System.setIn(new FileInputStream("A-large.in"));
      System.setOut(new PrintStream("A-large.out"));
    }
    catch(Exception e){
    }
    sc=new Scanner(System.in);
    L=sc.nextInt();
    D=sc.nextInt();
    int N=sc.nextInt();
    css=new char[D][];
    for(int i=0 ; i<D ; i++)css[i]=sc.next().toCharArray();
    for(int n=1 ; n<=N ; n++){
      System.out.printf("Case #%d: ",n);
      new A().run();
    }
  }
  static int L,D ;
  static Scanner sc ;
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static    attribute INF : int := (1*(2->pow(20)))->oclAsType(long);
  static   attribute css : Sequence(Sequence(String));
   operation run() : void
  pre: true
  post: true
  activity: (     var key : Sequence(String) ; key := sc.next()->characters() ;
     var b : Sequence(Sequence(boolean)) ; b := Integer.subrange(1,L)->collect(Integer.subrange(1,127)->collect(false)) ;
        var i : int ; i := 0 ;
    var j : int ; j := 0 ; while i < key->size() do (     if (key[i+1] = '(') then         i := i + 1 ;
    while (key[(i + 1)+1] /= ')') do (    skip ;     b[j+1][key[i+1]+1] := true ; ;     i := i + 1 ;
 ) else     b[j+1][key[i+1]+1] := true ; ;   ;     i := i + 1 ;     j := j + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (cs : css) do ( (         var i : int ; i := 0 ; while i < L do (     if (not(b[i+1][cs[i+1]+1])) then     continue else skip ;  ;     i := i + 1 ) ; 
     ans := ans + 1 )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("A-large.in"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile("A-large.out"))) )   catch (e : ProgramException) do skip
     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
    L := sc.nextInt() ; 
    D := sc.nextInt() ; 
    var N : int ; N := sc.nextInt() ;
    css := Integer.subrange(1,D)->collect(Sequence{}) ; 
        var i : int ; i := 0 ; while i < D do (     css[i+1] := sc.next()->characters() ;  ;     i := i + 1 ) ; 
        var n : int ; n := 1 ; while n <= N do ( (     OclFile["System.out"].printf("Case #%d: ", n) ; 
     A.newA().run() )  ;     n := n + 1 ) ; 
 );
  static   attribute L : int;
  static   attribute sc : OclFile;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package de.measite.gcj ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.LineNumberReader ;
import java.util.regex.Pattern ;
public class Main1 {
  public static void main(String[] args){
    try {
      LineNumberReader lnr=new LineNumberReader(new InputStreamReader(System.in));
      String line[]=lnr.readLine().trim().split(" ");
      final int d=Integer.parseInt(line[1]);
      final int n=Integer.parseInt(line[2]);
      String word[]=new String[d];
      for(int i=0 ; i<d ; i++){
        word[i]=lnr.readLine().trim();
      }
      for(int i=1 ; i<=n ; i++){
        String m=lnr.readLine().trim().replace('(','[').replace(')',']');
        Pattern pattern=Pattern.compile(m);
        int count=0 ;
        for(String w : word){
          if(pattern.matcher(w).matches()){
            count++;
          }
        }
        System.out.println("Case #"+i+": "+count);
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var lnr : LineNumberReader ; lnr := LineNumberReader.newLineNumberReader(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : Sequence(String) ; line := lnr.readLine()->trim()->split(" ") ;
    var d : int ; d := (line[1+1])->toInteger() ;
    var n : int ; n := (line[2+1])->toInteger() ;
    var word : Sequence(String) ; word := Integer.subrange(1,d)->collect(null) ;
        var i : int ; i := 0 ; while i < d do ( (     word[i+1] := lnr.readLine()->trim() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     var m : String ; m := lnr.readLine()->trim().replace('(', '[').replace(')', ']') ;
     var pattern : OclRegex ; pattern := OclRegex.compile(m) ;
    var count : int ; count := 0 ;
    for (w : word) do ( (     if (pattern.matcher(w).isMatch()) then (     count := count + 1 ) else skip )  ) ; 
    OclFile["System.out"].println("Case #" + i + ": " + count) ; 
 )  ;     i := i + 1 ) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Set ;
public class A {
  public static void main(String[] args)throws IOException {
    BufferedReader buffer=new BufferedReader(new InputStreamReader(System.in));
    String entrada=buffer.readLine();
    String ns[]=entrada.split(" ");
    int l=Integer.parseInt(ns[0]);
    int d=Integer.parseInt(ns[1]);
    int n=Integer.parseInt(ns[2]);
    String palavras[]=new String[d+1];
    for(int i=0 ; i<d ; i++){
      palavras[i]=buffer.readLine();
    }
    for(int k=1 ; k<=n ; k++){
      List<Set<Character>>conjuntosAceitaveis=new ArrayList<Set<Character>>();
      for(int i=0 ; i<l ; i++){
        conjuntosAceitaveis.add(new HashSet<Character>());
      }
      String expressao=buffer.readLine();
      int pt=0 ;
      for(int i=0 ; i<l ; i++){
        if(expressao.charAt(pt)=='('){
          for(pt++; expressao.charAt(pt)!=')' ;
          pt++){
            conjuntosAceitaveis.get(i).add(expressao.charAt(pt));
          }
          pt++;
        }
        else {
          conjuntosAceitaveis.get(i).add(expressao.charAt(pt));
          pt++;
        }
      }
      int cont=0 ;
      for(int i=0 ; i<d ; i++){
        boolean pode=true ;
        for(int j=0 ; j<l ; j++){
          if(! conjuntosAceitaveis.get(j).contains(palavras[i] .charAt(j))){
            pode=false ;
            break ;
          }
        }
        if(pode)cont++;
      }
      System.out.println("Case #"+k+": "+cont);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var buffer : OclFile ; buffer := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var entrada : String ; entrada := buffer.readLine() ;
    var ns : Sequence(String) ; ns := entrada->split(" ") ;
    var l : int ; l := (ns[0+1])->toInteger() ;
    var d : int ; d := (ns[1+1])->toInteger() ;
    var n : int ; n := (ns[2+1])->toInteger() ;
    var palavras : Sequence(String) ; palavras := Integer.subrange(1,d + 1)->collect(null) ;
        var i : int ; i := 0 ; while i < d do ( (     palavras[i+1] := buffer.readLine() )  ;     i := i + 1 ) ; 
        var k : int ; k := 1 ; while k <= n do ( (     var conjuntosAceitaveis : Sequence(Set(String)) ; conjuntosAceitaveis := Sequence{} ;
         var i : int ; i := 0 ; while i < l do ( (     conjuntosAceitaveis := conjuntosAceitaveis->including(Set{}) )  ;     i := i + 1 ) ; 
    var expressao : String ; expressao := buffer.readLine() ;
    var pt : int ; pt := 0 ;
        var i : int ; i := 0 ; while i < l do ( (     if (expressao->at(pt+1) = '(') then (         pt := pt + 1 ; while expressao->at(pt+1) /= ')' do ( (     conjuntosAceitaveis->at(i+1)->excludes(expressao->at(pt+1)) )  ;     pt := pt + 1 ) ; 
     pt := pt + 1 ) else (     conjuntosAceitaveis->at(i+1)->excludes(expressao->at(pt+1)) ; 
     pt := pt + 1 ) )  ;     i := i + 1 ) ; 
    var cont : int ; cont := 0 ;
        var i : int ; i := 0 ; while i < d do ( (     var pode : boolean ; pode := true ;
         var j : int ; j := 0 ; while j < l do ( (     if (not(conjuntosAceitaveis->at(j+1)->includes(palavras[i+1]->at(j+1)))) then (     pode := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (pode) then     cont := cont + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Case #" + k + ": " + cont) ; 
 )  ;     k := k + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package gcj2009.qualification ;
import java.io.File ;
import java.io.PrintWriter ;
import java.text.SimpleDateFormat ;
import java.util.Date ;
import java.util.Scanner ;
import java.util.regex.Pattern ;
public class A_Alien_Language {
  private static boolean SMALL=false ;
  private static String PROBLEM="A" ;
  public static void main(String[] args){
    try {
      Scanner scan=new Scanner(new File(String.format("%s-%s.in",PROBLEM,(SMALL ? "small" : "large"))));
      PrintWriter pw=new PrintWriter(new File(String.format("%s-%s.out",PROBLEM,(SMALL ? "small" : "large"))));
      int L=scan.nextInt(),D=scan.nextInt(),N=scan.nextInt();
      scan.nextLine();
      String[] dictionary=new String[D];
      for(int i=0 ; i<D ; ++i)dictionary[i]=scan.nextLine();
      System.out.println(String.format("%d test cases:",N));
      long start=System.currentTimeMillis(),t1,left ;
      for(int CASE=1 ; CASE<=N ; ++CASE){
        t1=System.currentTimeMillis();
        System.out.print(String.format("%d.[%s] ",CASE,new SimpleDateFormat("HH:mm:ss.SSS").format(new Date(t1))));
        String pattern=scan.nextLine();
        pattern=pattern.replace('(','[').replace(')',']');
        Pattern p=Pattern.compile(pattern);
        int cnt=0 ;
        for(int i=0 ; i<D ; ++i)if(p.matcher(dictionary[i]).matches())cnt++;
        String res=String.valueOf(cnt);
        pw.println(String.format("Case #%d: %s",CASE,res));
        left=(System.currentTimeMillis()-start)*(N-CASE)/CASE ;
        System.out.println(String.format("%s(%dms,~%dms left)",res,(System.currentTimeMillis()-t1),left));
      }
      pw.close();
      scan.close();
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Alien_Language {
  static   attribute SMALL : boolean := false;
  static   attribute PROBLEM : String := "A";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile(StringLib.format("%s-%s.in",Sequence{PROBLEM,(if SMALL then "small" else "large" endif)}))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile(StringLib.format("%s-%s.out",Sequence{PROBLEM,(if SMALL then "small" else "large" endif)}))) ;
    var L : int ; L := scan.getCurrent()->toInteger() ;
    var D : int ; D := scan.getCurrent()->toInteger() ;
    var N : int ; N := scan.getCurrent()->toInteger() ;
    skip ; 
    var dictionary : Sequence(String) ; dictionary := Integer.subrange(1,D)->collect(null) ;
        var i : int ; i := 0 ; while i < D do (     dictionary[i+1] := scan.nextLine() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(StringLib.format("%d test cases:",Sequence{N})) ; 
    var start : long ; start := OclDate.getSystemTime() ;
    var t1 : long ;
    var left : long ;
        var CASE : int ; CASE := 1 ; while CASE <= N do ( (     t1 := OclDate.getSystemTime() ; 
     OclFile["System.out"].print(StringLib.format("%d.[%s] ",Sequence{CASE,SimpleDateFormat.newSimpleDateFormat("HH:mm:ss.SSS").format(OclDate.newOclDate(t1))})) ; 
    var pattern : String ; pattern := scan.nextLine() ;
    pattern := pattern.replace('(', '[').replace(')', ']') ; 
    var p : OclRegex ; p := OclRegex.compile(pattern) ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < D do (     if (p.matcher(dictionary[i+1]).isMatch()) then     cnt := cnt + 1 ; else skip ;  ;     i := i + 1 ) ; 
    var res : String ; res := ((cnt) + "") ;
    skip ; 
    left := (OclDate.getSystemTime() - start) * (N - CASE) / CASE ; 
    OclFile["System.out"].println(StringLib.format("%s(%dms,~%dms left)",Sequence{res,(OclDate.getSystemTime() - t1),left})) ; 
 )  ;     CASE := CASE + 1 ) ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      long[] c=new long[4];
      for(int i=0 ; i<4 ; ++i)c[i]=in.nextLong();
      for(int i=0 ; i<3 ; ++i)c[i+1]=Math.min(c[i+1],2*c[i]);
      long n=in.nextLong();
      out.println(c[3]*(n/2)+c[2]*(n % 2));
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var c : Sequence(long) ; c := Integer.subrange(1,4)->collect(0) ;
         var i : int ; i := 0 ; while i < 4 do (     c[i+1] := in.nextLong() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do (     c[i + 1+1] := Set{c[i + 1+1], 2 * c[i+1]}->min() ;  ;     i := i + 1 ) ; 
    var n : long ; n := in.nextLong() ;
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static long M=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    long[] xs=new long[n];
    long[] ys=new long[m];
    for(int i=0 ; i<n ; i++){
      xs[i]=sc.nextInt();
    }
    for(int i=0 ; i<m ; i++){
      ys[i]=sc.nextInt();
    }
    long xa=0 ;
    for(int i=0 ; i<n ; i++){
      xa+=i*xs[i]-(n-i-1)*xs[i];
      xa %=M ;
    }
    long ya=0 ;
    for(int i=0 ; i<m ; i++){
      ya+=i*ys[i]-(m-i-1)*ys[i];
      ya %=M ;
    }
    System.out.println((xa*ya)% M);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute M : long := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var xs : Sequence(long) ; xs := Integer.subrange(1,n)->collect(0) ;
    var ys : Sequence(long) ; ys := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     xs[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     ys[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var xa : long ; xa := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     xa := xa+(i * xs[i+1] - (n - i - 1) * xs[i+1]) ; 
     xa := xa mod M )  ;     i := i + 1 ) ; 
    var ya : long ; ya := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     ya := ya+(i * ys[i+1] - (m - i - 1) * ys[i+1]) ; 
     ya := ya mod M )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((xa * ya) mod M) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.run();
  }
  long MOD=1000000007 ;
  public void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int x[]=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=sc.nextInt();
    }
    int y[]=new int[m];
    for(int i=0 ; i<m ; i++){
      y[i]=sc.nextInt();
    }
    long xx=0 ;
    for(int k=0 ; k<n ; k++){
      xx+=((2*k-n+1)*(long)x[k])% MOD ;
      xx %=MOD ;
    }
    long yy=0 ;
    for(int k=0 ; k<m ; k++){
      yy+=((2*k-m+1)*(long)y[k])% MOD ;
      yy %=MOD ;
    }
    System.out.println((xx*yy)% MOD);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.run() );
   attribute MOD : long := 1000000007;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var y : Sequence(int) ; y := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     y[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var xx : long ; xx := 0 ;
        var k : int ; k := 0 ; while k < n do ( (     xx := xx+(((2 * k - n + 1) * x[k+1]->oclAsType(long)) mod MOD) ; 
     xx := xx mod MOD )  ;     k := k + 1 ) ; 
    var yy : long ; yy := 0 ;
        var k : int ; k := 0 ; while k < m do ( (     yy := yy+(((2 * k - m + 1) * y[k+1]->oclAsType(long)) mod MOD) ; 
     yy := yy mod MOD )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println((xx * yy) mod MOD) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printPascal(int n){
    for(int line=0 ; line<n ; line++){
      for(int i=0 ; i<=line ; i++)System.out.print(binomialCoeff(line,i)+" ");
      System.out.println();
    }
  }
  static int binomialCoeff(int n,int k){
    int res=1 ;
    if(k>n-k)k=n-k ;
    for(int i=0 ; i<k ; ++i){
      res*=(n-i);
      res/=(i+1);
    }
    return res ;
  }
  public static void main(String args[]){
    int n=7 ;
    printPascal(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printPascal( n : int) : void
  pre: true
  post: true
  activity: (         var line : int ; line := 0 ; while line < n do ( (         var i : int ; i := 0 ; while i <= line do (     OclFile["System.out"].print(binomialCoeff(line, i) + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() )  ;     line := line + 1 ) );
  static   operation binomialCoeff( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
     if (k > n - k) then     k := n - k ; else skip ; 
         var i : int ; i := 0 ; while i < k do ( (     res := res*((n - i)) ; 
     res := res/((i + 1)) )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     execute printPascal(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static final long MOD=100_000_000_7 ;
  public static void main(String[] args){
    new Main().execute();
  }
  public void execute(){
    Scanner sc=new Scanner(System.in);
    final int N=sc.nextInt();
    final int M=sc.nextInt();
    long[] x=new long[N];
    long[] y=new long[M];
    for(int i=0 ; i<N ; i++){
      x[i]=sc.nextLong();
    }
    for(int i=0 ; i<M ; i++){
      y[i]=sc.nextLong();
    }
    long xSum=0 ;
    for(int i=0 ; i<N ; i++){
      xSum=(xSum+i*x[i]-(N-i-1)*x[i])% MOD ;
    }
    long ySum=0 ;
    for(int j=0 ; j<M ; j++){
      ySum=(ySum+j*y[j]-(M-j-1)*y[j])% MOD ;
    }
    System.out.println((xSum*ySum)% MOD);
    sc.close();
  }
  private void bruteForce(long[] x,long[] y){
    int n=x.length ;
    int m=y.length ;
    long S=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        for(int k=0 ; k<m ; k++){
          for(int l=k+1 ; l<m ; l++){
            S=(S+(x[j]-x[i])*(y[l]-y[k]))% MOD ;
          }
        }
      }
    }
    System.out.println(S);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 100_000_000_7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().execute() );
   operation execute() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var x : Sequence(long) ; x := Integer.subrange(1,N)->collect(0) ;
    var y : Sequence(long) ; y := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     x[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     y[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var xSum : long ; xSum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     xSum := (xSum + i * x[i+1] - (N - i - 1) * x[i+1]) mod MOD )  ;     i := i + 1 ) ; 
    var ySum : long ; ySum := 0 ;
        var j : int ; j := 0 ; while j < M do ( (     ySum := (ySum + j * y[j+1] - (M - j - 1) * y[j+1]) mod MOD )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println((xSum * ySum) mod MOD) ; 
    skip ; 
 );
   operation bruteForce( x : Sequence(long), y : Sequence(long)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := x->size() ;
     var m : int ; m := y->size() ;
    var S : long ; S := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (         var k : int ; k := 0 ; while k < m do ( (         var l : int ; l := k + 1 ; while l < m do ( (     S := (S + (x[j+1] - x[i+1]) * (y[l+1] - y[k+1])) mod MOD )  ;     l := l + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(S) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  private static final long MOD=1_000_000_007L ;
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      int m=scanner.nextInt();
      long sumX=mod(IntStream.range(0,n).mapToLong(i->mod((2*i+1-n)*scanner.nextLong())).sum());
      long sumY=mod(IntStream.range(0,m).mapToLong(i->mod((2*i+1-m)*scanner.nextLong())).sum());
      System.out.println(mod(sumX*sumY));
    }
  }
  private static long mod(long l){
    long result=l % MOD ;
    return(result>=0)? result : result+MOD ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 1_000_000_007L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
    var sumX : long ; sumX := mod(Integer.subrange(0, n-1)->collect( _x1 | (lambda i : OclAny in mod((2 * i + 1 - n) * scanner.getCurrent()->toLong()))->apply(_x1) )->sum()) ;
    var sumY : long ; sumY := mod(Integer.subrange(0, m-1)->collect( _x1 | (lambda i : OclAny in mod((2 * i + 1 - m) * scanner.getCurrent()->toLong()))->apply(_x1) )->sum()) ;
    OclFile["System.out"].println(mod(sumX * sumY)) ; 
 ))  );
  static   operation mod( l : long) : long
  pre: true
  post: true
  activity: (     var result : long ; result := l mod MOD ;
     return if (result >= 0) then result else result + MOD endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    long[] x=new long[n];
    long[] y=new long[m];
    for(int i=0 ; i<n ; i++)x[i]=sc.nextLong();
    for(int i=0 ; i<m ; i++)y[i]=sc.nextLong();
    BigInteger sum1=BigInteger.valueOf(0);
    BigInteger sum2=BigInteger.valueOf(0);
    for(int i=0 ; i<n ; i++){
      sum1=sum1.add(BigInteger.valueOf((2*i+1-n)*x[i]));
    }
    for(int i=0 ; i<m ; i++){
      sum2=sum2.add(BigInteger.valueOf((2*i+1-m)*y[i]));
    }
    BigInteger result=sum1.multiply(sum2).remainder(BigInteger.valueOf(1000000007));
    System.out.println(result);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : Sequence(long) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(long) ; y := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     x[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     y[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var sum1 : long ; sum1 := (0 + "")->toLong() ;
    var sum2 : long ; sum2 := (0 + "")->toLong() ;
        var i : int ; i := 0 ; while i < n do ( (     sum1 := sum1->excludes(((2 * i + 1 - n) * x[i+1] + "")->toLong()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     sum2 := sum2->excludes(((2 * i + 1 - m) * y[i+1] + "")->toLong()) )  ;     i := i + 1 ) ; 
    var result : long ; result := sum1.multiply(sum2).remainder((1000000007 + "")->toLong()) ;
    OclFile["System.out"].println(result) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.BufferedReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.io.IOException ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskB solver=new TaskB();
    solver.solve(1,in,out);
    out.close();
  }
}
class TaskB {
  public void solve(int testNumber,InputReader in,PrintWriter out){
    String word=in.next();
    int answer=0 ;
    for(int i=0 ; i<word.length(); i++){
      answer=Math.max(answer,getAns(word,i));
    }
    out.println(answer);
  }
  private int getAns(String word,int start){
    char ch=word.charAt(start);
    int res=1 ;
    while(start<word.length()){
      int nextIdx=start+1 ;
      while(nextIdx<word.length()){
        if(word.charAt(nextIdx)==ch &&((nextIdx-start)% 2==1)){
          break ;
        }
        nextIdx++;
      }
      if(nextIdx<word.length()){
        res++;
      }
      start=nextIdx ;
    }
    return res ;
  }
}
class InputReader {
  private BufferedReader reader ;
  private String[] currentArray ;
  public InputReader(InputStream inputStream){
    reader=new BufferedReader(new InputStreamReader(inputStream));
  }
  public String next(){
    try {
      currentArray=null ;
      return reader.readLine();
    }
    catch(IOException e){
      throw new RuntimeException(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskB ; solver := TaskB.newTaskB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
}
class TaskB {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var word : String ; word := in.next() ;
     var answer : int ; answer := 0 ;
         var i : int ; i := 0 ; while i < word->size() do ( (     answer := Set{answer, getAns(word, i)}->max() )  ;     i := i + 1 ) ; 
     skip );
   operation getAns( word : String, start : int) : int
  pre: true
  post: true
  activity: (     var ch : String ; ch := word->at(start+1) ;
     var res : int ; res := 1 ;
     while (start < word->size()) do (     var nextIdx : int ; nextIdx := start + 1 ;
     while (nextIdx < word->size()) do (     if (word->at(nextIdx+1) = ch & ((nextIdx - start) mod 2 = 1)) then (     break ) else skip ; 
     nextIdx := nextIdx + 1 ) ; 
     if (nextIdx < word->size()) then (     res := res + 1 ) else skip ; 
     start := nextIdx ) ; 
     return res );
}
class InputReader {
   attribute reader : OclFile;
   attribute currentArray : Sequence(String);
   static operation newInputReader( inputStream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     currentArray := null ; 
     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MAIN {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.nextLine();
    in.close();
    int res=0 ;
    if(s!=null && s.length()>0){
      for(char c='A' ; c<='Z' ; c++){
        int curRes ;
        int startPos ;
        startPos=findHighestPipe(s,c,true);
        curRes=findHighestPipe(s,startPos,c);
        if(curRes>res)res=curRes ;
        startPos=findHighestPipe(s,c,false);
        curRes=findHighestPipe(s,startPos,c);
        if(curRes>res)res=curRes ;
      }
    }
    System.out.println(res);
  }
  public static int findHighestPipe(String s,char c,boolean odd){
    int startPos=odd ? 1 : 0 ;
    while(startPos<s.length()&& !(s.charAt(startPos)==c && startPos % 2==(odd ? 1 : 0)))startPos++;
    return startPos ;
  }
  public static int findHighestPipe(String s,int pos,char c){
    if(pos>=s.length())return 0 ;
    int res=1 ;
    while(true){
      int prePos=pos ;
      pos++;
      while(pos<s.length()&& !(s.charAt(pos)==c &&(pos-prePos-1)% 2==0)){
        pos++;
      }
      if(pos<s.length()){
        res++;
      }
      else {
        break ;
      }
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class MAIN {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.nextLine() ;
    skip ; 
    var res : int ; res := 0 ;
    if (s /= null & s->size() > 0) then (         var c : String ; c := 'A' ; while c <= 'Z' do ( (     var curRes : int ;
     var startPos : int ;
    startPos := findHighestPipe(s, c, true) ; 
    curRes := findHighestPipe(s, startPos, c) ; 
    if (curRes > res) then     res := curRes ; else skip ; 
    startPos := findHighestPipe(s, c, false) ; 
    curRes := findHighestPipe(s, startPos, c) ; 
    if (curRes > res) then     res := curRes ; else skip ; 
 )  ;     c := c + 1 ) ) else skip ; 
    OclFile["System.out"].println(res) ; 
 );
  static   operation findHighestPipe( s : String, c : String, odd : boolean) : int
  pre: true
  post: true
  activity: (     var startPos : int ; startPos := if odd then 1 else 0 endif ;
     while (startPos < s->size() & not((s->at(startPos+1) = c & startPos mod 2 = (if odd then 1 else 0 endif)))) do     startPos := startPos + 1 ; ; 
     return startPos );
  static   operation findHighestPipe( s : String, pos : int, c : String) : int
  pre: true
  post: true
  activity: (     if (pos >= s->size()) then     return 0 else skip ; 
     var res : int ; res := 1 ;
     while (true) do (     var prePos : int ; prePos := pos ;
     pos := pos + 1 ; 
     while (pos < s->size() & not((s->at(pos+1) = c & (pos - prePos - 1) mod 2 = 0))) do (     pos := pos + 1 ) ; 
     if (pos < s->size()) then (     res := res + 1 ) else (     break ) ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int fun(int x){
    int y=(x/4)*4 ;
    int ans=0 ;
    for(int i=y ; i<=x ; i++)ans ^=i ;
    return ans ;
  }
  static int query(int x){
    if(x==0)return 0 ;
    int k=(x+1)/2 ;
    return((x %=2)!=0)? 2*fun(k):((fun(k-1)*2)^(k & 1));
  }
  static void allQueries(int q,int l[],int r[]){
    for(int i=0 ; i<q ; i++)System.out.println((query(r[i])^ query(l[i]-1)));
  }
  public static void main(String[] args){
    int q=3 ;
    int[] l={
      2,2,5 };
      int[] r={
        4,8,9 };
        allQueries(q,l,r);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fun( x : int) : int
  pre: true
  post: true
  activity: (     var y : int ; y := (x / 4) * 4 ;
     var ans : int ; ans := 0 ;
         var i : int ; i := y ; while i <= x do (     ans := MathLib.bitwiseXor(ans,i) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation query( x : int) : int
  pre: true
  post: true
  activity: (     if (x = 0) then     return 0 else skip ; 
     var k : int ; k := (x + 1) / 2 ;
     return if ((x) /= 0) then 2 * fun(k) else ((fun(k - 1) * 2) xor (MathLib.bitwiseAnd(k,1))) endif );
  static   operation allQueries( q : int, l : Sequence(int), r : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < q do (     OclFile["System.out"].println((query(r[i+1]) xor query(l[i+1] - 1))) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var q : int ; q := 3 ;
     var l : Sequence(int) ; l := Sequence{2,2,5} ;
     var r : Sequence(int) ; r := Sequence{4,8,9} ;
     execute allQueries(q, l, r) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static double dis(double x1,double y1,double x2){
    return Math.sqrt((x1-x2)*(x1-x2)+y1*y1);
  }
  public static void main(String[] args){
    int n ;
    double v1,v2 ;
    int maxn=1001 ;
    int a[]=new int[maxn];
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    v1=sc.nextDouble();
    v2=sc.nextDouble();
    for(int i=1 ; i<=n ; i++)a[i]=sc.nextInt();
    double x,y ;
    x=sc.nextDouble();
    y=sc.nextDouble();
    double ans2=dis(x,y,a[2])/v2+a[2]/v1 ;
    int ans1=2 ;
    for(int i=3 ; i<=n ; i++){
      double tmp=a[i]/v1+dis(x,y,a[i])/v2 ;
      if(tmp<=ans2){
        ans2=tmp ;
        ans1=i ;
      }
    }
    System.out.println(ans1);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation dis( x1 : double, y1 : double, x2 : double) : double
  pre: true
  post: true
  activity: (     return ((x1 - x2) * (x1 - x2) + y1 * y1)->sqrt() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     var v1 : double ;
    var v2 : double ;
    var maxn : int ; maxn := 1001 ;
    var a : Sequence(int) ; a := Integer.subrange(1,maxn)->collect(0) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := sc.getCurrent()->toInteger() ; 
    v1 := sc.getCurrent()->toReal() ; 
    v2 := sc.getCurrent()->toReal() ; 
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var x : double ;
    var y : double ;
    x := sc.getCurrent()->toReal() ; 
    y := sc.getCurrent()->toReal() ; 
    var ans2 : double ; ans2 := dis(x, y, a[2+1]) / v2 + a[2+1] / v1 ;
    var ans1 : int ; ans1 := 2 ;
        var i : int ; i := 3 ; while i <= n do ( (     var tmp : double ; tmp := a[i+1] / v1 + dis(x, y, a[i+1]) / v2 ;
     if (tmp <= ans2) then (     ans2 := tmp ; 
     ans1 := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans1) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Arrays ;
import java.util.ArrayList ;
import java.lang.Math ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    long q=sc.nextLong();
    long h=sc.nextLong();
    long s=sc.nextLong();
    long d=sc.nextLong();
    int n=sc.nextInt();
    long min=1000000000 ;
    if(n % 2==0){
      long[] tmp={
        q*8,h*4,s*2,d };
        for(int i=0 ; i<4 ; i++){
          if(min>tmp[i]){
            min=tmp[i];
          }
        }
        System.out.println(n/2*min);
      }
      else {
        long[] tmp={
          q*8,h*4,s*2,d };
          for(int i=0 ; i<4 ; i++){
            if(min>tmp[i]){
              min=tmp[i];
            }
          }
          if(q*4>=h*2){
            if(h*2>=s){
              System.out.println(n/2*min+s);
            }
            else {
              System.out.println(n/2*min+h*2);
            }
          }
          else {
            if(q*4>=s){
              System.out.println(n/2*min+s);
            }
            else {
              System.out.println(n/2*min+q*4);
            }
          }
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var q : long ; q := sc.getCurrent()->toLong() ;
     var h : long ; h := sc.getCurrent()->toLong() ;
    var s : long ; s := sc.getCurrent()->toLong() ;
    var d : long ; d := sc.getCurrent()->toLong() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var min : long ; min := 1000000000 ;
    if (n mod 2 = 0) then (     var tmp : Sequence(long) ; tmp := Sequence{q * 8,h * 4,s * 2,d} ;
         var i : int ; i := 0 ; while i < 4 do ( (     if (min > tmp[i+1]) then (     min := tmp[i+1] ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(n / 2 * min) ) else (     var tmp : Sequence(long) ; tmp := Sequence{q * 8,h * 4,s * 2,d} ;
         var i : int ; i := 0 ; while i < 4 do ( (     if (min > tmp[i+1]) then (     min := tmp[i+1] ) else skip )  ;     i := i + 1 ) ; 
     if (q * 4 >= h * 2) then (     if (h * 2 >= s) then (     OclFile["System.out"].println(n / 2 * min + s) ) else (     OclFile["System.out"].println(n / 2 * min + h * 2) ) ) else (     if (q * 4 >= s) then (     OclFile["System.out"].println(n / 2 * min + s) ) else (     OclFile["System.out"].println(n / 2 * min + q * 4) ) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static double dis(double x1,double y1,double x2){
    return Math.sqrt((x1-x2)*(x1-x2)+y1*y1);
  }
  public static void main(String[] args){
    int n ;
    double v1,v2 ;
    int maxn=1005 ;
    int a[]=new int[maxn];
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    v1=sc.nextDouble();
    v2=sc.nextDouble();
    for(int i=1 ; i<=n ; i++)a[i]=sc.nextInt();
    double x,y ;
    x=sc.nextDouble();
    y=sc.nextDouble();
    double ans2=dis(x,y,a[2])/v2+a[2]/v1 ;
    int ans1=2 ;
    for(int i=3 ; i<=n ; i++){
      double tmp=a[i]/v1+dis(x,y,a[i])/v2 ;
      if(tmp<=ans2){
        ans2=tmp ;
        ans1=i ;
      }
    }
    System.out.println(ans1);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation dis( x1 : double, y1 : double, x2 : double) : double
  pre: true
  post: true
  activity: (     return ((x1 - x2) * (x1 - x2) + y1 * y1)->sqrt() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     var v1 : double ;
    var v2 : double ;
    var maxn : int ; maxn := 1005 ;
    var a : Sequence(int) ; a := Integer.subrange(1,maxn)->collect(0) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := sc.getCurrent()->toInteger() ; 
    v1 := sc.getCurrent()->toReal() ; 
    v2 := sc.getCurrent()->toReal() ; 
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var x : double ;
    var y : double ;
    x := sc.getCurrent()->toReal() ; 
    y := sc.getCurrent()->toReal() ; 
    var ans2 : double ; ans2 := dis(x, y, a[2+1]) / v2 + a[2+1] / v1 ;
    var ans1 : int ; ans1 := 2 ;
        var i : int ; i := 3 ; while i <= n do ( (     var tmp : double ; tmp := a[i+1] / v1 + dis(x, y, a[i+1]) / v2 ;
     if (tmp <= ans2) then (     ans2 := tmp ; 
     ans1 := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans1) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Practice {
  static Scanner scn=new Scanner(System.in);
  static StringBuilder sb=new StringBuilder();
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] HastaLaVistaLa){
    int t=1 ;
    for(int i=0 ; i<t ; i++)solve();
    out.println(sb);
    out.close();
  }
  public static void solve(){
    int n=scn.nextInt();
    double vBus=scn.nextInt(),vPer=scn.nextInt();
    double[] stops=new double[n];
    for(int i=0 ; i<n ; i++)stops[i]=scn.nextInt();
    double dX=scn.nextInt(),dY=scn.nextInt();
    double min=Long.MAX_VALUE ;
    int index=1 ;
    double fromSchool=Long.MAX_VALUE ;
    for(int i=1 ; i<n ; i++){
      double bus=(stops[i])/vBus ;
      double dist=go(stops[i],0,dX,dY)/vPer ;
      if(min>bus+dist){
        min=bus+dist ;
        index=i+1 ;
        fromSchool=dist ;
      }
    }
    for(int i=1 ; i<n ; i++){
      double bus=(stops[i])/vBus ;
      double dist=go(stops[i],0,dX,dY)/vPer ;
      double add=(bus+dist);
      if(add==min && dist<fromSchool){
        index=i+1 ;
      }
    }
    sb.append(index);
  }
  public static double go(double x1,double y1,double X,double Y){
    double dist=(x1-X)*(x1-X)+(y1-Y)*(y1-Y);
    return(double)Math.sqrt(dist);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   attribute scn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute sb : String := StringLib.newString();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( HastaLaVistaLa : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
         var i : int ; i := 0 ; while i < t do (     execute solve() ;  ;     i := i + 1 ) ; 
     skip ; 
     skip );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := scn.getCurrent()->toInteger() ;
     var vBus : double ; vBus := scn.getCurrent()->toInteger() ;
    var vPer : double ; vPer := scn.getCurrent()->toInteger() ;
    var stops : Sequence(double) ; stops := Integer.subrange(1,n)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do (     stops[i+1] := scn.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dX : double ; dX := scn.getCurrent()->toInteger() ;
    var dY : double ; dY := scn.getCurrent()->toInteger() ;
    var min : double ; min := "9223372036854775807"->toLong() ;
    var index : int ; index := 1 ;
    var fromSchool : double ; fromSchool := "9223372036854775807"->toLong() ;
        var i : int ; i := 1 ; while i < n do ( (     var bus : double ; bus := (stops[i+1]) / vBus ;
     var dist : double ; dist := go(stops[i+1], 0, dX, dY) / vPer ;
     if (min > bus + dist) then (     min := bus + dist ; 
     index := i + 1 ; 
     fromSchool := dist ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     var bus : double ; bus := (stops[i+1]) / vBus ;
     var dist : double ; dist := go(stops[i+1], 0, dX, dY) / vPer ;
     var add : double ; add := (bus + dist) ;
     if (add = min & dist < fromSchool) then (     index := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(index) ; 
 );
  static   operation go( x1 : double, y1 : double, X : double, Y : double) : double
  pre: true
  post: true
  activity: (     var dist : double ; dist := (x1 - X) * (x1 - X) + (y1 - Y) * (y1 - Y) ;
     return (dist)->sqrt()->oclAsType(double) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class File1 {
  private static double dis(long x,long ux,long uy){
    return Math.sqrt((ux-x)*(ux-x)+uy*uy);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long vb=sc.nextInt();
    long vs=sc.nextInt();
    long[] stop=new long[n];
    for(int i=0 ; i<n ; i++)stop[i]=sc.nextInt();
    int ux=sc.nextInt();
    int uy=sc.nextInt();
    int index=0 ;
    double min=Double.MAX_VALUE ;
    for(int i=1 ; i<n ; i++){
      double t=(double)stop[i]/vb+dis(stop[i],ux,uy)/vs ;
      if((min==t && dis(stop[i],ux,uy)<dis(stop[index],ux,uy))|| min>t){
        min=t ;
        index=i ;
      }
    }
    System.out.println(index+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class File1 {
  static   operation dis( x : long, ux : long, uy : long) : double
  pre: true
  post: true
  activity: (     return ((ux - x) * (ux - x) + uy * uy)->sqrt() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var vb : long ; vb := sc.getCurrent()->toInteger() ;
    var vs : long ; vs := sc.getCurrent()->toInteger() ;
    var stop : Sequence(long) ; stop := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     stop[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ux : int ; ux := sc.getCurrent()->toInteger() ;
    var uy : int ; uy := sc.getCurrent()->toInteger() ;
    var index : int ; index := 0 ;
    var min : double ; min := (2 - 2->pow(-52))*(2->pow(1023)) ;
        var i : int ; i := 1 ; while i < n do ( (     var t : double ; t := stop[i+1]->oclAsType(double) / vb + dis(stop[i+1], ux, uy) / vs ;
     if ((min = t & dis(stop[i+1], ux, uy) < dis(stop[index+1], ux, uy)) or min > t) then (     min := t ; 
     index := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(index + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static final int MAX=1000001 ;
  static int numofAP(int a[],int n){
    int minarr=+2147483647 ;
    int maxarr=-2147483648 ;
    for(int i=0 ; i<n ; i++){
      minarr=Math.min(minarr,a[i]);
      maxarr=Math.max(maxarr,a[i]);
    }
    int dp[]=new int[n];
    int sum[]=new int[MAX];
    int ans=n+1 ;
    for(int d=(minarr-maxarr); d<=(maxarr-minarr); d++){
      Arrays.fill(sum,0);
      for(int i=0 ; i<n ; i++){
        dp[i]=1 ;
        if(a[i]-d>=1 && a[i]-d<=1000000)dp[i]+=sum[a[i]-d];
        ans+=dp[i]-1 ;
        sum[a[i] ]+=dp[i];
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3 };
      int n=arr.length ;
      System.out.println(numofAP(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX : int := 1000001;
  static   operation numofAP( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var minarr : int ; minarr := 2147483647 ;
     var maxarr : int ; maxarr := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     minarr := Set{minarr, a[i+1]}->min() ; 
     maxarr := Set{maxarr, a[i+1]}->max() )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
    var sum : Sequence(int) ; sum := Integer.subrange(1,MAX)->collect(0) ;
    var ans : int ; ans := n + 1 ;
        var d : int ; d := (minarr - maxarr) ; while d <= (maxarr - minarr) do ( (     sum := sum->collect(0) ; 
         var i : int ; i := 0 ; while i < n do ( (     dp[i+1] := 1 ; 
     if (a[i+1] - d >= 1 & a[i+1] - d <= 1000000) then     dp[i+1] := dp[i+1]+(sum[a[i+1] - d+1]) ; else skip ; 
     ans := ans+(dp[i+1] - 1) ; 
     sum[a[i+1]+1] := sum[a[i+1]+1]+(dp[i+1]) )  ;     i := i + 1 ) )  ;     d := d + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(numofAP(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static double dis(double x1,double y1,double x2){
    return Math.sqrt((x1-x2)*(x1-x2)+y1*y1);
  }
  public static void main(String[] args){
    int n ;
    double v1,v2 ;
    int maxn=1001 ;
    int a[]=new int[maxn];
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    v1=sc.nextDouble();
    v2=sc.nextDouble();
    for(int i=1 ; i<=n ; i++)a[i]=sc.nextInt();
    double x,y ;
    x=sc.nextDouble();
    y=sc.nextDouble();
    double ans2=dis(x,y,a[0])/v2+a[0]/v1 ;
    int ans1=2 ;
    for(int i=3 ; i<=n ; i++){
      double tmp=a[i]/v1+dis(x,y,a[i])/v2 ;
      if(tmp<=ans2){
        ans2=tmp ;
        ans1=i ;
      }
    }
    System.out.println(ans1);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation dis( x1 : double, y1 : double, x2 : double) : double
  pre: true
  post: true
  activity: (     return ((x1 - x2) * (x1 - x2) + y1 * y1)->sqrt() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     var v1 : double ;
    var v2 : double ;
    var maxn : int ; maxn := 1001 ;
    var a : Sequence(int) ; a := Integer.subrange(1,maxn)->collect(0) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := sc.getCurrent()->toInteger() ; 
    v1 := sc.getCurrent()->toReal() ; 
    v2 := sc.getCurrent()->toReal() ; 
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var x : double ;
    var y : double ;
    x := sc.getCurrent()->toReal() ; 
    y := sc.getCurrent()->toReal() ; 
    var ans2 : double ; ans2 := dis(x, y, a[0+1]) / v2 + a[0+1] / v1 ;
    var ans1 : int ; ans1 := 2 ;
        var i : int ; i := 3 ; while i <= n do ( (     var tmp : double ; tmp := a[i+1] / v1 + dis(x, y, a[i+1]) / v2 ;
     if (tmp <= ans2) then (     ans2 := tmp ; 
     ans1 := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans1) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String previousNumber(String num){
    int n=num.length();
    if(num.compareTo("1")==0){
      return "0" ;
    }
    int i ;
    for(i=n-1 ; i>=0 ; i--){
      if(num.charAt(i)=='1'){
        num=num.substring(0,i)+'0'+num.substring(i+1);
        break ;
      }
      else {
        num=num.substring(0,i)+'1'+num.substring(i+1);
      }
    }
    if(i==0){
      return num.substring(1,n-1);
    }
    return num ;
  }
  public static void main(String[] args){
    String num="10110" ;
    System.out.print("Binary representation of previous number="+previousNumber(num));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation previousNumber( num : String) : String
  pre: true
  post: true
  activity: (     var n : int ; n := num->size() ;
     if (num->compareTo("1") = 0) then (     return "0" ) else skip ; 
    var i : int ;
        i := n - 1 ; while i >= 0 do ( (     if (num->at(i+1) = '1') then (     num := num.subrange(0+1,i) + '0' + num.subrange(i + 1+1,i + 1) ; 
     break ) else (     num := num.subrange(0+1,i) + '1' + num.subrange(i + 1+1,i + 1) ) )  ;     i := i - 1 ) ; 
    if (i = 0) then (     return num.subrange(1+1,n - 1) ) else skip ; 
    return num 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : String ; num := "10110" ;
     OclFile["System.out"].print("Binary representation of previous number=" + previousNumber(num)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class P1307A {
  public static void main(String[] args)throws IOException {
    BufferedReader io=new BufferedReader(new InputStreamReader(System.in));
    Integer cnt=Integer.valueOf(io.readLine());
    List<Integer>rs=new ArrayList<Integer>();
    while(cnt>0){
      cnt--;
      String[] nd=io.readLine().split(" ");
      Integer n=Integer.valueOf(nd[0]);
      Integer d=Integer.valueOf(nd[1]);
      String[] input=io.readLine().split(" ");
      if(input.length==1){
        rs.add(Integer.valueOf(input[0]));
      }
      else {
        Integer tmp=Integer.valueOf(input[0]);
        for(int i=1 ; i<input.length ; i++){
          if((Integer.valueOf(input[i])*i)<=d){
            tmp=tmp+Integer.valueOf(input[i]);
            d=d-Integer.valueOf(input[i])*i ;
          }
          else {
            tmp=tmp+d/i ;
            break ;
          }
        }
        rs.add(tmp);
      }
    }
    for(Integer integer : rs){
      System.out.println(integer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P1307A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var cnt : int ; cnt := (io.readLine())->toInteger() ;
    var rs : Sequence(int) ; rs := Sequence{} ;
    while (cnt > 0) do (     cnt := cnt - 1 ; 
     var nd : Sequence(String) ; nd := io.readLine()->split(" ") ;
    var n : int ; n := (nd[0+1])->toInteger() ;
    var d : int ; d := (nd[1+1])->toInteger() ;
    var input : Sequence(String) ; input := io.readLine()->split(" ") ;
    if (input->size() = 1) then (     rs := rs->including((input[0+1])->toInteger()) ) else (     var tmp : int ; tmp := (input[0+1])->toInteger() ;
         var i : int ; i := 1 ; while i < input->size() do ( (     if (((input[i+1])->toInteger() * i) <= d) then (     tmp := tmp + (input[i+1])->toInteger() ; 
     d := d - (input[i+1])->toInteger() * i ) else (     tmp := tmp + d / i ; 
     break ) )  ;     i := i + 1 ) ; 
     rs := rs->including(tmp) ) ;  
 ) ; 
    for (integer : rs) do ( (     OclFile["System.out"].println(integer) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cow {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t,n,d,j,i,a[],p ;
    t=sc.nextInt();
    for(j=1 ; j<=t ; j++){
      n=sc.nextInt();
      a=new int[n];
      d=sc.nextInt();
      for(i=0 ; i<n ; i++)a[i]=sc.nextInt();
      i=1 ;
      while(d>0 && i<n){
        if(a[i]==0){
          i++;
          continue ;
        }
        p=d/i ;
        d=d-i*(int)Math.min(p,a[i]);
        if(d<0)break ;
        a[0]=a[0]+(int)Math.min(p,a[i]);
        i++;
      }
      System.out.println(a[0]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cow {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ;
    var n : int ;
    var d : int ;
    var j : int ;
    var i : int ;
    var a : Sequence(void) ;
    var p : int ;
     t := sc.getCurrent()->toInteger() ; 
         j := 1 ; while j <= t do ( (     n := sc.getCurrent()->toInteger() ; 
     a := Integer.subrange(1,n)->collect(0) ; 
    d := sc.getCurrent()->toInteger() ; 
        i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    i := 1 ; 
    while (d > 0 & i < n) do (     if (a[i+1] = 0) then (     i := i + 1 ; 
     continue ) else skip ; 
     p := d / i ; 
    d := d - i * Set{p, a[i+1]}->min()->oclAsType(int) ; 
    if (d < 0) then     break else skip ; 
    a[0+1] := a[0+1] + Set{p, a[i+1]}->min()->oclAsType(int) ; 
    i := i + 1 ; 
 ) ; 
    OclFile["System.out"].println(a[0+1]) ; 
 )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      int n,d ;
      n=scanner.nextInt();
      d=scanner.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; i++){
        a[i]=scanner.nextInt();
      }
      int ans=a[0];
      outer : for(int i=1 ;
      i<a.length ;
      i++){
        while(a[i]>0){
          if(d-(i)>=0){
            ans+=1 ;
            a[i]--;
            d-=i ;
          }
          else {
            break outer ;
          }
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ;
    var d : int ;
     n := scanner.getCurrent()->toInteger() ; 
    d := scanner.getCurrent()->toInteger() ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := a[0+1] ;
        var i : int ; i := 1 ; while i < a->size() do ( (     while (a[i+1] > 0) do (     if (d - (i) >= 0) then (     ans := ans+(1) ; 
     a[i+1] := a[i+1] - 1 ; 
     d := d-(i) ) else (     break ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_Cow_and_Haybales {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int d=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; ++i){
        a[i]=sc.nextInt();
      }
      System.out.println(solve(a,d));
    }
    sc.close();
  }
  static int solve(int[] a,int d){
    int result=a[0];
    for(int i=1 ; i<a.length ; ++i){
      int additive=Math.min(a[i],d/i);
      result+=additive ;
      d-=additive*i ;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Cow_and_Haybales {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(a, d)) ; 
 )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : Sequence(int), d : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := a[0+1] ;
         var i : int ; i := 1 ; while i < a->size() do ( (     var additive : int ; additive := Set{a[i+1], d / i}->min() ;
     result := result+(additive) ; 
     d := d-(additive * i) )  ;     i := i + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  void solve(){
    int[] a=new int[] {
      in.nextInt(),in.nextInt(),in.nextInt(),in.nextInt()};
      for(int i=0 ; i<3 ; i++){
        a[i+1]=Math.min(a[i+1],a[i]*2);
      }
      for(int i=2 ; i>=0 ; i--){
      }
      long n=in.nextLong()*4 ;
      long result=0 ;
      for(int i=3 ; i>=0 ; i--){
        long div=n>>>i ;
        result+=div*a[i];
        n-=div<<i ;
      }
      out.println(result);
    }
    FastScanner in ;
    PrintWriter out ;
    void run(){
      in=new FastScanner();
      out=new PrintWriter(System.out);
      solve();
      out.close();
    }
    class FastScanner {
      BufferedReader br ;
      StringTokenizer st ;
      public FastScanner(){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
      public FastScanner(String s){
        try {
          br=new BufferedReader(new FileReader(s));
        }
        catch(FileNotFoundException e){
          e.printStackTrace();
        }
      }
      public String nextToken(){
        while(st==null || ! st.hasMoreTokens()){
          try {
            st=new StringTokenizer(br.readLine());
          }
          catch(IOException e){
          }
        }
        return st.nextToken();
      }
      public int nextInt(){
        return Integer.parseInt(nextToken());
      }
      public long nextLong(){
        return Long.parseLong(nextToken());
      }
      public double nextDouble(){
        return Double.parseDouble(nextToken());
      }
    }
    public static void main(String[] args){
      new Main().run();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{in.nextInt(),in.nextInt(),in.nextInt(),in.nextInt()} ;
         var i : int ; i := 0 ; while i < 3 do ( (     a[i + 1+1] := Set{a[i + 1+1], a[i+1] * 2}->min() )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i >= 0 do ( skip  ;     i := i - 1 ) ; 
    var n : long ; n := in.nextLong() * 4 ;
    var result : long ; result := 0 ;
        var i : int ; i := 3 ; while i >= 0 do ( (     var div : long ; div := (n/(2->pow(i)))->oclAsType(long) ;
     result := result+(div * a[i+1]) ; 
     n := n-((div*(2->pow(i)))->oclAsType(long)) )  ;     i := i - 1 ) ; 
    out.println(result) ; 
 );
   attribute in : FastScanner;
   attribute out : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     in := FastScanner.newFastScanner() ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     execute solve() ; 
     skip );
 class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
 );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void createHash(HashSet<Integer>hash,int maxElement){
    int prev=0,curr=1 ;
    hash.add(prev);
    hash.add(curr);
    while(curr<=maxElement){
      int temp=curr+prev ;
      hash.add(temp);
      prev=curr ;
      curr=temp ;
    }
  }
  static int countFibonacciDivisors(int n){
    HashSet<Integer>hash=new HashSet<Integer>();
    createHash(hash,n);
    int cnt=0 ;
    for(int i=1 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        if((n/i==i)&&(hash.contains(n/i)))cnt++;
        else {
          if(hash.contains(n/i))cnt++;
          if(hash.contains(n/(n/i)))cnt++;
        }
      }
    }
    return cnt ;
  }
  public static void main(String[] args){
    int n=12 ;
    System.out.print(countFibonacciDivisors(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation createHash( hash : Set(int), maxElement : int) : void
  pre: true
  post: true
  activity: (     var prev : int ; prev := 0 ;
    var curr : int ; curr := 1 ;
     hash->excludes(prev) ; 
     hash->excludes(curr) ; 
     while (curr <= maxElement) do (     var temp : int ; temp := curr + prev ;
     hash->excludes(temp) ; 
     prev := curr ; 
     curr := temp ) );
  static   operation countFibonacciDivisors( n : int) : int
  pre: true
  post: true
  activity: (     var hash : Set(int) ; hash := Set{} ;
     execute createHash(hash, n) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 1 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     if ((n / i = i) & (hash->includes(n / i))) then     cnt := cnt + 1 ; else (     if (hash->includes(n / i)) then     cnt := cnt + 1 ; else skip ; 
     if (hash->includes(n / (n / i))) then     cnt := cnt + 1 ; else skip ) ) else skip )  ;     i := i + 1 ) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     OclFile["System.out"].print(countFibonacciDivisors(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public final class Test {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int cum1=0,cum2=0,mxcum1=0,mxcum2=0 ;
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
        cum1+=arr[i];
        mxcum1=Math.max(mxcum1,cum1);
      }
      int m=sc.nextInt();
      int[] brr=new int[m];
      for(int i=0 ; i<m ; i++){
        brr[i]=sc.nextInt();
        cum2+=brr[i];
        mxcum2=Math.max(mxcum2,cum2);
      }
      System.out.println(mxcum1+mxcum2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var cum1 : int ; cum1 := 0 ;
    var cum2 : int ; cum2 := 0 ;
    var mxcum1 : int ; mxcum1 := 0 ;
    var mxcum2 : int ; mxcum2 := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     cum1 := cum1+(arr[i+1]) ; 
     mxcum1 := Set{mxcum1, cum1}->max() )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var brr : Sequence(int) ; brr := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     brr[i+1] := sc.getCurrent()->toInteger() ; 
     cum2 := cum2+(brr[i+1]) ; 
     mxcum2 := Set{mxcum2, cum2}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(mxcum1 + mxcum2) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class NewClass {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    ArrayList<Integer>b=new ArrayList<>();
    ArrayList<Integer>r=new ArrayList<>();
    for(int i=0 ; i<t ; i++){
      int rn=in.nextInt();
      int mj=0 ;
      int max=0 ;
      for(int j=0 ; j<rn ; j++){
        mj+=in.nextInt();
        max=Math.max(mj,max);
      }
      int bn=in.nextInt();
      int mjj=0 ;
      int maxx=0 ;
      for(int j=0 ; j<bn ; j++){
        mjj+=in.nextInt();
        maxx=Math.max(mjj,maxx);
      }
      System.out.println(max+maxx);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Sequence{} ;
    var r : Sequence(int) ; r := Sequence{} ;
        var i : int ; i := 0 ; while i < t do ( (     var rn : int ; rn := in.getCurrent()->toInteger() ;
     var mj : int ; mj := 0 ;
    var max : int ; max := 0 ;
        var j : int ; j := 0 ; while j < rn do ( (     mj := mj+(in.getCurrent()->toInteger()) ; 
     max := Set{mj, max}->max() )  ;     j := j + 1 ) ; 
    var bn : int ; bn := in.getCurrent()->toInteger() ;
    var mjj : int ; mjj := 0 ;
    var maxx : int ; maxx := 0 ;
        var j : int ; j := 0 ; while j < bn do ( (     mjj := mjj+(in.getCurrent()->toInteger()) ; 
     maxx := Set{mjj, maxx}->max() )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(max + maxx) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class solution {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args)throws java.lang.Exception {
    OutputStream outputStream=System.out ;
    PrintWriter out=new PrintWriter(outputStream);
    FastReader s=new FastReader();
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int arr1[]=new int[n];
      int m1=0 ;
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        arr1[i]=s.nextInt();
        sum+=arr1[i];
        m1=Math.max(m1,sum);
      }
      int m=s.nextInt();
      int arr2[]=new int[m];
      int m2=0 ;
      int sum1=0 ;
      for(int i=0 ; i<m ; i++){
        arr2[i]=s.nextInt();
        sum1+=arr2[i];
        m2=Math.max(m2,sum1);
      }
      out.println(m1+m2);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile(outputStream)) ;
    var s : FastReader ; s := FastReader.newFastReader() ;
    var t : int ; t := s.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.nextInt() ;
     var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n)->collect(0) ;
    var m1 : int ; m1 := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr1[i+1] := s.nextInt() ; 
     sum := sum+(arr1[i+1]) ; 
     m1 := Set{m1, sum}->max() )  ;     i := i + 1 ) ; 
    var m : int ; m := s.nextInt() ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,m)->collect(0) ;
    var m2 : int ; m2 := 0 ;
    var sum1 : int ; sum1 := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     arr2[i+1] := s.nextInt() ; 
     sum1 := sum1+(arr2[i+1]) ; 
     m2 := Set{m2, sum1}->max() )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(in,out);
    out.close();
  }
  static class Task {
    int getTimesDivideBy2(int a){
      int times=0 ;
      while(a % 2==0){
        a/=2 ;
        times++;
      }
      return times ;
    }
    void solve(InputReader in,PrintWriter out){
      int N=in.nextInt();
      int ans=0 ;
      for(int i=0 ; i<N ; i++){
        int a=in.nextInt();
        ans+=getTimesDivideBy2(a);
      }
      out.println(ans);
    }
  }
  static class InputReader {
    BufferedReader reader ;
    StringTokenizer tokenizer ;
    InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream));
      tokenizer=null ;
    }
    String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] nextIntArray(int size){
      int[] arr=new int[size];
      for(int i=0 ; i<size ; i++){
        arr[i]=nextInt();
      }
      return arr ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(in, out) ; 
    skip ; 
 );
  static class Task {
   operation getTimesDivideBy2( a : int) : int
  pre: true
  post: true
  activity: (     var times : int ; times := 0 ;
     while (a mod 2 = 0) do (     a := a/(2) ; 
     times := times + 1 ) ; 
     return times );
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.nextInt() ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := in.nextInt() ;
     ans := ans+(getTimesDivideBy2(a)) )  ;     i := i + 1 ) ; 
     skip );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextIntArray( size : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < size do ( (     arr[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return arr );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p021 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p021().run());
  }
  public String run(){
    int sum=0 ;
    for(int i=1 ; i<10000 ; i++){
      if(isAmicable(i))sum+=i ;
    }
    return Integer.toString(sum);
  }
  private static boolean isAmicable(int n){
    int m=divisorSum(n);
    return m!=n && divisorSum(m)==n ;
  }
  private static int divisorSum(int n){
    int sum=0 ;
    for(int i=1 ; i<n ; i++){
      if(n % i==0)sum+=i ;
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p021 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p021.newp021().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i < 10000 do ( (     if (isAmicable(i)) then     sum := sum+(i) ; else skip )  ;     i := i + 1 ) ; 
     return ((sum) + "") );
  static   operation isAmicable( n : int) : boolean
  pre: true
  post: true
  activity: (     var m : int ; m := divisorSum(n) ;
     return m /= n & divisorSum(m) = n );
  static   operation divisorSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     if (n mod i = 0) then     sum := sum+(i) ; else skip )  ;     i := i + 1 ) ; 
     return sum );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String a=sc.next();
    String b[]=a.split("");
    int count=0 ;
    int half=a.length()/2 ;
    for(int i=0 ; i<half ; i++){
      if(! b[i] .equals(b[a.length()-1-i])){
        count+=1 ;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := sc.getCurrent() ;
    var b : Sequence(String) ; b := a->split("") ;
    var count : int ; count := 0 ;
    var half : int ; half := a->size() / 2 ;
        var i : int ; i := 0 ; while i < half do ( (     if (not(b[i+1] = b[a->size() - 1 - i+1])) then (     count := count+(1) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int count=0 ;
    for(int i=0,j=s.length()-1 ; i<j ; i++,j--){
      if(s.charAt(i)!=s.charAt(j))count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ;
    var j : int ; j := s->size() - 1 ; while i < j do ( (     if (s->at(i+1) /= s->at(j+1)) then     count := count + 1 ; else skip )  ;     i := i + 1 ;     j := j - 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] chars=sc.next().toCharArray();
    int counter=0 ;
    int length=chars.length ;
    for(int i=0 ; i<chars.length/2 ; i++){
      if(chars[i]==chars[length-1-i]){
      }
      else {
        counter++;
      }
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var chars : Sequence(String) ; chars := sc.getCurrent()->characters() ;
    var counter : int ; counter := 0 ;
    var length : int ; length := chars->size() ;
        var i : int ; i := 0 ; while i < chars->size() / 2 do ( (     if (chars[i+1] = chars[length - 1 - i+1]) then skip else (     counter := counter + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    String S=stdIn.next();
    int sum=S.length()/2 ;
    int k=S.length();
    int ans=0 ;
    for(int i=0 ; i<sum ; i++){
      k--;
      if(S.charAt(i)!=S.charAt(k)){
        ans++;
      }
    }
    System.out.println(ans);
    stdIn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := stdIn.getCurrent() ;
    var sum : int ; sum := S->size() / 2 ;
    var k : int ; k := S->size() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < sum do ( (     k := k - 1 ; 
     if (S->at(i+1) /= S->at(k+1)) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    int h=sc.nextInt();
    int s=sc.nextInt();
    int d=sc.nextInt();
    long n=sc.nextLong()*4 ;
    sc.close();
    Tea[] arr=new Tea[4];
    arr[0]=new Tea(q,1);
    arr[1]=new Tea(h,2);
    arr[2]=new Tea(s,4);
    arr[3]=new Tea(d,8);
    Arrays.parallelSort(arr);
    long ans=0 ;
    int i=0 ;
    while(n>0){
      long a=n/arr[i] .m ;
      ans+=arr[i] .p*a ;
      n %=arr[i] .m ;
      i++;
    }
    System.out.println(ans);
  }
  static class Tea implements Comparable<Tea>{
    int p,m ;
    public Tea(int p,int m){
      this.p=p ;
      this.m=m ;
    }
    public int compareTo(Tea o){
      return p*8/m-o.p*8/o.m ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var n : long ; n := sc.getCurrent()->toLong() * 4 ;
    skip ; 
    var arr : Sequence(Tea) ; arr := Integer.subrange(1,4)->collect(null) ;
    arr[0+1] := Tea.newTea(q, 1) ; 
    arr[1+1] := Tea.newTea(h, 2) ; 
    arr[2+1] := Tea.newTea(s, 4) ; 
    arr[3+1] := Tea.newTea(d, 8) ; 
    arr := arr->sort() ; 
    var ans : long ; ans := 0 ;
    var i : int ; i := 0 ;
    while (n > 0) do (     var a : long ; a := n / arr[i+1].m ;
     ans := ans+(arr[i+1].p * a) ; 
     n := n mod arr[i+1].m ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class Tea implements Comparable<Tea> {
   attribute p : int;
   static operation newTea( p : int, m : int) : Tea
  pre: true
  post: true
  activity:
  ( var self : Tea ;
    self := createTea();
    self.initialise(p, m);
    return self );
  operation initialise( p : int, m : int) : void
  pre: true  post: true
  activity: (     self.p := p ; 
     self.m := m );
   operation compareTo( o : Tea) : int
  pre: true
  post: true
  activity: (     return p * 8 / m - o.p * 8 / o.m );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    int l=0,r=s.length()-1 ;
    int count=0 ;
    while(l<r){
      if(s.charAt(l)!=s.charAt(r)){
        count++;
      }
      l++;
      r--;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
    var l : int ; l := 0 ;
    var r : int ; r := s->size() - 1 ;
    var count : int ; count := 0 ;
    while (l < r) do (     if (s->at(l+1) /= s->at(r+1)) then (     count := count + 1 ) else skip ; 
     l := l + 1 ; 
     r := r - 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean validate(long n){
    int count[]=new int[10];
    while(n>0){
      int r=(int)n % 10 ;
      if(count[r]==r)return false ;
      count[r]++;
      n/=10 ;
    }
    return true ;
  }
  public static void main(String[] args){
    long n=1552793 ;
    if(validate(n))System.out.println("True");
    else System.out.println("False");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation validate( n : long) : boolean
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,10)->collect(0) ;
     while (n > 0) do (     var r : int ; r := n->oclAsType(int) mod 10 ;
     if (count[r+1] = r) then     return false else skip ; 
     count[r+1] := count[r+1] + 1 ; 
     n := n/(10) ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 1552793 ;
     if (validate(n)) then     OclFile["System.out"].println("True") ; else     OclFile["System.out"].println("False") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1530 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int R=in.nextInt();
      int C=in.nextInt();
      char[][] A=new char[R][C];
      for(int r=0 ; r<R ; r++){
        for(int c=0 ; c<C ; c++){
          A[r][c]='0' ;
        }
      }
      for(int c=0 ; c<C ; c+=2){
        A[0][c]='1' ;
        A[R-1][c]='1' ;
      }
      for(int r=2 ; r<R-2 ; r+=2){
        A[r][0]='1' ;
        A[r][C-1]='1' ;
      }
      for(char[] row : A){
        System.out.println(new String(row));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1530 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var R : int ; R := in.getCurrent()->toInteger() ;
     var C : int ; C := in.getCurrent()->toInteger() ;
    var A : Sequence(Sequence(String)) ; A := Integer.subrange(1,R)->collect(Integer.subrange(1,C)->collect(0)) ;
        var r : int ; r := 0 ; while r < R do ( (         var c : int ; c := 0 ; while c < C do ( (     A[r+1][c+1] := '0' )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
        var c : int ; c := 0 ; while c < C do ( (     A[0+1][c+1] := '1' ; 
     A[R - 1+1][c+1] := '1' )  ;     c := c+(2) ) ; 
        var r : int ; r := 2 ; while r < R - 2 do ( (     A[r+1][0+1] := '1' ; 
     A[r+1][C - 1+1] := '1' )  ;     r := r+(2) ) ; 
    for (row : A) do ( (     OclFile["System.out"].println(StringLib.newString(row)) )  ) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeHundredSixty {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=input.nextInt();
      int m=input.nextInt();
      int[][] arrayOne=new int[n][m];
      for(int i=0 ; i<m ; i++){
        if(i % 2==0){
          System.out.print(1);
        }
        else {
          System.out.print(0);
        }
      }
      System.out.println();
      for(int i=0 ; i<m ; i++){
        System.out.print(0);
      }
      System.out.println();
      for(int i=0 ; i<n-4 ; i++){
        if(i % 2!=0){
          for(int j=0 ; j<m ; j++){
            System.out.print(0);
          }
        }
        else {
          System.out.print(1);
          for(int j=1 ; j<m-1 ; j++){
            System.out.print(0);
          }
          System.out.print(1);
        }
        System.out.println();
      }
      if(n!=3){
        for(int i=0 ; i<m ; i++){
          System.out.print(0);
        }
        System.out.println();
      }
      for(int i=0 ; i<m ; i++){
        if(i % 2==0){
          System.out.print(1);
        }
        else {
          System.out.print(0);
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var m : int ; m := input.getCurrent()->toInteger() ;
    var arrayOne : Sequence(Sequence(int)) ; arrayOne := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (     if (i mod 2 = 0) then (     OclFile["System.out"].print(1) ) else (     OclFile["System.out"].print(0) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
        var i : int ; i := 0 ; while i < m do ( (     OclFile["System.out"].print(0) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
        var i : int ; i := 0 ; while i < n - 4 do ( (     if (i mod 2 /= 0) then (         var j : int ; j := 0 ; while j < m do ( (     OclFile["System.out"].print(0) )  ;     j := j + 1 ) ) else (     OclFile["System.out"].print(1) ; 
         var j : int ; j := 1 ; while j < m - 1 do ( (     OclFile["System.out"].print(0) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print(1) ) ;  
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
    if (n /= 3) then (         var i : int ; i := 0 ; while i < m do ( (     OclFile["System.out"].print(0) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) else skip ; 
        var i : int ; i := 0 ; while i < m do ( (     if (i mod 2 = 0) then (     OclFile["System.out"].print(1) ) else (     OclFile["System.out"].print(0) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  double polyapothem(double n,double a){
    if(a<0 && n<0)return-1 ;
    return(a/(2*java.lang.Math.tan((180/n)*3.14159/180)));
  }
  public static void main(String args[]){
    double a=9,n=6 ;
    GFG g=new GFG();
    System.out.println(g.polyapothem(n,a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
   operation polyapothem( n : double, a : double) : double
  pre: true
  post: true
  activity: (     if (a < 0 & n < 0) then     return -1 else skip ; 
     return (a / (2 * java.lang.Math.tan((180 / n) * 3.14159 / 180))) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 9 ;
    var n : double ; n := 6 ;
     var g : GFG ; g := GFG.newGFG() ;
     OclFile["System.out"].println(g.polyapothem(n, a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    String[] line=br.readLine().split(" ");
    int n=Integer.parseInt(line[0]),d=Integer.parseInt(line[1]),m=Integer.parseInt(line[2]);
    int[] a=new int[n];
    line=br.readLine().split(" ");
    for(int i=0 ; i<n ; ++i){
      a[i]=Integer.parseInt(line[i]);
    }
    Arrays.sort(a);
    long[] prefix=new long[n+1];
    int max=-1 ;
    for(int i=0 ; i<n ; ++i){
      prefix[i+1]=prefix[i]+a[i];
      if(a[i]<=m &&(max==-1 || a[i]>=a[max])){
        max=i ;
      }
    }
    long res=0 ;
    int small=max+1 ;
    int big=n-small ;
    for(int x=Math.min(big,(n+d)/(d+1)); x*(d+1)>=big ; --x){
      res=Math.max(res,prefix[n]-prefix[n-x]+prefix[small]-prefix[(int)Math.max(0,(x-1)*d-(big-x))]);
    }
    bw.write(Long.toString(res));
    bw.newLine();
    br.close();
    bw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var n : int ; n := (line[0+1])->toInteger() ;
    var d : int ; d := (line[1+1])->toInteger() ;
    var m : int ; m := (line[2+1])->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    line := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (line[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var prefix : Sequence(long) ; prefix := Integer.subrange(1,n + 1)->collect(0) ;
    var max : int ; max := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     prefix[i + 1+1] := prefix[i+1] + a[i+1] ; 
     if (a[i+1] <= m & (max = -1 or a[i+1] >= a[max+1])) then (     max := i ) else skip )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
    var small : int ; small := max + 1 ;
    var big : int ; big := n - small ;
        var x : int ; x := Set{big, (n + d) / (d + 1)}->min() ; while x * (d + 1) >= big do ( (     res := Set{res, prefix[n+1] - prefix[n - x+1] + prefix[small+1] - prefix[Set{0, (x - 1) * d - (big - x)}->max()->oclAsType(int)+1]}->max() )  ;     x := x - 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void result(String s,int n){
    HashSet<String>st=new HashSet<String>();
    for(int i=0 ; i<(int)s.length(); i++){
      String ans="" ;
      for(int j=i ; j<(int)s.length(); j++){
        ans+=s.charAt(j);
        if(ans.length()==n){
          st.add(ans);
          break ;
        }
      }
    }
    for(String it : st)System.out.print(it+" ");
  }
  public static void main(String[] args){
    String s="abca" ;
    int n=3 ;
    result(s,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation result( s : String, n : int) : void
  pre: true
  post: true
  activity: (     var st : Set(String) ; st := Set{} ;
         var i : int ; i := 0 ; while i < s->size()->oclAsType(int) do ( (     var ans : String ; ans := "" ;
         var j : int ; j := i ; while j < s->size()->oclAsType(int) do ( (     ans := ans+(s->at(j+1)) ; 
     if (ans->size() = n) then (     st := st->including(ans) ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     for (it : st) do (     OclFile["System.out"].print(it + " ") ;  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abca" ;
     var n : int ; n := 3 ;
     execute result(s, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class pb1 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int d=in.nextInt();
    int m=in.nextInt();
    ArrayList<Integer>a=new ArrayList<>();
    ArrayList<Integer>b=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      int v=in.nextInt();
      if(v<=m)b.add(v);
      else a.add(v);
    }
    Collections.sort(a);
    Collections.sort(b);
    long[] apref=new long[a.size()+1];
    long[] bpref=new long[n+1];
    for(int i=1 ; i<=n ; i++){
      if(i<=a.size()){
        apref[i]=apref[i-1]+a.get(a.size()-i);
      }
      if(i<=b.size()){
        bpref[i]=bpref[i-1]+b.get(b.size()-i);
      }
      else bpref[i]=bpref[i-1];
    }
    if(a.size()==0)System.out.println(bpref[n]);
    else {
      long ans=0 ;
      for(int ai=1 ; ai<=a.size()&&(ai-1)*(d+1)+1<=n ; ai++){
        ans=Math.max(ans,apref[ai]+bpref[n-(ai-1)*(d+1)-1]);
      }
      System.out.println(ans);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class pb1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
    var b : Sequence(int) ; b := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var v : int ; v := in.getCurrent()->toInteger() ;
     if (v <= m) then     b := b->including(v) ; else     a := a->including(v) ; )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    var apref : Sequence(long) ; apref := Integer.subrange(1,a->size() + 1)->collect(0) ;
    var bpref : Sequence(long) ; bpref := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     if (i <= a->size()) then (     apref[i+1] := apref[i - 1+1] + a->at(a->size() - i+1) ) else skip ; 
     if (i <= b->size()) then (     bpref[i+1] := bpref[i - 1+1] + b->at(b->size() - i+1) ) else     bpref[i+1] := bpref[i - 1+1] ; )  ;     i := i + 1 ) ; 
    if (a->size() = 0) then     OclFile["System.out"].println(bpref[n+1]) else (     var ans : long ; ans := 0 ;
         var ai : int ; ai := 1 ; while ai <= a->size() & (ai - 1) * (d + 1) + 1 <= n do ( (     ans := Set{ans, apref[ai+1] + bpref[n - (ai - 1) * (d + 1) - 1+1]}->max() )  ;     ai := ai + 1 ) ; 
     OclFile["System.out"].println(ans) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String op=sc.next();
      char[] s1=sc.next().toCharArray();
      char[] s2=sc.next().toCharArray();
      s="" ;
      int p1=0,p2=0 ;
      int l1=s1.length,l2=s2.length ;
      while(p1<l1 && p2<l2){
        if(s1[p1]==s2[p2]){
          s+=s1[p1];
          p1++;
          p2++;
        }
        else if(s1[p1]=='('){
          p1=read(s1,p1,(op.equals("u")? true : false));
        }
        else {
          p2=read(s2,p2,(op.equals("u")? true : false));
        }
      }
      if(op.equals("u")){
        while(p1<l1)s+=s1[p1++];
        while(p2<l2)s+=s2[p2++];
      }
      System.out.println(s);
    }
  }
  private static String s ;
  private static int read(char[] t,int p,boolean flg){
    int level=0 ;
    do {
      if(flg)s+=t[p];
      if(t[p]=='(')level++;
      else if(t[p]==')')level--;
      p++;
    }
    while(level!=0);
    return p ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var op : String ; op := sc.getCurrent() ;
     var s1 : Sequence(String) ; s1 := sc.getCurrent()->characters() ;
    var s2 : Sequence(String) ; s2 := sc.getCurrent()->characters() ;
    s := "" ; 
    var p1 : int ; p1 := 0 ;
    var p2 : int ; p2 := 0 ;
    var l1 : int ; l1 := s1->size() ;
    var l2 : int ; l2 := s2->size() ;
    while (p1 < l1 & p2 < l2) do (     if (s1[p1+1] = s2[p2+1]) then (     s := s+(s1[p1+1]) ; 
     p1 := p1 + 1 ; 
     p2 := p2 + 1 ) else     if (s1[p1+1] = '(') then (     p1 := read(s1, p1, (if op = "u" then true else false endif)) ) else (     p2 := read(s2, p2, (if op = "u" then true else false endif)) ) ;  ) ; 
    if (op = "u") then (     while (p1 < l1) do      s := s + s1[p1+1]  ; p1 := p1 + 1 ; ; 
     while (p2 < l2) do      s := s + s2[p2+1]  ; p2 := p2 + 1 ; ) else skip ; 
    OclFile["System.out"].println(s) ; 
 ) );
  static   attribute s : String;
  static   operation read( t : Sequence(String), p : int, flg : boolean) : int
  pre: true
  post: true
  activity: (     var level : int ; level := 0 ;
   while true do ((     if (flg) then     s := s+(t[p+1]) ; else skip ; 
     if (t[p+1] = '(') then     level := level + 1 else     if (t[p+1] = ')') then     level := level - 1 ; else skip ; ;  
     p := p + 1 ) ;
    if (level /= 0) then skip else break) ; 
     return p );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String op=sc.next();
      char[] s1=sc.next().toCharArray();
      char[] s2=sc.next().toCharArray();
      s="" ;
      int p1=0,p2=0 ;
      int l1=s1.length,l2=s2.length ;
      while(p1<l1 && p2<l2){
        if(s1[p1]==s2[p2]){
          s+=s1[p1];
          p1++;
          p2++;
        }
        else if(s1[p1]=='('){
          p1=read(s1,p1,(op.equals("u")? true : false));
        }
        else {
          p2=read(s2,p2,(op.equals("u")? true : false));
        }
      }
      if(op.equals("u")){
        while(p1<l1)s+=s1[p1++];
        while(p2<l2)s+=s2[p2++];
      }
      System.out.println(s);
    }
  }
  private static String s ;
  private static int read(char[] t,int p,boolean flg){
    int level=0 ;
    do {
      if(flg)s+=t[p];
      if(t[p]=='(')level++;
      else if(t[p]==')')level--;
      p++;
    }
    while(level!=0);
    return p ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var op : String ; op := sc.getCurrent() ;
     var s1 : Sequence(String) ; s1 := sc.getCurrent()->characters() ;
    var s2 : Sequence(String) ; s2 := sc.getCurrent()->characters() ;
    s := "" ; 
    var p1 : int ; p1 := 0 ;
    var p2 : int ; p2 := 0 ;
    var l1 : int ; l1 := s1->size() ;
    var l2 : int ; l2 := s2->size() ;
    while (p1 < l1 & p2 < l2) do (     if (s1[p1+1] = s2[p2+1]) then (     s := s+(s1[p1+1]) ; 
     p1 := p1 + 1 ; 
     p2 := p2 + 1 ) else     if (s1[p1+1] = '(') then (     p1 := read(s1, p1, (if op = "u" then true else false endif)) ) else (     p2 := read(s2, p2, (if op = "u" then true else false endif)) ) ;  ) ; 
    if (op = "u") then (     while (p1 < l1) do      s := s + s1[p1+1]  ; p1 := p1 + 1 ; ; 
     while (p2 < l2) do      s := s + s2[p2+1]  ; p2 := p2 + 1 ; ) else skip ; 
    OclFile["System.out"].println(s) ; 
 ) );
  static   attribute s : String;
  static   operation read( t : Sequence(String), p : int, flg : boolean) : int
  pre: true
  post: true
  activity: (     var level : int ; level := 0 ;
   while true do ((     if (flg) then     s := s+(t[p+1]) ; else skip ; 
     if (t[p+1] = '(') then     level := level + 1 else     if (t[p+1] = ')') then     level := level - 1 ; else skip ; ;  
     p := p + 1 ) ;
    if (level /= 0) then skip else break) ; 
     return p );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countNumbers(int L,int R,int K){
    if(K==9){
      K=0 ;
    }
    int totalnumbers=R-L+1 ;
    int factor9=totalnumbers/9 ;
    int rem=totalnumbers % 9 ;
    int ans=factor9 ;
    for(int i=R ; i>R-rem ; i--){
      int rem1=i % 9 ;
      if(rem1==K){
        ans++;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int L=10 ;
    int R=22 ;
    int K=3 ;
    System.out.println(countNumbers(L,R,K));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countNumbers( L : int, R : int, K : int) : int
  pre: true
  post: true
  activity: (     if (K = 9) then (     K := 0 ) else skip ; 
     var totalnumbers : int ; totalnumbers := R - L + 1 ;
    var factor9 : int ; factor9 := totalnumbers / 9 ;
    var rem : int ; rem := totalnumbers mod 9 ;
    var ans : int ; ans := factor9 ;
        var i : int ; i := R ; while i > R - rem do ( (     var rem1 : int ; rem1 := i mod 9 ;
     if (rem1 = K) then (     ans := ans + 1 ) else skip )  ;     i := i - 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 10 ;
     var R : int ; R := 22 ;
     var K : int ; K := 3 ;
     OclFile["System.out"].println(countNumbers(L, R, K)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    while(sc.hasNext()){
      char query=sc.next().charAt(0);
      String tree1=sc.next();
      String tree2=sc.next();
      Node root=new Node();
      parse(tree1,0,root,1);
      parse(tree2,0,root,2);
      root.write(query=='u');
      System.out.println();
    }
  }
  static int parse(String tree,int pos,Node cur,int val){
    cur.val+=val ;
++pos ;
    if(tree.charAt(pos)=='('){
      if(cur.left==null){
        cur.left=new Node();
      }
      pos=parse(tree,pos,cur.left,val);
    }
++pos ;
    if(tree.charAt(pos)=='('){
      if(cur.right==null){
        cur.right=new Node();
      }
      pos=parse(tree,pos,cur.right,val);
    }
    return pos+1 ;
  }
  static class Node {
    Node left ;
    Node right ;
    int val=0 ;
    boolean match(boolean union){
      if(union){
        return this.val>0 ;
      }
      else {
        return this.val==3 ;
      }
    }
    void write(boolean union){
      if(! match(union))return ;
      System.out.print("(");
      if(this.left!=null)this.left.write(union);
      System.out.print(",");
      if(this.right!=null)this.right.write(union);
      System.out.print(")");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     var query : String ; query := sc.getCurrent()->at(0+1) ;
     var tree1 : String ; tree1 := sc.getCurrent() ;
    var tree2 : String ; tree2 := sc.getCurrent() ;
    var root : Node ; root := Node.newNode() ;
    execute parse(tree1, 0, root, 1) ; 
    execute parse(tree2, 0, root, 2) ; 
    root.write(query = 'u') ; 
    OclFile["System.out"].println() ; 
 ) );
  static   operation parse( tree : String, pos : int, cur : Node, val : int) : int
  pre: true
  post: true
  activity: (     cur.val := cur.val+(val) ; 
     pos := pos + 1 ; 
    if (tree->at(pos+1) = '(') then (     if (cur.left = null) then (     cur.left := Node.newNode() ) else skip ; 
     pos := parse(tree, pos, cur.left, val) ) else skip ; 
    pos := pos + 1 ; 
    if (tree->at(pos+1) = '(') then (     if (cur.right = null) then (     cur.right := Node.newNode() ) else skip ; 
     pos := parse(tree, pos, cur.right, val) ) else skip ; 
    return pos + 1 
 );
  static class Node {
   attribute left : Node;
   attribute right : Node;
   attribute val : int := 0;
   operation match( union : boolean) : boolean
  pre: true
  post: true
  activity: (     if (union) then (     return self.val > 0 ) else (     return self.val = 3 ) );
   operation write( union : boolean) : void
  pre: true
  post: true
  activity: (     if (not(match(union))) then     return else skip ; 
     OclFile["System.out"].print("(") ; 
    if (self.left /= null) then     self.left.write(union) ; else skip ; 
    OclFile["System.out"].print(",") ; 
    if (self.right /= null) then     self.right.write(union) ; else skip ; 
    OclFile["System.out"].print(")") ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static class Node {
    public Node l,r ;
    public Node(Node l_,Node r_){
      l=l_ ;
      r=r_ ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    for(; sc.hasNext(); ){
      char type=sc.next().charAt(0);
      String x=sc.next();
      String y=sc.next();
      pos=0 ;
      Node nx=makeNode(x);
      pos=0 ;
      Node ny=makeNode(y);
      System.out.println(toString(type=='u' ? union(nx,ny): intersect(nx,ny)));
    }
  }
  private static int pos ;
  private static Node makeNode(String s){
    Node node=new Node(null,null);
    if(s.charAt(pos)=='(')pos++;
    if(s.charAt(pos)=='('){
      node.l=makeNode(s);
    }
    if(s.charAt(pos)==',')pos++;
    if(s.charAt(pos)=='('){
      node.r=makeNode(s);
    }
    if(s.charAt(pos)==')')pos++;
    return node ;
  }
  private static Node union(Node x,Node y){
    if(x==null){
      return y ;
    }
    else if(y==null){
      return x ;
    }
    return new Node(union(x.l,y.l),union(x.r,y.r));
  }
  private static Node intersect(Node x,Node y){
    if(x==null || y==null){
      return null ;
    }
    return new Node(intersect(x.l,y.l),intersect(x.r,y.r));
  }
  private static String toString(Node node){
    return node==null ? "" : "("+toString(node.l)+","+toString(node.r)+")" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Node {
   attribute l : Node;
   static operation newNode( l_ : Node, r_ : Node) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(l_, r_);
    return self );
  operation initialise( l_ : Node, r_ : Node) : void
  pre: true  post: true
  activity: (     l := l_ ; 
     r := r_ );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while sc.hasNext() do ( (     var type : String ; type := sc.getCurrent()->at(0+1) ;
     var x : String ; x := sc.getCurrent() ;
    var y : String ; y := sc.getCurrent() ;
    pos := 0 ; 
    var nx : Node ; nx := makeNode(x) ;
    pos := 0 ; 
    var ny : Node ; ny := makeNode(y) ;
    OclFile["System.out"].println(toString(if type = 'u' then union(nx, ny) else intersect(nx, ny) endif)) ; 
 )  ) );
  static   attribute pos : int;
  static   operation makeNode( s : String) : Node
  pre: true
  post: true
  activity: (     var node : Node ; node := Node.newNode(null, null) ;
     if (s->at(pos+1) = '(') then     pos := pos + 1 ; else skip ; 
    if (s->at(pos+1) = '(') then (     node.l := makeNode(s) ) else skip ; 
    if (s->at(pos+1) = ',') then     pos := pos + 1 ; else skip ; 
    if (s->at(pos+1) = '(') then (     node.r := makeNode(s) ) else skip ; 
    if (s->at(pos+1) = ')') then     pos := pos + 1 ; else skip ; 
    return node 
 );
  static   operation union( x : Node, y : Node) : Node
  pre: true
  post: true
  activity: (     if (x = null) then (     return y ) else     if (y = null) then (     return x ) else skip ; ;  
     return Node.newNode(union(x.l, y.l), union(x.r, y.r)) );
  static   operation intersect( x : Node, y : Node) : Node
  pre: true
  post: true
  activity: (     if (x = null or y = null) then (     return null ) else skip ; 
     return Node.newNode(intersect(x.l, y.l), intersect(x.r, y.r)) );
  static   operation toString( node : Node) : String
  pre: true
  post: true
  activity: (     return if node = null then "" else "(" + toString(node.l) + "," + toString(node.r) + ")" endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader a=new BufferedReader(new InputStreamReader(System.in));
    String b ;
    String c[];
    while((b=a.readLine())!=null){
      c=b.split(" ");
      print_iu(c[1],c[2],c[0]);
    }
  }
  static void print_iu(String a,String b,String x){
    int i=0,j=0 ;
    boolean y ;
    if(x.charAt(0)=='i'){
      y=false ;
    }
    else {
      y=true ;
    }
    while(i<a.length()&& j<b.length()){
      if(a.charAt(i)==b.charAt(j)){
        System.out.print(a.charAt(i));
++i ;
++j ;
      }
      else if(a.charAt(i)=='('){
        int c=0 ;
        while(true){
          if(y){
            System.out.print(a.charAt(i));
          }
          if(a.charAt(i)=='('){
++c ;
          }
          else if(a.charAt(i)==')'){
--c ;
            if(c==0){
++i ;
              break ;
            }
          }
++i ;
        }
      }
      else if(b.charAt(j)=='('){
        int c=0 ;
        while(true){
          if(y){
            System.out.print(b.charAt(j));
          }
          if(b.charAt(j)=='('){
++c ;
          }
          else if(b.charAt(j)==')'){
--c ;
            if(c==0){
++j ;
              break ;
            }
          }
++j ;
        }
      }
    }
    System.out.println("");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : OclFile ; a := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var b : String ;
     var c : Sequence(String) ;
         b := a.readLine() ;
    while ((b) /= null) do (    skip ; (     c := b->split(" ") ; 
     execute print_iu(c[1+1], c[2+1], c[0+1]) ) ;     b := a.readLine() ;
 ) );
  static   operation print_iu( a : String, b : String, x : String) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var j : int ; j := 0 ;
     var y : boolean ;
    if (x->at(0+1) = 'i') then (     y := false ) else (     y := true ) ;  
    while (i < a.length() & j < b->size()) do (     if (a.charAt(i) = b->at(j+1)) then (     OclFile["System.out"].print(a.charAt(i)) ; 
     i := i + 1 ; 
     j := j + 1 ) else     if (a.charAt(i) = '(') then (     var c : int ; c := 0 ;
     while (true) do (     if (y) then (     OclFile["System.out"].print(a.charAt(i)) ) else skip ; 
     if (a.charAt(i) = '(') then (     c := c + 1 ) else     if (a.charAt(i) = ')') then (     c := c - 1 ; 
     if (c = 0) then (     i := i + 1 ; 
     break ) else skip ) else skip ; ;  
     i := i + 1 ) ) else     if (b->at(j+1) = '(') then (     var c : int ; c := 0 ;
     while (true) do (     if (y) then (     OclFile["System.out"].print(b->at(j+1)) ) else skip ; 
     if (b->at(j+1) = '(') then (     c := c + 1 ) else     if (b->at(j+1) = ')') then (     c := c - 1 ; 
     if (c = 0) then (     j := j + 1 ; 
     break ) else skip ) else skip ; ;  
     j := j + 1 ) ) else skip ; ;  ) ; 
    OclFile["System.out"].println("") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    int count=0 ;
    while(n>1){
      n=(n+(n % 3==0 ? 0 : 3-n % 3))/3 ;
      count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var count : int ; count := 0 ;
    while (n > 1) do (     n := (n + (if n mod 3 = 0 then 0 else 3 - n mod 3 endif)) / 3 ; 
     count := count + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[])throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int N=Integer.parseInt(br.readLine());
    ArrayList<Integer>min=new ArrayList<Integer>();
    min.add(0);
    min.add(2);
    int tmp_min=2 ;
    int size_worse ;
    for(int i=3 ; i<=N ; i++){
      if(i % 3==0){
        size_worse=i/3 ;
      }
      else {
        size_worse=i/3+1 ;
      }
      if(size_worse>=tmp_min){
        min.add(i);
        tmp_min=i ;
        i=3*(i-1);
      }
    }
    System.out.println(min.size()-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var N : int ; N := (br.readLine())->toInteger() ;
    var min : Sequence(int) ; min := Sequence{} ;
    min := min->including(0) ; 
    min := min->including(2) ; 
    var tmp_min : int ; tmp_min := 2 ;
    var size_worse : int ;
        var i : int ; i := 3 ; while i <= N do ( (     if (i mod 3 = 0) then (     size_worse := i / 3 ) else (     size_worse := i / 3 + 1 ) ;  
     if (size_worse >= tmp_min) then (     min := min->including(i) ; 
     tmp_min := i ; 
     i := 3 * (i - 1) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min->size() - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
class Main {
  public static Scanner sc=new Scanner(in);
  public static Random rand=new Random();
  public void run(){
    long n=sc.nextLong();
    int t=1 ;
    for(long k=3 ; k<n ; k*=3,t++);
    ln(t);
  }
  public static void main(String[] args){
    new Main().run();
  }
  public int[] nextIntArray(int n){
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=sc.nextInt();
    }
    return res ;
  }
  public static void pr(Object o){
    out.print(o);
  }
  public static void ln(Object o){
    out.println(o);
  }
  public static void ln(){
    out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(in);
  static   attribute rand : OclRandom := OclRandom.newOclRandom();
   operation run() : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.getCurrent()->toLong() ;
     var t : int ; t := 1 ;
         var k : long ; k := 3 ; while k < n do (   ;     k := k*(3) ;     t := t + 1 ) ; 
     execute ln(t) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return res );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     out.println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
public class Main {
  public static void main(String[] args){
    int N=nextInt();
    int count=0 ;
    while(N>1){
      N=(int)Math.ceil((double)N/3);
      count++;
    }
    System.out.println(count);
  }
  static int nextInt(){
    int c ;
    try {
      c=System.in.read();
      while(c!='-' &&(c<'0' || c>'9'))c=System.in.read();
      if(c=='-')return-nextInt();
      int res=0 ;
      while(c>='0' && c<='9'){
        res=res*10+c-'0' ;
        c=System.in.read();
      }
      return res ;
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return-1 ;
  }
  static char nextChar(){
    try {
      int b=System.in.read();
      while(b!=-1 &&(b==' ' || b=='\r' || b=='\n'));
      if(b==-1)return 0 ;
      return(char)b ;
    }
    catch(IOException e){
    }
    return 0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := nextInt() ;
     var count : int ; count := 0 ;
     while (N > 1) do (     N := (N->oclAsType(double) / 3)->ceil()->oclAsType(int) ; 
     count := count + 1 ) ; 
     OclFile["System.out"].println(count) );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     var c : int ;
     try (     c := OclFile["System.in"].read() ; 
     while (c /= '-' & (c < '0' or c > '9')) do     c := OclFile["System.in"].read() ; ; 
    if (c = '-') then     return -nextInt() else skip ; 
    var res : int ; res := 0 ;
    while (c >= '0' & c <= '9') do (     res := res * 10 + c - ('0')->char2byte() ; 
     c := OclFile["System.in"].read() ) ; 
    return res 
 )   catch (e : IOException) do (     e.printStackTrace() )
     return -1 );
  static   operation nextChar() : String
  pre: true
  post: true
  activity: (     try (     var b : int ; b := OclFile["System.in"].read() ;
     while (b /= -1 & (b = ' ' or b = '\r' or b = '
')) do  ; 
     if (b = -1) then     return 0 else skip ; 
     return b->oclAsType(String) )   catch (e : IOException) do skip
     return 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int h=100 ;
    int w=100 ;
    final int WHITE=0 ;
    final int BLACK=1 ;
    int[][] grd=new int[h][w];
    for(int i=0 ; i<h/2 ; i++){
      for(int j=0 ; j<w ; j++){
        grd[i][j]=BLACK ;
      }
    }
    for(int i=0 ; i<a-1 ; i++){
      int y=i*2/w*2 ;
      int x=i*2 % w+y % 2 % 2 ;
      grd[y][x]=WHITE ;
    }
    for(int i=0 ; i<b-1 ; i++){
      int y=h-i*2/w*2-1 ;
      int x=w-i*2 % w-1-y % 2 % 2 ;
      grd[y][x]=BLACK ;
    }
    System.out.println(h+" "+w);
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        System.out.print((grd[i][j]==WHITE)? '.' : '#');
      }
      System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var h : int ; h := 100 ;
    var w : int ; w := 100 ;
    var WHITE : int ; WHITE := 0 ;
    var BLACK : int ; BLACK := 1 ;
    var grd : Sequence(Sequence(int)) ; grd := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h / 2 do ( (         var j : int ; j := 0 ; while j < w do ( (     grd[i+1][j+1] := BLACK )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a - 1 do ( (     var y : int ; y := i * 2 / w * 2 ;
     var x : int ; x := i * 2 mod w + y mod 2 mod 2 ;
     grd[y+1][x+1] := WHITE )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < b - 1 do ( (     var y : int ; y := h - i * 2 / w * 2 - 1 ;
     var x : int ; x := w - i * 2 mod w - 1 - y mod 2 mod 2 ;
     grd[y+1][x+1] := BLACK )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(h + " " + w) ; 
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     OclFile["System.out"].print(if (grd[i+1][j+1] = WHITE) then '.' else '#' endif) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println("") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static void solve(){
    double n=in.nextInt();
    int cnt=0 ;
    while(n>1){
      n=(int)Math.ceil(n/3);
      cnt++;
    }
    out.println(cnt);
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    solve();
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : double ; n := in.getCurrent()->toInteger() ;
     var cnt : int ; cnt := 0 ;
     while (n > 1) do (     n := (n / 3)->ceil()->oclAsType(int) ; 
     cnt := cnt + 1 ) ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    execute solve() ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int peakIndexInMountainArray(int[] A){
    int lo=0,hi=A.length-1 ;
    while(lo<hi){
      int mid=(lo+hi)/2 ;
      if(A[mid]<A[mid+1])lo=mid+1 ;
      else hi=mid ;
    }
    return lo ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation peakIndexInMountainArray( A : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var lo : int ; lo := 0 ;
    var hi : int ; hi := A->size() - 1 ;
     while (lo < hi) do (     var mid : int ; mid := (lo + hi) / 2 ;
     if (A[mid+1] < A[mid + 1+1]) then     lo := mid + 1 ; else     hi := mid ; ) ; 
     return lo );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      long a=in.nextLong();
      long b=in.nextLong();
      long c=in.nextLong();
      long d=in.nextLong();
      long e=in.nextLong();
      long f=in.nextLong();
      long y=Math.min(c,b);
      long x=a ;
      if(y+x<=d){
        System.out.println(y*f+x*e);
      }
      else if(f>=e){
        System.out.println(Math.min(y,d)*f+(d-Math.min(y,d))*e);
      }
      else if(e>=f){
        System.out.println(Math.min(x,d)*e+(d-Math.min(x,d))*f);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var a : long ; a := in.getCurrent()->toLong() ;
     var b : long ; b := in.getCurrent()->toLong() ;
    var c : long ; c := in.getCurrent()->toLong() ;
    var d : long ; d := in.getCurrent()->toLong() ;
    var e : long ; e := in.getCurrent()->toLong() ;
    var f : long ; f := in.getCurrent()->toLong() ;
    var y : long ; y := Set{c, b}->min() ;
    var x : long ; x := a ;
    if (y + x <= d) then (     OclFile["System.out"].println(y * f + x * e) ) else     if (f >= e) then (     OclFile["System.out"].println(Set{y, d}->min() * f + (d - Set{y, d}->min()) * e) ) else     if (e >= f) then (     OclFile["System.out"].println(Set{x, d}->min() * e + (d - Set{x, d}->min()) * f) ) else skip ; ;  ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static boolean checkIsAP(int arr[],int n){
    if(n==1)return true ;
    Arrays.sort(arr);
    int d=arr[1]-arr[0];
    for(int i=2 ; i<n ; i++)if(arr[i]-arr[i-1]!=d)return false ;
    return true ;
  }
  public static void main(String[] args){
    int arr[]={
      20,15,5,0,10 };
      int n=arr.length ;
      if(checkIsAP(arr,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkIsAP( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 1) then     return true else skip ; 
     arr := arr->sort() ; 
    var d : int ; d := arr[1+1] - arr[0+1] ;
        var i : int ; i := 2 ; while i < n do (     if (arr[i+1] - arr[i - 1+1] /= d) then     return false else skip ;  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{20,15,5,0,10} ;
     var n : int ; n := arr->size() ;
     if (checkIsAP(arr, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static boolean checkIsAP(int arr[],int n){
    if(n==1)return true ;
    Arrays.sort(arr);
    int d=arr[1]-arr[0];
    for(int i=2 ; i<n ; i++)if(arr[i]-arr[i-1]!=d)return false ;
    return true ;
  }
  public static void main(String[] args){
    int arr[]={
      20,15,5,0,10 };
      int n=arr.length ;
      if(checkIsAP(arr,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkIsAP( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 1) then     return true else skip ; 
     arr := arr->sort() ; 
    var d : int ; d := arr[1+1] - arr[0+1] ;
        var i : int ; i := 2 ; while i < n do (     if (arr[i+1] - arr[i - 1+1] /= d) then     return false else skip ;  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{20,15,5,0,10} ;
     var n : int ; n := arr->size() ;
     if (checkIsAP(arr, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean areElementsContiguous(int arr[],int n){
    Arrays.sort(arr);
    for(int i=1 ; i<n ; i++)if(arr[i]-arr[i-1]>1)return false ;
    return true ;
  }
  public static void main(String[] args){
    int arr[]={
      5,2,3,6,4,4,6,6 };
      int n=arr.length ;
      if(areElementsContiguous(arr,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation areElementsContiguous( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
         var i : int ; i := 1 ; while i < n do (     if (arr[i+1] - arr[i - 1+1] > 1) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,2,3,6,4,4,6,6} ;
     var n : int ; n := arr->size() ;
     if (areElementsContiguous(arr, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean ifPossible(int arr[],int n){
    int copy[]=Arrays.copyOf(arr,arr.length);
    Arrays.sort(copy);
    for(int i=0 ; i<n ; i++){
      if(!(arr[i]==copy[i])&& !(arr[n-1-i]==copy[i]))return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    int arr[]={
      1,7,6,4,5,3,2,8 };
      int n=arr.length ;
      if(ifPossible(arr,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation ifPossible( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var copy : Sequence(int) ; copy := arr.subrange(1,arr->size()) ;
     copy := copy->sort() ; 
         var i : int ; i := 0 ; while i < n do ( (     if (not((arr[i+1] = copy[i+1])) & not((arr[n - 1 - i+1] = copy[i+1]))) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,7,6,4,5,3,2,8} ;
     var n : int ; n := arr->size() ;
     if (ifPossible(arr, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.nextLine();
    int N=S.length();
    long ret=0 ;
    for(int i=0 ; i<Math.pow(2,N-1); i++){
      int p=N-1 ;
      for(int j=0 ; j<N-1 ; j++){
        if(((i>>j)& 1)==1){
          String str=S.substring(N-1-j,p+1);
          p=(N-1-j)-1 ;
          ret+=Long.parseLong(str);
        }
      }
      ret+=Long.parseLong(S.substring(0,p+1));
    }
    System.out.println(ret);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.nextLine() ;
    var N : int ; N := S->size() ;
    var ret : long ; ret := 0 ;
        var i : int ; i := 0 ; while i < 2->pow((N)->char2byte() - 1) do ( (     var p : int ; p := (N)->char2byte() - 1 ;
         var j : int ; j := 0 ; while j < (N)->char2byte() - 1 do ( (     if ((((i/(2->pow(j)))->oclAsType(long)) & 1) = 1) then (     var str : String ; str := S.subrange((N)->char2byte() - 1 - j+1,p + 1) ;
     p := ((N)->char2byte() - 1 - j) - 1 ; 
     ret := ret+((str)->toLong()) ) else skip )  ;     j := j + 1 ) ; 
     ret := ret+((S.subrange(0+1,p + 1))->toLong()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ret) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String s=scanner.nextLine();
    long length=s.length();
    scanner.close();
    long sum=0 ;
    for(int i=0 ; i<length ; i++){
      long left=(long)Math.ceil(Math.pow(2,i-1));
      for(int j=i+1 ; j<length+1 ; j++){
        sum+=(long)left*Long.valueOf(s.substring(i,j))*Math.ceil(Math.pow(2,length-j-1));
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scanner.nextLine() ;
    var length : long ; length := s->size() ;
    skip ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < length do ( (     var left : long ; left := (2->pow(i - 1))->ceil()->oclAsType(long) ;
         var j : int ; j := i + 1 ; while j < length + 1 do ( (     sum := sum+(left->oclAsType(long) * (s.subrange(i+1,j))->toLong() * (2->pow((length)->char2byte() - j - 1))->ceil()) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int[] sequence ;
  public static void main(String[] args){
    new Main().solve();
  }
  public void solve(){
    long sum=0 ;
    String line=new Scanner(System.in).nextLine();
    sequence=new int[line.length()];
    for(int i=0 ; i<line.length(); i++){
      sequence[i]=Character.getNumericValue(line.charAt(i));
    }
    for(int i=0 ; i<(int)Math.pow(2.0,line.length()-1); i++){
      sum+=addition(i);
    }
    System.out.println(sum);
  }
  public long addition(int pattern){
    boolean isOne=false ;
    long temp=sequence[0];
    long sum=0 ;
    for(int i=0 ; i<sequence.length-1 ; i++){
      if((pattern>>i & 0x1)==1){
        sum+=temp ;
        temp=sequence[i+1];
        isOne=true ;
      }
      else {
        isOne=false ;
        temp*=10 ;
        temp+=sequence[i+1];
      }
    }
    sum+=temp ;
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sequence : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     var line : String ; line := OclFile.newOclFile_Read(OclFile["System.in"]).nextLine() ;
    sequence := Integer.subrange(1,line->size())->collect(0) ; 
        var i : int ; i := 0 ; while i < line->size() do ( (     sequence[i+1] := ("" + line->at(i+1))->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 2.0->pow(line->size() - 1)->oclAsType(int) do ( (     sum := sum+(addition(i)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
   operation addition( pattern : int) : long
  pre: true
  post: true
  activity: (     var isOne : boolean ; isOne := false ;
     var temp : long ; temp := sequence[0+1] ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < sequence->size() - 1 do ( (     if ((MathLib.bitwiseAnd((pattern/(2->pow(i)))->oclAsType(long),0x1)) = 1) then (     sum := sum+(temp) ; 
     temp := sequence[i + 1+1] ; 
     isOne := true ) else (     isOne := false ; 
     temp := temp*(10) ; 
     temp := temp+(sequence[i + 1+1]) ) )  ;     i := i + 1 ) ; 
    sum := sum+(temp) ; 
    return sum 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    String str=s.next();
    long result=0 ;
    for(int i=0 ; i<str.length(); i++){
      int no=Integer.parseInt(""+str.charAt(i));
      for(int j=0 ; j<str.length()-i ; j++){
        result+=no*Math.pow(10,j)*Math.pow(2,i)*Math.pow(2,Math.max(str.length()-2-j-i,0));
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := s.getCurrent() ;
    var result : long ; result := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     var no : int ; no := ("" + str->at(i+1))->toInteger() ;
         var j : int ; j := 0 ; while j < str->size() - i do ( (     result := result+(no * 10->pow(j) * 2->pow(i) * 2->pow(Set{str->size() - 2 - j - i, 0}->max())) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    sc.close();
    System.out.println("100 100");
    int[][] map=new int[100][100];
    for(int i=50 ; i<100 ; i++){
      for(int j=0 ; j<100 ; j++){
        map[i][j]=1 ;
      }
    }
    int cw=1,cb=1 ;
    while(cw<a){
      int ti=cw/50 ;
      int tj=cw % 50 ;
      if(ti % 2==0){
        map[ti*2][tj*2]=1 ;
      }
      else {
        map[ti*2][tj*2+1]=1 ;
      }
      cw++;
    }
    while(cb<b){
      int ti=cb/50 ;
      int tj=cb % 50 ;
      if(ti % 2==0){
        map[99-ti*2][tj*2]=0 ;
      }
      else {
        map[99-ti*2][tj*2+1]=0 ;
      }
      cb++;
    }
    for(int i=0 ; i<100 ; i++){
      String ans="" ;
      for(int j=0 ; j<100 ; j++){
        if(map[i][j]==0){
          ans+="#" ;
        }
        else {
          ans+="." ;
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    skip ; 
    OclFile["System.out"].println("100 100") ; 
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(0)) ;
        var i : int ; i := 50 ; while i < 100 do ( (         var j : int ; j := 0 ; while j < 100 do ( (     map[i+1][j+1] := 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var cw : int ; cw := 1 ;
    var cb : int ; cb := 1 ;
    while (cw < a) do (     var ti : int ; ti := cw / 50 ;
     var tj : int ; tj := cw mod 50 ;
     if (ti mod 2 = 0) then (     map[ti * 2+1][tj * 2+1] := 1 ) else (     map[ti * 2+1][tj * 2 + 1+1] := 1 ) ;  
     cw := cw + 1 ) ; 
    while (cb < b) do (     var ti : int ; ti := cb / 50 ;
     var tj : int ; tj := cb mod 50 ;
     if (ti mod 2 = 0) then (     map[99 - ti * 2+1][tj * 2+1] := 0 ) else (     map[99 - ti * 2+1][tj * 2 + 1+1] := 0 ) ;  
     cb := cb + 1 ) ; 
        var i : int ; i := 0 ; while i < 100 do ( (     var ans : String ; ans := "" ;
         var j : int ; j := 0 ; while j < 100 do ( (     if (map[i+1][j+1] = 0) then (     ans := ans+("#") ) else (     ans := ans+(".") ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(ans) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  private static int[] arr ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String input=scanner.nextLine();
    arr=Arrays.stream(input.split("")).mapToInt(Integer :: parseInt).toArray();
    long sum=calc(0,arr.length-1);
    System.out.println(sum);
  }
  private static long calc(int position,int end){
    if(position>end)return 0 ;
    long tmp=0 ;
    for(int i=position ; i<end ; i++){
      tmp+=toInt(position,i)*Math.pow(2,(end-i-1))+calc(i+1,end);
    }
    tmp+=toInt(position,end);
    return tmp ;
  }
  private static long toInt(int start,int end){
    if(start==end){
      return arr[start];
    }
    long tmp=0 ;
    for(int i=start ; i<=end ; i++){
      tmp+=arr[i]*Math.pow(10,(end-i));
    }
    return tmp ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute arr : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : String ; input := scanner.nextLine() ;
    arr := stream(input->split(""))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ; 
    var sum : long ; sum := calc(0, arr->size() - 1) ;
    OclFile["System.out"].println(sum) ; 
 );
  static   operation calc( position : int, end : int) : long
  pre: true
  post: true
  activity: (     if (position > end) then     return 0 else skip ; 
     var tmp : long ; tmp := 0 ;
        var i : int ; i := position ; while i < end do ( (     tmp := tmp+(toInt(position, i) * 2->pow((end - i - 1)) + calc(i + 1, end)) )  ;     i := i + 1 ) ; 
    tmp := tmp+(toInt(position, end)) ; 
    return tmp 
 );
  static   operation toInt( start : int, end : int) : long
  pre: true
  post: true
  activity: (     if (start = end) then (     return arr[start+1] ) else skip ; 
     var tmp : long ; tmp := 0 ;
         var i : int ; i := start ; while i <= end do ( (     tmp := tmp+(arr[i+1] * 10->pow((end - i))) )  ;     i := i + 1 ) ; 
     return tmp );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int pairCount(int arr[],int n){
    int max_val=Arrays.stream(arr).max().getAsInt();
    Vector<Boolean>prime=new Vector<>(max_val+1);
    for(int i=0 ; i<max_val+1 ; i++){
      prime.add(true);
    }
    prime.add(0,Boolean.FALSE);
    prime.add(1,Boolean.FALSE);
    for(int p=2 ; p*p<=max_val ; p++){
      if(prime.get(p)==true){
        for(int i=p*2 ; i<=max_val ; i+=p){
          prime.add(i,Boolean.FALSE);
        }
      }
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(prime.get(arr[i])){
        count++;
      }
    }
    return(count*(count-1))/2 ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,6,7 };
      int n=arr.length ;
      System.out.println(pairCount(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pairCount( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max_val : int ; max_val := stream(arr).max().getAsInt() ;
     var prime : Sequence(Boolean) ; prime := Sequence{}->union(max_val + 1) ;
        var i : int ; i := 0 ; while i < max_val + 1 do ( (     prime := prime->including(true) )  ;     i := i + 1 ) ; 
    prime := prime.insertAt(0+1,false) ; 
    prime := prime.insertAt(1+1,false) ; 
        var p : int ; p := 2 ; while p * p <= max_val do ( (     if (prime->at(p+1) = true) then (         var i : int ; i := p * 2 ; while i <= max_val do ( (     prime := prime.insertAt(i+1,false) )  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (prime->at(arr[i+1]+1)) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    return (count * (count - 1)) / 2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(pairCount(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int a=s.nextInt();
    int b=s.nextInt();
    int c=s.nextInt();
    int d=s.nextInt();
    int e=s.nextInt();
    int f=s.nextInt();
    int sum1=0 ;
    int sum2=0 ;
    if(f<e){
      sum1=(Math.min(a,d))*e ;
      d=d-Math.min(a,d);
      sum2=Math.min(b,Math.min(c,d))*f ;
    }
    else {
      sum2=Math.min(b,Math.min(c,d))*f ;
      d=d-Math.min(b,Math.min(c,d));
      sum1=(Math.min(a,d))*e ;
    }
    System.out.println(sum1+sum2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := s.getCurrent()->toInteger() ;
    var b : int ; b := s.getCurrent()->toInteger() ;
    var c : int ; c := s.getCurrent()->toInteger() ;
    var d : int ; d := s.getCurrent()->toInteger() ;
    var e : int ; e := s.getCurrent()->toInteger() ;
    var f : int ; f := s.getCurrent()->toInteger() ;
    var sum1 : int ; sum1 := 0 ;
    var sum2 : int ; sum2 := 0 ;
    if (f < e) then (     sum1 := (Set{a, d}->min()) * e ; 
     d := d - Set{a, d}->min() ; 
     sum2 := Set{b, Set{c, d}->min()}->min() * f ) else (     sum2 := Set{b, Set{c, d}->min()}->min() * f ; 
     d := d - Set{b, Set{c, d}->min()}->min() ; 
     sum1 := (Set{a, d}->min()) * e ) ;  
    OclFile["System.out"].println(sum1 + sum2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int bsearch(int prefixsum[],int n,int k){
    int ans=-1 ;
    int left=1,right=n ;
    while(left<=right){
      int mid=(left+right)/2 ;
      int i ;
      for(i=mid ; i<=n ; i++){
        if(prefixsum[i]-prefixsum[i-mid]>k)break ;
      }
      if(i==n+1){
        left=mid+1 ;
        ans=mid ;
      }
      else right=mid-1 ;
    }
    return ans ;
  }
  static int maxSize(int arr[],int n,int k){
    int prefixsum[]=new int[n+1];
    Arrays.fill(prefixsum,0);
    for(int i=0 ; i<n ; i++)prefixsum[i+1]=prefixsum[i]+arr[i];
    return bsearch(prefixsum,n,k);
  }
  public static void main(String arg[]){
    int arr[]={
      1,2,10,4 };
      int n=arr.length ;
      int k=14 ;
      System.out.println(maxSize(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation bsearch( prefixsum : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := -1 ;
     var left : int ; left := 1 ;
    var right : int ; right := n ;
     while (left <= right) do (     var mid : int ; mid := (left + right) / 2 ;
     var i : int ;
         i := mid ; while i <= n do ( (     if (prefixsum[i+1] - prefixsum[i - mid+1] > k) then     break else skip )  ;     i := i + 1 ) ; 
     if (i = n + 1) then (     left := mid + 1 ; 
     ans := mid ) else     right := mid - 1 ; ) ; 
     return ans );
  static   operation maxSize( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var prefixsum : Sequence(int) ; prefixsum := Integer.subrange(1,n + 1)->collect(0) ;
     prefixsum := prefixsum->collect(0) ; 
         var i : int ; i := 0 ; while i < n do (     prefixsum[i + 1+1] := prefixsum[i+1] + arr[i+1] ;  ;     i := i + 1 ) ; 
     return bsearch(prefixsum, n, k) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,10,4} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 14 ;
     OclFile["System.out"].println(maxSize(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
class GfG {
  static int count_pairs(int n,int a[]){
    HashMap<Integer,Integer>frequency=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(! frequency.containsKey(a[i]))frequency.put(a[i],0);
      frequency.put(a[i],frequency.get(a[i])+1);
    }
    int count=0 ;
    for(Map.Entry<Integer,Integer>x : frequency.entrySet()){
      int f=x.getValue();
      count+=f*(f-1)/2 ;
    }
    return((n*(n-1))/2)-count ;
  }
  public static void main(String[] args){
    int arr[]={
      2,4,5,2,5,7,2,8 };
      int n=arr.length ;
      System.out.println(count_pairs(n,arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation count_pairs( n : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var frequency : Map(int,int) ; frequency := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (not(frequency->keys()->includes(a[i+1]))) then     frequency := frequency->union(Map{a[i+1] |-> 0}) ; else skip ; 
     frequency := frequency->union(Map{a[i+1] |-> frequency->at(a[i+1]) + 1}) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    for (x : frequency->asSet()) do ( (     var f : int ; f := x.getValue() ;
     count := count+(f * (f - 1) / 2) )  ) ; 
    return ((n * (n - 1)) / 2) - count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,5,2,5,7,2,8} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(count_pairs(n, arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int t=scn.nextInt();
    for(int i=0 ; i<t ; ++i){
      int a=scn.nextInt();
      if(a==1 || a==2 || a==4 || a==5 || a==8 || a==11){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scn.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : int ; a := scn.getCurrent()->toInteger() ;
     if (a = 1 or a = 2 or a = 4 or a = 5 or a = 8 or a = 11) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    h : while(t-->0){
      int n=s.nextInt();
      if(n % 3==0 || n % 7==0 || n % 10==0)System.out.println("YES");
      else {
        for(int i=1 ; (7*i)<n ; i++){
          if((n-(7*i))% 3==0){
            System.out.println("YES");
            continue h ;
          }
        }
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     if (n mod 3 = 0 or n mod 7 = 0 or n mod 10 = 0) then     OclFile["System.out"].println("YES") ; else (         var i : int ; i := 1 ; while (7 * i) < n do ( (     if ((n - (7 * i)) mod 3 = 0) then (     OclFile["System.out"].println("YES") ; 
     continue ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("NO") ) ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class D {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Integer>arr=Arrays.asList(1,2,4,5,8,11);
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      if(arr.contains(x)){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Sequence{1,2,4,5,8,11} ;
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (arr->includes(x)) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeSeventy {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    for(int k=0 ; k<n ; k++){
      int t=input.nextInt();
      int count=0 ;
      for(int i=0 ; i<(100/7); i++){
        for(int j=0 ; j<(100/3); j++){
          if(t==(3*j)+(7*i)){
            count++;
            break ;
          }
        }
      }
      if(count>0){
        System.out.println("YES");
      }
      else if(count==0){
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeSeventy {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
         var k : int ; k := 0 ; while k < n do ( (     var t : int ; t := input.getCurrent()->toInteger() ;
     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < (100 / 7) do ( (         var j : int ; j := 0 ; while j < (100 / 3) do ( (     if (t = (3 * j) + (7 * i)) then (     count := count + 1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (count > 0) then (     OclFile["System.out"].println("YES") ) else     if (count = 0) then (     OclFile["System.out"].println("NO") ) else skip ; )  ;     k := k + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static int count(String s,char value){
    int cnt=0 ;
    for(int i=0 ; i<s.length(); i++)if(s.charAt(i)==value)cnt++;
    return cnt ;
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    String[] lst=new String[n];
    for(int i=0 ; i<n ; i++){
      lst[i]=sc.next();
      if(count(lst[i],lst[i] .charAt(0))!=lst[i] .length()){
        System.out.println("NO");
        System.exit(0);
      }
      if(i>0){
        if(lst[i] .equals(lst[i-1])){
          System.out.println("NO");
          System.exit(0);
        }
      }
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation count( s : String, value : String) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < s->size() do (     if (s->at(i+1) = value) then     cnt := cnt + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var lst : Sequence(String) ; lst := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     lst[i+1] := sc.getCurrent() ; 
     if (count(lst[i+1], lst[i+1]->at(0+1)) /= lst[i+1]->size()) then (     OclFile["System.out"].println("NO") ; 
 OclProcess.exit(0) ) else skip ; 
     if (i > 0) then (     if (lst[i+1] = lst[i - 1+1]) then (     OclFile["System.out"].println("NO") ; 
 OclProcess.exit(0) ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Flags {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    String[] str=new String[n];
    for(int i=0 ; i<n ; i++){
      str[i]=in.next();
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m-1 ; j++){
        if(str[i] .charAt(j)!=str[i] .charAt(j+1)){
          System.out.println("NO");
          return ;
        }
      }
    }
    for(int i=0 ; i<n-1 ; i++){
      for(int j=0 ; j<m ; j++){
        if(str[i] .charAt(j)==str[i+1] .charAt(j)){
          System.out.println("NO");
          return ;
        }
      }
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Flags {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var str : Sequence(String) ; str := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     str[i+1] := in.getCurrent() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m - 1 do ( (     if (str[i+1]->at(j+1) /= str[i+1]->at(j + 1+1)) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := 0 ; while j < m do ( (     if (str[i+1]->at(j+1) = str[i + 1+1]->at(j+1)) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication139 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayList<String>arr=new ArrayList<>();
    Set<String>arra=new HashSet<>();
    int num1=sc.nextInt();
    int num2=sc.nextInt();
    boolean c=true ;
    String old="" ;
    for(int i=0 ; i<num1 ; i++){
      String s=sc.next();
      if(old.equals("")){
      }
      else {
        if(s.equals(old)){
          c=false ;
        }
      }
      old=s ;
      arr.add(s);
      arra.add(s);
      for(int j=0 ; j<num2-1 ; j++){
        if(s.charAt(j)!=s.charAt(j+1)){
          c=false ;
        }
      }
    }
    if(c){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication139 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(String) ; arr := Sequence{} ;
    var arra : Set(String) ; arra := Set{} ;
    var num1 : int ; num1 := sc.getCurrent()->toInteger() ;
    var num2 : int ; num2 := sc.getCurrent()->toInteger() ;
    var c : boolean ; c := true ;
    var old : String ; old := "" ;
        var i : int ; i := 0 ; while i < num1 do ( (     var s : String ; s := sc.getCurrent() ;
     if (old = "") then skip else (     if (s = old) then (     c := false ) else skip ) ;  
    old := s ; 
    arr := arr->including(s) ; 
    arra := arra->including(s) ; 
        var j : int ; j := 0 ; while j < num2 - 1 do ( (     if (s->at(j+1) /= s->at(j + 1+1)) then (     c := false ) else skip )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    if (c) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    System.out.println("100 100");
    boolean ans[][]=new boolean[100][100];
    for(int i=0 ; i<100 ; i++){
      for(int j=0 ; j<100 ; j++){
        if(i<50){
          ans[i][j]=true ;
        }
        else {
          ans[i][j]=false ;
        }
      }
    }
    for(int i=0 ; i<B-1 ; i++){
      ans[2*(i/50)][2*(i % 50)]=false ;
    }
    for(int i=0 ; i<A-1 ; i++){
      ans[2*(i/50)+51][2*(i % 50)]=true ;
    }
    for(int i=0 ; i<100 ; i++){
      for(int j=0 ; j<100 ; j++){
        if(ans[i][j]){
          System.out.print('.');
        }
        else {
          System.out.print('#');
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println("100 100") ; 
    var ans : Sequence(Sequence(boolean)) ; ans := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(false)) ;
        var i : int ; i := 0 ; while i < 100 do ( (         var j : int ; j := 0 ; while j < 100 do ( (     if (i < 50) then (     ans[i+1][j+1] := true ) else (     ans[i+1][j+1] := false ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < B - 1 do ( (     ans[2 * (i / 50)+1][2 * (i mod 50)+1] := false )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < A - 1 do ( (     ans[2 * (i / 50) + 51+1][2 * (i mod 50)+1] := true )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 100 do ( (         var j : int ; j := 0 ; while j < 100 do ( (     if (ans[i+1][j+1]) then (     OclFile["System.out"].print('.') ) else (     OclFile["System.out"].print('#') ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    int b=in.nextInt();
    int c=in.nextInt();
    int d=in.nextInt();
    int e=in.nextInt();
    int f=in.nextInt();
    int sum=0 ;
    if(e>f){
      if(a>d)sum=d*e ;
      else {
        sum=sum+a*e ;
        d=d-a ;
        int x=Math.min(Math.min(b,c),d);
        sum=sum+x*f ;
      }
      System.out.println(sum);
    }
    else {
      if(b>d && c>d)sum=sum+d*f ;
      else {
        int x=Math.min(b,c);
        sum=sum+x*f ;
        d=d-x ;
        int y=Math.min(a,d);
        sum=sum+y*e ;
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var e : int ; e := in.getCurrent()->toInteger() ;
    var f : int ; f := in.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    if (e > f) then (     if (a > d) then     sum := d * e else (     sum := sum + a * e ; 
     d := d - a ; 
     var x : int ; x := Set{Set{b, c}->min(), d}->min() ;
     sum := sum + x * f ) ;  
     OclFile["System.out"].println(sum) ) else (     if (b > d & c > d) then     sum := sum + d * f else (     var x : int ; x := Set{b, c}->min() ;
     sum := sum + x * f ; 
    d := d - x ; 
    var y : int ; y := Set{a, d}->min() ;
    sum := sum + y * e ; 
 ) ;  
     OclFile["System.out"].println(sum) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PalindromeDance {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] p=new int[2];
    p[0]=sc.nextInt();
    p[1]=sc.nextInt();
    int[] s=new int[n];
    for(int i=0 ; i<n ; i++){
      s[i]=sc.nextInt();
    }
    int lo=0,hi=n-1,price=0 ;
    while(lo<hi){
      if(s[lo]==s[hi]){
        if(s[lo]==2)price+=2*Math.min(p[0],p[1]);
      }
      else {
        if(s[lo]==2)price+=p[s[hi] ];
        else if(s[hi]==2)price+=p[s[lo] ];
        else {
          System.out.println(-1);
          return ;
        }
      }
      lo++;
      hi--;
    }
    if(n % 2!=0 && s[n/2]==2)price+=Math.min(p[0],p[1]);
    System.out.println(price);
  }
}
------------------------------------------------------------
OCL File:
---------
 class PalindromeDance {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,2)->collect(0) ;
    p[0+1] := sc.getCurrent()->toInteger() ; 
    p[1+1] := sc.getCurrent()->toInteger() ; 
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var lo : int ; lo := 0 ;
    var hi : int ; hi := n - 1 ;
    var price : int ; price := 0 ;
    while (lo < hi) do (     if (s[lo+1] = s[hi+1]) then (     if (s[lo+1] = 2) then     price := price+(2 * Set{p[0+1], p[1+1]}->min()) ; else skip ) else (     if (s[lo+1] = 2) then     price := price+(p[s[hi+1]+1]) ; else     if (s[hi+1] = 2) then     price := price+(p[s[lo+1]+1]) else (     OclFile["System.out"].println(-1) ; 
     return ) ;  ) ;  
     lo := lo + 1 ; 
     hi := hi - 1 ) ; 
    if (n mod 2 /= 0 & s[n / 2+1] = 2) then     price := price+(Set{p[0+1], p[1+1]}->min()) ; else skip ; 
    OclFile["System.out"].println(price) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minCost(int[] cost,int n){
    int totalCost=0 ;
    int boardingBus=0 ;
    for(int i=1 ; i<n ; i++){
      if(cost[boardingBus]>cost[i]){
        totalCost+=((i-boardingBus)*cost[boardingBus]);
        boardingBus=i ;
      }
    }
    totalCost+=((n-boardingBus)*cost[boardingBus]);
    return totalCost ;
  }
  public static void main(String[] args){
    int[] cost={
      4,7,8,3,4 };
      int n=cost.length ;
      System.out.print(minCost(cost,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minCost( cost : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var totalCost : int ; totalCost := 0 ;
     var boardingBus : int ; boardingBus := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (cost[boardingBus+1] > cost[i+1]) then (     totalCost := totalCost+(((i - boardingBus) * cost[boardingBus+1])) ; 
     boardingBus := i ) else skip )  ;     i := i + 1 ) ; 
    totalCost := totalCost+(((n - boardingBus) * cost[boardingBus+1])) ; 
    return totalCost 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cost : Sequence(int) ; cost := Sequence{4,7,8,3,4} ;
     var n : int ; n := cost->size() ;
     OclFile["System.out"].print(minCost(cost, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int maxSum(int arr[],int n){
    int sum=0 ;
    int i ;
    int pivot=findPivot(arr,n);
    int diff=n-1-pivot ;
    for(i=0 ; i<n ; i++){
      sum=sum+((i+diff)% n)*arr[i];
    }
    return sum ;
  }
  static int findPivot(int arr[],int n){
    int i ;
    for(i=0 ; i<n ; i++){
      if(arr[i]>arr[(i+1)% n])return i ;
    }
    return 0 ;
  }
  public static void main(String args[]){
    int arr[]={
      8,3,1,2 };
      int n=arr.length ;
      int max=maxSum(arr,n);
      System.out.println(max);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var i : int ;
    var pivot : int ; pivot := findPivot(arr, n) ;
    var diff : int ; diff := n - 1 - pivot ;
        i := 0 ; while i < n do ( (     sum := sum + ((i + diff) mod n) * arr[i+1] )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation findPivot( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
         i := 0 ; while i < n do ( (     if (arr[i+1] > arr[(i + 1) mod n+1]) then     return i else skip )  ;     i := i + 1 ) ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,3,1,2} ;
     var n : int ; n := arr->size() ;
     var max : int ; max := maxSum(arr, n) ;
     OclFile["System.out"].println(max) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p016 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p016().run());
  }
  public String run(){
    String temp=BigInteger.ONE.shiftLeft(1000).toString();
    int sum=0 ;
    for(int i=0 ; i<temp.length(); i++)sum+=temp.charAt(i)-'0' ;
    return Integer.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p016 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p016.newp016().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var temp : String ; temp := 1.shiftLeft(1000)+"" ;
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < temp->size() do (     sum := sum+(temp->at(i+1) - ('0')->char2byte()) ;  ;     i := i + 1 ) ; 
     return ((sum) + "") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int q=sc.nextInt();
      int[] A=new int[q];
      int head=0,foot=0 ;
      for(int i=0 ; i<q ; i++){
        int query=sc.nextInt();
        if(query==0){
          switch(sc.nextInt()){
            case 0 : head--;
            A[(head+q)% q]=sc.nextInt();
            break ;
            case 1 : A[(foot+q)% q]=sc.nextInt();
            foot++;
            break ;
          }
        }
        else if(query==1){
          System.out.println(A[(head+sc.nextInt()+q)% q]);
        }
        else if(query==2){
          switch(sc.nextInt()){
            case 0 : head++;
            break ;
            case 1 : foot--;
            break ;
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var q : int ; q := sc.getCurrent()->toInteger() ;
     var A : Sequence(int) ; A := Integer.subrange(1,q)->collect(0) ;
     var head : int ; head := 0 ;
    var foot : int ; foot := 0 ;
         var i : int ; i := 0 ; while i < q do ( (     var query : int ; query := sc.getCurrent()->toInteger() ;
     if (query = 0) then ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (sc.getCurrent()->toInteger()) ; 
       if _switchval = 0 then
     head := head - 1 ; 
    A[(head + q) mod q+1] := sc.getCurrent()->toInteger() ; 
    break 
   else skip ;
       if _switchval = 1 then
     A[(foot + q) mod q+1] := sc.getCurrent()->toInteger() ; 
    foot := foot + 1 ; 
    break 
   else skip ;
 )
 ) else     if (query = 1) then (     OclFile["System.out"].println(A[(head + sc.getCurrent()->toInteger() + q) mod q+1]) ) else     if (query = 2) then ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (sc.getCurrent()->toInteger()) ; 
       if _switchval = 0 then
     head := head + 1 ; 
    break 
   else skip ;
       if _switchval = 1 then
     foot := foot - 1 ; 
    break 
   else skip ;
 )
 ) else skip ; ;  )  ;     i := i + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int q=Integer.parseInt(br.readLine());
    MyDeque deque=new MyDeque(400000);
    boolean changed=false ;
    Integer a[]=null ;
    for(int i=0 ; i<q ; i++){
      String[] tmpArray=br.readLine().split(" ");
      if(tmpArray[0] .equals("0")){
        if(tmpArray[1] .equals("0")){
          deque.push(Integer.parseInt(tmpArray[2]));
        }
        else {
          deque.add(Integer.parseInt(tmpArray[2]));
        }
      }
      else if(tmpArray[0] .equals("1")){
        System.out.println(deque.get(Integer.parseInt(tmpArray[1])));
      }
      else {
        if(tmpArray[1] .equals("0")){
          deque.removeFirst();
        }
        else {
          deque.removeLast();
        }
        changed=true ;
      }
    }
  }
}
class MyDeque {
  private int limit ;
  private int first,last ;
  private int[] data ;
  MyDeque(int limit){
    data=new int[limit*2+1];
    first=limit ;
    last=limit ;
  }
  void push(int x){
    data[--first]=x ;
  }
  void add(int x){
    data[last++]=x ;
  }
  int get(int index){
    return data[first+index];
  }
  int removeFirst(){
    int result=data[first++];
    return result ;
  }
  int removeLast(){
    last--;
    return data[last];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var q : int ; q := (br.readLine())->toInteger() ;
    var deque : MyDeque ; deque := MyDeque.newMyDeque(400000) ;
    var changed : boolean ; changed := false ;
    var a : Sequence(int) ; a := null ;
        var i : int ; i := 0 ; while i < q do ( (     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
     if (tmpArray[0+1] = "0") then (     if (tmpArray[1+1] = "0") then (     deque := deque->append((tmpArray[2+1])->toInteger()) ) else (     deque->excludes((tmpArray[2+1])->toInteger()) ) ) else     if (tmpArray[0+1] = "1") then (     OclFile["System.out"].println(deque->at((tmpArray[1+1])->toInteger()+1)) ) else (     if (tmpArray[1+1] = "0") then (     deque := deque->tail() ) else (     deque := deque->front() ) ;  
     changed := true ) ;  )  ;     i := i + 1 ) ; 
 );
}
class MyDeque {
   attribute limit : int;
   attribute first : int;
   attribute data : Sequence(int);
   static operation newMyDeque( limit : int) : MyDeque
  pre: true
  post: true
  activity:
  ( var self : MyDeque ;
    self := createMyDeque();
    self.initialise(limit);
    return self );
  operation initialise( limit : int) : void
  pre: true  post: true
  activity: (     data := Integer.subrange(1,limit * 2 + 1)->collect(0) ; 
     first := limit ; 
     last := limit );
   operation push( x : int) : void
  pre: true
  post: true
  activity: (         first := first - 1 ;
 data[first+1] := x  );
   operation add( x : int) : void
  pre: true
  post: true
  activity: (      data[last+1] := x  ; last := last + 1 );
   operation get( index : int) : int
  pre: true
  post: true
  activity: (     return data[first + index+1] );
   operation removeFirst() : int
  pre: true
  post: true
  activity: (     var result : int ; result := data[first+1] ;
     return result );
   operation removeLast() : int
  pre: true
  post: true
  activity: (     last := last - 1 ; 
     return data[last+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayDeque ;
import java.util.Deque ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int q=scan.nextInt();
    int i=0 ;
    int d=0 ;
    int limit=400000 ;
    MyDeque A=new MyDeque(limit);
    while(i<q){
      i++;
      int Cmd=scan.nextInt();
      switch(Cmd){
        case 0 : d=scan.nextInt();
        int x=scan.nextInt();
        push(A,d,x);
        break ;
        case 1 : int p=scan.nextInt();
        randomAccess(A,p);
        break ;
        case 2 : d=scan.nextInt();
        pop(A,d);
        break ;
        default : break ;
      }
    }
  }
  private static void push(MyDeque A,int d,int x){
    if(d==0){
      A.addFirst(x);
    }
    else if(d==1){
      A.addLast(x);
    }
  }
  private static void randomAccess(MyDeque A,int p){
    System.out.println(A.get(p));
  }
  private static void pop(MyDeque A,int d){
    if(d==0){
      A.removeFirst();
    }
    else if(d==1){
      A.removeLast();
    }
  }
}
class MyDeque {
  private int size ;
  private int first ;
  private int last ;
  private int data[];
  MyDeque(int limit){
    data=new int[limit*2+1];
    first=limit ;
    last=limit-1 ;
    size=0 ;
  }
  void addFirst(int x){
    data[--first]=x ;
  }
  void addLast(int x){
    data[++last]=x ;
  }
  int get(int p){
    return data[first+p];
  }
  void removeFirst(){
    first++;
  }
  void removeLast(){
    last--;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := scan.getCurrent()->toInteger() ;
    var i : int ; i := 0 ;
    var d : int ; d := 0 ;
    var limit : int ; limit := 400000 ;
    var A : MyDeque ; A := MyDeque.newMyDeque(limit) ;
    while (i < q) do (     i := i + 1 ; 
     var Cmd : int ; Cmd := scan.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (Cmd) ; 
       if _switchval = 0 then
     d := scan.getCurrent()->toInteger() ; 
    var x : int ; x := scan.getCurrent()->toInteger() ;
    execute push(A, d, x) ; 
    break 
   else skip ;
       if _switchval = 1 then
     var p : int ; p := scan.getCurrent()->toInteger() ;
    execute randomAccess(A, p) ; 
    break 
   else skip ;
       if _switchval = 2 then
     d := scan.getCurrent()->toInteger() ; 
    execute pop(A, d) ; 
    break 
   else skip ;
       if true then
     break 
   else skip ;
 )
 ) ; 
 );
  static   operation push( A : MyDeque, d : int, x : int) : void
  pre: true
  post: true
  activity: (     if (d = 0) then (     A := A->prepend(x) ) else     if (d = 1) then (     A := A->append(x) ) else skip ; );
  static   operation randomAccess( A : MyDeque, p : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(A->at(p+1)) );
  static   operation pop( A : MyDeque, d : int) : void
  pre: true
  post: true
  activity: (     if (d = 0) then (     A := A->tail() ) else     if (d = 1) then (     A := A->front() ) else skip ; );
}
class MyDeque {
   attribute size : int;
   attribute first : int;
   attribute last : int;
   attribute data : Sequence(int);
   static operation newMyDeque( limit : int) : MyDeque
  pre: true
  post: true
  activity:
  ( var self : MyDeque ;
    self := createMyDeque();
    self.initialise(limit);
    return self );
  operation initialise( limit : int) : void
  pre: true  post: true
  activity: (     data := Integer.subrange(1,limit * 2 + 1)->collect(0) ; 
     first := limit ; 
     last := limit - 1 ; 
     size := 0 );
   operation addFirst( x : int) : void
  pre: true
  post: true
  activity: (         first := first - 1 ;
 data[first+1] := x  );
   operation addLast( x : int) : void
  pre: true
  post: true
  activity: (         last := last + 1 ;
 data[last+1] := x  );
   operation get( p : int) : int
  pre: true
  post: true
  activity: (     return data[first + p+1] );
   operation removeFirst() : void
  pre: true
  post: true
  activity: (     first := first + 1 );
   operation removeLast() : void
  pre: true
  post: true
  activity: (     last := last - 1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num_query=sc.nextInt();
    ArrayList<Integer>front=new ArrayList<>();
    ArrayList<Integer>rear=new ArrayList<>();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<num_query ; i++){
      int query_type=sc.nextInt();
      int d,x,p ;
      switch(query_type){
        case 0 : d=sc.nextInt();
        x=sc.nextInt();
        if(d==0)front.add(x);
        else rear.add(x);
        break ;
        case 1 : p=sc.nextInt();
        int tmp ;
        if(p<front.size())tmp=front.get(front.size()-1-p);
        else tmp=rear.get(p-front.size());
        sb.append(String.format("%d\n",tmp));
        break ;
        case 2 : d=sc.nextInt();
        if(d==0){
          if(front.isEmpty()){
            rear.remove(0);
          }
          else {
            front.remove(front.size()-1);
          }
        }
        else {
          if(rear.isEmpty()){
            front.remove(0);
          }
          else {
            rear.remove(rear.size()-1);
          }
        }
        break ;
        default : return ;
      }
    }
    System.out.print(sb.toString());
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num_query : int ; num_query := sc.getCurrent()->toInteger() ;
    var front : Sequence(int) ; front := Sequence{} ;
    var rear : Sequence(int) ; rear := Sequence{} ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < num_query do ( (     var query_type : int ; query_type := sc.getCurrent()->toInteger() ;
     var d : int ;
    var x : int ;
    var p : int ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (query_type) ; 
       if _switchval = 0 then
     d := sc.getCurrent()->toInteger() ; 
    x := sc.getCurrent()->toInteger() ; 
    if (d = 0) then     front := front->including(x) else     rear := rear->including(x) ; ;  
    break 
   else skip ;
       if _switchval = 1 then
     p := sc.getCurrent()->toInteger() ; 
    var tmp : int ;
    if (p < front->size()) then     tmp := front->at(front->size() - 1 - p+1) else     tmp := rear->at(p - front->size()+1) ; ;  
    sb := sb + StringLib.newString(StringLib.format("%d\n",Sequence{tmp})) ; 
    break 
   else skip ;
       if _switchval = 2 then
     d := sc.getCurrent()->toInteger() ; 
    if (d = 0) then (     if (front->isEmpty()) then (     rear := rear->excludingAt(0+1) ) else (     front := front->excludingFirst(front->size() - 1) ) ) else (     if (rear->isEmpty()) then (     front := front->excludingAt(0+1) ) else (     rear := rear->excludingFirst(rear->size() - 1) ) ) ;  
    break 
   else skip ;
       if true then
     return 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Arrays ;
import java.util.Iterator ;
import java.util.Scanner ;
class Main {
  static Scanner scan=new Scanner(System.in);
  public static void main(String[] args){
    ArrayDeque<Integer>list=new ArrayDeque<>();
    int n=scan.nextInt();
    for(int i=0 ; i<n ; i++){
      int query=scan.nextInt();
      int a=scan.nextInt();
      switch(query){
        case 0 : int b=scan.nextInt();
        if(a==0){
          list.addFirst(b);
        }
        else {
          list.addLast(b);
        }
        break ;
        case 1 : Iterator<Integer>ite=list.iterator();
        for(int j=0 ; j<a ; j++){
          ite.next();
        }
        System.out.println(ite.next());
        break ;
        case 2 : if(a==0){
          list.removeFirst();
        }
        else {
          list.removeLast();
        }
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := ArrayDeque<OclAny>.newArrayDeque() ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var query : int ; query := scan.getCurrent()->toInteger() ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (query) ; 
       if _switchval = 0 then
     var b : int ; b := scan.getCurrent()->toInteger() ;
    if (a = 0) then (     list := list->prepend(b) ) else (     list := list->append(b) ) ;  
    break 
   else skip ;
       if _switchval = 1 then
     var ite : OclIterator ; ite := list->iterator() ;
        var j : int ; j := 0 ; while j < a do ( (     ite.next() )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ite.next()) ; 
    break 
   else skip ;
       if _switchval = 2 then
     if (a = 0) then (     list := list->tail() ) else (     list := list->front() ) ;  
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maximumSumSubarray(int arr[],int n){
    int min_prefix_sum=0 ;
    int res=Integer.MIN_VALUE ;
    int prefix_sum[]=new int[n];
    prefix_sum[0]=arr[0];
    for(int i=1 ; i<n ; i++)prefix_sum[i]=prefix_sum[i-1]+arr[i];
    for(int i=0 ; i<n ; i++){
      res=Math.max(res,prefix_sum[i]-min_prefix_sum);
      min_prefix_sum=Math.min(min_prefix_sum,prefix_sum[i]);
    }
    return res ;
  }
  public static void main(String[] args){
    int arr1[]={
-2,-3,4,-1,-2,1,5,-3 };
      int n1=arr1.length ;
      System.out.println(maximumSumSubarray(arr1,n1));
      int arr2[]={
        4,-8,9,-4,1,-8,-1,6 };
        int n2=arr2.length ;
        System.out.println(maximumSumSubarray(arr2,n2));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maximumSumSubarray( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var min_prefix_sum : int ; min_prefix_sum := 0 ;
     var res : int ; res := -2147483648 ;
    var prefix_sum : Sequence(int) ; prefix_sum := Integer.subrange(1,n)->collect(0) ;
    prefix_sum[0+1] := arr[0+1] ; 
        var i : int ; i := 1 ; while i < n do (     prefix_sum[i+1] := prefix_sum[i - 1+1] + arr[i+1] ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     res := Set{res, prefix_sum[i+1] - min_prefix_sum}->max() ; 
     min_prefix_sum := Set{min_prefix_sum, prefix_sum[i+1]}->min() )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{-2,-3,4,-1,-2,1,5,-3} ;
     var n1 : int ; n1 := arr1->size() ;
    OclFile["System.out"].println(maximumSumSubarray(arr1, n1)) ; 
    var arr2 : Sequence(int) ; arr2 := Sequence{4,-8,9,-4,1,-8,-1,6} ;
    var n2 : int ; n2 := arr2->size() ;
    OclFile["System.out"].println(maximumSumSubarray(arr2, n2)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int[] arr=new int[4];
    int[] type=new int[2];
    int price1=0 ;
    int price2=0 ;
    for(int i=0 ; i<4 ; i++){
      arr[i]=s.nextInt();
    }
    for(int i=0 ; i<2 ; i++){
      type[i]=s.nextInt();
    }
    if(type[0]>type[1]){
      price1=Math.min(arr[0],arr[3])*type[0];
      arr[3]=Math.max(0,arr[3]-arr[0]);
      price2=Math.min(arr[3],Math.min(arr[1],arr[2]))*type[1];
    }
    else {
      price1=Math.min(arr[3],Math.min(arr[1],arr[2]))*type[1];
      arr[3]=Math.max(0,arr[3]-Math.min(arr[1],arr[2]));
      price2=Math.min(arr[0],arr[3])*type[0];
    }
    System.out.println(price1+price2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,4)->collect(0) ;
    var type : Sequence(int) ; type := Integer.subrange(1,2)->collect(0) ;
    var price1 : int ; price1 := 0 ;
    var price2 : int ; price2 := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     arr[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 2 do ( (     type[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (type[0+1] > type[1+1]) then (     price1 := Set{arr[0+1], arr[3+1]}->min() * type[0+1] ; 
     arr[3+1] := Set{0, arr[3+1] - arr[0+1]}->max() ; 
     price2 := Set{arr[3+1], Set{arr[1+1], arr[2+1]}->min()}->min() * type[1+1] ) else (     price1 := Set{arr[3+1], Set{arr[1+1], arr[2+1]}->min()}->min() * type[1+1] ; 
     arr[3+1] := Set{0, arr[3+1] - Set{arr[1+1], arr[2+1]}->min()}->max() ; 
     price2 := Set{arr[0+1], arr[3+1]}->min() * type[0+1] ) ;  
    OclFile["System.out"].println(price1 + price2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.Stream ;
public class Main {
  static char[][] ret=new char[100][100];
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int a=scan.nextInt()-1 ;
    int b=scan.nextInt()-1 ;
    for(int i=0 ; i<50 ; i++){
      for(int j=0 ; j<100 ; j++){
        ret[i][j]='#' ;
      }
      for(int j=0 ; j<100 ; j++){
        ret[i+50][j]='.' ;
      }
    }
    int ar=a/50 ;
    int al=a % 50 ;
    for(int i=0 ; i<ar ; i++){
      for(int j=0 ; j<50 ; j++){
        ret[2*i][2*j]='.' ;
      }
    }
    for(int i=0 ; i<al ; i++){
      ret[2*ar][2*i]='.' ;
    }
    int br=b/50 ;
    int bl=b % 50 ;
    for(int i=0 ; i<br ; i++){
      for(int j=0 ; j<50 ; j++){
        ret[2*i+51][2*j]='#' ;
      }
    }
    for(int i=0 ; i<bl ; i++){
      ret[2*br+51][2*i]='#' ;
    }
    System.out.println("100 100");
    for(int i=0 ; i<100 ; i++){
      System.out.println(new String(ret[i]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ret : Sequence(Sequence(String)) := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scan.getCurrent()->toInteger() - 1 ;
    var b : int ; b := scan.getCurrent()->toInteger() - 1 ;
        var i : int ; i := 0 ; while i < 50 do ( (         var j : int ; j := 0 ; while j < 100 do ( (     ret[i+1][j+1] := '#' )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < 100 do ( (     ret[i + 50+1][j+1] := '.' )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ar : int ; ar := a / 50 ;
    var al : int ; al := a mod 50 ;
        var i : int ; i := 0 ; while i < ar do ( (         var j : int ; j := 0 ; while j < 50 do ( (     ret[2 * i+1][2 * j+1] := '.' )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < al do ( (     ret[2 * ar+1][2 * i+1] := '.' )  ;     i := i + 1 ) ; 
    var br : int ; br := b / 50 ;
    var bl : int ; bl := b mod 50 ;
        var i : int ; i := 0 ; while i < br do ( (         var j : int ; j := 0 ; while j < 50 do ( (     ret[2 * i + 51+1][2 * j+1] := '#' )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < bl do ( (     ret[2 * br + 51+1][2 * i+1] := '#' )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("100 100") ; 
        var i : int ; i := 0 ; while i < 100 do ( (     OclFile["System.out"].println(StringLib.newString(ret[i+1])) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int N=100005 ;
  static int[] lpf=new int[N];
  static void least_prime_factor(){
    for(int i=2 ; i<N ; i++)if(lpf[i] % 2!=1)for(int j=i ; j<N ; j+=i)if(lpf[j] % 2!=0)lpf[j]=i ;
  }
  static void Mobius(int n){
    int[] mobius=new int[N];
    for(int i=1 ; i<N ; i++){
      if(i==1)mobius[i]=1 ;
      else {
        if(lpf[i/lpf[i] ]==lpf[i])mobius[i]=0 ;
        else mobius[i]=-1*mobius[i/lpf[i] ];
      }
    }
    for(int i=1 ; i<=n ; i++)System.out.print(mobius[i]+" ");
  }
  public static void main(String[] args){
    int n=5 ;
    Arrays.fill(lpf,-1);
    least_prime_factor();
    Mobius(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 100005;
  static   attribute lpf : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static   operation least_prime_factor() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i < N do (     if (lpf[i+1] mod 2 /= 1) then         var j : int ; j := i ; while j < N do (     if (lpf[j+1] mod 2 /= 0) then     lpf[j+1] := i ; else skip ;  ;     j := j+(i) ) ; else skip ;  ;     i := i + 1 ) );
  static   operation Mobius( n : int) : void
  pre: true
  post: true
  activity: (     var mobius : Sequence(int) ; mobius := Integer.subrange(1,N)->collect(0) ;
         var i : int ; i := 1 ; while i < N do ( (     if (i = 1) then     mobius[i+1] := 1 ; else (     if (lpf[i / lpf[i+1]+1] = lpf[i+1]) then     mobius[i+1] := 0 ; else     mobius[i+1] := -1 * mobius[i / lpf[i+1]+1] ; ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i <= n do (     OclFile["System.out"].print(mobius[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     lpf := lpf->collect(-1) ; 
     execute least_prime_factor() ; 
     execute Mobius(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int a=scan.nextInt();
    int b=scan.nextInt();
    int c=scan.nextInt();
    int d=scan.nextInt();
    long ans=getCount(n,a,b,c,d);
    System.out.print(ans);
  }
  public static long getCount(int n,int a,int b,int c,int d){
    int upLeft=a+b ;
    int upRight=a+c ;
    int downLeft=b+d ;
    int downRight=c+d ;
    int[] arr=new int[4];
    arr[0]=upLeft ;
    arr[1]=upRight ;
    arr[2]=downLeft ;
    arr[3]=downRight ;
    Arrays.sort(arr);
    long range=arr[3]-arr[0]+1 ;
    long ans=0 ;
    if(n>=range){
      ans=(n-range+1)*n ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    var c : int ; c := scan.getCurrent()->toInteger() ;
    var d : int ; d := scan.getCurrent()->toInteger() ;
    var ans : long ; ans := getCount(n, a, b, c, d) ;
    OclFile["System.out"].print(ans) ; 
 );
  static   operation getCount( n : int, a : int, b : int, c : int, d : int) : long
  pre: true
  post: true
  activity: (     var upLeft : int ; upLeft := a + b ;
     var upRight : int ; upRight := a + c ;
    var downLeft : int ; downLeft := b + d ;
    var downRight : int ; downRight := c + d ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,4)->collect(0) ;
    arr[0+1] := upLeft ; 
    arr[1+1] := upRight ; 
    arr[2+1] := downLeft ; 
    arr[3+1] := downRight ; 
    arr := arr->sort() ; 
    var range : long ; range := arr[3+1] - arr[0+1] + 1 ;
    var ans : long ; ans := 0 ;
    if (n >= range) then (     ans := (n - range + 1) * n ) else skip ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int a=scan.nextInt();
    int b=scan.nextInt();
    int c=scan.nextInt();
    int d=scan.nextInt();
    long ans=getCount(n,a,b,c,d);
    System.out.print(ans);
  }
  public static long getCount(int n,int a,int b,int c,int d){
    long ans=0 ;
    for(int x=1 ; x<=n ; x++){
      int y=x+b-c ;
      int z=x+a-d ;
      int w=a+y-d ;
      if(1<=y && y<=n && 1<=z && z<=n && 1<=w && w<=n){
        ans++;
      }
    }
    ans*=n ;
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    var c : int ; c := scan.getCurrent()->toInteger() ;
    var d : int ; d := scan.getCurrent()->toInteger() ;
    var ans : long ; ans := getCount(n, a, b, c, d) ;
    OclFile["System.out"].print(ans) ; 
 );
  static   operation getCount( n : int, a : int, b : int, c : int, d : int) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
         var x : int ; x := 1 ; while x <= n do ( (     var y : int ; y := x + b - c ;
     var z : int ; z := x + a - d ;
     var w : int ; w := a + y - d ;
     if (1 <= y & y <= n & 1 <= z & z <= n & 1 <= w & w <= n) then (     ans := ans + 1 ) else skip )  ;     x := x + 1 ) ; 
     ans := ans*(n) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.image.BufferedImage ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class RestoringPainting {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    String[] temp=br.readLine().split(" ");
    int max=Integer.parseInt(temp[0]);
    int a=Integer.parseInt(temp[1]);
    int b=Integer.parseInt(temp[2]);
    int c=Integer.parseInt(temp[3]);
    int d=Integer.parseInt(temp[4]);
    int count=0 ;
    for(int x=1 ; x<=max ; x++){
      int z=x-c+b ;
      int m=x-d+a ;
      int n=m+z-x ;
      if(z>0 && z<=max && m>0 && m<=max && n>0 && n<=max){
        count++;
      }
    }
    pr.println((long)count*(long)max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class RestoringPainting {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
     var max : int ; max := (temp[0+1])->toInteger() ;
    var a : int ; a := (temp[1+1])->toInteger() ;
    var b : int ; b := (temp[2+1])->toInteger() ;
    var c : int ; c := (temp[3+1])->toInteger() ;
    var d : int ; d := (temp[4+1])->toInteger() ;
    var count : int ; count := 0 ;
        var x : int ; x := 1 ; while x <= max do ( (     var z : int ; z := x - c + b ;
     var m : int ; m := x - d + a ;
     var n : int ; n := m + z - x ;
     if (z > 0 & z <= max & m > 0 & m <= max & n > 0 & n <= max) then (     count := count + 1 ) else skip )  ;     x := x + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),f=0 ;
    int[] arr1=new int[n];
    int[] arr2=new int[n];
    for(int i=0 ; i<n ; i++){
      arr1[i]=in.nextInt();
      arr2[i]=arr1[i];
    }
    Arrays.sort(arr2);
    for(int i=0 ; i<n ; i++){
      if(arr1[i]!=arr2[i])f++;
    }
    if(f==2 || f==0)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var f : int ; f := 0 ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr1[i+1] := in.getCurrent()->toInteger() ; 
     arr2[i+1] := arr1[i+1] )  ;     i := i + 1 ) ; 
    arr2 := arr2->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr1[i+1] /= arr2[i+1]) then     f := f + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (f = 2 or f = 0) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args)throws IOException {
    MScanner s=new MScanner(System.in);
    int n=s.nextInt(),f=0 ;
    int[] arr1=new int[n];
    int[] arr2=new int[n];
    for(int i=0 ; i<n ; i++){
      arr1[i]=s.nextInt();
      arr2[i]=arr1[i];
    }
    Arrays.sort(arr2);
    for(int i=0 ; i<n ; i++){
      if(arr1[i]!=arr2[i])f++;
    }
    if(f==2 || f==0)System.out.println("YES");
    else System.out.println("NO");
  }
  static class MScanner {
    StringTokenizer st ;
    BufferedReader br ;
    public MScanner(InputStream system){
      br=new BufferedReader(new InputStreamReader(system));
    }
    public MScanner(String file)throws Exception {
      br=new BufferedReader(new FileReader(file));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public char nextChar()throws IOException {
      return next().charAt(0);
    }
    public Long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
    public void waitForInput()throws InterruptedException {
      Thread.sleep(3000);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : MScanner ; s := MScanner.newMScanner(OclFile["System.in"]) ;
     var n : int ; n := s.nextInt() ;
    var f : int ; f := 0 ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr1[i+1] := s.nextInt() ; 
     arr2[i+1] := arr1[i+1] )  ;     i := i + 1 ) ; 
    arr2 := arr2->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr1[i+1] /= arr2[i+1]) then     f := f + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (f = 2 or f = 0) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
  static class MScanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newMScanner( system : OclFile) : MScanner
  pre: true
  post: true
  activity:
  ( var self : MScanner ;
    self := createMScanner();
    self.initialise(system);
    return self );
  operation initialise( system : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(system)) );
   static operation newMScanner( file : String) : MScanner
  pre: true
  post: true
  activity:
  ( var self : MScanner ;
    self := createMScanner();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
   operation waitForInput() : void
  pre: true
  post: true
  activity: (     OclProcess.sleep(3000) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(new BufferedInputStream(System.in));
    int a=cin.nextInt();
    int b=cin.nextInt();
    int n=a,m=b ;
    int maxx=0 ;
    while(a!=0){
      maxx=Math.max(maxx,a % 10);
      a/=10 ;
    }
    while(b!=0){
      maxx=Math.max(maxx,b % 10);
      b/=10 ;
    }
    int ans=0 ;
    for(int i=maxx+1 ; i<=16 ; i++){
      String nn=Integer.toString(n);
      String mm=Integer.toString(m);
      BigInteger s1=new BigInteger(nn,i);
      BigInteger s2=new BigInteger(mm,i);
      ans=Math.max(ans,s1.add(s2).toString(i).length());
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var a : int ; a := cin.getCurrent()->toInteger() ;
    var b : int ; b := cin.getCurrent()->toInteger() ;
    var n : int ; n := a ;
    var m : int ; m := b ;
    var maxx : int ; maxx := 0 ;
    while (a /= 0) do (     maxx := Set{maxx, a mod 10}->max() ; 
     a := a/(10) ) ; 
    while (b /= 0) do (     maxx := Set{maxx, b mod 10}->max() ; 
     b := b/(10) ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := maxx + 1 ; while i <= 16 do ( (     var nn : String ; nn := ((n) + "") ;
     var mm : String ; mm := ((m) + "") ;
    var s1 : long ; s1 := long(nn, i) ;
    var s2 : long ; s2 := long(mm, i) ;
    ans := Set{ans, s1->excludes(s2).toString(i)->size()}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String n=in.next();
    String m=in.next();
    int base=max(n.chars().max().getAsInt(),m.chars().max().getAsInt())-'0'+1 ;
    System.out.println(new BigInteger(n,base).add(new BigInteger(m,base)).toString(base).length());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : String ; n := in.getCurrent() ;
    var m : String ; m := in.getCurrent() ;
    var base : int ; base := max(n.chars().max().getAsInt(), m.chars().max().getAsInt()) - ('0')->char2byte() + 1 ;
    OclFile["System.out"].println(long(n, base)->excludes(long(m, base)).toString(base)->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewClass {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    String name1=in.next(),name2=in.next();
    System.out.println(name1+" "+name2);
    int n=in.nextInt();
    while(true){
      String s1=in.next(),s2=in.next();
      if(s1.equals(name1)){
        name1=s2 ;
      }
      if(s1.equals(name2)){
        name2=s2 ;
      }
      System.out.println(name1+" "+name2);
      n--;
      if(n==0)break ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var name1 : String ; name1 := in.getCurrent() ;
    var name2 : String ; name2 := in.getCurrent() ;
    OclFile["System.out"].println(name1 + " " + name2) ; 
    var n : int ; n := in.getCurrent()->toInteger() ;
    while (true) do (     var s1 : String ; s1 := in.getCurrent() ;
    var s2 : String ; s2 := in.getCurrent() ;
     if (s1 = name1) then (     name1 := s2 ) else skip ; 
    if (s1 = name2) then (     name2 := s2 ) else skip ; 
    OclFile["System.out"].println(name1 + " " + name2) ; 
    n := n - 1 ; 
    if (n = 0) then     break else skip ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B49 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int A=in.nextInt();
    int B=in.nextInt();
    int base=Math.max(maxDigit(A),maxDigit(B))+1 ;
    int newA=Integer.parseInt(""+A,base);
    int newB=Integer.parseInt(""+B,base);
    int answer=Integer.toString(newA+newB,base).length();
    System.out.println(answer);
  }
  static int maxDigit(int number){
    int max=0 ;
    while(number!=0){
      int digit=number % 10 ;
      number/=10 ;
      max=Math.max(max,digit);
    }
    return max ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B49 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := in.getCurrent()->toInteger() ;
    var B : int ; B := in.getCurrent()->toInteger() ;
    var base : int ; base := Set{maxDigit(A), maxDigit(B)}->max() + 1 ;
    var newA : int ; newA := ("" + A)->toInteger() ;
    var newB : int ; newB := ("" + B)->toInteger() ;
    var answer : int ; answer := ((newA + newB) + "")->size() ;
    OclFile["System.out"].println(answer) ; 
 );
  static   operation maxDigit( number : int) : int
  pre: true
  post: true
  activity: (     var max : int ; max := 0 ;
     while (number /= 0) do (     var digit : int ; digit := number mod 10 ;
     number := number/(10) ; 
     max := Set{max, digit}->max() ) ; 
     return max );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    int R=sc.nextInt();
    int S=sc.nextInt();
    int P=sc.nextInt();
    String[] T=sc.next().split("");
    int point=0 ;
    for(int i=0 ; i<T.length ; i++){
      if(i<K){
        if(T[i] .equals("r")){
          point=point+P ;
        }
        else if(T[i] .equals("s")){
          point=point+R ;
        }
        else if(T[i] .equals("p")){
          point=point+S ;
        }
      }
      else {
        if(T[i] .equals("r")){
          if(T[i-K] .equals("r")){
            T[i]="x" ;
          }
          else {
            point=point+P ;
          }
        }
        else if(T[i] .equals("s")){
          if(T[i-K] .equals("s")){
            T[i]="x" ;
          }
          else {
            point=point+R ;
          }
        }
        else if(T[i] .equals("p")){
          if(T[i-K] .equals("p")){
            T[i]="x" ;
          }
          else {
            point=point+S ;
          }
        }
      }
    }
    System.out.println(point);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var R : int ; R := sc.getCurrent()->toInteger() ;
    var S : int ; S := sc.getCurrent()->toInteger() ;
    var P : int ; P := sc.getCurrent()->toInteger() ;
    var T : Sequence(String) ; T := sc.getCurrent()->split("") ;
    var point : int ; point := 0 ;
        var i : int ; i := 0 ; while i < T->size() do ( (     if (i < K) then (     if (T[i+1] = "r") then (     point := point + P ) else     if (T[i+1] = "s") then (     point := point + R ) else     if (T[i+1] = "p") then (     point := point + S ) else skip ; ;  ) else (     if (T[i+1] = "r") then (     if (T[i - K+1] = "r") then (     T[i+1] := "x" ) else (     point := point + P ) ) else     if (T[i+1] = "s") then (     if (T[i - K+1] = "s") then (     T[i+1] := "x" ) else (     point := point + R ) ) else     if (T[i+1] = "p") then (     if (T[i - K+1] = "p") then (     T[i+1] := "x" ) else (     point := point + S ) ) else skip ; ;  ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(point) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class UboundedKnapsack {
  private static int max(int i,int j){
    return(i>j)? i : j ;
  }
  private static int unboundedKnapsack(int W,int n,int[] val,int[] wt){
    int dp[]=new int[W+1];
    for(int i=0 ; i<=W ; i++){
      for(int j=0 ; j<n ; j++){
        if(wt[j]<=i){
          dp[i]=max(dp[i],dp[i-wt[j] ]+val[j]);
        }
      }
    }
    return dp[W];
  }
  public static void main(String[] args){
    int W=100 ;
    int val[]={
      10,30,20 };
      int wt[]={
        5,10,15 };
        int n=val.length ;
        System.out.println(unboundedKnapsack(W,n,val,wt));
      }
    }

------------------------------------------------------------
OCL File:
---------
class UboundedKnapsack {
  static   operation max( i : int, j : int) : int
  pre: true
  post: true
  activity: (     return if (i > j) then i else j endif );
  static   operation unboundedKnapsack( W : int, n : int, val : Sequence(int), wt : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,W + 1)->collect(0) ;
         var i : int ; i := 0 ; while i <= W do ( (         var j : int ; j := 0 ; while j < n do ( (     if (wt[j+1] <= i) then (     dp[i+1] := Set{dp[i+1], dp[i - wt[j+1]+1] + val[j+1]}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return dp[W+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var W : int ; W := 100 ;
     var val : Sequence(int) ; val := Sequence{10,30,20} ;
    var wt : Sequence(int) ; wt := Sequence{5,10,15} ;
    var n : int ; n := val->size() ;
    OclFile["System.out"].println(unboundedKnapsack(W, n, val, wt)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void rearrange(int arr[],int n){
    int i=-1,j=n ;
    while(i<j){
      while(arr[++i]>0);
      while(arr[--j]<0);
      if(i<j)swap(arr,i,j);
    }
    if(i==0 || i==n)return ;
    int k=0 ;
    while(k<n && i<n){
      swap(arr,k,i);
      i=i+1 ;
      k=k+2 ;
    }
  }
  static void printArray(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    System.out.println("");
  }
  static void swap(int arr[],int index1,int index2){
    int c=arr[index1];
    arr[index1]=arr[index2];
    arr[index2]=c ;
  }
  public static void main(String[] args){
    int arr[]={
      2,3,-4,-1,6,-9 };
      int n=arr.length ;
      System.out.println("Given array is ");
      printArray(arr,n);
      rearrange(arr,n);
      System.out.println("Rearranged array is ");
      printArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation rearrange( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := -1 ;
    var j : int ; j := n ;
     while (i < j) do (         i := i + 1 ;
    while (arr[(i + 1)+1] > 0) do (        skip ;     skip ;  ;     i := i + 1 ;
 ) ;  
         j := j - 1 ;
    while (arr[(j - 1)+1] < 0) do (        skip ;     skip ;  ;     j := j - 1 ;
 ) ;  
     if (i < j) then     execute swap(arr, i, j) ; else skip ) ; 
    if (i = 0 or i = n) then     return else skip ; 
    var k : int ; k := 0 ;
    while (k < n & i < n) do (     execute swap(arr, k, i) ; 
     i := i + 1 ; 
     k := k + 2 ) ; 
 );
  static   operation printArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("") );
  static   operation swap( arr : Sequence(int), index1 : int, index2 : int) : void
  pre: true
  post: true
  activity: (     var c : int ; c := arr[index1+1] ;
     arr[index1+1] := arr[index2+1] ; 
     arr[index2+1] := c );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,-4,-1,6,-9} ;
     var n : int ; n := arr->size() ;
    OclFile["System.out"].println("Given array is ") ; 
    execute printArray(arr, n) ; 
    execute rearrange(arr, n) ; 
    OclFile["System.out"].println("Rearranged array is ") ; 
    execute printArray(arr, n) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      int a=scanner.nextInt();
      if(slove(a))ans++;
    }
    System.out.println(ans);
  }
  private boolean slove(int a){
    for(int i=1 ; i*i<=a ; i++){
      if((a-i)%(2*i+1)==0)return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     if (slove(a)) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation slove( a : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i * i <= a do ( (     if ((a - i) mod (2 * i + 1) = 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    SC sc=new SC(System.in);
    int room=sc.nextInt();
    int arien=0 ;
    for(int i=0 ; i<room ; i++){
      int a=sc.nextInt();
      int hen=1 ;
      boolean b=false ;
      while(hen*hen*2+hen<=a){
        if((a-hen)%(hen*2+1)==0){
          b=true ;
          break ;
        }
        hen++;
      }
      if(! b){
        arien++;
      }
    }
    pl(arien);
  }
  static class SC {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public SC(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        throw new UncheckedIOException(e);
      }
    }
  }
  public static void pl(Object o){
    System.out.println(o);
  }
  public static void pl(){
    System.out.println();
  }
  public static void p(Object o){
    System.out.print(o);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : SC ; sc := SC.newSC(OclFile["System.in"]) ;
     var room : int ; room := sc.nextInt() ;
    var arien : int ; arien := 0 ;
        var i : int ; i := 0 ; while i < room do ( (     var a : int ; a := sc.nextInt() ;
     var hen : int ; hen := 1 ;
    var b : boolean ; b := false ;
    while (hen * hen * 2 + hen <= a) do (     if ((a - hen) mod (hen * 2 + 1) = 0) then (     b := true ; 
     break ) else skip ; 
     hen := hen + 1 ) ; 
    if (not(b)) then (     arien := arien + 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    execute pl(arien) ; 
 );
  static class SC {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newSC( in : OclFile) : SC
  pre: true
  post: true
  activity:
  ( var self : SC ;
    self := createSC();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 );
}
  static   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation pl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.Map ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final int n=sc.nextInt();
    final long Smax=Integer.MAX_VALUE ;
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      final long S=sc.nextInt();
      boolean found=false ;
      for(long x=1 ; ; x++){
        if(S>=2*(x*x+x)){
          if((S-x)%(2*x+1)==0){
            found=true ;
            break ;
          }
        }
        else {
          break ;
        }
      }
      if(! found){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var Smax : long ; Smax := 2147483647 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var S : long ; S := sc.getCurrent()->toInteger() ;
     var found : boolean ; found := false ;
         var x : long ; x := 1 ; while true do ( (     if (S >= 2 * (x * x + x)) then (     if ((S - x) mod (2 * x + 1) = 0) then (     found := true ; 
     break ) else skip ) else (     break ) )  ;     x := x + 1 ) ; 
     if (not(found)) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),cnt=0 ;
    for(long i=0 ; i<n ; i++){
      if(! isAllow(sc.nextInt()))cnt++;
    }
    System.out.println(cnt);
  }
  boolean isAllow(long S){
    for(long i=1 ; i*i<S ; i++){
      if((S-i)%(2*i+1)==0)return true ;
    }
    return false ;
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var cnt : int ; cnt := 0 ;
         var i : long ; i := 0 ; while i < n do ( (     if (not(isAllow(sc.getCurrent()->toInteger()))) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(cnt) );
   operation isAllow( S : long) : boolean
  pre: true
  post: true
  activity: (         var i : long ; i := 1 ; while i * i < S do ( (     if ((S - i) mod (2 * i + 1) = 0) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int cnt=0 ;
    int p,q ;
    for(int i=0 ; i<n ; i++){
      p=sc.nextInt();
      if((p-1)% 3==0 ||(p-2)% 5==0 ||(p-3)% 7==0){
        cnt++;
      }
      else {
        for(int j=5 ; j<Integer.MAX_VALUE/2 ; j++){
          if(p-j<2*j+1)break ;
          else if((p-j)%(2*j+1)==0){
            cnt++;
            break ;
          }
          j++;
          if(p-j<2*j+1)break ;
          else if((p-j)%(2*j+1)==0){
            cnt++;
            break ;
          }
          j++;
        }
      }
    }
    System.out.println(n-cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var cnt : int ; cnt := 0 ;
    var p : int ;
    var q : int ;
        var i : int ; i := 0 ; while i < n do ( (     p := sc.getCurrent()->toInteger() ; 
     if ((p - 1) mod 3 = 0 or (p - 2) mod 5 = 0 or (p - 3) mod 7 = 0) then (     cnt := cnt + 1 ) else (         var j : int ; j := 5 ; while j < 2147483647 / 2 do ( (     if (p - j < 2 * j + 1) then     break else     if ((p - j) mod (2 * j + 1) = 0) then (     cnt := cnt + 1 ; 
     break ) else skip ; ;  
     j := j + 1 ; 
     if (p - j < 2 * j + 1) then     break else     if ((p - j) mod (2 * j + 1) = 0) then (     cnt := cnt + 1 ; 
     break ) else skip ; ;  
     j := j + 1 )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n - cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int Solution(int[] A){
    int ans=2 ;
    int n=A.length ;
    if(n<=2)return n ;
    int[] llap=new int[n];
    for(int i=0 ; i<n ; i++)llap[i]=2 ;
    Arrays.sort(A);
    for(int j=n-2 ; j>=0 ; j--){
      int i=j-1 ;
      int k=j+1 ;
      while(i>=0 && k<n){
        if(A[i]+A[k]==2*A[j]){
          llap[j]=Math.max(llap[k]+1,llap[j]);
          ans=Math.max(ans,llap[j]);
          i-=1 ;
          k+=1 ;
        }
        else if(A[i]+A[k]<2*A[j])k+=1 ;
        else i-=1 ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int[] a={
      9,4,7,2,10 };
      System.out.print(Solution(a)+"\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Solution( A : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 2 ;
     var n : int ; n := A->size() ;
    if (n <= 2) then     return n else skip ; 
    var llap : Sequence(int) ; llap := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     llap[i+1] := 2 ;  ;     i := i + 1 ) ; 
    A := A->sort() ; 
        var j : int ; j := n - 2 ; while j >= 0 do ( (     var i : int ; i := j - 1 ;
     var k : int ; k := j + 1 ;
     while (i >= 0 & k < n) do (     if (A[i+1] + A[k+1] = 2 * A[j+1]) then (     llap[j+1] := Set{llap[k+1] + 1, llap[j+1]}->max() ; 
     ans := Set{ans, llap[j+1]}->max() ; 
     i := i-(1) ; 
     k := k+(1) ) else     if (A[i+1] + A[k+1] < 2 * A[j+1]) then     k := k+(1) else     i := i-(1) ; ;  ) )  ;     j := j - 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{9,4,7,2,10} ;
     OclFile["System.out"].print(Solution(a) + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      int st=32 ;
      for(int time=0 ; st>0 ; time++){
        st-=(st-1)% 5 ;
        System.out.println(st);
        int g=a[time % a.length];
        st-=g ;
        if(st<0){
          st=0 ;
        }
        System.out.println(st);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var st : int ; st := 32 ;
        var time : int ; time := 0 ; while st > 0 do ( (     st := st-((st - 1) mod 5) ; 
     OclFile["System.out"].println(st) ; 
    var g : int ; g := a[time mod a->size()+1] ;
    st := st-(g) ; 
    if (st < 0) then (     st := 0 ) else skip ; 
    OclFile["System.out"].println(st) ; 
 )  ;     time := time + 1 ) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    solve(System.in,System.out);
  }
  static void solve(InputStream is,PrintStream os){
    Scanner sc=new Scanner(is);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int r=sc.nextInt();
    int s=sc.nextInt();
    int p=sc.nextInt();
    String t=sc.next();
    long ans=0 ;
    for(int i=0 ; i<k ; i++){
      char lastUsing='*' ;
      for(int j=i ; j<n ; j+=k){
        char c=t.charAt(j);
        if(c=='r'){
          if(lastUsing!='p'){
            ans+=p ;
            lastUsing='p' ;
          }
          else {
            lastUsing='*' ;
          }
        }
        else if(c=='s'){
          if(lastUsing!='r'){
            ans+=r ;
            lastUsing='r' ;
          }
          else {
            lastUsing='*' ;
          }
        }
        else if(c=='p'){
          if(lastUsing!='s'){
            ans+=s ;
            lastUsing='s' ;
          }
          else {
            lastUsing='*' ;
          }
        }
      }
    }
    os.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation solve( is : OclFile, os : OclFile) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(is) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
    var t : String ; t := sc.getCurrent() ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     var lastUsing : String ; lastUsing := '*' ;
         var j : int ; j := i ; while j < n do ( (     var c : String ; c := t->at(j+1) ;
     if (c = 'r') then (     if (lastUsing /= 'p') then (     ans := ans+(p) ; 
     lastUsing := 'p' ) else (     lastUsing := '*' ) ) else     if (c = 's') then (     if (lastUsing /= 'r') then (     ans := ans+(r) ; 
     lastUsing := 'r' ) else (     lastUsing := '*' ) ) else     if (c = 'p') then (     if (lastUsing /= 's') then (     ans := ans+(s) ; 
     lastUsing := 's' ) else (     lastUsing := '*' ) ) else skip ; ;  )  ;     j := j+(k) ) )  ;     i := i + 1 ) ; 
    os.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  private void doit(){
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] data=new int[n];
      for(int i=0 ; i<n ; i++){
        data[i]=sc.nextInt();
      }
      StringBuilder ans=new StringBuilder();
      int num=32 ;
      int ind=0 ;
      for(int i=0 ; ; i++){
        if(i % 2==0){
          int now=(num-1)% 5 ;
          num-=now ;
        }
        else {
          num-=data[ind % n];
          ind++;
        }
        if(num<0)num=0 ;
        ans.append(num+"\n");
        if(num==0)break ;
      }
      System.out.print(ans.toString());
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation doit() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var data : Sequence(int) ; data := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     data[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : String ; ans := StringLib.newString() ;
    var num : int ; num := 32 ;
    var ind : int ; ind := 0 ;
        var i : int ; i := 0 ; while true do ( (     if (i mod 2 = 0) then (     var now : int ; now := ((num)->char2byte() - 1) mod 5 ;
     num := num-(now) ) else (     num := num-(data[ind mod n+1]) ; 
     ind := ind + 1 ) ;  
     if (num < 0) then     num := 0 ; else skip ; 
     ans := ans + StringLib.newString(num + "\n") ; 
     if (num = 0) then     break else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(ans+"") ; 
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int i=parseInt(line);
      if(i==0)break ;
      int[] a=new int[i];
      words=br.readLine().split(" ");
      for(int j=0 ; j<i ; j++){
        a[j]=parseInt(words[j]);
      }
      int n=32,j=0 ;
      while(true){
        n-=(n-1)% 5 ;
        System.out.println(n);
        if(n<=0)break ;
        if(n>=a[j % i]){
          n-=a[j % i];
        }
        else {
          n=0 ;
        }
        j++;
        System.out.println(n);
        if(n<=0)break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var i : int ; i := parseInt(line) ;
     if (i = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,i)->collect(0) ;
    words := br.readLine()->split(" ") ; 
        var j : int ; j := 0 ; while j < i do ( (     a[j+1] := (words[j+1] + "")->toInteger() )  ;     j := j + 1 ) ; 
    var n : int ; n := 32 ;
    var j : int ; j := 0 ;
    while (true) do (     n := n-((n - 1) mod 5) ; 
     OclFile["System.out"].println(n) ; 
    if (n <= 0) then     break else skip ; 
    if (n >= a[j mod i+1]) then (     n := n-(a[j mod i+1]) ) else (     n := 0 ) ;  
    j := j + 1 ; 
    OclFile["System.out"].println(n) ; 
    if (n <= 0) then     break else skip ; 
 ) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(stdIn.hasNext()){
      int n=stdIn.nextInt();
      if(n==0){
        break ;
      }
      List<Integer>list=new ArrayList<Integer>();
      for(int i=0 ; i<n ; ++i){
        int a=stdIn.nextInt();
        list.add(a);
      }
      int ohajiki=32 ;
      int pos=0 ;
      boolean endFlag=false ;
      while(! endFlag){
        ohajiki-=(ohajiki-1)% 5 ;
        System.out.println(ohajiki);
        ohajiki-=list.get(pos);
        if(ohajiki<=0){
          endFlag=true ;
          System.out.println("0");
          continue ;
        }
        else {
          System.out.println(ohajiki);
        }
++pos ;
        if(pos>=n){
          pos=0 ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (stdIn.hasNext()) do (     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := stdIn.getCurrent()->toInteger() ;
     list := list->including(a) )  ;     i := i + 1 ) ; 
    var ohajiki : int ; ohajiki := 32 ;
    var pos : int ; pos := 0 ;
    var endFlag : boolean ; endFlag := false ;
    while (not(endFlag)) do (     ohajiki := ohajiki-((ohajiki - 1) mod 5) ; 
     OclFile["System.out"].println(ohajiki) ; 
    ohajiki := ohajiki-(list->at(pos+1)) ; 
    if (ohajiki <= 0) then (     endFlag := true ; 
     OclFile["System.out"].println("0") ; 
     continue ) else (     OclFile["System.out"].println(ohajiki) ) ;  
    pos := pos + 1 ; 
    if (pos >= n) then (     pos := 0 ) else skip ; 
 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minSteps(String str){
    int count=0 ;
    for(int i=0 ; i<str.length()-2 ; i++){
      if(((int)str.charAt(i))=='0'){
        if(str.charAt(i+1)=='1'){
          if(str.charAt(i+2)=='0'){
            count++;
            i+=2 ;
          }
        }
      }
    }
    return count ;
  }
  public static void main(String args[]){
    String str="0101010" ;
    System.out.println(minSteps(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minSteps( str : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < str->size() - 2 do ( (     if ((str->at(i+1)->oclAsType(int)) = '0') then (     if (str->at(i + 1+1) = '1') then (     if (str->at(i + 2+1) = '0') then (     count := count + 1 ; 
     i := i+(2) ) else skip ) else skip ) else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "0101010" ;
     OclFile["System.out"].println(minSteps(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int d=sc.nextInt();
      int e=sc.nextInt();
      int ans=0 ;
      if(a<0){
        ans=d+Math.abs(a)*c+b*e ;
      }
      else {
        if(a==0)ans+=d ;
        ans+=(b-a)*e ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var e : int ; e := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    if (a < 0) then (     ans := d + if a < 0 then -(a) else a endif * c + b * e ) else (     if (a = 0) then     ans := ans+(d) ; else skip ; 
     ans := ans+((b - a) * e) ) ;  
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    Scanner sc=new Scanner(systemin);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    int D=sc.nextInt();
    int E=sc.nextInt();
    int ret=0 ;
    if(B>0){
      if(A>0){
        ret=(B-A)*E ;
      }
      else {
        ret=B*E+D+(-A*C);
      }
    }
    else {
      ret=(B-A)*C ;
    }
    result.printf("%d\n",ret);
    sc.close();
    return false ;
  }
  PrintStream log ;
  PrintStream result=System.out ;
  BufferedReader systemin ;
  static Main instance=new Main();
  Main(){
    systemin=new BufferedReader(new InputStreamReader(System.in));
    log=new PrintStream(new OutputStream(){
      public void write(int b){
      }
    }
);
  }
  public static void main(String[] args)throws IOException {
    instance.main();
    instance.systemin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(systemin) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var D : int ; D := sc.getCurrent()->toInteger() ;
    var E : int ; E := sc.getCurrent()->toInteger() ;
    var ret : int ; ret := 0 ;
    if (B > 0) then (     if (A > 0) then (     ret := (B - A) * E ) else (     ret := B * E + D + (-A * C) ) ) else (     ret := (B - A) * C ) ;  
    result.printf("%d\n", ret) ; 
    skip ; 
    return false 
 );
   attribute log : OclFile;
   attribute result : OclFile := OclFile["System.out"];
   attribute systemin : OclFile;
  static   attribute instance : Main := Main.newMain();
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     systemin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     log := OclFile.newOclFile_Write(OclFile()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     instance.main() ; 
     instance.systemin.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minimumChanges(int arr[],int n,int d){
    int maxFreq=-1 ;
    HashMap<Integer,Integer>freq=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; ++i){
      int a0=arr[i]-(i)*d ;
      if(freq.containsKey(a0)){
        freq.put(a0,freq.get(a0)+1);
      }
      else freq.put(a0,1);
      if(freq.get(a0)>maxFreq)maxFreq=freq.get(a0);
    }
    return(n-maxFreq);
  }
  public static void main(String args[]){
    int n=5,d=1 ;
    int arr[]={
      1,3,3,4,6 };
      System.out.println(minimumChanges(arr,n,d));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumChanges( arr : Sequence(int), n : int, d : int) : int
  pre: true
  post: true
  activity: (     var maxFreq : int ; maxFreq := -1 ;
     var freq : Map(int,int) ; freq := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     var a0 : int ; a0 := arr[i+1] - (i) * d ;
     if (freq->keys()->includes(a0)) then (     freq := freq->union(Map{a0 |-> freq->at(a0) + 1}) ) else     freq := freq->union(Map{a0 |-> 1}) ; ;  
     if (freq->at(a0) > maxFreq) then     maxFreq := freq->at(a0) ; else skip )  ;     i := i + 1 ) ; 
     return (n - maxFreq) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var d : int ; d := 1 ;
     var arr : Sequence(int) ; arr := Sequence{1,3,3,4,6} ;
     OclFile["System.out"].println(minimumChanges(arr, n, d)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    int[] arg=new int[100];
    int i=0,sum=0,n=0,m=0 ;
    int[] dist=null,weather=null ;
    int state=0 ;
    int[] k=new int[5];
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String line ;
      while((line=br.readLine())!=null){
        k[0]=Integer.parseInt(line);
        k[1]=Integer.parseInt(br.readLine());
        k[2]=Integer.parseInt(br.readLine());
        k[3]=Integer.parseInt(br.readLine());
        k[4]=Integer.parseInt(br.readLine());
        if(k[0]<0){
          System.out.println(Math.abs(k[0])*k[2]+k[3]+k[1]*k[4]);
        }
        else {
          System.out.println((k[1]-k[0])*k[4]);
        }
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arg : Sequence(int) ; arg := Integer.subrange(1,100)->collect(0) ;
     var i : int ; i := 0 ;
    var sum : int ; sum := 0 ;
    var n : int ; n := 0 ;
    var m : int ; m := 0 ;
    var dist : Sequence(int) ; dist := null ;
    var weather : Sequence(int) ; weather := null ;
    var state : int ; state := 0 ;
    var k : Sequence(int) ; k := Integer.subrange(1,5)->collect(0) ;
    try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     k[0+1] := (line)->toInteger() ; 
     k[1+1] := (br.readLine())->toInteger() ; 
    k[2+1] := (br.readLine())->toInteger() ; 
    k[3+1] := (br.readLine())->toInteger() ; 
    k[4+1] := (br.readLine())->toInteger() ; 
    if (k[0+1] < 0) then (     OclFile["System.out"].println(if k[0+1] < 0 then -(k[0+1]) else k[0+1] endif * k[2+1] + k[3+1] + k[1+1] * k[4+1]) ) else (     OclFile["System.out"].println((k[1+1] - k[0+1]) * k[4+1]) ) ;  
    break 
 ) ;     line := br.readLine() ;
 ) ))  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    SC sc=new SC(System.in);
    int tempA=sc.nextInt();
    int tempB=sc.nextInt();
    int frost=sc.nextInt();
    int defrs=sc.nextInt();
    int hotte=sc.nextInt();
    if(tempA<0){
      pl(-tempA*frost+defrs+tempB*hotte);
    }
    else {
      pl((tempB-tempA)*hotte);
    }
  }
  public static void pl(Object o){
    System.out.println(o);
  }
  public static void pl(){
    System.out.println();
  }
  public static void p(Object o){
    System.out.print(o);
  }
  static class SC {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public SC(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        throw new UncheckedIOException(e);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : SC ; sc := SC.newSC(OclFile["System.in"]) ;
     var tempA : int ; tempA := sc.nextInt() ;
    var tempB : int ; tempB := sc.nextInt() ;
    var frost : int ; frost := sc.nextInt() ;
    var defrs : int ; defrs := sc.nextInt() ;
    var hotte : int ; hotte := sc.nextInt() ;
    if (tempA < 0) then (     execute pl(-tempA * frost + defrs + tempB * hotte) ) else (     execute pl((tempB - tempA) * hotte) ) ;  
 );
  static   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation pl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
  static class SC {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newSC( in : OclFile) : SC
  pre: true
  post: true
  activity:
  ( var self : SC ;
    self := createSC();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.security.NoSuchAlgorithmException ;
import java.util.ArrayList ;
import java.util.HashMap ;
public class Main {
  public static HashMap<String,String>map=new HashMap<>();
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a[]=new int[5];
    for(int i=0 ; i<5 ; i++){
      a[i]=sc.nextInt();
    }
    int time=(Math.abs(Math.min(0,a[0]))*a[2])+(a[0]<=0 ? a[3] : 0)+((a[1]-Math.max(a[0],0))*a[4]);
    System.out.println(time);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute map : Map(String,String) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,5)->collect(0) ;
        var i : int ; i := 0 ; while i < 5 do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var time : int ; time := (if Set{0, a[0+1]}->min() < 0 then -(Set{0, a[0+1]}->min()) else Set{0, a[0+1]}->min() endif * a[2+1]) + (if a[0+1] <= 0 then a[3+1] else 0 endif) + ((a[1+1] - Set{a[0+1], 0}->max()) * a[4+1]) ;
    OclFile["System.out"].println(time) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    final int n=sc.nextInt();
    final int k=sc.nextInt();
    final int r=sc.nextInt();
    final int s=sc.nextInt();
    final int p=sc.nextInt();
    final String t=sc.next();
    final char[] hands={
      'r','s','p' };
      final Map<Character,Character>bestChoiceMap=new HashMap<>();
      bestChoiceMap.put('r','p');
      bestChoiceMap.put('s','r');
      bestChoiceMap.put('p','s');
      long ans=0 ;
      final char[] actual=new char[n];
      for(int i=0 ; i<n ; i++){
        final char prevHand=i-k>=0 ? actual[i-k] : 0 ;
        final char c=t.charAt(i);
        final char nextC=i+k<n ? t.charAt(i+k): 0 ;
        actual[i]=bestChoiceMap.get(c);
        if(actual[i]==prevHand){
          for(char hand : hands){
            if((nextC==0 || hand!=bestChoiceMap.get(nextC))&& hand!=prevHand){
              actual[i]=hand ;
            }
          }
        }
        if(actual[i]=='r' && c=='s')ans+=r ;
        if(actual[i]=='s' && c=='p')ans+=s ;
        if(actual[i]=='p' && c=='r')ans+=p ;
      }
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
    var t : String ; t := sc.getCurrent() ;
    var hands : Sequence(String) ; hands := Sequence{'r','s','p'} ;
    var bestChoiceMap : Map(String,String) ; bestChoiceMap := Map{} ;
    bestChoiceMap := bestChoiceMap->union(Map{'r' |-> 'p'}) ; 
    bestChoiceMap := bestChoiceMap->union(Map{'s' |-> 'r'}) ; 
    bestChoiceMap := bestChoiceMap->union(Map{'p' |-> 's'}) ; 
    var ans : long ; ans := 0 ;
    var actual : Sequence(String) ; actual := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var prevHand : String ; prevHand := if i - k >= 0 then actual[i - k+1] else 0 endif ;
     var c : String ; c := t->at(i+1) ;
    var nextC : String ; nextC := if i + k < n then t->at(i + k+1) else 0 endif ;
    actual[i+1] := bestChoiceMap->at(c) ; 
    if (actual[i+1] = prevHand) then (     for (hand : hands) do ( (     if ((nextC = 0 or hand /= bestChoiceMap->at(nextC)) & hand /= prevHand) then (     actual[i+1] := hand ) else skip )  ) ) else skip ; 
    if (actual[i+1] = 'r' & c = 's') then     ans := ans+(r) ; else skip ; 
    if (actual[i+1] = 's' & c = 'p') then     ans := ans+(s) ; else skip ; 
    if (actual[i+1] = 'p' & c = 'r') then     ans := ans+(p) ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Codeforces {
  public static void main(String[] args)throws IOException {
    Scanner scan=new Scanner(System.in);
    StringBuilder out=new StringBuilder();
    StringTokenizer tk ;
    Reader.init(System.in);
    StringBuilder strB=new StringBuilder();
    String str=Reader.next();
    int countX=0 ;
    int countY=0 ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)=='x')countX++;
      else countY++;
    }
    if(countX>countY)for(int i=0 ;
    i<countX-countY ;
    i++){
      strB.append("x");
    }
    else for(int i=0 ;
    i<countY-countX ;
    i++){
      strB.append("y");
    }
    System.out.println(strB);
  }
}
class Reader {
  static BufferedReader reader ;
  static StringTokenizer tokenizer ;
  static void init(InputStream input)throws UnsupportedEncodingException {
    reader=new BufferedReader(new InputStreamReader(input,"UTF-8"));
    tokenizer=new StringTokenizer("");
  }
  static String next()throws IOException {
    while(! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  static String nextLine()throws IOException {
    return reader.readLine();
  }
  static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  static long nextLong()throws IOException {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : String ; out := StringLib.newString() ;
    var tk : OclIterator ;
    Reader.init(OclFile["System.in"]) ; 
    var strB : String ; strB := StringLib.newString() ;
    var str : String ; str := Reader.next() ;
    var countX : int ; countX := 0 ;
    var countY : int ; countY := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = 'x') then     countX := countX + 1 ; else     countY := countY + 1 ; )  ;     i := i + 1 ) ; 
    if (countX > countY) then         var i : int ; i := 0 ; while i < (countX)->char2byte() - countY do ( (     strB := strB + StringLib.newString("x") )  ;     i := i + 1 ) else         var i : int ; i := 0 ; while i < countY - (countX)->char2byte() do ( (     strB := strB + StringLib.newString("y") )  ;     i := i + 1 ) ; ;  
    OclFile["System.out"].println(strB) ; 
 );
}
class Reader {
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   operation init( input : OclFile) : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(input, "UTF-8")) ; 
     tokenizer := OclIterator.newOclIterator_String("") );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     return reader.readLine() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.nio.charset.*;
import java.util.*;
public class TestClass {
  public static void main(String[] args)throws Exception {
    StringBuilder out=new StringBuilder();
    StringTokenizer tk ;
    Reader.init(System.in);
    String s=Reader.next();
    StringBuilder ss=new StringBuilder();
    int x=0 ;
    int y=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='x'){
        x++;
      }
      else {
        y++;
      }
    }
    if(x>y){
      for(int i=0 ; i<x-y ; i++){
        ss.append('x');
      }
    }
    else {
      for(int i=0 ; i<y-x ; i++){
        ss.append('y');
      }
    }
    System.out.println(ss);
  }
}
class Reader {
  static BufferedReader reader ;
  static StringTokenizer tokenizer ;
  static void init(InputStream input)throws UnsupportedEncodingException {
    reader=new BufferedReader(new InputStreamReader(input,StandardCharsets.UTF_8));
    tokenizer=new StringTokenizer("");
  }
  static String next()throws IOException {
    while(! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  static String nextLine()throws IOException {
    return reader.readLine();
  }
  static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  static long nextLong()throws IOException {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class TestClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : String ; out := StringLib.newString() ;
     var tk : OclIterator ;
    Reader.init(OclFile["System.in"]) ; 
    var s : String ; s := Reader.next() ;
    var ss : String ; ss := StringLib.newString() ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'x') then (     x := x + 1 ) else (     y := y + 1 ) )  ;     i := i + 1 ) ; 
    if (x > y) then (         var i : int ; i := 0 ; while i < (x)->char2byte() - y do ( (     ss := ss + StringLib.newString('x') )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < y - (x)->char2byte() do ( (     ss := ss + StringLib.newString('y') )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(ss) ; 
 );
}
class Reader {
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   operation init( input : OclFile) : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(input, StandardCharsets.UTF_8)) ; 
     tokenizer := OclIterator.newOclIterator_String("") );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     return reader.readLine() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B_Code_Parsing {
  static Scanner in=new Scanner(System.in);
  static int n ;
  static char a[];
  public static void main(String[] amit){
    a=in.next().toCharArray();
    n=a.length ;
    if(n==1){
      System.out.print(a[0]);
      return ;
    }
    int x=0,y=0 ;
    StringBuilder ans=new StringBuilder();
    for(char i : a){
      if(i=='x'){
++x ;
      }
      else {
++y ;
      }
    }
    if(x==y){
    }
    else if(x>y){
      x-=y ;
      while(x-->0){
        ans.append('x');
      }
    }
    else {
      y-=x ;
      while(y-->0){
        ans.append('y');
      }
    }
    System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Code_Parsing {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   attribute a : Sequence(String);
  static   operation main( amit : Sequence(String)) : void
  pre: true
  post: true
  activity: (     a := in.getCurrent()->characters() ; 
     n := a->size() ; 
    if (n = 1) then (     OclFile["System.out"].print(a[0+1]) ; 
     return ) else skip ; 
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var ans : String ; ans := StringLib.newString() ;
    for (i : a) do ( (     if (i = 'x') then (     x := x + 1 ) else (     y := y + 1 ) )  ) ; 
    if (x = y) then skip else     if (x > y) then (     x := x-(y) ; 
         while (x > 0) do (        x := x - 1 ;     skip ; (     ans := ans + StringLib.newString('x') ) ;  ) ) else (     y := y-(x) ; 
         while (y > 0) do (        y := y - 1 ;     skip ; (     ans := ans + StringLib.newString('y') ) ;  ) ) ;  ;  
    OclFile["System.out"].print(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
public class Main {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
      String str=br.readLine();
      if(! str.contains("x")|| ! str.contains("y")){
        bw.append(str+"\n");
      }
      else {
        int x=0,y=0 ;
        for(char ch : str.toCharArray()){
          if(ch=='x')x++;
          if(ch=='y')y++;
        }
        StringBuilder ans=new StringBuilder();
        if(x>y){
          for(int i=0 ; i<(x-y); i++)ans.append('x');
        }
        else if(x<y){
          for(int i=0 ; i<(y-x); i++)ans.append('y');
        }
        bw.append(ans.toString()+"\n");
      }
      bw.flush();
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var str : String ; str := br.readLine() ;
    if (not(str->includes("x")) or not(str->includes("y"))) then (     skip ) else (     var x : int ; x := 0 ;
    var y : int ; y := 0 ;
     for (ch : str->characters()) do ( (     if (ch = 'x') then     x := x + 1 ; else skip ; 
     if (ch = 'y') then     y := y + 1 ; else skip )  ) ; 
    var ans : String ; ans := StringLib.newString() ;
    if (x > y) then (         var i : int ; i := 0 ; while i < ((x)->char2byte() - (y)->char2byte()) do (     ans := ans + StringLib.newString('x') ;  ;     i := i + 1 ) ) else     if (x < y) then (         var i : int ; i := 0 ; while i < ((y)->char2byte() - (x)->char2byte()) do (     ans := ans + StringLib.newString('y') ;  ;     i := i + 1 ) ) else skip ; ;  
    skip ; 
 ) ;  
    skip ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean EqualNumbers(int a[],int n){
    for(int i=0 ; i<n ; i++){
      while(a[i] % 2==0){
        a[i]/=2 ;
      }
      while(a[i] % 3==0){
        a[i]/=3 ;
      }
      if(a[i]!=a[0]){
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    int a[]={
      50,75,150 };
      int n=a.length ;
      if(EqualNumbers(a,n)){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation EqualNumbers( a : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     while (a[i+1] mod 2 = 0) do (     a[i+1] := a[i+1]/(2) ) ; 
     while (a[i+1] mod 3 = 0) do (     a[i+1] := a[i+1]/(3) ) ; 
     if (a[i+1] /= a[0+1]) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{50,75,150} ;
     var n : int ; n := a->size() ;
     if (EqualNumbers(a, n)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int n=input.nextInt();
    int k=input.nextInt();
    ArrayDeque<Integer>a=new ArrayDeque<>();
    for(int i=0 ; i<n ; i++){
      a.add(input.nextInt());
    }
    int total=0 ;
    while(! a.isEmpty()){
      if(a.peekFirst()<=k){
        total++;
        a.pollFirst();
      }
      else if(a.peekLast()<=k){
        total++;
        a.pollLast();
      }
      else break ;
    }
    System.out.println(total);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var n : int ; n := input.nextInt() ;
    var k : int ; k := input.nextInt() ;
    var a : Sequence(int) ; a := ArrayDeque<OclAny>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < n do ( (     a := a->including(input.nextInt()) )  ;     i := i + 1 ) ; 
    var total : int ; total := 0 ;
    while (not(a->isEmpty())) do (     if (a.peekFirst() <= k) then (     total := total + 1 ; 
     a := a->tail() ) else     if (a.peekLast() <= k) then (     total := total + 1 ; 
     a := a->front() ) else     break ;  ) ; 
    OclFile["System.out"].println(total) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.*;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=input.nextInt();
    int[][] vec=new int[n][4];
    for(int i=0 ; i<n ; i++){
      vec[i][0]=input.nextInt();
      vec[i][1]=input.nextInt();
      vec[i][2]=input.nextInt();
      vec[i][3]=input.nextInt();
    }
    int ans=500 ;
    int ansprice=20000 ;
    for(int i=0 ; i<n ; i++){
      int fl=1 ;
      for(int j=0 ; j<n ; j++){
        if(vec[i][0]<vec[j][0] && vec[i][1]<vec[j][1] && vec[i][2]<vec[j][2]){
          fl=0 ;
        }
      }
      if(fl==1){
        if(vec[i][3]<ansprice){
          ansprice=vec[i][3];
          ans=i+1 ;
        }
      }
    }
    System.out.println(ans);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := input.getCurrent()->toInteger() ;
    var vec : Sequence(Sequence(int)) ; vec := Integer.subrange(1,n)->collect(Integer.subrange(1,4)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     vec[i+1][0+1] := input.getCurrent()->toInteger() ; 
     vec[i+1][1+1] := input.getCurrent()->toInteger() ; 
     vec[i+1][2+1] := input.getCurrent()->toInteger() ; 
     vec[i+1][3+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 500 ;
    var ansprice : int ; ansprice := 20000 ;
        var i : int ; i := 0 ; while i < n do ( (     var fl : int ; fl := 1 ;
         var j : int ; j := 0 ; while j < n do ( (     if (vec[i+1][0+1] < vec[j+1][0+1] & vec[i+1][1+1] < vec[j+1][1+1] & vec[i+1][2+1] < vec[j+1][2+1]) then (     fl := 0 ) else skip )  ;     j := j + 1 ) ; 
     if (fl = 1) then (     if (vec[i+1][3+1] < ansprice) then (     ansprice := vec[i+1][3+1] ; 
     ans := i + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _999A_MishkaandContest {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    final int n=input.nextInt();
    final int k=input.nextInt();
    LinkedList<Integer>list=new LinkedList<>();
    for(int i=0 ; i<n ; i++){
      list.add(input.nextInt());
    }
    while(! list.isEmpty()&& list.peekFirst()<=k){
      list.pollFirst();
    }
    while(! list.isEmpty()&& list.peekLast()<=k){
      list.pollLast();
    }
    System.out.println(n-list.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class _999A_MishkaandContest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var k : int ; k := input.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    while (not(list->isEmpty()) & list.peekFirst() <= k) do (     list := list->tail() ) ; 
    while (not(list->isEmpty()) & list.peekLast() <= k) do (     list := list->front() ) ; 
    OclFile["System.out"].println(n - list->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class esep {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    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 count=0 ;
    int l=0 ;
    int r=n-1 ;
    while(l<arr.length && r>=0){
      if(arr[l]<=k){
++count ;
++l ;
      }
      else if(arr[r]<=k){
++count ;
--r ;
      }
      else {
        break ;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class esep {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var l : int ; l := 0 ;
    var r : int ; r := n - 1 ;
    while (l < arr->size() & r >= 0) do (     if (arr[l+1] <= k) then (     count := count + 1 ; 
     l := l + 1 ) else     if (arr[r+1] <= k) then (     count := count + 1 ; 
     r := r - 1 ) else (     break ) ;  ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.System.*;
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    int num=Integer.parseInt(sc.next());
    int difficulty=Integer.parseInt(sc.next());
    int counter=0 ;
    int arr[]=new int[num];
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=Integer.parseInt(sc.next());
    }
    for(int j=0 ; j<arr.length ; j++){
      if(difficulty>=arr[j]){
        counter++;
      }
      else {
        for(int x=arr.length-1 ; x>=0 ; x--){
          if(difficulty>=arr[x])counter++;
          else break ;
        }
        break ;
      }
    }
    out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var num : int ; num := (sc.getCurrent())->toInteger() ;
    var difficulty : int ; difficulty := (sc.getCurrent())->toInteger() ;
    var counter : int ; counter := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,num)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < arr->size() do ( (     if (difficulty >= arr[j+1]) then (     counter := counter + 1 ) else (         var x : int ; x := arr->size() - 1 ; while x >= 0 do ( (     if (difficulty >= arr[x+1]) then     counter := counter + 1 ; else     break )  ;     x := x - 1 ) ; 
     break ) )  ;     j := j + 1 ) ; 
    out.println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class _999a_MishakAndContest {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
    }
    int counter=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]<=k){
        counter++;
      }
      else {
        break ;
      }
    }
    if(counter<n){
      for(int i=n-1 ; i>=0 ; i--){
        if(arr[i]<=k){
          counter++;
        }
        else {
          break ;
        }
      }
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _999a_MishakAndContest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] <= k) then (     counter := counter + 1 ) else (     break ) )  ;     i := i + 1 ) ; 
    if (counter < n) then (         var i : int ; i := n - 1 ; while i >= 0 do ( (     if (arr[i+1] <= k) then (     counter := counter + 1 ) else (     break ) )  ;     i := i - 1 ) ) else skip ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    final int N=Integer.parseInt(sc.next());
    final int K=Integer.parseInt(sc.next());
    final int R=Integer.parseInt(sc.next());
    final int S=Integer.parseInt(sc.next());
    final int P=Integer.parseInt(sc.next());
    final char T[]=sc.next().toCharArray();
    sc.close();
    List<Character>C=new ArrayList<>();
    for(char t : T){
      if(t=='r'){
        C.add('p');
      }
      else if(t=='s'){
        C.add('r');
      }
      else {
        C.add('s');
      }
    }
    for(int i=0 ; i<N-K ; i++){
      if(C.get(i)==C.get(i+K)){
        C.set(i+K,'x');
      }
    }
    long sum=0 ;
    for(int i=0 ; i<N ; i++){
      if(C.get(i)=='p'){
        sum+=P ;
      }
      else if(C.get(i)=='r'){
        sum+=R ;
      }
      else if(C.get(i)=='s'){
        sum+=S ;
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var K : int ; K := (sc.getCurrent())->toInteger() ;
    var R : int ; R := (sc.getCurrent())->toInteger() ;
    var S : int ; S := (sc.getCurrent())->toInteger() ;
    var P : int ; P := (sc.getCurrent())->toInteger() ;
    var T : Sequence(String) ; T := sc.getCurrent()->characters() ;
    skip ; 
    var C : Sequence(String) ; C := Sequence{} ;
    for (t : T) do ( (     if (t = 'r') then (     C := C->including('p') ) else     if (t = 's') then (     C := C->including('r') ) else (     C := C->including('s') ) ;  )  ) ; 
        var i : int ; i := 0 ; while i < N - K do ( (     if (C->at(i+1) = C->at(i + K+1)) then (     C := C.setAt(i + K+1,'x') ) else skip )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (C->at(i+1) = 'p') then (     sum := sum+(P) ) else     if (C->at(i+1) = 'r') then (     sum := sum+(R) ) else     if (C->at(i+1) = 's') then (     sum := sum+(S) ) else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
public class Main {
  static List<List<Integer>>perms=new ArrayList<>();
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    BigInteger a=new BigInteger(sc.next());
    BigInteger b=new BigInteger(sc.next());
    BigInteger x=new BigInteger(sc.next());
    BigInteger y=new BigInteger(sc.next());
    BigInteger gcd=x.gcd(y);
    System.out.println(a.divide(x.divide(gcd)).min(b.divide(y.divide(gcd))));
  }
  public static void heapsAlgo(int k,int[] A){
    if(k==1){
      List<Integer>list=new ArrayList<>();
      for(int i=0 ; i<A.length ; i++){
        list.add(A[i]);
      }
      perms.add(list);
    }
    else {
      heapsAlgo(k-1,A);
      for(int i=0 ; i<k-1 ; i++){
        if(k % 2==0){
          int temp=A[i];
          A[i]=A[k-1];
          A[k-1]=temp ;
        }
        else {
          int temp=A[0];
          A[0]=A[k-1];
          A[k-1]=temp ;
        }
        heapsAlgo(k-1,A);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute perms : Sequence(Sequence(int)) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := long(sc.getCurrent()) ;
    var b : long ; b := long(sc.getCurrent()) ;
    var x : long ; x := long(sc.getCurrent()) ;
    var y : long ; y := long(sc.getCurrent()) ;
    var gcd : long ; gcd := x.gcd(y) ;
    OclFile["System.out"].println(a.divide(x.divide(gcd))->min()) ; 
 );
  static   operation heapsAlgo( k : int, A : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (k = 1) then (     var list : Sequence(int) ; list := Sequence{} ;
         var i : int ; i := 0 ; while i < A->size() do ( (     list := list->including(A[i+1]) )  ;     i := i + 1 ) ; 
     perms := perms->including(list) ) else (     execute heapsAlgo(k - 1, A) ; 
         var i : int ; i := 0 ; while i < k - 1 do ( (     if (k mod 2 = 0) then (     var temp : int ; temp := A[i+1] ;
     A[i+1] := A[k - 1+1] ; 
     A[k - 1+1] := temp ) else (     var temp : int ; temp := A[0+1] ;
     A[0+1] := A[k - 1+1] ; 
     A[k - 1+1] := temp ) ;  
     execute heapsAlgo(k - 1, A) )  ;     i := i + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B_1041 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long arr[]=new long[4];
    for(int i=0 ; i<4 ; i++)arr[i]=sc.nextLong();
    long hcf=gcd(Math.min(arr[2],arr[3]),Math.max(arr[2],arr[3]));
    arr[2]/=hcf ;
    arr[3]/=hcf ;
    long ans=Math.min(arr[0]/arr[2],arr[1]/arr[3]);
    System.out.println(ans);
  }
  static long gcd(long a,long b){
    if(b % a==0)return(a);
    else return(gcd(b % a,a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_1041 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(long) ; arr := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do (     arr[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var hcf : long ; hcf := gcd(Set{arr[2+1], arr[3+1]}->min(), Set{arr[2+1], arr[3+1]}->max()) ;
    arr[2+1] := arr[2+1]/(hcf) ; 
    arr[3+1] := arr[3+1]/(hcf) ; 
    var ans : long ; ans := Set{arr[0+1] / arr[2+1], arr[1+1] / arr[3+1]}->min() ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b mod a = 0) then     return (a) else     return (gcd(b mod a, a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long[] arr=new long[4];
    for(int i=0 ; i<4 ; i++){
      arr[i]=sc.nextLong();
    }
    long gcdofxy=gcd(arr[2],arr[3]);
    arr[2]=arr[2]/gcdofxy ;
    arr[3]=arr[3]/gcdofxy ;
    long answer=Math.min(arr[0]/arr[2],arr[1]/arr[3]);
    System.out.println(answer);
  }
  private static long gcd(long a,long b){
    if(a==0){
      return b ;
    }
    return gcd(b % a,a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(long) ; arr := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     arr[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var gcdofxy : long ; gcdofxy := gcd(arr[2+1], arr[3+1]) ;
    arr[2+1] := arr[2+1] / gcdofxy ; 
    arr[3+1] := arr[3+1] / gcdofxy ; 
    var answer : long ; answer := Set{arr[0+1] / arr[2+1], arr[1+1] / arr[3+1]}->min() ;
    OclFile["System.out"].println(answer) ; 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then (     return b ) else skip ; 
     return gcd(b mod a, a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TwoElevators {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int testCases=scanner.nextInt();
    for(int i=0 ; i<testCases ; i++){
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      int c=scanner.nextInt();
      System.out.println(twoElevators(a,b,c));
    }
  }
  private static int twoElevators(int a,int b,int c){
    if(a==1){
      return 1 ;
    }
    int tempA=Math.abs(a-1);
    int tempB=0 ;
    if(c==1){
      tempB=Math.abs(c-b);
    }
    else {
      tempB=Math.abs(c-b)+Math.abs(c-1);
    }
    if(tempA==tempB){
      return 3 ;
    }
    else if(tempA>tempB){
      return 2 ;
    }
    else {
      return 1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TwoElevators {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < testCases do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
     var c : int ; c := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(twoElevators(a, b, c)) )  ;     i := i + 1 ) );
  static   operation twoElevators( a : int, b : int, c : int) : int
  pre: true
  post: true
  activity: (     if (a = 1) then (     return 1 ) else skip ; 
     var tempA : int ; tempA := if a - 1 < 0 then -(a - 1) else a - 1 endif ;
    var tempB : int ; tempB := 0 ;
    if (c = 1) then (     tempB := if c - b < 0 then -(c - b) else c - b endif ) else (     tempB := if c - b < 0 then -(c - b) else c - b endif + if c - 1 < 0 then -(c - 1) else c - 1 endif ) ;  
    if (tempA = tempB) then (     return 3 ) else     if (tempA > tempB) then (     return 2 ) else (     return 1 ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class laptops {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int[][] laptops=new int[s.nextInt()][4];
    boolean[] obselete=new boolean[laptops.length];
    for(int i=0 ; i<laptops.length ; i++){
      for(int k=0 ; k<4 ; k++){
        laptops[i][k]=s.nextInt();
      }
    }
    for(int i=0 ; i<laptops.length ; i++){
      for(int n=0 ; n<laptops.length ; n++){
        if(n!=i){
          for(int k=0 ; k<4 ; k++){
            if(laptops[i][k]>=laptops[n][k]){
              break ;
            }
            if(k==3){
              obselete[i]=true ;
            }
          }
        }
      }
    }
    int cheapest=Integer.MAX_VALUE ;
    int index=-1 ;
    for(int i=0 ; i<laptops.length ; i++){
      if(obselete[i]!=true){
        if(laptops[i][3]<cheapest){
          cheapest=laptops[i][3];
          index=i ;
        }
      }
    }
    System.out.print(index+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class laptops {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var laptops : Sequence(Sequence(int)) ; laptops := Integer.subrange(1,s.getCurrent()->toInteger())->collect(Integer.subrange(1,4)->collect(0)) ;
    var obselete : Sequence(boolean) ; obselete := Integer.subrange(1,laptops->size())->collect(false) ;
        var i : int ; i := 0 ; while i < laptops->size() do ( (         var k : int ; k := 0 ; while k < 4 do ( (     laptops[i+1][k+1] := s.getCurrent()->toInteger() )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < laptops->size() do ( (         var n : int ; n := 0 ; while n < laptops->size() do ( (     if (n /= i) then (         var k : int ; k := 0 ; while k < 4 do ( (     if (laptops[i+1][k+1] >= laptops[n+1][k+1]) then (     break ) else skip ; 
     if (k = 3) then (     obselete[i+1] := true ) else skip )  ;     k := k + 1 ) ) else skip )  ;     n := n + 1 ) )  ;     i := i + 1 ) ; 
    var cheapest : int ; cheapest := 2147483647 ;
    var index : int ; index := -1 ;
        var i : int ; i := 0 ; while i < laptops->size() do ( (     if (obselete[i+1] /= true) then (     if (laptops[i+1][3+1] < cheapest) then (     cheapest := laptops[i+1][3+1] ; 
     index := i ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(index + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A1729 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      long a=sc.nextLong();
      long b=sc.nextLong();
      long c=sc.nextLong();
      long j=Math.abs(b-c)+c ;
      if(a<j){
        System.out.println("1");
      }
      else if(a>j){
        System.out.println("2");
      }
      else {
        System.out.println("3");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1729 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tt : int ; tt := 0 ; while tt < t do ( (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
    var c : long ; c := sc.getCurrent()->toLong() ;
    var j : long ; j := if b - c < 0 then -(b - c) else b - c endif + c ;
    if (a < j) then (     OclFile["System.out"].println("1") ) else     if (a > j) then (     OclFile["System.out"].println("2") ) else (     OclFile["System.out"].println("3") ) ;  ;  
 )  ;     tt := tt + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Skeleton {
  public Skeleton(){
  }
  static class FastReader {
    public BufferedReader br ;
    public StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
      st=null ;
    }
    public String next(){
      while(st==null || ! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
    String nextLine(){
      String str="" ;
      try {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader fr=new FastReader();
    int t=fr.nextInt();
    while(t-->0){
      int a=fr.nextInt();
      int b=fr.nextInt();
      int c=fr.nextInt();
      if(a-1<Math.abs(c-b)+Math.abs(c-1))System.out.println(1);
      else if(a-1>Math.abs(c-b)+Math.abs(c-1))System.out.println(2);
      else System.out.println(3);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Skeleton {
   static operation newSkeleton() : Skeleton
  pre: true
  post: true
  activity:
  ( var self : Skeleton ;
    self := createSkeleton();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fr : FastReader ; fr := FastReader.newFastReader() ;
     var t : int ; t := fr.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := fr.nextInt() ;
     var b : int ; b := fr.nextInt() ;
     var c : int ; c := fr.nextInt() ;
     if (a - 1 < if c - b < 0 then -(c - b) else c - b endif + if c - 1 < 0 then -(c - 1) else c - 1 endif) then     OclFile["System.out"].println(1) ; else     if (a - 1 > if c - b < 0 then -(c - b) else c - b endif + if c - 1 < 0 then -(c - 1) else c - 1 endif) then     OclFile["System.out"].println(2) else     OclFile["System.out"].println(3) ; ;  ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public Main(){
    int t=sc.nextInt();
    sc.nextLine();
    for(int i=0 ; i<t ; i++){
      String in=sc.nextLine();
      int a=Integer.parseInt(in.split(" ")[0]);
      int b=Integer.parseInt(in.split(" ")[1]);
      int c=Integer.parseInt(in.split(" ")[2]);
      int l2=Math.abs(c-b)+c-1 ;
      if(a-1<l2)System.out.println(1);
      else if(a-1>l2)System.out.println(2);
      else System.out.println(3);
    }
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
     skip ; 
         var i : int ; i := 0 ; while i < t do ( (     var in : String ; in := sc.nextLine() ;
     var a : int ; a := (in->split(" ")[0+1])->toInteger() ;
    var b : int ; b := (in->split(" ")[1+1])->toInteger() ;
    var c : int ; c := (in->split(" ")[2+1])->toInteger() ;
    var l2 : int ; l2 := if c - b < 0 then -(c - b) else c - b endif + c - 1 ;
    if ((a)->char2byte() - 1 < l2) then     OclFile["System.out"].println(1) else     if ((a)->char2byte() - 1 > l2) then     OclFile["System.out"].println(2) else     OclFile["System.out"].println(3) ; ;  ;  
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p134 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p134().run());
  }
  public String run(){
    long sum=0 ;
    int[] primes=Library.listPrimes(2000000);
    for(int i=2 ; primes[i]<=1000000 ; i++){
      int p=primes[i];
      int q=primes[i+1];
      int k=1 ;
      while(k<p)k*=10 ;
      long m=(long)(q-p)*Library.reciprocalMod(k % q,q)% q ;
      sum+=m*k+p ;
    }
    return Long.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
class p134 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p134.newp134().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     var primes : Sequence(int) ; primes := Library.listPrimes(2000000) ;
         var i : int ; i := 2 ; while primes[i+1] <= 1000000 do ( (     var p : int ; p := primes[i+1] ;
     var q : int ; q := primes[i + 1+1] ;
    var k : int ; k := 1 ;
    while (k < p) do     k := k*(10) ; ; 
    var m : long ; m := (q - p)->oclAsType(long) * Library.reciprocalMod(k mod q, q) mod q ;
    sum := sum+(m * k + p) ; 
 )  ;     i := i + 1 ) ; 
     return ((sum) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] B=new int[N-1];
    for(int i=0 ; i<N-1 ; i++){
      B[i]=sc.nextInt();
    }
    int[] A=new int[N];
    for(int i=0 ; i<N-2 ; i++){
      if(B[i]==B[i+1]){
        A[i+1]=B[i];
      }
      else if(B[i]<B[i+1]){
        A[i+1]=B[i];
      }
      else if(B[i]>B[i+1]){
        A[i+1]=B[i+1];
      }
    }
    A[0]=B[0];
    A[N-1]=B[N-2];
    int ans=0 ;
    for(int i=0 ; i<N ; i++){
      ans+=A[i];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var B : Sequence(int) ; B := Integer.subrange(1,N - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     B[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N - 2 do ( (     if (B[i+1] = B[i + 1+1]) then (     A[i + 1+1] := B[i+1] ) else     if (B[i+1] < B[i + 1+1]) then (     A[i + 1+1] := B[i+1] ) else     if (B[i+1] > B[i + 1+1]) then (     A[i + 1+1] := B[i + 1+1] ) else skip ; ;  )  ;     i := i + 1 ) ; 
    A[0+1] := B[0+1] ; 
    A[N - 1+1] := B[N - 2+1] ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     ans := ans+(A[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    MyScanner in=new MyScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    C solver=new C();
    solver.solve(1,in,out);
    out.close();
  }
  static class C {
    public void solve(int testNumber,MyScanner in,PrintWriter out){
      int N=in.Int();
      int[] a=in.Int(N);
      int ans=0 ;
      for(int n : a){
        while(1!=(n & 1)){
          ans++;
          n>>=1 ;
        }
      }
      out.println(ans);
    }
  }
  static class MyScanner {
    private BufferedReader in ;
    private StringTokenizer st ;
    public MyScanner(InputStream stream){
      in=new BufferedReader(new InputStreamReader(stream));
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          String rl=in.readLine();
          if(rl==null){
            return null ;
          }
          st=new StringTokenizer(rl);
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    public int Int(){
      return Integer.parseInt(next());
    }
    public int[] Int(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=Int();
      }
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : MyScanner ; in := MyScanner.newMyScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : C ; solver := C.newC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class C {
   operation solve( testNumber : int, in : MyScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.Int() ;
     var a : Sequence(int) ; a := in.Int(N) ;
    var ans : int ; ans := 0 ;
    for (n : a) do ( (     while (1 /= (n & 1)) do (     ans := ans + 1 ; 
     n := n/(2->pow(1)) ) )  ) ; 
    skip ; 
 );
}
  static class MyScanner {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner( stream : OclFile) : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     var rl : String ; rl := in.readLine() ;
     if (rl = null) then (     return null ) else skip ; 
     st := OclIterator.newOclIterator_String(rl) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation Int() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation Int( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := Int() )  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    out=new PrintWriter(new BufferedOutputStream(System.out));
    int N=sc.nextInt();
    int K=sc.nextInt();
    int R=sc.nextInt();
    int S=sc.nextInt();
    int P=sc.nextInt();
    String t=sc.next();
    int dp[]=new int[N+K];
    int ans=0 ;
    for(int i=0 ; i<N ; i++){
      char op=t.charAt(i);
      int cand=0 ;
      switch(op){
        case 'r' : cand=1 ;
        break ;
        case 's' : cand=2 ;
        break ;
        case 'p' : cand=3 ;
        break ;
      }
      if(dp[i]!=cand){
        dp[i+K]=cand ;
        switch(cand){
          case 1 : ans+=P ;
          break ;
          case 2 : ans+=R ;
          break ;
          case 3 : ans+=S ;
          break ;
        }
      }
    }
    out.println(ans);
    out.close();
  }
  public static PrintWriter out ;
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var N : int ; N := sc.nextInt() ;
    var K : int ; K := sc.nextInt() ;
    var R : int ; R := sc.nextInt() ;
    var S : int ; S := sc.nextInt() ;
    var P : int ; P := sc.nextInt() ;
    var t : String ; t := sc.next() ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,N + K)->collect(0) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var op : String ; op := t->at(i+1) ;
     var cand : int ; cand := 0 ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (op) ; 
       if _switchval = 'r' then
     cand := 1 ; 
    break 
   else skip ;
       if _switchval = 's' then
     cand := 2 ; 
    break 
   else skip ;
       if _switchval = 'p' then
     cand := 3 ; 
    break 
   else skip ;
 )
     if (dp[i+1] /= cand) then (     dp[i + K+1] := cand ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (cand) ; 
       if _switchval = 1 then
     ans := ans+(P) ; 
    break 
   else skip ;
       if _switchval = 2 then
     ans := ans+(R) ; 
    break 
   else skip ;
       if _switchval = 3 then
     ans := ans+(S) ; 
    break 
   else skip ;
 )
 ) else skip )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
    out.close() ; 
 );
  static   attribute out : OclFile;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CMaximalValue solver=new CMaximalValue();
    solver.solve(1,in,out);
    out.close();
  }
  static class CMaximalValue {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int[] b=in.readIntArray(n-1);
      int[] a=new int[n];
      a[0]=b[0];
      a[n-1]=b[n-2];
      for(int i=1 ; i<n-1 ; i++){
        a[i]=Math.min(b[i-1],b[i]);
      }
      long answer=0 ;
      for(int x : a)answer+=x ;
      out.println(answer);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public int[] readIntArray(int n){
      int[] x=new int[n];
      for(int i=0 ; i<n ; i++){
        x[i]=nextInt();
      }
      return x ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CMaximalValue ; solver := CMaximalValue.newCMaximalValue() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CMaximalValue {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var b : Sequence(int) ; b := in.readIntArray(n - 1) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    a[0+1] := b[0+1] ; 
    a[n - 1+1] := b[n - 2+1] ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     a[i+1] := Set{b[i - 1+1], b[i+1]}->min() )  ;     i := i + 1 ) ; 
    var answer : long ; answer := 0 ;
    for (x : a) do (     answer := answer+(x) ;  ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     x[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return x );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.nio.CharBuffer ;
import java.util.NoSuchElementException ;
public class Main {
  public static void main(String[] args){
    SimpleScanner scanner=new SimpleScanner(System.in);
    PrintWriter writer=new PrintWriter(System.out);
    int n=scanner.nextInt();
    int pre=scanner.nextInt();
    int sum=pre ;
    for(int i=2 ; i<n ; ++i){
      int cur=scanner.nextInt();
      sum+=Math.min(pre,cur);
      pre=cur ;
    }
    sum+=pre ;
    writer.println(sum);
    writer.close();
  }
  private static class SimpleScanner {
    private static final int BUFFER_SIZE=10240 ;
    private Readable in ;
    private CharBuffer buffer ;
    private boolean eof ;
    SimpleScanner(InputStream in){
      this.in=new BufferedReader(new InputStreamReader(in));
      buffer=CharBuffer.allocate(BUFFER_SIZE);
      buffer.limit(0);
      eof=false ;
    }
    private char read(){
      if(! buffer.hasRemaining()){
        buffer.clear();
        int n ;
        try {
          n=in.read(buffer);
        }
        catch(IOException e){
          n=-1 ;
        }
        if(n<=0){
          eof=true ;
          return '\0' ;
        }
        buffer.flip();
      }
      return buffer.get();
    }
    private void checkEof(){
      if(eof)throw new NoSuchElementException();
    }
    private char nextChar(){
      checkEof();
      char b=read();
      checkEof();
      return b ;
    }
    private String next(){
      char b ;
      do {
        b=read();
        checkEof();
      }
      while(Character.isWhitespace(b));
      StringBuilder sb=new StringBuilder();
      do {
        sb.append(b);
        b=read();
      }
      while(! eof && ! Character.isWhitespace(b));
      return sb.toString();
    }
    private int nextInt(){
      return Integer.parseInt(next());
    }
    private long nextLong(){
      return Long.parseLong(next());
    }
    private double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : SimpleScanner ; scanner := SimpleScanner.newSimpleScanner(OclFile["System.in"]) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := scanner.nextInt() ;
    var pre : int ; pre := scanner.nextInt() ;
    var sum : int ; sum := pre ;
        var i : int ; i := 2 ; while i < n do ( (     var cur : int ; cur := scanner.nextInt() ;
     sum := sum+(Set{pre, cur}->min()) ; 
     pre := cur )  ;     i := i + 1 ) ; 
    sum := sum+(pre) ; 
    skip ; 
    skip ; 
 );
  static class SimpleScanner {
  static    attribute BUFFER_SIZE : int := 10240;
   attribute in : Readable;
   attribute buffer : Sequence(int);
   attribute eof : boolean;
   static operation newSimpleScanner( in : OclFile) : SimpleScanner
  pre: true
  post: true
  activity:
  ( var self : SimpleScanner ;
    self := createSimpleScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     self.in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     buffer := CharBuffer.allocate(BUFFER_SIZE) ; 
     buffer := buffer.limit(0) ; 
     eof := false );
   operation read() : String
  pre: true
  post: true
  activity: (     if (not(buffer.hasRemaining())) then (     buffer := buffer->intersection(Set{}) ; 
     var n : int ;
    try (     n := in.read(buffer) )   catch (e : IOException) do (     n := -1 )
    if (n <= 0) then (     eof := true ; 
     return '\0' ) else skip ; 
    buffer := buffer.flip() ; 
 ) else skip ; 
     return buffer.get() );
   operation checkEof() : void
  pre: true
  post: true
  activity: (     if (eof) then     error IncorrectElementException() ; else skip );
   operation nextChar() : String
  pre: true
  post: true
  activity: (     execute checkEof() ; 
     var b : String ; b := read() ;
     execute checkEof() ; 
     return b );
   operation next() : String
  pre: true
  post: true
  activity: (     var b : String ;
   while true do ((     b := read() ; 
     execute checkEof() ) ;
    if ((b->isMatch("[\\t\\n ]")) then skip else break) ; 
    var sb : String ; sb := StringLib.newString() ;
  while true do ((     sb := sb + StringLib.newString(b) ; 
     b := read() ) ;
    if (not(eof) & not((b->isMatch("[\\t\\n ]"))) then skip else break) ; 
    return sb+"" 
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader bf=null ;
    bf=new BufferedReader(new InputStreamReader(System.in));
    int ans=0,n ;
    int[] b ;
    String str ;
    String[] s ;
    str=bf.readLine();
    n=Integer.parseInt(str);
    b=new int[n-1];
    str=bf.readLine();
    s=str.split(" ");
    for(int i=0 ; i<n-1 ; ++i){
      b[i]=Integer.parseInt(s[i]);
    }
    ans=b[0];
    for(int i=1 ; i<n-1 ; ++i){
      ans+=Math.min(b[i],b[i-1]);
    }
    ans+=b[n-2];
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := null ;
     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
    var ans : int ; ans := 0 ;
    var n : int ;
    var b : Sequence(int) ;
    var str : String ;
    var s : Sequence(String) ;
    str := bf.readLine() ; 
    n := (str)->toInteger() ; 
    b := Integer.subrange(1,n - 1)->collect(0) ; 
    str := bf.readLine() ; 
    s := str->split(" ") ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     b[i+1] := (s[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    ans := b[0+1] ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     ans := ans+(Set{b[i+1], b[i - 1+1]}->min()) )  ;     i := i + 1 ) ; 
    ans := ans+(b[n - 2+1]) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Hackerrank {
  public static void main(String[] args){
    Scanner sc1=new Scanner(System.in);
    int n=sc1.nextInt();
    int arr[][]=new int[n][4];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<4 ; j++){
        arr[i][j]=sc1.nextInt();
      }
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(i!=j){
          if(arr[i][0]<arr[j][0] && arr[i][1]<arr[j][1] && arr[i][2]<arr[j][2]){
            arr[i][3]=Integer.MAX_VALUE ;
          }
        }
      }
    }
    int posL=-1 ;
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(arr[i][3]<min){
        min=arr[i][3];
        posL=i+1 ;
      }
    }
    System.out.println(posL);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hackerrank {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc1 : OclFile ; sc1 := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc1.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,4)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 4 do ( (     arr[i+1][j+1] := sc1.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (i /= j) then (     if (arr[i+1][0+1] < arr[j+1][0+1] & arr[i+1][1+1] < arr[j+1][1+1] & arr[i+1][2+1] < arr[j+1][2+1]) then (     arr[i+1][3+1] := 2147483647 ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var posL : int ; posL := -1 ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1][3+1] < min) then (     min := arr[i+1][3+1] ; 
     posL := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(posL) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] listB=new int[N-1];
    int[] listA=new int[N];
    for(int index=0 ; index<N-1 ; index++){
      listB[index]=sc.nextInt();
    }
    int lastNum=0 ;
    for(int index=0 ; index<N-1 ; index++){
      int num=listB[index];
      listA[index]=num ;
      if(index!=0){
        if(listA[index]>lastNum){
          listA[index]=lastNum ;
        }
      }
      lastNum=num ;
    }
    listA[N-1]=listB[N-2];
    int total=0 ;
    for(int index=0 ; index<N ; index++){
      total+=listA[index];
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var listB : Sequence(int) ; listB := Integer.subrange(1,N - 1)->collect(0) ;
    var listA : Sequence(int) ; listA := Integer.subrange(1,N)->collect(0) ;
        var index : int ; index := 0 ; while index < N - 1 do ( (     listB[index+1] := sc.getCurrent()->toInteger() )  ;     index := index + 1 ) ; 
    var lastNum : int ; lastNum := 0 ;
        var index : int ; index := 0 ; while index < N - 1 do ( (     var num : int ; num := listB[index+1] ;
     listA[index+1] := num ; 
     if (index /= 0) then (     if (listA[index+1] > lastNum) then (     listA[index+1] := lastNum ) else skip ) else skip ; 
     lastNum := num )  ;     index := index + 1 ) ; 
    listA[N - 1+1] := listB[N - 2+1] ; 
    var total : int ; total := 0 ;
        var index : int ; index := 0 ; while index < N do ( (     total := total+(listA[index+1]) )  ;     index := index + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class c {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    char p=in.next().charAt(0);
    HashSet<Character>ans=new HashSet<>();
    int[] di={
      0,0,1,-1 };
      int[] dj={
        1,-1,0,0 };
        char[][] map=new char[n][m];
        for(int i=0 ; i<n ; i++)map[i]=in.next().toCharArray();
        for(int i=0 ; i<n ; i++){
          for(int j=0 ; j<m ; j++){
            if(map[i][j]!=p)continue ;
            for(int k=0 ; k<4 ; k++){
              int ni=i+di[k];
              int nj=j+dj[k];
              if(ni>-1 && ni<n && nj>-1 && nj<m && map[ni][nj]!=p && map[ni][nj]!='.')ans.add(map[ni][nj]);
            }
          }
        }
        System.out.println(ans.size());
      }
    }

------------------------------------------------------------
OCL File:
---------
 class c {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var p : String ; p := in.getCurrent()->at(0+1) ;
    var ans : Set(String) ; ans := Set{} ;
    var di : Sequence(int) ; di := Sequence{0,0,1,-1} ;
    var dj : Sequence(int) ; dj := Sequence{1,-1,0,0} ;
    var map : Sequence(Sequence(String)) ; map := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do (     map[i+1] := in.getCurrent()->characters() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (map[i+1][j+1] /= p) then     continue else skip ; 
         var k : int ; k := 0 ; while k < 4 do ( (     var ni : int ; ni := i + di[k+1] ;
     var nj : int ; nj := j + dj[k+1] ;
     if (ni > -1 & ni < n & nj > -1 & nj < m & map[ni+1][nj+1] /= p & map[ni+1][nj+1] /= '.') then     ans := ans->including(map[ni+1][nj+1]) ; else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.function.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int N=s.nextInt();
    int[] A=new int[1000001];
    int[] nms=new int[N];
    boolean one=false ;
    for(int i=0 ; i<N ; i++){
      int now=s.nextInt();
      A[now]++;
      nms[i]=now ;
    }
    int ret=0 ;
    for(int i=0 ; i<N ; i++){
      if(! checkDivided(A,nms[i])){
        ret++;
      }
    }
    System.out.println(ret);
  }
  private static boolean checkDivided(int[] A,int n){
    int sqrt=(int)Math.sqrt(n);
    if(A[n]>1){
      return true ;
    }
    if(n==1){
      if(A[1]>1){
        return true ;
      }
      else {
        return false ;
      }
    }
    if(A[1]>0){
      return true ;
    }
    for(int i=2 ; i<=sqrt ; i++){
      int tmp=n ;
      if(A[i]>0 && n % i==0){
        return true ;
      }
      while(tmp % i==0){
        tmp/=i ;
        if(A[tmp]>0){
          if(n % tmp==0){
            return true ;
          }
        }
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := s.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,1000001)->collect(0) ;
    var nms : Sequence(int) ; nms := Integer.subrange(1,N)->collect(0) ;
    var one : boolean ; one := false ;
        var i : int ; i := 0 ; while i < N do ( (     var now : int ; now := s.getCurrent()->toInteger() ;
     A[now+1] := A[now+1] + 1 ; 
     nms[i+1] := now )  ;     i := i + 1 ) ; 
    var ret : int ; ret := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (not(checkDivided(A, nms[i+1]))) then (     ret := ret + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ret) ; 
 );
  static   operation checkDivided( A : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var sqrt : int ; sqrt := (n)->sqrt()->oclAsType(int) ;
     if (A[n+1] > 1) then (     return true ) else skip ; 
    if (n = 1) then (     if (A[1+1] > 1) then (     return true ) else (     return false ) ) else skip ; 
    if (A[1+1] > 0) then (     return true ) else skip ; 
        var i : int ; i := 2 ; while i <= sqrt do ( (     var tmp : int ; tmp := n ;
     if (A[i+1] > 0 & n mod i = 0) then (     return true ) else skip ; 
     while (tmp mod i = 0) do (     tmp := tmp/(i) ; 
     if (A[tmp+1] > 0) then (     if (n mod tmp = 0) then (     return true ) else skip ) else skip ) )  ;     i := i + 1 ) ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.Stream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      String data1=scanner.nextLine();
      String data2=scanner.nextLine();
      String[] data2Array=data2.split(" ");
      int[] a=Stream.of(data2Array).mapToInt(Integer :: parseInt).toArray();
      int[] array=new int[10000005];
      for(int x : a){
        if(array[x]!=0){
          array[x]=2 ;
          continue ;
        }
        for(int i=x ; i<10000005 ; i+=x){
          array[i]++;
        }
      }
      int ans=0 ;
      for(int x : a){
        if(array[x]==1){
          ans++;
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var data1 : String ; data1 := scanner.nextLine() ;
     var data2 : String ; data2 := scanner.nextLine() ;
    var data2Array : Sequence(String) ; data2Array := data2->split(" ") ;
    var a : Sequence(int) ; a := Sequence{data2Array}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var array : Sequence(int) ; array := Integer.subrange(1,10000005)->collect(0) ;
    for (x : a) do ( (     if (array[x+1] /= 0) then (     array[x+1] := 2 ; 
     continue ) else skip ; 
         var i : int ; i := x ; while i < 10000005 do ( (     array[i+1] := array[i+1] + 1 )  ;     i := i+(x) ) )  ) ; 
    var ans : int ; ans := 0 ;
    for (x : a) do ( (     if (array[x+1] = 1) then (     ans := ans + 1 ) else skip )  ) ; 
    OclFile["System.out"].println(ans) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    int num=998244353 ;
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    int n=Integer.parseInt(bf.readLine());
    Map<Integer,Integer>graph=new HashMap<Integer,Integer>();
    Set<Integer>no=new HashSet<Integer>();
    StringTokenizer st1=new StringTokenizer(bf.readLine());
    ArrayList<Integer>array=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      array.add(Integer.parseInt(st1.nextToken()));
      no.add(array.get(i));
      if(graph.containsKey(array.get(i))){
        graph.put(array.get(i),graph.get(array.get(i))+1);
      }
      else {
        graph.put(array.get(i),1);
      }
    }
    int removecount=0 ;
    for(int i : array){
      ArrayList<Integer>factors=new ArrayList<Integer>();
      for(int j=1 ; j*j<=i ; j++){
        if(i % j==0){
          factors.add(j);
          factors.add(i/j);
        }
      }
      for(int j : factors){
        if(j!=i && graph.containsKey(j)){
          removecount++;
          break ;
        }
        else if(j==i && graph.containsKey(j)&& graph.get(j)>1){
          removecount++;
          break ;
        }
      }
    }
    out.println(n-removecount);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 998244353 ;
     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (bf.readLine())->toInteger() ;
    var graph : Map(int,int) ; graph := Map{} ;
    var no : Set(int) ; no := Set{} ;
    var st1 : OclIterator ; st1 := OclIterator.newOclIterator_String(bf.readLine()) ;
    var array : Sequence(int) ; array := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     array := array->including((st1.next())->toInteger()) ; 
     no := no->including(array->at(i+1)) ; 
     if (graph->keys()->includes(array->at(i+1))) then (     graph := graph->union(Map{array->at(i+1) |-> graph->at(array->at(i+1)) + 1}) ) else (     graph := graph->union(Map{array->at(i+1) |-> 1}) ) )  ;     i := i + 1 ) ; 
    var removecount : int ; removecount := 0 ;
    for (i : array) do ( (     var factors : Sequence(int) ; factors := Sequence{} ;
         var j : int ; j := 1 ; while j * j <= i do ( (     if (i mod j = 0) then (     factors := factors->including(j) ; 
     factors := factors->including(i / j) ) else skip )  ;     j := j + 1 ) ; 
     for (j : factors) do ( (     if (j /= i & graph->keys()->includes(j)) then (     removecount := removecount + 1 ; 
     break ) else     if (j = i & graph->keys()->includes(j) & graph->at(j) > 1) then (     removecount := removecount + 1 ; 
     break ) else skip ; )  ) )  ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  final int MOD=998244353 ;
  final int MAX=Integer.MAX_VALUE ;
  final long LMAX=Long.MAX_VALUE ;
  int len=(int)1e6+1 ;
  void doIt(){
    int N=sc.nextInt();
    int A[]=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
    }
    Arrays.sort(A);
    Set<Integer>set=new HashSet<>();
    int sum=0 ;
    for(int i=0 ; i<N ; i++){
      int count=1 ;
      for(int j : fac(A[i])){
        if(set.contains(j)){
          count=0 ;
          break ;
        }
      }
      if(A[i]==A[(i+1)% N])count=0 ;
      sum+=count ;
      set.add(A[i]);
    }
    if(A.length==1)sum=1 ;
    System.out.println(sum);
  }
  List<Integer>fac(int n){
    List<Integer>li=new ArrayList<>();
    for(int i=1 ; i*i<=n ; i++){
      if(n % i==0){
        li.add(i);
        li.add(n/i);
      }
    }
    return li ;
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute MOD : int := 998244353;
   attribute MAX : int := 2147483647;
   attribute LMAX : long := "9223372036854775807"->toLong();
   attribute len : int := 1e6->oclAsType(int) + 1;
   operation doIt() : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    var set : Set(int) ; set := Set{} ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var count : int ; count := 1 ;
     for (j : fac(A[i+1])) do ( (     if (set->includes(j)) then (     count := 0 ; 
     break ) else skip )  ) ; 
    if (A[i+1] = A[(i + 1) mod N+1]) then     count := 0 ; else skip ; 
    sum := sum+(count) ; 
    set := set->including(A[i+1]) ; 
 )  ;     i := i + 1 ) ; 
    if (A->size() = 1) then     sum := 1 ; else skip ; 
    OclFile["System.out"].println(sum) ; 
 );
   operation fac( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var li : Sequence(int) ; li := Sequence{} ;
         var i : int ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     li := li->including(i) ; 
     li := li->including(n / i) ) else skip )  ;     i := i + 1 ) ; 
     return li );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
public class GFG {
  private static void sort(String[] strArr,String str){
    Comparator<String>myComp=new Comparator<String>(){
      @ Override public int compare(String a,String b){
        for(int i=0 ; i<Math.min(a.length(),b.length()); i++){
          if(str.indexOf(a.charAt(i))==str.indexOf(b.charAt(i))){
            continue ;
          }
          else if(str.indexOf(a.charAt(i))>str.indexOf(b.charAt(i))){
            return 1 ;
          }
          else {
            return-1 ;
          }
        }
        return 0 ;
      }
    };
    Arrays.sort(strArr,myComp);
  }
  public static void main(String[] args){
    String str="fguecbdavwyxzhijklmnopqrst" ;
    String[] strArr={
      "geeksforgeeks","is","the","best","place","for","learning" };
      sort(strArr,str);
      for(int i=0 ; i<strArr.length ; i++){
        System.out.print(strArr[i]+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sort( strArr : Sequence(String), str : String) : void
  pre: true
  post: true
  activity: (     var myComp : Function(<String>,(<String>,boolean)) ; myComp := OclComparator<String>.newOclComparator() ;
     strArr := OclComparator.sortWith(strArr, myComp) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "fguecbdavwyxzhijklmnopqrst" ;
     var strArr : Sequence(String) ; strArr := Sequence{"geeksforgeeks","is","the","best","place","for","learning"} ;
     execute sort(strArr, str) ; 
         var i : int ; i := 0 ; while i < strArr->size() do ( (     OclFile["System.out"].print(strArr[i+1] + " ") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeSet ;
public class Main {
  static Main instance=new Main();
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    Set<Integer>set=new HashSet<>();
    int N=scan.nextInt();
    Set<Integer>AList=new TreeSet<>();
    Set<Integer>dpl=new HashSet<>();
    for(int i=0 ; i<N ; i++){
      int A=scan.nextInt();
      if(dpl.contains(A)){
        set.add(A);
      }
      else {
        dpl.add(A);
        AList.add(A);
      }
    }
    Set<Integer>ald=new HashSet<>();
    for(int A : AList){
      if(! ald.contains(A)){
        for(int j=2 ; j*A<=1000000 ; j++){
          set.add(j*A);
          ald.add(j*A);
        }
      }
    }
    int result=0 ;
    for(int A : AList){
      if(! set.contains(A)){
        result++;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute instance : Main := Main.newMain();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var set : Set(int) ; set := Set{} ;
    var N : int ; N := scan.getCurrent()->toInteger() ;
    var AList : Set(int) ; AList := Set{} ;
    var dpl : Set(int) ; dpl := Set{} ;
        var i : int ; i := 0 ; while i < N do ( (     var A : int ; A := scan.getCurrent()->toInteger() ;
     if (dpl->includes(A)) then (     set := set->including(A) ) else (     dpl := dpl->including(A) ; 
     AList := AList->including(A) ) )  ;     i := i + 1 ) ; 
    var ald : Set(int) ; ald := Set{} ;
    for (A : AList) do ( (     if (not(ald->includes(A))) then (         var j : int ; j := 2 ; while j * A <= 1000000 do ( (     set := set->including(j * A) ; 
     ald := ald->including(j * A) )  ;     j := j + 1 ) ) else skip )  ) ; 
    var result : int ; result := 0 ;
    for (A : AList) do ( (     if (not(set->includes(A))) then (     result := result + 1 ) else skip )  ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void last_digit(int X,int Y){
    System.out.print(X % Y);
  }
  public static void main(String[] args){
    int X=55,Y=3 ;
    last_digit(X,Y);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation last_digit( X : int, Y : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(X mod Y) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 55 ;
    var Y : int ; Y := 3 ;
     execute last_digit(X, Y) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Laptop106B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] speed=new int[n];
    int[] ram=new int[n];
    int[] hdd=new int[n];
    int[] cost=new int[n];
    for(int i=0 ; i<n ; i++){
      speed[i]=in.nextInt();
      ram[i]=in.nextInt();
      hdd[i]=in.nextInt();
      cost[i]=in.nextInt();
    }
    int index=-1 ;
    int min=1001 ;
    for(int i=0 ; i<n ; i++){
      boolean outdated=false ;
      for(int j=0 ; j<n ; j++){
        if(speed[i]<speed[j] && ram[i]<ram[j] && hdd[i]<hdd[j]){
          outdated=true ;
          break ;
        }
      }
      if(! outdated && cost[i]<min){
        min=cost[i];
        index=i+1 ;
      }
    }
    System.out.println(index);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Laptop106B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var speed : Sequence(int) ; speed := Integer.subrange(1,n)->collect(0) ;
    var ram : Sequence(int) ; ram := Integer.subrange(1,n)->collect(0) ;
    var hdd : Sequence(int) ; hdd := Integer.subrange(1,n)->collect(0) ;
    var cost : Sequence(int) ; cost := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     speed[i+1] := in.getCurrent()->toInteger() ; 
     ram[i+1] := in.getCurrent()->toInteger() ; 
     hdd[i+1] := in.getCurrent()->toInteger() ; 
     cost[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var index : int ; index := -1 ;
    var min : int ; min := 1001 ;
        var i : int ; i := 0 ; while i < n do ( (     var outdated : boolean ; outdated := false ;
         var j : int ; j := 0 ; while j < n do ( (     if (speed[i+1] < speed[j+1] & ram[i+1] < ram[j+1] & hdd[i+1] < hdd[j+1]) then (     outdated := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (not(outdated) & cost[i+1] < min) then (     min := cost[i+1] ; 
     index := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(index) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemB {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=scn.nextInt();
    }
    int idx=-1 ;
    int min=arr[0];
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i % n]>arr[(i+1)% n]){
        count++;
        idx=i ;
      }
    }
    if(count>1){
      System.out.println("-1");
    }
    else if(idx==-1){
      System.out.println(0);
    }
    else {
      System.out.println(n-idx-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := scn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var idx : int ; idx := -1 ;
    var min : int ; min := arr[0+1] ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i mod n+1] > arr[(i + 1) mod n+1]) then (     count := count + 1 ; 
     idx := i ) else skip )  ;     i := i + 1 ) ; 
    if (count > 1) then (     OclFile["System.out"].println("-1") ) else     if (idx = -1) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(n - idx - 1) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=1 ;
    while(t-->0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      int count=0,in=0 ;
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
        if(i>0 && arr[i-1]>arr[i]){
          count++;
          in=i ;
        }
      }
      if(count==0)System.out.println(0);
      else if(count==1 && arr[n-1]<=arr[0])System.out.println(n-in);
      else System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var count : int ; count := 0 ;
    var in : int ; in := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (i > 0 & arr[i - 1+1] > arr[i+1]) then (     count := count + 1 ; 
     in := i ) else skip )  ;     i := i + 1 ) ; 
    if (count = 0) then     OclFile["System.out"].println(0) else     if (count = 1 & arr[n - 1+1] <= arr[0+1]) then     OclFile["System.out"].println(n - in) else     OclFile["System.out"].println(-1) ; ;  ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String args[]){
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    int a[]=new int[n+1];
    int i,p=0,pin=-1 ;
    for(i=0 ; i<n ; i++)a[i]=sc.nextInt();
    a[n]=a[0];
    for(i=n-1 ; i>=0 ; i--){
      if(a[i+1]<a[i]){
        p++;
        if(p==2){
          System.out.println(-1);
          return ;
        }
        else pin=i ;
      }
    }
    if(p==0){
      System.out.println(0);
    }
    else {
      if(pin==n-1)System.out.println(0);
      else System.out.println(n-pin-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : int ; n := sc.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var i : int ;
    var p : int ; p := 0 ;
    var pin : int ; pin := -1 ;
        i := 0 ; while i < n do (     a[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
    a[n+1] := a[0+1] ; 
        i := n - 1 ; while i >= 0 do ( (     if (a[i + 1+1] < a[i+1]) then (     p := p + 1 ; 
     if (p = 2) then (     OclFile["System.out"].println(-1) ; 
     return ) else     pin := i ; ) else skip )  ;     i := i - 1 ) ; 
    if (p = 0) then (     OclFile["System.out"].println(0) ) else (     if (pin = n - 1) then     OclFile["System.out"].println(0) ; else     OclFile["System.out"].println(n - pin - 1) ; ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int a[]=new int[n];
    int i ;
    String str[]=br.readLine().split(" ");
    for(i=0 ; i<n ; i++)a[i]=Integer.parseInt(str[i]);
    int inc=0,dec=0 ;
    for(i=0 ; i<(n-1); i++){
      if(a[i]<=a[i+1]){
        continue ;
      }
      break ;
    }
    boolean ans=true ;
    int j=-1 ;
    for(j=(i+1); j<(n-1); j++){
      if(a[j]>a[j+1]){
        ans=false ;
        break ;
      }
    }
    if(ans==false){
      System.out.println("-1");
    }
    else {
      if(i==(n-1)){
        System.out.println("0");
      }
      else if(a[0]>=a[n-1]){
        System.out.println(n-i-1);
      }
      else System.out.println("-1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var i : int ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
        i := 0 ; while i < n do (     a[i+1] := (str[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var inc : int ; inc := 0 ;
    var dec : int ; dec := 0 ;
        i := 0 ; while i < (n - 1) do ( (     if (a[i+1] <= a[i + 1+1]) then (     continue ) else skip ; 
     break )  ;     i := i + 1 ) ; 
    var ans : boolean ; ans := true ;
    var j : int ; j := -1 ;
        j := (i + 1) ; while j < (n - 1) do ( (     if (a[j+1] > a[j + 1+1]) then (     ans := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (ans = false) then (     OclFile["System.out"].println("-1") ) else (     if (i = (n - 1)) then (     OclFile["System.out"].println("0") ) else     if (a[0+1] >= a[n - 1+1]) then (     OclFile["System.out"].println(n - i - 1) ) else     OclFile["System.out"].println("-1") ; ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    int[] b=new int[n];
    for(int i=0 ; i<a.length ; i++){
      a[i]=sc.nextInt();
    }
    for(int i=0 ; i<a.length ; i++){
      b[i]=a[n-i-1];
      System.out.print(b[i]);
      if(i==a.length-1)break ;
      System.out.print(" ");
    }
    System.out.println();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     b[i+1] := a[n - i - 1+1] ; 
     OclFile["System.out"].print(b[i+1]) ; 
     if (i = a->size() - 1) then     break else skip ; 
     OclFile["System.out"].print(" ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    String[] str=br.readLine().split(" ");
    for(int i=n-1 ; i>=0 ; i--){
      sb.append(str[i]+" ");
    }
    int a=sb.length();
    sb.deleteCharAt(a-1);
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
        var i : int ; i := (n)->char2byte() - 1 ; while i >= 0 do ( (     sb := sb + StringLib.newString(str[i+1] + " ") )  ;     i := i - 1 ) ; 
    var a : int ; a := sb->size() ;
    sb := sb->excludingAt(a - 1+1) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int len=Integer.parseInt(sc.nextLine());
    String[] nums=sc.nextLine().split(" ");
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<len ; i++){
      sb.append(nums[len-(i+1)]).append((i+1)<len ? " " : "");
    }
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := (sc.nextLine())->toInteger() ;
    var nums : Sequence(String) ; nums := sc.nextLine()->split(" ") ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < len do ( (     sb := sb + StringLib.newString(nums[len - (i + 1)+1]) + StringLib.newString(if (i + 1) < len then " " else "" endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdin=new Scanner(System.in);
    int num=Integer.parseInt(stdin.nextLine());
    boolean boo=true ;
    int[] seq=new int[num];
    if(num<=100){
      for(int i=0 ; i<num ; i++){
        seq[i]=stdin.nextInt();
        if(seq[i]>=0 && seq[i]<=1000){
          continue ;
        }
        else {
          boo=false ;
          break ;
        }
      }
    }
    if(boo==true){
      for(int j=num ; j>0 ; j--){
        if(j!=1){
          System.out.print(seq[j-1]+" ");
        }
        else {
          System.out.println(seq[j-1]);
        }
      }
    }
    stdin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := (stdin.nextLine())->toInteger() ;
    var boo : boolean ; boo := true ;
    var seq : Sequence(int) ; seq := Integer.subrange(1,num)->collect(0) ;
    if (num <= 100) then (         var i : int ; i := 0 ; while i < num do ( (     seq[i+1] := stdin.getCurrent()->toInteger() ; 
     if (seq[i+1] >= 0 & seq[i+1] <= 1000) then (     continue ) else (     boo := false ; 
     break ) )  ;     i := i + 1 ) ) else skip ; 
    if (boo = true) then (         var j : int ; j := num ; while j > 0 do ( (     if (j /= 1) then (     OclFile["System.out"].print(seq[j - 1+1] + " ") ) else (     OclFile["System.out"].println(seq[j - 1+1]) ) )  ;     j := j - 1 ) ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int P=A*B ;
    System.out.println(P);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var P : int ; P := A * B ;
    OclFile["System.out"].println(P) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] su=br.readLine().split(" ");
    StringBuilder outArray=new StringBuilder();
    for(int i=n-1 ; i>=0 ; i--){
      outArray.append(su[i]+" ");
    }
    int p=outArray.length();
    outArray.deleteCharAt(p-1);
    System.out.println(outArray);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var su : Sequence(String) ; su := br.readLine()->split(" ") ;
    var outArray : String ; outArray := StringLib.newString() ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     outArray := outArray + StringLib.newString(su[i+1] + " ") )  ;     i := i - 1 ) ; 
    var p : int ; p := outArray->size() ;
    outArray := outArray->excludingAt(p - 1+1) ; 
    OclFile["System.out"].println(outArray) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p013 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p013().run());
  }
  public String run(){
    BigInteger sum=BigInteger.ZERO ;
    for(String num : NUMBERS)sum=sum.add(new BigInteger(num));
    return sum.toString().substring(0,10);
  }
  private static String[] NUMBERS={
    "37107287533902102798797998220837590246510135740250","46376937677490009712648124896970078050417018260538","74324986199524741059474233309513058123726617309629","91942213363574161572522430563301811072406154908250","23067588207539346171171980310421047513778063246676","89261670696623633820136378418383684178734361726757","28112879812849979408065481931592621691275889832738","44274228917432520321923589422876796487670272189318","47451445736001306439091167216856844588711603153276","70386486105843025439939619828917593665686757934951","62176457141856560629502157223196586755079324193331","64906352462741904929101432445813822663347944758178","92575867718337217661963751590579239728245598838407","58203565325359399008402633568948830189458628227828","80181199384826282014278194139940567587151170094390","35398664372827112653829987240784473053190104293586","86515506006295864861532075273371959191420517255829","71693888707715466499115593487603532921714970056938","54370070576826684624621495650076471787294438377604","53282654108756828443191190634694037855217779295145","36123272525000296071075082563815656710885258350721","45876576172410976447339110607218265236877223636045","17423706905851860660448207621209813287860733969412","81142660418086830619328460811191061556940512689692","51934325451728388641918047049293215058642563049483","62467221648435076201727918039944693004732956340691","15732444386908125794514089057706229429197107928209","55037687525678773091862540744969844508330393682126","18336384825330154686196124348767681297534375946515","80386287592878490201521685554828717201219257766954","78182833757993103614740356856449095527097864797581","16726320100436897842553539920931837441497806860984","48403098129077791799088218795327364475675590848030","87086987551392711854517078544161852424320693150332","59959406895756536782107074926966537676326235447210","69793950679652694742597709739166693763042633987085","41052684708299085211399427365734116182760315001271","65378607361501080857009149939512557028198746004375","35829035317434717326932123578154982629742552737307","94953759765105305946966067683156574377167401875275","88902802571733229619176668713819931811048770190271","25267680276078003013678680992525463401061632866526","36270218540497705585629946580636237993140746255962","24074486908231174977792365466257246923322810917141","91430288197103288597806669760892938638285025333403","34413065578016127815921815005561868836468420090470","23053081172816430487623791969842487255036638784583","11487696932154902810424020138335124462181441773470","63783299490636259666498587618221225225512486764533","67720186971698544312419572409913959008952310058822","95548255300263520781532296796249481641953868218774","76085327132285723110424803456124867697064507995236","37774242535411291684276865538926205024910326572967","23701913275725675285653248258265463092207058596522","29798860272258331913126375147341994889534765745501","18495701454879288984856827726077713721403798879715","38298203783031473527721580348144513491373226651381","34829543829199918180278916522431027392251122869539","40957953066405232632538044100059654939159879593635","29746152185502371307642255121183693803580388584903","41698116222072977186158236678424689157993532961922","62467957194401269043877107275048102390895523597457","23189706772547915061505504953922979530901129967519","86188088225875314529584099251203829009407770775672","11306739708304724483816533873502340845647058077308","82959174767140363198008187129011875491310547126581","97623331044818386269515456334926366572897563400500","42846280183517070527831839425882145521227251250327","55121603546981200581762165212827652751691296897789","32238195734329339946437501907836945765883352399886","75506164965184775180738168837861091527357929701337","62177842752192623401942399639168044983993173312731","32924185707147349566916674687634660915035914677504","99518671430235219628894890102423325116913619626622","73267460800591547471830798392868535206946944540724","76841822524674417161514036427982273348055556214818","97142617910342598647204516893989422179826088076852","87783646182799346313767754307809363333018982642090","10848802521674670883215120185883543223812876952786","71329612474782464538636993009049310363619763878039","62184073572399794223406235393808339651327408011116","66627891981488087797941876876144230030984490851411","60661826293682836764744779239180335110989069790714","85786944089552990653640447425576083659976645795096","66024396409905389607120198219976047599490197230297","64913982680032973156037120041377903785566085089252","16730939319872750275468906903707539413042652315011","94809377245048795150954100921645863754710598436791","78639167021187492431995700641917969777599028300699","15368713711936614952811305876380278410754449733078","40789923115535562561142322423255033685442488917353","44889911501440648020369068063960672322193204149535","41503128880339536053299340368006977710650566631954","81234880673210146739058568557934581403627822703280","82616570773948327592232845941706525094512325230608","22918802058777319719839450180888072429661980811197","77158542502016545090413245809786882778948721859617","72107838435069186155435662884062257473692284509516","20849603980134001723930671666823555245252804609722","53503534226472524250874054075591789781264330331690",};
  }

------------------------------------------------------------
OCL File:
---------
 class p013 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p013.newp013().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     for (num : NUMBERS) do (     sum := sum->excludes(long(num)) ;  ) ; 
     return sum+"".subrange(0+1,10) );
  static   attribute NUMBERS : Sequence(String) := Sequence{"37107287533902102798797998220837590246510135740250","46376937677490009712648124896970078050417018260538","74324986199524741059474233309513058123726617309629","91942213363574161572522430563301811072406154908250","23067588207539346171171980310421047513778063246676","89261670696623633820136378418383684178734361726757","28112879812849979408065481931592621691275889832738","44274228917432520321923589422876796487670272189318","47451445736001306439091167216856844588711603153276","70386486105843025439939619828917593665686757934951","62176457141856560629502157223196586755079324193331","64906352462741904929101432445813822663347944758178","92575867718337217661963751590579239728245598838407","58203565325359399008402633568948830189458628227828","80181199384826282014278194139940567587151170094390","35398664372827112653829987240784473053190104293586","86515506006295864861532075273371959191420517255829","71693888707715466499115593487603532921714970056938","54370070576826684624621495650076471787294438377604","53282654108756828443191190634694037855217779295145","36123272525000296071075082563815656710885258350721","45876576172410976447339110607218265236877223636045","17423706905851860660448207621209813287860733969412","81142660418086830619328460811191061556940512689692","51934325451728388641918047049293215058642563049483","62467221648435076201727918039944693004732956340691","15732444386908125794514089057706229429197107928209","55037687525678773091862540744969844508330393682126","18336384825330154686196124348767681297534375946515","80386287592878490201521685554828717201219257766954","78182833757993103614740356856449095527097864797581","16726320100436897842553539920931837441497806860984","48403098129077791799088218795327364475675590848030","87086987551392711854517078544161852424320693150332","59959406895756536782107074926966537676326235447210","69793950679652694742597709739166693763042633987085","41052684708299085211399427365734116182760315001271","65378607361501080857009149939512557028198746004375","35829035317434717326932123578154982629742552737307","94953759765105305946966067683156574377167401875275","88902802571733229619176668713819931811048770190271","25267680276078003013678680992525463401061632866526","36270218540497705585629946580636237993140746255962","24074486908231174977792365466257246923322810917141","91430288197103288597806669760892938638285025333403","34413065578016127815921815005561868836468420090470","23053081172816430487623791969842487255036638784583","11487696932154902810424020138335124462181441773470","63783299490636259666498587618221225225512486764533","67720186971698544312419572409913959008952310058822","95548255300263520781532296796249481641953868218774","76085327132285723110424803456124867697064507995236","37774242535411291684276865538926205024910326572967","23701913275725675285653248258265463092207058596522","29798860272258331913126375147341994889534765745501","18495701454879288984856827726077713721403798879715","38298203783031473527721580348144513491373226651381","34829543829199918180278916522431027392251122869539","40957953066405232632538044100059654939159879593635","29746152185502371307642255121183693803580388584903","41698116222072977186158236678424689157993532961922","62467957194401269043877107275048102390895523597457","23189706772547915061505504953922979530901129967519","86188088225875314529584099251203829009407770775672","11306739708304724483816533873502340845647058077308","82959174767140363198008187129011875491310547126581","97623331044818386269515456334926366572897563400500","42846280183517070527831839425882145521227251250327","55121603546981200581762165212827652751691296897789","32238195734329339946437501907836945765883352399886","75506164965184775180738168837861091527357929701337","62177842752192623401942399639168044983993173312731","32924185707147349566916674687634660915035914677504","99518671430235219628894890102423325116913619626622","73267460800591547471830798392868535206946944540724","76841822524674417161514036427982273348055556214818","97142617910342598647204516893989422179826088076852","87783646182799346313767754307809363333018982642090","10848802521674670883215120185883543223812876952786","71329612474782464538636993009049310363619763878039","62184073572399794223406235393808339651327408011116","66627891981488087797941876876144230030984490851411","60661826293682836764744779239180335110989069790714","85786944089552990653640447425576083659976645795096","66024396409905389607120198219976047599490197230297","64913982680032973156037120041377903785566085089252","16730939319872750275468906903707539413042652315011","94809377245048795150954100921645863754710598436791","78639167021187492431995700641917969777599028300699","15368713711936614952811305876380278410754449733078","40789923115535562561142322423255033685442488917353","44889911501440648020369068063960672322193204149535","41503128880339536053299340368006977710650566631954","81234880673210146739058568557934581403627822703280","82616570773948327592232845941706525094512325230608","22918802058777319719839450180888072429661980811197","77158542502016545090413245809786882778948721859617","72107838435069186155435662884062257473692284509516","20849603980134001723930671666823555245252804609722","53503534226472524250874054075591789781264330331690",};
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countPoints(int n,int m,int a[],int[] b,int x,int y){
    Arrays.sort(a);
    Arrays.sort(b);
    int j=0 ;
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      while(j<m){
        if(a[i]+y<b[j])break ;
        if(b[j]>=a[i]-x && b[j]<=a[i]+y){
          count++;
          j++;
          break ;
        }
        else j++;
      }
    }
    return count ;
  }
  public static void main(String args[]){
    int x=1,y=4 ;
    int[] a={
      1,5 };
      int n=a.length ;
      int[] b={
        1,1,2 };
        int m=a.length ;
        System.out.println(countPoints(n,m,a,b,x,y));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPoints( n : int, m : int, a : Sequence(int), b : Sequence(int), x : int, y : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     b := b->sort() ; 
    var j : int ; j := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     while (j < m) do (     if (a[i+1] + y < b[j+1]) then     break else skip ; 
     if (b[j+1] >= a[i+1] - x & b[j+1] <= a[i+1] + y) then (     count := count + 1 ; 
     j := j + 1 ; 
     break ) else     j := j + 1 ; ) )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 1 ;
    var y : int ; y := 4 ;
     var a : Sequence(int) ; a := Sequence{1,5} ;
    var n : int ; n := a->size() ;
    var b : Sequence(int) ; b := Sequence{1,1,2} ;
    var m : int ; m := a->size() ;
    OclFile["System.out"].println(countPoints(n, m, a, b, x, y)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
class GFG {
  static int findPermutation(int n){
    int len=(int)Math.ceil(Math.log10(n));
    for(int i=0 ; i<len ; i++){
      if(n % 2!=0){
        return n ;
      }
      else {
        n=(n/10)+(n % 10)*(int)Math.pow(10,len-i-1);
        continue ;
      }
    }
    return-1 ;
  }
  public static void main(String args[]){
    int n=132 ;
    System.out.println(findPermutation(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findPermutation( n : int) : int
  pre: true
  post: true
  activity: (     var len : int ; len := ((n)->log10())->ceil()->oclAsType(int) ;
         var i : int ; i := 0 ; while i < len do ( (     if (n mod 2 /= 0) then (     return n ) else (     n := (n / 10) + (n mod 10) * 10->pow(len - i - 1)->oclAsType(int) ; 
     continue ) )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 132 ;
     OclFile["System.out"].println(findPermutation(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    StringTokenizer st ;
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    st=new StringTokenizer(br.readLine()," ");
    int n=Integer.parseInt(st.nextToken());
    int k=Integer.parseInt(st.nextToken());
    ArrayList<String>arr=new ArrayList<>();
    for(int i=1 ; i<=n ; i++){
      arr.add(String.valueOf(i));
    }
    String a ;
    for(int j=0 ; j<k ; j++){
      int d=Integer.parseInt(br.readLine());
      st=new StringTokenizer(br.readLine());
      while(st.hasMoreTokens()){
        a=st.nextToken();
        arr.remove(a);
      }
    }
    br.close();
    System.out.println(arr.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var st : OclIterator ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    st := OclIterator.newOclIterator_String_String(br.readLine(), " ") ; 
    var n : int ; n := (st.next())->toInteger() ;
    var k : int ; k := (st.next())->toInteger() ;
    var arr : Sequence(String) ; arr := Sequence{} ;
        var i : int ; i := 1 ; while i <= n do ( (     arr := arr->including(((i) + "")) )  ;     i := i + 1 ) ; 
    var a : String ;
        var j : int ; j := 0 ; while j < k do ( (     var d : int ; d := (br.readLine())->toInteger() ;
     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     while (st.hasNext()) do (     a := st.next() ; 
     arr := arr->excludingFirst(a) ) )  ;     j := j + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(arr->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Set ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt(),k=scanner.nextInt();
      Set<Integer>set=IntStream.rangeClosed(1,n).boxed().collect(Collectors.toSet());
      IntStream.range(0,k).forEach(i->{
        int d=scanner.nextInt();
        IntStream.range(0,d).forEach(j->set.remove(scanner.nextInt()));
      }
);
      System.out.println(set.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
     var set : Set(int) ; set := Integer.subrange(1, n).collect(Collectors.toSet()) ;
     for i : Integer.subrange(0, k-1) do
    (    skip) ; 
     OclFile["System.out"].println(set->size()) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  final Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] count=new int[n+1];
    for(int i=0 ; i<k ; i++){
      int d=sc.nextInt();
      for(int j=0 ; j<d ; j++){
        count[sc.nextInt()]++;
      }
    }
    int ans=0 ;
    for(int i=1 ; i<=n ; i++){
      if(count[i]==0)ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var count : Sequence(int) ; count := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     var d : int ; d := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < d do ( (     count[sc.getCurrent()->toInteger()+1] := count[sc.getCurrent()->toInteger()+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (count[i+1] = 0) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String[] str=in.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int k=Integer.parseInt(str[1]);
    int[] d=new int[k];
    int[] count=new int[n];
    for(int i=0 ; i<k ; i++){
      d[i]=Integer.parseInt(in.readLine());
      int[][] a=new int[k][d[i] ];
      str=in.readLine().split(" ");
      for(int j=0 ; j<d[i]; j++){
        a[i][j]=Integer.parseInt(str[j]);
        count[a[i][j]-1]++;
      }
    }
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(count[i]==0)ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := in.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var k : int ; k := (str[1+1])->toInteger() ;
    var d : Sequence(int) ; d := Integer.subrange(1,k)->collect(0) ;
    var count : Sequence(int) ; count := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     d[i+1] := (in.readLine())->toInteger() ; 
     var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,k)->collect(Integer.subrange(1,d[i+1])->collect(0)) ;
     str := in.readLine()->split(" ") ; 
         var j : int ; j := 0 ; while j < d[i+1] do ( (     a[i+1][j+1] := (str[j+1])->toInteger() ; 
     count[a[i+1][j+1] - 1+1] := count[a[i+1][j+1] - 1+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (count[i+1] = 0) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] treat=new int[n];
    for(int i=0 ; i<k ; i++){
      int n2=sc.nextInt();
      for(int j=0 ; j<n2 ; j++){
        treat[sc.nextInt()-1]++;
      }
    }
    int ans=0 ;
    for(int t : treat){
      if(t==0)ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var treat : Sequence(int) ; treat := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     var n2 : int ; n2 := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < n2 do ( (     treat[sc.getCurrent()->toInteger() - 1+1] := treat[sc.getCurrent()->toInteger() - 1+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (t : treat) do ( (     if (t = 0) then     ans := ans + 1 ; else skip )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Throwable {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    double n=sc.nextInt();
    double m=sc.nextInt();
    double k=sc.nextInt();
    double lane=Math.ceil(Math.ceil(k/2)/m);
    double other=Math.ceil(k/2)% m ;
    if(other==0)other=m ;
    char res=k % 2==0 ? 'R' : 'L' ;
    out.println((int)lane+" "+(int)other+" "+res);
    out.flush();
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : double ; n := sc.getCurrent()->toInteger() ;
    var m : double ; m := sc.getCurrent()->toInteger() ;
    var k : double ; k := sc.getCurrent()->toInteger() ;
    var lane : double ; lane := ((k / 2)->ceil() / m)->ceil() ;
    var other : double ; other := (k / 2)->ceil() mod m ;
    if (other = 0) then     other := m ; else skip ; 
    var res : String ; res := if k mod 2 = 0 then 'R' else 'L' endif ;
    skip ; 
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.*;
public class App {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  static int[] f=new int[100001];
  static {
    f[1]=1 ;
    for(int i=2 ; i<f.length ; ++i){
      f[i]=(int)(((i<<1)-1L)*f[i-1] % 1000000007*(i<<1)% 1000000007);
    }
  }
  public static void main(String[] args)throws Exception {
    if(System.getProperty("ONLINE_JUDGE")==null){
      File inputFile=new File("/Users/vipinjain/self/cp/input.txt");
      File outputFile=new File("/Users/vipinjain/self/cp/output.txt");
      br=new BufferedReader(new FileReader(inputFile));
      bw=new BufferedWriter(new FileWriter(outputFile));
    }
    int tests ;
    tests=1 ;
    while(tests-->0){
      solve();
    }
    bw.flush();
    bw.close();
    br.close();
  }
  static boolean isVowel(char c){
    c=Character.toLowerCase(c);
    return c=='a' || c=='e' || c=='i' || c=='o' || c=='u' || c=='y' ;
  }
  static void solve()throws Exception {
    String[] tmp=br.readLine().split(" ");
    int n=Integer.parseInt(tmp[0]);
    int m=Integer.parseInt(tmp[1]);
    int k=Integer.parseInt(tmp[2]);
    int p=(k-1)/2 ;
    bw.write((p/m+1)+" "+(p % m+1)+" "+((k & 1)==0 ? "R" : "L"));
    bw.write("\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute f : Sequence(int) := Integer.subrange(1,100001)->collect(0);
  static operation initialiseClass()
  pre: true post: true
  activity:     f[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < f->size() do ( (     f[i+1] := ((((i*(2->pow(1)))->oclAsType(long)) - 1L) * f[i - 1+1] mod 1000000007 * ((i*(2->pow(1)))->oclAsType(long)) mod 1000000007)->oclAsType(int) )  ;     i := i + 1 ) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null) then (     var inputFile : OclFile ; inputFile := OclFile("/Users/vipinjain/self/cp/input.txt") ;
     var outputFile : OclFile ; outputFile := OclFile("/Users/vipinjain/self/cp/output.txt") ;
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputFile)) ; 
     bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputFile)) ) else skip ; 
     var tests : int ;
    tests := 1 ; 
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation isVowel( c : String) : boolean
  pre: true
  post: true
  activity: (     c := (c + "")->toLowerCase() ; 
     return c = 'a' or c = 'e' or c = 'i' or c = 'o' or c = 'u' or c = 'y' );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var tmp : Sequence(String) ; tmp := br.readLine()->split(" ") ;
     var n : int ; n := (tmp[0+1])->toInteger() ;
    var m : int ; m := (tmp[1+1])->toInteger() ;
    var k : int ; k := (tmp[2+1])->toInteger() ;
    var p : int ; p := (k - 1) / 2 ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Santa_Clas_Place_in_Class {
  public static void main(String args[])throws Exception {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(f.readLine());
    int one=Integer.parseInt(st.nextToken());
    int two=Integer.parseInt(st.nextToken());
    int pos=Integer.parseInt(st.nextToken())-1 ;
    int lane=pos/(two*2)+1 ;
    int desk_row=pos %(two*2)/2+1 ;
    System.out.println(lane+" "+desk_row+" "+(pos % 2==0 ? "L" : "R"));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Santa_Clas_Place_in_Class {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
    var one : int ; one := (st.next())->toInteger() ;
    var two : int ; two := (st.next())->toInteger() ;
    var pos : int ; pos := (st.next())->toInteger() - 1 ;
    var lane : int ; lane := pos / (two * 2) + 1 ;
    var desk_row : int ; desk_row := pos mod (two * 2) / 2 + 1 ;
    OclFile["System.out"].println(lane + " " + desk_row + " " + (if pos mod 2 = 0 then "L" else "R" endif)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    Main mainObj=new Main();
    mainObj.solve();
  }
  public void solve()throws IOException {
    FastScanner fs=new FastScanner();
    int a=fs.nextInt();
    int b=fs.nextInt();
    System.out.println(a*b);
  }
  public class FastScanner {
    BufferedReader reader ;
    private StringTokenizer st ;
    public FastScanner(){
      st=null ;
      reader=new BufferedReader(new InputStreamReader(System.in));
    }
    public String next()throws IOException {
      if(st==null || ! st.hasMoreElements()){
        st=new StringTokenizer(reader.readLine());
      }
      return st.nextToken();
    }
    public String nextLine()throws IOException {
      st=null ;
      String readLine=null ;
      readLine=reader.readLine();
      return readLine ;
    }
    public int nextInt()throws NumberFormatException,IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws NumberFormatException,IOException {
      return Long.parseLong(next());
    }
    public int[] nextIntArr(int n)throws NumberFormatException,IOException {
      int[] retArr=new int[n];
      for(int i=0 ; i<n ; i++){
        retArr[i]=nextInt();
      }
      return retArr ;
    }
    public long[] nextLongArr(int n)throws NumberFormatException,IOException {
      long[] retArr=new long[n];
      for(int i=0 ; i<n ; i++){
        retArr[i]=nextLong();
      }
      return retArr ;
    }
    public void close()throws IOException {
      reader.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mainObj : Main ; mainObj := Main.newMain() ;
     mainObj.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var a : int ; a := fs.nextInt() ;
     var b : int ; b := fs.nextInt() ;
     OclFile["System.out"].println(a * b) );
 class FastScanner {
   attribute reader : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     st := null ; 
     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (st = null or not(st.hasNext())) then (     st := OclIterator.newOclIterator_String(reader.readLine()) ) else skip ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     st := null ; 
     var readLine : String ; readLine := null ;
     readLine := reader.readLine() ; 
     return readLine );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextIntArr( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var retArr : Sequence(int) ; retArr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     retArr[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return retArr );
   operation nextLongArr( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var retArr : Sequence(long) ; retArr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     retArr[i+1] := nextLong() )  ;     i := i + 1 ) ; 
     return retArr );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int multiplyWith3Point5(int x){
    return(x<<1)+x+(x>>1);
  }
  public static void main(String[] args){
    int x=2 ;
    System.out.println(multiplyWith3Point5(x));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation multiplyWith3Point5( x : int) : int
  pre: true
  post: true
  activity: (     return ((x*(2->pow(1)))->oclAsType(long)) + x + ((x/(2->pow(1)))->oclAsType(long)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 2 ;
     OclFile["System.out"].println(multiplyWith3Point5(x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class C {
  private BufferedReader in ;
  private PrintWriter out ;
  private StringTokenizer st ;
  private void solve()throws IOException {
    int tests=nextInt();
    for(int test=1 ; test<=tests ; test++){
      out.print("Case #"+test+": ");
      int N=nextInt();
      long L=nextLong();
      long H=nextLong();
      long[] A=new long[N];
      for(int i=0 ; i<N ; i++){
        A[i]=nextLong();
      }
      long result=-1 ;
      for(long C=L ; C<=H ; C++){
        boolean ok=true ;
        for(int i=0 ; i<N ; i++){
          if(C % A[i]!=0 && A[i] % C!=0){
            ok=false ;
            break ;
          }
        }
        if(ok){
          result=C ;
          break ;
        }
      }
      if(result==-1){
        out.println("NO");
      }
      else {
        out.println(result);
      }
    }
  }
  public static void main(String[] args){
    new C().run();
  }
  public void run(){
    try {
      in=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(System.out);
      st=null ;
      solve();
      in.close();
      out.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  private String nextToken()throws IOException {
    while(st==null || ! st.hasMoreTokens()){
      st=new StringTokenizer(in.readLine());
    }
    return st.nextToken();
  }
  private int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  private long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  private double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
   attribute in : OclFile;
   attribute out : OclFile;
   attribute st : OclIterator;
   operation solve() : void
  pre: true
  post: true
  activity: (     var tests : int ; tests := nextInt() ;
         var test : int ; test := 1 ; while test <= tests do ( (     skip ; 
     var N : int ; N := nextInt() ;
    var L : long ; L := nextLong() ;
    var H : long ; H := nextLong() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := nextLong() )  ;     i := i + 1 ) ; 
    var result : long ; result := -1 ;
        var C : long ; C := L ; while C <= H do ( (     var ok : boolean ; ok := true ;
         var i : int ; i := 0 ; while i < N do ( (     if (C mod A[i+1] /= 0 & A[i+1] mod C /= 0) then (     ok := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (ok) then (     result := C ; 
     break ) else skip )  ;     C := C + 1 ) ; 
    if (result = -1) then (     skip ) else (     skip ) ;  
 )  ;     test := test + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     C.newC().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    st := null ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package CodeJam ;
import java.util.*;
import java.io.*;
import org.apache.commons.lang.StringUtils ;
import org.apache.commons.lang.ArrayUtils ;
import java.lang.Math.*;
import java.math.BigInteger ;
import static helper.Print.*;
public class B {
  private static String inFilename="C-small-attempt0.in" ;
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(new FileReader("src/CodeJam/"+inFilename));
    PrintWriter out=new PrintWriter(new FileWriter("src/CodeJam/output.txt"));
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      String result="NO" ;
      int N=in.nextInt();
      int L=in.nextInt();
      int H=in.nextInt();
      int[] f=new int[N];
      for(int i=0 ; i<N ; i++){
        f[i]=in.nextInt();
      }
      loop : for(int i=L ;
      i<=H ;
      i++){
        int j=0 ;
        for(; j<N ; j++){
          if(!(f[j] % i==0 || i % f[j]==0)){
            continue loop ;
          }
        }
        if(j==N){
          result=String.valueOf(i);
          break ;
        }
      }
      out.print("Case #"+(t+1)+": "+result+"\n");
    }
    in.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute inFilename : String := "C-small-attempt0.in";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read("src/CodeJam/" + inFilename)) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("src/CodeJam/output.txt"))) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < T do ( (     var result : String ; result := "NO" ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var L : int ; L := in.getCurrent()->toInteger() ;
    var H : int ; H := in.getCurrent()->toInteger() ;
    var f : Sequence(int) ; f := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     f[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := L ; while i <= H do ( (     var j : int ; j := 0 ;
       while j < N do ( (     if (not((f[j+1] mod i = 0 or i mod f[j+1] = 0))) then (     continue ) else skip )  ;     j := j + 1 ) ; 
     if (j = N) then (     result := ((i) + "") ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class PerfectHarmony {
  public static void main(String args[])throws FileNotFoundException {
    new PerfectHarmony();
  }
  public PerfectHarmony()throws FileNotFoundException {
    Scanner scanner=new Scanner(System.in);
    PrintWriter writer=new PrintWriter(new File("C:/res.txt"));
    int COUNT=scanner.nextInt();
    for(int y=1 ; y<=COUNT ; y++){
      int N=scanner.nextInt(),L=scanner.nextInt(),H=scanner.nextInt();
      int nums[]=new int[N];
      for(int i=0 ; i<N ; i++)nums[i]=scanner.nextInt();
      boolean result=false ;
      loop : for(int i=L ;
      i<=H ;
      i++){
        for(int j=0 ; j<N ; j++)if(i % nums[j]!=0 && nums[j] % i!=0)continue loop ;
        writer.write(String.format("Case #%d: %d\n",y,i));
        result=true ;
        break loop ;
      }
      if(! result){
        writer.write(String.format("Case #%d: NO\n",y));
      }
    }
    writer.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class PerfectHarmony {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( PerfectHarmony.newPerfectHarmony() );
   static operation newPerfectHarmony() : PerfectHarmony
  pre: true
  post: true
  activity:
  ( var self : PerfectHarmony ;
    self := createPerfectHarmony();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile("C:/res.txt")) ;
    var COUNT : int ; COUNT := scanner.getCurrent()->toInteger() ;
        var y : int ; y := 1 ; while y <= COUNT do ( (     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var L : int ; L := scanner.getCurrent()->toInteger() ;
    var H : int ; H := scanner.getCurrent()->toInteger() ;
     var nums : Sequence(int) ; nums := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     nums[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var result : boolean ; result := false ;
        var i : int ; i := L ; while i <= H do ( (         var j : int ; j := 0 ; while j < N do (     if (i mod nums[j+1] /= 0 & nums[j+1] mod i /= 0) then     continue else skip ;  ;     j := j + 1 ) ; 
     skip ; 
     result := true ; 
     break )  ;     i := i + 1 ) ; 
    if (not(result)) then (     skip ) else skip ; 
 )  ;     y := y + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  Scanner in ;
  PrintWriter out ;
  static final String problem="C-small" ;
  static void asserT(boolean e){
    if(! e){
      throw new Error();
    }
  }
  void solveOne(){
    int nPlayers=in.nextInt();
    int low=in.nextInt();
    int high=in.nextInt();
    int freq[]=new int[nPlayers];
    for(int i=0 ; i<freq.length ; i++){
      freq[i]=in.nextInt();
    }
    for(int f=low ; f<=high ; f++){
      boolean fail=false ;
      for(int other : freq){
        if(other % f!=0 && f % other!=0){
          fail=true ;
          break ;
        }
      }
      if(! fail){
        out.println(f);
        return ;
      }
    }
    out.println("NO");
  }
  void solve(){
    int nTests=in.nextInt();
    for(int i=0 ; i<nTests ; i++){
      out.print("Case #"+(i+1)+": ");
      solveOne();
    }
  }
  void run(){
    try {
      in=new Scanner(new FileReader("C:\\roundC\\"+problem+".in"));out=newPrintWriter(newFileWriter("C:\\roundC\\"+problem+".out"));
    }
    catch(IOException e){
      in=new Scanner(System.in);
      out=new PrintWriter(System.out);
    }
    try {
      solve();
    }
    finally {
      out.close();
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile;
   attribute out : OclFile;
  static    attribute problem : String := "C-small";
  static   operation asserT( e : boolean) : void
  pre: true
  post: true
  activity: (     if (not(e)) then (     error SystemException() ) else skip );
   operation solveOne() : void
  pre: true
  post: true
  activity: (     var nPlayers : int ; nPlayers := in.getCurrent()->toInteger() ;
     var low : int ; low := in.getCurrent()->toInteger() ;
    var high : int ; high := in.getCurrent()->toInteger() ;
    var freq : Sequence(int) ; freq := Integer.subrange(1,nPlayers)->collect(0) ;
        var i : int ; i := 0 ; while i < freq->size() do ( (     freq[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var f : int ; f := low ; while f <= high do ( (     var fail : boolean ; fail := false ;
     for (other : freq) do ( (     if (other mod f /= 0 & f mod other /= 0) then (     fail := true ; 
     break ) else skip )  ) ; 
     if (not(fail)) then (     skip ; 
     return ) else skip )  ;     f := f + 1 ) ; 
    skip ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var nTests : int ; nTests := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < nTests do ( (     skip ; 
     execute solveOne() )  ;     i := i + 1 ) );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("C:\\roundC\\" + problem + ".in"))) ; 
     out := newPrintWriter(newFileWriter("C:\\roundC\\" + problem + ".out")) )   catch (e : IOException) do (     in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) )
     try (     execute solve() )   finally (     skip )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
import java.text.*;
import java.util.regex.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Integer.*;
import static java.lang.Double.*;
import static java.lang.Character.*;
public class C {
  Object solve(){
    int N=sc.nextInt();
    long L=sc.nextLong();
    long H=sc.nextLong();
    long[] a=new long[N];
    for(int i=0 ; i<N ; i++)a[i]=sc.nextLong();
    loop : for(long m=L ;
    m<=H ;
    m++){
      for(int i=0 ; i<N ; i++){
        if(a[i] % m!=0 && m % a[i]!=0)continue loop ;
      }
      return m ;
    }
    return "NO" ;
  }
  private static Scanner sc ;
  private static PrintWriter fw ;
  public static void main(String[] args)throws Exception {
    String inFile ;
    inFile="C-small-attempt0.in" ;
    sc=new Scanner(new FileInputStream(inFile));
    fw=new PrintWriter(new FileWriter("output.txt",false));
    int N=sc.nextInt();
    sc.nextLine();
    for(int cas=1 ; cas<=N ; cas++){
      fw.print("Case #"+cas+": ");
      Object res=new C().solve();
      if(res instanceof Double)fw.printf("%.10f\n",res);
      else fw.printf("%s\n",res);
      fw.flush();
    }
    fw.close();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
   operation solve() : OclAny
  pre: true
  post: true
  activity: (     var N : int ; N := sc.nextInt() ;
     var L : long ; L := sc.nextLong() ;
    var H : long ; H := sc.nextLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     a[i+1] := sc.nextLong() ;  ;     i := i + 1 ) ; 
        var m : long ; m := L ; while m <= H do ( (         var i : int ; i := 0 ; while i < N do ( (     if (a[i+1] mod m /= 0 & m mod a[i+1] /= 0) then     continue else skip )  ;     i := i + 1 ) ; 
     return m )  ;     m := m + 1 ) ; 
    return "NO" 
 );
  static   attribute sc : OclFile;
  static   attribute fw : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inFile : String ;
     inFile := "C-small-attempt0.in" ; 
    sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(inFile))) ; 
    fw := OclFile.newOclFile_Write(OclFile.newOclFile_Write("output.txt", false)) ; 
    var N : int ; N := sc.getCurrent()->toInteger() ;
    skip ; 
        var cas : int ; cas := 1 ; while cas <= N do ( (     skip ; 
     var res : OclAny ; res := C.newC().solve() ;
     if (res->oclIsKindOf(double)) then     skip else     skip ; ;  
     skip )  ;     cas := cas + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findSubarrCnt(int arr[],int n){
    int ans=0,XOR=0 ;
    int prefix[]=new int[n];
    for(int i=0 ; i<n ; ++i){
      XOR=XOR ^ arr[i];
      prefix[i]=XOR ;
    }
    HashMap<Integer,Integer>evenGroup=new HashMap<>();
    HashMap<Integer,Integer>oddGroup=new HashMap<>();
    oddGroup.put(0,1);
    for(int i=0 ; i<n ; ++i){
      if(i % 2==1){
        if(oddGroup.containsKey(prefix[i])){
          ans+=oddGroup.get(prefix[i]);
          oddGroup.put(prefix[i],oddGroup.get(prefix[i]+1));
        }
        else {
          oddGroup.put(prefix[i],1);
        }
      }
      else {
        if(evenGroup.containsKey(prefix[i])){
          ans+=evenGroup.get(prefix[i]);
          evenGroup.put(prefix[i],evenGroup.get(prefix[i]+1));
        }
        else {
          evenGroup.put(prefix[i],1);
        }
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      3,2,2,3,7,6 };
      int N=arr.length ;
      System.out.println(findSubarrCnt(arr,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSubarrCnt( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
    var XOR : int ; XOR := 0 ;
     var prefix : Sequence(int) ; prefix := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     XOR := MathLib.bitwiseXor(XOR,arr[i+1]) ; 
     prefix[i+1] := XOR )  ;     i := i + 1 ) ; 
    var evenGroup : Map(int,int) ; evenGroup := Map{} ;
    var oddGroup : Map(int,int) ; oddGroup := Map{} ;
    oddGroup := oddGroup->union(Map{0 |-> 1}) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 1) then (     if (oddGroup->keys()->includes(prefix[i+1])) then (     ans := ans+(oddGroup->at(prefix[i+1])) ; 
     oddGroup := oddGroup->union(Map{prefix[i+1] |-> oddGroup->at(prefix[i+1] + 1)}) ) else (     oddGroup := oddGroup->union(Map{prefix[i+1] |-> 1}) ) ) else (     if (evenGroup->keys()->includes(prefix[i+1])) then (     ans := ans+(evenGroup->at(prefix[i+1])) ; 
     evenGroup := evenGroup->union(Map{prefix[i+1] |-> evenGroup->at(prefix[i+1] + 1)}) ) else (     evenGroup := evenGroup->union(Map{prefix[i+1] |-> 1}) ) ) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,2,2,3,7,6} ;
     var N : int ; N := arr->size() ;
     OclFile["System.out"].println(findSubarrCnt(arr, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int h=Integer.parseInt(scanner.next());
    int n=Integer.parseInt(scanner.next());
    for(int i=1 ; i<=n ; i++){
      h=h-Integer.parseInt(scanner.next());
    }
    if(h<=0){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := (scanner.getCurrent())->toInteger() ;
    var n : int ; n := (scanner.getCurrent())->toInteger() ;
        var i : int ; i := 1 ; while i <= n do ( (     h := h - (scanner.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    if (h <= 0) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Main {
  public static final long mod=(long)1e9+7 ;
  public static final int inf=Integer.MAX_VALUE/10 ;
  static void solve(InputReader in,PrintWriter out){
    int h=in.ni();
    int n=in.ni();
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=in.ni();
    }
    out.println(sum>=h ? "Yes" : "No");
  }
  public static void main(String[] args)throws Exception {
    InputReader in=new InputReader(System.in);
    PrintWriter out=new PrintWriter(System.out);
    solve(in,out);
    out.close();
  }
  public static class InputReader {
    private BufferedReader br ;
    private StringTokenizer st ;
    public InputReader(InputStream is){
      br=new BufferedReader(new InputStreamReader(is));
      st=null ;
    }
    public String ns(){
      if(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(Exception e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    public long nl(){
      return Long.parseLong(ns());
    }
    public int ni(){
      return Integer.parseInt(ns());
    }
    public Double nd(){
      return Double.parseDouble(ns());
    }
    public int[] ni(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=ni();
      }
      return a ;
    }
    public long[] nl(int n){
      long[] a=new long[n];
      for(int i=0 ; i<n ; i++){
        a[i]=nl();
      }
      return a ;
    }
    public double[] nd(int n){
      double[] a=new double[n];
      for(int i=0 ; i<n ; i++){
        a[i]=nd();
      }
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute mod : long := 1e9->oclAsType(long) + 7;
  static    attribute inf : int := 2147483647 / 10;
  static   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var h : int ; h := in.ni() ;
     var n : int ; n := in.ni() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(in.ni()) )  ;     i := i + 1 ) ; 
    out.println(if sum >= h then "Yes" else "No" endif) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : InputReader ; in := InputReader.newInputReader(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     execute solve(in, out) ; 
     skip );
  static class InputReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newInputReader( is : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) ; 
     st := null );
   operation ns() : String
  pre: true
  post: true
  activity: (     if (st = null or not(st.hasNext())) then (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     error ProgramException(e) )
 ) else skip ; 
     return st.next() );
   operation nl() : long
  pre: true
  post: true
  activity: (     return (ns())->toLong() );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (ns())->toInteger() );
   operation nd() : double
  pre: true
  post: true
  activity: (     return (ns())->toReal() );
   operation ni( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := ni() )  ;     i := i + 1 ) ; 
     return a );
   operation nl( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := nl() )  ;     i := i + 1 ) ; 
     return a );
   operation nd( n : int) : Sequence(double)
  pre: true
  post: true
  activity: (     var a : Sequence(double) ; a := Integer.subrange(1,n)->collect(0.0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := nd() )  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastScanner sc=new FastScanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long h=sc.nextLong(),n=sc.nextLong();
    long all=0 ;
    for(; n>0 ; n--){
      all+=sc.nextLong();
    }
    pw.print(all<h ? "No" : "Yes");
    pw.close();
  }
  static class FastScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public FastScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
      tokenizer=null ;
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          return reader.readLine();
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken("\n");
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public int[] nextIntArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    public long[] nextLongArray(int n){
      long[] a=new long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var h : long ; h := sc.nextLong() ;
    var n : long ; n := sc.nextLong() ;
    var all : long ; all := 0 ;
      while n > 0 do ( (     all := all+(sc.nextLong()) )  ;     n := n - 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.nextToken("\n") );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    ArrayList<Long>list=new ArrayList<>();
    long x=scn.nextInt();
    long t=scn.nextInt();
    for(int i=0 ; i<t ; i++){
      long y=scn.nextLong();
      list.add(y);
    }
    long s=0 ;
    for(Long i : list){
      s=s+i ;
    }
    if(s>=x){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
    scn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(long) ; list := Sequence{} ;
    var x : long ; x := scn.getCurrent()->toInteger() ;
    var t : long ; t := scn.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < t do ( (     var y : long ; y := scn.getCurrent()->toLong() ;
     list := list->including(y) )  ;     i := i + 1 ) ; 
    var s : long ; s := 0 ;
    for (i : list) do ( (     s := s + i )  ) ; 
    if (s >= x) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int m=sc.nextInt();
      int n=sc.nextInt();
      boolean[][] e=new boolean[m+1][m+1];
      int[] deg=new int[m+1];
      for(int i=0 ; i<n ; i++){
        int x=sc.nextInt();
        int y=sc.nextInt();
        e[y][x]=true ;
        deg[y]++;
      }
      for(int i=0 ; i<m ; i++){
        for(int j=1 ; j<=m ; j++){
          if(deg[j]==0){
            if(i!=m-1 && j==2)continue ;
            System.out.println(j);
            deg[j]=-1 ;
            for(int k=1 ; k<=m ; k++)if(e[k][j]){
              deg[k]--;
            }
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var m : int ; m := sc.getCurrent()->toInteger() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var e : Sequence(Sequence(boolean)) ; e := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,m + 1)->collect(false)) ;
    var deg : Sequence(int) ; deg := Integer.subrange(1,m + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     e[y+1][x+1] := true ; 
     deg[y+1] := deg[y+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 1 ; while j <= m do ( (     if (deg[j+1] = 0) then (     if (i /= m - 1 & j = 2) then     continue else skip ; 
     OclFile["System.out"].println(j) ; 
     deg[j+1] := -1 ; 
         var k : int ; k := 1 ; while k <= m do (     if (e[k+1][j+1]) then (     deg[k+1] := deg[k+1] - 1 ) else skip ;  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static FastReader in=new FastReader(System.in);
  private static PrintWriter out=new PrintWriter(System.out);
  private static final long MOD=(long)1e9+7 ;
  public static void main(String[] args){
    solve();
    out.flush();
  }
  private static void solve(){
    int a=in.nextInt();
    int b=in.nextInt();
    out.println(a*b);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    FastReader(InputStream inputStream){
      br=new BufferedReader(new InputStreamReader(inputStream));
    }
    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 ;
    }
    public int[] nextIntArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    public long[] nextLongArray(int n){
      long[] a=new long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : FastReader := FastReader.newFastReader(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static    attribute MOD : long := 1e9->oclAsType(long) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() ; 
     skip );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.nextInt() ;
     var b : int ; b := in.nextInt() ;
     skip );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader( inputStream : OclFile) : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int sum=sc.nextInt();
    int n=sc.nextInt();
    int tmpsum=0 ;
    for(int i=0 ; i<n ; i++){
      tmpsum+=sc.nextInt();
    }
    if(tmpsum>=sum){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sum : int ; sum := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var tmpsum : int ; tmpsum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     tmpsum := tmpsum+(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    if (tmpsum >= sum) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int n=gi();
    long[] T=new long[n];
    long s=1 ;
    for(int i=0 ; i<n ; i++){
      T[i]=gl();
      s=(s/uclid(s,T[i]))*T[i];
    }
    System.out.println(s);
  }
  public static long uclid(long m,long n){
    if(m<n){
      m ^=n ;
      n ^=m ;
      m ^=n ;
    }
    while(true){
      long t=m % n ;
      if(t==0){
        return n ;
      }
      else {
        m=n ;
        n=t ;
      }
    }
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := gi() ;
    var T : Sequence(long) ; T := Integer.subrange(1,n)->collect(0) ;
    var s : long ; s := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     T[i+1] := gl() ; 
     s := (s / uclid(s, T[i+1])) * T[i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 );
  static   operation uclid( m : long, n : long) : long
  pre: true
  post: true
  activity: (     if (m < n) then (     m := MathLib.bitwiseXor(m,n) ; 
     n := MathLib.bitwiseXor(n,m) ; 
     m := MathLib.bitwiseXor(m,n) ) else skip ; 
     while (true) do (     var t : long ; t := m mod n ;
     if (t = 0) then (     return n ) else (     m := n ; 
     n := t ) ) );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskC solver=new TaskC();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskC {
    long gcd(long a,long b){
      if(b==0)return a ;
      return gcd(b,a % b);
    }
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      long[] T=new long[n];
      for(int i=0 ; i<n ; i++){
        T[i]=in.nextLong();
      }
      long sum=1 ;
      for(long l : T){
        long gcd1=gcd(sum,l);
        l/=gcd1 ;
        sum*=l ;
      }
      out.println(sum);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextFloat(){
      return Double.parseDouble(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskC ; solver := TaskC.newTaskC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskC {
   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var T : Sequence(long) ; T := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     T[i+1] := in.nextLong() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 1 ;
    for (l : T) do ( (     var gcd1 : long ; gcd1 := gcd(sum, l) ;
     l := l/(gcd1) ; 
     sum := sum*(l) )  ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Throwable {
    MyScanner sc=new MyScanner();
    PrintWriter pw=new PrintWriter(System.out);
    int n=sc.nextInt()-1 ;
    long lcm=sc.nextLong();
    while(n-->0){
      long t=sc.nextLong();
      long g=gcd(lcm,t);
      lcm=(lcm/g)*t ;
    }
    pw.println(lcm);
    pw.flush();
    pw.close();
  }
  static long gcd(long a,long b){
    return b==0 ? a : gcd(b,a % b);
  }
  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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.nextInt() - 1 ;
    var lcm : long ; lcm := sc.nextLong() ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var t : long ; t := sc.nextLong() ;
     var g : long ; g := gcd(lcm, t) ;
     lcm := (lcm / g) * t ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.math.BigInteger ;
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner cin=new Scanner(new BufferedInputStream(System.in));
    int T ;
    while(cin.hasNext()){
      BigInteger ans=BigInteger.valueOf(1);
      T=cin.nextInt();
      BigInteger tmp ;
      for(int i=0 ; i<T ; i++){
        tmp=cin.nextBigInteger();
        ans=ans.multiply(tmp).divide(ans.gcd(tmp));
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var T : int ;
     while (cin.hasNext()) do (     var ans : long ; ans := (1 + "")->toLong() ;
     T := cin.getCurrent()->toInteger() ; 
    var tmp : long ;
        var i : int ; i := 0 ; while i < T do ( (     tmp := cin.nextBigInteger() ; 
     ans := ans.multiply(tmp).divide(ans.gcd(tmp)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  private static BigInteger Max=new BigInteger("1000000000000000000");
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    BigInteger[] input=new BigInteger[N];
    for(int i=0 ; i<N ; i++){
      input[i]=new BigInteger(sc.next());
    }
    BigInteger result=BigInteger.ONE ;
    for(BigInteger temp : input){
      result=LCM(result,temp);
    }
    if(result.compareTo(Max)>=0)result=Max ;
    System.out.println(result.toString());
  }
  private static BigInteger GCD(BigInteger a,BigInteger b){
    return a.gcd(b);
  }
  private static BigInteger LCM(BigInteger a,BigInteger b){
    if(b.compareTo(Max)>=0){
      return Max ;
    }
    else {
      return a.multiply(b).divide(GCD(a,b));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute Max : long := long("1000000000000000000");
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var input : Sequence(long) ; input := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     input[i+1] := long(sc.getCurrent()) )  ;     i := i + 1 ) ; 
    var result : long ; result := 1 ;
    for (temp : input) do ( (     result := LCM(result, temp) )  ) ; 
    if (result->compareTo(Max) >= 0) then     result := Max ; else skip ; 
    OclFile["System.out"].println(result+"") ; 
 );
  static   operation GCD( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return a.gcd(b) );
  static   operation LCM( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b->compareTo(Max) >= 0) then (     return Max ) else (     return a.multiply(b).divide(GCD(a, b)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args)throws IOException {
    FastReader ob=new FastReader();
    try {
      int t=ob.nextInt();
      while(t--!=0){
        long a=ob.nextLong();
        long b=ob.nextLong();
        long currXor=0 ;
        currXor=a % 4==0 ? 0 : a % 4==1 ? a-1 : a % 4==3 ? a : 1 ;
        if(currXor==b){
          System.out.println(a);
        }
        else {
          long ans=0 ;
          if((currXor ^ b)!=a)System.out.println(a+1);
          else System.out.println(a+2);
        }
      }
    }
    catch(Exception e){
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ob : FastReader ; ob := FastReader.newFastReader() ;
     try (     var t : int ; t := ob.nextInt() ;
         while (t /= 0) do (    skip ; (     var a : long ; a := ob.nextLong() ;
     var b : long ; b := ob.nextLong() ;
    var currXor : long ; currXor := 0 ;
    currXor := if a mod 4 = 0 then 0 else if a mod 4 = 1 then a - 1 else if a mod 4 = 3 then a else 1 endif endif endif ; 
    if (currXor = b) then (     OclFile["System.out"].println(a) ) else (     var ans : long ; ans := 0 ;
     if ((MathLib.bitwiseXor(currXor,b)) /= a) then     OclFile["System.out"].println(a + 1) ; else     OclFile["System.out"].println(a + 2) ; ) ;  
 ) ;  ) )   catch (e : ProgramException) do (     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  public static void main(String[] args)throws IOException {
    Reader sc=new Reader();
    PrintWriter out=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int xor ;
      if(a % 4==1)xor=a-1 ;
      else if(a % 4==2)xor=1 ;
      else if(a % 4==3)xor=a ;
      else xor=0 ;
      if(xor==b)out.println(a);
      else if((xor ^ b)!=a)out.println((a+1));
      else out.println((a+2));
      out.flush();
    }
  }
  static class Reader {
    BufferedReader br ;
    StringTokenizer st ;
    public Reader(){
      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 {
        if(st.hasMoreTokens())str=st.nextToken("\n");
        else str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var xor : int ;
    if (a mod 4 = 1) then     xor := a - 1 else     if (a mod 4 = 2) then     xor := 1 else     if (a mod 4 = 3) then     xor := a else     xor := 0 ; ;  ;  ;  
    if (xor = b) then     skip else     if ((MathLib.bitwiseXor(xor,b)) /= a) then     skip else     skip ; ;  ;  
    skip ; 
 ) ;  ) );
  static class Reader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newReader() : Reader
  pre: true
  post: true
  activity:
  ( var self : Reader ;
    self := createReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then     str := st.nextToken("\n") ; else     str := br.readLine() ; )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] xorPrefix=new int[1_000_000];
    for(int i=1 ; i<xorPrefix.length ; i++)xorPrefix[i]=xorPrefix[i-1] ^ i ;
    for(int p=0 ; p<N ; p++){
      int a=sc.nextInt(),b=sc.nextInt();
      int required=xorPrefix[a-1] ^ b ;
      if(required==0)System.out.println(a);
      else if(required==a)System.out.println(a+2);
      else System.out.println(a+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var xorPrefix : Sequence(int) ; xorPrefix := Integer.subrange(1,1_000_000)->collect(0) ;
        var i : int ; i := 1 ; while i < xorPrefix->size() do (     xorPrefix[i+1] := xorPrefix[i - 1+1] xor i ;  ;     i := i + 1 ) ; 
        var p : int ; p := 0 ; while p < N do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
     var required : int ; required := MathLib.bitwiseXor(xorPrefix[a - 1+1],b) ;
     if (required = 0) then     OclFile["System.out"].println(a) ; else     if (required = a) then     OclFile["System.out"].println(a + 2) else     OclFile["System.out"].println(a + 1) ; ;  )  ;     p := p + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    switch(sc.next()){
      case "a" : case "i" : case "u" : case "e" : case "o" : System.out.println("vowel");
      break ;
      default : System.out.println("consonant");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (sc.getCurrent()) ; 
    if _switchval = "a" or _switchval = "i" or _switchval = "u" or _switchval = "e" or _switchval = "o" then
    OclFile["System.out"].println("vowel") ; 
    break 
   else skip ;
       if true then
     OclFile["System.out"].println("consonant") ; 
   else skip ;
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public final class Main {
  public static void main(String[] args){
    final Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    final int first=in.nextInt();
    final int second=in.nextInt();
    System.out.println(first*second);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var first : int ; first := in.getCurrent()->toInteger() ;
     var second : int ; second := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println(first * second) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String c=br.readLine();
      if(c.equals("a")|| c.equals("e")|| c.equals("i")|| c.equals("o")|| c.equals("u")){
        System.out.println("vowel");
      }
      else {
        System.out.println("consonant");
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var c : String ; c := br.readLine() ;
     if (c = "a" or c = "e" or c = "i" or c = "o" or c = "u") then (     OclFile["System.out"].println("vowel") ) else (     OclFile["System.out"].println("consonant") ) ))   catch (e : IOException) do (     e.printStackTrace() )
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Main(){
  }
  public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    final String a="a" ;
    final String e="e" ;
    final String i="i" ;
    final String o="o" ;
    final String u="u" ;
    String text="" ;
    text=scanner.nextLine();
    switch(text){
      case a : System.out.println("vowel");
      break ;
      case e : System.out.println("vowel");
      break ;
      case i : System.out.println("vowel");
      break ;
      case o : System.out.println("vowel");
      break ;
      case u : System.out.println("vowel");
      break ;
      default : System.out.println("consonant");
      break ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := "a" ;
    var e : String ; e := "e" ;
    var i : String ; i := "i" ;
    var o : String ; o := "o" ;
    var u : String ; u := "u" ;
    var text : String ; text := "" ;
    text := scanner.nextLine() ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (text) ; 
       if _switchval = a then
     OclFile["System.out"].println("vowel") ; 
    break 
   else skip ;
       if _switchval = e then
     OclFile["System.out"].println("vowel") ; 
    break 
   else skip ;
       if _switchval = i then
     OclFile["System.out"].println("vowel") ; 
    break 
   else skip ;
       if _switchval = o then
     OclFile["System.out"].println("vowel") ; 
    break 
   else skip ;
       if _switchval = u then
     OclFile["System.out"].println("vowel") ; 
    break 
   else skip ;
       if true then
     OclFile["System.out"].println("consonant") ; 
    break 
   else skip ;
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static char c ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    c=sc.next().charAt(0);
    boolean isVowel=false ;
    switch(c){
      case 'a' : case 'e' : case 'i' : case 'o' : case 'u' : isVowel=true ;
    }
    if(isVowel){
      System.out.println("vowel");
    }
    else {
      System.out.println("consonant");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute c : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     c := sc.getCurrent()->at(0+1) ; 
    var isVowel : boolean ; isVowel := false ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
    if _switchval = 'a' or _switchval = 'e' or _switchval = 'i' or _switchval = 'o' or _switchval = 'u' then
    isVowel := true ; 
   else skip ;
      )
    if (isVowel) then (     OclFile["System.out"].println("vowel") ) else (     OclFile["System.out"].println("consonant") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    char c=s.charAt(0);
    String ans ;
    if(c=='a'){
      ans="vowel" ;
    }
    else if(c=='i'){
      ans="vowel" ;
    }
    else if(c=='u'){
      ans="vowel" ;
    }
    else if(c=='e'){
      ans="vowel" ;
    }
    else if(c=='o'){
      ans="vowel" ;
    }
    else {
      ans="consonant" ;
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var c : String ; c := s->at(0+1) ;
    var ans : String ;
    if (c = 'a') then (     ans := "vowel" ) else     if (c = 'i') then (     ans := "vowel" ) else     if (c = 'u') then (     ans := "vowel" ) else     if (c = 'e') then (     ans := "vowel" ) else     if (c = 'o') then (     ans := "vowel" ) else (     ans := "consonant" ) ;  ;  ;  ;  ;  
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    int max_idx=-1 ;
    int max=-1 ;
    for(int i=0 ; i<n ; i++){
      int a=stdIn.nextInt();
      int b=stdIn.nextInt();
      if(max<b){
        max_idx=a ;
        max=b ;
      }
      else if(max==b && max_idx>a){
        max_idx=a ;
      }
    }
    System.out.println(max_idx+" "+max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var max_idx : int ; max_idx := -1 ;
    var max : int ; max := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := stdIn.getCurrent()->toInteger() ;
     var b : int ; b := stdIn.getCurrent()->toInteger() ;
     if (max < b) then (     max_idx := a ; 
     max := b ) else     if (max = b & max_idx > a) then (     max_idx := a ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max_idx + " " + max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    int cnt=parseNum();
    int[] out={
-1,-1 };
      int[] tmp=null ;
      for(int n=0 ; n<cnt ; n++){
        tmp=parseScore();
        if(out[1]<tmp[1] || out[1]==tmp[1] && out[0]>tmp[0]){
          out[0]=tmp[0];
          out[1]=tmp[1];
        }
      }
      System.out.printf("%d %d\n",out[0],out[1]);
    }
    private static int[] parseScore(){
      int[] params=new int[2];
      String strin=null ;
      if((strin=parseStdin())!=null){
        String[] lines=strin.split(" ");
        params[0]=Integer.parseInt(lines[0]);
        params[1]=Integer.parseInt(lines[1]);
      }
      return params ;
    }
    private static int parseNum(){
      int param=0 ;
      String strin=null ;
      if((strin=parseStdin())!=null){
        param=Integer.parseInt(strin);
      }
      return param ;
    }
    private static String parseStdin(){
      String stdin=null ;
      try {
        String tmp=br.readLine();
        if(! tmp.isEmpty())stdin=tmp ;
      }
      catch(IOException e){
      }
      return stdin ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := parseNum() ;
     var out : Sequence(int) ; out := Sequence{-1,-1} ;
    var tmp : Sequence(int) ; tmp := null ;
        var n : int ; n := 0 ; while n < cnt do ( (     tmp := parseScore() ; 
     if (out[1+1] < tmp[1+1] or out[1+1] = tmp[1+1] & out[0+1] > tmp[0+1]) then (     out[0+1] := tmp[0+1] ; 
     out[1+1] := tmp[1+1] ) else skip )  ;     n := n + 1 ) ; 
    OclFile["System.out"].printf("%d %d\n", out[0+1], out[1+1]) ; 
 );
  static   operation parseScore() : Sequence(int)
  pre: true
  post: true
  activity: (     var params : Sequence(int) ; params := Integer.subrange(1,2)->collect(0) ;
     var strin : String ; strin := null ;
     if ((strin) /= null) then (     var lines : Sequence(String) ; lines := strin->split(" ") ;
     params[0+1] := (lines[0+1])->toInteger() ; 
     params[1+1] := (lines[1+1])->toInteger() ) else skip ; 
     return params );
  static   operation parseNum() : int
  pre: true
  post: true
  activity: (     var param : int ; param := 0 ;
     var strin : String ; strin := null ;
     if ((strin) /= null) then (     param := (strin)->toInteger() ) else skip ; 
     return param );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var stdin : String ; stdin := null ;
     try (     var tmp : String ; tmp := br.readLine() ;
     if (not(tmp->isEmpty())) then     stdin := tmp ; else skip )   catch (e : IOException) do skip
     return stdin );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n,i,v,max,m,mmin ;
    n=sc.nextInt();
    max=-1 ;
    mmin=-1 ;
    for(i=0 ; i<n ; i++){
      m=sc.nextInt();
      v=sc.nextInt();
      if(max<v ||(max==v && mmin>m)){
        max=v ;
        mmin=m ;
      }
    }
    out.println(mmin+" "+max);
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var i : int ;
    var v : int ;
    var max : int ;
    var m : int ;
    var mmin : int ;
    n := sc.nextInt() ; 
    max := -1 ; 
    mmin := -1 ; 
        i := 0 ; while i < n do ( (     m := sc.nextInt() ; 
     v := sc.nextInt() ; 
     if (max < v or (max = v & mmin > m)) then (     max := v ; 
     mmin := m ) else skip )  ;     i := i + 1 ) ; 
    out.println(mmin + " " + max) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
class Player implements Comparable<Player>{
  public int a,v ;
  Player(int a,int v){
    this.a=a ;
    this.v=v ;
  }
  public int compareTo(Player t){
    return this.a-t.a ;
  }
}
public class Main {
  public static void main(String[] args){
    ArrayList<Player>ar=new ArrayList<Player>();
    int Champion=0,num=Integer.MIN_VALUE ;
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n-->0){
      ar.add(new Player(sc.nextInt(),sc.nextInt()));
    }
    Collections.sort(ar);
    for(Player p : ar){
      if(p.v>num){
        Champion=p.a ;
        num=p.v ;
      }
    }
    System.out.println(Champion+" "+num);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Player implements Comparable<Player> {
   attribute a : int;
   static operation newPlayer( a : int, v : int) : Player
  pre: true
  post: true
  activity:
  ( var self : Player ;
    self := createPlayer();
    self.initialise(a, v);
    return self );
  operation initialise( a : int, v : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.v := v );
   operation compareTo( t : Player) : int
  pre: true
  post: true
  activity: (     return self.a - t.a );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ar : Sequence(Player) ; ar := Sequence{} ;
     var Champion : int ; Champion := 0 ;
    var num : int ; num := -2147483648 ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     ar := ar->including(Player.newPlayer(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) ) ;  ) ;  
    ar := ar->sort() ; 
    for (p : ar) do ( (     if (p.v > num) then (     Champion := p.a ; 
     num := p.v ) else skip )  ) ; 
    OclFile["System.out"].println(Champion + " " + num) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String victim1=scanner.next(),victim2=scanner.next();
    int n=scanner.nextInt();
    System.out.println(victim1+' '+victim2);
    while(n-->0){
      String killed=scanner.next(),newVictim=scanner.next();
      if(killed.equals(victim1)){
        victim1=newVictim ;
      }
      else {
        victim2=newVictim ;
      }
      System.out.println(victim1+' '+victim2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var victim1 : String ; victim1 := scanner.getCurrent() ;
    var victim2 : String ; victim2 := scanner.getCurrent() ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    OclFile["System.out"].println(victim1 + ' ' + victim2) ; 
        while (n > 0) do (        n := n - 1 ;     skip ; (     var killed : String ; killed := scanner.getCurrent() ;
    var newVictim : String ; newVictim := scanner.getCurrent() ;
     if (killed = victim1) then (     victim1 := newVictim ) else (     victim2 := newVictim ) ;  
     OclFile["System.out"].println(victim1 + ' ' + victim2) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s="" ;
    int[] top=new int[] {
      21,-1 };
      int n=Integer.parseInt(br.readLine());
      int i=0 ;
      while((s=br.readLine())!=null){
        if(i==n)break ;
        Scanner sc=new Scanner(s);
        int _angler=sc.nextInt();
        int _catch=sc.nextInt();
        if(_angler<0 || _angler>20)continue ;
        if(_catch<0 || _angler>100)continue ;
        if(top[1]<_catch ||(top[1]==_catch && top[0]>_angler)){
          top[0]=_angler ;
          top[1]=_catch ;
        }
        i++;
      }
      System.out.println(top[0]+" "+top[1]);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := "" ;
    var top : Sequence(int) ; top := Sequence{21,-1} ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var i : int ; i := 0 ;
        s := br.readLine() ;
    while ((s) /= null) do (    skip ; (     if (i = n) then     break else skip ; 
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile(s)) ;
    var _angler : int ; _angler := sc.getCurrent()->toInteger() ;
    var _catch : int ; _catch := sc.getCurrent()->toInteger() ;
    if (_angler < 0 or _angler > 20) then     continue else skip ; 
    if (_catch < 0 or _angler > 100) then     continue else skip ; 
    if (top[1+1] < _catch or (top[1+1] = _catch & top[0+1] > _angler)) then (     top[0+1] := _angler ; 
     top[1+1] := _catch ) else skip ; 
    i := i + 1 ; 
 ) ;     s := br.readLine() ;
 ) ;  
    OclFile["System.out"].println(top[0+1] + " " + top[1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void rearrange(int arr[],int n){
    int temp ;
    for(int i=0 ; i<n-1 ; i++){
      if(i % 2==0 && arr[i]>arr[i+1]){
        temp=arr[i];
        arr[i]=arr[i+1];
        arr[i+1]=temp ;
      }
      if(i % 2!=0 && arr[i]<arr[i+1]){
        temp=arr[i];
        arr[i]=arr[i+1];
        arr[i+1]=temp ;
      }
    }
  }
  static void printArray(int arr[],int size){
    for(int i=0 ; i<size ; i++)System.out.print(arr[i]+" ");
    System.out.println();
  }
  public static void main(String[] args){
    int arr[]={
      6,4,2,1,8,3 };
      int n=arr.length ;
      System.out.print("Before rearranging: \n");
      printArray(arr,n);
      rearrange(arr,n);
      System.out.print("After rearranging: \n");
      printArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation rearrange( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var temp : int ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     if (i mod 2 = 0 & arr[i+1] > arr[i + 1+1]) then (     temp := arr[i+1] ; 
     arr[i+1] := arr[i + 1+1] ; 
     arr[i + 1+1] := temp ) else skip ; 
     if (i mod 2 /= 0 & arr[i+1] < arr[i + 1+1]) then (     temp := arr[i+1] ; 
     arr[i+1] := arr[i + 1+1] ; 
     arr[i + 1+1] := temp ) else skip )  ;     i := i + 1 ) );
  static   operation printArray( arr : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < size do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,4,2,1,8,3} ;
     var n : int ; n := arr->size() ;
    OclFile["System.out"].print("Before rearranging: \n") ; 
    execute printArray(arr, n) ; 
    execute rearrange(arr, n) ; 
    OclFile["System.out"].print("After rearranging: \n") ; 
    execute printArray(arr, n) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int intA=sc.nextInt();
    int intB=sc.nextInt();
    System.out.println(intA*intB);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var intA : int ; intA := sc.getCurrent()->toInteger() ;
     var intB : int ; intB := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(intA * intB) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=null ;
    try {
      scan=new Scanner(System.in);
      int[] a=new int[2];
      int n=scan.nextInt();
      for(int i=0 ; i<n ; i++){
        int judge=scan.next().compareTo(scan.next());
        if(judge<0){
          a[1]+=3 ;
        }
        else if(judge>0){
          a[0]+=3 ;
        }
        else for(int j=0 ;
        j<2 ;
        j++)a[j]++;
      }
      System.out.printf("%d %d\n",a[0],a[1]);
    }
    finally {
      scan.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := null ;
     try (     scan := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var a : Sequence(int) ; a := Integer.subrange(1,2)->collect(0) ;
    var n : int ; n := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var judge : int ; judge := scan.getCurrent()->compareTo(scan.getCurrent()) ;
     if (judge < 0) then (     a[1+1] := a[1+1]+(3) ) else     if (judge > 0) then (     a[0+1] := a[0+1]+(3) ) else         var j : int ; j := 0 ; while j < 2 do (     a[j+1] := a[j+1] + 1 ;  ;     j := j + 1 ) ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%d %d\n", a[0+1], a[1+1]) ; 
 )   finally (     skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(in.readLine());
    int scoreT=0,scoreH=0,diff ;
    for(int i=0 ; i<n ; i++){
      String[] cardStr=in.readLine().split(" ");
      if((diff=cardStr[0] .compareToIgnoreCase(cardStr[1]))==0){
        scoreT++;
        scoreH++;
      }
      else if(diff>0){
        scoreT+=3 ;
      }
      else {
        scoreH+=3 ;
      }
    }
    System.out.println(scoreT+" "+scoreH);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (in.readLine())->toInteger() ;
    var scoreT : int ; scoreT := 0 ;
    var scoreH : int ; scoreH := 0 ;
    var diff : int ;
        var i : int ; i := 0 ; while i < n do ( (     var cardStr : Sequence(String) ; cardStr := in.readLine()->split(" ") ;
     if ((diff) = 0) then (     scoreT := scoreT + 1 ; 
     scoreH := scoreH + 1 ) else     if (diff > 0) then (     scoreT := scoreT+(3) ) else (     scoreH := scoreH+(3) ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(scoreT + " " + scoreH) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),t=0,h=0 ;
    for(int i=0 ; i<n ; i++){
      String Ta=in.next(),Ha=in.next();
      if(Ta.equals(Ha)){
        t++;
        h++;
      }
      else if(Ta.compareTo(Ha)>0){
        t+=3 ;
      }
      else {
        h+=3 ;
      }
    }
    System.out.println(t+" "+h);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var t : int ; t := 0 ;
    var h : int ; h := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var Ta : String ; Ta := in.getCurrent() ;
    var Ha : String ; Ha := in.getCurrent() ;
     if (Ta = Ha) then (     t := t + 1 ; 
     h := h + 1 ) else     if (Ta->compareTo(Ha) > 0) then (     t := t+(3) ) else (     h := h+(3) ) ;  )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(t + " " + h) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public void doIt(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int taroPoint=0 ;
    int hanakoPoint=0 ;
    for(int i=0 ; i<n ; i++){
      String taro=sc.next();
      String hanako=sc.next();
      boolean flg=true ;
      for(int j=0 ; j<taro.length()&& j<hanako.length(); j++){
        if(taro.charAt(j)>hanako.charAt(j)){
          flg=false ;
          taroPoint+=3 ;
          break ;
        }
        else if(taro.charAt(j)<hanako.charAt(j)){
          flg=false ;
          hanakoPoint+=3 ;
          break ;
        }
      }
      if(flg){
        if(taro.length()>hanako.length()){
          taroPoint+=3 ;
        }
        else if(taro.length()<hanako.length()){
          hanakoPoint+=3 ;
        }
        else {
          taroPoint+=1 ;
          hanakoPoint+=1 ;
        }
      }
    }
    System.out.println(taroPoint+" "+hanakoPoint);
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var taroPoint : int ; taroPoint := 0 ;
    var hanakoPoint : int ; hanakoPoint := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var taro : String ; taro := sc.getCurrent() ;
     var hanako : String ; hanako := sc.getCurrent() ;
    var flg : boolean ; flg := true ;
        var j : int ; j := 0 ; while j < taro->size() & j < hanako->size() do ( (     if (taro->at(j+1) > hanako->at(j+1)) then (     flg := false ; 
     taroPoint := taroPoint+(3) ; 
     break ) else     if (taro->at(j+1) < hanako->at(j+1)) then (     flg := false ; 
     hanakoPoint := hanakoPoint+(3) ; 
     break ) else skip ; )  ;     j := j + 1 ) ; 
    if (flg) then (     if (taro->size() > hanako->size()) then (     taroPoint := taroPoint+(3) ) else     if (taro->size() < hanako->size()) then (     hanakoPoint := hanakoPoint+(3) ) else (     taroPoint := taroPoint+(1) ; 
     hanakoPoint := hanakoPoint+(1) ) ;  ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(taroPoint + " " + hanakoPoint) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String args[]){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      int sumh=0,sumt=0 ;
      int n=Integer.parseInt(br.readLine());
      for(int i=0 ; i<n ; i++){
        String[] s=br.readLine().split(" ");
        if(s[0] .equals(s[1])){
          sumh+=1 ;
          sumt+=1 ;
        }
        else if(sort(s[0],s[1]))sumt+=3 ;
        else sumh+=3 ;
      }
      System.out.println(sumt+" "+sumh);
    }
    catch(IOException e){
      System.out.println(e);
    }
  }
  public static boolean sort(String f,String s){
    int i=0 ;
    while(i<f.length()){
      if(f.charAt(i)<s.charAt(i))return false ;
      else if(f.charAt(i)>s.charAt(i))return true ;
      i++;
      if(i>=s.length())return true ;
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sumh : int ; sumh := 0 ;
    var sumt : int ; sumt := 0 ;
    var n : int ; n := (br.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
     if (s[0+1] = s[1+1]) then (     sumh := sumh+(1) ; 
     sumt := sumt+(1) ) else     if (sort(s[0+1], s[1+1])) then     sumt := sumt+(3) else     sumh := sumh+(3) ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sumt + " " + sumh) ; 
 )   catch (e : IOException) do (     OclFile["System.out"].println(e) )
 );
  static   operation sort( f : String, s : String) : boolean
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     while (i < f->size()) do (     if (f->at(i+1) < s->at(i+1)) then     return false else     if (f->at(i+1) > s->at(i+1)) then     return true else skip ; ;  
     i := i + 1 ; 
     if (i >= s->size()) then     return true else skip ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double d=sc.nextInt();
    double h=sc.nextInt();
    double v=sc.nextInt();
    double e=sc.nextInt();
    double curr=h*Math.PI*d*d/4 ;
    double outgoing=v ;
    double incoming=e*Math.PI*d*d/4 ;
    if(incoming>=outgoing){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
      double net=outgoing-incoming ;
      System.out.println(curr/net);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : double ; d := sc.getCurrent()->toInteger() ;
    var h : double ; h := sc.getCurrent()->toInteger() ;
    var v : double ; v := sc.getCurrent()->toInteger() ;
    var e : double ; e := sc.getCurrent()->toInteger() ;
    var curr : double ; curr := h * 3.141592653589793 * d * d / 4 ;
    var outgoing : double ; outgoing := v ;
    var incoming : double ; incoming := e * 3.141592653589793 * d * d / 4 ;
    if (incoming >= outgoing) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ; 
     var net : double ; net := outgoing - incoming ;
     OclFile["System.out"].println(curr / net) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF667_D2_A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    double d=scanner.nextDouble();
    double h=scanner.nextDouble();
    double v=scanner.nextDouble();
    double e=scanner.nextDouble();
    double vol_water=Math.PI*(d/2)*(d/2)*h ;
    double vol_increase=Math.PI*(d/2)*(d/2)*e ;
    double vol_decrease=v ;
    double difference=vol_decrease-vol_increase ;
    if(difference>0){
      System.out.println("YES");
      System.out.println(vol_water/difference);
    }
    else {
      System.out.println("NO");
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF667_D2_A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : double ; d := scanner.getCurrent()->toReal() ;
    var h : double ; h := scanner.getCurrent()->toReal() ;
    var v : double ; v := scanner.getCurrent()->toReal() ;
    var e : double ; e := scanner.getCurrent()->toReal() ;
    var vol_water : double ; vol_water := 3.141592653589793 * (d / 2) * (d / 2) * h ;
    var vol_increase : double ; vol_increase := 3.141592653589793 * (d / 2) * (d / 2) * e ;
    var vol_decrease : double ; vol_decrease := v ;
    var difference : double ; difference := vol_decrease - vol_increase ;
    if (difference > 0) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(vol_water / difference) ) else (     OclFile["System.out"].println("NO") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(b % a==0){
      System.out.println(a+b);
    }
    else {
      System.out.println(b-a);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (b mod a = 0) then (     OclFile["System.out"].println(a + b) ) else (     OclFile["System.out"].println(b - a) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  private static class FastScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public FastScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
      tokenizer=null ;
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          return reader.readLine();
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken("\n");
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public int[] nextIntArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    public long[] nextLongArray(int n){
      long[] a=new long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
  }
  public static void main(String[] args){
    FastScanner sc=new FastScanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    System.out.println(b % a==0 ? a+b : b-a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.nextToken("\n") );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var a : int ; a := sc.nextInt() ;
     var b : int ; b := sc.nextInt() ;
     OclFile["System.out"].println(if b mod a = 0 then a + b else b - a endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int aValue ;
    int bValue ;
    int answer ;
    Scanner scanner=new Scanner(System.in);
    String A=scanner.next();
    String B=scanner.next();
    aValue=Integer.valueOf(A);
    bValue=Integer.valueOf(B);
    if(bValue % aValue==0){
      answer=bValue+aValue ;
    }
    else {
      answer=bValue-aValue ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var aValue : int ;
     var bValue : int ;
    var answer : int ;
    var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var A : String ; A := scanner.getCurrent() ;
    var B : String ; B := scanner.getCurrent() ;
    aValue := (A)->toInteger() ; 
    bValue := (B)->toInteger() ; 
    if (bValue mod aValue = 0) then (     answer := bValue + aValue ) else (     answer := bValue - aValue ) ;  
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Maximizer {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(reader.readLine());
    String num=st.nextToken();
    int n=num.length();
    char[] a=num.toCharArray();
    int k=Integer.parseInt(st.nextToken());
    for(int i=0 ; i<n-1 ; i++){
      if(k==0)break ;
      int max=i ;
      for(int j=i+1 ; j<i+k+1 && j<n ; j++)if(a[j]>a[max])max=j ;
      int ok=max-i ;
      if(ok>0){
        char x=a[max];
        while(max>i){
          a[max]=a[max-1];
          max--;
        }
        a[max]=x ;
        k-=ok ;
      }
    }
    StringBuilder ans=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      ans.append(a[i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Maximizer {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(reader.readLine()) ;
    var num : String ; num := st.next() ;
    var n : int ; n := num->size() ;
    var a : Sequence(String) ; a := num->characters() ;
    var k : int ; k := (st.next())->toInteger() ;
        var i : int ; i := 0 ; while i < (n)->char2byte() - 1 do ( (     if (k = 0) then     break else skip ; 
     var max : int ; max := i ;
        var j : int ; j := i + 1 ; while j < i + k + 1 & j < n do (     if (a[j+1] > a[max+1]) then     max := j ; else skip ;  ;     j := j + 1 ) ; 
    var ok : int ; ok := max - i ;
    if (ok > 0) then (     var x : String ; x := a[max+1] ;
     while (max > i) do (     a[max+1] := a[max - 1+1] ; 
     max := max - 1 ) ; 
     a[max+1] := x ; 
     k := k-(ok) ) else skip ; 
 )  ;     i := i + 1 ) ; 
    var ans : String ; ans := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans + StringLib.newString(a[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    int a=sc.nextInt();
    int b=sc.nextInt();
    System.out.println(b % a==0 ? a+b : b-a);
  }
  static int l_min(int[] a){
    Arrays.sort(a);
    return a[0];
  }
  static int l_max(int[] a){
    int l=a.length ;
    Arrays.sort(a);
    return a[l-1];
  }
  public static PrintWriter out ;
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var a : int ; a := sc.nextInt() ;
     var b : int ; b := sc.nextInt() ;
     OclFile["System.out"].println(if b mod a = 0 then a + b else b - a endif) );
  static   operation l_min( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     return a[0+1] );
  static   operation l_max( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var l : int ; l := a->size() ;
     a := a->sort() ; 
     return a[l - 1+1] );
  static   attribute out : OclFile;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().solveA();
  }
  private void solveA(){
    Scanner scanner=null ;
    int lineAB=0 ;
    int lineBC=0 ;
    try {
      scanner=new Scanner(System.in);
      lineAB=scanner.nextInt();
      lineBC=scanner.nextInt();
      if(lineBC % lineAB==0){
        System.out.println(lineAB+lineBC);
      }
      else {
        System.out.println(lineBC-lineAB);
      }
      System.out.println("");
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
  private void solveB(){
    Scanner scanner=null ;
    int lineAB=0 ;
    int lineBC=0 ;
    int lineCA=0 ;
    try {
      scanner=new Scanner(System.in);
      lineAB=scanner.nextInt();
      System.out.println("");
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
  private void solveC(){
    Scanner scanner=null ;
    int lineAB=0 ;
    int lineBC=0 ;
    int lineCA=0 ;
    try {
      scanner=new Scanner(System.in);
      lineAB=scanner.nextInt();
      System.out.println("");
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
  private void solveD(){
    Scanner scanner=null ;
    int lineAB=0 ;
    int lineBC=0 ;
    int lineCA=0 ;
    try {
      scanner=new Scanner(System.in);
      lineAB=scanner.nextInt();
      System.out.println("");
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solveA() );
   operation solveA() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var lineAB : int ; lineAB := 0 ;
     var lineBC : int ; lineBC := 0 ;
     try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     lineAB := scanner.getCurrent()->toInteger() ; 
    lineBC := scanner.getCurrent()->toInteger() ; 
    if (lineBC mod lineAB = 0) then (     OclFile["System.out"].println(lineAB + lineBC) ) else (     OclFile["System.out"].println(lineBC - lineAB) ) ;  
    OclFile["System.out"].println("") ; 
 )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
   operation solveB() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var lineAB : int ; lineAB := 0 ;
    var lineBC : int ; lineBC := 0 ;
    var lineCA : int ; lineCA := 0 ;
    try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     lineAB := scanner.getCurrent()->toInteger() ; 
     OclFile["System.out"].println("") )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
   operation solveC() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var lineAB : int ; lineAB := 0 ;
    var lineBC : int ; lineBC := 0 ;
    var lineCA : int ; lineCA := 0 ;
    try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     lineAB := scanner.getCurrent()->toInteger() ; 
     OclFile["System.out"].println("") )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
   operation solveD() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var lineAB : int ; lineAB := 0 ;
    var lineBC : int ; lineBC := 0 ;
    var lineCA : int ; lineCA := 0 ;
    try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     lineAB := scanner.getCurrent()->toInteger() ; 
     OclFile["System.out"].println("") )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Mytemplate {
  static boolean ans=false ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=1 ;
    while(t>0){
      t--;
      int n=sc.nextInt();
      double[][] a=new double[n][n];
      double[][] b=new double[n][n];
      double[][] c=new double[n][n];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          a[i][j]=sc.nextInt();
        }
      }
      for(int i=0 ; i<n ; i++){
        for(int j=i ; j<n ; j++){
          if(i==j){
            b[i][j]=a[i][j];
            c[i][j]=0.0 ;
          }
          else {
            b[i][j]=a[i][j]+a[j][i];
            b[i][j]/=2 ;
            b[j][i]=b[i][j];
            c[i][j]=a[i][j]-b[i][j];
            c[j][i]=-1*c[i][j];
          }
        }
      }
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          System.out.print(b[i][j]+" ");
        }
        System.out.println();
      }
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          System.out.print(c[i][j]+" ");
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mytemplate {
  static   attribute ans : boolean := false;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
     while (t > 0) do (     t := t - 1 ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(double)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0.0)) ;
    var b : Sequence(Sequence(double)) ; b := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0.0)) ;
    var c : Sequence(Sequence(double)) ; c := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     a[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i ; while j < n do ( (     if (i = j) then (     b[i+1][j+1] := a[i+1][j+1] ; 
     c[i+1][j+1] := 0.0 ) else (     b[i+1][j+1] := a[i+1][j+1] + a[j+1][i+1] ; 
     b[i+1][j+1] := b[i+1][j+1]/(2) ; 
    b[j+1][i+1] := b[i+1][j+1] ; 
    c[i+1][j+1] := a[i+1][j+1] - b[i+1][j+1] ; 
    c[j+1][i+1] := -1 * c[i+1][j+1] ; 
 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     OclFile["System.out"].print(b[i+1][j+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     OclFile["System.out"].print(c[i+1][j+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class omkarandperson {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int i=0 ;
      Vector<Integer>v=new Vector<>();
      Set<Integer>s=new HashSet<Integer>();
      for(i=0 ; i<n ; i++){
        v.add(sc.nextInt());
        s.add(v.get(i));
      }
      if(s.size()>1)System.out.println(1);
      else System.out.println(n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class omkarandperson {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var i : int ; i := 0 ;
    var v : Sequence(int) ; v := Sequence{} ;
    var s : Set(int) ; s := Set{} ;
        i := 0 ; while i < n do ( (     v := v->including(sc.getCurrent()->toInteger()) ; 
     s := s->including(v->at(i+1)) )  ;     i := i + 1 ) ; 
    if (s->size() > 1) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println(n) ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedOutputStream ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class GR10A {
  public static void main(String[] args){
    int t=scn.nextInt();
    while(t>0){
      int n=scn.nextInt();
      int[] arr=scn.readArray(n);
      Arrays.sort(arr);
      if(n>=2){
        if(arr[0]!=arr[n-1]){
          out.println(1);
        }
        else {
          out.println(n);
        }
      }
      else {
        out.println(1);
      }
      t--;
    }
    out.close();
  }
  static FastScanner scn=new FastScanner();
  static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GR10A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := scn.nextInt() ;
     while (t > 0) do (     var n : int ; n := scn.nextInt() ;
     var arr : Sequence(int) ; arr := scn.readArray(n) ;
    arr := arr->sort() ; 
    if (n >= 2) then (     if (arr[0+1] /= arr[n - 1+1]) then (     out.println(1) ) else (     out.println(n) ) ) else (     out.println(1) ) ;  
    t := t - 1 ; 
 ) ; 
     out.close() );
  static   attribute scn : FastScanner := FastScanner.newFastScanner();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t--!=0){
      int n=s.nextInt();
      HashSet<Integer>set=new HashSet<>();
      int ans=1 ;
      for(int i=0 ; i<n ; i++){
        set.add(s.nextInt());
      }
      if(set.size()==1){
        ans=n ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var set : Set(int) ; set := Set{} ;
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     set := set->including(s.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    if (set->size() = 1) then (     ans := n ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  ArrayList<LinkedList<Integer>>adjacent ;
  boolean[] visited ;
  int ni(){
    return sc.nextInt();
  }
  void dfs(int x){
    for(int y : adjacent.get(x)){
      if(! visited[y]){
        visited[y]=true ;
        dfs(y);
      }
    }
    System.out.println(x);
  }
  void io(){
    sc=new Scanner(System.in);
    int m=ni(),n=ni();
    adjacent=new ArrayList<LinkedList<Integer>>();
    for(int i=0 ; i<=m ; ++i){
      adjacent.add(new LinkedList<Integer>());
    }
    int last=0 ;
    for(int i=0 ; i<n ; ++i){
      int x=ni(),y=ni();
      adjacent.get(y).add(x);
      if(last==0 || last==x)last=y ;
    }
    visited=new boolean[m+1];
    dfs(last);
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().io();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute adjacent : Sequence(Sequence(int));
   attribute visited : Sequence(boolean);
   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
   operation dfs( x : int) : void
  pre: true
  post: true
  activity: (     for (y : adjacent->at(x+1)) do ( (     if (not(visited[y+1])) then (     visited[y+1] := true ; 
     execute dfs(y) ) else skip )  ) ; 
     OclFile["System.out"].println(x) );
   operation io() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var m : int ; m := ni() ;
    var n : int ; n := ni() ;
    adjacent := Sequence{} ; 
        var i : int ; i := 0 ; while i <= m do ( (     adjacent := adjacent->including(Sequence{}) )  ;     i := i + 1 ) ; 
    var last : int ; last := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := ni() ;
    var y : int ; y := ni() ;
     adjacent->at(y+1)->excludes(x) ; 
     if (last = 0 or last = x) then     last := y ; else skip )  ;     i := i + 1 ) ; 
    visited := Integer.subrange(1,m + 1)->collect(false) ; 
    execute dfs(last) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().io() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class OmkarAndPassword {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int t=scn.nextInt();
    while(t-->0){
      int n=scn.nextInt();
      Set<Integer>set=new HashSet<>();
      for(int i=0 ; i<n ; i++){
        int val=scn.nextInt();
        set.add(val);
      }
      if(set.size()>1){
        System.out.println(1);
      }
      else {
        System.out.println(n);
      }
    }
    scn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class OmkarAndPassword {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scn.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scn.getCurrent()->toInteger() ;
     var set : Set(int) ; set := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     var val : int ; val := scn.getCurrent()->toInteger() ;
     set := set->including(val) )  ;     i := i + 1 ) ; 
     if (set->size() > 1) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(n) ) ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.*;
public class Solution {
  static MyScanner str=new MyScanner();
  public static void main(String[] args)throws IOException {
    int T=i();
    while(T-->0){
      solve();
    }
  }
  static void solve()throws IOException {
    int n=i(),k=i(),r=i(),c=i();
    StringBuffer sf=new StringBuffer();
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=n ; j++){
        if((i+j)% k==(r+c)% k){
          sf.append('X');
        }
        else sf.append('.');
      }
      sf.append('\n');
    }
    System.out.print(sf);
  }
  public static int i()throws IOException {
    return str.nextInt();
  }
  public static long l()throws IOException {
    return str.nextLong();
  }
  public static double d()throws IOException {
    return str.nextDouble();
  }
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute str : MyScanner := MyScanner.newMyScanner();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := i() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := i() ;
    var k : int ; k := i() ;
    var r : int ; r := i() ;
    var c : int ; c := i() ;
     var sf : String ; sf := StringLib.newString() ;
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     if ((i + j) mod k = (r + c) mod k) then (     sf := sf + StringLib.newString('X') ) else     sf := sf + StringLib.newString('.') ; )  ;     j := j + 1 ) ; 
     sf := sf + StringLib.newString('
') )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(sf) );
  static   operation i() : int
  pre: true
  post: true
  activity: (     return str.nextInt() );
  static   operation l() : long
  pre: true
  post: true
  activity: (     return str.nextLong() );
  static   operation d() : double
  pre: true
  post: true
  activity: (     return str.nextDouble() );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class b {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int t=fs.nextInt();
    while(t-->0){
      int n=fs.nextInt();
      int k=fs.nextInt();
      int r=fs.nextInt();
      int c=fs.nextInt();
      char[][] board=new char[n][n];
      for(int i=0 ; i<n ; ++i){
        Arrays.fill(board[i],'.');
      }
      r--;
      c--;
      for(int i=0 ; i<n ; ++i){
        for(int j=0 ; j<n ; ++j){
          int res=(i+j-r-c)% k ;
          out.print(res==0 ? 'X' : '.');
        }
        out.println();
      }
    }
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := fs.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := fs.nextInt() ;
     var k : int ; k := fs.nextInt() ;
    var r : int ; r := fs.nextInt() ;
    var c : int ; c := fs.nextInt() ;
    var board : Sequence(Sequence(String)) ; board := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     board[i+1] := board[i+1]->collect('.') )  ;     i := i + 1 ) ; 
    r := r - 1 ; 
    c := c - 1 ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     var res : int ; res := (i + j - r - c) mod k ;
     skip )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
 ) ;  ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long t=in.nextLong();
    while(t--!=0){
      solve(in);
    }
    in.close();
  }
  public static void solve(Scanner in){
    int n=in.nextInt(),k=in.nextInt(),r=in.nextInt()-1,c=in.nextInt()-1 ;
    boolean[][] matrix=new boolean[n][n];
    for(int i=0 ; i<n ; i++){
      matrix[(r+i)% n][(c+i)% n]=true ;
    }
    for(int row=0 ; row<n ; row++){
      for(int col=0 ; col<n ; col++){
        if(matrix[row][col]){
          for(int i=0 ; i<n/k ; i++){
            matrix[row][(col+i*k)% n]=true ;
          }
          break ;
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(matrix[i][j])System.out.print('X');
        else System.out.print('.');
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : long ; t := in.getCurrent()->toLong() ;
         while (t /= 0) do (    skip ; (     execute solve(in) ) ;  ) ;  
     skip );
  static   operation solve( in : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var r : int ; r := in.getCurrent()->toInteger() - 1 ;
    var c : int ; c := in.getCurrent()->toInteger() - 1 ;
     var matrix : Sequence(Sequence(boolean)) ; matrix := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ;
        var i : int ; i := 0 ; while i < n do ( (     matrix[(r + i) mod n+1][(c + i) mod n+1] := true )  ;     i := i + 1 ) ; 
        var row : int ; row := 0 ; while row < n do ( (         var col : int ; col := 0 ; while col < n do ( (     if (matrix[row+1][col+1]) then (         var i : int ; i := 0 ; while i < n / k do ( (     matrix[row+1][(col + i * k) mod n+1] := true )  ;     i := i + 1 ) ; 
     break ) else skip )  ;     col := col + 1 ) )  ;     row := row + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (matrix[i+1][j+1]) then     OclFile["System.out"].print('X') ; else     OclFile["System.out"].print('.') ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class CF435_D2_B {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String num=scanner.next();
    int k=scanner.nextInt();
    for(int i=0 ; i<num.length()&& k>0 ; i++){
      int m=maxIndex(num.substring(i,Math.min(i+k+1,num.length())).toCharArray())+i ;
      num=num.substring(0,i)+num.charAt(m)+num.substring(i,m)+num.substring(m+1);
      k=k-(m-i);
    }
    System.out.println(num);
  }
  public static int maxIndex(char[] arr){
    char max=arr[0];
    int i=0 ;
    for(int j=1 ; j<arr.length ; j++){
      if(arr[j]>max){
        max=arr[j];
        i=j ;
      }
    }
    return i ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF435_D2_B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : String ; num := scanner.getCurrent() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < num->size() & k > 0 do ( (     var m : int ; m := maxIndex(num.subrange(i+1,Set{i + k + 1, num->size()}->min())->characters()) + i ;
     num := num.subrange(0+1,i) + num->at(m+1) + num.subrange(i+1,m) + num.subrange(m + 1+1,m + 1) ; 
     k := (k)->char2byte() - (m - i) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(num) ; 
 );
  static   operation maxIndex( arr : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var max : String ; max := arr[0+1] ;
     var i : int ; i := 0 ;
         var j : int ; j := 1 ; while j < arr->size() do ( (     if (arr[j+1] > max) then (     max := arr[j+1] ; 
     i := j ) else skip )  ;     j := j + 1 ) ; 
     return i );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void solve(int A,int B){
    int count=0 ;
    for(int i=0 ; i<32 ; i++){
      if(((A>>i)& 1)!=((B>>i)& 1)){
        count++;
      }
    }
    System.out.println("Number of different bits : "+count);
  }
  public static void main(String[] args){
    int A=12,B=15 ;
    solve(A,B);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( A : int, B : int) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < 32 do ( (     if ((((A/(2->pow(i)))->oclAsType(long)) & 1) /= (((B/(2->pow(i)))->oclAsType(long)) & 1)) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Number of different bits : " + count) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 12 ;
    var B : int ; B := 15 ;
     execute solve(A, B) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p035 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p035().run());
  }
  private static final int LIMIT=Library.pow(10,6);
  private boolean[] isPrime=Library.listPrimality(LIMIT-1);
  public String run(){
    int count=0 ;
    for(int i=0 ; i<isPrime.length ; i++){
      if(isCircularPrime(i))count++;
    }
    return Integer.toString(count);
  }
  private boolean isCircularPrime(int n){
    String s=Integer.toString(n);
    for(int i=0 ; i<s.length(); i++){
      if(! isPrime[Integer.parseInt(s.substring(i)+s.substring(0,i))])return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p035 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p035.newp035().run()) );
  static    attribute LIMIT : int := Library.pow(10, 6);
   attribute isPrime : Sequence(boolean) := Library.listPrimality(LIMIT - 1);
   operation run() : String
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < isPrime->size() do ( (     if (isCircularPrime(i)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return ((count) + "") );
   operation isCircularPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     var s : String ; s := ((n) + "") ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (not(isPrime[(s.subrange(i+1,i) + s.subrange(0+1,i))->toInteger()+1])) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void factorize(long n){
    int count=0 ;
    while(!(n % 2>0)){
      n>>=1 ;
      count++;
    }
    if(count>0){
      System.out.println("2"+" "+count);
    }
    for(long i=3 ; i<=(long)Math.sqrt(n); i+=2){
      count=0 ;
      while(n % i==0){
        count++;
        n=n/i ;
      }
      if(count>0){
        System.out.println(i+" "+count);
      }
    }
    if(n>2){
      System.out.println(n+" "+"1");
    }
  }
  public static void main(String[] args){
    long n=1000000000000000000L ;
    factorize(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation factorize( n : long) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (not((n mod 2 > 0))) do (     n := n/(2->pow(1)) ; 
     count := count + 1 ) ; 
    if (count > 0) then (     OclFile["System.out"].println("2" + " " + count) ) else skip ; 
        var i : long ; i := 3 ; while i <= (n)->sqrt()->oclAsType(long) do ( (     count := 0 ; 
     while (n mod i = 0) do (     count := count + 1 ; 
     n := n / i ) ; 
     if (count > 0) then (     OclFile["System.out"].println(i + " " + count) ) else skip )  ;     i := i+(2) ) ; 
    if (n > 2) then (     OclFile["System.out"].println(n + " " + "1") ) else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 1000000000000000000L ;
     execute factorize(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static PrintWriter out=new PrintWriter(System.out);
  static Scanner in=new Scanner(System.in);
  static BufferedReader re=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter wr=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws IOException {
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int T=in.nextInt();
    while(T>0){
      int n=in.nextInt();
      int arr[]=new int[n+1];
      for(int i=1 ; i<=n ; i++){
        arr[i]=1 ;
      }
      out.println("2");
      for(int i=1 ; i<=n ; i++){
        int a=i ;
        while(a<=n && arr[a]==1){
          out.print(a+" ");
          arr[a]=0 ;
          a*=2 ;
        }
      }
      out.println();
      T--;
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute re : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute wr : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
     while (T > 0) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := 1 )  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 1 ; while i <= n do ( (     var a : int ; a := i ;
     while (a <= n & arr[a+1] = 1) do (     skip ; 
     arr[a+1] := 0 ; 
     a := a*(2) ) )  ;     i := i + 1 ) ; 
    skip ; 
    T := T - 1 ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      TreeSet<Integer>set=new TreeSet<>();
      for(int i=1 ; i<=n ; i++){
        set.add(i);
      }
      int ans[]=new int[n+1];
      int index=1 ;
      int anscount=0 ;
      for(int i=1 ; i<=n ; i++){
        int start=i ;
        if(set.contains(start)){
          while(start<=n){
            ans[index++]=start ;
            set.remove(start);
            start*=2 ;
          }
        }
      }
      StringBuilder result=new StringBuilder();
      result.append(2+"\n");
      for(int i=1 ; i<ans.length ; i++){
        result.append(ans[i]+" ");
      }
      System.out.println(result);
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var tc : int ; tc := input.nextInt() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.nextInt() ;
     var set : Set(int) ; set := Set{} ;
        var i : int ; i := 1 ; while i <= n do ( (     set := set->including(i) )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,n + 1)->collect(0) ;
    var index : int ; index := 1 ;
    var anscount : int ; anscount := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var start : int ; start := i ;
     if (set->includes(start)) then (     while (start <= n) do (      ans[index+1] := start  ; index := index + 1 ; 
     set := set->excludingAt(start+1) ; 
     start := start*(2) ) ) else skip )  ;     i := i + 1 ) ; 
    var result : String ; result := StringLib.newString() ;
    result := result + StringLib.newString(2 + "\n") ; 
        var i : int ; i := 1 ; while i < ans->size() do ( (     result := result + StringLib.newString(ans[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ) ;  ) ;  );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.Iterator ;
import java.util.LinkedList ;
import java.util.Scanner ;
import java.util.Stack ;
public class Main {
  public static boolean visit(final int n,boolean[][] adj,final int cur,Stack<Integer>order,int[] color){
    color[cur]=1 ;
    for(int i=0 ; i<n ; i++){
      if(! adj[cur][i]){
        continue ;
      }
      if(color[i]==2){
        continue ;
      }
      else if(color[i]==1){
        return false ;
      }
      else if(! visit(n,adj,i,order,color)){
        return false ;
      }
    }
    order.push(cur);
    color[cur]=2 ;
    return true ;
  }
  public static boolean topological_sort(final int n,boolean[][] adj,Stack<Integer>stack){
    int[] color=new int[n];
    for(int i=0 ; i<n ; i++){
      if(color[i]==0 && ! visit(n,adj,i,stack,color)){
        stack.clear();
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final int m=sc.nextInt();
    final int n=sc.nextInt();
    boolean[][] relate=new boolean[m][m];
    for(int i=0 ; i<n ; i++){
      final int x=sc.nextInt()-1 ;
      final int y=sc.nextInt()-1 ;
      relate[x][y]=true ;
    }
    Stack<Integer>stack=new Stack<Integer>();
    if(! topological_sort(m,relate,stack)){
      return ;
    }
    while(! stack.empty()){
      System.out.println(stack.pop()+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation visit( n : int, adj : Sequence(Sequence(boolean)), cur : int, order : Sequence(int), color : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     color[cur+1] := 1 ; 
         var i : int ; i := 0 ; while i < n do ( (     if (not(adj[cur+1][i+1])) then (     continue ) else skip ; 
     if (color[i+1] = 2) then (     continue ) else     if (color[i+1] = 1) then (     return false ) else     if (not(visit(n, adj, i, order, color))) then (     return false ) else skip ; ;  )  ;     i := i + 1 ) ; 
    order := order->append(cur) ; 
    color[cur+1] := 2 ; 
    return true 
 );
  static   operation topological_sort( n : int, adj : Sequence(Sequence(boolean)), stack : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var color : Sequence(int) ; color := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     if (color[i+1] = 0 & not(visit(n, adj, i, stack, color))) then (     stack := stack->intersection(Set{}) ; 
     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var relate : Sequence(Sequence(boolean)) ; relate := Integer.subrange(1,m)->collect(Integer.subrange(1,m)->collect(false)) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
     var y : int ; y := sc.getCurrent()->toInteger() - 1 ;
     relate[x+1][y+1] := true )  ;     i := i + 1 ) ; 
    var stack : Sequence(int) ; stack := Sequence{} ;
    if (not(topological_sort(m, relate, stack))) then (     return ) else skip ; 
    while (not(stack->isEmpty())) do (     OclFile["System.out"].println(stack->last() + 1) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int no=sc.nextInt();
      boolean vis[]=new boolean[no+1];
      Arrays.fill(vis,false);
      System.out.println(2);
      System.out.print(1+" ");
      for(int i=2 ; i<=no ; i++){
        for(int j=i ; j<=no ; j=2*j){
          if(! vis[j]){
            vis[j]=true ;
            System.out.print(j+" ");
          }
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var no : int ; no := sc.getCurrent()->toInteger() ;
     var vis : Sequence(boolean) ; vis := Integer.subrange(1,no + 1)->collect(false) ;
    vis := vis->collect(false) ; 
    OclFile["System.out"].println(2) ; 
    OclFile["System.out"].print(1 + " ") ; 
        var i : int ; i := 2 ; while i <= no do ( (         var j : int ; j := i ; while j <= no do ( (     if (not(vis[j+1])) then (     vis[j+1] := true ; 
     OclFile["System.out"].print(j + " ") ) else skip )  ;     j := 2 * j ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.HashSet ;
import java.util.PriorityQueue ;
import java.util.StringTokenizer ;
public class Solution {
  static PrintWriter pw ;
  static FastScanner s ;
  public static void main(String[] args)throws Exception {
    pw=new PrintWriter(System.out);
    s=new FastScanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      pw.println(2);
      int a[]=new int[n];
      a[0]=1 ;
      int count=0 ;
      int i=0 ;
      int start=1 ;
      while(count<n-1){
        if(i<n && 2*a[i]<=n){
          a[++i]=2*a[i-1];
        }
        else {
          start+=2 ;
          a[++i]=start ;
        }
        count++;
      }
      for(int k=0 ; k<a.length ; k++){
        pw.print(a[k]+" ");
      }
      pw.println();
    }
    pw.flush();
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public FastScanner(String s)throws Exception {
    br=new BufferedReader(new FileReader(new File(s)));
  }
  public String next()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(next());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute pw : OclFile;
  static   attribute s : FastScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     pw := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     s := FastScanner.newFastScanner(OclFile["System.in"]) ; 
    var t : int ; t := s.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.nextInt() ;
     skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    a[0+1] := 1 ; 
    var count : int ; count := 0 ;
    var i : int ; i := 0 ;
    var start : int ; start := 1 ;
    while (count < n - 1) do (     if (i < n & 2 * a[i+1] <= n) then (         i := i + 1 ;
 a[i+1] := 2 * a[i - 1+1]  ) else (     start := start+(2) ; 
         i := i + 1 ;
 a[i+1] := start  ) ;  
     count := count + 1 ) ; 
        var k : int ; k := 0 ; while k < a->size() do ( (     skip )  ;     k := k + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class MaximumValue_276B {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine()),res=0 ;
    boolean[] seen=new boolean[2000001];
    StringTokenizer st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<n ; i++)seen[Integer.parseInt(st.nextToken())]=true ;
    int[] floors=new int[2000001];
    for(int i=1 ; i<2000001 ; i++){
      if(seen[i-1]){
        floors[i]=i-1 ;
      }
      else {
        floors[i]=floors[i-1];
      }
    }
    for(int i=1 ; i<2000001 ; i++){
      if(! seen[i])continue ;
      for(int j=2*i ; j<2000001 ; j+=i){
        res=Math.max(res,floors[j] % i);
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MaximumValue{
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var res : int ; res := 0 ;
    var seen : Sequence(boolean) ; seen := Integer.subrange(1,2000001)->collect(false) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < n do (     seen[(st.next())->toInteger()+1] := true ;  ;     i := i + 1 ) ; 
    var floors : Sequence(int) ; floors := Integer.subrange(1,2000001)->collect(0) ;
        var i : int ; i := 1 ; while i < 2000001 do ( (     if (seen[i - 1+1]) then (     floors[i+1] := i - 1 ) else (     floors[i+1] := floors[i - 1+1] ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < 2000001 do ( (     if (not(seen[i+1])) then     continue else skip ; 
         var j : int ; j := 2 * i ; while j < 2000001 do ( (     res := Set{res, floors[j+1] mod i}->max() )  ;     j := j+(i) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}
76B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var res : int ; res := 0 ;
    var seen : Sequence(boolean) ; seen := Integer.subrange(1,2000001)->collect(false) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < n do (     seen[(st.next())->toInteger()+1] := true ;  ;     i := i + 1 ) ; 
    var floors : Sequence(int) ; floors := Integer.subrange(1,2000001)->collect(0) ;
        var i : int ; i := 1 ; while i < 2000001 do ( (     if (seen[i - 1+1]) then (     floors[i+1] := i - 1 ) else (     floors[i+1] := floors[i - 1+1] ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < 2000001 do ( (     if (not(seen[i+1])) then     continue else skip ; 
         var j : int ; j := 2 * i ; while j < 2000001 do ( (     res := Set{res, floors[j+1] mod i}->max() )  ;     j := j+(i) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n+1];
    for(int i=1 ; i<=n ; i++)a[i]=sc.nextInt();
    Arrays.sort(a);
    int max=0 ;
    for(int i=1 ; i<=n ; i++){
      if(i==1 || a[i]!=a[i-1]){
        for(int j=2 ; j*a[i]<=a[n]; j++){
          int x,l=1,r=n ;
          while(l<=r){
            int mid=(l+r)>>1 ;
            if(a[mid]<j*a[i])l=mid+1 ;
            else r=mid-1 ;
          }
          max=Math.max(max,a[l-1] % a[i]);
        }
        max=Math.max(max,a[n] % a[i]);
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if (i = 1 or a[i+1] /= a[i - 1+1]) then (         var j : int ; j := 2 ; while j * a[i+1] <= a[n+1] do ( (     var x : int ;
    var l : int ; l := 1 ;
    var r : int ; r := n ;
     while (l <= r) do (     var mid : int ; mid := ((l + r)/(2->pow(1)))->oclAsType(long) ;
     if (a[mid+1] < j * a[i+1]) then     l := mid + 1 ; else     r := mid - 1 ; ) ; 
     max := Set{max, a[l - 1+1] mod a[i+1]}->max() )  ;     j := j + 1 ) ; 
     max := Set{max, a[n+1] mod a[i+1]}->max() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int cntRotations(String s,int n){
    String str=s+s ;
    int pre[]=new int[2*n];
    for(int i=0 ; i<2*n ; i++){
      if(i!=0)pre[i]+=pre[i-1];
      if(str.charAt(i)=='a' || str.charAt(i)=='e' || str.charAt(i)=='i' || str.charAt(i)=='o' || str.charAt(i)=='u'){
        pre[i]++;
      }
    }
    int ans=0 ;
    for(int i=n-1 ; i<2*n-1 ; i++){
      int r=i,l=i-n ;
      int x1=pre[r];
      if(l>=0)x1-=pre[l];
      r=i-n/2 ;
      int left=pre[r];
      if(l>=0)left-=pre[l];
      int right=x1-left ;
      if(left>right){
        ans++;
      }
    }
    return ans ;
  }
  public static void main(String args[]){
    String s="abecidft" ;
    int n=s.length();
    System.out.println(cntRotations(s,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation cntRotations( s : String, n : int) : int
  pre: true
  post: true
  activity: (     var str : String ; str := s + s ;
     var pre : Sequence(int) ; pre := Integer.subrange(1,2 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     if (i /= 0) then     pre[i+1] := pre[i+1]+(pre[i - 1+1]) ; else skip ; 
     if (str->at(i+1) = 'a' or str->at(i+1) = 'e' or str->at(i+1) = 'i' or str->at(i+1) = 'o' or str->at(i+1) = 'u') then (     pre[i+1] := pre[i+1] + 1 ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := n - 1 ; while i < 2 * n - 1 do ( (     var r : int ; r := i ;
    var l : int ; l := i - n ;
     var x1 : int ; x1 := pre[r+1] ;
    if (l >= 0) then     x1 := x1-(pre[l+1]) ; else skip ; 
    r := i - n / 2 ; 
    var left : int ; left := pre[r+1] ;
    if (l >= 0) then     left := left-(pre[l+1]) ; else skip ; 
    var right : int ; right := x1 - left ;
    if (left > right) then (     ans := ans + 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abecidft" ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].println(cntRotations(s, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Ekalavya {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char[] ch=in.next().toCharArray();
    int k=in.nextInt();
    for(int i=0 ; i<ch.length ; i++){
      int idx=-1 ;
      char max=ch[i];
      for(int j=i+1 ; j<ch.length ; j++){
        if(ch[j]>max && j-i<=k){
          max=ch[j];
          idx=j ;
        }
      }
      if(idx!=-1){
        k-=(idx-i);
        for(int j=idx ; j>i ; j--){
          char temp=ch[j];
          ch[j]=ch[j-1];
          ch[j-1]=temp ;
        }
      }
    }
    for(int i=0 ; i<ch.length ; i++){
      System.out.print(ch[i]);
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ekalavya {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ch : Sequence(String) ; ch := in.getCurrent()->characters() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < ch->size() do ( (     var idx : int ; idx := -1 ;
     var max : String ; max := ch[i+1] ;
         var j : int ; j := i + 1 ; while j < ch->size() do ( (     if (ch[j+1] > max & (j)->char2byte() - i <= k) then (     max := ch[j+1] ; 
     idx := j ) else skip )  ;     j := j + 1 ) ; 
     if (idx /= -1) then (     k := k-((idx - i)) ; 
         var j : int ; j := idx ; while j > i do ( (     var temp : String ; temp := ch[j+1] ;
     ch[j+1] := ch[(j)->char2byte() - 1+1] ; 
     ch[(j)->char2byte() - 1+1] := temp )  ;     j := j - 1 ) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < ch->size() do ( (     OclFile["System.out"].print(ch[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int longestPrefixSuffix(String s){
    int n=s.length();
    int lps[]=new int[n];
    lps[0]=0 ;
    int len=0 ;
    int i=1 ;
    while(i<n){
      if(s.charAt(i)==s.charAt(len)){
        len++;
        lps[i]=len ;
        i++;
      }
      else {
        if(len!=0){
          len=lps[len-1];
        }
        else {
          lps[i]=0 ;
          i++;
        }
      }
    }
    int res=lps[n-1];
    return(res>n/2)? n/2 : res ;
  }
  public static void main(String[] args){
    String s="abcab" ;
    System.out.println(longestPrefixSuffix(s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation longestPrefixSuffix( s : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var lps : Sequence(int) ; lps := Integer.subrange(1,n)->collect(0) ;
    lps[0+1] := 0 ; 
    var len : int ; len := 0 ;
    var i : int ; i := 1 ;
    while (i < n) do (     if (s->at(i+1) = s->at(len+1)) then (     len := len + 1 ; 
     lps[i+1] := len ; 
     i := i + 1 ) else (     if (len /= 0) then (     len := lps[len - 1+1] ) else (     lps[i+1] := 0 ; 
     i := i + 1 ) ) ) ; 
    var res : int ; res := lps[n - 1+1] ;
    return if (res > n / 2) then n / 2 else res endif 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abcab" ;
     OclFile["System.out"].println(longestPrefixSuffix(s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findMaxAverage(int arr[],int n,int k){
    if(k>n)return-1 ;
    int sum=arr[0];
    for(int i=1 ; i<k ; i++)sum+=arr[i];
    int max_sum=sum,max_end=k-1 ;
    for(int i=k ; i<n ; i++){
      sum=sum+arr[i]-arr[i-k];
      if(sum>max_sum){
        max_sum=sum ;
        max_end=i ;
      }
    }
    return max_end-k+1 ;
  }
  public static void main(String[] args){
    int arr[]={
      1,12,-5,-6,50,3 };
      int k=4 ;
      int n=arr.length ;
      System.out.println("The maximum average"+" subarray of length "+k+" begins at index "+findMaxAverage(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMaxAverage( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     if (k > n) then     return -1 else skip ; 
     var sum : int ; sum := arr[0+1] ;
        var i : int ; i := 1 ; while i < k do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    var max_sum : int ; max_sum := sum ;
    var max_end : int ; max_end := k - 1 ;
        var i : int ; i := k ; while i < n do ( (     sum := sum + arr[i+1] - arr[i - k+1] ; 
     if (sum > max_sum) then (     max_sum := sum ; 
     max_end := i ) else skip )  ;     i := i + 1 ) ; 
    return max_end - k + 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,12,-5,-6,50,3} ;
     var k : int ; k := 4 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("The maximum average" + " subarray of length " + k + " begins at index " + findMaxAverage(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findMaxAverage(int[] arr,int n,int k){
    if(k>n)return-1 ;
    int[] csum=new int[n];
    csum[0]=arr[0];
    for(int i=1 ; i<n ; i++)csum[i]=csum[i-1]+arr[i];
    int max_sum=csum[k-1],max_end=k-1 ;
    for(int i=k ; i<n ; i++){
      int curr_sum=csum[i]-csum[i-k];
      if(curr_sum>max_sum){
        max_sum=curr_sum ;
        max_end=i ;
      }
    }
    return max_end-k+1 ;
  }
  static public void main(String[] args){
    int[] arr={
      1,12,-5,-6,50,3 };
      int k=4 ;
      int n=arr.length ;
      System.out.println("The maximum "+"average subarray of length "+k+" begins at index "+findMaxAverage(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMaxAverage( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     if (k > n) then     return -1 else skip ; 
     var csum : Sequence(int) ; csum := Integer.subrange(1,n)->collect(0) ;
    csum[0+1] := arr[0+1] ; 
        var i : int ; i := 1 ; while i < n do (     csum[i+1] := csum[i - 1+1] + arr[i+1] ;  ;     i := i + 1 ) ; 
    var max_sum : int ; max_sum := csum[k - 1+1] ;
    var max_end : int ; max_end := k - 1 ;
        var i : int ; i := k ; while i < n do ( (     var curr_sum : int ; curr_sum := csum[i+1] - csum[i - k+1] ;
     if (curr_sum > max_sum) then (     max_sum := curr_sum ; 
     max_end := i ) else skip )  ;     i := i + 1 ) ; 
    return max_end - k + 1 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,12,-5,-6,50,3} ;
     var k : int ; k := 4 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("The maximum " + "average subarray of length " + k + " begins at index " + findMaxAverage(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class pair {
    int first,second ;
    public pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static Vector<pair>FindPoints(int n){
    Vector<pair>v=new Vector<pair>();
    v.add(new pair(0,0));
    v.add(new pair(0,n));
    v.add(new pair(n,0));
    v.add(new pair(n,n));
    if(n % 2==0)v.add(new pair(n/2,n/2));
    return v ;
  }
  public static void main(String[] args){
    int N=8 ;
    Vector<pair>v=FindPoints(N);
    for(pair i : v){
      System.out.print("("+i.first+","+i.second+")");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class pair {
   attribute first : int;
   static operation newpair( first : int, second : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation FindPoints( n : int) : Sequence(pair)
  pre: true
  post: true
  activity: (     var v : Sequence(pair) ; v := Sequence{} ;
     v := v->including(pair.newpair(0, 0)) ; 
    v := v->including(pair.newpair(0, n)) ; 
    v := v->including(pair.newpair(n, 0)) ; 
    v := v->including(pair.newpair(n, n)) ; 
    if (n mod 2 = 0) then     v := v->including(pair.newpair(n / 2, n / 2)) ; else skip ; 
    return v 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 8 ;
     var v : Sequence(pair) ; v := FindPoints(N) ;
     for (i : v) do ( (     OclFile["System.out"].print("(" + i->at("first") + "," + i->at("second") + ")") )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    long s=in.nextLong();
    long[] a=new long[n];
    Arrays.setAll(a,i->in.nextLong());
    pw.println(solve(n,a,s));
    pw.close();
  }
  static long solve(int n,long[] a,long s){
    long ans=-1 ;
    long sum=0 ;
    long r=Long.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      sum+=a[i];
      r=Math.min(a[i],r);
    }
    if(sum<s)return-1 ;
    long l=0 ;
    while(l<=r){
      long mid=(l+r)/2 ;
      if(possible(n,a,s,mid)){
        ans=mid ;
        l=mid+1 ;
      }
      else r=mid-1 ;
    }
    return ans ;
  }
  static boolean possible(int n,long[] a,long s,long least){
    long sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=(a[i]-least);
    if(s<=sum)return true ;
    return false ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var s : long ; s := in.getCurrent()->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
setAll(a, lambda i : OclAny in in.getCurrent()->toLong()) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( n : int, a : Sequence(long), s : long) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := -1 ;
     var sum : long ; sum := 0 ;
    var r : long ; r := "9223372036854775807"->toLong() ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(a[i+1]) ; 
     r := Set{a[i+1], r}->min() )  ;     i := i + 1 ) ; 
    if (sum < s) then     return -1 else skip ; 
    var l : long ; l := 0 ;
    while (l <= r) do (     var mid : long ; mid := (l + r) / 2 ;
     if (possible(n, a, s, mid)) then (     ans := mid ; 
     l := mid + 1 ) else     r := mid - 1 ; ) ; 
    return ans 
 );
  static   operation possible( n : int, a : Sequence(long), s : long, least : long) : boolean
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+((a[i+1] - least)) ;  ;     i := i + 1 ) ; 
     if (s <= sum) then     return true else skip ; 
     return false );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Set ;
public class DistinctElements {
  public static boolean areDistinct(Integer arr[]){
    Set<Integer>s=new HashSet<Integer>(Arrays.asList(arr));
    return(s.size()==arr.length);
  }
  public static void main(String[] args){
    Integer[] arr={
      1,2,3,2 };
      if(areDistinct(arr))System.out.println("All Elements are Distinct");
      else System.out.println("Not all Elements are Distinct");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class DistinctElements {
  static   operation areDistinct( arr : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{}->union(arr) ;
     return (s->size() = arr->size()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,2} ;
     if (areDistinct(arr)) then     OclFile["System.out"].println("All Elements are Distinct") ; else     OclFile["System.out"].println("Not all Elements are Distinct") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean maxProduct(int arr[],int n,int p){
    int minVal=arr[0];
    int maxVal=arr[0];
    int maxProduct=arr[0];
    for(int i=1 ; i<n ; i++){
      if(arr[i]<0){
        int temp=maxVal ;
        maxVal=minVal ;
        minVal=temp ;
      }
      maxVal=Math.max(arr[i],maxVal*arr[i]);
      minVal=Math.min(arr[i],minVal*arr[i]);
      if(minVal==p || maxVal==p){
        return true ;
      }
      maxProduct=Math.max(maxProduct,maxVal);
    }
    return false ;
  }
  public static void main(String[] args){
    int[] arr={
      1,2,-5,-4 };
      int product=-10 ;
      int n=arr.length ;
      if(maxProduct(arr,n,product)){
        System.out.println("YES");
      }
      else System.out.println("NO");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxProduct( arr : Sequence(int), n : int, p : int) : boolean
  pre: true
  post: true
  activity: (     var minVal : int ; minVal := arr[0+1] ;
     var maxVal : int ; maxVal := arr[0+1] ;
    var maxProduct : int ; maxProduct := arr[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] < 0) then (     var temp : int ; temp := maxVal ;
     maxVal := minVal ; 
     minVal := temp ) else skip ; 
     maxVal := Set{arr[i+1], maxVal * arr[i+1]}->max() ; 
    minVal := Set{arr[i+1], minVal * arr[i+1]}->min() ; 
    if (minVal = p or maxVal = p) then (     return true ) else skip ; 
    maxProduct := Set{maxProduct, maxVal}->max() ; 
 )  ;     i := i + 1 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,-5,-4} ;
     var product : int ; product := -10 ;
     var n : int ; n := arr->size() ;
     if (maxProduct(arr, n, product)) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printCombinations(int a[],int n,int m){
    for(int i=0 ; i<(1<<n); i++){
      int sum=0 ;
      int num=1<<(n-1);
      for(int j=0 ; j<n ; j++){
        if((i & num)>0)sum+=a[j];
        else sum+=(-1*a[j]);
        num=num>>1 ;
      }
      if(sum % m==0){
        num=1<<(n-1);
        for(int j=0 ; j<n ; j++){
          if((i & num)>0)System.out.print("+"+a[j]+" ");
          else System.out.print("-"+a[j]+" ");
          num=num>>1 ;
        }
        System.out.println();
      }
    }
  }
  public static void main(String args[]){
    int a[]={
      3,5,6,8 };
      int n=a.length ;
      int m=5 ;
      printCombinations(a,n,m);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printCombinations( a : Sequence(int), n : int, m : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < ((1*(2->pow(n)))->oclAsType(long)) do ( (     var sum : int ; sum := 0 ;
     var num : int ; num := (1*(2->pow((n - 1))))->oclAsType(long) ;
         var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd(i,num)) > 0) then     sum := sum+(a[j+1]) else     sum := sum+((-1 * a[j+1])) ; ;  
     num := (num/(2->pow(1)))->oclAsType(long) )  ;     j := j + 1 ) ; 
     if (sum mod m = 0) then (     num := (1*(2->pow((n - 1))))->oclAsType(long) ; 
         var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd(i,num)) > 0) then     OclFile["System.out"].print("+" + a[j+1] + " ") else     OclFile["System.out"].print("-" + a[j+1] + " ") ; ;  
     num := (num/(2->pow(1)))->oclAsType(long) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{3,5,6,8} ;
     var n : int ; n := a->size() ;
     var m : int ; m := 5 ;
     execute printCombinations(a, n, m) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      int[][] map=new int[n][2];
      for(int i=0 ; i<n ; i++){
        map[i][0]=scanner.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        map[i][1]=scanner.nextInt();
      }
      int[] ans=new int[2];
      for(int i=0 ; i<2 ; i++){
        int x=i ;
        int y=0 ;
        int count=0 ;
        boolean[][] b=new boolean[n][2];
        while(true){
          if(b[y][x]){
            ans[i]=Integer.MAX_VALUE ;
            break ;
          }
          if(y==n-1 && map[y][x]!=2){
            ans[i]=count ;
            break ;
          }
          b[y][x]=true ;
          if(y<n-1 && map[y][x]==1 && map[y+1][x]==1)y++;
          else if(map[y][x]==2)y--;
          else {
            if(x==0)x=1 ;
            else x=0 ;
            if(y==n-2)y+=1 ;
            else y+=2 ;
            count++;
          }
        }
      }
      if(ans[0]==Integer.MAX_VALUE && ans[1]==Integer.MAX_VALUE)System.out.println("NA");
      else System.out.println(ans[0]<ans[1] ? ans[0] : ans[1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     map[i+1][0+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     map[i+1][1+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,2)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 do ( (     var x : int ; x := i ;
     var y : int ; y := 0 ;
    var count : int ; count := 0 ;
    var b : Sequence(Sequence(boolean)) ; b := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(false)) ;
    while (true) do (     if (b[y+1][x+1]) then (     ans[i+1] := 2147483647 ; 
     break ) else skip ; 
     if (y = n - 1 & map[y+1][x+1] /= 2) then (     ans[i+1] := count ; 
     break ) else skip ; 
     b[y+1][x+1] := true ; 
     if (y < n - 1 & map[y+1][x+1] = 1 & map[y + 1+1][x+1] = 1) then     y := y + 1 ; else     if (map[y+1][x+1] = 2) then     y := y - 1 else (     if (x = 0) then     x := 1 else     x := 0 ; ;  
     if (y = n - 2) then     y := y+(1) else     y := y+(2) ; ;  
     count := count + 1 ) ;  ) ; 
 )  ;     i := i + 1 ) ; 
    if (ans[0+1] = 2147483647 & ans[1+1] = 2147483647) then     OclFile["System.out"].println("NA") else     OclFile["System.out"].println(if ans[0+1] < ans[1+1] then ans[0+1] else ans[1+1] endif) ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      int[][] map=new int[n][2];
      for(int i=0 ; i<n ; i++){
        map[i][0]=scanner.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        map[i][1]=scanner.nextInt();
      }
      int[] ans=new int[2];
      for(int i=0 ; i<2 ; i++){
        int x=i ;
        int y=0 ;
        int count=0 ;
        boolean[][] b=new boolean[n][2];
        while(true){
          if(b[y][x]){
            ans[i]=Integer.MAX_VALUE ;
            break ;
          }
          if(y==n-1 && map[y][x]!=2){
            ans[i]=count ;
            break ;
          }
          b[y][x]=true ;
          if(map[y][x]==1 && map[y+1][x]==1)y++;
          else if(map[y][x]==2)y--;
          else {
            if(x==0)x=1 ;
            else x=0 ;
            if(y==n-2)y+=1 ;
            else y+=2 ;
            count++;
          }
        }
      }
      if(ans[0]==Integer.MAX_VALUE && ans[1]==Integer.MAX_VALUE)System.out.println("NA");
      else System.out.println(ans[0]<ans[1] ? ans[0] : ans[1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     map[i+1][0+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     map[i+1][1+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,2)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 do ( (     var x : int ; x := i ;
     var y : int ; y := 0 ;
    var count : int ; count := 0 ;
    var b : Sequence(Sequence(boolean)) ; b := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(false)) ;
    while (true) do (     if (b[y+1][x+1]) then (     ans[i+1] := 2147483647 ; 
     break ) else skip ; 
     if (y = n - 1 & map[y+1][x+1] /= 2) then (     ans[i+1] := count ; 
     break ) else skip ; 
     b[y+1][x+1] := true ; 
     if (map[y+1][x+1] = 1 & map[y + 1+1][x+1] = 1) then     y := y + 1 ; else     if (map[y+1][x+1] = 2) then     y := y - 1 else (     if (x = 0) then     x := 1 else     x := 0 ; ;  
     if (y = n - 2) then     y := y+(1) else     y := y+(2) ; ;  
     count := count + 1 ) ;  ) ; 
 )  ;     i := i + 1 ) ; 
    if (ans[0+1] = 2147483647 & ans[1+1] = 2147483647) then     OclFile["System.out"].println("NA") else     OclFile["System.out"].println(if ans[0+1] < ans[1+1] then ans[0+1] else ans[1+1] endif) ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      int[] stack=new int[n+1];
      int top=0 ;
      int color=scanner.nextInt();
      for(int i=1 ; i<n ; i++){
        int cur=scanner.nextInt();
        if(color==cur)continue ;
        color=cur ;
        if(i % 2==0)stack[top++]=i ;
        else if(top>0)top--;
      }
      stack[top++]=n ;
      int ans=0 ;
      int cur=0 ;
      for(int i=0 ; i<top ; i++){
        if(i % 2==0)ans+=stack[i]-cur ;
        cur=stack[i];
      }
      if(color==0 ^ top % 2!=0)ans=n-ans ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var stack : Sequence(int) ; stack := Integer.subrange(1,n + 1)->collect(0) ;
    var top : int ; top := 0 ;
    var color : int ; color := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i < n do ( (     var cur : int ; cur := scanner.getCurrent()->toInteger() ;
     if (color = cur) then     continue else skip ; 
     color := cur ; 
     if (i mod 2 = 0) then      stack[top+1] := i  ; top := top + 1 ; else     if (top > 0) then     top := top - 1 ; else skip ; )  ;     i := i + 1 ) ; 
     stack[top+1] := n  ; top := top + 1 ; 
    var ans : int ; ans := 0 ;
    var cur : int ; cur := 0 ;
        var i : int ; i := 0 ; while i < top do ( (     if (i mod 2 = 0) then     ans := ans+(stack[i+1] - cur) ; else skip ; 
     cur := stack[i+1] )  ;     i := i + 1 ) ; 
    if (color = 0 xor top mod 2 /= 0) then     ans := n - ans ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String num=scanner.nextLine();
    int pos=0 ;
    for(int i=0 ; i<num.length(); i++){
      if(num.charAt(i)=='1')pos=i ;
    }
    if(pos==0){
      if((num.length()-1)% 2==1){
        System.out.println((num.length()-1)/2+1);
      }
      else {
        System.out.println((num.length()-1)/2);
      }
    }
    else {
      System.out.println((num.length()-1)/2+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : String ; num := scanner.nextLine() ;
    var pos : int ; pos := 0 ;
        var i : int ; i := 0 ; while i < num->size() do ( (     if (num->at(i+1) = '1') then     pos := i ; else skip )  ;     i := i + 1 ) ; 
    if (pos = 0) then (     if ((num->size() - 1) mod 2 = 1) then (     OclFile["System.out"].println((num->size() - 1) / 2 + 1) ) else (     OclFile["System.out"].println((num->size() - 1) / 2) ) ) else (     OclFile["System.out"].println((num->size() - 1) / 2 + 1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException {
    int n=sc.nextInt();
    long a[]=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      while(a[i] % 2==0){
        a[i]/=2 ;
        sum++;
      }
    }
    out.print(sum);
    out.flush();
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(FileReader fileReader){
      br=new BufferedReader(fileReader);
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     while (a[i+1] mod 2 = 0) do (     a[i+1] := a[i+1]/(2) ; 
     sum := sum + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( fileReader : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(fileReader);
    return self );
  operation initialise( fileReader : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(fileReader) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int power(int num,int n){
    if(n==0)return 1 ;
    else if(n % 2==0)return power(num,n/2)*power(num,n/2);
    else return num*power(num,n/2)*power(num,n/2);
  }
  static int checkRecursive(int x,int n,int curr_num,int curr_sum){
    int results=0 ;
    int p=power(curr_num,n);
    while(p+curr_sum<x){
      results+=checkRecursive(x,n,curr_num+1,p+curr_sum);
      curr_num++;
      p=power(curr_num,n);
    }
    if(p+curr_sum==x)results++;
    return results ;
  }
  public static void main(String[] args){
    int x=10,n=2 ;
    System.out.println(checkRecursive(x,n,1,0));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation power( num : int, n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else     if (n mod 2 = 0) then     return power(num, n / 2) * power(num, n / 2) else     return num * power(num, n / 2) * power(num, n / 2) ;  );
  static   operation checkRecursive( x : int, n : int, curr_num : int, curr_sum : int) : int
  pre: true
  post: true
  activity: (     var results : int ; results := 0 ;
     var p : int ; p := power(curr_num, n) ;
    while (p + curr_sum < x) do (     results := results+(checkRecursive(x, n, curr_num + 1, p + curr_sum)) ; 
     curr_num := curr_num + 1 ; 
     p := power(curr_num, n) ) ; 
    if (p + curr_sum = x) then     results := results + 1 ; else skip ; 
    return results 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 10 ;
    var n : int ; n := 2 ;
     OclFile["System.out"].println(checkRecursive(x, n, 1, 0)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Stack ;
public class Main {
  class R {
    int id ;
    boolean white ;
    public R(int id,boolean white){
      this.id=id ;
      this.white=white ;
    }
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      Stack<R>s=new Stack<R>();
      for(int i=1 ; i<=n ; i++){
        boolean w=sc.nextInt()==0 ;
        if(s.isEmpty()){
          s.add(new R(i,w));
          continue ;
        }
        if(i % 2==1 && s.peek().white!=w)s.add(new R(i,w));
        else if(i % 2==0 && s.peek().white!=w){
          R r=s.pop();
          s.push(new R(r.id,w));
          while(s.size()>=2){
            R a=s.pop();
            if(a.white!=s.peek().white){
              s.push(a);
              break ;
            }
          }
        }
      }
      int c=0 ;
      int p=n+1 ;
      while(! s.isEmpty()){
        R r=s.pop();
        if(r.white)c+=p-r.id ;
        p=r.id ;
      }
      System.out.println(c);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class R {
   attribute id : int;
   attribute white : boolean;
   static operation newR( id : int, white : boolean) : R
  pre: true
  post: true
  activity:
  ( var self : R ;
    self := createR();
    self.initialise(id, white);
    return self );
  operation initialise( id : int, white : boolean) : void
  pre: true  post: true
  activity: (     self.id := id ; 
     self.white := white );
}
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var s : Sequence(R) ; s := Sequence{} ;
        var i : int ; i := 1 ; while i <= n do ( (     var w : boolean ; w := sc.getCurrent()->toInteger() = 0 ;
     if (s->isEmpty()) then (     s := s->including(R.newR(i, w)) ; 
     continue ) else skip ; 
     if (i mod 2 = 1 & s->min().white /= w) then     s := s->including(R.newR(i, w)) ; else     if (i mod 2 = 0 & s->min().white /= w) then (     var r : R ; r := s->last() ;
     s := s->append(R.newR(r.id, w)) ; 
     while (s->size() >= 2) do (     var a : R ; a := s->last() ;
     if (a.white /= s->min().white) then (     s := s->append(a) ; 
     break ) else skip ) ) else skip ; )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
    var p : int ; p := n + 1 ;
    while (not(s->isEmpty())) do (     var r : R ; r := s->last() ;
     if (r.white) then     c := c+(p - r.id) ; else skip ; 
     p := r.id ) ; 
    OclFile["System.out"].println(c) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class trailzero {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long k=sc.nextLong();
    long min=Long.MAX_VALUE ;
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      long p=sc.nextLong();
      sum+=p ;
      if(p<min){
        min=p ;
      }
    }
    System.out.println(sum<k ?-1 : Math.min(min,(sum-k)/n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class trailzero {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var min : long ; min := "9223372036854775807"->toLong() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var p : long ; p := sc.getCurrent()->toLong() ;
     sum := sum+(p) ; 
     if (p < min) then (     min := p ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if sum < k then -1 else Set{min, (sum - k) / n}->min() endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Range {
  public int from,to ;
  public int color ;
  Range(int from,int to,int color){
    this.from=from ;
    this.to=to ;
    this.color=color ;
  }
  @ Override public String toString(){
    return "color: "+color+","+"from "+from+" to "+to ;
  }
}
public class Main {
  Scanner sc ;
  Stack<Range>stack ;
  int n ;
  Main(){
    sc=new Scanner(System.in);
  }
  public static void main(String[] args){
    new Main().run();
  }
  boolean init(){
    n=sc.nextInt();
    if(n==0)return false ;
    stack=new Stack<Range>();
    stack.push(new Range(1,1,0));
    return true ;
  }
  void println(Object s){
    System.out.println(s);
  }
  void run(){
    while(init()){
      int color ;
      for(int i=1 ; i<=n ; i++){
        color=sc.nextInt();
        if(i % 2==1){
          if(stack.peek().color==color){
            stack.peek().to++;
          }
          else {
            stack.push(new Range(i,i+1,color));
          }
        }
        else {
          if(stack.peek().color==color){
            stack.peek().to++;
          }
          else {
            Range r=stack.pop();
            r.color=color ;
            if(stack.empty()){
              r.to++;
              stack.push(r);
            }
            else {
              stack.peek().to=r.to+1 ;
            }
          }
        }
      }
      int count=0 ;
      for(Range r : stack){
        if(r.color==0){
          count+=(r.to-r.from);
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Range {
   attribute from : int;
   attribute color : int;
   static operation newRange( from : int, to : int, color : int) : Range
  pre: true
  post: true
  activity:
  ( var self : Range ;
    self := createRange();
    self.initialise(from, to,color);
    return self );
  operation initialise( from : int, to : int, color : int) : void
  pre: true  post: true
  activity: (     self.from := from ; 
     self.to := to ; 
     self.color := color );
      operation toString() : String
  pre: true
  post: true
  activity: (     return "color: " + color + "," + "from " + from + " to " + to );
}
class Main {
   attribute sc : OclFile;
   attribute stack : Sequence(Range);
   attribute n : int;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation init() : boolean
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     return false else skip ; 
    stack := Sequence{} ; 
    stack := stack->append(Range.newRange(1, 1, 0)) ; 
    return true 
 );
   operation println( s : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
   operation run() : void
  pre: true
  post: true
  activity: (     while (init()) do (     var color : int ;
         var i : int ; i := 1 ; while i <= n do ( (     color := sc.getCurrent()->toInteger() ; 
     if (i mod 2 = 1) then (     if (stack->min().color = color) then (     stack->min().to := stack->min().to + 1 ) else (     stack := stack->append(Range.newRange(i, i + 1, color)) ) ) else (     if (stack->min().color = color) then (     stack->min().to := stack->min().to + 1 ) else (     var r : Range ; r := stack->last() ;
     r.color := color ; 
     if (stack->isEmpty()) then (     r.to := r.to + 1 ; 
     stack := stack->append(r) ) else (     stack->min().to := r.to + 1 ) ) ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    for (r : stack) do ( (     if (r.color = 0) then (     count := count+((r.to - r.from)) ) else skip )  ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      LinkedList<Integer>list=new LinkedList<Integer>();
      for(int i=1 ; i<=n ; i++){
        int c=sc.nextInt()*2-1 ;
        int d=0 ;
        if(! list.isEmpty()){
          d=list.pop();
        }
        if(c*d>=0){
          list.push(c+d);
        }
        else {
          if(i % 2==1){
            list.push(d);
            list.push(c);
          }
          else {
            int e=0 ;
            if(! list.isEmpty()){
              e=list.pop();
            }
            list.push((abs(e)+abs(d)+abs(c))*c);
          }
        }
      }
      int ans=0 ;
      for(int c : list){
        if(c<0){
          ans-=c ;
        }
      }
      println(ans+"");
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 1 ; while i <= n do ( (     var c : int ; c := sc.getCurrent()->toInteger() * 2 - 1 ;
     var d : int ; d := 0 ;
     if (not(list->isEmpty())) then (     d := list->last() ;     list := list->front() ) else skip ; 
     if (c * d >= 0) then (     list := list->append(c + d) ) else (     if (i mod 2 = 1) then (     list := list->append(d) ; 
     list := list->append(c) ) else (     var e : int ; e := 0 ;
     if (not(list->isEmpty())) then (     e := list->last() ;     list := list->front() ) else skip ; 
     list := list->append((abs(e) + abs(d) + abs(c)) * c) ) ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (c : list) do ( (     if (c < 0) then (     ans := ans-(c) ) else skip )  ) ; 
    execute println(ans + "") ; 
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char s[]=new char[6];
    s=sc.next().toCharArray();
    int sum1=0,sum2=0 ;
    for(int i=0 ; i<6 ; i++){
      if(i<3)sum1+=s[i]-'0' ;
      else sum2+=s[i]-'0' ;
    }
    if(sum1>sum2){
      for(int i=0 ; i<3 ; i++){
        char ch=s[i+3];
        s[i+3]=s[i];
        s[i]=ch ;
      }
    }
    for(int i=0 ; i<3 ; i++){
      s[i]=(char)((9-(s[i]-'0'))+'0');
    }
    Arrays.sort(s);
    int dif=Math.abs(sum1-sum2),x=5,ans=0 ;
    while(dif>0){
      ans++;
      dif-=s[x]-'0' ;
      x--;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := Integer.subrange(1,6)->collect(0) ;
    s := sc.getCurrent()->characters() ; 
    var sum1 : int ; sum1 := 0 ;
    var sum2 : int ; sum2 := 0 ;
        var i : int ; i := 0 ; while i < 6 do ( (     if (i < 3) then     sum1 := sum1+(s[i+1] - ('0')->char2byte()) ; else     sum2 := sum2+(s[i+1] - ('0')->char2byte()) ; )  ;     i := i + 1 ) ; 
    if (sum1 > sum2) then (         var i : int ; i := 0 ; while i < 3 do ( (     var ch : String ; ch := s[i + 3+1] ;
     s[i + 3+1] := s[i+1] ; 
     s[i+1] := ch )  ;     i := i + 1 ) ) else skip ; 
        var i : int ; i := 0 ; while i < 3 do ( (     s[i+1] := ((9 - (s[i+1] - ('0')->char2byte())) + '0')->oclAsType(String) )  ;     i := i + 1 ) ; 
    s := s->sort() ; 
    var dif : int ; dif := if (sum1)->char2byte() - (sum2)->char2byte() < 0 then -((sum1)->char2byte() - (sum2)->char2byte()) else (sum1)->char2byte() - (sum2)->char2byte() endif ;
    var x : int ; x := 5 ;
    var ans : int ; ans := 0 ;
    while (dif > 0) do (     ans := ans + 1 ; 
     dif := dif-(s[x+1] - ('0')->char2byte()) ; 
     x := x - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void positiveNegativeZero(int[] arr){
    int len=arr.length ;
    float positiveCount=0 ;
    float negativeCount=0 ;
    float zeroCount=0 ;
    for(int i=0 ; i<len ; i++){
      if(arr[i]>0){
        positiveCount++;
      }
      else if(arr[i]<0){
        negativeCount++;
      }
      else if(arr[i]==0){
        zeroCount++;
      }
    }
    System.out.printf("%1.4f ",positiveCount/len);
    System.out.printf("%1.4f ",negativeCount/len);
    System.out.printf("%1.4f ",zeroCount/len);
    System.out.println();
  }
  public static void main(String args[]){
    int[] a1={
      2,-1,5,6,0,-3 };
      positiveNegativeZero(a1);
      int[] a2={
        4,0,-2,-9,-7,1 };
        positiveNegativeZero(a2);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation positiveNegativeZero( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var len : int ; len := arr->size() ;
     var positiveCount : double ; positiveCount := 0 ;
    var negativeCount : double ; negativeCount := 0 ;
    var zeroCount : double ; zeroCount := 0 ;
        var i : int ; i := 0 ; while i < len do ( (     if (arr[i+1] > 0) then (     positiveCount := positiveCount + 1 ) else     if (arr[i+1] < 0) then (     negativeCount := negativeCount + 1 ) else     if (arr[i+1] = 0) then (     zeroCount := zeroCount + 1 ) else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%1.4f ", positiveCount / len) ; 
    OclFile["System.out"].printf("%1.4f ", negativeCount / len) ; 
    OclFile["System.out"].printf("%1.4f ", zeroCount / len) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a1 : Sequence(int) ; a1 := Sequence{2,-1,5,6,0,-3} ;
     execute positiveNegativeZero(a1) ; 
     var a2 : Sequence(int) ; a2 := Sequence{4,0,-2,-9,-7,1} ;
     execute positiveNegativeZero(a2) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long t=sc.nextLong();
    long[] a=new long[n];
    long cnt=0 ;
    long min=1000000001 ;
    long max=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
      if(a[i]-min>max){
        max=a[i]-min ;
        cnt=1 ;
      }
      else if(a[i]-min==max){
        cnt++;
      }
      min=Math.min(a[i],min);
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : long ; t := sc.getCurrent()->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var cnt : long ; cnt := 0 ;
    var min : long ; min := 1000000001 ;
    var max : long ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() ; 
     if (a[i+1] - min > max) then (     max := a[i+1] - min ; 
     cnt := 1 ) else     if (a[i+1] - min = max) then (     cnt := cnt + 1 ) else skip ; ;  
     min := Set{a[i+1], min}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  BufferedReader br ;
  PrintWriter out ;
  StringTokenizer st ;
  boolean eof ;
  void solve()throws IOException {
    int n=nextInt();
    int t=nextInt();
    int[] a=new int[n];
    int minPref=Integer.MAX_VALUE ;
    int maxProfit=0 ;
    int[] profitHere=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=nextInt();
      profitHere[i]=a[i]-minPref ;
      minPref=Math.min(minPref,a[i]);
      maxProfit=Math.max(maxProfit,profitHere[i]);
    }
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(profitHere[i]==maxProfit){
        ans++;
      }
    }
    out.println(ans);
  }
  Main()throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(System.out);
    solve();
    out.close();
  }
  public static void main(String[] args)throws IOException {
    new Main();
  }
  String nextToken(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
        eof=true ;
        return null ;
      }
    }
    return st.nextToken();
  }
  String nextString(){
    try {
      return br.readLine();
    }
    catch(IOException e){
      eof=true ;
      return null ;
    }
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute br : OclFile;
   attribute out : OclFile;
   attribute st : OclIterator;
   attribute eof : boolean;
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var t : int ; t := nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var minPref : int ; minPref := 2147483647 ;
    var maxProfit : int ; maxProfit := 0 ;
    var profitHere : Sequence(int) ; profitHere := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := nextInt() ; 
     profitHere[i+1] := a[i+1] - minPref ; 
     minPref := Set{minPref, a[i+1]}->min() ; 
     maxProfit := Set{maxProfit, profitHere[i+1]}->max() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (profitHere[i+1] = maxProfit) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     execute solve() ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     eof := true ; 
     return null )
 ) ; 
     return st.next() );
   operation nextString() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do (     eof := true ; 
     return null )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static void solve(){
    int n=in.nextInt();
    int t=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    int min=Integer.MAX_VALUE ;
    int d=0 ;
    for(int i=0 ; i<n ; i++){
      min=Math.min(min,a[i]);
      d=Math.max(d,a[i]-min);
    }
    int cnt=0 ;
    HashMap<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      cnt+=map.getOrDefault(a[i]-d,0);
      map.put(a[i],map.getOrDefault(a[i],0)+1);
    }
    out.println(cnt);
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    solve();
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
    var d : int ; d := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     min := Set{min, a[i+1]}->min() ; 
     d := Set{d, a[i+1] - min}->max() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     cnt := cnt+((if map->keys()->contains(a[i+1] - d) then map->at(a[i+1] - d) else 0 endif)) ; 
     map := map->union(Map{a[i+1] |-> (if map->keys()->contains(a[i+1]) then map->at(a[i+1]) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    execute solve() ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int T=sc.nextInt();
    int[] A=new int[N+1];
    for(int i=1 ; i<=N ; i++){
      A[i]=sc.nextInt();
    }
    sc.close();
    A[0]=Integer.MAX_VALUE ;
    int max=0 ;
    int last_min_i=N ;
    int max_start_i=N ;
    int diff_max=0 ;
    int cost=0 ;
    for(int i=N ; i>=0 ; i--){
      if(A[i]>max){
        if(diff_max>0){
          int cost0=0 ;
          int cost1=0 ;
          for(int j=i+1 ; j<=max_start_i ; j++){
            if(A[j]==max && j>=last_min_i){
              cost0++;
            }
            else if(A[j]==max-diff_max){
              if(cost0>cost1){
                cost0=cost1 ;
              }
              cost1++;
            }
          }
          cost+=Math.min(cost0,cost1);
        }
        max=A[i];
        max_start_i=i ;
      }
      else if(A[i]==max){
      }
      else {
        if(max-A[i]==diff_max){
          last_min_i=i ;
        }
        else if(max-A[i]>diff_max){
          diff_max=max-A[i];
          last_min_i=i ;
          cost=0 ;
        }
      }
    }
    System.out.println(cost);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    A[0+1] := 2147483647 ; 
    var max : int ; max := 0 ;
    var last_min_i : int ; last_min_i := N ;
    var max_start_i : int ; max_start_i := N ;
    var diff_max : int ; diff_max := 0 ;
    var cost : int ; cost := 0 ;
        var i : int ; i := N ; while i >= 0 do ( (     if (A[i+1] > max) then (     if (diff_max > 0) then (     var cost0 : int ; cost0 := 0 ;
     var cost1 : int ; cost1 := 0 ;
         var j : int ; j := i + 1 ; while j <= max_start_i do ( (     if (A[j+1] = max & j >= last_min_i) then (     cost0 := cost0 + 1 ) else     if (A[j+1] = max - diff_max) then (     if (cost0 > cost1) then (     cost0 := cost1 ) else skip ; 
     cost1 := cost1 + 1 ) else skip ; )  ;     j := j + 1 ) ; 
     cost := cost+(Set{cost0, cost1}->min()) ) else skip ; 
     max := A[i+1] ; 
     max_start_i := i ) else     if (A[i+1] = max) then skip else (     if (max - A[i+1] = diff_max) then (     last_min_i := i ) else     if (max - A[i+1] > diff_max) then (     diff_max := max - A[i+1] ; 
     last_min_i := i ; 
     cost := 0 ) else skip ; ) ;  )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(cost) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMax(int arr[],int n){
    int res=0 ;
    int i,j ;
    for(i=0 ; i<n ; i++){
      int count=0 ;
      for(j=0 ; j<i ; j++){
        if(arr[j] % arr[i]==0)count+=1 ;
      }
      res=Math.max(count,res);
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      8,1,28,4,2,6,7 };
      int n=arr.length ;
      System.out.println(findMax(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMax( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     var i : int ;
    var j : int ;
         i := 0 ; while i < n do ( (     var count : int ; count := 0 ;
         j := 0 ; while j < i do ( (     if (arr[j+1] mod arr[i+1] = 0) then     count := count+(1) ; else skip )  ;     j := j + 1 ) ; 
     res := Set{count, res}->max() )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,1,28,4,2,6,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMax(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class GFG {
  static void findElements(int arr[],int n){
    Arrays.sort(arr);
    for(int i=0 ; i<n-2 ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String args[]){
    int arr[]={
      2,-6,3,5,1 };
      int n=arr.length ;
      findElements(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findElements( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
         var i : int ; i := 0 ; while i < n - 2 do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,-6,3,5,1} ;
     var n : int ; n := arr->size() ;
     execute findElements(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    long s=in.nextLong(),mn=Long.MAX_VALUE,tot=0L ;
    long arr[]=new long[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextLong();
      tot+=arr[i];
      if(arr[i]<mn){
        mn=arr[i];
      }
    }
    System.out.println(s>tot ?-1 : Math.min(mn,(tot-s)/n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : long ; s := in.getCurrent()->toLong() ;
    var mn : long ; mn := "9223372036854775807"->toLong() ;
    var tot : long ; tot := 0L ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toLong() ; 
     tot := tot+(arr[i+1]) ; 
     if (arr[i+1] < mn) then (     mn := arr[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if s > tot then -1 else Set{mn, (tot - s) / n}->min() endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] $){
    int n=scanner.nextInt();
    int t=scanner.nextInt();
    int[] a=new int[n];
    int[] min=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scanner.nextInt();
      min[i]=i==0 ? a[i] : Math.min(min[i-1],a[i]);
    }
    int ans=0 ;
    int diff=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(diff<a[i]-min[i]){
        diff=a[i]-min[i];
        ans=1 ;
      }
      else if(diff==a[i]-min[i]){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var min : Sequence(int) ; min := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() ; 
     min[i+1] := if i = 0 then a[i+1] else Set{min[i - 1+1], a[i+1]}->min() endif )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var diff : int ; diff := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (diff < a[i+1] - min[i+1]) then (     diff := a[i+1] - min[i+1] ; 
     ans := 1 ) else     if (diff = a[i+1] - min[i+1]) then (     ans := ans + 1 ) else skip ; )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B496 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    in.next();
    String min=in.next();
    char[] S=min.toCharArray();
    for(int add=0 ; add<10 ; add++){
      for(int start=0 ; start<S.length ; start++){
        StringBuilder sb=new StringBuilder();
        for(int i=start ; i<S.length ; i++){
          sb.append(S[i]);
        }
        for(int i=0 ; i<start ; i++){
          sb.append(S[i]);
        }
        String cand=sb.toString();
        if(cand.compareTo(min)<0){
          min=cand ;
        }
      }
      for(int i=0 ; i<S.length ; i++){
        if(S[i]=='9'){
          S[i]='0' ;
        }
        else {
          S[i]++;
        }
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B496 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var min : String ; min := in.getCurrent() ;
    var S : Sequence(String) ; S := min->characters() ;
        var add : int ; add := 0 ; while add < 10 do ( (         var start : int ; start := 0 ; while start < S->size() do ( (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := start ; while i < S->size() do ( (     sb := sb + StringLib.newString(S[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < start do ( (     sb := sb + StringLib.newString(S[i+1]) )  ;     i := i + 1 ) ; 
    var cand : String ; cand := sb+"" ;
    if (cand->compareTo(min) < 0) then (     min := cand ) else skip ; 
 )  ;     start := start + 1 ) ; 
         var i : int ; i := 0 ; while i < S->size() do ( (     if (S[i+1] = '9') then (     S[i+1] := '0' ) else (     S[i+1] := S[i+1] + 1 ) )  ;     i := i + 1 ) )  ;     add := add + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String minNum(char num[],int k){
    int len=num.length ;
    if(len==0 || k==0){
      String num_str=new String(num);
      return num_str ;
    }
    if(len==1)return "0" ;
    if(num[0]!='1'){
      num[0]='1' ;
      k--;
    }
    int i=1 ;
    while(k>0 && i<len){
      if(num[i]!='0'){
        num[i]='0' ;
        k--;
      }
      i++;
    }
    String num_str=new String(num);
    return num_str ;
  }
  public static void main(String args[]){
    String num="91945" ;
    int k=3 ;
    System.out.println(minNum(num.toCharArray(),k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minNum( num : Sequence(String), k : int) : String
  pre: true
  post: true
  activity: (     var len : int ; len := num->size() ;
     if (len = 0 or k = 0) then (     var num_str : String ; num_str := StringLib.newString(num) ;
     return num_str ) else skip ; 
    if (len = 1) then     return "0" else skip ; 
    if (num[0+1] /= '1') then (     num[0+1] := '1' ; 
     k := k - 1 ) else skip ; 
    var i : int ; i := 1 ;
    while (k > 0 & i < len) do (     if (num[i+1] /= '0') then (     num[i+1] := '0' ; 
     k := k - 1 ) else skip ; 
     i := i + 1 ) ; 
    var num_str : String ; num_str := StringLib.newString(num) ;
    return num_str 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : String ; num := "91945" ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println(minNum(num->characters(), k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float squareRoot(float n){
    float x=n ;
    float y=1 ;
    double e=0.000001 ;
    while(x-y>e){
      x=(x+y)/2 ;
      y=n/x ;
    }
    return x ;
  }
  public static void main(String[] args){
    int n=50 ;
    System.out.printf("Square root of "+n+" is "+squareRoot(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation squareRoot( n : double) : double
  pre: true
  post: true
  activity: (     var x : double ; x := n ;
     var y : double ; y := 1 ;
    var e : double ; e := 0.000001 ;
    while (x - y > e) do (     x := (x + y) / 2 ; 
     y := n / x ) ; 
    return x 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 50 ;
     OclFile["System.out"].printf("Square root of " + n + " is " + squareRoot(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int ans,n ;
  int[] close ;
  private void doit(){
    Scanner sc=new Scanner(System.in);
    HashSet<Integer>init=new HashSet<Integer>();
    init.add(1);
    close=new int[1024];
    Arrays.fill(close,1<<24);
    close[1]=0 ;
    solve(1,0,init);
    while(true){
      n=sc.nextInt();
      if(n==0)break ;
      System.out.println(close[n]);
    }
  }
  private void solve(int now,int step,HashSet<Integer>record){
    if(step==13){
      return ;
    }
    for(int value : record){
      for(int i=-1 ; i<=1 ; i+=2){
        int next=now+value*i ;
        if(next<=0)continue ;
        if(record.contains(next))continue ;
        if(next<1024){
          if(close[next]<step+1){
            continue ;
          }
          close[next]=step+1 ;
        }
        HashSet<Integer>nextr=new HashSet<Integer>(record);
        nextr.add(next);
        solve(next,step+1,nextr);
      }
    }
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute ans : int;
   attribute close : Sequence(int);
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var init : Set(int) ; init := Set{} ;
    init := init->including(1) ; 
    close := Integer.subrange(1,1024)->collect(0) ; 
    close := close->collect((1*(2->pow(24)))->oclAsType(long)) ; 
    close[1+1] := 0 ; 
    execute solve(1, 0, init) ; 
    while (true) do (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
     OclFile["System.out"].println(close[n+1]) ) ; 
 );
   operation solve( now : int, step : int, record : Set(int)) : void
  pre: true
  post: true
  activity: (     if (step = 13) then (     return ) else skip ; 
     for (value : record) do ( (         var i : int ; i := -1 ; while i <= 1 do ( (     var next : int ; next := now + value * i ;
     if (next <= 0) then     continue else skip ; 
    if (record->includes(next)) then     continue else skip ; 
    if (next < 1024) then (     if (close[next+1] < step + 1) then (     continue ) else skip ; 
     close[next+1] := step + 1 ) else skip ; 
    var nextr : Set(int) ; nextr := Set{}->union(record) ;
    nextr := nextr->including(next) ; 
    execute solve(next, step + 1, nextr) ; 
 )  ;     i := i+(2) ) )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int N=100005 ;
  static int mod=1000000007 ;
  static int cnt[]=new int[N];
  static void Divisors(){
    for(int i=1 ; i<N ; i++){
      for(int j=1 ; j*i<N ; j++){
        cnt[i*j]++;
      }
    }
  }
  static int Sumofdivisors(int A,int B,int C){
    int sum=0 ;
    Divisors();
    for(int i=1 ; i<=A ; i++){
      for(int j=1 ; j<=B ; j++){
        for(int k=1 ; k<=C ; k++){
          int x=i*j*k ;
          sum+=cnt[x];
          if(sum>=mod){
            sum-=mod ;
          }
        }
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int A=5,B=6,C=7 ;
    System.out.println(Sumofdivisors(A,B,C));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 100005;
  static   attribute mod : int := 1000000007;
  static   attribute cnt : int := Integer.subrange(1,N)->collect(0);
  static   operation Divisors() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < N do ( (         var j : int ; j := 1 ; while j * i < N do ( (     cnt[i * j+1] := cnt[i * j+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation Sumofdivisors( A : int, B : int, C : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     execute Divisors() ; 
         var i : int ; i := 1 ; while i <= A do ( (         var j : int ; j := 1 ; while j <= B do ( (         var k : int ; k := 1 ; while k <= C do ( (     var x : int ; x := i * j * k ;
     sum := sum+(cnt[x+1]) ; 
     if (sum >= mod) then (     sum := sum-(mod) ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 5 ;
    var B : int ; B := 6 ;
    var C : int ; C := 7 ;
     OclFile["System.out"].println(Sumofdivisors(A, B, C)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAX=32768 ;
  static int[] arr=new int[2*MAX];
  static void gouldSequence(){
    arr[0]=1 ;
    int i=1 ;
    int p=1 ;
    while(i<=MAX){
      int j=0 ;
      while(j<i){
        arr[i+j]=2*arr[j];
        j++;
      }
      i=(1<<p);
      p++;
    }
  }
  static void printSequence(int n){
    for(int i=0 ; i<n ; i++){
      System.out.print(arr[i]+" ");
    }
  }
  public static void main(String[] args){
    gouldSequence();
    int n=16 ;
    printSequence(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 32768;
  static   attribute arr : Sequence(int) := Integer.subrange(1,2 * MAX)->collect(0);
  static   operation gouldSequence() : void
  pre: true
  post: true
  activity: (     arr[0+1] := 1 ; 
     var i : int ; i := 1 ;
     var p : int ; p := 1 ;
     while (i <= MAX) do (     var j : int ; j := 0 ;
     while (j < i) do (     arr[i + j+1] := 2 * arr[j+1] ; 
     j := j + 1 ) ; 
     i := ((1*(2->pow(p)))->oclAsType(long)) ; 
     p := p + 1 ) );
  static   operation printSequence( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute gouldSequence() ; 
     var n : int ; n := 16 ;
     execute printSequence(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findNumber(int n){
    for(int i=n-1 ; i>=0 ; i--){
      int[] count=new int[10];
      int x=i ;
      int count1=0,count2=0 ;
      while(x>0){
        count[x % 10]++;
        x/=10 ;
        count1++;
      }
      for(int j=0 ; j<10 ; j++){
        if(count[j]==1)count2++;
      }
      if(count1==count2)return i ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    int n=8490 ;
    System.out.println(findNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNumber( n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := n - 1 ; while i >= 0 do ( (     var count : Sequence(int) ; count := Integer.subrange(1,10)->collect(0) ;
     var x : int ; x := i ;
    var count1 : int ; count1 := 0 ;
    var count2 : int ; count2 := 0 ;
    while (x > 0) do (     count[x mod 10+1] := count[x mod 10+1] + 1 ; 
     x := x/(10) ; 
     count1 := count1 + 1 ) ; 
        var j : int ; j := 0 ; while j < 10 do ( (     if (count[j+1] = 1) then     count2 := count2 + 1 ; else skip )  ;     j := j + 1 ) ; 
    if (count1 = count2) then     return i else skip ; 
 )  ;     i := i - 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8490 ;
     OclFile["System.out"].println(findNumber(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class B {
  public static void main(String[] args){
    String s=(new Scanner(System.in)).next();
    if(s.substring(0,3).equals("ftp")){
      out.print("ftp://");
      s=s.substring(3);
    }
    else {
      out.print("http://");
      s=s.substring(4);
    }
    int x=s.lastIndexOf("ru");
    out.println(s.substring(0,x)+".ru"+(x==s.length()-2 ? "" : "/"+s.substring(x+2)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := (OclFile.newOclFile_Read(OclFile["System.in"])).next() ;
     if (s.subrange(0+1,3) = "ftp") then (     out.print("ftp://") ; 
     s := s.subrange(3+1,3) ) else (     out.print("http://") ; 
     s := s.subrange(4+1,4) ) ;  
     var x : int ; x := s->lastIndexOf("ru")-1 ;
     out.println(s.subrange(0+1,x) + ".ru" + (if x = s->size() - 2 then "" else "/" + s.subrange(x + 2+1,x + 2) endif)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B_Internet_Address {
  static Scanner sc=new Scanner(System.in);
  public static void main(String...args){
    String str=sc.next();
    String[] mem=new String[str.length()];
    for(int i=0 ; i<str.length(); i++){
      mem[i]=String.valueOf(str.charAt(i));
    }
    StringBuilder protocol=new StringBuilder();
    StringBuilder domain=new StringBuilder();
    StringBuilder context=new StringBuilder();
    StringBuilder ans=new StringBuilder();
    int stage=1 ;
    for(int i=0 ; i<mem.length ; i++){
      if(stage==1){
        protocol.append(mem[i]);
        if(protocol.toString().equals("http")&& stage==1){
          ans.append("http://");
          stage++;
        }
        if(protocol.toString().equals("ftp")&& stage==1){
          ans.append("ftp://");
          stage++;
        }
      }
      if(stage==2){
        domain.append(mem[i]);
        if(domain.toString().endsWith("ru")&& ! domain.substring(1,domain.length()-2).toString().isEmpty()){
          ans.append(domain.substring(1,domain.length()-2)+".ru");
          stage++;
        }
      }
      if(stage==3){
        if(! str.substring(i+1).isEmpty())ans.append("/"+str.substring(i+1));
        break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Internet_Address {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := sc.getCurrent() ;
     var mem : Sequence(String) ; mem := Integer.subrange(1,str->size())->collect(null) ;
        var i : int ; i := 0 ; while i < str->size() do ( (     mem[i+1] := ((str->at(i+1)) + "") )  ;     i := i + 1 ) ; 
    var protocol : String ; protocol := StringLib.newString() ;
    var domain : String ; domain := StringLib.newString() ;
    var context : String ; context := StringLib.newString() ;
    var ans : String ; ans := StringLib.newString() ;
    var stage : int ; stage := 1 ;
        var i : int ; i := 0 ; while i < mem->size() do ( (     if (stage = 1) then (     protocol := protocol + StringLib.newString(mem[i+1]) ; 
     if (protocol+"" = "http" & stage = 1) then (     ans := ans + StringLib.newString("http://") ; 
     stage := stage + 1 ) else skip ; 
     if (protocol+"" = "ftp" & stage = 1) then (     ans := ans + StringLib.newString("ftp://") ; 
     stage := stage + 1 ) else skip ) else skip ; 
     if (stage = 2) then (     domain := domain + StringLib.newString(mem[i+1]) ; 
     if (domain+""->hasSuffix("ru") & not(domain.subrange(1+1,domain->size() - 2)+""->isEmpty())) then (     ans := ans + StringLib.newString(domain.subrange(1+1,domain->size() - 2) + ".ru") ; 
     stage := stage + 1 ) else skip ) else skip ; 
     if (stage = 3) then (     if (not(str.subrange(i + 1+1,i + 1)->isEmpty())) then     ans := ans + StringLib.newString("/" + str.subrange(i + 1+1,i + 1)) ; else skip ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Abuka {
  BufferedReader br ;
  StringTokenizer in ;
  PrintWriter out ;
  public String nextToken()throws IOException {
    while(in==null || ! in.hasMoreTokens()){
      in=new StringTokenizer(br.readLine());
    }
    return in.nextToken();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  public static void main(String[] args)throws IOException {
    new Abuka().run();
  }
  public void solve()throws IOException {
    int n=nextInt();
    long s=nextLong();
    long[] v=new long[n];
    long min=Long.MAX_VALUE ;
    long ts=0 ;
    for(int i=0 ; i<n ; i++){
      v[i]=nextLong();
      min=Math.min(v[i],min);
      ts+=v[i];
    }
    long d=0 ;
    for(int i=0 ; i<n ; i++){
      d+=v[i]-min ;
    }
    if(!(s>ts)){
      if(s<=d){
        out.println(min);
      }
      else {
        long t=min*n ;
        t-=(s-d);
        long k=t/n ;
        out.println(k);
      }
    }
    else {
      out.println("-1");
    }
  }
  public void run(){
    try {
      br=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(System.out);
      solve();
      out.close();
    }
    catch(IOException e){
      e.printStackTrace();
      System.exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Abuka {
   attribute br : OclFile;
   attribute in : OclIterator;
   attribute out : OclFile;
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (in = null or not(in.hasNext())) do (     in := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return in.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Abuka.newAbuka().run() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var s : long ; s := nextLong() ;
    var v : Sequence(long) ; v := Integer.subrange(1,n)->collect(0) ;
    var min : long ; min := "9223372036854775807"->toLong() ;
    var ts : long ; ts := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     v[i+1] := nextLong() ; 
     min := Set{v[i+1], min}->min() ; 
     ts := ts+(v[i+1]) )  ;     i := i + 1 ) ; 
    var d : long ; d := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     d := d+(v[i+1] - min) )  ;     i := i + 1 ) ; 
    if (not((s > ts))) then (     if (s <= d) then (     skip ) else (     var t : long ; t := min * n ;
     t := t-((s - d)) ; 
     var k : long ; k := t / n ;
     skip ) ) else (     skip ) ;  
 );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     execute solve() ; 
     skip )   catch (e : IOException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMax(int arr[],int n){
    boolean[] divisible=new boolean[n];
    int res=0 ;
    for(int i=n-1 ; i>0 ; i--){
      if(divisible[i])continue ;
      int cnt=0 ;
      for(int j=0 ; j<i ; j++){
        if((arr[j] % arr[i])==0){
          divisible[j]=true ;
          cnt++;
        }
      }
      res=Math.max(res,cnt);
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      8,1,28,4,2,6,7 };
      int n=arr.length ;
      System.out.println(findMax(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMax( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var divisible : Sequence(boolean) ; divisible := Integer.subrange(1,n)->collect(false) ;
     var res : int ; res := 0 ;
         var i : int ; i := n - 1 ; while i > 0 do ( (     if (divisible[i+1]) then     continue else skip ; 
     var cnt : int ; cnt := 0 ;
         var j : int ; j := 0 ; while j < i do ( (     if ((arr[j+1] mod arr[i+1]) = 0) then (     divisible[j+1] := true ; 
     cnt := cnt + 1 ) else skip )  ;     j := j + 1 ) ; 
     res := Set{res, cnt}->max() )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,1,28,4,2,6,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMax(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Test {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String result="" ;
    int index=s.lastIndexOf("ru");
    if(s.startsWith("http")){
      result+="http://" ;
      for(int i=4 ; i<index ; i++){
        result+=s.charAt(i);
      }
    }
    else {
      result+="ftp://" ;
      for(int i=3 ; i<index ; i++){
        result+=s.charAt(i);
      }
    }
    result+=".ru" ;
    if(index!=s.length()-2){
      result+="/" ;
      for(int i=index+2 ; i<s.length(); i++){
        result+=s.charAt(i);
      }
    }
    System.out.println(result);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var result : String ; result := "" ;
    var index : int ; index := s->lastIndexOf("ru")-1 ;
    if (s->hasPrefix("http")) then (     result := result+("http://") ; 
         var i : int ; i := 4 ; while i < index do ( (     result := result+(s->at(i+1)) )  ;     i := i + 1 ) ) else (     result := result+("ftp://") ; 
         var i : int ; i := 3 ; while i < index do ( (     result := result+(s->at(i+1)) )  ;     i := i + 1 ) ) ;  
    result := result+(".ru") ; 
    if (index /= s->size() - 2) then (     result := result+("/") ; 
         var i : int ; i := index + 2 ; while i < s->size() do ( (     result := result+(s->at(i+1)) )  ;     i := i + 1 ) ) else skip ; 
    OclFile["System.out"].println(result) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B245 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String S=in.next();
    String protocol ;
    if(S.startsWith("http")){
      protocol="http" ;
    }
    else {
      protocol="ftp" ;
    }
    S=S.substring(protocol.length());
    int idx=S.lastIndexOf("ru");
    String domain=S.substring(0,idx);
    String address=protocol+"://"+domain+".ru" ;
    String context=S.substring(idx+2);
    if(! context.isEmpty()){
      address+="/"+context ;
    }
    System.out.println(address);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B245 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := in.getCurrent() ;
    var protocol : String ;
    if (S->hasPrefix("http")) then (     protocol := "http" ) else (     protocol := "ftp" ) ;  
    S := S.subrange(protocol->size()+1,protocol->size()) ; 
    var idx : int ; idx := S->lastIndexOf("ru")-1 ;
    var domain : String ; domain := S.subrange(0+1,idx) ;
    var address : String ; address := protocol + "://" + domain + ".ru" ;
    var context : String ; context := S.subrange(idx + 2+1,idx + 2) ;
    if (not(context->isEmpty())) then (     address := address+("/" + context) ) else skip ; 
    OclFile["System.out"].println(address) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class b {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] perim=new int[n];
    int[] height=new int[n];
    for(int i=0 ; i<n ; i++){
      perim[i]+=2*input.nextInt();
      perim[i]+=2*input.nextInt();
      height[i]=input.nextInt();
    }
    int m=input.nextInt();
    int[] length=new int[m];
    int[] width=new int[m];
    int[] price=new int[m];
    for(int i=0 ; i<m ; i++){
      length[i]=input.nextInt();
      width[i]=input.nextInt();
      price[i]=input.nextInt();
    }
    int total=0 ;
    for(int i=0 ; i<n ; i++){
      int min=1000000000 ;
      int mindex=0 ;
      for(int j=0 ; j<m ; j++){
        int area=length[j];
        if(area<height[i])continue ;
        int per=area/height[i];
        per*=width[j];
        int cost=perim[i]/per*price[j];
        if(perim[i] % per!=0)cost+=price[j];
        if(cost<min){
          min=cost ;
          mindex=j ;
        }
      }
      total+=min ;
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var perim : Sequence(int) ; perim := Integer.subrange(1,n)->collect(0) ;
    var height : Sequence(int) ; height := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     perim[i+1] := perim[i+1]+(2 * input.getCurrent()->toInteger()) ; 
     perim[i+1] := perim[i+1]+(2 * input.getCurrent()->toInteger()) ; 
     height[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := input.getCurrent()->toInteger() ;
    var length : Sequence(int) ; length := Integer.subrange(1,m)->collect(0) ;
    var width : Sequence(int) ; width := Integer.subrange(1,m)->collect(0) ;
    var price : Sequence(int) ; price := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     length[i+1] := input.getCurrent()->toInteger() ; 
     width[i+1] := input.getCurrent()->toInteger() ; 
     price[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var min : int ; min := 1000000000 ;
     var mindex : int ; mindex := 0 ;
         var j : int ; j := 0 ; while j < m do ( (     var area : int ; area := length[j+1] ;
     if (area < height[i+1]) then     continue else skip ; 
    var per : int ; per := area / height[i+1] ;
    per := per*(width[j+1]) ; 
    var cost : int ; cost := perim[i+1] / per * price[j+1] ;
    if (perim[i+1] mod per /= 0) then     cost := cost+(price[j+1]) ; else skip ; 
    if (cost < min) then (     min := cost ; 
     mindex := j ) else skip ; 
 )  ;     j := j + 1 ) ; 
     total := total+(min) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF139B {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int[] pp=new int[n];
    int[] hh=new int[n];
    for(int i=0 ; i<n ; i++){
      StringTokenizer st=new StringTokenizer(br.readLine());
      int l=Integer.parseInt(st.nextToken());
      int w=Integer.parseInt(st.nextToken());
      int h=Integer.parseInt(st.nextToken());
      pp[i]=(l+w)*2 ;
      hh[i]=h ;
    }
    int m=Integer.parseInt(br.readLine());
    int[] ll=new int[m];
    int[] ww=new int[m];
    int[] cc=new int[m];
    for(int j=0 ; j<m ; j++){
      StringTokenizer st=new StringTokenizer(br.readLine());
      ll[j]=Integer.parseInt(st.nextToken());
      ww[j]=Integer.parseInt(st.nextToken());
      cc[j]=Integer.parseInt(st.nextToken());
    }
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      int min=Integer.MAX_VALUE ;
      for(int j=0 ; j<m ; j++){
        int t=(pp[i]+ww[j]-1)/ww[j];
        int s=ll[j]/hh[i];
        if(s>0){
          int cost=(t+s-1)/s*cc[j];
          if(min>cost)min=cost ;
        }
      }
      sum+=min ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF139B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var pp : Sequence(int) ; pp := Integer.subrange(1,n)->collect(0) ;
    var hh : Sequence(int) ; hh := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var l : int ; l := (st.next())->toInteger() ;
    var w : int ; w := (st.next())->toInteger() ;
    var h : int ; h := (st.next())->toInteger() ;
    pp[i+1] := (l + w) * 2 ; 
    hh[i+1] := h ; 
 )  ;     i := i + 1 ) ; 
    var m : int ; m := (br.readLine())->toInteger() ;
    var ll : Sequence(int) ; ll := Integer.subrange(1,m)->collect(0) ;
    var ww : Sequence(int) ; ww := Integer.subrange(1,m)->collect(0) ;
    var cc : Sequence(int) ; cc := Integer.subrange(1,m)->collect(0) ;
        var j : int ; j := 0 ; while j < m do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     ll[j+1] := (st.next())->toInteger() ; 
     ww[j+1] := (st.next())->toInteger() ; 
     cc[j+1] := (st.next())->toInteger() )  ;     j := j + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var min : int ; min := 2147483647 ;
         var j : int ; j := 0 ; while j < m do ( (     var t : int ; t := (pp[i+1] + ww[j+1] - 1) / ww[j+1] ;
     var s : int ; s := ll[j+1] / hh[i+1] ;
     if (s > 0) then (     var cost : int ; cost := (t + s - 1) / s * cc[j+1] ;
     if (min > cost) then     min := cost ; else skip ) else skip )  ;     j := j + 1 ) ; 
     sum := sum+(min) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class b {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[] perim=new int[n];
    int[] height=new int[n];
    for(int i=0 ; i<n ; i++){
      perim[i]+=2*input.nextInt();
      perim[i]+=2*input.nextInt();
      height[i]=input.nextInt();
    }
    int m=input.nextInt();
    int[] length=new int[m];
    int[] width=new int[m];
    int[] price=new int[m];
    for(int i=0 ; i<m ; i++){
      length[i]=input.nextInt();
      width[i]=input.nextInt();
      price[i]=input.nextInt();
    }
    int total=0 ;
    for(int i=0 ; i<n ; i++){
      int min=1000000000 ;
      int mindex=0 ;
      for(int j=0 ; j<m ; j++){
        int area=length[j];
        if(area<height[i])continue ;
        int per=area/height[i];
        per*=width[j];
        int cost=perim[i]/per*price[j];
        if(perim[i] % per!=0)cost+=price[j];
        if(cost<min){
          min=cost ;
          mindex=j ;
        }
      }
      total+=min ;
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var perim : Sequence(int) ; perim := Integer.subrange(1,n)->collect(0) ;
    var height : Sequence(int) ; height := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     perim[i+1] := perim[i+1]+(2 * input.getCurrent()->toInteger()) ; 
     perim[i+1] := perim[i+1]+(2 * input.getCurrent()->toInteger()) ; 
     height[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := input.getCurrent()->toInteger() ;
    var length : Sequence(int) ; length := Integer.subrange(1,m)->collect(0) ;
    var width : Sequence(int) ; width := Integer.subrange(1,m)->collect(0) ;
    var price : Sequence(int) ; price := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     length[i+1] := input.getCurrent()->toInteger() ; 
     width[i+1] := input.getCurrent()->toInteger() ; 
     price[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var min : int ; min := 1000000000 ;
     var mindex : int ; mindex := 0 ;
         var j : int ; j := 0 ; while j < m do ( (     var area : int ; area := length[j+1] ;
     if (area < height[i+1]) then     continue else skip ; 
    var per : int ; per := area / height[i+1] ;
    per := per*(width[j+1]) ; 
    var cost : int ; cost := perim[i+1] / per * price[j+1] ;
    if (perim[i+1] mod per /= 0) then     cost := cost+(price[j+1]) ; else skip ; 
    if (cost < min) then (     min := cost ; 
     mindex := j ) else skip ; 
 )  ;     j := j + 1 ) ; 
     total := total+(min) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class vfe {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=in.nextInt();
      }
      boolean raz=false ;
      int a=in.nextInt();
      for(int i=1 ; i<n ; i++){
        int b=in.nextInt();
        if(a!=b){
          raz=true ;
        }
      }
      if(raz){
        System.out.println("YES");
      }
      else {
        raz=true ;
        for(int i=0 ; i<n-1 ; i++){
          if(arr[i]>arr[i+1]){
            raz=false ;
            break ;
          }
        }
        if(raz){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
      out.flush();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class vfe {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var raz : boolean ; raz := false ;
    var a : int ; a := in.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i < n do ( (     var b : int ; b := in.getCurrent()->toInteger() ;
     if (a /= b) then (     raz := true ) else skip )  ;     i := i + 1 ) ; 
    if (raz) then (     OclFile["System.out"].println("YES") ) else (     raz := true ; 
         var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] > arr[i + 1+1]) then (     raz := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (raz) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  
    skip ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int t=0 ; t<test ; t++){
      int n=in.nextInt();
      int a[]=new int[n];
      int b[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      int zc=0,oc=0 ;
      for(int i=0 ; i<n ; i++){
        b[i]=in.nextInt();
        if(b[i]==0){
          zc++;
        }
        else {
          oc++;
        }
      }
      if(isSorted(a)){
        pw.println("Yes");
      }
      else {
        if(zc>=1 && oc>=1){
          pw.println("Yes");
        }
        else {
          pw.println("No");
        }
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
  private static boolean isSorted(int[] arr){
    for(int i=1 ; i<arr.length ; i++)if(arr[i]<arr[i-1])return false ;
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < test do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var zc : int ; zc := 0 ;
    var oc : int ; oc := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := in.getCurrent()->toInteger() ; 
     if (b[i+1] = 0) then (     zc := zc + 1 ) else (     oc := oc + 1 ) )  ;     i := i + 1 ) ; 
    if (isSorted(a)) then (     skip ) else (     if (zc >= 1 & oc >= 1) then (     skip ) else (     skip ) ) ;  
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
  static   operation isSorted( arr : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < arr->size() do (     if (arr[i+1] < arr[i - 1+1]) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static int averageValue(String s){
    int sum_char=0 ;
    for(int i=0 ; i<s.length(); i++){
      sum_char+=(int)s.charAt(i);
    }
    return sum_char/s.length();
  }
  public static void main(String[] args){
    String s="GeeksforGeeks" ;
    System.out.println(averageValue(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation averageValue( s : String) : int
  pre: true
  post: true
  activity: (     var sum_char : int ; sum_char := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     sum_char := sum_char+(s->at(i+1)->oclAsType(int)) )  ;     i := i + 1 ) ; 
     return sum_char / s->size() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "GeeksforGeeks" ;
     OclFile["System.out"].println(averageValue(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
class GfG {
  static int longestSubstring(String s){
    int cnt=1,maxi=1 ;
    int n=s.length();
    for(int i=1 ; i<n ; i++){
      if(s.charAt(i)!=s.charAt(i-1))cnt++;
      else {
        maxi=Math.max(cnt,maxi);
        cnt=1 ;
      }
    }
    maxi=Math.max(cnt,maxi);
    return maxi ;
  }
  public static void main(String[] args){
    String s="ccccdeededff" ;
    System.out.println(longestSubstring(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation longestSubstring( s : String) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 1 ;
    var maxi : int ; maxi := 1 ;
     var n : int ; n := s->size() ;
        var i : int ; i := 1 ; while i < n do ( (     if (s->at(i+1) /= s->at(i - 1+1)) then     cnt := cnt + 1 ; else (     maxi := Set{cnt, maxi}->max() ; 
     cnt := 1 ) )  ;     i := i + 1 ) ; 
    maxi := Set{cnt, maxi}->max() ; 
    return maxi 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "ccccdeededff" ;
     OclFile["System.out"].println(longestSubstring(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class pair {
    int first,second ;
    public pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static boolean checkconv(int a[],int b[],int n){
    int[] c=new int[n];
    int flag=0 ;
    for(int i=0 ; i<n ; i++){
      c[i]=b[i]-a[i];
    }
    Vector<pair>idxs=new Vector<pair>();
    for(int i=0 ; i<n ; i++){
      if(c[i]!=0)idxs.add(new pair(i,c[i]));
    }
    for(int i=0 ; i<idxs.size()-1 ; i++){
      if(idxs.get(i+1).first-idxs.get(i).first!=1 || idxs.get(i+1).second!=idxs.get(i).second){
        flag=1 ;
        break ;
      }
    }
    return flag==1 ? false : true ;
  }
  static int diffofarrays(int a[],int b[],int n){
    int[] c=new int[n];
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      c[i]=b[i]-a[i];
    }
    for(int i=0 ; i<n ; i++){
      if(c[i]!=0){
        ans=c[i];
        break ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int A[]={
      3,7,1,4,0,2,2 };
      int B[]={
        3,7,3,6,2,2,2 };
        int arr_size=A.length ;
        if(checkconv(A,B,arr_size)){
          System.out.print(diffofarrays(A,B,arr_size)+"\n");
        }
        else System.out.print("NA"+"\n");
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class pair {
   attribute first : int;
   static operation newpair( first : int, second : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation checkconv( a : Sequence(int), b : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
     var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := b[i+1] - a[i+1] )  ;     i := i + 1 ) ; 
    var idxs : Sequence(pair) ; idxs := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (c[i+1] /= 0) then     idxs := idxs->including(pair.newpair(i, c[i+1])) ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < idxs->size() - 1 do ( (     if (idxs->at(i + 1+1)->at("first") - idxs->at(i+1)->at("first") /= 1 or idxs->at(i + 1+1)->at("second") /= idxs->at(i+1)->at("second")) then (     flag := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    return if flag = 1 then false else true endif 
 );
  static   operation diffofarrays( a : Sequence(int), b : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
     var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := b[i+1] - a[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (c[i+1] /= 0) then (     ans := c[i+1] ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{3,7,1,4,0,2,2} ;
     var B : Sequence(int) ; B := Sequence{3,7,3,6,2,2,2} ;
     var arr_size : int ; arr_size := A->size() ;
     if (checkconv(A, B, arr_size)) then (     OclFile["System.out"].print(diffofarrays(A, B, arr_size) + "\n") ) else     OclFile["System.out"].print("NA" + "\n") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1343 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      if(((n/2)& 1)==1){
        System.out.println("NO");
        continue ;
      }
      System.out.println("YES");
      int[] ans=new int[n];
      int half=n/2 ;
      for(int i=0 ; i<half ; i++){
        ans[i]=2*(i+1);
        ans[i+half]=ans[i]-1 ;
      }
      ans[n-1]+=half ;
      for(int i=0 ; i<n-1 ; i++){
        System.out.print(ans[i]+" ");
      }
      System.out.println(ans[n-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1343 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (((n / 2) & 1) = 1) then (     OclFile["System.out"].println("NO") ; 
     continue ) else skip ; 
    OclFile["System.out"].println("YES") ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
    var half : int ; half := n / 2 ;
        var i : int ; i := 0 ; while i < half do ( (     ans[i+1] := 2 * (i + 1) ; 
     ans[i + half+1] := ans[i+1] - 1 )  ;     i := i + 1 ) ; 
    ans[n - 1+1] := ans[n - 1+1]+(half) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     OclFile["System.out"].print(ans[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans[n - 1+1]) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int X=Integer.parseInt(sc.next());
    int ans=1 ;
    for(int i=2 ; i<32 ; i++){
      int b=i ;
      for(int p=2 ; p<10 ; p++){
        b*=i ;
        if(b<=X){
          ans=Math.max(ans,b);
        }
        else {
          break ;
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : int ; X := (sc.getCurrent())->toInteger() ;
    var ans : int ; ans := 1 ;
        var i : int ; i := 2 ; while i < 32 do ( (     var b : int ; b := i ;
         var p : int ; p := 2 ; while p < 10 do ( (     b := b*(i) ; 
     if (b <= X) then (     ans := Set{ans, b}->max() ) else (     break ) )  ;     p := p + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ABC097B solver=new ABC097B();
    solver.solve(1,in,out);
    out.close();
  }
  static class ABC097B {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int X=in.nextInt();
      boolean[] b=new boolean[X+1];
      b[1]=true ;
      for(int c=2 ; c<=X ; c++){
        int v=c*c ;
        while(v<=X){
          b[v]=true ;
          v*=c ;
        }
      }
      for(int i=X ; i>=1 ; i--){
        if(b[i]){
          out.println(i);
          return ;
        }
      }
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ABC097B ; solver := ABC097B.newABC097B() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ABC097B {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var X : int ; X := in.getCurrent()->toInteger() ;
     var b : Sequence(boolean) ; b := Integer.subrange(1,X + 1)->collect(false) ;
    b[1+1] := true ; 
        var c : int ; c := 2 ; while c <= X do ( (     var v : int ; v := c * c ;
     while (v <= X) do (     b[v+1] := true ; 
     v := v*(c) ) )  ;     c := c + 1 ) ; 
        var i : int ; i := X ; while i >= 1 do ( (     if (b[i+1]) then (     skip ; 
     return ) else skip )  ;     i := i - 1 ) ; 
    return 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] num={
      1,4,8,16,32,64,128,256,512,9,27,81,243,729,16,64,256,1024,25,125,625,36,216,49,343,64,512,81,729,100,1000,121,144,169,196,225,256,289,324,361,400,441,484,529,576,625,676,729,784,841,900,961 };
      Arrays.sort(num);
      int X=sc.nextInt();
      int max=-1 ;
      for(int i=num.length ; i>0 ; i--){
        int n=num[i-1];
        if(n<=X){
          max=Math.max(max,n);
          break ;
        }
      }
      System.out.println(max);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : Sequence(int) ; num := Sequence{1,4,8,16,32,64,128,256,512,9,27,81,243,729,16,64,256,1024,25,125,625,36,216,49,343,64,512,81,729,100,1000,121,144,169,196,225,256,289,324,361,400,441,484,529,576,625,676,729,784,841,900,961} ;
    num := num->sort() ; 
    var X : int ; X := sc.getCurrent()->toInteger() ;
    var max : int ; max := -1 ;
        var i : int ; i := num->size() ; while i > 0 do ( (     var n : int ; n := num[i - 1+1] ;
     if (n <= X) then (     max := Set{max, n}->max() ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import static java.lang.StrictMath.abs ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    double[] ans=new double[331];
    ans[0]=0 ;
    double a=0 ;
    double b=0 ;
    for(double i=1 ; i<33 ; i++){
      for(double k=2 ; k<10 ; k++){
        a=Math.pow(i,k);
        if(a<=x && x-a<x-b){
          b=a ;
        }
      }
    }
    System.out.println((int)b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var ans : Sequence(double) ; ans := Integer.subrange(1,331)->collect(0.0) ;
    ans[0+1] := 0 ; 
    var a : double ; a := 0 ;
    var b : double ; b := 0 ;
        var i : double ; i := 1 ; while i < 33 do ( (         var k : double ; k := 2 ; while k < 10 do ( (     a := i->pow(k) ; 
     if (a <= x & x - a < x - b) then (     b := a ) else skip )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(b->oclAsType(int)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in))){
      final String s=reader.readLine();
      int X=Integer.parseInt(s);
      int e=1 ;
      if(X==1)e=X ;
      else {
        for(int i=2 ; i<=X ; i++){
          for(int j=2 ; j<=X ; j++){
            if(X<Math.pow(i,j))break ;
            if(e<(int)Math.pow(i,j))e=(int)Math.pow(i,j);
          }
        }
      }
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var s : String ; s := reader.readLine() ;
     var X : int ; X := (s)->toInteger() ;
    var e : int ; e := 1 ;
    if (X = 1) then     e := X else (         var i : int ; i := 2 ; while i <= X do ( (         var j : int ; j := 2 ; while j <= X do ( (     if (X < i->pow(j)) then     break else skip ; 
     if (e < i->pow(j)->oclAsType(int)) then     e := i->pow(j)->oclAsType(int) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(e) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Stack ;
import java.util.StringTokenizer ;
public class AC {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    long a=fs.nextLong(),b=fs.nextLong();
    long ans=0 ;
    while(b!=0){
      ans+=a/b ;
      a=a % b ;
      long temp=a ;
      a=b ;
      b=temp ;
    }
    System.out.println(ans);
  }
  static class Pair {
    int x ;
    int y ;
    public Pair(int x,int y){
      this.x=x ;
      this.y=y ;
    }
    public int getX(){
      return this.x ;
    }
    public int getY(){
      return this.y ;
    }
  }
  static void sort(int[] a){
    ArrayList<Integer>l=new ArrayList<>();
    for(int i : a)l.add(i);
    Collections.sort(l);
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AC {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var a : long ; a := fs.nextLong() ;
    var b : long ; b := fs.nextLong() ;
    var ans : long ; ans := 0 ;
    while (b /= 0) do (     ans := ans+(a / b) ; 
     a := a mod b ; 
    var temp : long ; temp := a ;
    a := b ; 
    b := temp ; 
 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class Pair {
   attribute x : int;
   attribute y : int;
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation getX() : int
  pre: true
  post: true
  activity: (     return self.x );
   operation getY() : int
  pre: true
  post: true
  activity: (     return self.y );
}
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l := l->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Stack ;
import java.util.StringTokenizer ;
public class AC {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    long a=fs.nextLong(),b=fs.nextLong();
    long ans=0 ;
    while(b!=0){
      ans+=a/b ;
      a=a % b ;
      long temp=a ;
      a=b ;
      b=temp ;
    }
    System.out.println(ans);
  }
  static class Pair {
    int x ;
    int y ;
    public Pair(int x,int y){
      this.x=x ;
      this.y=y ;
    }
    public int getX(){
      return this.x ;
    }
    public int getY(){
      return this.y ;
    }
  }
  static void sort(int[] a){
    ArrayList<Integer>l=new ArrayList<>();
    for(int i : a)l.add(i);
    Collections.sort(l);
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AC {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var a : long ; a := fs.nextLong() ;
    var b : long ; b := fs.nextLong() ;
    var ans : long ; ans := 0 ;
    while (b /= 0) do (     ans := ans+(a / b) ; 
     a := a mod b ; 
    var temp : long ; temp := a ;
    a := b ; 
    b := temp ; 
 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class Pair {
   attribute x : int;
   attribute y : int;
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation getX() : int
  pre: true
  post: true
  activity: (     return self.x );
   operation getY() : int
  pre: true
  post: true
  activity: (     return self.y );
}
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l := l->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class rationalResistance {
  public static void main(String[] args){
    Kattio io=new Kattio();
    long a=io.nextLong();
    long b=io.nextLong();
    long m=Math.max(a,b);
    long n=Math.min(a,b);
    long total=0L ;
    while(true){
      if(m==0 || n==0){
        break ;
      }
      total+=(m/n);
      long k=m ;
      long l=n ;
      n=k % l ;
      m=l ;
    }
    io.println(total);
    io.close();
  }
  static class Kattio extends PrintWriter {
    private BufferedReader r ;
    private StringTokenizer st ;
    public Kattio(){
      this(System.in,System.out);
    }
    public Kattio(InputStream i,OutputStream o){
      super(o);
      r=new BufferedReader(new InputStreamReader(i));
    }
    public Kattio(String problemName)throws IOException {
      super(problemName+".out");
      r=new BufferedReader(new FileReader(problemName+".in"));
    }
    public String next(){
      try {
        while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(r.readLine());
        return st.nextToken();
      }
      catch(Exception e){
      }
      return null ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class rationalResistance {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : Kattio ; io := Kattio.newKattio() ;
     var a : long ; a := io.nextLong() ;
    var b : long ; b := io.nextLong() ;
    var m : long ; m := Set{a, b}->max() ;
    var n : long ; n := Set{a, b}->min() ;
    var total : long ; total := 0L ;
    while (true) do (     if (m = 0 or n = 0) then (     break ) else skip ; 
     total := total+((m / n)) ; 
    var k : long ; k := m ;
    var l : long ; l := n ;
    n := k mod l ; 
    m := l ; 
 ) ; 
    io.println(total) ; 
    io.close() ; 
 );
  static class Kattio extends OclFile {
   attribute r : OclFile;
   attribute st : OclIterator;
   static operation newKattio() : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile["System.in"], OclFile["System.out"]) );
   static operation newKattio( i : OclFile, o : OclFile) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(i, o);
    return self );
  operation initialise( i : OclFile, o : OclFile) : void
  pre: true  post: true
  activity: (     execute super(o) ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(i)) );
   static operation newKattio( problemName : String) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(problemName);
    return self );
  operation initialise( problemName : String) : void
  pre: true  post: true
  activity: (     execute super(problemName + ".out") ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(problemName + ".in")) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(r.readLine()) ; ; 
     return st.next() )   catch (e : ProgramException) do skip
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.run();
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    long k=sc.nextLong();
    int n=50 ;
    long sum=k/n ;
    long amari=k % n ;
    long a[]=new long[50];
    for(int i=0 ; i<n ; i++){
      a[i]=i+sum ;
    }
    for(int i=0 ; i<amari ; i++){
      a[n-1-i]++;
    }
    System.out.println(n);
    for(int i=0 ; i<n ; i++){
      System.out.print(a[i]+(i==n-1 ? "\n" : " "));
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : long ; k := sc.getCurrent()->toLong() ;
    var n : int ; n := 50 ;
    var sum : long ; sum := k / n ;
    var amari : long ; amari := k mod n ;
    var a : Sequence(long) ; a := Integer.subrange(1,50)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := i + sum )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < amari do ( (     a[n - 1 - i+1] := a[n - 1 - i+1] + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(a[i+1] + (if i = n - 1 then "\n" else " " endif)) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Eevee {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int length=sc.nextInt();
    String answer="" ;
    if(length==6){
      System.out.print("espeon");
    }
    else if(length==8){
      System.out.print("vaporeon");
    }
    String puzzle=sc.next();
    String[] arr={
      "jolteon","flareon","umbreon","leafeon","glaceon","sylveon" };
      for(int i=0 ; i<length-3 ; i++){
        for(int e=0 ; e<arr.length ; e++){
          if(puzzle.charAt(i)==arr[e] .charAt(i)){
            answer=arr[e];
            break ;
          }
        }
      }
      System.out.print(answer);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Eevee {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var length : int ; length := sc.getCurrent()->toInteger() ;
    var answer : String ; answer := "" ;
    if (length = 6) then (     OclFile["System.out"].print("espeon") ) else     if (length = 8) then (     OclFile["System.out"].print("vaporeon") ) else skip ; ;  
    var puzzle : String ; puzzle := sc.getCurrent() ;
    var arr : Sequence(String) ; arr := Sequence{"jolteon","flareon","umbreon","leafeon","glaceon","sylveon"} ;
        var i : int ; i := 0 ; while i < length - 3 do ( (         var e : int ; e := 0 ; while e < arr->size() do ( (     if (puzzle->at(i+1) = arr[e+1]->at(i+1)) then (     answer := arr[e+1] ; 
     break ) else skip )  ;     e := e + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class problems {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int testCases=input.nextInt();
    for(int i=0 ; i<testCases ; i++){
      int n=input.nextInt();
      int sum=2,sum2=1 ;
      if(n % 4!=0){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
        for(int j=1 ; j<=n/2 ; j+=1){
          System.out.print(sum+" ");
          sum+=2 ;
        }
        sum-=2 ;
        for(int j=1 ; j<n/2 ; j+=1){
          System.out.print(sum2+" ");
          sum2+=2 ;
        }
        if(n % 4==0){
          System.out.println(sum+n/2-1);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class problems {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := input.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < testCases do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var sum : int ; sum := 2 ;
    var sum2 : int ; sum2 := 1 ;
     if (n mod 4 /= 0) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ; 
         var j : int ; j := 1 ; while j <= n / 2 do ( (     OclFile["System.out"].print(sum + " ") ; 
     sum := sum+(2) )  ;     j := j+(1) ) ; 
    sum := sum-(2) ; 
        var j : int ; j := 1 ; while j < n / 2 do ( (     OclFile["System.out"].print(sum2 + " ") ; 
     sum2 := sum2+(2) )  ;     j := j+(1) ) ; 
    if (n mod 4 = 0) then (     OclFile["System.out"].println(sum + n / 2 - 1) ) else skip ; 
 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Eevee {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String s=in.next();
    s=s.toLowerCase();
    String[] a={
      "vaporeon","jolteon","flareon","espeon","umbreon","leafeon","glaceon","sylveon" };
      for(int i=0 ; i<a.length ; i++){
        boolean pp=s.length()==a[i] .length();
        for(int j=0 ; j<s.length()&& pp ; j++){
          if(s.charAt(j)!=a[i] .charAt(j)&& s.charAt(j)!='.'){
            pp=false ;
            break ;
          }
        }
        if(pp){
          System.out.println(a[i]);
          return ;
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Eevee {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    s := s->toLowerCase() ; 
    var a : Sequence(String) ; a := Sequence{"vaporeon","jolteon","flareon","espeon","umbreon","leafeon","glaceon","sylveon"} ;
        var i : int ; i := 0 ; while i < a->size() do ( (     var pp : boolean ; pp := s->size() = a[i+1]->size() ;
         var j : int ; j := 0 ; while j < s->size() & pp do ( (     if (s->at(j+1) /= a[i+1]->at(j+1) & s->at(j+1) /= '.') then (     pp := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (pp) then (     OclFile["System.out"].println(a[i+1]) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    String s=input.next();
    char[] ch=s.toCharArray();
    String[] x={
      "vaporeon","jolteon","flareon","espeon","umbreon","leafeon","glaceon","sylveon",};
      int i ;
      int j ;
      char[] ch1 ;
      for(i=0 ; i<8 ; i++){
        if(x[i] .length()==n){
          ch1=x[i] .toCharArray();
          for(j=0 ; j<n ; j++){
            if(ch[j]!='.'){
              if(ch[j]!=ch1[j]){
                break ;
              }
            }
          }
          if(j>=n){
            System.out.println(x[i]);
            break ;
          }
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var s : String ; s := input.getCurrent() ;
    var ch : Sequence(String) ; ch := s->characters() ;
    var x : Sequence(String) ; x := Sequence{"vaporeon","jolteon","flareon","espeon","umbreon","leafeon","glaceon","sylveon",} ;
    var i : int ;
    var j : int ;
    var ch1 : Sequence(String) ;
        i := 0 ; while i < 8 do ( (     if (x[i+1]->size() = n) then (     ch1 := x[i+1]->characters() ; 
         j := 0 ; while j < n do ( (     if (ch[j+1] /= '.') then (     if (ch[j+1] /= ch1[j+1]) then (     break ) else skip ) else skip )  ;     j := j + 1 ) ; 
     if (j >= n) then (     OclFile["System.out"].println(x[i+1]) ; 
     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void block(long x){
    ArrayList<Integer>v=new ArrayList<Integer>();
    System.out.print("Blocks for "+x+" : ");
    while(x>0){
      v.add((int)x % 2);
      x=x/2 ;
    }
    for(int i=0 ; i<v.size(); i++){
      if(v.get(i)==1){
        System.out.print(i);
        if(i!=v.size()-1)System.out.print(",");
      }
    }
    System.out.println();
  }
  public static void main(String args[]){
    block(71307);
    block(1213);
    block(29);
    block(100);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation block( x : long) : void
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Sequence{} ;
     OclFile["System.out"].print("Blocks for " + x + " : ") ; 
    while (x > 0) do (     v := v->including(x->oclAsType(int) mod 2) ; 
     x := x / 2 ) ; 
        var i : int ; i := 0 ; while i < v->size() do ( (     if (v->at(i+1) = 1) then (     OclFile["System.out"].print(i) ; 
     if (i /= v->size() - 1) then     OclFile["System.out"].print(",") ; else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute block(71307) ; 
     execute block(1213) ; 
     execute block(29) ; 
     execute block(100) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean doesContainB(int a,int b,int c){
    if(a==b){
      return true ;
    }
    if((b-a)*c>0 &&(b-a)% c==0){
      return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    int a=1,b=7,c=3 ;
    if(doesContainB(a,b,c)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation doesContainB( a : int, b : int, c : int) : boolean
  pre: true
  post: true
  activity: (     if (a = b) then (     return true ) else skip ; 
     if ((b - a) * c > 0 & (b - a) mod c = 0) then (     return true ) else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 1 ;
    var b : int ; b := 7 ;
    var c : int ; c := 3 ;
     if (doesContainB(a, b, c)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isRectangle(int a,int b,int c,int d){
    if((a ^ b ^ c ^ d)!=0)return false ;
    else return true ;
  }
  public static void main(String[] args){
    int a,b,c,d ;
    a=3 ;
    b=2 ;
    c=3 ;
    d=2 ;
    if(isRectangle(a,b,c,d))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isRectangle( a : int, b : int, c : int, d : int) : boolean
  pre: true
  post: true
  activity: (     if ((a xor b xor c xor d) /= 0) then     return false else     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ;
    var b : int ;
    var c : int ;
    var d : int ;
     a := 3 ; 
    b := 2 ; 
    c := 3 ; 
    d := 2 ; 
    if (isRectangle(a, b, c, d)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static Scanner in ;
  public static void main(String[] args){
    in=new Scanner(System.in);
    int n=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    long[] pre=new long[n];
    int MOD=(int)1e9+7 ;
    for(int i=0 ; i<n ; i++){
      pre[i]=((i-1>=0 ? pre[i-1] : 0)+a[i])% MOD ;
    }
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      long val=(pre[n-1]-pre[i]+MOD)% MOD ;
      ans=(ans+(a[i]*val)% MOD)% MOD ;
      ans %=MOD ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var pre : Sequence(long) ; pre := Integer.subrange(1,n)->collect(0) ;
    var MOD : int ; MOD := 1e9->oclAsType(int) + 7 ;
        var i : int ; i := 0 ; while i < n do ( (     pre[i+1] := ((if i - 1 >= 0 then pre[i - 1+1] else 0 endif) + a[i+1]) mod MOD )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var val : long ; val := (pre[n - 1+1] - pre[i+1] + MOD) mod MOD ;
     ans := (ans + (a[i+1] * val) mod MOD) mod MOD ; 
     ans := ans mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    solve(in,out);
    out.close();
  }
  static void solve(FastScanner in,PrintWriter out){
    int n=in.nextInt();
    long ans=0 ;
    long a[]=new long[n];
    long sum[]=new long[n];
    long s=0 ;
    int M=1_000_000_000+7 ;
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextLong();
      s+=a[i];
      sum[i]=s ;
    }
    for(int i=0 ; i<n ; i++){
      ans=(ans+(((sum[n-1]-sum[i])% M)*a[i])% M)% M ;
    }
    out.println(ans);
  }
  static void sort(int[] a){
    ArrayList<Integer>l=new ArrayList<>();
    for(int i : a)l.add(i);
    Collections.sort(l);
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     execute solve(in, out) ; 
     skip );
  static   operation solve( in : FastScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var ans : long ; ans := 0 ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : Sequence(long) ; sum := Integer.subrange(1,n)->collect(0) ;
    var s : long ; s := 0 ;
    var M : int ; M := 1_000_000_000 + 7 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.nextLong() ; 
     s := s+(a[i+1]) ; 
     sum[i+1] := s )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     ans := (ans + (((sum[n - 1+1] - sum[i+1]) mod M) * a[i+1]) mod M) mod M )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l := l->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.stream.Stream ;
import java.util.stream.LongStream ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    DDecreaseContestantVer solver=new DDecreaseContestantVer();
    solver.solve(1,in,out);
    out.close();
  }
  static class DDecreaseContestantVer {
    private static final int MAX_PILES=50 ;
    public void solve(int testNumber,Scanner in,PrintWriter out){
      out.println(MAX_PILES);
      long k=in.nextLong();
      long m=k % MAX_PILES ;
      k/=MAX_PILES ;
      long[] a=new long[MAX_PILES];
      Arrays.fill(a,MAX_PILES+k-m-1);
      for(int i=0 ; i<m ; i++){
        a[i]+=MAX_PILES+1 ;
      }
      out.println(Arrays.stream(a).mapToObj(Long :: toString).collect(Collectors.joining(" ")));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : DDecreaseContestantVer ; solver := DDecreaseContestantVer.newDDecreaseContestantVer() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class DDecreaseContestantVer {
  static    attribute MAX_PILES : int := 50;
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     skip ; 
     var k : long ; k := in.getCurrent()->toLong() ;
    var m : long ; m := k mod MAX_PILES ;
    k := k/(MAX_PILES) ; 
    var a : Sequence(long) ; a := Integer.subrange(1,MAX_PILES)->collect(0) ;
    a := a->collect(MAX_PILES + k - m - 1) ; 
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := a[i+1]+(MAX_PILES + 1) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    int n=sc.nextInt();
    long[] a=new long[n];
    final long mod=1000000007 ;
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
      sum+=a[i];
    }
    long ans=0 ;
    for(int i=0 ; i<n-1 ; i++){
      sum-=a[i];
      long tmp=a[i]*(sum % mod);
      ans+=tmp % mod ;
      ans %=mod ;
    }
    System.out.println(ans);
  }
  static class MyScanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),1<<15);
    StringTokenizer tokenizer ;
    String next(){
      try {
        while(tokenizer==null || ! tokenizer.hasMoreTokens()){
          tokenizer=new StringTokenizer(reader.readLine());
        }
      }
      catch(IOException ignored){
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var n : int ; n := sc.nextInt() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var mod : long ; mod := 1000000007 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.nextLong() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     sum := sum-(a[i+1]) ; 
     var tmp : long ; tmp := a[i+1] * (sum mod mod) ;
     ans := ans+(tmp mod mod) ; 
     ans := ans mod mod )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class MyScanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (1*(2->pow(15)))->oclAsType(long));
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (ignored : IOException) do skip
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner reader=new Scanner(System.in);
    int n=reader.nextInt(),zeroCount=0 ;
    int[] arr2=new int[n];
    for(int i=0 ; i<n ; i++){
      arr2[i]=reader.nextInt();
      if(arr2[i]==0){
        zeroCount++;
      }
    }
    int[] arr=new int[n-zeroCount];
    if(arr.length<2){
      System.out.println(0);
    }
    else {
      int encountered=0 ;
      for(int i=0 ; i<arr2.length ; i++){
        if(arr2[i]==0){
          encountered++;
        }
        else {
          arr[i-encountered]=arr2[i];
        }
      }
      long ret=0 ;
      BigInteger modThing=new BigInteger(""+((int)Math.pow(10,9)+7));
      BigInteger prev=(new BigInteger(""+arr[arr.length-2])).multiply(new BigInteger(""+arr[arr.length-1]));
      BigInteger fakePrev=new BigInteger("0");
      ret+=prev.mod(modThing).intValue();
      ret %=Math.pow(10,9)+7 ;
      for(int i=arr.length-3 ; i>=0 ; i--){
        BigInteger single=(new BigInteger(""+arr[i])).multiply(new BigInteger(""+arr[i+1]));
        BigInteger newOne=prev.multiply(new BigInteger(""+arr[i])).divide(new BigInteger(""+arr[i+1]));
        prev=single.add(newOne);
        ret+=prev.mod(modThing).intValue();
        ret %=Math.pow(10,9)+7 ;
      }
      System.out.println(ret);
    }
    reader.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := reader.getCurrent()->toInteger() ;
    var zeroCount : int ; zeroCount := 0 ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr2[i+1] := reader.getCurrent()->toInteger() ; 
     if (arr2[i+1] = 0) then (     zeroCount := zeroCount + 1 ) else skip )  ;     i := i + 1 ) ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n - zeroCount)->collect(0) ;
    if (arr->size() < 2) then (     OclFile["System.out"].println(0) ) else (     var encountered : int ; encountered := 0 ;
         var i : int ; i := 0 ; while i < arr2->size() do ( (     if (arr2[i+1] = 0) then (     encountered := encountered + 1 ) else (     arr[i - encountered+1] := arr2[i+1] ) )  ;     i := i + 1 ) ; 
    var ret : long ; ret := 0 ;
    var modThing : long ; modThing := long("" + (10->pow(9)->oclAsType(int) + 7)) ;
    var prev : long ; prev := (long("" + arr[arr->size() - 2+1])).multiply(long("" + arr[arr->size() - 1+1])) ;
    var fakePrev : long ; fakePrev := long("0") ;
    ret := ret+(prev.mod(modThing)->oclAsType(int)) ; 
    ret := ret mod 10->pow(9) + 7 ; 
        var i : int ; i := arr->size() - 3 ; while i >= 0 do ( (     var single : long ; single := (long("" + arr[i+1])).multiply(long("" + arr[i + 1+1])) ;
     var newOne : long ; newOne := prev.multiply(long("" + arr[i+1])).divide(long("" + arr[i + 1+1])) ;
    prev := single->excludes(newOne) ; 
    ret := ret+(prev.mod(modThing)->oclAsType(int)) ; 
    ret := ret mod 10->pow(9) + 7 ; 
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ret) ; 
 ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.Integer.*;
import static java.lang.Long.parseLong ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader read=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter prnt=new PrintWriter(System.out);
    StringTokenizer st ;
    int N=parseInt(read.readLine());
    long[] arr=new long[N];
    st=new StringTokenizer(read.readLine());
    for(int i=0 ; i<N ; i++){
      arr[i]=parseLong(st.nextToken());
    }
    prnt.println(getSum(arr,N));
    prnt.close();
  }
  static long getSum(long[] arr,int N){
    long mod=(long)(1e9+7);
    long Sum=0 ;
    long[] preixSum=new long[N];
    preixSum[0]=arr[0];
    for(int i=1 ; i<N ; i++){
      preixSum[i]+=(preixSum[i-1]+arr[i]);
    }
    for(int i=0 ; i<(N-1); i++){
      Sum+=((arr[i] % mod)*((preixSum[N-1]-preixSum[i])% mod))% mod ;
      Sum %=mod ;
    }
    return Sum % mod ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : OclFile ; read := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var prnt : OclFile ; prnt := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var st : OclIterator ;
    var N : int ; N := parseInt(read.readLine()) ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,N)->collect(0) ;
    st := OclIterator.newOclIterator_String(read.readLine()) ; 
        var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := parseLong(st.next()) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation getSum( arr : Sequence(long), N : int) : long
  pre: true
  post: true
  activity: (     var mod : long ; mod := (1e9 + 7)->oclAsType(long) ;
     var Sum : long ; Sum := 0 ;
    var preixSum : Sequence(long) ; preixSum := Integer.subrange(1,N)->collect(0) ;
    preixSum[0+1] := arr[0+1] ; 
        var i : int ; i := 1 ; while i < N do ( (     preixSum[i+1] := preixSum[i+1]+((preixSum[i - 1+1] + arr[i+1])) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < (N - 1) do ( (     Sum := Sum+(((arr[i+1] mod mod) * ((preixSum[N - 1+1] - preixSum[i+1]) mod mod)) mod mod) ; 
     Sum := Sum mod mod )  ;     i := i + 1 ) ; 
    return Sum mod mod 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class BalancedArray {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      if((n/2)% 2==1){
        System.out.println("No");
      }
      else {
        System.out.println("Yes");
        for(int i=2 ; i<=n ; i+=2){
          System.out.print(i+" ");
        }
        for(int i=1 ; i<=n-3 ; i+=2){
          System.out.print(i+" ");
        }
        System.out.print(n+((n/2)-1));
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BalancedArray {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if ((n / 2) mod 2 = 1) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ; 
         var i : int ; i := 2 ; while i <= n do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i+(2) ) ; 
        var i : int ; i := 1 ; while i <= n - 3 do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i+(2) ) ; 
    OclFile["System.out"].print(n + ((n / 2) - 1)) ; 
    OclFile["System.out"].println() ; 
 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void solution(PrintWriter out)throws IOException {
    int n=in.nextInt(),b=in.nextInt();
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++)nums[i]=in.nextInt();
    int max=nums[0];
    for(int i=1 ; i<n ; i++)max=Math.max(max,nums[i]);
    double[] add=new double[n];
    for(int i=0 ; i<n ; i++){
      int d=max-nums[i];
      b-=d ;
      add[i]=d ;
    }
    if(b<0)out.println(-1);
    else {
      for(int i=0 ; i<n ; i++){
        add[i]+=b*1.0/n ;
        out.printf("%.6f\n",add[i]);
      }
    }
  }
  public static void main(String[] args)throws Exception {
    in.init();
    PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    solution(out);
    out.close();
  }
  protected static class in {
    private static BufferedReader reader ;
    private static StringTokenizer tokenizer ;
    public static void init()throws FileNotFoundException {
      reader=new BufferedReader(new InputStreamReader(System.in));
      tokenizer=new StringTokenizer("");
    }
    public static String next()throws IOException {
      while(! tokenizer.hasMoreTokens())tokenizer=new StringTokenizer(reader.readLine());
      return tokenizer.nextToken();
    }
    public static int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public static double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public static long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation solution( out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
    var b : int ; b := in.nextInt() ;
     var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     nums[i+1] := in.nextInt() ;  ;     i := i + 1 ) ; 
    var max : int ; max := nums[0+1] ;
        var i : int ; i := 1 ; while i < n do (     max := Set{max, nums[i+1]}->max() ;  ;     i := i + 1 ) ; 
    var add : Sequence(double) ; add := Integer.subrange(1,n)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do ( (     var d : int ; d := max - nums[i+1] ;
     b := b-(d) ; 
     add[i+1] := d )  ;     i := i + 1 ) ; 
    if (b < 0) then     out.println(-1) else (         var i : int ; i := 0 ; while i < n do ( (     add[i+1] := add[i+1]+(b * 1.0 / n) ; 
     out.printf("%.6f\n", add[i+1]) )  ;     i := i + 1 ) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in.init() ; 
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
     execute solution(out) ; 
     skip );
   static class in {
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   operation init() : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := OclIterator.newOclIterator_String("") );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ; ; 
     return tokenizer.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
import java.math.*;
public class test {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int b=sc.nextInt();
    int sum=b ;
    int mx=0 ;
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      sum+=arr[i];
      if(arr[i]>mx)mx=arr[i];
    }
    double share=(1.0*sum)/n ;
    if(share<mx)System.out.println("-1");
    else {
      for(int i=0 ; i<n ; i++){
        System.out.println(String.format("%.8f",share-arr[i]));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := b ;
    var mx : int ; mx := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(arr[i+1]) ; 
     if (arr[i+1] > mx) then     mx := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
    var share : double ; share := (1.0 * sum) / n ;
    if (share < mx) then     OclFile["System.out"].println("-1") else (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(StringLib.format("%.8f",Sequence{share - arr[i+1]})) )  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class ProblemAboutEquation {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int b=scan.nextInt();
    double array[]=new double[n];
    double ans[]=new double[n];
    double max=0 ;
    for(int i=0 ; i<n ; i++){
      array[i]=scan.nextInt();
      if(array[i]>max)max=array[i];
    }
    boolean imp=false ;
    for(int i=0 ; i<n ; i++){
      double newNum=max-array[i];
      b-=newNum ;
      if(b>=0){
        array[i]=newNum+array[i];
        ans[i]=newNum ;
      }
      else {
        imp=true ;
        break ;
      }
    }
    if(! imp){
      double div=b/(double)n ;
      for(int i=0 ; i<n ; i++){
        ans[i]+=div ;
        ans[i]=(double)Math.round(ans[i]*1000000d)/1000000d ;
        System.out.println(String.format("%.6f",ans[i]));
      }
    }
    else {
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemAboutEquation {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    var array : Sequence(double) ; array := Integer.subrange(1,n)->collect(0.0) ;
    var ans : Sequence(double) ; ans := Integer.subrange(1,n)->collect(0.0) ;
    var max : double ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := scan.getCurrent()->toInteger() ; 
     if (array[i+1] > max) then     max := array[i+1] ; else skip )  ;     i := i + 1 ) ; 
    var imp : boolean ; imp := false ;
        var i : int ; i := 0 ; while i < n do ( (     var newNum : double ; newNum := max - array[i+1] ;
     b := b-(newNum) ; 
     if (b >= 0) then (     array[i+1] := newNum + array[i+1] ; 
     ans[i+1] := newNum ) else (     imp := true ; 
     break ) )  ;     i := i + 1 ) ; 
    if (not(imp)) then (     var div : double ; div := b / n->oclAsType(double) ;
         var i : int ; i := 0 ; while i < n do ( (     ans[i+1] := ans[i+1]+(div) ; 
     ans[i+1] := (ans[i+1] * 1000000d)->round()->oclAsType(double) / 1000000d ; 
     OclFile["System.out"].println(StringLib.format("%.6f",Sequence{ans[i+1]})) )  ;     i := i + 1 ) ) else (     OclFile["System.out"].println(-1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Vector ;
public class Main {
  static Scanner input=new Scanner(System.in);
  static final double eps=0.000001 ;
  static double n ;
  static double m ;
  static double[] a ;
  static double[] b ;
  static double ans=0 ;
  static Vector<Double>v ;
  static public void main(String[] args){
    n=read();
    m=read();
    boolean chk=false ;
    a=new double[(int)n+2];
    b=new double[(int)n+2];
    for(int i=0 ; i<n ; i++){
      a[i]=read();
      if(a[i]==1)chk=true ;
    }
    for(int i=0 ; i<n ; i++){
      b[i]=read();
      if(b[i]==1)chk=true ;
    }
    if(chk){
      System.out.println(-1);
      return ;
    }
    v=new Vector<Double>(2*(int)n);
    v.add(a[0]);
    for(int i=1 ; i<n ; i++){
      v.add(b[i]);
      v.add(a[i]);
    }
    v.add(b[0]);
    bs(0,10_000_000_000F);
    System.out.println(ans);
  }
  static double read(){
    return input.nextDouble();
  }
  static boolean chk(double f){
    for(double x : v){
      double rq=(m+f)/x ;
      if(f<rq)return false ;
      f-=rq ;
    }
    return true ;
  }
  static void bs(double b,double e){
    if(b<=e-eps){
      double mid=(b+e)/2 ;
      if(chk(mid)){
        ans=mid ;
        bs(b,mid);
      }
      else bs(mid,e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute input : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute eps : double := 0.000001;
  static   attribute n : double;
  static   attribute m : double;
  static   attribute a : Sequence(double);
  static   attribute b : Sequence(double);
  static   attribute ans : double := 0;
  static   attribute v : Sequence(double);
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := read() ; 
     m := read() ; 
    var chk : boolean ; chk := false ;
    a := Integer.subrange(1,n->oclAsType(int) + 2)->collect(0.0) ; 
    b := Integer.subrange(1,n->oclAsType(int) + 2)->collect(0.0) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := read() ; 
     if (a[i+1] = 1) then     chk := true ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := read() ; 
     if (b[i+1] = 1) then     chk := true ; else skip )  ;     i := i + 1 ) ; 
    if (chk) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    v := Sequence{}->union(2 * n->oclAsType(int)) ; 
    v := v->including(a[0+1]) ; 
        var i : int ; i := 1 ; while i < n do ( (     v := v->including(b[i+1]) ; 
     v := v->including(a[i+1]) )  ;     i := i + 1 ) ; 
    v := v->including(b[0+1]) ; 
    execute bs(0, 10_000_000_000F) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation read() : double
  pre: true
  post: true
  activity: (     return input.getCurrent()->toReal() );
  static   operation chk( f : double) : boolean
  pre: true
  post: true
  activity: (     for (x : v) do ( (     var rq : double ; rq := (m + f) / x ;
     if (f < rq) then     return false else skip ; 
     f := f-(rq) )  ) ; 
     return true );
  static   operation bs( b : double, e : double) : void
  pre: true
  post: true
  activity: (     if (b <= e - eps) then (     var mid : double ; mid := (b + e) / 2 ;
     if (chk(mid)) then (     ans := mid ; 
     execute bs(b, mid) ) else     execute bs(mid, e) ; ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Locale ;
import java.util.Scanner ;
public class A1010 {
  public static void main(String[] args){
    Locale.setDefault(Locale.US);
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int M=in.nextInt();
    int[] C=new int[2*N];
    for(int n=0 ; n<N ; n++){
      C[2*n]=in.nextInt();
    }
    C[C.length-1]=in.nextInt();
    for(int n=1 ; n<N ; n++){
      C[2*n-1]=in.nextInt();
    }
    double w=M ;
    boolean possible=true ;
    for(int n=C.length-1 ; n>=0 ; n--){
      int c=C[n];
      if(c==1){
        possible=false ;
        break ;
      }
      w+=w/(c-1);
    }
    if(possible){
      System.out.printf("%.9f\n",w-M);
    }
    else {
      System.out.println("-1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1010 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.US) ; 
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var M : int ; M := in.getCurrent()->toInteger() ;
    var C : Sequence(int) ; C := Integer.subrange(1,2 * N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     C[2 * n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    C[C->size() - 1+1] := in.getCurrent()->toInteger() ; 
        var n : int ; n := 1 ; while n < N do ( (     C[2 * n - 1+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var w : double ; w := M ;
    var possible : boolean ; possible := true ;
        var n : int ; n := C->size() - 1 ; while n >= 0 do ( (     var c : int ; c := C[n+1] ;
     if (c = 1) then (     possible := false ; 
     break ) else skip ; 
     w := w+(w / (c - 1)) )  ;     n := n - 1 ) ; 
    if (possible) then (     OclFile["System.out"].printf("%.9f\n", w - M) ) else (     OclFile["System.out"].println("-1") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String removeDuplicate(char str[],int n){
    int index=0 ;
    for(int i=0 ; i<n ; i++){
      int j ;
      for(j=0 ; j<i ; j++){
        if(str[i]==str[j]){
          break ;
        }
      }
      if(j==i){
        str[index++]=str[i];
      }
    }
    return String.valueOf(Arrays.copyOf(str,index));
  }
  public static void main(String[] args){
    char str[]="geeksforgeeks".toCharArray();
    int n=str.length ;
    System.out.println(removeDuplicate(str,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation removeDuplicate( str : Sequence(String), n : int) : String
  pre: true
  post: true
  activity: (     var index : int ; index := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var j : int ;
         j := 0 ; while j < i do ( (     if (str[i+1] = str[j+1]) then (     break ) else skip )  ;     j := j + 1 ) ; 
     if (j = i) then (      str[index+1] := str[i+1]  ; index := index + 1 ) else skip )  ;     i := i + 1 ) ; 
     return ((str.subrange(1,index)) + "") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := "geeksforgeeks"->characters() ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].println(removeDuplicate(str, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ASerialKiller {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    int n=sc.nextInt();
    String[][] ans=new String[n+1][2];
    for(int i=0 ; i<=n ; i++){
      ans[i]=s.split(" ");
    }
    for(int i=0 ; i<n ; i++){
      String murder=sc.next();
      String replace=sc.next();
      if(ans[i][0] .equalsIgnoreCase(murder)){
        ans[i+1][0]=replace ;
        ans[i+1][1]=ans[i][1];
      }
      else {
        ans[i+1][1]=replace ;
        ans[i+1][0]=ans[i][0];
      }
    }
    for(int i=0 ; i<=n ; i++){
      System.out.println(ans[i][0]+" "+ans[i][1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ASerialKiller {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : Sequence(Sequence(String)) ; ans := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,2)->collect(null)) ;
        var i : int ; i := 0 ; while i <= n do ( (     ans[i+1] := s->split(" ") )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var murder : String ; murder := sc.getCurrent() ;
     var replace : String ; replace := sc.getCurrent() ;
     if (ans[i+1][0+1]->equalsIgnoreCase(murder)) then (     ans[i + 1+1][0+1] := replace ; 
     ans[i + 1+1][1+1] := ans[i+1][1+1] ) else (     ans[i + 1+1][1+1] := replace ; 
     ans[i + 1+1][0+1] := ans[i+1][0+1] ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= n do ( (     OclFile["System.out"].println(ans[i+1][0+1] + " " + ans[i+1][1+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String commonPrefixUtil(String str1,String str2){
    String result="" ;
    int n1=str1.length(),n2=str2.length();
    for(int i=0,j=0 ; i<=n1-1 && j<=n2-1 ; i++,j++){
      if(str1.charAt(i)!=str2.charAt(j)){
        break ;
      }
      result+=str1.charAt(i);
    }
    return(result);
  }
  static String commonPrefix(String arr[],int n){
    String prefix=arr[0];
    for(int i=1 ; i<=n-1 ; i++){
      prefix=commonPrefixUtil(prefix,arr[i]);
    }
    return(prefix);
  }
  public static void main(String[] args){
    String arr[]={
      "geeksforgeeks","geeks","geek","geezer" };
      int n=arr.length ;
      String ans=commonPrefix(arr,n);
      if(ans.length()>0){
        System.out.printf("The longest common prefix is-%s",ans);
      }
      else {
        System.out.printf("There is no common prefix");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation commonPrefixUtil( str1 : String, str2 : String) : String
  pre: true
  post: true
  activity: (     var result : String ; result := "" ;
     var n1 : int ; n1 := str1->size() ;
    var n2 : int ; n2 := str2->size() ;
         var i : int ; i := 0 ;
    var j : int ; j := 0 ; while i <= (n1)->char2byte() - 1 & j <= (n2)->char2byte() - 1 do ( (     if (str1->at(i+1) /= str2->at(j+1)) then (     break ) else skip ; 
     result := result+(str1->at(i+1)) )  ;     i := i + 1 ;     j := j + 1 ) ; 
     return (result) );
  static   operation commonPrefix( arr : Sequence(String), n : int) : String
  pre: true
  post: true
  activity: (     var prefix : String ; prefix := arr[0+1] ;
         var i : int ; i := 1 ; while i <= n - 1 do ( (     prefix := commonPrefixUtil(prefix, arr[i+1]) )  ;     i := i + 1 ) ; 
     return (prefix) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"geeksforgeeks","geeks","geek","geezer"} ;
     var n : int ; n := arr->size() ;
     var ans : String ; ans := commonPrefix(arr, n) ;
     if (ans->size() > 0) then (     OclFile["System.out"].printf("The longest common prefix is-%s", ans) ) else (     OclFile["System.out"].printf("There is no common prefix") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int getRemainder(int num,int divisor){
    if(divisor==0){
      System.out.println("Error: divisor "+"can't be zero \n");
      return-1 ;
    }
    if(divisor<0)divisor=-divisor ;
    if(num<0)num=-num ;
    int i=1 ;
    int product=0 ;
    while(product<=num){
      product=divisor*i ;
      i++;
    }
    return num-(product-divisor);
  }
  public static void main(String[] args){
    System.out.println(getRemainder(100,7));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getRemainder( num : int, divisor : int) : int
  pre: true
  post: true
  activity: (     if (divisor = 0) then (     OclFile["System.out"].println("Error: divisor " + "can't be zero \n") ; 
     return -1 ) else skip ; 
     if (divisor < 0) then     divisor := -divisor ; else skip ; 
    if (num < 0) then     num := -num ; else skip ; 
    var i : int ; i := 1 ;
    var product : int ; product := 0 ;
    while (product <= num) do (     product := divisor * i ; 
     i := i + 1 ) ; 
    return num - (product - divisor) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(getRemainder(100, 7)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  static List<Integer>power=new ArrayList<Integer>();
  static void nextPower(Integer N){
    Integer carry=0 ;
    for(int i=0 ; i<power.size(); i++){
      Integer prod=(power.get(i)*N)+carry ;
      power.set(i,prod % 10);
      carry=prod/10 ;
    }
    while(carry>=1){
      power.add(carry % 10);
      carry=carry/10 ;
    }
  }
  static void printPowerNumber(int X,int N){
    power.add(1);
    List<Integer>res=new ArrayList<Integer>();
    for(int i=1 ; i<=X ; i++){
      nextPower(N);
      res.add(power.get(power.size()-1));
      res.add(power.get(0));
    }
    for(int i=0 ; i<res.size(); i++)System.out.print(res.get(i));
  }
  public static void main(String args[]){
    Integer N=19,X=4 ;
    printPowerNumber(X,N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute power : Sequence(int) := Sequence{};
  static   operation nextPower( N : int) : void
  pre: true
  post: true
  activity: (     var carry : int ; carry := 0 ;
         var i : int ; i := 0 ; while i < power->size() do ( (     var prod : int ; prod := (power->at(i+1) * N) + carry ;
     power := power.setAt(i+1,prod mod 10) ; 
     carry := prod / 10 )  ;     i := i + 1 ) ; 
     while (carry >= 1) do (     power := power->including(carry mod 10) ; 
     carry := carry / 10 ) );
  static   operation printPowerNumber( X : int, N : int) : void
  pre: true
  post: true
  activity: (     power := power->including(1) ; 
     var res : Sequence(int) ; res := Sequence{} ;
         var i : int ; i := 1 ; while i <= X do ( (     execute nextPower(N) ; 
     res := res->including(power->at(power->size() - 1+1)) ; 
     res := res->including(power->at(0+1)) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < res->size() do (     OclFile["System.out"].print(res->at(i+1)) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 19 ;
    var X : int ; X := 4 ;
     execute printPowerNumber(X, N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void CountWords(String str,int k){
    int sum=0 ;
    int NumberOfWords=0 ;
    int counter=0 ;
    int len=str.length();
    for(int i=0 ; i<len ; ++i){
      if(str.charAt(i)==' '){
        if(sum<k){
          counter++;
        }
        sum=0 ;
        NumberOfWords++;
      }
      else {
        sum+=str.charAt(i);
      }
    }
    NumberOfWords++;
    if(sum<k){
      counter++;
    }
    System.out.println("Number of words having sum "+"of ASCII values less than k="+counter);
    System.out.println("Number of words having sum of "+"ASCII values greater than or equal to k="+(NumberOfWords-counter));
  }
  public static void main(String[] args){
    String str="Learn how to code" ;
    int k=400 ;
    CountWords(str,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation CountWords( str : String, k : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var NumberOfWords : int ; NumberOfWords := 0 ;
    var counter : int ; counter := 0 ;
    var len : int ; len := str->size() ;
        var i : int ; i := 0 ; while i < len do ( (     if (str->at(i+1) = ' ') then (     if (sum < k) then (     counter := counter + 1 ) else skip ; 
     sum := 0 ; 
     NumberOfWords := NumberOfWords + 1 ) else (     sum := sum+(str->at(i+1)) ) )  ;     i := i + 1 ) ; 
    NumberOfWords := NumberOfWords + 1 ; 
    if (sum < k) then (     counter := counter + 1 ) else skip ; 
    OclFile["System.out"].println("Number of words having sum " + "of ASCII values less than k=" + counter) ; 
    OclFile["System.out"].println("Number of words having sum of " + "ASCII values greater than or equal to k=" + (NumberOfWords - counter)) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "Learn how to code" ;
     var k : int ; k := 400 ;
     execute CountWords(str, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int[] x=new int[n];
    int[] y=new int[n];
    int xmax=Integer.MIN_VALUE ;
    int ymax=Integer.MIN_VALUE ;
    int xmin=Integer.MAX_VALUE ;
    int ymin=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      x[i]=a-b ;
      y[i]=a+b ;
      xmax=Math.max(xmax,x[i]);
      ymax=Math.max(ymax,y[i]);
      xmin=Math.min(xmin,x[i]);
      ymin=Math.min(ymin,y[i]);
    }
    int ret=0 ;
    int ret2=0 ;
    for(int i=0 ; i<n ; i++){
      ret=Math.max(ret,Math.min(dist(xmax,x[i],ymax,y[i]),dist(x[i],xmin,y[i],ymin)));
      ret2=Math.max(ret2,Math.min(dist(xmax,x[i],y[i],ymin),dist(x[i],xmin,ymax,y[i])));
    }
    System.out.println(Math.min(ret,ret2));
  }
  private int dist(int a,int b,int c,int d){
    return Math.max(a-b,c-d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
    var xmax : int ; xmax := -2147483648 ;
    var ymax : int ; ymax := -2147483648 ;
    var xmin : int ; xmin := 2147483647 ;
    var ymin : int ; ymin := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
    x[i+1] := a - b ; 
    y[i+1] := a + b ; 
    xmax := Set{xmax, x[i+1]}->max() ; 
    ymax := Set{ymax, y[i+1]}->max() ; 
    xmin := Set{xmin, x[i+1]}->min() ; 
    ymin := Set{ymin, y[i+1]}->min() ; 
 )  ;     i := i + 1 ) ; 
    var ret : int ; ret := 0 ;
    var ret2 : int ; ret2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ret := Set{ret, Set{dist(xmax, x[i+1], ymax, y[i+1]), dist(x[i+1], xmin, y[i+1], ymin)}->min()}->max() ; 
     ret2 := Set{ret2, Set{dist(xmax, x[i+1], y[i+1], ymin), dist(x[i+1], xmin, ymax, y[i+1])}->min()}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{ret, ret2}->min()) ; 
 );
   operation dist( a : int, b : int, c : int, d : int) : int
  pre: true
  post: true
  activity: (     return Set{a - b, c - d}->max() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    long totalBlocks=0 ;
    long a[]=new long[n];
    for(int i=0 ; i<n ; ++i){
      a[i]=sc.nextLong();
      totalBlocks+=a[i];
    }
    Arrays.sort(a);
    long selected=0 ;
    for(int i=0 ; i<n ; ++i){
      if(a[i]>selected)selected++;
    }
    long leftCols=a[n-1]-selected ;
    long remBlocks=totalBlocks-leftCols-n ;
    System.out.print(remBlocks);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var totalBlocks : long ; totalBlocks := 0 ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() ; 
     totalBlocks := totalBlocks+(a[i+1]) )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var selected : long ; selected := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] > selected) then     selected := selected + 1 ; else skip )  ;     i := i + 1 ) ; 
    var leftCols : long ; leftCols := a[n - 1+1] - selected ;
    var remBlocks : long ; remBlocks := totalBlocks - leftCols - n ;
    OclFile["System.out"].print(remBlocks) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Random ;
import java.util.concurrent.ThreadLocalRandom ;
public class ViewMatter {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    String[] temp=br.readLine().split(" ");
    int n=Integer.parseInt(temp[0]);
    int m=Integer.parseInt(temp[1]);
    int[] nums=new int[n];
    temp=br.readLine().split(" ");
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      nums[i]=Integer.parseInt(temp[i]);
      sum+=nums[i];
    }
    shuffleArray(nums);
    Arrays.sort(nums);
    long canNotRemove=0 ;
    int currentMaxHeight=nums[n-1];
    for(int i=n-1 ; i>=0 ; i--){
      if(i-1>=0){
        if(currentMaxHeight<=nums[i]){
          canNotRemove++;
          currentMaxHeight--;
        }
        else if(currentMaxHeight>nums[i]){
          canNotRemove+=currentMaxHeight-nums[i]+1 ;
          currentMaxHeight=nums[i]-1 ;
        }
      }
      else {
        canNotRemove+=Math.max(1,currentMaxHeight);
      }
    }
    pr.println(sum-canNotRemove);
  }
  public static void shuffleArray(int[] arr){
    Random rnd=ThreadLocalRandom.current();
    for(int i=arr.length-1 ; i>0 ; i--){
      int index=rnd.nextInt(i+1);
      if(index!=i){
        arr[index] ^=arr[i];
        arr[i] ^=arr[index];
        arr[index] ^=arr[i];
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ViewMatter {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
     var n : int ; n := (temp[0+1])->toInteger() ;
    var m : int ; m := (temp[1+1])->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
    temp := br.readLine()->split(" ") ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := (temp[i+1])->toInteger() ; 
     sum := sum+(nums[i+1]) )  ;     i := i + 1 ) ; 
    execute shuffleArray(nums) ; 
    nums := nums->sort() ; 
    var canNotRemove : long ; canNotRemove := 0 ;
    var currentMaxHeight : int ; currentMaxHeight := nums[n - 1+1] ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (i - 1 >= 0) then (     if (currentMaxHeight <= nums[i+1]) then (     canNotRemove := canNotRemove + 1 ; 
     currentMaxHeight := currentMaxHeight - 1 ) else     if (currentMaxHeight > nums[i+1]) then (     canNotRemove := canNotRemove+(currentMaxHeight - nums[i+1] + 1) ; 
     currentMaxHeight := nums[i+1] - 1 ) else skip ; ) else (     canNotRemove := canNotRemove+(Set{1, currentMaxHeight}->max()) ) )  ;     i := i - 1 ) ; 
    skip ; 
 );
  static   operation shuffleArray( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var rnd : OclRandom ; rnd := MathLib ;
         var i : int ; i := arr->size() - 1 ; while i > 0 do ( (     var index : int ; index := rnd.nextInt(i + 1) ;
     if (index /= i) then (     arr[index+1] := MathLib.bitwiseXor(arr[index+1],arr[i+1]) ; 
     arr[i+1] := MathLib.bitwiseXor(arr[i+1],arr[index+1]) ; 
     arr[index+1] := MathLib.bitwiseXor(arr[index+1],arr[i+1]) ) else skip )  ;     i := i - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static void printExpansion(String str){
    String suff="" ;
    for(int i=str.length()-1 ; i>=0 ; i--){
      suff=suff+str.charAt(i);
      System.out.print(suff);
    }
  }
  public static void main(String args[]){
    String str="geeks" ;
    printExpansion(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation printExpansion( str : String) : void
  pre: true
  post: true
  activity: (     var suff : String ; suff := "" ;
         var i : int ; i := str->size() - 1 ; while i >= 0 do ( (     suff := suff + str->at(i+1) ; 
     OclFile["System.out"].print(suff) )  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeks" ;
     execute printExpansion(str) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double seriesSum(int n){
    int i=1 ;
    double res=0.0 ;
    boolean sign=true ;
    while(n>0){
      n--;
      if(sign){
        sign=! sign ;
        res=res+(double)++i/++i ;
      }
      else {
        sign=! sign ;
        res=res-(double)++i/++i ;
      }
    }
    return res ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.print(seriesSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation seriesSum( n : int) : double
  pre: true
  post: true
  activity: (     var i : int ; i := 1 ;
     var res : double ; res := 0.0 ;
    var sign : boolean ; sign := true ;
    while (n > 0) do (     n := n - 1 ; 
     if (sign) then (     sign := not(sign) ; 
         i := i + 1 ;
    i := i + 1 ;
 res := res + i->oclAsType(double) / i  ) else (     sign := not(sign) ; 
         i := i + 1 ;
    i := i + 1 ;
 res := res - i->oclAsType(double) / i  ) ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].print(seriesSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int toggleBitsFromLToR(int n,int l,int r){
    if(r<l)return n ;
    int num=((1<<r)-1)^((1<<(l-1))-1);
    return(n ^ num);
  }
  static int smallNumWithNSetAndMUnsetBits(int n,int m){
    int num=(1<<(n+m))-1 ;
    return toggleBitsFromLToR(num,n,n+m-1);
  }
  public static void main(String[] args){
    int n=2,m=2 ;
    System.out.println(smallNumWithNSetAndMUnsetBits(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation toggleBitsFromLToR( n : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     if (r < l) then     return n else skip ; 
     var num : int ; num := MathLib.bitwiseXor((((1*(2->pow(r)))->oclAsType(long)) - 1),(((1*(2->pow((l - 1))))->oclAsType(long)) - 1)) ;
     return (n xor num) );
  static   operation smallNumWithNSetAndMUnsetBits( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := ((1*(2->pow((n + m))))->oclAsType(long)) - 1 ;
     return toggleBitsFromLToR(num, n, n + m - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
    var m : int ; m := 2 ;
     OclFile["System.out"].println(smallNumWithNSetAndMUnsetBits(n, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    long K=scan.nextLong();
    if(K==0){
      System.out.println(2);
      System.out.println("1 1");
      return ;
    }
    if(K==1){
      System.out.println(2);
      System.out.println("3 0");
      return ;
    }
    long[] a=new long[50];
    for(int i=0 ; i<50 ; i++){
      a[i]=Math.floorDiv(K,50)+i ;
    }
    long remain=K-Math.floorDiv(K,50)*50 ;
    for(long i=0 ; i<remain ; i++){
      for(int j=0 ; j<50 ; j++){
        if(j==0){
          a[j]+=50 ;
          continue ;
        }
        a[j]-=1 ;
      }
      Arrays.sort(a);
    }
    System.out.println(50);
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<50 ; i++){
      sb.append(a[i]);
      sb.append(" ");
    }
    System.out.println(sb.substring(0,sb.length()-1));
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var K : long ; K := scan.getCurrent()->toLong() ;
    if (K = 0) then (     OclFile["System.out"].println(2) ; 
     OclFile["System.out"].println("1 1") ; 
     return ) else skip ; 
    if (K = 1) then (     OclFile["System.out"].println(2) ; 
     OclFile["System.out"].println("3 0") ; 
     return ) else skip ; 
    var a : Sequence(long) ; a := Integer.subrange(1,50)->collect(0) ;
        var i : int ; i := 0 ; while i < 50 do ( (     a[i+1] := floorDiv(K, 50) + i )  ;     i := i + 1 ) ; 
    var remain : long ; remain := K - floorDiv(K, 50) * 50 ;
        var i : long ; i := 0 ; while i < remain do ( (         var j : int ; j := 0 ; while j < 50 do ( (     if (j = 0) then (     a[j+1] := a[j+1]+(50) ; 
     continue ) else skip ; 
     a[j+1] := a[j+1]-(1) )  ;     j := j + 1 ) ; 
     a := a->sort() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(50) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < 50 do ( (     sb := sb + StringLib.newString(a[i+1]) ; 
     sb := sb + StringLib.newString(" ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb.subrange(0+1,sb->size() - 1)) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.nio.charset.MalformedInputException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int N=sc.nextInt();
    int y=(int)(Math.sqrt(N));
    int u=y ;
    while(y*u<N){
      u++;
    }
    int r=(y+u)*2 ;
    out.println(r);
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var y : int ; y := ((N)->sqrt())->oclAsType(int) ;
    var u : int ; u := y ;
    while (y * u < N) do (     u := u + 1 ) ; 
    var r : int ; r := (y + u) * 2 ;
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static long n ;
  static long solve(){
    long l=0,b=0 ;
    l=(long)Math.sqrt(n);
    b=l ;
    n-=l*b ;
    long extra=n/l ;
    n-=extra*l ;
    return 2*(l+b+extra)+((n>0)? 2 : 0);
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    n=Long.parseLong(bf.readLine().trim());
    str.append(solve()).append("\n");
    pw.print(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute n : long;
  static   operation solve() : long
  pre: true
  post: true
  activity: (     var l : long ; l := 0 ;
    var b : long ; b := 0 ;
     l := (n)->sqrt()->oclAsType(long) ; 
    b := l ; 
    n := n-(l * b) ; 
    var extra : long ; extra := n / l ;
    n := n-(extra * l) ; 
    return 2 * (l + b + extra) + (if (n > 0) then 2 else 0 endif) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    n := (bf.readLine()->trim())->toLong() ; 
    str := str + StringLib.newString(solve()) + StringLib.newString("\n") ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B859 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println(2*((int)Math.ceil(2*Math.sqrt(N))));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B859 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(2 * ((2 * (N)->sqrt())->ceil()->oclAsType(int))) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static int solve(int n){
    int t=(int)Math.sqrt(n);
    if(n==1)return 4 ;
    int ans=t*4 ;
    if(t*t==n)return ans ;
    n=n-(t*t);
    ans+=((n % t==0)? n/t :(n/t)+1)*2 ;
    return ans ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    System.out.println(solve(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation solve( n : int) : int
  pre: true
  post: true
  activity: (     var t : int ; t := (n)->sqrt()->oclAsType(int) ;
     if (n = 1) then     return 4 else skip ; 
    var ans : int ; ans := t * 4 ;
    if (t * t = n) then     return ans else skip ; 
    n := n - (t * t) ; 
    ans := ans+((if (n mod t = 0) then n / t else (n / t) + 1 endif) * 2) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int mod=100000 ;
    while(true){
      int w=scanner.nextInt();
      int h=scanner.nextInt();
      if((w | h)==0)break ;
      int[][][] dp=new int[4][h][w];
      for(int i=0 ; i<h ; i++)dp[0][i][0]=1 ;
      for(int i=0 ; i<w ; i++)dp[2][0][i]=1 ;
      for(int i=1 ; i<h ; i++){
        for(int j=1 ; j<w ; j++){
          dp[0][i][j]=(dp[0][i-1][j]+dp[1][i-1][j])% mod ;
          dp[1][i][j]=dp[2][i-1][j] % mod ;
          dp[2][i][j]=(dp[2][i][j-1]+dp[3][i][j-1])% mod ;
          dp[3][i][j]=dp[0][i][j-1] % mod ;
        }
      }
      int ans=0 ;
      for(int i=0 ; i<4 ; i++){
        ans+=dp[i][h-1][w-1];
      }
      System.out.println(ans % mod);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var mod : int ; mod := 100000 ;
     while (true) do (     var w : int ; w := scanner.getCurrent()->toInteger() ;
     var h : int ; h := scanner.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(w,h)) = 0) then     break else skip ; 
    var dp : Sequence(Sequence(Sequence(int))) ; dp := Integer.subrange(1,4)->collect(Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0))) ;
        var i : int ; i := 0 ; while i < h do (     dp[0+1][i+1][0+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < w do (     dp[2+1][0+1][i+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < h do ( (         var j : int ; j := 1 ; while j < w do ( (     dp[0+1][i+1][j+1] := (dp[0+1][i - 1+1][j+1] + dp[1+1][i - 1+1][j+1]) mod mod ; 
     dp[1+1][i+1][j+1] := dp[2+1][i - 1+1][j+1] mod mod ; 
     dp[2+1][i+1][j+1] := (dp[2+1][i+1][j - 1+1] + dp[3+1][i+1][j - 1+1]) mod mod ; 
     dp[3+1][i+1][j+1] := dp[0+1][i+1][j - 1+1] mod mod )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     ans := ans+(dp[i+1][h - 1+1][w - 1+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans mod mod) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int[] data=new int[5];
    int cnt=0 ;
    int n=Integer.parseInt(br.readLine());
    String str=br.readLine();
    StringTokenizer st=new StringTokenizer(str," ");
    while(st.hasMoreTokens())data[Integer.parseInt(st.nextToken())]++;
    cnt=data[4]+data[3]+data[2]/2 ;
    data[1]-=data[3];
    if(data[2] % 2==1){
      cnt++;
      data[1]-=2 ;
    }
    if(data[1]>0)cnt+=(data[1]+3)/4 ;
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var data : Sequence(int) ; data := Integer.subrange(1,5)->collect(0) ;
    var cnt : int ; cnt := 0 ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var str : String ; str := br.readLine() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String_String(str, " ") ;
    while (st.hasNext()) do     data[(st.next())->toInteger()+1] := data[(st.next())->toInteger()+1] + 1 ; ; 
    cnt := data[4+1] + data[3+1] + data[2+1] / 2 ; 
    data[1+1] := data[1+1]-(data[3+1]) ; 
    if (data[2+1] mod 2 = 1) then (     cnt := cnt + 1 ; 
     data[1+1] := data[1+1]-(2) ) else skip ; 
    if (data[1+1] > 0) then     cnt := cnt+((data[1+1] + 3) / 4) ; else skip ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  final int MOD=100000 ;
  void run(){
    for(; ; ){
      int w=sc.nextInt();
      int h=sc.nextInt();
      if((w | h)==0)return ;
      int[][][] dp=new int[h][w][4];
      dp[0][0][2]=1 ;
      dp[0][0][3]=1 ;
      for(int i=0 ; i<h ; i++){
        for(int j=0 ; j<w ; j++){
          if(i+1<h)dp[i+1][j][0]=(dp[i+1][j][0]+dp[i][j][0]+dp[i][j][2])% MOD ;
          if(i+1<h)dp[i+1][j][2]=(dp[i+1][j][2]+dp[i][j][1])% MOD ;
          if(j+1<w)dp[i][j+1][1]=(dp[i][j+1][1]+dp[i][j][1]+dp[i][j][3])% MOD ;
          if(j+1<w)dp[i][j+1][3]=(dp[i][j+1][3]+dp[i][j][0])% MOD ;
        }
      }
      int ans=0 ;
      for(int i=0 ; i<4 ; i++)ans+=dp[h-1][w-1][i];
      System.out.println(ans % MOD);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute MOD : int := 100000;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var w : int ; w := sc.getCurrent()->toInteger() ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(w,h)) = 0) then     return else skip ; 
    var dp : Sequence(Sequence(Sequence(int))) ; dp := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(Integer.subrange(1,4)->collect(0))) ;
    dp[0+1][0+1][2+1] := 1 ; 
    dp[0+1][0+1][3+1] := 1 ; 
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (i + 1 < h) then     dp[i + 1+1][j+1][0+1] := (dp[i + 1+1][j+1][0+1] + dp[i+1][j+1][0+1] + dp[i+1][j+1][2+1]) mod MOD ; else skip ; 
     if (i + 1 < h) then     dp[i + 1+1][j+1][2+1] := (dp[i + 1+1][j+1][2+1] + dp[i+1][j+1][1+1]) mod MOD ; else skip ; 
     if (j + 1 < w) then     dp[i+1][j + 1+1][1+1] := (dp[i+1][j + 1+1][1+1] + dp[i+1][j+1][1+1] + dp[i+1][j+1][3+1]) mod MOD ; else skip ; 
     if (j + 1 < w) then     dp[i+1][j + 1+1][3+1] := (dp[i+1][j + 1+1][3+1] + dp[i+1][j+1][0+1]) mod MOD ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 4 do (     ans := ans+(dp[h - 1+1][w - 1+1][i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans mod MOD) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public void doIt(){
    final int MOD=100000 ;
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    while(!(x==0 && y==0)){
      int[][][] list=new int[y+1][x+1][4];
      list[1][1][0]=1 ;
      list[1][1][1]=0 ;
      list[1][1][2]=1 ;
      list[1][1][3]=0 ;
      for(int i=1 ; i<=y ; i++){
        for(int j=1 ; j<=x ; j++){
          if(i==1 && j==1)continue ;
          list[i][j][0]+=list[i-1][j][3];
          list[i][j][1]+=(list[i-1][j][0]+list[i-1][j][1])% MOD ;
          list[i][j][2]+=list[i][j-1][1];
          list[i][j][3]+=(list[i][j-1][2]+list[i][j-1][3])% MOD ;
        }
      }
      int sum=0 ;
      for(int i=0 ; i<4 ; i++){
        sum+=list[y][x][i];
      }
      System.out.println(sum % MOD);
      x=sc.nextInt();
      y=sc.nextInt();
    }
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var MOD : int ; MOD := 100000 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    while (not((x = 0 & y = 0))) do (     var list : Sequence(Sequence(Sequence(int))) ; list := Integer.subrange(1,y + 1)->collect(Integer.subrange(1,x + 1)->collect(Integer.subrange(1,4)->collect(0))) ;
     list[1+1][1+1][0+1] := 1 ; 
    list[1+1][1+1][1+1] := 0 ; 
    list[1+1][1+1][2+1] := 1 ; 
    list[1+1][1+1][3+1] := 0 ; 
        var i : int ; i := 1 ; while i <= y do ( (         var j : int ; j := 1 ; while j <= x do ( (     if (i = 1 & j = 1) then     continue else skip ; 
     list[i+1][j+1][0+1] := list[i+1][j+1][0+1]+(list[i - 1+1][j+1][3+1]) ; 
    list[i+1][j+1][1+1] := list[i+1][j+1][1+1]+((list[i - 1+1][j+1][0+1] + list[i - 1+1][j+1][1+1]) mod MOD) ; 
    list[i+1][j+1][2+1] := list[i+1][j+1][2+1]+(list[i+1][j - 1+1][1+1]) ; 
    list[i+1][j+1][3+1] := list[i+1][j+1][3+1]+((list[i+1][j - 1+1][2+1] + list[i+1][j - 1+1][3+1]) mod MOD) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     sum := sum+(list[y+1][x+1][i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum mod MOD) ; 
    x := sc.getCurrent()->toInteger() ; 
    y := sc.getCurrent()->toInteger() ; 
 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  static Scanner scanner=new Scanner();
  public static void main(String[] $){
    long k=scanner.nextLong();
    long a=49+k/50-k % 50 ;
    System.out.println(50);
    for(int i=0 ; i<50 ; i++){
      if(k % 50>0){
        System.out.println(a+51);
        k--;
      }
      else {
        System.out.println(a);
      }
    }
  }
  static class Scanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),1<<15);
    StringTokenizer tokenizer ;
    String next(){
      try {
        while(tokenizer==null || ! tokenizer.hasMoreTokens()){
          tokenizer=new StringTokenizer(reader.readLine());
        }
      }
      catch(IOException ignored){
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := (arguments ( ));
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : long ; k := scanner.getCurrent()->toLong() ;
     var a : long ; a := 49 + k / 50 - k mod 50 ;
     OclFile["System.out"].println(50) ; 
         var i : int ; i := 0 ; while i < 50 do ( (     if (k mod 50 > 0) then (     OclFile["System.out"].println(a + 51) ; 
     k := k - 1 ) else (     OclFile["System.out"].println(a) ) )  ;     i := i + 1 ) );
  static class Scanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (1*(2->pow(15)))->oclAsType(long));
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (ignored : IOException) do skip
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class First_project {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String[] x=new String[2];
    x[0]=input.next();
    x[1]=input.next();
    if(x[0] .equals(x[1])){
      System.out.println("-1");
    }
    else {
      int max=Math.max(x[0] .length(),x[1] .length());
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class First_project {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : Sequence(String) ; x := Integer.subrange(1,2)->collect(null) ;
    x[0+1] := input.getCurrent() ; 
    x[1+1] := input.getCurrent() ; 
    if (x[0+1] = x[1+1]) then (     OclFile["System.out"].println("-1") ) else (     var max : int ; max := Set{x[0+1]->size(), x[1+1]->size()}->max() ;
     OclFile["System.out"].println(max) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.function.IntPredicate ;
import org.omg.CORBA.Current ;
import static java.lang.Math.abs ;
import java.math.BigInteger ;
public class omar {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String a=input.nextLine();
    String b=input.nextLine();
    if(a.equals(b)){
      System.out.println("-1");
    }
    else if(a.length()>=b.length()){
      System.out.println(a.length());
    }
    else if(a.length()<b.length()){
      System.out.println(b.length());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class omar {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := input.nextLine() ;
     var b : String ; b := input.nextLine() ;
     if (a = b) then (     OclFile["System.out"].println("-1") ) else     if (a->size() >= b->size()) then (     OclFile["System.out"].println(a->size()) ) else     if (a->size() < b->size()) then (     OclFile["System.out"].println(b->size()) ) else skip ; ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String str1=sc.next();
    String str2=sc.next();
    if(str1.equals(str2)==true){
      System.out.println(-1);
    }
    else if(str1.length()!=str2.length()){
      System.out.println(Math.max(str1.length(),str2.length()));
    }
    else {
      System.out.println(str1.length());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str1 : String ; str1 := sc.getCurrent() ;
     var str2 : String ; str2 := sc.getCurrent() ;
     if (str1 = str2 = true) then (     OclFile["System.out"].println(-1) ) else     if (str1->size() /= str2->size()) then (     OclFile["System.out"].println(Set{str1->size(), str2->size()}->max()) ) else (     OclFile["System.out"].println(str1->size()) ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class JavaApplication7 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String a=in.next();
    String b=in.next();
    if(a.equals(b))System.out.println(-1);
    else System.out.println(Math.max(a.length(),b.length()));
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication7 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := in.getCurrent() ;
     var b : String ; b := in.getCurrent() ;
     if (a = b) then     OclFile["System.out"].println(-1) ; else     OclFile["System.out"].println(Set{a->size(), b->size()}->max()) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  static Scanner e=new Scanner(System.in);
  public static void main(String[] args){
    String a=e.next();
    String b=e.next();
    int max=Math.max(a.length(),b.length());
    if(a.length()!=b.length()|| ! a.equals(b))System.out.println(max);
    else System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute e : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ; a := e.getCurrent() ;
     var b : String ; b := e.getCurrent() ;
     var max : int ; max := Set{a->size(), b->size()}->max() ;
     if (a->size() /= b->size() or not(a = b)) then     OclFile["System.out"].println(max) ; else     OclFile["System.out"].println(-1) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    if(s.equals("zyxwvutsrqponmlkjihgfedcba")){
      System.out.println(-1);
      return ;
    }
    if(s.length()==26){
      for(int i=24 ; i>=0 ; i--){
        char target=s.charAt(i);
        char c='z' ;
        boolean exist=false ;
        for(int j=i+1 ; j<s.length(); j++){
          if(target<s.charAt(j)){
            exist=true ;
            if(c>s.charAt(j)){
              c=s.charAt(j);
            }
          }
        }
        if(exist){
          System.out.println(s.substring(0,i)+c);
          return ;
        }
      }
    }
    char last='a' ;
    while(true){
      if(s.indexOf(last)==-1){
        System.out.println(s+last);
        return ;
      }
      last++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    if (s = "zyxwvutsrqponmlkjihgfedcba") then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    if (s->size() = 26) then (         var i : int ; i := 24 ; while i >= 0 do ( (     var target : String ; target := s->at(i+1) ;
     var c : String ; c := 'z' ;
    var exist : boolean ; exist := false ;
        var j : int ; j := i + 1 ; while j < s->size() do ( (     if (target < s->at(j+1)) then (     exist := true ; 
     if (c > s->at(j+1)) then (     c := s->at(j+1) ) else skip ) else skip )  ;     j := j + 1 ) ; 
    if (exist) then (     OclFile["System.out"].println(s.subrange(0+1,i) + c) ; 
     return ) else skip ; 
 )  ;     i := i - 1 ) ) else skip ; 
    var last : String ; last := 'a' ;
    while (true) do (     if (s->indexOf(last)-1 = -1) then (     OclFile["System.out"].println(s + last) ; 
     return ) else skip ; 
     last := last + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int K,N ;
  List<Long>h ;
  long result ;
  Main(){
    Scanner in=new Scanner(System.in);
    N=in.nextInt();
    K=in.nextInt();
    h=new ArrayList<>(N);
    for(int i=0 ; i<N ; ++i){
      h.add(in.nextLong());
    }
    in.close();
    Collections.sort(h);
  }
  void calc(){
    long diff=Long.MAX_VALUE ;
    for(int i=0 ; i+K<=N ; ++i){
      int largeIndex=i+K-1 ;
      if(diff>h.get(largeIndex)-h.get(i)){
        diff=h.get(largeIndex)-h.get(i);
      }
    }
    result=diff ;
  }
  public static void main(String[] args){
    Main ins=new Main();
    ins.calc();
    System.out.println(ins.result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute K : int;
   attribute h : Sequence(long);
   attribute result : long;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := in.getCurrent()->toInteger() ; 
    K := in.getCurrent()->toInteger() ; 
    h := Sequence{}->union(N) ; 
        var i : int ; i := 0 ; while i < N do ( (     h := h->including(in.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    skip ; 
    h := h->sort() ; 
 );
   operation calc() : void
  pre: true
  post: true
  activity: (     var diff : long ; diff := "9223372036854775807"->toLong() ;
         var i : int ; i := 0 ; while i + K <= N do ( (     var largeIndex : int ; largeIndex := i + K - 1 ;
     if (diff > h->at(largeIndex+1) - h->at(i+1)) then (     diff := h->at(largeIndex+1) - h->at(i+1) ) else skip )  ;     i := i + 1 ) ; 
     result := diff );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ins : Main ; ins := Main.newMain() ;
     ins.calc() ; 
     OclFile["System.out"].println(ins.result) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
import static java.lang.System.exit ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  static void solve()throws Exception {
    String s=scanString();
    if(s.length()<26){
      out.print(s);
      for(char c='a' ; ; c++){
        if(s.indexOf(c)<0){
          out.print(c);
          break ;
        }
      }
    }
    else {
      boolean can[]=new boolean[26];
      i : for(int i=25 ;
      ;
      i--){
        if(i<0){
          out.print("-1");
          break ;
        }
        for(char c=(char)(s.charAt(i)+1); c<='z' ; c++){
          if(can[c-'a']){
            out.print(s.substring(0,i));
            out.print(c);
            break i ;
          }
        }
        can[s.charAt(i)-'a']=true ;
      }
    }
  }
  static int scanInt()throws IOException {
    return parseInt(scanString());
  }
  static long scanLong()throws IOException {
    return parseLong(scanString());
  }
  static String scanString()throws IOException {
    while(tok==null || ! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  public static void main(String[] args){
    try {
      in=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(System.out);
      solve();
      in.close();
      out.close();
    }
    catch(Throwable e){
      e.printStackTrace();
      exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var s : String ; s := scanString() ;
     if (s->size() < 26) then (     out.print(s) ; 
         var c : String ; c := 'a' ; while true do ( (     if (s->indexOf(c)-1 < 0) then (     out.print(c) ; 
     break ) else skip )  ;     c := c + 1 ) ) else (     var can : Sequence(boolean) ; can := Integer.subrange(1,26)->collect(false) ;
         var i : int ; i := 25 ; while true do ( (     if (i < 0) then (     out.print("-1") ; 
     break ) else skip ; 
         var c : String ; c := (s->at(i+1) + 1)->oclAsType(String) ; while c <= 'z' do ( (     if (can[(c)->char2byte() - ('a')->char2byte()+1]) then (     out.print(s.subrange(0+1,i)) ; 
     out.print(c) ; 
     break ) else skip )  ;     c := c + 1 ) ; 
     can[s->at(i+1) - ('a')->char2byte()+1] := true )  ;     i := i - 1 ) ; ) );
  static   operation scanInt() : int
  pre: true
  post: true
  activity: (     return (scanString() + "")->toInteger() );
  static   operation scanLong() : long
  pre: true
  post: true
  activity: (     return parseLong(scanString()) );
  static   operation scanString() : String
  pre: true
  post: true
  activity: (     while (tok = null or not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return tok.next() );
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
     execute exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    FastScanner in=new FastScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,FastScanner in,PrintWriter out){
      String s=in.next();
      int n=s.length();
      for(int pos=s.length(); pos>=0 ; pos--){
        for(int i=(pos==n)? 0 :(s.charAt(pos)-'a'+1); i<26 ; i++){
          String newS=s.substring(0,pos)+(char)('a'+i);
          if(diverse(newS)){
            out.println(newS);
            return ;
          }
        }
      }
      out.println(-1);
    }
    private boolean diverse(String newS){
      char[] c=newS.toCharArray();
      Arrays.sort(c);
      for(int i=0 ; i<c.length-1 ; i++){
        if(c[i]==c[i+1]){
          return false ;
        }
      }
      return true ;
    }
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(InputStream in){
      br=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      while(st==null || ! st.hasMoreElements()){
        String line=null ;
        try {
          line=br.readLine();
        }
        catch(IOException e){
        }
        st=new StringTokenizer(line);
      }
      return st.nextToken();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : FastScanner ; in := FastScanner.newFastScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : FastScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.next() ;
     var n : int ; n := s->size() ;
         var pos : int ; pos := s->size() ; while pos >= 0 do ( (         var i : int ; i := if (pos = n) then 0 else (s->at(pos+1) - ('a')->char2byte() + 1) endif ; while i < 26 do ( (     var newS : String ; newS := s.subrange(0+1,pos) + ('a' + i)->oclAsType(String) ;
     if (diverse(newS)) then (     skip ; 
     return ) else skip )  ;     i := i + 1 ) )  ;     pos := pos - 1 ) ; 
     skip );
   operation diverse( newS : String) : boolean
  pre: true
  post: true
  activity: (     var c : Sequence(String) ; c := newS->characters() ;
     c := c->sort() ; 
         var i : int ; i := 0 ; while i < c->size() - 1 do ( (     if (c[i+1] = c[i + 1+1]) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
}
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     var line : String ; line := null ;
     try (     line := br.readLine() )   catch (e : IOException) do skip
     st := OclIterator.newOclIterator_String(line) ) ; 
     return st.next() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public void run(){
    Scanner sc=new Scanner(System.in);
    String text=sc.next();
    String ans="-1" ;
    Set<Character>chsSet=new HashSet();
    for(char ch : text.toCharArray())chsSet.add(ch);
    System.err.println(chsSet);
    if(text.length()<26){
      for(int i=0 ; i<26 ; i++){
        char ch=(char)('a'+i);
        if(! chsSet.contains(ch)){
          ans=text+ch ;
          break ;
        }
      }
    }
    else {
      OUTER : for(int i=24 ;
      i>=0 ;
      i--){
        if(text.charAt(i)<text.charAt(i+1)){
          for(int j=25 ; j>i ; j--){
            if(text.charAt(i)<text.charAt(j)){
              ans=text.substring(0,i)+text.charAt(j);
              break OUTER ;
            }
          }
        }
      }
    }
    System.out.println(ans);
  }
  static public void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var text : String ; text := sc.getCurrent() ;
    var ans : String ; ans := "-1" ;
    var chsSet : Set(String) ; chsSet := Set{} ;
    for (ch : text->characters()) do (     chsSet := chsSet->including(ch) ;  ) ; 
    OclFile["System.err"].println(chsSet) ; 
    if (text->size() < 26) then (         var i : int ; i := 0 ; while i < 26 do ( (     var ch : String ; ch := ('a' + i)->oclAsType(String) ;
     if (not(chsSet->includes(ch))) then (     ans := text + ch ; 
     break ) else skip )  ;     i := i + 1 ) ) else (         var i : int ; i := 24 ; while i >= 0 do ( (     if (text->at(i+1) < text->at(i + 1+1)) then (         var j : int ; j := 25 ; while j > i do ( (     if (text->at(i+1) < text->at(j+1)) then (     ans := text.subrange(0+1,i) + text->at(j+1) ; 
     break ) else skip )  ;     j := j - 1 ) ) else skip )  ;     i := i - 1 ) ; ) ;  
    OclFile["System.out"].println(ans) ; 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main extends PrintWriter {
  Main(){
    super(System.out,true);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    Main o=new Main();
    o.main();
    o.flush();
  }
  void main(){
    long k=sc.nextLong();
    int n=50 ;
    int r=(int)(k % n);
    println(n);
    for(int i=0 ; i<r ; i++)print(n-1+1+k/n+" ");
    for(int i=r ; i<n ; i++)print(n-1-r+k/n+" ");
    println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends OclFile {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"], true) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : Main ; o := Main.newMain() ;
     o.main() ; 
     o.flush() );
   operation main() : void
  pre: true
  post: true
  activity: (     var k : long ; k := sc.getCurrent()->toLong() ;
     var n : int ; n := 50 ;
    var r : int ; r := (k mod n)->oclAsType(int) ;
    execute println(n) ; 
        var i : int ; i := 0 ; while i < r do (     execute print(n - 1 + 1 + k / n + " ") ;  ;     i := i + 1 ) ; 
        var i : int ; i := r ; while i < n do (     execute print(n - 1 - r + k / n + " ") ;  ;     i := i + 1 ) ; 
    execute println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    sc.close();
    String result=solve(s);
    System.out.println(result);
  }
  private static String solve(String s){
    if("zyxwvutsrqponmlkjihgfedcba".equals(s)){
      return "-1" ;
    }
    char[] alphabets="abcdefghijklmnopqrstuvwxyz".toCharArray();
    boolean[] isUsed=new boolean[26];
    if(s.length()<26){
      for(char c : s.toCharArray()){
        isUsed[(int)c-97]=true ;
      }
      for(int i=0 ; i<isUsed.length ; i++){
        if(! isUsed[i]){
          s+=alphabets[i];
          break ;
        }
      }
      return s ;
    }
    else {
      char[] c=s.toCharArray();
      for(int i=25 ; 0<i ; i--){
        char right=c[i];
        char left=c[i-1];
        isUsed[(int)right-97]=true ;
        c[i]='*' ;
        if(left<right){
          for(int j=(int)left-97 ; j<26 ; j++){
            if(isUsed[j]){
              c[i-1]=alphabets[j];
              break ;
            }
          }
          break ;
        }
      }
      return new String(c).replace("*","");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    skip ; 
    var result : String ; result := solve(s) ;
    OclFile["System.out"].println(result) ; 
 );
  static   operation solve( s : String) : String
  pre: true
  post: true
  activity: (     if ("zyxwvutsrqponmlkjihgfedcba" = s) then (     return "-1" ) else skip ; 
     var alphabets : Sequence(String) ; alphabets := "abcdefghijklmnopqrstuvwxyz"->characters() ;
     var isUsed : Sequence(boolean) ; isUsed := Integer.subrange(1,26)->collect(false) ;
     if (s->size() < 26) then (     for (c : s->characters()) do ( (     isUsed[c->oclAsType(int) - 97+1] := true )  ) ; 
         var i : int ; i := 0 ; while i < isUsed->size() do ( (     if (not(isUsed[i+1])) then (     s := s+(alphabets[i+1]) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     return s ) else (     var c : Sequence(String) ; c := s->characters() ;
         var i : int ; i := 25 ; while 0 < i do ( (     var right : String ; right := c[i+1] ;
     var left : String ; left := c[i - 1+1] ;
    isUsed[(right)->char2byte() - 97+1] := true ; 
    c[i+1] := '*' ; 
    if (left < right) then (         var j : int ; j := (left)->char2byte() - 97 ; while j < 26 do ( (     if (isUsed[j+1]) then (     c[i - 1+1] := alphabets[j+1] ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     break ) else skip ; 
 )  ;     i := i - 1 ) ; 
     return StringLib.newString(c).replace("*", "") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    String othello ;
    char[] field ;
    int i ;
    othello=sc.next();
    field=new char[othello.length()];
    for(i=0 ; i<field.length ; i++){
      field[i]=othello.charAt(i);
    }
    if(field[0]=='x' && field[field.length-1]=='x'){
      System.out.println("x");
    }
    else {
      System.out.println("o");
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var othello : String ;
    var field : Sequence(String) ;
    var i : int ;
    othello := sc.next() ; 
    field := Integer.subrange(1,othello->size())->collect(0) ; 
        i := 0 ; while i < field->size() do ( (     field[i+1] := othello->at(i+1) )  ;     i := i + 1 ) ; 
    if (field[0+1] = 'x' & field[field->size() - 1+1] = 'x') then (     OclFile["System.out"].println("x") ) else (     OclFile["System.out"].println("o") ) ;  
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main extends Template {
  public void solve()throws IOException {
    String str=nextToken();
    if(str.charAt(0)!=str.charAt(str.length()-1)){
      System.out.println("o");
    }
    else {
      System.out.println(Character.toString(str.charAt(0)));
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
abstract class Template implements Runnable {
  public abstract void solve()throws IOException ;
  BufferedReader reader ;
  StringTokenizer tokenizer ;
  PrintWriter writer ;
  public void run(){
    try {
      reader=new BufferedReader(new InputStreamReader(System.in));
      tokenizer=null ;
      writer=new PrintWriter(System.out);
      solve();
      reader.close();
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  public String nextToken()throws IOException {
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends Template {
   operation solve() : void
  pre: true
  post: true
  activity: (     var str : String ; str := nextToken() ;
     if (str->at(0+1) /= str->at(str->size() - 1+1)) then (     OclFile["System.out"].println("o") ) else (     OclFile["System.out"].println((str->at(0+1) + "")) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}
class Template implements Runnable {
     operation solve() : void
  pre: true
  post: true;
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   attribute writer : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     try (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := null ; 
    writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.Scanner ;
import java.util.TreeSet ;
import javax.print.attribute.standard.MediaSize.Other ;
import javax.xml.bind.ParseConversionEvent ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    char[] input=sc.next().toCharArray();
    boolean first_w=input[0]=='o' ;
    int length=1 ;
    char prev=input[0];
    for(int i=1 ; i<input.length ; i++){
      if(prev!=input[i]){
        length++;
        prev=input[i];
      }
    }
    if(length % 2==0 || first_w){
      System.out.println('o');
    }
    else {
      System.out.println('x');
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : Sequence(String) ; input := sc.getCurrent()->characters() ;
    var first_w : boolean ; first_w := input[0+1] = 'o' ;
    var length : int ; length := 1 ;
    var prev : String ; prev := input[0+1] ;
        var i : int ; i := 1 ; while i < input->size() do ( (     if (prev /= input[i+1]) then (     length := length + 1 ; 
     prev := input[i+1] ) else skip )  ;     i := i + 1 ) ; 
    if (length mod 2 = 0 or first_w) then (     OclFile["System.out"].println('o') ) else (     OclFile["System.out"].println('x') ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static char[] field ;
  public static void main(String[] args){
    while(read()){
      solve();
    }
  }
  static boolean read(){
    if(! sc.hasNext())return false ;
    field=sc.next().toCharArray();
    return true ;
  }
  static void solve(){
    System.out.println(field[0]==field[field.length-1] && field[0]=='x' ? 'x' : 'o');
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute field : Sequence(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (read()) do (     execute solve() ) );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     if (not(sc.hasNext())) then     return false else skip ; 
     field := sc.getCurrent()->characters() ; 
     return true );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if field[0+1] = field[field->size() - 1+1] & field[0+1] = 'x' then 'x' else 'o' endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static String str ;
  static boolean solve(){
    int change=0 ;
    for(int i=0 ; i<str.length()-1 ; ++i){
      if(str.charAt(i)!=str.charAt(i+1))++change ;
    }
    if(str.charAt(0)=='o' && str.charAt(str.length()-1)=='o'){
++change ;
    }
    return change % 2!=0 ;
  }
  public static void main(String[] args){
    str=sc.next();
    System.out.println(solve()? 'o' : 'x');
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute str : String;
  static   operation solve() : boolean
  pre: true
  post: true
  activity: (     var change : int ; change := 0 ;
         var i : int ; i := 0 ; while i < str->size() - 1 do ( (     if (str->at(i+1) /= str->at(i + 1+1)) then     change := change + 1 ; else skip )  ;     i := i + 1 ) ; 
     if (str->at(0+1) = 'o' & str->at(str->size() - 1+1) = 'o') then (     change := change + 1 ) else skip ; 
     return change mod 2 /= 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     str := sc.getCurrent() ; 
     OclFile["System.out"].println(if solve() then 'o' else 'x' endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int[] plusOne(int[] digits){
    return addToDigit(digits,digits.length-1);
  }
  private int[] addToDigit(int[] digits,int index){
    if(index==-1){
      int[] newDigits=new int[digits.length+1];
      newDigits[0]=1 ;
      for(int i=0 ; i<digits.length ; i++){
        newDigits[i+1]=digits[i];
      }
      return newDigits ;
    }
    if(digits[index]==9){
      digits[index]=0 ;
      return addToDigit(digits,index-1);
    }
    else {
      digits[index]++;
      return digits ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation plusOne( digits : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     return addToDigit(digits, digits->size() - 1) );
   operation addToDigit( digits : Sequence(int), index : int) : Sequence(int)
  pre: true
  post: true
  activity: (     if (index = -1) then (     var newDigits : Sequence(int) ; newDigits := Integer.subrange(1,digits->size() + 1)->collect(0) ;
     newDigits[0+1] := 1 ; 
         var i : int ; i := 0 ; while i < digits->size() do ( (     newDigits[i + 1+1] := digits[i+1] )  ;     i := i + 1 ) ; 
     return newDigits ) else skip ; 
     if (digits[index+1] = 9) then (     digits[index+1] := 0 ; 
     return addToDigit(digits, index - 1) ) else (     digits[index+1] := digits[index+1] + 1 ; 
     return digits ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in),1);
    String s ;
    String sl[];
    s=r.readLine();
    sl=s.split(" ");
    int n=Integer.parseInt(sl[0]);
    int k=Integer.parseInt(sl[1]);
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      s=r.readLine();
      a[i]=Integer.parseInt(s);
    }
    Arrays.sort(a);
    int min=1000000001 ;
    for(int i=0 ; i<=n-k ; i++){
      min=Math.min(min,a[i+k-1]-a[i]);
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 1) ;
     var s : String ;
    var sl : Sequence(String) ;
    s := r.readLine() ; 
    sl := s->split(" ") ; 
    var n : int ; n := (sl[0+1])->toInteger() ;
    var k : int ; k := (sl[1+1])->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s := r.readLine() ; 
     a[i+1] := (s)->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var min : int ; min := 1000000001 ;
        var i : int ; i := 0 ; while i <= (n)->char2byte() - k do ( (     min := Set{min, a[i + k - 1+1] - a[i+1]}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void minBinary(int n){
    int[] digit=new int[10];
    int len=0 ;
    while(n>0){
      digit[len++]=n % 10 ;
      n/=10 ;
    }
    digit=reverse(digit,0,len-1);
    int ans=0 ;
    for(int i=0 ; i<len ; i++){
      ans=Math.max(ans,digit[i]);
    }
    System.out.print("Minimum Number of binary"+" Strings needed: "+ans+"\n");
    for(int i=1 ; i<=ans ; i++){
      int num=0 ;
      for(int j=0 ; j<len ; j++){
        if(digit[j]>0){
          num=num*10+1 ;
          digit[j]--;
        }
        else {
          num*=10 ;
        }
      }
      System.out.print(num+" ");
    }
  }
  static int[] reverse(int str[],int start,int end){
    int temp ;
    while(start<=end){
      temp=str[start];
      str[start]=str[end];
      str[end]=temp ;
      start++;
      end--;
    }
    return str ;
  }
  public static void main(String[] args){
    int n=564 ;
    minBinary(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minBinary( n : int) : void
  pre: true
  post: true
  activity: (     var digit : Sequence(int) ; digit := Integer.subrange(1,10)->collect(0) ;
     var len : int ; len := 0 ;
    while (n > 0) do (      digit[len+1] := n mod 10  ; len := len + 1 ; 
     n := n/(10) ) ; 
    digit := reverse(digit, 0, len - 1) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < len do ( (     ans := Set{ans, digit[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("Minimum Number of binary" + " Strings needed: " + ans + "\n") ; 
        var i : int ; i := 1 ; while i <= ans do ( (     var num : int ; num := 0 ;
         var j : int ; j := 0 ; while j < len do ( (     if (digit[j+1] > 0) then (     num := num * 10 + 1 ; 
     digit[j+1] := digit[j+1] - 1 ) else (     num := num*(10) ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print(num + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation reverse( str : Sequence(int), start : int, end : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var temp : int ;
     while (start <= end) do (     temp := str[start+1] ; 
     str[start+1] := str[end+1] ; 
    str[end+1] := temp ; 
    start := start + 1 ; 
    end := end - 1 ; 
 ) ; 
     return str );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 564 ;
     execute minBinary(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int zeroUpto(int digits){
    int first=(int)((Math.pow(10,digits)-1)/9);
    int second=(int)((Math.pow(9,digits)-1)/8);
    return 9*(first-second);
  }
  static int toInt(char c){
    return(int)(c)-48 ;
  }
  static int countZero(String num){
    int k=num.length();
    int total=zeroUpto(k-1);
    int non_zero=0 ;
    for(int i=0 ; i<num.length(); i++){
      if(num.charAt(i)=='0'){
        non_zero--;
        break ;
      }
      non_zero+=(toInt(num.charAt(i))-1)*(Math.pow(9,k-1-i));
    }
    int no=0,remaining=0,calculatedUpto=0 ;
    for(int i=0 ; i<num.length(); i++){
      no=no*10+(toInt(num.charAt(i)));
      if(i!=0)calculatedUpto=calculatedUpto*10+9 ;
    }
    remaining=no-calculatedUpto ;
    int ans=zeroUpto(k-1)+(remaining-non_zero-1);
    return ans ;
  }
  static public void main(String[] args){
    String num="107" ;
    System.out.println("Count of numbers from 1"+" to "+num+" is "+countZero(num));
    num="1264" ;
    System.out.println("Count of numbers from 1"+" to "+num+" is "+countZero(num));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation zeroUpto( digits : int) : int
  pre: true
  post: true
  activity: (     var first : int ; first := ((10->pow(digits) - 1) / 9)->oclAsType(int) ;
     var second : int ; second := ((9->pow(digits) - 1) / 8)->oclAsType(int) ;
     return 9 * (first - second) );
  static   operation toInt( c : String) : int
  pre: true
  post: true
  activity: (     return (c)->oclAsType(int) - 48 );
  static   operation countZero( num : String) : int
  pre: true
  post: true
  activity: (     var k : int ; k := num->size() ;
     var total : int ; total := zeroUpto(k - 1) ;
    var non_zero : int ; non_zero := 0 ;
        var i : int ; i := 0 ; while i < num->size() do ( (     if (num->at(i+1) = '0') then (     non_zero := non_zero - 1 ; 
     break ) else skip ; 
     non_zero := non_zero+((toInt(num->at(i+1)) - 1) * (9->pow(k - 1 - i))) )  ;     i := i + 1 ) ; 
    var no : int ; no := 0 ;
    var remaining : int ; remaining := 0 ;
    var calculatedUpto : int ; calculatedUpto := 0 ;
        var i : int ; i := 0 ; while i < num->size() do ( (     no := no * 10 + (toInt(num->at(i+1))) ; 
     if (i /= 0) then     calculatedUpto := calculatedUpto * 10 + 9 ; else skip )  ;     i := i + 1 ) ; 
    remaining := no - calculatedUpto ; 
    var ans : int ; ans := zeroUpto(k - 1) + (remaining - non_zero - 1) ;
    return ans 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : String ; num := "107" ;
     OclFile["System.out"].println("Count of numbers from 1" + " to " + num + " is " + countZero(num)) ; 
     num := "1264" ; 
     OclFile["System.out"].println("Count of numbers from 1" + " to " + num + " is " + countZero(num)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  String s ;
  int id ;
  StringBuilder fnc(){
    StringBuilder sb=new StringBuilder();
    int cnt=0 ;
    while(true){
      if(id==s.length())return sb ;
      char c=s.charAt(id);
      id++;
      if(c=='[')sb.append(fnc());
      else if(c==']')return sb.reverse();
      else if(c=='+')cnt++;
      else if(c=='-')cnt--;
      else {
        int x=c-65 ;
        if(x==-2)x=65 ;
        else if(x+cnt>=0)x=65+(x+cnt)% 26 ;
        else x=91+(x+cnt)% 26 ;
        sb.append((char)x);
        cnt=0 ;
      }
    }
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      s=sc.next();
      if(s.equals("."))break ;
      id=0 ;
      System.out.println(fnc());
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute s : String;
   attribute id : int;
   operation fnc() : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     var cnt : int ; cnt := 0 ;
     while (true) do (     if (id = s->size()) then     return sb else skip ; 
     var c : String ; c := s->at(id+1) ;
     id := id + 1 ; 
     if (c = '[') then     sb := sb + StringLib.newString(fnc()) ; else     if (c = ']') then     return sb->reverse() else     if (c = '+') then     cnt := cnt + 1 else     if (c = '-') then     cnt := cnt - 1 else (     var x : int ; x := (c)->char2byte() - 65 ;
     if (x = -2) then     x := 65 else     if (x + cnt >= 0) then     x := 65 + (x + cnt) mod 26 else     x := 91 + (x + cnt) mod 26 ; ;  ;  
     sb := sb + StringLib.newString(x->oclAsType(String)) ; 
     cnt := 0 ) ;  ;  ;  ) );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     s := sc.getCurrent() ; 
     if (s = ".") then     break else skip ; 
     id := 0 ; 
     OclFile["System.out"].println(fnc()) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static char[] s ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(true){
      s=in.next().toCharArray();
      if(s[0]=='.')break ;
      idx=0 ;
      char[] res=cipher().toCharArray();
      for(int i=0 ; i<res.length ; i++){
        if(res[i]=='?')res[i]='A' ;
      }
      System.out.println(String.valueOf(res));
    }
  }
  public static int idx ;
  public static String cipher(){
    if(idx==s.length || s[idx]==']')return "" ;
    String next ;
    String res="" ;
    while((next=string()).length()>0){
      res+=next ;
    }
    return res ;
  }
  public static String string(){
    if(idx==s.length || s[idx]==']')return "" ;
    if(s[idx]=='['){
      idx++;
      char[] tmp=cipher().toCharArray();
      char[] tmp2=new char[tmp.length];
      for(int i=0 ; i<tmp.length ; i++){
        tmp2[i]=tmp[tmp.length-1-i];
      }
      idx++;
      return String.valueOf(tmp2);
    }
    return letter()+"" ;
  }
  public static char letter(){
    if(s[idx]=='+'){
      idx++;
      char res=letter();
      return res=='?' ? res :(char)((res+1-'A')% 26+'A');
    }
    else if(s[idx]=='-'){
      idx++;
      char res=letter();
      return res=='?' ? res :(char)((res-1+26-'A')% 26+'A');
    }
    return s[idx++];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : Sequence(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     s := in.getCurrent()->characters() ; 
     if (s[0+1] = '.') then     break else skip ; 
    idx := 0 ; 
    var res : Sequence(String) ; res := cipher()->characters() ;
        var i : int ; i := 0 ; while i < res->size() do ( (     if (res[i+1] = '?') then     res[i+1] := 'A' ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((res)->sum() ) ; 
 ) );
  static   attribute idx : int;
  static   operation cipher() : String
  pre: true
  post: true
  activity: (     if (idx = s->size() or s[idx+1] = ']') then     return "" else skip ; 
     var next : String ;
    var res : String ; res := "" ;
        next := string() ;
    while ((next)->size() > 0) do (        next := string() ;
    (next)->size() ;     skip ; (     res := res+(next) ) ;     next := string() ;
 ) ;  
    return res 
 );
  static   operation string() : String
  pre: true
  post: true
  activity: (     if (idx = s->size() or s[idx+1] = ']') then     return "" else skip ; 
     if (s[idx+1] = '[') then (     idx := idx + 1 ; 
     var tmp : Sequence(String) ; tmp := cipher()->characters() ;
    var tmp2 : Sequence(String) ; tmp2 := Integer.subrange(1,tmp->size())->collect(0) ;
        var i : int ; i := 0 ; while i < tmp->size() do ( (     tmp2[i+1] := tmp[tmp->size() - 1 - i+1] )  ;     i := i + 1 ) ; 
    idx := idx + 1 ; 
    return (tmp2)->sum()  
 ) else skip ; 
     return letter() + "" );
  static   operation letter() : String
  pre: true
  post: true
  activity: (     if (s[idx+1] = '+') then (     idx := idx + 1 ; 
     var res : String ; res := letter() ;
     return if res = '?' then res else ((res + 1 - ('A')->char2byte()) mod 26 + 'A')->oclAsType(String) endif ) else     if (s[idx+1] = '-') then (     idx := idx + 1 ; 
     var res : String ; res := letter() ;
     return if res = '?' then res else (((res)->char2byte() - 1 + 26 - ('A')->char2byte()) mod 26 + 'A')->oclAsType(String) endif ) else skip ; ;  
     return s[idx+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
class Main {
  public static void main(String[] args){
    Solve s=new Solve();
    s.solve();
  }
}
class Solve {
  Solve(){
  }
  Scanner in=new Scanner(System.in);
  void solve(){
    while(in.hasNext()){
      String s=in.next();
      if(s.equals("."))return ;
      System.out.println(calc(s,false));
    }
  }
  String calc(String s,boolean isrev){
    StringBuilder ret=new StringBuilder();
    int r=0 ;
    char c='A' ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='['){
        int k=i+1,rank=1 ;
        while(rank>0){
          if(s.charAt(k)=='[')rank++;
          else if(s.charAt(k)==']')rank--;
          k++;
        }
        ret.append(calc(s.substring(i+1,k),true));
        i=k-1 ;
      }
      else if(s.charAt(i)==']')continue ;
      else if(s.charAt(i)=='+')r++;
      else if(s.charAt(i)=='-')r--;
      else {
        if(s.charAt(i)=='?')c='A' ;
        else c=(char)('A'+(s.charAt(i)-'A'+r+26*100)% 26);
        r=0 ;
        ret.append(c);
      }
    }
    if(isrev)ret.reverse();
    return ret.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Solve ; s := Solve.newSolve() ;
     s.solve() );
}
class Solve {
   static operation newSolve() : Solve
  pre: true
  post: true
  activity:
  ( var self : Solve ;
    self := createSolve();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation solve() : void
  pre: true
  post: true
  activity: (     while (in.hasNext()) do (     var s : String ; s := in.getCurrent() ;
     if (s = ".") then     return else skip ; 
     OclFile["System.out"].println(calc(s, false)) ) );
   operation calc( s : String, isrev : boolean) : String
  pre: true
  post: true
  activity: (     var ret : String ; ret := StringLib.newString() ;
     var r : int ; r := 0 ;
    var c : String ; c := 'A' ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '[') then (     var k : int ; k := i + 1 ;
    var rank : int ; rank := 1 ;
     while (rank > 0) do (     if (s->at(k+1) = '[') then     rank := rank + 1 else     if (s->at(k+1) = ']') then     rank := rank - 1 ; else skip ; ;  
     k := k + 1 ) ; 
     ret := ret + StringLib.newString(calc(s.subrange(i + 1+1,k), true)) ; 
     i := k - 1 ) else     if (s->at(i+1) = ']') then     continue else     if (s->at(i+1) = '+') then     r := r + 1 else     if (s->at(i+1) = '-') then     r := r - 1 else (     if (s->at(i+1) = '?') then     c := 'A' else     c := ('A' + (s->at(i+1) - ('A')->char2byte() + r + 26 * 100) mod 26)->oclAsType(String) ; ;  
     r := 0 ; 
     ret := ret + StringLib.newString(c) ) ;  ;  ;  )  ;     i := i + 1 ) ; 
    if (isrev) then     ret := ret->reverse() ; else skip ; 
    return ret+"" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class ACE {
  static int gcd(int a,int b){
    return b==0 ? a : gcd(b,a % b);
  }
  static int find_LCM(int x,int y){
    return(x*y)/gcd(x,y);
  }
  static int CountPairs(int n,int m,int A,int B){
    int cnt=0 ;
    int lcm=find_LCM(A,B);
    for(int i=1 ; i<=n ; i++)cnt+=(m+(i % lcm))/lcm ;
    return cnt ;
  }
  public static void main(String[] args){
    int n=60,m=90,A=5,B=10 ;
    System.out.println(CountPairs(n,m,A,B));
  }
}
------------------------------------------------------------
OCL File:
---------
 class ACE {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
  static   operation find_LCM( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return (x * y) / gcd(x, y) );
  static   operation CountPairs( n : int, m : int, A : int, B : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var lcm : int ; lcm := find_LCM(A, B) ;
         var i : int ; i := 1 ; while i <= n do (     cnt := cnt+((m + (i mod lcm)) / lcm) ;  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 60 ;
    var m : int ; m := 90 ;
    var A : int ; A := 5 ;
    var B : int ; B := 10 ;
     OclFile["System.out"].println(CountPairs(n, m, A, B)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line=null ;
    int[] l=new int[10];
    int[] v=new int[2];
    while((line=br.readLine())!=null){
      String[] data=line.trim().split(",");
      int distance=0 ;
      for(int i=0 ; i<10 ; i++){
        l[i]=Integer.parseInt(data[i]);
        distance+=l[i];
      }
      for(int i=0 ; i<2 ; i++)v[i]=Integer.parseInt(data[i+10]);
      double see=distance*((double)v[0]/(v[1]+v[0]));
      for(int i=0 ; i<10 ; i++){
        if(see-l[i]>0){
          see-=l[i];
        }
        else {
          System.out.println(i+1);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := null ;
    var l : Sequence(int) ; l := Integer.subrange(1,10)->collect(0) ;
    var v : Sequence(int) ; v := Integer.subrange(1,2)->collect(0) ;
        line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     var data : Sequence(String) ; data := line->trim()->split(",") ;
     var distance : int ; distance := 0 ;
        var i : int ; i := 0 ; while i < 10 do ( (     l[i+1] := (data[i+1])->toInteger() ; 
     distance := distance+(l[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 2 do (     v[i+1] := (data[i + 10+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var see : double ; see := distance * (v[0+1]->oclAsType(double) / (v[1+1] + v[0+1])) ;
        var i : int ; i := 0 ; while i < 10 do ( (     if (see - l[i+1] > 0) then (     see := see-(l[i+1]) ) else (     OclFile["System.out"].println(i + 1) ; 
     break ) )  ;     i := i + 1 ) ; 
 ) ;     line := br.readLine() ;
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    try {
      while(true){
        new aoj0034().doIt();
      }
    }
    catch(Exception g){
      System.exit(0);
    }
  }
  class aoj0034 {
    int a[]=new int[10];
    void doIt(){
      String str[]=sc.next().split(",");
      int sum=0 ;
      for(int i=0 ; i<10 ; i++){
        a[i]=Integer.parseInt(str[i]);
        sum=sum+a[i];
      }
      int v1=Integer.parseInt(str[10]);
      int v2=Integer.parseInt(str[11]);
      double time=sum/(double)(v1+v2);
      time=time*v1 ;
      sum=0 ;
      for(int i=0 ; i<10 ; i++){
        sum=sum+a[i];
        if(sum>=time){
          System.out.println(i+1);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     while (true) do (     aoj0034.newaoj0034().doIt() ) )   catch (g : ProgramException) do ( OclProcess.exit(0) )
 );
 class aoj0034 {
   attribute a : int := Integer.subrange(1,10)->collect(0);
   operation doIt() : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := sc.getCurrent()->split(",") ;
     var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 10 do ( (     a[i+1] := (str[i+1])->toInteger() ; 
     sum := sum + a[i+1] )  ;     i := i + 1 ) ; 
    var v1 : int ; v1 := (str[10+1])->toInteger() ;
    var v2 : int ; v2 := (str[11+1])->toInteger() ;
    var time : double ; time := sum / (v1 + v2)->oclAsType(double) ;
    time := time * v1 ; 
    sum := 0 ; 
        var i : int ; i := 0 ; while i < 10 do ( (     sum := sum + a[i+1] ; 
     if (sum >= time) then (     OclFile["System.out"].println(i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    int[] data=null ;
    while((data=parseData())!=null){
      calc(data);
    }
  }
  private static void calc(int[] data){
    int n=0 ;
    double dt=(double)data[9]/(double)(data[10]+data[11]);
    double dl=(double)data[10]*dt ;
    for(; n<10 ; n++){
      if(dl==(double)data[n] || dl<(double)data[n]){
        break ;
      }
    }
    System.out.println(n+1);
  }
  private static int[] parseData(){
    int[] data=null ;
    String strIn=null ;
    if((strIn=parseStdin())!=null){
      String[] aN=strIn.split(",");
      data=new int[12];
      for(int n=0 ; n<data.length ; n++){
        data[n]=Integer.parseInt(aN[n]);
        if(1<=n && n<=9){
          data[n]+=data[n-1];
        }
      }
    }
    return data ;
  }
  private static String parseStdin(){
    String strNum=null ;
    try {
      String line=br.readLine();
      if(line!=null){
        if(! line.isEmpty()){
          strNum=line ;
        }
      }
    }
    catch(IOException e){
    }
    return strNum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var data : Sequence(int) ; data := null ;
         data := parseData() ;
    while ((data) /= null) do (    skip ; (     execute calc(data) ) ;     data := parseData() ;
 ) );
  static   operation calc( data : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 0 ;
     var dt : double ; dt := data[9+1]->oclAsType(double) / (data[10+1] + data[11+1])->oclAsType(double) ;
    var dl : double ; dl := data[10+1]->oclAsType(double) * dt ;
      while n < 10 do ( (     if (dl = data[n+1]->oclAsType(double) or dl < data[n+1]->oclAsType(double)) then (     break ) else skip )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(n + 1) ; 
 );
  static   operation parseData() : Sequence(int)
  pre: true
  post: true
  activity: (     var data : Sequence(int) ; data := null ;
     var strIn : String ; strIn := null ;
     if ((strIn) /= null) then (     var aN : Sequence(String) ; aN := strIn->split(",") ;
     data := Integer.subrange(1,12)->collect(0) ; 
         var n : int ; n := 0 ; while n < data->size() do ( (     data[n+1] := (aN[n+1])->toInteger() ; 
     if (1 <= n & n <= 9) then (     data[n+1] := data[n+1]+(data[n - 1+1]) ) else skip )  ;     n := n + 1 ) ) else skip ; 
     return data );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var strNum : String ; strNum := null ;
     try (     var line : String ; line := br.readLine() ;
     if (line /= null) then (     if (not(line->isEmpty())) then (     strNum := line ) else skip ) else skip )   catch (e : IOException) do skip
     return strNum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[] A=new long[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextLong();
    }
    long ans=0 ;
    for(int i=0 ; i<N ; i++){
      while(A[i] % 2==0){
        A[i]=A[i]/2 ;
        ans++;
      }
    }
    System.out.println(ans);
  }
  private static final long MOD=998244353 ;
  private static long FACT[];
  private static long IFACT[];
  private static void create_fact(int N){
    FACT=new long[N+1];
    IFACT=new long[N+1];
    FACT[0]=1 ;
    IFACT[0]=1 ;
    for(int i=1 ; i<=N ; i++){
      FACT[i]=FACT[i-1]*i % MOD ;
      IFACT[i]=mod_inverse(FACT[i]);
    }
  }
  private static long comb(int n,int r){
    if(n<0 || r<0 || n<r){
      return 0 ;
    }
    if(r>n/2){
      r=n-r ;
    }
    return FACT[n]*IFACT[n-r] % MOD*IFACT[r] % MOD ;
  }
  private static long mod_inverse(long a){
    long b=MOD ;
    long p=1,q=0 ;
    while(b>0){
      long c=a/b ;
      long d ;
      d=a ;
      a=b ;
      b=d % b ;
      d=p ;
      p=q ;
      q=d-c*q ;
    }
    return p<0 ? p+MOD : p ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     while (A[i+1] mod 2 = 0) do (     A[i+1] := A[i+1] / 2 ; 
     ans := ans + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static    attribute MOD : long := 998244353;
  static   attribute FACT : Sequence(long);
  static   attribute IFACT : Sequence(long);
  static   operation create_fact( N : int) : void
  pre: true
  post: true
  activity: (     FACT := Integer.subrange(1,N + 1)->collect(0) ; 
     IFACT := Integer.subrange(1,N + 1)->collect(0) ; 
    FACT[0+1] := 1 ; 
    IFACT[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= N do ( (     FACT[i+1] := FACT[i - 1+1] * i mod MOD ; 
     IFACT[i+1] := mod_inverse(FACT[i+1]) )  ;     i := i + 1 ) ; 
 );
  static   operation comb( n : int, r : int) : long
  pre: true
  post: true
  activity: (     if (n < 0 or r < 0 or n < r) then (     return 0 ) else skip ; 
     if (r > n / 2) then (     r := n - r ) else skip ; 
     return FACT[n+1] * IFACT[n - r+1] mod MOD * IFACT[r+1] mod MOD );
  static   operation mod_inverse( a : long) : long
  pre: true
  post: true
  activity: (     var b : long ; b := MOD ;
     var p : long ; p := 1 ;
    var q : long ; q := 0 ;
     while (b > 0) do (     var c : long ; c := a / b ;
     var d : long ;
    d := a ; 
    a := b ; 
    b := d mod b ; 
    d := p ; 
    p := q ; 
    q := d - c * q ; 
 ) ; 
     return if p < 0 then p + MOD else p endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int M=scan.nextInt();
    int[] kane=new int[N];
    for(int i=0 ; i<N ; i++){
      kane[i]=scan.nextInt();
    }
    Arrays.sort(kane);
    int min=kane[N-1]-kane[0];
    for(int i=0 ; i<N-M+1 ; i++){
      int x=kane[N-1-i];
      int y=kane[N-M-i];
      int z=x-y ;
      if(z==0){
        min=0 ;
        break ;
      }
      else if(min>z){
        min=z ;
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var M : int ; M := scan.getCurrent()->toInteger() ;
    var kane : Sequence(int) ; kane := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     kane[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    kane := kane->sort() ; 
    var min : int ; min := kane[N - 1+1] - kane[0+1] ;
        var i : int ; i := 0 ; while i < N - M + 1 do ( (     var x : int ; x := kane[N - 1 - i+1] ;
     var y : int ; y := kane[N - M - i+1] ;
     var z : int ; z := x - y ;
     if (z = 0) then (     min := 0 ; 
     break ) else     if (min > z) then (     min := z ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void printDistinct(int arr[],int n){
    Arrays.sort(arr);
    for(int i=0 ; i<n ; i++){
      while(i<n-1 && arr[i]==arr[i+1])i++;
      System.out.print(arr[i]+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      6,10,5,4,9,120,4,6,10 };
      int n=arr.length ;
      printDistinct(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printDistinct( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
         var i : int ; i := 0 ; while i < n do ( (     while (i < n - 1 & arr[i+1] = arr[i + 1+1]) do     i := i + 1 ; ; 
     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,10,5,4,9,120,4,6,10} ;
     var n : int ; n := arr->size() ;
     execute printDistinct(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float cone(float a){
    if(a<0)return-1 ;
    float r=(float)(a*Math.sqrt(2))/3 ;
    float h=(2*a)/3 ;
    float V=(float)(3.14*Math.pow(r,2)*h);
    return V ;
  }
  public static void main(String[] args){
    float a=5 ;
    System.out.println(cone(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation cone( a : double) : double
  pre: true
  post: true
  activity: (     if (a < 0) then     return -1 else skip ; 
     var r : double ; r := (a * (2)->sqrt())->oclAsType(double) / 3 ;
    var h : double ; h := (2 * a) / 3 ;
    var V : double ; V := (3.14 * r->pow(2) * h)->oclAsType(double) ;
    return V 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 5 ;
     OclFile["System.out"].println(cone(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private int[] a=new int[10];
  private double v1,v2 ;
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      String[] str=scan.nextLine().split(",");
      int dis=0 ;
      for(int i=0 ; i<10 ; i++){
        a[i]=Integer.parseInt(str[i]);
        dis+=a[i];
      }
      v1=Double.parseDouble(str[10]);
      v2=Double.parseDouble(str[11]);
      double pos=v1*dis/(v1+v2);
      int cal=0,ans=0 ;
      for(int i=0 ; i<10 ; i++){
        if(cal+a[i]>=pos){
          ans=i+1 ;
          break ;
        }
        cal+=a[i];
      }
      System.out.println(ans);
    }
  }
  private void debug(){
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute a : Sequence(int) := Integer.subrange(1,10)->collect(0);
   attribute v1 : double;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var str : Sequence(String) ; str := scan.nextLine()->split(",") ;
     var dis : int ; dis := 0 ;
        var i : int ; i := 0 ; while i < 10 do ( (     a[i+1] := (str[i+1])->toInteger() ; 
     dis := dis+(a[i+1]) )  ;     i := i + 1 ) ; 
    v1 := (str[10+1])->toReal() ; 
    v2 := (str[11+1])->toReal() ; 
    var pos : double ; pos := v1 * dis / (v1 + v2) ;
    var cal : int ; cal := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 10 do ( (     if (cal + a[i+1] >= pos) then (     ans := i + 1 ; 
     break ) else skip ; 
     cal := cal+(a[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
   operation debug() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(stdIn.hasNext()){
      int[] length=new int[10];
      int[] v=new int[2];
      String str=stdIn.nextLine();
      int j=0 ;
      int k=0 ;
      for(int i=0 ; i<str.length(); i++){
        if('0'<=str.charAt(i)&& str.charAt(i)<='9'){
          length[j]=length[j]*10 ;
          length[j]+=(int)str.charAt(i)-(int)'0' ;
        }
        else {
          j++;
          if(j==10){
            k=i+1 ;
            break ;
          }
        }
      }
      j=0 ;
      for(int i=k ; i<str.length(); i++){
        if('0'<=str.charAt(i)&& str.charAt(i)<='9'){
          v[j]=v[j]*10 ;
          v[j]+=(int)str.charAt(i)-(int)'0' ;
        }
        else {
          j++;
        }
      }
      int l=0 ;
      for(int i=0 ; i<10 ; i++){
        l+=length[i];
      }
      double t=(double)l/(v[0]+v[1]);
      double len=v[0]*t ;
      j=0 ;
      double le=0 ;
      while(true){
        le+=(double)length[j];
        if(le>=len){
          System.out.println(j+1);
          break ;
        }
        j++;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (stdIn.hasNext()) do (     var length : Sequence(int) ; length := Integer.subrange(1,10)->collect(0) ;
     var v : Sequence(int) ; v := Integer.subrange(1,2)->collect(0) ;
    var str : String ; str := stdIn.nextLine() ;
    var j : int ; j := 0 ;
    var k : int ; k := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if ('0' <= str->at(i+1) & str->at(i+1) <= '9') then (     length[j+1] := length[j+1] * 10 ; 
     length[j+1] := length[j+1]+(str->at(i+1)->oclAsType(int) - ('0')->char2byte()) ) else (     j := j + 1 ; 
     if (j = 10) then (     k := i + 1 ; 
     break ) else skip ) )  ;     i := i + 1 ) ; 
    j := 0 ; 
        var i : int ; i := k ; while i < str->size() do ( (     if ('0' <= str->at(i+1) & str->at(i+1) <= '9') then (     v[j+1] := v[j+1] * 10 ; 
     v[j+1] := v[j+1]+(str->at(i+1)->oclAsType(int) - ('0')->char2byte()) ) else (     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var l : int ; l := 0 ;
        var i : int ; i := 0 ; while i < 10 do ( (     l := l+(length[i+1]) )  ;     i := i + 1 ) ; 
    var t : double ; t := l->oclAsType(double) / (v[0+1] + v[1+1]) ;
    var len : double ; len := v[0+1] * t ;
    j := 0 ; 
    var le : double ; le := 0 ;
    while (true) do (     le := le+(length[j+1]->oclAsType(double)) ; 
     if (le >= len) then (     OclFile["System.out"].println(j + 1) ; 
     break ) else skip ; 
     j := j + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  private static int fixDigit(int num,int index,int digit){
    switch(index){
      case-1 : return num ;
      case 0 : return 1000*digit+(num % 1000);
      case 1 : return 100*digit+(num/1000)*1000+(num % 100);
      case 2 : return 10*digit+(num/100)*100+(num % 10);
      case 3 : return digit+(num/10)*10 ;
      default : return 0 ;
    }
  }
  private static int changeMinimunValue(int oldVlaue,int minValue,int maxValue){
    int newValue=9999 ;
    for(int index=0 ; index<=3 ; ++index){
      for(int digit=0 ; digit<=9 ; ++digit){
        int temp=fixDigit(oldVlaue,index,digit);
        if(minValue<=temp && temp<=maxValue && temp<newValue){
          newValue=temp ;
        }
      }
    }
    return newValue ;
  }
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.nextLine());
    List<Integer>arr=new ArrayList<>();
    for(int i=0 ; i<n ; ++i){
      arr.add(Integer.parseInt(sc.next()));
    }
    List<Integer>arr2=new ArrayList<>();
    int minValue=1000 ;
    int maxValue=2011 ;
    for(int i=0 ; i<n ; ++i){
      int newValue=changeMinimunValue(arr.get(i),minValue,maxValue);
      if(newValue<minValue || maxValue<newValue)break ;
      arr2.add(newValue);
      minValue=newValue ;
    }
    if(arr2.size()!=arr.size()){
      System.out.println("No solution");
    }
    else {
      arr2.forEach(i->System.out.println(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation fixDigit( num : int, index : int, digit : int) : int
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (index) ; 
       if _switchval = -1 then
     return num 
   else skip ;
       if _switchval = 0 then
     return 1000 * digit + (num mod 1000) 
   else skip ;
       if _switchval = 1 then
     return 100 * digit + (num / 1000) * 1000 + (num mod 100) 
   else skip ;
       if _switchval = 2 then
     return 10 * digit + (num / 100) * 100 + (num mod 10) 
   else skip ;
       if _switchval = 3 then
     return digit + (num / 10) * 10 
   else skip ;
       if true then
     return 0 
   else skip ;
 )
 );
  static   operation changeMinimunValue( oldVlaue : int, minValue : int, maxValue : int) : int
  pre: true
  post: true
  activity: (     var newValue : int ; newValue := 9999 ;
         var index : int ; index := 0 ; while index <= 3 do ( (         var digit : int ; digit := 0 ; while digit <= 9 do ( (     var temp : int ; temp := fixDigit(oldVlaue, index, digit) ;
     if (minValue <= temp & temp <= maxValue & temp < newValue) then (     newValue := temp ) else skip )  ;     digit := digit + 1 ) )  ;     index := index + 1 ) ; 
     return newValue );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.nextLine())->toInteger() ;
    var arr : Sequence(int) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr := arr->including((sc.getCurrent())->toInteger()) )  ;     i := i + 1 ) ; 
    var arr2 : Sequence(int) ; arr2 := Sequence{} ;
    var minValue : int ; minValue := 1000 ;
    var maxValue : int ; maxValue := 2011 ;
        var i : int ; i := 0 ; while i < n do ( (     var newValue : int ; newValue := changeMinimunValue(arr->at(i+1), minValue, maxValue) ;
     if (newValue < minValue or maxValue < newValue) then     break else skip ; 
     arr2 := arr2->including(newValue) ; 
     minValue := newValue )  ;     i := i + 1 ) ; 
    if (arr2->size() /= arr->size()) then (     OclFile["System.out"].println("No solution") ) else (     for i : arr2 do
    (    OclFile["System.out"].println(i)) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HarryPotterAndTheHistoryOfMagic {
  static boolean valid(int[] dates){
    for(int i=0 ; i<dates.length ; i++){
      if(dates[i]<1000 || dates[i]>2011)return false ;
      if(i>0 && dates[i-1]>dates[i])return false ;
    }
    return true ;
  }
  static int changeDate(int currentDate,int previousDate){
    char[] dateChars=String.valueOf(currentDate).toCharArray();
    int min=9999 ;
    for(int i=0 ; i<dateChars.length ; i++){
      char tmp=dateChars[i];
      for(char c='0' ; c<='9' ; c++){
        dateChars[i]=c ;
        int year=Integer.parseInt(String.valueOf(dateChars));
        if(year<=2011 && year>=previousDate && year<min){
          min=year ;
        }
      }
      dateChars[i]=tmp ;
    }
    return min ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] dates=new int[n];
    for(int i=0 ; i<n ; i++){
      dates[i]=in.nextInt();
    }
    int[] newDates=new int[n];
    for(int i=0 ; i<n ; i++){
      newDates[i]=changeDate(dates[i],i==0 ? 1000 : newDates[i-1]);
    }
    if(! valid(newDates)){
      System.out.println("No solution");
    }
    else {
      for(int date : newDates){
        System.out.println(date);
      }
    }
    in.close();
    System.exit(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class HarryPotterAndTheHistoryOfMagic {
  static   operation valid( dates : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < dates->size() do ( (     if (dates[i+1] < 1000 or dates[i+1] > 2011) then     return false else skip ; 
     if (i > 0 & dates[i - 1+1] > dates[i+1]) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation changeDate( currentDate : int, previousDate : int) : int
  pre: true
  post: true
  activity: (     var dateChars : Sequence(String) ; dateChars := ((currentDate) + "")->characters() ;
     var min : int ; min := 9999 ;
         var i : int ; i := 0 ; while i < dateChars->size() do ( (     var tmp : String ; tmp := dateChars[i+1] ;
         var c : String ; c := '0' ; while c <= '9' do ( (     dateChars[i+1] := c ; 
     var year : int ; year := ((dateChars)->sum() )->toInteger() ;
     if (year <= 2011 & year >= previousDate & year < min) then (     min := year ) else skip )  ;     c := c + 1 ) ; 
     dateChars[i+1] := tmp )  ;     i := i + 1 ) ; 
     return min );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var dates : Sequence(int) ; dates := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     dates[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var newDates : Sequence(int) ; newDates := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     newDates[i+1] := changeDate(dates[i+1], if i = 0 then 1000 else newDates[i - 1+1] endif) )  ;     i := i + 1 ) ; 
    if (not(valid(newDates))) then (     OclFile["System.out"].println("No solution") ) else (     for (date : newDates) do ( (     OclFile["System.out"].println(date) )  ) ) ;  
    skip ; 
OclProcess.exit(0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class suffix {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int i,c=0 ;
    String s,t,w ;
    s=sc.next();
    t=sc.next();
    if(t.length()>s.length()){
      System.out.println("need tree");
      System.exit(0);
    }
    w=s ;
    for(i=0 ; i<t.length(); i++){
      if(w.indexOf(t.charAt(i))!=-1)w=w.substring(0,w.indexOf(t.charAt(i)))+w.substring(w.indexOf(t.charAt(i))+1);
      else break ;
    }
    if(i!=t.length()){
      System.out.println("need tree");
      System.exit(0);
    }
    c=0 ;
    for(i=0 ; i<s.length(); i++){
      if(s.charAt(i)==t.charAt(c))c++;
      if(c==t.length())break ;
    }
    if(c==t.length())System.out.println("automaton");
    else if(t.length()==s.length())System.out.println("array");
    else System.out.println("both");
  }
}
------------------------------------------------------------
OCL File:
---------
 class suffix {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ;
    var c : int ; c := 0 ;
    var s : String ;
    var t : String ;
    var w : String ;
    s := sc.getCurrent() ; 
    t := sc.getCurrent() ; 
    if (t->size() > s->size()) then (     OclFile["System.out"].println("need tree") ; 
 OclProcess.exit(0) ) else skip ; 
    w := s ; 
        i := 0 ; while i < t->size() do ( (     if (w->indexOf(t->at(i+1))-1 /= -1) then     w := w.subrange(0+1,w->indexOf(t->at(i+1))-1) + w.subrange(w->indexOf(t->at(i+1))-1 + 1+1,w->indexOf(t->at(i+1))-1 + 1) ; else     break )  ;     i := i + 1 ) ; 
    if (i /= t->size()) then (     OclFile["System.out"].println("need tree") ; 
 OclProcess.exit(0) ) else skip ; 
    c := 0 ; 
        i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = t->at(c+1)) then     c := c + 1 ; else skip ; 
     if (c = t->size()) then     break else skip )  ;     i := i + 1 ) ; 
    if (c = t->size()) then     OclFile["System.out"].println("automaton") else     if (t->size() = s->size()) then     OclFile["System.out"].println("array") else     OclFile["System.out"].println("both") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class LC {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String t=sc.next();
    fun(s,t);
  }
  static void fun(String s,String t){
    boolean auto=false ;
    boolean arr=false ;
    Map<Character,Integer>sm=new HashMap<>();
    Map<Character,Integer>tm=new HashMap<>();
    for(int i=0 ; i<s.length(); i++){
      sm.put(s.charAt(i),sm.getOrDefault(s.charAt(i),0)+1);
    }
    for(int i=0 ; i<t.length(); i++){
      tm.put(t.charAt(i),tm.getOrDefault(t.charAt(i),0)+1);
    }
    for(Map.Entry<Character,Integer>e : tm.entrySet()){
      if(! sm.containsKey(e.getKey())|| e.getValue()>sm.get(e.getKey())){
        System.out.println("need tree");
        return ;
      }
      else if(e.getValue()<sm.get(e.getKey()))auto=true ;
    }
    if(s.length()>t.length())auto=true ;
    int pos=0,i=0 ;
    while(i<s.length()){
      if(s.charAt(i)==t.charAt(pos))pos++;
      if(pos==t.length())break ;
      i++;
    }
    if(pos!=t.length())arr=true ;
    if(auto && arr)System.out.println("both");
    else if(arr)System.out.println("array");
    else System.out.println("automaton");
  }
}
------------------------------------------------------------
OCL File:
---------
 class LC {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
     var t : String ; t := sc.getCurrent() ;
     execute fun(s, t) );
  static   operation fun( s : String, t : String) : void
  pre: true
  post: true
  activity: (     var auto : boolean ; auto := false ;
     var arr : boolean ; arr := false ;
    var sm : Map(String,int) ; sm := Map{} ;
    var tm : Map(String,int) ; tm := Map{} ;
        var i : int ; i := 0 ; while i < s->size() do ( (     sm := sm->union(Map{s->at(i+1) |-> (if sm->keys()->contains(s->at(i+1)) then sm->at(s->at(i+1)) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < t->size() do ( (     tm := tm->union(Map{t->at(i+1) |-> (if tm->keys()->contains(t->at(i+1)) then tm->at(t->at(i+1)) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    for (e : tm->asSet()) do ( (     if (not(sm->keys()->includes(e.getKey())) or e.getValue() > sm->at(e.getKey())) then (     OclFile["System.out"].println("need tree") ; 
     return ) else     if (e.getValue() < sm->at(e.getKey())) then     auto := true ; else skip ; )  ) ; 
    if (s->size() > t->size()) then     auto := true ; else skip ; 
    var pos : int ; pos := 0 ;
    var i : int ; i := 0 ;
    while (i < s->size()) do (     if (s->at(i+1) = t->at(pos+1)) then     pos := pos + 1 ; else skip ; 
     if (pos = t->size()) then     break else skip ; 
     i := i + 1 ) ; 
    if (pos /= t->size()) then     arr := true ; else skip ; 
    if (auto & arr) then     OclFile["System.out"].println("both") else     if (arr) then     OclFile["System.out"].println("array") else     OclFile["System.out"].println("automaton") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    String str1=scn.next();
    String str2=scn.next();
    int[] arr=new int[26];
    for(int i=0 ; i<str1.length(); i++){
      arr[str1.charAt(i)-'a']++;
    }
    for(int i=0 ; i<str2.length(); i++){
      arr[str2.charAt(i)-'a']--;
      if(arr[str2.charAt(i)-'a']<0){
        System.out.println("need tree");
        return ;
      }
    }
    if(str1.length()==str2.length()){
      System.out.println("array");
      return ;
    }
    int x=0,y=0 ;
    while(x<str1.length()&& y<str2.length()){
      if(str1.charAt(x)==str2.charAt(y)){
        y++;
      }
      x++;
    }
    if(y==str2.length()){
      System.out.println("automaton");
      return ;
    }
    System.out.println("both");
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str1 : String ; str1 := scn.getCurrent() ;
    var str2 : String ; str2 := scn.getCurrent() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < str1->size() do ( (     arr[str1->at(i+1) - ('a')->char2byte()+1] := arr[str1->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < str2->size() do ( (     arr[str2->at(i+1) - ('a')->char2byte()+1] := arr[str2->at(i+1) - ('a')->char2byte()+1] - 1 ; 
     if (arr[str2->at(i+1) - ('a')->char2byte()+1] < 0) then (     OclFile["System.out"].println("need tree") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    if (str1->size() = str2->size()) then (     OclFile["System.out"].println("array") ; 
     return ) else skip ; 
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    while (x < str1->size() & y < str2->size()) do (     if (str1->at(x+1) = str2->at(y+1)) then (     y := y + 1 ) else skip ; 
     x := x + 1 ) ; 
    if (y = str2->size()) then (     OclFile["System.out"].println("automaton") ; 
     return ) else skip ; 
    OclFile["System.out"].println("both") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Rectangle {
  static int count(int N){
    int a=0 ;
    a=(N*(N+1))/2 ;
    return a ;
  }
  public static void main(String args[]){
    int n=4 ;
    System.out.print(count(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class Rectangle {
  static   operation count( N : int) : int
  pre: true
  post: true
  activity: (     var a : int ; a := 0 ;
     a := (N * (N + 1)) / 2 ; 
     return a );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].print(count(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean checkPrime(String number){
    int num=Integer.valueOf(number);
    for(int i=2 ; i*i<=num ; i++)if((num % i)==0)return false ;
    return true ;
  }
  static int splitIntoPrimes(String number){
    if(number.length()==0)return 0 ;
    if(number.length()<=6 && checkPrime(number))return 1 ;
    else {
      int numLen=number.length();
      int ans=1000000 ;
      for(int i=1 ; i<=6 && i<=numLen ; i++){
        if(checkPrime(number.substring(0,i))){
          int val=splitIntoPrimes(number.substring(i));
          if(val!=-1){
            ans=Math.min(ans,1+val);
          }
        }
      }
      if(ans==1000000)return-1 ;
      return ans ;
    }
  }
  public static void main(String[] args){
    System.out.print(splitIntoPrimes("13499315")+"\n");
    System.out.print(splitIntoPrimes("43")+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkPrime( number : String) : boolean
  pre: true
  post: true
  activity: (     var num : int ; num := (number)->toInteger() ;
         var i : int ; i := 2 ; while i * i <= num do (     if ((num mod i) = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation splitIntoPrimes( number : String) : int
  pre: true
  post: true
  activity: (     if (number->size() = 0) then     return 0 else skip ; 
     if (number->size() <= 6 & checkPrime(number)) then     return 1 else (     var numLen : int ; numLen := number->size() ;
     var ans : int ; ans := 1000000 ;
        var i : int ; i := 1 ; while i <= 6 & i <= numLen do ( (     if (checkPrime(number.subrange(0+1,i))) then (     var val : int ; val := splitIntoPrimes(number.subrange(i+1,i)) ;
     if (val /= -1) then (     ans := Set{ans, 1 + val}->min() ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (ans = 1000000) then     return -1 else skip ; 
    return ans 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(splitIntoPrimes("13499315") + "\n") ; 
     OclFile["System.out"].print(splitIntoPrimes("43") + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Practice {
  static Scanner scn=new Scanner(System.in);
  static StringBuilder sb=new StringBuilder();
  public static void main(String[] ScoobyDoobyDo){
    int n=1 ;
    for(int i=0 ; i<n ; i++)solve();
    System.out.println(sb);
  }
  public static void solve(){
    int n=scn.nextInt();
    char[] ch=scn.next().toCharArray();
    boolean[] bool=new boolean[n];
    List<Integer>r=new ArrayList<>(),l=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      if(ch[i]=='L')l.add(i);
      else if(ch[i]=='R')r.add(i);
    }
    int res=0 ;
    outer : for(int right : r){
      for(int left : l){
        if(bool[left])continue ;
        if(left>right){
          int d=left-right ;
          if(d % 2==0)res++;
          int i1=right,i2=left ;
          while(i1<=i2){
            bool[i1]=true ;
            bool[i2]=true ;
            i1++;
            i2--;
          }
          continue outer ;
        }
      }
    }
    for(int right : r){
      if(bool[right])continue ;
      int i1=right ;
      while(i1<n){
        bool[i1]=true ;
        i1++;
      }
    }
    for(int left : l){
      if(bool[left])continue ;
      int i1=left ;
      while(i1>=0){
        bool[i1]=true ;
        i1--;
      }
    }
    for(int i=0 ; i<n ; i++)if(! bool[i])res++;
    sb.append(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   attribute scn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute sb : String := StringLib.newString();
  static   operation main( ScoobyDoobyDo : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1 ;
         var i : int ; i := 0 ; while i < n do (     execute solve() ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sb) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := scn.getCurrent()->toInteger() ;
     var ch : Sequence(String) ; ch := scn.getCurrent()->characters() ;
    var bool : Sequence(boolean) ; bool := Integer.subrange(1,n)->collect(false) ;
    var r : Sequence(int) ; r := Sequence{} ;
    var l : Sequence(int) ; l := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (ch[i+1] = 'L') then     l->excludes(i) ; else     if (ch[i+1] = 'R') then     r := r->including(i) ; else skip ; )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    for (right : r) do ( (     for (left : l) do ( (     if (bool[left+1]) then     continue else skip ; 
     if (left > right) then (     var d : int ; d := left - right ;
     if (d mod 2 = 0) then     res := res + 1 ; else skip ; 
    var i1 : int ; i1 := right ;
    var i2 : int ; i2 := left ;
    while (i1 <= i2) do (     bool[i1+1] := true ; 
     bool[i2+1] := true ; 
     i1 := i1 + 1 ; 
     i2 := i2 - 1 ) ; 
    continue 
 ) else skip )  ) )  ) ; 
    for (right : r) do ( (     if (bool[right+1]) then     continue else skip ; 
     var i1 : int ; i1 := right ;
     while (i1 < n) do (     bool[i1+1] := true ; 
     i1 := i1 + 1 ) )  ) ; 
    for (left : l) do ( (     if (bool[left+1]) then     continue else skip ; 
     var i1 : int ; i1 := left ;
     while (i1 >= 0) do (     bool[i1+1] := true ; 
     i1 := i1 - 1 ) )  ) ; 
        var i : int ; i := 0 ; while i < n do (     if (not(bool[i+1])) then     res := res + 1 ; else skip ;  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean Prime(int n){
    if(n==1)return false ;
    for(int i=2 ; i*i<=n ; i++)if(n % i==0)return false ;
    return true ;
  }
  static boolean checkSumPrime(String str){
    int summ=0 ;
    for(int i=1 ; i<str.length(); i++)summ+=Math.abs(str.charAt(i-1)-str.charAt(i));
    if(Prime(summ))return true ;
    else return false ;
  }
  public static void main(String[] args){
    int num=142 ;
    String str="142" ;
    if(checkSumPrime(str))System.out.println("Prime");
    else System.out.println("Not Prime");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Prime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 1) then     return false else skip ; 
         var i : int ; i := 2 ; while i * i <= n do (     if (n mod i = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation checkSumPrime( str : String) : boolean
  pre: true
  post: true
  activity: (     var summ : int ; summ := 0 ;
         var i : int ; i := 1 ; while i < str->size() do (     summ := summ+(if str->at(i - 1+1) - str->at(i+1) < 0 then -(str->at(i - 1+1) - str->at(i+1)) else str->at(i - 1+1) - str->at(i+1) endif) ;  ;     i := i + 1 ) ; 
     if (Prime(summ)) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 142 ;
     var str : String ; str := "142" ;
     if (checkSumPrime(str)) then     OclFile["System.out"].println("Prime") ; else     OclFile["System.out"].println("Not Prime") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int counter=scanner.nextInt();
    final int diff=scanner.nextInt();
    final int[] trees=new int[counter];
    for(int i=0 ; i<counter ; i++){
      trees[i]=scanner.nextInt();
    }
    Arrays.sort(trees);
    final int[] diffs=new int[counter-diff+1];
    for(int i=0 ; i<counter-diff+1 ; i++){
      diffs[i]=trees[i+diff-1]-trees[i];
    }
    System.out.println(min(diffs));
  }
  public static int min(int[] array){
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<array.length ; i++){
      if(array[i]<min){
        min=array[i];
      }
    }
    return min ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var counter : int ; counter := scanner.getCurrent()->toInteger() ;
    var diff : int ; diff := scanner.getCurrent()->toInteger() ;
    var trees : Sequence(int) ; trees := Integer.subrange(1,counter)->collect(0) ;
        var i : int ; i := 0 ; while i < counter do ( (     trees[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    trees := trees->sort() ; 
    var diffs : Sequence(int) ; diffs := Integer.subrange(1,counter - diff + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < counter - diff + 1 do ( (     diffs[i+1] := trees[i + diff - 1+1] - trees[i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{diffs}->min()) ; 
 );
  static   operation min( array : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var min : int ; min := 2147483647 ;
         var i : int ; i := 0 ; while i < array->size() do ( (     if (array[i+1] < min) then (     min := array[i+1] ) else skip )  ;     i := i + 1 ) ; 
     return min );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B405 {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int N=input.nextInt();
    String s=input.next();
    int answer=0 ;
    int lastL=-1 ;
    int lastR=-2 ;
    for(int n=0 ; n<N ; n++){
      char c=s.charAt(n);
      if(c=='L'){
        lastL=n ;
        if(lastR!=-2){
          if((lastL-lastR)% 2==0){
            answer++;
          }
        }
      }
      else if(c=='R'){
        answer+=n-lastL-1 ;
        lastR=n ;
      }
    }
    if(lastR<lastL){
      answer+=N-lastL-1 ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B405 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := input.getCurrent()->toInteger() ;
    var s : String ; s := input.getCurrent() ;
    var answer : int ; answer := 0 ;
    var lastL : int ; lastL := -1 ;
    var lastR : int ; lastR := -2 ;
        var n : int ; n := 0 ; while n < N do ( (     var c : String ; c := s->at(n+1) ;
     if (c = 'L') then (     lastL := n ; 
     if (lastR /= -2) then (     if ((lastL - lastR) mod 2 = 0) then (     answer := answer + 1 ) else skip ) else skip ) else     if (c = 'R') then (     answer := answer+(n - lastL - 1) ; 
     lastR := n ) else skip ; )  ;     n := n + 1 ) ; 
    if (lastR < lastL) then (     answer := answer+(N - lastL - 1) ) else skip ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    int[] ans=getPermutation(n,k);
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<ans.length ; i++){
      sb.append(ans[i]).append(" ");
    }
    System.out.println(sb);
  }
  public static int[] getPermutation(int n,int k){
    int[] ans=new int[2*n];
    int idx=0 ;
    while(idx<k){
      ans[2*idx]=2*idx+2 ;
      ans[2*idx+1]=2*idx+1 ;
      idx++;
    }
    while(idx<n){
      ans[2*idx]=2*idx+1 ;
      ans[2*idx+1]=2*idx+2 ;
      idx++;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var ans : Sequence(int) ; ans := getPermutation(n, k) ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < ans->size() do ( (     sb := sb + StringLib.newString(ans[i+1]) + StringLib.newString(" ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
  static   operation getPermutation( n : int, k : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Integer.subrange(1,2 * n)->collect(0) ;
     var idx : int ; idx := 0 ;
    while (idx < k) do (     ans[2 * idx+1] := 2 * idx + 2 ; 
     ans[2 * idx + 1+1] := 2 * idx + 1 ; 
     idx := idx + 1 ) ; 
    while (idx < n) do (     ans[2 * idx+1] := 2 * idx + 1 ; 
     ans[2 * idx + 1+1] := 2 * idx + 2 ; 
     idx := idx + 1 ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Permutation {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int k=s.nextInt();
    List<Integer>permutation=new ArrayList<>();
    if(k==0){
      for(int i=1 ; i<=2*n ; i++){
        permutation.add(i);
      }
    }
    else {
      permutation.add(k+1);
      permutation.add(1);
      for(int i=2 ; i<2*n ; i++){
        if(i>=k+1){
          permutation.add(i+1);
        }
        else {
          permutation.add(i);
        }
      }
    }
    for(Integer i : permutation){
      if(i==2*n){
        System.out.print(i);
      }
      else {
        System.out.print(i+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Permutation {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var k : int ; k := s.getCurrent()->toInteger() ;
    var permutation : Sequence(int) ; permutation := Sequence{} ;
    if (k = 0) then (         var i : int ; i := 1 ; while i <= 2 * n do ( (     permutation := permutation->including(i) )  ;     i := i + 1 ) ) else (     permutation := permutation->including(k + 1) ; 
     permutation := permutation->including(1) ; 
         var i : int ; i := 2 ; while i < 2 * n do ( (     if (i >= k + 1) then (     permutation := permutation->including(i + 1) ) else (     permutation := permutation->including(i) ) )  ;     i := i + 1 ) ) ;  
    for (i : permutation) do ( (     if (i = 2 * n) then (     OclFile["System.out"].print(i) ) else (     OclFile["System.out"].print(i + " ") ) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CF359B {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt()*2,k=sc.nextInt(),ar[]=new int[n];
    for(int i=0 ; i<n ; i++)ar[i]=i+1 ;
    for(int i=0 ; i<k*2 ; i+=2){
      int t=ar[i];
      ar[i]=ar[i+1];
      ar[i+1]=t ;
    }
    for(int x : ar)System.out.print(x+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF359B {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() * 2 ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var ar : Sequence(void) ; ar := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     ar[i+1] := i + 1 ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < k * 2 do ( (     var t : int ; t := ar[i+1] ;
     ar[i+1] := ar[i + 1+1] ; 
     ar[i + 1+1] := t )  ;     i := i+(2) ) ; 
     for (x : ar) do (     OclFile["System.out"].print(x + " ") ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Test {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    ArrayList<Integer>list=new ArrayList<>();
    int col=1 ;
    while(k-->0){
      list.add(col);
      col++;
      list.add(col);
      col++;
      list.add(col+1);
      list.add(col);
      col+=2 ;
    }
    for(int i=col-1 ; i<(2*n); i+=2){
      list.add(col);
      list.add(col+1);
      col+=2 ;
    }
    for(int i=0 ; i<(2*n); i++)System.out.print(list.get(i)+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
    var col : int ; col := 1 ;
        while (k > 0) do (        k := k - 1 ;     skip ; (     list := list->including(col) ; 
     col := col + 1 ; 
    list := list->including(col) ; 
    col := col + 1 ; 
    list := list->including(col + 1) ; 
    list := list->including(col) ; 
    col := col+(2) ; 
 ) ;  ) ;  
        var i : int ; i := col - 1 ; while i < (2 * n) do ( (     list := list->including(col) ; 
     list := list->including(col + 1) ; 
     col := col+(2) )  ;     i := i+(2) ) ; 
        var i : int ; i := 0 ; while i < (2 * n) do (     OclFile["System.out"].print(list->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int N=4 ;
  static final int M=4 ;
  static boolean isPairWithDiff(int mat[][],int k){
    HashSet<Integer>s=new HashSet<Integer>();
    for(int i=0 ; i<N ; i++)for(int j=0 ; j<M ; j++)s.add(mat[i][j]);
    for(int i=0 ; i<N ; i++)for(int j=0 ; j<M ; j++)if(s.contains(k+mat[i][j])&& k+mat[i][j]!=(int)s.toArray()[s.size()-1])return true ;
    return false ;
  }
  public static void main(String[] args){
    int mat[][]={
      {
        5,2,3,4 },{
          5,6,7,8 },{
            9,10,11,12 },{
              13,14,15,100 }
            };
            int k=85 ;
            System.out.println(isPairWithDiff(mat,k)==true ? "YES" : "NO");
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute N : int := 4;
  static    attribute M : int := 4;
  static   operation isPairWithDiff( mat : Sequence(Sequence(int)), k : int) : boolean
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
         var i : int ; i := 0 ; while i < N do (         var j : int ; j := 0 ; while j < M do (     s := s->including(mat[i+1][j+1]) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < N do (         var j : int ; j := 0 ; while j < M do (     if (s->includes(k + mat[i+1][j+1]) & k + mat[i+1][j+1] /= s->asSequence()[s->size() - 1+1]->oclAsType(int)) then     return true else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{5,2,3,4},Sequence{5,6,7,8},Sequence{9,10,11,12},Sequence{13,14,15,100}} ;
     var k : int ; k := 85 ;
     OclFile["System.out"].println(if isPairWithDiff(mat, k) = true then "YES" else "NO" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
public class Count_Subsequences {
  static final int MAX_CHAR=256 ;
  static int countSub(String str){
    int[] last=new int[MAX_CHAR];
    Arrays.fill(last,-1);
    int n=str.length();
    int[] dp=new int[n+1];
    dp[0]=1 ;
    for(int i=1 ; i<=n ; i++){
      dp[i]=2*dp[i-1];
      if(last[(int)str.charAt(i-1)]!=-1)dp[i]=dp[i]-dp[last[(int)str.charAt(i-1)] ];
      last[(int)str.charAt(i-1)]=(i-1);
    }
    return dp[n];
  }
  public static void main(String args[]){
    System.out.println(countSub("gfg"));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Count_Subsequences {
  static    attribute MAX_CHAR : int := 256;
  static   operation countSub( str : String) : int
  pre: true
  post: true
  activity: (     var last : Sequence(int) ; last := Integer.subrange(1,MAX_CHAR)->collect(0) ;
     last := last->collect(-1) ; 
    var n : int ; n := str->size() ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
    dp[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do ( (     dp[i+1] := 2 * dp[i - 1+1] ; 
     if (last[str->at(i - 1+1)->oclAsType(int)+1] /= -1) then     dp[i+1] := dp[i+1] - dp[last[str->at(i - 1+1)->oclAsType(int)+1]+1] ; else skip ; 
     last[str->at(i - 1+1)->oclAsType(int)+1] := (i - 1) )  ;     i := i + 1 ) ; 
    return dp[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(countSub("gfg")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minCost(int N,int P,int Q){
    int cost=0 ;
    while(N>0){
      if((N & 1)>0){
        cost+=P ;
        N--;
      }
      else {
        int temp=N/2 ;
        if(temp*P>Q)cost+=Q ;
        else cost+=P*temp ;
        N/=2 ;
      }
    }
    return cost ;
  }
  public static void main(String[] args){
    int N=9,P=5,Q=1 ;
    System.out.println(minCost(N,P,Q));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minCost( N : int, P : int, Q : int) : int
  pre: true
  post: true
  activity: (     var cost : int ; cost := 0 ;
     while (N > 0) do (     if ((N & 1) > 0) then (     cost := cost+(P) ; 
     N := N - 1 ) else (     var temp : int ; temp := N / 2 ;
     if (temp * P > Q) then     cost := cost+(Q) else     cost := cost+(P * temp) ; ;  
     N := N/(2) ) ) ; 
     return cost );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 9 ;
    var P : int ; P := 5 ;
    var Q : int ; Q := 1 ;
     OclFile["System.out"].println(minCost(N, P, Q)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isSafe(int x,int y){
    return(x<4 && y<3);
  }
  static int minJump(int height[][],int x,int y){
    if(x==4-1 && y==3-1)return 0 ;
    int diag=Integer.MAX_VALUE ;
    if(isSafe(x+1,y+1))diag=minJump(height,x+1,y+1)+Math.abs(height[x][y]-height[x+1][y+1]);
    int down=Integer.MAX_VALUE ;
    if(isSafe(x+1,y))down=minJump(height,x+1,y)+Math.abs(height[x][y]-height[x+1][y]);
    int right=Integer.MAX_VALUE ;
    if(isSafe(x,y+1))right=minJump(height,x,y+1)+Math.abs(height[x][y]-height[x][y+1]);
    return Math.min(down,Math.min(right,diag));
  }
  public static void main(String[] args){
    int height[][]={
      {
        5,4,2 },{
          9,2,1 },{
            2,5,9 },{
              1,3,11 }
            };
            System.out.println(minJump(height,0,0));
          }
        }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isSafe( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return (x < 4 & y < 3) );
  static   operation minJump( height : Sequence(Sequence(int)), x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (x = 4 - 1 & y = 3 - 1) then     return 0 else skip ; 
     var diag : int ; diag := 2147483647 ;
    if (isSafe(x + 1, y + 1)) then     diag := minJump(height, x + 1, y + 1) + if height[x+1][y+1] - height[x + 1+1][y + 1+1] < 0 then -(height[x+1][y+1] - height[x + 1+1][y + 1+1]) else height[x+1][y+1] - height[x + 1+1][y + 1+1] endif ; else skip ; 
    var down : int ; down := 2147483647 ;
    if (isSafe(x + 1, y)) then     down := minJump(height, x + 1, y) + if height[x+1][y+1] - height[x + 1+1][y+1] < 0 then -(height[x+1][y+1] - height[x + 1+1][y+1]) else height[x+1][y+1] - height[x + 1+1][y+1] endif ; else skip ; 
    var right : int ; right := 2147483647 ;
    if (isSafe(x, y + 1)) then     right := minJump(height, x, y + 1) + if height[x+1][y+1] - height[x+1][y + 1+1] < 0 then -(height[x+1][y+1] - height[x+1][y + 1+1]) else height[x+1][y+1] - height[x+1][y + 1+1] endif ; else skip ; 
    return Set{down, Set{right, diag}->min()}->min() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var height : Sequence(Sequence(int)) ; height := Sequence{Sequence{5,4,2},Sequence{9,2,1},Sequence{2,5,9},Sequence{1,3,11}} ;
     OclFile["System.out"].println(minJump(height, 0, 0)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  float sum(float n){
    if(n<2)return 1 ;
    else return 1/n+(sum(n-1));
  }
  public static void main(String args[]){
    GFG g=new GFG();
    System.out.println(g.sum(8));
    System.out.print(g.sum(10));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
   operation sum( n : double) : double
  pre: true
  post: true
  activity: (     if (n < 2) then     return 1 else     return 1 / n + (sum(n - 1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : GFG ; g := GFG.newGFG() ;
     OclFile["System.out"].println(g.sum(8)) ; 
     OclFile["System.out"].print(g.sum(10)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public void decisionmain(int n,int game[][],int result[][]){
    for(int j=0 ; j<3 ; j++){
      for(int i=0 ; i<n ; i++){
        for(int k=0 ; k<n ; k++){
          decisionsub(i,j,k,game,result);
        }
      }
    }
  }
  public void decisionsub(int i,int j,int k,int game[][],int result[][]){
    if(k!=i){
      if(game[i][j]==game[k][j]){
        result[i][j]=0 ;
      }
    }
  }
  public void scoresum(int n,int result[][]){
    for(int i=0 ; i<n ; i++){
      int sum=0 ;
      for(int j=0 ; j<3 ; j++){
        sum+=result[i][j];
      }
      System.out.println(sum);
    }
  }
  void doIt(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[][] game=new int[n][3];
    int[][] result=new int[n][3];
    int i,j ;
    for(i=0 ; i<n ; i++){
      for(j=0 ; j<3 ; j++){
        game[i][j]=sc.nextInt();
        result[i][j]=game[i][j];
      }
    }
    decisionmain(n,game,result);
    scoresum(n,result);
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation decisionmain( n : int, game : Sequence(Sequence(int)), result : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var j : int ; j := 0 ; while j < 3 do ( (         var i : int ; i := 0 ; while i < n do ( (         var k : int ; k := 0 ; while k < n do ( (     execute decisionsub(i, j, k, game, result) )  ;     k := k + 1 ) )  ;     i := i + 1 ) )  ;     j := j + 1 ) );
   operation decisionsub( i : int, j : int, k : int, game : Sequence(Sequence(int)), result : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     if (k /= i) then (     if (game[i+1][j+1] = game[k+1][j+1]) then (     result[i+1][j+1] := 0 ) else skip ) else skip );
   operation scoresum( n : int, result : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < 3 do ( (     sum := sum+(result[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(sum) )  ;     i := i + 1 ) );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var game : Sequence(Sequence(int)) ; game := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(0)) ;
    var result : Sequence(Sequence(int)) ; result := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(0)) ;
    var i : int ;
    var j : int ;
        i := 0 ; while i < n do ( (         j := 0 ; while j < 3 do ( (     game[i+1][j+1] := sc.getCurrent()->toInteger() ; 
     result[i+1][j+1] := game[i+1][j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    execute decisionmain(n, game, result) ; 
    execute scoresum(n, result) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Collections ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] ar=new int[n];
    int[] abs=new int[n-k+1];
    for(int i=0 ; i<n ; i++){
      ar[i]=sc.nextInt();
    }
    Arrays.sort(ar);
    for(int i=0 ; i<n-k+1 ; i++){
      abs[i]=ar[k-1+i]-ar[i];
    }
    int min=abs[0];
    for(int i=0 ; i<n-k+1 ; i++){
      if(abs[i]<min){
        min=abs[i];
      }
    }
    System.out.println(min);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
    var abs : Sequence(int) ; abs := Integer.subrange(1,n - k + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    ar := ar->sort() ; 
        var i : int ; i := 0 ; while i < n - k + 1 do ( (     abs[i+1] := ar[k - 1 + i+1] - ar[i+1] )  ;     i := i + 1 ) ; 
    var min : int ; min := abs[0+1] ;
        var i : int ; i := 0 ; while i < n - k + 1 do ( (     if (abs[i+1] < min) then (     min := abs[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=Integer.parseInt(line);
      short[][] occured=new short[3][101];
      short[][] choice=new short[n][3];
      short c1,c2,c3 ;
      StringTokenizer st ;
      for(int i=0 ; i<n ; i++){
        st=new StringTokenizer(br.readLine());
        c1=Short.parseShort(st.nextToken());
        c2=Short.parseShort(st.nextToken());
        c3=Short.parseShort(st.nextToken());
        occured[0][c1]++;
        occured[1][c2]++;
        occured[2][c3]++;
        choice[i][0]=c1 ;
        choice[i][1]=c2 ;
        choice[i][2]=c3 ;
      }
      short points ;
      StringBuilder sb=new StringBuilder();
      for(int i=0 ; i<n ; i++){
        points=0 ;
        for(int j=0 ; j<3 ; j++){
          if(occured[j][choice[i][j] ]<2){
            points+=choice[i][j];
          }
        }
        sb.append(points+"\n");
      }
      System.out.print(sb.toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := (line)->toInteger() ;
     var occured : Sequence(Sequence(int)) ; occured := Integer.subrange(1,3)->collect(Integer.subrange(1,101)->collect(0)) ;
    var choice : Sequence(Sequence(int)) ; choice := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(0)) ;
    var c1 : int ;
    var c2 : int ;
    var c3 : int ;
    var st : OclIterator ;
        var i : int ; i := 0 ; while i < n do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     c1 := (st.next())->toInteger() ; 
    c2 := (st.next())->toInteger() ; 
    c3 := (st.next())->toInteger() ; 
    occured[0+1][c1+1] := occured[0+1][c1+1] + 1 ; 
    occured[1+1][c2+1] := occured[1+1][c2+1] + 1 ; 
    occured[2+1][c3+1] := occured[2+1][c3+1] + 1 ; 
    choice[i+1][0+1] := c1 ; 
    choice[i+1][1+1] := c2 ; 
    choice[i+1][2+1] := c3 ; 
 )  ;     i := i + 1 ) ; 
    var points : int ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     points := 0 ; 
         var j : int ; j := 0 ; while j < 3 do ( (     if (occured[j+1][choice[i+1][j+1]+1] < 2) then (     points := points+(choice[i+1][j+1]) ) else skip )  ;     j := j + 1 ) ; 
     sb := sb + StringLib.newString(points + "\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      int n=scan.nextInt();
      UniqueNumber un=new UniqueNumber(n);
      un.input(scan,n);
      un.point(n);
      un.output(n);
    }
  }
}
class UniqueNumber {
  int[][] myNumber ;
  int[] myPoint ;
  public UniqueNumber(int n){
    myNumber=new int[n][3];
    myPoint=new int[n];
    for(int i=0 ; i<n ; i++){
      myPoint[i]=0 ;
    }
  }
  public void input(Scanner scan,int n){
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<3 ; j++){
        myNumber[i][j]=scan.nextInt();
      }
    }
  }
  public void output(int n){
    for(int i=0 ; i<n ; i++){
      System.out.println(myPoint[i]);
    }
  }
  public void point(int n){
    boolean flag ;
    for(int i=0 ; i<3 ; i++){
      for(int j=0 ; j<n ; j++){
        flag=true ;
        for(int k=0 ; k<n ; k++){
          if(j!=k){
            if(myNumber[j][i]==myNumber[k][i]){
              flag=false ;
              break ;
            }
          }
        }
        if(flag){
          myPoint[j]+=myNumber[j][i];
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var un : UniqueNumber ; un := UniqueNumber.newUniqueNumber(n) ;
    un.input(scan, n) ; 
    un.point(n) ; 
    un.output(n) ; 
 ) );
}
class UniqueNumber {
   attribute myNumber : Sequence(Sequence(int));
   attribute myPoint : Sequence(int);
   static operation newUniqueNumber( n : int) : UniqueNumber
  pre: true
  post: true
  activity:
  ( var self : UniqueNumber ;
    self := createUniqueNumber();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     myNumber := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(0)) ; 
     myPoint := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do ( (     myPoint[i+1] := 0 )  ;     i := i + 1 ) );
   operation input( scan : OclFile, n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 3 do ( (     myNumber[i+1][j+1] := scan.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
   operation output( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(myPoint[i+1]) )  ;     i := i + 1 ) );
   operation point( n : int) : void
  pre: true
  post: true
  activity: (     var flag : boolean ;
         var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < n do ( (     flag := true ; 
         var k : int ; k := 0 ; while k < n do ( (     if (j /= k) then (     if (myNumber[j+1][i+1] = myNumber[k+1][i+1]) then (     flag := false ; 
     break ) else skip ) else skip )  ;     k := k + 1 ) ; 
     if (flag) then (     myPoint[j+1] := myPoint[j+1]+(myNumber[j+1][i+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int[] namber=new int[200];
  public static int[] syokika(int[] namber){
    for(int i=0 ; i<namber.length ; i++){
      namber[i]=0 ;
    }
    return namber ;
  }
  public static int[][] hantei(int[][] array,int n,int j){
    int count=1 ;
    namber=syokika(namber);
    for(int k=1 ; k<n ; k++){
      for(int i=k+1 ; i<=n ; i++){
        if(array[k][j]==array[i][j]){
          namber[count]=array[k][j];
          count++;
        }
      }
    }
    for(int k=1 ; k<namber.length ; k++){
      for(int i=1 ; i<=n ; i++){
        if(namber[k]==array[i][j]){
          array[i][j]=0 ;
        }
      }
    }
    return array ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[][] array=new int[n+1][4];
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=3 ; j++){
        array[i][j]=sc.nextInt();
      }
    }
    for(int j=1 ; j<=3 ; j++){
      array=hantei(array,n,j);
    }
    for(int i=1 ; i<=n ; i++){
      int answer=0 ;
      for(int j=1 ; j<=3 ; j++){
        answer+=array[i][j];
      }
      System.out.println(answer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute namber : Sequence(int) := Integer.subrange(1,200)->collect(0);
  static   operation syokika( namber : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < namber->size() do ( (     namber[i+1] := 0 )  ;     i := i + 1 ) ; 
     return namber );
  static   operation hantei( array : Sequence(Sequence(int)), n : int, j : int) : Sequence(Sequence(int))
  pre: true
  post: true
  activity: (     var count : int ; count := 1 ;
     namber := syokika(namber) ; 
        var k : int ; k := 1 ; while k < n do ( (         var i : int ; i := k + 1 ; while i <= n do ( (     if (array[k+1][j+1] = array[i+1][j+1]) then (     namber[count+1] := array[k+1][j+1] ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
        var k : int ; k := 1 ; while k < namber->size() do ( (         var i : int ; i := 1 ; while i <= n do ( (     if (namber[k+1] = array[i+1][j+1]) then (     array[i+1][j+1] := 0 ) else skip )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    return array 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var array : Sequence(Sequence(int)) ; array := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,4)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= 3 do ( (     array[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var j : int ; j := 1 ; while j <= 3 do ( (     array := hantei(array, n, j) )  ;     j := j + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     var answer : int ; answer := 0 ;
         var j : int ; j := 1 ; while j <= 3 do ( (     answer := answer+(array[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(answer) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    int[] score=new int[n];
    int[][] scan=new int[n][];
    for(int i=0 ; i<n ; i++){
      scan[i]=new int[3];
      for(int j=0 ; j<3 ; j++){
        scan[i][j]=stdIn.nextInt();
      }
    }
    for(int i=0 ; i<3 ; i++){
      HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();
      int[] input=new int[n];
      for(int j=0 ; j<n ; j++){
        input[j]=scan[j][i];
        if(map.containsKey(input[j])){
          int value=map.get(input[j]);
          map.put(input[j],++value);
        }
        else {
          map.put(input[j],1);
        }
      }
      for(int j=0 ; j<n ; j++){
        if(map.get(input[j])==1){
          score[j]+=input[j];
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      System.out.println(score[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var score : Sequence(int) ; score := Integer.subrange(1,n)->collect(0) ;
    var scan : Sequence(Sequence(int)) ; scan := Integer.subrange(1,n)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < n do ( (     scan[i+1] := Integer.subrange(1,3)->collect(0) ; 
         var j : int ; j := 0 ; while j < 3 do ( (     scan[i+1][j+1] := stdIn.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do ( (     var map : Map(int,int) ; map := Map{} ;
     var input : Sequence(int) ; input := Integer.subrange(1,n)->collect(0) ;
         var j : int ; j := 0 ; while j < n do ( (     input[j+1] := scan[j+1][i+1] ; 
     if (map->keys()->includes(input[j+1])) then (     var value : int ; value := map->at(input[j+1]) ;
     map := map->union(Map{input[j+1] |-> (value + 1)}) ) else (     map := map->union(Map{input[j+1] |-> 1}) ) )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < n do ( (     if (map->at(input[j+1]) = 1) then (     score[j+1] := score[j+1]+(input[j+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(score[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  final static int size=10001 ;
  static int prime[]=new int[size];
  static int freq[]=new int[size];
  static void sieve(int a,int b){
    prime[1]=1 ;
    for(int i=2 ; i*i<size ; i++){
      if(prime[i]==0){
        for(int j=i*2 ; j<size ; j+=i)prime[j]=1 ;
      }
    }
    for(int p=1 ; p<size ; p++){
      for(int q=1 ; q<size ; q++){
        if(prime[p]==0 && prime[q]==0 && a*p+b*q<size){
          freq[a*p+b*q]++;
        }
      }
    }
  }
  public static void main(String[] args){
    int queries=2,a=1,b=2 ;
    sieve(a,b);
    int arr[]={
      15,25 };
      for(int i=0 ; i<queries ; i++){
        System.out.print(freq[arr[i] ]+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute size : int := 10001;
  static   attribute prime : int := Integer.subrange(1,size)->collect(0);
  static   attribute freq : int := Integer.subrange(1,size)->collect(0);
  static   operation sieve( a : int, b : int) : void
  pre: true
  post: true
  activity: (     prime[1+1] := 1 ; 
         var i : int ; i := 2 ; while i * i < size do ( (     if (prime[i+1] = 0) then (         var j : int ; j := i * 2 ; while j < size do (     prime[j+1] := 1 ;  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
         var p : int ; p := 1 ; while p < size do ( (         var q : int ; q := 1 ; while q < size do ( (     if (prime[p+1] = 0 & prime[q+1] = 0 & a * p + b * q < size) then (     freq[a * p + b * q+1] := freq[a * p + b * q+1] + 1 ) else skip )  ;     q := q + 1 ) )  ;     p := p + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var queries : int ; queries := 2 ;
    var a : int ; a := 1 ;
    var b : int ; b := 2 ;
     execute sieve(a, b) ; 
     var arr : Sequence(int) ; arr := Sequence{15,25} ;
         var i : int ; i := 0 ; while i < queries do ( (     OclFile["System.out"].print(freq[arr[i+1]+1] + " ") )  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class T1553B_2 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int q=Integer.parseInt(in.nextLine());
    for(int i=0 ; i<q ; i++){
      s=in.nextLine();
      t=in.nextLine();
      boolean result=false ;
      for(int j=0 ; j<s.length(); j++){
        result=search(j,0,true);
        if(result)break ;
      }
      if(result){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
  private static String s ;
  private static String t ;
  private static boolean search(int indexS,int indexT,boolean right){
    if(s.charAt(indexS)!=t.charAt(indexT)){
      return false ;
    }
    if(indexT+1==t.length()){
      return true ;
    }
    if(right && indexS+1<s.length()){
      if(search(indexS+1,indexT+1,true)){
        return true ;
      }
    }
    if(indexS>0){
      if(search(indexS-1,indexT+1,false)){
        return true ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class T1553B{
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := (in.nextLine())->toInteger() ;
         var i : int ; i := 0 ; while i < q do ( (     s := in.nextLine() ; 
     t := in.nextLine() ; 
    var result : boolean ; result := false ;
        var j : int ; j := 0 ; while j < s->size() do ( (     result := search(j, 0, true) ; 
     if (result) then     break else skip )  ;     j := j + 1 ) ; 
    if (result) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     i := i + 1 ) );
  static   attribute s : String;
  static   attribute t : String;
  static   operation search( indexS : int, indexT : int, right : boolean) : boolean
  pre: true
  post: true
  activity: (     if (s->at(indexS+1) /= t->at(indexT+1)) then (     return false ) else skip ; 
     if (indexT + 1 = t->size()) then (     return true ) else skip ; 
    if (right & indexS + 1 < s->size()) then (     if (search(indexS + 1, indexT + 1, true)) then (     return true ) else skip ) else skip ; 
    if (indexS > 0) then (     if (search(indexS - 1, indexT + 1, false)) then (     return true ) else skip ) else skip ; 
    return false 
 );
}
 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := (in.nextLine())->toInteger() ;
         var i : int ; i := 0 ; while i < q do ( (     s := in.nextLine() ; 
     t := in.nextLine() ; 
    var result : boolean ; result := false ;
        var j : int ; j := 0 ; while j < s->size() do ( (     result := search(j, 0, true) ; 
     if (result) then     break else skip )  ;     j := j + 1 ) ; 
    if (result) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     i := i + 1 ) );
  static   attribute s : String;
  static   attribute t : String;
  static   operation search( indexS : int, indexT : int, right : boolean) : boolean
  pre: true
  post: true
  activity: (     if (s->at(indexS+1) /= t->at(indexT+1)) then (     return false ) else skip ; 
     if (indexT + 1 = t->size()) then (     return true ) else skip ; 
    if (right & indexS + 1 < s->size()) then (     if (search(indexS + 1, indexT + 1, true)) then (     return true ) else skip ) else skip ; 
    if (indexS > 0) then (     if (search(indexS - 1, indexT + 1, false)) then (     return true ) else skip ) else skip ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int edgeCover(int n){
    int result=0 ;
    result=(int)Math.ceil((double)n/2.0);
    return result ;
  }
  public static void main(String args[]){
    int n=5 ;
    System.out.print(edgeCover(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation edgeCover( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     result := (n->oclAsType(double) / 2.0)->ceil()->oclAsType(int) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].print(edgeCover(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printSeries(int n){
    for(int i=1 ; i<=n ; i++){
      int num=i*(i+1)*(i+2)/6 ;
      System.out.print(num+" ");
    }
  }
  public static void main(String[] args){
    int n=10 ;
    printSeries(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printSeries( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= n do ( (     var num : int ; num := i * (i + 1) * (i + 2) / 6 ;
     OclFile["System.out"].print(num + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     execute printSeries(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countElements(int p[],int n){
    int ans=0 ;
    for(int i=1 ; i<n-1 ; i++){
      if(p[i-1]>p[i] && p[i]>p[i+1])ans++;
      else if(p[i-1]<p[i] && p[i]<p[i+1])ans++;
    }
    return ans ;
  }
  public static void main(String[] args){
    int p[]={
      2,5,1,3,4 };
      int n=p.length ;
      System.out.println(countElements(p,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countElements( p : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i < n - 1 do ( (     if (p[i - 1+1] > p[i+1] & p[i+1] > p[i + 1+1]) then     ans := ans + 1 ; else     if (p[i - 1+1] < p[i+1] & p[i+1] < p[i + 1+1]) then     ans := ans + 1 ; else skip ; )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : Sequence(int) ; p := Sequence{2,5,1,3,4} ;
     var n : int ; n := p->size() ;
     OclFile["System.out"].println(countElements(p, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    TreeSet<Integer>set=new TreeSet<>();
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      set.add(Integer.parseInt(in.next()));
    }
    int m=in.nextInt();
    for(int i=0 ; i<m ; i++){
      set.remove(Integer.parseInt(in.next()));
    }
    PrintWriter out=new PrintWriter(System.out);
    Iterator<Integer>itr=set.iterator();
    while(itr.hasNext()){
      out.println(itr.next());
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var set : Set(int) ; set := Set{} ;
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     set := set->including((in.getCurrent())->toInteger()) )  ;     i := i + 1 ) ; 
    var m : int ; m := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     set := set->excludingFirst((in.getCurrent())->toInteger()) )  ;     i := i + 1 ) ; 
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var itr : OclIterator ; itr := set->iterator() ;
    while (itr.hasNext()) do (     skip ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=stdIn.nextInt();
    }
    int m=stdIn.nextInt();
    int b[]=new int[m];
    for(int i=0 ; i<m ; i++){
      b[i]=stdIn.nextInt();
    }
    int aindex=0 ;
    int bindex=0 ;
    while(true){
      if(a[aindex]==b[bindex]){
        aindex++;
        bindex++;
      }
      else if(a[aindex]>b[bindex]){
        bindex++;
      }
      else if(a[aindex]<b[bindex]){
        System.out.println(a[aindex]);
        aindex++;
      }
      if(aindex==n){
        break ;
      }
      if(bindex==m){
        for(int i=aindex ; i<n ; i++){
          System.out.println(a[i]);
        }
        break ;
      }
    }
    stdIn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := stdIn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := stdIn.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := stdIn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var aindex : int ; aindex := 0 ;
    var bindex : int ; bindex := 0 ;
    while (true) do (     if (a[aindex+1] = b[bindex+1]) then (     aindex := aindex + 1 ; 
     bindex := bindex + 1 ) else     if (a[aindex+1] > b[bindex+1]) then (     bindex := bindex + 1 ) else     if (a[aindex+1] < b[bindex+1]) then (     OclFile["System.out"].println(a[aindex+1]) ; 
     aindex := aindex + 1 ) else skip ; ;  ;  
     if (aindex = n) then (     break ) else skip ; 
     if (bindex = m) then (         var i : int ; i := aindex ; while i < n do ( (     OclFile["System.out"].println(a[i+1]) )  ;     i := i + 1 ) ; 
     break ) else skip ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void angleequichord(int z){
    System.out.println("The angle subtended at the center is "+z+" degrees");
  }
  public static void main(String[] args){
    int z=48 ;
    angleequichord(z);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation angleequichord( z : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("The angle subtended at the center is " + z + " degrees") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var z : int ; z := 48 ;
     execute angleequichord(z) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeSet ;
class Main {
  public static void main(String[] args){
    Set<Long>setA=new TreeSet<Long>();
    Set<Long>setB=new TreeSet<Long>();
    try(Scanner sc=new Scanner(System.in)){
      int times=sc.nextInt();
      for(int i=0 ; i<times ; i++)setA.add(sc.nextLong());
      times=sc.nextInt();
      for(int i=0 ; i<times ; i++)setB.add(sc.nextLong());
      ArrayList<Long>a=new ArrayList<Long>(setB);
      for(int i=0 ; i<times ; i++){
        Long l=a.get(i);
        boolean check=setA.contains(l);
        if(check)setA.remove(l);
      }
      a=new ArrayList<Long>(setA);
      for(int i=0 ; i<a.size(); i++)System.out.println(a.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var setA : Set(long) ; setA := Set{} ;
     var setB : Set(long) ; setB := Set{} ;
     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var times : int ; times := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < times do (     setA := setA->including(sc.getCurrent()->toLong()) ;  ;     i := i + 1 ) ; 
    times := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < times do (     setB := setB->including(sc.getCurrent()->toLong()) ;  ;     i := i + 1 ) ; 
    var a : Sequence(long) ; a := Sequence{}->union(setB) ;
        var i : int ; i := 0 ; while i < times do ( (     var l : long ; l := a->at(i+1) ;
     var check : boolean ; check := setA->includes(l) ;
     if (check) then     setA := setA->excludingAt(l+1) ; else skip )  ;     i := i + 1 ) ; 
    a := Sequence{}->union(setA) ; 
        var i : int ; i := 0 ; while i < a->size() do (     OclFile["System.out"].println(a->at(i+1)) ;  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    TreeSet<Integer>set=new TreeSet<>();
    int a=scan.nextInt();
    for(int i=0 ; i<a ; i++){
      int num=scan.nextInt();
      set.add(num);
    }
    TreeSet<Integer>set2=new TreeSet<>();
    int b=scan.nextInt();
    for(int i=0 ; i<b ; i++){
      int num=scan.nextInt();
      set2.add(num);
    }
    TreeSet<Integer>difference=new TreeSet<>(set);
    difference.removeAll(set2);
    for(int i : difference){
      System.out.println(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var set : Set(int) ; set := Set{} ;
    var a : int ; a := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < a do ( (     var num : int ; num := scan.getCurrent()->toInteger() ;
     set := set->including(num) )  ;     i := i + 1 ) ; 
    var set2 : Set(int) ; set2 := Set{} ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < b do ( (     var num : int ; num := scan.getCurrent()->toInteger() ;
     set2 := set2->including(num) )  ;     i := i + 1 ) ; 
    var difference : Set(int) ; difference := Set{}->union(set) ;
    difference := difference - set2 ; 
    for (i : difference) do ( (     OclFile["System.out"].println(i) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    StringBuilder sb=new StringBuilder();
    Set<Integer>set1=new TreeSet<>();
    Set<Integer>set2=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      set1.add(sc.nextInt());
    }
    int m=sc.nextInt();
    for(int i=0 ; i<m ; i++){
      set2.add(sc.nextInt());
    }
    set2.retainAll(set1);
    set1.removeAll(set2);
    for(int num : set1){
      sb.append(num);
      sb.append('\n');
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
    var set1 : Set(int) ; set1 := Set{} ;
    var set2 : Set(int) ; set2 := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     set1 := set1->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     set2 := set2->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    set2 := set2->intersection(set1) ; 
    set1 := set1 - set2 ; 
    for (num : set1) do ( (     sb := sb + StringLib.newString(num) ; 
     sb := sb + StringLib.newString('
') )  ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static void sort(String[] s,int n){
    for(int i=1 ; i<n ; i++){
      String temp=s[i];
      int j=i-1 ;
      while(j>=0 && temp.length()<s[j] .length()){
        s[j+1]=s[j];
        j--;
      }
      s[j+1]=temp ;
    }
  }
  static void printArraystring(String str[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(str[i]+" ");
  }
  public static void main(String args[]){
    String[] arr={
      "GeeksforGeeks","I","from","am" };
      int n=arr.length ;
      sort(arr,n);
      printArraystring(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation sort( s : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < n do ( (     var temp : String ; temp := s[i+1] ;
     var j : int ; j := i - 1 ;
     while (j >= 0 & temp->size() < s[j+1]->size()) do (     s[j + 1+1] := s[j+1] ; 
     j := j - 1 ) ; 
     s[j + 1+1] := temp )  ;     i := i + 1 ) );
  static   operation printArraystring( str : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(str[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"GeeksforGeeks","I","from","am"} ;
     var n : int ; n := arr->size() ;
     execute sort(arr, n) ; 
     execute printArraystring(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int M=1000000007 ;
  static long power(long x,int y,int p){
    long res=1 ;
    x=x % p ;
    while(y>0){
      if((y & 1)==1)res=(res*x)% p ;
      y=y>>1 ;
      x=(x*x)% p ;
    }
    return res ;
  }
  static long modInverse(long n,int p){
    return power(n,p-2,p);
  }
  static long nCrModPFermat(long n,int r,int p){
    if(r==0)return 1 ;
    long fac[]=new long[(int)n+1];
    fac[0]=1 ;
    int i ;
    for(i=1 ; i<=n ; i++)fac[i]=fac[i-1]*i % p ;
    return(fac[(int)n]*modInverse(fac[r],p)% p*modInverse(fac[(int)n-r],p)% p)% p ;
  }
  static long countOdd(long n){
    long x=n/2 ;
    if(n % 2==1)x++;
    return x ;
  }
  static long counteEven(long n){
    long x=n/2 ;
    return x ;
  }
  static long CountEvenSumSequences(long n){
    long count=0 ;
    for(int i=0 ; i<=n ; i++){
      int even=i,odd=(int)n-i ;
      if(odd % 2==1)continue ;
      long tot=(power(countOdd(n),odd,M)*nCrModPFermat(n,odd,M))% M ;
      tot=(tot*power(counteEven(n),i,M))% M ;
      count+=tot ;
      count %=M ;
    }
    return count ;
  }
  public static void main(String[] args){
    long n=5 ;
    System.out.println(CountEvenSumSequences(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute M : int := 1000000007;
  static   operation power( x : long, y : int, p : int) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     if ((y & 1) = 1) then     res := (res * x) mod p ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res );
  static   operation modInverse( n : long, p : int) : long
  pre: true
  post: true
  activity: (     return power(n, p - 2, p) );
  static   operation nCrModPFermat( n : long, r : int, p : int) : long
  pre: true
  post: true
  activity: (     if (r = 0) then     return 1 else skip ; 
     var fac : Sequence(long) ; fac := Integer.subrange(1,n->oclAsType(int) + 1)->collect(0) ;
    fac[0+1] := 1 ; 
    var i : int ;
        i := 1 ; while i <= n do (     fac[i+1] := fac[i - 1+1] * i mod p ;  ;     i := i + 1 ) ; 
    return (fac[n->oclAsType(int)+1] * modInverse(fac[r+1], p) mod p * modInverse(fac[n->oclAsType(int) - r+1], p) mod p) mod p 
 );
  static   operation countOdd( n : long) : long
  pre: true
  post: true
  activity: (     var x : long ; x := n / 2 ;
     if (n mod 2 = 1) then     x := x + 1 ; else skip ; 
     return x );
  static   operation counteEven( n : long) : long
  pre: true
  post: true
  activity: (     var x : long ; x := n / 2 ;
     return x );
  static   operation CountEvenSumSequences( n : long) : long
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
         var i : int ; i := 0 ; while i <= n do ( (     var even : int ; even := i ;
    var odd : int ; odd := n->oclAsType(int) - i ;
     if (odd mod 2 = 1) then     continue else skip ; 
    var tot : long ; tot := (power(countOdd(n), odd, M) * nCrModPFermat(n, odd, M)) mod M ;
    tot := (tot * power(counteEven(n), i, M)) mod M ; 
    count := count+(tot) ; 
    count := count mod M ; 
 )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 5 ;
     OclFile["System.out"].println(CountEvenSumSequences(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sumOfTheSeries(int n){
    int sum=0 ;
    for(int i=1 ; i<=n ; i++){
      int k=2 ;
      for(int j=1 ; j<=i ; j++){
        sum+=k ;
        k+=2 ;
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.printf("Sum=%d",sumOfTheSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumOfTheSeries( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     var k : int ; k := 2 ;
         var j : int ; j := 1 ; while j <= i do ( (     sum := sum+(k) ; 
     k := k+(2) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].printf("Sum=%d", sumOfTheSeries(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int prev=0 ;
    boolean isDown=true ;
    TreeMap<Integer,Integer>map=new TreeMap<>();
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      if(isDown && prev<x){
        if(map.containsKey(prev)){
          map.put(prev,map.get(prev)+1);
        }
        else {
          map.put(prev,1);
        }
        isDown=false ;
      }
      else if(! isDown && prev>x){
        if(map.containsKey(prev)){
          map.put(prev,map.get(prev)-1);
        }
        else {
          map.put(prev,-1);
        }
        isDown=true ;
      }
      prev=x ;
    }
    if(! isDown){
      if(map.containsKey(prev)){
        map.put(prev,map.get(prev)-1);
      }
      else {
        map.put(prev,-1);
      }
    }
    int max=0 ;
    int current=0 ;
    for(int x : map.values()){
      current+=x ;
      max=Math.max(max,current);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var prev : int ; prev := 0 ;
    var isDown : boolean ; isDown := true ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (isDown & prev < x) then (     if (map->keys()->includes(prev)) then (     map := map->union(Map{prev |-> map->at(prev) + 1}) ) else (     map := map->union(Map{prev |-> 1}) ) ;  
     isDown := false ) else     if (not(isDown) & prev > x) then (     if (map->keys()->includes(prev)) then (     map := map->union(Map{prev |-> map->at(prev) - 1}) ) else (     map := map->union(Map{prev |-> -1}) ) ;  
     isDown := true ) else skip ; ;  
     prev := x )  ;     i := i + 1 ) ; 
    if (not(isDown)) then (     if (map->keys()->includes(prev)) then (     map := map->union(Map{prev |-> map->at(prev) - 1}) ) else (     map := map->union(Map{prev |-> -1}) ) ) else skip ; 
    var max : int ; max := 0 ;
    var current : int ; current := 0 ;
    for (x : map->values()) do ( (     current := current+(x) ; 
     max := Set{max, current}->max() )  ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char a=sc.next().toCharArray()[0];
    char b=sc.next().toCharArray()[0];
    if(a>b){
      System.out.println('>');
    }
    else if(a==b){
      System.out.println('=');
    }
    else {
      System.out.println('<');
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := sc.getCurrent()->characters()[0+1] ;
     var b : String ; b := sc.getCurrent()->characters()[0+1] ;
     if (a > b) then (     OclFile["System.out"].println('>') ) else     if (a = b) then (     OclFile["System.out"].println('=') ) else (     OclFile["System.out"].println('<') ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  class Mnt {
    int a ;
    int m ;
    public Mnt(int a,int m){
      this.a=a ;
      this.m=m ;
    }
  }
  boolean main()throws IOException {
    Scanner sc=new Scanner(systemin);
    int N=sc.nextInt();
    boolean up=true ;
    int old=-1 ;
    boolean all0=true ;
    List<Mnt>list=new ArrayList<>();
    for(int i=0 ; i<=N ; i++){
      int A ;
      if(N==i)A=0 ;
      else A=sc.nextInt();
      if(A!=0)all0=false ;
      if(up && A<old){
        list.add(new Mnt(old,1));
        up=false ;
      }
      else if(! up && A>old){
        list.add(new Mnt(old,0));
        up=true ;
      }
      old=A ;
    }
    list.sort((a,b)->a.a-b.a);
    int max=1 ;
    int sima=1 ;
    old=-1 ;
    for(int i=0 ; i<list.size(); i++){
      Mnt m=list.get(i);
      if(m.a!=old){
        max=Math.max(max,sima);
      }
      if(m.m>0)sima--;
      else sima++;
      log.printf("list a=%d m=%d sima=%d max=%d\n",m.a,m.m,sima,max);
      old=m.a ;
    }
    if(all0)max=0 ;
    result.printf("%d\n",max);
    sc.close();
    return false ;
  }
  PrintStream log ;
  PrintStream result=System.out ;
  BufferedReader systemin ;
  static Main instance=new Main();
  Main(){
    systemin=new BufferedReader(new InputStreamReader(System.in));
    log=new PrintStream(new OutputStream(){
      public void write(int b){
      }
    }
);
  }
  public static void main(String[] args)throws IOException {
    instance.main();
    instance.systemin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class Mnt {
   attribute a : int;
   attribute m : int;
   static operation newMnt( a : int, m : int) : Mnt
  pre: true
  post: true
  activity:
  ( var self : Mnt ;
    self := createMnt();
    self.initialise(a, m);
    return self );
  operation initialise( a : int, m : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.m := m );
}
   operation main() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(systemin) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var up : boolean ; up := true ;
    var old : int ; old := -1 ;
    var all0 : boolean ; all0 := true ;
    var list : Sequence(Mnt) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i <= N do ( (     var A : int ;
     if (N = i) then     A := 0 else     A := sc.getCurrent()->toInteger() ; ;  
    if (A /= 0) then     all0 := false ; else skip ; 
    if (up & A < old) then (     list := list->including(Mnt.newMnt(old, 1)) ; 
     up := false ) else     if (not(up) & A > old) then (     list := list->including(Mnt.newMnt(old, 0)) ; 
     up := true ) else skip ; ;  
    old := A ; 
 )  ;     i := i + 1 ) ; 
    list := list.sort(lambda (a , b) : OclAny in a.a - b.a) ; 
    var max : int ; max := 1 ;
    var sima : int ; sima := 1 ;
    old := -1 ; 
        var i : int ; i := 0 ; while i < list->size() do ( (     var m : Mnt ; m := list->at(i+1) ;
     if (m.a /= old) then (     max := Set{max, sima}->max() ) else skip ; 
    if (m.m > 0) then     sima := sima - 1 else     sima := sima + 1 ; ;  
    log.printf("list a=%d m=%d sima=%d max=%d\n", m.a, m.m, sima, max) ; 
    old := m.a ; 
 )  ;     i := i + 1 ) ; 
    if (all0) then     max := 0 ; else skip ; 
    result.printf("%d\n", max) ; 
    skip ; 
    return false 
 );
   attribute log : OclFile;
   attribute result : OclFile := OclFile["System.out"];
   attribute systemin : OclFile;
  static   attribute instance : Main := Main.newMain();
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     systemin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     log := OclFile.newOclFile_Write(OclFile()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     instance.main() ; 
     instance.systemin.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class Main {
  public static int nobleInteger(int arr[]){
    Arrays.sort(arr);
    int n=arr.length ;
    for(int i=0 ; i<n-1 ; i++){
      if(arr[i]==arr[i+1])continue ;
      if(arr[i]==n-i-1)return arr[i];
    }
    if(arr[n-1]==0)return arr[n-1];
    return-1 ;
  }
  public static void main(String args[]){
    int[] arr={
      10,3,20,40,2 };
      int res=nobleInteger(arr);
      if(res!=-1)System.out.println("The noble integer is "+res);
      else System.out.println("No Noble Integer Found");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation nobleInteger( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var n : int ; n := arr->size() ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] = arr[i + 1+1]) then     continue else skip ; 
     if (arr[i+1] = n - i - 1) then     return arr[i+1] else skip )  ;     i := i + 1 ) ; 
    if (arr[n - 1+1] = 0) then     return arr[n - 1+1] else skip ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,3,20,40,2} ;
     var res : int ; res := nobleInteger(arr) ;
     if (res /= -1) then     OclFile["System.out"].println("The noble integer is " + res) ; else     OclFile["System.out"].println("No Noble Integer Found") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void findNumbers(int n,int d){
    for(int i=0 ; i<n-2 ; i++)System.out.print("1"+" ");
    System.out.print("2"+" ");
    System.out.println(n+d);
  }
  public static void main(String args[]){
    int N=3,D=5 ;
    findNumbers(N,D);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNumbers( n : int, d : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n - 2 do (     OclFile["System.out"].print("1" + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("2" + " ") ; 
     OclFile["System.out"].println(n + d) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
    var D : int ; D := 5 ;
     execute findNumbers(N, D) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.util.Scanner ;
public class A362 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      char[][] A=new char[8][];
      for(int r=0 ; r<8 ; r++){
        A[r]=in.next().toCharArray();
      }
      Point k1=null ;
      Point k2=null ;
      for(int r=0 ; r<8 ; r++){
        for(int c=0 ; c<8 ; c++){
          if(A[r][c]=='K'){
            if(k1==null){
              k1=new Point(r,c);
            }
            else {
              k2=new Point(r,c);
            }
          }
        }
      }
      int dx=Math.abs(k1.x-k2.x);
      int dy=Math.abs(k1.y-k2.y);
      boolean ok=(dx % 4==0)&&(dy % 4==0);
      System.out.println(ok ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A362 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var A : Sequence(Sequence(String)) ; A := Integer.subrange(1,8)->collect(Sequence{}) ;
         var r : int ; r := 0 ; while r < 8 do ( (     A[r+1] := in.getCurrent()->characters() )  ;     r := r + 1 ) ; 
    var k1 : Point ; k1 := null ;
    var k2 : Point ; k2 := null ;
        var r : int ; r := 0 ; while r < 8 do ( (         var c : int ; c := 0 ; while c < 8 do ( (     if (A[r+1][c+1] = 'K') then (     if (k1 = null) then (     k1 := Point.newPoint(r, c) ) else (     k2 := Point.newPoint(r, c) ) ) else skip )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    var dx : int ; dx := if k1.x - k2.x < 0 then -(k1.x - k2.x) else k1.x - k2.x endif ;
    var dy : int ; dy := if k1.y - k2.y < 0 then -(k1.y - k2.y) else k1.y - k2.y endif ;
    var ok : boolean ; ok := (dx mod 4 = 0) & (dy mod 4 = 0) ;
    OclFile["System.out"].println(if ok then "YES" else "NO" endif) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Turn_the_rectangle {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    long h[]=new long[n];
    long w[]=new long[n];
    for(int i=0 ; i<n ; i++){
      w[i]=scanner.nextLong();
      h[i]=scanner.nextLong();
    }
    scanner.close();
    long t=h[0]>w[0] ? h[0] : w[0];
    for(int i=1 ; i<n ; i++){
      if(!(t>=h[i] || t>=w[i])){
        System.out.println("NO");
        System.exit(0);
      }
      else if(t>h[i] && t<w[i])t=h[i];
      else if(t>w[i] && t<h[i])t=w[i];
      else if(t>h[i] && t>w[i])t=h[i]>w[i] ? h[i] : w[i];
      else if(t==h[i] || t==w[i])t=t==h[i] ? h[i] : w[i];
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Turn_the_rectangle {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var h : Sequence(long) ; h := Integer.subrange(1,n)->collect(0) ;
    var w : Sequence(long) ; w := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     w[i+1] := scanner.getCurrent()->toLong() ; 
     h[i+1] := scanner.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    skip ; 
    var t : long ; t := if h[0+1] > w[0+1] then h[0+1] else w[0+1] endif ;
        var i : int ; i := 1 ; while i < n do ( (     if (not((t >= h[i+1] or t >= w[i+1]))) then (     OclFile["System.out"].println("NO") ; 
 OclProcess.exit(0) ) else     if (t > h[i+1] & t < w[i+1]) then     t := h[i+1] else     if (t > w[i+1] & t < h[i+1]) then     t := w[i+1] else     if (t > h[i+1] & t > w[i+1]) then     t := if h[i+1] > w[i+1] then h[i+1] else w[i+1] endif else     if (t = h[i+1] or t = w[i+1]) then     t := if t = h[i+1] then h[i+1] else w[i+1] endif ; else skip ; ;  ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int n=cin.nextInt();
    int[][] arr=new int[n][2];
    for(int i=0 ; i<n ; i++){
      arr[i][0]=cin.nextInt();
      arr[i][1]=cin.nextInt();
    }
    int max1=(arr[0][0]>arr[0][1])? arr[0][0] : arr[0][1];
    for(int i=1 ; i<n ; i++){
      int min=(arr[i][0]<=arr[i][1])? arr[i][0] : arr[i][1];
      int max=(arr[i][0]>arr[i][1])? arr[i][0] : arr[i][1];
      if(max1<min){
        System.out.println("NO");
        return ;
      }
      max1=(max1>=max)? max : min ;
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := cin.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1][0+1] := cin.getCurrent()->toInteger() ; 
     arr[i+1][1+1] := cin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var max1 : int ; max1 := if (arr[0+1][0+1] > arr[0+1][1+1]) then arr[0+1][0+1] else arr[0+1][1+1] endif ;
        var i : int ; i := 1 ; while i < n do ( (     var min : int ; min := if (arr[i+1][0+1] <= arr[i+1][1+1]) then arr[i+1][0+1] else arr[i+1][1+1] endif ;
     var max : int ; max := if (arr[i+1][0+1] > arr[i+1][1+1]) then arr[i+1][0+1] else arr[i+1][1+1] endif ;
     if (max1 < min) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
     max1 := if (max1 >= max) then max else min endif )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1008 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int last=Integer.MAX_VALUE ;
    for(int n=0 ; n<N ; n++){
      int W=in.nextInt();
      int H=in.nextInt();
      int max=Math.max(W,H);
      int min=Math.min(W,H);
      if(last>=max){
        last=max ;
      }
      else if(last>=min){
        last=min ;
      }
      else {
        last=0 ;
      }
    }
    System.out.println((last==0)? "NO" : "YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1008 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var last : int ; last := 2147483647 ;
        var n : int ; n := 0 ; while n < N do ( (     var W : int ; W := in.getCurrent()->toInteger() ;
     var H : int ; H := in.getCurrent()->toInteger() ;
    var max : int ; max := Set{W, H}->max() ;
    var min : int ; min := Set{W, H}->min() ;
    if (last >= max) then (     last := max ) else     if (last >= min) then (     last := min ) else (     last := 0 ) ;  ;  
 )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(if (last = 0) then "NO" else "YES" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class turnRect {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] width=new int[n];
    int[] height=new int[n];
    for(int i=0 ; i<n ; i++){
      width[i]=sc.nextInt();
      height[i]=sc.nextInt();
    }
    boolean output=true ;
    height[n-1]=Math.min(height[n-1],width[n-1]);
    for(int i=n-2 ; i>-1 ; i--){
      if(Math.min(height[i],width[i])>=height[i+1]){
        height[i]=Math.min(height[i],width[i]);
      }
      else {
        if(height[i]>=height[i+1]){
          height[i]=height[i];
        }
        else {
          if(width[i]>=height[i+1]){
            height[i]=width[i];
          }
          else {
            output=false ;
            break ;
          }
        }
      }
    }
    if(output){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class turnRect {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var width : Sequence(int) ; width := Integer.subrange(1,n)->collect(0) ;
    var height : Sequence(int) ; height := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     width[i+1] := sc.getCurrent()->toInteger() ; 
     height[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var output : boolean ; output := true ;
    height[n - 1+1] := Set{height[n - 1+1], width[n - 1+1]}->min() ; 
        var i : int ; i := n - 2 ; while i > -1 do ( (     if (Set{height[i+1], width[i+1]}->min() >= height[i + 1+1]) then (     height[i+1] := Set{height[i+1], width[i+1]}->min() ) else (     if (height[i+1] >= height[i + 1+1]) then (     height[i+1] := height[i+1] ) else (     if (width[i+1] >= height[i + 1+1]) then (     height[i+1] := width[i+1] ) else (     output := false ; 
     break ) ) ) )  ;     i := i - 1 ) ; 
    if (output) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int maxSquare(int b,int m){
    return(b/m-1)*(b/m)/2 ;
  }
  public static void main(String args[]){
    int b=10,m=2 ;
    System.out.println(maxSquare(b,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxSquare( b : int, m : int) : int
  pre: true
  post: true
  activity: (     return (b / m - 1) * (b / m) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var b : int ; b := 10 ;
    var m : int ; m := 2 ;
     OclFile["System.out"].println(maxSquare(b, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Random ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.HashMap ;
public class Main {
  public static void main(String[] args){
    HashMap<String,Integer>map=new HashMap<>();
    map.put("A",10);
    map.put("B",11);
    map.put("C",12);
    map.put("D",13);
    map.put("E",14);
    map.put("F",15);
    Scanner sc=new Scanner(System.in);
    String x=sc.next();
    String y=sc.next();
    int a=map.get(x);
    int b=map.get(y);
    if(a<b)System.out.println("<");
    if(a==b)System.out.println("=");
    if(a>b)System.out.println(">");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var map : Map(String,int) ; map := Map{} ;
     map := map->union(Map{"A" |-> 10}) ; 
    map := map->union(Map{"B" |-> 11}) ; 
    map := map->union(Map{"C" |-> 12}) ; 
    map := map->union(Map{"D" |-> 13}) ; 
    map := map->union(Map{"E" |-> 14}) ; 
    map := map->union(Map{"F" |-> 15}) ; 
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var x : String ; x := sc.getCurrent() ;
    var y : String ; y := sc.getCurrent() ;
    var a : int ; a := map->at(x) ;
    var b : int ; b := map->at(y) ;
    if (a < b) then     OclFile["System.out"].println("<") ; else skip ; 
    if (a = b) then     OclFile["System.out"].println("=") ; else skip ; 
    if (a > b) then     OclFile["System.out"].println(">") ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MinOfCubed(int k){
    if(k<8)return k ;
    int res=k ;
    for(int i=1 ; i<=k ; i++){
      if((i*i*i)>k)return res ;
      res=Math.min(res,MinOfCubed(k-(i*i*i))+1);
    }
    return res ;
  }
  public static void main(String[] args){
    int num=15 ;
    System.out.println(MinOfCubed(num));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation MinOfCubed( k : int) : int
  pre: true
  post: true
  activity: (     if (k < 8) then     return k else skip ; 
     var res : int ; res := k ;
         var i : int ; i := 1 ; while i <= k do ( (     if ((i * i * i) > k) then     return res else skip ; 
     res := Set{res, MinOfCubed(k - (i * i * i)) + 1}->min() )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 15 ;
     OclFile["System.out"].println(MinOfCubed(num)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  public static int findGCD(ArrayList<Integer>arr,int n){
    int result=arr.get(0);
    for(int i=1 ; i<n ; i++)result=gcd(arr.get(i),result);
    return result ;
  }
  public static void compute(ArrayList<Integer>arr,int n){
    ArrayList<Integer>answer=new ArrayList<Integer>();
    int GCD_of_array=findGCD(arr,n);
    if(GCD_of_array==arr.get(0)){
      answer.add(arr.get(0));
      for(int i=1 ; i<n ; i++){
        answer.add(arr.get(0));
        answer.add(arr.get(i));
      }
      for(int i=0 ; i<answer.size(); i++)System.out.print(answer.get(i)+" ");
    }
    else System.out.print("No array "+"can be build");
  }
  public static void main(String args[]){
    int n=3 ;
    Integer input[]={
      2,5,6,7,11 };
      HashSet<Integer>GCD=new HashSet<Integer>(Arrays.asList(input));
      ArrayList<Integer>arr=new ArrayList<Integer>();
      for(int v : GCD)arr.add(v);
      compute(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation findGCD( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := arr->at(0+1) ;
         var i : int ; i := 1 ; while i < n do (     result := gcd(arr->at(i+1), result) ;  ;     i := i + 1 ) ; 
     return result );
  static   operation compute( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var answer : Sequence(int) ; answer := Sequence{} ;
     var GCD_of_array : int ; GCD_of_array := findGCD(arr, n) ;
     if (GCD_of_array = arr->at(0+1)) then (     answer := answer->including(arr->at(0+1)) ; 
         var i : int ; i := 1 ; while i < n do ( (     answer := answer->including(arr->at(0+1)) ; 
     answer := answer->including(arr->at(i+1)) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < answer->size() do (     OclFile["System.out"].print(answer->at(i+1) + " ") ;  ;     i := i + 1 ) ) else     OclFile["System.out"].print("No array " + "can be build") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var input : Sequence(int) ; input := Sequence{2,5,6,7,11} ;
    var GCD : Set(int) ; GCD := Set{}->union(input) ;
    var arr : Sequence(int) ; arr := Sequence{} ;
    for (v : GCD) do (     arr := arr->including(v) ;  ) ; 
    execute compute(arr, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
import static java.lang.Math.max ;
import static java.lang.System.exit ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  static void solve()throws Exception {
    String s=scanString();
    int n=s.length()+1 ;
    int res[]=new int[n];
    for(int i=1 ; i<n ; i++){
      if(s.charAt(i-1)=='<'){
        res[i]=res[i-1]+1 ;
      }
    }
    for(int i=n-2 ; i>=0 ; i--){
      if(s.charAt(i)=='>'){
        res[i]=max(res[i],res[i+1]+1);
      }
    }
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      ans+=res[i];
    }
    out.print(ans);
  }
  static int scanInt()throws IOException {
    return parseInt(scanString());
  }
  static long scanLong()throws IOException {
    return parseLong(scanString());
  }
  static String scanString()throws IOException {
    while(tok==null || ! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine());
    }
    return tok.nextToken();
  }
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  public static void main(String[] args){
    try {
      in=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(System.out);
      solve();
      in.close();
      out.close();
    }
    catch(Throwable e){
      e.printStackTrace();
      exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var s : String ; s := scanString() ;
     var n : int ; n := s->size() + 1 ;
    var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 1 ; while i < n do ( (     if (s->at(i - 1+1) = '<') then (     res[i+1] := res[i - 1+1] + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := (n)->char2byte() - 2 ; while i >= 0 do ( (     if (s->at(i+1) = '>') then (     res[i+1] := Set{res[i+1], res[i + 1+1] + 1}->max() ) else skip )  ;     i := i - 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans+(res[i+1]) )  ;     i := i + 1 ) ; 
    out.print(ans) ; 
 );
  static   operation scanInt() : int
  pre: true
  post: true
  activity: (     return (scanString() + "")->toInteger() );
  static   operation scanLong() : long
  pre: true
  post: true
  activity: (     return parseLong(scanString()) );
  static   operation scanString() : String
  pre: true
  post: true
  activity: (     while (tok = null or not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return tok.next() );
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
     execute exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    new Main();
  }
  Scanner in=new Scanner(System.in);
  PrintWriter out=new PrintWriter(System.out);
  int len ;
  char[] s ;
  long[] cmp ;
  Main(){
    s=in.next().toCharArray();
    cmp=new long[len=s.length];
    int at=0 ;
    for(int i=0 ; i<len ; i++){
      int j=i ;
      while(j<len && s[i]==s[j])j++;
      cmp[at++]=j-i ;
      i=j-1 ;
    }
    long ans=0 ;
    if(s[0]=='>'){
      for(int i=1 ; i<at-1 ; i+=2){
        ans+=tri(max(cmp[i],cmp[i+1]));
        ans+=tri(min(cmp[i],cmp[i+1])-1);
      }
      if(at % 2==0)ans+=tri(cmp[at-1]);
      ans+=tri(cmp[0]);
    }
    else {
      for(int i=0 ; i<=at-2 ; i+=2){
        ans+=tri(max(cmp[i],cmp[i+1]));
        ans+=tri(min(cmp[i],cmp[i+1])-1);
      }
      if(at % 2==1)ans+=tri(cmp[at-1]);
    }
    out.println(ans);
    out.close();
  }
  long tri(long a){
    return a*(a+1L)/2L ;
  }
  long min(long a,long b){
    if(a<b)return a ;
    return b ;
  }
  long max(long a,long b){
    if(a>b)return a ;
    return b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   attribute len : int;
   attribute s : Sequence(String);
   attribute cmp : Sequence(long);
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     s := in.getCurrent()->characters() ; 
     cmp := Integer.subrange(1,len)->collect(0) ; 
    var at : int ; at := 0 ;
        var i : int ; i := 0 ; while i < len do ( (     var j : int ; j := i ;
     while (j < len & s[i+1] = s[j+1]) do     j := j + 1 ; ; 
      cmp[at+1] := j - i  ; at := at + 1 ; 
     i := j - 1 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    if (s[0+1] = '>') then (         var i : int ; i := 1 ; while i < at - 1 do ( (     ans := ans+(tri(Set{cmp[i+1], cmp[i + 1+1]}->max())) ; 
     ans := ans+(tri(min(cmp[i+1], cmp[i + 1+1]) - 1)) )  ;     i := i+(2) ) ; 
     if (at mod 2 = 0) then     ans := ans+(tri(cmp[at - 1+1])) ; else skip ; 
     ans := ans+(tri(cmp[0+1])) ) else (         var i : int ; i := 0 ; while i <= at - 2 do ( (     ans := ans+(tri(Set{cmp[i+1], cmp[i + 1+1]}->max())) ; 
     ans := ans+(tri(min(cmp[i+1], cmp[i + 1+1]) - 1)) )  ;     i := i+(2) ) ; 
     if (at mod 2 = 1) then     ans := ans+(tri(cmp[at - 1+1])) ; else skip ) ;  
    skip ; 
    skip ; 
 );
   operation tri( a : long) : long
  pre: true
  post: true
  activity: (     return a * (a + 1L) / 2L );
   operation min( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a < b) then     return a else skip ; 
     return b );
   operation max( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a > b) then     return a else skip ; 
     return b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int count(int n){
    if(n==0)return 1 ;
    if(n==1)return 1 ;
    else return(n*count(n-1))+((n-1)*count(n-2));
  }
  public static void main(String[] args){
    int A[]={
      1,2,3,9 };
      int n=4 ;
      System.out.println(count(n-1));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     if (n = 1) then     return 1 else     return (n * count(n - 1)) + ((n - 1) * count(n - 2)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{1,2,3,9} ;
     var n : int ; n := 4 ;
     OclFile["System.out"].println(count(n - 1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner std=new Scanner(System.in);
    String text=std.next();
    long[] dp=new long[text.length()+1];
    for(int i=0 ; i<text.length(); i++){
      char c=text.charAt(i);
      if(c=='<'){
        dp[i+1]=Math.max(dp[i+1],dp[i]+1);
      }
      else if(c=='>'){
        long value=Math.max(dp[i]-1,0);
        dp[i+1]=Math.min(dp[i+1],value);
      }
    }
    for(int i=text.length()-1 ; i>=0 ; i--){
      char c=text.charAt(i);
      if(c=='<'){
        long value=Math.max(dp[i+1]-1,0);
        dp[i]=Math.min(dp[i],value);
      }
      else if(c=='>'){
        long value=Math.max(dp[i+1]+1,0);
        dp[i]=Math.max(dp[i],value);
      }
    }
    System.out.println(Arrays.stream(dp).sum());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var std : OclFile ; std := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var text : String ; text := std.getCurrent() ;
    var dp : Sequence(long) ; dp := Integer.subrange(1,text->size() + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < text->size() do ( (     var c : String ; c := text->at(i+1) ;
     if (c = '<') then (     dp[i + 1+1] := Set{dp[i + 1+1], dp[i+1] + 1}->max() ) else     if (c = '>') then (     var value : long ; value := Set{dp[i+1] - 1, 0}->max() ;
     dp[i + 1+1] := Set{dp[i + 1+1], value}->min() ) else skip ; )  ;     i := i + 1 ) ; 
        var i : int ; i := text->size() - 1 ; while i >= 0 do ( (     var c : String ; c := text->at(i+1) ;
     if (c = '<') then (     var value : long ; value := Set{dp[i + 1+1] - 1, 0}->max() ;
     dp[i+1] := Set{dp[i+1], value}->min() ) else     if (c = '>') then (     var value : long ; value := Set{dp[i + 1+1] + 1, 0}->max() ;
     dp[i+1] := Set{dp[i+1], value}->max() ) else skip ; )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(stream(dp)->sum()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    A solver=new A();
    solver.solve(1,in,out);
    out.close();
  }
  static class A {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      String S=in.next();
      int n=S.length();
      long ans=0 ;
      long[] a=new long[n+1];
      for(int i=0 ; i<n ; i++){
        if(S.charAt(i)=='<'){
          a[i+1]=a[i]+1 ;
        }
      }
      for(int i=n-1 ; i>=0 ; i--){
        if(S.charAt(i)=='>'){
          if(a[i+1]>=a[i]){
            a[i]=a[i+1]+1 ;
          }
        }
      }
      for(long num : a){
        ans+=num ;
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : A ; solver := A.newA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class A {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var S : String ; S := in.getCurrent() ;
     var n : int ; n := S->size() ;
    var ans : long ; ans := 0 ;
    var a : Sequence(long) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     if (S->at(i+1) = '<') then (     a[i + 1+1] := a[i+1] + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := (n)->char2byte() - 1 ; while i >= 0 do ( (     if (S->at(i+1) = '>') then (     if (a[i + 1+1] >= a[i+1]) then (     a[i+1] := a[i + 1+1] + 1 ) else skip ) else skip )  ;     i := i - 1 ) ; 
    for (num : a) do ( (     ans := ans+(num) )  ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    char[] seq=br.readLine().toCharArray();
    int n=seq.length+1 ;
    int[] arr=new int[n];
    Arrays.fill(arr,-1);
    int index=n-1 ;
    while(index>0){
      if((index==n-1 || seq[index]=='<')&& seq[index-1]=='>'){
        arr[index]=0 ;
        while(index-2>=0 && seq[index-2]=='>'){
          arr[index-1]=arr[index]+1 ;
          index--;
        }
        arr[index-1]=arr[index]+1 ;
      }
      index--;
    }
    if(arr[0]==-1){
      arr[0]=0 ;
    }
    index=1 ;
    while(index<n){
      if(arr[index]==-1){
        arr[index]=arr[index-1]+1 ;
      }
      index++;
    }
    for(int i=0 ; i<n-1 ; i++){
      if(seq[i]=='<' && arr[i]>=arr[i+1]){
        arr[i+1]=arr[i]+1 ;
      }
      if(seq[i]=='>' && arr[i]<=arr[i+1]){
        arr[i]=arr[i+1]+1 ;
      }
    }
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=arr[i];
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var seq : Sequence(String) ; seq := br.readLine()->characters() ;
    var n : int ; n := seq->size() + 1 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    arr := arr->collect(-1) ; 
    var index : int ; index := n - 1 ;
    while (index > 0) do (     if ((index = n - 1 or seq[index+1] = '<') & seq[index - 1+1] = '>') then (     arr[index+1] := 0 ; 
     while (index - 2 >= 0 & seq[index - 2+1] = '>') do (     arr[index - 1+1] := arr[index+1] + 1 ; 
     index := index - 1 ) ; 
     arr[index - 1+1] := arr[index+1] + 1 ) else skip ; 
     index := index - 1 ) ; 
    if (arr[0+1] = -1) then (     arr[0+1] := 0 ) else skip ; 
    index := 1 ; 
    while (index < n) do (     if (arr[index+1] = -1) then (     arr[index+1] := arr[index - 1+1] + 1 ) else skip ; 
     index := index + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (seq[i+1] = '<' & arr[i+1] >= arr[i + 1+1]) then (     arr[i + 1+1] := arr[i+1] + 1 ) else skip ; 
     if (seq[i+1] = '>' & arr[i+1] <= arr[i + 1+1]) then (     arr[i+1] := arr[i + 1+1] + 1 ) else skip )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static double polygonArea(double X[],double Y[],int n){
    double area=0.0 ;
    int j=n-1 ;
    for(int i=0 ; i<n ; i++){
      area+=(X[j]+X[i])*(Y[j]-Y[i]);
      j=i ;
    }
    return Math.abs(area/2.0);
  }
  public static void main(String[] args){
    double X[]={
      0,2,4 };
      double Y[]={
        1,3,7 };
        int n=3 ;
        System.out.println(polygonArea(X,Y,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation polygonArea( X : Sequence(double), Y : Sequence(double), n : int) : double
  pre: true
  post: true
  activity: (     var area : double ; area := 0.0 ;
     var j : int ; j := n - 1 ;
         var i : int ; i := 0 ; while i < n do ( (     area := area+((X[j+1] + X[i+1]) * (Y[j+1] - Y[i+1])) ; 
     j := i )  ;     i := i + 1 ) ; 
     return if area / 2.0 < 0 then -(area / 2.0) else area / 2.0 endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : Sequence(double) ; X := Sequence{0,2,4} ;
     var Y : Sequence(double) ; Y := Sequence{1,3,7} ;
     var n : int ; n := 3 ;
     OclFile["System.out"].println(polygonArea(X, Y, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static double polygonArea(double X[],double Y[],int n){
    double area=0.0 ;
    int j=n-1 ;
    for(int i=0 ; i<n ; i++){
      area+=(X[j]+X[i])*(Y[j]-Y[i]);
      j=i ;
    }
    return Math.abs(area/2.0);
  }
  public static void main(String[] args){
    double X[]={
      0,2,4 };
      double Y[]={
        1,3,7 };
        int n=X.length ;
        System.out.println(polygonArea(X,Y,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation polygonArea( X : Sequence(double), Y : Sequence(double), n : int) : double
  pre: true
  post: true
  activity: (     var area : double ; area := 0.0 ;
     var j : int ; j := n - 1 ;
         var i : int ; i := 0 ; while i < n do ( (     area := area+((X[j+1] + X[i+1]) * (Y[j+1] - Y[i+1])) ; 
     j := i )  ;     i := i + 1 ) ; 
     return if area / 2.0 < 0 then -(area / 2.0) else area / 2.0 endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : Sequence(double) ; X := Sequence{0,2,4} ;
     var Y : Sequence(double) ; Y := Sequence{1,3,7} ;
     var n : int ; n := X->size() ;
     OclFile["System.out"].println(polygonArea(X, Y, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.*;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      String[] s=new String[2];
      for(int i=0 ; i<2 ; i++){
        s[i]=in.next();
        out.print(s[i]+" ");
      }
      out.println();
      int n=in.nextInt();
      while(n-->0){
        String a=in.next();
        String b=in.next();
        for(int i=0 ; i<2 ; i++){
          if(Objects.equals(s[i],a)){
            s[i]=b ;
          }
          out.print(s[i]+" ");
        }
        out.println();
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := Integer.subrange(1,2)->collect(null) ;
         var i : int ; i := 0 ; while i < 2 do ( (     s[i+1] := in.next() ; 
     skip )  ;     i := i + 1 ) ; 
    skip ; 
    var n : int ; n := in.nextInt() ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var a : String ; a := in.next() ;
     var b : String ; b := in.next() ;
         var i : int ; i := 0 ; while i < 2 do ( (     if (Objects = s[i+1], a) then (     s[i+1] := b ) else skip ; 
     skip )  ;     i := i + 1 ) ; 
     skip ) ;  ) ;  
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[][] ch=new char[n][n];
    boolean even=true ;
    for(int i=0 ; i<n ; i++){
      String s=sc.next();
      for(int j=0 ; j<n ; j++){
        ch[i][j]=s.charAt(j);
      }
    }
    for(int i=0 ; i<n ; i++){
      int count=0 ;
      for(int j=0 ; j<n ; j++){
        if(i-1>=0 && ch[i-1][j]=='o')count++;
        if(i+1<n && ch[i+1][j]=='o')count++;
        if(j-1>=0 && ch[i][j-1]=='o')count++;
        if(j+1<n && ch[i][j+1]=='o')count++;
        if(count % 2==1)even=false ;
      }
    }
    if(even==true)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ch : Sequence(Sequence(String)) ; ch := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var even : boolean ; even := true ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < n do ( (     ch[i+1][j+1] := s->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (i - 1 >= 0 & ch[i - 1+1][j+1] = 'o') then     count := count + 1 ; else skip ; 
     if (i + 1 < n & ch[i + 1+1][j+1] = 'o') then     count := count + 1 ; else skip ; 
    if ((j)->char2byte() - 1 >= 0 & ch[i+1][(j)->char2byte() - 1+1] = 'o') then     count := count + 1 ; else skip ; 
    if (j + 1 < n & ch[i+1][j + 1+1] = 'o') then     count := count + 1 ; else skip ; 
    if (count mod 2 = 1) then     even := false ; else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (even = true) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class code {
  static int dir[][]=new int[][] {
    {
      0,1 },{
        0,-1 },{
          1,0 },{
-1,0 }
          };
          public static void main(String[] args)throws java.lang.Exception {
            Scanner sc=new Scanner(System.in);
            int n=sc.nextInt();
            int count=0 ;
            boolean flag=false ;
            char arr[][]=new char[n][n];
            for(int i=0 ; i<n ; i++){
              String s=sc.next();
              char ch[]=s.toCharArray();
              for(int j=0 ; j<n ; j++){
                arr[i][j]=ch[j];
              }
            }
            for(int i=0 ; i<n && ! flag ; i++){
              for(int j=0 ; j<n && ! flag ; j++){
                count=dfs(i,j,n,arr);
                if(count % 2!=0){
                  flag=true ;
                  System.out.println("NO");
                }
              }
            }
            if(flag==false){
              System.out.println("YES");
            }
          }
          public static int dfs(int i,int j,int n,char arr[][]){
            if(i<0 || i>=n || j<0 || j>=n){
              return 0 ;
            }
            int count=0 ;
            Queue<int[]>q=new LinkedList<>();
            q.add(new int[] {
              i,j }
);
              while(! q.isEmpty()){
                int cell[]=q.remove();
                int x=cell[0];
                int y=cell[1];
                for(int m[] : dir){
                  int newRow=m[0]+x ;
                  int newCol=m[1]+y ;
                  if(newRow>=0 && newRow<n && newCol>=0 && newCol<n){
                    if(arr[newRow][newCol]=='o'){
                      count++;
                    }
                  }
                }
              }
              return count ;
            }
          }

------------------------------------------------------------
OCL File:
---------
 class code {
  static   attribute dir : int := Sequence{Sequence{0,1},Sequence{0,-1},Sequence{1,0},Sequence{-1,0}};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var flag : boolean ; flag := false ;
    var arr : Sequence(Sequence(String)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
     var ch : Sequence(String) ; ch := s->characters() ;
         var j : int ; j := 0 ; while j < n do ( (     arr[i+1][j+1] := ch[j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n & not(flag) do ( (         var j : int ; j := 0 ; while j < n & not(flag) do ( (     count := dfs(i, j, n, arr) ; 
     if (count mod 2 /= 0) then (     flag := true ; 
     OclFile["System.out"].println("NO") ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (flag = false) then (     OclFile["System.out"].println("YES") ) else skip ; 
 );
  static   operation dfs( i : int, j : int, n : int, arr : Sequence(Sequence(String))) : int
  pre: true
  post: true
  activity: (     if (i < 0 or i >= n or j < 0 or j >= n) then (     return 0 ) else skip ; 
     var count : int ; count := 0 ;
    var q : Sequence(Sequence(int)) ; q := Sequence{} ;
    q := q->including(Sequence{i,j}) ; 
    while (not(q->isEmpty())) do (     var cell : Sequence(int) ; cell := q.remove() ;
     var x : int ; x := cell[0+1] ;
     var y : int ; y := cell[1+1] ;
     for (m : dir) do ( (     var newRow : int ; newRow := m[0+1] + x ;
     var newCol : int ; newCol := m[1+1] + y ;
     if (newRow >= 0 & newRow < n & newCol >= 0 & newCol < n) then (     if (arr[newRow+1][newCol+1] = 'o') then (     count := count + 1 ) else skip ) else skip )  ) ) ; 
    return count 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeMap ;
import java.util.TreeSet ;
import javax.management.RuntimeErrorException ;
public class CodeforcesQuestions {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    char arr[][]=new char[n][n];
    int flag=0 ;
    for(int i=0 ; i<n ; i++){
      String s1=s.next();
      for(int j=0 ; j<n ; j++){
        arr[i][j]=s1.charAt(j);
      }
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(i-1>=0){
          if(arr[i-1][j]=='o')count++;
        }
        if(i+1<=n-1){
          if(arr[i+1][j]=='o')count++;
        }
        if(j-1>=0){
          if(arr[i][j-1]=='o')count++;
        }
        if(j+1<=n-1){
          if(arr[i][j+1]=='o')count++;
        }
        if(count % 2!=0){
          flag=1 ;
          break ;
        }
        count=0 ;
      }
      if(flag==1)break ;
    }
    if(flag==0)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeforcesQuestions {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(String)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var s1 : String ; s1 := s.getCurrent() ;
         var j : int ; j := 0 ; while j < n do ( (     arr[i+1][j+1] := s1->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (i - 1 >= 0) then (     if (arr[i - 1+1][j+1] = 'o') then     count := count + 1 ; else skip ) else skip ; 
     if (i + 1 <= n - 1) then (     if (arr[i + 1+1][j+1] = 'o') then     count := count + 1 ; else skip ) else skip ; 
    if ((j)->char2byte() - 1 >= 0) then (     if (arr[i+1][(j)->char2byte() - 1+1] = 'o') then     count := count + 1 ; else skip ) else skip ; 
    if (j + 1 <= n - 1) then (     if (arr[i+1][j + 1+1] = 'o') then     count := count + 1 ; else skip ) else skip ; 
    if (count mod 2 /= 0) then (     flag := 1 ; 
     break ) else skip ; 
    count := 0 ; 
 )  ;     j := j + 1 ) ; 
     if (flag = 1) then     break else skip )  ;     i := i + 1 ) ; 
    if (flag = 0) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashSet ;
import java.util.Scanner ;
public class trailzero {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int r=sc.nextInt();
    int c=r ;
    char a[][]=new char[r][c];
    for(int i=0 ; i<r ; i++){
      String s=sc.next();
      for(int j=0 ; j<c ; j++){
        a[i][j]=s.charAt(j);
      }
    }
    boolean b=true ;
    for(int i=0 ; i<r ; i++){
      for(int j=0 ; j<c ; j++){
        int c1=0 ;
        if(j+1>=0 && j+1<c && a[i][j+1]=='o'){
          c1++;
        }
        if(j-1>=0 && j-1<c && a[i][j-1]=='o'){
          c1++;
        }
        if(i+1>=0 && i+1<r && a[i+1][j]=='o'){
          c1++;
        }
        if(i-1>=0 && i-1<r && a[i-1][j]=='o'){
          c1++;
        }
        if(c1 % 2!=0){
          b=false ;
          break ;
        }
      }
    }
    if(b){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class trailzero {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var c : int ; c := r ;
    var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,r)->collect(Integer.subrange(1,c)->collect(0)) ;
        var i : int ; i := 0 ; while i < r do ( (     var s : String ; s := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < c do ( (     a[i+1][j+1] := s->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var b : boolean ; b := true ;
        var i : int ; i := 0 ; while i < r do ( (         var j : int ; j := 0 ; while j < c do ( (     var c1 : int ; c1 := 0 ;
     if (j + 1 >= 0 & j + 1 < c & a[i+1][j + 1+1] = 'o') then (     c1 := c1 + 1 ) else skip ; 
    if ((j)->char2byte() - 1 >= 0 & (j)->char2byte() - 1 < c & a[i+1][(j)->char2byte() - 1+1] = 'o') then (     c1 := c1 + 1 ) else skip ; 
    if (i + 1 >= 0 & i + 1 < r & a[i + 1+1][j+1] = 'o') then (     c1 := c1 + 1 ) else skip ; 
    if ((i)->char2byte() - 1 >= 0 & (i)->char2byte() - 1 < r & a[(i)->char2byte() - 1+1][j+1] = 'o') then (     c1 := c1 + 1 ) else skip ; 
    if (c1 mod 2 /= 0) then (     b := false ; 
     break ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (b) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.List ;
public class HelloWorld {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      int n=Integer.parseInt(br.readLine());
      boolean[][] board=new boolean[n][n];
      for(int i=0 ; i<n ; i++){
        String line=br.readLine();
        for(int j=0 ; j<n ; j++){
          char ch=line.charAt(j);
          if(ch=='o'){
            board[i][j]=true ;
          }
        }
      }
      boolean even=true ;
      for(int i=0 ; i<n ; i++){
        int c=0 ;
        for(int j=0 ; j<n ; j++){
          if(i-1>=0 && board[i-1][j])c++;
          if(i+1<n && board[i+1][j])c++;
          if(j-1>=0 && board[i][j-1])c++;
          if(j+1<n && board[i][j+1])c++;
          if(c % 2==1)even=false ;
        }
      }
      System.out.println(even ? "YES" : "NO");
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var n : int ; n := (br.readLine())->toInteger() ;
     var board : Sequence(Sequence(boolean)) ; board := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ;
        var i : int ; i := 0 ; while i < n do ( (     var line : String ; line := br.readLine() ;
         var j : int ; j := 0 ; while j < n do ( (     var ch : String ; ch := line->at(j+1) ;
     if (ch = 'o') then (     board[i+1][j+1] := true ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var even : boolean ; even := true ;
        var i : int ; i := 0 ; while i < n do ( (     var c : int ; c := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (i - 1 >= 0 & board[i - 1+1][j+1]) then     c := c + 1 ; else skip ; 
     if (i + 1 < n & board[i + 1+1][j+1]) then     c := c + 1 ; else skip ; 
    if ((j)->char2byte() - 1 >= 0 & board[i+1][(j)->char2byte() - 1+1]) then     c := c + 1 ; else skip ; 
    if (j + 1 < n & board[i+1][j + 1+1]) then     c := c + 1 ; else skip ; 
    if (c mod 2 = 1) then     even := false ; else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if even then "YES" else "NO" endif) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int findLengthOfLCIS(int[] nums){
    if(nums.length==0)return 0 ;
    int curr=1,ans=1 ;
    for(int i=0 ; i<nums.length-1 ; i++){
      if(nums[i]<nums[i+1]){
        curr++;
        if(curr>=ans)ans=curr ;
      }
      else {
        curr=1 ;
      }
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation findLengthOfLCIS( nums : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (nums->size() = 0) then     return 0 else skip ; 
     var curr : int ; curr := 1 ;
    var ans : int ; ans := 1 ;
         var i : int ; i := 0 ; while i < nums->size() - 1 do ( (     if (nums[i+1] < nums[i + 1+1]) then (     curr := curr + 1 ; 
     if (curr >= ans) then     ans := curr ; else skip ) else (     curr := 1 ) )  ;     i := i + 1 ) ; 
     return ans );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=100001 ;
  static void find_distinct(int a[],int n,int q,int queries[]){
    int[] check=new int[MAX];
    int[] idx=new int[MAX];
    int cnt=1 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(check[a[i] ]==0){
        idx[i]=cnt ;
        check[a[i] ]=1 ;
        cnt++;
      }
      else {
        idx[i]=cnt-1 ;
      }
    }
    for(int i=0 ; i<q ; i++){
      int m=queries[i];
      System.out.print(idx[m]+" ");
    }
  }
  public static void main(String[] args){
    int a[]={
      1,2,3,1,2,3,4,5 };
      int n=a.length ;
      int queries[]={
        0,3,5,7 };
        int q=queries.length ;
        find_distinct(a,n,q,queries);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100001;
  static   operation find_distinct( a : Sequence(int), n : int, q : int, queries : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var check : Sequence(int) ; check := Integer.subrange(1,MAX)->collect(0) ;
     var idx : Sequence(int) ; idx := Integer.subrange(1,MAX)->collect(0) ;
    var cnt : int ; cnt := 1 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (check[a[i+1]+1] = 0) then (     idx[i+1] := cnt ; 
     check[a[i+1]+1] := 1 ; 
     cnt := cnt + 1 ) else (     idx[i+1] := cnt - 1 ) )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var m : int ; m := queries[i+1] ;
     OclFile["System.out"].print(idx[m+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,1,2,3,4,5} ;
     var n : int ; n := a->size() ;
    var queries : Sequence(int) ; queries := Sequence{0,3,5,7} ;
    var q : int ; q := queries->size() ;
    execute find_distinct(a, n, q, queries) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] arg){
    Scanner sc=new Scanner(System.in);
    int ninzu=sc.nextInt();
    int[] teamscore=new int[ninzu+1];
    for(int i=0 ; i<ninzu ; i++){
      teamscore[i]=sc.nextInt();
    }
    teamscore[ninzu]=0 ;
    Arrays.sort(teamscore);
    int tmp=0 ;
    for(int h=100 ; h>=1 ; h--){
      tmp=0 ;
      for(int i=1 ; i<=ninzu ; i++){
        if(teamscore[i]>=h){
          tmp++;
        }
      }
      if(tmp>=h){
        System.out.println(h);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ninzu : int ; ninzu := sc.getCurrent()->toInteger() ;
    var teamscore : Sequence(int) ; teamscore := Integer.subrange(1,ninzu + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < ninzu do ( (     teamscore[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    teamscore[ninzu+1] := 0 ; 
    teamscore := teamscore->sort() ; 
    var tmp : int ; tmp := 0 ;
        var h : int ; h := 100 ; while h >= 1 do ( (     tmp := 0 ; 
         var i : int ; i := 1 ; while i <= ninzu do ( (     if (teamscore[i+1] >= h) then (     tmp := tmp + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (tmp >= h) then (     OclFile["System.out"].println(h) ; 
     break ) else skip )  ;     h := h - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int N=parseInt(br.readLine());
    int[] score=new int[102];
    StringTokenizer st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<N ; i++){
      score[parseInt(st.nextToken())]++;
    }
    int ans=0 ;
    for(int i=100 ; i>=0 ; i--){
      score[i]+=score[i+1];
      if(score[i]>=i){
        ans=i ;
        break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var N : int ; N := parseInt(br.readLine()) ;
    var score : Sequence(int) ; score := Integer.subrange(1,102)->collect(0) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < N do ( (     score[parseInt(st.next())+1] := score[parseInt(st.next())+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 100 ; while i >= 0 do ( (     score[i+1] := score[i+1]+(score[i + 1+1]) ; 
     if (score[i+1] >= i) then (     ans := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] array=new int[100];
    for(int i=0 ; i<n ; i++){
      array[sc.nextInt()-1]++;
    }
    int score=0 ;
    for(int i=0 ; i<array.length ; i++){
      int count=0 ;
      for(int j=array.length-1 ; j>=score ; j--){
        count+=array[j];
      }
      if(count>score && count>0){
        score=i+1 ;
      }
    }
    System.out.println(score);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,100)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     array[sc.getCurrent()->toInteger() - 1+1] := array[sc.getCurrent()->toInteger() - 1+1] + 1 )  ;     i := i + 1 ) ; 
    var score : int ; score := 0 ;
        var i : int ; i := 0 ; while i < array->size() do ( (     var count : int ; count := 0 ;
         var j : int ; j := array->size() - 1 ; while j >= score do ( (     count := count+(array[j+1]) )  ;     j := j - 1 ) ; 
     if (count > score & count > 0) then (     score := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(score) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.Comparable ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String x=sc.next();
    String y=sc.next();
    if(x.compareTo(y)==0){
      System.out.println("=");
    }
    else if(x.compareTo(y)<0){
      System.out.println("<");
    }
    else if(x.compareTo(y)>0){
      System.out.println(">");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : String ; x := sc.getCurrent() ;
    var y : String ; y := sc.getCurrent() ;
    if (x->compareTo(y) = 0) then (     OclFile["System.out"].println("=") ) else     if (x->compareTo(y) < 0) then (     OclFile["System.out"].println("<") ) else     if (x->compareTo(y) > 0) then (     OclFile["System.out"].println(">") ) else skip ; ;  ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[] a=new int[n];
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=scan.nextInt();
    }
    Arrays.sort(a);
    for(int i=0 ; i<n ; i++){
      if(a[i]>=n-i){
        ans=n-i ;
        break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] >= n - i) then (     ans := n - i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int count[]=new int[101];
    for(int i=0 ; i<N ; ++i){
      int A=sc.nextInt();
      count[A]++;
    }
    for(int a=100 ; a>=1 ; --a){
      count[a-1]+=count[a];
    }
    int max=0 ;
    for(int a=0 ; a<=100 ; ++a){
      if(count[a]>=a){
        max=a ;
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var count : Sequence(int) ; count := Integer.subrange(1,101)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     var A : int ; A := sc.getCurrent()->toInteger() ;
     count[A+1] := count[A+1] + 1 )  ;     i := i + 1 ) ; 
        var a : int ; a := 100 ; while a >= 1 do ( (     count[a - 1+1] := count[a - 1+1]+(count[a+1]) )  ;     a := a - 1 ) ; 
    var max : int ; max := 0 ;
        var a : int ; a := 0 ; while a <= 100 do ( (     if (count[a+1] >= a) then (     max := a ) else skip )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int sumDigitSquare(int n){
    int sq=0 ;
    while(n!=0){
      int digit=n % 10 ;
      sq+=digit*digit ;
      n=n/10 ;
    }
    return sq ;
  }
  static boolean isHappy(int n){
    while(true){
      if(n==1)return true ;
      n=sumDigitSquare(n);
      if(n==4)return false ;
    }
  }
  public static void main(String args[]){
    int n=23 ;
    if(isHappy(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumDigitSquare( n : int) : int
  pre: true
  post: true
  activity: (     var sq : int ; sq := 0 ;
     while (n /= 0) do (     var digit : int ; digit := n mod 10 ;
     sq := sq+(digit * digit) ; 
     n := n / 10 ) ; 
     return sq );
  static   operation isHappy( n : int) : boolean
  pre: true
  post: true
  activity: (     while (true) do (     if (n = 1) then     return true else skip ; 
     n := sumDigitSquare(n) ; 
     if (n = 4) then     return false else skip ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 23 ;
     if (isHappy(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float exponential(int n,float x){
    float sum=1 ;
    for(int i=n-1 ; i>0 ; --i)sum=1+x*sum/i ;
    return sum ;
  }
  public static void main(String[] args){
    int n=10 ;
    float x=1 ;
    System.out.println("e^x="+exponential(n,x));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation exponential( n : int, x : double) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 1 ;
         var i : int ; i := n - 1 ; while i > 0 do (     sum := 1 + x * sum / i ;  ;     i := i - 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     var x : double ; x := 1 ;
     OclFile["System.out"].println("e^x=" + exponential(n, x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int trailingZero(int x){
    int i=5,count=0 ;
    while(x>i){
      count=count+x/i ;
      i=i*5 ;
    }
    return count ;
  }
  static int countProductTrailing(int M,int N){
    return trailingZero(N)+trailingZero(M);
  }
  public static void main(String args[]){
    int N=67,M=98 ;
    System.out.println(countProductTrailing(N,M));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation trailingZero( x : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 5 ;
    var count : int ; count := 0 ;
     while (x > i) do (     count := count + x / i ; 
     i := i * 5 ) ; 
     return count );
  static   operation countProductTrailing( M : int, N : int) : int
  pre: true
  post: true
  activity: (     return trailingZero(N) + trailingZero(M) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 67 ;
    var M : int ; M := 98 ;
     OclFile["System.out"].println(countProductTrailing(N, M)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int devider=1000000007 ;
    if(Math.abs(n-m)>1){
      System.out.println(0);
      return ;
    }
    long count=1 ;
    if(n==m){
      while(n!=1){
        count*=n ;
        count %=devider ;
        count*=m ;
        count %=devider ;
        n--;
        m--;
      }
      count*=2 ;
      count %=devider ;
    }
    else {
      int large=Math.max(n,m);
      int small=Math.min(n,m);
      while(large!=1){
        count*=large ;
        count %=devider ;
        count*=small ;
        count %=devider ;
        large--;
        small--;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var devider : int ; devider := 1000000007 ;
    if (if n - m < 0 then -(n - m) else n - m endif > 1) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var count : long ; count := 1 ;
    if (n = m) then (     while (n /= 1) do (     count := count*(n) ; 
     count := count mod devider ; 
    count := count*(m) ; 
    count := count mod devider ; 
    n := n - 1 ; 
    m := m - 1 ; 
 ) ; 
     count := count*(2) ; 
     count := count mod devider ) else (     var large : int ; large := Set{n, m}->max() ;
     var small : int ; small := Set{n, m}->min() ;
     while (large /= 1) do (     count := count*(large) ; 
     count := count mod devider ; 
    count := count*(small) ; 
    count := count mod devider ; 
    large := large - 1 ; 
    small := small - 1 ; 
 ) ) ;  
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner scan=new Scanner(System.in);
    long all=scan.nextLong();
    long left=0 ;
    long right=0 ;
    for(int i=0 ; i<all ; i++){
      long a=scan.nextLong();
      String p=scan.next();
      long num=scan.nextLong();
      if(p.equals("(")){
        left+=num ;
      }
      else {
        right+=num ;
      }
      if(left==right){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var all : long ; all := scan.getCurrent()->toLong() ;
    var left : long ; left := 0 ;
    var right : long ; right := 0 ;
        var i : int ; i := 0 ; while i < all do ( (     var a : long ; a := scan.getCurrent()->toLong() ;
     var p : String ; p := scan.getCurrent() ;
    var num : long ; num := scan.getCurrent()->toLong() ;
    if (p = "(") then (     left := left+(num) ) else (     right := right+(num) ) ;  
    if (left = right) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  int n,m ;
  int MOD=1000000007 ;
  public static void main(String args[]){
    new Main().run();
  }
  void run(){
    FastReader sc=new FastReader();
    n=sc.nextInt();
    m=sc.nextInt();
    solve();
  }
  void solve(){
    if(n>m){
      int temp=n ;
      n=m ;
      m=temp ;
    }
    if(m-n>1){
      System.out.println(0);
      return ;
    }
    long ans=0 ;
    long[] facts=fillFactorial(m,MOD);
    if(n==m){
      ans=2*facts[n]*facts[m] % MOD ;
    }
    else {
      ans=facts[n]*facts[m] % MOD ;
    }
    System.out.println(ans);
  }
  long[] fillFactorial(int max,int mod){
    long[] facts=new long[max+1];
    facts[0]=1 ;
    for(int i=1 ; i<facts.length ; i++){
      facts[i]=facts[i-1]*i % mod ;
    }
    return facts ;
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     n := sc.nextInt() ; 
     m := sc.nextInt() ; 
     execute solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     if (n > m) then (     var temp : int ; temp := n ;
     n := m ; 
     m := temp ) else skip ; 
     if (m - n > 1) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var ans : long ; ans := 0 ;
    var facts : Sequence(long) ; facts := fillFactorial(m, MOD) ;
    if (n = m) then (     ans := 2 * facts[n+1] * facts[m+1] mod MOD ) else (     ans := facts[n+1] * facts[m+1] mod MOD ) ;  
    OclFile["System.out"].println(ans) ; 
 );
   operation fillFactorial( max : int, mod : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var facts : Sequence(long) ; facts := Integer.subrange(1,max + 1)->collect(0) ;
     facts[0+1] := 1 ; 
         var i : int ; i := 1 ; while i < facts->size() do ( (     facts[i+1] := facts[i - 1+1] * i mod mod )  ;     i := i + 1 ) ; 
     return facts );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int M=scan.nextInt();
    long sum=1 ;
    if((int)Math.abs(N-M)==0 ||(int)Math.abs(N-M)==1){
      for(long i=1 ; i<=N ; i++){
        sum=(sum*i)% 1000000007 ;
      }
      for(long i=1 ; i<=M ; i++){
        sum=(sum*i)% 1000000007 ;
      }
      if((int)Math.abs(N-M)==0){
        sum=(sum*2)% 1000000007 ;
      }
    }
    else {
      sum=0 ;
    }
    System.out.println(sum);
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var M : int ; M := scan.getCurrent()->toInteger() ;
    var sum : long ; sum := 1 ;
    if (if N - M < 0 then -(N - M) else N - M endif->oclAsType(int) = 0 or if N - M < 0 then -(N - M) else N - M endif->oclAsType(int) = 1) then (         var i : long ; i := 1 ; while i <= N do ( (     sum := (sum * i) mod 1000000007 )  ;     i := i + 1 ) ; 
         var i : long ; i := 1 ; while i <= M do ( (     sum := (sum * i) mod 1000000007 )  ;     i := i + 1 ) ; 
     if (if N - M < 0 then -(N - M) else N - M endif->oclAsType(int) = 0) then (     sum := (sum * 2) mod 1000000007 ) else skip ) else (     sum := 0 ) ;  
    OclFile["System.out"].println(sum) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.IOException ;
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Deque ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    long N=in.nextLong();
    long M=in.nextLong();
    long MOD=1000000007 ;
    long ans=0 ;
    if(N-M==0){
      ans=factorial(N,MOD);
      ans=(ans*ans*2)% MOD ;
    }
    else if(Math.abs(N-M)==1){
      ans=(factorial(N,MOD)*factorial(M,MOD))% MOD ;
    }
    System.out.println(ans);
  }
  public static long factorial(long n,long MOD){
    long ans=1 ;
    for(long i=n ; i>=2 ; i--){
      ans*=i ;
      ans %=MOD ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := in.getCurrent()->toLong() ;
    var M : long ; M := in.getCurrent()->toLong() ;
    var MOD : long ; MOD := 1000000007 ;
    var ans : long ; ans := 0 ;
    if (N - M = 0) then (     ans := factorial(N, MOD) ; 
     ans := (ans * ans * 2) mod MOD ) else     if (if N - M < 0 then -(N - M) else N - M endif = 1) then (     ans := (factorial(N, MOD) * factorial(M, MOD)) mod MOD ) else skip ; ;  
    OclFile["System.out"].println(ans) ; 
 );
  static   operation factorial( n : long, MOD : long) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
         var i : long ; i := n ; while i >= 2 do ( (     ans := ans*(i) ; 
     ans := ans mod MOD )  ;     i := i - 1 ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String a,b ;
    a=sc.next();
    b=sc.next();
    int a2=0,b2=0 ;
    if(a.equals("A"))a2=10 ;
    else if(a.equals("B"))a2=11 ;
    else if(a.equals("C"))a2=12 ;
    else if(a.equals("D"))a2=13 ;
    else if(a.equals("E"))a2=14 ;
    else if(a.equals("F"))a2=15 ;
    if(b.equals("A"))b2=10 ;
    else if(b.equals("B"))b2=11 ;
    else if(b.equals("C"))b2=12 ;
    else if(b.equals("D"))b2=13 ;
    else if(b.equals("E"))b2=14 ;
    else if(b.equals("F"))b2=15 ;
    if(a2>b2)System.out.println(">");
    else if(a2<b2)System.out.println("<");
    else if(a2==b2)System.out.println("=");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ;
    var b : String ;
    a := sc.getCurrent() ; 
    b := sc.getCurrent() ; 
    var a2 : int ; a2 := 0 ;
    var b2 : int ; b2 := 0 ;
    if (a = "A") then     a2 := 10 else     if (a = "B") then     a2 := 11 else     if (a = "C") then     a2 := 12 else     if (a = "D") then     a2 := 13 else     if (a = "E") then     a2 := 14 else     if (a = "F") then     a2 := 15 ; else skip ; ;  ;  ;  ;  ;  
    if (b = "A") then     b2 := 10 else     if (b = "B") then     b2 := 11 else     if (b = "C") then     b2 := 12 else     if (b = "D") then     b2 := 13 else     if (b = "E") then     b2 := 14 else     if (b = "F") then     b2 := 15 ; else skip ; ;  ;  ;  ;  ;  
    if (a2 > b2) then     OclFile["System.out"].println(">") else     if (a2 < b2) then     OclFile["System.out"].println("<") else     if (a2 = b2) then     OclFile["System.out"].println("=") ; else skip ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javax.swing.*;
import java.util.*;
public class Main {
  static final long MOD=1000000007 ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int a=scanner.nextInt();
    int b=scanner.nextInt();
    long[][] map=new long[a+b+1][2];
    int N=a+b ;
    int tempa=a ;
    int tempb=b ;
    map[0][0]=0l ;
    map[0][1]=a ;
    int flag=0 ;
    long to=a ;
    a--;
    for(int i=1 ; i<N ; i++){
      if(map[i-1][0]==0){
        map[i][0]=1 ;
        to=to*b % MOD ;
        b--;
      }
      else {
        map[i][0]=0 ;
        to=to*a % MOD ;
        a--;
      }
    }
    a=tempa ;
    b=tempb ;
    map[0][0]=1l ;
    map[0][1]=b ;
    flag=0 ;
    long to2=b ;
    b--;
    for(int i=1 ; i<N ; i++){
      if(map[i-1][0]==0){
        map[i][0]=1 ;
        to2=to2*b % MOD ;
        b--;
      }
      else {
        map[i][0]=0 ;
        to2=to2*a % MOD ;
        a--;
      }
    }
    System.out.println((to+to2)% MOD);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(long)) ; map := Integer.subrange(1,a + b + 1)->collect(Integer.subrange(1,2)->collect(0)) ;
    var N : int ; N := a + b ;
    var tempa : int ; tempa := a ;
    var tempb : int ; tempb := b ;
    map[0+1][0+1] := 0l ; 
    map[0+1][1+1] := a ; 
    var flag : int ; flag := 0 ;
    var to : long ; to := a ;
    a := a - 1 ; 
        var i : int ; i := 1 ; while i < N do ( (     if (map[i - 1+1][0+1] = 0) then (     map[i+1][0+1] := 1 ; 
     to := to * b mod MOD ; 
     b := b - 1 ) else (     map[i+1][0+1] := 0 ; 
     to := to * a mod MOD ; 
     a := a - 1 ) )  ;     i := i + 1 ) ; 
    a := tempa ; 
    b := tempb ; 
    map[0+1][0+1] := 1l ; 
    map[0+1][1+1] := b ; 
    flag := 0 ; 
    var to2 : long ; to2 := b ;
    b := b - 1 ; 
        var i : int ; i := 1 ; while i < N do ( (     if (map[i - 1+1][0+1] = 0) then (     map[i+1][0+1] := 1 ; 
     to2 := to2 * b mod MOD ; 
     b := b - 1 ) else (     map[i+1][0+1] := 0 ; 
     to2 := to2 * a mod MOD ; 
     a := a - 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((to + to2) mod MOD) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int koma[]=new int[n];
    for(int i=0 ; i<n ; i++){
      koma[i]=sc.nextInt();
    }
    int m=sc.nextInt();
    for(int i=0 ; i<m ; i++){
      int command=sc.nextInt();
      if(command==n){
        if(koma[command-1]!=2019)koma[command-1]++;
      }
      else if(koma[command-1]+1!=koma[command]){
        koma[command-1]++;
      }
    }
    for(int i=0 ; i<n ; i++)System.out.println(koma[i]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var koma : Sequence(int) ; koma := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     koma[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     var command : int ; command := sc.getCurrent()->toInteger() ;
     if (command = n) then (     if (koma[command - 1+1] /= 2019) then     koma[command - 1+1] := koma[command - 1+1] + 1 ; else skip ) else     if (koma[command - 1+1] + 1 /= koma[command+1]) then (     koma[command - 1+1] := koma[command - 1+1] + 1 ) else skip ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].println(koma[i+1]) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Piece {
  private int position ;
  public Piece(){
  }
  public void setPosition(int pos){
    this.position=pos ;
  }
  public int getPosition(){
    return this.position ;
  }
  public void movePosition(){
    this.position++;
  }
}
class Rule {
  public Rule(){
  }
  public void movePiece(Piece piece1,Piece piece2){
    int pos1=piece1.getPosition();
    int pos2=piece2.getPosition();
    if(pos1+1!=pos2){
      piece1.movePosition();
    }
  }
}
public class Main {
  public static void main(String[] args){
    final int MAX_POS=2020 ;
    Rule rule=new Rule();
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    Piece[] pieces=new Piece[N+2];
    for(int i=1 ; i<=N ; i++){
      int X=Integer.parseInt(sc.next());
      pieces[i]=new Piece();
      pieces[i] .setPosition(X);
    }
    pieces[N+1]=new Piece();
    pieces[N+1] .setPosition(MAX_POS);
    int M=Integer.parseInt(sc.next());
    for(int i=0 ; i<M ; i++){
      int A=Integer.parseInt(sc.next());
      rule.movePiece((pieces[A]),pieces[A+1]);
    }
    for(int i=1 ; i<=N ; i++){
      System.out.println(pieces[i] .getPosition());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Piece {
   attribute position : int;
   static operation newPiece() : Piece
  pre: true
  post: true
  activity:
  ( var self : Piece ;
    self := createPiece();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   operation setPosition( pos : int) : void
  pre: true
  post: true
  activity: (     self.position := pos );
   operation getPosition() : int
  pre: true
  post: true
  activity: (     return self.position );
   operation movePosition() : void
  pre: true
  post: true
  activity: (     self.position := self.position + 1 );
}
class Rule {
   static operation newRule() : Rule
  pre: true
  post: true
  activity:
  ( var self : Rule ;
    self := createRule();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   operation movePiece( piece1 : Piece, piece2 : Piece) : void
  pre: true
  post: true
  activity: (     var pos1 : int ; pos1 := piece1.getPosition() ;
     var pos2 : int ; pos2 := piece2.getPosition() ;
     if (pos1 + 1 /= pos2) then (     piece1.movePosition() ) else skip );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var MAX_POS : int ; MAX_POS := 2020 ;
     var rule : Rule ; rule := Rule.newRule() ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var N : int ; N := (sc.getCurrent())->toInteger() ;
    var pieces : Sequence(Piece) ; pieces := Integer.subrange(1,N + 2)->collect(null) ;
        var i : int ; i := 1 ; while i <= N do ( (     var X : int ; X := (sc.getCurrent())->toInteger() ;
     pieces[i+1] := Piece.newPiece() ; 
     pieces[i+1].setPosition(X) )  ;     i := i + 1 ) ; 
    pieces[N + 1+1] := Piece.newPiece() ; 
    pieces[N + 1+1].setPosition(MAX_POS) ; 
    var M : int ; M := (sc.getCurrent())->toInteger() ;
        var i : int ; i := 0 ; while i < M do ( (     var A : int ; A := (sc.getCurrent())->toInteger() ;
     rule.movePiece((pieces[A+1]), pieces[A + 1+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (     OclFile["System.out"].println(pieces[i+1].getPosition()) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    Scanner sc=new Scanner(systemin);
    int[] masu=new int[2019+1];
    int N=sc.nextInt();
    int[] X=new int[N+1];
    for(int n=1 ; n<=N ; n++){
      X[n]=sc.nextInt();
      masu[X[n] ]=1 ;
    }
    int M=sc.nextInt();
    for(int m=0 ; m<M ; m++){
      int A=sc.nextInt();
      if(X[A]<2019 && masu[X[A]+1]==0){
        masu[X[A] ]--;
        X[A]++;
        masu[X[A] ]++;
      }
    }
    for(int n=1 ; n<=N ; n++){
      result.printf("%d\n",X[n]);
    }
    sc.close();
    return false ;
  }
  PrintStream log ;
  PrintStream result=System.out ;
  BufferedReader systemin ;
  static Main instance=new Main();
  Main(){
    systemin=new BufferedReader(new InputStreamReader(System.in));
    log=new PrintStream(new OutputStream(){
      public void write(int b){
      }
    }
);
  }
  public static void main(String[] args)throws IOException {
    instance.main();
    instance.systemin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(systemin) ;
     var masu : Sequence(int) ; masu := Integer.subrange(1,2019 + 1)->collect(0) ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var X : Sequence(int) ; X := Integer.subrange(1,N + 1)->collect(0) ;
        var n : int ; n := 1 ; while n <= N do ( (     X[n+1] := sc.getCurrent()->toInteger() ; 
     masu[X[n+1]+1] := 1 )  ;     n := n + 1 ) ; 
    var M : int ; M := sc.getCurrent()->toInteger() ;
        var m : int ; m := 0 ; while m < M do ( (     var A : int ; A := sc.getCurrent()->toInteger() ;
     if (X[A+1] < 2019 & masu[X[A+1] + 1+1] = 0) then (     masu[X[A+1]+1] := masu[X[A+1]+1] - 1 ; 
     X[A+1] := X[A+1] + 1 ; 
     masu[X[A+1]+1] := masu[X[A+1]+1] + 1 ) else skip )  ;     m := m + 1 ) ; 
        var n : int ; n := 1 ; while n <= N do ( (     result.printf("%d\n", X[n+1]) )  ;     n := n + 1 ) ; 
    skip ; 
    return false 
 );
   attribute log : OclFile;
   attribute result : OclFile := OclFile["System.out"];
   attribute systemin : OclFile;
  static   attribute instance : Main := Main.newMain();
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     systemin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     log := OclFile.newOclFile_Write(OclFile()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     instance.main() ; 
     instance.systemin.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static final int MAX=2019 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] X=new int[N];
    for(int i=0 ; i<N ; i++){
      X[i]=sc.nextInt();
    }
    int M=sc.nextInt();
    for(int i=0 ; i<M ; i++){
      int A=sc.nextInt();
      advancePiece(X,A);
    }
    for(int i=0 ; i<N ; i++){
      System.out.println(X[i]);
    }
    sc.close();
  }
  static void advancePiece(int[] x,int a){
    int work=x[a-1]+1 ;
    if(work==MAX+1){
      return ;
    }
    for(int i=0 ; i<x.length ; i++){
      if(work==x[i]){
        return ;
      }
    }
    x[a-1]=work ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 2019;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var X : Sequence(int) ; X := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     X[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var M : int ; M := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < M do ( (     var A : int ; A := sc.getCurrent()->toInteger() ;
     execute advancePiece(X, A) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].println(X[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation advancePiece( x : Sequence(int), a : int) : void
  pre: true
  post: true
  activity: (     var work : int ; work := x[a - 1+1] + 1 ;
     if (work = MAX + 1) then (     return ) else skip ; 
         var i : int ; i := 0 ; while i < x->size() do ( (     if (work = x[i+1]) then (     return ) else skip )  ;     i := i + 1 ) ; 
     x[a - 1+1] := work );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int num=sc.nextInt();
      List<Integer>pieces=new ArrayList<Integer>();
      for(int i=0 ; i<num ; i++)pieces.add(sc.nextInt());
      int times=sc.nextInt();
      for(int i=0 ; i<times ; i++){
        int call=sc.nextInt()-1 ;
        int now=pieces.get(call);
        if((now!=2019)&&(! pieces.contains(now+1))){
          pieces.set(call,now+1);
        }
      }
      for(int i=0 ; i<num ; i++){
        System.out.println(pieces.get(i));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var num : int ; num := sc.getCurrent()->toInteger() ;
     var pieces : Sequence(int) ; pieces := Sequence{} ;
        var i : int ; i := 0 ; while i < num do (     pieces := pieces->including(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    var times : int ; times := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < times do ( (     var call : int ; call := sc.getCurrent()->toInteger() - 1 ;
     var now : int ; now := pieces->at(call+1) ;
     if ((now /= 2019) & (not(pieces->includes(now + 1)))) then (     pieces := pieces.setAt(call+1,now + 1) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < num do ( (     OclFile["System.out"].println(pieces->at(i+1)) )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static long getPairs(Vector<Integer>A,Vector<Integer>B,int n){
    int[] D=new int[n];
    for(int i=0 ; i<n ; i++){
      D[i]=A.get(i)-B.get(i);
    }
    Arrays.sort(D);
    long total=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(D[i]>0){
        total+=n-i-1 ;
      }
      else {
        int k=upper_bound(D,0,D.length,-D[i]);
        total+=n-k ;
      }
    }
    return total ;
  }
  static int upper_bound(int[] a,int low,int high,int element){
    while(low<high){
      int middle=low+(high-low)/2 ;
      if(a[middle]>element)high=middle ;
      else low=middle+1 ;
    }
    return low ;
  }
  public static void main(String[] args){
    int n=5 ;
    Vector<Integer>A=new Vector<Integer>();
    Vector<Integer>B=new Vector<Integer>();
    A.add(4);
    A.add(8);
    A.add(2);
    A.add(6);
    A.add(2);
    B.add(4);
    B.add(5);
    B.add(4);
    B.add(1);
    B.add(3);
    System.out.print(getPairs(A,B,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getPairs( A : Sequence(int), B : Sequence(int), n : int) : long
  pre: true
  post: true
  activity: (     var D : Sequence(int) ; D := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     D[i+1] := A->at(i+1) - B->at(i+1) )  ;     i := i + 1 ) ; 
    D := D->sort() ; 
    var total : long ; total := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (D[i+1] > 0) then (     total := total+(n - i - 1) ) else (     var k : int ; k := upper_bound(D, 0, D->size(), -D[i+1]) ;
     total := total+(n - k) ) )  ;     i := i - 1 ) ; 
    return total 
 );
  static   operation upper_bound( a : Sequence(int), low : int, high : int, element : int) : int
  pre: true
  post: true
  activity: (     while (low < high) do (     var middle : int ; middle := low + (high - low) / 2 ;
     if (a[middle+1] > element) then     high := middle ; else     low := middle + 1 ; ) ; 
     return low );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var A : Sequence(int) ; A := Sequence{} ;
    var B : Sequence(int) ; B := Sequence{} ;
    A := A->including(4) ; 
    A := A->including(8) ; 
    A := A->including(2) ; 
    A := A->including(6) ; 
    A := A->including(2) ; 
    B := B->including(4) ; 
    B := B->including(5) ; 
    B := B->including(4) ; 
    B := B->including(1) ; 
    B := B->including(3) ; 
    OclFile["System.out"].print(getPairs(A, B, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static void solve(){
    int q=in.nextInt();
    StringBuilder s=new StringBuilder();
    long l=0,r=0 ;
    while(q-->0){
      long pos=in.nextLong();
      char c=in.next().charAt(0);
      int n=in.nextInt();
      if(c=='('){
        l+=n ;
      }
      else {
        r+=n ;
      }
      out.println(l==r ? "Yes" : "No");
    }
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    solve();
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var q : int ; q := in.getCurrent()->toInteger() ;
     var s : String ; s := StringLib.newString() ;
     var l : long ; l := 0 ;
    var r : long ; r := 0 ;
         while (q > 0) do (        q := q - 1 ;     skip ; (     var pos : long ; pos := in.getCurrent()->toLong() ;
     var c : String ; c := in.getCurrent()->at(0+1) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    if (c = '(') then (     l := l+(n) ) else (     r := r+(n) ) ;  
    skip ; 
 ) ;  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    execute solve() ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int arr[]=new int[] {
    1,0,0,1,1,0,1,0,1,1 };
    static void findZeroes(int m){
      int wL=0,wR=0 ;
      int bestL=0,bestWindow=0 ;
      int zeroCount=0 ;
      while(wR<arr.length){
        if(zeroCount<=m){
          if(arr[wR]==0)zeroCount++;
          wR++;
        }
        if(zeroCount>m){
          if(arr[wL]==0)zeroCount--;
          wL++;
        }
        if((wR-wL>bestWindow)&&(zeroCount<=m)){
          bestWindow=wR-wL ;
          bestL=wL ;
        }
      }
      for(int i=0 ; i<bestWindow ; i++){
        if(arr[bestL+i]==0)System.out.print(bestL+i+" ");
      }
    }
    public static void main(String[] args){
      int m=2 ;
      System.out.println("Indexes of zeroes to be flipped are ");
      findZeroes(m);
    }
  }

------------------------------------------------------------
OCL File:
---------
class Test {
  static   attribute arr : int := Sequence{1,0,0,1,1,0,1,0,1,1};
  static   operation findZeroes( m : int) : void
  pre: true
  post: true
  activity: (     var wL : int ; wL := 0 ;
    var wR : int ; wR := 0 ;
     var bestL : int ; bestL := 0 ;
    var bestWindow : int ; bestWindow := 0 ;
    var zeroCount : int ; zeroCount := 0 ;
    while (wR < arr->size()) do (     if (zeroCount <= m) then (     if (arr[wR+1] = 0) then     zeroCount := zeroCount + 1 ; else skip ; 
     wR := wR + 1 ) else skip ; 
     if (zeroCount > m) then (     if (arr[wL+1] = 0) then     zeroCount := zeroCount - 1 ; else skip ; 
     wL := wL + 1 ) else skip ; 
     if ((wR - wL > bestWindow) & (zeroCount <= m)) then (     bestWindow := wR - wL ; 
     bestL := wL ) else skip ) ; 
        var i : int ; i := 0 ; while i < bestWindow do ( (     if (arr[bestL + i+1] = 0) then     OclFile["System.out"].print(bestL + i + " ") ; else skip )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 2 ;
     OclFile["System.out"].println("Indexes of zeroes to be flipped are ") ; 
     execute findZeroes(m) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAX=1000006 ;
  static void sieve(int count[]){
    for(int i=2 ; i*i<=MAX ; i++){
      if(count[i]==0){
        for(int j=2*i ; j<MAX ; j+=i)count[j]++;
        count[i]=1 ;
      }
    }
  }
  static int query(int count[],int l,int r){
    int sum=0 ;
    for(int i=l ; i<=r ; i++)sum+=count[i];
    return sum ;
  }
  public static void main(String[] args){
    int count[]=new int[MAX];
    sieve(count);
    System.out.println(query(count,6,10)+" "+query(count,1,5));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 1000006;
  static   operation sieve( count : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= MAX do ( (     if (count[i+1] = 0) then (         var j : int ; j := 2 * i ; while j < MAX do (     count[j+1] := count[j+1] + 1 ;  ;     j := j+(i) ) ; 
     count[i+1] := 1 ) else skip )  ;     i := i + 1 ) );
  static   operation query( count : Sequence(int), l : int, r : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := l ; while i <= r do (     sum := sum+(count[i+1]) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,MAX)->collect(0) ;
     execute sieve(count) ; 
     OclFile["System.out"].println(query(count, 6, 10) + " " + query(count, 1, 5)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char X=sc.next().charAt(0);
    char Y=sc.next().charAt(0);
    System.out.println(solve(X,Y));
    sc.close();
  }
  static String solve(char X,char Y){
    if(X<Y){
      return "<" ;
    }
    else if(X>Y){
      return ">" ;
    }
    else {
      return "=" ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : String ; X := sc.getCurrent()->at(0+1) ;
    var Y : String ; Y := sc.getCurrent()->at(0+1) ;
    OclFile["System.out"].println(solve(X, Y)) ; 
    skip ; 
 );
  static   operation solve( X : String, Y : String) : String
  pre: true
  post: true
  activity: (     if (X < Y) then (     return "<" ) else     if (X > Y) then (     return ">" ) else (     return "=" ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class YearNumber {
  int number ;
  public YearNumber(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  public void input(int number){
    boolean b=true ;
    int num=number % 2020 ;
    int numberDiv=number/2020 ;
    if(num<=numberDiv){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    YearNumber instance=new YearNumber(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      int num=input.nextInt();
      instance.input(num);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class YearNumber {
   attribute number : int;
   static operation newYearNumber( number : int) : YearNumber
  pre: true
  post: true
  activity:
  ( var self : YearNumber ;
    self := createYearNumber();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
   operation input( number : int) : void
  pre: true
  post: true
  activity: (     var b : boolean ; b := true ;
     var num : int ; num := number mod 2020 ;
     var numberDiv : int ; numberDiv := number / 2020 ;
     if (num <= numberDiv) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
     var instance : YearNumber ; instance := YearNumber.newYearNumber(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
     instance.input(num) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Solver {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int tt=0 ; tt<T ; tt++){
      int n=in.nextInt();
      int cnt21=(n % 2020);
      int cnt20=(n-(2021*cnt21))/2020 ;
      if(cnt20>=0 &&(cnt21*2021)+(cnt20*2020)==n){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solver {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var tt : int ; tt := 0 ; while tt < T do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var cnt21 : int ; cnt21 := (n mod 2020) ;
     var cnt20 : int ; cnt20 := (n - (2021 * cnt21)) / 2020 ;
     if (cnt20 >= 0 & (cnt21 * 2021) + (cnt20 * 2020) = n) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) )  ;     tt := tt + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class NewYear {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int temp1=0 ;
    int temp2=0 ;
    while(t-->0){
      int n=sc.nextInt();
      temp1=n/2020 ;
      if(temp1<1){
        System.out.println("NO");
      }
      else {
        int lastDigit=n % 2020 ;
        if(lastDigit>temp1){
          System.out.println("NO");
        }
        else {
          System.out.println("YES");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewYear {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var temp1 : int ; temp1 := 0 ;
    var temp2 : int ; temp2 := 0 ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     temp1 := n / 2020 ; 
     if (temp1 < 1) then (     OclFile["System.out"].println("NO") ) else (     var lastDigit : int ; lastDigit := n mod 2020 ;
     if (lastDigit > temp1) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Number {
  public static void main(String[] args){
    Scanner o=new Scanner(System.in);
    int t=o.nextInt();
    while(t-->0){
      int n=o.nextInt();
      boolean yes=false ;
      int div=n/2020 ;
      if(n % 2020<=div)yes=true ;
      if(yes && n>=2020)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Number {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : OclFile ; o := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := o.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := o.getCurrent()->toInteger() ;
     var yes : boolean ; yes := false ;
    var div : int ; div := n / 2020 ;
    if (n mod 2020 <= div) then     yes := true ; else skip ; 
    if (yes & n >= 2020) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int W=sc.nextInt();
    int H=sc.nextInt();
    int N=sc.nextInt();
    int right=W ;
    int left=0 ;
    int up=H ;
    int down=0 ;
    for(int i=0 ; i<N ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      int a=sc.nextInt();
      if(a==1)left=Math.max(left,x);
      if(a==2)right=Math.min(right,x);
      if(a==3)down=Math.max(down,y);
      if(a==4)up=Math.min(up,y);
    }
    int ans=Math.max(0,right-left)*Math.max(0,up-down);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var W : int ; W := sc.getCurrent()->toInteger() ;
    var H : int ; H := sc.getCurrent()->toInteger() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var right : int ; right := W ;
    var left : int ; left := 0 ;
    var up : int ; up := H ;
    var down : int ; down := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    if (a = 1) then     left := Set{left, x}->max() ; else skip ; 
    if (a = 2) then     right := Set{right, x}->min() ; else skip ; 
    if (a = 3) then     down := Set{down, y}->max() ; else skip ; 
    if (a = 4) then     up := Set{up, y}->min() ; else skip ; 
 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := Set{0, right - left}->max() * Set{0, up - down}->max() ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.*;
import java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    int w=in.nextInt();
    int h=in.nextInt();
    int n=in.nextInt();
    int xl=0 ;
    int xr=w ;
    int yl=0 ;
    int yup=h ;
    for(int i=0 ; i<n ; i++){
      int x=in.nextInt();
      int y=in.nextInt();
      int a=in.nextInt();
      if(a==1 && xl<=x){
        xl=Math.min(xr,x);
      }
      else if(a==2 && xr>=x){
        xr=Math.max(xl,x);
      }
      else if(a==3 && yl<=y){
        yl=Math.min(yup,y);
      }
      else if(a==4 && yup>=y){
        yup=Math.max(yl,y);
      }
    }
    int width=xr-xl ;
    int hight=yup-yl ;
    int area=width*hight ;
    System.out.println(area);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var w : int ; w := in.getCurrent()->toInteger() ;
    var h : int ; h := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var xl : int ; xl := 0 ;
    var xr : int ; xr := w ;
    var yl : int ; yl := 0 ;
    var yup : int ; yup := h ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var y : int ; y := in.getCurrent()->toInteger() ;
     var a : int ; a := in.getCurrent()->toInteger() ;
     if (a = 1 & xl <= x) then (     xl := Set{xr, x}->min() ) else     if (a = 2 & xr >= x) then (     xr := Set{xl, x}->max() ) else     if (a = 3 & yl <= y) then (     yl := Set{yup, y}->min() ) else     if (a = 4 & yup >= y) then (     yup := Set{yl, y}->max() ) else skip ; ;  ;  )  ;     i := i + 1 ) ; 
    var width : int ; width := xr - xl ;
    var hight : int ; hight := yup - yl ;
    var area : int ; area := width * hight ;
    OclFile["System.out"].println(area) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int w=Integer.parseInt(sc.next());
    int h=Integer.parseInt(sc.next());
    int n=Integer.parseInt(sc.next());
    int[][] r=new int[w+1][h+1];
    for(int i=0 ; i<n ; i++){
      int x=Integer.parseInt(sc.next());
      int y=Integer.parseInt(sc.next());
      int a=Integer.parseInt(sc.next());
      int sx=0,sy=0,fx=w+1,fy=h+1 ;
      if(a==1)fx=x ;
      else if(a==2)sx=x+1 ;
      else if(a==3)fy=y ;
      else sy=y+1 ;
      for(int j=sx ; j<fx ; j++)for(int k=sy ; k<fy ; k++)r[j][k]=1 ;
    }
    int minx=Integer.MAX_VALUE ;
    int maxx=0 ;
    int miny=Integer.MAX_VALUE ;
    int maxy=0 ;
    for(int i=0 ; i<=w ; i++)for(int j=0 ; j<=h ; j++){
      if(r[i][j]!=1){
        if(i<minx)minx=i ;
        if(i>maxx)maxx=i ;
        if(j<miny)miny=j ;
        if(j>maxy)maxy=j ;
      }
    }
    int ans=0 ;
    if(minx!=Integer.MAX_VALUE && miny!=Integer.MAX_VALUE)ans=(maxx-minx)*(maxy-miny);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := (sc.getCurrent())->toInteger() ;
    var h : int ; h := (sc.getCurrent())->toInteger() ;
    var n : int ; n := (sc.getCurrent())->toInteger() ;
    var r : Sequence(Sequence(int)) ; r := Integer.subrange(1,w + 1)->collect(Integer.subrange(1,h + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := (sc.getCurrent())->toInteger() ;
     var y : int ; y := (sc.getCurrent())->toInteger() ;
    var a : int ; a := (sc.getCurrent())->toInteger() ;
    var sx : int ; sx := 0 ;
    var sy : int ; sy := 0 ;
    var fx : int ; fx := w + 1 ;
    var fy : int ; fy := h + 1 ;
    if (a = 1) then     fx := x else     if (a = 2) then     sx := x + 1 else     if (a = 3) then     fy := y else     sy := y + 1 ; ;  ;  ;  
        var j : int ; j := sx ; while j < fx do (         var k : int ; k := sy ; while k < fy do (     r[j+1][k+1] := 1 ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    var minx : int ; minx := 2147483647 ;
    var maxx : int ; maxx := 0 ;
    var miny : int ; miny := 2147483647 ;
    var maxy : int ; maxy := 0 ;
        var i : int ; i := 0 ; while i <= w do (         var j : int ; j := 0 ; while j <= h do ( (     if (r[i+1][j+1] /= 1) then (     if (i < minx) then     minx := i ; else skip ; 
     if (i > maxx) then     maxx := i ; else skip ; 
     if (j < miny) then     miny := j ; else skip ; 
     if (j > maxy) then     maxy := j ; else skip ) else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    if (minx /= 2147483647 & miny /= 2147483647) then     ans := (maxx - minx) * (maxy - miny) ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int maxX=sc.nextInt();
    int maxY=sc.nextInt();
    int squearNum=sc.nextInt();
    boolean[][] squear=new boolean[maxX][maxY];
    int x ;
    int y ;
    int positionPaint ;
    for(int i=0 ; i<squearNum ; i++){
      x=sc.nextInt();
      y=sc.nextInt();
      positionPaint=sc.nextInt();
      switch(positionPaint){
        case 1 : paintX(squear,x,0,maxY);
        break ;
        case 2 : paintX(squear,maxX,x,maxY);
        break ;
        case 3 : paintY(squear,y,0,maxX);
        break ;
        case 4 : paintY(squear,maxY,y,maxX);
        break ;
        default : }
      }
      int count=0 ;
      for(int i=0 ; i<maxX ; i++){
        for(int j=0 ; j<maxY ; j++){
          if(! squear[i][j]){
            count++;
          }
        }
      }
      System.out.println(count);
    }
    public static void paintX(boolean[][] square,int maxX,int x,int maxY){
      for(int i=x ; i<maxX ; i++){
        for(int j=0 ; j<maxY ; j++){
          square[i][j]=true ;
        }
      }
    }
    public static void paintY(boolean[][] square,int maxY,int y,int maxX){
      for(int i=0 ; i<maxX ; i++){
        for(int j=y ; j<maxY ; j++){
          square[i][j]=true ;
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var maxX : int ; maxX := sc.getCurrent()->toInteger() ;
    var maxY : int ; maxY := sc.getCurrent()->toInteger() ;
    var squearNum : int ; squearNum := sc.getCurrent()->toInteger() ;
    var squear : Sequence(Sequence(boolean)) ; squear := Integer.subrange(1,maxX)->collect(Integer.subrange(1,maxY)->collect(false)) ;
    var x : int ;
    var y : int ;
    var positionPaint : int ;
        var i : int ; i := 0 ; while i < squearNum do ( (     x := sc.getCurrent()->toInteger() ; 
     y := sc.getCurrent()->toInteger() ; 
     positionPaint := sc.getCurrent()->toInteger() ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (positionPaint) ; 
       if _switchval = 1 then
     execute paintX(squear, x, 0, maxY) ; 
    break 
   else skip ;
       if _switchval = 2 then
     execute paintX(squear, maxX, x, maxY) ; 
    break 
   else skip ;
       if _switchval = 3 then
     execute paintY(squear, y, 0, maxX) ; 
    break 
   else skip ;
       if _switchval = 4 then
     execute paintY(squear, maxY, y, maxX) ; 
    break 
   else skip ;
   if true then
 )
 )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < maxX do ( (         var j : int ; j := 0 ; while j < maxY do ( (     if (not(squear[i+1][j+1])) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation paintX( square : Sequence(Sequence(boolean)), maxX : int, x : int, maxY : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := x ; while i < maxX do ( (         var j : int ; j := 0 ; while j < maxY do ( (     square[i+1][j+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation paintY( square : Sequence(Sequence(boolean)), maxY : int, y : int, maxX : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < maxX do ( (         var j : int ; j := y ; while j < maxY do ( (     square[i+1][j+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int q=Integer.parseInt(br.readLine());
    String[] tmpArray ;
    StringBuffer sb=new StringBuffer();
    long left=0 ;
    long right=0 ;
    for(int i=0 ; i<q ; i++){
      tmpArray=br.readLine().split(" ");
      long pos=Long.parseLong(tmpArray[0]);
      char c=tmpArray[1] .charAt(0);
      long n=Long.parseLong(tmpArray[2]);
      StringBuffer tmpSb=new StringBuffer();
      if(c=='('){
        left+=n ;
      }
      else {
        right+=n ;
      }
      int len=sb.length();
      if(right==left){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var q : int ; q := (br.readLine())->toInteger() ;
    var tmpArray : Sequence(String) ;
    var sb : String ; sb := StringLib.newString() ;
    var left : long ; left := 0 ;
    var right : long ; right := 0 ;
        var i : int ; i := 0 ; while i < q do ( (     tmpArray := br.readLine()->split(" ") ; 
     var pos : long ; pos := (tmpArray[0+1])->toLong() ;
    var c : String ; c := tmpArray[1+1]->at(0+1) ;
    var n : long ; n := (tmpArray[2+1])->toLong() ;
    var tmpSb : String ; tmpSb := StringLib.newString() ;
    if (c = '(') then (     left := left+(n) ) else (     right := right+(n) ) ;  
    var len : int ; len := sb->size() ;
    if (right = left) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final int W=sc.nextInt();
    final int H=sc.nextInt();
    final int N=sc.nextInt();
    final int[][] area=new int[W][H];
    for(int i=0 ; i<W ; i++){
      for(int j=0 ; j<H ; j++){
        area[i][j]=1 ;
      }
    }
    for(int i=0 ; i<N ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      int a=sc.nextInt();
      switch(a){
        case 1 : paint(area,0,0,x,H);
        break ;
        case 2 : paint(area,x,0,W,H);
        break ;
        case 3 : paint(area,0,0,W,y);
        break ;
        case 4 : paint(area,0,y,W,H);
        break ;
      }
    }
    int ans=0 ;
    for(int i=0 ; i<W ; i++){
      for(int j=0 ; j<H ; j++){
        ans+=area[i][j];
      }
    }
    System.out.println(ans);
  }
  private static void paint(int[][] area,int px,int py,int qx,int qy){
    for(int i=px ; i<qx ; i++){
      for(int j=py ; j<qy ; j++){
        area[i][j]=0 ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var W : int ; W := sc.getCurrent()->toInteger() ;
    var H : int ; H := sc.getCurrent()->toInteger() ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var area : Sequence(Sequence(int)) ; area := Integer.subrange(1,W)->collect(Integer.subrange(1,H)->collect(0)) ;
        var i : int ; i := 0 ; while i < W do ( (         var j : int ; j := 0 ; while j < H do ( (     area[i+1][j+1] := 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (a) ; 
       if _switchval = 1 then
     execute paint(area, 0, 0, x, H) ; 
    break 
   else skip ;
       if _switchval = 2 then
     execute paint(area, x, 0, W, H) ; 
    break 
   else skip ;
       if _switchval = 3 then
     execute paint(area, 0, 0, W, y) ; 
    break 
   else skip ;
       if _switchval = 4 then
     execute paint(area, 0, y, W, H) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < W do ( (         var j : int ; j := 0 ; while j < H do ( (     ans := ans+(area[i+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation paint( area : Sequence(Sequence(int)), px : int, py : int, qx : int, qy : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := px ; while i < qx do ( (         var j : int ; j := py ; while j < qy do ( (     area[i+1][j+1] := 0 )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
public class Main {
  public static final int BIG_NUM=2000000000 ;
  public static final int MOD=1000000007 ;
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String input[]=br.readLine().split("\\s+");
      BigInteger A=new BigInteger(input[0]);
      BigInteger B=new BigInteger(input[1]);
      BigInteger ans=A.multiply(B);
      System.out.println(ans);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute BIG_NUM : int := 2000000000;
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var input : Sequence(String) ; input := br.readLine()->split("\\s+") ;
     var A : long ; A := long(input[0+1]) ;
    var B : long ; B := long(input[1+1]) ;
    var ans : long ; ans := A.multiply(B) ;
    OclFile["System.out"].println(ans) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float findVolume(float l,float b,float h){
    float volume=(l*b*h)/2 ;
    return volume ;
  }
  public static void main(String[] args){
    float l=18,b=12,h=9 ;
    System.out.println("Volume of triangular prism: "+findVolume(l,b,h));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findVolume( l : double, b : double, h : double) : double
  pre: true
  post: true
  activity: (     var volume : double ; volume := (l * b * h) / 2 ;
     return volume );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : double ; l := 18 ;
    var b : double ; b := 12 ;
    var h : double ; h := 9 ;
     OclFile["System.out"].println("Volume of triangular prism: " + findVolume(l, b, h)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication128 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    int counterMin=0 ;
    int counterMax=0 ;
    for(int i=1 ; i<=num ; i++){
      if(i % 7==1 || i % 7==2){
        counterMax++;
      }
      else if(i % 7==6 || i % 7==0){
        counterMin++;
      }
    }
    System.out.println(counterMin+" "+counterMax);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication128 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
    var counterMin : int ; counterMin := 0 ;
    var counterMax : int ; counterMax := 0 ;
        var i : int ; i := 1 ; while i <= num do ( (     if (i mod 7 = 1 or i mod 7 = 2) then (     counterMax := counterMax + 1 ) else     if (i mod 7 = 6 or i mod 7 = 0) then (     counterMin := counterMin + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(counterMin + " " + counterMax) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import java.util.regex.Pattern ;
public class Main {
  public static void main(String[] args){
    FastScanner sc=new FastScanner();
    int n=sc.nextInt();
    int m=n/7 ;
    int y ;
    int min=0 ;
    if(n % 7>=2){
      y=2 ;
    }
    else {
      y=n % 7 ;
    }
    int y2=0 ;
    if(n<=5){
      min=0 ;
    }
    else {
      min=2*(n/7);
      if(n % 7<=5){
        y2=0 ;
      }
      else {
        y2=n % 7-5 ;
      }
    }
    System.out.println((min+y2)+" "+(2*m+y));
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner() ;
     var n : int ; n := sc.nextInt() ;
    var m : int ; m := n / 7 ;
    var y : int ;
    var min : int ; min := 0 ;
    if (n mod 7 >= 2) then (     y := 2 ) else (     y := n mod 7 ) ;  
    var y2 : int ; y2 := 0 ;
    if (n <= 5) then (     min := 0 ) else (     min := 2 * (n / 7) ; 
     if (n mod 7 <= 5) then (     y2 := 0 ) else (     y2 := n mod 7 - 5 ) ) ;  
    OclFile["System.out"].println((min + y2) + " " + (2 * m + y)) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=n % 7 ;
    if(m==0){
      System.out.print(n/7*2+" ");
      System.out.println(n/7*2);
    }
    else if(m==6){
      System.out.print(n/7*2+1+" ");
      System.out.println(n/7*2+2);
    }
    else if(m==5 || m==4 || m==3 || m==2){
      System.out.print(n/7*2+" ");
      System.out.println(n/7*2+2);
    }
    else if(m==1){
      System.out.print(n/7*2+" ");
      System.out.println(n/7*2+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := n mod 7 ;
     if (m = 0) then (     OclFile["System.out"].print(n / 7 * 2 + " ") ; 
     OclFile["System.out"].println(n / 7 * 2) ) else     if (m = 6) then (     OclFile["System.out"].print(n / 7 * 2 + 1 + " ") ; 
     OclFile["System.out"].println(n / 7 * 2 + 2) ) else     if (m = 5 or m = 4 or m = 3 or m = 2) then (     OclFile["System.out"].print(n / 7 * 2 + " ") ; 
     OclFile["System.out"].println(n / 7 * 2 + 2) ) else     if (m = 1) then (     OclFile["System.out"].print(n / 7 * 2 + " ") ; 
     OclFile["System.out"].println(n / 7 * 2 + 1) ) else skip ; ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Holidays {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    if(n==1){
      System.out.println("0 1");
      return ;
    }
    if(n>=2 && n<=5){
      System.out.println("0 2");
      return ;
    }
    if(n==7){
      System.out.println("2 2");
      return ;
    }
    int min=0,i=1,count=1 ;
    while(i<=n){
      if(i==7*count-1)min+=1 ;
      if(i==7*count){
        min+=1 ;
        count++;
        i+=4 ;
      }
      i++;
    }
    i=2 ;
    count=1 ;
    int max=2 ;
    while(i<=n){
      if(i==7*count+1)max+=1 ;
      if(i==7*count+2){
        max+=1 ;
        count++;
        i+=4 ;
      }
      i++;
    }
    System.out.println(min+" "+max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Holidays {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    if (n = 1) then (     OclFile["System.out"].println("0 1") ; 
     return ) else skip ; 
    if (n >= 2 & n <= 5) then (     OclFile["System.out"].println("0 2") ; 
     return ) else skip ; 
    if (n = 7) then (     OclFile["System.out"].println("2 2") ; 
     return ) else skip ; 
    var min : int ; min := 0 ;
    var i : int ; i := 1 ;
    var count : int ; count := 1 ;
    while (i <= n) do (     if (i = 7 * count - 1) then     min := min+(1) ; else skip ; 
     if (i = 7 * count) then (     min := min+(1) ; 
     count := count + 1 ; 
     i := i+(4) ) else skip ; 
     i := i + 1 ) ; 
    i := 2 ; 
    count := 1 ; 
    var max : int ; max := 2 ;
    while (i <= n) do (     if (i = 7 * count + 1) then     max := max+(1) ; else skip ; 
     if (i = 7 * count + 2) then (     max := max+(1) ; 
     count := count + 1 ; 
     i := i+(4) ) else skip ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println(min + " " + max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class problemD {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int evenWeek=n/7 ;
    int minHoliday=evenWeek*2 ;
    if(n % 7>0){
      if(n % 7<=2)minHoliday+=n % 7 ;
      else minHoliday+=2 ;
    }
    int maxHoliday=evenWeek*2 ;
    if(n % 7>5){
      maxHoliday+=(n % 7-6+1);
    }
    System.out.println(maxHoliday+" "+minHoliday);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class problemD {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var evenWeek : int ; evenWeek := n / 7 ;
    var minHoliday : int ; minHoliday := evenWeek * 2 ;
    if (n mod 7 > 0) then (     if (n mod 7 <= 2) then     minHoliday := minHoliday+(n mod 7) ; else     minHoliday := minHoliday+(2) ; ) else skip ; 
    var maxHoliday : int ; maxHoliday := evenWeek * 2 ;
    if (n mod 7 > 5) then (     maxHoliday := maxHoliday+((n mod 7 - 6 + 1)) ) else skip ; 
    OclFile["System.out"].println(maxHoliday + " " + minHoliday) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextInt();
    }
    int alice=0 ;
    int bob=0 ;
    for(int i=0 ; i<a.length ; i++){
      int high=0 ;
      int idx=-1 ;
      for(int j=0 ; j<a.length ; j++){
        if(high<a[j]){
          high=a[j];
          idx=j ;
        }
      }
      if((i+1)% 2==0){
        bob=bob+high ;
      }
      else {
        alice=alice+high ;
      }
      a[idx]=0 ;
    }
    System.out.println(alice-bob);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var alice : int ; alice := 0 ;
    var bob : int ; bob := 0 ;
        var i : int ; i := 0 ; while i < a->size() do ( (     var high : int ; high := 0 ;
     var idx : int ; idx := -1 ;
        var j : int ; j := 0 ; while j < a->size() do ( (     if (high < a[j+1]) then (     high := a[j+1] ; 
     idx := j ) else skip )  ;     j := j + 1 ) ; 
    if ((i + 1) mod 2 = 0) then (     bob := bob + high ) else (     alice := alice + high ) ;  
    a[idx+1] := 0 ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(alice - bob) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    FastScanner in=new FastScanner();
    int N=in.nextInt();
    ArrayList<Integer>cards=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      cards.add(in.nextInt());
    }
    Collections.sort(cards,Collections.reverseOrder());
    int Maxscore=0 ;
    for(int i=0 ; i<cards.size(); i++){
      if(i % 2==0){
        Maxscore+=cards.get(i);
      }
      else {
        Maxscore-=cards.get(i);
      }
    }
    System.out.println(Maxscore);
  }
  public static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(String s){
      try {
        br=new BufferedReader(new FileReader(s));
      }
      catch(FileNotFoundException e){
        e.printStackTrace();
      }
    }
    public FastScanner(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String nextToken(){
      while(st==null || ! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    String nextLine(){
      st=null ;
      try {
        return br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return null ;
    }
    int nextInt(){
      return Integer.parseInt(nextToken());
    }
    long nextLong(){
      return Long.parseLong(nextToken());
    }
    double nextDouble(){
      return Double.parseDouble(nextToken());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var N : int ; N := in.nextInt() ;
    var cards : Sequence(int) ; cards := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     cards := cards->including(in.nextInt()) )  ;     i := i + 1 ) ; 
    cards, reverseOrder() := cards, reverseOrder()->sort() ; 
    var Maxscore : int ; Maxscore := 0 ;
        var i : int ; i := 0 ; while i < cards->size() do ( (     if (i mod 2 = 0) then (     Maxscore := Maxscore+(cards->at(i+1)) ) else (     Maxscore := Maxscore-(cards->at(i+1)) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Maxscore) ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
 );
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     st := null ; 
     try (     return br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int totalCard=scanner.nextInt();
    int[] cardList=new int[totalCard];
    for(int index=0 ; index<totalCard ; index++){
      int temp=scanner.nextInt();
      cardList[index]=temp ;
    }
    int alicePoint=0 ;
    int bobPoint=0 ;
    boolean aliceTurn=true ;
    for(int index=0 ; index<totalCard ; index++){
      int card=getMaximum(cardList);
      if(aliceTurn==true){
        alicePoint+=card ;
        aliceTurn=false ;
      }
      else {
        bobPoint+=card ;
        aliceTurn=true ;
      }
    }
    System.out.println(Math.abs(alicePoint-bobPoint));
  }
  static int getMaximum(int[] cardList){
    int maximum=0 ;
    int maximumIndex=0 ;
    for(int index=0 ; index<cardList.length ; index++){
      int temp=cardList[index];
      if(temp>maximum){
        maximum=temp ;
        maximumIndex=index ;
      }
    }
    cardList[maximumIndex]=0 ;
    return maximum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var totalCard : int ; totalCard := scanner.getCurrent()->toInteger() ;
    var cardList : Sequence(int) ; cardList := Integer.subrange(1,totalCard)->collect(0) ;
        var index : int ; index := 0 ; while index < totalCard do ( (     var temp : int ; temp := scanner.getCurrent()->toInteger() ;
     cardList[index+1] := temp )  ;     index := index + 1 ) ; 
    var alicePoint : int ; alicePoint := 0 ;
    var bobPoint : int ; bobPoint := 0 ;
    var aliceTurn : boolean ; aliceTurn := true ;
        var index : int ; index := 0 ; while index < totalCard do ( (     var card : int ; card := getMaximum(cardList) ;
     if (aliceTurn = true) then (     alicePoint := alicePoint+(card) ; 
     aliceTurn := false ) else (     bobPoint := bobPoint+(card) ; 
     aliceTurn := true ) )  ;     index := index + 1 ) ; 
    OclFile["System.out"].println(if alicePoint - bobPoint < 0 then -(alicePoint - bobPoint) else alicePoint - bobPoint endif) ; 
 );
  static   operation getMaximum( cardList : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var maximum : int ; maximum := 0 ;
     var maximumIndex : int ; maximumIndex := 0 ;
        var index : int ; index := 0 ; while index < cardList->size() do ( (     var temp : int ; temp := cardList[index+1] ;
     if (temp > maximum) then (     maximum := temp ; 
     maximumIndex := index ) else skip )  ;     index := index + 1 ) ; 
    cardList[maximumIndex+1] := 0 ; 
    return maximum 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    List<Integer>inputList=new ArrayList<Integer>();
    List<Integer>aliceList=new ArrayList<Integer>();
    List<Integer>bobList=new ArrayList<Integer>();
    for(int i=0 ; i<N ; i++){
      int num=sc.nextInt();
      inputList.add(num);
    }
    Collections.sort(inputList,Collections.reverseOrder());
    boolean aliceFlg=true ;
    for(int j=0 ; j<inputList.size(); j++){
      if(aliceFlg){
        aliceList.add(inputList.get(j));
        aliceFlg=false ;
      }
      else {
        bobList.add(inputList.get(j));
        aliceFlg=true ;
      }
    }
    int aliceSum=0 ;
    for(int aliceNum : aliceList){
      aliceSum+=aliceNum ;
    }
    int bobSum=0 ;
    for(int bobNum : bobList){
      bobSum+=bobNum ;
    }
    System.out.println(aliceSum-bobSum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var inputList : Sequence(int) ; inputList := Sequence{} ;
    var aliceList : Sequence(int) ; aliceList := Sequence{} ;
    var bobList : Sequence(int) ; bobList := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var num : int ; num := sc.getCurrent()->toInteger() ;
     inputList := inputList->including(num) )  ;     i := i + 1 ) ; 
    inputList, reverseOrder() := inputList, reverseOrder()->sort() ; 
    var aliceFlg : boolean ; aliceFlg := true ;
        var j : int ; j := 0 ; while j < inputList->size() do ( (     if (aliceFlg) then (     aliceList := aliceList->including(inputList->at(j+1)) ; 
     aliceFlg := false ) else (     bobList := bobList->including(inputList->at(j+1)) ; 
     aliceFlg := true ) )  ;     j := j + 1 ) ; 
    var aliceSum : int ; aliceSum := 0 ;
    for (aliceNum : aliceList) do ( (     aliceSum := aliceSum+(aliceNum) )  ) ; 
    var bobSum : int ; bobSum := 0 ;
    for (bobNum : bobList) do ( (     bobSum := bobSum+(bobNum) )  ) ; 
    OclFile["System.out"].println(aliceSum - bobSum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static final Scanner scn=new Scanner(System.in);
  private static final String[][] TABLE={
    {
    },{
    ".",",","!","?"," " },{
      "a","b","c" },{
        "d","e","f" },{
          "g","h","i" },{
            "j","k","l" },{
              "m","n","o" },{
                "p","q","r","s" },{
                  "t","u","v" },{
                    "w","x","y","z" }
                  };
                  public static void main(String[] args){
                    scn.nextLine();
                    while(scn.hasNextLine()){
                      Scanner reader=new Scanner(scn.nextLine());
                      reader.useDelimiter("0+");
                      StringBuilder sb=new StringBuilder();
                      while(reader.hasNext()){
                        String tmp=reader.next();
                        int y=Integer.parseInt(tmp.substring(0,1));
                        int x=(tmp.length()-1)% TABLE[y] .length ;
                        sb.append(TABLE[y][x]);
                      }
                      System.out.println(sb);
                    }
                  }
                }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute scn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute TABLE : Sequence(Sequence(String)) := Sequence{Sequence{},Sequence{".",",","!","?"," "},Sequence{"a","b","c"},Sequence{"d","e","f"},Sequence{"g","h","i"},Sequence{"j","k","l"},Sequence{"m","n","o"},Sequence{"p","q","r","s"},Sequence{"t","u","v"},Sequence{"w","x","y","z"}};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     skip ; 
     while (scn.hasNextLine()) do (     var reader : OclFile ; reader := OclFile.newOclFile_Read(scn.nextLine()) ;
     skip ; 
    var sb : String ; sb := StringLib.newString() ;
    while (reader.hasNext()) do (     var tmp : String ; tmp := reader.getCurrent() ;
     var y : int ; y := (tmp.subrange(0+1,1))->toInteger() ;
     var x : int ; x := (tmp->size() - 1) mod TABLE[y+1]->size() ;
     sb := sb + StringLib.newString(TABLE[y+1][x+1]) ) ; 
    OclFile["System.out"].println(sb) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class practice462b {
  public static void main(String[] args)throws Exception {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    StringTokenizer st=new StringTokenizer(f.readLine());
    int n=Integer.parseInt(st.nextToken());
    int k=Integer.parseInt(st.nextToken());
    c462b[] cards=new c462b[26];
    for(int i=0 ; i<26 ; i++){
      cards[i]=new c462b();
    }
    String s=f.readLine();
    for(int t=0 ; t<n ; t++){
      cards[s.charAt(t)-'A'] .left++;
    }
    long ans=0 ;
    for(int i=0 ; i<k ; i++){
      Arrays.sort(cards);
      long change=Math.min(cards[25] .left,k-i);
      ans+=change*change ;
      cards[25] .left-=change ;
      i+=change-1 ;
    }
    out.println(ans);
    out.close();
  }
}
class c462b implements Comparable {
  int left=0 ;
  @ Override public int compareTo(Object o){
    return left-((c462b)o).left ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice462b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var k : int ; k := (st.next())->toInteger() ;
    var cards : Sequence(c462b) ; cards := Integer.subrange(1,26)->collect(null) ;
        var i : int ; i := 0 ; while i < 26 do ( (     cards[i+1] := c462b.newc462b() )  ;     i := i + 1 ) ; 
    var s : String ; s := f.readLine() ;
        var t : int ; t := 0 ; while t < n do ( (     cards[s->at(t+1) - ('A')->char2byte()+1].left := cards[s->at(t+1) - ('A')->char2byte()+1].left + 1 )  ;     t := t + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     cards := cards->sort() ; 
     var change : long ; change := Set{cards[25+1].left, k - i}->min() ;
    ans := ans+(change * change) ; 
    cards[25+1].left := cards[25+1].left-(change) ; 
    i := i+(change - 1) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}
class c462b implements OclAny {
   attribute left : int := 0;
      operation compareTo( o : OclAny) : int
  pre: true
  post: true
  activity: (     return left - (o->oclAsType(c462b)).left );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  Scanner sc=new Scanner(in);
  void run(){
    int q=sc.nextInt();
    long num=0L ;
    int lr=0 ;
    for(int i=0 ; i<q ; i++){
      sc.next();
      char p=sc.next().charAt(0);
      int n=sc.nextInt();
      if(p=='('){
        if(num==0){
          num=n ;
          lr=1 ;
        }
        else {
          if(lr>0){
            num+=n ;
          }
          else {
            if(num>=n){
              num-=n ;
            }
            else {
              num=n-num ;
              lr=1 ;
            }
          }
        }
      }
      else {
        if(num==0){
          num=n ;
          lr=-1 ;
        }
        else {
          if(lr<0){
            num+=n ;
          }
          else {
            if(num>=n){
              num-=n ;
            }
            else {
              num=n-num ;
              lr=-1 ;
            }
          }
        }
      }
      if(num==0)out.println("Yes");
      else out.println("No");
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   operation run() : void
  pre: true
  post: true
  activity: (     var q : int ; q := sc.getCurrent()->toInteger() ;
     var num : long ; num := 0L ;
     var lr : int ; lr := 0 ;
         var i : int ; i := 0 ; while i < q do ( (     skip ; 
     var p : String ; p := sc.getCurrent()->at(0+1) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    if (p = '(') then (     if (num = 0) then (     num := n ; 
     lr := 1 ) else (     if (lr > 0) then (     num := num+(n) ) else (     if (num >= n) then (     num := num-(n) ) else (     num := (n)->char2byte() - num ; 
     lr := 1 ) ) ) ) else (     if (num = 0) then (     num := n ; 
     lr := -1 ) else (     if (lr < 0) then (     num := num+(n) ) else (     if (num >= n) then (     num := num-(n) ) else (     num := (n)->char2byte() - num ; 
     lr := -1 ) ) ) ) ;  
    if (num = 0) then     out.println("Yes") else     out.println("No") ; ;  
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Integer[] a=new Integer[n];
    int i=0 ;
    while(sc.hasNext()){
      a[i]=sc.nextInt();
      i++;
    }
    Arrays.sort(a,Collections.reverseOrder());
    int Alice=0 ;
    int Bob=0 ;
    int diff=0 ;
    for(int j=0 ; j<a.length ; j++){
      if(j % 2==0){
        Alice+=a[j];
      }
      else {
        Bob+=a[j];
      }
    }
    diff=Alice-Bob ;
    System.out.println(diff);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(null) ;
    var i : int ; i := 0 ;
    while (sc.hasNext()) do (     a[i+1] := sc.getCurrent()->toInteger() ; 
     i := i + 1 ) ; 
    a := OclComparator.sortWith(a, reverseOrder()) ; 
    var Alice : int ; Alice := 0 ;
    var Bob : int ; Bob := 0 ;
    var diff : int ; diff := 0 ;
        var j : int ; j := 0 ; while j < a->size() do ( (     if (j mod 2 = 0) then (     Alice := Alice+(a[j+1]) ) else (     Bob := Bob+(a[j+1]) ) )  ;     j := j + 1 ) ; 
    diff := Alice - Bob ; 
    OclFile["System.out"].println(diff) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Z_ccc_1_3 {
  static int n ;
  static int ax ;
  static int bx ;
  static int ay ;
  static int by ;
  static int cx ;
  static int cy ;
  public static void main(String args[])throws IOException {
    InputStreamReader r=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(r);
    n=Integer.parseInt(br.readLine());
    StringTokenizer st=new StringTokenizer(br.readLine());
    ax=Integer.parseInt(st.nextToken());
    ay=Integer.parseInt(st.nextToken());
    st=new StringTokenizer(br.readLine());
    bx=Integer.parseInt(st.nextToken());
    by=Integer.parseInt(st.nextToken());
    st=new StringTokenizer(br.readLine());
    cx=Integer.parseInt(st.nextToken());
    cy=Integer.parseInt(st.nextToken());
    int div_b=0 ;
    int div_c=0 ;
    if(bx<ax && by>ay){
      div_b=1 ;
    }
    else if(bx>ax && by>ay){
      div_b=2 ;
    }
    else if(bx<ax && by<ay){
      div_b=3 ;
    }
    else if(bx>ax && by<ay){
      div_b=4 ;
    }
    if(cx<ax && cy>ay){
      div_c=1 ;
    }
    else if(cx>ax && cy>ay){
      div_c=2 ;
    }
    else if(cx<ax && cy<ay){
      div_c=3 ;
    }
    else if(cx>ax && cy<ay){
      div_c=4 ;
    }
    if(div_c==div_b){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Z_ccc_1_3 {
  static   attribute n : int;
  static   attribute ax : int;
  static   attribute bx : int;
  static   attribute ay : int;
  static   attribute by : int;
  static   attribute cx : int;
  static   attribute cy : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(r) ;
    n := (br.readLine())->toInteger() ; 
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    ax := (st.next())->toInteger() ; 
    ay := (st.next())->toInteger() ; 
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    bx := (st.next())->toInteger() ; 
    by := (st.next())->toInteger() ; 
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    cx := (st.next())->toInteger() ; 
    cy := (st.next())->toInteger() ; 
    var div_b : int ; div_b := 0 ;
    var div_c : int ; div_c := 0 ;
    if (bx < ax & by > ay) then (     div_b := 1 ) else     if (bx > ax & by > ay) then (     div_b := 2 ) else     if (bx < ax & by < ay) then (     div_b := 3 ) else     if (bx > ax & by < ay) then (     div_b := 4 ) else skip ; ;  ;  ;  
    if (cx < ax & cy > ay) then (     div_c := 1 ) else     if (cx > ax & cy > ay) then (     div_c := 2 ) else     if (cx < ax & cy < ay) then (     div_c := 3 ) else     if (cx > ax & cy < ay) then (     div_c := 4 ) else skip ; ;  ;  ;  
    if (div_c = div_b) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int ax=sc.nextInt();
    int ay=sc.nextInt();
    int bx=sc.nextInt();
    int by=sc.nextInt();
    int dx=sc.nextInt();
    int dy=sc.nextInt();
    if(bx>ax && by>ay && dx>ax && dy>ay){
      System.out.println("YES");
    }
    else if(bx>ax && by<ay && dx>ax && dy<ay){
      System.out.println("YES");
    }
    else if(bx<ax && by>ay && dx<ax && dy>ay){
      System.out.println("YES");
    }
    else if(bx<ax && by<ay && dx<ax && dy<ay){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ax : int ; ax := sc.getCurrent()->toInteger() ;
    var ay : int ; ay := sc.getCurrent()->toInteger() ;
    var bx : int ; bx := sc.getCurrent()->toInteger() ;
    var by : int ; by := sc.getCurrent()->toInteger() ;
    var dx : int ; dx := sc.getCurrent()->toInteger() ;
    var dy : int ; dy := sc.getCurrent()->toInteger() ;
    if (bx > ax & by > ay & dx > ax & dy > ay) then (     OclFile["System.out"].println("YES") ) else     if (bx > ax & by < ay & dx > ax & dy < ay) then (     OclFile["System.out"].println("YES") ) else     if (bx < ax & by > ay & dx < ax & dy > ay) then (     OclFile["System.out"].println("YES") ) else     if (bx < ax & by < ay & dx < ax & dy < ay) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GeeksforGeeks {
  public static String smallestNumber(String str){
    char[] num=str.toCharArray();
    int n=str.length();
    int[] rightMin=new int[n];
    rightMin[n-1]=-1 ;
    int right=n-1 ;
    for(int i=n-2 ; i>=1 ; i--){
      if(num[i]>num[right])rightMin[i]=right ;
      else {
        rightMin[i]=-1 ;
        right=i ;
      }
    }
    int small=-1 ;
    for(int i=1 ; i<n ; i++)if(num[i]!='0'){
      if(small==-1){
        if(num[i]<num[0])small=i ;
      }
      else if(num[i]<num[small])small=i ;
    }
    if(small!=-1){
      char temp ;
      temp=num[0];
      num[0]=num[small];
      num[small]=temp ;
    }
    else {
      for(int i=1 ; i<n ; i++){
        if(rightMin[i]!=-1){
          char temp ;
          temp=num[i];
          num[i]=num[rightMin[i] ];
          num[rightMin[i] ]=temp ;
          break ;
        }
      }
    }
    return(new String(num));
  }
  public static void main(String argc[]){
    String num="9625635" ;
    System.out.println("Smallest number: "+smallestNumber(num));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GeeksforGeeks {
  static   operation smallestNumber( str : String) : String
  pre: true
  post: true
  activity: (     var num : Sequence(String) ; num := str->characters() ;
     var n : int ; n := str->size() ;
    var rightMin : Sequence(int) ; rightMin := Integer.subrange(1,n)->collect(0) ;
    rightMin[n - 1+1] := -1 ; 
    var right : int ; right := n - 1 ;
        var i : int ; i := n - 2 ; while i >= 1 do ( (     if (num[i+1] > num[right+1]) then     rightMin[i+1] := right ; else (     rightMin[i+1] := -1 ; 
     right := i ) )  ;     i := i - 1 ) ; 
    var small : int ; small := -1 ;
        var i : int ; i := 1 ; while i < n do (     if (num[i+1] /= '0') then (     if (small = -1) then (     if (num[i+1] < num[0+1]) then     small := i ; else skip ) else     if (num[i+1] < num[small+1]) then     small := i ; else skip ; ) else skip ;  ;     i := i + 1 ) ; 
    if (small /= -1) then (     var temp : String ;
     temp := num[0+1] ; 
     num[0+1] := num[small+1] ; 
     num[small+1] := temp ) else (         var i : int ; i := 1 ; while i < n do ( (     if (rightMin[i+1] /= -1) then (     var temp : String ;
     temp := num[i+1] ; 
    num[i+1] := num[rightMin[i+1]+1] ; 
    num[rightMin[i+1]+1] := temp ; 
    break 
 ) else skip )  ;     i := i + 1 ) ) ;  
    return (StringLib.newString(num)) 
 );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : String ; num := "9625635" ;
     OclFile["System.out"].println("Smallest number: " + smallestNumber(num)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int sumOfDiv(int x){
    int sum=1 ;
    for(int i=2 ; i<=Math.sqrt(x); i++){
      if(x % i==0){
        sum+=i ;
        if(x/i!=i)sum+=x/i ;
      }
    }
    return sum ;
  }
  static boolean isAmicable(int a,int b){
    return(sumOfDiv(a)==b && sumOfDiv(b)==a);
  }
  static int countPairs(int arr[],int n){
    HashSet<Integer>s=new HashSet<Integer>();
    int count=0 ;
    for(int i=0 ; i<n ; i++)s.add(arr[i]);
    for(int i=0 ; i<n ; i++){
      if(s.contains(sumOfDiv(arr[i]))){
        int sum=sumOfDiv(arr[i]);
        if(isAmicable(arr[i],sum))count++;
      }
    }
    return count/2 ;
  }
  public static void main(String[] args){
    int arr1[]={
      220,284,1184,1210,2,5 };
      int n1=arr1.length ;
      System.out.println(countPairs(arr1,n1));
      int arr2[]={
        2620,2924,5020,5564,6232,6368 };
        int n2=arr2.length ;
        System.out.println(countPairs(arr2,n2));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfDiv( x : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 1 ;
         var i : int ; i := 2 ; while i <= (x)->sqrt() do ( (     if (x mod i = 0) then (     sum := sum+(i) ; 
     if (x / i /= i) then     sum := sum+(x / i) ; else skip ) else skip )  ;     i := i + 1 ) ; 
     return sum );
  static   operation isAmicable( a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     return (sumOfDiv(a) = b & sumOfDiv(b) = a) );
  static   operation countPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
     var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do (     s := s->including(arr[i+1]) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (s->includes(sumOfDiv(arr[i+1]))) then (     var sum : int ; sum := sumOfDiv(arr[i+1]) ;
     if (isAmicable(arr[i+1], sum)) then     count := count + 1 ; else skip ) else skip )  ;     i := i + 1 ) ; 
    return count / 2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{220,284,1184,1210,2,5} ;
     var n1 : int ; n1 := arr1->size() ;
    OclFile["System.out"].println(countPairs(arr1, n1)) ; 
    var arr2 : Sequence(int) ; arr2 := Sequence{2620,2924,5020,5564,6232,6368} ;
    var n2 : int ; n2 := arr2->size() ;
    OclFile["System.out"].println(countPairs(arr2, n2)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int d=sc.nextInt();
    long count=0 ;
    int current=0 ;
    int state=1 ;
    long total=0 ;
    for(int i=0 ; i<n ; i++){
      int time=sc.nextInt();
      int floor=sc.nextInt();
      if(state-1+floor-1<=time-current){
        total+=count*(state-1);
        count=1 ;
        current=time ;
        state=floor ;
      }
      else if(Math.abs(floor-state)<=time-current){
        total+=count*(time-current);
        count++;
        current=time ;
        state=floor ;
        if(count>d){
          System.out.println(-1);
          return ;
        }
      }
      else {
        System.out.println(-1);
        return ;
      }
    }
    total+=count*(state-1);
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var count : long ; count := 0 ;
    var current : int ; current := 0 ;
    var state : int ; state := 1 ;
    var total : long ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var time : int ; time := sc.getCurrent()->toInteger() ;
     var floor : int ; floor := sc.getCurrent()->toInteger() ;
     if (state - 1 + floor - 1 <= time - current) then (     total := total+(count * (state - 1)) ; 
     count := 1 ; 
     current := time ; 
     state := floor ) else     if (if floor - state < 0 then -(floor - state) else floor - state endif <= time - current) then (     total := total+(count * (time - current)) ; 
     count := count + 1 ; 
    current := time ; 
    state := floor ; 
    if (count > d) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
 ) else (     OclFile["System.out"].println(-1) ; 
     return ) ;  )  ;     i := i + 1 ) ; 
    total := total+(count * (state - 1)) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int givesum(int A[],int n){
    int max=Arrays.stream(A).max().getAsInt();
    int maxBit=(int)Math.ceil(Math.log(max)+1);
    int totalSubarrays=n*(n+1)/2 ;
    int s=0 ;
    for(int i=0 ; i<maxBit ; i++){
      int c1=0 ;
      Vector<Integer>vec=new Vector<>();
      int sum=0 ;
      for(int j=0 ; j<n ; j++){
        int a=A[j]>>i ;
        if(!(a % 2==1)){
          vec.add(j);
        }
      }
      int cntSubarrNotSet=0 ;
      int cnt=1 ;
      for(int j=1 ; j<vec.size(); j++){
        if(vec.get(j)-vec.get(j-1)==1){
          cnt++;
        }
        else {
          cntSubarrNotSet+=cnt*(cnt+1)/2 ;
          cnt=1 ;
        }
      }
      cntSubarrNotSet+=cnt*(cnt+1)/2 ;
      if(vec.size()==0)cntSubarrNotSet=0 ;
      int cntSubarrIthSet=totalSubarrays-cntSubarrNotSet ;
      s+=cntSubarrIthSet*Math.pow(2,i);
    }
    return s ;
  }
  public static void main(String[] args){
    int A[]={
      1,2,3,4,5 };
      int n=A.length ;
      System.out.println(givesum(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation givesum( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max : int ; max := stream(A).max().getAsInt() ;
     var maxBit : int ; maxBit := ((max)->log() + 1)->ceil()->oclAsType(int) ;
    var totalSubarrays : int ; totalSubarrays := n * (n + 1) / 2 ;
    var s : int ; s := 0 ;
        var i : int ; i := 0 ; while i < maxBit do ( (     var c1 : int ; c1 := 0 ;
     var vec : Sequence(int) ; vec := Sequence{} ;
    var sum : int ; sum := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     var a : int ; a := (A[j+1]/(2->pow(i)))->oclAsType(long) ;
     if (not((a mod 2 = 1))) then (     vec := vec->including(j) ) else skip )  ;     j := j + 1 ) ; 
    var cntSubarrNotSet : int ; cntSubarrNotSet := 0 ;
    var cnt : int ; cnt := 1 ;
        var j : int ; j := 1 ; while j < vec->size() do ( (     if (vec->at(j+1) - vec->at(j - 1+1) = 1) then (     cnt := cnt + 1 ) else (     cntSubarrNotSet := cntSubarrNotSet+(cnt * (cnt + 1) / 2) ; 
     cnt := 1 ) )  ;     j := j + 1 ) ; 
    cntSubarrNotSet := cntSubarrNotSet+(cnt * (cnt + 1) / 2) ; 
    if (vec->size() = 0) then     cntSubarrNotSet := 0 ; else skip ; 
    var cntSubarrIthSet : int ; cntSubarrIthSet := totalSubarrays - cntSubarrNotSet ;
    s := s+(cntSubarrIthSet * 2->pow(i)) ; 
 )  ;     i := i + 1 ) ; 
    return s 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{1,2,3,4,5} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].println(givesum(A, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.*;
public class App {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws Exception {
    if(System.getProperty("ONLINE_JUDGE")==null){
      File inputFile=new File("/Users/vipinjain/self/cp/input.txt");
      File outputFile=new File("/Users/vipinjain/self/cp/output.txt");
      br=new BufferedReader(new FileReader(inputFile));
      bw=new BufferedWriter(new FileWriter(outputFile));
    }
    int tests ;
    tests=Integer.parseInt(br.readLine());
    while(tests-->0){
      solve();
    }
    bw.flush();
    bw.close();
    br.close();
  }
  static void solve()throws Exception {
    int n=Integer.parseInt(br.readLine());
    int[] arr=Stream.of(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    int res=0 ;
    for(int i=0 ; i<n ; ++i){
      res |=arr[i];
    }
    bw.write(res+"\n");
  }
  static int gcd(int a,int b){
    if(a==0){
      return b ;
    }
    return gcd(b % a,a);
  }
  static boolean isPrime(long n){
    for(long i=2 ; i*i<=n ; i++){
      if(n % i==0){
        return false ;
      }
    }
    return true ;
  }
  static long minDivisor(long n){
    for(long i=2 ; i*i<=n ; ++i){
      if(n % i==0){
        return i ;
      }
    }
    return n ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null) then (     var inputFile : OclFile ; inputFile := OclFile("/Users/vipinjain/self/cp/input.txt") ;
     var outputFile : OclFile ; outputFile := OclFile("/Users/vipinjain/self/cp/output.txt") ;
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputFile)) ; 
     bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputFile)) ) else skip ; 
     var tests : int ;
    tests := (br.readLine())->toInteger() ; 
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var arr : Sequence(int) ; arr := Sequence{br.readLine()->split(" ")}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     res := MathLib.bitwiseOr(res, arr[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then (     return b ) else skip ; 
     return gcd(b mod a, a) );
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (         var i : long ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation minDivisor( n : long) : long
  pre: true
  post: true
  activity: (         var i : long ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     return i ) else skip )  ;     i := i + 1 ) ; 
     return n );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int k=0 ; k<t ; k++){
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      int x=0 ;
      for(int i=0 ; i<n ; i++){
        x=x | arr[i];
      }
      System.out.println(x);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var k : int ; k := 0 ; while k < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x := MathLib.bitwiseOr(x,arr[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(x) ; 
 )  ;     k := k + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class test6 {
  public static final int mod=1000000007 ;
  public static void main(String[] args)throws IOException {
    BufferedReader s=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    String[] ip=s.readLine().split(" ");
    int n=Integer.parseInt(ip[0]);
    long k=Integer.parseInt(ip[1]);
    char[] arr=s.readLine().toCharArray();
    Long[] dict=new Long[26];
    Arrays.fill(dict,0L);
    for(int i=0 ; i<n ; i++){
      dict[arr[i]-'A']++;
    }
    Arrays.sort(dict,Collections.reverseOrder());
    long coins=0 ;
    for(int i=0 ; i<dict.length ; i++){
      long v=dict[i];
      if(v>=k){
        coins+=k*k ;
        break ;
      }
      else {
        coins+=v*v ;
        k-=v ;
      }
    }
    System.out.println(coins);
    out.flush();
    out.close();
  }
  public static class Pair {
    int d=0 ;
    int prev=0 ;
    boolean p=true ;
    Pair(int n,int o,boolean c){
      d=n ;
      prev=o ;
      p=c ;
    }
  }
  public static<K,V extends Comparable<V>>Map<K,V>sortByValues(final Map<K,V>map){
    Comparator<K>valueComparator=new Comparator<K>(){
      public int compare(K k1,K k2){
        int compare=map.get(k1).compareTo(map.get(k2));
        if(compare==0)return 1 ;
        else return compare ;
      }
    };
    Map<K,V>sortedByValues=new TreeMap<K,V>(valueComparator);
    sortedByValues.putAll(map);
    return sortedByValues ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class test6 {
  static    attribute mod : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var ip : Sequence(String) ; ip := s.readLine()->split(" ") ;
    var n : int ; n := (ip[0+1])->toInteger() ;
    var k : long ; k := (ip[1+1])->toInteger() ;
    var arr : Sequence(String) ; arr := s.readLine()->characters() ;
    var dict : Sequence(long) ; dict := Integer.subrange(1,26)->collect(null) ;
    dict := dict->collect(0L) ; 
        var i : int ; i := 0 ; while i < n do ( (     dict[arr[i+1] - ('A')->char2byte()+1] := dict[arr[i+1] - ('A')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    dict := OclComparator.sortWith(dict, reverseOrder()) ; 
    var coins : long ; coins := 0 ;
        var i : int ; i := 0 ; while i < dict->size() do ( (     var v : long ; v := dict[i+1] ;
     if (v >= k) then (     coins := coins+(k * k) ; 
     break ) else (     coins := coins+(v * v) ; 
     k := k-(v) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(coins) ; 
    skip ; 
    skip ; 
 );
  static class Pair {
   attribute d : int := 0;
   attribute prev : int := 0;
   attribute p : boolean := true;
   static operation newPair( n : int, o : int, c : boolean) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(n, o,c);
    return self );
  operation initialise( n : int, o : int, c : boolean) : void
  pre: true  post: true
  activity: (     d := n ; 
     prev := o ; 
     p := c );
}
  static   operation sortByValues<K,V>( map : Map(K,V)) : Map(K,V)
  pre: true
  post: true
  activity: (     var valueComparator : Function(<K>,(<K>,boolean)) ; valueComparator := OclComparator<K>.newOclComparator() ;
     var sortedByValues : Map(K,V) ; sortedByValues := Map{}->union(valueComparator) ;
     sortedByValues := sortedByValues->union(map) ; 
     return sortedByValues );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector ;
class GFG {
  static class Pair {
    private int first ;
    private int second ;
    Pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
    public int getFirst(){
      return first ;
    }
    public int getSecond(){
      return second ;
    }
  }
  static int solve(int[] Array,int N,int K){
    int[] count_Arr=new int[N+2];
    int factor=1 ;
    int size=N ;
    while(size>0){
      int start=1 ;
      int end=size ;
      count_Arr[1]+=factor*N ;
      count_Arr[end+1]-=factor*N ;
      factor++;
      size/=2 ;
    }
    for(int i=2 ; i<=N ; i++)count_Arr[i]+=count_Arr[i-1];
    Vector<Pair>element=new Vector<>();
    for(int i=0 ; i<N ; i++){
      Pair x=new Pair(Array[i],count_Arr[i+1]);
      element.add(x);
    }
    int start=1 ;
    for(int i=0 ; i<N ; i++){
      int end=start+element.elementAt(0).getSecond()-1 ;
      if(K>=start && K<=end)return element.elementAt(i).getFirst();
      start+=element.elementAt(i).getSecond();
    }
    return-1 ;
  }
  public static void main(String[] args){
    int[] arr={
      2,4,5,1 };
      int N=arr.length ;
      int K=13 ;
      System.out.println(solve(arr,N,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Pair {
   attribute first : int;
   attribute second : int;
   static operation newPair( first : int, second : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
   operation getFirst() : int
  pre: true
  post: true
  activity: (     return first );
   operation getSecond() : int
  pre: true
  post: true
  activity: (     return second );
}
  static   operation solve( Array : Sequence(int), N : int, K : int) : int
  pre: true
  post: true
  activity: (     var count_Arr : Sequence(int) ; count_Arr := Integer.subrange(1,N + 2)->collect(0) ;
     var factor : int ; factor := 1 ;
    var size : int ; size := N ;
    while (size > 0) do (     var start : int ; start := 1 ;
     var end : int ; end := size ;
    count_Arr[1+1] := count_Arr[1+1]+(factor * N) ; 
    count_Arr[end + 1+1] := count_Arr[end + 1+1]-(factor * N) ; 
    factor := factor + 1 ; 
    size := size/(2) ; 
 ) ; 
        var i : int ; i := 2 ; while i <= N do (     count_Arr[i+1] := count_Arr[i+1]+(count_Arr[i - 1+1]) ;  ;     i := i + 1 ) ; 
    var element : Sequence(Map) ; element := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var x : Map ; x := Map(Array[i+1], count_Arr[i + 1+1]) ;
     element := element->including(x) )  ;     i := i + 1 ) ; 
    var start : int ; start := 1 ;
        var i : int ; i := 0 ; while i < N do ( (     var end : int ; end := start + element->at(0+1).getSecond() - 1 ;
     if (K >= start & K <= end) then     return element->at(i+1)->first() else skip ; 
     start := start+(element->at(i+1).getSecond()) )  ;     i := i + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,5,1} ;
     var N : int ; N := arr->size() ;
     var K : int ; K := 13 ;
     OclFile["System.out"].println(solve(arr, N, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int dataset=sc.nextInt();
      long left=0,right=0 ;
      while(dataset-->0){
        String pos=sc.next();
        char c=sc.next().charAt(0);
        int time=sc.nextInt();
        if(c=='('){
          left+=time ;
        }
        else {
          right+=time ;
        }
        if(left==right){
          System.out.println("Yes");
        }
        else {
          System.out.println("No");
        }
      }
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var dataset : int ; dataset := sc.getCurrent()->toInteger() ;
     var left : long ; left := 0 ;
    var right : long ; right := 0 ;
         while (dataset > 0) do (        dataset := dataset - 1 ;     skip ; (     var pos : String ; pos := sc.getCurrent() ;
     var c : String ; c := sc.getCurrent()->at(0+1) ;
    var time : int ; time := sc.getCurrent()->toInteger() ;
    if (c = '(') then (     left := left+(time) ) else (     right := right+(time) ) ;  
    if (left = right) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 ) ;  ) ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String x="" ;
    try {
      x=in.readLine();
    }
    catch(NumberFormatException e){
      e.printStackTrace();
    }
    catch(IOException e){
      e.printStackTrace();
    }
    for(int i=0 ; i<x.length(); i++){
      char c=x.charAt(i);
      if((c<'A')|| c>'z'){
        System.out.print(c);
        continue ;
      }
      if((c-'a')<0){
        c=(char)(c+('a'-'A'));
      }
      else {
        c=(char)(c-('a'-'A'));
      }
      System.out.print(c);
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var x : String ; x := "" ;
    try (     x := in.readLine() )   catch (e : IncorrectElementException) do (     e.printStackTrace() )
   catch (e : IOException) do (     e.printStackTrace() )
        var i : int ; i := 0 ; while i < x->size() do ( (     var c : String ; c := x->at(i+1) ;
     if ((c < 'A') or c > 'z') then (     OclFile["System.out"].print(c) ; 
     continue ) else skip ; 
     if (((c)->char2byte() - ('a')->char2byte()) < 0) then (     c := (c + (('a')->char2byte() - ('A')->char2byte()))->oclAsType(String) ) else (     c := ((c)->char2byte() - (('a')->char2byte() - ('A')->char2byte()))->oclAsType(String) ) ;  
     OclFile["System.out"].print(c) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=br.readLine();
    String[] strs=new String[str.length()];
    for(int i=0 ; i<str.length(); i++){
      strs[i]=String.valueOf(str.charAt(i));
      if(strs[i] .toUpperCase().equals(strs[i])){
        strs[i]=strs[i] .toLowerCase();
      }
      else if(strs[i] .toLowerCase().equals(strs[i])){
        strs[i]=strs[i] .toUpperCase();
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<strs.length ; i++){
      sb.append(strs[i]);
    }
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := br.readLine() ;
    var strs : Sequence(String) ; strs := Integer.subrange(1,str->size())->collect(null) ;
        var i : int ; i := 0 ; while i < str->size() do ( (     strs[i+1] := ((str->at(i+1)) + "") ; 
     if (strs[i+1]->toUpperCase() = strs[i+1]) then (     strs[i+1] := strs[i+1]->toLowerCase() ) else     if (strs[i+1]->toLowerCase() = strs[i+1]) then (     strs[i+1] := strs[i+1]->toUpperCase() ) else skip ; )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < strs->size() do ( (     sb := sb + StringLib.newString(strs[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      String line=sc.nextLine();
      String answer="" ;
      int length=line.length();
      for(int i=0 ; i<length ; i++){
        char ch=line.charAt(i);
        if(Character.isUpperCase(ch)==true){
          answer+=Character.toLowerCase(ch);
        }
        else if(Character.isLowerCase(ch)==true){
          answer+=Character.toUpperCase(ch);
        }
        else answer+=ch ;
      }
      System.out.println(answer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var line : String ; line := sc.nextLine() ;
     var answer : String ; answer := "" ;
    var length : int ; length := line->size() ;
        var i : int ; i := 0 ; while i < length do ( (     var ch : String ; ch := line->at(i+1) ;
     if ((ch->toUpperCase() = ch) = true) then (     answer := answer+((ch + "")->toLowerCase()) ) else     if ((ch->toLowerCase() = ch) = true) then (     answer := answer+((ch + "")->toUpperCase()) ) else     answer := answer+(ch) ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  private static Scanner sc=new Scanner(System.in);
  private static String input=sc.nextLine();
  private static ArrayList<String>result=new ArrayList<String>();
  public static void main(String[] args){
    for(int i=0 ; i<input.length(); i++){
      char c=exchanger(input.charAt(i));
      result.add(String.valueOf(c));
    }
    for(int i=0 ; i<result.size(); i++){
      System.out.print(result.get(i));
    }
    System.out.println("");
  }
  private static char exchanger(char x){
    if(Character.isUpperCase(x))return Character.toLowerCase(x);
    if(Character.isLowerCase(x))return Character.toUpperCase(x);
    else return x ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute input : String := sc.nextLine();
  static   attribute result : Sequence(String) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < input->size() do ( (     var c : String ; c := exchanger(input->at(i+1)) ;
     result := result->including(((c) + "")) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < result->size() do ( (     OclFile["System.out"].print(result->at(i+1)) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("") );
  static   operation exchanger( x : String) : String
  pre: true
  post: true
  activity: (     if ((x->toUpperCase() = x)) then     return (x + "")->toLowerCase() else skip ; 
     if ((x->toLowerCase() = x)) then     return (x + "")->toUpperCase() else     return x );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    String str=input.readLine();
    for(char c : str.toCharArray()){
      if(Character.isLowerCase(c)){
        System.out.print(Character.toUpperCase(c));
      }
      else {
        System.out.print(Character.toLowerCase(c));
      }
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := input.readLine() ;
     for (c : str->characters()) do ( (     if ((c->toLowerCase() = c)) then (     OclFile["System.out"].print((c + "")->toUpperCase()) ) else (     OclFile["System.out"].print((c + "")->toLowerCase()) ) )  ) ; 
     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    int k=sc.nextInt();
    int d=sc.nextInt();
    int with_oven=0 ;
    int without_oven=0 ;
    int with=0 ;
    int without=0 ;
    int finish_with=0 ;
    int finish_without=0 ;
    for(int i=1 ; ; ++i){
      if(i % t==0){
        without_oven+=k ;
        with_oven+=k ;
      }
      if(i>d &&(i-d)% t==0){
        with_oven+=k ;
      }
      if(with_oven>=n && with==0){
        finish_with=i ;
        with=1 ;
      }
      if(without_oven>=n && without==0){
        finish_without=i ;
        without=1 ;
      }
      if(with_oven>=n && without_oven>=n){
        break ;
      }
    }
    if(finish_with>=finish_without){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var with_oven : int ; with_oven := 0 ;
    var without_oven : int ; without_oven := 0 ;
    var with : int ; with := 0 ;
    var without : int ; without := 0 ;
    var finish_with : int ; finish_with := 0 ;
    var finish_without : int ; finish_without := 0 ;
        var i : int ; i := 1 ; while true do ( (     if (i mod t = 0) then (     without_oven := without_oven+(k) ; 
     with_oven := with_oven+(k) ) else skip ; 
     if (i > d & (i - d) mod t = 0) then (     with_oven := with_oven+(k) ) else skip ; 
    if (with_oven >= n & with = 0) then (     finish_with := i ; 
     with := 1 ) else skip ; 
    if (without_oven >= n & without = 0) then (     finish_without := i ; 
     without := 1 ) else skip ; 
    if (with_oven >= n & without_oven >= n) then (     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (finish_with >= finish_without) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n_cake=in.nextInt();
    int time=in.nextInt();
    int k=in.nextInt();
    int d=in.nextInt();
    int n=n_cake ;
    int oven=0 ;
    int total=n_cake ;
    int sec=d ;
    int o=0 ;
    if(n_cake<=k ||(n_cake<=k*2 && d>time)||((n_cake/k)*time)<d){
      System.out.println("NO");
    }
    else {
      while(n>0){
        if(n>0 && n!=total && o>=d){
          sec+=time ;
          n-=k ;
          if(n>0){
            n-=k ;
          }
        }
        if(n>0 && o<d){
          o+=time ;
          n-=k ;
        }
        while(n_cake>0){
          oven+=time ;
          n_cake-=k ;
        }
      }
      if(sec<oven){
        System.out.println("YES");
      }
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n_cake : int ; n_cake := in.getCurrent()->toInteger() ;
    var time : int ; time := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var n : int ; n := n_cake ;
    var oven : int ; oven := 0 ;
    var total : int ; total := n_cake ;
    var sec : int ; sec := d ;
    var o : int ; o := 0 ;
    if (n_cake <= k or (n_cake <= k * 2 & d > time) or ((n_cake / k) * time) < d) then (     OclFile["System.out"].println("NO") ) else (     while (n > 0) do (     if (n > 0 & n /= total & o >= d) then (     sec := sec+(time) ; 
     n := n-(k) ; 
     if (n > 0) then (     n := n-(k) ) else skip ) else skip ; 
     if (n > 0 & o < d) then (     o := o+(time) ; 
     n := n-(k) ) else skip ; 
     while (n_cake > 0) do (     oven := oven+(time) ; 
     n_cake := n_cake-(k) ) ) ; 
     if (sec < oven) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
import static java.lang.Math.*;
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
import static java.lang.Double.parseDouble ;
import static java.lang.String.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder out=new StringBuilder();
    StringTokenizer tk ;
    tk=new StringTokenizer(in.readLine());
    int n=parseInt(tk.nextToken()),t=parseInt(tk.nextToken()),k=parseInt(tk.nextToken()),d=parseInt(tk.nextToken());
    int g=(n+k-1)/k ;
    int o1=0,o2=d ;
    for(int i=0 ; i<g ; i++){
      if(o1<=o2)o1+=t ;
      else o2+=t ;
    }
    if(max(o1,o2)<g*t)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : String ; out := StringLib.newString() ;
    var tk : OclIterator ;
    tk := OclIterator.newOclIterator_String(in.readLine()) ; 
    var n : int ; n := parseInt(tk.next()) ;
    var t : int ; t := parseInt(tk.next()) ;
    var k : int ; k := parseInt(tk.next()) ;
    var d : int ; d := parseInt(tk.next()) ;
    var g : int ; g := (n + k - 1) / k ;
    var o1 : int ; o1 := 0 ;
    var o2 : int ; o2 := d ;
        var i : int ; i := 0 ; while i < g do ( (     if (o1 <= o2) then     o1 := o1+(t) ; else     o2 := o2+(t) ; )  ;     i := i + 1 ) ; 
    if (Set{o1, o2}->max() < g * t) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] inputs ;
    inputs=br.readLine().split(" ");
    int n=Integer.parseInt(inputs[0]);
    int k=Integer.parseInt(inputs[1]);
    char s[]=new char[n];
    s=br.readLine().toCharArray();
    int sum=0 ;
    char prev=' ' ;
    for(int i=0 ; i<n ; i++){
      if(prev==s[i]){
        sum++;
      }
      prev=s[i];
    }
    System.out.print(Math.min(n-1,sum+k*2));
    br.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var inputs : Sequence(String) ;
    inputs := br.readLine()->split(" ") ; 
    var n : int ; n := (inputs[0+1])->toInteger() ;
    var k : int ; k := (inputs[1+1])->toInteger() ;
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(0) ;
    s := br.readLine()->characters() ; 
    var sum : int ; sum := 0 ;
    var prev : String ; prev := ' ' ;
        var i : int ; i := 0 ; while i < n do ( (     if (prev = s[i+1]) then (     sum := sum + 1 ) else skip ; 
     prev := s[i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(Set{n - 1, sum + k * 2}->min()) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
import static java.lang.Math.*;
import static java.lang.Integer.parseInt ;
import static java.lang.Long.parseLong ;
import static java.lang.Double.parseDouble ;
import static java.lang.String.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder out=new StringBuilder();
    StringTokenizer tk ;
    tk=new StringTokenizer(in.readLine());
    int n=parseInt(tk.nextToken()),t=parseInt(tk.nextToken()),k=parseInt(tk.nextToken()),d=parseInt(tk.nextToken());
    int g=(n+k-1)/k ;
    int o1=0,o2=d ;
    for(int i=0 ; i<g ; i++){
      if(o1<=o2)o1+=t ;
      else o2+=t ;
    }
    if(max(o1,o2)<g*t)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : String ; out := StringLib.newString() ;
    var tk : OclIterator ;
    tk := OclIterator.newOclIterator_String(in.readLine()) ; 
    var n : int ; n := parseInt(tk.next()) ;
    var t : int ; t := parseInt(tk.next()) ;
    var k : int ; k := parseInt(tk.next()) ;
    var d : int ; d := parseInt(tk.next()) ;
    var g : int ; g := (n + k - 1) / k ;
    var o1 : int ; o1 := 0 ;
    var o2 : int ; o2 := d ;
        var i : int ; i := 0 ; while i < g do ( (     if (o1 <= o2) then     o1 := o1+(t) ; else     o2 := o2+(t) ; )  ;     i := i + 1 ) ; 
    if (Set{o1, o2}->max() < g * t) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Training {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),t=sc.nextInt(),k=sc.nextInt(),d=sc.nextInt();
    int g=(n+k-1)/k ;
    int o1=0,o2=d ;
    for(int i=0 ; i<g ; i++){
      if(o1<=o2)o1+=t ;
      else {
        o2+=t ;
      }
    }
    if(Math.max(o1,o2)<t*g)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Training {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var g : int ; g := (n + k - 1) / k ;
    var o1 : int ; o1 := 0 ;
    var o2 : int ; o2 := d ;
        var i : int ; i := 0 ; while i < g do ( (     if (o1 <= o2) then     o1 := o1+(t) ; else (     o2 := o2+(t) ) )  ;     i := i + 1 ) ; 
    if (Set{o1, o2}->max() < t * g) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  int n ;
  int[] a ;
  void run(){
    for(; ; ){
      n=sc.nextInt();
      if(n==0){
        break ;
      }
      a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      solve();
    }
  }
  void solve(){
    sort(a);
    int sum=0 ;
    for(int i=1 ; i<n-1 ; i++){
      sum+=a[i];
    }
    println(""+sum/(n-2));
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   attribute n : int;
   attribute a : Sequence(int);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then (     break ) else skip ; 
    a := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute solve() ; 
 )  ) );
   operation solve() : void
  pre: true
  post: true
  activity: (     execute sort(a) ; 
     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i < n - 1 do ( (     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
     execute println("" + sum / (n - 2)) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int c,n,x1,y1,x2,y2 ;
    n=sc.nextInt();
    x1=sc.nextInt();
    y1=sc.nextInt();
    x2=sc.nextInt();
    y2=sc.nextInt();
    int dx=Math.abs(x2-x1);
    int dy=Math.abs(y2-y1);
    if(((dx-n)*(dy-n))==0)c=x1+y1+x2+y2 ;
    else c=dx+dy ;
    System.out.println(Math.min(c,4*n-c));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : int ;
    var n : int ;
    var x1 : int ;
    var y1 : int ;
    var x2 : int ;
    var y2 : int ;
    n := sc.getCurrent()->toInteger() ; 
    x1 := sc.getCurrent()->toInteger() ; 
    y1 := sc.getCurrent()->toInteger() ; 
    x2 := sc.getCurrent()->toInteger() ; 
    y2 := sc.getCurrent()->toInteger() ; 
    var dx : int ; dx := if x2 - x1 < 0 then -(x2 - x1) else x2 - x1 endif ;
    var dy : int ; dy := if y2 - y1 < 0 then -(y2 - y1) else y2 - y1 endif ;
    if (((dx - n) * (dy - n)) = 0) then     c := x1 + y1 + x2 + y2 else     c := dx + dy ; ;  
    OclFile["System.out"].println(Set{c, 4 * n - c}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int x1=input.nextInt();
    int y1=input.nextInt();
    int x2=input.nextInt();
    int y2=input.nextInt();
    int a ;
    if(Math.abs(x1-x2)==n){
      a=n+Math.min(2*n-(y1+y2),y1+y2);
    }
    else if(Math.abs(y1-y2)==n){
      a=n+Math.min(2*n-(x1+x2),x1+x2);
    }
    else {
      a=Math.abs(x1-x2)+Math.abs(y1-y2);
    }
    System.out.println(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var x1 : int ; x1 := input.getCurrent()->toInteger() ;
    var y1 : int ; y1 := input.getCurrent()->toInteger() ;
    var x2 : int ; x2 := input.getCurrent()->toInteger() ;
    var y2 : int ; y2 := input.getCurrent()->toInteger() ;
    var a : int ;
    if (if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif = n) then (     a := n + Set{2 * n - (y1 + y2), y1 + y2}->min() ) else     if (if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif = n) then (     a := n + Set{2 * n - (x1 + x2), x1 + x2}->min() ) else (     a := if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif + if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif ) ;  ;  
    OclFile["System.out"].println(a) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A57 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int x=in.nextInt();
    int y=in.nextInt();
    int pos1=position(N,x,y);
    x=in.nextInt();
    y=in.nextInt();
    int pos2=position(N,x,y);
    int dist1=Math.abs(pos2-pos1);
    int dist2=4*N-dist1 ;
    int dist=Math.min(dist1,dist2);
    System.out.println(dist);
  }
  static int position(int N,int x,int y){
    if(y==0){
      return x ;
    }
    else if(x==N){
      return N+y ;
    }
    else if(y==N){
      return 3*N-x ;
    }
    else {
      return 4*N-y ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A57 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
    var y : int ; y := in.getCurrent()->toInteger() ;
    var pos1 : int ; pos1 := position(N, x, y) ;
    x := in.getCurrent()->toInteger() ; 
    y := in.getCurrent()->toInteger() ; 
    var pos2 : int ; pos2 := position(N, x, y) ;
    var dist1 : int ; dist1 := if pos2 - pos1 < 0 then -(pos2 - pos1) else pos2 - pos1 endif ;
    var dist2 : int ; dist2 := 4 * N - dist1 ;
    var dist : int ; dist := Set{dist1, dist2}->min() ;
    OclFile["System.out"].println(dist) ; 
 );
  static   operation position( N : int, x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (y = 0) then (     return x ) else     if (x = N) then (     return N + y ) else     if (y = N) then (     return 3 * N - x ) else (     return 4 * N - y ) ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int M=scanner.nextInt();
      int W=scanner.nextInt();
      if((M | W)==0)break ;
      int[] bm=new int[M];
      for(int i=0 ; i<M ; i++)bm[i]=scanner.nextInt();
      int[] bw=new int[W];
      for(int i=0 ; i<W ; i++)bw[i]=scanner.nextInt();
      int[] dp=new int[1<<W];
      Arrays.fill(dp,-1);
      dp[0]=0 ;
      for(int i=0 ; i<M ; i++){
        for(int j=(1<<W)-1 ; j>=0 ; j--){
          if(dp[j]==-1)continue ;
          for(int k=0 ; k<W ; k++){
            if(((j>>k)& 1)==1)continue ;
            int a=j | 1<<k ;
            int b=(int)(Math.abs(bm[i]-bw[k])*Math.pow(Math.abs(bm[i]-bw[k])-30,2));
            dp[a]=Math.max(dp[a],dp[j]+b);
          }
        }
      }
      int max=0 ;
      for(int i=0 ; i<1<<W ; i++){
        max=Math.max(max,dp[i]);
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var M : int ; M := scanner.getCurrent()->toInteger() ;
     var W : int ; W := scanner.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(M,W)) = 0) then     break else skip ; 
    var bm : Sequence(int) ; bm := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do (     bm[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var bw : Sequence(int) ; bw := Integer.subrange(1,W)->collect(0) ;
        var i : int ; i := 0 ; while i < W do (     bw[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,(1*(2->pow(W)))->oclAsType(long))->collect(0) ;
    dp := dp->collect(-1) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < M do ( (         var j : int ; j := ((1*(2->pow(W)))->oclAsType(long)) - 1 ; while j >= 0 do ( (     if (dp[j+1] = -1) then     continue else skip ; 
         var k : int ; k := 0 ; while k < W do ( (     if ((((j/(2->pow(k)))->oclAsType(long)) & 1) = 1) then     continue else skip ; 
     var a : int ; a := MathLib.bitwiseOr(j,(1*(2->pow(k)))->oclAsType(long)) ;
     var b : int ; b := (if bm[i+1] - bw[k+1] < 0 then -(bm[i+1] - bw[k+1]) else bm[i+1] - bw[k+1] endif * if bm[i+1] - bw[k+1] < 0 then -(bm[i+1] - bw[k+1]) else bm[i+1] - bw[k+1] endif - 30->pow(2))->oclAsType(int) ;
     dp[a+1] := Set{dp[a+1], dp[j+1] + b}->max() )  ;     k := k + 1 ) )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < (1*(2->pow(W)))->oclAsType(long) do ( (     max := Set{max, dp[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int M=scanner.nextInt();
      int W=scanner.nextInt();
      if((M | W)==0)break ;
      int[] bm=new int[M];
      for(int i=0 ; i<M ; i++)bm[i]=scanner.nextInt();
      int[] bw=new int[W];
      for(int i=0 ; i<W ; i++)bw[i]=scanner.nextInt();
      int[] dp=new int[1<<W];
      Arrays.fill(dp,-1);
      dp[0]=0 ;
      for(int i=0 ; i<M ; i++){
        for(int j=(1<<W)-2 ; j>=0 ; j--){
          if(dp[j]==-1)continue ;
          for(int k=0 ; k<W ; k++){
            if(((j>>k)& 1)==1)continue ;
            int a=j | 1<<k ;
            int b=(int)(Math.abs(bm[i]-bw[k])*Math.pow(Math.abs(bm[i]-bw[k])-30,2));
            dp[a]=Math.max(dp[a],dp[j]+b);
          }
        }
      }
      int max=0 ;
      for(int i=0 ; i<1<<W ; i++){
        max=Math.max(max,dp[i]);
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var M : int ; M := scanner.getCurrent()->toInteger() ;
     var W : int ; W := scanner.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(M,W)) = 0) then     break else skip ; 
    var bm : Sequence(int) ; bm := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do (     bm[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var bw : Sequence(int) ; bw := Integer.subrange(1,W)->collect(0) ;
        var i : int ; i := 0 ; while i < W do (     bw[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,(1*(2->pow(W)))->oclAsType(long))->collect(0) ;
    dp := dp->collect(-1) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < M do ( (         var j : int ; j := ((1*(2->pow(W)))->oclAsType(long)) - 2 ; while j >= 0 do ( (     if (dp[j+1] = -1) then     continue else skip ; 
         var k : int ; k := 0 ; while k < W do ( (     if ((((j/(2->pow(k)))->oclAsType(long)) & 1) = 1) then     continue else skip ; 
     var a : int ; a := MathLib.bitwiseOr(j,(1*(2->pow(k)))->oclAsType(long)) ;
     var b : int ; b := (if bm[i+1] - bw[k+1] < 0 then -(bm[i+1] - bw[k+1]) else bm[i+1] - bw[k+1] endif * if bm[i+1] - bw[k+1] < 0 then -(bm[i+1] - bw[k+1]) else bm[i+1] - bw[k+1] endif - 30->pow(2))->oclAsType(int) ;
     dp[a+1] := Set{dp[a+1], dp[j+1] + b}->max() )  ;     k := k + 1 ) )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < (1*(2->pow(W)))->oclAsType(long) do ( (     max := Set{max, dp[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main2 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 long mod=(long)(1e9+7);
  static FastReader sc=new FastReader();
  static PrintWriter out=new PrintWriter(System.out);
  static long ans[];
  public static void main(String[] args){
    int t=1 ;
    t=sc.nextInt();
    z : while(t-->0){
      int N=sc.nextInt();
      int x=sc.nextInt();
      int y=sc.nextInt();
      int min=Math.min(N,x+y-N+1);
      min=Math.max(1,min);
      int max=Math.min(N,x+y-1);
      System.out.println(min+"  "+max);
    }
    out.close();
  }
  private static void ini(ArrayList<Integer>[] tre2){
    for(int i=0 ; i<tre2.length ; i++){
      tre2[i]=new ArrayList<>();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main2 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   attribute mod : long := (1e9 + 7)->oclAsType(long);
  static   attribute sc : FastReader := FastReader.newFastReader();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute ans : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
     t := sc.nextInt() ; 
         while (t > 0) do (        t := t - 1 ;     skip ; (     var N : int ; N := sc.nextInt() ;
     var x : int ; x := sc.nextInt() ;
    var y : int ; y := sc.nextInt() ;
    var min : int ; min := Set{N, x + y - N + 1}->min() ;
    min := Set{1, min}->max() ; 
    var max : int ; max := Set{N, x + y - 1}->min() ;
    OclFile["System.out"].println(min + "  " + max) ; 
 ) ;  ) ;  
     skip );
  static   operation ini( tre2 : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < tre2->size() do ( (     tre2[i+1] := Sequence{} )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.*;
import static java.lang.System.*;
public class Main {
  public static void main(String[] args){
    int i,j ;
    Scanner sc=new Scanner(in);
    int n=parseInt(sc.next());
    int k=parseInt(sc.next());
    char[] s=sc.next().toCharArray();
    sc.close();
    int m=n ;
    int cnt=0 ;
    for(i=0 ; i<s.length-1 ; i++){
      if(s[i]=='R' && s[i+1]=='L'){
        cnt++;
        i++;
      }
    }
    if(s[n-1]=='R'){
      cnt++;
      m++;
    }
    if(s[0]=='L'){
      cnt++;
      m++;
    }
    out.println(Math.min(n-1,m-2*(cnt-k)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
    var n : int ; n := parseInt(sc.getCurrent()) ;
    var k : int ; k := parseInt(sc.getCurrent()) ;
    var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    skip ; 
    var m : int ; m := n ;
    var cnt : int ; cnt := 0 ;
        i := 0 ; while i < s->size() - 1 do ( (     if (s[i+1] = 'R' & s[i + 1+1] = 'L') then (     cnt := cnt + 1 ; 
     i := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (s[n - 1+1] = 'R') then (     cnt := cnt + 1 ; 
     m := m + 1 ) else skip ; 
    if (s[0+1] = 'L') then (     cnt := cnt + 1 ; 
     m := m + 1 ) else skip ; 
    out.println(Set{n - 1, m - 2 * (cnt - k)}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Vjudge {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int x=sc.nextInt();
      int y=sc.nextInt();
      int worst=Math.min(n,x+y-1);
      int best=0 ;
      if(x+y<=n)best=1 ;
      else best=Math.min(n,x+y-n+1);
      System.out.println(best+" "+worst);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Vjudge {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var worst : int ; worst := Set{n, x + y - 1}->min() ;
    var best : int ; best := 0 ;
    if (x + y <= n) then     best := 1 else     best := Set{n, x + y - n + 1}->min() ; ;  
    OclFile["System.out"].println(best + " " + worst) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countNumbers(int x,int n){
    if(x>n)return 0 ;
    return 1+countNumbers(x*10,n)+countNumbers(x*10+1,n);
  }
  public static void main(String[] args){
    int n=120 ;
    System.out.println(countNumbers(1,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countNumbers( x : int, n : int) : int
  pre: true
  post: true
  activity: (     if (x > n) then     return 0 else skip ; 
     return 1 + countNumbers(x * 10, n) + countNumbers(x * 10 + 1, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 120 ;
     OclFile["System.out"].println(countNumbers(1, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int two_sets(int a[],int n){
    Arrays.sort(a);
    return a[n/2]-a[(n/2)-1];
  }
  public static void main(String[] args){
    int a[]={
      1,4,4,6,7,9 };
      int n=a.length ;
      System.out.println(two_sets(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation two_sets( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     return a[n / 2+1] - a[(n / 2) - 1+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,4,4,6,7,9} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(two_sets(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num=20 ;
    while(true){
      ArrayList<Integer>ary=new ArrayList<Integer>();
      num=sc.nextInt();
      if(num==0){
        break ;
      }
      for(int i=0 ; i<num ; i++){
        int word=sc.nextInt();
        ary.add(word);
      }
      int min=ary.get(0);
      int max=ary.get(0);
      for(int i : ary){
        if(i<min){
          min=i ;
        }
        if(i>max){
          max=i ;
        }
      }
      int index1=ary.indexOf(min);
      ary.remove(index1);
      int index2=ary.indexOf(max);
      ary.remove(index2);
      int sum=0 ;
      for(int i : ary){
        sum+=i ;
      }
      int ave=sum/ary.size();
      System.out.println(ave);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := 20 ;
     while (true) do (     var ary : Sequence(int) ; ary := Sequence{} ;
     num := sc.getCurrent()->toInteger() ; 
    if (num = 0) then (     break ) else skip ; 
        var i : int ; i := 0 ; while i < num do ( (     var word : int ; word := sc.getCurrent()->toInteger() ;
     ary := ary->including(word) )  ;     i := i + 1 ) ; 
    var min : int ; min := ary->at(0+1) ;
    var max : int ; max := ary->at(0+1) ;
    for (i : ary) do ( (     if (i < min) then (     min := i ) else skip ; 
     if (i > max) then (     max := i ) else skip )  ) ; 
    var index1 : int ; index1 := ary->indexOf(min)-1 ;
    ary := ary->excludingAt(index1+1) ; 
    var index2 : int ; index2 := ary->indexOf(max)-1 ;
    ary := ary->excludingAt(index2+1) ; 
    var sum : int ; sum := 0 ;
    for (i : ary) do ( (     sum := sum+(i) )  ) ; 
    var ave : int ; ave := sum / ary->size() ;
    OclFile["System.out"].println(ave) ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static int getSum(int arr[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      double sqrtCurrent=Math.sqrt(arr[i]);
      for(int j=0 ; j<n ; j++){
        double x=arr[j];
        if(x==sqrtCurrent){
          sum+=(sqrtCurrent*sqrtCurrent);
          break ;
        }
      }
    }
    return sum ;
  }
  public static void main(String args[]){
    int arr[]={
      2,4,5,6,7,8,9,3 };
      int n=arr.length ;
      System.out.println(getSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var sqrtCurrent : double ; sqrtCurrent := (arr[i+1])->sqrt() ;
         var j : int ; j := 0 ; while j < n do ( (     var x : double ; x := arr[j+1] ;
     if (x = sqrtCurrent) then (     sum := sum+((sqrtCurrent * sqrtCurrent)) ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,5,6,7,8,9,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(getSum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p587 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p587().run());
  }
  public String run(){
    double lSectionArea=1-Math.PI/4 ;
    for(int i=1 ; ; i++){
      double slope=1.0/i ;
      double a=slope*slope+1 ;
      double b=-2*(slope+1);
      double c=1 ;
      double x=(2*c)/(-b+Math.sqrt(b*b-4*a*c));
      double concaveTriangleArea=(x*x*slope/2)+(integral(1)-integral(x));
      if(concaveTriangleArea/lSectionArea<0.001)return Integer.toString(i);
      if(i==Integer.MAX_VALUE)throw new AssertionError();
    }
  }
  private static double integral(double x){
    double t=x-1 ;
    return t-(Math.sqrt(x*(2-x))*t+Math.asin(t))/2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p587 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p587.newp587().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var lSectionArea : double ; lSectionArea := 1 - 3.141592653589793 / 4 ;
         var i : int ; i := 1 ; while true do ( (     var slope : double ; slope := 1.0 / i ;
     var a : double ; a := slope * slope + 1 ;
    var b : double ; b := -2 * (slope + 1) ;
    var c : double ; c := 1 ;
    var x : double ; x := (2 * c) / (-b + (b * b - 4 * a * c)->sqrt()) ;
    var concaveTriangleArea : double ; concaveTriangleArea := (x * x * slope / 2) + (integral(1) - integral(x)) ;
    if (concaveTriangleArea / lSectionArea < 0.001) then     return ((i) + "") else skip ; 
    if (i = 2147483647) then     error AssertionException() ; else skip ; 
 )  ;     i := i + 1 ) );
  static   operation integral( x : double) : double
  pre: true
  post: true
  activity: (     var t : double ; t := x - 1 ;
     return t - ((x * (2 - x))->sqrt() * t + (t)->asin()) / 2 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static void printDiagonalSums(int[][] mat,int n){
    int principal=0,secondary=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(i==j)principal+=mat[i][j];
        if((i+j)==(n-1))secondary+=mat[i][j];
      }
    }
    System.out.println("Principal Diagonal:"+principal);
    System.out.println("Secondary Diagonal:"+secondary);
  }
  static public void main(String[] args){
    int[][] a={
      {
        1,2,3,4 },{
          5,6,7,8 },{
            1,2,3,4 },{
              5,6,7,8 }
            };
            printDiagonalSums(a,4);
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printDiagonalSums( mat : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (     var principal : int ; principal := 0 ;
    var secondary : int ; secondary := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (i = j) then     principal := principal+(mat[i+1][j+1]) ; else skip ; 
     if ((i + j) = (n - 1)) then     secondary := secondary+(mat[i+1][j+1]) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Principal Diagonal:" + principal) ; 
     OclFile["System.out"].println("Secondary Diagonal:" + secondary) );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(Sequence(int)) ; a := Sequence{Sequence{1,2,3,4},Sequence{5,6,7,8},Sequence{1,2,3,4},Sequence{5,6,7,8}} ;
     execute printDiagonalSums(a, 4) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static void printDiagonalSums(int[][] mat,int n){
    int principal=0,secondary=0 ;
    for(int i=0 ; i<n ; i++){
      principal+=mat[i][i];
      secondary+=mat[i][n-i-1];
    }
    System.out.println("Principal Diagonal:"+principal);
    System.out.println("Secondary Diagonal:"+secondary);
  }
  static public void main(String[] args){
    int[][] a={
      {
        1,2,3,4 },{
          5,6,7,8 },{
            1,2,3,4 },{
              5,6,7,8 }
            };
            printDiagonalSums(a,4);
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printDiagonalSums( mat : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (     var principal : int ; principal := 0 ;
    var secondary : int ; secondary := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     principal := principal+(mat[i+1][i+1]) ; 
     secondary := secondary+(mat[i+1][n - i - 1+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Principal Diagonal:" + principal) ; 
     OclFile["System.out"].println("Secondary Diagonal:" + secondary) );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(Sequence(int)) ; a := Sequence{Sequence{1,2,3,4},Sequence{5,6,7,8},Sequence{1,2,3,4},Sequence{5,6,7,8}} ;
     execute printDiagonalSums(a, 4) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import java.io.*;
public class S {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int test=Integer.parseInt(br.readLine());
    while(test>0){
      test--;
      String s=br.readLine();
      solve(s);
    }
  }
  final static int MOD=1000000007 ;
  public static void solve(String s){
    if(isPal(s)){
      String ss="a"+s ;
      if(isPal(ss)){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
        System.out.println(ss);
      }
    }
    else {
      StringBuilder sb=new StringBuilder();
      int n=s.length();
      int g=n/2 ;
      for(int i=0 ; i<g ; i++){
        sb.append(s.charAt(i));
      }
      sb.append('a');
      for(int i=g ; i<n ; i++){
        sb.append(s.charAt(i));
      }
      System.out.println("YES");
      System.out.println(sb.toString());
    }
  }
  public static boolean isPal(String s){
    int l=0 ;
    int r=s.length()-1 ;
    while(l<=r){
      if(s.charAt(l)!=s.charAt(r)){
        return false ;
      }
      l++;
      r--;
    }
    return true ;
  }
  public static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class S {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var test : int ; test := (br.readLine())->toInteger() ;
     while (test > 0) do (     test := test - 1 ; 
     var s : String ; s := br.readLine() ;
     execute solve(s) ) );
  static   attribute MOD : int := 1000000007;
  static   operation solve( s : String) : void
  pre: true
  post: true
  activity: (     if (isPal(s)) then (     var ss : String ; ss := "a" + s ;
     if (isPal(ss)) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(ss) ) ) else (     var sb : String ; sb := StringLib.newString() ;
     var n : int ; n := s->size() ;
    var g : int ; g := n / 2 ;
        var i : int ; i := 0 ; while i < g do ( (     sb := sb + StringLib.newString(s->at(i+1)) )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString('a') ; 
        var i : int ; i := g ; while i < n do ( (     sb := sb + StringLib.newString(s->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
    OclFile["System.out"].println(sb+"") ; 
 ) );
  static   operation isPal( s : String) : boolean
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
     var r : int ; r := s->size() - 1 ;
     while (l <= r) do (     if (s->at(l+1) /= s->at(r+1)) then (     return false ) else skip ; 
     l := l + 1 ; 
     r := r - 1 ) ; 
     return true );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Solution {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ni(){
      return Integer.parseInt(next());
    }
    long nl(){
      return Long.parseLong(next());
    }
    double nd(){
      return Double.parseDouble(next());
    }
    String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args)throws java.lang.Exception {
    FastReader fr=new FastReader();
    PrintWriter out=new PrintWriter(System.out);
    int t=fr.ni();
    while(t-->0){
      String str=fr.next();
      String temp='a'+str ;
      String temp2=str+'a' ;
      if(! isPalindrom(temp.toCharArray())){
        out.println("YES");
        out.println(temp);
      }
      else if(! isPalindrom(temp2.toCharArray())){
        out.println("YES");
        out.println(temp2);
      }
      else out.println("NO");
    }
    out.close();
  }
  public static boolean isPalindrom(char[] arr){
    int i=0,j=arr.length-1 ;
    while(i<=j){
      if(arr[i]!=arr[j])return false ;
      i++;
      j--;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nl() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nd() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fr : FastReader ; fr := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := fr.ni() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var str : String ; str := fr.next() ;
     var temp : String ; temp := 'a' + str ;
     var temp2 : String ; temp2 := str + 'a' ;
     if (not(isPalindrom(temp->characters()))) then (     skip ; 
     skip ) else     if (not(isPalindrom(temp2->characters()))) then (     skip ; 
     skip ) else     skip ; ;  ) ;  ) ;  
    skip ; 
 );
  static   operation isPalindrom( arr : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var j : int ; j := arr->size() - 1 ;
     while (i <= j) do (     if (arr[i+1] /= arr[j+1]) then     return false else skip ; 
     i := i + 1 ; 
     j := j - 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int Search(String S){
    int result=0 ;
    for(int i=0 ; i<S.length()-1 ; i++)if(S.charAt(i)==S.charAt(i+1))result++;
    return result ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int K=in.nextInt();
    in.nextLine();
    String S=in.nextLine();
    System.out.println((Search(S)+2*K)>(N-1)?(N-1):(Search(S)+2*K));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation Search( S : String) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < S->size() - 1 do (     if (S->at(i+1) = S->at(i + 1+1)) then     result := result + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    skip ; 
    var S : String ; S := in.nextLine() ;
    OclFile["System.out"].println(if (Search(S) + 2 * K) > (N - 1) then (N - 1) else (Search(S) + 2 * K) endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int count=0 ;
      String s=sc.next();
      for(int i=0 ; i<s.length(); i++){
        if(s.charAt(i)=='a')count++;
      }
      if(count==s.length()){
        System.out.println("NO");
        continue ;
      }
      String s1=s+"a" ;
      int flag=0 ;
      for(int i=0 ; i<(s1.length()+1)/2 ; i++){
        if(s1.charAt(i)!=s1.charAt(s1.length()-1-i)){
          flag=1 ;
          break ;
        }
      }
      if(flag==1){
        System.out.println("YES");
        System.out.println(s1);
      }
      else {
        System.out.println("YES");
        System.out.println("a"+s);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var count : int ; count := 0 ;
     var s : String ; s := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'a') then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (count = s->size()) then (     OclFile["System.out"].println("NO") ; 
     continue ) else skip ; 
    var s1 : String ; s1 := s + "a" ;
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < (s1->size() + 1) / 2 do ( (     if (s1->at(i+1) /= s1->at(s1->size() - 1 - (i)->char2byte()+1)) then (     flag := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 1) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(s1) ) else (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println("a" + s) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  static boolean pali(String s){
    int n=s.length();
    for(int i=0 ; i<n/2 ; i++){
      int j=n-i-1 ;
      if(s.charAt(i)!=s.charAt(j)){
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      while(n-->0){
        String s=sc.next();
        String s1="a" ;
        if((s.length()==1)&&(s.equals(s1)==true)){
          System.out.println("NO");
        }
        else if((s.length()==1)&&(s.equals(s1)==false)){
          System.out.println("YES");
          System.out.println(s+s1);
        }
        else if(! pali(s.concat(s1))){
          System.out.println("YES");
          System.out.println(s.concat(s1));
        }
        else if(! pali(s1.concat(s))){
          System.out.println("YES");
          System.out.println(s1.concat(s));
        }
        else {
          System.out.println("NO");
        }
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation pali( s : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
         var i : int ; i := 0 ; while i < n / 2 do ( (     var j : int ; j := n - i - 1 ;
     if (s->at(i+1) /= s->at(j+1)) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var s : String ; s := sc.getCurrent() ;
     var s1 : String ; s1 := "a" ;
     if ((s->size() = 1) & (s = s1 = true)) then (     OclFile["System.out"].println("NO") ) else     if ((s->size() = 1) & (s = s1 = false)) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(s + s1) ) else     if (not(pali(s+s1))) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(s+s1) ) else     if (not(pali(s1+s))) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(s1+s) ) else (     OclFile["System.out"].println("NO") ) ;  ;  ;  ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Emirp {
  public static boolean isPrime(int n){
    if(n<=1)return false ;
    for(int i=2 ; i<n ; i++)if(n % i==0)return false ;
    return true ;
  }
  public static boolean isEmirp(int n){
    if(isPrime(n)==false)return false ;
    int rev=0 ;
    while(n!=0){
      int d=n % 10 ;
      rev=rev*10+d ;
      n/=10 ;
    }
    return isPrime(rev);
  }
  public static void main(String args[])throws IOException {
    int n=13 ;
    if(isEmirp(n)==true)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Emirp {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
         var i : int ; i := 2 ; while i < n do (     if (n mod i = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation isEmirp( n : int) : boolean
  pre: true
  post: true
  activity: (     if (isPrime(n) = false) then     return false else skip ; 
     var rev : int ; rev := 0 ;
     while (n /= 0) do (     var d : int ; d := n mod 10 ;
     rev := rev * 10 + d ; 
     n := n/(10) ) ; 
     return isPrime(rev) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 13 ;
     if (isEmirp(n) = true) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long power(int x,long y){
    long res=1 ;
    while(y>0){
      if(y==1)res=(res*x);
      y=y>>1 ;
      x=(x*x);
    }
    return res ;
  }
  static long solve(int L){
    int n=L/2+1 ;
    long ans=power(n,n-2);
    return ans ;
  }
  public static void main(String[] args){
    int L=6 ;
    System.out.println(solve(L));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation power( x : int, y : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     while (y > 0) do (     if (y = 1) then     res := (res * x) ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) ) ; 
     return res );
  static   operation solve( L : int) : long
  pre: true
  post: true
  activity: (     var n : int ; n := L / 2 + 1 ;
     var ans : long ; ans := power(n, n - 2) ;
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 6 ;
     OclFile["System.out"].println(solve(L)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=Integer.parseInt(line);
      if(n==0){
        break ;
      }
      int min=1001,max=-1,sum=0 ;
      for(int i=0 ; i<n ; i++){
        int s=Integer.parseInt(br.readLine());
        sum+=s ;
        if(s<min){
          min=s ;
        }
        if(s>max){
          max=s ;
        }
      }
      System.out.println((sum-min-max)/(n-2));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := (line)->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var min : int ; min := 1001 ;
    var max : int ; max := -1 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var s : int ; s := (br.readLine())->toInteger() ;
     sum := sum+(s) ; 
     if (s < min) then (     min := s ) else skip ; 
     if (s > max) then (     max := s ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((sum - min - max) / ((n)->char2byte() - 2)) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B_Queue_at_the_School {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),t=sc.nextInt();
    String s=sc.next();
    while(s.contains("BG")&& t>0){
      s=s.replace("BG","GB");
      t--;
    }
    System.out.println(s);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Queue_at_the_School {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    while (s->includes("BG") & t > 0) do (     s := s.replace("BG", "GB") ; 
     t := t - 1 ) ; 
    OclFile["System.out"].println(s) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    if(n<1){
      System.exit(0);
    }
    int t=scanner.nextInt();
    if(t>50){
      System.exit(0);
    }
    String s=scanner.next();
    if(s.length()==n){
      while(t>0){
        if(s.contains("BG")){
          s=s.replaceAll("BG","GB");
        }
        t--;
      }
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    if (n < 1) then ( OclProcess.exit(0) ) else skip ; 
    var t : int ; t := scanner.getCurrent()->toInteger() ;
    if (t > 50) then ( OclProcess.exit(0) ) else skip ; 
    var s : String ; s := scanner.getCurrent() ;
    if (s->size() = n) then (     while (t > 0) do (     if (s->includes("BG")) then (     s := s.replaceAllMatches("BG", "GB" ) ) else skip ; 
     t := t - 1 ) ; 
     OclFile["System.out"].println(s) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class QueueAtSchool {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int number=in.nextInt();
    int time=in.nextInt();
    String queue=in.next();
    for(int i=0 ; i<time ; i++){
      queue=queue.replaceAll("BG","GB");
    }
    System.out.println(queue);
  }
}
------------------------------------------------------------
OCL File:
---------
 class QueueAtSchool {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := in.getCurrent()->toInteger() ;
    var time : int ; time := in.getCurrent()->toInteger() ;
    var queue : String ; queue := in.getCurrent() ;
        var i : int ; i := 0 ; while i < time do ( (     queue := queue.replaceAllMatches("BG", "GB" ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(queue) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Application {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    String teen=scan.next();
    while(k-->0){
      teen=teen.replace("BG","GB");
    }
    System.out.println(teen);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Application {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var teen : String ; teen := scan.getCurrent() ;
        while (k > 0) do (        k := k - 1 ;     skip ; (     teen := teen.replace("BG", "GB") ) ;  ) ;  
    OclFile["System.out"].println(teen) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Codesolver {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,k ;
    n=sc.nextInt();
    k=sc.nextInt();
    sc.nextLine();
    String st ;
    st=sc.nextLine();
    for(int i=0 ; i<k ; i++){
      st=st.replace("BG","GB");
    }
    System.out.println(st);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codesolver {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var k : int ;
    n := sc.getCurrent()->toInteger() ; 
    k := sc.getCurrent()->toInteger() ; 
    skip ; 
    var st : String ;
    st := sc.nextLine() ; 
        var i : int ; i := 0 ; while i < k do ( (     st := st.replace("BG", "GB") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(st) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    int K=Integer.parseInt(sc.next());
    String S=sc.next();
    char[] c1=S.toCharArray();
    char[] c3=S.toCharArray();
    boolean flag=false ;
    int count=0 ;
    for(int i=0 ; i<N ; i++){
      if(flag && c1[i]=='R'){
        flag=false ;
        count++;
      }
      if(count==K){
        break ;
      }
      if(c1[i]=='L'){
        flag=true ;
        c1[i]='R' ;
      }
    }
    flag=false ;
    count=0 ;
    for(int i=0 ; i<N ; i++){
      if(flag && c3[i]=='L'){
        flag=false ;
        count++;
      }
      if(count==K){
        break ;
      }
      if(c3[i]=='R'){
        flag=true ;
        c3[i]='L' ;
      }
    }
    String S1=new String(c1);
    String S3=new String(c3);
    count=1 ;
    int sum1=0 ;
    char bef=S1.charAt(0);
    for(int i=1 ; i<N ; i++){
      if(S1.charAt(i)==bef){
        count++;
        if(i==N-1){
          sum1+=count-1 ;
        }
      }
      else {
        bef=S1.charAt(i);
        sum1+=count-1 ;
        count=1 ;
      }
    }
    count=1 ;
    int sum3=0 ;
    bef=S3.charAt(0);
    for(int i=1 ; i<N ; i++){
      if(S3.charAt(i)==bef){
        count++;
        if(i==N-1){
          sum3+=count-1 ;
        }
      }
      else {
        bef=S3.charAt(i);
        sum3+=count-1 ;
        count=1 ;
      }
    }
    System.out.println(Math.max(sum1,sum3));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var K : int ; K := (sc.getCurrent())->toInteger() ;
    var S : String ; S := sc.getCurrent() ;
    var c1 : Sequence(String) ; c1 := S->characters() ;
    var c3 : Sequence(String) ; c3 := S->characters() ;
    var flag : boolean ; flag := false ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (flag & c1[i+1] = 'R') then (     flag := false ; 
     count := count + 1 ) else skip ; 
     if (count = K) then (     break ) else skip ; 
     if (c1[i+1] = 'L') then (     flag := true ; 
     c1[i+1] := 'R' ) else skip )  ;     i := i + 1 ) ; 
    flag := false ; 
    count := 0 ; 
        var i : int ; i := 0 ; while i < N do ( (     if (flag & c3[i+1] = 'L') then (     flag := false ; 
     count := count + 1 ) else skip ; 
     if (count = K) then (     break ) else skip ; 
     if (c3[i+1] = 'R') then (     flag := true ; 
     c3[i+1] := 'L' ) else skip )  ;     i := i + 1 ) ; 
    var S1 : String ; S1 := StringLib.newString(c1) ;
    var S3 : String ; S3 := StringLib.newString(c3) ;
    count := 1 ; 
    var sum1 : int ; sum1 := 0 ;
    var bef : String ; bef := S1->at(0+1) ;
        var i : int ; i := 1 ; while i < N do ( (     if (S1->at(i+1) = bef) then (     count := count + 1 ; 
     if (i = N - 1) then (     sum1 := sum1+(count - 1) ) else skip ) else (     bef := S1->at(i+1) ; 
     sum1 := sum1+(count - 1) ; 
     count := 1 ) )  ;     i := i + 1 ) ; 
    count := 1 ; 
    var sum3 : int ; sum3 := 0 ;
    bef := S3->at(0+1) ; 
        var i : int ; i := 1 ; while i < N do ( (     if (S3->at(i+1) = bef) then (     count := count + 1 ; 
     if (i = N - 1) then (     sum3 := sum3+(count - 1) ) else skip ) else (     bef := S3->at(i+1) ; 
     sum3 := sum3+(count - 1) ; 
     count := 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{sum1, sum3}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String num1=sc.next();
    String num2=sc.next();
    int i=0 ;
    for(i=0 ; i<num1.length(); i++){
      if(num1.charAt(i)!=num2.charAt(i)){
        System.out.print("1");
      }
      else {
        System.out.print("0");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num1 : String ; num1 := sc.getCurrent() ;
    var num2 : String ; num2 := sc.getCurrent() ;
    var i : int ; i := 0 ;
        i := 0 ; while i < num1->size() do ( (     if (num1->at(i+1) /= num2->at(i+1)) then (     OclFile["System.out"].print("1") ) else (     OclFile["System.out"].print("0") ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class CodeForces {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    LinkedList<Character>list1=new LinkedList<>();
    LinkedList<Character>list2=new LinkedList<>();
    LinkedList<Character>list3=new LinkedList<>();
    String num1=scan.next();
    String num2=scan.next();
    for(int i=0 ; i<num1.length(); i++){
      char s=num1.charAt(i);
      list1.add(s);
      char c=num2.charAt(i);
      list2.add(c);
    }
    for(int i=0 ; i<num1.length(); i++){
      if(list1.get(i)==list2.get(i))list3.add('0');
      else list3.add('1');
    }
    for(Character c : list3){
      System.out.print(c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list1 : Sequence(String) ; list1 := Sequence{} ;
    var list2 : Sequence(String) ; list2 := Sequence{} ;
    var list3 : Sequence(String) ; list3 := Sequence{} ;
    var num1 : String ; num1 := scan.getCurrent() ;
    var num2 : String ; num2 := scan.getCurrent() ;
        var i : int ; i := 0 ; while i < num1->size() do ( (     var s : String ; s := num1->at(i+1) ;
     list1 := list1->including(s) ; 
     var c : String ; c := num2->at(i+1) ;
     list2 := list2->including(c) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < num1->size() do ( (     if (list1->at(i+1) = list2->at(i+1)) then     list3 := list3->including('0') ; else     list3 := list3->including('1') ; )  ;     i := i + 1 ) ; 
    for (c : list3) do ( (     OclFile["System.out"].print(c) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class UltraFastMathematician {
  public static void main(String[] args)throws IOException {
    FastIO io=new FastIO();
    String a=io.nextLine();
    String b=io.nextLine();
    for(int i=0 ; i<a.length(); i++){
      int aval=a.charAt(i)-'0' ;
      int bval=b.charAt(i)-'0' ;
      io.print(aval ^ bval);
    }
    io.println();
    io.close();
  }
  static class FastIO extends PrintWriter {
    private BufferedReader br ;
    private StringTokenizer st ;
    public FastIO(){
      this(System.in,System.out);
    }
    public FastIO(InputStream in,OutputStream out){
      super(out);
      br=new BufferedReader(new InputStreamReader(in));
    }
    public FastIO(String problemName)throws IOException {
      super(new FileWriter(problemName+".out"));
      br=new BufferedReader(new FileReader(problemName+".in"));
    }
    public String next(){
      try {
        while(st==null || ! st.hasMoreTokens()){
          st=new StringTokenizer(br.readLine());
        }
        return st.nextToken();
      }
      catch(Exception e){
      }
      return null ;
    }
    public String nextLine(){
      try {
        return br.readLine();
      }
      catch(Exception e){
      }
      return null ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public boolean nextBoolean(){
      return Boolean.parseBoolean(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class UltraFastMathematician {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : FastIO ; io := FastIO.newFastIO() ;
     var a : String ; a := io.nextLine() ;
    var b : String ; b := io.nextLine() ;
        var i : int ; i := 0 ; while i < a->size() do ( (     var aval : int ; aval := a->at(i+1) - ('0')->char2byte() ;
     var bval : int ; bval := b->at(i+1) - ('0')->char2byte() ;
     io.print(MathLib.bitwiseXor(aval,bval)) )  ;     i := i + 1 ) ; 
    io.println() ; 
    io.close() ; 
 );
  static class FastIO extends OclFile {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastIO() : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile["System.in"], OclFile["System.out"]) );
   static operation newFastIO( in : OclFile, out : OclFile) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(in, out);
    return self );
  operation initialise( in : OclFile, out : OclFile) : void
  pre: true  post: true
  activity: (     execute super(out) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   static operation newFastIO( problemName : String) : FastIO
  pre: true
  post: true
  activity:
  ( var self : FastIO ;
    self := createFastIO();
    self.initialise(problemName);
    return self );
  operation initialise( problemName : String) : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Write(problemName + ".out")) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(problemName + ".in")) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() )   catch (e : ProgramException) do skip
     return null );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : ProgramException) do skip
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextBoolean() : boolean
  pre: true
  post: true
  activity: (     return parseBoolean(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class cp_temp_test {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        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().trim();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  static class FastWriter {
    private final BufferedWriter bw ;
    public FastWriter(){
      this.bw=new BufferedWriter(new OutputStreamWriter(System.out));
    }
    public void print(Object object)throws IOException {
      bw.append(""+object);
    }
    public void println(Object object)throws IOException {
      print(object);
      bw.append("\n");
    }
    public void close()throws IOException {
      bw.close();
    }
  }
  public static void main(String[] args){
    try {
      FastReader in=new FastReader();
      FastWriter out=new FastWriter();
      String m=in.nextLine();
      String n=in.nextLine();
      StringBuilder ans=new StringBuilder();
      for(int i=0 ; i<m.length(); i++){
        if(m.charAt(i)==0 && n.charAt(i)==0){
          ans.append(0);
        }
        else if(m.charAt(i)!=n.charAt(i)){
          ans.append(1);
        }
        else {
          ans.append(0);
        }
      }
      out.print(ans.toString());
      out.close();
    }
    catch(Exception e){
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp_temp_test {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine()->trim() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return str );
}
  static class FastWriter {
   attribute bw : OclFile;
   static operation newFastWriter() : FastWriter
  pre: true
  post: true
  activity:
  ( var self : FastWriter ;
    self := createFastWriter();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) );
   operation print( object : OclAny) : void
  pre: true
  post: true
  activity: (     skip );
   operation println( object : OclAny) : void
  pre: true
  post: true
  activity: (     execute print(object) ; 
     skip );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : FastWriter ; out := FastWriter.newFastWriter() ;
    var m : String ; m := in.nextLine() ;
    var n : String ; n := in.nextLine() ;
    var ans : String ; ans := StringLib.newString() ;
        var i : int ; i := 0 ; while i < m->size() do ( (     if (m->at(i+1) = 0 & n->at(i+1) = 0) then (     ans := ans + StringLib.newString(0) ) else     if (m->at(i+1) /= n->at(i+1)) then (     ans := ans + StringLib.newString(1) ) else (     ans := ans + StringLib.newString(0) ) ;  )  ;     i := i + 1 ) ; 
    out.print(ans+"") ; 
    out.close() ; 
 )   catch (e : ProgramException) do (     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Codesolver {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String st1,st2 ;
    st1=sc.nextLine();
    st2=sc.nextLine();
    String str="" ;
    for(int i=0 ; i<st1.length(); i++){
      if(st1.charAt(i)==st2.charAt(i)){
        str=str+"0" ;
      }
      else {
        str=str+"1" ;
      }
    }
    System.out.println(str);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codesolver {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var st1 : String ;
    var st2 : String ;
    st1 := sc.nextLine() ; 
    st2 := sc.nextLine() ; 
    var str : String ; str := "" ;
        var i : int ; i := 0 ; while i < st1->size() do ( (     if (st1->at(i+1) = st2->at(i+1)) then (     str := str + "0" ) else (     str := str + "1" ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(str) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n ;
    while((n=sc.nextInt())!=0){
      LinkedList<Integer>list=new LinkedList<Integer>();
      int Sum=0 ;
      for(int i=0 ; i<n ; i++){
        list.add(sc.nextInt());
        Sum+=list.getLast();
      }
      Sum-=Collections.max(list);
      Sum-=Collections.min(list);
      int t=Sum/(list.size()-2);
      pw.printf("%d\n",t);
    }
    pw.close();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ;
        n := sc.getCurrent()->toInteger() ;
    while ((n) /= 0) do (    skip ; (     var list : Sequence(int) ; list := Sequence{} ;
     var Sum : int ; Sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(sc.getCurrent()->toInteger()) ; 
     Sum := Sum+(list->last()) )  ;     i := i + 1 ) ; 
    Sum := Sum-( list->max()) ; 
    Sum := Sum-(list->min()) ; 
    var t : int ; t := Sum / (list->size() - 2) ;
    skip ; 
 ) ;     n := sc.getCurrent()->toInteger() ;
 ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int GCD(int a,int b){
    if(b==0)return a ;
    return GCD(b,a % b);
  }
  static void FillPrefixSuffix(int prefix[],int arr[],int suffix[],int n){
    prefix[0]=arr[0];
    for(int i=1 ; i<n ; i++)prefix[i]=GCD(prefix[i-1],arr[i]);
    suffix[n-1]=arr[n-1];
    for(int i=n-2 ; i>=0 ; i--)suffix[i]=GCD(suffix[i+1],arr[i]);
  }
  static int GCDoutsideRange(int l,int r,int prefix[],int suffix[],int n){
    if(l==0)return suffix[r+1];
    if(r==n-1)return prefix[l-1];
    return GCD(prefix[l-1],suffix[r+1]);
  }
  public static void main(String[] args){
    int arr[]={
      2,6,9 };
      int n=arr.length ;
      int prefix[]=new int[n];
      int suffix[]=new int[n];
      FillPrefixSuffix(prefix,arr,suffix,n);
      int l=0,r=0 ;
      System.out.println(GCDoutsideRange(l,r,prefix,suffix,n));
      l=1 ;
      r=1 ;
      System.out.println(GCDoutsideRange(l,r,prefix,suffix,n));
      l=1 ;
      r=2 ;
      System.out.println(GCDoutsideRange(l,r,prefix,suffix,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation GCD( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return GCD(b, a mod b) );
  static   operation FillPrefixSuffix( prefix : Sequence(int), arr : Sequence(int), suffix : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     prefix[0+1] := arr[0+1] ; 
         var i : int ; i := 1 ; while i < n do (     prefix[i+1] := GCD(prefix[i - 1+1], arr[i+1]) ;  ;     i := i + 1 ) ; 
     suffix[n - 1+1] := arr[n - 1+1] ; 
         var i : int ; i := n - 2 ; while i >= 0 do (     suffix[i+1] := GCD(suffix[i + 1+1], arr[i+1]) ;  ;     i := i - 1 ) );
  static   operation GCDoutsideRange( l : int, r : int, prefix : Sequence(int), suffix : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (l = 0) then     return suffix[r + 1+1] else skip ; 
     if (r = n - 1) then     return prefix[l - 1+1] else skip ; 
     return GCD(prefix[l - 1+1], suffix[r + 1+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,6,9} ;
     var n : int ; n := arr->size() ;
    var prefix : Sequence(int) ; prefix := Integer.subrange(1,n)->collect(0) ;
    var suffix : Sequence(int) ; suffix := Integer.subrange(1,n)->collect(0) ;
    execute FillPrefixSuffix(prefix, arr, suffix, n) ; 
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    OclFile["System.out"].println(GCDoutsideRange(l, r, prefix, suffix, n)) ; 
    l := 1 ; 
    r := 1 ; 
    OclFile["System.out"].println(GCDoutsideRange(l, r, prefix, suffix, n)) ; 
    l := 1 ; 
    r := 2 ; 
    OclFile["System.out"].println(GCDoutsideRange(l, r, prefix, suffix, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int number=sc.nextInt(),target=sc.nextInt();
    Integer[] arr=new Integer[number];
    for(int i=0 ; i<number ; i++){
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr,(a,b)->b-a);
    int flag=0 ;
    for(Integer integer : arr){
      target-=integer ;
      flag++;
      if(target<=0){
        System.out.println(flag);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := sc.getCurrent()->toInteger() ;
    var target : int ; target := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,number)->collect(null) ;
        var i : int ; i := 0 ; while i < number do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := OclComparator.sortWith(arr, lambda (a , b) : OclAny in b - a) ; 
    var flag : int ; flag := 0 ;
    for (integer : arr) do ( (     target := target-(integer) ; 
     flag := flag + 1 ; 
     if (target <= 0) then (     OclFile["System.out"].println(flag) ; 
     return ) else skip )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
public class P609A {
  public static void main(String[] args)throws IOException {
    BufferedReader io=new BufferedReader(new InputStreamReader(System.in));
    Integer n=Integer.valueOf(io.readLine());
    Integer m=Integer.valueOf(io.readLine());
    Integer rs=0 ;
    List<Integer>vols=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      Integer tmp=Integer.valueOf(io.readLine());
      if(m<=tmp){
        rs=1 ;
      }
      vols.add(tmp);
    }
    if(rs==1){
      System.out.println(rs);
    }
    else {
      Collections.sort(vols);
      for(int i=vols.size()-1 ; i>=0 ; i--){
        Integer tmp=vols.get(i);
        if(m>tmp){
          rs++;
          m=m-tmp ;
        }
        else {
          rs++;
          break ;
        }
      }
      System.out.println(rs);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P609A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (io.readLine())->toInteger() ;
    var m : int ; m := (io.readLine())->toInteger() ;
    var rs : int ; rs := 0 ;
    var vols : Sequence(int) ; vols := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var tmp : int ; tmp := (io.readLine())->toInteger() ;
     if (m <= tmp) then (     rs := 1 ) else skip ; 
     vols := vols->including(tmp) )  ;     i := i + 1 ) ; 
    if (rs = 1) then (     OclFile["System.out"].println(rs) ) else (     vols := vols->sort() ; 
         var i : int ; i := vols->size() - 1 ; while i >= 0 do ( (     var tmp : int ; tmp := vols->at(i+1) ;
     if (m > tmp) then (     rs := rs + 1 ; 
     m := m - tmp ) else (     rs := rs + 1 ; 
     break ) )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println(rs) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class FlashDrives {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),i ;
    long m=in.nextLong(),s=0,d=0 ;
    int[] a=new int[n];
    for(i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    in.close();
    Arrays.sort(a);
    for(i=n-1 ; i>=0 ; i--){
      s+=a[i];
      d++;
      if(s>=m){
        break ;
      }
    }
    System.out.println(d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class FlashDrives {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var i : int ;
    var m : long ; m := in.getCurrent()->toLong() ;
    var s : long ; s := 0 ;
    var d : long ; d := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    a := a->sort() ; 
        i := n - 1 ; while i >= 0 do ( (     s := s+(a[i+1]) ; 
     d := d + 1 ; 
     if (s >= m) then (     break ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(d) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class MaximumOfMaximumsOfMinimums {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),k=in.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=in.nextLong();
    pw.println(solve(n,a,k));
    pw.close();
  }
  static long solve(int n,long[] a,int k){
    if(k==1){
      long res=Long.MAX_VALUE ;
      for(long x : a)res=Math.min(x,res);
      return res ;
    }
    if(k==2){
      if(n==1)return a[0];
      ArrayDeque<Long>dq=new ArrayDeque<>();
      for(long x : a)dq.add(x);
      long lMin=Long.MAX_VALUE,rMin=Long.MAX_VALUE ;
      long ans=a[0];
      while(! dq.isEmpty()){
        lMin=Math.min(dq.pollFirst(),lMin);
        if(rMin==Long.MAX_VALUE && dq.isEmpty()){
          rMin=Long.MIN_VALUE ;
          break ;
        }
        if(dq.isEmpty())break ;
        rMin=Long.min(dq.getLast(),rMin);
        ans=Math.max(ans,Math.max(rMin,lMin));
      }
      ans=Math.max(ans,Math.max(rMin,lMin));
      return ans ;
    }
    long ans=Long.MIN_VALUE ;
    for(long x : a)ans=Math.max(ans,x);
    return ans ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class MaximumOfMaximumsOfMinimums {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( n : int, a : Sequence(long), k : int) : long
  pre: true
  post: true
  activity: (     if (k = 1) then (     var res : long ; res := "9223372036854775807"->toLong() ;
     for (x : a) do (     res := Set{x, res}->min() ;  ) ; 
     return res ) else skip ; 
     if (k = 2) then (     if (n = 1) then     return a[0+1] else skip ; 
     var dq : Sequence(long) ; dq := ArrayDeque<OclAny>.newArrayDeque() ;
    for (x : a) do (     dq := dq->including(x) ;  ) ; 
    var lMin : long ; lMin := "9223372036854775807"->toLong() ;
    var rMin : long ; rMin := "9223372036854775807"->toLong() ;
    var ans : long ; ans := a[0+1] ;
    while (not(dq->isEmpty())) do (     lMin := Set{dq->first(), lMin}->min() ; 
     if (rMin = "9223372036854775807"->toLong() & dq->isEmpty()) then (     rMin := "-9223372036854775808"->toLong() ; 
     break ) else skip ; 
    if (dq->isEmpty()) then     break else skip ; 
    rMin := Set{dq->last(), rMin}->min() ; 
    ans := Set{ans, Set{rMin, lMin}->max()}->max() ; 
 ) ; 
    ans := Set{ans, Set{rMin, lMin}->max()}->max() ; 
    return ans 
 ) else skip ; 
    var ans : long ; ans := "-9223372036854775808"->toLong() ;
    for (x : a) do (     ans := Set{ans, x}->max() ;  ) ; 
    return ans 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Comparator ;
public class USBFlashDrives {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int m=Integer.parseInt(br.readLine());
    Integer[] arr=new Integer[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(br.readLine());
    }
    Arrays.sort(arr,Comparator.reverseOrder());
    int count=0 ;
    while(m>0){
      m-=arr[count];
      count++;
    }
    System.out.print(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class USBFlashDrives {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var m : int ; m := (br.readLine())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    arr := OclComparator.sortWith(arr, Comparator.reverseOrder()) ; 
    var count : int ; count := 0 ;
    while (m > 0) do (     m := m-(arr[count+1]) ; 
     count := count + 1 ) ; 
    OclFile["System.out"].print(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean canBecomeEmpty(String str,String sub_str){
    while(str.length()>0){
      int idx=str.indexOf(sub_str);
      if(idx==-1){
        break ;
      }
      str=str.replaceFirst(sub_str,"");
    }
    return(str.length()==0);
  }
  public static void main(String[] args){
    String str="GEEGEEKSKS",sub_str="GEEKS" ;
    if(canBecomeEmpty(str,sub_str)){
      System.out.print("\nYes");
    }
    else {
      System.out.print("\nNo");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation canBecomeEmpty( str : String, sub_str : String) : boolean
  pre: true
  post: true
  activity: (     while (str->size() > 0) do (     var idx : int ; idx := str->indexOf(sub_str)-1 ;
     if (idx = -1) then (     break ) else skip ; 
     str := str.replaceFirstMatch(sub_str, "") ) ; 
     return (str->size() = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GEEGEEKSKS" ;
    var sub_str : String ; sub_str := "GEEKS" ;
     if (canBecomeEmpty(str, sub_str)) then (     OclFile["System.out"].print("\nYes") ) else (     OclFile["System.out"].print("\nNo") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void removeChar(String s,char c){
    int j,count=0,n=s.length();
    char[] t=s.toCharArray();
    for(int i=j=0 ; i<n ; i++){
      if(t[i]!=c)t[j++]=t[i];
      else count++;
    }
    while(count>0){
      t[j++]='\0' ;
      count--;
    }
    System.out.println(t);
  }
  public static void main(String[] args){
    String s="geeksforgeeks" ;
    removeChar(s,'g');
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation removeChar( s : String, c : String) : void
  pre: true
  post: true
  activity: (     var j : int ;
    var count : int ; count := 0 ;
    var n : int ; n := s->size() ;
     var t : Sequence(String) ; t := s->characters() ;
        var i : int ;     j := 0 ;
i := j ; while i < n do ( (     if (t[i+1] /= c) then      t[j+1] := t[i+1]  ; j := j + 1 ; else     count := count + 1 ; )  ;     i := i + 1 ) ; 
    while (count > 0) do (      t[j+1] := '\0'  ; j := j + 1 ; 
     count := count - 1 ) ; 
    OclFile["System.out"].println(t) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     execute removeChar(s, 'g') );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.util.ArrayList ;
import java.util.Deque ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
public class A1179 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    StringBuilder out=new StringBuilder();
    int N=in.nextInt();
    int Q=in.nextInt();
    Deque<Integer>deque=new LinkedList<>();
    int max=Integer.MIN_VALUE ;
    for(int n=0 ; n<N ; n++){
      int a=in.nextInt();
      max=Math.max(max,a);
      deque.addLast(a);
    }
    List<Point>list=new ArrayList<>();
    while(deque.peekFirst()!=max){
      int a=deque.pollFirst();
      int b=deque.pollFirst();
      list.add(new Point(a,b));
      if(a>b){
        deque.addFirst(a);
        deque.addLast(b);
      }
      else {
        deque.addFirst(b);
        deque.addLast(a);
      }
    }
    int[] cycle=new int[N-1];
    deque.pollFirst();
    for(int n=0 ; n<N-1 ; n++){
      cycle[n]=deque.pollFirst();
    }
    for(int q=0 ; q<Q ; q++){
      long M=in.nextLong()-1 ;
      if(M<list.size()){
        Point p=list.get((int)M);
        out.append(p.x).append(' ').append(p.y).append('\n');
      }
      else {
        M-=list.size();
        M %=cycle.length ;
        out.append(max).append(' ').append(cycle[(int)M]).append('\n');
      }
    }
    System.out.print(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1179 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : String ; out := StringLib.newString() ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var Q : int ; Q := in.getCurrent()->toInteger() ;
    var deque : Sequence(int) ; deque := Sequence{} ;
    var max : int ; max := -2147483648 ;
        var n : int ; n := 0 ; while n < N do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     max := Set{max, a}->max() ; 
     deque := deque->append(a) )  ;     n := n + 1 ) ; 
    var list : Sequence(Point) ; list := Sequence{} ;
    while (deque.peekFirst() /= max) do (     var a : int ; a := deque->first() ;
     var b : int ; b := deque->first() ;
     list := list->including(Point.newPoint(a, b)) ; 
     if (a > b) then (     deque := deque->prepend(a) ; 
     deque := deque->append(b) ) else (     deque := deque->prepend(b) ; 
     deque := deque->append(a) ) ) ; 
    var cycle : Sequence(int) ; cycle := Integer.subrange(1,(N)->char2byte() - 1)->collect(0) ;
    deque := deque->tail() ; 
        var n : int ; n := 0 ; while n < (N)->char2byte() - 1 do ( (     cycle[n+1] := deque->first() ;     deque := deque->tail() )  ;     n := n + 1 ) ; 
        var q : int ; q := 0 ; while q < Q do ( (     var M : long ; M := in.getCurrent()->toLong() - 1 ;
     if (M < list->size()) then (     var p : Point ; p := list->at(M->oclAsType(int)+1) ;
     out := out + StringLib.newString(p.x) + StringLib.newString(' ') + StringLib.newString(p.y) + StringLib.newString('
') ) else (     M := M-(list->size()) ; 
     M := M mod cycle->size() ; 
     out := out + StringLib.newString(max) + StringLib.newString(' ') + StringLib.newString(cycle[M->oclAsType(int)+1]) + StringLib.newString('
') ) )  ;     q := q + 1 ) ; 
    OclFile["System.out"].print(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.io.*;
class GFG {
  static int MinOperation(int a[],int b[],int n){
    Arrays.sort(a);
    Arrays.sort(b);
    int result=0 ;
    for(int i=0 ; i<n ; ++i){
      if(a[i]>b[i])result=result+Math.abs(a[i]-b[i]);
      else if(a[i]<b[i])result=result+Math.abs(a[i]-b[i]);
    }
    return result ;
  }
  public static void main(String[] args){
    int a[]={
      3,1,1 };
      int b[]={
        1,2,2 };
        int n=a.length ;
        System.out.println(MinOperation(a,b,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MinOperation( a : Sequence(int), b : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     b := b->sort() ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] > b[i+1]) then     result := result + if a[i+1] - b[i+1] < 0 then -(a[i+1] - b[i+1]) else a[i+1] - b[i+1] endif ; else     if (a[i+1] < b[i+1]) then     result := result + if a[i+1] - b[i+1] < 0 then -(a[i+1] - b[i+1]) else a[i+1] - b[i+1] endif ; else skip ; )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{3,1,1} ;
     var b : Sequence(int) ; b := Sequence{1,2,2} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(MinOperation(a, b, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static final int TEN=10 ;
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int k=scanner.nextInt();
      long a=0,b=1 ;
      for(int i=0 ; i<k ; i++){
        if(((9==(a/b)% TEN))&&(f(a+b)>f(a+TEN*b))){
          b*=TEN ;
        }
        a+=b ;
        System.out.println(a);
      }
    }
  }
  private static double f(long n){
    long sum=0,now=n ;
    while(now>0){
      sum+=now % TEN ;
      now/=TEN ;
    }
    return((double)n)/sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute TEN : int := 10;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var k : int ; k := scanner.getCurrent()->toInteger() ;
     var a : long ; a := 0 ;
    var b : long ; b := 1 ;
         var i : int ; i := 0 ; while i < k do ( (     if (((9 = (a / b) mod TEN)) & (f(a + b) > f(a + TEN * b))) then (     b := b*(TEN) ) else skip ; 
     a := a+(b) ; 
     OclFile["System.out"].println(a) )  ;     i := i + 1 ) ))  );
  static   operation f( n : long) : double
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
    var now : long ; now := n ;
     while (now > 0) do (     sum := sum+(now mod TEN) ; 
     now := now/(TEN) ) ; 
     return (n->oclAsType(double)) / sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static InputStreamReader isr ;
  static BufferedReader br ;
  public static void main(String args[])throws IOException {
    isr=new InputStreamReader(System.in);
    br=new BufferedReader(isr);
    int c ;
    while((c=getint())!=-1){
      if(c!=0){
        int[] arr=getData(c);
        Arrays.sort(arr);
        System.out.println(averageP(arr));
      }
      else {
        break ;
      }
    }
  }
  static int getint(){
    try {
      int n=0 ;
      String buf=br.readLine();
      n=Integer.parseInt(buf);
      return n ;
    }
    catch(Exception e){
      return-1 ;
    }
  }
  static int[] getData(int n){
    try {
      int[] r=new int[n];
      for(int i=0 ; i<n ; i++){
        r[i]=Integer.parseInt(br.readLine());
      }
      return r ;
    }
    catch(Exception e){
      System.err.println("List Length Error");
      return new int[] {
      };
    }
  }
  static int averageP(int[] r){
    if(r.length>2){
      int sum=0 ;
      for(int i=1 ; i<(r.length-1); i++){
        sum+=r[i];
      }
      sum=sum/(r.length-2);
      return sum ;
    }
    else {
      return 0 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute isr : OclFile;
  static   attribute br : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     isr := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     br := OclFile.newOclFile_Read(isr) ; 
     var c : int ;
         c := getint() ;
    while ((c) /= -1) do (    skip ; (     if (c /= 0) then (     var arr : Sequence(int) ; arr := getData(c) ;
     arr := arr->sort() ; 
     OclFile["System.out"].println(averageP(arr)) ) else (     break ) ) ;     c := getint() ;
 ) );
  static   operation getint() : int
  pre: true
  post: true
  activity: (     try (     var n : int ; n := 0 ;
     var buf : String ; buf := br.readLine() ;
     n := (buf)->toInteger() ; 
     return n )   catch (e : ProgramException) do (     return -1 )
 );
  static   operation getData( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     try (     var r : Sequence(int) ; r := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     r[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
     return r )   catch (e : ProgramException) do (     OclFile["System.err"].println("List Length Error") ; 
     return Sequence{} )
 );
  static   operation averageP( r : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (r->size() > 2) then (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i < (r->size() - 1) do ( (     sum := sum+(r[i+1]) )  ;     i := i + 1 ) ; 
     sum := sum / (r->size() - 2) ; 
     return sum ) else (     return 0 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
import java.io.*;
public class Main {
  static BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  private static final int HUNDRED=100 ;
  public static void main(String[] args)throws IOException {
    String s=in.readLine();
    long n=Long.parseLong(s);
    long k=0,kk=1 ;
    for(int i=0 ; i<n ; i++){
      if((k/kk)% 10==9 && f(k+kk)>f(k+10*kk))kk*=10 ;
      k+=kk ;
      out.append(k+"\n");
    }
    out.flush();
    in.close();
    out.close();
  }
  private static double f(long num){
    long copy=num ;
    long sum=0 ;
    while(copy>0){
      sum+=copy % 10 ;
      copy/=10 ;
    }
    return(double)num/sum ;
  }
  private static int modulo(int S,int N){
    return((S)&(N-1));
  }
  private static int isPowerOfTwo(int S){
    return(S &(S-1))==0 ? 1 : 0 ;
  }
  private static int[] readInts()throws IOException {
    return Stream.of(in.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
  }
  private static int readInt()throws IOException {
    return Integer.parseInt(in.readLine());
  }
  private static long[] readLongs()throws IOException {
    return Stream.of(in.readLine().split(" ")).mapToLong(Long :: parseLong).toArray();
  }
  private static long readLong()throws IOException {
    return Long.parseLong(in.readLine());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])));
  static    attribute HUNDRED : int := 100;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.readLine() ;
     var n : long ; n := (s)->toLong() ;
    var k : long ; k := 0 ;
    var kk : long ; kk := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if ((k / kk) mod 10 = 9 & f(k + kk) > f(k + 10 * kk)) then     kk := kk*(10) ; else skip ; 
     k := k+(kk) ; 
     skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation f( num : long) : double
  pre: true
  post: true
  activity: (     var copy : long ; copy := num ;
     var sum : long ; sum := 0 ;
     while (copy > 0) do (     sum := sum+(copy mod 10) ; 
     copy := copy/(10) ) ; 
     return num->oclAsType(double) / sum );
  static   operation modulo( S : int, N : int) : int
  pre: true
  post: true
  activity: (     return ((S) & (N - 1)) );
  static   operation isPowerOfTwo( S : int) : int
  pre: true
  post: true
  activity: (     return if (S & (S - 1)) = 0 then 1 else 0 endif );
  static   operation readInts() : Sequence(int)
  pre: true
  post: true
  activity: (     return Sequence{in.readLine()->split(" ")}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() );
  static   operation readInt() : int
  pre: true
  post: true
  activity: (     return (in.readLine())->toInteger() );
  static   operation readLongs() : Sequence(long)
  pre: true
  post: true
  activity: (     return Sequence{in.readLine()->split(" ")}->collect( _x1 | (lambda _s : String in _s->toLong())->apply(_x1) )->asSequence() );
  static   operation readLong() : long
  pre: true
  post: true
  activity: (     return (in.readLine())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    long K=sc.nextLong();
    long ans=0 ;
    long add=1 ;
    PrintWriter pw=new PrintWriter(System.out);
    int cnt=0 ;
    while(cnt++<K){
      if((ans+add)*S(ans+add*10)>(ans+add*10)*S(ans+add))add=add*10 ;
      ans+=add ;
      pw.println(ans);
    }
    pw.close();
  }
  long S(long a){
    long ret=0 ;
    while(a>0){
      ret+=a % 10 ;
      a/=10 ;
    }
    return ret ;
  }
  static void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var K : long ; K := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
    var add : long ; add := 1 ;
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var cnt : int ; cnt := 0 ;
        while (cnt < K) do (        cnt := cnt + 1 ;     skip ; (     if ((ans + add) * S(ans + add * 10) > (ans + add * 10) * S(ans + add)) then     add := add * 10 ; else skip ; 
     ans := ans+(add) ; 
     skip ) ;  ) ;  
    skip ; 
 );
   operation S( a : long) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := 0 ;
     while (a > 0) do (     ret := ret+(a mod 10) ; 
     a := a/(10) ) ; 
     return ret );
  static   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedHashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long K=sc.nextLong();
    Set<Long>sunekeSet=new LinkedHashSet<>();
    for(long m=1 ; m<=10e15 ; m*=10){
      boolean sunukeCheckFlag=true ;
      for(int i=1 ; sunukeCheckFlag ; i++){
        long x=i*m+m-1 ;
        long y=(i+1)*m+m-1 ;
        if(x*Sn(y)<=y*Sn(x)){
          sunekeSet.add(x);
          if(K==sunekeSet.size()){
            sunekeSet.stream().forEach(System.out :: println);
            return ;
          }
        }
        else {
          sunukeCheckFlag=false ;
        }
      }
    }
  }
  public static long Sn(long num){
    long Sn=0 ;
    while(num!=0){
      Sn+=num % 10 ;
      num/=10 ;
    }
    return Sn ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var K : long ; K := sc.getCurrent()->toLong() ;
     var sunekeSet : Set(long) ; sunekeSet := Set{} ;
         var m : long ; m := 1 ; while m <= 10e15 do ( (     var sunukeCheckFlag : boolean ; sunukeCheckFlag := true ;
         var i : int ; i := 1 ; while sunukeCheckFlag do ( (     var x : long ; x := i * m + m - 1 ;
     var y : long ; y := (i + 1) * m + m - 1 ;
     if (x * Sn(y) <= y * Sn(x)) then (     sunekeSet := sunekeSet->including(x) ; 
     if (K = sunekeSet->size()) then (     for _forEach : sunekeSet do
    (    skip ;) ; 
     return ) else skip ) else (     sunukeCheckFlag := false ) )  ;     i := i + 1 ) )  ;     m := m*(10) ) );
  static   operation Sn( num : long) : long
  pre: true
  post: true
  activity: (     var Sn : long ; Sn := 0 ;
     while (num /= 0) do (     Sn := Sn+(num mod 10) ; 
     num := num/(10) ) ; 
     return Sn );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
  void run(){
    int n=sc.nextInt();
    int k=sc.nextInt();
    char prev=' ' ;
    int init=0 ;
    for(char ch : sc.next().toCharArray()){
      if(ch==prev){
        init++;
      }
      prev=ch ;
    }
    System.out.println(Math.min(n-1,init+2*k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var prev : String ; prev := ' ' ;
    var init : int ; init := 0 ;
    for (ch : sc.getCurrent()->characters()) do ( (     if (ch = prev) then (     init := init + 1 ) else skip ; 
     prev := ch )  ) ; 
    OclFile["System.out"].println(Set{n - 1, init + 2 * k}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static double compute(long l){
    long sum=0 ;
    long t=l ;
    while(t>0){
      sum+=t % 10 ;
      t/=10 ;
    }
    return(double)l/sum ;
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int k=s.nextInt();
    long current=1 ;
    for(int i=0 ; i<k ; i++){
      double min=Double.MAX_VALUE ;
      long next=-1 ;
      String currentString=current+"" ;
      for(int j=0 ; j<currentString.length()+1 ; j++){
        String ender="" ;
        for(int m=0 ; m<j ; m++){
          ender+="9" ;
        }
        String temp=currentString.substring(0,currentString.length()-j)+ender ;
        long tempVal=new Long(temp);
        double ans=compute(tempVal);
        if(ans<min){
          min=ans ;
          next=tempVal ;
        }
      }
      System.out.println(next);
      current=next+1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation compute( l : long) : double
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     var t : long ; t := l ;
     while (t > 0) do (     sum := sum+(t mod 10) ; 
     t := t/(10) ) ; 
     return l->oclAsType(double) / sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := s.getCurrent()->toInteger() ;
     var current : long ; current := 1 ;
         var i : int ; i := 0 ; while i < k do ( (     var min : double ; min := (2 - 2->pow(-52))*(2->pow(1023)) ;
     var next : long ; next := -1 ;
    var currentString : String ; currentString := current + "" ;
        var j : int ; j := 0 ; while j < currentString->size() + 1 do ( (     var ender : String ; ender := "" ;
         var m : int ; m := 0 ; while m < j do ( (     ender := ender+("9") )  ;     m := m + 1 ) ; 
    var temp : String ; temp := currentString.subrange(0+1,currentString->size() - (j)->char2byte()) + ender ;
    var tempVal : long ; tempVal := ("" + (temp))->toLong() ;
    var ans : double ; ans := compute(tempVal) ;
    if (ans < min) then (     min := ans ; 
     next := tempVal ) else skip ; 
 )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(next) ; 
    current := next + 1 ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static int n,m ;
  static boolean vist[];
  static ArrayList<Integer>ar[];
  static int max(int n){
    vist[n]=true ;
    int c=1 ;
    for(int i=0 ; i<ar[n] .size(); i++)if(! vist[ar[n] .get(i)])c+=max(ar[n] .get(i));
    return c ;
  }
  public static void main(String...args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    m=sc.nextInt();
    ar=new ArrayList[n+1];
    for(int i=1 ; i<=n ; i++)ar[i]=new ArrayList();
    for(int i=1 ; i<=m ; i++){
      int s=sc.nextInt(),d=sc.nextInt();
      ar[s] .add(d);
      ar[d] .add(s);
    }
    vist=new boolean[n+1];
    long max=1 ;
    for(int i=1 ; i<=n ; i++)if(! vist[i])max*=(Math.pow(2,max(i)-1));
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute vist : Sequence(boolean);
  static   attribute ar : Sequence(Sequence(int));
  static   operation max( n : int) : int
  pre: true
  post: true
  activity: (     vist[n+1] := true ; 
     var c : int ; c := 1 ;
         var i : int ; i := 0 ; while i < ar[n+1]->size() do (     if (not(vist[ar[n+1]->at(i+1)+1])) then     c := c+(Set{ar[n+1]->at(i+1)}->max()) ; else skip ;  ;     i := i + 1 ) ; 
     return c );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
    ar := Integer.subrange(1,n + 1)->collect(null) ; 
        var i : int ; i := 1 ; while i <= n do (     ar[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= m do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
     ar[s+1]->excludes(d) ; 
     ar[d+1]->excludes(s) )  ;     i := i + 1 ) ; 
    vist := Integer.subrange(1,n + 1)->collect(false) ; 
    var max : long ; max := 1 ;
        var i : int ; i := 1 ; while i <= n do (     if (not(vist[i+1])) then     max := max*((2->pow(max(i) - 1))) ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printGreater(int x,int y){
    double X=y*Math.log(x);
    double Y=x*Math.log(y);
    if(Math.abs(X-Y)<1e-9){
      System.out.println("Equal");
    }
    else if(X>Y){
      System.out.println(x+"^"+y);
    }
    else {
      System.out.println(y+"^"+x);
    }
  }
  public static void main(String[] args){
    int x=5,y=8 ;
    printGreater(x,y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printGreater( x : int, y : int) : void
  pre: true
  post: true
  activity: (     var X : double ; X := y * (x)->log() ;
     var Y : double ; Y := x * (y)->log() ;
     if (if X - Y < 0 then -(X - Y) else X - Y endif < 1e-9) then (     OclFile["System.out"].println("Equal") ) else     if (X > Y) then (     OclFile["System.out"].println(x + "^" + y) ) else (     OclFile["System.out"].println(y + "^" + x) ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 5 ;
    var y : int ; y := 8 ;
     execute printGreater(x, y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p044 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p044().run());
  }
  public String run(){
    long minD=-1 ;
    for(int i=2 ; ; i++){
      long pentI=pentagonalNumber(i);
      if(minD!=-1 && pentI-pentagonalNumber(i-1)>=minD)break ;
      for(int j=i-1 ; j>=1 ; j--){
        long pentJ=pentagonalNumber(j);
        long diff=pentI-pentJ ;
        if(minD!=-1 && diff>=minD)break ;
        else if(isPentagonalNumber(pentI+pentJ)&& isPentagonalNumber(diff))minD=diff ;
      }
    }
    return Long.toString(minD);
  }
  private static long pentagonalNumber(int x){
    if(x<=0)throw new IllegalArgumentException();
    return(long)x*(x*3-1)>>>1 ;
  }
  private static boolean isPentagonalNumber(long y){
    if(y<=0)return false ;
    long temp=y*24+1 ;
    long sqrt=Library.sqrt(temp);
    return sqrt*sqrt==temp && sqrt % 6==5 ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p044 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p044.newp044().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var minD : long ; minD := -1 ;
         var i : int ; i := 2 ; while true do ( (     var pentI : long ; pentI := pentagonalNumber(i) ;
     if (minD /= -1 & pentI - pentagonalNumber(i - 1) >= minD) then     break else skip ; 
         var j : int ; j := i - 1 ; while j >= 1 do ( (     var pentJ : long ; pentJ := pentagonalNumber(j) ;
     var diff : long ; diff := pentI - pentJ ;
     if (minD /= -1 & diff >= minD) then     break else     if (isPentagonalNumber(pentI + pentJ) & isPentagonalNumber(diff)) then     minD := diff ; else skip ; )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
     return ((minD) + "") );
  static   operation pentagonalNumber( x : int) : long
  pre: true
  post: true
  activity: (     if (x <= 0) then     error IllegalArgumentException.newIllegalArgumentException() ; else skip ; 
     return (x->oclAsType(long) * (x * 3 - 1)/(2->pow(1)))->oclAsType(long) );
  static   operation isPentagonalNumber( y : long) : boolean
  pre: true
  post: true
  activity: (     if (y <= 0) then     return false else skip ; 
     var temp : long ; temp := y * 24 + 1 ;
     var sqrt : long ; sqrt := Library.sqrt(temp) ;
     return sqrt * sqrt = temp & sqrt mod 6 = 5 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      if((long)Math.pow(3,n-1)>(long)Math.pow(10,9))System.out.println("NO");
      else {
        int k=1 ;
        System.out.println("YES");
        System.out.print(1+" ");
        for(int i=1 ; i<n ; i++){
          System.out.print(k*3+" ");
          k*=3 ;
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     if (3->pow(n - 1)->oclAsType(long) > 10->pow(9)->oclAsType(long)) then     OclFile["System.out"].println("NO") ; else (     var k : int ; k := 1 ;
     OclFile["System.out"].println("YES") ; 
    OclFile["System.out"].print(1 + " ") ; 
        var i : int ; i := 1 ; while i < n do ( (     OclFile["System.out"].print(k * 3 + " ") ; 
     k := k*(3) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t--!=0){
      int n=scanner.nextInt();
      if(n>19){
        System.out.println("NO");
        continue ;
      }
      System.out.println("YES");
      int v=1 ;
      for(int i=0 ; i<n ; i++){
        System.out.print(v+" ");
        v*=3 ;
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n > 19) then (     OclFile["System.out"].println("NO") ; 
     continue ) else skip ; 
    OclFile["System.out"].println("YES") ; 
    var v : int ; v := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(v + " ") ; 
     v := v*(3) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int K=in.nextInt();
    int a[]=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      a[i]=in.nextInt();
    }
    int tag[]=new int[K+1];
    int p1=0,p2=0 ;
    int min=n+1 ;
    int sum=0 ;
    while(p1<=n){
      if(sum==K){
        min=Math.min(min,p2-p1);
      }
      if(sum<K){
        p2++;
        if(p2>n)break ;
        if(a[p2]<=K){
          if(tag[a[p2] ]==0)sum++;
          tag[a[p2] ]++;
        }
      }
      else {
        p1++;
        if(p1>n)break ;
        if(a[p1]<=K){
          tag[a[p1] ]--;
          if(tag[a[p1] ]==0)sum--;
        }
      }
    }
    if(min==n+1)System.out.println(0);
    else System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var tag : Sequence(int) ; tag := Integer.subrange(1,K + 1)->collect(0) ;
    var p1 : int ; p1 := 0 ;
    var p2 : int ; p2 := 0 ;
    var min : int ; min := n + 1 ;
    var sum : int ; sum := 0 ;
    while (p1 <= n) do (     if (sum = K) then (     min := Set{min, p2 - p1}->min() ) else skip ; 
     if (sum < K) then (     p2 := p2 + 1 ; 
     if (p2 > n) then     break else skip ; 
     if (a[p2+1] <= K) then (     if (tag[a[p2+1]+1] = 0) then     sum := sum + 1 ; else skip ; 
     tag[a[p2+1]+1] := tag[a[p2+1]+1] + 1 ) else skip ) else (     p1 := p1 + 1 ; 
     if (p1 > n) then     break else skip ; 
     if (a[p1+1] <= K) then (     tag[a[p1+1]+1] := tag[a[p1+1]+1] - 1 ; 
     if (tag[a[p1+1]+1] = 0) then     sum := sum - 1 ; else skip ) else skip ) ) ; 
    if (min = n + 1) then     OclFile["System.out"].println(0) else     OclFile["System.out"].println(min) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.*;
public class App {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws Exception {
    if(System.getProperty("ONLINE_JUDGE")==null){
      File inputFile=new File("/Users/vipinjain/self/cp/input.txt");
      File outputFile=new File("/Users/vipinjain/self/cp/output.txt");
      br=new BufferedReader(new FileReader(inputFile));
      bw=new BufferedWriter(new FileWriter(outputFile));
    }
    int tests ;
    tests=Integer.parseInt(br.readLine());
    while(tests-->0){
      solve();
    }
    bw.flush();
    bw.close();
    br.close();
  }
  static void solve()throws Exception {
    int n=Integer.parseInt(br.readLine());
    if(n>19){
      bw.write("NO");
    }
    else {
      bw.write("YES\n");
      StringBuilder sb=new StringBuilder();
      for(int i=0 ; i<n ; ++i){
        int num=(int)(Math.pow(3,i));
        sb.append(num+" ");
      }
      bw.write(sb.toString().trim());
    }
    bw.write("\n");
  }
  static int gcd(int a,int b){
    if(a==0){
      return b ;
    }
    return gcd(b % a,a);
  }
  static boolean isPrime(long n){
    for(long i=2 ; i*i<=n ; i++){
      if(n % i==0){
        return false ;
      }
    }
    return true ;
  }
  static long minDivisor(long n){
    for(long i=2 ; i*i<=n ; ++i){
      if(n % i==0){
        return i ;
      }
    }
    return n ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null) then (     var inputFile : OclFile ; inputFile := OclFile("/Users/vipinjain/self/cp/input.txt") ;
     var outputFile : OclFile ; outputFile := OclFile("/Users/vipinjain/self/cp/output.txt") ;
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputFile)) ; 
     bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputFile)) ) else skip ; 
     var tests : int ;
    tests := (br.readLine())->toInteger() ; 
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     if (n > 19) then (     skip ) else (     skip ; 
     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := (3->pow(i))->oclAsType(int) ;
     sb := sb + StringLib.newString(num + " ") )  ;     i := i + 1 ) ; 
     skip ) ;  
     skip );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then (     return b ) else skip ; 
     return gcd(b mod a, a) );
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (         var i : long ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation minDivisor( n : long) : long
  pre: true
  post: true
  activity: (         var i : long ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     return i ) else skip )  ;     i := i + 1 ) ; 
     return n );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class amd {
  static int mod=1000000000 ;
  static int n ;
  static int m ;
  static int k ;
  static long a[];
  static long b[];
  public static void main(String[] args){
    FastScanner s=new FastScanner();
    int t=s.nextInt();
    int v=0 ;
    while(t-->0){
      n=s.nextInt();
      StringBuilder sb=new StringBuilder();
      sb.append(1+" ");
      long prev=1 ;
      boolean po=true ;
      for(int i=1 ; i<n ; i++){
        if(prev*3>mod){
          po=false ;
          break ;
        }
        sb.append((prev*3)+" ");
        prev=(prev*3);
      }
      if(po){
        System.out.println("YES");
        System.out.println(sb);
      }
      else {
        System.out.println("NO");
      }
    }
  }
  static void sort(int[] a){
    ArrayList<Integer>l=new ArrayList<>();
    for(int i : a)l.add(i);
    Collections.sort(l);
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class amd {
  static   attribute mod : int := 1000000000;
  static   attribute n : int;
  static   attribute m : int;
  static   attribute k : int;
  static   attribute a : Sequence(long);
  static   attribute b : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : FastScanner ; s := FastScanner.newFastScanner() ;
     var t : int ; t := s.nextInt() ;
     var v : int ; v := 0 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     n := s.nextInt() ; 
     var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString(1 + " ") ; 
    var prev : long ; prev := 1 ;
    var po : boolean ; po := true ;
        var i : int ; i := 1 ; while i < n do ( (     if (prev * 3 > mod) then (     po := false ; 
     break ) else skip ; 
     sb := sb + StringLib.newString((prev * 3) + " ") ; 
     prev := (prev * 3) )  ;     i := i + 1 ) ; 
    if (po) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(sb) ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l := l->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p045 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p045().run());
  }
  public String run(){
    int i=286 ;
    int j=166 ;
    int k=144 ;
    while(true){
      long triangle=(long)i*(i+1)/2 ;
      long pentagon=(long)j*(j*3-1)/2 ;
      long hexagon=(long)k*(k*2-1);
      long min=Math.min(Math.min(triangle,pentagon),hexagon);
      if(min==triangle && min==pentagon && min==hexagon)return Long.toString(min);
      if(min==triangle)i++;
      if(min==pentagon)j++;
      if(min==hexagon)k++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class p045 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p045.newp045().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var i : int ; i := 286 ;
     var j : int ; j := 166 ;
     var k : int ; k := 144 ;
     while (true) do (     var triangle : long ; triangle := i->oclAsType(long) * (i + 1) / 2 ;
     var pentagon : long ; pentagon := j->oclAsType(long) * (j * 3 - 1) / 2 ;
    var hexagon : long ; hexagon := k->oclAsType(long) * (k * 2 - 1) ;
    var min : long ; min := Set{Set{triangle, pentagon}->min(), hexagon}->min() ;
    if (min = triangle & min = pentagon & min = hexagon) then     return ((min) + "") else skip ; 
    if (min = triangle) then     i := i + 1 ; else skip ; 
    if (min = pentagon) then     j := j + 1 ; else skip ; 
    if (min = hexagon) then     k := k + 1 ; else skip ; 
 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Set ;
import java.util.*;
import java.util.Arrays ;
import java.lang.Math ;
import java.util.Collections ;
public class Log {
  class GIATRI {
    public int x=0 ;
    public int y=0 ;
  }
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int t=sc.nextInt();
    while(t>0){
      tinh();
      t=t-1 ;
    }
  }
  public static void tinh(){
    int n=sc.nextInt();
    int[] A=new int[n+1];
    if(n>19){
      System.out.println("NO");
    }
    else {
      A[1]=1 ;
      for(int i=2 ; i<=n ; i++){
        A[i]=A[i-1]*3 ;
      }
      System.out.println("YES");
      for(int i=1 ; i<=n ; i++){
        System.out.print(A[i]+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Log {
 class GIATRI {
   attribute x : int := 0;
   attribute y : int := 0;
}
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     execute tinh() ; 
     t := t - 1 ) );
  static   operation tinh() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var A : Sequence(int) ; A := Integer.subrange(1,n + 1)->collect(0) ;
     if (n > 19) then (     OclFile["System.out"].println("NO") ) else (     A[1+1] := 1 ; 
         var i : int ; i := 2 ; while i <= n do ( (     A[i+1] := A[i - 1+1] * 3 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
        var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].print(A[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static void printAllDivisors(int arr[],int N){
    int g=arr[0];
    HashSet<Integer>divisors=new HashSet<Integer>();
    for(int i=1 ; i<N ; i++){
      g=gcd(arr[i],g);
    }
    for(int i=1 ; i*i<=g ; i++){
      if(g % i==0){
        divisors.add(i);
        if(g/i!=i)divisors.add(g/i);
      }
    }
    for(int it : divisors)System.out.print(it+" ");
  }
  public static void main(String[] args){
    int arr[]={
      6,90,12,18,30,24 };
      int n=arr.length ;
      printAllDivisors(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation printAllDivisors( arr : Sequence(int), N : int) : void
  pre: true
  post: true
  activity: (     var g : int ; g := arr[0+1] ;
     var divisors : Set(int) ; divisors := Set{} ;
        var i : int ; i := 1 ; while i < N do ( (     g := gcd(arr[i+1], g) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i * i <= g do ( (     if (g mod i = 0) then (     divisors := divisors->including(i) ; 
     if (g / i /= i) then     divisors := divisors->including(g / i) ; else skip ) else skip )  ;     i := i + 1 ) ; 
    for (it : divisors) do (     OclFile["System.out"].print(it + " ") ;  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,90,12,18,30,24} ;
     var n : int ; n := arr->size() ;
     execute printAllDivisors(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int cal(int n){
    double res=Math.pow(Math.ceil((Math.pow(Math.pow(10,(n-1)),1/4))),4);
    return(int)res ;
  }
  public static void main(String[] args){
    int n=1 ;
    System.out.println(cal(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation cal( n : int) : int
  pre: true
  post: true
  activity: (     var res : double ; res := ((10->pow((n - 1))->pow(1 / 4)))->ceil()->pow(4) ;
     return res->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1 ;
     OclFile["System.out"].println(cal(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void result(int N){
    for(int num=0 ; num<N ; num++){
      if(num % 3==0 && num % 5==0)System.out.print(num+" ");
    }
  }
  public static void main(String[] args){
    int N=100 ;
    result(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation result( N : int) : void
  pre: true
  post: true
  activity: (         var num : int ; num := 0 ; while num < N do ( (     if (num mod 3 = 0 & num mod 5 = 0) then     OclFile["System.out"].print(num + " ") ; else skip )  ;     num := num + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 100 ;
     execute result(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String FirstAndLast(String str){
    char[] ch=str.toCharArray();
    for(int i=0 ; i<ch.length ; i++){
      int k=i ;
      while(i<ch.length && ch[i]!=' ')i++;
      ch[k]=(char)(ch[k]>='a' && ch[k]<='z' ?((int)ch[k]-32):(int)ch[k]);
      ch[i-1]=(char)(ch[i-1]>='a' && ch[i-1]<='z' ?((int)ch[i-1]-32):(int)ch[i-1]);
    }
    return new String(ch);
  }
  public static void main(String args[]){
    String str="Geeks for Geeks" ;
    System.out.println(str);
    System.out.println(FirstAndLast(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation FirstAndLast( str : String) : String
  pre: true
  post: true
  activity: (     var ch : Sequence(String) ; ch := str->characters() ;
         var i : int ; i := 0 ; while i < ch->size() do ( (     var k : int ; k := i ;
     while (i < ch->size() & ch[i+1] /= ' ') do     i := i + 1 ; ; 
     ch[k+1] := (if ch[k+1] >= 'a' & ch[k+1] <= 'z' then (ch[k+1]->oclAsType(int) - 32) else ch[k+1]->oclAsType(int) endif)->oclAsType(String) ; 
     ch[i - 1+1] := (if ch[i - 1+1] >= 'a' & ch[i - 1+1] <= 'z' then (ch[i - 1+1]->oclAsType(int) - 32) else ch[i - 1+1]->oclAsType(int) endif)->oclAsType(String) )  ;     i := i + 1 ) ; 
     return StringLib.newString(ch) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "Geeks for Geeks" ;
     OclFile["System.out"].println(str) ; 
     OclFile["System.out"].println(FirstAndLast(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int r=sc.nextInt();
    if(a<2*r || b<2*r)System.out.println("Second");
    else System.out.println("First");
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    if (a < 2 * r or b < 2 * r) then     OclFile["System.out"].println("Second") else     OclFile["System.out"].println("First") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class plate {
  public static void main(String[] args){
    FastScanner scan=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int a=scan.nextInt(),b=scan.nextInt(),d=scan.nextInt()*2 ;
    out.println(a<d || b<d ? "Second" : "First");
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new InputStreamReader(System.in));
        st=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
        e.printStackTrace();
      }
    }
    public String next(){
      if(st.hasMoreTokens())return st.nextToken();
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      String line="" ;
      if(st.hasMoreTokens())line=st.nextToken();
      else try {
        return br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      while(st.hasMoreTokens())line+=" "+st.nextToken();
      return line ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class plate {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : FastScanner ; scan := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : int ; a := scan.nextInt() ;
    var b : int ; b := scan.nextInt() ;
    var d : int ; d := scan.nextInt() * 2 ;
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     if (st.hasNext()) then     return st.next() else skip ; 
     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     e.printStackTrace() )
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var line : String ; line := "" ;
     if (st.hasNext()) then     line := st.next() else     try (     return br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
 ;  
     while (st.hasNext()) do     line := line+(" " + st.next()) ; ; 
     return line );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int product(int N){
    int ans=1 ;
    int val=(int)Math.pow(2,N-1);
    for(int i=1 ; i<=N ; i++){
      ans*=(int)Math.pow(i,val);
    }
    return ans ;
  }
  public static void main(String[] args){
    int N=2 ;
    System.out.println(product(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation product( N : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
     var val : int ; val := 2->pow(N - 1)->oclAsType(int) ;
         var i : int ; i := 1 ; while i <= N do ( (     ans := ans*(i->pow(val)->oclAsType(int)) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 2 ;
     OclFile["System.out"].println(product(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int K=scan.nextInt();
    int[] a=new int[N];
    Map<Integer,Integer>map=new HashMap<Integer,Integer>();
    for(int i=0 ; i<N ; i++){
      a[i]=scan.nextInt();
    }
    scan.close();
    int min=Integer.MAX_VALUE ;
    int right=0 ;
    for(int left=0 ; left<N ; left++){
      while(right<N && map.size()<K){
        if(a[right]<=K){
          map.merge(a[right],1,(val1,val2)->val1+val2);
        }
        right++;
      }
      if(map.size()==K){
        int l=right-left ;
        min=Math.min(min,l);
      }
      if(right==left){
        right++;
      }
      else {
        if(a[left]<=K){
          if(map.get(a[left])==1){
            map.remove(a[left]);
          }
          else {
            map.merge(a[left],-1,(val1,val2)->val1+val2);
          }
        }
      }
    }
    if(min==Integer.MAX_VALUE){
      System.out.println(0);
    }
    else {
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var K : int ; K := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var min : int ; min := 2147483647 ;
    var right : int ; right := 0 ;
        var left : int ; left := 0 ; while left < N do ( (     while (right < N & map.size() < K) do (     if (a[right+1] <= K) then (     map := map.merge(a[right+1], 1, lambda (val1 , val2) : OclAny in val1 + val2) ) else skip ; 
     right := right + 1 ) ; 
     if (map.size() = K) then (     var l : int ; l := right - left ;
     min := Set{min, l}->min() ) else skip ; 
     if (right = left) then (     right := right + 1 ) else (     if (a[left+1] <= K) then (     if (map->at(a[left+1]) = 1) then (     map := map->antirestrict(Set{a[left+1]}) ) else (     map := map.merge(a[left+1], -1, lambda (val1 , val2) : OclAny in val1 + val2) ) ) else skip ) )  ;     left := left + 1 ) ; 
    if (min = 2147483647) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(min) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static boolean checkIfUnequal(int n,int q){
    String s1=Integer.toString(n);
    int a[]=new int[26];
    for(int i=0 ; i<s1.length(); i++)a[s1.charAt(i)-'0']++;
    int prod=n*q ;
    String s2=Integer.toString(prod);
    for(int i=0 ; i<s2.length(); i++)if(a[s2.charAt(i)-'0']==1)return false ;
    return true ;
  }
  static int countInRange(int l,int r,int q){
    int count=0 ;
    for(int i=l ; i<=r ; i++){
      if(checkIfUnequal(i,q))count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int l=10,r=12,q=2 ;
    System.out.println(countInRange(l,r,q));
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation checkIfUnequal( n : int, q : int) : boolean
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := ((n) + "") ;
     var a : Sequence(int) ; a := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < s1->size() do (     a[s1->at(i+1) - ('0')->char2byte()+1] := a[s1->at(i+1) - ('0')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    var prod : int ; prod := n * q ;
    var s2 : String ; s2 := ((prod) + "") ;
        var i : int ; i := 0 ; while i < s2->size() do (     if (a[s2->at(i+1) - ('0')->char2byte()+1] = 1) then     return false else skip ;  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation countInRange( l : int, r : int, q : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := l ; while i <= r do ( (     if (checkIfUnequal(i, q)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 10 ;
    var r : int ; r := 12 ;
    var q : int ; q := 2 ;
     OclFile["System.out"].println(countInRange(l, r, q)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    BigInteger a=scan.nextBigInteger();
    BigInteger b=scan.nextBigInteger();
    System.out.println(a.multiply(b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := scan.nextBigInteger() ;
     var b : long ; b := scan.nextBigInteger() ;
     OclFile["System.out"].println(a.multiply(b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxPrimefactorNum(int N){
    if(N<2)return 0 ;
    boolean[] arr=new boolean[N+1];
    int prod=1,res=0 ;
    for(int p=2 ; p*p<=N ; p++){
      if(arr[p]==false){
        for(int i=p*2 ; i<=N ; i+=p)arr[i]=true ;
        prod*=p ;
        if(prod>N)return res ;
        res++;
      }
    }
    return res ;
  }
  public static void main(String[] args){
    int N=500 ;
    System.out.println(maxPrimefactorNum(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxPrimefactorNum( N : int) : int
  pre: true
  post: true
  activity: (     if (N < 2) then     return 0 else skip ; 
     var arr : Sequence(boolean) ; arr := Integer.subrange(1,N + 1)->collect(false) ;
    var prod : int ; prod := 1 ;
    var res : int ; res := 0 ;
        var p : int ; p := 2 ; while p * p <= N do ( (     if (arr[p+1] = false) then (         var i : int ; i := p * 2 ; while i <= N do (     arr[i+1] := true ;  ;     i := i+(p) ) ; 
     prod := prod*(p) ; 
     if (prod > N) then     return res else skip ; 
     res := res + 1 ) else skip )  ;     p := p + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 500 ;
     OclFile["System.out"].println(maxPrimefactorNum(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Sum {
  void sumOfPrevK(int N,int K){
    int arr[]=new int[N];
    int prevsum=0 ;
    arr[0]=1 ;
    for(int i=0 ; i<N-1 ; i++){
      if(i<=K){
        arr[i+1]=arr[i]+prevsum ;
        prevsum=arr[i+1];
      }
      else {
        arr[i+1]=arr[i]+prevsum-arr[i+1-K];
        prevsum=arr[i]+prevsum ;
      }
    }
    for(int i=0 ; i<N ; i++){
      System.out.print(arr[i]+" ");
    }
  }
  public static void main(String args[]){
    Sum s=new Sum();
    int N=8,K=3 ;
    s.sumOfPrevK(N,K);
  }
}
------------------------------------------------------------
OCL File:
---------
class Sum {
   operation sumOfPrevK( N : int, K : int) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
     var prevsum : int ; prevsum := 0 ;
    arr[0+1] := 1 ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     if (i <= K) then (     arr[i + 1+1] := arr[i+1] + prevsum ; 
     prevsum := arr[i + 1+1] ) else (     arr[i + 1+1] := arr[i+1] + prevsum - arr[i + 1 - K+1] ; 
     prevsum := arr[i+1] + prevsum ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Sum ; s := Sum.newSum() ;
     var N : int ; N := 8 ;
    var K : int ; K := 3 ;
     s.sumOfPrevK(N, K) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(final String[] args){
    try(final Scanner sc=new Scanner(System.in)){
      final int n=sc.nextInt();
      final int k=sc.nextInt();
      final String s=sc.next();
      List<Integer>nums=new ArrayList<Integer>();
      int now=1 ;
      int count=0 ;
      for(int i=0 ; i<n ; i++){
        if(s.charAt(i)==(char)('0'+now)){
          count+=1 ;
        }
        else {
          nums.add(count);
          now=1-now ;
          count=1 ;
        }
      }
      nums.add(count);
      if(nums.size()% 2==0){
        nums.add(0);
      }
      List<Integer>sums=new ArrayList<>(nums.size()+1);
      sums.add(0);
      for(int i=0 ; i<nums.size(); i++){
        sums.add(sums.get(i)+nums.get(i));
      }
      int ans=0 ;
      int add=2*k+1 ;
      for(int i=0 ; i<nums.size(); i+=2){
        int left=i ;
        int right=Math.min(left+add,nums.size());
        int temp=sums.get(right)-sums.get(left);
        ans=Math.max(ans,temp);
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile = OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var nums : Sequence(int) ; nums := Sequence{} ;
    var now : int ; now := 1 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = ('0' + now)->oclAsType(String)) then (     count := count+(1) ) else (     nums := nums->including(count) ; 
     now := 1 - now ; 
     count := 1 ) )  ;     i := i + 1 ) ; 
    nums := nums->including(count) ; 
    if (nums->size() mod 2 = 0) then (     nums := nums->including(0) ) else skip ; 
    var sums : Sequence(int) ; sums := Sequence{}->union(nums->size() + 1) ;
    sums := sums->including(0) ; 
        var i : int ; i := 0 ; while i < nums->size() do ( (     sums := sums->including(sums->at(i+1) + nums->at(i+1)) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var add : int ; add := 2 * k + 1 ;
        var i : int ; i := 0 ; while i < nums->size() do ( (     var left : int ; left := i ;
     var right : int ; right := Set{left + add, nums->size()}->min() ;
     var temp : int ; temp := sums->at(right+1) - sums->at(left+1) ;
     ans := Set{ans, temp}->max() )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(ans) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  private static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=Integer.parseInt(sc.next());
    int k=Integer.parseInt(sc.next());
    String s=sc.next();
    char[] si=s.toCharArray();
    char s0='0' ;
    char s1='1' ;
    ArrayList<Integer>numS=new ArrayList<Integer>();
    int now=1 ;
    int count=0 ;
    for(char curr : si){
      if(Character.getNumericValue(curr)==now){
        count++;
      }
      else {
        numS.add(count);
        now=1-now ;
        count=1 ;
      }
    }
    if(count!=0)numS.add(count);
    if(numS.size()% 2==0)numS.add(0);
    int add=2*k+1 ;
    int ans=0 ;
    int left=0 ;
    int right=0 ;
    int tmp=0 ;
    for(int nextleft=0 ; nextleft<numS.size(); nextleft+=2){
      int nextright=Math.min(nextleft+add,numS.size());
      while(nextleft>left){
        tmp-=numS.get(left);
        left++;
      }
      while(nextright>right){
        tmp+=numS.get(right);
        right++;
      }
      ans=Math.max(tmp,ans);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (sc.getCurrent())->toInteger() ;
     var k : int ; k := (sc.getCurrent())->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var si : Sequence(String) ; si := s->characters() ;
    var s0 : String ; s0 := '0' ;
    var s1 : String ; s1 := '1' ;
    var numS : Sequence(int) ; numS := Sequence{} ;
    var now : int ; now := 1 ;
    var count : int ; count := 0 ;
    for (curr : si) do ( (     if (("" + curr)->toInteger() = now) then (     count := count + 1 ) else (     numS := numS->including(count) ; 
     now := 1 - now ; 
     count := 1 ) )  ) ; 
    if (count /= 0) then     numS := numS->including(count) ; else skip ; 
    if (numS->size() mod 2 = 0) then     numS := numS->including(0) ; else skip ; 
    var add : int ; add := 2 * k + 1 ;
    var ans : int ; ans := 0 ;
    var left : int ; left := 0 ;
    var right : int ; right := 0 ;
    var tmp : int ; tmp := 0 ;
        var nextleft : int ; nextleft := 0 ; while nextleft < numS->size() do ( (     var nextright : int ; nextright := Set{nextleft + add, numS->size()}->min() ;
     while (nextleft > left) do (     tmp := tmp-(numS->at(left+1)) ; 
     left := left + 1 ) ; 
     while (nextright > right) do (     tmp := tmp+(numS->at(right+1)) ; 
     right := right + 1 ) ; 
     ans := Set{tmp, ans}->max() )  ;     nextleft := nextleft+(2) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int k=Integer.parseInt(sc.next());
    String s=sc.next();
    int l=0 ;
    int r=0 ;
    for(int i=0 ; i<k ; i++){
      r=s.indexOf("0",r);
      r=s.indexOf("10",r);
      if(r==-1){
        r=n-1 ;
        break ;
      }
    }
    int max=0 ;
    while(true){
      if(r-l+1>max){
        max=r-l+1 ;
      }
      if(r==n-1)break ;
      r=s.indexOf("0",r);
      r=s.indexOf("10",r);
      if(r==-1){
        r=n-1 ;
      }
      l=s.indexOf("01",l)+1 ;
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var k : int ; k := (sc.getCurrent())->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     r := s.subrange(r+1)->indexOf("0"+"") + r - 1  ; 
     r := s.subrange(r+1)->indexOf("10"+"") + r - 1  ; 
     if (r = -1) then (     r := n - 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    while (true) do (     if (r - (l)->char2byte() + 1 > max) then (     max := r - (l)->char2byte() + 1 ) else skip ; 
     if (r = n - 1) then     break else skip ; 
    r := s.subrange(r+1)->indexOf("0"+"") + r - 1  ; 
    r := s.subrange(r+1)->indexOf("10"+"") + r - 1  ; 
    if (r = -1) then (     r := n - 1 ) else skip ; 
    l := s.subrange(l+1)->indexOf("01"+"") + l - 1  + 1 ; 
 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] $){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt(),k=s.nextInt();
    char[] t=s.next().toCharArray();
    ArrayList<Integer>l=new ArrayList<>();
    if(t[0]=='0')l.add(0);
    {
      int c=1 ;
      for(int i=0 ; i<n ; ++i){
        if(i==n-1 || t[i+1]!=t[i]){
          l.add(c);
          c=1 ;
        }
        else++c ;
      }
    }
    if(t[n-1]=='0')l.add(0);
    if(k*2+1>=l.size()){
      System.out.println(t.length);
      return ;
    }
    int sum=0,r=0 ;
    for(int i=0 ; i<=(k-1)*2 ; ++i)sum+=l.get(i);
    for(int i=k*2 ; i<l.size(); i+=2){
      sum+=l.get(i);
      sum+=l.get(i-1);
      System.err.println(sum);
      r=Math.max(r,sum);
      sum-=l.get(i-k*2);
      sum-=l.get(i-k*2+1);
    }
    System.out.println(r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var k : int ; k := s.getCurrent()->toInteger() ;
    var t : Sequence(String) ; t := s.getCurrent()->characters() ;
    var l : Sequence(int) ; l := Sequence{} ;
    if (t[0+1] = '0') then     l := l->including(0) ; else skip ; 
(     var c : int ; c := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (i = n - 1 or t[i + 1+1] /= t[i+1]) then (     l := l->including(c) ; 
     c := 1 ) else     c := c + 1 ; )  ;     i := i + 1 ) ) 
    if (t[n - 1+1] = '0') then     l := l->including(0) ; else skip ; 
    if (k * 2 + 1 >= l->size()) then (     OclFile["System.out"].println(t->size()) ; 
     return ) else skip ; 
    var sum : int ; sum := 0 ;
    var r : int ; r := 0 ;
        var i : int ; i := 0 ; while i <= (k - 1) * 2 do (     sum := sum+(l->at(i+1)) ;  ;     i := i + 1 ) ; 
        var i : int ; i := k * 2 ; while i < l->size() do ( (     sum := sum+(l->at(i+1)) ; 
     sum := sum+(l->at(i - 1+1)) ; 
    OclFile["System.err"].println(sum) ; 
    r := Set{r, sum}->max() ; 
    sum := sum-(l->at(i - k * 2+1)) ; 
    sum := sum-(l->at(i - k * 2 + 1+1)) ; 
 )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(r) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.ArrayList ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    String S=sc.next();
    int max=0 ;
    int sum=0 ;
    int a=0 ;
    int x=1 ;
    ArrayList<Integer>list=new ArrayList<Integer>();
    list.add(0);
    for(int i=0 ; i<N ; i++){
      if(i!=N-1){
        if(S.charAt(i)=='0' && S.charAt(i+1)=='1'){
          sum+=1 ;
          a+=1 ;
          list.add(i+1);
        }
        else {
          sum+=1 ;
        }
        if(a==K && S.charAt(i)=='1' && S.charAt(i+1)=='0'){
          max=Math.max(max,sum);
          sum-=list.get(x)-list.get(x-1);
          x+=1 ;
          a-=1 ;
        }
      }
      else if(i==N-1){
        sum+=1 ;
        max=Math.max(max,sum);
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var S : String ; S := sc.getCurrent() ;
    var max : int ; max := 0 ;
    var sum : int ; sum := 0 ;
    var a : int ; a := 0 ;
    var x : int ; x := 1 ;
    var list : Sequence(int) ; list := Sequence{} ;
    list := list->including(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (i /= N - 1) then (     if (S->at(i+1) = '0' & S->at(i + 1+1) = '1') then (     sum := sum+(1) ; 
     a := a+(1) ; 
     list := list->including(i + 1) ) else (     sum := sum+(1) ) ;  
     if (a = K & S->at(i+1) = '1' & S->at(i + 1+1) = '0') then (     max := Set{max, sum}->max() ; 
     sum := sum-(list->at(x+1) - list->at(x - 1+1)) ; 
     x := x+(1) ; 
     a := a-(1) ) else skip ) else     if (i = N - 1) then (     sum := sum+(1) ; 
     max := Set{max, sum}->max() ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=1000000 ;
  static ArrayList<Integer>primes=new ArrayList<Integer>();
  static void sieve(){
    int n=MAX ;
    int nNew=(n)/2 ;
    boolean[] marked=new boolean[nNew+100];
    int tmp=(int)Math.sqrt(n);
    for(int i=1 ; i<=(tmp-1)/2 ; i++)for(int j=(i*(i+1))<<1 ; j<=nNew ; j=j+2*i+1)marked[j]=true ;
    primes.add(2);
    for(int i=1 ; i<=nNew ; i++)if(marked[i]==false)primes.add(2*i+1);
  }
  static void primeLcm(int[] arr,int n){
    int[] factors=new int[MAX];
    for(int i=0 ; i<n ; i++){
      int copy=arr[i];
      int sqr=(int)Math.sqrt(copy);
      for(int j=0 ; primes.get(j)<=sqr ; j++){
        if(copy % primes.get(j)==0){
          while(copy % primes.get(j)==0)copy=copy/primes.get(j);
          factors[primes.get(j)]=1 ;
        }
      }
      if(copy>1)factors[copy]=1 ;
    }
    if(factors[2]==1)System.out.print("2 ");
    for(int i=3 ; i<=MAX ; i=i+2)if(factors[i]==1)System.out.print(i+" ");
  }
  public static void main(String[] args){
    sieve();
    int[] arr={
      20,10,15,60 };
      int n=arr.length ;
      primeLcm(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 1000000;
  static   attribute primes : Sequence(int) := Sequence{};
  static   operation sieve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := MAX ;
     var nNew : int ; nNew := (n) / 2 ;
    var marked : Sequence(boolean) ; marked := Integer.subrange(1,nNew + 100)->collect(false) ;
    var tmp : int ; tmp := (n)->sqrt()->oclAsType(int) ;
        var i : int ; i := 1 ; while i <= (tmp - 1) / 2 do (         var j : int ; j := ((i * (i + 1))*(2->pow(1)))->oclAsType(long) ; while j <= nNew do (     marked[j+1] := true ;  ;     j := j + 2 * i + 1 ) ;  ;     i := i + 1 ) ; 
    primes := primes->including(2) ; 
        var i : int ; i := 1 ; while i <= nNew do (     if (marked[i+1] = false) then     primes := primes->including(2 * i + 1) ; else skip ;  ;     i := i + 1 ) ; 
 );
  static   operation primeLcm( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var factors : Sequence(int) ; factors := Integer.subrange(1,MAX)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     var copy : int ; copy := arr[i+1] ;
     var sqr : int ; sqr := (copy)->sqrt()->oclAsType(int) ;
         var j : int ; j := 0 ; while primes->at(j+1) <= sqr do ( (     if (copy mod primes->at(j+1) = 0) then (     while (copy mod primes->at(j+1) = 0) do     copy := copy / primes->at(j+1) ; ; 
     factors[primes->at(j+1)+1] := 1 ) else skip )  ;     j := j + 1 ) ; 
     if (copy > 1) then     factors[copy+1] := 1 ; else skip )  ;     i := i + 1 ) ; 
     if (factors[2+1] = 1) then     OclFile["System.out"].print("2 ") ; else skip ; 
         var i : int ; i := 3 ; while i <= MAX do (     if (factors[i+1] = 1) then     OclFile["System.out"].print(i + " ") ; else skip ;  ;     i := i + 2 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute sieve() ; 
     var arr : Sequence(int) ; arr := Sequence{20,10,15,60} ;
     var n : int ; n := arr->size() ;
     execute primeLcm(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  final static int CHARS=26 ;
  static int countDeletions(String str1,String str2){
    int arr[]=new int[CHARS];
    for(int i=0 ; i<str1.length(); i++){
      arr[str1.charAt(i)-'a']++;
    }
    for(int i=0 ; i<str2.length(); i++){
      arr[str2.charAt(i)-'a']--;
    }
    int ans=0 ;
    for(int i=0 ; i<CHARS ; i++){
      ans+=Math.abs(arr[i]);
    }
    return ans ;
  }
  static public void main(String[] args){
    String str1="bcadeh",str2="hea" ;
    System.out.println(countDeletions(str1,str2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute CHARS : int := 26;
  static   operation countDeletions( str1 : String, str2 : String) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,CHARS)->collect(0) ;
         var i : int ; i := 0 ; while i < str1->size() do ( (     arr[str1->at(i+1) - ('a')->char2byte()+1] := arr[str1->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < str2->size() do ( (     arr[str2->at(i+1) - ('a')->char2byte()+1] := arr[str2->at(i+1) - ('a')->char2byte()+1] - 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < CHARS do ( (     ans := ans+(if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "bcadeh" ;
    var str2 : String ; str2 := "hea" ;
     OclFile["System.out"].println(countDeletions(str1, str2)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int totalBoxesRemoved(int arr[],int n){
    int count=0 ;
    int prev=arr[0];
    for(int i=1 ; i<n ; i++){
      if(arr[i]>prev){
        count+=(arr[i]-prev);
        arr[i]=prev ;
        prev=arr[i];
      }
      else {
        prev=arr[i];
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      5,4,7,3,2,1 };
      int n=arr.length ;
      System.out.println(totalBoxesRemoved(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation totalBoxesRemoved( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var prev : int ; prev := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] > prev) then (     count := count+((arr[i+1] - prev)) ; 
     arr[i+1] := prev ; 
     prev := arr[i+1] ) else (     prev := arr[i+1] ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,4,7,3,2,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(totalBoxesRemoved(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getSum(int[] BITree,int index){
    int sum=0 ;
    while(index>0){
      sum+=BITree[index];
      index-=index &(-index);
    }
    return sum ;
  }
  static void updateBIT(int[] BITree,int n,int index,int val){
    while(index<=n){
      BITree[index]+=val ;
      index+=index &(-index);
    }
  }
  static int getInvCount(int[] arr,int n){
    int invcount=0 ;
    int maxElement=0 ;
    for(int i=0 ; i<n ; i++)if(maxElement<arr[i])maxElement=arr[i];
    int[] BIT=new int[maxElement+1];
    for(int i=1 ; i<=maxElement ; i++)BIT[i]=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      invcount+=getSum(BIT,arr[i]-1);
      updateBIT(BIT,maxElement,arr[i],1);
    }
    return invcount ;
  }
  public static void main(String[] args){
    int[] arr={
      8,4,2,1 };
      int n=arr.length ;
      System.out.println("Number of inversions are : "+getInvCount(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getSum( BITree : Sequence(int), index : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (index > 0) do (     sum := sum+(BITree[index+1]) ; 
     index := index-(index & (-index)) ) ; 
     return sum );
  static   operation updateBIT( BITree : Sequence(int), n : int, index : int, val : int) : void
  pre: true
  post: true
  activity: (     while (index <= n) do (     BITree[index+1] := BITree[index+1]+(val) ; 
     index := index+(index & (-index)) ) );
  static   operation getInvCount( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var invcount : int ; invcount := 0 ;
     var maxElement : int ; maxElement := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (maxElement < arr[i+1]) then     maxElement := arr[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    var BIT : Sequence(int) ; BIT := Integer.subrange(1,maxElement + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= maxElement do (     BIT[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     invcount := invcount+(getSum(BIT, arr[i+1] - 1)) ; 
     execute updateBIT(BIT, maxElement, arr[i+1], 1) )  ;     i := i - 1 ) ; 
    return invcount 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,4,2,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Number of inversions are : " + getInvCount(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int max_element(int a[]){
    int m=a[0];
    for(int i=0 ; i<a.length ; i++)m=Math.max(a[i],m);
    return m ;
  }
  static boolean checkDivisors(int a[],int n){
    int X=max_element(a);
    Vector<Integer>b=new Vector<Integer>();
    for(int i=1 ; i*i<=X ; i++){
      if(X % i==0){
        b.add(i);
        if(X/i!=i)b.add(X/i);
      }
    }
    if(b.size()!=n)return false ;
    Arrays.sort(a);
    Collections.sort(b);
    for(int i=0 ; i<n ; i++){
      if(b.get(i)!=a[i])return false ;
    }
    return true ;
  }
  public static void main(String args[]){
    int arr[]={
      8,1,2,12,48,6,4,24,16,3 };
      int N=arr.length ;
      if(checkDivisors(arr,N))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation max_element( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var m : int ; m := a[0+1] ;
         var i : int ; i := 0 ; while i < a->size() do (     m := Set{a[i+1], m}->max() ;  ;     i := i + 1 ) ; 
     return m );
  static   operation checkDivisors( a : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var X : int ; X := max_element(a) ;
     var b : Sequence(int) ; b := Sequence{} ;
        var i : int ; i := 1 ; while i * i <= X do ( (     if (X mod i = 0) then (     b := b->including(i) ; 
     if (X / i /= i) then     b := b->including(X / i) ; else skip ) else skip )  ;     i := i + 1 ) ; 
    if (b->size() /= n) then     return false else skip ; 
    a := a->sort() ; 
    b := b->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (b->at(i+1) /= a[i+1]) then     return false else skip )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,1,2,12,48,6,4,24,16,3} ;
     var N : int ; N := arr->size() ;
     if (checkDivisors(arr, N)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int findProduct(int arr[],int n){
    Arrays.sort(arr);
    int prod=1*arr[0];
    for(int i=0 ; i<n-1 ; i++){
      if(arr[i]!=arr[i+1]){
        prod=prod*arr[i+1];
      }
    }
    return prod ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,1,1,4,5,6 };
      int n=arr.length ;
      System.out.println(findProduct(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findProduct( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var prod : int ; prod := 1 * arr[0+1] ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] /= arr[i + 1+1]) then (     prod := prod * arr[i + 1+1] ) else skip )  ;     i := i + 1 ) ; 
     return prod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,1,1,4,5,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findProduct(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int centeredSquare_number(int N){
    float n=(9+(float)Math.sqrt(36*N+45))/18 ;
    if(n-(int)n==0)return 1 ;
    else return 0 ;
  }
  public static void main(String[] args){
    int i=13 ;
    System.out.println(centeredSquare_number(i));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation centeredSquare_number( N : int) : int
  pre: true
  post: true
  activity: (     var n : double ; n := (9 + (36 * N + 45)->sqrt()->oclAsType(double)) / 18 ;
     if (n - n->oclAsType(int) = 0) then     return 1 else     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 13 ;
     OclFile["System.out"].println(centeredSquare_number(i)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maxLength(String s,int n){
    int invalidOpenBraces=0 ;
    int invalidCloseBraces=0 ;
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='('){
        invalidOpenBraces++;
      }
      else {
        if(invalidOpenBraces==0){
          invalidCloseBraces++;
        }
        else {
          invalidOpenBraces--;
        }
      }
    }
    return(n-(invalidOpenBraces+invalidCloseBraces));
  }
  public static void main(String[] args){
    String s="()(((((()" ;
    int n=s.length();
    System.out.println(maxLength(s,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxLength( s : String, n : int) : int
  pre: true
  post: true
  activity: (     var invalidOpenBraces : int ; invalidOpenBraces := 0 ;
     var invalidCloseBraces : int ; invalidCloseBraces := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = '(') then (     invalidOpenBraces := invalidOpenBraces + 1 ) else (     if (invalidOpenBraces = 0) then (     invalidCloseBraces := invalidCloseBraces + 1 ) else (     invalidOpenBraces := invalidOpenBraces - 1 ) ) )  ;     i := i + 1 ) ; 
     return (n - (invalidOpenBraces + invalidCloseBraces)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "()(((((()" ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].println(maxLength(s, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int __gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static int countPrimitiveRoots(int p){
    int result=1 ;
    for(int i=2 ; i<p ; i++)if(__gcd(i,p)==1)result++;
    return result ;
  }
  public static void main(String[] args){
    int p=5 ;
    System.out.println(countPrimitiveRoots(p-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
    if (a = b) then     return a else skip ; 
    if (a > b) then     return __gcd(a - b, b) else skip ; 
    return __gcd(a, b - a) 
 );
  static   operation countPrimitiveRoots( p : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 1 ;
         var i : int ; i := 2 ; while i < p do (     if (__gcd(i, p) = 1) then     result := result + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : int ; p := 5 ;
     OclFile["System.out"].println(countPrimitiveRoots(p - 1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int N=4 ;
  static void add(int A[][],int B[][],int C[][]){
    int i,j ;
    for(i=0 ; i<N ; i++)for(j=0 ; j<N ; j++)C[i][j]=A[i][j]+B[i][j];
  }
  public static void main(String[] args){
    int A[][]={
      {
        1,1,1,1 },{
          2,2,2,2 },{
            3,3,3,3 },{
              4,4,4,4 }
            };
            int B[][]={
              {
                1,1,1,1 },{
                  2,2,2,2 },{
                    3,3,3,3 },{
                      4,4,4,4 }
                    };
                    int C[][]=new int[N][N];
                    int i,j ;
                    add(A,B,C);
                    System.out.print("Result matrix is \n");
                    for(i=0 ; i<N ; i++){
                      for(j=0 ; j<N ; j++)System.out.print(C[i][j]+" ");
                      System.out.print("\n");
                    }
                  }
                }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute N : int := 4;
  static   operation add( A : Sequence(Sequence(int)), B : Sequence(Sequence(int)), C : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := 0 ; while i < N do (         j := 0 ; while j < N do (     C[i+1][j+1] := A[i+1][j+1] + B[i+1][j+1] ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(Sequence(int)) ; A := Sequence{Sequence{1,1,1,1},Sequence{2,2,2,2},Sequence{3,3,3,3},Sequence{4,4,4,4}} ;
     var B : Sequence(Sequence(int)) ; B := Sequence{Sequence{1,1,1,1},Sequence{2,2,2,2},Sequence{3,3,3,3},Sequence{4,4,4,4}} ;
    var C : Sequence(Sequence(int)) ; C := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
    var i : int ;
    var j : int ;
    execute add(A, B, C) ; 
    OclFile["System.out"].print("Result matrix is \n") ; 
        i := 0 ; while i < N do ( (         j := 0 ; while j < N do (     OclFile["System.out"].print(C[i+1][j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int N=4 ;
  static void subtract(int A[][],int B[][],int C[][]){
    int i,j ;
    for(i=0 ; i<N ; i++)for(j=0 ; j<N ; j++)C[i][j]=A[i][j]-B[i][j];
  }
  public static void main(String[] args){
    int A[][]={
      {
        1,1,1,1 },{
          2,2,2,2 },{
            3,3,3,3 },{
              4,4,4,4 }
            };
            int B[][]={
              {
                1,1,1,1 },{
                  2,2,2,2 },{
                    3,3,3,3 },{
                      4,4,4,4 }
                    };
                    int C[][]=new int[N][N];
                    int i,j ;
                    subtract(A,B,C);
                    System.out.print("Result matrix is \n");
                    for(i=0 ; i<N ; i++){
                      for(j=0 ; j<N ; j++)System.out.print(C[i][j]+" ");
                      System.out.print("\n");
                    }
                  }
                }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute N : int := 4;
  static   operation subtract( A : Sequence(Sequence(int)), B : Sequence(Sequence(int)), C : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := 0 ; while i < N do (         j := 0 ; while j < N do (     C[i+1][j+1] := A[i+1][j+1] - B[i+1][j+1] ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(Sequence(int)) ; A := Sequence{Sequence{1,1,1,1},Sequence{2,2,2,2},Sequence{3,3,3,3},Sequence{4,4,4,4}} ;
     var B : Sequence(Sequence(int)) ; B := Sequence{Sequence{1,1,1,1},Sequence{2,2,2,2},Sequence{3,3,3,3},Sequence{4,4,4,4}} ;
    var C : Sequence(Sequence(int)) ; C := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
    var i : int ;
    var j : int ;
    execute subtract(A, B, C) ; 
    OclFile["System.out"].print("Result matrix is \n") ; 
        i := 0 ; while i < N do ( (         j := 0 ; while j < N do (     OclFile["System.out"].print(C[i+1][j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static int getRightMin(int arr[],int n){
    int min=arr[0];
    int rightMin=0 ;
    int i=1 ;
    while(i<n){
      if(arr[i]==min)rightMin=i ;
      i*=2 ;
    }
    i=rightMin+1 ;
    while(i<n && arr[i]==min){
      rightMin=i ;
      i++;
    }
    return rightMin ;
  }
  public static int getLeftMax(int arr[],int n){
    int max=arr[n-1];
    int leftMax=n-1 ;
    int i=n-2 ;
    while(i>0){
      if(arr[i]==max)leftMax=i ;
      i/=2 ;
    }
    i=leftMax-1 ;
    while(i>=0 && arr[i]==max){
      leftMax=i ;
      i--;
    }
    return leftMax ;
  }
  public static void main(String[] args){
    int arr[]={
      0,0,1,2,5,5,6,8,8 };
      int n=arr.length ;
      System.out.println("Minimum left : "+0);
      System.out.println("Minimum right : "+getRightMin(arr,n));
      System.out.println("Maximum left : "+getLeftMax(arr,n));
      System.out.println("Maximum right : "+(n-1));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getRightMin( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var min : int ; min := arr[0+1] ;
     var rightMin : int ; rightMin := 0 ;
    var i : int ; i := 1 ;
    while (i < n) do (     if (arr[i+1] = min) then     rightMin := i ; else skip ; 
     i := i*(2) ) ; 
    i := rightMin + 1 ; 
    while (i < n & arr[i+1] = min) do (     rightMin := i ; 
     i := i + 1 ) ; 
    return rightMin 
 );
  static   operation getLeftMax( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max : int ; max := arr[n - 1+1] ;
     var leftMax : int ; leftMax := n - 1 ;
    var i : int ; i := n - 2 ;
    while (i > 0) do (     if (arr[i+1] = max) then     leftMax := i ; else skip ; 
     i := i/(2) ) ; 
    i := leftMax - 1 ; 
    while (i >= 0 & arr[i+1] = max) do (     leftMax := i ; 
     i := i - 1 ) ; 
    return leftMax 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,0,1,2,5,5,6,8,8} ;
     var n : int ; n := arr->size() ;
    OclFile["System.out"].println("Minimum left : " + 0) ; 
    OclFile["System.out"].println("Minimum right : " + getRightMin(arr, n)) ; 
    OclFile["System.out"].println("Maximum left : " + getLeftMax(arr, n)) ; 
    OclFile["System.out"].println("Maximum right : " + (n - 1)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DormWaterSupply {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int p=sc.nextInt();
    int[] flowout=new int[n];
    int[] flowin=new int[n];
    int[] flowto=new int[n];
    for(int i=0 ; i<p ; i++){
      int a=sc.nextInt()-1 ;
      int b=sc.nextInt()-1 ;
      int d=sc.nextInt();
      flowout[a]=d ;
      flowin[b]=d ;
      flowto[a]=b ;
    }
    int r=0 ;
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      int water=0 ;
      if(flowout[i]>0 && flowin[i]==0){
        water=flowout[i];
        int j=flowto[i];
        while(flowout[j]>0){
          water=Math.min(water,flowout[j]);
          j=flowto[j];
        }
        r++;
        sb.append("\n"+(i+1)+" "+(j+1)+" "+water);
      }
    }
    System.out.print(Integer.toString(r)+sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class DormWaterSupply {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
    var flowout : Sequence(int) ; flowout := Integer.subrange(1,n)->collect(0) ;
    var flowin : Sequence(int) ; flowin := Integer.subrange(1,n)->collect(0) ;
    var flowto : Sequence(int) ; flowto := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < p do ( (     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
     var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    flowout[a+1] := d ; 
    flowin[b+1] := d ; 
    flowto[a+1] := b ; 
 )  ;     i := i + 1 ) ; 
    var r : int ; r := 0 ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     var water : int ; water := 0 ;
     if (flowout[i+1] > 0 & flowin[i+1] = 0) then (     water := flowout[i+1] ; 
     var j : int ; j := flowto[i+1] ;
    while (flowout[j+1] > 0) do (     water := Set{water, flowout[j+1]}->min() ; 
     j := flowto[j+1] ) ; 
    r := r + 1 ; 
    sb := sb + StringLib.newString("\n" + (i + 1) + " " + (j + 1) + " " + water) ; 
 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(((r) + "") + sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isCommonBase(String base,String s1,String s2){
    for(int j=0 ; j<s1.length(); ++j){
      if(base.charAt(j % base.length())!=s1.charAt(j)){
        return false ;
      }
    }
    for(int j=0 ; j<s2.length(); ++j){
      if(base.charAt(j % base.length())!=s2.charAt(j)){
        return false ;
      }
    }
    return true ;
  }
  static int countCommonBases(String s1,String s2){
    int n1=s1.length(),n2=s2.length();
    int count=0 ;
    for(int i=1 ; i<=Math.min(n1,n2); i++){
      String base=s1.substring(0,i);
      if(isCommonBase(base,s1,s2)){
        count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    String s1="pqrspqrs" ;
    String s2="pqrspqrspqrspqrs" ;
    System.out.println(countCommonBases(s1,s2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isCommonBase( base : String, s1 : String, s2 : String) : boolean
  pre: true
  post: true
  activity: (         var j : int ; j := 0 ; while j < s1->size() do ( (     if (base->at(j mod base->size()+1) /= s1->at(j+1)) then (     return false ) else skip )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < s2->size() do ( (     if (base->at(j mod base->size()+1) /= s2->at(j+1)) then (     return false ) else skip )  ;     j := j + 1 ) ; 
     return true );
  static   operation countCommonBases( s1 : String, s2 : String) : int
  pre: true
  post: true
  activity: (     var n1 : int ; n1 := s1->size() ;
    var n2 : int ; n2 := s2->size() ;
     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i <= Set{n1, n2}->min() do ( (     var base : String ; base := s1.subrange(0+1,i) ;
     if (isCommonBase(base, s1, s2)) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "pqrspqrs" ;
     var s2 : String ; s2 := "pqrspqrspqrspqrs" ;
     OclFile["System.out"].println(countCommonBases(s1, s2)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findSetBits(int n){
    int[] dp=new int[n+1];
    System.out.print(dp[0]+" ");
    for(int i=1 ; i<=n ; i++){
      if(i % 2==0){
        dp[i]=dp[i/2];
      }
      else {
        dp[i]=dp[i/2]+1 ;
      }
      System.out.print(dp[i]+" ");
    }
  }
  public static void main(String[] args){
    int n=5 ;
    findSetBits(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findSetBits( n : int) : void
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
     OclFile["System.out"].print(dp[0+1] + " ") ; 
         var i : int ; i := 1 ; while i <= n do ( (     if (i mod 2 = 0) then (     dp[i+1] := dp[i / 2+1] ) else (     dp[i+1] := dp[i / 2+1] + 1 ) ;  
     OclFile["System.out"].print(dp[i+1] + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute findSetBits(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int arr[]=new int[] {
    1,2,3,4 };
    static void subArray(int n){
      for(int i=0 ; i<n ; i++){
        for(int j=i ; j<n ; j++){
          for(int k=i ; k<=j ; k++)System.out.print(arr[k]+" ");
        }
      }
    }
    public static void main(String[] args){
      System.out.println("All Non-empty Subarrays");
      subArray(arr.length);
    }
  }

------------------------------------------------------------
OCL File:
---------
class Test {
  static   attribute arr : int := Sequence{1,2,3,4};
  static   operation subArray( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i ; while j < n do ( (         var k : int ; k := i ; while k <= j do (     OclFile["System.out"].print(arr[k+1] + " ") ;  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("All Non-empty Subarrays") ; 
     execute subArray(arr->size()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1006A_AdjacentReplacements {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    final int len=input.nextInt();
    LinkedList<Integer>list=new LinkedList<>();
    LinkedHashSet<Integer>set=new LinkedHashSet<>();
    for(int i=0 ; i<len ; i++){
      int num=input.nextInt();
      list.add(num);
      if(num % 2==0){
        set.add(num);
      }
    }
    for(Integer i : set){
      Collections.replaceAll(list,i,i-1);
    }
    System.out.println(list.toString().replaceAll("[\\[\\],] ",""));
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1006A_AdjacentReplacements {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := input.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < len do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
     list := list->including(num) ; 
     if (num mod 2 = 0) then (     set := set->including(num) ) else skip )  ;     i := i + 1 ) ; 
    for (i : set) do ( (     list := list->collect( x1 | if x1 = i then i - 1 else x1 endif ) )  ) ; 
    OclFile["System.out"].println(list+"".replaceAllMatches("[\\[\\],] ", "" )) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static boolean isMagic(int n){
    int sum=0 ;
    while(n>0 || sum>9){
      if(n==0){
        n=sum ;
        sum=0 ;
      }
      sum+=n % 10 ;
      n/=10 ;
    }
    return(sum==1);
  }
  public static void main(String args[]){
    int n=1234 ;
    if(isMagic(n))System.out.println("Magic Number");
    else System.out.println("Not a magic Number");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isMagic( n : int) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n > 0 or sum > 9) do (     if (n = 0) then (     n := sum ; 
     sum := 0 ) else skip ; 
     sum := sum+(n mod 10) ; 
     n := n/(10) ) ; 
     return (sum = 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1234 ;
     if (isMagic(n)) then     OclFile["System.out"].println("Magic Number") ; else     OclFile["System.out"].println("Not a magic Number") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int NumUnsignBits=64 ;
  static long findNum(long x){
    for(int i=0 ; i<NumUnsignBits-1 ; i++){
      if(((x>>i)& 1)!=((x>>(i+1))& 1)){
        x ^=(1<<i)|(1<<(i+1));
        return x ;
      }
    }
    return Long.MIN_VALUE ;
  }
  public static void main(String[] args){
    int n=92 ;
    System.out.println(findNum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute NumUnsignBits : int := 64;
  static   operation findNum( x : long) : long
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < NumUnsignBits - 1 do ( (     if ((((x/(2->pow(i)))->oclAsType(long)) & 1) /= (((x/(2->pow((i + 1))))->oclAsType(long)) & 1)) then (     x := MathLib.bitwiseXor(x,((1*(2->pow(i)))->oclAsType(long)) or ((1*(2->pow((i + 1))))->oclAsType(long))) ; 
     return x ) else skip )  ;     i := i + 1 ) ; 
     return "-9223372036854775808"->toLong() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 92 ;
     OclFile["System.out"].println(findNum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    Scanner sc=new Scanner(systemin);
    String s=sc.nextLine();
    boolean valid=false ;
    if(s.length()<6){
      valid=false ;
    }
    else {
      boolean num=false ;
      boolean small=false ;
      boolean big=false ;
      for(int i=0 ; i<s.length(); i++){
        int c=s.charAt(i);
        if('0'<=c && c<='9'){
          num=true ;
        }
        else if('a'<=c && c<='z'){
          small=true ;
        }
        else if('A'<=c && c<='Z'){
          big=true ;
        }
      }
      if(num && small && big)valid=true ;
    }
    result.printf("%s\n",valid ? "VALID" : "INVALID");
    sc.close();
    return false ;
  }
  PrintStream log ;
  PrintStream result=System.out ;
  BufferedReader systemin ;
  static Main instance=new Main();
  Main(){
    systemin=new BufferedReader(new InputStreamReader(System.in));
    log=new PrintStream(new OutputStream(){
      public void write(int b){
      }
    }
);
  }
  public static void main(String[] args)throws IOException {
    instance.main();
    instance.systemin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(systemin) ;
     var s : String ; s := sc.nextLine() ;
    var valid : boolean ; valid := false ;
    if (s->size() < 6) then (     valid := false ) else (     var num : boolean ; num := false ;
     var small : boolean ; small := false ;
    var big : boolean ; big := false ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var c : int ; c := s->at(i+1) ;
     if ('0' <= c & c <= '9') then (     num := true ) else     if ('a' <= c & c <= 'z') then (     small := true ) else     if ('A' <= c & c <= 'Z') then (     big := true ) else skip ; ;  )  ;     i := i + 1 ) ; 
    if (num & small & big) then     valid := true ; else skip ; 
 ) ;  
    result.printf("%s\n", if valid then "VALID" else "INVALID" endif) ; 
    skip ; 
    return false 
 );
   attribute log : OclFile;
   attribute result : OclFile := OclFile["System.out"];
   attribute systemin : OclFile;
  static   attribute instance : Main := Main.newMain();
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     systemin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     log := OclFile.newOclFile_Write(OclFile()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     instance.main() ; 
     instance.systemin.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    System.out.println(solve(sc.next())? "VALID" : "INVALID");
  }
  static boolean solve(String s){
    if(s.length()<6)return false ;
    int r=0 ;
    for(char c : s.toCharArray()){
      if(Character.isDigit(c))r |=1 ;
      if(Character.isUpperCase(c))r |=2 ;
      if(Character.isLowerCase(c))r |=4 ;
    }
    return r==7 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if solve(sc.getCurrent()) then "VALID" else "INVALID" endif) );
  static   operation solve( s : String) : boolean
  pre: true
  post: true
  activity: (     if (s->size() < 6) then     return false else skip ; 
     var r : int ; r := 0 ;
     for (c : s->characters()) do ( (     if ((c + "")->isMatch("[0-9]")) then     r := MathLib.bitwiseOr(r, 1) ; else skip ; 
     if ((c->toUpperCase() = c)) then     r := MathLib.bitwiseOr(r, 2) ; else skip ; 
     if ((c->toLowerCase() = c)) then     r := MathLib.bitwiseOr(r, 4) ; else skip )  ) ; 
     return r = 7 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    int l=s.length();
    if(l<6){
      System.out.println("INVALID");
      return ;
    }
    char[] p=new char[l];
    for(int i=0 ; i<l ; i++){
      p[i]=s.charAt(i);
    }
    boolean num=false ;
    boolean cap=false ;
    boolean lit=false ;
    for(int i=0 ; i<l ; i++){
      char c=p[i];
      if('0'<=c && c<='9')num=true ;
      if('A'<=c && c<='Z')cap=true ;
      if('a'<=c && c<='z')lit=true ;
    }
    if(num && cap && lit){
      System.out.println("VALID");
    }
    else {
      System.out.println("INVALID");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var l : int ; l := s->size() ;
    if (l < 6) then (     OclFile["System.out"].println("INVALID") ; 
     return ) else skip ; 
    var p : Sequence(String) ; p := Integer.subrange(1,l)->collect(0) ;
        var i : int ; i := 0 ; while i < l do ( (     p[i+1] := s->at(i+1) )  ;     i := i + 1 ) ; 
    var num : boolean ; num := false ;
    var cap : boolean ; cap := false ;
    var lit : boolean ; lit := false ;
        var i : int ; i := 0 ; while i < l do ( (     var c : String ; c := p[i+1] ;
     if ('0' <= c & c <= '9') then     num := true ; else skip ; 
     if ('A' <= c & c <= 'Z') then     cap := true ; else skip ; 
     if ('a' <= c & c <= 'z') then     lit := true ; else skip )  ;     i := i + 1 ) ; 
    if (num & cap & lit) then (     OclFile["System.out"].println("VALID") ) else (     OclFile["System.out"].println("INVALID") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.LinkedList ;
import java.util.ListIterator ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String input=sc.next();
    boolean flag=input.length()>=6 && input.matches(".*[a-z]+.*")&& input.matches(".*[A-Z]+.*")&& input.matches(".*[0-9]+.*");
    System.out.println(flag ? "VALID" : "INVALID");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : String ; input := sc.getCurrent() ;
     var flag : boolean ; flag := input->size() >= 6 & input->isMatch(".*[a-z]+.*") & input->isMatch(".*[A-Z]+.*") & input->isMatch(".*[0-9]+.*") ;
     OclFile["System.out"].println(if flag then "VALID" else "INVALID" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  static int h ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    h=Integer.parseInt(sc.nextLine())+1 ;
    int[] a=new int[h];
    int[] input=Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    for(int i=1 ; i<h ; i++){
      a[i]=input[i-1];
    }
    buildMaxHeap(a);
    for(int i=1 ; i<h ; i++){
      System.out.print(" "+a[i]);
    }
    System.out.println();
  }
  static void buildMaxHeap(int[] a){
    for(int i=h/2 ; i>=1 ; i--){
      maxHeapify(a,i);
    }
  }
  static void maxHeapify(int[] a,int i){
    int leftId=i*2 ;
    int rightId=i*2+1 ;
    int largest=0 ;
    if(leftId<h && a[leftId]>a[i]){
      largest=leftId ;
    }
    else {
      largest=i ;
    }
    if(rightId<h && a[rightId]>a[largest]){
      largest=rightId ;
    }
    if(largest!=i){
      int tmp=a[i];
      a[i]=a[largest];
      a[largest]=tmp ;
      maxHeapify(a,largest);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute h : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     h := (sc.nextLine())->toInteger() + 1 ; 
    var a : Sequence(int) ; a := Integer.subrange(1,h)->collect(0) ;
    var input : Sequence(int) ; input := stream(sc.nextLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
        var i : int ; i := 1 ; while i < h do ( (     a[i+1] := input[i - 1+1] )  ;     i := i + 1 ) ; 
    execute buildMaxHeap(a) ; 
        var i : int ; i := 1 ; while i < h do ( (     OclFile["System.out"].print(" " + a[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation buildMaxHeap( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := h / 2 ; while i >= 1 do ( (     execute maxHeapify(a, i) )  ;     i := i - 1 ) );
  static   operation maxHeapify( a : Sequence(int), i : int) : void
  pre: true
  post: true
  activity: (     var leftId : int ; leftId := i * 2 ;
     var rightId : int ; rightId := i * 2 + 1 ;
    var largest : int ; largest := 0 ;
    if (leftId < h & a[leftId+1] > a[i+1]) then (     largest := leftId ) else (     largest := i ) ;  
    if (rightId < h & a[rightId+1] > a[largest+1]) then (     largest := rightId ) else skip ; 
    if (largest /= i) then (     var tmp : int ; tmp := a[i+1] ;
     a[i+1] := a[largest+1] ; 
     a[largest+1] := tmp ; 
     execute maxHeapify(a, largest) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int tc=input.nextInt();
    work : while(tc-->0){
      long n=input.nextLong();
      long x=Long.MAX_VALUE ;
      long y=Long.MIN_VALUE ;
      if(n % 6==0){
        x=Math.min(x,n/6);
        y=Math.max(y,n/6);
      }
      if(n % 6==2 && n!=2){
        x=Math.min(x,((n/6)-1)+2);
        y=Math.max(y,((n/6)-1)+2);
      }
      if(n % 6==4 && n!=4){
        x=Math.min(x,n/6+1);
        y=Math.max(y,n/6+1);
      }
      if(n % 4==0){
        x=Math.min(x,n/4);
        y=Math.max(y,n/4);
      }
      if(n % 4==2 && n!=2){
        x=Math.min(x,(n/4)-1+1);
        y=Math.max(y,(n/4)-1+1);
      }
      if(x!=Long.MAX_VALUE && y!=Long.MIN_VALUE)System.out.println(x+" "+y);
      else {
        System.out.println("-1");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := input.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : long ; n := input.getCurrent()->toLong() ;
     var x : long ; x := "9223372036854775807"->toLong() ;
    var y : long ; y := "-9223372036854775808"->toLong() ;
    if (n mod 6 = 0) then (     x := Set{x, n / 6}->min() ; 
     y := Set{y, n / 6}->max() ) else skip ; 
    if (n mod 6 = 2 & n /= 2) then (     x := Set{x, ((n / 6) - 1) + 2}->min() ; 
     y := Set{y, ((n / 6) - 1) + 2}->max() ) else skip ; 
    if (n mod 6 = 4 & n /= 4) then (     x := Set{x, n / 6 + 1}->min() ; 
     y := Set{y, n / 6 + 1}->max() ) else skip ; 
    if (n mod 4 = 0) then (     x := Set{x, n / 4}->min() ; 
     y := Set{y, n / 4}->max() ) else skip ; 
    if (n mod 4 = 2 & n /= 2) then (     x := Set{x, (n / 4) - 1 + 1}->min() ; 
     y := Set{y, (n / 4) - 1 + 1}->max() ) else skip ; 
    if (x /= "9223372036854775807"->toLong() & y /= "-9223372036854775808"->toLong()) then     OclFile["System.out"].println(x + " " + y) else (     OclFile["System.out"].println("-1") ) ;  
 ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void maxHeapify(int[] A,int i){
    int H=A.length ;
    int largest ;
    int l=2*(i+1)-1 ;
    int r=2*(i+1);
    if(l<H && A[l]>A[i])largest=l ;
    else largest=i ;
    if(r<H && A[r]>A[largest])largest=r ;
    if(largest!=i){
      int temp=A[i];
      A[i]=A[largest];
      A[largest]=temp ;
      maxHeapify(A,largest);
    }
  }
  public static void main(String[] argv){
    int n ;
    Scanner in=new Scanner(System.in);
    n=in.nextInt();
    int[] tree=new int[n];
    for(int i=0 ; i<n ; i++){
      tree[i]=in.nextInt();
    }
    for(int i=(n-1)/2 ; i>=0 ; i--){
      maxHeapify(tree,i);
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(" "+tree[i]);
    }
    System.out.println();
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation maxHeapify( A : Sequence(int), i : int) : void
  pre: true
  post: true
  activity: (     var H : int ; H := A->size() ;
     var largest : int ;
    var l : int ; l := 2 * (i + 1) - 1 ;
    var r : int ; r := 2 * (i + 1) ;
    if (l < H & A[l+1] > A[i+1]) then     largest := l else     largest := i ; ;  
    if (r < H & A[r+1] > A[largest+1]) then     largest := r ; else skip ; 
    if (largest /= i) then (     var temp : int ; temp := A[i+1] ;
     A[i+1] := A[largest+1] ; 
     A[largest+1] := temp ; 
     execute maxHeapify(A, largest) ) else skip ; 
 );
  static   operation main( argv : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := in.getCurrent()->toInteger() ; 
    var tree : Sequence(int) ; tree := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     tree[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := (n - 1) / 2 ; while i >= 0 do ( (     execute maxHeapify(tree, i) )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(" " + tree[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=s.nextInt();
    }
    solution(a);
    output(a);
  }
  public static int[] solution(int[] a){
    for(int i=0 ; i<a.length ; i++){
      if(a[i] % 2==0)a[i]=a[i]-1 ;
    }
    return a ;
  }
  public static void output(int[] a){
    for(int i=0 ; i<a.length ; i++){
      System.out.print(a[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute solution(a) ; 
    execute output(a) ; 
 );
  static   operation solution( a : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] mod 2 = 0) then     a[i+1] := a[i+1] - 1 ; else skip )  ;     i := i + 1 ) ; 
     return a );
  static   operation output( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < a->size() do ( (     OclFile["System.out"].print(a[i+1] + " ") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  static int N ;
  public static int[] Nodes ;
  static long changecount=0 ;
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    N=Integer.parseInt(br.readLine());
    Nodes=new int[N];
    String[] string=br.readLine().split(" ");
    for(int i=0 ; i<N ; i++){
      Nodes[i]=Integer.parseInt(string[i]);
    }
    for(int i=N/2 ; 0<=i ; i--){
      maxHeapify(i);
    }
    System.out.print(" ");
    for(int i=0 ; i<N ; i++){
      System.out.print(Nodes[i]);
      if(i<N-1){
        System.out.print(" ");
      }
    }
    System.out.println();
  }
  public static void maxHeapify(int i){
    int left=i*2+1,right=i*2+2,largest ;
    if(left<N && Nodes[left]>Nodes[i]){
      largest=left ;
    }
    else {
      largest=i ;
    }
    if(right<N && Nodes[right]>Nodes[largest]){
      largest=right ;
    }
    if(largest!=i){
      int tmp=Nodes[i];
      Nodes[i]=Nodes[largest];
      Nodes[largest]=tmp ;
      maxHeapify(largest);
    }
  }
}
class Node {
  int key ;
  int index ;
  Node(int i,int x){
    key=x ;
    index=i ;
  }
  void print(){
    System.out.print("node "+index+": key="+key+",");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute Nodes : Sequence(int);
  static   attribute changecount : long := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     N := (br.readLine())->toInteger() ; 
    Nodes := Integer.subrange(1,N)->collect(0) ; 
    var string : Sequence(String) ; string := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < N do ( (     Nodes[i+1] := (string[i+1])->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := N / 2 ; while 0 <= i do ( (     execute maxHeapify(i) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].print(" ") ; 
        var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].print(Nodes[i+1]) ; 
     if (i < N - 1) then (     OclFile["System.out"].print(" ") ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation maxHeapify( i : int) : void
  pre: true
  post: true
  activity: (     var left : int ; left := i * 2 + 1 ;
    var right : int ; right := i * 2 + 2 ;
    var largest : int ;
     if (left < N & Nodes[left+1] > Nodes[i+1]) then (     largest := left ) else (     largest := i ) ;  
     if (right < N & Nodes[right+1] > Nodes[largest+1]) then (     largest := right ) else skip ; 
     if (largest /= i) then (     var tmp : int ; tmp := Nodes[i+1] ;
     Nodes[i+1] := Nodes[largest+1] ; 
     Nodes[largest+1] := tmp ; 
     execute maxHeapify(largest) ) else skip );
}
class Node {
   attribute key : int;
   attribute index : int;
   static operation newNode( i : int, x : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(i, x);
    return self );
  operation initialise( i : int, x : int) : void
  pre: true  post: true
  activity: (     key := x ; 
     index := i );
   operation print() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("node " + index + ": key=" + key + ",") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      int heapSize=Integer.parseInt(br.readLine());
      String[] keys=br.readLine().split(" ");
      int[] mHeap=new int[heapSize+1];
      mHeap[0]=heapSize ;
      for(int i=1 ; i<=heapSize ; i++)mHeap[i]=Integer.parseInt(keys[i-1]);
      buildMaxHeap(mHeap);
      StringBuilder buf=new StringBuilder();
      for(int i=1 ; i<mHeap.length ; i++)buf.append(" ").append(mHeap[i]);
      System.out.println(buf);
    }
    catch(IOException e){
      System.out.println("IOException!");
    }
  }
  private void buildMaxHeap(int[] heap){
    for(int i=heap[0]/2 ; i>0 ; i--)maxHeapify(heap,i);
  }
  private void maxHeapify(int[] heap,int node){
    int t,left,right,largest ;
    left=nodeLeft(node);
    right=nodeRight(node);
    if((left<=heap[0])&&(heap[left]>heap[node]))largest=left ;
    else largest=node ;
    if((right<=heap[0])&&(heap[right]>heap[largest]))largest=right ;
    if(largest!=node){
      t=heap[node];
      heap[node]=heap[largest];
      heap[largest]=t ;
      maxHeapify(heap,largest);
    }
  }
  private int nodeLeft(int node){
    return node*2 ;
  }
  private int nodeRight(int node){
    return node*2+1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var heapSize : int ; heapSize := (br.readLine())->toInteger() ;
     var keys : Sequence(String) ; keys := br.readLine()->split(" ") ;
    var mHeap : Sequence(int) ; mHeap := Integer.subrange(1,heapSize + 1)->collect(0) ;
    mHeap[0+1] := heapSize ; 
        var i : int ; i := 1 ; while i <= heapSize do (     mHeap[i+1] := (keys[i - 1+1])->toInteger() ;  ;     i := i + 1 ) ; 
    execute buildMaxHeap(mHeap) ; 
    var buf : String ; buf := StringLib.newString() ;
        var i : int ; i := 1 ; while i < mHeap->size() do (     buf := buf + StringLib.newString(" ") + StringLib.newString(mHeap[i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(buf) ; 
 ))   catch (e : IOException) do (     OclFile["System.out"].println("IOException!") )
  );
   operation buildMaxHeap( heap : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := heap[0+1] / 2 ; while i > 0 do (     execute maxHeapify(heap, i) ;  ;     i := i - 1 ) );
   operation maxHeapify( heap : Sequence(int), node : int) : void
  pre: true
  post: true
  activity: (     var t : int ;
    var left : int ;
    var right : int ;
    var largest : int ;
     left := nodeLeft(node) ; 
    right := nodeRight(node) ; 
    if ((left <= heap[0+1]) & (heap[left+1] > heap[node+1])) then     largest := left else     largest := node ; ;  
    if ((right <= heap[0+1]) & (heap[right+1] > heap[largest+1])) then     largest := right ; else skip ; 
    if (largest /= node) then (     t := heap[node+1] ; 
     heap[node+1] := heap[largest+1] ; 
     heap[largest+1] := t ; 
     execute maxHeapify(heap, largest) ) else skip ; 
 );
   operation nodeLeft( node : int) : int
  pre: true
  post: true
  activity: (     return node * 2 );
   operation nodeRight( node : int) : int
  pre: true
  post: true
  activity: (     return node * 2 + 1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class shortest_path {
  static int INF=Integer.MAX_VALUE,N=4 ;
  static int minCost(int cost[][]){
    int dist[]=new int[N];
    for(int i=0 ; i<N ; i++)dist[i]=INF ;
    dist[0]=0 ;
    for(int i=0 ; i<N ; i++)for(int j=i+1 ; j<N ; j++)if(dist[j]>dist[i]+cost[i][j])dist[j]=dist[i]+cost[i][j];
    return dist[N-1];
  }
  public static void main(String args[]){
    int cost[][]={
      {
        0,15,80,90 },{
          INF,0,40,50 },{
            INF,INF,0,70 },{
              INF,INF,INF,0 }
            };
            System.out.println("The Minimum cost to reach station "+N+" is "+minCost(cost));
          }
        }

------------------------------------------------------------
OCL File:
---------
class shortest_path {
  static   attribute INF : int := 2147483647;
  static   operation minCost( cost : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var dist : Sequence(int) ; dist := Integer.subrange(1,N)->collect(0) ;
         var i : int ; i := 0 ; while i < N do (     dist[i+1] := INF ;  ;     i := i + 1 ) ; 
    dist[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < N do (         var j : int ; j := i + 1 ; while j < N do (     if (dist[j+1] > dist[i+1] + cost[i+1][j+1]) then     dist[j+1] := dist[i+1] + cost[i+1][j+1] ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return dist[N - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cost : Sequence(Sequence(int)) ; cost := Sequence{Sequence{0,15,80,90},Sequence{INF,0,40,50},Sequence{INF,INF,0,70},Sequence{INF,INF,INF,0}} ;
     OclFile["System.out"].println("The Minimum cost to reach station " + N + " is " + minCost(cost)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String srgs[]){
    Scanner sc=new Scanner(System.in);
    int n ;
    while(sc.hasNext()){
      n=sc.nextInt();
      String s="3C" ;
      String s2="0" ;
      n %=39 ;
      n=(n==0)? 39 : n ;
      s+=(0<=n && n<=9)? s2+Integer.toString(n): Integer.toString(n);
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( srgs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
     while (sc.hasNext()) do (     n := sc.getCurrent()->toInteger() ; 
     var s : String ; s := "3C" ;
    var s2 : String ; s2 := "0" ;
    n := n mod 39 ; 
    n := if (n = 0) then 39 else n endif ; 
    s := s+(if (0 <= n & n <= 9) then s2 + ((n) + "") else ((n) + "") endif) ; 
    OclFile["System.out"].println(s) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n ;
    for(; sc.hasNext(); ){
      n=sc.nextInt();
      n %=39 ;
      if(n==0)n=39 ;
      out.printf("3C%02d%n",n);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
       while sc.hasNext() do ( (     n := sc.nextInt() ; 
     n := n mod 39 ; 
     if (n = 0) then     n := 39 ; else skip ; 
     out.printf("3C%02d%n", n) )  ) ; 
     sc.close() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public void solve()throws IOException {
    while(stdIn.hasNext()){
      int n=stdIn.nextInt();
      StringBuilder ans=new StringBuilder("3C");
      int x=(n % 39!=0)? n % 39 : 39 ;
      if(x/10==0){
        ans.append("0");
      }
      ans.append(x);
      writer.println(ans);
      writer.flush();
    }
    writer.flush();
  }
  public static void main(String args[])throws IOException {
    new Main().run();
  }
  Scanner stdIn ;
  PrintWriter writer ;
  public void run()throws IOException {
    stdIn=null ;
    try {
      stdIn=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
      writer=new PrintWriter(System.out);
      solve();
      stdIn.close();
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     while (stdIn.hasNext()) do (     var n : int ; n := stdIn.nextInt() ;
     var ans : String ; ans := StringLib.newString("3C") ;
    var x : int ; x := if (n mod 39 /= 0) then n mod 39 else 39 endif ;
    if (x / 10 = 0) then (     ans := ans + StringLib.newString("0") ) else skip ; 
    ans := ans + StringLib.newString(x) ; 
    writer.println(ans) ; 
    writer.flush() ; 
 ) ; 
     writer.flush() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute stdIn : OclFile;
   attribute writer : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     stdIn := null ; 
     try (     stdIn := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
     writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  static final int NUM_STUDENTS=39 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String buf ;
    while((buf=br.readLine())!=null){
      System.out.println(getIDWithFlag(Integer.parseInt(buf)));
    }
  }
  public static String getIDWithFlag(int numCandy){
    int id=numCandy % NUM_STUDENTS ;
    if(id==0)id=39 ;
    return "3C"+String.format("%02d",id);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute NUM_STUDENTS : int := 39;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var buf : String ;
         buf := br.readLine() ;
    while ((buf) /= null) do (    skip ; (     OclFile["System.out"].println(getIDWithFlag((buf)->toInteger())) ) ;     buf := br.readLine() ;
 ) );
  static   operation getIDWithFlag( numCandy : int) : String
  pre: true
  post: true
  activity: (     var id : int ; id := numCandy mod NUM_STUDENTS ;
     if (id = 0) then     id := 39 ; else skip ; 
     return "3C" + StringLib.format("%02d",Sequence{id}) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findAnswer(int n,int[] arr){
    Arrays.sort(arr);
    int sum=0 ;
    for(int i=0 ; i<n/2 ; ++i){
      sum+=(arr[i]+arr[n-i-1])*(arr[i]+arr[n-i-1]);
    }
    return sum ;
  }
  public static void main(String[] args){
    int[] arr={
      53,28,143,5 };
      int n=arr.length ;
      System.out.println(findAnswer(n,arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findAnswer( n : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n / 2 do ( (     sum := sum+((arr[i+1] + arr[n - i - 1+1]) * (arr[i+1] + arr[n - i - 1+1])) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{53,28,143,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findAnswer(n, arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws java.io.IOException {
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      String text=scan.next();
      int count=0 ;
      for(int i=0 ; i<Integer.parseInt(text); i++){
++count ;
        if(count==40){
          count=1 ;
        }
      }
      if(Integer.toString(count).length()==1){
        System.out.println("3C0"+count);
      }
      else {
        System.out.println("3C"+count);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var text : String ; text := scan.getCurrent() ;
     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < (text)->toInteger() do ( (     count := count + 1 ; 
     if (count = 40) then (     count := 1 ) else skip )  ;     i := i + 1 ) ; 
     if (((count) + "")->size() = 1) then (     OclFile["System.out"].println("3C0" + count) ) else (     OclFile["System.out"].println("3C" + count) ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    StringTokenizer st=new StringTokenizer(f.readLine());
    int n=Integer.parseInt(st.nextToken());
    int m=Integer.parseInt(st.nextToken());
    int k=Integer.parseInt(st.nextToken());
    int[] ar=new int[n];
    int[] tr=new int[n];
    int[] ac=new int[m];
    int[] tc=new int[m];
    for(int i=1 ; i<=k ; i++){
      st=new StringTokenizer(f.readLine());
      int t=Integer.parseInt(st.nextToken());
      int x=Integer.parseInt(st.nextToken())-1 ;
      int a=Integer.parseInt(st.nextToken());
      if(t==1){
        ar[x]=a ;
        tr[x]=i ;
      }
      else {
        ac[x]=a ;
        tc[x]=i ;
      }
    }
    for(int i=0 ; i<n ; i++){
      if(tr[i]>tc[0]){
        out.print(ar[i]);
      }
      else {
        out.print(ac[0]);
      }
      for(int j=1 ; j<m ; j++){
        if(tr[i]>tc[j]){
          out.print(" "+ar[i]);
        }
        else {
          out.print(" "+ac[j]);
        }
      }
      out.println();
    }
    f.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(f.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var k : int ; k := (st.next())->toInteger() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
    var tr : Sequence(int) ; tr := Integer.subrange(1,n)->collect(0) ;
    var ac : Sequence(int) ; ac := Integer.subrange(1,m)->collect(0) ;
    var tc : Sequence(int) ; tc := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 1 ; while i <= k do ( (     st := OclIterator.newOclIterator_String(f.readLine()) ; 
     var t : int ; t := (st.next())->toInteger() ;
    var x : int ; x := (st.next())->toInteger() - 1 ;
    var a : int ; a := (st.next())->toInteger() ;
    if (t = 1) then (     ar[x+1] := a ; 
     tr[x+1] := i ) else (     ac[x+1] := a ; 
     tc[x+1] := i ) ;  
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (tr[i+1] > tc[0+1]) then (     skip ) else (     skip ) ;  
         var j : int ; j := 1 ; while j < m do ( (     if (tr[i+1] > tc[j+1]) then (     skip ) else (     skip ) )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.*;
import javafx.util.Pair ;
public class Main {
  public static void main(String args[]){
    FastScanner input=new FastScanner();
    int n=input.nextInt();
    int m=input.nextInt();
    int k=input.nextInt();
    LinkedList<Integer>a=new LinkedList<>();
    for(int i=0 ; i<k ; i++){
      a.add(input.nextInt());
    }
    long total=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        int value=input.nextInt();
        int c=0 ;
        for(Integer integer : a){
          c++;
          if(integer==value){
            int add=integer ;
            total+=c ;
            a.remove(integer);
            a.add(0,add);
            break ;
          }
        }
      }
    }
    System.out.println(total);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var n : int ; n := input.nextInt() ;
    var m : int ; m := input.nextInt() ;
    var k : int ; k := input.nextInt() ;
    var a : Sequence(int) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < k do ( (     a := a->including(input.nextInt()) )  ;     i := i + 1 ) ; 
    var total : long ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     var value : int ; value := input.nextInt() ;
     var c : int ; c := 0 ;
     for (integer : a) do ( (     c := c + 1 ; 
     if (integer = value) then (     var add : int ; add := integer ;
     total := total+(c) ; 
    a := a->excludingFirst(integer) ; 
    a := a.insertAt(0+1,add) ; 
    break 
 ) else skip )  ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      if(a[i] % 2==0)a[i]--;
    }
    for(int i=0 ; i<n ; i++)System.out.print(a[i]+" ");
    System.out.println("");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (a[i+1] mod 2 = 0) then     a[i+1] := a[i+1] - 1 ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Iterator ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
public class B665 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int M=in.nextInt();
    int K=in.nextInt();
    List<Integer>list=new LinkedList<>();
    for(int k=0 ; k<K ; k++){
      list.add(in.nextInt());
    }
    int answer=0 ;
    for(int n=0 ; n<N ; n++){
      for(int m=0 ; m<M ; m++){
        int a=in.nextInt();
        Iterator<Integer>iter=list.iterator();
        int b ;
        do {
          answer++;
          b=iter.next();
        }
        while(a!=b);
        iter.remove();
        list.add(0,a);
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B665 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var M : int ; M := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var k : int ; k := 0 ; while k < K do ( (     list := list->including(in.getCurrent()->toInteger()) )  ;     k := k + 1 ) ; 
    var answer : int ; answer := 0 ;
        var n : int ; n := 0 ; while n < N do ( (         var m : int ; m := 0 ; while m < M do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var iter : OclIterator ; iter := list->iterator() ;
    var b : int ;
  while true do ((     answer := answer + 1 ; 
     b := iter.next() ) ;
    if (a /= b) then skip else break) ; 
    iter := iter.remove() ; 
    list := list.insertAt(0+1,a) ; 
 )  ;     m := m + 1 ) )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1031 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int[] OR=new int[N-1];
    int[] AND=new int[N-1];
    for(int n=0 ; n<N-1 ; n++){
      OR[n]=in.nextInt();
    }
    for(int n=0 ; n<N-1 ; n++){
      AND[n]=in.nextInt();
    }
    int[] answer=new int[N];
    boolean found=false ;
    main : for(int start=0 ;
    start<4 ;
    start++){
      answer[0]=start ;
      for(int n=1 ; n<N ; n++){
        int prev=answer[n-1];
        int and=AND[n-1];
        int or=OR[n-1];
        if((prev & and)!=and ||(or & and)!=and){
          continue main ;
        }
        answer[n]=prev ^(or & ~ and);
      }
      found=true ;
      break ;
    }
    if(found){
      System.out.println("YES");
      StringBuilder out=new StringBuilder();
      for(int a : answer){
        out.append(a).append(' ');
      }
      System.out.println(out);
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1031 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var OR : Sequence(int) ; OR := Integer.subrange(1,N - 1)->collect(0) ;
    var AND : Sequence(int) ; AND := Integer.subrange(1,N - 1)->collect(0) ;
        var n : int ; n := 0 ; while n < N - 1 do ( (     OR[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
        var n : int ; n := 0 ; while n < N - 1 do ( (     AND[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var answer : Sequence(int) ; answer := Integer.subrange(1,N)->collect(0) ;
    var found : boolean ; found := false ;
        var start : int ; start := 0 ; while start < 4 do ( (     answer[0+1] := start ; 
         var n : int ; n := 1 ; while n < N do ( (     var prev : int ; prev := answer[n - 1+1] ;
     var and : int ; and := AND[n - 1+1] ;
    var or : int ; or := OR[n - 1+1] ;
    if ((MathLib.bitwiseAnd(prev,and)) /= and or (MathLib.bitwiseAnd(or,and)) /= and) then (     continue ) else skip ; 
    answer[n+1] := MathLib.bitwiseXor(prev,(MathLib.bitwiseAnd(or,-(and + 1)))) ; 
 )  ;     n := n + 1 ) ; 
     found := true ; 
     break )  ;     start := start + 1 ) ; 
    if (found) then (     OclFile["System.out"].println("YES") ; 
     var out : String ; out := StringLib.newString() ;
     for (a : answer) do ( (     out := out + StringLib.newString(a) + StringLib.newString(' ') )  ) ; 
     OclFile["System.out"].println(out) ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int number_of_digits(int n){
    int i ;
    int res ;
    int sum=0 ;
    for(i=4,res=1 ; ; i*=4,res++){
      sum+=i ;
      if(sum>=n)break ;
    }
    return res ;
  }
  public static void main(String[] args){
    int n=21 ;
    System.out.println(number_of_digits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation number_of_digits( n : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
     var res : int ;
    var sum : int ; sum := 0 ;
        i := 4 ;     res := 1 ; while true do ( (     sum := sum+(i) ; 
     if (sum >= n) then     break else skip )  ;     i := i*(4) ;     res := res + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 21 ;
     OclFile["System.out"].println(number_of_digits(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class A1705 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      int X=in.nextInt();
      int[] H=new int[2*N];
      for(int n=0 ; n<H.length ; n++){
        H[n]=in.nextInt();
      }
      Arrays.sort(H);
      boolean ok=true ;
      for(int n=0 ; n<N ; n++){
        ok &=(H[n]+X<=H[N+n]);
      }
      System.out.println(ok ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1705 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var X : int ; X := in.getCurrent()->toInteger() ;
    var H : Sequence(int) ; H := Integer.subrange(1,2 * N)->collect(0) ;
        var n : int ; n := 0 ; while n < H->size() do ( (     H[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    H := H->sort() ; 
    var ok : boolean ; ok := true ;
        var n : int ; n := 0 ; while n < N do ( (     ok := MathLib.bitwiseAnd(ok, (H[n+1] + X <= H[N + n+1])) )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(if ok then "YES" else "NO" endif) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    while(t!=0){
      boolean flag=true ;
      int n=input.nextInt();
      int x=input.nextInt();
      int[] array=new int[2*n+1];
      int[] book=new int[2*n+1];
      for(int i=0 ; i<2*n ; i++){
        array[i]=input.nextInt();
        book[i]=0 ;
      }
      Arrays.sort(array,0,2*n);
      int cnt=0 ;
      int l=0 ;
      int r=l+1 ;
      while(cnt<n && r<2*n){
        if(book[l]==0){
          book[l]=1 ;
        }
        if(array[l]+x<=array[r]){
          l++;
          book[r]=1 ;
          cnt++;
        }
        r++;
      }
      if(cnt<n){
        flag=false ;
      }
      if(flag)System.out.println("YES");
      else System.out.println("NO");
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
     while (t /= 0) do (     var flag : boolean ; flag := true ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var x : int ; x := input.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,2 * n + 1)->collect(0) ;
    var book : Sequence(int) ; book := Integer.subrange(1,2 * n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     array[i+1] := input.getCurrent()->toInteger() ; 
     book[i+1] := 0 )  ;     i := i + 1 ) ; 
    array := array.subrange(1,0)^(array.subrange(0+1,2 * n)->sort())^array.subrange(2 * n+1,array.size) ; 
    var cnt : int ; cnt := 0 ;
    var l : int ; l := 0 ;
    var r : int ; r := l + 1 ;
    while (cnt < n & r < 2 * n) do (     if (book[l+1] = 0) then (     book[l+1] := 1 ) else skip ; 
     if (array[l+1] + x <= array[r+1]) then (     l := l + 1 ; 
     book[r+1] := 1 ; 
     cnt := cnt + 1 ) else skip ; 
     r := r + 1 ) ; 
    if (cnt < n) then (     flag := false ) else skip ; 
    if (flag) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collection ;
import java.util.Collections ;
import java.util.Scanner ;
public class MarkThePhotographer {
  static Scanner input=new Scanner(System.in);
  public static void main(String[] args){
    int t=input.nextInt();
    while(t>0){
      solve();
      t--;
    }
  }
  public static void solve(){
    int n=input.nextInt();
    int x=input.nextInt();
    ArrayList<Integer>heights=new ArrayList<>();
    int count=n ;
    int z=n*2 ;
    for(int i=0 ; i<z ; i++){
      heights.add(input.nextInt());
    }
    Collections.sort(heights);
    ArrayList<Integer>shorts=new ArrayList<>();
    for(int i=n-1 ; i>=0 ; i--){
      shorts.add(heights.get(i));
      heights.remove(i);
    }
    ArrayList<Integer>talls=new ArrayList<>();
    for(int i=n-1 ; i>=0 ; i--){
      talls.add(heights.get(i));
      heights.remove(i);
    }
    for(int i=n-1 ; i>=0 ; i--){
      int t=talls.get(i);
      talls.remove(i);
      for(int v=shorts.size()-1 ; v>=0 ; v--){
        if((t-shorts.get(v)>=x)||(shorts.get(v)-t>=x)){
          shorts.remove(v);
          count--;
          break ;
        }
      }
    }
    if(count==0)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class MarkThePhotographer {
  static   attribute input : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := input.getCurrent()->toInteger() ;
     while (t > 0) do (     execute solve() ; 
     t := t - 1 ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := input.getCurrent()->toInteger() ;
     var x : int ; x := input.getCurrent()->toInteger() ;
    var heights : Sequence(int) ; heights := Sequence{} ;
    var count : int ; count := n ;
    var z : int ; z := n * 2 ;
        var i : int ; i := 0 ; while i < z do ( (     heights := heights->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    heights := heights->sort() ; 
    var shorts : Sequence(int) ; shorts := Sequence{} ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     shorts := shorts->including(heights->at(i+1)) ; 
     heights := heights->excludingAt(i+1) )  ;     i := i - 1 ) ; 
    var talls : Sequence(int) ; talls := Sequence{} ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     talls := talls->including(heights->at(i+1)) ; 
     heights := heights->excludingAt(i+1) )  ;     i := i - 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     var t : int ; t := talls->at(i+1) ;
     talls := talls->excludingAt(i+1) ; 
         var v : int ; v := shorts->size() - 1 ; while v >= 0 do ( (     if ((t - shorts->at(v+1) >= x) or (shorts->at(v+1) - t >= x)) then (     shorts := shorts->excludingAt(v+1) ; 
     count := count - 1 ; 
     break ) else skip )  ;     v := v - 1 ) )  ;     i := i - 1 ) ; 
    if (count = 0) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int maxSum(int a[],int n){
    Arrays.sort(a);
    int sum=0 ;
    for(int i=0 ; i<n-1 ; i+=2){
      sum+=a[i];
    }
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      1,3,2,1,4,5 };
      int n=arr.length ;
      System.out.println(maxSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSum( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     sum := sum+(a[i+1]) )  ;     i := i+(2) ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,2,1,4,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
import java.lang.Character ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int t=cin.nextInt();
    while(t-->0){
      boolean done=true ;
      int n=cin.nextInt();
      int x=cin.nextInt();
      int arr[]=new int[n*2];
      for(int i=0 ; i<n*2 ; i++){
        arr[i]=cin.nextInt();
      }
      Arrays.sort(arr);
      for(int i=0 ; i<n ; i++){
        if(arr[i+n]-arr[i]<x){
          done=false ;
        }
      }
      if(done){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := cin.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var done : boolean ; done := true ;
     var n : int ; n := cin.getCurrent()->toInteger() ;
    var x : int ; x := cin.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n * 2)->collect(0) ;
        var i : int ; i := 0 ; while i < n * 2 do ( (     arr[i+1] := cin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i + n+1] - arr[i+1] < x) then (     done := false ) else skip )  ;     i := i + 1 ) ; 
    if (done) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int x=sc.nextInt();
      int[] heights=new int[2*n];
      for(int idx=0 ; idx<2*n ; idx++)heights[idx]=sc.nextInt();
      Arrays.sort(heights);
      System.out.println(diffPossible(heights,x,n)? "YES" : "NO");
    }
  }
  public static boolean diffPossible(int[] heights,int x,int n){
    for(int idx=0 ; idx<n ; idx++){
      if(heights[idx+n]-heights[idx]<x)return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var heights : Sequence(int) ; heights := Integer.subrange(1,2 * n)->collect(0) ;
        var idx : int ; idx := 0 ; while idx < 2 * n do (     heights[idx+1] := sc.getCurrent()->toInteger() ;  ;     idx := idx + 1 ) ; 
    heights := heights->sort() ; 
    OclFile["System.out"].println(if diffPossible(heights, x, n) then "YES" else "NO" endif) ; 
 ) ;  ) );
  static   operation diffPossible( heights : Sequence(int), x : int, n : int) : boolean
  pre: true
  post: true
  activity: (         var idx : int ; idx := 0 ; while idx < n do ( (     if (heights[idx + n+1] - heights[idx+1] < x) then     return false else skip )  ;     idx := idx + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Books {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,m ;
    int arr[]=new int[100001];
    n=sc.nextInt();
    m=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    int sum=0,mx=0,count=0 ;
    int l=0,r=0 ;
    while(r<n){
      sum+=arr[r++];
      count++;
      if(sum>m){
        sum-=arr[l++];
        count--;
      }
      if(mx<count)mx=count ;
    }
    System.out.println(mx);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Books {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var m : int ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,100001)->collect(0) ;
    n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var mx : int ; mx := 0 ;
    var count : int ; count := 0 ;
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    while (r < n) do (      sum := sum + arr[r+1]  ; r := r + 1 ; 
     count := count + 1 ; 
     if (sum > m) then (      sum := sum - (arr[l+1])  ; l := l + 1 ; 
     count := count - 1 ) else skip ; 
     if (mx < count) then     mx := count ; else skip ) ; 
    OclFile["System.out"].println(mx) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Books {
  public static void main(String[] args)throws IOException {
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer stringTokenizer=new StringTokenizer(bufferedReader.readLine());
    int n=Integer.parseInt(stringTokenizer.nextToken());
    int t=Integer.parseInt(stringTokenizer.nextToken());
    stringTokenizer=new StringTokenizer(bufferedReader.readLine());
    int[] books=new int[n];
    for(int i=0 ; i<n ; i++)books[i]=Integer.parseInt(stringTokenizer.nextToken());
    int answer=0 ;
    int right=0 ;
    int rangeSum=0 ;
    for(int left=0 ; left<n ; left++){
      while(right<n && rangeSum+books[right]<=t){
        rangeSum+=books[right];
        right++;
      }
      if(answer<right-left)answer=right-left ;
      rangeSum-=books[left];
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Books {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var stringTokenizer : OclIterator ; stringTokenizer := OclIterator.newOclIterator_String(bufferedReader.readLine()) ;
    var n : int ; n := (stringTokenizer.next())->toInteger() ;
    var t : int ; t := (stringTokenizer.next())->toInteger() ;
    stringTokenizer := OclIterator.newOclIterator_String(bufferedReader.readLine()) ; 
    var books : Sequence(int) ; books := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     books[i+1] := (stringTokenizer.next())->toInteger() ;  ;     i := i + 1 ) ; 
    var answer : int ; answer := 0 ;
    var right : int ; right := 0 ;
    var rangeSum : int ; rangeSum := 0 ;
        var left : int ; left := 0 ; while left < n do ( (     while (right < n & rangeSum + books[right+1] <= t) do (     rangeSum := rangeSum+(books[right+1]) ; 
     right := right + 1 ) ; 
     if (answer < right - left) then     answer := right - left ; else skip ; 
     rangeSum := rangeSum-(books[left+1]) )  ;     left := left + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.*;
public class App {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws Exception {
    if(System.getProperty("ONLINE_JUDGE")==null){
      File inputFile=new File("/Users/vipinjain/self/cp/input.txt");
      File outputFile=new File("/Users/vipinjain/self/cp/output.txt");
      br=new BufferedReader(new FileReader(inputFile));
      bw=new BufferedWriter(new FileWriter(outputFile));
    }
    int tests ;
    tests=1 ;
    while(tests-->0){
      solve();
    }
    bw.flush();
    bw.close();
    br.close();
  }
  static void solve()throws Exception {
    int n=Integer.parseInt(br.readLine());
    int[] arr=Stream.of(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; ++i){
      int num=(arr[i] & 1)==0 ? arr[i]-1 : arr[i];
      sb.append(num+" ");
    }
    bw.write(sb.toString().trim());
  }
  static int gcd(int a,int b){
    if(a==0){
      return b ;
    }
    return gcd(b % a,a);
  }
  static boolean isPrime(long n){
    for(long i=2 ; i*i<=n ; i++){
      if(n % i==0){
        return false ;
      }
    }
    return true ;
  }
  static long minDivisor(long n){
    for(long i=2 ; i*i<=n ; ++i){
      if(n % i==0){
        return i ;
      }
    }
    return n ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null) then (     var inputFile : OclFile ; inputFile := OclFile("/Users/vipinjain/self/cp/input.txt") ;
     var outputFile : OclFile ; outputFile := OclFile("/Users/vipinjain/self/cp/output.txt") ;
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputFile)) ; 
     bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputFile)) ) else skip ; 
     var tests : int ;
    tests := 1 ; 
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var arr : Sequence(int) ; arr := Sequence{br.readLine()->split(" ")}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := if (MathLib.bitwiseAnd(arr[i+1],1)) = 0 then arr[i+1] - 1 else arr[i+1] endif ;
     sb := sb + StringLib.newString(num + " ") )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then (     return b ) else skip ; 
     return gcd(b mod a, a) );
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (         var i : long ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation minDivisor( n : long) : long
  pre: true
  post: true
  activity: (         var i : long ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     return i ) else skip )  ;     i := i + 1 ) ; 
     return n );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Books {
  public static void main(String[] args)throws IOException {
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer stringTokenizer=new StringTokenizer(bufferedReader.readLine());
    int n=Integer.parseInt(stringTokenizer.nextToken());
    int t=Integer.parseInt(stringTokenizer.nextToken());
    stringTokenizer=new StringTokenizer(bufferedReader.readLine());
    int[] books=new int[n];
    for(int i=0 ; i<n ; i++)books[i]=Integer.parseInt(stringTokenizer.nextToken());
    int answer=0 ;
    int right=0 ;
    int rangeSum=0 ;
    for(int left=0 ; left<n ; left++){
      while(right<n && rangeSum+books[right]<=t){
        rangeSum+=books[right];
        right++;
      }
      if(answer<right-left){
        answer=right-left ;
      }
      rangeSum-=books[left];
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Books {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var stringTokenizer : OclIterator ; stringTokenizer := OclIterator.newOclIterator_String(bufferedReader.readLine()) ;
    var n : int ; n := (stringTokenizer.next())->toInteger() ;
    var t : int ; t := (stringTokenizer.next())->toInteger() ;
    stringTokenizer := OclIterator.newOclIterator_String(bufferedReader.readLine()) ; 
    var books : Sequence(int) ; books := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     books[i+1] := (stringTokenizer.next())->toInteger() ;  ;     i := i + 1 ) ; 
    var answer : int ; answer := 0 ;
    var right : int ; right := 0 ;
    var rangeSum : int ; rangeSum := 0 ;
        var left : int ; left := 0 ; while left < n do ( (     while (right < n & rangeSum + books[right+1] <= t) do (     rangeSum := rangeSum+(books[right+1]) ; 
     right := right + 1 ) ; 
     if (answer < right - left) then (     answer := right - left ) else skip ; 
     rangeSum := rangeSum-(books[left+1]) )  ;     left := left + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B_Books {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),t=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    System.out.println(max(arr,n,t));
  }
  public static int max(int[] arr,int n,int t){
    int l=0,sum=0,res=0 ;
    for(int r=0 ; r<n ; r++){
      sum+=arr[r];
      while(sum>t){
        sum-=arr[l++];
      }
      res=Math.max(r-l+1,res);
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Books {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{arr, n, t}->max()) ; 
 );
  static   operation max( arr : Sequence(int), n : int, t : int) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
    var sum : int ; sum := 0 ;
    var res : int ; res := 0 ;
         var r : int ; r := 0 ; while r < n do ( (     sum := sum+(arr[r+1]) ; 
     while (sum > t) do (      sum := sum - (arr[l+1])  ; l := l + 1 ) ; 
     res := Set{r - l + 1, res}->max() )  ;     r := r + 1 ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class LexoSmallest {
  static boolean compareSeq(char[] S,int x,int y,int n){
    for(int i=0 ; i<n ; i++){
      if(S[x]<S[y])return false ;
      else if(S[x]>S[y])return true ;
      x=(x+1)% n ;
      y=(y+1)% n ;
    }
    return true ;
  }
  static int smallestSequence(char[] S,int n){
    int index=0 ;
    for(int i=1 ; i<n ; i++)if(compareSeq(S,index,i,n))index=i ;
    return index ;
  }
  static void printSmallestSequence(String str,int n){
    char[] S=str.toCharArray();
    int starting_index=smallestSequence(S,n);
    for(int i=0 ; i<n ; i++)System.out.print(S[(starting_index+i)% n]);
  }
  public static void main(String[] args){
    String S="DCACBCAA" ;
    int n=8 ;
    printSmallestSequence(S,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class LexoSmallest {
  static   operation compareSeq( S : Sequence(String), x : int, y : int, n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (S[x+1] < S[y+1]) then     return false else     if (S[x+1] > S[y+1]) then     return true else skip ; ;  
     x := (x + 1) mod n ; 
     y := (y + 1) mod n )  ;     i := i + 1 ) ; 
     return true );
  static   operation smallestSequence( S : Sequence(String), n : int) : int
  pre: true
  post: true
  activity: (     var index : int ; index := 0 ;
         var i : int ; i := 1 ; while i < n do (     if (compareSeq(S, index, i, n)) then     index := i ; else skip ;  ;     i := i + 1 ) ; 
     return index );
  static   operation printSmallestSequence( str : String, n : int) : void
  pre: true
  post: true
  activity: (     var S : Sequence(String) ; S := str->characters() ;
     var starting_index : int ; starting_index := smallestSequence(S, n) ;
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(S[(starting_index + i) mod n+1]) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := "DCACBCAA" ;
     var n : int ; n := 8 ;
     execute printSmallestSequence(S, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    in.nextLine();
    String s=in.nextLine();
    char arr[]=s.toCharArray();
    boolean x=false ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]=='?' && i==0)x=true ;
      else if(arr[i]=='?' && i==n-1){
        x=true ;
        break ;
      }
      else if(arr[i]=='?' && arr[i+1]=='?')x=true ;
      else if(arr[i]=='?' && arr[i]>0 && arr[i-1]==arr[i+1])x=true ;
      else if(i+1!=n && arr[i]==arr[i+1]){
        x=false ;
        break ;
      }
    }
    if(x==true)System.out.println("yes");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    skip ; 
    var s : String ; s := in.nextLine() ;
    var arr : Sequence(String) ; arr := s->characters() ;
    var x : boolean ; x := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = '?' & i = 0) then     x := true ; else     if (arr[i+1] = '?' & i = n - 1) then (     x := true ; 
     break ) else     if (arr[i+1] = '?' & arr[i + 1+1] = '?') then     x := true else     if (arr[i+1] = '?' & arr[i+1] > 0 & arr[i - 1+1] = arr[i + 1+1]) then     x := true else     if (i + 1 /= n & arr[i+1] = arr[i + 1+1]) then (     x := false ; 
     break ) else skip ; ;  ;  ;  )  ;     i := i + 1 ) ; 
    if (x = true) then     OclFile["System.out"].println("yes") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.regex.*;
public class vk18 {
  public static void main(String[] stp)throws Exception {
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    String na=scan.next();
    if(na.contains("CC")|| na.contains("YY")|| na.contains("MM")){
      System.out.println("NO");
      System.exit(0);
    }
    else {
      if(na.contains("??")|| na.contains("C?C")|| na.contains("M?M")|| na.contains("Y?Y")|| na.startsWith("?")|| na.endsWith("?"))System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class vk18 {
  static   operation main( stp : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
     var na : String ; na := scan.getCurrent() ;
     if (na->includes("CC") or na->includes("YY") or na->includes("MM")) then (     OclFile["System.out"].println("NO") ; 
 OclProcess.exit(0) ) else (     if (na->includes("??") or na->includes("C?C") or na->includes("M?M") or na->includes("Y?Y") or na->hasPrefix("?") or na->hasSuffix("?")) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int maxSum(int arr[],int n){
    Arrays.sort(arr);
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=(arr[i]*i);
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      3,5,6,1 };
      int n=arr.length ;
      System.out.println(maxSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+((arr[i+1] * i)) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,5,6,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class calc {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String str=in.next();
    if(str.contains("CC")|| str.contains("YY")|| str.contains("MM")){
      System.out.println("No");
      return ;
    }
    if(str.startsWith("?")|| str.endsWith("?")|| str.contains("??")|| str.contains("C?C")|| str.contains("Y?Y")|| str.contains("M?M"))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class calc {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var str : String ; str := in.getCurrent() ;
    if (str->includes("CC") or str->includes("YY") or str->includes("MM")) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
    if (str->hasPrefix("?") or str->hasSuffix("?") or str->includes("??") or str->includes("C?C") or str->includes("Y?Y") or str->includes("M?M")) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int time=scan.nextInt();
    int planA=scan.nextInt();
    int planB=scan.nextInt();
    if(time*planA>=planB){
      System.out.println(planB);
    }
    else {
      System.out.println(time*planA);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var time : int ; time := scan.getCurrent()->toInteger() ;
    var planA : int ; planA := scan.getCurrent()->toInteger() ;
    var planB : int ; planB := scan.getCurrent()->toInteger() ;
    if (time * planA >= planB) then (     OclFile["System.out"].println(planB) ) else (     OclFile["System.out"].println(time * planA) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solveA();
  }
  private void solveA(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int A=sc.nextInt();
    int B=sc.nextInt();
    int a=(A*N);
    if(a>B){
      System.out.println(B);
    }
    else if(a==B){
      System.out.println(a);
    }
    else {
      System.out.println(a);
    }
  }
  private void solveB(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println(N);
  }
  private void solveC(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println(N);
  }
  private void solveD(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println(N);
  }
  private void solveE(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println(N);
  }
  private void solveF(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solveA() );
   operation solveA() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var a : int ; a := (A * N) ;
    if (a > B) then (     OclFile["System.out"].println(B) ) else     if (a = B) then (     OclFile["System.out"].println(a) ) else (     OclFile["System.out"].println(a) ) ;  ;  
 );
   operation solveB() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N) );
   operation solveC() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N) );
   operation solveD() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N) );
   operation solveE() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N) );
   operation solveF() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int a=in.nextInt();
      int b=in.nextInt();
      int ans=n*a>b ? b : n*a ;
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var ans : int ; ans := if n * a > b then b else n * a endif ;
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    int plun1=n*a ;
    int plun2=b ;
    System.out.println(Math.min(plun1,plun2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var a : int ; a := (sc.getCurrent())->toInteger() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    var plun1 : int ; plun1 := n * a ;
    var plun2 : int ; plun2 := b ;
    OclFile["System.out"].println(Set{plun1, plun2}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void find(int ar[]){
    for(int i=0 ; i<ar.length ; i++){
      if(ar[i] % 2==0){
        ar[i]=ar[i]-1 ;
      }
    }
    for(int i=0 ; i<ar.length ; i++){
      System.out.print(ar[i]+" ");
    }
  }
  public static void main(String[] args){
    try {
      System.setIn(new FileInputStream("input.txt"));
      System.setOut(new PrintStream(new FileOutputStream("output.txt")));
    }
    catch(Exception e){
      System.err.println("Error");
    }
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int ar[]=new int[n];
    for(int i=0 ; i<n ; i++){
      ar[i]=sc.nextInt();
    }
    find(ar);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation find( ar : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < ar->size() do ( (     if (ar[i+1] mod 2 = 0) then (     ar[i+1] := ar[i+1] - 1 ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < ar->size() do ( (     OclFile["System.out"].print(ar[i+1] + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) )   catch (e : ProgramException) do (     OclFile["System.err"].println("Error") )
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute find(ar) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solveA();
  }
  private void solveA(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int A=sc.nextInt();
    int B=sc.nextInt();
    int NA=N*A ;
    if(NA>B){
      System.out.println(B);
    }
    else {
      System.out.println(NA);
    }
  }
  private void solveB(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println(N);
  }
  private void solveC(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println(N);
  }
  private void solveD(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println(N);
  }
  private void solveE(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println(N);
  }
  private void solveF(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    System.out.println(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solveA() );
   operation solveA() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var NA : int ; NA := N * A ;
    if (NA > B) then (     OclFile["System.out"].println(B) ) else (     OclFile["System.out"].println(NA) ) ;  
 );
   operation solveB() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N) );
   operation solveC() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N) );
   operation solveD() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N) );
   operation solveE() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N) );
   operation solveF() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Random ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    char[] line=fs.next().toCharArray();
    int sum=0 ;
    for(char c : line)sum+=c-'0' ;
    System.out.println(sum % 9==0 ? "Yes" : "No");
  }
  static final Random random=new Random();
  static void ruffleSort(int[] a){
    int n=a.length ;
    for(int i=0 ; i<n ; i++){
      int oi=random.nextInt(n),temp=a[oi];
      a[oi]=a[i];
      a[i]=temp ;
    }
    Arrays.sort(a);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var line : Sequence(String) ; line := fs.next()->characters() ;
    var sum : int ; sum := 0 ;
    for (c : line) do (     sum := sum+(c - ('0')->char2byte()) ;  ) ; 
    OclFile["System.out"].println(if sum mod 9 = 0 then "Yes" else "No" endif) ; 
 );
  static    attribute random : OclRandom := OclRandom.newOclRandom();
  static   operation ruffleSort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() ;
         var i : int ; i := 0 ; while i < n do ( (     var oi : int ; oi := random.nextInt(n) ;
    var temp : int ; temp := a[oi+1] ;
     a[oi+1] := a[i+1] ; 
     a[i+1] := temp )  ;     i := i + 1 ) ; 
     a := a->sort() );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(new BufferedInputStream(System.in));
    BigInteger a=sc.nextBigInteger();
    BigInteger n=new BigInteger("9");
    if((a.mod(n)).compareTo(BigInteger.ZERO)==0)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var a : long ; a := sc.nextBigInteger() ;
     var n : long ; n := long("9") ;
     if ((a.mod(n))->compareTo(0) = 0) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    String s=sc.next();
    int sum=0 ;
    for(int i=0 ; i<s.length(); i++){
      sum=sum+(s.charAt(i)-'0');
    }
    if(sum % 9==0){
      out.println("Yes");
    }
    else {
      out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var s : String ; s := sc.getCurrent() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     sum := sum + (s->at(i+1) - ('0')->char2byte()) )  ;     i := i + 1 ) ; 
    if (sum mod 9 = 0) then (     out.println("Yes") ) else (     out.println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class GFG {
  static int findSum(int arr[],int n){
    Arrays.sort(arr);
    int sum=arr[0];
    for(int i=0 ; i<n-1 ; i++){
      if(arr[i]!=arr[i+1]){
        sum=sum+arr[i+1];
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,1,1,4,5,6 };
      int n=arr.length ;
      System.out.println(findSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var sum : int ; sum := arr[0+1] ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] /= arr[i + 1+1]) then (     sum := sum + arr[i + 1+1] ) else skip )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,1,1,4,5,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String args[])throws Exception {
    MyScanner sc=new MyScanner();
    PrintWriter pr=new PrintWriter(System.out);
    String s=sc.next();
    long sum=0 ;
    for(char ch : s.toCharArray())sum+=Integer.parseInt(ch+"");
    pr.print((sum % 9==0)? "Yes" : "No");
    pr.close();
  }
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : String ; s := sc.next() ;
    var sum : long ; sum := 0 ;
    for (ch : s->characters()) do (     sum := sum+((ch + "")->toInteger()) ;  ) ; 
    skip ; 
    skip ; 
 );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
public class Main {
  static void solve(){
    Scanner sc=new Scanner(System.in);
    BigInteger b=BigInteger.ZERO ;
    BigInteger NINE=new BigInteger("9");
    for(char ch : sc.next().toCharArray())b=b.add(new BigInteger(""+ch));
    System.out.println(b.mod(NINE).equals(BigInteger.ZERO)? "Yes" : "No");
    sc.close();
  }
  public static void main(String args[]){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var b : long ; b := 0 ;
    var NINE : long ; NINE := long("9") ;
    for (ch : sc.getCurrent()->characters()) do (     b := b->excludes(long("" + ch)) ;  ) ; 
    OclFile["System.out"].println(if b.mod(NINE) = 0 then "Yes" else "No" endif) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Harry_Potter_And_Three_Spells_Kamel {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    int e=sc.nextInt();
    int f=sc.nextInt();
    if(b*d*f>a*c*e ||(a==0 && c!=0 && b!=0 && d!=0)||(c==0 && d!=0)||(e==0 && f!=0 && d!=0 && b!=0)){
      System.out.println("Ron");
    }
    else {
      System.out.println("Hermione");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Harry_Potter_And_Three_Spells_Kamel {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var e : int ; e := sc.getCurrent()->toInteger() ;
    var f : int ; f := sc.getCurrent()->toInteger() ;
    if (b * d * f > a * c * e or (a = 0 & c /= 0 & b /= 0 & d /= 0) or (c = 0 & d /= 0) or (e = 0 & f /= 0 & d /= 0 & b /= 0)) then (     OclFile["System.out"].println("Ron") ) else (     OclFile["System.out"].println("Hermione") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    a65 solver=new a65();
    solver.solve(1,in,out);
    out.close();
  }
  static class a65 {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int a=in.nextInt();
      int b=in.nextInt();
      int c=in.nextInt();
      int d=in.nextInt();
      int e=in.nextInt();
      int f=in.nextInt();
      int next=b*d*f ;
      int prev=a*c*e ;
      if(c==0 && d>0){
        out.println("Ron");
        return ;
      }
      if(a==0 && b>0 && d>0){
        out.println("Ron");
        return ;
      }
      if(prev>=next){
        out.println("Hermione");
        return ;
      }
      out.println("Ron");
    }
  }
  static class InputReader {
    private BufferedReader reader ;
    private StringTokenizer stt ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream));
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        return null ;
      }
    }
    public String next(){
      while(stt==null || ! stt.hasMoreTokens()){
        stt=new StringTokenizer(nextLine());
      }
      return stt.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : a65 ; solver := a65.newa65() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class a65 {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.nextInt() ;
     var b : int ; b := in.nextInt() ;
    var c : int ; c := in.nextInt() ;
    var d : int ; d := in.nextInt() ;
    var e : int ; e := in.nextInt() ;
    var f : int ; f := in.nextInt() ;
    var next : int ; next := b * d * f ;
    var prev : int ; prev := a * c * e ;
    if (c = 0 & d > 0) then (     skip ; 
     return ) else skip ; 
    if (a = 0 & b > 0 & d > 0) then (     skip ; 
     return ) else skip ; 
    if (prev >= next) then (     skip ; 
     return ) else skip ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute stt : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     return null )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (stt = null or not(stt.hasNext())) do (     stt := OclIterator.newOclIterator_String(nextLine()) ) ; 
     return stt.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.*;
import java.util.function.BiConsumer ;
import java.util.function.Consumer ;
import java.util.function.Function ;
import java.util.stream.*;
public class Main {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    int c=Integer.parseInt(sc.next());
    int d=Integer.parseInt(sc.next());
    int e=Integer.parseInt(sc.next());
    int f=Integer.parseInt(sc.next());
    if(d==0){
      System.out.println("Hermione");
    }
    else if(c==0){
      System.out.println("Ron");
    }
    else if(b==0){
      System.out.println("Hermione");
    }
    else if(a==0){
      System.out.println("Ron");
    }
    else if(f==0){
      System.out.println("Hermione");
    }
    else if(e==0){
      System.out.println("Ron");
    }
    else {
      double per=1.0*b/a*d/c*f/e ;
      if(per>1.0){
        System.out.println("Ron");
      }
      else {
        System.out.println("Hermione");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := (sc.getCurrent())->toInteger() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    var c : int ; c := (sc.getCurrent())->toInteger() ;
    var d : int ; d := (sc.getCurrent())->toInteger() ;
    var e : int ; e := (sc.getCurrent())->toInteger() ;
    var f : int ; f := (sc.getCurrent())->toInteger() ;
    if (d = 0) then (     OclFile["System.out"].println("Hermione") ) else     if (c = 0) then (     OclFile["System.out"].println("Ron") ) else     if (b = 0) then (     OclFile["System.out"].println("Hermione") ) else     if (a = 0) then (     OclFile["System.out"].println("Ron") ) else     if (f = 0) then (     OclFile["System.out"].println("Hermione") ) else     if (e = 0) then (     OclFile["System.out"].println("Ron") ) else (     var per : double ; per := 1.0 * b / a * d / c * f / e ;
     if (per > 1.0) then (     OclFile["System.out"].println("Ron") ) else (     OclFile["System.out"].println("Hermione") ) ) ;  ;  ;  ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[])throws Exception {
    Scanner cin=new Scanner(System.in);
    int a=cin.nextInt(),b=cin.nextInt(),c=cin.nextInt(),d=cin.nextInt(),e=cin.nextInt(),f=cin.nextInt();
    if((a*c*e<b*d*f)||((a==0)&&(b*d>0))||(c==0)&&(d>0))System.out.println("Ron");
    else System.out.println("Hermione");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := cin.getCurrent()->toInteger() ;
    var b : int ; b := cin.getCurrent()->toInteger() ;
    var c : int ; c := cin.getCurrent()->toInteger() ;
    var d : int ; d := cin.getCurrent()->toInteger() ;
    var e : int ; e := cin.getCurrent()->toInteger() ;
    var f : int ; f := cin.getCurrent()->toInteger() ;
     if ((a * c * e < b * d * f) or ((a = 0) & (b * d > 0)) or (c = 0) & (d > 0)) then     OclFile["System.out"].println("Ron") ; else     OclFile["System.out"].println("Hermione") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countStrUtil(int[][][] dp,int n,int bCount,int cCount){
    if(bCount<0 || cCount<0){
      return 0 ;
    }
    if(n==0){
      return 1 ;
    }
    if(bCount==0 && cCount==0){
      return 1 ;
    }
    if(dp[n][bCount][cCount]!=-1){
      return dp[n][bCount][cCount];
    }
    int res=countStrUtil(dp,n-1,bCount,cCount);
    res+=countStrUtil(dp,n-1,bCount-1,cCount);
    res+=countStrUtil(dp,n-1,bCount,cCount-1);
    return(dp[n][bCount][cCount]=res);
  }
  static int countStr(int n,int bCount,int cCount){
    int[][][] dp=new int[n+1][2][3];
    for(int i=0 ; i<n+1 ; i++){
      for(int j=0 ; j<2 ; j++){
        for(int k=0 ; k<3 ; k++){
          dp[i][j][k]=-1 ;
        }
      }
    }
    return countStrUtil(dp,n,bCount,cCount);
  }
  public static void main(String[] args){
    int n=3 ;
    int bCount=1,cCount=2 ;
    System.out.println(countStr(n,bCount,cCount));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countStrUtil( dp : Sequence(Sequence(Sequence(int))), n : int, bCount : int, cCount : int) : int
  pre: true
  post: true
  activity: (     if (bCount < 0 or cCount < 0) then (     return 0 ) else skip ; 
     if (n = 0) then (     return 1 ) else skip ; 
    if (bCount = 0 & cCount = 0) then (     return 1 ) else skip ; 
    if (dp[n+1][bCount+1][cCount+1] /= -1) then (     return dp[n+1][bCount+1][cCount+1] ) else skip ; 
    var res : int ; res := countStrUtil(dp, n - 1, bCount, cCount) ;
    res := res+(countStrUtil(dp, n - 1, bCount - 1, cCount)) ; 
    res := res+(countStrUtil(dp, n - 1, bCount, cCount - 1)) ; 
    return (dp[n+1][bCount+1][cCount+1]) 
 );
  static   operation countStr( n : int, bCount : int, cCount : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(Sequence(int))) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,2)->collect(Integer.subrange(1,3)->collect(0))) ;
         var i : int ; i := 0 ; while i < n + 1 do ( (         var j : int ; j := 0 ; while j < 2 do ( (         var k : int ; k := 0 ; while k < 3 do ( (     dp[i+1][j+1][k+1] := -1 )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return countStrUtil(dp, n, bCount, cCount) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var bCount : int ; bCount := 1 ;
    var cCount : int ; cCount := 2 ;
     OclFile["System.out"].println(countStr(n, bCount, cCount)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class general {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long w=sc.nextLong(),h=sc.nextLong();
      List<Long>max=new ArrayList<>();
      for(long i=1 ; i<=4 ; i++){
        long k=sc.nextLong();
        List<Long>list=new ArrayList<>();
        for(long j=0 ; j<k ; j++)list.add(sc.nextLong());
        max.add(list.get(list.size()-1)-list.get(0));
      }
      long max_area=Math.max(max.get(0)*h,Math.max(max.get(1)*h,Math.max(max.get(2)*w,max.get(3)*w)));
      System.out.println(max_area);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class general {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var w : long ; w := sc.getCurrent()->toLong() ;
    var h : long ; h := sc.getCurrent()->toLong() ;
     var max : Sequence(long) ; max := Sequence{} ;
        var i : long ; i := 1 ; while i <= 4 do ( (     var k : long ; k := sc.getCurrent()->toLong() ;
     var list : Sequence(long) ; list := Sequence{} ;
         var j : long ; j := 0 ; while j < k do (     list := list->including(sc.getCurrent()->toLong()) ;  ;     j := j + 1 ) ; 
     max := max->including(list->at(list->size() - 1+1) - list->at(0+1)) )  ;     i := i + 1 ) ; 
    var max_area : long ; max_area := Set{max->at(0+1) * h, Set{max->at(1+1) * h, Set{max->at(2+1) * w, max->at(3+1) * w}->max()}->max()}->max() ;
    OclFile["System.out"].println(max_area) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  public static void main(String[] args)throws IOException {
    Reader sc=new Reader();
    PrintWriter out=new PrintWriter(System.out);
    long t=sc.nextLong();
    while(t-->0){
      long w=sc.nextLong(),h=sc.nextLong();
      List<Long>max=new ArrayList<>();
      for(int i=1 ; i<=4 ; i++){
        long k=sc.nextLong();
        List<Long>list=new ArrayList<>();
        for(long j=0 ; j<k ; j++)list.add(sc.nextLong());
        max.add(list.get(list.size()-1)-list.get(0));
      }
      Long max_area=Math.max(max.get(0)*h,Math.max(max.get(1)*h,Math.max(max.get(2)*w,max.get(3)*w)));
      out.println(max_area);
      out.flush();
    }
  }
  static class Reader {
    BufferedReader br ;
    StringTokenizer st ;
    public Reader(){
      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 {
        if(st.hasMoreTokens())str=st.nextToken("\n");
        else str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var t : long ; t := sc.getCurrent()->toLong() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var w : long ; w := sc.getCurrent()->toLong() ;
    var h : long ; h := sc.getCurrent()->toLong() ;
     var max : Sequence(long) ; max := Sequence{} ;
        var i : int ; i := 1 ; while i <= 4 do ( (     var k : long ; k := sc.getCurrent()->toLong() ;
     var list : Sequence(long) ; list := Sequence{} ;
         var j : long ; j := 0 ; while j < k do (     list := list->including(sc.getCurrent()->toLong()) ;  ;     j := j + 1 ) ; 
     max := max->including(list->at(list->size() - 1+1) - list->at(0+1)) )  ;     i := i + 1 ) ; 
    var max_area : long ; max_area := Set{max->at(0+1) * h, Set{max->at(1+1) * h, Set{max->at(2+1) * w, max->at(3+1) * w}->max()}->max()}->max() ;
    skip ; 
    skip ; 
 ) ;  ) );
  static class Reader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newReader() : Reader
  pre: true
  post: true
  activity:
  ( var self : Reader ;
    self := createReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then     str := st.nextToken("\n") ; else     str := br.readLine() ; )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int MAX=10000 ;
  static Vector<Integer>arr=new Vector<Integer>();
  static void SieveOfEratosthenes(){
    boolean[] prime=new boolean[MAX];
    for(int i=0 ; i<MAX ; i++)prime[i]=true ;
    for(int p=2 ; p*p<MAX ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<MAX ; i+=p)prime[i]=false ;
      }
    }
    for(int p=2 ; p<MAX ; p++)if(prime[p])arr.add(p);
  }
  static boolean isEuclid(long n){
    long product=1 ;
    int i=0 ;
    while(product<n){
      product=product*arr.get(i);
      if(product+1==n)return true ;
      i++;
    }
    return false ;
  }
  public static void main(String[] args){
    SieveOfEratosthenes();
    long n=31 ;
    if(isEuclid(n))System.out.println("YES");
    else System.out.println("NO");
    n=42 ;
    if(isEuclid(n))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX : int := 10000;
  static   attribute arr : Sequence(int) := Sequence{};
  static   operation SieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,MAX)->collect(false) ;
         var i : int ; i := 0 ; while i < MAX do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
         var p : int ; p := 2 ; while p * p < MAX do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i < MAX do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
         var p : int ; p := 2 ; while p < MAX do (     if (prime[p+1]) then     arr := arr->including(p) ; else skip ;  ;     p := p + 1 ) );
  static   operation isEuclid( n : long) : boolean
  pre: true
  post: true
  activity: (     var product : long ; product := 1 ;
     var i : int ; i := 0 ;
     while (product < n) do (     product := product * arr->at(i+1) ; 
     if (product + 1 = n) then     return true else skip ; 
     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes() ; 
     var n : long ; n := 31 ;
    if (isEuclid(n)) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
    n := 42 ; 
    if (isEuclid(n)) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int nextGap(int gap){
    if(gap<=1)return 0 ;
    return(int)((gap/2)+(gap % 2));
  }
  static void mergeTwoSortedArray(int[] arr1,int[] arr2,int n,int m){
    int x=Math.min(n,m);
    for(int i=0 ; i<x ; i++){
      if(arr1[n-i-1]>arr2[i]){
        int temp=arr1[n-i-1];
        arr1[n-i-1]=arr2[i];
        arr2[i]=temp ;
      }
    }
    for(int gap=nextGap(n); gap>0 ; gap=nextGap(gap)){
      for(int i=0 ; i+gap<n ; i++)if(arr1[i]>arr1[i+gap]){
        int temp=arr1[i];
        arr1[i]=arr1[i+gap];
        arr1[i+gap]=temp ;
      }
    }
    for(int gap=nextGap(m); gap>0 ; gap=nextGap(gap)){
      for(int i=0 ; i+gap<m ; i++)if(arr2[i]>arr2[i+gap]){
        int temp=arr2[i];
        arr2[i]=arr2[i+gap];
        arr2[i+gap]=temp ;
      }
    }
    for(int i=0 ; i<n ; i++)System.out.print(arr1[i]+" ");
    for(int j=0 ; j<m ; j++)System.out.print(arr2[j]+" ");
  }
  public static void main(String[] args){
    int arr1[]={
      1,5,9,10,15,20 };
      int n=arr1.length ;
      int arr2[]={
        2,3,8,13 };
        int m=arr2.length ;
        mergeTwoSortedArray(arr1,arr2,n,m);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nextGap( gap : int) : int
  pre: true
  post: true
  activity: (     if (gap <= 1) then     return 0 else skip ; 
     return ((gap / 2) + (gap mod 2))->oclAsType(int) );
  static   operation mergeTwoSortedArray( arr1 : Sequence(int), arr2 : Sequence(int), n : int, m : int) : void
  pre: true
  post: true
  activity: (     var x : int ; x := Set{n, m}->min() ;
         var i : int ; i := 0 ; while i < x do ( (     if (arr1[n - i - 1+1] > arr2[i+1]) then (     var temp : int ; temp := arr1[n - i - 1+1] ;
     arr1[n - i - 1+1] := arr2[i+1] ; 
     arr2[i+1] := temp ) else skip )  ;     i := i + 1 ) ; 
        var gap : int ; gap := nextGap(n) ; while gap > 0 do ( (         var i : int ; i := 0 ; while i + gap < n do (     if (arr1[i+1] > arr1[i + gap+1]) then (     var temp : int ; temp := arr1[i+1] ;
     arr1[i+1] := arr1[i + gap+1] ; 
     arr1[i + gap+1] := temp ) else skip ;  ;     i := i + 1 ) )  ;     gap := nextGap(gap) ) ; 
        var gap : int ; gap := nextGap(m) ; while gap > 0 do ( (         var i : int ; i := 0 ; while i + gap < m do (     if (arr2[i+1] > arr2[i + gap+1]) then (     var temp : int ; temp := arr2[i+1] ;
     arr2[i+1] := arr2[i + gap+1] ; 
     arr2[i + gap+1] := temp ) else skip ;  ;     i := i + 1 ) )  ;     gap := nextGap(gap) ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr1[i+1] + " ") ;  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < m do (     OclFile["System.out"].print(arr2[j+1] + " ") ;  ;     j := j + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{1,5,9,10,15,20} ;
     var n : int ; n := arr1->size() ;
    var arr2 : Sequence(int) ; arr2 := Sequence{2,3,8,13} ;
    var m : int ; m := arr2->size() ;
    execute mergeTwoSortedArray(arr1, arr2, n, m) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int min_val=Integer.MAX_VALUE ;
  static int min_steps=0 ;
  static int sumOfDigits(int n){
    String s=String.valueOf(n);
    int sum=0 ;
    for(int i=0 ; i<s.length(); i++){
      sum+=(s.charAt(i)-'0');
    }
    return sum ;
  }
  static void Transform(int n,int d,int steps){
    if(n<min_val){
      min_val=n ;
      min_steps=steps ;
    }
    else if(n==min_val){
      min_steps=Math.min(min_steps,steps);
    }
    if(steps<15){
      Transform(sumOfDigits(n),d,steps+1);
      Transform(n+d,d,steps+1);
    }
  }
  public static void main(String[] args){
    int N=9,D=3 ;
    Transform(N,D,0);
    System.out.print(min_val+" "+min_steps);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute min_val : int := 2147483647;
  static   attribute min_steps : int := 0;
  static   operation sumOfDigits( n : int) : int
  pre: true
  post: true
  activity: (     var s : String ; s := ((n) + "") ;
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     sum := sum+((s->at(i+1) - ('0')->char2byte())) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation Transform( n : int, d : int, steps : int) : void
  pre: true
  post: true
  activity: (     if (n < min_val) then (     min_val := n ; 
     min_steps := steps ) else     if (n = min_val) then (     min_steps := Set{min_steps, steps}->min() ) else skip ; ;  
     if (steps < 15) then (     execute Transform(sumOfDigits(n), d, steps + 1) ; 
     execute Transform(n + d, d, steps + 1) ) else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 9 ;
    var D : int ; D := 3 ;
     execute Transform(N, D, 0) ; 
     OclFile["System.out"].print(min_val + " " + min_steps) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<ArrayList<Integer>>graph=new ArrayList<>();
    for(int i=0 ; i<26 ; i++){
      graph.add(new ArrayList<>());
    }
    int[] types=new int[n];
    for(int i=0 ; i<n ; i++){
      int x=sc.next().charAt(0)-'a' ;
      graph.get(x).add(i);
      types[i]=x ;
    }
    int[] costs=new int[n];
    Arrays.fill(costs,Integer.MAX_VALUE);
    PriorityQueue<Path>queue=new PriorityQueue<>();
    queue.add(new Path(0,0));
    while(queue.size()>0){
      Path p=queue.poll();
      if(p.idx>=n){
        continue ;
      }
      if(costs[p.idx]<=p.value){
        continue ;
      }
      costs[p.idx]=p.value ;
      queue.add(new Path(p.idx+1,p.value+1));
      for(int x : graph.get(types[p.idx])){
        if(x<=p.idx){
          continue ;
        }
        queue.add(new Path(x,p.value));
      }
      graph.get(types[p.idx]).clear();
    }
    System.out.println(costs[n-1]+1);
  }
  static class Path implements Comparable<Path>{
    int idx ;
    int value ;
    public Path(int idx,int value){
      this.idx=idx ;
      this.value=value ;
    }
    public int compareTo(Path another){
      return value-another.value ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var graph : Sequence(Sequence(int)) ; graph := Sequence{} ;
        var i : int ; i := 0 ; while i < 26 do ( (     graph := graph->including(Sequence{}) )  ;     i := i + 1 ) ; 
    var types : Sequence(int) ; types := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->at(0+1) - ('a')->char2byte() ;
     graph->at(x+1)->excludes(i) ; 
     types[i+1] := x )  ;     i := i + 1 ) ; 
    var costs : Sequence(int) ; costs := Integer.subrange(1,n)->collect(0) ;
    costs := costs->collect(2147483647) ; 
    var queue : Sequence(String) ; queue := Sequence{} ;
    queue := queue->including(String(0, 0)) ; 
    while (queue->size() > 0) do (     var p : String ; p := queue->min() ;
     if (p.idx >= n) then (     continue ) else skip ; 
    if (costs[p.idx+1] <= p.value) then (     continue ) else skip ; 
    costs[p.idx+1] := p.value ; 
    queue := queue->including(String(p.idx + 1, p.value + 1)) ; 
    for (x : graph->at(types[p.idx+1]+1)) do ( (     if (x <= p.idx) then (     continue ) else skip ; 
     queue := queue->including(String(x, p.value)) )  ) ; 
    graph := graph->at(types[p.idx+1]+1)->intersection(Set{}) ; 
 ) ; 
    OclFile["System.out"].println(costs[n - 1+1] + 1) ; 
 );
  static class Path implements Comparable<String> {
   attribute idx : int;
   attribute value : int;
   static operation newPath( idx : int, value : int) : Path
  pre: true
  post: true
  activity:
  ( var self : Path ;
    self := createPath();
    self.initialise(idx, value);
    return self );
  operation initialise( idx : int, value : int) : void
  pre: true  post: true
  activity: (     self.idx := idx ; 
     self.value := value );
   operation compareTo( another : String) : int
  pre: true
  post: true
  activity: (     return (value)->char2byte() - another.value );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countdig(int m){
    if(m==0)return 0 ;
    else return 1+countdig(m/10);
  }
  static int countSteps(int x){
    int c=0 ;
    int last=x ;
    while(last>0){
      int digits=countdig(last);
      digits-=1 ;
      int divisor=(int)Math.pow(10,digits);
      int first=last/divisor ;
      int lastnumber=first*divisor ;
      int skipped=(last-lastnumber)/first ;
      skipped+=1 ;
      c+=skipped ;
      last=last-(first*skipped);
    }
    return c ;
  }
  public static void main(String[] args){
    int n=14 ;
    System.out.println(countSteps(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countdig( m : int) : int
  pre: true
  post: true
  activity: (     if (m = 0) then     return 0 else     return 1 + countdig(m / 10) );
  static   operation countSteps( x : int) : int
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
     var last : int ; last := x ;
     while (last > 0) do (     var digits : int ; digits := countdig(last) ;
     digits := digits-(1) ; 
    var divisor : int ; divisor := 10->pow(digits)->oclAsType(int) ;
    var first : int ; first := last / divisor ;
    var lastnumber : int ; lastnumber := first * divisor ;
    var skipped : int ; skipped := (last - lastnumber) / first ;
    skipped := skipped+(1) ; 
    c := c+(skipped) ; 
    last := last - (first * skipped) ; 
 ) ; 
     return c );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 14 ;
     OclFile["System.out"].println(countSteps(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class B {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    int t=fs.nextInt();
    while(t-->0){
      long n=fs.nextLong();
      long x=fs.nextLong();
      if(Math.abs(n)% 2==1){
        if(x % 4==0)System.out.println(n);
        else if(x % 4==1)System.out.println(n+x);
        else if(x % 4==2)System.out.println(n-1);
        else System.out.println(n-2+1-x);
      }
      else {
        if(x % 4==0)System.out.println(n);
        else if(x % 4==1)System.out.println(n-x);
        else if(x % 4==2)System.out.println(n+1);
        else System.out.println(n+2-1+x);
      }
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! 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());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var t : int ; t := fs.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := fs.nextLong() ;
     var x : long ; x := fs.nextLong() ;
     if (if n < 0 then -(n) else n endif mod 2 = 1) then (     if (x mod 4 = 0) then     OclFile["System.out"].println(n) ; else     if (x mod 4 = 1) then     OclFile["System.out"].println(n + x) else     if (x mod 4 = 2) then     OclFile["System.out"].println(n - 1) else     OclFile["System.out"].println(n - 2 + 1 - x) ; ;  ;  ) else (     if (x mod 4 = 0) then     OclFile["System.out"].println(n) ; else     if (x mod 4 = 1) then     OclFile["System.out"].println(n - x) else     if (x mod 4 = 2) then     OclFile["System.out"].println(n + 1) else     OclFile["System.out"].println(n + 2 - 1 + x) ; ;  ;  ) ) ;  ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test2 {
  public static void main(String[] args){
    new Test2().runOnce();
  }
  public void runOnce(){
    Scanner scanner=new Scanner(System.in);
    int chance=scanner.nextInt();
    for(int k=0 ; k<chance ; k++){
      long pos=scanner.nextLong();
      long time=scanner.nextLong();
      long round ;
      if(pos % 2!=0){
        if(time>0){
          pos+=1 ;
        }
        round=(time-1)/4 ;
        pos+=round*4 ;
        if((time-1)% 4==1){
          pos-=time ;
        }
        else if((time-1)% 4==2){
          pos-=time+time-1 ;
        }
        else if((time-1)% 4==3){
          pos-=time-2+time-1-time ;
        }
      }
      else {
        pos-=1 ;
        round=(time-1)/4 ;
        pos-=round*4 ;
        if((time-1)% 4==1){
          pos+=time ;
        }
        else if((time-1)% 4==2){
          pos+=time+time-1 ;
        }
        else if((time-1)% 4==3){
          pos+=time-2+time-1-time ;
        }
      }
      System.out.println(pos);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Test2.newTest2().runOnce() );
   operation runOnce() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var chance : int ; chance := scanner.getCurrent()->toInteger() ;
         var k : int ; k := 0 ; while k < chance do ( (     var pos : long ; pos := scanner.getCurrent()->toLong() ;
     var time : long ; time := scanner.getCurrent()->toLong() ;
    var round : long ;
    if (pos mod 2 /= 0) then (     if (time > 0) then (     pos := pos+(1) ) else skip ; 
     round := (time - 1) / 4 ; 
     pos := pos+(round * 4) ; 
     if ((time - 1) mod 4 = 1) then (     pos := pos-(time) ) else     if ((time - 1) mod 4 = 2) then (     pos := pos-(time + time - 1) ) else     if ((time - 1) mod 4 = 3) then (     pos := pos-(time - 2 + time - 1 - time) ) else skip ; ;  ) else (     pos := pos-(1) ; 
     round := (time - 1) / 4 ; 
     pos := pos-(round * 4) ; 
     if ((time - 1) mod 4 = 1) then (     pos := pos+(time) ) else     if ((time - 1) mod 4 = 2) then (     pos := pos+(time + time - 1) ) else     if ((time - 1) mod 4 = 3) then (     pos := pos+(time - 2 + time - 1 - time) ) else skip ; ;  ) ;  
    OclFile["System.out"].println(pos) ; 
 )  ;     k := k + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class B {
  public static void main(String args[]){
    Scanner fs=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int T=fs.nextInt();
    for(int loop=1 ; loop<=T ; loop++){
      long start=fs.nextLong(),jumps=fs.nextLong();
      long j=(jumps/4)*4+1 ;
      jumps %=4 ;
      for(int i=0 ; i<jumps ; i++){
        if(start % 2==0)start-=j ;
        else start+=j ;
        j++;
      }
      System.out.println(start);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : OclFile ; fs := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var T : int ; T := fs.getCurrent()->toInteger() ;
         var loop : int ; loop := 1 ; while loop <= T do ( (     var start : long ; start := fs.getCurrent()->toLong() ;
    var jumps : long ; jumps := fs.getCurrent()->toLong() ;
     var j : long ; j := (jumps / 4) * 4 + 1 ;
    jumps := jumps mod 4 ; 
        var i : int ; i := 0 ; while i < jumps do ( (     if (start mod 2 = 0) then     start := start-(j) else     start := start+(j) ; ;  
     j := j + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(start) ; 
 )  ;     loop := loop + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B_Segments {
  static Scanner in=new Scanner(System.in);
  static int n ;
  static void solve(){
    int possible_pair=(n*(n+1))/2 ;
    int ans=(int)((Math.floor((double)n/2.0)+1.0)*Math.ceil((double)n/2.0));
    System.out.print(ans);
  }
  public static void main(String[] amit){
    n=in.nextInt();
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Segments {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var possible_pair : int ; possible_pair := (n * (n + 1)) / 2 ;
     var ans : int ; ans := (((n->oclAsType(double) / 2.0)->floor() + 1.0) * (n->oclAsType(double) / 2.0)->ceil())->oclAsType(int) ;
     OclFile["System.out"].print(ans) );
  static   operation main( amit : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := in.getCurrent()->toInteger() ; 
     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.*;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int k=in.nextInt();
      int[] a=new int[n];
      int[] b=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
        b[i]=a[i];
      }
      Arrays.sort(a);
      if(k==1){
        out.println(a[0]);
      }
      else if(k==2){
        out.println(Math.max(b[0],b[n-1]));
      }
      else {
        out.println(a[n-1]);
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var k : int ; k := in.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.nextInt() ; 
     b[i+1] := a[i+1] )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    if (k = 1) then (     skip ) else     if (k = 2) then (     skip ) else (     skip ) ;  ;  
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class D_1296 {
  public static void main(String ar[])throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    StringBuffer sb=new StringBuffer();
    for(int r=0 ; r<t ; r++){
      String s1[]=br.readLine().split(" ");
      int n=Integer.parseInt(s1[0]);
      long p=Long.parseLong(s1[1]);
      int k[]=new int[n];
      String s2[]=br.readLine().split(" ");
      for(int i=0 ; i<n ; i++)k[i]=Integer.parseInt(s2[i]);
      long mod=1000000007 ;
      long mod1=982451653 ;
      long mod2=982451707 ;
      long x=0,x1=0,x2=0 ;
      Arrays.sort(k);
      for(int i=n-1 ; i>=0 ; i--){
        if(x==0 && x1==0){
          x=(x+pow(p,k[i],mod))% mod ;
          x1=(x1+pow(p,k[i],mod1))% mod1 ;
        }
        else {
          x=(x-pow(p,k[i],mod)+mod)% mod ;
          x1=(x1-pow(p,k[i],mod1)+mod1)% mod1 ;
        }
      }
      sb.append(x).append("\n");
    }
    System.out.println(sb);
  }
  public static long pow(long a,int n,long mod){
    long r=1 ;
    while(n>0){
      if(n % 2==1)r=(r*a)% mod ;
      a=(a*a)% mod ;
      n=n/2 ;
    }
    return r % mod ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class D_1296 {
  static   operation main( ar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        var r : int ; r := 0 ; while r < t do ( (     var s1 : Sequence(String) ; s1 := br.readLine()->split(" ") ;
     var n : int ; n := (s1[0+1])->toInteger() ;
    var p : long ; p := (s1[1+1])->toLong() ;
    var k : Sequence(int) ; k := Integer.subrange(1,n)->collect(0) ;
    var s2 : Sequence(String) ; s2 := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < n do (     k[i+1] := (s2[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var mod : long ; mod := 1000000007 ;
    var mod1 : long ; mod1 := 982451653 ;
    var mod2 : long ; mod2 := 982451707 ;
    var x : long ; x := 0 ;
    var x1 : long ; x1 := 0 ;
    var x2 : long ; x2 := 0 ;
    k := k->sort() ; 
        var i : int ; i := (n)->char2byte() - 1 ; while i >= 0 do ( (     if (x = 0 & x1 = 0) then (     x := (x + pow(p, k[i+1], mod)) mod mod ; 
     x1 := (x1 + pow(p, k[i+1], mod1)) mod mod1 ) else (     x := (x - pow(p, k[i+1], mod) + mod) mod mod ; 
     x1 := (x1 - pow(p, k[i+1], mod1) + mod1) mod mod1 ) )  ;     i := i - 1 ) ; 
    sb := sb + StringLib.newString(x) + StringLib.newString("\n") ; 
 )  ;     r := r + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
  static   operation pow( a : long, n : int, mod : long) : long
  pre: true
  post: true
  activity: (     var r : long ; r := 1 ;
     while (n > 0) do (     if (n mod 2 = 1) then     r := (r * a) mod mod ; else skip ; 
     a := (a * a) mod mod ; 
     n := n / 2 ) ; 
     return r mod mod );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    System.out.println("? "+(long)1e10);
    String s=sc.next();
    if(s.equals("Y")){
      int cnt=0 ;
      while(true){
        System.out.println("? "+(long)(2*Math.pow(10,cnt)));
        s=sc.next();
        if(s.equals("Y")){
          System.out.println("! "+(long)Math.pow(10,cnt));
          return ;
        }
++cnt ;
      }
    }
    else {
      int cnt=9 ;
      while(true){
        System.out.println("? "+(long)Math.pow(10,cnt));
        s=sc.next();
        if(s.equals("Y")){
          break ;
        }
--cnt ;
      }
      long left=(long)Math.pow(10,cnt);
      long right=(long)Math.pow(10,cnt+1)-1 ;
      while(right-left>1){
        long middle=(right+left)/2 ;
        System.out.println("? "+middle*10);
        s=sc.next();
        if(s.equals("Y")){
          right=middle ;
        }
        else {
          left=middle ;
        }
      }
      System.out.println("! "+right);
    }
  }
  void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println("? " + 1e10->oclAsType(long)) ; 
     var s : String ; s := sc.getCurrent() ;
     if (s = "Y") then (     var cnt : int ; cnt := 0 ;
     while (true) do (     OclFile["System.out"].println("? " + (2 * 10->pow(cnt))->oclAsType(long)) ; 
     s := sc.getCurrent() ; 
     if (s = "Y") then (     OclFile["System.out"].println("! " + 10->pow(cnt)->oclAsType(long)) ; 
     return ) else skip ; 
     cnt := cnt + 1 ) ) else (     var cnt : int ; cnt := 9 ;
     while (true) do (     OclFile["System.out"].println("? " + 10->pow(cnt)->oclAsType(long)) ; 
     s := sc.getCurrent() ; 
     if (s = "Y") then (     break ) else skip ; 
     cnt := cnt - 1 ) ; 
    var left : long ; left := 10->pow(cnt)->oclAsType(long) ;
    var right : long ; right := 10->pow(cnt + 1)->oclAsType(long) - 1 ;
    while (right - left > 1) do (     var middle : long ; middle := (right + left) / 2 ;
     OclFile["System.out"].println("? " + middle * 10) ; 
     s := sc.getCurrent() ; 
     if (s = "Y") then (     right := middle ) else (     left := middle ) ) ; 
    OclFile["System.out"].println("! " + right) ; 
 ) );
   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner scan=new Scanner(System.in);
    Main main=new Main();
    int l ;
    int N=0 ;
    for(l=1 ; l<11 ; l++){
      main.output(false,(int)Math.pow(10,l));
      if(main.input(scan)==0){
        break ;
      }
    }
    if(l!=11){
      int nMin=(int)Math.pow(10,l-1);
      int nMax=(int)Math.pow(10,l)-1 ;
      while(nMin!=nMax){
        int n=(nMin+nMax)/2 ;
        main.output(false,(n*10L));
        if(main.input(scan)==0){
          nMin=n+1 ;
        }
        else {
          nMax=n ;
        }
      }
      N=nMin ;
    }
    else {
      for(l=0 ; l<10 ; l++){
        main.output(false,(int)Math.pow(10,l)*2);
        if(main.input(scan)==1){
          N=(int)Math.pow(10,l);
          break ;
        }
      }
    }
    main.output(true,N);
  }
  private void output(boolean answerFlag,long n){
    if(answerFlag){
      System.out.println("! "+n);
    }
    else {
      System.out.println("? "+n);
    }
    System.out.flush();
  }
  private int input(Scanner scan)throws Exception {
    String input=scan.next();
    if("Y".equals(input)){
      return 1 ;
    }
    else if("N".equals(input)){
      return 0 ;
    }
    else {
      throw new Exception();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var main : Main ; main := Main.newMain() ;
    var l : int ;
    var N : int ; N := 0 ;
        l := 1 ; while l < 11 do ( (     main.output(false, 10->pow(l)->oclAsType(int)) ; 
     if (main.input(scan) = 0) then (     break ) else skip )  ;     l := l + 1 ) ; 
    if (l /= 11) then (     var nMin : int ; nMin := 10->pow(l - 1)->oclAsType(int) ;
     var nMax : int ; nMax := 10->pow(l)->oclAsType(int) - 1 ;
     while (nMin /= nMax) do (     var n : int ; n := (nMin + nMax) / 2 ;
     main.output(false, (n * 10L)) ; 
     if (main.input(scan) = 0) then (     nMin := n + 1 ) else (     nMax := n ) ) ; 
     N := nMin ) else (         l := 0 ; while l < 10 do ( (     main.output(false, 10->pow(l)->oclAsType(int) * 2) ; 
     if (main.input(scan) = 1) then (     N := 10->pow(l)->oclAsType(int) ; 
     break ) else skip )  ;     l := l + 1 ) ) ;  
    main.output(true, N) ; 
 );
   operation output( answerFlag : boolean, n : long) : void
  pre: true
  post: true
  activity: (     if (answerFlag) then (     OclFile["System.out"].println("! " + n) ) else (     OclFile["System.out"].println("? " + n) ) ;  
     OclFile["System.out"].flush() );
   operation input( scan : OclFile) : int
  pre: true
  post: true
  activity: (     var input : String ; input := scan.getCurrent() ;
     if ("Y" = input) then (     return 1 ) else     if ("N" = input) then (     return 0 ) else (     error ProgramException() ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void ask(String number){
    System.out.println("? "+number);
  }
  public static void ask(long number){
    System.out.println("? "+number);
  }
  public static void answer(String number){
    System.out.println("! "+number);
  }
  public static void answer(long number){
    System.out.println("! "+number);
  }
  public static long dec(int k){
    long a=1 ;
    for(int i=0 ; i<k ; i++)a*=10 ;
    return a ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int digit=-1 ;
    for(int i=0 ; i<=10 ; i++){
      ask(dec(i));
      if(sc.nextLine().equals("N")){
        digit=i ;
        break ;
      }
    }
    if(digit==-1){
      for(int i=0 ; i<=10 ; i++){
        ask(2*dec(i));
        if(sc.nextLine().equals("Y")){
          answer(dec(i));
          System.exit(0);
        }
      }
    }
    else {
      long min=dec(digit-1);
      long max=dec(digit)-1 ;
      while(min<max){
        long next=(min+max)/2 ;
        ask(next*10);
        if(sc.nextLine().equals("Y")){
          max=next ;
        }
        else {
          min=next+1 ;
        }
      }
      answer(min);
      System.exit(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation ask( number : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("? " + number) );
  static   operation ask( number : long) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("? " + number) );
  static   operation answer( number : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("! " + number) );
  static   operation answer( number : long) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("! " + number) );
  static   operation dec( k : int) : long
  pre: true
  post: true
  activity: (     var a : long ; a := 1 ;
         var i : int ; i := 0 ; while i < k do (     a := a*(10) ;  ;     i := i + 1 ) ; 
     return a );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var digit : int ; digit := -1 ;
         var i : int ; i := 0 ; while i <= 10 do ( (     execute ask(dec(i)) ; 
     if (sc.nextLine() = "N") then (     digit := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (digit = -1) then (         var i : int ; i := 0 ; while i <= 10 do ( (     execute ask(2 * dec(i)) ; 
     if (sc.nextLine() = "Y") then (     execute answer(dec(i)) ; 
 OclProcess.exit(0) ) else skip )  ;     i := i + 1 ) ) else (     var min : long ; min := dec(digit - 1) ;
     var max : long ; max := dec(digit) - 1 ;
    while (min < max) do (     var next : long ; next := (min + max) / 2 ;
     execute ask(next * 10) ; 
     if (sc.nextLine() = "Y") then (     max := next ) else (     min := next + 1 ) ) ; 
    execute answer(min) ; 
OclProcess.exit(0) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static void countWaysToJump(int arr[],int n){
    int count_jump[]=new int[n];
    Arrays.fill(count_jump,0);
    for(int i=n-2 ; i>=0 ; i--){
      if(arr[i]>=n-i-1)count_jump[i]++;
      for(int j=i+1 ; j<n-1 && j<=arr[i]+i ; j++)if(count_jump[j]!=-1)count_jump[i]+=count_jump[j];
      if(count_jump[i]==0)count_jump[i]=-1 ;
    }
    for(int i=0 ; i<n ; i++)System.out.print(count_jump[i]+" ");
  }
  public static void main(String[] args){
    int arr[]={
      1,3,5,8,9,1,0,7,6,8,9 };
      int n=arr.length ;
      countWaysToJump(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countWaysToJump( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var count_jump : Sequence(int) ; count_jump := Integer.subrange(1,n)->collect(0) ;
     count_jump := count_jump->collect(0) ; 
         var i : int ; i := n - 2 ; while i >= 0 do ( (     if (arr[i+1] >= n - i - 1) then     count_jump[i+1] := count_jump[i+1] + 1 ; else skip ; 
         var j : int ; j := i + 1 ; while j < n - 1 & j <= arr[i+1] + i do (     if (count_jump[j+1] /= -1) then     count_jump[i+1] := count_jump[i+1]+(count_jump[j+1]) ; else skip ;  ;     j := j + 1 ) ; 
     if (count_jump[i+1] = 0) then     count_jump[i+1] := -1 ; else skip )  ;     i := i - 1 ) ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(count_jump[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,5,8,9,1,0,7,6,8,9} ;
     var n : int ; n := arr->size() ;
     execute countWaysToJump(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static boolean checkPolygonWithMidpoints(int arr[],int N,int midpoints){
    for(int j=0 ; j<midpoints ; j++){
      int val=1 ;
      for(int k=j ; k<N ; k+=midpoints){
        val &=arr[k];
      }
      if(val!=0 && N/midpoints>2){
        System.out.println("Polygon possible with side length "+N/midpoints);
        return true ;
      }
    }
    return false ;
  }
  static void isPolygonPossible(int arr[],int N){
    int limit=(int)Math.sqrt(N);
    for(int i=1 ; i<=limit ; i++){
      if(N % i==0){
        if(checkPolygonWithMidpoints(arr,N,i)|| checkPolygonWithMidpoints(arr,N,(N/i)))return ;
      }
    }
    System.out.println("Not possible");
  }
  public static void main(String args[]){
    int arr[]={
      1,0,1,0,1,0,1,0,1,1 };
      isPolygonPossible(arr,arr.length);
    }
  }

------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation checkPolygonWithMidpoints( arr : Sequence(int), N : int, midpoints : int) : boolean
  pre: true
  post: true
  activity: (         var j : int ; j := 0 ; while j < midpoints do ( (     var val : int ; val := 1 ;
         var k : int ; k := j ; while k < N do ( (     val := MathLib.bitwiseAnd(val, arr[k+1]) )  ;     k := k+(midpoints) ) ; 
     if (val /= 0 & N / midpoints > 2) then (     OclFile["System.out"].println("Polygon possible with side length " + N / midpoints) ; 
     return true ) else skip )  ;     j := j + 1 ) ; 
     return false );
  static   operation isPolygonPossible( arr : Sequence(int), N : int) : void
  pre: true
  post: true
  activity: (     var limit : int ; limit := (N)->sqrt()->oclAsType(int) ;
         var i : int ; i := 1 ; while i <= limit do ( (     if (N mod i = 0) then (     if (checkPolygonWithMidpoints(arr, N, i) or checkPolygonWithMidpoints(arr, N, (N / i))) then     return else skip ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Not possible") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,0,1,0,1,0,1,0,1,1} ;
     execute isPolygonPossible(arr, arr->size()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int circle(int x1,int y1,int x2,int y2,int r1,int r2){
    int distSq=(x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
    int radSumSq=(r1+r2)*(r1+r2);
    if(distSq==radSumSq)return 1 ;
    else if(distSq>radSumSq)return-1 ;
    else return 0 ;
  }
  public static void main(String[] args){
    int x1=-10,y1=8 ;
    int x2=14,y2=-24 ;
    int r1=30,r2=10 ;
    int t=circle(x1,y1,x2,y2,r1,r2);
    if(t==1)System.out.println("Circle touch to"+" each other.");
    else if(t<0)System.out.println("Circle not touch"+" to each other.");
    else System.out.println("Circle intersect"+" to each other.");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation circle( x1 : int, y1 : int, x2 : int, y2 : int, r1 : int, r2 : int) : int
  pre: true
  post: true
  activity: (     var distSq : int ; distSq := (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) ;
     var radSumSq : int ; radSumSq := (r1 + r2) * (r1 + r2) ;
     if (distSq = radSumSq) then     return 1 else     if (distSq > radSumSq) then     return -1 else     return 0 ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x1 : int ; x1 := -10 ;
    var y1 : int ; y1 := 8 ;
     var x2 : int ; x2 := 14 ;
    var y2 : int ; y2 := -24 ;
    var r1 : int ; r1 := 30 ;
    var r2 : int ; r2 := 10 ;
    var t : int ; t := circle(x1, y1, x2, y2, r1, r2) ;
    if (t = 1) then     OclFile["System.out"].println("Circle touch to" + " each other.") else     if (t < 0) then     OclFile["System.out"].println("Circle not touch" + " to each other.") else     OclFile["System.out"].println("Circle intersect" + " to each other.") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PatternGFG {
  private static void print(int n,int k){
    for(int i=0 ; i<n ; i++){
      System.out.println();
      for(int j=0 ; j<(3*k+2); j++){
        if((i==0 && j!=k && j!=2*k+1)||((i==n/2)&&(j>1)&&(j!=k)&&(j!=2*k+1)&&(j!=2*k+3))||((i==n-1)&&(j!=k)&&((j<=k)||(j>2*k+1)))||(j==0)||(j==k+1)||(j==(2*k+2))||((j==k-1 || j==3*k+1)&&(i>n/2)))System.out.print("*");
        else System.out.print(" ");
      }
    }
  }
  public static void main(String[] args){
    int n=7,k=5 ;
    print(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class PatternGFG {
  static   operation print( n : int, k : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println() ; 
         var j : int ; j := 0 ; while j < (3 * k + 2) do ( (     if ((i = 0 & j /= k & j /= 2 * k + 1) or ((i = n / 2) & (j > 1) & (j /= k) & (j /= 2 * k + 1) & (j /= 2 * k + 3)) or ((i = n - 1) & (j /= k) & ((j <= k) or (j > 2 * k + 1))) or (j = 0) or (j = k + 1) or (j = (2 * k + 2)) or ((j = k - 1 or j = 3 * k + 1) & (i > n / 2))) then     OclFile["System.out"].print("*") ; else     OclFile["System.out"].print(" ") ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
    var k : int ; k := 5 ;
     execute print(n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt()+1 ;
    pw.println((long)(Math.pow(n,2)/4));
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() + 1 ;
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class hello {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    long t=in.nextLong();
    String num=in.next();
    int dec=num.indexOf(".");
    num=num.replace(".","");
    char[] cs=num.toCharArray();
    int len=cs.length ;
    for(int i=dec ; i<len ; i++){
      if(cs[i]-'0'>=5){
        len=i+1 ;
        break ;
      }
    }
    while(t>0){
      int roundIdx=-1 ;
      for(int i=len-1 ; i>=dec ; i--){
        int v=cs[i]-'0' ;
        if(v>=5){
          roundIdx=i ;
          break ;
        }
      }
      if(roundIdx==-1)break ;
      len=roundIdx ;
      while(len>0 && cs[len-1]=='9'){
        cs[len-1]='0' ;
        len--;
      }
      if(len==0){
        System.out.print("1");
        break ;
      }
      cs[len-1]++;
      t--;
    }
    System.out.print(new String(cs,0,dec));
    if(len-dec>0){
      System.out.print(".");
      System.out.println(new String(cs,dec,len-dec));
    }
    else {
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class hello {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var t : long ; t := in.getCurrent()->toLong() ;
    var num : String ; num := in.getCurrent() ;
    var dec : int ; dec := num->indexOf(".")-1 ;
    num := num.replace(".", "") ; 
    var cs : Sequence(String) ; cs := num->characters() ;
    var len : int ; len := cs->size() ;
        var i : int ; i := dec ; while i < len do ( (     if (cs[i+1] - ('0')->char2byte() >= 5) then (     len := i + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    while (t > 0) do (     var roundIdx : int ; roundIdx := -1 ;
         var i : int ; i := len - 1 ; while i >= dec do ( (     var v : int ; v := cs[i+1] - ('0')->char2byte() ;
     if (v >= 5) then (     roundIdx := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    if (roundIdx = -1) then     break else skip ; 
    len := roundIdx ; 
    while (len > 0 & cs[len - 1+1] = '9') do (     cs[len - 1+1] := '0' ; 
     len := len - 1 ) ; 
    if (len = 0) then (     OclFile["System.out"].print("1") ; 
     break ) else skip ; 
    cs[len - 1+1] := cs[len - 1+1] + 1 ; 
    t := t - 1 ; 
 ) ; 
    OclFile["System.out"].print(StringLib.newString(cs, 0, dec)) ; 
    if (len - (dec)->char2byte() > 0) then (     OclFile["System.out"].print(".") ; 
     OclFile["System.out"].println(StringLib.newString(cs, dec, len - (dec)->char2byte())) ) else (     OclFile["System.out"].println() ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(new BufferedInputStream(System.in));
    while(in.hasNext()){
      BigInteger a=in.nextBigInteger(),b=in.nextBigInteger();
      System.out.println(a.multiply(b));
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (in.hasNext()) do (     var a : long ; a := in.nextBigInteger() ;
    var b : long ; b := in.nextBigInteger() ;
     OclFile["System.out"].println(a.multiply(b)) ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Reposts {
  static ArrayList<Integer>[] adj ;
  static boolean[] vis ;
  static int cnt=0 ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    adj=new ArrayList[2*n+1];
    for(int i=0 ; i<=2*n ; i++)adj[i]=new ArrayList<>();
    HashMap<String,Integer>map=new HashMap<>();
    vis=new boolean[2*n+1];
    for(int i=0 ; i<n ; i++){
      String str1=in.next().toLowerCase();
      in.next();
      String str2=in.next().toLowerCase();
      int u=map.getOrDefault(str1,map.size()+1);
      map.put(str1,u);
      int v=map.getOrDefault(str2,map.size()+1);
      map.put(str2,v);
      adj[u] .add(v);
    }
    int ans=0 ;
    for(int i : map.values()){
      vis=new boolean[2*n+1];
      cnt=0 ;
      dfs(i);
      ans=Math.max(ans,cnt);
    }
    pw.println(ans);
    pw.close();
  }
  static void dfs(int u){
    cnt++;
    vis[u]=true ;
    for(int i : adj[u]){
      if(! vis[i])dfs(i);
    }
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Reposts {
  static   attribute adj : Sequence(Sequence(int));
  static   attribute vis : Sequence(boolean);
  static   attribute cnt : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    adj := Integer.subrange(1,2 * n + 1)->collect(null) ; 
        var i : int ; i := 0 ; while i <= 2 * n do (     adj[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
    var map : Map(String,int) ; map := Map{} ;
    vis := Integer.subrange(1,2 * n + 1)->collect(false) ; 
        var i : int ; i := 0 ; while i < n do ( (     var str1 : String ; str1 := in.getCurrent()->toLowerCase() ;
     skip ; 
    var str2 : String ; str2 := in.getCurrent()->toLowerCase() ;
    var u : int ; u := (if map->keys()->contains(str1) then map->at(str1) else map.size() + 1 endif) ;
    map := map->union(Map{str1 |-> u}) ; 
    var v : int ; v := (if map->keys()->contains(str2) then map->at(str2) else map.size() + 1 endif) ;
    map := map->union(Map{str2 |-> v}) ; 
    adj[u+1]->excludes(v) ; 
 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (i : map->values()) do ( (     vis := Integer.subrange(1,2 * n + 1)->collect(false) ; 
     cnt := 0 ; 
     execute dfs(i) ; 
     ans := Set{ans, cnt}->max() )  ) ; 
    skip ; 
    skip ; 
 );
  static   operation dfs( u : int) : void
  pre: true
  post: true
  activity: (     cnt := cnt + 1 ; 
     vis[u+1] := true ; 
     for (i : adj[u+1]) do ( (     if (not(vis[i+1])) then     execute dfs(i) ; else skip )  ) );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Reposts {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter output=new BufferedWriter(new OutputStreamWriter(System.out));
    int t=Integer.parseInt(br.readLine());
    HashMap<String,Integer>graph=new HashMap<>();
    int max=0 ;
    for(int i=0 ; i<t ; i++){
      String[] data=br.readLine().split(" ");
      String name1=data[0] .toLowerCase();
      String name2=data[2] .toLowerCase();
      int prev=graph.getOrDefault(name2,0)+1 ;
      max=Math.max(max,prev);
      graph.put(name1,prev);
    }
    System.out.println(max+1);
    output.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Reposts {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var output : OclFile ; output := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var t : int ; t := (br.readLine())->toInteger() ;
    var graph : Map(String,int) ; graph := Map{} ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < t do ( (     var data : Sequence(String) ; data := br.readLine()->split(" ") ;
     var name1 : String ; name1 := data[0+1]->toLowerCase() ;
    var name2 : String ; name2 := data[2+1]->toLowerCase() ;
    var prev : int ; prev := (if graph->keys()->contains(name2) then graph->at(name2) else 0 endif) + 1 ;
    max := Set{max, prev}->max() ; 
    graph := graph->union(Map{name1 |-> prev}) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max + 1) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class DP {
  static int n ;
  static String a[];
  static int mod=(int)1e9+7 ;
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    n=sc.nextInt();
    Map<String,Integer>map=new HashMap<>();
    map.put("polycarp",1);
    for(int i=0 ; i<n ; i++){
      a=sc.nextLine().toLowerCase().split(" ");
      map.put(a[0],map.getOrDefault(a[2],0)+1);
    }
    int max=0 ;
    for(Map.Entry entry : map.entrySet()){
      int val=(int)entry.getValue();
      max=Math.max(max,val);
    }
    out.println(max);
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(String s)throws FileNotFoundException {
      br=new BufferedReader(new FileReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DP {
  static   attribute n : int;
  static   attribute a : Sequence(String);
  static   attribute mod : int := 1e9->oclAsType(int) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    n := sc.getCurrent()->toInteger() ; 
    var map : Map(String,int) ; map := Map{} ;
    map := map->union(Map{"polycarp" |-> 1}) ; 
        var i : int ; i := 0 ; while i < n do ( (     a := sc.nextLine()->toLowerCase()->split(" ") ; 
     map := map->union(Map{a[0+1] |-> (if map->keys()->contains(a[2+1]) then map->at(a[2+1]) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    for (entry : map->asSet()) do ( (     var val : int ; val := entry.getValue()->oclAsType(int) ;
     max := Set{max, val}->max() )  ) ; 
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( s : String) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void find(int ar[]){
    List<Integer>ans=new ArrayList<>();
    for(int i=0 ; i<ar.length ; i++){
      int cnt=1 ;
      while(i+1<ar.length && ar[i]==ar[i+1]-1){
        cnt++;
        i++;
      }
      ans.add(cnt);
    }
    System.out.println(ans.size());
    for(int i=0 ; i<ans.size(); i++){
      System.out.print(ans.get(i)+" ");
    }
  }
  public static void main(String[] args){
    try {
      System.setIn(new FileInputStream("input.txt"));
      System.setOut(new PrintStream(new FileOutputStream("output.txt")));
    }
    catch(Exception e){
      System.err.println("Error");
    }
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int ar[]=new int[n];
    for(int i=0 ; i<n ; i++){
      ar[i]=sc.nextInt();
    }
    find(ar);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation find( ar : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Sequence{} ;
         var i : int ; i := 0 ; while i < ar->size() do ( (     var cnt : int ; cnt := 1 ;
     while (i + 1 < ar->size() & ar[i+1] = ar[i + 1+1] - 1) do (     cnt := cnt + 1 ; 
     i := i + 1 ) ; 
     ans := ans->including(cnt) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans->size()) ; 
         var i : int ; i := 0 ; while i < ans->size() do ( (     OclFile["System.out"].print(ans->at(i+1) + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) )   catch (e : ProgramException) do (     OclFile["System.err"].println("Error") )
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute find(ar) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1005A_TanyaandStairways {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int counter=1 ;
    List<Integer>list=new LinkedList<>();
    Stack<Integer>stack=new Stack<>();
    final int len=input.nextInt();
    int first=input.nextInt();
    stack.push(first);
    for(int i=1 ; i<len ; i++){
      int num=input.nextInt();
      if(num<=stack.peek()){
        counter++;
        list.add(stack.peek());
      }
      stack.push(num);
    }
    list.add(stack.peek());
    System.out.println(counter);
    System.out.println(list.toString().replaceAll("[\\[\\],] ",""));
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1005A_TanyaandStairways {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var counter : int ; counter := 1 ;
    var list : Sequence(int) ; list := Sequence{} ;
    var stack : Sequence(int) ; stack := Sequence{} ;
    var len : int ; len := input.getCurrent()->toInteger() ;
    var first : int ; first := input.getCurrent()->toInteger() ;
    stack := stack->append(first) ; 
        var i : int ; i := 1 ; while i < len do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
     if (num <= stack->min()) then (     counter := counter + 1 ; 
     list := list->including(stack->min()) ) else skip ; 
     stack := stack->append(num) )  ;     i := i + 1 ) ; 
    list := list->including(stack->min()) ; 
    OclFile["System.out"].println(counter) ; 
    OclFile["System.out"].println(list+"".replaceAllMatches("[\\[\\],] ", "" )) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    int n=nextInt();
    int[] c=new int[n];
    int sum1=0 ;
    for(int i=0 ; i<n ; i++){
      c[i]=nextInt();
      if(c[i]==1){
        sum1++;
      }
    }
    int sum=1 ;
    int[] otv=new int[sum1];
    int k=0 ;
    for(int i=1 ; i<n ; i++){
      if(c[i]==1){
        otv[k]=sum ;
        sum=1 ;
        k++;
      }
      else {
        sum++;
      }
    }
    otv[sum1-1]=sum ;
    System.out.println(sum1);
    for(int i=0 ; i<sum1 ; i++){
      System.out.print(otv[i]+" ");
    }
  }
  static class Edge implements Comparable<Edge>{
    int first,second ;
    public Edge(int first,int second){
      this.first=first ;
      this.second=second ;
    }
    @ Override public int compareTo(Edge o){
      if(first!=o.first)return Integer.compare(first,o.first);
      return Integer.compare(second,o.second);
    }
  }
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static PrintWriter out=new PrintWriter(System.out);
  static StringTokenizer in=new StringTokenizer("");
  public static String nextToken()throws IOException {
    while(in==null || ! in.hasMoreTokens()){
      in=new StringTokenizer(br.readLine());
    }
    return in.nextToken();
  }
  public static int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public static double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  public static long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    var sum1 : int ; sum1 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := nextInt() ; 
     if (c[i+1] = 1) then (     sum1 := sum1 + 1 ) else skip )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 1 ;
    var otv : Sequence(int) ; otv := Integer.subrange(1,sum1)->collect(0) ;
    var k : int ; k := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (c[i+1] = 1) then (     otv[k+1] := sum ; 
     sum := 1 ; 
     k := k + 1 ) else (     sum := sum + 1 ) )  ;     i := i + 1 ) ; 
    otv[sum1 - 1+1] := sum ; 
    OclFile["System.out"].println(sum1) ; 
        var i : int ; i := 0 ; while i < sum1 do ( (     OclFile["System.out"].print(otv[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static class Edge implements Comparable<Edge> {
   attribute first : int;
   static operation newEdge( first : int, second : int) : Edge
  pre: true
  post: true
  activity:
  ( var self : Edge ;
    self := createEdge();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
      operation compareTo( o : Edge) : int
  pre: true
  post: true
  activity: (     if (first /= o->at("first")) then     return compare(first, o->at("first")) else skip ; 
     return compare(second, o->at("second")) );
}
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute in : OclIterator := OclIterator.newOclIterator_String("");
  static   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (in = null or not(in.hasNext())) do (     in := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return in.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.Math ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    ArrayList<Integer>numStairs=new ArrayList<Integer>();
    int n ;
    int current=0 ;
    int previous=0 ;
    int stairways=0 ;
    n=input.nextInt();
    for(int i=0 ; i<n ; i++){
      previous=current ;
      current=input.nextInt();
      if(current==1){
        stairways++;
      }
      if(i==n-1){
        if(current==1 && n>1){
          numStairs.add(previous);
          numStairs.add(current);
        }
        else {
          numStairs.add(current);
        }
      }
      else if(current==1 && i!=0){
        numStairs.add(previous);
      }
    }
    System.out.println(stairways);
    for(int i=0 ; i<numStairs.size(); i++){
      System.out.print(numStairs.get(i)+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numStairs : Sequence(int) ; numStairs := Sequence{} ;
    var n : int ;
    var current : int ; current := 0 ;
    var previous : int ; previous := 0 ;
    var stairways : int ; stairways := 0 ;
    n := input.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     previous := current ; 
     current := input.getCurrent()->toInteger() ; 
     if (current = 1) then (     stairways := stairways + 1 ) else skip ; 
     if (i = n - 1) then (     if (current = 1 & n > 1) then (     numStairs := numStairs->including(previous) ; 
     numStairs := numStairs->including(current) ) else (     numStairs := numStairs->including(current) ) ) else     if (current = 1 & i /= 0) then (     numStairs := numStairs->including(previous) ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(stairways) ; 
        var i : int ; i := 0 ; while i < numStairs->size() do ( (     OclFile["System.out"].print(numStairs->at(i+1) + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1005A_TanyaAndStairways {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    ArrayList<Integer>arr=new ArrayList<>();
    ArrayList<Integer>res=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      arr.add(in.nextInt());
    }
    for(int i=1 ; i<n ; i++){
      if(arr.get(i)==1){
        res.add(arr.get(i-1));
      }
      if(i==n-1){
        res.add(arr.get(i));
      }
    }
    if(arr.size()==1){
      res.add(arr.get(0));
    }
    System.out.println(res.size());
    res.forEach((i)->{
      System.out.print(i+" ");
    }
);
    System.out.println("");
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1005A_TanyaAndStairways {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Sequence{} ;
    var res : Sequence(int) ; res := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr := arr->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (arr->at(i+1) = 1) then (     res := res->including(arr->at(i - 1+1)) ) else skip ; 
     if (i = n - 1) then (     res := res->including(arr->at(i+1)) ) else skip )  ;     i := i + 1 ) ; 
    if (arr->size() = 1) then (     res := res->including(arr->at(0+1)) ) else skip ; 
    OclFile["System.out"].println(res->size()) ; 
    for i : res do
    (    skip) ; 
    OclFile["System.out"].println("") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  static final PrintStream out=System.out ;
  static Scanner sc=new Scanner(System.in);
  static final long Mod=1000_000_007L ;
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
    System.exit(0);
  }
  void solve(){
    long A=nextLong();
    long B=nextLong();
    int C=nextInt();
    int D=nextInt();
    long Anum=0,Bnum=0 ;
    long lcm=C/gcd(C,D)*D ;
    A--;
    Anum=A-A/C-A/D+A/lcm ;
    Bnum=B-B/C-B/D+B/lcm ;
    out.println(Bnum-Anum);
  }
  public int[] nextIntArray(int n){
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public long[] nextLongArray(int n){
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=nextLong();
    return a ;
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
  public String next(){
    return sc.next();
  }
  long gcd(long m,long n){
    if(m<n)return gcd(n,m);
    if(n==0)return m ;
    return gcd(n,m % n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute out : OclFile := OclFile["System.out"];
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute Mod : long := 1000_000_007L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() ; 
 OclProcess.exit(0) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var A : long ; A := nextLong() ;
     var B : long ; B := nextLong() ;
    var C : int ; C := nextInt() ;
    var D : int ; D := nextInt() ;
    var Anum : long ; Anum := 0 ;
    var Bnum : long ; Bnum := 0 ;
    var lcm : long ; lcm := C / gcd(C, D) * D ;
    A := A - 1 ; 
    Anum := A - A / C - A / D + A / lcm ; 
    Bnum := B - B / C - B / D + B / lcm ; 
    skip ; 
 );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation next() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
   operation gcd( m : long, n : long) : long
  pre: true
  post: true
  activity: (     if (m < n) then     return gcd(n, m) else skip ; 
     if (n = 0) then     return m else skip ; 
     return gcd(n, m mod n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt()+1 ;
    pw.println((long)(Math.pow(n,2)/4));
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() + 1 ;
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class LCM {
  static long lcm(int a,int b){
    return(long)a*b/gcd(a,b);
  }
  private static int gcd(int a,int b){
    if(b==0){
      return a ;
    }
    else {
      return gcd(b,a % b);
    }
  }
}
public class Main {
  static Scanner stdIn=new Scanner(System.in);
  public static void main(String[] args){
    long a=stdIn.nextLong();
    long b=stdIn.nextLong();
    int c=stdIn.nextInt();
    int d=stdIn.nextInt();
    System.out.println(antiDivision(b,c,d)-antiDivision(a-1,c,d));
  }
  static long antiDivision(long n,int c,int d){
    return n-(division(n,c)+division(n,d)-division(n,LCM.lcm(c,d)));
  }
  static long division(long n,long d){
    return n/d ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class LCM {
  static   operation lcm( a : int, b : int) : long
  pre: true
  post: true
  activity: (     return a->oclAsType(long) * b / gcd(a, b) );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else (     return gcd(b, a mod b) ) );
}
class Main {
  static   attribute stdIn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ; a := stdIn.getCurrent()->toLong() ;
     var b : long ; b := stdIn.getCurrent()->toLong() ;
    var c : int ; c := stdIn.getCurrent()->toInteger() ;
    var d : int ; d := stdIn.getCurrent()->toInteger() ;
    OclFile["System.out"].println(antiDivision(b, c, d) - antiDivision(a - 1, c, d)) ; 
 );
  static   operation antiDivision( n : long, c : int, d : int) : long
  pre: true
  post: true
  activity: (     return n - (division(n, c) + division(n, d) - division(n, LCM.lcm(c, d))) );
  static   operation division( n : long, d : long) : long
  pre: true
  post: true
  activity: (     return n / d );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.io.BufferedOutputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    try(BufferedInputStream in=new BufferedInputStream(System.in);
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out))){
      Scanner sc=new Scanner(in);
      long a=sc.nextLong();
      long b=sc.nextLong();
      long c=sc.nextLong();
      long d=sc.nextLong();
      out.println(b-a+1-cnt(a,b,c)-cnt(a,b,d)+cnt(a,b,lcm(c,d)));
    }
  }
  private static long cnt(long a,long b,long c){
    long consumed=(a-1)% c ;
    long rest=c-1-consumed ;
    a+=rest ;
    return(b-a+1+c-1)/c ;
  }
  private static long lcm(long a,long b){
    return a*b/gcd(a,b);
  }
  private static long gcd(long a,long b){
    while(b>0){
      long t=a % b ;
      a=b ;
      b=t ;
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
 (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var c : long ; c := sc.getCurrent()->toLong() ;
    var d : long ; d := sc.getCurrent()->toLong() ;
    skip ; 
 ))  );
  static   operation cnt( a : long, b : long, c : long) : long
  pre: true
  post: true
  activity: (     var consumed : long ; consumed := (a - 1) mod c ;
     var rest : long ; rest := c - 1 - consumed ;
     a := a+(rest) ; 
     return (b - a + 1 + c - 1) / c );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return a * b / gcd(a, b) );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     while (b > 0) do (     var t : long ; t := a mod b ;
     a := b ; 
     b := t ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long A=sc.nextLong();
    long B=sc.nextLong();
    long C=sc.nextLong();
    long D=sc.nextLong();
    long koumoku=B-A+1 ;
    long kosu=koumoku-kosu(A,B,C)-kosu(A,B,D)+kosu(A,B,lcm(C,D));
    System.out.println(kosu);
  }
  public static long kosu(long min,long max,long wari){
    long start ;
    if(min % wari==0){
      start=min ;
    }
    else {
      start=min+(wari-min % wari);
    }
    long mod=(max-start+1)% wari ;
    long kosu=(max-start+1)/wari ;
    if(mod>0){
      kosu+=1 ;
    }
    return kosu ;
  }
  private static long lcm(long m,long n){
    return m*n/gcd(m,n);
  }
  private static long gcd(long m,long n){
    if(m<n)return gcd(n,m);
    if(n==0)return m ;
    return gcd(n,m % n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : long ; A := sc.getCurrent()->toLong() ;
    var B : long ; B := sc.getCurrent()->toLong() ;
    var C : long ; C := sc.getCurrent()->toLong() ;
    var D : long ; D := sc.getCurrent()->toLong() ;
    var koumoku : long ; koumoku := B - A + 1 ;
    var kosu : long ; kosu := koumoku - kosu(A, B, C) - kosu(A, B, D) + kosu(A, B, lcm(C, D)) ;
    OclFile["System.out"].println(kosu) ; 
 );
  static   operation kosu( min : long, max : long, wari : long) : long
  pre: true
  post: true
  activity: (     var start : long ;
     if (min mod wari = 0) then (     start := min ) else (     start := min + (wari - min mod wari) ) ;  
    var mod : long ; mod := (max - start + 1) mod wari ;
    var kosu : long ; kosu := (max - start + 1) / wari ;
    if (mod > 0) then (     kosu := kosu+(1) ) else skip ; 
    return kosu 
 );
  static   operation lcm( m : long, n : long) : long
  pre: true
  post: true
  activity: (     return m * n / gcd(m, n) );
  static   operation gcd( m : long, n : long) : long
  pre: true
  post: true
  activity: (     if (m < n) then     return gcd(n, m) else skip ; 
     if (n = 0) then     return m else skip ; 
     return gcd(n, m mod n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long a=Long.parseLong(sc.next());
    long b=Long.parseLong(sc.next());
    long c=Long.parseLong(sc.next());
    long d=Long.parseLong(sc.next());
    long total=b-(a-1);
    long countC=b/c-(a-1)/c ;
    long countD=b/d-(a-1)/d ;
    long cm=b/lcm((int)c,(int)d)-(a-1)/lcm((int)c,(int)d);
    long result=total-countC-countD+cm ;
    System.out.println(result);
    sc.close();
  }
  public static long lcm(int a,int b){
    int temp ;
    long c=a ;
    c*=b ;
    while((temp=a % b)!=0){
      a=b ;
      b=temp ;
    }
    return c/b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := (sc.getCurrent())->toLong() ;
    var b : long ; b := (sc.getCurrent())->toLong() ;
    var c : long ; c := (sc.getCurrent())->toLong() ;
    var d : long ; d := (sc.getCurrent())->toLong() ;
    var total : long ; total := b - (a - 1) ;
    var countC : long ; countC := b / c - (a - 1) / c ;
    var countD : long ; countD := b / d - (a - 1) / d ;
    var cm : long ; cm := b / lcm(c->oclAsType(int), d->oclAsType(int)) - (a - 1) / lcm(c->oclAsType(int), d->oclAsType(int)) ;
    var result : long ; result := total - countC - countD + cm ;
    OclFile["System.out"].println(result) ; 
    skip ; 
 );
  static   operation lcm( a : int, b : int) : long
  pre: true
  post: true
  activity: (     var temp : int ;
     var c : long ; c := a ;
    c := c*(b) ; 
        temp := a mod b ;
    while ((temp) /= 0) do (    skip ; (     a := b ; 
     b := temp ) ;     temp := a mod b ;
 ) ;  
    return c / b 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long sumOfDigits(long n){
    long sum=0 ;
    while(n>0){
      sum+=n % 10 ;
      n/=10 ;
    }
    return sum ;
  }
  static long countDigits(long num,long limit){
    long left=1,right=num,result=0 ;
    while(left<=right){
      long mid=(right+left)/2 ;
      if((mid-sumOfDigits(mid))>=limit){
        result=num-mid+1 ;
        right=mid-1 ;
      }
      else {
        left=mid+1 ;
      }
    }
    return result ;
  }
  public static void main(String[] args){
    long N=1546300,L=30651 ;
    System.out.println(countDigits(N,L));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumOfDigits( n : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     while (n > 0) do (     sum := sum+(n mod 10) ; 
     n := n/(10) ) ; 
     return sum );
  static   operation countDigits( num : long, limit : long) : long
  pre: true
  post: true
  activity: (     var left : long ; left := 1 ;
    var right : long ; right := num ;
    var result : long ; result := 0 ;
     while (left <= right) do (     var mid : long ; mid := (right + left) / 2 ;
     if ((mid - sumOfDigits(mid)) >= limit) then (     result := num - mid + 1 ; 
     right := mid - 1 ) else (     left := mid + 1 ) ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := 1546300 ;
    var L : long ; L := 30651 ;
     OclFile["System.out"].println(countDigits(N, L)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.math.BigInteger ;
import java.net.InetAddress ;
import java.net.ServerSocket ;
import java.net.Socket ;
import java.util.*;
import static java.lang.System.out ;
public class app {
  public static long m ;
  static int mod=998244353 ;
  static int inf=(int)1e9 ;
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int s=sc.nextInt();
      int z=Integer.MIN_VALUE ;
      int zx=0 ;
      for(int i=0 ; i<s ; i++){
        int xc=sc.nextInt();
        z=Math.max(z,xc);
        zx=Math.max(zx,z-xc);
      }
      int r=0 ;
      int aa=0 ;
      while(zx>aa){
        aa+=Math.pow(2,r);
        r++;
      }
      out.println(r);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class app {
  static   attribute m : long;
  static   attribute mod : int := 998244353;
  static   attribute inf : int := 1e9->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var z : int ; z := -2147483648 ;
    var zx : int ; zx := 0 ;
        var i : int ; i := 0 ; while i < s do ( (     var xc : int ; xc := sc.getCurrent()->toInteger() ;
     z := Set{z, xc}->max() ; 
     zx := Set{zx, z - xc}->max() )  ;     i := i + 1 ) ; 
    var r : int ; r := 0 ;
    var aa : int ; aa := 0 ;
    while (zx > aa) do (     aa := aa+(2->pow(r)) ; 
     r := r + 1 ) ; 
    out.println(r) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  String S,T ;
  public static void main(String[] args){
    Main a=new Main();
    a.read();
    a.solve();
  }
  public void read(){
    Scanner sc=new Scanner(System.in);
    S=sc.next();
    T=sc.next();
  }
  public void solve(){
    StringBuilder sb=new StringBuilder();
    sb.append(S);
    int tlen=T.length();
    int slen=S.length();
    boolean restorable=false ;
    String key="" ;
    outer : for(int i=slen-tlen ;
    i>=0 ;
    i--){
      inner : for(int j=0 ;
      j<tlen ;
      j++){
        if((S.charAt(i+j)!=T.charAt(j))&&(S.charAt(i+j)!='?')){
          continue outer ;
        }
      }
      sb.replace(i,i+tlen,T);
      restorable=true ;
      break ;
    }
    if(restorable==true){
      key=sb.toString().replaceAll("\\?","a");
    }
    else {
      key="UNRESTORABLE" ;
    }
    System.out.println(key);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute S : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Main ; a := Main.newMain() ;
     a.read() ; 
     a.solve() );
   operation read() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     S := sc.getCurrent() ; 
     T := sc.getCurrent() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     sb := sb + StringLib.newString(S) ; 
    var tlen : int ; tlen := T->size() ;
    var slen : int ; slen := S->size() ;
    var restorable : boolean ; restorable := false ;
    var key : String ; key := "" ;
        var i : int ; i := slen - (tlen)->char2byte() ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < tlen do ( (     if ((S->at(i + j+1) /= T->at(j+1)) & (S->at(i + j+1) /= '?')) then (     continue ) else skip )  ;     j := j + 1 ) ; 
     sb.replace(i, i + tlen, T) ; 
     restorable := true ; 
     break )  ;     i := i - 1 ) ; 
    if (restorable = true) then (     key := sb+"".replaceAllMatches("\\?", "a" ) ) else (     key := "UNRESTORABLE" ) ;  
    OclFile["System.out"].println(key) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  private static final String NOT_FOUND="UNRESTORABLE" ;
  public static void main(String[] args){
    new Main().execute();
  }
  public void execute(){
    Scanner sc=new Scanner(System.in);
    final String sDash=sc.next();
    final String T=sc.next();
    List<String>candidates=new ArrayList<>();
    for(int i=0,bound=sDash.length()-T.length(); i<=bound ; i++){
      if(fuzzyMatch(sDash.substring(i,i+T.length()),T)){
        String c=sDash.substring(0,i).replace('?','a')+T+sDash.substring(i+T.length(),sDash.length()).replace('?','a');
        candidates.add(c);
      }
    }
    if(candidates.size()>0){
      Collections.sort(candidates);
      System.out.println(candidates.get(0));
    }
    else {
      System.out.println(NOT_FOUND);
    }
    sc.close();
  }
  private boolean fuzzyMatch(String s,String t){
    for(int i=0,len=s.length(); i<len ; i++){
      if(s.charAt(i)!='?' && s.charAt(i)!=t.charAt(i)){
        return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute NOT_FOUND : String := "UNRESTORABLE";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().execute() );
   operation execute() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sDash : String ; sDash := sc.getCurrent() ;
    var T : String ; T := sc.getCurrent() ;
    var candidates : Sequence(String) ; candidates := Sequence{} ;
        var i : int ; i := 0 ;
    var bound : int ; bound := sDash->size() - T->size() ; while i <= bound do ( (     if (fuzzyMatch(sDash.subrange(i+1,i + T->size()), T)) then (     var c : String ; c := sDash.subrange(0+1,i).replace('?', 'a') + T + sDash.subrange(i + T->size()+1,sDash->size()).replace('?', 'a') ;
     candidates := candidates->including(c) ) else skip )  ;     i := i + 1 ) ; 
    if (candidates->size() > 0) then (     candidates := candidates->sort() ; 
     OclFile["System.out"].println(candidates->at(0+1)) ) else (     OclFile["System.out"].println(NOT_FOUND) ) ;  
    skip ; 
 );
   operation fuzzyMatch( s : String, t : String) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ;
    var len : int ; len := s->size() ; while i < len do ( (     if (s->at(i+1) /= '?' & s->at(i+1) /= t->at(i+1)) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String t=sc.next();
    String[] h=new String[51];
    for(int i=0 ; i<51 ; i++){
      h[i]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz" ;
    }
    int st=0 ;
    int ite=0 ;
    for(int end=st+t.length()-1 ; end<s.length(); end++){
      st=end-t.length()+1 ;
      for(int i=0 ; i<t.length(); i++){
        if(s.substring(st+i,st+i+1).equals("?")){
        }
        else if(! t.substring(i,i+1).equals(s.substring(st+i,st+i+1))){
          break ;
        }
        if(i==t.length()-1){
          h[ite]="" ;
          for(int j=0 ; j<s.length(); j++){
            if(st<=j && j<=end){
              h[ite]+=t.substring(j-st,j-st+1);
            }
            else {
              String buff=s.substring(j,j+1);
              if(buff.equals("?")){
                h[ite]+="a" ;
              }
              else {
                h[ite]+=buff ;
              }
            }
          }
          ite++;
        }
      }
    }
    Arrays.sort(h);
    if(h[0] .equals("zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz")){
      System.out.println("UNRESTORABLE");
    }
    else {
      System.out.println(h[0]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var h : Sequence(String) ; h := Integer.subrange(1,51)->collect(null) ;
        var i : int ; i := 0 ; while i < 51 do ( (     h[i+1] := "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz" )  ;     i := i + 1 ) ; 
    var st : int ; st := 0 ;
    var ite : int ; ite := 0 ;
        var end : int ; end := st + t->size() - 1 ; while end < s->size() do ( (     st := end - t->size() + 1 ; 
         var i : int ; i := 0 ; while i < t->size() do ( (     if (s.subrange(st + i+1,st + i + 1) = "?") then skip else     if (not(t.subrange(i+1,i + 1) = s.subrange(st + i+1,st + i + 1))) then (     break ) else skip ; ;  
     if (i = t->size() - 1) then (     h[ite+1] := "" ; 
         var j : int ; j := 0 ; while j < s->size() do ( (     if (st <= j & j <= end) then (     h[ite+1] := h[ite+1]+(t.subrange(j - st+1,j - st + 1)) ) else (     var buff : String ; buff := s.subrange(j+1,j + 1) ;
     if (buff = "?") then (     h[ite+1] := h[ite+1]+("a") ) else (     h[ite+1] := h[ite+1]+(buff) ) ) )  ;     j := j + 1 ) ; 
     ite := ite + 1 ) else skip )  ;     i := i + 1 ) )  ;     end := end + 1 ) ; 
    h := h->sort() ; 
    if (h[0+1] = "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz") then (     OclFile["System.out"].println("UNRESTORABLE") ) else (     OclFile["System.out"].println(h[0+1]) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static Scanner sc ;
  public Main(){
  }
  public static void main(String[] args){
    sc=new Scanner(System.in);
    new Main().solve();
  }
  private void solve(){
    String Sd=sc.next();
    String T=sc.next();
    char[] sd=Sd.toCharArray();
    char[] t=T.toCharArray();
    int tlen=t.length ;
    String tmp="" ;
    int tleft=9999 ;
    for(int i=Sd.length()-1 ; ; ){
      int left=i-tlen+1 ;
      if(left<0){
        break ;
      }
      if(check(left,i,sd,t)){
        tmp=new String(t);
        tleft=left ;
        break ;
      }
      i--;
    }
    if(tleft==9999){
      System.out.println("UNRESTORABLE");
    }
    else {
      StringBuilder sb=new StringBuilder();
      sb.append(Sd);
      sb.replace(tleft,tleft+tlen,tmp);
      System.out.println(sb.toString().replaceAll("\\?","a"));
    }
  }
  boolean check(int s,int g,char[] sd,char[] t){
    int ti=0 ;
    for(int i=s ; i<=g ; i++){
      if(sd[i]!='?' && sd[i]!=t[ti]){
        return false ;
      }
      ti++;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var Sd : String ; Sd := sc.getCurrent() ;
     var T : String ; T := sc.getCurrent() ;
    var sd : Sequence(String) ; sd := Sd->characters() ;
    var t : Sequence(String) ; t := T->characters() ;
    var tlen : int ; tlen := t->size() ;
    var tmp : String ; tmp := "" ;
    var tleft : int ; tleft := 9999 ;
        var i : int ; i := Sd->size() - 1 ; while true do ( (     var left : int ; left := i - tlen + 1 ;
     if (left < 0) then (     break ) else skip ; 
     if (check(left, i, sd, t)) then (     tmp := StringLib.newString(t) ; 
     tleft := left ; 
     break ) else skip ; 
     i := i - 1 )  ) ; 
    if (tleft = 9999) then (     OclFile["System.out"].println("UNRESTORABLE") ) else (     var sb : String ; sb := StringLib.newString() ;
     sb := sb + StringLib.newString(Sd) ; 
     sb.replace(tleft, tleft + tlen, tmp) ; 
     OclFile["System.out"].println(sb+"".replaceAllMatches("\\?", "a" )) ) ;  
 );
   operation check( s : int, g : int, sd : Sequence(String), t : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     var ti : int ; ti := 0 ;
         var i : int ; i := s ; while i <= g do ( (     if (sd[i+1] /= '?' & sd[i+1] /= t[ti+1]) then (     return false ) else skip ; 
     ti := ti + 1 )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    long[] arr=new long[n+1];
    arr[0]=2 ;
    arr[1]=1 ;
    for(int i=2 ; i<arr.length ; i++)arr[i]=arr[i-1]+arr[i-2];
    System.out.println(arr[n]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
    arr[0+1] := 2 ; 
    arr[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < arr->size() do (     arr[i+1] := arr[i - 1+1] + arr[i - 2+1] ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(arr[n+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import java.io.*;
public class S {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    solve(n);
  }
  public static void solve(int n){
    int a[]=new int[110];
    for(int i=1 ; i<=n ; i++){
      for(int j=0 ; j<=n-i ; j++){
        a[j]+=1 ;
        a[j+i]-=1 ;
      }
    }
    int ans=0 ;
    for(int i=1 ; i<a.length ; i++){
      a[i]+=a[i-1];
    }
    for(int i=0 ; i<a.length ; i++){
      ans=Math.max(ans,a[i]);
    }
    System.out.println(ans);
  }
  public static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class S {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
     execute solve(n) );
  static   operation solve( n : int) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,110)->collect(0) ;
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= n - i do ( (     a[j+1] := a[j+1]+(1) ; 
     a[j + i+1] := a[j + i+1]-(1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < a->size() do ( (     a[i+1] := a[i+1]+(a[i - 1+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     ans := Set{ans, a[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next().replaceAll("\\?",".");
    String t=sc.next();
    int ns=s.length();
    int nt=t.length();
    for(int i=0 ; i+nt<=ns ; i++){
      String regex=s.substring(ns-nt-i,ns-nt-i+nt);
      if(t.matches(regex)){
        String ans=s.replaceFirst(s.substring(0,ns-nt-i)+regex,s.substring(0,ns-nt-i)+t).replaceAll("\\.","a");
        System.out.println(ans);
        return ;
      }
    }
    System.out.println("UNRESTORABLE");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent().replaceAllMatches("\\?", "." ) ;
    var t : String ; t := sc.getCurrent() ;
    var ns : int ; ns := s->size() ;
    var nt : int ; nt := t->size() ;
        var i : int ; i := 0 ; while i + nt <= ns do ( (     var regex : String ; regex := s.subrange((ns)->char2byte() - nt - i+1,(ns)->char2byte() - nt - i + nt) ;
     if (t->isMatch(regex)) then (     var ans : String ; ans := s.replaceFirstMatch(s.subrange(0+1,(ns)->char2byte() - nt - i) + regex, s.subrange(0+1,(ns)->char2byte() - nt - i) + t).replaceAllMatches("\\.", "a" ) ;
     OclFile["System.out"].println(ans) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("UNRESTORABLE") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=in.nextInt();
    pw.println(solve(a,n));
    pw.close();
  }
  static int solve(int[] a,int n){
    int ans=0 ;
    ArrayDeque<Integer>dq=new ArrayDeque<>();
    for(int i=0 ; i<n ; i++)dq.add(a[i]);
    int l=1,r=(int)1e6 ;
    int cnt=0 ;
    while(! dq.isEmpty()){
      l++;
      r--;
      cnt++;
      if(dq.peekLast()==r){
        ans=cnt ;
        dq.pollLast();
      }
      if(dq.isEmpty())break ;
      if(dq.peekFirst()==l){
        ans=cnt ;
        dq.pollFirst();
      }
    }
    return ans ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var dq : Sequence(int) ; dq := ArrayDeque<OclAny>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < n do (     dq := dq->including(a[i+1]) ;  ;     i := i + 1 ) ; 
    var l : int ; l := 1 ;
    var r : int ; r := 1e6->oclAsType(int) ;
    var cnt : int ; cnt := 0 ;
    while (not(dq->isEmpty())) do (     l := l + 1 ; 
     r := r - 1 ; 
    cnt := cnt + 1 ; 
    if (dq.peekLast() = r) then (     ans := cnt ; 
     dq := dq->front() ) else skip ; 
    if (dq->isEmpty()) then     break else skip ; 
    if (dq.peekFirst() = l) then (     ans := cnt ; 
     dq := dq->tail() ) else skip ; 
 ) ; 
    return ans 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import org.w3c.dom.ls.LSInput ;
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.*;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
import java.util.jar.Attributes ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int a=1 ;
      int b=1000000 ;
      int sum=0 ;
      int s[]=new int[n];
      int flag=0 ;
      for(int i=0 ; i<n ; i++){
        int m=in.nextInt();
        if(m-a<b-m){
          sum=sum+m-a ;
          b=b-m+a ;
          a=m ;
        }
        else {
          if(b-m<0){
            continue ;
          }
          else {
            sum=sum+b-m ;
            i=n-1 ;
          }
        }
      }
      out.println(sum);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var a : int ; a := 1 ;
    var b : int ; b := 1000000 ;
    var sum : int ; sum := 0 ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var m : int ; m := in.nextInt() ;
     if (m - a < b - m) then (     sum := sum + m - a ; 
     b := b - m + a ; 
     a := m ) else (     if (b - m < 0) then (     continue ) else (     sum := sum + b - m ; 
     i := n - 1 ) ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int y=1000000/2 ;
    int max=0 ;
    for(int i=0 ; i<n ; i++){
      int s=in.nextInt();
      if(s<y){
        int x=s-1 ;
        if(x>max)max=x ;
      }
      else if(s>y+1){
        int x=1000000-s ;
        if(x>max)max=x ;
      }
      else if(s==y || s==y+1){
        System.out.println(y-1);
        return ;
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var y : int ; y := 1000000 / 2 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var s : int ; s := in.getCurrent()->toInteger() ;
     if (s < y) then (     var x : int ; x := s - 1 ;
     if (x > max) then     max := x ; else skip ) else     if (s > y + 1) then (     var x : int ; x := 1000000 - s ;
     if (x > max) then     max := x ; else skip ) else     if (s = y or s = y + 1) then (     OclFile["System.out"].println(y - 1) ; 
     return ) else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int max=100 ;
  public static void main(String[] args){
    long[] arr=new long[max];
    arr[0]=0 ;
    arr[1]=1 ;
    int i=0 ;
    for(i=2 ; i<max ; i++)arr[i]=arr[i-1]+arr[i-2];
    for(i=1 ; i<max-1 ; i++){
      if((arr[i] % 10==0)&&(arr[i+1] % 10==1))break ;
    }
    System.out.println("Sequence is repeating after index "+i);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute max : int := 100;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(long) ; arr := Integer.subrange(1,max)->collect(0) ;
     arr[0+1] := 0 ; 
    arr[1+1] := 1 ; 
    var i : int ; i := 0 ;
        i := 2 ; while i < max do (     arr[i+1] := arr[i - 1+1] + arr[i - 2+1] ;  ;     i := i + 1 ) ; 
        i := 1 ; while i < max - 1 do ( (     if ((arr[i+1] mod 10 = 0) & (arr[i + 1+1] mod 10 = 1)) then     break else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Sequence is repeating after index " + i) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void reverse(int[] a,int n,int k){
    if(k>n){
      System.out.println("Invalid k");
      return ;
    }
    for(int i=0 ; i<k/2 ; i++){
      int tempswap=a[i];
      a[i]=a[k-i-1];
      a[k-i-1]=tempswap ;
    }
  }
  public static void main(String args[]){
    int[] a={
      1,2,3,4,5,6 };
      int n=a.length,k=4 ;
      reverse(a,n,k);
      for(int i=0 ; i<n ; ++i)System.out.print(a[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation reverse( a : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     if (k > n) then (     OclFile["System.out"].println("Invalid k") ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < k / 2 do ( (     var tempswap : int ; tempswap := a[i+1] ;
     a[i+1] := a[k - i - 1+1] ; 
     a[k - i - 1+1] := tempswap )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,4,5,6} ;
     var n : int ; n := a->size() ;
    var k : int ; k := 4 ;
     execute reverse(a, n, k) ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int n,m ;
  private final int LONG=1900 ;
  private final int SHORT=100 ;
  public static void main(String[] args){
    Main m=new Main();
    m.read();
    m.solve();
  }
  private void read(){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    m=sc.nextInt();
  }
  private void solve(){
    double ans=0.;
    double rat=2<<(m-1);
    double one=(LONG*m+SHORT*(n-m))*(1./rat);
    double co=(rat-1.)/rat ;
    double tmp=0.;
    ans=one ;
    int cnt=1 ;
    while(ans-tmp>0.01){
      cnt++;
      tmp=ans ;
      ans+=(one*cnt)*co ;
      co*=(rat-1.)/rat ;
    }
    System.out.println(Math.round(ans));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute LONG : int := 1900;
   attribute SHORT : int := 100;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.read() ; 
     m.solve() );
   operation read() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
     m := sc.getCurrent()->toInteger() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var ans : double ; ans := 0. ;
     var rat : double ; rat := (2*(2->pow((m - 1))))->oclAsType(long) ;
    var one : double ; one := (LONG * m + SHORT * (n - m)) * (1. / rat) ;
    var co : double ; co := (rat - 1.) / rat ;
    var tmp : double ; tmp := 0. ;
    ans := one ; 
    var cnt : int ; cnt := 1 ;
    while (ans - tmp > 0.01) do (     cnt := cnt + 1 ; 
     tmp := ans ; 
     ans := ans+((one * cnt) * co) ; 
     co := co*((rat - 1.) / rat) ) ; 
    OclFile["System.out"].println((ans)->round()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    FastScanner in=new FastScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskC solver=new TaskC();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskC {
    public void solve(int testNumber,FastScanner in,PrintWriter out){
      int n=in.nextInt();
      int m=in.nextInt();
      int ans=(n-m)*100+1900*m ;
      ans*=1<<m ;
      out.println(ans);
    }
  }
  static class FastScanner {
    private BufferedReader in ;
    private StringTokenizer st ;
    public FastScanner(InputStream stream){
      in=new BufferedReader(new InputStreamReader(stream));
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          String rl=in.readLine();
          if(rl==null){
            return null ;
          }
          st=new StringTokenizer(rl);
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : FastScanner ; in := FastScanner.newFastScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskC ; solver := TaskC.newTaskC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskC {
   operation solve( testNumber : int, in : FastScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var m : int ; m := in.nextInt() ;
    var ans : int ; ans := (n - m) * 100 + 1900 * m ;
    ans := ans*((1*(2->pow(m)))->oclAsType(long)) ; 
    skip ; 
 );
}
  static class FastScanner {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( stream : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     var rl : String ; rl := in.readLine() ;
     if (rl = null) then (     return null ) else skip ; 
     st := OclIterator.newOclIterator_String(rl) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  static int pow(int a,int b){
    int ans=1 ;
    for(int i=0 ; i<b ; i++)ans*=a ;
    return ans ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    long cycle=1900*M+100*(N-M);
    int trial=pow(2,M);
    System.out.println(cycle*trial);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation pow( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
         var i : int ; i := 0 ; while i < b do (     ans := ans*(a) ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var cycle : long ; cycle := 1900 * M + 100 * (N - M) ;
    var trial : int ; trial := pow(2, M) ;
    OclFile["System.out"].println(cycle * trial) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(in,out);
    out.close();
  }
  static class Task {
    void solve(InputReader in,PrintWriter out){
      int N=in.nextInt();
      long[] lucas=new long[N+1];
      lucas[0]=2 ;
      lucas[1]=1 ;
      for(int i=2 ; i<N+1 ; i++){
        lucas[i]=lucas[i-1]+lucas[i-2];
      }
      out.println(lucas[N]);
    }
  }
  static class InputReader {
    BufferedReader reader ;
    StringTokenizer tokenizer ;
    InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream));
      tokenizer=null ;
    }
    String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.nextInt() ;
     var lucas : Sequence(long) ; lucas := Integer.subrange(1,N + 1)->collect(0) ;
    lucas[0+1] := 2 ; 
    lucas[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < N + 1 do ( (     lucas[i+1] := lucas[i - 1+1] + lucas[i - 2+1] )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  void solve(){
    int n=in.nextInt(),m=in.nextInt();
    out.println((1L<<m)*(1900*m+100*(n-m)));
  }
  FastScanner in ;
  PrintWriter out ;
  void run(){
    in=new FastScanner();
    out=new PrintWriter(System.out);
    solve();
    out.close();
  }
  class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public FastScanner(String s){
      try {
        br=new BufferedReader(new FileReader(s));
      }
      catch(FileNotFoundException e){
        e.printStackTrace();
      }
    }
    public String nextToken(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(nextToken());
    }
    public long nextLong(){
      return Long.parseLong(nextToken());
    }
    public double nextDouble(){
      return Double.parseDouble(nextToken());
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
    var m : int ; m := in.nextInt() ;
     out.println(((1L*(2->pow(m)))->oclAsType(long)) * (1900 * m + 100 * (n - m))) );
   attribute in : FastScanner;
   attribute out : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     in := FastScanner.newFastScanner() ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     execute solve() ; 
     skip );
 class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
 );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
class Main {
  public static Scanner sc=new Scanner(in);
  public static Random rand=new Random();
  char[][] vals=new char[][] {
    {
    },{
    '.',',','!','?',' ' },{
      'a','b','c' },{
        'd','e','f' },{
          'g','h','i' },{
            'j','k','l' },{
              'm','n','o' },{
                'p','q','r','s' },{
                  't','u','v' },{
                    'w','x','y','z' },};
                    public void run(){
                      char[] keys=sc.next().toCharArray();
                      StringBuilder sb=new StringBuilder();
                      char now=0 ;
                      int times=-1 ;
                      for(int i=0 ; i<keys.length ; i++){
                        char key=keys[i];
                        if(key=='0'){
                          if(Character.isDigit(now)){
                            sb.append(vals[now-'0'][times % vals[now-'0'] .length]);
                          }
                          now=0 ;
                          times=-1 ;
                        }
                        else {
                          now=key ;
                          times++;
                        }
                      }
                      ln(sb);
                    }
                    public static void main(String[] args){
                      int n=sc.nextInt();
                      while(n--!=0)new Main().run();
                    }
                    public int[] nextIntArray(int n){
                      int[] res=new int[n];
                      for(int i=0 ; i<n ; i++){
                        res[i]=sc.nextInt();
                      }
                      return res ;
                    }
                    public static void pr(Object o){
                      out.print(o);
                    }
                    public static void ln(Object o){
                      out.println(o);
                    }
                    public static void ln(){
                      out.println();
                    }
                  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(in);
  static   attribute rand : OclRandom := OclRandom.newOclRandom();
   attribute vals : Sequence(Sequence(String)) := Sequence{Sequence{},Sequence{'.',',','!','?',' '},Sequence{'a','b','c'},Sequence{'d','e','f'},Sequence{'g','h','i'},Sequence{'j','k','l'},Sequence{'m','n','o'},Sequence{'p','q','r','s'},Sequence{'t','u','v'},Sequence{'w','x','y','z'},};
   operation run() : void
  pre: true
  post: true
  activity: (     var keys : Sequence(String) ; keys := sc.getCurrent()->characters() ;
     var sb : String ; sb := StringLib.newString() ;
    var now : String ; now := 0 ;
    var times : int ; times := -1 ;
        var i : int ; i := 0 ; while i < keys->size() do ( (     var key : String ; key := keys[i+1] ;
     if (key = '0') then (     if ((now + "")->isMatch("[0-9]")) then (     sb := sb + StringLib.newString(vals[(now)->char2byte() - ('0')->char2byte()+1][times mod vals[(now)->char2byte() - ('0')->char2byte()+1]->size()+1]) ) else skip ; 
     now := 0 ; 
     times := -1 ) else (     now := key ; 
     times := times + 1 ) )  ;     i := i + 1 ) ; 
    execute ln(sb) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
         while (n /= 0) do (    skip ;     Main.newMain().run() ; ;  ) );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return res );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     out.println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B_Segments {
  static Scanner in=new Scanner(System.in);
  static int n ;
  static void solve(){
    int possible_pair=(n*(n+1))/2 ;
    int ans=(int)((Math.floor((double)n/2.0)+1.0)*Math.ceil((double)n/2.0));
    System.out.print(ans);
  }
  public static void main(String[] amit){
    n=in.nextInt();
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Segments {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var possible_pair : int ; possible_pair := (n * (n + 1)) / 2 ;
     var ans : int ; ans := (((n->oclAsType(double) / 2.0)->floor() + 1.0) * (n->oclAsType(double) / 2.0)->ceil())->oclAsType(int) ;
     OclFile["System.out"].print(ans) );
  static   operation main( amit : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := in.getCurrent()->toInteger() ; 
     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    int M=Integer.parseInt(sc.next());
    double c=1900.0*M+100.0*(N-M);
    double p=1.0 ;
    double res=0.0 ;
    double q=1.0 ;
    for(int i=0 ; i<M ; i++)p*=0.5 ;
    for(int i=1 ; i<3000000 ; i++){
      res+=i*c*p*q ;
      q*=1-p ;
    }
    double eps=0.0000001 ;
    int ret=(int)Math.floor(res+eps);
    System.out.println(ret);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var M : int ; M := (sc.getCurrent())->toInteger() ;
    var c : double ; c := 1900.0 * M + 100.0 * (N - M) ;
    var p : double ; p := 1.0 ;
    var res : double ; res := 0.0 ;
    var q : double ; q := 1.0 ;
        var i : int ; i := 0 ; while i < M do (     p := p*(0.5) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < 3000000 do ( (     res := res+(i * c * p * q) ; 
     q := q*(1 - p) )  ;     i := i + 1 ) ; 
    var eps : double ; eps := 0.0000001 ;
    var ret : int ; ret := (res + eps)->floor()->oclAsType(int) ;
    OclFile["System.out"].println(ret) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int LucasSum(int N){
    int sum=0 ;
    int a=2,b=1,c ;
    sum+=a ;
    while(b<=N){
      sum+=b ;
      c=a+b ;
      a=b ;
      b=c ;
    }
    return sum ;
  }
  public static void main(String[] args){
    int N=20 ;
    System.out.println(LucasSum(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation LucasSum( N : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var a : int ; a := 2 ;
    var b : int ; b := 1 ;
    var c : int ;
    sum := sum+(a) ; 
    while (b <= N) do (     sum := sum+(b) ; 
     c := a + b ; 
     a := b ; 
     b := c ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 20 ;
     OclFile["System.out"].println(LucasSum(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int v=sc.nextInt();
      int e=sc.nextInt();
      int r=sc.nextInt();
      int INF=100000000 ;
      int[] s=new int[e];
      int[] t=new int[e];
      int[] cost=new int[e];
      for(int i=0 ; i<e ; i++){
        s[i]=sc.nextInt();
        t[i]=sc.nextInt();
        cost[i]=sc.nextInt();
      }
      int[] d=new int[v];
      for(int i=0 ; i<v ; i++){
        d[i]=INF ;
      }
      d[r]=0 ;
      int count=0 ;
      int end=1 ;
      for(int k=0 ; k<v ; k++){
        count++;
        boolean update=false ;
        for(int i=0 ; i<e ; i++){
          if(d[s[i] ]<INF && d[t[i] ]>d[s[i] ]+cost[i]){
            if(count==v){
              end=0 ;
              break ;
            }
            d[t[i] ]=d[s[i] ]+cost[i];
            update=true ;
          }
        }
        if(! update){
          break ;
        }
        if(end==0){
          break ;
        }
      }
      if(end==0){
        System.out.println("NEGATIVE CYCLE");
      }
      else {
        for(int i=0 ; i<v ; i++){
          if(d[i]==INF)System.out.println("INF");
          else System.out.println(d[i]);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var v : int ; v := sc.getCurrent()->toInteger() ;
     var e : int ; e := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var INF : int ; INF := 100000000 ;
    var s : Sequence(int) ; s := Integer.subrange(1,e)->collect(0) ;
    var t : Sequence(int) ; t := Integer.subrange(1,e)->collect(0) ;
    var cost : Sequence(int) ; cost := Integer.subrange(1,e)->collect(0) ;
        var i : int ; i := 0 ; while i < e do ( (     s[i+1] := sc.getCurrent()->toInteger() ; 
     t[i+1] := sc.getCurrent()->toInteger() ; 
     cost[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var d : Sequence(int) ; d := Integer.subrange(1,v)->collect(0) ;
        var i : int ; i := 0 ; while i < v do ( (     d[i+1] := INF )  ;     i := i + 1 ) ; 
    d[r+1] := 0 ; 
    var count : int ; count := 0 ;
    var end : int ; end := 1 ;
        var k : int ; k := 0 ; while k < v do ( (     count := count + 1 ; 
     var update : boolean ; update := false ;
        var i : int ; i := 0 ; while i < e do ( (     if (d[s[i+1]+1] < INF & d[t[i+1]+1] > d[s[i+1]+1] + cost[i+1]) then (     if (count = v) then (     end := 0 ; 
     break ) else skip ; 
     d[t[i+1]+1] := d[s[i+1]+1] + cost[i+1] ; 
     update := true ) else skip )  ;     i := i + 1 ) ; 
    if (not(update)) then (     break ) else skip ; 
    if (end = 0) then (     break ) else skip ; 
 )  ;     k := k + 1 ) ; 
    if (end = 0) then (     OclFile["System.out"].println("NEGATIVE CYCLE") ) else (         var i : int ; i := 0 ; while i < v do ( (     if (d[i+1] = INF) then     OclFile["System.out"].println("INF") ; else     OclFile["System.out"].println(d[i+1]) ; )  ;     i := i + 1 ) ) ;  
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int INF=Integer.MAX_VALUE/2 ;
  static class Edge {
    int from ;
    int to ;
    int cost ;
    Edge(int from,int to,int cost){
      this.from=from ;
      this.to=to ;
      this.cost=cost ;
    }
  }
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int V=stdIn.nextInt();
    int E=stdIn.nextInt();
    int r=stdIn.nextInt();
    int[] d=new int[V];
    Arrays.fill(d,INF);
    d[r]=0 ;
    ArrayList<Edge>list=new ArrayList<Edge>();
    for(int i=0 ; i<E ; i++){
      int s=stdIn.nextInt();
      int t=stdIn.nextInt();
      int l=stdIn.nextInt();
      Edge edge=new Edge(s,t,l);
      list.add(edge);
    }
    for(int i=0 ; i<V ; i++){
      for(int j=0 ; j<E ; j++){
        Edge edge=list.get(j);
        if(d[edge.from]!=INF && d[edge.to]>d[edge.from]+edge.cost){
          d[edge.to]=d[edge.from]+edge.cost ;
          if(i==V-1){
            System.out.println("NEGATIVE CYCLE");
            return ;
          }
        }
      }
    }
    for(int i=0 ; i<V ; i++){
      if(d[i]>INF/2){
        System.out.println("INF");
      }
      else {
        System.out.println(d[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := 2147483647 / 2;
  static class Edge {
   attribute from : int;
   attribute to : int;
   attribute cost : int;
   static operation newEdge( from : int, to : int, cost : int) : Edge
  pre: true
  post: true
  activity:
  ( var self : Edge ;
    self := createEdge();
    self.initialise(from, to,cost);
    return self );
  operation initialise( from : int, to : int, cost : int) : void
  pre: true  post: true
  activity: (     self.from := from ; 
     self.to := to ; 
     self.cost := cost );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var V : int ; V := stdIn.getCurrent()->toInteger() ;
    var E : int ; E := stdIn.getCurrent()->toInteger() ;
    var r : int ; r := stdIn.getCurrent()->toInteger() ;
    var d : Sequence(int) ; d := Integer.subrange(1,V)->collect(0) ;
    d := d->collect(INF) ; 
    d[r+1] := 0 ; 
    var list : Sequence(Edge) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < E do ( (     var s : int ; s := stdIn.getCurrent()->toInteger() ;
     var t : int ; t := stdIn.getCurrent()->toInteger() ;
    var l : int ; l := stdIn.getCurrent()->toInteger() ;
    var edge : Edge ; edge := Edge.newEdge(s, t, l) ;
    list := list->including(edge) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < V do ( (         var j : int ; j := 0 ; while j < E do ( (     var edge : Edge ; edge := list->at(j+1) ;
     if (d[edge.from+1] /= INF & d[edge.to+1] > d[edge.from+1] + edge.cost) then (     d[edge.to+1] := d[edge.from+1] + edge.cost ; 
     if (i = V - 1) then (     OclFile["System.out"].println("NEGATIVE CYCLE") ; 
     return ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < V do ( (     if (d[i+1] > INF / 2) then (     OclFile["System.out"].println("INF") ) else (     OclFile["System.out"].println(d[i+1]) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int v=sc.nextInt();
    int e=sc.nextInt();
    int s=sc.nextInt();
    int[][] edge=new int[e][3];
    for(int i=0 ; i<e ; i++){
      edge[i][0]=sc.nextInt();
      edge[i][1]=sc.nextInt();
      edge[i][2]=sc.nextInt();
    }
    long[] ans=bellmanFord(v,edge,s);
    if(ans==null)System.out.println("NEGATIVE CYCLE");
    else for(long a : ans){
      if(a==Long.MAX_VALUE)System.out.println("INF");
      else System.out.println(a);
    }
    sc.close();
  }
  public static long[] bellmanFord(int n,int[][] edge,int s){
    long d[]=new long[n];
    Arrays.fill(d,Long.MAX_VALUE);
    d[s]=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<edge.length ; j++){
        int[] e=edge[j];
        if(d[e[0] ]!=Long.MAX_VALUE && d[e[1] ]>d[e[0] ]+e[2]){
          d[e[1] ]=d[e[0] ]+e[2];
          if(i==n-1){
            d=null ;
            break ;
          }
        }
      }
    }
    return d ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var v : int ; v := sc.getCurrent()->toInteger() ;
    var e : int ; e := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var edge : Sequence(Sequence(int)) ; edge := Integer.subrange(1,e)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < e do ( (     edge[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     edge[i+1][1+1] := sc.getCurrent()->toInteger() ; 
     edge[i+1][2+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : Sequence(long) ; ans := bellmanFord(v, edge, s) ;
    if (ans = null) then     OclFile["System.out"].println("NEGATIVE CYCLE") else     for (a : ans) do ( (     if (a = "9223372036854775807"->toLong()) then     OclFile["System.out"].println("INF") ; else     OclFile["System.out"].println(a) ; )  ) ; ;  
    skip ; 
 );
  static   operation bellmanFord( n : int, edge : Sequence(Sequence(int)), s : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var d : Sequence(long) ; d := Integer.subrange(1,n)->collect(0) ;
     d := d->collect("9223372036854775807"->toLong()) ; 
    d[s+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < edge->size() do ( (     var e : Sequence(int) ; e := edge[j+1] ;
     if (d[e[0+1]+1] /= "9223372036854775807"->toLong() & d[e[1+1]+1] > d[e[0+1]+1] + e[2+1]) then (     d[e[1+1]+1] := d[e[0+1]+1] + e[2+1] ; 
     if (i = n - 1) then (     d := null ; 
     break ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return d 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int V=sc.nextInt();
    int E=sc.nextInt();
    int r=sc.nextInt();
    Edge[] edges=new Edge[E];
    for(int i=0 ; i<E ; i++){
      edges[i]=new Edge(sc.nextInt(),sc.nextInt(),sc.nextInt());
    }
    solve(V,E,r,edges);
  }
  public static void solve(int V,int E,int r,Edge[] edges){
    int[] cost=new int[V];
    Arrays.fill(cost,Integer.MAX_VALUE);
    cost[r]=0 ;
    for(int i=0 ; i<V ; i++){
      boolean update=false ;
      for(int j=0 ; j<E ; j++){
        Edge edge=edges[j];
        if(cost[edge.src]==Integer.MAX_VALUE){
          continue ;
        }
        if(cost[edge.src]+edge.cost<cost[edge.dest]){
          update=true ;
          cost[edge.dest]=cost[edge.src]+edge.cost ;
        }
      }
      if(i==V-1){
        if(update){
          System.out.println("NEGATIVE CYCLE");
        }
        else {
          for(int k=0 ; k<V ; k++){
            if(cost[k]==Integer.MAX_VALUE){
              System.out.println("INF");
            }
            else {
              System.out.println(cost[k]);
            }
          }
        }
      }
      update=false ;
    }
  }
}
class Edge {
  int src ;
  int dest ;
  int cost ;
  public Edge(int s,int d,int c){
    src=s ;
    dest=d ;
    cost=c ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var V : int ; V := sc.getCurrent()->toInteger() ;
    var E : int ; E := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var edges : Sequence(Edge) ; edges := Integer.subrange(1,E)->collect(null) ;
        var i : int ; i := 0 ; while i < E do ( (     edges[i+1] := Edge.newEdge(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    execute solve(V, E, r, edges) ; 
 );
  static   operation solve( V : int, E : int, r : int, edges : Sequence(Edge)) : void
  pre: true
  post: true
  activity: (     var cost : Sequence(int) ; cost := Integer.subrange(1,V)->collect(0) ;
     cost := cost->collect(2147483647) ; 
     cost[r+1] := 0 ; 
         var i : int ; i := 0 ; while i < V do ( (     var update : boolean ; update := false ;
         var j : int ; j := 0 ; while j < E do ( (     var edge : Edge ; edge := edges[j+1] ;
     if (cost[edge.src+1] = 2147483647) then (     continue ) else skip ; 
     if (cost[edge.src+1] + edge.cost < cost[edge.dest+1]) then (     update := true ; 
     cost[edge.dest+1] := cost[edge.src+1] + edge.cost ) else skip )  ;     j := j + 1 ) ; 
     if (i = V - 1) then (     if (update) then (     OclFile["System.out"].println("NEGATIVE CYCLE") ) else (         var k : int ; k := 0 ; while k < V do ( (     if (cost[k+1] = 2147483647) then (     OclFile["System.out"].println("INF") ) else (     OclFile["System.out"].println(cost[k+1]) ) )  ;     k := k + 1 ) ) ) else skip ; 
     update := false )  ;     i := i + 1 ) );
}
class Edge {
   attribute src : int;
   attribute dest : int;
   attribute cost : int;
   static operation newEdge( s : int, d : int, c : int) : Edge
  pre: true
  post: true
  activity:
  ( var self : Edge ;
    self := createEdge();
    self.initialise(s, d,c);
    return self );
  operation initialise( s : int, d : int, c : int) : void
  pre: true  post: true
  activity: (     src := s ; 
     dest := d ; 
     cost := c );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  private static final int MAX=99999 ;
  public static void main(String[] args)throws Exception {
    Scanner scanner=new Scanner(System.in);
    int V=scanner.nextInt();
    int E=scanner.nextInt();
    int src=scanner.nextInt();
    int[] dist=new int[V];
    int[][] edges=new int[E][3];
    for(int i=0 ; i<V ; ++i){
      dist[i]=MAX ;
    }
    dist[src]=0 ;
    for(int i=0 ; i<E ; ++i){
      int[] edge=new int[] {
        scanner.nextInt(),scanner.nextInt(),scanner.nextInt()};
        edges[i]=edge ;
      }
      for(int i=1 ; i<V ; ++i){
        boolean update=false ;
        for(int j=0 ; j<E ; ++j){
          int[] edge=edges[j];
          if(dist[edge[0] ]!=MAX && dist[edge[1] ]>dist[edge[0] ]+edge[2]){
            dist[edge[1] ]=dist[edge[0] ]+edge[2];
            update=true ;
          }
        }
        if(! update){
          break ;
        }
      }
      boolean containNegativeCycle=false ;
      for(int j=0 ; j<E ; ++j){
        int[] edge=edges[j];
        if(dist[edge[0] ]!=MAX && dist[edge[1] ]>dist[edge[0] ]+edge[2]){
          containNegativeCycle=true ;
          break ;
        }
      }
      if(containNegativeCycle){
        System.out.println("NEGATIVE CYCLE");
        return ;
      }
      for(int i=0 ; i<V ; ++i){
        System.out.println(dist[i]==MAX ? "INF" : dist[i]);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 99999;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var V : int ; V := scanner.getCurrent()->toInteger() ;
    var E : int ; E := scanner.getCurrent()->toInteger() ;
    var src : int ; src := scanner.getCurrent()->toInteger() ;
    var dist : Sequence(int) ; dist := Integer.subrange(1,V)->collect(0) ;
    var edges : Sequence(Sequence(int)) ; edges := Integer.subrange(1,E)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < V do ( (     dist[i+1] := MAX )  ;     i := i + 1 ) ; 
    dist[src+1] := 0 ; 
        var i : int ; i := 0 ; while i < E do ( (     var edge : Sequence(int) ; edge := Sequence{scanner.getCurrent()->toInteger(),scanner.getCurrent()->toInteger(),scanner.getCurrent()->toInteger()} ;
     edges[i+1] := edge )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < V do ( (     var update : boolean ; update := false ;
         var j : int ; j := 0 ; while j < E do ( (     var edge : Sequence(int) ; edge := edges[j+1] ;
     if (dist[edge[0+1]+1] /= MAX & dist[edge[1+1]+1] > dist[edge[0+1]+1] + edge[2+1]) then (     dist[edge[1+1]+1] := dist[edge[0+1]+1] + edge[2+1] ; 
     update := true ) else skip )  ;     j := j + 1 ) ; 
     if (not(update)) then (     break ) else skip )  ;     i := i + 1 ) ; 
    var containNegativeCycle : boolean ; containNegativeCycle := false ;
        var j : int ; j := 0 ; while j < E do ( (     var edge : Sequence(int) ; edge := edges[j+1] ;
     if (dist[edge[0+1]+1] /= MAX & dist[edge[1+1]+1] > dist[edge[0+1]+1] + edge[2+1]) then (     containNegativeCycle := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (containNegativeCycle) then (     OclFile["System.out"].println("NEGATIVE CYCLE") ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < V do ( (     OclFile["System.out"].println(if dist[i+1] = MAX then "INF" else dist[i+1] endif) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isUnique(int[] a,int n,int k){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=a[i];
    sum+=n-1 ;
    return(sum==k);
  }
  static public void main(String[] args){
    int[] a={
      3,3,3 };
      int n=a.length ;
      int k=12 ;
      if(isUnique(a,n,k))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isUnique( a : Sequence(int), n : int, k : int) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+(a[i+1]) ;  ;     i := i + 1 ) ; 
     sum := sum+(n - 1) ; 
     return (sum = k) );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{3,3,3} ;
     var n : int ; n := a->size() ;
     var k : int ; k := 12 ;
     if (isUnique(a, n, k)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void countPermutations(int N,int B){
    int x=(int)Math.pow(B,N);
    int y=(int)Math.pow(B,N-1);
    System.out.println(x-y);
  }
  public static void main(String[] args){
    int N=6 ;
    int B=4 ;
    countPermutations(N,B);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countPermutations( N : int, B : int) : void
  pre: true
  post: true
  activity: (     var x : int ; x := B->pow(N)->oclAsType(int) ;
     var y : int ; y := B->pow(N - 1)->oclAsType(int) ;
     OclFile["System.out"].println(x - y) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 6 ;
     var B : int ; B := 4 ;
     execute countPermutations(N, B) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int ans[]=new int[1010];
    int vis[]=new int[1010];
    int arr[]=new int[1010];
    int m=0 ;
    int n=cin.nextInt();
    for(int i=1 ; i<=n ; ++i){
      arr[i]=cin.nextInt();
    }
    arr[0]=0 ;
    for(int i=1 ; i<=n ; ++i){
      boolean flag=true ;
      for(int j=1 ; j-1<i ; ++j){
        vis[j-1]=arr[j]-arr[j-1];
      }
      for(int j=i+1 ; j<=n ; ++j){
        if(vis[(j-1)% i]!=arr[j]-arr[j-1]){
          flag=false ;
          break ;
        }
      }
      if(flag)ans[m++]=i ;
    }
    System.out.println(m);
    for(int i=0 ; i<m ; ++i){
      System.out.print(ans[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ans : Sequence(int) ; ans := Integer.subrange(1,1010)->collect(0) ;
    var vis : Sequence(int) ; vis := Integer.subrange(1,1010)->collect(0) ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,1010)->collect(0) ;
    var m : int ; m := 0 ;
    var n : int ; n := cin.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := cin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (     var flag : boolean ; flag := true ;
         var j : int ; j := 1 ; while j - 1 < i do ( (     vis[j - 1+1] := arr[j+1] - arr[j - 1+1] )  ;     j := j + 1 ) ; 
         var j : int ; j := i + 1 ; while j <= n do ( (     if (vis[(j - 1) mod i+1] /= arr[j+1] - arr[j - 1+1]) then (     flag := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (flag) then      ans[m+1] := i  ; m := m + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(m) ; 
        var i : int ; i := 0 ; while i < m do ( (     OclFile["System.out"].print(ans[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    while(true){
      int n=1000-in.nextInt();
      if(n==1000)return ;
      int cnt=0 ;
      if(n>=500){
        cnt++;
        n-=500 ;
      }
      if(n>=100){
        cnt+=n/100 ;
        n %=100 ;
      }
      if(n>=50){
        cnt++;
        n-=50 ;
      }
      if(n>=10){
        cnt+=n/10 ;
        n %=10 ;
      }
      if(n>=5){
        cnt++;
        n-=5 ;
      }
      cnt+=n ;
      System.out.println(cnt);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := 1000 - in.getCurrent()->toInteger() ;
     if (n = 1000) then     return else skip ; 
    var cnt : int ; cnt := 0 ;
    if (n >= 500) then (     cnt := cnt + 1 ; 
     n := n-(500) ) else skip ; 
    if (n >= 100) then (     cnt := cnt+(n / 100) ; 
     n := n mod 100 ) else skip ; 
    if (n >= 50) then (     cnt := cnt + 1 ; 
     n := n-(50) ) else skip ; 
    if (n >= 10) then (     cnt := cnt+(n / 10) ; 
     n := n mod 10 ) else skip ; 
    if (n >= 5) then (     cnt := cnt + 1 ; 
     n := n-(5) ) else skip ; 
    cnt := cnt+(n) ; 
    OclFile["System.out"].println(cnt) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] argv){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] a=new int[1001];
    for(int i=1 ; i<=N ; i++){
      a[i]=sc.nextInt();
    }
    int[] x=new int[1000];
    for(int i=1 ; i<=N ; i++){
      x[i-1]=a[i]-a[i-1];
    }
    List<Integer>ans=new ArrayList<>();
    for(int k=1 ; k<=N ; k++){
      boolean ok=true ;
      for(int i=0 ; i<N ; i++){
        if(x[i]!=x[i % k]){
          ok=false ;
          i=N+1 ;
        }
      }
      if(ok){
        ans.add(k);
      }
    }
    System.out.println(ans.size());
    for(int k : ans)System.out.print(k+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( argv : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,1001)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var x : Sequence(int) ; x := Integer.subrange(1,1000)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do ( (     x[i - 1+1] := a[i+1] - a[i - 1+1] )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := Sequence{} ;
        var k : int ; k := 1 ; while k <= N do ( (     var ok : boolean ; ok := true ;
         var i : int ; i := 0 ; while i < N do ( (     if (x[i+1] /= x[i mod k+1]) then (     ok := false ; 
     i := N + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (ok) then (     ans := ans->including(k) ) else skip )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(ans->size()) ; 
    for (k : ans) do (     OclFile["System.out"].print(k + " ") ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=100 ;
  static Vector<Integer>Prefix=new Vector<>();
  static int repeated_digit(int n){
    HashSet<Integer>a=new HashSet<>();
    int d ;
    while(n!=0){
      d=n % 10 ;
      if(a.contains(d))return 0 ;
      a.add(d);
      n/=10 ;
    }
    return 1 ;
  }
  static void pre_calculations(){
    Prefix.add(0);
    Prefix.add(repeated_digit(1));
    for(int i=2 ; i<MAX+1 ; i++)Prefix.add(repeated_digit(i)+Prefix.elementAt(i-1));
  }
  static int calculate(int L,int R){
    return Prefix.elementAt(R)-Prefix.elementAt(L-1);
  }
  public static void main(String[] args){
    int L=1,R=100 ;
    pre_calculations();
    System.out.println(calculate(L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100;
  static   attribute Prefix : Sequence(int) := Sequence{};
  static   operation repeated_digit( n : int) : int
  pre: true
  post: true
  activity: (     var a : Set(int) ; a := Set{} ;
     var d : int ;
     while (n /= 0) do (     d := n mod 10 ; 
     if (a->includes(d)) then     return 0 else skip ; 
     a := a->including(d) ; 
     n := n/(10) ) ; 
     return 1 );
  static   operation pre_calculations() : void
  pre: true
  post: true
  activity: (     Prefix := Prefix->including(0) ; 
     Prefix := Prefix->including(repeated_digit(1)) ; 
         var i : int ; i := 2 ; while i < MAX + 1 do (     Prefix := Prefix->including(repeated_digit(i) + Prefix->at(i - 1+1)) ;  ;     i := i + 1 ) );
  static   operation calculate( L : int, R : int) : int
  pre: true
  post: true
  activity: (     return Prefix->at(R+1) - Prefix->at(L - 1+1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 1 ;
    var R : int ; R := 100 ;
     execute pre_calculations() ; 
     OclFile["System.out"].println(calculate(L, R)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] arr=sc.next().toCharArray();
    int x=0 ;
    int y=0 ;
    for(char c : arr){
      if(c>='A' && c<='M'){
        y++;
      }
      else if(c>='N' && c<='Z'){
        y--;
      }
      else if(c>='a' && c<='m'){
        x++;
      }
      else {
        x--;
      }
    }
    StringBuilder sb=new StringBuilder();
    if(x>0){
      for(int i=0 ; i<x ; i++){
        sb.append("a");
      }
    }
    else {
      for(int i=0 ; i>x ; i--){
        sb.append("z");
      }
    }
    if(y>0){
      for(int i=0 ; i<y ; i++){
        sb.append("A");
      }
    }
    else {
      for(int i=0 ; i>y ; i--){
        sb.append("Z");
      }
    }
    System.out.println(sb.length());
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    for (c : arr) do ( (     if (c >= 'A' & c <= 'M') then (     y := y + 1 ) else     if (c >= 'N' & c <= 'Z') then (     y := y - 1 ) else     if (c >= 'a' & c <= 'm') then (     x := x + 1 ) else (     x := x - 1 ) ;  ;  )  ) ; 
    var sb : String ; sb := StringLib.newString() ;
    if (x > 0) then (         var i : int ; i := 0 ; while i < x do ( (     sb := sb + StringLib.newString("a") )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i > x do ( (     sb := sb + StringLib.newString("z") )  ;     i := i - 1 ) ) ;  
    if (y > 0) then (         var i : int ; i := 0 ; while i < y do ( (     sb := sb + StringLib.newString("A") )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i > y do ( (     sb := sb + StringLib.newString("Z") )  ;     i := i - 1 ) ) ;  
    OclFile["System.out"].println(sb->size()) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  int w ;
  int h ;
  int count ;
  short[][] map ;
  public void run(){
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      w=scan.nextInt();
      h=scan.nextInt();
      if(w==0 && h==0){
        break ;
      }
      map=new short[h][w];
      for(int i=0 ; i<h ; i++){
        for(int j=0 ; j<w ; j++){
          map[i][j]=scan.nextShort();
        }
      }
      count=0 ;
      for(int i=0 ; i<w ; i++){
        if(map[0][i]!=1){
          count+=ski(0,i);
        }
      }
      System.out.println(count);
    }
  }
  public int ski(int y,int x){
    if(y==h-1 && x>=0 && x<w){
      return 1 ;
    }
    int res=0 ;
    if(map[y][x]==2){
      if(y==h-2){
        return 1 ;
      }
      else if(map[y+2][x]==1){
        return 0 ;
      }
      else {
        res+=ski(y+2,x);
      }
    }
    else {
      if(x-1>=0 && map[y+1][x-1]==0){
        res+=ski(y+1,x-1);
      }
      if(map[y+1][x]!=1){
        res+=ski(y+1,x);
      }
      if(x+1<w && map[y+1][x+1]==0){
        res+=ski(y+1,x+1);
      }
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute w : int;
   attribute h : int;
   attribute count : int;
   attribute map : Sequence(Sequence(int));
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     w := scan.getCurrent()->toInteger() ; 
     h := scan.getCurrent()->toInteger() ; 
    if (w = 0 & h = 0) then (     break ) else skip ; 
    map := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ; 
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     map[i+1][j+1] := scan.nextShort() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    count := 0 ; 
        var i : int ; i := 0 ; while i < w do ( (     if (map[0+1][i+1] /= 1) then (     count := count+(ski(0, i)) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
   operation ski( y : int, x : int) : int
  pre: true
  post: true
  activity: (     if (y = h - 1 & x >= 0 & x < w) then (     return 1 ) else skip ; 
     var res : int ; res := 0 ;
     if (map[y+1][x+1] = 2) then (     if (y = h - 2) then (     return 1 ) else     if (map[y + 2+1][x+1] = 1) then (     return 0 ) else (     res := res+(ski(y + 2, x)) ) ;  ) else (     if (x - 1 >= 0 & map[y + 1+1][x - 1+1] = 0) then (     res := res+(ski(y + 1, x - 1)) ) else skip ; 
     if (map[y + 1+1][x+1] /= 1) then (     res := res+(ski(y + 1, x)) ) else skip ; 
     if (x + 1 < w & map[y + 1+1][x + 1+1] = 0) then (     res := res+(ski(y + 1, x + 1)) ) else skip ) ;  
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int H,W ;
  static int[][] field ;
  static int[][] dp ;
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    for(; ; ){
      W=cin.nextInt();
      H=cin.nextInt();
      if(W+H==0)break ;
      field=new int[H+2][W];
      dp=new int[H+2][W];
      for(int i=0 ; i<H ; i++){
        for(int j=0 ; j<W ; j++){
          field[i][j]=cin.nextInt();
        }
      }
      for(int i=0 ; i<W ; i++){
        if(field[0][i]==0)dp[0][i]=1 ;
      }
      for(int i=0 ; i<H ; i++){
        for(int j=0 ; j<W ; j++){
          if(field[i][j]==0){
            if(i!=H-1){
              for(int k=-1 ; k<=1 ; k++){
                if(j+k<0 || j+k>=W)continue ;
                if(field[i+1][j+k]==1)continue ;
                if(k!=0 && field[i+1][j+k]==2)continue ;
                dp[i+1][j+k]+=dp[i][j];
              }
            }
            else {
              dp[i+1][j]+=dp[i][j];
            }
          }
          else if(field[i][j]==2){
            dp[i+2][j]+=dp[i][j];
          }
        }
      }
      int ans=0 ;
      for(int i=H ; i<H+2 ; i++){
        for(int j=0 ; j<W ; j++){
          ans+=dp[i][j];
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute H : int;
  static   attribute field : Sequence(Sequence(int));
  static   attribute dp : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     W := cin.getCurrent()->toInteger() ; 
     H := cin.getCurrent()->toInteger() ; 
    if (W + H = 0) then     break else skip ; 
    field := Integer.subrange(1,H + 2)->collect(Integer.subrange(1,W)->collect(0)) ; 
    dp := Integer.subrange(1,H + 2)->collect(Integer.subrange(1,W)->collect(0)) ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     field[i+1][j+1] := cin.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < W do ( (     if (field[0+1][i+1] = 0) then     dp[0+1][i+1] := 1 ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (field[i+1][j+1] = 0) then (     if (i /= H - 1) then (         var k : int ; k := -1 ; while k <= 1 do ( (     if (j + k < 0 or j + k >= W) then     continue else skip ; 
     if (field[i + 1+1][j + k+1] = 1) then     continue else skip ; 
     if (k /= 0 & field[i + 1+1][j + k+1] = 2) then     continue else skip ; 
     dp[i + 1+1][j + k+1] := dp[i + 1+1][j + k+1]+(dp[i+1][j+1]) )  ;     k := k + 1 ) ) else (     dp[i + 1+1][j+1] := dp[i + 1+1][j+1]+(dp[i+1][j+1]) ) ) else     if (field[i+1][j+1] = 2) then (     dp[i + 2+1][j+1] := dp[i + 2+1][j+1]+(dp[i+1][j+1]) ) else skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := H ; while i < H + 2 do ( (         var j : int ; j := 0 ; while j < W do ( (     ans := ans+(dp[i+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      int w=in.nextInt(),h=in.nextInt();
      if(w==0 && h==0)break ;
      int board[][]=new int[h][w];
      int dp[][]=new int[h+1][w];
      for(int i=0 ; i<h ; i++)for(int j=0 ; j<w ; j++)board[i][j]=in.nextInt();
      for(int j=0 ; j<w ; j++)dp[0][j]=1 ;
      for(int i=0 ; i<h-1 ; i++){
        for(int j=0 ; j<w ; j++){
          if(board[i][j]==0){
            if(j>0 && board[i+1][j-1]!=2)dp[i+1][j-1]+=dp[i][j];
            if(j<w-1 && board[i+1][j+1]!=2)dp[i+1][j+1]+=dp[i][j];
            dp[i+1][j]+=dp[i][j];
          }
          else if(board[i][j]==2){
            dp[i+2][j]+=dp[i][j];
          }
        }
      }
      for(int j=0 ; j<w ; j++)if(board[h-1][j]!=1)dp[h][j]+=dp[h-1][j];
      int ans=0 ;
      for(int j=0 ; j<w ; j++)ans+=dp[h][j];
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var w : int ; w := in.getCurrent()->toInteger() ;
    var h : int ; h := in.getCurrent()->toInteger() ;
     if (w = 0 & h = 0) then     break else skip ; 
    var board : Sequence(Sequence(int)) ; board := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do (         var j : int ; j := 0 ; while j < w do (     board[i+1][j+1] := in.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < w do (     dp[0+1][j+1] := 1 ;  ;     j := j + 1 ) ; 
        var i : int ; i := 0 ; while i < h - 1 do ( (         var j : int ; j := 0 ; while j < w do ( (     if (board[i+1][j+1] = 0) then (     if (j > 0 & board[i + 1+1][j - 1+1] /= 2) then     dp[i + 1+1][j - 1+1] := dp[i + 1+1][j - 1+1]+(dp[i+1][j+1]) ; else skip ; 
     if (j < w - 1 & board[i + 1+1][j + 1+1] /= 2) then     dp[i + 1+1][j + 1+1] := dp[i + 1+1][j + 1+1]+(dp[i+1][j+1]) ; else skip ; 
     dp[i + 1+1][j+1] := dp[i + 1+1][j+1]+(dp[i+1][j+1]) ) else     if (board[i+1][j+1] = 2) then (     dp[i + 2+1][j+1] := dp[i + 2+1][j+1]+(dp[i+1][j+1]) ) else skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < w do (     if (board[h - 1+1][j+1] /= 1) then     dp[h+1][j+1] := dp[h+1][j+1]+(dp[h - 1+1][j+1]) ; else skip ;  ;     j := j + 1 ) ; 
    var ans : int ; ans := 0 ;
        var j : int ; j := 0 ; while j < w do (     ans := ans+(dp[h+1][j+1]) ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.System.in ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    int input=Integer.parseInt(reader.readLine());
    long[] ryuka=new long[87];
    ryuka[0]=2 ;
    ryuka[1]=1 ;
    for(int i=2 ; i<87 ; i++){
      ryuka[i]=ryuka[i-1]+ryuka[i-2];
    }
    System.out.println(ryuka[input]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     var input : int ; input := (reader.readLine())->toInteger() ;
    var ryuka : Sequence(long) ; ryuka := Integer.subrange(1,87)->collect(0) ;
    ryuka[0+1] := 2 ; 
    ryuka[1+1] := 1 ; 
        var i : int ; i := 2 ; while i < 87 do ( (     ryuka[i+1] := ryuka[i - 1+1] + ryuka[i - 2+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ryuka[input+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[][] move={
      {
        1,-1 },{
          1,0 },{
            1,1 }
          };
          while(true){
            int w=sc.nextInt();
            int h=sc.nextInt();
            if((w | h)==0)break ;
            int[][] map=new int[h+1][w];
            int[][] dp=new int[h][w];
            for(int i=0 ; i<h ; i++)for(int j=0 ; j<w ; j++)map[i][j]=sc.nextInt();
            for(int j=0 ; j<w ; j++)if(map[h-1][j]!=1)dp[h-1][j]=1 ;
            for(int i=h-2 ; i>=0 ; i--){
              for(int j=0 ; j<w ; j++){
                if(map[i][j]==1){
                  dp[i][j]=0 ;
                  continue ;
                }
                if(map[i][j]==2){
                  if(i+2==h)dp[i][j]=1 ;
                  else dp[i][j]=dp[i+2][j];
                }
                else {
                  int s=0 ;
                  for(int k=0 ; k<3 ; k++){
                    int ni=i+move[k][0];
                    int nj=j+move[k][1];
                    if(0<=nj && nj<w){
                      if(k!=1 && map[ni][nj]==2)continue ;
                      s+=dp[ni][nj];
                    }
                  }
                  dp[i][j]=s ;
                }
              }
            }
            int s=0 ;
            for(int j=0 ; j<w ; j++)s+=dp[0][j];
            System.out.println(s);
          }
        }
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var move : Sequence(Sequence(int)) ; move := Sequence{Sequence{1,-1},Sequence{1,0},Sequence{1,1}} ;
     while (true) do (     var w : int ; w := sc.getCurrent()->toInteger() ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(w,h)) = 0) then     break else skip ; 
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,h + 1)->collect(Integer.subrange(1,w)->collect(0)) ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do (         var j : int ; j := 0 ; while j < w do (     map[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < w do (     if (map[h - 1+1][j+1] /= 1) then     dp[h - 1+1][j+1] := 1 ; else skip ;  ;     j := j + 1 ) ; 
        var i : int ; i := h - 2 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < w do ( (     if (map[i+1][j+1] = 1) then (     dp[i+1][j+1] := 0 ; 
     continue ) else skip ; 
     if (map[i+1][j+1] = 2) then (     if (i + 2 = h) then     dp[i+1][j+1] := 1 ; else     dp[i+1][j+1] := dp[i + 2+1][j+1] ; ) else (     var s : int ; s := 0 ;
         var k : int ; k := 0 ; while k < 3 do ( (     var ni : int ; ni := i + move[k+1][0+1] ;
     var nj : int ; nj := j + move[k+1][1+1] ;
     if (0 <= nj & nj < w) then (     if (k /= 1 & map[ni+1][nj+1] = 2) then     continue else skip ; 
     s := s+(dp[ni+1][nj+1]) ) else skip )  ;     k := k + 1 ) ; 
     dp[i+1][j+1] := s ) )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    var s : int ; s := 0 ;
        var j : int ; j := 0 ; while j < w do (     s := s+(dp[0+1][j+1]) ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public void doIt(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int x=sc.nextInt();
      int y=sc.nextInt();
      if(x==0 && y==0){
        break ;
      }
      int[][] dp=new int[y+2][x+2];
      int[][] data=new int[y+2][x+2];
      for(int i=1 ; i<y+1 ; i++){
        for(int j=1 ; j<x+1 ; j++){
          data[i][j]=sc.nextInt();
        }
      }
      for(int i=1 ; i<x+1 ; i++){
        dp[1][i]=1 ;
      }
      for(int i=1 ; i<=y-1 ; i++){
        for(int j=1 ; j<=x ; j++){
          int posSta=data[i][j];
          if(posSta==1){
            continue ;
          }
          else if(posSta==2){
            dp[i+2][j]+=dp[i][j];
          }
          else {
            if(data[i+1][j-1]!=2){
              dp[i+1][j-1]+=dp[i][j];
            }
            dp[i+1][j]+=dp[i][j];
            if(data[i+1][j+1]!=2){
              dp[i+1][j+1]+=dp[i][j];
            }
          }
        }
      }
      int sum=0 ;
      for(int i=y ; i<=y+1 ; i++){
        for(int j=1 ; j<=x ; j++){
          if(data[i][j]==1)continue ;
          sum+=dp[i][j];
        }
      }
      System.out.println(sum);
    }
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    if (x = 0 & y = 0) then (     break ) else skip ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,y + 2)->collect(Integer.subrange(1,x + 2)->collect(0)) ;
    var data : Sequence(Sequence(int)) ; data := Integer.subrange(1,y + 2)->collect(Integer.subrange(1,x + 2)->collect(0)) ;
        var i : int ; i := 1 ; while i < y + 1 do ( (         var j : int ; j := 1 ; while j < x + 1 do ( (     data[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < x + 1 do ( (     dp[1+1][i+1] := 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= y - 1 do ( (         var j : int ; j := 1 ; while j <= x do ( (     var posSta : int ; posSta := data[i+1][j+1] ;
     if (posSta = 1) then (     continue ) else     if (posSta = 2) then (     dp[i + 2+1][j+1] := dp[i + 2+1][j+1]+(dp[i+1][j+1]) ) else (     if (data[i + 1+1][j - 1+1] /= 2) then (     dp[i + 1+1][j - 1+1] := dp[i + 1+1][j - 1+1]+(dp[i+1][j+1]) ) else skip ; 
     dp[i + 1+1][j+1] := dp[i + 1+1][j+1]+(dp[i+1][j+1]) ; 
     if (data[i + 1+1][j + 1+1] /= 2) then (     dp[i + 1+1][j + 1+1] := dp[i + 1+1][j + 1+1]+(dp[i+1][j+1]) ) else skip ) ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := y ; while i <= y + 1 do ( (         var j : int ; j := 1 ; while j <= x do ( (     if (data[i+1][j+1] = 1) then     continue else skip ; 
     sum := sum+(dp[i+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  static int n ;
  static long ans=1000000000 ;
  static int[] memo ;
  static int[] dp ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt()*1000 ;
    int a=sc.nextInt()*1000 ;
    int[] h=new int[n];
    for(int i=0 ; i<n ; i++){
      h[i]=sc.nextInt();
    }
    int ans=1000000000 ;
    int key=0 ;
    for(int i=0 ; i<n ; i++){
      int d=Math.abs(a-(t-h[i]*6));
      if(d<ans){
        key=i+1 ;
        ans=Math.min(ans,d);
      }
    }
    System.out.println(key);
  }
}
class Pair implements Comparable {
  int from ;
  int end ;
  int dis ;
  @ Override public int compareTo(Object other){
    Pair otherpair=(Pair)other ;
    return dis-otherpair.dis ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute ans : long := 1000000000;
  static   attribute memo : Sequence(int);
  static   attribute dp : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() * 1000 ;
    var a : int ; a := sc.getCurrent()->toInteger() * 1000 ;
    var h : Sequence(int) ; h := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     h[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 1000000000 ;
    var key : int ; key := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var d : int ; d := if a - (t - h[i+1] * 6) < 0 then -(a - (t - h[i+1] * 6)) else a - (t - h[i+1] * 6) endif ;
     if (d < ans) then (     key := i + 1 ; 
     ans := Set{ans, d}->min() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(key) ; 
 );
}
class Pair implements OclAny {
   attribute from : int;
   attribute end : int;
   attribute dis : int;
      operation compareTo( other : OclAny) : int
  pre: true
  post: true
  activity: (     var otherpair : Map ; otherpair := other->oclAsType(Map) ;
     return dis - otherpair.dis );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayList<Integer>ar=new ArrayList<Integer>();
    int N=sc.nextInt();
    int T=sc.nextInt();
    int A=sc.nextInt();
    int H[]=new int[N];
    for(int i=0 ; i<N ; i++){
      H[i]=sc.nextInt();
    }
    if(N==1){
      System.out.println(1);
    }
    else {
      double min=Math.abs((T-H[0]*0.006)-A);
      for(int i=1 ; i<N ; i++){
        if(Math.abs((T-H[i]*0.006)-A)<min){
          min=Math.abs((T-H[i]*0.006)-A);
          ar.add(i);
        }
      }
    }
    if(ar.size()==0){
      System.out.println(1);
    }
    else {
      System.out.println(ar.get(ar.size()-1)+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ar : Sequence(int) ; ar := Sequence{} ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var H : Sequence(int) ; H := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     H[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (N = 1) then (     OclFile["System.out"].println(1) ) else (     var min : double ; min := if (T - H[0+1] * 0.006) - A < 0 then -((T - H[0+1] * 0.006) - A) else (T - H[0+1] * 0.006) - A endif ;
         var i : int ; i := 1 ; while i < N do ( (     if (if (T - H[i+1] * 0.006) - A < 0 then -((T - H[i+1] * 0.006) - A) else (T - H[i+1] * 0.006) - A endif < min) then (     min := if (T - H[i+1] * 0.006) - A < 0 then -((T - H[i+1] * 0.006) - A) else (T - H[i+1] * 0.006) - A endif ; 
     ar := ar->including(i) ) else skip )  ;     i := i + 1 ) ) ;  
    if (ar->size() = 0) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(ar->at(ar->size() - 1+1) + 1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int price=sc.nextInt();
      if(price==0)break ;
      System.out.println(CountChange(1000-price));
    }
  }
  public static int CountChange(int p){
    int[] coins={
      500,100,50,10,5,1 };
      int cntcng=0 ;
      for(int c : coins){
        cntcng+=p/c ;
        p %=c ;
      }
      return cntcng ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var price : int ; price := sc.getCurrent()->toInteger() ;
     if (price = 0) then     break else skip ; 
     OclFile["System.out"].println(CountChange(1000 - price)) ) );
  static   operation CountChange( p : int) : int
  pre: true
  post: true
  activity: (     var coins : Sequence(int) ; coins := Sequence{500,100,50,10,5,1} ;
     var cntcng : int ; cntcng := 0 ;
     for (c : coins) do ( (     cntcng := cntcng+(p / c) ; 
     p := p mod c )  ) ; 
     return cntcng );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    double T=sc.nextDouble();
    int A=sc.nextInt();
    int ans=0 ;
    double min=Double.MAX_VALUE ;
    for(int i=0 ; i<N ; i++){
      double tmp=T-sc.nextDouble()*0.006 ;
      double t=Math.abs(A-tmp);
      if(t<min){
        ans=i+1 ;
        min=t ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var T : double ; T := sc.getCurrent()->toReal() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    var min : double ; min := (2 - 2->pow(-52))*(2->pow(1023)) ;
        var i : int ; i := 0 ; while i < N do ( (     var tmp : double ; tmp := T - sc.getCurrent()->toReal() * 0.006 ;
     var t : double ; t := if A - tmp < 0 then -(A - tmp) else A - tmp endif ;
     if (t < min) then (     ans := i + 1 ; 
     min := t ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n[]=new int[1000];
    int i=0 ;
    int a=scan.nextInt();
    int b=scan.nextInt();
    int c=scan.nextInt();
    do {
      n[i]=scan.nextInt();
      i++;
      if(i==a){
        break ;
      }
    }
    while(true);
    i=0 ;
    double ans1=1000000 ;
    double ans12=100000 ;
    double ans2=1000000 ;
    int ans3=0 ;
    do {
      ans1=b-0.006*n[i];
      ans12=c-ans1 ;
      if(ans12<0){
        ans12=ans12*-1 ;
      }
      if(ans12<ans2){
        ans2=ans12 ;
        ans3=i+1 ;
      }
      i++;
      if(i==a){
        break ;
      }
    }
    while(true);
    System.out.println(ans3);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : Sequence(int) ; n := Integer.subrange(1,1000)->collect(0) ;
    var i : int ; i := 0 ;
    var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    var c : int ; c := scan.getCurrent()->toInteger() ;
  while true do ((     n[i+1] := scan.getCurrent()->toInteger() ; 
     i := i + 1 ; 
     if (i = a) then (     break ) else skip ) ;
    if (true) then skip else break) ; 
    i := 0 ; 
    var ans1 : double ; ans1 := 1000000 ;
    var ans12 : double ; ans12 := 100000 ;
    var ans2 : double ; ans2 := 1000000 ;
    var ans3 : int ; ans3 := 0 ;
  while true do ((     ans1 := b - 0.006 * n[i+1] ; 
     ans12 := c - ans1 ; 
    if (ans12 < 0) then (     ans12 := ans12 * -1 ) else skip ; 
    if (ans12 < ans2) then (     ans2 := ans12 ; 
     ans3 := i + 1 ) else skip ; 
    i := i + 1 ; 
    if (i = a) then (     break ) else skip ; 
 ) ;
    if (true) then skip else break) ; 
    OclFile["System.out"].println(ans3) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  static Scanner in ;
  static PrintWriter out ;
  static void solve(){
    Scanner stdIn=new Scanner(System.in);
    int N=stdIn.nextInt();
    int T=stdIn.nextInt();
    int A=stdIn.nextInt();
    int[] H=new int[N];
    for(int i=0 ; i<N ; i++){
      H[i]=stdIn.nextInt();
    }
    int answer=1 ;
    double near_A=Math.abs(A-(T-(H[0]*0.006)));
    for(int i=1 ; i<N ; i++){
      if(near_A>Math.abs(A-(T-(H[i]*0.006)))){
        answer=i+1 ;
        near_A=Math.abs(A-(T-(H[i]*0.006)));
      }
    }
    System.out.println(answer);
  }
  public static void main(String[] args){
    in=new Scanner(System.in);
    out=new PrintWriter(System.out);
    solve();
    out.flush();
    out.close();
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := stdIn.getCurrent()->toInteger() ;
    var T : int ; T := stdIn.getCurrent()->toInteger() ;
    var A : int ; A := stdIn.getCurrent()->toInteger() ;
    var H : Sequence(int) ; H := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     H[i+1] := stdIn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var answer : int ; answer := 1 ;
    var near_A : double ; near_A := if A - (T - (H[0+1] * 0.006)) < 0 then -(A - (T - (H[0+1] * 0.006))) else A - (T - (H[0+1] * 0.006)) endif ;
        var i : int ; i := 1 ; while i < N do ( (     if (near_A > if A - (T - (H[i+1] * 0.006)) < 0 then -(A - (T - (H[i+1] * 0.006))) else A - (T - (H[i+1] * 0.006)) endif) then (     answer := i + 1 ; 
     near_A := if A - (T - (H[i+1] * 0.006)) < 0 then -(A - (T - (H[i+1] * 0.006))) else A - (T - (H[i+1] * 0.006)) endif ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Discriminant {
  static int disc(int a,int b,int c){
    int dis=(int)Math.pow(b,2)-(4*a*c);
    return dis ;
  }
  public static void main(String args[]){
    int a=20 ;
    int b=30 ;
    int c=10 ;
    int discriminant=disc(a,b,c);
    if(discriminant>0){
      System.out.println("Discriminant is "+discriminant+" which is Positive");
      System.out.println("Hence Two Solutions");
    }
    else if(discriminant==0){
      System.out.println("Discriminant is "+discriminant+" which is Zero");
      System.out.println("Hence One Solution");
    }
    else {
      System.out.println("Discriminant is "+discriminant+" which is Negative");
      System.out.println("Hence No Real Solutions");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class Discriminant {
  static   operation disc( a : int, b : int, c : int) : int
  pre: true
  post: true
  activity: (     var dis : int ; dis := b->pow(2)->oclAsType(int) - (4 * a * c) ;
     return dis );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 20 ;
     var b : int ; b := 30 ;
    var c : int ; c := 10 ;
    var discriminant : int ; discriminant := disc(a, b, c) ;
    if (discriminant > 0) then (     OclFile["System.out"].println("Discriminant is " + discriminant + " which is Positive") ; 
     OclFile["System.out"].println("Hence Two Solutions") ) else     if (discriminant = 0) then (     OclFile["System.out"].println("Discriminant is " + discriminant + " which is Zero") ; 
     OclFile["System.out"].println("Hence One Solution") ) else (     OclFile["System.out"].println("Discriminant is " + discriminant + " which is Negative") ; 
     OclFile["System.out"].println("Hence No Real Solutions") ) ;  ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null){
      int n=Integer.parseInt(line.substring(0,line.indexOf(' ')));
      int m=Integer.parseInt(line.substring(line.indexOf(' ')+1));
      if(n==0 && m==0)break ;
      m++;
      int[] wish=new int[m];
      for(int i=0 ; i<n ; i++){
        StringTokenizer st=new StringTokenizer(br.readLine());
        for(int j=1 ; j<m ; j++){
          if(st.nextToken().equals("1"))wish[j]++;
        }
      }
      StringBuilder sb=new StringBuilder();
      for(int i=n ; i>=0 ; i--){
        for(int j=1 ; j<m ; j++){
          if(wish[j]==i)sb.append(j+" ");
        }
      }
      System.out.println(sb.toString().substring(0,sb.length()-1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     var n : int ; n := (line.subrange(0+1,line->indexOf(' ')-1))->toInteger() ;
     var m : int ; m := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1))->toInteger() ;
    if (n = 0 & m = 0) then     break else skip ; 
    m := m + 1 ; 
    var wish : Sequence(int) ; wish := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
         var j : int ; j := 1 ; while j < m do ( (     if (st.next() = "1") then     wish[j+1] := wish[j+1] + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := n ; while i >= 0 do ( (         var j : int ; j := 1 ; while j < m do ( (     if (wish[j+1] = i) then     sb := sb + StringLib.newString(j + " ") ; else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(sb+"".subrange(0+1,sb->size() - 1)) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    BigInteger n=scanner.nextBigInteger();
    BigInteger lPrev=new BigInteger("2");
    BigInteger l=new BigInteger("1");
    BigInteger i=new BigInteger("1");
    BigInteger one=new BigInteger("1");
    if(n.equals(one)){
      System.out.println(1);
      return ;
    }
    while(! i.equals(n)){
      BigInteger lNext=l.add(lPrev);
      lPrev=l ;
      l=lNext ;
      i=i.add(one);
    }
    System.out.println(l.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := scanner.nextBigInteger() ;
    var lPrev : long ; lPrev := long("2") ;
    var l : long ; l := long("1") ;
    var i : long ; i := long("1") ;
    var one : long ; one := long("1") ;
    if (n = one) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    while (not(i = n)) do (     var lNext : long ; lNext := l->excludes(lPrev) ;
     lPrev := l ; 
     l := lNext ; 
     i := i->excludes(one) ) ; 
    OclFile["System.out"].println(l+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if((n | m)==0){
        break ;
      }
      class R {
        int id,count ;
      }
      R[] rs=new R[m];
      for(int i=0 ; i<m ; i++){
        rs[i]=new R();
        rs[i] .id=i+1 ;
      }
      for(int j=0 ; j<n ; j++){
        for(int i=0 ; i<m ; i++){
          rs[i] .count+=sc.nextInt();
        }
      }
      Arrays.sort(rs,new Comparator<R>(){
        @ Override public int compare(R r1,R r2){
          if(r1.count!=r2.count){
            return r2.count-r1.count ;
          }
          else {
            return r1.id-r2.id ;
          }
        }
      }
);
      for(int i=0 ; i<m ; i++){
        print(rs[i] .id+(i==m-1 ? "\n" : " "));
      }
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,m)) = 0) then (     break ) else skip ; 
class R {
   attribute id : int;
}
    var rs : Sequence(R) ; rs := Integer.subrange(1,m)->collect(null) ;
        var i : int ; i := 0 ; while i < m do ( (     rs[i+1] := R.newR() ; 
     rs[i+1].id := i + 1 )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (         var i : int ; i := 0 ; while i < m do ( (     rs[i+1].count := rs[i+1].count+(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    rs := OclComparator.sortWith(rs, OclComparator<R>.newOclComparator()) ; 
        var i : int ; i := 0 ; while i < m do ( (     execute print(rs[i+1].id + (if i = m - 1 then "\n" else " " endif)) )  ;     i := i + 1 ) ; 
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static public void main(String[] argv){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
      PrintWriter pw=new PrintWriter(bw,true);
      while(true){
        String buf=br.readLine();
        StringTokenizer st=new StringTokenizer(buf);
        int n,m ;
        n=Integer.valueOf(st.nextToken());
        m=Integer.valueOf(st.nextToken());
        if(n==0 && m==0)break ;
        int[] count=new int[m];
        for(int i=0 ; i<n ; i++){
          buf=br.readLine();
          st=new StringTokenizer(buf);
          for(int j=0 ; j<m ; j++){
            int e=Integer.valueOf(st.nextToken());
            if(e==1)++count[j];
          }
        }
        ArrayList<Integer>res=solve(count,n,m);
        int num=res.size();
        for(int i=0 ; i<num ; i++){
          pw.print(res.get(i));
          if(i<num-1)pw.print(" ");
        }
        pw.println();
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  static ArrayList<Integer>solve(int[] count,int n,int m){
    ArrayList<Integer>ret=new ArrayList<Integer>();
    for(int i=n ; i>=0 ; i--){
      for(int j=0 ; j<m ; j++){
        if(count[j]==i)ret.add(new Integer(j+1));
      }
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    operation main( argv : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(bw, true) ;
     while (true) do (     var buf : String ; buf := br.readLine() ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(buf) ;
    var n : int ;
    var m : int ;
    n := (st.next())->toInteger() ; 
    m := (st.next())->toInteger() ; 
    if (n = 0 & m = 0) then     break else skip ; 
    var count : Sequence(int) ; count := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     buf := br.readLine() ; 
     st := OclIterator.newOclIterator_String(buf) ; 
         var j : int ; j := 0 ; while j < m do ( (     var e : int ; e := (st.next())->toInteger() ;
     if (e = 1) then     count[j+1] := count[j+1] + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : Sequence(int) ; res := solve(count, n, m) ;
    var num : int ; num := res->size() ;
        var i : int ; i := 0 ; while i < num do ( (     skip ; 
     if (i < num - 1) then     skip ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
  static   operation solve( count : Sequence(int), n : int, m : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ret : Sequence(int) ; ret := Sequence{} ;
         var i : int ; i := n ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < m do ( (     if (count[j+1] = i) then     ret := ret->including(("" + (j + 1))->toInteger()) ; else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static class Pair implements Comparable<Pair>{
    public int first=0,second=0 ;
    @ Override public int compareTo(Pair other){
      return other.second-this.second ;
    }
  }
  public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    int n,m ;
    while(true){
      n=scanner.nextInt();
      m=scanner.nextInt();
      if(n==0 && m==0){
        break ;
      }
      Pair[] a=new Pair[m];
      for(int i=0 ; i<m ; i++){
        a[i]=new Pair();
        a[i] .first=i+1 ;
      }
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<m ; j++){
          a[j] .second+=scanner.nextInt();
        }
      }
      Arrays.sort(a);
      for(int i=0 ; i<m ; i++)System.out.print(a[i] .first+(i==m-1 ? "" : " "));
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Pair implements Comparable<Map> {
   attribute first : int := 0;
      operation compareTo( other : Map) : int
  pre: true
  post: true
  activity: (     return other->at("second") - self->at("second") );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var m : int ;
     while (true) do (     n := scanner.getCurrent()->toInteger() ; 
     m := scanner.getCurrent()->toInteger() ; 
    if (n = 0 & m = 0) then (     break ) else skip ; 
    var a : Sequence(Map) ; a := Integer.subrange(1,m)->collect(null) ;
        var i : int ; i := 0 ; while i < m do ( (     a[i+1] := Map() ; 
     a[i+1]->at("first") := i + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     a[j+1]->at("second") := a[j+1]->at("second")+(scanner.getCurrent()->toInteger()) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
        var i : int ; i := 0 ; while i < m do (     OclFile["System.out"].print(a[i+1]->at("first") + (if i = m - 1 then "" else " " endif)) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    boolean[] arg=null ;
    int[] states=null ;
    int kouho=0,member=0 ;
    int i=0 ;
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String line ;
      while((line=br.readLine())!=null){
        String[] tokens=line.split(" ");
        if(tokens.length==2){
          member=Integer.parseInt(tokens[0]);
          kouho=Integer.parseInt(tokens[1]);
          states=new int[kouho];
          if(member==0 && kouho==0)break ;
          i=0 ;
        }
        else {
          for(int k=0 ; k<kouho ; k++){
            states[k]+=Integer.parseInt(tokens[k]);
          }
          i++;
          if(i==member){
            int[] score=new int[kouho];
            int count=0 ;
            for(int l=member ; -1<l ; l--){
              for(int j=0 ; j<kouho ; j++){
                if(states[j]==l){
                  score[count]=j+1 ;
                  count++;
                }
                if(count==kouho){
                  break ;
                }
              }
              if(count==kouho){
                break ;
              }
            }
            String[] str=new String[kouho];
            for(int l=0 ; l<kouho ; l++){
              str[l]=Integer.toString(score[l]);
            }
            System.out.print(String.join(" ",str));
            System.out.println();
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arg : Sequence(boolean) ; arg := null ;
     var states : Sequence(int) ; states := null ;
    var kouho : int ; kouho := 0 ;
    var member : int ; member := 0 ;
    var i : int ; i := 0 ;
    try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     var tokens : Sequence(String) ; tokens := line->split(" ") ;
     if (tokens->size() = 2) then (     member := (tokens[0+1])->toInteger() ; 
     kouho := (tokens[1+1])->toInteger() ; 
    states := Integer.subrange(1,kouho)->collect(0) ; 
    if (member = 0 & kouho = 0) then     break else skip ; 
    i := 0 ; 
 ) else (         var k : int ; k := 0 ; while k < kouho do ( (     states[k+1] := states[k+1]+((tokens[k+1])->toInteger()) )  ;     k := k + 1 ) ; 
     i := i + 1 ; 
     if (i = member) then (     var score : Sequence(int) ; score := Integer.subrange(1,kouho)->collect(0) ;
     var count : int ; count := 0 ;
        var l : int ; l := member ; while -1 < l do ( (         var j : int ; j := 0 ; while j < kouho do ( (     if (states[j+1] = l) then (     score[count+1] := j + 1 ; 
     count := count + 1 ) else skip ; 
     if (count = kouho) then (     break ) else skip )  ;     j := j + 1 ) ; 
     if (count = kouho) then (     break ) else skip )  ;     l := l - 1 ) ; 
    var str : Sequence(String) ; str := Integer.subrange(1,kouho)->collect(null) ;
        var l : int ; l := 0 ; while l < kouho do ( (     str[l+1] := ((score[l+1]) + "") )  ;     l := l + 1 ) ; 
    OclFile["System.out"].print(join(" ", str)) ; 
    OclFile["System.out"].println() ; 
 ) else skip ) ) ;     line := br.readLine() ;
 ) ))  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void minSwaps(String str1,String str2){
    int count=0 ;
    for(int i=0 ; i<str1.length(); i++){
      if(str1.charAt(i)!=str2.charAt(i))count++;
    }
    if(count % 2==0)System.out.println(count/2);
    else System.out.println("Not Possible");
  }
  public static void main(String args[]){
    String binaryString1="1110000" ;
    String binaryString2="0001101" ;
    minSwaps(binaryString1,binaryString2);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minSwaps( str1 : String, str2 : String) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < str1->size() do ( (     if (str1->at(i+1) /= str2->at(i+1)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     if (count mod 2 = 0) then     OclFile["System.out"].println(count / 2) ; else     OclFile["System.out"].println("Not Possible") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var binaryString1 : String ; binaryString1 := "1110000" ;
     var binaryString2 : String ; binaryString2 := "0001101" ;
     execute minSwaps(binaryString1, binaryString2) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    int[] conis=new int[] {
      500,100,50,10,5,1 };
      int[] charge=new int[1000];
      for(int i=1 ; i<charge.length ; i++){
        int k=1000-i ;
        for(int coin : conis){
          charge[i]+=k/coin ;
          k %=coin ;
          if(k==0){
            break ;
          }
        }
      }
      while((line=br.readLine())!=null && ! line.isEmpty()){
        int n=Integer.parseInt(line);
        if(n==0){
          break ;
        }
        System.out.println(charge[n]);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
    var conis : Sequence(int) ; conis := Sequence{500,100,50,10,5,1} ;
    var charge : Sequence(int) ; charge := Integer.subrange(1,1000)->collect(0) ;
        var i : int ; i := 1 ; while i < charge->size() do ( (     var k : int ; k := 1000 - i ;
     for (coin : conis) do ( (     charge[i+1] := charge[i+1]+(k / coin) ; 
     k := k mod coin ; 
     if (k = 0) then (     break ) else skip )  ) )  ;     i := i + 1 ) ; 
        line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := (line)->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
     OclFile["System.out"].println(charge[n+1]) ) ;     line := br.readLine() ;
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static boolean coprime(int a,int b){
    return(gcd(a,b)==1);
  }
  static void possibleTripletInRange(int L,int R){
    boolean flag=false ;
    int possibleA=0,possibleB=0,possibleC=0 ;
    for(int a=L ; a<=R ; a++){
      for(int b=a+1 ; b<=R ; b++){
        for(int c=b+1 ; c<=R ; c++){
          if(coprime(a,b)&& coprime(b,c)&& ! coprime(a,c)){
            flag=true ;
            possibleA=a ;
            possibleB=b ;
            possibleC=c ;
            break ;
          }
        }
      }
    }
    if(flag==true){
      System.out.println("("+possibleA+","+possibleB+","+possibleC+")"+" is one such possible triplet "+"between "+L+" and "+R);
    }
    else {
      System.out.println("No Such Triplet exists"+"between "+L+" and "+R);
    }
  }
  public static void main(String[] args){
    int L,R ;
    L=2 ;
    R=10 ;
    possibleTripletInRange(L,R);
    L=23 ;
    R=46 ;
    possibleTripletInRange(L,R);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation coprime( a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     return (gcd(a, b) = 1) );
  static   operation possibleTripletInRange( L : int, R : int) : void
  pre: true
  post: true
  activity: (     var flag : boolean ; flag := false ;
     var possibleA : int ; possibleA := 0 ;
    var possibleB : int ; possibleB := 0 ;
    var possibleC : int ; possibleC := 0 ;
         var a : int ; a := L ; while a <= R do ( (         var b : int ; b := a + 1 ; while b <= R do ( (         var c : int ; c := b + 1 ; while c <= R do ( (     if (coprime(a, b) & coprime(b, c) & not(coprime(a, c))) then (     flag := true ; 
     possibleA := a ; 
    possibleB := b ; 
    possibleC := c ; 
    break 
 ) else skip )  ;     c := c + 1 ) )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
     if (flag = true) then (     OclFile["System.out"].println("(" + possibleA + "," + possibleB + "," + possibleC + ")" + " is one such possible triplet " + "between " + L + " and " + R) ) else (     OclFile["System.out"].println("No Such Triplet exists" + "between " + L + " and " + R) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ;
    var R : int ;
     L := 2 ; 
    R := 10 ; 
    execute possibleTripletInRange(L, R) ; 
    L := 23 ; 
    R := 46 ; 
    execute possibleTripletInRange(L, R) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class practice {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int k=s.nextInt();
      int p=(k+1)/2 ;
      System.out.println(n-p);
      for(int i=p ; i<=n ; i++){
        if(i!=k){
          System.out.print(i+" ");
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var k : int ; k := s.getCurrent()->toInteger() ;
    var p : int ; p := (k + 1) / 2 ;
    OclFile["System.out"].println(n - p) ; 
        var i : int ; i := p ; while i <= n do ( (     if (i /= k) then (     OclFile["System.out"].print(i + " ") ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem1493A {
  public static Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    int tc=scanner.nextInt();
    while(tc-->0){
      int n=scanner.nextInt();
      int k=scanner.nextInt();
      System.out.println((n-k)+(k/2));
      for(int i=k+1 ; i<=n ; i++){
        System.out.print(i+" ");
      }
      for(int i=(k+1)/2 ; i<k ; i++){
        System.out.print(i+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem1493A {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var tc : int ; tc := scanner.getCurrent()->toInteger() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var k : int ; k := scanner.getCurrent()->toInteger() ;
    OclFile["System.out"].println((n - k) + (k / 2)) ; 
        var i : int ; i := k + 1 ; while i <= n do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i + 1 ) ; 
        var i : int ; i := (k + 1) / 2 ; while i < k do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int EulerTotientFunction(int limit){
    int copy=limit ;
    Vector<Integer>primes=new Vector<Integer>();
    for(int i=2 ; i*i<=limit ; i++){
      if(limit % i==0){
        while(limit % i==0){
          limit/=i ;
        }
        primes.add(i);
      }
    }
    if(limit>=2){
      primes.add(limit);
    }
    int ans=copy ;
    for(int it : primes){
      ans=(ans/it)*(it-1);
    }
    return ans ;
  }
  static void CountGCD(int m,int k){
    if(m % k!=0){
      System.out.print(0+"\n");
      return ;
    }
    if(m==k){
      System.out.print(2+"\n");
      return ;
    }
    int limit=m/k ;
    int ans=EulerTotientFunction(limit);
    System.out.print(ans+"\n");
  }
  public static void main(String[] args){
    int M=9 ;
    int K=1 ;
    CountGCD(M,K);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation EulerTotientFunction( limit : int) : int
  pre: true
  post: true
  activity: (     var copy : int ; copy := limit ;
     var primes : Sequence(int) ; primes := Sequence{} ;
        var i : int ; i := 2 ; while i * i <= limit do ( (     if (limit mod i = 0) then (     while (limit mod i = 0) do (     limit := limit/(i) ) ; 
     primes := primes->including(i) ) else skip )  ;     i := i + 1 ) ; 
    if (limit >= 2) then (     primes := primes->including(limit) ) else skip ; 
    var ans : int ; ans := copy ;
    for (it : primes) do ( (     ans := (ans / it) * (it - 1) )  ) ; 
    return ans 
 );
  static   operation CountGCD( m : int, k : int) : void
  pre: true
  post: true
  activity: (     if (m mod k /= 0) then (     OclFile["System.out"].print(0 + "\n") ; 
     return ) else skip ; 
     if (m = k) then (     OclFile["System.out"].print(2 + "\n") ; 
     return ) else skip ; 
    var limit : int ; limit := m / k ;
    var ans : int ; ans := EulerTotientFunction(limit) ;
    OclFile["System.out"].print(ans + "\n") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var M : int ; M := 9 ;
     var K : int ; K := 1 ;
     execute CountGCD(M, K) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int __gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static void printRatio(int a,int b,int c,int d){
    if(b*c>a*d){
      int temp=c ;
      c=d ;
      d=c ;
      temp=a ;
      a=b ;
      b=temp ;
    }
    int lcm=(a*c)/__gcd(a,c);
    int x=lcm/a ;
    b*=x ;
    int y=lcm/c ;
    d*=y ;
    int k=__gcd(b,d);
    b/=k ;
    d/=k ;
    System.out.print(b+":"+d);
  }
  public static void main(String[] args){
    int a=4,b=3,c=2,d=2 ;
    printRatio(a,b,c,d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
    if (a = b) then     return a else skip ; 
    if (a > b) then     return __gcd(a - b, b) else skip ; 
    return __gcd(a, b - a) 
 );
  static   operation printRatio( a : int, b : int, c : int, d : int) : void
  pre: true
  post: true
  activity: (     if (b * c > a * d) then (     var temp : int ; temp := c ;
     c := d ; 
    d := c ; 
    temp := a ; 
    a := b ; 
    b := temp ; 
 ) else skip ; 
     var lcm : int ; lcm := (a * c) / __gcd(a, c) ;
    var x : int ; x := lcm / a ;
    b := b*(x) ; 
    var y : int ; y := lcm / c ;
    d := d*(y) ; 
    var k : int ; k := __gcd(b, d) ;
    b := b/(k) ; 
    d := d/(k) ; 
    OclFile["System.out"].print(b + ":" + d) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 4 ;
    var b : int ; b := 3 ;
    var c : int ; c := 2 ;
    var d : int ; d := 2 ;
     execute printRatio(a, b, c, d) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int arr[]=new int[n];
      int arr1[]=new int[n];
      int temp=0 ;
      for(int j=0 ; j<n ; j++){
        int p=sc.nextInt();
        arr[j]=p ;
        arr1[j]=p ;
      }
      for(int j=0 ; j<=1 ; j++){
        for(int k=0 ; k<n-1 ; k++){
          if(arr[k]>arr[k+1]){
            temp=arr[k];
            arr[k]=arr[k+1];
            arr[k+1]=temp ;
          }
        }
      }
      for(int j=0 ; j<=1 ; j++){
        for(int k=0 ; k<n-1 ; k++){
          if(arr1[k]<arr1[k+1]){
            temp=arr1[k];
            arr1[k]=arr1[k+1];
            arr1[k+1]=temp ;
          }
        }
      }
      System.out.println((arr[n-2]+arr[n-1])-(arr1[n-2]+arr1[n-1]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n)->collect(0) ;
    var temp : int ; temp := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     var p : int ; p := sc.getCurrent()->toInteger() ;
     arr[j+1] := p ; 
     arr1[j+1] := p )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j <= 1 do ( (         var k : int ; k := 0 ; while k < n - 1 do ( (     if (arr[k+1] > arr[k + 1+1]) then (     temp := arr[k+1] ; 
     arr[k+1] := arr[k + 1+1] ; 
     arr[k + 1+1] := temp ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j <= 1 do ( (         var k : int ; k := 0 ; while k < n - 1 do ( (     if (arr1[k+1] < arr1[k + 1+1]) then (     temp := arr1[k+1] ; 
     arr1[k+1] := arr1[k + 1+1] ; 
     arr1[k + 1+1] := temp ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println((arr[n - 2+1] + arr[n - 1+1]) - (arr1[n - 2+1] + arr1[n - 1+1])) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.StringTokenizer ;
public class Solution {
  static PrintWriter pw ;
  static FastScanner s ;
  public static void main(String[] args)throws Exception {
    pw=new PrintWriter(System.out);
    s=new FastScanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      ArrayList<Long>a=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        a.add(s.nextLong());
      }
      Collections.sort(a);
      pw.println(a.get(n-1)+a.get(n-2)-a.get(0)-a.get(1));
    }
    pw.flush();
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public FastScanner(String s)throws Exception {
    br=new BufferedReader(new FileReader(new File(s)));
  }
  public String next()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(next());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute pw : OclFile;
  static   attribute s : FastScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     pw := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     s := FastScanner.newFastScanner(OclFile["System.in"]) ; 
    var t : int ; t := s.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.nextInt() ;
     var a : Sequence(long) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     a := a->including(s.nextLong()) )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      int k=sc.nextInt();
      long arr[]=new long[k];
      for(int j=0 ; j<k ; j++)arr[j]=sc.nextLong();
      long max1=Long.MIN_VALUE ;
      long max2=Long.MIN_VALUE ;
      long min1=Long.MAX_VALUE ;
      long min2=Long.MAX_VALUE ;
      int indmax=0 ;
      int indmin=0 ;
      for(int j=0 ; j<k ; j++){
        if(arr[j]>max1){
          max1=arr[j];
          indmax=j ;
        }
        if(arr[j]<min1){
          min1=arr[j];
          indmin=j ;
        }
      }
      arr[indmax]=0 ;
      arr[indmin]=0 ;
      for(int j=0 ; j<k ; j++){
        if(arr[j]>max2 && arr[j]!=0)max2=arr[j];
        if(arr[j]<min2 && arr[j]!=0)min2=arr[j];
      }
      System.out.println((max1-min1)+(max2-min2));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var k : int ; k := sc.getCurrent()->toInteger() ;
     var arr : Sequence(long) ; arr := Integer.subrange(1,k)->collect(0) ;
        var j : int ; j := 0 ; while j < k do (     arr[j+1] := sc.getCurrent()->toLong() ;  ;     j := j + 1 ) ; 
    var max1 : long ; max1 := "-9223372036854775808"->toLong() ;
    var max2 : long ; max2 := "-9223372036854775808"->toLong() ;
    var min1 : long ; min1 := "9223372036854775807"->toLong() ;
    var min2 : long ; min2 := "9223372036854775807"->toLong() ;
    var indmax : int ; indmax := 0 ;
    var indmin : int ; indmin := 0 ;
        var j : int ; j := 0 ; while j < k do ( (     if (arr[j+1] > max1) then (     max1 := arr[j+1] ; 
     indmax := j ) else skip ; 
     if (arr[j+1] < min1) then (     min1 := arr[j+1] ; 
     indmin := j ) else skip )  ;     j := j + 1 ) ; 
    arr[indmax+1] := 0 ; 
    arr[indmin+1] := 0 ; 
        var j : int ; j := 0 ; while j < k do ( (     if (arr[j+1] > max2 & arr[j+1] /= 0) then     max2 := arr[j+1] ; else skip ; 
     if (arr[j+1] < min2 & arr[j+1] /= 0) then     min2 := arr[j+1] ; else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println((max1 - min1) + (max2 - min2)) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printPairs(int arr[],int n){
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        System.out.print("("+arr[i]+","+arr[j]+")"+",");
      }
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,2 };
      int n=arr.length ;
      printPairs(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printPairs( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     OclFile["System.out"].print("(" + arr[i+1] + "," + arr[j+1] + ")" + ",") )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2} ;
     var n : int ; n := arr->size() ;
     execute printPairs(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int firstNonRepeating(int arr[],int n){
    for(int i=0 ; i<n ; i++){
      int j ;
      for(j=0 ; j<n ; j++)if(i!=j && arr[i]==arr[j])break ;
      if(j==n)return arr[i];
    }
    return-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      9,4,9,6,7,4 };
      int n=arr.length ;
      System.out.print(firstNonRepeating(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation firstNonRepeating( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var j : int ;
         j := 0 ; while j < n do (     if (i /= j & arr[i+1] = arr[j+1]) then     break else skip ;  ;     j := j + 1 ) ; 
     if (j = n) then     return arr[i+1] else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{9,4,9,6,7,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(firstNonRepeating(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int M=scanner.nextInt();
    List<Card>list=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      int a=scanner.nextInt();
      list.add(new Card(a,1));
    }
    for(int i=0 ; i<M ; i++){
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      list.add(new Card(b,a));
    }
    list.sort((c1,c2)->c2.number-c1.number);
    int remain=N ;
    long sum=0 ;
    for(Card c : list){
      int r=Math.min(remain,c.count);
      sum+=(long)c.number*r ;
      remain-=r ;
    }
    System.out.println(sum);
  }
  private static class Card {
    private final int number ;
    private final int count ;
    private Card(int number,int count){
      this.number=number ;
      this.count=count ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var M : int ; M := scanner.getCurrent()->toInteger() ;
    var list : Sequence(Card) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     list := list->including(Card.newCard(a, 1)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
     list := list->including(Card.newCard(b, a)) )  ;     i := i + 1 ) ; 
    list := list.sort(lambda (c1 , c2) : OclAny in c2.number - c1.number) ; 
    var remain : int ; remain := N ;
    var sum : long ; sum := 0 ;
    for (c : list) do ( (     var r : int ; r := Set{remain, c.count}->min() ;
     sum := sum+(c.number->oclAsType(long) * r) ; 
     remain := remain-(r) )  ) ; 
    OclFile["System.out"].println(sum) ; 
 );
  static class Card {
   attribute number : int;
   attribute count : int;
   static operation newCard( number : int, count : int) : Card
  pre: true
  post: true
  activity:
  ( var self : Card ;
    self := createCard();
    self.initialise(number, count);
    return self );
  operation initialise( number : int, count : int) : void
  pre: true  post: true
  activity: (     self.number := number ; 
     self.count := count );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.System.*;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int money ;
    while((money=scan.nextInt())!=0){
      money=1000-money ;
      int coin=0 ;
      if(money>=500){
        coin++;
        money-=500 ;
      }
      if(money>=100){
        while(money>=100){
          coin++;
          money-=100 ;
        }
      }
      if(money>=50){
        coin++;
        money-=50 ;
      }
      if(money>=10){
        while(money>=10){
          coin++;
          money-=10 ;
        }
      }
      if(money>=5){
        coin++;
        money-=5 ;
      }
      if(money>=1){
        while(money>=1){
          coin++;
          money-=1 ;
        }
      }
      out.println(coin);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var money : int ;
         money := scan.getCurrent()->toInteger() ;
    while ((money) /= 0) do (    skip ; (     money := 1000 - money ; 
     var coin : int ; coin := 0 ;
    if (money >= 500) then (     coin := coin + 1 ; 
     money := money-(500) ) else skip ; 
    if (money >= 100) then (     while (money >= 100) do (     coin := coin + 1 ; 
     money := money-(100) ) ) else skip ; 
    if (money >= 50) then (     coin := coin + 1 ; 
     money := money-(50) ) else skip ; 
    if (money >= 10) then (     while (money >= 10) do (     coin := coin + 1 ; 
     money := money-(10) ) ) else skip ; 
    if (money >= 5) then (     coin := coin + 1 ; 
     money := money-(5) ) else skip ; 
    if (money >= 1) then (     while (money >= 1) do (     coin := coin + 1 ; 
     money := money-(1) ) ) else skip ; 
    out.println(coin) ; 
 ) ;     money := scan.getCurrent()->toInteger() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Card {
  int b ;
  int c ;
  public Card(int b,int c){
    this.b=b ;
    this.c=c ;
  }
}
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int m=Integer.parseInt(sc.next());
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Long.parseLong(sc.next());
    }
    Arrays.sort(a);
    Card[] ca=new Card[m];
    for(int i=0 ; i<m ; i++){
      int b=Integer.parseInt(sc.next());
      int c=Integer.parseInt(sc.next());
      ca[i]=new Card(b,c);
    }
    Arrays.sort(ca,(ax,bx)->bx.c-ax.c);
    Long[] tmp=new Long[n];
    int count=0 ;
    for(int i=0 ; i<m ; i++){
      Card card=ca[i];
      for(int j=0 ; j<card.b ; j++){
        if(count==n)break ;
        tmp[count]=(long)card.c ;
        count++;
      }
      if(count==n)break ;
    }
    for(int i=count ; i<n ; i++){
      tmp[i]=0L ;
    }
    Arrays.sort(tmp,Comparator.reverseOrder());
    for(int i=0 ; i<n ; i++){
      if(a[i]<tmp[i]){
        a[i]=tmp[i];
      }
      else {
        break ;
      }
    }
    long total=0 ;
    for(int i=0 ; i<n ; i++){
      total+=a[i];
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Card {
   attribute b : int;
   attribute c : int;
   static operation newCard( b : int, c : int) : Card
  pre: true
  post: true
  activity:
  ( var self : Card ;
    self := createCard();
    self.initialise(b, c);
    return self );
  operation initialise( b : int, c : int) : void
  pre: true  post: true
  activity: (     self.b := b ; 
     self.c := c );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var m : int ; m := (sc.getCurrent())->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sc.getCurrent())->toLong() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var ca : Sequence(Card) ; ca := Integer.subrange(1,m)->collect(null) ;
        var i : int ; i := 0 ; while i < m do ( (     var b : int ; b := (sc.getCurrent())->toInteger() ;
     var c : int ; c := (sc.getCurrent())->toInteger() ;
     ca[i+1] := Card.newCard(b, c) )  ;     i := i + 1 ) ; 
    ca := OclComparator.sortWith(ca, lambda (ax , bx) : OclAny in bx.c - ax.c) ; 
    var tmp : Sequence(long) ; tmp := Integer.subrange(1,n)->collect(null) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var card : Card ; card := ca[i+1] ;
         var j : int ; j := 0 ; while j < card.b do ( (     if (count = n) then     break else skip ; 
     tmp[count+1] := card.c->oclAsType(long) ; 
     count := count + 1 )  ;     j := j + 1 ) ; 
     if (count = n) then     break else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := count ; while i < n do ( (     tmp[i+1] := 0L )  ;     i := i + 1 ) ; 
    tmp := OclComparator.sortWith(tmp, Comparator.reverseOrder()) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] < tmp[i+1]) then (     a[i+1] := tmp[i+1] ) else (     break ) )  ;     i := i + 1 ) ; 
    var total : long ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     total := total+(a[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    PriorityQueue<Integer>queue=new PriorityQueue<>();
    for(int i=0 ; i<n ; i++){
      queue.add(sc.nextInt());
    }
    Change[] changes=new Change[m];
    for(int i=0 ; i<m ; i++){
      changes[i]=new Change(sc.nextInt(),sc.nextInt());
    }
    Arrays.sort(changes);
    long total=0 ;
    for(Change x : changes){
      if(queue.size()==0 || queue.peek()>x.value){
        break ;
      }
      for(int i=0 ; i<x.times ; i++){
        if(queue.size()==0 || queue.peek()>x.value){
          break ;
        }
        total+=x.value ;
        queue.poll();
      }
    }
    while(queue.size()>0){
      total+=queue.poll();
    }
    System.out.println(total);
  }
  static class Change implements Comparable<Change>{
    int value ;
    int times ;
    public Change(int times,int value){
      this.value=value ;
      this.times=times ;
    }
    public String toString(){
      return "value:"+value+" times:"+times ;
    }
    public int compareTo(Change another){
      return another.value-value ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var queue : Sequence(int) ; queue := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     queue := queue->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var changes : Sequence(Change) ; changes := Integer.subrange(1,m)->collect(null) ;
        var i : int ; i := 0 ; while i < m do ( (     changes[i+1] := Change.newChange(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    changes := changes->sort() ; 
    var total : long ; total := 0 ;
    for (x : changes) do ( (     if (queue->size() = 0 or queue->min() > x.value) then (     break ) else skip ; 
         var i : int ; i := 0 ; while i < x.times do ( (     if (queue->size() = 0 or queue->min() > x.value) then (     break ) else skip ; 
     total := total+(x.value) ; 
     queue := queue->sort()->tail() )  ;     i := i + 1 ) )  ) ; 
    while (queue->size() > 0) do (     total := total + queue->min() ;     queue := queue->sort()->tail() ) ; 
    OclFile["System.out"].println(total) ; 
 );
  static class Change implements Comparable<Change> {
   attribute value : int;
   attribute times : int;
   static operation newChange( times : int, value : int) : Change
  pre: true
  post: true
  activity:
  ( var self : Change ;
    self := createChange();
    self.initialise(times, value);
    return self );
  operation initialise( times : int, value : int) : void
  pre: true  post: true
  activity: (     self.value := value ; 
     self.times := times );
   operation toString() : String
  pre: true
  post: true
  activity: (     return "value:" + value + " times:" + times );
   operation compareTo( another : Change) : int
  pre: true
  post: true
  activity: (     return another.value - value );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=scan.nextInt();
    int M=scan.nextInt();
    ArrayList<Pair>data=new ArrayList();
    for(int i=0 ; i<N ; i++){
      data.add(new Pair(1,scan.nextLong()));
    }
    for(int i=0 ; i<M ; i++){
      int B=scan.nextInt();
      long C=scan.nextLong();
      data.add(new Pair(B,C));
    }
    data.sort(new PairComparator());
    long answer=0 ;
    int remain=N ;
    int index=0 ;
    while(0<remain){
      Pair pair=data.get(index++);
      int size=pair.size ;
      long value=pair.value ;
      answer+=Math.min(remain,size)*value ;
      remain-=Math.min(remain,size);
    }
    System.out.println(answer);
  }
  class Pair {
    int size ;
    long value ;
    Pair(int size,long value){
      this.size=size ;
      this.value=value ;
    }
  }
  class PairComparator implements Comparator<Pair>{
    @ Override public int compare(Pair o1,Pair o2){
      if(o1.value!=o2.value){
        return-Long.compare(o1.value,o2.value);
      }
      return-Integer.compare(o1.size,o2.size);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var M : int ; M := scan.getCurrent()->toInteger() ;
    var data : Sequence(Map) ; data := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     data := data->including(Map(1, scan.getCurrent()->toLong())) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var B : int ; B := scan.getCurrent()->toInteger() ;
     var C : long ; C := scan.getCurrent()->toLong() ;
     data := data->including(Map(B, C)) )  ;     i := i + 1 ) ; 
    data := data.sort(PairComparator.newPairComparator()) ; 
    var answer : long ; answer := 0 ;
    var remain : int ; remain := N ;
    var index : int ; index := 0 ;
    while (0 < remain) do (     var pair : Map ; pair := data->at(index+1) ;
     var size : int ; size := pair.size ;
    var value : long ; value := pair.value ;
    answer := answer+(Set{remain, size}->min() * value) ; 
    remain := remain-(Set{remain, size}->min()) ; 
 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
 class Pair {
   attribute size : int;
   attribute value : long;
   static operation newPair( size : int, value : long) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(size, value);
    return self );
  operation initialise( size : int, value : long) : void
  pre: true  post: true
  activity: (     self.size := size ; 
     self.value := value );
}
 class PairComparator implements Function(<Map>,(<Map>,boolean)) {
      operation compare( o1 : Map, o2 : Map) : int
  pre: true
  post: true
  activity: (     if (o1.value /= o2.value) then (     return -compare(o1.value, o2.value) ) else skip ; 
     return -compare(o1.size, o2.size) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int maxsum_SIS(int arr[],int n){
    int max_sum=0 ;
    int current_sum=arr[0];
    for(int i=1 ; i<n ; i++){
      if(arr[i-1]<arr[i]){
        current_sum=current_sum+arr[i];
      }
      else {
        max_sum=Math.max(max_sum,current_sum);
        current_sum=arr[i];
      }
    }
    return Math.max(max_sum,current_sum);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,2,4 };
      int n=arr.length ;
      System.out.println("Maximum sum : "+maxsum_SIS(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxsum_SIS( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max_sum : int ; max_sum := 0 ;
     var current_sum : int ; current_sum := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do ( (     if (arr[i - 1+1] < arr[i+1]) then (     current_sum := current_sum + arr[i+1] ) else (     max_sum := Set{max_sum, current_sum}->max() ; 
     current_sum := arr[i+1] ) )  ;     i := i + 1 ) ; 
     return Set{max_sum, current_sum}->max() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,2,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Maximum sum : " + maxsum_SIS(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
    }
    int cnt=0 ;
    List<int[]>b_c=new ArrayList<int[]>();
    for(int i=0 ; i<M ; i++){
      int b=sc.nextInt();
      if(cnt<100005){
        cnt+=b ;
      }
      int c=sc.nextInt();
      int[] b__c={
        b,c };
        b_c.add(b__c);
      }
      Arrays.sort(A);
      Comparator<int[]>comparator=new Comparator<int[]>(){
        @ Override public int compare(int[] o1,int[] o2){
          return Integer.valueOf(o2[1]).compareTo(Integer.valueOf(o1[1]));
        }
      };
      Collections.sort(b_c,comparator);
      List<Integer>C=new ArrayList<Integer>();
      int len=0 ;
      loop : for(int i=0 ;
      i<M ;
      i++){
        int b=b_c.get(i)[0];
        int c=b_c.get(i)[1];
        for(int j=0 ; j<b ; j++){
          C.add(c);
          len++;
          if(len>100005){
            break loop ;
          }
        }
      }
      for(int i=0 ; i<Math.min(cnt,N); i++){
        if(A[i]<=C.get(i)){
          A[i]=C.get(i);
        }
        else {
          break ;
        }
      }
      long ans=0L ;
      for(int i=0 ; i<N ; i++){
        ans+=(long)A[i];
      }
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    var b_c : Sequence(Sequence(int)) ; b_c := Sequence{} ;
        var i : int ; i := 0 ; while i < M do ( (     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (cnt < 100005) then (     cnt := cnt+(b) ) else skip ; 
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var b__c : Sequence(int) ; b__c := Sequence{b,c} ;
    b_c := b_c->including(b__c) ; 
 )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    var comparator : Function(<Sequence(int)>,(<Sequence(int)>,boolean)) ; comparator := OclComparator<Sequence(int)>.newOclComparator() ;
    b_c, comparator := b_c, comparator->sort() ; 
    var C : Sequence(int) ; C := Sequence{} ;
    var len : int ; len := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     var b : int ; b := b_c->at(i+1)[0+1] ;
     var c : int ; c := b_c->at(i+1)[1+1] ;
         var j : int ; j := 0 ; while j < b do ( (     C := C->including(c) ; 
     len := len + 1 ; 
     if (len > 100005) then (     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Set{cnt, N}->min() do ( (     if (A[i+1] <= C->at(i+1)) then (     A[i+1] := C->at(i+1) ) else (     break ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0L ;
        var i : int ; i := 0 ; while i < N do ( (     ans := ans+(A[i+1]->oclAsType(long)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B_Beautiful_Paintings {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] count=new int[1001];
    for(int i=0 ; i<n ; i++){
      int tmp=sc.nextInt();
      count[tmp]++;
    }
    Arrays.sort(count);
    int ans=0 ;
    for(int i=999 ; i>0 ; i--){
      if(count[i]==0)break ;
      ans+=count[i];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Beautiful_Paintings {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var count : Sequence(int) ; count := Integer.subrange(1,1001)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var tmp : int ; tmp := sc.getCurrent()->toInteger() ;
     count[tmp+1] := count[tmp+1] + 1 )  ;     i := i + 1 ) ; 
    count := count->sort() ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 999 ; while i > 0 do ( (     if (count[i+1] = 0) then     break else skip ; 
     ans := ans+(count[i+1]) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sizeofInt=8 ;
  static int toggleLastMBits(int n,int m){
    int num=(1<<m)-1 ;
    return(n ^ num);
  }
  static int unsetLastMBits(int n,int m){
    int num=(1<<(sizeofInt*8-1))-1 ;
    num=toggleLastMBits(num,m);
    return(n & num);
  }
  public static void main(String[] args){
    int n=150,m=4 ;
    System.out.println(unsetLastMBits(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute sizeofInt : int := 8;
  static   operation toggleLastMBits( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := ((1*(2->pow(m)))->oclAsType(long)) - 1 ;
     return (n xor num) );
  static   operation unsetLastMBits( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := ((1*(2->pow((sizeofInt * 8 - 1))))->oclAsType(long)) - 1 ;
     num := toggleLastMBits(num, m) ; 
     return (n & num) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 150 ;
    var m : int ; m := 4 ;
     OclFile["System.out"].println(unsetLastMBits(n, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.*;
public class B {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int q=input.nextInt();
    int k=input.nextInt();
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=input.nextInt();
    }
    for(int i=0 ; i<q ; i++){
      int ans=0 ;
      int l=input.nextInt()-1 ;
      int r=input.nextInt()-1 ;
      ans+=nums[l]-1 ;
      ans+=k-nums[r];
      ans+=(nums[r]-nums[l]-(r-l))*2 ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var q : int ; q := input.getCurrent()->toInteger() ;
    var k : int ; k := input.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var ans : int ; ans := 0 ;
     var l : int ; l := input.getCurrent()->toInteger() - 1 ;
    var r : int ; r := input.getCurrent()->toInteger() - 1 ;
    ans := ans+(nums[l+1] - 1) ; 
    ans := ans+(k - nums[r+1]) ; 
    ans := ans+((nums[r+1] - nums[l+1] - (r - l)) * 2) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int lcm(int a,int b){
    int GCD=__gcd(a,b);
    return(a*b)/GCD ;
  }
  static int MinLCM(int a[],int n){
    int[] Prefix=new int[n+2];
    int[] Suffix=new int[n+2];
    Prefix[1]=a[0];
    for(int i=2 ; i<=n ; i+=1){
      Prefix[i]=lcm(Prefix[i-1],a[i-1]);
    }
    Suffix[n]=a[n-1];
    for(int i=n-1 ; i>=1 ; i-=1){
      Suffix[i]=lcm(Suffix[i+1],a[i-1]);
    }
    int ans=Math.min(Suffix[2],Prefix[n-1]);
    for(int i=2 ; i<n ; i+=1){
      ans=Math.min(ans,lcm(Prefix[i-1],Suffix[i+1]));
    }
    return ans ;
  }
  static int __gcd(int a,int b){
    return b==0 ? a : __gcd(b,a % b);
  }
  public static void main(String[] args){
    int a[]={
      5,15,9,36 };
      int n=a.length ;
      System.out.println(MinLCM(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation lcm( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var GCD : int ; GCD := __gcd(a, b) ;
     return (a * b) / GCD );
  static   operation MinLCM( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var Prefix : Sequence(int) ; Prefix := Integer.subrange(1,n + 2)->collect(0) ;
     var Suffix : Sequence(int) ; Suffix := Integer.subrange(1,n + 2)->collect(0) ;
    Prefix[1+1] := a[0+1] ; 
        var i : int ; i := 2 ; while i <= n do ( (     Prefix[i+1] := lcm(Prefix[i - 1+1], a[i - 1+1]) )  ;     i := i+(1) ) ; 
    Suffix[n+1] := a[n - 1+1] ; 
        var i : int ; i := n - 1 ; while i >= 1 do ( (     Suffix[i+1] := lcm(Suffix[i + 1+1], a[i - 1+1]) )  ;     i := i-(1) ) ; 
    var ans : int ; ans := Set{Suffix[2+1], Prefix[n - 1+1]}->min() ;
        var i : int ; i := 2 ; while i < n do ( (     ans := Set{ans, lcm(Prefix[i - 1+1], Suffix[i + 1+1])}->min() )  ;     i := i+(1) ) ; 
    return ans 
 );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else __gcd(b, a mod b) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{5,15,9,36} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(MinLCM(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  int[] dp ;
  int MONEY=1000 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    dp();
    for(; ; ){
      int money=sc.nextInt();
      if(money==0)break ;
      System.out.println(dp[money]);
    }
  }
  void dp(){
    dp=new int[MONEY+1];
    int coin[]={
      1,5,10,50,100,500 };
      fill(dp,INF);
      dp[MONEY]=0 ;
      for(int i=MONEY ; i>=0 ; i--)for(int j=0 ; j<coin.length ; j++){
        if(i-coin[j]>0)dp[i-coin[j] ]=min(dp[i-coin[j] ],dp[i]+1);
      }
    }
    public static void main(String[] args){
      new Main().run();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute dp : Sequence(int);
   attribute MONEY : int := 1000;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute dp() ; 
       while true do ( (     var money : int ; money := sc.getCurrent()->toInteger() ;
     if (money = 0) then     break else skip ; 
     OclFile["System.out"].println(dp[money+1]) )  ) );
   operation dp() : void
  pre: true
  post: true
  activity: (     dp := Integer.subrange(1,MONEY + 1)->collect(0) ; 
     var coin : Sequence(int) ; coin := Sequence{1,5,10,50,100,500} ;
    execute fill(dp, INF) ; 
    dp[MONEY+1] := 0 ; 
        var i : int ; i := MONEY ; while i >= 0 do (         var j : int ; j := 0 ; while j < coin->size() do ( (     if (i - coin[j+1] > 0) then     dp[i - coin[j+1]+1] := Set{dp[i - coin[j+1]+1], dp[i+1] + 1}->min() ; else skip )  ;     j := j + 1 ) ;  ;     i := i - 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
public class Div1_453B {
  static int n ;
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter printer=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    n=Integer.parseInt(reader.readLine());
    int[] prev=new int[n+1];
    int[] cur=new int[n+1];
    prev[0]=1 ;
    cur[1]=1 ;
    for(int i=1 ; i<n ; i++){
      int[] nxt=add(prev,lShift(cur));
      prev=cur ;
      cur=nxt ;
    }
    printer.println(n);
    for(int i=0 ; i<=n ; i++){
      printer.print(cur[i]+" ");
    }
    printer.println();
    printer.println(n-1);
    for(int i=0 ; i<=n-1 ; i++){
      printer.print(prev[i]+" ");
    }
    printer.println();
    printer.close();
  }
  static int[] add(int[] a,int[] b){
    int[] ret=new int[n+1];
    for(int i=0 ; i<=n ; i++){
      ret[i]=(a[i]+b[i])% 2 ;
    }
    return ret ;
  }
  static int[] lShift(int[] items){
    int[] ret=new int[n+1];
    for(int i=n ; i>=1 ; i--){
      ret[i]=items[i-1];
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Div1_453B {
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var printer : OclFile ; printer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    n := (reader.readLine())->toInteger() ; 
    var prev : Sequence(int) ; prev := Integer.subrange(1,n + 1)->collect(0) ;
    var cur : Sequence(int) ; cur := Integer.subrange(1,n + 1)->collect(0) ;
    prev[0+1] := 1 ; 
    cur[1+1] := 1 ; 
        var i : int ; i := 1 ; while i < n do ( (     var nxt : Sequence(int) ; nxt := add(prev, lShift(cur)) ;
     prev := cur ; 
     cur := nxt )  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i <= n do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
        var i : int ; i := 0 ; while i <= n - 1 do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation add( a : Sequence(int), b : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var ret : Sequence(int) ; ret := Integer.subrange(1,n + 1)->collect(0) ;
         var i : int ; i := 0 ; while i <= n do ( (     ret[i+1] := (a[i+1] + b[i+1]) mod 2 )  ;     i := i + 1 ) ; 
     return ret );
  static   operation lShift( items : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var ret : Sequence(int) ; ret := Integer.subrange(1,n + 1)->collect(0) ;
         var i : int ; i := n ; while i >= 1 do ( (     ret[i+1] := items[i - 1+1] )  ;     i := i - 1 ) ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void alternateFib(int n){
    if(n<0)return ;
    int f1=0 ;
    int f2=1 ;
    System.out.print(f1+" ");
    for(int i=2 ; i<=n ; i++){
      int f3=f2+f1 ;
      if(i % 2==0)System.out.print(f3+" ");
      f1=f2 ;
      f2=f3 ;
    }
  }
  public static void main(String[] args){
    int N=15 ;
    alternateFib(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation alternateFib( n : int) : void
  pre: true
  post: true
  activity: (     if (n < 0) then     return else skip ; 
     var f1 : int ; f1 := 0 ;
    var f2 : int ; f2 := 1 ;
    OclFile["System.out"].print(f1 + " ") ; 
        var i : int ; i := 2 ; while i <= n do ( (     var f3 : int ; f3 := f2 + f1 ;
     if (i mod 2 = 0) then     OclFile["System.out"].print(f3 + " ") ; else skip ; 
     f1 := f2 ; 
     f2 := f3 )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 15 ;
     execute alternateFib(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int D=sc.nextInt();
    int[][] vectors=new int[N][D];
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<D ; j++){
        vectors[i][j]=sc.nextInt();
      }
    }
    int answer=0 ;
    for(int i=0 ; i<N-1 ; i++){
      for(int j=i+1 ; j<N ; j++){
        int dist=0 ;
        for(int d=0 ; d<D ; d++){
          int x=(vectors[i][d]-vectors[j][d]);
          dist+=(x*x);
        }
        double sq=Math.sqrt(dist);
        answer+=(Math.abs(sq-Math.floor(sq))<0.001 ? 1 : 0);
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var D : int ; D := sc.getCurrent()->toInteger() ;
    var vectors : Sequence(Sequence(int)) ; vectors := Integer.subrange(1,N)->collect(Integer.subrange(1,D)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < D do ( (     vectors[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var answer : int ; answer := 0 ;
        var i : int ; i := 0 ; while i < N - 1 do ( (         var j : int ; j := i + 1 ; while j < N do ( (     var dist : int ; dist := 0 ;
         var d : int ; d := 0 ; while d < D do ( (     var x : int ; x := (vectors[i+1][d+1] - vectors[j+1][d+1]) ;
     dist := dist+((x * x)) )  ;     d := d + 1 ) ; 
     var sq : double ; sq := (dist)->sqrt() ;
     answer := answer+((if if sq - (sq)->floor() < 0 then -(sq - (sq)->floor()) else sq - (sq)->floor() endif < 0.001 then 1 else 0 endif)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int x1=sc.nextInt();
      int y1=sc.nextInt();
      int x2=sc.nextInt();
      int y2=sc.nextInt();
      System.out.println(solve(x1,y1,x2,y2));
    }
    sc.close();
  }
  static int solve(int x1,int y1,int x2,int y2){
    return Math.abs(x1-x2)+Math.abs(y1-y2)+((x1!=x2 && y1!=y2)? 2 : 0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var x1 : int ; x1 := sc.getCurrent()->toInteger() ;
     var y1 : int ; y1 := sc.getCurrent()->toInteger() ;
    var x2 : int ; x2 := sc.getCurrent()->toInteger() ;
    var y2 : int ; y2 := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(solve(x1, y1, x2, y2)) ; 
 )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( x1 : int, y1 : int, x2 : int, y2 : int) : int
  pre: true
  post: true
  activity: (     return if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif + if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif + (if (x1 /= x2 & y1 /= y2) then 2 else 0 endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileNotFoundException ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Wabbit {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String linea ;
      linea=br.readLine();
      int limite=Integer.parseInt(linea);
      long x1,x2,y1,y2,resultado ;
      for(int l=1 ; l<=limite ; l++){
        String array2[]=br.readLine().split(" ");
        x1=Integer.parseInt(array2[0]);
        y1=Integer.parseInt(array2[1]);
        x2=Integer.parseInt(array2[2]);
        y2=Integer.parseInt(array2[3]);
        if(x1-x2==0){
          resultado=Math.abs(y1-y2);
        }
        else if(y1-y2==0){
          resultado=Math.abs(x1-x2);
        }
        else {
          resultado=Math.abs(x1-x2)+Math.abs(y1-y2)+2 ;
        }
        System.out.println(resultado);
      }
      br.close();
    }
    catch(FileNotFoundException e){
      e.printStackTrace();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Wabbit {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var linea : String ;
    linea := br.readLine() ; 
    var limite : int ; limite := (linea)->toInteger() ;
    var x1 : long ;
    var x2 : long ;
    var y1 : long ;
    var y2 : long ;
    var resultado : long ;
        var l : int ; l := 1 ; while l <= limite do ( (     var array2 : Sequence(String) ; array2 := br.readLine()->split(" ") ;
     x1 := (array2[0+1])->toInteger() ; 
    y1 := (array2[1+1])->toInteger() ; 
    x2 := (array2[2+1])->toInteger() ; 
    y2 := (array2[3+1])->toInteger() ; 
    if (x1 - x2 = 0) then (     resultado := if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif ) else     if (y1 - y2 = 0) then (     resultado := if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif ) else (     resultado := if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif + if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif + 2 ) ;  ;  
    OclFile["System.out"].println(resultado) ; 
 )  ;     l := l + 1 ) ; 
    skip ; 
 )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        int x1=sc.nextInt();
        int y1=sc.nextInt();
        int x2=sc.nextInt();
        int y2=sc.nextInt();
        if(x1==x2 || y1==y2)System.out.println(Math.abs(x1-x2)+Math.abs(y1-y2));
        else System.out.println(Math.abs(x1-x2)+Math.abs(y1-y2)+2);
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var x1 : int ; x1 := sc.getCurrent()->toInteger() ;
     var y1 : int ; y1 := sc.getCurrent()->toInteger() ;
    var x2 : int ; x2 := sc.getCurrent()->toInteger() ;
    var y2 : int ; y2 := sc.getCurrent()->toInteger() ;
    if (x1 = x2 or y1 = y2) then     OclFile["System.out"].println(if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif + if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif) else     OclFile["System.out"].println(if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif + if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif + 2) ; ;  
 ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(stdIn.hasNext()){
      int n=stdIn.nextInt();
      int m=stdIn.nextInt();
      if(n==0 && m==0){
        break ;
      }
      Queue<Boolean>deq=new ArrayDeque<Boolean>();
      boolean[] flag=new boolean[n];
      for(int i=0 ; i<n ; ++i){
        flag[i]=true ;
      }
      int remain=n ;
      int pos=0 ;
      int count=0 ;
      while(remain!=1){
        if(pos>=n){
          pos=0 ;
        }
        if(flag[pos]){
++count ;
        }
        if(count==m){
          flag[pos]=false ;
          count=0 ;
--remain ;
        }
++pos ;
      }
      for(int i=0 ; i<n ; ++i){
        if(flag[i]){
          System.out.println(i+1);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (stdIn.hasNext()) do (     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     var m : int ; m := stdIn.getCurrent()->toInteger() ;
    if (n = 0 & m = 0) then (     break ) else skip ; 
    var deq : Sequence(Boolean) ; deq := ArrayDeque<Boolean>.newArrayDeque() ;
    var flag : Sequence(boolean) ; flag := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     flag[i+1] := true )  ;     i := i + 1 ) ; 
    var remain : int ; remain := n ;
    var pos : int ; pos := 0 ;
    var count : int ; count := 0 ;
    while (remain /= 1) do (     if (pos >= n) then (     pos := 0 ) else skip ; 
     if (flag[pos+1]) then (     count := count + 1 ) else skip ; 
     if (count = m) then (     flag[pos+1] := false ; 
     count := 0 ; 
     remain := remain - 1 ) else skip ; 
     pos := pos + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (flag[i+1]) then (     OclFile["System.out"].println(i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayDeque ;
import java.util.Deque ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while(!(line=br.readLine()).equals("0 0")){
      int n=Integer.parseInt(line.substring(0,line.indexOf(' ')));
      int m=Integer.parseInt(line.substring(line.indexOf(' ')+1));
      Deque<Integer>q=new ArrayDeque<Integer>(n);
      for(int i=1 ; i<=n ; i++){
        q.offer(i);
      }
      while(q.size()!=1){
        for(int i=0 ; i<m-1 ; i++){
          q.offer(q.poll());
        }
        q.poll();
      }
      System.out.println(q.poll());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
     while (not((line) = "0 0")) do (     var n : int ; n := (line.subrange(0+1,line->indexOf(' ')-1))->toInteger() ;
     var m : int ; m := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1))->toInteger() ;
    var q : Sequence(int) ; q := ArrayDeque<int>.newArrayDeque(n) ;
        var i : int ; i := 1 ; while i <= n do ( (     q := q->including(i) )  ;     i := i + 1 ) ; 
    while (q->size() /= 1) do (         var i : int ; i := 0 ; while i < m - 1 do ( (     q := q->including(q->min()) )  ;     i := i + 1 ) ; 
     q := q->sort()->tail() ) ; 
    OclFile["System.out"].println(q->min()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
import java.util.*;
import static java.lang.System.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int min(int...ar){
    Arrays.sort(ar);
    return ar[0];
  }
  static int max(int...ar){
    Arrays.sort(ar);
    return ar[ar.length-1];
  }
  public static void main(String[] args){
    while(sc.hasNext()){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if(n==0 && m==0)break ;
      LinkedList<Integer>list=new LinkedList<>();
      for(int i=1 ; i<=n-1 ; i++)list.add(i);
      list.addFirst(n);
      int j=0 ;
      while(list.size()!=1){
        for(int i=0 ; i<(j==0 ? m : m-1); i++){
          list.addLast(list.removeFirst());
        }
        list.removeFirst();
        j++;
      }
      out.println(list.getFirst());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation min( ar : Sequence(int)) : int
  pre: true
  post: true
  activity: (     ar := ar->sort() ; 
     return ar[0+1] );
  static   operation max( ar : Sequence(int)) : int
  pre: true
  post: true
  activity: (     ar := ar->sort() ; 
     return ar[ar->size() - 1+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if (n = 0 & m = 0) then     break else skip ; 
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 1 ; while i <= n - 1 do (     list := list->including(i) ;  ;     i := i + 1 ) ; 
    list := list->prepend(n) ; 
    var j : int ; j := 0 ;
    while (list->size() /= 1) do (         var i : int ; i := 0 ; while i < (if j = 0 then m else m - 1 endif) do ( (     list := list->append(list->first()) )  ;     i := i + 1 ) ; 
     list := list->tail() ; 
     j := j + 1 ) ; 
    out.println(list->first()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static int JosephsPotato(int n,int m){
    int cnt=0 ;
    int move=m ;
    int mod=n+1 ;
    int[] player=new int[n+1];
    boolean[] isLose=new boolean[n+1];
    for(int i=1 ; i<player.length ; i++){
      player[i]=i ;
      isLose[i]=false ;
    }
    int point=0 ;
    while(true){
      int j=1 ;
      int p=0 ;
      int index=0 ;
      while(true){
        if((point+j)% mod==0){
          j++;
          continue ;
        }
        if(isLose[(point+j)% mod]==false){
          p++;
          if(p==move){
            index=(point+j)% mod ;
            break ;
          }
        }
        j++;
      }
      isLose[index]=true ;
      cnt++;
      point=index ;
      if(cnt==n-1)break ;
    }
    for(int i=1 ; i<player.length ; i++){
      if(! isLose[i])return i ;
    }
    return-1 ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    ArrayList<Integer>ans=new ArrayList<Integer>();
    while(true){
      StringTokenizer st=new StringTokenizer(br.readLine()," ");
      int n=Integer.parseInt(st.nextToken());
      int m=Integer.parseInt(st.nextToken());
      if(n==0 && m==0)break ;
      ans.add(JosephsPotato(n,m));
    }
    for(int a : ans)System.out.println(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation JosephsPotato( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var move : int ; move := m ;
    var mod : int ; mod := n + 1 ;
    var player : Sequence(int) ; player := Integer.subrange(1,n + 1)->collect(0) ;
    var isLose : Sequence(boolean) ; isLose := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 1 ; while i < player->size() do ( (     player[i+1] := i ; 
     isLose[i+1] := false )  ;     i := i + 1 ) ; 
    var point : int ; point := 0 ;
    while (true) do (     var j : int ; j := 1 ;
     var p : int ; p := 0 ;
    var index : int ; index := 0 ;
    while (true) do (     if ((point + j) mod mod = 0) then (     j := j + 1 ; 
     continue ) else skip ; 
     if (isLose[(point + j) mod mod+1] = false) then (     p := p + 1 ; 
     if (p = move) then (     index := (point + j) mod mod ; 
     break ) else skip ) else skip ; 
     j := j + 1 ) ; 
    isLose[index+1] := true ; 
    cnt := cnt + 1 ; 
    point := index ; 
    if (cnt = n - 1) then     break else skip ; 
 ) ; 
        var i : int ; i := 1 ; while i < player->size() do ( (     if (not(isLose[i+1])) then     return i else skip )  ;     i := i + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var ans : Sequence(int) ; ans := Sequence{} ;
     while (true) do (     var st : OclIterator ; st := OclIterator.newOclIterator_String_String(br.readLine(), " ") ;
     var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    if (n = 0 & m = 0) then     break else skip ; 
    ans := ans->including(JosephsPotato(n, m)) ; 
 ) ; 
     for (a : ans) do (     OclFile["System.out"].println(a) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean solve(){
    int n=in.nextInt();
    int m=in.nextInt();
    if(n+m==0)return false ;
    ArrayList<Integer>list=new ArrayList<Integer>();
    for(int i=1 ; i<=n ; i++){
      list.add(i);
    }
    int p=0 ;
    while(list.size()>1){
      int idx=(p+m-1)% list.size();
      list.remove(idx);
      p=idx ;
    }
    out.println(list.get(0));
    return true ;
  }
  public static void main(String[] args){
    long start=System.currentTimeMillis();
    while(solve());
    out.flush();
    long end=System.currentTimeMillis();
    in.close();
    out.close();
  }
  static void trace(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   operation solve() : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    if (n + m = 0) then     return false else skip ; 
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 1 ; while i <= n do ( (     list := list->including(i) )  ;     i := i + 1 ) ; 
    var p : int ; p := 0 ;
    while (list->size() > 1) do (     var idx : int ; idx := (p + m - 1) mod list->size() ;
     list := list->excludingAt(idx+1) ; 
     p := idx ) ; 
    skip ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : long ; start := OclDate.getSystemTime() ;
     while (solve()) do  ; 
    skip ; 
    var end : long ; end := OclDate.getSystemTime() ;
    skip ; 
    skip ; 
 );
  static   operation trace( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class RatMaze {
  static int N ;
  void printSolution(int sol[][]){
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++)System.out.print(" "+sol[i][j]+" ");
      System.out.println();
    }
  }
  boolean isSafe(int maze[][],int x,int y){
    return(x>=0 && x<N && y>=0 && y<N && maze[x][y]==1);
  }
  boolean solveMaze(int maze[][]){
    int sol[][]=new int[N][N];
    if(solveMazeUtil(maze,0,0,sol)==false){
      System.out.print("Solution doesn't exist");
      return false ;
    }
    printSolution(sol);
    return true ;
  }
  boolean solveMazeUtil(int maze[][],int x,int y,int sol[][]){
    if(x==N-1 && y==N-1 && maze[x][y]==1){
      sol[x][y]=1 ;
      return true ;
    }
    if(isSafe(maze,x,y)==true){
      sol[x][y]=1 ;
      if(solveMazeUtil(maze,x+1,y,sol))return true ;
      if(solveMazeUtil(maze,x,y+1,sol))return true ;
      sol[x][y]=0 ;
      return false ;
    }
    return false ;
  }
  public static void main(String args[]){
    RatMaze rat=new RatMaze();
    int maze[][]={
      {
        1,0,0,0 },{
          1,1,0,1 },{
            0,1,0,0 },{
              1,1,1,1 }
            };
            N=maze.length ;
            rat.solveMaze(maze);
          }
        }

------------------------------------------------------------
OCL File:
---------
class RatMaze {
  static   attribute N : int;
   operation printSolution( sol : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do (     OclFile["System.out"].print(" " + sol[i+1][j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
   operation isSafe( maze : Sequence(Sequence(int)), x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return (x >= 0 & x < N & y >= 0 & y < N & maze[x+1][y+1] = 1) );
   operation solveMaze( maze : Sequence(Sequence(int))) : boolean
  pre: true
  post: true
  activity: (     var sol : Sequence(Sequence(int)) ; sol := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
     if (solveMazeUtil(maze, 0, 0, sol) = false) then (     OclFile["System.out"].print("Solution doesn't exist") ; 
     return false ) else skip ; 
     execute printSolution(sol) ; 
     return true );
   operation solveMazeUtil( maze : Sequence(Sequence(int)), x : int, y : int, sol : Sequence(Sequence(int))) : boolean
  pre: true
  post: true
  activity: (     if (x = N - 1 & y = N - 1 & maze[x+1][y+1] = 1) then (     sol[x+1][y+1] := 1 ; 
     return true ) else skip ; 
     if (isSafe(maze, x, y) = true) then (     sol[x+1][y+1] := 1 ; 
     if (solveMazeUtil(maze, x + 1, y, sol)) then     return true else skip ; 
    if (solveMazeUtil(maze, x, y + 1, sol)) then     return true else skip ; 
    sol[x+1][y+1] := 0 ; 
    return false 
 ) else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var rat : RatMaze ; rat := RatMaze.newRatMaze() ;
     var maze : Sequence(Sequence(int)) ; maze := Sequence{Sequence{1,0,0,0},Sequence{1,1,0,1},Sequence{0,1,0,0},Sequence{1,1,1,1}} ;
     N := maze->size() ; 
     rat.solveMaze(maze) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] x=new int[200005];
    for(int i=0 ; i<(n+m); i++)x[i]=sc.nextInt();
    int[] f=new int[200005];
    int[] taxi=new int[200005];
    int k=0 ;
    for(int i=0 ; i<(n+m); i++){
      f[i]=sc.nextInt();
      if(f[i]==1)taxi[k++]=i ;
    }
    int[] res=new int[200005];
    res[0]=taxi[0];
    for(int i=0 ; i<(m-1); i++){
      int t1=x[taxi[i] ];
      int t2=x[taxi[i+1] ];
      for(int j=(taxi[i]+1); j<taxi[i+1]; j++){
        if((x[j]-t1)<=(t2-x[j]))res[i]++;
        else res[i+1]++;
      }
    }
    res[m-1]+=n+m-1-taxi[m-1];
    StringBuilder ans=new StringBuilder();
    for(int i=0 ; i<m ; i++){
      if(ans.length()>0)ans.append(" ");
      ans.append(res[i]);
    }
    System.out.println(ans.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,200005)->collect(0) ;
        var i : int ; i := 0 ; while i < (n + m) do (     x[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var f : Sequence(int) ; f := Integer.subrange(1,200005)->collect(0) ;
    var taxi : Sequence(int) ; taxi := Integer.subrange(1,200005)->collect(0) ;
    var k : int ; k := 0 ;
        var i : int ; i := 0 ; while i < (n + m) do ( (     f[i+1] := sc.getCurrent()->toInteger() ; 
     if (f[i+1] = 1) then      taxi[k+1] := i  ; k := k + 1 ; else skip )  ;     i := i + 1 ) ; 
    var res : Sequence(int) ; res := Integer.subrange(1,200005)->collect(0) ;
    res[0+1] := taxi[0+1] ; 
        var i : int ; i := 0 ; while i < (m - 1) do ( (     var t1 : int ; t1 := x[taxi[i+1]+1] ;
     var t2 : int ; t2 := x[taxi[i + 1+1]+1] ;
         var j : int ; j := (taxi[i+1] + 1) ; while j < taxi[i + 1+1] do ( (     if ((x[j+1] - t1) <= (t2 - x[j+1])) then     res[i+1] := res[i+1] + 1 ; else     res[i + 1+1] := res[i + 1+1] + 1 ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    res[m - 1+1] := res[m - 1+1]+(n + m - 1 - taxi[m - 1+1]) ; 
    var ans : String ; ans := StringLib.newString() ;
        var i : int ; i := 0 ; while i < m do ( (     if (ans->size() > 0) then     ans := ans + StringLib.newString(" ") ; else skip ; 
     ans := ans + StringLib.newString(res[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    BigInteger a,b ;
    Scanner cin=new Scanner(System.in);
    a=cin.nextBigInteger();
    b=cin.nextBigInteger();
    System.out.println(a.multiply(b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : long ;
    var b : long ;
     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    a := cin.nextBigInteger() ; 
    b := cin.nextBigInteger() ; 
    OclFile["System.out"].println(a.multiply(b)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.*;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
import java.util.jar.Attributes ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      Integer[] s=new Integer[n];
      for(int i=0 ; i<n ; i++){
        s[i]=in.nextInt();
      }
      Arrays.sort(s);
      if(n % 2==0)out.println(s[n/2-1]);
      else out.println(s[(n+1)/2-1]);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    s := s->sort() ; 
    if (n mod 2 = 0) then     skip else     skip ; ;  
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class teachingassistant {
  private static InputReader in ;
  private static PrintWriter out ;
  public static boolean SUBMIT=true ;
  public static final String NAME="A-large" ;
  private static void main2()throws IOException {
    char[] c=in.next().toCharArray();
    int n=c.length ;
    char[] stack=new char[n];
    int idx=0 ;
    int need=0 ;
    for(int i=0 ; i<n ; i++){
      if(idx>0 && stack[idx-1]==c[i]){
        idx--;
        continue ;
      }
      if(i+idx>=n){
        need++;
        idx--;
      }
      else {
        stack[idx++]=c[i];
      }
    }
    out.println((n-need)*5);
  }
  public static void main(String[] args)throws IOException {
    if(SUBMIT){
      in=new InputReader(new FileInputStream(new File(NAME+".in")));
      out=new PrintWriter(new BufferedWriter(new FileWriter(NAME+".out")));
    }
    else {
      in=new InputReader(System.in);
      out=new PrintWriter(System.out,true);
    }
    int numCases=in.nextInt();
    for(int test=1 ; test<=numCases ; test++){
      out.print("Case #"+test+": ");
      main2();
    }
    out.close();
    System.exit(0);
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class teachingassistant {
  static   attribute in : InputReader;
  static   attribute out : OclFile;
  static   attribute SUBMIT : boolean := true;
  static    attribute NAME : String := "A-large";
  static   operation main2() : void
  pre: true
  post: true
  activity: (     var c : Sequence(String) ; c := in.next()->characters() ;
     var n : int ; n := c->size() ;
    var stack : Sequence(String) ; stack := Integer.subrange(1,n)->collect(0) ;
    var idx : int ; idx := 0 ;
    var need : int ; need := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (idx > 0 & stack[idx - 1+1] = c[i+1]) then (     idx := idx - 1 ; 
     continue ) else skip ; 
     if (i + idx >= n) then (     need := need + 1 ; 
     idx := idx - 1 ) else (      stack[idx+1] := c[i+1]  ; idx := idx + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (SUBMIT) then (     in := InputReader.newInputReader(OclFile.newOclFile_Read(OclFile(NAME + ".in"))) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(NAME + ".out"))) ) else (     in := InputReader.newInputReader(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"], true) ) ;  
     var numCases : int ; numCases := in.nextInt() ;
        var test : int ; test := 1 ; while test <= numCases do ( (     skip ; 
     execute main2() )  ;     test := test + 1 ) ; 
    skip ; 
OclProcess.exit(0) ; 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package cj2016.r3 ;
import java.io.*;
import java.util.*;
public class A {
  Scanner sc ;
  PrintWriter pw ;
  char[] c ;
  public static void main(String[] args)throws Exception {
    String filePrefix=args.length>0 ? args[0] : "A-large" ;
    try {
      new A().run(filePrefix);
    }
    catch(Exception e){
      System.err.println(e);
    }
  }
  public void run(String filePrefix)throws Exception {
    sc=new Scanner(new FileReader(filePrefix+".in"));
    pw=new PrintWriter(new FileWriter(filePrefix+".out"));
    int ntest=sc.nextInt();
    for(int test=1 ; test<=ntest ; test++){
      read(sc);
      pw.print("Case #"+test+": ");
      System.out.print("Case #"+test+": ");
      solve();
    }
    System.out.println("Finished.");
    sc.close();
    pw.close();
  }
  void read(Scanner sc){
    c=sc.next().toCharArray();
  }
  void print(Object s){
    pw.print(s);
    System.out.print(s);
  }
  void println(Object s){
    pw.println(s);
    System.out.println(s);
  }
  void solve(){
    int N=c.length ;
    int score=0 ;
    LinkedList<Character>stack=new LinkedList<Character>();
    for(int i=0 ; i<N ; i++){
      if(! stack.isEmpty()&& stack.peek()==c[i]){
        stack.pop();
        score+=10 ;
      }
      else {
        stack.push(c[i]);
      }
    }
    println(score+stack.size()/2*5);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   attribute sc : OclFile;
   attribute pw : OclFile;
   attribute c : Sequence(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var filePrefix : String ; filePrefix := if args->size() > 0 then args[0+1] else "A-large" endif ;
     try (     A.newA().run(filePrefix) )   catch (e : ProgramException) do (     OclFile["System.err"].println(e) )
 );
   operation run( filePrefix : String) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(filePrefix + ".in")) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(filePrefix + ".out")) ; 
    var ntest : int ; ntest := sc.getCurrent()->toInteger() ;
        var test : int ; test := 1 ; while test <= ntest do ( (     execute read(sc) ; 
     skip ; 
     OclFile["System.out"].print("Case #" + test + ": ") ; 
     execute solve() )  ;     test := test + 1 ) ; 
    OclFile["System.out"].println("Finished.") ; 
    skip ; 
    skip ; 
 );
   operation read( sc : OclFile) : void
  pre: true
  post: true
  activity: (     c := sc.getCurrent()->characters() );
   operation print( s : OclAny) : void
  pre: true
  post: true
  activity: (     skip ; 
     OclFile["System.out"].print(s) );
   operation println( s : OclAny) : void
  pre: true
  post: true
  activity: (     skip ; 
     OclFile["System.out"].println(s) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : int ; N := c->size() ;
     var score : int ; score := 0 ;
    var stack : Sequence(String) ; stack := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     if (not(stack->isEmpty()) & stack->min() = c[i+1]) then (     stack := stack->front() ; 
     score := score+(10) ) else (     stack := stack->append(c[i+1]) ) )  ;     i := i + 1 ) ; 
    execute println(score + stack->size() / 2 * 5) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.FilenameFilter ;
import java.util.Locale ;
import java.io.FileOutputStream ;
import java.io.IOException ;
import java.io.FileInputStream ;
import java.io.File ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.LinkedList ;
public class Main {
  public static void main(String[] args){
    Locale.setDefault(Locale.US);
    InputStream inputStream ;
    try {
      final String regex="A-(small|large).*[.] in" ;
      File directory=new File(".");
      File[] candidates=directory.listFiles(new FilenameFilter(){
        public boolean accept(File dir,String name){
          return name.matches(regex);
        }
      }
);
      File toRun=null ;
      for(File candidate : candidates){
        if(toRun==null || candidate.lastModified()>toRun.lastModified())toRun=candidate ;
      }
      inputStream=new FileInputStream(toRun);
    }
    catch(IOException e){
      throw new RuntimeException(e);
    }
    OutputStream outputStream ;
    try {
      outputStream=new FileOutputStream("a.out");
    }
    catch(IOException e){
      throw new RuntimeException(e);
    }
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    int testCount=Integer.parseInt(in.next());
    for(int i=1 ; i<=testCount ; i++)solver.solve(i,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      String s=in.next();
      int pairs=0 ;
      LinkedList<Character>list=new LinkedList<>();
      for(int i=0 ; i<s.length(); i++){
        char next=s.charAt(i);
        char last=list.size()>0 ? list.peekLast(): 'x' ;
        if(last==next){
          pairs++;
          list.pollLast();
        }
        else {
          list.add(next);
        }
      }
      out.printf("Case #%d: %d\n",testNumber,pairs*10+5*list.size()/2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.US) ; 
     var inputStream : OclFile ;
    try (     var regex : String ; regex := "A-(small|large).*[.] in" ;
     var directory : OclFile ; directory := OclFile(".") ;
    var candidates : Sequence(OclFile) ; candidates := directory.listFiles(OclRegex()) ;
    var toRun : OclFile ; toRun := null ;
    for (candidate : candidates) do ( (     if (toRun = null or candidate.lastModified() > toRun.lastModified()) then     toRun := candidate ; else skip )  ) ; 
    inputStream := OclFile.newOclFile_Read(toRun) ; 
 )   catch (e : IOException) do (     error ProgramException(e) )
    var outputStream : OclFile ;
    try (     outputStream := OclFile.newOclFile_Write(OclFile.newOclFile("a.out")) )   catch (e : IOException) do (     error ProgramException(e) )
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    var testCount : int ; testCount := (in.getCurrent())->toInteger() ;
        var i : int ; i := 1 ; while i <= testCount do (     solver.solve(i, in, out) ;  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.getCurrent() ;
     var pairs : int ; pairs := 0 ;
    var list : Sequence(String) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var next : String ; next := s->at(i+1) ;
     var last : String ; last := if list->size() > 0 then list.peekLast() else 'x' endif ;
     if (last = next) then (     pairs := pairs + 1 ; 
     list := list->front() ) else (     list := list->including(next) ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Assistant {
  public void solve(){
    String s=in.nextToken();
    char[] stack=new char[s.length()];
    int size=0 ;
    for(char c : s.toCharArray()){
      if(size>0 && c==stack[size-1]){
        size--;
      }
      else {
        stack[size++]=c ;
      }
    }
    out.println(5*(size/2)+10*(s.length()-size)/2);
  }
  public void run(){
    try {
      in=new FastScanner("input.txt");
      out=new PrintWriter("output.txt");
      int tests=in.nextInt();
      for(int i=1 ; i<=tests ; i++){
        long time=System.currentTimeMillis();
        out.printf("Case #%d: ",i);
        solve();
        System.err.printf("Solved case #%d in %d ms\n",i,System.currentTimeMillis()-time);
      }
      out.close();
    }
    catch(FileNotFoundException e){
    }
  }
  FastScanner in ;
  PrintWriter out ;
  class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(String fileName){
      try {
        br=new BufferedReader(new FileReader(fileName));
      }
      catch(FileNotFoundException e){
      }
    }
    String nextToken(){
      while(st==null || ! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
        }
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(nextToken());
    }
    long nextLong(){
      return Long.parseLong(nextToken());
    }
    double nextDouble(){
      return Double.parseDouble(nextToken());
    }
  }
  public static void main(String[] args){
    new Assistant().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Assistant {
   operation solve() : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.next() ;
     var stack : Sequence(String) ; stack := Integer.subrange(1,s->size())->collect(0) ;
    var size : int ; size := 0 ;
    for (c : s->characters()) do ( (     if (size > 0 & c = stack[size - 1+1]) then (     size := size - 1 ) else (      stack[size+1] := c  ; size := size + 1 ) )  ) ; 
    out.println(5 * (size / 2) + 10 * (s->size() - size) / 2) ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     in := FastScanner.newFastScanner("input.txt") ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ; 
    var tests : int ; tests := in.nextInt() ;
        var i : int ; i := 1 ; while i <= tests do ( (     var time : long ; time := OclDate.getSystemTime() ;
     out.printf("Case #%d: ", i) ; 
     execute solve() ; 
     OclFile["System.err"].printf("Solved case #%d in %d ms\n", i, OclDate.getSystemTime() - time) )  ;     i := i + 1 ) ; 
    out.close() ; 
 )   catch (e : FileNotFoundException) do skip
 );
   attribute in : FastScanner;
   attribute out : OclFile;
 class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( fileName : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(fileName);
    return self );
  operation initialise( fileName : String) : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(fileName)) )   catch (e : FileNotFoundException) do skip
 );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Assistant.newAssistant().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package gcj.gcj2016.round3 ;
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.Stack ;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=in.nextInt();
    for(int cs=1 ; cs<=t ; cs++){
      char[] c=in.next().toCharArray();
      out.println(String.format("Case #%d: %d",cs,solve(c)));
    }
    out.flush();
  }
  private static int solve(char[] mood){
    int n=mood.length ;
    int score=0 ;
    int code=0 ;
    int jam=0 ;
    Stack<Character>stk=new Stack<>();
    for(int i=0 ; i<n ; i++){
      if(stk.size()==0){
        stk.push(mood[i]);
      }
      else {
        if(stk.peek()==mood[i]){
          stk.pop();
          score+=10 ;
        }
        else {
          int pool=stk.size();
          int left=n-i ;
          if(pool+1<=left-1){
            stk.push(mood[i]);
          }
          else {
            stk.pop();
            score+=5 ;
          }
        }
      }
    }
    return score ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        var cs : int ; cs := 1 ; while cs <= t do ( (     var c : Sequence(String) ; c := in.getCurrent()->characters() ;
     skip )  ;     cs := cs + 1 ) ; 
    skip ; 
 );
  static   operation solve( mood : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := mood->size() ;
     var score : int ; score := 0 ;
    var code : int ; code := 0 ;
    var jam : int ; jam := 0 ;
    var stk : Sequence(String) ; stk := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (stk->size() = 0) then (     stk := stk->append(mood[i+1]) ) else (     if (stk->min() = mood[i+1]) then (     stk := stk->front() ; 
     score := score+(10) ) else (     var pool : int ; pool := stk->size() ;
     var left : int ; left := n - i ;
     if (pool + 1 <= left - 1) then (     stk := stk->append(mood[i+1]) ) else (     stk := stk->front() ; 
     score := score+(5) ) ) ) )  ;     i := i + 1 ) ; 
    return score 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] w=new int[N];
    w[0]=sc.nextInt();
    for(int i=1 ; i<N ; i++){
      w[i]=w[i-1]+sc.nextInt();
    }
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<N ; i++){
      int front=w[i];
      int back=w[N-1]-w[i];
      min=Math.min(min,Math.abs(back-front));
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var w : Sequence(int) ; w := Integer.subrange(1,N)->collect(0) ;
    w[0+1] := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i < N do ( (     w[i+1] := w[i - 1+1] + sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < N do ( (     var front : int ; front := w[i+1] ;
     var back : int ; back := w[N - 1+1] - w[i+1] ;
     min := Set{min, if back - front < 0 then -(back - front) else back - front endif}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String argv[]){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] W=new int[N];
    for(int i=0 ; i<N ; i++){
      W[i]=sc.nextInt();
    }
    int diff=100000 ;
    for(int i=1 ; i<N ; i++){
      int sum1=sum_array(W,0,i);
      int sum2=sum_array(W,i,N);
      if(Math.abs(sum1-sum2)<diff){
        diff=Math.abs(sum1-sum2);
      }
    }
    System.out.println(diff);
  }
  public static int sum_array(int[] array,int a,int b){
    int result=0 ;
    for(int i=a ; i<b ; i++){
      result+=array[i];
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( argv : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var W : Sequence(int) ; W := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     W[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var diff : int ; diff := 100000 ;
        var i : int ; i := 1 ; while i < N do ( (     var sum1 : int ; sum1 := sum_array(W, 0, i) ;
     var sum2 : int ; sum2 := sum_array(W, i, N) ;
     if (if sum1 - sum2 < 0 then -(sum1 - sum2) else sum1 - sum2 endif < diff) then (     diff := if sum1 - sum2 < 0 then -(sum1 - sum2) else sum1 - sum2 endif ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(diff) ; 
 );
  static   operation sum_array( array : Sequence(int), a : int, b : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := a ; while i < b do ( (     result := result+(array[i+1]) )  ;     i := i + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  static String br=System.getProperty("line.separator");
  static Scanner sc=new Scanner(System.in);
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    int N=nextInt();
    int[] W=new int[N];
    int sum=0 ;
    for(int i=0 ; i<N ; i++){
      W[i]=nextInt();
      sum+=W[i];
    }
    int min=sum ;
    int sum2=0 ;
    for(int i=0 ; i<N-1 ; i++){
      sum2+=W[i];
      min=Math.min(Math.abs(sum-sum2-sum2),min);
    }
    println(min);
  }
  static long lcm(long a,long b){
    long temp ;
    long c=a ;
    c*=b ;
    while((temp=a % b)!=0){
      a=b ;
      b=temp ;
    }
    return(c/b);
  }
  static int nextInt(){
    return Integer.parseInt(next());
  }
  static Long nextLong(){
    return Long.parseLong(next());
  }
  static String next(){
    return sc.next();
  }
  static String nextLine(){
    return sc.nextLine();
  }
  static void println(Object o){
    out.println(o);
    out.flush();
  }
  static void print(Object o){
    PrintWriter out=new PrintWriter(System.out);
    out.print(o);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : String := OclProcess.getEnvironmentProperty("line.separator");
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := nextInt() ;
     var W : Sequence(int) ; W := Integer.subrange(1,N)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     W[i+1] := nextInt() ; 
     sum := sum+(W[i+1]) )  ;     i := i + 1 ) ; 
    var min : int ; min := sum ;
    var sum2 : int ; sum2 := 0 ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     sum2 := sum2+(W[i+1]) ; 
     min := Set{if sum - sum2 - sum2 < 0 then -(sum - sum2 - sum2) else sum - sum2 - sum2 endif, min}->min() )  ;     i := i + 1 ) ; 
    execute println(min) ; 
 );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var temp : long ;
     var c : long ; c := a ;
    c := c*(b) ; 
        temp := a mod b ;
    while ((temp) /= 0) do (    skip ; (     a := b ; 
     b := temp ) ;     temp := a mod b ;
 ) ;  
    return (c / b) 
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation next() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
  static   operation nextLine() : String
  pre: true
  post: true
  activity: (     return sc.nextLine() );
  static   operation println( o : OclAny) : void
  pre: true
  post: true
  activity: (     skip ; 
     skip );
  static   operation print( o : OclAny) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     skip ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    SC sc=new SC(System.in);
    int N=sc.nextInt();
    int[] W=new int[N+1];
    for(int i=1 ; i<=N ; i++){
      W[i]=sc.nextInt();
    }
    for(int i=1 ; i<=N ; i++){
      W[i]=W[i]+W[i-1];
    }
    int MIN=114514810 ;
    for(int i=1 ; i<N ; i++){
      MIN=Math.min(MIN,Math.abs((W[N]-W[i])-W[i]));
    }
    pl(MIN);
  }
  static class SC {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public SC(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        throw new UncheckedIOException(e);
      }
    }
  }
  public static void pl(Object o){
    System.out.println(o);
  }
  public static void pl(){
    System.out.println();
  }
  public static void p(Object o){
    System.out.print(o);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : SC ; sc := SC.newSC(OclFile["System.in"]) ;
     var N : int ; N := sc.nextInt() ;
    var W : Sequence(int) ; W := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do ( (     W[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (     W[i+1] := W[i+1] + W[i - 1+1] )  ;     i := i + 1 ) ; 
    var MIN : int ; MIN := 114514810 ;
        var i : int ; i := 1 ; while i < N do ( (     MIN := Set{MIN, if (W[N+1] - W[i+1]) - W[i+1] < 0 then -((W[N+1] - W[i+1]) - W[i+1]) else (W[N+1] - W[i+1]) - W[i+1] endif}->min() )  ;     i := i + 1 ) ; 
    execute pl(MIN) ; 
 );
  static class SC {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newSC( in : OclFile) : SC
  pre: true
  post: true
  activity:
  ( var self : SC ;
    self := createSC();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 );
}
  static   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation pl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countFact(int low,int high){
    int fact=1,x=1 ;
    while(fact<low){
      fact=fact*x ;
      x++;
    }
    int res=0 ;
    while(fact<=high){
      res++;
      fact=fact*x ;
      x++;
    }
    return res ;
  }
  public static void main(String[] args){
    System.out.print("Count is "+countFact(2,720));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countFact( low : int, high : int) : int
  pre: true
  post: true
  activity: (     var fact : int ; fact := 1 ;
    var x : int ; x := 1 ;
     while (fact < low) do (     fact := fact * x ; 
     x := x + 1 ) ; 
    var res : int ; res := 0 ;
    while (fact <= high) do (     res := res + 1 ; 
     fact := fact * x ; 
     x := x + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("Count is " + countFact(2, 720)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=getInt(sc);
    int d=getInt(sc);
    int[][] points=new int[n][d];
    for(int i=0 ; i<n ; i++){
      points[i]=getIntArray(sc);
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        if(isInteger(getDistance(points[i],points[j]))){
          count++;
        }
      }
    }
    System.out.println(count);
  }
  private static boolean isInteger(double distance){
    return(int)distance==distance ;
  }
  private static double getDistance(int[] is,int[] is2){
    int distanceSquare=0 ;
    for(int i=0 ; i<is.length ; i++){
      distanceSquare+=Math.pow(is[i]-is2[i],2);
    }
    return Math.sqrt(distanceSquare);
  }
  public static long getLong(Scanner sc){
    return Long.parseLong(sc.next());
  }
  public static int getInt(Scanner sc){
    return Integer.parseInt(sc.next());
  }
  public static String getString(Scanner sc){
    return sc.next();
  }
  public static int[] getIntArray(Scanner sc){
    String line="" ;
    while(line.equals("")){
      line=sc.nextLine();
    }
    String[] strArray=line.split(" ");
    int[] intArray=new int[strArray.length];
    for(int i=0 ; i<strArray.length ; i++){
      intArray[i]=Integer.parseInt(strArray[i]);
    }
    return intArray ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := getInt(sc) ;
    var d : int ; d := getInt(sc) ;
    var points : Sequence(Sequence(int)) ; points := Integer.subrange(1,n)->collect(Integer.subrange(1,d)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     points[i+1] := getIntArray(sc) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (isInteger(getDistance(points[i+1], points[j+1]))) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation isInteger( distance : double) : boolean
  pre: true
  post: true
  activity: (     return distance->oclAsType(int) = distance );
  static   operation getDistance( is : Sequence(int), is2 : Sequence(int)) : double
  pre: true
  post: true
  activity: (     var distanceSquare : int ; distanceSquare := 0 ;
         var i : int ; i := 0 ; while i < is->size() do ( (     distanceSquare := distanceSquare+(is[i+1] - is2[i+1]->pow(2)) )  ;     i := i + 1 ) ; 
     return (distanceSquare)->sqrt() );
  static   operation getLong( sc : OclFile) : long
  pre: true
  post: true
  activity: (     return (sc.getCurrent())->toLong() );
  static   operation getInt( sc : OclFile) : int
  pre: true
  post: true
  activity: (     return (sc.getCurrent())->toInteger() );
  static   operation getString( sc : OclFile) : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
  static   operation getIntArray( sc : OclFile) : Sequence(int)
  pre: true
  post: true
  activity: (     var line : String ; line := "" ;
     while (line = "") do (     line := sc.nextLine() ) ; 
    var strArray : Sequence(String) ; strArray := line->split(" ") ;
    var intArray : Sequence(int) ; intArray := Integer.subrange(1,strArray->size())->collect(0) ;
        var i : int ; i := 0 ; while i < strArray->size() do ( (     intArray[i+1] := (strArray[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    return intArray 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] arg){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    ArrayList<Integer>W=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      W.add(scan.nextInt());
    }
    int sum=0 ;
    for(Integer temp : W){
      sum+=temp ;
    }
    int sumk=0 ;
    int min=Math.abs(sum-2*W.get(0));
    int diffk ;
    for(int j=0 ; j<n-1 ; j++){
      sumk=0 ;
      for(int k=0 ; k<=j ; k++){
        sumk+=W.get(k);
      }
      diffk=Math.abs(sum-2*sumk);
      if(diffk<min)min=diffk ;
    }
    System.out.print(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var W : Sequence(int) ; W := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     W := W->including(scan.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    for (temp : W) do ( (     sum := sum+(temp) )  ) ; 
    var sumk : int ; sumk := 0 ;
    var min : int ; min := if sum - 2 * W->at(0+1) < 0 then -(sum - 2 * W->at(0+1)) else sum - 2 * W->at(0+1) endif ;
    var diffk : int ;
        var j : int ; j := 0 ; while j < n - 1 do ( (     sumk := 0 ; 
         var k : int ; k := 0 ; while k <= j do ( (     sumk := sumk+(W->at(k+1)) )  ;     k := k + 1 ) ; 
     diffk := if sum - 2 * sumk < 0 then -(sum - 2 * sumk) else sum - 2 * sumk endif ; 
     if (diffk < min) then     min := diffk ; else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].print(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class C {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner in=new Scanner(new File("input.txt"));
    PrintWriter out=new PrintWriter("output.txt");
    int T=in.nextInt();
    for(int i=0 ; i<T ; i++){
      String s="Case #"+(i+1)+": "+new C().solve(in);
      out.println(s);
      System.out.println(s);
    }
    out.close();
  }
  private String solve(Scanner in){
    long N=in.nextLong();
    int m=0 ;
    while(1l*m*m<=N)m++;
    boolean[] p=new boolean[m];
    Arrays.fill(p,true);
    int res=0 ;
    for(int x=2 ; x<m ; x++){
      if(p[x]){
        for(int y=x+x ; y<m ; y+=x){
          p[y]=false ;
        }
        int t=0 ;
        long n=N ;
        while(n>=x){
          n/=x ;
          t++;
        }
        res+=t-1 ;
      }
    }
    if(N>1)res++;
    return ""+res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("input.txt")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < T do ( (     var s : String ; s := "Case #" + (i + 1) + ": " + C.newC().solve(in) ;
     skip ; 
     OclFile["System.out"].println(s) )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation solve( in : OclFile) : String
  pre: true
  post: true
  activity: (     var N : long ; N := in.getCurrent()->toLong() ;
     var m : int ; m := 0 ;
    while (1l * m * m <= N) do     m := m + 1 ; ; 
    var p : Sequence(boolean) ; p := Integer.subrange(1,m)->collect(false) ;
    p := p->collect(true) ; 
    var res : int ; res := 0 ;
        var x : int ; x := 2 ; while x < m do ( (     if (p[x+1]) then (         var y : int ; y := x + x ; while y < m do ( (     p[y+1] := false )  ;     y := y+(x) ) ; 
     var t : int ; t := 0 ;
    var n : long ; n := N ;
    while (n >= x) do (     n := n/(x) ; 
     t := t + 1 ) ; 
    res := res+(t - 1) ; 
 ) else skip )  ;     x := x + 1 ) ; 
    if (N > 1) then     res := res + 1 ; else skip ; 
    return "" + res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.math.BigInteger.*;
import static java.util.Arrays.*;
import java.io.*;
import java.math.*;
import java.util.*;
public class C {
  Scanner sc=new Scanner(System.in);
  int M=1000010 ;
  void solve(){
    long N=sc.nextLong();
    if(N==1){
      System.out.println(0);
      return ;
    }
    boolean[] isPrime=new boolean[M];
    for(int i=3 ; i<M ; i+=2)isPrime[i]=true ;
    isPrime[2]=true ;
    for(int i=3 ; i*i<M ; i+=2)if(isPrime[i]){
      for(int j=i*i,k=i*2 ; j<M ; j+=k){
        isPrime[j]=false ;
      }
    }
    long res=1 ;
    for(long i=2 ; i*i<=N ; i++)if(isPrime[(int)i]){
      int num=2 ;
      long j=i*i ;
      while(j*i<=N){
        j*=i ;
        num++;
      }
      res+=num-1 ;
    }
    System.out.println(res);
  }
  void run(){
    int caseN=sc.nextInt();
    for(int caseID=1 ; caseID<=caseN ; caseID++){
      System.out.printf("Case #%d: ",caseID);
      solve();
      System.out.flush();
    }
  }
  void debug(Object...os){
    System.err.println(deepToString(os));
  }
  public static void main(String[] args){
    try {
      System.setIn(new BufferedInputStream(new FileInputStream(args.length>0 ? args[0] :(C.class.getName()+".in"))));
    }
    catch(Exception e){
    }
    new C().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute M : int := 1000010;
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : long ; N := sc.getCurrent()->toLong() ;
     if (N = 1) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var isPrime : Sequence(boolean) ; isPrime := Integer.subrange(1,M)->collect(false) ;
        var i : int ; i := 3 ; while i < M do (     isPrime[i+1] := true ;  ;     i := i+(2) ) ; 
    isPrime[2+1] := true ; 
        var i : int ; i := 3 ; while i * i < M do (     if (isPrime[i+1]) then (         var j : int ; j := i * i ;
    var k : int ; k := i * 2 ; while j < M do ( (     isPrime[j+1] := false )  ;     j := j+(k) ) ) else skip ;  ;     i := i+(2) ) ; 
    var res : long ; res := 1 ;
        var i : long ; i := 2 ; while i * i <= N do (     if (isPrime[i->oclAsType(int)+1]) then (     var num : int ; num := 2 ;
     var j : long ; j := i * i ;
     while (j * i <= N) do (     j := j*(i) ; 
     num := num + 1 ) ; 
     res := res+(num - 1) ) else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     var caseN : int ; caseN := sc.getCurrent()->toInteger() ;
         var caseID : int ; caseID := 1 ; while caseID <= caseN do ( (     OclFile["System.out"].printf("Case #%d: ", caseID) ; 
     execute solve() ; 
     OclFile["System.out"].flush() )  ;     caseID := caseID + 1 ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile_Read(if args->size() > 0 then args[0+1] else (OclType["C"].getName() + ".in") endif))) )   catch (e : ProgramException) do skip
     C.newC().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ExpensiveDinner {
  void solve()throws Exception {
    long n=nextLong();
    if(n==1){
      out.println(0);
      return ;
    }
    ArrayList<Long>primes=new ArrayList<Long>();
    int sqrt=(int)Math.sqrt(n)+10 ;
    boolean[] a=new boolean[sqrt+1];
    for(int i=2 ; i<=sqrt ; i++){
      if(! a[i]){
        primes.add((long)i);
        for(int j=2*i ; j<=sqrt ; j+=i)a[j]=true ;
      }
    }
    long ans1=0 ;
    long ans2=1 ;
    for(long i : primes){
      if(i>n)break ;
      ans1++;
      long j=i ;
      while(j<=n){
        ans2++;
        j*=i ;
      }
    }
    out.println(ans2-ans1);
  }
  void run(){
    try {
      in=new BufferedReader(new FileReader("input.txt"));
      out=new PrintWriter("output.txt");
      int tests=nextInt();
      for(int i=0 ; i<tests ; i++){
        out.print("Case #"+(i+1)+": ");
        solve();
      }
      out.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  BufferedReader in ;
  StringTokenizer st ;
  PrintWriter out ;
  final String filename=new String("ExpensiveDinner").toLowerCase();
  String nextToken()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(in.readLine());
    return st.nextToken();
  }
  int nextInt()throws Exception {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws Exception {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws Exception {
    return Double.parseDouble(nextToken());
  }
  public static void main(String[] args){
    new ExpensiveDinner().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ExpensiveDinner {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : long ; n := nextLong() ;
     if (n = 1) then (     out.println(0) ; 
     return ) else skip ; 
    var primes : Sequence(long) ; primes := Sequence{} ;
    var sqrt : int ; sqrt := (n)->sqrt()->oclAsType(int) + 10 ;
    var a : Sequence(boolean) ; a := Integer.subrange(1,sqrt + 1)->collect(false) ;
        var i : int ; i := 2 ; while i <= sqrt do ( (     if (not(a[i+1])) then (     primes := primes->including(i->oclAsType(long)) ; 
         var j : int ; j := 2 * i ; while j <= sqrt do (     a[j+1] := true ;  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    var ans1 : long ; ans1 := 0 ;
    var ans2 : long ; ans2 := 1 ;
    for (i : primes) do ( (     if (i > n) then     break else skip ; 
     ans1 := ans1 + 1 ; 
     var j : long ; j := i ;
     while (j <= n) do (     ans2 := ans2 + 1 ; 
     j := j*(i) ) )  ) ; 
    out.println(ans2 - ans1) ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ; 
    var tests : int ; tests := nextInt() ;
        var i : int ; i := 0 ; while i < tests do ( (     out.print("Case #" + (i + 1) + ": ") ; 
     execute solve() )  ;     i := i + 1 ) ; 
    out.close() ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
   attribute in : OclFile;
   attribute st : OclIterator;
   attribute out : OclFile;
   attribute filename : String := StringLib.newString("ExpensiveDinner")->toLowerCase();
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(in.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     ExpensiveDinner.newExpensiveDinner().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final long MAX=1000000000 ;
  static void findTriangle(long S){
    long X1=0,Y1=0 ;
    long X2=MAX,Y2=1 ;
    long X3=(MAX-S % MAX)% MAX ;
    long Y3=(S+X3)/MAX ;
    System.out.println("("+X1+","+Y1+")");
    System.out.println("("+X2+","+Y2+")");
    System.out.println("("+X3+","+Y3+")");
  }
  public static void main(String[] args){
    long S=4 ;
    findTriangle(S);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : long := 1000000000;
  static   operation findTriangle( S : long) : void
  pre: true
  post: true
  activity: (     var X1 : long ; X1 := 0 ;
    var Y1 : long ; Y1 := 0 ;
     var X2 : long ; X2 := MAX ;
    var Y2 : long ; Y2 := 1 ;
    var X3 : long ; X3 := (MAX - S mod MAX) mod MAX ;
    var Y3 : long ; Y3 := (S + X3) / MAX ;
    OclFile["System.out"].println("(" + X1 + "," + Y1 + ")") ; 
    OclFile["System.out"].println("(" + X2 + "," + Y2 + ")") ; 
    OclFile["System.out"].println("(" + X3 + "," + Y3 + ")") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := 4 ;
     execute findTriangle(S) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
    public static void main(String[] args) {
        try (Scanner sc = new Scanner(System.in)) {
            solve(sc);
        }
    }
    static void solve(Scanner sc) {
        ArrayDeque<Integer> idxList = new ArrayDeque<>();
        ArrayDeque<Puddle> areaStuck = new ArrayDeque<>();
        char[] input = sc.next().toCharArray();
        for (int i = 0; i < input.length; i++) {
            if (input[i] == '\\') {
                idxList.push(i);
            } else if (input[i] == '/' && idxList.size() > 0) {
                int j = idxList.pop();
                int tmp = i - j;
                while (areaStuck.size() > 0 && areaStuck.peek().beginIndex > j) {
                    Puddle stuck = areaStuck.pop();
                    tmp += stuck.area;
                }
                areaStuck.push(new Puddle(j, tmp));
            }
        }
        int sum = 0, cnt = areaStuck.size();
        StringBuilder sb = new StringBuilder();
        while (!areaStuck.isEmpty()) {
            int tmp = areaStuck.removeLast().area;
            sb.append(tmp).append(' ');
            sum += tmp;
        }
        System.out.println(sum);
        System.out.print(cnt);
        System.out.println(sb.length() > 0 ? (" " + sb.toString().trim()) : " ");
    }
}
class Puddle {
    int beginIndex;
    int area;
    Puddle(int beginIndex, int area) {
        this.beginIndex = beginIndex;
        this.area = area;
    }
}

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     execute solve(sc) ))  );
  static   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var idxList : Sequence(int) ; idxList := ArrayDeque<OclAny>.newArrayDeque() ;
     var areaStuck : Sequence(Puddle) ; areaStuck := ArrayDeque<OclAny>.newArrayDeque() ;
    var input : Sequence(String) ; input := sc.getCurrent()->characters() ;
        var i : int ; i := 0 ; while i < input->size() do ( (     if (input[i+1] = '\\') then (     idxList := idxList->append(i) ) else     if (input[i+1] = '/' & idxList->size() > 0) then (     var j : int ; j := idxList->last() ;
     var tmp : int ; tmp := i - j ;
     while (areaStuck->size() > 0 & areaStuck->min().beginIndex > j) do (     var stuck : Puddle ; stuck := areaStuck->last() ;
     tmp := tmp+(stuck.area) ) ; 
     areaStuck := areaStuck->append(Puddle.newPuddle(j, tmp)) ) else skip ; )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var cnt : int ; cnt := areaStuck->size() ;
    var sb : String ; sb := StringLib.newString() ;
    while (not(areaStuck->isEmpty())) do (     var tmp : int ; tmp := areaStuck->last().area ;
     sb := sb + StringLib.newString(tmp) + StringLib.newString(' ') ; 
     sum := sum+(tmp) ) ; 
    OclFile["System.out"].println(sum) ; 
    OclFile["System.out"].print(cnt) ; 
    OclFile["System.out"].println(if sb->size() > 0 then (" " + sb+""->trim()) else " " endif) ; 
 );
}
class Puddle {
   attribute beginIndex : int;
   attribute area : int;
   static operation newPuddle( beginIndex : int, area : int) : Puddle
  pre: true
  post: true
  activity:
  ( var self : Puddle ;
    self := createPuddle();
    self.initialise(beginIndex, area);
    return self );
  operation initialise( beginIndex : int, area : int) : void
  pre: true  post: true
  activity: (     self.beginIndex := beginIndex ; 
     self.area := area );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner;
import java.util.Stack;
public class Main {
    public static void main(String arg[]) {
        Scanner sc = new Scanner(System.in);
        Stack<Integer> SlopeStack = new Stack<>();
        Stack<Pool> poolStack = new Stack<>();
        String ch;
        int sum = 0;
        ch = sc.nextLine();
        for (int i = 0; i < ch.length(); i++) {
            switch (ch.charAt(i)) {
                case '\\':
                    SlopeStack.push(i);
                    break;
                case '/':
                    if (!SlopeStack.isEmpty()) {
                        Pool v = new Pool(SlopeStack.pop(), i);
                        while (!poolStack.isEmpty()) {
                            Pool latest = poolStack.pop();
                            if (!v.isChild(latest)) {
                                poolStack.push(latest);
                                break;
                            }
                            v.addSize(latest.getSize());
                        }
                        poolStack.push(v);
                    }
                    break;
                case '_':
                    break;
            }
        }
        int[] areaSize = new int[poolStack.size()];
        for (int i = 0; i < areaSize.length; i++) {
            areaSize[i] = poolStack.pop().getSize();
            sum += areaSize[i];
        }
        System.out.println(sum);
        System.out.print(areaSize.length);
        for (int i = areaSize.length - 1; i >= 0; i--) {
            System.out.print(" " + areaSize[i]);
        }
        System.out.println();
    }
}
class Pool {
    int left;
    int right;
    int area;
    Pool(int left, int right) {
        this.left = left;
        this.right = right;
        this.area = right - left;
    }
    public void addSize(int i) {
        area += i;
    }
    public boolean isChild(Pool pool) {
        return left < pool.left && right > pool.right;
    }
    public int getSize() {
        return area;
    }
}

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var SlopeStack : Sequence(int) ; SlopeStack := Sequence{} ;
    var poolStack : Sequence(Pool) ; poolStack := Sequence{} ;
    var ch : String ;
    var sum : int ; sum := 0 ;
    ch := sc.nextLine() ; 
        var i : int ; i := 0 ; while i < ch->size() do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (ch->at(i+1)) ; 
       if _switchval = '\\' then
     SlopeStack := SlopeStack->append(i) ; 
    break 
   else skip ;
       if _switchval = '/' then
     if (not(SlopeStack->isEmpty())) then (     var v : Pool ; v := Pool.newPool(SlopeStack->last(), i) ;
     while (not(poolStack->isEmpty())) do (     var latest : Pool ; latest := poolStack->last() ;
     if (not(v.isChild(latest))) then (     poolStack := poolStack->append(latest) ; 
     break ) else skip ; 
     v.addSize(latest.getSize()) ) ; 
     poolStack := poolStack->append(v) ) else skip ; 
    break 
   else skip ;
       if _switchval = '_' then
     break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    var areaSize : Sequence(int) ; areaSize := Integer.subrange(1,poolStack->size())->collect(0) ;
        var i : int ; i := 0 ; while i < areaSize->size() do ( (     areaSize[i+1] := poolStack->last().getSize() ; 
     sum := sum+(areaSize[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
    OclFile["System.out"].print(areaSize->size()) ; 
        var i : int ; i := areaSize->size() - 1 ; while i >= 0 do ( (     OclFile["System.out"].print(" " + areaSize[i+1]) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}
class Pool {
   attribute left : int;
   attribute right : int;
   attribute area : int;
   static operation newPool( left : int, right : int) : Pool
  pre: true
  post: true
  activity:
  ( var self : Pool ;
    self := createPool();
    self.initialise(left, right);
    return self );
  operation initialise( left : int, right : int) : void
  pre: true  post: true
  activity: (     self.left := left ; 
     self.right := right ; 
     self.area := right - left );
   operation addSize( i : int) : void
  pre: true
  post: true
  activity: (     area := area+(i) );
   operation isChild( pool : Pool) : boolean
  pre: true
  post: true
  activity: (     return left < pool.left & right > pool.right );
   operation getSize() : int
  pre: true
  post: true
  activity: (     return area );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        LinkedList<Integer> posList = new LinkedList<>();
        LinkedList<Record> areaList = new LinkedList<>();
        int sum = 0, area = 0;
        Scanner sc = new Scanner(System.in);
        String[] input = sc.nextLine().split("");
        sc.close();
        for (int i = 0; i < input.length; i++) {
            if ("\\".equals(input[i])) {
                posList.add(i);
            } else if ("/".equals(input[i]) && (!posList.isEmpty())) {
                Integer leftPos = posList.removeLast();
                sum += i - leftPos;
                area = i - leftPos;
                while (!areaList.isEmpty() && areaList.getLast().getPos() > leftPos) {
                    area += areaList.removeLast().getArea();
                }
                areaList.add(new Record(leftPos, area));
            }
        }
        System.out.println(sum);
        System.out.print(areaList.size());
        while (!areaList.isEmpty()) {
            System.out.print(" " + areaList.removeFirst().getArea());
        }
        System.out.println();
    }
}
class Record {
    private int pos;
    private int area;
    public int getPos() {
        return pos;
    }
    public void setPos(int pos) {
        this.pos = pos;
    }
    public int getArea() {
        return area;
    }
    public void setArea(int area) {
        this.area = area;
    }
    public Record(int pos, int area) {
        this.pos = pos;
        this.area = area;
    }
}

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var posList : Sequence(int) ; posList := Sequence{} ;
     var areaList : Sequence(Record) ; areaList := Sequence{} ;
    var sum : int ; sum := 0 ;
    var area : int ; area := 0 ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var input : Sequence(String) ; input := sc.nextLine()->split("") ;
    skip ; 
        var i : int ; i := 0 ; while i < input->size() do ( (     if ("\\" = input[i+1]) then (     posList := posList->including(i) ) else     if ("/" = input[i+1] & (not(posList->isEmpty()))) then (     var leftPos : int ; leftPos := posList->last() ;
     sum := sum+(i - leftPos) ; 
    area := i - leftPos ; 
    while (not(areaList->isEmpty()) & areaList->last().getPos() > leftPos) do (     area := area+(areaList->last().getArea()) ) ; 
    areaList := areaList->including(Record.newRecord(leftPos, area)) ; 
 ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
    OclFile["System.out"].print(areaList->size()) ; 
    while (not(areaList->isEmpty())) do (     OclFile["System.out"].print(" " + areaList->first().getArea()) ) ; 
    OclFile["System.out"].println() ; 
 );
}
class Record {
   attribute pos : int;
   attribute area : int;
   operation getPos() : int
  pre: true
  post: true
  activity: (     return pos );
   operation setPos( pos : int) : void
  pre: true
  post: true
  activity: (     self.pos := pos );
   operation getArea() : int
  pre: true
  post: true
  activity: (     return area );
   operation setArea( area : int) : void
  pre: true
  post: true
  activity: (     self.area := area );
   static operation newRecord( pos : int, area : int) : Record
  pre: true
  post: true
  activity:
  ( var self : Record ;
    self := createRecord();
    self.initialise(pos, area);
    return self );
  operation initialise( pos : int, area : int) : void
  pre: true  post: true
  activity: (     self.pos := pos ; 
     self.area := area );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private class Point {
    int size=0 ;
    int[] as=null ;
    public Point(int dim){
      this.size=dim ;
      this.as=new int[dim];
    }
    public void read(Scanner in){
      for(int i=0 ; i<this.size ; i++){
        as[i]=in.nextInt();
      }
    }
    public boolean isIntegerDiff(Point oth){
      long diff=0 ;
      for(int i=0 ; i<size ; i++){
        long d=this.as[i]-oth.as[i];
        diff+=d*d ;
      }
      long num=Math.round(Math.sqrt((double)diff));
      if(num*num==diff){
        return true ;
      }
      else {
        return false ;
      }
    }
  }
  public void solve(){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int D=in.nextInt();
    Point[] ps=new Point[N];
    for(int i=0 ; i<N ; i++){
      ps[i]=new Point(D);
      ps[i] .read(in);
    }
    in.close();
    long count=0 ;
    for(int i=0 ; i<N ; i++){
      for(int j=i+1 ; j<N ; j++){
        if(ps[i] .isIntegerDiff(ps[j])){
          count++;
        }
      }
    }
    System.out.println(count);
  }
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class Point {
   attribute size : int := 0;
   attribute as : Sequence(int) := null;
   static operation newPoint( dim : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(dim);
    return self );
  operation initialise( dim : int) : void
  pre: true  post: true
  activity: (     self.size := dim ; 
     self.as := Integer.subrange(1,dim)->collect(0) );
   operation read( in : OclFile) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < self.size do ( (     as[i+1] := in.nextInt() )  ;     i := i + 1 ) );
   operation isIntegerDiff( oth : Point) : boolean
  pre: true
  post: true
  activity: (     var diff : long ; diff := 0 ;
         var i : int ; i := 0 ; while i < size do ( (     var d : long ; d := self.as[i+1] - oth.as[i+1] ;
     diff := diff+(d * d) )  ;     i := i + 1 ) ; 
     var num : long ; num := ((diff->oclAsType(double))->sqrt())->round() ;
     if (num * num = diff) then (     return true ) else (     return false ) );
}
   operation solve() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var D : int ; D := in.getCurrent()->toInteger() ;
    var ps : Sequence(Point) ; ps := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     ps[i+1] := Point.newPoint(D) ; 
     ps[i+1].read(in) )  ;     i := i + 1 ) ; 
    skip ; 
    var count : long ; count := 0 ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := i + 1 ; while j < N do ( (     if (ps[i+1].isIntegerDiff(ps[j+1])) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static int findOccurrences(String str1,String substr1){
    int n=str1.length();
    char[] str=str1.toCharArray();
    char[] substr=substr1.toCharArray();
    int[] preLeft=new int[n];
    int[] preRight=new int[n];
    if(str[0]==substr[0])preLeft[0]++;
    for(int i=1 ; i<n ; i++){
      if(str[i]==substr[0])preLeft[i]=preLeft[i-1]+1 ;
      else preLeft[i]=preLeft[i-1];
    }
    if(str[n-1]==substr[2])preRight[n-1]++;
    for(int i=n-2 ; i>=0 ; i--){
      if(str[i]==substr[2])preRight[i]=preRight[i+1]+1 ;
      else preRight[i]=preRight[i+1];
    }
    int counter=0 ;
    for(int i=1 ; i<n-1 ; i++){
      if(str[i]==str[1]){
        int total=preLeft[i-1]*preRight[i+1];
        counter+=total ;
      }
    }
    return counter ;
  }
  public static void main(String argc[]){
    String str="GFGFGYSYIOIWIN" ;
    String substr="GFG" ;
    System.out.println(findOccurrences(str,substr));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation findOccurrences( str1 : String, substr1 : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str1->size() ;
     var str : Sequence(String) ; str := str1->characters() ;
    var substr : Sequence(String) ; substr := substr1->characters() ;
    var preLeft : Sequence(int) ; preLeft := Integer.subrange(1,n)->collect(0) ;
    var preRight : Sequence(int) ; preRight := Integer.subrange(1,n)->collect(0) ;
    if (str[0+1] = substr[0+1]) then     preLeft[0+1] := preLeft[0+1] + 1 ; else skip ; 
        var i : int ; i := 1 ; while i < n do ( (     if (str[i+1] = substr[0+1]) then     preLeft[i+1] := preLeft[i - 1+1] + 1 ; else     preLeft[i+1] := preLeft[i - 1+1] ; )  ;     i := i + 1 ) ; 
    if (str[n - 1+1] = substr[2+1]) then     preRight[n - 1+1] := preRight[n - 1+1] + 1 ; else skip ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (str[i+1] = substr[2+1]) then     preRight[i+1] := preRight[i + 1+1] + 1 ; else     preRight[i+1] := preRight[i + 1+1] ; )  ;     i := i - 1 ) ; 
    var counter : int ; counter := 0 ;
        var i : int ; i := 1 ; while i < n - 1 do ( (     if (str[i+1] = str[1+1]) then (     var total : int ; total := preLeft[i - 1+1] * preRight[i + 1+1] ;
     counter := counter+(total) ) else skip )  ;     i := i + 1 ) ; 
    return counter 
 );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GFGFGYSYIOIWIN" ;
     var substr : String ; substr := "GFG" ;
     OclFile["System.out"].println(findOccurrences(str, substr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = br.readLine();
        ArrayDeque<Integer> left = new ArrayDeque<>();
        ArrayDeque<Integer> areaLeft = new ArrayDeque<>();
        ArrayDeque<Integer> area = new ArrayDeque<>();
        for (int i = 0; i < s.length(); ++i) {
            char c = s.charAt(i);
            if (c == '\\') {
                left.addFirst(i);
            } else if (c == '/') {
                if (!left.isEmpty()) {
                    int l = left.removeFirst();
                    areaLeft.addFirst(l);
                    area.addFirst(i - l);
                }
            }
        }
        int lastl = s.length();
        while (!areaLeft.isEmpty()) {
            int l = areaLeft.removeFirst();
            if (l > lastl) {
                area.addLast(area.removeFirst() + area.removeLast());
            } else {
                area.addLast(area.removeFirst());
                lastl = l;
            }
        }
        StringBuilder sb = new StringBuilder();
        int sum = 0;
        for (Integer i : area) {
            sum += i;
            sb.insert(0, " " + i);
        }
        sb.insert(0, area.size());
        System.out.println(sum);
        System.out.println(sb);
    }
}

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := br.readLine() ;
    var left : Sequence(int) ; left := ArrayDeque<OclAny>.newArrayDeque() ;
    var areaLeft : Sequence(int) ; areaLeft := ArrayDeque<OclAny>.newArrayDeque() ;
    var area : Sequence(int) ; area := ArrayDeque<OclAny>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var c : String ; c := s->at(i+1) ;
     if (c = '\\') then (     left := left->prepend(i) ) else     if (c = '/') then (     if (not(left->isEmpty())) then (     var l : int ; l := left->first() ;
     areaLeft := areaLeft->prepend(l) ; 
     area := area->prepend(i - (l)->char2byte()) ) else skip ) else skip ; )  ;     i := i + 1 ) ; 
    var lastl : int ; lastl := s->size() ;
    while (not(areaLeft->isEmpty())) do (     var l : int ; l := areaLeft->first() ;
     if (l > lastl) then (     area := area->append(area->first() + area->last()) ) else (     area := area->append(area->first()) ; 
     lastl := l ) ) ; 
    var sb : String ; sb := StringLib.newString() ;
    var sum : int ; sum := 0 ;
    for (i : area) do ( (     sum := sum+(i) ; 
     sb := sb.insertAt(0+1, StringLib.newString(" " + i)) )  ) ; 
    sb := sb.insertAt(0+1, StringLib.newString(area->size())) ; 
    OclFile["System.out"].println(sum) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.sql.Array ;
import java.util.*;
public class Hi {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] array1=new int[n];
    HashMap<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<array1.length ; i++)array1[i]=sc.nextInt();
    for(int i=0 ; i<array1.length ; i++)map.put(sc.nextInt(),i);
    int[] time=new int[n];
    for(int i=0 ; i<n ; i++){
      int element=array1[i];
      time[i]=map.get(element)+1 ;
    }
    int[] prefixMax=new int[n];
    prefixMax[0]=time[0];
    for(int i=1 ; i<n ; i++)prefixMax[i]=Math.max(prefixMax[i-1],time[i]);
    int count=0 ;
    for(int i=1 ; i<n ; i++){
      if(time[i]<prefixMax[i-1])count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hi {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var array1 : Sequence(int) ; array1 := Integer.subrange(1,n)->collect(0) ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < array1->size() do (     array1[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < array1->size() do (     map := map->union(Map{sc.getCurrent()->toInteger() |-> i}) ;  ;     i := i + 1 ) ; 
    var time : Sequence(int) ; time := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var element : int ; element := array1[i+1] ;
     time[i+1] := map->at(element) + 1 )  ;     i := i + 1 ) ; 
    var prefixMax : Sequence(int) ; prefixMax := Integer.subrange(1,n)->collect(0) ;
    prefixMax[0+1] := time[0+1] ; 
        var i : int ; i := 1 ; while i < n do (     prefixMax[i+1] := Set{prefixMax[i - 1+1], time[i+1]}->max() ;  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (time[i+1] < prefixMax[i - 1+1]) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cp1 {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int a[]=new int[n];
    int b[]=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=in.nextInt();
    for(int i=0 ; i<n ; i++)b[i]=in.nextInt();
    int i=0,j=0 ;
    int ctr=0 ;
    HashSet<Integer>hs=new HashSet<>();
    while(j<n){
      if(! hs.contains(a[i])){
        if(a[i]==b[j]){
          i++;
          j++;
        }
        else {
          hs.add(b[j]);
          j++;
          ctr++;
        }
      }
      else i++;
    }
    System.out.println(ctr);
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     b[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    var ctr : int ; ctr := 0 ;
    var hs : Set(int) ; hs := Set{} ;
    while (j < n) do (     if (not(hs->includes(a[i+1]))) then (     if (a[i+1] = b[j+1]) then (     i := i + 1 ; 
     j := j + 1 ) else (     hs := hs->including(b[j+1]) ; 
     j := j + 1 ; 
     ctr := ctr + 1 ) ) else     i := i + 1 ; ) ; 
    OclFile["System.out"].println(ctr) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p357 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p357().run());
  }
  private static final int LIMIT=Library.pow(10,8);
  private boolean[] isPrime ;
  public String run(){
    isPrime=Library.listPrimality(LIMIT+1);
    long sum=0 ;
    for(int n=0 ; n<=LIMIT ; n++){
      if(isPrime[n+1] && isPrimeGenerating(n))sum+=n ;
    }
    return Long.toString(sum);
  }
  private boolean isPrimeGenerating(int n){
    for(int i=1,end=Library.sqrt(n); i<=end ; i++){
      if(n % i==0 && ! isPrime[i+n/i])return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p357 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p357.newp357().run()) );
  static    attribute LIMIT : int := Library.pow(10, 8);
   attribute isPrime : Sequence(boolean);
   operation run() : String
  pre: true
  post: true
  activity: (     isPrime := Library.listPrimality(LIMIT + 1) ; 
     var sum : long ; sum := 0 ;
         var n : int ; n := 0 ; while n <= LIMIT do ( (     if (isPrime[n + 1+1] & isPrimeGenerating(n)) then     sum := sum+(n) ; else skip )  ;     n := n + 1 ) ; 
     return ((sum) + "") );
   operation isPrimeGenerating( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ;
    var end : int ; end := Library.sqrt(n) ; while i <= end do ( (     if (n mod i = 0 & not(isPrime[i + n / i+1])) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Tern101 {
  final static int mod=(int)(1e9+7.0);
  final static String endl="\n" ;
  static double startTime,endTime ;
  static Scanner sc=null ;
  static StringBuilder sb=null ;
  static void solution()throws Exception {
    String in=sc.next();
    int countOne=0 ;
    for(int i=0 ; i<in.length(); i++){
      if(in.charAt(i)=='1')countOne++;
    }
    for(int i=0 ; i<in.length(); i++){
      char c=in.charAt(i);
      if(c=='1')continue ;
      if(c=='2' && countOne!=0){
        while(countOne-->0){
          sb.append('1');
        }
        sb.append('2');
      }
      else {
        sb.append(c);
      }
    }
    while(countOne-->0){
      sb.append('1');
    }
  }
  public static void main(String[] args)throws Exception {
    sc=new Scanner(System.in);
    sb=new StringBuilder();
    solution();
    print(sb);
    sc.close();
  }
  static void print(Object s){
    System.out.print(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Tern101 {
  static   attribute mod : int := (1e9 + 7.0)->oclAsType(int);
  static   attribute endl : String := "\n";
  static   attribute startTime : double;
  static   attribute sc : OclFile := null;
  static   attribute sb : String := null;
  static   operation solution() : void
  pre: true
  post: true
  activity: (     var in : String ; in := sc.getCurrent() ;
     var countOne : int ; countOne := 0 ;
        var i : int ; i := 0 ; while i < in->size() do ( (     if (in->at(i+1) = '1') then     countOne := countOne + 1 ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < in->size() do ( (     var c : String ; c := in->at(i+1) ;
     if (c = '1') then     continue else skip ; 
     if (c = '2' & countOne /= 0) then (         while (countOne > 0) do (        countOne := countOne - 1 ;     skip ; (     sb := sb + StringLib.newString('1') ) ;  ) ;  
     sb := sb + StringLib.newString('2') ) else (     sb := sb + StringLib.newString(c) ) )  ;     i := i + 1 ) ; 
        while (countOne > 0) do (        countOne := countOne - 1 ;     skip ; (     sb := sb + StringLib.newString('1') ) ;  ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     sb := StringLib.newString() ; 
    execute solution() ; 
    execute print(sb) ; 
    skip ; 
 );
  static   operation print( s : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] str=sc.next().toCharArray();
    int cnt0=0,cnt1=0 ;
    int idx=str.length ;
    boolean f=true ;
    for(int i=0 ; i<str.length ; i++){
      if(str[i]=='1')cnt1++;
      else if(str[i]=='2'){
        f=false ;
        if(idx==str.length)idx=i ;
      }
      else {
        if(f)cnt0++;
      }
    }
    for(int i=0 ; i<cnt0 ; i++)System.out.print("0");
    for(int i=0 ; i<cnt1 ; i++)System.out.print("1");
    for(int i=idx ; i<str.length ; i++){
      if(str[i]=='1')continue ;
      System.out.print(str[i]);
    }
    System.out.println();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : Sequence(String) ; str := sc.getCurrent()->characters() ;
    var cnt0 : int ; cnt0 := 0 ;
    var cnt1 : int ; cnt1 := 0 ;
    var idx : int ; idx := str->size() ;
    var f : boolean ; f := true ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str[i+1] = '1') then     cnt1 := cnt1 + 1 ; else     if (str[i+1] = '2') then (     f := false ; 
     if (idx = str->size()) then     idx := i ; else skip ) else (     if (f) then     cnt0 := cnt0 + 1 ; else skip ) ;  )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < cnt0 do (     OclFile["System.out"].print("0") ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < cnt1 do (     OclFile["System.out"].print("1") ;  ;     i := i + 1 ) ; 
        var i : int ; i := idx ; while i < str->size() do ( (     if (str[i+1] = '1') then     continue else skip ; 
     OclFile["System.out"].print(str[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    char[] s=in.next().toCharArray();
    int beforgetTwo=-1 ;
    int zero=0 ;
    for(int i=0 ; i<s.length ; i++){
      if(s[i]=='2'){
        beforgetTwo=i ;
        break ;
      }
      if(s[i]=='0')zero++;
    }
    if(beforgetTwo==-1){
      Arrays.sort(s);
      for(char a : s)pw.print(a);
    }
    else {
      for(int i=0 ; i<zero ; i++)pw.print("0");
      int cnt=0 ;
      for(char c : s)if(c=='1')cnt++;
      for(int i=0 ; i<cnt ; i++)pw.print("1");
      for(int i=beforgetTwo ; i<s.length ; i++){
        if(s[i]=='1')continue ;
        pw.print(s[i]);
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : Sequence(String) ; s := in.getCurrent()->characters() ;
    var beforgetTwo : int ; beforgetTwo := -1 ;
    var zero : int ; zero := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s[i+1] = '2') then (     beforgetTwo := i ; 
     break ) else skip ; 
     if (s[i+1] = '0') then     zero := zero + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (beforgetTwo = -1) then (     s := s->sort() ; 
     for (a : s) do (     skip ;  ) ) else (         var i : int ; i := 0 ; while i < zero do (     skip ;  ;     i := i + 1 ) ; 
     var cnt : int ; cnt := 0 ;
    for (c : s) do (     if (c = '1') then     cnt := cnt + 1 ; else skip ;  ) ; 
        var i : int ; i := 0 ; while i < cnt do (     skip ;  ;     i := i + 1 ) ; 
        var i : int ; i := beforgetTwo ; while i < s->size() do ( (     if (s[i+1] = '1') then     continue else skip ; 
     skip )  ;     i := i + 1 ) ; 
 ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int count=0 ;
    int n=s.length();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='1'){
        count++;
      }
      else {
        sb.append(s.charAt(i));
      }
    }
    int x=sb.toString().indexOf('2');
    if(x<0){
      System.out.print(sb.toString());
      for(int i=0 ; i<count ; i++){
        System.out.print('1');
      }
      return ;
    }
    System.out.print(sb.substring(0,x));
    for(int i=0 ; i<count ; i++){
      System.out.print('1');
    }
    System.out.print(sb.substring(x,sb.length()));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var count : int ; count := 0 ;
    var n : int ; n := s->size() ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = '1') then (     count := count + 1 ) else (     sb := sb + StringLib.newString(s->at(i+1)) ) )  ;     i := i + 1 ) ; 
    var x : int ; x := sb+""->indexOf('2')-1 ;
    if (x < 0) then (     OclFile["System.out"].print(sb+"") ; 
         var i : int ; i := 0 ; while i < count do ( (     OclFile["System.out"].print('1') )  ;     i := i + 1 ) ; 
     return ) else skip ; 
    OclFile["System.out"].print(sb.subrange(0+1,x)) ; 
        var i : int ; i := 0 ; while i < count do ( (     OclFile["System.out"].print('1') )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb.subrange(x+1,sb->size())) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    int n=Integer.parseInt(s.split(" ")[0]);
    int d=Integer.parseInt(s.split(" ")[1]);
    int[][] x=new int[n][d];
    for(int i=0 ; i<n ; i++){
      s=sc.nextLine();
      String[] temp=s.split(" ");
      for(int j=0 ; j<d ; j++){
        x[i][j]=Integer.parseInt(temp[j]);
      }
    }
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        double dis=0 ;
        for(int k=0 ; k<d ; k++){
          dis+=(x[i][k]-x[j][k])*(x[i][k]-x[j][k]);
        }
        if(Math.sqrt(dis)==Math.ceil(Math.sqrt(dis))){
          ans++;
        }
      }
    }
    System.out.println(ans);
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var n : int ; n := (s->split(" ")[0+1])->toInteger() ;
    var d : int ; d := (s->split(" ")[1+1])->toInteger() ;
    var x : Sequence(Sequence(int)) ; x := Integer.subrange(1,n)->collect(Integer.subrange(1,d)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     s := sc.nextLine() ; 
     var temp : Sequence(String) ; temp := s->split(" ") ;
         var j : int ; j := 0 ; while j < d do ( (     x[i+1][j+1] := (temp[j+1])->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var dis : double ; dis := 0 ;
         var k : int ; k := 0 ; while k < d do ( (     dis := dis+((x[i+1][k+1] - x[j+1][k+1]) * (x[i+1][k+1] - x[j+1][k+1])) )  ;     k := k + 1 ) ; 
     if ((dis)->sqrt() = ((dis)->sqrt())->ceil()) then (     ans := ans + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double PI=3.1415926535 ;
  static double findAnglesA(double a,double b,double c){
    double A=Math.acos((b*b+c*c-a*a)/(2*b*c));
    return A*180/PI ;
  }
  static double findAnglesB(double a,double b,double c){
    double B=Math.acos((a*a+c*c-b*b)/(2*a*c));
    return B*180/PI ;
  }
  static void printAngles(int a,int b,int c){
    double x=(double)a ;
    double y=(double)b ;
    double z=(double)c ;
    double A=findAnglesA(x,y,z);
    double B=findAnglesB(x,y,z);
    System.out.println("Angles are A="+A+",B="+B+",C="+90);
  }
  static void printOtherSides(int n){
    int b=0,c=0 ;
    if((n & 1)>0){
      if(n==1)System.out.println(-1);
      else {
        b=(n*n-1)/2 ;
        c=(n*n+1)/2 ;
        System.out.println("Side b="+b+",Side c="+c);
      }
    }
    else {
      if(n==2)System.out.println(-1);
      else {
        b=n*n/4-1 ;
        c=n*n/4+1 ;
        System.out.println("Side b="+b+",Side c="+c);
      }
    }
    printAngles(n,b,c);
  }
  public static void main(String[] args){
    int a=12 ;
    printOtherSides(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute PI : double := 3.1415926535;
  static   operation findAnglesA( a : double, b : double, c : double) : double
  pre: true
  post: true
  activity: (     var A : double ; A := ((b * b + c * c - a * a) / (2 * b * c))->acos() ;
     return A * 180 / PI );
  static   operation findAnglesB( a : double, b : double, c : double) : double
  pre: true
  post: true
  activity: (     var B : double ; B := ((a * a + c * c - b * b) / (2 * a * c))->acos() ;
     return B * 180 / PI );
  static   operation printAngles( a : int, b : int, c : int) : void
  pre: true
  post: true
  activity: (     var x : double ; x := a->oclAsType(double) ;
     var y : double ; y := b->oclAsType(double) ;
    var z : double ; z := c->oclAsType(double) ;
    var A : double ; A := findAnglesA(x, y, z) ;
    var B : double ; B := findAnglesB(x, y, z) ;
    OclFile["System.out"].println("Angles are A=" + A + ",B=" + B + ",C=" + 90) ; 
 );
  static   operation printOtherSides( n : int) : void
  pre: true
  post: true
  activity: (     var b : int ; b := 0 ;
    var c : int ; c := 0 ;
     if ((n & 1) > 0) then (     if (n = 1) then     OclFile["System.out"].println(-1) ; else (     b := (n * n - 1) / 2 ; 
     c := (n * n + 1) / 2 ; 
     OclFile["System.out"].println("Side b=" + b + ",Side c=" + c) ) ) else (     if (n = 2) then     OclFile["System.out"].println(-1) ; else (     b := n * n / 4 - 1 ; 
     c := n * n / 4 + 1 ; 
     OclFile["System.out"].println("Side b=" + b + ",Side c=" + c) ) ) ;  
     execute printAngles(n, b, c) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 12 ;
     execute printOtherSides(a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=false ;
  private static PrintWriter _out=new PrintWriter(System.out);
  private static PrintWriter _err=new PrintWriter(System.err);
  private void solve(Scanner sc){
    String s1=sc.next();
    String s2=sc.next();
    String s3=sc.next();
    StringBuilder sb=new StringBuilder();
    sb.append(s1.charAt(0));
    sb.append(s2.charAt(0));
    sb.append(s3.charAt(0));
    _out.println(sb.toString().toUpperCase());
  }
  private static BigInteger C(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    for(long i=r ; i>1 ; --i){
      res=res.divide(BigInteger.valueOf(i));
    }
    return res ;
  }
  private static BigInteger P(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    return res ;
  }
  public static void main(String[] args){
    long S=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    new Main().solve(sc);
    _out.flush();
    long G=System.currentTimeMillis();
    if(elapsed){
      _err.println((G-S)+"ms");
    }
    _err.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := false;
  static   attribute _out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute _err : OclFile := OclFile.newOclFile_Write(OclFile["System.err"]);
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := sc.next() ;
     var s2 : String ; s2 := sc.next() ;
    var s3 : String ; s3 := sc.next() ;
    var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString(s1->at(0+1)) ; 
    sb := sb + StringLib.newString(s2->at(0+1)) ; 
    sb := sb + StringLib.newString(s3->at(0+1)) ; 
    skip ; 
 );
  static   operation C( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
         var i : long ; i := r ; while i > 1 do ( (     res := res.divide((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation P( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    Main.newMain().solve(sc) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findSum(int n){
    int ans=0,temp=0,num ;
    for(int i=1 ; i<=n && temp<n ; i++){
      temp=i-1 ;
      num=1 ;
      while(temp<n){
        if(temp+i<=n)ans+=(i*num);
        else ans+=((n-temp)*num);
        temp+=i ;
        num++;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int N=2 ;
    System.out.println(findSum(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSum( n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
    var temp : int ; temp := 0 ;
    var num : int ;
         var i : int ; i := 1 ; while i <= n & temp < n do ( (     temp := i - 1 ; 
     num := 1 ; 
     while (temp < n) do (     if (temp + i <= n) then     ans := ans+((i * num)) else     ans := ans+(((n - temp) * num)) ; ;  
     temp := temp+(i) ; 
     num := num + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 2 ;
     OclFile["System.out"].println(findSum(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static double printProbability(int L,int n){
    int p=(1<<(n-1));
    return 1.0-((double)n)/((double)p);
  }
  public static void main(String args[]){
    int n=3,L=5 ;
    System.out.println(printProbability(L,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printProbability( L : int, n : int) : double
  pre: true
  post: true
  activity: (     var p : int ; p := ((1*(2->pow((n - 1))))->oclAsType(long)) ;
     return 1.0 - (n->oclAsType(double)) / (p->oclAsType(double)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
    var L : int ; L := 5 ;
     OclFile["System.out"].println(printProbability(L, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Solve s=new Solve();
    s.solve();
  }
}
class Solve {
  Scanner in=new Scanner(System.in);
  void solve(){
    while(in.hasNext()){
      int n=in.nextInt(),s=in.nextInt(),e=in.nextInt();
      if(n==0 && s==0 && e==0)return ;
      int a[]=new int[24*60+100];
      s=toM(s);
      e=toM(e);
      for(int i=0 ; i<n ; i++){
        int t=in.nextInt();
        for(int j=0 ; j<t ; j++){
          int ts=toM(in.nextInt()),te=toM(in.nextInt());
          a[ts]+=1 ;
          a[te]-=1 ;
        }
      }
      for(int i=1 ; i<24*60+100 ; i++){
        a[i]+=a[i-1];
      }
      int ans=0 ;
      for(int i=s ; i<e ; i++){
        if(a[i]==n)a[i]=0 ;
        else a[i]=a[i>0 ? i-1 : 0]+1 ;
        ans=Math.max(ans,a[i]);
      }
      System.out.println(ans);
    }
  }
  int toM(int h){
    return(h/100)*60+h % 100 ;
  }
  int toH(int m){
    return m/60*100+m % 60 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Solve ; s := Solve.newSolve() ;
     s.solve() );
}
class Solve {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation solve() : void
  pre: true
  post: true
  activity: (     while (in.hasNext()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : int ; s := in.getCurrent()->toInteger() ;
    var e : int ; e := in.getCurrent()->toInteger() ;
     if (n = 0 & s = 0 & e = 0) then     return else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,24 * 60 + 100)->collect(0) ;
    s := toM(s) ; 
    e := toM(e) ; 
        var i : int ; i := 0 ; while i < n do ( (     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var ts : int ; ts := toM(in.getCurrent()->toInteger()) ;
    var te : int ; te := toM(in.getCurrent()->toInteger()) ;
     a[ts+1] := a[ts+1]+(1) ; 
     a[te+1] := a[te+1]-(1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < 24 * 60 + 100 do ( (     a[i+1] := a[i+1]+(a[i - 1+1]) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := s ; while i < e do ( (     if (a[i+1] = n) then     a[i+1] := 0 else     a[i+1] := a[if i > 0 then i - 1 else 0 endif+1] + 1 ; ;  
     ans := Set{ans, a[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
   operation toM( h : int) : int
  pre: true
  post: true
  activity: (     return (h / 100) * 60 + h mod 100 );
   operation toH( m : int) : int
  pre: true
  post: true
  activity: (     return m / 60 * 100 + m mod 60 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static class R implements Comparable<R>{
    public int s ;
    public int t ;
    public R(int s,int t){
      this.s=s ;
      this.t=t ;
    }
    public int compareTo(R o){
      return s-o.s ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      int p=sc.nextInt();
      int q=sc.nextInt();
      p=(p/100)*60+p % 100 ;
      q=(q/100)*60+q % 100 ;
      if(n==0 && p==0 && q==0)break ;
      PriorityQueue<R>pq=new PriorityQueue<R>();
      for(int i=0 ; i<n ; i++){
        int k=sc.nextInt();
        int last=0 ;
        for(int j=0 ; j<k ; j++){
          int s=sc.nextInt();
          int t=sc.nextInt();
          s=(s/100)*60+s % 100 ;
          t=(t/100)*60+t % 100 ;
          if(j==0){
            pq.add(new R(p,s));
            last=t ;
          }
          else {
            pq.add(new R(last,s));
            last=t ;
          }
          if(j==k-1){
            pq.add(new R(last,q));
          }
        }
      }
      int max=0 ;
      R r=null ;
      while(! pq.isEmpty()){
        R a=pq.poll();
        if(r==null){
          r=a ;
        }
        else if(r.s<=a.s && a.s<=r.t){
          r.t=Math.max(r.t,a.t);
        }
        else {
          r=a ;
        }
        max=Math.max(max,r.t-r.s);
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class R implements Comparable<R> {
   attribute s : int;
   attribute t : int;
   static operation newR( s : int, t : int) : R
  pre: true
  post: true
  activity:
  ( var self : R ;
    self := createR();
    self.initialise(s, t);
    return self );
  operation initialise( s : int, t : int) : void
  pre: true  post: true
  activity: (     self.s := s ; 
     self.t := t );
   operation compareTo( o : R) : int
  pre: true
  post: true
  activity: (     return s - o.s );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var p : int ; p := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    p := (p / 100) * 60 + p mod 100 ; 
    q := (q / 100) * 60 + q mod 100 ; 
    if (n = 0 & p = 0 & q = 0) then     break else skip ; 
    var pq : Sequence(R) ; pq := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var k : int ; k := sc.getCurrent()->toInteger() ;
     var last : int ; last := 0 ;
         var j : int ; j := 0 ; while j < k do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    s := (s / 100) * 60 + s mod 100 ; 
    t := (t / 100) * 60 + t mod 100 ; 
    if (j = 0) then (     pq := pq->including(R.newR(p, s)) ; 
     last := t ) else (     pq := pq->including(R.newR(last, s)) ; 
     last := t ) ;  
    if (j = k - 1) then (     pq := pq->including(R.newR(last, q)) ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var r : R ; r := null ;
    while (not(pq->isEmpty())) do (     var a : R ; a := pq->min() ;
     if (r = null) then (     r := a ) else     if (r.s <= a.s & a.s <= r.t) then (     r.t := Set{r.t, a.t}->max() ) else (     r := a ) ;  ;  
     max := Set{max, r.t - r.s}->max() ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args)throws Exception {
    while(true){
      int N=sc.nextInt();
      int P=sc.nextInt();
      int Q=sc.nextInt();
      if(N==0)break ;
      int start=toMin(P);
      int end=toMin(Q);
      int[] cm=new int[end-start+1];
      for(int i=0 ; i<N ; ++i){
        int K=sc.nextInt();
        for(int j=0 ; j<K ; ++j){
          int cms=toMin(sc.nextInt());
          int cme=toMin(sc.nextInt());
          for(int l=Math.max(cms,start); l<Math.min(cme,end); ++l){
++cm[l-start];
          }
        }
      }
      cm[end-start]=N ;
      int ans=0 ;
      int prev=-1 ;
      for(int i=start ; i<=end ; ++i){
        if(cm[i-start]==N){
          if(prev!=-1){
            ans=Math.max(ans,i-prev);
            prev=-1 ;
          }
        }
        else {
          if(prev==-1)prev=i ;
        }
      }
      System.out.println(ans);
    }
  }
  static int toMin(int hourmin){
    return hourmin/100*60+hourmin % 100 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var P : int ; P := sc.getCurrent()->toInteger() ;
    var Q : int ; Q := sc.getCurrent()->toInteger() ;
    if (N = 0) then     break else skip ; 
    var start : int ; start := toMin(P) ;
    var end : int ; end := toMin(Q) ;
    var cm : Sequence(int) ; cm := Integer.subrange(1,end - start + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     var K : int ; K := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < K do ( (     var cms : int ; cms := toMin(sc.getCurrent()->toInteger()) ;
     var cme : int ; cme := toMin(sc.getCurrent()->toInteger()) ;
         var l : int ; l := Set{cms, start}->max() ; while l < Set{cme, end}->min() do ( (     cm[l - start+1] := cm[l - start+1] + 1 )  ;     l := l + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    cm[end - start+1] := N ; 
    var ans : int ; ans := 0 ;
    var prev : int ; prev := -1 ;
        var i : int ; i := start ; while i <= end do ( (     if (cm[i - start+1] = N) then (     if (prev /= -1) then (     ans := Set{ans, i - prev}->max() ; 
     prev := -1 ) else skip ) else (     if (prev = -1) then     prev := i ; else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation toMin( hourmin : int) : int
  pre: true
  post: true
  activity: (     return hourmin / 100 * 60 + hourmin mod 100 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      final int n=sc.nextInt();
      final int p=sc.nextInt();
      final int q=sc.nextInt();
      if(n==0 && p==0 && q==0){
        break ;
      }
      final int start_min=p/100*60+p % 100 ;
      final int end_min=q/100*60+q % 100 ;
      final int size=end_min-start_min ;
      int[] interval=new int[size];
      for(int i=0 ; i<n ; i++){
        final int k=sc.nextInt();
        for(int j=0 ; j<k ; j++){
          final int c_p=sc.nextInt();
          final int c_e=sc.nextInt();
          final int c_start=(c_p/100*60+c_p % 100)-start_min ;
          final int c_end=(c_e/100*60+c_e % 100)-start_min ;
          interval[c_start]++;
          if(c_end<size){
            interval[c_end]--;
          }
        }
      }
      for(int t=1 ; t<size ; t++){
        interval[t]+=interval[t-1];
      }
      int cur=0 ;
      int max=0 ;
      for(int i=0 ; i<size ; i++){
        if(interval[i]!=n){
          cur++;
        }
        else {
          max=Math.max(max,cur);
          cur=0 ;
        }
      }
      max=Math.max(max,cur);
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var p : int ; p := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    if (n = 0 & p = 0 & q = 0) then (     break ) else skip ; 
    var start_min : int ; start_min := p / 100 * 60 + p mod 100 ;
    var end_min : int ; end_min := q / 100 * 60 + q mod 100 ;
    var size : int ; size := end_min - start_min ;
    var interval : Sequence(int) ; interval := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var k : int ; k := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < k do ( (     var c_p : int ; c_p := sc.getCurrent()->toInteger() ;
     var c_e : int ; c_e := sc.getCurrent()->toInteger() ;
    var c_start : int ; c_start := (c_p / 100 * 60 + c_p mod 100) - start_min ;
    var c_end : int ; c_end := (c_e / 100 * 60 + c_e mod 100) - start_min ;
    interval[c_start+1] := interval[c_start+1] + 1 ; 
    if (c_end < size) then (     interval[c_end+1] := interval[c_end+1] - 1 ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var t : int ; t := 1 ; while t < size do ( (     interval[t+1] := interval[t+1]+(interval[t - 1+1]) )  ;     t := t + 1 ) ; 
    var cur : int ; cur := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < size do ( (     if (interval[i+1] /= n) then (     cur := cur + 1 ) else (     max := Set{max, cur}->max() ; 
     cur := 0 ) )  ;     i := i + 1 ) ; 
    max := Set{max, cur}->max() ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
class Main {
  static int toInt(int hour,int minute){
    return hour*60+minute ;
  }
  public static void main(final String[] args){
    final Scanner stdin=new Scanner(System.in);
    while(true){
      final int n=stdin.nextInt();
      final int p=stdin.nextInt();
      final int q=stdin.nextInt();
      if(n==0 && p==0 && q==0){
        break ;
      }
      final int from=toInt(p/100,p % 100);
      final int to=toInt(q/100,q % 100);
      boolean[][] coms=new boolean[n][to-from];
      for(int i=0 ; i<n ; i++){
        final int m=stdin.nextInt();
        for(int j=0 ; j<m ; j++){
          final int mp=stdin.nextInt();
          final int fm=toInt(mp/100,mp % 100);
          final int mq=stdin.nextInt();
          final int t=toInt(mq/100,mq % 100);
          Arrays.fill(coms[i],fm-from,t-from,true);
        }
      }
      int count=0 ;
      int maxCount=0 ;
      for(int i=0 ; i<to-from ; i++){
        boolean flag=false ;
        for(int j=0 ; j<n ; j++){
          flag |=! coms[j][i];
        }
        if(flag){
          count++;
          maxCount=max(maxCount,count);
        }
        else {
          count=0 ;
        }
      }
      System.out.println(maxCount);
    }
  }
  static void printMap(boolean[][] array){
    for(boolean[] ar : array){
      System.err.println(Arrays.toString(ar));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation toInt( hour : int, minute : int) : int
  pre: true
  post: true
  activity: (     return hour * 60 + minute );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := stdin.getCurrent()->toInteger() ;
     var p : int ; p := stdin.getCurrent()->toInteger() ;
    var q : int ; q := stdin.getCurrent()->toInteger() ;
    if (n = 0 & p = 0 & q = 0) then (     break ) else skip ; 
    var from : int ; from := toInt(p / 100, p mod 100) ;
    var to : int ; to := toInt(q / 100, q mod 100) ;
    var coms : Sequence(Sequence(boolean)) ; coms := Integer.subrange(1,n)->collect(Integer.subrange(1,to - from)->collect(false)) ;
        var i : int ; i := 0 ; while i < n do ( (     var m : int ; m := stdin.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < m do ( (     var mp : int ; mp := stdin.getCurrent()->toInteger() ;
     var fm : int ; fm := toInt(mp / 100, mp mod 100) ;
    var mq : int ; mq := stdin.getCurrent()->toInteger() ;
    var t : int ; t := toInt(mq / 100, mq mod 100) ;
    coms[i+1] := coms[i+1]->collect(true) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var maxCount : int ; maxCount := 0 ;
        var i : int ; i := 0 ; while i < to - from do ( (     var flag : boolean ; flag := false ;
         var j : int ; j := 0 ; while j < n do ( (     flag := MathLib.bitwiseOr(flag, not(coms[j+1][i+1])) )  ;     j := j + 1 ) ; 
     if (flag) then (     count := count + 1 ; 
     maxCount := Set{maxCount, count}->max() ) else (     count := 0 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(maxCount) ; 
 ) );
  static   operation printMap( array : Sequence(Sequence(boolean))) : void
  pre: true
  post: true
  activity: (     for (ar : array) do ( (     OclFile["System.err"].println((ar + "")) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.Stream ;
class Main {
  private static void solve(int n,int d,int[][] x){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        long distance=0 ;
        for(int k=0 ; k<d ; k++){
          int diff=Math.abs(x[i][k]-x[j][k]);
          distance+=diff*diff ;
        }
        double sqrt=Math.sqrt((double)distance);
        if(Math.floor(sqrt)==sqrt)count++;
      }
    }
    System.out.println(count);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String[] num=sc.nextLine().split(" ");
    int n=Integer.parseInt(num[0]);
    int d=Integer.parseInt(num[1]);
    int[][] x=new int[n][d];
    for(int i=0 ; i<n ; i++){
      String[] xi=sc.nextLine().split(" ");
      for(int j=0 ; j<d ; j++)x[i][j]=Integer.parseInt(xi[j]);
    }
    solve(n,d,x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( n : int, d : int, x : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     var distance : long ; distance := 0 ;
         var k : int ; k := 0 ; while k < d do ( (     var diff : int ; diff := if x[i+1][k+1] - x[j+1][k+1] < 0 then -(x[i+1][k+1] - x[j+1][k+1]) else x[i+1][k+1] - x[j+1][k+1] endif ;
     distance := distance+(diff * diff) )  ;     k := k + 1 ) ; 
     var sqrt : double ; sqrt := (distance->oclAsType(double))->sqrt() ;
     if ((sqrt)->floor() = sqrt) then     count := count + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : Sequence(String) ; num := sc.nextLine()->split(" ") ;
    var n : int ; n := (num[0+1])->toInteger() ;
    var d : int ; d := (num[1+1])->toInteger() ;
    var x : Sequence(Sequence(int)) ; x := Integer.subrange(1,n)->collect(Integer.subrange(1,d)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var xi : Sequence(String) ; xi := sc.nextLine()->split(" ") ;
         var j : int ; j := 0 ; while j < d do (     x[i+1][j+1] := (xi[j+1])->toInteger() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    execute solve(n, d, x) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static char[][] c={
    {
      '.',',','!','?',' ' },{
        'a','b','c' },{
          'd','e','f' },{
            'g','h','i' },{
              'j','k','l' },{
                'm','n','o' },{
                  'p','q','r','s' },{
                    't','u','v' },{
                      'w','x','y','z' }
                    };
                    static void solve(){
                      String s=in.next();
                      int pos=0 ;
                      String ans="" ;
                      while(pos<s.length()){
                        int id=s.charAt(pos)-'0'-1 ;
                        if(id==-1){
                          pos++;
                          continue ;
                        }
                        int cnt=0 ;
                        while(s.charAt(pos)!='0'){
                          pos++;
                          cnt=(cnt+1)% c[id] .length ;
                        }
                        ans+=c[id][(cnt+c[id] .length-1)% c[id] .length];
                      }
                      out.println(ans);
                    }
                    public static void main(String[] args){
                      long start=System.currentTimeMillis();
                      int n=in.nextInt();
                      while(n-->0)solve();
                      out.flush();
                      long end=System.currentTimeMillis();
                      in.close();
                      out.close();
                    }
                    static void trace(Object...o){
                      System.out.println(Arrays.deepToString(o));
                    }
                  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute c : Sequence(Sequence(String)) := Sequence{Sequence{'.',',','!','?',' '},Sequence{'a','b','c'},Sequence{'d','e','f'},Sequence{'g','h','i'},Sequence{'j','k','l'},Sequence{'m','n','o'},Sequence{'p','q','r','s'},Sequence{'t','u','v'},Sequence{'w','x','y','z'}};
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.getCurrent() ;
     var pos : int ; pos := 0 ;
    var ans : String ; ans := "" ;
    while (pos < s->size()) do (     var id : int ; id := s->at(pos+1) - ('0')->char2byte() - 1 ;
     if (id = -1) then (     pos := pos + 1 ; 
     continue ) else skip ; 
    var cnt : int ; cnt := 0 ;
    while (s->at(pos+1) /= '0') do (     pos := pos + 1 ; 
     cnt := (cnt + 1) mod c[id+1]->size() ) ; 
    ans := ans+(c[id+1][(cnt + c[id+1]->size() - 1) mod c[id+1]->size()+1]) ; 
 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : long ; start := OclDate.getSystemTime() ;
     var n : int ; n := in.getCurrent()->toInteger() ;
        while (n > 0) do (        n := n - 1 ;     skip ;     execute solve() ; ;  ) ;  
    skip ; 
    var end : long ; end := OclDate.getSystemTime() ;
    skip ; 
    skip ; 
 );
  static   operation trace( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.util.InputMismatchException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      String[] s=in.nextStringArray(3);
      String ans="" ;
      for(int i=0 ; i<3 ; i++){
        ans+=s[i] .charAt(0);
      }
      out.println(ans.toUpperCase());
    }
  }
  static class InputReader {
    BufferedReader in ;
    StringTokenizer tok ;
    public String nextString(){
      while(! tok.hasMoreTokens()){
        try {
          tok=new StringTokenizer(in.readLine()," ");
        }
        catch(IOException e){
          throw new InputMismatchException();
        }
      }
      return tok.nextToken();
    }
    public String[] nextStringArray(int n){
      String[] res=new String[n];
      for(int i=0 ; i<n ; i++){
        res[i]=nextString();
      }
      return res ;
    }
    public InputReader(InputStream inputStream){
      in=new BufferedReader(new InputStreamReader(inputStream));
      tok=new StringTokenizer("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := in.nextStringArray(3) ;
     var ans : String ; ans := "" ;
         var i : int ; i := 0 ; while i < 3 do ( (     ans := ans+(s[i+1]->at(0+1)) )  ;     i := i + 1 ) ; 
     skip );
}
  static class InputReader {
   attribute in : OclFile;
   attribute tok : OclIterator;
   operation nextString() : String
  pre: true
  post: true
  activity: (     while (not(tok.hasNext())) do (     try (     tok := OclIterator.newOclIterator_String_String(in.readLine(), " ") )   catch (e : IOException) do (     error IncorrectElementException() )
 ) ; 
     return tok.next() );
   operation nextStringArray( n : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var res : Sequence(String) ; res := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := nextString() )  ;     i := i + 1 ) ; 
     return res );
   static operation newInputReader( inputStream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) ; 
     tok := OclIterator.newOclIterator_String("") );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] arg){
    int MOD=1000000007 ;
    int N=sc.nextInt();
    int W=sc.nextInt();
    int[] w=new int[N+1];
    for(int i=0 ; i<N ; ++i){
      w[i]=sc.nextInt();
    }
    w[N]=1<<30 ;
    Arrays.sort(w);
    long ans=0 ;
    int sum=0 ;
    int[] dp=new int[W+1];
    for(int i=0 ; i<=N && sum<=W ; ++i){
      Arrays.fill(dp,0);
      dp[sum]=1 ;
      for(int j=i+1 ; j<N ; ++j){
        for(int k=W ; k-w[j]>=0 ; --k){
          dp[k]+=dp[k-w[j] ];
          if(dp[k]>=MOD)dp[k]-=MOD ;
        }
      }
      for(int j=W ; j+w[i]>W && j>=0 ; --j){
        ans+=dp[j];
      }
      sum+=w[i];
    }
    System.out.println(ans % MOD);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var MOD : int ; MOD := 1000000007 ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var w : Sequence(int) ; w := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     w[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    w[N+1] := (1*(2->pow(30)))->oclAsType(long) ; 
    w := w->sort() ; 
    var ans : long ; ans := 0 ;
    var sum : int ; sum := 0 ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,W + 1)->collect(0) ;
        var i : int ; i := 0 ; while i <= N & sum <= W do ( (     dp := dp->collect(0) ; 
     dp[sum+1] := 1 ; 
        var j : int ; j := i + 1 ; while j < N do ( (         var k : int ; k := W ; while k - w[j+1] >= 0 do ( (     dp[k+1] := dp[k+1]+(dp[k - w[j+1]+1]) ; 
     if (dp[k+1] >= MOD) then     dp[k+1] := dp[k+1]-(MOD) ; else skip )  ;     k := k - 1 ) )  ;     j := j + 1 ) ; 
        var j : int ; j := W ; while j + w[i+1] > W & j >= 0 do ( (     ans := ans+(dp[j+1]) )  ;     j := j - 1 ) ; 
    sum := sum+(w[i+1]) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans mod MOD) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
class Piece {
  int h,w ;
  public Piece(int w,int h){
    this.h=h ;
    this.w=w ;
  }
  int area(){
    return h*w ;
  }
  @ Override public String toString(){
    return "[("+w+","+h+"),"+area()+"] " ;
  }
}
public class Main {
  public static void main(String[] $){
    Scanner s=new Scanner(System.in);
    ArrayList<Piece>l=new ArrayList<>();
    while(true){
      l.clear();
      int cut=s.nextInt();
      {
        Piece p=new Piece(s.nextInt(),s.nextInt());
        if(p.w==0)return ;
        l.add(p);
      }
      for(int c=0 ; c<cut ; ++c){
        Piece p=l.remove(s.nextInt()-1),a,b ;
        int w=p.w,h=p.h,k=s.nextInt()%(h*2+w*2);
        if(k<w ||(w+h<k && k<w*2+h)){
          k %=w+h ;
          a=new Piece(k,h);
          b=new Piece(w-k,h);
        }
        else {
          k %=w+h ;
          k-=w ;
          a=new Piece(w,k);
          b=new Piece(w,h-k);
        }
        if(a.area()>b.area()){
          Piece t=a ;
          a=b ;
          b=t ;
        }
        l.add(a);
        l.add(b);
      }
      System.out.println(l.stream().mapToInt(Piece :: area).filter(o->o>0).sorted().mapToObj(String :: valueOf).collect(Collectors.joining(" ")));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Piece {
   attribute h : int;
   static operation newPiece( w : int, h : int) : Piece
  pre: true
  post: true
  activity:
  ( var self : Piece ;
    self := createPiece();
    self.initialise(w, h);
    return self );
  operation initialise( w : int, h : int) : void
  pre: true  post: true
  activity: (     self.h := h ; 
     self.w := w );
   operation area() : int
  pre: true
  post: true
  activity: (     return h * w );
      operation toString() : String
  pre: true
  post: true
  activity: (     return "[(" + w + "," + h + ")," + area() + "] " );
}
class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : Sequence(Piece) ; l := Sequence{} ;
     while (true) do (     l := l->intersection(Set{}) ; 
     var cut : int ; cut := s.getCurrent()->toInteger() ;
(     var p : Piece ; p := Piece.newPiece(s.getCurrent()->toInteger(), s.getCurrent()->toInteger()) ;
     if (p.w = 0) then     return else skip ; 
     l := l->including(p) ) 
        var c : int ; c := 0 ; while c < cut do ( (     var p : Piece ; p := l->includes(s.getCurrent()->toInteger() - 1) ;
    var a : Piece ;
    var b : Piece ;
     var w : int ; w := p.w ;
    var h : int ; h := p.h ;
    var k : int ; k := s.getCurrent()->toInteger() mod (h * 2 + w * 2) ;
    if (k < w or (w + h < k & k < w * 2 + h)) then (     k := k mod w + h ; 
     a := Piece.newPiece(k, h) ; 
     b := Piece.newPiece(w - k, h) ) else (     k := k mod w + h ; 
     k := k-(w) ; 
     a := Piece.newPiece(w, k) ; 
     b := Piece.newPiece(w, h - k) ) ;  
    if (a.area() > b.area()) then (     var t : Piece ; t := a ;
     a := b ; 
     b := t ) else skip ; 
    l := l->including(a) ; 
    l := l->including(b) ; 
 )  ;     c := c + 1 ) ; 
    OclFile["System.out"].println(l->collect( _x1 | (lambda _pars : OclAny in Piece.newPiece().area(_pars))->apply(_x1) )->select( _x1 | (lambda o : OclAny in o > 0)->apply(_x1) )->sort().mapToObj(lambda _pars : OclAny in String.newString().valueOf(_pars)).collect(Collectors.joining(" "))) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void SieveOfEratosthenes(boolean prime[],int p_size){
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<=p_size ; p++){
      if(prime[p]){
        for(int i=p*2 ; i<p_size ; i+=p){
          prime[i]=false ;
        }
      }
    }
  }
  static void sumProdOfPrimeFreq(char[] s){
    boolean[] prime=new boolean[s.length+1];
    Arrays.fill(prime,true);
    SieveOfEratosthenes(prime,s.length+1);
    int i,j ;
    Map<Character,Integer>mp=new HashMap<>();
    for(i=0 ; i<s.length ; i++){
      mp.put(s[i],mp.get(s[i])==null ? 1 : mp.get(s[i])+1);
    }
    int sum=0,product=1 ;
    for(Map.Entry<Character,Integer>it : mp.entrySet()){
      if(prime[it.getValue()]){
        sum+=it.getValue();
        product*=it.getValue();
      }
    }
    System.out.print("Sum="+sum);
    System.out.println("\nProduct="+product);
  }
  public static void main(String[] args){
    String s="geeksforgeeks" ;
    sumProdOfPrimeFreq(s.toCharArray());
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation SieveOfEratosthenes( prime : Sequence(boolean), p_size : int) : void
  pre: true
  post: true
  activity: (     prime[0+1] := false ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p <= p_size do ( (     if (prime[p+1]) then (         var i : int ; i := p * 2 ; while i < p_size do ( (     prime[i+1] := false )  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation sumProdOfPrimeFreq( s : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,s->size() + 1)->collect(false) ;
     prime := prime->collect(true) ; 
    execute SieveOfEratosthenes(prime, s->size() + 1) ; 
    var i : int ;
    var j : int ;
    var mp : Map(String,int) ; mp := Map{} ;
        i := 0 ; while i < s->size() do ( (     mp := mp->union(Map{s[i+1] |-> if mp->at(s[i+1]) = null then 1 else mp->at(s[i+1]) + 1 endif}) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var product : int ; product := 1 ;
    for (it : mp->asSet()) do ( (     if (prime[it.getValue()+1]) then (     sum := sum+(it.getValue()) ; 
     product := product*(it.getValue()) ) else skip )  ) ; 
    OclFile["System.out"].print("Sum=" + sum) ; 
    OclFile["System.out"].println("\nProduct=" + product) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     execute sumProdOfPrimeFreq(s->characters()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
class GFG {
  static int subset(int arr[],int n){
    HashMap<Integer,Integer>mp=new HashMap<>();
    for(int i=0 ; i<n ; i++)mp.put(arr[i],mp.get(arr[i])==null ? 1 : mp.get(arr[i])+1);
    int res=0 ;
    for(Map.Entry<Integer,Integer>entry : mp.entrySet())res=Math.max(res,entry.getValue());
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      5,6,9,3,4,3,4 };
      int n=arr.length ;
      System.out.println(subset(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation subset( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do (     mp := mp->union(Map{arr[i+1] |-> if mp->at(arr[i+1]) = null then 1 else mp->at(arr[i+1]) + 1 endif}) ;  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    for (entry : mp->asSet()) do (     res := Set{res, entry.getValue()}->max() ;  ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,6,9,3,4,3,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(subset(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int GCD(int a,int b){
    if(b==0)return a ;
    return GCD(b,a % b);
  }
  static int findMaxSumUtil(int arr[],int n){
    int finalGCD=arr[0];
    for(int i=1 ; i<n ; i++)finalGCD=GCD(arr[i],finalGCD);
    return finalGCD ;
  }
  static int findMaxSum(int arr[],int n){
    int maxElement=findMaxSumUtil(arr,n);
    return(maxElement*n);
  }
  public static void main(String[] args){
    int arr[]={
      8,20,12,36 };
      int n=arr.length ;
      System.out.println(findMaxSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation GCD( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return GCD(b, a mod b) );
  static   operation findMaxSumUtil( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var finalGCD : int ; finalGCD := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do (     finalGCD := GCD(arr[i+1], finalGCD) ;  ;     i := i + 1 ) ; 
     return finalGCD );
  static   operation findMaxSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var maxElement : int ; maxElement := findMaxSumUtil(arr, n) ;
     return (maxElement * n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,20,12,36} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMaxSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static class Node {
    int data ;
    Node next ;
    Node(int data){
      this.data=data ;
    }
  }
  static Node modularNode(Node head,int k){
    if(k<=0 || head==null)return null ;
    int i=1 ;
    Node modularNode=null ;
    for(Node temp=head ; temp!=null ; temp=temp.next){
      if(i % k==0)modularNode=temp ;
      i++;
    }
    return modularNode ;
  }
  public static void main(String[] args){
    Node head=new Node(1);
    head.next=new Node(2);
    head.next.next=new Node(3);
    head.next.next.next=new Node(4);
    head.next.next.next.next=new Node(5);
    int k=2 ;
    Node answer=modularNode(head,k);
    System.out.print("Modular node is ");
    if(answer!=null)System.out.println(answer.data);
    else System.out.println("null");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
   static operation newNode( data : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(data);
    return self );
  operation initialise( data : int) : void
  pre: true  post: true
  activity: (     self.data := data );
}
  static   operation modularNode( head : Node, k : int) : Node
  pre: true
  post: true
  activity: (     if (k <= 0 or head = null) then     return null else skip ; 
     var i : int ; i := 1 ;
    var modularNode : Node ; modularNode := null ;
        var temp : Node ; temp := head ; while temp /= null do ( (     if (i mod k = 0) then     modularNode := temp ; else skip ; 
     i := i + 1 )  ;     temp := temp.next ) ; 
    return modularNode 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := Node.newNode(1) ;
     head.next := Node.newNode(2) ; 
    head.next.next := Node.newNode(3) ; 
    head.next.next.next := Node.newNode(4) ; 
    head.next.next.next.next := Node.newNode(5) ; 
    var k : int ; k := 2 ;
    var answer : Node ; answer := modularNode(head, k) ;
    OclFile["System.out"].print("Modular node is ") ; 
    if (answer /= null) then     OclFile["System.out"].println(answer.data) else     OclFile["System.out"].println("null") ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countSol(int coeff[],int start,int end,int rhs){
    if(rhs==0)return 1 ;
    int result=0 ;
    for(int i=start ; i<=end ; i++)if(coeff[i]<=rhs)result+=countSol(coeff,i,end,rhs-coeff[i]);
    return result ;
  }
  public static void main(String[] args){
    int coeff[]={
      2,2,5 };
      int rhs=4 ;
      int n=coeff.length ;
      System.out.println(countSol(coeff,0,n-1,rhs));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSol( coeff : Sequence(int), start : int, end : int, rhs : int) : int
  pre: true
  post: true
  activity: (     if (rhs = 0) then     return 1 else skip ; 
     var result : int ; result := 0 ;
         var i : int ; i := start ; while i <= end do (     if (coeff[i+1] <= rhs) then     result := result+(countSol(coeff, i, end, rhs - coeff[i+1])) ; else skip ;  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var coeff : Sequence(int) ; coeff := Sequence{2,2,5} ;
     var rhs : int ; rhs := 4 ;
     var n : int ; n := coeff->size() ;
     OclFile["System.out"].println(countSol(coeff, 0, n - 1, rhs)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Garden {
  public static void main(String[] args){
    Scanner iScanner=new Scanner(System.in);
    int n=iScanner.nextInt();
    int len=iScanner.nextInt();
    int[] buckets=new int[n];
    for(int i=0 ; i<n ; i++){
      buckets[i]=iScanner.nextInt();
    }
    int count=0 ;
    Arrays.sort(buckets);
    while(n>0){
      if(len % buckets[n-1]==0){
        count=len/buckets[n-1];
        break ;
      }
      n--;
    }
    System.out.println(count);
    iScanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Garden {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var iScanner : OclFile ; iScanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := iScanner.getCurrent()->toInteger() ;
    var len : int ; len := iScanner.getCurrent()->toInteger() ;
    var buckets : Sequence(int) ; buckets := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     buckets[i+1] := iScanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    buckets := buckets->sort() ; 
    while (n > 0) do (     if (len mod buckets[n - 1+1] = 0) then (     count := len / buckets[n - 1+1] ; 
     break ) else skip ; 
     n := n - 1 ) ; 
    OclFile["System.out"].println(count) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] arg){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] arr=new int[n];
    int max=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      if(k % arr[i]==0 && arr[i]>max)max=arr[i];
    }
    System.out.println(k/max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (k mod arr[i+1] = 0 & arr[i+1] > max) then     max := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(k / max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Objects ;
import java.util.Scanner ;
import java.util.stream.Stream ;
public class Main {
  public static void main(final String[] args)throws Exception {
    final Scanner sc=new Scanner(System.in);
    final String s1=sc.next();
    final String s2=sc.next();
    final String s3=sc.next();
    StringBuffer result=new StringBuffer().append(s1.charAt(0)).append(s2.charAt(0)).append(s3.charAt(0));
    System.out.println(result.toString().toUpperCase());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := sc.getCurrent() ;
    var s2 : String ; s2 := sc.getCurrent() ;
    var s3 : String ; s3 := sc.getCurrent() ;
    var result : String ; result := StringLib.newString() + StringLib.newString(s1->at(0+1)) + StringLib.newString(s2->at(0+1)) + StringLib.newString(s3->at(0+1)) ;
    OclFile["System.out"].println(result+""->toUpperCase()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] arg){
    Scanner sc=new Scanner(System.in);
    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 max=0 ;
    for(int i=0 ; i<n ; i++){
      if(k % arr[i]==0 && arr[i]>max)max=arr[i];
    }
    System.out.println(k/max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (k mod arr[i+1] = 0 & arr[i+1] > max) then     max := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(k / max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem915A {
  public static Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    int size=scanner.nextInt();
    int length=scanner.nextInt();
    int[] array=new int[size];
    for(int i=0 ; i<array.length ; i++){
      array[i]=scanner.nextInt();
    }
    int max=Integer.MIN_VALUE ;
    for(int i=0 ; i<array.length ; i++){
      if(length % array[i]==0){
        max=Math.max(max,array[i]);
      }
    }
    int ans=length/max ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem915A {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var size : int ; size := scanner.getCurrent()->toInteger() ;
     var length : int ; length := scanner.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < array->size() do ( (     array[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
        var i : int ; i := 0 ; while i < array->size() do ( (     if (length mod array[i+1] = 0) then (     max := Set{max, array[i+1]}->max() ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := length / max ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int k=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
      Arrays.sort(arr);
      int ans=0,min=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; i++){
        if(k % arr[i]==0){
          ans=k/arr[i];
          min=Math.min(min,ans);
        }
      }
      System.out.println(min);
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var ans : int ; ans := 0 ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     if (k mod arr[i+1] = 0) then (     ans := k / arr[i+1] ; 
     min := Set{min, ans}->min() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findIntegers(int n,int x,int y){
    ArrayList<Integer>ans=new ArrayList<Integer>();
    for(int i=0 ; i<n-1 ; i++)ans.add(1);
    if(y-(n-1)<=0){
      System.out.print("-1");
      return ;
    }
    ans.add(y-(n-1));
    int store=0 ;
    for(int i=0 ; i<n ; i++)store+=ans.get(i)*ans.get(i);
    if(store<x){
      System.out.print("-1");
      return ;
    }
    for(int i=0 ; i<n ; i++)System.out.print(ans.get(i)+" ");
  }
  public static void main(String[] args){
    int n=3,x=254,y=18 ;
    findIntegers(n,x,y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findIntegers( n : int, x : int, y : int) : void
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Sequence{} ;
         var i : int ; i := 0 ; while i < n - 1 do (     ans := ans->including(1) ;  ;     i := i + 1 ) ; 
    if (y - (n - 1) <= 0) then (     OclFile["System.out"].print("-1") ; 
     return ) else skip ; 
    ans := ans->including(y - (n - 1)) ; 
    var store : int ; store := 0 ;
        var i : int ; i := 0 ; while i < n do (     store := store+(ans->at(i+1) * ans->at(i+1)) ;  ;     i := i + 1 ) ; 
    if (store < x) then (     OclFile["System.out"].print("-1") ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(ans->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
    var x : int ; x := 254 ;
    var y : int ; y := 18 ;
     execute findIntegers(n, x, y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  static String replaceConsonants(String str){
    String res="" ;
    int i=0,count=0 ;
    while(i<str.length()){
      if(str.charAt(i)!='a' && str.charAt(i)!='e' && str.charAt(i)!='i' && str.charAt(i)!='o' && str.charAt(i)!='u'){
        i++;
        count++;
      }
      else {
        if(count>0)res+=count ;
        res+=str.charAt(i);
        i++;
        count=0 ;
      }
    }
    if(count>0)res+=count ;
    return res ;
  }
  public static void main(String[] args){
    String str="abcdeiop" ;
    System.out.println(replaceConsonants(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation replaceConsonants( str : String) : String
  pre: true
  post: true
  activity: (     var res : String ; res := "" ;
     var i : int ; i := 0 ;
    var count : int ; count := 0 ;
    while (i < str->size()) do (     if (str->at(i+1) /= 'a' & str->at(i+1) /= 'e' & str->at(i+1) /= 'i' & str->at(i+1) /= 'o' & str->at(i+1) /= 'u') then (     i := i + 1 ; 
     count := count + 1 ) else (     if (count > 0) then     res := res+(count) ; else skip ; 
     res := res+(str->at(i+1)) ; 
     i := i + 1 ; 
     count := 0 ) ) ; 
    if (count > 0) then     res := res+(count) ; else skip ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abcdeiop" ;
     OclFile["System.out"].println(replaceConsonants(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int gcd(int a,int b){
    while(b!=0){
      int t=b ;
      b=a % b ;
      a=t ;
    }
    return a ;
  }
  static int findMinDiff(int a,int b,int x,int y){
    int g=gcd(a,b);
    int diff=Math.abs(x-y)% g ;
    return Math.min(diff,g-diff);
  }
  public static void main(String[] args){
    int a=20,b=52,x=5,y=7 ;
    System.out.println(findMinDiff(a,b,x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     while (b /= 0) do (     var t : int ; t := b ;
     b := a mod b ; 
     a := t ) ; 
     return a );
  static   operation findMinDiff( a : int, b : int, x : int, y : int) : int
  pre: true
  post: true
  activity: (     var g : int ; g := gcd(a, b) ;
     var diff : int ; diff := if x - y < 0 then -(x - y) else x - y endif mod g ;
     return Set{diff, g - diff}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 20 ;
    var b : int ; b := 52 ;
    var x : int ; x := 5 ;
    var y : int ; y := 7 ;
     OclFile["System.out"].println(findMinDiff(a, b, x, y)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class GFG {
  static void rearrangeArray(int arr[],int n){
    Arrays.sort(arr);
    int[] tempArr=new int[n];
    int ArrIndex=0 ;
    for(int i=0,j=n-1 ; i<=n/2 || j>n/2 ; i++,j--){
      if(ArrIndex<n){
        tempArr[ArrIndex]=arr[i];
        ArrIndex++;
      }
      if(ArrIndex<n){
        tempArr[ArrIndex]=arr[j];
        ArrIndex++;
      }
    }
    for(int i=0 ; i<n ; i++)arr[i]=tempArr[i];
  }
  public static void main(String args[]){
    int arr[]={
      5,8,1,4,2,9,3,7,6 };
      int n=arr.length ;
      rearrangeArray(arr,n);
      for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation rearrangeArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var tempArr : Sequence(int) ; tempArr := Integer.subrange(1,n)->collect(0) ;
    var ArrIndex : int ; ArrIndex := 0 ;
        var i : int ; i := 0 ;
    var j : int ; j := n - 1 ; while i <= n / 2 or j > n / 2 do ( (     if (ArrIndex < n) then (     tempArr[ArrIndex+1] := arr[i+1] ; 
     ArrIndex := ArrIndex + 1 ) else skip ; 
     if (ArrIndex < n) then (     tempArr[ArrIndex+1] := arr[j+1] ; 
     ArrIndex := ArrIndex + 1 ) else skip )  ;     i := i + 1 ;     j := j - 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := tempArr[i+1] ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,8,1,4,2,9,3,7,6} ;
     var n : int ; n := arr->size() ;
     execute rearrangeArray(arr, n) ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.stream.*;
public class Main {
  public static final Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
  public static final PrintStream out=System.out ;
  public static void main(String[] args){
    int P=in.nextInt();
    int[] A=new int[P];
    int[] B=new int[P];
    for(int i=0 ; i<P ; i++){
      A[i]=in.nextInt();
    }
    B[0]=A[0];
    for(int i=1 ; i<P ; i++){
      B[P-1]=(B[P-1]+A[i]-B[0]+P)% P ;
    }
    B[P-1]=(P-B[P-1])% P ;
    for(int i=P-2 ; 0<i ; i--){
      for(int j=1 ; j<P ; j++){
        A[j]=(A[j]*j)% P ;
        B[i]=(B[i]+A[j])% P ;
      }
      B[i]=(P-B[i])% P ;
    }
    out.println(Arrays.stream(B).mapToObj(Integer :: toString).collect(Collectors.joining(" ")));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])));
  static    attribute out : OclFile := OclFile["System.out"];
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var P : int ; P := in.getCurrent()->toInteger() ;
     var A : Sequence(int) ; A := Integer.subrange(1,P)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,P)->collect(0) ;
        var i : int ; i := 0 ; while i < P do ( (     A[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    B[0+1] := A[0+1] ; 
        var i : int ; i := 1 ; while i < P do ( (     B[P - 1+1] := (B[P - 1+1] + A[i+1] - B[0+1] + P) mod P )  ;     i := i + 1 ) ; 
    B[P - 1+1] := (P - B[P - 1+1]) mod P ; 
        var i : int ; i := P - 2 ; while 0 < i do ( (         var j : int ; j := 1 ; while j < P do ( (     A[j+1] := (A[j+1] * j) mod P ; 
     B[i+1] := (B[i+1] + A[j+1]) mod P )  ;     j := j + 1 ) ; 
     B[i+1] := (P - B[i+1]) mod P )  ;     i := i - 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int Max=0 ;
    int Min=0 ;
    Min=k==n || k==0 ? 0 : 1 ;
    Max=k==0 || k==n ? 0 : Math.min(2*k,n-k);
    System.out.println(Min+" "+Max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var Max : int ; Max := 0 ;
    var Min : int ; Min := 0 ;
    Min := if k = n or k = 0 then 0 else 1 endif ; 
    Max := if k = 0 or k = n then 0 else Set{2 * k, n - k}->min() endif ; 
    OclFile["System.out"].println(Min + " " + Max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] __){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int min=k==n || k==0 ? 0 : 1 ;
    int max=k==0 ? 0 : Math.min(2*k,n-k);
    System.out.println(min+" "+max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( __ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var min : int ; min := if k = n or k = 0 then 0 else 1 endif ;
    var max : int ; max := if k = 0 then 0 else Set{2 * k, n - k}->min() endif ;
    OclFile["System.out"].println(min + " " + max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long n=scanner.nextLong();
    long k=scanner.nextLong();
    long min=1,max=0 ;
    max=n-k ;
    if(k*3<n){
      max=2*k ;
    }
    if(k>=n || k==0){
      max=0 ;
      min=0 ;
    }
    System.out.printf("%d %d",min,max);
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := scanner.getCurrent()->toLong() ;
    var k : long ; k := scanner.getCurrent()->toLong() ;
    var min : long ; min := 1 ;
    var max : long ; max := 0 ;
    max := n - k ; 
    if (k * 3 < n) then (     max := 2 * k ) else skip ; 
    if (k >= n or k = 0) then (     max := 0 ; 
     min := 0 ) else skip ; 
    OclFile["System.out"].printf("%d %d", min, max) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in))){
      final String s=reader.readLine();
      final String sl[]=s.split(" ");
      String s1=sl[0];
      String s2=sl[1];
      String s3=sl[2];
      String ans=String.format("%c",s1.charAt(0)-32);
      ans+=String.format("%c",s2.charAt(0)-32);
      ans+=String.format("%c",s3.charAt(0)-32);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var s : String ; s := reader.readLine() ;
     var sl : Sequence(String) ; sl := s->split(" ") ;
    var s1 : String ; s1 := sl[0+1] ;
    var s2 : String ; s2 := sl[1+1] ;
    var s3 : String ; s3 := sl[2+1] ;
    var ans : String ; ans := StringLib.format("%c",Sequence{s1->at(0+1) - 32}) ;
    ans := ans+(StringLib.format("%c",Sequence{s2->at(0+1) - 32})) ; 
    ans := ans+(StringLib.format("%c",Sequence{s3->at(0+1) - 32})) ; 
    OclFile["System.out"].println(ans) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    System.out.println(Math.min(m==0 ? 0 : 1,n-m)+" "+Math.min(2*m,n-m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(Set{if m = 0 then 0 else 1 endif, n - m}->min() + " " + Set{2 * m, n - m}->min()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class MaximBuysAnApartment {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),k=in.nextInt();
    pw.println(solve(n,k)[0]+" "+solve(n,k)[1]);
    pw.close();
  }
  static long[] solve(long n,long k){
    long[] ans=new long[2];
    if(k==n){
      ans[0]=0 ;
      ans[1]=0 ;
      return ans ;
    }
    if(k>0)ans[0]=1 ;
    long case1=k+k*2 ;
    if(case1<=n){
      ans[1]=k*2 ;
      return ans ;
    }
    ans[1]=n-k ;
    return ans ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class MaximBuysAnApartment {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    skip ; 
    skip ; 
 );
  static   operation solve( n : long, k : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var ans : Sequence(long) ; ans := Integer.subrange(1,2)->collect(0) ;
     if (k = n) then (     ans[0+1] := 0 ; 
     ans[1+1] := 0 ; 
     return ans ) else skip ; 
    if (k > 0) then     ans[0+1] := 1 ; else skip ; 
    var case1 : long ; case1 := k + k * 2 ;
    if (case1 <= n) then (     ans[1+1] := k * 2 ; 
     return ans ) else skip ; 
    ans[1+1] := n - k ; 
    return ans 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int area=a*b ;
    int length=2*(a+b);
    System.out.println(area+" "+length);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var area : int ; area := a * b ;
    var length : int ; length := 2 * (a + b) ;
    OclFile["System.out"].println(area + " " + length) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String s=new String(in.readLine());
    String[] ss=s.split(" ");
    int a=Integer.parseInt(ss[0]);
    int b=Integer.parseInt(ss[1]);
    System.out.print(a*b);
    System.out.print(" ");
    System.out.println(2*a+2*b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := StringLib.newString(in.readLine()) ;
    var ss : Sequence(String) ; ss := s->split(" ") ;
    var a : int ; a := (ss[0+1])->toInteger() ;
    var b : int ; b := (ss[1+1])->toInteger() ;
    OclFile["System.out"].print(a * b) ; 
    OclFile["System.out"].print(" ") ; 
    OclFile["System.out"].println(2 * a + 2 * b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int a=stdIn.nextInt();
    while(a--!=0){
      int X=stdIn.nextInt();
      int Y=stdIn.nextInt();
      int W=stdIn.nextInt();
      int H=stdIn.nextInt();
      int N=stdIn.nextInt();
      int count=0 ;
      for(int i=0 ; i<N ; ++i){
        int x=stdIn.nextInt();
        int y=stdIn.nextInt();
        if((X<=x && x<=X+W)&&(Y<=y && y<=Y+H)){
++count ;
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := stdIn.getCurrent()->toInteger() ;
         while (a /= 0) do (    skip ; (     var X : int ; X := stdIn.getCurrent()->toInteger() ;
     var Y : int ; Y := stdIn.getCurrent()->toInteger() ;
    var W : int ; W := stdIn.getCurrent()->toInteger() ;
    var H : int ; H := stdIn.getCurrent()->toInteger() ;
    var N : int ; N := stdIn.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var x : int ; x := stdIn.getCurrent()->toInteger() ;
     var y : int ; y := stdIn.getCurrent()->toInteger() ;
     if ((X <= x & x <= X + W) & (Y <= y & y <= Y + H)) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int length=Integer.parseInt(sc.next());
    int breadth=Integer.parseInt(sc.next());
    Rectangle rec=new Rectangle(length,breadth);
    System.out.println(rec.calculateArea()+" "+rec.calculatePerimeter());
    sc.close();
  }
}
class Rectangle {
  private int length ;
  private int breadth ;
  Rectangle(){
    throw new IllegalArgumentException("It is not acceptable.");
  }
  Rectangle(int length,int breadth){
    this.length=length ;
    this.breadth=breadth ;
  }
  public int getLength(){
    return this.length ;
  }
  public int getBreadth(){
    return this.breadth ;
  }
  public int calculatePerimeter(){
    return 2*this.length+2*this.breadth ;
  }
  public int calculateArea(){
    return this.length*this.breadth ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var length : int ; length := (sc.getCurrent())->toInteger() ;
    var breadth : int ; breadth := (sc.getCurrent())->toInteger() ;
    var rec : Rectangle ; rec := Rectangle.newRectangle(length, breadth) ;
    OclFile["System.out"].println(rec.calculateArea() + " " + rec.calculatePerimeter()) ; 
    skip ; 
 );
}
class Rectangle {
   attribute length : int;
   attribute breadth : int;
   static operation newRectangle() : Rectangle
  pre: true
  post: true
  activity:
  ( var self : Rectangle ;
    self := createRectangle();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     error IllegalArgumentException.newIllegalArgumentException("It is not acceptable.") );
   static operation newRectangle( length : int, breadth : int) : Rectangle
  pre: true
  post: true
  activity:
  ( var self : Rectangle ;
    self := createRectangle();
    self.initialise(length, breadth);
    return self );
  operation initialise( length : int, breadth : int) : void
  pre: true  post: true
  activity: (     self->size() := length ; 
     self.breadth := breadth );
   operation getLength() : int
  pre: true
  post: true
  activity: (     return self->size() );
   operation getBreadth() : int
  pre: true
  post: true
  activity: (     return self.breadth );
   operation calculatePerimeter() : int
  pre: true
  post: true
  activity: (     return 2 * self->size() + 2 * self.breadth );
   operation calculateArea() : int
  pre: true
  post: true
  activity: (     return self->size() * self.breadth );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    System.out.println(squareArea(x,y)+" "+squarePerimeter(x,y));
  }
  public static int squareArea(int x,int y){
    return x*y ;
  }
  public static int squarePerimeter(int x,int y){
    return(x+y)*2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(squareArea(x, y) + " " + squarePerimeter(x, y)) );
  static   operation squareArea( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return x * y );
  static   operation squarePerimeter( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return (x + y) * 2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args){
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(isr);
    try {
      String list[]=br.readLine().split(" ");
      int x=Integer.parseInt(list[0]);
      int y=Integer.parseInt(list[1]);
      System.out.println(x*y+" "+((x*2)+(y*2)));
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
     try (     var list : Sequence(String) ; list := br.readLine()->split(" ") ;
     var x : int ; x := (list[0+1])->toInteger() ;
     var y : int ; y := (list[1+1])->toInteger() ;
     OclFile["System.out"].println(x * y + " " + ((x * 2) + (y * 2))) )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char value=sc.nextLine().toCharArray()[0];
    if(Character.isUpperCase(value))System.out.println('A');
    else System.out.println('a');
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var value : String ; value := sc.nextLine()->characters()[0+1] ;
     if ((value->toUpperCase() = value)) then     OclFile["System.out"].println('A') ; else     OclFile["System.out"].println('a') ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  public static void main(String hi[])throws Exception {
    BufferedReader infile=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(infile.readLine());
    char val=st.nextToken().charAt(0);
    if(val>='A' && val<='Z')System.out.println('A');
    else System.out.println('a');
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( hi : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var infile : OclFile ; infile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(infile.readLine()) ;
     var val : String ; val := st.next()->at(0+1) ;
     if (val >= 'A' & val <= 'Z') then     OclFile["System.out"].println('A') ; else     OclFile["System.out"].println('a') ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
class Main {
  final Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    if(Character.isUpperCase(sc.next().charAt(0))){
      System.out.println("A");
    }
    else {
      System.out.println("a");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     if ((sc.getCurrent()->at(0+1)->toUpperCase() = sc.getCurrent()->at(0+1))) then (     OclFile["System.out"].println("A") ) else (     OclFile["System.out"].println("a") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  void solve(){
    String s=instr().substring(0,1)+instr().substring(0,1)+instr().substring(0,1);
    out.println(s.toUpperCase());
  }
  public static Scanner in=new Scanner(System.in);
  public static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    new Main().solve();
    out.flush();
  }
  public int inint(){
    return in.nextInt();
  }
  public long inlong(){
    return in.nextLong();
  }
  public String instr(){
    return in.next();
  }
  public char inchar(){
    return in.next().charAt(0);
  }
  public int[] inintar(int num){
    int[] a=new int[num];
    for(int i=0 ; i<num ; i++){
      a[i]=in.nextInt();
    }
    return a ;
  }
  public char[] incharar(){
    return in.next().toCharArray();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var s : String ; s := instr().subrange(0+1,1) + instr().subrange(0+1,1) + instr().subrange(0+1,1) ;
     out.println(s->toUpperCase()) );
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() ; 
     skip );
   operation inint() : int
  pre: true
  post: true
  activity: (     return in.getCurrent()->toInteger() );
   operation inlong() : long
  pre: true
  post: true
  activity: (     return in.getCurrent()->toLong() );
   operation instr() : String
  pre: true
  post: true
  activity: (     return in.getCurrent() );
   operation inchar() : String
  pre: true
  post: true
  activity: (     return in.getCurrent()->at(0+1) );
   operation inintar( num : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,num)->collect(0) ;
         var i : int ; i := 0 ; while i < num do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return a );
   operation incharar() : Sequence(String)
  pre: true
  post: true
  activity: (     return in.getCurrent()->characters() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    char c=in.next().charAt(0);
    if(c>=65 && c<=90)System.out.println('A');
    else System.out.println('a');
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var c : String ; c := in.getCurrent()->at(0+1) ;
    if (c >= 65 & c <= 90) then     OclFile["System.out"].println('A') else     OclFile["System.out"].println('a') ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import static java.lang.Character.isUpperCase ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char a=sc.next().charAt(0);
    if(isUpperCase(a)){
      System.out.println("A");
    }
    else {
      System.out.println("a");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := sc.getCurrent()->at(0+1) ;
     if (isUpperCase(a)) then (     OclFile["System.out"].println("A") ) else (     OclFile["System.out"].println("a") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int minElements(int arr[],int n){
    int halfSum=0 ;
    for(int i=0 ; i<n ; i++)halfSum=halfSum+arr[i];
    halfSum=halfSum/2 ;
    Arrays.sort(arr);
    int res=0,curr_sum=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      curr_sum+=arr[i];
      res++;
      if(curr_sum>halfSum)return res ;
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      3,1,7,1 };
      int n=arr.length ;
      System.out.println(minElements(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minElements( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var halfSum : int ; halfSum := 0 ;
         var i : int ; i := 0 ; while i < n do (     halfSum := halfSum + arr[i+1] ;  ;     i := i + 1 ) ; 
    halfSum := halfSum / 2 ; 
    arr := arr->sort() ; 
    var res : int ; res := 0 ;
    var curr_sum : int ; curr_sum := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     curr_sum := curr_sum+(arr[i+1]) ; 
     res := res + 1 ; 
     if (curr_sum > halfSum) then     return res else skip )  ;     i := i - 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,1,7,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minElements(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int x,y,w,h,n,m ;
    int[] cx,cy ;
    int i,j,count ;
    m=sc.nextInt();
    for(i=0 ; i<m ; i++){
      x=sc.nextInt();
      y=sc.nextInt();
      w=sc.nextInt();
      h=sc.nextInt();
      n=sc.nextInt();
      count=0 ;
      cx=new int[n];
      cy=new int[n];
      for(j=0 ; j<n ; j++){
        cx[j]=sc.nextInt();
        cy[j]=sc.nextInt();
      }
      for(j=0 ; j<n ; j++){
        if(x<=cx[j] && cx[j]<=(x+w)&& y<=cy[j] && cy[j]<=(y+h)){
          count++;
        }
      }
      System.out.println(count);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var x : int ;
    var y : int ;
    var w : int ;
    var h : int ;
    var n : int ;
    var m : int ;
    var cx : Sequence(int) ;
    var cy : Sequence(int) ;
    var i : int ;
    var j : int ;
    var count : int ;
    m := sc.nextInt() ; 
        i := 0 ; while i < m do ( (     x := sc.nextInt() ; 
     y := sc.nextInt() ; 
    w := sc.nextInt() ; 
    h := sc.nextInt() ; 
    n := sc.nextInt() ; 
    count := 0 ; 
    cx := Integer.subrange(1,n)->collect(0) ; 
    cy := Integer.subrange(1,n)->collect(0) ; 
        j := 0 ; while j < n do ( (     cx[j+1] := sc.nextInt() ; 
     cy[j+1] := sc.nextInt() )  ;     j := j + 1 ) ; 
        j := 0 ; while j < n do ( (     if (x <= cx[j+1] & cx[j+1] <= (x + w) & y <= cy[j+1] & cy[j+1] <= (y + h)) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )  ;     i := i + 1 ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMin(int arr[],int n){
    int ans=1 ;
    for(int i=0 ; i<n ; i++){
      int j=i+1 ;
      while(j<n && arr[j]>=arr[j-1])j++;
      ans=Math.max(ans,j-i);
      i=j-1 ;
    }
    return n-ans ;
  }
  public static void main(String[] args){
    int arr[]={
      3,2,1 };
      int n=arr.length ;
      System.out.println(findMin(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMin( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     var j : int ; j := i + 1 ;
     while (j < n & arr[j+1] >= arr[j - 1+1]) do     j := j + 1 ; ; 
     ans := Set{ans, j - i}->max() ; 
     i := j - 1 )  ;     i := i + 1 ) ; 
     return n - ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,2,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMin(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private void solve()throws IOException {
    long N=nextLong();
    ArrayList<Integer>ans=solve(N+1);
    out.println(2*ans.size());
    for(int i : ans)out.print(i+" ");
    for(int i=1 ; i<=ans.size(); i++)out.print(i+" ");
  }
  ArrayList<Integer>solve(long N){
    ArrayList<Integer>ans=new ArrayList<>();
    if(N==1)return ans ;
    if(N % 2==0){
      ArrayList<Integer>curr=solve(N/2);
      curr.add(curr.size()+1);
      ans=curr ;
    }
    else {
      ArrayList<Integer>curr=solve(N-1);
      ans.add(curr.size()+1);
      ans.addAll(curr);
    }
    return ans ;
  }
  public void run()throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    st=null ;
    out=new PrintWriter(System.out);
    solve();
    br.close();
    out.close();
  }
  public static void main(String args[])throws IOException {
    new Main().run();
  }
  BufferedReader br ;
  StringTokenizer st ;
  PrintWriter out ;
  String nextToken()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  String nextLine()throws IOException {
    return br.readLine();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : long ; N := nextLong() ;
     var ans : Sequence(int) ; ans := solve(N + 1) ;
    out.println(2 * ans->size()) ; 
    for (i : ans) do (     out.print(i + " ") ;  ) ; 
        var i : int ; i := 1 ; while i <= ans->size() do (     out.print(i + " ") ;  ;     i := i + 1 ) ; 
 );
   operation solve( N : long) : Sequence(int)
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Sequence{} ;
     if (N = 1) then     return ans else skip ; 
     if (N mod 2 = 0) then (     var curr : Sequence(int) ; curr := solve(N / 2) ;
     curr := curr->including(curr->size() + 1) ; 
     ans := curr ) else (     var curr : Sequence(int) ; curr := solve(N - 1) ;
     ans := ans->including(curr->size() + 1) ; 
     ans := ans->union(curr) ) ;  
     return ans );
   operation run() : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := null ; 
    out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    br.close() ; 
    out.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute br : OclFile;
   attribute st : OclIterator;
   attribute out : OclFile;
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Deque ;
import java.util.List ;
import java.util.Scanner ;
class Main {
  private static int bitcount(long n){
    int res=0 ;
    while(n>0){
      if((n & 1)==1)++res ;
      n/=2 ;
    }
    return res ;
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    long N=scan.nextLong();
    int maxbit=-1 ;
    long n=N ;
    while(n>0){
      n/=2 ;
++maxbit ;
    }
    Deque<Integer>first=new ArrayDeque<>();
    List<Integer>second=new ArrayList<>();
    for(int i=maxbit ; i>0 ; --i){
      first.addLast(i);
      second.add(i);
    }
    Deque<Integer>useNumber=new ArrayDeque<>();
    for(int i=bitcount(N)-1 ; i>0 ; --i){
      useNumber.addLast(maxbit+i);
      first.addFirst(maxbit+i);
    }
    for(int i=maxbit-1 ; i>=0 ; --i){
      if(((N>>i)& 1)==1){
        int inn=useNumber.removeFirst();
        second.add(second.indexOf(i+1)+1,inn);
      }
    }
    List<Integer>ans=new ArrayList<>();
    ans.add(100);
    while(! first.isEmpty()){
      ans.add(first.removeFirst());
    }
    for(int i : second)ans.add(i);
    ans.add(100);
    System.out.println(ans.size());
    for(int i : ans)System.out.print(i+" ");
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation bitcount( n : long) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     while (n > 0) do (     if ((n & 1) = 1) then     res := res + 1 ; else skip ; 
     n := n/(2) ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := scan.getCurrent()->toLong() ;
    var maxbit : int ; maxbit := -1 ;
    var n : long ; n := N ;
    while (n > 0) do (     n := n/(2) ; 
     maxbit := maxbit + 1 ) ; 
    var first : Sequence(int) ; first := ArrayDeque<OclAny>.newArrayDeque() ;
    var second : Sequence(int) ; second := Sequence{} ;
        var i : int ; i := maxbit ; while i > 0 do ( (     first := first->append(i) ; 
     second := second->including(i) )  ;     i := i - 1 ) ; 
    var useNumber : Sequence(int) ; useNumber := ArrayDeque<OclAny>.newArrayDeque() ;
        var i : int ; i := bitcount(N) - 1 ; while i > 0 do ( (     useNumber := useNumber->append(maxbit + i) ; 
     first := first->prepend(maxbit + i) )  ;     i := i - 1 ) ; 
        var i : int ; i := maxbit - 1 ; while i >= 0 do ( (     if ((((N/(2->pow(i)))->oclAsType(long)) & 1) = 1) then (     var inn : int ; inn := useNumber->first() ;
     second := second.insertAt(second->indexOf(i + 1)-1 + 1+1,inn) ) else skip )  ;     i := i - 1 ) ; 
    var ans : Sequence(int) ; ans := Sequence{} ;
    ans := ans->including(100) ; 
    while (not(first->isEmpty())) do (     ans := ans->including(first->first()) ) ; 
    for (i : second) do (     ans := ans->including(i) ;  ) ; 
    ans := ans->including(100) ; 
    OclFile["System.out"].println(ans->size()) ; 
    for (i : ans) do (     OclFile["System.out"].print(i + " ") ;  ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  BufferedReader br ;
  PrintWriter out ;
  StringTokenizer st ;
  boolean eof ;
  void go(ArrayDeque<Integer>q,long x){
    if(x==1){
      return ;
    }
    if(x % 2==0){
      go(q,x/2);
      q.addLast(q.size()+1);
    }
    else {
      go(q,x-1);
      q.addFirst(q.size()+1);
    }
  }
  void solve()throws IOException {
    long x=nextLong()+1 ;
    ArrayDeque<Integer>q=new ArrayDeque<>();
    go(q,x);
    List<Integer>ans=new ArrayList<>();
    for(int i=1 ; i<=q.size(); i++){
      ans.add(i);
    }
    ans.addAll(q);
    out.println(ans.size());
    for(int xx : ans){
      out.print(xx+" ");
    }
    out.println();
  }
  Main()throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(System.out);
    solve();
    out.close();
  }
  public static void main(String[] args)throws IOException {
    new Main();
  }
  String nextToken(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
        eof=true ;
        return null ;
      }
    }
    return st.nextToken();
  }
  String nextString(){
    try {
      return br.readLine();
    }
    catch(IOException e){
      eof=true ;
      return null ;
    }
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute br : OclFile;
   attribute out : OclFile;
   attribute st : OclIterator;
   attribute eof : boolean;
   operation go( q : Sequence(int), x : long) : void
  pre: true
  post: true
  activity: (     if (x = 1) then (     return ) else skip ; 
     if (x mod 2 = 0) then (     execute go(q, x / 2) ; 
     q := q->append(q->size() + 1) ) else (     execute go(q, x - 1) ; 
     q := q->prepend(q->size() + 1) ) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var x : long ; x := nextLong() + 1 ;
     var q : Sequence(int) ; q := ArrayDeque<OclAny>.newArrayDeque() ;
    execute go(q, x) ; 
    var ans : Sequence(int) ; ans := Sequence{} ;
        var i : int ; i := 1 ; while i <= q->size() do ( (     ans := ans->including(i) )  ;     i := i + 1 ) ; 
    ans := ans->union(q) ; 
    skip ; 
    for (xx : ans) do ( (     skip )  ) ; 
    skip ; 
 );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     execute solve() ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     eof := true ; 
     return null )
 ) ; 
     return st.next() );
   operation nextString() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do (     eof := true ; 
     return null )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    long N=sc.nextLong();
    ArrayList<Integer>first=new ArrayList<>();
    ArrayList<Integer>second=new ArrayList<>();
    for(int i=1 ; (1L<<i)-1<=N ; i++){
      first.add(i);
      second.add(i);
    }
    N-=(1L<<first.size())-1 ;
    while(N>0){
      int a=first.size()+1 ;
      first.add(a);
      for(int i=0 ; ; i++){
        if((1L<<(i+1))>N){
          second.add(i,a);
          N-=(1L<<(i));
          break ;
        }
      }
    }
    System.out.println(first.size()*2);
    for(int i=0 ; i<first.size(); i++){
      System.out.print(first.get(i)+" ");
    }
    for(int i=0 ; i<first.size(); i++){
      System.out.print(second.get(i)+(i==first.size()-1 ? "\n" : " "));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := sc.getCurrent()->toLong() ;
     var first : Sequence(int) ; first := Sequence{} ;
    var second : Sequence(int) ; second := Sequence{} ;
        var i : int ; i := 1 ; while ((1L*(2->pow(i)))->oclAsType(long)) - 1 <= N do ( (     first := first->including(i) ; 
     second := second->including(i) )  ;     i := i + 1 ) ; 
    N := N-(((1L*(2->pow(first->size())))->oclAsType(long)) - 1) ; 
    while (N > 0) do (     var a : int ; a := first->size() + 1 ;
     first := first->including(a) ; 
         var i : int ; i := 0 ; while true do ( (     if (((1L*(2->pow((i + 1))))->oclAsType(long)) > N) then (     second := second.insertAt(i+1,a) ; 
     N := N-(((1L*(2->pow((i))))->oclAsType(long))) ; 
     break ) else skip )  ;     i := i + 1 ) ) ; 
    OclFile["System.out"].println(first->size() * 2) ; 
        var i : int ; i := 0 ; while i < first->size() do ( (     OclFile["System.out"].print(first->at(i+1) + " ") )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < first->size() do ( (     OclFile["System.out"].print(second->at(i+1) + (if i = first->size() - 1 then "\n" else " " endif)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    ArrayList<Integer>res=new ArrayList<Integer>();
    int k ;
    for(k=40 ; k>=0 ; k--){
      if(n>=(1L<<k)-1)break ;
    }
    for(int i=1 ; i<=k ; i++)res.add(i);
    n-=(1L<<k)-1 ;
    for(int i=k-1 ; i>=0 ; i--){
      if(n<(1L<<i))continue ;
      k++;
      res.add(i,k);
      n-=1L<<i ;
    }
    System.out.println(2*res.size());
    for(int x : res)System.out.print(x+" ");
    for(int i=1 ; i<=res.size(); i++)System.out.print(i+" ");
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var res : Sequence(int) ; res := Sequence{} ;
    var k : int ;
        k := 40 ; while k >= 0 do ( (     if (n >= ((1L*(2->pow(k)))->oclAsType(long)) - 1) then     break else skip )  ;     k := k - 1 ) ; 
        var i : int ; i := 1 ; while i <= k do (     res := res->including(i) ;  ;     i := i + 1 ) ; 
    n := n-(((1L*(2->pow(k)))->oclAsType(long)) - 1) ; 
        var i : int ; i := k - 1 ; while i >= 0 do ( (     if (n < ((1L*(2->pow(i)))->oclAsType(long))) then     continue else skip ; 
     k := k + 1 ; 
     res := res.insertAt(i+1,k) ; 
     n := n-((1L*(2->pow(i)))->oclAsType(long)) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(2 * res->size()) ; 
    for (x : res) do (     OclFile["System.out"].print(x + " ") ;  ) ; 
        var i : int ; i := 1 ; while i <= res->size() do (     OclFile["System.out"].print(i + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int ni(){
    return cin.nextInt();
  }
  long nl(){
    return cin.nextLong();
  }
  String line(){
    return cin.nextLine();
  }
  void println(String str){
    System.out.println(str);
  }
  void print(String str){
    System.out.print(str);
  }
  static final int MOD=1000000007 ;
  Scanner cin=new Scanner(System.in);
  String output ;
  public static void main(String[] args){
    new Main().run();
  }
  public void run(){
    input();
    int res=solve();
    output=res+"" ;
    println(output);
  }
  int H,W ;
  void input(){
    H=ni();
    W=ni();
    if(W>H){
      W=H+W ;
      H=W-H ;
      W=W-H ;
    }
  }
  int solve(){
    if(H % 3==0 || W % 3==0){
      return 0 ;
    }
    return Math.min(cal(H,W),cal(W,H));
  }
  int cal(long h,long w){
    long res=w ;
    for(long i=h/3 ; i<=h/2 ; i++){
      long a[]=new long[3];
      a[0]=(i)*w ;
      a[1]=(h-i)*(w/2);
      a[2]=(h-i)*(w-w/2);
      Arrays.sort(a);
      res=Math.min(res,a[2]-a[0]);
    }
    return(int)res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation ni() : int
  pre: true
  post: true
  activity: (     return cin.nextInt() );
   operation nl() : long
  pre: true
  post: true
  activity: (     return cin.nextLong() );
   operation line() : String
  pre: true
  post: true
  activity: (     return cin.nextLine() );
   operation println( str : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(str) );
   operation print( str : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(str) );
  static    attribute MOD : int := 1000000007;
   attribute cin : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute output : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     execute input() ; 
     var res : int ; res := solve() ;
     output := res + "" ; 
     execute println(output) );
   attribute H : int;
   operation input() : void
  pre: true
  post: true
  activity: (     H := ni() ; 
     W := ni() ; 
     if (W > H) then (     W := H + W ; 
     H := W - H ; 
     W := W - H ) else skip );
   operation solve() : int
  pre: true
  post: true
  activity: (     if (H mod 3 = 0 or W mod 3 = 0) then (     return 0 ) else skip ; 
     return Set{cal(H, W), cal(W, H)}->min() );
   operation cal( h : long, w : long) : int
  pre: true
  post: true
  activity: (     var res : long ; res := w ;
         var i : long ; i := h / 3 ; while i <= h / 2 do ( (     var a : Sequence(long) ; a := Integer.subrange(1,3)->collect(0) ;
     a[0+1] := (i) * w ; 
    a[1+1] := (h - i) * (w / 2) ; 
    a[2+1] := (h - i) * (w - w / 2) ; 
    a := a->sort() ; 
    res := Set{res, a[2+1] - a[0+1]}->min() ; 
 )  ;     i := i + 1 ) ; 
     return res->oclAsType(int) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  static int findTerm(int n){
    if(n==1)return n ;
    else {
      int term=7 ;
      for(int i=2 ; i<=n ; i++)term=term*2+(i-1);
      return term ;
    }
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.print(findTerm(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findTerm( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return n else (     var term : int ; term := 7 ;
         var i : int ; i := 2 ; while i <= n do (     term := term * 2 + (i - 1) ;  ;     i := i + 1 ) ; 
     return term ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].print(findTerm(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long h=sc.nextLong();
    long w=sc.nextLong();
    if(h % 3==0 || w % 3==0){
      System.out.println(0);
      return ;
    }
    long res=Math.min(h,w);
    if(w % 2==1){
      long diff=(3*w-1)*(h/3+1)/2-h*(w-1)/2 ;
      res=Math.min(res,diff);
      diff=h*(w+1)/2-(3*w+1)*(h/3)/2 ;
      res=Math.min(res,diff);
    }
    else {
      long diff=3*w*(h/3+1)/2-h*w/2 ;
      res=Math.min(res,diff);
      diff=w*h/2-3*w*(h/3)/2 ;
      res=Math.min(res,diff);
    }
    if(h % 2==1){
      long diff=(3*h-1)*(w/3+1)/2-w*(h-1)/2 ;
      res=Math.min(res,diff);
      diff=w*(h+1)/2-(3*h+1)*(w/3)/2 ;
      res=Math.min(res,diff);
    }
    else {
      long diff=3*h*(w/3+1)/2-w*h/2 ;
      res=Math.min(res,diff);
      diff=w*h/2-3*h*(w/3)/2 ;
      res=Math.min(res,diff);
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : long ; h := sc.getCurrent()->toLong() ;
    var w : long ; w := sc.getCurrent()->toLong() ;
    if (h mod 3 = 0 or w mod 3 = 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var res : long ; res := Set{h, w}->min() ;
    if (w mod 2 = 1) then (     var diff : long ; diff := (3 * w - 1) * (h / 3 + 1) / 2 - h * (w - 1) / 2 ;
     res := Set{res, diff}->min() ; 
     diff := h * (w + 1) / 2 - (3 * w + 1) * (h / 3) / 2 ; 
     res := Set{res, diff}->min() ) else (     var diff : long ; diff := 3 * w * (h / 3 + 1) / 2 - h * w / 2 ;
     res := Set{res, diff}->min() ; 
     diff := w * h / 2 - 3 * w * (h / 3) / 2 ; 
     res := Set{res, diff}->min() ) ;  
    if (h mod 2 = 1) then (     var diff : long ; diff := (3 * h - 1) * (w / 3 + 1) / 2 - w * (h - 1) / 2 ;
     res := Set{res, diff}->min() ; 
     diff := w * (h + 1) / 2 - (3 * h + 1) * (w / 3) / 2 ; 
     res := Set{res, diff}->min() ) else (     var diff : long ; diff := 3 * h * (w / 3 + 1) / 2 - w * h / 2 ;
     res := Set{res, diff}->min() ; 
     diff := w * h / 2 - 3 * h * (w / 3) / 2 ; 
     res := Set{res, diff}->min() ) ;  
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    try {
      String packageName=new Main().getClass().getPackage().getName();
      System.setIn(new FileInputStream("src/"+packageName+"/input.txt"));
    }
    catch(FileNotFoundException e){
    }
    catch(NullPointerException e){
    }
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc ;
  void run(){
    sc=new Scanner(System.in);
    int T=sc.nextInt();
    while(T-->0)solve();
  }
  void solve(){
    int sx=sc.nextInt();
    int sy=sc.nextInt();
    int lenx=sc.nextInt();
    int leny=sc.nextInt();
    int ans=0 ;
    int M=sc.nextInt();
    for(int i=0 ; i<M ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      if(sx<=x && x<=sx+lenx && sy<=y && y<=sy+leny)ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var packageName : String ; packageName := Main.newMain()->oclType().getPackage().getName() ;
 setIn(OclFile.newOclFile_Read(OclFile.newOclFile("src/" + packageName + "/input.txt"))) )   catch (e : FileNotFoundException) do skip
   catch (e : NullAccessException) do skip
     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var T : int ; T := sc.getCurrent()->toInteger() ;
         while (T > 0) do (        T := T - 1 ;     skip ;     execute solve() ; ;  ) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sx : int ; sx := sc.getCurrent()->toInteger() ;
     var sy : int ; sy := sc.getCurrent()->toInteger() ;
    var lenx : int ; lenx := sc.getCurrent()->toInteger() ;
    var leny : int ; leny := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < M do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     if (sx <= x & x <= sx + lenx & sy <= y & y <= sy + leny) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Spliterator ;
import java.util.Spliterators ;
import java.util.concurrent.ThreadLocalRandom ;
import java.util.concurrent.atomic.AtomicInteger ;
import java.util.stream.IntStream ;
import java.util.stream.Stream ;
import java.util.stream.StreamSupport ;
public class Main {
  static Scanner s=new Scanner(System.in);
  static long[] fal_rnd(int size){
    AtomicInteger l=new AtomicInteger(-1),r=new AtomicInteger(size);
    long[] res=new long[size];
    INS(size).unordered().parallel().mapToLong(Long :: parseLong).forEach(v->res[ThreadLocalRandom.current().nextBoolean()? l.incrementAndGet(): r.decrementAndGet()]=v);
    return res ;
  }
  static IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static Stream<String>INS(long size){
    return StreamSupport.stream(Spliterators.spliterator(s,size,Spliterator.NONNULL & Spliterator.IMMUTABLE),false).limit(size);
  }
  public static void main(String[] __){
    int a=s.nextInt(),b=s.nextInt();
    System.out.println(Math.min(solve(a,b),solve(b,a)));
  }
  private static long solve(long w,long h){
    long r=Integer.MAX_VALUE ;
    for(int i=0 ; i<=w ; i++){
      long sg=h*i ;
      long sb=(h+1)/2*(w-i);
      long sr=h/2*(w-i);
      r=Math.min(r,Math.abs(Math.max(sg,sb)-Math.min(sg,sr)));
      sb=(w-i+1)/2*h ;
      sr=(w-i)/2*h ;
      r=Math.min(r,Math.abs(Math.max(sg,sb)-Math.min(sg,sr)));
    }
    return r ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation fal_rnd( size : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var l : int ; l := (-1) ;
    var r : int ; r := (size) ;
     var res : Sequence(long) ; res := Integer.subrange(1,size)->collect(0) ;
     for v : INS(size)->collect( _x1 | (lambda _s : String in _s->toLong())->apply(_x1) ) do
    (    res[if MathLib.nextBoolean() then l+1 else r-1 endif+1] := v) ; 
     return res );
  static   operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static   operation INS( size : long) : Stream<String>
  pre: true
  post: true
  activity: (     return (OclIterator.newOclIterator_Sequence(s)).elements.subrange(1,size) );
  static   operation main( __ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := s.getCurrent()->toInteger() ;
    var b : int ; b := s.getCurrent()->toInteger() ;
     OclFile["System.out"].println(Set{solve(a, b), solve(b, a)}->min()) );
  static   operation solve( w : long, h : long) : long
  pre: true
  post: true
  activity: (     var r : long ; r := 2147483647 ;
         var i : int ; i := 0 ; while i <= w do ( (     var sg : long ; sg := h * i ;
     var sb : long ; sb := (h + 1) / 2 * (w - i) ;
    var sr : long ; sr := h / 2 * (w - i) ;
    r := Set{r, if Set{sg, sb}->max() - Set{sg, sr}->min() < 0 then -(Set{sg, sb}->max() - Set{sg, sr}->min()) else Set{sg, sb}->max() - Set{sg, sr}->min() endif}->min() ; 
    sb := (w - i + 1) / 2 * h ; 
    sr := (w - i) / 2 * h ; 
    r := Set{r, if Set{sg, sb}->max() - Set{sg, sr}->min() < 0 then -(Set{sg, sb}->max() - Set{sg, sr}->min()) else Set{sg, sb}->max() - Set{sg, sr}->min() endif}->min() ; 
 )  ;     i := i + 1 ) ; 
     return r );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    System.out.println(Long.min(calc(h,w),calc(w,h)));
  }
  static long calc(long a,long b){
    long x=(a/3)*b ;
    long y=((a-a/3)/2)*b ;
    long z=(a-(a/3)-(a-a/3)/2)*b ;
    ArrayList<Long>vals=new ArrayList<>();
    vals.add(x);
    vals.add(y);
    vals.add(z);
    Collections.sort(vals);
    long min=vals.get(2)-vals.get(0);
    for(long i=1 ; i<a ; i++){
      x=i*b ;
      y=(a-i)*(b/2);
      z=(a-i)*(b-b/2);
      vals=new ArrayList<>();
      vals.add(x);
      vals.add(y);
      vals.add(z);
      Collections.sort(vals);
      min=Long.min(min,vals.get(2)-vals.get(0));
    }
    return min ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(Set{calc(h, w), calc(w, h)}->min()) );
  static   operation calc( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var x : long ; x := (a / 3) * b ;
     var y : long ; y := ((a - a / 3) / 2) * b ;
    var z : long ; z := (a - (a / 3) - (a - a / 3) / 2) * b ;
    var vals : Sequence(long) ; vals := Sequence{} ;
    vals := vals->including(x) ; 
    vals := vals->including(y) ; 
    vals := vals->including(z) ; 
    vals := vals->sort() ; 
    var min : long ; min := vals->at(2+1) - vals->at(0+1) ;
        var i : long ; i := 1 ; while i < a do ( (     x := i * b ; 
     y := (a - i) * (b / 2) ; 
    z := (a - i) * (b - b / 2) ; 
    vals := Sequence{} ; 
    vals := vals->including(x) ; 
    vals := vals->including(y) ; 
    vals := vals->including(z) ; 
    vals := vals->sort() ; 
    min := Set{min, vals->at(2+1) - vals->at(0+1)}->min() ; 
 )  ;     i := i + 1 ) ; 
    return min 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void otherEndPoint(int x1,int y1,int m1,int m2){
    float x2=(float)(2*m1-x1);
    float y2=(float)(2*m2-y1);
    System.out.println("x2="+x2+","+"y2="+y2);
  }
  public static void main(String args[]){
    int x1=-4,y1=-1,m1=3,m2=5 ;
    otherEndPoint(x1,y1,m1,m2);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation otherEndPoint( x1 : int, y1 : int, m1 : int, m2 : int) : void
  pre: true
  post: true
  activity: (     var x2 : double ; x2 := (2 * m1 - x1)->oclAsType(double) ;
     var y2 : double ; y2 := (2 * m2 - y1)->oclAsType(double) ;
     OclFile["System.out"].println("x2=" + x2 + "," + "y2=" + y2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x1 : int ; x1 := -4 ;
    var y1 : int ; y1 := -1 ;
    var m1 : int ; m1 := 3 ;
    var m2 : int ; m2 := 5 ;
     execute otherEndPoint(x1, y1, m1, m2) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class LightsOut {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[][] a=new int[3][3];
    int[][] lights={
      {
        1,1,1 },{
          1,1,1 },{
            1,1,1 },};
            for(int i=0 ; i<3 ; i++){
              for(int j=0 ; j<3 ; j++){
                a[i][j]=sc.nextInt();
              }
            }
            for(int i=0 ; i<3 ; i++){
              for(int j=0 ; j<3 ; j++){
                for(int k=i-1 ; k<=i+1 ; k++){
                  for(int l=j-1 ; l<=j+1 ; l++){
                    if(k<0 || l<0 || k>2 || l>2)continue ;
                    else if(i==k || j==l){
                      lights[i][j]+=a[k][l];
                    }
                  }
                }
                System.out.print(lights[i][j] % 2==0 ? 0 : 1);
              }
              System.out.print("\n");
            }
          }
        }

------------------------------------------------------------
OCL File:
---------
 class LightsOut {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
    var lights : Sequence(Sequence(int)) ; lights := Sequence{Sequence{1,1,1},Sequence{1,1,1},Sequence{1,1,1},} ;
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     a[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 0 ; while j < 3 do ( (         var k : int ; k := i - 1 ; while k <= i + 1 do ( (         var l : int ; l := j - 1 ; while l <= j + 1 do ( (     if (k < 0 or l < 0 or k > 2 or l > 2) then     continue else     if (i = k or j = l) then (     lights[i+1][j+1] := lights[i+1][j+1]+(a[k+1][l+1]) ) else skip ; )  ;     l := l + 1 ) )  ;     k := k + 1 ) ; 
     OclFile["System.out"].print(if lights[i+1][j+1] mod 2 = 0 then 0 else 1 endif) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class LightsOut {
  public static void main(String[] args)throws FileNotFoundException {
    FastReader in=new FastReader();
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    int[][] arr=new int[5][5];
    for(int i=1 ; i<=3 ; i++){
      for(int j=1 ; j<=3 ; j++){
        arr[i][j]=in.nextInt();
      }
    }
    for(int i=1 ; i<=3 ; i++){
      for(int j=1 ; j<=3 ; j++){
        out.print((arr[i-1][j]+arr[i][j-1]+arr[i][j]+arr[i+1][j]+arr[i][j+1]+1)% 2);
      }
      out.println();
    }
    out.close();
  }
  private static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    FastReader()throws FileNotFoundException {
      br=new BufferedReader(new InputStreamReader(System.getProperty("ONLINE_JUDGE")==null ? new FileInputStream("input.txt"): 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class LightsOut {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,5)->collect(Integer.subrange(1,5)->collect(0)) ;
        var i : int ; i := 1 ; while i <= 3 do ( (         var j : int ; j := 1 ; while j <= 3 do ( (     arr[i+1][j+1] := in.nextInt() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 3 do ( (         var j : int ; j := 1 ; while j <= 3 do ( (     skip )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(if OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null then OclFile.newOclFile_Read(OclFile.newOclFile("input.txt")) else OclFile["System.in"] endif)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class LightsOut {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int arr[][]=new int[3][3];
    int array[][]=new int[3][3];
    for(int i=0 ; i<3 ; i++){
      arr[i][0]=sc.nextInt();
      arr[i][1]=sc.nextInt();
      arr[i][2]=sc.nextInt();
      array[i][0]=1 ;
      array[i][1]=1 ;
      array[i][2]=1 ;
    }
    for(int i=0 ; i<arr.length ; i++){
      for(int j=0 ; j<arr.length ; j++){
        if((arr[i][j] & 1)==1){
          array[i][j] ^=1 ;
          if(j+1<3)array[i][j+1]=array[i][j+1] ^ 1 ;
          if(j-1>=0)array[i][j-1]=array[i][j-1] ^ 1 ;
          if(i-1>=0)array[i-1][j]=array[i-1][j] ^ 1 ;
          if(i+1<3)array[i+1][j]=array[i+1][j] ^ 1 ;
        }
      }
    }
    for(int i=0 ; i<arr.length ; i++){
      for(int j=0 ; j<arr.length ; j++){
        System.out.print(array[i][j]);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class LightsOut {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
    var array : Sequence(Sequence(int)) ; array := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < 3 do ( (     arr[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     arr[i+1][1+1] := sc.getCurrent()->toInteger() ; 
    arr[i+1][2+1] := sc.getCurrent()->toInteger() ; 
    array[i+1][0+1] := 1 ; 
    array[i+1][1+1] := 1 ; 
    array[i+1][2+1] := 1 ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (         var j : int ; j := 0 ; while j < arr->size() do ( (     if ((arr[i+1][j+1] & 1) = 1) then (     array[i+1][j+1] := MathLib.bitwiseXor(array[i+1][j+1],1) ; 
     if (j + 1 < 3) then     array[i+1][j + 1+1] := array[i+1][j + 1+1] xor 1 ; else skip ; 
    if (j - 1 >= 0) then     array[i+1][j - 1+1] := array[i+1][j - 1+1] xor 1 ; else skip ; 
    if (i - 1 >= 0) then     array[i - 1+1][j+1] := array[i - 1+1][j+1] xor 1 ; else skip ; 
    if (i + 1 < 3) then     array[i + 1+1][j+1] := array[i + 1+1][j+1] xor 1 ; else skip ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (         var j : int ; j := 0 ; while j < arr->size() do ( (     OclFile["System.out"].print(array[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.*;
import java.io.*;
public final class Solution {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int arr[][]=new int[3][3];
    for(int i=0 ; i<3 ; i++){
      String arri[]=br.readLine().split(" ");
      for(int j=0 ; j<3 ; j++)arr[i][j]=Integer.parseInt(arri[j]);
    }
    int dp[][]=new int[5][5];
    int ans[][]=new int[3][3];
    for(int i=1 ; i<=3 ; i++){
      for(int j=1 ; j<=3 ; j++){
        int k=arr[i-1][j-1];
        dp[i][j]+=k ;
        dp[i-1][j]+=k ;
        dp[i+1][j]+=k ;
        dp[i][j-1]+=k ;
        dp[i][j+1]+=k ;
      }
    }
    for(int i=1 ; i<=3 ; i++){
      for(int j=1 ; j<=3 ; j++){
        if(dp[i][j] % 2==0)ans[i-1][j-1]=1 ;
        else ans[i-1][j-1]=0 ;
        System.out.print(ans[i-1][j-1]+"");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < 3 do ( (     var arri : Sequence(String) ; arri := br.readLine()->split(" ") ;
         var j : int ; j := 0 ; while j < 3 do (     arr[i+1][j+1] := (arri[j+1])->toInteger() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,5)->collect(Integer.subrange(1,5)->collect(0)) ;
    var ans : Sequence(Sequence(int)) ; ans := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 1 ; while i <= 3 do ( (         var j : int ; j := 1 ; while j <= 3 do ( (     var k : int ; k := arr[i - 1+1][(j)->char2byte() - 1+1] ;
     dp[i+1][j+1] := dp[i+1][j+1]+(k) ; 
    dp[i - 1+1][j+1] := dp[i - 1+1][j+1]+(k) ; 
    dp[i + 1+1][j+1] := dp[i + 1+1][j+1]+(k) ; 
    dp[i+1][(j)->char2byte() - 1+1] := dp[i+1][(j)->char2byte() - 1+1]+(k) ; 
    dp[i+1][j + 1+1] := dp[i+1][j + 1+1]+(k) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 3 do ( (         var j : int ; j := 1 ; while j <= 3 do ( (     if (dp[i+1][j+1] mod 2 = 0) then     ans[i - 1+1][(j)->char2byte() - 1+1] := 1 else     ans[i - 1+1][(j)->char2byte() - 1+1] := 0 ; ;  
     OclFile["System.out"].print(ans[i - 1+1][(j)->char2byte() - 1+1] + "") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=100005 ;
  static int spf[]=new int[MAX];
  static void sieve(){
    spf[0]=1 ;
    spf[1]=-1 ;
    for(int i=2 ; i*i<MAX ; i++){
      if(spf[i]==0){
        for(int j=i*2 ; j<MAX ; j+=i){
          if(spf[j]==0){
            spf[j]=i ;
          }
        }
      }
    }
    for(int i=2 ; i<MAX ; i++){
      if(spf[i]!=1)spf[i]=i ;
    }
  }
  static int smallestInteger(int[] arr,int n){
    int gcd=0 ;
    for(int i=0 ; i<n ; i++)gcd=__gcd(gcd,arr[i]);
    return spf[gcd];
  }
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  public static void main(String[] args){
    sieve();
    int arr[]={
      2,4,8 };
      int n=arr.length ;
      System.out.println(smallestInteger(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100005;
  static   attribute spf : int := Integer.subrange(1,MAX)->collect(0);
  static   operation sieve() : void
  pre: true
  post: true
  activity: (     spf[0+1] := 1 ; 
     spf[1+1] := -1 ; 
         var i : int ; i := 2 ; while i * i < MAX do ( (     if (spf[i+1] = 0) then (         var j : int ; j := i * 2 ; while j < MAX do ( (     if (spf[j+1] = 0) then (     spf[j+1] := i ) else skip )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 2 ; while i < MAX do ( (     if (spf[i+1] /= 1) then     spf[i+1] := i ; else skip )  ;     i := i + 1 ) );
  static   operation smallestInteger( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var gcd : int ; gcd := 0 ;
         var i : int ; i := 0 ; while i < n do (     gcd := __gcd(gcd, arr[i+1]) ;  ;     i := i + 1 ) ; 
     return spf[gcd+1] );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute sieve() ; 
     var arr : Sequence(int) ; arr := Sequence{2,4,8} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(smallestInteger(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public boolean enough(int x,int m,int n,int k){
    int count=0 ;
    for(int i=1 ; i<=m ; i++){
      count+=Math.min(x/i,n);
    }
    return count>=k ;
  }
  public int findKthNumber(int m,int n,int k){
    int lo=1,hi=m*n ;
    while(lo<hi){
      int mi=lo+(hi-lo)/2 ;
      if(! enough(mi,m,n,k))lo=mi+1 ;
      else hi=mi ;
    }
    return lo ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation enough( x : int, m : int, n : int, k : int) : boolean
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i <= m do ( (     count := count+(Set{x / i, n}->min()) )  ;     i := i + 1 ) ; 
     return count >= k );
   operation findKthNumber( m : int, n : int, k : int) : int
  pre: true
  post: true
  activity: (     var lo : int ; lo := 1 ;
    var hi : int ; hi := m * n ;
     while (lo < hi) do (     var mi : int ; mi := lo + (hi - lo) / 2 ;
     if (not(enough(mi, m, n, k))) then     lo := mi + 1 ; else     hi := mi ; ) ; 
     return lo );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF603B extends PrintWriter {
  CF603B(){
    super(System.out,true);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    CF603B o=new CF603B();
    o.main();
    o.flush();
  }
  static final int MD=1000000007 ;
  long power(int a,int k){
    return k==0 ? 1 : power(a,k-1)*a % MD ;
  }
  void main(){
    int p=sc.nextInt();
    int k=sc.nextInt();
    if(k==0){
      println(power(p,p-1));
      return ;
    }
    if(k==1){
      println(power(p,p));
      return ;
    }
    long x=1 ;
    int m=0 ;
    do {
      x=x*k % p ;
      m++;
    }
    while(x!=1);
    println(power(p,(p-1)/m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF603B extends OclFile {
   static operation newCF603B() : CF603B
  pre: true
  post: true
  activity:
  ( var self : CF603B ;
    self := createCF603B();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"], true) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : CF603B ; o := CF603B.newCF603B() ;
     o.main() ; 
     o.flush() );
  static    attribute MD : int := 1000000007;
   operation power( a : int, k : int) : long
  pre: true
  post: true
  activity: (     return if k = 0 then 1 else power(a, k - 1) * a mod MD endif );
   operation main() : void
  pre: true
  post: true
  activity: (     var p : int ; p := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    if (k = 0) then (     execute println(power(p, p - 1)) ; 
     return ) else skip ; 
    if (k = 1) then (     execute println(power(p, p)) ; 
     return ) else skip ; 
    var x : long ; x := 1 ;
    var m : int ; m := 0 ;
  while true do ((     x := x * k mod p ; 
     m := m + 1 ) ;
    if (x /= 1) then skip else break) ; 
    execute println(power(p, (p - 1) / m)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.awt.geom.*;
public class Main {
  Scanner sc ;
  Main(){
    sc=new Scanner(System.in);
  }
  double ax1 ;
  double ay1 ;
  double ax2 ;
  double ay2 ;
  double bx1 ;
  double by1 ;
  double bx2 ;
  double by2 ;
  boolean init(){
    if(! sc.hasNext())return false ;
    double x1,y1,x2,y2 ;
    ax1=sc.nextDouble();
    ay1=sc.nextDouble();
    ax2=sc.nextDouble();
    ay2=sc.nextDouble();
    bx1=sc.nextDouble();
    by1=sc.nextDouble();
    bx2=sc.nextDouble();
    by2=sc.nextDouble();
    return true ;
  }
  void run(){
    while(init()){
      if(ax2>=bx1 && bx2>=ax1 && ay2>=by1 && by2>=ay1){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   attribute ax1 : double;
   attribute ay1 : double;
   attribute ax2 : double;
   attribute ay2 : double;
   attribute bx1 : double;
   attribute by1 : double;
   attribute bx2 : double;
   attribute by2 : double;
   operation init() : boolean
  pre: true
  post: true
  activity: (     if (not(sc.hasNext())) then     return false else skip ; 
     var x1 : double ;
    var y1 : double ;
    var x2 : double ;
    var y2 : double ;
    ax1 := sc.getCurrent()->toReal() ; 
    ay1 := sc.getCurrent()->toReal() ; 
    ax2 := sc.getCurrent()->toReal() ; 
    ay2 := sc.getCurrent()->toReal() ; 
    bx1 := sc.getCurrent()->toReal() ; 
    by1 := sc.getCurrent()->toReal() ; 
    bx2 := sc.getCurrent()->toReal() ; 
    by2 := sc.getCurrent()->toReal() ; 
    return true 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     while (init()) do (     if (ax2 >= bx1 & bx2 >= ax1 & ay2 >= by1 & by2 >= ay1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int D=parseInt(br.readLine());
    for(int i=0 ; i<D ; i++){
      int minx,miny,maxx,maxy ;
      int count=0 ;
      words=br.readLine().split(" ");
      minx=parseInt(words[0]);
      miny=parseInt(words[1]);
      maxx=minx+parseInt(words[2]);
      maxy=miny+parseInt(words[3]);
      int N=parseInt(br.readLine());
      for(int j=0 ; j<N ; j++){
        line=br.readLine();
        int x,y ;
        x=parseInt(line.substring(0,line.indexOf(' ')));
        y=parseInt(line.substring(line.indexOf(' ')+1));
        if(minx<=x && x<=maxx && miny<=y && y<=maxy)count++;
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var D : int ; D := parseInt(br.readLine()) ;
        var i : int ; i := 0 ; while i < D do ( (     var minx : int ;
    var miny : int ;
    var maxx : int ;
    var maxy : int ;
     var count : int ; count := 0 ;
    words := br.readLine()->split(" ") ; 
    minx := (words[0+1] + "")->toInteger() ; 
    miny := (words[1+1] + "")->toInteger() ; 
    maxx := minx + (words[2+1] + "")->toInteger() ; 
    maxy := miny + (words[3+1] + "")->toInteger() ; 
    var N : int ; N := parseInt(br.readLine()) ;
        var j : int ; j := 0 ; while j < N do ( (     line := br.readLine() ; 
     var x : int ;
    var y : int ;
    x := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    y := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    if (minx <= x & x <= maxx & miny <= y & y <= maxy) then     count := count + 1 ; else skip ; 
 )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static long MOD=1_000_000_007 ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int P=in.nextInt();
    int K=in.nextInt();
    in.close();
    long ans=calc(P,K);
    System.out.println(ans);
  }
  public static long calc(int P,int K){
    if(K==0){
      return modPow(P,P-1);
    }
    if(K==1){
      return modPow(P,P);
    }
    int count=0 ;
    boolean[] visited=new boolean[P];
    for(int i=1 ; i<visited.length ; i++){
      if(visited[i]){
        continue ;
      }
      long j=i ;
      count++;
      while(! visited[(int)j]){
        visited[(int)j]=true ;
        j=(j*K)% P ;
      }
    }
    return modPow(P,count);
  }
  public static long modPow(long base,long exp){
    base %=MOD ;
    long ans=1 ;
    while(exp>0){
      if(exp % 2==1){
        ans=(ans*base)% MOD ;
      }
      base=(base*base)% MOD ;
      exp>>=1 ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute MOD : long := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var P : int ; P := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    skip ; 
    var ans : long ; ans := calc(P, K) ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation calc( P : int, K : int) : long
  pre: true
  post: true
  activity: (     if (K = 0) then (     return modPow(P, P - 1) ) else skip ; 
     if (K = 1) then (     return modPow(P, P) ) else skip ; 
    var count : int ; count := 0 ;
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,P)->collect(false) ;
        var i : int ; i := 1 ; while i < visited->size() do ( (     if (visited[i+1]) then (     continue ) else skip ; 
     var j : long ; j := i ;
     count := count + 1 ; 
     while (not(visited[j->oclAsType(int)+1])) do (     visited[j->oclAsType(int)+1] := true ; 
     j := (j * K) mod P ) )  ;     i := i + 1 ) ; 
    return modPow(P, count) 
 );
  static   operation modPow( base : long, exp : long) : long
  pre: true
  post: true
  activity: (     base := base mod MOD ; 
     var ans : long ; ans := 1 ;
     while (exp > 0) do (     if (exp mod 2 = 1) then (     ans := (ans * base) mod MOD ) else skip ; 
     base := (base * base) mod MOD ; 
     exp := exp/(2->pow(1)) ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] u=new int[n-1];
    int[] v=new int[n-1];
    for(int i=0 ; i<n-1 ; ++i){
      u[i]=sc.nextInt()-1 ;
      v[i]=sc.nextInt()-1 ;
    }
    System.out.println(solve(u,v,k));
    sc.close();
  }
  static long solve(int[] u,int[] v,int k){
    int n=u.length+1 ;
    @ SuppressWarnings("unchecked")List<Integer>[] adjLists=new List[n];
    for(int i=0 ; i<adjLists.length ; ++i){
      adjLists[i]=new ArrayList<>();
    }
    for(int i=0 ; i<u.length ; ++i){
      adjLists[u[i] ] .add(v[i]);
      adjLists[v[i] ] .add(u[i]);
    }
    List<Integer>deltas=new ArrayList<>();
    search(deltas,adjLists,new boolean[n],0,0);
    return deltas.stream().sorted(Collections.reverseOrder()).limit(k).mapToLong(x->x).sum();
  }
  static int search(List<Integer>deltas,List<Integer>[] adjLists,boolean[] visited,int node,int depth){
    visited[node]=true ;
    int childNum=0 ;
    for(int adj : adjLists[node]){
      if(! visited[adj]){
        childNum+=search(deltas,adjLists,visited,adj,depth+1);
      }
    }
    deltas.add(depth-childNum);
    return childNum+1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var u : Sequence(int) ; u := Integer.subrange(1,n - 1)->collect(0) ;
    var v : Sequence(int) ; v := Integer.subrange(1,n - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     u[i+1] := sc.getCurrent()->toInteger() - 1 ; 
     v[i+1] := sc.getCurrent()->toInteger() - 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(u, v, k)) ; 
    skip ; 
 );
  static   operation solve( u : Sequence(int), v : Sequence(int), k : int) : long
  pre: true
  post: true
  activity: (     var n : int ; n := u->size() + 1 ;
     var adjLists : Sequence(Sequence(int)) ; adjLists := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < adjLists->size() do ( (     adjLists[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < u->size() do ( (     adjLists[u[i+1]+1]->excludes(v[i+1]) ; 
     adjLists[v[i+1]+1]->excludes(u[i+1]) )  ;     i := i + 1 ) ; 
    var deltas : Sequence(int) ; deltas := Sequence{} ;
    execute search(deltas, adjLists, Integer.subrange(1,n)->collect(false), 0, 0) ; 
    return deltas->sort().subrange(1,k)->collect( _x1 | (lambda x : OclAny in x)->apply(_x1) )->sum() 
 );
  static   operation search( deltas : Sequence(int), adjLists : Sequence(Sequence(int)), visited : Sequence(boolean), node : int, depth : int) : int
  pre: true
  post: true
  activity: (     visited[node+1] := true ; 
     var childNum : int ; childNum := 0 ;
    for (adj : adjLists[node+1]) do ( (     if (not(visited[adj+1])) then (     childNum := childNum+(search(deltas, adjLists, visited, adj, depth + 1)) ) else skip )  ) ; 
    deltas := deltas->including(depth - childNum) ; 
    return childNum + 1 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Vector missing_elements(Vector vec){
    Vector mis=new Vector();
    for(int i=0 ; i<vec.size(); i++){
      int temp=Math.abs((int)vec.get(i))-1 ;
      if((int)vec.get(temp)>0)vec.set(temp,-(int)vec.get(temp));
      else vec.set(temp,vec.get(temp));
    }
    for(int i=0 ; i<vec.size(); i++){
      if((int)vec.get(i)>0)mis.add(i+1);
    }
    return mis ;
  }
  public static void main(String args[]){
    Vector vec=new Vector();
    vec.add(3);
    vec.add(3);
    vec.add(3);
    vec.add(5);
    vec.add(1);
    Vector miss_ele=missing_elements(vec);
    for(int i=0 ; i<miss_ele.size(); i++)System.out.print(miss_ele.get(i)+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation missing_elements( vec : Sequence) : Sequence
  pre: true
  post: true
  activity: (     var mis : Sequence ; mis := Sequence{} ;
         var i : int ; i := 0 ; while i < vec->size() do ( (     var temp : int ; temp := if vec->at(i+1)->oclAsType(int) < 0 then -(vec->at(i+1)->oclAsType(int)) else vec->at(i+1)->oclAsType(int) endif - 1 ;
     if (vec->at(temp+1)->oclAsType(int) > 0) then     vec := vec.setAt(temp+1, -vec->at(temp+1)->oclAsType(int)) ; else     vec := vec.setAt(temp+1, vec->at(temp+1)) ; )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < vec->size() do ( (     if (vec->at(i+1)->oclAsType(int) > 0) then     mis := mis->including(i + 1) ; else skip )  ;     i := i + 1 ) ; 
     return mis );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var vec : Sequence ; vec := Sequence{} ;
     vec := vec->including(3) ; 
    vec := vec->including(3) ; 
    vec := vec->including(3) ; 
    vec := vec->including(5) ; 
    vec := vec->including(1) ; 
    var miss_ele : Sequence ; miss_ele := missing_elements(vec) ;
        var i : int ; i := 0 ; while i < miss_ele->size() do (     OclFile["System.out"].print(miss_ele->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int height=sc.nextInt();
    int left=sc.nextInt();
    int right=sc.nextInt();
    int types=0 ;
    for(int i=left ; i<=right ; i++){
      if(height % i==0){
        types++;
      }
    }
    System.out.println(types);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var height : int ; height := sc.getCurrent()->toInteger() ;
    var left : int ; left := sc.getCurrent()->toInteger() ;
    var right : int ; right := sc.getCurrent()->toInteger() ;
    var types : int ; types := 0 ;
        var i : int ; i := left ; while i <= right do ( (     if (height mod i = 0) then (     types := types + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(types) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt(),a=sc.nextInt(),b=sc.nextInt();
    int ans=0 ;
    for(int i=a ; i<=b ; i++){
      if(h % i==0)ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := a ; while i <= b do ( (     if (h mod i = 0) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      while(sc.hasNext()){
        final int H=sc.nextInt();
        final int A=sc.nextInt();
        final int B=sc.nextInt();
        System.out.println(solver(H,A,B));
      }
    }
  }
  private static int solver(int h,int a,int b){
    int ans=0 ;
    for(int i=a ; i<=b ; i++){
      if(h % i==0){
        ans++;
      }
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (sc.hasNext()) do (     var H : int ; H := sc.getCurrent()->toInteger() ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solver(H, A, B)) ) ))  );
  static   operation solver( h : int, a : int, b : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := a ; while i <= b do ( (     if (h mod i = 0) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int H,A,B ;
    H=sc.nextInt();
    A=sc.nextInt();
    B=sc.nextInt();
    int ans=0 ;
    for(int i=A ; i<=B ; i++){
      if(H % i==0)ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ;
    var A : int ;
    var B : int ;
    H := sc.getCurrent()->toInteger() ; 
    A := sc.getCurrent()->toInteger() ; 
    B := sc.getCurrent()->toInteger() ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := A ; while i <= B do ( (     if (H mod i = 0) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int a,b,total ;
    while(scan.hasNextInt()){
      a=scan.nextInt();
      b=scan.nextInt();
      total=a+b ;
      int i=1 ;
      while(true){
        total=total/10 ;
        if(total==0){
          System.out.println(i);
          break ;
        }
        i++;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ;
    var b : int ;
    var total : int ;
     while (scan.hasNextInt()) do (     a := scan.getCurrent()->toInteger() ; 
     b := scan.getCurrent()->toInteger() ; 
    total := a + b ; 
    var i : int ; i := 1 ;
    while (true) do (     total := total / 10 ; 
     if (total = 0) then (     OclFile["System.out"].println(i) ; 
     break ) else skip ; 
     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.stream.*;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    br.lines().parallel().map(line->String.valueOf(Stream.of(line.split(" ")).mapToInt(Integer :: parseInt).sum()).length()).sequential().forEach(System.out :: println);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     for _forEach : br.lines()->collect( _x1 | (lambda line : OclAny in ((Sequence{line->split(" ")}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->sum()) + "")->size())->apply(_x1) ) do
    (    skip ;) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void find_numbers(int N){
    if(N==1){
      System.out.print(-1);
    }
    else {
      System.out.print(N+" "+(N+1)+" "+(N*(N+1)));
    }
  }
  public static void main(String[] args){
    int N=5 ;
    find_numbers(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find_numbers( N : int) : void
  pre: true
  post: true
  activity: (     if (N = 1) then (     OclFile["System.out"].print(-1) ) else (     OclFile["System.out"].print(N + " " + (N + 1) + " " + (N * (N + 1))) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     execute find_numbers(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.security.spec.RSAOtherPrimeInfo ;
import java.util.*;
public class Main {
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      Integer[] a=new Integer[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      Arrays.sort(a);
      if(n % 2==0)out.println(a[n/2-1]);
      else out.println(a[n/2]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    if (n mod 2 = 0) then     skip else     skip ; ;  
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine())!=null){
      String[] tokens=line.split(" ");
      Integer result=Integer.parseInt(tokens[0])+Integer.parseInt(tokens[1]);
      System.out.println(result.toString().length());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     var tokens : Sequence(String) ; tokens := line->split(" ") ;
     var result : int ; result := (tokens[0+1])->toInteger() + (tokens[1+1])->toInteger() ;
     OclFile["System.out"].println(result+""->size()) ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] aa=new int[2];
    int i=1 ;
    while(sc.hasNext()){
      if(i % 2!=0){
        aa[0]=sc.nextInt();
        i++;
      }
      else {
        aa[1]=sc.nextInt();
        int c=aa[0]+aa[1];
        int digit=0 ;
        while(c>=10){
          c=c/10 ;
          digit++;
        }
        System.out.println(digit+1);
        i++;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var aa : Sequence(int) ; aa := Integer.subrange(1,2)->collect(0) ;
     var i : int ; i := 1 ;
     while (sc.hasNext()) do (     if (i mod 2 /= 0) then (     aa[0+1] := sc.getCurrent()->toInteger() ; 
     i := i + 1 ) else (     aa[1+1] := sc.getCurrent()->toInteger() ; 
     var c : int ; c := aa[0+1] + aa[1+1] ;
    var digit : int ; digit := 0 ;
    while (c >= 10) do (     c := c / 10 ; 
     digit := digit + 1 ) ; 
    OclFile["System.out"].println(digit + 1) ; 
    i := i + 1 ; 
 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Scanner ;
public class Main {
  static int digit(int a,int b){
    int x=a+b ;
    int d=0 ;
    while(x>0){
      d++;
      x/=10 ;
    }
    return d ;
  }
  public static void main(String[] args)throws IOException {
    Scanner stdIn=null ;
    final int NUM=1000 ;
    int[][] p=new int[NUM][2];
    try {
      stdIn=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
      int i=0 ;
      while(stdIn.hasNext()){
        if(stdIn.hasNextInt()){
          p[i][0]=stdIn.nextInt();
          p[i][1]=stdIn.nextInt();
        }
        else {
          stdIn.next();
        }
        i++;
      }
      for(int j=0 ; j<i ; j++){
        System.out.println(digit(p[j][0],p[j][1]));
      }
    }
    finally {
      if(stdIn!=null){
        stdIn.close();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation digit( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := a + b ;
     var d : int ; d := 0 ;
     while (x > 0) do (     d := d + 1 ; 
     x := x/(10) ) ; 
     return d );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := null ;
     var NUM : int ; NUM := 1000 ;
     var p : Sequence(Sequence(int)) ; p := Integer.subrange(1,NUM)->collect(Integer.subrange(1,2)->collect(0)) ;
     try (     stdIn := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ; 
     var i : int ; i := 0 ;
     while (stdIn.hasNext()) do (     if (stdIn.hasNextInt()) then (     p[i+1][0+1] := stdIn.getCurrent()->toInteger() ; 
     p[i+1][1+1] := stdIn.getCurrent()->toInteger() ) else (     skip ) ;  
     i := i + 1 ) ; 
         var j : int ; j := 0 ; while j < i do ( (     OclFile["System.out"].println(digit(p[j+1][0+1], p[j+1][1+1])) )  ;     j := j + 1 ) )   finally (     if (stdIn /= null) then (     skip ) else skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int r=sc.nextInt();
    int g=sc.nextInt();
    int b=sc.nextInt();
    int ans=0 ;
    ans=(r/3+g/3+b/3)+(int)Math.min(r % 3,(int)Math.min(g % 3,b % 3));
    if(r>1 && g>1 && b>1){
      ans=(int)Math.max(ans,1+(r-1)/3+(g-1)/3+(b-1)/3+(int)Math.min((r-1)% 3,(int)Math.min((g-1)% 3,(b-1)% 3)));
    }
    if(r>2 && g>2 && b>2){
      ans=(int)Math.max(ans,2+(r-2)/3+(g-2)/3+(b-2)/3+(int)Math.min((r-2)% 3,(int)Math.min((g-2)% 3,(b-2)% 3)));
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var g : int ; g := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    ans := (r / 3 + g / 3 + b / 3) + Set{r mod 3, Set{g mod 3, b mod 3}->min()->oclAsType(int)}->min()->oclAsType(int) ; 
    if (r > 1 & g > 1 & b > 1) then (     ans := Set{ans, 1 + (r - 1) / 3 + (g - 1) / 3 + (b - 1) / 3 + Set{(r - 1) mod 3, Set{(g - 1) mod 3, (b - 1) mod 3}->min()->oclAsType(int)}->min()->oclAsType(int)}->max()->oclAsType(int) ) else skip ; 
    if (r > 2 & g > 2 & b > 2) then (     ans := Set{ans, 2 + (r - 2) / 3 + (g - 2) / 3 + (b - 2) / 3 + Set{(r - 2) mod 3, Set{(g - 2) mod 3, (b - 2) mod 3}->min()->oclAsType(int)}->min()->oclAsType(int)}->max()->oclAsType(int) ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class ciel_and_flowers {
  public static void main(String[] args){
    Kattio io=new Kattio();
    int[] arr=new int[3];
    for(int i=0 ; i<3 ; i++){
      arr[i]=io.nextInt();
    }
    Arrays.sort(arr);
    if(arr[0]!=0 &&(arr[1]-(arr[0]-1))% 3==0 &&(arr[2]-(arr[0]-1))% 3==0){
      io.println(arr[0]-1+(arr[1]-(arr[0]-1))/3+(arr[2]-(arr[0]-1))/3);
    }
    else {
      io.println(arr[0]+(arr[1]-arr[0])/3+(arr[2]-arr[0])/3);
    }
    io.close();
  }
  static class Kattio extends PrintWriter {
    private BufferedReader r ;
    private StringTokenizer st ;
    public Kattio(){
      this(System.in,System.out);
    }
    public Kattio(InputStream i,OutputStream o){
      super(o);
      r=new BufferedReader(new InputStreamReader(i));
    }
    public Kattio(String problemName)throws IOException {
      super(problemName+".out");
      r=new BufferedReader(new FileReader(problemName+".in"));
    }
    public String next(){
      try {
        while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(r.readLine());
        return st.nextToken();
      }
      catch(Exception e){
      }
      return null ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ciel_and_flowers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : Kattio ; io := Kattio.newKattio() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     arr[i+1] := io.nextInt() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    if (arr[0+1] /= 0 & (arr[1+1] - (arr[0+1] - 1)) mod 3 = 0 & (arr[2+1] - (arr[0+1] - 1)) mod 3 = 0) then (     io.println(arr[0+1] - 1 + (arr[1+1] - (arr[0+1] - 1)) / 3 + (arr[2+1] - (arr[0+1] - 1)) / 3) ) else (     io.println(arr[0+1] + (arr[1+1] - arr[0+1]) / 3 + (arr[2+1] - arr[0+1]) / 3) ) ;  
    io.close() ; 
 );
  static class Kattio extends OclFile {
   attribute r : OclFile;
   attribute st : OclIterator;
   static operation newKattio() : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute this(OclFile["System.in"], OclFile["System.out"]) );
   static operation newKattio( i : OclFile, o : OclFile) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(i, o);
    return self );
  operation initialise( i : OclFile, o : OclFile) : void
  pre: true  post: true
  activity: (     execute super(o) ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(i)) );
   static operation newKattio( problemName : String) : Kattio
  pre: true
  post: true
  activity:
  ( var self : Kattio ;
    self := createKattio();
    self.initialise(problemName);
    return self );
  operation initialise( problemName : String) : void
  pre: true  post: true
  activity: (     execute super(problemName + ".out") ; 
     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(problemName + ".in")) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(r.readLine()) ; ; 
     return st.next() )   catch (e : ProgramException) do skip
     return null );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.Math ;
class CloseSum {
  static void printClosest(int arr[],int n,int x){
    int res_l=0,res_r=0 ;
    int l=0,r=n-1,diff=Integer.MAX_VALUE ;
    while(r>l){
      if(Math.abs(arr[l]+arr[r]-x)<diff){
        res_l=l ;
        res_r=r ;
        diff=Math.abs(arr[l]+arr[r]-x);
      }
      if(arr[l]+arr[r]>x)r--;
      else l++;
    }
    System.out.println(" The closest pair is "+arr[res_l]+" and "+arr[res_r]);
  }
  public static void main(String[] args){
    int arr[]={
      10,22,28,29,30,40 },x=54 ;
      int n=arr.length ;
      printClosest(arr,n,x);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class CloseSum {
  static   operation printClosest( arr : Sequence(int), n : int, x : int) : void
  pre: true
  post: true
  activity: (     var res_l : int ; res_l := 0 ;
    var res_r : int ; res_r := 0 ;
     var l : int ; l := 0 ;
    var r : int ; r := n - 1 ;
    var diff : int ; diff := 2147483647 ;
     while (r > l) do (     if (if arr[l+1] + arr[r+1] - x < 0 then -(arr[l+1] + arr[r+1] - x) else arr[l+1] + arr[r+1] - x endif < diff) then (     res_l := l ; 
     res_r := r ; 
     diff := if arr[l+1] + arr[r+1] - x < 0 then -(arr[l+1] + arr[r+1] - x) else arr[l+1] + arr[r+1] - x endif ) else skip ; 
     if (arr[l+1] + arr[r+1] > x) then     r := r - 1 ; else     l := l + 1 ; ) ; 
     OclFile["System.out"].println(" The closest pair is " + arr[res_l+1] + " and " + arr[res_r+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,22,28,29,30,40} ;
    var x : int ; x := 54 ;
     var n : int ; n := arr->size() ;
     execute printClosest(arr, n, x) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.*;
class Geeks {
  public static void main(String a[]){
    int x=10 ;
    int y=5 ;
    x=x+y ;
    y=x-y ;
    x=x-y ;
    System.out.println("After swaping:"+" x="+x+",y="+y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Geeks {
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 10 ;
     var y : int ; y := 5 ;
    x := x + y ; 
    y := x - y ; 
    x := x - y ; 
    OclFile["System.out"].println("After swaping:" + " x=" + x + ",y=" + y) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int i=0,n,a,k ;
    Scanner sc=new Scanner(System.in);
    k=sc.nextInt();
    n=sc.nextInt();
    int b[]=new int[k];
    while(i<n){
      a=sc.nextInt();
      if(b[a % k]==1){
        System.out.println(i+1);
        System.exit(0);
      }
      b[a % k]=1 ;
      i++;
    }
    System.out.println("-1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var n : int ;
    var a : int ;
    var k : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    k := sc.getCurrent()->toInteger() ; 
    n := sc.getCurrent()->toInteger() ; 
    var b : Sequence(int) ; b := Integer.subrange(1,k)->collect(0) ;
    while (i < n) do (     a := sc.getCurrent()->toInteger() ; 
     if (b[a mod k+1] = 1) then (     OclFile["System.out"].println(i + 1) ; 
 OclProcess.exit(0) ) else skip ; 
     b[a mod k+1] := 1 ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println("-1") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int i=0,n,a,p ;
    Scanner sc=new Scanner(System.in);
    p=sc.nextInt();
    n=sc.nextInt();
    int d[]=new int[p];
    while(i<n){
      a=sc.nextInt();
      if(d[a % p]==1){
        System.out.println(i+1);
        System.exit(0);
      }
      d[a % p]=1 ;
      i++;
    }
    System.out.println("-1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var n : int ;
    var a : int ;
    var p : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    p := sc.getCurrent()->toInteger() ; 
    n := sc.getCurrent()->toInteger() ; 
    var d : Sequence(int) ; d := Integer.subrange(1,p)->collect(0) ;
    while (i < n) do (     a := sc.getCurrent()->toInteger() ; 
     if (d[a mod p+1] = 1) then (     OclFile["System.out"].println(i + 1) ; 
 OclProcess.exit(0) ) else skip ; 
     d[a mod p+1] := 1 ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println("-1") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int p=sc.nextInt();
    int n=sc.nextInt();
    int rem[]=new int[300];
    for(int i=1 ; i<=n ; i++){
      int x=sc.nextInt();
      int r=x % p ;
      if(rem[r]==1){
        System.out.println(i);
        return ;
      }
      rem[r]=1 ;
    }
    System.out.println("-1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : int ; p := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var rem : Sequence(int) ; rem := Integer.subrange(1,300)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var r : int ; r := x mod p ;
     if (rem[r+1] = 1) then (     OclFile["System.out"].println(i) ; 
     return ) else skip ; 
     rem[r+1] := 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("-1") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void sortDiagonal(int a[][],int M,int N){
    for(int i=0 ; i<M ; i++){
      int sm=a[i][i];
      int pos=i ;
      for(int j=i+1 ; j<N ; j++){
        if(sm>a[j][j]){
          sm=a[j][j];
          pos=j ;
        }
      }
      swap(a,i,i,pos,pos);
    }
    for(int i=0 ; i<M ; i++){
      for(int j=0 ; j<N ; j++)System.out.print(a[i][j]+" ");
      System.out.println();
    }
  }
  static void swap(int[][] a,int i,int i2,int pos,int pos2){
    int temp=a[i][i2];
    a[i][i2]=a[pos][pos2];
    a[pos][pos2]=temp ;
  }
  public static void main(String[] args){
    int a[][]={
      {
        4,2 },{
          3,1 }
        };
        sortDiagonal(a,2,2);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sortDiagonal( a : Sequence(Sequence(int)), M : int, N : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < M do ( (     var sm : int ; sm := a[i+1][i+1] ;
     var pos : int ; pos := i ;
         var j : int ; j := i + 1 ; while j < N do ( (     if (sm > a[j+1][j+1]) then (     sm := a[j+1][j+1] ; 
     pos := j ) else skip )  ;     j := j + 1 ) ; 
     execute swap(a, i, i, pos, pos) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < M do ( (         var j : int ; j := 0 ; while j < N do (     OclFile["System.out"].print(a[i+1][j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation swap( a : Sequence(Sequence(int)), i : int, i2 : int, pos : int, pos2 : int) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := a[i+1][i2+1] ;
     a[i+1][i2+1] := a[pos+1][pos2+1] ; 
     a[pos+1][pos2+1] := temp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(Sequence(int)) ; a := Sequence{Sequence{4,2},Sequence{3,1}} ;
     execute sortDiagonal(a, 2, 2) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class App {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int p=scan.nextInt();
    int n=scan.nextInt();
    int[] numbers=new int[300];
    for(int i=0 ; i<n ; i++){
      numbers[i]=scan.nextInt();
    }
    scan.close();
    int numberOfElementsAddedToBucket=0 ;
    Set addedToBucket=new HashSet<Integer>();
    for(int i=0 ; i<n ; i++){
      addedToBucket.add(numbers[i] % p);
      Integer sizeOfBucket=addedToBucket.size();
      if(sizeOfBucket.equals(numberOfElementsAddedToBucket)){
        System.out.println(i+1);
        return ;
      }
      numberOfElementsAddedToBucket=sizeOfBucket ;
    }
    System.out.println("-1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : int ; p := scan.getCurrent()->toInteger() ;
    var n : int ; n := scan.getCurrent()->toInteger() ;
    var numbers : Sequence(int) ; numbers := Integer.subrange(1,300)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     numbers[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var numberOfElementsAddedToBucket : int ; numberOfElementsAddedToBucket := 0 ;
    var addedToBucket : Set ; addedToBucket := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     addedToBucket := addedToBucket->including(numbers[i+1] mod p) ; 
     var sizeOfBucket : int ; sizeOfBucket := addedToBucket->size() ;
     if (sizeOfBucket = numberOfElementsAddedToBucket) then (     OclFile["System.out"].println(i + 1) ; 
     return ) else skip ; 
     numberOfElementsAddedToBucket := sizeOfBucket )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("-1") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int bankNotes(int A,int B,int S,int N){
    int numerator=S-(B*N);
    int denominator=A-B ;
    if(numerator % denominator==0)return(numerator/denominator);
    return-1 ;
  }
  public static void main(String[] args){
    int A=1,B=2,S=7,N=5 ;
    System.out.print(bankNotes(A,B,S,N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation bankNotes( A : int, B : int, S : int, N : int) : int
  pre: true
  post: true
  activity: (     var numerator : int ; numerator := S - (B * N) ;
     var denominator : int ; denominator := A - B ;
     if (numerator mod denominator = 0) then     return (numerator / denominator) else skip ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 1 ;
    var B : int ; B := 2 ;
    var S : int ; S := 7 ;
    var N : int ; N := 5 ;
     OclFile["System.out"].print(bankNotes(A, B, S, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void TwentyoneMatchstick(int arr[],int N){
    for(int i=0 ; i<N ; i+=1){
      System.out.print(5-arr[i]+" ");
    }
    System.out.println();
  }
  public static void main(String[] args){
    int arr[]={
      3,4,2,2 };
      int N=arr.length ;
      TwentyoneMatchstick(arr,N);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation TwentyoneMatchstick( arr : Sequence(int), N : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].print(5 - arr[i+1] + " ") )  ;     i := i+(1) ) ; 
     OclFile["System.out"].println() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,4,2,2} ;
     var N : int ; N := arr->size() ;
     execute TwentyoneMatchstick(arr, N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String S=scan.next();
    int ans=0 ;
    if(S.length()% 2==0){
      if(S.charAt(S.length()/2-1)!=S.charAt(S.length()/2)){
        System.out.println(S.length()/2);
        return ;
      }
      else {
        S=S.substring(0,S.length()/2)+S.substring(S.length()/2+1);
        ans=1 ;
      }
    }
    int mid=S.length()/2 ;
    for(int i=1 ; i+mid<=S.length(); ++i){
      if(i+mid==S.length()|| S.charAt(mid+i)!=S.charAt(mid)|| S.charAt(mid-i)!=S.charAt(mid)){
        ans+=mid+i ;
        break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := scan.getCurrent() ;
    var ans : int ; ans := 0 ;
    if (S->size() mod 2 = 0) then (     if (S->at(S->size() / 2 - 1+1) /= S->at(S->size() / 2+1)) then (     OclFile["System.out"].println(S->size() / 2) ; 
     return ) else (     S := S.subrange(0+1,S->size() / 2) + S.subrange(S->size() / 2 + 1+1,S->size() / 2 + 1) ; 
     ans := 1 ) ) else skip ; 
    var mid : int ; mid := S->size() / 2 ;
        var i : int ; i := 1 ; while i + mid <= S->size() do ( (     if (i + mid = S->size() or S->at(mid + i+1) /= S->at(mid+1) or S->at(mid - i+1) /= S->at(mid+1)) then (     ans := ans+(mid + i) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.util.InputMismatchException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskD solver=new TaskD();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskD {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      String s=in.nextString();
      int n=s.length();
      int ans=n ;
      for(int i=0 ; i<n-1 ; i++){
        if(s.charAt(i)!=s.charAt(i+1)){
          ans=Math.min(ans,Math.max(i+1,n-1-i));
        }
      }
      out.println(ans);
    }
  }
  static class InputReader {
    BufferedReader in ;
    StringTokenizer tok ;
    public String nextString(){
      while(! tok.hasMoreTokens()){
        try {
          tok=new StringTokenizer(in.readLine()," ");
        }
        catch(IOException e){
          throw new InputMismatchException();
        }
      }
      return tok.nextToken();
    }
    public InputReader(InputStream inputStream){
      in=new BufferedReader(new InputStreamReader(inputStream));
      tok=new StringTokenizer("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskD ; solver := TaskD.newTaskD() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskD {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.nextString() ;
     var n : int ; n := s->size() ;
    var ans : int ; ans := n ;
        var i : int ; i := 0 ; while i < (n)->char2byte() - 1 do ( (     if (s->at(i+1) /= s->at(i + 1+1)) then (     ans := Set{ans, Set{i + 1, (n)->char2byte() - 1 - i}->max()}->min() ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute in : OclFile;
   attribute tok : OclIterator;
   operation nextString() : String
  pre: true
  post: true
  activity: (     while (not(tok.hasNext())) do (     try (     tok := OclIterator.newOclIterator_String_String(in.readLine(), " ") )   catch (e : IOException) do (     error IncorrectElementException() )
 ) ; 
     return tok.next() );
   static operation newInputReader( inputStream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) ; 
     tok := OclIterator.newOclIterator_String("") );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    String s=sc.next();
    int n=s.length();
    int[] a=new int[n+1];
    for(int i=1 ; i<=n ; i++)a[i]=s.charAt(i-1)-'0' ;
    long res=Integer.MAX_VALUE ;
    for(int i=1 ; i<=n-1 ; i++)if(a[i]!=a[i+1])res=Math.min(res,Math.max(i,n-i));
    out.println(res==Integer.MAX_VALUE ? n : res);
    out.close();
  }
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var s : String ; s := sc.next() ;
    var n : int ; n := s->size() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := s->at(i - 1+1) - ('0')->char2byte() ;  ;     i := i + 1 ) ; 
    var res : long ; res := 2147483647 ;
        var i : int ; i := 1 ; while i <= (n)->char2byte() - 1 do (     if (a[i+1] /= a[i + 1+1]) then     res := Set{res, Set{i, (n)->char2byte() - i}->max()}->min() ; else skip ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskB solver=new TaskB();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskB {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      String s=in.next();
      int len=s.length();
      int l=1,r=s.length();
      while(l<r){
        int mid=r-(r-l)/2 ;
        boolean flag=true ;
        if(2*mid-len>1){
          for(int i=len-mid+1 ; i<mid ; ++i){
            if(s.charAt(i)!=s.charAt(len-mid)){
              flag=false ;
              break ;
            }
          }
        }
        if(flag){
          l=mid ;
        }
        else {
          r=mid-1 ;
        }
      }
      out.println(l);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskB ; solver := TaskB.newTaskB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskB {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.getCurrent() ;
     var len : int ; len := s->size() ;
    var l : int ; l := 1 ;
    var r : int ; r := s->size() ;
    while (l < r) do (     var mid : int ; mid := r - (r - l) / 2 ;
     var flag : boolean ; flag := true ;
     if (2 * mid - (len)->char2byte() > 1) then (         var i : int ; i := (len)->char2byte() - mid + 1 ; while i < mid do ( (     if (s->at(i+1) /= s->at((len)->char2byte() - mid+1)) then (     flag := false ; 
     break ) else skip )  ;     i := i + 1 ) ) else skip ; 
     if (flag) then (     l := mid ) else (     r := mid - 1 ) ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    char[] arr=in.readLine().toCharArray();
    int best=arr.length ;
    char l='-' ;
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]!=l && i!=0){
        int o=arr.length-i ;
        int m=i>o ? i : o ;
        if(m<best)best=m ;
      }
      l=arr[i];
    }
    System.out.println(best);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var arr : Sequence(String) ; arr := in.readLine()->characters() ;
    var best : int ; best := arr->size() ;
    var l : String ; l := '-' ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] /= l & i /= 0) then (     var o : int ; o := arr->size() - (i)->char2byte() ;
     var m : int ; m := if i > o then i else o endif ;
     if (m < best) then     best := m ; else skip ) else skip ; 
     l := arr[i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(best) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxLength(int[] a,int n){
    int maximum=1 ;
    int left[]=new int[n];
    int right[]=new int[n];
    for(int i=0 ; i<n ; i++){
      left[i]=1 ;
      right[i]=1 ;
    }
    for(int i=n-2 ; i>=0 ; i--){
      if(a[i]>a[i+1]){
        right[i]=right[i+1]+1 ;
      }
      maximum=Math.max(maximum,right[i]);
    }
    for(int i=1 ; i<n ; i++){
      if(a[i]<a[i-1]){
        left[i]=left[i-1]+1 ;
      }
    }
    if(n>2){
      for(int i=1 ; i<n-1 ; i++){
        if(a[i-1]>a[i+1]){
          maximum=Math.max(maximum,left[i-1]+right[i+1]);
        }
      }
    }
    return maximum ;
  }
  public static void main(String[] args){
    int arr[]={
      8,7,3,5,2,9 };
      int n=arr.length ;
      System.out.println(maxLength(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxLength( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var maximum : int ; maximum := 1 ;
     var left : Sequence(int) ; left := Integer.subrange(1,n)->collect(0) ;
    var right : Sequence(int) ; right := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     left[i+1] := 1 ; 
     right[i+1] := 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (a[i+1] > a[i + 1+1]) then (     right[i+1] := right[i + 1+1] + 1 ) else skip ; 
     maximum := Set{maximum, right[i+1]}->max() )  ;     i := i - 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] < a[i - 1+1]) then (     left[i+1] := left[i - 1+1] + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (n > 2) then (         var i : int ; i := 1 ; while i < n - 1 do ( (     if (a[i - 1+1] > a[i + 1+1]) then (     maximum := Set{maximum, left[i - 1+1] + right[i + 1+1]}->max() ) else skip )  ;     i := i + 1 ) ) else skip ; 
    return maximum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,7,3,5,2,9} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxLength(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int divisibleby37(String n1){
    int l=n1.length();
    if(n1=="0")return 0 ;
    if(l % 3==1){
      n1="00"+n1 ;
      l+=2 ;
    }
    else if(l % 3==2){
      n1="0"+n1 ;
      l+=1 ;
    }
    char[] n=n1.toCharArray();
    int gSum=0 ;
    while(l!=0){
      int gvalue ;
      if(l==2)gvalue=((int)n[(l-2)]-48)*100+((int)n[(l-1)]-48)*10 ;
      else if(l==1)gvalue=((int)n[(l-1)]-48)*100 ;
      else gvalue=((int)n[(l-3)]-48)*100+((int)n[(l-2)]-48)*10+((int)n[(l-1)]-48)*1 ;
      l=l-3 ;
      gSum=gSum+gvalue ;
    }
    if(gSum>=1000)return(divisibleby37(String.valueOf(gSum)));
    else return(gSum % 37==0)? 1 : 0 ;
  }
  public static void main(String[] args){
    String s="8955795758" ;
    if(divisibleby37(s)==1)System.out.println("True");
    else System.out.println("False");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation divisibleby37( n1 : String) : int
  pre: true
  post: true
  activity: (     var l : int ; l := n1->size() ;
     if (n1 = "0") then     return 0 else skip ; 
    if (l mod 3 = 1) then (     n1 := "00" + n1 ; 
     l := l+(2) ) else     if (l mod 3 = 2) then (     n1 := "0" + n1 ; 
     l := l+(1) ) else skip ; ;  
    var n : Sequence(String) ; n := n1->characters() ;
    var gSum : int ; gSum := 0 ;
    while (l /= 0) do (     var gvalue : int ;
     if (l = 2) then     gvalue := (n[(l - 2)+1]->oclAsType(int) - 48) * 100 + (n[(l - 1)+1]->oclAsType(int) - 48) * 10 else     if (l = 1) then     gvalue := (n[(l - 1)+1]->oclAsType(int) - 48) * 100 else     gvalue := (n[(l - 3)+1]->oclAsType(int) - 48) * 100 + (n[(l - 2)+1]->oclAsType(int) - 48) * 10 + (n[(l - 1)+1]->oclAsType(int) - 48) * 1 ; ;  ;  
     l := l - 3 ; 
     gSum := gSum + gvalue ) ; 
    if (gSum >= 1000) then     return (divisibleby37(((gSum) + ""))) else     return if (gSum mod 37 = 0) then 1 else 0 endif ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "8955795758" ;
     if (divisibleby37(s) = 1) then     OclFile["System.out"].println("True") ; else     OclFile["System.out"].println("False") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void CountSegments(int N,int a[]){
    int frequency[]=new int[10001];
    int c=0 ;
    for(int i=0 ; i<N ; i++){
      frequency[a[i] ]++;
    }
    for(int i=0 ; i<=10000 ; i++)c=Math.max(c,frequency[i]);
    System.out.println(c);
  }
  public static void main(String[] args){
    int N=6 ;
    int[] a={
      1,3,4,3,2,3 };
      CountSegments(N,a);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation CountSegments( N : int, a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var frequency : Sequence(int) ; frequency := Integer.subrange(1,10001)->collect(0) ;
     var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     frequency[a[i+1]+1] := frequency[a[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= 10000 do (     c := Set{c, frequency[i+1]}->max() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 6 ;
     var a : Sequence(int) ; a := Sequence{1,3,4,3,2,3} ;
     execute CountSegments(N, a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean checkPermutation(int[] arr,int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=arr[i];
    int[] prefix=new int[n+1];
    Arrays.fill(prefix,0);
    prefix[0]=arr[0];
    for(int i=1 ; i<n ; i++)prefix[i]=prefix[i-1]+arr[i];
    for(int i=0 ; i<n-1 ; i++){
      int lsum=prefix[i];
      int rsum=sum-prefix[i];
      int l_len=i+1,r_len=n-i-1 ;
      if(((2*lsum)==(l_len*(l_len+1)))&&((2*rsum)==(r_len*(r_len+1))))return true ;
    }
    return false ;
  }
  public static void main(String args[]){
    int[] arr={
      1,2,5,3,4,1,2 };
      int n=arr.length ;
      if(checkPermutation(arr,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkPermutation( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    var prefix : Sequence(int) ; prefix := Integer.subrange(1,n + 1)->collect(0) ;
    prefix := prefix->collect(0) ; 
    prefix[0+1] := arr[0+1] ; 
        var i : int ; i := 1 ; while i < n do (     prefix[i+1] := prefix[i - 1+1] + arr[i+1] ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var lsum : int ; lsum := prefix[i+1] ;
     var rsum : int ; rsum := sum - prefix[i+1] ;
     var l_len : int ; l_len := i + 1 ;
    var r_len : int ; r_len := n - i - 1 ;
     if (((2 * lsum) = (l_len * (l_len + 1))) & ((2 * rsum) = (r_len * (r_len + 1)))) then     return true else skip )  ;     i := i + 1 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,5,3,4,1,2} ;
     var n : int ; n := arr->size() ;
     if (checkPermutation(arr, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] s=new int[n];
    for(int i=0 ; i<n ; i++){
      s[i]=in.nextInt();
    }
    Set<Integer>list=new HashSet<>();
    for(int i=1 ; i*i<=n ; i++){
      if(n % i==0){
        list.add(i);
        list.add(n/i);
      }
    }
    list.remove(n);
    int max=1 ;
    out : for(int t : list){
      for(int i=0 ; i<n-t ; i++){
        if(s[i]!=s[i+t])continue out ;
      }
      max=Math.max(n/t,max);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var list : Set(int) ; list := Set{} ;
        var i : int ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     list := list->including(i) ; 
     list := list->including(n / i) ) else skip )  ;     i := i + 1 ) ; 
    list := list->excludingAt(n+1) ; 
    var max : int ; max := 1 ;
    for (t : list) do ( (         var i : int ; i := 0 ; while i < n - t do ( (     if (s[i+1] /= s[i + t+1]) then     continue else skip )  ;     i := i + 1 ) ; 
     max := Set{n / t, max}->max() )  ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int checkDigits(int n){
    while(n>0){
      if(((n % 10)% 2)>0)return 0 ;
      n/=10 ;
    }
    return 1 ;
  }
  static int largestNumber(int n){
    for(int i=n ; ; i--)if(checkDigits(i)>0)return i ;
  }
  static public void main(String[] args){
    int N=23 ;
    System.out.println(largestNumber(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkDigits( n : int) : int
  pre: true
  post: true
  activity: (     while (n > 0) do (     if (((n mod 10) mod 2) > 0) then     return 0 else skip ; 
     n := n/(10) ) ; 
     return 1 );
  static   operation largestNumber( n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := n ; while true do (     if (checkDigits(i) > 0) then     return i else skip ;  ;     i := i - 1 ) );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 23 ;
     OclFile["System.out"].println(largestNumber(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int l=scanner.nextInt();
    ArrayList<String>word=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      word.add(scanner.next());
    }
    boolean changed=true ;
    while(changed){
      changed=false ;
      for(int i=1 ; i<n ; i++){
        if(compare(word.get(i),word.get(i-1))){
          String tmp ;
          tmp=word.get(i);
          word.set(i,word.get(i-1));
          word.set(i-1,tmp);
          changed=true ;
        }
      }
    }
    for(String w : word){
      System.out.print(w);
    }
  }
  public static boolean compare(String str1,String str2){
    return str1.compareTo(str2)<0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var l : int ; l := scanner.getCurrent()->toInteger() ;
    var word : Sequence(String) ; word := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     word := word->including(scanner.getCurrent()) )  ;     i := i + 1 ) ; 
    var changed : boolean ; changed := true ;
    while (changed) do (     changed := false ; 
         var i : int ; i := 1 ; while i < n do ( (     if (compare(word->at(i+1), word->at(i - 1+1))) then (     var tmp : String ;
     tmp := word->at(i+1) ; 
    word := word.setAt(i+1,word->at(i - 1+1)) ; 
    word := word.setAt(i - 1+1,tmp) ; 
    changed := true ; 
 ) else skip )  ;     i := i + 1 ) ) ; 
    for (w : word) do ( (     OclFile["System.out"].print(w) )  ) ; 
 );
  static   operation compare( str1 : String, str2 : String) : boolean
  pre: true
  post: true
  activity: (     return str1->compareTo(str2) < 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
class Main {
  int n ;
  int l ;
  String[] s ;
  Main(int n,int l,String[] s){
    this.n=n ;
    this.l=l ;
    this.s=s ;
  }
  String solve(){
    String ans="" ;
    List<String>sList=new ArrayList<>(Arrays.asList(s));
    Collections.sort(sList);
    for(String si : sList){
      ans+=si ;
    }
    return ans ;
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int l=sc.nextInt();
    String[] s=new String[n];
    for(int i=0 ; i<n ; i++){
      s[i]=sc.next();
    }
    sc.close();
    String ans=new Main(n,l,s).solve();
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute l : int;
   attribute s : Sequence(String);
   static operation newMain( n : int, l : int, s : Sequence(String)) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(n, l,s);
    return self );
  operation initialise( n : int, l : int, s : Sequence(String)) : void
  pre: true  post: true
  activity: (     self.n := n ; 
     self.l := l ; 
     self.s := s );
   operation solve() : String
  pre: true
  post: true
  activity: (     var ans : String ; ans := "" ;
     var sList : Sequence(String) ; sList := Sequence{}->union(s) ;
    sList := sList->sort() ; 
    for (si : sList) do ( (     ans := ans+(si) )  ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : String ; ans := Main.newMain(n, l, s).solve() ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static MyReader in=new MyReader();
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    int N,L ;
    {
      int[] a=in.ii();
      N=a[0];
      L=a[1];
    }
    String[] S=new String[N];
    for(int i=0 ; i<N ; i++)S[i]=in.s();
    Arrays.sort(S);
    for(int i=0 ; i<N ; i++)out.print(S[i]);
    out.flush();
  }
  static class MyReader extends BufferedReader {
    MyReader(){
      super(new InputStreamReader(System.in));
    }
    String s(){
      try {
        return readLine();
      }
      catch(IOException e){
        return "" ;
      }
    }
    String[] ss(){
      return s().split(" ");
    }
    int i(){
      return Integer.parseInt(s());
    }
    int[] ii(){
      String[] ss=ss();
      int[] ii=new int[ss.length];
      for(int j=0 ; j<ss.length ; j++)ii[j]=Integer.parseInt(ss[j]);
      return ii ;
    }
    long l(){
      return Long.parseLong(s());
    }
    long[] ll(){
      String[] ss=ss();
      long[] ll=new long[ss.length];
      for(int j=0 ; j<ss.length ; j++)ll[j]=Long.parseLong(ss[j]);
      return ll ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : MyReader := MyReader.newMyReader();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ;
    var L : int ;
 (     var a : Sequence(int) ; a := in.ii() ;
     N := a[0+1] ; 
     L := a[1+1] ) 
    var S : Sequence(String) ; S := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do (     S[i+1] := in.s() ;  ;     i := i + 1 ) ; 
    S := S->sort() ; 
        var i : int ; i := 0 ; while i < N do (     skip ;  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class MyReader extends OclFile {
   static operation newMyReader() : MyReader
  pre: true
  post: true
  activity:
  ( var self : MyReader ;
    self := createMyReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation s() : String
  pre: true
  post: true
  activity: (     try (     return readLine() )   catch (e : IOException) do (     return "" )
 );
   operation ss() : Sequence(String)
  pre: true
  post: true
  activity: (     return s()->split(" ") );
   operation i() : int
  pre: true
  post: true
  activity: (     return (s())->toInteger() );
   operation ii() : Sequence(int)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var ii : Sequence(int) ; ii := Integer.subrange(1,ss->size())->collect(0) ;
         var j : int ; j := 0 ; while j < ss->size() do (     ii[j+1] := (ss[j+1])->toInteger() ;  ;     j := j + 1 ) ; 
     return ii );
   operation l() : long
  pre: true
  post: true
  activity: (     return (s())->toLong() );
   operation ll() : Sequence(long)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var ll : Sequence(long) ; ll := Integer.subrange(1,ss->size())->collect(0) ;
         var j : int ; j := 0 ; while j < ss->size() do (     ll[j+1] := (ss[j+1])->toLong() ;  ;     j := j + 1 ) ; 
     return ll );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.stream.Collectors ;
import java.util.stream.Stream ;
public class Main {
  public static void main(String[] args)throws Exception {
    String[] lines=Io.read();
    String result=Stream.of(lines).skip(1).sorted().collect(Collectors.joining());
    Io.write(result);
  }
}
class Io {
  public static String[] read()throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    List<String>inputs=new ArrayList<String>();
    String line ;
    while((line=br.readLine())!=null){
      if(line.equals(""))break ;
      inputs.add(line);
    }
    br.close();
    return inputs.toArray(new String[0]);
  }
  public static void write(String line){
    System.out.println(line);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var lines : Sequence(String) ; lines := Io.read() ;
     var result : String ; result := Sequence{lines}.subrange(1+1)->sort().collect(Collectors.joining()) ;
     Io.write(result) );
}
class Io {
  static   operation read() : Sequence(String)
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var inputs : Sequence(String) ; inputs := Sequence{} ;
    var line : String ;
        line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line = "") then     break else skip ; 
     inputs := inputs->including(line) ) ;     line := br.readLine() ;
 ) ;  
    skip ; 
    return inputs->asSequence() 
 );
  static   operation write( line : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(line) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().solve();
  }
  void solve(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int L=sc.nextInt();
    String[] s=new String[N];
    for(int i=0 ; i<N ; i++){
      s[i]=sc.next();
    }
    for(int i=N-1 ; i>=0 ; i--){
      for(int j=0 ; j<i ; j++){
        if(isLarge(s[j],s[j+1],L)==1){
          String temp=s[j];
          s[j]=s[j+1];
          s[j+1]=temp ;
        }
      }
    }
    String ans="" ;
    for(int i=0 ; i<N ; i++)ans+=s[i];
    System.out.println(ans);
  }
  int isLarge(String s1,String s2,int L){
    for(int i=0 ; i<L ; i++){
      if(s1.charAt(i)>s2.charAt(i))return 1 ;
      else if(s1.charAt(i)<s2.charAt(i))return-1 ;
    }
    return 0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var L : int ; L := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     s[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
        var i : int ; i := N - 1 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < i do ( (     if (isLarge(s[j+1], s[j + 1+1], L) = 1) then (     var temp : String ; temp := s[j+1] ;
     s[j+1] := s[j + 1+1] ; 
     s[j + 1+1] := temp ) else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < N do (     ans := ans+(s[i+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation isLarge( s1 : String, s2 : String, L : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < L do ( (     if (s1->at(i+1) > s2->at(i+1)) then     return 1 else     if (s1->at(i+1) < s2->at(i+1)) then     return -1 else skip ; )  ;     i := i + 1 ) ; 
     return 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A111 {
  static FastScanner fs=null ;
  public static void main(String[] args){
    fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    long n=fs.nextLong();
    long x=fs.nextLong();
    long y=fs.nextLong();
    long p=y-n+(long)1 ;
    long pow=p*p+n-(long)1 ;
    if(pow<x || p<=0){
      out.println("-1");
    }
    else {
      for(long i=1 ; i<n ; i++){
        out.println("1");
      }
      out.println(p);
    }
    out.println();
    out.close();
  }
  static void sort(int[] a){
    ArrayList<Integer>l=new ArrayList<>();
    for(int i : a)l.add(i);
    Collections.sort(l);
    for(int i=0 ; i<a.length ; i++)a[i]=l.get(i);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A111 {
  static   attribute fs : FastScanner := null;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     fs := FastScanner.newFastScanner() ; 
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := fs.nextLong() ;
    var x : long ; x := fs.nextLong() ;
    var y : long ; y := fs.nextLong() ;
    var p : long ; p := y - n + 1->oclAsType(long) ;
    var pow : long ; pow := p * p + n - 1->oclAsType(long) ;
    if (pow < x or p <= 0) then (     skip ) else (         var i : long ; i := 1 ; while i < n do ( (     skip )  ;     i := i + 1 ) ; 
     skip ) ;  
    skip ; 
    skip ; 
 );
  static   operation sort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     for (i : a) do (     l := l->including(i) ;  ) ; 
     l := l->sort() ; 
         var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := l->at(i+1) ;  ;     i := i + 1 ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    String[] a=new String[n];
    String[] b=new String[m];
    int x=0 ;
    int y=0 ;
    boolean end=false ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.next();
    }
    for(int i=0 ; i<m ; i++){
      b[i]=sc.next();
    }
    while(true){
      end=true ;
      for(int i=0 ; i<m ; i++){
        end=end & b[i] .equals(a[i+y] .substring(x,x+m));
      }
      if(end){
        System.out.println("Yes");
        return ;
      }
      else {
        if(x==n-m-1 && y==n-m-1){
          System.out.println("No");
          return ;
        }
        else if(x==n-m-1){
          x=0 ;
          y++;
        }
        else {
          x++;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(String) ; a := Integer.subrange(1,n)->collect(null) ;
    var b : Sequence(String) ; b := Integer.subrange(1,m)->collect(null) ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var end : boolean ; end := false ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    while (true) do (     end := true ; 
         var i : int ; i := 0 ; while i < m do ( (     end := MathLib.bitwiseAnd(end,b[i+1] = a[i + y+1].subrange(x+1,x + m)) )  ;     i := i + 1 ) ; 
     if (end) then (     OclFile["System.out"].println("Yes") ; 
     return ) else (     if (x = n - m - 1 & y = n - m - 1) then (     OclFile["System.out"].println("No") ; 
     return ) else     if (x = n - m - 1) then (     x := 0 ; 
     y := y + 1 ) else (     x := x + 1 ) ;  ) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    int n=in.nextInt();
    int m=in.nextInt();
    String[] a=new String[n];
    String[] b=new String[m];
    for(int i=0 ; i<n ; i++){
      a[i]=in.next();
    }
    for(int i=0 ; i<m ; i++){
      b[i]=in.next();
    }
    Boolean pass=true ;
    for(int i=0 ; i<n-m+1 ; i++){
      for(int j=0 ; j<n-m+1 ; j++){
        pass=true ;
        for(int k=0 ; k<m ; k++){
          if(! pass)break ;
          for(int l=0 ; l<m ; l++){
            if(a[i+k] .charAt(j+l)!=b[k] .charAt(l)){
              pass=false ;
              break ;
            }
          }
        }
        if(pass){
          System.out.println("Yes");
          return ;
        }
      }
    }
    System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var a : Sequence(String) ; a := Integer.subrange(1,n)->collect(null) ;
    var b : Sequence(String) ; b := Integer.subrange(1,m)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := in.getCurrent() )  ;     i := i + 1 ) ; 
    var pass : Boolean ; pass := true ;
        var i : int ; i := 0 ; while i < n - m + 1 do ( (         var j : int ; j := 0 ; while j < n - m + 1 do ( (     pass := true ; 
         var k : int ; k := 0 ; while k < m do ( (     if (not(pass)) then     break else skip ; 
         var l : int ; l := 0 ; while l < m do ( (     if (a[i + k+1]->at(j + l+1) /= b[k+1]->at(l+1)) then (     pass := false ; 
     break ) else skip )  ;     l := l + 1 ) )  ;     k := k + 1 ) ; 
     if (pass) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("No") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double nthHarmonic(int N){
    float harmonic=1 ;
    for(int i=2 ; i<=N ; i++){
      harmonic+=(float)1/i ;
    }
    return harmonic ;
  }
  public static void main(String[] args){
    int N=8 ;
    System.out.print(nthHarmonic(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nthHarmonic( N : int) : double
  pre: true
  post: true
  activity: (     var harmonic : double ; harmonic := 1 ;
         var i : int ; i := 2 ; while i <= N do ( (     harmonic := harmonic+(1->oclAsType(double) / i) )  ;     i := i + 1 ) ; 
     return harmonic );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 8 ;
     OclFile["System.out"].print(nthHarmonic(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    String[] a=new String[n];
    String[] b=new String[m];
    String x="" ;
    String y="" ;
    for(int i=0 ; i<n ; i++){
      a[i]=scan.next();
      x=x+a[i];
    }
    for(int i=0 ; i<m ; i++){
      b[i]=scan.next();
      y=y+b[i];
    }
    List<Integer>index=new ArrayList<Integer>();
    for(int i=0,l=0 ; i<m ; i++){
      if(a[i] .contains(b[l])){
        index.add(i);
        l++;
      }
    }
    boolean hyozi=false ;
    for(int i=0,l=index.size()-1 ; i<index.size()-1 ; i++,l--){
      if(index.get(i)+1==index.get(i+1)){
        hyozi=true ;
      }
      else if(index.get(l)+1==index.get(l-1)){
        hyozi=true ;
      }
      else {
        hyozi=false ;
      }
    }
    if(m==n){
      int count=0 ;
      for(int i=0 ; i<n ; i++){
        if(a[i] .equals(b[i])){
          count++;
        }
      }
      if(count==a.length){
        hyozi=true ;
      }
      else {
        hyozi=false ;
      }
    }
    if(hyozi==true){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var a : Sequence(String) ; a := Integer.subrange(1,n)->collect(null) ;
    var b : Sequence(String) ; b := Integer.subrange(1,m)->collect(null) ;
    var x : String ; x := "" ;
    var y : String ; y := "" ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent() ; 
     x := x + a[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := scan.getCurrent() ; 
     y := y + b[i+1] )  ;     i := i + 1 ) ; 
    var index : Sequence(int) ; index := Sequence{} ;
        var i : int ; i := 0 ;
    var l : int ; l := 0 ; while i < m do ( (     if (a[i+1]->includes(b[l+1])) then (     index := index->including(i) ; 
     l := l + 1 ) else skip )  ;     i := i + 1 ) ; 
    var hyozi : boolean ; hyozi := false ;
        var i : int ; i := 0 ;
    var l : int ; l := index->size() - 1 ; while i < index->size() - 1 do ( (     if (index->at(i+1) + 1 = index->at(i + 1+1)) then (     hyozi := true ) else     if (index->at(l+1) + 1 = index->at(l - 1+1)) then (     hyozi := true ) else (     hyozi := false ) ;  )  ;     i := i + 1 ;     l := l - 1 ) ; 
    if (m = n) then (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = b[i+1]) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (count = a->size()) then (     hyozi := true ) else (     hyozi := false ) ) else skip ; 
    if (hyozi = true) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  static void possible(){
    System.out.println("Yes");
    System.exit(0);
  }
  static void impossible(){
    System.out.println("No");
    System.exit(0);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    char[][] picture=new char[N][N];
    for(int h=0 ; h<N ; h++){
      String line=sc.next();
      for(int w=0 ; w<N ; w++)picture[h][w]=line.charAt(w);
    }
    char[][] pattern=new char[M][M];
    for(int h=0 ; h<M ; h++){
      String line=sc.next();
      for(int w=0 ; w<M ; w++)pattern[h][w]=line.charAt(w);
    }
    for(int cx=0 ; cx<=N-M ; cx++)for(int cy=0 ; cy<=N-M ; cy++){
      boolean match=true ;
      for(int dx=0 ; dx<M ; dx++)for(int dy=0 ; dy<M ; dy++){
        if(picture[cx+dx][cy+dy]!=pattern[dx][dy])match=false ;
      }
      if(match)possible();
    }
    impossible();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation possible() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Yes") ; 
 OclProcess.exit(0) );
  static   operation impossible() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("No") ; 
 OclProcess.exit(0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var picture : Sequence(Sequence(String)) ; picture := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
        var h : int ; h := 0 ; while h < N do ( (     var line : String ; line := sc.getCurrent() ;
         var w : int ; w := 0 ; while w < N do (     picture[h+1][w+1] := line->at(w+1) ;  ;     w := w + 1 ) )  ;     h := h + 1 ) ; 
    var pattern : Sequence(Sequence(String)) ; pattern := Integer.subrange(1,M)->collect(Integer.subrange(1,M)->collect(0)) ;
        var h : int ; h := 0 ; while h < M do ( (     var line : String ; line := sc.getCurrent() ;
         var w : int ; w := 0 ; while w < M do (     pattern[h+1][w+1] := line->at(w+1) ;  ;     w := w + 1 ) )  ;     h := h + 1 ) ; 
        var cx : int ; cx := 0 ; while cx <= N - M do (         var cy : int ; cy := 0 ; while cy <= N - M do ( (     var match : boolean ; match := true ;
         var dx : int ; dx := 0 ; while dx < M do (         var dy : int ; dy := 0 ; while dy < M do ( (     if (picture[cx + dx+1][cy + dy+1] /= pattern[dx+1][dy+1]) then     match := false ; else skip )  ;     dy := dy + 1 ) ;  ;     dx := dx + 1 ) ; 
     if (match) then     execute possible() ; else skip )  ;     cy := cy + 1 ) ;  ;     cx := cx + 1 ) ; 
    execute impossible() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int dif=n-m+1 ;
    boolean ams[][]=new boolean[n][n];
    boolean bms[][]=new boolean[m][m];
    boolean con ;
    boolean nex ;
    String sstack ;
    for(int i=0 ; i<n ; i++){
      sstack=sc.next();
      for(int j=0 ; j<n ; j++){
        if(sstack.charAt(j)=='#')ams[i][j]=true ;
        else ams[i][j]=false ;
      }
    }
    for(int i=0 ; i<m ; i++){
      sstack=sc.next();
      for(int j=0 ; j<m ; j++){
        if(sstack.charAt(j)=='#')bms[i][j]=true ;
        else bms[i][j]=false ;
      }
    }
    nex=true ;
    for(int i=0 ; i<dif && nex ; i++){
      for(int j=0 ; j<dif && nex ; j++){
        con=true ;
        for(int k=0 ; k<m && con ; k++){
          for(int l=0 ; l<m && con ; l++){
            if(ams[i+k][j+l]!=bms[k][l])con=false ;
          }
        }
        if(con)nex=false ;
      }
    }
    if(nex)System.out.println("No");
    else System.out.println("Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var dif : int ; dif := n - m + 1 ;
    var ams : Sequence(Sequence(boolean)) ; ams := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ;
    var bms : Sequence(Sequence(boolean)) ; bms := Integer.subrange(1,m)->collect(Integer.subrange(1,m)->collect(false)) ;
    var con : boolean ;
    var nex : boolean ;
    var sstack : String ;
        var i : int ; i := 0 ; while i < n do ( (     sstack := sc.getCurrent() ; 
         var j : int ; j := 0 ; while j < n do ( (     if (sstack->at(j+1) = '#') then     ams[i+1][j+1] := true ; else     ams[i+1][j+1] := false ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     sstack := sc.getCurrent() ; 
         var j : int ; j := 0 ; while j < m do ( (     if (sstack->at(j+1) = '#') then     bms[i+1][j+1] := true ; else     bms[i+1][j+1] := false ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    nex := true ; 
        var i : int ; i := 0 ; while i < dif & nex do ( (         var j : int ; j := 0 ; while j < dif & nex do ( (     con := true ; 
         var k : int ; k := 0 ; while k < m & con do ( (         var l : int ; l := 0 ; while l < m & con do ( (     if (ams[i + k+1][j + l+1] /= bms[k+1][l+1]) then     con := false ; else skip )  ;     l := l + 1 ) )  ;     k := k + 1 ) ; 
     if (con) then     nex := false ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (nex) then     OclFile["System.out"].println("No") else     OclFile["System.out"].println("Yes") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
public class Test {
  static String getMinNumberForPattern(String seq){
    int n=seq.length();
    if(n>=9)return "-1" ;
    char result[]=new char[n+1];
    int count=1 ;
    for(int i=0 ; i<=n ; i++){
      if(i==n || seq.charAt(i)=='I'){
        for(int j=i-1 ; j>=-1 ; j--){
          result[j+1]=(char)((int)'0'+count++);
          if(j>=0 && seq.charAt(j)=='I')break ;
        }
      }
    }
    return new String(result);
  }
  public static void main(String[] args)throws IOException {
    String inputs[]={
      "IDID","I","DD","II","DIDI","IIDDD","DDIDDIID" };
      for(String input : inputs){
        System.out.println(getMinNumberForPattern(input));
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation getMinNumberForPattern( seq : String) : String
  pre: true
  post: true
  activity: (     var n : int ; n := seq->size() ;
     if (n >= 9) then     return "-1" else skip ; 
    var result : Sequence(String) ; result := Integer.subrange(1,n + 1)->collect(0) ;
    var count : int ; count := 1 ;
        var i : int ; i := 0 ; while i <= n do ( (     if (i = n or seq->at(i+1) = 'I') then (         var j : int ; j := i - 1 ; while j >= -1 do ( (      result[j + 1+1] := (('0')->char2byte() + count)->oclAsType(String)  ; count := count + 1 ; 
     if (j >= 0 & seq->at(j+1) = 'I') then     break else skip )  ;     j := j - 1 ) ) else skip )  ;     i := i + 1 ) ; 
    return StringLib.newString(result) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputs : Sequence(String) ; inputs := Sequence{"IDID","I","DD","II","DIDI","IIDDD","DDIDDIID"} ;
     for (input : inputs) do ( (     OclFile["System.out"].println(getMinNumberForPattern(input)) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public final class p146 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p146().run());
  }
  private static final int LIMIT=150000000 ;
  private static long[] INCREMENTS={
    1,3,7,9,13,27 };
    public String run(){
      long sum=0 ;
      for(int n=0 ; n<LIMIT ; n+=10){
        if(hasConsecutivePrimes(n))sum+=n ;
      }
      return Long.toString(sum);
    }
    private static long maxNumber=(long)LIMIT*LIMIT+INCREMENTS[INCREMENTS.length-1];
    private static int[] primes=Library.listPrimes((int)Library.sqrt(maxNumber));
    private static boolean hasConsecutivePrimes(int n){
      long n2=(long)n*n ;
      long[] temp=new long[INCREMENTS.length];
      for(int i=0 ; i<INCREMENTS.length ; i++)temp[i]=n2+INCREMENTS[i];
      for(int p : primes){
        for(long x : temp){
          if(x!=p && x % p==0)return false ;
        }
      }
      for(int i=1 ; i<INCREMENTS[INCREMENTS.length-1]; i++){
        if(Arrays.binarySearch(INCREMENTS,i)<0 && isPrime(n2+i))return false ;
      }
      return true ;
    }
    private static boolean isPrime(long n){
      int end=(int)Library.sqrt(n);
      for(int p : primes){
        if(p>end)break ;
        if(n!=p && n % p==0)return false ;
      }
      return true ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class p146 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p146.newp146().run()) );
  static    attribute LIMIT : int := 150000000;
  static   attribute INCREMENTS : Sequence(long) := Sequence{1,3,7,9,13,27};
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var n : int ; n := 0 ; while n < LIMIT do ( (     if (hasConsecutivePrimes(n)) then     sum := sum+(n) ; else skip )  ;     n := n+(10) ) ; 
     return ((sum) + "") );
  static   attribute maxNumber : long := LIMIT->oclAsType(long) * LIMIT + INCREMENTS[INCREMENTS->size() - 1+1];
  static   attribute primes : Sequence(int) := Library.listPrimes(Library.sqrt(maxNumber)->oclAsType(int));
  static   operation hasConsecutivePrimes( n : int) : boolean
  pre: true
  post: true
  activity: (     var n2 : long ; n2 := n->oclAsType(long) * n ;
     var temp : Sequence(long) ; temp := Integer.subrange(1,INCREMENTS->size())->collect(0) ;
        var i : int ; i := 0 ; while i < INCREMENTS->size() do (     temp[i+1] := n2 + INCREMENTS[i+1] ;  ;     i := i + 1 ) ; 
    for (p : primes) do ( (     for (x : temp) do ( (     if (x /= p & x mod p = 0) then     return false else skip )  ) )  ) ; 
        var i : int ; i := 1 ; while i < INCREMENTS[INCREMENTS->size() - 1+1] do ( (     if ((INCREMENTS->indexOf(i) - 1) < 0 & isPrime(n2 + i)) then     return false else skip )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (     var end : int ; end := Library.sqrt(n)->oclAsType(int) ;
     for (p : primes) do ( (     if (p > end) then     break else skip ; 
     if (n /= p & n mod p = 0) then     return false else skip )  ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    int[][] a=new int[H][W];
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        a[i][j]=sc.nextInt();
      }
    }
    int m=0 ;
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        m=solve(a,i,j,H,W);
        if(m<min)min=m ;
      }
    }
    System.out.println(min);
  }
  static int solve(int[][] a,int x,int y,int H,int W){
    int m=0 ;
    int diffH=0 ;
    int diffW=0 ;
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        diffH=Math.abs(x-i);
        diffW=Math.abs(y-j);
        m+=Math.min(diffH,diffW)*a[i][j];
      }
    }
    return m ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     a[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var m : int ; m := 0 ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     m := solve(a, i, j, H, W) ; 
     if (m < min) then     min := m ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
  static   operation solve( a : Sequence(Sequence(int)), x : int, y : int, H : int, W : int) : int
  pre: true
  post: true
  activity: (     var m : int ; m := 0 ;
     var diffH : int ; diffH := 0 ;
    var diffW : int ; diffW := 0 ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     diffH := if x - i < 0 then -(x - i) else x - i endif ; 
     diffW := if y - j < 0 then -(y - j) else y - j endif ; 
     m := m+(Set{diffH, diffW}->min() * a[i+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return m 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  static final int INF=1<<29 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    line=br.readLine();
    int H,W ;
    H=parseInt(line.substring(0,line.indexOf(' ')));
    W=parseInt(line.substring(line.indexOf(' ')+1));
    int[][] map=new int[H][W];
    for(int i=0 ; i<H ; i++){
      StringTokenizer st=new StringTokenizer(br.readLine());
      for(int j=0 ; j<W ; j++){
        map[i][j]=parseInt(st.nextToken());
      }
    }
    int ans=INF ;
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        int sum=0 ;
        for(int m=0 ; m<H ; m++){
          for(int n=0 ; n<W ; n++){
            sum+=Math.min(Math.abs(i-m),Math.abs(j-n))*map[m][n];
          }
        }
        ans=Math.min(ans,sum);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := (1*(2->pow(29)))->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    line := br.readLine() ; 
    var H : int ;
    var W : int ;
    H := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    W := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var i : int ; i := 0 ; while i < H do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
         var j : int ; j := 0 ; while j < W do ( (     map[i+1][j+1] := (st.next() + "")->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := INF ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     var sum : int ; sum := 0 ;
         var m : int ; m := 0 ; while m < H do ( (         var n : int ; n := 0 ; while n < W do ( (     sum := sum+(Set{if i - m < 0 then -(i - m) else i - m endif, if j - n < 0 then -(j - n) else j - n endif}->min() * map[m+1][n+1]) )  ;     n := n + 1 ) )  ;     m := m + 1 ) ; 
     ans := Set{ans, sum}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
public class a_Quasi_palindrome {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long y=sc.nextLong();
    long x=sc.nextLong();
    if(!(1l*n-1+(x-n+1)*(x-n+1)>=y)||(x-n+1)<=0)System.out.println(-1);
    else {
      System.out.println(x-n+1);
      while(n-1>0){
        System.out.println(1);
        n--;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class a_Quasi_palindrome {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var y : long ; y := sc.getCurrent()->toLong() ;
    var x : long ; x := sc.getCurrent()->toLong() ;
    if (not((1l * n - 1 + (x - n + 1) * (x - n + 1) >= y)) or (x - n + 1) <= 0) then     OclFile["System.out"].println(-1) else (     OclFile["System.out"].println(x - n + 1) ; 
     while (n - 1 > 0) do (     OclFile["System.out"].println(1) ; 
     n := n - 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int h=sc.nextInt();
      int w=sc.nextInt();
      int[][] population=new int[h][w];
      int[] hSum=new int[h];
      int[] wSum=new int[w];
      for(int i=0 ; i<h ; i++){
        for(int j=0 ; j<w ; j++){
          population[i][j]=sc.nextInt();
        }
      }
      int min=10000000 ;
      for(int i=0 ; i<h ; i++){
        for(int j=0 ; j<w ; j++){
          int count=0 ;
          for(int k=0 ; k<h ; k++){
            for(int l=0 ; l<w ; l++){
              int toh=Math.abs(k-i);
              int tow=Math.abs(j-l);
              count+=Math.min(toh,tow)*population[k][l];
            }
          }
          min=Math.min(min,count);
        }
      }
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var h : int ; h := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    var population : Sequence(Sequence(int)) ; population := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    var hSum : Sequence(int) ; hSum := Integer.subrange(1,h)->collect(0) ;
    var wSum : Sequence(int) ; wSum := Integer.subrange(1,w)->collect(0) ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     population[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var min : int ; min := 10000000 ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     var count : int ; count := 0 ;
         var k : int ; k := 0 ; while k < h do ( (         var l : int ; l := 0 ; while l < w do ( (     var toh : int ; toh := if k - i < 0 then -(k - i) else k - i endif ;
     var tow : int ; tow := if j - l < 0 then -(j - l) else j - l endif ;
     count := count+(Set{toh, tow}->min() * population[k+1][l+1]) )  ;     l := l + 1 ) )  ;     k := k + 1 ) ; 
     min := Set{min, count}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] size=br.readLine().split(" ");
    int H=Integer.parseInt(size[0]);
    int W=Integer.parseInt(size[1]);
    int[][] map=new int[H][W];
    for(int h=0 ; h<H ; h++){
      String[] line=br.readLine().split(" ");
      for(int w=0 ; w<W ; w++){
        map[h][w]=Integer.parseInt(line[w]);
      }
    }
    int answer=Integer.MAX_VALUE ;
    for(int h=0 ; h<H ; h++){
      for(int w=0 ; w<W ; w++){
        int score=0 ;
        for(int hh=0 ; hh<H ; hh++){
          for(int ww=0 ; ww<W ; ww++){
            score+=map[hh][ww]*Math.min(Math.abs(h-hh),Math.abs(w-ww));
          }
        }
        answer=Math.min(answer,score);
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var size : Sequence(String) ; size := br.readLine()->split(" ") ;
    var H : int ; H := (size[0+1])->toInteger() ;
    var W : int ; W := (size[1+1])->toInteger() ;
    var map : Sequence(Sequence(int)) ; map := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var h : int ; h := 0 ; while h < H do ( (     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
         var w : int ; w := 0 ; while w < W do ( (     map[h+1][w+1] := (line[w+1])->toInteger() )  ;     w := w + 1 ) )  ;     h := h + 1 ) ; 
    var answer : int ; answer := 2147483647 ;
        var h : int ; h := 0 ; while h < H do ( (         var w : int ; w := 0 ; while w < W do ( (     var score : int ; score := 0 ;
         var hh : int ; hh := 0 ; while hh < H do ( (         var ww : int ; ww := 0 ; while ww < W do ( (     score := score+(map[hh+1][ww+1] * Set{if h - hh < 0 then -(h - hh) else h - hh endif, if w - ww < 0 then -(w - ww) else w - ww endif}->min()) )  ;     ww := ww + 1 ) )  ;     hh := hh + 1 ) ; 
     answer := Set{answer, score}->min() )  ;     w := w + 1 ) )  ;     h := h + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().mainrun();
  }
  private Scanner scan ;
  private int H,W ;
  private Long[] Ans ;
  private int[][] A ;
  private void mainrun(){
    scan=new Scanner(System.in);
    H=scan.nextInt();
    W=scan.nextInt();
    Ans=new Long[H*W];
    A=new int[H][W];
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        A[i][j]=scan.nextInt();
      }
    }
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        Long ans=(long)0 ;
        for(int k=0 ; k<H ; k++){
          for(int l=0 ; l<W ; l++){
            int h=0,w=0 ;
            h=Math.abs(k-i)*A[k][l];
            w=Math.abs(l-j)*A[k][l];
            ans+=Math.min(h,w);
          }
        }
        Ans[W*i+j]=ans ;
      }
    }
    System.out.println(Arrays.asList(Ans).parallelStream().mapToLong(e->e).min().getAsLong());
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().mainrun() );
   attribute scan : OclFile;
   attribute H : int;
   attribute Ans : Sequence(long);
   attribute A : Sequence(Sequence(int));
   operation mainrun() : void
  pre: true
  post: true
  activity: (     scan := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     H := scan.getCurrent()->toInteger() ; 
    W := scan.getCurrent()->toInteger() ; 
    Ans := Integer.subrange(1,H * W)->collect(null) ; 
    A := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     A[i+1][j+1] := scan.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     var ans : long ; ans := 0->oclAsType(long) ;
         var k : int ; k := 0 ; while k < H do ( (         var l : int ; l := 0 ; while l < W do ( (     var h : int ; h := 0 ;
    var w : int ; w := 0 ;
     h := if k - i < 0 then -(k - i) else k - i endif * A[k+1][l+1] ; 
     w := if l - j < 0 then -(l - j) else l - j endif * A[k+1][l+1] ; 
     ans := ans+(Set{h, w}->min()) )  ;     l := l + 1 ) )  ;     k := k + 1 ) ; 
     Ans[W * i + j+1] := ans )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Ans.parallelStream()->collect( _x1 | (lambda e : OclAny in e)->apply(_x1) ).min().getAsLong()) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int caseCount ;
    caseCount=Integer.parseInt(scanner.nextLine());
    Keitai keitai=new Keitai();
    for(int i=0 ; i<caseCount ; i++){
      System.out.println(keitai.getMessage(scanner.nextLine()));
    }
    scanner.close();
  }
}
class Keitai {
  private static final int PATTERNLEN_MAX=1024 ;
  private static final int STRLEN_MAX=75 ;
  private static final String[] characters={
    "",".,!? ","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz" };
    private static final char CONFIRM_KEY='0' ;
    private static Scanner scanner ;
    public String getMessage(String pattern){
      String message=this.convertPatternToMessage(pattern);
      return message ;
    }
    private String convertPatternToMessage(String pattern){
      String result="" ;
      char[] patternArray=pattern.toCharArray();
      char row ;
      int col ;
      int cursor=0 ;
      while(cursor<patternArray.length && cursor<this.PATTERNLEN_MAX){
        if(patternArray[cursor]!=this.CONFIRM_KEY){
          row=patternArray[cursor];
          col=0 ;
          cursor++;
          while(patternArray[cursor]!=this.CONFIRM_KEY &&(cursor<patternArray.length && cursor<this.PATTERNLEN_MAX)){
            col++;
            cursor++;
          }
          col=col %(characters[Character.getNumericValue(row)] .toCharArray().length);
          result+=characters[Character.getNumericValue(row)] .toCharArray()[col];
        }
        else {
          cursor++;
        }
      }
      return result ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var caseCount : int ;
    caseCount := (scanner.nextLine())->toInteger() ; 
    var keitai : Keitai ; keitai := Keitai.newKeitai() ;
        var i : int ; i := 0 ; while i < caseCount do ( (     OclFile["System.out"].println(keitai.getMessage(scanner.nextLine())) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
class Keitai {
  static    attribute PATTERNLEN_MAX : int := 1024;
  static    attribute STRLEN_MAX : int := 75;
  static    attribute characters : Sequence(String) := Sequence{"",".,!? ","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
  static    attribute CONFIRM_KEY : String := '0';
  static   attribute scanner : OclFile;
   operation getMessage( pattern : String) : String
  pre: true
  post: true
  activity: (     var message : String ; message := self.convertPatternToMessage(pattern) ;
     return message );
   operation convertPatternToMessage( pattern : String) : String
  pre: true
  post: true
  activity: (     var result : String ; result := "" ;
     var patternArray : Sequence(String) ; patternArray := pattern->characters() ;
    var row : String ;
    var col : int ;
    var cursor : int ; cursor := 0 ;
    while (cursor < patternArray->size() & cursor < self.PATTERNLEN_MAX) do (     if (patternArray[cursor+1] /= self.CONFIRM_KEY) then (     row := patternArray[cursor+1] ; 
     col := 0 ; 
    cursor := cursor + 1 ; 
    while (patternArray[cursor+1] /= self.CONFIRM_KEY & (cursor < patternArray->size() & cursor < self.PATTERNLEN_MAX)) do (     col := col + 1 ; 
     cursor := cursor + 1 ) ; 
    col := col mod (characters[("" + row)->toInteger()+1]->characters()->size()) ; 
    result := result+(characters[("" + row)->toInteger()+1]->characters()[col+1]) ; 
 ) else (     cursor := cursor + 1 ) ) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static double calculateAlternateSum(int n){
    if(n<=0)return 0 ;
    int fibo[]=new int[n+1];
    fibo[0]=0 ;
    fibo[1]=1 ;
    double sum=Math.pow(fibo[0],2)+Math.pow(fibo[1],2);
    for(int i=2 ; i<=n ; i++){
      fibo[i]=fibo[i-1]+fibo[i-2];
      if(i % 2==0)sum-=fibo[i];
      else sum+=fibo[i];
    }
    return sum ;
  }
  public static void main(String args[]){
    int n=8 ;
    System.out.println("Alternating Fibonacci Sum upto "+n+" terms: "+calculateAlternateSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation calculateAlternateSum( n : int) : double
  pre: true
  post: true
  activity: (     if (n <= 0) then     return 0 else skip ; 
     var fibo : Sequence(int) ; fibo := Integer.subrange(1,n + 1)->collect(0) ;
    fibo[0+1] := 0 ; 
    fibo[1+1] := 1 ; 
    var sum : double ; sum := fibo[0+1]->pow(2) + fibo[1+1]->pow(2) ;
        var i : int ; i := 2 ; while i <= n do ( (     fibo[i+1] := fibo[i - 1+1] + fibo[i - 2+1] ; 
     if (i mod 2 = 0) then     sum := sum-(fibo[i+1]) ; else     sum := sum+(fibo[i+1]) ; )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     OclFile["System.out"].println("Alternating Fibonacci Sum upto " + n + " terms: " + calculateAlternateSum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public final class p038 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p038().run());
  }
  public String run(){
    int max=-1 ;
    for(int n=2 ; n<=9 ; n++){
      for(int i=1 ; i<Library.pow(10,9/n); i++){
        String concat="" ;
        for(int j=1 ; j<=n ; j++)concat+=i*j ;
        if(isPandigital(concat))max=Math.max(Integer.parseInt(concat),max);
      }
    }
    return Integer.toString(max);
  }
  private static boolean isPandigital(String s){
    if(s.length()!=9)return false ;
    char[] temp=s.toCharArray();
    Arrays.sort(temp);
    return new String(temp).equals("123456789");
  }
}
------------------------------------------------------------
OCL File:
---------
 class p038 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p038.newp038().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var max : int ; max := -1 ;
         var n : int ; n := 2 ; while n <= 9 do ( (         var i : int ; i := 1 ; while i < Library.pow(10, 9 / n) do ( (     var concat : String ; concat := "" ;
         var j : int ; j := 1 ; while j <= n do (     concat := concat+(i * j) ;  ;     j := j + 1 ) ; 
     if (isPandigital(concat)) then     max := Set{(concat)->toInteger(), max}->max() ; else skip )  ;     i := i + 1 ) )  ;     n := n + 1 ) ; 
     return ((max) + "") );
  static   operation isPandigital( s : String) : boolean
  pre: true
  post: true
  activity: (     if (s->size() /= 9) then     return false else skip ; 
     var temp : Sequence(String) ; temp := s->characters() ;
     temp := temp->sort() ; 
     return StringLib.newString(temp) = "123456789" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test {
  private static final int Max=(int)(1e5+10);
  private static int n ;
  private static int k ;
  private static int A[];
  private static int Min ;
  public static void main(String[] args){
    Init();
    long ans=0 ;
    boolean ok=true ;
    for(int i=0 ; i<n ; i++){
      if((A[i]-Min)% k==0){
        ans+=((A[i]-Min)/k);
      }
      else {
        ok=false ;
        break ;
      }
    }
    if(! ok){
      System.out.println(-1);
    }
    else {
      System.out.println(ans);
    }
  }
  private static void Init(){
    Scanner cin=new Scanner(System.in);
    n=cin.nextInt();
    k=cin.nextInt();
    A=new int[Max];
    Min=(int)(1e9+10);
    for(int i=0 ; i<n ; i++){
      A[i]=cin.nextInt();
      Min=Math.min(Min,A[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static    attribute Max : int := (1e5 + 10)->oclAsType(int);
  static   attribute n : int;
  static   attribute k : int;
  static   attribute A : Sequence(int);
  static   attribute Min : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute Init() ; 
     var ans : long ; ans := 0 ;
    var ok : boolean ; ok := true ;
        var i : int ; i := 0 ; while i < n do ( (     if ((A[i+1] - Min) mod k = 0) then (     ans := ans+(((A[i+1] - Min) / k)) ) else (     ok := false ; 
     break ) )  ;     i := i + 1 ) ; 
    if (not(ok)) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(ans) ) ;  
 );
  static   operation Init() : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := cin.getCurrent()->toInteger() ; 
    k := cin.getCurrent()->toInteger() ; 
    A := Integer.subrange(1,Max)->collect(0) ; 
    Min := (1e9 + 10)->oclAsType(int) ; 
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := cin.getCurrent()->toInteger() ; 
     Min := Set{Min, A[i+1]}->min() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class oleg {
  private int[] array ;
  private int[] tempMergArr ;
  private int length ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long val=sc.nextLong();
    long arr[]=new long[N];
    for(int i=0 ; i<N ; i++){
      arr[i]=sc.nextLong();
    }
    long prev=arr[0] % val ;
    int flag=0 ;
    for(int i=1 ; i<N ; i++){
      if((arr[i] % val)!=prev){
        flag=1 ;
        break ;
      }
    }
    if(flag==1){
      System.out.println("-1");
    }
    else {
      sort(arr,0,N);
      long sum=0 ;
      for(int i=1 ; i<N ; i++){
        sum+=(Math.abs(arr[0]-arr[i]))/val ;
      }
      System.out.println(sum);
    }
  }
  public static void sort(long[] a,int low,int high){
    int N=high-low ;
    if(N<=1)return ;
    int mid=low+N/2 ;
    sort(a,low,mid);
    sort(a,mid,high);
    long[] temp=new long[N];
    int i=low,j=mid ;
    for(int k=0 ; k<N ; k++){
      if(i==mid)temp[k]=a[j++];
      else if(j==high)temp[k]=a[i++];
      else if(a[j]<a[i])temp[k]=a[j++];
      else temp[k]=a[i++];
    }
    for(int k=0 ; k<N ; k++)a[low+k]=temp[k];
  }
}
------------------------------------------------------------
OCL File:
---------
 class oleg {
   attribute array : Sequence(int);
   attribute tempMergArr : Sequence(int);
   attribute length : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var val : long ; val := sc.getCurrent()->toLong() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var prev : long ; prev := arr[0+1] mod val ;
    var flag : int ; flag := 0 ;
        var i : int ; i := 1 ; while i < N do ( (     if ((arr[i+1] mod val) /= prev) then (     flag := 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 1) then (     OclFile["System.out"].println("-1") ) else (     execute sort(arr, 0, N) ; 
     var sum : long ; sum := 0 ;
         var i : int ; i := 1 ; while i < N do ( (     sum := sum+((if arr[0+1] - arr[i+1] < 0 then -(arr[0+1] - arr[i+1]) else arr[0+1] - arr[i+1] endif) / val) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sum) ) ;  
 );
  static   operation sort( a : Sequence(long), low : int, high : int) : void
  pre: true
  post: true
  activity: (     var N : int ; N := high - low ;
     if (N <= 1) then     return else skip ; 
    var mid : int ; mid := low + N / 2 ;
    execute sort(a, low, mid) ; 
    execute sort(a, mid, high) ; 
    var temp : Sequence(long) ; temp := Integer.subrange(1,N)->collect(0) ;
    var i : int ; i := low ;
    var j : int ; j := mid ;
        var k : int ; k := 0 ; while k < N do ( (     if (i = mid) then      temp[k+1] := a[j+1]  ; j := j + 1 ; else     if (j = high) then      temp[k+1] := a[i+1]  ; i := i + 1 else     if (a[j+1] < a[i+1]) then      temp[k+1] := a[j+1]  ; j := j + 1 else      temp[k+1] := a[i+1]  ; i := i + 1 ; ;  ;  )  ;     k := k + 1 ) ; 
        var k : int ; k := 0 ; while k < N do (     a[low + k+1] := temp[k+1] ;  ;     k := k + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _793A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int minVal=Integer.MAX_VALUE ;
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      minVal=Math.min(arr[i],minVal);
    }
    Long ans=0l ;
    for(int i=0 ; i<n ; i++){
      if((arr[i]-minVal)% k!=0){
        ans=-1l ;
        break ;
      }
      ans+=(arr[i]-minVal)/k ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _793A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var minVal : int ; minVal := 2147483647 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     minVal := Set{arr[i+1], minVal}->min() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0l ;
        var i : int ; i := 0 ; while i < n do ( (     if ((arr[i+1] - minVal) mod k /= 0) then (     ans := -1l ; 
     break ) else skip ; 
     ans := ans+((arr[i+1] - minVal) / k) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int fact(int n){
    int num=1 ;
    for(int i=1 ; i<=n ; i++){
      num=num*i ;
    }
    return num ;
  }
  static int Special_Factorial_Number(int k){
    for(int i=1 ; i<=k ; i++){
      if(fact(i)% k==0){
        return i ;
      }
    }
    return 0 ;
  }
  public static void main(String[] args){
    int k=16 ;
    System.out.println(Special_Factorial_Number(k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation fact( n : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (     num := num * i )  ;     i := i + 1 ) ; 
     return num );
  static   operation Special_Factorial_Number( k : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= k do ( (     if (fact(i) mod k = 0) then (     return i ) else skip )  ;     i := i + 1 ) ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 16 ;
     OclFile["System.out"].println(Special_Factorial_Number(k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (true) {
            int fy = sc.nextInt(), fm = sc.nextInt(), fd = sc.nextInt();
            int ty = sc.nextInt(), tm = sc.nextInt(), to = sc.nextInt();
            if (fy == -1) break;
            System.out.println(Duration.between(
                    LocalDateTime.of(fy, fm, fd, 0, 0),
                    LocalDateTime.of(ty, tm, to, 0, 0)
            ).toDays());
        }
    }
}

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var fy : int ; fy := sc.getCurrent()->toInteger() ;
    var fm : int ; fm := sc.getCurrent()->toInteger() ;
    var fd : int ; fd := sc.getCurrent()->toInteger() ;
     var ty : int ; ty := sc.getCurrent()->toInteger() ;
    var tm : int ; tm := sc.getCurrent()->toInteger() ;
    var to : int ; to := sc.getCurrent()->toInteger() ;
     if (fy = -1) then     break else skip ; 
     OclFile["System.out"].println(Duration.between(LocalDateTime.of(fy, fm, fd, 0, 0), LocalDateTime.of(ty, tm, to, 0, 0)).toDays()) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class pair {
    double F,S ;
    public pair(double F,double S){
      this.F=F ;
      this.S=S ;
    }
    public pair(){
    }
  }
  static double minDistance(pair A,pair B,pair E){
    pair AB=new pair();
    AB.F=B.F-A.F ;
    AB.S=B.S-A.S ;
    pair BE=new pair();
    BE.F=E.F-B.F ;
    BE.S=E.S-B.S ;
    pair AE=new pair();
    AE.F=E.F-A.F ;
    AE.S=E.S-A.S ;
    double AB_BE,AB_AE ;
    AB_BE=(AB.F*BE.F+AB.S*BE.S);
    AB_AE=(AB.F*AE.F+AB.S*AE.S);
    double reqAns=0 ;
    if(AB_BE>0){
      double y=E.S-B.S ;
      double x=E.F-B.F ;
      reqAns=Math.sqrt(x*x+y*y);
    }
    else if(AB_AE<0){
      double y=E.S-A.S ;
      double x=E.F-A.F ;
      reqAns=Math.sqrt(x*x+y*y);
    }
    else {
      double x1=AB.F ;
      double y1=AB.S ;
      double x2=AE.F ;
      double y2=AE.S ;
      double mod=Math.sqrt(x1*x1+y1*y1);
      reqAns=Math.abs(x1*y2-y1*x2)/mod ;
    }
    return reqAns ;
  }
  public static void main(String[] args){
    pair A=new pair(0,0);
    pair B=new pair(2,0);
    pair E=new pair(1,1);
    System.out.print((int)minDistance(A,B,E));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class pair {
   attribute F : double;
   static operation newpair( F : double, S : double) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(F, S);
    return self );
  operation initialise( F : double, S : double) : void
  pre: true  post: true
  activity: (     self.F := F ; 
     self.S := S );
   static operation newpair() : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
}
  static   operation minDistance( A : pair, B : pair, E : pair) : double
  pre: true
  post: true
  activity: (     var AB : pair ; AB := pair.newpair() ;
     AB.F := B.F - A.F ; 
    AB.S := B.S - A.S ; 
    var BE : pair ; BE := pair.newpair() ;
    BE.F := E.F - B.F ; 
    BE.S := E.S - B.S ; 
    var AE : pair ; AE := pair.newpair() ;
    AE.F := E.F - A.F ; 
    AE.S := E.S - A.S ; 
    var AB_BE : double ;
    var AB_AE : double ;
    AB_BE := (AB.F * BE.F + AB.S * BE.S) ; 
    AB_AE := (AB.F * AE.F + AB.S * AE.S) ; 
    var reqAns : double ; reqAns := 0 ;
    if (AB_BE > 0) then (     var y : double ; y := E.S - B.S ;
     var x : double ; x := E.F - B.F ;
     reqAns := (x * x + y * y)->sqrt() ) else     if (AB_AE < 0) then (     var y : double ; y := E.S - A.S ;
     var x : double ; x := E.F - A.F ;
     reqAns := (x * x + y * y)->sqrt() ) else (     var x1 : double ; x1 := AB.F ;
     var y1 : double ; y1 := AB.S ;
    var x2 : double ; x2 := AE.F ;
    var y2 : double ; y2 := AE.S ;
    var mod : double ; mod := (x1 * x1 + y1 * y1)->sqrt() ;
    reqAns := if x1 * y2 - y1 * x2 < 0 then -(x1 * y2 - y1 * x2) else x1 * y2 - y1 * x2 endif / mod ; 
 ) ;  ;  
    return reqAns 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : pair ; A := pair.newpair(0, 0) ;
     var B : pair ; B := pair.newpair(2, 0) ;
     var E : pair ; E := pair.newpair(1, 1) ;
     OclFile["System.out"].print(minDistance(A, B, E)->oclAsType(int)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long n=in.nextLong();
    int N=(int)Math.sqrt(n);
    Prime prime=new Prime(N);
    prime.sieve();
    prime.primeFactorization(n);
    ArrayList<Long>ls=prime.pf ;
    Collections.sort(ls);
    long v=ls.get(0);
    if(n % v==0){
      n-=v ;
      long res=n/2 ;
      pw.println(res+1);
    }
    else pw.println(-1);
    pw.close();
  }
  static class Prime {
    int N ;
    ArrayList<Integer>prime ;
    ArrayList<Long>pf ;
    boolean[] isPrime ;
    Prime(int N){
      this.N=N+5 ;
      prime=new ArrayList<>();
      isPrime=new boolean[this.N];
    }
    void sieve(){
      Arrays.fill(isPrime,true);
      isPrime[0]=false ;
      isPrime[1]=false ;
      for(int i=2 ; i*i<N ; i++){
        if(! isPrime[i])continue ;
        for(int j=i*i ; j<N ; j+=i)isPrime[j]=false ;
      }
      for(int i=2 ; i<N ; i++){
        if(isPrime[i])prime.add(i);
      }
    }
    void primeFactorization(long n){
      pf=new ArrayList<>();
      for(int i=0 ; i<prime.size(); i++){
        long p=prime.get(i);
        if(p*p>n)break ;
        if(n % p==0){
          while(n % p==0){
            n/=p ;
            pf.add(p);
          }
        }
      }
      if(n>1)pf.add(n);
    }
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := in.getCurrent()->toLong() ;
    var N : int ; N := (n)->sqrt()->oclAsType(int) ;
    var prime : Prime ; prime := Prime.newPrime(N) ;
    prime.sieve() ; 
    prime.primeFactorization(n) ; 
    var ls : Sequence(long) ; ls := prime.pf ;
    ls := ls->sort() ; 
    var v : long ; v := ls->at(0+1) ;
    if (n mod v = 0) then (     n := n-(v) ; 
     var res : long ; res := n / 2 ;
     skip ) else     skip ; ;  
    skip ; 
 );
  static class Prime {
   attribute N : int;
   attribute prime : Sequence(int);
   attribute pf : Sequence(long);
   attribute isPrime : Sequence(boolean);
   static operation newPrime( N : int) : Prime
  pre: true
  post: true
  activity:
  ( var self : Prime ;
    self := createPrime();
    self.initialise(N);
    return self );
  operation initialise( N : int) : void
  pre: true  post: true
  activity: (     self.N := N + 5 ; 
     prime := Sequence{} ; 
     isPrime := Integer.subrange(1,self.N)->collect(false) );
   operation sieve() : void
  pre: true
  post: true
  activity: (     isPrime := isPrime->collect(true) ; 
     isPrime[0+1] := false ; 
    isPrime[1+1] := false ; 
        var i : int ; i := 2 ; while i * i < N do ( (     if (not(isPrime[i+1])) then     continue else skip ; 
         var j : int ; j := i * i ; while j < N do (     isPrime[j+1] := false ;  ;     j := j+(i) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i < N do ( (     if (isPrime[i+1]) then     prime := prime->including(i) ; else skip )  ;     i := i + 1 ) ; 
 );
   operation primeFactorization( n : long) : void
  pre: true
  post: true
  activity: (     pf := Sequence{} ; 
         var i : int ; i := 0 ; while i < prime->size() do ( (     var p : long ; p := prime->at(i+1) ;
     if (p * p > n) then     break else skip ; 
     if (n mod p = 0) then (     while (n mod p = 0) do (     n := n/(p) ; 
     pf := pf->including(p) ) ) else skip )  ;     i := i + 1 ) ; 
     if (n > 1) then     pf := pf->including(n) ; else skip );
}
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CodeForces_1076B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Long n=sc.nextLong();
    Long sum=0l ;
    while(n>0 && ! isPrime(n)){
      if(n % 2==0){
        sum+=n/2 ;
        n=0l ;
        break ;
      }
      for(Long i=3l ; i*i<=n ; i++){
        if(isPrime(i)&& n % i==0){
          n-=i ;
          sum+=1 ;
          break ;
        }
      }
    }
    if(n>1 && isPrime(n)){
      sum+=1 ;
    }
    System.out.println(sum);
  }
  public static Boolean isPrime(long n){
    for(long i=2 ; i*i<=n ; i++){
      if(n % i==0)return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces_1076B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var sum : long ; sum := 0l ;
    while (n > 0 & not(isPrime(n))) do (     if (n mod 2 = 0) then (     sum := sum+(n / 2) ; 
     n := 0l ; 
     break ) else skip ; 
         var i : long ; i := 3l ; while i * i <= n do ( (     if (isPrime(i) & n mod i = 0) then (     n := n-(i) ; 
     sum := sum+(1) ; 
     break ) else skip )  ;     i := i + 1 ) ) ; 
    if (n > 1 & isPrime(n)) then (     sum := sum+(1) ) else skip ; 
    OclFile["System.out"].println(sum) ; 
 );
  static   operation isPrime( n : long) : Boolean
  pre: true
  post: true
  activity: (         var i : long ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int SumF(int S[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum=sum+(int)(S[i]*Math.pow(2,n-i-1));
    return sum ;
  }
  static int SumL(int S[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum=sum+(int)(S[i]*Math.pow(2,i));
    return sum ;
  }
  static int sumSetDiff(int S[],int n){
    return SumL(S,n)-SumF(S,n);
  }
  public static void main(String arg[]){
    int n=4 ;
    int S[]={
      5,2,9,6 };
      System.out.println(sumSetDiff(S,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation SumF( S : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum + (S[i+1] * 2->pow(n - i - 1))->oclAsType(int) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation SumL( S : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum + (S[i+1] * 2->pow(i))->oclAsType(int) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation sumSetDiff( S : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     return SumL(S, n) - SumF(S, n) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var S : Sequence(int) ; S := Sequence{5,2,9,6} ;
     OclFile["System.out"].println(sumSetDiff(S, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  static int numberOfSolutions(int n){
    int c=0 ;
    for(int x=0 ; x<=n ; ++x)if(n==x+(n ^ x))++c ;
    return c ;
  }
  public static void main(String args[]){
    int n=3 ;
    System.out.print(numberOfSolutions(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation numberOfSolutions( n : int) : int
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
         var x : int ; x := 0 ; while x <= n do (     if (n = x + (n xor x)) then     c := c + 1 ; else skip ;  ;     x := x + 1 ) ; 
     return c );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].print(numberOfSolutions(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    String s=in.next();
    char ch[]=s.toCharArray();
    int cb=0,sb=0,u=0,l=0,a=0,r=0,sc=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(ch[i]=='B'){
        cb++;
      }
      else if(ch[i]=='b'){
        sb++;
      }
      else if(ch[i]=='u'){
        u++;
      }
      else if(ch[i]=='l'){
        l++;
      }
      else if(ch[i]=='a'){
        a++;
      }
      else if(ch[i]=='s'){
        sc++;
      }
      else if(ch[i]=='r'){
        r++;
      }
    }
    u=u/2 ;
    a=a/2 ;
    int m1=Math.min(cb,sb);
    int m2=Math.min(u,m1);
    int m3=Math.min(m2,a);
    int m4=Math.min(m3,l);
    int m5=Math.min(sc,r);
    pw.println(Math.min(m4,m5));
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : String ; s := in.getCurrent() ;
    var ch : Sequence(String) ; ch := s->characters() ;
    var cb : int ; cb := 0 ;
    var sb : int ; sb := 0 ;
    var u : int ; u := 0 ;
    var l : int ; l := 0 ;
    var a : int ; a := 0 ;
    var r : int ; r := 0 ;
    var sc : int ; sc := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (ch[i+1] = 'B') then (     cb := cb + 1 ) else     if (ch[i+1] = 'b') then (     sb := sb + 1 ) else     if (ch[i+1] = 'u') then (     u := u + 1 ) else     if (ch[i+1] = 'l') then (     l := l + 1 ) else     if (ch[i+1] = 'a') then (     a := a + 1 ) else     if (ch[i+1] = 's') then (     sc := sc + 1 ) else     if (ch[i+1] = 'r') then (     r := r + 1 ) else skip ; ;  ;  ;  ;  ;  )  ;     i := i + 1 ) ; 
    u := u / 2 ; 
    a := a / 2 ; 
    var m1 : int ; m1 := Set{cb, sb}->min() ;
    var m2 : int ; m2 := Set{u, m1}->min() ;
    var m3 : int ; m3 := Set{m2, a}->min() ;
    var m4 : int ; m4 := Set{m3, l}->min() ;
    var m5 : int ; m5 := Set{sc, r}->min() ;
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test218 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int x=((int)Math.sqrt(n)+(int)Math.cbrt(n))+1 ;
      for(int i=1,k=1 ; k<=n ; i++){
        x--;
        k=(int)Math.pow(i*i,3);
      }
      System.out.println(x);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test218 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var x : int ; x := ((n)->sqrt()->oclAsType(int) + (n)->cbrt()->oclAsType(int)) + 1 ;
         var i : int ; i := 1 ;
    var k : int ; k := 1 ; while k <= n do ( (     x := x - 1 ; 
     k := i * i->pow(3)->oclAsType(int) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(x) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      Set<Integer>s=new HashSet<Integer>();
      for(int i=1 ; i*i<=n ; i++){
        s.add(i*i);
      }
      for(int i=1 ; i*i*i<=n ; i++){
        s.add(i*i*i);
      }
      System.out.println(s.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : Set(int) ; s := Set{} ;
        var i : int ; i := 1 ; while i * i <= n do ( (     s := s->including(i * i) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i * i * i <= n do ( (     s := s->including(i * i * i) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s->size()) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int maxLen(int[] arr,int n){
    int min_val=Arrays.stream(arr).min().getAsInt();
    int freq=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==min_val)freq++;
    }
    return freq ;
  }
  public static void main(String[] args){
    int arr[]={
      1,3,1 };
      int n=arr.length ;
      System.out.println(maxLen(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxLen( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var min_val : int ; min_val := stream(arr).min().getAsInt() ;
     var freq : int ; freq := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = min_val) then     freq := freq + 1 ; else skip )  ;     i := i + 1 ) ; 
     return freq );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,3,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxLen(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class LinkedList {
  static Node head ;
  class Node {
    int data ;
    Node next ;
    Node(int d){
      data=d ;
      next=null ;
    }
  }
  Node kAltReverse(Node head,int k){
    return _kAltReverse(head,k,true);
  }
  Node _kAltReverse(Node node,int k,boolean b){
    if(node==null){
      return null ;
    }
    int count=1 ;
    Node prev=null ;
    Node current=node ;
    Node next=null ;
    while(current!=null && count<=k){
      next=current.next ;
      if(b==true){
        current.next=prev ;
      }
      prev=current ;
      current=next ;
      count++;
    }
    if(b==true){
      node.next=_kAltReverse(current,k,! b);
      return prev ;
    }
    else {
      prev.next=_kAltReverse(current,k,! b);
      return node ;
    }
  }
  void printList(Node node){
    while(node!=null){
      System.out.print(node.data+" ");
      node=node.next ;
    }
  }
  void push(int newdata){
    Node mynode=new Node(newdata);
    mynode.next=head ;
    head=mynode ;
  }
  public static void main(String[] args){
    LinkedList list=new LinkedList();
    for(int i=20 ; i>0 ; i--){
      list.push(i);
    }
    System.out.println("Given Linked List :");
    list.printList(head);
    head=list.kAltReverse(head,3);
    System.out.println("");
    System.out.println("Modified Linked List :");
    list.printList(head);
  }
}
------------------------------------------------------------
OCL File:
---------
class LinkedList {
  static   attribute head : Node;
 class Node {
   attribute data : int;
   attribute next : Node;
   static operation newNode( d : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(d);
    return self );
  operation initialise( d : int) : void
  pre: true  post: true
  activity: (     data := d ; 
     next := null );
}
   operation kAltReverse( head : Node, k : int) : Node
  pre: true
  post: true
  activity: (     return _kAltReverse(head, k, true) );
   operation _kAltReverse( node : Node, k : int, b : boolean) : Node
  pre: true
  post: true
  activity: (     if (node = null) then (     return null ) else skip ; 
     var count : int ; count := 1 ;
    var prev : Node ; prev := null ;
    var current : Node ; current := node ;
    var next : Node ; next := null ;
    while (current /= null & count <= k) do (     next := current.next ; 
     if (b = true) then (     current.next := prev ) else skip ; 
    prev := current ; 
    current := next ; 
    count := count + 1 ; 
 ) ; 
    if (b = true) then (     node.next := _kAltReverse(current, k, not(b)) ; 
     return prev ) else (     prev.next := _kAltReverse(current, k, not(b)) ; 
     return node ) ;  
 );
   operation printList( node : Node) : void
  pre: true
  post: true
  activity: (     while (node /= null) do (     OclFile["System.out"].print(node.data + " ") ; 
     node := node.next ) );
   operation push( newdata : int) : void
  pre: true
  post: true
  activity: (     var mynode : Node ; mynode := Node.newNode(newdata) ;
     mynode.next := head ; 
     head := mynode );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var list : Sequence ; list := Sequence{} ;
         var i : int ; i := 20 ; while i > 0 do ( (     list := list->append(i) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println("Given Linked List :") ; 
    list := list.printList(head) ; 
    head := list.kAltReverse(head, 3) ; 
    OclFile["System.out"].println("") ; 
    OclFile["System.out"].println("Modified Linked List :") ; 
    list := list.printList(head) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  static int[] days={
    0,31,28,31,30,31,30,31,31,30,31,30,31 };
    static boolean isLeap(int y){
      return(y % 4==0 &&(y % 100!=0 || y % 400==0));
    }
    static int yTod(int y){
      if(isLeap(y))return 366 ;
      else return 365 ;
    }
    static int myTod(int m,int y){
      if(m==2 && isLeap(y))return 29 ;
      else return days[m];
    }
    static int dmyTod(int d,int m,int y){
      int res=0 ;
      int month=0 ;
      while(++month<m){
        res+=myTod(month,y);
      }
      res+=d ;
      return res ;
    }
    public static void main(String[] args)throws IOException {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String line ;
      int y1,m1,d1,y2,m2,d2 ;
      while((line=br.readLine())!=null){
        String[] input=line.split(" ");
        y1=Integer.parseInt(input[0]);
        m1=Integer.parseInt(input[1]);
        d1=Integer.parseInt(input[2]);
        y2=Integer.parseInt(input[3]);
        m2=Integer.parseInt(input[4]);
        d2=Integer.parseInt(input[5]);
        if(y1<0 || m1<0 || d1<0 || y2<0 || m2<0 || d2<0){
          break ;
        }
        long sum=0 ;
        if(y1<y2){
          sum+=yTod(y1)-dmyTod(d1,m1,y1)+1 ;
          y1++;
          m1=1 ;
          d1=1 ;
        }
        while(y1<y2){
          sum+=yTod(y1++);
        }
        sum+=dmyTod(d2,m2,y2)-dmyTod(d1,m1,y1);
        System.out.println(sum);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute days : Sequence(int) := Sequence{0,31,28,31,30,31,30,31,31,30,31,30,31};
  static   operation isLeap( y : int) : boolean
  pre: true
  post: true
  activity: (     return (y mod 4 = 0 & (y mod 100 /= 0 or y mod 400 = 0)) );
  static   operation yTod( y : int) : int
  pre: true
  post: true
  activity: (     if (isLeap(y)) then     return 366 else     return 365 );
  static   operation myTod( m : int, y : int) : int
  pre: true
  post: true
  activity: (     if (m = 2 & isLeap(y)) then     return 29 else     return days[m+1] );
  static   operation dmyTod( d : int, m : int, y : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     var month : int ; month := 0 ;
        month := month + 1 ;
    while ((month + 1) < m) do (        month := month + 1 ;     skip ; (     res := res+(myTod(month, y)) ) ;     month := month + 1 ;
 ) ;  
    res := res+(d) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var y1 : int ;
    var m1 : int ;
    var d1 : int ;
    var y2 : int ;
    var m2 : int ;
    var d2 : int ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     var input : Sequence(String) ; input := line->split(" ") ;
     y1 := (input[0+1])->toInteger() ; 
    m1 := (input[1+1])->toInteger() ; 
    d1 := (input[2+1])->toInteger() ; 
    y2 := (input[3+1])->toInteger() ; 
    m2 := (input[4+1])->toInteger() ; 
    d2 := (input[5+1])->toInteger() ; 
    if (y1 < 0 or m1 < 0 or d1 < 0 or y2 < 0 or m2 < 0 or d2 < 0) then (     break ) else skip ; 
    var sum : long ; sum := 0 ;
    if (y1 < y2) then (     sum := sum+(yTod(y1) - dmyTod(d1, m1, y1) + 1) ; 
     y1 := y1 + 1 ; 
     m1 := 1 ; 
     d1 := 1 ) else skip ; 
    while (y1 < y2) do (     sum := sum+(yTod(y1)) ) ; 
    sum := sum+(dmyTod(d2, m2, y2) - dmyTod(d1, m1, y1)) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class LinkedList {
  static Node head ;
  class Node {
    int data ;
    Node next ;
    Node(int d){
      data=d ;
      next=null ;
    }
  }
  Node kAltReverse(Node node,int k){
    Node current=node ;
    Node next=null,prev=null ;
    int count=0 ;
    while(current!=null && count<k){
      next=current.next ;
      current.next=prev ;
      prev=current ;
      current=next ;
      count++;
    }
    if(node!=null){
      node.next=current ;
    }
    count=0 ;
    while(count<k-1 && current!=null){
      current=current.next ;
      count++;
    }
    if(current!=null){
      current.next=kAltReverse(current.next,k);
    }
    return prev ;
  }
  void printList(Node node){
    while(node!=null){
      System.out.print(node.data+" ");
      node=node.next ;
    }
  }
  void push(int newdata){
    Node mynode=new Node(newdata);
    mynode.next=head ;
    head=mynode ;
  }
  public static void main(String[] args){
    LinkedList list=new LinkedList();
    for(int i=20 ; i>0 ; i--){
      list.push(i);
    }
    System.out.println("Given Linked List :");
    list.printList(head);
    head=list.kAltReverse(head,3);
    System.out.println("");
    System.out.println("Modified Linked List :");
    list.printList(head);
  }
}
------------------------------------------------------------
OCL File:
---------
class LinkedList {
  static   attribute head : Node;
 class Node {
   attribute data : int;
   attribute next : Node;
   static operation newNode( d : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(d);
    return self );
  operation initialise( d : int) : void
  pre: true  post: true
  activity: (     data := d ; 
     next := null );
}
   operation kAltReverse( node : Node, k : int) : Node
  pre: true
  post: true
  activity: (     var current : Node ; current := node ;
     var next : Node ; next := null ;
    var prev : Node ; prev := null ;
    var count : int ; count := 0 ;
    while (current /= null & count < k) do (     next := current.next ; 
     current.next := prev ; 
    prev := current ; 
    current := next ; 
    count := count + 1 ; 
 ) ; 
    if (node /= null) then (     node.next := current ) else skip ; 
    count := 0 ; 
    while (count < k - 1 & current /= null) do (     current := current.next ; 
     count := count + 1 ) ; 
    if (current /= null) then (     current.next := kAltReverse(current.next, k) ) else skip ; 
    return prev 
 );
   operation printList( node : Node) : void
  pre: true
  post: true
  activity: (     while (node /= null) do (     OclFile["System.out"].print(node.data + " ") ; 
     node := node.next ) );
   operation push( newdata : int) : void
  pre: true
  post: true
  activity: (     var mynode : Node ; mynode := Node.newNode(newdata) ;
     mynode.next := head ; 
     head := mynode );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var list : Sequence ; list := Sequence{} ;
         var i : int ; i := 20 ; while i > 0 do ( (     list := list->append(i) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println("Given Linked List :") ; 
    list := list.printList(head) ; 
    head := list.kAltReverse(head, 3) ; 
    OclFile["System.out"].println("") ; 
    OclFile["System.out"].println("Modified Linked List :") ; 
    list := list.printList(head) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Olympiad {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    HashSet<Integer>set=new HashSet();
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      if(x!=0)set.add(x);
    }
    {
      System.out.println(set.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Olympiad {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x /= 0) then     set := set->including(x) ; else skip )  ;     i := i + 1 ) ; 
(     OclFile["System.out"].println(set->size()) ) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    int r=0 ;
    while(r<n){
      a[r]=sc.nextInt();
      r++;
    }
    r=0 ;
    int i=n-1 ;
    int q=1 ;
    Arrays.sort(a);
    while(a[r]==0){
      r++;
    }
    r=0 ;
    while(a[r]==0){
      if(r+1==n){
        q=0 ;
        r++;
      }
      q=1 ;
      r++;
    }
    if(q!=0){
      while(a[r]==0){
        r++;
      }
      while(a[r]!=a[i]){
        if(a[r]==a[r+1]){
          r++;
        }
        else {
          q++;
          r++;
        }
      }
      System.out.println(q);
    }
    else {
      System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var r : int ; r := 0 ;
    while (r < n) do (     a[r+1] := sc.getCurrent()->toInteger() ; 
     r := r + 1 ) ; 
    r := 0 ; 
    var i : int ; i := n - 1 ;
    var q : int ; q := 1 ;
    a := a->sort() ; 
    while (a[r+1] = 0) do (     r := r + 1 ) ; 
    r := 0 ; 
    while (a[r+1] = 0) do (     if (r + 1 = n) then (     q := 0 ; 
     r := r + 1 ) else skip ; 
     q := 1 ; 
     r := r + 1 ) ; 
    if (q /= 0) then (     while (a[r+1] = 0) do (     r := r + 1 ) ; 
     while (a[r+1] /= a[i+1]) do (     if (a[r+1] = a[r + 1+1]) then (     r := r + 1 ) else (     q := q + 1 ; 
     r := r + 1 ) ) ; 
     OclFile["System.out"].println(q) ) else (     OclFile["System.out"].println(0) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Arrays ;
public class program {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    Arrays.sort(a);
    int count=1 ;
    for(int i=0 ; i<n-1 ; i++){
      if(a[i]!=0){
        if(a[i]!=a[i+1]){
          count++;
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class program {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var count : int ; count := 1 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (a[i+1] /= 0) then (     if (a[i+1] /= a[i + 1+1]) then (     count := count + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int a[]=new int[n];
    int count=0 ;
    HashMap<Integer,Integer>h=new HashMap<>();
    for(int i=0 ; i<n ; i++)a[i]=s.nextInt();
    for(int i=0 ; i<n ; i++){
      if(h.containsKey(a[i])){
        h.put(a[i],h.get(a[i])+1);
      }
      else {
        h.put(a[i],1);
      }
    }
    if(h.containsKey(0)){
      System.out.println(h.size()-1);
    }
    else {
      System.out.println(h.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var count : int ; count := 0 ;
    var h : Map(int,int) ; h := Map{} ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (h->keys()->includes(a[i+1])) then (     h := h->union(Map{a[i+1] |-> h->at(a[i+1]) + 1}) ) else (     h := h->union(Map{a[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    if (h->keys()->includes(0)) then (     OclFile["System.out"].println(h.size() - 1) ) else (     OclFile["System.out"].println(h.size()) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_Olympiad {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] A=new int[n];
    for(int i=0 ; i<n ; i++){
      A[i]=sc.nextInt();
    }
    int count=0 ;
    int[] B=new int[601];
    for(int i=0 ; i<601 ; i++){
      B[i]=0 ;
    }
    for(int i=0 ; i<n ; i++){
      if(A[i]<=600)B[A[i] ]++;
    }
    for(int i=1 ; i<=600 ; i++){
      if(B[i]!=0){
        count++;
      }
    }
    System.out.print(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Olympiad {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var B : Sequence(int) ; B := Integer.subrange(1,601)->collect(0) ;
        var i : int ; i := 0 ; while i < 601 do ( (     B[i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (A[i+1] <= 600) then     B[A[i+1]+1] := B[A[i+1]+1] + 1 ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 600 do ( (     if (B[i+1] /= 0) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class GottaCatchEmAll {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] s=sc.next().toCharArray();
    HashMap<Character,Integer>map=new HashMap<>();
    map.put('B',0);
    map.put('u',0);
    map.put('l',0);
    map.put('b',0);
    map.put('a',0);
    map.put('s',0);
    map.put('r',0);
    for(int i=0 ; i<s.length ; i++){
      char ch=s[i];
      if(map.containsKey(ch))map.put(ch,map.get(ch)+1);
    }
    int max=Integer.MAX_VALUE ;
    for(Character key : map.keySet()){
      if(key=='u' || key=='a')max=Math.min(map.get(key)/2,max);
      else max=Math.min(map.get(key),max);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GottaCatchEmAll {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var map : Map(String,int) ; map := Map{} ;
    map := map->union(Map{'B' |-> 0}) ; 
    map := map->union(Map{'u' |-> 0}) ; 
    map := map->union(Map{'l' |-> 0}) ; 
    map := map->union(Map{'b' |-> 0}) ; 
    map := map->union(Map{'a' |-> 0}) ; 
    map := map->union(Map{'s' |-> 0}) ; 
    map := map->union(Map{'r' |-> 0}) ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     var ch : String ; ch := s[i+1] ;
     if (map->keys()->includes(ch)) then     map := map->union(Map{ch |-> map->at(ch) + 1}) ; else skip )  ;     i := i + 1 ) ; 
    var max : int ; max := 2147483647 ;
    for (key : map->keys()) do ( (     if (key = 'u' or key = 'a') then     max := Set{map->at(key) / 2, max}->min() ; else     max := Set{map->at(key), max}->min() ; )  ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  static int getMissingNo(int a[],int n){
    int x1=a[0];
    int x2=1 ;
    for(int i=1 ; i<n ; i++)x1=x1 ^ a[i];
    for(int i=2 ; i<=n+1 ; i++)x2=x2 ^ i ;
    return(x1 ^ x2);
  }
  public static void main(String args[]){
    int a[]={
      1,2,4,5,6 };
      int miss=getMissingNo(a,5);
      System.out.println(miss);
    }
  }

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation getMissingNo( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var x1 : int ; x1 := a[0+1] ;
     var x2 : int ; x2 := 1 ;
        var i : int ; i := 1 ; while i < n do (     x1 := MathLib.bitwiseXor(x1,a[i+1]) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= n + 1 do (     x2 := MathLib.bitwiseXor(x2,i) ;  ;     i := i + 1 ) ; 
    return (MathLib.bitwiseXor(x1,x2)) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,4,5,6} ;
     var miss : int ; miss := getMissingNo(a, 5) ;
     OclFile["System.out"].println(miss) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import sun.reflect.generics.tree.Tree ;
import java.util.*;
public class codeforce {
  public static void main(String[] args){
    Scanner css=new Scanner(System.in);
    int t=css.nextInt();
    while(t-->0){
      int n=css.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=css.nextInt();
      }
      int nums[]=arr.clone();
      Arrays.sort(arr);
      if(Arrays.equals(arr,nums)){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforce {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var css : OclFile ; css := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := css.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := css.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := css.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var nums : Sequence(int) ; nums := arr->copy() ;
    arr := arr->sort() ; 
    if (arr = nums) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class prog1 {
  static String solve(int a[],int n){
    for(int i=1 ; i<n ; i++){
      if(a[i]<a[i-1])return "YES" ;
    }
    return "NO" ;
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=1 ; i<=t ; i++){
      int n=sc.nextInt();
      int arr[]=new int[n];
      for(int j=0 ; j<n ; j++)arr[j]=sc.nextInt();
      String ans=solve(arr,n);
      System.out.println(ans);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class prog1 {
  static   operation solve( a : Sequence(int), n : int) : String
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] < a[i - 1+1]) then     return "YES" else skip )  ;     i := i + 1 ) ; 
     return "NO" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do (     arr[j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ; 
    var ans : String ; ans := solve(arr, n) ;
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Arrays ;
import java.util.Calendar ;
import java.util.Scanner ;
import javax.swing.plaf.basic.BasicComboBoxUI.ComboBoxLayoutManager ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      int y1=sc.nextInt();
      int m1=sc.nextInt();
      int d1=sc.nextInt();
      int y2=sc.nextInt();
      int m2=sc.nextInt();
      int d2=sc.nextInt();
      if(y1==-1)break ;
      Calendar cal1=Calendar.getInstance();
      cal1.set(y1,m1-1,d1,0,0,0);
      Calendar cal2=Calendar.getInstance();
      cal2.set(y2,m2-1,d2,0,0,0);
      long dd=(cal2.getTime().getTime()-cal1.getTime().getTime())/(1000*60*60*24);
      System.out.println(dd);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var y1 : int ; y1 := sc.getCurrent()->toInteger() ;
     var m1 : int ; m1 := sc.getCurrent()->toInteger() ;
    var d1 : int ; d1 := sc.getCurrent()->toInteger() ;
    var y2 : int ; y2 := sc.getCurrent()->toInteger() ;
    var m2 : int ; m2 := sc.getCurrent()->toInteger() ;
    var d2 : int ; d2 := sc.getCurrent()->toInteger() ;
    if (y1 = -1) then     break else skip ; 
    var cal1 : OclDate ; cal1 := OclDate.newOclDate() ;
    cal1 := cal1.setAt(y1+1, 0) ; 
    var cal2 : OclDate ; cal2 := OclDate.newOclDate() ;
    cal2 := cal2.setAt(y2+1, 0) ; 
    var dd : long ; dd := (cal2.time.getTime() - cal1.time.getTime()) / (1000 * 60 * 60 * 24) ;
    OclFile["System.out"].println(dd) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int toggleBitsFromLToR(int n,int l,int r){
    int num=((1<<r)-1)^((1<<(l-1))-1);
    return(n ^ num);
  }
  public static void main(String[] args){
    int n=50 ;
    int l=2,r=5 ;
    System.out.println(toggleBitsFromLToR(n,l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation toggleBitsFromLToR( n : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := MathLib.bitwiseXor((((1*(2->pow(r)))->oclAsType(long)) - 1),(((1*(2->pow((l - 1))))->oclAsType(long)) - 1)) ;
     return (n xor num) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 50 ;
     var l : int ; l := 2 ;
    var r : int ; r := 5 ;
     OclFile["System.out"].println(toggleBitsFromLToR(n, l, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  boolean isValidSubString(String r,int K,int p){
    int c=0 ;
    for(int i=0 ; i<r.length(); i++){
      if((int)r.charAt(i)>p){
        c++;
      }
    }
    if(c==K){
      return true ;
    }
    else {
      return false ;
    }
  }
  void countSubStrings(String s,int K,int p){
    int l=s.length();
    int count=0 ;
    for(int i=0 ; i<l ; i++){
      for(int j=K ; (i+j)<=l ; j++){
        String r=s.substring(i,(i+j));
        if(isValidSubString(r,K,p)){
          count++;
        }
      }
    }
    System.out.println(count);
  }
  public static void main(String args[]){
    GFG g=new GFG();
    String s="abepztydba" ;
    int K=4 ;
    int p=110 ;
    g.countSubStrings(s,K,p);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
   operation isValidSubString( r : String, K : int, p : int) : boolean
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
         var i : int ; i := 0 ; while i < r->size() do ( (     if (r->at(i+1)->oclAsType(int) > p) then (     c := c + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (c = K) then (     return true ) else (     return false ) );
   operation countSubStrings( s : String, K : int, p : int) : void
  pre: true
  post: true
  activity: (     var l : int ; l := s->size() ;
     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < l do ( (         var j : int ; j := K ; while (i + j) <= l do ( (     var r : String ; r := s.subrange(i+1,(i + j)) ;
     if (isValidSubString(r, K, p)) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : GFG ; g := GFG.newGFG() ;
     var s : String ; s := "abepztydba" ;
    var K : int ; K := 4 ;
    var p : int ; p := 110 ;
    g.countSubStrings(s, K, p) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int lenOfLongIncSubArr(int arr[],int n){
    int max=1,len=1 ;
    for(int i=1 ; i<n ; i++){
      if(arr[i]>arr[i-1])len++;
      else {
        if(max<len)max=len ;
        len=1 ;
      }
    }
    if(max<len)max=len ;
    return max ;
  }
  public static void main(String[] args){
    int arr[]={
      5,6,3,5,7,8,9,1,2 };
      int n=arr.length ;
      System.out.println("Length="+lenOfLongIncSubArr(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation lenOfLongIncSubArr( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max : int ; max := 1 ;
    var len : int ; len := 1 ;
         var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] > arr[i - 1+1]) then     len := len + 1 ; else (     if (max < len) then     max := len ; else skip ; 
     len := 1 ) )  ;     i := i + 1 ) ; 
     if (max < len) then     max := len ; else skip ; 
     return max );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,6,3,5,7,8,9,1,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Length=" + lenOfLongIncSubArr(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main implements Runnable {
  StreamTokenizer ST ;
  PrintWriter out ;
  BufferedReader br ;
  Scanner in ;
  String FileName="test" ;
  int inf=1000000000 ;
  int nextInt()throws IOException {
    ST.nextToken();
    return(int)ST.nval ;
  }
  String next()throws IOException {
    ST.nextToken();
    return ST.sval ;
  }
  double nextD()throws IOException {
    ST.nextToken();
    return ST.nval ;
  }
  public static void main(String[] args)throws IOException {
    new Thread(new Main()).start();
  }
  public void run(){
    try {
      out=new PrintWriter(new BufferedWriter(new FileWriter(new File("output.txt"))));
      br=new BufferedReader(new FileReader("input.txt"));
      in=new Scanner(br);
      ST=new StreamTokenizer(br);
      solve();
      out.close();
    }
    catch(IOException e){
      throw new IllegalStateException(e);
    }
  }
  public void solve()throws IOException {
    BigDecimal d=BigDecimal.valueOf(5);
    BigDecimal l=BigDecimal.valueOf(2);
    BigDecimal r=BigDecimal.valueOf(3);
    BigDecimal e=BigDecimal.valueOf(1);
    e=e.divide(BigDecimal.TEN.pow(100));
    while(r.subtract(l).compareTo(e)>0){
      BigDecimal m=l.add(r).divide(BigDecimal.valueOf(2));
      if(m.multiply(m).compareTo(d)>0)r=m ;
      else l=m ;
    }
    r=r.add(BigDecimal.valueOf(3));
    int tests=nextInt();
    for(int test=1 ; test<=tests ; test++){
      out.print("Case #"+test+": ");
      BigDecimal x=r.pow(nextInt());
      String s=x.toString();
      s="0"+s.substring(0,s.indexOf('.'));
      out.println(s.substring(s.length()-3,s.length()));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
   attribute ST : StreamTokenizer;
   attribute out : OclFile;
   attribute br : OclFile;
   attribute in : OclFile;
   attribute FileName : String := "test";
   attribute inf : int := 1000000000;
   operation nextInt() : int
  pre: true
  post: true
  activity: (     ST.next() ; 
     return ST.nval->oclAsType(int) );
   operation next() : String
  pre: true
  post: true
  activity: (     ST.next() ; 
     return ST.sval );
   operation nextD() : double
  pre: true
  post: true
  activity: (     ST.next() ; 
     return ST.nval );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(Main.newMain()).start() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile("output.txt")))) ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
    in := OclFile.newOclFile_Read(br) ; 
    ST := StreamTokenizer.newStreamTokenizer(br) ; 
    execute solve() ; 
    skip ; 
 )   catch (e : IOException) do (     error IncorrectElementException(e) )
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var d : double ; d := (5 + "")->toReal() ;
     var l : double ; l := (2 + "")->toReal() ;
    var r : double ; r := (3 + "")->toReal() ;
    var e : double ; e := (1 + "")->toReal() ;
    e := e.divide(10.0.pow(100)) ; 
    while (r.subtract(l)->compareTo(e) > 0) do (     var m : double ; m := l->excludes(r).divide((2 + "")->toReal()) ;
     if (m.multiply(m)->compareTo(d) > 0) then     r := m ; else     l := m ; ) ; 
    r := r->excludes((3 + "")->toReal()) ; 
    var tests : int ; tests := nextInt() ;
        var test : int ; test := 1 ; while test <= tests do ( (     skip ; 
     var x : double ; x := r.pow(nextInt()) ;
    var s : String ; s := x+"" ;
    s := "0" + s.subrange(0+1,s->indexOf('.')-1) ; 
    skip ; 
 )  ;     test := test + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import org.apfloat.*;
import java.util.*;
import java.math.*;
public class Numbers {
  static int[] jojojo={
    143,751,935,607,903,991,335,47,943,471,55,447,463,991,95,607,263,151,855,527,743,351,135,407,903,791,135,647,343,471,455,847,263,191,95,807,463,551,455,527,343,951,335,207,903,591,935,247,743,471,855,247,63,391,95,7,663,951,55,527,943,551,535,7,903,391,735,847,143,471,255,647,863,591,95,207,863,351,655,527,543,151,735,807,903,191,535,447,543,471,655,47,663,791,95,407,63,751,255,527 };
    static String jojojofunction(long l){
      if(l==0)return "001" ;
      if(l==1)return "005" ;
      if(l==2)return "027" ;
      String s=""+jojojo[(int)((l-3)% jojojo.length)];
      while(s.length()<3)s="0"+s ;
      return s ;
    }
    public static void main(String[] args){
      Scanner sc=new Scanner(System.in);
      for(int c=0,T=sc.nextInt(); c<T ; c++){
        System.out.println("Case #"+(c+1)+": "+jojojofunction(sc.nextLong()));
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Numbers {
  static   attribute jojojo : Sequence(int) := Sequence{143,751,935,607,903,991,335,47,943,471,55,447,463,991,95,607,263,151,855,527,743,351,135,407,903,791,135,647,343,471,455,847,263,191,95,807,463,551,455,527,343,951,335,207,903,591,935,247,743,471,855,247,63,391,95,7,663,951,55,527,943,551,535,7,903,391,735,847,143,471,255,647,863,591,95,207,863,351,655,527,543,151,735,807,903,191,535,447,543,471,655,47,663,791,95,407,63,751,255,527};
  static   operation jojojofunction( l : long) : String
  pre: true
  post: true
  activity: (     if (l = 0) then     return "001" else skip ; 
     if (l = 1) then     return "005" else skip ; 
    if (l = 2) then     return "027" else skip ; 
    var s : String ; s := "" + jojojo[((l - 3) mod jojojo->size())->oclAsType(int)+1] ;
    while (s->size() < 3) do     s := "0" + s ; ; 
    return s 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var c : int ; c := 0 ;
    var T : int ; T := sc.getCurrent()->toInteger() ; while c < T do ( (     OclFile["System.out"].println("Case #" + (c + 1) + ": " + jojojofunction(sc.getCurrent()->toLong())) )  ;     c := c + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class C {
  public static void main(String[] args)throws Throwable {
    StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    PrintWriter out=new PrintWriter(new BufferedWriter(new FileWriter("A-small.out")));
    BigDecimal X=new BigDecimal("3").add(new BigDecimal("2.2360679774997896964091736687312762354406183596115257242708972454105209256378048994144144083787822749695081761507737835042532677244470738635863601215334527088667781731918791658112766453226398565805357613504175337850034233924140644420864325390972525926272288762995174024406816117759089094984923713907297288984820886415426898940991316935770197486788844250897541329561831769214999774248015304341150359576683325124988151781394080005624208552435422355561063063428202340933319829339597463522712013417496142026359047378855043896870611356600457571399565955669569175645782219525000605392312340050092867648755297220567662536660744858535052623306784946334222423176372770266324076801044433158257335058930981362263431986864719469899701808189524264459620345221411922329125981963258111041704958070481204034559949435068555518555725123886416550102624363125710244496187894246829034044747161154557232017376765904609185295756035779843980541553807790643936397230287560629994822138521773485924535151210463455550407072278724215347787529112121211843317893351910380080111181790045906188462496471042442483088801294068113146959532794478989989316915774607924618075006798771242048473805027736082915599139624489149435606834625290644083279446426808889897460463083535378750420613747576068834018790881925591179735744641902485378711461940901919136880351103976384360412810581103786989518520146970456420217638928908844463778263858937924400460288754053984601560617052236150903857754100421936849872542718503752155576933167230047782698666624462106784642724863852745782134100679856453052711241805959728494551954513101723097508714965294362829025400120477803241554644899887061779981900336065622438864096392877535172662959714382279563079561495230154442350165389172786409130419793971113562821393674576811749220675621088878188736716716276226233798771115395096829828906830182590814010038955097232615084528345878936073463961172366783665719826079214402891190089955842415224957129183232167411899757201394037881977280152887234186683454183828673002743153202296076286125247610286423469630201118026912202360158101276284305418617176185751406901015616290917639812672259655962823490678546241618579455844426596128589375648549748034901108135575141664746219518302355259568865694958163530361955745368322352650077224225828736687534047007422326614517397665174206726444762196180242203979835368298350246626803054676876744690018695720995"));
    String[] ans=new String[31];
    for(int i=2 ; i<31 ; i++){
      ans[i]=m3(X.pow(i).toBigInteger().toString());
      System.out.println(i);
    }
    System.out.println("Ready.");
    in.nextToken();
    int t=(int)in.nval,iter=0 ;
    while(t-->0){
      iter++;
      in.nextToken();
      out.println("Case #"+iter+": "+ans[(int)in.nval]);
    }
    out.close();
    System.exit(0);
  }
  static String m3(String s){
    if(s.length()>3)s=s.substring(s.length()-3);
    while(s.length()<3)s="0"+s ;
    return s ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : StreamTokenizer ; in := StreamTokenizer.newStreamTokenizer(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("A-small.out")))) ;
    var X : double ; X := double("3")->excludes(double("2.2360679774997896964091736687312762354406183596115257242708972454105209256378048994144144083787822749695081761507737835042532677244470738635863601215334527088667781731918791658112766453226398565805357613504175337850034233924140644420864325390972525926272288762995174024406816117759089094984923713907297288984820886415426898940991316935770197486788844250897541329561831769214999774248015304341150359576683325124988151781394080005624208552435422355561063063428202340933319829339597463522712013417496142026359047378855043896870611356600457571399565955669569175645782219525000605392312340050092867648755297220567662536660744858535052623306784946334222423176372770266324076801044433158257335058930981362263431986864719469899701808189524264459620345221411922329125981963258111041704958070481204034559949435068555518555725123886416550102624363125710244496187894246829034044747161154557232017376765904609185295756035779843980541553807790643936397230287560629994822138521773485924535151210463455550407072278724215347787529112121211843317893351910380080111181790045906188462496471042442483088801294068113146959532794478989989316915774607924618075006798771242048473805027736082915599139624489149435606834625290644083279446426808889897460463083535378750420613747576068834018790881925591179735744641902485378711461940901919136880351103976384360412810581103786989518520146970456420217638928908844463778263858937924400460288754053984601560617052236150903857754100421936849872542718503752155576933167230047782698666624462106784642724863852745782134100679856453052711241805959728494551954513101723097508714965294362829025400120477803241554644899887061779981900336065622438864096392877535172662959714382279563079561495230154442350165389172786409130419793971113562821393674576811749220675621088878188736716716276226233798771115395096829828906830182590814010038955097232615084528345878936073463961172366783665719826079214402891190089955842415224957129183232167411899757201394037881977280152887234186683454183828673002743153202296076286125247610286423469630201118026912202360158101276284305418617176185751406901015616290917639812672259655962823490678546241618579455844426596128589375648549748034901108135575141664746219518302355259568865694958163530361955745368322352650077224225828736687534047007422326614517397665174206726444762196180242203979835368298350246626803054676876744690018695720995")) ;
    var ans : Sequence(String) ; ans := Integer.subrange(1,31)->collect(null) ;
        var i : int ; i := 2 ; while i < 31 do ( (     ans[i+1] := m3(X.pow(i).toBigInteger()+"") ; 
     OclFile["System.out"].println(i) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Ready.") ; 
    in.next() ; 
    var t : int ; t := in.nval->oclAsType(int) ;
    var iter : int ; iter := 0 ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     iter := iter + 1 ; 
     in.next() ; 
     skip ) ;  ) ;  
    skip ; 
OclProcess.exit(0) ; 
 );
  static   operation m3( s : String) : String
  pre: true
  post: true
  activity: (     if (s->size() > 3) then     s := s.subrange(s->size() - 3+1,s->size() - 3) ; else skip ; 
     while (s->size() < 3) do     s := "0" + s ; ; 
     return s );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class _0730GottaCatchEmAll {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String input=sc.nextLine();
    int[] arr=new int[200];
    for(int i=0 ; i<input.length(); i++){
      arr[input.charAt(i)]++;
    }
    String check="Bulbasaur" ;
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<check.length(); i++){
      char temp=check.charAt(i);
      if(temp=='a' || temp=='u'){
        min=Math.min(min,arr[temp]/2);
      }
      else {
        min=Math.min(min,arr[temp]);
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _0730GottaCatchEmAll {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : String ; input := sc.nextLine() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,200)->collect(0) ;
        var i : int ; i := 0 ; while i < input->size() do ( (     arr[input->at(i+1)+1] := arr[input->at(i+1)+1] + 1 )  ;     i := i + 1 ) ; 
    var check : String ; check := "Bulbasaur" ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < check->size() do ( (     var temp : String ; temp := check->at(i+1) ;
     if (temp = 'a' or temp = 'u') then (     min := Set{min, arr[temp+1] / 2}->min() ) else (     min := Set{min, arr[temp+1]}->min() ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.BigInteger ;
public class Main {
  final static String FNAME="c1" ;
  public Scanner in ;
  public PrintWriter out ;
  void open()throws IOException {
    in=new Scanner(new File(FNAME+".in"));
    out=new PrintWriter(new File(FNAME+".out"));
  }
  void close()throws IOException {
    out.close();
  }
  void run(){
    BigInteger two=new BigInteger("2");
    BigInteger l=new BigInteger("2").multiply(BigInteger.TEN.pow(35));
    BigInteger r=new BigInteger("3").multiply(BigInteger.TEN.pow(35));
    BigInteger p=new BigInteger("5").multiply(BigInteger.TEN.pow(70));
    while(! r.equals(l)){
      BigInteger m=l.add(r).divide(two);
      if(m.multiply(m).compareTo(p)>0){
        r=m ;
      }
      else {
        l=m.add(BigInteger.ONE);
      }
    }
    l=l.add(new BigInteger("3").multiply(BigInteger.TEN.pow(35)));
    int tn=in.nextInt();
    for(int test=1 ; test<=tn ; test++){
      int d=in.nextInt();
      String s=""+l.pow(d).divide(BigInteger.TEN.pow(d*35)).remainder(new BigInteger("1000"));
      while(s.length()<3){
        s='0'+s ;
      }
      out.println("Case #"+test+": "+s);
    }
  }
  public static void main(String[] args)throws IOException {
    new Thread(){
      public void run(){
        try {
          Main solution=new Main();
          solution.open();
          solution.run();
          solution.close();
        }
        catch(Exception e){
          throw new RuntimeException(e);
        }
      }
    }
.start();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute FNAME : String := "c1";
   attribute in : OclFile;
   attribute out : OclFile;
   operation open() : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile(FNAME + ".in")) ; 
     out := OclFile.newOclFile_Write(OclFile(FNAME + ".out")) );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
   operation run() : void
  pre: true
  post: true
  activity: (     var two : long ; two := long("2") ;
     var l : long ; l := long("2").multiply(10.pow(35)) ;
    var r : long ; r := long("3").multiply(10.pow(35)) ;
    var p : long ; p := long("5").multiply(10.pow(70)) ;
    while (not(r = l)) do (     var m : long ; m := l->excludes(r).divide(two) ;
     if (m.multiply(m)->compareTo(p) > 0) then (     r := m ) else (     l := m->excludes(1) ) ) ; 
    l := l->excludes(long("3").multiply(10.pow(35))) ; 
    var tn : int ; tn := in.getCurrent()->toInteger() ;
        var test : int ; test := 1 ; while test <= tn do ( (     var d : int ; d := in.getCurrent()->toInteger() ;
     var s : String ; s := "" + l.pow(d).divide(10.pow(d * 35)).remainder(long("1000")) ;
     while (s->size() < 3) do (     s := '0' + s ) ; 
     skip )  ;     test := test + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess().start() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
import java.util.*;
public class z {
  static BigDecimal sqrt(BigDecimal z){
    BigDecimal l=BigDecimal.valueOf(2);
    BigDecimal r=BigDecimal.valueOf(3);
    for(int i=0 ; i<100 ; i++){
      BigDecimal x=l.add(r).divide(BigDecimal.valueOf(2));
      if(x.multiply(x).compareTo(z)>=0)r=x ;
      else l=x ;
    };
    return l.add(r).divide(BigDecimal.valueOf(2));
  };
  public static void main(String args[]){
    BigDecimal t1=BigDecimal.valueOf(3);
    BigDecimal t2=t1.add(sqrt(BigDecimal.valueOf(5)));
    String s[]=new String[31];
    BigDecimal p=t2 ;
    for(int i=1 ; i<=30 ; i++){
      String q=""+p ;
      int h=q.indexOf('.');
      int b=Math.max(h-3,0);
      q=q.substring(b,h);
      while(q.length()<3)q="0"+q ;
      s[i]=q ;
      p=p.multiply(t2);
    };
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=1 ; i<=t ; i++){
      int h=in.nextInt();
      System.out.println("Case #"+i+": "+s[h]);
    };
  };
};
------------------------------------------------------------
OCL File:
---------
 class z {
  static   operation sqrt( z : double) : double
  pre: true
  post: true
  activity: (     var l : double ; l := (2 + "")->toReal() ;
     var r : double ; r := (3 + "")->toReal() ;
        var i : int ; i := 0 ; while i < 100 do ( (     var x : double ; x := l->excludes(r).divide((2 + "")->toReal()) ;
     if (x.multiply(x)->compareTo(z) >= 0) then     r := x ; else     l := x ; )  ;     i := i + 1 ) ; 
    return l->excludes(r).divide((2 + "")->toReal()) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t1 : double ; t1 := (3 + "")->toReal() ;
     var t2 : double ; t2 := t1->excludes(sqrt((5 + "")->toReal())) ;
    var s : Sequence(String) ; s := Integer.subrange(1,31)->collect(null) ;
    var p : double ; p := t2 ;
        var i : int ; i := 1 ; while i <= 30 do ( (     var q : String ; q := "" + p ;
     var h : int ; h := q->indexOf('.')-1 ;
    var b : int ; b := Set{(h)->char2byte() - 3, 0}->max() ;
    q := q.subrange(b+1,h) ; 
    while (q->size() < 3) do     q := "0" + q ; ; 
    s[i+1] := q ; 
    p := p.multiply(t2) ; 
 )  ;     i := i + 1 ) ; 
    var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= t do ( (     var h : int ; h := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println("Case #" + i + ": " + s[h+1]) )  ;     i := i + 1 ) ; 
 );
}
;

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int month[]={
      0,31,28,31,30,31,30,31,31,30,31,30,31 };
      for(; ; ){
        int y1=in.nextInt(),m1=in.nextInt(),d1=in.nextInt();
        int y2=in.nextInt(),m2=in.nextInt(),d2=in.nextInt();
        int cnt1=0 ;
        int cnt2=0 ;
        if(y1<0)break ;
        for(int i=1 ; i<y1 ; i++){
          if(year(i))cnt1+=366 ;
          else cnt1+=365 ;
        }
        for(int i=1 ; i<m1 ; i++){
          if(i==2 && year(y1))cnt1+=month[i]+1 ;
          else cnt1+=month[i];
        }
        cnt1+=d1 ;
        for(int i=1 ; i<y2 ; i++){
          if(year(i))cnt2+=366 ;
          else cnt2+=365 ;
        }
        for(int i=1 ; i<m2 ; i++){
          if(i==2 && year(y2))cnt2+=month[i]+1 ;
          else cnt2+=month[i];
        }
        cnt2+=d2 ;
        System.out.println(cnt2-cnt1);
      }
    }
    static boolean year(int y){
      if(y % 4==0 &&(y % 100!=0 || y % 400==0))return true ;
      else return false ;
    }
    static public void debug(Object...o){
      System.out.println(Arrays.deepToString(o));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var month : Sequence(int) ; month := Sequence{0,31,28,31,30,31,30,31,31,30,31,30,31} ;
       while true do ( (     var y1 : int ; y1 := in.getCurrent()->toInteger() ;
    var m1 : int ; m1 := in.getCurrent()->toInteger() ;
    var d1 : int ; d1 := in.getCurrent()->toInteger() ;
     var y2 : int ; y2 := in.getCurrent()->toInteger() ;
    var m2 : int ; m2 := in.getCurrent()->toInteger() ;
    var d2 : int ; d2 := in.getCurrent()->toInteger() ;
    var cnt1 : int ; cnt1 := 0 ;
    var cnt2 : int ; cnt2 := 0 ;
    if (y1 < 0) then     break else skip ; 
        var i : int ; i := 1 ; while i < y1 do ( (     if (year(i)) then     cnt1 := cnt1+(366) ; else     cnt1 := cnt1+(365) ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < m1 do ( (     if (i = 2 & year(y1)) then     cnt1 := cnt1+(month[i+1] + 1) ; else     cnt1 := cnt1+(month[i+1]) ; )  ;     i := i + 1 ) ; 
    cnt1 := cnt1+(d1) ; 
        var i : int ; i := 1 ; while i < y2 do ( (     if (year(i)) then     cnt2 := cnt2+(366) ; else     cnt2 := cnt2+(365) ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < m2 do ( (     if (i = 2 & year(y2)) then     cnt2 := cnt2+(month[i+1] + 1) ; else     cnt2 := cnt2+(month[i+1]) ; )  ;     i := i + 1 ) ; 
    cnt2 := cnt2+(d2) ; 
    OclFile["System.out"].println(cnt2 - cnt1) ; 
 )  ) );
  static   operation year( y : int) : boolean
  pre: true
  post: true
  activity: (     if (y mod 4 = 0 & (y mod 100 /= 0 or y mod 400 = 0)) then     return true else     return false );
  static    operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    new Main().solve();
  }
  private void solve()throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    double[] rs=new double[n];
    for(int i=0 ; i<n ; i++){
      rs[i]=sc.nextInt();
    }
    double[] pos=new double[n];
    pos[0]=rs[0];
    for(int i=1 ; i<n ; i++){
      double minLeft=rs[i];
      for(int j=0 ; j<i ; j++){
        double dl=2*Math.sqrt(rs[i]*rs[j]);
        minLeft=Math.max(minLeft,pos[j]+dl);
      }
      pos[i]=minLeft ;
    }
    double ans=0 ;
    for(int i=0 ; i<n ; i++){
      ans=Math.max(ans,pos[i]+rs[i]);
    }
    System.out.printf("%.8f%n",ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var rs : Sequence(double) ; rs := Integer.subrange(1,n)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do ( (     rs[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var pos : Sequence(double) ; pos := Integer.subrange(1,n)->collect(0.0) ;
    pos[0+1] := rs[0+1] ; 
        var i : int ; i := 1 ; while i < n do ( (     var minLeft : double ; minLeft := rs[i+1] ;
         var j : int ; j := 0 ; while j < i do ( (     var dl : double ; dl := 2 * (rs[i+1] * rs[j+1])->sqrt() ;
     minLeft := Set{minLeft, pos[j+1] + dl}->max() )  ;     j := j + 1 ) ; 
     pos[i+1] := minLeft )  ;     i := i + 1 ) ; 
    var ans : double ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ans := Set{ans, pos[i+1] + rs[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.8f%n", ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] R=new int[N];
    for(int i=0 ; i<N ; i++){
      R[i]=sc.nextInt();
    }
    double[] pos=new double[N];
    double max=0 ;
    for(int i=0 ; i<N ; i++){
      double pp=R[i];
      for(int j=0 ; j<i ; j++){
        double c=R[j]+R[i];
        double a=Math.abs(R[j]-R[i]);
        double b=Math.sqrt(c*c-a*a);
        pp=Math.max(pp,b+pos[j]);
      }
      pos[i]=pp ;
      max=Math.max(pos[i]+R[i],max);
    }
    System.out.printf("%.8f\n",max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var R : Sequence(int) ; R := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     R[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var pos : Sequence(double) ; pos := Integer.subrange(1,N)->collect(0.0) ;
    var max : double ; max := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var pp : double ; pp := R[i+1] ;
         var j : int ; j := 0 ; while j < i do ( (     var c : double ; c := R[j+1] + R[i+1] ;
     var a : double ; a := if R[j+1] - R[i+1] < 0 then -(R[j+1] - R[i+1]) else R[j+1] - R[i+1] endif ;
     var b : double ; b := (c * c - a * a)->sqrt() ;
     pp := Set{pp, b + pos[j+1]}->max() )  ;     j := j + 1 ) ; 
     pos[i+1] := pp ; 
     max := Set{pos[i+1] + R[i+1], max}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.8f\n", max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    SqueezeTheCylinders solver=new SqueezeTheCylinders();
    solver.solve(1,in,out);
    out.close();
  }
  static class SqueezeTheCylinders {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      double[] r=new double[n];
      for(int i=0 ; i<n ; i++){
        r[i]=in.nextDouble();
      }
      double[] center=new double[n];
      Arrays.fill(center,-1e9);
      center[0]=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<i ; j++){
          center[i]=Math.max(center[i],center[j]+Math.sqrt((r[i]+r[j])*(r[i]+r[j])-(r[i]-r[j])*(r[i]-r[j])));
        }
      }
      double L=1e9,R=-1e9 ;
      for(int i=0 ; i<n ; i++){
        L=Math.min(L,center[i]-r[i]);
        R=Math.max(R,center[i]+r[i]);
      }
      out.printf("%.8f\n",R-L);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : SqueezeTheCylinders ; solver := SqueezeTheCylinders.newSqueezeTheCylinders() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class SqueezeTheCylinders {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var r : Sequence(double) ; r := Integer.subrange(1,n)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do ( (     r[i+1] := in.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
    var center : Sequence(double) ; center := Integer.subrange(1,n)->collect(0.0) ;
    center := center->collect(-1e9) ; 
    center[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < i do ( (     center[i+1] := Set{center[i+1], center[j+1] + ((r[i+1] + r[j+1]) * (r[i+1] + r[j+1]) - (r[i+1] - r[j+1]) * (r[i+1] - r[j+1]))->sqrt()}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var L : double ; L := 1e9 ;
    var R : double ; R := -1e9 ;
        var i : int ; i := 0 ; while i < n do ( (     L := Set{L, center[i+1] - r[i+1]}->min() ; 
     R := Set{R, center[i+1] + r[i+1]}->max() )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.util.Scanner sc,java.io.PrintStream out){
    final int n=sc.nextInt();
    final double[] r=new double[n];
    for(int i=0 ; i<n ; ++i)r[i]=sc.nextInt();
    final double[] c=new double[n];
    c[0]=r[0];
    for(int i=1 ; i<n ; ++i){
      c[i]=r[i];
      for(int j=0 ; j<i ; ++j){
        c[i]=Math.max(c[i],c[j]+Math.sqrt(Math.pow(r[j]+r[i],2)-Math.pow(r[j]-r[i],2)));
      }
    }
    double res=0 ;
    for(int i=0 ; i<n ; ++i)res=Math.max(res,c[i]+r[i]);
    System.out.printf("%.8f\n",res);
  }
  public static void main(String[] args){
(new Main()).run(new java.util.Scanner(System.in),System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( sc : Scanner, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var r : Sequence(double) ; r := Integer.subrange(1,n)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do (     r[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
    var c : Sequence(double) ; c := Integer.subrange(1,n)->collect(0.0) ;
    c[0+1] := r[0+1] ; 
        var i : int ; i := 1 ; while i < n do ( (     c[i+1] := r[i+1] ; 
         var j : int ; j := 0 ; while j < i do ( (     c[i+1] := Set{c[i+1], c[j+1] + (r[j+1] + r[i+1]->pow(2) - r[j+1] - r[i+1]->pow(2))->sqrt()}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : double ; res := 0 ;
        var i : int ; i := 0 ; while i < n do (     res := Set{res, c[i+1] + r[i+1]}->max() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.8f\n", res) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(Scanner.newScanner(OclFile["System.in"]), OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      int l=sc.nextInt();
      if(n==0 && l==0){
        break ;
      }
      int[] map=new int[86500];
      int[] s=new int[n];
      int[] t=new int[n];
      int[] u=new int[n];
      for(int i=0 ; i<n ; i++){
        s[i]=sc.nextInt();
        t[i]=sc.nextInt();
        u[i]=sc.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        for(int j=s[i]; j<t[i]; j++){
          map[j]=u[i];
        }
      }
      double min=0 ;
      double max=1e7 ;
      for(; ; ){
        if(Math.abs(max-min)<1e-8){
          break ;
        }
        double med=(max+min)/2 ;
        double f=l ;
        boolean ok=true ;
        double f1=0 ;
        for(int i=0 ; i<86400 ; i++){
          f-=map[i];
          f+=med ;
          if(f>l){
            f=l ;
          }
          if(f<0){
            ok=false ;
            break ;
          }
        }
        f1=f ;
        for(int i=0 ; i<86400 ; i++){
          f-=map[i];
          f+=med ;
          if(f>l){
            f=l ;
          }
          if(f<0){
            ok=false ;
            break ;
          }
        }
        if(f<f1){
          ok=false ;
        }
        if(ok){
          max=med ;
        }
        else {
          min=med ;
        }
      }
      System.out.printf("%.7f\n",max);
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    if (n = 0 & l = 0) then (     break ) else skip ; 
    var map : Sequence(int) ; map := Integer.subrange(1,86500)->collect(0) ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
    var u : Sequence(int) ; u := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := sc.getCurrent()->toInteger() ; 
     t[i+1] := sc.getCurrent()->toInteger() ; 
     u[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := s[i+1] ; while j < t[i+1] do ( (     map[j+1] := u[i+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var min : double ; min := 0 ;
    var max : double ; max := 1e7 ;
      while true do ( (     if (if max - min < 0 then -(max - min) else max - min endif < 1e-8) then (     break ) else skip ; 
     var med : double ; med := (max + min) / 2 ;
    var f : double ; f := l ;
    var ok : boolean ; ok := true ;
    var f1 : double ; f1 := 0 ;
        var i : int ; i := 0 ; while i < 86400 do ( (     f := f-(map[i+1]) ; 
     f := f+(med) ; 
     if (f > l) then (     f := l ) else skip ; 
     if (f < 0) then (     ok := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    f1 := f ; 
        var i : int ; i := 0 ; while i < 86400 do ( (     f := f-(map[i+1]) ; 
     f := f+(med) ; 
     if (f > l) then (     f := l ) else skip ; 
     if (f < 0) then (     ok := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (f < f1) then (     ok := false ) else skip ; 
    if (ok) then (     max := med ) else (     min := med ) ;  
 )  ) ; 
    OclFile["System.out"].printf("%.7f\n", max) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class MobarkProblems {
  public static void main(String[] args){
    FastReader input=new FastReader();
    int test=input.nextInt();
    long num,div,steps=0 ;
    for(int i=0 ; i<test ; i++){
      num=input.nextLong();
      steps=0 ;
      while(num>1){
        if(num % 2==0 && num>2){
          div=num/2 ;
          num=num/div ;
          steps++;
        }
        else if(num % 3==0 && num>3){
          div=num/3 ;
          num=num/div ;
          steps++;
        }
        else {
          num-=1 ;
          steps++;
        }
      }
      System.out.println(steps);
    }
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    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 {
      if(st.hasMoreTokens()){
        str=st.nextToken("\n");
      }
      else {
        str=br.readLine();
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return str ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class MobarkProblems {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastReader ; input := FastReader.newFastReader() ;
     var test : int ; test := input.nextInt() ;
     var num : long ;
    var div : long ;
    var steps : long ; steps := 0 ;
         var i : int ; i := 0 ; while i < test do ( (     num := input.nextLong() ; 
     steps := 0 ; 
     while (num > 1) do (     if (num mod 2 = 0 & num > 2) then (     div := num / 2 ; 
     num := num / div ; 
     steps := steps + 1 ) else     if (num mod 3 = 0 & num > 3) then (     div := num / 3 ; 
     num := num / div ; 
     steps := steps + 1 ) else (     num := num-(1) ; 
     steps := steps + 1 ) ;  ) ; 
     OclFile["System.out"].println(steps) )  ;     i := i + 1 ) );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF_1451A_SubtractOrDivide_B {
  public static void main(String[] args){
    CF_1451A_SubtractOrDivide_B main=new CF_1451A_SubtractOrDivide_B();
    Scanner scanner=new Scanner(System.in);
    int count=scanner.nextInt();
    for(int i=0 ; i<count ; i++){
      int number=scanner.nextInt();
      if(number==1){
        System.out.println(0);
        continue ;
      }
      if(number==2){
        System.out.println(1);
        continue ;
      }
      if(number==3){
        System.out.println(2);
        continue ;
      }
      if(number % 2==1){
        System.out.println(3);
        continue ;
      }
      if(number % 2==0){
        System.out.println(2);
        continue ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF_1451A_SubtractOrDivide_B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : CFmain451A_SubtractOrDivide_B ; main := CFCFmain451A_SubtractOrDivide_B.newCFmain451A_SubtractOrDivide_B()451A_SubtractOrDivide_B.newCFCFmain451A_SubtractOrDivide_B.newCFmain451A_SubtractOrDivide_B()451A_SubtractOrDivide_B() ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < count do ( (     var number : int ; number := scanner.getCurrent()->toInteger() ;
     if (number = 1) then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
    if (number = 2) then (     OclFile["System.out"].println(1) ; 
     continue ) else skip ; 
    if (number = 3) then (     OclFile["System.out"].println(2) ; 
     continue ) else skip ; 
    if (number mod 2 = 1) then (     OclFile["System.out"].println(3) ; 
     continue ) else skip ; 
    if (number mod 2 = 0) then (     OclFile["System.out"].println(2) ; 
     continue ) else skip ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.ArrayList ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      System.out.println(Math.min(2+(n & 1),n-1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(Set{2 + (MathLib.bitwiseAnd(n,1)), n - 1}->min()) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    String s=in.next();
    char ch[]=s.toCharArray();
    int cb=0,sb=0,u=0,l=0,a=0,r=0,sc=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(ch[i]=='B'){
        cb++;
      }
      else if(ch[i]=='b'){
        sb++;
      }
      else if(ch[i]=='u'){
        u++;
      }
      else if(ch[i]=='l'){
        l++;
      }
      else if(ch[i]=='a'){
        a++;
      }
      else if(ch[i]=='s'){
        sc++;
      }
      else if(ch[i]=='r'){
        r++;
      }
    }
    u=u/2 ;
    a=a/2 ;
    int ara[]=new int[7];
    ara[0]=cb ;
    ara[1]=sb ;
    ara[2]=l ;
    ara[3]=u ;
    ara[4]=a ;
    ara[5]=r ;
    ara[6]=sc ;
    Arrays.sort(ara);
    pw.println(ara[0]);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : String ; s := in.getCurrent() ;
    var ch : Sequence(String) ; ch := s->characters() ;
    var cb : int ; cb := 0 ;
    var sb : int ; sb := 0 ;
    var u : int ; u := 0 ;
    var l : int ; l := 0 ;
    var a : int ; a := 0 ;
    var r : int ; r := 0 ;
    var sc : int ; sc := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (ch[i+1] = 'B') then (     cb := cb + 1 ) else     if (ch[i+1] = 'b') then (     sb := sb + 1 ) else     if (ch[i+1] = 'u') then (     u := u + 1 ) else     if (ch[i+1] = 'l') then (     l := l + 1 ) else     if (ch[i+1] = 'a') then (     a := a + 1 ) else     if (ch[i+1] = 's') then (     sc := sc + 1 ) else     if (ch[i+1] = 'r') then (     r := r + 1 ) else skip ; ;  ;  ;  ;  ;  )  ;     i := i + 1 ) ; 
    u := u / 2 ; 
    a := a / 2 ; 
    var ara : Sequence(int) ; ara := Integer.subrange(1,7)->collect(0) ;
    ara[0+1] := cb ; 
    ara[1+1] := sb ; 
    ara[2+1] := l ; 
    ara[3+1] := u ; 
    ara[4+1] := a ; 
    ara[5+1] := r ; 
    ara[6+1] := sc ; 
    ara := ara->sort() ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test301 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int x=in.nextInt();
      if(x==1){
        System.out.println(0);
      }
      else if(x==2){
        System.out.println(1);
      }
      else if(x % 2==0 || x==3){
        System.out.println(2);
      }
      else {
        System.out.println(3);
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test301 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     if (x = 1) then (     OclFile["System.out"].println(0) ) else     if (x = 2) then (     OclFile["System.out"].println(1) ) else     if (x mod 2 = 0 or x = 3) then (     OclFile["System.out"].println(2) ) else (     OclFile["System.out"].println(3) ) ;  ;  )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      StringTokenizer st=new StringTokenizer(line);
      int m,nmin,nmax ;
      m=parseInt(st.nextToken());
      nmin=parseInt(st.nextToken());
      nmax=parseInt(st.nextToken());
      if((m | nmin | nmax)==0)break ;
      int[] ns=new int[m];
      for(int i=0 ; i<m ; i++){
        ns[i]=parseInt(br.readLine());
      }
      int max=-1,n=nmin ;
      for(int i=nmin-1 ; i<nmax ; i++){
        int gap=ns[i]-ns[i+1];
        if(max<=gap){
          max=gap ;
          n=i+1 ;
        }
      }
      System.out.println(n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var st : OclIterator ; st := OclIterator.newOclIterator_String(line) ;
     var m : int ;
    var nmin : int ;
    var nmax : int ;
    m := (st.next() + "")->toInteger() ; 
    nmin := (st.next() + "")->toInteger() ; 
    nmax := (st.next() + "")->toInteger() ; 
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(m,nmin),nmax)) = 0) then     break else skip ; 
    var ns : Sequence(int) ; ns := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     ns[i+1] := (br.readLine() + "")->toInteger() )  ;     i := i + 1 ) ; 
    var max : int ; max := -1 ;
    var n : int ; n := nmin ;
        var i : int ; i := nmin - 1 ; while i < nmax do ( (     var gap : int ; gap := ns[i+1] - ns[i + 1+1] ;
     if (max <= gap) then (     max := gap ; 
     n := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    BigInteger a=new BigInteger(str);
    str=sc.next();
    BigInteger b=new BigInteger(str);
    System.out.println(a.multiply(b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var a : long ; a := long(str) ;
    str := sc.getCurrent() ; 
    var b : long ; b := long(str) ;
    OclFile["System.out"].println(a.multiply(b)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int[] mon={
    0,31,28,31,30,31,30,31,31,30,31,30,31 };
    class date {
      int y ;
      int m ;
      int d ;
      date(int q,int w,int e){
        y=q ;
        m=w ;
        d=e ;
      }
      long serialValue(){
        long ret=0 ;
        y-=1 ;
        ret+=y*365 ;
        ret+=y/4 ;
        ret-=y/100 ;
        ret+=y/400 ;
        for(int i=0 ; i<m ; i++){
          ret+=mon[i];
        }
        y+=1 ;
        if(y % 400==0 ||(y % 100!=0 && y % 4==0)){
          if(m>2){
            ret+=1 ;
          }
        }
        ret+=d ;
        return ret ;
      }
    }
    void run(){
      for(; ; ){
        int[] in=new int[6];
        int flag=0 ;
        for(int i=0 ; i<6 ; i++){
          in[i]=sc.nextInt();
          flag |=in[i];
        }
        if(flag<0){
          break ;
        }
        date a=new date(in[0],in[1],in[2]);
        date b=new date(in[3],in[4],in[5]);
        System.out.println(b.serialValue()-a.serialValue());
      }
    }
    public static void main(String[] args){
      Main m=new Main();
      m.run();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute mon : Sequence(int) := Sequence{0,31,28,31,30,31,30,31,31,30,31,30,31};
 class date {
   attribute y : int;
   attribute m : int;
   attribute d : int;
   static operation newdate( q : int, w : int, e : int) : date
  pre: true
  post: true
  activity:
  ( var self : date ;
    self := createdate();
    self.initialise(q, w,e);
    return self );
  operation initialise( q : int, w : int, e : int) : void
  pre: true  post: true
  activity: (     y := q ; 
     m := w ; 
     d := e );
   operation serialValue() : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := 0 ;
     y := y-(1) ; 
    ret := ret+(y * 365) ; 
    ret := ret+(y / 4) ; 
    ret := ret-(y / 100) ; 
    ret := ret+(y / 400) ; 
        var i : int ; i := 0 ; while i < m do ( (     ret := ret+(mon[i+1]) )  ;     i := i + 1 ) ; 
    y := y+(1) ; 
    if (y mod 400 = 0 or (y mod 100 /= 0 & y mod 4 = 0)) then (     if (m > 2) then (     ret := ret+(1) ) else skip ) else skip ; 
    ret := ret+(d) ; 
    return ret 
 );
}
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var in : Sequence(int) ; in := Integer.subrange(1,6)->collect(0) ;
     var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < 6 do ( (     in[i+1] := sc.getCurrent()->toInteger() ; 
     flag := MathLib.bitwiseOr(flag, in[i+1]) )  ;     i := i + 1 ) ; 
    if (flag < 0) then (     break ) else skip ; 
    var a : date ; a := date.newdate(in[0+1], in[1+1], in[2+1]) ;
    var b : date ; b := date.newdate(in[3+1], in[4+1], in[5+1]) ;
    OclFile["System.out"].println(b.serialValue() - a.serialValue()) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class lucky_number {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int fl=0 ;
    for(int i=1 ; i<=n ; i++){
      if((i % 4==0)||(i % 7==0)||(i % 47==0)||(i % 477==0)){
        if(n % i==0){
          fl=1 ;
          System.out.println("YES");
          break ;
        }
      }
    }
    if(fl==0)System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class lucky_number {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var fl : int ; fl := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     if ((i mod 4 = 0) or (i mod 7 = 0) or (i mod 47 = 0) or (i mod 477 = 0)) then (     if (n mod i = 0) then (     fl := 1 ; 
     OclFile["System.out"].println("YES") ; 
     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (fl = 0) then     OclFile["System.out"].println("NO") ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A122 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String[] arr={
      "4","7" };
      String s="" ;
      String s1="" ;
      int[] three=new int[14];
      three[0]=4 ;
      three[1]=7 ;
      int a=2 ;
      for(int i=0 ; i<2 ; i++){
        for(int j=0 ; j<2 ; j++){
          s1+=arr[i]+arr[j];
          int o=Integer.parseInt(s1);
          s1="" ;
          three[a]=o ;
          a+=1 ;
          for(int k=0 ; k<2 ; k++){
            s+=arr[i]+arr[j]+arr[k];
            int p=Integer.parseInt(s);
            s="" ;
            three[a]=p ;
            a+=1 ;
          }
        }
      }
      for(int i : three){
        if(n % i==0){
          System.out.println("YES");
          System.exit(0);
        }
      }
      System.out.println("NO");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class A122 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := Sequence{"4","7"} ;
    var s : String ; s := "" ;
    var s1 : String ; s1 := "" ;
    var three : Sequence(int) ; three := Integer.subrange(1,14)->collect(0) ;
    three[0+1] := 4 ; 
    three[1+1] := 7 ; 
    var a : int ; a := 2 ;
        var i : int ; i := 0 ; while i < 2 do ( (         var j : int ; j := 0 ; while j < 2 do ( (     s1 := s1+(arr[i+1] + arr[j+1]) ; 
     var o : int ; o := (s1)->toInteger() ;
    s1 := "" ; 
    three[a+1] := o ; 
    a := a+(1) ; 
        var k : int ; k := 0 ; while k < 2 do ( (     s := s+(arr[i+1] + arr[j+1] + arr[k+1]) ; 
     var p : int ; p := (s)->toInteger() ;
    s := "" ; 
    three[a+1] := p ; 
    a := a+(1) ; 
 )  ;     k := k + 1 ) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    for (i : three) do ( (     if (n mod i = 0) then (     OclFile["System.out"].println("YES") ; 
 OclProcess.exit(0) ) else skip )  ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    if(a % 4==0 || a % 7==0 || a % 47==0 || a % 74==0 || a % 477==0)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (a mod 4 = 0 or a mod 7 = 0 or a mod 47 = 0 or a mod 74 = 0 or a mod 477 = 0) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    solve(n);
  }
  public static void solve(int n){
    String a=Integer.toString(n);
    if(n % 4==0 || n % 47==0 || n % 7==0){
      System.out.println("YES");
      return ;
    }
    a=a.replace("4","");
    a=a.replace("7","");
    if(a.length()==0)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     execute solve(n) );
  static   operation solve( n : int) : void
  pre: true
  post: true
  activity: (     var a : String ; a := ((n) + "") ;
     if (n mod 4 = 0 or n mod 47 = 0 or n mod 7 = 0) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
    a := a.replace("4", "") ; 
    a := a.replace("7", "") ; 
    if (a->size() = 0) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class test {
  static List<Integer>list ;
  static void getAll(){
    for(int i=1 ; i<1000 ; i++){
      if(lucky(i))list.add(i);
    }
  }
  static boolean lucky(int n){
    while(n>0){
      if(n % 10==4 || n % 10==7){
        n/=10 ;
        continue ;
      }
      else return false ;
    }
    return true ;
  }
  static boolean div(int x){
    int n=list.size();
    for(int i=0 ; i<n ; i++){
      if(x % list.get(i)==0)return true ;
    }
    return false ;
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    list=new ArrayList<>();
    getAll();
    int n=sc.nextInt();
    if(div(n))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   attribute list : Sequence(int);
  static   operation getAll() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < 1000 do ( (     if (lucky(i)) then     list := list->including(i) ; else skip )  ;     i := i + 1 ) );
  static   operation lucky( n : int) : boolean
  pre: true
  post: true
  activity: (     while (n > 0) do (     if (n mod 10 = 4 or n mod 10 = 7) then (     n := n/(10) ; 
     continue ) else     return false ) ; 
     return true );
  static   operation div( x : int) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := list->size() ;
         var i : int ; i := 0 ; while i < n do ( (     if (x mod list->at(i+1) = 0) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     list := Sequence{} ; 
    execute getAll() ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
    if (div(n)) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<=n ; i++){
      if(i*(i+1)/2==n){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i <= n do ( (     if (i * (i + 1) / 2 = n) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("NO") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_TriangularNumbers {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String res="" ;
    for(int i=1 ; i<=n ; i++){
      if(n==i*(i+1)/2){
        res="YES" ;
        break ;
      }
      else {
        res="NO" ;
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_TriangularNumbers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var res : String ; res := "" ;
        var i : int ; i := 1 ; while i <= n do ( (     if (n = i * (i + 1) / 2) then (     res := "YES" ; 
     break ) else (     res := "NO" ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    long n ;
    Scanner in=new Scanner(System.in);
    n=in.nextInt();
    long triangular=1 ;
    long i=1 ;
    while(triangular<n){
      i+=1 ;
      triangular+=i ;
    }
    if(triangular==n){
      System.out.print("YES");
    }
    else {
      System.out.print("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := in.getCurrent()->toInteger() ; 
    var triangular : long ; triangular := 1 ;
    var i : long ; i := 1 ;
    while (triangular < n) do (     i := i+(1) ; 
     triangular := triangular+(i) ) ; 
    if (triangular = n) then (     OclFile["System.out"].print("YES") ) else (     OclFile["System.out"].print("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Code {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    System.out.println(triangularNumberChecker(in.nextInt()));
    in.close();
  }
  private static String triangularNumberChecker(int a){
    a=2*a ;
    for(int i=1 ; i<=a ; i++){
      if((a % i==0 && a %(i+1)==0)&&(a/i==a/(i+1)+1)){
        return "YES" ;
      }
    }
    return "NO" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println(triangularNumberChecker(in.getCurrent()->toInteger())) ; 
     skip );
  static   operation triangularNumberChecker( a : int) : String
  pre: true
  post: true
  activity: (     a := 2 * a ; 
         var i : int ; i := 1 ; while i <= a do ( (     if ((a mod i = 0 & a mod (i + 1) = 0) & (a / i = a / (i + 1) + 1)) then (     return "YES" ) else skip )  ;     i := i + 1 ) ; 
     return "NO" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int smallestSum(int n){
    if(n==1)return 0 ;
    return(2*(int)Math.pow(10,n-1));
  }
  static int largestSum(int n){
    return(2*((int)Math.pow(10,n)-1));
  }
  public static void main(String args[]){
    int n=4 ;
    System.out.println("Largest="+largestSum(n));
    System.out.print("Smallest="+smallestSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation smallestSum( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 0 else skip ; 
     return (2 * 10->pow(n - 1)->oclAsType(int)) );
  static   operation largestSum( n : int) : int
  pre: true
  post: true
  activity: (     return (2 * (10->pow(n)->oclAsType(int) - 1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println("Largest=" + largestSum(n)) ; 
     OclFile["System.out"].print("Smallest=" + smallestSum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int lcs(String X,String Y,int m,int n){
    int L[][]=new int[m+1][n+1];
    for(int i=0 ; i<=m ; i++){
      for(int j=0 ; j<=n ; j++){
        if(i==0 || j==0)L[i][j]=0 ;
        else if(X.charAt(i-1)==Y.charAt(j-1))L[i][j]=L[i-1][j-1]+1 ;
        else L[i][j]=Math.max(L[i-1][j],L[i][j-1]);
      }
    }
    return L[m][n];
  }
  static int findMinCost(String X,String Y,int costX,int costY){
    int m=X.length();
    int n=Y.length();
    int len_LCS ;
    len_LCS=lcs(X,Y,m,n);
    return costX*(m-len_LCS)+costY*(n-len_LCS);
  }
  public static void main(String[] args){
    String X="ef" ;
    String Y="gh" ;
    System.out.println("Minimum Cost to make two strings "+" identical is="+findMinCost(X,Y,10,20));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation lcs( X : String, Y : String, m : int, n : int) : int
  pre: true
  post: true
  activity: (     var L : Sequence(Sequence(int)) ; L := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i <= m do ( (         var j : int ; j := 0 ; while j <= n do ( (     if (i = 0 or j = 0) then     L[i+1][j+1] := 0 ; else     if (X->at(i - 1+1) = Y->at(j - 1+1)) then     L[i+1][j+1] := L[i - 1+1][j - 1+1] + 1 else     L[i+1][j+1] := Set{L[i - 1+1][j+1], L[i+1][j - 1+1]}->max() ; ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return L[m+1][n+1] );
  static   operation findMinCost( X : String, Y : String, costX : int, costY : int) : int
  pre: true
  post: true
  activity: (     var m : int ; m := X->size() ;
     var n : int ; n := Y->size() ;
    var len_LCS : int ;
    len_LCS := lcs(X, Y, m, n) ; 
    return costX * (m - len_LCS) + costY * (n - len_LCS) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : String ; X := "ef" ;
     var Y : String ; Y := "gh" ;
     OclFile["System.out"].println("Minimum Cost to make two strings " + " identical is=" + findMinCost(X, Y, 10, 20)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<=n ; i++){
      if(i*(i+1)/2==n){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i <= n do ( (     if (i * (i + 1) / 2 = n) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("NO") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int distinctChars(String s){
    int freq[]=new int[26];
    int count=0 ;
    for(int i=0 ; i<s.length(); i++)freq[s.charAt(i)-'a']++;
    for(int i=0 ; i<26 ; i++){
      if(freq[i]>0)count++;
    }
    return count ;
  }
  static int waysToSplit(String s){
    int n=s.length();
    int answer=0 ;
    for(int i=1 ; i<n ; i++){
      String left=s.substring(0,i);
      String right=s.substring(i,n);
      if(distinctChars(left)==distinctChars(right))answer++;
    }
    return answer ;
  }
  public static void main(String[] args){
    String s="ababa" ;
    System.out.print(waysToSplit(s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation distinctChars( s : String) : int
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
     var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < s->size() do (     freq[s->at(i+1) - ('a')->char2byte()+1] := freq[s->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 26 do ( (     if (freq[i+1] > 0) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation waysToSplit( s : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var answer : int ; answer := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     var left : String ; left := s.subrange(0+1,i) ;
     var right : String ; right := s.subrange(i+1,n) ;
     if (distinctChars(left) = distinctChars(right)) then     answer := answer + 1 ; else skip )  ;     i := i + 1 ) ; 
     return answer );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "ababa" ;
     OclFile["System.out"].print(waysToSplit(s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    double d,i ;
    d=sc.nextDouble();
    if(d<1)out.println(d*Math.sqrt(2));
    else if(d<Math.sqrt(2))out.println("2");
    else if(d<2)out.println(d*Math.sqrt(2));
    else if(d<Math.sqrt(2)*1.5)out.println("3");
    else out.println(d*Math.sqrt(2));
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var d : double ;
    var i : double ;
    d := sc.nextDouble() ; 
    if (d < 1) then     out.println(d * (2)->sqrt()) else     if (d < (2)->sqrt()) then     out.println("2") else     if (d < 2) then     out.println(d * (2)->sqrt()) else     if (d < (2)->sqrt() * 1.5) then     out.println("3") else     out.println(d * (2)->sqrt()) ; ;  ;  ;  ;  
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    double d=in.nextDouble();
    double cand1=Math.sqrt(Math.pow(d,2)/2)*2 ;
    double cand2=Double.MIN_VALUE ;
    if(d<=Math.sqrt(Math.pow((int)d,2)+1)){
      cand2=(int)d+1 ;
    }
    System.out.println(Math.max(cand1,cand2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : double ; d := in.getCurrent()->toReal() ;
    var cand1 : double ; cand1 := (d->pow(2) / 2)->sqrt() * 2 ;
    var cand2 : double ; cand2 := 2->pow(-1074) ;
    if (d <= (d->oclAsType(int)->pow(2) + 1)->sqrt()) then (     cand2 := d->oclAsType(int) + 1 ) else skip ; 
    OclFile["System.out"].println(Set{cand1, cand2}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double d=Double.parseDouble(sc.next());
    double e=(int)d+1 ;
    e=Math.max(e,d/Math.sqrt(2)*2);
    System.out.println(e);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : double ; d := (sc.getCurrent())->toReal() ;
    var e : double ; e := d->oclAsType(int) + 1 ;
    e := Set{e, d / (2)->sqrt() * 2}->max() ; 
    OclFile["System.out"].println(e) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    double d=sc.nextDouble();
    double ans=Math.max((int)d+1,d/Math.sqrt(2)*2);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : double ; d := sc.getCurrent()->toReal() ;
     var ans : double ; ans := Set{d->oclAsType(int) + 1, d / (2)->sqrt() * 2}->max() ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  static int Triplets(int n){
    int ans=0 ;
    for(int i=1 ; i<=n ; ++i){
      for(int j=i ; j<=n ; ++j){
        int x=i*i+j*j ;
        int y=(int)Math.sqrt(x);
        if(y*y==x && y<=n)++ans ;
      }
    }
    return ans ;
  }
  public static void main(String args[]){
    int n=10 ;
    System.out.println(Triplets(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
  static   operation Triplets( n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i ; while j <= n do ( (     var x : int ; x := i * i + j * j ;
     var y : int ; y := (x)->sqrt()->oclAsType(int) ;
     if (y * y = x & y <= n) then     ans := ans + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(Triplets(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Queue ;
class GFG {
  public static int countUnvisited(int n,int m){
    int X=(m*n)-m-n ;
    Queue<Integer>queue=new LinkedList<>();
    queue.add(X);
    int count=0 ;
    while(! queue.isEmpty()){
      int curr=queue.poll();
      count++;
      if(curr-m>0)queue.add(curr-m);
      if(curr-n>0)queue.add(curr-n);
    }
    return count ;
  }
  public static void main(String args[]){
    int n=2,m=5 ;
    System.out.print(countUnvisited(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countUnvisited( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var X : int ; X := (m * n) - m - n ;
     var queue : Sequence(int) ; queue := Sequence{} ;
    queue := queue->including(X) ; 
    var count : int ; count := 0 ;
    while (not(queue->isEmpty())) do (     var curr : int ; curr := queue->min() ;
     count := count + 1 ; 
     if (curr - m > 0) then     queue := queue->including(curr - m) ; else skip ; 
     if (curr - n > 0) then     queue := queue->including(curr - n) ; else skip ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
    var m : int ; m := 5 ;
     OclFile["System.out"].print(countUnvisited(n, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void dist(double x1,double y1,double x2,double y2,double r){
    System.out.println("The shortest distance "+"between a point and a circle is "+(Math.sqrt((Math.pow((x2-x1),2))+(Math.pow((y2-y1),2)))-r));
  }
  public static void main(String[] args){
    double x1=4,y1=6,x2=35,y2=42,r=5 ;
    dist(x1,y1,x2,y2,r);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation dist( x1 : double, y1 : double, x2 : double, y2 : double, r : double) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("The shortest distance " + "between a point and a circle is " + ((((x2 - x1)->pow(2)) + ((y2 - y1)->pow(2)))->sqrt() - r)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x1 : double ; x1 := 4 ;
    var y1 : double ; y1 := 6 ;
    var x2 : double ; x2 := 35 ;
    var y2 : double ; y2 := 42 ;
    var r : double ; r := 5 ;
     execute dist(x1, y1, x2, y2, r) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static ArrayList<Integer>al[];
  static boolean vis[];
  static int max ;
  static void DFS(int node){
    vis[node]=true ;
    max++;
    for(int i : al[node]){
      if(vis[i]==false){
        DFS(i);
      }
    }
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    PrintWriter w=new PrintWriter(System.out);
    int n=sc.nextInt();
    int m=sc.nextInt();
    al=new ArrayList[n];
    Arrays.setAll(al,e->new ArrayList());
    vis=new boolean[n];
    for(int i=0 ; i<m ; i++){
      int temp1=sc.nextInt()-1 ;
      int temp2=sc.nextInt()-1 ;
      al[temp1] .add(temp2);
      al[temp2] .add(temp1);
    }
    int fin_max=0 ;
    for(int i=0 ; i<n ; i++){
      if(vis[i]==false){
        max=0 ;
        DFS(i);
        fin_max=Math.max(fin_max,max);
      }
    }
    w.println(fin_max);
    w.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute al : Sequence(Sequence(int));
  static   attribute vis : Sequence(boolean);
  static   attribute max : int;
  static   operation DFS( node : int) : void
  pre: true
  post: true
  activity: (     vis[node+1] := true ; 
     max := max + 1 ; 
     for (i : al[node+1]) do ( (     if (vis[i+1] = false) then (     execute DFS(i) ) else skip )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : OclFile ; w := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    al := Integer.subrange(1,n)->collect(null) ; 
setAll(al, lambda e : OclAny in Sequence{}) ; 
    vis := Integer.subrange(1,n)->collect(false) ; 
        var i : int ; i := 0 ; while i < m do ( (     var temp1 : int ; temp1 := sc.getCurrent()->toInteger() - 1 ;
     var temp2 : int ; temp2 := sc.getCurrent()->toInteger() - 1 ;
     al[temp1+1]->excludes(temp2) ; 
     al[temp2+1]->excludes(temp1) )  ;     i := i + 1 ) ; 
    var fin_max : int ; fin_max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (vis[i+1] = false) then (     max := 0 ; 
     execute DFS(i) ; 
     fin_max := Set{fin_max, max}->max() ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class d2 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    List<Integer>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      list.add(in.nextInt());
    }
    Collections.sort(list);
    if(n % 2==0){
      System.out.println(list.get((n-1)/2));
    }
    else {
      System.out.println(list.get(n/2));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class d2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    if (n mod 2 = 0) then (     OclFile["System.out"].println(list->at((n - 1) / 2+1)) ) else (     OclFile["System.out"].println(list->at(n / 2+1)) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  static int countRectangles(int l,int w){
    int squareSide=__gcd(l,w);
    return(l*w)/(squareSide*squareSide);
  }
  public static void main(String[] args){
    int l=4,w=6 ;
    System.out.println(countRectangles(l,w));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation countRectangles( l : int, w : int) : int
  pre: true
  post: true
  activity: (     var squareSide : int ; squareSide := __gcd(l, w) ;
     return (l * w) / (squareSide * squareSide) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 4 ;
    var w : int ; w := 6 ;
     OclFile["System.out"].println(countRectangles(l, w)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int[] data ;
  static int[] w ;
  static int root(int q){
    if(data[q]!=q){
      data[q]=root(data[q]);
    }
    return data[q];
  }
  static void union(int p,int q){
    int rp=root(p);
    int rq=root(q);
    if(w[rp]>w[rq]){
      data[rq]=rp ;
      w[rp]+=w[rq];
    }
    else {
      data[rp]=rq ;
      w[rq]+=w[rp];
    }
  }
  static boolean find(int p,int q){
    return root(p)==root(q);
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    data=new int[n];
    w=new int[n];
    for(int i=0 ; i<n ; i++){
      data[i]=i ;
      w[i]=1 ;
    }
    for(int i=0 ; i<m ; i++){
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      if(! find(a-1,b-1))union(a-1,b-1);
    }
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(data[i]==i)ans=Math.max(ans,w[i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute data : Sequence(int);
  static   attribute w : Sequence(int);
  static   operation root( q : int) : int
  pre: true
  post: true
  activity: (     if (data[q+1] /= q) then (     data[q+1] := root(data[q+1]) ) else skip ; 
     return data[q+1] );
  static   operation union( p : int, q : int) : void
  pre: true
  post: true
  activity: (     var rp : int ; rp := root(p) ;
     var rq : int ; rq := root(q) ;
     if (w[rp+1] > w[rq+1]) then (     data[rq+1] := rp ; 
     w[rp+1] := w[rp+1]+(w[rq+1]) ) else (     data[rp+1] := rq ; 
     w[rq+1] := w[rq+1]+(w[rp+1]) ) );
  static   operation find( p : int, q : int) : boolean
  pre: true
  post: true
  activity: (     return root(p) = root(q) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    data := Integer.subrange(1,n)->collect(0) ; 
    w := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     data[i+1] := i ; 
     w[i+1] := 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
     if (not(find(a - 1, b - 1))) then     execute union(a - 1, b - 1) ; else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (data[i+1] = i) then     ans := Set{ans, w[i+1]}->max() ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Map.Entry ;
class Main {
  static int mod=(int)(Math.pow(10,9)+7);
  static List<ArrayList<Integer>>list=new ArrayList<ArrayList<Integer>>();
  static int a_dist[];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    for(long i=0 ; i<N ; i++)list.add(new ArrayList<Integer>());
    long[][] a=new long[M][2];
    for(long i=0 ; i<M ; i++){
      int ai=sc.nextInt()-1 ;
      int bi=sc.nextInt()-1 ;
      list.get(ai).add(bi);
      list.get(bi).add(ai);
    }
    long ans=0 ;
    boolean[] visited=new boolean[N];
    LinkedList<Integer>q=new LinkedList<Integer>();
    for(int i=0 ; i<N ; i++){
      if(visited[i]==true)continue ;
      int cnt=1 ;
      visited[i]=true ;
      q.add(i);
      q.add(-1);
      while(! q.isEmpty()){
        int now=q.poll();
        int parent=q.poll();
        for(int j=0 ; j<list.get(now).size(); j++){
          int next=list.get(now).get(j);
          if(next==parent)continue ;
          if(visited[next]==true)continue ;
          visited[next]=true ;
          cnt++;
          q.add(next);
          q.add(now);
        }
      }
      ans=Math.max(ans,cnt);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := (10->pow(9) + 7)->oclAsType(int);
  static   attribute list : Sequence(Sequence(int)) := Sequence{};
  static   attribute a_dist : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
        var i : long ; i := 0 ; while i < N do (     list := list->including(Sequence{}) ;  ;     i := i + 1 ) ; 
    var a : Sequence(Sequence(long)) ; a := Integer.subrange(1,M)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : long ; i := 0 ; while i < M do ( (     var ai : int ; ai := sc.getCurrent()->toInteger() - 1 ;
     var bi : int ; bi := sc.getCurrent()->toInteger() - 1 ;
     list->at(ai+1)->excludes(bi) ; 
     list->at(bi+1)->excludes(ai) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,N)->collect(false) ;
    var q : Sequence(int) ; q := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     if (visited[i+1] = true) then     continue else skip ; 
     var cnt : int ; cnt := 1 ;
    visited[i+1] := true ; 
    q := q->including(i) ; 
    q := q->including(-1) ; 
    while (not(q->isEmpty())) do (     var now : int ; now := q->min() ;
     var parent : int ; parent := q->min() ;
         var j : int ; j := 0 ; while j < list->at(now+1)->size() do ( (     var next : int ; next := list->at(now+1)->at(j+1) ;
     if (next = parent) then     continue else skip ; 
    if (visited[next+1] = true) then     continue else skip ; 
    visited[next+1] := true ; 
    cnt := cnt + 1 ; 
    q := q->including(next) ; 
    q := q->including(now) ; 
 )  ;     j := j + 1 ) ) ; 
    ans := Set{ans, cnt}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int m=scn.nextInt();
    ArrayList<ArrayList<Integer>>al=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      ArrayList<Integer>al1=new ArrayList<>();
      al.add(al1);
    }
    HashSet<String>hs=new HashSet<>();
    for(int i=0 ; i<m ; i++){
      int val1=scn.nextInt();
      int val2=scn.nextInt();
      String s1=val1+"#"+val2 ;
      String s2=val2+"#"+val1 ;
      if(hs.contains(s1)|| hs.contains(s2)){
        continue ;
      }
      hs.add(s1);
      al.get(val1-1).add(val2-1);
      al.get(val2-1).add(val1-1);
    }
    int max=0 ;
    HashSet<Integer>hs1=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      cnt=0 ;
      dfs(i,al,hs1);
      max=Math.max(cnt,max);
    }
    System.out.println(max);
  }
  static int cnt=0 ;
  public static void dfs(int s,ArrayList<ArrayList<Integer>>al,HashSet<Integer>hs){
    if(hs.contains(s)){
      return ;
    }
    hs.add(s);
    cnt++;
    for(int val : al.get(s)){
      dfs(val,al,hs);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var m : int ; m := scn.getCurrent()->toInteger() ;
    var al : Sequence(Sequence(int)) ; al := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var al1 : Sequence(int) ; al1 := Sequence{} ;
     al := al->including(al1) )  ;     i := i + 1 ) ; 
    var hs : Set(String) ; hs := Set{} ;
        var i : int ; i := 0 ; while i < m do ( (     var val1 : int ; val1 := scn.getCurrent()->toInteger() ;
     var val2 : int ; val2 := scn.getCurrent()->toInteger() ;
    var s1 : String ; s1 := val1 + "#" + val2 ;
    var s2 : String ; s2 := val2 + "#" + val1 ;
    if (hs->includes(s1) or hs->includes(s2)) then (     continue ) else skip ; 
    hs := hs->including(s1) ; 
    al->at(val1 - 1+1)->excludes(val2 - 1) ; 
    al->at(val2 - 1+1)->excludes(val1 - 1) ; 
 )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var hs1 : Set(int) ; hs1 := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     cnt := 0 ; 
     execute dfs(i, al, hs1) ; 
     max := Set{cnt, max}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static   attribute cnt : int := 0;
  static   operation dfs( s : int, al : Sequence(Sequence(int)), hs : Set(int)) : void
  pre: true
  post: true
  activity: (     if (hs->includes(s)) then (     return ) else skip ; 
     hs := hs->including(s) ; 
     cnt := cnt + 1 ; 
     for (val : al->at(s+1)) do ( (     execute dfs(val, al, hs) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findSubArr(int arr[],int n){
    for(int i=0 ; i<n-1 ; i++){
      if(Math.abs(arr[i]-arr[i+1])>=2){
        System.out.print(arr[i]+" "+arr[i+1]);
        return ;
      }
    }
    System.out.print(-1);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,4,6,7 };
      int n=arr.length ;
      findSubArr(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findSubArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n - 1 do ( (     if (if arr[i+1] - arr[i + 1+1] < 0 then -(arr[i+1] - arr[i + 1+1]) else arr[i+1] - arr[i + 1+1] endif >= 2) then (     OclFile["System.out"].print(arr[i+1] + " " + arr[i + 1+1]) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(-1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,4,6,7} ;
     var n : int ; n := arr->size() ;
     execute findSubArr(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int countFibs(int low,int high){
    int f1=0,f2=1,f3=1 ;
    int result=0 ;
    while(f1<=high){
      if(f1>=low)result++;
      f1=f2 ;
      f2=f3 ;
      f3=f1+f2 ;
    }
    return result ;
  }
  public static void main(String args[]){
    int low=10,high=100 ;
    System.out.println("Count of Fibonacci Numbers is "+countFibs(low,high));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countFibs( low : int, high : int) : int
  pre: true
  post: true
  activity: (     var f1 : int ; f1 := 0 ;
    var f2 : int ; f2 := 1 ;
    var f3 : int ; f3 := 1 ;
     var result : int ; result := 0 ;
     while (f1 <= high) do (     if (f1 >= low) then     result := result + 1 ; else skip ; 
     f1 := f2 ; 
     f2 := f3 ; 
     f3 := f1 + f2 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var low : int ; low := 10 ;
    var high : int ; high := 100 ;
     OclFile["System.out"].println("Count of Fibonacci Numbers is " + countFibs(low, high)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int findNthDigit(int n){
    int len=1 ;
    long count=9 ;
    int start=1 ;
    while(n>len*count){
      n-=len*count ;
      len+=1 ;
      count*=10 ;
      start*=10 ;
    }
    start+=(n-1)/len ;
    String s=Integer.toString(start);
    return Character.getNumericValue(s.charAt((n-1)% len));
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation findNthDigit( n : int) : int
  pre: true
  post: true
  activity: (     var len : int ; len := 1 ;
     var count : long ; count := 9 ;
    var start : int ; start := 1 ;
    while (n > len * count) do (     n := n-(len * count) ; 
     len := len+(1) ; 
     count := count*(10) ; 
     start := start*(10) ) ; 
    start := start+((n - 1) / len) ; 
    var s : String ; s := ((start) + "") ;
    return ("" + s->at((n - 1) mod len+1))->toInteger() 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countDecodingDP(char digits[],int n){
    int count[]=new int[n+1];
    count[0]=1 ;
    count[1]=1 ;
    if(digits[0]=='0')return 0 ;
    for(int i=2 ; i<=n ; i++){
      count[i]=0 ;
      if(digits[i-1]>'0')count[i]=count[i-1];
      if(digits[i-2]=='1' ||(digits[i-2]=='2' && digits[i-1]<'7'))count[i]+=count[i-2];
    }
    return count[n];
  }
  public static void main(String[] args){
    char digits[]={
      '1','2','3','4' };
      int n=digits.length ;
      System.out.println("Count is "+countDecodingDP(digits,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countDecodingDP( digits : Sequence(String), n : int) : int
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,n + 1)->collect(0) ;
     count[0+1] := 1 ; 
    count[1+1] := 1 ; 
    if (digits[0+1] = '0') then     return 0 else skip ; 
        var i : int ; i := 2 ; while i <= n do ( (     count[i+1] := 0 ; 
     if (digits[i - 1+1] > '0') then     count[i+1] := count[i - 1+1] ; else skip ; 
     if (digits[i - 2+1] = '1' or (digits[i - 2+1] = '2' & digits[i - 1+1] < '7')) then     count[i+1] := count[i+1]+(count[i - 2+1]) ; else skip )  ;     i := i + 1 ) ; 
    return count[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var digits : Sequence(String) ; digits := Sequence{'1','2','3','4'} ;
     var n : int ; n := digits->size() ;
     OclFile["System.out"].println("Count is " + countDecodingDP(digits, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
class GFG {
  static void printNos(int n){
    if(n>0){
      printNos(n-1);
      System.out.print(n+" ");
    }
    return ;
  }
  public static void main(String[] args){
    printNos(100);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printNos( n : int) : void
  pre: true
  post: true
  activity: (     if (n > 0) then (     execute printNos(n - 1) ; 
     OclFile["System.out"].print(n + " ") ) else skip ; 
     return );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute printNos(100) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public boolean leafSimilar(TreeNode root1,TreeNode root2){
    List<Integer>leaves1=new ArrayList();
    List<Integer>leaves2=new ArrayList();
    dfs(root1,leaves1);
    dfs(root2,leaves2);
    return leaves1.equals(leaves2);
  }
  public void dfs(TreeNode node,List<Integer>leafValues){
    if(node!=null){
      if(node.left==null && node.right==null)leafValues.add(node.val);
      dfs(node.left,leafValues);
      dfs(node.right,leafValues);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation leafSimilar( root1 : TreeNode, root2 : TreeNode) : boolean
  pre: true
  post: true
  activity: (     var leaves1 : Sequence(int) ; leaves1 := Sequence{} ;
     var leaves2 : Sequence(int) ; leaves2 := Sequence{} ;
    execute dfs(root1, leaves1) ; 
    execute dfs(root2, leaves2) ; 
    return leaves1 = leaves2 
 );
   operation dfs( node : TreeNode, leafValues : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (node /= null) then (     if (node.left = null & node.right = null) then     leafValues->excludes(node.val) ; else skip ; 
     execute dfs(node.left, leafValues) ; 
     execute dfs(node.right, leafValues) ) else skip );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Squares {
  public static int numberOfSquares(int base){
    base=(base-2);
    base=base/2 ;
    return base*(base+1)/2 ;
  }
  public static void main(String args[]){
    int base=8 ;
    System.out.println(numberOfSquares(base));
  }
}
------------------------------------------------------------
OCL File:
---------
class Squares {
  static   operation numberOfSquares( base : int) : int
  pre: true
  post: true
  activity: (     base := (base - 2) ; 
     base := base / 2 ; 
     return base * (base + 1) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var base : int ; base := 8 ;
     OclFile["System.out"].println(numberOfSquares(base)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    long n=s.nextLong(),k=s.nextLong();
    if((n/k)% 2==0)System.out.println("NO");
    else System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := s.getCurrent()->toLong() ;
    var k : long ; k := s.getCurrent()->toLong() ;
     if ((n / k) mod 2 = 0) then     OclFile["System.out"].println("NO") ; else     OclFile["System.out"].println("YES") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
class GFG {
  static boolean isUgly(int n){
    while(n % 2==0)n=n/2 ;
    while(n % 3==0)n=n/3 ;
    while(n % 5==0)n=n/5 ;
    if(n==1)return true ;
    return false ;
  }
  static void sortUglyNumbers(int arr[],int n){
    ArrayList<Integer>list=new ArrayList<>();
    int i ;
    for(i=0 ; i<n ; i++){
      if(isUgly(arr[i])){
        list.add(arr[i]);
        arr[i]=-1 ;
      }
    }
    Collections.sort(list);
    int j=0 ;
    for(i=0 ; i<n ; i++){
      if(arr[i]==-1)System.out.print(list.get(j++)+" ");
      else System.out.print(arr[i]+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,7,12,10 };
      int n=arr.length ;
      sortUglyNumbers(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isUgly( n : int) : boolean
  pre: true
  post: true
  activity: (     while (n mod 2 = 0) do     n := n / 2 ; ; 
     while (n mod 3 = 0) do     n := n / 3 ; ; 
    while (n mod 5 = 0) do     n := n / 5 ; ; 
    if (n = 1) then     return true else skip ; 
    return false 
 );
  static   operation sortUglyNumbers( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     var i : int ;
        i := 0 ; while i < n do ( (     if (isUgly(arr[i+1])) then (     list := list->including(arr[i+1]) ; 
     arr[i+1] := -1 ) else skip )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var j : int ; j := 0 ;
        i := 0 ; while i < n do ( (     if (arr[i+1] = -1) then     OclFile["System.out"].print(list->at(j+1) + " ") ; else     OclFile["System.out"].print(arr[i+1] + " ") ; )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,7,12,10} ;
     var n : int ; n := arr->size() ;
     execute sortUglyNumbers(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class JavaApplication77 {
  public static void main(String[] args){
    Scanner read=new Scanner(System.in);
    long n=read.nextLong(),k=read.nextLong(),mn=n/k ;
    System.out.println(mn % 2==0 ? "NO" : "YES");
  }
  static boolean Sorted(int[] ar){
    for(int i=0 ; i<ar.length-1 ; i++)if(ar[i]>ar[i+1])return false ;
    return true ;
  }
  static int gcd(int a,int b){
    int r ;
    while(a % b>0){
      r=a % b ;
      a=b ;
      b=r ;
    }
    return b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication77 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : OclFile ; read := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := read.getCurrent()->toLong() ;
    var k : long ; k := read.getCurrent()->toLong() ;
    var mn : long ; mn := n / k ;
     OclFile["System.out"].println(if mn mod 2 = 0 then "NO" else "YES" endif) );
  static   operation Sorted( ar : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < ar->size() - 1 do (     if (ar[i+1] > ar[i + 1+1]) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var r : int ;
     while (a mod b > 0) do (     r := a mod b ; 
     a := b ; 
     b := r ) ; 
     return b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class HelloWorld {
  public static void solve(int n,int m,int k){
    System.out.println((n<=m && n<=k ? "Yes" : "No"));
  }
  public static void sol(int n){
    int ans=0 ;
    for(int i=1 ; i<n ; ++i){
      if(n % i==0){
        ans++;
      }
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long k=sc.nextLong();
    System.out.println(((n/k)% 2==1 ? "YES" : "NO"));
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation solve( n : int, m : int, k : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((if n <= m & n <= k then "Yes" else "No" endif)) );
  static   operation sol( n : int) : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     if (n mod i = 0) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    OclFile["System.out"].println((if (n / k) mod 2 = 1 then "YES" else "NO" endif)) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int Comparison(int a,int b){
    return(((a>b)? a : b));
  }
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int[] sum=new int[2];
    for(int r=0 ; r<2 ; r++){
      int buf ;
      sum[r]=0 ;
      for(int c=0 ; c<4 ; c++){
        buf=stdIn.nextInt();
        sum[r]+=buf ;
      }
    }
    System.out.println(Comparison(sum[0],sum[1]));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation Comparison( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return ((if (a > b) then a else b endif)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sum : Sequence(int) ; sum := Integer.subrange(1,2)->collect(0) ;
         var r : int ; r := 0 ; while r < 2 do ( (     var buf : int ;
     sum[r+1] := 0 ; 
         var c : int ; c := 0 ; while c < 4 do ( (     buf := stdIn.getCurrent()->toInteger() ; 
     sum[r+1] := sum[r+1]+(buf) )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
     OclFile["System.out"].println(Comparison(sum[0+1], sum[1+1])) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int a,b,i,j,k,l ;
    i=sc.nextInt();
    j=sc.nextInt();
    k=sc.nextInt();
    l=sc.nextInt();
    a=i+j+k+l ;
    i=sc.nextInt();
    j=sc.nextInt();
    k=sc.nextInt();
    l=sc.nextInt();
    b=i+j+k+l ;
    if(a<b)a=b ;
    System.out.println(a);
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var a : int ;
    var b : int ;
    var i : int ;
    var j : int ;
    var k : int ;
    var l : int ;
    i := sc.nextInt() ; 
    j := sc.nextInt() ; 
    k := sc.nextInt() ; 
    l := sc.nextInt() ; 
    a := i + j + k + l ; 
    i := sc.nextInt() ; 
    j := sc.nextInt() ; 
    k := sc.nextInt() ; 
    l := sc.nextInt() ; 
    b := i + j + k + l ; 
    if (a < b) then     a := b ; else skip ; 
    OclFile["System.out"].println(a) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] inputA=br.readLine().split(" ");
    String[] inputB=br.readLine().split(" ");
    if(sumScore(inputA)>sumScore(inputB))System.out.println(sumScore(inputA));
    else System.out.println(sumScore(inputB));
  }
  private static int sumScore(String[] score){
    int sum=0 ;
    for(int i=0 ; i<score.length ; ++i){
      sum+=Integer.parseInt(score[i]);
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var inputA : Sequence(String) ; inputA := br.readLine()->split(" ") ;
     var inputB : Sequence(String) ; inputB := br.readLine()->split(" ") ;
     if (sumScore(inputA) > sumScore(inputB)) then     OclFile["System.out"].println(sumScore(inputA)) ; else     OclFile["System.out"].println(sumScore(inputB)) ; );
  static   operation sumScore( score : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < score->size() do ( (     sum := sum+((score[i+1])->toInteger()) )  ;     i := i + 1 ) ; 
     return sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
class Main {
  public static void main(final String[] args){
    final Scanner stdin=new Scanner(System.in);
    int score=-1 ;
    for(int i=0 ; i<2 ; i++){
      int pscore=0 ;
      for(int j=0 ; j<4 ; j++){
        pscore+=stdin.nextInt();
      }
      score=Math.max(score,pscore);
    }
    System.out.println(score);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var score : int ; score := -1 ;
         var i : int ; i := 0 ; while i < 2 do ( (     var pscore : int ; pscore := 0 ;
         var j : int ; j := 0 ; while j < 4 do ( (     pscore := pscore+(stdin.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
     score := Set{score, pscore}->max() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(score) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int A=0 ;
    for(int i=0 ; i<4 ; i++){
      A+=sc.nextInt();
    }
    int B=0 ;
    for(int i=0 ; i<4 ; i++){
      B+=sc.nextInt();
    }
    out.println(Math.max(A,B));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 0 ;
         var i : int ; i := 0 ; while i < 4 do ( (     A := A+(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var B : int ; B := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     B := B+(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    out.println(Set{A, B}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class RearrangeArray {
  void rightrotate(int arr[],int n,int outofplace,int cur){
    int tmp=arr[cur];
    for(int i=cur ; i>outofplace ; i--)arr[i]=arr[i-1];
    arr[outofplace]=tmp ;
  }
  void rearrange(int arr[],int n){
    int outofplace=-1 ;
    for(int index=0 ; index<n ; index++){
      if(outofplace>=0){
        if(((arr[index]>=0)&&(arr[outofplace]<0))||((arr[index]<0)&&(arr[outofplace]>=0))){
          rightrotate(arr,n,outofplace,index);
          if(index-outofplace>2)outofplace=outofplace+2 ;
          else outofplace=-1 ;
        }
      }
      if(outofplace==-1){
        if(((arr[index]>=0)&&((index & 0x01)==0))||((arr[index]<0)&&(index & 0x01)==1))outofplace=index ;
      }
    }
  }
  void printArray(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
    System.out.println("");
  }
  public static void main(String[] args){
    RearrangeArray rearrange=new RearrangeArray();
    int arr[]={
-5,-2,5,2,4,7,1,8,0,-8 };
      int n=arr.length ;
      System.out.println("Given array is ");
      rearrange.printArray(arr,n);
      rearrange.rearrange(arr,n);
      System.out.println("RearrangeD array is ");
      rearrange.printArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class RearrangeArray {
   operation rightrotate( arr : Sequence(int), n : int, outofplace : int, cur : int) : void
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := arr[cur+1] ;
         var i : int ; i := cur ; while i > outofplace do (     arr[i+1] := arr[i - 1+1] ;  ;     i := i - 1 ) ; 
     arr[outofplace+1] := tmp );
   operation rearrange( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var outofplace : int ; outofplace := -1 ;
         var index : int ; index := 0 ; while index < n do ( (     if (outofplace >= 0) then (     if (((arr[index+1] >= 0) & (arr[outofplace+1] < 0)) or ((arr[index+1] < 0) & (arr[outofplace+1] >= 0))) then (     execute rightrotate(arr, n, outofplace, index) ; 
     if (index - outofplace > 2) then     outofplace := outofplace + 2 ; else     outofplace := -1 ; ) else skip ) else skip ; 
     if (outofplace = -1) then (     if (((arr[index+1] >= 0) & ((MathLib.bitwiseAnd(index,0x01)) = 0)) or ((arr[index+1] < 0) & (MathLib.bitwiseAnd(index,0x01)) = 1)) then     outofplace := index ; else skip ) else skip )  ;     index := index + 1 ) );
   operation printArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var rearrange : RearrangeArray ; rearrange := RearrangeArray.newRearrangeArray() ;
     var arr : Sequence(int) ; arr := Sequence{-5,-2,5,2,4,7,1,8,0,-8} ;
    var n : int ; n := arr->size() ;
    OclFile["System.out"].println("Given array is ") ; 
    rearrange.printArray(arr, n) ; 
    rearrange.rearrange(arr, n) ; 
    OclFile["System.out"].println("RearrangeD array is ") ; 
    rearrange.printArray(arr, n) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float rmsValue(int arr[],int n){
    int square=0 ;
    float mean=0 ;
    float root=0 ;
    for(int i=0 ; i<n ; i++){
      square+=Math.pow(arr[i],2);
    }
    mean=(square/(float)(n));
    root=(float)Math.sqrt(mean);
    return root ;
  }
  public static void main(String args[]){
    int arr[]={
      10,4,6,8 };
      int n=arr.length ;
      System.out.println(rmsValue(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation rmsValue( arr : Sequence(int), n : int) : double
  pre: true
  post: true
  activity: (     var square : int ; square := 0 ;
     var mean : double ; mean := 0 ;
    var root : double ; root := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     square := square+(arr[i+1]->pow(2)) )  ;     i := i + 1 ) ; 
    mean := (square / (n)->oclAsType(double)) ; 
    root := (mean)->sqrt()->oclAsType(double) ; 
    return root 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,4,6,8} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(rmsValue(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String t=sc.next();
    int mod=s.length();
    long ans=0 ;
    TreeSet<Integer>[] index=new TreeSet[26];
    for(int i=0 ; i<26 ; i++){
      index[i]=new TreeSet<>();
    }
    for(int i=0 ; i<t.length(); i++){
      TreeSet<Integer>tmp=index[t.charAt(i)-'a'];
      if(tmp.size()==0){
        if(s.indexOf(t.charAt(i))==-1){
          ans=-1 ;
          break ;
        }
        else {
          int in=0 ;
          while(s.indexOf(t.charAt(i),in)!=-1){
            tmp.add(s.indexOf(t.charAt(i),in));
            in=s.indexOf(t.charAt(i),in)+1 ;
          }
        }
      }
      int num ;
      if(tmp.ceiling((int)(ans % mod))==null){
        num=tmp.first();
      }
      else {
        num=tmp.ceiling((int)(ans % mod));
      }
      if(num+1<=ans % mod){
        ans=mod*(ans/mod+1)+num+1 ;
      }
      else {
        ans=mod*(ans/mod)+num+1 ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var mod : int ; mod := s->size() ;
    var ans : long ; ans := 0 ;
    var index : Sequence(Set(int)) ; index := Integer.subrange(1,26)->collect(null) ;
        var i : int ; i := 0 ; while i < 26 do ( (     index[i+1] := Set{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < t->size() do ( (     var tmp : Set(int) ; tmp := index[t->at(i+1) - ('a')->char2byte()+1] ;
     if (tmp->size() = 0) then (     if (s->indexOf(t->at(i+1))-1 = -1) then (     ans := -1 ; 
     break ) else (     var in : int ; in := 0 ;
     while (s.subrange(in+1)->indexOf(t->at(i+1)+"") + in - 1  /= -1) do (     tmp := tmp->including(s.subrange(in+1)->indexOf(t->at(i+1)+"") + in - 1 ) ; 
     in := s.subrange(in+1)->indexOf(t->at(i+1)+"") + in - 1  + 1 ) ) ) else skip ; 
    var num : int ;
    if (tmp.ceiling((ans mod mod)->oclAsType(int)) = null) then (     num := tmp->first() ) else (     num := tmp.ceiling((ans mod mod)->oclAsType(int)) ) ;  
    if (num + 1 <= ans mod mod) then (     ans := mod * (ans / mod + 1) + num + 1 ) else (     ans := mod * (ans / mod) + num + 1 ) ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=null ;
    PrintStream out=null ;
    try {
      sc=new Scanner(System.in);
      out=System.out ;
      exec(sc,out);
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
    finally {
      if(out!=null){
        out.close();
      }
      if(sc!=null){
        sc.close();
      }
    }
    System.exit(0);
  }
  public static void exec(final Scanner sc,final PrintStream out)throws Exception {
    final String s=sc.next();
    final String t=sc.next();
    final int index[][]=new int[s.length()+1][26];
    Arrays.fill(index[s.length()],-1);
    for(int i=s.length()-1 ; i>=0 ; i--){
      for(int l=0 ; l<26 ; l++){
        index[i][l]=index[i+1][l];
      }
      int l=s.charAt(i)-'a' ;
      index[i][l]=i ;
    }
    long offset=0 ;
    int cursor=0 ;
    for(int i=0 ; i<t.length(); i++){
      final int letter=t.charAt(i)-'a' ;
      final int next=index[cursor][letter];
      if(next==-1){
        if(cursor==0){
          out.println("-1");
          return ;
        }
        else {
          offset+=s.length();
          cursor=0 ;
          i--;
          continue ;
        }
      }
      else {
        cursor=next+1 ;
      }
    }
    out.println(offset+cursor);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := null ;
     var out : OclFile ; out := null ;
     try (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     out := OclFile["System.out"] ; 
     execute exec(sc, out) )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
   finally (     if (out /= null) then (     skip ) else skip ; 
     if (sc /= null) then (     skip ) else skip )
 OclProcess.exit(0) );
  static   operation exec( sc : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := sc.getCurrent() ;
     var t : String ; t := sc.getCurrent() ;
    var index : Sequence(Sequence(int)) ; index := Integer.subrange(1,s->size() + 1)->collect(Integer.subrange(1,26)->collect(0)) ;
    index[s->size()+1] := index[s->size()+1]->collect(-1) ; 
        var i : int ; i := s->size() - 1 ; while i >= 0 do ( (         var l : int ; l := 0 ; while l < 26 do ( (     index[i+1][l+1] := index[i + 1+1][l+1] )  ;     l := l + 1 ) ; 
     var l : int ; l := s->at(i+1) - ('a')->char2byte() ;
     index[i+1][l+1] := i )  ;     i := i - 1 ) ; 
    var offset : long ; offset := 0 ;
    var cursor : int ; cursor := 0 ;
        var i : int ; i := 0 ; while i < t->size() do ( (     var letter : int ; letter := t->at(i+1) - ('a')->char2byte() ;
     var next : int ; next := index[cursor+1][letter+1] ;
     if (next = -1) then (     if (cursor = 0) then (     skip ; 
     return ) else (     offset := offset+(s->size()) ; 
     cursor := 0 ; 
     i := i - 1 ; 
     continue ) ) else (     cursor := next + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test_M {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt(),b=sc.nextInt(),c=sc.nextInt(),d=sc.nextInt();
    if(a==b && a==c && a==d && a==0){
      System.out.println(1);
      return ;
    }
    if(c>0){
      if(a!=0 && d==a){
        System.out.println(1);
        return ;
      }
      else {
        System.out.println(0);
        return ;
      }
    }
    if(a!=d){
      System.out.println(0);
      return ;
    }
    System.out.println(1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class test_M {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    if (a = b & a = c & a = d & a = 0) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    if (c > 0) then (     if (a /= 0 & d = a) then (     OclFile["System.out"].println(1) ; 
     return ) else (     OclFile["System.out"].println(0) ; 
     return ) ) else skip ; 
    if (a /= d) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    OclFile["System.out"].println(1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.ByteArrayInputStream ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  static boolean honban=true ;
  public static void main(String[] args)throws Exception {
    if(honban){
      Scanner sc=new Scanner(System.in);
      mainInternal(sc);
    }
    else {
      String[] testInputs={
        "contest\r\n"+"son","contest\r\n"+"programming","contest\r\n"+"sentence" };
        for(String testInput : testInputs){
          Scanner sc=new Scanner(new ByteArrayInputStream(testInput.getBytes()));
          mainInternal(sc);
        }
      }
    }
    public static void mainInternal(Scanner sc){
      char[] argS=sc.next().toCharArray();
      char[] argT=sc.next().toCharArray();
      Map<Character,TreeSet<Integer>>charIndexMap=new HashMap<Character,TreeSet<Integer>>();
      for(int i=0 ; i<argS.length ; i++){
        char c=argS[i];
        TreeSet<Integer>t=charIndexMap.get(c);
        if(t==null){
          t=new TreeSet<Integer>();
          charIndexMap.put(c,t);
        }
        t.add(i);
      }
      long fullGlobalIndex=1 ;
      int prevLocalIndex=-1 ;
      for(char c : argT){
        TreeSet<Integer>charIndex=charIndexMap.get(c);
        if(charIndex==null){
          System.out.println("-1");
          return ;
        }
        Integer nextLocalIndex=charIndex.higher(prevLocalIndex);
        if(nextLocalIndex==null){
          nextLocalIndex=charIndex.first();
          fullGlobalIndex+=argS.length-prevLocalIndex+nextLocalIndex ;
          prevLocalIndex=nextLocalIndex ;
        }
        else {
          if(prevLocalIndex<0){
            prevLocalIndex=0 ;
          }
          fullGlobalIndex+=nextLocalIndex-prevLocalIndex ;
          prevLocalIndex=nextLocalIndex ;
        }
      }
      System.out.println(fullGlobalIndex);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute honban : boolean := true;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (honban) then (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute mainInternal(sc) ) else (     var testInputs : Sequence(String) ; testInputs := Sequence{"contest\r\n" + "son","contest\r\n" + "programming","contest\r\n" + "sentence"} ;
     for (testInput : testInputs) do ( (     var sc : OclFile ; sc := OclFile.newOclFile_Read(ByteArrayInputStream.newByteArrayInputStream(testInput->characters()->collect( _c | _c->char2byte() ))) ;
     execute mainInternal(sc) )  ) ) );
  static   operation mainInternal( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var argS : Sequence(String) ; argS := sc.getCurrent()->characters() ;
     var argT : Sequence(String) ; argT := sc.getCurrent()->characters() ;
    var charIndexMap : Map(String,Set(int)) ; charIndexMap := Map{} ;
        var i : int ; i := 0 ; while i < argS->size() do ( (     var c : String ; c := argS[i+1] ;
     var t : Set(int) ; t := charIndexMap->at(c) ;
     if (t = null) then (     t := Set{} ; 
     charIndexMap := charIndexMap->union(Map{c |-> t}) ) else skip ; 
     t := t->including(i) )  ;     i := i + 1 ) ; 
    var fullGlobalIndex : long ; fullGlobalIndex := 1 ;
    var prevLocalIndex : int ; prevLocalIndex := -1 ;
    for (c : argT) do ( (     var charIndex : Set(int) ; charIndex := charIndexMap->at(c) ;
     if (charIndex = null) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
     var nextLocalIndex : int ; nextLocalIndex := charIndex.higher(prevLocalIndex) ;
     if (nextLocalIndex = null) then (     nextLocalIndex := charIndex->first() ; 
     fullGlobalIndex := fullGlobalIndex+(argS->size() - prevLocalIndex + nextLocalIndex) ; 
     prevLocalIndex := nextLocalIndex ) else (     if (prevLocalIndex < 0) then (     prevLocalIndex := 0 ) else skip ; 
     fullGlobalIndex := fullGlobalIndex+(nextLocalIndex - prevLocalIndex) ; 
     prevLocalIndex := nextLocalIndex ) )  ) ; 
    OclFile["System.out"].println(fullGlobalIndex) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  static Scanner scanner=new Scanner();
  public static void main(String[] $)throws IOException {
    char[] s=scanner.next().toCharArray();
    int n=s.length ;
    char[] t=scanner.next().toCharArray();
    int m=t.length ;
    List<Integer>[] list=new ArrayList[26];
    for(int i=0 ; i<26 ; i++){
      list[i]=new ArrayList<>();
    }
    for(int i=0 ; i<n ; i++){
      list[s[i]-'a'] .add(i);
    }
    long loop=0 ;
    long lastIndex=-1 ;
    for(int i=0 ; i<m ; i++){
      List<Integer>indexList=list[t[i]-'a'];
      if(indexList.size()==0){
        System.out.println(-1);
        return ;
      }
      int ok=-1,ng=indexList.size();
      while(Math.abs(ok-ng)>1){
        int mid=(ok+ng)/2 ;
        if(lastIndex>=indexList.get(mid)){
          ok=mid ;
        }
        else {
          ng=mid ;
        }
      }
      if(ng>=indexList.size()){
        lastIndex=indexList.get(0);
        loop++;
      }
      else {
        lastIndex=indexList.get(ng);
      }
    }
    System.out.println(loop*n+lastIndex+1);
  }
  static class Scanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),1<<15);
    StringTokenizer tokenizer ;
    String next()throws IOException {
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        tokenizer=new StringTokenizer(reader.readLine());
      }
      return tokenizer.nextToken();
    }
    int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := (arguments ( ));
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := scanner.getCurrent()->characters() ;
     var n : int ; n := s->size() ;
    var t : Sequence(String) ; t := scanner.getCurrent()->characters() ;
    var m : int ; m := t->size() ;
    var list : Sequence(Sequence(int)) ; list := Integer.subrange(1,26)->collect(null) ;
        var i : int ; i := 0 ; while i < 26 do ( (     list[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     list[s[i+1] - ('a')->char2byte()+1]->excludes(i) )  ;     i := i + 1 ) ; 
    var loop : long ; loop := 0 ;
    var lastIndex : long ; lastIndex := -1 ;
        var i : int ; i := 0 ; while i < m do ( (     var indexList : Sequence(int) ; indexList := list[t[i+1] - ('a')->char2byte()+1] ;
     if (indexList->size() = 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var ok : int ; ok := -1 ;
    var ng : int ; ng := indexList->size() ;
    while (if ok - ng < 0 then -(ok - ng) else ok - ng endif > 1) do (     var mid : int ; mid := (ok + ng) / 2 ;
     if (lastIndex >= indexList->at(mid+1)) then (     ok := mid ) else (     ng := mid ) ) ; 
    if (ng >= indexList->size()) then (     lastIndex := indexList->at(0+1) ; 
     loop := loop + 1 ) else (     lastIndex := indexList->at(ng+1) ) ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(loop * n + lastIndex + 1) ; 
 );
  static class Scanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (1*(2->pow(15)))->oclAsType(long));
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s=br.readLine();
    String t=br.readLine();
    br.close();
    List<TreeSet<Integer>>list=new ArrayList<>(26);
    for(int i=0 ; i<26 ; i++){
      list.add(new TreeSet<>());
    }
    int n=s.length();
    for(int i=0 ; i<n ; i++){
      int k=s.charAt(i)-'a' ;
      list.get(k).add(i);
      list.get(k).add(i+n);
    }
    long base=0 ;
    int idx=-1 ;
    for(int i=0 ; i<t.length(); i++){
      int k=t.charAt(i)-'a' ;
      Integer j=list.get(k).higher(idx);
      if(j==null){
        System.out.println(-1);
        return ;
      }
      idx=j ;
      if(idx>=n){
        base+=n ;
        idx-=n ;
      }
    }
    System.out.println(base+idx+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := br.readLine() ;
    var t : String ; t := br.readLine() ;
    skip ; 
    var list : Sequence(Set(int)) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < 26 do ( (     list := list->including(Set{}) )  ;     i := i + 1 ) ; 
    var n : int ; n := s->size() ;
        var i : int ; i := 0 ; while i < n do ( (     var k : int ; k := s->at(i+1) - ('a')->char2byte() ;
     list->at(k+1)->excludes(i) ; 
     list->at(k+1)->excludes(i + n) )  ;     i := i + 1 ) ; 
    var base : long ; base := 0 ;
    var idx : int ; idx := -1 ;
        var i : int ; i := 0 ; while i < t->size() do ( (     var k : int ; k := t->at(i+1) - ('a')->char2byte() ;
     var j : int ; j := list->at(k+1).higher(idx) ;
    if (j = null) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    idx := j ; 
    if (idx >= n) then (     base := base+(n) ; 
     idx := idx-(n) ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(base + idx + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int N=10005 ;
  static void SieveOfEratosthenes(Vector<Boolean>composite){
    for(int i=0 ; i<N ; i++){
      composite.add(i,false);
    }
    for(int p=2 ; p*p<N ; p++){
      if(! composite.get(p)){
        for(int i=p*2 ; i<N ; i+=p){
          composite.add(i,true);
        }
      }
    }
  }
  static int sumOfElements(int arr[],int n){
    Vector<Boolean>composite=new Vector<Boolean>();
    for(int i=0 ; i<N ; i++)composite.add(false);
    SieveOfEratosthenes(composite);
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++)if(mp.containsKey(arr[i])){
      mp.put(arr[i],mp.get(arr[i])+1);
    }
    else {
      mp.put(arr[i],1);
    }
    int sum=0 ;
    for(Map.Entry<Integer,Integer>it : mp.entrySet()){
      if(composite.get(it.getValue())){
        sum+=(it.getKey());
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,1,1,1,3,3,2,4 };
      int n=arr.length ;
      System.out.print(sumOfElements(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute N : int := 10005;
  static   operation SieveOfEratosthenes( composite : Sequence(Boolean)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do ( (     composite->excludes(i, false) )  ;     i := i + 1 ) ; 
         var p : int ; p := 2 ; while p * p < N do ( (     if (not(composite->at(p+1))) then (         var i : int ; i := p * 2 ; while i < N do ( (     composite->excludes(i, true) )  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation sumOfElements( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var composite : Sequence(Boolean) ; composite := Sequence{} ;
         var i : int ; i := 0 ; while i < N do (     composite := composite->including(false) ;  ;     i := i + 1 ) ; 
    execute SieveOfEratosthenes(composite) ; 
    var mp : Map(int,int) ; mp := Map{} ;
        var i : int ; i := 0 ; while i < n do (     if (mp->keys()->includes(arr[i+1])) then (     mp := mp->union(Map{arr[i+1] |-> mp->at(arr[i+1]) + 1}) ) else (     mp := mp->union(Map{arr[i+1] |-> 1}) ) ;   ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    for (it : mp->asSet()) do ( (     if (composite->at(it.getValue()+1)) then (     sum := sum+((it.getKey())) ) else skip )  ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,1,1,1,3,3,2,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(sumOfElements(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF1674B {
  public static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    for(int i=0 ; i<n ; i++){
      String str=scanner.next();
      int res=(str.charAt(0)-'a')*26+(str.charAt(1)-'a');
      int minus=str.charAt(0)-'a' ;
      if(str.charAt(1)>=str.charAt(0))res=res-minus ;
      else res=res-minus+1 ;
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF1674B {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := scanner.getCurrent() ;
     var res : int ; res := (str->at(0+1) - ('a')->char2byte()) * 26 + (str->at(1+1) - ('a')->char2byte()) ;
    var minus : int ; minus := str->at(0+1) - ('a')->char2byte() ;
    if (str->at(1+1) >= str->at(0+1)) then     res := (res)->char2byte() - minus else     res := (res)->char2byte() - minus + 1 ; ;  
    OclFile["System.out"].println(res) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    while(t-->0){
      char[] s=scan.next().toCharArray();
      int result=(s[0]-'a')*25 ;
      result+=(s[0]<=s[1])?(s[1]-'a'):(s[1]-'a'+1);
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : Sequence(String) ; s := scan.getCurrent()->characters() ;
     var result : int ; result := (s[0+1] - ('a')->char2byte()) * 25 ;
     result := result+(if (s[0+1] <= s[1+1]) then (s[1+1] - ('a')->char2byte()) else (s[1+1] - ('a')->char2byte() + 1) endif) ; 
     OclFile["System.out"].println(result) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    sc.nextLine();
    while(t--!=0){
      String val=sc.nextLine();
      int ans=(val.charAt(0)-'a')*25 ;
      ans+=val.charAt(1)-'a'+1 ;
      if(val.charAt(0)<val.charAt(1))ans--;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     skip ; 
         while (t /= 0) do (    skip ; (     var val : String ; val := sc.nextLine() ;
     var ans : int ; ans := (val->at(0+1) - ('a')->char2byte()) * 25 ;
    ans := ans+(val->at(1+1) - ('a')->char2byte() + 1) ; 
    if (val->at(0+1) < val->at(1+1)) then     ans := ans - 1 ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int M=sc.nextInt();
    int N=sc.nextInt();
    int[] P=new int[M];
    for(int i=0 ; i<M ; ++i){
      P[i]=sc.nextInt();
    }
    Arrays.sort(P);
    int[] dp=new int[M+10001];
    Arrays.fill(dp,Integer.MAX_VALUE);
    dp[0]=0 ;
    for(int i=0 ; i<N ; ++i){
      int C=sc.nextInt();
      int E=sc.nextInt();
      for(int j=dp.length-1 ; j-C>=0 ; --j){
        if(dp[j-C]==Integer.MAX_VALUE)continue ;
        dp[j]=Math.min(dp[j],dp[j-C]+E);
      }
    }
    int[] sum=new int[dp.length];
    for(int i=0 ; i<M ; ++i){
      sum[i+1]=sum[i]+P[M-1-i];
    }
    for(int i=M+1 ; i<sum.length ; ++i){
      sum[i]=sum[M];
    }
    int ans=0 ;
    for(int i=0 ; i<sum.length ; ++i){
      if(dp[i]==Integer.MAX_VALUE)continue ;
      ans=Math.max(ans,sum[i]-dp[i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var M : int ; M := sc.getCurrent()->toInteger() ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var P : Sequence(int) ; P := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     P[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    P := P->sort() ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,M + 10001)->collect(0) ;
    dp := dp->collect(2147483647) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < N do ( (     var C : int ; C := sc.getCurrent()->toInteger() ;
     var E : int ; E := sc.getCurrent()->toInteger() ;
         var j : int ; j := dp->size() - 1 ; while j - C >= 0 do ( (     if (dp[j - C+1] = 2147483647) then     continue else skip ; 
     dp[j+1] := Set{dp[j+1], dp[j - C+1] + E}->min() )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    var sum : Sequence(int) ; sum := Integer.subrange(1,dp->size())->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     sum[i + 1+1] := sum[i+1] + P[M - 1 - i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := M + 1 ; while i < sum->size() do ( (     sum[i+1] := sum[M+1] )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < sum->size() do ( (     if (dp[i+1] = 2147483647) then     continue else skip ; 
     ans := Set{ans, sum[i+1] - dp[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    Integer t=scanner.nextInt();
    while(t-->0){
      Integer sum=0 ;
      String text=scanner.next();
      int firstChar=text.charAt(0);
      int secondChar=text.charAt(1);
      sum+=25*(firstChar-97);
      if(firstChar<secondChar)sum+=(secondChar-98);
      else sum+=(secondChar-97);
      System.out.println(sum+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var sum : int ; sum := 0 ;
     var text : String ; text := scanner.getCurrent() ;
    var firstChar : int ; firstChar := text->at(0+1) ;
    var secondChar : int ; secondChar := text->at(1+1) ;
    sum := sum+(25 * ((firstChar)->char2byte() - 97)) ; 
    if (firstChar < secondChar) then     sum := sum+((secondChar - 98)) else     sum := sum+((secondChar - 97)) ; ;  
    OclFile["System.out"].println(sum + 1) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  final int MAX_CHAR=26 ;
  static void frequency(int fre[][],String s[],int n){
    for(int i=0 ; i<n ; i++){
      String str=s[i];
      for(int j=0 ; j<str.length(); j++)fre[i][str.charAt(j)-'a']++;
    }
  }
  static void LongestSequence(int fre[][],int n){
    for(int i=24 ; i>=0 ; i--){
      int mi=fre[0][i];
      for(int j=1 ; j<n ; j++)mi=Math.min(fre[j][i],mi);
      while(mi--!=0)System.out.print((char)('a'+i));
    }
  }
  public static void main(String args[]){
    String s[]={
      "loo","lol","olive" };
      int n=s.length ;
      int fre[][]=new int[n][26];
      frequency(fre,s,n);
      LongestSequence(fre,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
   attribute MAX_CHAR : int := 26;
  static   operation frequency( fre : Sequence(Sequence(int)), s : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := s[i+1] ;
         var j : int ; j := 0 ; while j < str->size() do (     fre[i+1][str->at(j+1) - ('a')->char2byte()+1] := fre[i+1][str->at(j+1) - ('a')->char2byte()+1] + 1 ;  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation LongestSequence( fre : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 24 ; while i >= 0 do ( (     var mi : int ; mi := fre[0+1][i+1] ;
         var j : int ; j := 1 ; while j < n do (     mi := Set{fre[j+1][i+1], mi}->min() ;  ;     j := j + 1 ) ; 
         while (mi /= 0) do (    skip ;     OclFile["System.out"].print(('a' + i)->oclAsType(String)) ; ;  ) )  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := Sequence{"loo","lol","olive"} ;
     var n : int ; n := s->size() ;
    var fre : Sequence(Sequence(int)) ; fre := Integer.subrange(1,n)->collect(Integer.subrange(1,26)->collect(0)) ;
    execute frequency(fre, s, n) ; 
    execute LongestSequence(fre, n) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class b {
  static long MOD=1_000_000_007 ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long n=in.nextInt();
    long m=in.nextInt();
    long numWaysOneType=fastPow(2,m)-1 ;
    long ans=fastPow(numWaysOneType,n);
    System.out.println(ans);
  }
  public static long fastPow(long base,long pow){
    if(pow==0)return 1 ;
    if(pow==1)return base ;
    long ret=fastPow(base,pow/2);
    ret=(ret*ret)% MOD ;
    if(pow % 2==1)ret*=base ;
    return ret % MOD ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class b {
  static   attribute MOD : long := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toInteger() ;
    var m : long ; m := in.getCurrent()->toInteger() ;
    var numWaysOneType : long ; numWaysOneType := fastPow(2, m) - 1 ;
    var ans : long ; ans := fastPow(numWaysOneType, n) ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation fastPow( base : long, pow : long) : long
  pre: true
  post: true
  activity: (     if (pow = 0) then     return 1 else skip ; 
     if (pow = 1) then     return base else skip ; 
    var ret : long ; ret := fastPow(base, pow / 2) ;
    ret := (ret * ret) mod MOD ; 
    if (pow mod 2 = 1) then     ret := ret*(base) ; else skip ; 
    return ret mod MOD 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a=sc.nextLong();
    long b=sc.nextLong();
    long c=sc.nextLong();
    long d=sc.nextLong();
    if(a==0 && d==0 && c!=0){
      System.out.println(0);
    }
    else if(a==d)System.out.println(1);
    else System.out.println(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var c : long ; c := sc.getCurrent()->toLong() ;
    var d : long ; d := sc.getCurrent()->toLong() ;
    if (a = 0 & d = 0 & c /= 0) then (     OclFile["System.out"].println(0) ) else     if (a = d) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println(0) ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.StringTokenizer ;
public class alicePresents {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter wr=new BufferedWriter(new OutputStreamWriter(System.out));
    StringTokenizer tokenizer=new StringTokenizer(br.readLine());
    BigInteger a=new BigInteger(tokenizer.nextToken());
    BigInteger b=new BigInteger(tokenizer.nextToken());
    BigInteger mod=BigInteger.valueOf((long)(1e9+7));
    System.out.println(BigInteger.valueOf(2).modPow(b,mod).subtract(BigInteger.ONE).modPow(a,mod));
  }
}
------------------------------------------------------------
OCL File:
---------
 class alicePresents {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var wr : OclFile ; wr := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var tokenizer : OclIterator ; tokenizer := OclIterator.newOclIterator_String(br.readLine()) ;
    var a : long ; a := long(tokenizer.next()) ;
    var b : long ; b := long(tokenizer.next()) ;
    var mod : long ; mod := ((1e9 + 7)->oclAsType(long) + "")->toLong() ;
    OclFile["System.out"].println((2 + "")->toLong().modPow(b, mod).subtract(1).modPow(a, mod)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.lang.Math ;
import java.math.BigInteger ;
import java.util.StringTokenizer ;
public class hh {
  public static final int Mod=1000000007 ;
  public static void main(String[] args){
    MyScanner in=new MyScanner();
    BigInteger n=BigInteger.valueOf(in.nextInt());
    BigInteger m=BigInteger.valueOf(in.nextInt());
    BigInteger two=BigInteger.valueOf(2);
    two=two.modPow(m,BigInteger.valueOf(Mod));
    two=two.add(BigInteger.valueOf(-1));
    two=two.modPow(n,BigInteger.valueOf(Mod));
    System.out.println(two.mod(BigInteger.valueOf(Mod)).intValue());
  }
}
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());
  }
}
------------------------------------------------------------
OCL File:
---------
 class hh {
  static    attribute Mod : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : MyScanner ; in := MyScanner.newMyScanner() ;
     var n : long ; n := (in.nextInt() + "")->toLong() ;
    var m : long ; m := (in.nextInt() + "")->toLong() ;
    var two : long ; two := (2 + "")->toLong() ;
    two := two.modPow(m, (Mod + "")->toLong()) ; 
    two := two->excludes((-1 + "")->toLong()) ; 
    two := two.modPow(n, (Mod + "")->toLong()) ; 
    OclFile["System.out"].println(two.mod((Mod + "")->toLong())->oclAsType(int)) ; 
 );
}
class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean isPossible(int n,int k,int arr[]){
    int sum=arr[0];
    int maxVal=arr[0];
    for(int i=1 ; i<n ; i++){
      sum+=arr[i];
      maxVal=Math.max(maxVal,arr[i]);
    }
    if((float)maxVal>(float)(sum+k)/n)return false ;
    return true ;
  }
  public static void main(String[] args){
    int k=8 ;
    int arr[]={
      1,2,3,4 };
      int n=arr.length ;
      if(isPossible(n,k,arr))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPossible( n : int, k : int, arr : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := arr[0+1] ;
     var maxVal : int ; maxVal := arr[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     sum := sum+(arr[i+1]) ; 
     maxVal := Set{maxVal, arr[i+1]}->max() )  ;     i := i + 1 ) ; 
    if (maxVal->oclAsType(double) > (sum + k)->oclAsType(double) / n) then     return false else skip ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 8 ;
     var arr : Sequence(int) ; arr := Sequence{1,2,3,4} ;
     var n : int ; n := arr->size() ;
     if (isPossible(n, k, arr)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int n ;
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    String str[]=new String[n];
    for(int i=0 ; i<n ; i++){
      str[i]=sc.next();
    }
    String min=str[0];
    for(int i=1 ; i<n ; i++){
      if(str[i] .compareTo(min)<0){
        min=str[i];
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := sc.getCurrent()->toInteger() ; 
    var str : Sequence(String) ; str := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     str[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    var min : String ; min := str[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     if (str[i+1]->compareTo(min) < 0) then (     min := str[i+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(is);
    String str=br.readLine();
    int n=Integer.parseInt(str);
    if(n!=0)str=br.readLine();
    for(int i=0 ; i<n-1 ; i++){
      String pre=br.readLine();
      if(str.compareTo(pre)>0)str=pre.toString();
    }
    if(n!=0)System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(is) ;
    var str : String ; str := br.readLine() ;
    var n : int ; n := (str)->toInteger() ;
    if (n /= 0) then     str := br.readLine() ; else skip ; 
        var i : int ; i := 0 ; while i < (n)->char2byte() - 1 do ( (     var pre : String ; pre := br.readLine() ;
     if (str->compareTo(pre) > 0) then     str := pre+"" ; else skip )  ;     i := i + 1 ) ; 
    if (n /= 0) then     OclFile["System.out"].println(str) ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int size=15000 ;
    int m=scanner.nextInt();
    int n=scanner.nextInt();
    int[] manju=new int[m];
    for(int i=0 ; i<m ; i++)manju[i]=scanner.nextInt();
    int[] dp=new int[size+2];
    Arrays.fill(dp,1<<30);
    dp[0]=0 ;
    for(int i=0 ; i<n ; i++){
      int c=scanner.nextInt();
      int e=scanner.nextInt();
      for(int j=size ; j>=c ; j--){
        dp[j]=Math.min(dp[j],dp[j-c]+e);
      }
    }
    for(int i=size ; i>=0 ; i--)dp[i]=Math.min(dp[i],dp[i+1]);
    Arrays.sort(manju);
    int ans=0 ;
    int sum=0 ;
    for(int i=0 ; i<m ; i++){
      sum+=manju[m-i-1];
      ans=Math.max(ans,sum-dp[i+1]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var size : int ; size := 15000 ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var manju : Sequence(int) ; manju := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     manju[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,size + 2)->collect(0) ;
    dp := dp->collect((1*(2->pow(30)))->oclAsType(long)) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     var c : int ; c := scanner.getCurrent()->toInteger() ;
     var e : int ; e := scanner.getCurrent()->toInteger() ;
         var j : int ; j := size ; while j >= c do ( (     dp[j+1] := Set{dp[j+1], dp[j - c+1] + e}->min() )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := size ; while i >= 0 do (     dp[i+1] := Set{dp[i+1], dp[i + 1+1]}->min() ;  ;     i := i - 1 ) ; 
    manju := manju->sort() ; 
    var ans : int ; ans := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     sum := sum+(manju[m - i - 1+1]) ; 
     ans := Set{ans, sum - dp[i + 1+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public void doIt(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String first=sc.next();
    for(int i=1 ; i<n ; i++){
      String temp=sc.next();
      boolean flg=true ;
      for(int j=0 ; j<first.length()&& j<temp.length(); j++){
        if(first.charAt(j)>temp.charAt(j)){
          first=temp ;
          flg=false ;
          break ;
        }
        else if(first.charAt(j)<temp.charAt(j)){
          flg=false ;
          break ;
        }
        else {
        }
      }
      if(flg && first.length()>temp.length()){
        first=temp ;
      }
    }
    System.out.println(first);
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var first : String ; first := sc.getCurrent() ;
        var i : int ; i := 1 ; while i < n do ( (     var temp : String ; temp := sc.getCurrent() ;
     var flg : boolean ; flg := true ;
         var j : int ; j := 0 ; while j < first->size() & j < temp->size() do ( (     if (first->at(j+1) > temp->at(j+1)) then (     first := temp ; 
     flg := false ; 
     break ) else     if (first->at(j+1) < temp->at(j+1)) then (     flg := false ; 
     break ) else skip ;  )  ;     j := j + 1 ) ; 
     if (flg & first->size() > temp->size()) then (     first := temp ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(first) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(isr);
    String buf ;
    String minStr=null ;
    try {
      br.readLine();
      while(br.ready()){
        buf=br.readLine();
        Scanner scanner=new Scanner(buf);
        String s=scanner.next();
        if(minStr==null){
          minStr=s ;
        }
        else if(minStr.compareTo(s)>0){
          minStr=s ;
        }
      }
      System.out.println(minStr);
    }
    catch(IOException e){
      System.out.println("Read error.");
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
    var buf : String ;
    var minStr : String ; minStr := null ;
    try (     skip ; 
     while (br.canRead()) do (     buf := br.readLine() ; 
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile.newOclFile(buf)) ;
     var s : String ; s := scanner.getCurrent() ;
     if (minStr = null) then (     minStr := s ) else     if (minStr->compareTo(s) > 0) then (     minStr := s ) else skip ; ) ; 
     OclFile["System.out"].println(minStr) )   catch (e : IOException) do (     OclFile["System.out"].println("Read error.") ; 
     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
public class Main {
  public static void main(String[] args){
    new Main().find();
  }
  void find(){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str ;
    ArrayList<String>list=new ArrayList<String>();
    try {
      while((str=br.readLine())!=null){
        list.add(str);
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
    list.remove(0);
    Collections.sort(list);
    System.out.println(list.get(0));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().nextMatch() );
   operation find() : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ;
    var list : Sequence(String) ; list := Sequence{} ;
    try (         str := br.readLine() ;
    while ((str) /= null) do (    skip ; (     list := list->including(str) ) ;     str := br.readLine() ;
 ) )   catch (e : IOException) do (     e.printStackTrace() )
    list := list->excludingAt(0+1) ; 
    list := list->sort() ; 
    OclFile["System.out"].println(list->at(0+1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    HashMap<Integer,Integer>map=new HashMap<>();
    int key=0 ;
    if(s.charAt(0)=='B')map.put(key,1);
    for(int i=1 ; i<n ; i++){
      if(s.charAt(i)=='B'){
        if(s.charAt(i-1)=='W'){
          map.put(++key,1);
        }
        else map.put(key,map.get(key)+1);
      }
    }
    System.out.println(map.size());
    for(int i : map.values()){
      System.out.print(i+" ");
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var map : Map(int,int) ; map := Map{} ;
    var key : int ; key := 0 ;
    if (s->at(0+1) = 'B') then     map := map->union(Map{key |-> 1}) ; else skip ; 
        var i : int ; i := 1 ; while i < n do ( (     if (s->at(i+1) = 'B') then (     if (s->at(i - 1+1) = 'W') then (     map := map->union(Map{(key + 1) |-> 1}) ) else     map := map->union(Map{key |-> map->at(key) + 1}) ; ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(map.size()) ; 
    for (i : map->values()) do ( (     OclFile["System.out"].print(i + " ") )  ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class MergeArrays {
  void moveToEnd(int mPlusN[],int size){
    int i,j=size-1 ;
    for(i=size-1 ; i>=0 ; i--){
      if(mPlusN[i]!=-1){
        mPlusN[j]=mPlusN[i];
        j--;
      }
    }
  }
  void merge(int mPlusN[],int N[],int m,int n){
    int i=n ;
    int j=0 ;
    int k=0 ;
    while(k<(m+n)){
      if((i<(m+n)&& mPlusN[i]<=N[j])||(j==n)){
        mPlusN[k]=mPlusN[i];
        k++;
        i++;
      }
      else {
        mPlusN[k]=N[j];
        k++;
        j++;
      }
    }
  }
  void printArray(int arr[],int size){
    int i ;
    for(i=0 ; i<size ; i++)System.out.print(arr[i]+" ");
    System.out.println("");
  }
  public static void main(String[] args){
    MergeArrays mergearray=new MergeArrays();
    int mPlusN[]={
      2,8,-1,-1,-1,13,-1,15,20 };
      int N[]={
        5,7,9,25 };
        int n=N.length ;
        int m=mPlusN.length-n ;
        mergearray.moveToEnd(mPlusN,m+n);
        mergearray.merge(mPlusN,N,m,n);
        mergearray.printArray(mPlusN,m+n);
      }
    }

------------------------------------------------------------
OCL File:
---------
class MergeArrays {
   operation moveToEnd( mPlusN : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ; j := size - 1 ;
         i := size - 1 ; while i >= 0 do ( (     if (mPlusN[i+1] /= -1) then (     mPlusN[j+1] := mPlusN[i+1] ; 
     j := j - 1 ) else skip )  ;     i := i - 1 ) );
   operation merge( mPlusN : Sequence(int), N : Sequence(int), m : int, n : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := n ;
     var j : int ; j := 0 ;
     var k : int ; k := 0 ;
     while (k < (m + n)) do (     if ((i < (m + n) & mPlusN[i+1] <= N[j+1]) or (j = n)) then (     mPlusN[k+1] := mPlusN[i+1] ; 
     k := k + 1 ; 
     i := i + 1 ) else (     mPlusN[k+1] := N[j+1] ; 
     k := k + 1 ; 
     j := j + 1 ) ) );
   operation printArray( arr : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
         i := 0 ; while i < size do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mergearray : MergeArrays ; mergearray := MergeArrays.newMergeArrays() ;
     var mPlusN : Sequence(int) ; mPlusN := Sequence{2,8,-1,-1,-1,13,-1,15,20} ;
    var N : Sequence(int) ; N := Sequence{5,7,9,25} ;
    var n : int ; n := N->size() ;
    var m : int ; m := mPlusN->size() - n ;
    mergearray.moveToEnd(mPlusN, m + n) ; 
    mergearray.merge(mPlusN, N, m, n) ; 
    mergearray.printArray(mPlusN, m + n) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int c1=in.nextInt(),c2=in.nextInt(),c3=in.nextInt(),c4=in.nextInt();
    if(c1==c4 &&(c3==0 || c1>0)){
      pw.println(1);
    }
    else {
      pw.println(0);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var c1 : int ; c1 := in.getCurrent()->toInteger() ;
    var c2 : int ; c2 := in.getCurrent()->toInteger() ;
    var c3 : int ; c3 := in.getCurrent()->toInteger() ;
    var c4 : int ; c4 := in.getCurrent()->toInteger() ;
    if (c1 = c4 & (c3 = 0 or c1 > 0)) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n,x=0,sum=0,idx=0 ;
    int[] array ;
    String string ;
    n=scanner.nextInt();
    array=new int[n];
    System.out.flush();
    string=scanner.next();
    for(int i=0 ; i<string.length(); i++){
      if(string.charAt(i)=='B'){
        sum++;
        if(i==string.length()-1){
          array[idx++]=sum ;
        }
      }
      else if(string.charAt(i)=='W'){
        if(i>0 && string.charAt(i-1)=='B'){
          array[idx++]=sum ;
          sum=0 ;
        }
      }
    }
    System.out.println(idx);
    for(int i=0 ; i<idx ; i++){
      System.out.print(array[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var x : int ; x := 0 ;
    var sum : int ; sum := 0 ;
    var idx : int ; idx := 0 ;
    var array : Sequence(int) ;
    var string : String ;
    n := scanner.getCurrent()->toInteger() ; 
    array := Integer.subrange(1,n)->collect(0) ; 
    OclFile["System.out"].flush() ; 
    string := scanner.getCurrent() ; 
        var i : int ; i := 0 ; while i < string->size() do ( (     if (string->at(i+1) = 'B') then (     sum := sum + 1 ; 
     if (i = string->size() - 1) then (      array[idx+1] := sum  ; idx := idx + 1 ) else skip ) else     if (string->at(i+1) = 'W') then (     if (i > 0 & string->at((i)->char2byte() - 1+1) = 'B') then (      array[idx+1] := sum  ; idx := idx + 1 ; 
     sum := 0 ) else skip ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(idx) ; 
        var i : int ; i := 0 ; while i < idx do ( (     OclFile["System.out"].print(array[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    int n=fs.nextInt();
    String s=fs.next();
    char[] c=s.toCharArray();
    int[] a=new int[10000];
    int res=0 ;
    int count=0 ;
    for(int i=0 ; i<s.length(); i++)if(c[i]=='B'){
      count++;
    }
    else {
      if(count>0){
        res++;
        a[res]=count ;
        count=0 ;
      }
    }
    if(res==n)System.out.println(0);
    else if(count==0){
      System.out.println(res);
      for(int i=1 ; i<=res ; i++)System.out.print(a[i]+" ");
    }
    else {
      System.out.println(res+1);
      for(int i=1 ; i<=res ; i++)System.out.print(a[i]+" ");
      System.out.print(count);
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! 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());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var n : int ; n := fs.nextInt() ;
    var s : String ; s := fs.next() ;
    var c : Sequence(String) ; c := s->characters() ;
    var a : Sequence(int) ; a := Integer.subrange(1,10000)->collect(0) ;
    var res : int ; res := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < s->size() do (     if (c[i+1] = 'B') then (     count := count + 1 ) else (     if (count > 0) then (     res := res + 1 ; 
     a[res+1] := count ; 
     count := 0 ) else skip ) ;   ;     i := i + 1 ) ; 
    if (res = n) then     OclFile["System.out"].println(0) else     if (count = 0) then (     OclFile["System.out"].println(res) ; 
         var i : int ; i := 1 ; while i <= res do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ) else (     OclFile["System.out"].println(res + 1) ; 
         var i : int ; i := 1 ; while i <= res do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(count) ) ;  ;  
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),c=0,w=1,a[]=new int[n];
    sc.nextLine();
    String s=sc.nextLine();
    s=s+"W" ;
    for(int i=0 ; i<n ; i++){
      char ch=s.charAt(i);
      if(ch=='B'){
        if(s.charAt(i)==s.charAt(i+1)){
          w++;
        }
        else {
          c++;
          a[c-1]=w ;
          w=1 ;
        }
      }
    }
    System.out.println(c);
    for(int i=0 ; i<c ; i++)System.out.print(a[i]+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
    var w : int ; w := 1 ;
    var a : Sequence(void) ; a := Integer.subrange(1,n)->collect(0) ;
    skip ; 
    var s : String ; s := sc.nextLine() ;
    s := s + "W" ; 
        var i : int ; i := 0 ; while i < n do ( (     var ch : String ; ch := s->at(i+1) ;
     if (ch = 'B') then (     if (s->at(i+1) = s->at(i + 1+1)) then (     w := w + 1 ) else (     c := c + 1 ; 
     a[c - 1+1] := w ; 
     w := 1 ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
        var i : int ; i := 0 ; while i < c do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
public class P721A_OnedimensionalJapaneseCrossword {
  public static void main(String[] subhani)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    String s=br.readLine();
    solve(n,s);
  }
  public static void solve(int n,String s){
    int groups=0 ;
    ArrayList<Integer>sizes=new ArrayList<>();
    int i=0 ;
    while(i<n){
      if(s.charAt(i)=='B'){
        groups++;
        int r=i ;
        while(r<n && s.charAt(r)=='B')r++;
        sizes.add(r-i);
        i=r ;
      }
      else i++;
    }
    System.out.println(groups);
    if(groups>0){
      for(int x : sizes)System.out.print(x+" ");
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P721A_OnedimensionalJapaneseCrossword {
  static   operation main( subhani : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var s : String ; s := br.readLine() ;
    execute solve(n, s) ; 
 );
  static   operation solve( n : int, s : String) : void
  pre: true
  post: true
  activity: (     var groups : int ; groups := 0 ;
     var sizes : Sequence(int) ; sizes := Sequence{} ;
    var i : int ; i := 0 ;
    while (i < n) do (     if (s->at(i+1) = 'B') then (     groups := groups + 1 ; 
     var r : int ; r := i ;
    while (r < n & s->at(r+1) = 'B') do     r := r + 1 ; ; 
    sizes := sizes->including(r - i) ; 
    i := r ; 
 ) else     i := i + 1 ; ) ; 
    OclFile["System.out"].println(groups) ; 
    if (groups > 0) then (     for (x : sizes) do (     OclFile["System.out"].print(x + " ") ;  ) ; 
     OclFile["System.out"].println() ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int m=scanner.nextInt();
    int n=scanner.nextInt();
    int[] manju=new int[m];
    for(int i=0 ; i<m ; i++)manju[i]=scanner.nextInt();
    int[] dp=new int[m+1];
    Arrays.fill(dp,1<<30);
    dp[0]=0 ;
    for(int i=0 ; i<n ; i++){
      int c=scanner.nextInt();
      int e=scanner.nextInt();
      for(int j=m ; j>=0 ; j--){
        int a=Math.max(0,j-c);
        dp[j]=Math.min(dp[j],dp[a]+e);
      }
    }
    Arrays.sort(manju);
    int ans=0 ;
    int sum=0 ;
    for(int i=0 ; i<m ; i++){
      sum+=manju[m-i-1];
      ans=Math.max(ans,sum-dp[i+1]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := scanner.getCurrent()->toInteger() ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var manju : Sequence(int) ; manju := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     manju[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,m + 1)->collect(0) ;
    dp := dp->collect((1*(2->pow(30)))->oclAsType(long)) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     var c : int ; c := scanner.getCurrent()->toInteger() ;
     var e : int ; e := scanner.getCurrent()->toInteger() ;
         var j : int ; j := m ; while j >= 0 do ( (     var a : int ; a := Set{0, j - c}->max() ;
     dp[j+1] := Set{dp[j+1], dp[a+1] + e}->min() )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    manju := manju->sort() ; 
    var ans : int ; ans := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     sum := sum+(manju[m - i - 1+1]) ; 
     ans := Set{ans, sum - dp[i + 1+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.text.DecimalFormat ;
import java.util.StringTokenizer ;
public class Main {
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    String nextLine()throws IOException {
      return br.readLine();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  static FastScanner in=new FastScanner();
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException {
    int n=in.nextInt(),k=in.nextInt();
    int x1=in.nextInt(),y1=in.nextInt(),x2,y2 ;
    double sum=0.0 ;
    while(--n!=0){
      x2=in.nextInt();
      y2=in.nextInt();
      sum+=calc(x1,y1,x2,y2);
      x1=x2 ;
      y1=y2 ;
    }
    DecimalFormat df=new DecimalFormat("##.#########");
    sum=(sum/50.0)*(double)k ;
    out.print(String.format("%.9f",sum));
    out.close();
  }
  public static double calc(int x1,int y1,int x2,int y2){
    int tempX=x2-x1 ;
    tempX*=tempX ;
    int tempY=y2-y1 ;
    tempY*=tempY ;
    return Math.sqrt(tempY+tempX);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   attribute in : FastScanner := FastScanner.newFastScanner();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
    var k : int ; k := in.nextInt() ;
     var x1 : int ; x1 := in.nextInt() ;
    var y1 : int ; y1 := in.nextInt() ;
    var x2 : int ;
    var y2 : int ;
    var sum : double ; sum := 0.0 ;
        n := n - 1 ;
    while ((n - 1) /= 0) do (    skip ; (     x2 := in.nextInt() ; 
     y2 := in.nextInt() ; 
    sum := sum+(calc(x1, y1, x2, y2)) ; 
    x1 := x2 ; 
    y1 := y2 ; 
 ) ;     n := n - 1 ;
 ) ;  
    var df : DecimalFormat ; df := DecimalFormat.newDecimalFormat("##.#########") ;
    sum := (sum / 50.0) * k->oclAsType(double) ; 
    skip ; 
    skip ; 
 );
  static   operation calc( x1 : int, y1 : int, x2 : int, y2 : int) : double
  pre: true
  post: true
  activity: (     var tempX : int ; tempX := x2 - x1 ;
     tempX := tempX*(tempX) ; 
    var tempY : int ; tempY := y2 - y1 ;
    tempY := tempY*(tempY) ; 
    return (tempY + tempX)->sqrt() 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class CF127_D2_A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    ArrayList<Pair>points=new ArrayList<>();
    int n=scanner.nextInt();
    int k=scanner.nextInt();
    for(int i=0 ; i<n ; i++){
      Pair tmp=new Pair();
      tmp.setX(scanner.nextInt());
      tmp.setY(scanner.nextInt());
      points.add(tmp);
    }
    double value=0 ;
    for(int i=1 ; i<n ; i++){
      value+=Math.hypot(points.get(i).x-points.get(i-1).x,points.get(i).y-points.get(i-1).y);
    }
    double ans=value/50*k ;
    System.out.println(ans);
    scanner.close();
  }
}
class Pair {
  public int x ;
  public int y ;
  public Pair(){
  }
  public void setX(int x){
    this.x=x ;
  }
  public void setY(int y){
    this.y=y ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF127_D2_A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var points : Sequence(Map) ; points := Sequence{} ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var tmp : Map ; tmp := Map() ;
     tmp := tmp.setX(scanner.getCurrent()->toInteger()) ; 
     tmp := tmp.setY(scanner.getCurrent()->toInteger()) ; 
     points := points->including(tmp) )  ;     i := i + 1 ) ; 
    var value : double ; value := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     value := value+(hypot(points->at(i+1).x - points->at(i - 1+1).x, points->at(i+1).y - points->at(i - 1+1).y)) )  ;     i := i + 1 ) ; 
    var ans : double ; ans := value / 50 * k ;
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}
class Pair {
   attribute x : int;
   attribute y : int;
   static operation newPair() : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   operation setX( x : int) : void
  pre: true
  post: true
  activity: (     self.x := x );
   operation setY( y : int) : void
  pre: true
  post: true
  activity: (     self.y := y );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication117 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num1=sc.nextInt();
    double num2=sc.nextInt();
    double all=0 ;
    double x=sc.nextDouble();
    double y=sc.nextDouble();
    for(int i=1 ; i<num1 ; i++){
      double a=sc.nextInt();
      double b=sc.nextInt();
      all+=Math.sqrt((a-x)*(a-x)+(b-y)*(b-y));
      x=a ;
      y=b ;
    }
    System.out.println(num2*all/50.);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication117 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num1 : int ; num1 := sc.getCurrent()->toInteger() ;
    var num2 : double ; num2 := sc.getCurrent()->toInteger() ;
    var all : double ; all := 0 ;
    var x : double ; x := sc.getCurrent()->toReal() ;
    var y : double ; y := sc.getCurrent()->toReal() ;
        var i : int ; i := 1 ; while i < num1 do ( (     var a : double ; a := sc.getCurrent()->toInteger() ;
     var b : double ; b := sc.getCurrent()->toInteger() ;
    all := all+(((a - x) * (a - x) + (b - y) * (b - y))->sqrt()) ; 
    x := a ; 
    y := b ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(num2 * all / 50.) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    String nextLine()throws IOException {
      return br.readLine();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  static FastScanner in=new FastScanner();
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException {
    int n=in.nextInt(),k=in.nextInt();
    int x1=in.nextInt(),y1=in.nextInt(),x2,y2 ;
    double sum=0.0 ;
    while(--n!=0){
      x2=in.nextInt();
      y2=in.nextInt();
      sum+=calc(x1,y1,x2,y2);
      x1=x2 ;
      y1=y2 ;
    }
    sum=(sum/50.0)*(double)k ;
    out.print(String.format("%.9f",sum));
    out.close();
  }
  public static double calc(int x1,int y1,int x2,int y2){
    int tempX=x2-x1 ;
    tempX*=tempX ;
    int tempY=y2-y1 ;
    tempY*=tempY ;
    return Math.sqrt(tempY+tempX);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   attribute in : FastScanner := FastScanner.newFastScanner();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
    var k : int ; k := in.nextInt() ;
     var x1 : int ; x1 := in.nextInt() ;
    var y1 : int ; y1 := in.nextInt() ;
    var x2 : int ;
    var y2 : int ;
    var sum : double ; sum := 0.0 ;
        n := n - 1 ;
    while ((n - 1) /= 0) do (    skip ; (     x2 := in.nextInt() ; 
     y2 := in.nextInt() ; 
    sum := sum+(calc(x1, y1, x2, y2)) ; 
    x1 := x2 ; 
    y1 := y2 ; 
 ) ;     n := n - 1 ;
 ) ;  
    sum := (sum / 50.0) * k->oclAsType(double) ; 
    skip ; 
    skip ; 
 );
  static   operation calc( x1 : int, y1 : int, x2 : int, y2 : int) : double
  pre: true
  post: true
  activity: (     var tempX : int ; tempX := x2 - x1 ;
     tempX := tempX*(tempX) ; 
    var tempY : int ; tempY := y2 - y1 ;
    tempY := tempY*(tempY) ; 
    return (tempY + tempX)->sqrt() 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int M=3 ;
  static int N=3 ;
  static void reverseArray(int arr[][]){
    for(int i=0 ; i<M ; i++){
      int start=0 ;
      int end=N-1 ;
      while(start<end){
        int temp=arr[i][start];
        arr[i][start]=arr[i][end];
        arr[i][end]=temp ;
        start++;
        end--;
      }
    }
    for(int i=0 ; i<M ; i++){
      for(int j=0 ; j<N ; j++){
        System.out.print(arr[i][j]+" ");
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    int arr[][]={
      {
        1,2,3 },{
          4,5,6 },{
            7,8,9 }
          };
          reverseArray(arr);
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute M : int := 3;
  static   attribute N : int := 3;
  static   operation reverseArray( arr : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < M do ( (     var start : int ; start := 0 ;
     var end : int ; end := N - 1 ;
     while (start < end) do (     var temp : int ; temp := arr[i+1][start+1] ;
     arr[i+1][start+1] := arr[i+1][end+1] ; 
    arr[i+1][end+1] := temp ; 
    start := start + 1 ; 
    end := end - 1 ; 
 ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < M do ( (         var j : int ; j := 0 ; while j < N do ( (     OclFile["System.out"].print(arr[i+1][j+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(int)) ; arr := Sequence{Sequence{1,2,3},Sequence{4,5,6},Sequence{7,8,9}} ;
     execute reverseArray(arr) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printUpperHalf(String str){
    char first,second ;
    int pos=0 ;
    for(int i=1 ; i<=4 ; i++){
      first=str.charAt(pos);
      second=str.charAt(pos+1);
      pos+=2 ;
      for(int j=4-i ; j>=1 ; j--)System.out.print(" ");
      System.out.print(first);
      for(int j=1 ; j<i ; j++)System.out.print("--");
      System.out.println(second);
    }
  }
  static void printLowerHalf(String str){
    char first,second ;
    int pos=0 ;
    for(int i=1 ; i<=4 ; i++){
      first=str.charAt(pos);
      second=str.charAt(pos+1);
      pos+=2 ;
      for(int j=1 ; j<i ; j++)System.out.print(" ");
      System.out.print(first);
      for(int j=4-i ; j>=1 ; j--)System.out.print("--");
      System.out.println(second);
    }
  }
  static void printDNA(String str[],int n){
    for(int i=0 ; i<n ; i++){
      int x=i % 6 ;
      if(x % 2==0)printUpperHalf(str[x]);
      else printLowerHalf(str[x]);
    }
  }
  public static void main(String[] args){
    int n=8 ;
    String DNA[]={
      "ATTAATTA","TAGCTAGC","CGCGATAT","TAATATGC","ATCGTACG","CGTAGCAT" };
      printDNA(DNA,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printUpperHalf( str : String) : void
  pre: true
  post: true
  activity: (     var first : String ;
    var second : String ;
     var pos : int ; pos := 0 ;
         var i : int ; i := 1 ; while i <= 4 do ( (     first := str->at(pos+1) ; 
     second := str->at(pos + 1+1) ; 
    pos := pos+(2) ; 
        var j : int ; j := 4 - i ; while j >= 1 do (     OclFile["System.out"].print(" ") ;  ;     j := j - 1 ) ; 
    OclFile["System.out"].print(first) ; 
        var j : int ; j := 1 ; while j < i do (     OclFile["System.out"].print("--") ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(second) ; 
 )  ;     i := i + 1 ) );
  static   operation printLowerHalf( str : String) : void
  pre: true
  post: true
  activity: (     var first : String ;
    var second : String ;
     var pos : int ; pos := 0 ;
         var i : int ; i := 1 ; while i <= 4 do ( (     first := str->at(pos+1) ; 
     second := str->at(pos + 1+1) ; 
    pos := pos+(2) ; 
        var j : int ; j := 1 ; while j < i do (     OclFile["System.out"].print(" ") ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].print(first) ; 
        var j : int ; j := 4 - i ; while j >= 1 do (     OclFile["System.out"].print("--") ;  ;     j := j - 1 ) ; 
    OclFile["System.out"].println(second) ; 
 )  ;     i := i + 1 ) );
  static   operation printDNA( str : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := i mod 6 ;
     if (x mod 2 = 0) then     execute printUpperHalf(str[x+1]) ; else     execute printLowerHalf(str[x+1]) ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     var DNA : Sequence(String) ; DNA := Sequence{"ATTAATTA","TAGCTAGC","CGCGATAT","TAATATGC","ATCGTACG","CGTAGCAT"} ;
     execute printDNA(DNA, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class p1179b {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt();
    int m=in.nextInt();
    int currYbot=1 ;
    int currYtop=m ;
    int currSide=0 ;
    while(currYbot<currYtop){
      if(currSide==0){
        for(int i=1 ; i<=n ; i++){
          out.println(i+" "+currYbot);
          out.println((n-i+1)+" "+currYtop);
        }
      }
      else {
        for(int i=1 ; i<=n ; i++){
          out.println((n-i+1)+" "+currYbot);
          out.println(i+" "+currYtop);
        }
      }
      currYbot++;
      currYtop--;
      currSide ^=1 ;
    }
    if(currYbot==currYtop){
      int left=1 ;
      int right=n ;
      if(currSide==0){
        while(left<right){
          out.println(left+" "+currYbot);
          out.println(right+" "+currYbot);
          left++;
          right--;
        }
      }
      else {
        while(left<right){
          out.println(right+" "+currYbot);
          out.println(left+" "+currYbot);
          left++;
          right--;
        }
      }
      if(left==right)out.println(left+" "+currYbot);
    }
    out.close();
    ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class p1179b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var currYbot : int ; currYbot := 1 ;
    var currYtop : int ; currYtop := m ;
    var currSide : int ; currSide := 0 ;
    while (currYbot < currYtop) do (     if (currSide = 0) then (         var i : int ; i := 1 ; while i <= n do ( (     skip ; 
     skip )  ;     i := i + 1 ) ) else (         var i : int ; i := 1 ; while i <= n do ( (     skip ; 
     skip )  ;     i := i + 1 ) ) ;  
     currYbot := currYbot + 1 ; 
     currYtop := currYtop - 1 ; 
     currSide := MathLib.bitwiseXor(currSide,1) ) ; 
    if (currYbot = currYtop) then (     var left : int ; left := 1 ;
     var right : int ; right := n ;
     if (currSide = 0) then (     while (left < right) do (     skip ; 
     skip ; 
     left := left + 1 ; 
     right := right - 1 ) ) else (     while (left < right) do (     skip ; 
     skip ; 
     left := left + 1 ; 
     right := right - 1 ) ) ;  
     if (left = right) then     skip ; else skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int remainingArea(int N,int M,int K){
    while(K-->0 && N>0 && M>0){
      if(N>M)N=N-M ;
      else M=M-N ;
    }
    if(N>0 && M>0)return N*M ;
    else return 0 ;
  }
  public static void main(String[] args){
    int N=5,M=3,K=2 ;
    System.out.println(remainingArea(N,M,K));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation remainingArea( N : int, M : int, K : int) : int
  pre: true
  post: true
  activity: (         while (K > 0 & N > 0 & M > 0) do (    skip ; (     if (N > M) then     N := N - M ; else     M := M - N ; ) ;  ) ;  
     if (N > 0 & M > 0) then     return N * M else     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
    var M : int ; M := 3 ;
    var K : int ; K := 2 ;
     OclFile["System.out"].println(remainingArea(N, M, K)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeforces358B {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int numWords=Integer.parseInt(br.readLine());
    StringBuilder str=new StringBuilder();
    str.append("<3");
    for(int i=0 ; i<numWords ; i++){
      str.append(br.readLine());
      str.append("<3");
    }
    String st=br.readLine();
    int index=0 ;
    boolean bo=false ;
    for(int i=0 ; i<st.length(); i++){
      if(st.charAt(i)==str.charAt(index)){
        index++;
      }
      if(index==str.length()){
        bo=true ;
        break ;
      }
    }
    if(bo){
      System.out.println("yes");
    }
    else {
      System.out.println("no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces358B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var numWords : int ; numWords := (br.readLine())->toInteger() ;
    var str : String ; str := StringLib.newString() ;
    str := str + StringLib.newString("<3") ; 
        var i : int ; i := 0 ; while i < numWords do ( (     str := str + StringLib.newString(br.readLine()) ; 
     str := str + StringLib.newString("<3") )  ;     i := i + 1 ) ; 
    var st : String ; st := br.readLine() ;
    var index : int ; index := 0 ;
    var bo : boolean ; bo := false ;
        var i : int ; i := 0 ; while i < st->size() do ( (     if (st->at(i+1) = str->at(index+1)) then (     index := index + 1 ) else skip ; 
     if (index = str->size()) then (     bo := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (bo) then (     OclFile["System.out"].println("yes") ) else (     OclFile["System.out"].println("no") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    int numWords=Integer.parseInt(in.readLine());
    StringBuilder rightMessage=new StringBuilder();
    rightMessage.append("<3");
    for(int i=0 ; i<numWords ; i++){
      rightMessage.append(in.readLine());
      rightMessage.append("<3");
    }
    StringBuilder message=new StringBuilder(in.readLine().replaceAll("[^a-z<3] ",""));
    for(int j=0 ; j<rightMessage.length()-1 ; j++){
      while(message.length()>rightMessage.length()&& message.charAt(j)!=rightMessage.charAt(j)){
        message.replace(j,j+1,"");
      }
    }
    if(message.length()>rightMessage.length()){
      message.replace(rightMessage.length(),message.length(),"");
    }
    if(message.toString().equals(rightMessage.toString())){
      System.out.println("yes");
    }
    else {
      System.out.println("no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var numWords : int ; numWords := (in.readLine())->toInteger() ;
    var rightMessage : String ; rightMessage := StringLib.newString() ;
    rightMessage := rightMessage + StringLib.newString("<3") ; 
        var i : int ; i := 0 ; while i < numWords do ( (     rightMessage := rightMessage + StringLib.newString(in.readLine()) ; 
     rightMessage := rightMessage + StringLib.newString("<3") )  ;     i := i + 1 ) ; 
    var message : String ; message := StringLib.newString(in.readLine().replaceAllMatches("[^a-z<3] ", "" )) ;
        var j : int ; j := 0 ; while j < rightMessage->size() - 1 do ( (     while (message->size() > rightMessage->size() & message->at(j+1) /= rightMessage->at(j+1)) do (     message.replace(j, j + 1, "") ) )  ;     j := j + 1 ) ; 
    if (message->size() > rightMessage->size()) then (     message.replace(rightMessage->size(), message->size(), "") ) else skip ; 
    if (message+"" = rightMessage+"") then (     OclFile["System.out"].println("yes") ) else (     OclFile["System.out"].println("no") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int[] array=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      array[i]=scanner.nextInt();
    }
    for(int i=1 ; i<=n ; i++){
      System.out.printf("node %d: key=%d,",i,array[i]);
      if(i/2>0)System.out.printf("parent key=%d,",array[i/2]);
      if(2*i<=n)System.out.printf("left key=%d,",array[2*i]);
      if((2*i+1)<=n)System.out.printf("right key=%d,",array[2*i+1]);
      System.out.print("\n");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     array[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].printf("node %d: key=%d,", i, array[i+1]) ; 
     if (i / 2 > 0) then     OclFile["System.out"].printf("parent key=%d,", array[i / 2+1]) ; else skip ; 
    if (2 * i <= n) then     OclFile["System.out"].printf("left key=%d,", array[2 * i+1]) ; else skip ; 
    if ((2 * i + 1) <= n) then     OclFile["System.out"].printf("right key=%d,", array[2 * i + 1+1]) ; else skip ; 
    OclFile["System.out"].print("\n") ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B358 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    StringBuilder expected=new StringBuilder("<3");
    for(int n=0 ; n<N ; n++){
      expected.append(in.next()).append("<3");
    }
    String actual=in.next();
    int eIdx=0 ;
    int aIdx=0 ;
    while(eIdx<expected.length()&& aIdx<actual.length()){
      int ec=expected.charAt(eIdx);
      int ac=actual.charAt(aIdx++);
      if(ec==ac){
        eIdx++;
      }
    }
    boolean ok=(eIdx==expected.length());
    System.out.println(ok ? "yes" : "no");
  }
}
------------------------------------------------------------
OCL File:
---------
 class B358 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var expected : String ; expected := StringLib.newString("<3") ;
        var n : int ; n := 0 ; while n < N do ( (     expected := expected + StringLib.newString(in.getCurrent()) + StringLib.newString("<3") )  ;     n := n + 1 ) ; 
    var actual : String ; actual := in.getCurrent() ;
    var eIdx : int ; eIdx := 0 ;
    var aIdx : int ; aIdx := 0 ;
    while (eIdx < expected->size() & aIdx < actual->size()) do (     var ec : int ; ec := expected->at(eIdx+1) ;
     var ac : int ; ac := actual->at(aIdx+1) ;
     if (ec = ac) then (     eIdx := eIdx + 1 ) else skip ) ; 
    var ok : boolean ; ok := (eIdx = expected->size()) ;
    OclFile["System.out"].println(if ok then "yes" else "no" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int oddDays(int N){
    int hund1=N/100 ;
    int hund4=N/400 ;
    int leap=N>>2 ;
    int ord=N-leap ;
    if(hund1>0){
      ord+=hund1 ;
      leap-=hund1 ;
    }
    if(hund4>0){
      ord-=hund4 ;
      leap+=hund4 ;
    }
    int days=ord+leap*2 ;
    int odd=days % 7 ;
    return odd ;
  }
  public static void main(String args[]){
    int N=100 ;
    System.out.print(oddDays(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation oddDays( N : int) : int
  pre: true
  post: true
  activity: (     var hund1 : int ; hund1 := N / 100 ;
     var hund4 : int ; hund4 := N / 400 ;
    var leap : int ; leap := (N/(2->pow(2)))->oclAsType(long) ;
    var ord : int ; ord := N - leap ;
    if (hund1 > 0) then (     ord := ord+(hund1) ; 
     leap := leap-(hund1) ) else skip ; 
    if (hund4 > 0) then (     ord := ord-(hund4) ; 
     leap := leap+(hund4) ) else skip ; 
    var days : int ; days := ord + leap * 2 ;
    var odd : int ; odd := days mod 7 ;
    return odd 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 100 ;
     OclFile["System.out"].print(oddDays(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static void main(String args[]){
    int i,j,r,N,count=0 ;
    N=3 ;
    N--;
    r=5 ;
    for(i=0 ; i<r ; i++){
      if(i<=r/2){
        count=N+1 ;
        for(j=0 ; j<=i ; j++){
          N++;
          System.out.print(N+" ");
        }
        System.out.println();
      }
      else {
        N=count-(r-i);
        count=N ;
        for(j=i ; j<r ; j++){
          System.out.print(N+" ");
          N++;
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var r : int ;
    var N : int ;
    var count : int ; count := 0 ;
     N := 3 ; 
    N := N - 1 ; 
    r := 5 ; 
        i := 0 ; while i < r do ( (     if (i <= r / 2) then (     count := N + 1 ; 
         j := 0 ; while j <= i do ( (     N := N + 1 ; 
     OclFile["System.out"].print(N + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() ) else (     N := count - (r - i) ; 
     count := N ; 
         j := i ; while j < r do ( (     OclFile["System.out"].print(N + " ") ; 
     N := N + 1 )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.pow ;
class Triangle {
  public static double numberOfTriangles(int n){
    double ans=2*(pow(3,n))-1 ;
    return ans ;
  }
  public static void main(String[] args){
    int n=2 ;
    System.out.println(numberOfTriangles(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Triangle {
  static   operation numberOfTriangles( n : int) : double
  pre: true
  post: true
  activity: (     var ans : double ; ans := 2 * (pow(3, n)) - 1 ;
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     OclFile["System.out"].println(numberOfTriangles(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class AA {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int p=0 ; p<t ; p++){
      int r=sc.nextInt();
      int g=sc.nextInt();
      int b=sc.nextInt();
      int w=sc.nextInt();
      int c=0 ;
      if(r % 2==1)c++;
      if(g % 2==1)c++;
      if(b % 2==1)c++;
      int d=0 ;
      if(w % 2==1)d++;
      if((c+d)<=1)System.out.println("Yes");
      else if((c+d)==3 ||(c+d)==4)if(r>0 && g>0 && b>0)System.out.println("Yes");
      else System.out.println("No");
      else System.out.println("No");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class AA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var p : int ; p := 0 ; while p < t do ( (     var r : int ; r := sc.getCurrent()->toInteger() ;
     var g : int ; g := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
    if (r mod 2 = 1) then     c := c + 1 ; else skip ; 
    if (g mod 2 = 1) then     c := c + 1 ; else skip ; 
    if (b mod 2 = 1) then     c := c + 1 ; else skip ; 
    var d : int ; d := 0 ;
    if (w mod 2 = 1) then     d := d + 1 ; else skip ; 
    if ((c + d) <= 1) then     OclFile["System.out"].println("Yes") else     if ((c + d) = 3 or (c + d) = 4) then     if (r > 0 & g > 0 & b > 0) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; else     OclFile["System.out"].println("No") ; ;  ;  
 )  ;     p := p + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int ev=0,od=0,z=0 ;
      int lst[]=new int[4];
      for(int i=0 ; i<4 ; i++){
        lst[i]=sc.nextInt();
        if(lst[i]==0)z++;
        else if(lst[i] % 2==1)od++;
        else ev++;
      }
      if(z>0){
        if(lst[3]!=0){
          if(od<=1)System.out.println("YES");
          else System.out.println("NO");
        }
        else {
          if(od % 2==1 || od==0)System.out.println("YES");
          else System.out.println("NO");
        }
      }
      else {
        if(ev==1 || od==1)System.out.println("YES");
        else if(ev==4 || od==4)System.out.println("YES");
        else System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var ev : int ; ev := 0 ;
    var od : int ; od := 0 ;
    var z : int ; z := 0 ;
     var lst : Sequence(int) ; lst := Integer.subrange(1,4)->collect(0) ;
         var i : int ; i := 0 ; while i < 4 do ( (     lst[i+1] := sc.getCurrent()->toInteger() ; 
     if (lst[i+1] = 0) then     z := z + 1 ; else     if (lst[i+1] mod 2 = 1) then     od := od + 1 else     ev := ev + 1 ; ;  )  ;     i := i + 1 ) ; 
     if (z > 0) then (     if (lst[3+1] /= 0) then (     if (od <= 1) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) else (     if (od mod 2 = 1 or od = 0) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) ) else (     if (ev = 1 or od = 1) then     OclFile["System.out"].println("YES") ; else     if (ev = 4 or od = 4) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int i,n,x ;
    n=scan.nextInt();
    for(i=3 ; i<=n ; i++){
      x=i ;
      if(x % 3==0){
        System.out.print(" "+i);
      }
      else {
        while(x>0){
          if(x % 10==3){
            System.out.print(" "+i);
            break ;
          }
          x/=10 ;
        }
      }
    }
    System.out.println("");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ;
    var n : int ;
    var x : int ;
    n := scan.getCurrent()->toInteger() ; 
        i := 3 ; while i <= n do ( (     x := i ; 
     if (x mod 3 = 0) then (     OclFile["System.out"].print(" " + i) ) else (     while (x > 0) do (     if (x mod 10 = 3) then (     OclFile["System.out"].print(" " + i) ; 
     break ) else skip ; 
     x := x/(10) ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[]){
    FastReader input=new FastReader();
    PrintWriter out=new PrintWriter(System.out);
    int T=1 ;
    while(T-->0){
      int n=input.nextInt();
      int m=input.nextInt();
      int x=1,y=n ;
      int count=0 ;
      while(x<=y){
        int a=1,b=m ;
        int f=0 ;
        for(int i=1 ; i<=m*2 ; i++){
          if(i % 2!=0){
            out.println(x+" "+a);
            count++;
            if(count==n*m){
              f=1 ;
              break ;
            }
            a++;
          }
          else {
            out.println(y+" "+b);
            count++;
            if(count==n*m){
              f=1 ;
              break ;
            }
            b--;
          }
        }
        if(f==1){
          break ;
        }
        x++;
        y--;
      }
    }
    out.close();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastReader ; input := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := 1 ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := input.nextInt() ;
     var m : int ; m := input.nextInt() ;
    var x : int ; x := 1 ;
    var y : int ; y := n ;
    var count : int ; count := 0 ;
    while (x <= y) do (     var a : int ; a := 1 ;
    var b : int ; b := m ;
     var f : int ; f := 0 ;
        var i : int ; i := 1 ; while i <= m * 2 do ( (     if (i mod 2 /= 0) then (     skip ; 
     count := count + 1 ; 
     if (count = n * m) then (     f := 1 ; 
     break ) else skip ; 
     a := a + 1 ) else (     skip ; 
     count := count + 1 ; 
     if (count = n * m) then (     f := 1 ; 
     break ) else skip ; 
     b := b - 1 ) )  ;     i := i + 1 ) ; 
    if (f = 1) then (     break ) else skip ; 
    x := x + 1 ; 
    y := y - 1 ; 
 ) ; 
 ) ;  ) ;  
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(isr);
    int n=Integer.parseInt(br.readLine());
    for(int x=1 ; x<=n ; x++){
      if(x % 3==0){
        System.out.print(" "+x);
      }
      else {
        Integer m=new Integer(x);
        String k=m.toString();
        for(int y=0 ; y<k.length(); y++){
          String str=String.valueOf(k.charAt(y));
          if(str.equals("3")){
            System.out.print(" "+x);
            break ;
          }
        }
      }
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
    var n : int ; n := (br.readLine())->toInteger() ;
        var x : int ; x := 1 ; while x <= n do ( (     if (x mod 3 = 0) then (     OclFile["System.out"].print(" " + x) ) else (     var m : int ; m := ("" + (x))->toInteger() ;
     var k : String ; k := m+"" ;
         var y : int ; y := 0 ; while y < k->size() do ( (     var str : String ; str := ((k->at(y+1)) + "") ;
     if (str = "3") then (     OclFile["System.out"].print(" " + x) ; 
     break ) else skip )  ;     y := y + 1 ) ) )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
import java.util.Objects ;
public class Main {
  public static void main(String[] args){
    FastScanner sc=new FastScanner();
    int n=sc.nextInt();
    for(int i=1 ; i<=n ; i++){
      int tmp=i ;
      if(i % 3==0)System.out.print(" "+i);
      else {
        while(tmp!=0){
          if(tmp % 10==3){
            System.out.print(" "+i);
            break ;
          }
          tmp/=10 ;
        }
      }
    }
    System.out.println();
  }
  public static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(String s){
      try {
        br=new BufferedReader(new FileReader(s));
      }
      catch(FileNotFoundException e){
        e.printStackTrace();
      }
    }
    public FastScanner(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String nextToken(){
      while(st==null || ! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(nextToken());
    }
    long nextLong(){
      return Long.parseLong(nextToken());
    }
    double nextDouble(){
      return Double.parseDouble(nextToken());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner() ;
     var n : int ; n := sc.nextInt() ;
         var i : int ; i := 1 ; while i <= n do ( (     var tmp : int ; tmp := i ;
     if (i mod 3 = 0) then     OclFile["System.out"].print(" " + i) ; else (     while (tmp /= 0) do (     if (tmp mod 10 = 3) then (     OclFile["System.out"].print(" " + i) ; 
     break ) else skip ; 
     tmp := tmp/(10) ) ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
 );
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  void run(){
    int N=readInt();
    for(int i=1 ; i<=N ; i++){
      int x=i ;
      if(x % 3==0){
        sysout.print(" "+i);
        continue ;
      }
      while(x>0){
        boolean end=false ;
        if(x % 10==3){
          sysout.print(" "+i);
          end=true ;
        }
        if(end)break ;
        x/=10 ;
      }
    }
    sysout.println();
  }
  public static void main(String[] args){
    new Main().run();
  }
  PrintWriter sysout=new PrintWriter(System.out,true);
  BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer buffer=null ;
  String readLine(){
    buffer=null ;
    try {
      return in.readLine();
    }
    catch(IOException e){
      throw new RuntimeException(e);
    }
  }
  String read(){
    if(buffer==null || ! buffer.hasMoreTokens()){
      buffer=new StringTokenizer(readLine());
    }
    return buffer.nextToken();
  }
  int readInt(){
    return Integer.parseInt(read());
  }
  long readLong(){
    return Long.parseLong(read());
  }
  double readDouble(){
    return Double.parseDouble(read());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var N : int ; N := readInt() ;
         var i : int ; i := 1 ; while i <= N do ( (     var x : int ; x := i ;
     if (x mod 3 = 0) then (     sysout.print(" " + i) ; 
     continue ) else skip ; 
     while (x > 0) do (     var end : boolean ; end := false ;
     if (x mod 10 = 3) then (     sysout.print(" " + i) ; 
     end := true ) else skip ; 
     if (end) then     break else skip ; 
     x := x/(10) ) )  ;     i := i + 1 ) ; 
     sysout.println() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute sysout : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], true);
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute buffer : OclIterator := null;
   operation readLine() : String
  pre: true
  post: true
  activity: (     buffer := null ; 
     try (     return in.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 );
   operation read() : String
  pre: true
  post: true
  activity: (     if (buffer = null or not(buffer.hasNext())) then (     buffer := OclIterator.newOclIterator_String(readLine()) ) else skip ; 
     return buffer.next() );
   operation readInt() : int
  pre: true
  post: true
  activity: (     return (read())->toInteger() );
   operation readLong() : long
  pre: true
  post: true
  activity: (     return (read())->toLong() );
   operation readDouble() : double
  pre: true
  post: true
  activity: (     return (read())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner stdin=new Scanner(System.in)){
      int n=Integer.parseInt(stdin.next());
      if(n<3 || n>10000){
        throw new RuntimeException("Input Range:between 3 and 10000");
      }
      System.out.println(checkNum(n));
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  private static String checkNum(int n){
    StringBuilder sb=new StringBuilder();
    for(int i=1 ; i<=n ; i++){
      if(i % 3==0){
        sb.append(' ').append(String.valueOf(i));
      }
      else if(String.valueOf(i).contains("3")){
        sb.append(' ').append(String.valueOf(i));
      }
    }
    return sb.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var stdin : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := (stdin.getCurrent())->toInteger() ;
     if (n < 3 or n > 10000) then (     error ProgramException("Input Range:between 3 and 10000") ) else skip ; 
     OclFile["System.out"].println(checkNum(n)) ))   catch (e : ProgramException) do (     e.printStackTrace() )
  );
  static   operation checkNum( n : int) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 1 ; while i <= n do ( (     if (i mod 3 = 0) then (     sb := sb + StringLib.newString(' ') + StringLib.newString(((i) + "")) ) else     if (((i) + "")->includes("3")) then (     sb := sb + StringLib.newString(' ') + StringLib.newString(((i) + "")) ) else skip ; )  ;     i := i + 1 ) ; 
     return sb+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class pair {
    int first,second ;
    public pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  static int minStepsNeeded(int k,int d1,int d2,int x){
    int gcd=__gcd(d1,d2);
    if((k-x)% gcd!=0)return-1 ;
    Queue<pair>q=new LinkedList<>();
    HashSet<Integer>visited=new HashSet<>();
    q.add(new pair(k,0));
    visited.add(k);
    while(! q.isEmpty()){
      int s=q.peek().first ;
      int stp=q.peek().second ;
      if(s==x)return stp ;
      q.remove();
      if(! visited.contains(s+d1)){
        q.add(new pair(s+d1,stp+1));
        visited.add(s+d1);
      }
      if(visited.contains(s+d2)){
        q.add(new pair(s+d2,stp+1));
        visited.add(s+d2);
      }
      if(! visited.contains(s-d1)){
        q.add(new pair(s-d1,stp+1));
        visited.add(s-d1);
      }
      if(! visited.contains(s-d2)){
        q.add(new pair(s-d2,stp+1));
        visited.add(s-d2);
      }
    }
    return Integer.MIN_VALUE ;
  }
  public static void main(String[] args){
    int k=10,d1=4,d2=6,x=8 ;
    System.out.println(minStepsNeeded(k,d1,d2,x));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class pair {
   attribute first : int;
   static operation newpair( first : int, second : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation minStepsNeeded( k : int, d1 : int, d2 : int, x : int) : int
  pre: true
  post: true
  activity: (     var gcd : int ; gcd := __gcd(d1, d2) ;
     if ((k - x) mod gcd /= 0) then     return -1 else skip ; 
    var q : Sequence(pair) ; q := Sequence{} ;
    var visited : Set(int) ; visited := Set{} ;
    q := q->including(pair.newpair(k, 0)) ; 
    visited := visited->including(k) ; 
    while (not(q->isEmpty())) do (     var s : int ; s := q->min()->at("first") ;
     var stp : int ; stp := q->min()->at("second") ;
    if (s = x) then     return stp else skip ; 
    q := q.remove() ; 
    if (not(visited->includes(s + d1))) then (     q := q->including(pair.newpair(s + d1, stp + 1)) ; 
     visited := visited->including(s + d1) ) else skip ; 
    if (visited->includes(s + d2)) then (     q := q->including(pair.newpair(s + d2, stp + 1)) ; 
     visited := visited->including(s + d2) ) else skip ; 
    if (not(visited->includes(s - d1))) then (     q := q->including(pair.newpair(s - d1, stp + 1)) ; 
     visited := visited->including(s - d1) ) else skip ; 
    if (not(visited->includes(s - d2))) then (     q := q->including(pair.newpair(s - d2, stp + 1)) ; 
     visited := visited->including(s - d2) ) else skip ; 
 ) ; 
    return -2147483648 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 10 ;
    var d1 : int ; d1 := 4 ;
    var d2 : int ; d2 := 6 ;
    var x : int ; x := 8 ;
     OclFile["System.out"].println(minStepsNeeded(k, d1, d2, x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countFactor(int P,int X){
    if(X<P)return 0 ;
    return(X/P+countFactor(P,X/P));
  }
  static int findSmallestX(int Y){
    int low=0,high=5*Y ;
    int N=0 ;
    while(low<=high){
      int mid=(high+low)/2 ;
      if(countFactor(5,mid)<Y){
        low=mid+1 ;
      }
      else {
        N=mid ;
        high=mid-1 ;
      }
    }
    return N ;
  }
  public static void main(String args[]){
    int Y=10 ;
    System.out.println(findSmallestX(Y));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countFactor( P : int, X : int) : int
  pre: true
  post: true
  activity: (     if (X < P) then     return 0 else skip ; 
     return (X / P + countFactor(P, X / P)) );
  static   operation findSmallestX( Y : int) : int
  pre: true
  post: true
  activity: (     var low : int ; low := 0 ;
    var high : int ; high := 5 * Y ;
     var N : int ; N := 0 ;
     while (low <= high) do (     var mid : int ; mid := (high + low) / 2 ;
     if (countFactor(5, mid) < Y) then (     low := mid + 1 ) else (     N := mid ; 
     high := mid - 1 ) ) ; 
     return N );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Y : int ; Y := 10 ;
     OclFile["System.out"].println(findSmallestX(Y)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAX_K=15 ;
  static int fac[]=new int[MAX_K];
  static void factorial(int k){
    fac[0]=1 ;
    for(int i=1 ; i<=k+1 ; i++){
      fac[i]=(i*fac[i-1]);
    }
  }
  static int bin(int a,int b){
    int ans=((fac[a])/(fac[a-b]*fac[b]));
    return ans ;
  }
  static int sumofn(int n,int k){
    int p=0 ;
    int num1,temp ;
    int arr[]=new int[1000];
    for(int j=1 ; j<=k ; j++){
      if(j==1){
        num1=(n*(n+1))/2 ;
        arr[p++]=num1 ;
        temp=num1 ;
      }
      else {
        temp=((int)Math.pow(n+1,j+1)-1-n);
        for(int s=1 ; s<j ; s++){
          temp=temp-(arr[j-s-1]*bin(j+1,s+1));
        }
        temp=temp/(j+1);
        arr[p++]=temp ;
      }
    }
    temp=arr[p-1];
    return temp ;
  }
  public static void main(String[] args){
    int n=5,k=2 ;
    factorial(k);
    System.out.println(sumofn(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX_K : int := 15;
  static   attribute fac : int := Integer.subrange(1,MAX_K)->collect(0);
  static   operation factorial( k : int) : void
  pre: true
  post: true
  activity: (     fac[0+1] := 1 ; 
         var i : int ; i := 1 ; while i <= k + 1 do ( (     fac[i+1] := (i * fac[i - 1+1]) )  ;     i := i + 1 ) );
  static   operation bin( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := ((fac[a+1]) / (fac[a - b+1] * fac[b+1])) ;
     return ans );
  static   operation sumofn( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var p : int ; p := 0 ;
     var num1 : int ;
    var temp : int ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,1000)->collect(0) ;
        var j : int ; j := 1 ; while j <= k do ( (     if (j = 1) then (     num1 := (n * (n + 1)) / 2 ; 
      arr[p+1] := num1  ; p := p + 1 ; 
     temp := num1 ) else (     temp := (n + 1->pow(j + 1)->oclAsType(int) - 1 - n) ; 
         var s : int ; s := 1 ; while s < j do ( (     temp := temp - (arr[j - s - 1+1] * bin(j + 1, s + 1)) )  ;     s := s + 1 ) ; 
     temp := temp / (j + 1) ; 
      arr[p+1] := temp  ; p := p + 1 ) )  ;     j := j + 1 ) ; 
    temp := arr[p - 1+1] ; 
    return temp 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var k : int ; k := 2 ;
     execute factorial(k) ; 
     OclFile["System.out"].println(sumofn(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int __gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static void reachTheNums(int nums[],int k,int d1,int d2,int n){
    int i ;
    int ans[]=new int[n];
    int gcd=__gcd(d1,d2);
    for(i=0 ; i<n ; i++){
      int x=nums[i]-k ;
      if(x % gcd==0)ans[i]=1 ;
      else ans[i]=0 ;
    }
    for(i=0 ; i<n ; i++)System.out.print(ans[i]+" ");
  }
  public static void main(String[] args){
    int nums[]={
      9,4 };
      int n=nums.length ;
      int k=8 ;
      int d1=3,d2=2 ;
      reachTheNums(nums,k,d1,d2,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
    if (a = b) then     return a else skip ; 
    if (a > b) then     return __gcd(a - b, b) else skip ; 
    return __gcd(a, b - a) 
 );
  static   operation reachTheNums( nums : Sequence(int), k : int, d1 : int, d2 : int, n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
     var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
    var gcd : int ; gcd := __gcd(d1, d2) ;
        i := 0 ; while i < n do ( (     var x : int ; x := nums[i+1] - k ;
     if (x mod gcd = 0) then     ans[i+1] := 1 ; else     ans[i+1] := 0 ; )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do (     OclFile["System.out"].print(ans[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var nums : Sequence(int) ; nums := Sequence{9,4} ;
     var n : int ; n := nums->size() ;
    var k : int ; k := 8 ;
    var d1 : int ; d1 := 3 ;
    var d2 : int ; d2 := 2 ;
    execute reachTheNums(nums, k, d1, d2, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int MOD=998244353 ;
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    int n=sc.nextInt();
    int s=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    long[][] dp=new long[n+1][s+1];
    dp[0][0]=1 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=0 ; j<=s ; j++){
        int tmp=arr[i-1];
        dp[i][j]+=dp[i-1][j]*2 ;
        dp[i][j] %=MOD ;
        if(tmp<=j)dp[i][j]+=dp[i-1][j-tmp];
        dp[i][j] %=MOD ;
      }
    }
    for(int i=0 ; i<=n ; i++){
      for(int j=0 ; j<s ; j++){
      }
    }
    System.out.println(dp[n][s]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute MOD : int := 998244353;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : int ; s := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,s + 1)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= s do ( (     var tmp : int ; tmp := arr[i - 1+1] ;
     dp[i+1][j+1] := dp[i+1][j+1]+(dp[i - 1+1][j+1] * 2) ; 
    dp[i+1][j+1] := dp[i+1][j+1] mod MOD ; 
    if (tmp <= j) then     dp[i+1][j+1] := dp[i+1][j+1]+(dp[i - 1+1][j - tmp+1]) ; else skip ; 
    dp[i+1][j+1] := dp[i+1][j+1] mod MOD ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= n do ( (         var j : int ; j := 0 ; while j < s do ( skip  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[n+1][s+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static PrintWriter out=new PrintWriter(System.out);
  static Scanner sc=new Scanner(System.in);
  static BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
  long mod=998244353 ;
  long inv2=1 ;
  public static void main(String[] args)throws IOException {
    Main main=new Main();
    main.solve();
    out.flush();
  }
  void solve()throws IOException {
    int n=sc.nextInt(),S=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    long[][] dp=new long[n][S+1];
    inv2=power(2,mod-2);
    if(a[0]<=S)dp[0][a[0] ]=power(2,n-1);
    for(int i=1 ; i<n ; i++){
      int cur=a[i];
      for(int j=1 ; j<=S ; j++)dp[i][j]=dp[i-1][j];
      if(cur<=S){
        dp[i][cur]=(dp[i][cur]+power(2,n-1))% mod ;
      }
      for(int j=cur+1 ; j<=S ; j++){
        dp[i][j]+=dp[i-1][j-cur]*inv2 % mod ;
        dp[i][j] %=mod ;
      }
    }
    long ans=dp[n-1][S];
    out.println(ans);
  }
  long power(long base,long p){
    long ans=1 ;
    while(p>0){
      if(p % 2==1)ans=ans*base % mod ;
      base=base*base % mod ;
      p/=2 ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute mod : long := 998244353;
   attribute inv2 : long := 1;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() ; 
     skip );
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var S : int ; S := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,S + 1)->collect(0)) ;
    inv2 := power(2, mod - 2) ; 
    if (a[0+1] <= S) then     dp[0+1][a[0+1]+1] := power(2, n - 1) ; else skip ; 
        var i : int ; i := 1 ; while i < n do ( (     var cur : int ; cur := a[i+1] ;
         var j : int ; j := 1 ; while j <= S do (     dp[i+1][j+1] := dp[i - 1+1][j+1] ;  ;     j := j + 1 ) ; 
     if (cur <= S) then (     dp[i+1][cur+1] := (dp[i+1][cur+1] + power(2, n - 1)) mod mod ) else skip ; 
         var j : int ; j := cur + 1 ; while j <= S do ( (     dp[i+1][j+1] := dp[i+1][j+1]+(dp[i - 1+1][j - cur+1] * inv2 mod mod) ; 
     dp[i+1][j+1] := dp[i+1][j+1] mod mod )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := dp[n - 1+1][S+1] ;
    skip ; 
 );
   operation power( base : long, p : long) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
     while (p > 0) do (     if (p mod 2 = 1) then     ans := ans * base mod mod ; else skip ; 
     base := base * base mod mod ; 
     p := p/(2) ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
import java.util.Set ;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str[]=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int k=Integer.parseInt(str[1]);
    str=br.readLine().split(" ");
    int p[]=new int[n];
    for(int i=0 ; i<n ; i++){
      p[i]=(Integer.parseInt(str[i])+1);
    }
    int s[]=new int[n+1];
    s[0]=0 ;
    for(int i=0 ; i<n ; i++){
      s[i+1]=s[i]+p[i];
    }
    int max=0 ;
    for(int i=0 ; i<=n-k ; i++){
      max=Math.max(max,s[i+k]-s[i]);
    }
    System.out.println((double)max/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var k : int ; k := (str[1+1])->toInteger() ;
    str := br.readLine()->split(" ") ; 
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := ((str[i+1])->toInteger() + 1) )  ;     i := i + 1 ) ; 
    var s : Sequence(int) ; s := Integer.subrange(1,n + 1)->collect(0) ;
    s[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     s[i + 1+1] := s[i+1] + p[i+1] )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i <= (n)->char2byte() - k do ( (     max := Set{max, s[i + k+1] - s[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max->oclAsType(double) / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int s=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    long result=0 ;
    long[][] dp=new long[3001][3001];
    int MOD=998244353 ;
    dp[0][0]=1 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<dp[0] .length ; j++){
        if(j+a[i]<3001){
          dp[i+1][j+a[i] ]+=dp[i][j];
          dp[i+1][j+a[i] ] %=MOD ;
        }
        dp[i+1][j]+=dp[i][j]*2 % MOD ;
        dp[i+1][j] %=MOD ;
      }
    }
    result=dp[n][s];
    System.out.println(result);
  }
  public static class Scanner {
    private BufferedReader br ;
    private StringTokenizer tok ;
    public Scanner(InputStream is)throws IOException {
      br=new BufferedReader(new InputStreamReader(is));
    }
    private void getLine()throws IOException {
      while(! hasNext())tok=new StringTokenizer(br.readLine());
    }
    private boolean hasNext(){
      return tok!=null && tok.hasMoreTokens();
    }
    public String next()throws IOException {
      getLine();
      return tok.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var result : long ; result := 0 ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,3001)->collect(Integer.subrange(1,3001)->collect(0)) ;
    var MOD : int ; MOD := 998244353 ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < dp[0+1]->size() do ( (     if (j + a[i+1] < 3001) then (     dp[i + 1+1][j + a[i+1]+1] := dp[i + 1+1][j + a[i+1]+1]+(dp[i+1][j+1]) ; 
     dp[i + 1+1][j + a[i+1]+1] := dp[i + 1+1][j + a[i+1]+1] mod MOD ) else skip ; 
     dp[i + 1+1][j+1] := dp[i + 1+1][j+1]+(dp[i+1][j+1] * 2 mod MOD) ; 
     dp[i + 1+1][j+1] := dp[i + 1+1][j+1] mod MOD )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    result := dp[n+1][s+1] ; 
    OclFile["System.out"].println(result) ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute tok : OclIterator;
   static operation newScanner( is : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
   operation getLine() : void
  pre: true
  post: true
  activity: (     while (not(hasNext())) do     tok := OclIterator.newOclIterator_String(br.readLine()) ; );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return tok /= null & tok.hasNext() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute getLine() ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int nth_term(int a,int b,int n){
    int z=0 ;
    if(n % 6==1)z=a ;
    else if(n % 6==2)z=b ;
    else if(n % 6==3)z=b-a ;
    else if(n % 6==4)z=-a ;
    else if(n % 6==5)z=-b ;
    if(n % 6==0)z=-(b-a);
    return z ;
  }
  public static void main(String[] args){
    int a=10,b=17,n=3 ;
    System.out.println(nth_term(a,b,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nth_term( a : int, b : int, n : int) : int
  pre: true
  post: true
  activity: (     var z : int ; z := 0 ;
     if (n mod 6 = 1) then     z := a else     if (n mod 6 = 2) then     z := b else     if (n mod 6 = 3) then     z := b - a else     if (n mod 6 = 4) then     z := -a else     if (n mod 6 = 5) then     z := -b ; else skip ; ;  ;  ;  ;  
     if (n mod 6 = 0) then     z := -(b - a) ; else skip ; 
     return z );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 10 ;
    var b : int ; b := 17 ;
    var n : int ; n := 3 ;
     OclFile["System.out"].println(nth_term(a, b, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int parent(int i){
    return i/2 ;
  }
  public static int left(int i){
    return 2*i ;
  }
  public static int right(int i){
    return 2*i+1 ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int H,i ;
    int MAX=100000 ;
    int[] A=new int[MAX+1];
    H=sc.nextInt();
    for(i=1 ; i<=H ; i++)A[i]=sc.nextInt();
    for(i=1 ; i<=H ; i++){
      System.out.print("node "+i+": key="+A[i]+",");
      if(parent(i)>=1)System.out.print("parent key="+A[parent(i)]+",");
      if(left(i)<=H)System.out.print("left key="+A[left(i)]+",");
      if(right(i)<=H)System.out.print("right key="+A[right(i)]+",");
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation parent( i : int) : int
  pre: true
  post: true
  activity: (     return i / 2 );
  static   operation left( i : int) : int
  pre: true
  post: true
  activity: (     return 2 * i );
  static   operation right( i : int) : int
  pre: true
  post: true
  activity: (     return 2 * i + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ;
    var i : int ;
    var MAX : int ; MAX := 100000 ;
    var A : Sequence(int) ; A := Integer.subrange(1,MAX + 1)->collect(0) ;
    H := sc.getCurrent()->toInteger() ; 
        i := 1 ; while i <= H do (     A[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        i := 1 ; while i <= H do ( (     OclFile["System.out"].print("node " + i + ": key=" + A[i+1] + ",") ; 
     if (parent(i) >= 1) then     OclFile["System.out"].print("parent key=" + A[parent(i)+1] + ",") ; else skip ; 
    if (left(i) <= H) then     OclFile["System.out"].print("left key=" + A[left(i)+1] + ",") ; else skip ; 
    if (right(i) <= H) then     OclFile["System.out"].print("right key=" + A[right(i)+1] + ",") ; else skip ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int mod=998244353 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int S=sc.nextInt();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
    }
    long[][] dp=new long[N+1][3100];
    dp[0][0]=1 ;
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<3100 ; j++){
        dp[i+1][j]+=2*dp[i][j];
        if(j-A[i]>=0)dp[i+1][j]+=dp[i][j-A[i] ];
        dp[i+1][j] %=mod ;
      }
    }
    System.out.println(dp[N][S]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := 998244353;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var S : int ; S := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,3100)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < 3100 do ( (     dp[i + 1+1][j+1] := dp[i + 1+1][j+1]+(2 * dp[i+1][j+1]) ; 
     if (j - A[i+1] >= 0) then     dp[i + 1+1][j+1] := dp[i + 1+1][j+1]+(dp[i+1][j - A[i+1]+1]) ; else skip ; 
     dp[i + 1+1][j+1] := dp[i + 1+1][j+1] mod mod )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[N+1][S+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int s=scanner.nextInt();
    int[][] dp=new int[2][s+1];
    dp[0][0]=1 ;
    for(int i=1 ; i<=n ; i++){
      int v=scanner.nextInt();
      for(int j=0 ; j<s+1 ; j++){
        dp[i % 2][j]=(dp[(i+1)% 2][j]*2)% 998244353 ;
      }
      for(int j=0 ; j<s+1-v ; j++){
        if(dp[(i+1)% 2][j]>0){
          dp[i % 2][j+v]=(dp[i % 2][j+v]+dp[(i+1)% 2][j])% 998244353 ;
        }
      }
    }
    System.out.println(dp[n % 2][s]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var s : int ; s := scanner.getCurrent()->toInteger() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,s + 1)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do ( (     var v : int ; v := scanner.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < s + 1 do ( (     dp[i mod 2+1][j+1] := (dp[(i + 1) mod 2+1][j+1] * 2) mod 998244353 )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < s + 1 - v do ( (     if (dp[(i + 1) mod 2+1][j+1] > 0) then (     dp[i mod 2+1][j + v+1] := (dp[i mod 2+1][j + v+1] + dp[(i + 1) mod 2+1][j+1]) mod 998244353 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[n mod 2+1][s+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class ProductArray {
  void productArray(int arr[],int n){
    if(n==1){
      System.out.print("0");
      return ;
    }
    int i,temp=1 ;
    int prod[]=new int[n];
    for(int j=0 ; j<n ; j++)prod[j]=1 ;
    for(i=0 ; i<n ; i++){
      prod[i]=temp ;
      temp*=arr[i];
    }
    temp=1 ;
    for(i=n-1 ; i>=0 ; i--){
      prod[i]*=temp ;
      temp*=arr[i];
    }
    for(i=0 ; i<n ; i++)System.out.print(prod[i]+" ");
    return ;
  }
  public static void main(String[] args){
    ProductArray pa=new ProductArray();
    int arr[]={
      10,3,5,6,2 };
      int n=arr.length ;
      System.out.println("The product array is : ");
      pa.productArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class ProductArray {
   operation productArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     if (n = 1) then (     OclFile["System.out"].print("0") ; 
     return ) else skip ; 
     var i : int ;
    var temp : int ; temp := 1 ;
    var prod : Sequence(int) ; prod := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do (     prod[j+1] := 1 ;  ;     j := j + 1 ) ; 
        i := 0 ; while i < n do ( (     prod[i+1] := temp ; 
     temp := temp*(arr[i+1]) )  ;     i := i + 1 ) ; 
    temp := 1 ; 
        i := n - 1 ; while i >= 0 do ( (     prod[i+1] := prod[i+1]*(temp) ; 
     temp := temp*(arr[i+1]) )  ;     i := i - 1 ) ; 
        i := 0 ; while i < n do (     OclFile["System.out"].print(prod[i+1] + " ") ;  ;     i := i + 1 ) ; 
    return 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var pa : ProductArray ; pa := ProductArray.newProductArray() ;
     var arr : Sequence(int) ; arr := Sequence{10,3,5,6,2} ;
    var n : int ; n := arr->size() ;
    OclFile["System.out"].println("The product array is : ") ; 
    pa.productArray(arr, n) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class ProductArray {
  void productArray(int arr[],int n){
    if(n==1){
      System.out.print(0);
      return ;
    }
    int left[]=new int[n];
    int right[]=new int[n];
    int prod[]=new int[n];
    int i,j ;
    left[0]=1 ;
    right[n-1]=1 ;
    for(i=1 ; i<n ; i++)left[i]=arr[i-1]*left[i-1];
    for(j=n-2 ; j>=0 ; j--)right[j]=arr[j+1]*right[j+1];
    for(i=0 ; i<n ; i++)prod[i]=left[i]*right[i];
    for(i=0 ; i<n ; i++)System.out.print(prod[i]+" ");
    return ;
  }
  public static void main(String[] args){
    ProductArray pa=new ProductArray();
    int arr[]={
      10,3,5,6,2 };
      int n=arr.length ;
      System.out.println("The product array is : ");
      pa.productArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class ProductArray {
   operation productArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     if (n = 1) then (     OclFile["System.out"].print(0) ; 
     return ) else skip ; 
     var left : Sequence(int) ; left := Integer.subrange(1,n)->collect(0) ;
    var right : Sequence(int) ; right := Integer.subrange(1,n)->collect(0) ;
    var prod : Sequence(int) ; prod := Integer.subrange(1,n)->collect(0) ;
    var i : int ;
    var j : int ;
    left[0+1] := 1 ; 
    right[n - 1+1] := 1 ; 
        i := 1 ; while i < n do (     left[i+1] := arr[i - 1+1] * left[i - 1+1] ;  ;     i := i + 1 ) ; 
        j := n - 2 ; while j >= 0 do (     right[j+1] := arr[j + 1+1] * right[j + 1+1] ;  ;     j := j - 1 ) ; 
        i := 0 ; while i < n do (     prod[i+1] := left[i+1] * right[i+1] ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do (     OclFile["System.out"].print(prod[i+1] + " ") ;  ;     i := i + 1 ) ; 
    return 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var pa : ProductArray ; pa := ProductArray.newProductArray() ;
     var arr : Sequence(int) ; arr := Sequence{10,3,5,6,2} ;
    var n : int ; n := arr->size() ;
    OclFile["System.out"].println("The product array is : ") ; 
    pa.productArray(arr, n) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    int a=0 ;
    int b=x ;
    boolean jud=false ;
    for(int i=0 ; i<=x ; i++){
      if(y==2*a+4*b){
        jud=true ;
      }
      a++;
      b--;
    }
    if(jud){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var a : int ; a := 0 ;
    var b : int ; b := x ;
    var jud : boolean ; jud := false ;
        var i : int ; i := 0 ; while i <= x do ( (     if (y = 2 * a + 4 * b) then (     jud := true ) else skip ; 
     a := a + 1 ; 
     b := b - 1 )  ;     i := i + 1 ) ; 
    if (jud) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    String[] lo=reader.readLine().split(" ");
    int X=Integer.parseInt(lo[0]);
    int Y=Integer.parseInt(lo[1]);
    if((Y-2*X)% 2==0 &&(Y-2*X)>=0 &&(Y-2*X)/2<=X){
      System.out.println("Yes");
    }
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var lo : Sequence(String) ; lo := reader.readLine()->split(" ") ;
    var X : int ; X := (lo[0+1])->toInteger() ;
    var Y : int ; Y := (lo[1+1])->toInteger() ;
    if ((Y - 2 * X) mod 2 = 0 & (Y - 2 * X) >= 0 & (Y - 2 * X) / 2 <= X) then (     OclFile["System.out"].println("Yes") ) else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static Scanner sc ;
  static void solve(){
    int qnt=sc.nextInt();
    int legs=sc.nextInt();
    if(4*qnt<legs || legs<2*qnt || legs % 2!=0){
      System.out.println("No");
      return ;
    }
    System.out.println("Yes");
  }
  public static void main(String args[])throws Exception {
    sc=new Scanner(System.in);
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var qnt : int ; qnt := sc.getCurrent()->toInteger() ;
     var legs : int ; legs := sc.getCurrent()->toInteger() ;
     if (4 * qnt < legs or legs < 2 * qnt or legs mod 2 /= 0) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
     OclFile["System.out"].println("Yes") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int legs=sc.nextInt();
    int turtles=(legs/2)-n ;
    int cranes=Math.abs(n-turtles);
    if(turtles>=0 && cranes>=0 && turtles+cranes==n &&((2*cranes)+(4*turtles))==legs){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var legs : int ; legs := sc.getCurrent()->toInteger() ;
    var turtles : int ; turtles := (legs / 2) - n ;
    var cranes : int ; cranes := if n - turtles < 0 then -(n - turtles) else n - turtles endif ;
    if (turtles >= 0 & cranes >= 0 & turtles + cranes = n & ((2 * cranes) + (4 * turtles)) = legs) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int x=scan.nextInt();
    int y=scan.nextInt();
    for(int crane=0 ; crane<=100 ; crane++){
      for(int turtle=0 ; turtle<=100 ; turtle++){
        if((crane+turtle==x)&&(crane*2+turtle*4==y)){
          System.out.println("Yes");
          return ;
        }
      }
    }
    System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := scan.getCurrent()->toInteger() ;
    var y : int ; y := scan.getCurrent()->toInteger() ;
        var crane : int ; crane := 0 ; while crane <= 100 do ( (         var turtle : int ; turtle := 0 ; while turtle <= 100 do ( (     if ((crane + turtle = x) & (crane * 2 + turtle * 4 = y)) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip )  ;     turtle := turtle + 1 ) )  ;     crane := crane + 1 ) ; 
    OclFile["System.out"].println("No") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    init();
    int n=nextInt(),k=nextInt();
    double[] ps=new double[n];
    for(int i=0 ; i<ps.length ; i++){
      ps[i]=expected(nextInt());
      if(i>0)ps[i]+=ps[i-1];
    }
    double ans=0.0 ;
    for(int i=0 ; i+k-1<ps.length ; i++){
      ans=Math.max(ans,ps[i+k-1]-(i-1>=0 ? ps[i-1] : 0));
    }
    System.out.println(ans);
  }
  private static double expected(double p){
    double sum=0.0 ;
    for(int i=1 ; i<=p ; i++){
      sum+=i ;
    }
    return sum/p ;
  }
  private static BufferedReader reader ;
  private static StringTokenizer tokenizer ;
  private static void init(){
    reader=new BufferedReader(new InputStreamReader(System.in));
    tokenizer=new StringTokenizer("");
  }
  private static String next()throws IOException {
    String read ;
    while(! tokenizer.hasMoreTokens()){
      read=reader.readLine();
      if(read==null || read.equals(""))return "-1" ;
      tokenizer=new StringTokenizer(read);
    }
    return tokenizer.nextToken();
  }
  private static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute init() ; 
     var n : int ; n := nextInt() ;
    var k : int ; k := nextInt() ;
    var ps : Sequence(double) ; ps := Integer.subrange(1,n)->collect(0.0) ;
        var i : int ; i := 0 ; while i < ps->size() do ( (     ps[i+1] := expected(nextInt()) ; 
     if (i > 0) then     ps[i+1] := ps[i+1]+(ps[i - 1+1]) ; else skip )  ;     i := i + 1 ) ; 
    var ans : double ; ans := 0.0 ;
        var i : int ; i := 0 ; while i + k - 1 < ps->size() do ( (     ans := Set{ans, ps[i + k - 1+1] - (if i - 1 >= 0 then ps[i - 1+1] else 0 endif)}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation expected( p : double) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0.0 ;
         var i : int ; i := 1 ; while i <= p do ( (     sum := sum+(i) )  ;     i := i + 1 ) ; 
     return sum / p );
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   operation init() : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := OclIterator.newOclIterator_String("") );
  static   operation next() : String
  pre: true
  post: true
  activity: (     var read : String ;
     while (not(tokenizer.hasNext())) do (     read := reader.readLine() ; 
     if (read = null or read = "") then     return "-1" else skip ; 
     tokenizer := OclIterator.newOclIterator_String(read) ) ; 
     return tokenizer.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  class BinaryHeap {
    private long[] heap ;
    private int size ;
    public BinaryHeap(int capacity){
      this.heap=new long[capacity];
      this.size=0 ;
    }
    public void dumpNodes(){
      for(int i=0 ; i<this.size ; i++){
        System.out.printf("node %d: key=%d,",i+1,this.heap[i]);
        int parent=this.parentIndexOf(i);
        if(i>0 && parent<this.size){
          System.out.printf("parent key=%d,",this.heap[parent]);
        }
        int left=this.leftIndexOf(i);
        if(left<this.size){
          System.out.printf("left key=%d,",this.heap[left]);
        }
        int right=this.rightIndexOf(i);
        if(right<this.size){
          System.out.printf("right key=%d,",this.heap[right]);
        }
        System.out.print("\n");
      }
    }
    public void insert(long key){
      this.heap[this.size]=key ;
      this.size++;
    }
    private int parentIndexOf(int i){
      return((i+1)/2)-1 ;
    }
    public int leftIndexOf(int i){
      return((i+1)*2)-1 ;
    }
    public int rightIndexOf(int i){
      return(i+1)*2 ;
    }
  }
  public static void main(String[] args){
    new Main().main();
  }
  public void main(){
    Scanner scanner=new Scanner(System.in);
    int n=Integer.parseInt(scanner.nextLine());
    String[] line=scanner.nextLine().split(" ",n);
    BinaryHeap heap=new BinaryHeap(n);
    for(int i=0 ; i<n ; i++){
      long a=Long.parseLong(line[i]);
      heap.insert(a);
    }
    heap.dumpNodes();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class BinaryHeap {
   attribute heap : Sequence(long);
   attribute size : int;
   static operation newBinaryHeap( capacity : int) : BinaryHeap
  pre: true
  post: true
  activity:
  ( var self : BinaryHeap ;
    self := createBinaryHeap();
    self.initialise(capacity);
    return self );
  operation initialise( capacity : int) : void
  pre: true  post: true
  activity: (     self.heap := Integer.subrange(1,capacity)->collect(0) ; 
     self.size := 0 );
   operation dumpNodes() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < self.size do ( (     OclFile["System.out"].printf("node %d: key=%d,", i + 1, self.heap[i+1]) ; 
     var parent : int ; parent := self.parentIndexOf(i) ;
    if (i > 0 & parent < self.size) then (     OclFile["System.out"].printf("parent key=%d,", self.heap[parent+1]) ) else skip ; 
    var left : int ; left := self.leftIndexOf(i) ;
    if (left < self.size) then (     OclFile["System.out"].printf("left key=%d,", self.heap[left+1]) ) else skip ; 
    var right : int ; right := self.rightIndexOf(i) ;
    if (right < self.size) then (     OclFile["System.out"].printf("right key=%d,", self.heap[right+1]) ) else skip ; 
    OclFile["System.out"].print("\n") ; 
 )  ;     i := i + 1 ) );
   operation insert( key : long) : void
  pre: true
  post: true
  activity: (     self.heap[self.size+1] := key ; 
     self.size := self.size + 1 );
   operation parentIndexOf( i : int) : int
  pre: true
  post: true
  activity: (     return ((i + 1) / 2) - 1 );
   operation leftIndexOf( i : int) : int
  pre: true
  post: true
  activity: (     return ((i + 1) * 2) - 1 );
   operation rightIndexOf( i : int) : int
  pre: true
  post: true
  activity: (     return (i + 1) * 2 );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().main() );
   operation main() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (scanner.nextLine())->toInteger() ;
    var line : Sequence(String) ; line := scanner.nextLine()->split(" ") ;
    var heap : BinaryHeap ; heap := BinaryHeap.newBinaryHeap(n) ;
        var i : int ; i := 0 ; while i < n do ( (     var a : long ; a := (line[i+1])->toLong() ;
     heap := heap.insertAt(a+1, StringLib.newString()) )  ;     i := i + 1 ) ; 
    heap.dumpNodes() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int binaryToDecimal(int n){
    int num=n ;
    int dec_value=0 ;
    int base=1 ;
    int temp=num ;
    while(temp>0){
      int last_digit=temp % 10 ;
      temp=temp/10 ;
      dec_value+=last_digit*base ;
      base=base*2 ;
    }
    return dec_value ;
  }
  public static void main(String[] args){
    int num=10101001 ;
    System.out.println(binaryToDecimal(num));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation binaryToDecimal( n : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := n ;
     var dec_value : int ; dec_value := 0 ;
    var base : int ; base := 1 ;
    var temp : int ; temp := num ;
    while (temp > 0) do (     var last_digit : int ; last_digit := temp mod 10 ;
     temp := temp / 10 ; 
     dec_value := dec_value+(last_digit * base) ; 
     base := base * 2 ) ; 
    return dec_value 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 10101001 ;
     OclFile["System.out"].println(binaryToDecimal(num)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class SequencewithDigits {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int t=in.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      long a=in.nextLong(),k=in.nextLong();
      pw.println(solve(a,k));
    }
    pw.close();
  }
  static long solve(long a,long k){
    long ans=a ;
    for(long i=2 ; i<=k ; i++){
      long v=minDig(ans)*maxDig(ans);
      if(v==0)return ans ;
      ans+=v ;
    }
    return ans ;
  }
  static long minDig(long n){
    long ans=10 ;
    while(n!=0){
      ans=Math.min(ans,n % 10);
      n/=10 ;
    }
    return ans ;
  }
  static long maxDig(long n){
    long ans=0 ;
    while(n!=0){
      ans=Math.max(ans,n % 10);
      n/=10 ;
    }
    return ans ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class SequencewithDigits {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        var tt : int ; tt := 0 ; while tt < t do ( (     var a : long ; a := in.getCurrent()->toLong() ;
    var k : long ; k := in.getCurrent()->toLong() ;
     skip )  ;     tt := tt + 1 ) ; 
    skip ; 
 );
  static   operation solve( a : long, k : long) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := a ;
         var i : long ; i := 2 ; while i <= k do ( (     var v : long ; v := minDig(ans) * maxDig(ans) ;
     if (v = 0) then     return ans else skip ; 
     ans := ans+(v) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation minDig( n : long) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 10 ;
     while (n /= 0) do (     ans := Set{ans, n mod 10}->min() ; 
     n := n/(10) ) ; 
     return ans );
  static   operation maxDig( n : long) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
     while (n /= 0) do (     ans := Set{ans, n mod 10}->max() ; 
     n := n/(10) ) ; 
     return ans );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] s=new int[n];
    int[] t=new int[n];
    String ss=sc.next();
    for(int i=0 ; i<n ; i++){
      s[i]=ss.charAt(i)-'a' ;
    }
    String st=sc.next();
    for(int i=0 ; i<n ; i++){
      t[i]=st.charAt(i)-'a' ;
    }
    int[] table=new int[26];
    for(int i=0 ; i<26 ; i++){
      table[i]=0 ;
    }
    table[s[0] ]=1 ;
    for(int i=1 ; i<n-1 ; i++){
      table[s[i] ]+=table[t[i] ];
      table[s[i] ] %=1000000007 ;
    }
    System.out.println(table[t[n-1] ]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
    var ss : String ; ss := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := ss->at(i+1) - ('a')->char2byte() )  ;     i := i + 1 ) ; 
    var st : String ; st := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < n do ( (     t[i+1] := st->at(i+1) - ('a')->char2byte() )  ;     i := i + 1 ) ; 
    var table : Sequence(int) ; table := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < 26 do ( (     table[i+1] := 0 )  ;     i := i + 1 ) ; 
    table[s[0+1]+1] := 1 ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     table[s[i+1]+1] := table[s[i+1]+1]+(table[t[i+1]+1]) ; 
     table[s[i+1]+1] := table[s[i+1]+1] mod 1000000007 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(table[t[n - 1+1]+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  static String[] S ;
  static String[] T ;
  static int N ;
  public static void main(String args[])throws IOException {
    Scanner scan=new Scanner(System.in);
    int ansDiv=1000000007 ;
    N=Integer.parseInt(scan.nextLine());
    String s=scan.nextLine();
    String t=scan.nextLine();
    S=s.split("");
    T=t.split("");
    HashMap<String,Integer>hash=new HashMap<String,Integer>();
    hash.put(S[0],1);
    for(int i=1 ; i<N-1 ; i++){
      if(! hash.containsKey(S[i])){
        hash.put(S[i],0);
      }
      if(! hash.containsKey(T[i])){
        hash.put(T[i],0);
      }
      hash.put(S[i],(hash.get(T[i])+hash.get(S[i]))% ansDiv);
    }
    System.out.println(hash.get(T[N-1]));
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute S : Sequence(String);
  static   attribute T : Sequence(String);
  static   attribute N : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ansDiv : int ; ansDiv := 1000000007 ;
    N := (scan.nextLine())->toInteger() ; 
    var s : String ; s := scan.nextLine() ;
    var t : String ; t := scan.nextLine() ;
    S := s->split("") ; 
    T := t->split("") ; 
    var hash : Map(String,int) ; hash := Map{} ;
    hash := hash->union(Map{S[0+1] |-> 1}) ; 
        var i : int ; i := 1 ; while i < N - 1 do ( (     if (not(hash->keys()->includes(S[i+1]))) then (     hash := hash->union(Map{S[i+1] |-> 0}) ) else skip ; 
     if (not(hash->keys()->includes(T[i+1]))) then (     hash := hash->union(Map{T[i+1] |-> 0}) ) else skip ; 
     hash := hash->union(Map{S[i+1] |-> (hash->at(T[i+1]) + hash->at(S[i+1])) mod ansDiv}) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(hash->at(T[N - 1+1])) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char[] s=in.nextLine().toCharArray();
    in.close();
    char ch=0 ;
    int cnt=0,scnt=1 ;
    for(char c : s){
      if(c==ch)scnt++;
      else {
        if(scnt>=cnt)cnt=scnt ;
        ch=c ;
        scnt=1 ;
      }
    }
    if(scnt>=cnt)cnt=scnt ;
    if(cnt<7)System.out.println("NO");
    else System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := in.nextLine()->characters() ;
    skip ; 
    var ch : String ; ch := 0 ;
    var cnt : int ; cnt := 0 ;
    var scnt : int ; scnt := 1 ;
    for (c : s) do ( (     if (c = ch) then     scnt := scnt + 1 ; else (     if (scnt >= cnt) then     cnt := scnt ; else skip ; 
     ch := c ; 
     scnt := 1 ) )  ) ; 
    if (scnt >= cnt) then     cnt := scnt ; else skip ; 
    if (cnt < 7) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class prog1 {
  static String solve(String str){
    int c=1 ;
    if(str.length()<7)return "NO" ;
    for(int i=0 ; i<str.length()-1 ; i++){
      char ch1=str.charAt(i);
      char ch2=str.charAt(i+1);
      if(ch1==ch2){
        c++;
      }
      else {
        if(c>=7)return "YES" ;
        c=1 ;
      }
    }
    if(c>=7)return "YES" ;
    return "NO" ;
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String str=sc.nextLine();
    String ans=solve(str);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class prog1 {
  static   operation solve( str : String) : String
  pre: true
  post: true
  activity: (     var c : int ; c := 1 ;
     if (str->size() < 7) then     return "NO" else skip ; 
        var i : int ; i := 0 ; while i < str->size() - 1 do ( (     var ch1 : String ; ch1 := str->at(i+1) ;
     var ch2 : String ; ch2 := str->at(i + 1+1) ;
     if (ch1 = ch2) then (     c := c + 1 ) else (     if (c >= 7) then     return "YES" else skip ; 
     c := 1 ) )  ;     i := i + 1 ) ; 
    if (c >= 7) then     return "YES" else skip ; 
    return "NO" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.nextLine() ;
     var ans : String ; ans := solve(str) ;
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class nurda {
  public static void main(String[] args){
    Scanner real=new Scanner(System.in);
    String n=real.nextLine();
    if(n.contains("0000000")|| n.contains("1111111")){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class nurda {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var real : OclFile ; real := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : String ; n := real.nextLine() ;
     if (n->includes("0000000") or n->includes("1111111")) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class pr6 {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String s=scan.nextLine();
    int w1=0,w2=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='1'){
        w1++;
        w2=0 ;
      }
      else if(s.charAt(i)=='0'){
        w1=0 ;
        w2++;
      }
      if(w1==7 || w2==7){
        System.out.println("YES");
        break ;
      }
    }
    if(w1!=7 && w2!=7)System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class pr6 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scan.nextLine() ;
    var w1 : int ; w1 := 0 ;
    var w2 : int ; w2 := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '1') then (     w1 := w1 + 1 ; 
     w2 := 0 ) else     if (s->at(i+1) = '0') then (     w1 := 0 ; 
     w2 := w2 + 1 ) else skip ; ;  
     if (w1 = 7 or w2 = 7) then (     OclFile["System.out"].println("YES") ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (w1 /= 7 & w2 /= 7) then     OclFile["System.out"].println("NO") ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Football {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String num=in.next();
    int count1=0 ;
    int count2=0 ;
    for(int i=0 ; i<num.length(); i++){
      if(num.charAt(i)=='1'){
        count1++;
      }
      else if(num.charAt(i)=='0'){
        count2++;
      }
      if(count1<7 && num.charAt(i)=='0'){
        count1=0 ;
      }
      else if(count2<7 && num.charAt(i)=='1'){
        count2=0 ;
      }
    }
    if(count1>=7 || count2>=7)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Football {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : String ; num := in.getCurrent() ;
    var count1 : int ; count1 := 0 ;
    var count2 : int ; count2 := 0 ;
        var i : int ; i := 0 ; while i < num->size() do ( (     if (num->at(i+1) = '1') then (     count1 := count1 + 1 ) else     if (num->at(i+1) = '0') then (     count2 := count2 + 1 ) else skip ; ;  
     if (count1 < 7 & num->at(i+1) = '0') then (     count1 := 0 ) else     if (count2 < 7 & num->at(i+1) = '1') then (     count2 := 0 ) else skip ; )  ;     i := i + 1 ) ; 
    if (count1 >= 7 or count2 >= 7) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Geeks {
  static int binomialCoeff(int x,int n,int k){
    int sum=0,term=1 ;
    for(int i=1 ; i<=n && sum<k ; ++i){
      term*=x-i+1 ;
      term/=i ;
      sum+=term ;
    }
    return sum ;
  }
  static int minTrials(int n,int k){
    int low=1,high=k ;
    while(low<high){
      int mid=(low+high)/2 ;
      if(binomialCoeff(mid,n,k)<k)low=mid+1 ;
      else high=mid ;
    }
    return low ;
  }
  public static void main(String args[]){
    System.out.println(minTrials(2,10));
  }
}
------------------------------------------------------------
OCL File:
---------
class Geeks {
  static   operation binomialCoeff( x : int, n : int, k : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
    var term : int ; term := 1 ;
         var i : int ; i := 1 ; while i <= n & sum < k do ( (     term := term*(x - i + 1) ; 
     term := term/(i) ; 
     sum := sum+(term) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation minTrials( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var low : int ; low := 1 ;
    var high : int ; high := k ;
     while (low < high) do (     var mid : int ; mid := (low + high) / 2 ;
     if (binomialCoeff(mid, n, k) < k) then     low := mid + 1 ; else     high := mid ; ) ; 
     return low );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(minTrials(2, 10)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt(),K=sc.nextInt(),p[]=new int[N],sum[]=new int[N+1];
    for(int i=0 ; i<N ; i++){
      p[i]=sc.nextInt()+1 ;
      if(i==0)sum[i]=0 ;
      sum[i+1]=sum[i]+p[i];
    }
    double ans=0 ;
    for(int i=0 ; i<=N-K ; i++){
      ans=Math.max(ans,sum[i+K]-sum[i]);
    }
    System.out.println((double)ans/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var p : Sequence(void) ; p := Integer.subrange(1,N)->collect(0) ;
    var sum : Sequence(void) ; sum := Integer.subrange(1,N + 1)->collect(0) ;
         var i : int ; i := 0 ; while i < N do ( (     p[i+1] := sc.getCurrent()->toInteger() + 1 ; 
     if (i = 0) then     sum[i+1] := 0 ; else skip ; 
     sum[i + 1+1] := sum[i+1] + p[i+1] )  ;     i := i + 1 ) ; 
    var ans : double ; ans := 0 ;
        var i : int ; i := 0 ; while i <= N - K do ( (     ans := Set{ans, sum[i + K+1] - sum[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans->oclAsType(double) / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxSum(int p0,int p1,int a[],int pos,int n){
    if(pos==n){
      if(p0==p1)return p0 ;
      else return 0 ;
    }
    int ans=maxSum(p0,p1,a,pos+1,n);
    ans=Math.max(ans,maxSum(p0+a[pos],p1,a,pos+1,n));
    ans=Math.max(ans,maxSum(p0,p1+a[pos],a,pos+1,n));
    return ans ;
  }
  public static void main(String[] args){
    int n=4 ;
    int a[]={
      1,2,3,6 };
      System.out.println(maxSum(0,0,a,0,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxSum( p0 : int, p1 : int, a : Sequence(int), pos : int, n : int) : int
  pre: true
  post: true
  activity: (     if (pos = n) then (     if (p0 = p1) then     return p0 else     return 0 ) else skip ; 
     var ans : int ; ans := maxSum(p0, p1, a, pos + 1, n) ;
    ans := Set{ans, maxSum(p0 + a[pos+1], p1, a, pos + 1, n)}->max() ; 
    ans := Set{ans, maxSum(p0, p1 + a[pos+1], a, pos + 1, n)}->max() ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var a : Sequence(int) ; a := Sequence{1,2,3,6} ;
     OclFile["System.out"].println(maxSum(0, 0, a, 0, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in))){
      final String s=reader.readLine();
      final String[] sl=s.split(" ");
      Double D=Double.parseDouble(sl[0]);
      int N=Integer.parseInt(sl[1]);
      if(N==100)N+=1 ;
      System.out.println((int)(N*Math.pow(100d,D)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var s : String ; s := reader.readLine() ;
     var sl : Sequence(String) ; sl := s->split(" ") ;
    var D : double ; D := (sl[0+1])->toReal() ;
    var N : int ; N := (sl[1+1])->toInteger() ;
    if (N = 100) then     N := N+(1) ; else skip ; 
    OclFile["System.out"].println((N * 100d->pow(D))->oclAsType(int)) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    final Scanner scanner=new Scanner(System.in);
    int d=scanner.nextInt();
    int n=scanner.nextInt();
    int result=0 ;
    if(d==0){
      for(int i=0 ; i<n ; i++){
        result+=1 ;
        if(result % 100==0){
          result+=1 ;
        }
      }
    }
    else if(d==1){
      for(int i=0 ; i<n ; i++){
        result+=100 ;
        if(result % 10000==0){
          result+=100 ;
        }
      }
    }
    else if(d==2){
      for(int i=0 ; i<n ; i++){
        result+=10000 ;
        if(result % 1000000==0){
          result+=10000 ;
        }
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : int ; d := scanner.getCurrent()->toInteger() ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var result : int ; result := 0 ;
    if (d = 0) then (         var i : int ; i := 0 ; while i < n do ( (     result := result+(1) ; 
     if (result mod 100 = 0) then (     result := result+(1) ) else skip )  ;     i := i + 1 ) ) else     if (d = 1) then (         var i : int ; i := 0 ; while i < n do ( (     result := result+(100) ; 
     if (result mod 10000 = 0) then (     result := result+(100) ) else skip )  ;     i := i + 1 ) ) else     if (d = 2) then (         var i : int ; i := 0 ; while i < n do ( (     result := result+(10000) ; 
     if (result mod 1000000 = 0) then (     result := result+(10000) ) else skip )  ;     i := i + 1 ) ) else skip ; ;  ;  
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String args[])throws Exception {
    Input input=new Input();
    final Data l=input.readLine();
    final int D=l.col[0];
    final int N=l.col[1];
    System.out.print((int)Math.pow(100,D)*(N==100 ? N+1 : N));
  }
  static class Input {
    public BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    public void close()throws Exception {
      input.close();
    }
    public Data readLine()throws Exception {
      return new Data(input.readLine().split(" "));
    }
  }
  static class Data {
    public int[] col ;
    public Data(String[] values){
      col=new int[values.length];
      for(int i=0 ; i<values.length ; i++){
        col[i]=Integer.parseInt(values[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : Input ; input := Input.newInput() ;
     var l : Data ; l := input.readLine() ;
    var D : int ; D := l.col[0+1] ;
    var N : int ; N := l.col[1+1] ;
    OclFile["System.out"].print(100->pow(D)->oclAsType(int) * (if N = 100 then N + 1 else N endif)) ; 
 );
  static class Input {
   attribute input : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
   operation readLine() : Data
  pre: true
  post: true
  activity: (     return Data.newData(input.readLine()->split(" ")) );
}
  static class Data {
   attribute col : Sequence(int);
   static operation newData( values : Sequence(String)) : Data
  pre: true
  post: true
  activity:
  ( var self : Data ;
    self := createData();
    self.initialise(values);
    return self );
  operation initialise( values : Sequence(String)) : void
  pre: true  post: true
  activity: (     col := Integer.subrange(1,values->size())->collect(0) ; 
         var i : int ; i := 0 ; while i < values->size() do ( (     col[i+1] := (values[i+1])->toInteger() )  ;     i := i + 1 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  private static class FastScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public FastScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
      tokenizer=null ;
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          return reader.readLine();
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken("\n");
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public int[] nextIntArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    public long[] nextLongArray(int n){
      long[] a=new long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
  }
  public static void main(String[] args){
    FastScanner sc=new FastScanner(System.in);
    int d=sc.nextInt();
    int n=sc.nextInt();
    int a=(int)Math.pow(100,d);
    int i=1 ;
    int count=0 ;
    while(count<n){
      int val=a*i ;
      if(val % a==0 && val %(a*100)!=0){
        count++;
      }
      i++;
    }
    System.out.println(a*(i-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.nextToken("\n") );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLongArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var d : int ; d := sc.nextInt() ;
    var n : int ; n := sc.nextInt() ;
    var a : int ; a := 100->pow(d)->oclAsType(int) ;
    var i : int ; i := 1 ;
    var count : int ; count := 0 ;
    while (count < n) do (     var val : int ; val := a * i ;
     if (val mod a = 0 & val mod (a * 100) /= 0) then (     count := count + 1 ) else skip ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println(a * (i - 1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int d=sc.nextInt();
    int n=sc.nextInt();
    int ans=0 ;
    if(d==0 && n!=100){
      ans=n ;
    }
    else if(d==0 && n==100){
      ans=n+1 ;
    }
    if(d==1 && n!=100){
      ans=n*100 ;
    }
    else if(d==1 && n==100){
      ans=(n+1)*100 ;
    }
    if(d==2 && n!=100){
      ans=n*10000 ;
    }
    else if(d==2 && n==100){
      ans=(n+1)*10000 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    if (d = 0 & n /= 100) then (     ans := n ) else     if (d = 0 & n = 100) then (     ans := n + 1 ) else skip ; ;  
    if (d = 1 & n /= 100) then (     ans := n * 100 ) else     if (d = 1 & n = 100) then (     ans := (n + 1) * 100 ) else skip ; ;  
    if (d = 2 & n /= 100) then (     ans := n * 10000 ) else     if (d = 2 & n = 100) then (     ans := (n + 1) * 10000 ) else skip ; ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class solution {
  static int oddEquivalent(String s,int n){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='1')count++;
    }
    return count ;
  }
  public static void main(String ar[]){
    String s="1011011" ;
    int n=s.length();
    System.out.println(oddEquivalent(s,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class solution {
  static   operation oddEquivalent( s : String, n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = '1') then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( ar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "1011011" ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].println(oddEquivalent(s, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public final class p122 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p122().run());
  }
  private static final int LIMIT=200 ;
  private int[] minOperations ;
  private int numUnknown ;
  public String run(){
    minOperations=new int[LIMIT+1];
    Arrays.fill(minOperations,-1);
    minOperations[0]=0 ;
    minOperations[1]=0 ;
    numUnknown=LIMIT-1 ;
    for(int ops=1 ; numUnknown>0 ; ops++){
      IntStack chain=new IntStack(ops+1);
      chain.push(1);
      exploreChains(chain,ops);
    }
    int sum=0 ;
    for(int x : minOperations)sum+=x ;
    return Integer.toString(sum);
  }
  private void exploreChains(IntStack chain,int maxOps){
    if(chain.size>maxOps || numUnknown==0)return ;
    int max=chain.values[chain.size-1];
    for(int i=chain.size-1 ; i>=0 ; i--){
      for(int j=i ; j>=0 ; j--){
        int x=chain.values[i]+chain.values[j];
        if(x<=max)break ;
        if(x<=LIMIT){
          chain.push(x);
          if(minOperations[x]==-1){
            minOperations[x]=chain.size-1 ;
            numUnknown--;
          }
          exploreChains(chain,maxOps);
          chain.pop();
        }
      }
    }
  }
  private static final class IntStack {
    public int[] values ;
    public int size ;
    public IntStack(int capacity){
      values=new int[capacity];
      size=0 ;
    }
    public void push(int x){
      if(size>=values.length)throw new IllegalStateException();
      values[size]=x ;
      size++;
    }
    public int pop(){
      if(size<=0)throw new IllegalStateException();
      size--;
      return values[size];
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class p122 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p122.newp122().run()) );
  static    attribute LIMIT : int := 200;
   attribute minOperations : Sequence(int);
   attribute numUnknown : int;
   operation run() : String
  pre: true
  post: true
  activity: (     minOperations := Integer.subrange(1,LIMIT + 1)->collect(0) ; 
     minOperations := minOperations->collect(-1) ; 
    minOperations[0+1] := 0 ; 
    minOperations[1+1] := 0 ; 
    numUnknown := LIMIT - 1 ; 
        var ops : int ; ops := 1 ; while numUnknown > 0 do ( (     var chain : IntStack ; chain := IntStack.newIntStack(ops + 1) ;
     chain := chain->append(1) ; 
     execute exploreChains(chain, ops) )  ;     ops := ops + 1 ) ; 
    var sum : int ; sum := 0 ;
    for (x : minOperations) do (     sum := sum+(x) ;  ) ; 
    return ((sum) + "") 
 );
   operation exploreChains( chain : IntStack, maxOps : int) : void
  pre: true
  post: true
  activity: (     if (chain.size > maxOps or numUnknown = 0) then     return else skip ; 
     var max : int ; max := chain.values[chain.size - 1+1] ;
         var i : int ; i := chain.size - 1 ; while i >= 0 do ( (         var j : int ; j := i ; while j >= 0 do ( (     var x : int ; x := chain.values[i+1] + chain.values[j+1] ;
     if (x <= max) then     break else skip ; 
     if (x <= LIMIT) then (     chain := chain->append(x) ; 
     if (minOperations[x+1] = -1) then (     minOperations[x+1] := chain.size - 1 ; 
     numUnknown := numUnknown - 1 ) else skip ; 
     execute exploreChains(chain, maxOps) ; 
     chain := chain->front() ) else skip )  ;     j := j - 1 ) )  ;     i := i - 1 ) );
  static  class IntStack {
   attribute values : Sequence(int);
   attribute size : int;
   static operation newIntStack( capacity : int) : IntStack
  pre: true
  post: true
  activity:
  ( var self : IntStack ;
    self := createIntStack();
    self.initialise(capacity);
    return self );
  operation initialise( capacity : int) : void
  pre: true  post: true
  activity: (     values := Integer.subrange(1,capacity)->collect(0) ; 
     size := 0 );
   operation push( x : int) : void
  pre: true
  post: true
  activity: (     if (size >= values->size()) then     error IncorrectElementException() ; else skip ; 
     values[size+1] := x ; 
     size := size + 1 );
   operation pop() : int
  pre: true
  post: true
  activity: (     if (size <= 0) then     error IncorrectElementException() ; else skip ; 
     size := size - 1 ; 
     return values[size+1] );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MinimizeleftOverSum(int a[],int n){
    Vector<Integer>v1=new Vector<Integer>(),v2=new Vector<Integer>();
    for(int i=0 ; i<n ; i++){
      if(a[i] % 2==1)v1.add(a[i]);
      else v2.add(a[i]);
    }
    if(v1.size()>v2.size()){
      Collections.sort(v1);
      Collections.sort(v2);
      int x=v1.size()-v2.size()-1 ;
      int sum=0 ;
      int i=0 ;
      while(i<x){
        sum+=v1.get(i++);
      }
      return sum ;
    }
    else if(v2.size()>v1.size()){
      Collections.sort(v1);
      Collections.sort(v2);
      int x=v2.size()-v1.size()-1 ;
      int sum=0 ;
      int i=0 ;
      while(i<x){
        sum+=v2.get(i++);
      }
      return sum ;
    }
    else return 0 ;
  }
  public static void main(String[] args){
    int a[]={
      2,2,2,2 };
      int n=a.length ;
      System.out.println(MinimizeleftOverSum(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MinimizeleftOverSum( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var v1 : Sequence(int) ; v1 := Sequence{} ;
    var v2 : Sequence(int) ; v2 := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] mod 2 = 1) then     v1 := v1->including(a[i+1]) ; else     v2->excludes(a[i+1]) ; )  ;     i := i + 1 ) ; 
     if (v1->size() > v2->size()) then (     v1 := v1->sort() ; 
     v2 := v2->sort() ; 
    var x : int ; x := v1->size() - v2->size() - 1 ;
    var sum : int ; sum := 0 ;
    var i : int ; i := 0 ;
    while (i < x) do (     sum := sum+(v1->at(i+1)) ) ; 
    return sum 
 ) else     if (v2->size() > v1->size()) then (     v1 := v1->sort() ; 
     v2 := v2->sort() ; 
    var x : int ; x := v2->size() - v1->size() - 1 ;
    var sum : int ; sum := 0 ;
    var i : int ; i := 0 ;
    while (i < x) do (     sum := sum+(v2->at(i+1)) ) ; 
    return sum 
 ) else     return 0 ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,2,2,2} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(MinimizeleftOverSum(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Random ;
import java.util.concurrent.ThreadLocalRandom ;
public class OptimalPointOnALine {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    String[] temp=br.readLine().split(" ");
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=Integer.parseInt(temp[i]);
    }
    shuffleArray(nums);
    Arrays.sort(nums);
    if(n % 2==1){
      pr.println(nums[n/2]);
      return ;
    }
    pr.println(nums[n/2-1]);
  }
  public static void shuffleArray(int[] arr){
    Random rnd=ThreadLocalRandom.current();
    for(int i=arr.length-1 ; i>0 ; i--){
      int index=rnd.nextInt(i+1);
      if(index!=i){
        arr[index] ^=arr[i];
        arr[i] ^=arr[index];
        arr[index] ^=arr[i];
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class OptimalPointOnALine {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := (temp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    execute shuffleArray(nums) ; 
    nums := nums->sort() ; 
    if (n mod 2 = 1) then (     skip ; 
     return ) else skip ; 
    skip ; 
 );
  static   operation shuffleArray( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var rnd : OclRandom ; rnd := MathLib ;
         var i : int ; i := arr->size() - 1 ; while i > 0 do ( (     var index : int ; index := rnd.nextInt(i + 1) ;
     if (index /= i) then (     arr[index+1] := MathLib.bitwiseXor(arr[index+1],arr[i+1]) ; 
     arr[i+1] := MathLib.bitwiseXor(arr[i+1],arr[index+1]) ; 
     arr[index+1] := MathLib.bitwiseXor(arr[index+1],arr[i+1]) ) else skip )  ;     i := i - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void convertToBinary(int num,int a[],int n){
    int pointer=n-1 ;
    while(num>0){
      a[pointer]=num % 2 ;
      num=num/2 ;
      pointer--;
    }
  }
  static void checkforsum(int a[],int n){
    int sum1=0 ;
    int sum2=0 ;
    int mid=n/2 ;
    for(int i=0 ; i<mid ; i++)sum1=sum1+a[i];
    for(int j=mid ; j<n ; j++)sum2=sum2+a[j];
    if(sum1==sum2){
      for(int i=0 ; i<n ; i++)System.out.print(a[i]);
      System.out.println();
    }
  }
  static void print_seq(int m){
    int n=(2*m);
    int a[]=new int[n];
    for(int j=0 ; j<n ; j++){
      a[j]=0 ;
    }
    for(int i=0 ; i<(int)Math.pow(2,n); i++){
      convertToBinary(i,a,n);
      checkforsum(a,n);
    }
  }
  public static void main(String[] args){
    int m=2 ;
    print_seq(m);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation convertToBinary( num : int, a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var pointer : int ; pointer := n - 1 ;
     while (num > 0) do (     a[pointer+1] := num mod 2 ; 
     num := num / 2 ; 
     pointer := pointer - 1 ) );
  static   operation checkforsum( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var sum1 : int ; sum1 := 0 ;
     var sum2 : int ; sum2 := 0 ;
    var mid : int ; mid := n / 2 ;
        var i : int ; i := 0 ; while i < mid do (     sum1 := sum1 + a[i+1] ;  ;     i := i + 1 ) ; 
        var j : int ; j := mid ; while j < n do (     sum2 := sum2 + a[j+1] ;  ;     j := j + 1 ) ; 
    if (sum1 = sum2) then (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(a[i+1]) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) else skip ; 
 );
  static   operation print_seq( m : int) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (2 * m) ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var j : int ; j := 0 ; while j < n do ( (     a[j+1] := 0 )  ;     j := j + 1 ) ; 
         var i : int ; i := 0 ; while i < 2->pow(n)->oclAsType(int) do ( (     execute convertToBinary(i, a, n) ; 
     execute checkforsum(a, n) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 2 ;
     execute print_seq(m) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scan=new Scanner(System.in)){
      int N=scan.nextInt();
      int K=scan.nextInt();
      double[] s=new double[N+1];
      int[] p=new int[N];
      for(int i=0 ; i<N ; i++)p[i]=scan.nextInt();
      for(int i=0 ; i<N ; i++){
        s[i+1]=s[i]+(p[i]+1)/2.0 ;
      }
      double max=0 ;
      for(int i=0 ; i<=N-K ; i++){
        double a=s[i+K]-s[i];
        if(max<a)max=a ;
      }
      BigDecimal d=new BigDecimal(max);
      String str=String.format("%1$.7f",d);
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := scan.getCurrent()->toInteger() ;
     var K : int ; K := scan.getCurrent()->toInteger() ;
    var s : Sequence(double) ; s := Integer.subrange(1,N + 1)->collect(0.0) ;
    var p : Sequence(int) ; p := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     p[i+1] := scan.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     s[i + 1+1] := s[i+1] + (p[i+1] + 1) / 2.0 )  ;     i := i + 1 ) ; 
    var max : double ; max := 0 ;
        var i : int ; i := 0 ; while i <= N - K do ( (     var a : double ; a := s[i + K+1] - s[i+1] ;
     if (max < a) then     max := a ; else skip )  ;     i := i + 1 ) ; 
    var d : double ; d := double(max) ;
    var str : String ; str := StringLib.format("%1$.7f",Sequence{d}) ;
    OclFile["System.out"].println(max) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printArr(int[] arr,int k){
    for(int i=0 ; i<k ; i++)System.out.print(arr[i]+" ");
    System.out.print("\n");
  }
  static void printSeqUtil(int n,int k,int len,int[] arr){
    if(len==k){
      printArr(arr,k);
      return ;
    }
    int i=(len==0)? 1 : arr[len-1]+1 ;
    len++;
    while(i<=n){
      arr[len-1]=i ;
      printSeqUtil(n,k,len,arr);
      i++;
    }
    len--;
  }
  static void printSeq(int n,int k){
    int[] arr=new int[k];
    int len=0 ;
    printSeqUtil(n,k,len,arr);
  }
  static public void main(String[] args){
    int k=3,n=7 ;
    printSeq(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printArr( arr : Sequence(int), k : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < k do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("\n") );
  static   operation printSeqUtil( n : int, k : int, len : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (len = k) then (     execute printArr(arr, k) ; 
     return ) else skip ; 
     var i : int ; i := if (len = 0) then 1 else arr[len - 1+1] + 1 endif ;
    len := len + 1 ; 
    while (i <= n) do (     arr[len - 1+1] := i ; 
     execute printSeqUtil(n, k, len, arr) ; 
     i := i + 1 ) ; 
    len := len - 1 ; 
 );
  static   operation printSeq( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,k)->collect(0) ;
     var len : int ; len := 0 ;
     execute printSeqUtil(n, k, len, arr) );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 3 ;
    var n : int ; n := 7 ;
     execute printSeq(n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void check(int n){
    if(n % 2==1 && n>5){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
  public static void main(String[] args){
    int a=3 ;
    int b=7 ;
    check(a);
    check(b);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation check( n : int) : void
  pre: true
  post: true
  activity: (     if (n mod 2 = 1 & n > 5) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
     var b : int ; b := 7 ;
     execute check(a) ; 
     execute check(b) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class LevkoAndPermutation {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(in.readLine());
    int n=Integer.parseInt(st.nextToken()),k=Integer.parseInt(st.nextToken());
    int[] arr=new int[n];
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=i+1 ;
    }
    if(k==n)System.out.println(-1);
    else {
      k=n-k ;
      if(k==1){
        for(int i=0 ; i<arr.length ; i++){
          System.out.print(arr[i]+" ");
        }
      }
      else {
        int lst=arr.length-1 ;
        while(k-->2){
          arr[lst]=arr[lst-1];
          lst--;
        }
        arr[lst]=1 ;
        arr[0]=n ;
        for(int i=0 ; i<arr.length ; i++){
          System.out.print(arr[i]+" ");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class LevkoAndPermutation {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(in.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var k : int ; k := (st.next())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := i + 1 )  ;     i := i + 1 ) ; 
    if (k = n) then     OclFile["System.out"].println(-1) else (     k := n - k ; 
     if (k = 1) then (         var i : int ; i := 0 ; while i < arr->size() do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ) else (     var lst : int ; lst := arr->size() - 1 ;
         while (k > 2) do (        k := k - 1 ;     skip ; (     arr[lst+1] := arr[lst - 1+1] ; 
     lst := lst - 1 ) ;  ) ;  
    arr[lst+1] := 1 ; 
    arr[0+1] := n ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt(),k=sc.nextInt();
    if(k==n){
      System.out.println(-1);
      return ;
    }
    int[] perm=new int[n+1];
    perm[1]=1 ;
    int i=2 ;
    for(; i<=n && k-->0 ; i++){
      perm[i]=i ;
    }
    if(i<=n){
      perm[1]=i ;
      perm[n]=1 ;
    }
    for(; i<n ; i++){
      perm[i]=i+1 ;
    }
    for(int j=1 ; j<perm.length ; j++){
      out.print(perm[j]+" ");
    }
    out.flush();
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(FileReader fileReader){
      br=new BufferedReader(fileReader);
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    if (k = n) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var perm : Sequence(int) ; perm := Integer.subrange(1,n + 1)->collect(0) ;
    perm[1+1] := 1 ; 
    var i : int ; i := 2 ;
      while i <= n & k > 0 do ( (     perm[i+1] := i )  ;     i := i + 1 ) ; 
    if (i <= n) then (     perm[1+1] := i ; 
     perm[n+1] := 1 ) else skip ; 
      while i < n do ( (     perm[i+1] := i + 1 )  ;     i := i + 1 ) ; 
        var j : int ; j := 1 ; while j < perm->size() do ( (     skip )  ;     j := j + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( fileReader : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(fileReader);
    return self );
  operation initialise( fileReader : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(fileReader) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().solve();
  }
  void solve(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    long[] a=new long[n];
    long[] sum_a=new long[n];
    long[] sum_b=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
      if(i==0){
        sum_a[i]=a[i];
        sum_b[i]=Math.max(0,a[i]);
      }
      else {
        sum_a[i]=sum_a[i-1]+a[i];
        sum_b[i]=sum_b[i-1]+Math.max(0,a[i]);
      }
    }
    long ans=0 ;
    for(int i=0 ; i<=n-k ; i++){
      long sum_black=0 ;
      long sum_white=0 ;
      if(i==0)sum_black+=sum_a[i+k-1];
      else sum_black+=sum_a[i+k-1]-sum_a[i-1];
      if(i>0){
        sum_black+=sum_b[i-1];
        sum_white+=sum_b[i-1];
      }
      sum_black+=sum_b[n-1]-sum_b[i+k-1];
      sum_white+=sum_b[n-1]-sum_b[i+k-1];
      ans=Math.max(sum_black,ans);
      ans=Math.max(sum_white,ans);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum_a : Sequence(long) ; sum_a := Integer.subrange(1,n)->collect(0) ;
    var sum_b : Sequence(long) ; sum_b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() ; 
     if (i = 0) then (     sum_a[i+1] := a[i+1] ; 
     sum_b[i+1] := Set{0, a[i+1]}->max() ) else (     sum_a[i+1] := sum_a[i - 1+1] + a[i+1] ; 
     sum_b[i+1] := sum_b[i - 1+1] + Set{0, a[i+1]}->max() ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i <= n - k do ( (     var sum_black : long ; sum_black := 0 ;
     var sum_white : long ; sum_white := 0 ;
    if (i = 0) then     sum_black := sum_black+(sum_a[i + k - 1+1]) else     sum_black := sum_black+(sum_a[i + k - 1+1] - sum_a[i - 1+1]) ; ;  
    if (i > 0) then (     sum_black := sum_black+(sum_b[i - 1+1]) ; 
     sum_white := sum_white+(sum_b[i - 1+1]) ) else skip ; 
    sum_black := sum_black+(sum_b[n - 1+1] - sum_b[i + k - 1+1]) ; 
    sum_white := sum_white+(sum_b[n - 1+1] - sum_b[i + k - 1+1]) ; 
    ans := Set{sum_black, ans}->max() ; 
    ans := Set{sum_white, ans}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    int k=sc.nextInt();
    long[] a=new long[100010];
    long[] b=new long[100010];
    long[] c=new long[100010];
    for(int i=1 ; i<=n ; i++){
      a[i]=sc.nextLong();
      b[i]=b[i-1]+a[i];
    }
    long sum=0 ;
    for(int i=1 ; i<=n ; i++){
      sum+=a[i]>0 ? a[i] : 0 ;
      c[i]=sum ;
    }
    long ret=0 ;
    long t,u ;
    for(int i=1 ; i<=n-k+1 ; i++){
      u=Math.max(b[i+k-1]-b[i-1],0);
      t=c[i-1]+u+c[n]-c[i+k-1];
      ret=Math.max(ret,t);
    }
    System.out.println(ret);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,100010)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,100010)->collect(0) ;
    var c : Sequence(long) ; c := Integer.subrange(1,100010)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := sc.getCurrent()->toLong() ; 
     b[i+1] := b[i - 1+1] + a[i+1] )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     sum := sum+(if a[i+1] > 0 then a[i+1] else 0 endif) ; 
     c[i+1] := sum )  ;     i := i + 1 ) ; 
    var ret : long ; ret := 0 ;
    var t : long ;
    var u : long ;
        var i : int ; i := 1 ; while i <= n - k + 1 do ( (     u := Set{b[i + k - 1+1] - b[i - 1+1], 0}->max() ; 
     t := c[i - 1+1] + u + c[n+1] - c[i + k - 1+1] ; 
     ret := Set{ret, t}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ret) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] a=new int[n];
    long[] b=new long[n+1];
    long[] c=new long[n+2];
    b[0]=0 ;
    c[0]=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      if(i==0){
        b[i+1]=a[i];
        c[i+1]=Math.max(a[i],0);
      }
      else {
        b[i+1]=b[i]+a[i];
        c[i+1]=c[i]+Math.max(a[i],0);
      }
    }
    c[n+1]=c[n];
    long sum,ans=0 ;
    for(int i=k ; i<=n ; i++){
      sum=c[i-k];
      sum+=c[n+1]-c[i];
      ans=Math.max(ans,sum);
      sum+=b[i]-b[i-k];
      ans=Math.max(ans,sum);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,n + 1)->collect(0) ;
    var c : Sequence(long) ; c := Integer.subrange(1,n + 2)->collect(0) ;
    b[0+1] := 0 ; 
    c[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (i = 0) then (     b[i + 1+1] := a[i+1] ; 
     c[i + 1+1] := Set{a[i+1], 0}->max() ) else (     b[i + 1+1] := b[i+1] + a[i+1] ; 
     c[i + 1+1] := c[i+1] + Set{a[i+1], 0}->max() ) )  ;     i := i + 1 ) ; 
    c[n + 1+1] := c[n+1] ; 
    var sum : long ;
    var ans : long ; ans := 0 ;
        var i : int ; i := k ; while i <= n do ( (     sum := c[i - k+1] ; 
     sum := sum+(c[n + 1+1] - c[i+1]) ; 
    ans := Set{ans, sum}->max() ; 
    sum := sum+(b[i+1] - b[i - k+1]) ; 
    ans := Set{ans, sum}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int n=6,m=6 ;
  static void maxSum(long arr[][]){
    long[][] dp=new long[n+1][3];
    for(int i=0 ; i<n ; i++){
      long m1=0,m2=0,m3=0 ;
      for(int j=0 ; j<m ; j++){
        if((j/(m/3))==0){
          m1=Math.max(m1,arr[i][j]);
        }
        else if((j/(m/3))==1){
          m2=Math.max(m2,arr[i][j]);
        }
        else if((j/(m/3))==2){
          m3=Math.max(m3,arr[i][j]);
        }
      }
      dp[i+1][0]=Math.max(dp[i][1],dp[i][2])+m1 ;
      dp[i+1][1]=Math.max(dp[i][0],dp[i][2])+m2 ;
      dp[i+1][2]=Math.max(dp[i][1],dp[i][0])+m3 ;
    }
    System.out.print(Math.max(Math.max(dp[n][0],dp[n][1]),dp[n][2])+"\n");
  }
  public static void main(String[] args){
    long arr[][]={
      {
        1,3,5,2,4,6 },{
          6,4,5,1,3,2 },{
            1,3,5,2,4,6 },{
              6,4,5,1,3,2 },{
                6,4,5,1,3,2 },{
                  1,3,5,2,4,6 }
                };
                maxSum(arr);
              }
            }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute n : int := 6;
  static   operation maxSum( arr : Sequence(Sequence(long))) : void
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,3)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do ( (     var m1 : long ; m1 := 0 ;
    var m2 : long ; m2 := 0 ;
    var m3 : long ; m3 := 0 ;
         var j : int ; j := 0 ; while j < m do ( (     if ((j / (m / 3)) = 0) then (     m1 := Set{m1, arr[i+1][j+1]}->max() ) else     if ((j / (m / 3)) = 1) then (     m2 := Set{m2, arr[i+1][j+1]}->max() ) else     if ((j / (m / 3)) = 2) then (     m3 := Set{m3, arr[i+1][j+1]}->max() ) else skip ; ;  )  ;     j := j + 1 ) ; 
    dp[i + 1+1][0+1] := Set{dp[i+1][1+1], dp[i+1][2+1]}->max() + m1 ; 
    dp[i + 1+1][1+1] := Set{dp[i+1][0+1], dp[i+1][2+1]}->max() + m2 ; 
    dp[i + 1+1][2+1] := Set{dp[i+1][1+1], dp[i+1][0+1]}->max() + m3 ; 
 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(Set{Set{dp[n+1][0+1], dp[n+1][1+1]}->max(), dp[n+1][2+1]}->max() + "\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Sequence(long)) ; arr := Sequence{Sequence{1,3,5,2,4,6},Sequence{6,4,5,1,3,2},Sequence{1,3,5,2,4,6},Sequence{6,4,5,1,3,2},Sequence{6,4,5,1,3,2},Sequence{1,3,5,2,4,6}} ;
     execute maxSum(arr) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] $){
    int n=scanner.nextInt();
    int k=scanner.nextInt();
    long[] b=new long[n+1];
    long[] w=new long[n+1];
    for(int i=1 ; i<=n ; i++){
      int a=scanner.nextInt();
      if(a<0){
        b[i]=-a ;
      }
      else {
        w[i]=a ;
      }
    }
    Arrays.parallelPrefix(b,Long :: sum);
    Arrays.parallelPrefix(w,Long :: sum);
    long m=Long.MAX_VALUE ;
    for(int i=k ; i<=n ; i++){
      m=Math.min(m,Math.min(b[i]-b[i-k],w[i]-w[i-k]));
    }
    System.out.println(w[n]-m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var k : int ; k := scanner.getCurrent()->toInteger() ;
    var b : Sequence(long) ; b := Integer.subrange(1,n + 1)->collect(0) ;
    var w : Sequence(long) ; w := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     if (a < 0) then (     b[i+1] := -a ) else (     w[i+1] := a ) )  ;     i := i + 1 ) ; 
parallelPrefix(b, lambda _pars : OclAny in Long.newLong().sum(_pars)) ; 
parallelPrefix(w, lambda _pars : OclAny in Long.newLong().sum(_pars)) ; 
    var m : long ; m := "9223372036854775807"->toLong() ;
        var i : int ; i := k ; while i <= n do ( (     m := Set{m, Set{b[i+1] - b[i - k+1], w[i+1] - w[i - k+1]}->min()}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(w[n+1] - m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    int[] a=new int[N];
    long black=0 ;
    long white=0 ;
    long tmp=0 ;
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextInt();
      if(i<K)black+=a[i];
      if(i>=K)tmp+=Math.max(0,a[i]);
    }
    long ans=Math.max(black,white);
    for(int i=K ; i<N ; i++){
      tmp-=Math.max(0,a[i]);
      tmp+=Math.max(0,a[i-K]);
      black+=a[i];
      black-=a[i-K];
      ans=Math.max(ans,tmp+black);
      ans=Math.max(ans,tmp+white);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var black : long ; black := 0 ;
    var white : long ; white := 0 ;
    var tmp : long ; tmp := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (i < K) then     black := black+(a[i+1]) ; else skip ; 
     if (i >= K) then     tmp := tmp+(Set{0, a[i+1]}->max()) ; else skip )  ;     i := i + 1 ) ; 
    var ans : long ; ans := Set{black, white}->max() ;
        var i : int ; i := K ; while i < N do ( (     tmp := tmp-(Set{0, a[i+1]}->max()) ; 
     tmp := tmp+(Set{0, a[i - K+1]}->max()) ; 
    black := black+(a[i+1]) ; 
    black := black-(a[i - K+1]) ; 
    ans := Set{ans, tmp + black}->max() ; 
    ans := Set{ans, tmp + white}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.run();
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    long sum[]=new long[200005];
    int p[]=new int[200005];
    long r[]=new long[1001];
    for(int i=1 ; i<=1000 ; i++){
      r[i]=r[i-1]+i ;
    }
    sum[0]=0 ;
    for(int i=0 ; i<n ; i++){
      p[i]=sc.nextInt();
      sum[i+1]=sum[i]+p[i];
    }
    long max=0 ;
    int maxi=0 ;
    for(int i=0 ; i<n-k+1 ; i++){
      long tmp=sum[i+k]-sum[i];
      if(max<tmp){
        max=tmp ;
        maxi=i ;
      }
    }
    double e=0 ;
    for(int i=0 ; i<k ; i++){
      e+=(double)r[p[i+maxi] ]/(double)p[i+maxi];
    }
    System.out.println(e);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var sum : Sequence(long) ; sum := Integer.subrange(1,200005)->collect(0) ;
    var p : Sequence(int) ; p := Integer.subrange(1,200005)->collect(0) ;
    var r : Sequence(long) ; r := Integer.subrange(1,1001)->collect(0) ;
        var i : int ; i := 1 ; while i <= 1000 do ( (     r[i+1] := r[i - 1+1] + i )  ;     i := i + 1 ) ; 
    sum[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := sc.getCurrent()->toInteger() ; 
     sum[i + 1+1] := sum[i+1] + p[i+1] )  ;     i := i + 1 ) ; 
    var max : long ; max := 0 ;
    var maxi : int ; maxi := 0 ;
        var i : int ; i := 0 ; while i < n - k + 1 do ( (     var tmp : long ; tmp := sum[i + k+1] - sum[i+1] ;
     if (max < tmp) then (     max := tmp ; 
     maxi := i ) else skip )  ;     i := i + 1 ) ; 
    var e : double ; e := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     e := e+(r[p[i + maxi+1]+1]->oclAsType(double) / p[i + maxi+1]->oclAsType(double)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(e) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getMissingNo(int a[],int n){
    int total=1 ;
    for(int i=2 ; i<=(n+1); i++){
      total+=i ;
      total-=a[i-2];
    }
    return total ;
  }
  public static void main(String[] args){
    int[] arr={
      1,2,3,5 };
      System.out.println(getMissingNo(arr,arr.length));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getMissingNo( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var total : int ; total := 1 ;
         var i : int ; i := 2 ; while i <= (n + 1) do ( (     total := total+(i) ; 
     total := total-(a[i - 2+1]) )  ;     i := i + 1 ) ; 
     return total );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,5} ;
     OclFile["System.out"].println(getMissingNo(arr, arr->size())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MaximumDivisors(int X,int Y){
    int[] arr=new int[Y-X+1];
    for(int i=0 ; i<arr.length ; i++)arr[i]=0 ;
    int mx=0 ;
    int cnt=0 ;
    for(int i=1 ; i*i<=Y ; i++){
      int sq=i*i ;
      int first_divisible ;
      if((X/i)*i>=X)first_divisible=(X/i)*i ;
      else first_divisible=(X/i+1)*i ;
      for(int j=first_divisible ; j<=Y ; j+=i){
        if(j<sq)continue ;
        else if(j==sq)arr[j-X]++;
        else arr[j-X]+=2 ;
      }
    }
    for(int i=X ; i<=Y ; i++){
      if(arr[i-X]>mx){
        cnt=1 ;
        mx=arr[i-X];
      }
      else if(arr[i-X]==mx)cnt++;
    }
    return cnt ;
  }
  public static void main(String[] args){
    int X=1,Y=10 ;
    System.out.println(MaximumDivisors(X,Y));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation MaximumDivisors( X : int, Y : int) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,Y - X + 1)->collect(0) ;
         var i : int ; i := 0 ; while i < arr->size() do (     arr[i+1] := 0 ;  ;     i := i + 1 ) ; 
    var mx : int ; mx := 0 ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 1 ; while i * i <= Y do ( (     var sq : int ; sq := i * i ;
     var first_divisible : int ;
     if ((X / i) * i >= X) then     first_divisible := (X / i) * i else     first_divisible := (X / i + 1) * i ; ;  
         var j : int ; j := first_divisible ; while j <= Y do ( (     if (j < sq) then     continue else     if (j = sq) then     arr[j - X+1] := arr[j - X+1] + 1 else     arr[j - X+1] := arr[j - X+1]+(2) ; ;  )  ;     j := j+(i) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := X ; while i <= Y do ( (     if (arr[i - X+1] > mx) then (     cnt := 1 ; 
     mx := arr[i - X+1] ) else     if (arr[i - X+1] = mx) then     cnt := cnt + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 1 ;
    var Y : int ; Y := 10 ;
     OclFile["System.out"].println(MaximumDivisors(X, Y)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int find_sub(String s,int k){
    int len=s.length();
    int lp=0,rp=0 ;
    int ans=0 ;
    int[] hash_char=new int[26];
    for(; rp<len ; rp++){
      hash_char[s.charAt(rp)-'a']++;
      while(hash_char[s.charAt(rp)-'a']>k){
        hash_char[s.charAt(lp)-'a']--;
        lp++;
      }
      ans+=rp-lp+1 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    String S="aaabb" ;
    int k=2 ;
    System.out.println(find_sub(S,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find_sub( s : String, k : int) : int
  pre: true
  post: true
  activity: (     var len : int ; len := s->size() ;
     var lp : int ; lp := 0 ;
    var rp : int ; rp := 0 ;
    var ans : int ; ans := 0 ;
    var hash_char : Sequence(int) ; hash_char := Integer.subrange(1,26)->collect(0) ;
      while rp < len do ( (     hash_char[s->at(rp+1) - ('a')->char2byte()+1] := hash_char[s->at(rp+1) - ('a')->char2byte()+1] + 1 ; 
     while (hash_char[s->at(rp+1) - ('a')->char2byte()+1] > k) do (     hash_char[s->at(lp+1) - ('a')->char2byte()+1] := hash_char[s->at(lp+1) - ('a')->char2byte()+1] - 1 ; 
     lp := lp + 1 ) ; 
     ans := ans+(rp - lp + 1) )  ;     rp := rp + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := "aaabb" ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(find_sub(S, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean check(int p,int n){
    int temp=p,count=0,f=5 ;
    while(f<=temp){
      count+=temp/f ;
      f=f*5 ;
    }
    return(count>=n);
  }
  static int findNum(int n){
    if(n==1)return 5 ;
    int low=0 ;
    int high=5*n ;
    while(low<high){
      int mid=(low+high)>>1 ;
      if(check(mid,n))high=mid ;
      else low=mid+1 ;
    }
    return low ;
  }
  public static void main(String[] args){
    int n=6 ;
    System.out.println(findNum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation check( p : int, n : int) : boolean
  pre: true
  post: true
  activity: (     var temp : int ; temp := p ;
    var count : int ; count := 0 ;
    var f : int ; f := 5 ;
     while (f <= temp) do (     count := count+(temp / f) ; 
     f := f * 5 ) ; 
     return (count >= n) );
  static   operation findNum( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 5 else skip ; 
     var low : int ; low := 0 ;
    var high : int ; high := 5 * n ;
    while (low < high) do (     var mid : int ; mid := ((low + high)/(2->pow(1)))->oclAsType(long) ;
     if (check(mid, n)) then     high := mid ; else     low := mid + 1 ; ) ; 
    return low 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(findNum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int firstEven(int arr[],int n){
    HashMap<Integer,Boolean>map=new HashMap<Integer,Boolean>();
    for(int i=0 ; i<n ; i++){
      if(map.get(arr[i])==null)map.put(arr[i],false);
      else {
        boolean val=map.get(arr[i]);
        if(val==true)map.put(arr[i],false);
        else map.put(arr[i],true);
      }
    }
    int j=0 ;
    for(j=0 ; j<n ; j++){
      if(map.get(arr[j])==true)break ;
    }
    return arr[j];
  }
  public static void main(String[] args){
    int arr[]={
      2,4,6,8,1,6 };
      int n=arr.length ;
      System.out.println(firstEven(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation firstEven( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var map : Map(int,Boolean) ; map := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (map->at(arr[i+1]) = null) then     map := map->union(Map{arr[i+1] |-> false}) ; else (     var val : boolean ; val := map->at(arr[i+1]) ;
     if (val = true) then     map := map->union(Map{arr[i+1] |-> false}) ; else     map := map->union(Map{arr[i+1] |-> true}) ; ) )  ;     i := i + 1 ) ; 
    var j : int ; j := 0 ;
        j := 0 ; while j < n do ( (     if (map->at(arr[j+1]) = true) then     break else skip )  ;     j := j + 1 ) ; 
    return arr[j+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,6,8,1,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(firstEven(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
class Test {
  static void printUnion(int arr1[],int arr2[]){
    HashSet<Integer>hs=new HashSet<>();
    for(int i=0 ; i<arr1.length ; i++)hs.add(arr1[i]);
    for(int i=0 ; i<arr2.length ; i++)hs.add(arr2[i]);
    System.out.println(hs);
  }
  static void printIntersection(int arr1[],int arr2[]){
    HashSet<Integer>hs=new HashSet<>();
    HashSet<Integer>hs1=new HashSet<>();
    for(int i=0 ; i<arr1.length ; i++)hs.add(arr1[i]);
    for(int i=0 ; i<arr2.length ; i++)if(hs.contains(arr2[i]))System.out.print(arr2[i]+" ");
  }
  public static void main(String[] args){
    int arr1[]={
      7,1,5,2,3,6 };
      int arr2[]={
        3,8,6,20,7 };
        System.out.println("Union of two arrays is : ");
        printUnion(arr1,arr2);
        System.out.println("Intersection of two arrays is : ");
        printIntersection(arr1,arr2);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation printUnion( arr1 : Sequence(int), arr2 : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var hs : Set(int) ; hs := Set{} ;
         var i : int ; i := 0 ; while i < arr1->size() do (     hs := hs->including(arr1[i+1]) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < arr2->size() do (     hs := hs->including(arr2[i+1]) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(hs) );
  static   operation printIntersection( arr1 : Sequence(int), arr2 : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var hs : Set(int) ; hs := Set{} ;
     var hs1 : Set(int) ; hs1 := Set{} ;
         var i : int ; i := 0 ; while i < arr1->size() do (     hs := hs->including(arr1[i+1]) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < arr2->size() do (     if (hs->includes(arr2[i+1])) then     OclFile["System.out"].print(arr2[i+1] + " ") ; else skip ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{7,1,5,2,3,6} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{3,8,6,20,7} ;
    OclFile["System.out"].println("Union of two arrays is : ") ; 
    execute printUnion(arr1, arr2) ; 
    OclFile["System.out"].println("Intersection of two arrays is : ") ; 
    execute printIntersection(arr1, arr2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void FindPoints(int x1,int y1,int x2,int y2,int x3,int y3,int x4,int y4){
    int x5=Math.max(x1,x3);
    int y5=Math.max(y1,y3);
    int x6=Math.min(x2,x4);
    int y6=Math.min(y2,y4);
    if(x5>x6 || y5>y6){
      System.out.println("No intersection");
      return ;
    }
    System.out.print("("+x5+","+y5+")");
    System.out.print("("+x6+","+y6+")");
    int x7=x5 ;
    int y7=y6 ;
    System.out.print("("+x7+","+y7+")");
    int x8=x6 ;
    int y8=y5 ;
    System.out.print("("+x8+","+y8+")");
  }
  public static void main(String args[]){
    int x1=0,y1=0,x2=10,y2=8 ;
    int x3=2,y3=3,x4=7,y4=9 ;
    FindPoints(x1,y1,x2,y2,x3,y3,x4,y4);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation FindPoints( x1 : int, y1 : int, x2 : int, y2 : int, x3 : int, y3 : int, x4 : int, y4 : int) : void
  pre: true
  post: true
  activity: (     var x5 : int ; x5 := Set{x1, x3}->max() ;
     var y5 : int ; y5 := Set{y1, y3}->max() ;
    var x6 : int ; x6 := Set{x2, x4}->min() ;
    var y6 : int ; y6 := Set{y2, y4}->min() ;
    if (x5 > x6 or y5 > y6) then (     OclFile["System.out"].println("No intersection") ; 
     return ) else skip ; 
    OclFile["System.out"].print("(" + x5 + "," + y5 + ")") ; 
    OclFile["System.out"].print("(" + x6 + "," + y6 + ")") ; 
    var x7 : int ; x7 := x5 ;
    var y7 : int ; y7 := y6 ;
    OclFile["System.out"].print("(" + x7 + "," + y7 + ")") ; 
    var x8 : int ; x8 := x6 ;
    var y8 : int ; y8 := y5 ;
    OclFile["System.out"].print("(" + x8 + "," + y8 + ")") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x1 : int ; x1 := 0 ;
    var y1 : int ; y1 := 0 ;
    var x2 : int ; x2 := 10 ;
    var y2 : int ; y2 := 8 ;
     var x3 : int ; x3 := 2 ;
    var y3 : int ; y3 := 3 ;
    var x4 : int ; x4 := 7 ;
    var y4 : int ; y4 := 9 ;
     execute FindPoints(x1, y1, x2, y2, x3, y3, x4, y4) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int binaryToDecimal(String n){
    String num=n ;
    int dec_value=0 ;
    int base=1 ;
    int len=num.length();
    for(int i=len-1 ; i>=0 ; i--){
      if(num.charAt(i)=='1')dec_value+=base ;
      base=base*2 ;
    }
    return dec_value ;
  }
  public static void main(String[] args){
    String num=new String("10101001");
    System.out.println(binaryToDecimal(num));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation binaryToDecimal( n : String) : int
  pre: true
  post: true
  activity: (     var num : String ; num := n ;
     var dec_value : int ; dec_value := 0 ;
    var base : int ; base := 1 ;
    var len : int ; len := num->size() ;
        var i : int ; i := len - 1 ; while i >= 0 do ( (     if (num->at(i+1) = '1') then     dec_value := dec_value+(base) ; else skip ; 
     base := base * 2 )  ;     i := i - 1 ) ; 
    return dec_value 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : String ; num := StringLib.newString("10101001") ;
     OclFile["System.out"].println(binaryToDecimal(num)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int a=scanner.nextInt();
    int b=scanner.nextInt();
    float ansA=(float)(a/0.08f);
    float ansB=(float)(b/0.1f);
    int aa=ansA % 1==0 ?(int)ansA :(int)ansA+1 ;
    int bb=ansB % 1==0 ?(int)ansB :(int)ansB+1 ;
    int c=Math.max(aa,bb);
    Boolean isOK=true ;
    if((int)(c*0.08f)!=a){
      isOK=false ;
    }
    if((int)(c*0.1f)!=b){
      isOK=false ;
    }
    int ans=isOK ? c :-1 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var ansA : double ; ansA := (a / 0.08f)->oclAsType(double) ;
    var ansB : double ; ansB := (b / 0.1f)->oclAsType(double) ;
    var aa : int ; aa := if ansA mod 1 = 0 then ansA->oclAsType(int) else ansA->oclAsType(int) + 1 endif ;
    var bb : int ; bb := if ansB mod 1 = 0 then ansB->oclAsType(int) else ansB->oclAsType(int) + 1 endif ;
    var c : int ; c := Set{aa, bb}->max() ;
    var isOK : Boolean ; isOK := true ;
    if ((c * 0.08f)->oclAsType(int) /= a) then (     isOK := false ) else skip ; 
    if ((c * 0.1f)->oclAsType(int) /= b) then (     isOK := false ) else skip ; 
    var ans : int ; ans := if isOK then c else -1 endif ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int A=scanner.nextInt();
    int B=scanner.nextInt();
    double rateA=.08 ;
    double rateB=.1 ;
    int potenialA=(int)(A/rateA);
    int potenialB=(int)(B/rateB);
    int smallestStart=0 ;
    if(potenialA<potenialB){
      smallestStart=potenialB ;
    }
    else {
      smallestStart=potenialA ;
    }
    int price=smallestStart ;
    boolean answerFound=false ;
    boolean possible=false ;
    while(answerFound==false){
      if((int)(price*rateA)==A &&(int)(price*rateB)==B){
        possible=true ;
        answerFound=true ;
        break ;
      }
      if((int)(price*rateA)>A ||(int)(price*rateB)>B){
        answerFound=true ;
        break ;
      }
      price++;
    }
    if(possible){
      System.out.println(price);
    }
    else {
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := scanner.getCurrent()->toInteger() ;
    var B : int ; B := scanner.getCurrent()->toInteger() ;
    var rateA : double ; rateA := .08 ;
    var rateB : double ; rateB := .1 ;
    var potenialA : int ; potenialA := (A / rateA)->oclAsType(int) ;
    var potenialB : int ; potenialB := (B / rateB)->oclAsType(int) ;
    var smallestStart : int ; smallestStart := 0 ;
    if (potenialA < potenialB) then (     smallestStart := potenialB ) else (     smallestStart := potenialA ) ;  
    var price : int ; price := smallestStart ;
    var answerFound : boolean ; answerFound := false ;
    var possible : boolean ; possible := false ;
    while (answerFound = false) do (     if ((price * rateA)->oclAsType(int) = A & (price * rateB)->oclAsType(int) = B) then (     possible := true ; 
     answerFound := true ; 
     break ) else skip ; 
     if ((price * rateA)->oclAsType(int) > A or (price * rateB)->oclAsType(int) > B) then (     answerFound := true ; 
     break ) else skip ; 
     price := price + 1 ) ; 
    if (possible) then (     OclFile["System.out"].println(price) ) else (     OclFile["System.out"].println(-1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class RotateArray {
  void leftRotate(int arr[],int d,int n){
    for(int i=0 ; i<d ; i++)leftRotatebyOne(arr,n);
  }
  void leftRotatebyOne(int arr[],int n){
    int i,temp ;
    temp=arr[0];
    for(i=0 ; i<n-1 ; i++)arr[i]=arr[i+1];
    arr[i]=temp ;
  }
  void printArray(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String[] args){
    RotateArray rotate=new RotateArray();
    int arr[]={
      1,2,3,4,5,6,7 };
      rotate.leftRotate(arr,2,7);
      rotate.printArray(arr,7);
    }
  }

------------------------------------------------------------
OCL File:
---------
class RotateArray {
   operation leftRotate( arr : Sequence(int), d : int, n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < d do (     execute leftRotatebyOne(arr, n) ;  ;     i := i + 1 ) );
   operation leftRotatebyOne( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var temp : int ;
     temp := arr[0+1] ; 
         i := 0 ; while i < n - 1 do (     arr[i+1] := arr[i + 1+1] ;  ;     i := i + 1 ) ; 
     arr[i+1] := temp );
   operation printArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var rotate : RotateArray ; rotate := RotateArray.newRotateArray() ;
     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6,7} ;
     rotate.leftRotate(arr, 2, 7) ; 
     rotate.printArray(arr, 7) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scan=new Scanner(System.in)){
      int A=scan.nextInt();
      int B=scan.nextInt();
      int[] s=new int[2000];
      int ase=(double)((A*25)/2)==(A*25.0)/2.0 ?(A*25)/2 :(A*25)/2+1 ;
      int ako=(double)(((A+1)*25)/2)==((A+1)*25.0)/2.0 ?((A+1)*25)/2-1 :((A+1)*25)/2 ;
      int bse=B*10 ;
      int bko=B*10+9 ;
      for(int i=ase-1 ; i<ako ; i++){
        s[i]++;
      }
      for(int i=bse-1 ; i<bko ; i++){
        s[i]++;
      }
      int ok=0 ;
      for(int i=0 ; i<2000 ; i++){
        if(s[i]==2){
          ok=1 ;
          System.out.println(i+1);
          break ;
        }
      }
      if(ok==0)System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var A : int ; A := scan.getCurrent()->toInteger() ;
     var B : int ; B := scan.getCurrent()->toInteger() ;
    var s : Sequence(int) ; s := Integer.subrange(1,2000)->collect(0) ;
    var ase : int ; ase := if ((A * 25) / 2)->oclAsType(double) = (A * 25.0) / 2.0 then (A * 25) / 2 else (A * 25) / 2 + 1 endif ;
    var ako : int ; ako := if (((A + 1) * 25) / 2)->oclAsType(double) = ((A + 1) * 25.0) / 2.0 then ((A + 1) * 25) / 2 - 1 else ((A + 1) * 25) / 2 endif ;
    var bse : int ; bse := B * 10 ;
    var bko : int ; bko := B * 10 + 9 ;
        var i : int ; i := ase - 1 ; while i < ako do ( (     s[i+1] := s[i+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := bse - 1 ; while i < bko do ( (     s[i+1] := s[i+1] + 1 )  ;     i := i + 1 ) ; 
    var ok : int ; ok := 0 ;
        var i : int ; i := 0 ; while i < 2000 do ( (     if (s[i+1] = 2) then (     ok := 1 ; 
     OclFile["System.out"].println(i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (ok = 0) then     OclFile["System.out"].println(-1) ; else skip ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    for(double price=0 ; price<200000 ; price++){
      int tax8=(int)(price*0.08);
      int tax10=(int)(price*0.1);
      if((tax8==a)&&(tax10==b)){
        System.out.println((int)price);
        System.exit(0);
      }
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
        var price : double ; price := 0 ; while price < 200000 do ( (     var tax8 : int ; tax8 := (price * 0.08)->oclAsType(int) ;
     var tax10 : int ; tax10 := (price * 0.1)->oclAsType(int) ;
     if ((tax8 = a) & (tax10 = b)) then (     OclFile["System.out"].println(price->oclAsType(int)) ; 
 OclProcess.exit(0) ) else skip )  ;     price := price + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int a=stdIn.nextInt();
    int b=stdIn.nextInt();
    double c=a/0.08 ;
    double cc=(a+1)/0.08 ;
    double d=b/0.1 ;
    double dd=(b+1)/0.1 ;
    boolean flag=true ;
    Outer : for(int i=(int)Math.ceil(c);
    i<cc ;
    i++){
      for(int j=(int)Math.ceil(d); j<dd ; j++){
        if(i==j){
          System.out.println(i);
          flag=false ;
          break Outer ;
        }
      }
    }
    if(flag){
      System.out.println("-1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := stdIn.getCurrent()->toInteger() ;
    var b : int ; b := stdIn.getCurrent()->toInteger() ;
    var c : double ; c := a / 0.08 ;
    var cc : double ; cc := (a + 1) / 0.08 ;
    var d : double ; d := b / 0.1 ;
    var dd : double ; dd := (b + 1) / 0.1 ;
    var flag : boolean ; flag := true ;
        var i : int ; i := (c)->ceil()->oclAsType(int) ; while i < cc do ( (         var j : int ; j := (d)->ceil()->oclAsType(int) ; while j < dd do ( (     if (i = j) then (     OclFile["System.out"].println(i) ; 
     flag := false ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (flag) then (     OclFile["System.out"].println("-1") ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findExtra(int arr1[],int arr2[],int n){
    for(int i=0 ; i<n ; i++)if(arr1[i]!=arr2[i])return i ;
    return n ;
  }
  public static void main(String[] args){
    int arr1[]={
      2,4,6,8,10,12,13 };
      int arr2[]={
        2,4,6,8,10,12 };
        int n=arr2.length ;
        System.out.println(findExtra(arr1,arr2,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findExtra( arr1 : Sequence(int), arr2 : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     if (arr1[i+1] /= arr2[i+1]) then     return i else skip ;  ;     i := i + 1 ) ; 
     return n );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{2,4,6,8,10,12,13} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{2,4,6,8,10,12} ;
     var n : int ; n := arr2->size() ;
     OclFile["System.out"].println(findExtra(arr1, arr2, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int height ;
  static int search(int arr[],int strt,int end,int value){
    for(int i=strt ; i<=end ; i++)if(arr[i]==value)return i ;
    return-1 ;
  }
  static int getHeight(int in[],int level[],int start,int end,int n){
    if(start>end)return 0 ;
    int getIndex=search(in,start,end,level[0]);
    if(getIndex==-1)return 0 ;
    int leftCount=getIndex-start ;
    int rightCount=end-getIndex ;
    int[] newLeftLevel=new int[leftCount];
    int[] newRightLevel=new int[rightCount];
    int lheight=0,rheight=0 ;
    int k=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=start ; j<getIndex ; j++){
        if(level[i]==in[j]){
          newLeftLevel[k]=level[i];
          k++;
          break ;
        }
      }
    }
    k=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=getIndex+1 ; j<=end ; j++){
        if(level[i]==in[j]){
          newRightLevel[k]=level[i];
          k++;
          break ;
        }
      }
    }
    if(leftCount>0)lheight=getHeight(in,newLeftLevel,start,getIndex-1,leftCount);
    if(rightCount>0)rheight=getHeight(in,newRightLevel,getIndex+1,end,rightCount);
    height=Math.max(lheight+1,rheight+1);
    newRightLevel=null ;
    newLeftLevel=null ;
    return height ;
  }
  public static void main(String[] args){
    int in[]={
      4,8,10,12,14,20,22 };
      int level[]={
        20,8,22,4,12,10,14 };
        int n=in.length ;
        height=0 ;
        System.out.println(getHeight(in,level,0,n-1,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute height : int;
  static   operation search( arr : Sequence(int), strt : int, end : int, value : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := strt ; while i <= end do (     if (arr[i+1] = value) then     return i else skip ;  ;     i := i + 1 ) ; 
     return -1 );
  static   operation getHeight( in : Sequence(int), level : Sequence(int), start : int, end : int, n : int) : int
  pre: true
  post: true
  activity: (     if (start > end) then     return 0 else skip ; 
     var getIndex : int ; getIndex := search(in, start, end, level[0+1]) ;
    if (getIndex = -1) then     return 0 else skip ; 
    var leftCount : int ; leftCount := getIndex - start ;
    var rightCount : int ; rightCount := end - getIndex ;
    var newLeftLevel : Sequence(int) ; newLeftLevel := Integer.subrange(1,leftCount)->collect(0) ;
    var newRightLevel : Sequence(int) ; newRightLevel := Integer.subrange(1,rightCount)->collect(0) ;
    var lheight : int ; lheight := 0 ;
    var rheight : int ; rheight := 0 ;
    var k : int ; k := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := start ; while j < getIndex do ( (     if (level[i+1] = in[j+1]) then (     newLeftLevel[k+1] := level[i+1] ; 
     k := k + 1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    k := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := getIndex + 1 ; while j <= end do ( (     if (level[i+1] = in[j+1]) then (     newRightLevel[k+1] := level[i+1] ; 
     k := k + 1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (leftCount > 0) then     lheight := getHeight(in, newLeftLevel, start, getIndex - 1, leftCount) ; else skip ; 
    if (rightCount > 0) then     rheight := getHeight(in, newRightLevel, getIndex + 1, end, rightCount) ; else skip ; 
    height := Set{lheight + 1, rheight + 1}->max() ; 
    newRightLevel := null ; 
    newLeftLevel := null ; 
    return height 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : Sequence(int) ; in := Sequence{4,8,10,12,14,20,22} ;
     var level : Sequence(int) ; level := Sequence{20,8,22,4,12,10,14} ;
    var n : int ; n := in->size() ;
    height := 0 ; 
    OclFile["System.out"].println(getHeight(in, level, 0, n - 1, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
public class RaceAgainstTime {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    String[] temp=br.readLine().split(" ");
    int h=Integer.parseInt(temp[0]);
    int m=Integer.parseInt(temp[1]);
    int s=Integer.parseInt(temp[2]);
    int t1=Integer.parseInt(temp[3]);
    int t2=Integer.parseInt(temp[4]);
    int hDegree=h==12 ? 0 : h*30 ;
    int mDegree=m*6 ;
    int sDegree=s*6 ;
    int t1Degree=t1==12 ? 0 : t1*30 ;
    int t2Degree=t2==12 ? 0 : t2*30 ;
    List<Integer>list=new ArrayList<>();
    Collections.addAll(list,hDegree,mDegree,sDegree);
    Collections.sort(list);
    int flag1=3 ;
    int flag2=3 ;
    if(t1Degree>list.get(0)&& t1Degree<=list.get(1)){
      flag1=1 ;
    }
    else if(t1Degree>list.get(1)&& t1Degree<=list.get(2)){
      flag1=2 ;
    }
    if(t2Degree>list.get(0)&& t2Degree<=list.get(1)){
      flag2=1 ;
    }
    else if(t2Degree>list.get(1)&& t2Degree<=list.get(2)){
      flag2=2 ;
    }
    pr.println(flag1==flag2 ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class RaceAgainstTime {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
     var h : int ; h := (temp[0+1])->toInteger() ;
    var m : int ; m := (temp[1+1])->toInteger() ;
    var s : int ; s := (temp[2+1])->toInteger() ;
    var t1 : int ; t1 := (temp[3+1])->toInteger() ;
    var t2 : int ; t2 := (temp[4+1])->toInteger() ;
    var hDegree : int ; hDegree := if h = 12 then 0 else h * 30 endif ;
    var mDegree : int ; mDegree := m * 6 ;
    var sDegree : int ; sDegree := s * 6 ;
    var t1Degree : int ; t1Degree := if t1 = 12 then 0 else t1 * 30 endif ;
    var t2Degree : int ; t2Degree := if t2 = 12 then 0 else t2 * 30 endif ;
    var list : Sequence(int) ; list := Sequence{} ;
addAll(list, hDegree, mDegree, sDegree) ; 
    list := list->sort() ; 
    var flag1 : int ; flag1 := 3 ;
    var flag2 : int ; flag2 := 3 ;
    if (t1Degree > list->at(0+1) & t1Degree <= list->at(1+1)) then (     flag1 := 1 ) else     if (t1Degree > list->at(1+1) & t1Degree <= list->at(2+1)) then (     flag1 := 2 ) else skip ; ;  
    if (t2Degree > list->at(0+1) & t2Degree <= list->at(1+1)) then (     flag2 := 1 ) else     if (t2Degree > list->at(1+1) & t2Degree <= list->at(2+1)) then (     flag2 := 2 ) else skip ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _424A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    sc.nextLine();
    String s=sc.nextLine();
    int sittingToStanding=0 ;
    int sitting=0,standing=0 ;
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='x'){
        sitting++;
      }
      else {
        standing++;
      }
    }
    sittingToStanding=(sitting-standing)/2 ;
    System.out.println(Math.abs(sittingToStanding));
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='x' && sittingToStanding>0){
        System.out.print('X');
        sittingToStanding--;
      }
      else if(s.charAt(i)=='X' && sittingToStanding<0){
        System.out.print('x');
        sittingToStanding++;
      }
      else {
        System.out.print(s.charAt(i));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _424A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    skip ; 
    var s : String ; s := sc.nextLine() ;
    var sittingToStanding : int ; sittingToStanding := 0 ;
    var sitting : int ; sitting := 0 ;
    var standing : int ; standing := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = 'x') then (     sitting := sitting + 1 ) else (     standing := standing + 1 ) )  ;     i := i + 1 ) ; 
    sittingToStanding := (sitting - standing) / 2 ; 
    OclFile["System.out"].println(if sittingToStanding < 0 then -(sittingToStanding) else sittingToStanding endif) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = 'x' & sittingToStanding > 0) then (     OclFile["System.out"].print('X') ; 
     sittingToStanding := sittingToStanding - 1 ) else     if (s->at(i+1) = 'X' & sittingToStanding < 0) then (     OclFile["System.out"].print('x') ; 
     sittingToStanding := sittingToStanding + 1 ) else (     OclFile["System.out"].print(s->at(i+1)) ) ;  )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static long subarrayXor(int arr[],int n,int m){
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      int xorSum=0 ;
      for(int j=i ; j<n ; j++){
        xorSum=xorSum ^ arr[j];
        if(xorSum==m)ans++;
      }
    }
    return ans ;
  }
  public static void main(String args[]){
    int[] arr={
      4,2,2,6,4 };
      int n=arr.length ;
      int m=6 ;
      System.out.println("Number of subarrays"+" having given XOR is "+subarrayXor(arr,n,m));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation subarrayXor( arr : Sequence(int), n : int, m : int) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var xorSum : int ; xorSum := 0 ;
         var j : int ; j := i ; while j < n do ( (     xorSum := MathLib.bitwiseXor(xorSum,arr[j+1]) ; 
     if (xorSum = m) then     ans := ans + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,2,2,6,4} ;
     var n : int ; n := arr->size() ;
     var m : int ; m := 6 ;
     OclFile["System.out"].println("Number of subarrays" + " having given XOR is " + subarrayXor(arr, n, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in))){
      int[] array=readIntArray(reader);
      int N=array[0];
      int K=array[1];
      int c=(N-1)*(N-2)/2-K ;
      if(c<0){
        System.out.println("-1");
        return ;
      }
      StringBuilder sb=new StringBuilder();
      for(int i=2 ; i<=N ; i++){
        sb.append("1 ").append(i).append("\n");
      }
      for(int i=2 ; i<=N ; i++){
        for(int j=i+1 ; j<=N ; j++){
          if(c==0){
            break ;
          }
          sb.append(i).append(" ").append(j).append("\n");
          c--;
        }
        if(c==0){
          break ;
        }
      }
      System.out.println(N-1+(N-1)*(N-2)/2-K);
      System.out.print(sb.toString());
    }
  }
  public static int[] readIntArray(BufferedReader reader)throws Exception {
    String[] str=reader.readLine().split(" ");
    int[] array=new int[str.length];
    for(int i=0 ; i<str.length ; i++){
      array[i]=Integer.parseInt(str[i]);
    }
    return array ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var array : Sequence(int) ; array := readIntArray(reader) ;
     var N : int ; N := array[0+1] ;
    var K : int ; K := array[1+1] ;
    var c : int ; c := (N - 1) * (N - 2) / 2 - K ;
    if (c < 0) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 2 ; while i <= N do ( (     sb := sb + StringLib.newString("1 ") + StringLib.newString(i) + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= N do ( (         var j : int ; j := i + 1 ; while j <= N do ( (     if (c = 0) then (     break ) else skip ; 
     sb := sb + StringLib.newString(i) + StringLib.newString(" ") + StringLib.newString(j) + StringLib.newString("\n") ; 
     c := c - 1 )  ;     j := j + 1 ) ; 
     if (c = 0) then (     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(N - 1 + (N - 1) * (N - 2) / 2 - K) ; 
    OclFile["System.out"].print(sb+"") ; 
 ))  );
  static   operation readIntArray( reader : OclFile) : Sequence(int)
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := reader.readLine()->split(" ") ;
     var array : Sequence(int) ; array := Integer.subrange(1,str->size())->collect(0) ;
         var i : int ; i := 0 ; while i < str->size() do ( (     array[i+1] := (str[i+1])->toInteger() )  ;     i := i + 1 ) ; 
     return array );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.PrintWriter ;
public class Main {
  private static int N ;
  private static int K ;
  private static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args){
    load();
    solve();
    pw.flush();
  }
  private static void load(){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    K=sc.nextInt();
  }
  private static void solve(){
    if(K>(N-1)*(N-2)/2){
      pw.println(-1);
      return ;
    }
    int cnt=N-1+(N-1)*(N-2)/2-K ;
    pw.println(cnt);
    for(int v=1 ; v<=N ; v+=1){
      for(int w=v+1 ; w<=N ; w+=1){
        pw.println(String.format("%d %d",v,w));
        cnt-=1 ;
        if(cnt==0){
          return ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute K : int;
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute load() ; 
     execute solve() ; 
     skip );
  static   operation load() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
     K := sc.getCurrent()->toInteger() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     if (K > (N - 1) * (N - 2) / 2) then (     skip ; 
     return ) else skip ; 
     var cnt : int ; cnt := N - 1 + (N - 1) * (N - 2) / 2 - K ;
     skip ; 
         var v : int ; v := 1 ; while v <= N do ( (         var w : int ; w := v + 1 ; while w <= N do ( (     skip ; 
     cnt := cnt-(1) ; 
     if (cnt = 0) then (     return ) else skip )  ;     w := w+(1) ) )  ;     v := v+(1) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int n=in.nextInt();
    int k=in.nextInt();
    solve(n,k);
    in.close();
  }
  private static void solve(int n,int k){
    int x=(n-1)*(n-2)/2 ;
    if(k>x){
      System.out.println(-1);
      return ;
    }
    System.out.println(n-1+x-k);
    for(int i=2 ; i<=n ; i++)System.out.println(1+" "+i);
    for(int i=2 ; i<n ; i++)for(int j=i+1 ; j<=n ; j++){
      if(k==x)return ;
      x--;
      System.out.println(i+" "+j);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    execute solve(n, k) ; 
    skip ; 
 );
  static   operation solve( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var x : int ; x := (n - 1) * (n - 2) / 2 ;
     if (k > x) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    OclFile["System.out"].println(n - 1 + x - k) ; 
        var i : int ; i := 2 ; while i <= n do (     OclFile["System.out"].println(1 + " " + i) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i < n do (         var j : int ; j := i + 1 ; while j <= n do ( (     if (k = x) then     return else skip ; 
     x := x - 1 ; 
     OclFile["System.out"].println(i + " " + j) )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.ArrayDeque ;
import java.util.Deque ;
public class Main {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static StreamTokenizer st=new StreamTokenizer(br);
  static PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws Exception {
    while(st.nextToken()!=StreamTokenizer.TT_EOF){
      int n=(int)st.nval ;
      int[] arr=new int[n];
      int ans=Integer.MIN_VALUE ;
      for(int i=0 ; i<n ; i++){
        arr[i]=nextInt();
      }
      Deque<Integer>queue=new ArrayDeque<>();
      for(int i=0 ; i<n ; i++){
        while(! queue.isEmpty()&& arr[i]>arr[queue.peekFirst()]){
          int pre=queue.pollFirst();
          ans=Math.max(ans,arr[i] ^ arr[pre]);
        }
        if(! queue.isEmpty())ans=Math.max(ans,arr[i] ^ arr[queue.peekFirst()]);
        queue.offerFirst(i);
      }
      pw.println(ans);
      pw.flush();
    }
    closeAll();
  }
  public static int nextInt()throws IOException {
    st.nextToken();
    return(int)st.nval ;
  }
  public static double nextDouble()throws IOException {
    st.nextToken();
    return st.nval ;
  }
  public static long nextLong()throws Exception {
    st.nextToken();
    return(long)st.nval ;
  }
  public static String nextStr()throws Exception {
    st.nextToken();
    return st.sval ;
  }
  public static void closeAll()throws Exception {
    pw.close();
    br.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute st : StreamTokenizer := StreamTokenizer.newStreamTokenizer(br);
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (st.next() /= StreamTokenizer.TT_EOF) do (     var n : int ; n := st.nval->oclAsType(int) ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var ans : int ; ans := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := nextInt() )  ;     i := i + 1 ) ; 
    var queue : Sequence(int) ; queue := ArrayDeque<OclAny>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < n do ( (     while (not(queue->isEmpty()) & arr[i+1] > arr[queue.peekFirst()+1]) do (     var pre : int ; pre := queue->first() ;
     ans := Set{ans, arr[i+1] xor arr[pre+1]}->max() ) ; 
     if (not(queue->isEmpty())) then     ans := Set{ans, arr[i+1] xor arr[queue.peekFirst()+1]}->max() ; else skip ; 
     queue := queue->prepend(i) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 ) ; 
     execute closeAll() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     st.next() ; 
     return st.nval->oclAsType(int) );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     st.next() ; 
     return st.nval );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     st.next() ; 
     return st.nval->oclAsType(long) );
  static   operation nextStr() : String
  pre: true
  post: true
  activity: (     st.next() ; 
     return st.sval );
  static   operation closeAll() : void
  pre: true
  post: true
  activity: (     skip ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int nMinus1C2=1 ;
    for(int i=n-1 ; i>=n-2 ; i--){
      nMinus1C2*=i ;
    }
    nMinus1C2/=2 ;
    if(k>nMinus1C2){
      System.out.println(-1);
      return ;
    }
    int m=(n-1)+(nMinus1C2-k);
    System.out.println(m);
    for(int i=1 ; i<n ; i++){
      System.out.println("1 "+(i+1));
    }
    int l=nMinus1C2-k ;
    int p=2 ;
    int q=3 ;
    while(l-->0){
      System.out.println(p+" "+q);
      q++;
      if(q>n){
        p++;
        q=p+1 ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var nMinus1C2 : int ; nMinus1C2 := 1 ;
        var i : int ; i := n - 1 ; while i >= n - 2 do ( (     nMinus1C2 := nMinus1C2*(i) )  ;     i := i - 1 ) ; 
    nMinus1C2 := nMinus1C2/(2) ; 
    if (k > nMinus1C2) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var m : int ; m := (n - 1) + (nMinus1C2 - k) ;
    OclFile["System.out"].println(m) ; 
        var i : int ; i := 1 ; while i < n do ( (     OclFile["System.out"].println("1 " + (i + 1)) )  ;     i := i + 1 ) ; 
    var l : int ; l := nMinus1C2 - k ;
    var p : int ; p := 2 ;
    var q : int ; q := 3 ;
        while (l > 0) do (        l := l - 1 ;     skip ; (     OclFile["System.out"].println(p + " " + q) ; 
     q := q + 1 ; 
     if (q > n) then (     p := p + 1 ; 
     q := p + 1 ) else skip ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    if((N-1)*(N-2)/2<K){
      System.out.println(-1);
    }
    else {
      int connect=(N-1)*(N-2)/2-K ;
      System.out.println(N-1+connect);
      for(int i=0 ; i<N-1 ; i++){
        System.out.println("1 "+(i+2));
      }
      for(int i=2 ; i<=N ; i++){
        for(int j=i+1 ; j<=N ; j++){
          if(connect>0){
            System.out.println(i+" "+j);
            connect--;
          }
        }
      }
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    if ((N - 1) * (N - 2) / 2 < K) then (     OclFile["System.out"].println(-1) ) else (     var connect : int ; connect := (N - 1) * (N - 2) / 2 - K ;
     OclFile["System.out"].println(N - 1 + connect) ; 
         var i : int ; i := 0 ; while i < N - 1 do ( (     OclFile["System.out"].println("1 " + (i + 2)) )  ;     i := i + 1 ) ; 
         var i : int ; i := 2 ; while i <= N do ( (         var j : int ; j := i + 1 ; while j <= N do ( (     if (connect > 0) then (     OclFile["System.out"].println(i + " " + j) ; 
     connect := connect - 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findSmallest(int a[],int n){
    for(int i=0 ; i<n ; i++){
      int j ;
      for(j=0 ; j<n ; j++)if(a[j] % a[i]>=1)break ;
      if(j==n)return a[i];
    }
    return-1 ;
  }
  public static void main(String args[]){
    int a[]={
      25,20,5,10,100 };
      int n=a.length ;
      System.out.println(findSmallest(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSmallest( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var j : int ;
         j := 0 ; while j < n do (     if (a[j+1] mod a[i+1] >= 1) then     break else skip ;  ;     j := j + 1 ) ; 
     if (j = n) then     return a[i+1] else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{25,20,5,10,100} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(findSmallest(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Map.Entry ;
import java.util.Scanner ;
import java.util.TreeMap ;
public class Main {
  public static void main(String[] args){
    int i,q,order ;
    String key,key2,str="" ;
    TreeMap<String,Integer>tm=new TreeMap<String,Integer>();
    try(Scanner sc=new Scanner(System.in)){
      q=sc.nextInt();
      for(i=0 ; i<q ; i++){
        order=sc.nextInt();
        key=sc.next();
        switch(order){
          case 0 : tm.put(key,sc.nextInt());
          break ;
          case 1 : if(tm.get(key)==null){
            System.out.println(0);
          }
          else {
            System.out.println(tm.get(key));
          }
          break ;
          case 2 : tm.remove(key);
          break ;
          case 3 : key2=sc.next();
          for(Entry<String,Integer>output : tm.subMap(key,true,key2,true).entrySet()){
            System.out.println(output.getKey()+" "+output.getValue());
          }
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var q : int ;
    var order : int ;
     var key : String ;
    var key2 : String ;
    var str : String ; str := "" ;
     var tm : Map(String,int) ; tm := Map{} ;
     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     q := sc.getCurrent()->toInteger() ; 
         i := 0 ; while i < q do ( (     order := sc.getCurrent()->toInteger() ; 
     key := sc.getCurrent() ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (order) ; 
       if _switchval = 0 then
     tm := tm->union(Map{key |-> sc.getCurrent()->toInteger()}) ; 
    break 
   else skip ;
       if _switchval = 1 then
     if (tm->at(key) = null) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(tm->at(key)) ) ;  
    break 
   else skip ;
       if _switchval = 2 then
     tm := tm->antirestrict(Set{key}) ; 
    break 
   else skip ;
       if _switchval = 3 then
     key2 := sc.getCurrent() ; 
    for (output : tm->restrict( _key | _key < true & _key >= key )->asSet()) do ( (     OclFile["System.out"].println(output.getKey() + " " + output.getValue()) )  ) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=1 ;
    while(t-->0){
      int n=sc.nextInt();
      String s=sc.next();
      int x=0 ;
      for(int i=0 ; i<n ; i++){
        char ch=s.charAt(i);
        if(ch=='x'){
          x++;
        }
      }
      int X=n-x ;
      if(x==X){
        System.out.println(0);
        System.out.println(s);
        continue ;
      }
      StringBuilder ans=new StringBuilder();
      if(x>X){
        int d=x-X ;
        d=d/2 ;
        System.out.println(d);
        for(int i=0 ; i<n ; i++){
          if(d>0){
            if(s.charAt(i)=='x'){
              ans.append('X');
              d--;
            }
            else {
              ans.append('X');
            }
          }
          else {
            ans.append(s.charAt(i));
          }
        }
        System.out.println(ans);
      }
      else {
        int d=X-x ;
        d=d/2 ;
        System.out.println(d);
        for(int i=0 ; i<n ; i++){
          if(d>0){
            if(s.charAt(i)=='X'){
              ans.append('x');
              d--;
            }
            else {
              ans.append('x');
            }
          }
          else {
            ans.append(s.charAt(i));
          }
        }
        System.out.println(ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : String ; s := sc.getCurrent() ;
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var ch : String ; ch := s->at(i+1) ;
     if (ch = 'x') then (     x := x + 1 ) else skip )  ;     i := i + 1 ) ; 
    var X : int ; X := n - (x)->char2byte() ;
    if (x = X) then (     OclFile["System.out"].println(0) ; 
     OclFile["System.out"].println(s) ; 
     continue ) else skip ; 
    var ans : String ; ans := StringLib.newString() ;
    if (x > X) then (     var d : int ; d := (x)->char2byte() - (X)->char2byte() ;
     d := d / 2 ; 
    OclFile["System.out"].println(d) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (d > 0) then (     if (s->at(i+1) = 'x') then (     ans := ans + StringLib.newString('X') ; 
     d := d - 1 ) else (     ans := ans + StringLib.newString('X') ) ) else (     ans := ans + StringLib.newString(s->at(i+1)) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) else (     var d : int ; d := (X)->char2byte() - (x)->char2byte() ;
     d := d / 2 ; 
    OclFile["System.out"].println(d) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (d > 0) then (     if (s->at(i+1) = 'X') then (     ans := ans + StringLib.newString('x') ; 
     d := d - 1 ) else (     ans := ans + StringLib.newString('x') ) ) else (     ans := ans + StringLib.newString(s->at(i+1)) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int q=Integer.parseInt(str[0]);
    SortedMap<String,Integer>mpa=new TreeMap<String,Integer>();
    for(int i=0 ; i<q ; i++){
      str=br.readLine().split(" ");
      int op=Integer.parseInt(str[0]);
      if(op==0){
        String key=str[1];
        int x=Integer.parseInt(str[2]);
        mpa.put(key,x);
      }
      else if(op==1){
        String key=str[1];
        if(mpa.containsKey(key))System.out.println(mpa.get(key));
        else System.out.println(0);
      }
      else if(op==2){
        String key=str[1];
        if(mpa.containsKey(key))mpa.remove(key);
      }
      else {
        String L=str[1];
        String R=str[2]+"#" ;
        SortedMap<String,Integer>mpb=mpa.subMap(L,R);
        for(String s : mpb.keySet()){
          System.out.println(s+" "+mpa.get(s));
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var q : int ; q := (str[0+1])->toInteger() ;
    var mpa : Map(String,int) ; mpa := Map{} ;
        var i : int ; i := 0 ; while i < q do ( (     str := br.readLine()->split(" ") ; 
     var op : int ; op := (str[0+1])->toInteger() ;
     if (op = 0) then (     var key : String ; key := str[1+1] ;
     var x : int ; x := (str[2+1])->toInteger() ;
     mpa := mpa->union(Map{key |-> x}) ) else     if (op = 1) then (     var key : String ; key := str[1+1] ;
     if (mpa->keys()->includes(key)) then     OclFile["System.out"].println(mpa->at(key)) ; else     OclFile["System.out"].println(0) ; ) else     if (op = 2) then (     var key : String ; key := str[1+1] ;
     if (mpa->keys()->includes(key)) then     mpa := mpa->antirestrict(Set{key}) ; else skip ) else (     var L : String ; L := str[1+1] ;
     var R : String ; R := str[2+1] + "#" ;
     var mpb : Map(String,int) ; mpb := mpa->restrict( _key | _key < R & _key >= L ) ;
     for (s : mpb->keys()) do ( (     OclFile["System.out"].println(s + " " + mpa->at(s)) )  ) ) ;  ;  )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Map.Entry ;
public class Main {
  @ SuppressWarnings({
    "rawtypes","unchecked","resource" }
)public static void main(String[] arg){
      TreeMap<String,Integer>map=new TreeMap();
      Scanner sc=new Scanner(System.in);
      int cnt=sc.nextInt();
      for(int i=0 ; i<cnt ; i++){
        int cmt=sc.nextInt();
        switch(cmt){
          case 0 : String str=sc.next();
          int num=sc.nextInt();
          map.put(str,num);
          break ;
          case 1 : str=sc.next();
          if(map.containsKey(str))System.out.println(map.get(str));
          else System.out.println(0);
          break ;
          case 2 : str=sc.next();
          map.remove(str);
          break ;
          case 3 : String l=sc.next();
          String r=sc.next();
          NavigableMap<String,Integer>in=map.subMap(l,true,r,true);
          Iterator<NavigableMap.Entry<String,Integer>>it=in.entrySet().iterator();
          while(it.hasNext()){
            NavigableMap.Entry<String,Integer>yes=it.next();
            System.out.println(yes.getKey()+" "+yes.getValue());
          }
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var map : Map(String,int) ; map := Map{} ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cnt : int ; cnt := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < cnt do ( (     var cmt : int ; cmt := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (cmt) ; 
       if _switchval = 0 then
     var str : String ; str := sc.getCurrent() ;
    var num : int ; num := sc.getCurrent()->toInteger() ;
    map := map->union(Map{str |-> num}) ; 
    break 
   else skip ;
       if _switchval = 1 then
     str := sc.getCurrent() ; 
    if (map->keys()->includes(str)) then     OclFile["System.out"].println(map->at(str)) else     OclFile["System.out"].println(0) ; ;  
    break 
   else skip ;
       if _switchval = 2 then
     str := sc.getCurrent() ; 
    map := map->antirestrict(Set{str}) ; 
    break 
   else skip ;
       if _switchval = 3 then
     var l : String ; l := sc.getCurrent() ;
    var r : String ; r := sc.getCurrent() ;
    var in : NavigableMap<String,int> ; in := map->restrict( _key | _key < true & _key >= l ) ;
    var it : OclIterator ; it := in->asSet()->iterator() ;
    while (it.hasNext()) do (     var yes : Entry<String,int> ; yes := it.next() ;
     OclFile["System.out"].println(yes.getKey() + " " + yes.getValue()) ) ; 
   else skip ;
 )
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Iterator ;
import java.util.Map ;
import java.util.Objects ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    TreeMap<String,Integer>map=new TreeMap<>();
    int q=sc.nextInt();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<q ; i++){
      int op=sc.nextInt();
      String key=sc.next();
      switch(op){
        case 0 : map.put(key,sc.nextInt());
        break ;
        case 1 : if(Objects.isNull(map.get(key))){
          sb.append(0);
          sb.append('\n');
        }
        else {
          sb.append(map.get(key));
          sb.append('\n');
        }
        break ;
        case 2 : map.remove(key);
        break ;
        case 3 : String r=sc.next();
        Map<String,Integer>submap=map.subMap(key,r);
        for(String str : submap.keySet()){
          sb.append(str);
          sb.append(' ');
          sb.append(map.get(str));
          sb.append('\n');
        }
        if(map.get(r)!=null){
          sb.append(r);
          sb.append(' ');
          sb.append(map.get(r));
          sb.append('\n');
        }
        break ;
      }
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var map : Map(String,int) ; map := Map{} ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < q do ( (     var op : int ; op := sc.getCurrent()->toInteger() ;
     var key : String ; key := sc.getCurrent() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (op) ; 
       if _switchval = 0 then
     map := map->union(Map{key |-> sc.getCurrent()->toInteger()}) ; 
    break 
   else skip ;
       if _switchval = 1 then
     if (Objects.isNull(map->at(key))) then (     sb := sb + StringLib.newString(0) ; 
     sb := sb + StringLib.newString('
') ) else (     sb := sb + StringLib.newString(map->at(key)) ; 
     sb := sb + StringLib.newString('
') ) ;  
    break 
   else skip ;
       if _switchval = 2 then
     map := map->antirestrict(Set{key}) ; 
    break 
   else skip ;
       if _switchval = 3 then
     var r : String ; r := sc.getCurrent() ;
    var submap : Map(String,int) ; submap := map->restrict( _key | _key < r & _key >= key ) ;
    for (str : submap->keys()) do ( (     sb := sb + StringLib.newString(str) ; 
     sb := sb + StringLib.newString(' ') ; 
     sb := sb + StringLib.newString(map->at(str)) ; 
     sb := sb + StringLib.newString('
') )  ) ; 
    if (map->at(r) /= null) then (     sb := sb + StringLib.newString(r) ; 
     sb := sb + StringLib.newString(' ') ; 
     sb := sb + StringLib.newString(map->at(r)) ; 
     sb := sb + StringLib.newString('
') ) else skip ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Codeforces {
  public static void main(String[] args){
    Scanner kali=new Scanner(System.in);
    int all=kali.nextInt();
    int temp=0 ;
    for(int i=1 ; i<=all ; i++){
      int num=kali.nextInt();
      temp+=num ;
    }
    if(temp>0){
      System.out.println("HARD");
    }
    else {
      System.out.println("EASY");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var kali : OclFile ; kali := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var all : int ; all := kali.getCurrent()->toInteger() ;
    var temp : int ; temp := 0 ;
        var i : int ; i := 1 ; while i <= all do ( (     var num : int ; num := kali.getCurrent()->toInteger() ;
     temp := temp+(num) )  ;     i := i + 1 ) ; 
    if (temp > 0) then (     OclFile["System.out"].println("HARD") ) else (     OclFile["System.out"].println("EASY") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.sql.SQLOutput ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class nurda {
  public static void main(String[] args){
    Scanner real=new Scanner(System.in);
    int n=real.nextInt();
    int h=0 ;
    int sum=0 ;
    int hum=0 ;
    int[] arr=new int[n];
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=real.nextInt();
      if(arr[i]>h){
        sum++;
      }
    }
    if(sum>=1){
      System.out.println("hard");
    }
    else {
      System.out.println("easy");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class nurda {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var real : OclFile ; real := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := real.getCurrent()->toInteger() ;
    var h : int ; h := 0 ;
    var sum : int ; sum := 0 ;
    var hum : int ; hum := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := real.getCurrent()->toInteger() ; 
     if (arr[i+1] > h) then (     sum := sum + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (sum >= 1) then (     OclFile["System.out"].println("hard") ) else (     OclFile["System.out"].println("easy") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int a=scan.nextInt();
    int b=scan.nextInt();
    int A=a ;
    int B=b ;
    while(A % B!=0){
      int Z=A ;
      A=B ;
      B=Z % A ;
    }
    System.out.println((a+b+1)-B);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    var A : int ; A := a ;
    var B : int ; B := b ;
    while (A mod B /= 0) do (     var Z : int ; Z := A ;
     A := B ; 
     B := Z mod A ) ; 
    OclFile["System.out"].println((a + b + 1) - B) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Deque ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    int ans=0 ;
    Deque<Integer>stack=new ArrayDeque<>();
    for(int i=0 ; i<n ; i++){
      while(! stack.isEmpty()&& a[stack.peekLast()]<a[i]){
        ans=Math.max(ans,a[stack.pollLast()] ^ a[i]);
      }
      stack.offerLast(i);
    }
    stack.clear();
    for(int i=n-1 ; i>=0 ; i--){
      while(! stack.isEmpty()&& a[stack.peekLast()]<a[i]){
        ans=Math.max(ans,a[stack.pollLast()] ^ a[i]);
      }
      stack.offerLast(i);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var stack : Sequence(int) ; stack := ArrayDeque<OclAny>.newArrayDeque() ;
        var i : int ; i := 0 ; while i < n do ( (     while (not(stack->isEmpty()) & a[stack.peekLast()+1] < a[i+1]) do (     ans := Set{ans, a[stack->last()+1] xor a[i+1]}->max() ) ; 
     stack := stack->append(i) )  ;     i := i + 1 ) ; 
    stack := stack->intersection(Set{}) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     while (not(stack->isEmpty()) & a[stack.peekLast()+1] < a[i+1]) do (     ans := Set{ans, a[stack->last()+1] xor a[i+1]}->max() ) ; 
     stack := stack->append(i) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class easy {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int a=scan.nextInt();
    int b=0 ;
    int sum=0 ;
    for(int i=0 ; i<a ; i++){
      b=scan.nextInt();
      sum+=b ;
    }
    if(sum>=1){
      System.out.println("Hard");
    }
    else {
      System.out.println("Easy");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class easy {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < a do ( (     b := scan.getCurrent()->toInteger() ; 
     sum := sum+(b) )  ;     i := i + 1 ) ; 
    if (sum >= 1) then (     OclFile["System.out"].println("Hard") ) else (     OclFile["System.out"].println("Easy") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Task_1030 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int quantity=in.nextInt();
    for(int i=0 ; i<quantity ; i++){
      int c=in.nextInt();
      if(c==1){
        System.out.println("HARD");
        return ;
      }
    }
    System.out.println("EASY");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Task_1030 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var quantity : int ; quantity := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < quantity do ( (     var c : int ; c := in.getCurrent()->toInteger() ;
     if (c = 1) then (     OclFile["System.out"].println("HARD") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("EASY") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Rough {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long arr[]=new long[(int)n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    boolean flag=false ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==1){
        System.out.println("HARD");
        flag=true ;
        break ;
      }
    }
    if(flag==false){
      System.out.println("EASY");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Rough {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n->oclAsType(int))->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 1) then (     OclFile["System.out"].println("HARD") ; 
     flag := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = false) then (     OclFile["System.out"].println("EASY") ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner reader=new Scanner(System.in);
    while(reader.hasNext()){
      int n=reader.nextInt();
      String s1=reader.next();
      char b[]=s1.toCharArray();
      int c[]=new int[n];
      int n1=0 ;
      int n2=0 ;
      for(int i=0 ; i<n ; i++){
        if(b[i]=='x'){
          c[i]=1 ;
          n1++;
        }
        else {
          c[i]=2 ;
          n2++;
        }
      }
      if(n1==n2){
        System.out.println("0");
        for(int i=0 ; i<n ; i++)System.out.print(b[i]);
      }
      else if(n1>n2){
        int nn1=n1 ;
        int nn2=n2 ;
        for(int i=0 ; i<n ; i++){
          if(b[i]=='x'){
            b[i]='X' ;
            nn2++;
            nn1--;
            if(nn1==nn2)break ;
          }
        }
        System.out.println((n1-n2)/2);
        for(int i=0 ; i<n ; i++)System.out.print(b[i]);
      }
      else {
        int nn1=n1 ;
        int nn2=n2 ;
        for(int i=0 ; i<n ; i++){
          if(b[i]=='X'){
            b[i]='x' ;
            nn2--;
            nn1++;
            if(nn1==nn2)break ;
          }
        }
        System.out.println((n2-n1)/2);
        for(int i=0 ; i<n ; i++)System.out.print(b[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (reader.hasNext()) do (     var n : int ; n := reader.getCurrent()->toInteger() ;
     var s1 : String ; s1 := reader.getCurrent() ;
    var b : Sequence(String) ; b := s1->characters() ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    var n1 : int ; n1 := 0 ;
    var n2 : int ; n2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (b[i+1] = 'x') then (     c[i+1] := 1 ; 
     n1 := n1 + 1 ) else (     c[i+1] := 2 ; 
     n2 := n2 + 1 ) )  ;     i := i + 1 ) ; 
    if (n1 = n2) then (     OclFile["System.out"].println("0") ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(b[i+1]) ;  ;     i := i + 1 ) ) else     if (n1 > n2) then (     var nn1 : int ; nn1 := n1 ;
     var nn2 : int ; nn2 := n2 ;
        var i : int ; i := 0 ; while i < n do ( (     if (b[i+1] = 'x') then (     b[i+1] := 'X' ; 
     nn2 := nn2 + 1 ; 
     nn1 := nn1 - 1 ; 
     if (nn1 = nn2) then     break else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((n1 - n2) / 2) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(b[i+1]) ;  ;     i := i + 1 ) ; 
 ) else (     var nn1 : int ; nn1 := n1 ;
     var nn2 : int ; nn2 := n2 ;
        var i : int ; i := 0 ; while i < n do ( (     if (b[i+1] = 'X') then (     b[i+1] := 'x' ; 
     nn2 := nn2 - 1 ; 
     nn1 := nn1 + 1 ; 
     if (nn1 = nn2) then     break else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((n2 - n1) / 2) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(b[i+1]) ;  ;     i := i + 1 ) ; 
 ) ;  ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new C().doIt();
  }
  class C {
    int alf[]=new int[128];
    void doIt(){
      int n=sc.nextInt();
      String str=sc.next();
      char ctr[]=str.toCharArray();
      for(int i=0 ; i<n ; i++){
        if(i % 2==0)alf[ctr[i] ]++;
      }
      int ans=0 ;
      for(int i=1 ; i<=9 ; i++){
        int num=0 ;
        for(char c='a' ; c<='z' ; c++){
          if(alf[c]==i)num++;
        }
        if(i==1){
          if(num>0){
            if(ans>0)ans=ans+1 ;
            ans=ans+(num*2)-1 ;
          }
        }
        else {
          if(num==1){
            if(ans>0)ans=ans+1 ;
            ans=ans+3 ;
          }
          else if(num>1){
            if(ans>0)ans=ans+1 ;
            ans=ans+(2*num)+3 ;
          }
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     C.newC().doIt() );
 class C {
   attribute alf : int := Integer.subrange(1,128)->collect(0);
   operation doIt() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var str : String ; str := sc.getCurrent() ;
    var ctr : Sequence(String) ; ctr := str->characters() ;
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then     alf[ctr[i+1]+1] := alf[ctr[i+1]+1] + 1 ; else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= 9 do ( (     var num : int ; num := 0 ;
         var c : String ; c := 'a' ; while c <= 'z' do ( (     if (alf[c+1] = i) then     num := num + 1 ; else skip )  ;     c := c + 1 ) ; 
     if (i = 1) then (     if (num > 0) then (     if (ans > 0) then     ans := ans + 1 ; else skip ; 
     ans := ans + (num * 2) - 1 ) else skip ) else (     if (num = 1) then (     if (ans > 0) then     ans := ans + 1 ; else skip ; 
     ans := ans + 3 ) else     if (num > 1) then (     if (ans > 0) then     ans := ans + 1 ; else skip ; 
     ans := ans + (2 * num) + 3 ) else skip ; ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] arr=sc.next().toCharArray();
    int[] counts=new int[26];
    for(char c : arr){
      if(c!='+'){
        counts[c-'a']++;
      }
    }
    Arrays.sort(counts);
    int prev=counts[25];
    int cnt=1 ;
    int total=0 ;
    if(prev==1){
      prev=0 ;
      total+=2 ;
    }
    for(int i=24 ; i>=0 && counts[i]>0 ; i--){
      if(prev==counts[i]){
        cnt++;
      }
      else {
        if(prev==0){
          total+=2 ;
        }
        else {
          if(cnt>=2){
            total+=4+cnt*2 ;
          }
          else {
            total+=4 ;
          }
          cnt=1 ;
          if(counts[i]==1){
            prev=0 ;
            total+=2 ;
          }
          else {
            prev=counts[i];
          }
        }
      }
    }
    if(prev!=0){
      if(cnt>=2){
        total+=4+cnt*2 ;
      }
      else {
        total+=4 ;
      }
    }
    System.out.println(total-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
    var counts : Sequence(int) ; counts := Integer.subrange(1,26)->collect(0) ;
    for (c : arr) do ( (     if (c /= '+') then (     counts[c - ('a')->char2byte()+1] := counts[c - ('a')->char2byte()+1] + 1 ) else skip )  ) ; 
    counts := counts->sort() ; 
    var prev : int ; prev := counts[25+1] ;
    var cnt : int ; cnt := 1 ;
    var total : int ; total := 0 ;
    if (prev = 1) then (     prev := 0 ; 
     total := total+(2) ) else skip ; 
        var i : int ; i := 24 ; while i >= 0 & counts[i+1] > 0 do ( (     if (prev = counts[i+1]) then (     cnt := cnt + 1 ) else (     if (prev = 0) then (     total := total+(2) ) else (     if (cnt >= 2) then (     total := total+(4 + cnt * 2) ) else (     total := total+(4) ) ;  
     cnt := 1 ; 
     if (counts[i+1] = 1) then (     prev := 0 ; 
     total := total+(2) ) else (     prev := counts[i+1] ) ) ) )  ;     i := i - 1 ) ; 
    if (prev /= 0) then (     if (cnt >= 2) then (     total := total+(4 + cnt * 2) ) else (     total := total+(4) ) ) else skip ; 
    OclFile["System.out"].println(total - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long K=sc.nextLong();
    long A[]=new long[N];
    for(int n=0 ; n<N ; n++)A[n]=sc.nextLong();
    long x=0 ;
    final int DIGIT=40 ;
    for(int i=DIGIT-1 ; i>=0 ; i--){
      int count=0 ;
      for(int j=0 ; j<N ; j++)count+=(1 &(A[j]>>i));
      if(count<=N/2)if((x | 1l<<i)<=K)x=x | 1l<<i ;
    }
    long sum=0 ;
    for(int i=0 ; i<N ; i++)sum+=(x ^ A[i]);
    System.out.println(sum);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : long ; K := sc.getCurrent()->toLong() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do (     A[n+1] := sc.getCurrent()->toLong() ;  ;     n := n + 1 ) ; 
    var x : long ; x := 0 ;
    var DIGIT : int ; DIGIT := 40 ;
        var i : int ; i := DIGIT - 1 ; while i >= 0 do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < N do (     count := count+((MathLib.bitwiseAnd(1,((A[j+1]/(2->pow(i)))->oclAsType(long))))) ;  ;     j := j + 1 ) ; 
     if (count <= N / 2) then     if ((MathLib.bitwiseOr(x,(1l*(2->pow(i)))->oclAsType(long))) <= K) then     x := MathLib.bitwiseOr(x,(1l*(2->pow(i)))->oclAsType(long)) ; else skip ; else skip )  ;     i := i - 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do (     sum := sum+((MathLib.bitwiseXor(x,A[i+1]))) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.System.in ;
public class Main {
  static int n ;
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long K=sc.nextLong();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextLong();
    long[] bitCount=new long[41];
    for(int i=1 ; i<=40 ; i++){
      long mask=1L<<(i-1);
      for(long w : a)bitCount[i]+=(mask & w)>0 ? 1 : 0 ;
    }
    long[] dp=new long[41];
    for(int i=1 ; i<=40 ; i++){
      long mask=1L<<(i-1);
      dp[i]=dp[i-1]+Math.max(bitCount[i],n-bitCount[i])*mask ;
    }
    long ans=0 ;
    for(long w : a)ans+=w ^ K ;
    for(int i=40 ; i>=1 ; i--){
      long mask=1L<<(i-1);
      if((mask & K)==0)continue ;
      long submask=~(mask-1),X=K ^ mask ;
      long cur=0 ;
      for(int j=0 ; j<n ; j++){
        long now=(a[j] ^ X)& submask ;
        cur+=now ;
      }
      cur+=dp[i-1];
      ans=Math.max(ans,cur);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var K : long ; K := sc.getCurrent()->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var bitCount : Sequence(long) ; bitCount := Integer.subrange(1,41)->collect(0) ;
        var i : int ; i := 1 ; while i <= 40 do ( (     var mask : long ; mask := (1L*(2->pow((i - 1))))->oclAsType(long) ;
     for (w : a) do (     bitCount[i+1] := bitCount[i+1]+(if (MathLib.bitwiseAnd(mask,w)) > 0 then 1 else 0 endif) ;  ) )  ;     i := i + 1 ) ; 
    var dp : Sequence(long) ; dp := Integer.subrange(1,41)->collect(0) ;
        var i : int ; i := 1 ; while i <= 40 do ( (     var mask : long ; mask := (1L*(2->pow((i - 1))))->oclAsType(long) ;
     dp[i+1] := dp[i - 1+1] + Set{bitCount[i+1], n - bitCount[i+1]}->max() * mask )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    for (w : a) do (     ans := ans+(w xor K) ;  ) ; 
        var i : int ; i := 40 ; while i >= 1 do ( (     var mask : long ; mask := (1L*(2->pow((i - 1))))->oclAsType(long) ;
     if ((MathLib.bitwiseAnd(mask,K)) = 0) then     continue else skip ; 
    var submask : long ; submask := -((mask - 1) + 1) ;
    var X : long ; X := MathLib.bitwiseXor(K,mask) ;
    var cur : long ; cur := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     var now : long ; now := MathLib.bitwiseAnd((MathLib.bitwiseXor(a[j+1],X)),submask) ;
     cur := cur+(now) )  ;     j := j + 1 ) ; 
    cur := cur+(dp[i - 1+1]) ; 
    ans := Set{ans, cur}->max() ; 
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int SIZE=40 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long k=sc.nextLong();
    boolean[] base=getArray(k);
    long[] nums=new long[n];
    boolean[][] arrs=new boolean[n][];
    for(int i=0 ; i<n ; i++){
      nums[i]=sc.nextLong();
      arrs[i]=getArray(nums[i]);
    }
    boolean[] ans=new boolean[SIZE];
    boolean isFirst=true ;
    for(int i=SIZE-1 ; i>=0 ; i--){
      if(isFirst && ! base[i]){
        ans[i]=false ;
      }
      else {
        int count=0 ;
        for(int j=0 ; j<n ; j++){
          if(arrs[j][i]){
            count++;
          }
        }
        if(count*2>=n){
          ans[i]=false ;
          if(isFirst && base[i]){
            isFirst=false ;
          }
        }
        else {
          ans[i]=true ;
        }
      }
    }
    long fin=0 ;
    for(int i=SIZE-1 ; i>=0 ; i--){
      fin<<=1 ;
      if(ans[i]){
        fin++;
      }
    }
    long total=0 ;
    for(long x : nums){
      total+=(x ^ fin);
    }
    System.out.println(total);
  }
  static boolean[] getArray(long x){
    boolean[] ans=new boolean[SIZE];
    for(int i=0 ; i<SIZE ; i++){
      if(x % 2==1){
        ans[i]=true ;
      }
      x/=2 ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute SIZE : int := 40;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var base : Sequence(boolean) ; base := getArray(k) ;
    var nums : Sequence(long) ; nums := Integer.subrange(1,n)->collect(0) ;
    var arrs : Sequence(Sequence(boolean)) ; arrs := Integer.subrange(1,n)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := sc.getCurrent()->toLong() ; 
     arrs[i+1] := getArray(nums[i+1]) )  ;     i := i + 1 ) ; 
    var ans : Sequence(boolean) ; ans := Integer.subrange(1,SIZE)->collect(false) ;
    var isFirst : boolean ; isFirst := true ;
        var i : int ; i := SIZE - 1 ; while i >= 0 do ( (     if (isFirst & not(base[i+1])) then (     ans[i+1] := false ) else (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (arrs[j+1][i+1]) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (count * 2 >= n) then (     ans[i+1] := false ; 
     if (isFirst & base[i+1]) then (     isFirst := false ) else skip ) else (     ans[i+1] := true ) ) )  ;     i := i - 1 ) ; 
    var fin : long ; fin := 0 ;
        var i : int ; i := SIZE - 1 ; while i >= 0 do ( (     fin := fin*(2->pow(1)) ; 
     if (ans[i+1]) then (     fin := fin + 1 ) else skip )  ;     i := i - 1 ) ; 
    var total : long ; total := 0 ;
    for (x : nums) do ( (     total := total+((x xor fin)) )  ) ; 
    OclFile["System.out"].println(total) ; 
 );
  static   operation getArray( x : long) : Sequence(boolean)
  pre: true
  post: true
  activity: (     var ans : Sequence(boolean) ; ans := Integer.subrange(1,SIZE)->collect(false) ;
         var i : int ; i := 0 ; while i < SIZE do ( (     if (x mod 2 = 1) then (     ans[i+1] := true ) else skip ; 
     x := x/(2) )  ;     i := i + 1 ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  public static final int MAX_BIT=39 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long K=sc.nextLong();
    long[] A=new long[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextLong();
    }
    int[] oneBitNums=new int[MAX_BIT+1];
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<=MAX_BIT ; j++){
        if((A[i]>>j & 1)==1){
          oneBitNums[j]++;
        }
      }
    }
    int[] xBits=new int[MAX_BIT+1];
    for(int i=MAX_BIT ; i>=0 ; i--){
      if(oneBitNums[i]<=N/2){
        xBits[i]=1 ;
      }
    }
    long X=0 ;
    for(int i=MAX_BIT ; i>=0 ; i--){
      if(xBits[i]==1){
        long num=(long)Math.pow(2.0,i);
        if(X+num<=K){
          X+=num ;
        }
      }
    }
    long ans=0 ;
    for(int i=0 ; i<N ; i++){
      ans+=X ^ A[i];
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX_BIT : int := 39;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : long ; K := sc.getCurrent()->toLong() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var oneBitNums : Sequence(int) ; oneBitNums := Integer.subrange(1,MAX_BIT + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j <= MAX_BIT do ( (     if ((MathLib.bitwiseAnd((A[i+1]/(2->pow(j)))->oclAsType(long),1)) = 1) then (     oneBitNums[j+1] := oneBitNums[j+1] + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var xBits : Sequence(int) ; xBits := Integer.subrange(1,MAX_BIT + 1)->collect(0) ;
        var i : int ; i := MAX_BIT ; while i >= 0 do ( (     if (oneBitNums[i+1] <= N / 2) then (     xBits[i+1] := 1 ) else skip )  ;     i := i - 1 ) ; 
    var X : long ; X := 0 ;
        var i : int ; i := MAX_BIT ; while i >= 0 do ( (     if (xBits[i+1] = 1) then (     var num : long ; num := 2.0->pow(i)->oclAsType(long) ;
     if (X + num <= K) then (     X := X+(num) ) else skip ) else skip )  ;     i := i - 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     ans := ans+(MathLib.bitwiseXor(X,A[i+1])) )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long k=sc.nextLong();
    k++;
    int[] kk=new int[40];
    long[] c=new long[40];
    for(int i=0 ; i<40 ; i++){
      if(k % 2==1)kk[i]=1 ;
      k/=2 ;
    }
    for(int i=0 ; i<n ; i++){
      long a=sc.nextLong();
      for(int j=0 ; j<40 ; j++){
        if(a % 2==1)c[j]++;
        a/=2 ;
      }
    }
    long ans=0 ;
    for(int i=0 ; i<40 ; i++){
      long t=0 ;
      if(kk[39-i]==1){
        for(int j=0 ; j<40 ; j++){
          if(j<i){
            if(kk[39-j]==0){
              t+=((long)Math.pow(2,39-j)*c[39-j]);
            }
            else {
              t+=((long)Math.pow(2,39-j)*((long)n-c[39-j]));
            }
          }
          else if(j==i){
            t+=((long)Math.pow(2,39-j)*c[39-j]);
          }
          else {
            t+=(long)Math.max((long)Math.pow(2,39-j)*c[39-j],(long)Math.pow(2,39-j)*((long)n-c[39-j]));
          }
        }
      }
      ans=Math.max(ans,t);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    k := k + 1 ; 
    var kk : Sequence(int) ; kk := Integer.subrange(1,40)->collect(0) ;
    var c : Sequence(long) ; c := Integer.subrange(1,40)->collect(0) ;
        var i : int ; i := 0 ; while i < 40 do ( (     if (k mod 2 = 1) then     kk[i+1] := 1 ; else skip ; 
     k := k/(2) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var a : long ; a := sc.getCurrent()->toLong() ;
         var j : int ; j := 0 ; while j < 40 do ( (     if (a mod 2 = 1) then     c[j+1] := c[j+1] + 1 ; else skip ; 
     a := a/(2) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < 40 do ( (     var t : long ; t := 0 ;
     if (kk[39 - i+1] = 1) then (         var j : int ; j := 0 ; while j < 40 do ( (     if (j < i) then (     if (kk[39 - j+1] = 0) then (     t := t+((2->pow(39 - j)->oclAsType(long) * c[39 - j+1])) ) else (     t := t+((2->pow(39 - j)->oclAsType(long) * (n->oclAsType(long) - c[39 - j+1]))) ) ) else     if (j = i) then (     t := t+((2->pow(39 - j)->oclAsType(long) * c[39 - j+1])) ) else (     t := t+(Set{2->pow(39 - j)->oclAsType(long) * c[39 - j+1], 2->pow(39 - j)->oclAsType(long) * (n->oclAsType(long) - c[39 - j+1])}->max()->oclAsType(long)) ) ;  )  ;     j := j + 1 ) ) else skip ; 
     ans := Set{ans, t}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] arr=new long[n+1];
    for(int i=1 ; i<=n ; i++){
      arr[i]=sc.nextLong();
    }
    long ans=0 ;
    Deque<Integer>deque=new ArrayDeque<>();
    for(int i=1 ; i<=n ; i++){
      while(! deque.isEmpty()&& arr[deque.peek()]<arr[i]){
        deque.poll();
      }
      if(! deque.isEmpty()){
        ans=Math.max(ans,arr[deque.peek()] ^ arr[i]);
      }
      deque.push(i);
    }
    for(int i=n ; i>=1 ; i--){
      while(! deque.isEmpty()&& arr[deque.peek()]<arr[i]){
        deque.poll();
      }
      if(! deque.isEmpty()){
        ans=Math.max(ans,arr[deque.peek()] ^ arr[i]);
      }
      deque.push(i);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var deque : Sequence(int) ; deque := ArrayDeque<OclAny>.newArrayDeque() ;
        var i : int ; i := 1 ; while i <= n do ( (     while (not(deque->isEmpty()) & arr[deque->min()+1] < arr[i+1]) do (     deque := deque->sort()->tail() ) ; 
     if (not(deque->isEmpty())) then (     ans := Set{ans, arr[deque->min()+1] xor arr[i+1]}->max() ) else skip ; 
     deque := deque->append(i) )  ;     i := i + 1 ) ; 
        var i : int ; i := n ; while i >= 1 do ( (     while (not(deque->isEmpty()) & arr[deque->min()+1] < arr[i+1]) do (     deque := deque->sort()->tail() ) ; 
     if (not(deque->isEmpty())) then (     ans := Set{ans, arr[deque->min()+1] xor arr[i+1]}->max() ) else skip ; 
     deque := deque->append(i) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String s=in.next();
    int r=0,g=0,b=0 ;
    for(char c : s.toCharArray()){
      switch(c){
        case 'R' : r++;
        break ;
        case 'B' : b++;
        break ;
        case 'G' : g++;
        break ;
      }
    }
    String out="" ;
    if(g==n)out="G" ;
    else if(b==n)out="B" ;
    else if(r==n)out="R" ;
    else {
      if((g+r>1))out+="B" ;
      if((r+b>1))out+="G" ;
      if((g+b>1))out+="R" ;
    }
    System.out.println(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var r : int ; r := 0 ;
    var g : int ; g := 0 ;
    var b : int ; b := 0 ;
    for (c : s->characters()) do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
       if _switchval = 'R' then
     r := r + 1 ; 
    break 
   else skip ;
       if _switchval = 'B' then
     b := b + 1 ; 
    break 
   else skip ;
       if _switchval = 'G' then
     g := g + 1 ; 
    break 
   else skip ;
 )
 )  ) ; 
    var out : String ; out := "" ;
    if (g = n) then     out := "G" else     if (b = n) then     out := "B" else     if (r = n) then     out := "R" else (     if ((g + r > 1)) then     out := out+("B") ; else skip ; 
     if ((r + b > 1)) then     out := out+("G") ; else skip ; 
     if ((g + b > 1)) then     out := out+("R") ; else skip ) ;  ;  ;  
    OclFile["System.out"].println(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=Integer.parseInt(in.next());
    List<Integer>A=new ArrayList<>(),B=new ArrayList<>();
    for(int i=1 ; i<=n ; i++)A.add(i);
    parm(A,B,-1,-1);
    out.flush();
  }
  static void parm(List<Integer>A,List<Integer>B,int u,int v){
    List<Integer>ls=new ArrayList<>(A),res=new ArrayList<>(B);
    if(u!=-1)ls.remove(u);
    if(v!=-1)res.add(v);
    if(ls.size()==1){
      res.add(ls.get(0));
      for(int i=0 ; i<res.size()-1 ; i++)out.print(res.get(i)+" ");
      out.println(res.get(res.size()-1));
      return ;
    }
    for(int i=0 ; i<ls.size(); i++){
      parm(ls,res,i,ls.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (in.getCurrent())->toInteger() ;
    var A : Sequence(int) ; A := Sequence{} ;
    var B : Sequence(int) ; B := Sequence{} ;
        var i : int ; i := 1 ; while i <= n do (     A := A->including(i) ;  ;     i := i + 1 ) ; 
    execute parm(A, B, -1, -1) ; 
    skip ; 
 );
  static   operation parm( A : Sequence(int), B : Sequence(int), u : int, v : int) : void
  pre: true
  post: true
  activity: (     var ls : Sequence(int) ; ls := Sequence{}->union(A) ;
    var res : Sequence(int) ; res := Sequence{}->union(B) ;
     if (u /= -1) then     ls := ls->excludingFirst(u) ; else skip ; 
    if (v /= -1) then     res->excludes(v) ; else skip ; 
    if (ls->size() = 1) then (     res->excludes(ls->at(0+1)) ; 
         var i : int ; i := 0 ; while i < res->size() - 1 do (     skip ;  ;     i := i + 1 ) ; 
     skip ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < ls->size() do ( (     execute parm(ls, res, i, ls->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication100 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayList<Character>arr=new ArrayList<>();
    int num=sc.nextInt();
    String s=sc.next();
    int sit=0 ;
    int stand=0 ;
    String res="" ;
    int counter=0 ;
    boolean c=true ;
    for(int i=0 ; i<num ; i++){
      arr.add(s.charAt(i));
      if(s.charAt(i)=='x'){
        sit++;
      }
      else {
        stand++;
      }
    }
    while(c){
      if(sit==stand){
        c=false ;
      }
      else if(sit>stand){
        arr.set(arr.indexOf('x'),'X');
        counter++;
        stand++;
        sit--;
      }
      else {
        arr.set(arr.indexOf('X'),'x');
        counter++;
        stand--;
        sit++;
      }
    }
    System.out.println(counter);
    for(int i=0 ; i<num ; i++){
      res+=arr.get(i);
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication100 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(String) ; arr := Sequence{} ;
    var num : int ; num := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var sit : int ; sit := 0 ;
    var stand : int ; stand := 0 ;
    var res : String ; res := "" ;
    var counter : int ; counter := 0 ;
    var c : boolean ; c := true ;
        var i : int ; i := 0 ; while i < num do ( (     arr := arr->including(s->at(i+1)) ; 
     if (s->at(i+1) = 'x') then (     sit := sit + 1 ) else (     stand := stand + 1 ) )  ;     i := i + 1 ) ; 
    while (c) do (     if (sit = stand) then (     c := false ) else     if (sit > stand) then (     arr := arr.setAt(arr->indexOf('x')-1+1,'X') ; 
     counter := counter + 1 ; 
     stand := stand + 1 ; 
     sit := sit - 1 ) else (     arr := arr.setAt(arr->indexOf('X')-1+1,'x') ; 
     counter := counter + 1 ; 
     stand := stand - 1 ; 
     sit := sit + 1 ) ;  ) ; 
    OclFile["System.out"].println(counter) ; 
        var i : int ; i := 0 ; while i < num do ( (     res := res+(arr->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static List<List<Integer>>fullLIst ;
  static void perm(List<Integer>seed){
    List<Integer>list=new ArrayList<>(seed);
    boolean[] used=new boolean[seed.size()];
    build(seed,list,used,0);
  }
  static void build(List<Integer>seed,List<Integer>list,boolean[] used,int index){
    if(index==seed.size()){
      fullLIst.add(new ArrayList<>(list));
      return ;
    }
    for(int i=0 ; i<seed.size(); i++){
      if(used[i]){
        continue ;
      }
      else {
        list.set(index,seed.get(i));
        used[i]=true ;
        build(seed,list,used,index+1);
        used[i]=false ;
      }
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    List<Integer>sortedList=new ArrayList<>();
    int n=sc.nextInt();
    for(int i=1 ; i<=n ; i++){
      sortedList.add(i);
    }
    fullLIst=new ArrayList<>();
    Collections.sort(sortedList);
    perm(sortedList);
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<fullLIst.size(); i++){
      for(int j=0 ; j<fullLIst.get(i).size()-1 ; j++){
        sb.append(fullLIst.get(i).get(j));
        sb.append(' ');
      }
      sb.append(fullLIst.get(i).get(fullLIst.get(i).size()-1));
      sb.append('\n');
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute fullLIst : Sequence(Sequence(int));
  static   operation perm( seed : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{}->union(seed) ;
     var used : Sequence(boolean) ; used := Integer.subrange(1,seed->size())->collect(false) ;
     execute build(seed, list, used, 0) );
  static   operation build( seed : Sequence(int), list : Sequence(int), used : Sequence(boolean), index : int) : void
  pre: true
  post: true
  activity: (     if (index = seed->size()) then (     fullLIst := fullLIst->including(Sequence{}->union(list)) ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < seed->size() do ( (     if (used[i+1]) then (     continue ) else (     list := list.setAt(index+1,seed->at(i+1)) ; 
     used[i+1] := true ; 
     execute build(seed, list, used, index + 1) ; 
     used[i+1] := false ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sortedList : Sequence(int) ; sortedList := Sequence{} ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= n do ( (     sortedList := sortedList->including(i) )  ;     i := i + 1 ) ; 
    fullLIst := Sequence{} ; 
    sortedList := sortedList->sort() ; 
    execute perm(sortedList) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < fullLIst->size() do ( (         var j : int ; j := 0 ; while j < fullLIst->at(i+1)->size() - 1 do ( (     sb := sb + StringLib.newString(fullLIst->at(i+1)->at(j+1)) ; 
     sb := sb + StringLib.newString(' ') )  ;     j := j + 1 ) ; 
     sb := sb + StringLib.newString(fullLIst->at(i+1)->at(fullLIst->at(i+1)->size() - 1+1)) ; 
     sb := sb + StringLib.newString('
') )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int length=sc.nextInt();
      int[] nums=new int[length];
      for(int i=0 ; i<length ; i++){
        nums[i]=i+1 ;
      }
      permutation(nums,"");
    }
  }
  public static void permutation(int[] nums,String usedNums){
    if(nums.length==1){
      System.out.println(usedNums+nums[0]);
    }
    else {
      for(int i=0 ; i<nums.length ; i++){
        int[] pNums=new int[nums.length-1];
        System.arraycopy(nums,0,pNums,0,i);
        System.arraycopy(nums,i+1,pNums,i,nums.length-i-1);
        permutation(pNums,usedNums+nums[i]+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var length : int ; length := sc.getCurrent()->toInteger() ;
     var nums : Sequence(int) ; nums := Integer.subrange(1,length)->collect(0) ;
         var i : int ; i := 0 ; while i < length do ( (     nums[i+1] := i + 1 )  ;     i := i + 1 ) ; 
     execute permutation(nums, "") ))  );
  static   operation permutation( nums : Sequence(int), usedNums : String) : void
  pre: true
  post: true
  activity: (     if (nums->size() = 1) then (     OclFile["System.out"].println(usedNums + nums[0+1]) ) else (         var i : int ; i := 0 ; while i < nums->size() do ( (     var pNums : Sequence(int) ; pNums := Integer.subrange(1,nums->size() - 1)->collect(0) ;
     for _x : Integer.subrange(1,i) do pNums[0 + _x] := nums[0 + _x] ; 
     for _x : Integer.subrange(1,nums->size() - i - 1) do pNums[i + _x] := nums[i + 1 + _x] ; 
     execute permutation(pNums, usedNums + nums[i+1] + " ") )  ;     i := i + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static StringBuilder sb ;
  static List<List<Integer>>permutations ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sb=new StringBuilder();
    int num=sc.nextInt();
    ArrayList<Integer>array=new ArrayList<>();
    for(int i=0 ; i<num ; i++){
      array.add(i+1);
    }
    permutations=new ArrayList<List<Integer>>();
    permutation(array,new ArrayList<>());
    for(int i=0 ; i<permutations.size(); i++){
      printListWithWhiteSpace(permutations.get(i));
    }
    System.out.print(sb);
    sc.close();
  }
  public static void permutation(List<Integer>q,List<Integer>ans){
    if(q.size()<=1){
      List<Integer>tmp=new ArrayList<>();
      tmp.addAll(new ArrayList<>(ans));
      tmp.add(q.get(0));
      permutations.add(tmp);
    }
    else {
      for(int i=0 ; i<q.size(); i++){
        List<Integer>new_q=new ArrayList<>();
        new_q.addAll(new ArrayList<>(q.subList(0,i)));
        new_q.addAll(new ArrayList<>(q.subList(i+1,q.size())));
        List<Integer>new_ans=new ArrayList<>();
        new_ans.addAll(new ArrayList<>(ans));
        new_ans.add(q.get(i));
        permutation(new_q,new_ans);
      }
    }
  }
  public static void printListWithWhiteSpace(List<Integer>list){
    for(int i=0 ; i<list.size(); i++){
      sb.append(list.get(i));
      if(i!=list.size()-1)sb.append(' ');
      else sb.append("\n");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sb : String;
  static   attribute permutations : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     sb := StringLib.newString() ; 
    var num : int ; num := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Sequence{} ;
        var i : int ; i := 0 ; while i < num do ( (     array := array->including(i + 1) )  ;     i := i + 1 ) ; 
    permutations := Sequence{} ; 
    execute permutation(array, Sequence{}) ; 
        var i : int ; i := 0 ; while i < permutations->size() do ( (     execute printListWithWhiteSpace(permutations->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
    skip ; 
 );
  static   operation permutation( q : Sequence(int), ans : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (q->size() <= 1) then (     var tmp : Sequence(int) ; tmp := Sequence{} ;
     tmp := tmp->union(Sequence{}->union(ans)) ; 
     tmp := tmp->including(q->at(0+1)) ; 
     permutations := permutations->including(tmp) ) else (         var i : int ; i := 0 ; while i < q->size() do ( (     var new_q : Sequence(int) ; new_q := Sequence{} ;
     new_q := new_q->union(Sequence{}->union(q.subrange(0+1,i))) ; 
    new_q := new_q->union(Sequence{}->union(q.subrange(i + 1+1,q->size()))) ; 
    var new_ans : Sequence(int) ; new_ans := Sequence{} ;
    new_ans := new_ans->union(Sequence{}->union(ans)) ; 
    new_ans := new_ans->including(q->at(i+1)) ; 
    execute permutation(new_q, new_ans) ; 
 )  ;     i := i + 1 ) ) );
  static   operation printListWithWhiteSpace( list : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < list->size() do ( (     sb := sb + StringLib.newString(list->at(i+1)) ; 
     if (i /= list->size() - 1) then     sb := sb + StringLib.newString(' ') ; else     sb := sb + StringLib.newString("\n") ; )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner scan=new Scanner(System.in);
  public static void main(String[] args){
    int n=scan.nextInt();
    String str="" ;
    for(int i=1 ; i<=n ; i++){
      String str2=String.valueOf(i);
      str+=str2 ;
    }
    permutation(str,"");
  }
  public static void permutation(String q,String ans){
    if(q.length()<=1){
      if(ans.length()!=0)ans+=" " ;
      System.out.println(ans+q);
    }
    else {
      for(int i=0 ; i<q.length(); i++){
        if(ans.length()==0)permutation(q.substring(0,i)+q.substring(i+1),ans+q.charAt(i));
        else permutation(q.substring(0,i)+q.substring(i+1),ans+" "+q.charAt(i));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var str : String ; str := "" ;
         var i : int ; i := 1 ; while i <= n do ( (     var str2 : String ; str2 := ((i) + "") ;
     str := str+(str2) )  ;     i := i + 1 ) ; 
     execute permutation(str, "") );
  static   operation permutation( q : String, ans : String) : void
  pre: true
  post: true
  activity: (     if (q->size() <= 1) then (     if (ans->size() /= 0) then     ans := ans+(" ") ; else skip ; 
     OclFile["System.out"].println(ans + q) ) else (         var i : int ; i := 0 ; while i < q->size() do ( (     if (ans->size() = 0) then     execute permutation(q.subrange(0+1,i) + q.subrange(i + 1+1,i + 1), ans + q->at(i+1)) ; else     execute permutation(q.subrange(0+1,i) + q.subrange(i + 1+1,i + 1), ans + " " + q->at(i+1)) ; )  ;     i := i + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPowerOfTwo(int n){
    return n>0 &&((n &(n-1))==0);
  }
  static int findPosition(int n){
    if(! isPowerOfTwo(n))return-1 ;
    int count=0 ;
    while(n>0){
      n=n>>1 ;
++count ;
    }
    return count ;
  }
  public static void main(String[] args){
    int n=0 ;
    int pos=findPosition(n);
    if(pos==-1)System.out.println("n="+n+",Invalid number");
    else System.out.println("n="+n+",Position "+pos);
    n=12 ;
    pos=findPosition(n);
    if(pos==-1)System.out.println("n="+n+",Invalid number");
    else System.out.println("n="+n+",Position "+pos);
    n=128 ;
    pos=findPosition(n);
    if(pos==-1)System.out.println("n="+n+",Invalid number");
    else System.out.println("n="+n+",Position "+pos);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPowerOfTwo( n : int) : boolean
  pre: true
  post: true
  activity: (     return n > 0 & ((n & (n - 1)) = 0) );
  static   operation findPosition( n : int) : int
  pre: true
  post: true
  activity: (     if (not(isPowerOfTwo(n))) then     return -1 else skip ; 
     var count : int ; count := 0 ;
     while (n > 0) do (     n := (n/(2->pow(1)))->oclAsType(long) ; 
     count := count + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 0 ;
     var pos : int ; pos := findPosition(n) ;
    if (pos = -1) then     OclFile["System.out"].println("n=" + n + ",Invalid number") else     OclFile["System.out"].println("n=" + n + ",Position " + pos) ; ;  
    n := 12 ; 
    pos := findPosition(n) ; 
    if (pos = -1) then     OclFile["System.out"].println("n=" + n + ",Invalid number") else     OclFile["System.out"].println("n=" + n + ",Position " + pos) ; ;  
    n := 128 ; 
    pos := findPosition(n) ; 
    if (pos = -1) then     OclFile["System.out"].println("n=" + n + ",Invalid number") else     OclFile["System.out"].println("n=" + n + ",Position " + pos) ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int Log2n(int n){
    return(n>1)? 1+Log2n(n/2): 0 ;
  }
  static boolean isPowerOfTwo(int n){
    return n>0 &&((n &(n-1))==0);
  }
  static int findPosition(int n){
    if(! isPowerOfTwo(n))return-1 ;
    return Log2n(n)+1 ;
  }
  public static void main(String[] args){
    int n=0 ;
    int pos=findPosition(n);
    if(pos==-1)System.out.println("n="+n+",Invalid number ");
    else System.out.println("n="+n+",Position "+pos);
    n=12 ;
    pos=findPosition(n);
    if(pos==-1)System.out.println("n="+n+",Invalid number ");
    else System.out.println("n="+n+",Position "+pos);
    n=128 ;
    pos=findPosition(n);
    if(pos==-1)System.out.println("n="+n+",Invalid number ");
    else System.out.println("n="+n+",Position "+pos);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Log2n( n : int) : int
  pre: true
  post: true
  activity: (     return if (n > 1) then 1 + Log2n(n / 2) else 0 endif );
  static   operation isPowerOfTwo( n : int) : boolean
  pre: true
  post: true
  activity: (     return n > 0 & ((n & (n - 1)) = 0) );
  static   operation findPosition( n : int) : int
  pre: true
  post: true
  activity: (     if (not(isPowerOfTwo(n))) then     return -1 else skip ; 
     return Log2n(n) + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 0 ;
     var pos : int ; pos := findPosition(n) ;
    if (pos = -1) then     OclFile["System.out"].println("n=" + n + ",Invalid number ") else     OclFile["System.out"].println("n=" + n + ",Position " + pos) ; ;  
    n := 12 ; 
    pos := findPosition(n) ; 
    if (pos = -1) then     OclFile["System.out"].println("n=" + n + ",Invalid number ") else     OclFile["System.out"].println("n=" + n + ",Position " + pos) ; ;  
    n := 128 ; 
    pos := findPosition(n) ; 
    if (pos = -1) then     OclFile["System.out"].println("n=" + n + ",Invalid number ") else     OclFile["System.out"].println("n=" + n + ",Position " + pos) ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.Vector ;
class GFG {
  static void findfactors(int n){
    Vector<Integer>vec=new Vector<Integer>();
    for(int i=1 ; i*i<=n ; i++){
      if(n % i==0){
        vec.add(i);
        vec.add(n/i);
      }
    }
    Collections.sort(vec);
    System.out.println("All the factors are->");
    for(int i=0 ; i<vec.size(); i++){
      System.out.print(vec.get(i)+" ");
    }
    System.out.println();
    int maxProduct=1 ;
    boolean flag=true ;
    for(int i=0 ; i<vec.size(); i++){
      for(int j=i ; j<vec.size(); j++){
        for(int k=j ; k<vec.size(); k++){
          int y=n-vec.get(i)-vec.get(j)-vec.get(k);
          if(y<=0){
            break ;
          }
          if(n % y==0){
            flag=false ;
            maxProduct=Math.max(vec.get(i)*vec.get(j)*vec.get(k)*y,maxProduct);
          }
        }
      }
    }
    if(flag==false){
      System.out.println("Product is->"+maxProduct);
    }
    else {
      System.out.println("Not possible");
    }
  }
  public static void main(String[] args){
    int n ;
    n=50 ;
    findfactors(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findfactors( n : int) : void
  pre: true
  post: true
  activity: (     var vec : Sequence(int) ; vec := Sequence{} ;
         var i : int ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     vec := vec->including(i) ; 
     vec := vec->including(n / i) ) else skip )  ;     i := i + 1 ) ; 
    vec := vec->sort() ; 
    OclFile["System.out"].println("All the factors are->") ; 
        var i : int ; i := 0 ; while i < vec->size() do ( (     OclFile["System.out"].print(vec->at(i+1) + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    var maxProduct : int ; maxProduct := 1 ;
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < vec->size() do ( (         var j : int ; j := i ; while j < vec->size() do ( (         var k : int ; k := j ; while k < vec->size() do ( (     var y : int ; y := n - vec->at(i+1) - vec->at(j+1) - vec->at(k+1) ;
     if (y <= 0) then (     break ) else skip ; 
     if (n mod y = 0) then (     flag := false ; 
     maxProduct := Set{vec->at(i+1) * vec->at(j+1) * vec->at(k+1) * y, maxProduct}->max() ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (flag = false) then (     OclFile["System.out"].println("Product is->" + maxProduct) ) else (     OclFile["System.out"].println("Not possible") ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
     n := 50 ; 
     execute findfactors(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      String qwright="nmhjklyuiop" ;
      int n=sc.nextInt();
      String[] u=new String[n];
      for(int i=0 ; i<n ; i++){
        u[i]=sc.next();
      }
      int m=sc.nextInt();
      int flag=0 ;
      for(int i=0 ; i<m ; i++){
        String t=sc.next();
        for(int j=0 ; j<n ; j++){
          boolean look=false ;
          for(int k=0 ; k<n ; k++){
            if(u[k] .equals(t)){
              look=true ;
              break ;
            }
          }
          if(look){
            if(flag==0){
              System.out.println("Opened by "+t);
              flag=1 ;
              break ;
            }
            else if(flag==1){
              System.out.println("Closed by "+t);
              flag=0 ;
              break ;
            }
          }
          else {
            System.out.println("Unknown "+t);
            break ;
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var qwright : String ; qwright := "nmhjklyuiop" ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var u : Sequence(String) ; u := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     u[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var t : String ; t := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < n do ( (     var look : boolean ; look := false ;
         var k : int ; k := 0 ; while k < n do ( (     if (u[k+1] = t) then (     look := true ; 
     break ) else skip )  ;     k := k + 1 ) ; 
     if (look) then (     if (flag = 0) then (     OclFile["System.out"].println("Opened by " + t) ; 
     flag := 1 ; 
     break ) else     if (flag = 1) then (     OclFile["System.out"].println("Closed by " + t) ; 
     flag := 0 ; 
     break ) else skip ; ) else (     OclFile["System.out"].println("Unknown " + t) ; 
     break ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Stack ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=sc.nextInt();
    }
    Stack<Integer>st=new Stack<Integer>();
    int ans=-1 ;
    for(int i=0 ; i<n ; i++){
      if(st.isEmpty()){
        st.add(i);
        continue ;
      }
      while(! st.isEmpty()&& nums[st.peek()]<nums[i]){
        st.pop();
      }
      if(! st.isEmpty()){
        int pre=st.peek();
        ans=Math.max(ans,nums[pre] ^ nums[i]);
      }
      st.add(i);
    }
    st.clear();
    for(int i=n-1 ; i>=0 ; i--){
      if(st.isEmpty()){
        st.add(i);
        continue ;
      }
      while(! st.isEmpty()&& nums[st.peek()]<nums[i]){
        st.pop();
      }
      if(! st.isEmpty()){
        int pre=st.peek();
        ans=Math.max(ans,nums[i] ^ nums[pre]);
      }
      st.add(i);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var st : Sequence(int) ; st := Sequence{} ;
    var ans : int ; ans := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (st->isEmpty()) then (     st := st->including(i) ; 
     continue ) else skip ; 
     while (not(st->isEmpty()) & nums[st->min()+1] < nums[i+1]) do (     st := st->front() ) ; 
     if (not(st->isEmpty())) then (     var pre : int ; pre := st->min() ;
     ans := Set{ans, nums[pre+1] xor nums[i+1]}->max() ) else skip ; 
     st := st->including(i) )  ;     i := i + 1 ) ; 
    st := st->intersection(Set{}) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (st->isEmpty()) then (     st := st->including(i) ; 
     continue ) else skip ; 
     while (not(st->isEmpty()) & nums[st->min()+1] < nums[i+1]) do (     st := st->front() ) ; 
     if (not(st->isEmpty())) then (     var pre : int ; pre := st->min() ;
     ans := Set{ans, nums[i+1] xor nums[pre+1]}->max() ) else skip ; 
     st := st->including(i) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  public void run(){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      int cardNo=Integer.parseInt(br.readLine());
      String openFlg="0" ;
      ArrayList<String>cardList=new ArrayList<String>();
      for(int i=0 ; i<cardNo ; i++){
        cardList.add(br.readLine());
      }
      int touchNo=Integer.parseInt(br.readLine());
      for(int j=0 ; j<touchNo ; j++){
        String usr=br.readLine();
        if(! cardList.contains(usr)){
          System.out.println("Unknown "+usr);
        }
        else {
          if(openFlg.equals("1")){
            openFlg="0" ;
            System.out.println("Closed by "+usr);
          }
          else {
            openFlg="1" ;
            System.out.println("Opened by "+usr);
          }
        }
      }
    }
    catch(Exception e){
      e.getStackTrace();
      System.exit(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var cardNo : int ; cardNo := (br.readLine())->toInteger() ;
    var openFlg : String ; openFlg := "0" ;
    var cardList : Sequence(String) ; cardList := Sequence{} ;
        var i : int ; i := 0 ; while i < cardNo do ( (     cardList := cardList->including(br.readLine()) )  ;     i := i + 1 ) ; 
    var touchNo : int ; touchNo := (br.readLine())->toInteger() ;
        var j : int ; j := 0 ; while j < touchNo do ( (     var usr : String ; usr := br.readLine() ;
     if (not(cardList->includes(usr))) then (     OclFile["System.out"].println("Unknown " + usr) ) else (     if (openFlg = "1") then (     openFlg := "0" ; 
     OclFile["System.out"].println("Closed by " + usr) ) else (     openFlg := "1" ; 
     OclFile["System.out"].println("Opened by " + usr) ) ) )  ;     j := j + 1 ) ; 
 )   catch (e : ProgramException) do (     e.getStackTrace() ; 
 OclProcess.exit(0) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findSubSequence(String s,int num){
    int res=0 ;
    int i=0 ;
    while(num>0){
      if((num & 1)==1)res+=s.charAt(i)-'0' ;
      i++;
      num=num>>1 ;
    }
    return res ;
  }
  static int combinedSum(String s){
    int n=s.length();
    int c_sum=0 ;
    int range=(1<<n)-1 ;
    for(int i=0 ; i<=range ; i++)c_sum+=findSubSequence(s,i);
    return c_sum ;
  }
  public static void main(String[] args){
    String s="123" ;
    System.out.println(combinedSum(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSubSequence( s : String, num : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     var i : int ; i := 0 ;
     while (num > 0) do (     if ((num & 1) = 1) then     res := res+(s->at(i+1) - ('0')->char2byte()) ; else skip ; 
     i := i + 1 ; 
     num := (num/(2->pow(1)))->oclAsType(long) ) ; 
     return res );
  static   operation combinedSum( s : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var c_sum : int ; c_sum := 0 ;
    var range : int ; range := ((1*(2->pow(n)))->oclAsType(long)) - 1 ;
        var i : int ; i := 0 ; while i <= range do (     c_sum := c_sum+(findSubSequence(s, i)) ;  ;     i := i + 1 ) ; 
    return c_sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "123" ;
     OclFile["System.out"].println(combinedSum(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class class1 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String arg[]){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int d=input.nextInt();
    int e=input.nextInt();
    int ans=n ;
    for(int i=0 ; i*5*e<=n ; ++i){
      ans=Math.min(ans,(n-i*5*e)% d);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class class1 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var d : int ; d := input.getCurrent()->toInteger() ;
    var e : int ; e := input.getCurrent()->toInteger() ;
    var ans : int ; ans := n ;
        var i : int ; i := 0 ; while i * 5 * e <= n do ( (     ans := Set{ans, (n - i * 5 * e) mod d}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
import java.util.Set ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    int n=parseInt(br.readLine());
    Set<String>ids=new HashSet<String>();
    boolean lock=true ;
    for(int i=0 ; i<n ; i++){
      ids.add(br.readLine());
    }
    int m=parseInt(br.readLine());
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<m ; i++){
      String id=br.readLine();
      if(ids.contains(id)){
        if(lock){
          sb.append("Opened by "+id+"\n");
          lock=false ;
        }
        else {
          sb.append("Closed by "+id+"\n");
          lock=true ;
        }
      }
      else {
        sb.append("Unknown "+id+"\n");
      }
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var n : int ; n := parseInt(br.readLine()) ;
    var ids : Set(String) ; ids := Set{} ;
    var lock : boolean ; lock := true ;
        var i : int ; i := 0 ; while i < n do ( (     ids := ids->including(br.readLine()) )  ;     i := i + 1 ) ; 
    var m : int ; m := parseInt(br.readLine()) ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < m do ( (     var id : String ; id := br.readLine() ;
     if (ids->includes(id)) then (     if (lock) then (     sb := sb + StringLib.newString("Opened by " + id + "\n") ; 
     lock := false ) else (     sb := sb + StringLib.newString("Closed by " + id + "\n") ; 
     lock := true ) ) else (     sb := sb + StringLib.newString("Unknown " + id + "\n") ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Set ;
import java.util.Spliterator ;
import java.util.Spliterators ;
import java.util.concurrent.ThreadLocalRandom ;
import java.util.concurrent.atomic.AtomicInteger ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
import java.util.stream.Stream ;
import java.util.stream.StreamSupport ;
public class Main {
  static final Scanner s=new Scanner(System.in);
  static final long[] fal_rnd(int size){
    AtomicInteger l=new AtomicInteger(-1),r=new AtomicInteger(size);
    long[] res=new long[size];
    INS(size).unordered().parallel().mapToLong(Long :: parseLong).forEach(v->res[ThreadLocalRandom.current().nextBoolean()? l.incrementAndGet(): r.decrementAndGet()]=v);
    return res ;
  }
  static final IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static final Stream<String>INS(long size){
    return StreamSupport.stream(Spliterators.spliterator(s,size,Spliterator.NONNULL & Spliterator.IMMUTABLE),false).limit(size);
  }
  public static void main(String __[]){
    Set<String>set=INS(s.nextInt()).collect(Collectors.toSet());
    boolean isOpen=false ;
    for(int i=s.nextInt(); i>0 ; i--){
      String in=s.next();
      if(set.contains(in)){
        System.out.println((isOpen ? "Closed by " : "Opened by ")+in);
        isOpen ^=true ;
      }
      else {
        System.out.println("Unknown "+in);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    operation fal_rnd( size : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var l : int ; l := (-1) ;
    var r : int ; r := (size) ;
     var res : Sequence(long) ; res := Integer.subrange(1,size)->collect(0) ;
     for v : INS(size)->collect( _x1 | (lambda _s : String in _s->toLong())->apply(_x1) ) do
    (    res[if MathLib.nextBoolean() then l+1 else r-1 endif+1] := v) ; 
     return res );
  static    operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static    operation INS( size : long) : Stream<String>
  pre: true
  post: true
  activity: (     return (OclIterator.newOclIterator_Sequence(s)).elements.subrange(1,size) );
  static   operation main( __ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var set : Set(String) ; set := INS(s.getCurrent()->toInteger()).collect(Collectors.toSet()) ;
     var isOpen : boolean ; isOpen := false ;
         var i : int ; i := s.getCurrent()->toInteger() ; while i > 0 do ( (     var in : String ; in := s.getCurrent() ;
     if (set->includes(in)) then (     OclFile["System.out"].println((if isOpen then "Closed by " else "Opened by " endif) + in) ; 
     isOpen := MathLib.bitwiseXor(isOpen,true) ) else (     OclFile["System.out"].println("Unknown " + in) ) )  ;     i := i - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  Main(){
    sc=new Scanner(System.in);
  }
  int ni(){
    return sc.nextInt();
  }
  void run(){
    String[] l=new String[] {
      "Closed by ","Opened by " };
      int N=ni();
      HashSet<String>set=new HashSet<String>();
      for(int i=0 ; i<N ; ++i){
        set.add(sc.next());
      }
      int M=ni();
      int flag=0 ;
      for(int i=0 ; i<M ; ++i){
        String str=sc.next();
        if(set.contains(str)){
          flag=1-flag ;
          System.out.println(l[flag]+str);
        }
        else {
          System.out.println("Unknown "+str);
        }
      }
    }
    public static void main(String[] args){
      new Main().run();
    }
    void debug(Object...os){
      System.err.println(Arrays.deepToString(os));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
   operation run() : void
  pre: true
  post: true
  activity: (     var l : Sequence(String) ; l := Sequence{"Closed by ","Opened by "} ;
     var N : int ; N := ni() ;
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := 0 ; while i < N do ( (     set := set->including(sc.getCurrent()) )  ;     i := i + 1 ) ; 
    var M : int ; M := ni() ;
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     var str : String ; str := sc.getCurrent() ;
     if (set->includes(str)) then (     flag := 1 - flag ; 
     OclFile["System.out"].println(l[flag+1] + str) ) else (     OclFile["System.out"].println("Unknown " + str) ) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Writes {
  int number ;
  public Writes(int number){
    this.number=number ;
  }
  public int getNumber(){
    return number ;
  }
  public boolean contain(char s1,String s){
    boolean b=false ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)==s1){
        b=true ;
        break ;
      }
    }
    return b ;
  }
  public int numberCh(String s){
    int count=1 ;
    String s1=""+s.charAt(0);
    for(int i=1 ; i<s.length(); i++){
      if(contain(s.charAt(i),s1)==true){
      }
      else {
        count++;
        s1+=s.charAt(i);
      }
    }
    return count ;
  }
  public void input(String s){
    int count=0 ;
    for(int i=0 ; i<s.length(); i+=3){
      String s1 ;
      if(i+3>s.length()){
        s1=s.substring(i,s.length());
      }
      else {
        s1=s.substring(i,i+3);
      }
      count++;
      for(int k=i+3 ; k<s.length(); k++){
        if(contain(s.charAt(k),s1)){
          i++;
        }
        else if(numberCh(s1)<3){
          i++;
          s1+=s.charAt(k);
        }
        else {
          break ;
        }
      }
    }
    System.out.println(count);
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    Writes instance=new Writes(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      String s=input.next();
      instance.input(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Writes {
   attribute number : int;
   static operation newWrites( number : int) : Writes
  pre: true
  post: true
  activity:
  ( var self : Writes ;
    self := createWrites();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
   operation contain( s1 : String, s : String) : boolean
  pre: true
  post: true
  activity: (     var b : boolean ; b := false ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = s1) then (     b := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     return b );
   operation numberCh( s : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 1 ;
     var s1 : String ; s1 := "" + s->at(0+1) ;
         var i : int ; i := 1 ; while i < s->size() do ( (     if (contain(s->at(i+1), s1) = true) then skip else (     count := count + 1 ; 
     s1 := s1+(s->at(i+1)) ) )  ;     i := i + 1 ) ; 
     return count );
   operation input( s : String) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     var s1 : String ;
     if (i + 3 > s->size()) then (     s1 := s.subrange(i+1,s->size()) ) else (     s1 := s.subrange(i+1,i + 3) ) ;  
     count := count + 1 ; 
         var k : int ; k := i + 3 ; while k < s->size() do ( (     if (contain(s->at(k+1), s1)) then (     i := i + 1 ) else     if (numberCh(s1) < 3) then (     i := i + 1 ; 
     s1 := s1+(s->at(k+1)) ) else (     break ) ;  )  ;     k := k + 1 ) )  ;     i := i+(3) ) ; 
     OclFile["System.out"].println(count) );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
     var instance : Writes ; instance := Writes.newWrites(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var s : String ; s := input.getCurrent() ;
     instance.input(s) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.HashSet ;
import java.util.StringTokenizer ;
public class Solution {
  static PrintWriter pw ;
  static FastScanner s ;
  public static void main(String[] args)throws Exception {
    pw=new PrintWriter(System.out);
    s=new FastScanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      String str=s.next();
      HashSet<Character>hs=new HashSet<>();
      int days=0 ;
      for(int i=0 ; i<str.length(); i++){
        if(hs.size()<3){
          hs.add(str.charAt(i));
        }
        else {
          if(hs.contains(str.charAt(i)))continue ;
          days++;
          hs=new HashSet<>();
          hs.add(str.charAt(i));
        }
      }
      if(hs.size()>0)days++;
      pw.println(days);
    }
    pw.flush();
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public FastScanner(String s)throws Exception {
    br=new BufferedReader(new FileReader(new File(s)));
  }
  public String next()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(next());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute pw : OclFile;
  static   attribute s : FastScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     pw := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     s := FastScanner.newFastScanner(OclFile["System.in"]) ; 
    var t : int ; t := s.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var str : String ; str := s.next() ;
     var hs : Set(String) ; hs := Set{} ;
    var days : int ; days := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (hs->size() < 3) then (     hs := hs->including(str->at(i+1)) ) else (     if (hs->includes(str->at(i+1))) then     continue else skip ; 
     days := days + 1 ; 
     hs := Set{} ; 
     hs := hs->including(str->at(i+1)) ) )  ;     i := i + 1 ) ; 
    if (hs->size() > 0) then     days := days + 1 ; else skip ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class ques {
  int count=0 ;
  static void helper(String s){
    int i=0 ;
    int count=0 ;
    int ans=0 ;
    Map<Character,Integer>mp=new HashMap<>();
    int[] li=new int[s.length()];
    while(i<s.length()){
      if(mp.containsKey(s.charAt(i)));
      else {
        mp.put(s.charAt(i),1);
        count++;
      }
      if(count==3){
        ans++;
      }
      if(count==4){
        count=1 ;
        mp.clear();
        mp.put(s.charAt(i),1);
      }
      li[i]=count ;
      i++;
    }
    int pf=0 ;
    for(int j=1 ; j<s.length(); j++){
      if(li[j]==3 && li[j]!=li[j-1])pf++;
    }
    if(li[s.length()-1]==2 || li[s.length()-1]==1)pf++;
    System.out.println(pf);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int j=0 ; j<t ; j++){
      String s=sc.next();
      helper(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ques {
   attribute count : int := 0;
  static   operation helper( s : String) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var count : int ; count := 0 ;
    var ans : int ; ans := 0 ;
    var mp : Map(String,int) ; mp := Map{} ;
    var li : Sequence(int) ; li := Integer.subrange(1,s->size())->collect(0) ;
    while (i < s->size()) do (     if (mp->keys()->includes(s->at(i+1))) then  else (     mp := mp->union(Map{s->at(i+1) |-> 1}) ; 
     count := count + 1 ) ;  
     if (count = 3) then (     ans := ans + 1 ) else skip ; 
    if (count = 4) then (     count := 1 ; 
     mp := mp->intersection(Map{}) ; 
     mp := mp->union(Map{s->at(i+1) |-> 1}) ) else skip ; 
    li[i+1] := count ; 
    i := i + 1 ; 
 ) ; 
    var pf : int ; pf := 0 ;
        var j : int ; j := 1 ; while j < s->size() do ( (     if (li[j+1] = 3 & li[j+1] /= li[j - 1+1]) then     pf := pf + 1 ; else skip )  ;     j := j + 1 ) ; 
    if (li[s->size() - 1+1] = 2 or li[s->size() - 1+1] = 1) then     pf := pf + 1 ; else skip ; 
    OclFile["System.out"].println(pf) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var s : String ; s := sc.getCurrent() ;
     execute helper(s) )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test294 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      char a[]=in.next().toCharArray();
      char b[]=new char[3];
      int sum=1 ;
      for(int i=0 ; i<a.length ; i++){
        boolean x=true ;
        for(int k=0 ; k<3 ; k++){
          if(b[k]==a[i]){
            x=false ;
            break ;
          }
          else if(b[k]=='\0'){
            x=false ;
            b[k]=a[i];
            break ;
          }
        }
        if(x){
          b[0]=a[i];
          for(int k=1 ; k<3 ; k++){
            b[k]='\0' ;
          }
          sum++;
        }
      }
      System.out.println(sum);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test294 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var a : Sequence(String) ; a := in.getCurrent()->characters() ;
     var b : Sequence(String) ; b := Integer.subrange(1,3)->collect(0) ;
    var sum : int ; sum := 1 ;
        var i : int ; i := 0 ; while i < a->size() do ( (     var x : boolean ; x := true ;
         var k : int ; k := 0 ; while k < 3 do ( (     if (b[k+1] = a[i+1]) then (     x := false ; 
     break ) else     if (b[k+1] = '\0') then (     x := false ; 
     b[k+1] := a[i+1] ; 
     break ) else skip ; )  ;     k := k + 1 ) ; 
     if (x) then (     b[0+1] := a[i+1] ; 
         var k : int ; k := 1 ; while k < 3 do ( (     b[k+1] := '\0' )  ;     k := k + 1 ) ; 
     sum := sum + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void EvenOddLength(int arr[],int n){
    int even=0 ;
    for(int i=0 ; i<n ; i++){
      String x=Integer.toString(arr[i]);
      if(x.length()% 2==0)even++;
    }
    System.out.println("Number of even length elements="+even);
    System.out.println("Number of odd length elements="+(n-even));
  }
  public static void main(String args[]){
    int arr[]={
      12,44,213,232,3433 };
      int n=arr.length ;
      EvenOddLength(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation EvenOddLength( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var even : int ; even := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var x : String ; x := ((arr[i+1]) + "") ;
     if (x->size() mod 2 = 0) then     even := even + 1 ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Number of even length elements=" + even) ; 
     OclFile["System.out"].println("Number of odd length elements=" + (n - even)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,44,213,232,3433} ;
     var n : int ; n := arr->size() ;
     execute EvenOddLength(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=input.nextInt();
    int r=0 ;
    for(int i=1 ; i<10 ; i++){
      int x=(int)((Math.pow(2,i)-1)*Math.pow(2,i-1));
      if(n % x==0){
        r=x ;
      }
    }
    pw.println(r);
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := input.getCurrent()->toInteger() ;
    var r : int ; r := 0 ;
        var i : int ; i := 1 ; while i < 10 do ( (     var x : int ; x := ((2->pow(i) - 1) * 2->pow(i - 1))->oclAsType(int) ;
     if (n mod x = 0) then (     r := x ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int find_digit(String s,int n){
    int first_digit=-1 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(s.charAt(i)<'0' || s.charAt(i)>'9'){
        first_digit=i ;
        break ;
      }
    }
    first_digit++;
    int s_len=first_digit ;
    int num=0,pw=1 ;
    int i=n-1 ;
    while(i>=0){
      if(s.charAt(i)>='0' && s.charAt(i)<='9'){
        int digit=s.charAt(i)-'0' ;
        num=num+(pw*digit);
        if(num>=s_len)return-1 ;
        pw=pw*10 ;
      }
      i--;
    }
    num=num*10 ;
    int req=s_len-num ;
    if(req>9 || req<0)return-1 ;
    return req ;
  }
  public static void main(String[] args){
    String s="abcd0" ;
    int n=s.length();
    System.out.print(find_digit(s,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation find_digit( s : String, n : int) : int
  pre: true
  post: true
  activity: (     var first_digit : int ; first_digit := -1 ;
         var i : int ; i := n - 1 ; while i >= 0 do ( (     if (s->at(i+1) < '0' or s->at(i+1) > '9') then (     first_digit := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    first_digit := first_digit + 1 ; 
    var s_len : int ; s_len := first_digit ;
    var num : int ; num := 0 ;
    var pw : int ; pw := 1 ;
    var i : int ; i := n - 1 ;
    while (i >= 0) do (     if (s->at(i+1) >= '0' & s->at(i+1) <= '9') then (     var digit : int ; digit := s->at(i+1) - ('0')->char2byte() ;
     num := num + (pw * digit) ; 
     if (num >= s_len) then     return -1 else skip ; 
     pw := pw * 10 ) else skip ; 
     i := i - 1 ) ; 
    num := num * 10 ; 
    var req : int ; req := s_len - num ;
    if (req > 9 or req < 0) then     return -1 else skip ; 
    return req 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abcd0" ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].print(find_digit(s, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class class1 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String arg[]){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int d=input.nextInt();
    int e=input.nextInt();
    int ans=n ;
    for(int i=0 ; i*5*e<=n ; ++i){
      ans=Math.min(ans,(n-i*5*e)% d);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class class1 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var d : int ; d := input.getCurrent()->toInteger() ;
    var e : int ; e := input.getCurrent()->toInteger() ;
    var ans : int ; ans := n ;
        var i : int ; i := 0 ; while i * 5 * e <= n do ( (     ans := Set{ans, (n - i * 5 * e) mod d}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class _893B {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader sc=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    int n=sc.nextInt();
    int ans=0 ;
    for(int k=1 ; k<=16 ; k++){
      int x=((1<<k)-1)*(1<<(k-1));
      if(n % x==0)ans=x ;
    }
    System.out.println(ans);
  }
  public static int gcd(int a,int b){
    return(a==0)? b : gcd(b % a,a);
  }
  public static List<Integer>sieve(int n){
    List<Integer>primes=new LinkedList<>();
    boolean[] composite=new boolean[n+1];
    for(int i=2 ; i*i<=n ; i++)for(int j=i*i ; j<=n && ! composite[i]; j+=i)composite[j]=true ;
    for(int j=2 ; j<composite.length ; j++)if(! composite[j])primes.add(j);
    return primes ;
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _893B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var sc : InputReader ; sc := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var n : int ; n := sc.nextInt() ;
    var ans : int ; ans := 0 ;
        var k : int ; k := 1 ; while k <= 16 do ( (     var x : int ; x := (((1*(2->pow(k)))->oclAsType(long)) - 1) * ((1*(2->pow((k - 1))))->oclAsType(long)) ;
     if (n mod x = 0) then     ans := x ; else skip )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if (a = 0) then b else gcd(b mod a, a) endif );
  static   operation sieve( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var primes : Sequence(int) ; primes := Sequence{} ;
     var composite : Sequence(boolean) ; composite := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 2 ; while i * i <= n do (         var j : int ; j := i * i ; while j <= n & not(composite[i+1]) do (     composite[j+1] := true ;  ;     j := j+(i) ) ;  ;     i := i + 1 ) ; 
        var j : int ; j := 2 ; while j < composite->size() do (     if (not(composite[j+1])) then     primes := primes->including(j) ; else skip ;  ;     j := j + 1 ) ; 
    return primes 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.util.Collections ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BKThCommonDivisor solver=new BKThCommonDivisor();
    solver.solve(1,in,out);
    out.close();
  }
  static class BKThCommonDivisor {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int a=in.nextInt();
      int b=in.nextInt();
      int k=in.nextInt();
      ArrayList<Integer>array=new ArrayList<>();
      int gcd=1 ;
      int index=0 ;
      for(int i=1 ; i<=a && i<=b ; ++i){
        if(a % i==0 && b % i==0){
          gcd=i ;
          array.add(gcd);
          index++;
        }
      }
      Collections.sort(array);
      ArrayList<Integer>crray=new ArrayList<>();
      for(int i=array.size()-1 ; i>=0 ; i--){
        int x=array.get(i);
        crray.add(x);
      }
      out.println(crray.get(k-1));
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BKThCommonDivisor ; solver := BKThCommonDivisor.newBKThCommonDivisor() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BKThCommonDivisor {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.nextInt() ;
     var b : int ; b := in.nextInt() ;
    var k : int ; k := in.nextInt() ;
    var array : Sequence(int) ; array := Sequence{} ;
    var gcd : int ; gcd := 1 ;
    var index : int ; index := 0 ;
        var i : int ; i := 1 ; while i <= a & i <= b do ( (     if (a mod i = 0 & b mod i = 0) then (     gcd := i ; 
     array := array->including(gcd) ; 
     index := index + 1 ) else skip )  ;     i := i + 1 ) ; 
    array := array->sort() ; 
    var crray : Sequence(int) ; crray := Sequence{} ;
        var i : int ; i := array->size() - 1 ; while i >= 0 do ( (     var x : int ; x := array->at(i+1) ;
     crray := crray->including(x) )  ;     i := i - 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new InputStreamReader(System.in));
        st=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
        e.printStackTrace();
      }
    }
    public String next(){
      if(st.hasMoreTokens())return st.nextToken();
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      String line="" ;
      if(st.hasMoreTokens())line=st.nextToken();
      else try {
        return br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      while(st.hasMoreTokens())line+=" "+st.nextToken();
      return line ;
    }
  }
  public static void main(String[] args){
    FastScanner sc=new FastScanner();
    PrintWriter pw=new PrintWriter(System.out);
    int a=sc.nextInt(),b=sc.nextInt(),k=sc.nextInt();
    int small=Math.min(a,b);
    int cnt=0 ;
    for(int i=small ; i>=1 ; i--){
      if(a % i==0 && b % i==0){
        cnt++;
      }
      if(cnt==k){
        pw.println(i);
        break ;
      }
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     if (st.hasNext()) then     return st.next() else skip ; 
     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     e.printStackTrace() )
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var line : String ; line := "" ;
     if (st.hasNext()) then     line := st.next() else     try (     return br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
 ;  
     while (st.hasNext()) do     line := line+(" " + st.next()) ; ; 
     return line );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner() ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : int ; a := sc.nextInt() ;
    var b : int ; b := sc.nextInt() ;
    var k : int ; k := sc.nextInt() ;
    var small : int ; small := Set{a, b}->min() ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := small ; while i >= 1 do ( (     if (a mod i = 0 & b mod i = 0) then (     cnt := cnt + 1 ) else skip ; 
     if (cnt = k) then (     skip ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Comparator ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  static int gcd(int a,int b){
    if(a<b){
      int t=a ;
      a=b ;
      b=t ;
    }
    if(a % b==0){
      return b ;
    }
    return gcd(a,a % b);
  }
  public static void main(String[] args){
    Scanner std=new Scanner(System.in);
    int A=std.nextInt();
    int B=std.nextInt();
    int K=std.nextInt();
    int a=gcd(A,B);
    PriorityQueue<Integer>pq=new PriorityQueue<>(Comparator.reverseOrder());
    for(int i=1 ; i<=a ; i++){
      if(a % i==0){
        pq.add(i);
      }
    }
    int value=0 ;
    for(int i=0 ; i<K ; i++){
      value=pq.poll();
    }
    System.out.println(value);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a < b) then (     var t : int ; t := a ;
     a := b ; 
     b := t ) else skip ; 
     if (a mod b = 0) then (     return b ) else skip ; 
     return gcd(a, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var std : OclFile ; std := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := std.getCurrent()->toInteger() ;
    var B : int ; B := std.getCurrent()->toInteger() ;
    var K : int ; K := std.getCurrent()->toInteger() ;
    var a : int ; a := gcd(A, B) ;
    var pq : Sequence(int) ; pq := Sequence{}->union(Comparator.reverseOrder()) ;
        var i : int ; i := 1 ; while i <= a do ( (     if (a mod i = 0) then (     pq := pq->including(i) ) else skip )  ;     i := i + 1 ) ; 
    var value : int ; value := 0 ;
        var i : int ; i := 0 ; while i < K do ( (     value := pq->min() ;     pq := pq->sort()->tail() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(value) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int A=Integer.parseInt(sc.next());
      int B=Integer.parseInt(sc.next());
      int K=Integer.parseInt(sc.next());
      List<Integer>l=new ArrayList<Integer>();
      for(int i=1 ; i<=Math.min(A,B); i++){
        if(A % i==0 && B % i==0){
          l.add(0,i);
        }
      }
      System.out.println(l.get(K-1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var A : int ; A := (sc.getCurrent())->toInteger() ;
     var B : int ; B := (sc.getCurrent())->toInteger() ;
    var K : int ; K := (sc.getCurrent())->toInteger() ;
    var l : Sequence(int) ; l := Sequence{} ;
        var i : int ; i := 1 ; while i <= Set{A, B}->min() do ( (     if (A mod i = 0 & B mod i = 0) then (     l := l.insertAt(0+1,i) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(l->at(K - 1+1)) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner cin=new Scanner(System.in);
    int a=cin.nextInt();
    int b=cin.nextInt();
    int c=cin.nextInt();
    int d=a<b ? a : b ;
    ArrayList<Integer>factor=new ArrayList<>();
    for(int i=1 ; i<=d ; i++){
      if(a % i==0 && b % i==0)factor.add(i);
    }
    Collections.sort(factor,Collections.reverseOrder());
    System.out.println(factor.get(c-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := cin.getCurrent()->toInteger() ;
    var b : int ; b := cin.getCurrent()->toInteger() ;
    var c : int ; c := cin.getCurrent()->toInteger() ;
    var d : int ; d := if a < b then a else b endif ;
    var factor : Sequence(int) ; factor := Sequence{} ;
        var i : int ; i := 1 ; while i <= d do ( (     if (a mod i = 0 & b mod i = 0) then     factor := factor->including(i) ; else skip )  ;     i := i + 1 ) ; 
    factor, reverseOrder() := factor, reverseOrder()->sort() ; 
    OclFile["System.out"].println(factor->at(c - 1+1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int w=sc.nextInt();
    int h=sc.nextInt();
    PriorityQueue<Integer>queue=new PriorityQueue<>();
    for(int i=0 ; i<w ; i++){
      queue.add(-sc.nextInt());
    }
    PriorityQueue<Integer>next=new PriorityQueue<>();
    for(int i=0 ; i<h ; i++){
      int count=sc.nextInt();
      for(int j=0 ; j<w ; j++){
        if(j<count){
          if(queue.peek()==0){
            System.out.println(0);
            return ;
          }
          next.add(queue.poll()+1);
        }
        else {
          next.add(queue.poll());
        }
      }
      PriorityQueue<Integer>tmp=next ;
      next=queue ;
      queue=tmp ;
    }
    if(queue.peek()!=0){
      System.out.println(0);
    }
    else {
      System.out.println(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var queue : Sequence(int) ; queue := Sequence{} ;
        var i : int ; i := 0 ; while i < w do ( (     queue := queue->including(-sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var next : Sequence(int) ; next := Sequence{} ;
        var i : int ; i := 0 ; while i < h do ( (     var count : int ; count := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < w do ( (     if (j < count) then (     if (queue->min() = 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
     next := next->including(queue->min() + 1) ) else (     next := next->including(queue->min()) ) )  ;     j := j + 1 ) ; 
    var tmp : Sequence(int) ; tmp := next ;
    next := queue ; 
    queue := tmp ; 
 )  ;     i := i + 1 ) ; 
    if (queue->min() /= 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int w=sc.nextInt(),h=sc.nextInt();
    int[] aw=new int[w],bh=new int[h];
    for(int i=0 ; i<w ; i++){
      aw[i]=sc.nextInt();
    }
    for(int i=0 ; i<h ; i++){
      bh[i]=sc.nextInt();
    }
    PriorityQueue<Integer>queue=new PriorityQueue<>(Comparator.reverseOrder());
    for(int i=0 ; i<w ; i++){
      queue.add(aw[i]);
    }
    Arrays.sort(bh);
    for(int back=h-1 ; back>=0 ; back--){
      int pushCnt=bh[back];
      int[] tmp=new int[pushCnt];
      for(int i=0 ; i<pushCnt ; i++){
        tmp[i]=queue.poll()-1 ;
      }
      if(Arrays.stream(tmp).anyMatch(value->value<0)){
        System.out.println(0);
        return ;
      }
      for(int i : tmp){
        queue.add(i);
      }
    }
    System.out.println(1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var aw : Sequence(int) ; aw := Integer.subrange(1,w)->collect(0) ;
    var bh : Sequence(int) ; bh := Integer.subrange(1,h)->collect(0) ;
        var i : int ; i := 0 ; while i < w do ( (     aw[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < h do ( (     bh[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var queue : Sequence(int) ; queue := Sequence{}->union(Comparator.reverseOrder()) ;
        var i : int ; i := 0 ; while i < w do ( (     queue := queue->including(aw[i+1]) )  ;     i := i + 1 ) ; 
    bh := bh->sort() ; 
        var back : int ; back := h - 1 ; while back >= 0 do ( (     var pushCnt : int ; pushCnt := bh[back+1] ;
     var tmp : Sequence(int) ; tmp := Integer.subrange(1,pushCnt)->collect(0) ;
        var i : int ; i := 0 ; while i < pushCnt do ( (     tmp[i+1] := queue->min() - 1 )  ;     i := i + 1 ) ; 
    if (stream(tmp)->exists( _x2 | (lambda value : OclAny in value < 0)->apply(_x2) )) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    for (i : tmp) do ( (     queue := queue->including(i) )  ) ; 
 )  ;     back := back - 1 ) ; 
    OclFile["System.out"].println(1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int w=sc.nextInt();
    int h=sc.nextInt();
    Integer[] col=new Integer[w];
    Integer[] row=new Integer[h];
    int sumC=0,sumR=0 ;
    for(int i=0 ; i<w ; ++i){
      col[i]=sc.nextInt();
      sumC+=col[i];
    }
    for(int i=0 ; i<h ; ++i){
      row[i]=sc.nextInt();
      sumR+=row[i];
    }
    if(sumR!=sumC){
      System.out.println("0");
      return ;
    }
    for(int i=0 ; i<w ; ++i){
      Arrays.sort(row,Comparator.reverseOrder());
      for(int j=0 ; j<h ; ++j){
        if(col[i]==0 || row[j]==0)break ;
--row[j];
--col[i];
      }
      if(col[i]>0){
        System.out.println("0");
        return ;
      }
    }
    System.out.println("1");
  }
  public static void main(String[] a){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var col : Sequence(int) ; col := Integer.subrange(1,w)->collect(null) ;
    var row : Sequence(int) ; row := Integer.subrange(1,h)->collect(null) ;
    var sumC : int ; sumC := 0 ;
    var sumR : int ; sumR := 0 ;
        var i : int ; i := 0 ; while i < w do ( (     col[i+1] := sc.getCurrent()->toInteger() ; 
     sumC := sumC+(col[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < h do ( (     row[i+1] := sc.getCurrent()->toInteger() ; 
     sumR := sumR+(row[i+1]) )  ;     i := i + 1 ) ; 
    if (sumR /= sumC) then (     OclFile["System.out"].println("0") ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < w do ( (     row := OclComparator.sortWith(row, Comparator.reverseOrder()) ; 
         var j : int ; j := 0 ; while j < h do ( (     if (col[i+1] = 0 or row[j+1] = 0) then     break else skip ; 
     row[j+1] := row[j+1] - 1 ; 
     col[i+1] := col[i+1] - 1 )  ;     j := j + 1 ) ; 
     if (col[i+1] > 0) then (     OclFile["System.out"].println("0") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("1") ; 
 );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static char flip(char ch){
    return(ch=='0')? '1' : '0' ;
  }
  public static int getFlipWithStartingCharcter(String str,char expected){
    int flipCount=0 ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)!=expected)flipCount++;
      expected=flip(expected);
    }
    return flipCount ;
  }
  public static int minFlipToMakeStringAlternate(String str){
    return Math.min(getFlipWithStartingCharcter(str,'0'),getFlipWithStartingCharcter(str,'1'));
  }
  public static void main(String args[]){
    String str="0001010111" ;
    System.out.println(minFlipToMakeStringAlternate(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation flip( ch : String) : String
  pre: true
  post: true
  activity: (     return if (ch = '0') then '1' else '0' endif );
  static   operation getFlipWithStartingCharcter( str : String, expected : String) : int
  pre: true
  post: true
  activity: (     var flipCount : int ; flipCount := 0 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) /= expected) then     flipCount := flipCount + 1 ; else skip ; 
     expected := flip(expected) )  ;     i := i + 1 ) ; 
     return flipCount );
  static   operation minFlipToMakeStringAlternate( str : String) : int
  pre: true
  post: true
  activity: (     return Set{getFlipWithStartingCharcter(str, '0'), getFlipWithStartingCharcter(str, '1')}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "0001010111" ;
     OclFile["System.out"].println(minFlipToMakeStringAlternate(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    long n=fs.nextInt(),d=fs.nextInt(),e=fs.nextInt()*5 ;
    long min=n ;
    for(int i=0 ; i<600 ; i++){
      if(n<e*i)break ;
      long left=n-e*i ;
      left %=d ;
      min=Math.min(min,left);
    }
    System.out.println(min);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var n : long ; n := fs.nextInt() ;
    var d : long ; d := fs.nextInt() ;
    var e : long ; e := fs.nextInt() * 5 ;
    var min : long ; min := n ;
        var i : int ; i := 0 ; while i < 600 do ( (     if (n < e * i) then     break else skip ; 
     var left : long ; left := n - e * i ;
     left := left mod d ; 
     min := Set{min, left}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader()throws IOException {
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public FastReader(String s)throws IOException {
      br=new BufferedReader(new FileReader(new File(s)));
    }
    String next(){
      while(st==null || ! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(Exception e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return str ;
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
  public static void main(String[] args)throws IOException {
    FastReader in=new FastReader();
    int n=in.nextInt();
    int m=in.nextInt();
    int k=in.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=in.nextInt();
    if(n % 2==0)System.out.println(0);
    else {
      int b=a[0];
      for(int i=2 ; i<n ; i+=2)b=Math.min(a[i],b);
      System.out.println(Math.min(b,1L*m/((n+1)/2)*k));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   static operation newFastReader( s : String) : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return str );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var n : int ; n := in.nextInt() ;
    var m : int ; m := in.nextInt() ;
    var k : int ; k := in.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.nextInt() ;  ;     i := i + 1 ) ; 
    if (n mod 2 = 0) then     OclFile["System.out"].println(0) else (     var b : int ; b := a[0+1] ;
         var i : int ; i := 2 ; while i < n do (     b := Set{a[i+1], b}->min() ;  ;     i := i+(2) ) ; 
     OclFile["System.out"].println(Set{b, 1L * m / ((n + 1) / 2) * k}->min()) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.concurrent.LinkedBlockingDeque ;
import java.lang.*;
public class Grasshopper {
  public static void main(String[] args)throws Exception {
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int jump=scan.nextInt();
    scan.nextLine();
    int start=-1,target=-1 ;
    char[] str=scan.nextLine().toCharArray();
    for(int i=0 ; i<n ; i++){
      if(str[i]=='G')start=i ;
      else if(str[i]=='T')target=i ;
    }
    Queue<Integer>q=new LinkedList<>();
    boolean[] visited=new boolean[n];
    q.add(start);
    while(! q.isEmpty()){
      int curr=q.remove();
      if(visited[curr])continue ;
      if(curr==target){
        System.out.println("YES");
        return ;
      }
      visited[curr]=true ;
      if(curr+jump<n && ! visited[curr+jump] && str[curr+jump]!='#'){
        q.add(curr+jump);
      }
      if(curr-jump>=0 && ! visited[curr-jump] && str[curr-jump]!='#'){
        q.add(curr-jump);
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Grasshopper {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var jump : int ; jump := scan.getCurrent()->toInteger() ;
    skip ; 
    var start : int ; start := -1 ;
    var target : int ; target := -1 ;
    var str : Sequence(String) ; str := scan.nextLine()->characters() ;
        var i : int ; i := 0 ; while i < n do ( (     if (str[i+1] = 'G') then     start := i ; else     if (str[i+1] = 'T') then     target := i ; else skip ; )  ;     i := i + 1 ) ; 
    var q : Sequence(int) ; q := Sequence{} ;
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,n)->collect(false) ;
    q := q->including(start) ; 
    while (not(q->isEmpty())) do (     var curr : int ; curr := q.remove() ;
     if (visited[curr+1]) then     continue else skip ; 
    if (curr = target) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
    visited[curr+1] := true ; 
    if (curr + jump < n & not(visited[curr + jump+1]) & str[curr + jump+1] /= '#') then (     q := q->including(curr + jump) ) else skip ; 
    if (curr - jump >= 0 & not(visited[curr - jump+1]) & str[curr - jump+1] /= '#') then (     q := q->including(curr - jump) ) else skip ; 
 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.rmi.server.RemoteServer ;
import java.security.cert.CollectionCertStoreParameters ;
import java.util.*;
public class A_Ostap_and_Grasshopper {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int k=s.nextInt();
    String str=s.next();
    int indT=0,indG=0 ;
    for(int i=0 ; i<n ; i++){
      if(str.charAt(i)=='G'){
        indG=i ;
      }
      else if(str.charAt(i)=='T'){
        indT=i ;
      }
    }
    int b=0 ;
    if(indG<indT)for(int i=indG ;
    i<=indT ;
    i+=k){
      if(str.charAt(i)=='#'){
        b=-1 ;
        break ;
      }
      else if(str.charAt(i)=='T')b=1 ;
    }
    else {
      for(int i=indG ; i>=indT ; i-=k){
        if(str.charAt(i)=='#'){
          b=-1 ;
          break ;
        }
        else if(str.charAt(i)=='T')b=1 ;
      }
    }
    if(b==-1 || b==0)System.out.println("NO");
    else System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Ostap_and_Grasshopper {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var k : int ; k := s.getCurrent()->toInteger() ;
    var str : String ; str := s.getCurrent() ;
    var indT : int ; indT := 0 ;
    var indG : int ; indG := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (str->at(i+1) = 'G') then (     indG := i ) else     if (str->at(i+1) = 'T') then (     indT := i ) else skip ; )  ;     i := i + 1 ) ; 
    var b : int ; b := 0 ;
    if (indG < indT) then         var i : int ; i := indG ; while i <= indT do ( (     if (str->at(i+1) = '#') then (     b := -1 ; 
     break ) else     if (str->at(i+1) = 'T') then     b := 1 ; else skip ; )  ;     i := i+(k) ) else (         var i : int ; i := indG ; while i >= indT do ( (     if (str->at(i+1) = '#') then (     b := -1 ; 
     break ) else     if (str->at(i+1) = 'T') then     b := 1 ; else skip ; )  ;     i := i-(k) ) ) ;  
    if (b = -1 or b = 0) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.abs ;
import java.util.Scanner ;
public class Grasshopper735 {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int cell=in.nextInt();
    int jump=in.nextInt();
    String str=in.next();
    int g=0,t=0 ;
    String ans="NO" ;
    for(int i=0 ; i<cell ; i++){
      if(str.charAt(i)=='G')g=i+1 ;
      if(str.charAt(i)=='T')t=i+1 ;
    }
    if((abs(g-t)% jump!=0)){
      System.out.println(ans);
      return ;
    }
    if(g>t){
      for(int j=g-1 ; j>t-1 ; j-=jump){
        if(str.charAt(j)=='#'){
          System.out.println(ans);
          return ;
        }
      }
    }
    if(g<t){
      for(int j=g-1 ; j<t-1 ; j+=jump){
        if(str.charAt(j)=='#'){
          System.out.println(ans);
          return ;
        }
      }
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Grasshopper735 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cell : int ; cell := in.getCurrent()->toInteger() ;
    var jump : int ; jump := in.getCurrent()->toInteger() ;
    var str : String ; str := in.getCurrent() ;
    var g : int ; g := 0 ;
    var t : int ; t := 0 ;
    var ans : String ; ans := "NO" ;
        var i : int ; i := 0 ; while i < cell do ( (     if (str->at(i+1) = 'G') then     g := i + 1 ; else skip ; 
     if (str->at(i+1) = 'T') then     t := i + 1 ; else skip )  ;     i := i + 1 ) ; 
    if ((abs((g)->char2byte() - (t)->char2byte()) mod jump /= 0)) then (     OclFile["System.out"].println(ans) ; 
     return ) else skip ; 
    if (g > t) then (         var j : int ; j := (g)->char2byte() - 1 ; while j > (t)->char2byte() - 1 do ( (     if (str->at(j+1) = '#') then (     OclFile["System.out"].println(ans) ; 
     return ) else skip )  ;     j := j-(jump) ) ) else skip ; 
    if (g < t) then (         var j : int ; j := (g)->char2byte() - 1 ; while j < (t)->char2byte() - 1 do ( (     if (str->at(j+1) = '#') then (     OclFile["System.out"].println(ans) ; 
     return ) else skip )  ;     j := j+(jump) ) ) else skip ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class OstapNGrassHopper {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String nAndkLine=in.nextLine();
    Scanner lineSc=new Scanner(nAndkLine);
    int n=lineSc.nextInt();
    int k=lineSc.nextInt();
    String line=in.nextLine();
    int startPos=line.indexOf("G");
    int i=startPos ;
    while(i>=0){
      if(line.charAt(i)=='T'){
        System.out.println("YES");
        return ;
      }
      else if(line.charAt(i)=='#'){
        break ;
      }
      i-=k ;
    }
    i=startPos ;
    while(i<line.length()){
      if(line.charAt(i)=='T'){
        System.out.println("YES");
        return ;
      }
      else if(line.charAt(i)=='#'){
        System.out.println("NO");
        return ;
      }
      i+=k ;
    }
    System.out.println("NO");
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class OstapNGrassHopper {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var nAndkLine : String ; nAndkLine := in.nextLine() ;
    var lineSc : OclFile ; lineSc := OclFile.newOclFile_Read(OclFile.newOclFile(nAndkLine)) ;
    var n : int ; n := lineSc.getCurrent()->toInteger() ;
    var k : int ; k := lineSc.getCurrent()->toInteger() ;
    var line : String ; line := in.nextLine() ;
    var startPos : int ; startPos := line->indexOf("G")-1 ;
    var i : int ; i := startPos ;
    while (i >= 0) do (     if (line->at(i+1) = 'T') then (     OclFile["System.out"].println("YES") ; 
     return ) else     if (line->at(i+1) = '#') then (     break ) else skip ; ;  
     i := i-(k) ) ; 
    i := startPos ; 
    while (i < line->size()) do (     if (line->at(i+1) = 'T') then (     OclFile["System.out"].println("YES") ; 
     return ) else     if (line->at(i+1) = '#') then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; ;  
     i := i+(k) ) ; 
    OclFile["System.out"].println("NO") ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TrickyAlchemy_912A {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    long A=input.nextInt(),B=input.nextInt();
    long x=input.nextInt(),y=input.nextInt(),z=input.nextInt();
    B-=z*3 ;
    A-=x*2 ;
    A-=y ;
    B-=y ;
    boolean fA=false,fB=false ;
    if(A<0){
      A=Math.abs(A);
      fA=true ;
    }
    if(B<0){
      B=Math.abs(B);
      fB=true ;
    }
    if(fA && fB)System.out.println(A+B);
    else if(fA)System.out.println(A);
    else if(fB)System.out.println(B);
    else System.out.println(0);
    input.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class TrickyAlchemy_912A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : long ; A := input.getCurrent()->toInteger() ;
    var B : long ; B := input.getCurrent()->toInteger() ;
    var x : long ; x := input.getCurrent()->toInteger() ;
    var y : long ; y := input.getCurrent()->toInteger() ;
    var z : long ; z := input.getCurrent()->toInteger() ;
    B := B-(z * 3) ; 
    A := A-(x * 2) ; 
    A := A-(y) ; 
    B := B-(y) ; 
    var fA : boolean ; fA := false ;
    var fB : boolean ; fB := false ;
    if (A < 0) then (     A := if A < 0 then -(A) else A endif ; 
     fA := true ) else skip ; 
    if (B < 0) then (     B := if B < 0 then -(B) else B endif ; 
     fB := true ) else skip ; 
    if (fA & fB) then     OclFile["System.out"].println(A + B) else     if (fA) then     OclFile["System.out"].println(A) else     if (fB) then     OclFile["System.out"].println(B) else     OclFile["System.out"].println(0) ; ;  ;  ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    long a=scan.nextLong();
    long b=scan.nextLong();
    long x=scan.nextLong();
    long y=scan.nextLong();
    long z=scan.nextLong();
    long result=Math.max(0,2*x+y-a)+Math.max(0,3*z+y-b);
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := scan.getCurrent()->toLong() ;
    var b : long ; b := scan.getCurrent()->toLong() ;
    var x : long ; x := scan.getCurrent()->toLong() ;
    var y : long ; y := scan.getCurrent()->toLong() ;
    var z : long ; z := scan.getCurrent()->toLong() ;
    var result : long ; result := Set{0, 2 * x + y - a}->max() + Set{0, 3 * z + y - b}->max() ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long a=in.nextLong();
    long b=in.nextLong();
    long x=in.nextLong();
    long y=in.nextLong();
    long z=in.nextLong();
    long yello=x*2+y ;
    long blue=y+z*3 ;
    long needYello,needBlue ;
    if(yello<=a){
      needYello=0 ;
    }
    else {
      needYello=yello-a ;
    }
    if(blue<=b){
      needBlue=0 ;
    }
    else {
      needBlue=blue-b ;
    }
    long sum=needYello+needBlue ;
    System.out.println(sum);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := in.getCurrent()->toLong() ;
    var b : long ; b := in.getCurrent()->toLong() ;
    var x : long ; x := in.getCurrent()->toLong() ;
    var y : long ; y := in.getCurrent()->toLong() ;
    var z : long ; z := in.getCurrent()->toLong() ;
    var yello : long ; yello := x * 2 + y ;
    var blue : long ; blue := y + z * 3 ;
    var needYello : long ;
    var needBlue : long ;
    if (yello <= a) then (     needYello := 0 ) else (     needYello := yello - a ) ;  
    if (blue <= b) then (     needBlue := 0 ) else (     needBlue := blue - b ) ;  
    var sum : long ; sum := needYello + needBlue ;
    OclFile["System.out"].println(sum) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    long d,t,a,b,x,y,z ;
    Scanner in=new Scanner(System.in);
    a=in.nextLong();
    b=in.nextLong();
    x=in.nextLong();
    y=in.nextLong();
    z=in.nextLong();
    d=2*x+y-a ;
    t=3*z+y-b ;
    if(d<0 && t<0)System.out.println(0);
    else if(d<0 && t>=0)System.out.println(t);
    else if(d>=0 && t<0)System.out.println(d);
    else System.out.println(t+d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : long ;
    var t : long ;
    var a : long ;
    var b : long ;
    var x : long ;
    var y : long ;
    var z : long ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    a := in.getCurrent()->toLong() ; 
    b := in.getCurrent()->toLong() ; 
    x := in.getCurrent()->toLong() ; 
    y := in.getCurrent()->toLong() ; 
    z := in.getCurrent()->toLong() ; 
    d := 2 * x + y - a ; 
    t := 3 * z + y - b ; 
    if (d < 0 & t < 0) then     OclFile["System.out"].println(0) else     if (d < 0 & t >= 0) then     OclFile["System.out"].println(t) else     if (d >= 0 & t < 0) then     OclFile["System.out"].println(d) else     OclFile["System.out"].println(t + d) ; ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.HashSet ;
import java.util.Set ;
public class OptimalCurrencyExchange {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int n=Integer.parseInt(br.readLine());
    int d=Integer.parseInt(br.readLine());
    int e=Integer.parseInt(br.readLine());
    int res=n ;
    for(int i=0 ; i*5*e<=n ; i++){
      res=Math.min(res,(n-i*5*e)% d);
    }
    pr.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class OptimalCurrencyExchange {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var d : int ; d := (br.readLine())->toInteger() ;
    var e : int ; e := (br.readLine())->toInteger() ;
    var res : int ; res := n ;
        var i : int ; i := 0 ; while i * 5 * e <= n do ( (     res := Set{res, (n - i * 5 * e) mod d}->min() )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TrickyAlchemy {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    long y=input.nextLong(),b=input.nextLong();
    long yellow=input.nextLong(),green=input.nextLong(),blue=input.nextLong();
    long yellowCounter=(yellow*2)+green ;
    long blueCounter=(blue*3)+green ;
    long ans=Math.max(0,yellowCounter-y)+Math.max(0,blueCounter-b);
    System.out.println(ans);
    input.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class TrickyAlchemy {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var y : long ; y := input.getCurrent()->toLong() ;
    var b : long ; b := input.getCurrent()->toLong() ;
    var yellow : long ; yellow := input.getCurrent()->toLong() ;
    var green : long ; green := input.getCurrent()->toLong() ;
    var blue : long ; blue := input.getCurrent()->toLong() ;
    var yellowCounter : long ; yellowCounter := (yellow * 2) + green ;
    var blueCounter : long ; blueCounter := (blue * 3) + green ;
    var ans : long ; ans := Set{0, yellowCounter - y}->max() + Set{0, blueCounter - b}->max() ;
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      if(n % 2==0){
        out.println(0);
        return ;
      }
      int m=in.nextInt();
      if(n>2*m){
        out.println(0);
        return ;
      }
      int k=in.nextInt();
      int[] cell=new int[n];
      for(int i=0 ; i<n ; i++){
        cell[i]=in.nextInt();
      }
      long min=(long)k*((long)m/(long)((n+1)/2));
      for(int i=0 ; i<n ; i+=2){
        min=Math.min(min,cell[i]);
      }
      out.println(min);
    }
  }
  static class InputReader {
    private StringTokenizer tokenizer ;
    private BufferedReader reader ;
    public InputReader(InputStream inputStream){
      reader=new BufferedReader(new InputStreamReader(inputStream));
    }
    private void fillTokenizer(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(Exception e){
          throw new RuntimeException(e);
        }
      }
    }
    public String next(){
      fillTokenizer();
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     if (n mod 2 = 0) then (     skip ; 
     return ) else skip ; 
    var m : int ; m := in.nextInt() ;
    if (n > 2 * m) then (     skip ; 
     return ) else skip ; 
    var k : int ; k := in.nextInt() ;
    var cell : Sequence(int) ; cell := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     cell[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    var min : long ; min := k->oclAsType(long) * (m->oclAsType(long) / ((n + 1) / 2)->oclAsType(long)) ;
        var i : int ; i := 0 ; while i < n do ( (     min := Set{min, cell[i+1]}->min() )  ;     i := i+(2) ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute tokenizer : OclIterator;
   attribute reader : OclFile;
   static operation newInputReader( inputStream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) );
   operation fillTokenizer() : void
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : ProgramException) do (     error ProgramException(e) )
 ) else skip );
   operation next() : String
  pre: true
  post: true
  activity: (     execute fillTokenizer() ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int factorial(int n){
    int res=1,i ;
    for(i=2 ; i<=n ; i++)res*=i ;
    return res ;
  }
  public static void main(String[] args){
    int num=5 ;
    System.out.println("Factorial of "+num+" is "+factorial(5));
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation factorial( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
    var i : int ;
         i := 2 ; while i <= n do (     res := res*(i) ;  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 5 ;
     OclFile["System.out"].println("Factorial of " + num + " is " + factorial(5)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int xorPairCount(int arr[],int n,int x){
    int result=0 ;
    Map<Integer,Integer>m=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int curr_xor=x ^ arr[i];
      if(m.containsKey(curr_xor))result+=m.get(curr_xor);
      if(m.containsKey(arr[i])){
        m.put(arr[i],m.get(arr[i])+1);
      }
      else {
        m.put(arr[i],1);
      }
    }
    return result ;
  }
  public static void main(String[] args){
    int arr[]={
      2,5,2 };
      int n=arr.length ;
      int x=0 ;
      System.out.println("Count of pairs with given XOR="+xorPairCount(arr,n,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation xorPairCount( arr : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var m : Map(int,int) ; m := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     var curr_xor : int ; curr_xor := MathLib.bitwiseXor(x,arr[i+1]) ;
     if (m->keys()->includes(curr_xor)) then     result := result+(m->at(curr_xor)) ; else skip ; 
     if (m->keys()->includes(arr[i+1])) then (     m := m->union(Map{arr[i+1] |-> m->at(arr[i+1]) + 1}) ) else (     m := m->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,5,2} ;
     var n : int ; n := arr->size() ;
     var x : int ; x := 0 ;
     OclFile["System.out"].println("Count of pairs with given XOR=" + xorPairCount(arr, n, x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class buggy {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int totalMoves=scan.nextInt();
    String directions=scan.next();
    int U=0 ;
    int D=0 ;
    int L=0 ;
    int R=0 ;
    for(int i=0 ; i<totalMoves ; i++){
      if(directions.charAt(i)=='U'){
        U++;
      }
      if(directions.charAt(i)=='D'){
        D++;
      }
      if(directions.charAt(i)=='L'){
        L++;
      }
      if(directions.charAt(i)=='R'){
        R++;
      }
    }
    System.out.println((Math.min(U,D)+Math.min(L,R))*2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class buggy {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var totalMoves : int ; totalMoves := scan.getCurrent()->toInteger() ;
    var directions : String ; directions := scan.getCurrent() ;
    var U : int ; U := 0 ;
    var D : int ; D := 0 ;
    var L : int ; L := 0 ;
    var R : int ; R := 0 ;
        var i : int ; i := 0 ; while i < totalMoves do ( (     if (directions->at(i+1) = 'U') then (     U := U + 1 ) else skip ; 
     if (directions->at(i+1) = 'D') then (     D := D + 1 ) else skip ; 
     if (directions->at(i+1) = 'L') then (     L := L + 1 ) else skip ; 
     if (directions->at(i+1) = 'R') then (     R := R + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((Set{U, D}->min() + Set{L, R}->min()) * 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf888B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    String s=scan.next();
    int uCnt=0 ;
    int dCnt=0 ;
    int rCnt=0 ;
    int lCnt=0 ;
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='U'){
        uCnt++;
      }
      else if(s.charAt(i)=='D'){
        dCnt++;
      }
      else if(s.charAt(i)=='R'){
        rCnt++;
      }
      else if(s.charAt(i)=='L'){
        lCnt++;
      }
    }
    System.out.println(2*Math.min(uCnt,dCnt)+2*Math.min(rCnt,lCnt));
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf888B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var s : String ; s := scan.getCurrent() ;
    var uCnt : int ; uCnt := 0 ;
    var dCnt : int ; dCnt := 0 ;
    var rCnt : int ; rCnt := 0 ;
    var lCnt : int ; lCnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = 'U') then (     uCnt := uCnt + 1 ) else     if (s->at(i+1) = 'D') then (     dCnt := dCnt + 1 ) else     if (s->at(i+1) = 'R') then (     rCnt := rCnt + 1 ) else     if (s->at(i+1) = 'L') then (     lCnt := lCnt + 1 ) else skip ; ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(2 * Set{uCnt, dCnt}->min() + 2 * Set{rCnt, lCnt}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf888B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    String command=scan.next();
    int cntL=0 ;
    int cntD=0 ;
    int cntU=0 ;
    int cntR=0 ;
    for(int i=0 ; i<n ; i++){
      char c=command.charAt(i);
      if(c=='L')cntL++;
      else if(c=='R')cntR++;
      else if(c=='D')cntD++;
      else cntU++;
    }
    System.out.println(2*Math.min(cntL,cntR)+2*Math.min(cntD,cntU));
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf888B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var command : String ; command := scan.getCurrent() ;
    var cntL : int ; cntL := 0 ;
    var cntD : int ; cntD := 0 ;
    var cntU : int ; cntU := 0 ;
    var cntR : int ; cntR := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var c : String ; c := command->at(i+1) ;
     if (c = 'L') then     cntL := cntL + 1 ; else     if (c = 'R') then     cntR := cntR + 1 else     if (c = 'D') then     cntD := cntD + 1 else     cntU := cntU + 1 ; ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(2 * Set{cntL, cntR}->min() + 2 * Set{cntD, cntU}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Practice {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    String com=scan.next();
    int[] arr=new int[2];
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(com.charAt(i)=='R'){
        arr[0]++;
      }
      else if(com.charAt(i)=='L'){
        arr[0]--;
      }
      else if(com.charAt(i)=='U'){
        arr[1]++;
      }
      else {
        arr[1]--;
      }
    }
    ans=n-(Math.abs(arr[0])+Math.abs(arr[1]));
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var com : String ; com := scan.getCurrent() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,2)->collect(0) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (com->at(i+1) = 'R') then (     arr[0+1] := arr[0+1] + 1 ) else     if (com->at(i+1) = 'L') then (     arr[0+1] := arr[0+1] - 1 ) else     if (com->at(i+1) = 'U') then (     arr[1+1] := arr[1+1] + 1 ) else (     arr[1+1] := arr[1+1] - 1 ) ;  ;  )  ;     i := i + 1 ) ; 
    ans := n - (if arr[0+1] < 0 then -(arr[0+1]) else arr[0+1] endif + if arr[1+1] < 0 then -(arr[1+1]) else arr[1+1] endif) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf888B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    String in=scan.next();
    int cntL=0 ;
    int cntR=0 ;
    int cntU=0 ;
    int cntD=0 ;
    for(int i=0 ; i<n ; i++){
      char c=in.charAt(i);
      if(c=='L')cntL++;
      else if(c=='R')cntR++;
      else if(c=='D')cntD++;
      else cntU++;
    }
    System.out.println(2*Math.min(cntD,cntU)+2*Math.min(cntL,cntR));
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf888B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var in : String ; in := scan.getCurrent() ;
    var cntL : int ; cntL := 0 ;
    var cntR : int ; cntR := 0 ;
    var cntU : int ; cntU := 0 ;
    var cntD : int ; cntD := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var c : String ; c := in->at(i+1) ;
     if (c = 'L') then     cntL := cntL + 1 ; else     if (c = 'R') then     cntR := cntR + 1 else     if (c = 'D') then     cntD := cntD + 1 else     cntU := cntU + 1 ; ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(2 * Set{cntD, cntU}->min() + 2 * Set{cntL, cntR}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf548A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    StringBuilder input=new StringBuilder();
    input.append(scan.next());
    int n=scan.nextInt();
    int length=input.length()/n ;
    Boolean isPal=true ;
    for(int i=0 ; i<n ; i++){
      if(input.length()% n!=0){
        isPal=false ;
        break ;
      }
      String nextWord=input.substring(i*length,(i+1)*length);
      StringBuilder rev=new StringBuilder(nextWord);
      rev.reverse();
      String reverse=rev.toString();
      int o=0 ;
      while(o<length){
        if(reverse.charAt(o)!=nextWord.charAt(o)){
          isPal=false ;
          break ;
        }
        else {
          isPal=true ;
          o++;
        }
      }
      if(isPal==false){
        break ;
      }
      nextWord="" ;
      reverse="" ;
    }
    if(isPal==true){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf548A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : String ; input := StringLib.newString() ;
    input := input + StringLib.newString(scan.getCurrent()) ; 
    var n : int ; n := scan.getCurrent()->toInteger() ;
    var length : int ; length := input->size() / n ;
    var isPal : Boolean ; isPal := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (input->size() mod n /= 0) then (     isPal := false ; 
     break ) else skip ; 
     var nextWord : String ; nextWord := input.subrange(i * length+1,(i + 1) * length) ;
    var rev : String ; rev := StringLib.newString(nextWord) ;
    rev := rev->reverse() ; 
    var reverse : String ; reverse := rev+"" ;
    var o : int ; o := 0 ;
    while (o < length) do (     if (reverse->at(o+1) /= nextWord->at(o+1)) then (     isPal := false ; 
     break ) else (     isPal := true ; 
     o := o + 1 ) ) ; 
    if (isPal = false) then (     break ) else skip ; 
    nextWord := "" ; 
    reverse := "" ; 
 )  ;     i := i + 1 ) ; 
    if (isPal = true) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.*;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int k=in.nextInt();
      int p=in.nextInt();
      double sum=0 ;
      for(int i=1 ; i<=k ; i++){
        int a=i ;
        double b=i ;
        while(a!=0){
          b=b*10+a % 10 ;
          a/=10 ;
        }
        b=b % p ;
        sum=(sum+b)% p ;
      }
      out.printf("%.0f",sum);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var k : int ; k := in.nextInt() ;
     var p : int ; p := in.nextInt() ;
    var sum : double ; sum := 0 ;
        var i : int ; i := 1 ; while i <= k do ( (     var a : int ; a := i ;
     var b : double ; b := i ;
    while (a /= 0) do (     b := b * 10 + a mod 10 ; 
     a := a/(10) ) ; 
    b := b mod p ; 
    sum := (sum + b) mod p ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class mike {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String input=scan.next();
    int words=scan.nextInt();
    int lengthPerWord=input.length()/words ;
    int i=0 ;
    if(input.length()% words!=0){
      System.out.println("NO");
    }
    else {
      while(i<input.length()){
        StringBuilder theWord=new StringBuilder();
        while(theWord.length()<lengthPerWord){
          theWord.append(input.charAt(i));
          i++;
        }
        StringBuilder rev=new StringBuilder(theWord);
        rev.reverse();
        if(! theWord.toString().equals(rev.toString())){
          System.out.println("NO");
          break ;
        }
        else if(i==input.length()){
          System.out.println("YES");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class mike {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : String ; input := scan.getCurrent() ;
    var words : int ; words := scan.getCurrent()->toInteger() ;
    var lengthPerWord : int ; lengthPerWord := input->size() / words ;
    var i : int ; i := 0 ;
    if (input->size() mod words /= 0) then (     OclFile["System.out"].println("NO") ) else (     while (i < input->size()) do (     var theWord : String ; theWord := StringLib.newString() ;
     while (theWord->size() < lengthPerWord) do (     theWord := theWord + StringLib.newString(input->at(i+1)) ; 
     i := i + 1 ) ; 
    var rev : String ; rev := StringLib.newString(theWord) ;
    rev := rev->reverse() ; 
    if (not(theWord+"" = rev+"")) then (     OclFile["System.out"].println("NO") ; 
     break ) else     if (i = input->size()) then (     OclFile["System.out"].println("YES") ) else skip ; ;  
 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf548A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    StringBuilder str=new StringBuilder(scan.next());
    int cnt=0 ;
    int k=scan.nextInt();
    int length=str.length();
    int PalindromeLength=length/k ;
    if(str.length()% k!=0){
      System.out.println("NO");
    }
    else {
      for(int i=0 ; i<k ; i++){
        if(PalindromeLength==1){
          cnt=k ;
        }
        else {
          String sb=str.substring(i*PalindromeLength,(i+1)*PalindromeLength);
          String first=sb.substring(0,PalindromeLength/2);
          StringBuilder last=new StringBuilder(sb.substring(PalindromeLength/2));
          StringBuilder reverse=last.reverse();
          if(PalindromeLength % 2==1){
            first=sb.substring(0,PalindromeLength/2+1);
          }
          if(first.equals(reverse.toString())){
            cnt++;
          }
        }
      }
      if(cnt==k){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf548A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := StringLib.newString(scan.getCurrent()) ;
    var cnt : int ; cnt := 0 ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var length : int ; length := str->size() ;
    var PalindromeLength : int ; PalindromeLength := length / k ;
    if (str->size() mod k /= 0) then (     OclFile["System.out"].println("NO") ) else (         var i : int ; i := 0 ; while i < k do ( (     if (PalindromeLength = 1) then (     cnt := k ) else (     var sb : String ; sb := str.subrange(i * PalindromeLength+1,(i + 1) * PalindromeLength) ;
     var first : String ; first := sb.subrange(0+1,PalindromeLength / 2) ;
    var last : String ; last := StringLib.newString(sb.subrange(PalindromeLength / 2+1,PalindromeLength / 2)) ;
    var reverse : String ; reverse := last->reverse() ;
    if (PalindromeLength mod 2 = 1) then (     first := sb.subrange(0+1,PalindromeLength / 2 + 1) ) else skip ; 
    if (first = reverse+"") then (     cnt := cnt + 1 ) else skip ; 
 ) )  ;     i := i + 1 ) ; 
     if (cnt = k) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    FastScanner in=new FastScanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    new Main().run(in,out);
    out.close();
  }
  public static long mod=17352642619633L ;
  void run(FastScanner in,PrintWriter out){
    int N=in.nextInt();
    int M=in.nextInt();
    long K=in.nextInt();
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++)a[i]=in.nextInt();
    if(N % 2==0){
      out.println(0);
      return ;
    }
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<N ; i++){
      if(i % 2==0){
        min=Math.min(min,a[i]);
      }
    }
    int moves=1+N/2 ;
    long ret=min ;
    if(moves>M)ret=0 ;
    else ret=Math.min(ret,K*(M/moves));
    out.println(ret);
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(InputStream in){
      br=new BufferedReader(new InputStreamReader(in));
      st=null ;
    }
    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());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     Main.newMain().run(in, out) ; 
     skip );
  static   attribute mod : long := 17352642619633L;
   operation run( in : FastScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.nextInt() ;
     var M : int ; M := in.nextInt() ;
    var K : long ; K := in.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     a[i+1] := in.nextInt() ;  ;     i := i + 1 ) ; 
    if (N mod 2 = 0) then (     skip ; 
     return ) else skip ; 
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < N do ( (     if (i mod 2 = 0) then (     min := Set{min, a[i+1]}->min() ) else skip )  ;     i := i + 1 ) ; 
    var moves : int ; moves := 1 + N / 2 ;
    var ret : long ; ret := min ;
    if (moves > M) then     ret := 0 else     ret := Set{ret, K * (M / moves)}->min() ; ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     st := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Project {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    StringBuilder str=new StringBuilder(scan.next());
    int cnt=0 ;
    int k=scan.nextInt();
    int length=str.length();
    int PalindromeLength=length/k ;
    if(str.length()% k!=0){
      System.out.println("NO");
    }
    else {
      for(int i=0 ; i<k ; i++){
        if(PalindromeLength==1){
          cnt=k ;
        }
        else {
          String sb=str.substring(i*PalindromeLength,(i+1)*PalindromeLength);
          String first=sb.substring(0,PalindromeLength/2);
          StringBuilder last=new StringBuilder(sb.substring(PalindromeLength/2));
          StringBuilder reverse=last.reverse();
          if(PalindromeLength % 2==1){
            first=sb.substring(0,PalindromeLength/2+1);
          }
          if(first.equals(reverse.toString())){
            cnt++;
          }
        }
      }
      if(cnt==k){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Project {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := StringLib.newString(scan.getCurrent()) ;
    var cnt : int ; cnt := 0 ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var length : int ; length := str->size() ;
    var PalindromeLength : int ; PalindromeLength := length / k ;
    if (str->size() mod k /= 0) then (     OclFile["System.out"].println("NO") ) else (         var i : int ; i := 0 ; while i < k do ( (     if (PalindromeLength = 1) then (     cnt := k ) else (     var sb : String ; sb := str.subrange(i * PalindromeLength+1,(i + 1) * PalindromeLength) ;
     var first : String ; first := sb.subrange(0+1,PalindromeLength / 2) ;
    var last : String ; last := StringLib.newString(sb.subrange(PalindromeLength / 2+1,PalindromeLength / 2)) ;
    var reverse : String ; reverse := last->reverse() ;
    if (PalindromeLength mod 2 = 1) then (     first := sb.subrange(0+1,PalindromeLength / 2 + 1) ) else skip ; 
    if (first = reverse+"") then (     cnt := cnt + 1 ) else skip ; 
 ) )  ;     i := i + 1 ) ; 
     if (cnt = k) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf548A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String s=scan.next();
    int k=scan.nextInt();
    scan.close();
    if(s.length()% k!=0){
      System.out.println("NO");
    }
    else {
      boolean possible=true ;
      int len=s.length()/k ;
      for(int i=0 ; i<k ; i++){
        for(int j=0 ; j<len ; j++){
          if(s.charAt(i*len+j)!=s.charAt((i+1)*len-j-1)){
            possible=false ;
            break ;
          }
        }
        if(! possible){
          break ;
        }
      }
      if(possible){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf548A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scan.getCurrent() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    skip ; 
    if (s->size() mod k /= 0) then (     OclFile["System.out"].println("NO") ) else (     var possible : boolean ; possible := true ;
     var len : int ; len := s->size() / k ;
         var i : int ; i := 0 ; while i < k do ( (         var j : int ; j := 0 ; while j < len do ( (     if (s->at(i * len + j+1) /= s->at((i + 1) * len - j - 1+1)) then (     possible := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (not(possible)) then (     break ) else skip )  ;     i := i + 1 ) ; 
     if (possible) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    String line=null ;
    while((line=reader.readLine())!=null){
      if(line.isEmpty()){
        continue ;
      }
      double q=Double.parseDouble(line);
      if(q==-1.0){
        break ;
      }
      double x=q*0.5 ;
      double eps=0.00001*q ;
      while(true){
        double xx=x*x ;
        double xxx=xx*x ;
        if(Math.abs(xxx-q)<eps){
          break ;
        }
        x-=(xxx-q)/(3.0*xx);
      }
      out.println(String.format("%.6f",x));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     var line : String ; line := null ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->isEmpty()) then (     continue ) else skip ; 
     var q : double ; q := (line)->toReal() ;
    if (q = -1.0) then (     break ) else skip ; 
    var x : double ; x := q * 0.5 ;
    var eps : double ; eps := 0.00001 * q ;
    while (true) do (     var xx : double ; xx := x * x ;
     var xxx : double ; xxx := xx * x ;
     if (if xxx - (q)->char2byte() < 0 then -(xxx - (q)->char2byte()) else xxx - (q)->char2byte() endif < eps) then (     break ) else skip ; 
     x := x-((xxx - (q)->char2byte()) / (3.0 * xx)) ) ; 
    out.println(StringLib.format("%.6f",Sequence{x})) ; 
 ) ;     line := reader.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-5 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      double q=sc.nextDouble();
      if(q==0){
        System.out.println(0.00000);
        continue ;
      }
      if(q==-1)break ;
      double x=q/2 ;
      while(abs(x*x*x-q)>=EPS*q){
        x=f(x,q);
      }
      System.out.printf("%.6f\n",x);
    }
  }
  double f(double x,double q){
    return x-(x*x*x-q)/(3*x*x);
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-5;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var q : double ; q := sc.getCurrent()->toReal() ;
     if (q = 0) then (     OclFile["System.out"].println(0.00000) ; 
     continue ) else skip ; 
    if (q = -1) then     break else skip ; 
    var x : double ; x := q / 2 ;
    while (abs(x * x * x - q) >= EPS * q) do (     x := f(x, q) ) ; 
    OclFile["System.out"].printf("%.6f\n", x) ; 
 )  ) );
   operation f( x : double, q : double) : double
  pre: true
  post: true
  activity: (     return x - (x * x * x - q) / (3 * x * x) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.text.DecimalFormat ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      double n=sc.nextInt();
      if(n==-1)break ;
      double x=(double)n/2 ;
      for(; !(Math.abs(x*x*x-n)<0.00001*n); ){
        x=x-(x*x*x-n)/(3*x*x);
      }
      DecimalFormat df=new DecimalFormat();
      df.applyLocalizedPattern("0.000000");
      System.out.println(df.format(x));
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : double ; n := sc.getCurrent()->toInteger() ;
     if (n = -1) then     break else skip ; 
    var x : double ; x := n->oclAsType(double) / 2 ;
      while not((if x * x * x - n < 0 then -(x * x * x - n) else x * x * x - n endif < 0.00001 * n)) do ( (     x := x - (x * x * x - n) / (3 * x * x) )  ) ; 
    var df : DecimalFormat ; df := DecimalFormat.newDecimalFormat() ;
    df.applyLocalizedPattern("0.000000") ; 
    OclFile["System.out"].println(df.format(x)) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args){
    BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    String str="" ;
    int input=0 ;
    double ans=0 ;
    try {
      while(true){
        str=bfr.readLine();
        input=Integer.parseInt(str);
        if(input<0){
          System.exit(0);
        }
        ans=(double)input ;
        ans=kotae(ans/2,input);
        System.out.println(ans);
      }
    }
    catch(IOException e){
    }
  }
  public static double kotae(double a,int b){
    double newans=0 ;
    double bb=(double)b ;
    newans=a-(a*a*a-bb)/(3*a*a);
    if(Math.abs(newans*newans*newans-bb)<0.00001*bb){
      return newans ;
    }
    else {
      newans=kotae(newans,b);
    }
    return newans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bfr : OclFile ; bfr := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := "" ;
    var input : int ; input := 0 ;
    var ans : double ; ans := 0 ;
    try (     while (true) do (     str := bfr.readLine() ; 
     input := (str)->toInteger() ; 
    if (input < 0) then ( OclProcess.exit(0) ) else skip ; 
    ans := input->oclAsType(double) ; 
    ans := kotae(ans / 2, input) ; 
    OclFile["System.out"].println(ans) ; 
 ) )   catch (e : IOException) do skip
 );
  static   operation kotae( a : double, b : int) : double
  pre: true
  post: true
  activity: (     var newans : double ; newans := 0 ;
     var bb : double ; bb := b->oclAsType(double) ;
    newans := a - (a * a * a - bb) / (3 * a * a) ; 
    if (if newans * newans * newans - bb < 0 then -(newans * newans * newans - bb) else newans * newans * newans - bb endif < 0.00001 * bb) then (     return newans ) else (     newans := kotae(newans, b) ) ;  
    return newans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    double q,x ;
    for(; ; out.println(x)){
      q=sc.nextDouble();
      if(q==-1)break ;
      x=q/2.0 ;
      for(; x*x*x-q>=0.00001*q || x*x*x-q<=-0.00001*q ; )x-=(x*x*x-q)/(3*x*x);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var q : double ;
    var x : double ;
       while true do ( (     q := sc.nextDouble() ; 
     if (q = -1) then     break else skip ; 
     x := q / 2.0 ; 
       while x * x * x - q >= 0.00001 * q or x * x * x - q <= -0.00001 * q do (     x := x-((x * x * x - q) / (3 * x * x)) ;  ) )  ;     out.println(x) ) ; 
     sc.close() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float knapSack(int W,float wt[],float val[],int n){
    float maxratio=Integer.MIN_VALUE ;
    int maxindex=0 ;
    for(int i=0 ; i<n ; i++){
      if((val[i]/wt[i])>maxratio){
        maxratio=(val[i]/wt[i]);
        maxindex=i ;
      }
    }
    return(W*maxratio);
  }
  public static void main(String[] args){
    float val[]={
      14,27,44,19 };
      float wt[]={
        6,7,9,8 };
        int n=val.length ;
        int W=50 ;
        System.out.println(knapSack(W,wt,val,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation knapSack( W : int, wt : Sequence(double), val : Sequence(double), n : int) : double
  pre: true
  post: true
  activity: (     var maxratio : double ; maxratio := -2147483648 ;
     var maxindex : int ; maxindex := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if ((val[i+1] / wt[i+1]) > maxratio) then (     maxratio := (val[i+1] / wt[i+1]) ; 
     maxindex := i ) else skip )  ;     i := i + 1 ) ; 
     return (W * maxratio) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var val : Sequence(double) ; val := Sequence{14,27,44,19} ;
     var wt : Sequence(double) ; wt := Sequence{6,7,9,8} ;
    var n : int ; n := val->size() ;
    var W : int ; W := 50 ;
    OclFile["System.out"].println(knapSack(W, wt, val, n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A_Learning_Languages {
  static ArrayList<Integer>[] adjList,graph ;
  static boolean[] visited ;
  static int tree=0 ;
  private static void dfs(int node){
    visited[node]=true ;
    for(int nxt : graph[node]){
      if(! visited[nxt])dfs(nxt);
    }
  }
  public static void main(String[] args)throws IOException,InterruptedException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    adjList=new ArrayList[m+1];
    graph=new ArrayList[n];
    visited=new boolean[n];
    for(int i=0 ; i<m+1 ; i++)adjList[i]=new ArrayList<>();
    for(int i=0 ; i<n ; i++)graph[i]=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      while(x-->0){
        int lang=sc.nextInt();
        adjList[lang] .add(i);
      }
    }
    for(int i=1 ; i<adjList.length ; i++){
      for(int j=0 ; j<adjList[i] .size()-1 ; j++){
        int a=adjList[i] .get(j);
        int b=adjList[i] .get(j+1);
        graph[a] .add(b);
        graph[b] .add(a);
      }
    }
    for(int i=0 ; i<n ; i++){
      if(! visited[i]){
        dfs(i);
        tree++;
      }
    }
    boolean corner=true ;
    for(int i=0 ; i<m+1 ; i++){
      if(adjList[i] .size()!=0){
        corner=false ;
        break ;
      }
    }
    if(corner)System.out.println(n);
    else System.out.println(tree-1);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Learning_Languages {
  static   attribute adjList : Sequence(Sequence(int));
  static   attribute visited : Sequence(boolean);
  static   attribute tree : int := 0;
  static   operation dfs( node : int) : void
  pre: true
  post: true
  activity: (     visited[node+1] := true ; 
     for (nxt : graph[node+1]) do ( (     if (not(visited[nxt+1])) then     execute dfs(nxt) ; else skip )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    adjList := Integer.subrange(1,m + 1)->collect(null) ; 
    graph := Integer.subrange(1,n)->collect(null) ; 
    visited := Integer.subrange(1,n)->collect(false) ; 
        var i : int ; i := 0 ; while i < m + 1 do (     adjList[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     graph[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
         while (x > 0) do (        x := x - 1 ;     skip ; (     var lang : int ; lang := sc.getCurrent()->toInteger() ;
     adjList[lang+1]->excludes(i) ) ;  ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < adjList->size() do ( (         var j : int ; j := 0 ; while j < adjList[i+1]->size() - 1 do ( (     var a : int ; a := adjList[i+1]->at(j+1) ;
     var b : int ; b := adjList[i+1]->at(j + 1+1) ;
     graph[a+1]->excludes(b) ; 
     graph[b+1]->excludes(a) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (not(visited[i+1])) then (     execute dfs(i) ; 
     tree := tree + 1 ) else skip )  ;     i := i + 1 ) ; 
    var corner : boolean ; corner := true ;
        var i : int ; i := 0 ; while i < m + 1 do ( (     if (adjList[i+1]->size() /= 0) then (     corner := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (corner) then     OclFile["System.out"].println(n) else     OclFile["System.out"].println(tree - 1) ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int recamanGenerator(int arr[],int n){
    arr[0]=0 ;
    for(int i=1 ; i<=n ; i++){
      int temp=arr[i-1]-i ;
      int j ;
      for(j=0 ; j<i ; j++){
        if((arr[j]==temp)|| temp<0){
          temp=arr[i-1]+i ;
          break ;
        }
      }
      arr[i]=temp ;
    }
    return 0 ;
  }
  static int recamanArray(int arr[],int n){
    Set<Integer>s=new HashSet<Integer>();
    int recaman[]=new int[n+1];
    recamanGenerator(recaman,n);
    for(int i=0 ; i<n ; i++)s.add(recaman[i]);
    for(int i=0 ; i<n ; i++){
      if(s.contains(arr[i]))s.remove(arr[i]);
    }
    return s.size();
  }
  public static void main(String args[]){
    int arr[]={
      7,11,20,4,2,1,8,6 };
      int n=arr.length ;
      System.out.print(recamanArray(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation recamanGenerator( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr[0+1] := 0 ; 
         var i : int ; i := 1 ; while i <= n do ( (     var temp : int ; temp := arr[i - 1+1] - i ;
     var j : int ;
         j := 0 ; while j < i do ( (     if ((arr[j+1] = temp) or temp < 0) then (     temp := arr[i - 1+1] + i ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     arr[i+1] := temp )  ;     i := i + 1 ) ; 
     return 0 );
  static   operation recamanArray( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
     var recaman : Sequence(int) ; recaman := Integer.subrange(1,n + 1)->collect(0) ;
    execute recamanGenerator(recaman, n) ; 
        var i : int ; i := 0 ; while i < n do (     s := s->including(recaman[i+1]) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (s->includes(arr[i+1])) then     s := s->excludingFirst(arr[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    return s->size() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{7,11,20,4,2,1,8,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(recamanArray(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long length=sc.nextInt();
    int n=sc.nextInt();
    char[] arr=sc.next().toCharArray();
    long count=0 ;
    for(int i=1 ; i<length ; i++){
      if(arr[i-1]=='o' && arr[i]=='o'){
        count++;
      }
    }
    for(int i=0 ; i<n ; i++){
      length+=count*3 ;
      count*=2 ;
    }
    System.out.println(length);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var length : long ; length := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
    var count : long ; count := 0 ;
        var i : int ; i := 1 ; while i < length do ( (     if (arr[i - 1+1] = 'o' & arr[i+1] = 'o') then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     length := length+(count * 3) ; 
     count := count*(2) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(length) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math ;
public class autobio {
  public static boolean isAutoBio(int num){
    String autoStr ;
    int index,number,i,j,cnt ;
    autoStr=Integer.toString(num);
    for(i=0 ; i<autoStr.length(); i++){
      index=Integer.parseInt(autoStr.charAt(i)+"");
      cnt=0 ;
      for(j=0 ; j<autoStr.length(); j++){
        number=Integer.parseInt(autoStr.charAt(j)+"");
        if(number==i)cnt++;
      }
      if(cnt!=index)return false ;
    }
    return true ;
  }
  public static void findAutoBios(double n){
    double high,low ;
    int i,flag=0 ;
    low=Math.pow(10.0,n-1);
    high=Math.pow(10.0,n)-1.0 ;
    for(i=(int)low ; i<=(int)high ; i++)if(isAutoBio(i)){
      flag=1 ;
      System.out.print(i+",");
    }
    if(flag==0)System.out.println("There is no Autobiographical Number"+"with "+(int)n+" digits");
  }
  public static void main(String[] args){
    double N=0 ;
    findAutoBios(N);
    N=4 ;
    findAutoBios(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class autobio {
  static   operation isAutoBio( num : int) : boolean
  pre: true
  post: true
  activity: (     var autoStr : String ;
     var index : int ;
    var number : int ;
    var i : int ;
    var j : int ;
    var cnt : int ;
    autoStr := ((num) + "") ; 
        i := 0 ; while i < autoStr->size() do ( (     index := (autoStr->at(i+1) + "")->toInteger() ; 
     cnt := 0 ; 
         j := 0 ; while j < autoStr->size() do ( (     number := (autoStr->at(j+1) + "")->toInteger() ; 
     if (number = i) then     cnt := cnt + 1 ; else skip )  ;     j := j + 1 ) ; 
     if (cnt /= index) then     return false else skip )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation findAutoBios( n : double) : void
  pre: true
  post: true
  activity: (     var high : double ;
    var low : double ;
     var i : int ;
    var flag : int ; flag := 0 ;
    low := 10.0->pow(n - 1) ; 
    high := 10.0->pow(n) - 1.0 ; 
        i := low->oclAsType(int) ; while i <= high->oclAsType(int) do (     if (isAutoBio(i)) then (     flag := 1 ; 
     OclFile["System.out"].print(i + ",") ) else skip ;  ;     i := i + 1 ) ; 
    if (flag = 0) then     OclFile["System.out"].println("There is no Autobiographical Number" + "with " + n->oclAsType(int) + " digits") ; else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : double ; N := 0 ;
     execute findAutoBios(N) ; 
     N := 4 ; 
     execute findAutoBios(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long factorial(int n){
    long res=1 ;
    for(int i=2 ; i<=n ; i++){
      res*=i ;
    }
    return res ;
  }
  static void printNComposite(int n){
    long fact=factorial(n+1);
    for(int i=2 ; i<=n+1 ; ++i){
      System.out.print(fact+i+" ");
    }
  }
  public static void main(String[] args){
    int n=4 ;
    printNComposite(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation factorial( n : int) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : int ; i := 2 ; while i <= n do ( (     res := res*(i) )  ;     i := i + 1 ) ; 
     return res );
  static   operation printNComposite( n : int) : void
  pre: true
  post: true
  activity: (     var fact : long ; fact := factorial(n + 1) ;
         var i : int ; i := 2 ; while i <= n + 1 do ( (     OclFile["System.out"].print(fact + i + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     execute printNComposite(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static long n,m ;
  static void solve(){
    long cnt=0 ;
    if(n<=m){
      for(int i=1 ; i<=n ; i++){
        for(int j=1 ; j<=n ; j++){
          if((i*i+j*j)% m==0){
            cnt++;
          }
        }
      }
      str.append(cnt).append("\n");
      return ;
    }
    for(int x=1 ; x<=m ; x++){
      for(int y=1 ; y<=m ; y++){
        long val=x*x+y*y ;
        if(val % m==0)cnt+=(((n-x)/m+1)*((n-y)/m+1));
      }
    }
    str.append(cnt).append("\n");
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    String st[]=bf.readLine().trim().split("\\s+");
    n=Long.parseLong(st[0]);
    m=Long.parseLong(st[1]);
    solve();
    pw.println(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute n : long;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var cnt : long ; cnt := 0 ;
     if (n <= m) then (         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     if ((i * i + j * j) mod m = 0) then (     cnt := cnt + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     str := str + StringLib.newString(cnt) + StringLib.newString("\n") ; 
     return ) else skip ; 
         var x : int ; x := 1 ; while x <= m do ( (         var y : int ; y := 1 ; while y <= m do ( (     var val : long ; val := x * x + y * y ;
     if (val mod m = 0) then     cnt := cnt+((((n - x) / m + 1) * ((n - y) / m + 1))) ; else skip )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
     str := str + StringLib.newString(cnt) + StringLib.newString("\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var st : Sequence(String) ; st := bf.readLine()->trim()->split("\\s+") ;
    n := (st[0+1])->toLong() ; 
    m := (st[1+1])->toLong() ; 
    execute solve() ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static long n,m ;
  static void solve(){
    long cnt=0 ;
    if(n<=m){
      for(int i=1 ; i<=n ; i++){
        for(int j=1 ; j<=n ; j++){
          if((i*i+j*j)% m==0)cnt++;
        }
      }
      str.append(cnt).append("\n");
      return ;
    }
    for(long i=1 ; i<=m ; i++){
      for(long j=1 ; j<=m ; j++){
        long val1=i*i+j*j ;
        if(val1 % m==0)cnt+=((n-(i-1)+m-1)/m)*((n-(j-1)+m-1)/m);
      }
    }
    str.append(cnt).append("\n");
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    String st[]=bf.readLine().trim().split("\\s+");
    n=Long.parseLong(st[0]);
    m=Long.parseLong(st[1]);
    solve();
    pw.println(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute n : long;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var cnt : long ; cnt := 0 ;
     if (n <= m) then (         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     if ((i * i + j * j) mod m = 0) then     cnt := cnt + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     str := str + StringLib.newString(cnt) + StringLib.newString("\n") ; 
     return ) else skip ; 
         var i : long ; i := 1 ; while i <= m do ( (         var j : long ; j := 1 ; while j <= m do ( (     var val1 : long ; val1 := i * i + j * j ;
     if (val1 mod m = 0) then     cnt := cnt+(((n - (i - 1) + m - 1) / m) * ((n - (j - 1) + m - 1) / m)) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     str := str + StringLib.newString(cnt) + StringLib.newString("\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var st : Sequence(String) ; st := bf.readLine()->trim()->split("\\s+") ;
    n := (st[0+1])->toLong() ; 
    m := (st[1+1])->toLong() ; 
    execute solve() ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static long n,m ;
  static void solve(){
    long cnt=0 ;
    if(n<=m){
      for(int i=1 ; i<=n ; i++){
        for(int j=1 ; j<=n ; j++){
          if((i*i+j*j)% m==0)cnt++;
        }
      }
      str.append(cnt).append("\n");
      return ;
    }
    for(long i=1 ; i<=m ; i++){
      for(long j=1 ; j<=m ; j++){
        long val1=i*i+j*j ;
        if(val1 % m==0)cnt+=((n-i+m)/m)*((n-j+m)/m);
      }
    }
    str.append(cnt).append("\n");
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    String st[]=bf.readLine().trim().split("\\s+");
    n=Long.parseLong(st[0]);
    m=Long.parseLong(st[1]);
    solve();
    pw.println(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute n : long;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var cnt : long ; cnt := 0 ;
     if (n <= m) then (         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     if ((i * i + j * j) mod m = 0) then     cnt := cnt + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     str := str + StringLib.newString(cnt) + StringLib.newString("\n") ; 
     return ) else skip ; 
         var i : long ; i := 1 ; while i <= m do ( (         var j : long ; j := 1 ; while j <= m do ( (     var val1 : long ; val1 := i * i + j * j ;
     if (val1 mod m = 0) then     cnt := cnt+(((n - i + m) / m) * ((n - j + m) / m)) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     str := str + StringLib.newString(cnt) + StringLib.newString("\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var st : Sequence(String) ; st := bf.readLine()->trim()->split("\\s+") ;
    n := (st[0+1])->toLong() ; 
    m := (st[1+1])->toLong() ; 
    execute solve() ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static long n,m ;
  static void solve(){
    long cnt=0 ;
    for(long i=1 ; i<=m ; i++){
      for(long j=1 ; j<=m ; j++){
        long val1=i*i+j*j ;
        if(val1 % m==0)cnt+=((n-i+m)/m)*((n-j+m)/m);
      }
    }
    str.append(cnt).append("\n");
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    String st[]=bf.readLine().trim().split("\\s+");
    n=Long.parseLong(st[0]);
    m=Long.parseLong(st[1]);
    solve();
    pw.println(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute n : long;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var cnt : long ; cnt := 0 ;
         var i : long ; i := 1 ; while i <= m do ( (         var j : long ; j := 1 ; while j <= m do ( (     var val1 : long ; val1 := i * i + j * j ;
     if (val1 mod m = 0) then     cnt := cnt+(((n - i + m) / m) * ((n - j + m) / m)) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     str := str + StringLib.newString(cnt) + StringLib.newString("\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var st : Sequence(String) ; st := bf.readLine()->trim()->split("\\s+") ;
    n := (st[0+1])->toLong() ; 
    m := (st[1+1])->toLong() ; 
    execute solve() ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void AlternateRearrange(int arr[],int n){
    Arrays.sort(arr);
    Vector v1=new Vector();
    Vector v2=new Vector();
    for(int i=0 ; i<n ; i++)if(arr[i] % 2==0)v1.add(arr[i]);
    else v2.add(arr[i]);
    int index=0,i=0,j=0 ;
    boolean flag=false ;
    if(arr[0] % 2==0)flag=true ;
    while(index<n){
      if(flag==true){
        arr[index]=(int)v1.get(i);
        i+=1 ;
        index+=1 ;
        flag=! flag ;
      }
      else {
        arr[index]=(int)v2.get(j);
        j+=1 ;
        index+=1 ;
        flag=! flag ;
      }
    }
    for(i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String[] args){
    int arr[]={
      9,8,13,2,19,14 };
      int n=arr.length ;
      AlternateRearrange(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation AlternateRearrange( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var v1 : Sequence ; v1 := Sequence{} ;
    var v2 : Sequence ; v2 := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     if (arr[i+1] mod 2 = 0) then     v1 := v1->including(arr[i+1]) else     v2 := v2->including(arr[i+1]) ; ;   ;     i := i + 1 ) ; 
    var index : int ; index := 0 ;
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    var flag : boolean ; flag := false ;
    if (arr[0+1] mod 2 = 0) then     flag := true ; else skip ; 
    while (index < n) do (     if (flag = true) then (     arr[index+1] := v1->at(i+1)->oclAsType(int) ; 
     i := i+(1) ; 
     index := index+(1) ; 
     flag := not(flag) ) else (     arr[index+1] := v2->at(j+1)->oclAsType(int) ; 
     j := j+(1) ; 
     index := index+(1) ; 
     flag := not(flag) ) ) ; 
        i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{9,8,13,2,19,14} ;
     var n : int ; n := arr->size() ;
     execute AlternateRearrange(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
public class A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    if(n>m){
      int t=n ;
      n=m ;
      m=t ;
    }
    if(n==m){
      System.out.println("0");
    }
    else {
      int a=n ;
      int b=m ;
      int x1=0,y1=0,z1=0 ;
      int x2=0,y2=0,z2=0 ;
      while(a % 2==0){
        x1++;
        a/=2 ;
      }
      while(a % 3==0){
        y1++;
        a/=3 ;
      }
      while(a % 5==0){
        z1++;
        a/=5 ;
      }
      while(b % 2==0){
        x2++;
        b/=2 ;
      }
      while(b % 3==0){
        y2++;
        b/=3 ;
      }
      while(b % 5==0){
        z2++;
        b/=5 ;
      }
      if(a!=b){
        System.out.println("-1");
      }
      else {
        System.out.println(Math.abs(x1-x2)+Math.abs(y1-y2)+Math.abs(z1-z2));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    if (n > m) then (     var t : int ; t := n ;
     n := m ; 
     m := t ) else skip ; 
    if (n = m) then (     OclFile["System.out"].println("0") ) else (     var a : int ; a := n ;
     var b : int ; b := m ;
    var x1 : int ; x1 := 0 ;
    var y1 : int ; y1 := 0 ;
    var z1 : int ; z1 := 0 ;
    var x2 : int ; x2 := 0 ;
    var y2 : int ; y2 := 0 ;
    var z2 : int ; z2 := 0 ;
    while (a mod 2 = 0) do (     x1 := x1 + 1 ; 
     a := a/(2) ) ; 
    while (a mod 3 = 0) do (     y1 := y1 + 1 ; 
     a := a/(3) ) ; 
    while (a mod 5 = 0) do (     z1 := z1 + 1 ; 
     a := a/(5) ) ; 
    while (b mod 2 = 0) do (     x2 := x2 + 1 ; 
     b := b/(2) ) ; 
    while (b mod 3 = 0) do (     y2 := y2 + 1 ; 
     b := b/(3) ) ; 
    while (b mod 5 = 0) do (     z2 := z2 + 1 ; 
     b := b/(5) ) ; 
    if (a /= b) then (     OclFile["System.out"].println("-1") ) else (     OclFile["System.out"].println(if x1 - x2 < 0 then -(x1 - x2) else x1 - x2 endif + if y1 - y2 < 0 then -(y1 - y2) else y1 - y2 endif + if z1 - z2 < 0 then -(z1 - z2) else z1 - z2 endif) ) ;  
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    boolean div=true ;
    int count=0 ;
    int adiv2=0 ;
    int bdiv2=0 ;
    int adiv3=0 ;
    int bdiv3=0 ;
    int adiv5=0 ;
    int bdiv5=0 ;
    while(a % 2==0){
      adiv2++;
      a/=2 ;
    }
    while(a % 3==0){
      adiv3++;
      a/=3 ;
    }
    while(a % 5==0){
      adiv5++;
      a/=5 ;
    }
    while(b % 2==0){
      bdiv2++;
      b/=2 ;
    }
    while(b % 3==0){
      bdiv3++;
      b/=3 ;
    }
    while(b % 5==0){
      bdiv5++;
      b/=5 ;
    }
    if(a==b){
      System.out.println(Math.abs(adiv2-bdiv2)+Math.abs(adiv3-bdiv3)+Math.abs(adiv5-bdiv5));
    }
    else {
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var div : boolean ; div := true ;
    var count : int ; count := 0 ;
    var adiv2 : int ; adiv2 := 0 ;
    var bdiv2 : int ; bdiv2 := 0 ;
    var adiv3 : int ; adiv3 := 0 ;
    var bdiv3 : int ; bdiv3 := 0 ;
    var adiv5 : int ; adiv5 := 0 ;
    var bdiv5 : int ; bdiv5 := 0 ;
    while (a mod 2 = 0) do (     adiv2 := adiv2 + 1 ; 
     a := a/(2) ) ; 
    while (a mod 3 = 0) do (     adiv3 := adiv3 + 1 ; 
     a := a/(3) ) ; 
    while (a mod 5 = 0) do (     adiv5 := adiv5 + 1 ; 
     a := a/(5) ) ; 
    while (b mod 2 = 0) do (     bdiv2 := bdiv2 + 1 ; 
     b := b/(2) ) ; 
    while (b mod 3 = 0) do (     bdiv3 := bdiv3 + 1 ; 
     b := b/(3) ) ; 
    while (b mod 5 = 0) do (     bdiv5 := bdiv5 + 1 ; 
     b := b/(5) ) ; 
    if (a = b) then (     OclFile["System.out"].println(if adiv2 - bdiv2 < 0 then -(adiv2 - bdiv2) else adiv2 - bdiv2 endif + if adiv3 - bdiv3 < 0 then -(adiv3 - bdiv3) else adiv3 - bdiv3 endif + if adiv5 - bdiv5 < 0 then -(adiv5 - bdiv5) else adiv5 - bdiv5 endif) ) else (     OclFile["System.out"].println(-1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution5 {
  public static int gcd(int a,int b){
    if(b==0){
      return a ;
    }
    return gcd(b,a % b);
  }
  public static int construct(int x,int gd){
    if(x==gd){
      return 0 ;
    }
    if(x<gd ||(x % 2!=0 && x % 3!=0 && x % 5!=0)){
      return 1000000000 ;
    }
    int k1=Integer.MAX_VALUE ;
    int k2=Integer.MAX_VALUE ;
    int k3=Integer.MAX_VALUE ;
    if(x % 2==0){
      k1=1+construct(x/2,gd);
    }
    if(x % 3==0){
      k2=1+construct(x/3,gd);
    }
    if(x % 5==0){
      k3=1+construct(x/5,gd);
    }
    return Math.min(k1,Math.min(k2,k3));
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int g=gcd(a,b);
    int x1=construct(a,g);
    int x2=construct(b,g);
    if(x1>=1000000000 || x2>=1000000000){
      System.out.println(-1);
    }
    else {
      System.out.println(x1+x2);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution5 {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else skip ; 
     return gcd(b, a mod b) );
  static   operation construct( x : int, gd : int) : int
  pre: true
  post: true
  activity: (     if (x = gd) then (     return 0 ) else skip ; 
     if (x < gd or (x mod 2 /= 0 & x mod 3 /= 0 & x mod 5 /= 0)) then (     return 1000000000 ) else skip ; 
    var k1 : int ; k1 := 2147483647 ;
    var k2 : int ; k2 := 2147483647 ;
    var k3 : int ; k3 := 2147483647 ;
    if (x mod 2 = 0) then (     k1 := 1 + construct(x / 2, gd) ) else skip ; 
    if (x mod 3 = 0) then (     k2 := 1 + construct(x / 3, gd) ) else skip ; 
    if (x mod 5 = 0) then (     k3 := 1 + construct(x / 5, gd) ) else skip ; 
    return Set{k1, Set{k2, k3}->min()}->min() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var g : int ; g := gcd(a, b) ;
    var x1 : int ; x1 := construct(a, g) ;
    var x2 : int ; x2 := construct(b, g) ;
    if (x1 >= 1000000000 or x2 >= 1000000000) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(x1 + x2) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int l=sc.nextInt();
    int n=sc.nextInt();
    String s=sc.next();
    long oocnt=0 ;
    for(int i=0 ; i<s.length()-1 ; ++i){
      if(s.charAt(i)=='o' && s.charAt(i+1)=='o')++oocnt ;
    }
    long total_oocnt=0 ;
    for(int i=0 ; i<n ; ++i){
      total_oocnt+=oocnt ;
      oocnt*=2 ;
    }
    System.out.println(3*total_oocnt+s.length());
  }
  public static void main(String[] a){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var oocnt : long ; oocnt := 0 ;
        var i : int ; i := 0 ; while i < s->size() - 1 do ( (     if (s->at(i+1) = 'o' & s->at(i + 1+1) = 'o') then     oocnt := oocnt + 1 ; else skip )  ;     i := i + 1 ) ; 
    var total_oocnt : long ; total_oocnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     total_oocnt := total_oocnt+(oocnt) ; 
     oocnt := oocnt*(2) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(3 * total_oocnt + s->size()) ; 
 );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GfG {
  public static int findNumbers(int N){
    ArrayList<Integer>v=new ArrayList<Integer>();
    while(N>0){
      int n=N,m=0,p=1 ;
      while(n>0){
        if(n % 10!=0)m+=p ;
        n/=10 ;
        p*=10 ;
      }
      v.add(m);
      N-=m ;
    }
    for(int i=0 ; i<v.size(); i++)System.out.print(" "+v.get(i));
    return 0 ;
  }
  public static void main(String[] args){
    int N=31 ;
    findNumbers(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation findNumbers( N : int) : int
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Sequence{} ;
     while (N > 0) do (     var n : int ; n := N ;
    var m : int ; m := 0 ;
    var p : int ; p := 1 ;
     while (n > 0) do (     if (n mod 10 /= 0) then     m := m+(p) ; else skip ; 
     n := n/(10) ; 
     p := p*(10) ) ; 
     v := v->including(m) ; 
     N := N-(m) ) ; 
         var i : int ; i := 0 ; while i < v->size() do (     OclFile["System.out"].print(" " + v->at(i+1)) ;  ;     i := i + 1 ) ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 31 ;
     execute findNumbers(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Set ;
public final class p271 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p271().run());
  }
  private static final int[] FACTORS={
    2,3,5,7,11,13,17,19,23,29,31,37,41,43 };
    private List<Set<Integer>>factorSolutions=new ArrayList<>();
    public String run(){
      for(int fact : FACTORS){
        Set<Integer>sols=new HashSet<>();
        for(int j=1 ; j<fact ; j++){
          if(Library.powMod(j,3,fact)==1)sols.add(j);
        }
        factorSolutions.add(sols);
      }
      BigInteger sum=buildAndSumSolutions(0,BigInteger.ZERO,BigInteger.ONE);
      return sum.subtract(BigInteger.ONE).toString();
    }
    private BigInteger buildAndSumSolutions(int factorIndex,BigInteger x,BigInteger m){
      if(factorIndex==FACTORS.length)return x ;
      else {
        BigInteger result=BigInteger.ZERO ;
        BigInteger fact=BigInteger.valueOf(FACTORS[factorIndex]);
        for(int sol : factorSolutions.get(factorIndex)){
          BigInteger newx=chineseRemainderTheorem(x,m,BigInteger.valueOf(sol),fact);
          BigInteger temp=buildAndSumSolutions(factorIndex+1,newx,m.multiply(fact));
          result=result.add(temp);
        }
        return result ;
      }
    }
    private static BigInteger chineseRemainderTheorem(BigInteger a,BigInteger p,BigInteger b,BigInteger q){
      return a.add(b.subtract(a).multiply(p.modInverse(q)).multiply(p)).mod(p.multiply(q));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class p271 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p271.newp271().run()) );
  static    attribute FACTORS : Sequence(int) := Sequence{2,3,5,7,11,13,17,19,23,29,31,37,41,43};
   attribute factorSolutions : Sequence(Set(int)) := Sequence{};
   operation run() : String
  pre: true
  post: true
  activity: (     for (fact : FACTORS) do ( (     var sols : Set(int) ; sols := Set{} ;
         var j : int ; j := 1 ; while j < fact do ( (     if (Library.powMod(j, 3, fact) = 1) then     sols := sols->including(j) ; else skip )  ;     j := j + 1 ) ; 
     factorSolutions := factorSolutions->including(sols) )  ) ; 
     var sum : long ; sum := buildAndSumSolutions(0, 0, 1) ;
     return sum.subtract(1)+"" );
   operation buildAndSumSolutions( factorIndex : int, x : long, m : long) : long
  pre: true
  post: true
  activity: (     if (factorIndex = FACTORS->size()) then     return x else (     var result : long ; result := 0 ;
     var fact : long ; fact := (FACTORS[factorIndex+1] + "")->toLong() ;
     for (sol : factorSolutions->at(factorIndex+1)) do ( (     var newx : long ; newx := chineseRemainderTheorem(x, m, (sol + "")->toLong(), fact) ;
     var temp : long ; temp := buildAndSumSolutions(factorIndex + 1, newx, m.multiply(fact)) ;
     result := result->excludes(temp) )  ) ; 
     return result ) );
  static   operation chineseRemainderTheorem( a : long, p : long, b : long, q : long) : long
  pre: true
  post: true
  activity: (     return a->excludes(b.subtract(a).multiply(p.modInverse(q)).multiply(p)).mod(p.multiply(q)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int factorial(int n){
    return(n==1 || n==0)? 1 : n*factorial(n-1);
  }
  public static void main(String[] args){
    int num=5 ;
    System.out.println("Factorial of "+num+" is "+factorial(num));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation factorial( n : int) : int
  pre: true
  post: true
  activity: (     return if (n = 1 or n = 0) then 1 else n * factorial(n - 1) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 5 ;
     OclFile["System.out"].println("Factorial of " + num + " is " + factorial(num)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int dp[][];
  public static void computeDpArray(int arr[],int n){
    for(int i=0 ; i<n ; ++i){
      for(int j=1 ; j<=15000 ; ++j){
        if(i==0 && j==arr[i])dp[i][j]=1 ;
        else if(i==0)dp[i][j]=0 ;
        else if(arr[i]==j)dp[i][j]=dp[i-1][j]+1 ;
        else dp[i][j]=dp[i-1][j];
      }
    }
  }
  public static int countTripletSum(int arr[],int n){
    computeDpArray(arr,n);
    int ans=0 ;
    for(int i=0 ; i<n-2 ; ++i){
      for(int j=i+1 ; j<n-1 ; ++j){
        for(int k=1 ; k<=24 ; ++k){
          int cube=k*k*k ;
          int rem=cube-(arr[i]+arr[j]);
          if(rem>0)ans+=dp[n-1][rem]-dp[j][rem];
        }
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      2,5,1,20,6 };
      int n=arr.length ;
      dp=new int[1001][15001];
      System.out.println(countTripletSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute dp : Sequence(Sequence(int));
  static   operation computeDpArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 1 ; while j <= 15000 do ( (     if (i = 0 & j = arr[i+1]) then     dp[i+1][j+1] := 1 ; else     if (i = 0) then     dp[i+1][j+1] := 0 else     if (arr[i+1] = j) then     dp[i+1][j+1] := dp[i - 1+1][j+1] + 1 else     dp[i+1][j+1] := dp[i - 1+1][j+1] ; ;  ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation countTripletSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     execute computeDpArray(arr, n) ; 
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n - 2 do ( (         var j : int ; j := i + 1 ; while j < n - 1 do ( (         var k : int ; k := 1 ; while k <= 24 do ( (     var cube : int ; cube := k * k * k ;
     var rem : int ; rem := cube - (arr[i+1] + arr[j+1]) ;
     if (rem > 0) then     ans := ans+(dp[n - 1+1][rem+1] - dp[j+1][rem+1]) ; else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,5,1,20,6} ;
     var n : int ; n := arr->size() ;
     dp := Integer.subrange(1,1001)->collect(Integer.subrange(1,15001)->collect(0)) ; 
     OclFile["System.out"].println(countTripletSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  static final Scanner cin=new Scanner(System.in);
  public static void main(String[] args){
    int t=cin.nextInt();
    while(t>0){
      solve();
      t--;
    }
  }
  public static void solve(){
    int size=cin.nextInt();
    int[] arr=new int[size];
    int sum=0 ;
    int one=0 ;
    int two=0 ;
    for(int i=0 ; i<size ; i++){
      arr[i]=cin.nextInt();
      if(arr[i]==1)one++;
      if(arr[i]==2)two++;
      sum+=arr[i];
    }
    if(sum % 2==1){
      System.out.println("NO");
      return ;
    }
    int curr=0 ;
    int two_required=(sum/2)/2 ;
    if(two_required>two){
      two_required=two ;
    }
    curr=two_required*2 ;
    int rem=sum/2-curr ;
    if(one>=rem){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute cin : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := cin.getCurrent()->toInteger() ;
     while (t > 0) do (     execute solve() ; 
     t := t - 1 ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var size : int ; size := cin.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
    var sum : int ; sum := 0 ;
    var one : int ; one := 0 ;
    var two : int ; two := 0 ;
        var i : int ; i := 0 ; while i < size do ( (     arr[i+1] := cin.getCurrent()->toInteger() ; 
     if (arr[i+1] = 1) then     one := one + 1 ; else skip ; 
     if (arr[i+1] = 2) then     two := two + 1 ; else skip ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    if (sum mod 2 = 1) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    var curr : int ; curr := 0 ;
    var two_required : int ; two_required := (sum / 2) / 2 ;
    if (two_required > two) then (     two_required := two ) else skip ; 
    curr := two_required * 2 ; 
    var rem : int ; rem := sum / 2 - curr ;
    if (one >= rem) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner scan=new Scanner(System.in);
    int A=scan.nextInt();
    int B=scan.nextInt();
    int C=scan.nextInt();
    if(A<=C && B>=C){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := scan.getCurrent()->toInteger() ;
    var B : int ; B := scan.getCurrent()->toInteger() ;
    var C : int ; C := scan.getCurrent()->toInteger() ;
    if (A <= C & B >= C) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Fair {
  public static void main(String[] args){
    Scanner o=new Scanner(System.in);
    int t=o.nextInt();
    while(t-->0){
      int n=o.nextInt(),sum=0 ;
      boolean cont1=false ;
      for(int i=0 ; i<n ; i++){
        int elt=o.nextInt();
        if(elt==1)cont1=true ;
        sum+=elt ;
      }
      if(sum % 2==1)System.out.println("NO");
      else {
        if(! cont1 &&(sum/2)% 2==1)System.out.println("NO");
        else System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Fair {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : OclFile ; o := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := o.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := o.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
     var cont1 : boolean ; cont1 := false ;
         var i : int ; i := 0 ; while i < n do ( (     var elt : int ; elt := o.getCurrent()->toInteger() ;
     if (elt = 1) then     cont1 := true ; else skip ; 
     sum := sum+(elt) )  ;     i := i + 1 ) ; 
     if (sum mod 2 = 1) then     OclFile["System.out"].println("NO") ; else (     if (not(cont1) & (sum / 2) mod 2 = 1) then     OclFile["System.out"].println("NO") ; else     OclFile["System.out"].println("YES") ; ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int k=sc.nextInt();
    int answer=0 ;
    int max=a ;
    int other1=b ;
    int other2=c ;
    if(b>max){
      max=b ;
      other1=a ;
      other2=c ;
    }
    if(c>max){
      max=c ;
      other1=a ;
      other2=b ;
    }
    for(int i=0 ; i<k ; i++){
      max*=2 ;
    }
    System.out.print(max+other1+other2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var answer : int ; answer := 0 ;
    var max : int ; max := a ;
    var other1 : int ; other1 := b ;
    var other2 : int ; other2 := c ;
    if (b > max) then (     max := b ; 
     other1 := a ; 
     other2 := c ) else skip ; 
    if (c > max) then (     max := c ; 
     other1 := a ; 
     other2 := b ) else skip ; 
        var i : int ; i := 0 ; while i < k do ( (     max := max*(2) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(max + other1 + other2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static final Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    int a=scanner.nextInt();
    int b=scanner.nextInt();
    int c=scanner.nextInt();
    int k=scanner.nextInt();
    solve(a,b,c,k);
  }
  static void solve(int a,int b,int c,int k){
    int a1=a ;
    int b1=b ;
    int c1=c ;
    int res=0 ;
    for(int i=0 ; i<k ; i++){
      a1*=2 ;
    }
    res=Math.max(res,a1+b1+c1);
    a1=a ;
    b1=b ;
    c1=c ;
    for(int i=0 ; i<k ; i++){
      b1*=2 ;
    }
    res=Math.max(res,a1+b1+c1);
    a1=a ;
    b1=b ;
    c1=c ;
    for(int i=0 ; i<k ; i++){
      c1*=2 ;
    }
    res=Math.max(res,a1+b1+c1);
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
    execute solve(a, b, c, k) ; 
 );
  static   operation solve( a : int, b : int, c : int, k : int) : void
  pre: true
  post: true
  activity: (     var a1 : int ; a1 := a ;
     var b1 : int ; b1 := b ;
    var c1 : int ; c1 := c ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     a1 := a1*(2) )  ;     i := i + 1 ) ; 
    res := Set{res, a1 + b1 + c1}->max() ; 
    a1 := a ; 
    b1 := b ; 
    c1 := c ; 
        var i : int ; i := 0 ; while i < k do ( (     b1 := b1*(2) )  ;     i := i + 1 ) ; 
    res := Set{res, a1 + b1 + c1}->max() ; 
    a1 := a ; 
    b1 := b ; 
    c1 := c ; 
        var i : int ; i := 0 ; while i < k do ( (     c1 := c1*(2) )  ;     i := i + 1 ) ; 
    res := Set{res, a1 + b1 + c1}->max() ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] input=br.readLine().split(" ");
    int A[]=new int[3];
    for(int i=0 ; i<3 ; i++){
      A[i]=Integer.parseInt(input[i]);
    }
    Arrays.sort(A);
    int n=Integer.parseInt(br.readLine());
    while(n-->0)A[2]=A[2]*2 ;
    System.out.println(A[0]+A[1]+A[2]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : Sequence(String) ; input := br.readLine()->split(" ") ;
    var A : Sequence(int) ; A := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     A[i+1] := (input[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    var n : int ; n := (br.readLine())->toInteger() ;
        while (n > 0) do (        n := n - 1 ;     skip ;     A[2+1] := A[2+1] * 2 ; ;  ) ;  
    OclFile["System.out"].println(A[0+1] + A[1+1] + A[2+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    ArrayList<Integer>a=new ArrayList<>();
    a.add(scan.nextInt());
    a.add(scan.nextInt());
    a.add(scan.nextInt());
    int n=scan.nextInt();
    int x=Collections.max(a);
    for(int i=0 ; i<n ; i++){
      x=x*2 ;
    }
    a.remove(Collections.max(a));
    a.add(x);
    int sum=0 ;
    for(Integer u : a){
      sum+=u ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Sequence{} ;
    a := a->including(scan.getCurrent()->toInteger()) ; 
    a := a->including(scan.getCurrent()->toInteger()) ; 
    a := a->including(scan.getCurrent()->toInteger()) ; 
    var n : int ; n := scan.getCurrent()->toInteger() ;
    var x : int ; x := .max(a) ;
        var i : int ; i := 0 ; while i < n do ( (     x := x * 2 )  ;     i := i + 1 ) ; 
    a := a->excludingFirst( a->max()) ; 
    a := a->including(x) ; 
    var sum : int ; sum := 0 ;
    for (u : a) do ( (     sum := sum+(u) )  ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int numberOfCuts(int M,int N){
    int result=0 ;
    result=(M-1)*(N-1);
    return result ;
  }
  public static void main(String args[]){
    int M=4,N=4 ;
    int Cuts=numberOfCuts(M,N);
    System.out.println("Maximum cuts="+Cuts);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation numberOfCuts( M : int, N : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     result := (M - 1) * (N - 1) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var M : int ; M := 4 ;
    var N : int ; N := 4 ;
     var Cuts : int ; Cuts := numberOfCuts(M, N) ;
     OclFile["System.out"].println("Maximum cuts=" + Cuts) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Collections ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayList<Integer>list=new ArrayList<Integer>();
    for(int i=0 ; i<3 ; i++){
      list.add(sc.nextInt());
    }
    Collections.sort(list);
    int K=sc.nextInt();
    int max=list.get(2);
    for(int i=0 ; i<K ; i++){
      max*=2 ;
    }
    System.out.println(list.get(0)+list.get(1)+max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < 3 do ( (     list := list->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var max : int ; max := list->at(2+1) ;
        var i : int ; i := 0 ; while i < K do ( (     max := max*(2) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(list->at(0+1) + list->at(1+1) + max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    HashSet<Long>l=new HashSet<>();
    long j=s.nextLong();
    long k=j-1 ;
    for(long i=2 ; i*i<=j ; ++i){
      if(j % i==0){
        f(i,j,l);
        f(j/i,j,l);
      }
      if(k % i==0){
        f(i,j,l);
        f(k/i,j,l);
      }
    }
    System.out.println(j<=3 ? j-1 : l.size()+2);
  }
  private static void f(long i,long k,HashSet<Long>l){
    while(k % i==0){
      k/=i ;
    }
    if(k % i==1)l.add(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : Set(long) ; l := Set{} ;
    var j : long ; j := s.getCurrent()->toLong() ;
    var k : long ; k := j - 1 ;
        var i : long ; i := 2 ; while i * i <= j do ( (     if (j mod i = 0) then (     execute f(i, j, l) ; 
     execute f(j / i, j, l) ) else skip ; 
     if (k mod i = 0) then (     execute f(i, j, l) ; 
     execute f(k / i, j, l) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if j <= 3 then j - 1 else l->size() + 2 endif) ; 
 );
  static   operation f( i : long, k : long, l : Set(long)) : void
  pre: true
  post: true
  activity: (     while (k mod i = 0) do (     k := k/(i) ) ; 
     if (k mod i = 1) then     l := l->including(i) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private void solve(){
    long n=sc.nextLong();
    long m=n-1 ;
    long x=2 ;
    long ans=n==2 ? 1 : 2 ;
    while(x*x<m){
      if(m % x==0){
        ans+=2 ;
      }
++x ;
    }
    if(x*x==m){
++ans ;
    }
    x=2 ;
    while(x*x<=n){
      if(n % x==0){
        long y=n ;
        while(y % x==0){
          y/=x ;
        }
        if(y % x==1){
++ans ;
        }
      }
++x ;
    }
    out.println(ans);
  }
  private static PrintWriter out ;
  private static MyScanner sc ;
  private static class MyScanner {
    BufferedReader br ;
    StringTokenizer st ;
    private 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());
    }
  }
  public static void main(String[] args){
    out=new PrintWriter(new BufferedOutputStream(System.out));
    sc=new MyScanner();
    new Main().solve();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.nextLong() ;
     var m : long ; m := n - 1 ;
    var x : long ; x := 2 ;
    var ans : long ; ans := if n = 2 then 1 else 2 endif ;
    while (x * x < m) do (     if (m mod x = 0) then (     ans := ans+(2) ) else skip ; 
     x := x + 1 ) ; 
    if (x * x = m) then (     ans := ans + 1 ) else skip ; 
    x := 2 ; 
    while (x * x <= n) do (     if (n mod x = 0) then (     var y : long ; y := n ;
     while (y mod x = 0) do (     y := y/(x) ) ; 
     if (y mod x = 1) then (     ans := ans + 1 ) else skip ) else skip ; 
     x := x + 1 ) ; 
    out.println(ans) ; 
 );
  static   attribute out : OclFile;
  static   attribute sc : MyScanner;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
     sc := MyScanner.newMyScanner() ; 
     Main.newMain().solve() ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    if(n==2){
      System.out.println(1);
      return ;
    }
    HashSet<Long>hs=calc_n1(n-1);
    hs=calc_n0(n,hs);
    System.out.println(hs.size());
  }
  public static HashSet<Long>calc_n1(long l){
    long max=(long)Math.pow(l,0.5)+1 ;
    HashSet<Long>ret=new HashSet<>();
    ret.add(l-1);
    for(long i=2 ; i<max ; i++){
      if(l % i==0){
        ret.add(l/i);
        ret.add(i);
      }
    }
    return ret ;
  }
  public static HashSet<Long>calc_n0(long l,HashSet<Long>hs){
    long max=(long)Math.pow(l,0.5)+1 ;
    hs.add(l);
    for(long i=2 ; i<max ; i++){
      long l2=l ;
      boolean div=false ;
      while(l2 % i==0){
        l2/=i ;
        div=true ;
      }
      if(l2 % i==1 && div){
        hs.add(i);
      }
    }
    return hs ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    if (n = 2) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    var hs : Set(long) ; hs := calc_n1(n - 1) ;
    hs := calc_n0(n, hs) ; 
    OclFile["System.out"].println(hs->size()) ; 
 );
  static   operation calc_n1( l : long) : Set(long)
  pre: true
  post: true
  activity: (     var max : long ; max := l->pow(0.5)->oclAsType(long) + 1 ;
     var ret : Set(long) ; ret := Set{} ;
    ret := ret->including(l - 1) ; 
        var i : long ; i := 2 ; while i < max do ( (     if (l mod i = 0) then (     ret := ret->including(l / i) ; 
     ret := ret->including(i) ) else skip )  ;     i := i + 1 ) ; 
    return ret 
 );
  static   operation calc_n0( l : long, hs : Set(long)) : Set(long)
  pre: true
  post: true
  activity: (     var max : long ; max := l->pow(0.5)->oclAsType(long) + 1 ;
     hs := hs->including(l) ; 
         var i : long ; i := 2 ; while i < max do ( (     var l2 : long ; l2 := l ;
     var div : boolean ; div := false ;
     while (l2 mod i = 0) do (     l2 := l2/(i) ; 
     div := true ) ; 
     if (l2 mod i = 1 & div) then (     hs := hs->including(i) ) else skip )  ;     i := i + 1 ) ; 
     return hs );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  void solve(){
    int a=inint(),b=inint(),c=inint();
    out.println(c>=a && c<=b ? "Yes" : "No");
  }
  public static Scanner in=new Scanner(System.in);
  public static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    new Main().solve();
    out.flush();
  }
  public int inint(){
    return in.nextInt();
  }
  public long inlong(){
    return in.nextLong();
  }
  public String instr(){
    return in.next();
  }
  public char inchar(){
    return in.next().charAt(0);
  }
  public int[] inintar(int num){
    int[] a=new int[num];
    for(int i=0 ; i<num ; i++){
      a[i]=in.nextInt();
    }
    return a ;
  }
  public char[] incharar(){
    return in.next().toCharArray();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ; a := inint() ;
    var b : int ; b := inint() ;
    var c : int ; c := inint() ;
     out.println(if c >= a & c <= b then "Yes" else "No" endif) );
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() ; 
     skip );
   operation inint() : int
  pre: true
  post: true
  activity: (     return in.getCurrent()->toInteger() );
   operation inlong() : long
  pre: true
  post: true
  activity: (     return in.getCurrent()->toLong() );
   operation instr() : String
  pre: true
  post: true
  activity: (     return in.getCurrent() );
   operation inchar() : String
  pre: true
  post: true
  activity: (     return in.getCurrent()->at(0+1) );
   operation inintar( num : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,num)->collect(0) ;
         var i : int ; i := 0 ; while i < num do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return a );
   operation incharar() : Sequence(String)
  pre: true
  post: true
  activity: (     return in.getCurrent()->characters() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static boolean isOk(long n,long k){
    while(n % k==0){
      n=n/k ;
    }
    return n % k==1 ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    int ans=1 ;
    for(long k=2 ; k*k<=n ; k++){
      if(n % k==0){
        if(isOk(n,k)){
          ans++;
        }
        if(n/k!=k && isOk(n,n/k)){
          ans++;
        }
      }
    }
    if(n>2){
      ans++;
      for(long k=2 ; k*k<=n-1 ; k++){
        if((n-1)% k==0){
          ans++;
          if((n-1)/k!=k){
            ans++;
          }
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation isOk( n : long, k : long) : boolean
  pre: true
  post: true
  activity: (     while (n mod k = 0) do (     n := n / k ) ; 
     return n mod k = 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var ans : int ; ans := 1 ;
        var k : long ; k := 2 ; while k * k <= n do ( (     if (n mod k = 0) then (     if (isOk(n, k)) then (     ans := ans + 1 ) else skip ; 
     if (n / k /= k & isOk(n, n / k)) then (     ans := ans + 1 ) else skip ) else skip )  ;     k := k + 1 ) ; 
    if (n > 2) then (     ans := ans + 1 ; 
         var k : long ; k := 2 ; while k * k <= n - 1 do ( (     if ((n - 1) mod k = 0) then (     ans := ans + 1 ; 
     if ((n - 1) / k /= k) then (     ans := ans + 1 ) else skip ) else skip )  ;     k := k + 1 ) ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    long N=scan.nextLong();
    Set<Long>divisors=new HashSet<>();
    for(long i=1 ; i*i<=N-1 ; i++){
      if((N-1)% i!=0){
        continue ;
      }
      divisors.add(i);
      divisors.add((N-1)/i);
    }
    divisors.remove(1L);
    Set<Long>set=new HashSet<>();
    for(long i=1 ; i*i<=N ; i++){
      if(N % i!=0){
        continue ;
      }
      set.add(i);
      set.add(N/i);
    }
    set.remove(1L);
    for(long i : set){
      long target=N ;
      while(target % i==0){
        target/=i ;
      }
      if((target-1)% i==0){
        divisors.add(i);
      }
    }
    System.out.println(divisors.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : long ; N := scan.getCurrent()->toLong() ;
    var divisors : Set(long) ; divisors := Set{} ;
        var i : long ; i := 1 ; while i * i <= N - 1 do ( (     if ((N - 1) mod i /= 0) then (     continue ) else skip ; 
     divisors := divisors->including(i) ; 
     divisors := divisors->including((N - 1) / i) )  ;     i := i + 1 ) ; 
    divisors := divisors->excludingAt(1L+1) ; 
    var set : Set(long) ; set := Set{} ;
        var i : long ; i := 1 ; while i * i <= N do ( (     if (N mod i /= 0) then (     continue ) else skip ; 
     set := set->including(i) ; 
     set := set->including(N / i) )  ;     i := i + 1 ) ; 
    set := set->excludingAt(1L+1) ; 
    for (i : set) do ( (     var target : long ; target := N ;
     while (target mod i = 0) do (     target := target/(i) ) ; 
     if ((target - 1) mod i = 0) then (     divisors := divisors->including(i) ) else skip )  ) ; 
    OclFile["System.out"].println(divisors->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.io.*;
class GFG {
  static int pairs_count(int arr[],int n,int sum){
    int ans=0 ;
    Arrays.sort(arr);
    int i=0,j=n-1 ;
    while(i<j){
      if(arr[i]+arr[j]<sum)i++;
      else if(arr[i]+arr[j]>sum)j--;
      else {
        int x=arr[i],xx=i ;
        while((i<j)&&(arr[i]==x))i++;
        int y=arr[j],yy=j ;
        while((j>=i)&&(arr[j]==y))j--;
        if(x==y){
          int temp=i-xx+yy-j-1 ;
          ans+=(temp*(temp+1))/2 ;
        }
        else ans+=(i-xx)*(yy-j);
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      1,5,7,5,-1 };
      int n=arr.length ;
      int sum=6 ;
      System.out.println(pairs_count(arr,n,sum));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation pairs_count( arr : Sequence(int), n : int, sum : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     arr := arr->sort() ; 
    var i : int ; i := 0 ;
    var j : int ; j := n - 1 ;
    while (i < j) do (     if (arr[i+1] + arr[j+1] < sum) then     i := i + 1 ; else     if (arr[i+1] + arr[j+1] > sum) then     j := j - 1 else (     var x : int ; x := arr[i+1] ;
    var xx : int ; xx := i ;
     while ((i < j) & (arr[i+1] = x)) do     i := i + 1 ; ; 
    var y : int ; y := arr[j+1] ;
    var yy : int ; yy := j ;
    while ((j >= i) & (arr[j+1] = y)) do     j := j - 1 ; ; 
    if (x = y) then (     var temp : int ; temp := i - xx + yy - j - 1 ;
     ans := ans+((temp * (temp + 1)) / 2) ) else     ans := ans+((i - xx) * (yy - j)) ; ;  
 ) ;  ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,7,5,-1} ;
     var n : int ; n := arr->size() ;
     var sum : int ; sum := 6 ;
     OclFile["System.out"].println(pairs_count(arr, n, sum)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
import java.text.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    for(int iter=0 ; iter<n ; iter++){
      BigInteger a=in.nextBigInteger(),b=in.nextBigInteger();
      String str=a.add(b).toString();
      if(str.length()>80){
        System.out.println("overflow");
      }
      else System.out.println(str);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         var iter : int ; iter := 0 ; while iter < n do ( (     var a : long ; a := in.nextBigInteger() ;
    var b : long ; b := in.nextBigInteger() ;
     var str : String ; str := a->excludes(b)+"" ;
     if (str->size() > 80) then (     OclFile["System.out"].println("overflow") ) else     OclFile["System.out"].println(str) ; )  ;     iter := iter + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Fraction {
  long num ;
  long denom ;
  Fraction(int num,int denom){
    this.num=num ;
    this.denom=denom ;
    reduction();
  }
  void reduction(){
    long gcdA=gcd(num,denom);
    num/=gcdA ;
    denom/=gcdA ;
  }
  long gcd(long x,long y){
    if(y==0){
      return x ;
    }
    else {
      return gcd(y,x % y);
    }
  }
  void add(Fraction fraction){
    num=fraction.denom*num+fraction.num*denom ;
    denom*=fraction.denom ;
    reduction();
  }
  void mul(Fraction fraction){
    num*=fraction.num ;
    denom*=fraction.denom ;
    reduction();
  }
  double value(){
    return(double)num/denom ;
  }
}
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] line=br.readLine().split(" ");
    int x=Integer.parseInt(line[0]);
    int y=Integer.parseInt(line[1]);
    Fraction posX=new Fraction(0,1);
    Fraction posY=new Fraction(0,1);
    Fraction diffX=new Fraction(1,y);
    Fraction diffY=new Fraction(1,2*x);
    int result=0 ;
    while(posX.value()<=2*x){
      if(posX.denom==1 &&(posX.num % 2==0)){
        result++;
      }
      else if(posY.denom==1){
        result++;
      }
      posX.add(diffX);
      posY.add(diffY);
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Fraction {
   attribute num : long;
   attribute denom : long;
   static operation newFraction( num : int, denom : int) : Fraction
  pre: true
  post: true
  activity:
  ( var self : Fraction ;
    self := createFraction();
    self.initialise(num, denom);
    return self );
  operation initialise( num : int, denom : int) : void
  pre: true  post: true
  activity: (     self.num := num ; 
     self.denom := denom ; 
     execute reduction() );
   operation reduction() : void
  pre: true
  post: true
  activity: (     var gcdA : long ; gcdA := gcd(num, denom) ;
     num := num/(gcdA) ; 
     denom := denom/(gcdA) );
   operation gcd( x : long, y : long) : long
  pre: true
  post: true
  activity: (     if (y = 0) then (     return x ) else (     return gcd(y, x mod y) ) );
   operation add( fraction : Fraction) : void
  pre: true
  post: true
  activity: (     num := fraction.denom * num + fraction.num * denom ; 
     denom := denom*(fraction.denom) ; 
     execute reduction() );
   operation mul( fraction : Fraction) : void
  pre: true
  post: true
  activity: (     num := num*(fraction.num) ; 
     denom := denom*(fraction.denom) ; 
     execute reduction() );
   operation value() : double
  pre: true
  post: true
  activity: (     return num->oclAsType(double) / denom );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var x : int ; x := (line[0+1])->toInteger() ;
    var y : int ; y := (line[1+1])->toInteger() ;
    var posX : Fraction ; posX := Fraction.newFraction(0, 1) ;
    var posY : Fraction ; posY := Fraction.newFraction(0, 1) ;
    var diffX : Fraction ; diffX := Fraction.newFraction(1, y) ;
    var diffY : Fraction ; diffY := Fraction.newFraction(1, 2 * x) ;
    var result : int ; result := 0 ;
    while (posX.value() <= 2 * x) do (     if (posX.denom = 1 & (posX.num mod 2 = 0)) then (     result := result + 1 ) else     if (posY.denom = 1) then (     result := result + 1 ) else skip ; ;  
     posX->excludes(diffX) ; 
     posY->excludes(diffY) ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.System.out ;
import static java.lang.Integer.parseInt ;
import java.math.BigDecimal ;
import java.io.File ;
import java.util.Scanner ;
public class Main extends BaseExe {
  public static void main(String[] args){
    new Main().exeSysIn();
  }
  @ Override protected void execute(){
    int dataCount=parseInt(nextLine());
    for(int count=0 ; count<dataCount ; count++){
      BigDecimal x=new BigDecimal(nextLine());
      BigDecimal y=new BigDecimal(nextLine());
      BigDecimal sum=x.add(y);
      if(sum.precision()>80){
        out.println("overflow");
      }
      else {
        out.println(sum);
      }
    }
  }
}
abstract class BaseExe {
  private Scanner scan ;
  private String inData ;
  public void exeSysIn(){
    try(Scanner scan=new Scanner(System.in)){
      exeCtrl(scan);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  public void exeFileIn(String inDataPath){
    try(Scanner scan=new Scanner(new File(inDataPath))){
      exeCtrl(scan);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  private void exeCtrl(Scanner scan){
    this.scan=scan ;
    execute();
  }
  protected abstract void execute();
  protected String nextLine(){
    return scan.nextLine();
  }
  protected boolean judgeInData(){
    return hasNextLine()&& isNotEmptyInData();
  }
  protected boolean hasNextLine(){
    return scan.hasNextLine();
  }
  protected boolean isNotEmptyInData(){
    return ! "".equals(inData=nextLine());
  }
  protected String getInData(){
    return inData ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends BaseExe {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().exeSysIn() );
      operation execute() : void
  pre: true
  post: true
  activity: (     var dataCount : int ; dataCount := parseInt(nextLine()) ;
         var count : int ; count := 0 ; while count < dataCount do ( (     var x : double ; x := double(nextLine()) ;
     var y : double ; y := double(nextLine()) ;
     var sum : double ; sum := x->excludes(y) ;
     if (sum.precision() > 80) then (     out.println("overflow") ) else (     out.println(sum) ) )  ;     count := count + 1 ) );
}
class BaseExe {
   attribute scan : OclFile;
   attribute inData : String;
   operation exeSysIn() : void
  pre: true
  post: true
  activity: (     try (    var scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     execute exeCtrl(scan) ))   catch (e : ProgramException) do (     e.printStackTrace() )
  );
   operation exeFileIn( inDataPath : String) : void
  pre: true
  post: true
  activity: (     try (    var scan : OclFile := OclFile.newOclFile_Read(OclFile(inDataPath)) ;
 (     execute exeCtrl(scan) ))   catch (e : ProgramException) do (     e.printStackTrace() )
  );
   operation exeCtrl( scan : OclFile) : void
  pre: true
  post: true
  activity: (     self.scan := scan ; 
     execute execute() );
      operation execute() : void
  pre: true
  post: true;
     operation nextLine() : String
  pre: true
  post: true
  activity: (     return scan.nextLine() );
     operation judgeInData() : boolean
  pre: true
  post: true
  activity: (     return hasNextLine() & isNotEmptyInData() );
     operation hasNextLine() : boolean
  pre: true
  post: true
  activity: (     return scan.hasNextLine() );
     operation isNotEmptyInData() : boolean
  pre: true
  post: true
  activity: (     return not("" = inData) );
     operation getInData() : String
  pre: true
  post: true
  activity: (     return inData );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    int N=Integer.parseInt(input());
    for(int i=0 ; i<N ; i++){
      String num1=input();
      String num2=input();
      if(80<num1.length()|| 80<num2.length()){
        System.out.println("overflow");
      }
      else {
        BigInteger bigNum1=new BigInteger(num1);
        BigInteger bigNum2=new BigInteger(num2);
        String result=bigNum1.add(bigNum2).toString();
        if(80<result.toString().length()){
          System.out.println("overflow");
        }
        else {
          System.out.println(result.toString());
        }
      }
    }
    close();
  }
  public static String input(){
    return scanner.nextLine();
  }
  public static void close(){
    if(scanner!=null){
      scanner.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := (input())->toInteger() ;
         var i : int ; i := 0 ; while i < N do ( (     var num1 : String ; num1 := input() ;
     var num2 : String ; num2 := input() ;
     if (80 < num1->size() or 80 < num2->size()) then (     OclFile["System.out"].println("overflow") ) else (     var bigNum1 : long ; bigNum1 := long(num1) ;
     var bigNum2 : long ; bigNum2 := long(num2) ;
     var result : String ; result := bigNum1->excludes(bigNum2)+"" ;
     if (80 < result+""->size()) then (     OclFile["System.out"].println("overflow") ) else (     OclFile["System.out"].println(result+"") ) ) )  ;     i := i + 1 ) ; 
     execute close() );
  static   operation input() : String
  pre: true
  post: true
  activity: (     return scanner.nextLine() );
  static   operation close() : void
  pre: true
  post: true
  activity: (     if (scanner /= null) then (     skip ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int a=in.nextInt();
      int b=in.nextInt();
      int c=in.nextInt();
      if(c>=a && c<=b){
        out.println("Yes");
      }
      else {
        out.println("No");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
     var c : int ; c := in.getCurrent()->toInteger() ;
     if (c >= a & c <= b) then (     skip ) else (     skip ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class GfG {
  public static void FindAllElements(int n,int k){
    int sum=k ;
    int[] A=new int[k];
    Arrays.fill(A,0,k,1);
    for(int i=k-1 ; i>=0 ; --i){
      while(sum+A[i]<=n){
        sum+=A[i];
        A[i]*=2 ;
      }
    }
    if(sum!=n){
      System.out.print("Impossible");
    }
    else {
      for(int i=0 ; i<k ; ++i)System.out.print(A[i]+" ");
    }
  }
  public static void main(String[] args){
    int n=12 ;
    int k=6 ;
    FindAllElements(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation FindAllElements( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := k ;
     var A : Sequence(int) ; A := Integer.subrange(1,k)->collect(0) ;
    A := A->collect(1) ; 
        var i : int ; i := k - 1 ; while i >= 0 do ( (     while (sum + A[i+1] <= n) do (     sum := sum+(A[i+1]) ; 
     A[i+1] := A[i+1]*(2) ) )  ;     i := i - 1 ) ; 
    if (sum /= n) then (     OclFile["System.out"].print("Impossible") ) else (         var i : int ; i := 0 ; while i < k do (     OclFile["System.out"].print(A[i+1] + " ") ;  ;     i := i + 1 ) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     var k : int ; k := 6 ;
     execute FindAllElements(n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      long[] array=new long[n];
      for(int i=0 ; i<n ; i++)array[i]=sc.nextLong();
      int times=sc.nextInt();
      for(int i=0 ; i<times ; i++){
        int query=sc.nextInt();
        int start=sc.nextInt();
        int end=sc.nextInt();
        switch(query){
          case 0 : long min=array[start];
          for(int j=start+1 ; j<end ; j++){
            min=Math.min(min,array[j]);
          }
          System.out.println(min);
          break ;
          case 1 : long max=array[start];
          for(int j=start+1 ; j<end ; j++){
            max=Math.max(max,array[j]);
          }
          System.out.println(max);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var array : Sequence(long) ; array := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     array[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var times : int ; times := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < times do ( (     var query : int ; query := sc.getCurrent()->toInteger() ;
     var start : int ; start := sc.getCurrent()->toInteger() ;
     var end : int ; end := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (query) ; 
       if _switchval = 0 then
     var min : long ; min := array[start+1] ;
        var j : int ; j := start + 1 ; while j < end do ( (     min := Set{min, array[j+1]}->min() )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(min) ; 
    break 
   else skip ;
       if _switchval = 1 then
     var max : long ; max := array[start+1] ;
        var j : int ; j := start + 1 ; while j < end do ( (     max := Set{max, array[j+1]}->max() )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(max) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] arg){
    int a=0,b=0 ;
    Scanner sc=new Scanner(System.in);
    List<Integer>list=new ArrayList<Integer>();
    int m=sc.nextInt();
    int[] str=new int[m];
    for(int i=0 ; i<m ; i++){
      str[i]=sc.nextInt();
      list.add(new Integer(str[i]));
    }
    int n=sc.nextInt();
    for(int j=0 ; j<n ; j++){
      int d=sc.nextInt();
      switch(d){
        case 0 : a=sc.nextInt();
        b=sc.nextInt();
        List<Integer>l2=list.subList(a,b);
        int c=Collections.min(l2);
        System.out.println(c);
        break ;
        case 1 : a=sc.nextInt();
        b=sc.nextInt();
        List<Integer>l3=list.subList(a,b);
        int q=Collections.max(l3);
        System.out.println(q);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 0 ;
    var b : int ; b := 0 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var list : Sequence(int) ; list := Sequence{} ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var str : Sequence(int) ; str := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     str[i+1] := sc.getCurrent()->toInteger() ; 
     list := list->including(("" + (str[i+1]))->toInteger()) )  ;     i := i + 1 ) ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var j : int ; j := 0 ; while j < n do ( (     var d : int ; d := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (d) ; 
       if _switchval = 0 then
     a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    var l2 : Sequence(int) ; l2 := list.subrange(a+1,b) ;
    var c : int ; c := .min(l2) ;
    OclFile["System.out"].println(c) ; 
    break 
   else skip ;
       if _switchval = 1 then
     a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    var l3 : Sequence(int) ; l3 := list.subrange(a+1,b) ;
    var q : int ; q := .max(l3) ;
    OclFile["System.out"].println(q) ; 
    break 
   else skip ;
 )
 )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static ArrayList<Integer>arrA=new ArrayList<Integer>();
  static int max=0,min=0 ;
  public static void main(String[] args){
    int iNumVar=0 ;
    int iQueryComm=0 ;
    int start=0,end=0 ;
    Scanner scInputData=new Scanner(System.in);
    iNumVar=scInputData.nextInt();
    for(int iNumArr=0 ; iNumArr<iNumVar ; iNumArr++){
      arrA.add(scInputData.nextInt());
    }
    iNumVar=scInputData.nextInt();
    for(int iNumQuery=0 ; iNumQuery<iNumVar ; iNumQuery++){
      iQueryComm=scInputData.nextInt();
      start=scInputData.nextInt();
      end=scInputData.nextInt();
      switch(iQueryComm){
        case 0 : calcMin(start,end);
        break ;
        case 1 : calcMax(start,end);
        break ;
      }
    }
    scInputData.close();
  }
  private static void calcMax(int start,int end){
    max=arrA.get(start);
    for(int iFactorNum=start+1 ; iFactorNum<end ; iFactorNum++){
      max=Math.max(arrA.get(iFactorNum),max);
    }
    System.out.println(max);
  }
  private static void calcMin(int start,int end){
    min=arrA.get(start);
    for(int iFactorNum=start+1 ; iFactorNum<end ; iFactorNum++){
      min=Math.min(arrA.get(iFactorNum),min);
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute arrA : Sequence(int) := Sequence{};
  static   attribute max : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var iNumVar : int ; iNumVar := 0 ;
     var iQueryComm : int ; iQueryComm := 0 ;
    var start : int ; start := 0 ;
    var end : int ; end := 0 ;
    var scInputData : OclFile ; scInputData := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    iNumVar := scInputData.getCurrent()->toInteger() ; 
        var iNumArr : int ; iNumArr := 0 ; while iNumArr < iNumVar do ( (     arrA := arrA->including(scInputData.getCurrent()->toInteger()) )  ;     iNumArr := iNumArr + 1 ) ; 
    iNumVar := scInputData.getCurrent()->toInteger() ; 
        var iNumQuery : int ; iNumQuery := 0 ; while iNumQuery < iNumVar do ( (     iQueryComm := scInputData.getCurrent()->toInteger() ; 
     start := scInputData.getCurrent()->toInteger() ; 
     end := scInputData.getCurrent()->toInteger() ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (iQueryComm) ; 
       if _switchval = 0 then
     execute calcMin(start, end) ; 
    break 
   else skip ;
       if _switchval = 1 then
     execute calcMax(start, end) ; 
    break 
   else skip ;
 )
 )  ;     iNumQuery := iNumQuery + 1 ) ; 
    skip ; 
 );
  static   operation calcMax( start : int, end : int) : void
  pre: true
  post: true
  activity: (     max := arrA->at(start+1) ; 
         var iFactorNum : int ; iFactorNum := start + 1 ; while iFactorNum < end do ( (     max := Set{arrA->at(iFactorNum+1), max}->max() )  ;     iFactorNum := iFactorNum + 1 ) ; 
     OclFile["System.out"].println(max) );
  static   operation calcMin( start : int, end : int) : void
  pre: true
  post: true
  activity: (     min := arrA->at(start+1) ; 
         var iFactorNum : int ; iFactorNum := start + 1 ; while iFactorNum < end do ( (     min := Set{arrA->at(iFactorNum+1), min}->min() )  ;     iFactorNum := iFactorNum + 1 ) ; 
     OclFile["System.out"].println(min) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=Integer.parseInt(in.next()),A[]=new int[n];
    for(int i=0 ; i<n ; i++)A[i]=Integer.parseInt(in.next());
    int q=Integer.parseInt(in.next());
    for(int i=0 ; i<q ; i++){
      int com=Integer.parseInt(in.next()),b=Integer.parseInt(in.next()),e=Integer.parseInt(in.next());
      if(com==0){
        int min=A[b];
        for(int j=b+1 ; j<e ; j++){
          if(A[j]<min)min=A[j];
        }
        out.println(min);
      }
      else {
        int max=A[b];
        for(int j=b+1 ; j<e ; j++){
          if(A[j]>max)max=A[j];
        }
        out.println(max);
      }
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (in.getCurrent())->toInteger() ;
    var A : Sequence(void) ; A := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     A[i+1] := (in.getCurrent())->toInteger() ;  ;     i := i + 1 ) ; 
    var q : int ; q := (in.getCurrent())->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var com : int ; com := (in.getCurrent())->toInteger() ;
    var b : int ; b := (in.getCurrent())->toInteger() ;
    var e : int ; e := (in.getCurrent())->toInteger() ;
     if (com = 0) then (     var min : int ; min := A[b+1] ;
         var j : int ; j := b + 1 ; while j < e do ( (     if (A[j+1] < min) then     min := A[j+1] ; else skip )  ;     j := j + 1 ) ; 
     skip ) else (     var max : int ; max := A[b+1] ;
         var j : int ; j := b + 1 ; while j < e do ( (     if (A[j+1] > max) then     max := A[j+1] ; else skip )  ;     j := j + 1 ) ; 
     skip ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static long m(long a[],int b,int e){
    long Min=a[b];
    for(int i=b+1 ; i<e ; i++)Min=Math.min(Min,a[i]);
    return Min ;
  }
  public static long M(long a[],int b,int e){
    long Max=a[b];
    for(int i=b+1 ; i<e ; i++)Max=Math.max(Max,a[i]);
    return Max ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long a[]=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextLong();
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      int com=sc.nextInt();
      int b=sc.nextInt();
      int e=sc.nextInt();
      if(com==0)System.out.println(m(a,b,e));
      else System.out.println(M(a,b,e));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation m( a : Sequence(long), b : int, e : int) : long
  pre: true
  post: true
  activity: (     var Min : long ; Min := a[b+1] ;
         var i : int ; i := b + 1 ; while i < e do (     Min := Set{Min, a[i+1]}->min() ;  ;     i := i + 1 ) ; 
     return Min );
  static   operation M( a : Sequence(long), b : int, e : int) : long
  pre: true
  post: true
  activity: (     var Max : long ; Max := a[b+1] ;
         var i : int ; i := b + 1 ; while i < e do (     Max := Set{Max, a[i+1]}->max() ;  ;     i := i + 1 ) ; 
     return Max );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var com : int ; com := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     var e : int ; e := sc.getCurrent()->toInteger() ;
     if (com = 0) then     OclFile["System.out"].println(m(a, b, e)) ; else     OclFile["System.out"].println(M(a, b, e)) ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void print(int n,int k){
    System.out.print(k+" ");
    for(int i=2 ; i<=n ; i++){
      int x=(int)(Math.pow(k,i)-Math.pow(k,i-1));
      System.out.print(x+" ");
    }
  }
  public static void main(String[] args){
    int N=3,K=4 ;
    print(N,K);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation print( n : int, k : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(k + " ") ; 
         var i : int ; i := 2 ; while i <= n do ( (     var x : int ; x := (k->pow(i) - k->pow(i - 1))->oclAsType(int) ;
     OclFile["System.out"].print(x + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
    var K : int ; K := 4 ;
     execute print(N, K) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long getMinNum(int N){
    int lcm=1 ;
    for(int i=2 ; i<=N ; i++)lcm=((i*lcm)/(__gcd(i,lcm)));
    return(lcm+1);
  }
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  public static void main(String args[]){
    int N=5 ;
    System.out.println(getMinNum(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getMinNum( N : int) : long
  pre: true
  post: true
  activity: (     var lcm : int ; lcm := 1 ;
         var i : int ; i := 2 ; while i <= N do (     lcm := ((i * lcm) / (__gcd(i, lcm))) ;  ;     i := i + 1 ) ; 
     return (lcm + 1) );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     OclFile["System.out"].println(getMinNum(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p014 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p014().run());
  }
  private static final int LIMIT=Library.pow(10,6);
  public String run(){
    int maxArg=-1 ;
    int maxChain=0 ;
    for(int i=1 ; i<LIMIT ; i++){
      int chainLen=collatzChainLength(BigInteger.valueOf(i));
      if(chainLen>maxChain){
        maxArg=i ;
        maxChain=chainLen ;
      }
    }
    return Integer.toString(maxArg);
  }
  private static final BigInteger CACHE_SIZE=BigInteger.valueOf(LIMIT);
  private int[] collatzChainLength=new int[CACHE_SIZE.intValue()];
  private int collatzChainLength(BigInteger n){
    if(n.signum()<0)throw new IllegalArgumentException();
    if(n.compareTo(CACHE_SIZE)>=0)return collatzChainLengthDirect(n);
    int index=n.intValue();
    if(collatzChainLength[index]==0)collatzChainLength[index]=collatzChainLengthDirect(n);
    return collatzChainLength[index];
  }
  private int collatzChainLengthDirect(BigInteger n){
    if(n.equals(BigInteger.ONE))return 1 ;
    else if(! n.testBit(0))return collatzChainLength(n.shiftRight(1))+1 ;
    else return collatzChainLength(n.multiply(BigInteger.valueOf(3)).add(BigInteger.ONE))+1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class p014 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p014.newp014().run()) );
  static    attribute LIMIT : int := Library.pow(10, 6);
   operation run() : String
  pre: true
  post: true
  activity: (     var maxArg : int ; maxArg := -1 ;
     var maxChain : int ; maxChain := 0 ;
         var i : int ; i := 1 ; while i < LIMIT do ( (     var chainLen : int ; chainLen := collatzChainLength((i + "")->toLong()) ;
     if (chainLen > maxChain) then (     maxArg := i ; 
     maxChain := chainLen ) else skip )  ;     i := i + 1 ) ; 
     return ((maxArg) + "") );
  static    attribute CACHE_SIZE : long := (LIMIT + "")->toLong();
   attribute collatzChainLength : Sequence(int) := Integer.subrange(1,CACHE_SIZE->oclAsType(int))->collect(0);
   operation collatzChainLength( n : long) : int
  pre: true
  post: true
  activity: (     if (n.signum() < 0) then     error IllegalArgumentException.newIllegalArgumentException() ; else skip ; 
     if (n->compareTo(CACHE_SIZE) >= 0) then     return collatzChainLengthDirect(n) else skip ; 
    var index : int ; index := n->oclAsType(int) ;
    if (collatzChainLength[index+1] = 0) then     collatzChainLength[index+1] := collatzChainLengthDirect(n) ; else skip ; 
    return collatzChainLength[index+1] 
 );
   operation collatzChainLengthDirect( n : long) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 1 else     if (not(n.testBit(0))) then     return collatzChainLength(n.shiftRight(1)) + 1 else     return collatzChainLength(n.multiply((3 + "")->toLong())->excludes(1)) + 1 ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static int MOD=1_000_000_007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    List<List<Integer>>graph=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      graph.add(new ArrayList<>());
    }
    for(int i=0 ; i<N-1 ; i++){
      int a=sc.nextInt();
      a--;
      int b=sc.nextInt();
      b--;
      graph.get(a).add(b);
      graph.get(b).add(a);
    }
    long ans=K*dfs(K,graph,0,-1);
    ans %=MOD ;
    System.out.println(ans);
  }
  private static long dfs(int K,List<List<Integer>>graph,int now,int from){
    int colorNum=from==-1 ? K-1 : K-2 ;
    long ret=1 ;
    for(int next : graph.get(now)){
      if(next!=from){
        ret*=colorNum ;
        ret %=MOD ;
        colorNum--;
        ret*=dfs(K,graph,next,now);
        ret %=MOD ;
      }
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : int := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var graph : Sequence(Sequence(int)) ; graph := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     graph := graph->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     a := a - 1 ; 
    var b : int ; b := sc.getCurrent()->toInteger() ;
    b := b - 1 ; 
    graph->at(a+1)->excludes(b) ; 
    graph->at(b+1)->excludes(a) ; 
 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := K * dfs(K, graph, 0, -1) ;
    ans := ans mod MOD ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation dfs( K : int, graph : Sequence(Sequence(int)), now : int, from : int) : long
  pre: true
  post: true
  activity: (     var colorNum : int ; colorNum := if from = -1 then K - 1 else K - 2 endif ;
     var ret : long ; ret := 1 ;
     for (next : graph->at(now+1)) do ( (     if (next /= from) then (     ret := ret*(colorNum) ; 
     ret := ret mod MOD ; 
    colorNum := colorNum - 1 ; 
    ret := ret*(dfs(K, graph, next, now)) ; 
    ret := ret mod MOD ; 
 ) else skip )  ) ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Collection ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    solve();
  }
  public static void solve(){
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    sc.close();
    out.println((a<=c && c<=b)? "Yes" : "No");
    out.flush();
  }
  static class Pair {
    int a,b ;
    public Pair(int a,int b){
      this.a=a ;
      this.b=b ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    skip ; 
    skip ; 
    skip ; 
 );
  static class Pair {
   attribute a : int;
   static operation newPair( a : int, b : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void dupLastIndex(int arr[],int n){
    if(arr==null || n<=0)return ;
    for(int i=n-1 ; i>0 ; i--){
      if(arr[i]==arr[i-1]){
        System.out.println("Last index:"+i);
        System.out.println("Last duplicate item: "+arr[i]);
        return ;
      }
    }
    System.out.print("no duplicate found");
  }
  public static void main(String[] args){
    int arr[]={
      1,5,5,6,6,7,9 };
      int n=arr.length ;
      dupLastIndex(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation dupLastIndex( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     if (arr = null or n <= 0) then     return else skip ; 
         var i : int ; i := n - 1 ; while i > 0 do ( (     if (arr[i+1] = arr[i - 1+1]) then (     OclFile["System.out"].println("Last index:" + i) ; 
     OclFile["System.out"].println("Last duplicate item: " + arr[i+1]) ; 
     return ) else skip )  ;     i := i - 1 ) ; 
     OclFile["System.out"].print("no duplicate found") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,5,6,6,7,9} ;
     var n : int ; n := arr->size() ;
     execute dupLastIndex(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static void main(String[] args){
    Scanner stdin=new Scanner(System.in);
    long n=stdin.nextLong();
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=stdin.nextLong();
    }
    System.out.println(sum/n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := stdin.getCurrent()->toLong() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(stdin.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum / n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    int size=0 ;
    try {
      size=readIntArray()[0];
    }
    catch(Exception e){
      return false ;
    }
    long sum=0 ;
    for(int i=0 ; i<size ; i++){
      sum+=readIntArray()[0];
    }
    System.out.printf("%d\n",sum/size);
    return false ;
  }
  private final static boolean DEBUG=false ;
  public static void main(String[] args)throws IOException {
    if(DEBUG){
      log=System.out ;
      String inputStr="1:15:" ;
      inputStr=inputStr.replace(":","\n");
      reader=new BufferedReader(new StringReader(inputStr));
    }
    else {
      log=new PrintStream(new OutputStream(){
        public void write(int b){
        }
      }
);
      reader=new BufferedReader(new InputStreamReader(System.in));
    }
    int N=Integer.MAX_VALUE ;
    for(int i=0 ; i<N ; i++){
      boolean b=new Main().main();
      if(! b)break ;
    }
    reader.close();
  }
  static PrintStream log ;
  static BufferedReader reader ;
  private static int[] readIntArray()throws IOException {
    String s=null ;
    for(; ; ){
      s=reader.readLine();
      if(s==null)return null ;
      s=s.trim();
      if(s.length()!=0)break ;
    }
    String[] sp=s.split("[,] ");
    int[] a=new int[sp.length];
    for(int i=0 ; i<sp.length ; i++){
      a[i]=Integer.parseInt(sp[i]);
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var size : int ; size := 0 ;
     try (     size := readIntArray()[0+1] )   catch (e : ProgramException) do (     return false )
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < size do ( (     sum := sum+(readIntArray()[0+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%d\n", sum / size) ; 
    return false 
 );
  static   attribute DEBUG : boolean := false;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (DEBUG) then (     log := OclFile["System.out"] ; 
     var inputStr : String ; inputStr := "1:15:" ;
     inputStr := inputStr.replace(":", "\n") ; 
     reader := OclFile.newOclFile_Read(StringReader.newStringReader(inputStr)) ) else (     log := OclFile.newOclFile_Write(OclFile()) ; 
     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ) ;  
     var N : int ; N := 2147483647 ;
         var i : int ; i := 0 ; while i < N do ( (     var b : boolean ; b := Main.newMain().main() ;
     if (not(b)) then     break else skip )  ;     i := i + 1 ) ; 
     reader.close() );
  static   attribute log : OclFile;
  static   attribute reader : OclFile;
  static   operation readIntArray() : Sequence(int)
  pre: true
  post: true
  activity: (     var s : String ; s := null ;
       while true do ( (     s := reader.readLine() ; 
     if (s = null) then     return null else skip ; 
     s := s->trim() ; 
     if (s->size() /= 0) then     break else skip )  ) ; 
    var sp : Sequence(String) ; sp := s->split("[,] ") ;
    var a : Sequence(int) ; a := Integer.subrange(1,sp->size())->collect(0) ;
        var i : int ; i := 0 ; while i < sp->size() do ( (     a[i+1] := (sp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    return a 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.math.BigDecimal ;
public class Main {
  public Main(){
    Scanner sc=new Scanner(System.in);
    BigDecimal n=new BigDecimal(sc.next());
    BigDecimal sum=new BigDecimal("0");
    while(sc.hasNext()){
      BigDecimal tmp=new BigDecimal(sc.next());
      sum=sum.add(tmp);
    }
    sum=sum.divide(n,BigDecimal.ROUND_HALF_UP);
    System.out.println(sum);
  }
  public static void main(String[] args){
    Main test=new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : double ; n := double(sc.getCurrent()) ;
    var sum : double ; sum := double("0") ;
    while (sc.hasNext()) do (     var tmp : double ; tmp := double(sc.getCurrent()) ;
     sum := sum->excludes(tmp) ) ; 
    sum := sum.divide(n, ROUND_HALF_UP) ; 
    OclFile["System.out"].println(sum) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var test : Main ; test := Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String a[])throws java.io.IOException {
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    long sum=0 ;
    while(scan.hasNext()){
      sum+=scan.nextInt();
    }
    System.out.println(sum/n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var sum : long ; sum := 0 ;
    while (scan.hasNext()) do (     sum := sum+(scan.getCurrent()->toInteger()) ) ; 
    OclFile["System.out"].println(sum / n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import static java.util.Arrays.fill ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      int n=sc.nextInt();
      if(n==0)break ;
      long sum=0 ;
      for(int i=0 ; i<n ; i++)sum+=sc.nextInt();
      System.out.println(sum/n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (     sum := sum+(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum / n) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public char findTheDifference(String s,String t){
    int total=t.charAt(s.length());
    for(int i=0 ; i<s.length(); i++)total+=(t.charAt(i)-s.charAt(i));
    return(char)total ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation findTheDifference( s : String, t : String) : String
  pre: true
  post: true
  activity: (     var total : int ; total := t->at(s->size()+1) ;
         var i : int ; i := 0 ; while i < s->size() do (     total := total+((t->at(i+1) - s->at(i+1))) ;  ;     i := i + 1 ) ; 
     return total->oclAsType(String) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void expressDigit(int arr[],int n){
    int min=9,index=0,temp=0 ;
    temp=arr[0];
    for(int i=1 ; i<10 ; i++){
      if(arr[i]<min){
        min=arr[i];
        index=i ;
      }
    }
    if(temp<min){
      System.out.print(1);
      for(int i=1 ; i<=temp+1 ; i++)System.out.print(0);
    }
    else {
      for(int i=0 ; i<min ; i++)System.out.print(index);
      System.out.print(index);
    }
  }
  public static void main(String[] args){
    int arr[]={
      2,2,1,2,1,1,3,1,1,1 };
      int N=10 ;
      expressDigit(arr,N);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation expressDigit( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var min : int ; min := 9 ;
    var index : int ; index := 0 ;
    var temp : int ; temp := 0 ;
     temp := arr[0+1] ; 
         var i : int ; i := 1 ; while i < 10 do ( (     if (arr[i+1] < min) then (     min := arr[i+1] ; 
     index := i ) else skip )  ;     i := i + 1 ) ; 
     if (temp < min) then (     OclFile["System.out"].print(1) ; 
         var i : int ; i := 1 ; while i <= temp + 1 do (     OclFile["System.out"].print(0) ;  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < min do (     OclFile["System.out"].print(index) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(index) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,2,1,2,1,1,3,1,1,1} ;
     var N : int ; N := 10 ;
     execute expressDigit(arr, N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static int N=100005 ;
  static boolean isprime[]=new boolean[N];
  static boolean can[]=new boolean[N];
  static ArrayList<Integer>SieveOfEratosthenes(){
    for(int a=0 ; a<isprime.length ; a++){
      isprime[a]=true ;
    }
    for(int p=2 ; p*p<N ; p++){
      if(isprime[p]==true){
        for(int i=p*p ; i<N ; i+=p)isprime[i]=false ;
      }
    }
    ArrayList<Integer>primes=new ArrayList<Integer>();
    for(int i=2 ; i<N ; i++)if(isprime[i])primes.add(i);
    return primes ;
  }
  static int Prime_Numbers(int n){
    ArrayList<Integer>primes=SieveOfEratosthenes();
    for(int i=0 ; i<(int)(primes.size())-1 ; i++)if(primes.get(i)+primes.get(i+1)+1<N)can[primes.get(i)+primes.get(i+1)+1]=true ;
    int ans=0 ;
    for(int i=2 ; i<=n ; i++){
      if(can[i] && isprime[i]==true){
        ans++;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int n=50 ;
    System.out.println(Prime_Numbers(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   attribute N : int := 100005;
  static   attribute isprime : boolean := Integer.subrange(1,N)->collect(false);
  static   attribute can : boolean := Integer.subrange(1,N)->collect(false);
  static   operation SieveOfEratosthenes() : Sequence(int)
  pre: true
  post: true
  activity: (         var a : int ; a := 0 ; while a < isprime->size() do ( (     isprime[a+1] := true )  ;     a := a + 1 ) ; 
         var p : int ; p := 2 ; while p * p < N do ( (     if (isprime[p+1] = true) then (         var i : int ; i := p * p ; while i < N do (     isprime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var primes : Sequence(int) ; primes := Sequence{} ;
        var i : int ; i := 2 ; while i < N do (     if (isprime[i+1]) then     primes := primes->including(i) ; else skip ;  ;     i := i + 1 ) ; 
    return primes 
 );
  static   operation Prime_Numbers( n : int) : int
  pre: true
  post: true
  activity: (     var primes : Sequence(int) ; primes := SieveOfEratosthenes() ;
         var i : int ; i := 0 ; while i < (primes->size())->oclAsType(int) - 1 do (     if (primes->at(i+1) + primes->at(i + 1+1) + 1 < N) then     can[primes->at(i+1) + primes->at(i + 1+1) + 1+1] := true ; else skip ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 2 ; while i <= n do ( (     if (can[i+1] & isprime[i+1] = true) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 50 ;
     OclFile["System.out"].println(Prime_Numbers(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.*;
public class Diamond implements Runnable {
  final Scanner in ;
  final PrintWriter out ;
  public Diamond()throws FileNotFoundException {
    out=new PrintWriter(getClass().getName().toLowerCase()+".out");
    in=new Scanner(new File(getClass().getName().toLowerCase()+".in"));
  }
  public static void main(String[] args){
    try {
      new Diamond().run();
    }
    catch(FileNotFoundException e){
      e.printStackTrace();
    }
  }
  public void run(){
    int tests=in.nextInt();
    in.nextLine();
    for(int testcase=1 ; testcase<=tests ; testcase++){
      int n=in.nextInt();
      List<List<Integer>>edges=new ArrayList<List<Integer>>();
      for(int i=0 ; i<n ; i++){
        List<Integer>cur=new ArrayList<Integer>();
        int mi=in.nextInt();
        for(int x=0 ; x<mi ; x++){
          cur.add(in.nextInt()-1);
        }
        edges.add(cur);
      }
      boolean path=false ;
      for(int st=0 ; st<n ; st++){
        Queue<Integer>q=new ArrayDeque<Integer>();
        Set<Integer>v=new HashSet<Integer>();
        v.add(st);
        for(q.offer(st); ! q.isEmpty(); q.poll()){
          int c=q.peek();
          for(int d : edges.get(c)){
            if(v.contains(d)){
              path=true ;
              continue ;
            }
            v.add(d);
            q.offer(d);
          }
        }
      }
      out.println("Case #"+testcase+": "+(path ? "Yes" : "No"));
    }
    out.close();
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Diamond implements Runnable {
   attribute in : OclFile;
   attribute out : OclFile;
   static operation newDiamond() : Diamond
  pre: true
  post: true
  activity:
  ( var self : Diamond ;
    self := createDiamond();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     out := OclFile.newOclFile_Write(getClass().getName()->toLowerCase() + ".out") ; 
     in := OclFile.newOclFile_Read(OclFile(getClass().getName()->toLowerCase() + ".in")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     Diamond.newDiamond().run() )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
 );
   operation run() : void
  pre: true
  post: true
  activity: (     var tests : int ; tests := in.getCurrent()->toInteger() ;
     skip ; 
        var testcase : int ; testcase := 1 ; while testcase <= tests do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var edges : Sequence(Sequence(int)) ; edges := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var cur : Sequence(int) ; cur := Sequence{} ;
     var mi : int ; mi := in.getCurrent()->toInteger() ;
         var x : int ; x := 0 ; while x < mi do ( (     cur := cur->including(in.getCurrent()->toInteger() - 1) )  ;     x := x + 1 ) ; 
     edges := edges->including(cur) )  ;     i := i + 1 ) ; 
    var path : boolean ; path := false ;
        var st : int ; st := 0 ; while st < n do ( (     var q : Sequence(int) ; q := ArrayDeque<int>.newArrayDeque() ;
     var v : Set(int) ; v := Set{} ;
     v := v->including(st) ; 
         q := q->including(st) ; while not(q->isEmpty()) do ( (     var c : int ; c := q->min() ;
     for (d : edges->at(c+1)) do ( (     if (v->includes(d)) then (     path := true ; 
     continue ) else skip ; 
     v := v->including(d) ; 
     q := q->including(d) )  ) )  ;     q := q->sort()->tail() ) )  ;     st := st + 1 ) ; 
    skip ; 
 )  ;     testcase := testcase + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s=br.readLine();
    String[] array=s.split(" ");
    int a=Integer.parseInt(array[0]);
    int b=Integer.parseInt(array[1]);
    int c=Integer.parseInt(array[2]);
    if(c>=a && c<=b){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := br.readLine() ;
    var array : Sequence(String) ; array := s->split(" ") ;
    var a : int ; a := (array[0+1])->toInteger() ;
    var b : int ; b := (array[1+1])->toInteger() ;
    var c : int ; c := (array[2+1])->toInteger() ;
    if (c >= a & c <= b) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
import java.io.*;
public class codeHundredSixty {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=input.nextInt();
      int m=input.nextInt();
      if(n>=m){
        int gabe=1 ;
        for(int i=1 ; i<=m ; i++){
          int index=1 ;
          for(int j=1 ; j<=i ; j++){
            index++;
            System.out.print('B');
          }
          for(int j=index ; j<=m ; j++){
            System.out.print('W');
          }
          System.out.println();
          gabe++;
        }
        for(int i=gabe ; i<=n ; i++){
          for(int j=0 ; j<m ; j++){
            System.out.print('B');
          }
          System.out.println();
        }
      }
      else {
        int gabe=1 ;
        for(int i=1 ; i<=n ; i++){
          int index=0 ;
          for(int j=1 ; j<i ; j++){
            System.out.print('W');
            index++;
          }
          for(int j=index ; j<m ; j++){
            System.out.print('B');
          }
          System.out.println();
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var m : int ; m := input.getCurrent()->toInteger() ;
     if (n >= m) then (     var gabe : int ; gabe := 1 ;
         var i : int ; i := 1 ; while i <= m do ( (     var index : int ; index := 1 ;
         var j : int ; j := 1 ; while j <= i do ( (     index := index + 1 ; 
     OclFile["System.out"].print('B') )  ;     j := j + 1 ) ; 
        var j : int ; j := index ; while j <= m do ( (     OclFile["System.out"].print('W') )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println() ; 
    gabe := gabe + 1 ; 
 )  ;     i := i + 1 ) ; 
         var i : int ; i := gabe ; while i <= n do ( (         var j : int ; j := 0 ; while j < m do ( (     OclFile["System.out"].print('B') )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ) else (     var gabe : int ; gabe := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (     var index : int ; index := 0 ;
         var j : int ; j := 1 ; while j < i do ( (     OclFile["System.out"].print('W') ; 
     index := index + 1 )  ;     j := j + 1 ) ; 
         var j : int ; j := index ; while j < m do ( (     OclFile["System.out"].print('B') )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ) )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int t=0 ; t<test ; t++){
      int n=in.nextInt(),m=in.nextInt();
      int mul=n*m ;
      mul--;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<m ; j++){
          if(mul>=1){
            pw.print("B");
            mul--;
          }
        }
        if(i+1==n){
          pw.println("W");
        }
        else {
          pw.println();
        }
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < test do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
     var mul : int ; mul := n * m ;
     mul := mul - 1 ; 
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (mul >= 1) then (     skip ; 
     mul := mul - 1 ) else skip )  ;     j := j + 1 ) ; 
     if (i + 1 = n) then (     skip ) else (     skip ) )  ;     i := i + 1 ) )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.nio.charset.MalformedInputException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int m=sc.nextInt();
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<m ; j++){
          if(i==0 && j==0){
            out.print("W");
          }
          else {
            out.print("B");
          }
        }
        out.println();
      }
    }
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (i = 0 & j = 0) then (     skip ) else (     skip ) )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ) ;  ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Codeforces {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int tests=sc.nextInt();
    for(int t=0 ; t<tests ; t++){
      int n=sc.nextInt();
      int m=sc.nextInt();
      String str1="" ;
      for(int i=0 ; i<m ; i++){
        str1=str1.concat("B");
      }
      System.out.println(str1);
      String str="B" ;
      for(int i=1 ; i<m ; i++){
        str=str.concat("W");
      }
      for(int i=1 ; i<n ; i++){
        System.out.println(str);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tests : int ; tests := sc.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < tests do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var str1 : String ; str1 := "" ;
        var i : int ; i := 0 ; while i < m do ( (     str1 := str1+"B" )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(str1) ; 
    var str : String ; str := "B" ;
        var i : int ; i := 1 ; while i < m do ( (     str := str+"W" )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     OclFile["System.out"].println(str) )  ;     i := i + 1 ) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Division {
  static int fact(int n){
    if(n==0)return 1 ;
    return n*fact(n-1);
  }
  static int div(int x){
    int ans=0 ;
    for(int i=1 ; i<=x ; i++)if(x % i==0)ans+=i ;
    return ans ;
  }
  static int sumFactDiv(int n){
    return div(fact(n));
  }
  public static void main(String args[]){
    int n=4 ;
    System.out.println(sumFactDiv(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Division {
  static   operation fact( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     return n * fact(n - 1) );
  static   operation div( x : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i <= x do (     if (x mod i = 0) then     ans := ans+(i) ; else skip ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation sumFactDiv( n : int) : int
  pre: true
  post: true
  activity: (     return div(fact(n)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(sumFactDiv(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int longestSubarry(int arr[],int n){
    int res=0 ;
    for(int i=0 ; i<n ; i++){
      int curr_count=0 ;
      while(i<n && arr[i]>=0){
        curr_count++;
        i++;
      }
      res=Math.max(res,curr_count);
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      1,0,4,0,1,-1,-1,0,0,1,0 };
      int n=arr.length ;
      System.out.println(longestSubarry(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation longestSubarry( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var curr_count : int ; curr_count := 0 ;
     while (i < n & arr[i+1] >= 0) do (     curr_count := curr_count + 1 ; 
     i := i + 1 ) ; 
     res := Set{res, curr_count}->max() )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,0,4,0,1,-1,-1,0,0,1,0} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(longestSubarry(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int[][] map=new int[8][8];
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    for(int m=0 ; m<n ; m++){
      for(int i=0 ; i<8 ; i++){
        String input=scanner.next();
        for(int j=0 ; j<8 ; j++){
          map[i][j]=Integer.parseInt(input.substring(j,j+1));
        }
      }
      int x=scanner.nextInt()-1 ;
      int y=scanner.nextInt()-1 ;
      map[y][x]=2 ;
      boolean is_chain=false ;
      do {
        is_chain=false ;
        for(int i=0 ; i<8 ; i++){
          for(int j=0 ; j<8 ; j++){
            if(map[i][j]==2){
              is_chain=true ;
              setBom(i,j);
              map[i][j]=0 ;
            }
          }
        }
      }
      while(is_chain);
      System.out.println("Data "+(m+1)+":");
      for(int i=0 ; i<8 ; i++){
        for(int j=0 ; j<8 ; j++){
          System.out.printf("%1$d%2$s",map[i][j],j<7 ? "" : "\n");
        }
      }
    }
  }
  static void setBom(int y,int x){
    for(int i=-3 ; i<=3 ; i++){
      if(0<=x+i && x+i<8){
        if(map[y][x+i]==1){
          map[y][x+i]=2 ;
        }
      }
      if(0<=y+i && y+i<8){
        if(map[y+i][x]==1){
          map[y+i][x]=2 ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute map : Sequence(Sequence(int)) := Integer.subrange(1,8)->collect(Integer.subrange(1,8)->collect(0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
         var m : int ; m := 0 ; while m < n do ( (         var i : int ; i := 0 ; while i < 8 do ( (     var input : String ; input := scanner.getCurrent() ;
         var j : int ; j := 0 ; while j < 8 do ( (     map[i+1][j+1] := (input.subrange(j+1,j + 1))->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     var x : int ; x := scanner.getCurrent()->toInteger() - 1 ;
    var y : int ; y := scanner.getCurrent()->toInteger() - 1 ;
    map[y+1][x+1] := 2 ; 
    var is_chain : boolean ; is_chain := false ;
  while true do ((     is_chain := false ; 
         var i : int ; i := 0 ; while i < 8 do ( (         var j : int ; j := 0 ; while j < 8 do ( (     if (map[i+1][j+1] = 2) then (     is_chain := true ; 
     execute setBom(i, j) ; 
     map[i+1][j+1] := 0 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) ;
    if (is_chain) then skip else break) ; 
    OclFile["System.out"].println("Data " + (m + 1) + ":") ; 
        var i : int ; i := 0 ; while i < 8 do ( (         var j : int ; j := 0 ; while j < 8 do ( (     OclFile["System.out"].printf("%1$d%2$s", map[i+1][j+1], if j < 7 then "" else "\n" endif) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 )  ;     m := m + 1 ) );
  static   operation setBom( y : int, x : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := -3 ; while i <= 3 do ( (     if (0 <= x + i & x + i < 8) then (     if (map[y+1][x + i+1] = 1) then (     map[y+1][x + i+1] := 2 ) else skip ) else skip ; 
     if (0 <= y + i & y + i < 8) then (     if (map[y + i+1][x+1] = 1) then (     map[y + i+1][x+1] := 2 ) else skip ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int[][] field ;
  boolean[][] visited ;
  void Bomb(int x,int y){
    if(x<0 || y<0 || x>=8 || y>=8 || field[x][y]==0){
      return ;
    }
    field[x][y]=0 ;
    Bomb(x+1,y);
    Bomb(x+2,y);
    Bomb(x+3,y);
    Bomb(x-1,y);
    Bomb(x-2,y);
    Bomb(x-3,y);
    Bomb(x,y+1);
    Bomb(x,y+2);
    Bomb(x,y+3);
    Bomb(x,y-1);
    Bomb(x,y-2);
    Bomb(x,y-3);
  }
  void run(){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    stdIn.nextLine();
    for(int i=0 ; i<n ; i++){
      stdIn.nextLine();
      field=new int[8][8];
      visited=new boolean[8][8];
      for(int j=0 ; j<8 ; j++){
        char[] tmp=stdIn.nextLine().toCharArray();
        for(int k=0 ; k<8 ; k++){
          if(tmp[k]=='1'){
            field[j][k]=1 ;
          }
        }
      }
      int y=Integer.parseInt(stdIn.nextLine());
      int x=Integer.parseInt(stdIn.nextLine());
      Bomb(--x,--y);
      System.out.println("Data "+(i+1)+":");
      for(int j=0 ; j<8 ; j++){
        for(int k=0 ; k<8 ; k++){
          System.out.print(field[j][k]);
        }
        System.out.println();
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute field : Sequence(Sequence(int));
   attribute visited : Sequence(Sequence(boolean));
   operation Bomb( x : int, y : int) : void
  pre: true
  post: true
  activity: (     if (x < 0 or y < 0 or x >= 8 or y >= 8 or field[x+1][y+1] = 0) then (     return ) else skip ; 
     field[x+1][y+1] := 0 ; 
    execute Bomb(x + 1, y) ; 
    execute Bomb(x + 2, y) ; 
    execute Bomb(x + 3, y) ; 
    execute Bomb(x - 1, y) ; 
    execute Bomb(x - 2, y) ; 
    execute Bomb(x - 3, y) ; 
    execute Bomb(x, y + 1) ; 
    execute Bomb(x, y + 2) ; 
    execute Bomb(x, y + 3) ; 
    execute Bomb(x, y - 1) ; 
    execute Bomb(x, y - 2) ; 
    execute Bomb(x, y - 3) ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     skip ; 
         var i : int ; i := 0 ; while i < n do ( (     skip ; 
     field := Integer.subrange(1,8)->collect(Integer.subrange(1,8)->collect(0)) ; 
    visited := Integer.subrange(1,8)->collect(Integer.subrange(1,8)->collect(false)) ; 
        var j : int ; j := 0 ; while j < 8 do ( (     var tmp : Sequence(String) ; tmp := stdIn.nextLine()->characters() ;
         var k : int ; k := 0 ; while k < 8 do ( (     if (tmp[k+1] = '1') then (     field[j+1][k+1] := 1 ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    var y : int ; y := (stdIn.nextLine())->toInteger() ;
    var x : int ; x := (stdIn.nextLine())->toInteger() ;
    execute Bomb((x - 1), (y - 1)) ; 
    OclFile["System.out"].println("Data " + (i + 1) + ":") ; 
        var j : int ; j := 0 ; while j < 8 do ( (         var k : int ; k := 0 ; while k < 8 do ( (     OclFile["System.out"].print(field[j+1][k+1]) )  ;     k := k + 1 ) ; 
     OclFile["System.out"].println() )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  static int[][] map ;
  public static void main(String[] args){
    BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
    try {
      int n=Integer.valueOf(sc.readLine());
      for(int k=1 ; k<=n ; k++){
        String st=sc.readLine();
        map=new int[14][14];
        for(int i=3 ; i<11 ; i++){
          st=sc.readLine();
          for(int j=3 ; j<11 ; j++)map[i][j]=st.charAt(j-3)-'0' ;
        }
        int x=Integer.valueOf(sc.readLine())+2 ;
        int y=Integer.valueOf(sc.readLine())+2 ;
        solve(x,y);
        System.out.println("Data "+k+":");
        for(int t=3 ; t<11 ; t++){
          for(int u=3 ; u<11 ; u++)System.out.print(map[t][u]);
          System.out.println();
        }
      }
    }
    catch(Exception e){
      System.out.println("Error");
    }
  }
  static void solve(int x,int y){
    if(map[y][x]==1){
      map[y][x]=0 ;
      for(int i=-3 ; i<0 ; i++){
        solve(x+i,y);
        solve(x,y+i);
      }
      for(int i=1 ; i<4 ; i++){
        solve(x+i,y);
        solve(x,y+i);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute map : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var n : int ; n := (sc.readLine())->toInteger() ;
         var k : int ; k := 1 ; while k <= n do ( (     var st : String ; st := sc.readLine() ;
     map := Integer.subrange(1,14)->collect(Integer.subrange(1,14)->collect(0)) ; 
        var i : int ; i := 3 ; while i < 11 do ( (     st := sc.readLine() ; 
         var j : int ; j := 3 ; while j < 11 do (     map[i+1][j+1] := st->at(j - 3+1) - ('0')->char2byte() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var x : int ; x := (sc.readLine())->toInteger() + 2 ;
    var y : int ; y := (sc.readLine())->toInteger() + 2 ;
    execute solve(x, y) ; 
    OclFile["System.out"].println("Data " + k + ":") ; 
        var t : int ; t := 3 ; while t < 11 do ( (         var u : int ; u := 3 ; while u < 11 do (     OclFile["System.out"].print(map[t+1][u+1]) ;  ;     u := u + 1 ) ; 
     OclFile["System.out"].println() )  ;     t := t + 1 ) ; 
 )  ;     k := k + 1 ) )   catch (e : ProgramException) do (     OclFile["System.out"].println("Error") )
 );
  static   operation solve( x : int, y : int) : void
  pre: true
  post: true
  activity: (     if (map[y+1][x+1] = 1) then (     map[y+1][x+1] := 0 ; 
         var i : int ; i := -3 ; while i < 0 do ( (     execute solve(x + i, y) ; 
     execute solve(x, y + i) )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i < 4 do ( (     execute solve(x + i, y) ; 
     execute solve(x, y + i) )  ;     i := i + 1 ) ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String decToBinary(int n){
    int[] binaryNum=new int[32];
    int i=0 ;
    while(n>0){
      binaryNum[i]=n % 2 ;
      n=n/2 ;
      i++;
    }
    String binary="" ;
    for(int j=i-1 ; j>=0 ; j--){
      binary+=String.valueOf(binaryNum[j]);
    }
    return binary ;
  }
  static int countFreq(String pat,String txt){
    int M=pat.length();
    int N=txt.length();
    int res=0 ;
    for(int i=0 ; i<=N-M ; i++){
      int j ;
      for(j=0 ; j<M ; j++){
        if(txt.charAt(i+j)!=pat.charAt(j)){
          break ;
        }
      }
      if(j==M){
        res++;
        j=0 ;
      }
    }
    return res ;
  }
  static void findOccurrence(int arr[],int n,String pattern){
    for(int i=0 ; i<n ; i++){
      String binary=decToBinary(arr[i]);
      System.out.print(countFreq(pattern,binary)+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      5,106,7,8 };
      String pattern="10" ;
      int n=arr.length ;
      findOccurrence(arr,n,pattern);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation decToBinary( n : int) : String
  pre: true
  post: true
  activity: (     var binaryNum : Sequence(int) ; binaryNum := Integer.subrange(1,32)->collect(0) ;
     var i : int ; i := 0 ;
    while (n > 0) do (     binaryNum[i+1] := n mod 2 ; 
     n := n / 2 ; 
     i := i + 1 ) ; 
    var binary : String ; binary := "" ;
        var j : int ; j := i - 1 ; while j >= 0 do ( (     binary := binary+(((binaryNum[j+1]) + "")) )  ;     j := j - 1 ) ; 
    return binary 
 );
  static   operation countFreq( pat : String, txt : String) : int
  pre: true
  post: true
  activity: (     var M : int ; M := pat->size() ;
     var N : int ; N := txt->size() ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i <= N - M do ( (     var j : int ;
         j := 0 ; while j < M do ( (     if (txt->at(i + j+1) /= pat->at(j+1)) then (     break ) else skip )  ;     j := j + 1 ) ; 
     if (j = M) then (     res := res + 1 ; 
     j := 0 ) else skip )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation findOccurrence( arr : Sequence(int), n : int, pattern : String) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var binary : String ; binary := decToBinary(arr[i+1]) ;
     OclFile["System.out"].print(countFreq(pattern, binary) + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,106,7,8} ;
     var pattern : String ; pattern := "10" ;
     var n : int ; n := arr->size() ;
     execute findOccurrence(arr, n, pattern) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedWriter ;
import java.io.File ;
import java.io.FileWriter ;
import java.util.Scanner ;
import java.util.logging.Level ;
import java.util.logging.Logger ;
public class R1CC {
  static boolean[] g ;
  static int[][] p ;
  static int[] d ;
  public static void main(String[] args){
    try {
      Scanner sc=new Scanner(new File("A-large.in"));
      BufferedWriter bw=new BufferedWriter(new FileWriter(new File("output.out")));
      int t=sc.nextInt();
      X : for(int i=0 ;
      i<t ;
      i++){
        bw.write("Case #"+String.valueOf(i+1)+": ");
        int r=0 ;
        int n=sc.nextInt();
        d=new int[n];
        p=new int[n][n];
        for(int j=0 ; j<n ; j++){
          d[j]=sc.nextInt();
          for(int k=0 ; k<d[j]; k++)p[j][k]=sc.nextInt()-1 ;
        }
        for(int j=0 ; j<n ; j++){
          g=new boolean[n];
          if(traverse(j)){
            bw.write("Yes");
            bw.newLine();
            bw.flush();
            continue X ;
          }
        }
        bw.write("No");
        bw.newLine();
        bw.flush();
      }
      bw.close();
    }
    catch(Exception ex){
      Logger.getLogger(QA.class.getName()).log(Level.SEVERE,null,ex);
    }
  }
  static boolean traverse(int h){
    for(int i=0 ; i<d[h]; i++){
      if(g[p[h][i] ])return true ;
      else g[p[h][i] ]=true ;
      if(traverse(p[h][i]))return true ;
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class R1CC {
  static   attribute g : Sequence(boolean);
  static   attribute p : Sequence(Sequence(int));
  static   attribute d : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile("A-large.in")) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile("output.out"))) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < t do ( (     skip ; 
     var r : int ; r := 0 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    d := Integer.subrange(1,n)->collect(0) ; 
    p := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
        var j : int ; j := 0 ; while j < n do ( (     d[j+1] := sc.getCurrent()->toInteger() ; 
         var k : int ; k := 0 ; while k < d[j+1] do (     p[j+1][k+1] := sc.getCurrent()->toInteger() - 1 ;  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     g := Integer.subrange(1,n)->collect(false) ; 
     if (traverse(j)) then (     skip ; 
     skip ; 
     skip ; 
     continue ) else skip )  ;     j := j + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 )   catch (ex : ProgramException) do (     Logger.getLogger(OclType["QA"].getName()).log(Level.SEVERE, null, ex) )
 );
  static   operation traverse( h : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < d[h+1] do ( (     if (g[p[h+1][i+1]+1]) then     return true else     g[p[h+1][i+1]+1] := true ; ;  
     if (traverse(p[h+1][i+1])) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.geom.*;
public class Main {
  int[][] data ;
  int n=8 ;
  private void doit(){
    Scanner sc=new Scanner(System.in);
    int dataset=sc.nextInt();
    int count=1 ;
    while(dataset-->0){
      data=new int[8][8];
      for(int i=0 ; i<n ; i++){
        String s=sc.next();
        for(int j=0 ; j<8 ; j++){
          data[i][j]=s.charAt(j)-'0' ;
        }
      }
      int x=sc.nextInt()-1 ;
      int y=sc.nextInt()-1 ;
      dfs(x,y);
      System.out.printf("Data %d:\n",count++);
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          System.out.print(data[i][j]);
        }
        System.out.println();
      }
    }
  }
  private void dfs(int x,int y){
    data[y][x]=0 ;
    for(int i=-3 ; i<=3 ; i++){
      if(isOK(x+i,y)&& data[y][x+i]==1){
        dfs(x+i,y);
      }
    }
    for(int i=-3 ; i<=3 ; i++){
      if(isOK(x,y+i)&& data[y+i][x]==1){
        dfs(x,y+i);
      }
    }
  }
  private boolean isOK(int x,int y){
    if(0<=x && x<n && 0<=y && y<n){
      return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute data : Sequence(Sequence(int));
   attribute n : int := 8;
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dataset : int ; dataset := sc.getCurrent()->toInteger() ;
     var count : int ; count := 1 ;
         while (dataset > 0) do (        dataset := dataset - 1 ;     skip ; (     data := Integer.subrange(1,8)->collect(Integer.subrange(1,8)->collect(0)) ; 
         var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < 8 do ( (     data[i+1][j+1] := s->at(j+1) - ('0')->char2byte() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
    var y : int ; y := sc.getCurrent()->toInteger() - 1 ;
    execute dfs(x, y) ; 
    OclFile["System.out"].printf("Data %d:\n", count) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     OclFile["System.out"].print(data[i+1][j+1]) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 ) ;  ) );
   operation dfs( x : int, y : int) : void
  pre: true
  post: true
  activity: (     data[y+1][x+1] := 0 ; 
         var i : int ; i := -3 ; while i <= 3 do ( (     if (isOK(x + i, y) & data[y+1][x + i+1] = 1) then (     execute dfs(x + i, y) ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := -3 ; while i <= 3 do ( (     if (isOK(x, y + i) & data[y + i+1][x+1] = 1) then (     execute dfs(x, y + i) ) else skip )  ;     i := i + 1 ) );
   operation isOK( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     if (0 <= x & x < n & 0 <= y & y < n) then (     return true ) else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int N=sc.nextInt();
      int S=sc.nextInt();
      int W=sc.nextInt();
      int Q=sc.nextInt();
      if(N==0 && S==0 && W==0 && Q==0)break ;
      int g=S ;
      int[] a=new int[N];
      for(int i=0 ; i<N ; ++i){
        a[N-1-i]=(g/7)% 10 ;
        if(g % 2==0){
          g=(g/2);
        }
        else {
          g=(g/2)^ W ;
        }
      }
      int[] seq=new int[N];
      long pow10=1 ;
      int zeropos=0 ;
      HashMap<Integer,Integer>map=new HashMap<>();
      map.put(0,1);
      int ans=0 ;
      for(int i=0 ; i<N ; ++i){
        if(Q!=2 && Q!=5){
          seq[i]=(int)(((i>0 ? seq[i-1] : 0)+pow10*a[i])% Q);
          if(a[i]!=0 && map.containsKey(seq[i]))ans+=map.get(seq[i]);
          map.put(seq[i],1+(map.containsKey(seq[i])? map.get(seq[i]): 0));
          pow10=pow10*10 % Q ;
        }
        else {
          if(a[i] % Q==0){
++zeropos ;
          }
          if(a[i]!=0){
            ans+=zeropos ;
          }
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var S : int ; S := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var Q : int ; Q := sc.getCurrent()->toInteger() ;
    if (N = 0 & S = 0 & W = 0 & Q = 0) then     break else skip ; 
    var g : int ; g := S ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[N - 1 - i+1] := (g / 7) mod 10 ; 
     if (g mod 2 = 0) then (     g := (g / 2) ) else (     g := (g / 2) xor W ) )  ;     i := i + 1 ) ; 
    var seq : Sequence(int) ; seq := Integer.subrange(1,N)->collect(0) ;
    var pow10 : long ; pow10 := 1 ;
    var zeropos : int ; zeropos := 0 ;
    var map : Map(int,int) ; map := Map{} ;
    map := map->union(Map{0 |-> 1}) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (Q /= 2 & Q /= 5) then (     seq[i+1] := (((if i > 0 then seq[i - 1+1] else 0 endif) + pow10 * a[i+1]) mod Q)->oclAsType(int) ; 
     if (a[i+1] /= 0 & map->keys()->includes(seq[i+1])) then     ans := ans+(map->at(seq[i+1])) ; else skip ; 
     map := map->union(Map{seq[i+1] |-> 1 + (if map->keys()->includes(seq[i+1]) then map->at(seq[i+1]) else 0 endif)}) ; 
     pow10 := pow10 * 10 mod Q ) else (     if (a[i+1] mod Q = 0) then (     zeropos := zeropos + 1 ) else skip ; 
     if (a[i+1] /= 0) then (     ans := ans+(zeropos) ) else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      int N=sc.nextInt();
      int S=sc.nextInt();
      int W=sc.nextInt();
      int Q=sc.nextInt();
      if((N | S | W | Q)==0){
        break ;
      }
      int a[]=new int[N];
      int g=S ;
      for(int i=0 ; i<N ; i++){
        a[i]=(g/7)% 10 ;
        if(g % 2==0){
          g=(g/2);
        }
        else {
          g=(g/2)^ W ;
        }
      }
      int ans=0 ;
      if(Q==2 || Q==5){
        ans=0 ;
        int zeroc=0 ;
        for(int i=0 ; i<N ; i++){
          if(a[i]!=0){
            zeroc++;
          }
          if(a[i] % Q==0){
            ans+=zeroc ;
          }
        }
        System.out.println(ans);
        continue ;
      }
      int used[]=new int[Q];
      used[0]=1 ;
      int p=1 ;
      int prev=0 ;
      for(int i=0 ; i<N ; i++){
        int v=(prev+p*a[N-i-1])% Q ;
        prev=v ;
        if(a[N-i-1]!=0){
          ans+=used[v];
        }
        used[v]++;
        p=(p*10)% Q ;
      }
      System.out.println(ans);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var S : int ; S := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var Q : int ; Q := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(MathLib.bitwiseOr(N,S),W),Q)) = 0) then (     break ) else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var g : int ; g := S ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := (g / 7) mod 10 ; 
     if (g mod 2 = 0) then (     g := (g / 2) ) else (     g := (g / 2) xor W ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    if (Q = 2 or Q = 5) then (     ans := 0 ; 
     var zeroc : int ; zeroc := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (a[i+1] /= 0) then (     zeroc := zeroc + 1 ) else skip ; 
     if (a[i+1] mod Q = 0) then (     ans := ans+(zeroc) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    continue 
 ) else skip ; 
    var used : Sequence(int) ; used := Integer.subrange(1,Q)->collect(0) ;
    used[0+1] := 1 ; 
    var p : int ; p := 1 ;
    var prev : int ; prev := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var v : int ; v := (prev + p * a[N - i - 1+1]) mod Q ;
     prev := v ; 
    if (a[N - i - 1+1] /= 0) then (     ans := ans+(used[v+1]) ) else skip ; 
    used[v+1] := used[v+1] + 1 ; 
    p := (p * 10) mod Q ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int N,Q ;
  public static void main(String[] args){
    while(true){
      N=sc.nextInt();
      if(N==0)break ;
      int S=sc.nextInt();
      int W=sc.nextInt();
      Q=sc.nextInt();
      int[] A=new int[N];
      int g=S ;
      for(int i=0 ; i<N ; ++i){
        A[i]=(g/7)% 10 ;
        if(g % 2==0){
          g=g/2 ;
        }
        else {
          g=(g/2)^ W ;
        }
      }
      System.out.println(solve(A));
    }
  }
  static long solve(int[] A){
    long ans=0 ;
    if(Q==2 || Q==5){
      int nonzero=0 ;
      for(int i=0 ; i<N ; ++i){
        if(A[i]!=0)++nonzero ;
        if(A[i] % Q==0){
          ans+=nonzero ;
        }
      }
      return ans ;
    }
    HashMap<Long,Integer>map=new HashMap<Long,Integer>();
    long sum=0 ;
    long base=1 ;
    for(int i=0 ; i<N ; ++i){
      sum+=A[N-1-i]*base ;
      sum %=Q ;
      base*=10 ;
      base %=Q ;
      int c=map.containsKey(sum)? map.get(sum): 0 ;
      if(A[N-1-i]!=0){
        ans+=c ;
        if(sum==0)ans++;
      }
      if(c!=0){
        map.put(sum,c+1);
      }
      else {
        map.put(sum,1);
      }
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     N := sc.getCurrent()->toInteger() ; 
     if (N = 0) then     break else skip ; 
    var S : int ; S := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    Q := sc.getCurrent()->toInteger() ; 
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var g : int ; g := S ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := (g / 7) mod 10 ; 
     if (g mod 2 = 0) then (     g := g / 2 ) else (     g := (g / 2) xor W ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(A)) ; 
 ) );
  static   operation solve( A : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
     if (Q = 2 or Q = 5) then (     var nonzero : int ; nonzero := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     if (A[i+1] /= 0) then     nonzero := nonzero + 1 ; else skip ; 
     if (A[i+1] mod Q = 0) then (     ans := ans+(nonzero) ) else skip )  ;     i := i + 1 ) ; 
     return ans ) else skip ; 
    var map : Map(long,int) ; map := Map{} ;
    var sum : long ; sum := 0 ;
    var base : long ; base := 1 ;
        var i : int ; i := 0 ; while i < N do ( (     sum := sum+(A[N - 1 - i+1] * base) ; 
     sum := sum mod Q ; 
    base := base*(10) ; 
    base := base mod Q ; 
    var c : int ; c := if map->keys()->includes(sum) then map->at(sum) else 0 endif ;
    if (A[N - 1 - i+1] /= 0) then (     ans := ans+(c) ; 
     if (sum = 0) then     ans := ans + 1 ; else skip ) else skip ; 
    if (c /= 0) then (     map := map->union(Map{sum |-> c + 1}) ) else (     map := map->union(Map{sum |-> 1}) ) ;  
 )  ;     i := i + 1 ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int N,Q ;
  public static void main(String[] args){
    while(true){
      N=sc.nextInt();
      if(N==0)break ;
      int S=sc.nextInt();
      int W=sc.nextInt();
      Q=sc.nextInt();
      int[] A=new int[N];
      int g=S ;
      for(int i=0 ; i<N ; ++i){
        A[i]=(g/7)% 10 ;
        if(g % 2==0){
          g=g/2 ;
        }
        else {
          g=(g/2)^ W ;
        }
      }
      System.out.println(solve(A));
    }
  }
  static long solve(int[] A){
    long ans=0 ;
    if(Q==2 || Q==5){
      int nonzero=0 ;
      for(int i=0 ; i<N ; ++i){
        if(A[i]!=0)++nonzero ;
        if(A[i] % Q==0){
          ans+=nonzero ;
        }
      }
      return ans ;
    }
    HashMap<Long,Integer>map=new HashMap<Long,Integer>();
    long sum=0 ;
    long base=1 ;
    for(int i=0 ; i<N ; ++i){
      sum+=A[N-1-i]*base ;
      sum %=Q ;
      base*=10 ;
      base %=Q ;
      Integer ci=map.get(sum);
      int c=ci==null ? 0 : ci.intValue();
      if(A[N-1-i]!=0){
        ans+=c ;
        if(sum==0)ans++;
      }
      map.put(sum,c+1);
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     N := sc.getCurrent()->toInteger() ; 
     if (N = 0) then     break else skip ; 
    var S : int ; S := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    Q := sc.getCurrent()->toInteger() ; 
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var g : int ; g := S ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := (g / 7) mod 10 ; 
     if (g mod 2 = 0) then (     g := g / 2 ) else (     g := (g / 2) xor W ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(A)) ; 
 ) );
  static   operation solve( A : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
     if (Q = 2 or Q = 5) then (     var nonzero : int ; nonzero := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     if (A[i+1] /= 0) then     nonzero := nonzero + 1 ; else skip ; 
     if (A[i+1] mod Q = 0) then (     ans := ans+(nonzero) ) else skip )  ;     i := i + 1 ) ; 
     return ans ) else skip ; 
    var map : Map(long,int) ; map := Map{} ;
    var sum : long ; sum := 0 ;
    var base : long ; base := 1 ;
        var i : int ; i := 0 ; while i < N do ( (     sum := sum+(A[N - 1 - i+1] * base) ; 
     sum := sum mod Q ; 
    base := base*(10) ; 
    base := base mod Q ; 
    var ci : int ; ci := map->at(sum) ;
    var c : int ; c := if ci = null then 0 else ci->oclAsType(int) endif ;
    if (A[N - 1 - i+1] /= 0) then (     ans := ans+(c) ; 
     if (sum = 0) then     ans := ans + 1 ; else skip ) else skip ; 
    map := map->union(Map{sum |-> c + 1}) ; 
 )  ;     i := i + 1 ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int N,Q ;
  static HashMap<Long,Integer>map=new HashMap<Long,Integer>(100000);
  public static void main(String[] args){
    StringBuilder sb=new StringBuilder();
    int[] A=new int[100000];
    while(true){
      N=Integer.parseInt(sc.next());
      if(N==0)break ;
      int S=Integer.parseInt(sc.next());
      int W=Integer.parseInt(sc.next());
      Q=Integer.parseInt(sc.next());
      int g=S ;
      for(int i=0 ; i<N ; ++i){
        A[i]=(g/7)% 10 ;
        if(g % 2==0){
          g=g/2 ;
        }
        else {
          g=(g/2)^ W ;
        }
      }
      sb.append(solve(A)+"\n");
    }
    System.out.print(sb);
  }
  static long solve(int[] A){
    long ans=0 ;
    if(Q==2 || Q==5){
      int nonzero=0 ;
      for(int i=0 ; i<N ; ++i){
        if(A[i]!=0)++nonzero ;
        if(A[i] % Q==0){
          ans+=nonzero ;
        }
      }
      return ans ;
    }
    map.clear();
    long sum=0 ;
    long base=1 ;
    for(int i=0 ; i<N ; ++i){
      sum+=A[N-1-i]*base ;
      sum %=Q ;
      base*=10 ;
      base %=Q ;
      Integer ci=map.get(sum);
      int c=ci==null ? 0 : ci.intValue();
      if(A[N-1-i]!=0){
        ans+=c ;
        if(sum==0)ans++;
      }
      map.put(sum,c+1);
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int;
  static   attribute map : Map(long,int) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     var A : Sequence(int) ; A := Integer.subrange(1,100000)->collect(0) ;
     while (true) do (     N := (sc.getCurrent())->toInteger() ; 
     if (N = 0) then     break else skip ; 
    var S : int ; S := (sc.getCurrent())->toInteger() ;
    var W : int ; W := (sc.getCurrent())->toInteger() ;
    Q := (sc.getCurrent())->toInteger() ; 
    var g : int ; g := S ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := (g / 7) mod 10 ; 
     if (g mod 2 = 0) then (     g := g / 2 ) else (     g := (g / 2) xor W ) )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(solve(A) + "\n") ; 
 ) ; 
     OclFile["System.out"].print(sb) );
  static   operation solve( A : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
     if (Q = 2 or Q = 5) then (     var nonzero : int ; nonzero := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     if (A[i+1] /= 0) then     nonzero := nonzero + 1 ; else skip ; 
     if (A[i+1] mod Q = 0) then (     ans := ans+(nonzero) ) else skip )  ;     i := i + 1 ) ; 
     return ans ) else skip ; 
    map := map->intersection(Map{}) ; 
    var sum : long ; sum := 0 ;
    var base : long ; base := 1 ;
        var i : int ; i := 0 ; while i < N do ( (     sum := sum+(A[N - 1 - i+1] * base) ; 
     sum := sum mod Q ; 
    base := base*(10) ; 
    base := base mod Q ; 
    var ci : int ; ci := map->at(sum) ;
    var c : int ; c := if ci = null then 0 else ci->oclAsType(int) endif ;
    if (A[N - 1 - i+1] /= 0) then (     ans := ans+(c) ; 
     if (sum = 0) then     ans := ans + 1 ; else skip ) else skip ; 
    map := map->union(Map{sum |-> c + 1}) ; 
 )  ;     i := i + 1 ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findLargest(int m,int s){
    if(s==0){
      System.out.print(m==1 ? "Largest number is 0" : "Not possible");
      return ;
    }
    if(s>9*m){
      System.out.println("Not possible");
      return ;
    }
    int[] res=new int[m];
    for(int i=0 ; i<m ; i++){
      if(s>=9){
        res[i]=9 ;
        s-=9 ;
      }
      else {
        res[i]=s ;
        s=0 ;
      }
    }
    System.out.print("Largest number is ");
    for(int i=0 ; i<m ; i++)System.out.print(res[i]);
  }
  public static void main(String[] args){
    int s=9,m=2 ;
    findLargest(m,s);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findLargest( m : int, s : int) : void
  pre: true
  post: true
  activity: (     if (s = 0) then (     OclFile["System.out"].print(if m = 1 then "Largest number is 0" else "Not possible" endif) ; 
     return ) else skip ; 
     if (s > 9 * m) then (     OclFile["System.out"].println("Not possible") ; 
     return ) else skip ; 
    var res : Sequence(int) ; res := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     if (s >= 9) then (     res[i+1] := 9 ; 
     s := s-(9) ) else (     res[i+1] := s ; 
     s := 0 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("Largest number is ") ; 
        var i : int ; i := 0 ; while i < m do (     OclFile["System.out"].print(res[i+1]) ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : int ; s := 9 ;
    var m : int ; m := 2 ;
     execute findLargest(m, s) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findSmallest(int m,int s){
    if(s==0){
      System.out.print(m==1 ? "Smallest number is 0" : "Not possible");
      return ;
    }
    if(s>9*m){
      System.out.println("Not possible");
      return ;
    }
    int[] res=new int[m];
    s-=1 ;
    for(int i=m-1 ; i>0 ; i--){
      if(s>9){
        res[i]=9 ;
        s-=9 ;
      }
      else {
        res[i]=s ;
        s=0 ;
      }
    }
    res[0]=s+1 ;
    System.out.print("Smallest number is ");
    for(int i=0 ; i<m ; i++)System.out.print(res[i]);
  }
  public static void main(String[] args){
    int s=9,m=2 ;
    findSmallest(m,s);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findSmallest( m : int, s : int) : void
  pre: true
  post: true
  activity: (     if (s = 0) then (     OclFile["System.out"].print(if m = 1 then "Smallest number is 0" else "Not possible" endif) ; 
     return ) else skip ; 
     if (s > 9 * m) then (     OclFile["System.out"].println("Not possible") ; 
     return ) else skip ; 
    var res : Sequence(int) ; res := Integer.subrange(1,m)->collect(0) ;
    s := s-(1) ; 
        var i : int ; i := m - 1 ; while i > 0 do ( (     if (s > 9) then (     res[i+1] := 9 ; 
     s := s-(9) ) else (     res[i+1] := s ; 
     s := 0 ) )  ;     i := i - 1 ) ; 
    res[0+1] := s + 1 ; 
    OclFile["System.out"].print("Smallest number is ") ; 
        var i : int ; i := 0 ; while i < m do (     OclFile["System.out"].print(res[i+1]) ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : int ; s := 9 ;
    var m : int ; m := 2 ;
     execute findSmallest(m, s) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static void printLines(int n,int k){
    for(int i=0 ; i<n ; i++){
      System.out.println(k*(6*i+1)+" "+k*(6*i+2)+" "+k*(6*i+3)+" "+k*(6*i+5));
    }
  }
  public static void main(String args[]){
    int n=2,k=2 ;
    printLines(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printLines( n : int, k : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(k * (6 * i + 1) + " " + k * (6 * i + 2) + " " + k * (6 * i + 3) + " " + k * (6 * i + 5)) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
    var k : int ; k := 2 ;
     execute printLines(n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void makearrayequal(int arr[],int n){
    int x=0 ;
    for(int i=0 ; i<n ; i++){
      x+=(arr[i] & 1);
    }
    System.out.println(Math.min(x,n-x));
  }
  public static void main(String[] args){
    int arr[]={
      4,3,2,1 };
      int n=arr.length ;
      makearrayequal(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation makearrayequal( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     x := x+((arr[i+1] & 1)) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(Set{x, n - x}->min()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,3,2,1} ;
     var n : int ; n := arr->size() ;
     execute makearrayequal(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int index[]=new int[100001];
    for(int i=0 ; i<n ; i++){
      int val=sc.nextInt();
      index[val]=i+1 ;
    }
    int q=sc.nextInt();
    long front=0 ;
    long back=0 ;
    for(int i=0 ; i<q ; i++){
      int num=sc.nextInt();
      front+=index[num];
      back+=(n-index[num]+1);
    }
    System.out.println(front+" "+back);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var index : Sequence(int) ; index := Integer.subrange(1,100001)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var val : int ; val := sc.getCurrent()->toInteger() ;
     index[val+1] := i + 1 )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var front : long ; front := 0 ;
    var back : long ; back := 0 ;
        var i : int ; i := 0 ; while i < q do ( (     var num : int ; num := sc.getCurrent()->toInteger() ;
     front := front+(index[num+1]) ; 
     back := back+((n - index[num+1] + 1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(front + " " + back) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package codejam.round1c_2012 ;
import java.io.File ;
import java.io.PrintStream ;
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Deque ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Set ;
public class MainA {
  static char[] mapping=new char[256];
  static List<Set<Integer>>defs ;
  public static void main(String[] args)throws Exception {
    String f="/home/floris/dev/java/Test/src/codejam/round1c_2012/A-large.in" ;
    Scanner sc=new Scanner(new File(f));
    System.setOut(new PrintStream(new File(f+".out")));
    int T=sc.nextInt();
    for(int i=1 ; T-->0 ; i++){
      defs=new ArrayList<Set<Integer>>();
      int classCount=sc.nextInt();
      for(int j=0 ; j<classCount ; j++){
        Set<Integer>cur=new HashSet<Integer>();
        int ic=sc.nextInt();
        for(int k=0 ; k<ic ; k++)cur.add(sc.nextInt()-1);
        defs.add(cur);
      }
      System.out.printf("Case #%d: %s%n",i,solve());
    }
  }
  private static String solve(){
    for(int i=0 ; i<defs.size(); i++){
      List<Integer>contained=new ArrayList<Integer>();
      Deque<Integer>d=new ArrayDeque();
      d.addAll(defs.get(i));
      contained.addAll(defs.get(i));
      contained.add(i);
      while(! d.isEmpty()){
        int v=d.remove();
        for(int k : defs.get(v)){
          if(contained.contains(k))return "Yes" ;
          d.add(k);
          contained.add(k);
        }
      }
    }
    return "No" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainA {
  static   attribute mapping : Sequence(String) := Integer.subrange(1,256)->collect(0);
  static   attribute defs : Sequence(Set(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : String ; f := "/home/floris/dev/java/Test/src/codejam/round1c"/home/floris/dev/java/Test/src/codejam/round1c    var f :  ; f := "/home/floris/dev/java/Test/src/codejam/round1c"/home/floris/dev/java/Test/src/codejam/round1c_2012/A-large.in"012/A-large.in"012/A-large.in"012/A-large.in" ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile(f)) ;
setOut(OclFile.newOclFile_Write(OclFile(f + ".out"))) ; 
    var T : int ; T := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while T > 0 do ( (     defs := Sequence{} ; 
     var classCount : int ; classCount := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < classCount do ( (     var cur : Set(int) ; cur := Set{} ;
     var ic : int ; ic := sc.getCurrent()->toInteger() ;
         var k : int ; k := 0 ; while k < ic do (     cur := cur->including(sc.getCurrent()->toInteger() - 1) ;  ;     k := k + 1 ) ; 
     defs := defs->including(cur) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].printf("Case #%d: %s%n", i, solve()) )  ;     i := i + 1 ) ; 
 );
  static   operation solve() : String
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < defs->size() do ( (     var contained : Sequence(int) ; contained := Sequence{} ;
     var d : Sequence(int) ; d := Sequence{} ;
    d := d->union(defs->at(i+1)) ; 
    contained := contained->union(defs->at(i+1)) ; 
    contained := contained->including(i) ; 
    while (not(d->isEmpty())) do (     var v : int ; v := d.remove() ;
     for (k : defs->at(v+1)) do ( (     if (contained->includes(k)) then     return "Yes" else skip ; 
     d := d->including(k) ; 
     contained := contained->including(k) )  ) ) ; 
 )  ;     i := i + 1 ) ; 
     return "No" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    long vasya=0 ;
    long petya=0 ;
    int[] arr=new int[100100];
    int[] arr1=new int[100100];
    for(int i=0 ; i<n ; i++){
      arr1[i]=input.nextInt();
      arr[arr1[i] ]=i+1 ;
    }
    long m=input.nextInt();
    while(m-->0){
      int number=input.nextInt();
      vasya+=arr[number];
      petya+=n-arr[number]+1 ;
    }
    System.out.println(vasya+" "+petya);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var vasya : long ; vasya := 0 ;
    var petya : long ; petya := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,100100)->collect(0) ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,100100)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr1[i+1] := input.getCurrent()->toInteger() ; 
     arr[arr1[i+1]+1] := i + 1 )  ;     i := i + 1 ) ; 
    var m : long ; m := input.getCurrent()->toInteger() ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     var number : int ; number := input.getCurrent()->toInteger() ;
     vasya := vasya+(arr[number+1]) ; 
     petya := petya+(n - arr[number+1] + 1) ) ;  ) ;  
    OclFile["System.out"].println(vasya + " " + petya) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    int N=sc.nextInt();
    int[] ix=new int[100005];
    for(int i=1 ; i<=N ; i++){
      int num=sc.nextInt();
      ix[num]=i ;
    }
    long tot1=0,tot2=0 ;
    int M=sc.nextInt();
    while(M!=0){
      int q=sc.nextInt();
      tot1+=ix[q];
      tot2+=N-ix[q]+1 ;
      M--;
    }
    System.out.print(tot1+" "+tot2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var ix : Sequence(int) ; ix := Integer.subrange(1,100005)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do ( (     var num : int ; num := sc.getCurrent()->toInteger() ;
     ix[num+1] := i )  ;     i := i + 1 ) ; 
    var tot1 : long ; tot1 := 0 ;
    var tot2 : long ; tot2 := 0 ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    while (M /= 0) do (     var q : int ; q := sc.getCurrent()->toInteger() ;
     tot1 := tot1+(ix[q+1]) ; 
     tot2 := tot2+(N - ix[q+1] + 1) ; 
     M := M - 1 ) ; 
    OclFile["System.out"].print(tot1 + " " + tot2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class EffectiveApproach {
  private static int[] arr=new int[(int)(1e5+5)];
  public static void main(String[] args)throws FileNotFoundException {
    FastReader in=new FastReader();
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++)arr[in.nextInt()]=i ;
    int m=in.nextInt();
    long one=0 ;
    long two=0 ;
    for(int i=0 ; i<m ; i++){
      int idx=arr[in.nextInt()]+1 ;
      one+=idx ;
      two+=n-idx+1 ;
    }
    out.println(one+" "+two);
    out.close();
  }
  private static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    FastReader()throws FileNotFoundException {
      br=new BufferedReader(new InputStreamReader(System.getProperty("ONLINE_JUDGE")==null ? new FileInputStream("input.txt"): 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class EffectiveApproach {
  static   attribute arr : Sequence(int) := Integer.subrange(1,(1e5 + 5)->oclAsType(int))->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := in.nextInt() ;
        var i : int ; i := 0 ; while i < n do (     arr[in.nextInt()+1] := i ;  ;     i := i + 1 ) ; 
    var m : int ; m := in.nextInt() ;
    var one : long ; one := 0 ;
    var two : long ; two := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var idx : int ; idx := arr[in.nextInt()+1] + 1 ;
     one := one+(idx) ; 
     two := two+(n - idx + 1) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(if OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null then OclFile.newOclFile_Read(OclFile.newOclFile("input.txt")) else OclFile["System.in"] endif)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void division_of_string(char[] str,int k){
    int n=str.length ;
    Map<Character,Boolean>has=new HashMap<>();
    int ans=0,cnt=0,i=0 ;
    while(i<n){
      if(! has.containsKey(str[i])){
        cnt++;
        has.put(str[i],true);
      }
      if(cnt==k){
        ans=i ;
        break ;
      }
      i++;
    }
    has.clear();
    cnt=0 ;
    while(i<n){
      if(! has.containsKey(str[i])){
        cnt++;
        has.put(str[i],true);
      }
      if(cnt==k){
        break ;
      }
      i++;
    }
    if(cnt<k){
      System.out.println("Not possible");
    }
    else {
      i=0 ;
      while(i<=ans){
        System.out.print(str[i]);
        i++;
      }
      System.out.println("");
      while(i<n){
        System.out.print(str[i]);
        i++;
      }
      System.out.println("");
    }
    System.out.println("");
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    int k=4 ;
    division_of_string(str.toCharArray(),k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation division_of_string( str : Sequence(String), k : int) : void
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var has : Map(String,Boolean) ; has := Map{} ;
    var ans : int ; ans := 0 ;
    var cnt : int ; cnt := 0 ;
    var i : int ; i := 0 ;
    while (i < n) do (     if (not(has->keys()->includes(str[i+1]))) then (     cnt := cnt + 1 ; 
     has := has->union(Map{str[i+1] |-> true}) ) else skip ; 
     if (cnt = k) then (     ans := i ; 
     break ) else skip ; 
     i := i + 1 ) ; 
    has := has->intersection(Map{}) ; 
    cnt := 0 ; 
    while (i < n) do (     if (not(has->keys()->includes(str[i+1]))) then (     cnt := cnt + 1 ; 
     has := has->union(Map{str[i+1] |-> true}) ) else skip ; 
     if (cnt = k) then (     break ) else skip ; 
     i := i + 1 ) ; 
    if (cnt < k) then (     OclFile["System.out"].println("Not possible") ) else (     i := 0 ; 
     while (i <= ans) do (     OclFile["System.out"].print(str[i+1]) ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
    while (i < n) do (     OclFile["System.out"].print(str[i+1]) ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
 ) ;  
    OclFile["System.out"].println("") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var k : int ; k := 4 ;
     execute division_of_string(str->characters(), k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int count_pairs(String s1[],String s2[],int n1,int n2){
    HashMap<String,Integer>mp=new HashMap<String,Integer>();
    for(int i=0 ; i<n1 ; i++)mp.put(s1[i],0);
    for(int i=0 ; i<n1 ; i++)mp.put(s1[i],mp.get(s1[i])+1);
    int cnt=0 ;
    for(int i=0 ; i<n2 ; i++){
      if(mp.get(s2[i])>0){
        cnt++;
        mp.put(s2[i],mp.get(s2[i])-1);
      }
    }
    return cnt ;
  }
  public static void main(String[] args){
    String s1[]={
      "abc","def" };
      String s2[]={
        "abc","abc" };
        int n1=s1.length ;
        int n2=s2.length ;
        System.out.println(count_pairs(s1,s2,n1,n2));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count_pairs( s1 : Sequence(String), s2 : Sequence(String), n1 : int, n2 : int) : int
  pre: true
  post: true
  activity: (     var mp : Map(String,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n1 do (     mp := mp->union(Map{s1[i+1] |-> 0}) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n1 do (     mp := mp->union(Map{s1[i+1] |-> mp->at(s1[i+1]) + 1}) ;  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n2 do ( (     if (mp->at(s2[i+1]) > 0) then (     cnt := cnt + 1 ; 
     mp := mp->union(Map{s2[i+1] |-> mp->at(s2[i+1]) - 1}) ) else skip )  ;     i := i + 1 ) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : Sequence(String) ; s1 := Sequence{"abc","def"} ;
     var s2 : Sequence(String) ; s2 := Sequence{"abc","abc"} ;
    var n1 : int ; n1 := s1->size() ;
    var n2 : int ; n2 := s2->size() ;
    OclFile["System.out"].println(count_pairs(s1, s2, n1, n2)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int fact(int n){
    int res=1 ;
    for(int i=2 ; i<=n ; i++)res=res*i ;
    return res ;
  }
  static int nCr(int n,int r){
    return fact(n)/(fact(r)*fact(n-r));
  }
  static int NumberOfWays(int X,int Y,int M,int N){
    return fact(X+Y)*nCr(M,X)*nCr(N,Y);
  }
  public static void main(String[] args)throws java.lang.Exception {
    int X=2,Y=2,M=3,N=3 ;
    System.out.println(NumberOfWays(X,Y,M,N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fact( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
         var i : int ; i := 2 ; while i <= n do (     res := res * i ;  ;     i := i + 1 ) ; 
     return res );
  static   operation nCr( n : int, r : int) : int
  pre: true
  post: true
  activity: (     return fact(n) / (fact(r) * fact(n - r)) );
  static   operation NumberOfWays( X : int, Y : int, M : int, N : int) : int
  pre: true
  post: true
  activity: (     return fact(X + Y) * nCr(M, X) * nCr(N, Y) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 2 ;
    var Y : int ; Y := 2 ;
    var M : int ; M := 3 ;
    var N : int ; N := 3 ;
     OclFile["System.out"].println(NumberOfWays(X, Y, M, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findCountOfSolutions(int n,int p){
    int ans=0 ;
    for(int x=1 ; x<p ; x++){
      if((x*x)% p==1){
        int last=x+p*(n/p);
        if(last>n)last-=p ;
        ans+=((last-x)/p+1);
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int n=10 ;
    int p=5 ;
    System.out.println(findCountOfSolutions(n,p));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findCountOfSolutions( n : int, p : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var x : int ; x := 1 ; while x < p do ( (     if ((x * x) mod p = 1) then (     var last : int ; last := x + p * (n / p) ;
     if (last > n) then     last := last-(p) ; else skip ; 
     ans := ans+(((last - x) / p + 1)) ) else skip )  ;     x := x + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     var p : int ; p := 5 ;
     OclFile["System.out"].println(findCountOfSolutions(n, p)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int LAS[][]=new int[1000][2];
  static int solve(int arr[],int n,int i,int pos){
    if(i==n)return 0 ;
    if(LAS[i][pos]==1)return LAS[i][pos];
    int inc=0,exc=0 ;
    if(arr[i]>0 && pos==1){
      pos=0 ;
      inc=1+solve(arr,n,i+1,pos);
    }
    else if(arr[i]<0 && pos==0){
      pos=1 ;
      inc=1+solve(arr,n,i+1,pos);
    }
    exc=solve(arr,n,i+1,pos);
    LAS[i][pos]=Math.max(inc,exc);
    return LAS[i][pos];
  }
  public static void main(String[] args){
    int arr[]={
-1,2,3,4,5,-6,8,-99 };
      int n=arr.length ;
      System.out.println(Math.max(solve(arr,n,0,0),solve(arr,n,0,1)));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute LAS : int := Integer.subrange(1,1000)->collect(Integer.subrange(1,2)->collect(0));
  static   operation solve( arr : Sequence(int), n : int, i : int, pos : int) : int
  pre: true
  post: true
  activity: (     if (i = n) then     return 0 else skip ; 
     if (LAS[i+1][pos+1] = 1) then     return LAS[i+1][pos+1] else skip ; 
    var inc : int ; inc := 0 ;
    var exc : int ; exc := 0 ;
    if (arr[i+1] > 0 & pos = 1) then (     pos := 0 ; 
     inc := 1 + solve(arr, n, i + 1, pos) ) else     if (arr[i+1] < 0 & pos = 0) then (     pos := 1 ; 
     inc := 1 + solve(arr, n, i + 1, pos) ) else skip ; ;  
    exc := solve(arr, n, i + 1, pos) ; 
    LAS[i+1][pos+1] := Set{inc, exc}->max() ; 
    return LAS[i+1][pos+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-1,2,3,4,5,-6,8,-99} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(Set{solve(arr, n, 0, 0), solve(arr, n, 0, 1)}->max()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int findKthLargest(int[] nums,int k){
    shuffle(nums);
    k=nums.length-k ;
    int lo=0 ;
    int hi=nums.length-1 ;
    while(lo<hi){
      final int j=partition(nums,lo,hi);
      if(j<k){
        lo=j+1 ;
      }
      else if(j>k){
        hi=j-1 ;
      }
      else {
        break ;
      }
    }
    return nums[k];
  }
  private int partition(int[] a,int lo,int hi){
    int i=lo ;
    int j=hi+1 ;
    while(true){
      while(i<hi && less(a[++i],a[lo]));
      while(j>lo && less(a[lo],a[--j]));
      if(i>=j){
        break ;
      }
      exch(a,i,j);
    }
    exch(a,lo,j);
    return j ;
  }
  private void exch(int[] a,int i,int j){
    final int tmp=a[i];
    a[i]=a[j];
    a[j]=tmp ;
  }
  private boolean less(int v,int w){
    return v<w ;
  }
  private void shuffle(int a[]){
    final Random random=new Random();
    for(int ind=1 ; ind<a.length ; ind++){
      final int r=random.nextInt(ind+1);
      exch(a,ind,r);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation findKthLargest( nums : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     execute shuffle(nums) ; 
     k := nums->size() - k ; 
    var lo : int ; lo := 0 ;
    var hi : int ; hi := nums->size() - 1 ;
    while (lo < hi) do (     var j : int ; j := partition(nums, lo, hi) ;
     if (j < k) then (     lo := j + 1 ) else     if (j > k) then (     hi := j - 1 ) else (     break ) ;  ) ; 
    return nums[k+1] 
 );
   operation partition( a : Sequence(int), lo : int, hi : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := lo ;
     var j : int ; j := hi + 1 ;
    while (true) do (     while (i < hi & less(a[(i + 1)+1], a[lo+1])) do  ; 
     while (j > lo & less(a[lo+1], a[(j - 1)+1])) do  ; 
     if (i >= j) then (     break ) else skip ; 
     execute exch(a, i, j) ) ; 
    execute exch(a, lo, j) ; 
    return j 
 );
   operation exch( a : Sequence(int), i : int, j : int) : void
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := a[i+1] ;
     a[i+1] := a[j+1] ; 
     a[j+1] := tmp );
   operation less( v : int, w : int) : boolean
  pre: true
  post: true
  activity: (     return v < w );
   operation shuffle( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var random : OclRandom ; random := OclRandom.newOclRandom() ;
         var ind : int ; ind := 1 ; while ind < a->size() do ( (     var r : int ; r := random.nextInt(ind + 1) ;
     execute exch(a, ind, r) )  ;     ind := ind + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] x=new int[n];
    int[] a=new int[n];
    int[] k=new int[n+1];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      k[a[i] ]++;
      if(a[i]>=k[a[i] ])x[a[i]-k[a[i] ] ]++;
    }
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(x[i]==0)ans++;
    }
    for(int i=0 ; i<m ; i++){
      int X=sc.nextInt()-1 ;
      int Y=sc.nextInt();
      int t=a[X];
      a[X]=Y ;
      if(t>=k[t]){
        x[t-k[t] ]--;
        if(x[t-k[t] ]==0)ans++;
      }
      k[t]--;
      if((Y-k[Y])>=1){
        x[Y-k[Y]-1]++;
        if(x[Y-k[Y]-1]==1)ans--;
      }
      k[Y]++;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var k : Sequence(int) ; k := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     k[a[i+1]+1] := k[a[i+1]+1] + 1 ; 
     if (a[i+1] >= k[a[i+1]+1]) then     x[a[i+1] - k[a[i+1]+1]+1] := x[a[i+1] - k[a[i+1]+1]+1] + 1 ; else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (x[i+1] = 0) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var X : int ; X := sc.getCurrent()->toInteger() - 1 ;
     var Y : int ; Y := sc.getCurrent()->toInteger() ;
    var t : int ; t := a[X+1] ;
    a[X+1] := Y ; 
    if (t >= k[t+1]) then (     x[t - k[t+1]+1] := x[t - k[t+1]+1] - 1 ; 
     if (x[t - k[t+1]+1] = 0) then     ans := ans + 1 ; else skip ) else skip ; 
    k[t+1] := k[t+1] - 1 ; 
    if ((Y - k[Y+1]) >= 1) then (     x[Y - k[Y+1] - 1+1] := x[Y - k[Y+1] - 1+1] + 1 ; 
     if (x[Y - k[Y+1] - 1+1] = 1) then     ans := ans - 1 ; else skip ) else skip ; 
    k[Y+1] := k[Y+1] + 1 ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] nums=new int[n+1];
    int[] counts=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      nums[i]=sc.nextInt();
      counts[nums[i] ]++;
    }
    int[] imos=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      imos[Math.max(i-counts[i],0)]++;
      imos[i]--;
    }
    int zeros=-1 ;
    if(imos[0]==0){
      zeros++;
    }
    for(int i=1 ; i<=n ; i++){
      imos[i]+=imos[i-1];
      if(imos[i]==0){
        zeros++;
      }
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<m ; i++){
      int idx=sc.nextInt();
      int x=nums[idx];
      if(x-counts[x]>=0){
        imos[x-counts[x] ]--;
        if(imos[x-counts[x] ]==0){
          zeros++;
        }
      }
      counts[x]--;
      int y=sc.nextInt();
      nums[idx]=y ;
      counts[y]++;
      if(y-counts[y]>=0){
        if(imos[y-counts[y] ]==0){
          zeros--;
        }
        imos[y-counts[y] ]++;
      }
      sb.append(zeros).append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n + 1)->collect(0) ;
    var counts : Sequence(int) ; counts := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     nums[i+1] := sc.getCurrent()->toInteger() ; 
     counts[nums[i+1]+1] := counts[nums[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var imos : Sequence(int) ; imos := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     imos[Set{i - counts[i+1], 0}->max()+1] := imos[Set{i - counts[i+1], 0}->max()+1] + 1 ; 
     imos[i+1] := imos[i+1] - 1 )  ;     i := i + 1 ) ; 
    var zeros : int ; zeros := -1 ;
    if (imos[0+1] = 0) then (     zeros := zeros + 1 ) else skip ; 
        var i : int ; i := 1 ; while i <= n do ( (     imos[i+1] := imos[i+1]+(imos[i - 1+1]) ; 
     if (imos[i+1] = 0) then (     zeros := zeros + 1 ) else skip )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < m do ( (     var idx : int ; idx := sc.getCurrent()->toInteger() ;
     var x : int ; x := nums[idx+1] ;
    if (x - counts[x+1] >= 0) then (     imos[x - counts[x+1]+1] := imos[x - counts[x+1]+1] - 1 ; 
     if (imos[x - counts[x+1]+1] = 0) then (     zeros := zeros + 1 ) else skip ) else skip ; 
    counts[x+1] := counts[x+1] - 1 ; 
    var y : int ; y := sc.getCurrent()->toInteger() ;
    nums[idx+1] := y ; 
    counts[y+1] := counts[y+1] + 1 ; 
    if (y - counts[y+1] >= 0) then (     if (imos[y - counts[y+1]+1] = 0) then (     zeros := zeros - 1 ) else skip ; 
     imos[y - counts[y+1]+1] := imos[y - counts[y+1]+1] + 1 ) else skip ; 
    sb := sb + StringLib.newString(zeros) + StringLib.newString("\n") ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new FileReader("A-small-attempt0.in"));
    PrintWriter out=new PrintWriter(new FileWriter("A-small.out"));
    int T=Integer.parseInt(in.readLine());
    for(int i=0 ; i<T ; i++){
      boolean adj[][]=new boolean[1005][1005];
      int N ;
      String s=in.readLine();
      StringTokenizer st=new StringTokenizer(s);
      N=Integer.parseInt(st.nextToken());
      for(int r=0 ; r<N ; r++){
        s=in.readLine();
        st=new StringTokenizer(s);
        int M=Integer.parseInt(st.nextToken());
        for(int c=0 ; c<M ; c++){
          int d=Integer.parseInt(st.nextToken())-1 ;
          adj[r][d]=true ;
        }
      }
      boolean ans=false ;
      for(int n=0 ; n<N ; n++){
        LinkedList<Integer>q=new LinkedList<Integer>();
        q.add(n);
        boolean v[]=new boolean[N];
        while(! q.isEmpty()){
          int x=q.pollFirst();
          if(v[x]){
            ans=true ;
            break ;
          }
          v[x]=true ;
          for(int m=0 ; m<N ; m++){
            if(adj[x][m]){
              q.addFirst(m);
            }
          }
        }
      }
      out.println("Case #"+(i+1)+": "+(ans ? "Yes" : "No"));
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("A-small-attempt0.in"))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("A-small.out"))) ;
    var T : int ; T := (in.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < T do ( (     var adj : Sequence(Sequence(boolean)) ; adj := Integer.subrange(1,1005)->collect(Integer.subrange(1,1005)->collect(false)) ;
     var N : int ;
    var s : String ; s := in.readLine() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(s) ;
    N := (st.next())->toInteger() ; 
        var r : int ; r := 0 ; while r < N do ( (     s := in.readLine() ; 
     st := OclIterator.newOclIterator_String(s) ; 
     var M : int ; M := (st.next())->toInteger() ;
         var c : int ; c := 0 ; while c < M do ( (     var d : int ; d := (st.next())->toInteger() - 1 ;
     adj[r+1][d+1] := true )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    var ans : boolean ; ans := false ;
        var n : int ; n := 0 ; while n < N do ( (     var q : Sequence(int) ; q := Sequence{} ;
     q := q->including(n) ; 
     var v : Sequence(boolean) ; v := Integer.subrange(1,N)->collect(false) ;
     while (not(q->isEmpty())) do (     var x : int ; x := q->first() ;
     if (v[x+1]) then (     ans := true ; 
     break ) else skip ; 
     v[x+1] := true ; 
         var m : int ; m := 0 ; while m < N do ( (     if (adj[x+1][m+1]) then (     q := q->prepend(m) ) else skip )  ;     m := m + 1 ) ) )  ;     n := n + 1 ) ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int M=scan.nextInt();
    int[] A=IntStream.range(0,N).map(i->scan.nextInt()).toArray();
    int[] num=new int[N+1];
    int[] line=new int[N+1];
    Arrays.fill(num,0);
    Arrays.fill(line,0);
    for(int i=0 ; i<N ; ++i)num[A[i] ]++;
    for(int i=1 ; i<=N ; ++i){
      for(int j=0 ; j<num[i]; j++){
        if(i>j)line[i-j]++;
      }
    }
    int gap=0 ;
    for(int i=1 ; i<=N ; ++i)if(line[i]<=0)++gap ;
    while(M-->0){
      int x=scan.nextInt()-1 ;
      int y=scan.nextInt();
      int a=A[x];
      A[x]=y ;
--num[a];
      if(a-num[a]>0){
--line[a-num[a] ];
        if(line[a-num[a] ]==0)++gap ;
      }
++num[y];
      if(y-num[y]+1>0){
        if(line[y-num[y]+1]==0)--gap ;
++line[y-num[y]+1];
      }
      System.out.println(gap);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var M : int ; M := scan.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(0, N-1)->collect( _x1 | (lambda i : OclAny in scan.getCurrent()->toInteger())->apply(_x1) )->asSequence() ;
    var num : Sequence(int) ; num := Integer.subrange(1,N + 1)->collect(0) ;
    var line : Sequence(int) ; line := Integer.subrange(1,N + 1)->collect(0) ;
    num := num->collect(0) ; 
    line := line->collect(0) ; 
        var i : int ; i := 0 ; while i < N do (     num[A[i+1]+1] := num[A[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := 0 ; while j < num[i+1] do ( (     if (i > j) then     line[i - j+1] := line[i - j+1] + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var gap : int ; gap := 0 ;
        var i : int ; i := 1 ; while i <= N do (     if (line[i+1] <= 0) then     gap := gap + 1 ; else skip ;  ;     i := i + 1 ) ; 
        while (M > 0) do (        M := M - 1 ;     skip ; (     var x : int ; x := scan.getCurrent()->toInteger() - 1 ;
     var y : int ; y := scan.getCurrent()->toInteger() ;
    var a : int ; a := A[x+1] ;
    A[x+1] := y ; 
    num[a+1] := num[a+1] - 1 ; 
    if (a - num[a+1] > 0) then (     line[a - num[a+1]+1] := line[a - num[a+1]+1] - 1 ; 
     if (line[a - num[a+1]+1] = 0) then     gap := gap + 1 ; else skip ) else skip ; 
    num[y+1] := num[y+1] + 1 ; 
    if (y - num[y+1] + 1 > 0) then (     if (line[y - num[y+1] + 1+1] = 0) then     gap := gap - 1 ; else skip ; 
     line[y - num[y+1] + 1+1] := line[y - num[y+1] + 1+1] + 1 ) else skip ; 
    OclFile["System.out"].println(gap) ; 
 ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[] a=new int[N];
    int[] b=new int[N+1];
    int[] c=new int[N];
    for(int i=1 ; i<N+1 ; i++){
      b[i]=i ;
    }
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextInt();
      b[a[i] ]--;
      if(b[a[i] ]>=0)c[b[a[i] ] ]++;
    }
    int L=0 ;
    for(int i=0 ; i<N ; i++){
      if(c[i]==0)L++;
    }
    for(int i=0 ; i<M ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      if(b[a[x-1] ]>=0)c[b[a[x-1] ] ]--;
      if(b[a[x-1] ]>=0 && c[b[a[x-1] ] ]==0)L++;
      b[a[x-1] ]++;
      a[x-1]=y ;
      b[y]--;
      if(b[y]>=0 && c[b[y] ]==0)L--;
      if(b[y]>=0)c[b[y] ]++;
      System.out.println(L);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,N + 1)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 1 ; while i < N + 1 do ( (     b[i+1] := i )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[a[i+1]+1] := b[a[i+1]+1] - 1 ; 
     if (b[a[i+1]+1] >= 0) then     c[b[a[i+1]+1]+1] := c[b[a[i+1]+1]+1] + 1 ; else skip )  ;     i := i + 1 ) ; 
    var L : int ; L := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (c[i+1] = 0) then     L := L + 1 ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    if (b[a[x - 1+1]+1] >= 0) then     c[b[a[x - 1+1]+1]+1] := c[b[a[x - 1+1]+1]+1] - 1 ; else skip ; 
    if (b[a[x - 1+1]+1] >= 0 & c[b[a[x - 1+1]+1]+1] = 0) then     L := L + 1 ; else skip ; 
    b[a[x - 1+1]+1] := b[a[x - 1+1]+1] + 1 ; 
    a[x - 1+1] := y ; 
    b[y+1] := b[y+1] - 1 ; 
    if (b[y+1] >= 0 & c[b[y+1]+1] = 0) then     L := L - 1 ; else skip ; 
    if (b[y+1] >= 0) then     c[b[y+1]+1] := c[b[y+1]+1] + 1 ; else skip ; 
    OclFile["System.out"].println(L) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findMin(int arr[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=arr[i];
    Arrays.sort(arr);
    int min=arr[0];
    int max=0 ;
    for(int i=n-1 ; i>=1 ; i--){
      int num=arr[i];
      int total=num+min ;
      int j ;
      for(j=2 ; j<=num ; j++){
        if(num % j==0){
          int d=j ;
          int now=(num/d)+(min*d);
          int reduce=total-now ;
          if(reduce>max)max=reduce ;
        }
      }
    }
    System.out.println(sum-max);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5 };
      int n=arr.length ;
      findMin(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMin( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var min : int ; min := arr[0+1] ;
    var max : int ; max := 0 ;
        var i : int ; i := n - 1 ; while i >= 1 do ( (     var num : int ; num := arr[i+1] ;
     var total : int ; total := num + min ;
     var j : int ;
         j := 2 ; while j <= num do ( (     if (num mod j = 0) then (     var d : int ; d := j ;
     var now : int ; now := (num / d) + (min * d) ;
     var reduce : int ; reduce := total - now ;
     if (reduce > max) then     max := reduce ; else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(sum - max) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var n : int ; n := arr->size() ;
     execute findMin(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  static int solve(int[] A,int n){
    int i,cnt=0,j ;
    int[] parent=new int[n+1];
    int[] vis=new int[n+1];
    for(i=0 ; i<n+1 ; i++){
      parent[i]=-1 ;
      vis[i]=0 ;
    }
    for(i=0 ; i<n ; i++){
      j=i ;
      if(parent[j]==-1){
        while(parent[j]==-1){
          parent[j]=i ;
          j=(j+A[j]+1)% n ;
        }
        if(parent[j]==i){
          while(vis[j]==0){
            vis[j]=1 ;
            cnt++;
            j=(j+A[j]+1)% n ;
          }
        }
      }
    }
    return cnt ;
  }
  public static void main(String args[]){
    int[] A={
      0,0,0,2 };
      int n=A.length ;
      System.out.print(solve(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var cnt : int ; cnt := 0 ;
    var j : int ;
     var parent : Sequence(int) ; parent := Integer.subrange(1,n + 1)->collect(0) ;
    var vis : Sequence(int) ; vis := Integer.subrange(1,n + 1)->collect(0) ;
        i := 0 ; while i < n + 1 do ( (     parent[i+1] := -1 ; 
     vis[i+1] := 0 )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     j := i ; 
     if (parent[j+1] = -1) then (     while (parent[j+1] = -1) do (     parent[j+1] := i ; 
     j := (j + A[j+1] + 1) mod n ) ; 
     if (parent[j+1] = i) then (     while (vis[j+1] = 0) do (     vis[j+1] := 1 ; 
     cnt := cnt + 1 ; 
     j := (j + A[j+1] + 1) mod n ) ) else skip ) else skip )  ;     i := i + 1 ) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{0,0,0,2} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].print(solve(A, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int k=scanner.nextInt();
    int[] a=new int[k];
    for(int i=0 ; i<a.length ; i++){
      a[i]=scanner.nextInt();
    }
    Arrays.sort(a);
    int cnt=a[0]-1 ;
    if(k==25){
      for(int i=a.length-2 ; i>=0 ; i--){
        cnt+=a[i+1]-a[i]-1 ;
      }
      System.out.println(cnt);
    }
    else {
      if(a[a.length-1]<=25){
        System.out.println(0);
      }
      else {
        System.out.println(a[a.length-1]-25);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var cnt : int ; cnt := a[0+1] - 1 ;
    if (k = 25) then (         var i : int ; i := a->size() - 2 ; while i >= 0 do ( (     cnt := cnt+(a[i + 1+1] - a[i+1] - 1) )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println(cnt) ) else (     if (a[a->size() - 1+1] <= 25) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(a[a->size() - 1+1] - 25) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.*;
public class App {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws Exception {
    if(System.getProperty("ONLINE_JUDGE")==null){
      File inputFile=new File("/Users/vipinjain/self/cp/input.txt");
      File outputFile=new File("/Users/vipinjain/self/cp/output.txt");
      br=new BufferedReader(new FileReader(inputFile));
      bw=new BufferedWriter(new FileWriter(outputFile));
    }
    int tests ;
    tests=1 ;
    while(tests-->0){
      solve();
    }
    bw.flush();
    bw.close();
    br.close();
  }
  static int getNumberOfDays(int month){
    switch(month){
      case 1 : case 3 : case 5 : case 7 : case 8 : case 10 : case 12 : return 31 ;
      case 2 : return 28 ;
      default : return 30 ;
    }
  }
  static void solve()throws Exception {
    int k=Integer.parseInt(br.readLine());
    int[] arr=Stream.of(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    int maxGreaterThan25=26 ;
    int countUpto25=0 ;
    int countGreatherThan25=0 ;
    for(int num : arr){
      if(num<=25){
        countUpto25++;
      }
      else {
        maxGreaterThan25=Math.max(maxGreaterThan25,num);
      }
    }
    if(countUpto25==k){
      bw.write("0");
    }
    else {
      int ans=maxGreaterThan25-25 ;
      bw.write(ans+"");
    }
    bw.write("\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null) then (     var inputFile : OclFile ; inputFile := OclFile("/Users/vipinjain/self/cp/input.txt") ;
     var outputFile : OclFile ; outputFile := OclFile("/Users/vipinjain/self/cp/output.txt") ;
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputFile)) ; 
     bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputFile)) ) else skip ; 
     var tests : int ;
    tests := 1 ; 
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation getNumberOfDays( month : int) : int
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (month) ; 
    if _switchval = 1 or _switchval = 3 or _switchval = 5 or _switchval = 7 or _switchval = 8 then
   if _switchval = 10 then
   if _switchval = 12 then
    return 31 
   else skip ;
       if _switchval = 2 then
     return 28 
   else skip ;
       if true then
     return 30 
   else skip ;
 )
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var k : int ; k := (br.readLine())->toInteger() ;
     var arr : Sequence(int) ; arr := Sequence{br.readLine()->split(" ")}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var maxGreaterThan25 : int ; maxGreaterThan25 := 26 ;
    var countUpto25 : int ; countUpto25 := 0 ;
    var countGreatherThan25 : int ; countGreatherThan25 := 0 ;
    for (num : arr) do ( (     if (num <= 25) then (     countUpto25 := countUpto25 + 1 ) else (     maxGreaterThan25 := Set{maxGreaterThan25, num}->max() ) )  ) ; 
    if (countUpto25 = k) then (     skip ) else (     var ans : int ; ans := maxGreaterThan25 - 25 ;
     skip ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.*;
public class App {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws Exception {
    if(System.getProperty("ONLINE_JUDGE")==null){
      File inputFile=new File("/Users/vipinjain/self/cp/input.txt");
      File outputFile=new File("/Users/vipinjain/self/cp/output.txt");
      br=new BufferedReader(new FileReader(inputFile));
      bw=new BufferedWriter(new FileWriter(outputFile));
    }
    int tests ;
    tests=1 ;
    while(tests-->0){
      solve();
    }
    bw.flush();
    bw.close();
    br.close();
  }
  static int getNumberOfDays(int month){
    switch(month){
      case 1 : case 3 : case 5 : case 7 : case 8 : case 10 : case 12 : return 31 ;
      case 2 : return 28 ;
      default : return 30 ;
    }
  }
  static void solve()throws Exception {
    int k=Integer.parseInt(br.readLine());
    int[] arr=Stream.of(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    int minGreatherThan25=26 ;
    int maxGreaterThan25=26 ;
    int countUpto25=0 ;
    int countGreatherThan25=0 ;
    for(int num : arr){
      if(num<=25){
        countUpto25++;
      }
      if(num>25){
        countGreatherThan25++;
        minGreatherThan25=Math.min(minGreatherThan25,num);
        maxGreaterThan25=Math.max(maxGreaterThan25,num);
      }
    }
    if(countUpto25==k){
      bw.write("0");
    }
    else {
      int ans=maxGreaterThan25-minGreatherThan25+1 ;
      bw.write(ans+"");
    }
    bw.write("\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null) then (     var inputFile : OclFile ; inputFile := OclFile("/Users/vipinjain/self/cp/input.txt") ;
     var outputFile : OclFile ; outputFile := OclFile("/Users/vipinjain/self/cp/output.txt") ;
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputFile)) ; 
     bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputFile)) ) else skip ; 
     var tests : int ;
    tests := 1 ; 
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation getNumberOfDays( month : int) : int
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (month) ; 
    if _switchval = 1 or _switchval = 3 or _switchval = 5 or _switchval = 7 or _switchval = 8 then
   if _switchval = 10 then
   if _switchval = 12 then
    return 31 
   else skip ;
       if _switchval = 2 then
     return 28 
   else skip ;
       if true then
     return 30 
   else skip ;
 )
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var k : int ; k := (br.readLine())->toInteger() ;
     var arr : Sequence(int) ; arr := Sequence{br.readLine()->split(" ")}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var minGreatherThan25 : int ; minGreatherThan25 := 26 ;
    var maxGreaterThan25 : int ; maxGreaterThan25 := 26 ;
    var countUpto25 : int ; countUpto25 := 0 ;
    var countGreatherThan25 : int ; countGreatherThan25 := 0 ;
    for (num : arr) do ( (     if (num <= 25) then (     countUpto25 := countUpto25 + 1 ) else skip ; 
     if (num > 25) then (     countGreatherThan25 := countGreatherThan25 + 1 ; 
     minGreatherThan25 := Set{minGreatherThan25, num}->min() ; 
     maxGreaterThan25 := Set{maxGreaterThan25, num}->max() ) else skip )  ) ; 
    if (countUpto25 = k) then (     skip ) else (     var ans : int ; ans := maxGreaterThan25 - minGreatherThan25 + 1 ;
     skip ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNextInt()){
      int n=in.nextInt();
      int m=in.nextInt();
      long s=0 ;
      for(int i=1 ; i<=n ; i++){
        String a=""+i ;
        String b[]=a.split("");
        int c=a.length();
        String q="" ;
        for(int j=0 ; j<c ; j++){
          q=b[j]+q ;
        }
        q=i+q ;
        s=(s+Long.parseLong(q))% m ;
      }
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNextInt()) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var s : long ; s := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var a : String ; a := "" + i ;
     var b : Sequence(String) ; b := a->split("") ;
    var c : int ; c := a->size() ;
    var q : String ; q := "" ;
        var j : int ; j := 0 ; while j < c do ( (     q := b[j+1] + q )  ;     j := j + 1 ) ; 
    q := i + q ; 
    s := (s + (q)->toLong()) mod m ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.*;
public class App {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws Exception {
    if(System.getProperty("ONLINE_JUDGE")==null){
      File inputFile=new File("/Users/vipinjain/self/cp/input.txt");
      File outputFile=new File("/Users/vipinjain/self/cp/output.txt");
      br=new BufferedReader(new FileReader(inputFile));
      bw=new BufferedWriter(new FileWriter(outputFile));
    }
    int tests ;
    tests=1 ;
    while(tests-->0){
      solve();
    }
    bw.flush();
    bw.close();
    br.close();
  }
  static int getNumberOfDays(int month){
    switch(month){
      case 1 : case 3 : case 5 : case 7 : case 8 : case 10 : case 12 : return 31 ;
      case 2 : return 28 ;
      default : return 30 ;
    }
  }
  static void solve()throws Exception {
    int k=Integer.parseInt(br.readLine());
    int[] arr=Stream.of(br.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    int minGreatherThan25=26 ;
    int maxGreaterThan25=26 ;
    int countUpto25=0 ;
    int countGreatherThan25=0 ;
    for(int num : arr){
      if(num<=25){
        countUpto25++;
      }
      if(num>25){
        countGreatherThan25++;
        minGreatherThan25=Math.min(minGreatherThan25,num);
        maxGreaterThan25=Math.max(maxGreaterThan25,num);
      }
    }
    if(countUpto25==k){
      bw.write("0");
    }
    else {
      int ans=k-countUpto25+(maxGreaterThan25-minGreatherThan25+1-countGreatherThan25);
      bw.write(ans+"");
    }
    bw.write("\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null) then (     var inputFile : OclFile ; inputFile := OclFile("/Users/vipinjain/self/cp/input.txt") ;
     var outputFile : OclFile ; outputFile := OclFile("/Users/vipinjain/self/cp/output.txt") ;
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputFile)) ; 
     bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputFile)) ) else skip ; 
     var tests : int ;
    tests := 1 ; 
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation getNumberOfDays( month : int) : int
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (month) ; 
    if _switchval = 1 or _switchval = 3 or _switchval = 5 or _switchval = 7 or _switchval = 8 then
   if _switchval = 10 then
   if _switchval = 12 then
    return 31 
   else skip ;
       if _switchval = 2 then
     return 28 
   else skip ;
       if true then
     return 30 
   else skip ;
 )
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var k : int ; k := (br.readLine())->toInteger() ;
     var arr : Sequence(int) ; arr := Sequence{br.readLine()->split(" ")}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var minGreatherThan25 : int ; minGreatherThan25 := 26 ;
    var maxGreaterThan25 : int ; maxGreaterThan25 := 26 ;
    var countUpto25 : int ; countUpto25 := 0 ;
    var countGreatherThan25 : int ; countGreatherThan25 := 0 ;
    for (num : arr) do ( (     if (num <= 25) then (     countUpto25 := countUpto25 + 1 ) else skip ; 
     if (num > 25) then (     countGreatherThan25 := countGreatherThan25 + 1 ; 
     minGreatherThan25 := Set{minGreatherThan25, num}->min() ; 
     maxGreaterThan25 := Set{maxGreaterThan25, num}->max() ) else skip )  ) ; 
    if (countUpto25 = k) then (     skip ) else (     var ans : int ; ans := k - countUpto25 + (maxGreaterThan25 - minGreatherThan25 + 1 - countGreatherThan25) ;
     skip ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    boolean flag=false ;
    int max=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      int val=in.nextInt();
      if(val>=25){
        flag=true ;
      }
      max=Math.max(val,max);
    }
    if(! flag){
      pw.println(0);
    }
    else {
      pw.println(max-25);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var flag : boolean ; flag := false ;
    var max : int ; max := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     var val : int ; val := in.getCurrent()->toInteger() ;
     if (val >= 25) then (     flag := true ) else skip ; 
     max := Set{val, max}->max() )  ;     i := i + 1 ) ; 
    if (not(flag)) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class pair {
    int first,second ;
    public pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static int findPowerOfP(int N,int p){
    int count=0 ;
    int r=p ;
    while(r<=N){
      count+=(N/r);
      r=r*p ;
    }
    return count ;
  }
  static Vector<pair>primeFactorsofB(int B){
    Vector<pair>ans=new Vector<pair>();
    for(int i=2 ; B!=1 ; i++){
      if(B % i==0){
        int count=0 ;
        while(B % i==0){
          B=B/i ;
          count++;
        }
        ans.add(new pair(i,count));
      }
    }
    return ans ;
  }
  static int largestPowerOfB(int N,int B){
    Vector<pair>vec=new Vector<pair>();
    vec=primeFactorsofB(B);
    int ans=Integer.MAX_VALUE ;
    for(int i=0 ; i<vec.size(); i++)ans=Math.min(ans,findPowerOfP(N,vec.get(i).first)/vec.get(i).second);
    return ans ;
  }
  public static void main(String[] args){
    System.out.println(largestPowerOfB(5,2));
    System.out.println(largestPowerOfB(6,9));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class pair {
   attribute first : int;
   static operation newpair( first : int, second : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation findPowerOfP( N : int, p : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var r : int ; r := p ;
     while (r <= N) do (     count := count+((N / r)) ; 
     r := r * p ) ; 
     return count );
  static   operation primeFactorsofB( B : int) : Sequence(pair)
  pre: true
  post: true
  activity: (     var ans : Sequence(pair) ; ans := Sequence{} ;
         var i : int ; i := 2 ; while B /= 1 do ( (     if (B mod i = 0) then (     var count : int ; count := 0 ;
     while (B mod i = 0) do (     B := B / i ; 
     count := count + 1 ) ; 
     ans := ans->including(pair.newpair(i, count)) ) else skip )  ;     i := i + 1 ) ; 
     return ans );
  static   operation largestPowerOfB( N : int, B : int) : int
  pre: true
  post: true
  activity: (     var vec : Sequence(pair) ; vec := Sequence{} ;
     vec := primeFactorsofB(B) ; 
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i < vec->size() do (     ans := Set{ans, findPowerOfP(N, vec->at(i+1)->at("first")) / vec->at(i+1)->at("second")}->min() ;  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(largestPowerOfB(5, 2)) ; 
     OclFile["System.out"].println(largestPowerOfB(6, 9)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Set ;
public class Q1 {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int numTests=s.nextInt();
    for(int test=0 ; test<numTests ; test++){
      System.out.println("Case #"+(test+1)+": "+getResult(s));
    }
  }
  private static String getResult(Scanner s){
    int numNodes=s.nextInt();
    List<GraphNode>nodes=new ArrayList<GraphNode>(numNodes);
    for(int i=0 ; i<numNodes ; i++){
      nodes.add(new GraphNode());
    }
    for(int i=0 ; i<numNodes ; i++){
      int numChildren=s.nextInt();
      for(int j=0 ; j<numChildren ; j++){
        int child=s.nextInt();
        nodes.get(child-1).childNodes.add(nodes.get(i));
      }
    }
    for(GraphNode node : nodes){
      if(node.childNodes.size()>1 && node.hasDiamond()){
        return "Yes" ;
      }
    }
    return "No" ;
  }
  public static class GraphNode {
    public List<GraphNode>childNodes=new LinkedList<GraphNode>();
    public boolean hasDiamond(){
      List<GraphNode>foundSoFar=new LinkedList<GraphNode>();
      Set<GraphNode>fastLookup=new HashSet<GraphNode>();
      foundSoFar.add(this);
      fastLookup.add(this);
      while(foundSoFar.size()>0){
        GraphNode node=foundSoFar.remove(0);
        for(GraphNode child : node.childNodes){
          if(fastLookup.contains(child))return true ;
          foundSoFar.add(child);
          fastLookup.add(child);
        }
      }
      return false ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Q1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numTests : int ; numTests := s.getCurrent()->toInteger() ;
         var test : int ; test := 0 ; while test < numTests do ( (     OclFile["System.out"].println("Case #" + (test + 1) + ": " + getResult(s)) )  ;     test := test + 1 ) );
  static   operation getResult( s : OclFile) : String
  pre: true
  post: true
  activity: (     var numNodes : int ; numNodes := s.getCurrent()->toInteger() ;
     var nodes : Sequence(GraphNode) ; nodes := Sequence{} ;
        var i : int ; i := 0 ; while i < numNodes do ( (     nodes := nodes->including(GraphNode.newGraphNode()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < numNodes do ( (     var numChildren : int ; numChildren := s.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < numChildren do ( (     var child : int ; child := s.getCurrent()->toInteger() ;
     nodes->at(child - 1+1).childNodes->excludes(nodes->at(i+1)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    for (node : nodes) do ( (     if (node.childNodes->size() > 1 & node.hasDiamond()) then (     return "Yes" ) else skip )  ) ; 
    return "No" 
 );
  static class GraphNode {
   attribute childNodes : Sequence(GraphNode) := Sequence{};
   operation hasDiamond() : boolean
  pre: true
  post: true
  activity: (     var foundSoFar : Sequence(GraphNode) ; foundSoFar := Sequence{} ;
     var fastLookup : Set(GraphNode) ; fastLookup := Set{} ;
    foundSoFar := foundSoFar->including(self) ; 
    fastLookup := fastLookup->including(self) ; 
    while (foundSoFar->size() > 0) do (     var node : GraphNode ; node := foundSoFar->at(0+1) ;
     for (child : node.childNodes) do ( (     if (fastLookup->includes(child)) then     return true else skip ; 
     foundSoFar := foundSoFar->including(child) ; 
     fastLookup := fastLookup->including(child) )  ) ) ; 
    return false 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static char largest_alphabet(String a,int n){
    char max='A' ;
    for(int i=0 ; i<n ; i++)if(a.charAt(i)>max)max=a.charAt(i);
    return max ;
  }
  static char smallest_alphabet(String a,int n){
    char min='z' ;
    for(int i=0 ; i<n-1 ; i++)if(a.charAt(i)<min)min=a.charAt(i);
    return min ;
  }
  public static void main(String args[]){
    String a="GeEksforGeeks" ;
    int size=a.length();
    System.out.print("Largest and smallest alphabet is : ");
    System.out.print(largest_alphabet(a,size)+" and ");
    System.out.println(smallest_alphabet(a,size));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation largest_alphabet( a : String, n : int) : String
  pre: true
  post: true
  activity: (     var max : String ; max := 'A' ;
         var i : int ; i := 0 ; while i < n do (     if (a->at(i+1) > max) then     max := a->at(i+1) ; else skip ;  ;     i := i + 1 ) ; 
     return max );
  static   operation smallest_alphabet( a : String, n : int) : String
  pre: true
  post: true
  activity: (     var min : String ; min := 'z' ;
         var i : int ; i := 0 ; while i < n - 1 do (     if (a->at(i+1) < min) then     min := a->at(i+1) ; else skip ;  ;     i := i + 1 ) ; 
     return min );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ; a := "GeEksforGeeks" ;
     var size : int ; size := a->size() ;
    OclFile["System.out"].print("Largest and smallest alphabet is : ") ; 
    OclFile["System.out"].print(largest_alphabet(a, size) + " and ") ; 
    OclFile["System.out"].println(smallest_alphabet(a, size)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _1118A_WaterBuying {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=input.nextInt();
    while(test-->0){
      long n=input.nextLong();
      long one=input.nextLong();
      long two=input.nextLong();
      if(one*2>two){
        long bySecond=n/2 ;
        long byFirst=n % 2 ;
        System.out.println((bySecond*two)+(byFirst*one));
      }
      else {
        System.out.println(one*n);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1118A_WaterBuying {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := input.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : long ; n := input.getCurrent()->toLong() ;
     var one : long ; one := input.getCurrent()->toLong() ;
     var two : long ; two := input.getCurrent()->toLong() ;
     if (one * 2 > two) then (     var bySecond : long ; bySecond := n / 2 ;
     var byFirst : long ; byFirst := n mod 2 ;
     OclFile["System.out"].println((bySecond * two) + (byFirst * one)) ) else (     OclFile["System.out"].println(one * n) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long q=sc.nextLong();
    while(q>0){
      long n=sc.nextLong();
      long a=sc.nextLong();
      long b=sc.nextLong();
      long x=0 ;
      if(n % 2==1){
        x=a ;
        n--;
      }
      long k=n/2 ;
      x+=Math.min(a*2,b)*k ;
      System.out.println(x);
      q--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : long ; q := sc.getCurrent()->toLong() ;
     while (q > 0) do (     var n : long ; n := sc.getCurrent()->toLong() ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var x : long ; x := 0 ;
    if (n mod 2 = 1) then (     x := a ; 
     n := n - 1 ) else skip ; 
    var k : long ; k := n / 2 ;
    x := x+(Set{a * 2, b}->min() * k) ; 
    OclFile["System.out"].println(x) ; 
    q := q - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int q=input.nextInt();
    for(; q>0 ; q--){
      long n=input.nextLong();
      long a=input.nextLong();
      long b=input.nextLong();
      if(2*a<b)System.out.println(a*n);
      else System.out.println((n/2)*b+(n % 2)*a);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := input.getCurrent()->toInteger() ;
       while q > 0 do ( (     var n : long ; n := input.getCurrent()->toLong() ;
     var a : long ; a := input.getCurrent()->toLong() ;
     var b : long ; b := input.getCurrent()->toLong() ;
     if (2 * a < b) then     OclFile["System.out"].println(a * n) ; else     OclFile["System.out"].println((n / 2) * b + (n mod 2) * a) ; )  ;     q := q - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int MAX=100005 ;
  static final int MOD=1000000007 ;
  static int[][][] dp=new int[MAX][101][2];
  static int countNum(int idx,int sum,int tight,Vector<Integer>num,int len,int k){
    if(len==idx){
      if(sum==0)return 1 ;
      else return 0 ;
    }
    if(dp[idx][sum][tight]!=-1)return dp[idx][sum][tight];
    int res=0,limit ;
    if(tight==0){
      limit=num.get(idx);
    }
    else {
      limit=9 ;
    }
    for(int i=0 ; i<=limit ; i++){
      int new_tight=tight ;
      if(tight==0 && i<limit)new_tight=1 ;
      res+=countNum(idx+1,(sum+i)% k,new_tight,num,len,k);
      res %=MOD ;
    }
    if(res<0)res+=MOD ;
    return dp[idx][sum][tight]=res ;
  }
  static Vector<Integer>process(String s){
    Vector<Integer>num=new Vector<Integer>();
    for(int i=0 ; i<s.length(); i++){
      num.add(s.charAt(i)-'0');
    }
    return num ;
  }
  public static void main(String[] args){
    String n="98765432109876543210" ;
    int len=n.length();
    int k=58 ;
    for(int i=0 ; i<MAX ; i++){
      for(int j=0 ; j<101 ; j++){
        for(int l=0 ; l<2 ; l++)dp[i][j][l]=-1 ;
      }
    }
    Vector<Integer>num=process(n);
    System.out.print(countNum(0,0,0,num,len,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX : int := 100005;
  static    attribute MOD : int := 1000000007;
  static   attribute dp : Sequence(Sequence(Sequence(int))) := Integer.subrange(1,MAX)->collect(Integer.subrange(1,101)->collect(Integer.subrange(1,2)->collect(0)));
  static   operation countNum( idx : int, sum : int, tight : int, num : Sequence(int), len : int, k : int) : int
  pre: true
  post: true
  activity: (     if (len = idx) then (     if (sum = 0) then     return 1 else     return 0 ) else skip ; 
     if (dp[idx+1][sum+1][tight+1] /= -1) then     return dp[idx+1][sum+1][tight+1] else skip ; 
    var res : int ; res := 0 ;
    var limit : int ;
    if (tight = 0) then (     limit := num->at(idx+1) ) else (     limit := 9 ) ;  
        var i : int ; i := 0 ; while i <= limit do ( (     var new_tight : int ; new_tight := tight ;
     if (tight = 0 & i < limit) then     new_tight := 1 ; else skip ; 
     res := res+(countNum(idx + 1, (sum + i) mod k, new_tight, num, len, k)) ; 
     res := res mod MOD )  ;     i := i + 1 ) ; 
    if (res < 0) then     res := res+(MOD) ; else skip ; 
    return dp[idx+1][sum+1][tight+1] 
 );
  static   operation process( s : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var num : Sequence(int) ; num := Sequence{} ;
         var i : int ; i := 0 ; while i < s->size() do ( (     num := num->including(s->at(i+1) - ('0')->char2byte()) )  ;     i := i + 1 ) ; 
     return num );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : String ; n := "98765432109876543210" ;
     var len : int ; len := n->size() ;
    var k : int ; k := 58 ;
        var i : int ; i := 0 ; while i < MAX do ( (         var j : int ; j := 0 ; while j < 101 do ( (         var l : int ; l := 0 ; while l < 2 do (     dp[i+1][j+1][l+1] := -1 ;  ;     l := l + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var num : Sequence(int) ; num := process(n) ;
    OclFile["System.out"].print(countNum(0, 0, 0, num, len, k)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int Segment(int x[],int l[],int n){
    if(n==1)return 1 ;
    int ans=2 ;
    for(int i=1 ; i<n-1 ; i++){
      if(x[i]-l[i]>x[i-1])ans++;
      else if(x[i]+l[i]<x[i+1]){
        x[i]=x[i]+l[i];
        ans++;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int x[]={
      1,3,4,5,8 },l[]={
        10,1,2,2,5 };
        int n=x.length ;
        System.out.println(Segment(x,l,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Segment( x : Sequence(int), l : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 1 else skip ; 
     var ans : int ; ans := 2 ;
         var i : int ; i := 1 ; while i < n - 1 do ( (     if (x[i+1] - l[i+1] > x[i - 1+1]) then     ans := ans + 1 ; else     if (x[i+1] + l[i+1] < x[i + 1+1]) then (     x[i+1] := x[i+1] + l[i+1] ; 
     ans := ans + 1 ) else skip ; )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : Sequence(int) ; x := Sequence{1,3,4,5,8} ;
    var l : Sequence(void) ; l := Sequence{10,1,2,2,5} ;
     var n : int ; n := x->size() ;
     OclFile["System.out"].println(Segment(x, l, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B771 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int K=in.nextInt();
    String[] names=new String[N];
    for(int n=0 ; n<N ; n++){
      names[n]=(char)('A'+n/26)+""+(char)('a'+n % 26);
    }
    for(int end=K-1 ; end<N ; end++){
      boolean effective="YES".equals(in.next());
      if(! effective){
        names[end]=names[end-K+1];
      }
    }
    StringBuilder out=new StringBuilder();
    for(String name : names){
      out.append(name).append(' ');
    }
    System.out.println(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B771 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    var names : Sequence(String) ; names := Integer.subrange(1,N)->collect(null) ;
        var n : int ; n := 0 ; while n < N do ( (     names[n+1] := ('A' + n / 26)->oclAsType(String) + "" + ('a' + n mod 26)->oclAsType(String) )  ;     n := n + 1 ) ; 
        var end : int ; end := K - 1 ; while end < N do ( (     var effective : boolean ; effective := "YES" = in.getCurrent() ;
     if (not(effective)) then (     names[end+1] := names[end - K + 1+1] ) else skip )  ;     end := end + 1 ) ; 
    var out : String ; out := StringLib.newString() ;
    for (name : names) do ( (     out := out + StringLib.newString(name) + StringLib.newString(' ') )  ) ; 
    OclFile["System.out"].println(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findNumber(int n,int m){
    int num=(m-1)*9+n ;
    return num ;
  }
  public static void main(String args[]){
    int n=2,m=5 ;
    System.out.print(findNumber(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNumber( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := (m - 1) * 9 + n ;
     return num );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
    var m : int ; m := 5 ;
     OclFile["System.out"].print(findNumber(n, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void oddIntegers(int n,int k){
    if(n % 2!=k % 2){
      System.out.println("-1");
      return ;
    }
    int sum=0 ;
    int i=1 ;
    int j=1 ;
    while(j<k){
      sum=sum+i ;
      System.out.print(i+" ");
      i=i+2 ;
      j++;
    }
    int finalOdd=n-sum ;
    System.out.println(finalOdd);
  }
  public static void main(String[] args){
    int n=10 ;
    int k=2 ;
    oddIntegers(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation oddIntegers( n : int, k : int) : void
  pre: true
  post: true
  activity: (     if (n mod 2 /= k mod 2) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
     var sum : int ; sum := 0 ;
    var i : int ; i := 1 ;
    var j : int ; j := 1 ;
    while (j < k) do (     sum := sum + i ; 
     OclFile["System.out"].print(i + " ") ; 
     i := i + 2 ; 
     j := j + 1 ) ; 
    var finalOdd : int ; finalOdd := n - sum ;
    OclFile["System.out"].println(finalOdd) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     var k : int ; k := 2 ;
     execute oddIntegers(n, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    if(((B+A)% 3==0)||((A % 3)==0)||((B % 3)==0)){
      System.out.println("Possible");
    }
    else {
      System.out.println("Impossible");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
     if (((B + A) mod 3 = 0) or ((A mod 3) = 0) or ((B mod 3) = 0)) then (     OclFile["System.out"].println("Possible") ) else (     OclFile["System.out"].println("Impossible") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String in=br.readLine();
      String chr[]=in.split(" ");
      int a=Integer.parseInt(chr[0]);
      int b=Integer.parseInt(chr[1]);
      System.out.println(a % 3==0 || b % 3==0 ||(a+b)% 3==0 ? "Possible" : "Impossible");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var in : String ; in := br.readLine() ;
     var chr : Sequence(String) ; chr := in->split(" ") ;
    var a : int ; a := (chr[0+1])->toInteger() ;
    var b : int ; b := (chr[1+1])->toInteger() ;
    OclFile["System.out"].println(if a mod 3 = 0 or b mod 3 = 0 or (a + b) mod 3 = 0 then "Possible" else "Impossible" endif) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Set ;
public final class p075 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p075().run());
  }
  private static final int LIMIT=1500000 ;
  public String run(){
    Set<IntTriple>triples=new HashSet<>();
    for(int s=3 ; s*s<=LIMIT ; s+=2){
      for(int t=s-2 ; t>0 ; t-=2){
        if(Library.gcd(s,t)==1){
          int a=s*t ;
          int b=(s*s-t*t)/2 ;
          int c=(s*s+t*t)/2 ;
          if(a+b+c<=LIMIT)triples.add(new IntTriple(a,b,c));
        }
      }
    }
    byte[] ways=new byte[LIMIT+1];
    for(IntTriple triple : triples){
      int sum=triple.a+triple.b+triple.c ;
      for(int i=sum ; i<ways.length ; i+=sum)ways[i]=(byte)Math.min(ways[i]+1,2);
    }
    int count=0 ;
    for(int x : ways){
      if(x==1)count++;
    }
    return Integer.toString(count);
  }
  private static final class IntTriple {
    public final int a ;
    public final int b ;
    public final int c ;
    public IntTriple(int a,int b,int c){
      this.a=a ;
      this.b=b ;
      this.c=c ;
    }
    public boolean equals(Object obj){
      if(!(obj instanceof IntTriple))return false ;
      else {
        IntTriple other=(IntTriple)obj ;
        return a==other.a && b==other.b && c==other.c ;
      }
    }
    public int hashCode(){
      return a+b+c ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class p075 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p075.newp075().run()) );
  static    attribute LIMIT : int := 1500000;
   operation run() : String
  pre: true
  post: true
  activity: (     var triples : Set(IntTriple) ; triples := Set{} ;
         var s : int ; s := 3 ; while s * s <= LIMIT do ( (         var t : int ; t := s - 2 ; while t > 0 do ( (     if (Library.gcd(s, t) = 1) then (     var a : int ; a := s * t ;
     var b : int ; b := (s * s - t * t) / 2 ;
     var c : int ; c := (s * s + t * t) / 2 ;
     if (a + b + c <= LIMIT) then     triples := triples->including(IntTriple.newIntTriple(a, b, c)) ; else skip ) else skip )  ;     t := t-(2) ) )  ;     s := s+(2) ) ; 
    var ways : Sequence(int) ; ways := Integer.subrange(1,LIMIT + 1)->collect(0) ;
    for (triple : triples) do ( (     var sum : int ; sum := triple.a + triple.b + triple.c ;
         var i : int ; i := sum ; while i < ways->size() do (     ways[i+1] := (Set{ways[i+1] + 1, 2}->min() mod 128) ;  ;     i := i+(sum) ) )  ) ; 
    var count : int ; count := 0 ;
    for (x : ways) do ( (     if (x = 1) then     count := count + 1 ; else skip )  ) ; 
    return ((count) + "") 
 );
  static  class IntTriple {
   attribute a : int;
   attribute b : int;
   attribute c : int;
   static operation newIntTriple( a : int, b : int, c : int) : IntTriple
  pre: true
  post: true
  activity:
  ( var self : IntTriple ;
    self := createIntTriple();
    self.initialise(a, b,c);
    return self );
  operation initialise( a : int, b : int, c : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b ; 
     self.c := c );
   operation equals( obj : OclAny) : boolean
  pre: true
  post: true
  activity: (     if (not((obj->oclIsKindOf(IntTriple)))) then     return false else (     var other : IntTriple ; other := obj->oclAsType(IntTriple) ;
     return a = other.a & b = other.b & c = other.c ) );
   operation hashCode() : int
  pre: true
  post: true
  activity: (     return a + b + c );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
import static java.lang.System.*;
public class Main {
  public static void main(String args[])throws Exception {
    Scanner sc=new Scanner(in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    if((a+b)% 3==0 || a % 3==0 || b % 3==0)out.println("Possible");
    else out.println("Impossible");
  }
}
class Berland {
  char ch ;
  int pos ;
  public Berland(int a,char b){
    ch=b ;
    pos=a ;
  }
}
class ChComparator implements Comparator<Berland>{
  public int compare(Berland f1,Berland f2){
    if(f1.ch==f2.ch)return 0 ;
    if(f1.ch<f2.ch)return-1 ;
    return 1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if ((a + b) mod 3 = 0 or a mod 3 = 0 or b mod 3 = 0) then     out.println("Possible") ; else     out.println("Impossible") ; );
}
class Berland {
   attribute ch : String;
   attribute pos : int;
   static operation newBerland( a : int, b : String) : Berland
  pre: true
  post: true
  activity:
  ( var self : Berland ;
    self := createBerland();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : String) : void
  pre: true  post: true
  activity: (     ch := b ; 
     pos := a );
}
class ChComparator implements Function(<Berland>,(<Berland>,boolean)) {
   operation compare( f1 : Berland, f2 : Berland) : int
  pre: true
  post: true
  activity: (     if (f1.ch = f2.ch) then     return 0 else skip ; 
     if (f1.ch < f2.ch) then     return -1 else skip ; 
     return 1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static Scanner sc ;
  private static Printer pr ;
  private static void solve(){
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(a % 3==0 || b % 3==0 ||(a+b)% 3==0){
      pr.println("Possible");
    }
    else {
      pr.println("Impossible");
    }
  }
  public static void main(String[] args){
    sc=new Scanner(System.in);
    pr=new Printer(System.out);
    solve();
    pr.close();
    sc.close();
  }
  private static class Printer extends PrintWriter {
    Printer(PrintStream out){
      super(out);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile;
  static   attribute pr : Printer;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (a mod 3 = 0 or b mod 3 = 0 or (a + b) mod 3 = 0) then (     pr.println("Possible") ) else (     pr.println("Impossible") ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     pr := Printer.newPrinter(OclFile["System.out"]) ; 
    execute solve() ; 
    pr.close() ; 
    skip ; 
 );
  static class Printer extends OclFile {
   static operation newPrinter( out : OclFile) : Printer
  pre: true
  post: true
  activity:
  ( var self : Printer ;
    self := createPrinter();
    self.initialise(out);
    return self );
  operation initialise( out : OclFile) : void
  pre: true  post: true
  activity: (     execute super(out) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    if(A % 3==0){
      System.out.println("Possible");
    }
    else if(B % 3==0){
      System.out.println("Possible");
    }
    else if((A+B)% 3==0){
      System.out.println("Possible");
    }
    else {
      System.out.println("Impossible");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
     if (A mod 3 = 0) then (     OclFile["System.out"].println("Possible") ) else     if (B mod 3 = 0) then (     OclFile["System.out"].println("Possible") ) else     if ((A + B) mod 3 = 0) then (     OclFile["System.out"].println("Possible") ) else (     OclFile["System.out"].println("Impossible") ) ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p191 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p191().run());
  }
  private static final int NUM_DAYS=30 ;
  private static final int MAX_ABSENT=2 ;
  private static final int MAX_LATE=1 ;
  public String run(){
    long[][][] numPrizeStrings=new long[NUM_DAYS+1][MAX_ABSENT+1][MAX_LATE+1];
    numPrizeStrings[0][0][0]=1 ;
    for(int i=1 ; i<=NUM_DAYS ; i++){
      for(int j=0 ; j<=MAX_ABSENT ; j++){
        for(int k=0 ; k<=MAX_LATE ; k++){
          long sum ;
          if(j==0){
            sum=0 ;
            for(int l=0 ; l<=MAX_ABSENT ; l++)sum+=numPrizeStrings[i-1][l][k];
            if(k>0){
              for(int l=0 ; l<=MAX_ABSENT ; l++)sum+=numPrizeStrings[i-1][l][k-1];
            }
          }
          else sum=numPrizeStrings[i-1][j-1][k];
          numPrizeStrings[i][j][k]=sum ;
        }
      }
    }
    long sum=0 ;
    for(int j=0 ; j<=MAX_ABSENT ; j++){
      for(int k=0 ; k<=MAX_LATE ; k++)sum+=numPrizeStrings[NUM_DAYS][j][k];
    }
    return Long.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
class p191 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p191.newp191().run()) );
  static    attribute NUM_DAYS : int := 30;
  static    attribute MAX_ABSENT : int := 2;
  static    attribute MAX_LATE : int := 1;
   operation run() : String
  pre: true
  post: true
  activity: (     var numPrizeStrings : Sequence(Sequence(Sequence(long))) ; numPrizeStrings := Integer.subrange(1,NUM_DAYS + 1)->collect(Integer.subrange(1,MAX_ABSENT + 1)->collect(Integer.subrange(1,MAX_LATE + 1)->collect(0))) ;
     numPrizeStrings[0+1][0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= NUM_DAYS do ( (         var j : int ; j := 0 ; while j <= MAX_ABSENT do ( (         var k : int ; k := 0 ; while k <= MAX_LATE do ( (     var sum : long ;
     if (j = 0) then (     sum := 0 ; 
         var l : int ; l := 0 ; while l <= MAX_ABSENT do (     sum := sum+(numPrizeStrings[i - 1+1][l+1][k+1]) ;  ;     l := l + 1 ) ; 
     if (k > 0) then (         var l : int ; l := 0 ; while l <= MAX_ABSENT do (     sum := sum+(numPrizeStrings[i - 1+1][l+1][k - 1+1]) ;  ;     l := l + 1 ) ) else skip ) else     sum := numPrizeStrings[i - 1+1][j - 1+1][k+1] ; ;  
     numPrizeStrings[i+1][j+1][k+1] := sum )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var j : int ; j := 0 ; while j <= MAX_ABSENT do ( (         var k : int ; k := 0 ; while k <= MAX_LATE do (     sum := sum+(numPrizeStrings[NUM_DAYS+1][j+1][k+1]) ;  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    return ((sum) + "") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A1008 {
  public static void main(String[] args){
    InputStream inputReader=System.in ;
    OutputStream outputReader=System.out ;
    InputReader in=new InputReader(inputReader);
    PrintWriter out=new PrintWriter(outputReader);
    Algorithm solver=new Algorithm();
    solver.solve(in,out);
    out.close();
  }
}
class Algorithm {
  void solve(InputReader ir,PrintWriter pw){
    int n=ir.nextInt(),answer=1001 ;
    int[] a=new int[n+2];
    for(int i=1 ; i<=n ; i++)a[i]=ir.nextInt();
    for(int i=1 ; i<=n ; i++){
      if(a[i]>=a[i-1] || a[i]>=a[i+1]){
        answer=Math.min(answer,a[i]);
      }
    }
    pw.print(answer);
  }
}
class InputReader {
  private BufferedReader reader ;
  private StringTokenizer tokenizer ;
  InputReader(InputStream stream){
    reader=new BufferedReader(new InputStreamReader(stream),32768);
    tokenizer=null ;
  }
  String next(){
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        tokenizer=new StringTokenizer(reader.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }
  String nextLine(){
    String fullLine=null ;
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        fullLine=reader.readLine();
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
      return fullLine ;
    }
    return fullLine ;
  }
  String[] toArray(){
    return nextLine().split(" ");
  }
  int nextInt(){
    return Integer.parseInt(next());
  }
  double nextDouble(){
    return Double.parseDouble(next());
  }
  long nextLong(){
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1008 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputReader : OclFile ; inputReader := OclFile["System.in"] ;
     var outputReader : OclFile ; outputReader := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputReader) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputReader) ;
    var solver : Algorithm ; solver := Algorithm.newAlgorithm() ;
    solver.solve(in, out) ; 
    skip ; 
 );
}
class Algorithm {
   operation solve( ir : InputReader, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := ir.nextInt() ;
    var answer : int ; answer := 1001 ;
     var a : Sequence(int) ; a := Integer.subrange(1,n + 2)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := ir.nextInt() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (a[i+1] >= a[i - 1+1] or a[i+1] >= a[i + 1+1]) then (     answer := Set{answer, a[i+1]}->min() ) else skip )  ;     i := i + 1 ) ; 
    pw.print(answer) ; 
 );
}
class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var fullLine : String ; fullLine := null ;
     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     fullLine := reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
     return fullLine ) ; 
     return fullLine );
   operation toArray() : Sequence(String)
  pre: true
  post: true
  activity: (     return nextLine()->split(" ") );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String isDivisible(int n){
    int temp=n ;
    while(n>0){
      int k=n % 10 ;
      if(temp % k==0){
        return "YES" ;
      }
      n/=10 ;
    }
    return "NO" ;
  }
  public static void main(String[] args){
    int n=9876543 ;
    System.out.println(isDivisible(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isDivisible( n : int) : String
  pre: true
  post: true
  activity: (     var temp : int ; temp := n ;
     while (n > 0) do (     var k : int ; k := n mod 10 ;
     if (temp mod k = 0) then (     return "YES" ) else skip ; 
     n := n/(10) ) ; 
     return "NO" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9876543 ;
     OclFile["System.out"].println(isDivisible(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class test {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    StringTokenizer st=new StringTokenizer(br.readLine());
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(st.nextToken());
    }
    if(n==1){
      System.out.println(a[0]);
      return ;
    }
    if(n==2){
      System.out.println(Math.min(a[0],a[1]));
      return ;
    }
    int min=Math.min(a[0],a[n-1]);
    int i=n-1 ;
    while(i>=2){
      if(a[i]>a[i-1] && a[i-1]>a[i-2]){
        min=Math.min(min,a[i-1]);
        i--;
      }
      else if(a[i-1]<a[i]){
        min=Math.min(min,a[i-2]);
        i=i-2 ;
      }
      else {
        i--;
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    if (n = 1) then (     OclFile["System.out"].println(a[0+1]) ; 
     return ) else skip ; 
    if (n = 2) then (     OclFile["System.out"].println(Set{a[0+1], a[1+1]}->min()) ; 
     return ) else skip ; 
    var min : int ; min := Set{a[0+1], a[n - 1+1]}->min() ;
    var i : int ; i := n - 1 ;
    while (i >= 2) do (     if (a[i+1] > a[i - 1+1] & a[i - 1+1] > a[i - 2+1]) then (     min := Set{min, a[i - 1+1]}->min() ; 
     i := i - 1 ) else     if (a[i - 1+1] < a[i+1]) then (     min := Set{min, a[i - 2+1]}->min() ; 
     i := i - 2 ) else (     i := i - 1 ) ;  ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int replace(String A,String B){
    int n=A.length(),m=B.length();
    int count=0,i,j ;
    for(i=0 ; i<n ; i++){
      for(j=0 ; j<m ; j++){
        if(i+j>=n)break ;
        else if(A.charAt(i+j)!=B.charAt(j))break ;
      }
      if(j==m){
        count++;
        i+=m-1 ;
      }
    }
    return count ;
  }
  public static void main(String args[]){
    String str1="aaaaaaaa" ;
    String str2="aaa" ;
    System.out.println(replace(str1,str2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation replace( A : String, B : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := A->size() ;
    var m : int ; m := B->size() ;
     var count : int ; count := 0 ;
    var i : int ;
    var j : int ;
         i := 0 ; while i < n do ( (         j := 0 ; while j < m do ( (     if (i + j >= n) then     break else     if (A->at(i + j+1) /= B->at(j+1)) then     break else skip ; )  ;     j := j + 1 ) ; 
     if (j = m) then (     count := count + 1 ; 
     i := i+(m - 1) ) else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "aaaaaaaa" ;
     var str2 : String ; str2 := "aaa" ;
     OclFile["System.out"].println(replace(str1, str2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static int count(String s,char value){
    int cnt=0 ;
    for(int i=0 ; i<s.length(); i++)if(s.charAt(i)==value)cnt++;
    return cnt ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    while(q-->0){
      int n=sc.nextInt();
      int l=sc.nextInt();
      int r=sc.nextInt();
      int k=sc.nextInt();
      int[] lst=new int[n];
      for(int i=0 ; i<n ; i++)lst[i]=sc.nextInt();
      Arrays.sort(lst);
      int cost=0,res=0 ;
      for(int i=0 ; i<n ; i++){
        if(lst[i]>=l && lst[i]<=r && cost+lst[i]<=k){
          cost+=lst[i];
          res++;
        }
        else if(cost>=k)break ;
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation count( s : String, value : String) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < s->size() do (     if (s->at(i+1) = value) then     cnt := cnt + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
         while (q > 0) do (        q := q - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var lst : Sequence(int) ; lst := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     lst[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    lst := lst->sort() ; 
    var cost : int ; cost := 0 ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (lst[i+1] >= l & lst[i+1] <= r & cost + lst[i+1] <= k) then (     cost := cost+(lst[i+1]) ; 
     res := res + 1 ) else     if (cost >= k) then     break else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class divan {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int l=sc.nextInt();
      ;
      int r=sc.nextInt();
      int k=sc.nextInt();
      int arr[]=new int[n];
      for(int i=0 ; i<arr.length ; i++)arr[i]=sc.nextInt();
      Arrays.sort(arr);
      int s=0,c=0,flag=0 ;
      for(int i=0 ; i<n ; i++){
        if(arr[i]>=l && arr[i]<=r){
          s+=arr[i];
          if(s<=k){
            c++;
          }
          else {
            break ;
          }
        }
      }
      System.out.println(c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class divan {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var s : int ; s := 0 ;
    var c : int ; c := 0 ;
    var flag : int ; flag := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] >= l & arr[i+1] <= r) then (     s := s+(arr[i+1]) ; 
     if (s <= k) then (     c := c + 1 ) else (     break ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  int N,M ;
  int INF=Integer.MAX_VALUE/2 ;
  int[][] graph,memo ;
  void run(){
    N=sc.nextInt();
    M=sc.nextInt();
    graph=new int[N][N];
    memo=new int[N][1<<N];
    for(int i=0 ; i<N ; i++){
      Arrays.fill(graph[i],INF);
      Arrays.fill(memo[i],-1);
    }
    for(int i=0 ; i<M ; i++){
      int s=sc.nextInt();
      int t=sc.nextInt();
      int cost=sc.nextInt();
      graph[s][t]=cost ;
    }
    int res=tsp(0,1);
    System.out.println(res==INF ?-1 : res);
  }
  int tsp(int v,int mask){
    if(memo[v][mask]!=-1)return memo[v][mask];
    if(mask==(1<<N)-1)return graph[v][0];
    int res=INF ;
    for(int i=0 ; i<N ; i++){
      if((mask &(1<<i))!=0)continue ;
      res=Math.min(res,graph[v][i]+tsp(i,mask |(1<<i)));
    }
    return memo[v][mask]=res ;
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute N : int;
   attribute INF : int := 2147483647 / 2;
   attribute graph : Sequence(Sequence(int));
   operation run() : void
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     M := sc.getCurrent()->toInteger() ; 
    graph := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ; 
    memo := Integer.subrange(1,N)->collect(Integer.subrange(1,(1*(2->pow(N)))->oclAsType(long))->collect(0)) ; 
        var i : int ; i := 0 ; while i < N do ( (     graph[i+1] := graph[i+1]->collect(INF) ; 
     memo[i+1] := memo[i+1]->collect(-1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     var cost : int ; cost := sc.getCurrent()->toInteger() ;
     graph[s+1][t+1] := cost )  ;     i := i + 1 ) ; 
    var res : int ; res := tsp(0, 1) ;
    OclFile["System.out"].println(if res = INF then -1 else res endif) ; 
 );
   operation tsp( v : int, mask : int) : int
  pre: true
  post: true
  activity: (     if (memo[v+1][mask+1] /= -1) then     return memo[v+1][mask+1] else skip ; 
     if (mask = ((1*(2->pow(N)))->oclAsType(long)) - 1) then     return graph[v+1][0+1] else skip ; 
    var res : int ; res := INF ;
        var i : int ; i := 0 ; while i < N do ( (     if ((mask & ((1*(2->pow(i)))->oclAsType(long))) /= 0) then     continue else skip ; 
     res := Set{res, graph[v+1][i+1] + tsp(i, mask or ((1*(2->pow(i)))->oclAsType(long)))}->min() )  ;     i := i + 1 ) ; 
    return memo[v+1][mask+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Test {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    ArrayList<Character>arr=new ArrayList<>();
    for(int i=0 ; i<s.length(); i++){
      arr.add(s.charAt(i));
    }
    if(arr.get(0)!='a')System.out.println("NO");
    else if(arr.lastIndexOf('a')>arr.indexOf('b')|| arr.lastIndexOf('a')>arr.indexOf('c')|| arr.lastIndexOf('b')>arr.indexOf('c')){
      System.out.println("NO");
    }
    else {
      int numa=0 ;
      int numb=0 ;
      int numc=0 ;
      for(int i=0 ; i<s.length(); i++){
        if(s.charAt(i)=='a')numa++;
        else if(s.charAt(i)=='b')numb++;
        else if(s.charAt(i)=='c')numc++;
      }
      if(numa==numc || numb==numc ||(numa==numc && numb==numc))System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
    var arr : Sequence(String) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < s->size() do ( (     arr := arr->including(s->at(i+1)) )  ;     i := i + 1 ) ; 
    if (arr->at(0+1) /= 'a') then     OclFile["System.out"].println("NO") else     if (arr->lastIndexOf('a')-1 > arr->indexOf('b')-1 or arr->lastIndexOf('a')-1 > arr->indexOf('c')-1 or arr->lastIndexOf('b')-1 > arr->indexOf('c')-1) then (     OclFile["System.out"].println("NO") ) else (     var numa : int ; numa := 0 ;
     var numb : int ; numb := 0 ;
    var numc : int ; numc := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'a') then     numa := numa + 1 ; else     if (s->at(i+1) = 'b') then     numb := numb + 1 else     if (s->at(i+1) = 'c') then     numc := numc + 1 ; else skip ; ;  )  ;     i := i + 1 ) ; 
    if (numa = numc or numb = numc or (numa = numc & numb = numc)) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  static final int INF=Integer.MAX_VALUE/2 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line=br.readLine();
    int v=Integer.parseInt(line.substring(0,line.indexOf(" ")));
    int e=Integer.parseInt(line.substring(line.indexOf(' ')+1));
    int[][] d=new int[v][v];
    for(int i=0 ; i<v ; i++){
      Arrays.fill(d[i],-1);
    }
    for(int i=0 ; i<e ; i++){
      line=br.readLine();
      String[] str=line.split(" ");
      int si=Integer.parseInt(str[0]);
      int ti=Integer.parseInt(str[1]);
      int di=Integer.parseInt(str[2]);
      d[si][ti]=di ;
    }
    int[][] dp=new int[1<<v][v];
    for(int i=0 ; i<1<<v ; i++)Arrays.fill(dp[i],INF);
    dp[(1<<v)-1][0]=0 ;
    for(int i=(1<<v)-2 ; i>=0 ; i--){
      for(int j=0 ; j<v ; j++){
        for(int k=0 ; k<v ; k++){
          if((i>>k & 1)==0 && d[j][k]!=-1)dp[i][j]=Math.min(dp[i][j],dp[i | 1<<k][k]+d[j][k]);
        }
      }
    }
    System.out.println(dp[0][0]>=INF ?-1 : dp[0][0]);
    br.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := 2147483647 / 2;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := br.readLine() ;
    var v : int ; v := (line.subrange(0+1,line->indexOf(" ")-1))->toInteger() ;
    var e : int ; e := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1))->toInteger() ;
    var d : Sequence(Sequence(int)) ; d := Integer.subrange(1,v)->collect(Integer.subrange(1,v)->collect(0)) ;
        var i : int ; i := 0 ; while i < v do ( (     d[i+1] := d[i+1]->collect(-1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < e do ( (     line := br.readLine() ; 
     var str : Sequence(String) ; str := line->split(" ") ;
    var si : int ; si := (str[0+1])->toInteger() ;
    var ti : int ; ti := (str[1+1])->toInteger() ;
    var di : int ; di := (str[2+1])->toInteger() ;
    d[si+1][ti+1] := di ; 
 )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,(1*(2->pow(v)))->oclAsType(long))->collect(Integer.subrange(1,v)->collect(0)) ;
        var i : int ; i := 0 ; while i < (1*(2->pow(v)))->oclAsType(long) do (     dp[i+1] := dp[i+1]->collect(INF) ;  ;     i := i + 1 ) ; 
    dp[((1*(2->pow(v)))->oclAsType(long)) - 1+1][0+1] := 0 ; 
        var i : int ; i := ((1*(2->pow(v)))->oclAsType(long)) - 2 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < v do ( (         var k : int ; k := 0 ; while k < v do ( (     if ((MathLib.bitwiseAnd((i/(2->pow(k)))->oclAsType(long),1)) = 0 & d[j+1][k+1] /= -1) then     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[MathLib.bitwiseOr(i,(1*(2->pow(k)))->oclAsType(long))+1][k+1] + d[j+1][k+1]}->min() ; else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(if dp[0+1][0+1] >= INF then -1 else dp[0+1][0+1] endif) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int N,M ;
  int INF=Integer.MAX_VALUE/2 ;
  int[][] graph ;
  Map<Integer,Map<Integer,Integer>>dp=new HashMap<>();
  void run(){
    N=sc.nextInt();
    M=sc.nextInt();
    graph=new int[N][N];
    for(int i=0 ; i<N ; i++){
      Arrays.fill(graph[i],INF);
    }
    for(int i=0 ; i<M ; i++){
      int s=sc.nextInt();
      int t=sc.nextInt();
      int cost=sc.nextInt();
      graph[s][t]=cost ;
    }
    int res=tsp(1,0);
    System.out.println(res==INF ?-1 : res);
  }
  int tsp(int mask,int v){
    if(dp.containsKey(mask)&& dp.get(mask).containsKey(v))return dp.get(mask).get(v);
    if(mask==(1<<N)-1)return graph[v][0];
    int res=INF ;
    for(int i=0 ; i<N ; i++){
      if((mask &(1<<i))!=0)continue ;
      int tmp=graph[v][i]+tsp(mask |(1<<i),i);
      if(tmp<res)res=tmp ;
    }
    if(! dp.containsKey(mask)){
      dp.put(mask,new HashMap<>());
    }
    dp.get(mask).put(v,res);
    return res ;
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute N : int;
   attribute INF : int := 2147483647 / 2;
   attribute graph : Sequence(Sequence(int));
   attribute dp : Map(int,Map(int,int)) := Map{};
   operation run() : void
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     M := sc.getCurrent()->toInteger() ; 
    graph := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ; 
        var i : int ; i := 0 ; while i < N do ( (     graph[i+1] := graph[i+1]->collect(INF) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     var cost : int ; cost := sc.getCurrent()->toInteger() ;
     graph[s+1][t+1] := cost )  ;     i := i + 1 ) ; 
    var res : int ; res := tsp(1, 0) ;
    OclFile["System.out"].println(if res = INF then -1 else res endif) ; 
 );
   operation tsp( mask : int, v : int) : int
  pre: true
  post: true
  activity: (     if (dp->keys()->includes(mask) & dp->at(mask).containsKey(v)) then     return dp->at(mask)->at(v+1) else skip ; 
     if (mask = ((1*(2->pow(N)))->oclAsType(long)) - 1) then     return graph[v+1][0+1] else skip ; 
    var res : int ; res := INF ;
        var i : int ; i := 0 ; while i < N do ( (     if ((mask & ((1*(2->pow(i)))->oclAsType(long))) /= 0) then     continue else skip ; 
     var tmp : int ; tmp := graph[v+1][i+1] + tsp(mask or ((1*(2->pow(i)))->oclAsType(long)), i) ;
     if (tmp < res) then     res := tmp ; else skip )  ;     i := i + 1 ) ; 
    if (not(dp->keys()->includes(mask))) then (     dp := dp->union(Map{mask |-> Map{}}) ) else skip ; 
    dp := dp->at(mask)->union(Map{v |-> res}) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  int N,M ;
  int INF=Integer.MAX_VALUE/2 ;
  int[][] graph,memo ;
  void run(){
    N=sc.nextInt();
    M=sc.nextInt();
    graph=new int[N][N];
    memo=new int[N][1<<N];
    for(int i=0 ; i<N ; i++){
      Arrays.fill(graph[i],INF);
      Arrays.fill(memo[i],-1);
    }
    for(int i=0 ; i<M ; i++){
      int s=sc.nextInt();
      int t=sc.nextInt();
      int cost=sc.nextInt();
      graph[s][t]=cost ;
    }
    int res=tsp(0,1);
    System.out.println(res==INF ?-1 : res);
  }
  int tsp(int v,int mask){
    if(memo[v][mask]!=-1)return memo[v][mask];
    if(mask==(1<<N)-1)return graph[v][0];
    int res=INF ;
    for(int i=0 ; i<N ; i++){
      if((mask &(1<<i))!=0)continue ;
      res=Math.min(res,graph[v][i]+tsp(i,mask |(1<<i)));
    }
    return memo[v][mask]=res ;
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute N : int;
   attribute INF : int := 2147483647 / 2;
   attribute graph : Sequence(Sequence(int));
   operation run() : void
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     M := sc.getCurrent()->toInteger() ; 
    graph := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ; 
    memo := Integer.subrange(1,N)->collect(Integer.subrange(1,(1*(2->pow(N)))->oclAsType(long))->collect(0)) ; 
        var i : int ; i := 0 ; while i < N do ( (     graph[i+1] := graph[i+1]->collect(INF) ; 
     memo[i+1] := memo[i+1]->collect(-1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     var cost : int ; cost := sc.getCurrent()->toInteger() ;
     graph[s+1][t+1] := cost )  ;     i := i + 1 ) ; 
    var res : int ; res := tsp(0, 1) ;
    OclFile["System.out"].println(if res = INF then -1 else res endif) ; 
 );
   operation tsp( v : int, mask : int) : int
  pre: true
  post: true
  activity: (     if (memo[v+1][mask+1] /= -1) then     return memo[v+1][mask+1] else skip ; 
     if (mask = ((1*(2->pow(N)))->oclAsType(long)) - 1) then     return graph[v+1][0+1] else skip ; 
    var res : int ; res := INF ;
        var i : int ; i := 0 ; while i < N do ( (     if ((mask & ((1*(2->pow(i)))->oclAsType(long))) /= 0) then     continue else skip ; 
     res := Set{res, graph[v+1][i+1] + tsp(i, mask or ((1*(2->pow(i)))->oclAsType(long)))}->min() )  ;     i := i + 1 ) ; 
    return memo[v+1][mask+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static void main(String[] args)throws Exception {
    MyScanner scan=new MyScanner(System.in);
    int v=scan.nextInt();
    int e=scan.nextInt();
    Group[] groups=new Group[v];
    for(int i=0 ; i<v ; i++)groups[i]=new Group();
    List<Branch>branches=new ArrayList<>(e);
    for(int i=0 ; i<e ; i++){
      branches.add(new Branch(scan.nextInt(),scan.nextInt(),scan.nextInt()));
    }
    Collections.sort(branches);
    int result=0 ;
    for(Branch _b : branches){
      Group g1=groups[_b.s] .getGroup();
      Group g2=groups[_b.t] .getGroup();
      if(g1==g2)continue ;
      Group newg=new Group();
      g1.parent=newg ;
      g2.parent=newg ;
      result+=_b.v ;
    }
    System.out.println(result);
  }
}
class Group {
  Group parent ;
  Group(){
  }
  Group getGroup(){
    return(parent==null)? this : parent.getGroup();
  }
}
class Branch implements Comparable<Branch>{
  int s,t ;
  int v ;
  Branch(int _s,int _t,int _v){
    s=_s ;
    t=_t ;
    v=_v ;
  }
  @ Override public int compareTo(Branch _b){
    return this.v-_b.v ;
  }
}
class MyScanner {
  InputStream in ;
  MyScanner(InputStream _in){
    in=_in ;
  }
  int nextInt(){
    int result=0 ;
    try {
      int _i=in.read();
      while(_i<'0' || _i>'9'){
        _i=in.read();
      }
      while(_i>='0' && _i<='9'){
        result*=10 ;
        result+=(int)(_i-'0');
        _i=in.read();
      }
      return result ;
    }
    catch(Exception e){
      e.printStackTrace();
      return 0 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : MyScanner ; scan := MyScanner.newMyScanner(OclFile["System.in"]) ;
     var v : int ; v := scan.nextInt() ;
    var e : int ; e := scan.nextInt() ;
    var groups : Sequence(Group) ; groups := Integer.subrange(1,v)->collect(null) ;
        var i : int ; i := 0 ; while i < v do (     groups[i+1] := Group.newGroup() ;  ;     i := i + 1 ) ; 
    var branches : Sequence(Branch) ; branches := Sequence{} ;
        var i : int ; i := 0 ; while i < e do ( (     branches := branches->including(Branch.newBranch(scan.nextInt(), scan.nextInt(), scan.nextInt())) )  ;     i := i + 1 ) ; 
    branches := branches->sort() ; 
    var result : int ; result := 0 ;
    for (_b : branches) do ( (     var g1 : Group ; g1 := groups[_b.s+1].getGroup() ;
     var g2 : Group ; g2 := groups[_b.t+1].getGroup() ;
    if (g1 = g2) then     continue else skip ; 
    var newg : Group ; newg := Group.newGroup() ;
    g1.parent := newg ; 
    g2.parent := newg ; 
    result := result+(_b.v) ; 
 )  ) ; 
    OclFile["System.out"].println(result) ; 
 );
}
class Group {
   attribute parent : Group;
   static operation newGroup() : Group
  pre: true
  post: true
  activity:
  ( var self : Group ;
    self := createGroup();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   operation getGroup() : Group
  pre: true
  post: true
  activity: (     return if (parent = null) then self else parent.getGroup() endif );
}
class Branch implements Comparable<Branch> {
   attribute s : int;
   attribute v : int;
   static operation newBranch( _s : int, _t : int, _v : int) : Branch
  pre: true
  post: true
  activity:
  ( var self : Branch ;
    self := createBranch();
    self.initialise(_s, _t,_v);
    return self );
  operation initialise( _s : int, _t : int, _v : int) : void
  pre: true  post: true
  activity: (     s := _s ; 
     t := _t ; 
     v := _v );
      operation compareTo( _b : Branch) : int
  pre: true
  post: true
  activity: (     return self.v - _b.v );
}
class MyScanner {
   attribute in : OclFile;
   static operation newMyScanner( _in : OclFile) : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise(_in);
    return self );
  operation initialise( _in : OclFile) : void
  pre: true  post: true
  activity: (     in := _in );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     try (     var _i : int ; _i := in.read() ;
     while (_i < '0' or _i > '9') do (     _i := in.read() ) ; 
     while (_i >= '0' & _i <= '9') do (     result := result*(10) ; 
     result := result+((_i - ('0')->char2byte())->oclAsType(int)) ; 
     _i := in.read() ) ; 
     return result )   catch (e : ProgramException) do (     e.printStackTrace() ; 
     return 0 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String isDivisible(long n){
    long temp=n ;
    int sum=0 ;
    while(n!=0){
      int k=(int)n % 10 ;
      sum+=k ;
      n/=10 ;
    }
    if(temp % sum==0)return "YES" ;
    return "NO" ;
  }
  public static void main(String[] args){
    long n=123 ;
    System.out.println(isDivisible(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isDivisible( n : long) : String
  pre: true
  post: true
  activity: (     var temp : long ; temp := n ;
     var sum : int ; sum := 0 ;
    while (n /= 0) do (     var k : int ; k := n->oclAsType(int) mod 10 ;
     sum := sum+(k) ; 
     n := n/(10) ) ; 
    if (temp mod sum = 0) then     return "YES" else skip ; 
    return "NO" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 123 ;
     OclFile["System.out"].println(isDivisible(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int n,m ;
  ArrayList<ArrayList<Edge>>edges ;
  public static void main(String[] args){
    Main p=new Main();
    p.read();
    p.solve();
  }
  void read(){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    m=sc.nextInt();
    edges=new ArrayList<>(n);
    for(int i=0 ; i<n ; i++){
      edges.add(new ArrayList<>());
    }
    for(int i=0 ; i<m ; i++){
      int src=sc.nextInt();
      int trg=sc.nextInt();
      int cost=sc.nextInt();
      edges.get(src).add(new Edge(trg,cost));
      edges.get(trg).add(new Edge(src,cost));
    }
  }
  void solve(){
    boolean[] tree=new boolean[n];
    long ans=0L ;
    PriorityQueue<Edge>queue=new PriorityQueue<>(new Comparator<Edge>(){
      @ Override public int compare(Edge edge,Edge t1){
        return Integer.compare(edge.cost,t1.cost);
      }
    }
);
    tree[0]=true ;
    for(Edge e : edges.get(0)){
      queue.add(e);
    }
    while(! queue.isEmpty()){
      Edge e=queue.poll();
      if(tree[e.to])continue ;
      ans+=e.cost ;
      tree[e.to]=true ;
      for(Edge _e : edges.get(e.to)){
        if(! tree[_e.to])queue.add(_e);
      }
    }
    System.out.println(ans);
  }
}
class Edge {
  int to,cost ;
  Edge(int to,int cost){
    this.to=to ;
    this.cost=cost ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute edges : Sequence(Sequence(Edge));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : Main ; p := Main.newMain() ;
     p.read() ; 
     p.solve() );
   operation read() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
    edges := Sequence{} ; 
        var i : int ; i := 0 ; while i < n do ( (     edges := edges->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var src : int ; src := sc.getCurrent()->toInteger() ;
     var trg : int ; trg := sc.getCurrent()->toInteger() ;
    var cost : int ; cost := sc.getCurrent()->toInteger() ;
    edges->at(src+1)->excludes(Edge.newEdge(trg, cost)) ; 
    edges->at(trg+1)->excludes(Edge.newEdge(src, cost)) ; 
 )  ;     i := i + 1 ) ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var tree : Sequence(boolean) ; tree := Integer.subrange(1,n)->collect(false) ;
     var ans : long ; ans := 0L ;
    var queue : Sequence(Edge) ; queue := Sequence{}->union(OclComparator<Edge>.newOclComparator()) ;
    tree[0+1] := true ; 
    for (e : edges->at(0+1)) do ( (     queue := queue->including(e) )  ) ; 
    while (not(queue->isEmpty())) do (     var e : Edge ; e := queue->min() ;
     if (tree[e.to+1]) then     continue else skip ; 
    ans := ans+(e.cost) ; 
    tree[e.to+1] := true ; 
    for (_e : edges->at(e.to+1)) do ( (     if (not(tree[_e.to+1])) then     queue := queue->including(_e) ; else skip )  ) ; 
 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}
class Edge {
   attribute to : int;
   static operation newEdge( to : int, cost : int) : Edge
  pre: true
  post: true
  activity:
  ( var self : Edge ;
    self := createEdge();
    self.initialise(to, cost);
    return self );
  operation initialise( to : int, cost : int) : void
  pre: true  post: true
  activity: (     self.to := to ; 
     self.cost := cost );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int last ;
  static Vector<Integer>findSubset(Vector<Integer>temp,int k){
    Vector<Integer>ans=new Vector<Integer>();
    for(int i=last ; i>=0 ; i--){
      int cnt=0 ;
      for(Integer it : temp){
        int bit=it &(1<<i);
        if(bit>0)cnt++;
      }
      if(cnt>=k){
        for(Integer it : temp){
          int bit=it &(1<<i);
          if(bit>0)ans.add(it);
        }
        last=i-1 ;
        return ans ;
      }
    }
    return ans ;
  }
  static int findMaxiumAnd(int a[],int n,int k){
    last=31 ;
    Vector<Integer>temp1=new Vector<Integer>();
    Vector<Integer>temp2=new Vector<Integer>();
    ;
    for(int i=0 ; i<n ; i++){
      temp2.add(a[i]);
    }
    while((int)temp2.size()>=k){
      temp1=temp2 ;
      temp2=findSubset(temp2,k);
    }
    int ans=temp1.get(0);
    for(int i=0 ; i<k ; i++)ans=ans & temp1.get(i);
    return ans ;
  }
  public static void main(String[] args){
    int a[]={
      255,127,31,5,24,37,15 };
      int n=a.length ;
      int k=4 ;
      System.out.println(findMaxiumAnd(a,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute last : int;
  static   operation findSubset( temp : Sequence(int), k : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Sequence{} ;
         var i : int ; i := last ; while i >= 0 do ( (     var cnt : int ; cnt := 0 ;
     for (it : temp) do ( (     var bit : int ; bit := MathLib.bitwiseAnd(it,((1*(2->pow(i)))->oclAsType(long))) ;
     if (bit > 0) then     cnt := cnt + 1 ; else skip )  ) ; 
     if (cnt >= k) then (     for (it : temp) do ( (     var bit : int ; bit := MathLib.bitwiseAnd(it,((1*(2->pow(i)))->oclAsType(long))) ;
     if (bit > 0) then     ans := ans->including(it) ; else skip )  ) ; 
     last := i - 1 ; 
     return ans ) else skip )  ;     i := i - 1 ) ; 
     return ans );
  static   operation findMaxiumAnd( a : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     last := 31 ; 
     var temp1 : Sequence(int) ; temp1 := Sequence{} ;
    var temp2 : Sequence(int) ; temp2 := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     temp2 := temp2->including(a[i+1]) )  ;     i := i + 1 ) ; 
    while (temp2->size()->oclAsType(int) >= k) do (     temp1 := temp2 ; 
     temp2 := findSubset(temp2, k) ) ; 
    var ans : int ; ans := temp1->at(0+1) ;
        var i : int ; i := 0 ; while i < k do (     ans := MathLib.bitwiseAnd(ans,temp1->at(i+1)) ;  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{255,127,31,5,24,37,15} ;
     var n : int ; n := a->size() ;
     var k : int ; k := 4 ;
     OclFile["System.out"].println(findMaxiumAnd(a, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class A_Kuroni_and_the_Gifts {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int[] a=readArray(sc,n);
      int[] b=readArray(sc,n);
      System.out.println(solve(a,b));
    }
    sc.close();
  }
  static int[] readArray(Scanner sc,int size){
    int[] result=new int[size];
    for(int i=0 ; i<result.length ; ++i){
      result[i]=sc.nextInt();
    }
    return result ;
  }
  static String solve(int[] a,int[] b){
    return String.format("%s\n%s",Arrays.stream(a).sorted().mapToObj(String :: valueOf).collect(Collectors.joining(" ")),Arrays.stream(b).sorted().mapToObj(String :: valueOf).collect(Collectors.joining(" ")));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Kuroni_and_the_Gifts {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := readArray(sc, n) ;
     var b : Sequence(int) ; b := readArray(sc, n) ;
     OclFile["System.out"].println(solve(a, b)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation readArray( sc : OclFile, size : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var result : Sequence(int) ; result := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < result->size() do ( (     result[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return result );
  static   operation solve( a : Sequence(int), b : Sequence(int)) : String
  pre: true
  post: true
  activity: (     return StringLib.format("%s\n%s",Sequence{stream(a)->sort().mapToObj(lambda _pars : OclAny in String.newString().valueOf(_pars)).collect(Collectors.joining(" ")),stream(b)->sort().mapToObj(lambda _pars : OclAny in String.newString().valueOf(_pars)).collect(Collectors.joining(" "))}) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
public class CheckTheString {
  public static void main(String[] args)throws Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    char[] c=reader.readLine().toCharArray();
    int[] sum={
      0,0,0 };
      boolean ordered=true ;
      sum[c[0]-'a']++;
      for(int i=1 ; i<c.length ; i++){
        sum[c[i]-'a']++;
        ordered=ordered && c[i-1]<=c[i];
      }
      if(ordered &&(sum[0]==sum[2] || sum[1]==sum[2])&& sum[0]>0 && sum[1]>0){
        writer.write("Yes");
      }
      else {
        writer.write("No");
      }
      writer.newLine();
      writer.flush();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class CheckTheString {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var c : Sequence(String) ; c := reader.readLine()->characters() ;
    var sum : Sequence(int) ; sum := Sequence{0,0,0} ;
    var ordered : boolean ; ordered := true ;
    sum[c[0+1] - ('a')->char2byte()+1] := sum[c[0+1] - ('a')->char2byte()+1] + 1 ; 
        var i : int ; i := 1 ; while i < c->size() do ( (     sum[c[i+1] - ('a')->char2byte()+1] := sum[c[i+1] - ('a')->char2byte()+1] + 1 ; 
     ordered := ordered & c[i - 1+1] <= c[i+1] )  ;     i := i + 1 ) ; 
    if (ordered & (sum[0+1] = sum[2+1] or sum[1+1] = sum[2+1]) & sum[0+1] > 0 & sum[1+1] > 0) then (     skip ) else (     skip ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean checkConcurrent(int a1,int b1,int c1,int a2,int b2,int c2,int a3,int b3,int c3){
    return(a3*(b1*c2-b2*c1)+b3*(c1*a2-c2*a1)+c3*(a1*b2-a2*b1)==0);
  }
  public static void main(String[] args){
    int a1=2,b1=-3,c1=5 ;
    int a2=3,b2=4,c2=-7 ;
    int a3=9,b3=-5,c3=8 ;
    if(checkConcurrent(a1,b1,c1,a2,b2,c2,a3,b3,c3))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkConcurrent( a1 : int, b1 : int, c1 : int, a2 : int, b2 : int, c2 : int, a3 : int, b3 : int, c3 : int) : boolean
  pre: true
  post: true
  activity: (     return (a3 * (b1 * c2 - b2 * c1) + b3 * (c1 * a2 - c2 * a1) + c3 * (a1 * b2 - a2 * b1) = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a1 : int ; a1 := 2 ;
    var b1 : int ; b1 := -3 ;
    var c1 : int ; c1 := 5 ;
     var a2 : int ; a2 := 3 ;
    var b2 : int ; b2 := 4 ;
    var c2 : int ; c2 := -7 ;
     var a3 : int ; a3 := 9 ;
    var b3 : int ; b3 := -5 ;
    var c3 : int ; c3 := 8 ;
     if (checkConcurrent(a1, b1, c1, a2, b2, c2, a3, b3, c3)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int sameSetBits(int arr[],int n){
    Vector<Integer>v=new Vector<>();
    for(int i=0 ; i<n ; i++){
      int count=Integer.bitCount(arr[i]);
      v.add(count);
    }
    int current_count=1,max_count=1 ;
    for(int i=1 ; i<v.size()-1 ; i++){
      if(v.get(i+1)==v.get(i))current_count++;
      else current_count=1 ;
      max_count=Math.max(max_count,current_count);
    }
    return max_count ;
  }
  public static void main(String[] args){
    int arr[]={
      9,75,14,7,13,11 };
      int n=arr.length ;
      System.out.println(sameSetBits(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sameSetBits( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     var count : int ; count := bitCount(arr[i+1]) ;
     v := v->including(count) )  ;     i := i + 1 ) ; 
    var current_count : int ; current_count := 1 ;
    var max_count : int ; max_count := 1 ;
        var i : int ; i := 1 ; while i < v->size() - 1 do ( (     if (v->at(i + 1+1) = v->at(i+1)) then     current_count := current_count + 1 else     current_count := 1 ; ;  
     max_count := Set{max_count, current_count}->max() )  ;     i := i + 1 ) ; 
    return max_count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{9,75,14,7,13,11} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(sameSetBits(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int value(char x){
    return(int)(x-'a');
  }
  static String maximumProduct(String str,int n){
    String answer="",curr="" ;
    long maxProduct=0,product=1 ;
    for(int i=0 ; i<n ; i++){
      product*=1L*value(str.charAt(i));
      curr+=str.charAt(i);
      if(product>=maxProduct){
        maxProduct=product ;
        answer=curr ;
      }
      if(product==0){
        product=1 ;
        curr="" ;
      }
    }
    return answer ;
  }
  public static void main(String[] args){
    String str="sdtfakdhdahdzz" ;
    int n=str.length();
    System.out.print(maximumProduct(str,n)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation value( x : String) : int
  pre: true
  post: true
  activity: (     return (x - ('a')->char2byte())->oclAsType(int) );
  static   operation maximumProduct( str : String, n : int) : String
  pre: true
  post: true
  activity: (     var answer : String ; answer := "" ;
    var curr : String ; curr := "" ;
     var maxProduct : long ; maxProduct := 0 ;
    var product : long ; product := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     product := product*(1L * value(str->at(i+1))) ; 
     curr := curr+(str->at(i+1)) ; 
     if (product >= maxProduct) then (     maxProduct := product ; 
     answer := curr ) else skip ; 
     if (product = 0) then (     product := 1 ; 
     curr := "" ) else skip )  ;     i := i + 1 ) ; 
     return answer );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "sdtfakdhdahdzz" ;
     var n : int ; n := str->size() ;
     OclFile["System.out"].print(maximumProduct(str, n) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    String a=s.next();
    String b=s.next();
    String answer="" ;
    int naa=a.length();
    int nab=b.length();
    int i=0 ;
    if(naa==nab){
      if(a.equals(b)){
        answer="EQUAL" ;
      }
      else {
        for(i=0 ; i<naa ; i++){
          int q=a.charAt(i)+0 ;
          int l=b.charAt(i)-0 ;
          if(q>l){
            answer="GREATER" ;
            break ;
          }
          else if(q<l){
            answer="LESS" ;
            break ;
          }
        }
      }
    }
    else if(naa>nab){
      answer="GREATER" ;
    }
    else if(naa<nab){
      answer="LESS" ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := s.getCurrent() ;
    var b : String ; b := s.getCurrent() ;
    var answer : String ; answer := "" ;
    var naa : int ; naa := a->size() ;
    var nab : int ; nab := b->size() ;
    var i : int ; i := 0 ;
    if (naa = nab) then (     if (a = b) then (     answer := "EQUAL" ) else (         i := 0 ; while i < naa do ( (     var q : int ; q := a->at(i+1) + 0 ;
     var l : int ; l := b->at(i+1) - 0 ;
     if (q > l) then (     answer := "GREATER" ; 
     break ) else     if (q < l) then (     answer := "LESS" ; 
     break ) else skip ; )  ;     i := i + 1 ) ) ) else     if (naa > nab) then (     answer := "GREATER" ) else     if (naa < nab) then (     answer := "LESS" ) else skip ; ;  ;  
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int W=sc.nextInt();
    int H=sc.nextInt();
    int T=sc.nextInt();
    int P=sc.nextInt();
    int[] X=new int[P];
    int[] Y=new int[P];
    for(int i=0 ; i<P ; ++i){
      X[i]=sc.nextInt();
      Y[i]=sc.nextInt();
      sc.next();
    }
    int[][] S=new int[H][W];
    for(int i=0 ; i<H ; ++i){
      for(int j=0 ; j<W ; ++j){
        S[i][j]=sc.nextInt();
      }
    }
    int ans=0 ;
    for(int i=0 ; i<P ; ++i){
      ans+=S[Y[i] ][X[i] ];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var W : int ; W := sc.getCurrent()->toInteger() ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
    var P : int ; P := sc.getCurrent()->toInteger() ;
    var X : Sequence(int) ; X := Integer.subrange(1,P)->collect(0) ;
    var Y : Sequence(int) ; Y := Integer.subrange(1,P)->collect(0) ;
        var i : int ; i := 0 ; while i < P do ( (     X[i+1] := sc.getCurrent()->toInteger() ; 
     Y[i+1] := sc.getCurrent()->toInteger() ; 
     skip )  ;     i := i + 1 ) ; 
    var S : Sequence(Sequence(int)) ; S := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     S[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < P do ( (     ans := ans+(S[Y[i+1]+1][X[i+1]+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int w=sc.nextInt();
    int h=sc.nextInt();
    int t=sc.nextInt();
    int[][] field=new int[h][w];
    int p=sc.nextInt();
    for(int i=0 ; i<p ; i++){
      int ww=sc.nextInt();
      int hh=sc.nextInt();
      int tt=sc.nextInt();
      field[hh][ww]++;
    }
    long total=0 ;
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        if(sc.nextInt()==1){
          total+=field[i][j];
        }
      }
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var field : Sequence(Sequence(int)) ; field := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    var p : int ; p := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < p do ( (     var ww : int ; ww := sc.getCurrent()->toInteger() ;
     var hh : int ; hh := sc.getCurrent()->toInteger() ;
     var tt : int ; tt := sc.getCurrent()->toInteger() ;
     field[hh+1][ww+1] := field[hh+1][ww+1] + 1 )  ;     i := i + 1 ) ; 
    var total : long ; total := 0 ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (sc.getCurrent()->toInteger() = 1) then (     total := total+(field[i+1][j+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static String[][] boards={
    null,null,null,{
      "aab","d.b","dcc" },{
        "aacd","bbcd","cdaa","cdbb" },{
          "aaccd","ijj.d","i..le","h..le","hggff" },{
            "aabee.","d.b..f","dcc..f","f..aab","f..d.b",".hhdcc" },{
              "aabb..a",".cc..ca","...ddcb","a.d...b","acd....","bc..cc.","b..aabb" }
            };
            public static void main(String[] args)throws Exception {
              Scanner sc=new Scanner(System.in);
              int n=sc.nextInt();
              PrintWriter pw=new PrintWriter(System.out);
              if(n<3){
                pw.println("-1");
                pw.flush();
              }
              else if(n==3){
                for(String s : boards[3]){
                  pw.println(s);
                }
                pw.flush();
              }
              else {
                char[][] res=new char[n][n];
                for(char[] s : res)Arrays.fill(s,'.');
                int k=0 ;
                while(k+7<n){
                  for(int i=0 ; i<4 ; i++){
                    char[] s=boards[4][i] .toCharArray();
                    for(int j=0 ; j<4 ; j++){
                      res[k+i][k+j]=s[j];
                    }
                  }
                  k+=4 ;
                }
                for(int i=0 ; i<n-k ; i++){
                  char[] s=boards[n-k][i] .toCharArray();
                  for(int j=0 ; j<n-k ; j++){
                    res[k+i][k+j]=s[j];
                  }
                }
                for(char[] s : res)pw.println(s);
                pw.flush();
              }
            }
          }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute boards : Sequence(Sequence(String)) := Sequence{null,null,null,Sequence{"aab","d.b","dcc"},Sequence{"aacd","bbcd","cdaa","cdbb"},Sequence{"aaccd","ijj.d","i..le","h..le","hggff"},Sequence{"aabee.","d.b..f","dcc..f","f..aab","f..d.b",".hhdcc"},Sequence{"aabb..a",".cc..ca","...ddcb","a.d...b","acd....","bc..cc.","b..aabb"}};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     if (n < 3) then (     skip ; 
     skip ) else     if (n = 3) then (     for (s : boards[3+1]) do ( (     skip )  ) ; 
     skip ) else (     var res : Sequence(Sequence(String)) ; res := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
     for (s : res) do (     s := s->collect('.') ;  ) ; 
    var k : int ; k := 0 ;
    while (k + 7 < n) do (         var i : int ; i := 0 ; while i < 4 do ( (     var s : Sequence(String) ; s := boards[4+1][i+1]->characters() ;
         var j : int ; j := 0 ; while j < 4 do ( (     res[k + i+1][k + j+1] := s[j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     k := k+(4) ) ; 
        var i : int ; i := 0 ; while i < n - k do ( (     var s : Sequence(String) ; s := boards[n - k+1][i+1]->characters() ;
         var j : int ; j := 0 ; while j < n - k do ( (     res[k + i+1][k + j+1] := s[j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    for (s : res) do (     skip ;  ) ; 
    skip ; 
 ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void minOperation(String S,int N,int K){
    if(N % K!=0){
      System.out.println("Not Possible");
    }
    else {
      int[] count=new int[26];
      for(int i=0 ; i<N ; i++){
        count[(S.charAt(i)-97)]++;
      }
      int E=N/K ;
      Vector<Integer>greaterE=new Vector<>();
      Vector<Integer>lessE=new Vector<>();
      for(int i=0 ; i<26 ; i++){
        if(count[i]<E)lessE.add(E-count[i]);
        else greaterE.add(count[i]-E);
      }
      Collections.sort(greaterE);
      Collections.sort(lessE);
      int mi=Integer.MAX_VALUE ;
      for(int i=0 ; i<=K ; i++){
        int set1=i ;
        int set2=K-i ;
        if(greaterE.size()>=set1 && lessE.size()>=set2){
          int step1=0 ;
          int step2=0 ;
          for(int j=0 ; j<set1 ; j++)step1+=greaterE.get(j);
          for(int j=0 ; j<set2 ; j++)step2+=lessE.get(j);
          mi=Math.min(mi,Math.max(step1,step2));
        }
      }
      System.out.println(mi);
    }
  }
  public static void main(String[] args){
    String S="accb" ;
    int N=S.length();
    int K=2 ;
    minOperation(S,N,K);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minOperation( S : String, N : int, K : int) : void
  pre: true
  post: true
  activity: (     if (N mod K /= 0) then (     OclFile["System.out"].println("Not Possible") ) else (     var count : Sequence(int) ; count := Integer.subrange(1,26)->collect(0) ;
         var i : int ; i := 0 ; while i < N do ( (     count[(S->at(i+1) - 97)+1] := count[(S->at(i+1) - 97)+1] + 1 )  ;     i := i + 1 ) ; 
    var E : int ; E := N / K ;
    var greaterE : Sequence(int) ; greaterE := Sequence{} ;
    var lessE : Sequence(int) ; lessE := Sequence{} ;
        var i : int ; i := 0 ; while i < 26 do ( (     if (count[i+1] < E) then     lessE := lessE->including(E - count[i+1]) ; else     greaterE := greaterE->including(count[i+1] - E) ; )  ;     i := i + 1 ) ; 
    greaterE := greaterE->sort() ; 
    lessE := lessE->sort() ; 
    var mi : int ; mi := 2147483647 ;
        var i : int ; i := 0 ; while i <= K do ( (     var set1 : int ; set1 := i ;
     var set2 : int ; set2 := K - i ;
     if (greaterE->size() >= set1 & lessE->size() >= set2) then (     var step1 : int ; step1 := 0 ;
     var step2 : int ; step2 := 0 ;
        var j : int ; j := 0 ; while j < set1 do (     step1 := step1+(greaterE->at(j+1)) ;  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < set2 do (     step2 := step2+(lessE->at(j+1)) ;  ;     j := j + 1 ) ; 
    mi := Set{mi, Set{step1, step2}->max()}->min() ; 
 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(mi) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := "accb" ;
     var N : int ; N := S->size() ;
     var K : int ; K := 2 ;
     execute minOperation(S, N, K) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String minimize(String str){
    String mstr=" " ;
    int l,i,flagchar[]=new int[26];
    char ch ;
    l=str.length();
    for(i=0 ; i<str.length(); i++){
      ch=str.charAt(i);
      if(flagchar[ch-97]==0){
        mstr=mstr+ch ;
        flagchar[ch-97]=1 ;
      }
    }
    return mstr ;
  }
  static void replaceMinimizeUtil(String str){
    String minimizedStr,finalStr="" ;
    int i,index,l ;
    char ch ;
    l=str.length();
    minimizedStr=minimize(str);
    for(i=0 ; i<minimizedStr.length(); i++){
      ch=minimizedStr.charAt(i);
      index=(ch*ch)% l ;
      finalStr=finalStr+str.charAt(index);
    }
    System.out.println("Final String: "+finalStr);
  }
  public static void main(String[] args){
    String str="geeks" ;
    replaceMinimizeUtil(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minimize( str : String) : String
  pre: true
  post: true
  activity: (     var mstr : String ; mstr := " " ;
     var l : int ;
    var i : int ;
    var flagchar : Sequence(void) ; flagchar := Integer.subrange(1,26)->collect(0) ;
    var ch : String ;
    l := str->size() ; 
        i := 0 ; while i < str->size() do ( (     ch := str->at(i+1) ; 
     if (flagchar[(ch)->char2byte() - 97+1] = 0) then (     mstr := mstr + ch ; 
     flagchar[(ch)->char2byte() - 97+1] := 1 ) else skip )  ;     i := i + 1 ) ; 
    return mstr 
 );
  static   operation replaceMinimizeUtil( str : String) : void
  pre: true
  post: true
  activity: (     var minimizedStr : String ;
    var finalStr : String ; finalStr := "" ;
     var i : int ;
    var index : int ;
    var l : int ;
    var ch : String ;
    l := str->size() ; 
    minimizedStr := minimize(str) ; 
        i := 0 ; while i < minimizedStr->size() do ( (     ch := minimizedStr->at(i+1) ; 
     index := (ch * ch) mod l ; 
     finalStr := finalStr + str->at(index+1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Final String: " + finalStr) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeks" ;
     execute replaceMinimizeUtil(str) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class countSetBits {
  static int countSetBits(int n){
    int count=0 ;
    while(n>0){
      n &=(n-1);
      count++;
    }
    return count ;
  }
  public static void main(String args[]){
    int i=9 ;
    System.out.println(countSetBits(i));
  }
}
------------------------------------------------------------
OCL File:
---------
 class countSetBits {
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     n := MathLib.bitwiseAnd(n, (n - 1)) ; 
     count := count + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 9 ;
     OclFile["System.out"].println(countSetBits(i)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class countSetBits {
  static int countSetBits(int n){
    int count=0 ;
    while(n>0){
      count+=n & 1 ;
      n>>=1 ;
    }
    return count ;
  }
  public static void main(String args[]){
    int i=9 ;
    System.out.println(countSetBits(i));
  }
}
------------------------------------------------------------
OCL File:
---------
 class countSetBits {
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     count := count+(n & 1) ; 
     n := n/(2->pow(1)) ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 9 ;
     OclFile["System.out"].println(countSetBits(i)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class AA {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int c=0 ;
    int n=s.length();
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='1')c++;
    }
    int k ;
    if(c>1)k=n-1 ;
    else k=n-2 ;
    if(k % 2==1)k--;
    if(n<=1)System.out.print(0);
    else if(n<=2 ||(n==3 && c==1))System.out.print(1);
    else System.out.print(k/2+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class AA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var c : int ; c := 0 ;
    var n : int ; n := s->size() ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = '1') then     c := c + 1 ; else skip )  ;     i := i + 1 ) ; 
    var k : int ;
    if (c > 1) then     k := n - 1 else     k := n - 2 ; ;  
    if (k mod 2 = 1) then     k := k - 1 ; else skip ; 
    if (n <= 1) then     OclFile["System.out"].print(0) else     if (n <= 2 or (n = 3 & c = 1)) then     OclFile["System.out"].print(1) else     OclFile["System.out"].print(k / 2 + 1) ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String args[]){
    BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    String str="" ;
    StringTokenizer stk ;
    int x_kazu,y_kazu=0 ;
    try {
      str=bfr.readLine();
      if(str==""){
        System.exit(0);
      }
      stk=new StringTokenizer(str," ");
      x_kazu=Integer.parseInt(stk.nextToken());
      y_kazu=Integer.parseInt(stk.nextToken());
      int gcm=0 ;
      for(int i=1 ; i<=Math.min(x_kazu,y_kazu); i++){
        if(x_kazu % i==0 && y_kazu % i==0){
          gcm=i ;
        }
      }
      int res=((x_kazu/gcm)+(y_kazu/gcm)-1)*gcm+1 ;
      System.out.println(res);
    }
    catch(IOException e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bfr : OclFile ; bfr := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := "" ;
    var stk : OclIterator ;
    var x_kazu : int ;
    var y_kazu : int ; y_kazu := 0 ;
    try (     str := bfr.readLine() ; 
     if (str = "") then ( OclProcess.exit(0) ) else skip ; 
    stk := OclIterator.newOclIterator_String_String(str, " ") ; 
    x_kazu := (stk.next())->toInteger() ; 
    y_kazu := (stk.next())->toInteger() ; 
    var gcm : int ; gcm := 0 ;
        var i : int ; i := 1 ; while i <= Set{x_kazu, y_kazu}->min() do ( (     if (x_kazu mod i = 0 & y_kazu mod i = 0) then (     gcm := i ) else skip )  ;     i := i + 1 ) ; 
    var res : int ; res := ((x_kazu / gcm) + (y_kazu / gcm) - 1) * gcm + 1 ;
    OclFile["System.out"].println(res) ; 
 )   catch (e : IOException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
public class checkTheString {
  public static void main(String args[])throws Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    char r[]=reader.readLine().toCharArray();
    int c[]=new int[3];
    c[r[0]-'a']++;
    boolean flag=true ;
    for(int i=1 ; i<r.length ; i++){
      c[r[i]-'a']++;
      if(r[i]<r[i-1]){
        flag=false ;
      }
    }
    if(flag && c[0]>0 && c[1]>0 &&(c[2]==c[0] || c[2]==c[1])){
      writer.write("Yes");
    }
    else {
      writer.write("No");
    }
    writer.newLine();
    writer.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class checkTheString {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var r : Sequence(String) ; r := reader.readLine()->characters() ;
    var c : Sequence(int) ; c := Integer.subrange(1,3)->collect(0) ;
    c[r[0+1] - ('a')->char2byte()+1] := c[r[0+1] - ('a')->char2byte()+1] + 1 ; 
    var flag : boolean ; flag := true ;
        var i : int ; i := 1 ; while i < r->size() do ( (     c[r[i+1] - ('a')->char2byte()+1] := c[r[i+1] - ('a')->char2byte()+1] + 1 ; 
     if (r[i+1] < r[i - 1+1]) then (     flag := false ) else skip )  ;     i := i + 1 ) ; 
    if (flag & c[0+1] > 0 & c[1+1] > 0 & (c[2+1] = c[0+1] or c[2+1] = c[1+1])) then (     skip ) else (     skip ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  private class Node {
    public long pattern=0 ;
    public int index ;
    public LinkedList<Integer>children=new LinkedList<Integer>();
    public int parent=-1 ;
    public Node(int i){
      this.index=i ;
    }
    public void setParent(int K,int parent,int use,Node[] nodes){
      this.pattern=K-use ;
      this.parent=parent ;
      int count=1 ;
      if(parent!=-1){
        count++;
      }
      for(int n : children){
        if(n==this.parent){
          continue ;
        }
        nodes[n] .setParent(K,index,count,nodes);
        count++;
      }
    }
  }
  public void solve(){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int K=in.nextInt();
    Node[] nodes=new Node[N];
    for(int i=0 ; i<N ; i++){
      nodes[i]=new Node(i);
    }
    for(int i=0 ; i<N-1 ; i++){
      int a=in.nextInt()-1 ;
      int b=in.nextInt()-1 ;
      nodes[a] .children.add(b);
      nodes[b] .children.add(a);
    }
    in.close();
    nodes[0] .setParent(K,-1,0,nodes);
    long patterns=1 ;
    for(int i=0 ; i<N ; i++){
      patterns=(patterns*nodes[i] .pattern)% 1_000_000_007 ;
    }
    System.out.println(patterns);
  }
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class Node {
   attribute pattern : long := 0;
   attribute index : int;
   attribute children : Sequence(int) := Sequence{};
   attribute parent : int := -1;
   static operation newNode( i : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(i);
    return self );
  operation initialise( i : int) : void
  pre: true  post: true
  activity: (     self.index := i );
   operation setParent( K : int, parent : int, use : int, nodes : Sequence(Node)) : void
  pre: true
  post: true
  activity: (     self.pattern := K - use ; 
     self.parent := parent ; 
    var count : int ; count := 1 ;
    if (parent /= -1) then (     count := count + 1 ) else skip ; 
    for (n : children) do ( (     if (n = self.parent) then (     continue ) else skip ; 
     nodes[n+1].setParent(K, index, count, nodes) ; 
     count := count + 1 )  ) ; 
 );
}
   operation solve() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    var nodes : Sequence(Node) ; nodes := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     nodes[i+1] := Node.newNode(i) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     var a : int ; a := in.getCurrent()->toInteger() - 1 ;
     var b : int ; b := in.getCurrent()->toInteger() - 1 ;
     nodes[a+1].children->excludes(b) ; 
     nodes[b+1].children->excludes(a) )  ;     i := i + 1 ) ; 
    skip ; 
    nodes[0+1].setParent(K, -1, 0, nodes) ; 
    var patterns : long ; patterns := 1 ;
        var i : int ; i := 0 ; while i < N do ( (     patterns := (patterns * nodes[i+1].pattern) mod 1_000_000_007 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(patterns) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    String a=input.readLine();
    String b=input.readLine();
    int a1 ;
    int b1 ;
    if(a.length()>b.length()){
      System.out.println("GREATER");
    }
    else if(b.length()>a.length()){
      System.out.println("LESS");
    }
    else {
      while(a.length()>0 && b.length()>0){
        a1=Integer.parseInt(a.substring(0,1));
        b1=Integer.parseInt(b.substring(0,1));
        if(a1>b1){
          System.out.println("GREATER");
          break ;
        }
        else if(b1>a1){
          System.out.println("LESS");
          break ;
        }
        a=a.substring(1);
        b=b.substring(1);
      }
      if(a.length()==0){
        System.out.println("EQUAL");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var a : String ; a := input.readLine() ;
    var b : String ; b := input.readLine() ;
    var a1 : int ;
    var b1 : int ;
    if (a->size() > b->size()) then (     OclFile["System.out"].println("GREATER") ) else     if (b->size() > a->size()) then (     OclFile["System.out"].println("LESS") ) else (     while (a->size() > 0 & b->size() > 0) do (     a1 := (a.subrange(0+1,1))->toInteger() ; 
     b1 := (b.subrange(0+1,1))->toInteger() ; 
    if (a1 > b1) then (     OclFile["System.out"].println("GREATER") ; 
     break ) else     if (b1 > a1) then (     OclFile["System.out"].println("LESS") ; 
     break ) else skip ; ;  
    a := a.subrange(1+1,1) ; 
    b := b.subrange(1+1,1) ; 
 ) ; 
     if (a->size() = 0) then (     OclFile["System.out"].println("EQUAL") ) else skip ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int max_intersection(int center[],int length,int k){
    Arrays.sort(center);
    if(center[2]-center[0]>=2*k+length){
      return 0 ;
    }
    else if(center[2]-center[0]>=2*k){
      return(2*k-(center[2]-center[0]-length));
    }
    else return length ;
  }
  public static void main(String args[]){
    int center[]={
      1,2,3 };
      int L=1 ;
      int K=1 ;
      System.out.println(max_intersection(center,L,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation max_intersection( center : Sequence(int), length : int, k : int) : int
  pre: true
  post: true
  activity: (     center := center->sort() ; 
     if (center[2+1] - center[0+1] >= 2 * k + length) then (     return 0 ) else     if (center[2+1] - center[0+1] >= 2 * k) then (     return (2 * k - (center[2+1] - center[0+1] - length)) ) else     return length ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var center : Sequence(int) ; center := Sequence{1,2,3} ;
     var L : int ; L := 1 ;
     var K : int ; K := 1 ;
     OclFile["System.out"].println(max_intersection(center, L, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class CLG {
  static float hexagonside(float a){
    if(a<0)return-1 ;
    float x=a/3 ;
    return x ;
  }
  public static void main(String[] args){
    float a=6 ;
    System.out.println(hexagonside(a));
  }
}
------------------------------------------------------------
OCL File:
---------
class CLG {
  static   operation hexagonside( a : double) : double
  pre: true
  post: true
  activity: (     if (a < 0) then     return -1 else skip ; 
     var x : double ; x := a / 3 ;
     return x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 6 ;
     OclFile["System.out"].println(hexagonside(a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String findLargest(int N){
    String largest=strings(N,'7');
    return largest ;
  }
  static String findSmallest(int N){
    String smallest="1"+strings((N-1),'0');
    return smallest ;
  }
  private static String strings(int N,char c){
    String temp="" ;
    for(int i=0 ; i<N ; i++){
      temp+=c ;
    }
    return temp ;
  }
  static void printLargestSmallest(int N){
    System.out.print("Largest: "+findLargest(N)+"\n");
    System.out.print("Smallest: "+findSmallest(N)+"\n");
  }
  public static void main(String[] args){
    int N=4 ;
    printLargestSmallest(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findLargest( N : int) : String
  pre: true
  post: true
  activity: (     var largest : String ; largest := strings(N, '7') ;
     return largest );
  static   operation findSmallest( N : int) : String
  pre: true
  post: true
  activity: (     var smallest : String ; smallest := "1" + strings((N - 1), '0') ;
     return smallest );
  static   operation strings( N : int, c : String) : String
  pre: true
  post: true
  activity: (     var temp : String ; temp := "" ;
         var i : int ; i := 0 ; while i < N do ( (     temp := temp+(c) )  ;     i := i + 1 ) ; 
     return temp );
  static   operation printLargestSmallest( N : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("Largest: " + findLargest(N) + "\n") ; 
     OclFile["System.out"].print("Smallest: " + findSmallest(N) + "\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     execute printLargestSmallest(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isVowel(char c){
    return(c=='a' || c=='A' || c=='e' || c=='E' || c=='i' || c=='I' || c=='o' || c=='O' || c=='u' || c=='U');
  }
  static String reverseVowel(String str1){
    int j=0 ;
    char[] str=str1.toCharArray();
    String vowel="" ;
    for(int i=0 ; i<str.length ; i++){
      if(isVowel(str[i])){
        j++;
        vowel+=str[i];
      }
    }
    for(int i=0 ; i<str.length ; i++){
      if(isVowel(str[i])){
        str[i]=vowel.charAt(--j);
      }
    }
    return String.valueOf(str);
  }
  public static void main(String[] args){
    String str="hello world" ;
    System.out.println(reverseVowel(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isVowel( c : String) : boolean
  pre: true
  post: true
  activity: (     return (c = 'a' or c = 'A' or c = 'e' or c = 'E' or c = 'i' or c = 'I' or c = 'o' or c = 'O' or c = 'u' or c = 'U') );
  static   operation reverseVowel( str1 : String) : String
  pre: true
  post: true
  activity: (     var j : int ; j := 0 ;
     var str : Sequence(String) ; str := str1->characters() ;
    var vowel : String ; vowel := "" ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (isVowel(str[i+1])) then (     j := j + 1 ; 
     vowel := vowel+(str[i+1]) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < str->size() do ( (     if (isVowel(str[i+1])) then (     str[i+1] := vowel->at((j - 1)+1) ) else skip )  ;     i := i + 1 ) ; 
    return (str)->sum()  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "hello world" ;
     OclFile["System.out"].println(reverseVowel(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int ans ;
  static void subsetSum(Vector<Integer>c){
    int L=c.size();
    int mul=(int)Math.pow(2,L-1);
    for(int i=0 ; i<c.size(); i++)ans+=c.get(i)*mul ;
  }
  static void subsetGen(int[] arr,int i,int n,Vector<Integer>c){
    if(i==n){
      subsetSum(c);
      return ;
    }
    subsetGen(arr,i+1,n,c);
    c.add(arr[i]);
    subsetGen(arr,i+1,n,c);
    c.remove(0);
  }
  public static void main(String[] args){
    int arr[]={
      1,1 };
      int n=arr.length ;
      Vector<Integer>c=new Vector<Integer>();
      subsetGen(arr,0,n,c);
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute ans : int;
  static   operation subsetSum( c : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := c->size() ;
     var mul : int ; mul := 2->pow(L - 1)->oclAsType(int) ;
         var i : int ; i := 0 ; while i < c->size() do (     ans := ans+(c->at(i+1) * mul) ;  ;     i := i + 1 ) );
  static   operation subsetGen( arr : Sequence(int), i : int, n : int, c : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (i = n) then (     execute subsetSum(c) ; 
     return ) else skip ; 
     execute subsetGen(arr, i + 1, n, c) ; 
    c->excludes(arr[i+1]) ; 
    execute subsetGen(arr, i + 1, n, c) ; 
    c := c->excludingAt(0+1) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1} ;
     var n : int ; n := arr->size() ;
    var c : Sequence(int) ; c := Sequence{} ;
    execute subsetGen(arr, 0, n, c) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    int ans=0 ;
    if(x==y){
      System.out.println("0");
      System.exit(0);
    }
    if(x>=0 && y>=0){
      if(x<y){
        ans=y-x ;
      }
      else {
        if(y!=0){
          ans=y+x ;
        }
        else {
          ans=y+x+1 ;
        }
      }
      System.out.println(ans);
      System.exit(0);
    }
    if(x<0 && y<0){
      if(x>y){
        ans=Math.abs(y)-Math.abs(x)+2 ;
      }
      else {
        ans=Math.abs(x)-Math.abs(y);
      }
      System.out.println(ans);
      System.exit(0);
    }
    if(x>y){
      if(x>Math.abs(y)){
        ans=x-Math.abs(y)+1 ;
      }
      else {
        ans=Math.abs(y)-Math.abs(x)+1 ;
      }
    }
    else {
      if(Math.abs(x)<y){
        ans=y-Math.abs(x)+1 ;
      }
      else if(y!=0){
        ans=Math.abs(x)-Math.abs(y)+1 ;
      }
      else {
        ans=Math.abs(x)-Math.abs(y);
      }
    }
    System.out.println(ans);
    System.exit(0);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    if (x = y) then (     OclFile["System.out"].println("0") ; 
 OclProcess.exit(0) ) else skip ; 
    if (x >= 0 & y >= 0) then (     if (x < y) then (     ans := y - x ) else (     if (y /= 0) then (     ans := y + x ) else (     ans := y + x + 1 ) ) ;  
     OclFile["System.out"].println(ans) ; 
 OclProcess.exit(0) ) else skip ; 
    if (x < 0 & y < 0) then (     if (x > y) then (     ans := if y < 0 then -(y) else y endif - if x < 0 then -(x) else x endif + 2 ) else (     ans := if x < 0 then -(x) else x endif - if y < 0 then -(y) else y endif ) ;  
     OclFile["System.out"].println(ans) ; 
 OclProcess.exit(0) ) else skip ; 
    if (x > y) then (     if (x > if y < 0 then -(y) else y endif) then (     ans := x - if y < 0 then -(y) else y endif + 1 ) else (     ans := if y < 0 then -(y) else y endif - if x < 0 then -(x) else x endif + 1 ) ) else (     if (if x < 0 then -(x) else x endif < y) then (     ans := y - if x < 0 then -(x) else x endif + 1 ) else     if (y /= 0) then (     ans := if x < 0 then -(x) else x endif - if y < 0 then -(y) else y endif + 1 ) else (     ans := if x < 0 then -(x) else x endif - if y < 0 then -(y) else y endif ) ;  ) ;  
    OclFile["System.out"].println(ans) ; 
OclProcess.exit(0) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    LightScanner in=new LightScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ASimpleCalculator solver=new ASimpleCalculator();
    solver.solve(1,in,out);
    out.close();
  }
  static class ASimpleCalculator {
    public void solve(int testNumber,LightScanner in,PrintWriter out){
      int x=in.ints(),y=in.ints();
      int ans=Integer.MAX_VALUE ;
      if(x<=y){
        ans=Math.min(ans,y-x);
      }
      if(x<=-y){
        ans=Math.min(ans,1-x-y);
      }
      if(-x<=y){
        ans=Math.min(ans,1+x+y);
      }
      if(-x<=-y){
        ans=Math.min(ans,2-y+x);
      }
      out.println(ans);
    }
  }
  static class LightScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public LightScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String string(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int ints(){
      return Integer.parseInt(string());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : LightScanner ; in := LightScanner.newLightScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ASimpleCalculator ; solver := ASimpleCalculator.newASimpleCalculator() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ASimpleCalculator {
   operation solve( testNumber : int, in : LightScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var x : int ; x := in.ints() ;
    var y : int ; y := in.ints() ;
     var ans : int ; ans := 2147483647 ;
    if (x <= y) then (     ans := Set{ans, y - x}->min() ) else skip ; 
    if (x <= -y) then (     ans := Set{ans, 1 - x - y}->min() ) else skip ; 
    if (-x <= y) then (     ans := Set{ans, 1 + x + y}->min() ) else skip ; 
    if (-x <= -y) then (     ans := Set{ans, 2 - y + x}->min() ) else skip ; 
    skip ; 
 );
}
  static class LightScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newLightScanner( in : OclFile) : LightScanner
  pre: true
  post: true
  activity:
  ( var self : LightScanner ;
    self := createLightScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation string() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation ints() : int
  pre: true
  post: true
  activity: (     return (string())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Taska solver=new Taska();
    solver.solve(1,in,out);
    out.close();
  }
  static class Taska {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int x=in.nextInt();
      int y=in.nextInt();
      if(x==y){
        out.println(0);
        return ;
      }
      int d=Math.abs(Math.abs(x)-Math.abs(y));
      int ans=d ;
      if(Math.abs(x+d)==Math.abs(y)){
        if((x+d)!=y)ans++;
        out.println(ans);
        return ;
      }
      ans++;
      x*=-1 ;
      if((x+d)!=y)ans++;
      out.println(ans);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Taska ; solver := Taska.newTaska() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class Taska {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var x : int ; x := in.nextInt() ;
     var y : int ; y := in.nextInt() ;
    if (x = y) then (     skip ; 
     return ) else skip ; 
    var d : int ; d := if if x < 0 then -(x) else x endif - if y < 0 then -(y) else y endif < 0 then -(if x < 0 then -(x) else x endif - if y < 0 then -(y) else y endif) else if x < 0 then -(x) else x endif - if y < 0 then -(y) else y endif endif ;
    var ans : int ; ans := d ;
    if (if x + d < 0 then -(x + d) else x + d endif = if y < 0 then -(y) else y endif) then (     if ((x + d) /= y) then     ans := ans + 1 ; else skip ; 
     skip ; 
     return ) else skip ; 
    ans := ans + 1 ; 
    x := x*(-1) ; 
    if ((x + d) /= y) then     ans := ans + 1 ; else skip ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static long x=0 ;
  static long y=0 ;
  static long ans=0 ;
  public static void main(String[] args){
    x=sc.nextLong();
    y=sc.nextLong();
    if(x<=y)ans=(x>=0)? y-x :(-x<=y)? 1+y+x :(0<y)? 1-y-x : y-x ;
    else ans=(y>0)? 2-y+x :(y==0)? 1+x :(-y<=x)? 1+y+x :(0<=x)? 1-y-x : 2-y+x ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute x : long := 0;
  static   attribute y : long := 0;
  static   attribute ans : long := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     x := sc.getCurrent()->toLong() ; 
     y := sc.getCurrent()->toLong() ; 
     if (x <= y) then     ans := if (x >= 0) then y - x else if (-x <= y) then 1 + y + x else if (0 < y) then 1 - y - x else y - x endif endif endif else     ans := if (y > 0) then 2 - y + x else if (y = 0) then 1 + x else if (-y <= x) then 1 + y + x else if (0 <= x) then 1 - y - x else 2 - y + x endif endif endif endif ; ;  
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer stk=new StringTokenizer(br.readLine());
    long x=Long.parseLong(stk.nextToken());
    long y=Long.parseLong(stk.nextToken());
    long rta=0 ;
    if(x<0){
      if(y<0){
        if(x<y){
          System.out.println(Math.abs((y*-1)-(x*-1)));
        }
        else {
          System.out.println(Math.abs((y*-1)-(x*-1))+2);
        }
      }
      else {
        if(x*-1<y){
          System.out.println(Math.abs((y)-(x*-1))+1);
        }
        else if(x*-1==y){
          System.out.println(1);
        }
        else {
          if(y==0)System.out.println(x*-1);
          else System.out.println(Math.abs((x*-1)-(y))+1);
        }
      }
    }
    else {
      if(y<0){
        if(x<y*-1){
          System.out.println(Math.abs((y*-1)-(x))+1);
        }
        else if(x==y*-1){
          System.out.println(1);
        }
        else {
          System.out.println(Math.abs(x-(y*-1))+1);
        }
      }
      else {
        if(x>y){
          if(y==0)System.out.println(x+1);
          else System.out.println(Math.abs((y)-(x))+2);
        }
        else {
          System.out.println(Math.abs((y)-(x)));
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var stk : OclIterator ; stk := OclIterator.newOclIterator_String(br.readLine()) ;
    var x : long ; x := (stk.next())->toLong() ;
    var y : long ; y := (stk.next())->toLong() ;
    var rta : long ; rta := 0 ;
    if (x < 0) then (     if (y < 0) then (     if (x < y) then (     OclFile["System.out"].println(if (y * -1) - (x * -1) < 0 then -((y * -1) - (x * -1)) else (y * -1) - (x * -1) endif) ) else (     OclFile["System.out"].println(if (y * -1) - (x * -1) < 0 then -((y * -1) - (x * -1)) else (y * -1) - (x * -1) endif + 2) ) ) else (     if (x * -1 < y) then (     OclFile["System.out"].println(if (y) - (x * -1) < 0 then -((y) - (x * -1)) else (y) - (x * -1) endif + 1) ) else     if (x * -1 = y) then (     OclFile["System.out"].println(1) ) else (     if (y = 0) then     OclFile["System.out"].println(x * -1) ; else     OclFile["System.out"].println(if (x * -1) - (y) < 0 then -((x * -1) - (y)) else (x * -1) - (y) endif + 1) ; ) ;  ) ) else (     if (y < 0) then (     if (x < y * -1) then (     OclFile["System.out"].println(if (y * -1) - (x) < 0 then -((y * -1) - (x)) else (y * -1) - (x) endif + 1) ) else     if (x = y * -1) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(if x - (y * -1) < 0 then -(x - (y * -1)) else x - (y * -1) endif + 1) ) ;  ) else (     if (x > y) then (     if (y = 0) then     OclFile["System.out"].println(x + 1) ; else     OclFile["System.out"].println(if (y) - (x) < 0 then -((y) - (x)) else (y) - (x) endif + 2) ; ) else (     OclFile["System.out"].println(if (y) - (x) < 0 then -((y) - (x)) else (y) - (x) endif) ) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    String a=sc.next();
    String b=sc.next();
    String ans ;
    int la=a.length();
    int lb=b.length();
    if(la>lb){
      ans="GREATER" ;
    }
    else if(la<lb){
      ans="LESS" ;
    }
    else {
      if(a.compareTo(b)<0){
        ans="LESS" ;
      }
      else if(a.compareTo(b)>0){
        ans="GREATER" ;
      }
      else {
        ans="EQUAL" ;
      }
    }
    System.out.println(ans);
  }
  static int l_min(int[] a){
    Arrays.sort(a);
    return a[0];
  }
  static int l_max(int[] a){
    int l=a.length ;
    Arrays.sort(a);
    return a[l-1];
  }
  public static PrintWriter out ;
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var a : String ; a := sc.next() ;
    var b : String ; b := sc.next() ;
    var ans : String ;
    var la : int ; la := a->size() ;
    var lb : int ; lb := b->size() ;
    if (la > lb) then (     ans := "GREATER" ) else     if (la < lb) then (     ans := "LESS" ) else (     if (a->compareTo(b) < 0) then (     ans := "LESS" ) else     if (a->compareTo(b) > 0) then (     ans := "GREATER" ) else (     ans := "EQUAL" ) ;  ) ;  ;  
    OclFile["System.out"].println(ans) ; 
 );
  static   operation l_min( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     return a[0+1] );
  static   operation l_max( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var l : int ; l := a->size() ;
     a := a->sort() ; 
     return a[l - 1+1] );
  static   attribute out : OclFile;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String str=sc.nextLine();
    char last='a' ;
    int as=0 ;
    int bs=0 ;
    int cs=0 ;
    boolean breakd=false ;
    char got ;
    if(str.charAt(0)=='a'){
      for(int i=0 ; i<str.length(); i++){
        got=str.charAt(i);
        if(got<last){
          System.out.println("NO");
          breakd=true ;
          break ;
        }
        else {
          if(got=='a'){
            as++;
            last='a' ;
          }
          else if(got=='b'){
            bs++;
            last='b' ;
          }
          else {
            cs++;
            last='c' ;
          }
        }
      }
    }
    else {
      breakd=true ;
      System.out.println("NO");
    }
    if(! breakd){
      if((cs==as || cs==bs)&&(as>0 && bs>0)){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.nextLine() ;
    var last : String ; last := 'a' ;
    var as : int ; as := 0 ;
    var bs : int ; bs := 0 ;
    var cs : int ; cs := 0 ;
    var breakd : boolean ; breakd := false ;
    var got : String ;
    if (str->at(0+1) = 'a') then (         var i : int ; i := 0 ; while i < str->size() do ( (     got := str->at(i+1) ; 
     if (got < last) then (     OclFile["System.out"].println("NO") ; 
     breakd := true ; 
     break ) else (     if (got = 'a') then (     as := as + 1 ; 
     last := 'a' ) else     if (got = 'b') then (     bs := bs + 1 ; 
     last := 'b' ) else (     cs := cs + 1 ; 
     last := 'c' ) ;  ) )  ;     i := i + 1 ) ) else (     breakd := true ; 
     OclFile["System.out"].println("NO") ) ;  
    if (not(breakd)) then (     if ((cs = as or cs = bs) & (as > 0 & bs > 0)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    while(sc.hasNext()){
      String[] text=sc.nextLine().split(" ");
      int[] cards=new int[text.length];
      boolean one=false ;
      int sum=0 ;
      boolean flag=false ;
      for(int $=0 ; $<text.length ; $++){
        cards[$]=Integer.parseInt(text[$]);
        if(cards[0]==0){
          flag=true ;
          break ;
        }
        if(cards[$]==1){
          one=true ;
          sum++;
        }
        else if(cards[$]>=10 && cards[$]<=13){
          sum+=10 ;
        }
        else {
          sum+=cards[$];
        }
      }
      if(flag){
        break ;
      }
      if(one){
        if(sum+10<=21){
          sum+=10 ;
        }
      }
      if(sum>21){
        sum=0 ;
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     var text : Sequence(String) ; text := sc.nextLine()->split(" ") ;
     var cards : Sequence(int) ; cards := Integer.subrange(1,text->size())->collect(0) ;
    var one : boolean ; one := false ;
    var sum : int ; sum := 0 ;
    var flag : boolean ; flag := false ;
        var $ : int ; $ := 0 ; while $ < text->size() do ( (     cards[$+1] := (text[$+1])->toInteger() ; 
     if (cards[0+1] = 0) then (     flag := true ; 
     break ) else skip ; 
     if (cards[$+1] = 1) then (     one := true ; 
     sum := sum + 1 ) else     if (cards[$+1] >= 10 & cards[$+1] <= 13) then (     sum := sum+(10) ) else (     sum := sum+(cards[$+1]) ) ;  )  ;     $ := $ + 1 ) ; 
    if (flag) then (     break ) else skip ; 
    if (one) then (     if (sum + 10 <= 21) then (     sum := sum+(10) ) else skip ) else skip ; 
    if (sum > 21) then (     sum := 0 ) else skip ; 
    OclFile["System.out"].println(sum) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.regex.*;
import static java.lang.Math.*;
import static java.lang.System.out ;
public class Main {
  final Scanner sc=new Scanner(System.in);
  final int[] vx={
    0,1,0,-1 },vy={
-1,0,1,0 };
      static class Point {
        int x,y ;
        Point(int x,int y){
          this.x=x ;
          this.y=y ;
        }
        Point(){
          this.x=0 ;
          this.y=0 ;
        }
        @ Override public String toString(){
          return "("+this.x+","+this.y+")" ;
        }
        static boolean ok(int x,int y,int X,int Y,int min){
          return(min<=x && x<X)&&(min<=y && y<Y);
        }
        static boolean ok(int x,int y,int X,int Y){
          return ok(x,y,X,Y,0);
        }
      }
      public static void main(String[] args){
        new Main().AOJ0169();
      }
      void AOJ0169(){
        while(sc.hasNext()){
          String[] s=sc.nextLine().split(" ");
          if(s[0] .equals("0"))break ;
          int ans=0,c=0 ;
          for(String i : s){
            c+=(i.equals("1")? 1 : 0);
            ans+=solve0169(i);
          }
          while(--c>=0){
            if(ans+10>21)break ;
            ans+=10 ;
          }
          out.println((ans<=21 ? ans : 0));
        }
      }
      int solve0169(String s){
        int r=Integer.parseInt(s);
        if(r>=10)return 10 ;
        return r ;
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute vx : Sequence(int) := Sequence{0,1,0,-1};
  static class Point {
   attribute x : int;
   static operation newPoint( x : int, y : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   static operation newPoint() : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.x := 0 ; 
     self.y := 0 );
      operation toString() : String
  pre: true
  post: true
  activity: (     return "(" + self.x + "," + self.y + ")" );
  static   operation ok( x : int, y : int, X : int, Y : int, min : int) : boolean
  pre: true
  post: true
  activity: (     return (min <= x & x < X) & (min <= y & y < Y) );
  static   operation ok( x : int, y : int, X : int, Y : int) : boolean
  pre: true
  post: true
  activity: (     return ok(x, y, X, Y, 0) );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().AOJ0169() );
   operation AOJ0169() : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     var s : Sequence(String) ; s := sc.nextLine()->split(" ") ;
     if (s[0+1] = "0") then     break else skip ; 
    var ans : int ; ans := 0 ;
    var c : int ; c := 0 ;
    for (i : s) do ( (     c := c+((if i = "1" then 1 else 0 endif)) ; 
     ans := ans+(solve0169(i)) )  ) ; 
        c := c - 1 ;
    while ((c - 1) >= 0) do (        c := c - 1 ;     skip ; (     if (ans + 10 > 21) then     break else skip ; 
     ans := ans+(10) ) ;     c := c - 1 ;
 ) ;  
    out.println((if ans <= 21 then ans else 0 endif)) ; 
 ) );
   operation solve0169( s : String) : int
  pre: true
  post: true
  activity: (     var r : int ; r := (s)->toInteger() ;
     if (r >= 10) then     return 10 else skip ; 
     return r );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class Main {
  Scanner sc ;
  int solve(ArrayList<Integer>cards){
    int ace=0 ;
    int point=0 ;
    for(int card : cards){
      point+=card>10 ? 10 : card ;
      ace+=card==1 ? 1 : 0 ;
    }
    for(; point<=11 && ace>0 ; --ace){
      point+=10 ;
    }
    return point<=21 ? point : 0 ;
  }
  String ns(){
    return sc.nextLine();
  }
  void io(){
    sc=new Scanner(System.in);
    while(true){
      StringTokenizer tok=new StringTokenizer(ns());
      ArrayList<Integer>cards=new ArrayList<Integer>();
      while(tok.hasMoreTokens()){
        cards.add(Integer.parseInt(tok.nextToken()));
      }
      if(cards.size()==1 && cards.get(0)==0)break ;
      System.out.println(solve(cards));
    }
    sc.close();
  }
  public static void main(String[] args){
    new Main().io();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   operation solve( cards : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var ace : int ; ace := 0 ;
     var point : int ; point := 0 ;
    for (card : cards) do ( (     point := point+(if card > 10 then 10 else card endif) ; 
     ace := ace+(if card = 1 then 1 else 0 endif) )  ) ; 
      while point <= 11 & ace > 0 do ( (     point := point+(10) )  ;     ace := ace - 1 ) ; 
    return if point <= 21 then point else 0 endif 
 );
   operation ns() : String
  pre: true
  post: true
  activity: (     return sc.nextLine() );
   operation io() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     while (true) do (     var tok : OclIterator ; tok := OclIterator.newOclIterator_String(ns()) ;
     var cards : Sequence(int) ; cards := Sequence{} ;
    while (tok.hasNext()) do (     cards := cards->including((tok.next())->toInteger()) ) ; 
    if (cards->size() = 1 & cards->at(0+1) = 0) then     break else skip ; 
    OclFile["System.out"].println(solve(cards)) ; 
 ) ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().io() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      String[] ss=sc.nextLine().split(" ");
      if(ss.length==1 && ss[0] .equals("0"))break ;
      int[] as=new int[ss.length];
      for(int i=0 ; i<ss.length ; i++){
        as[i]=Integer.parseInt(ss[i]);
      }
      Arrays.sort(as);
      int ans=0 ;
      int one=0 ;
      for(int x : as){
        if(x==1){
          ans+=1 ;
          one++;
        }
        else if(x>=10){
          ans+=10 ;
        }
        else {
          ans+=x ;
        }
      }
      for(int i=0 ; i<one ; i++){
        if(ans+10<=21)ans+=10 ;
      }
      if(ans>21)ans=0 ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var ss : Sequence(String) ; ss := sc.nextLine()->split(" ") ;
     if (ss->size() = 1 & ss[0+1] = "0") then     break else skip ; 
    var as : Sequence(int) ; as := Integer.subrange(1,ss->size())->collect(0) ;
        var i : int ; i := 0 ; while i < ss->size() do ( (     as[i+1] := (ss[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    as := as->sort() ; 
    var ans : int ; ans := 0 ;
    var one : int ; one := 0 ;
    for (x : as) do ( (     if (x = 1) then (     ans := ans+(1) ; 
     one := one + 1 ) else     if (x >= 10) then (     ans := ans+(10) ) else (     ans := ans+(x) ) ;  )  ) ; 
        var i : int ; i := 0 ; while i < one do ( (     if (ans + 10 <= 21) then     ans := ans+(10) ; else skip )  ;     i := i + 1 ) ; 
    if (ans > 21) then     ans := 0 ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner sc=new Scanner(System.in);
    String ph=new String();
    while(sc.hasNext()){
      ph=sc.nextLine();
      if(ph.equals("0"))break ;
      System.out.printf("%d\n",CalcScore(ph));
    }
  }
  public static int CalcScore(String dk){
    int[] score={
      0,11,2,3,4,5,6,7,8,9,10,10,10,10 };
      int max=0 ;
      int min=0 ;
      String[] plh=new String[5];
      ArrayList<Integer>ph=new ArrayList<Integer>();
      int cntAce=0 ;
      plh=dk.split(" ");
      for(String s : plh){
        ph.add(Integer.parseInt(s));
        if(Integer.parseInt(s)==1){
++cntAce ;
        }
      }
      for(int cd : ph){
        max+=score[cd];
        if(cd==1){
          min+=1 ;
        }
        else {
          min+=score[cd];
        }
      }
      int tmp=min ;
      for(int i=0 ; i<cntAce ; i++){
        tmp+=10 ;
        if(tmp>21){
          break ;
        }
        else {
          min=tmp ;
        }
      }
      if(max>21)max=0 ;
      if(min>21)min=0 ;
      return Math.max(max,min);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ph : String ; ph := StringLib.newString() ;
     while (sc.hasNext()) do (     ph := sc.nextLine() ; 
     if (ph = "0") then     break else skip ; 
     OclFile["System.out"].printf("%d\n", CalcScore(ph)) ) );
  static   operation CalcScore( dk : String) : int
  pre: true
  post: true
  activity: (     var score : Sequence(int) ; score := Sequence{0,11,2,3,4,5,6,7,8,9,10,10,10,10} ;
     var max : int ; max := 0 ;
    var min : int ; min := 0 ;
    var plh : Sequence(String) ; plh := Integer.subrange(1,5)->collect(null) ;
    var ph : Sequence(int) ; ph := Sequence{} ;
    var cntAce : int ; cntAce := 0 ;
    plh := dk->split(" ") ; 
    for (s : plh) do ( (     ph := ph->including((s)->toInteger()) ; 
     if ((s)->toInteger() = 1) then (     cntAce := cntAce + 1 ) else skip )  ) ; 
    for (cd : ph) do ( (     max := max+(score[cd+1]) ; 
     if (cd = 1) then (     min := min+(1) ) else (     min := min+(score[cd+1]) ) )  ) ; 
    var tmp : int ; tmp := min ;
        var i : int ; i := 0 ; while i < cntAce do ( (     tmp := tmp+(10) ; 
     if (tmp > 21) then (     break ) else (     min := tmp ) )  ;     i := i + 1 ) ; 
    if (max > 21) then     max := 0 ; else skip ; 
    if (min > 21) then     min := 0 ; else skip ; 
    return Set{max, min}->max() 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    int z=sc.nextInt();
    x-=z ;
    System.out.println(x/(y+z));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var z : int ; z := sc.getCurrent()->toInteger() ;
    x := x-(z) ; 
    OclFile["System.out"].println(x / (y + z)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(1,in,out);
    out.close();
  }
  static class Task {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int X=in.nextInt();
      int Y=in.nextInt();
      int Z=in.nextInt();
      int ans=0 ;
      if(X>=Y+2*Z){
        X-=Z ;
        ans=X/(Y+Z);
      }
      out.println(ans);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var X : int ; X := in.nextInt() ;
     var Y : int ; Y := in.nextInt() ;
    var Z : int ; Z := in.nextInt() ;
    var ans : int ; ans := 0 ;
    if (X >= Y + 2 * Z) then (     X := X-(Z) ; 
     ans := X / (Y + Z) ) else skip ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in))){
      final String s=reader.readLine();
      final String[] sl=s.split(" ");
      int X=Integer.parseInt(sl[0]);
      int Y=Integer.parseInt(sl[1]);
      int Z=Integer.parseInt(sl[2]);
      int ans=0 ;
      for(int i=0 ; i<=100000 ; i++){
        if(X<i*Y+(i+1)*Z)break ;
        ans=i ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var s : String ; s := reader.readLine() ;
     var sl : Sequence(String) ; sl := s->split(" ") ;
    var X : int ; X := (sl[0+1])->toInteger() ;
    var Y : int ; Y := (sl[1+1])->toInteger() ;
    var Z : int ; Z := (sl[2+1])->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i <= 100000 do ( (     if (X < i * Y + (i + 1) * Z) then     break else skip ; 
     ans := i )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.nio.charset.StandardCharsets ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader reader=new InputStreamReader(System.in,StandardCharsets.UTF_8);
    BufferedReader in=new BufferedReader(reader);
    String[] tokens=in.readLine().split(" ");
    int X=Integer.parseInt(tokens[0]);
    int Y=Integer.parseInt(tokens[1]);
    int Z=Integer.parseInt(tokens[2]);
    X-=Z ;
    int result=X/(Y+Z);
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"], StandardCharsets.UTF_8) ;
     var in : OclFile ; in := OclFile.newOclFile_Read(reader) ;
    var tokens : Sequence(String) ; tokens := in.readLine()->split(" ") ;
    var X : int ; X := (tokens[0+1])->toInteger() ;
    var Y : int ; Y := (tokens[1+1])->toInteger() ;
    var Z : int ; Z := (tokens[2+1])->toInteger() ;
    X := X-(Z) ; 
    var result : int ; result := X / (Y + Z) ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    BigInteger a=new BigInteger(sc.next());
    BigInteger b=new BigInteger(sc.next());
    if(a.equals(b)){
      System.out.println("EQUAL");
    }
    else if(a.compareTo(b)>0){
      System.out.println("GREATER");
    }
    else {
      System.out.println("LESS");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := long(sc.getCurrent()) ;
     var b : long ; b := long(sc.getCurrent()) ;
     if (a = b) then (     OclFile["System.out"].println("EQUAL") ) else     if (a->compareTo(b) > 0) then (     OclFile["System.out"].println("GREATER") ) else (     OclFile["System.out"].println("LESS") ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    B solver=new B();
    solver.solve(1,in,out);
    out.close();
  }
  static class B {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int x=Integer.parseInt(in.next());
      int y=Integer.parseInt(in.next());
      int z=Integer.parseInt(in.next());
      int ans=0 ;
      int tmp=x/(y+z);
      if(x %(y+z)==0){
        out.println(tmp-1);
      }
      else {
        if(x-tmp*(y+z)>=z){
          out.println(x/(y+z));
        }
        else {
          out.println(tmp-1);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : B ; solver := B.newB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class B {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var x : int ; x := (in.getCurrent())->toInteger() ;
     var y : int ; y := (in.getCurrent())->toInteger() ;
    var z : int ; z := (in.getCurrent())->toInteger() ;
    var ans : int ; ans := 0 ;
    var tmp : int ; tmp := x / (y + z) ;
    if (x mod (y + z) = 0) then (     skip ) else (     if (x - tmp * (y + z) >= z) then (     skip ) else (     skip ) ) ;  
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int mod=100000 ;
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    int[] map=new int[n];
    int sum=0 ;
    for(int i=1 ; i<n ; i++){
      sum+=scanner.nextInt();
      map[i]=sum ;
    }
    int ans=0 ;
    int index=0 ;
    int now=0 ;
    while(m-->0){
      index+=scanner.nextInt();
      ans+=Math.abs(map[index]-now);
      ans %=mod ;
      now=map[index];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var mod : int ; mod := 100000 ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var map : Sequence(int) ; map := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     sum := sum+(scanner.getCurrent()->toInteger()) ; 
     map[i+1] := sum )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var index : int ; index := 0 ;
    var now : int ; now := 0 ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     index := index+(scanner.getCurrent()->toInteger()) ; 
     ans := ans+(if map[index+1] - now < 0 then -(map[index+1] - now) else map[index+1] - now endif) ; 
     ans := ans mod mod ; 
     now := map[index+1] ) ;  ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Random ;
import java.util.Deque ;
import java.util.LinkedList ;
public class CF78_D2_B {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    char[] colors={
      'R','O','Y','G','B','I','V' };
      Deque<Character>space=new LinkedList<>();
      int n=scanner.nextInt();
      char[] arr={
        'G','B','I','V' };
        System.out.print("ROYGBIV");
        n-=7 ;
        for(int i=0 ; i<n ; i++){
          System.out.print(arr[i % 4]);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class CF78_D2_B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var colors : Sequence(String) ; colors := Sequence{'R','O','Y','G','B','I','V'} ;
    var space : Sequence(String) ; space := Sequence{} ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := Sequence{'G','B','I','V'} ;
    OclFile["System.out"].print("ROYGBIV") ; 
    n := n-(7) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i mod 4+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char arr[]=new char[7];
    arr[0]='R' ;
    arr[1]='O' ;
    arr[2]='Y' ;
    arr[3]='G' ;
    arr[4]='B' ;
    arr[5]='I' ;
    arr[6]='V' ;
    String ans="" ;
    int count=1 ;
    int val=0 ;
    int length=0 ;
    for(int i=0 ; i<n ; i++){
      ans+=arr[length % 7];
      length++;
      if(length==7){
        length-=4 ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := Integer.subrange(1,7)->collect(0) ;
    arr[0+1] := 'R' ; 
    arr[1+1] := 'O' ; 
    arr[2+1] := 'Y' ; 
    arr[3+1] := 'G' ; 
    arr[4+1] := 'B' ; 
    arr[5+1] := 'I' ; 
    arr[6+1] := 'V' ; 
    var ans : String ; ans := "" ;
    var count : int ; count := 1 ;
    var val : int ; val := 0 ;
    var length : int ; length := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans+(arr[length mod 7+1]) ; 
     length := length + 1 ; 
     if (length = 7) then (     length := length-(4) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String x="ROYGBIV" ;
    char[] m=new char[] {
      'R','O','Y','G','B','I','V' };
      while(x.length()<n){
        x+=x.charAt(x.length()-4);
      }
      System.out.println(x);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var x : String ; x := "ROYGBIV" ;
    var m : Sequence(String) ; m := Sequence{'R','O','Y','G','B','I','V'} ;
    while (x->size() < n) do (     x := x+(x->at(x->size() - 4+1)) ) ; 
    OclFile["System.out"].println(x) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    String str="" ;
    int index=0 ;
    Character[] arr=new Character[7];
    arr[0]='R' ;
    arr[1]='O' ;
    arr[2]='Y' ;
    arr[3]='G' ;
    arr[4]='B' ;
    arr[5]='I' ;
    arr[6]='V' ;
    while(n-->0){
      str+=arr[index++];
      if(index==7)index=3 ;
    }
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var str : String ; str := "" ;
    var index : int ; index := 0 ;
    var arr : Sequence(String) ; arr := Integer.subrange(1,7)->collect(null) ;
    arr[0+1] := 'R' ; 
    arr[1+1] := 'O' ; 
    arr[2+1] := 'Y' ; 
    arr[3+1] := 'G' ; 
    arr[4+1] := 'B' ; 
    arr[5+1] := 'I' ; 
    arr[6+1] := 'V' ; 
        while (n > 0) do (        n := n - 1 ;     skip ; (      str := str + arr[index+1]  ; index := index + 1 ; 
     if (index = 7) then     index := 3 ; else skip ) ;  ) ;  
    OclFile["System.out"].println(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF78_D2_B {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    char[] colors={
      'R','O','Y','G','B','I','V' };
      int n=scanner.nextInt();
      char[] arr={
        'G','B','I','V' };
        System.out.print("ROYGBIV");
        n-=7 ;
        for(int i=0 ; i<n ; i++){
          System.out.print(arr[i % 4]);
        }
        scanner.close();
      }
    }

------------------------------------------------------------
OCL File:
---------
 class CF78_D2_B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var colors : Sequence(String) ; colors := Sequence{'R','O','Y','G','B','I','V'} ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := Sequence{'G','B','I','V'} ;
    OclFile["System.out"].print("ROYGBIV") ; 
    n := n-(7) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i mod 4+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Queue<Integer>reverse(Queue<Integer>q){
    int s=q.size();
    Queue<Integer>ans=new LinkedList<>();
    for(int i=0 ; i<s ; i++){
      for(int j=0 ; j<q.size()-1 ; j++){
        int x=q.peek();
        q.remove();
        q.add(x);
      }
      ans.add(q.peek());
      q.remove();
    }
    return ans ;
  }
  public static void main(String[] args){
    Queue<Integer>q=new LinkedList<>();
    q.add(1);
    q.add(2);
    q.add(3);
    q.add(4);
    q.add(5);
    q=reverse(q);
    while(! q.isEmpty()){
      System.out.print(q.peek()+" ");
      q.remove();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation reverse( q : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var s : int ; s := q->size() ;
     var ans : Sequence(int) ; ans := Sequence{} ;
         var i : int ; i := 0 ; while i < s do ( (         var j : int ; j := 0 ; while j < q->size() - 1 do ( (     var x : int ; x := q->min() ;
     q := q.remove() ; 
     q->excludes(x) )  ;     j := j + 1 ) ; 
     ans := ans->including(q->min()) ; 
     q := q.remove() )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var q : Sequence(int) ; q := Sequence{} ;
     q := q->including(1) ; 
    q := q->including(2) ; 
    q := q->including(3) ; 
    q := q->including(4) ; 
    q := q->including(5) ; 
    q := reverse(q) ; 
    while (not(q->isEmpty())) do (     OclFile["System.out"].print(q->min() + " ") ; 
     q := q.remove() ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long h=sc.nextInt();
    long w=sc.nextInt();
    long s=sc.nextInt();
    long t=sc.nextInt();
    if(h*w % 2==1 &&(s*w+t)% 2==1){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : long ; h := sc.getCurrent()->toInteger() ;
    var w : long ; w := sc.getCurrent()->toInteger() ;
    var s : long ; s := sc.getCurrent()->toInteger() ;
    var t : long ; t := sc.getCurrent()->toInteger() ;
    if (h * w mod 2 = 1 & (s * w + t) mod 2 = 1) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    int x=sc.nextInt();
    int y=sc.nextInt();
    if(h*w % 2==1 &&(x+y)% 2==1){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    if (h * w mod 2 = 1 & (x + y) mod 2 = 1) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String a=sc.next();
    String b=sc.next();
    String ans="" ;
    if(a.length()>b.length()){
      System.out.println("GREATER");
      return ;
    }
    else if(a.length()<b.length()){
      System.out.println("LESS");
      return ;
    }
    else {
      for(int i=0 ; i<a.length(); i++){
        int an=Character.getNumericValue(a.charAt(i));
        int bn=Character.getNumericValue(b.charAt(i));
        if(an>bn){
          System.out.println("GREATER");
          return ;
        }
        else if(an<bn){
          System.out.println("LESS");
          return ;
        }
      }
    }
    System.out.println("EQUAL");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := sc.getCurrent() ;
    var b : String ; b := sc.getCurrent() ;
    var ans : String ; ans := "" ;
    if (a->size() > b->size()) then (     OclFile["System.out"].println("GREATER") ; 
     return ) else     if (a->size() < b->size()) then (     OclFile["System.out"].println("LESS") ; 
     return ) else (         var i : int ; i := 0 ; while i < a->size() do ( (     var an : int ; an := ("" + a->at(i+1))->toInteger() ;
     var bn : int ; bn := ("" + b->at(i+1))->toInteger() ;
     if (an > bn) then (     OclFile["System.out"].println("GREATER") ; 
     return ) else     if (an < bn) then (     OclFile["System.out"].println("LESS") ; 
     return ) else skip ; )  ;     i := i + 1 ) ) ;  ;  
    OclFile["System.out"].println("EQUAL") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Nth {
  public static int nthTerm(int N){
    return N*N+(N+1)*(N+1);
  }
  public static void main(String[] args){
    int N=3 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Nth {
  static   operation nthTerm( N : int) : int
  pre: true
  post: true
  activity: (     return N * N + (N + 1) * (N + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
     OclFile["System.out"].println(nthTerm(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printModulus(int X,int Y){
    int d=Math.abs(X-Y);
    int i=1 ;
    while(i*i<=d){
      if(d % i==0){
        System.out.print(i+" ");
        if(d/i!=i)System.out.print(d/i+" ");
      }
      i++;
    }
  }
  public static void main(String[] args){
    int X=10 ;
    int Y=26 ;
    printModulus(X,Y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printModulus( X : int, Y : int) : void
  pre: true
  post: true
  activity: (     var d : int ; d := if X - Y < 0 then -(X - Y) else X - Y endif ;
     var i : int ; i := 1 ;
     while (i * i <= d) do (     if (d mod i = 0) then (     OclFile["System.out"].print(i + " ") ; 
     if (d / i /= i) then     OclFile["System.out"].print(d / i + " ") ; else skip ) else skip ; 
     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 10 ;
     var Y : int ; Y := 26 ;
     execute printModulus(X, Y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    int n=sc.nextInt()-1 ;
    int m=sc.nextInt();
    long s[]=new long[n+1];
    for(int i=0 ; i<n ; i++){
      s[i+1]=s[i]+sc.nextInt();
    }
    int p=0 ;
    long ans=0 ;
    for(int i=0 ; i<m ; i++){
      int p2=sc.nextInt();
      ans+=Math.abs(s[p2+p]-s[p]);
      p=p+p2 ;
    }
    System.out.println(ans % 100000);
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() - 1 ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var s : Sequence(long) ; s := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i + 1+1] := s[i+1] + sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var p : int ; p := 0 ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var p2 : int ; p2 := sc.getCurrent()->toInteger() ;
     ans := ans+(if s[p2 + p+1] - s[p+1] < 0 then -(s[p2 + p+1] - s[p+1]) else s[p2 + p+1] - s[p+1] endif) ; 
     p := p + p2 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans mod 100000) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public List<String>ipToCIDR(String ip,int n){
    long start=ipToLong(ip);
    List<String>ans=new ArrayList();
    while(n>0){
      int mask=Math.max(33-bitLength(Long.lowestOneBit(start)),33-bitLength(n));
      ans.add(longToIP(start)+"/"+mask);
      start+=1<<(32-mask);
      n-=1<<(32-mask);
    }
    return ans ;
  }
  private long ipToLong(String ip){
    long ans=0 ;
    for(String x : ip.split("\\.")){
      ans=256*ans+Integer.valueOf(x);
    }
    return ans ;
  }
  private String longToIP(long x){
    return String.format("%s.%s.%s.%s",x>>24,(x>>16)% 256,(x>>8)% 256,x % 256);
  }
  private int bitLength(long x){
    if(x==0)return 1 ;
    int ans=0 ;
    while(x>0){
      x>>=1 ;
      ans++;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation ipToCIDR( ip : String, n : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var start : long ; start := ipToLong(ip) ;
     var ans : Sequence(String) ; ans := Sequence{} ;
     while (n > 0) do (     var mask : int ; mask := Set{33 - bitLength(lowestOneBit(start)), 33 - bitLength(n)}->max() ;
     ans := ans->including(longToIP(start) + "/" + mask) ; 
     start := start+((1*(2->pow((32 - mask))))->oclAsType(long)) ; 
     n := n-((1*(2->pow((32 - mask))))->oclAsType(long)) ) ; 
     return ans );
   operation ipToLong( ip : String) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
     for (x : ip->split("\\.")) do ( (     ans := 256 * ans + (x)->toInteger() )  ) ; 
     return ans );
   operation longToIP( x : long) : String
  pre: true
  post: true
  activity: (     return StringLib.format("%s.%s.%s.%s",Sequence{(x/(2->pow(24)))->oclAsType(long),((x/(2->pow(16)))->oclAsType(long)) mod 256,((x/(2->pow(8)))->oclAsType(long)) mod 256,x mod 256}) );
   operation bitLength( x : long) : int
  pre: true
  post: true
  activity: (     if (x = 0) then     return 1 else skip ; 
     var ans : int ; ans := 0 ;
     while (x > 0) do (     x := x/(2->pow(1)) ; 
     ans := ans + 1 ) ; 
     return ans );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean ispalindrome(String s){
    int l=s.length();
    for(int i=0,j=l-1 ; i<=j ; i++,j--){
      if(s.charAt(i)!=s.charAt(j)){
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    String s="BABABAA" ;
    int cnt=0 ;
    int flag=0 ;
    while(s.length()>0){
      if(ispalindrome(s)){
        flag=1 ;
        break ;
      }
      else {
        cnt++;
        s=s.substring(0,s.length()-1);
      }
    }
    if(flag==1){
      System.out.println(cnt);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation ispalindrome( s : String) : boolean
  pre: true
  post: true
  activity: (     var l : int ; l := s->size() ;
         var i : int ; i := 0 ;
    var j : int ; j := l - 1 ; while i <= j do ( (     if (s->at(i+1) /= s->at(j+1)) then (     return false ) else skip )  ;     i := i + 1 ;     j := j - 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "BABABAA" ;
     var cnt : int ; cnt := 0 ;
    var flag : int ; flag := 0 ;
    while (s->size() > 0) do (     if (ispalindrome(s)) then (     flag := 1 ; 
     break ) else (     cnt := cnt + 1 ; 
     s := s.subrange(0+1,s->size() - 1) ) ) ; 
    if (flag = 1) then (     OclFile["System.out"].println(cnt) ) else skip ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.io.*;
import java.util.*;
class GFG {
  static char reVal(int num){
    if(num>=0 && num<=9)return(char)(num+48);
    else return(char)(num-10+65);
  }
  static String fromDeci(int base1,int inputNum){
    String s="" ;
    while(inputNum>0){
      s+=reVal(inputNum % base1);
      inputNum/=base1 ;
    }
    StringBuilder ix=new StringBuilder();
    ix.append(s);
    return new String(ix.reverse());
  }
  public static void main(String[] args){
    int inputNum=282,base1=16 ;
    System.out.println("Equivalent of "+inputNum+" in base "+base1+" is "+fromDeci(base1,inputNum));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation reVal( num : int) : String
  pre: true
  post: true
  activity: (     if (num >= 0 & num <= 9) then     return (num + 48)->oclAsType(String) else     return (num - 10 + 65)->oclAsType(String) );
  static   operation fromDeci( base1 : int, inputNum : int) : String
  pre: true
  post: true
  activity: (     var s : String ; s := "" ;
     while (inputNum > 0) do (     s := s+(reVal(inputNum mod base1)) ; 
     inputNum := inputNum/(base1) ) ; 
    var ix : String ; ix := StringLib.newString() ;
    ix := ix + StringLib.newString(s) ; 
    return StringLib.newString(ix->reverse()) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputNum : int ; inputNum := 282 ;
    var base1 : int ; base1 := 16 ;
     OclFile["System.out"].println("Equivalent of " + inputNum + " in base " + base1 + " is " + fromDeci(base1, inputNum)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String X,Y ;
  static int lcs(int i,int j,int count){
    if(i==0 || j==0){
      return count ;
    }
    if(X.charAt(i-1)==Y.charAt(j-1)){
      count=lcs(i-1,j-1,count+1);
    }
    count=Math.max(count,Math.max(lcs(i,j-1,0),lcs(i-1,j,0)));
    return count ;
  }
  public static void main(String[] args){
    int n,m ;
    X="abcdxyz" ;
    Y="xyzabcd" ;
    n=X.length();
    m=Y.length();
    System.out.println(lcs(n,m,0));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute X : String;
  static   operation lcs( i : int, j : int, count : int) : int
  pre: true
  post: true
  activity: (     if (i = 0 or j = 0) then (     return count ) else skip ; 
     if (X->at(i - 1+1) = Y->at(j - 1+1)) then (     count := lcs(i - 1, j - 1, count + 1) ) else skip ; 
     count := Set{count, Set{lcs(i, j - 1, 0), lcs(i - 1, j, 0)}->max()}->max() ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var m : int ;
     X := "abcdxyz" ; 
    Y := "xyzabcd" ; 
    n := X->size() ; 
    m := Y->size() ; 
    OclFile["System.out"].println(lcs(n, m, 0)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    StringBuilder sb=new StringBuilder();
    while(q-->0){
      long a=sc.nextLong();
      long b=sc.nextLong();
      sb.append(solve(a,b));
      sb.append("\n");
    }
    System.out.print(sb.toString());
  }
  private static long solve(long a,long b){
    if(a==b)return 2*(a-1);
    if(a>b){
      long t=a ;
      a=b ;
      b=t ;
    }
    long l=0 ;
    long r=b-1 ;
    while(r>l){
      long m=(l+r+1)/2 ;
      long l2=0 ;
      long r2=m ;
      while(r2-l2>1){
        long m2=(l2+r2)/2 ;
        if((m-(m2-1))*(a+m2)<=(m-(m2))*(a+1+m2)){
          l2=m2 ;
        }
        else {
          r2=m2 ;
        }
      }
      if((m-l2)*(a+1+l2)<a*b){
        l=m ;
      }
      else {
        r=m-1 ;
      }
    }
    return(a-1)+l ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
     sb := sb + StringLib.newString(solve(a, b)) ; 
     sb := sb + StringLib.newString("\n") ) ;  ) ;  
    OclFile["System.out"].print(sb+"") ; 
 );
  static   operation solve( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = b) then     return 2 * ((a)->char2byte() - 1) else skip ; 
     if (a > b) then (     var t : long ; t := a ;
     a := b ; 
     b := t ) else skip ; 
    var l : long ; l := 0 ;
    var r : long ; r := b - 1 ;
    while (r > l) do (     var m : long ; m := (l + r + 1) / 2 ;
     var l2 : long ; l2 := 0 ;
    var r2 : long ; r2 := m ;
    while (r2 - l2 > 1) do (     var m2 : long ; m2 := (l2 + r2) / 2 ;
     if ((m - (m2 - 1)) * (a + m2) <= (m - (m2)) * (a + 1 + m2)) then (     l2 := m2 ) else (     r2 := m2 ) ) ; 
    if ((m - l2) * (a + 1 + l2) < a * b) then (     l := m ) else (     r := m - 1 ) ;  
 ) ; 
    return ((a)->char2byte() - 1) + l 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String args[]){
    FastReader sc=new FastReader();
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      long a=sc.nextLong();
      long b=sc.nextLong();
      if(a>b){
        long temp=a ;
        a=b ;
        b=temp ;
      }
      long sol=a-1 ;
      long lo=0 ;
      long hi=b-1 ;
      while(lo<hi){
        long mi=(lo+hi+1)/2 ;
        long low=0 ;
        long high=mi-1 ;
        while(low<high){
          long mid=(low+high)/2 ;
          if((mi-mid)*(a+1+mid)>(mi-(mid+1))*(a+2+mid)){
            high=mid ;
          }
          else {
            low=mid+1 ;
          }
        }
        if((mi-low)*(a+1+low)<a*b){
          lo=mi ;
        }
        else {
          hi=mi-1 ;
        }
      }
      System.out.println(sol+lo);
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var q : int ; q := sc.nextInt() ;
         var i : int ; i := 0 ; while i < q do ( (     var a : long ; a := sc.nextLong() ;
     var b : long ; b := sc.nextLong() ;
    if (a > b) then (     var temp : long ; temp := a ;
     a := b ; 
     b := temp ) else skip ; 
    var sol : long ; sol := a - 1 ;
    var lo : long ; lo := 0 ;
    var hi : long ; hi := b - 1 ;
    while (lo < hi) do (     var mi : long ; mi := (lo + hi + 1) / 2 ;
     var low : long ; low := 0 ;
    var high : long ; high := mi - 1 ;
    while (low < high) do (     var mid : long ; mid := (low + high) / 2 ;
     if ((mi - mid) * (a + 1 + mid) > (mi - (mid + 1)) * (a + 2 + mid)) then (     high := mid ) else (     low := mid + 1 ) ) ; 
    if ((mi - low) * (a + 1 + low) < a * b) then (     lo := mi ) else (     hi := mi - 1 ) ;  
 ) ; 
    OclFile["System.out"].println(sol + lo) ; 
 )  ;     i := i + 1 ) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int q=Integer.parseInt(br.readLine());
    for(int i=0 ; i<q ; i++){
      String[] sa=br.readLine().split(" ");
      int a=Integer.parseInt(sa[0]);
      int b=Integer.parseInt(sa[1]);
      long x=Math.min(a,b);
      long y=Math.max(a,b);
      long xy=x*y ;
      if(y-x<=1){
        System.out.println((x-1)*2);
      }
      else {
        long ans=(x-1)*2 ;
        long start=(long)(Math.sqrt(xy))+10 ;
        start=start+start-x ;
        for(long r=start ; r>x ; r--){
          long d=r-x ;
          if(d % 2==0){
            long m=(x+r)/2 ;
            if(m*m<xy){
              ans+=r-x ;
              break ;
            }
          }
          else {
            long m=(x+r)/2 ;
            if(m*(m+1)<xy){
              ans+=r-x ;
              break ;
            }
          }
        }
        System.out.println(ans);
      }
    }
    br.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var q : int ; q := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < q do ( (     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
     var a : int ; a := (sa[0+1])->toInteger() ;
    var b : int ; b := (sa[1+1])->toInteger() ;
    var x : long ; x := Set{a, b}->min() ;
    var y : long ; y := Set{a, b}->max() ;
    var xy : long ; xy := x * y ;
    if (y - x <= 1) then (     OclFile["System.out"].println((x - 1) * 2) ) else (     var ans : long ; ans := (x - 1) * 2 ;
     var start : long ; start := ((xy)->sqrt())->oclAsType(long) + 10 ;
    start := start + start - x ; 
        var r : long ; r := start ; while r > x do ( (     var d : long ; d := r - x ;
     if (d mod 2 = 0) then (     var m : long ; m := (x + r) / 2 ;
     if (m * m < xy) then (     ans := ans+(r - x) ; 
     break ) else skip ) else (     var m : long ; m := (x + r) / 2 ;
     if (m * (m + 1) < xy) then (     ans := ans+(r - x) ; 
     break ) else skip ) )  ;     r := r - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  
 )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int calculateAreaSum(int l,int b){
    int size=1 ;
    int maxSize=Math.min(l,b);
    int totalArea=0 ;
    for(int i=1 ; i<=maxSize ; i++){
      int totalSquares=(l-size+1)*(b-size+1);
      int area=totalSquares*size*size ;
      totalArea+=area ;
      size++;
    }
    return totalArea ;
  }
  public static void main(String[] args){
    int l=4,b=3 ;
    System.out.println(calculateAreaSum(l,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation calculateAreaSum( l : int, b : int) : int
  pre: true
  post: true
  activity: (     var size : int ; size := 1 ;
     var maxSize : int ; maxSize := Set{l, b}->min() ;
    var totalArea : int ; totalArea := 0 ;
        var i : int ; i := 1 ; while i <= maxSize do ( (     var totalSquares : int ; totalSquares := (l - size + 1) * (b - size + 1) ;
     var area : int ; area := totalSquares * size * size ;
     totalArea := totalArea+(area) ; 
     size := size + 1 )  ;     i := i + 1 ) ; 
    return totalArea 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 4 ;
    var b : int ; b := 3 ;
     OclFile["System.out"].println(calculateAreaSum(l, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int Q=sc.nextInt();
    int[] A=new int[Q];
    int[] B=new int[Q];
    for(int i=0 ; i<Q ; i++){
      A[i]=sc.nextInt();
      B[i]=sc.nextInt();
    }
    for(long ans : solve(Q,A,B)){
      System.out.println(ans);
    }
  }
  private static long[] solve(int Q,int[] A,int[] B){
    long[] ans=new long[Q];
    for(int i=0 ; i<Q ; i++){
      ans[i]=calc(A[i],B[i]);
    }
    return ans ;
  }
  private static long calc(int a,int b){
    if(a==b){
      return calcSquare(a);
    }
    else {
      return calcNormal(a,b);
    }
  }
  private static long calcNormal(int a,int b){
    long ab=(long)a*b ;
    long r=(long)Math.floor(Math.sqrt(ab));
    long q=ab/r ;
    int plusQr=ab>(q*r)? 1 : 0 ;
    return(r-1)+(q-1)+plusQr-1 ;
  }
  private static long calcSquare(int a){
    long r=a-1 ;
    return r*2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var Q : int ; Q := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,Q)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,Q)->collect(0) ;
        var i : int ; i := 0 ; while i < Q do ( (     A[i+1] := sc.getCurrent()->toInteger() ; 
     B[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    for (ans : solve(Q, A, B)) do ( (     OclFile["System.out"].println(ans) )  ) ; 
 );
  static   operation solve( Q : int, A : Sequence(int), B : Sequence(int)) : Sequence(long)
  pre: true
  post: true
  activity: (     var ans : Sequence(long) ; ans := Integer.subrange(1,Q)->collect(0) ;
         var i : int ; i := 0 ; while i < Q do ( (     ans[i+1] := calc(A[i+1], B[i+1]) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation calc( a : int, b : int) : long
  pre: true
  post: true
  activity: (     if (a = b) then (     return calcSquare(a) ) else (     return calcNormal(a, b) ) );
  static   operation calcNormal( a : int, b : int) : long
  pre: true
  post: true
  activity: (     var ab : long ; ab := a->oclAsType(long) * b ;
     var r : long ; r := ((ab)->sqrt())->floor()->oclAsType(long) ;
    var q : long ; q := ab / r ;
    var plusQr : int ; plusQr := if ab > (q * r) then 1 else 0 endif ;
    return (r - 1) + (q - 1) + plusQr - 1 
 );
  static   operation calcSquare( a : int) : long
  pre: true
  post: true
  activity: (     var r : long ; r := a - 1 ;
     return r * 2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    String ls=System.lineSeparator();
    int q=in.nextInt();
    for(int i=0 ; i<q ; i++){
      long a=in.nextLong();
      long b=in.nextLong();
      long m=a*b ;
      long k=(int)Math.sqrt(m);
      if(k*k>=m)k--;
      long sum=0 ;
      if(k*(k+1)>=m)sum+=2*k-1 ;
      else sum+=2*k ;
      if(Math.min(a,b)<=k)sum--;
      sb.append(sum);
      sb.append(ls);
    }
    System.out.println(sb.toString());
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
    var ls : String ; ls := lineSeparator() ;
    var q : int ; q := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var a : long ; a := in.getCurrent()->toLong() ;
     var b : long ; b := in.getCurrent()->toLong() ;
    var m : long ; m := a * b ;
    var k : long ; k := (m)->sqrt()->oclAsType(int) ;
    if (k * k >= m) then     k := k - 1 ; else skip ; 
    var sum : long ; sum := 0 ;
    if (k * (k + 1) >= m) then     sum := sum+(2 * k - 1) else     sum := sum+(2 * k) ; ;  
    if (Set{a, b}->min() <= k) then     sum := sum - 1 ; else skip ; 
    sb := sb + StringLib.newString(sum) ; 
    sb := sb + StringLib.newString(ls) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void generateString(int A,int B){
    String rt="" ;
    while(0<A || 0<B){
      if(A<B){
        if(0<B--){
          rt+=('b');
        }
        if(0<B--){
          rt+=('b');
        }
        if(0<A--){
          rt+=('a');
        }
      }
      else if(B<A){
        if(0<A--){
          rt+=('a');
        }
        if(0<A--){
          rt+=('a');
        }
        if(0<B--){
          rt+=('b');
        }
      }
      else {
        if(0<A--){
          rt+=('a');
        }
        if(0<B--){
          rt+=('b');
        }
      }
    }
    System.out.println(rt);
  }
  public static void main(String[] args){
    int A=2,B=6 ;
    generateString(A,B);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation generateString( A : int, B : int) : void
  pre: true
  post: true
  activity: (     var rt : String ; rt := "" ;
     while (0 < A or 0 < B) do (     if (A < B) then (     if (0 < B) then (     rt := rt+(('b')) ) else skip ; 
     if (0 < B) then (     rt := rt+(('b')) ) else skip ; 
     if (0 < A) then (     rt := rt+(('a')) ) else skip ) else     if (B < A) then (     if (0 < A) then (     rt := rt+(('a')) ) else skip ; 
     if (0 < A) then (     rt := rt+(('a')) ) else skip ; 
     if (0 < B) then (     rt := rt+(('b')) ) else skip ) else (     if (0 < A) then (     rt := rt+(('a')) ) else skip ; 
     if (0 < B) then (     rt := rt+(('b')) ) else skip ) ;  ) ; 
     OclFile["System.out"].println(rt) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 2 ;
    var B : int ; B := 6 ;
     execute generateString(A, B) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  static final int MOD=100000 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n,m ;
      n=parseInt(line.substring(0,line.indexOf(' ')));
      m=parseInt(line.substring(line.indexOf(' ')+1));
      int[] d=new int[n];
      for(int i=1 ; i<=n-1 ; i++){
        d[i]=d[i-1]+Integer.parseInt(br.readLine());
      }
      long sum=0 ;
      int inn=0 ;
      for(int i=0 ; i<m ; i++){
        int _inn=parseInt(br.readLine());
        sum+=Math.abs(d[inn+_inn]-d[inn]);
        sum %=MOD ;
        inn+=_inn ;
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 100000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ;
    var m : int ;
     n := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    m := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 1 ; while i <= n - 1 do ( (     d[i+1] := d[i - 1+1] + (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    var inn : int ; inn := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var _inn : int ; _inn := parseInt(br.readLine()) ;
     sum := sum+(if d[inn + _inn+1] - d[inn+1] < 0 then -(d[inn + _inn+1] - d[inn+1]) else d[inn + _inn+1] - d[inn+1] endif) ; 
     sum := sum mod MOD ; 
     inn := inn+(_inn) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  final boolean DEBUG=true ;
  long d=1000000007l ;
  void run(){
    Scanner scan=new Scanner(System.in);
    StringBuffer sb=new StringBuffer();
    char[] txt=scan.next().toCharArray();
    char[] pat=scan.next().toCharArray();
    int tl=txt.length ;
    int pl=pat.length ;
    if(tl<pl)return ;
    long h=1,p=0,t=0 ;
    for(int i=0 ; i<pl ; i++){
      h=h*d ;
      p=d*p+pat[i];
      t=d*t+txt[i];
    }
    for(int i=0 ; i<=tl-pl ; i++){
      if(p==t)sb.append(i+"\n");
      if(i+pl<tl)t=t*d+txt[i+pl]-txt[i]*h ;
    }
    System.out.print(sb.toString());
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute DEBUG : boolean := true;
   attribute d : long := 1000000007l;
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
    var txt : Sequence(String) ; txt := scan.getCurrent()->characters() ;
    var pat : Sequence(String) ; pat := scan.getCurrent()->characters() ;
    var tl : int ; tl := txt->size() ;
    var pl : int ; pl := pat->size() ;
    if (tl < pl) then     return else skip ; 
    var h : long ; h := 1 ;
    var p : long ; p := 0 ;
    var t : long ; t := 0 ;
        var i : int ; i := 0 ; while i < pl do ( (     h := h * d ; 
     p := d * p + pat[i+1] ; 
     t := d * t + txt[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= tl - pl do ( (     if (p = t) then     sb := sb + StringLib.newString(i + "\n") ; else skip ; 
     if (i + pl < tl) then     t := t * d + txt[i + pl+1] - txt[i+1] * h ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.regex.Matcher ;
import java.util.regex.Pattern ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  public void run(){
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String t=br.readLine();
      String p=br.readLine();
      if(t.length()<p.length())return ;
      boolean soloChar=true ;
      char pHead=p.charAt(0);
      for(char c : p.toCharArray()){
        if(c!=pHead){
          soloChar=false ;
          break ;
        }
      }
      StringBuilder result=new StringBuilder();
      if(soloChar)searchStrSoloChar(t,p,result);
      else searchStr(t,p,result);
      System.out.print(result);
    }
    catch(IOException e){
      System.err.println(e);
    }
  }
  private void searchStr(String txt,String key,StringBuilder buf){
    Pattern ptn=Pattern.compile(key);
    Matcher mch=ptn.matcher(txt);
    for(int i=0 ; mch.find(i); i++){
      i=mch.start();
      buf.append(i).append("\n");
    }
  }
  private void searchStrSoloChar(String txt,String key,StringBuilder buf){
    int max=txt.length()-key.length();
    char kHead=key.charAt(0);
    int first=txt.indexOf(key);
    buf.append(first).append("\n");
    for(int i=first+1 ; i<=max ; i++){
      if(txt.charAt(i+key.length()-1)==kHead){
        buf.append(i).append("\n");
      }
      else {
        i=txt.indexOf(key,i);
        if(i==-1)break ;
        else buf.append(i).append("\n");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var t : String ; t := br.readLine() ;
     var p : String ; p := br.readLine() ;
    if (t->size() < p->size()) then     return else skip ; 
    var soloChar : boolean ; soloChar := true ;
    var pHead : String ; pHead := p->at(0+1) ;
    for (c : p->characters()) do ( (     if (c /= pHead) then (     soloChar := false ; 
     break ) else skip )  ) ; 
    var result : String ; result := StringLib.newString() ;
    if (soloChar) then     execute searchStrSoloChar(t, p, result) else     execute searchStr(t, p, result) ; ;  
    OclFile["System.out"].print(result) ; 
 ))   catch (e : IOException) do (     OclFile["System.err"].println(e) )
  );
   operation searchStr( txt : String, key : String, buf : String) : void
  pre: true
  post: true
  activity: (     var ptn : OclRegex ; ptn := OclRegex.compile(key) ;
     var mch : OclRegex ; mch := ptn.matcher(txt) ;
         var i : int ; i := 0 ; while mch.find(i) do ( (     i := mch.start() ; 
     buf := buf + StringLib.newString(i) + StringLib.newString("\n") )  ;     i := i + 1 ) );
   operation searchStrSoloChar( txt : String, key : String, buf : String) : void
  pre: true
  post: true
  activity: (     var max : int ; max := txt->size() - key->size() ;
     var kHead : String ; kHead := key->at(0+1) ;
    var first : int ; first := txt->indexOf(key)-1 ;
    buf := buf + StringLib.newString(first) + StringLib.newString("\n") ; 
        var i : int ; i := first + 1 ; while i <= max do ( (     if (txt->at(i + key->size() - 1+1) = kHead) then (     buf := buf + StringLib.newString(i) + StringLib.newString("\n") ) else (     i := txt.subrange(i+1)->indexOf(key+"") + i - 1  ; 
     if (i = -1) then     break else     buf := buf + StringLib.newString(i) + StringLib.newString("\n") ; ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str1=sc.next();
    String str2=sc.next();
    PrintWriter pwout=new PrintWriter(System.out);
    for(Integer i : rabinKarp(str2,str1))pwout.println(i);
    pwout.flush();
    return ;
  }
  static ArrayList<Integer>rabinKarp(String str1,String str2){
    ArrayList<Integer>list=new ArrayList<>();
    if(str1.length()>str2.length())return list ;
    final long RADIX=Long.parseUnsignedLong("100000007");
    long t=1,str1hash=0,str2hash=0 ;
    for(int i=0 ; i<str1.length(); i++){
      t*=RADIX ;
      str1hash=str1hash*RADIX+str1.charAt(i);
      str2hash=str2hash*RADIX+str2.charAt(i);
    }
    for(int i=0 ; i+str1.length()<=str2.length(); i++){
      if(str1hash==str2hash)list.add(i);
      if(i+str1.length()<str2.length()){
        str2hash=str2hash*RADIX+str2.charAt(i+str1.length())-str2.charAt(i)*t ;
      }
    }
    return list ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str1 : String ; str1 := sc.getCurrent() ;
    var str2 : String ; str2 := sc.getCurrent() ;
    var pwout : OclFile ; pwout := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    for (i : rabinKarp(str2, str1)) do (     skip ;  ) ; 
    skip ; 
    return 
 );
  static   operation rabinKarp( str1 : String, str2 : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     if (str1->size() > str2->size()) then     return list else skip ; 
    var RADIX : long ; RADIX := parseUnsignedLong("100000007") ;
    var t : long ; t := 1 ;
    var str1hash : long ; str1hash := 0 ;
    var str2hash : long ; str2hash := 0 ;
        var i : int ; i := 0 ; while i < str1->size() do ( (     t := t*(RADIX) ; 
     str1hash := str1hash * RADIX + str1->at(i+1) ; 
     str2hash := str2hash * RADIX + str2->at(i+1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i + str1->size() <= str2->size() do ( (     if (str1hash = str2hash) then     list := list->including(i) ; else skip ; 
     if (i + str1->size() < str2->size()) then (     str2hash := str2hash * RADIX + str2->at(i + str1->size()+1) - str2->at(i+1) * t ) else skip )  ;     i := i + 1 ) ; 
    return list 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  final static int Code=5 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    char[] A,B ;
    A=br.readLine().toCharArray();
    B=br.readLine().toCharArray();
    if(A.length<B.length)return ;
    int t=0 ;
    int p=0 ;
    int BN=search(Code,B.length);
    for(int i=0 ; i<B.length ; i++){
      t=t*Code+A[i];
      p=p*Code+B[i];
    }
    System.out.print(Print(t,p,A,B,BN));
    return ;
  }
  public static int search(int x,int n){
    if(n==0)return 1 ;
    int ret=search(x*x,n/2);
    if((n & 1)==1)ret*=x ;
    return ret ;
  }
  public static String Print(int t,int p,char[] A,char[] B,int BN){
    StringBuilder sb=new StringBuilder();
    if(t==p)sb.append("0\r\n");
    for(int i=1 ; i<A.length-B.length+1 ; i++){
      t=t*Code+A[i+B.length-1]-A[i-1]*BN ;
      if(t==p)sb.append(i+"\r\n");
    }
    return sb.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute Code : int := 5;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var A : Sequence(String) ;
    var B : Sequence(String) ;
    A := br.readLine()->characters() ; 
    B := br.readLine()->characters() ; 
    if (A->size() < B->size()) then     return else skip ; 
    var t : int ; t := 0 ;
    var p : int ; p := 0 ;
    var BN : int ; BN := search(Code, B->size()) ;
        var i : int ; i := 0 ; while i < B->size() do ( (     t := t * Code + A[i+1] ; 
     p := p * Code + B[i+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(Print(t, p, A, B, BN)) ; 
    return 
 );
  static   operation search( x : int, n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     var ret : int ; ret := search(x * x, n / 2) ;
     if ((n & 1) = 1) then     ret := ret*(x) ; else skip ; 
     return ret );
  static   operation Print( t : int, p : int, A : Sequence(String), B : Sequence(String), BN : int) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     if (t = p) then     sb := sb + StringLib.newString("0\r\n") ; else skip ; 
         var i : int ; i := 1 ; while i < A->size() - B->size() + 1 do ( (     t := t * Code + A[i + B->size() - 1+1] - A[(i)->char2byte() - 1+1] * BN ; 
     if (t = p) then     sb := sb + StringLib.newString(i + "\r\n") ; else skip )  ;     i := i + 1 ) ; 
     return sb+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.math.BigDecimal ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long q=sc.nextLong();
    for(long z=0 ; z<q ; z++){
      String str=sc.next();
      int[] a=new int[8];
      for(int i=0 ; i<8 ; i++){
        if(str.charAt(i)>='a'){
          a[i]=(int)str.charAt(i)-'a'+10 ;
        }
        else {
          a[i]=Integer.parseInt(str.charAt(i)+"");
        }
      }
      StringBuffer sb=new StringBuffer();
      for(int i=0 ; i<8 ; i++){
        sb.append(a[i]/8);
        if(a[i]/8>0)a[i]-=8 ;
        sb.append(a[i]/4);
        if(a[i]/4>0)a[i]-=4 ;
        sb.append(a[i]/2);
        if(a[i]/2>0)a[i]-=2 ;
        sb.append(a[i]/1);
      }
      int minus=0 ;
      BigDecimal ans=new BigDecimal("0");
      if(sb.charAt(0)=='1')minus=1 ;
      for(int i=1 ; i<32 ; i++){
        if(sb.charAt(i)=='1'){
          BigDecimal tnp=new BigDecimal(Math.pow(2.0,24-i));
          ans=ans.add(tnp);
        }
      }
      if(minus==1)System.out.print("-");
      System.out.print(ans);
      int scale=ans.scale();
      if(scale==0)System.out.print(".0");
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : long ; q := sc.getCurrent()->toLong() ;
         var z : long ; z := 0 ; while z < q do ( (     var str : String ; str := sc.getCurrent() ;
     var a : Sequence(int) ; a := Integer.subrange(1,8)->collect(0) ;
        var i : int ; i := 0 ; while i < 8 do ( (     if (str->at(i+1) >= 'a') then (     a[i+1] := str->at(i+1)->oclAsType(int) - ('a')->char2byte() + 10 ) else (     a[i+1] := (str->at(i+1) + "")->toInteger() ) )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < 8 do ( (     sb := sb + StringLib.newString(a[i+1] / 8) ; 
     if (a[i+1] / 8 > 0) then     a[i+1] := a[i+1]-(8) ; else skip ; 
    sb := sb + StringLib.newString(a[i+1] / 4) ; 
    if (a[i+1] / 4 > 0) then     a[i+1] := a[i+1]-(4) ; else skip ; 
    sb := sb + StringLib.newString(a[i+1] / 2) ; 
    if (a[i+1] / 2 > 0) then     a[i+1] := a[i+1]-(2) ; else skip ; 
    sb := sb + StringLib.newString(a[i+1] / 1) ; 
 )  ;     i := i + 1 ) ; 
    var minus : int ; minus := 0 ;
    var ans : double ; ans := double("0") ;
    if (sb->at(0+1) = '1') then     minus := 1 ; else skip ; 
        var i : int ; i := 1 ; while i < 32 do ( (     if (sb->at(i+1) = '1') then (     var tnp : double ; tnp := double(2.0->pow(24 - (i)->char2byte())) ;
     ans := ans->excludes(tnp) ) else skip )  ;     i := i + 1 ) ; 
    if (minus = 1) then     OclFile["System.out"].print("-") ; else skip ; 
    OclFile["System.out"].print(ans) ; 
    var scale : int ; scale := ans.scale() ;
    if (scale = 0) then     OclFile["System.out"].print(".0") ; else skip ; 
    OclFile["System.out"].println() ; 
 )  ;     z := z + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void arrange(int N){
    if(N==1){
      System.out.println("1");
      return ;
    }
    if(N==2 || N==3){
      System.out.println("-1");
      return ;
    }
    int even=-1,odd=-1 ;
    if(N % 2==0){
      even=N ;
      odd=N-1 ;
    }
    else {
      odd=N ;
      even=N-1 ;
    }
    while(odd>=1){
      System.out.print(odd);
      System.out.print(" ");
      odd=odd-2 ;
    }
    while(even>=2){
      System.out.print(even);
      System.out.print(" ");
      even=even-2 ;
    }
  }
  public static void main(String[] args){
    int N=5 ;
    arrange(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation arrange( N : int) : void
  pre: true
  post: true
  activity: (     if (N = 1) then (     OclFile["System.out"].println("1") ; 
     return ) else skip ; 
     if (N = 2 or N = 3) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
    var even : int ; even := -1 ;
    var odd : int ; odd := -1 ;
    if (N mod 2 = 0) then (     even := N ; 
     odd := N - 1 ) else (     odd := N ; 
     even := N - 1 ) ;  
    while (odd >= 1) do (     OclFile["System.out"].print(odd) ; 
     OclFile["System.out"].print(" ") ; 
     odd := odd - 2 ) ; 
    while (even >= 2) do (     OclFile["System.out"].print(even) ; 
     OclFile["System.out"].print(" ") ; 
     even := even - 2 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     execute arrange(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  String[] table={
    "0000","0001","0010","0011","0100","0101","0110","0111","1000","1001","1010","1011","1100","1101","1110","1111" };
    private void doit(){
      Scanner sc=new Scanner(System.in);
      int dataset=sc.nextInt();
      while(dataset-->0){
        String s=sc.next();
        StringBuilder sb=new StringBuilder();
        for(int i=0 ; i<s.length(); i++){
          int ind=s.charAt(i)-'0' ;
          if(ind>9){
            ind=s.charAt(i)-'a'+10 ;
          }
          sb.append(table[ind]);
        }
        double min=0.0,value=0.5 ;
        for(int i=0 ; i<7 ; i++){
          char c=sb.charAt(32-7+i);
          if(c=='1'){
            min+=value ;
          }
          value=value*0.5 ;
        }
        String op=sb.charAt(0)=='0' ? "" : "-" ;
        String temp=sb.substring(1,32-8+1);
        int num=Integer.parseInt(temp,2);
        String res=(min-(int)min)+"" ;
        System.out.println(op+num+"."+res.substring(2));
      }
    }
    private void debug(Object...o){
      System.out.println("debug="+Arrays.deepToString(o));
    }
    public static void main(String[] args){
      new Main().doit();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute table : Sequence(String) := Sequence{"0000","0001","0010","0011","0100","0101","0110","0111","1000","1001","1010","1011","1100","1101","1110","1111"};
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dataset : int ; dataset := sc.getCurrent()->toInteger() ;
         while (dataset > 0) do (        dataset := dataset - 1 ;     skip ; (     var s : String ; s := sc.getCurrent() ;
     var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var ind : int ; ind := s->at(i+1) - ('0')->char2byte() ;
     if (ind > 9) then (     ind := s->at(i+1) - ('a')->char2byte() + 10 ) else skip ; 
     sb := sb + StringLib.newString(table[ind+1]) )  ;     i := i + 1 ) ; 
    var min : double ; min := 0.0 ;
    var value : double ; value := 0.5 ;
        var i : int ; i := 0 ; while i < 7 do ( (     var c : String ; c := sb->at(32 - 7 + i+1) ;
     if (c = '1') then (     min := min+(value) ) else skip ; 
     value := value * 0.5 )  ;     i := i + 1 ) ; 
    var op : String ; op := if sb->at(0+1) = '0' then "" else "-" endif ;
    var temp : String ; temp := sb.subrange(1+1,32 - 8 + 1) ;
    var num : int ; num := (temp)->toInteger() ;
    var res : String ; res := (min - min->oclAsType(int)) + "" ;
    OclFile["System.out"].println(op + num + "." + res.subrange(2+1,2)) ; 
 ) ;  ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.BigDecimal ;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    while(q-->0){
      long b=Long.parseLong(sc.next(),16);
      double res=(b & 0x7fffff80)>>7 ;
      double frac=0.5 ;
      for(long i=6 ; i>=0 ; --i){
        if(((b>>i)& 1)==1)res+=frac ;
        frac*=0.5 ;
      }
      System.out.printf("%s%s%s\n",((b>>31)==1)? "-" : "",BigDecimal.valueOf(res).stripTrailingZeros().toPlainString(),((b & 0x0000007f)==0)? ".0" : "");
    }
  }
  public static void main(String[] a){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
         while (q > 0) do (        q := q - 1 ;     skip ; (     var b : long ; b := (sc.getCurrent())->toLong() ;
     var res : double ; res := ((MathLib.bitwiseAnd(b,0x7fffff80))/(2->pow(7)))->oclAsType(long) ;
    var frac : double ; frac := 0.5 ;
        var i : long ; i := 6 ; while i >= 0 do ( (     if ((((b/(2->pow(i)))->oclAsType(long)) & 1) = 1) then     res := res+(frac) ; else skip ; 
     frac := frac*(0.5) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].printf("%s%s%s\n", if (((b/(2->pow(31)))->oclAsType(long)) = 1) then "-" else "" endif, (res + "")->toReal().stripTrailingZeros().toPlainString(), if ((MathLib.bitwiseAnd(b,0x0000007f)) = 0) then ".0" else "" endif) ; 
 ) ;  ) );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int cnt=0 ;
    String[] s=new String[16];
    for(int a=0 ; a<2 ; a++){
      for(int b=0 ; b<2 ; b++){
        for(int c=0 ; c<2 ; c++){
          s[cnt]=a+""+b+""+c+"0" ;
          s[cnt+1]=a+""+b+""+c+"1" ;
          cnt+=2 ;
        }
      }
    }
    double[] u=new double[31];
    double v=0.0078125 ;
    for(int i=0 ; i<31 ; i++){
      u[i]=v ;
      v*=2 ;
    }
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      String t=sc.next();
      StringBuilder sb=new StringBuilder();
      int id=-1 ;
      for(int j=0 ; j<8 ; j++){
        char c=t.charAt(j);
        if(Character.isDigit(c))id=c-48 ;
        else id=c-87 ;
        sb.append(s[id]);
      }
      if(sb.charAt(0)=='1')System.out.print("-");
      int d=0 ;
      for(int j=7 ; j<31 ; j++){
        id=sb.charAt(31-j)-48 ;
        d+=id*u[j];
      }
      System.out.print(d+".");
      double dd=0 ;
      for(int j=0 ; j<7 ; j++){
        id=sb.charAt(31-j)-48 ;
        dd+=id*u[j];
      }
      String ddd=Double.toString(dd);
      System.out.println(ddd.substring(2,ddd.length()));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cnt : int ; cnt := 0 ;
    var s : Sequence(String) ; s := Integer.subrange(1,16)->collect(null) ;
        var a : int ; a := 0 ; while a < 2 do ( (         var b : int ; b := 0 ; while b < 2 do ( (         var c : int ; c := 0 ; while c < 2 do ( (     s[cnt+1] := a + "" + b + "" + c + "0" ; 
     s[cnt + 1+1] := a + "" + b + "" + c + "1" ; 
     cnt := cnt+(2) )  ;     c := c + 1 ) )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    var u : Sequence(double) ; u := Integer.subrange(1,31)->collect(0.0) ;
    var v : double ; v := 0.0078125 ;
        var i : int ; i := 0 ; while i < 31 do ( (     u[i+1] := v ; 
     v := v*(2) )  ;     i := i + 1 ) ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var t : String ; t := sc.getCurrent() ;
     var sb : String ; sb := StringLib.newString() ;
    var id : int ; id := -1 ;
        var j : int ; j := 0 ; while j < 8 do ( (     var c : String ; c := t->at(j+1) ;
     if ((c + "")->isMatch("[0-9]")) then     id := (c)->char2byte() - 48 else     id := (c)->char2byte() - 87 ; ;  
     sb := sb + StringLib.newString(s[id+1]) )  ;     j := j + 1 ) ; 
    if (sb->at(0+1) = '1') then     OclFile["System.out"].print("-") ; else skip ; 
    var d : int ; d := 0 ;
        var j : int ; j := 7 ; while j < 31 do ( (     id := sb->at(31 - j+1) - 48 ; 
     d := d+(id * u[j+1]) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].print(d + ".") ; 
    var dd : double ; dd := 0 ;
        var j : int ; j := 0 ; while j < 7 do ( (     id := sb->at(31 - j+1) - 48 ; 
     dd := dd+(id * u[j+1]) )  ;     j := j + 1 ) ; 
    var ddd : String ; ddd := ((dd) + "") ;
    OclFile["System.out"].println(ddd.subrange(2+1,ddd->size())) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n--!=0){
      long X=Long.parseLong(sc.next(),16);
      long a=(X & 0x7fffff80)>>7 ;
      double b=0,dt=0.5 ;
      long f=X & 0x7f ;
      long pos=1L<<6 ;
      while(0<pos){
        if((f & pos)>0){
          b+=dt ;
        }
        pos>>=1 ;
        dt/=2 ;
      }
      String t=(b+"").substring(2);
      System.out.printf("%s%d.%s\n",((X & 0x80000000)>0)? "-" : "",a,t);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         while (n /= 0) do (    skip ; (     var X : long ; X := (sc.getCurrent())->toLong() ;
     var a : long ; a := ((MathLib.bitwiseAnd(X,0x7fffff80))/(2->pow(7)))->oclAsType(long) ;
    var b : double ; b := 0 ;
    var dt : double ; dt := 0.5 ;
    var f : long ; f := MathLib.bitwiseAnd(X,0x7f) ;
    var pos : long ; pos := (1L*(2->pow(6)))->oclAsType(long) ;
    while (0 < pos) do (     if ((MathLib.bitwiseAnd(f,pos)) > 0) then (     b := b+(dt) ) else skip ; 
     pos := pos/(2->pow(1)) ; 
     dt := dt/(2) ) ; 
    var t : String ; t := (b + "").subrange(2+1,2) ;
    OclFile["System.out"].printf("%s%d.%s\n", if ((MathLib.bitwiseAnd(X,0x80000000)) > 0) then "-" else "" endif, a, t) ; 
 ) ;  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),m=in.nextInt();
    int dist[][]=new int[2][n+1];
    for(int i=1 ; i<n ; i++){
      dist[0][i]=dist[0][i-1]+in.nextInt();
      dist[1][n-1-(i-1)]=dist[0][i];
    }
    int pos[]=new int[m+1];
    long L=0 ;
    pos[0]=0 ;
    for(int i=1 ; i<=m ; i++){
      int acl=Integer.parseInt(in.next());
      pos[i]=pos[i-1]+acl ;
      if(acl>0)L+=dist[0][pos[i] ]-dist[0][pos[i-1] ];
      else L+=dist[0][pos[i-1] ]-dist[0][pos[i] ];
    }
    System.out.println(L % 100000);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var dist : Sequence(Sequence(int)) ; dist := Integer.subrange(1,2)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i < n do ( (     dist[0+1][i+1] := dist[0+1][i - 1+1] + in.getCurrent()->toInteger() ; 
     dist[1+1][n - 1 - (i - 1)+1] := dist[0+1][i+1] )  ;     i := i + 1 ) ; 
    var pos : Sequence(int) ; pos := Integer.subrange(1,m + 1)->collect(0) ;
    var L : long ; L := 0 ;
    pos[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= m do ( (     var acl : int ; acl := (in.getCurrent())->toInteger() ;
     pos[i+1] := pos[i - 1+1] + acl ; 
     if (acl > 0) then     L := L+(dist[0+1][pos[i+1]+1] - dist[0+1][pos[i - 1+1]+1]) ; else     L := L+(dist[0+1][pos[i - 1+1]+1] - dist[0+1][pos[i+1]+1]) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(L mod 100000) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean isPerfectSquare(int n){
    for(int sum=0,i=1 ; sum<n ; i+=2){
      sum+=i ;
      if(sum==n)return true ;
    }
    return false ;
  }
  public static void main(String args[]){
    if(isPerfectSquare(35))System.out.println("Yes");
    else System.out.println("NO");
    if(isPerfectSquare(49))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPerfectSquare( n : int) : boolean
  pre: true
  post: true
  activity: (         var sum : int ; sum := 0 ;
    var i : int ; i := 1 ; while sum < n do ( (     sum := sum+(i) ; 
     if (sum = n) then     return true else skip )  ;     i := i+(2) ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (isPerfectSquare(35)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("NO") ; ;  
     if (isPerfectSquare(49)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countTriplets(int arr[],int n){
    int[] freq=new int[100];
    for(int i=0 ; i<n ; i++){
      freq[arr[i] ]++;
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        if(freq[arr[i]+arr[j] ]>0){
          count++;
        }
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int n=4 ;
    int arr[]={
      1,5,3,2 };
      System.out.print(countTriplets(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countTriplets( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,100)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     freq[arr[i+1]+1] := freq[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (freq[arr[i+1] + arr[j+1]+1] > 0) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var arr : Sequence(int) ; arr := Sequence{1,5,3,2} ;
     OclFile["System.out"].print(countTriplets(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String a=sc.next();
    String b=sc.next();
    if(a.equals("H")&& b.equals("H")){
      System.out.println("H");
    }
    else if(a.equals("D")&& b.equals("D")){
      System.out.println("H");
    }
    else if(a.equals("D")&& b.equals("H")){
      System.out.println("D");
    }
    else if(a.equals("H")&& b.equals("D")){
      System.out.println("D");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := sc.getCurrent() ;
     var b : String ; b := sc.getCurrent() ;
     if (a = "H" & b = "H") then (     OclFile["System.out"].println("H") ) else     if (a = "D" & b = "D") then (     OclFile["System.out"].println("H") ) else     if (a = "D" & b = "H") then (     OclFile["System.out"].println("D") ) else     if (a = "H" & b = "D") then (     OclFile["System.out"].println("D") ) else skip ; ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    boolean a=sc.next().toCharArray()[0]=='H' ? true : false ;
    boolean b=sc.next().toCharArray()[0]=='H' ? true : false ;
    if(a==b){
      System.out.println("H");
    }
    else {
      System.out.println("D");
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : boolean ; a := if sc.getCurrent()->characters()[0+1] = 'H' then true else false endif ;
     var b : boolean ; b := if sc.getCurrent()->characters()[0+1] = 'H' then true else false endif ;
     if (a = b) then (     OclFile["System.out"].println("H") ) else (     OclFile["System.out"].println("D") ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String nyu=sc.nextLine();
    switch(nyu){
      case "H H" : System.out.println("H");
      break ;
      case "D D" : System.out.println("H");
      break ;
      case "H D" : System.out.println("D");
      break ;
      case "D H" : System.out.println("D");
      break ;
      default : System.out.println("NO");
      break ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var nyu : String ; nyu := sc.nextLine() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (nyu) ; 
       if _switchval = "H H" then
     OclFile["System.out"].println("H") ; 
    break 
   else skip ;
       if _switchval = "D D" then
     OclFile["System.out"].println("H") ; 
    break 
   else skip ;
       if _switchval = "H D" then
     OclFile["System.out"].println("D") ; 
    break 
   else skip ;
       if _switchval = "D H" then
     OclFile["System.out"].println("D") ; 
    break 
   else skip ;
       if true then
     OclFile["System.out"].println("NO") ; 
    break 
   else skip ;
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    int p[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt()-1 ;
      p[a[i] ]=i ;
    }
    TreeSet<Integer>x=new TreeSet<Integer>();
    int l[]=new int[n];
    int r[]=new int[n];
    for(int i=0 ; i<n ; i++){
      x.add(p[i]);
      if(x.first()==p[i]){
        l[i]=p[i]+1 ;
      }
      else {
        int lower=x.lower(p[i]);
        l[i]=p[i]-lower ;
      }
      if(x.last()==p[i]){
        r[i]=n-p[i];
      }
      else {
        int high=x.higher(p[i]);
        r[i]=high-p[i];
      }
    }
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      ans+=(long)l[i]*r[i]*(i+1);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() - 1 ; 
     p[a[i+1]+1] := i )  ;     i := i + 1 ) ; 
    var x : Set(int) ; x := Set{} ;
    var l : Sequence(int) ; l := Integer.subrange(1,n)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x := x->including(p[i+1]) ; 
     if (x->first() = p[i+1]) then (     l[i+1] := p[i+1] + 1 ) else (     var lower : int ; lower := x.lower(p[i+1]) ;
     l[i+1] := p[i+1] - lower ) ;  
     if (x->last() = p[i+1]) then (     r[i+1] := n - p[i+1] ) else (     var high : int ; high := x.higher(p[i+1]) ;
     r[i+1] := high - p[i+1] ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans+(l[i+1]->oclAsType(long) * r[i+1] * (i + 1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    String t=scan.next();
    char a=t.toCharArray()[0];
    t=scan.next();
    char b=t.toCharArray()[0];
    char answer=' ' ;
    if(a=='H'){
      answer=b ;
    }
    else {
      answer=b=='H' ? 'D' : 'H' ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var t : String ; t := scan.getCurrent() ;
    var a : String ; a := t->characters()[0+1] ;
    t := scan.getCurrent() ; 
    var b : String ; b := t->characters()[0+1] ;
    var answer : String ; answer := ' ' ;
    if (a = 'H') then (     answer := b ) else (     answer := if b = 'H' then 'D' else 'H' endif ) ;  
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    String a=sc.next();
    String b=sc.next();
    if(a.equals(b)){
      System.out.println("H");
    }
    else {
      System.out.println("D");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := sc.getCurrent() ;
     var b : String ; b := sc.getCurrent() ;
     if (a = b) then (     OclFile["System.out"].println("H") ) else (     OclFile["System.out"].println("D") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test293 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    char[][] a=new char[n][];
    boolean c[][]=new boolean[n][m];
    for(int i=0 ; i<n ; i++){
      char[] b=in.next().toCharArray();
      a[i]=b ;
    }
    for(int i=0 ; i<n ; i++){
      boolean x=true ;
      for(int j=0 ; j<m ; j++){
        if(a[i][j]=='S'){
          x=false ;
          break ;
        }
      }
      if(x){
        for(int j=0 ; j<m ; j++){
          c[i][j]=true ;
        }
      }
    }
    for(int i=0 ; i<m ; i++){
      boolean x=true ;
      for(int j=0 ; j<n ; j++){
        if(a[j][i]=='S'){
          x=false ;
          break ;
        }
      }
      if(x){
        for(int j=0 ; j<n ; j++){
          c[j][i]=true ;
        }
      }
    }
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(c[i][j]){
          sum++;
        }
      }
    }
    System.out.println(sum);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test293 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,n)->collect(Sequence{}) ;
    var c : Sequence(Sequence(boolean)) ; c := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(false)) ;
        var i : int ; i := 0 ; while i < n do ( (     var b : Sequence(String) ; b := in.getCurrent()->characters() ;
     a[i+1] := b )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var x : boolean ; x := true ;
         var j : int ; j := 0 ; while j < m do ( (     if (a[i+1][j+1] = 'S') then (     x := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (x) then (         var j : int ; j := 0 ; while j < m do ( (     c[i+1][j+1] := true )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var x : boolean ; x := true ;
         var j : int ; j := 0 ; while j < n do ( (     if (a[j+1][i+1] = 'S') then (     x := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (x) then (         var j : int ; j := 0 ; while j < n do ( (     c[j+1][i+1] := true )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (c[i+1][j+1]) then (     sum := sum + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _330A_Cakeminator {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int row=input.nextInt();
    int col=input.nextInt();
    input.nextLine();
    String[] columns=new String[col];
    for(int i=0 ; i<col ; i++){
      columns[i]="" ;
    }
    int rowEatenCount=0 ;
    int totalRowEaten=0 ;
    for(int i=0 ; i<row ; i++){
      String cakeRow=input.nextLine();
      for(int k=0 ; k<col ; k++){
        columns[k]+=cakeRow.charAt(k);
      }
      if(! cakeRow.contains("S")){
        rowEatenCount++;
        totalRowEaten+=col ;
      }
    }
    for(String str : columns){
      if(! str.contains("S")){
        totalRowEaten+=row-rowEatenCount ;
      }
    }
    System.out.println(totalRowEaten);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _330A_Cakeminator {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var row : int ; row := input.getCurrent()->toInteger() ;
    var col : int ; col := input.getCurrent()->toInteger() ;
    skip ; 
    var columns : Sequence(String) ; columns := Integer.subrange(1,col)->collect(null) ;
        var i : int ; i := 0 ; while i < col do ( (     columns[i+1] := "" )  ;     i := i + 1 ) ; 
    var rowEatenCount : int ; rowEatenCount := 0 ;
    var totalRowEaten : int ; totalRowEaten := 0 ;
        var i : int ; i := 0 ; while i < row do ( (     var cakeRow : String ; cakeRow := input.nextLine() ;
         var k : int ; k := 0 ; while k < col do ( (     columns[k+1] := columns[k+1]+(cakeRow->at(k+1)) )  ;     k := k + 1 ) ; 
     if (not(cakeRow->includes("S"))) then (     rowEatenCount := rowEatenCount + 1 ; 
     totalRowEaten := totalRowEaten+(col) ) else skip )  ;     i := i + 1 ) ; 
    for (str : columns) do ( (     if (not(str->includes("S"))) then (     totalRowEaten := totalRowEaten+(row - rowEatenCount) ) else skip )  ) ; 
    OclFile["System.out"].println(totalRowEaten) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int r=sc.nextInt();
    int c=sc.nextInt();
    char mat[][]=new char[r][c];
    for(int i=0 ; i<r ; i++){
      String s=sc.next();
      for(int j=0 ; j<c ; j++){
        mat[i][j]=s.charAt(j);
      }
    }
    int rcount=0 ;
    int count=0 ;
    for(int i=0 ; i<r ; i++){
      boolean b=true ;
      for(int j=0 ; j<c ; j++){
        if(mat[i][j]=='S')b=false ;
      }
      if(b==true){
        rcount++;
        count+=c ;
      }
    }
    int ccount=0 ;
    for(int j=0 ; j<c ; j++){
      boolean b=true ;
      for(int i=0 ; i<r ; i++){
        if(mat[i][j]=='S')b=false ;
      }
      if(b==true){
        ccount+=r-rcount ;
      }
    }
    System.out.println(count+ccount);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var mat : Sequence(Sequence(String)) ; mat := Integer.subrange(1,r)->collect(Integer.subrange(1,c)->collect(0)) ;
        var i : int ; i := 0 ; while i < r do ( (     var s : String ; s := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < c do ( (     mat[i+1][j+1] := s->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var rcount : int ; rcount := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < r do ( (     var b : boolean ; b := true ;
         var j : int ; j := 0 ; while j < c do ( (     if (mat[i+1][j+1] = 'S') then     b := false ; else skip )  ;     j := j + 1 ) ; 
     if (b = true) then (     rcount := rcount + 1 ; 
     count := count+(c) ) else skip )  ;     i := i + 1 ) ; 
    var ccount : int ; ccount := 0 ;
        var j : int ; j := 0 ; while j < c do ( (     var b : boolean ; b := true ;
         var i : int ; i := 0 ; while i < r do ( (     if (mat[i+1][j+1] = 'S') then     b := false ; else skip )  ;     i := i + 1 ) ; 
     if (b = true) then (     ccount := ccount+(r - rcount) ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(count + ccount) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=Integer.parseInt(line.substring(0,line.indexOf(' ')));
      int m=Integer.parseInt(line.substring(line.indexOf(' ')+1));
      int[] d=new int[n];
      for(int i=0 ; i<n-1 ; i++){
        d[i]=Integer.parseInt(br.readLine());
      }
      long sum=0 ;
      int inn=0 ;
      for(int i=0 ; i<m ; i++){
        int mm=Integer.parseInt(br.readLine());
        if(mm>0){
          for(int j=inn ; j<inn+mm ; j++){
            sum+=d[j];
          }
        }
        else {
          for(int j=inn-1 ; j>=inn+mm ; j--){
            sum+=d[j];
          }
        }
        inn+=mm ;
      }
      System.out.println(sum % 100000);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := (line.subrange(0+1,line->indexOf(' ')-1))->toInteger() ;
     var m : int ; m := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1))->toInteger() ;
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < (n)->char2byte() - 1 do ( (     d[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    var inn : int ; inn := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var mm : int ; mm := (br.readLine())->toInteger() ;
     if (mm > 0) then (         var j : int ; j := inn ; while j < inn + mm do ( (     sum := sum+(d[j+1]) )  ;     j := j + 1 ) ) else (         var j : int ; j := inn - 1 ; while j >= inn + mm do ( (     sum := sum+(d[j+1]) )  ;     j := j - 1 ) ) ;  
     inn := inn+(mm) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum mod 100000) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication138 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int r=sc.nextInt();
    int c=sc.nextInt();
    HashSet<Integer>rows=new HashSet<>();
    HashSet<Integer>cols=new HashSet<>();
    for(int i=0 ; i<r ; i++){
      String s=sc.next();
      for(int j=0 ; j<c ; j++){
        if(s.charAt(j)=='S'){
          rows.add(i);
          cols.add(j);
        }
      }
    }
    System.out.println((r*c)-(rows.size()*cols.size()));
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication138 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var rows : Set(int) ; rows := Set{} ;
    var cols : Set(int) ; cols := Set{} ;
        var i : int ; i := 0 ; while i < r do ( (     var s : String ; s := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < c do ( (     if (s->at(j+1) = 'S') then (     rows := rows->including(i) ; 
     cols := cols->including(j) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((r * c) - (rows->size() * cols->size())) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
import java.util.*;
public class Test {
  static Scanner sc=new Scanner(System.in);
  static BufferedWriter write=new BufferedWriter(new OutputStreamWriter(System.out));
  static PrintWriter out=new PrintWriter(write);
  public static void main(String[] args)throws java.lang.Exception {
    int r=sc.nextInt();
    int c=sc.nextInt();
    int grid[][]=new int[r][c];
    sc.nextLine();
    for(int i=0 ; i<r ; i++){
      String s=sc.nextLine();
      for(int j=0 ; j<c ; j++){
        if(s.charAt(j)=='S')grid[i][j]=1 ;
      }
    }
    int ans=0 ;
    for(int i=0 ; i<r ; i++){
      int cnt=0 ;
      for(int j=0 ; j<c ; j++){
        if(grid[i][j]==1){
          cnt=0 ;
          break ;
        }
        else if(grid[i][j]==0){
          cnt++;
          grid[i][j]=2 ;
        }
      }
      if(cnt==0){
        for(int j=0 ; j<c ; j++){
          if(grid[i][j]==2)grid[i][j]=0 ;
        }
      }
      ans+=cnt ;
    }
    for(int i=0 ; i<c ; i++){
      int cnt=0 ;
      for(int j=0 ; j<r ; j++){
        if(grid[j][i]==1){
          cnt=0 ;
          break ;
        }
        else if(grid[j][i]==0){
          cnt++;
          grid[j][i]=2 ;
        }
      }
      ans+=cnt ;
    }
    out.println(ans);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute write : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(write);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : int ; r := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
    var grid : Sequence(Sequence(int)) ; grid := Integer.subrange(1,r)->collect(Integer.subrange(1,c)->collect(0)) ;
    skip ; 
        var i : int ; i := 0 ; while i < r do ( (     var s : String ; s := sc.nextLine() ;
         var j : int ; j := 0 ; while j < c do ( (     if (s->at(j+1) = 'S') then     grid[i+1][j+1] := 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < r do ( (     var cnt : int ; cnt := 0 ;
         var j : int ; j := 0 ; while j < c do ( (     if (grid[i+1][j+1] = 1) then (     cnt := 0 ; 
     break ) else     if (grid[i+1][j+1] = 0) then (     cnt := cnt + 1 ; 
     grid[i+1][j+1] := 2 ) else skip ; )  ;     j := j + 1 ) ; 
     if (cnt = 0) then (         var j : int ; j := 0 ; while j < c do ( (     if (grid[i+1][j+1] = 2) then     grid[i+1][j+1] := 0 ; else skip )  ;     j := j + 1 ) ) else skip ; 
     ans := ans+(cnt) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < c do ( (     var cnt : int ; cnt := 0 ;
         var j : int ; j := 0 ; while j < r do ( (     if (grid[j+1][i+1] = 1) then (     cnt := 0 ; 
     break ) else     if (grid[j+1][i+1] = 0) then (     cnt := cnt + 1 ; 
     grid[j+1][i+1] := 2 ) else skip ; )  ;     j := j + 1 ) ; 
     ans := ans+(cnt) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    boolean first=true ;
    while(sc.hasNext()){
      String word=sc.next();
      if(word.charAt(word.length()-1)==',' || word.charAt(word.length()-1)=='.'){
        word=word.substring(0,word.length()-1);
      }
      if(3<=word.length()&& word.length()<=6){
        if(first){
          System.out.print(word);
          first=false ;
        }
        else {
          System.out.print(" "+word);
        }
      }
    }
    System.out.println("");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var first : boolean ; first := true ;
     while (sc.hasNext()) do (     var word : String ; word := sc.getCurrent() ;
     if (word->at(word->size() - 1+1) = ',' or word->at(word->size() - 1+1) = '.') then (     word := word.subrange(0+1,word->size() - 1) ) else skip ; 
     if (3 <= word->size() & word->size() <= 6) then (     if (first) then (     OclFile["System.out"].print(word) ; 
     first := false ) else (     OclFile["System.out"].print(" " + word) ) ) else skip ) ; 
     OclFile["System.out"].println("") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    String buffer=sc.nextLine();
    Scanner in=new Scanner(buffer.replace(',',' ').replace('.',' '));
    String ans="" ;
    for(; in.hasNext(); ){
      String tango=in.next();
      if(tango.length()<3)continue ;
      if(tango.length()>6)continue ;
      ans+=tango+" " ;
    }
    System.out.println(ans.trim());
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var buffer : String ; buffer := sc.nextLine() ;
     var in : OclFile ; in := OclFile.newOclFile_Read(buffer.replace(',', ' ').replace('.', ' ')) ;
    var ans : String ; ans := "" ;
      while in.hasNext() do ( (     var tango : String ; tango := in.getCurrent() ;
     if (tango->size() < 3) then     continue else skip ; 
     if (tango->size() > 6) then     continue else skip ; 
     ans := ans+(tango + " ") )  ) ; 
    OclFile["System.out"].println(ans->trim()) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int findMinEqualSums(int[] a,int N){
    int sum=0 ;
    for(int i=0 ; i<N ; i++){
      sum+=a[i];
    }
    int sum1=0,sum2=0 ;
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<N ; i++){
      sum1+=a[i];
      sum2=sum-sum1 ;
      if(Math.abs(sum1-sum2)<min){
        min=Math.abs(sum1-sum2);
      }
      if(min==0){
        break ;
      }
    }
    return min ;
  }
  public static void main(String args[]){
    int[] a={
      3,2,1,5,7,8 };
      int N=a.length ;
      System.out.println(findMinEqualSums(a,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMinEqualSums( a : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    var sum1 : int ; sum1 := 0 ;
    var sum2 : int ; sum2 := 0 ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < N do ( (     sum1 := sum1+(a[i+1]) ; 
     sum2 := sum - sum1 ; 
     if (if sum1 - sum2 < 0 then -(sum1 - sum2) else sum1 - sum2 endif < min) then (     min := if sum1 - sum2 < 0 then -(sum1 - sum2) else sum1 - sum2 endif ) else skip ; 
     if (min = 0) then (     break ) else skip )  ;     i := i + 1 ) ; 
    return min 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{3,2,1,5,7,8} ;
     var N : int ; N := a->size() ;
     OclFile["System.out"].println(findMinEqualSums(a, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    ArrayList<String>array=new ArrayList<String>();
    try {
      String str=null ;
      while((str=br.readLine())!=null){
        array.add(str);
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
    finally {
      try {
        br.close();
      }
      catch(IOException e){
        e.printStackTrace();
      }
    }
    for(String s : array){
      String[] data=s.split("[,.] ");
      String answer=null ;
      for(String word : data){
        if(word.length()<=6 && word.length()>=3){
          if(answer==null){
            answer=word ;
          }
          else {
            answer+=" "+word ;
          }
        }
      }
      System.out.println(answer);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var array : Sequence(String) ; array := Sequence{} ;
     try (     var str : String ; str := null ;
         str := br.readLine() ;
    while ((str) /= null) do (    skip ; (     array := array->including(str) ) ;     str := br.readLine() ;
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
   finally (     try (     skip )   catch (e : IOException) do (     e.printStackTrace() )
 )
     for (s : array) do ( (     var data : Sequence(String) ; data := s->split("[,.] ") ;
     var answer : String ; answer := null ;
     for (word : data) do ( (     if (word->size() <= 6 & word->size() >= 3) then (     if (answer = null) then (     answer := word ) else (     answer := answer+(" " + word) ) ) else skip )  ) ; 
     OclFile["System.out"].println(answer) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static final PrintWriter out=new PrintWriter(System.out,false);
  static void solve()throws IOException {
    String[] s=br.readLine().split(" ");
    int n=s.length ;
    ArrayList<String>list=new ArrayList<String>();
    for(int i=0 ; i<n ; i++){
      s[i]=s[i] .replaceAll(",","").replaceAll("\\.","");
      if(2<s[i] .length()&& s[i] .length()<7){
        list.add(s[i]);
      }
    }
    for(int i=0 ; i<list.size()-1 ; i++){
      out.print(list.get(i)+" ");
    }
    out.println(list.get(list.size()-1));
  }
  public static void main(String[] args)throws Exception {
    long start=System.currentTimeMillis();
    solve();
    out.flush();
    long end=System.currentTimeMillis();
    br.close();
    out.close();
  }
  static void trace(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
     var n : int ; n := s->size() ;
    var list : Sequence(String) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := s[i+1].replaceAllMatches(",", "" ).replaceAllMatches("\\.", "" ) ; 
     if (2 < s[i+1]->size() & s[i+1]->size() < 7) then (     list := list->including(s[i+1]) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < list->size() - 1 do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : long ; start := OclDate.getSystemTime() ;
     execute solve() ; 
    skip ; 
    var end : long ; end := OclDate.getSystemTime() ;
    skip ; 
    skip ; 
 );
  static   operation trace( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.*;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  static void tr(Object...os){
    System.err.println(deepToString(os));
  }
  void solve(){
    String[] words=sc.nextLine().split("[,\\.] ");
    boolean first=true ;
    for(int i=0 ; i<words.length ; i++){
      if(3<=words[i] .length()&& words[i] .length()<=6){
        if(first){
          first=false ;
        }
        else out.print(" ");
        out.print(words[i]);
      }
    }
    out.println();
  }
  public static void main(String[] args)throws Exception {
    new Main().run();
  }
  Scanner sc=null ;
  PrintWriter out=null ;
  public void run()throws Exception {
    sc=new Scanner(System.in);
    out=new PrintWriter(System.out);
    for(; sc.hasNext(); ){
      solve();
      out.flush();
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var words : Sequence(String) ; words := sc.nextLine()->split("[,\\.] ") ;
     var first : boolean ; first := true ;
         var i : int ; i := 0 ; while i < words->size() do ( (     if (3 <= words[i+1]->size() & words[i+1]->size() <= 6) then (     if (first) then (     first := false ) else     out.print(" ") ; ;  
     out.print(words[i+1]) ) else skip )  ;     i := i + 1 ) ; 
     out.println() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute sc : OclFile := null;
   attribute out : OclFile := null;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
       while sc.hasNext() do ( (     execute solve() ; 
     skip )  ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findXorSum(int arr[],int n){
    int sum=0 ;
    int mul=1 ;
    for(int i=0 ; i<30 ; i++){
      int c_odd=0 ;
      boolean odd=false ;
      for(int j=0 ; j<n ; j++){
        if((arr[j] &(1<<i))>0)odd=(! odd);
        if(odd)c_odd++;
      }
      for(int j=0 ; j<n ; j++){
        sum+=(mul*c_odd);
        if((arr[j] &(1<<i))>0)c_odd=(n-j-c_odd);
      }
      mul*=2 ;
    }
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      3,8,13 };
      int n=arr.length ;
      System.out.println(findXorSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findXorSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var mul : int ; mul := 1 ;
         var i : int ; i := 0 ; while i < 30 do ( (     var c_odd : int ; c_odd := 0 ;
     var odd : boolean ; odd := false ;
        var j : int ; j := 0 ; while j < n do ( (     if ((arr[j+1] & ((1*(2->pow(i)))->oclAsType(long))) > 0) then     odd := (not(odd)) ; else skip ; 
     if (odd) then     c_odd := c_odd + 1 ; else skip )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     sum := sum+((mul * c_odd)) ; 
     if ((arr[j+1] & ((1*(2->pow(i)))->oclAsType(long))) > 0) then     c_odd := (n - j - c_odd) ; else skip )  ;     j := j + 1 ) ; 
    mul := mul*(2) ; 
 )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,8,13} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findXorSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int N=100005 ;
  static Set<Integer>AMICABLE(){
    int sum[]=new int[N];
    for(int i=0 ; i<N ; i++)sum[i]=0 ;
    for(int i=1 ; i<N ; i++){
      sum[i]++;
      for(int j=2 ; j*j<=i ; j++){
        if(i % j==0){
          sum[i]+=j ;
          if(i/j!=j)sum[i]+=i/j ;
        }
      }
    }
    Set<Integer>s=new HashSet<Integer>();
    for(int i=2 ; i<N ; i++){
      if(i!=sum[i] && sum[i]<N && i==sum[sum[i] ]){
        s.add(i);
        s.add(sum[i]);
      }
    }
    return s ;
  }
  static int SumOfAmicable(int n){
    int sum=0 ;
    Set<Integer>s=AMICABLE();
    for(Integer x : s){
      if(x<=n)sum+=x ;
    }
    return sum ;
  }
  public static void main(String args[]){
    int n=284 ;
    System.out.println(SumOfAmicable(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute N : int := 100005;
  static   operation AMICABLE() : Set(int)
  pre: true
  post: true
  activity: (     var sum : Sequence(int) ; sum := Integer.subrange(1,N)->collect(0) ;
         var i : int ; i := 0 ; while i < N do (     sum[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < N do ( (     sum[i+1] := sum[i+1] + 1 ; 
         var j : int ; j := 2 ; while j * j <= i do ( (     if (i mod j = 0) then (     sum[i+1] := sum[i+1]+(j) ; 
     if (i / j /= j) then     sum[i+1] := sum[i+1]+(i / j) ; else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var s : Set(int) ; s := Set{} ;
        var i : int ; i := 2 ; while i < N do ( (     if (i /= sum[i+1] & sum[i+1] < N & i = sum[sum[i+1]+1]) then (     s := s->including(i) ; 
     s := s->including(sum[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    return s 
 );
  static   operation SumOfAmicable( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var s : Set(int) ; s := AMICABLE() ;
     for (x : s) do ( (     if (x <= n) then     sum := sum+(x) ; else skip )  ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 284 ;
     OclFile["System.out"].println(SumOfAmicable(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int t=sc.nextInt();
    if(x-t>=0){
      System.out.println(x-t);
    }
    else {
      System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     if (x - t >= 0) then (     OclFile["System.out"].println(x - t) ) else (     OclFile["System.out"].println(0) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arrS=new int[n];
    int[] arrT=new int[n];
    TreeMap<Integer,Integer>map=new TreeMap<>();
    for(int i=0 ; i<n ; i++){
      arrS[i]=sc.nextInt();
      map.put(arrS[i],null);
      arrT[i]=sc.nextInt();
      map.put(arrT[i],null);
    }
    int idx=1 ;
    for(int x : map.keySet()){
      map.put(x,idx);
      idx++;
    }
    int[] imos=new int[idx+1];
    for(int i=0 ; i<n ; i++){
      imos[map.get(arrS[i])]++;
      imos[map.get(arrT[i])+1]--;
    }
    int max=0 ;
    for(int i=1 ; i<idx ; i++){
      imos[i]+=imos[i-1];
      max=Math.max(max,imos[i]);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arrS : Sequence(int) ; arrS := Integer.subrange(1,n)->collect(0) ;
    var arrT : Sequence(int) ; arrT := Integer.subrange(1,n)->collect(0) ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     arrS[i+1] := sc.getCurrent()->toInteger() ; 
     map := map->union(Map{arrS[i+1] |-> null}) ; 
     arrT[i+1] := sc.getCurrent()->toInteger() ; 
     map := map->union(Map{arrT[i+1] |-> null}) )  ;     i := i + 1 ) ; 
    var idx : int ; idx := 1 ;
    for (x : map->keys()) do ( (     map := map->union(Map{x |-> idx}) ; 
     idx := idx + 1 )  ) ; 
    var imos : Sequence(int) ; imos := Integer.subrange(1,idx + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     imos[map->at(arrS[i+1])+1] := imos[map->at(arrS[i+1])+1] + 1 ; 
     imos[map->at(arrT[i+1]) + 1+1] := imos[map->at(arrT[i+1]) + 1+1] - 1 )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i < idx do ( (     imos[i+1] := imos[i+1]+(imos[i - 1+1]) ; 
     max := Set{max, imos[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] tmpArray=br.readLine().split(" ");
    int x=Integer.parseInt(tmpArray[0]);
    int t=Integer.parseInt(tmpArray[1]);
    System.out.println(Math.max(x-t,0));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
    var x : int ; x := (tmpArray[0+1])->toInteger() ;
    var t : int ; t := (tmpArray[1+1])->toInteger() ;
    OclFile["System.out"].println(Set{x - t, 0}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args)throws Exception {
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    long X=sc.nextLong();
    long t=sc.nextLong();
    System.out.println(Math.max(0,X-t));
  }
  static void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : long ; X := sc.getCurrent()->toLong() ;
     var t : long ; t := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println(Set{0, X - t}->max()) );
  static   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int x=scanner.nextInt(),t=scanner.nextInt();
      System.out.println((x>t)?(x-t): 0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var x : int ; x := scanner.getCurrent()->toInteger() ;
    var t : int ; t := scanner.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if (x > t) then (x - t) else 0 endif) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=scanner.nextInt();
      StringBuilder builder=new StringBuilder();
      int mod=n % 3 ;
      if(mod==1){
        for(int j=0 ; j<n/3 ; j++){
          builder.append(12);
        }
        builder.append(1);
      }
      else {
        for(int j=0 ; j<n/3 ; j++){
          builder.append(21);
        }
        if(mod==2){
          builder.append(2);
        }
      }
      System.out.println(builder);
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var builder : String ; builder := StringLib.newString() ;
    var mod : int ; mod := n mod 3 ;
    if (mod = 1) then (         var j : int ; j := 0 ; while j < n / 3 do ( (     builder := builder + StringLib.newString(12) )  ;     j := j + 1 ) ; 
     builder := builder + StringLib.newString(1) ) else (         var j : int ; j := 0 ; while j < n / 3 do ( (     builder := builder + StringLib.newString(21) )  ;     j := j + 1 ) ; 
     if (mod = 2) then (     builder := builder + StringLib.newString(2) ) else skip ) ;  
    OclFile["System.out"].println(builder) ; 
 )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public static void main(String[] args){
    java.util.Scanner scanner=new java.util.Scanner(System.in);
    int x=scanner.nextInt();
    int t=scanner.nextInt();
    System.out.println(Math.max(0,x-t));
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : Scanner ; scanner := Scanner.newScanner(OclFile["System.in"]) ;
     var x : int ; x := scanner.nextInt() ;
     var t : int ; t := scanner.nextInt() ;
     OclFile["System.out"].println(Set{0, x - t}->max()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void findSurfaceArea(float a,float h){
    float Area ;
    Area=6*a*h+3*(float)(Math.sqrt(3))*a*a ;
    System.out.println("Surface Area: "+Area);
  }
  static void findVolume(float a,float h){
    float Volume ;
    Volume=3*(float)(Math.sqrt(3))*a*a*h/2 ;
    System.out.println("Volume: "+Volume);
  }
  public static void main(String[] args){
    float a=5,h=10 ;
    findSurfaceArea(a,h);
    findVolume(a,h);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSurfaceArea( a : double, h : double) : void
  pre: true
  post: true
  activity: (     var Area : double ;
     Area := 6 * a * h + 3 * ((3)->sqrt())->oclAsType(double) * a * a ; 
     OclFile["System.out"].println("Surface Area: " + Area) );
  static   operation findVolume( a : double, h : double) : void
  pre: true
  post: true
  activity: (     var Volume : double ;
     Volume := 3 * ((3)->sqrt())->oclAsType(double) * a * a * h / 2 ; 
     OclFile["System.out"].println("Volume: " + Volume) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 5 ;
    var h : double ; h := 10 ;
     execute findSurfaceArea(a, h) ; 
     execute findVolume(a, h) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPrime(int N){
    for(int i=2 ; i<=Math.sqrt(N); i++){
      if(N % i==0)return false ;
    }
    return true ;
  }
  static int getDifference(int N){
    if(N==0)return 2 ;
    else if(N==1)return 1 ;
    else if(isPrime(N))return 0 ;
    int aboveN=-1,belowN=-1 ;
    int n1 ;
    n1=N+1 ;
    while(true){
      if(isPrime(n1)){
        aboveN=n1 ;
        break ;
      }
      else n1++;
    }
    n1=N-1 ;
    while(true){
      if(isPrime(n1)){
        belowN=n1 ;
        break ;
      }
      else n1--;
    }
    int diff1=aboveN-N ;
    int diff2=N-belowN ;
    return Math.min(diff1,diff2);
  }
  public static void main(String args[]){
    int N=25 ;
    System.out.println(getDifference(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( N : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i <= (N)->sqrt() do ( (     if (N mod i = 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation getDifference( N : int) : int
  pre: true
  post: true
  activity: (     if (N = 0) then     return 2 else     if (N = 1) then     return 1 else     if (isPrime(N)) then     return 0 else skip ; ;  ;  
     var aboveN : int ; aboveN := -1 ;
    var belowN : int ; belowN := -1 ;
    var n1 : int ;
    n1 := N + 1 ; 
    while (true) do (     if (isPrime(n1)) then (     aboveN := n1 ; 
     break ) else     n1 := n1 + 1 ; ) ; 
    n1 := N - 1 ; 
    while (true) do (     if (isPrime(n1)) then (     belowN := n1 ; 
     break ) else     n1 := n1 - 1 ; ) ; 
    var diff1 : int ; diff1 := aboveN - N ;
    var diff2 : int ; diff2 := N - belowN ;
    return Set{diff1, diff2}->min() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 25 ;
     OclFile["System.out"].println(getDifference(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  static String br=System.getProperty("line.separator");
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    String[] str=next().split("");
    Long count=0L ;
    Long w=0L ;
    for(int i=0 ; i<str.length ; i++){
      if(str[i] .equals("W")){
        count+=i-w ;
        w++;
      }
    }
    println(count);
  }
  static int nextInt(){
    return Integer.parseInt(next());
  }
  static Long nextLong(){
    return Long.parseLong(next());
  }
  static String next(){
    return sc.next();
  }
  static void println(Object o){
    PrintWriter out=new PrintWriter(System.out);
    out.println(o);
    out.flush();
  }
  static void print(Object o){
    PrintWriter out=new PrintWriter(System.out);
    out.print(o);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : String := OclProcess.getEnvironmentProperty("line.separator");
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := next()->split("") ;
     var count : long ; count := 0L ;
    var w : long ; w := 0L ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str[i+1] = "W") then (     count := count+(i - w) ; 
     w := w + 1 ) else skip )  ;     i := i + 1 ) ; 
    execute println(count) ; 
 );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
  static   operation next() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
  static   operation println( o : OclAny) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     skip ; 
     skip );
  static   operation print( o : OclAny) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     skip ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    String s=sc.next();
    int l=s.length();
    long count=0 ;
    int add=0 ;
    for(int i=l-1 ; i>=0 ; i--){
      if(s.charAt(i)=='W'){
        add++;
      }
      else if(s.charAt(i)=='B'){
        count=count+add ;
      }
    }
    System.out.println(count);
  }
  public static PrintWriter out ;
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var s : String ; s := sc.next() ;
    var l : int ; l := s->size() ;
    var count : long ; count := 0 ;
    var add : int ; add := 0 ;
        var i : int ; i := (l)->char2byte() - 1 ; while i >= 0 do ( (     if (s->at(i+1) = 'W') then (     add := add + 1 ) else     if (s->at(i+1) = 'B') then (     count := count + add ) else skip ; )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   attribute out : OclFile;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(1,in,out);
    out.close();
  }
  static class Task {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      String S=in.next();
      long tmp=0 ;
      long ans=0 ;
      for(int i=0 ; i<S.length(); i++){
        if(S.charAt(i)=='W'){
          ans+=tmp ;
        }
        else {
          tmp++;
        }
      }
      out.println(ans);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public char nextChar(){
      return next().charAt(0);
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var S : String ; S := in.next() ;
     var tmp : long ; tmp := 0 ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < S->size() do ( (     if (S->at(i+1) = 'W') then (     ans := ans+(tmp) ) else (     tmp := tmp + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  private static java.util.Scanner scanner=new java.util.Scanner(System.in);
  public static void main(String[] args){
    long count=0,ans=0 ;
    for(char c : scanner.next().toCharArray())if(c=='B')count++;
    else ans+=count ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   attribute scanner : Scanner := Scanner.newScanner(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
    var ans : long ; ans := 0 ;
     for (c : scanner.next()->characters()) do (     if (c = 'B') then     count := count + 1 else     ans := ans+(count) ; ;   ) ; 
     OclFile["System.out"].println(ans) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static boolean isVowel(char c){
    if(c=='a' || c=='e' || c=='i' || c=='o' || c=='u')return true ;
    return false ;
  }
  static boolean checkPossibility(String s1,String s2){
    int l1=s1.length();
    int l2=s2.length();
    if(l1!=l2)return false ;
    for(int i=0 ; i<l1 ; i++){
      if(isVowel(s1.charAt(i))&& isVowel(s2.charAt(i)))continue ;
      else if(!(isVowel(s1.charAt(i)))&& !(isVowel(s2.charAt(i))))continue ;
      else return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    String S1="abcgle" ;
    String S2="ezggli" ;
    if(checkPossibility(S1,S2)==true)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation isVowel( c : String) : boolean
  pre: true
  post: true
  activity: (     if (c = 'a' or c = 'e' or c = 'i' or c = 'o' or c = 'u') then     return true else skip ; 
     return false );
  static   operation checkPossibility( s1 : String, s2 : String) : boolean
  pre: true
  post: true
  activity: (     var l1 : int ; l1 := s1->size() ;
     var l2 : int ; l2 := s2->size() ;
    if (l1 /= l2) then     return false else skip ; 
        var i : int ; i := 0 ; while i < l1 do ( (     if (isVowel(s1->at(i+1)) & isVowel(s2->at(i+1))) then     continue else     if (not((isVowel(s1->at(i+1)))) & not((isVowel(s2->at(i+1))))) then     continue else     return false ;  )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S1 : String ; S1 := "abcgle" ;
     var S2 : String ; S2 := "ezggli" ;
     if (checkPossibility(S1, S2) = true) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    char[] s=sc.next().toCharArray();
    sc.close();
    long ans=0 ;
    int cnt=0 ;
    for(int i=s.length-1 ; i>=0 ; i--){
      if(s[i]=='W'){
        cnt++;
      }
      else {
        ans+=cnt ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    skip ; 
    var ans : long ; ans := 0 ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := s->size() - 1 ; while i >= 0 do ( (     if (s[i+1] = 'W') then (     cnt := cnt + 1 ) else (     ans := ans+(cnt) ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int max(int x,int y){
    return(x>y)? x : y ;
  }
  static int longestPalindromic(String str,int i,int j,int count){
    if(i>j)return count ;
    if(i==j)return(count+1);
    if(str.charAt(i)==str.charAt(j)){
      count=longestPalindromic(str,i+1,j-1,count+2);
      return max(count,max(longestPalindromic(str,i+1,j,0),longestPalindromic(str,i,j-1,0)));
    }
    return Math.max(longestPalindromic(str,i+1,j,0),longestPalindromic(str,i,j-1,0));
  }
  static int longest_palindromic_substr(String str){
    return longestPalindromic(str,0,str.length()-1,0);
  }
  public static void main(String[] args){
    String str="aaaabbaa" ;
    System.out.print(longest_palindromic_substr(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation max( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return if (x > y) then x else y endif );
  static   operation longestPalindromic( str : String, i : int, j : int, count : int) : int
  pre: true
  post: true
  activity: (     if (i > j) then     return count else skip ; 
     if (i = j) then     return (count + 1) else skip ; 
     if (str->at(i+1) = str->at(j+1)) then (     count := longestPalindromic(str, i + 1, j - 1, count + 2) ; 
     return Set{count, Set{longestPalindromic(str, i + 1, j, 0), longestPalindromic(str, i, j - 1, 0)}->max()}->max() ) else skip ; 
     return Set{longestPalindromic(str, i + 1, j, 0), longestPalindromic(str, i, j - 1, 0)}->max() );
  static   operation longest_palindromic_substr( str : String) : int
  pre: true
  post: true
  activity: (     return longestPalindromic(str, 0, str->size() - 1, 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "aaaabbaa" ;
     OclFile["System.out"].print(longest_palindromic_substr(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int findOptimalSolution(int[] a,int N){
    Arrays.sort(a);
    int points=0 ;
    for(int i=0 ; i<N ; i++){
      points+=a[i]*i ;
    }
    return points ;
  }
  public static void main(String args[]){
    int[] a={
      1,4,2,3,9 };
      int N=a.length ;
      System.out.println(findOptimalSolution(a,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findOptimalSolution( a : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var points : int ; points := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     points := points+(a[i+1] * i) )  ;     i := i + 1 ) ; 
     return points );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,4,2,3,9} ;
     var N : int ; N := a->size() ;
     OclFile["System.out"].println(findOptimalSolution(a, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class trailzero {
  public static void main(String[] args)throws Throwable {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int m=sc.nextInt();
    int a[]=new int[n];
    int p[]=new int[m];
    int index=-1 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      p[a[i] % m]++;
      if(p[a[i] % m]==k){
        index=a[i] % m ;
      }
    }
    if(index!=-1){
      int c=0 ;
      System.out.println("Yes");
      for(int i=0 ; i<n ; i++){
        if(a[i] % m==index){
          System.out.print(a[i]+" ");
          c++;
        }
        if(c==k){
          break ;
        }
      }
      System.out.println();
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class trailzero {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var p : Sequence(int) ; p := Integer.subrange(1,m)->collect(0) ;
    var index : int ; index := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     p[a[i+1] mod m+1] := p[a[i+1] mod m+1] + 1 ; 
     if (p[a[i+1] mod m+1] = k) then (     index := a[i+1] mod m ) else skip )  ;     i := i + 1 ) ; 
    if (index /= -1) then (     var c : int ; c := 0 ;
     OclFile["System.out"].println("Yes") ; 
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] mod m = index) then (     OclFile["System.out"].print(a[i+1] + " ") ; 
     c := c + 1 ) else skip ; 
     if (c = k) then (     break ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class compete2 {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    int m=scan.nextInt();
    int[] a=new int[n];
    int[] b=new int[m];
    for(int i=0 ; i<n ; i++){
      a[i]=scan.nextInt();
      b[a[i] % m]++;
      if(b[a[i] % m]==k){
        System.out.println("Yes");
        for(int j=0 ; j<=i ; j++){
          if(a[j] % m==a[i] % m){
            System.out.print(a[j]+" ");
          }
        }
        return ;
      }
    }
    System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class compete2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() ; 
     b[a[i+1] mod m+1] := b[a[i+1] mod m+1] + 1 ; 
     if (b[a[i+1] mod m+1] = k) then (     OclFile["System.out"].println("Yes") ; 
         var j : int ; j := 0 ; while j <= i do ( (     if (a[j+1] mod m = a[i+1] mod m) then (     OclFile["System.out"].print(a[j+1] + " ") ) else skip )  ;     j := j + 1 ) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("No") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int[][][] dp=new int[100][100][100];
  static int countString(int m,int n,String[] arr,int i){
    if(m<0 || n<0){
      return Integer.MIN_VALUE ;
    }
    if(i>=arr.length){
      return 0 ;
    }
    if(dp[m][n][i]!=-1){
      return dp[m][n][i];
    }
    int zero=0,one=0 ;
    for(char c : arr[i] .toCharArray()){
      if(c=='0'){
        zero++;
      }
      else {
        one++;
      }
    }
    int x=1+countString(m-zero,n-one,arr,i+1);
    int y=countString(m,n,arr,i+1);
    return dp[m][n][i]=Math.max(x,y);
  }
  public static void main(String[] args){
    String[] arr={
      "10","0001","1","111001","0" };
      int N=3,M=5 ;
      for(int i=0 ; i<100 ; i++){
        for(int j=0 ; j<100 ; j++){
          for(int l=0 ; l<100 ; l++)dp[i][j][l]=-1 ;
        }
      }
      System.out.print(countString(M,N,arr,0));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute dp : Sequence(Sequence(Sequence(int))) := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(0)));
  static   operation countString( m : int, n : int, arr : Sequence(String), i : int) : int
  pre: true
  post: true
  activity: (     if (m < 0 or n < 0) then (     return -2147483648 ) else skip ; 
     if (i >= arr->size()) then (     return 0 ) else skip ; 
    if (dp[m+1][n+1][i+1] /= -1) then (     return dp[m+1][n+1][i+1] ) else skip ; 
    var zero : int ; zero := 0 ;
    var one : int ; one := 0 ;
    for (c : arr[i+1]->characters()) do ( (     if (c = '0') then (     zero := zero + 1 ) else (     one := one + 1 ) )  ) ; 
    var x : int ; x := 1 + countString(m - zero, n - one, arr, i + 1) ;
    var y : int ; y := countString(m, n, arr, i + 1) ;
    return dp[m+1][n+1][i+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"10","0001","1","111001","0"} ;
     var N : int ; N := 3 ;
    var M : int ; M := 5 ;
         var i : int ; i := 0 ; while i < 100 do ( (         var j : int ; j := 0 ; while j < 100 do ( (         var l : int ; l := 0 ; while l < 100 do (     dp[i+1][j+1][l+1] := -1 ;  ;     l := l + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(countString(M, N, arr, 0)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector ;
class GFG {
  static long LCM(int arr[],int n){
    int max_num=0 ;
    for(int i=0 ; i<n ; i++){
      if(max_num<arr[i]){
        max_num=arr[i];
      }
    }
    long res=1 ;
    int x=2 ;
    while(x<=max_num){
      Vector<Integer>indexes=new Vector<>();
      for(int j=0 ; j<n ; j++){
        if(arr[j] % x==0){
          indexes.add(indexes.size(),j);
        }
      }
      if(indexes.size()>=2){
        for(int j=0 ; j<indexes.size(); j++){
          arr[indexes.get(j)]=arr[indexes.get(j)]/x ;
        }
        res=res*x ;
      }
      else {
        x++;
      }
    }
    for(int i=0 ; i<n ; i++){
      res=res*arr[i];
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,10,20,35 };
      int n=arr.length ;
      System.out.println(LCM(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation LCM( arr : Sequence(int), n : int) : long
  pre: true
  post: true
  activity: (     var max_num : int ; max_num := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (max_num < arr[i+1]) then (     max_num := arr[i+1] ) else skip )  ;     i := i + 1 ) ; 
    var res : long ; res := 1 ;
    var x : int ; x := 2 ;
    while (x <= max_num) do (     var indexes : Sequence(int) ; indexes := Sequence{} ;
         var j : int ; j := 0 ; while j < n do ( (     if (arr[j+1] mod x = 0) then (     indexes := indexes.insertAt(indexes->size()+1,j) ) else skip )  ;     j := j + 1 ) ; 
     if (indexes->size() >= 2) then (         var j : int ; j := 0 ; while j < indexes->size() do ( (     arr[indexes->at(j+1)+1] := arr[indexes->at(j+1)+1] / x )  ;     j := j + 1 ) ; 
     res := res * x ) else (     x := x + 1 ) ) ; 
        var i : int ; i := 0 ; while i < n do ( (     res := res * arr[i+1] )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,10,20,35} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(LCM(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int min_elimination(int n,int[] arr){
    int count=0 ;
    int prev_val=arr[0];
    for(int i=1 ; i<n ; i++){
      int curr_val=arr[i];
      if(curr_val % 2==prev_val % 2)count++;
      prev_val=curr_val ;
    }
    return count ;
  }
  public static void main(String[] args){
    int[] arr=new int[] {
      1,2,3,7,9 };
      int n=arr.length ;
      System.out.println(min_elimination(n,arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation min_elimination( n : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var prev_val : int ; prev_val := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do ( (     var curr_val : int ; curr_val := arr[i+1] ;
     if (curr_val mod 2 = prev_val mod 2) then     count := count + 1 ; else skip ; 
     prev_val := curr_val )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,7,9} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(min_elimination(n, arr)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class a {
  static InputReader in ;
  static PrintWriter out ;
  public static void main(String args[]){
    in=new InputReader(System.in);
    out=new PrintWriter(System.out);
    int n=Integer.valueOf(in.next());
    for(int i=1 ; i<=n ; i++){
      out.printf("Case #%d: %s\n",i,solve());
    }
    out.close();
  }
  static BigInteger solve(){
    BigInteger r=new BigInteger(in.next());
    BigInteger t=new BigInteger(in.next());
    BigInteger x=new BigInteger("0");
    BigInteger y=new BigInteger("2000000000000000000");
    BigInteger ans=new BigInteger("0");
    while(x.compareTo(y)!=1){
      BigInteger m=x.add(y).shiftRight(1);
      BigInteger tmp=m.multiply(r).shiftLeft(1).add(m.multiply(m.multiply(m).shiftLeft(2).subtract(BigInteger.ONE)).divide(new BigInteger("3"))).subtract(m.subtract(BigInteger.ONE).shiftLeft(1).multiply(m).multiply(m.shiftLeft(1).subtract(BigInteger.ONE)).divide(new BigInteger("3")));
      if(tmp.compareTo(t)!=1){
        ans=m ;
        x=m.add(BigInteger.ONE);
      }
      else y=m.subtract(BigInteger.ONE);
    }
    return ans ;
  }
}
class InputReader {
  StringTokenizer tokenizer ;
  BufferedReader reader ;
  public InputReader(InputStream stream){
    tokenizer=null ;
    reader=new BufferedReader(new InputStreamReader(stream));
  }
  public String next(){
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        tokenizer=new StringTokenizer(reader.readLine());
      }
      catch(IOException E){
        throw new RuntimeException(E);
      }
    }
    return tokenizer.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class a {
  static   attribute in : InputReader;
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := InputReader.newInputReader(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    var n : int ; n := (in.next())->toInteger() ;
        var i : int ; i := 1 ; while i <= n do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation solve() : long
  pre: true
  post: true
  activity: (     var r : long ; r := long(in.next()) ;
     var t : long ; t := long(in.next()) ;
    var x : long ; x := long("0") ;
    var y : long ; y := long("2000000000000000000") ;
    var ans : long ; ans := long("0") ;
    while (x->compareTo(y) /= 1) do (     var m : long ; m := x->excludes(y).shiftRight(1) ;
     var tmp : long ; tmp := m.multiply(r).shiftLeft(1)->excludes(m.multiply(m.multiply(m).shiftLeft(2).subtract(1)).divide(long("3"))).subtract(m.subtract(1).shiftLeft(1).multiply(m).multiply(m.shiftLeft(1).subtract(1)).divide(long("3"))) ;
     if (tmp->compareTo(t) /= 1) then (     ans := m ; 
     x := m->excludes(1) ) else     y := m.subtract(1) ; ) ; 
    return ans 
 );
}
class InputReader {
   attribute tokenizer : OclIterator;
   attribute reader : OclFile;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     tokenizer := null ; 
     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (E : IOException) do (     error ProgramException(E) )
 ) ; 
     return tokenizer.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.FileReader ;
import java.io.FileWriter ;
public class R1A {
  public static void main(String[] args){
    String prblm="A" ;
    boolean fl=true ;
    String filein=prblm+"-"+((fl)? "large" : "small")+".in.txt" ;
    String fileout=prblm+"-"+((fl)? "large" : "small")+".out.txt" ;
    try {
      BufferedReader fr=new BufferedReader(new FileReader(filein));
      BufferedWriter fw=new BufferedWriter(new FileWriter(fileout));
      String s=fr.readLine();
      int T=Integer.parseInt(s);
      for(int i=1 ; i<=T ; i++){
        s=fr.readLine();
        String[] tok=s.split(" ");
        long r=Long.parseLong(tok[0]);
        long t=Long.parseLong(tok[1]);
        long mn=0,mx=2000000000l ;
        while(mx-mn>0){
          long v=(mn+mx+1)/2 ;
          if(Long.MAX_VALUE/(2*r+2*v-1)<v || v*(2*r+2*v-1)>t)mx=v-1 ;
          else mn=v ;
        }
        System.out.println(mn);
        fw.write("Case #"+i+": "+mn+"\n");
      }
      fr.close();
      fw.close();
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class R1A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var prblm : String ; prblm := "A" ;
     var fl : boolean ; fl := true ;
    var filein : String ; filein := prblm + "-" + (if (fl) then "large" else "small" endif) + ".in.txt" ;
    var fileout : String ; fileout := prblm + "-" + (if (fl) then "large" else "small" endif) + ".out.txt" ;
    try (     var fr : OclFile ; fr := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(filein))) ;
     var fw : OclFile ; fw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile(fileout))) ;
    var s : String ; s := fr.readLine() ;
    var T : int ; T := (s)->toInteger() ;
        var i : int ; i := 1 ; while i <= T do ( (     s := fr.readLine() ; 
     var tok : Sequence(String) ; tok := s->split(" ") ;
    var r : long ; r := (tok[0+1])->toLong() ;
    var t : long ; t := (tok[1+1])->toLong() ;
    var mn : long ; mn := 0 ;
    var mx : long ; mx := 2000000000l ;
    while (mx - mn > 0) do (     var v : long ; v := (mn + mx + 1) / 2 ;
     if ("9223372036854775807"->toLong() / (2 * r + 2 * v - 1) < v or v * (2 * r + 2 * v - 1) > t) then     mx := v - 1 ; else     mn := v ; ) ; 
    OclFile["System.out"].println(mn) ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class A {
  static BigInteger B(long x){
    return BigInteger.valueOf(x);
  }
  static BigInteger r ;
  static BigInteger f(long guess){
    BigInteger x=B(guess);
    BigInteger two_x_minus_one=x.multiply(B(2)).subtract(B(1));
    return B(2).multiply(x).multiply(r).add(x.multiply(two_x_minus_one));
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int cas=1 ; cas<=T ; cas++){
      r=BigInteger.valueOf(in.nextLong());
      BigInteger t=BigInteger.valueOf(in.nextLong());
      long lo=0 ;
      long hi=t.longValue();
      while(lo<hi){
        long mid=(lo+hi+1)/2 ;
        BigInteger score=f(mid);
        if(score.compareTo(t)>0)hi=mid-1 ;
        else lo=mid ;
      }
      System.out.printf("Case #%d: %d\n",cas,lo);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation B( x : long) : long
  pre: true
  post: true
  activity: (     return (x + "")->toLong() );
  static   attribute r : long;
  static   operation f( guess : long) : long
  pre: true
  post: true
  activity: (     var x : long ; x := B(guess) ;
     var two_x_minus_one : long ; two_x_minus_one := x.multiply(B(2)).subtract(B(1)) ;
     return B(2).multiply(x).multiply(r)->excludes(x.multiply(two_x_minus_one)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var cas : int ; cas := 1 ; while cas <= T do ( (     r := (in.getCurrent()->toLong() + "")->toLong() ; 
     var t : long ; t := (in.getCurrent()->toLong() + "")->toLong() ;
    var lo : long ; lo := 0 ;
    var hi : long ; hi := t->oclAsType(long) ;
    while (lo < hi) do (     var mid : long ; mid := (lo + hi + 1) / 2 ;
     var score : long ; score := f(mid) ;
     if (score->compareTo(t) > 0) then     hi := mid - 1 ; else     lo := mid ; ) ; 
    OclFile["System.out"].printf("Case #%d: %d\n", cas, lo) ; 
 )  ;     cas := cas + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    List<Integer>[] edge=new ArrayList[N*3];
    for(int i=0 ; i<N*3 ; i++)edge[i]=new ArrayList<>();
    for(int i=0 ; i<M ; i++){
      int u=sc.nextInt()-1 ;
      int v=sc.nextInt()-1 ;
      edge[u] .add(v+N);
      edge[u+N] .add(v+2*N);
      edge[u+2*N] .add(v);
    }
    int S=sc.nextInt()-1 ;
    int T=sc.nextInt()-1 ;
    long[] d=new long[N*3];
    int INF=Integer.MAX_VALUE ;
    Arrays.fill(d,INF);
    d[S]=0 ;
    Queue<Integer>q=new ArrayDeque<>();
    for(int i : edge[S]){
      q.offer(i);
      d[i]=1 ;
    }
    while(q.size()>0){
      int x=q.poll();
      for(int i : edge[x]){
        if(d[i]>d[x]+1){
          d[i]=d[x]+1 ;
          q.offer(i);
        }
      }
    }
    System.out.println(d[T]!=INF ? d[T]/3 :-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var edge : Sequence(Sequence(int)) ; edge := Integer.subrange(1,N * 3)->collect(null) ;
        var i : int ; i := 0 ; while i < N * 3 do (     edge[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var u : int ; u := sc.getCurrent()->toInteger() - 1 ;
     var v : int ; v := sc.getCurrent()->toInteger() - 1 ;
    edge[u+1]->excludes(v + N) ; 
    edge[u + N+1]->excludes(v + 2 * N) ; 
    edge[u + 2 * N+1]->excludes(v) ; 
 )  ;     i := i + 1 ) ; 
    var S : int ; S := sc.getCurrent()->toInteger() - 1 ;
    var T : int ; T := sc.getCurrent()->toInteger() - 1 ;
    var d : Sequence(long) ; d := Integer.subrange(1,N * 3)->collect(0) ;
    var INF : int ; INF := 2147483647 ;
    d := d->collect(INF) ; 
    d[S+1] := 0 ; 
    var q : Sequence(int) ; q := ArrayDeque<OclAny>.newArrayDeque() ;
    for (i : edge[S+1]) do ( (     q := q->including(i) ; 
     d[i+1] := 1 )  ) ; 
    while (q->size() > 0) do (     var x : int ; x := q->min() ;
     for (i : edge[x+1]) do ( (     if (d[i+1] > d[x+1] + 1) then (     d[i+1] := d[x+1] + 1 ; 
     q := q->including(i) ) else skip )  ) ) ; 
    OclFile["System.out"].println(if d[T+1] /= INF then d[T+1] / 3 else -1 endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintStream ;
import java.math.BigInteger ;
import java.util.Scanner ;
public class A {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner scan=new Scanner(System.in);
    BigInteger TWO=BigInteger.valueOf(2);
    BigInteger FOUR=BigInteger.valueOf(4);
    int cases=scan.nextInt();
    BigInteger r,t,res ;
    PrintStream outfile=new PrintStream("C-large.out.txt");
    for(int c=1 ; c<=cases ; c++){
      r=scan.nextBigInteger();
      t=scan.nextBigInteger();
      res=r.multiply(r).subtract(r);
      res=res.add(t.multiply(TWO));
      res=res.multiply(FOUR).add(BigInteger.ONE);
      res=bigIntSqRootFloor(res);
      res=res.subtract(r.mod(TWO).equals(BigInteger.ZERO)? BigInteger.valueOf(3): BigInteger.valueOf(5));
      res=res.divide(FOUR);
      res=res.subtract(r.divide(TWO)).add(BigInteger.ONE);
      outfile.println("Case #"+c+": "+res.toString());
    }
  }
  public static BigInteger bigIntSqRootFloor(BigInteger x)throws IllegalArgumentException {
    if(x.compareTo(BigInteger.ZERO)<0){
      throw new IllegalArgumentException("Negative argument.");
    }
    if(x==BigInteger.ZERO || x==BigInteger.ONE){
      return x ;
    }
    BigInteger two=BigInteger.valueOf(2L);
    BigInteger y ;
    for(y=x.divide(two); y.compareTo(x.divide(y))>0 ; y=((x.divide(y)).add(y)).divide(two));
    return y ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var TWO : long ; TWO := (2 + "")->toLong() ;
    var FOUR : long ; FOUR := (4 + "")->toLong() ;
    var cases : int ; cases := scan.getCurrent()->toInteger() ;
    var r : long ;
    var t : long ;
    var res : long ;
    var outfile : OclFile ; outfile := OclFile.newOclFile_Write(OclFile.newOclFile("C-large.out.txt")) ;
        var c : int ; c := 1 ; while c <= cases do ( (     r := scan.nextBigInteger() ; 
     t := scan.nextBigInteger() ; 
    res := r.multiply(r).subtract(r) ; 
    res := res->excludes(t.multiply(TWO)) ; 
    res := res.multiply(FOUR)->excludes(1) ; 
    res := bigIntSqRootFloor(res) ; 
    res := res.subtract(if r.mod(TWO) = 0 then (3 + "")->toLong() else (5 + "")->toLong() endif) ; 
    res := res.divide(FOUR) ; 
    res := res.subtract(r.divide(TWO))->excludes(1) ; 
    skip ; 
 )  ;     c := c + 1 ) ; 
 );
  static   operation bigIntSqRootFloor( x : long) : long
  pre: true
  post: true
  activity: (     if (x->compareTo(0) < 0) then (     error IllegalArgumentException.newIllegalArgumentException("Negative argument.") ) else skip ; 
     if (x = 0 or x = 1) then (     return x ) else skip ; 
    var two : long ; two := (2L + "")->toLong() ;
    var y : long ;
        y := x.divide(two) ; while y->compareTo(x.divide(y)) > 0 do (   ;     y := ((x.divide(y))->excludes(y)).divide(two) ) ; 
    return y 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long res,MOD=(int)1e9+7 ;
  static ArrayList<ArrayList<Integer>>adj=new ArrayList<>();
  public static void main(String[] args)throws IOException {
    InputReader in=new InputReader();
    int n=in.nextInt();
    int k=in.nextInt();
    for(int i=0 ; i<n ; i++)adj.add(new ArrayList<>());
    for(int i=0 ; i<n-1 ; i++){
      int u=in.nextInt()-1 ;
      int v=in.nextInt()-1 ;
      adj.get(u).add(v);
      adj.get(v).add(u);
    }
    res=k ;
    dfs(0,-1,k);
    System.out.println(res);
  }
  public static void dfs(int cur,int parent,int k){
    if(adj.get(cur).size()+1>k)endProgram();
    int sub=parent==-1 ? 1 : 2 ;
    for(int index : adj.get(cur))if(index!=parent){
      res*=(k-sub++);
      res %=MOD ;
      dfs(index,cur,k);
    }
  }
  public static void endProgram(){
    System.out.println(0);
    System.exit(0);
  }
  static class InputReader {
    public BufferedReader br ;
    public StringTokenizer st ;
    public InputReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
      st=null ;
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute res : long;
  static   attribute adj : Sequence(Sequence(int)) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : InputReader ; in := InputReader.newInputReader() ;
     var n : int ; n := in.nextInt() ;
    var k : int ; k := in.nextInt() ;
        var i : int ; i := 0 ; while i < n do (     adj := adj->including(Sequence{}) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var u : int ; u := in.nextInt() - 1 ;
     var v : int ; v := in.nextInt() - 1 ;
     adj->at(u+1)->excludes(v) ; 
     adj->at(v+1)->excludes(u) )  ;     i := i + 1 ) ; 
    res := k ; 
    execute dfs(0, -1, k) ; 
    OclFile["System.out"].println(res) ; 
 );
  static   operation dfs( cur : int, parent : int, k : int) : void
  pre: true
  post: true
  activity: (     if (adj->at(cur+1)->size() + 1 > k) then     execute endProgram() ; else skip ; 
     var sub : int ; sub := if parent = -1 then 1 else 2 endif ;
     for (index : adj->at(cur+1)) do (     if (index /= parent) then (      res := res * ((k - sub))  ; sub := sub + 1 ; 
     res := res mod MOD ; 
     execute dfs(index, cur, k) ) else skip ;  ) );
  static   operation endProgram() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(0) ; 
 OclProcess.exit(0) );
  static class InputReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newInputReader() : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.concurrent.LinkedBlockingQueue ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedInputStream in=new BufferedInputStream(new DataInputStream(System.in));
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    int[] tasks=Arrays.stream(reader.readLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    Queue<Integer>taskList=new LinkedBlockingQueue<>();
    Queue<Long>events=new PriorityQueue<>(tasks[0]);
    long[] taskDur=new long[tasks[0] ];
    for(int i=0 ; i<tasks[0]; i++){
      long[] taskInput=Arrays.stream(reader.readLine().split(" ")).mapToLong(Long :: parseLong).toArray();
      taskDur[i]=taskInput[1];
      events.add(taskInput[0]*2+1);
    }
    long[] sol=new long[tasks[0] ];
    int nextTask=0 ;
    while(events.size()>0){
      long event=events.poll();
      long time=event/2 ;
      if(event % 2==0){
        int taskId=taskList.poll();
        sol[taskId]=time ;
        if(! taskList.isEmpty()){
          events.add((time+taskDur[taskList.peek()])*2);
        }
      }
      else {
        int task=nextTask++;
        if(taskList.size()<=tasks[1]){
          taskList.add(task);
          if(taskList.size()==1){
            events.add((time+taskDur[task])*2);
          }
        }
        else {
          sol[task]=-1 ;
        }
      }
    }
    System.out.println(Arrays.stream(sol).boxed().map(Object :: toString).collect(Collectors.joining(" ")));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile(OclFile["System.in"])) ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
    var tasks : Sequence(int) ; tasks := stream(reader.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var taskList : Sequence(int) ; taskList := LinkedBlockingQueue<OclAny>.newLinkedBlockingQueue() ;
    var events : Sequence(long) ; events := Sequence{}->union(tasks[0+1]) ;
    var taskDur : Sequence(long) ; taskDur := Integer.subrange(1,tasks[0+1])->collect(0) ;
        var i : int ; i := 0 ; while i < tasks[0+1] do ( (     var taskInput : Sequence(long) ; taskInput := stream(reader.readLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toLong())->apply(_x1) )->asSequence() ;
     taskDur[i+1] := taskInput[1+1] ; 
     events := events->including(taskInput[0+1] * 2 + 1) )  ;     i := i + 1 ) ; 
    var sol : Sequence(long) ; sol := Integer.subrange(1,tasks[0+1])->collect(0) ;
    var nextTask : int ; nextTask := 0 ;
    while (events->size() > 0) do (     var event : long ; event := events->min() ;
     var time : long ; time := event / 2 ;
     if (event mod 2 = 0) then (     var taskId : int ; taskId := taskList->min() ;
     sol[taskId+1] := time ; 
     if (not(taskList->isEmpty())) then (     events := events->including((time + taskDur[taskList->min()+1]) * 2) ) else skip ) else (     var task : int ; task := nextTask ;
     if (taskList->size() <= tasks[1+1]) then (     taskList := taskList->including(task) ; 
     if (taskList->size() = 1) then (     events := events->including((time + taskDur[task+1]) * 2) ) else skip ) else (     sol[task+1] := -1 ) ) ) ; 
    OclFile["System.out"].println(stream(sol)->collect( _x1 | (lambda _pars : OclAny in Object.newObject().toString(_pars))->apply(_x1) ).collect(Collectors.joining(" "))) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class A {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  int caze,T ;
  long r,t ;
  void run(){
    T=sc.nextInt();
    sc.nextLine();
    for(caze=1 ; caze<=T ; caze++){
      r=sc.nextLong();
      t=sc.nextLong();
      solveSmall();
    }
  }
  void solveSmall(){
    long left=0,right=(long)1e18 ;
    for(; right-left>1 ; ){
      long mid=(left+right)/2 ;
      boolean ok=(2*mid+2*r-1)<=t/mid ;
      if(ok){
        left=mid ;
      }
      else {
        right=mid ;
      }
    }
    answer(""+left);
  }
  void solveLarge(){
  }
  void answer(String s){
    println("Case #"+caze+": "+s);
  }
  void println(String s){
    System.out.println(s);
  }
  void print(String s){
    System.out.print(s);
  }
  void debug(Object...os){
    System.err.println(deepToString(os));
  }
  public static void main(String[] args){
    new A().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   attribute caze : int;
   attribute r : long;
   operation run() : void
  pre: true
  post: true
  activity: (     T := sc.getCurrent()->toInteger() ; 
     skip ; 
         caze := 1 ; while caze <= T do ( (     r := sc.getCurrent()->toLong() ; 
     t := sc.getCurrent()->toLong() ; 
     execute solveSmall() )  ;     caze := caze + 1 ) );
   operation solveSmall() : void
  pre: true
  post: true
  activity: (     var left : long ; left := 0 ;
    var right : long ; right := 1e18->oclAsType(long) ;
       while right - left > 1 do ( (     var mid : long ; mid := (left + right) / 2 ;
     var ok : boolean ; ok := (2 * mid + 2 * r - 1) <= t / mid ;
     if (ok) then (     left := mid ) else (     right := mid ) )  ) ; 
     execute answer("" + left) );
   operation solveLarge() : void
  pre: true
  post: true
  activity: skip;
   operation answer( s : String) : void
  pre: true
  post: true
  activity: (     execute println("Case #" + caze + ": " + s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     A.newA().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class min_steps {
  static int minInitialPoints(int points[][],int R,int C){
    int dp[][]=new int[R][C];
    int m=R,n=C ;
    dp[m-1][n-1]=points[m-1][n-1]>0 ? 1 : Math.abs(points[m-1][n-1])+1 ;
    for(int i=m-2 ; i>=0 ; i--)dp[i][n-1]=Math.max(dp[i+1][n-1]-points[i][n-1],1);
    for(int j=n-2 ; j>=0 ; j--)dp[m-1][j]=Math.max(dp[m-1][j+1]-points[m-1][j],1);
    for(int i=m-2 ; i>=0 ; i--){
      for(int j=n-2 ; j>=0 ; j--){
        int min_points_on_exit=Math.min(dp[i+1][j],dp[i][j+1]);
        dp[i][j]=Math.max(min_points_on_exit-points[i][j],1);
      }
    }
    return dp[0][0];
  }
  public static void main(String args[]){
    int points[][]={
      {
-2,-3,3 },{
-5,-10,1 },{
            10,30,-5 }
          };
          int R=3,C=3 ;
          System.out.println("Minimum Initial Points Required: "+minInitialPoints(points,R,C));
        }
      }

------------------------------------------------------------
OCL File:
---------
class min_steps {
  static   operation minInitialPoints( points : Sequence(Sequence(int)), R : int, C : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,R)->collect(Integer.subrange(1,C)->collect(0)) ;
     var m : int ; m := R ;
    var n : int ; n := C ;
    dp[m - 1+1][n - 1+1] := if points[m - 1+1][n - 1+1] > 0 then 1 else if points[m - 1+1][n - 1+1] < 0 then -(points[m - 1+1][n - 1+1]) else points[m - 1+1][n - 1+1] endif + 1 endif ; 
        var i : int ; i := m - 2 ; while i >= 0 do (     dp[i+1][n - 1+1] := Set{dp[i + 1+1][n - 1+1] - points[i+1][n - 1+1], 1}->max() ;  ;     i := i - 1 ) ; 
        var j : int ; j := n - 2 ; while j >= 0 do (     dp[m - 1+1][j+1] := Set{dp[m - 1+1][j + 1+1] - points[m - 1+1][j+1], 1}->max() ;  ;     j := j - 1 ) ; 
        var i : int ; i := m - 2 ; while i >= 0 do ( (         var j : int ; j := n - 2 ; while j >= 0 do ( (     var min_points_on_exit : int ; min_points_on_exit := Set{dp[i + 1+1][j+1], dp[i+1][j + 1+1]}->min() ;
     dp[i+1][j+1] := Set{min_points_on_exit - points[i+1][j+1], 1}->max() )  ;     j := j - 1 ) )  ;     i := i - 1 ) ; 
    return dp[0+1][0+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var points : Sequence(Sequence(int)) ; points := Sequence{Sequence{-2,-3,3},Sequence{-5,-10,1},Sequence{10,30,-5}} ;
     var R : int ; R := 3 ;
    var C : int ; C := 3 ;
     OclFile["System.out"].println("Minimum Initial Points Required: " + minInitialPoints(points, R, C)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static boolean judgeSquareSum(int n){
    for(int i=2 ; i*i<=n ; i++){
      int count=0 ;
      if(n % i==0){
        while(n % i==0){
          count++;
          n/=i ;
        }
        if(i % 4==3 && count % 2!=0)return false ;
      }
    }
    return n % 4!=3 ;
  }
  public static void main(String argc[]){
    int n=17 ;
    if(judgeSquareSum(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation judgeSquareSum( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= n do ( (     var count : int ; count := 0 ;
     if (n mod i = 0) then (     while (n mod i = 0) do (     count := count + 1 ; 
     n := n/(i) ) ; 
     if (i mod 4 = 3 & count mod 2 /= 0) then     return false else skip ) else skip )  ;     i := i + 1 ) ; 
     return n mod 4 /= 3 );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 17 ;
     if (judgeSquareSum(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int maxSortedAdjacentDiff(int[] arr,int n){
    int maxVal=arr[0];
    int minVal=arr[0];
    for(int i=1 ; i<n ; i++){
      maxVal=Math.max(maxVal,arr[i]);
      minVal=Math.min(minVal,arr[i]);
    }
    int maxBucket[]=new int[n-1];
    int minBucket[]=new int[n-1];
    Arrays.fill(maxBucket,0,n-1,Integer.MIN_VALUE);
    Arrays.fill(minBucket,0,n-1,Integer.MAX_VALUE);
    float delta=(float)(maxVal-minVal)/(float)(n-1);
    for(int i=0 ; i<n ; i++){
      if(arr[i]==maxVal || arr[i]==minVal){
        continue ;
      }
      int index=(int)(Math.round((arr[i]-minVal)/delta));
      if(maxBucket[index]==Integer.MIN_VALUE){
        maxBucket[index]=arr[i];
      }
      else {
        maxBucket[index]=Math.max(maxBucket[index],arr[i]);
      }
      if(minBucket[index]==Integer.MAX_VALUE){
        minBucket[index]=arr[i];
      }
      else {
        minBucket[index]=Math.min(minBucket[index],arr[i]);
      }
    }
    int prev_val=minVal ;
    int max_gap=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if(minBucket[i]==Integer.MAX_VALUE){
        continue ;
      }
      max_gap=Math.max(max_gap,minBucket[i]-prev_val);
      prev_val=maxBucket[i];
    }
    max_gap=Math.max(max_gap,maxVal-prev_val);
    return max_gap ;
  }
  public static void main(String[] args){
    int arr[]={
      1,10,5 };
      int n=arr.length ;
      System.out.println(maxSortedAdjacentDiff(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSortedAdjacentDiff( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var maxVal : int ; maxVal := arr[0+1] ;
     var minVal : int ; minVal := arr[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     maxVal := Set{maxVal, arr[i+1]}->max() ; 
     minVal := Set{minVal, arr[i+1]}->min() )  ;     i := i + 1 ) ; 
    var maxBucket : Sequence(int) ; maxBucket := Integer.subrange(1,n - 1)->collect(0) ;
    var minBucket : Sequence(int) ; minBucket := Integer.subrange(1,n - 1)->collect(0) ;
    maxBucket := maxBucket->collect(-2147483648) ; 
    minBucket := minBucket->collect(2147483647) ; 
    var delta : double ; delta := (maxVal - minVal)->oclAsType(double) / (n - 1)->oclAsType(double) ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = maxVal or arr[i+1] = minVal) then (     continue ) else skip ; 
     var index : int ; index := (((arr[i+1] - minVal) / delta)->round())->oclAsType(int) ;
     if (maxBucket[index+1] = -2147483648) then (     maxBucket[index+1] := arr[i+1] ) else (     maxBucket[index+1] := Set{maxBucket[index+1], arr[i+1]}->max() ) ;  
     if (minBucket[index+1] = 2147483647) then (     minBucket[index+1] := arr[i+1] ) else (     minBucket[index+1] := Set{minBucket[index+1], arr[i+1]}->min() ) )  ;     i := i + 1 ) ; 
    var prev_val : int ; prev_val := minVal ;
    var max_gap : int ; max_gap := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (minBucket[i+1] = 2147483647) then (     continue ) else skip ; 
     max_gap := Set{max_gap, minBucket[i+1] - prev_val}->max() ; 
     prev_val := maxBucket[i+1] )  ;     i := i + 1 ) ; 
    max_gap := Set{max_gap, maxVal - prev_val}->max() ; 
    return max_gap 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,10,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxSortedAdjacentDiff(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static void printTaxicab2(int N){
    int i=1,count=0 ;
    while(count<N){
      int int_count=0 ;
      for(int j=1 ; j<=Math.pow(i,1.0/3); j++)for(int k=j+1 ; k<=Math.pow(i,1.0/3); k++)if(j*j*j+k*k*k==i)int_count++;
      if(int_count==2){
        count++;
        System.out.println(count+" "+i);
      }
      i++;
    }
  }
  public static void main(String[] args){
    int N=5 ;
    printTaxicab2(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printTaxicab2( N : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 1 ;
    var count : int ; count := 0 ;
     while (count < N) do (     var int_count : int ; int_count := 0 ;
         var j : int ; j := 1 ; while j <= i->pow(1.0 / 3) do (         var k : int ; k := j + 1 ; while k <= i->pow(1.0 / 3) do (     if (j * j * j + k * k * k = i) then     int_count := int_count + 1 ; else skip ;  ;     k := k + 1 ) ;  ;     j := j + 1 ) ; 
     if (int_count = 2) then (     count := count + 1 ; 
     OclFile["System.out"].println(count + " " + i) ) else skip ; 
     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     execute printTaxicab2(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner stdin=new Scanner(System.in);
    char[] inS=stdin.next().toCharArray();
    Arrays.sort(inS);
    char[] inT=stdin.next().toCharArray();
    Arrays.sort(inT);
    String result="No" ;
    for(int indexS=0,indexT=(inT.length-1); (indexS<inS.length)||(indexT>=0); indexS++,indexT--){
      if(indexS>=inS.length){
        result="Yes" ;
        break ;
      }
      else if(indexT<0){
        result="No" ;
        break ;
      }
      if(inS[indexS]<inT[indexT]){
        result="Yes" ;
        break ;
      }
      else if(inS[indexS]>inT[indexT]){
        result="No" ;
        break ;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inS : Sequence(String) ; inS := stdin.getCurrent()->characters() ;
    inS := inS->sort() ; 
    var inT : Sequence(String) ; inT := stdin.getCurrent()->characters() ;
    inT := inT->sort() ; 
    var result : String ; result := "No" ;
        var indexS : int ; indexS := 0 ;
    var indexT : int ; indexT := (inT->size() - 1) ; while (indexS < inS->size()) or (indexT >= 0) do ( (     if (indexS >= inS->size()) then (     result := "Yes" ; 
     break ) else     if (indexT < 0) then (     result := "No" ; 
     break ) else skip ; ;  
     if (inS[indexS+1] < inT[indexT+1]) then (     result := "Yes" ; 
     break ) else     if (inS[indexS+1] > inT[indexT+1]) then (     result := "No" ; 
     break ) else skip ; )  ;     indexS := indexS + 1 ;     indexT := indexT - 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.stream.IntStream ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.util.InputMismatchException ;
import java.io.BufferedReader ;
import java.util.OptionalInt ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskB solver=new TaskB();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskB {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      String s=in.nextString();
      String t=in.nextString();
      int maxS=s.chars().max().getAsInt();
      int minS=s.chars().min().getAsInt();
      int maxT=t.chars().max().getAsInt();
      int minT=t.chars().min().getAsInt();
      if(minS<maxT){
        out.println("Yes");
        return ;
      }
      if(minS==maxS && minT==maxT && s.length()<t.length()){
        out.println("Yes");
        return ;
      }
      out.println("No");
    }
  }
  static class InputReader {
    BufferedReader in ;
    StringTokenizer tok ;
    public String nextString(){
      while(! tok.hasMoreTokens()){
        try {
          tok=new StringTokenizer(in.readLine()," ");
        }
        catch(IOException e){
          throw new InputMismatchException();
        }
      }
      return tok.nextToken();
    }
    public InputReader(InputStream inputStream){
      in=new BufferedReader(new InputStreamReader(inputStream));
      tok=new StringTokenizer("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskB ; solver := TaskB.newTaskB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskB {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.nextString() ;
     var t : String ; t := in.nextString() ;
    var maxS : int ; maxS := s.chars().max().getAsInt() ;
    var minS : int ; minS := s.chars().min().getAsInt() ;
    var maxT : int ; maxT := t.chars().max().getAsInt() ;
    var minT : int ; minT := t.chars().min().getAsInt() ;
    if (minS < maxT) then (     skip ; 
     return ) else skip ; 
    if (minS = maxS & minT = maxT & s->size() < t->size()) then (     skip ; 
     return ) else skip ; 
    skip ; 
 );
}
  static class InputReader {
   attribute in : OclFile;
   attribute tok : OclIterator;
   operation nextString() : String
  pre: true
  post: true
  activity: (     while (not(tok.hasNext())) do (     try (     tok := OclIterator.newOclIterator_String_String(in.readLine(), " ") )   catch (e : IOException) do (     error IncorrectElementException() )
 ) ; 
     return tok.next() );
   static operation newInputReader( inputStream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) ; 
     tok := OclIterator.newOclIterator_String("") );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String t=sc.next();
    char[] ss=new char[s.length()];
    char[] tt=new char[t.length()];
    for(int i=0 ; i<s.length(); i++){
      ss[i]=s.charAt(i);
    }
    for(int i=0 ; i<t.length(); i++){
      tt[i]=t.charAt(i);
    }
    Arrays.sort(ss);
    Arrays.sort(tt);
    boolean ans=false ;
    boolean flag=false ;
    int len=Math.min(s.length(),t.length());
    for(int i=0 ; i<len ; i++){
      if(ss[i]<tt[tt.length-1-i]){
        ans=true ;
        break ;
      }
      if(ss[i]!=tt[tt.length-1-i])flag=true ;
      if(i==len-1 && ss.length>tt.length)ans=false ;
    }
    if(! flag && ss.length<tt.length)ans=true ;
    if(s.equals(t))ans=false ;
    if(ans)System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var ss : Sequence(String) ; ss := Integer.subrange(1,s->size())->collect(0) ;
    var tt : Sequence(String) ; tt := Integer.subrange(1,t->size())->collect(0) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     ss[i+1] := s->at(i+1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < t->size() do ( (     tt[i+1] := t->at(i+1) )  ;     i := i + 1 ) ; 
    ss := ss->sort() ; 
    tt := tt->sort() ; 
    var ans : boolean ; ans := false ;
    var flag : boolean ; flag := false ;
    var len : int ; len := Set{s->size(), t->size()}->min() ;
        var i : int ; i := 0 ; while i < len do ( (     if (ss[i+1] < tt[tt->size() - 1 - i+1]) then (     ans := true ; 
     break ) else skip ; 
     if (ss[i+1] /= tt[tt->size() - 1 - i+1]) then     flag := true ; else skip ; 
     if (i = len - 1 & ss->size() > tt->size()) then     ans := false ; else skip )  ;     i := i + 1 ) ; 
    if (not(flag) & ss->size() < tt->size()) then     ans := true ; else skip ; 
    if (s = t) then     ans := false ; else skip ; 
    if (ans) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.nio.charset.StandardCharsets ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader reader=new InputStreamReader(System.in,StandardCharsets.UTF_8);
    BufferedReader in=new BufferedReader(reader);
    char[] s=in.readLine().toCharArray();
    char[] t=in.readLine().toCharArray();
    Queue<Character>queS=new PriorityQueue<>(new Comparator<Character>(){
      @ Override public int compare(Character o1,Character o2){
        return Character.compare(o1,o2);
      }
    }
);
    Queue<Character>queT=new PriorityQueue<>(new Comparator<Character>(){
      @ Override public int compare(Character o1,Character o2){
        return-1*Character.compare(o1,o2);
      }
    }
);
    for(int i=0 ; i<s.length ; ++i){
      queS.add(s[i]);
    }
    for(int i=0 ; i<t.length ; ++i){
      queT.add(t[i]);
    }
    boolean enable=false ;
    boolean disable=false ;
    Character charS,charT ;
    while(! queS.isEmpty()&& ! queT.isEmpty()){
      charS=queS.poll();
      charT=queT.poll();
      if(charS<charT){
        enable=true ;
        break ;
      }
      if(charS>charT){
        enable=false ;
        disable=true ;
        break ;
      }
    }
    if(! enable && ! disable){
      if(queS.isEmpty()&& ! queT.isEmpty()){
        enable=true ;
      }
    }
    String result=enable ? "Yes" : "No" ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"], StandardCharsets.UTF_8) ;
     var in : OclFile ; in := OclFile.newOclFile_Read(reader) ;
    var s : Sequence(String) ; s := in.readLine()->characters() ;
    var t : Sequence(String) ; t := in.readLine()->characters() ;
    var queS : Sequence(String) ; queS := Sequence{}->union(OclComparator<String>.newOclComparator()) ;
    var queT : Sequence(String) ; queT := Sequence{}->union(OclComparator<String>.newOclComparator()) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     queS := queS->including(s[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < t->size() do ( (     queT := queT->including(t[i+1]) )  ;     i := i + 1 ) ; 
    var enable : boolean ; enable := false ;
    var disable : boolean ; disable := false ;
    var charS : String ;
    var charT : String ;
    while (not(queS->isEmpty()) & not(queT->isEmpty())) do (     charS := queS->min() ;     queS := queS->sort()->tail() ; 
     charT := queT->min() ;     queT := queT->sort()->tail() ; 
     if (charS < charT) then (     enable := true ; 
     break ) else skip ; 
     if (charS > charT) then (     enable := false ; 
     disable := true ; 
     break ) else skip ) ; 
    if (not(enable) & not(disable)) then (     if (queS->isEmpty() & not(queT->isEmpty())) then (     enable := true ) else skip ) else skip ; 
    var result : String ; result := if enable then "Yes" else "No" endif ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  static IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static IntStream REPS(int l,int r){
    return IntStream.rangeClosed(l,r);
  }
  static IntStream INS(int n){
    return REPS(n).map(i->getInt());
  }
  static Scanner s=new Scanner(System.in);
  static int getInt(){
    return Integer.parseInt(s.next());
  }
  public static void main(String[] $){
    int x=getInt(),y=getInt(),g=gcd(x,y),X=x/g,Y=y/g ;
    System.out.println(x+y-g+1);
  }
  static int gcd(int a,int b){
    return a % b==0 ? b : gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static   operation REPS( l : int, r : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(l, r) );
  static   operation INS( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return REPS(n)->collect( _x1 | (lambda i : OclAny in getInt())->apply(_x1) ) );
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := getInt() ;
    var y : int ; y := getInt() ;
    var g : int ; g := gcd(x, y) ;
    var X : int ; X := x / g ;
    var Y : int ; Y := y / g ;
     OclFile["System.out"].println(x + y - g + 1) );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if a mod b = 0 then b else gcd(b, a mod b) endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int b=sc.nextInt();
    long[] ans=new long[n];
    LinkedList<Long>q=new LinkedList<>();
    for(int i=0 ; i<n ; i++){
      int t=sc.nextInt();
      int d=sc.nextInt();
      while(! q.isEmpty()&& q.getFirst()<=t){
        q.pollFirst();
      }
      if(q.size()<=b){
        ans[i]=(q.isEmpty()? t : q.getLast())+d ;
        q.add(ans[i]);
      }
      else {
        ans[i]=-1 ;
      }
    }
    for(int i=0 ; i<n ; ++i){
      System.out.print(ans[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var ans : Sequence(long) ; ans := Integer.subrange(1,n)->collect(0) ;
    var q : Sequence(long) ; q := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var d : int ; d := sc.getCurrent()->toInteger() ;
     while (not(q->isEmpty()) & q->first() <= t) do (     q := q->tail() ) ; 
     if (q->size() <= b) then (     ans[i+1] := (if q->isEmpty() then t else q->last() endif) + d ; 
     q := q->including(ans[i+1]) ) else (     ans[i+1] := -1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(ans[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    ArrayList<ArrayList<Integer>>graph=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      graph.add(new ArrayList<>());
    }
    for(int i=0 ; i<m ; i++){
      int a=sc.nextInt()-1 ;
      int b=sc.nextInt()-1 ;
      graph.get(a).add(b);
    }
    int start=sc.nextInt()-1 ;
    int end=sc.nextInt()-1 ;
    PriorityQueue<Path>queue=new PriorityQueue<>();
    queue.add(new Path(start,0,0));
    int[][] costs=new int[3][n];
    for(int[] arr : costs){
      Arrays.fill(arr,Integer.MAX_VALUE);
    }
    while(queue.size()>0){
      Path p=queue.poll();
      if(costs[p.mod][p.idx]<=p.value){
        continue ;
      }
      costs[p.mod][p.idx]=p.value ;
      for(int x : graph.get(p.idx)){
        queue.add(new Path(x,(p.mod+1)% 3,p.value+1));
      }
    }
    if(costs[0][end]==Integer.MAX_VALUE){
      System.out.println(-1);
    }
    else {
      System.out.println(costs[0][end]/3);
    }
  }
  static class Path implements Comparable<Path>{
    int idx ;
    int mod ;
    int value ;
    public Path(int idx,int mod,int value){
      this.idx=idx ;
      this.mod=mod ;
      this.value=value ;
    }
    public int compareTo(Path another){
      return value-another.value ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var graph : Sequence(Sequence(int)) ; graph := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     graph := graph->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
     var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
     graph->at(a+1)->excludes(b) )  ;     i := i + 1 ) ; 
    var start : int ; start := sc.getCurrent()->toInteger() - 1 ;
    var end : int ; end := sc.getCurrent()->toInteger() - 1 ;
    var queue : Sequence(String) ; queue := Sequence{} ;
    queue := queue->including(String(start, 0, 0)) ; 
    var costs : Sequence(Sequence(int)) ; costs := Integer.subrange(1,3)->collect(Integer.subrange(1,n)->collect(0)) ;
    for (arr : costs) do ( (     arr := arr->collect(2147483647) )  ) ; 
    while (queue->size() > 0) do (     var p : String ; p := queue->min() ;
     if (costs[p.mod+1][p.idx+1] <= p.value) then (     continue ) else skip ; 
     costs[p.mod+1][p.idx+1] := p.value ; 
     for (x : graph->at(p.idx+1)) do ( (     queue := queue->including(String(x, (p.mod + 1) mod 3, p.value + 1)) )  ) ) ; 
    if (costs[0+1][end+1] = 2147483647) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(costs[0+1][end+1] / 3) ) ;  
 );
  static class Path implements Comparable<String> {
   attribute idx : int;
   attribute mod : int;
   attribute value : int;
   static operation newPath( idx : int, mod : int, value : int) : Path
  pre: true
  post: true
  activity:
  ( var self : Path ;
    self := createPath();
    self.initialise(idx, mod,value);
    return self );
  operation initialise( idx : int, mod : int, value : int) : void
  pre: true  post: true
  activity: (     self.idx := idx ; 
     self.mod := mod ; 
     self.value := value );
   operation compareTo( another : String) : int
  pre: true
  post: true
  activity: (     return (value)->char2byte() - another.value );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String s=scanner.next();
    String t=scanner.next();
    char[] sAr=s.toCharArray();
    char[] tAr=t.toCharArray();
    char[] sd=chsort(sAr);
    if(Comp(sd,tAr))System.out.println("Yes");
    else System.out.println("No");
  };
  private static char[] chsort(char[] s){
    Arrays.sort(s);
    return s ;
  }
  private static Boolean Comp(char[] s,char[] t){
    int len=min(s.length,t.length);
    Boolean b ;
    int judge=0 ;
    for(int i=0 ; i<len ; i++){
      int j=i ;
      b=false ;
      while((j<t.length)&&(! b)){
        if(s[i]<t[j]){
          char c=t[i];
          t[i]=t[j];
          t[j]=c ;
          b=true ;
          judge=1 ;
        }
        else if((s[i]==t[j])&&(judge==0)){
          judge=0 ;
        }
        else {
          judge=-1 ;
        }
        j++;
      }
      if((b))return b ;
    }
    if((judge==0)&&(s.length<t.length)){
      return true ;
    }
    else {
      return false ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scanner.getCurrent() ;
    var t : String ; t := scanner.getCurrent() ;
    var sAr : Sequence(String) ; sAr := s->characters() ;
    var tAr : Sequence(String) ; tAr := t->characters() ;
    var sd : Sequence(String) ; sd := chsort(sAr) ;
    if (Comp(sd, tAr)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
  static   operation chsort( s : Sequence(String)) : Sequence(String)
  pre: true
  post: true
  activity: (     s := s->sort() ; 
     return s );
  static   operation Comp( s : Sequence(String), t : Sequence(String)) : Boolean
  pre: true
  post: true
  activity: (     var len : int ; len := min(s->size(), t->size()) ;
     var b : Boolean ;
    var judge : int ; judge := 0 ;
        var i : int ; i := 0 ; while i < len do ( (     var j : int ; j := i ;
     b := false ; 
     while ((j < t->size()) & (not(b))) do (     if (s[i+1] < t[j+1]) then (     var c : String ; c := t[i+1] ;
     t[i+1] := t[j+1] ; 
    t[j+1] := c ; 
    b := true ; 
    judge := 1 ; 
 ) else     if ((s[i+1] = t[j+1]) & (judge = 0)) then (     judge := 0 ) else (     judge := -1 ) ;  ;  
     j := j + 1 ) ; 
     if ((b)) then     return b else skip )  ;     i := i + 1 ) ; 
    if ((judge = 0) & (s->size() < t->size())) then (     return true ) else (     return false ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class c63a {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    String captain="" ;
    ArrayList<String>rats=new ArrayList<>();
    ArrayList<String>wc=new ArrayList<>();
    ArrayList<String>m=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      String name=scan.next();
      String shenfen=scan.next();
      if(shenfen.equals("captain"))captain=name ;
      else if(shenfen.equals("woman")|| shenfen.equals("child"))wc.add(name);
      else if(shenfen.equals("rat"))rats.add(name);
      else m.add(name);
    }
    for(int i=0 ; i<rats.size(); i++){
      System.out.println(rats.get(i));
    }
    for(int i=0 ; i<wc.size(); i++){
      System.out.println(wc.get(i));
    }
    for(int i=0 ; i<m.size(); i++){
      System.out.println(m.get(i));
    }
    System.out.println(captain);
  }
}
------------------------------------------------------------
OCL File:
---------
 class c63a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var captain : String ; captain := "" ;
    var rats : Sequence(String) ; rats := Sequence{} ;
    var wc : Sequence(String) ; wc := Sequence{} ;
    var m : Sequence(String) ; m := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var name : String ; name := scan.getCurrent() ;
     var shenfen : String ; shenfen := scan.getCurrent() ;
     if (shenfen = "captain") then     captain := name ; else     if (shenfen = "woman" or shenfen = "child") then     wc := wc->including(name) else     if (shenfen = "rat") then     rats := rats->including(name) else     m := m->including(name) ; ;  ;  )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < rats->size() do ( (     OclFile["System.out"].println(rats->at(i+1)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < wc->size() do ( (     OclFile["System.out"].println(wc->at(i+1)) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m->size() do ( (     OclFile["System.out"].println(m->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(captain) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class cf63A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    String cap="" ;
    ArrayList<String>rats=new ArrayList<>();
    ArrayList<String>womenChildren=new ArrayList<>();
    ArrayList<String>men=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      String name=scan.next();
      String status=scan.next();
      if(status.equals("captain")){
        cap=name ;
      }
      else if(status.equals("rat")){
        rats.add(name);
      }
      else if(status.equals("woman")|| status.equals("child")){
        womenChildren.add(name);
      }
      else if(status.equals("man")){
        men.add(name);
      }
    }
    ArrayList<String>Everybody=new ArrayList<>();
    Everybody.addAll(rats);
    Everybody.addAll(womenChildren);
    Everybody.addAll(men);
    Everybody.add(cap);
    print(Everybody);
  }
  static void print(ArrayList<String>list){
    for(int i=0 ; i<list.size(); i++){
      System.out.println(list.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf63A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var cap : String ; cap := "" ;
    var rats : Sequence(String) ; rats := Sequence{} ;
    var womenChildren : Sequence(String) ; womenChildren := Sequence{} ;
    var men : Sequence(String) ; men := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var name : String ; name := scan.getCurrent() ;
     var status : String ; status := scan.getCurrent() ;
     if (status = "captain") then (     cap := name ) else     if (status = "rat") then (     rats := rats->including(name) ) else     if (status = "woman" or status = "child") then (     womenChildren := womenChildren->including(name) ) else     if (status = "man") then (     men := men->including(name) ) else skip ; ;  ;  )  ;     i := i + 1 ) ; 
    var Everybody : Sequence(String) ; Everybody := Sequence{} ;
    Everybody := Everybody->union(rats) ; 
    Everybody := Everybody->union(womenChildren) ; 
    Everybody := Everybody->union(men) ; 
    Everybody := Everybody->including(cap) ; 
    execute print(Everybody) ; 
 );
  static   operation print( list : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < list->size() do ( (     OclFile["System.out"].println(list->at(i+1)) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class cf63A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    String cap="" ;
    ArrayList<String>rats=new ArrayList<>();
    ArrayList<String>womenChildren=new ArrayList<>();
    ArrayList<String>men=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      String name=scan.next();
      String status=scan.next();
      if(status.equals("captain")){
        cap=name ;
      }
      else if(status.equals("rat")){
        rats.add(name);
      }
      else if(status.equals("woman")|| status.equals("child")){
        womenChildren.add(name);
      }
      else if(status.equals("man")){
        men.add(name);
      }
    }
    ArrayList<String>Everybody=new ArrayList<>();
    Everybody.addAll(rats);
    Everybody.addAll(womenChildren);
    Everybody.addAll(men);
    Everybody.add(cap);
    print(Everybody);
  }
  static void print(ArrayList<String>list){
    for(int i=0 ; i<list.size(); i++){
      System.out.println(list.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf63A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var cap : String ; cap := "" ;
    var rats : Sequence(String) ; rats := Sequence{} ;
    var womenChildren : Sequence(String) ; womenChildren := Sequence{} ;
    var men : Sequence(String) ; men := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var name : String ; name := scan.getCurrent() ;
     var status : String ; status := scan.getCurrent() ;
     if (status = "captain") then (     cap := name ) else     if (status = "rat") then (     rats := rats->including(name) ) else     if (status = "woman" or status = "child") then (     womenChildren := womenChildren->including(name) ) else     if (status = "man") then (     men := men->including(name) ) else skip ; ;  ;  )  ;     i := i + 1 ) ; 
    var Everybody : Sequence(String) ; Everybody := Sequence{} ;
    Everybody := Everybody->union(rats) ; 
    Everybody := Everybody->union(womenChildren) ; 
    Everybody := Everybody->union(men) ; 
    Everybody := Everybody->including(cap) ; 
    execute print(Everybody) ; 
 );
  static   operation print( list : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < list->size() do ( (     OclFile["System.out"].println(list->at(i+1)) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class cf63a {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    String cap="" ;
    ArrayList<String>rats=new ArrayList<>();
    ArrayList<String>womenChildren=new ArrayList<>();
    ArrayList<String>men=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      String name=scan.next();
      String status=scan.next();
      if(status.equals("captain")){
        cap=name ;
      }
      else if(status.equals("rat")){
        rats.add(name);
      }
      else if(status.equals("woman")|| status.equals("child")){
        womenChildren.add(name);
      }
      else if(status.equals("man")){
        men.add(name);
      }
    }
    ArrayList<String>Everybody=new ArrayList<>();
    Everybody.addAll(rats);
    Everybody.addAll(womenChildren);
    Everybody.addAll(men);
    Everybody.add(cap);
    print(Everybody);
  }
  static void print(ArrayList<String>list){
    for(int i=0 ; i<list.size(); i++){
      System.out.println(list.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf63a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var cap : String ; cap := "" ;
    var rats : Sequence(String) ; rats := Sequence{} ;
    var womenChildren : Sequence(String) ; womenChildren := Sequence{} ;
    var men : Sequence(String) ; men := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var name : String ; name := scan.getCurrent() ;
     var status : String ; status := scan.getCurrent() ;
     if (status = "captain") then (     cap := name ) else     if (status = "rat") then (     rats := rats->including(name) ) else     if (status = "woman" or status = "child") then (     womenChildren := womenChildren->including(name) ) else     if (status = "man") then (     men := men->including(name) ) else skip ; ;  ;  )  ;     i := i + 1 ) ; 
    var Everybody : Sequence(String) ; Everybody := Sequence{} ;
    Everybody := Everybody->union(rats) ; 
    Everybody := Everybody->union(womenChildren) ; 
    Everybody := Everybody->union(men) ; 
    Everybody := Everybody->including(cap) ; 
    execute print(Everybody) ; 
 );
  static   operation print( list : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < list->size() do ( (     OclFile["System.out"].println(list->at(i+1)) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.System.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    int n=sc.nextInt();
    String[] vals=new String[n];
    String[] keys=new String[n];
    Map<Integer,List<String>>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      vals[i]=sc.next();
      keys[i]=sc.next();
    }
    List<String>lst_captian=new ArrayList<String>();
    List<String>lst_rat=new ArrayList<String>();
    List<String>lst_women=new ArrayList<String>();
    List<String>lst_men=new ArrayList<String>();
    for(int j=0 ; j<n ; j++){
      if(keys[j] .equals("captain")){
        if(! lst_captian.contains(vals[j]))lst_captian.add(vals[j]);
      }
      if(keys[j] .equals("woman")|| keys[j] .equals("child")){
        if(! lst_women.contains(vals[j]))lst_women.add(vals[j]);
      }
      if(keys[j] .equals("man")){
        if(! lst_men.contains(vals[j]))lst_men.add(vals[j]);
      }
      if(keys[j] .equals("rat")){
        if(! lst_rat.contains(vals[j]))lst_rat.add(vals[j]);
      }
    }
    map.put(4,lst_captian);
    map.put(2,lst_women);
    map.put(3,lst_men);
    map.put(1,lst_rat);
    for(Map.Entry<Integer,List<String>>entry : map.entrySet()){
      for(String e : entry.getValue())out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var vals : Sequence(String) ; vals := Integer.subrange(1,n)->collect(null) ;
    var keys : Sequence(String) ; keys := Integer.subrange(1,n)->collect(null) ;
    var map : Map(int,Sequence(String)) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     vals[i+1] := sc.getCurrent() ; 
     keys[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    var lst_captian : Sequence(String) ; lst_captian := Sequence{} ;
    var lst_rat : Sequence(String) ; lst_rat := Sequence{} ;
    var lst_women : Sequence(String) ; lst_women := Sequence{} ;
    var lst_men : Sequence(String) ; lst_men := Sequence{} ;
        var j : int ; j := 0 ; while j < n do ( (     if (keys[j+1] = "captain") then (     if (not(lst_captian->includes(vals[j+1]))) then     lst_captian := lst_captian->including(vals[j+1]) ; else skip ) else skip ; 
     if (keys[j+1] = "woman" or keys[j+1] = "child") then (     if (not(lst_women->includes(vals[j+1]))) then     lst_women := lst_women->including(vals[j+1]) ; else skip ) else skip ; 
     if (keys[j+1] = "man") then (     if (not(lst_men->includes(vals[j+1]))) then     lst_men := lst_men->including(vals[j+1]) ; else skip ) else skip ; 
     if (keys[j+1] = "rat") then (     if (not(lst_rat->includes(vals[j+1]))) then     lst_rat := lst_rat->including(vals[j+1]) ; else skip ) else skip )  ;     j := j + 1 ) ; 
    map := map->union(Map{4 |-> lst_captian}) ; 
    map := map->union(Map{2 |-> lst_women}) ; 
    map := map->union(Map{3 |-> lst_men}) ; 
    map := map->union(Map{1 |-> lst_rat}) ; 
    for (entry : map->asSet()) do ( (     for (e : entry.getValue()) do (     out.println(e) ;  ) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean squareRootExists(int n,int p){
    n=n % p ;
    for(int x=2 ; x<p ; x++)if((x*x)% p==n)return true ;
    return false ;
  }
  public static void main(String[] args){
    int p=7 ;
    int n=2 ;
    if(squareRootExists(n,p))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation squareRootExists( n : int, p : int) : boolean
  pre: true
  post: true
  activity: (     n := n mod p ; 
         var x : int ; x := 2 ; while x < p do (     if ((x * x) mod p = n) then     return true else skip ;  ;     x := x + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : int ; p := 7 ;
     var n : int ; n := 2 ;
     if (squareRootExists(n, p)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[][] A=new int[2][N];
    for(int i=0 ; i<2 ; i++)for(int j=0 ; j<N ; j++)A[i][j]=sc.nextInt();
    int[][] B=new int[2][N];
    B[1][N-1]=A[1][N-1];
    B[0][N-1]=A[0][N-1]+A[1][N-1];
    for(int j=N-2 ; j>0-1 ; j--){
      B[1][j]=A[1][j]+B[1][j+1];
      B[0][j]=A[0][j]+Math.max(B[0][j+1],B[1][j]);
    }
    System.out.println(B[0][0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(Sequence(int)) ; A := Integer.subrange(1,2)->collect(Integer.subrange(1,N)->collect(0)) ;
        var i : int ; i := 0 ; while i < 2 do (         var j : int ; j := 0 ; while j < N do (     A[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var B : Sequence(Sequence(int)) ; B := Integer.subrange(1,2)->collect(Integer.subrange(1,N)->collect(0)) ;
    B[1+1][N - 1+1] := A[1+1][N - 1+1] ; 
    B[0+1][N - 1+1] := A[0+1][N - 1+1] + A[1+1][N - 1+1] ; 
        var j : int ; j := N - 2 ; while j > 0 - 1 do ( (     B[1+1][j+1] := A[1+1][j+1] + B[1+1][j + 1+1] ; 
     B[0+1][j+1] := A[0+1][j+1] + Set{B[0+1][j + 1+1], B[1+1][j+1]}->max() )  ;     j := j - 1 ) ; 
    OclFile["System.out"].println(B[0+1][0+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=sc.nextInt();
    int[][] a=new int[2][n];
    for(int i=0 ; i<2 ; i++)for(int j=0 ; j<n ; j++)a[i][j]=sc.nextInt();
    int ans=0 ;
    for(int right=0 ; right<n ; right++){
      int row=0 ;
      int c=0 ;
      for(int i=0 ; i<n ; i++){
        c+=a[row][i];
        if(i==right){
          row=1 ;
          c+=a[row][i];
        }
      }
      ans=Math.max(c,ans);
    }
    System.out.println(ans);
    pw.flush();
    pw.close();
  }
  static class Scanner {
    BufferedReader br ;
    StringTokenizer st ;
    public Scanner(InputStream S){
      br=new BufferedReader(new InputStreamReader(S));
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(nextLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,2)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < 2 do (         var j : int ; j := 0 ; while j < n do (     a[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var right : int ; right := 0 ; while right < n do ( (     var row : int ; row := 0 ;
     var c : int ; c := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     c := c+(a[row+1][i+1]) ; 
     if (i = right) then (     row := 1 ; 
     c := c+(a[row+1][i+1]) ) else skip )  ;     i := i + 1 ) ; 
     ans := Set{c, ans}->max() )  ;     right := right + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newScanner( S : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(S);
    return self );
  operation initialise( S : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(S)) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(nextLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Queue ;
import java.util.Scanner ;
public class b07 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t,d ;
    int n=sc.nextInt();
    int x=sc.nextInt();
    Queue<Long>q=new LinkedList<Long>();
    long process=0 ;
    for(int i=0 ; i<n ; i++){
      t=sc.nextInt();
      d=sc.nextInt();
      while(! q.isEmpty()&& q.peek()<=t){
        q.remove();
      }
      if(q.size()<=x){
        process=Math.max(process,t)+d ;
        System.out.println(process);
        q.add(process);
      }
      else {
        System.out.println("-1");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class b07 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ;
    var d : int ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var q : Sequence(long) ; q := Sequence{} ;
    var process : long ; process := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     t := sc.getCurrent()->toInteger() ; 
     d := sc.getCurrent()->toInteger() ; 
     while (not(q->isEmpty()) & q->min() <= t) do (     q := q.remove() ) ; 
     if (q->size() <= x) then (     process := Set{process, t}->max() + d ; 
     OclFile["System.out"].println(process) ; 
     q := q->including(process) ) else (     OclFile["System.out"].println("-1") ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int N=Integer.parseInt(reader.readLine());
    int[][] grid=new int[2][N];
    for(int i=0 ; i<2 ; i++){
      String[] temp=reader.readLine().split("[] ");
      for(int j=0 ; j<N ; j++){
        grid[i][j]=Integer.parseInt(temp[j]);
      }
    }
    System.out.println(solution(grid,N));
  }
  public static int solution(int[][] grid,int N){
    for(int i=1 ; i>=0 ; i--){
      for(int j=N-1 ; j>=0 ; j--){
        int current=0 ;
        if(j+1<N){
          current=Math.max(current,grid[i][j+1]);
        }
        if(i+1<2){
          current=Math.max(current,grid[i+1][j]);
        }
        grid[i][j]+=current ;
      }
    }
    return grid[0][0];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var N : int ; N := (reader.readLine())->toInteger() ;
    var grid : Sequence(Sequence(int)) ; grid := Integer.subrange(1,2)->collect(Integer.subrange(1,N)->collect(0)) ;
        var i : int ; i := 0 ; while i < 2 do ( (     var temp : Sequence(String) ; temp := reader.readLine()->split("[] ") ;
         var j : int ; j := 0 ; while j < N do ( (     grid[i+1][j+1] := (temp[j+1])->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solution(grid, N)) ; 
 );
  static   operation solution( grid : Sequence(Sequence(int)), N : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i >= 0 do ( (         var j : int ; j := N - 1 ; while j >= 0 do ( (     var current : int ; current := 0 ;
     if (j + 1 < N) then (     current := Set{current, grid[i+1][j + 1+1]}->max() ) else skip ; 
     if (i + 1 < 2) then (     current := Set{current, grid[i + 1+1][j+1]}->max() ) else skip ; 
     grid[i+1][j+1] := grid[i+1][j+1]+(current) )  ;     j := j - 1 ) )  ;     i := i - 1 ) ; 
     return grid[0+1][0+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    ArrayList<ArrayList<Integer>>graph=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      graph.add(new ArrayList<>());
    }
    for(int i=0 ; i<m ; i++){
      graph.get(sc.nextInt()-1).add(sc.nextInt()-1);
    }
    int start=sc.nextInt()-1 ;
    int end=sc.nextInt()-1 ;
    PriorityQueue<Path>queue=new PriorityQueue<>();
    queue.add(new Path(start,0,0));
    int[][] points=new int[3][n];
    for(int i=0 ; i<3 ; i++){
      Arrays.fill(points[i],Integer.MAX_VALUE);
    }
    while(queue.size()>0){
      Path p=queue.poll();
      if(points[p.count][p.idx]<=p.value){
        continue ;
      }
      points[p.count][p.idx]=p.value ;
      for(int x : graph.get(p.idx)){
        queue.add(new Path(x,p.value+1,(p.count+1)% 3));
      }
    }
    if(points[0][end]==Integer.MAX_VALUE){
      System.out.println(-1);
    }
    else {
      System.out.println(points[0][end]/3);
    }
  }
  static class Path implements Comparable<Path>{
    int idx ;
    int value ;
    int count ;
    public Path(int idx,int value,int count){
      this.idx=idx ;
      this.value=value ;
      this.count=count ;
    }
    public int compareTo(Path another){
      return value-another.value ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var graph : Sequence(Sequence(int)) ; graph := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     graph := graph->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     graph->at(sc.getCurrent()->toInteger() - 1+1)->excludes(sc.getCurrent()->toInteger() - 1) )  ;     i := i + 1 ) ; 
    var start : int ; start := sc.getCurrent()->toInteger() - 1 ;
    var end : int ; end := sc.getCurrent()->toInteger() - 1 ;
    var queue : Sequence(String) ; queue := Sequence{} ;
    queue := queue->including(String(start, 0, 0)) ; 
    var points : Sequence(Sequence(int)) ; points := Integer.subrange(1,3)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < 3 do ( (     points[i+1] := points[i+1]->collect(2147483647) )  ;     i := i + 1 ) ; 
    while (queue->size() > 0) do (     var p : String ; p := queue->min() ;
     if (points[p.count+1][p.idx+1] <= p.value) then (     continue ) else skip ; 
     points[p.count+1][p.idx+1] := p.value ; 
     for (x : graph->at(p.idx+1)) do ( (     queue := queue->including(String(x, p.value + 1, (p.count + 1) mod 3)) )  ) ) ; 
    if (points[0+1][end+1] = 2147483647) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(points[0+1][end+1] / 3) ) ;  
 );
  static class Path implements Comparable<String> {
   attribute idx : int;
   attribute value : int;
   attribute count : int;
   static operation newPath( idx : int, value : int, count : int) : Path
  pre: true
  post: true
  activity:
  ( var self : Path ;
    self := createPath();
    self.initialise(idx, value,count);
    return self );
  operation initialise( idx : int, value : int, count : int) : void
  pre: true  post: true
  activity: (     self.idx := idx ; 
     self.value := value ; 
     self.count := count );
   operation compareTo( another : String) : int
  pre: true
  post: true
  activity: (     return (value)->char2byte() - another.value );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[][] a=new int[2][N];
    for(int i=0 ; i<N ; i++)a[0][i]=sc.nextInt();
    for(int i=0 ; i<N ; i++)a[1][i]=sc.nextInt();
    sc.close();
    int[] dp1=new int[N];
    int[] dp2=new int[N];
    dp1[0]=a[0][0];
    dp2[0]=a[1][0];
    for(int i=1 ; i<N ; i++){
      dp1[i]=a[0][i]+dp1[i-1];
      dp2[i]=a[1][i]+dp2[i-1];
    }
    int max=0 ;
    for(int i=0 ; i<N ; i++){
      int target=i==0 ? dp1[i]+dp2[N-1] : dp1[i]+dp2[N-1]-dp2[i-1];
      max=Math.max(max,target);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,2)->collect(Integer.subrange(1,N)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do (     a[0+1][i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do (     a[1+1][i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    skip ; 
    var dp1 : Sequence(int) ; dp1 := Integer.subrange(1,N)->collect(0) ;
    var dp2 : Sequence(int) ; dp2 := Integer.subrange(1,N)->collect(0) ;
    dp1[0+1] := a[0+1][0+1] ; 
    dp2[0+1] := a[1+1][0+1] ; 
        var i : int ; i := 1 ; while i < N do ( (     dp1[i+1] := a[0+1][i+1] + dp1[i - 1+1] ; 
     dp2[i+1] := a[1+1][i+1] + dp2[i - 1+1] )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var target : int ; target := if i = 0 then dp1[i+1] + dp2[N - 1+1] else dp1[i+1] + dp2[N - 1+1] - dp2[i - 1+1] endif ;
     max := Set{max, target}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[][] A=new int[2][N+1];
    int[] t0=new int[N+1];
    int[] t1=new int[N+1];
    int[] ans=new int[N+1];
    int total0=0,total1=0 ;
    for(int i=1 ; i<=N ; i++){
      A[0][i]=sc.nextInt();
      total0+=A[0][i];
      t0[i]=total0 ;
    }
    for(int i=1 ; i<=N ; i++){
      A[1][i]=sc.nextInt();
    }
    for(int i=N ; i>=1 ; i--){
      total1+=A[1][i];
      t1[i]=total1 ;
    }
    for(int i=1 ; i<=N ; i++){
      ans[i]=t0[i]+t1[i];
    }
    Arrays.sort(ans);
    System.out.println(ans[N]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(Sequence(int)) ; A := Integer.subrange(1,2)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
    var t0 : Sequence(int) ; t0 := Integer.subrange(1,N + 1)->collect(0) ;
    var t1 : Sequence(int) ; t1 := Integer.subrange(1,N + 1)->collect(0) ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,N + 1)->collect(0) ;
    var total0 : int ; total0 := 0 ;
    var total1 : int ; total1 := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     A[0+1][i+1] := sc.getCurrent()->toInteger() ; 
     total0 := total0+(A[0+1][i+1]) ; 
     t0[i+1] := total0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (     A[1+1][i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := N ; while i >= 1 do ( (     total1 := total1+(A[1+1][i+1]) ; 
     t1[i+1] := total1 )  ;     i := i - 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (     ans[i+1] := t0[i+1] + t1[i+1] )  ;     i := i + 1 ) ; 
    ans := ans->sort() ; 
    OclFile["System.out"].println(ans[N+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class LuckyMask {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    if(scanner.hasNext()){
      int a=scanner.nextInt();
      String b=scanner.next();
      for(int i=a+1 ; ; i++){
        String s=String.valueOf(i).replaceAll("[0,1,2,3,5,6,8,9] ","");
        if(s.equals(b)){
          System.out.println(i);
          return ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class LuckyMask {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     if (scanner.hasNext()) then (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : String ; b := scanner.getCurrent() ;
         var i : int ; i := a + 1 ; while true do ( (     var s : String ; s := ((i) + "").replaceAllMatches("[0,1,2,3,5,6,8,9] ", "" ) ;
     if (s = b) then (     OclFile["System.out"].println(i) ; 
     return ) else skip )  ;     i := i + 1 ) ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int test=1 ;
    while(test-->0){
      solve(cin);
    }
  }
  private static void solve(Scanner cin){
    int a,b ;
    a=cin.nextInt();
    b=cin.nextInt();
    if(b>a){
      System.out.println(b);
      return ;
    }
    while(true){
      a++;
      if(getNumber(a+"")==b)break ;
    }
    System.out.println(a);
  }
  private static Integer getNumber(String s){
    String gather="" ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='4' || s.charAt(i)=='7')gather+=s.charAt(i);
    }
    return gather.isEmpty()? 0 : Integer.parseInt(gather);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := 1 ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     execute solve(cin) ) ;  ) );
  static   operation solve( cin : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ;
    var b : int ;
     a := cin.getCurrent()->toInteger() ; 
    b := cin.getCurrent()->toInteger() ; 
    if (b > a) then (     OclFile["System.out"].println(b) ; 
     return ) else skip ; 
    while (true) do (     a := a + 1 ; 
     if (getNumber(a + "") = b) then     break else skip ) ; 
    OclFile["System.out"].println(a) ; 
 );
  static   operation getNumber( s : String) : int
  pre: true
  post: true
  activity: (     var gather : String ; gather := "" ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '4' or s->at(i+1) = '7') then     gather := gather+(s->at(i+1)) ; else skip )  ;     i := i + 1 ) ; 
     return if gather->isEmpty() then 0 else (gather)->toInteger() endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class luckyMask {
  static int lucky[]={
    0,0,0,0,1,0,0,1,0,0 };
    static int a,b ;
    public static void main(String[] args){
      load();
      solve();
      System.out.println(a);
    }
    static void load(){
      Scanner in=new Scanner(System.in);
      a=in.nextInt();
      b=in.nextInt();
      a++;
    }
    static long find_lucky(int t){
      int d=1 ;
      int res=0 ;
      while(t!=0){
        int tmp=t % 10 ;
        if(lucky[tmp]!=0){
          res+=tmp*d ;
          d*=10 ;
        }
        t/=10 ;
      }
      return res ;
    }
    static void solve(){
      while(find_lucky(a)!=b)a++;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class luckyMask {
  static   attribute lucky : int := Sequence{0,0,0,0,1,0,0,1,0,0};
  static   attribute a : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute load() ; 
     execute solve() ; 
     OclFile["System.out"].println(a) );
  static   operation load() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     a := in.getCurrent()->toInteger() ; 
     b := in.getCurrent()->toInteger() ; 
     a := a + 1 );
  static   operation find_lucky( t : int) : long
  pre: true
  post: true
  activity: (     var d : int ; d := 1 ;
     var res : int ; res := 0 ;
     while (t /= 0) do (     var tmp : int ; tmp := t mod 10 ;
     if (lucky[tmp+1] /= 0) then (     res := res+(tmp * d) ; 
     d := d*(10) ) else skip ; 
     t := t/(10) ) ; 
     return res );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     while (find_lucky(a) /= b) do     a := a + 1 ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class B134 {
  static int solve(int x,int y){
    int cnt=0 ;
    if(x==1 && y==1)return 0 ;
    while(true){
      if(x==0 || y==0)return Integer.MAX_VALUE ;
      if(x==1 || y==1)return(cnt+Math.max(x,y)-1);
      if(x>y)x-=y ;
      else y-=x ;
      cnt++;
    }
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int ans=Integer.MAX_VALUE ;
    for(int i=1 ; i<=n ; ++i){
      ans=Math.min(ans,solve(n,i));
    }
    if(n<=2)ans=n-1 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B134 {
  static   operation solve( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     if (x = 1 & y = 1) then     return 0 else skip ; 
     while (true) do (     if (x = 0 or y = 0) then     return 2147483647 else skip ; 
     if (x = 1 or y = 1) then     return (cnt + Set{x, y}->max() - 1) else skip ; 
     if (x > y) then     x := x-(y) else     y := y-(x) ; ;  
     cnt := cnt + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 1 ; while i <= n do ( (     ans := Set{ans, solve(n, i)}->min() )  ;     i := i + 1 ) ; 
    if (n <= 2) then     ans := n - 1 ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  static int ans=Integer.MAX_VALUE ;
  public static void calculate_single_pair_upwards(int a,int b,int count){
    if(a==1 && b==1){
      ans=Math.min(ans,count);
    }
    if(a-b>0){
      calculate_single_pair_upwards(a-b,b,count+1);
    }
    if(b-a>0){
      calculate_single_pair_upwards(a,b-a,count+1);
    }
  }
  public static void pairs(int n){
    if(n==1){
      System.out.println(0);
      return ;
    }
    for(int i=1 ; i<(n/2+1); i++){
      calculate_single_pair_upwards(i,n-i,1);
    }
    System.out.println(ans);
  }
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    pairs(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ans : int := 2147483647;
  static   operation calculate_single_pair_upwards( a : int, b : int, count : int) : void
  pre: true
  post: true
  activity: (     if (a = 1 & b = 1) then (     ans := Set{ans, count}->min() ) else skip ; 
     if (a - b > 0) then (     execute calculate_single_pair_upwards(a - b, b, count + 1) ) else skip ; 
     if (b - a > 0) then (     execute calculate_single_pair_upwards(a, b - a, count + 1) ) else skip );
  static   operation pairs( n : int) : void
  pre: true
  post: true
  activity: (     if (n = 1) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
         var i : int ; i := 1 ; while i < (n / 2 + 1) do ( (     execute calculate_single_pair_upwards(i, n - i, 1) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
     execute pairs(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int sum=0 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      char[] c=(sc.next()+"a").toCharArray();
      int res=0 ;
      for(int i=0 ; i<c.length ; i++){
        if('0'<=c[i] && c[i]<='9'){
          res=res*10+(c[i]-'0');
        }
        else {
          sum+=res ;
          res=0 ;
        }
      }
    }
    System.out.println(sum);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sum : int := 0;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var c : Sequence(String) ; c := (sc.getCurrent() + "a")->characters() ;
     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < c->size() do ( (     if ('0' <= c[i+1] & c[i+1] <= '9') then (     res := res * 10 + (c[i+1] - ('0')->char2byte()) ) else (     sum := sum+(res) ; 
     res := 0 ) )  ;     i := i + 1 ) ) ; 
     OclFile["System.out"].println(sum) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      if(n>m){
        System.out.println("NO");
        continue ;
      }
      Arrays.sort(a);
      long ans=a[n-1];
      for(int i=n-1 ; i>=0 ; i--){
        ans++;
        if(i>0)ans+=a[i];
      }
      if(ans<=m)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    if (n > m) then (     OclFile["System.out"].println("NO") ; 
     continue ) else skip ; 
    a := a->sort() ; 
    var ans : long ; ans := a[n - 1+1] ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     ans := ans + 1 ; 
     if (i > 0) then     ans := ans+(a[i+1]) ; else skip )  ;     i := i - 1 ) ; 
    if (ans <= m) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.regex.Matcher ;
import java.util.regex.Pattern ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder builder=new StringBuilder();
    String line ;
    int count=0 ;
    while((line=reader.readLine())!=null){
      Pattern pattern=Pattern.compile("([0-9]+)");
      Matcher matcher=pattern.matcher(line);
      while(matcher.find()){
        count+=Integer.parseInt(matcher.group());
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var builder : String ; builder := StringLib.newString() ;
    var line : String ;
    var count : int ; count := 0 ;
        line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     var pattern : OclRegex ; pattern := OclRegex.compile("([0-9]+)") ;
     var matcher : OclRegex ; matcher := pattern.matcher(line) ;
     while (matcher.nextMatch()) do (     count := count+((matcher.group())->toInteger()) ) ) ;     line := reader.readLine() ;
 ) ;  
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int answer=x*x*x ;
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     var answer : int ; answer := x * x * x ;
     OclFile["System.out"].println(answer) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    String stdin=null ;
    int sum=0 ;
    while((stdin=parseStdin())!=null){
      stdin=stdin.replaceAll("[^0-9] "," ").trim();
      stdin=stdin.replaceAll("[]+"," ");
      if(! stdin.isEmpty()){
        for(String s : stdin.split(" ")){
          sum+=Integer.parseInt(s);
        }
      }
    }
    System.out.println(sum);
  }
  private static String parseStdin(){
    String stdin=null ;
    try {
      stdin=br.readLine();
    }
    catch(IOException e){
    }
    return stdin ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : String ; stdin := null ;
     var sum : int ; sum := 0 ;
         stdin := parseStdin() ;
    while ((stdin) /= null) do (    skip ; (     stdin := stdin.replaceAllMatches("[^0-9] ", " " )->trim() ; 
     stdin := stdin.replaceAllMatches("[]+", " " ) ; 
     if (not(stdin->isEmpty())) then (     for (s : stdin->split(" ")) do ( (     sum := sum+((s)->toInteger()) )  ) ) else skip ) ;     stdin := parseStdin() ;
 ) ;  
     OclFile["System.out"].println(sum) );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var stdin : String ; stdin := null ;
     try (     stdin := br.readLine() )   catch (e : IOException) do skip
     return stdin );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int pass=0 ;
    while(sc.hasNextLine()){
      String line=sc.nextLine();
      if(line.equals("end"))break ;
      pass+=sumAll(line);
    }
    System.out.println(pass);
    sc.close();
  }
  static int sumAll(String str){
    List<Integer>begin=new ArrayList<Integer>();
    List<Integer>end=new ArrayList<Integer>();
    boolean c=false ;
    for(int i=0 ; i<str.length(); i++){
      if(isNum(str.charAt(i))){
        if(! c){
          begin.add(i);
          c=true ;
        }
      }
      else {
        if(c){
          end.add(i);
          c=false ;
        }
      }
      if(i==str.length()-1){
        if(c)end.add(i+1);
      }
    }
    int result=0 ;
    for(int i=0 ; i<begin.size(); i++){
      result+=Integer.parseInt(str.substring(begin.get(i),end.get(i)));
    }
    return result ;
  }
  static boolean isNum(char c){
    if('0'<=c && c<='9')return true ;
    else return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pass : int ; pass := 0 ;
    while (sc.hasNextLine()) do (     var line : String ; line := sc.nextLine() ;
     if (line = "end") then     break else skip ; 
     pass := pass+(sumAll(line)) ) ; 
    OclFile["System.out"].println(pass) ; 
    skip ; 
 );
  static   operation sumAll( str : String) : int
  pre: true
  post: true
  activity: (     var begin : Sequence(int) ; begin := Sequence{} ;
     var end : Sequence(int) ; end := Sequence{} ;
    var c : boolean ; c := false ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (isNum(str->at(i+1))) then (     if (not(c)) then (     begin := begin->including(i) ; 
     c := true ) else skip ) else (     if (c) then (     end := end->including(i) ; 
     c := false ) else skip ) ;  
     if (i = str->size() - 1) then (     if (c) then     end := end->including(i + 1) ; else skip ) else skip )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < begin->size() do ( (     result := result+((str.subrange(begin->at(i+1)+1,end->at(i+1)))->toInteger()) )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation isNum( c : String) : boolean
  pre: true
  post: true
  activity: (     if ('0' <= c & c <= '9') then     return true else     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Sol {
  static int countPairs(String s){
    Set<Character>st=new HashSet<Character>();
    st.add('a');
    st.add('e');
    st.add('i');
    st.add('o');
    st.add('u');
    int count=0 ;
    int n=s.length();
    for(int i=0 ; i<n-1 ; i++){
      if(st.contains(s.charAt(i))&& ! st.contains(s.charAt(i+1)))count++;
    }
    return count ;
  }
  public static void main(String args[]){
    String s="geeksforgeeks" ;
    System.out.println(countPairs(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sol {
  static   operation countPairs( s : String) : int
  pre: true
  post: true
  activity: (     var st : Set(String) ; st := Set{} ;
     st := st->including('a') ; 
    st := st->including('e') ; 
    st := st->including('i') ; 
    st := st->including('o') ; 
    st := st->including('u') ; 
    var count : int ; count := 0 ;
    var n : int ; n := s->size() ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (st->includes(s->at(i+1)) & not(st->includes(s->at(i + 1+1)))) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     OclFile["System.out"].println(countPairs(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class abc {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long p=sc.nextLong();
    long d=sc.nextLong(),ans=++p ;
    for(long t=10 ; ; t*=10){
      if(p % t>d)break ;
      ans=p-p % t ;
    }
    System.out.println(ans-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class abc {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : long ; p := sc.getCurrent()->toLong() ;
    var d : long ; d := sc.getCurrent()->toLong() ;
    var ans : long ;     p := p + 1 ;
ans := p ;
        var t : long ; t := 10 ; while true do ( (     if (p mod t > d) then     break else skip ; 
     ans := p - p mod t )  ;     t := t*(10) ) ; 
    OclFile["System.out"].println(ans - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long p=sc.nextLong(),l=sc.nextLong();
    long i=1 ;
    Stack<Integer>st=new Stack();
    while(l>0){
      if(p<9)break ;
      int d=(int)(p %(long)10);
      if(d==9){
        st.push(9);
        p=p/10 ;
        i*=(long)10 ;
        continue ;
      }
      d+=1 ;
      if(d*i<=l){
        l-=(long)(d*i);
        p-=(long)(d);
        st.push(9);
        p/=10 ;
        i*=(long)10 ;
      }
      else {
        break ;
      }
    }
    String newNo=(p!=0)? String.valueOf(p): "" ;
    while(! st.isEmpty()){
      newNo+=String.valueOf(st.pop());
    }
    System.out.println(newNo);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : long ; p := sc.getCurrent()->toLong() ;
    var l : long ; l := sc.getCurrent()->toLong() ;
    var i : long ; i := 1 ;
    var st : Sequence(int) ; st := Sequence{} ;
    while (l > 0) do (     if (p < 9) then     break else skip ; 
     var d : int ; d := (p mod 10->oclAsType(long))->oclAsType(int) ;
    if (d = 9) then (     st := st->append(9) ; 
     p := p / 10 ; 
     i := i*(10->oclAsType(long)) ; 
     continue ) else skip ; 
    d := d+(1) ; 
    if (d * i <= l) then (     l := l-((d * i)->oclAsType(long)) ; 
     p := p-((d)->oclAsType(long)) ; 
    st := st->append(9) ; 
    p := p/(10) ; 
    i := i*(10->oclAsType(long)) ; 
 ) else (     break ) ;  
 ) ; 
    var newNo : String ; newNo := if (p /= 0) then ((p) + "") else "" endif ;
    while (not(st->isEmpty())) do (     newNo := newNo+(((st->last()) + "")) ) ; 
    OclFile["System.out"].println(newNo) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Price999 {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    String input[]=reader.readLine().split(" ");
    long p=Long.parseLong(input[0]);
    long d=Long.parseLong(input[1]);
    p+=1 ;
    long n=p ;
    long t=10 ;
    while(true){
      if(p % t>d)break ;
      n=p-(p % t);
      t*=10 ;
    }
    System.out.println(n-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Price999 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : Sequence(String) ; input := reader.readLine()->split(" ") ;
    var p : long ; p := (input[0+1])->toLong() ;
    var d : long ; d := (input[1+1])->toLong() ;
    p := p+(1) ; 
    var n : long ; n := p ;
    var t : long ; t := 10 ;
    while (true) do (     if (p mod t > d) then     break else skip ; 
     n := (p)->char2byte() - (p mod t) ; 
     t := t*(10) ) ; 
    OclFile["System.out"].println(n - 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().solve(new Scanner(System.in));
  }
  public void solve(Scanner sc){
    int n=Integer.parseInt(sc.next());
    if(n % 7==0 || n % 4==0){
      System.out.println("Yes");
      return ;
    }
    for(int i=0 ; i*7<=n ; i++){
      for(int j=0 ; j*4+i*7<=n ; j++){
        if(j*4+i*7==n){
          System.out.println("Yes");
          return ;
        }
      }
    }
    System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (sc.next())->toInteger() ;
     if (n mod 7 = 0 or n mod 4 = 0) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i * 7 <= n do ( (         var j : int ; j := 0 ; while j * 4 + i * 7 <= n do ( (     if (j * 4 + i * 7 = n) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("No") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      long m=sc.nextLong();
      long[] arr=new long[n];
      long sum=0 ;
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextLong();
        sum+=arr[i];
      }
      Arrays.sort(arr);
      if(n>m)System.out.println("NO");
      else {
        sum+=n-arr[0]+arr[n-1];
        if(sum>m)System.out.println("NO");
        else System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : long ; m := sc.getCurrent()->toLong() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toLong() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    if (n > m) then     OclFile["System.out"].println("NO") else (     sum := sum+(n - arr[0+1] + arr[n - 1+1]) ; 
     if (sum > m) then     OclFile["System.out"].println("NO") ; else     OclFile["System.out"].println("YES") ; ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ABC105_2 solver=new ABC105_2();
    solver.solve(1,in,out);
    out.close();
  }
  static class ABC105_2 {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int NN=in.nextInt();
      if((NN % 4)==0){
        out.println("Yes");
        return ;
      }
      if((NN % 7)==0){
        out.println("Yes");
        return ;
      }
      for(int i=4 ; i<NN ; i+=4){
        if((NN-i)% 7==0){
          out.println("Yes");
          return ;
        }
      }
      out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ABC105    var solver : OclFile ; solver := ABC105().newABC105()() ; solver := ABC105().newABC105()() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ABC105{
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var NN : int ; NN := in.getCurrent()->toInteger() ;
     if ((NN mod 4) = 0) then (     skip ; 
     return ) else skip ; 
    if ((NN mod 7) = 0) then (     skip ; 
     return ) else skip ; 
        var i : int ; i := 4 ; while i < NN do ( (     if ((NN - i) mod 7 = 0) then (     skip ; 
     return ) else skip )  ;     i := i+(4) ) ; 
    skip ; 
 );
}
 {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var NN : int ; NN := in.getCurrent()->toInteger() ;
     if ((NN mod 4) = 0) then (     skip ; 
     return ) else skip ; 
    if ((NN mod 7) = 0) then (     skip ; 
     return ) else skip ; 
        var i : int ; i := 4 ; while i < NN do ( (     if ((NN - i) mod 7 = 0) then (     skip ; 
     return ) else skip )  ;     i := i+(4) ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static final int READ_COUNT=1 ;
  private static List<String>strList=new ArrayList<>();
  public static void main(String[] args){
    read();
    int n=Integer.parseInt(strList.get(0));
    if(n % 4==0 || n % 7==0){
      System.out.println("Yes");
      return ;
    }
    for(int i=1,iLen=n/7 ; i<=iLen ; i++){
      if((n-(i*7))% 4==0){
        System.out.println("Yes");
        return ;
      }
    }
    System.out.println("No");
  }
  private static void read(){
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      for(int i=0 ; i<READ_COUNT ; i++){
        strList.add(br.readLine());
      }
    }
    catch(IOException e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute READ_COUNT : int := 1;
  static   attribute strList : Sequence(String) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute read() ; 
     var n : int ; n := (strList->at(0+1))->toInteger() ;
    if (n mod 4 = 0 or n mod 7 = 0) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
        var i : int ; i := 1 ;
    var iLen : int ; iLen := n / 7 ; while i <= iLen do ( (     if ((n - (i * 7)) mod 4 = 0) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("No") ; 
 );
  static   operation read() : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (         var i : int ; i := 0 ; while i < READ_COUNT do ( (     strList := strList->including(br.readLine()) )  ;     i := i + 1 ) ))   catch (e : IOException) do skip
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.util.InputMismatchException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskB solver=new TaskB();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskB {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      boolean[] can=new boolean[110];
      can[0]=true ;
      for(int i=0 ; i<n ; i++){
        if(can[i]){
          can[i+4]=true ;
          can[i+7]=true ;
        }
      }
      out.println(can[n] ? "Yes" : "No");
    }
  }
  static class InputReader {
    private BufferedReader br ;
    private StringTokenizer st ;
    public InputReader(InputStream inputStream){
      br=new BufferedReader(new InputStreamReader(inputStream));
      st=new StringTokenizer("");
    }
    public String nextString(){
      while(! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine()," ");
        }
        catch(IOException e){
          throw new InputMismatchException();
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(nextString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskB ; solver := TaskB.newTaskB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskB {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var can : Sequence(boolean) ; can := Integer.subrange(1,110)->collect(false) ;
    can[0+1] := true ; 
        var i : int ; i := 0 ; while i < n do ( (     if (can[i+1]) then (     can[i + 4+1] := true ; 
     can[i + 7+1] := true ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newInputReader( inputStream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) ; 
     st := OclIterator.newOclIterator_String("") );
   operation nextString() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String_String(br.readLine(), " ") )   catch (e : IOException) do (     error IncorrectElementException() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextString())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String args[])throws IOException {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(is);
    String str=br.readLine();
    int answer=Integer.parseInt(str);
    answer=answer*answer*answer ;
    str=String.valueOf(answer);
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(is) ;
    var str : String ; str := br.readLine() ;
    var answer : int ; answer := (str)->toInteger() ;
    answer := answer * answer * answer ; 
    str := ((answer) + "") ; 
    OclFile["System.out"].println(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  final static Scanner IN=new Scanner(System.in);
  static int N=IN.nextInt();
  public static void main(String...args){
    boolean flag=false ;
    for(int c=0 ; c<=N ; c+=4){
      if((N-c)% 7==0){
        flag=true ;
        break ;
      }
    }
    System.out.println(flag ? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute IN : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int := IN.getCurrent()->toInteger();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var flag : boolean ; flag := false ;
         var c : int ; c := 0 ; while c <= N do ( (     if ((N - c) mod 7 = 0) then (     flag := true ; 
     break ) else skip )  ;     c := c+(4) ) ; 
     OclFile["System.out"].println(if flag then "Yes" else "No" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static boolean isTidy(int num){
    int prev=10 ;
    while(num!=0){
      int rem=num % 10 ;
      num/=10 ;
      if(rem>prev)return false ;
      prev=rem ;
    }
    return true ;
  }
  public static void main(String[] args){
    int num=1556 ;
    System.out.println(isTidy(num)? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation isTidy( num : int) : boolean
  pre: true
  post: true
  activity: (     var prev : int ; prev := 10 ;
     while (num /= 0) do (     var rem : int ; rem := num mod 10 ;
     num := num/(10) ; 
     if (rem > prev) then     return false else skip ; 
     prev := rem ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 1556 ;
     OclFile["System.out"].println(if isTidy(num) then "Yes" else "No" endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    String a=cin.nextLine();
    String[] b=cin.nextLine().split(" ");
    int[] c=new int[Integer.parseInt(a)];
    for(int i=0 ; i<c.length ; i++){
      c[i]=Integer.parseInt(b[i]);
    }
    int max=0 ;
    for(int i=0 ; i<c.length ; i++){
      if(max<c[i]){
        max=c[i];
      }
    }
    int now=max ;
    int count=max+1 ;
    int numberCount=0 ;
    boolean possible=true ;
    while(count>0){
      for(int k=0 ; k<c.length ; k++){
        if(c[k]==now){
          numberCount++;
        }
      }
      if(numberCount!=1 && count==1){
        possible=false ;
        break ;
      }
      if(numberCount!=2 && count==2){
        possible=false ;
        break ;
      }
      if(numberCount<2 && count!=2 && count!=1){
        possible=false ;
        break ;
      }
      count=count-2 ;
      numberCount=0 ;
      now--;
    }
    if(possible){
      System.out.println("Possible");
    }
    else {
      System.out.println("Impossible");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := cin.nextLine() ;
    var b : Sequence(String) ; b := cin.nextLine()->split(" ") ;
    var c : Sequence(int) ; c := Integer.subrange(1,(a)->toInteger())->collect(0) ;
        var i : int ; i := 0 ; while i < c->size() do ( (     c[i+1] := (b[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < c->size() do ( (     if (max < c[i+1]) then (     max := c[i+1] ) else skip )  ;     i := i + 1 ) ; 
    var now : int ; now := max ;
    var count : int ; count := max + 1 ;
    var numberCount : int ; numberCount := 0 ;
    var possible : boolean ; possible := true ;
    while (count > 0) do (         var k : int ; k := 0 ; while k < c->size() do ( (     if (c[k+1] = now) then (     numberCount := numberCount + 1 ) else skip )  ;     k := k + 1 ) ; 
     if (numberCount /= 1 & count = 1) then (     possible := false ; 
     break ) else skip ; 
    if (numberCount /= 2 & count = 2) then (     possible := false ; 
     break ) else skip ; 
    if (numberCount < 2 & count /= 2 & count /= 1) then (     possible := false ; 
     break ) else skip ; 
    count := count - 2 ; 
    numberCount := 0 ; 
    now := now - 1 ; 
 ) ; 
    if (possible) then (     OclFile["System.out"].println("Possible") ) else (     OclFile["System.out"].println("Impossible") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++)a[i]=sc.nextInt();
    System.out.println(possible(a)? "Possible" : "Impossible");
    sc.close();
  }
  static boolean possible(int[] a){
    int N=a.length ;
    Arrays.sort(a);
    int min=a[0];
    int max=a[N-1];
    if(max<min*2-1 || min*2<max)return false ;
    int[] cnt=new int[min*2+1];
    for(int i=0 ; i<N ; i++)cnt[a[i] ]++;
    for(int i=min ; i<=max ; i++){
      if(i==min){
        if(max==min*2){
          if(cnt[i]!=1)return false ;
        }
        else {
          if(cnt[i]!=2)return false ;
        }
      }
      else {
        if(cnt[i]<2)return false ;
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if possible(a) then "Possible" else "Impossible" endif) ; 
    skip ; 
 );
  static   operation possible( a : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var N : int ; N := a->size() ;
     a := a->sort() ; 
    var min : int ; min := a[0+1] ;
    var max : int ; max := a[N - 1+1] ;
    if (max < min * 2 - 1 or min * 2 < max) then     return false else skip ; 
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,min * 2 + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     cnt[a[i+1]+1] := cnt[a[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := min ; while i <= max do ( (     if (i = min) then (     if (max = min * 2) then (     if (cnt[i+1] /= 1) then     return false else skip ) else (     if (cnt[i+1] /= 2) then     return false else skip ) ) else (     if (cnt[i+1] < 2) then     return false else skip ) )  ;     i := i + 1 ) ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] a=new int[N];
    int[] cnt=new int[N];
    int min=N+1 ;
    int max=0 ;
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextInt();
      cnt[a[i] ]+=1 ;
      min=Math.min(min,a[i]);
      max=Math.max(max,a[i]);
    }
    sc.close();
    String POSSIBLE="Possible" ;
    String IMPOSSIBLE="Impossible" ;
    String ans=POSSIBLE ;
    if(cnt[min]==1){
      if(max==min*2){
        ans=POSSIBLE ;
        for(int i=min+1 ; i<=max ; i++){
          if(cnt[i]<2){
            ans=IMPOSSIBLE ;
            break ;
          }
        }
      }
      else {
        ans=IMPOSSIBLE ;
      }
    }
    else if(cnt[min]==2){
      if(max==min*2-1){
        ans=POSSIBLE ;
        for(int i=min+1 ; i<=max ; i++){
          if(cnt[i]<2){
            ans=IMPOSSIBLE ;
            break ;
          }
        }
      }
      else {
        ans=IMPOSSIBLE ;
      }
    }
    else {
      ans=IMPOSSIBLE ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,N)->collect(0) ;
    var min : int ; min := N + 1 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     cnt[a[i+1]+1] := cnt[a[i+1]+1]+(1) ; 
     min := Set{min, a[i+1]}->min() ; 
     max := Set{max, a[i+1]}->max() )  ;     i := i + 1 ) ; 
    skip ; 
    var POSSIBLE : String ; POSSIBLE := "Possible" ;
    var IMPOSSIBLE : String ; IMPOSSIBLE := "Impossible" ;
    var ans : String ; ans := POSSIBLE ;
    if (cnt[min+1] = 1) then (     if (max = min * 2) then (     ans := POSSIBLE ; 
         var i : int ; i := min + 1 ; while i <= max do ( (     if (cnt[i+1] < 2) then (     ans := IMPOSSIBLE ; 
     break ) else skip )  ;     i := i + 1 ) ) else (     ans := IMPOSSIBLE ) ) else     if (cnt[min+1] = 2) then (     if (max = min * 2 - 1) then (     ans := POSSIBLE ; 
         var i : int ; i := min + 1 ; while i <= max do ( (     if (cnt[i+1] < 2) then (     ans := IMPOSSIBLE ; 
     break ) else skip )  ;     i := i + 1 ) ) else (     ans := IMPOSSIBLE ) ) else (     ans := IMPOSSIBLE ) ;  ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPerfectPower(int n){
    if(n==1){
      return true ;
    }
    for(int x=2 ; x<=Math.sqrt(n); x++){
      int y=2 ;
      int p=(int)Math.pow(x,y);
      while(p<=n && p>0){
        if(p==n){
          return true ;
        }
        y++;
        p=(int)Math.pow(x,y);
      }
    }
    return false ;
  }
  static boolean isStrongNumber(int n){
    HashMap<Integer,Integer>count=new HashMap<Integer,Integer>();
    while(n % 2==0){
      n=n/2 ;
      if(count.containsKey(2)){
        count.put(2,count.get(2)+1);
      }
      else {
        count.put(2,1);
      }
    }
    for(int i=3 ; i<=Math.sqrt(n); i+=2){
      while(n % i==0){
        n=n/i ;
        if(count.containsKey(i)){
          count.put(i,count.get(i)+1);
        }
        else {
          count.put(i,1);
        }
      }
    }
    if(n>2){
      if(count.containsKey(n)){
        count.put(n,count.get(n)+1);
      }
      else {
        count.put(n,1);
      }
    }
    int flag=0 ;
    for(Map.Entry<Integer,Integer>b : count.entrySet()){
      if(b.getValue()==1){
        flag=1 ;
        break ;
      }
    }
    if(flag==1){
      return false ;
    }
    else {
      return true ;
    }
  }
  static boolean isTrojan(int n){
    if(! isPerfectPower(n)&& isStrongNumber(n)){
      return true ;
    }
    else {
      return false ;
    }
  }
  public static void main(String[] args){
    int n=108 ;
    if(isTrojan(n)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPerfectPower( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 1) then (     return true ) else skip ; 
         var x : int ; x := 2 ; while x <= (n)->sqrt() do ( (     var y : int ; y := 2 ;
     var p : int ; p := x->pow(y)->oclAsType(int) ;
     while (p <= n & p > 0) do (     if (p = n) then (     return true ) else skip ; 
     y := y + 1 ; 
     p := x->pow(y)->oclAsType(int) ) )  ;     x := x + 1 ) ; 
     return false );
  static   operation isStrongNumber( n : int) : boolean
  pre: true
  post: true
  activity: (     var count : Map(int,int) ; count := Map{} ;
     while (n mod 2 = 0) do (     n := n / 2 ; 
     if (count->keys()->includes(2)) then (     count := count->union(Map{2 |-> count->at(2) + 1}) ) else (     count := count->union(Map{2 |-> 1}) ) ) ; 
        var i : int ; i := 3 ; while i <= (n)->sqrt() do ( (     while (n mod i = 0) do (     n := n / i ; 
     if (count->keys()->includes(i)) then (     count := count->union(Map{i |-> count->at(i) + 1}) ) else (     count := count->union(Map{i |-> 1}) ) ) )  ;     i := i+(2) ) ; 
    if (n > 2) then (     if (count->keys()->includes(n)) then (     count := count->union(Map{n |-> count->at(n) + 1}) ) else (     count := count->union(Map{n |-> 1}) ) ) else skip ; 
    var flag : int ; flag := 0 ;
    for (b : count->asSet()) do ( (     if (b.getValue() = 1) then (     flag := 1 ; 
     break ) else skip )  ) ; 
    if (flag = 1) then (     return false ) else (     return true ) ;  
 );
  static   operation isTrojan( n : int) : boolean
  pre: true
  post: true
  activity: (     if (not(isPerfectPower(n)) & isStrongNumber(n)) then (     return true ) else (     return false ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 108 ;
     if (isTrojan(n)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static double result=0 ;
  static int count=0 ;
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int N=input.nextInt();
    int[][] arr=new int[N][2];
    for(int i=0 ; i<N ; i++){
      arr[i]=new int[] {
        input.nextInt(),input.nextInt()};
      }
      perm(arr,new boolean[N],0,0,null);
      System.out.println(result/count);
    }
    static void perm(int[][] arr,boolean[] bt,double sum,int cNum,int[] prev){
      if(cNum==arr.length){
        result+=sum ;
        count++;
      }
      for(int i=0 ; i<arr.length ; i++){
        if(! bt[i]){
          bt[i]=true ;
          if(cNum==0 && prev==null)perm(arr,bt,sum,cNum+1,arr[i]);
          else perm(arr,bt,sum+distance(prev,arr[i]),cNum+1,arr[i]);
          bt[i]=false ;
        }
      }
    }
    public static double distance(int[] p1,int[] p2){
      return Math.sqrt(Math.pow(Math.abs(p1[0]-p2[0]),2)+Math.pow(Math.abs(p1[1]-p2[1]),2));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute result : double := 0;
  static   attribute count : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := input.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,N)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := Sequence{input.getCurrent()->toInteger(),input.getCurrent()->toInteger()} )  ;     i := i + 1 ) ; 
    execute perm(arr, Integer.subrange(1,N)->collect(false), 0, 0, null) ; 
    OclFile["System.out"].println(result / count) ; 
 );
  static   operation perm( arr : Sequence(Sequence(int)), bt : Sequence(boolean), sum : double, cNum : int, prev : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (cNum = arr->size()) then (     result := result+(sum) ; 
     count := count + 1 ) else skip ; 
         var i : int ; i := 0 ; while i < arr->size() do ( (     if (not(bt[i+1])) then (     bt[i+1] := true ; 
     if (cNum = 0 & prev = null) then     execute perm(arr, bt, sum, cNum + 1, arr[i+1]) else     execute perm(arr, bt, sum + distance(prev, arr[i+1]), cNum + 1, arr[i+1]) ; ;  
     bt[i+1] := false ) else skip )  ;     i := i + 1 ) );
  static   operation distance( p1 : Sequence(int), p2 : Sequence(int)) : double
  pre: true
  post: true
  activity: (     return (if p1[0+1] - p2[0+1] < 0 then -(p1[0+1] - p2[0+1]) else p1[0+1] - p2[0+1] endif->pow(2) + if p1[1+1] - p2[1+1] < 0 then -(p1[1+1] - p2[1+1]) else p1[1+1] - p2[1+1] endif->pow(2))->sqrt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Deque ;
import java.util.Scanner ;
public class A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int numCases=sc.nextInt();
    for(int caseNum=1 ; caseNum<=numCases ; caseNum++){
      String S=sc.next();
      char ch=S.charAt(0);
      Deque<Character>chars=new ArrayDeque<>();
      chars.addLast(S.charAt(0));
      for(int i=1 ; i<S.length(); i++){
        char next=S.charAt(i);
        if(next>=chars.getFirst()){
          chars.addFirst(next);
        }
        else {
          chars.addLast(next);
        }
      }
      System.out.print("Case #"+caseNum+": ");
      for(Character c : chars){
        System.out.print(c);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numCases : int ; numCases := sc.getCurrent()->toInteger() ;
         var caseNum : int ; caseNum := 1 ; while caseNum <= numCases do ( (     var S : String ; S := sc.getCurrent() ;
     var ch : String ; ch := S->at(0+1) ;
    var chars : Sequence(String) ; chars := ArrayDeque<OclAny>.newArrayDeque() ;
    chars := chars->append(S->at(0+1)) ; 
        var i : int ; i := 1 ; while i < S->size() do ( (     var next : String ; next := S->at(i+1) ;
     if (next >= chars->first()) then (     chars := chars->prepend(next) ) else (     chars := chars->append(next) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("Case #" + caseNum + ": ") ; 
    for (c : chars) do ( (     OclFile["System.out"].print(c) )  ) ; 
    OclFile["System.out"].println() ; 
 )  ;     caseNum := caseNum + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package cj2016.r1a ;
import java.io.*;
import java.util.*;
public class A {
  Scanner sc ;
  PrintWriter pw ;
  char[] S ;
  public static void main(String[] args)throws Exception {
    String filePrefix=args.length>0 ? args[0] : "A-large" ;
    try {
      new A().run(filePrefix);
    }
    catch(Exception e){
      System.err.println(e);
    }
  }
  public void run(String filePrefix)throws Exception {
    sc=new Scanner(new FileReader(filePrefix+".in"));
    pw=new PrintWriter(new FileWriter(filePrefix+".out"));
    int ntest=sc.nextInt();
    for(int test=1 ; test<=ntest ; test++){
      read(sc);
      pw.print("Case #"+test+": ");
      System.out.print("Case #"+test+": ");
      solve();
    }
    System.out.println("Finished.");
    sc.close();
    pw.close();
  }
  void read(Scanner sc){
    S=sc.next().toCharArray();
  }
  void print(Object s){
    pw.print(s);
    System.out.print(s);
  }
  void println(Object s){
    pw.println(s);
    System.out.println(s);
  }
  public void solve(){
    String ans="" ;
    for(char c : S){
      String s1=ans+c ;
      String s2=c+ans ;
      ans=s1.compareTo(s2)<0 ? s2 : s1 ;
    }
    println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   attribute sc : OclFile;
   attribute pw : OclFile;
   attribute S : Sequence(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var filePrefix : String ; filePrefix := if args->size() > 0 then args[0+1] else "A-large" endif ;
     try (     A.newA().run(filePrefix) )   catch (e : ProgramException) do (     OclFile["System.err"].println(e) )
 );
   operation run( filePrefix : String) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(filePrefix + ".in")) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(filePrefix + ".out")) ; 
    var ntest : int ; ntest := sc.getCurrent()->toInteger() ;
        var test : int ; test := 1 ; while test <= ntest do ( (     execute read(sc) ; 
     skip ; 
     OclFile["System.out"].print("Case #" + test + ": ") ; 
     execute solve() )  ;     test := test + 1 ) ; 
    OclFile["System.out"].println("Finished.") ; 
    skip ; 
    skip ; 
 );
   operation read( sc : OclFile) : void
  pre: true
  post: true
  activity: (     S := sc.getCurrent()->characters() );
   operation print( s : OclAny) : void
  pre: true
  post: true
  activity: (     skip ; 
     OclFile["System.out"].print(s) );
   operation println( s : OclAny) : void
  pre: true
  post: true
  activity: (     skip ; 
     OclFile["System.out"].println(s) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var ans : String ; ans := "" ;
     for (c : S) do ( (     var s1 : String ; s1 := ans + c ;
     var s2 : String ; s2 := c + ans ;
     ans := if s1->compareTo(s2) < 0 then s2 else s1 endif )  ) ; 
     execute println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package lab6zp ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Lab6ZP {
  public static String solve(String s,int x){
    if(s.equals(".")){
      return "" ;
    }
    String t="" ;
    char c='Z' ;
    c-=x ;
    String[] u=s.split(Character.toString(c));
    for(int i=0 ; i<u.length-1 ; i++){
      t+=c ;
    }
    for(int i=0 ; i<u.length ; i++){
      if(i==0){
        t+=solve(u[i],x+1);
      }
      else {
        t+=remove(u[i]);
      }
    }
    return t ;
  }
  public static String remove(String s){
    String t="" ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)!='.'){
        t+=s.charAt(i);
      }
    }
    return t ;
  }
  public static String interlace(String s){
    String t="." ;
    for(int i=0 ; i<s.length(); i++){
      t+=s.charAt(i);
      t+="." ;
    }
    return t ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=Integer.parseInt(in.next());
    for(int i=0 ; i<n ; i++){
      String s=in.next();
      s=interlace(s);
      System.out.println("Case #"+(i+1)+": "+solve(s,0));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Lab6ZP {
  static   operation solve( s : String, x : int) : String
  pre: true
  post: true
  activity: (     if (s = ".") then (     return "" ) else skip ; 
     var t : String ; t := "" ;
    var c : String ; c := 'Z' ;
    c := c-(x) ; 
    var u : Sequence(String) ; u := s->split((c + "")) ;
        var i : int ; i := 0 ; while i < u->size() - 1 do ( (     t := t+(c) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < u->size() do ( (     if (i = 0) then (     t := t+(solve(u[i+1], x + 1)) ) else (     t := t+(remove(u[i+1])) ) )  ;     i := i + 1 ) ; 
    return t 
 );
  static   operation remove( s : String) : String
  pre: true
  post: true
  activity: (     var t : String ; t := "" ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) /= '.') then (     t := t+(s->at(i+1)) ) else skip )  ;     i := i + 1 ) ; 
     return t );
  static   operation interlace( s : String) : String
  pre: true
  post: true
  activity: (     var t : String ; t := "." ;
         var i : int ; i := 0 ; while i < s->size() do ( (     t := t+(s->at(i+1)) ; 
     t := t+(".") )  ;     i := i + 1 ) ; 
     return t );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (in.getCurrent())->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := in.getCurrent() ;
     s := interlace(s) ; 
     OclFile["System.out"].println("Case #" + (i + 1) + ": " + solve(s, 0)) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class Round1A {
  public static void main(String[] args)throws Exception {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter("A.txt");
    int T=Integer.parseInt(in.readLine());
    for(int c=1 ; c<=T ; c++){
      String s=in.readLine();
      int[] fl=new int[s.length()];
      int nfl=0 ;
      while(nfl<s.length()){
        char last=(char)('A'-1);
        int firstL=-1 ;
        for(int i=0 ; i<s.length(); i++){
          if(fl[i]==0 && s.charAt(i)>last){
            last=s.charAt(i);
            firstL=i ;
          }
        }
        for(int i=firstL ; i<s.length(); i++){
          if(fl[i]==0){
            nfl++;
            if(s.charAt(i)==last){
              fl[i]=1 ;
            }
            else fl[i]=-1 ;
          }
        }
      }
      String ans="" ;
      for(int i=0 ; i<s.length(); i++){
        if(fl[i]==1){
          ans=s.charAt(i)+ans ;
        }
        else if(fl[i]==-1){
          ans=ans+s.charAt(i);
        }
      }
      pw.println("Case #"+c+": "+ans);
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Round1A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile("A.txt")) ;
    var T : int ; T := (in.readLine())->toInteger() ;
        var c : int ; c := 1 ; while c <= T do ( (     var s : String ; s := in.readLine() ;
     var fl : Sequence(int) ; fl := Integer.subrange(1,s->size())->collect(0) ;
    var nfl : int ; nfl := 0 ;
    while (nfl < s->size()) do (     var last : String ; last := (('A')->char2byte() - 1)->oclAsType(String) ;
     var firstL : int ; firstL := -1 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (fl[i+1] = 0 & s->at(i+1) > last) then (     last := s->at(i+1) ; 
     firstL := i ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := firstL ; while i < s->size() do ( (     if (fl[i+1] = 0) then (     nfl := nfl + 1 ; 
     if (s->at(i+1) = last) then (     fl[i+1] := 1 ) else     fl[i+1] := -1 ; ) else skip )  ;     i := i + 1 ) ) ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (fl[i+1] = 1) then (     ans := s->at(i+1) + ans ) else     if (fl[i+1] = -1) then (     ans := ans + s->at(i+1) ) else skip ; )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     c := c + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      String line=reader.readLine();
      int num=Integer.parseInt(line);
      String result=""+num*num*num ;
      System.out.println(result);
    }
    catch(IOException e){
      System.out.println(e);
    }
    catch(NumberFormatException e){
      System.out.println("??°????????£????????????");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var line : String ; line := reader.readLine() ;
     var num : int ; num := (line)->toInteger() ;
     var result : String ; result := "" + num * num * num ;
     OclFile["System.out"].println(result) )   catch (e : IOException) do (     OclFile["System.out"].println(e) )
   catch (e : IncorrectElementException) do (     OclFile["System.out"].println("??�????????�????????????") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.File ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class a {
  public static void main(String[] Args)throws Exception {
    FS sc=new FS(new File("A-large.in"));
    PrintWriter out=new PrintWriter(new BufferedWriter(new FileWriter(new File("a.out"))));
    int cc=0 ;
    int t=sc.nextInt();
    while(t-->0){
      out.printf("Case #%d: ",++cc);
      String s=sc.next();
      out.printf("%s",foo(s));
      out.println("");
    }
    out.close();
  }
  public static String foo(String s)throws Exception {
    if(s.length()==0)return "" ;
    int last='A' ;
    for(int i=0 ; i<s.length(); i++){
      last=Math.max(last,s.charAt(i));
    }
    for(int i=s.length()-1 ; i>=0 ; i--){
      if(s.charAt(i)==last){
        return(char)(last)+foo(s.substring(0,i))+s.substring(i+1);
      }
    }
    throw new Exception("BANANAS");
  }
  public static class FS {
    BufferedReader br ;
    StringTokenizer st ;
    FS(InputStream in)throws Exception {
      br=new BufferedReader(new InputStreamReader(in));
      st=new StringTokenizer(br.readLine());
    }
    FS(File in)throws Exception {
      br=new BufferedReader(new FileReader(in));
      st=new StringTokenizer(br.readLine());
    }
    String next()throws Exception {
      if(st.hasMoreTokens())return st.nextToken();
      st=new StringTokenizer(br.readLine());
      return next();
    }
    int nextInt()throws Exception {
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class a {
  static   operation main( Args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FS ; sc := FS.newFS(OclFile("A-large.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile("a.out")))) ;
    var cc : int ; cc := 0 ;
    var t : int ; t := sc.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     skip ; 
     var s : String ; s := sc.next() ;
     skip ; 
     skip ) ;  ) ;  
    skip ; 
 );
  static   operation foo( s : String) : String
  pre: true
  post: true
  activity: (     if (s->size() = 0) then     return "" else skip ; 
     var last : int ; last := 'A' ;
        var i : int ; i := 0 ; while i < s->size() do ( (     last := Set{last, s->at(i+1)}->max() )  ;     i := i + 1 ) ; 
        var i : int ; i := s->size() - 1 ; while i >= 0 do ( (     if (s->at(i+1) = last) then (     return (last)->oclAsType(String) + foo(s.subrange(0+1,i)) + s.subrange(i + 1+1,i + 1) ) else skip )  ;     i := i - 1 ) ; 
    error ProgramException("BANANAS") ; 
 );
  static class FS {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFS( in : OclFile) : FS
  pre: true
  post: true
  activity:
  ( var self : FS ;
    self := createFS();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     st := OclIterator.newOclIterator_String(br.readLine()) );
   static operation newFS( in : OclFile) : FS
  pre: true
  post: true
  activity:
  ( var self : FS ;
    self := createFS();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     st := OclIterator.newOclIterator_String(br.readLine()) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (st.hasNext()) then     return st.next() else skip ; 
     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     return next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=scan.nextInt();
    long[] A=new long[N];
    for(int i=0 ; i<N ; i++){
      A[i]=scan.nextLong();
    }
    long ans=solve(A,0,N-1,1,1)+A[0]+A[N-1];
    System.out.println(ans);
  }
  public static long solve(long[] A,int left,int right,int c_l,int c_r){
    if(left+1==right){
      return 0 ;
    }
    long ans=Long.MAX_VALUE ;
    for(int i=left+1 ; i<right ; i++){
      ans=Math.min(ans,solve(A,left,i,c_l,c_l+c_r)+solve(A,i,right,c_l+c_r,c_r)+(c_l+c_r)*A[i]);
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := scan.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := solve(A, 0, N - 1, 1, 1) + A[0+1] + A[N - 1+1] ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation solve( A : Sequence(long), left : int, right : int, c_l : int, c_r : int) : long
  pre: true
  post: true
  activity: (     if (left + 1 = right) then (     return 0 ) else skip ; 
     var ans : long ; ans := "9223372036854775807"->toLong() ;
         var i : int ; i := left + 1 ; while i < right do ( (     ans := Set{ans, solve(A, left, i, c_l, c_l + c_r) + solve(A, i, right, c_l + c_r, c_r) + (c_l + c_r) * A[i+1]}->min() )  ;     i := i + 1 ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int sum(int k,int n){
    int sum=0 ;
    for(int i=0 ; i<=n ; i++){
      int p=1 ;
      for(int j=0 ; j<n-i ; j++){
        p=p*k ;
      }
      for(int j=0 ; j<i ; j++){
        p=p*(k-1);
      }
      sum=sum+p ;
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=3 ;
    int K=3 ;
    System.out.println(sum(K,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sum( k : int, n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i <= n do ( (     var p : int ; p := 1 ;
         var j : int ; j := 0 ; while j < n - i do ( (     p := p * k )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < i do ( (     p := p * (k - 1) )  ;     j := j + 1 ) ; 
     sum := sum + p )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var K : int ; K := 3 ;
     OclFile["System.out"].println(sum(K, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public void solve(){
    Scanner sc=new Scanner(System.in);
    int ninzu,k ;
    int ban ;
    for(int i=0 ; i<4 ; i++){
      ban=sc.nextInt();
      if(ban==1){
        k=6000 ;
      }
      else if(ban==2){
        k=4000 ;
      }
      else if(ban==3){
        k=3000 ;
      }
      else {
        k=2000 ;
      }
      ninzu=sc.nextInt();
      int uriage=k*ninzu ;
      System.out.println(uriage);
    }
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ninzu : int ;
    var k : int ;
     var ban : int ;
         var i : int ; i := 0 ; while i < 4 do ( (     ban := sc.getCurrent()->toInteger() ; 
     if (ban = 1) then (     k := 6000 ) else     if (ban = 2) then (     k := 4000 ) else     if (ban = 3) then (     k := 3000 ) else (     k := 2000 ) ;  ;  ;  
    ninzu := sc.getCurrent()->toInteger() ; 
    var uriage : int ; uriage := k * ninzu ;
    OclFile["System.out"].println(uriage) ; 
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int[][] b=new int[a][2];
    int d=0 ;
    double ans=0 ;
    int f=0 ;
    double g=0 ;
    int h=1 ;
    for(int i=0 ; i<a ; i++){
      b[i][0]=sc.nextInt();
      b[i][1]=sc.nextInt();
    }
    for(int j=1 ; j<a ; j++){
      d+=j ;
    }
    for(int w=1 ; w<=a ; w++){
      h*=w ;
    }
    double[] c=new double[d];
    for(int x=0 ; x<a-1 ; x++){
      for(int y=x+1 ; y<a ; y++){
        double e=Math.pow(b[x][0]-b[y][0],2)+Math.pow(b[x][1]-b[y][1],2);
        c[f]=Math.sqrt(e);
        f++;
      }
    }
    for(int z=0 ; z<d ; z++){
      g+=c[z];
    }
    int k=(h*(a-1))/d ;
    ans=(g*2)/a ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : Sequence(Sequence(int)) ; b := Integer.subrange(1,a)->collect(Integer.subrange(1,2)->collect(0)) ;
    var d : int ; d := 0 ;
    var ans : double ; ans := 0 ;
    var f : int ; f := 0 ;
    var g : double ; g := 0 ;
    var h : int ; h := 1 ;
        var i : int ; i := 0 ; while i < a do ( (     b[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     b[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var j : int ; j := 1 ; while j < a do ( (     d := d+(j) )  ;     j := j + 1 ) ; 
        var w : int ; w := 1 ; while w <= a do ( (     h := h*(w) )  ;     w := w + 1 ) ; 
    var c : Sequence(double) ; c := Integer.subrange(1,d)->collect(0.0) ;
        var x : int ; x := 0 ; while x < a - 1 do ( (         var y : int ; y := x + 1 ; while y < a do ( (     var e : double ; e := b[x+1][0+1] - b[y+1][0+1]->pow(2) + b[x+1][1+1] - b[y+1][1+1]->pow(2) ;
     c[f+1] := (e)->sqrt() ; 
     f := f + 1 )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
        var z : int ; z := 0 ; while z < d do ( (     g := g+(c[z+1]) )  ;     z := z + 1 ) ; 
    var k : int ; k := (h * (a - 1)) / d ;
    ans := (g * 2) / a ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      long a=sc.nextLong();
      long b=sc.nextLong();
      long cost=0 ;
      if(a==1){
        cost=6000*b ;
      }
      if(a==2){
        cost=4000*b ;
      }
      if(a==3){
        cost=3000*b ;
      }
      if(a==4){
        cost=2000*b ;
      }
      System.out.println(cost);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
    var cost : long ; cost := 0 ;
    if (a = 1) then (     cost := 6000 * b ) else skip ; 
    if (a = 2) then (     cost := 4000 * b ) else skip ; 
    if (a = 3) then (     cost := 3000 * b ) else skip ; 
    if (a = 4) then (     cost := 2000 * b ) else skip ; 
    OclFile["System.out"].println(cost) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int[][] a=new int[4][4];
    for(int i=0 ; i<4 ; i++){
      a[i][0]=stdIn.nextInt();
      a[i][1]=stdIn.nextInt();
    }
    for(int i=0 ; i<4 ; i++){
      switch(a[i][0]){
        case 1 : System.out.println(a[i][1]*6000);
        break ;
        case 2 : System.out.println(a[i][1]*4000);
        break ;
        case 3 : System.out.println(a[i][1]*3000);
        break ;
        case 4 : System.out.println(a[i][1]*2000);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,4)->collect(Integer.subrange(1,4)->collect(0)) ;
         var i : int ; i := 0 ; while i < 4 do ( (     a[i+1][0+1] := stdIn.getCurrent()->toInteger() ; 
     a[i+1][1+1] := stdIn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < 4 do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (a[i+1][0+1]) ; 
       if _switchval = 1 then
     OclFile["System.out"].println(a[i+1][1+1] * 6000) ; 
    break 
   else skip ;
       if _switchval = 2 then
     OclFile["System.out"].println(a[i+1][1+1] * 4000) ; 
    break 
   else skip ;
       if _switchval = 3 then
     OclFile["System.out"].println(a[i+1][1+1] * 3000) ; 
    break 
   else skip ;
       if _switchval = 4 then
     OclFile["System.out"].println(a[i+1][1+1] * 2000) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int ban ;
    int su ;
    int kin ;
    int s=6000,a=4000,b=3000,c=2000 ;
    Scanner sc=new Scanner(System.in);
    for(int i=0 ; i<4 ; i++){
      ban=sc.nextInt();
      su=sc.nextInt();
      switch(ban){
        case 1 : kin=s*su ;
        System.out.println(kin);
        break ;
        case 2 : kin=a*su ;
        System.out.println(kin);
        break ;
        case 3 : kin=b*su ;
        System.out.println(kin);
        break ;
        case 4 : kin=c*su ;
        System.out.println(kin);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ban : int ;
     var su : int ;
    var kin : int ;
    var s : int ; s := 6000 ;
    var a : int ; a := 4000 ;
    var b : int ; b := 3000 ;
    var c : int ; c := 2000 ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
        var i : int ; i := 0 ; while i < 4 do ( (     ban := sc.getCurrent()->toInteger() ; 
     su := sc.getCurrent()->toInteger() ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (ban) ; 
       if _switchval = 1 then
     kin := s * su ; 
    OclFile["System.out"].println(kin) ; 
    break 
   else skip ;
       if _switchval = 2 then
     kin := a * su ; 
    OclFile["System.out"].println(kin) ; 
    break 
   else skip ;
       if _switchval = 3 then
     kin := b * su ; 
    OclFile["System.out"].println(kin) ; 
    break 
   else skip ;
       if _switchval = 4 then
     kin := c * su ; 
    OclFile["System.out"].println(kin) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] arr=sc.next().toCharArray();
    char[][] mixed=new char[4][n];
    mixed[0][0]='W' ;
    mixed[0][1]='W' ;
    mixed[1][0]='W' ;
    mixed[1][1]='S' ;
    mixed[2][0]='S' ;
    mixed[2][1]='W' ;
    mixed[3][0]='S' ;
    mixed[3][1]='S' ;
    for(int i=0 ; i<4 ; i++){
      for(int j=2 ; j<n ; j++){
        if(mixed[i][j-2]=='S' ^ mixed[i][j-1]=='S' ^ arr[j-1]=='o'){
          mixed[i][j]='S' ;
        }
        else {
          mixed[i][j]='W' ;
        }
      }
      if((mixed[i][n-1]=='S' ^ mixed[i][0]=='S' ^ arr[0]=='o' ^ mixed[i][1]=='W')&&(mixed[i][n-2]=='S' ^ mixed[i][n-1]=='S' ^ arr[n-1]=='o' ^ mixed[i][0]=='W')){
        System.out.println(mixed[i]);
        return ;
      }
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
    var mixed : Sequence(Sequence(String)) ; mixed := Integer.subrange(1,4)->collect(Integer.subrange(1,n)->collect(0)) ;
    mixed[0+1][0+1] := 'W' ; 
    mixed[0+1][1+1] := 'W' ; 
    mixed[1+1][0+1] := 'W' ; 
    mixed[1+1][1+1] := 'S' ; 
    mixed[2+1][0+1] := 'S' ; 
    mixed[2+1][1+1] := 'W' ; 
    mixed[3+1][0+1] := 'S' ; 
    mixed[3+1][1+1] := 'S' ; 
        var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 2 ; while j < n do ( (     if (mixed[i+1][j - 2+1] = 'S' xor mixed[i+1][j - 1+1] = 'S' xor arr[j - 1+1] = 'o') then (     mixed[i+1][j+1] := 'S' ) else (     mixed[i+1][j+1] := 'W' ) )  ;     j := j + 1 ) ; 
     if ((mixed[i+1][n - 1+1] = 'S' xor mixed[i+1][0+1] = 'S' xor arr[0+1] = 'o' xor mixed[i+1][1+1] = 'W') & (mixed[i+1][n - 2+1] = 'S' xor mixed[i+1][n - 1+1] = 'S' xor arr[n - 1+1] = 'o' xor mixed[i+1][0+1] = 'W')) then (     OclFile["System.out"].println(mixed[i+1]) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().compute();
  }
  void compute(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    String s=sc.next();
    boolean[] isO=new boolean[N];
    for(int i=0 ; i<N ; i++){
      isO[i]=s.charAt(i)=='o' ;
    }
    boolean[] first={
      true,true,false,false };
      boolean[] second={
        true,false,true,false };
        for(int i=0 ; i<4 ; i++){
          boolean[] isS=new boolean[N];
          isS[0]=first[i];
          isS[1]=second[i];
          for(int j=2 ; j<N ; j++){
            boolean tmp=isS[j-1] ^ isO[j-1];
            if(isS[j-2]){
              tmp=! tmp ;
            }
            isS[j]=tmp ;
          }
          boolean tmp1=isS[N-1] ^ isO[N-1];
          if(isS[N-2]){
            tmp1=! tmp1 ;
          }
          boolean tmp2=isS[0] ^ isO[0];
          if(isS[N-1]){
            tmp2=! tmp2 ;
          }
          if(isS[0]==tmp1 && isS[1]==tmp2){
            for(int j=0 ; j<N ; j++){
              System.out.print(isS[j] ? 'S' : 'W');
            }
            System.out.println();
            return ;
          }
        }
        System.out.println(-1);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().compute() );
   operation compute() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var isO : Sequence(boolean) ; isO := Integer.subrange(1,N)->collect(false) ;
        var i : int ; i := 0 ; while i < N do ( (     isO[i+1] := s->at(i+1) = 'o' )  ;     i := i + 1 ) ; 
    var first : Sequence(boolean) ; first := Sequence{true,true,false,false} ;
    var second : Sequence(boolean) ; second := Sequence{true,false,true,false} ;
        var i : int ; i := 0 ; while i < 4 do ( (     var isS : Sequence(boolean) ; isS := Integer.subrange(1,N)->collect(false) ;
     isS[0+1] := first[i+1] ; 
    isS[1+1] := second[i+1] ; 
        var j : int ; j := 2 ; while j < N do ( (     var tmp : boolean ; tmp := MathLib.bitwiseXor(isS[j - 1+1],isO[j - 1+1]) ;
     if (isS[j - 2+1]) then (     tmp := not(tmp) ) else skip ; 
     isS[j+1] := tmp )  ;     j := j + 1 ) ; 
    var tmp1 : boolean ; tmp1 := MathLib.bitwiseXor(isS[N - 1+1],isO[N - 1+1]) ;
    if (isS[N - 2+1]) then (     tmp1 := not(tmp1) ) else skip ; 
    var tmp2 : boolean ; tmp2 := MathLib.bitwiseXor(isS[0+1],isO[0+1]) ;
    if (isS[N - 1+1]) then (     tmp2 := not(tmp2) ) else skip ; 
    if (isS[0+1] = tmp1 & isS[1+1] = tmp2) then (         var j : int ; j := 0 ; while j < N do ( (     OclFile["System.out"].print(if isS[j+1] then 'S' else 'W' endif) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() ; 
     return ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    while(scan.hasNext()){
      System.out.println(new BigInteger(scan.next()).pow(3));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     while (scan.hasNext()) do (     OclFile["System.out"].println(long(scan.getCurrent()).pow(3)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sc.nextInt();
    String s=sc.next();
    System.out.println(solve(s));
    sc.close();
  }
  static String solve(String s){
    for(String prefix : new String[] { "SS","SW","WS","WW" } ){
        String assignment=buildAssignment(s,prefix);
        if(assignment!=null){
          return assignment ;
        }
      }
      return "-1" ;
    }
    static String buildAssignment(String s,String prefix){
      StringBuilder result=new StringBuilder(prefix);
      for(int i=1 ; i<s.length()-1 ; ++i){
        result.append(another(s,result,i,result.charAt(i-1)));
      }
      return(another(s,result,result.length()-1,result.charAt(result.length()-2))==result.charAt(0)&& another(s,result,0,result.charAt(1))==result.charAt(result.length()-1))? result.toString(): null ;
    }
    static char another(String s,StringBuilder assignment,int index,char neighbor){
      if(assignment.charAt(index)=='S'){
        if(s.charAt(index)=='o'){
          return neighbor ;
        }
        else {
          return invert(neighbor);
        }
      }
      else {
        if(s.charAt(index)=='o'){
          return invert(neighbor);
        }
        else {
          return neighbor ;
        }
      }
    }
    static char invert(char neighbor){
      return(neighbor=='S')? 'W' : 'S' ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var s : String ; s := sc.getCurrent() ;
    OclFile["System.out"].println(solve(s)) ; 
    skip ; 
 );
  static   operation solve( s : String) : String
  pre: true
  post: true
  activity: (     for (prefix : Sequence{"SS","SW","WS","WW"}) do ( (     var assignment : String ; assignment := buildAssignment(s, prefix) ;
     if (assignment /= null) then (     return assignment ) else skip )  ) ; 
     return "-1" );
  static   operation buildAssignment( s : String, prefix : String) : String
  pre: true
  post: true
  activity: (     var result : String ; result := StringLib.newString(prefix) ;
         var i : int ; i := 1 ; while i < s->size() - 1 do ( (     result := result + StringLib.newString(another(s, result, i, result->at((i)->char2byte() - 1+1))) )  ;     i := i + 1 ) ; 
     return if (another(s, result, result->size() - 1, result->at(result->size() - 2+1)) = result->at(0+1) & another(s, result, 0, result->at(1+1)) = result->at(result->size() - 1+1)) then result+"" else null endif );
  static   operation another( s : String, assignment : String, index : int, neighbor : String) : String
  pre: true
  post: true
  activity: (     if (assignment->at(index+1) = 'S') then (     if (s->at(index+1) = 'o') then (     return neighbor ) else (     return invert(neighbor) ) ) else (     if (s->at(index+1) = 'o') then (     return invert(neighbor) ) else (     return neighbor ) ) );
  static   operation invert( neighbor : String) : String
  pre: true
  post: true
  activity: (     return if (neighbor = 'S') then 'W' else 'S' endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findTrailingZeros(int n){
    int count=0 ;
    for(int i=5 ; n/i>=1 ; i*=5)count+=n/i ;
    return count ;
  }
  public static void main(String[] args){
    int n=100 ;
    System.out.println("Count of trailing 0s in "+n+"! is "+findTrailingZeros(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findTrailingZeros( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 5 ; while n / i >= 1 do (     count := count+(n / i) ;  ;     i := i*(5) ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 100 ;
     OclFile["System.out"].println("Count of trailing 0s in " + n + "! is " + findTrailingZeros(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Leet442 {
  public static void main(String args[]){
    int numRay[]={
      0,4,3,2,7,8,2,3,1 };
      for(int i=0 ; i<numRay.length ; i++){
        numRay[numRay[i] % numRay.length]=numRay[numRay[i] % numRay.length]+numRay.length ;
      }
      System.out.println("The repeating elements are : ");
      for(int i=0 ; i<numRay.length ; i++){
        if(numRay[i]>=numRay.length*2){
          System.out.println(i+" ");
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class Leet442 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var numRay : Sequence(int) ; numRay := Sequence{0,4,3,2,7,8,2,3,1} ;
         var i : int ; i := 0 ; while i < numRay->size() do ( (     numRay[numRay[i+1] mod numRay->size()+1] := numRay[numRay[i+1] mod numRay->size()+1] + numRay->size() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("The repeating elements are : ") ; 
         var i : int ; i := 0 ; while i < numRay->size() do ( (     if (numRay[i+1] >= numRay->size() * 2) then (     OclFile["System.out"].println(i + " ") ) else skip )  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static class Node {
    int data ;
    Node left,right ;
  }
  static Node getNode(int data){
    Node newNode=new Node();
    newNode.data=data ;
    newNode.left=null ;
    newNode.right=null ;
    return newNode ;
  }
  static boolean isFullBinaryTree(Node root){
    if(root==null)return true ;
    Queue<Node>q=new LinkedList<Node>();
    q.add(root);
    while(! q.isEmpty()){
      Node node=q.peek();
      q.remove();
      if(node.left==null && node.right==null)continue ;
      if(node.left==null || node.right==null)return false ;
      q.add(node.left);
      q.add(node.right);
    }
    return true ;
  }
  public static void main(String[] args){
    Node root=getNode(1);
    root.left=getNode(2);
    root.right=getNode(3);
    root.left.left=getNode(4);
    root.left.right=getNode(5);
    if(isFullBinaryTree(root))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static class Node {
   attribute data : int;
   attribute left : Node;
}
  static   operation getNode( data : int) : Node
  pre: true
  post: true
  activity: (     var newNode : Node ; newNode := Node.newNode() ;
     newNode.data := data ; 
    newNode.left := null ; 
    newNode.right := null ; 
    return newNode 
 );
  static   operation isFullBinaryTree( root : Node) : boolean
  pre: true
  post: true
  activity: (     if (root = null) then     return true else skip ; 
     var q : Sequence(Node) ; q := Sequence{} ;
    q := q->including(root) ; 
    while (not(q->isEmpty())) do (     var node : Node ; node := q->min() ;
     q := q.remove() ; 
    if (node.left = null & node.right = null) then     continue else skip ; 
    if (node.left = null or node.right = null) then     return false else skip ; 
    q := q->including(node.left) ; 
    q := q->including(node.right) ; 
 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var root : Node ; root := getNode(1) ;
     root.left := getNode(2) ; 
    root.right := getNode(3) ; 
    root.left.left := getNode(4) ; 
    root.left.right := getNode(5) ; 
    if (isFullBinaryTree(root)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int N=scan.nextInt();
    int[] a=new int[N];
    for(int i=0 ; i<N ; ++i){
      a[i]=scan.nextInt();
    }
    int[] leftl=new int[N];
    int[] rightl=new int[N];
    ArrayDeque<Integer>que=new ArrayDeque<>();
    int index=0 ;
    while(index<N){
      while(! que.isEmpty()&& a[que.peek()]>a[index]){
        int ind=que.poll();
        rightl[ind]=index-ind-1 ;
      }
      que.push(index++);
    }
    while(! que.isEmpty()){
      int ind=que.poll();
      rightl[ind]=N-ind-1 ;
    }
    index=N-1 ;
    while(index>=0){
      while(! que.isEmpty()&& a[que.peek()]>a[index]){
        int ind=que.poll();
        leftl[ind]=ind-index-1 ;
      }
      que.push(index--);
    }
    while(! que.isEmpty()){
      int ind=que.poll();
      leftl[ind]=ind-index-1 ;
    }
    long ans=0 ;
    for(int i=0 ; i<N ; ++i){
      ans+=(long)a[i]*(leftl[i]+1)*(rightl[i]+1);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var leftl : Sequence(int) ; leftl := Integer.subrange(1,N)->collect(0) ;
    var rightl : Sequence(int) ; rightl := Integer.subrange(1,N)->collect(0) ;
    var que : Sequence(int) ; que := ArrayDeque<OclAny>.newArrayDeque() ;
    var index : int ; index := 0 ;
    while (index < N) do (     while (not(que->isEmpty()) & a[que->min()+1] > a[index+1]) do (     var ind : int ; ind := que->min() ;
     rightl[ind+1] := index - ind - 1 ) ; 
     que := que->append(index) ) ; 
    while (not(que->isEmpty())) do (     var ind : int ; ind := que->min() ;
     rightl[ind+1] := N - ind - 1 ) ; 
    index := N - 1 ; 
    while (index >= 0) do (     while (not(que->isEmpty()) & a[que->min()+1] > a[index+1]) do (     var ind : int ; ind := que->min() ;
     leftl[ind+1] := ind - index - 1 ) ; 
     que := que->append(index) ) ; 
    while (not(que->isEmpty())) do (     var ind : int ; ind := que->min() ;
     leftl[ind+1] := ind - index - 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     ans := ans+(a[i+1]->oclAsType(long) * (leftl[i+1] + 1) * (rightl[i+1] + 1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int findCount(int arr[],int n){
    int countOdd=0 ;
    for(int i=0 ; i<n ; i++)if(arr[i] % 2==1)countOdd++;
    if(countOdd % 2==0)return 1 ;
    else return 0 ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,5,1 };
      int n=arr.length ;
      System.out.println(findCount(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation findCount( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var countOdd : int ; countOdd := 0 ;
         var i : int ; i := 0 ; while i < n do (     if (arr[i+1] mod 2 = 1) then     countOdd := countOdd + 1 ; else skip ;  ;     i := i + 1 ) ; 
     if (countOdd mod 2 = 0) then     return 1 else     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,5,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findCount(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int sumArr(int arr[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=arr[i];
    return sum ;
  }
  static int maxSum(int arr[],int n,int k){
    Arrays.sort(arr);
    int i=0 ;
    while(i<n && k>0 && arr[i]<0){
      arr[i]*=-1 ;
      k--;
      i++;
    }
    if(k % 2==1){
      int min=0 ;
      for(i=1 ; i<n ; i++)if(arr[min]>arr[i])min=i ;
      arr[min]*=-1 ;
    }
    return sumArr(arr,n);
  }
  public static void main(String[] args){
    int arr[]={
-5,4,1,3,2 };
      int n=arr.length ;
      int k=4 ;
      System.out.println(maxSum(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumArr( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation maxSum( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var i : int ; i := 0 ;
    while (i < n & k > 0 & arr[i+1] < 0) do (     arr[i+1] := arr[i+1]*(-1) ; 
     k := k - 1 ; 
     i := i + 1 ) ; 
    if (k mod 2 = 1) then (     var min : int ; min := 0 ;
         i := 1 ; while i < n do (     if (arr[min+1] > arr[i+1]) then     min := i ; else skip ;  ;     i := i + 1 ) ; 
     arr[min+1] := arr[min+1]*(-1) ) else skip ; 
    return sumArr(arr, n) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{-5,4,1,3,2} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 4 ;
     OclFile["System.out"].println(maxSum(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector ;
public class GFG {
  static int max_val(int[] arr){
    int i ;
    int max=arr[0];
    for(i=1 ; i<arr.length ; i++){
      if(arr[i]>max){
        max=arr[i];
      }
    }
    return max ;
  }
  static void compositeSumProduct(int arr[],int n,int k){
    int max_val=max_val(arr);
    Vector<Boolean>prime=new Vector<>();
    for(int i=0 ; i<max_val+1 ; i++){
      prime.add(i,Boolean.TRUE);
    }
    for(int p=2 ; p*p<=max_val ; p++){
      if(prime.get(p)==true){
        for(int i=p*2 ; i<=max_val ; i+=p){
          prime.add(i,Boolean.FALSE);
        }
      }
    }
    int sum=0,product=1 ;
    for(int i=0 ; i<n ; i++){
      if(! prime.get(arr[i])&& arr[i] % k==0){
        sum+=arr[i];
        product*=arr[i];
      }
    }
    System.out.println("Sum of composite numbers "+"divisible by k is "+sum);
    System.out.println("\nProduct of composite numbers"+" divisible by k is "+product);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,6,7 };
      int n=arr.length ;
      int k=2 ;
      compositeSumProduct(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation max_val( arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var i : int ;
     var max : int ; max := arr[0+1] ;
         i := 1 ; while i < arr->size() do ( (     if (arr[i+1] > max) then (     max := arr[i+1] ) else skip )  ;     i := i + 1 ) ; 
     return max );
  static   operation compositeSumProduct( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var max_val : int ; max_val := max_val(arr) ;
     var prime : Sequence(Boolean) ; prime := Sequence{} ;
        var i : int ; i := 0 ; while i < max_val + 1 do ( (     prime := prime.insertAt(i+1,true) )  ;     i := i + 1 ) ; 
        var p : int ; p := 2 ; while p * p <= max_val do ( (     if (prime->at(p+1) = true) then (         var i : int ; i := p * 2 ; while i <= max_val do ( (     prime := prime.insertAt(i+1,false) )  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var sum : int ; sum := 0 ;
    var product : int ; product := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (not(prime->at(arr[i+1]+1)) & arr[i+1] mod k = 0) then (     sum := sum+(arr[i+1]) ; 
     product := product*(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Sum of composite numbers " + "divisible by k is " + sum) ; 
    OclFile["System.out"].println("\nProduct of composite numbers" + " divisible by k is " + product) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6,7} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     execute compositeSumProduct(arr, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.LinkedList ;
import java.util.Queue ;
public class Main {
  public static void main(String[] args)throws IOException {
    int overCount=0,empValue,n,empID ;
    long price,quantitiy ;
    long total ;
    long[] emp=new long[4001];
    Queue<Integer>iQueue=new LinkedList<Integer>();
    BufferedReader bReader=new BufferedReader(new InputStreamReader(System.in));
    aryClear(emp);
    while((empValue=Integer.parseInt(bReader.readLine()))!=0){
      n=0 ;
      while(n<empValue){
        String str=bReader.readLine();
        String[] editedstr=str.split(" ");
        empID=Integer.parseInt(editedstr[0]);
        price=Integer.parseInt(editedstr[1]);
        quantitiy=Integer.parseInt(editedstr[2]);
        total=price*quantitiy ;
        if(emp[empID]==-1){
          emp[empID]=total ;
          iQueue.offer(empID);
        }
        else if(emp[empID]<=1000000){
          emp[empID]+=total ;
        }
        else {
        }
        n++;
      }
      for(int a : iQueue){
        if(emp[a]>=1000000){
          System.out.println(a);
          overCount++;
        }
      }
      if(overCount==0){
        System.out.println("NA");
      }
      overCount=0 ;
      iQueue.clear();
      aryClear(emp);
    }
  }
  public static void aryClear(long[] ary){
    for(int i=0 ; i<=4000 ; i++){
      ary[i]=-1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var overCount : int ; overCount := 0 ;
    var empValue : int ;
    var n : int ;
    var empID : int ;
     var price : long ;
    var quantitiy : long ;
    var total : long ;
    var emp : Sequence(long) ; emp := Integer.subrange(1,4001)->collect(0) ;
    var iQueue : Sequence(int) ; iQueue := Sequence{} ;
    var bReader : OclFile ; bReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    execute aryClear(emp) ; 
        empValue := (bReader.readLine())->toInteger() ;
    while ((empValue) /= 0) do (    skip ; (     n := 0 ; 
     while (n < empValue) do (     var str : String ; str := bReader.readLine() ;
     var editedstr : Sequence(String) ; editedstr := str->split(" ") ;
    empID := (editedstr[0+1])->toInteger() ; 
    price := (editedstr[1+1])->toInteger() ; 
    quantitiy := (editedstr[2+1])->toInteger() ; 
    total := price * quantitiy ; 
    if (emp[empID+1] = -1) then (     emp[empID+1] := total ; 
     iQueue := iQueue->including(empID) ) else     if (emp[empID+1] <= 1000000) then (     emp[empID+1] := emp[empID+1]+(total) ) else skip ;  ;  
    n := n + 1 ; 
 ) ; 
    for (a : iQueue) do ( (     if (emp[a+1] >= 1000000) then (     OclFile["System.out"].println(a) ; 
     overCount := overCount + 1 ) else skip )  ) ; 
    if (overCount = 0) then (     OclFile["System.out"].println("NA") ) else skip ; 
    overCount := 0 ; 
    iQueue := iQueue->intersection(Set{}) ; 
    execute aryClear(emp) ; 
 ) ;     empValue := (bReader.readLine())->toInteger() ;
 ) ;  
 );
  static   operation aryClear( ary : Sequence(long)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= 4000 do ( (     ary[i+1] := -1 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public void calculate(){
    Scanner input=new Scanner(System.in);
    long numSellings=Long.parseLong(input.nextLine());
    while(numSellings!=0){
      ArrayList<Long>staffs=new ArrayList<Long>();
      HashMap<Long,Long>staffProceedMap=new HashMap<Long,Long>();
      for(int i=0 ; i<numSellings ; i++){
        String[] lines=input.nextLine().split(" ");
        long staffNo=Long.parseLong(lines[0]);
        long price=Long.parseLong(lines[1])*Long.parseLong(lines[2]);
        if(staffProceedMap.containsKey(staffNo)){
          staffProceedMap.put(staffNo,price+staffProceedMap.get(staffNo));
        }
        else {
          staffs.add(staffNo);
          staffProceedMap.put(staffNo,price);
        }
      }
      boolean success=false ;
      for(long staff : staffs){
        if(staffProceedMap.get(staff)>=1000000){
          System.out.println(staff);
          success=true ;
        }
      }
      if(! success){
        System.out.println("NA");
      }
      numSellings=Long.parseLong(input.nextLine());
    }
    input.close();
  }
  public static void main(String[] args)throws java.lang.Exception {
    Main saleResult=new Main();
    saleResult.calculate();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation calculate() : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numSellings : long ; numSellings := (input.nextLine())->toLong() ;
     while (numSellings /= 0) do (     var staffs : Sequence(long) ; staffs := Sequence{} ;
     var staffProceedMap : Map(long,long) ; staffProceedMap := Map{} ;
        var i : int ; i := 0 ; while i < numSellings do ( (     var lines : Sequence(String) ; lines := input.nextLine()->split(" ") ;
     var staffNo : long ; staffNo := (lines[0+1])->toLong() ;
     var price : long ; price := (lines[1+1])->toLong() * (lines[2+1])->toLong() ;
     if (staffProceedMap->keys()->includes(staffNo)) then (     staffProceedMap := staffProceedMap->union(Map{staffNo |-> price + staffProceedMap->at(staffNo)}) ) else (     staffs := staffs->including(staffNo) ; 
     staffProceedMap := staffProceedMap->union(Map{staffNo |-> price}) ) )  ;     i := i + 1 ) ; 
    var success : boolean ; success := false ;
    for (staff : staffs) do ( (     if (staffProceedMap->at(staff) >= 1000000) then (     OclFile["System.out"].println(staff) ; 
     success := true ) else skip )  ) ; 
    if (not(success)) then (     OclFile["System.out"].println("NA") ) else skip ; 
    numSellings := (input.nextLine())->toLong() ; 
 ) ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var saleResult : Main ; saleResult := Main.newMain() ;
     saleResult.calculate() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args){
    try {
      BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
      int n ;
      while(0!=(n=Integer.parseInt(in.readLine()))){
        int[] num=new int[n];
        long[] tot=new long[n];
        int size=0 ;
        for(int i=0 ; i<n ; i++){
          int[] cur=new int[3];
          String[] s=in.readLine().split(" ");
          for(int j=0 ; j<3 ; j++){
            cur[j]=Integer.parseInt(s[j]);
          }
          int idx ;
          for(idx=0 ; idx<size && num[idx]!=cur[0]; idx++){
          }
          num[idx]=cur[0];
          tot[idx]+=cur[1]*(long)cur[2];
          if(idx==size){
            size++;
          }
        }
        boolean flg=true ;
        for(int i=0 ; i<size ; i++){
          if(tot[i]>=1000000){
            flg=false ;
            System.out.println(num[i]);
          }
        }
        if(flg){
          System.out.println("NA");
        }
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ;
         n := (in.readLine())->toInteger() ;
    while (0 /= (n)) do (    skip ; (     var num : Sequence(int) ; num := Integer.subrange(1,n)->collect(0) ;
     var tot : Sequence(long) ; tot := Integer.subrange(1,n)->collect(0) ;
    var size : int ; size := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var cur : Sequence(int) ; cur := Integer.subrange(1,3)->collect(0) ;
     var s : Sequence(String) ; s := in.readLine()->split(" ") ;
        var j : int ; j := 0 ; while j < 3 do ( (     cur[j+1] := (s[j+1])->toInteger() )  ;     j := j + 1 ) ; 
    var idx : int ;
        idx := 0 ; while idx < size & num[idx+1] /= cur[0+1] do ( skip  ;     idx := idx + 1 ) ; 
    num[idx+1] := cur[0+1] ; 
    tot[idx+1] := tot[idx+1]+(cur[1+1] * cur[2+1]->oclAsType(long)) ; 
    if (idx = size) then (     size := size + 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    var flg : boolean ; flg := true ;
        var i : int ; i := 0 ; while i < size do ( (     if (tot[i+1] >= 1000000) then (     flg := false ; 
     OclFile["System.out"].println(num[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    if (flg) then (     OclFile["System.out"].println("NA") ) else skip ; 
 ) ;     n := (in.readLine())->toInteger() ;
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    int n=in.nextInt();
    System.out.println(n*n*n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println(n * n * n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    int index=0 ;
    int[][] employee=new int[1000][4001];
    int[][] result=new int[1000][4001];
    int[][] ans=new int[1000][4001];
    while(n!=0){
      int count=1 ;
      int[] check=new int[4001];
      for(int i=0 ; i<n ; i++){
        int id=stdIn.nextInt();
        long p=stdIn.nextLong();
        long q=stdIn.nextLong();
        if(check[id]==0){
          check[id]=count ;
          employee[index][count]=id ;
          count++;
        }
        result[index][check[id] ]+=p*q ;
        if(p*q>=1000000 || result[index][check[id] ]>=1000000){
          ans[index][check[id] ]=1 ;
        }
      }
      n=stdIn.nextInt();
      index++;
    }
    for(int i=0 ; i<index ; i++){
      boolean flag=false ;
      for(int j=1 ; j<4001 ; j++){
        if(employee[i][j]==0){
          if(! flag){
            System.out.println("NA");
          }
          break ;
        }
        else if(ans[i][j]==1){
          System.out.println(employee[i][j]);
          flag=true ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var index : int ; index := 0 ;
    var employee : Sequence(Sequence(int)) ; employee := Integer.subrange(1,1000)->collect(Integer.subrange(1,4001)->collect(0)) ;
    var result : Sequence(Sequence(int)) ; result := Integer.subrange(1,1000)->collect(Integer.subrange(1,4001)->collect(0)) ;
    var ans : Sequence(Sequence(int)) ; ans := Integer.subrange(1,1000)->collect(Integer.subrange(1,4001)->collect(0)) ;
    while (n /= 0) do (     var count : int ; count := 1 ;
     var check : Sequence(int) ; check := Integer.subrange(1,4001)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var id : int ; id := stdIn.getCurrent()->toInteger() ;
     var p : long ; p := stdIn.getCurrent()->toLong() ;
    var q : long ; q := stdIn.getCurrent()->toLong() ;
    if (check[id+1] = 0) then (     check[id+1] := count ; 
     employee[index+1][count+1] := id ; 
     count := count + 1 ) else skip ; 
    result[index+1][check[id+1]+1] := result[index+1][check[id+1]+1]+(p * q) ; 
    if (p * q >= 1000000 or result[index+1][check[id+1]+1] >= 1000000) then (     ans[index+1][check[id+1]+1] := 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    n := stdIn.getCurrent()->toInteger() ; 
    index := index + 1 ; 
 ) ; 
        var i : int ; i := 0 ; while i < index do ( (     var flag : boolean ; flag := false ;
         var j : int ; j := 1 ; while j < 4001 do ( (     if (employee[i+1][j+1] = 0) then (     if (not(flag)) then (     OclFile["System.out"].println("NA") ) else skip ; 
     break ) else     if (ans[i+1][j+1] = 1) then (     OclFile["System.out"].println(employee[i+1][j+1]) ; 
     flag := true ) else skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc ;
  static final int INF=1<<28 ;
  static final double EPS=1e-9 ;
  void run(){
    sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      HashMap<Integer,Long>map=new HashMap<Integer,Long>();
      LinkedList<Integer>list=new LinkedList<Integer>();
      for(int i=0 ; i<n ; i++){
        int id=sc.nextInt();
        long a=sc.nextInt();
        long b=sc.nextInt();
        if(! map.containsKey(id)){
          list.addLast(id);
          map.put(id,0l);
        }
        map.put(id,map.get(id)+a*b);
      }
      boolean f=false ;
      for(int id : list){
        if(map.get(id)>=1000000){
          println(id+"");
          f=true ;
        }
      }
      if(! f)println("NA");
    }
    sc.close();
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
  static    attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
  static    attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var map : Map(int,long) ; map := Map{} ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var id : int ; id := sc.getCurrent()->toInteger() ;
     var a : long ; a := sc.getCurrent()->toInteger() ;
    var b : long ; b := sc.getCurrent()->toInteger() ;
    if (not(map->keys()->includes(id))) then (     list := list->append(id) ; 
     map := map->union(Map{id |-> 0l}) ) else skip ; 
    map := map->union(Map{id |-> map->at(id) + a * b}) ; 
 )  ;     i := i + 1 ) ; 
    var f : boolean ; f := false ;
    for (id : list) do ( (     if (map->at(id) >= 1000000) then (     execute println(id + "") ; 
     f := true ) else skip )  ) ; 
    if (not(f)) then     execute println("NA") ; else skip ; 
 )  ) ; 
     skip );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt(),A[]=new int[N],Ma=0 ;
    for(int i=0 ; i<N ; i++){
      int t=sc.nextInt(),n=0 ;
      if(t % 2==1){
        Ma=0 ;
        break ;
      }
      while(t % 2==0){
        n++;
        t/=2 ;
      }
      if(Ma==0 && n!=0){
        Ma=n ;
      }
      else {
        Ma=Math.min(n,Ma);
      }
    }
    System.out.println(Ma);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(void) ; A := Integer.subrange(1,N)->collect(0) ;
    var Ma : int ; Ma := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     var t : int ; t := sc.getCurrent()->toInteger() ;
    var n : int ; n := 0 ;
     if (t mod 2 = 1) then (     Ma := 0 ; 
     break ) else skip ; 
     while (t mod 2 = 0) do (     n := n + 1 ; 
     t := t/(2) ) ; 
     if (Ma = 0 & n /= 0) then (     Ma := n ) else (     Ma := Set{n, Ma}->min() ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(Ma) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[] a=new int[n];
    int[] b=new int[n];
    int[] c=new int[n];
    int count=1 ;
    for(int i=0 ; i<n ; i++){
      a[i]=scan.nextInt();
      b[i]=scan.nextInt();
      c[i]=i ;
      count*=(i+1);
    }
    double sum=0 ;
    ArrayList<String>g=new ArrayList<String>();
    sum=permutation(c,n,g,sum,a,b);
    double p=(double)sum/count ;
    System.out.println(p);
  }
  static double permutation(int[] a,int n,ArrayList<String>g,double sum,int[] c,int[] b){
    if(g.size()==n){
      for(int k=0 ; k<g.size()-1 ; k++){
        int a1=Integer.parseInt(g.get(k));
        int a2=Integer.parseInt(g.get(k+1));
        sum+=calculate(c[a1],b[a1],c[a2],b[a2]);
      }
      return sum ;
    }
    for(int i=0 ; i<n ; i++){
      if(g.contains(a[i]+"")==false){
        g.add(a[i]+"");
        sum=permutation(a,n,g,sum,c,b);
        g.remove(a[i]+"");
      }
    }
    return sum ;
  }
  static double calculate(int a,int b,int c,int d){
    int len=(int)(a-c)*(a-c)+(b-d)*(b-d);
    double gg=(double)Math.sqrt(len);
    return gg ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    var count : int ; count := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() ; 
     b[i+1] := scan.getCurrent()->toInteger() ; 
     c[i+1] := i ; 
     count := count*((i + 1)) )  ;     i := i + 1 ) ; 
    var sum : double ; sum := 0 ;
    var g : Sequence(String) ; g := Sequence{} ;
    sum := permutation(c, n, g, sum, a, b) ; 
    var p : double ; p := sum->oclAsType(double) / count ;
    OclFile["System.out"].println(p) ; 
 );
  static   operation permutation( a : Sequence(int), n : int, g : Sequence(String), sum : double, c : Sequence(int), b : Sequence(int)) : double
  pre: true
  post: true
  activity: (     if (g->size() = n) then (         var k : int ; k := 0 ; while k < g->size() - 1 do ( (     var a1 : int ; a1 := (g->at(k+1))->toInteger() ;
     var a2 : int ; a2 := (g->at(k + 1+1))->toInteger() ;
     sum := sum+(calculate(c[a1+1], b[a1+1], c[a2+1], b[a2+1])) )  ;     k := k + 1 ) ; 
     return sum ) else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     if (g->includes(a[i+1] + "") = false) then (     g := g->including(a[i+1] + "") ; 
     sum := permutation(a, n, g, sum, c, b) ; 
     g := g->excludingFirst(a[i+1] + "") ) else skip )  ;     i := i + 1 ) ; 
     return sum );
  static   operation calculate( a : int, b : int, c : int, d : int) : double
  pre: true
  post: true
  activity: (     var len : int ; len := (a - c)->oclAsType(int) * (a - c) + (b - d) * (b - d) ;
     var gg : double ; gg := (len)->sqrt()->oclAsType(double) ;
     return gg );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.stream.IntStream ;
import java.util.stream.Stream ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(AtCoderReader ar=new AtCoderReader()){
      ar.next();
      int[] A=ar.nextIntArray();
      int min=Integer.MAX_VALUE ;
      for(int i=0 ; i<A.length ; i++){
        min=Math.min(min,getCan2DivCount(A[i]));
      }
      System.out.println(min);
    }
  }
  private static int getCan2DivCount(int num){
    if(num % 2==0){
      return 1+getCan2DivCount(num/2);
    }
    else {
      return 0 ;
    }
  }
  public static class AtCoderReader implements AutoCloseable {
    private final BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    public final String[] nextStringArray()throws IOException {
      return this.br.readLine().split(" ");
    }
    public final Stream<String>nextStream()throws IOException {
      return Stream.of(this.nextStringArray());
    }
    public final IntStream nextIntStream()throws NumberFormatException,IOException {
      return this.nextStream().mapToInt(Integer :: parseInt);
    }
    public final int[] nextIntArray()throws IOException {
      return this.nextIntStream().toArray();
    }
    public final int nextInt()throws NumberFormatException,IOException {
      return Integer.parseInt(next());
    }
    public final String next()throws IOException {
      return this.br.readLine();
    }
    @ Override public final void close()throws IOException {
      br.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var ar : AtCoderReader := AtCoderReader.newAtCoderReader() ;
 (     ar.next() ; 
     var A : Sequence(int) ; A := ar.nextIntArray() ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < A->size() do ( (     min := Set{min, getCan2DivCount(A[i+1])}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 ))  );
  static   operation getCan2DivCount( num : int) : int
  pre: true
  post: true
  activity: (     if (num mod 2 = 0) then (     return 1 + getCan2DivCount(num / 2) ) else (     return 0 ) );
  static class AtCoderReader implements AutoCloseable {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   operation nextStringArray() : Sequence(String)
  pre: true
  post: true
  activity: (     return self.br.readLine()->split(" ") );
   operation nextStream() : Stream<String>
  pre: true
  post: true
  activity: (     return Sequence{self.nextStringArray()} );
   operation nextIntStream() : Sequence(int)
  pre: true
  post: true
  activity: (     return self.nextStream()->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) ) );
   operation nextIntArray() : Sequence(int)
  pre: true
  post: true
  activity: (     return self.nextIntStream()->asSequence() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation next() : String
  pre: true
  post: true
  activity: (     return self.br.readLine() );
      operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Optional ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int count=Integer.valueOf(sc.nextLine());
    Optional<Integer>result=Arrays.asList(sc.nextLine().split(" ")).parallelStream().map(Main :: countCanDivideBy2).min(Integer :: compare);
    System.out.println(result.get());
  }
  public static int countCanDivideBy2(String s){
    int i=Integer.parseInt(s);
    int result=0 ;
    while(i % 2==0){
      i/=2 ;
      result++;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : int ; count := (sc.nextLine())->toInteger() ;
     var result : Optional<int> ; result := sc.nextLine()->split(" ").parallelStream()->collect( _x1 | (lambda _pars : OclAny in Main.newMain().countCanDivideBy2(_pars))->apply(_x1) )->min() ;
     OclFile["System.out"].println(result.get()) );
  static   operation countCanDivideBy2( s : String) : int
  pre: true
  post: true
  activity: (     var i : int ; i := (s)->toInteger() ;
     var result : int ; result := 0 ;
     while (i mod 2 = 0) do (     i := i/(2) ; 
     result := result + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
import jdk.nashorn.internal.runtime.regexp.joni.ScanEnvironment ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.nextLine());
    String[] aString=sc.nextLine().split(" ");
    byte count=0 ;
    boolean flag=true ;
    List<Integer>a=new ArrayList<>();
    do {
      if(aString!=null){
        for(int i=0 ; i<n ; i++){
          a.add(Integer.parseInt(aString[i]));
        }
        aString=null ;
      }
      for(int i=0 ; i<n ; i++){
        int target=a.get(i);
        if(target % 2!=0){
          flag=false ;
          break ;
        }
        a.set(i,target/2);
      }
      if(flag){
        count++;
      }
    }
    while(flag);
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.nextLine())->toInteger() ;
    var aString : Sequence(String) ; aString := sc.nextLine()->split(" ") ;
    var count : int ; count := 0 ;
    var flag : boolean ; flag := true ;
    var a : Sequence(int) ; a := Sequence{} ;
  while true do ((     if (aString /= null) then (         var i : int ; i := 0 ; while i < n do ( (     a := a->including((aString[i+1])->toInteger()) )  ;     i := i + 1 ) ; 
     aString := null ) else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     var target : int ; target := a->at(i+1) ;
     if (target mod 2 /= 0) then (     flag := false ; 
     break ) else skip ; 
     a := a.setAt(i+1,target / 2) )  ;     i := i + 1 ) ; 
     if (flag) then (     count := count + 1 ) else skip ) ;
    if (flag) then skip else break) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.OptionalInt ;
import java.util.stream.Stream ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      br.readLine();
      OptionalInt count=Stream.of(br.readLine().split(" ")).mapToInt(Integer :: parseInt).map(Main :: getCan2DivCount).min();
      System.out.println(count.orElse(0));
    }
  }
  private static int getCan2DivCount(int num){
    if(num % 2==0){
      return 1+getCan2DivCount(num/2);
    }
    else {
      return 0 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     skip ; 
     var count : OptionalInt ; count := Sequence{br.readLine()->split(" ")}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->collect( _x1 | (lambda _pars : OclAny in Main.newMain().getCan2DivCount(_pars))->apply(_x1) ).min() ;
     OclFile["System.out"].println(count.orElse(0)) ))  );
  static   operation getCan2DivCount( num : int) : int
  pre: true
  post: true
  activity: (     if (num mod 2 = 0) then (     return 1 + getCan2DivCount(num / 2) ) else (     return 0 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GFG {
  public static void getStrings(String str,String[] arr){
    for(int i=0 ; i<arr.length ; i++){
      if(check(arr[i],str)){
        System.out.print(arr[i]+" ");
      }
    }
  }
  public static boolean check(String s,String str){
    char[] chars=s.toCharArray();
    for(char c : chars){
      if(! str.contains(String.valueOf(c))){
        return false ;
      }
    }
    for(int i=0 ; i<chars.length-1 ; i++){
      if(chars[i]==chars[i+1]){
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    String str="ABCD" ;
    String[] arr={
      "AABCDA","ABCDZADC","ABCDBCA","ABCDABDCA" };
      getStrings(str,arr);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getStrings( str : String, arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < arr->size() do ( (     if (check(arr[i+1], str)) then (     OclFile["System.out"].print(arr[i+1] + " ") ) else skip )  ;     i := i + 1 ) );
  static   operation check( s : String, str : String) : boolean
  pre: true
  post: true
  activity: (     var chars : Sequence(String) ; chars := s->characters() ;
     for (c : chars) do ( (     if (not(str->includes(((c) + "")))) then (     return false ) else skip )  ) ; 
         var i : int ; i := 0 ; while i < chars->size() - 1 do ( (     if (chars[i+1] = chars[i + 1+1]) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "ABCD" ;
     var arr : Sequence(String) ; arr := Sequence{"AABCDA","ABCDZADC","ABCDBCA","ABCDABDCA"} ;
     execute getStrings(str, arr) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Parlament {
  public static void main(String[] args){
    Scanner s=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int n=s.nextInt();
    int a=s.nextInt();
    int b=s.nextInt();
    if((n>a*b)||(n/2>((b/2+1)*(a/2+1)+(b/2)*(a/2)))){
      System.out.print("-1");
      return ;
    }
    System.out.print(getSolution(n,a,b));
  }
  private static String getSolution(int n,int a,int b){
    StringBuilder sb=new StringBuilder(a+4*a*b);
    int i,j ;
    for(i=0 ; i<a ; i++){
      for(j=0 ; j<b ; j++){
        int index=i*b+1+(j+(b-1)*(i % 2)*((b+1)% 2))%(b);
        if(index<=n){
          sb.append(String.valueOf(index));
          sb.append(' ');
        }
        else {
          sb.append("0 ");
        }
      }
      sb.append('\n');
    }
    return sb.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Parlament {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var a : int ; a := s.getCurrent()->toInteger() ;
    var b : int ; b := s.getCurrent()->toInteger() ;
    if ((n > a * b) or (n / 2 > ((b / 2 + 1) * (a / 2 + 1) + (b / 2) * (a / 2)))) then (     OclFile["System.out"].print("-1") ; 
     return ) else skip ; 
    OclFile["System.out"].print(getSolution(n, a, b)) ; 
 );
  static   operation getSolution( n : int, a : int, b : int) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString(a + 4 * a * b) ;
     var i : int ;
    var j : int ;
         i := 0 ; while i < a do ( (         j := 0 ; while j < b do ( (     var index : int ; index := i * b + 1 + (j + (b - 1) * (i mod 2) * ((b + 1) mod 2)) mod (b) ;
     if (index <= n) then (     sb := sb + StringLib.newString(((index) + "")) ; 
     sb := sb + StringLib.newString(' ') ) else (     sb := sb + StringLib.newString("0 ") ) )  ;     j := j + 1 ) ; 
     sb := sb + StringLib.newString('
') )  ;     i := i + 1 ) ; 
     return sb+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int a=in.nextInt();
    int b=in.nextInt();
    int[][] seats=new int[a][b];
    int current=-1 ;
    boolean flag=false ;
    if(a*b<n)System.out.println("-1");
    else {
      for(int i=0 ; i<a ; i++){
        if(flag==true){
          flag=false ;
          break ;
        }
        if(i % 2==0){
          for(int j=0 ; j<b ; j+=2){
            current+=2 ;
            if(current<=n)seats[i][j]=current ;
            else {
              current=0 ;
              flag=true ;
              break ;
            }
          }
        }
        else {
          for(int j=1 ; j<b ; j+=2){
            current+=2 ;
            if(current<=n)seats[i][j]=current ;
            else {
              current=0 ;
              flag=true ;
              break ;
            }
          }
        }
      }
      current=0 ;
      flag=false ;
      for(int i=0 ; i<a ; i++){
        if(flag==true){
          break ;
        }
        if(i % 2==0){
          for(int j=1 ; j<b ; j+=2){
            current+=2 ;
            if(current<=n)seats[i][j]=current ;
            else {
              current=0 ;
              flag=true ;
              break ;
            }
          }
        }
        else {
          for(int j=0 ; j<b ; j+=2){
            current+=2 ;
            if(current<=n)seats[i][j]=current ;
            else {
              flag=true ;
              break ;
            }
          }
        }
      }
      for(int i=0 ; i<a ; i++){
        for(int j=0 ; j<b ; j++)System.out.print(seats[i][j]+" ");
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var seats : Sequence(Sequence(int)) ; seats := Integer.subrange(1,a)->collect(Integer.subrange(1,b)->collect(0)) ;
    var current : int ; current := -1 ;
    var flag : boolean ; flag := false ;
    if (a * b < n) then     OclFile["System.out"].println("-1") else (         var i : int ; i := 0 ; while i < a do ( (     if (flag = true) then (     flag := false ; 
     break ) else skip ; 
     if (i mod 2 = 0) then (         var j : int ; j := 0 ; while j < b do ( (     current := current+(2) ; 
     if (current <= n) then     seats[i+1][j+1] := current ; else (     current := 0 ; 
     flag := true ; 
     break ) )  ;     j := j+(2) ) ) else (         var j : int ; j := 1 ; while j < b do ( (     current := current+(2) ; 
     if (current <= n) then     seats[i+1][j+1] := current ; else (     current := 0 ; 
     flag := true ; 
     break ) )  ;     j := j+(2) ) ) )  ;     i := i + 1 ) ; 
     current := 0 ; 
    flag := false ; 
        var i : int ; i := 0 ; while i < a do ( (     if (flag = true) then (     break ) else skip ; 
     if (i mod 2 = 0) then (         var j : int ; j := 1 ; while j < b do ( (     current := current+(2) ; 
     if (current <= n) then     seats[i+1][j+1] := current ; else (     current := 0 ; 
     flag := true ; 
     break ) )  ;     j := j+(2) ) ) else (         var j : int ; j := 0 ; while j < b do ( (     current := current+(2) ; 
     if (current <= n) then     seats[i+1][j+1] := current ; else (     flag := true ; 
     break ) )  ;     j := j+(2) ) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a do ( (         var j : int ; j := 0 ; while j < b do (     OclFile["System.out"].print(seats[i+1][j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class main {
  public static void main(String[] args)throws java.lang.Exception {
    FastReader s=new FastReader();
    int t=s.nextInt();
    while(t--!=0){
      long l=s.nextLong();
      long r=s.nextLong();
      long m=s.nextLong();
      long maxdif=r-l ;
      long mindif=l-r ;
      boolean found=false ;
      long lower=m-maxdif ;
      if(lower<=0){
        lower=1 ;
      }
      long upper=m-mindif ;
      long a=0 ;
      long b=0 ;
      long c=0 ;
      for(long i=l ; i<=r ; i++){
        long num ;
        if(lower % i!=0){
          num=lower+(i-(lower % i));
        }
        else {
          num=lower ;
        }
        if(num<=upper){
          a=i ;
          if(num<m){
            b=r ;
            c=r-(m-num);
          }
          else {
            b=l ;
            c=l+(num-m);
          }
          break ;
        }
      }
      System.out.println(a+" "+b+" "+c);
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : FastReader ; s := FastReader.newFastReader() ;
     var t : int ; t := s.nextInt() ;
         while (t /= 0) do (    skip ; (     var l : long ; l := s.nextLong() ;
     var r : long ; r := s.nextLong() ;
    var m : long ; m := s.nextLong() ;
    var maxdif : long ; maxdif := r - l ;
    var mindif : long ; mindif := l - r ;
    var found : boolean ; found := false ;
    var lower : long ; lower := m - maxdif ;
    if (lower <= 0) then (     lower := 1 ) else skip ; 
    var upper : long ; upper := m - mindif ;
    var a : long ; a := 0 ;
    var b : long ; b := 0 ;
    var c : long ; c := 0 ;
        var i : long ; i := l ; while i <= r do ( (     var num : long ;
     if (lower mod i /= 0) then (     num := lower + (i - (lower mod i)) ) else (     num := lower ) ;  
     if (num <= upper) then (     a := i ; 
     if (num < m) then (     b := r ; 
     c := r - (m - num) ) else (     b := l ; 
     c := l + (num - m) ) ;  
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a + " " + b + " " + c) ; 
 ) ;  ) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class PrA {
  public static void main(String[] args)throws IOException {
    new PrA().run();
  }
  BufferedReader in ;
  PrintWriter out ;
  StringTokenizer st ;
  String nextToken()throws IOException {
    while(st==null || ! st.hasMoreTokens()){
      st=new StringTokenizer(in.readLine());
    }
    return st.nextToken();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  void run()throws IOException {
    in=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(System.out,true);
    solve();
    out.flush();
  }
  void solve()throws IOException {
    int n=nextInt();
    int a=nextInt();
    int b=nextInt();
    if(n>a*b){
      out.println(-1);
      return ;
    }
    int[][] ans=new int[a][b];
    int cur=1 ;
    for(int i=0 ; i<a && cur<=n ; i++){
      if(i % 2==0){
        for(int j=0 ; j<b && cur<=n ; j++){
          ans[i][j]=cur ;
          cur++;
        }
      }
      else {
        for(int j=b-1 ; j>-1 && cur<=n ; j--){
          ans[i][j]=cur ;
          cur++;
        }
      }
    }
    for(int i=0 ; i<a ; i++){
      for(int j=0 ; j<b ; j++){
        out.print(ans[i][j]+" ");
      }
      out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PrA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     PrA.newPrA().run() );
   attribute in : OclFile;
   attribute out : OclFile;
   attribute st : OclIterator;
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(in.readLine()) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation run() : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"], true) ; 
     execute solve() ; 
     skip );
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var a : int ; a := nextInt() ;
    var b : int ; b := nextInt() ;
    if (n > a * b) then (     skip ; 
     return ) else skip ; 
    var ans : Sequence(Sequence(int)) ; ans := Integer.subrange(1,a)->collect(Integer.subrange(1,b)->collect(0)) ;
    var cur : int ; cur := 1 ;
        var i : int ; i := 0 ; while i < a & cur <= n do ( (     if (i mod 2 = 0) then (         var j : int ; j := 0 ; while j < b & cur <= n do ( (     ans[i+1][j+1] := cur ; 
     cur := cur + 1 )  ;     j := j + 1 ) ) else (         var j : int ; j := b - 1 ; while j > -1 & cur <= n do ( (     ans[i+1][j+1] := cur ; 
     cur := cur + 1 )  ;     j := j - 1 ) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a do ( (         var j : int ; j := 0 ; while j < b do ( (     skip )  ;     j := j + 1 ) ; 
     skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    String S=sc.next();
    String T=S.replaceAll("ABC",".");
    System.out.println((S.length()-T.length())/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var S : String ; S := sc.getCurrent() ;
    var T : String ; T := S.replaceAllMatches("ABC", "." ) ;
    OclFile["System.out"].println((S->size() - T->size()) / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int[][] pos=new int[N][2];
    for(int i=0 ; i<N ; i++){
      pos[i][0]=scanner.nextInt();
      pos[i][1]=scanner.nextInt();
    }
    double sum=0 ;
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        if(i==j)continue ;
        sum+=dist(pos[i][0],pos[i][1],pos[j][0],pos[j][1]);
      }
    }
    System.out.println(sum/N);
  }
  private static double dist(int x1,int y1,int x2,int y2){
    return Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var pos : Sequence(Sequence(int)) ; pos := Integer.subrange(1,N)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     pos[i+1][0+1] := scanner.getCurrent()->toInteger() ; 
     pos[i+1][1+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum : double ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     if (i = j) then     continue else skip ; 
     sum := sum+(dist(pos[i+1][0+1], pos[i+1][1+1], pos[j+1][0+1], pos[j+1][1+1])) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum / N) ; 
 );
  static   operation dist( x1 : int, y1 : int, x2 : int, y2 : int) : double
  pre: true
  post: true
  activity: (     return ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))->sqrt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;
class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner io=new Scanner(System.in);
    int n=io.nextInt();
    char[] str=io.next().toCharArray();
    int c=0 ;
    for(int i=0 ; i<n-2 ; i++)if(str[i]=='A' && str[i+1]=='B' && str[i+2]=='C' &&(i+=2)>0)c++;
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := io.getCurrent()->toInteger() ;
    var str : Sequence(String) ; str := io.getCurrent()->characters() ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n - 2 do (     if (str[i+1] = 'A' & str[i + 1+1] = 'B' & str[i + 2+1] = 'C' & (i) > 0) then     c := c + 1 ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedInputStream ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(new BufferedInputStream(System.in));
    int a=sc.nextInt();
    String b=sc.next();
    char m[]=b.toCharArray();
    if(a<3)System.out.println("0");
    else {
      int count=0 ;
      for(int i=2 ; i<m.length ; i++){
        if(m[i-2]=='A' && m[i-1]=='B' && m[i]=='C')count++;
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : String ; b := sc.getCurrent() ;
    var m : Sequence(String) ; m := b->characters() ;
    if (a < 3) then     OclFile["System.out"].println("0") else (     var count : int ; count := 0 ;
         var i : int ; i := 2 ; while i < m->size() do ( (     if (m[i - 2+1] = 'A' & m[i - 1+1] = 'B' & m[i+1] = 'C') then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    int ans=0 ;
    String[] sArray=new String[s.length()];
    for(int i=0 ; i<s.length(); i++){
      String s2=String.valueOf(s.charAt(i));
      sArray[i]=s2 ;
    }
    for(int i=0 ; i<n-2 ; i++){
      if(sArray[i] .equals("A")){
        if(sArray[i+1] .equals("B")){
          if(sArray[i+2] .equals("C")){
            ans++;
          }
          else {
          }
        }
        else {
        }
      }
      else {
      }
    }
    System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var ans : int ; ans := 0 ;
    var sArray : Sequence(String) ; sArray := Integer.subrange(1,s->size())->collect(null) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var s2 : String ; s2 := ((s->at(i+1)) + "") ;
     sArray[i+1] := s2 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 2 do ( (     if (sArray[i+1] = "A") then (     if (sArray[i + 1+1] = "B") then (     if (sArray[i + 2+1] = "C") then (     ans := ans + 1 ) else skip ) else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    int count=0 ;
    for(int i=0 ; i<n-2 ; i++){
      if(s.charAt(i)=='A' && s.charAt(i+1)=='B' && s.charAt(i+2)=='C'){
        count++;
      }
    }
    out(count);
  }
  static long gcd(long a,long b){
    return(b==0)? a : gcd(b,a % b);
  }
  static int gcd(int a,int b){
    return(b==0)? a : gcd(b,a % b);
  }
  static void out(String info){
    System.out.println(info);
  }
  static void out(int info){
    System.out.println(info);
  }
  static void out(double info){
    System.out.println(info);
  }
  static void out(long info){
    System.out.println(info);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n - 2 do ( (     if (s->at(i+1) = 'A' & s->at(i + 1+1) = 'B' & s->at(i + 2+1) = 'C') then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    execute out(count) ; 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return if (b = 0) then a else gcd(b, a mod b) endif );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if (b = 0) then a else gcd(b, a mod b) endif );
  static   operation out( info : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(info) );
  static   operation out( info : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(info) );
  static   operation out( info : double) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(info) );
  static   operation out( info : long) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(info) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int mod=1000000007 ;
  static int countSubsets(int a[],int n){
    int answer=0 ;
    for(int i=0 ; i<(1<<n); i++){
      int bitwiseAND=-1 ;
      int bitwiseOR=0 ;
      int bitwiseXOR=0 ;
      for(int j=0 ; j<n ; j++){
        if((i &(1<<j))==0){
          if(bitwiseAND==-1)bitwiseAND=a[j];
          else bitwiseAND &=a[j];
          bitwiseOR |=a[j];
          bitwiseXOR ^=a[j];
        }
      }
      if(bitwiseAND==bitwiseOR && bitwiseOR==bitwiseXOR)answer=(answer+1)% mod ;
    }
    return answer ;
  }
  public static void main(String[] args){
    int N=6 ;
    int A[]={
      1,3,2,1,2,1 };
      System.out.print(countSubsets(A,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute mod : int := 1000000007;
  static   operation countSubsets( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var answer : int ; answer := 0 ;
         var i : int ; i := 0 ; while i < ((1*(2->pow(n)))->oclAsType(long)) do ( (     var bitwiseAND : int ; bitwiseAND := -1 ;
     var bitwiseOR : int ; bitwiseOR := 0 ;
    var bitwiseXOR : int ; bitwiseXOR := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd(i,((1*(2->pow(j)))->oclAsType(long)))) = 0) then (     if (bitwiseAND = -1) then     bitwiseAND := a[j+1] else     bitwiseAND := MathLib.bitwiseAnd(bitwiseAND, a[j+1]) ; ;  
     bitwiseOR := MathLib.bitwiseOr(bitwiseOR, a[j+1]) ; 
     bitwiseXOR := MathLib.bitwiseXor(bitwiseXOR,a[j+1]) ) else skip )  ;     j := j + 1 ) ; 
    if (bitwiseAND = bitwiseOR & bitwiseOR = bitwiseXOR) then     answer := (answer + 1) mod mod ; else skip ; 
 )  ;     i := i + 1 ) ; 
     return answer );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 6 ;
     var A : Sequence(int) ; A := Sequence{1,3,2,1,2,1} ;
     OclFile["System.out"].print(countSubsets(A, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Segregate {
  void segregate0and1(int arr[],int size){
    int left=0,right=size-1 ;
    while(left<right){
      while(arr[left]==0 && left<right)left++;
      while(arr[right]==1 && left<right)right--;
      if(left<right){
        arr[left]=0 ;
        arr[right]=1 ;
        left++;
        right--;
      }
    }
  }
  public static void main(String[] args){
    Segregate seg=new Segregate();
    int arr[]=new int[] {
      0,1,0,1,1,1 };
      int i,arr_size=arr.length ;
      seg.segregate0and1(arr,arr_size);
      System.out.print("Array after segregation is ");
      for(i=0 ; i<6 ; i++)System.out.print(arr[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
class Segregate {
   operation segregate0and1( arr : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (     var left : int ; left := 0 ;
    var right : int ; right := size - 1 ;
     while (left < right) do (     while (arr[left+1] = 0 & left < right) do     left := left + 1 ; ; 
     while (arr[right+1] = 1 & left < right) do     right := right - 1 ; ; 
     if (left < right) then (     arr[left+1] := 0 ; 
     arr[right+1] := 1 ; 
     left := left + 1 ; 
     right := right - 1 ) else skip ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var seg : Segregate ; seg := Segregate.newSegregate() ;
     var arr : Sequence(int) ; arr := Sequence{0,1,0,1,1,1} ;
    var i : int ;
    var arr_size : int ; arr_size := arr->size() ;
    seg.segregate0and1(arr, arr_size) ; 
    OclFile["System.out"].print("Array after segregation is ") ; 
        i := 0 ; while i < 6 do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[] sumA=new long[N+1];
    long[] sumB=new long[N+1];
    long countA=0,countB=0 ;
    for(int i=1 ; i<=N ; i++){
      long a=sc.nextLong();
      sumA[i]=a+sumA[i-1];
      sumB[i]=a+sumB[i-1];
      if(sumA[i]<=0 && i % 2!=0){
        countA+=1-sumA[i];
        sumA[i]+=1-sumA[i];
      }
      if(sumA[i]>=0 && i % 2==0){
        countA+=sumA[i]+1 ;
        sumA[i]+=(-1)-sumA[i];
      }
      if(sumB[i]<=0 && i % 2==0){
        countB+=1-sumB[i];
        sumB[i]+=1-sumB[i];
      }
      if(sumB[i]>=0 && i % 2!=0){
        countB+=sumB[i]+1 ;
        sumB[i]+=(-1)-sumB[i];
      }
    }
    System.out.println(Math.min(countA,countB));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var sumA : Sequence(long) ; sumA := Integer.subrange(1,N + 1)->collect(0) ;
    var sumB : Sequence(long) ; sumB := Integer.subrange(1,N + 1)->collect(0) ;
    var countA : long ; countA := 0 ;
    var countB : long ; countB := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     var a : long ; a := sc.getCurrent()->toLong() ;
     sumA[i+1] := a + sumA[i - 1+1] ; 
    sumB[i+1] := a + sumB[i - 1+1] ; 
    if (sumA[i+1] <= 0 & i mod 2 /= 0) then (     countA := countA+(1 - sumA[i+1]) ; 
     sumA[i+1] := sumA[i+1]+(1 - sumA[i+1]) ) else skip ; 
    if (sumA[i+1] >= 0 & i mod 2 = 0) then (     countA := countA+(sumA[i+1] + 1) ; 
     sumA[i+1] := sumA[i+1]+((-1) - sumA[i+1]) ) else skip ; 
    if (sumB[i+1] <= 0 & i mod 2 = 0) then (     countB := countB+(1 - sumB[i+1]) ; 
     sumB[i+1] := sumB[i+1]+(1 - sumB[i+1]) ) else skip ; 
    if (sumB[i+1] >= 0 & i mod 2 /= 0) then (     countB := countB+(sumB[i+1] + 1) ; 
     sumB[i+1] := sumB[i+1]+((-1) - sumB[i+1]) ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{countA, countB}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().compute();
  }
  void compute(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
    }
    long ans1=0 ;
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=a[i];
      if(i % 2==1 && sum<=0){
        ans1+=1-sum ;
        sum=1 ;
      }
      else if(i % 2==0 && sum>=0){
        ans1+=sum+1 ;
        sum=-1 ;
      }
    }
    long ans2=0 ;
    sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=a[i];
      if(i % 2==0 && sum<=0){
        ans2+=1-sum ;
        sum=1 ;
      }
      else if(i % 2==1 && sum>=0){
        ans2+=sum+1 ;
        sum=-1 ;
      }
    }
    System.out.println(Math.min(ans1,ans2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().compute() );
   operation compute() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var ans1 : long ; ans1 := 0 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(a[i+1]) ; 
     if (i mod 2 = 1 & sum <= 0) then (     ans1 := ans1+(1 - sum) ; 
     sum := 1 ) else     if (i mod 2 = 0 & sum >= 0) then (     ans1 := ans1+(sum + 1) ; 
     sum := -1 ) else skip ; )  ;     i := i + 1 ) ; 
    var ans2 : long ; ans2 := 0 ;
    sum := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(a[i+1]) ; 
     if (i mod 2 = 0 & sum <= 0) then (     ans2 := ans2+(1 - sum) ; 
     sum := 1 ) else     if (i mod 2 = 1 & sum >= 0) then (     ans2 := ans2+(sum + 1) ; 
     sum := -1 ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{ans1, ans2}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test0417 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long t=sc.nextLong();
    long l,r,m ;
    while(t-->0){
      l=sc.nextLong();
      r=sc.nextLong();
      m=sc.nextLong();
      for(long a=l ; a<=r ; a++){
        long q=m % a ;
        if(m>=a && q<=r-l){
          System.out.println(a+" "+(l+q)+" "+l);
          break ;
        }
        if(q-a>=l-r){
          System.out.println(a+" "+(r+q-a)+" "+r);
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test0417 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : long ; t := sc.getCurrent()->toLong() ;
     var l : long ;
    var r : long ;
    var m : long ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     l := sc.getCurrent()->toLong() ; 
     r := sc.getCurrent()->toLong() ; 
     m := sc.getCurrent()->toLong() ; 
         var a : long ; a := l ; while a <= r do ( (     var q : long ; q := m mod a ;
     if (m >= a & q <= r - l) then (     OclFile["System.out"].println(a + " " + (l + q) + " " + l) ; 
     break ) else skip ; 
     if (q - a >= l - r) then (     OclFile["System.out"].println(a + " " + (r + q - a) + " " + r) ; 
     break ) else skip )  ;     a := a + 1 ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[])throws IOException {
    long c1=0 ;
    long c2=0 ;
    long sum1=0 ;
    long sum2=0 ;
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    StringTokenizer st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<n ; i++){
      long tmp=Integer.parseInt(st.nextToken());
      sum1+=tmp ;
      sum2+=tmp ;
      if(i % 2==0){
        if(sum1<=0){
          c1+=Math.abs(sum1)+1 ;
          sum1=1 ;
        }
        if(sum2>=0){
          c2+=Math.abs(sum2)+1 ;
          sum2=-1 ;
        }
      }
      else {
        if(sum1>=0){
          c1+=Math.abs(sum1)+1 ;
          sum1=-1 ;
        }
        if(sum2<=0){
          c2+=Math.abs(sum2)+1 ;
          sum2=1 ;
        }
      }
    }
    System.out.println(Math.min(c1,c2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var c1 : long ; c1 := 0 ;
     var c2 : long ; c2 := 0 ;
    var sum1 : long ; sum1 := 0 ;
    var sum2 : long ; sum2 := 0 ;
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < n do ( (     var tmp : long ; tmp := (st.next())->toInteger() ;
     sum1 := sum1+(tmp) ; 
     sum2 := sum2+(tmp) ; 
     if (i mod 2 = 0) then (     if (sum1 <= 0) then (     c1 := c1+(if sum1 < 0 then -(sum1) else sum1 endif + 1) ; 
     sum1 := 1 ) else skip ; 
     if (sum2 >= 0) then (     c2 := c2+(if sum2 < 0 then -(sum2) else sum2 endif + 1) ; 
     sum2 := -1 ) else skip ) else (     if (sum1 >= 0) then (     c1 := c1+(if sum1 < 0 then -(sum1) else sum1 endif + 1) ; 
     sum1 := -1 ) else skip ; 
     if (sum2 <= 0) then (     c2 := c2+(if sum2 < 0 then -(sum2) else sum2 endif + 1) ; 
     sum2 := 1 ) else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{c1, c2}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int mod=1_000_000_007 ;
    int N=Integer.parseInt(sc.next());
    int K=Integer.parseInt(sc.next());
    ArrayList<ArrayList<Integer>>edge=new ArrayList<ArrayList<Integer>>();
    for(int i=0 ; i<N ; i++){
      ArrayList<Integer>list=new ArrayList<Integer>();
      edge.add(list);
    }
    for(int i=0 ; i<N-1 ; i++){
      int a=Integer.parseInt(sc.next())-1 ;
      int b=Integer.parseInt(sc.next())-1 ;
      edge.get(a).add(b);
      edge.get(b).add(a);
    }
    int flag[]=new int[N];
    long ans=1L ;
    ArrayList<Integer>dfs=new ArrayList<Integer>();
    dfs.add(0);
    dfs.add(0);
    flag[0]=1 ;
    ans*=K ;
    while(dfs.size()>0){
      Integer i=dfs.remove(0);
      Integer depth=dfs.remove(0);
      int j ;
      if(depth==0){
        j=-1 ;
      }
      else {
        j=0 ;
      }
      for(Integer element : edge.get(i)){
        if(flag[element]==1){
          continue ;
        }
        else {
          flag[element]=1 ;
          ans=ans*(K-2-j)% mod ;
          j++;
          for(Integer element_2 : edge.get(element)){
            if(flag[element_2]==0){
              dfs.add(element);
              dfs.add(depth+1);
              break ;
            }
          }
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var mod : int ; mod := 1_000_000_007 ;
    var N : int ; N := (sc.getCurrent())->toInteger() ;
    var K : int ; K := (sc.getCurrent())->toInteger() ;
    var edge : Sequence(Sequence(int)) ; edge := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var list : Sequence(int) ; list := Sequence{} ;
     edge := edge->including(list) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     var a : int ; a := (sc.getCurrent())->toInteger() - 1 ;
     var b : int ; b := (sc.getCurrent())->toInteger() - 1 ;
     edge->at(a+1)->excludes(b) ; 
     edge->at(b+1)->excludes(a) )  ;     i := i + 1 ) ; 
    var flag : Sequence(int) ; flag := Integer.subrange(1,N)->collect(0) ;
    var ans : long ; ans := 1L ;
    var dfs : Sequence(int) ; dfs := Sequence{} ;
    dfs := dfs->including(0) ; 
    dfs := dfs->including(0) ; 
    flag[0+1] := 1 ; 
    ans := ans*(K) ; 
    while (dfs->size() > 0) do (     var i : int ; i := dfs->at(0+1) ;
     var depth : int ; depth := dfs->at(0+1) ;
    var j : int ;
    if (depth = 0) then (     j := -1 ) else (     j := 0 ) ;  
    for (element : edge->at(i+1)) do ( (     if (flag[element+1] = 1) then (     continue ) else (     flag[element+1] := 1 ; 
     ans := ans * (K - 2 - j) mod mod ; 
     j := j + 1 ; 
     for (element(     if (flag[element0+1] = 0) then (     dfs := dfs->including(element) ; 
     dfs := dfs->including(depth + 1) ; 
     break ) else skip ) : edge->at(element+1)) do ( (     if (flag[element0+1] = 0) then (     dfs := dfs->including(element) ; 
     dfs := dfs->including(depth + 1) ; 
     break ) else skip )  ) ) )  ) ; 
 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static int roo(int n){
    int ans=1 ;
    while(n>0){
      ans=ans*n ;
      n=n-1 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[][] array=new int[n][2];
    double sum=0 ;
    for(int i=0 ; i<n ; i++){
      array[i][0]=sc.nextInt();
      array[i][1]=sc.nextInt();
    }
    int k=1 ;
    for(int i=0 ; i<n-1 ; i++){
      for(int j=k ; j<n ; j++){
        sum+=Math.sqrt((array[i][0]-array[j][0])*(array[i][0]-array[j][0])+(array[i][1]-array[j][1])*(array[i][1]-array[j][1]));
      }
      k+=1 ;
    }
    sum=sum*roo(n-2)*(n-1)*2 ;
    System.out.println(sum/roo(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation roo( n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
     while (n > 0) do (     ans := ans * n ; 
     n := n - 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var array : Sequence(Sequence(int)) ; array := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
    var sum : double ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     array[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var k : int ; k := 1 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := k ; while j < n do ( (     sum := sum+(((array[i+1][0+1] - array[j+1][0+1]) * (array[i+1][0+1] - array[j+1][0+1]) + (array[i+1][1+1] - array[j+1][1+1]) * (array[i+1][1+1] - array[j+1][1+1]))->sqrt()) )  ;     j := j + 1 ) ; 
     k := k+(1) )  ;     i := i + 1 ) ; 
    sum := sum * roo(n - 2) * (n - 1) * 2 ; 
    OclFile["System.out"].println(sum / roo(n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[] sumA=new long[N+1];
    long[] sumB=new long[N+1];
    long countA=0,countB=0 ;
    for(int i=1 ; i<=N ; i++){
      long a=sc.nextLong();
      sumA[i]=a+sumA[i-1];
      sumB[i]=a+sumB[i-1];
      if(sumA[i]<=0 && i % 2!=0){
        countA+=1-sumA[i];
        sumA[i]+=1-sumA[i];
      }
      if(sumA[i]>=0 && i % 2==0){
        countA+=sumA[i]+1 ;
        sumA[i]+=(-1)-sumA[i];
      }
      if(sumB[i]<=0 && i % 2==0){
        countB+=1-sumB[i];
        sumB[i]+=1-sumB[i];
      }
      if(sumB[i]>=0 && i % 2!=0){
        countB+=sumB[i]+1 ;
        sumB[i]+=(-1)-sumB[i];
      }
    }
    System.out.println(Math.min(countA,countB));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var sumA : Sequence(long) ; sumA := Integer.subrange(1,N + 1)->collect(0) ;
    var sumB : Sequence(long) ; sumB := Integer.subrange(1,N + 1)->collect(0) ;
    var countA : long ; countA := 0 ;
    var countB : long ; countB := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     var a : long ; a := sc.getCurrent()->toLong() ;
     sumA[i+1] := a + sumA[i - 1+1] ; 
    sumB[i+1] := a + sumB[i - 1+1] ; 
    if (sumA[i+1] <= 0 & i mod 2 /= 0) then (     countA := countA+(1 - sumA[i+1]) ; 
     sumA[i+1] := sumA[i+1]+(1 - sumA[i+1]) ) else skip ; 
    if (sumA[i+1] >= 0 & i mod 2 = 0) then (     countA := countA+(sumA[i+1] + 1) ; 
     sumA[i+1] := sumA[i+1]+((-1) - sumA[i+1]) ) else skip ; 
    if (sumB[i+1] <= 0 & i mod 2 = 0) then (     countB := countB+(1 - sumB[i+1]) ; 
     sumB[i+1] := sumB[i+1]+(1 - sumB[i+1]) ) else skip ; 
    if (sumB[i+1] >= 0 & i mod 2 /= 0) then (     countB := countB+(sumB[i+1] + 1) ; 
     sumB[i+1] := sumB[i+1]+((-1) - sumB[i+1]) ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{countA, countB}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static final Scanner s=new Scanner(System.in);
  static int n ;
  public static void main(String[] __){
    n=s.nextInt();
    long a[]=new long[n];
    for(int i=0 ; i<n ; i++)a[i]=s.nextInt();
    if(a[0]!=0){
      long r1=solve(Arrays.copyOf(a,a.length));
      long r2=Math.abs(a[0])+1 ;
      a[0]=-a[0]/Math.abs(a[0]);
      r2+=solve(Arrays.copyOf(a,a.length));
      System.out.println(Math.min(r1,r2));
    }
    else {
      a[0]=1 ;
      long r1=1+solve(Arrays.copyOf(a,a.length));
      a[0]=-1 ;
      long r2=1+solve(Arrays.copyOf(a,a.length));
      System.out.println(Math.min(r1,r2));
    }
  }
  private static final long solve(long[] a){
    long sum[]=new long[n];
    sum[0]=a[0];
    long res=0 ;
    for(int i=1 ; i<n ; i++){
      sum[i]=a[i]+sum[i-1];
      if(sum[i-1]>0){
        long t=-sum[i-1]-1 ;
        if(a[i]>t){
          res+=a[i]-t ;
          a[i]=t ;
        }
      }
      else {
        long t=-sum[i-1]+1 ;
        if(a[i]<t){
          res+=t-a[i];
          a[i]=t ;
        }
      }
      sum[i]=a[i]+sum[i-1];
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   operation main( __ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := s.getCurrent()->toInteger() ; 
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
     if (a[0+1] /= 0) then (     var r1 : long ; r1 := solve(a.subrange(1,a->size())) ;
     var r2 : long ; r2 := if a[0+1] < 0 then -(a[0+1]) else a[0+1] endif + 1 ;
    a[0+1] := -a[0+1] / if a[0+1] < 0 then -(a[0+1]) else a[0+1] endif ; 
    r2 := r2+(solve(a.subrange(1,a->size()))) ; 
    OclFile["System.out"].println(Set{r1, r2}->min()) ; 
 ) else (     a[0+1] := 1 ; 
     var r1 : long ; r1 := 1 + solve(a.subrange(1,a->size())) ;
    a[0+1] := -1 ; 
    var r2 : long ; r2 := 1 + solve(a.subrange(1,a->size())) ;
    OclFile["System.out"].println(Set{r1, r2}->min()) ; 
 ) );
  static    operation solve( a : Sequence(long)) : long
  pre: true
  post: true
  activity: (     var sum : Sequence(long) ; sum := Integer.subrange(1,n)->collect(0) ;
     sum[0+1] := a[0+1] ; 
    var res : long ; res := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     sum[i+1] := a[i+1] + sum[i - 1+1] ; 
     if (sum[i - 1+1] > 0) then (     var t : long ; t := -sum[i - 1+1] - 1 ;
     if (a[i+1] > t) then (     res := res+(a[i+1] - t) ; 
     a[i+1] := t ) else skip ) else (     var t : long ; t := -sum[i - 1+1] + 1 ;
     if (a[i+1] < t) then (     res := res+(t - a[i+1]) ; 
     a[i+1] := t ) else skip ) ;  
     sum[i+1] := a[i+1] + sum[i - 1+1] )  ;     i := i + 1 ) ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner scn=new Scanner(System.in);
    long N=scn.nextLong();
    System.out.println(N % 2==0 ? N : 2*N);
    scn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := scn.getCurrent()->toLong() ;
     OclFile["System.out"].println(if N mod 2 = 0 then N else 2 * N endif) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws Exception {
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      int inputInt=Integer.parseInt(br.readLine());
      int multipleOfTwoAndN=inputInt ;
      while(true){
        if(multipleOfTwoAndN % 2==0 && multipleOfTwoAndN % inputInt==0){
          break ;
        }
        multipleOfTwoAndN+=inputInt ;
      }
      System.out.println(multipleOfTwoAndN);
    }
    catch(IOException | NumberFormatException e){
      e.printStackTrace();
      System.exit(0);
    }
    catch(final Exception e){
      e.printStackTrace();
      System.exit(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var inputInt : int ; inputInt := (br.readLine())->toInteger() ;
    var multipleOfTwoAndN : int ; multipleOfTwoAndN := inputInt ;
    while (true) do (     if (multipleOfTwoAndN mod 2 = 0 & multipleOfTwoAndN mod inputInt = 0) then (     break ) else skip ; 
     multipleOfTwoAndN := multipleOfTwoAndN+(inputInt) ) ; 
    OclFile["System.out"].println(multipleOfTwoAndN) ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
 OclProcess.exit(0) )
   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(0) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n % 2!=0)n*=2 ;
    System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n mod 2 /= 0) then     n := n*(2) ; else skip ; 
     OclFile["System.out"].println(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    String line=input.readLine();
    int n=Integer.parseInt(line);
    System.out.println((n % 2==0)? n : n*2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := input.readLine() ;
     var n : int ; n := (line)->toInteger() ;
     OclFile["System.out"].println(if (n mod 2 = 0) then n else n * 2 endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    if(a % 2==0){
      System.out.println(a);
    }
    else {
      System.out.println(a*2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (a mod 2 = 0) then (     OclFile["System.out"].println(a) ) else (     OclFile["System.out"].println(a * 2) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p034 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p034().run());
  }
  public String run(){
    int sum=0 ;
    for(int i=3 ; i<10000000 ; i++){
      if(i==factorialDigitSum(i))sum+=i ;
    }
    return Integer.toString(sum);
  }
  private static int[] FACTORIAL={
    1,1,2,6,24,120,720,5040,40320,362880 };
    private static int factorialDigitSum(int x){
      int sum=0 ;
      while(x!=0){
        sum+=FACTORIAL[x % 10];
        x/=10 ;
      }
      return sum ;
    }
  }

------------------------------------------------------------
OCL File:
---------
class p034 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p034.newp034().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 3 ; while i < 10000000 do ( (     if (i = factorialDigitSum(i)) then     sum := sum+(i) ; else skip )  ;     i := i + 1 ) ; 
     return ((sum) + "") );
  static   attribute FACTORIAL : Sequence(int) := Sequence{1,1,2,6,24,120,720,5040,40320,362880};
  static   operation factorialDigitSum( x : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (x /= 0) do (     sum := sum+(FACTORIAL[x mod 10+1]) ; 
     x := x/(10) ) ; 
     return sum );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B742 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int x=scanner.nextInt();
    int[] count=new int[1000001];
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      int num=scanner.nextInt();
      int num2=(int)(num ^ x);
      ans+=count[num2];
      count[num]++;
    }
    System.out.println(ans);
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B742 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var x : int ; x := scanner.getCurrent()->toInteger() ;
    var count : Sequence(int) ; count := Integer.subrange(1,1000001)->collect(0) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := scanner.getCurrent()->toInteger() ;
     var num2 : int ; num2 := (MathLib.bitwiseXor(num,x))->oclAsType(int) ;
     ans := ans+(count[num2+1]) ; 
     count[num+1] := count[num+1] + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
import java.util.Set ;
import java.util.StringTokenizer ;
public class Shokers {
  public static void main(String[] args)throws IOException {
    final BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    Set<Character>candidates=new HashSet<>();
    Set<Character>checked=new HashSet<>();
    int res=0 ;
    for(int i=0 ; i<n ; i++){
      final StringTokenizer st=new StringTokenizer(br.readLine());
      final String action=st.nextToken();
      final String word=st.nextToken();
      switch(action){
        case "?" : {
          if(candidates.size()==1 || checked.size()>='z'-'a'){
            res++;
            break ;
          }
        }
        case "." : {
          for(char c : word.toCharArray()){
            checked.add(c);
            candidates.remove(c);
          }
          break ;
        }
        case "!" : {
          if(candidates.size()==1 || checked.size()>='z'-'a'){
            res++;
            break ;
          }
          if(candidates.isEmpty()){
            for(char c : word.toCharArray()){
              if(! checked.contains(c)){
                candidates.add(c);
              }
            }
          }
          else {
            Set<Character>wordSet=new HashSet<>();
            for(Character c : word.toCharArray()){
              wordSet.add(c);
            }
            candidates.retainAll(wordSet);
          }
          break ;
        }
      }
    }
    if(res>0){
      res--;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Shokers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var candidates : Set(String) ; candidates := Set{} ;
    var checked : Set(String) ; checked := Set{} ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var action : String ; action := st.next() ;
     var word : String ; word := st.next() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (action) ; 
       if _switchval = "?" then
 (     if (candidates->size() = 1 or checked->size() >= ('z')->char2byte() - ('a')->char2byte()) then (     res := res + 1 ; 
     break ) else skip ) 
   else skip ;
       if _switchval = "." then
 (     for (c : word->characters()) do ( (     checked := checked->including(c) ; 
     candidates := candidates->excludingFirst(c) )  ) ; 
     break ) 
   else skip ;
       if _switchval = "!" then
 (     if (candidates->size() = 1 or checked->size() >= ('z')->char2byte() - ('a')->char2byte()) then (     res := res + 1 ; 
     break ) else skip ; 
     if (candidates->isEmpty()) then (     for (c : word->characters()) do ( (     if (not(checked->includes(c))) then (     candidates := candidates->including(c) ) else skip )  ) ) else (     var wordSet : Set(String) ; wordSet := Set{} ;
     for (c : word->characters()) do ( (     wordSet := wordSet->including(c) )  ) ; 
     candidates := candidates->intersection(wordSet) ) ;  
     break ) 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    if (res > 0) then (     res := res - 1 ) else skip ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getPairs(int a[]){
    int count=0 ;
    for(int i=0 ; i<a.length ; i++){
      for(int j=0 ; j<a.length ; j++){
        if(a[i]<a[j])count++;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int a[]={
      2,4,3,1 };
      System.out.println(getPairs(a));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getPairs( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < a->size() do ( (         var j : int ; j := 0 ; while j < a->size() do ( (     if (a[i+1] < a[j+1]) then     count := count + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,4,3,1} ;
     OclFile["System.out"].println(getPairs(a)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static String findNthNo(int n){
    String res="" ;
    while(n>=1){
      if((n & 1)==1){
        res=res+"3" ;
        n=(n-1)/2 ;
      }
      else {
        res=res+"5" ;
        n=(n-2)/2 ;
      }
    }
    StringBuilder sb=new StringBuilder(res);
    sb.reverse();
    return new String(sb);
  }
  public static void main(String args[]){
    int n=5 ;
    System.out.print(findNthNo(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNthNo( n : int) : String
  pre: true
  post: true
  activity: (     var res : String ; res := "" ;
     while (n >= 1) do (     if ((n & 1) = 1) then (     res := res + "3" ; 
     n := (n - 1) / 2 ) else (     res := res + "5" ; 
     n := (n - 2) / 2 ) ) ; 
    var sb : String ; sb := StringLib.newString(res) ;
    sb := sb->reverse() ; 
    return StringLib.newString(sb) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].print(findNthNo(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static String findNthNo(int n){
    String res="" ;
    while(n>=1){
      if((n & 1)==1){
        res=res+"4" ;
        n=(n-1)/2 ;
      }
      else {
        res=res+"7" ;
        n=(n-2)/2 ;
      }
    }
    StringBuilder sb=new StringBuilder(res);
    sb.reverse();
    return new String(sb);
  }
  public static void main(String args[]){
    int n=13 ;
    System.out.print(findNthNo(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNthNo( n : int) : String
  pre: true
  post: true
  activity: (     var res : String ; res := "" ;
     while (n >= 1) do (     if ((n & 1) = 1) then (     res := res + "4" ; 
     n := (n - 1) / 2 ) else (     res := res + "7" ; 
     n := (n - 2) / 2 ) ) ; 
    var sb : String ; sb := StringLib.newString(res) ;
    sb := sb->reverse() ; 
    return StringLib.newString(sb) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 13 ;
     OclFile["System.out"].print(findNthNo(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Mridul4 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr1=new int[n];
    int[] arr2=new int[n];
    int i=-1,sum1=0,sum2=0,odd=0 ;
    while(i!=n-1){
      i=i+1 ;
      arr1[i]=sc.nextInt();
      arr2[i]=sc.nextInt();
    }
    i=-1 ;
    while(i!=n-1){
      i=i+1 ;
      sum1=sum1+arr1[i];
      sum2=sum2+arr2[i];
    }
    if(sum1 % 2==0 && sum2 % 2==0){
      System.out.println(0);
    }
    else if(sum1 % 2==0 && sum2 % 2!=0){
      System.out.println(-1);
    }
    else if(sum1 % 2!=0 && sum2 % 2==0){
      System.out.println(-1);
    }
    else {
      i=-1 ;
      while(i!=n-1){
        i=i+1 ;
        if((arr1[i]+arr2[i])% 2!=0){
          odd=1 ;
          break ;
        }
      }
      if(odd==1){
        System.out.println(1);
      }
      else {
        System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mridul4 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,n)->collect(0) ;
    var i : int ; i := -1 ;
    var sum1 : int ; sum1 := 0 ;
    var sum2 : int ; sum2 := 0 ;
    var odd : int ; odd := 0 ;
    while (i /= n - 1) do (     i := i + 1 ; 
     arr1[i+1] := sc.getCurrent()->toInteger() ; 
     arr2[i+1] := sc.getCurrent()->toInteger() ) ; 
    i := -1 ; 
    while (i /= n - 1) do (     i := i + 1 ; 
     sum1 := sum1 + arr1[i+1] ; 
     sum2 := sum2 + arr2[i+1] ) ; 
    if (sum1 mod 2 = 0 & sum2 mod 2 = 0) then (     OclFile["System.out"].println(0) ) else     if (sum1 mod 2 = 0 & sum2 mod 2 /= 0) then (     OclFile["System.out"].println(-1) ) else     if (sum1 mod 2 /= 0 & sum2 mod 2 = 0) then (     OclFile["System.out"].println(-1) ) else (     i := -1 ; 
     while (i /= n - 1) do (     i := i + 1 ; 
     if ((arr1[i+1] + arr2[i+1]) mod 2 /= 0) then (     odd := 1 ; 
     break ) else skip ) ; 
     if (odd = 1) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(-1) ) ) ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    boolean goodPair=false ;
    int upper=0 ;
    int lower=0 ;
    for(int i=0 ; i<n ; i++){
      int u=sc.nextInt();
      int l=sc.nextInt();
      if(((u+l)& 1)!=0)goodPair=true ;
      upper+=u ;
      lower+=l ;
    }
    if((upper & 1)==0 &&(lower & 1)==0){
      System.out.println(0);
    }
    else if((upper & 1)!=0 &&(lower & 1)!=0 && goodPair){
      System.out.println(1);
    }
    else {
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var goodPair : boolean ; goodPair := false ;
    var upper : int ; upper := 0 ;
    var lower : int ; lower := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var u : int ; u := sc.getCurrent()->toInteger() ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    if (((u + l) & 1) /= 0) then     goodPair := true ; else skip ; 
    upper := upper+(u) ; 
    lower := lower+(l) ; 
 )  ;     i := i + 1 ) ; 
    if ((MathLib.bitwiseAnd(upper,1)) = 0 & (MathLib.bitwiseAnd(lower,1)) = 0) then (     OclFile["System.out"].println(0) ) else     if ((MathLib.bitwiseAnd(upper,1)) /= 0 & (MathLib.bitwiseAnd(lower,1)) /= 0 & goodPair) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(-1) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import java.io.*;
public class Hello {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int a[]=new int[n],b[]=new int[n];
    int upper=0,lower=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
      b[i]=in.nextInt();
      upper+=a[i];
      lower+=b[i];
    }
    if(upper % 2==0 && lower % 2==0){
      pw.println(0);
    }
    else {
      int ans=-1,count=0 ;
      boolean flag=false ;
      for(int i=0 ; i<n ; i++){
        upper-=a[i];
        lower-=b[i];
        upper+=b[i];
        lower+=a[i];
        count++;
        if(upper % 2==0 && lower % 2==0){
          flag=true ;
          ans=1 ;
          break ;
        }
      }
      pw.println(ans);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hello {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(void) ; b := Integer.subrange(1,n)->collect(0) ;
    var upper : int ; upper := 0 ;
    var lower : int ; lower := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     b[i+1] := in.getCurrent()->toInteger() ; 
     upper := upper+(a[i+1]) ; 
     lower := lower+(b[i+1]) )  ;     i := i + 1 ) ; 
    if (upper mod 2 = 0 & lower mod 2 = 0) then (     skip ) else (     var ans : int ; ans := -1 ;
    var count : int ; count := 0 ;
     var flag : boolean ; flag := false ;
         var i : int ; i := 0 ; while i < n do ( (     upper := upper-(a[i+1]) ; 
     lower := lower-(b[i+1]) ; 
    upper := upper+(b[i+1]) ; 
    lower := lower+(a[i+1]) ; 
    count := count + 1 ; 
    if (upper mod 2 = 0 & lower mod 2 = 0) then (     flag := true ; 
     ans := 1 ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.*;
import java.util.Scanner ;
public class Arr {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),total_oddU=0,total_oddL=0,exOddU=0,exOddL=0 ;
    for(int i=0 ; i<n ; i++){
      int x=in.nextInt(),y=in.nextInt();
      total_oddU+=x % 2 ;
      total_oddL+=y % 2 ;
      if(x % 2+y % 2==1){
        exOddU+=x % 2 ;
        exOddL+=y % 2 ;
      }
    }
    if(total_oddU % 2+total_oddL % 2==0)System.out.println("0");
    else if(total_oddU % 2+total_oddL % 2==2 && n>1 && exOddU+exOddL>0)System.out.println("1");
    else System.out.println("-1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Arr {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var total_oddU : int ; total_oddU := 0 ;
    var total_oddL : int ; total_oddL := 0 ;
    var exOddU : int ; exOddU := 0 ;
    var exOddL : int ; exOddL := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
    var y : int ; y := in.getCurrent()->toInteger() ;
     total_oddU := total_oddU+(x mod 2) ; 
     total_oddL := total_oddL+(y mod 2) ; 
     if (x mod 2 + y mod 2 = 1) then (     exOddU := exOddU+(x mod 2) ; 
     exOddL := exOddL+(y mod 2) ) else skip )  ;     i := i + 1 ) ; 
     if (total_oddU mod 2 + total_oddL mod 2 = 0) then     OclFile["System.out"].println("0") ; else     if (total_oddU mod 2 + total_oddL mod 2 = 2 & n > 1 & exOddU + exOddL > 0) then     OclFile["System.out"].println("1") else     OclFile["System.out"].println("-1") ; ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    int ctr=0 ;
    Scanner s=new Scanner(System.in);
    int sum1=0 ;
    int sum2=0 ;
    int n=s.nextInt();
    for(int i=0 ; i<n ; i++){
      int x=s.nextInt();
      int y=s.nextInt();
      sum1=sum1+x ;
      sum2=sum2+y ;
      if(x % 2!=0 && y % 2==0){
        ctr++;
      }
      else if(x % 2==0 && y % 2!=0){
        ctr++;
      }
    }
    if(sum1 % 2==0 && sum2 % 2==0){
      System.out.println("0");
    }
    else if(sum1 % 2!=0 && sum2 % 2!=0 && ctr!=0){
      System.out.println("1");
    }
    else {
      System.out.println("-1");
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ctr : int ; ctr := 0 ;
     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var sum1 : int ; sum1 := 0 ;
    var sum2 : int ; sum2 := 0 ;
    var n : int ; n := s.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := s.getCurrent()->toInteger() ;
     var y : int ; y := s.getCurrent()->toInteger() ;
    sum1 := sum1 + x ; 
    sum2 := sum2 + y ; 
    if (x mod 2 /= 0 & y mod 2 = 0) then (     ctr := ctr + 1 ) else     if (x mod 2 = 0 & y mod 2 /= 0) then (     ctr := ctr + 1 ) else skip ; ;  
 )  ;     i := i + 1 ) ; 
    if (sum1 mod 2 = 0 & sum2 mod 2 = 0) then (     OclFile["System.out"].println("0") ) else     if (sum1 mod 2 /= 0 & sum2 mod 2 /= 0 & ctr /= 0) then (     OclFile["System.out"].println("1") ) else (     OclFile["System.out"].println("-1") ) ;  ;  
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int k=sc.nextInt();
    sc.close();
    int n=s.length();
    long[][][] dp=new long[n+1][k+1][2];
    dp[0][0][0]=1 ;
    for(int i=0 ; i<n ; i++){
      int a=s.charAt(i)-'0' ;
      for(int j=0 ; j<=k ; j++){
        if(a==0){
          dp[i+1][j][0]+=dp[i][j][0];
          dp[i+1][j][1]+=dp[i][j][1];
        }
        else {
          dp[i+1][j][1]+=dp[i][j][0]+dp[i][j][1];
        }
        if(j<k){
          if(a!=0){
            dp[i+1][j+1][0]+=dp[i][j][0];
            dp[i+1][j+1][1]+=dp[i][j][0]*(a-1);
          }
          dp[i+1][j+1][1]+=dp[i][j][1]*9 ;
        }
      }
    }
    System.out.println(dp[n][k][0]+dp[n][k][1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    skip ; 
    var n : int ; n := s->size() ;
    var dp : Sequence(Sequence(Sequence(long))) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,k + 1)->collect(Integer.subrange(1,2)->collect(0))) ;
    dp[0+1][0+1][0+1] := 1 ; 
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := s->at(i+1) - ('0')->char2byte() ;
         var j : int ; j := 0 ; while j <= k do ( (     if (a = 0) then (     dp[i + 1+1][j+1][0+1] := dp[i + 1+1][j+1][0+1]+(dp[i+1][j+1][0+1]) ; 
     dp[i + 1+1][j+1][1+1] := dp[i + 1+1][j+1][1+1]+(dp[i+1][j+1][1+1]) ) else (     dp[i + 1+1][j+1][1+1] := dp[i + 1+1][j+1][1+1]+(dp[i+1][j+1][0+1] + dp[i+1][j+1][1+1]) ) ;  
     if (j < k) then (     if (a /= 0) then (     dp[i + 1+1][j + 1+1][0+1] := dp[i + 1+1][j + 1+1][0+1]+(dp[i+1][j+1][0+1]) ; 
     dp[i + 1+1][j + 1+1][1+1] := dp[i + 1+1][j + 1+1][1+1]+(dp[i+1][j+1][0+1] * (a - 1)) ) else skip ; 
     dp[i + 1+1][j + 1+1][1+1] := dp[i + 1+1][j + 1+1][1+1]+(dp[i+1][j+1][1+1] * 9) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[n+1][k+1][0+1] + dp[n+1][k+1][1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int K=sc.nextInt();
    long result=0 ;
    int len=s.length();
    int[][][] dp=new int[len+1][4][2];
    dp[0][0][0]=1 ;
    for(int i=0 ; i<len ; i++){
      int n=s.charAt(i)-'0' ;
      for(int j=0 ; j<4 ; j++){
        for(int d=0 ; d<10 ; d++){
          int ni=i+1 ;
          int nj=j ;
          if(d>0)nj++;
          if(nj>K)continue ;
          dp[ni][nj][1]+=dp[i][j][1];
          if(n==d){
            dp[ni][nj][0]+=dp[i][j][0];
          }
          else if(n>d){
            dp[ni][nj][1]+=dp[i][j][0];
          }
        }
      }
    }
    result=dp[len][K][0]+dp[len][K][1];
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var result : long ; result := 0 ;
    var len : int ; len := s->size() ;
    var dp : Sequence(Sequence(Sequence(int))) ; dp := Integer.subrange(1,len + 1)->collect(Integer.subrange(1,4)->collect(Integer.subrange(1,2)->collect(0))) ;
    dp[0+1][0+1][0+1] := 1 ; 
        var i : int ; i := 0 ; while i < len do ( (     var n : int ; n := s->at(i+1) - ('0')->char2byte() ;
         var j : int ; j := 0 ; while j < 4 do ( (         var d : int ; d := 0 ; while d < 10 do ( (     var ni : int ; ni := i + 1 ;
     var nj : int ; nj := j ;
    if (d > 0) then     nj := nj + 1 ; else skip ; 
    if (nj > K) then     continue else skip ; 
    dp[ni+1][nj+1][1+1] := dp[ni+1][nj+1][1+1]+(dp[i+1][j+1][1+1]) ; 
    if (n = d) then (     dp[ni+1][nj+1][0+1] := dp[ni+1][nj+1][0+1]+(dp[i+1][j+1][0+1]) ) else     if (n > d) then (     dp[ni+1][nj+1][1+1] := dp[ni+1][nj+1][1+1]+(dp[i+1][j+1][0+1]) ) else skip ; ;  
 )  ;     d := d + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    result := dp[len+1][K+1][0+1] + dp[len+1][K+1][1+1] ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String N=sc.next();
    int K=sc.nextInt();
    int digit=N.length();
    int[][][] dp=new int[digit+1][K+1][2];
    dp[0][0][0]=1 ;
    for(int i=1 ; i<=digit ; i++){
      int x=Character.getNumericValue(N.charAt(i-1));
      for(int j=0 ; j<=K ; j++){
        dp[i][j][1]=dp[i-1][j][1];
        if(j>0)dp[i][j][1]+=dp[i-1][j-1][1]*9 ;
        if(x==0)dp[i][j][0]=dp[i-1][j][0];
        else {
          dp[i][j][1]+=dp[i-1][j][0];
          if(j>0){
            dp[i][j][0]=dp[i-1][j-1][0];
            dp[i][j][1]+=dp[i-1][j-1][0]*(x-1);
          }
        }
      }
    }
    System.out.println(dp[digit][K][0]+dp[digit][K][1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : String ; N := sc.getCurrent() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var digit : int ; digit := N->size() ;
    var dp : Sequence(Sequence(Sequence(int))) ; dp := Integer.subrange(1,digit + 1)->collect(Integer.subrange(1,K + 1)->collect(Integer.subrange(1,2)->collect(0))) ;
    dp[0+1][0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= digit do ( (     var x : int ; x := ("" + N->at(i - 1+1))->toInteger() ;
         var j : int ; j := 0 ; while j <= K do ( (     dp[i+1][j+1][1+1] := dp[i - 1+1][j+1][1+1] ; 
     if (j > 0) then     dp[i+1][j+1][1+1] := dp[i+1][j+1][1+1]+(dp[i - 1+1][j - 1+1][1+1] * 9) ; else skip ; 
     if (x = 0) then     dp[i+1][j+1][0+1] := dp[i - 1+1][j+1][0+1] ; else (     dp[i+1][j+1][1+1] := dp[i+1][j+1][1+1]+(dp[i - 1+1][j+1][0+1]) ; 
     if (j > 0) then (     dp[i+1][j+1][0+1] := dp[i - 1+1][j - 1+1][0+1] ; 
     dp[i+1][j+1][1+1] := dp[i+1][j+1][1+1]+(dp[i - 1+1][j - 1+1][0+1] * (x - 1)) ) else skip ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[digit+1][K+1][0+1] + dp[digit+1][K+1][1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class pre5 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int n=obj.nextInt(),k=obj.nextInt();
    char num[]=obj.next().toCharArray();
    if(n==1 && k>0){
      out.println(0);
      return ;
    }
    for(int i=0 ; i<n && k>0 ; i++){
      if(i==0){
        if(num[i]=='1')continue ;
        num[i]='1' ;
        k--;
      }
      else {
        if(num[i]=='0')continue ;
        num[i]='0' ;
        k--;
      }
    }
    for(int i=0 ; i<n ; i++)out.print(num[i]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre5 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var n : int ; n := obj.nextInt() ;
    var k : int ; k := obj.nextInt() ;
    var num : Sequence(String) ; num := obj.next()->characters() ;
    if (n = 1 & k > 0) then (     out.println(0) ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < n & k > 0 do ( (     if (i = 0) then (     if (num[i+1] = '1') then     continue else skip ; 
     num[i+1] := '1' ; 
     k := k - 1 ) else (     if (num[i+1] = '0') then     continue else skip ; 
     num[i+1] := '0' ; 
     k := k - 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     out.print(num[i+1]) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    double x=in.nextDouble(),y=in.nextDouble();
    double a=y/(x*2),b=y ;
    List<position>S=new ArrayList<>();
    for(double i=0 ; i<=x*2 ; i+=2){
      position p=new position();
      p.x=i ;
      p.y=b-(a*i);
      S.add(p);
    }
    for(double i=0 ; i<=y ; i++){
      position p=new position();
      p.x=(b-i)/a ;
      p.y=i ;
      boolean jd=true ;
      for(int j=0 ; j<S.size(); j++){
        position c=S.get(j);
        if((p.x==c.x)||(p.y==c.y)){
          jd=false ;
          break ;
        }
      }
      if(jd)S.add(p);
    }
    System.out.println(S.size());
  }
}
class position {
  double x,y ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : double ; x := in.getCurrent()->toReal() ;
    var y : double ; y := in.getCurrent()->toReal() ;
    var a : double ; a := y / (x * 2) ;
    var b : double ; b := y ;
    var S : Sequence(position) ; S := Sequence{} ;
        var i : double ; i := 0 ; while i <= x * 2 do ( (     var p : position ; p := position.newposition() ;
     p.x := i ; 
     p.y := b - (a * i) ; 
     S := S->including(p) )  ;     i := i+(2) ) ; 
        var i : double ; i := 0 ; while i <= y do ( (     var p : position ; p := position.newposition() ;
     p.x := (b - i) / a ; 
    p.y := i ; 
    var jd : boolean ; jd := true ;
        var j : int ; j := 0 ; while j < S->size() do ( (     var c : position ; c := S->at(j+1) ;
     if ((p.x = c.x) or (p.y = c.y)) then (     jd := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (jd) then     S := S->including(p) ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(S->size()) ; 
 );
}
class position {
   attribute x : double;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PhoenixAndPuzzle {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    while(test-->0){
      long n=sc.nextLong();
      if(n==1){
        System.out.println("NO");
      }
      else {
        if(n % 2==0 && isSquare(n/2)){
          System.out.println("YES");
        }
        else if(n % 4==0 && isSquare(n/4)){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
    }
  }
  private static boolean isSquare(long l){
    long sqrt=(long)Math.sqrt(l);
    return sqrt*sqrt==l ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class PhoenixAndPuzzle {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : long ; n := sc.getCurrent()->toLong() ;
     if (n = 1) then (     OclFile["System.out"].println("NO") ) else (     if (n mod 2 = 0 & isSquare(n / 2)) then (     OclFile["System.out"].println("YES") ) else     if (n mod 4 = 0 & isSquare(n / 4)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  ) ) ;  ) );
  static   operation isSquare( l : long) : boolean
  pre: true
  post: true
  activity: (     var sqrt : long ; sqrt := (l)->sqrt()->oclAsType(long) ;
     return sqrt * sqrt = l );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String n=sc.next();
    int k=sc.nextInt();
    int digit=n.length();
    int[][][] dp=new int[digit+1][k+1][2];
    dp[0][0][0]=1 ;
    for(int i=1 ; i<=digit ; i++){
      int x=Character.getNumericValue(n.charAt(i-1));
      for(int j=0 ; j<=k ; j++){
        dp[i][j][1]=dp[i-1][j][1];
        if(j>0)dp[i][j][1]+=dp[i-1][j-1][1]*9 ;
        if(x==0)dp[i][j][0]=dp[i-1][j][0];
        else {
          dp[i][j][1]+=dp[i-1][j][0];
          if(j>0){
            dp[i][j][0]=dp[i-1][j-1][0];
            dp[i][j][1]+=dp[i-1][j-1][0]*(x-1);
          }
        }
      }
    }
    System.out.println(dp[digit][k][0]+dp[digit][k][1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : String ; n := sc.getCurrent() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var digit : int ; digit := n->size() ;
    var dp : Sequence(Sequence(Sequence(int))) ; dp := Integer.subrange(1,digit + 1)->collect(Integer.subrange(1,k + 1)->collect(Integer.subrange(1,2)->collect(0))) ;
    dp[0+1][0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= digit do ( (     var x : int ; x := ("" + n->at(i - 1+1))->toInteger() ;
         var j : int ; j := 0 ; while j <= k do ( (     dp[i+1][j+1][1+1] := dp[i - 1+1][j+1][1+1] ; 
     if (j > 0) then     dp[i+1][j+1][1+1] := dp[i+1][j+1][1+1]+(dp[i - 1+1][j - 1+1][1+1] * 9) ; else skip ; 
     if (x = 0) then     dp[i+1][j+1][0+1] := dp[i - 1+1][j+1][0+1] ; else (     dp[i+1][j+1][1+1] := dp[i+1][j+1][1+1]+(dp[i - 1+1][j+1][0+1]) ; 
     if (j > 0) then (     dp[i+1][j+1][0+1] := dp[i - 1+1][j - 1+1][0+1] ; 
     dp[i+1][j+1][1+1] := dp[i+1][j+1][1+1]+(dp[i - 1+1][j - 1+1][0+1] * (x - 1)) ) else skip ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[digit+1][k+1][0+1] + dp[digit+1][k+1][1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int sum=0 ;
  public static int n,l ;
  public static String str ;
  public static char ch[]=new char[105];
  public static void dfs(int k,int nonzero,boolean beyond,int tot){
    if(tot<=0)return ;
    if(nonzero==n){
      sum+=tot ;
      return ;
    }
    if(k<l-1){
      if(ch[k]>'0')dfs(k+1,nonzero,false,tot);
      else dfs(k+1,nonzero,beyond,tot);
      if(ch[k]>'0'){
        dfs(k+1,nonzero+1,false,tot*(ch[k]-'0'-1));
        dfs(k+1,nonzero+1,beyond,tot);
      }
      dfs(k+1,nonzero+1,true,tot*(9-(ch[k]-'0')));
    }
    else {
      if(nonzero==n-1){
        if(beyond==false)sum+=tot*(ch[k]-'0');
        else sum+=tot*((ch[k]-'0')-1);
      }
    }
  }
  public static void main(String args[])throws Exception {
    Scanner cin=new Scanner(System.in);
    str=cin.next();
    n=cin.nextInt();
    l=str.length();
    for(int i=0 ; i<l ; ++i){
      ch[i]=str.charAt(l-i-1);
    }
    dfs(0,0,false,1);
    System.out.println(sum);
    cin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sum : int := 0;
  static   attribute n : int;
  static   attribute str : String;
  static   attribute ch : String := Integer.subrange(1,105)->collect(0);
  static   operation dfs( k : int, nonzero : int, beyond : boolean, tot : int) : void
  pre: true
  post: true
  activity: (     if (tot <= 0) then     return else skip ; 
     if (nonzero = n) then (     sum := sum+(tot) ; 
     return ) else skip ; 
     if (k < l - 1) then (     if (ch[k+1] > '0') then     execute dfs(k + 1, nonzero, false, tot) else     execute dfs(k + 1, nonzero, beyond, tot) ; ;  
     if (ch[k+1] > '0') then (     execute dfs(k + 1, nonzero + 1, false, tot * (ch[k+1] - ('0')->char2byte() - 1)) ; 
     execute dfs(k + 1, nonzero + 1, beyond, tot) ) else skip ; 
     execute dfs(k + 1, nonzero + 1, true, tot * (9 - (ch[k+1] - ('0')->char2byte()))) ) else (     if (nonzero = n - 1) then (     if (beyond = false) then     sum := sum+(tot * (ch[k+1] - ('0')->char2byte())) ; else     sum := sum+(tot * ((ch[k+1] - ('0')->char2byte()) - 1)) ; ) else skip ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     str := cin.getCurrent() ; 
    n := cin.getCurrent()->toInteger() ; 
    l := str->size() ; 
        var i : int ; i := 0 ; while i < l do ( (     ch[i+1] := str->at(l - i - 1+1) )  ;     i := i + 1 ) ; 
    execute dfs(0, 0, false, 1) ; 
    OclFile["System.out"].println(sum) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class code {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int t=sc.nextInt();
    while(t-->0){
      solve();
    }
  }
  static void solve(){
    int n=sc.nextInt();
    int k=sc.nextInt();
    int b1=0 ;
    int b2=1 ;
    for(int i=2 ; i<=n ; i++){
      if(k<=i-1){
        b2=i ;
        b1=k ;
        break ;
      }
      k-=i-1 ;
    }
    StringBuilder a=new StringBuilder();
    for(int i=1 ; i<=n ; i++){
      if(i==b1 || i==b2)a.append('b');
      else a.append('a');
    }
    System.out.println(a.reverse());
  }
}
------------------------------------------------------------
OCL File:
---------
 class code {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var b1 : int ; b1 := 0 ;
    var b2 : int ; b2 := 1 ;
        var i : int ; i := 2 ; while i <= n do ( (     if (k <= i - 1) then (     b2 := i ; 
     b1 := k ; 
     break ) else skip ; 
     k := k-(i - 1) )  ;     i := i + 1 ) ; 
    var a : String ; a := StringLib.newString() ;
        var i : int ; i := 1 ; while i <= n do ( (     if (i = b1 or i = b2) then     a := a + StringLib.newString('b') ; else     a := a + StringLib.newString('a') ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a->reverse()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class vfe {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      int k=in.nextInt();
      int sum=0 ;
      int id1=0 ;
      int id2=0 ;
      int arr[]=new int[n];
      for(int i=1 ; sum<k ; i++){
        sum+=i ;
        id1=i ;
      }
      id2=id1-1 ;
      id2-=(sum-k);
      arr[id1]=1 ;
      arr[id2]=1 ;
      for(int i=n-1 ; i>=0 ; i--){
        if(arr[i]==1){
          System.out.print('b');
        }
        else {
          System.out.print('a');
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class vfe {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var id1 : int ; id1 := 0 ;
    var id2 : int ; id2 := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 1 ; while sum < k do ( (     sum := sum+(i) ; 
     id1 := i )  ;     i := i + 1 ) ; 
    id2 := id1 - 1 ; 
    id2 := id2-((sum - k)) ; 
    arr[id1+1] := 1 ; 
    arr[id2+1] := 1 ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (arr[i+1] = 1) then (     OclFile["System.out"].print('b') ) else (     OclFile["System.out"].print('a') ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class ProblemA {
  static long k ;
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int test=Integer.parseInt(br.readLine());
    while(test-->0){
      String line[]=br.readLine().split(" ");
      int n=Integer.parseInt(line[0]);
      int k=Integer.parseInt(line[1]);
      char c[]=new char[n];
      Arrays.fill(c,'a');
      long val=0 ;
      for(int i=n-2 ; i>=0 ; i--){
        val=n-i ;
        val=(val*(val-1))/2 ;
        if(val>=k){
          c[i]='b' ;
          c[(int)(i+1+(val-k))]='b' ;
          break ;
        }
      }
      for(char it : c)sb.append(it);
      sb.append("\n");
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
  static   attribute k : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var test : int ; test := (br.readLine())->toInteger() ;
        while (test > 0) do (        test := test - 1 ;     skip ; (     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
     var n : int ; n := (line[0+1])->toInteger() ;
    var k : int ; k := (line[1+1])->toInteger() ;
    var c : Sequence(String) ; c := Integer.subrange(1,n)->collect(0) ;
    c := c->collect('a') ; 
    var val : long ; val := 0 ;
        var i : int ; i := (n)->char2byte() - 2 ; while i >= 0 do ( (     val := (n)->char2byte() - i ; 
     val := (val * ((val)->char2byte() - 1)) / 2 ; 
     if (val >= k) then (     c[i+1] := 'b' ; 
     c[(i + 1 + ((val)->char2byte() - k))->oclAsType(int)+1] := 'b' ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    for (it : c) do (     sb := sb + StringLib.newString(it) ;  ) ; 
    sb := sb + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class CF1328B {
  public static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int test=scanner.nextInt();
    while(test-->0){
      int n=scanner.nextInt();
      char[] arr=new char[n];
      Arrays.fill(arr,'a');
      int k=scanner.nextInt();
      int leftBIndex=n-2 ;
      for(int i=n-1 ; i>=0 ; i--){
        if(k<=n-i){
          int rightBIndex=n-k ;
          arr[leftBIndex]='b' ;
          arr[rightBIndex]='b' ;
          break ;
        }
        k=k-(n-i);
        leftBIndex--;
      }
      System.out.println(new String(arr));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF1328B {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var test : int ; test := scanner.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var arr : Sequence(String) ; arr := Integer.subrange(1,n)->collect(0) ;
    arr := arr->collect('a') ; 
    var k : int ; k := scanner.getCurrent()->toInteger() ;
    var leftBIndex : int ; leftBIndex := n - 2 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (k <= n - i) then (     var rightBIndex : int ; rightBIndex := n - k ;
     arr[leftBIndex+1] := 'b' ; 
     arr[rightBIndex+1] := 'b' ; 
     break ) else skip ; 
     k := k - (n - i) ; 
     leftBIndex := leftBIndex - 1 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(StringLib.newString(arr)) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    ArrayList<Integer>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      if(x>=a){
        list.add(x);
      }
      else {
        break ;
      }
    }
    int count=0 ;
    if(n-list.size()<m){
      for(int i=list.size()-1 ; i>=0 ; i--){
        if(list.get(i)<=b){
          count++;
        }
        else {
          break ;
        }
      }
    }
    System.out.println(list.size()-count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x >= a) then (     list := list->including(x) ) else (     break ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    if (n - list->size() < m) then (         var i : int ; i := list->size() - 1 ; while i >= 0 do ( (     if (list->at(i+1) <= b) then (     count := count + 1 ) else (     break ) )  ;     i := i - 1 ) ) else skip ; 
    OclFile["System.out"].println(list->size() - count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long mod=(long)(1e9+7);
  static long factorial(long n,long p){
    long res=1 ;
    for(int i=2 ; i<=n ; i++)res=(res*i)% p ;
    return res ;
  }
  static long power(long x,long y,long p){
    long res=1 ;
    x=x % p ;
    while(y>0){
      if((y & 1)==1)res=(res*x)% p ;
      y=y>>1 ;
      x=(x*x)% p ;
    }
    return res ;
  }
  static long modInverse(long n,long p){
    return power(n,p-2,p);
  }
  static long nCrModP(long n,long r,long p){
    if(r==0)return 1 ;
    long fac[]=new long[(int)n+1];
    fac[0]=1 ;
    for(int i=1 ; i<=n ; i++)fac[i]=fac[i-1]*i % p ;
    return(fac[(int)n]*modInverse(fac[(int)r],p)% p*modInverse(fac[(int)n-(int)r],p)% p)% p ;
  }
  static long countArrangements(long n,long k,long p){
    return(factorial(n,p)*nCrModP(k,n,p))% p ;
  }
  public static void main(String[] args){
    long N=5,K=8 ;
    System.out.println(countArrangements(N,K,mod));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute mod : long := (1e9 + 7)->oclAsType(long);
  static   operation factorial( n : long, p : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : int ; i := 2 ; while i <= n do (     res := (res * i) mod p ;  ;     i := i + 1 ) ; 
     return res );
  static   operation power( x : long, y : long, p : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     x := x mod p ; 
     while (y > 0) do (     if ((y & 1) = 1) then     res := (res * x) mod p ; else skip ; 
     y := (y/(2->pow(1)))->oclAsType(long) ; 
     x := (x * x) mod p ) ; 
     return res );
  static   operation modInverse( n : long, p : long) : long
  pre: true
  post: true
  activity: (     return power(n, p - 2, p) );
  static   operation nCrModP( n : long, r : long, p : long) : long
  pre: true
  post: true
  activity: (     if (r = 0) then     return 1 else skip ; 
     var fac : Sequence(long) ; fac := Integer.subrange(1,n->oclAsType(int) + 1)->collect(0) ;
    fac[0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do (     fac[i+1] := fac[i - 1+1] * i mod p ;  ;     i := i + 1 ) ; 
    return (fac[n->oclAsType(int)+1] * modInverse(fac[r->oclAsType(int)+1], p) mod p * modInverse(fac[n->oclAsType(int) - r->oclAsType(int)+1], p) mod p) mod p 
 );
  static   operation countArrangements( n : long, k : long, p : long) : long
  pre: true
  post: true
  activity: (     return (factorial(n, p) * nCrModP(k, n, p)) mod p );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := 5 ;
    var K : long ; K := 8 ;
     OclFile["System.out"].println(countArrangements(N, K, mod)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static int guess=1 ;
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int len=in.nextInt();
    int k=in.nextInt();
    String s="1" ;
    String str=in.next();
    char ans[]=str.toCharArray();
    if(k==1 && len==1){
      pw.println(0);
    }
    else {
      if(str.charAt(0)!='1'){
        if(k>=1){
          ans[0]='1' ;
          k--;
        }
      }
      for(int i=1 ; i<str.length(); i++){
        if(ans[i]!='0'){
          if(k>=1){
            ans[i]='0' ;
            k--;
          }
        }
      }
      for(char a : ans){
        pw.print(a);
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute guess : int := 1;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var len : int ; len := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var s : String ; s := "1" ;
    var str : String ; str := in.getCurrent() ;
    var ans : Sequence(String) ; ans := str->characters() ;
    if (k = 1 & len = 1) then (     skip ) else (     if (str->at(0+1) /= '1') then (     if (k >= 1) then (     ans[0+1] := '1' ; 
     k := k - 1 ) else skip ) else skip ; 
         var i : int ; i := 1 ; while i < str->size() do ( (     if (ans[i+1] /= '0') then (     if (k >= 1) then (     ans[i+1] := '0' ; 
     k := k - 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
     for (a : ans) do ( (     skip )  ) ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class MinimumCostPath {
  private static int min(int x,int y,int z){
    if(x<y)return(x<z)? x : z ;
    else return(y<z)? y : z ;
  }
  private static int minCost(int cost[][],int m,int n){
    int i,j ;
    int tc[][]=new int[m+1][n+1];
    tc[0][0]=cost[0][0];
    for(i=1 ; i<=m ; i++)tc[i][0]=tc[i-1][0]+cost[i][0];
    for(j=1 ; j<=n ; j++)tc[0][j]=tc[0][j-1]+cost[0][j];
    for(i=1 ; i<=m ; i++)for(j=1 ; j<=n ; j++)tc[i][j]=min(tc[i-1][j-1],tc[i-1][j],tc[i][j-1])+cost[i][j];
    return tc[m][n];
  }
  public static void main(String args[]){
    int cost[][]={
      {
        1,2,3 },{
          4,8,2 },{
            1,5,3 }
          };
          System.out.println(minCost(cost,2,2));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class MinimumCostPath {
  static   operation min( x : int, y : int, z : int) : int
  pre: true
  post: true
  activity: (     if (x < y) then     return if (x < z) then x else z endif else     return if (y < z) then y else z endif );
  static   operation minCost( cost : Sequence(Sequence(int)), m : int, n : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var tc : Sequence(Sequence(int)) ; tc := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
    tc[0+1][0+1] := cost[0+1][0+1] ; 
        i := 1 ; while i <= m do (     tc[i+1][0+1] := tc[i - 1+1][0+1] + cost[i+1][0+1] ;  ;     i := i + 1 ) ; 
        j := 1 ; while j <= n do (     tc[0+1][j+1] := tc[0+1][j - 1+1] + cost[0+1][j+1] ;  ;     j := j + 1 ) ; 
        i := 1 ; while i <= m do (         j := 1 ; while j <= n do (     tc[i+1][j+1] := Set{tc[i - 1+1][j - 1+1], tc[i - 1+1][j+1], tc[i+1][j - 1+1]}->min() + cost[i+1][j+1] ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return tc[m+1][n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cost : Sequence(Sequence(int)) ; cost := Sequence{Sequence{1,2,3},Sequence{4,8,2},Sequence{1,5,3}} ;
     OclFile["System.out"].println(minCost(cost, 2, 2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=sc.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
    }
    for(int i=0 ; i<n ; i++){
      for(int j=1 ; j<n ; j++){
        if(((j % 2==0)&&(a[j]>a[j-1]))||((j % 2==1)&&(a[j]<a[j-1]))){
          long tmp=a[j];
          a[j]=a[j-1];
          a[j-1]=tmp ;
        }
      }
    }
    boolean flag=true ;
    for(int j=1 ; j<n ; j++){
      if(((j % 2==0)&&(a[j]>a[j-1]))||((j % 2==1)&&(a[j]<a[j-1]))){
        pw.println("impossible");
        flag=false ;
      }
    }
    if(flag){
      for(int i=0 ; i<n-1 ; i++){
        pw.print(a[i]+" ");
      }
      pw.print(a[n-1]);
    }
    sc.close();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 1 ; while j < n do ( (     if (((j mod 2 = 0) & (a[j+1] > a[j - 1+1])) or ((j mod 2 = 1) & (a[j+1] < a[j - 1+1]))) then (     var tmp : long ; tmp := a[j+1] ;
     a[j+1] := a[j - 1+1] ; 
     a[j - 1+1] := tmp ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := true ;
        var j : int ; j := 1 ; while j < n do ( (     if (((j mod 2 = 0) & (a[j+1] > a[j - 1+1])) or ((j mod 2 = 1) & (a[j+1] < a[j - 1+1]))) then (     skip ; 
     flag := false ) else skip )  ;     j := j + 1 ) ; 
    if (flag) then (         var i : int ; i := 0 ; while i < n - 1 do ( (     skip )  ;     i := i + 1 ) ; 
     skip ) else skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class _28 {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    while(t-->0){
      int n=input.nextInt();
      double num=Math.sqrt(n/2.0);
      double num1=Math.sqrt(n/4.0);
      if(Math.round(num)==num || Math.round(num1)==num1){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := input.getCurrent()->toInteger() ;
     var num : double ; num := (n / 2.0)->sqrt() ;
     var num1 : double ; num1 := (n / 4.0)->sqrt() ;
     if ((num)->round() = num or (num1)->round() = num1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  ) );
}
8 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := input.getCurrent()->toInteger() ;
     var num : double ; num := (n / 2.0)->sqrt() ;
     var num1 : double ; num1 := (n / 4.0)->sqrt() ;
     if ((num)->round() = num or (num1)->round() = num1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int sumArr(int arr[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=arr[i];
    return sum ;
  }
  static int sumModArr(int arr[],int n){
    for(int i=0 ; i<n-1 ; i++){
      int subSum=0 ;
      for(int j=i+1 ; j<n ; j++){
        subSum+=arr[j];
      }
      arr[i]-=subSum ;
    }
    return sumArr(arr,n);
  }
  public static void main(String[] args){
    int arr[]={
      40,25,12,10 };
      int n=arr.length ;
      System.out.println(sumModArr(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumArr( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation sumModArr( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n - 1 do ( (     var subSum : int ; subSum := 0 ;
         var j : int ; j := i + 1 ; while j < n do ( (     subSum := subSum+(arr[j+1]) )  ;     j := j + 1 ) ; 
     arr[i+1] := arr[i+1]-(subSum) )  ;     i := i + 1 ) ; 
     return sumArr(arr, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{40,25,12,10} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(sumModArr(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int[] numberOfLines(String S,int[] widths){
    if(S.isEmpty())return new int[] {
      0,0 };
      int lines=1,width=0 ;
      for(char character : S.toCharArray()){
        int w=widths[character-'a'];
        width+=w ;
        if(width>=10){
          lines++;
          width=w ;
        }
      }
      return new int[] {
        lines,width };
      }
      public static void main(String[] args){
        String S="bbbcccdddaa" ;
        int widths[]={
          4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 };
          int[] ans=numberOfLines(S,widths);
          System.out.print(ans[0]+" "+ans[1]+"\n");
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation numberOfLines( S : String, widths : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     if (S->isEmpty()) then     return Sequence{0,0} else skip ; 
     var lines : int ; lines := 1 ;
    var width : int ; width := 0 ;
     for (character : S->characters()) do ( (     var w : int ; w := widths[character - ('a')->char2byte()+1] ;
     width := width+(w) ; 
     if (width >= 10) then (     lines := lines + 1 ; 
     width := w ) else skip )  ) ; 
     return Sequence{lines,width} );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := "bbbcccdddaa" ;
     var widths : Sequence(int) ; widths := Sequence{4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1} ;
     var ans : Sequence(int) ; ans := numberOfLines(S, widths) ;
     OclFile["System.out"].print(ans[0+1] + " " + ans[1+1] + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean checkPair(int arr[],int n){
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=arr[i];
    }
    if(sum % 2!=0){
      return false ;
    }
    sum=sum/2 ;
    HashSet<Integer>s=new HashSet<Integer>();
    for(int i=0 ; i<n ; i++){
      int val=sum-arr[i];
      if(s.contains(val)&& val==(int)s.toArray()[s.size()-1]){
        System.out.printf("Pair elements are %d and %d\n",arr[i],val);
        return true ;
      }
      s.add(arr[i]);
    }
    return false ;
  }
  public static void main(String[] args){
    int arr[]={
      2,11,5,1,4,7 };
      int n=arr.length ;
      if(checkPair(arr,n)==false){
        System.out.printf("No pair found");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkPair( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    if (sum mod 2 /= 0) then (     return false ) else skip ; 
    sum := sum / 2 ; 
    var s : Set(int) ; s := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     var val : int ; val := sum - arr[i+1] ;
     if (s->includes(val) & val = s->asSequence()[s->size() - 1+1]->oclAsType(int)) then (     OclFile["System.out"].printf("Pair elements are %d and %d\n", arr[i+1], val) ; 
     return true ) else skip ; 
     s := s->including(arr[i+1]) )  ;     i := i + 1 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,11,5,1,4,7} ;
     var n : int ; n := arr->size() ;
     if (checkPair(arr, n) = false) then (     OclFile["System.out"].printf("No pair found") ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int difference(int n){
    int S,res ;
    S=(n*(n+1))/2 ;
    res=S*(S-1);
    return res ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.print(difference(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation difference( n : int) : int
  pre: true
  post: true
  activity: (     var S : int ;
    var res : int ;
     S := (n * (n + 1)) / 2 ; 
     res := S * (S - 1) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].print(difference(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MAX=500 ;
  static int size=1 ;
  static void factorial(int[] prevFact,int prev,int n){
    for(int x=prev+1 ; x<=n ; x++)size=multiply(x,prevFact,size);
    for(int i=size-1 ; i>=0 ; i--)System.out.print(prevFact[i]);
    System.out.print(" ");
  }
  static void printfibFactorials(int limit){
    if(limit<1)return ;
    int a=1,b=1,c=2 ;
    System.out.print(a+" "+b+" ");
    int[] prevFact=new int[MAX];
    prevFact[0]=1 ;
    while(c<limit){
      factorial(prevFact,b,c);
      a=b ;
      b=c ;
      c=a+b ;
    }
  }
  static int multiply(int x,int[] prevFact,int size){
    int carry=0 ;
    for(int i=0 ; i<size ; i++){
      int prod=prevFact[i]*x+carry ;
      prevFact[i]=prod % 10 ;
      carry=prod/10 ;
    }
    while(carry!=0){
      prevFact[size]=carry % 10 ;
      carry=carry/10 ;
      size++;
    }
    return size ;
  }
  public static void main(String args[]){
    int limit=20 ;
    printfibFactorials(limit);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 500;
  static   attribute size : int := 1;
  static   operation factorial( prevFact : Sequence(int), prev : int, n : int) : void
  pre: true
  post: true
  activity: (         var x : int ; x := prev + 1 ; while x <= n do (     size := multiply(x, prevFact, size) ;  ;     x := x + 1 ) ; 
         var i : int ; i := size - 1 ; while i >= 0 do (     OclFile["System.out"].print(prevFact[i+1]) ;  ;     i := i - 1 ) ; 
     OclFile["System.out"].print(" ") );
  static   operation printfibFactorials( limit : int) : void
  pre: true
  post: true
  activity: (     if (limit < 1) then     return else skip ; 
     var a : int ; a := 1 ;
    var b : int ; b := 1 ;
    var c : int ; c := 2 ;
    OclFile["System.out"].print(a + " " + b + " ") ; 
    var prevFact : Sequence(int) ; prevFact := Integer.subrange(1,MAX)->collect(0) ;
    prevFact[0+1] := 1 ; 
    while (c < limit) do (     execute factorial(prevFact, b, c) ; 
     a := b ; 
     b := c ; 
     c := a + b ) ; 
 );
  static   operation multiply( x : int, prevFact : Sequence(int), size : int) : int
  pre: true
  post: true
  activity: (     var carry : int ; carry := 0 ;
         var i : int ; i := 0 ; while i < size do ( (     var prod : int ; prod := prevFact[i+1] * x + carry ;
     prevFact[i+1] := prod mod 10 ; 
     carry := prod / 10 )  ;     i := i + 1 ) ; 
     while (carry /= 0) do (     prevFact[size+1] := carry mod 10 ; 
     carry := carry / 10 ; 
     size := size + 1 ) ; 
     return size );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var limit : int ; limit := 20 ;
     execute printfibFactorials(limit) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isKAlternating(String s,int k){
    if(s.length()<k)return false ;
    int checker=0 ;
    for(int i=0 ; i<k ; i++){
      int bitAtIndex=s.charAt(i)-'a' ;
      if((checker &(1<<bitAtIndex))>0){
        return false ;
      }
      checker=checker |(1<<bitAtIndex);
    }
    for(int i=k ; i<s.length(); i++)if(s.charAt(i-k)!=s.charAt(i))return false ;
    return true ;
  }
  public static void main(String[] args){
    String str="acdeac" ;
    int K=4 ;
    if(isKAlternating(str,K))System.out.print("Yes"+"\n");
    else System.out.print("No"+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isKAlternating( s : String, k : int) : boolean
  pre: true
  post: true
  activity: (     if (s->size() < k) then     return false else skip ; 
     var checker : int ; checker := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     var bitAtIndex : int ; bitAtIndex := s->at(i+1) - ('a')->char2byte() ;
     if ((MathLib.bitwiseAnd(checker,((1*(2->pow(bitAtIndex)))->oclAsType(long)))) > 0) then (     return false ) else skip ; 
     checker := MathLib.bitwiseOr(checker,((1*(2->pow(bitAtIndex)))->oclAsType(long))) )  ;     i := i + 1 ) ; 
        var i : int ; i := k ; while i < s->size() do (     if (s->at(i - k+1) /= s->at(i+1)) then     return false else skip ;  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "acdeac" ;
     var K : int ; K := 4 ;
     if (isKAlternating(str, K)) then     OclFile["System.out"].print("Yes" + "\n") ; else     OclFile["System.out"].print("No" + "\n") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    C solver=new C();
    solver.solve(1,in,out);
    out.close();
  }
  static class C {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int[] arr=ScannerUtils.readIntArray(in,n);
      Arrays.sort(arr);
      if(n % 2==0){
        int next=1 ;
        for(int i=0 ; i<arr.length ; i+=2){
          if(arr[i]==next && arr[i+1]==next){
            next+=2 ;
          }
          else {
            out.println(0);
            return ;
          }
        }
      }
      else {
        if(arr[0]!=0){
          out.println(0);
          return ;
        }
        int next=2 ;
        for(int i=1 ; i<arr.length ; i+=2){
          if(arr[i]==next && arr[i+1]==next){
            next+=2 ;
          }
          else {
            out.println(0);
            return ;
          }
        }
      }
      int pow2=n/2 ;
      int res=1 ;
      while(pow2-->0){
        res=(res*2)% 1_000_000_007 ;
      }
      out.println(res);
    }
  }
  static class ScannerUtils {
    public static int[] readIntArray(Scanner in,int size){
      int[] array=new int[size];
      for(int i=0 ; i<size ; i++){
        array[i]=in.nextInt();
      }
      return array ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : C ; solver := C.newC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class C {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := ScannerUtils.readIntArray(in, n) ;
    arr := arr->sort() ; 
    if (n mod 2 = 0) then (     var next : int ; next := 1 ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = next & arr[i + 1+1] = next) then (     next := next+(2) ) else (     skip ; 
     return ) )  ;     i := i+(2) ) ) else (     if (arr[0+1] /= 0) then (     skip ; 
     return ) else skip ; 
     var next : int ; next := 2 ;
         var i : int ; i := 1 ; while i < arr->size() do ( (     if (arr[i+1] = next & arr[i + 1+1] = next) then (     next := next+(2) ) else (     skip ; 
     return ) )  ;     i := i+(2) ) ) ;  
    var pow2 : int ; pow2 := n / 2 ;
    var res : int ; res := 1 ;
        while (pow2 > 0) do (        pow2 := pow2 - 1 ;     skip ; (     res := (res * 2) mod 1_000_000_007 ) ;  ) ;  
    skip ; 
 );
}
  static class ScannerUtils {
  static   operation readIntArray( in : OclFile, size : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < size do ( (     array[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return array );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class main1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int arr[][]=new int[4][4];
    for(int i=0 ; i<4 ; i++){
      for(int j=0 ; j<4 ; j++){
        arr[i][j]=sc.nextInt();
      }
    }
    if(arr[0][3]==1){
      if(arr[0][1]==1 || arr[0][2]==1 || arr[0][0]==1 || arr[1][0]==1 || arr[2][1]==1 || arr[3][2]==1){
        System.out.println("YES");
        return ;
      }
    }
    if(arr[1][3]==1){
      if(arr[1][1]==1 || arr[1][2]==1 || arr[1][0]==1 || arr[2][0]==1 || arr[3][1]==1 || arr[0][2]==1){
        System.out.println("YES");
        return ;
      }
    }
    if(arr[2][3]==1){
      if(arr[2][1]==1 || arr[2][2]==1 || arr[2][0]==1 || arr[3][0]==1 || arr[0][1]==1 || arr[1][2]==1){
        System.out.println("YES");
        return ;
      }
    }
    if(arr[3][3]==1){
      if(arr[3][1]==1 || arr[3][2]==1 || arr[3][0]==1 || arr[0][0]==1 || arr[1][1]==1 || arr[2][2]==1){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class main1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,4)->collect(Integer.subrange(1,4)->collect(0)) ;
        var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < 4 do ( (     arr[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (arr[0+1][3+1] = 1) then (     if (arr[0+1][1+1] = 1 or arr[0+1][2+1] = 1 or arr[0+1][0+1] = 1 or arr[1+1][0+1] = 1 or arr[2+1][1+1] = 1 or arr[3+1][2+1] = 1) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    if (arr[1+1][3+1] = 1) then (     if (arr[1+1][1+1] = 1 or arr[1+1][2+1] = 1 or arr[1+1][0+1] = 1 or arr[2+1][0+1] = 1 or arr[3+1][1+1] = 1 or arr[0+1][2+1] = 1) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    if (arr[2+1][3+1] = 1) then (     if (arr[2+1][1+1] = 1 or arr[2+1][2+1] = 1 or arr[2+1][0+1] = 1 or arr[3+1][0+1] = 1 or arr[0+1][1+1] = 1 or arr[1+1][2+1] = 1) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    if (arr[3+1][3+1] = 1) then (     if (arr[3+1][1+1] = 1 or arr[3+1][2+1] = 1 or arr[3+1][0+1] = 1 or arr[0+1][0+1] = 1 or arr[1+1][1+1] = 1 or arr[2+1][2+1] = 1) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(in,out);
    out.close();
  }
}
class TaskA {
  public void solve(InputReader in,PrintWriter out){
    int n=in.nextInt(),x ;
    int[] c=new int[n];
    Arrays.fill(c,0);
    for(int i=0 ; i<n ; ++i){
      x=in.nextInt();
++c[x];
    }
    for(int i=0 ; i<n ; ++i){
      x=Math.abs(n-1-i-i);
--c[x];
    }
    for(int i=0 ; i<n ; ++i){
      if(c[i]!=0){
        out.println(0);
        return ;
      }
    }
    int m=n/2 ;
    int ans=1 ;
    int mod=(int)(1e9+7);
    for(int i=0 ; i<m ; ++i){
      ans=(ans+ans)% mod ;
    }
    out.println(ans);
  }
}
class InputReader {
  public BufferedReader reader ;
  public StringTokenizer tokenizer ;
  public InputReader(InputStream stream){
    reader=new BufferedReader(new InputStreamReader(stream),32768);
    tokenizer=null ;
  }
  public String next(){
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        tokenizer=new StringTokenizer(reader.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
  public double nextDouble(){
    return Double.parseDouble(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(in, out) ; 
    skip ; 
 );
}
class TaskA {
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
    var x : int ;
     var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    c := c->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     x := in.nextInt() ; 
     c[x+1] := c[x+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     x := if n - 1 - i - i < 0 then -(n - 1 - i - i) else n - 1 - i - i endif ; 
     c[x+1] := c[x+1] - 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (c[i+1] /= 0) then (     skip ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    var m : int ; m := n / 2 ;
    var ans : int ; ans := 1 ;
    var mod : int ; mod := (1e9 + 7)->oclAsType(int) ;
        var i : int ; i := 0 ; while i < m do ( (     ans := (ans + ans) mod mod )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
public class Main {
  static Set<Integer>a=new HashSet<Integer>();
  static Set<Integer>b=new HashSet<Integer>();
  static void solve(){
    Scanner sc=new Scanner(System.in);
    BigInteger m=new BigInteger("1000000007");
    int n=sc.nextInt();
    while(n-->0){
      int c=sc.nextInt();
      if(c==0)continue ;
      if(a.contains(c))b.add(c);
      else a.add(c);
    }
    if(a.size()==b.size())System.out.println(new BigInteger("2").pow(a.size()).mod(m));
    else System.out.println(0);
    sc.close();
  }
  public static void main(String args[]){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a : Set(int) := Set{};
  static   attribute b : Set(int) := Set{};
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : long ; m := long("1000000007") ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var c : int ; c := sc.getCurrent()->toInteger() ;
     if (c = 0) then     continue else skip ; 
     if (a->includes(c)) then     b := b->including(c) ; else     a := a->including(c) ; ) ;  ) ;  
    if (a->size() = b->size()) then     OclFile["System.out"].println(long("2").pow(a->size()).mod(m)) else     OclFile["System.out"].println(0) ; ;  
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  private static long MOD=1_000_000_007 ;
  public static void main(final String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int n=scanner.nextInt();
    final boolean answer=IntStream.range(0,n).mapToObj(i->scanner.nextInt()).collect(Collectors.groupingBy(k->k)).entrySet().stream().allMatch(entry->isPromised(n,entry));
    if(! answer){
      System.out.println(0);
    }
    else {
      System.out.println(iterativePow(2,n/2));
    }
  }
  private static boolean isPromised(final int n,final Map.Entry<Integer,List<Integer>>entry){
    if(entry.getKey()% 2==n % 2){
      return false ;
    }
    if(entry.getKey()==0){
      return entry.getValue().size()==1 ;
    }
    return entry.getValue().size()==2 ;
  }
  private static long iterativePow(long a,long b){
    long tmp=1 ;
    while(b>0){
      if((b & 1)==1){
        tmp*=a ;
        tmp %=MOD ;
      }
      a*=a ;
      a %=MOD ;
      b>>=1 ;
    }
    return tmp ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : long := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var answer : boolean ; answer := Integer.subrange(0, n-1).mapToObj(lambda i : OclAny in scanner.getCurrent()->toInteger()).collect(Collectors.groupingBy(lambda k : OclAny in k))->asSet()->forAll( _x2 | (lambda entry : OclAny in isPromised(n, entry))->apply(_x2) ) ;
     if (not(answer)) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(iterativePow(2, n / 2)) ) );
  static   operation isPromised( n : int, entry : Map(int,Sequence(int))) : boolean
  pre: true
  post: true
  activity: (     if (entry.getKey() mod 2 = n mod 2) then (     return false ) else skip ; 
     if (entry.getKey() = 0) then (     return entry.getValue()->size() = 1 ) else skip ; 
     return entry.getValue()->size() = 2 );
  static   operation iterativePow( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var tmp : long ; tmp := 1 ;
     while (b > 0) do (     if ((b & 1) = 1) then (     tmp := tmp*(a) ; 
     tmp := tmp mod MOD ) else skip ; 
     a := a*(a) ; 
     a := a mod MOD ; 
     b := b/(2->pow(1)) ) ; 
     return tmp );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long n=sc.nextLong();
      if((n % 4==0 && isPerfectSquare(n/4)==true)||(n % 2==0 && isPerfectSquare(n/2)==true))System.out.println("YES");
      else System.out.println("NO");
    }
  }
  static boolean isPerfectSquare(long x){
    if(x>=0){
      long sr=(long)Math.sqrt(x);
      return((sr*sr)==x);
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := sc.getCurrent()->toLong() ;
     if ((n mod 4 = 0 & isPerfectSquare(n / 4) = true) or (n mod 2 = 0 & isPerfectSquare(n / 2) = true)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) ;  ) );
  static   operation isPerfectSquare( x : long) : boolean
  pre: true
  post: true
  activity: (     if (x >= 0) then (     var sr : long ; sr := (x)->sqrt()->oclAsType(long) ;
     return ((sr * sr) = x) ) else skip ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.*;
import java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    int n=in.nextInt();
    int[] diff=new int[n+1];
    int[] amount=new int[n+1];
    int start=0 ;
    int mod=(int)1e9+7 ;
    for(int i=1 ; i<=n ; i++){
      diff[in.nextInt()]+=1 ;
      int next=Math.abs((n-start)-start-1);
      amount[next]+=1 ;
      start++;
    }
    int ans=1 ;
    for(int i=0 ; i<=n ; i++){
      if(diff[i]!=amount[i]){
        out.println(0);
        out.close();
        return ;
      }
      else {
        if(diff[i]>0)ans*=diff[i];
        ans %=mod ;
      }
    }
    out.println(ans);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var diff : Sequence(int) ; diff := Integer.subrange(1,n + 1)->collect(0) ;
    var amount : Sequence(int) ; amount := Integer.subrange(1,n + 1)->collect(0) ;
    var start : int ; start := 0 ;
    var mod : int ; mod := 1e9->oclAsType(int) + 7 ;
        var i : int ; i := 1 ; while i <= n do ( (     diff[in.getCurrent()->toInteger()+1] := diff[in.getCurrent()->toInteger()+1]+(1) ; 
     var next : int ; next := if (n - start) - start - 1 < 0 then -((n - start) - start - 1) else (n - start) - start - 1 endif ;
     amount[next+1] := amount[next+1]+(1) ; 
     start := start + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 1 ;
        var i : int ; i := 0 ; while i <= n do ( (     if (diff[i+1] /= amount[i+1]) then (     skip ; 
     skip ; 
     return ) else (     if (diff[i+1] > 0) then     ans := ans*(diff[i+1]) ; else skip ; 
     ans := ans mod mod ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int n ;
  static int[] ps ;
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    while(true){
      n=sc.nextInt();
      if(n==0)break ;
      ps=new int[n];
      for(int i=0 ; i<n ; i++){
        ps[i]=sc.nextInt();
      }
      System.out.println(solve(0,0,0));
    }
  }
  public static int solve(int k,int a,int b){
    if(k==n){
      return Math.abs(a-b);
    }
    return Math.min(solve(k+1,a,b+ps[k]),solve(k+1,a+ps[k],b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute ps : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
    ps := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     ps[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(0, 0, 0)) ; 
 ) );
  static   operation solve( k : int, a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (k = n) then (     return if a - b < 0 then -(a - b) else a - b endif ) else skip ; 
     return Set{solve(k + 1, a, b + ps[k+1]), solve(k + 1, a + ps[k+1], b)}->min() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Member ;
import java.util.*;
import javax.naming.spi.DirStateFactory.Result ;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new AOJ1045().doIt();
  }
  class AOJ1045 {
    int n ;
    int[] member ;
    int dfs(int index,int a,int b){
      int result=Integer.MAX_VALUE ;
      if(index==n){
        return Math.abs(a-b);
      }
      result=Math.min(result,dfs(index+1,a+member[index],b));
      result=Math.min(result,dfs(index+1,a,b+member[index]));
      return result ;
    }
    void solve(){
      member=new int[n];
      for(int i=0 ; i<n ; i++)member[i]=in.nextInt();
      System.out.println(dfs(0,0,0));
    }
    void doIt(){
      while(true){
        n=in.nextInt();
        if(n==0)break ;
        solve();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     AOJ1045.newAOJ1045().doIt() );
 class AOJ1045 {
   attribute n : int;
   attribute member : Sequence(int);
   operation dfs( index : int, a : int, b : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 2147483647 ;
     if (index = n) then (     return if a - b < 0 then -(a - b) else a - b endif ) else skip ; 
    result := Set{result, dfs(index + 1, a + member[index+1], b)}->min() ; 
    result := Set{result, dfs(index + 1, a, b + member[index+1])}->min() ; 
    return result 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     member := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do (     member[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(dfs(0, 0, 0)) );
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (true) do (     n := in.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
     execute solve() ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    try {
      String line ;
      while(true){
        int n=sc.nextInt();
        if(n==0)return ;
        int[] nums=new int[n];
        int total=0 ;
        for(int i=0 ; i<n ; i++){
          nums[i]=sc.nextInt();
          total+=nums[i];
        }
        int sum,index=0,diff=0,min=total ;
        while(index<Math.pow(2,n)){
          sum=0 ;
          for(int i=0 ; i<n ; i++){
            if((1<<i & index)>0)sum+=nums[i];
          }
          diff=Math.abs(total-2*sum);
          if(diff<=1){
            min=diff ;
            break ;
          }
          if(diff<min)min=diff ;
          index=index+1 ;
        }
        System.out.println(min);
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     try (     var line : String ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := sc.getCurrent()->toInteger() ; 
     total := total+(nums[i+1]) )  ;     i := i + 1 ) ; 
    var sum : int ;
    var index : int ; index := 0 ;
    var diff : int ; diff := 0 ;
    var min : int ; min := total ;
    while (index < 2->pow(n)) do (     sum := 0 ; 
         var i : int ; i := 0 ; while i < n do ( (     if ((MathLib.bitwiseAnd((1*(2->pow(i)))->oclAsType(long),index)) > 0) then     sum := sum+(nums[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    diff := if total - 2 * sum < 0 then -(total - 2 * sum) else total - 2 * sum endif ; 
    if (diff <= 1) then (     min := diff ; 
     break ) else skip ; 
    if (diff < min) then     min := diff ; else skip ; 
    index := index + 1 ; 
 ) ; 
    OclFile["System.out"].println(min) ; 
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      int[] num=new int[n];
      int ans=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; i++)num[i]=scanner.nextInt();
      for(int i=0 ; i<1<<(n-1); i++){
        int sum1=0 ;
        int sum2=0 ;
        for(int j=0 ; j<n ; j++){
          if(((i>>j)& 1)==1)sum1+=num[j];
          else sum2+=num[j];
        }
        ans=Math.min(ans,Math.abs(sum1-sum2));
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var num : Sequence(int) ; num := Integer.subrange(1,n)->collect(0) ;
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i < n do (     num[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < (1*(2->pow((n - 1))))->oclAsType(long) do ( (     var sum1 : int ; sum1 := 0 ;
     var sum2 : int ; sum2 := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if ((((i/(2->pow(j)))->oclAsType(long)) & 1) = 1) then     sum1 := sum1+(num[j+1]) ; else     sum2 := sum2+(num[j+1]) ; )  ;     j := j + 1 ) ; 
     ans := Set{ans, if sum1 - sum2 < 0 then -(sum1 - sum2) else sum1 - sum2 endif}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int[][] input=new int[4][4];
    for(int i=0 ; i<4 ; i++){
      for(int j=0 ; j<4 ; j++){
        input[i][j]=s.nextInt();
      }
    }
    for(int i=0 ; i<4 ; i++){
      for(int j=0 ; j<3 ; j++){
        if(input[i][j]==1){
          if(input[i][3]==1){
            System.out.println("YES");
            return ;
          }
          if(j==0){
            if(input[(i+3)% 4][3]==1){
              System.out.println("YES");
              return ;
            }
          }
          if(j==1){
            if(input[(i+2)% 4][3]==1){
              System.out.println("YES");
              return ;
            }
          }
          if(j==2){
            if(input[(i+1)% 4][3]==1){
              System.out.println("YES");
              return ;
            }
          }
        }
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : Sequence(Sequence(int)) ; input := Integer.subrange(1,4)->collect(Integer.subrange(1,4)->collect(0)) ;
        var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < 4 do ( (     input[i+1][j+1] := s.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 4 do ( (         var j : int ; j := 0 ; while j < 3 do ( (     if (input[i+1][j+1] = 1) then (     if (input[i+1][3+1] = 1) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
     if (j = 0) then (     if (input[(i + 3) mod 4+1][3+1] = 1) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
     if (j = 1) then (     if (input[(i + 2) mod 4+1][3+1] = 1) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ; 
     if (j = 2) then (     if (input[(i + 1) mod 4+1][3+1] = 1) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Integer>a=new ArrayList<>();
    List<Integer>b=new ArrayList<>();
    if(n % 2==0){
      for(int i=1 ; i<=n ; i++){
        for(int j=i+1 ; j<=n ; j++){
          if(i!=j && j!=n-i+1){
            a.add(i);
            b.add(j);
          }
        }
      }
    }
    else {
      for(int i=1 ; i<=n ; i++){
        for(int j=i+1 ; j<=n ; j++){
          if(i!=j && j!=n-i){
            a.add(i);
            b.add(j);
          }
        }
      }
    }
    System.out.println(a.size());
    for(int i=0 ; i<a.size(); i++){
      System.out.println(a.get(i)+" "+b.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
    var b : Sequence(int) ; b := Sequence{} ;
    if (n mod 2 = 0) then (         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i + 1 ; while j <= n do ( (     if (i /= j & j /= n - i + 1) then (     a := a->including(i) ; 
     b := b->including(j) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) else (         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i + 1 ; while j <= n do ( (     if (i /= j & j /= n - i) then (     a := a->including(i) ; 
     b := b->including(j) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(a->size()) ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     OclFile["System.out"].println(a->at(i+1) + " " + b->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
class Problem {
  private int N ;
  Problem(){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
  }
  void solve(){
    int n=N % 2==1 ? N : N+1 ;
    int M=N % 2==1 ?(N-1)/2 : N/2 ;
    ArrayList<String>edges=new ArrayList<>();
    for(int i=1 ; i<M ; i++){
      edges.add(i+" "+(i+1));
      edges.add(i+" "+(n-(i+1)));
      edges.add((i+1)+" "+(n-i));
      edges.add((n-(i+1))+" "+(n-i));
    }
    if(N % 2==0 && M>2){
      edges.add(1+" "+M);
      edges.add(1+" "+(M+1));
      edges.add(M+" "+(n-1));
      edges.add((M+1)+" "+(n-1));
    }
    else if(N % 2==1){
      edges.add(1+" "+N);
      edges.add((n-1)+" "+N);
      if(M>1){
        edges.add(M+" "+N);
        edges.add((M+1)+" "+N);
      }
    }
    System.out.println(edges.size());
    for(String e : edges){
      System.out.println(e);
    }
  }
}
public class Main {
  public static void main(String[] args){
    new Problem().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem {
   attribute N : int;
   static operation newProblem() : Problem
  pre: true
  post: true
  activity:
  ( var self : Problem ;
    self := createProblem();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := if N mod 2 = 1 then N else N + 1 endif ;
     var M : int ; M := if N mod 2 = 1 then (N - 1) / 2 else N / 2 endif ;
    var edges : Sequence(String) ; edges := Sequence{} ;
        var i : int ; i := 1 ; while i < M do ( (     edges := edges->including(i + " " + (i + 1)) ; 
     edges := edges->including(i + " " + (n - (i + 1))) ; 
     edges := edges->including((i + 1) + " " + (n - i)) ; 
     edges := edges->including((n - (i + 1)) + " " + (n - i)) )  ;     i := i + 1 ) ; 
    if (N mod 2 = 0 & M > 2) then (     edges := edges->including(1 + " " + M) ; 
     edges := edges->including(1 + " " + (M + 1)) ; 
     edges := edges->including(M + " " + (n - 1)) ; 
     edges := edges->including((M + 1) + " " + (n - 1)) ) else     if (N mod 2 = 1) then (     edges := edges->including(1 + " " + N) ; 
     edges := edges->including((n - 1) + " " + N) ; 
     if (M > 1) then (     edges := edges->including(M + " " + N) ; 
     edges := edges->including((M + 1) + " " + N) ) else skip ) else skip ; ;  
    OclFile["System.out"].println(edges->size()) ; 
    for (e : edges) do ( (     OclFile["System.out"].println(e) )  ) ; 
 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Problem.newProblem().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(final String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int n=scanner.nextInt();
    final LinkedList<Pair>pairs=new LinkedList<>();
    if(n % 2==1){
      for(int i=1 ; i<=n ; i++){
        for(int j=i+1 ; j<=n ; j++){
          if(i+j!=n){
            pairs.add(new Pair(i,j));
          }
        }
      }
    }
    else {
      for(int i=1 ; i<=n ; i++){
        for(int j=i+1 ; j<=n ; j++){
          if(i+j!=n+1){
            pairs.add(new Pair(i,j));
          }
        }
      }
    }
    System.out.println(pairs.size());
    final String answer=pairs.stream().map(Pair :: toString).collect(Collectors.joining("\n"));
    System.out.println(answer);
  }
  private static class Pair {
    final int x ;
    final int y ;
    Pair(final int x,final int y){
      this.x=x ;
      this.y=y ;
    }
    @ Override public String toString(){
      return x+" "+y ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var pairs : Sequence(Map) ; pairs := Sequence{} ;
    if (n mod 2 = 1) then (         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i + 1 ; while j <= n do ( (     if (i + j /= n) then (     pairs := pairs->including(Map(i, j)) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) else (         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i + 1 ; while j <= n do ( (     if (i + j /= n + 1) then (     pairs := pairs->including(Map(i, j)) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(pairs->size()) ; 
    var answer : String ; answer := pairs->collect( _x1 | (lambda _pars : OclAny in Pair.newPair().toString(_pars))->apply(_x1) ).collect(Collectors.joining("\n")) ;
    OclFile["System.out"].println(answer) ; 
 );
  static class Pair {
   attribute x : int;
   attribute y : int;
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
      operation toString() : String
  pre: true
  post: true
  activity: (     return x + " " + y );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.System.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    int n=sc.nextInt();
    if(n % 2==0){
      out.println((n-2)*(n/2));
      for(int i=1 ; i<n ; i++){
        for(int j=i+1 ; j<=n ; j++){
          if(i+j==n+1)continue ;
          out.println(i+" "+j);
        }
      }
    }
    else {
      out.println((n-2)*(n/2)+(n-1)/2);
      for(int i=1 ; i<n ; i++){
        for(int j=i+1 ; j<=n ; j++){
          if(i+j==n)continue ;
          out.println(i+" "+j);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (     out.println((n - 2) * (n / 2)) ; 
         var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := i + 1 ; while j <= n do ( (     if (i + j = n + 1) then     continue else skip ; 
     out.println(i + " " + j) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) else (     out.println((n - 2) * (n / 2) + (n - 1) / 2) ; 
         var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := i + 1 ; while j <= n do ( (     if (i + j = n) then     continue else skip ; 
     out.println(i + " " + j) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder();
    int t=fs.nextInt();
    while(t-->0){
      int n=fs.nextInt();
      int x=(int)Math.sqrt(n/2),y=(int)Math.sqrt(n/4);
      sb.append(((n % 2==0 && x*x==n/2)||(n % 4==0 && y*y==n/4))? "YES\n" : "NO\n");
    }
    out.println(sb);
    out.close();
  }
  static int isPerfectSquare(int x){
    if(x>=0){
      int sr=(int)Math.sqrt(x);
      if((sr*sr)==x)return sr ;
      else return 0 ;
    }
    return 0 ;
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    Long[] readArray(int n){
      Long[] a=new Long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    var t : int ; t := fs.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := fs.nextInt() ;
     var x : int ; x := (n / 2)->sqrt()->oclAsType(int) ;
    var y : int ; y := (n / 4)->sqrt()->oclAsType(int) ;
     sb := sb + StringLib.newString(if ((n mod 2 = 0 & x * x = n / 2) or (n mod 4 = 0 & y * y = n / 4)) then "YES\n" else "NO\n" endif) ) ;  ) ;  
    skip ; 
    skip ; 
 );
  static   operation isPerfectSquare( x : int) : int
  pre: true
  post: true
  activity: (     if (x >= 0) then (     var sr : int ; sr := (x)->sqrt()->oclAsType(int) ;
     if ((sr * sr) = x) then     return sr else     return 0 ) else skip ; 
     return 0 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    if(N % 2==0){
      int ans=0 ;
      for(int i=1 ; i<N ; i++){
        ans+=i ;
      }
      System.out.println(ans-N/2);
      for(int i=1 ; i<=N ; i++){
        for(int j=i+1 ; j<=N ; j++){
          if(i+j==N+1)continue ;
          System.out.print(i+" ");
          System.out.println(j);
        }
      }
    }
    else {
      int ans=0 ;
      for(int i=1 ; i<N ; i++){
        ans+=i ;
      }
      System.out.println(ans-(N-1)/2);
      for(int i=1 ; i<=N ; i++){
        for(int j=i+1 ; j<=N ; j++){
          if(i+j==N)continue ;
          System.out.print(i+" ");
          System.out.println(j);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N mod 2 = 0) then (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i < N do ( (     ans := ans+(i) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans - N / 2) ; 
         var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := i + 1 ; while j <= N do ( (     if (i + j = N + 1) then     continue else skip ; 
     OclFile["System.out"].print(i + " ") ; 
     OclFile["System.out"].println(j) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) else (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i < N do ( (     ans := ans+(i) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans - (N - 1) / 2) ; 
         var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := i + 1 ; while j <= N do ( (     if (i + j = N) then     continue else skip ; 
     OclFile["System.out"].print(i + " ") ; 
     OclFile["System.out"].println(j) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int CountOfOddSum(int a[][],int n){
    int[][] dp=new int[n][2];
    int[][] cnt=new int[n][2];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<2 ; j++){
        if(a[i][j] % 2==0){
          cnt[i][0]++;
        }
        else {
          cnt[i][1]++;
        }
      }
    }
    dp[0][0]=cnt[0][0];
    dp[0][1]=cnt[0][1];
    for(int i=1 ; i<n ; i++){
      dp[i][0]=(dp[i-1][0]*cnt[i][0]+dp[i-1][1]*cnt[i][1]);
      dp[i][1]=(dp[i-1][0]*cnt[i][1]+dp[i-1][1]*cnt[i][0]);
    }
    return dp[n-1][1];
  }
  public static void main(String[] args){
    int a[][]={
      {
        1,2 },{
          3,6 }
        };
        int n=a.length ;
        int ans=CountOfOddSum(a,n);
        System.out.println(ans);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation CountOfOddSum( a : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
     var cnt : Sequence(Sequence(int)) ; cnt := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 2 do ( (     if (a[i+1][j+1] mod 2 = 0) then (     cnt[i+1][0+1] := cnt[i+1][0+1] + 1 ) else (     cnt[i+1][1+1] := cnt[i+1][1+1] + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := cnt[0+1][0+1] ; 
    dp[0+1][1+1] := cnt[0+1][1+1] ; 
        var i : int ; i := 1 ; while i < n do ( (     dp[i+1][0+1] := (dp[i - 1+1][0+1] * cnt[i+1][0+1] + dp[i - 1+1][1+1] * cnt[i+1][1+1]) ; 
     dp[i+1][1+1] := (dp[i - 1+1][0+1] * cnt[i+1][1+1] + dp[i - 1+1][1+1] * cnt[i+1][0+1]) )  ;     i := i + 1 ) ; 
    return dp[n - 1+1][1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(Sequence(int)) ; a := Sequence{Sequence{1,2},Sequence{3,6}} ;
     var n : int ; n := a->size() ;
     var ans : int ; ans := CountOfOddSum(a, n) ;
     OclFile["System.out"].println(ans) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void WindowtoViewport(int x_w,int y_w,int x_wmax,int y_wmax,int x_wmin,int y_wmin,int x_vmax,int y_vmax,int x_vmin,int y_vmin){
    int x_v,y_v ;
    float sx,sy ;
    sx=(float)(x_vmax-x_vmin)/(x_wmax-x_wmin);
    sy=(float)(y_vmax-y_vmin)/(y_wmax-y_wmin);
    x_v=(int)(x_vmin+(float)((x_w-x_wmin)*sx));
    y_v=(int)(y_vmin+(float)((y_w-y_wmin)*sy));
    System.out.printf("The point on viewport:(%d,%d)\n ",x_v,y_v);
  }
  public static void main(String[] args){
    int x_wmax=80,y_wmax=80,x_wmin=20,y_wmin=40 ;
    int x_vmax=60,y_vmax=60,x_vmin=30,y_vmin=40 ;
    int x_w=30,y_w=80 ;
    WindowtoViewport(30,80,80,80,20,40,60,60,30,40);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation WindowtoViewport( x_w : int, y_w : int, x_wmax : int, y_wmax : int, x_wmin : int, y_wmin : int, x_vmax : int, y_vmax : int, x_vmin : int, y_vmin : int) : void
  pre: true
  post: true
  activity: (     var x_v : int ;
    var y_v : int ;
     var sx : double ;
    var sy : double ;
    sx := (x_vmax - x_vmin)->oclAsType(double) / (x_wmax - x_wmin) ; 
    sy := (y_vmax - y_vmin)->oclAsType(double) / (y_wmax - y_wmin) ; 
    x_v := (x_vmin + ((x_w - x_wmin) * sx)->oclAsType(double))->oclAsType(int) ; 
    y_v := (y_vmin + ((y_w - y_wmin) * sy)->oclAsType(double))->oclAsType(int) ; 
    OclFile["System.out"].printf("The point on viewport:(%d,%d)\n ", x_v, y_v) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x_wmax : int ; x_wmax := 80 ;
    var y_wmax : int ; y_wmax := 80 ;
    var x_wmin : int ; x_wmin := 20 ;
    var y_wmin : int ; y_wmin := 40 ;
     var x_vmax : int ; x_vmax := 60 ;
    var y_vmax : int ; y_vmax := 60 ;
    var x_vmin : int ; x_vmin := 30 ;
    var y_vmin : int ; y_vmin := 40 ;
     var x_w : int ; x_w := 30 ;
    var y_w : int ; y_w := 80 ;
     execute WindowtoViewport(30, 80, 80, 80, 20, 40, 60, 60, 30, 40) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void powerSet(String str,int index,String curr){
    int n=str.length();
    if(index==n){
      System.out.println(curr);
      return ;
    }
    powerSet(str,index+1,curr+str.charAt(index));
    powerSet(str,index+1,curr);
  }
  public static void main(String[] args){
    String str="abc" ;
    int index=0 ;
    String curr="" ;
    powerSet(str,index,curr);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation powerSet( str : String, index : int, curr : String) : void
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     if (index = n) then (     OclFile["System.out"].println(curr) ; 
     return ) else skip ; 
     execute powerSet(str, index + 1, curr + str->at(index+1)) ; 
     execute powerSet(str, index + 1, curr) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abc" ;
     var index : int ; index := 0 ;
     var curr : String ; curr := "" ;
     execute powerSet(str, index, curr) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TableTennis {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long k=sc.nextLong();
    int arr[]=new int[n];
    int max=0 ;
    int c=0 ;
    int ans=0 ;
    arr[0]=sc.nextInt();
    max=arr[0];
    for(int i=1 ; i<n ; i++){
      arr[i]=sc.nextInt();
      if(arr[i]>max){
        c=1 ;
        max=arr[i];
      }
      else c++;
      if(c==k && ans==0)ans=max ;
    }
    if(ans==0)ans=max ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class TableTennis {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := 0 ;
    var c : int ; c := 0 ;
    var ans : int ; ans := 0 ;
    arr[0+1] := sc.getCurrent()->toInteger() ; 
    max := arr[0+1] ; 
        var i : int ; i := 1 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr[i+1] > max) then (     c := 1 ; 
     max := arr[i+1] ) else     c := c + 1 ; ;  
     if (c = k & ans = 0) then     ans := max ; else skip )  ;     i := i + 1 ) ; 
    if (ans = 0) then     ans := max ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    String result="NO" ;
    Scanner sc=new Scanner(System.in);
    boolean[][] arr=new boolean[4][4];
    for(int i=0 ; i<4 ; i++){
      String[] s=sc.nextLine().split(" ");
      for(int j=0 ; j<s.length ; j++){
        if(s[j] .equals("0")){
          arr[i][j]=false ;
        }
        else {
          arr[i][j]=true ;
        }
      }
    }
    for(int i=0 ; i<4 ; i++){
      if(arr[i][3]==true){
        if(arr[i][0]==true || arr[i][1]==true || arr[i][2]==true){
          result="YES" ;
          break ;
        }
      }
      int tmp ;
      if(i==2)tmp=0 ;
      else if(i==3)tmp=1 ;
      else tmp=i+2 ;
      if(arr[i][1]==true && arr[tmp][3]==true){
        result="YES" ;
        break ;
      }
      if(i==0)tmp=3 ;
      else tmp=i-1 ;
      if(arr[i][0]==true && arr[tmp][3]==true){
        result="YES" ;
        break ;
      }
      if(i==3)tmp=0 ;
      else tmp=i+1 ;
      if(arr[i][2]==true && arr[tmp][3]==true){
        result="YES" ;
        break ;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var result : String ; result := "NO" ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var arr : Sequence(Sequence(boolean)) ; arr := Integer.subrange(1,4)->collect(Integer.subrange(1,4)->collect(false)) ;
        var i : int ; i := 0 ; while i < 4 do ( (     var s : Sequence(String) ; s := sc.nextLine()->split(" ") ;
         var j : int ; j := 0 ; while j < s->size() do ( (     if (s[j+1] = "0") then (     arr[i+1][j+1] := false ) else (     arr[i+1][j+1] := true ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 4 do ( (     if (arr[i+1][3+1] = true) then (     if (arr[i+1][0+1] = true or arr[i+1][1+1] = true or arr[i+1][2+1] = true) then (     result := "YES" ; 
     break ) else skip ) else skip ; 
     var tmp : int ;
    if (i = 2) then     tmp := 0 else     if (i = 3) then     tmp := 1 else     tmp := i + 2 ; ;  ;  
    if (arr[i+1][1+1] = true & arr[tmp+1][3+1] = true) then (     result := "YES" ; 
     break ) else skip ; 
    if (i = 0) then     tmp := 3 else     tmp := i - 1 ; ;  
    if (arr[i+1][0+1] = true & arr[tmp+1][3+1] = true) then (     result := "YES" ; 
     break ) else skip ; 
    if (i = 3) then     tmp := 0 else     tmp := i + 1 ; ;  
    if (arr[i+1][2+1] = true & arr[tmp+1][3+1] = true) then (     result := "YES" ; 
     break ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static BufferedReader br ;
  static StringTokenizer st ;
  static PrintWriter pr=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  public static class AL<T>extends ArrayList<T>{
  };
  public static void main(String[] args)throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    st=new StringTokenizer(br.readLine());
    Queue<Integer>q=new LinkedList<>();
    long n=nxtLong(),k=nxtLong();
    st=new StringTokenizer(br.readLine());
    int crr=nxtInt();
    for(int i=1 ; i<(int)n ; i++)q.add(nxtInt());
    if(k>=n*2)pr.println(n);
    else {
      int max=0,cnt=0,pow=-1 ;
      while(max<k){
        if(crr>q.peek()){
          q.add(q.poll());
          cnt++;
          if(cnt>max){
            max=cnt ;
            pow=crr ;
          }
        }
        else {
          q.add(crr);
          crr=q.poll();
          cnt=1 ;
        }
      }
      pr.println(pow);
    }
    pr.flush();
    pr.close();
  }
  static int nxtInt(){
    return Integer.parseInt(nxt());
  }
  static long nxtLong(){
    return Long.parseLong(nxt());
  }
  static double nxtDoub(){
    return Double.parseDouble(nxt());
  }
  static String nxt(){
    return st.nextToken();
  }
  static String nxtLn()throws IOException {
    return br.readLine();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile;
  static   attribute st : OclIterator;
  static   attribute pr : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])));
  static class AL<T> extends Sequence(T) { }
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := OclIterator.newOclIterator_String(br.readLine()) ; 
    var q : Sequence(int) ; q := Sequence{} ;
    var n : long ; n := nxtLong() ;
    var k : long ; k := nxtLong() ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    var crr : int ; crr := nxtInt() ;
        var i : int ; i := 1 ; while i < n->oclAsType(int) do (     q := q->including(nxtInt()) ;  ;     i := i + 1 ) ; 
    if (k >= n * 2) then     skip else (     var max : int ; max := 0 ;
    var cnt : int ; cnt := 0 ;
    var pow : int ; pow := -1 ;
     while (max < k) do (     if (crr > q->min()) then (     q := q->including(q->min()) ; 
     cnt := cnt + 1 ; 
     if (cnt > max) then (     max := cnt ; 
     pow := crr ) else skip ) else (     q := q->including(crr) ; 
     crr := q->min() ;     q := q->sort()->tail() ; 
     cnt := 1 ) ) ; 
     skip ) ;  
    skip ; 
    skip ; 
 );
  static   operation nxtInt() : int
  pre: true
  post: true
  activity: (     return (nxt())->toInteger() );
  static   operation nxtLong() : long
  pre: true
  post: true
  activity: (     return (nxt())->toLong() );
  static   operation nxtDoub() : double
  pre: true
  post: true
  activity: (     return (nxt())->toReal() );
  static   operation nxt() : String
  pre: true
  post: true
  activity: (     return st.next() );
  static   operation nxtLn() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Stack ;
import java.util.StringTokenizer ;
public class test {
  public static void main(String...args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    long k=Long.parseLong(st.nextToken());
    int[] a=new int[n];
    st=new StringTokenizer(br.readLine());
    int largest=-1 ;
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(st.nextToken());
      largest=largest>a[i] ? largest : a[i];
    }
    if(k>=n-1){
      System.out.println(largest);
    }
    else {
      Stack<Integer>s=new Stack<Integer>();
      int[] b=new int[n];
      b[n-1]=0 ;
      s.add(n-1);
      for(int i=n-2 ; i>=0 ; i--){
        while(! s.isEmpty()&& a[s.peek()]<a[i]){
          b[i]=b[i]+b[s.pop()]+1 ;
        }
        s.push(i);
      }
      int ans=-1 ;
      if(b[0]>=k){
        ans=a[0];
      }
      else {
        for(int i=1 ; i<n ; i++){
          if(b[i]+1>=k){
            ans=a[i];
            break ;
          }
        }
      }
      if(ans==-1){
        ans=largest ;
      }
      System.out.println(ans);
    }
  }
}
class pair {
  int val ;
  int index ;
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var k : long ; k := (st.next())->toLong() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    var largest : int ; largest := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (st.next())->toInteger() ; 
     largest := if largest > a[i+1] then largest else a[i+1] endif )  ;     i := i + 1 ) ; 
    if (k >= n - 1) then (     OclFile["System.out"].println(largest) ) else (     var s : Sequence(int) ; s := Sequence{} ;
     var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    b[n - 1+1] := 0 ; 
    s := s->including(n - 1) ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     while (not(s->isEmpty()) & a[s->min()+1] < a[i+1]) do (     b[i+1] := b[i+1] + b[s->last()+1] + 1 ) ; 
     s := s->append(i) )  ;     i := i - 1 ) ; 
    var ans : int ; ans := -1 ;
    if (b[0+1] >= k) then (     ans := a[0+1] ) else (         var i : int ; i := 1 ; while i < n do ( (     if (b[i+1] + 1 >= k) then (     ans := a[i+1] ; 
     break ) else skip )  ;     i := i + 1 ) ) ;  
    if (ans = -1) then (     ans := largest ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  
 );
}
class pair {
   attribute val : int;
   attribute index : int;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class Node {
    int data ;
    Node next ;
  };
  static Node push(Node head_ref,int new_data){
    Node new_node=new Node();
    new_node.data=new_data ;
    new_node.next=(head_ref);
(head_ref)=new_node ;
    return head_ref ;
  }
  static int getCount(Node head){
    int count=0 ;
    Node current=head ;
    while(current!=null){
      count++;
      current=current.next ;
    }
    return count ;
  }
  static int getNth(Node head,int n){
    Node curr=head ;
    for(int i=0 ; i<n-1 && curr!=null ; i++)curr=curr.next ;
    return curr.data ;
  }
  static void printReverse(Node head){
    Stack<Node>stk=new Stack<Node>();
    Node ptr=head ;
    while(ptr!=null){
      stk.push(ptr);
      ptr=ptr.next ;
    }
    while(stk.size()>0){
      System.out.print(stk.peek().data+" ");
      stk.pop();
    }
    System.out.println("\n");
  }
  public static void main(String args[]){
    Node head=null ;
    head=push(head,5);
    head=push(head,4);
    head=push(head,3);
    head=push(head,2);
    head=push(head,1);
    printReverse(head);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   operation push( head_ref : Node, new_data : int) : Node
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode() ;
     new_node.data := new_data ; 
    new_node.next := (head_ref) ; 
    (head_ref) := new_node ; 
    return head_ref 
 );
  static   operation getCount( head : Node) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var current : Node ; current := head ;
     while (current /= null) do (     count := count + 1 ; 
     current := current.next ) ; 
     return count );
  static   operation getNth( head : Node, n : int) : int
  pre: true
  post: true
  activity: (     var curr : Node ; curr := head ;
         var i : int ; i := 0 ; while i < n - 1 & curr /= null do (     curr := curr.next ;  ;     i := i + 1 ) ; 
     return curr.data );
  static   operation printReverse( head : Node) : void
  pre: true
  post: true
  activity: (     var stk : Sequence(Node) ; stk := Sequence{} ;
     var ptr : Node ; ptr := head ;
    while (ptr /= null) do (     stk := stk->append(ptr) ; 
     ptr := ptr.next ) ; 
    while (stk->size() > 0) do (     OclFile["System.out"].print(stk->min().data + " ") ; 
     stk := stk->front() ) ; 
    OclFile["System.out"].println("\n") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := null ;
     head := push(head, 5) ; 
    head := push(head, 4) ; 
    head := push(head, 3) ; 
    head := push(head, 2) ; 
    head := push(head, 1) ; 
    execute printReverse(head) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findAndSum(int[] arr,int n){
    int sum=0 ;
    int mul=1 ;
    for(int i=0 ; i<30 ; i++){
      boolean count_on=false ;
      int l=0 ;
      for(int j=0 ; j<n ; j++){
        if((arr[j] &(1<<i))>0)if(count_on)l++;
        else {
          count_on=true ;
          l++;
        }
        else if(count_on){
          sum+=((mul*l*(l+1))/2);
          count_on=false ;
          l=0 ;
        }
      }
      if(count_on){
        sum+=((mul*l*(l+1))/2);
        count_on=false ;
        l=0 ;
      }
      mul*=2 ;
    }
    return sum ;
  }
  public static void main(String[] args){
    int[] arr={
      7,1,1,5 };
      int n=arr.length ;
      System.out.println(findAndSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findAndSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var mul : int ; mul := 1 ;
         var i : int ; i := 0 ; while i < 30 do ( (     var count_on : boolean ; count_on := false ;
     var l : int ; l := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     if ((arr[j+1] & ((1*(2->pow(i)))->oclAsType(long))) > 0) then     if (count_on) then     l := l + 1 else (     count_on := true ; 
     l := l + 1 ) ;  else     if (count_on) then (     sum := sum+(((mul * l * (l + 1)) / 2)) ; 
     count_on := false ; 
     l := 0 ) else skip ; )  ;     j := j + 1 ) ; 
    if (count_on) then (     sum := sum+(((mul * l * (l + 1)) / 2)) ; 
     count_on := false ; 
     l := 0 ) else skip ; 
    mul := mul*(2) ; 
 )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{7,1,1,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findAndSum(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Solution {
  static int __builtin_popcount(int n){
    int count=0 ;
    while(n>0){
      if(n % 2==1)count++;
      n=n/2 ;
    }
    return count ;
  }
  static void count_values(int n){
    int set_bits=__builtin_popcount(n);
    System.out.println((int)Math.pow(2,set_bits));
  }
  public static void main(String args[]){
    int n=27 ;
    count_values(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation __builtin_popcount( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     if (n mod 2 = 1) then     count := count + 1 ; else skip ; 
     n := n / 2 ) ; 
     return count );
  static   operation count_values( n : int) : void
  pre: true
  post: true
  activity: (     var set_bits : int ; set_bits := __builtin_popcount(n) ;
     OclFile["System.out"].println(2->pow(set_bits)->oclAsType(int)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 27 ;
     execute count_values(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import java.io.*;
public class Hello {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    if(n<=9){
      pw.println(n);
    }
    else if(n<=99){
      int val=n-9 ;
      pw.println(9+(val*2));
    }
    else if(n<=999){
      int val=n-99 ;
      pw.println(9+180+(val*3));
    }
    else if(n<=9999){
      int val=n-999 ;
      pw.println(9+180+2700+(val*4));
    }
    else if(n<=99999){
      int val=n-9999 ;
      pw.println(9+180+2700+36000+(val*5));
    }
    else if(n<=999999){
      int val=n-99999 ;
      pw.println(9+180+2700+36000+450000+(val*6));
    }
    else if(n<=9999999){
      int val=n-999999 ;
      pw.println(9+180+2700+36000+450000+5400000+(val*7));
    }
    else if(n<=99999999){
      int val=n-9999999 ;
      pw.println(9+180+2700+36000+450000+5400000+63000000+(val*8));
    }
    else if(n<=999999999){
      long val=n-99999999 ;
      long sum=(9+180+2700+36000+450000+5400000+63000000+720000000+(val*9));
      pw.println(sum);
    }
    else {
      String v="8888888899" ;
      pw.println(v);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hello {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    if (n <= 9) then (     skip ) else     if (n <= 99) then (     var val : int ; val := n - 9 ;
     skip ) else     if (n <= 999) then (     var val : int ; val := n - 99 ;
     skip ) else     if (n <= 9999) then (     var val : int ; val := n - 999 ;
     skip ) else     if (n <= 99999) then (     var val : int ; val := n - 9999 ;
     skip ) else     if (n <= 999999) then (     var val : int ; val := n - 99999 ;
     skip ) else     if (n <= 9999999) then (     var val : int ; val := n - 999999 ;
     skip ) else     if (n <= 99999999) then (     var val : int ; val := n - 9999999 ;
     skip ) else     if (n <= 999999999) then (     var val : long ; val := n - 99999999 ;
     var sum : long ; sum := (9 + 180 + 2700 + 36000 + 450000 + 5400000 + 63000000 + 720000000 + (val * 9)) ;
     skip ) else (     var v : String ; v := "8888888899" ;
     skip ) ;  ;  ;  ;  ;  ;  ;  ;  ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] array=new long[n];
    for(int i=0 ; i<n ; i++){
      array[i]=sc.nextInt();
    }
    Arrays.sort(array);
    long[] cumsum=new long[n+1];
    for(int i=0 ; i<n ; i++){
      cumsum[i+1]=cumsum[i]+array[i];
    }
    int ok=1 ;
    for(int i=n-1 ; i>0 ; i--){
      if(cumsum[i]*2>=array[i]){
        ok++;
      }
      else {
        break ;
      }
    }
    System.out.println(ok);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var array : Sequence(long) ; array := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    array := array->sort() ; 
    var cumsum : Sequence(long) ; cumsum := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     cumsum[i + 1+1] := cumsum[i+1] + array[i+1] )  ;     i := i + 1 ) ; 
    var ok : int ; ok := 1 ;
        var i : int ; i := n - 1 ; while i > 0 do ( (     if (cumsum[i+1] * 2 >= array[i+1]) then (     ok := ok + 1 ) else (     break ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ok) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  private void solve()throws IOException {
    int n=nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=nextInt();
    }
    Arrays.sort(a);
    long s=0 ;
    int j=0 ;
    for(int i=0 ; i<n-1 ; i++){
      s+=a[i];
      if(a[i+1]>s*2){
        j=i+1 ;
      }
    }
    out.println(n-j);
  }
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer st ;
  PrintWriter out=new PrintWriter(System.out);
  String next()throws IOException {
    while(st==null || ! st.hasMoreTokens()){
      st=new StringTokenizer(br.readLine());
    }
    return st.nextToken();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    solve();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := nextInt() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var s : long ; s := 0 ;
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     s := s+(a[i+1]) ; 
     if (a[i + 1+1] > s * 2) then (     j := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    out.println(n - j) ; 
 );
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator;
   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     execute solve() ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=false ;
  private static PrintWriter _out=new PrintWriter(System.out);
  private static PrintWriter _err=new PrintWriter(System.err);
  private void solve(Scanner sc){
    int N=sc.nextInt();
    int[] A=new int[N];
    for(int i=0 ; i<N ; ++i){
      A[i]=sc.nextInt();
    }
    Arrays.sort(A);
    int t=0 ;
    long sum=0 ;
    for(int i=0 ; i<N-1 ; ++i){
      if(2*(sum+A[i])<A[i+1]){
        t=i+1 ;
      }
      sum+=A[i];
    }
    _out.println((N-t));
  }
  private static BigInteger C(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    for(long i=r ; i>1 ; --i){
      res=res.divide(BigInteger.valueOf(i));
    }
    return res ;
  }
  private static BigInteger P(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    return res ;
  }
  public static void main(String[] args){
    long S=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    new Main().solve(sc);
    _out.flush();
    long G=System.currentTimeMillis();
    if(elapsed){
      _err.println((G-S)+"ms");
    }
    _err.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := false;
  static   attribute _out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute _err : OclFile := OclFile.newOclFile_Write(OclFile["System.err"]);
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.nextInt() ;
     var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    var t : int ; t := 0 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     if (2 * (sum + A[i+1]) < A[i + 1+1]) then (     t := i + 1 ) else skip ; 
     sum := sum+(A[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation C( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
         var i : long ; i := r ; while i > 1 do ( (     res := res.divide((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation P( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    Main.newMain().solve(sc) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner cin=new Scanner(System.in);
    int target=cin.nextInt();
    long A[]=new long[target];
    int count=0 ;
    long tmp=0L ;
    long tmp_sum=0L ;
    boolean flg_brk=false ;
    for(int i=0 ; i<target ; i++){
      A[i]=cin.nextLong();
    }
    cin.close();
    Arrays.sort(A);
    for(int j=0 ; j<target-1 ; j++){
      tmp=A[j]+tmp_sum ;
      if(2*tmp>=A[target-1]){
        count=target-j ;
        break ;
      }
      else if(j==0 || A[j]!=A[j-1]){
        for(int k=j+1 ; k<target && 2*tmp>=A[k]; k++){
          tmp+=A[k];
          if(2*tmp>=A[target-1]){
            count=target-j ;
            flg_brk=true ;
          }
        }
        if(flg_brk){
          break ;
        }
      }
      tmp_sum+=A[j];
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var target : int ; target := cin.getCurrent()->toInteger() ;
    var A : Sequence(long) ; A := Integer.subrange(1,target)->collect(0) ;
    var count : int ; count := 0 ;
    var tmp : long ; tmp := 0L ;
    var tmp_sum : long ; tmp_sum := 0L ;
    var flg_brk : boolean ; flg_brk := false ;
        var i : int ; i := 0 ; while i < target do ( (     A[i+1] := cin.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    skip ; 
    A := A->sort() ; 
        var j : int ; j := 0 ; while j < target - 1 do ( (     tmp := A[j+1] + tmp_sum ; 
     if (2 * tmp >= A[target - 1+1]) then (     count := target - j ; 
     break ) else     if (j = 0 or A[j+1] /= A[j - 1+1]) then (         var k : int ; k := j + 1 ; while k < target & 2 * tmp >= A[k+1] do ( (     tmp := tmp+(A[k+1]) ; 
     if (2 * tmp >= A[target - 1+1]) then (     count := target - j ; 
     flg_brk := true ) else skip )  ;     k := k + 1 ) ; 
     if (flg_brk) then (     break ) else skip ) else skip ; ;  
     tmp_sum := tmp_sum+(A[j+1]) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A417 {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    byte[][] a=new byte[4][4];
    int i,j ;
    boolean b=false ;
    for(i=0 ; i<4 ; i++){
      for(j=0 ; j<4 ; j++){
        a[i][j]=s.nextByte();
      }
    }
    for(i=0 ; i<4 ; i++){
      if(a[i][3]==1){
        if(a[i][0]==1 || a[i][1]==1 || a[i][2]==1)b=true ;
        if(i==0){
          if(a[1][0]==1 || a[2][1]==1 || a[3][2]==1)b=true ;
        }
        if(i==1){
          if(a[2][0]==1 || a[3][1]==1 || a[0][2]==1)b=true ;
        }
        if(i==3){
          if(a[0][0]==1 || a[1][1]==1 || a[2][2]==1)b=true ;
        }
        if(i==2){
          if(a[3][0]==1 || a[0][1]==1 || a[1][2]==1)b=true ;
        }
      }
    }
    if(b)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A417 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,4)->collect(Integer.subrange(1,4)->collect(0)) ;
    var i : int ;
    var j : int ;
    var b : boolean ; b := false ;
        i := 0 ; while i < 4 do ( (         j := 0 ; while j < 4 do ( (     a[i+1][j+1] := s.nextByte() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        i := 0 ; while i < 4 do ( (     if (a[i+1][3+1] = 1) then (     if (a[i+1][0+1] = 1 or a[i+1][1+1] = 1 or a[i+1][2+1] = 1) then     b := true ; else skip ; 
     if (i = 0) then (     if (a[1+1][0+1] = 1 or a[2+1][1+1] = 1 or a[3+1][2+1] = 1) then     b := true ; else skip ) else skip ; 
    if (i = 1) then (     if (a[2+1][0+1] = 1 or a[3+1][1+1] = 1 or a[0+1][2+1] = 1) then     b := true ; else skip ) else skip ; 
    if (i = 3) then (     if (a[0+1][0+1] = 1 or a[1+1][1+1] = 1 or a[2+1][2+1] = 1) then     b := true ; else skip ) else skip ; 
    if (i = 2) then (     if (a[3+1][0+1] = 1 or a[0+1][1+1] = 1 or a[1+1][2+1] = 1) then     b := true ; else skip ) else skip ; 
 ) else skip )  ;     i := i + 1 ) ; 
    if (b) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] a1=new long[n];
    for(int i=0 ; i<n ; i++){
      long a=sc.nextLong();
      a1[i]=a ;
    }
    Arrays.sort(a1);
    long ans=1 ;
    for(int i=0 ; i<n-1 ; i++){
      if(a1[i]*2>=a1[i+1]){
        ans++;
      }
      else {
        ans=1 ;
      }
      a1[i+1]+=a1[i];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a1 : Sequence(long) ; a1 := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var a : long ; a := sc.getCurrent()->toLong() ;
     a1[i+1] := a )  ;     i := i + 1 ) ; 
    a1 := a1->sort() ; 
    var ans : long ; ans := 1 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (a1[i+1] * 2 >= a1[i + 1+1]) then (     ans := ans + 1 ) else (     ans := 1 ) ;  
     a1[i + 1+1] := a1[i + 1+1]+(a1[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
import java.util.*;
public class C {
  public static int[] a ;
  public static int find(int k,int x){
    int low=1 ;
    int up=k ;
    while(low<up){
      int mid=(low+up)/2 ;
      if(a[mid]<=x)low=mid+1 ;
      else up=mid ;
    }
    return low ;
  }
  public static void main(String args[]){
    a=new int[1000001];
    a[1]=2 ;
    a[2]=4 ;
    for(int i=3 ; i<=1000000 ; ++i)a[i]=find(i-1,i)+i ;
    Scanner scanner=new Scanner(System.in);
    int caseNumber=scanner.nextInt();
    for(int cases=0 ; cases<caseNumber ; ++cases){
      int a1=scanner.nextInt();
      int a2=scanner.nextInt();
      int b1=scanner.nextInt();
      int b2=scanner.nextInt();
      BigInteger ans=new BigInteger("0");
      for(int i=a1 ; i<=a2 ; ++i){
        int up=b2 ;
        int low=a[i];
        if(b1>low)low=b1 ;
        if(low>up)continue ;
        ans=ans.add(new BigInteger(Integer.toString(up-low+1)));
      }
      for(int i=b1 ; i<=b2 ; ++i){
        int up=a2 ;
        int low=a[i];
        if(a1>low)low=a1 ;
        if(low>up)continue ;
        ans=ans.add(new BigInteger(Integer.toString(up-low+1)));
      }
      System.out.println("Case #"+(cases+1)+": "+ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   attribute a : Sequence(int);
  static   operation find( k : int, x : int) : int
  pre: true
  post: true
  activity: (     var low : int ; low := 1 ;
     var up : int ; up := k ;
     while (low < up) do (     var mid : int ; mid := (low + up) / 2 ;
     if (a[mid+1] <= x) then     low := mid + 1 ; else     up := mid ; ) ; 
     return low );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     a := Integer.subrange(1,1000001)->collect(0) ; 
     a[1+1] := 2 ; 
    a[2+1] := 4 ; 
        var i : int ; i := 3 ; while i <= 1000000 do (     a[i+1] := find(i - 1, i) + i ;  ;     i := i + 1 ) ; 
    var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var caseNumber : int ; caseNumber := scanner.getCurrent()->toInteger() ;
        var cases : int ; cases := 0 ; while cases < caseNumber do ( (     var a1 : int ; a1 := scanner.getCurrent()->toInteger() ;
     var a2 : int ; a2 := scanner.getCurrent()->toInteger() ;
    var b1 : int ; b1 := scanner.getCurrent()->toInteger() ;
    var b2 : int ; b2 := scanner.getCurrent()->toInteger() ;
    var ans : long ; ans := long("0") ;
        var i : int ; i := a1 ; while i <= a2 do ( (     var up : int ; up := b2 ;
     var low : int ; low := a[i+1] ;
    if (b1 > low) then     low := b1 ; else skip ; 
    if (low > up) then     continue else skip ; 
    ans := ans->excludes(long(((up - low + 1) + ""))) ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := b1 ; while i <= b2 do ( (     var up : int ; up := a2 ;
     var low : int ; low := a[i+1] ;
    if (a1 > low) then     low := a1 ; else skip ; 
    if (low > up) then     continue else skip ; 
    ans := ans->excludes(long(((up - low + 1) + ""))) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Case #" + (cases + 1) + ": " + ans) ; 
 )  ;     cases := cases + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class NumberGame {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new FileReader("C-large.in"));
    PrintWriter out=new PrintWriter(new BufferedWriter(new FileWriter("C.out")));
    long alow,ahigh,blow,bhigh,cases ;
    cases=Integer.parseInt(in.readLine());
    double gold=(1+Math.sqrt(5))/2 ;
    for(int i=1 ; i<=cases ; i++){
      StringTokenizer st=new StringTokenizer(in.readLine());
      alow=Integer.parseInt(st.nextToken());
      ahigh=Integer.parseInt(st.nextToken());
      blow=Integer.parseInt(st.nextToken());
      bhigh=Integer.parseInt(st.nextToken());
      long count=(ahigh-alow+1)*(bhigh-blow+1);
      for(long a=alow ; a<=ahigh ; a++){
        long low=Math.max((long)(a/gold+1),blow);
        long high=Math.min(bhigh,(long)(a*gold));
        if(low<=bhigh && high>=blow)count-=high-low+1 ;
      }
      out.println("Case #"+i+": "+count);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class NumberGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("C-large.in"))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("C.out")))) ;
    var alow : long ;
    var ahigh : long ;
    var blow : long ;
    var bhigh : long ;
    var cases : long ;
    cases := (in.readLine())->toInteger() ; 
    var gold : double ; gold := (1 + (5)->sqrt()) / 2 ;
        var i : int ; i := 1 ; while i <= cases do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(in.readLine()) ;
     alow := (st.next())->toInteger() ; 
    ahigh := (st.next())->toInteger() ; 
    blow := (st.next())->toInteger() ; 
    bhigh := (st.next())->toInteger() ; 
    var count : long ; count := (ahigh - alow + 1) * (bhigh - blow + 1) ;
        var a : long ; a := alow ; while a <= ahigh do ( (     var low : long ; low := Set{(a / gold + 1)->oclAsType(long), blow}->max() ;
     var high : long ; high := Set{bhigh, (a * gold)->oclAsType(long)}->min() ;
     if (low <= bhigh & high >= blow) then     count := count-(high - low + 1) ; else skip )  ;     a := a + 1 ) ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.util.*;
public class C {
  boolean TIME=false ;
  Scanner sc ;
  void solve(){
    int A1=sc.nextInt(),A2=sc.nextInt();
    int B1=sc.nextInt(),B2=sc.nextInt();
    long res=0 ;
    for(int b=B1 ; b<=B2 ; b++){
      int min=(int)(ceil(1.0/R*b));
      int max=(int)(floor(R*b));
      min=max(min,A1);
      max=min(max,A2);
      res+=A2-A1+1 ;
      if(min<=max){
        res-=max-min+1 ;
      }
    }
    System.out.println(res);
  }
  double R=(sqrt(5)+1)/2 ;
  void run(){
    long time=System.currentTimeMillis();
    sc=new Scanner(System.in);
    int on=sc.nextInt();
    for(int o=1 ; o<=on ; o++){
      double t=(System.currentTimeMillis()-time)*1e-3 ;
      if(TIME)System.err.printf("%03d/%03d %.3f/%.3f%n",o,on,t,t/(o-1)*on);
      System.out.printf("Case #%d: ",o);
      solve();
      System.out.flush();
    }
  }
  void debug(Object...os){
    System.err.println(deepToString(os));
  }
  public static void main(String[] args){
    new C().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
   attribute TIME : boolean := false;
   attribute sc : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     var A1 : int ; A1 := sc.getCurrent()->toInteger() ;
    var A2 : int ; A2 := sc.getCurrent()->toInteger() ;
     var B1 : int ; B1 := sc.getCurrent()->toInteger() ;
    var B2 : int ; B2 := sc.getCurrent()->toInteger() ;
    var res : long ; res := 0 ;
        var b : int ; b := B1 ; while b <= B2 do ( (     var min : int ; min := (ceil(1.0 / R * b))->oclAsType(int) ;
     var max : int ; max := (floor(R * b))->oclAsType(int) ;
    min := Set{min, A1}->max() ; 
    max := Set{max, A2}->min() ; 
    res := res+(A2 - A1 + 1) ; 
    if (min <= max) then (     res := res-(max - min + 1) ) else skip ; 
 )  ;     b := b + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
   attribute R : double := (sqrt(5) + 1) / 2;
   operation run() : void
  pre: true
  post: true
  activity: (     var time : long ; time := OclDate.getSystemTime() ;
     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var on : int ; on := sc.getCurrent()->toInteger() ;
         var o : int ; o := 1 ; while o <= on do ( (     var t : double ; t := (OclDate.getSystemTime() - time) * 1e-3 ;
     if (TIME) then     OclFile["System.err"].printf("%03d/%03d %.3f/%.3f%n", o, on, t, t / (o - 1) * on) ; else skip ; 
    OclFile["System.out"].printf("Case #%d: ", o) ; 
    execute solve() ; 
    OclFile["System.out"].flush() ; 
 )  ;     o := o + 1 ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     C.newC().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileInputStream ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class Number {
  private Scanner fin ;
  private PrintStream fout ;
  public Number(String in,String out){
    try {
      fin=new Scanner(new FileInputStream(in));
      fout=new PrintStream(out);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  private void run(){
    int cas=fin.nextInt();
    for(int t=1 ; t<=cas ; ++t){
      fout.println("Case #"+t+": "+process());
    }
  }
  private int startpos[];
  private long process(){
    int a1,a2,b1,b2 ;
    a1=fin.nextInt();
    a2=fin.nextInt();
    b1=fin.nextInt();
    b2=fin.nextInt();
    startpos=new int[a2+1];
    if(a2>=1)startpos[1]=1 ;
    if(a2>=2)startpos[2]=2 ;
    int k=1 ;
    for(int i=3 ; i<=a2 ; ++i){
      while(i>=startpos[k]+k)k++;
      startpos[i]=k ;
    }
    long res=0 ;
    for(int i=a1 ; i<=a2 ; ++i){
      res+=count(i,b1,b2);
    }
    return res ;
  }
  private long count(int id,int b1,int b2){
    long res=b2-b1+1 ;
    if(b1<startpos[id]){
      if(b2<startpos[id])return res ;
      else if(b2<startpos[id]+id){
        return res-(b2-startpos[id]+1);
      }
      else {
        return res-id ;
      }
    }
    else if(b1<startpos[id]+id){
      if(b2<startpos[id]+id){
        return 0 ;
      }
      else {
        return b2-(startpos[id]+id)+1 ;
      }
    }
    else {
      return res ;
    }
  }
  public static void main(String[] args){
    new Number("c.in","c.out").run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Number {
   attribute fin : OclFile;
   attribute fout : OclFile;
   static operation newNumber( in : String, out : String) : Number
  pre: true
  post: true
  activity:
  ( var self : Number ;
    self := createNumber();
    self.initialise(in, out);
    return self );
  operation initialise( in : String, out : String) : void
  pre: true  post: true
  activity: (     try (     fin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     fout := OclFile.newOclFile_Write(out) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
   operation run() : void
  pre: true
  post: true
  activity: (     var cas : int ; cas := fin.getCurrent()->toInteger() ;
         var t : int ; t := 1 ; while t <= cas do ( (     skip )  ;     t := t + 1 ) );
   attribute startpos : Sequence(int);
   operation process() : long
  pre: true
  post: true
  activity: (     var a1 : int ;
    var a2 : int ;
    var b1 : int ;
    var b2 : int ;
     a1 := fin.getCurrent()->toInteger() ; 
    a2 := fin.getCurrent()->toInteger() ; 
    b1 := fin.getCurrent()->toInteger() ; 
    b2 := fin.getCurrent()->toInteger() ; 
    startpos := Integer.subrange(1,a2 + 1)->collect(0) ; 
    if (a2 >= 1) then     startpos[1+1] := 1 ; else skip ; 
    if (a2 >= 2) then     startpos[2+1] := 2 ; else skip ; 
    var k : int ; k := 1 ;
        var i : int ; i := 3 ; while i <= a2 do ( (     while (i >= startpos[k+1] + k) do     k := k + 1 ; ; 
     startpos[i+1] := k )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
        var i : int ; i := a1 ; while i <= a2 do ( (     res := res+(count(i, b1, b2)) )  ;     i := i + 1 ) ; 
    return res 
 );
   operation count( id : int, b1 : int, b2 : int) : long
  pre: true
  post: true
  activity: (     var res : long ; res := b2 - b1 + 1 ;
     if (b1 < startpos[id+1]) then (     if (b2 < startpos[id+1]) then     return res else     if (b2 < startpos[id+1] + id) then (     return res - (b2 - startpos[id+1] + 1) ) else (     return res - id ) ;  ) else     if (b1 < startpos[id+1] + id) then (     if (b2 < startpos[id+1] + id) then (     return 0 ) else (     return b2 - (startpos[id+1] + id) + 1 ) ) else (     return res ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     0.0.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class VanyaAndBooks {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long[] cnt={
      0,9,90,900,9000,90000,900000,9000000,90000000,900000000 };
      long N=in.nextLong();
      int size=Long.toString(N).length();
      long ans=0 ;
      for(int i=1 ; i<size ; i++)ans+=(long)i*cnt[i];
      ans+=(long)size*(N-makeNUm(size));
      pw.println(ans);
      pw.close();
    }
    static Long makeNUm(int size){
      String s="" ;
      for(int i=1 ; i<size ; i++){
        s=s+"9" ;
      }
      try {
        return Long.parseLong(s);
      }
      catch(Exception e){
        return 0L ;
      }
    }
    static void debug(Object...obj){
      System.err.println(Arrays.deepToString(obj));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class VanyaAndBooks {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var cnt : Sequence(long) ; cnt := Sequence{0,9,90,900,9000,90000,900000,9000000,90000000,900000000} ;
    var N : long ; N := in.getCurrent()->toLong() ;
    var size : int ; size := ((N) + "")->size() ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i < size do (     ans := ans+(i->oclAsType(long) * cnt[i+1]) ;  ;     i := i + 1 ) ; 
    ans := ans+(size->oclAsType(long) * (N - makeNUm(size))) ; 
    skip ; 
    skip ; 
 );
  static   operation makeNUm( size : int) : long
  pre: true
  post: true
  activity: (     var s : String ; s := "" ;
         var i : int ; i := 1 ; while i < size do ( (     s := s + "9" )  ;     i := i + 1 ) ; 
     try (     return (s)->toLong() )   catch (e : ProgramException) do (     return 0L )
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    String str=in.next();
    if(! str.contains("7")&& ! str.contains("4")){
      pw.println(-1);
    }
    else {
      Map<Character,Integer>map=new HashMap<>();
      for(int i=0 ; i<str.length(); i++){
        if(! map.containsKey(str.charAt(i))){
          map.put(str.charAt(i),1);
        }
        else {
          map.put(str.charAt(i),map.get(str.charAt(i))+1);
        }
      }
      int c1=0,c2=0 ;
      if(str.contains("4")){
        c1=map.get('4');
      }
      if(str.contains("7")){
        c2=map.get('7');
      }
      if(c1>=c2){
        pw.println(4);
      }
      else {
        pw.println(7);
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var str : String ; str := in.getCurrent() ;
    if (not(str->includes("7")) & not(str->includes("4"))) then (     skip ) else (     var map : Map(String,int) ; map := Map{} ;
         var i : int ; i := 0 ; while i < str->size() do ( (     if (not(map->keys()->includes(str->at(i+1)))) then (     map := map->union(Map{str->at(i+1) |-> 1}) ) else (     map := map->union(Map{str->at(i+1) |-> map->at(str->at(i+1)) + 1}) ) )  ;     i := i + 1 ) ; 
    var c1 : int ; c1 := 0 ;
    var c2 : int ; c2 := 0 ;
    if (str->includes("4")) then (     c1 := map->at('4') ) else skip ; 
    if (str->includes("7")) then (     c2 := map->at('7') ) else skip ; 
    if (c1 >= c2) then (     skip ) else (     skip ) ;  
 ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    int num4=0 ;
    int num7=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='4')num4++;
      else if(s.charAt(i)=='7')num7++;
    }
    if((num4==0 & num7==0))System.out.println("-1");
    else if(num4>num7)System.out.println("4");
    else if(num7>num4)System.out.println("7");
    else System.out.println("4");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
    var num4 : int ; num4 := 0 ;
    var num7 : int ; num7 := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '4') then     num4 := num4 + 1 ; else     if (s->at(i+1) = '7') then     num7 := num7 + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    if ((num4 = 0 & num7 = 0)) then     OclFile["System.out"].println("-1") else     if (num4 > num7) then     OclFile["System.out"].println("4") else     if (num7 > num4) then     OclFile["System.out"].println("7") else     OclFile["System.out"].println("4") ; ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int A=sc.nextInt();
    int B=sc.nextInt();
    int[] arr=new int[n];
    int sumOfUnblocked=0 ;
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=sc.nextInt();
      sumOfUnblocked+=arr[i];
    }
    int[] subArr=Arrays.copyOfRange(arr,1,n);
    Arrays.sort(subArr);
    int blocks=0 ;
    int i=subArr.length-1 ;
    while(((double)arr[0]*(double)A)/(double)sumOfUnblocked<B){
      sumOfUnblocked-=subArr[i];
      i--;
      blocks++;
    }
    System.out.println(blocks);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sumOfUnblocked : int ; sumOfUnblocked := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     sumOfUnblocked := sumOfUnblocked+(arr[i+1]) )  ;     i := i + 1 ) ; 
    var subArr : Sequence(int) ; subArr := arr.subrange(1+1,n) ;
    subArr := subArr->sort() ; 
    var blocks : int ; blocks := 0 ;
    var i : int ; i := subArr->size() - 1 ;
    while ((arr[0+1]->oclAsType(double) * A->oclAsType(double)) / sumOfUnblocked->oclAsType(double) < B) do (     sumOfUnblocked := sumOfUnblocked-(subArr[i+1]) ; 
     i := i - 1 ; 
     blocks := blocks + 1 ) ; 
    OclFile["System.out"].println(blocks) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  int n ;
  int[] a ;
  void run(){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    a=new int[n];
    int[] r=new int[n],l=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    LinkedList<Integer>stack=new LinkedList<>();
    LinkedList<Integer>cnts=new LinkedList<>();
    stack.add(0);
    int cnt=1 ;
    for(int i=0 ; i<n ; i++){
      l[i]=1 ;
      while(stack.getLast()>a[i]){
        stack.removeLast();
        l[i]+=cnts.removeLast();
      }
      stack.addLast(a[i]);
      cnts.addLast(l[i]);
    }
    stack.clear();
    stack.addLast(0);
    for(int i=n-1 ; i>=0 ; i--){
      r[i]=1 ;
      while(stack.getLast()>a[i]){
        stack.removeLast();
        r[i]+=cnts.removeLast();
      }
      stack.addLast(a[i]);
      cnts.addLast(r[i]);
    }
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      ans+=1L*a[i]*l[i]*r[i];
    }
    System.out.println(ans);
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute a : Sequence(int);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
    var r : Sequence(int) ; r := Integer.subrange(1,n)->collect(0) ;
    var l : Sequence(int) ; l := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var stack : Sequence(int) ; stack := Sequence{} ;
    var cnts : Sequence(int) ; cnts := Sequence{} ;
    stack := stack->including(0) ; 
    var cnt : int ; cnt := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     l[i+1] := 1 ; 
     while (stack->last() > a[i+1]) do (     stack := stack->front() ; 
     l[i+1] := l[i+1] + cnts->last() ;     cnts := cnts->front() ) ; 
     stack := stack->append(a[i+1]) ; 
     cnts := cnts->append(l[i+1]) )  ;     i := i + 1 ) ; 
    stack := stack->intersection(Set{}) ; 
    stack := stack->append(0) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     r[i+1] := 1 ; 
     while (stack->last() > a[i+1]) do (     stack := stack->front() ; 
     r[i+1] := r[i+1] + cnts->last() ;     cnts := cnts->front() ) ; 
     stack := stack->append(a[i+1]) ; 
     cnts := cnts->append(r[i+1]) )  ;     i := i - 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans+(1L * a[i+1] * l[i+1] * r[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Watering967B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int holes=in.nextInt();
    int water=in.nextInt();
    int volume=in.nextInt();
    int arr[]=new int[holes];
    List list=new ArrayList();
    long sum=0 ;
    for(int i=0 ; i<holes ; i++){
      arr[i]=in.nextInt();
      if(i>0)list.add(arr[i]);
      sum+=arr[i];
    }
    Collections.sort(list);
    if(volume==water){
      System.out.println(holes-1);
      return ;
    }
    for(int i=0 ; i<holes-1 ; i++){
      if((water*arr[0])/sum>=volume){
        System.out.println(i);
        return ;
      }
      else sum-=(int)list.get(holes-i-2);
    }
    System.out.println('0');
  }
}
------------------------------------------------------------
OCL File:
---------
 class Watering967B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var holes : int ; holes := in.getCurrent()->toInteger() ;
    var water : int ; water := in.getCurrent()->toInteger() ;
    var volume : int ; volume := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,holes)->collect(0) ;
    var list : Sequence ; list := Sequence{} ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < holes do ( (     arr[i+1] := in.getCurrent()->toInteger() ; 
     if (i > 0) then     list := list->including(arr[i+1]) ; else skip ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    list := list->sort() ; 
    if (volume = water) then (     OclFile["System.out"].println(holes - 1) ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < holes - 1 do ( (     if ((water * arr[0+1]) / sum >= volume) then (     OclFile["System.out"].println(i) ; 
     return ) else     sum := sum-(list->at(holes - i - 2+1)->oclAsType(int)) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println('0') ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int n=input.nextInt();
    int a=input.nextInt();
    int b=input.nextInt();
    ArrayList<Long>holes=new ArrayList<>();
    Long first=new Long(input.nextInt());
    int sum=first.intValue();
    for(int i=0 ; i<n-1 ; i++){
      holes.add(new Long(input.nextInt()));
      sum+=holes.get(i);
    }
    Collections.sort(holes,Collections.reverseOrder());
    int result=0 ;
    for(Long i : holes){
      if((first*a)/sum>=b){
        break ;
      }
      else {
        sum-=i ;
        result+=1 ;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var a : int ; a := input.getCurrent()->toInteger() ;
    var b : int ; b := input.getCurrent()->toInteger() ;
    var holes : Sequence(long) ; holes := Sequence{} ;
    var first : long ; first := ("" + (input.getCurrent()->toInteger()))->toLong() ;
    var sum : int ; sum := first->oclAsType(int) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     holes := holes->including(("" + (input.getCurrent()->toInteger()))->toLong()) ; 
     sum := sum+(holes->at(i+1)) )  ;     i := i + 1 ) ; 
    holes, reverseOrder() := holes, reverseOrder()->sort() ; 
    var result : int ; result := 0 ;
    for (i : holes) do ( (     if ((first * a) / sum >= b) then (     break ) else (     sum := sum-(i) ; 
     result := result+(1) ) )  ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int no_of_ways(int a[],int n){
    int count_0=0,count_1=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]==0)count_0++;
      else count_1++;
    }
    if(count_1 % 2==0)return count_0 ;
    else return count_1 ;
  }
  public static void main(String[] args){
    int n=4 ;
    int a1[]={
      1,1,0,0 };
      System.out.println(no_of_ways(a1,n));
      n=5 ;
      int a2[]={
        1,1,1,0,0 };
        System.out.println(no_of_ways(a2,n));
        n=5 ;
        int a3[]={
          1,1,0,0,0 };
          System.out.println(no_of_ways(a3,n));
          n=6 ;
          int a4[]={
            1,1,1,0,0,0 };
            System.out.println(no_of_ways(a4,n));
          }
        }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation no_of_ways( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count_0 : int ; count_0 := 0 ;
    var count    var count    var count_0 :  ; count_0 := 0 :  ; count    var count_0 :  ; count_0 := 0 := 0 : int ; count    var count    var count_0 :  ; count_0 := 0 :  ; count    var count_0 :  ; count_0 := 0 := 0 := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = 0) then     count_0 := count_0 + 1 ; else     countcountcount    if (a[i+1] = 0) then     count_0 := count_0 + 1 else     countcountcount    if (a[i+1] = 0) then     count_0 := count_0 + 1 else     countcountcount_1 := countcountcount_1 + 1 ; ;  
 := countcountcount    if (a[i+1] = 0) then     count_0 := count_0 + 1 else     countcountcount_1 := countcountcount_1 + 1 ; ;  
 + 1 ; ;  := countcountcount    if (a[i+1] = 0) then     count_0 := count_0 + 1 else     countcountcount    if (a[i+1] = 0) then     count_0 := count_0 + 1 else     countcountcount_1 := countcountcount_1 + 1 ; ;  
 := countcountcount    if (a[i+1] = 0) then     count_0 := count_0 + 1 else     countcountcount_1 := countcountcount_1 + 1 ; ;  
 + 1 ; ;  + 1 ; )  ;     i := i + 1 ) ; 
     if (count    if (count    var count_0 : int ; count_0 := 0 ;
    var count    var count    var count_0 :  ; count_0 := 0 :  ; count    var count_0 :  ; count_0 := 0 := 0 : int ; count    var count    var count_0 :  ; count_0 := 0 :  ; count    var count_0 :  ; count_0 := 0 := 0 := 0 ;
 mod 2 = 0) then     return count_0 else     return count    var count_0 : int ; count_0 := 0 ;
    var count    var count    var count_0 :  ; count_0 := 0 :  ; count    var count_0 :  ; count_0 := 0 := 0 : int ; count    var count    var count_0 :  ; count_0 := 0 :  ; count    var count_0 :  ; count_0 := 0 := 0 := 0 ;
 ;  mod 2 = 0) then     return count_0 else     return count    if (count    var count_0 : int ; count_0 := 0 ;
    var count    var count    var count_0 :  ; count_0 := 0 :  ; count    var count_0 :  ; count_0 := 0 := 0 : int ; count    var count    var count_0 :  ; count_0 := 0 :  ; count    var count_0 :  ; count_0 := 0 := 0 := 0 ;
 mod 2 = 0) then     return count_0 else     return count    var count_0 : int ; count_0 := 0 ;
    var count    var count    var count_0 :  ; count_0 := 0 :  ; count    var count_0 :  ; count_0 := 0 := 0 : int ; count    var count    var count_0 :  ; count_0 := 0 :  ; count    var count_0 :  ; count_0 := 0 := 0 := 0 ;
 ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     var a1 : Sequence(int) ; a1 := Sequence{1,1,0,0} ;
    OclFile["System.out"].println(no_of_ways(a1, n)) ; 
    n := 5 ; 
    var a2 : Sequence(int) ; a2 := Sequence{1,1,1,0,0} ;
    OclFile["System.out"].println(no_of_ways(a2, n)) ; 
    n := 5 ; 
    var a3 : Sequence(int) ; a3 := Sequence{1,1,0,0,0} ;
    OclFile["System.out"].println(no_of_ways(a3, n)) ; 
    n := 6 ; 
    var a4 : Sequence(int) ; a4 := Sequence{1,1,1,0,0,0} ;
    OclFile["System.out"].println(no_of_ways(a4, n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.HashMap ;
import java.util.Map ;
class GFG {
  static void distinctAdjacentElement(int a[],int n){
    HashMap<Integer,Integer>m=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; ++i){
      if(m.containsKey(a[i])){
        int x=m.get(a[i])+1 ;
        m.put(a[i],x);
      }
      else {
        m.put(a[i],1);
      }
    }
    int mx=0 ;
    for(int i=0 ; i<n ; ++i)if(mx<m.get(a[i]))mx=m.get(a[i]);
    if(mx>(n+1)/2)System.out.println("NO");
    else System.out.println("YES");
  }
  public static void main(String[] args){
    int a[]={
      7,7,7,7 };
      int n=4 ;
      distinctAdjacentElement(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation distinctAdjacentElement( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var m : Map(int,int) ; m := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (m->keys()->includes(a[i+1])) then (     var x : int ; x := m->at(a[i+1]) + 1 ;
     m := m->union(Map{a[i+1] |-> x}) ) else (     m := m->union(Map{a[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var mx : int ; mx := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (mx < m->at(a[i+1])) then     mx := m->at(a[i+1]) ; else skip ;  ;     i := i + 1 ) ; 
    if (mx > (n + 1) / 2) then     OclFile["System.out"].println("NO") else     OclFile["System.out"].println("YES") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{7,7,7,7} ;
     var n : int ; n := 4 ;
     execute distinctAdjacentElement(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int[] sortedSquares(int[] A){
    int pos=0 ;
    int[] res=new int[A.length];
    int curr=0 ;
    while(pos<A.length && A[pos]<0)pos++;
    int npos=pos-1 ;
    while(pos<A.length && npos>=0){
      if(A[pos]*A[pos]<A[npos]*A[npos]){
        res[curr++]=A[pos]*A[pos];
        pos++;
      }
      else {
        res[curr++]=A[npos]*A[npos];
        npos--;
      }
    }
    while(npos>=0){
      res[curr++]=A[npos]*A[npos];
      npos--;
    }
    while(pos<A.length){
      res[curr++]=A[pos]*A[pos];
      pos++;
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation sortedSquares( A : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var pos : int ; pos := 0 ;
     var res : Sequence(int) ; res := Integer.subrange(1,A->size())->collect(0) ;
    var curr : int ; curr := 0 ;
    while (pos < A->size() & A[pos+1] < 0) do     pos := pos + 1 ; ; 
    var npos : int ; npos := pos - 1 ;
    while (pos < A->size() & npos >= 0) do (     if (A[pos+1] * A[pos+1] < A[npos+1] * A[npos+1]) then (      res[curr+1] := A[pos+1] * A[pos+1]  ; curr := curr + 1 ; 
     pos := pos + 1 ) else (      res[curr+1] := A[npos+1] * A[npos+1]  ; curr := curr + 1 ; 
     npos := npos - 1 ) ) ; 
    while (npos >= 0) do (      res[curr+1] := A[npos+1] * A[npos+1]  ; curr := curr + 1 ; 
     npos := npos - 1 ) ; 
    while (pos < A->size()) do (      res[curr+1] := A[pos+1] * A[pos+1]  ; curr := curr + 1 ; 
     pos := pos + 1 ) ; 
    return res 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getSteps(int arr[],int n){
    int count=0 ;
    int modulus[]=new int[4];
    int sum=0 ;
    int i ;
    for(i=0 ; i<n ; i++){
      int mod=arr[i] % 4 ;
      sum+=mod ;
      modulus[mod]++;
    }
    if(sum % 4!=0){
      return-1 ;
    }
    else {
      if(modulus[1]>modulus[3]){
        count+=modulus[3];
      }
      else {
        count+=modulus[1];
      }
      modulus[1]-=count ;
      modulus[3]-=count ;
      modulus[2]+=modulus[1]/2 ;
      modulus[2]+=modulus[3]/2 ;
      count+=modulus[1]/2 ;
      count+=modulus[3]/2 ;
      count+=modulus[2]/2 ;
      return count ;
    }
  }
  public static void main(String[] args){
    int n=7 ;
    int arr[]={
      1,2,3,1,2,3,8 };
      int count=getSteps(arr,n);
      System.out.printf("%d",count);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getSteps( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var modulus : Sequence(int) ; modulus := Integer.subrange(1,4)->collect(0) ;
    var sum : int ; sum := 0 ;
    var i : int ;
        i := 0 ; while i < n do ( (     var mod : int ; mod := arr[i+1] mod 4 ;
     sum := sum+(mod) ; 
     modulus[mod+1] := modulus[mod+1] + 1 )  ;     i := i + 1 ) ; 
    if (sum mod 4 /= 0) then (     return -1 ) else (     if (modulus[1+1] > modulus[3+1]) then (     count := count+(modulus[3+1]) ) else (     count := count+(modulus[1+1]) ) ;  
     modulus[1+1] := modulus[1+1]-(count) ; 
    modulus[3+1] := modulus[3+1]-(count) ; 
    modulus[2+1] := modulus[2+1]+(modulus[1+1] / 2) ; 
    modulus[2+1] := modulus[2+1]+(modulus[3+1] / 2) ; 
    count := count+(modulus[1+1] / 2) ; 
    count := count+(modulus[3+1] / 2) ; 
    count := count+(modulus[2+1] / 2) ; 
    return count 
 ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     var arr : Sequence(int) ; arr := Sequence{1,2,3,1,2,3,8} ;
     var count : int ; count := getSteps(arr, n) ;
     OclFile["System.out"].printf("%d", count) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void sub_segments(String str,int n){
    int l=str.length();
    for(int x=0 ; x<l ; x+=n){
      String newlist=str.substring(x,x+n);
      List<Character>arr=new ArrayList<Character>();
      for(char y : newlist.toCharArray()){
        if(! arr.contains(y))arr.add(y);
      }
      for(char y : arr)System.out.print(y);
      System.out.println();
    }
  }
  public static void main(String[] args){
    String str="geeksforgeeksgfg" ;
    int n=4 ;
    sub_segments(str,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sub_segments( str : String, n : int) : void
  pre: true
  post: true
  activity: (     var l : int ; l := str->size() ;
         var x : int ; x := 0 ; while x < l do ( (     var newlist : String ; newlist := str.subrange(x+1,x + n) ;
     var arr : Sequence(String) ; arr := Sequence{} ;
    for (y : newlist->characters()) do ( (     if (not(arr->includes(y))) then     arr := arr->including(y) ; else skip )  ) ; 
    for (y : arr) do (     OclFile["System.out"].print(y) ;  ) ; 
    OclFile["System.out"].println() ; 
 )  ;     x := x+(n) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeksgfg" ;
     var n : int ; n := 4 ;
     execute sub_segments(str, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      double sum=0 ;
      int tt=1 ;
      double q=9 ;
      while(n>0){
        sum+=Math.min(q,n)*tt ;
        n-=q ;
        q*=10 ;
        tt++;
      }
      out.printf("%.0f",sum);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    boolean hasNext(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(Exception e){
          return false ;
        }
      }
      return true ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      String str=null ;
      try {
        str=reader.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public BigInteger nextBigInteger(){
      return new BigInteger(next());
    }
    public BigDecimal nextBigDecimal(){
      return new BigDecimal(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var sum : double ; sum := 0 ;
    var tt : int ; tt := 1 ;
    var q : double ; q := 9 ;
    while (n > 0) do (     sum := sum+(Set{q, n}->min() * tt) ; 
     n := n-(q) ; 
     q := q*(10) ; 
     tt := tt + 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : ProgramException) do (     return false )
 ) ; 
     return true );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := null ;
     try (     str := reader.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextBigInteger() : long
  pre: true
  post: true
  activity: (     return long(next()) );
   operation nextBigDecimal() : double
  pre: true
  post: true
  activity: (     return double(next()) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.Vector ;
class GFG {
  static int MinRemove(int[] a,int n,int k){
    int[] cnt=new int[n];
    for(int i=0 ; i<n ; i++){
      if(a[i]==0)cnt[0]++;
      else if(cnt[a[i]-1]>0){
        cnt[a[i]-1]--;
        cnt[a[i] ]++;
      }
    }
    return n-(k*cnt[k-1]);
  }
  public static void main(String[] args){
    int a[]={
      0,1,2,3,4,0,1,0,1,2,3,4 };
      int k=5 ;
      int n=a.length ;
      System.out.println(MinRemove(a,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MinRemove( a : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var cnt : Sequence(int) ; cnt := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = 0) then     cnt[0+1] := cnt[0+1] + 1 ; else     if (cnt[a[i+1] - 1+1] > 0) then (     cnt[a[i+1] - 1+1] := cnt[a[i+1] - 1+1] - 1 ; 
     cnt[a[i+1]+1] := cnt[a[i+1]+1] + 1 ) else skip ; )  ;     i := i + 1 ) ; 
     return n - (k * cnt[k - 1+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{0,1,2,3,4,0,1,0,1,2,3,4} ;
     var k : int ; k := 5 ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(MinRemove(a, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int SquareCube(long N){
    int cnt=0,i=1 ;
    while((int)(Math.pow(i,6))<=N){
++cnt ;
++i ;
    }
    return cnt ;
  }
  public static void main(String[] args){
    long N=100000 ;
    System.out.println(SquareCube(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation SquareCube( N : long) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
    var i : int ; i := 1 ;
     while ((i->pow(6))->oclAsType(int) <= N) do (     cnt := cnt + 1 ; 
     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := 100000 ;
     OclFile["System.out"].println(SquareCube(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int N=10000 ;
  static int MOD=1000000007 ;
  static int[] F=new int[N];
  static void precompute(){
    F[1]=2 ;
    F[2]=3 ;
    F[3]=4 ;
    for(int i=4 ; i<N ; i++)F[i]=(F[i-1]+F[i-2])% MOD ;
  }
  public static void main(String[] args){
    int n=8 ;
    precompute();
    System.out.println(F[n]);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 10000;
  static   attribute MOD : int := 1000000007;
  static   attribute F : Sequence(int) := Integer.subrange(1,N)->collect(0);
  static   operation precompute() : void
  pre: true
  post: true
  activity: (     F[1+1] := 2 ; 
     F[2+1] := 3 ; 
     F[3+1] := 4 ; 
         var i : int ; i := 4 ; while i < N do (     F[i+1] := (F[i - 1+1] + F[i - 2+1]) mod MOD ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     execute precompute() ; 
     OclFile["System.out"].println(F[n+1]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int h=in.nextInt(),w=in.nextInt();
    char[][] map=new char[h][w];
    in.nextLine();
    for(int i=0 ; i<h ; i++){
      map[i]=in.nextLine().toCharArray();
    }
    in.close();
    int[][] hmap=new int[h][w];
    int[][] vmap=new int[h][w];
    int cnt=0 ;
    for(int r=0 ; r<h ; r++){
      for(int c=0 ; c<w ; c++){
        cnt=0 ;
        while(c+cnt<w && map[r][c+cnt]=='.'){
          cnt++;
        }
        for(int i=c ; i<c+cnt ; i++){
          hmap[r][i]=cnt ;
        }
        c+=cnt ;
      }
    }
    for(int c=0 ; c<w ; c++){
      for(int r=0 ; r<h ; r++){
        cnt=0 ;
        while(r+cnt<h && map[r+cnt][c]=='.'){
          cnt++;
        }
        for(int i=r ; i<r+cnt ; i++){
          vmap[i][c]=cnt ;
        }
        r+=cnt ;
      }
    }
    int ans=0 ;
    for(int r=0 ; r<h ; r++){
      for(int c=0 ; c<w ; c++){
        ans=Math.max(ans,hmap[r][c]+vmap[r][c]-1);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := in.getCurrent()->toInteger() ;
    var w : int ; w := in.getCurrent()->toInteger() ;
    var map : Sequence(Sequence(String)) ; map := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    skip ; 
        var i : int ; i := 0 ; while i < h do ( (     map[i+1] := in.nextLine()->characters() )  ;     i := i + 1 ) ; 
    skip ; 
    var hmap : Sequence(Sequence(int)) ; hmap := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    var vmap : Sequence(Sequence(int)) ; vmap := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
    var cnt : int ; cnt := 0 ;
        var r : int ; r := 0 ; while r < h do ( (         var c : int ; c := 0 ; while c < w do ( (     cnt := 0 ; 
     while (c + cnt < w & map[r+1][c + cnt+1] = '.') do (     cnt := cnt + 1 ) ; 
         var i : int ; i := c ; while i < c + cnt do ( (     hmap[r+1][i+1] := cnt )  ;     i := i + 1 ) ; 
     c := c+(cnt) )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
        var c : int ; c := 0 ; while c < w do ( (         var r : int ; r := 0 ; while r < h do ( (     cnt := 0 ; 
     while (r + cnt < h & map[r + cnt+1][c+1] = '.') do (     cnt := cnt + 1 ) ; 
         var i : int ; i := r ; while i < r + cnt do ( (     vmap[i+1][c+1] := cnt )  ;     i := i + 1 ) ; 
     r := r+(cnt) )  ;     r := r + 1 ) )  ;     c := c + 1 ) ; 
    var ans : int ; ans := 0 ;
        var r : int ; r := 0 ; while r < h do ( (         var c : int ; c := 0 ; while c < w do ( (     ans := Set{ans, hmap[r+1][c+1] + vmap[r+1][c+1] - 1}->max() )  ;     c := c + 1 ) )  ;     r := r + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void primeFactors(int n,int freq[]){
    int cnt=0 ;
    while(n % 2==0){
      cnt++;
      n=n/2 ;
    }
    freq[2]=cnt ;
    for(int i=3 ; i<=Math.sqrt(n); i=i+2){
      cnt=0 ;
      while(n % i==0){
        cnt++;
        n=n/i ;
      }
      freq[i]=cnt ;
    }
    if(n>2)freq[n]=1 ;
  }
  static int getMaximumPower(int n,int m){
    int freq1[]=new int[n+1],freq2[]=new int[m+1];
    primeFactors(n,freq1);
    primeFactors(m,freq2);
    int maxi=0 ;
    for(int i=2 ; i<=m ; i++){
      if(freq1[i]==0 && freq2[i]==0)continue ;
      if(freq2[i]>freq1[i])return 0 ;
      if(freq2[i]!=0){
        maxi=Math.max(maxi,freq1[i]/freq2[i]);
      }
    }
    return maxi ;
  }
  public static void main(String[] args){
    int n=48,m=4 ;
    System.out.println(getMaximumPower(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation primeFactors( n : int, freq : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     while (n mod 2 = 0) do (     cnt := cnt + 1 ; 
     n := n / 2 ) ; 
    freq[2+1] := cnt ; 
        var i : int ; i := 3 ; while i <= (n)->sqrt() do ( (     cnt := 0 ; 
     while (n mod i = 0) do (     cnt := cnt + 1 ; 
     n := n / i ) ; 
     freq[i+1] := cnt )  ;     i := i + 2 ) ; 
    if (n > 2) then     freq[n+1] := 1 ; else skip ; 
 );
  static   operation getMaximumPower( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var freq1 : Sequence(int) ; freq1 := Integer.subrange(1,n + 1)->collect(0) ;
    var freq2 : Sequence(void) ; freq2 := Integer.subrange(1,m + 1)->collect(0) ;
     execute primeFactors(n, freq1) ; 
    execute primeFactors(m, freq2) ; 
    var maxi : int ; maxi := 0 ;
        var i : int ; i := 2 ; while i <= m do ( (     if (freq1[i+1] = 0 & freq2[i+1] = 0) then     continue else skip ; 
     if (freq2[i+1] > freq1[i+1]) then     return 0 else skip ; 
     if (freq2[i+1] /= 0) then (     maxi := Set{maxi, freq1[i+1] / freq2[i+1]}->max() ) else skip )  ;     i := i + 1 ) ; 
    return maxi 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 48 ;
    var m : int ; m := 4 ;
     OclFile["System.out"].println(getMaximumPower(n, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX_COUNT=10000 ;
  static List<String>vec=new LinkedList<String>();
  static void generateNumbersUtil(){
    Queue<String>q=new LinkedList<String>();
    q.add("9");
    for(int count=MAX_COUNT ; count>0 ; count--){
      String s1=q.peek();
      q.remove();
      vec.add(s1);
      String s2=s1 ;
      q.add(s1+"0");
      q.add(s2+"9");
    }
  }
  static String findSmallestMultiple(int n){
    for(int i=0 ; i<vec.size(); i++){
      if(Integer.parseInt(vec.get(i))% n==0){
        return vec.get(i);
      }
    }
    return "" ;
  }
  public static void main(String[] args){
    generateNumbersUtil();
    int n=7 ;
    System.out.println(findSmallestMultiple(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX_COUNT : int := 10000;
  static   attribute vec : Sequence(String) := Sequence{};
  static   operation generateNumbersUtil() : void
  pre: true
  post: true
  activity: (     var q : Sequence(String) ; q := Sequence{} ;
     q := q->including("9") ; 
         var count : int ; count := MAX_COUNT ; while count > 0 do ( (     var s1 : String ; s1 := q->min() ;
     q := q.remove() ; 
    vec := vec->including(s1) ; 
    var s2 : String ; s2 := s1 ;
    q := q->including(s1 + "0") ; 
    q := q->including(s2 + "9") ; 
 )  ;     count := count - 1 ) );
  static   operation findSmallestMultiple( n : int) : String
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < vec->size() do ( (     if ((vec->at(i+1))->toInteger() mod n = 0) then (     return vec->at(i+1) ) else skip )  ;     i := i + 1 ) ; 
     return "" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute generateNumbersUtil() ; 
     var n : int ; n := 7 ;
     OclFile["System.out"].println(findSmallestMultiple(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPrime(int p){
    double checkNumber=Math.pow(2,p)-1 ;
    double nextval=4 % checkNumber ;
    for(int i=1 ; i<p-1 ; i++)nextval=(nextval*nextval-2)% checkNumber ;
    return(nextval==0);
  }
  public static void main(String[] args){
    int p=7 ;
    double checkNumber=Math.pow(2,p)-1 ;
    if(isPrime(p))System.out.println((int)checkNumber+" is Prime.");
    else System.out.println((int)checkNumber+" is not Prime.");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( p : int) : boolean
  pre: true
  post: true
  activity: (     var checkNumber : double ; checkNumber := 2->pow(p) - 1 ;
     var nextval : double ; nextval := 4 mod checkNumber ;
         var i : int ; i := 1 ; while i < p - 1 do (     nextval := (nextval * nextval - 2) mod checkNumber ;  ;     i := i + 1 ) ; 
     return (nextval = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p : int ; p := 7 ;
     var checkNumber : double ; checkNumber := 2->pow(p) - 1 ;
     if (isPrime(p)) then     OclFile["System.out"].println(checkNumber->oclAsType(int) + " is Prime.") ; else     OclFile["System.out"].println(checkNumber->oclAsType(int) + " is not Prime.") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Solution {
  static PrintWriter pw ;
  static FastScanner s ;
  public static void main(String[] args)throws Exception {
    pw=new PrintWriter(System.out);
    s=new FastScanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int num=s.nextInt();
      int temp=num ;
      int count=0 ;
      while(temp>0){
        count++;
        temp=temp/10 ;
      }
      int value=(int)Math.pow(10,count-1);
      pw.println(num-value);
    }
    pw.flush();
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public FastScanner(String s)throws Exception {
    br=new BufferedReader(new FileReader(new File(s)));
  }
  public String next()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(next());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute pw : OclFile;
  static   attribute s : FastScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     pw := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     s := FastScanner.newFastScanner(OclFile["System.in"]) ; 
    var t : int ; t := s.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var num : int ; num := s.nextInt() ;
     var temp : int ; temp := num ;
    var count : int ; count := 0 ;
    while (temp > 0) do (     count := count + 1 ; 
     temp := temp / 10 ) ; 
    var value : int ; value := 10->pow(count - 1)->oclAsType(int) ;
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test206 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int x=in.nextInt();
      int a=(int)Math.log10(x);
      x-=Math.pow(10,a);
      System.out.println(x);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test206 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     var a : int ; a := (x)->log10()->oclAsType(int) ;
     x := x-(10->pow(a)) ; 
     OclFile["System.out"].println(x) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Application {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int m=sc.nextInt();
      int l=(int)Math.log10(m);
      System.out.println(m-((int)Math.pow(10,l)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Application {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var m : int ; m := sc.getCurrent()->toInteger() ;
     var l : int ; l := (m)->log10()->oclAsType(int) ;
     OclFile["System.out"].println(m - (10->pow(l)->oclAsType(int))) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Codesolver {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<Integer>ar=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      ar.add(sc.nextInt());
    }
    Collections.sort(ar);
    int sum=0 ;
    for(Integer integer : ar){
      sum=sum+integer ;
    }
    int sum2=0 ;
    for(int i=0 ; i<n ; i++){
      sum2=sum2+ar.get(n-i-1);
      sum=sum-ar.get(n-i-1);
      if(sum2>sum){
        System.out.println(i+1);
        break ;
      }
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codesolver {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ar : Sequence(int) ; ar := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     ar := ar->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    ar := ar->sort() ; 
    var sum : int ; sum := 0 ;
    for (integer : ar) do ( (     sum := sum + integer )  ) ; 
    var sum2 : int ; sum2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum2 := sum2 + ar->at(n - i - 1+1) ; 
     sum := sum - ar->at(n - i - 1+1) ; 
     if (sum2 > sum) then (     OclFile["System.out"].println(i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long input=sc.nextInt();
    test(input);
  }
  public static void test(long input){
    String temp=String.valueOf(input);
    long len=temp.length();
    long value=Integer.parseInt(temp);
    long result=0 ;
    long x=9999999999l ;
    if(len==1){
      value-=0 ;
      Math.abs(value);
      System.out.println(value);
    }
    else if(len==2){
      value=(9-value)*2 ;
      System.out.println(Math.abs(value)+9);
    }
    else if(len==3){
      value=(99-value)*3 ;
      System.out.println(Math.abs(value)+180+9);
    }
    else if(len==4){
      value=(999-value)*4 ;
      System.out.println(Math.abs(value)+2889);
    }
    else if(len==5){
      value=(9999-value)*5 ;
      System.out.println(Math.abs(value)+38889);
    }
    else if(len==6){
      value=(99999-value)*6 ;
      System.out.println(Math.abs(value)+488889);
    }
    else if(len==7){
      value=(999999-value)*7 ;
      System.out.println(Math.abs(value)+5888889);
    }
    else if(len==8){
      value=(9999999-value)*8 ;
      System.out.println(Math.abs(value)+68888889);
    }
    else if(len==9){
      value=(99999999-value)*9 ;
      System.out.println(Math.abs(value)+788888889);
    }
    else if(len==10){
      value=(999999999-value)*10 ;
      System.out.println(Math.abs(value)+8888888889l);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : long ; input := sc.getCurrent()->toInteger() ;
     execute test(input) );
  static   operation test( input : long) : void
  pre: true
  post: true
  activity: (     var temp : String ; temp := ((input) + "") ;
     var len : long ; len := temp->size() ;
    var value : long ; value := (temp)->toInteger() ;
    var result : long ; result := 0 ;
    var x : long ; x := 9999999999l ;
    if (len = 1) then (     value := value-(0) ; 
     Math.abs(value) ; 
     OclFile["System.out"].println(value) ) else     if (len = 2) then (     value := (9 - value) * 2 ; 
     OclFile["System.out"].println(if value < 0 then -(value) else value endif + 9) ) else     if (len = 3) then (     value := (99 - value) * 3 ; 
     OclFile["System.out"].println(if value < 0 then -(value) else value endif + 180 + 9) ) else     if (len = 4) then (     value := (999 - value) * 4 ; 
     OclFile["System.out"].println(if value < 0 then -(value) else value endif + 2889) ) else     if (len = 5) then (     value := (9999 - value) * 5 ; 
     OclFile["System.out"].println(if value < 0 then -(value) else value endif + 38889) ) else     if (len = 6) then (     value := (99999 - value) * 6 ; 
     OclFile["System.out"].println(if value < 0 then -(value) else value endif + 488889) ) else     if (len = 7) then (     value := (999999 - value) * 7 ; 
     OclFile["System.out"].println(if value < 0 then -(value) else value endif + 5888889) ) else     if (len = 8) then (     value := (9999999 - value) * 8 ; 
     OclFile["System.out"].println(if value < 0 then -(value) else value endif + 68888889) ) else     if (len = 9) then (     value := (99999999 - value) * 9 ; 
     OclFile["System.out"].println(if value < 0 then -(value) else value endif + 788888889) ) else     if (len = 10) then (     value := (999999999 - value) * 10 ; 
     OclFile["System.out"].println(if value < 0 then -(value) else value endif + 8888888889l) ) else skip ; ;  ;  ;  ;  ;  ;  ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int i=in.nextInt();
    int[] coins=new int[i];
    while(i--!=0)coins[i]=in.nextInt();
    in.close();
    Arrays.sort(coins);
    int sum=0 ;
    for(int coin : coins)sum+=coin ;
    int mine=0,cnt=0 ;
    while(mine<=sum-mine){
      cnt++;
      mine+=coins[coins.length-cnt];
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ; i := in.getCurrent()->toInteger() ;
    var coins : Sequence(int) ; coins := Integer.subrange(1,i)->collect(0) ;
        while (i /= 0) do (    skip ;     coins[i+1] := in.getCurrent()->toInteger() ; ;  ) ;  
    skip ; 
    coins := coins->sort() ; 
    var sum : int ; sum := 0 ;
    for (coin : coins) do (     sum := sum+(coin) ;  ) ; 
    var mine : int ; mine := 0 ;
    var cnt : int ; cnt := 0 ;
    while (mine <= sum - mine) do (     cnt := cnt + 1 ; 
     mine := mine+(coins[coins->size() - cnt+1]) ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int minimumCost(int cost[],int n){
    int dp1=0,dp2=0 ;
    for(int i=0 ; i<n ; i++){
      int dp0=cost[i]+Math.min(dp1,dp2);
      dp2=dp1 ;
      dp1=dp0 ;
    }
    return Math.min(dp1,dp2);
  }
  public static void main(String args[]){
    int a[]={
      2,5,3,1,7,3,4 };
      int n=a.length ;
      System.out.print(minimumCost(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumCost( cost : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var dp1 : int ; dp1 := 0 ;
    var dp2 : int ; dp2 := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var dp0 : int ; dp0 := cost[i+1] + Set{dp1, dp2}->min() ;
     dp2 := dp1 ; 
     dp1 := dp0 )  ;     i := i + 1 ) ; 
     return Set{dp1, dp2}->min() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,5,3,1,7,3,4} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(minimumCost(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class prog1 {
  static int solve(int a[],int n){
    int total=0 ;
    for(int i : a)total+=i ;
    total=total/2 ;
    Arrays.sort(a);
    int sum=0 ;
    int c=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      sum+=a[i];
      c++;
      if(sum>total){
        return c ;
      }
    }
    return c ;
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    int ans=solve(a,n);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class prog1 {
  static   operation solve( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var total : int ; total := 0 ;
     for (i : a) do (     total := total+(i) ;  ) ; 
    total := total / 2 ; 
    a := a->sort() ; 
    var sum : int ; sum := 0 ;
    var c : int ; c := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     sum := sum+(a[i+1]) ; 
     c := c + 1 ; 
     if (sum > total) then (     return c ) else skip )  ;     i := i - 1 ) ; 
    return c 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := solve(a, n) ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class twins {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int[] arr=new int[a];
    int sum=0 ;
    int sum1=0 ;
    for(int k=0 ; k<a ; k++){
      arr[k]=sc.nextInt();
    }
    for(int i=0 ; i<a ; i++){
      for(int j=i+1 ; j<a ; j++){
        int tmp=0 ;
        if(arr[i]>arr[j]){
          tmp=arr[i];
          arr[i]=arr[j];
          arr[j]=tmp ;
        }
      }
    }
    int y=0 ;
    for(int g=0 ; g<a ; g++){
      sum+=arr[g];
    }
    int half=sum/2 ;
    for(int f=a-1 ; f>=0 ; f--){
      sum1+=arr[f];
      y++;
      if(sum1>half){
        System.out.println(y);
        break ;
      }
      else if(sum1==half){
        System.out.println(y+1);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class twins {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,a)->collect(0) ;
    var sum : int ; sum := 0 ;
    var sum1 : int ; sum1 := 0 ;
        var k : int ; k := 0 ; while k < a do ( (     arr[k+1] := sc.getCurrent()->toInteger() )  ;     k := k + 1 ) ; 
        var i : int ; i := 0 ; while i < a do ( (         var j : int ; j := i + 1 ; while j < a do ( (     var tmp : int ; tmp := 0 ;
     if (arr[i+1] > arr[j+1]) then (     tmp := arr[i+1] ; 
     arr[i+1] := arr[j+1] ; 
     arr[j+1] := tmp ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var y : int ; y := 0 ;
        var g : int ; g := 0 ; while g < a do ( (     sum := sum+(arr[g+1]) )  ;     g := g + 1 ) ; 
    var half : int ; half := sum / 2 ;
        var f : int ; f := a - 1 ; while f >= 0 do ( (     sum1 := sum1+(arr[f+1]) ; 
     y := y + 1 ; 
     if (sum1 > half) then (     OclFile["System.out"].println(y) ; 
     break ) else     if (sum1 = half) then (     OclFile["System.out"].println(y + 1) ; 
     break ) else skip ; )  ;     f := f - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String s=in.next();
    int sum1[]=new int[n];
    int sum2[]=new int[n];
    for(int i=0 ; i<s.length(); i++){
      if(i>0){
        sum1[i]=sum1[i-1];
        sum2[i]=sum2[i-1];
      }
      if(s.charAt(i)=='<')sum1[i]++;
      else sum2[i]++;
    }
    int ans=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='<'){
        if(i==0 || sum2[i-1]==0)ans++;
      }
      else {
        if(i==s.length()-1 || sum1[n-1]-sum1[i]==0)ans++;
      }
    }
    System.out.println(ans);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var sum1 : Sequence(int) ; sum1 := Integer.subrange(1,n)->collect(0) ;
    var sum2 : Sequence(int) ; sum2 := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (i > 0) then (     sum1[i+1] := sum1[i - 1+1] ; 
     sum2[i+1] := sum2[i - 1+1] ) else skip ; 
     if (s->at(i+1) = '<') then     sum1[i+1] := sum1[i+1] + 1 ; else     sum2[i+1] := sum2[i+1] + 1 ; )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '<') then (     if (i = 0 or sum2[i - 1+1] = 0) then     ans := ans + 1 ; else skip ) else (     if (i = s->size() - 1 or sum1[n - 1+1] - sum1[i+1] = 0) then     ans := ans + 1 ; else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Answer solver=new Answer();
    solver.solve(in,out);
    out.close();
  }
}
class Answer {
  private final int INF=(int)(1e9+7);
  public void solve(InputReader in,PrintWriter out)throws IOException {
    int n=in.nextInt();
    String s=in.next();
    int i=0 ;
    while(i<n && s.charAt(i)=='<'){
      i++;
    }
    int j=n-1 ;
    while(j>=0 && s.charAt(j)=='>'){
      j--;
    }
    int ans=i+n-j-1 ;
    out.print(ans);
  }
}
class InputReader {
  private BufferedReader reader ;
  private StringTokenizer tokenizer ;
  InputReader(InputStream stream){
    reader=new BufferedReader(new InputStreamReader(stream),32768);
    tokenizer=null ;
  }
  public String next(){
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        tokenizer=new StringTokenizer(reader.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Answer ; solver := Answer.newAnswer() ;
    solver.solve(in, out) ; 
    skip ; 
 );
}
class Answer {
   attribute INF : int := (1e9 + 7)->oclAsType(int);
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var s : String ; s := in.next() ;
    var i : int ; i := 0 ;
    while (i < n & s->at(i+1) = '<') do (     i := i + 1 ) ; 
    var j : int ; j := n - 1 ;
    while (j >= 0 & s->at(j+1) = '>') do (     j := j - 1 ) ; 
    var ans : int ; ans := i + n - j - 1 ;
    skip ; 
 );
}
class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class bucky {
  private int contor=0 ;
  public static void main(String args[]){
    Scanner input=new Scanner(System.in);
    HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();
    HashMap<Integer,Integer>start=new HashMap<Integer,Integer>();
    HashMap<Integer,Integer>finish=new HashMap<Integer,Integer>();
    HashMap<Integer,Integer>maxime=new HashMap<Integer,Integer>();
    int n=input.nextInt();
    String str=input.next();
    int result=0 ;
    int poza=-1 ;
    int pozb=-1 ;
    int x=0 ;
    int y=0 ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)=='>' && x==0){
        poza=i ;
        x=1 ;
      }
      if(str.charAt(i)=='<')pozb=i ;
    }
    if(poza==-1 || pozb==-1)result=n ;
    else result=poza+n-pozb-1 ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class bucky {
   attribute contor : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var map : Map(int,int) ; map := Map{} ;
    var start : Map(int,int) ; start := Map{} ;
    var finish : Map(int,int) ; finish := Map{} ;
    var maxime : Map(int,int) ; maxime := Map{} ;
    var n : int ; n := input.getCurrent()->toInteger() ;
    var str : String ; str := input.getCurrent() ;
    var result : int ; result := 0 ;
    var poza : int ; poza := -1 ;
    var pozb : int ; pozb := -1 ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '>' & x = 0) then (     poza := i ; 
     x := 1 ) else skip ; 
     if (str->at(i+1) = '<') then     pozb := i ; else skip )  ;     i := i + 1 ) ; 
    if (poza = -1 or pozb = -1) then     result := n else     result := poza + n - pozb - 1 ; ;  
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import org.w3c.dom.ls.LSInput ;
import java.io.*;
import java.util.*;
import java.io.IOException ;
import java.io.InputStream ;
import java.util.jar.Attributes ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      String s=in.next();
      int f=0 ;
      for(int i=0 ; i<n ; i++){
        if(s.charAt(i)=='<'){
          f++;
        }
        else break ;
      }
      for(int i=n-1 ; i>=0 ; i--){
        if(s.charAt(i)=='>'){
          f++;
        }
        else break ;
      }
      System.out.println(f);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var s : String ; s := in.next() ;
    var f : int ; f := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = '<') then (     f := f + 1 ) else     break )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (s->at(i+1) = '>') then (     f := f + 1 ) else     break )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(f) ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static void vowelOrConsonant(char x){
    if(x=='a' || x=='e' || x=='i' || x=='o' || x=='u' || x=='A' || x=='E' || x=='I' || x=='O' || x=='U')System.out.println("Vowel");
    else System.out.println("Consonant");
  }
  static public void main(String[] args){
    vowelOrConsonant('c');
    vowelOrConsonant('E');
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation vowelOrConsonant( x : String) : void
  pre: true
  post: true
  activity: (     if (x = 'a' or x = 'e' or x = 'i' or x = 'o' or x = 'u' or x = 'A' or x = 'E' or x = 'I' or x = 'O' or x = 'U') then     OclFile["System.out"].println("Vowel") ; else     OclFile["System.out"].println("Consonant") ; );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute vowelOrConsonant('c') ; 
     execute vowelOrConsonant('E') );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Deque ;
import java.util.LinkedList ;
public class PrintAllPalindrome {
  public static void main(String[] args){
    String input="nitin" ;
    System.out.println("All possible palindrome"+"partions for "+input+" are :");
    allPalPartitions(input);
  }
  private static void allPalPartitions(String input){
    int n=input.length();
    ArrayList<ArrayList<String>>allPart=new ArrayList<>();
    Deque<String>currPart=new LinkedList<String>();
    allPalPartitonsUtil(allPart,currPart,0,n,input);
    for(int i=0 ; i<allPart.size(); i++){
      for(int j=0 ; j<allPart.get(i).size(); j++){
        System.out.print(allPart.get(i).get(j)+" ");
      }
      System.out.println();
    }
  }
  private static void allPalPartitonsUtil(ArrayList<ArrayList<String>>allPart,Deque<String>currPart,int start,int n,String input){
    if(start>=n){
      allPart.add(new ArrayList<>(currPart));
      return ;
    }
    for(int i=start ; i<n ; i++){
      if(isPalindrome(input,start,i)){
        currPart.addLast(input.substring(start,i+1));
        allPalPartitonsUtil(allPart,currPart,i+1,n,input);
        currPart.removeLast();
      }
    }
  }
  private static boolean isPalindrome(String input,int start,int i){
    while(start<i){
      if(input.charAt(start++)!=input.charAt(i--))return false ;
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class PrintAllPalindrome {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : String ; input := "nitin" ;
     OclFile["System.out"].println("All possible palindrome" + "partions for " + input + " are :") ; 
     execute allPalPartitions(input) );
  static   operation allPalPartitions( input : String) : void
  pre: true
  post: true
  activity: (     var n : int ; n := input->size() ;
     var allPart : Sequence(Sequence(String)) ; allPart := Sequence{} ;
    var currPart : Sequence(String) ; currPart := Sequence{} ;
    execute allPalPartitonsUtil(allPart, currPart, 0, n, input) ; 
        var i : int ; i := 0 ; while i < allPart->size() do ( (         var j : int ; j := 0 ; while j < allPart->at(i+1)->size() do ( (     OclFile["System.out"].print(allPart->at(i+1)->at(j+1) + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
  static   operation allPalPartitonsUtil( allPart : Sequence(Sequence(String)), currPart : Sequence(String), start : int, n : int, input : String) : void
  pre: true
  post: true
  activity: (     if (start >= n) then (     allPart := allPart->including(Sequence{}->union(currPart)) ; 
     return ) else skip ; 
         var i : int ; i := start ; while i < n do ( (     if (isPalindrome(input, start, i)) then (     currPart := currPart->append(input.subrange(start+1,i + 1)) ; 
     execute allPalPartitonsUtil(allPart, currPart, i + 1, n, input) ; 
     currPart := currPart->front() ) else skip )  ;     i := i + 1 ) );
  static   operation isPalindrome( input : String, start : int, i : int) : boolean
  pre: true
  post: true
  activity: (     while (start < i) do (     if (input->at(start+1) /= input->at(i+1)) then     return false else skip ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Doors {
  int number ;
  public Doors(int number){
    this.number=number ;
  }
  public void input(String s){
    boolean ba=true ;
    for(int i=0 ; i<s.length(); i++){
      boolean b=false ;
      if(s.charAt(i)>97){
        continue ;
      }
      else {
        int str=s.charAt(i);
        b=true ;
        for(int k=i ; k>=0 ; k--){
          int strCheck=s.charAt(k);
          if(str==strCheck-32){
            b=false ;
            break ;
          }
        }
      }
      if(b==true){
        ba=false ;
        break ;
      }
    }
    if(ba==false){
      System.out.println("NO");
    }
    else {
      System.out.println("YES");
    }
  }
  public int getNumber(){
    return number ;
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    Doors instance=new Doors(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      String s=input.next();
      instance.input(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Doors {
   attribute number : int;
   static operation newDoors( number : int) : Doors
  pre: true
  post: true
  activity:
  ( var self : Doors ;
    self := createDoors();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
   operation input( s : String) : void
  pre: true
  post: true
  activity: (     var ba : boolean ; ba := true ;
         var i : int ; i := 0 ; while i < s->size() do ( (     var b : boolean ; b := false ;
     if (s->at(i+1) > 97) then (     continue ) else (     var str : int ; str := s->at(i+1) ;
     b := true ; 
         var k : int ; k := i ; while k >= 0 do ( (     var strCheck : int ; strCheck := s->at(k+1) ;
     if (str = strCheck - 32) then (     b := false ; 
     break ) else skip )  ;     k := k - 1 ) ) ;  
     if (b = true) then (     ba := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (ba = false) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
     var instance : Doors ; instance := Doors.newDoors(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var s : String ; s := input.getCurrent() ;
     instance.input(s) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void checkArray(int a[],int b[],int n){
    int operations=0 ;
    int i=0 ;
    while(i<n){
      if(a[i]-b[i]==0){
        i++;
        continue ;
      }
      int diff=a[i]-b[i];
      i++;
      while(i<n && a[i]-b[i]==diff){
        i++;
      }
      operations++;
    }
    System.out.println(operations);
  }
  public static void main(String[] args){
    int a[]={
      3,7,1,4,1,2 };
      int b[]={
        3,7,3,6,3,2 };
        int size=a.length ;
        checkArray(a,b,size);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkArray( a : Sequence(int), b : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var operations : int ; operations := 0 ;
     var i : int ; i := 0 ;
     while (i < n) do (     if (a[i+1] - b[i+1] = 0) then (     i := i + 1 ; 
     continue ) else skip ; 
     var diff : int ; diff := a[i+1] - b[i+1] ;
    i := i + 1 ; 
    while (i < n & a[i+1] - b[i+1] = diff) do (     i := i + 1 ) ; 
    operations := operations + 1 ; 
 ) ; 
     OclFile["System.out"].println(operations) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{3,7,1,4,1,2} ;
     var b : Sequence(int) ; b := Sequence{3,7,3,6,3,2} ;
     var size : int ; size := a->size() ;
     execute checkArray(a, b, size) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.util.Scanner sc,java.io.PrintStream out){
    final int[] d=new int[1001];
    for(int i=1 ; i<=1000 ; ++i)d[i]=d[i-1]+i ;
    for(; ; ){
      final int N=sc.nextInt();
      if(N==0)break ;
      int res=0 ;
      for(int i=0 ; i<=1000 ; ++i)for(int j=i+2 ; j<=1000 ; ++j){
        if(d[j]-d[i]==N)++res ;
      }
      out.println(res);
    }
  }
  public static void main(String[] args){
(new Main()).run(new java.util.Scanner(System.in),System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( sc : Scanner, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var d : Sequence(int) ; d := Integer.subrange(1,1001)->collect(0) ;
         var i : int ; i := 1 ; while i <= 1000 do (     d[i+1] := d[i - 1+1] + i ;  ;     i := i + 1 ) ; 
       while true do ( (     var N : int ; N := sc.nextInt() ;
     if (N = 0) then     break else skip ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i <= 1000 do (         var j : int ; j := i + 2 ; while j <= 1000 do ( (     if (d[j+1] - d[i+1] = N) then     res := res + 1 ; else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    out.println(res) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(Scanner.newScanner(OclFile["System.in"]), OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DoorsAndKeys {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int testCase=Integer.parseInt(input.nextLine());
    for(int i=0 ; i<testCase ; i++){
      String map=input.nextLine();
      if(map.indexOf("R")<map.indexOf("r")|| map.indexOf("G")<map.indexOf("g")|| map.indexOf("B")<map.indexOf("b"))System.out.println("NO");
      else System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DoorsAndKeys {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCase : int ; testCase := (input.nextLine())->toInteger() ;
         var i : int ; i := 0 ; while i < testCase do ( (     var map : String ; map := input.nextLine() ;
     if (map->indexOf("R")-1 < map->indexOf("r")-1 or map->indexOf("G")-1 < map->indexOf("g")-1 or map->indexOf("B")-1 < map->indexOf("b")-1) then     OclFile["System.out"].println("NO") ; else     OclFile["System.out"].println("YES") ; )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder();
    int t=fs.nextInt();
    while(t-->0){
      Set<Character>set=new HashSet<>();
      String s=fs.next();
      boolean res=true ;
      for(int i=0 ; i<6 ; i++){
        if(s.charAt(i)=='b' || s.charAt(i)=='g' || s.charAt(i)=='r')set.add(s.charAt(i));
        else {
          char ch=Character.toLowerCase(s.charAt(i));
          if(! set.contains(ch)){
            res=false ;
            break ;
          }
        }
      }
      sb.append(res ? "YES" : "NO").append("\n");
    }
    out.print(sb);
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    var t : int ; t := fs.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var set : Set(String) ; set := Set{} ;
     var s : String ; s := fs.next() ;
    var res : boolean ; res := true ;
        var i : int ; i := 0 ; while i < 6 do ( (     if (s->at(i+1) = 'b' or s->at(i+1) = 'g' or s->at(i+1) = 'r') then     set := set->including(s->at(i+1)) ; else (     var ch : String ; ch := (s->at(i+1) + "")->toLowerCase() ;
     if (not(set->includes(ch))) then (     res := false ; 
     break ) else skip ) )  ;     i := i + 1 ) ; 
    sb := sb + StringLib.newString(if res then "YES" else "NO" endif) + StringLib.newString("\n") ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test265 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      boolean a[]=new boolean[3];
      boolean y=false ;
      char x[]=in.next().toCharArray();
      for(int i=0 ; i<6 ; i++){
        switch(x[i]){
          case 'r' : a[0]=true ;
          break ;
          case 'g' : a[1]=true ;
          break ;
          case 'b' : a[2]=true ;
          break ;
          case 'R' : if(! a[0]){
            y=true ;
          }
          break ;
          case 'G' : if(! a[1]){
            y=true ;
          }
          break ;
          default : if(! a[2]){
            y=true ;
          }
        }
        if(y){
          break ;
        }
      }
      if(y){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test265 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var a : Sequence(boolean) ; a := Integer.subrange(1,3)->collect(false) ;
     var y : boolean ; y := false ;
    var x : Sequence(String) ; x := in.getCurrent()->characters() ;
        var i : int ; i := 0 ; while i < 6 do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (x[i+1]) ; 
       if _switchval = 'r' then
     a[0+1] := true ; 
    break 
   else skip ;
       if _switchval = 'g' then
     a[1+1] := true ; 
    break 
   else skip ;
       if _switchval = 'b' then
     a[2+1] := true ; 
    break 
   else skip ;
       if _switchval = 'R' then
     if (not(a[0+1])) then (     y := true ) else skip ; 
    break 
   else skip ;
       if _switchval = 'G' then
     if (not(a[1+1])) then (     y := true ) else skip ; 
    break 
   else skip ;
       if true then
     if (not(a[2+1])) then (     y := true ) else skip ; 
   else skip ;
 )
     if (y) then (     break ) else skip )  ;     i := i + 1 ) ; 
    if (y) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long nextFibonacci(int n){
    double a=n*(1+Math.sqrt(5))/2.0 ;
    return Math.round(a);
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(nextFibonacci(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nextFibonacci( n : int) : long
  pre: true
  post: true
  activity: (     var a : double ; a := n * (1 + (5)->sqrt()) / 2.0 ;
     return (a)->round() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(nextFibonacci(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public List<List<Integer>>shiftGrid(int[][] grid,int k){
    int[][] newGrid=new int[grid.length][grid[0] .length];
    int m=grid.length ;
    int n=grid[0] .length ;
    int true_k=k %(m*n);
    int move_i=true_k/n ;
    int move_j=true_k % n ;
    for(int i=0 ; i<grid.length ; i++){
      for(int j=0 ; j<grid[i] .length ; j++){
        int new_i=i+move_i ;
        int new_j=(j+move_j)% n ;
        if(move_j+j>=n)new_i++;
        new_i %=m ;
        newGrid[new_i][new_j]=grid[i][j];
      }
    }
    List<List<Integer>>result=new ArrayList<>();
    for(int[] row : newGrid){
      List<Integer>listRow=new ArrayList<>();
      result.add(listRow);
      for(int v : row)listRow.add(v);
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation shiftGrid( grid : Sequence(Sequence(int)), k : int) : Sequence(Sequence(int))
  pre: true
  post: true
  activity: (     var newGrid : Sequence(Sequence(int)) ; newGrid := Integer.subrange(1,grid->size())->collect(Integer.subrange(1,grid[0+1]->size())->collect(0)) ;
     var m : int ; m := grid->size() ;
    var n : int ; n := grid[0+1]->size() ;
    var true_k : int ; true_k := k mod (m * n) ;
    var move_i : int ; move_i := true_k / n ;
    var move_j : int ; move_j := true_k mod n ;
        var i : int ; i := 0 ; while i < grid->size() do ( (         var j : int ; j := 0 ; while j < grid[i+1]->size() do ( (     var new_i : int ; new_i := i + move_i ;
     var new_j : int ; new_j := (j + move_j) mod n ;
    if (move_j + j >= n) then     new_i := new_i + 1 ; else skip ; 
    new_i := new_i mod m ; 
    newGrid[new_i+1][new_j+1] := grid[i+1][j+1] ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var result : Sequence(Sequence(int)) ; result := Sequence{} ;
    for (row : newGrid) do ( (     var listRow : Sequence(int) ; listRow := Sequence{} ;
     result := result->including(listRow) ; 
     for (v : row) do (     listRow := listRow->including(v) ;  ) )  ) ; 
    return result 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static void printMatrix(float mat[][]){
    for(int i=0 ; i<mat.length ; i++){
      for(int j=0 ; j<mat[i] .length ; j++)System.out.print(mat[i][j]+"   ");
      System.out.println();
    }
  }
  static void printDistribution(float mat[][]){
    int N=mat.length ;
    float[][] tr=new float[N][N];
    for(int i=0 ; i<N ; i++)for(int j=0 ; j<N ; j++)tr[i][j]=mat[j][i];
    float[][] symm=new float[N][N];
    float[][] skewsymm=new float[N][N];
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        symm[i][j]=(mat[i][j]+tr[i][j])/2 ;
        skewsymm[i][j]=(mat[i][j]-tr[i][j])/2 ;
      }
    }
    System.out.println("Symmetric matrix-");
    printMatrix(symm);
    System.out.println("Skew Symmetric matrix-");
    printMatrix(skewsymm);
  }
  public static void main(String[] args){
    float mat[][]={
      {
        2,-2,-4 },{
-1,3,4 },{
            1,-2,-3 }
          };
          printDistribution(mat);
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printMatrix( mat : Sequence(Sequence(double))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < mat->size() do ( (         var j : int ; j := 0 ; while j < mat[i+1]->size() do (     OclFile["System.out"].print(mat[i+1][j+1] + "   ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation printDistribution( mat : Sequence(Sequence(double))) : void
  pre: true
  post: true
  activity: (     var N : int ; N := mat->size() ;
     var tr : Sequence(Sequence(double)) ; tr := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < N do (         var j : int ; j := 0 ; while j < N do (     tr[i+1][j+1] := mat[j+1][i+1] ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var symm : Sequence(Sequence(double)) ; symm := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0.0)) ;
    var skewsymm : Sequence(Sequence(double)) ; skewsymm := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     symm[i+1][j+1] := (mat[i+1][j+1] + tr[i+1][j+1]) / 2 ; 
     skewsymm[i+1][j+1] := (mat[i+1][j+1] - tr[i+1][j+1]) / 2 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Symmetric matrix-") ; 
    execute printMatrix(symm) ; 
    OclFile["System.out"].println("Skew Symmetric matrix-") ; 
    execute printMatrix(skewsymm) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(double)) ; mat := Sequence{Sequence{2,-2,-4},Sequence{-1,3,4},Sequence{1,-2,-3}} ;
     execute printDistribution(mat) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public void run(){
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      calc(n);
    }
  }
  public void calc(int n){
    String before=sc.next();
    int min=-1000010000 ;
    int max=1000010000 ;
    int breakflug=0 ;
    for(int i=1 ; i<n ; i++){
      String s=sc.next();
      if(breakflug==0){
        if(s.equals("x")){
          if(before.equals("x")){
            min=0 ;
            max=0 ;
            breakflug=1 ;
          }
          else if(i % 2==0){
            int b=Integer.parseInt(before);
            if(b<max){
              max=b ;
            }
          }
          else {
            int b=Integer.parseInt(before);
            if(b>min){
              min=b ;
            }
          }
        }
        else {
          int a=Integer.parseInt(s);
          if(before.equals("x")){
            if(i % 2==0){
              if(a>min){
                min=a ;
              }
            }
            else {
              if(a<max){
                max=a ;
              }
            }
          }
          else {
            int b=Integer.parseInt(before);
            if(i % 2==0){
              if(b<=a){
                min=0 ;
                max=0 ;
                breakflug=1 ;
              }
            }
            else {
              if(b>=a){
                min=0 ;
                max=0 ;
                breakflug=1 ;
              }
            }
          }
        }
      }
      before=s ;
    }
    if(max-min<2){
      System.out.println("none");
    }
    else if(max-min==2){
      System.out.println(max-1);
    }
    else {
      System.out.println("ambiguous");
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
     execute calc(n) ) );
   operation calc( n : int) : void
  pre: true
  post: true
  activity: (     var before : String ; before := sc.getCurrent() ;
     var min : int ; min := -1000010000 ;
    var max : int ; max := 1000010000 ;
    var breakflug : int ; breakflug := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     var s : String ; s := sc.getCurrent() ;
     if (breakflug = 0) then (     if (s = "x") then (     if (before = "x") then (     min := 0 ; 
     max := 0 ; 
     breakflug := 1 ) else     if (i mod 2 = 0) then (     var b : int ; b := (before)->toInteger() ;
     if (b < max) then (     max := b ) else skip ) else (     var b : int ; b := (before)->toInteger() ;
     if (b > min) then (     min := b ) else skip ) ;  ) else (     var a : int ; a := (s)->toInteger() ;
     if (before = "x") then (     if (i mod 2 = 0) then (     if (a > min) then (     min := a ) else skip ) else (     if (a < max) then (     max := a ) else skip ) ) else (     var b : int ; b := (before)->toInteger() ;
     if (i mod 2 = 0) then (     if (b <= a) then (     min := 0 ; 
     max := 0 ; 
     breakflug := 1 ) else skip ) else (     if (b >= a) then (     min := 0 ; 
     max := 0 ; 
     breakflug := 1 ) else skip ) ) ) ) else skip ; 
     before := s )  ;     i := i + 1 ) ; 
    if (max - (min)->char2byte() < 2) then (     OclFile["System.out"].println("none") ) else     if (max - (min)->char2byte() = 2) then (     OclFile["System.out"].println(max - 1) ) else (     OclFile["System.out"].println("ambiguous") ) ;  ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static void main(String[] args){
    double cm,meter,kilometer ;
    cm=1000 ;
    meter=cm/100.0 ;
    kilometer=cm/100000.0 ;
    System.out.println("Length in meter="+meter+"m");
    System.out.println("Length in Kilometer="+kilometer+"km");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cm : double ;
    var meter : double ;
    var kilometer : double ;
     cm := 1000 ; 
    meter := cm / 100.0 ; 
    kilometer := cm / 100000.0 ; 
    OclFile["System.out"].println("Length in meter=" + meter + "m") ; 
    OclFile["System.out"].println("Length in Kilometer=" + kilometer + "km") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  private static int[] A=new int[2000001];
  private static int size=0 ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    for(; ; ){
      String[] instruction=br.readLine().split(" ");
      String str=instruction[0];
      if(str.equals("end")){
        break ;
      }
      if(str.equals("insert")){
        size++;
        int num=Integer.parseInt(instruction[1]);
        A[size]=num ;
        int i=size ;
        while(i>1 && A[i/2]<A[i]){
          swap(i,i/2);
          i/=2 ;
        }
      }
      else if(str.equals("extract")){
        int max=A[1];
        A[1]=0 ;
        swap(1,size);
        size--;
        maxHeapify(1);
        System.out.println(max);
      }
    }
  }
  public static void maxHeapify(int i){
    int l=i*2 ;
    int r=i*2+1 ;
    int large ;
    if(l<=size && A[l]>A[i])large=l ;
    else large=i ;
    if(r<=size && A[r]>A[large])large=r ;
    if(large!=i){
      swap(i,large);
      maxHeapify(large);
    }
  }
  public static void swap(int i,int j){
    int temp=A[i];
    A[i]=A[j];
    A[j]=temp ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute A : Sequence(int) := Integer.subrange(1,2000001)->collect(0);
  static   attribute size : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
       while true do ( (     var instruction : Sequence(String) ; instruction := br.readLine()->split(" ") ;
     var str : String ; str := instruction[0+1] ;
     if (str = "end") then (     break ) else skip ; 
     if (str = "insert") then (     size := size + 1 ; 
     var num : int ; num := (instruction[1+1])->toInteger() ;
    A[size+1] := num ; 
    var i : int ; i := size ;
    while (i > 1 & A[i / 2+1] < A[i+1]) do (     execute swap(i, i / 2) ; 
     i := i/(2) ) ; 
 ) else     if (str = "extract") then (     var max : int ; max := A[1+1] ;
     A[1+1] := 0 ; 
    execute swap(1, size) ; 
    size := size - 1 ; 
    execute maxHeapify(1) ; 
    OclFile["System.out"].println(max) ; 
 ) else skip ; )  ) );
  static   operation maxHeapify( i : int) : void
  pre: true
  post: true
  activity: (     var l : int ; l := i * 2 ;
     var r : int ; r := i * 2 + 1 ;
    var large : int ;
    if (l <= size & A[l+1] > A[i+1]) then     large := l else     large := i ; ;  
    if (r <= size & A[r+1] > A[large+1]) then     large := r ; else skip ; 
    if (large /= i) then (     execute swap(i, large) ; 
     execute maxHeapify(large) ) else skip ; 
 );
  static   operation swap( i : int, j : int) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := A[i+1] ;
     A[i+1] := A[j+1] ; 
     A[j+1] := temp );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  class PriorityQueue {
    private int len ;
    private List<Long>queArr ;
    public PriorityQueue(){
      len=0 ;
      queArr=new ArrayList<>();
    }
    public void insert(long val){
      len++;
      queArr.add(val);
      int currIx=len-1 ;
      while(currIx>0){
        int parIx=(currIx-1)/2 ;
        if(queArr.get(parIx)<val){
          queArr.set(currIx,queArr.get(parIx));
          currIx=parIx ;
        }
        else {
          break ;
        }
      }
      queArr.set(currIx,val);
    }
    public long extract(){
      long ans=queArr.get(0);
      queArr.set(0,queArr.get(len-1));
      queArr.remove(len-1);
      len--;
      if(len==0)return ans ;
      int currIx=0 ;
      long desVal=queArr.get(0);
      while(currIx*2+1<len){
        int leftChild=currIx*2+1,rightChild=currIx*2+2 ;
        if(rightChild<len && queArr.get(rightChild)>queArr.get(leftChild)){
          leftChild=rightChild ;
        }
        if(desVal>=queArr.get(leftChild))break ;
        queArr.set(currIx,queArr.get(leftChild));
        currIx=leftChild ;
      }
      queArr.set(currIx,desVal);
      return ans ;
    }
  }
  public Main(Scanner sc){
    PriorityQueue que=new PriorityQueue();
    while(true){
      String str=sc.next();
      if(str.equals("insert")){
        long val=sc.nextLong();
        que.insert(val);
      }
      else if(str.equals("extract")){
        long val=que.extract();
        System.out.println(val);
      }
      else if(str.equals("end")){
        break ;
      }
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Main m=new Main(sc);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class PriorityQueue {
   attribute len : int;
   attribute queArr : Sequence(long);
   static operation newPriorityQueue() : PriorityQueue
  pre: true
  post: true
  activity:
  ( var self : PriorityQueue ;
    self := createPriorityQueue();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     len := 0 ; 
     queArr := Sequence{} );
   operation insert( val : long) : void
  pre: true
  post: true
  activity: (     len := len + 1 ; 
     queArr := queArr->including(val) ; 
    var currIx : int ; currIx := len - 1 ;
    while (currIx > 0) do (     var parIx : int ; parIx := (currIx - 1) / 2 ;
     if (queArr->at(parIx+1) < val) then (     queArr := queArr.setAt(currIx+1,queArr->at(parIx+1)) ; 
     currIx := parIx ) else (     break ) ) ; 
    queArr := queArr.setAt(currIx+1,val) ; 
 );
   operation extract() : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := queArr->at(0+1) ;
     queArr := queArr.setAt(0+1,queArr->at(len - 1+1)) ; 
    queArr := queArr->excludingFirst(len - 1) ; 
    len := len - 1 ; 
    if (len = 0) then     return ans else skip ; 
    var currIx : int ; currIx := 0 ;
    var desVal : long ; desVal := queArr->at(0+1) ;
    while (currIx * 2 + 1 < len) do (     var leftChild : int ; leftChild := currIx * 2 + 1 ;
    var rightChild : int ; rightChild := currIx * 2 + 2 ;
     if (rightChild < len & queArr->at(rightChild+1) > queArr->at(leftChild+1)) then (     leftChild := rightChild ) else skip ; 
    if (desVal >= queArr->at(leftChild+1)) then     break else skip ; 
    queArr := queArr.setAt(currIx+1,queArr->at(leftChild+1)) ; 
    currIx := leftChild ; 
 ) ; 
    queArr := queArr.setAt(currIx+1,desVal) ; 
    return ans 
 );
}
   static operation newMain( sc : OclFile) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(sc);
    return self );
  operation initialise( sc : OclFile) : void
  pre: true  post: true
  activity: (     var que : Sequence ; que := Sequence{} ;
     while (true) do (     var str : String ; str := sc.next() ;
     if (str = "insert") then (     var val : long ; val := sc.nextLong() ;
     que := que.insert(val) ) else     if (str = "extract") then (     var val : long ; val := que.extract() ;
     OclFile["System.out"].println(val) ) else     if (str = "end") then (     break ) else skip ; ;  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : Main ; m := Main.newMain(sc) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
public class Main {
  public static void main(String[] args){
    while(true){
      int m=nextInt();
      if(m==0){
        break ;
      }
      int sum=1 ;
      int pattern=0 ;
      for(int j=2 ; j<50 ; j++){
        sum+=j ;
        if((m-sum)<0){
          System.out.println(pattern);
          break ;
        }
        else if((m-sum)% j==0){
          pattern++;
        }
      }
    }
  }
  static int nextInt(){
    int c ;
    try {
      c=System.in.read();
      while(c!='-' &&(c<'0' || c>'9'))c=System.in.read();
      if(c=='-')return-nextInt();
      int res=0 ;
      while(c>='0' && c<='9'){
        res=res*10+c-'0' ;
        c=System.in.read();
      }
      return res ;
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var m : int ; m := nextInt() ;
     if (m = 0) then (     break ) else skip ; 
    var sum : int ; sum := 1 ;
    var pattern : int ; pattern := 0 ;
        var j : int ; j := 2 ; while j < 50 do ( (     sum := sum+(j) ; 
     if ((m - sum) < 0) then (     OclFile["System.out"].println(pattern) ; 
     break ) else     if ((m - sum) mod j = 0) then (     pattern := pattern + 1 ) else skip ; )  ;     j := j + 1 ) ; 
 ) );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     var c : int ;
     try (     c := OclFile["System.in"].read() ; 
     while (c /= '-' & (c < '0' or c > '9')) do     c := OclFile["System.in"].read() ; ; 
    if (c = '-') then     return -nextInt() else skip ; 
    var res : int ; res := 0 ;
    while (c >= '0' & c <= '9') do (     res := res * 10 + c - ('0')->char2byte() ; 
     c := OclFile["System.in"].read() ) ; 
    return res 
 )   catch (e : IOException) do (     e.printStackTrace() )
     return -1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static String printVertically(String s){
    String result="" ;
    HashMap<Integer,String>map=new HashMap<>();
    Scanner sc=new Scanner(s);
    int max=Integer.MIN_VALUE ;
    while(sc.hasNext()){
      String st=sc.next();
      max=Math.max(max,st.length());
    }
    sc=new Scanner(s);
    while(sc.hasNext()){
      String st=sc.next();
      for(int i=0 ; i<st.length(); i++){
        char ch=st.charAt(i);
        map.put(i,map.getOrDefault(i,"")+ch);
      }
      for(int i=st.length(); i<max ; i++){
        map.put(i,map.getOrDefault(i,"")+"$");
      }
    }
    for(int i=0 ; i<max ; i++){
      String a=map.get(i);
      result+=a+" " ;
    }
    return result ;
  }
  public static void main(String[] args){
    String st="ge ek sfor ge eks" ;
    System.out.println(printVertically(st));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printVertically( s : String) : String
  pre: true
  post: true
  activity: (     var result : String ; result := "" ;
     var map : Map(int,String) ; map := Map{} ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(s) ;
    var max : int ; max := -2147483648 ;
    while (sc.hasNext()) do (     var st : String ; st := sc.getCurrent() ;
     max := Set{max, st->size()}->max() ) ; 
    sc := OclFile.newOclFile_Read(s) ; 
    while (sc.hasNext()) do (     var st : String ; st := sc.getCurrent() ;
         var i : int ; i := 0 ; while i < st->size() do ( (     var ch : String ; ch := st->at(i+1) ;
     map := map->union(Map{i |-> (if map->keys()->contains(i) then map->at(i) else "" endif) + ch}) )  ;     i := i + 1 ) ; 
         var i : int ; i := st->size() ; while i < max do ( (     map := map->union(Map{i |-> (if map->keys()->contains(i) then map->at(i) else "" endif) + "$"}) )  ;     i := i + 1 ) ) ; 
        var i : int ; i := 0 ; while i < max do ( (     var a : String ; a := map->at(i) ;
     result := result+(a + " ") )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var st : String ; st := "ge ek sfor ge eks" ;
     OclFile["System.out"].println(printVertically(st)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    P_queue S=new P_queue();
    while(true){
      String order=sc.next();
      if(order.equals("insert"))S.insert(sc.nextLong());
      else if(order.equals("extract"))System.out.println(S.extract());
      else break ;
    }
  }
}
class P_queue {
  long num[];
  int n=0 ;
  P_queue(){
    num=new long[2000010];
  }
  void insert(long k){
    num[++n]=k ;
    int i=n ;
    while(i>1){
      if(num[i/2]<=num[i]){
        long tmp=num[i/2];
        num[i/2]=num[i];
        num[i]=tmp ;
        i/=2 ;
      }
      else break ;
    }
  }
  long extract(){
    long ans=num[1];
    num[1]=num[n--];
    int i=1 ;
    while(true){
      int x=2*i ;
      if(2*i+1<=n){
        if(num[x]<=num[x+1])x++;
      }
      else if(2*i>n)break ;
      if(num[i]<num[x]){
        long tmp=num[i];
        num[i]=num[x];
        num[x]=tmp ;
        i=x ;
      }
      else break ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : P_queue ; S := P_queue.newP_queue() ;
     while (true) do (     var order : String ; order := sc.getCurrent() ;
     if (order = "insert") then     S := S.insertAt(sc.getCurrent()->toLong()+1, StringLib.newString()) ; else     if (order = "extract") then     OclFile["System.out"].println(S.extract()) else     break ;  ) );
}
class P_queue {
   attribute num : Sequence(long);
   attribute n : int := 0;
   static operation newP_queue() : P_queue
  pre: true
  post: true
  activity:
  ( var self : P_queue ;
    self := createP_queue();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     num := Integer.subrange(1,2000010)->collect(0) );
   operation insert( k : long) : void
  pre: true
  post: true
  activity: (         n := n + 1 ;
 num[n+1] := k  ; 
     var i : int ; i := n ;
     while (i > 1) do (     if (num[i / 2+1] <= num[i+1]) then (     var tmp : long ; tmp := num[i / 2+1] ;
     num[i / 2+1] := num[i+1] ; 
     num[i+1] := tmp ; 
     i := i/(2) ) else     break ) );
   operation extract() : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := num[1+1] ;
      num[1+1] := num[n+1]  ; n := n - 1 ; 
    var i : int ; i := 1 ;
    while (true) do (     var x : int ; x := 2 * i ;
     if (2 * i + 1 <= n) then (     if (num[x+1] <= num[x + 1+1]) then     x := x + 1 ; else skip ) else     if (2 * i > n) then     break else skip ; ;  
     if (num[i+1] < num[x+1]) then (     var tmp : long ; tmp := num[i+1] ;
     num[i+1] := num[x+1] ; 
     num[x+1] := tmp ; 
     i := x ) else     break ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static final int MAX=2000000 ;
  static int p=0 ;
  static int[] h=new int[MAX+1];
  ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      String order=sc.next();
      if(order.startsWith("i")){
        insert(sc.nextInt());
      }
      else if(order.startsWith("ex")){
        System.out.println(heapExtractMax());
      }
      else {
        break ;
      }
    }
  }
  static void insert(int key){
    p++;
    h[p]=Integer.MIN_VALUE ;
    heapIncreaseKey(p,key);
  }
  static void heapIncreaseKey(int i,int key){
    if(key<h[i]){
    }
    h[i]=key ;
    while(i>1 && h[i/2]<h[i]){
      int temp=h[i];
      h[i]=h[i/2];
      h[i/2]=temp ;
      i=i/2 ;
    }
  }
  static int heapExtractMax(){
    if(p<1){
    }
    int max=h[1];
    h[1]=h[p];
    p--;
    maxHeapify(h,1);
    return max ;
  }
  static int l(int i){
    return 2*i ;
  }
  static int r(int i){
    return 2*i+1 ;
  }
  static void maxHeapify(int[] h,int idx){
    int n=p ;
    int l=l(idx);
    int r=r(idx);
    int maxNodeIdx=0 ;
    if(l<=n && h[l]>h[idx]){
      maxNodeIdx=l ;
    }
    else {
      maxNodeIdx=idx ;
    }
    if(r<=n && h[r]>h[maxNodeIdx]){
      maxNodeIdx=r ;
    }
    if(maxNodeIdx!=idx){
      int temp=h[idx];
      h[idx]=h[maxNodeIdx];
      h[maxNodeIdx]=temp ;
      maxHeapify(h,maxNodeIdx);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 2000000;
  static   attribute p : int := 0;
  static   attribute h : Sequence(int) := Integer.subrange(1,MAX + 1)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var order : String ; order := sc.getCurrent() ;
     if (order->hasPrefix("i")) then (     execute insert(sc.getCurrent()->toInteger()) ) else     if (order->hasPrefix("ex")) then (     OclFile["System.out"].println(heapExtractMax()) ) else (     break ) ;  ) );
  static   operation insert( key : int) : void
  pre: true
  post: true
  activity: (     p := p + 1 ; 
     h[p+1] := -2147483648 ; 
     execute heapIncreaseKey(p, key) );
  static   operation heapIncreaseKey( i : int, key : int) : void
  pre: true
  post: true
  activity: (     if (key < h[i+1]) then skip else skip ; 
     h[i+1] := key ; 
     while (i > 1 & h[i / 2+1] < h[i+1]) do (     var temp : int ; temp := h[i+1] ;
     h[i+1] := h[i / 2+1] ; 
     h[i / 2+1] := temp ; 
     i := i / 2 ) );
  static   operation heapExtractMax() : int
  pre: true
  post: true
  activity: (     if (p < 1) then skip else skip ; 
     var max : int ; max := h[1+1] ;
    h[1+1] := h[p+1] ; 
    p := p - 1 ; 
    execute maxHeapify(h, 1) ; 
    return max 
 );
  static   operation l( i : int) : int
  pre: true
  post: true
  activity: (     return 2 * i );
  static   operation r( i : int) : int
  pre: true
  post: true
  activity: (     return 2 * i + 1 );
  static   operation maxHeapify( h : Sequence(int), idx : int) : void
  pre: true
  post: true
  activity: (     var n : int ; n := p ;
     var l : int ; l := l(idx) ;
    var r : int ; r := r(idx) ;
    var maxNodeIdx : int ; maxNodeIdx := 0 ;
    if (l <= n & h[l+1] > h[idx+1]) then (     maxNodeIdx := l ) else (     maxNodeIdx := idx ) ;  
    if (r <= n & h[r+1] > h[maxNodeIdx+1]) then (     maxNodeIdx := r ) else skip ; 
    if (maxNodeIdx /= idx) then (     var temp : int ; temp := h[idx+1] ;
     h[idx+1] := h[maxNodeIdx+1] ; 
     h[maxNodeIdx+1] := temp ; 
     execute maxHeapify(h, maxNodeIdx) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Comparator ;
import java.util.PriorityQueue ;
import java.util.StringTokenizer ;
class Main {
  static final PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PriorityQueue<Integer>pque=new PriorityQueue<Integer>(10,new Comparator<Integer>(){
      public int compare(Integer n1,Integer n2){
        return n1>n2 ?-1 : n1<n2 ? 1 : 0 ;
      }
    }
);
    int n ;
    while(true){
      StringTokenizer st=new StringTokenizer(br.readLine());
      String command=st.nextToken();
      if("insert".equals(command)){
        n=Integer.parseInt(st.nextToken());
        pque.offer(n);
      }
      else if("end".equals(command))break ;
      else out.println(pque.poll());
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pque : Sequence(int) ; pque := Sequence{} ;
    var n : int ;
    while (true) do (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var command : String ; command := st.next() ;
     if ("insert" = command) then (     n := (st.next())->toInteger() ; 
     pque := pque->including(n) ) else     if ("end" = command) then     break else     skip ; ;  ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  void solve(){
    Scanner scan=new Scanner(System.in);
    int sum=scan.nextInt()+scan.nextInt();
    if(sum<0){
      System.out.println(-1);
    }
    else if(sum==0){
      System.out.println(0);
    }
    else {
      System.out.println(1);
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sum : int ; sum := scan.getCurrent()->toInteger() + scan.getCurrent()->toInteger() ;
     if (sum < 0) then (     OclFile["System.out"].println(-1) ) else     if (sum = 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(1) ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int r=sc.nextInt();
    if(n<-r)System.out.println(-1);
    else if(n>-r)System.out.println(1);
    else System.out.println(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
     if (n < -r) then     OclFile["System.out"].println(-1) ; else     if (n > -r) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println(0) ; ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(is);
    String str ;
    while((str=br.readLine())!=null){
      String[] sp=str.split(" ");
      int h=Integer.parseInt(sp[0]);
      int r=Integer.parseInt(sp[1]);
      if(h+r==0){
        System.out.println(0);
      }
      else if(h+r>0){
        System.out.println(1);
      }
      else {
        System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(is) ;
     var str : String ;
         str := br.readLine() ;
    while ((str) /= null) do (    skip ; (     var sp : Sequence(String) ; sp := str->split(" ") ;
     var h : int ; h := (sp[0+1])->toInteger() ;
     var r : int ; r := (sp[1+1])->toInteger() ;
     if (h + r = 0) then (     OclFile["System.out"].println(0) ) else     if (h + r > 0) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(-1) ) ;  ) ;     str := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    line=br.readLine();
    int H,R ;
    H=parseInt(line.substring(0,line.indexOf(' ')));
    R=parseInt(line.substring(line.indexOf(' ')+1));
    if(H>-R){
      System.out.println(1);
    }
    else if(H==-R){
      System.out.println(0);
    }
    else {
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    line := br.readLine() ; 
    var H : int ;
    var R : int ;
    H := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    R := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    if (H > -R) then (     OclFile["System.out"].println(1) ) else     if (H = -R) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(-1) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int H=in.nextInt(),R=in.nextInt(),res ;
    if(H>=0)res=1 ;
    else if(H<-1*R)res=-1 ;
    else res=0 ;
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := in.getCurrent()->toInteger() ;
    var R : int ; R := in.getCurrent()->toInteger() ;
    var res : int ;
     if (H >= 0) then     res := 1 else     if (H < -1 * R) then     res := -1 else     res := 0 ; ;  ;  
     OclFile["System.out"].println(res) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int[] arr=new int[a*b*c+1];
    int mod=(int)Math.pow(2,30);
    for(int i=1 ; i<arr.length ; i++){
      for(int j=i ; j<arr.length ; j+=i){
        arr[j]++;
      }
    }
    int ans=0 ;
    for(int i=1 ; i<=a ; i++){
      for(int j=1 ; j<=b ; j++){
        for(int k=1 ; k<=c ; k++){
          ans=(ans+arr[i*j*k] % mod)% mod ;
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,a * b * c + 1)->collect(0) ;
    var mod : int ; mod := 2->pow(30)->oclAsType(int) ;
        var i : int ; i := 1 ; while i < arr->size() do ( (         var j : int ; j := i ; while j < arr->size() do ( (     arr[j+1] := arr[j+1] + 1 )  ;     j := j+(i) ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= a do ( (         var j : int ; j := 1 ; while j <= b do ( (         var k : int ; k := 1 ; while k <= c do ( (     ans := (ans + arr[i * j * k+1] mod mod) mod mod )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws IOException {
    ArrayList<String>datas=new ArrayList<String>();
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    ArrayList<Integer>result=new ArrayList<Integer>();
    while(true){
      String s1=new String(in.readLine());
      int target=Integer.parseInt(s1);
      int count=0 ;
      if(s1.equals("0"))break ;
      int now=0 ;
      for(int i=1 ; i<1000 ; i++){
        for(int j=1 ; j<100 ; j++){
          now=(j*(2*i+j-1))/2 ;
          if(now==target && j!=target && i!=target){
            count++;
          }
          if(now>1000 || now>target)break ;
        }
      }
      result.add(count);
    }
    for(int s : result){
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var datas : Sequence(String) ; datas := Sequence{} ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var result : Sequence(int) ; result := Sequence{} ;
    while (true) do (     var s1 : String ; s1 := StringLib.newString(in.readLine()) ;
     var target : int ; target := (s1)->toInteger() ;
    var count : int ; count := 0 ;
    if (s1 = "0") then     break else skip ; 
    var now : int ; now := 0 ;
        var i : int ; i := 1 ; while i < 1000 do ( (         var j : int ; j := 1 ; while j < 100 do ( (     now := (j * (2 * i + j - 1)) / 2 ; 
     if (now = target & j /= target & i /= target) then (     count := count + 1 ) else skip ; 
     if (now > 1000 or now > target) then     break else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    result := result->including(count) ; 
 ) ; 
    for (s : result) do ( (     OclFile["System.out"].println(s) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void computeTotient(int n){
    long phi[]=new long[n+1];
    for(int i=1 ; i<=n ; i++)phi[i]=i ;
    for(int p=2 ; p<=n ; p++){
      if(phi[p]==p){
        phi[p]=p-1 ;
        for(int i=2*p ; i<=n ; i+=p){
          phi[i]=(phi[i]/p)*(p-1);
        }
      }
    }
    for(int i=1 ; i<=n ; i++)System.out.println("Totient of "+i+" is "+phi[i]);
  }
  public static void main(String[] args){
    int n=12 ;
    computeTotient(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation computeTotient( n : int) : void
  pre: true
  post: true
  activity: (     var phi : Sequence(long) ; phi := Integer.subrange(1,n + 1)->collect(0) ;
         var i : int ; i := 1 ; while i <= n do (     phi[i+1] := i ;  ;     i := i + 1 ) ; 
         var p : int ; p := 2 ; while p <= n do ( (     if (phi[p+1] = p) then (     phi[p+1] := p - 1 ; 
         var i : int ; i := 2 * p ; while i <= n do ( (     phi[i+1] := (phi[i+1] / p) * (p - 1) )  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
         var i : int ; i := 1 ; while i <= n do (     OclFile["System.out"].println("Totient of " + i + " is " + phi[i+1]) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     execute computeTotient(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  public static void main(String[] args){
    int N=43 ;
    int ans=findRemainder(N);
    System.out.println(ans);
  }
  public static int findRemainder(int n){
    int x=n & 3 ;
    return x ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 43 ;
     var ans : int ; ans := findRemainder(N) ;
     OclFile["System.out"].println(ans) );
  static   operation findRemainder( n : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := MathLib.bitwiseAnd(n,3) ;
     return x );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void ReverseCharBridge(int n){
    for(int i=0 ; i<n ; i++){
      for(int j='A' ; j<'A'+(2*n)-1 ; j++){
        if(j>=('A'+n-1)+i)System.out.print((char)(('A'+n-1)-(j %('A'+n-1))));
        else if(j<=('A'+n-1)-i)System.out.print((char)j);
        else System.out.print(" ");
      }
      System.out.println();
    }
  }
  public static void main(String args[]){
    int n=6 ;
    ReverseCharBridge(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation ReverseCharBridge( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 'A' ; while j < 'A' + (2 * n) - 1 do ( (     if (j >= ('A' + n - 1) + i) then     OclFile["System.out"].print((('A' + n - 1) - (j mod ('A' + n - 1)))->oclAsType(String)) ; else     if (j <= ('A' + n - 1) - i) then     OclFile["System.out"].print(j->oclAsType(String)) else     OclFile["System.out"].print(" ") ; ;  )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     execute ReverseCharBridge(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import com.sun.javafx.scene.control.skin.VirtualFlow ;
import com.sun.scenario.effect.Merge ;
import java.awt.BorderLayout ;
import static java.lang.Math.*;
import java.math.BigDecimal ;
import java.text.DecimalFormat ;
import java.util.Scanner ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.BitSet ;
import java.util.Collection ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.Deque ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Iterator ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Map ;
import java.util.Queue ;
import java.util.Set ;
import java.util.Stack ;
import java.util.TreeSet ;
import java.util.Vector ;
import java.util.concurrent.atomic.AtomicMarkableReference ;
import javafx.util.Pair ;
import java.util.Scanner ;
public class NewClass1 {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int k=in.nextInt();
    int r=in.nextInt();
    int count=0 ;
    for(int i=1 ; i<=9 ; i++){
      if((k*i)% 10==0 ||(k*i)% 10==r){
        count=i ;
        break ;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var r : int ; r := in.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= 9 do ( (     if ((k * i) mod 10 = 0 or (k * i) mod 10 = r) then (     count := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class shovel {
  public static void main(String[] args){
    java.util.Scanner in=new java.util.Scanner(System.in);
    int p=in.nextInt();
    int c=in.nextInt();
    int count=0 ;
    int result=0 ;
    while(true){
      count++;
      result=p*count ;
      if(result % 10==0 || result % 10==c){
        break ;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
class shovel {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : Scanner ; in := Scanner.newScanner(OclFile["System.in"]) ;
     var p : int ; p := in.nextInt() ;
    var c : int ; c := in.nextInt() ;
    var count : int ; count := 0 ;
    var result : int ; result := 0 ;
    while (true) do (     count := count + 1 ; 
     result := p * count ; 
     if (result mod 10 = 0 or result mod 10 = c) then (     break ) else skip ) ; 
    OclFile["System.out"].println(count) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Codeforcs {
  public static void main(String[] args){
    Scanner I=new Scanner(System.in);
    int price=I.nextInt();
    int r=I.nextInt();
    for(int i=1 ; i>0 ; i++){
      if((price*i)% 10==r ||(price*i)% 10==0){
        System.out.println(i);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforcs {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var I : OclFile ; I := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var price : int ; price := I.getCurrent()->toInteger() ;
     var r : int ; r := I.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i > 0 do ( (     if ((price * i) mod 10 = r or (price * i) mod 10 = 0) then (     OclFile["System.out"].println(i) ; 
     break ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int ans=0 ;
    for(int i=1 ; i<1000 ; ++i){
      ans++;
      if((a*i)% 10==0){
        break ;
      }
      else if((a*i)% 10==b){
        break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < 1000 do ( (     ans := ans + 1 ; 
     if ((a * i) mod 10 = 0) then (     break ) else     if ((a * i) mod 10 = b) then (     break ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int price=input.nextInt();
    int reminder=input.nextInt();
    int i=1 ;
    int sumPrice=0 ;
    while(true){
      sumPrice=i*price ;
      if(sumPrice % 10==reminder || sumPrice % 10==0){
        break ;
      }
      i++;
    }
    System.out.println(i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var price : int ; price := input.getCurrent()->toInteger() ;
    var reminder : int ; reminder := input.getCurrent()->toInteger() ;
    var i : int ; i := 1 ;
    var sumPrice : int ; sumPrice := 0 ;
    while (true) do (     sumPrice := i * price ; 
     if (sumPrice mod 10 = reminder or sumPrice mod 10 = 0) then (     break ) else skip ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println(i) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static Scanner sc=new Scanner(System.in);
  public static void main(String[] args)throws Exception {
    while(sc.hasNext()){
      solve();
    }
  }
  private static void solve(){
    int n=sc.nextInt();
    if(n==0)return ;
    int[] ary=new int[n+1];
    int sum=0 ;
    for(int i=1 ; i<=n ; i++){
      sum+=i ;
      ary[i]=sum ;
    }
    int ret=0 ;
    for(int i=0 ; i<=n ; i++){
      for(int j=i+2 ; j<=n ; j++){
        if(ary[j]-ary[i]==n){
          ret++;
        }
      }
    }
    System.out.println(ret);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     execute solve() ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var ary : Sequence(int) ; ary := Integer.subrange(1,n + 1)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     sum := sum+(i) ; 
     ary[i+1] := sum )  ;     i := i + 1 ) ; 
    var ret : int ; ret := 0 ;
        var i : int ; i := 0 ; while i <= n do ( (         var j : int ; j := i + 2 ; while j <= n do ( (     if (ary[j+1] - ary[i+1] = n) then (     ret := ret + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ret) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        int n=sc.nextInt();
        int x=sc.nextInt();
        int arr[]=new int[n];
        int sum=0 ;
        for(int i=0 ; i<n ; i++){
          arr[i]=sc.nextInt();
          sum+=arr[i];
        }
        if(sum==x)System.out.println("NO");
        else {
          System.out.println("YES");
          for(int i=0 ; i<n ; i++){
            if(arr[i]==x){
              int temp=arr[i];
              arr[i]=arr[i+1];
              arr[i+1]=x ;
            }
            System.out.print(arr[i]+" ");
            x-=arr[i];
          }
          System.out.println();
        }
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    if (sum = x) then     OclFile["System.out"].println("NO") else (     OclFile["System.out"].println("YES") ; 
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = x) then (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := arr[i + 1+1] ; 
     arr[i + 1+1] := x ) else skip ; 
     OclFile["System.out"].print(arr[i+1] + " ") ; 
     x := x-(arr[i+1]) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ;  
 ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int count=0 ;
      for(int i=0 ; i<4 ; ++i)count+=(in.nextInt());
      if(count>0){
        count=(count!=4 ? 1 : 2);
      }
      System.out.println(count);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < 4 do (     count := count+((in.getCurrent()->toInteger())) ;  ;     i := i + 1 ) ; 
     if (count > 0) then (     count := (if count /= 4 then 1 else 2 endif) ) else skip ; 
     OclFile["System.out"].println(count) ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int count=0 ;
      int[][] grid=new int[2][2];
      for(int i=0 ; i<2 ; ++i){
        for(int j=0 ; j<2 ; ++j){
          grid[i][j]=in.nextInt();
          count+=grid[i][j];
        }
      }
      if(count>0){
        count=(count!=4 ? 1 : 2);
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var count : int ; count := 0 ;
     var grid : Sequence(Sequence(int)) ; grid := Integer.subrange(1,2)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < 2 do ( (         var j : int ; j := 0 ; while j < 2 do ( (     grid[i+1][j+1] := in.getCurrent()->toInteger() ; 
     count := count+(grid[i+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (count > 0) then (     count := (if count /= 4 then 1 else 2 endif) ) else skip ; 
    OclFile["System.out"].println(count) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF235B {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    double result=0 ;
    double previous=0 ;
    double current=0 ;
    for(int i=0 ; i<n ; i++){
      current=s.nextDouble();
      previous*=current ;
      result+=2*previous+current ;
      previous+=current ;
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF235B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var result : double ; result := 0 ;
    var previous : double ; previous := 0 ;
    var current : double ; current := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     current := s.getCurrent()->toReal() ; 
     previous := previous*(current) ; 
     result := result+(2 * previous + current) ; 
     previous := previous+(current) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t--!=0){
      int count=0 ;
      for(int i=0 ; i<4 ; i++){
        if(scanner.nextInt()==1){
          count++;
        }
      }
      if(count==4){
        System.out.println(2);
      }
      else if(count==0){
        System.out.println(0);
      }
      else {
        System.out.println(1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < 4 do ( (     if (scanner.getCurrent()->toInteger() = 1) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (count = 4) then (     OclFile["System.out"].println(2) ) else     if (count = 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(1) ) ;  ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int findMaxConsecutiveOnes(int[] nums){
    int ans=0 ;
    int curr=0 ;
    for(int i=0 ; i<nums.length ; i++){
      if(nums[i]==1){
        curr++;
        if(curr>ans)ans=curr ;
      }
      else {
        curr=0 ;
      }
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation findMaxConsecutiveOnes( nums : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var curr : int ; curr := 0 ;
         var i : int ; i := 0 ; while i < nums->size() do ( (     if (nums[i+1] = 1) then (     curr := curr + 1 ; 
     if (curr > ans) then     ans := curr ; else skip ) else (     curr := 0 ) )  ;     i := i + 1 ) ; 
     return ans );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int setBitNumber(int n){
    if(n==0)return 0 ;
    int msb=0 ;
    while(n!=0){
      n=n/2 ;
      msb++;
    }
    return(1<<msb);
  }
  public static void main(String[] args){
    int n=0 ;
    System.out.println(setBitNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation setBitNumber( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else skip ; 
     var msb : int ; msb := 0 ;
     while (n /= 0) do (     n := n / 2 ; 
     msb := msb + 1 ) ; 
     return ((1*(2->pow(msb)))->oclAsType(long)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 0 ;
     OclFile["System.out"].println(setBitNumber(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line=br.readLine();
    String[] lineArray=line.split(" ");
    int H=Integer.parseInt(lineArray[0]);
    int W=Integer.parseInt(lineArray[1]);
    char[][] campus=new char[H+2][W+2];
    for(int i=1 ; i<H+1 ; i++){
      line=br.readLine();
      for(int j=1 ; j<W+1 ; j++){
        campus[i][j]=line.charAt(j-1);
      }
    }
    String result="Yes" ;
    for(int i=1 ; i<H+1 ; i++){
      result=drawer(campus,H,W,i);
      if(result=="No"){
        break ;
      }
    }
    System.out.println(result);
  }
  public static String drawer(char[][] campus,int H,int W,int i){
    for(int j=1 ; j<W+1 ; j++){
      if(!(campus[i-1][j]=='#' || campus[i][j-1]=='#' || campus[i][j+1]=='#' || campus[i+1][j]=='#')&& campus[i][j]=='#'){
        return "No" ;
      }
    }
    return "Yes" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := br.readLine() ;
    var lineArray : Sequence(String) ; lineArray := line->split(" ") ;
    var H : int ; H := (lineArray[0+1])->toInteger() ;
    var W : int ; W := (lineArray[1+1])->toInteger() ;
    var campus : Sequence(Sequence(String)) ; campus := Integer.subrange(1,H + 2)->collect(Integer.subrange(1,W + 2)->collect(0)) ;
        var i : int ; i := 1 ; while i < H + 1 do ( (     line := br.readLine() ; 
         var j : int ; j := 1 ; while j < W + 1 do ( (     campus[i+1][j+1] := line->at(j - 1+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var result : String ; result := "Yes" ;
        var i : int ; i := 1 ; while i < H + 1 do ( (     result := drawer(campus, H, W, i) ; 
     if (result = "No") then (     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation drawer( campus : Sequence(Sequence(String)), H : int, W : int, i : int) : String
  pre: true
  post: true
  activity: (         var j : int ; j := 1 ; while j < W + 1 do ( (     if (not((campus[(i)->char2byte() - 1+1][j+1] = '#' or campus[i+1][j - 1+1] = '#' or campus[i+1][j + 1+1] = '#' or campus[i + 1+1][j+1] = '#')) & campus[i+1][j+1] = '#') then (     return "No" ) else skip )  ;     j := j + 1 ) ; 
     return "Yes" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void check(int h,int w,char c[][]){
    for(int i=0 ; i<h+2 ; i++){
      if(i==0 || i==h+1)continue ;
      for(int j=0 ; j<w+2 ; j++){
        if(c[i][j]=='.' || j==0 || j==w+1){
          continue ;
        }
        else {
          if(c[i+1][j]=='#' || c[i-1][j]=='#' || c[i][j+1]=='#' || c[i][j-1]=='#'){
            continue ;
          }
          else {
            System.out.print("No");
            return ;
          }
        }
      }
    }
    System.out.print("Yes");
    return ;
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int H=s.nextInt();
    int W=s.nextInt();
    String st[]=new String[H+2];
    char c[][]=new char[H+2][W+2];
    System.out.println();
    for(int i=0 ; i<H+1 ; i++){
      st[i]=s.nextLine();
    }
    for(int i=1 ; i<H+1 ; i++){
      for(int j=1 ; j<W+1 ; j++){
        c[i][j]=st[i] .charAt(j-1);
      }
    }
    Main a=new Main();
    a.check(H,W,c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation check( h : int, w : int, c : Sequence(Sequence(String))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < h + 2 do ( (     if (i = 0 or i = h + 1) then     continue else skip ; 
         var j : int ; j := 0 ; while j < w + 2 do ( (     if (c[i+1][j+1] = '.' or j = 0 or j = w + 1) then (     continue ) else (     if (c[i + 1+1][j+1] = '#' or c[i - 1+1][j+1] = '#' or c[i+1][j + 1+1] = '#' or c[i+1][j - 1+1] = '#') then (     continue ) else (     OclFile["System.out"].print("No") ; 
     return ) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print("Yes") ; 
     return );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := s.getCurrent()->toInteger() ;
    var W : int ; W := s.getCurrent()->toInteger() ;
    var st : Sequence(String) ; st := Integer.subrange(1,H + 2)->collect(null) ;
    var c : Sequence(Sequence(String)) ; c := Integer.subrange(1,H + 2)->collect(Integer.subrange(1,W + 2)->collect(0)) ;
    OclFile["System.out"].println() ; 
        var i : int ; i := 0 ; while i < H + 1 do ( (     st[i+1] := s.nextLine() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < H + 1 do ( (         var j : int ; j := 1 ; while j < W + 1 do ( (     c[i+1][j+1] := st[i+1]->at(j - 1+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var a : Main ; a := Main.newMain() ;
    a.check(H, W, c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    String[][] grid=new String[h][w];
    for(int i=0 ; i<h ; i++){
      String temp=sc.next();
      grid[i]=temp.split("");
    }
    String result="Yes" ;
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        if(! hasNeighbor(grid,i,j)){
          result="No" ;
          break ;
        }
      }
    }
    System.out.println(result);
  }
  static boolean hasNeighbor(String[][] grid,int x,int y){
    int h=grid.length ;
    int w=grid[0] .length ;
    String up=null ;
    String down=null ;
    String left=null ;
    String right=null ;
    String lu=null ;
    String ru=null ;
    String ld=null ;
    String rd=null ;
    if(x>0)up=grid[x-1][y];
    if(x<h-1)down=grid[x+1][y];
    if(y>0)left=grid[x][y-1];
    if(y<w-1)right=grid[x][y+1];
    if(grid[x][y] .equals("."))return true ;
    if(up!=null && up.equals("#"))return true ;
    if(down!=null && down.equals("#"))return true ;
    if(left!=null && left.equals("#"))return true ;
    if(right!=null && right.equals("#"))return true ;
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var grid : Sequence(Sequence(String)) ; grid := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(null)) ;
        var i : int ; i := 0 ; while i < h do ( (     var temp : String ; temp := sc.getCurrent() ;
     grid[i+1] := temp->split("") )  ;     i := i + 1 ) ; 
    var result : String ; result := "Yes" ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (not(hasNeighbor(grid, i, j))) then (     result := "No" ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation hasNeighbor( grid : Sequence(Sequence(String)), x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     var h : int ; h := grid->size() ;
     var w : int ; w := grid[0+1]->size() ;
    var up : String ; up := null ;
    var down : String ; down := null ;
    var left : String ; left := null ;
    var right : String ; right := null ;
    var lu : String ; lu := null ;
    var ru : String ; ru := null ;
    var ld : String ; ld := null ;
    var rd : String ; rd := null ;
    if (x > 0) then     up := grid[x - 1+1][y+1] ; else skip ; 
    if (x < h - 1) then     down := grid[x + 1+1][y+1] ; else skip ; 
    if (y > 0) then     left := grid[x+1][y - 1+1] ; else skip ; 
    if (y < w - 1) then     right := grid[x+1][y + 1+1] ; else skip ; 
    if (grid[x+1][y+1] = ".") then     return true else skip ; 
    if (up /= null & up = "#") then     return true else skip ; 
    if (down /= null & down = "#") then     return true else skip ; 
    if (left /= null & left = "#") then     return true else skip ; 
    if (right /= null & right = "#") then     return true else skip ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.Math ;
class LIS {
  static int CeilIndex(int A[],int l,int r,int key){
    while(r-l>1){
      int m=l+(r-l)/2 ;
      if(A[m]>=key)r=m ;
      else l=m ;
    }
    return r ;
  }
  static int LongestIncreasingSubsequenceLength(int A[],int size){
    int[] tailTable=new int[size];
    int len ;
    tailTable[0]=A[0];
    len=1 ;
    for(int i=1 ; i<size ; i++){
      if(A[i]<tailTable[0])tailTable[0]=A[i];
      else if(A[i]>tailTable[len-1])tailTable[len++]=A[i];
      else tailTable[CeilIndex(tailTable,-1,len-1,A[i])]=A[i];
    }
    return len ;
  }
  public static void main(String[] args){
    int A[]={
      2,5,3,7,11,8,10,13,6 };
      int n=A.length ;
      System.out.println("Length of Longest Increasing Subsequence is "+LongestIncreasingSubsequenceLength(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class LIS {
  static   operation CeilIndex( A : Sequence(int), l : int, r : int, key : int) : int
  pre: true
  post: true
  activity: (     while (r - l > 1) do (     var m : int ; m := l + (r - l) / 2 ;
     if (A[m+1] >= key) then     r := m ; else     l := m ; ) ; 
     return r );
  static   operation LongestIncreasingSubsequenceLength( A : Sequence(int), size : int) : int
  pre: true
  post: true
  activity: (     var tailTable : Sequence(int) ; tailTable := Integer.subrange(1,size)->collect(0) ;
     var len : int ;
    tailTable[0+1] := A[0+1] ; 
    len := 1 ; 
        var i : int ; i := 1 ; while i < size do ( (     if (A[i+1] < tailTable[0+1]) then     tailTable[0+1] := A[i+1] ; else     if (A[i+1] > tailTable[len - 1+1]) then      tailTable[len+1] := A[i+1]  ; len := len + 1 else     tailTable[CeilIndex(tailTable, -1, len - 1, A[i+1])+1] := A[i+1] ; ;  )  ;     i := i + 1 ) ; 
    return len 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{2,5,3,7,11,8,10,13,6} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].println("Length of Longest Increasing Subsequence is " + LongestIncreasingSubsequenceLength(A, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  public void run(){
    try(BufferedReader in=new BufferedReader(new InputStreamReader(System.in))){
      String[] lines=in.readLine().split(" ");
      int h=Integer.parseInt(lines[0]);
      int w=Integer.parseInt(lines[1]);
      boolean[][] mat=new boolean[h][w];
      String line ;
      for(int y=0 ; y<h ; y++){
        line=in.readLine();
        for(int x=0 ; x<w ; x++){
          mat[y][x]=line.charAt(x)=='#' ? true : false ;
        }
      }
      int[] rx={
        0,0,-1,1 };
        int[] ry={
-1,1,0,0 };
          boolean result=true ;
          boolean isPossible=false ;
          for(int y=0 ; result && y<h ; y++){
            for(int x=0 ; result && x<w ; x++){
              if(mat[y][x]){
                for(int i=0 ; ! isPossible && i<4 ; i++){
                  if(y+ry[i]>-1 && y+ry[i]<h && x+rx[i]>-1 && x+rx[i]<w)if(mat[y+ry[i] ][x+rx[i] ])isPossible=true ;
                }
                if(isPossible)isPossible=false ;
                else {
                  result=false ;
                }
              }
            }
          }
          String ans=result ? "Yes" : "No" ;
          System.out.println(ans);
        }
        catch(IOException e){
          System.err.println(e);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var lines : Sequence(String) ; lines := in.readLine()->split(" ") ;
     var h : int ; h := (lines[0+1])->toInteger() ;
    var w : int ; w := (lines[1+1])->toInteger() ;
    var mat : Sequence(Sequence(boolean)) ; mat := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(false)) ;
    var line : String ;
        var y : int ; y := 0 ; while y < h do ( (     line := in.readLine() ; 
         var x : int ; x := 0 ; while x < w do ( (     mat[y+1][x+1] := if line->at(x+1) = '#' then true else false endif )  ;     x := x + 1 ) )  ;     y := y + 1 ) ; 
    var rx : Sequence(int) ; rx := Sequence{0,0,-1,1} ;
    var ry : Sequence(int) ; ry := Sequence{-1,1,0,0} ;
    var result : boolean ; result := true ;
    var isPossible : boolean ; isPossible := false ;
        var y : int ; y := 0 ; while result & y < h do ( (         var x : int ; x := 0 ; while result & x < w do ( (     if (mat[y+1][x+1]) then (         var i : int ; i := 0 ; while not(isPossible) & i < 4 do ( (     if (y + ry[i+1] > -1 & y + ry[i+1] < h & x + rx[i+1] > -1 & x + rx[i+1] < w) then     if (mat[y + ry[i+1]+1][x + rx[i+1]+1]) then     isPossible := true ; else skip ; else skip )  ;     i := i + 1 ) ; 
     if (isPossible) then     isPossible := false ; else (     result := false ) ) else skip )  ;     x := x + 1 ) )  ;     y := y + 1 ) ; 
    var ans : String ; ans := if result then "Yes" else "No" endif ;
    OclFile["System.out"].println(ans) ; 
 ))   catch (e : IOException) do (     OclFile["System.err"].println(e) )
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
import java.util.*;
public class Main {
  static char maze[][]=new char[55][55];
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    while(cin.hasNext()){
      int n=cin.nextInt();
      int m=cin.nextInt();
      int flag=1 ;
      for(int i=0 ; i<=51 ; ++i){
        for(int j=0 ; j<=51 ; ++j){
          maze[i][j]='.' ;
        }
      }
      for(int i=1 ; i<=n ; ++i){
        String s=cin.next();
        for(int j=1 ; j<=m ; ++j){
          maze[i][j]=s.charAt(j-1);
        }
      }
      for(int i=1 ; i<=n ; ++i){
        for(int j=1 ; j<=m ; ++j){
          if(maze[i][j]=='#'){
            if(check(i,j)==false){
              flag=0 ;
            }
          }
        }
      }
      if(flag==1)System.out.println("Yes");
      else System.out.println("No");
    }
  }
  public static boolean check(int x,int y){
    if(maze[x-1][y]=='#' || maze[x+1][y]=='#' || maze[x][y-1]=='#' || maze[x][y+1]=='#')return true ;
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute maze : String := Integer.subrange(1,55)->collect(Integer.subrange(1,55)->collect(0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (cin.hasNext()) do (     var n : int ; n := cin.getCurrent()->toInteger() ;
     var m : int ; m := cin.getCurrent()->toInteger() ;
    var flag : int ; flag := 1 ;
        var i : int ; i := 0 ; while i <= 51 do ( (         var j : int ; j := 0 ; while j <= 51 do ( (     maze[i+1][j+1] := '.' )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     var s : String ; s := cin.getCurrent() ;
         var j : int ; j := 1 ; while j <= m do ( (     maze[i+1][j+1] := s->at((j)->char2byte() - 1+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= m do ( (     if (maze[i+1][j+1] = '#') then (     if (check(i, j) = false) then (     flag := 0 ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (flag = 1) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 ) );
  static   operation check( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     if (maze[x - 1+1][y+1] = '#' or maze[x + 1+1][y+1] = '#' or maze[x+1][y - 1+1] = '#' or maze[x+1][y + 1+1] = '#') then     return true else skip ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static class Pair implements Comparable<Pair>{
    int w,v ;
    public Pair(int w,int v){
      super();
      this.w=w ;
      this.v=v ;
    }
    @ Override public int compareTo(Pair o){
      return this.w*o.v-this.v*o.w ;
    }
  }
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    final int N=sc.nextInt();
    final int W=sc.nextInt();
    PriorityQueue<Pair>queue=new PriorityQueue<Main.Pair>();
    double cur_w=0,cur_v=0 ;
    for(int i=0 ; i<N ; i++){
      int w=sc.nextInt();
      int v=sc.nextInt();
      if(w>=0 && v<=0){
        continue ;
      }
      else if(w<=0 && v>=0){
        cur_w+=w ;
        cur_v+=v ;
        continue ;
      }
      else if(w<=0 && v<=0){
        cur_w+=w ;
        cur_v+=v ;
        w=-w ;
        v=-v ;
      }
      queue.add(new Pair(w,v));
    }
    while(! queue.isEmpty()){
      Pair p=queue.poll();
      final double rest=W-cur_w ;
      final double x=Math.max(0,Math.min(1,rest/p.w));
      cur_w+=x*p.w ;
      cur_v+=x*p.v ;
    }
    System.out.printf("%f\n",cur_v);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Pair implements Comparable<Map> {
   attribute w : int;
   static operation newPair( w : int, v : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(w, v);
    return self );
  operation initialise( w : int, v : int) : void
  pre: true  post: true
  activity: (     execute super() ; 
     self.w := w ; 
     self.v := v );
      operation compareTo( o : Map) : int
  pre: true
  post: true
  activity: (     return self.w * o.v - self.v * o.w );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var queue : Sequence(Map) ; queue := Sequence{} ;
    var cur_w : double ; cur_w := 0 ;
    var cur_v : double ; cur_v := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var w : int ; w := sc.getCurrent()->toInteger() ;
     var v : int ; v := sc.getCurrent()->toInteger() ;
     if (w >= 0 & v <= 0) then (     continue ) else     if (w <= 0 & v >= 0) then (     cur_w := cur_w+(w) ; 
     cur_v := cur_v+(v) ; 
     continue ) else     if (w <= 0 & v <= 0) then (     cur_w := cur_w+(w) ; 
     cur_v := cur_v+(v) ; 
     w := -w ; 
     v := -v ) else skip ; ;  ;  
     queue := queue->including(Map(w, v)) )  ;     i := i + 1 ) ; 
    while (not(queue->isEmpty())) do (     var p : Map ; p := queue->min() ;
     var rest : double ; rest := W - cur_w ;
    var x : double ; x := Set{0, Set{1, rest / p.w}->min()}->max() ;
    cur_w := cur_w+(x * p.w) ; 
    cur_v := cur_v+(x * p.v) ; 
 ) ; 
    OclFile["System.out"].printf("%f\n", cur_v) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean isVowel(char c){
    c=Character.toLowerCase(c);
    if(c=='a' || c=='e' || c=='i' || c=='o' || c=='u')return true ;
    return false ;
  }
  static String firstXvowels(String s,int x){
    String result="" ;
    for(int i=0 ; i<s.length(); i++){
      if(isVowel(s.charAt(i)))result+=s.charAt(i);
      if(result.length()==x){
        return result ;
      }
    }
    return "-1" ;
  }
  public static void main(String[] args){
    String str="GeeksForGeeks" ;
    int x=3 ;
    System.out.println(firstXvowels(str,x));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isVowel( c : String) : boolean
  pre: true
  post: true
  activity: (     c := (c + "")->toLowerCase() ; 
     if (c = 'a' or c = 'e' or c = 'i' or c = 'o' or c = 'u') then     return true else skip ; 
     return false );
  static   operation firstXvowels( s : String, x : int) : String
  pre: true
  post: true
  activity: (     var result : String ; result := "" ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (isVowel(s->at(i+1))) then     result := result+(s->at(i+1)) ; else skip ; 
     if (result->size() = x) then (     return result ) else skip )  ;     i := i + 1 ) ; 
     return "-1" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GeeksForGeeks" ;
     var x : int ; x := 3 ;
     OclFile["System.out"].println(firstXvowels(str, x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class E {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    double prev=0,ans=0 ;
    for(int i=0 ; i<n ; i++){
      double p=sc.nextDouble();
      ans+=p+prev*p*2 ;
      prev=prev*p+p ;
    }
    out.println(ans);
    out.flush();
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(FileReader fileReader){
      br=new BufferedReader(fileReader);
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class E {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var prev : double ; prev := 0 ;
    var ans : double ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var p : double ; p := sc.getCurrent()->toReal() ;
     ans := ans+(p + prev * p * 2) ; 
     prev := prev * p + p )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( fileReader : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(fileReader);
    return self );
  operation initialise( fileReader : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(fileReader) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  static ArrayList<Integer>[] g ;
  static int n ;
  static int[] deg ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    g=new ArrayList[n];
    deg=new int[n];
    for(int i=0 ; i<n ; ++i){
      g[i]=new ArrayList<>();
    }
    for(int i=1 ; i<n ; ++i){
      int a=sc.nextInt()-1 ;
      g[a] .add(i);
      g[i] .add(a);
    }
    dfs(0,-1);
    System.out.println(deg[0]);
  }
  static void dfs(int cur,int par){
    if(cur!=0 && g[cur] .size()==1){
      deg[cur]=0 ;
      return ;
    }
    else if(g[cur] .size()==0){
      deg[cur]=0 ;
      return ;
    }
    ArrayList<Integer>v=new ArrayList<>();
    for(int dst : g[cur]){
      if(dst==par)continue ;
      dfs(dst,cur);
      v.add(deg[dst]);
    }
    Collections.sort(v,new Comparator<Integer>(){
      @ Override public int compare(Integer o1,Integer o2){
        return-Integer.compare(o1,o2);
      }
    }
);
    int max=0 ;
    for(int i=0 ; i<v.size(); ++i){
      max=Math.max(max,i+v.get(i));
    }
    deg[cur]=max+1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute g : Sequence(Sequence(int));
  static   attribute n : int;
  static   attribute deg : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    g := Integer.subrange(1,n)->collect(null) ; 
    deg := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     g[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
     g[a+1]->excludes(i) ; 
     g[i+1]->excludes(a) )  ;     i := i + 1 ) ; 
    execute dfs(0, -1) ; 
    OclFile["System.out"].println(deg[0+1]) ; 
 );
  static   operation dfs( cur : int, par : int) : void
  pre: true
  post: true
  activity: (     if (cur /= 0 & g[cur+1]->size() = 1) then (     deg[cur+1] := 0 ; 
     return ) else     if (g[cur+1]->size() = 0) then (     deg[cur+1] := 0 ; 
     return ) else skip ; ;  
     var v : Sequence(int) ; v := Sequence{} ;
    for (dst : g[cur+1]) do ( (     if (dst = par) then     continue else skip ; 
     execute dfs(dst, cur) ; 
     v := v->including(deg[dst+1]) )  ) ; 
    v, OclComparator<int>.newOclComparator() := v, OclComparator<int>.newOclComparator()->sort() ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < v->size() do ( (     max := Set{max, i + v->at(i+1)}->max() )  ;     i := i + 1 ) ; 
    deg[cur+1] := max + 1 ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    Obj[] arr=new Obj[n];
    for(int i=0 ; i<n ; i++){
      Obj o=new Obj();
      o.i=i ;
      arr[i]=o ;
    }
    for(int i=1 ; i<n ; i++){
      int a=Integer.parseInt(br.readLine())-1 ;
      arr[a] .list.add(arr[i]);
    }
    br.close();
    dfs(arr,arr[0]);
    System.out.println(arr[0] .d);
  }
  static void dfs(Obj[] arr,Obj cur){
    List<Obj>list=cur.list ;
    if(! list.isEmpty()){
      for(Obj next : list){
        dfs(arr,next);
      }
      Collections.sort(list);
      int d=0 ;
      for(int i=0 ; i<list.size(); i++){
        d=Math.max(d,list.get(i).d);
        d++;
      }
      cur.d=d ;
    }
  }
  static class Obj implements Comparable<Obj>{
    int i,d ;
    List<Obj>list=new ArrayList<>();
    @ Override public int compareTo(Obj o){
      return d-o.d ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var arr : Sequence(Obj) ; arr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var o : Obj ; o := Obj.newObj() ;
     o.i := i ; 
     arr[i+1] := o )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     var a : int ; a := (br.readLine())->toInteger() - 1 ;
     arr[a+1].list->excludes(arr[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
    execute dfs(arr, arr[0+1]) ; 
    OclFile["System.out"].println(arr[0+1].d) ; 
 );
  static   operation dfs( arr : Sequence(Obj), cur : Obj) : void
  pre: true
  post: true
  activity: (     var list : Sequence(Obj) ; list := cur.list ;
     if (not(list->isEmpty())) then (     for (next : list) do ( (     execute dfs(arr, next) )  ) ; 
     list := list->sort() ; 
    var d : int ; d := 0 ;
        var i : int ; i := 0 ; while i < list->size() do ( (     d := Set{d, list->at(i+1).d}->max() ; 
     d := d + 1 )  ;     i := i + 1 ) ; 
    cur.d := d ; 
 ) else skip );
  static class Obj implements Comparable<Obj> {
   attribute i : int;
   attribute list : Sequence(Obj) := Sequence{};
      operation compareTo( o : Obj) : int
  pre: true
  post: true
  activity: (     return d - o.d );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    ArrayList<Integer>[] graph=new ArrayList[N];
    for(int i=0 ; i<N ; i++){
      graph[i]=new ArrayList<>();
    }
    for(int i=1 ; i<N ; i++){
      int a=scanner.nextInt()-1 ;
      graph[a] .add(i);
    }
    System.out.println(dfs(0,graph)-1);
  }
  private static int dfs(int v,ArrayList<Integer>[] graph){
    if(graph[v] .isEmpty()){
      return 1 ;
    }
    int[] tmp=new int[graph[v] .size()];
    for(int i=0 ; i<tmp.length ; i++){
      int u=graph[v] .get(i);
      tmp[i]=dfs(u,graph);
    }
    Arrays.sort(tmp);
    int max=0 ;
    for(int t : tmp){
      if(t<=max)max++;
      else max=t ;
    }
    max++;
    return max ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var graph : Sequence(Sequence(int)) ; graph := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     graph[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < N do ( (     var a : int ; a := scanner.getCurrent()->toInteger() - 1 ;
     graph[a+1]->excludes(i) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dfs(0, graph) - 1) ; 
 );
  static   operation dfs( v : int, graph : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     if (graph[v+1]->isEmpty()) then (     return 1 ) else skip ; 
     var tmp : Sequence(int) ; tmp := Integer.subrange(1,graph[v+1]->size())->collect(0) ;
        var i : int ; i := 0 ; while i < tmp->size() do ( (     var u : int ; u := graph[v+1]->at(i+1) ;
     tmp[i+1] := dfs(u, graph) )  ;     i := i + 1 ) ; 
    tmp := tmp->sort() ; 
    var max : int ; max := 0 ;
    for (t : tmp) do ( (     if (t <= max) then     max := max + 1 ; else     max := t ; )  ) ; 
    max := max + 1 ; 
    return max 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long l1=in.nextLong(),r1=in.nextLong(),l2=in.nextLong(),r2=in.nextLong();
    long k=in.nextLong();
    if(r1<l2){
      pw.println(0);
      pw.close();
      return ;
    }
    long meetStart=Math.max(l1,l2);
    long meetEnd=Math.min(r2,r1);
    long ans=(meetEnd-meetStart)+1 ;
    if(ans<=0){
      pw.println(0);
    }
    else if(meetStart<=k && meetEnd>=k){
      ans--;
      pw.println(ans);
    }
    else pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var l1 : long ; l1 := in.getCurrent()->toLong() ;
    var r1 : long ; r1 := in.getCurrent()->toLong() ;
    var l2 : long ; l2 := in.getCurrent()->toLong() ;
    var r2 : long ; r2 := in.getCurrent()->toLong() ;
    var k : long ; k := in.getCurrent()->toLong() ;
    if (r1 < l2) then (     skip ; 
     skip ; 
     return ) else skip ; 
    var meetStart : long ; meetStart := Set{l1, l2}->max() ;
    var meetEnd : long ; meetEnd := Set{r2, r1}->min() ;
    var ans : long ; ans := (meetEnd - meetStart) + 1 ;
    if (ans <= 0) then (     skip ) else     if (meetStart <= k & meetEnd >= k) then (     ans := ans - 1 ; 
     skip ) else     skip ; ;  ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class meet {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long l1,r1,l2,r2,k,d ;
    l1=sc.nextLong();
    r1=sc.nextLong();
    l2=sc.nextLong();
    r2=sc.nextLong();
    k=sc.nextLong();
    if(l2>=l1 && r2<=r1){
      if(k>=l2 && k<=r2)d=r2-l2 ;
      else d=r2-l2+1 ;
    }
    else if(r2>=l1 && r2<=r1){
      if(k>=l1 && k<=r2)d=r2-l1 ;
      else d=r2-l1+1 ;
    }
    else if(l2>=l1 && l2<=r1){
      if(k>=l2 && k<=r1)d=r1-l2 ;
      else d=r1-l2+1 ;
    }
    else if(l2<=l1 && r2>=r1){
      if(k>=l1 && k<=r1)d=r1-l1 ;
      else d=r1-l1+1 ;
    }
    else d=0 ;
    System.out.println(d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class meet {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l1 : long ;
    var r1 : long ;
    var l2 : long ;
    var r2 : long ;
    var k : long ;
    var d : long ;
    l1 := sc.getCurrent()->toLong() ; 
    r1 := sc.getCurrent()->toLong() ; 
    l2 := sc.getCurrent()->toLong() ; 
    r2 := sc.getCurrent()->toLong() ; 
    k := sc.getCurrent()->toLong() ; 
    if (l2 >= l1 & r2 <= r1) then (     if (k >= l2 & k <= r2) then     d := r2 - l2 ; else     d := r2 - l2 + 1 ; ) else     if (r2 >= l1 & r2 <= r1) then (     if (k >= l1 & k <= r2) then     d := r2 - l1 ; else     d := r2 - l1 + 1 ; ) else     if (l2 >= l1 & l2 <= r1) then (     if (k >= l2 & k <= r1) then     d := r1 - l2 ; else     d := r1 - l2 + 1 ; ) else     if (l2 <= l1 & r2 >= r1) then (     if (k >= l1 & k <= r1) then     d := r1 - l1 ; else     d := r1 - l1 + 1 ; ) else     d := 0 ; ;  ;  ;  ;  
    OclFile["System.out"].println(d) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int N=s.nextInt();
    int[] ban=new int[N];
    for(int i=0 ; i<N ; i++)ban[i]=s.nextInt();
    Arrays.sort(ban);
    System.out.println((ban[N-1]-ban[0]+1)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := s.getCurrent()->toInteger() ;
    var ban : Sequence(int) ; ban := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     ban[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    ban := ban->sort() ; 
    OclFile["System.out"].println((ban[N - 1+1] - ban[0+1] + 1) / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int T=1 ;
    long a,b,t1,t2,res ;
    long x ;
    String s1 ;
    while(T-->0){
      a=s.nextLong();
      b=s.nextLong();
      t1=s.nextLong();
      t2=s.nextLong();
      res=s.nextLong();
      a=Math.max(a,t1);
      b=Math.min(b,t2);
      if(a>b)System.out.println(0);
      else {
        if(res>=a && res<=b)System.out.println(b-a);
        else System.out.println(b-a+1);
      }
    }
  }
  private static boolean isPrime(int n){
    if(n==2)return true ;
    else if((n % 2==0 && n>2)|| n<2)return false ;
    else {
      for(int i=3 ; i<=(int)Math.sqrt(n); i+=2){
        if(n % i==0)return false ;
      }
      return true ;
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := 1 ;
    var a : long ;
    var b : long ;
    var t1 : long ;
    var t2 : long ;
    var res : long ;
    var x : long ;
    var s1 : String ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     a := s.getCurrent()->toLong() ; 
     b := s.getCurrent()->toLong() ; 
    t1 := s.getCurrent()->toLong() ; 
    t2 := s.getCurrent()->toLong() ; 
    res := s.getCurrent()->toLong() ; 
    a := Set{a, t1}->max() ; 
    b := Set{b, t2}->min() ; 
    if (a > b) then     OclFile["System.out"].println(0) else (     if (res >= a & res <= b) then     OclFile["System.out"].println(b - a) ; else     OclFile["System.out"].println(b - a + 1) ; ) ;  
 ) ;  ) ;  
 );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 2) then     return true else     if ((n mod 2 = 0 & n > 2) or n < 2) then     return false else (         var i : int ; i := 3 ; while i <= (n)->sqrt()->oclAsType(int) do ( (     if (n mod i = 0) then     return false else skip )  ;     i := i+(2) ) ; 
     return true ) ;  );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long mod=(long)(1e9+7);
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long l1=in.nextLong(),r1=in.nextLong(),l2=in.nextLong(),r2=in.nextLong(),k=in.nextLong();
    long left=Math.max(l1,l2),right=Math.min(r1,r2);
    if(left>right){
      pw.println(0);
    }
    else {
      if(k>=left && k<=right){
        pw.println(right-left);
      }
      else {
        pw.println(right-left+1);
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := (1e9 + 7)->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var l1 : long ; l1 := in.getCurrent()->toLong() ;
    var r1 : long ; r1 := in.getCurrent()->toLong() ;
    var l2 : long ; l2 := in.getCurrent()->toLong() ;
    var r2 : long ; r2 := in.getCurrent()->toLong() ;
    var k : long ; k := in.getCurrent()->toLong() ;
    var left : long ; left := Set{l1, l2}->max() ;
    var right : long ; right := Set{r1, r2}->min() ;
    if (left > right) then (     skip ) else (     if (k >= left & k <= right) then (     skip ) else (     skip ) ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findkth(int n,int k){
    Vector<Integer>v1=new Vector<Integer>();
    Vector<Integer>v2=new Vector<Integer>();
    for(int i=1 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        v1.add(i);
        if(i!=Math.sqrt(n))v2.add(n/i);
      }
    }
    Collections.reverse(v2);
    if(k>(v1.size()+v2.size()))System.out.print("Doesn't Exist");
    else {
      if(k<=v1.size())System.out.print(v1.get(k-1));
      else System.out.print(v2.get(k-v1.size()-1));
    }
  }
  public static void main(String[] args){
    int n=15,k=2 ;
    findkth(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findkth( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var v1 : Sequence(int) ; v1 := Sequence{} ;
     var v2 : Sequence(int) ; v2 := Sequence{} ;
        var i : int ; i := 1 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     v1 := v1->including(i) ; 
     if (i /= (n)->sqrt()) then     v2 := v2->including(n / i) ; else skip ) else skip )  ;     i := i + 1 ) ; 
    v2 := v2->reverse() ; 
    if (k > (v1->size() + v2->size())) then     OclFile["System.out"].print("Doesn't Exist") else (     if (k <= v1->size()) then     OclFile["System.out"].print(v1->at(k - 1+1)) ; else     OclFile["System.out"].print(v2->at(k - v1->size() - 1+1)) ; ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
    var k : int ; k := 2 ;
     execute findkth(n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GfG {
  public static String LedRequired(String s,int led){
    int seg[]={
      6,2,5,5,4,5,6,3,7,6 };
      int count=0 ;
      for(int i=0 ; i<s.length(); ++i){
        count+=seg[(int)(s.charAt(i))-48];
      }
      if(count<=led)return "YES" ;
      else return "NO" ;
    }
    public static void main(String[] args){
      String S="123456789" ;
      int led=20 ;
      System.out.println(LedRequired(S,led));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation LedRequired( s : String, led : int) : String
  pre: true
  post: true
  activity: (     var seg : Sequence(int) ; seg := Sequence{6,2,5,5,4,5,6,3,7,6} ;
     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     count := count+(seg[(s->at(i+1))->oclAsType(int) - 48+1]) )  ;     i := i + 1 ) ; 
     if (count <= led) then     return "YES" else     return "NO" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := "123456789" ;
     var led : int ; led := 20 ;
     OclFile["System.out"].println(LedRequired(S, led)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maxSum1(int arr[],int n){
    int dp[]=new int[n];
    int maxi=0 ;
    for(int i=0 ; i<n-1 ; i++){
      dp[i]=arr[i];
      if(maxi<arr[i])maxi=arr[i];
    }
    for(int i=2 ; i<n-1 ; i++){
      for(int j=0 ; j<i-1 ; j++){
        if(dp[i]<dp[j]+arr[i]){
          dp[i]=dp[j]+arr[i];
          if(maxi<dp[i])maxi=dp[i];
        }
      }
    }
    return maxi ;
  }
  static int maxSum2(int arr[],int n){
    int dp[]=new int[n];
    int maxi=0 ;
    for(int i=1 ; i<n ; i++){
      dp[i]=arr[i];
      if(maxi<arr[i])maxi=arr[i];
    }
    for(int i=3 ; i<n ; i++){
      for(int j=1 ; j<i-1 ; j++){
        if(dp[i]<arr[i]+dp[j]){
          dp[i]=arr[i]+dp[j];
          if(maxi<dp[i])maxi=dp[i];
        }
      }
    }
    return maxi ;
  }
  static int findMaxSum(int arr[],int n){
    int t=Math.max(maxSum1(arr,n),maxSum2(arr,n));
    return t ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,1 };
      int n=arr.length ;
      System.out.println(findMaxSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSum1( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
     var maxi : int ; maxi := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     dp[i+1] := arr[i+1] ; 
     if (maxi < arr[i+1]) then     maxi := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i < n - 1 do ( (         var j : int ; j := 0 ; while j < i - 1 do ( (     if (dp[i+1] < dp[j+1] + arr[i+1]) then (     dp[i+1] := dp[j+1] + arr[i+1] ; 
     if (maxi < dp[i+1]) then     maxi := dp[i+1] ; else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return maxi 
 );
  static   operation maxSum2( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
     var maxi : int ; maxi := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     dp[i+1] := arr[i+1] ; 
     if (maxi < arr[i+1]) then     maxi := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 3 ; while i < n do ( (         var j : int ; j := 1 ; while j < i - 1 do ( (     if (dp[i+1] < arr[i+1] + dp[j+1]) then (     dp[i+1] := arr[i+1] + dp[j+1] ; 
     if (maxi < dp[i+1]) then     maxi := dp[i+1] ; else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return maxi 
 );
  static   operation findMaxSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var t : int ; t := Set{maxSum1(arr, n), maxSum2(arr, n)}->max() ;
     return t );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMaxSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static FastReader sc=new FastReader();
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args)throws IOException {
    int n=sc.nextInt();
    double[][] f=new double[n+1][3];
    double p=0.0 ;
    for(int i=1 ; i<=n ; ++i){
      p=sc.nextDouble();
      f[i][0]=(f[i-1][0]+1)*p ;
      f[i][1]=f[i-1][1]+(2*f[i-1][0]+1)*p ;
    }
    out.printf("%f\n",f[n][1]);
    out.flush();
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    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 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : FastReader := FastReader.newFastReader();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var f : Sequence(Sequence(double)) ; f := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,3)->collect(0.0)) ;
    var p : double ; p := 0.0 ;
        var i : int ; i := 1 ; while i <= n do ( (     p := sc.nextDouble() ; 
     f[i+1][0+1] := (f[i - 1+1][0+1] + 1) * p ; 
     f[i+1][1+1] := f[i - 1+1][1+1] + (2 * f[i - 1+1][0+1] + 1) * p )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxRectangles(int L,int B,int l,int b){
    int horizontal=0,vertical=0 ;
    if(l<=L && b<=B){
      int columns=B/b ;
      int rows=L/l ;
      horizontal=rows*columns ;
    }
    if(l<=B && b<=L){
      int columns=L/b ;
      int rows=B/l ;
      vertical=rows*columns ;
    }
    return Math.max(horizontal,vertical);
  }
  public static void main(String[] args){
    int L=10,B=7,l=4,b=3 ;
    System.out.print(maxRectangles(L,B,l,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxRectangles( L : int, B : int, l : int, b : int) : int
  pre: true
  post: true
  activity: (     var horizontal : int ; horizontal := 0 ;
    var vertical : int ; vertical := 0 ;
     if (l <= L & b <= B) then (     var columns : int ; columns := B / b ;
     var rows : int ; rows := L / l ;
     horizontal := rows * columns ) else skip ; 
     if (l <= B & b <= L) then (     var columns : int ; columns := L / b ;
     var rows : int ; rows := B / l ;
     vertical := rows * columns ) else skip ; 
     return Set{horizontal, vertical}->max() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 10 ;
    var B : int ; B := 7 ;
    var l : int ; l := 4 ;
    var b : int ; b := 3 ;
     OclFile["System.out"].print(maxRectangles(L, B, l, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class demo {
  public static double sumOfTheSeries(int n){
    return(double)n/(n+1);
  }
  public static void main(String args[]){
    int n=10 ;
    System.out.println(sumOfTheSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class demo {
  static   operation sumOfTheSeries( n : int) : double
  pre: true
  post: true
  activity: (     return n->oclAsType(double) / (n + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(sumOfTheSeries(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static int method(int n){
    int sum=0 ;
    while(n>0){
      sum+=n % 10 ;
      n=n/10 ;
    }
    return sum ;
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    int count=1 ;
    int sum=0 ;
    if(str.length()!=1){
      for(int i=0 ; i<str.length(); i++){
        sum=sum+(str.charAt(i)-'0');
      }
      while(sum>=10){
        sum=method(sum);
        count++;
      }
      System.out.println(count);
    }
    else {
      System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation method( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n > 0) do (     sum := sum+(n mod 10) ; 
     n := n / 10 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var count : int ; count := 1 ;
    var sum : int ; sum := 0 ;
    if (str->size() /= 1) then (         var i : int ; i := 0 ; while i < str->size() do ( (     sum := sum + (str->at(i+1) - ('0')->char2byte()) )  ;     i := i + 1 ) ; 
     while (sum >= 10) do (     sum := method(sum) ; 
     count := count + 1 ) ; 
     OclFile["System.out"].println(count) ) else (     OclFile["System.out"].println(0) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static int method(int n){
    int sum=0 ;
    while(n>0){
      sum+=n % 10 ;
      n=n/10 ;
    }
    return sum ;
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    int count=1 ;
    int sum=0 ;
    int ans ;
    if(str.length()!=1){
      for(int i=0 ; i<str.length(); i++){
        sum=sum+(str.charAt(i)-'0');
      }
      while(sum>=10){
        ans=sum ;
        sum=method(sum);
        count++;
      }
      System.out.println(count);
    }
    else {
      System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation method( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n > 0) do (     sum := sum+(n mod 10) ; 
     n := n / 10 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var count : int ; count := 1 ;
    var sum : int ; sum := 0 ;
    var ans : int ;
    if (str->size() /= 1) then (         var i : int ; i := 0 ; while i < str->size() do ( (     sum := sum + (str->at(i+1) - ('0')->char2byte()) )  ;     i := i + 1 ) ; 
     while (sum >= 10) do (     ans := sum ; 
     sum := method(sum) ; 
     count := count + 1 ) ; 
     OclFile["System.out"].println(count) ) else (     OclFile["System.out"].println(0) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    Scanner sc=new Scanner(systemin);
    int N=sc.nextInt();
    int max=Integer.MIN_VALUE ;
    int min=Integer.MAX_VALUE ;
    for(int i=0 ; i<N ; i++){
      int x=sc.nextInt();
      max=Math.max(max,x);
      min=Math.min(min,x);
    }
    result.printf("%d\n",(max-min+1)/2);
    sc.close();
    return false ;
  }
  PrintStream log ;
  PrintStream result=System.out ;
  BufferedReader systemin ;
  static Main instance=new Main();
  Main(){
    systemin=new BufferedReader(new InputStreamReader(System.in));
    log=new PrintStream(new OutputStream(){
      public void write(int b){
      }
    }
);
  }
  public static void main(String[] args)throws IOException {
    instance.main();
    instance.systemin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(systemin) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var max : int ; max := -2147483648 ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < N do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     max := Set{max, x}->max() ; 
     min := Set{min, x}->min() )  ;     i := i + 1 ) ; 
    result.printf("%d\n", (max - min + 1) / 2) ; 
    skip ; 
    return false 
 );
   attribute log : OclFile;
   attribute result : OclFile := OclFile["System.out"];
   attribute systemin : OclFile;
  static   attribute instance : Main := Main.newMain();
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     systemin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     log := OclFile.newOclFile_Write(OclFile()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     instance.main() ; 
     instance.systemin.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    out=new PrintWriter(new BufferedOutputStream(System.out));
    String s=sc.nextLine();
    long times=0 ;
    while(s.length()>1){
      times++;
      char[] chars=s.toCharArray();
      BigInteger bigInteger=BigInteger.valueOf(0);
      bigInteger=sum(chars,bigInteger);
      s=bigInteger.toString();
    }
    System.out.println(times);
    out.close();
  }
  private static long MAX_9_VALUE=1024819115206086100L ;
  private static BigInteger sum(char[] chars,BigInteger bigInteger){
    long l=0 ;
    for(int i=0 ; i<chars.length ; i++){
      if(l % MAX_9_VALUE==0){
        bigInteger=bigInteger.add(BigInteger.valueOf(l));
        l=0 ;
      }
      l+=chars[i]-'0' ;
    }
    bigInteger=bigInteger.add(BigInteger.valueOf(l));
    return bigInteger ;
  }
  public static PrintWriter out ;
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var s : String ; s := sc.nextLine() ;
    var times : long ; times := 0 ;
    while (s->size() > 1) do (     times := times + 1 ; 
     var chars : Sequence(String) ; chars := s->characters() ;
    var bigInteger : long ; bigInteger := (0 + "")->toLong() ;
    bigInteger := sum(chars, bigInteger) ; 
    s := bigInteger+"" ; 
 ) ; 
    OclFile["System.out"].println(times) ; 
    out.close() ; 
 );
  static   attribute MAX_9_VALUE : long := 1024819115206086100L;
  static   operation sum( chars : Sequence(String), bigInteger : long) : long
  pre: true
  post: true
  activity: (     var l : long ; l := 0 ;
         var i : int ; i := 0 ; while i < chars->size() do ( (     if (l mod MAX_9_VALUE = 0) then (     bigInteger := bigInteger->excludes((l + "")->toLong()) ; 
     l := 0 ) else skip ; 
     l := l+(chars[i+1] - ('0')->char2byte()) )  ;     i := i + 1 ) ; 
     bigInteger := bigInteger->excludes((l + "")->toLong()) ; 
     return bigInteger );
  static   attribute out : OclFile;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int countDigitsToBeRemoved(int N,int K){
    String s=Integer.toString(N);
    int res=0 ;
    int f_zero=0 ;
    for(int i=s.length()-1 ; i>=0 ; i--){
      if(K==0)return res ;
      if(s.charAt(i)=='0'){
        f_zero=1 ;
        K--;
      }
      else res++;
    }
    if(K==0)return res ;
    else if(f_zero==1)return s.length()-1 ;
    return-1 ;
  }
  public static void main(String[] args){
    int N=10904025 ;
    int K=2 ;
    System.out.println(countDigitsToBeRemoved(N,K));
    N=1000 ;
    K=5 ;
    System.out.println(countDigitsToBeRemoved(N,K));
    N=23985 ;
    K=2 ;
    System.out.println(countDigitsToBeRemoved(N,K));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countDigitsToBeRemoved( N : int, K : int) : int
  pre: true
  post: true
  activity: (     var s : String ; s := ((N) + "") ;
     var res : int ; res := 0 ;
    var f_zero : int ; f_zero := 0 ;
        var i : int ; i := s->size() - 1 ; while i >= 0 do ( (     if (K = 0) then     return res else skip ; 
     if (s->at(i+1) = '0') then (     f_zero := 1 ; 
     K := K - 1 ) else     res := res + 1 ; )  ;     i := i - 1 ) ; 
    if (K = 0) then     return res else     if (f_zero = 1) then     return s->size() - 1 else skip ; ;  
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 10904025 ;
     var K : int ; K := 2 ;
    OclFile["System.out"].println(countDigitsToBeRemoved(N, K)) ; 
    N := 1000 ; 
    K := 5 ; 
    OclFile["System.out"].println(countDigitsToBeRemoved(N, K)) ; 
    N := 23985 ; 
    K := 2 ; 
    OclFile["System.out"].println(countDigitsToBeRemoved(N, K)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPerfect(int N){
    if((Math.sqrt(N)-Math.floor(Math.sqrt(N)))!=0)return false ;
    return true ;
  }
  static void getClosestPerfectSquare(int N){
    if(isPerfect(N)){
      System.out.println(N+" "+"0");
      return ;
    }
    int aboveN=-1,belowN=-1 ;
    int n1 ;
    n1=N+1 ;
    while(true){
      if(isPerfect(n1)){
        aboveN=n1 ;
        break ;
      }
      else n1++;
    }
    n1=N-1 ;
    while(true){
      if(isPerfect(n1)){
        belowN=n1 ;
        break ;
      }
      else n1--;
    }
    int diff1=aboveN-N ;
    int diff2=N-belowN ;
    if(diff1>diff2)System.out.println(belowN+" "+diff2);
    else System.out.println(aboveN+" "+diff1);
  }
  public static void main(String args[]){
    int N=1500 ;
    getClosestPerfectSquare(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPerfect( N : int) : boolean
  pre: true
  post: true
  activity: (     if (((N)->sqrt() - ((N)->sqrt())->floor()) /= 0) then     return false else skip ; 
     return true );
  static   operation getClosestPerfectSquare( N : int) : void
  pre: true
  post: true
  activity: (     if (isPerfect(N)) then (     OclFile["System.out"].println(N + " " + "0") ; 
     return ) else skip ; 
     var aboveN : int ; aboveN := -1 ;
    var belowN : int ; belowN := -1 ;
    var n1 : int ;
    n1 := N + 1 ; 
    while (true) do (     if (isPerfect(n1)) then (     aboveN := n1 ; 
     break ) else     n1 := n1 + 1 ; ) ; 
    n1 := N - 1 ; 
    while (true) do (     if (isPerfect(n1)) then (     belowN := n1 ; 
     break ) else     n1 := n1 - 1 ; ) ; 
    var diff1 : int ; diff1 := aboveN - N ;
    var diff2 : int ; diff2 := N - belowN ;
    if (diff1 > diff2) then     OclFile["System.out"].println(belowN + " " + diff2) else     OclFile["System.out"].println(aboveN + " " + diff1) ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 1500 ;
     execute getClosestPerfectSquare(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean Prime(int n){
    for(int j=2 ; j<=Math.sqrt(n); j++)if(n % j==0)return false ;
    return true ;
  }
  static int find_prime(int x,int xsqmodp,int y,int ysqmodp){
    int n=x*x-xsqmodp ;
    int n1=y*y-ysqmodp ;
    for(int j=2 ; j<=Math.max(Math.sqrt(n),Math.sqrt(n1)); j++){
      if(n % j==0 &&(x*x)% j==xsqmodp && n1 % j==0 &&(y*y)% j==ysqmodp)if(Prime(j))return j ;
      int j1=n/j ;
      if(n % j1==0 &&(x*x)% j1==xsqmodp && n1 % j1==0 &&(y*y)% j1==ysqmodp)if(Prime(j1))return j1 ;
      j1=n1/j ;
      if(n % j1==0 &&(x*x)% j1==xsqmodp && n1 % j1==0 &&(y*y)% j1==ysqmodp)if(Prime(j1))return j1 ;
    }
    if(n==n1)return n ;
    return Integer.MIN_VALUE ;
  }
  public static void main(String[] args){
    int x=3,xsqmodp=0,y=5,ysqmodp=1 ;
    System.out.println(find_prime(x,xsqmodp,y,ysqmodp));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Prime( n : int) : boolean
  pre: true
  post: true
  activity: (         var j : int ; j := 2 ; while j <= (n)->sqrt() do (     if (n mod j = 0) then     return false else skip ;  ;     j := j + 1 ) ; 
     return true );
  static   operation find_prime( x : int, xsqmodp : int, y : int, ysqmodp : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := x * x - xsqmodp ;
     var n1 : int ; n1 := y * y - ysqmodp ;
        var j : int ; j := 2 ; while j <= Set{(n)->sqrt(), (n1)->sqrt()}->max() do ( (     if (n mod j = 0 & (x * x) mod j = xsqmodp & n1 mod j = 0 & (y * y) mod j = ysqmodp) then     if (Prime(j)) then     return j else skip ; else skip ; 
     var j1 : int ; j1 := n / j ;
    if (n mod j1 = 0 & (x * x) mod j1 = xsqmodp & n1 mod j1 = 0 & (y * y) mod j1 = ysqmodp) then     if (Prime(j1)) then     return j1 else skip ; else skip ; 
    j1 := n1 / j ; 
    if (n mod j1 = 0 & (x * x) mod j1 = xsqmodp & n1 mod j1 = 0 & (y * y) mod j1 = ysqmodp) then     if (Prime(j1)) then     return j1 else skip ; else skip ; 
 )  ;     j := j + 1 ) ; 
    if (n = n1) then     return n else skip ; 
    return -2147483648 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 3 ;
    var xsqmodp : int ; xsqmodp := 0 ;
    var y : int ; y := 5 ;
    var ysqmodp : int ; ysqmodp := 1 ;
     OclFile["System.out"].println(find_prime(x, xsqmodp, y, ysqmodp)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class room_stair {
  public static void main(String args[]){
    int t ;
    Scanner in=new Scanner(System.in);
    t=in.nextInt();
    while(t!=0){
      t--;
      int n ;
      n=in.nextInt();
      in.nextLine();
      String s=in.nextLine();
      int left_most=0,right_most=0,i,j ;
      i=0 ;
      while(i<s.length()){
        left_most++;
        if(s.charAt(i)=='1')break ;
        i++;
      }
      if(i==s.length()){
        System.out.println(n);
        continue ;
      }
      i=s.length()-1 ;
      while(i>=0){
        right_most++;
        if(s.charAt(i)=='1')break ;
        i--;
      }
      int c=Math.min(left_most,right_most);
      System.out.println(2*(n-c+1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class room_stair {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     t := in.getCurrent()->toInteger() ; 
     while (t /= 0) do (     t := t - 1 ; 
     var n : int ;
    n := in.getCurrent()->toInteger() ; 
    skip ; 
    var s : String ; s := in.nextLine() ;
    var left_most : int ; left_most := 0 ;
    var right_most : int ; right_most := 0 ;
    var i : int ;
    var j : int ;
    i := 0 ; 
    while (i < s->size()) do (     left_most := left_most + 1 ; 
     if (s->at(i+1) = '1') then     break else skip ; 
     i := i + 1 ) ; 
    if (i = s->size()) then (     OclFile["System.out"].println(n) ; 
     continue ) else skip ; 
    i := s->size() - 1 ; 
    while (i >= 0) do (     right_most := right_most + 1 ; 
     if (s->at(i+1) = '1') then     break else skip ; 
     i := i - 1 ) ; 
    var c : int ; c := Set{left_most, right_most}->min() ;
    OclFile["System.out"].println(2 * (n - c + 1)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class MyClass {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    while(t-->0){
      int n=Integer.parseInt(br.readLine());
      String s=br.readLine();
      int st=-1,en=-1 ;
      int one=0 ;
      for(int i=0 ; i<n ; i++){
        if(s.charAt(i)=='1'){
          one++;
          if(st==-1)st=i ;
          en=i ;
        }
      }
      if(one==0){
        System.out.println(n);
      }
      else {
        int ans=2*Math.max(en+1,n-st);
        System.out.println(ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
     var s : String ; s := br.readLine() ;
    var st : int ; st := -1 ;
    var en : int ; en := -1 ;
    var one : int ; one := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = '1') then (     one := one + 1 ; 
     if (st = -1) then     st := i ; else skip ; 
     en := i ) else skip )  ;     i := i + 1 ) ; 
    if (one = 0) then (     OclFile["System.out"].println(n) ) else (     var ans : int ; ans := 2 * Set{en + 1, n - (st)->char2byte()}->max() ;
     OclFile["System.out"].println(ans) ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    int K=sc.nextInt();
    HashSet<Integer>set=new HashSet<>();
    for(int i=0 ; i<K ; ++i){
      set.add(sc.nextInt());
    }
    for(int i=N ; ; ++i){
      boolean ok=true ;
      int p=i ;
      while(p>0){
        if(set.contains(p % 10)){
          ok=false ;
          break ;
        }
        p/=10 ;
      }
      if(ok){
        System.out.println(i);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < K do ( (     set := set->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := N ; while true do ( (     var ok : boolean ; ok := true ;
     var p : int ; p := i ;
     while (p > 0) do (     if (set->includes(p mod 10)) then (     ok := false ; 
     break ) else skip ; 
     p := p/(10) ) ; 
     if (ok) then (     OclFile["System.out"].println(i) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class pre5 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int tc=obj.nextInt();
    while(tc--!=0){
      int n=obj.nextInt(),arr[]=new int[n];
      char str[]=obj.next().toCharArray();
      for(int i=0 ; i<n ; i++)arr[i]=(str[i]=='1')? 1 : 0 ;
      if(arr[0]==1 || arr[n-1]==1)out.println(2*n);
      else {
        int ans=n ;
        for(int i=0 ; i<n ; i++){
          if(arr[i]==1){
            int l=i+1,r=n-i ;
            ans=max(ans,max(l,r)*2);
          }
        }
        out.println(ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre5 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var tc : int ; tc := obj.nextInt() ;
         while (tc /= 0) do (    skip ; (     var n : int ; n := obj.nextInt() ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,n)->collect(0) ;
     var str : Sequence(String) ; str := obj.next()->characters() ;
         var i : int ; i := 0 ; while i < n do (     arr[i+1] := if (str[i+1] = '1') then 1 else 0 endif ;  ;     i := i + 1 ) ; 
     if (arr[0+1] = 1 or arr[n - 1+1] = 1) then     out.println(2 * n) ; else (     var ans : int ; ans := n ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 1) then (     var l : int ; l := i + 1 ;
    var r : int ; r := n - (i)->char2byte() ;
     ans := Set{ans, Set{l, r}->max() * 2}->max() ) else skip )  ;     i := i + 1 ) ; 
     out.println(ans) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class RoomsAndStaircases1244B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int tc=sc.nextInt();
    sc.nextLine();
    for(int i=0 ; i<tc ; i++){
      int len=sc.nextInt();
      sc.nextLine();
      String str=sc.nextLine();
      calcRooms2(str.toCharArray());
    }
  }
  static void calcRooms(char[] arr){
    int sum=0 ;
    if(arr[0]=='1' || arr[arr.length-1]=='1'){
      System.out.println(arr.length*2);
      return ;
    }
    int onec=0 ;
    int zc=0 ;
    for(int i=0 ; i<arr.length ; i++){
      char c=arr[i];
      if(c=='1'){
        onec++;
        sum+=2 ;
      }
      else {
        zc++;
        sum+=1 ;
      }
    }
    System.out.println(onec+" "+zc);
    System.out.println(sum);
  }
  static void calcRooms2(char[] arr){
    int sum1=0 ;
    if(arr[0]=='1' || arr[arr.length-1]=='1'){
      System.out.println(arr.length*2);
      return ;
    }
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i]=='1'){
        sum1=Math.max(sum1,Math.max(2*(arr.length-i),2*(i+1)));
      }
    }
    if(sum1==0){
      System.out.println(arr.length);
    }
    else {
      System.out.println(sum1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class RoomsAndStaircases1244B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := sc.getCurrent()->toInteger() ;
     skip ; 
         var i : int ; i := 0 ; while i < tc do ( (     var len : int ; len := sc.getCurrent()->toInteger() ;
     skip ; 
     var str : String ; str := sc.nextLine() ;
     execute calcRooms2(str->characters()) )  ;     i := i + 1 ) );
  static   operation calcRooms( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     if (arr[0+1] = '1' or arr[arr->size() - 1+1] = '1') then (     OclFile["System.out"].println(arr->size() * 2) ; 
     return ) else skip ; 
    var onec : int ; onec := 0 ;
    var zc : int ; zc := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     var c : String ; c := arr[i+1] ;
     if (c = '1') then (     onec := onec + 1 ; 
     sum := sum+(2) ) else (     zc := zc + 1 ; 
     sum := sum+(1) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(onec + " " + zc) ; 
    OclFile["System.out"].println(sum) ; 
 );
  static   operation calcRooms2( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sum1 : int ; sum1 := 0 ;
     if (arr[0+1] = '1' or arr[arr->size() - 1+1] = '1') then (     OclFile["System.out"].println(arr->size() * 2) ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = '1') then (     sum1 := Set{sum1, Set{2 * (arr->size() - i), 2 * (i + 1)}->max()}->max() ) else skip )  ;     i := i + 1 ) ; 
     if (sum1 = 0) then (     OclFile["System.out"].println(arr->size()) ) else (     OclFile["System.out"].println(sum1) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    roomsAndStaircases();
    ;
  }
  public static void roomsAndStaircases(){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=scan.nextInt();
      String s=scan.next();
      int out=n ;
      for(int i=0 ; i<(n+1)/2 ; i++){
        if(s.charAt(i)=='1' || s.charAt(n-i-1)=='1'){
          out=(n-i)*2 ;
          break ;
        }
      }
      System.out.println(out);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute roomsAndStaircases() ; 
  );
  static   operation roomsAndStaircases() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var s : String ; s := scan.getCurrent() ;
    var out : int ; out := n ;
        var i : int ; i := 0 ; while i < (n + 1) / 2 do ( (     if (s->at(i+1) = '1' or s->at(n - i - 1+1) = '1') then (     out := (n - i) * 2 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(out) ; 
 )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    FastScanner sc=new FastScanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    int[] adresses=new int[n];
    for(int i=0 ; i<n ; i++)adresses[i]=sc.nextInt();
    Arrays.sort(adresses);
    int dif=(adresses[n-1]-adresses[0]);
    int ans=0 ;
    if(dif % 2==0)ans=dif/2 ;
    else ans=dif/2+1 ;
    out.println(ans);
    out.flush();
  }
  static class FastScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public FastScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
      tokenizer=null ;
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          return reader.readLine();
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken("\n");
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.nextInt() ;
    var adresses : Sequence(int) ; adresses := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     adresses[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
    adresses := adresses->sort() ; 
    var dif : int ; dif := (adresses[n - 1+1] - adresses[0+1]) ;
    var ans : int ; ans := 0 ;
    if (dif mod 2 = 0) then     ans := dif / 2 else     ans := dif / 2 + 1 ; ;  
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.nextToken("\n") );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printSum(int m[],int s[],int n){
    int total=0 ;
    for(int i=0 ; i<n ; i++){
      total+=s[i];
      total+=(m[i]*60);
    }
    System.out.print(total/3600+" : ");
    total %=3600 ;
    System.out.print(total/60+": ");
    total %=60 ;
    System.out.println(total);
  }
  public static void main(String[] args){
    int m[]={
      0,2,3,2,1 };
      int s[]={
        45,31,11,27,28 };
        int n=m.length ;
        printSum(m,s,n);
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printSum( m : Sequence(int), s : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var total : int ; total := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     total := total+(s[i+1]) ; 
     total := total+((m[i+1] * 60)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(total / 3600 + " : ") ; 
    total := total mod 3600 ; 
    OclFile["System.out"].print(total / 60 + ": ") ; 
    total := total mod 60 ; 
    OclFile["System.out"].println(total) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Sequence(int) ; m := Sequence{0,2,3,2,1} ;
     var s : Sequence(int) ; s := Sequence{45,31,11,27,28} ;
     var n : int ; n := m->size() ;
     execute printSum(m, s, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long countWays(int n,int k){
    long total=k ;
    int mod=1000000007 ;
    int same=0,diff=k ;
    for(int i=2 ; i<=n ; i++){
      same=diff ;
      diff=(int)total*(k-1);
      diff=diff % mod ;
      total=(same+diff)% mod ;
    }
    return total ;
  }
  public static void main(String[] args){
    int n=3,k=2 ;
    System.out.println(countWays(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countWays( n : int, k : int) : long
  pre: true
  post: true
  activity: (     var total : long ; total := k ;
     var mod : int ; mod := 1000000007 ;
    var same : int ; same := 0 ;
    var diff : int ; diff := k ;
        var i : int ; i := 2 ; while i <= n do ( (     same := diff ; 
     diff := total->oclAsType(int) * (k - 1) ; 
     diff := diff mod mod ; 
     total := (same + diff) mod mod )  ;     i := i + 1 ) ; 
    return total 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
    var k : int ; k := 2 ;
     OclFile["System.out"].println(countWays(n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    Long[] bestSushi=new Long[N];
    Arrays.fill(bestSushi,0L);
    List<Long>otherSushi=new ArrayList<>(N);
    int sushiKind=0 ;
    for(int n=0 ; n<N ; n++){
      int t=sc.nextInt()-1 ;
      long d=sc.nextLong();
      if(bestSushi[t]==0)sushiKind++;
      if(bestSushi[t]>=d)otherSushi.add(d);
      else {
        otherSushi.add(new Long(bestSushi[t]));
        bestSushi[t]=d ;
      }
    }
    Arrays.sort(bestSushi,Comparator.reverseOrder());
    Collections.sort(otherSushi,Comparator.reverseOrder());
    long[] bestSum=new long[K+1];
    bestSum[0]=0L ;
    for(int k=1 ; k<=K ; k++){
      bestSum[k]=bestSum[k-1]+bestSushi[k-1];
    }
    long[] otherSum=new long[K+1];
    otherSum[0]=0L ;
    for(int k=1 ; k<=K ; k++){
      otherSum[k]=otherSum[k-1]+otherSushi.get(k-1);
    }
    long ans=0 ;
    for(int kind=1 ; kind<=Math.min(K,sushiKind); kind++){
      int other=K-kind ;
      ans=Math.max(ans,bestSum[kind]+otherSum[other]+((long)kind)*kind);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var bestSushi : Sequence(long) ; bestSushi := Integer.subrange(1,N)->collect(null) ;
    bestSushi := bestSushi->collect(0L) ; 
    var otherSushi : Sequence(long) ; otherSushi := Sequence{} ;
    var sushiKind : int ; sushiKind := 0 ;
        var n : int ; n := 0 ; while n < N do ( (     var t : int ; t := sc.getCurrent()->toInteger() - 1 ;
     var d : long ; d := sc.getCurrent()->toLong() ;
     if (bestSushi[t+1] = 0) then     sushiKind := sushiKind + 1 ; else skip ; 
     if (bestSushi[t+1] >= d) then     otherSushi := otherSushi->including(d) ; else (     otherSushi := otherSushi->including(("" + (bestSushi[t+1]))->toLong()) ; 
     bestSushi[t+1] := d ) )  ;     n := n + 1 ) ; 
    bestSushi := OclComparator.sortWith(bestSushi, Comparator.reverseOrder()) ; 
    otherSushi, Comparator.reverseOrder() := otherSushi, Comparator.reverseOrder()->sort() ; 
    var bestSum : Sequence(long) ; bestSum := Integer.subrange(1,K + 1)->collect(0) ;
    bestSum[0+1] := 0L ; 
        var k : int ; k := 1 ; while k <= K do ( (     bestSum[k+1] := bestSum[k - 1+1] + bestSushi[k - 1+1] )  ;     k := k + 1 ) ; 
    var otherSum : Sequence(long) ; otherSum := Integer.subrange(1,K + 1)->collect(0) ;
    otherSum[0+1] := 0L ; 
        var k : int ; k := 1 ; while k <= K do ( (     otherSum[k+1] := otherSum[k - 1+1] + otherSushi->at(k - 1+1) )  ;     k := k + 1 ) ; 
    var ans : long ; ans := 0 ;
        var kind : int ; kind := 1 ; while kind <= Set{K, sushiKind}->min() do ( (     var other : int ; other := K - kind ;
     ans := Set{ans, bestSum[kind+1] + otherSum[other+1] + (kind->oclAsType(long)) * kind}->max() )  ;     kind := kind + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.Stack ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    int[] t=new int[N];
    int[] d=new int[N];
    for(int i=0 ; i<N ; ++i){
      t[i]=sc.nextInt();
      d[i]=sc.nextInt();
    }
    System.out.println(solve(t,d,K));
    sc.close();
  }
  static long solve(int[] t,int[] d,int K){
    int[] sortedIndices=IntStream.range(0,t.length).boxed().sorted((i1,i2)->-Integer.compare(d[i1],d[i2])).mapToInt(x->x).toArray();
    Set<Integer>kinds=new HashSet<>();
    long dSum=0 ;
    Stack<Integer>extraDs=new Stack<>();
    for(int i=0 ; i<K ; ++i){
      int index=sortedIndices[i];
      dSum+=d[index];
      if(kinds.contains(t[index])){
        extraDs.push(d[index]);
      }
      else {
        kinds.add(t[index]);
      }
    }
    long result=dSum+(long)kinds.size()*kinds.size();
    for(int i=K ; i<sortedIndices.length ; ++i){
      int index=sortedIndices[i];
      if(! extraDs.empty()&& ! kinds.contains(t[index])){
        dSum+=d[index]-extraDs.pop();
        kinds.add(t[index]);
        result=Math.max(result,dSum+(long)kinds.size()*kinds.size());
      }
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,N)->collect(0) ;
    var d : Sequence(int) ; d := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     t[i+1] := sc.getCurrent()->toInteger() ; 
     d[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(t, d, K)) ; 
    skip ; 
 );
  static   operation solve( t : Sequence(int), d : Sequence(int), K : int) : long
  pre: true
  post: true
  activity: (     var sortedIndices : Sequence(int) ; sortedIndices := Integer.subrange(0, t->size()-1)->sort()->collect( _x1 | (lambda x : OclAny in x)->apply(_x1) )->asSequence() ;
     var kinds : Set(int) ; kinds := Set{} ;
    var dSum : long ; dSum := 0 ;
    var extraDs : Sequence(int) ; extraDs := Sequence{} ;
        var i : int ; i := 0 ; while i < K do ( (     var index : int ; index := sortedIndices[i+1] ;
     dSum := dSum+(d[index+1]) ; 
     if (kinds->includes(t[index+1])) then (     extraDs := extraDs->append(d[index+1]) ) else (     kinds := kinds->including(t[index+1]) ) )  ;     i := i + 1 ) ; 
    var result : long ; result := dSum + kinds->size()->oclAsType(long) * kinds->size() ;
        var i : int ; i := K ; while i < sortedIndices->size() do ( (     var index : int ; index := sortedIndices[i+1] ;
     if (not(extraDs->isEmpty()) & not(kinds->includes(t[index+1]))) then (     dSum := dSum+(d[index+1] - extraDs->last()) ; 
     kinds := kinds->including(t[index+1]) ; 
     result := Set{result, dSum + kinds->size()->oclAsType(long) * kinds->size()}->max() ) else skip )  ;     i := i + 1 ) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf708A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String in=scan.next();
    int index=0 ;
    while(in.charAt(index)=='a'){
      index++;
      if(index==in.length()){
        break ;
      }
    }
    StringBuilder out ;
    if(index==in.length()){
      out=new StringBuilder(in);
      out.setCharAt(in.length()-1,shift('a'));
    }
    else {
      out=new StringBuilder(in.substring(0,index));
      while(in.charAt(index)!='a'){
        out.append(shift(in.charAt(index)));
        index++;
        if(index==in.length()){
          break ;
        }
      }
      out.append(in.substring(index));
    }
    System.out.println(out);
  }
  public static char shift(char c){
    if(c=='a'){
      return 'z' ;
    }
    else {
      return(char)(c-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf708A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var in : String ; in := scan.getCurrent() ;
    var index : int ; index := 0 ;
    while (in->at(index+1) = 'a') do (     index := index + 1 ; 
     if (index = in->size()) then (     break ) else skip ) ; 
    var out : String ;
    if (index = in->size()) then (     out := StringLib.newString(in) ; 
     out := out.setAt(in->size() - 1+1, shift('a')) ) else (     out := StringLib.newString(in.subrange(0+1,index)) ; 
     while (in->at(index+1) /= 'a') do (     out := out + StringLib.newString(shift(in->at(index+1))) ; 
     index := index + 1 ; 
     if (index = in->size()) then (     break ) else skip ) ; 
     out := out + StringLib.newString(in.subrange(index+1,index)) ) ;  
    OclFile["System.out"].println(out) ; 
 );
  static   operation shift( c : String) : String
  pre: true
  post: true
  activity: (     if (c = 'a') then (     return 'z' ) else (     return (c - 1)->oclAsType(String) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Mcf708A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String str=scan.next();
    int index=0 ;
    while(str.charAt(index)=='a'){
      index++;
      if(index==str.length()){
        break ;
      }
    }
    StringBuilder out ;
    if(index==str.length()){
      out=new StringBuilder(str);
      out.setCharAt(index-1,'z');
    }
    else {
      out=new StringBuilder(str.substring(0,index));
      while(str.charAt(index)!='a'){
        out.append(shift(str.charAt(index)));
        index++;
        if(index==str.length()){
          break ;
        }
      }
      out.append(str.substring(index));
    }
    System.out.println(out);
  }
  public static char shift(char c){
    if(c=='a'){
      return 'z' ;
    }
    else {
      return(char)(c-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mcf708A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := scan.getCurrent() ;
    var index : int ; index := 0 ;
    while (str->at(index+1) = 'a') do (     index := index + 1 ; 
     if (index = str->size()) then (     break ) else skip ) ; 
    var out : String ;
    if (index = str->size()) then (     out := StringLib.newString(str) ; 
     out := out.setAt((index)->char2byte() - 1+1, 'z') ) else (     out := StringLib.newString(str.subrange(0+1,index)) ; 
     while (str->at(index+1) /= 'a') do (     out := out + StringLib.newString(shift(str->at(index+1))) ; 
     index := index + 1 ; 
     if (index = str->size()) then (     break ) else skip ) ; 
     out := out + StringLib.newString(str.subrange(index+1,index)) ) ;  
    OclFile["System.out"].println(out) ; 
 );
  static   operation shift( c : String) : String
  pre: true
  post: true
  activity: (     if (c = 'a') then (     return 'z' ) else (     return (c - 1)->oclAsType(String) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf708A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String str=scan.next();
    int index=0 ;
    while(str.charAt(index)=='a'){
      index++;
      if(index==str.length()){
        break ;
      }
    }
    if(index==str.length()){
      StringBuilder out=new StringBuilder(str);
      out.deleteCharAt(out.length()-1);
      out.append('z');
      System.out.println(out);
    }
    else {
      StringBuilder out=new StringBuilder(str.substring(0,index));
      for(int i=index ; i<str.length(); i++){
        if(str.charAt(i)!='a'){
          out.append(poop(str.charAt(i)));
        }
        else {
          out.append(str.substring(i));
          break ;
        }
      }
      System.out.println(out);
    }
  }
  public static char poop(char c){
    if(c=='a'){
      return 'z' ;
    }
    else {
      return(char)(c-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf708A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := scan.getCurrent() ;
    var index : int ; index := 0 ;
    while (str->at(index+1) = 'a') do (     index := index + 1 ; 
     if (index = str->size()) then (     break ) else skip ) ; 
    if (index = str->size()) then (     var out : String ; out := StringLib.newString(str) ;
     out := out->excludingAt(out->size() - 1+1) ; 
     out := out + StringLib.newString('z') ; 
     OclFile["System.out"].println(out) ) else (     var out : String ; out := StringLib.newString(str.subrange(0+1,index)) ;
         var i : int ; i := index ; while i < str->size() do ( (     if (str->at(i+1) /= 'a') then (     out := out + StringLib.newString(poop(str->at(i+1))) ) else (     out := out + StringLib.newString(str.subrange(i+1,i)) ; 
     break ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(out) ) ;  
 );
  static   operation poop( c : String) : String
  pre: true
  post: true
  activity: (     if (c = 'a') then (     return 'z' ) else (     return (c - 1)->oclAsType(String) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStreamReader ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReaderMain in=new InputReaderMain(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskMain solver=new TaskMain();
    solver.solve(1,in,out);
    out.close();
  }
}
class TaskMain {
  public boolean check(int cur,int[] arr){
    boolean ok=true ;
    while(cur!=0){
      int r=cur % 10 ;
      for(int i=0 ; i<arr.length ; ++i){
        if(arr[i]==r)ok=false ;
      }
      cur/=10 ;
    }
    if(ok)return true ;
    return false ;
  }
  public void solve(int taskNumber,InputReaderMain in,PrintWriter out){
    int N ;
    int K ;
    N=in.nextInt();
    K=in.nextInt();
    int[] arr=new int[K];
    for(int i=0 ; i<K ; ++i){
      int a=in.nextInt();
      arr[i]=a ;
    }
    for(int i=N ; i<N*10 ; ++i){
      if(check(i,arr)){
        System.out.println(i);
        return ;
      }
    }
  }
}
class InputReaderMain {
  public BufferedReader reader ;
  public StringTokenizer tokenizer ;
  public InputReaderMain(InputStream stream){
    reader=new BufferedReader(new InputStreamReader(stream),32768);
    tokenizer=null ;
  }
  public String next(){
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        tokenizer=new StringTokenizer(reader.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReaderMain ; in := InputReaderMain.newInputReaderMain(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskMain ; solver := TaskMain.newTaskMain() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
}
class TaskMain {
   operation check( cur : int, arr : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var ok : boolean ; ok := true ;
     while (cur /= 0) do (     var r : int ; r := cur mod 10 ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = r) then     ok := false ; else skip )  ;     i := i + 1 ) ; 
     cur := cur/(10) ) ; 
     if (ok) then     return true else skip ; 
     return false );
   operation solve( taskNumber : int, in : InputReaderMain, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ;
     var K : int ;
    N := in.nextInt() ; 
    K := in.nextInt() ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,K)->collect(0) ;
        var i : int ; i := 0 ; while i < K do ( (     var a : int ; a := in.nextInt() ;
     arr[i+1] := a )  ;     i := i + 1 ) ; 
        var i : int ; i := N ; while i < N * 10 do ( (     if (check(i, arr)) then (     OclFile["System.out"].println(i) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
 );
}
class InputReaderMain {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReaderMain( stream : OclFile) : InputReaderMain
  pre: true
  post: true
  activity:
  ( var self : InputReaderMain ;
    self := createInputReaderMain();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class LettersCyclicShift {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String s=scan.next();
    StringBuilder out=new StringBuilder();
    int index=0 ;
    while(index<s.length()){
      if(s.charAt(index)=='a'){
        out.append('a');
        index++;
      }
      else {
        break ;
      }
    }
    if(index==s.length()){
      out.deleteCharAt(out.length()-1);
      out.append('z');
    }
    else {
      while(index<s.length()){
        if(s.charAt(index)=='a'){
          break ;
        }
        else {
          out.append((char)(s.charAt(index)-1));
          index++;
        }
      }
      while(index<s.length()){
        out.append(s.charAt(index));
        index++;
      }
    }
    System.out.println(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class LettersCyclicShift {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scan.getCurrent() ;
    var out : String ; out := StringLib.newString() ;
    var index : int ; index := 0 ;
    while (index < s->size()) do (     if (s->at(index+1) = 'a') then (     out := out + StringLib.newString('a') ; 
     index := index + 1 ) else (     break ) ) ; 
    if (index = s->size()) then (     out := out->excludingAt(out->size() - 1+1) ; 
     out := out + StringLib.newString('z') ) else (     while (index < s->size()) do (     if (s->at(index+1) = 'a') then (     break ) else (     out := out + StringLib.newString((s->at(index+1) - 1)->oclAsType(String)) ; 
     index := index + 1 ) ) ; 
     while (index < s->size()) do (     out := out + StringLib.newString(s->at(index+1)) ; 
     index := index + 1 ) ) ;  
    OclFile["System.out"].println(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class t {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void mul(int a,int b,int re){
    if(b>0){
      re+=a ;
      b--;
      if(b==0)System.out.println(re);
      mul(a,b,re);
    }
  }
  public static void main(String[] args){
    FastReader in=new FastReader();
    int n=in.nextInt();
    int s=n*(n+1);
    s/=2 ;
    int nu=-1 ;
    int root=(int)Math.sqrt(s);
    root++;
    for(int i=2 ; i<root+1 ; i++){
      if(s % i==0){
        nu=i ;
        break ;
      }
    }
    if(nu==-1){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
      System.out.println(1+" "+nu);
      System.out.print(n-1+" ");
      for(int i=1 ; i<n+1 ; i++){
        if(i!=nu){
          System.out.print(i+" ");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class t {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation mul( a : int, b : int, re : int) : void
  pre: true
  post: true
  activity: (     if (b > 0) then (     re := re+(a) ; 
     b := b - 1 ; 
     if (b = 0) then     OclFile["System.out"].println(re) ; else skip ; 
     execute mul(a, b, re) ) else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var n : int ; n := in.nextInt() ;
    var s : int ; s := n * (n + 1) ;
    s := s/(2) ; 
    var nu : int ; nu := -1 ;
    var root : int ; root := (s)->sqrt()->oclAsType(int) ;
    root := root + 1 ; 
        var i : int ; i := 2 ; while i < root + 1 do ( (     if (s mod i = 0) then (     nu := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (nu = -1) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ; 
     OclFile["System.out"].println(1 + " " + nu) ; 
     OclFile["System.out"].print(n - 1 + " ") ; 
         var i : int ; i := 1 ; while i < n + 1 do ( (     if (i /= nu) then (     OclFile["System.out"].print(i + " ") ) else skip )  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int MAX=1000000 ;
  static Vector<Integer>arr=new Vector<Integer>();
  static boolean[] prime=new boolean[MAX];
  static void SieveOfEratosthenes(){
    for(int i=0 ; i<MAX ; i++)prime[i]=true ;
    for(int p=2 ; p*p<MAX ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<MAX ; i+=p)prime[i]=false ;
      }
    }
    for(int p=2 ; p<MAX ; p++)if(prime[p])arr.add(p);
  }
  static boolean isPrimorialPrime(int n){
    if(! prime[n])return false ;
    long product=1 ;
    int i=0 ;
    while(product<n){
      product=product*arr.get(i);
      if(product+1==n || product-1==n)return true ;
      i++;
    }
    return false ;
  }
  public static void main(String[] args){
    SieveOfEratosthenes();
    int n=31 ;
    if(isPrimorialPrime(n))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX : int := 1000000;
  static   attribute arr : Sequence(int) := Sequence{};
  static   attribute prime : Sequence(boolean) := Integer.subrange(1,MAX)->collect(false);
  static   operation SieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < MAX do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
         var p : int ; p := 2 ; while p * p < MAX do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i < MAX do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
         var p : int ; p := 2 ; while p < MAX do (     if (prime[p+1]) then     arr := arr->including(p) ; else skip ;  ;     p := p + 1 ) );
  static   operation isPrimorialPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (not(prime[n+1])) then     return false else skip ; 
     var product : long ; product := 1 ;
    var i : int ; i := 0 ;
    while (product < n) do (     product := product * arr->at(i+1) ; 
     if (product + 1 = n or product - 1 = n) then     return true else skip ; 
     i := i + 1 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes() ; 
     var n : int ; n := 31 ;
     if (isPrimorialPrime(n)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPalindrome(int n){
    int divisor=1 ;
    while(n/divisor>=10)divisor*=10 ;
    while(n!=0){
      int leading=n/divisor ;
      int trailing=n % 10 ;
      if(leading!=trailing)return false ;
      n=(n % divisor)/10 ;
      divisor=divisor/100 ;
    }
    return true ;
  }
  static int largestPalindrome(int[] A,int n){
    Arrays.sort(A);
    for(int i=n-1 ; i>=0 ; --i){
      if(isPalindrome(A[i]))return A[i];
    }
    return-1 ;
  }
  public static void main(String[] args){
    int[] A={
      1,232,54545,999991 };
      int n=A.length ;
      System.out.println(largestPalindrome(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPalindrome( n : int) : boolean
  pre: true
  post: true
  activity: (     var divisor : int ; divisor := 1 ;
     while (n / divisor >= 10) do     divisor := divisor*(10) ; ; 
     while (n /= 0) do (     var leading : int ; leading := n / divisor ;
     var trailing : int ; trailing := n mod 10 ;
    if (leading /= trailing) then     return false else skip ; 
    n := (n mod divisor) / 10 ; 
    divisor := divisor / 100 ; 
 ) ; 
     return true );
  static   operation largestPalindrome( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     A := A->sort() ; 
         var i : int ; i := n - 1 ; while i >= 0 do ( (     if (isPalindrome(A[i+1])) then     return A[i+1] else skip )  ;     i := i - 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{1,232,54545,999991} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].println(largestPalindrome(A, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPalindrome(int n){
    int divisor=1 ;
    while(n/divisor>=10)divisor*=10 ;
    while(n!=0){
      int leading=n/divisor ;
      int trailing=n % 10 ;
      if(leading!=trailing)return false ;
      n=(n % divisor)/10 ;
      divisor=divisor/100 ;
    }
    return true ;
  }
  static int largestPalindrome(int[] A,int n){
    int currentMax=-1 ;
    for(int i=0 ; i<n ; i++){
      if(A[i]>currentMax && isPalindrome(A[i]))currentMax=A[i];
    }
    return currentMax ;
  }
  public static void main(String[] args){
    int[] A={
      1,232,54545,999991 };
      int n=A.length ;
      System.out.println(largestPalindrome(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPalindrome( n : int) : boolean
  pre: true
  post: true
  activity: (     var divisor : int ; divisor := 1 ;
     while (n / divisor >= 10) do     divisor := divisor*(10) ; ; 
     while (n /= 0) do (     var leading : int ; leading := n / divisor ;
     var trailing : int ; trailing := n mod 10 ;
    if (leading /= trailing) then     return false else skip ; 
    n := (n mod divisor) / 10 ; 
    divisor := divisor / 100 ; 
 ) ; 
     return true );
  static   operation largestPalindrome( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var currentMax : int ; currentMax := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (A[i+1] > currentMax & isPalindrome(A[i+1])) then     currentMax := A[i+1] ; else skip )  ;     i := i + 1 ) ; 
     return currentMax );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{1,232,54545,999991} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].println(largestPalindrome(A, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean isAlphabaticOrder(String s){
    int n=s.length();
    for(int i=1 ; i<n ; i++){
      if(s.charAt(i)<s.charAt(i-1)){
        return false ;
      }
    }
    return true ;
  }
  static public void main(String[] args){
    String s="aabbbcc" ;
    if(isAlphabaticOrder(s)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isAlphabaticOrder( s : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
         var i : int ; i := 1 ; while i < n do ( (     if (s->at(i+1) < s->at(i - 1+1)) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "aabbbcc" ;
     if (isAlphabaticOrder(s)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean check(String s){
    int[] freq=new int[26];
    int n=s.length();
    for(int i=0 ; i<s.length(); i++){
      freq[(s.charAt(i))-97]+=1 ;
    }
    for(int i=0 ; i<freq.length ; i++){
      if(freq[i] % 2==1){
        return false ;
      }
    }
    return true ;
  }
  public static void main(String[] args){
    String s="abaccaba" ;
    if(check(s)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation check( s : String) : boolean
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
     var n : int ; n := s->size() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     freq[(s->at(i+1)) - 97+1] := freq[(s->at(i+1)) - 97+1]+(1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < freq->size() do ( (     if (freq[i+1] mod 2 = 1) then (     return false ) else skip )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abaccaba" ;
     if (check(s)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean check(String s){
    int n=s.length();
    for(int i=0 ; i<n-1 ; i++){
      if(s.charAt(i)>s.charAt(i+1))return true ;
    }
    return false ;
  }
  public static void main(String args[]){
    String s="geeksforgeeks" ;
    if(check(s))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation check( s : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     if (s->at(i+1) > s->at(i + 1+1)) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "geeksforgeeks" ;
     if (check(s)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findSubSeq(int arr[],int n){
    Arrays.sort(arr);
    int count[]=new int[n];
    int prev[]=new int[n];
    int i,j ;
    for(i=0 ; i<n ; i++)count[i]=1 ;
    for(j=0 ; j<n ; j++)prev[j]=-1 ;
    int max=0 ;
    int maxprev=-1 ;
    for(i=0 ; i<n ; i++){
      for(j=i-1 ; j>=0 ; j--){
        if(arr[i] % arr[j]==0 && count[j]+1>count[i]){
          count[i]=count[j]+1 ;
          prev[i]=j ;
        }
      }
      if(max<count[i]){
        max=count[i];
        maxprev=i ;
      }
    }
    i=maxprev ;
    while(i>=0){
      if(arr[i]!=-1)System.out.print(arr[i]+" ");
      i=prev[i];
    }
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5 };
      int n=arr.length ;
      findSubSeq(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSubSeq( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var count : Sequence(int) ; count := Integer.subrange(1,n)->collect(0) ;
    var prev : Sequence(int) ; prev := Integer.subrange(1,n)->collect(0) ;
    var i : int ;
    var j : int ;
        i := 0 ; while i < n do (     count[i+1] := 1 ;  ;     i := i + 1 ) ; 
        j := 0 ; while j < n do (     prev[j+1] := -1 ;  ;     j := j + 1 ) ; 
    var max : int ; max := 0 ;
    var maxprev : int ; maxprev := -1 ;
        i := 0 ; while i < n do ( (         j := i - 1 ; while j >= 0 do ( (     if (arr[i+1] mod arr[j+1] = 0 & count[j+1] + 1 > count[i+1]) then (     count[i+1] := count[j+1] + 1 ; 
     prev[i+1] := j ) else skip )  ;     j := j - 1 ) ; 
     if (max < count[i+1]) then (     max := count[i+1] ; 
     maxprev := i ) else skip )  ;     i := i + 1 ) ; 
    i := maxprev ; 
    while (i >= 0) do (     if (arr[i+1] /= -1) then     OclFile["System.out"].print(arr[i+1] + " ") ; else skip ; 
     i := prev[i+1] ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var n : int ; n := arr->size() ;
     execute findSubSeq(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int N=100005 ;
  static int LIS(int a[],int n){
    int dp[]=new int[N],d[]=new int[N];
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      dp[a[i] ]=1 ;
      for(int j=2 ; j*j<=a[i]; j++){
        if(a[i] % j==0){
          dp[a[i] ]=Math.max(dp[a[i] ],dp[d[j] ]+1);
          dp[a[i] ]=Math.max(dp[a[i] ],dp[d[a[i]/j] ]+1);
          d[j]=a[i];
          d[a[i]/j]=a[i];
        }
      }
      ans=Math.max(ans,dp[a[i] ]);
      d[a[i] ]=a[i];
    }
    return ans ;
  }
  public static void main(String args[]){
    int a[]={
      1,2,3,4,5,6 };
      int n=a.length ;
      System.out.print(LIS(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 100005;
  static   operation LIS( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,N)->collect(0) ;
    var d : Sequence(void) ; d := Integer.subrange(1,N)->collect(0) ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     dp[a[i+1]+1] := 1 ; 
         var j : int ; j := 2 ; while j * j <= a[i+1] do ( (     if (a[i+1] mod j = 0) then (     dp[a[i+1]+1] := Set{dp[a[i+1]+1], dp[d[j+1]+1] + 1}->max() ; 
     dp[a[i+1]+1] := Set{dp[a[i+1]+1], dp[d[a[i+1] / j+1]+1] + 1}->max() ; 
     d[j+1] := a[i+1] ; 
     d[a[i+1] / j+1] := a[i+1] ) else skip )  ;     j := j + 1 ) ; 
     ans := Set{ans, dp[a[i+1]+1]}->max() ; 
     d[a[i+1]+1] := a[i+1] )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,4,5,6} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(LIS(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class demo {
  public static double sumOfTheSeries(int n){
    double sum=0.0 ;
    for(int i=1 ; i<=n ; i++)sum+=1.0/(i*(i+1));
    return sum ;
  }
  public static void main(String args[]){
    int n=10 ;
    System.out.println(sumOfTheSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class demo {
  static   operation sumOfTheSeries( n : int) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0.0 ;
         var i : int ; i := 1 ; while i <= n do (     sum := sum+(1.0 / (i * (i + 1))) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(sumOfTheSeries(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in);
){
      solve(sc);
    }
  }
  public static void solve(Scanner sc){
    int N=sc.nextInt();
    int K=sc.nextInt();
    sc.nextLine();
    String[] Ds=sc.nextLine().split(" ");
    Set<String>DSet=new HashSet<>(Arrays.asList(Ds));
    boolean contains=true ;
    while(contains){
      contains=false ;
      String ns=String.valueOf(N);
      for(int i=0 ; i<ns.length(); i++){
        if(DSet.contains(String.valueOf(ns.charAt(i)))){
          N++;
          contains=true ;
          break ;
        }
      }
    }
    System.out.println(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     execute solve(sc) ))  );
  static   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    skip ; 
    var Ds : Sequence(String) ; Ds := sc.nextLine()->split(" ") ;
    var DSet : Set(String) ; DSet := Set{}->union(Ds) ;
    var contains : boolean ; contains := true ;
    while (contains) do (     contains := false ; 
     var ns : String ; ns := ((N) + "") ;
         var i : int ; i := 0 ; while i < ns->size() do ( (     if (DSet->includes(((ns->at(i+1)) + ""))) then (     N := N + 1 ; 
     contains := true ; 
     break ) else skip )  ;     i := i + 1 ) ) ; 
    OclFile["System.out"].println(N) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    boolean[] arr=new boolean[n];
    for(int i=0 ; i<m ; i++){
      arr[sc.nextInt()-1]=true ;
    }
    int left=0 ;
    int right=n-1 ;
    int count=0 ;
    while(left<right){
      while(left<n && arr[left]){
        left++;
      }
      while(right>=0 && ! arr[right]){
        right--;
      }
      if(left<right){
        count++;
        left++;
        right--;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arr : Sequence(boolean) ; arr := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < m do ( (     arr[sc.getCurrent()->toInteger() - 1+1] := true )  ;     i := i + 1 ) ; 
    var left : int ; left := 0 ;
    var right : int ; right := n - 1 ;
    var count : int ; count := 0 ;
    while (left < right) do (     while (left < n & arr[left+1]) do (     left := left + 1 ) ; 
     while (right >= 0 & not(arr[right+1])) do (     right := right - 1 ) ; 
     if (left < right) then (     count := count + 1 ; 
     left := left + 1 ; 
     right := right - 1 ) else skip ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countMultiples(int n){
    return n/3+n/7-n/21 ;
  }
  public static void main(String args[]){
    System.out.println("Count="+countMultiples(25));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countMultiples( n : int) : int
  pre: true
  post: true
  activity: (     return n / 3 + n / 7 - n / 21 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Count=" + countMultiples(25)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    int n=Integer.parseInt(sa[0]);
    sa=br.readLine().split(" ");
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[Integer.parseInt(sa[i])-1]=i ;
    }
    br.close();
    TreeSet<Integer>set=new TreeSet<Integer>();
    set.add(-1);
    set.add(n);
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      long x=a[i]-set.lower(a[i]);
      long y=set.higher(a[i])-a[i];
      ans+=x*y*(i+1);
      set.add(a[i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var n : int ; n := (sa[0+1])->toInteger() ;
    sa := br.readLine()->split(" ") ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[(sa[i+1])->toInteger() - 1+1] := i )  ;     i := i + 1 ) ; 
    skip ; 
    var set : Set(int) ; set := Set{} ;
    set := set->including(-1) ; 
    set := set->including(n) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : long ; x := a[i+1] - set.lower(a[i+1]) ;
     var y : long ; y := set.higher(a[i+1]) - a[i+1] ;
     ans := ans+(x * y * (i + 1)) ; 
     set := set->including(a[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class ConvertNum {
  static int convert(int m,int n){
    if(m==n)return 0 ;
    if(m>n)return m-n ;
    if(m<=0 && n>0)return-1 ;
    if(n % 2==1)return 1+convert(m,n+1);
    else return 1+convert(m,n/2);
  }
  public static void main(String[] args){
    int m=3,n=11 ;
    System.out.println("Minimum number of "+"operations : "+convert(m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class ConvertNum {
  static   operation convert( m : int, n : int) : int
  pre: true
  post: true
  activity: (     if (m = n) then     return 0 else skip ; 
     if (m > n) then     return m - n else skip ; 
     if (m <= 0 & n > 0) then     return -1 else skip ; 
     if (n mod 2 = 1) then     return 1 + convert(m, n + 1) else     return 1 + convert(m, n / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 3 ;
    var n : int ; n := 11 ;
     OclFile["System.out"].println("Minimum number of " + "operations : " + convert(m, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getMax(int inputArray[]){
    int maxValue=inputArray[0];
    for(int i=1 ; i<inputArray.length ; i++){
      if(inputArray[i]>maxValue){
        maxValue=inputArray[i];
      }
    }
    return maxValue ;
  }
  static int minSteps(int arr[],int n){
    int maxVal=getMax(arr);
    return maxVal ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,4 };
      int n=arr.length ;
      System.out.println(minSteps(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getMax( inputArray : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var maxValue : int ; maxValue := inputArray[0+1] ;
         var i : int ; i := 1 ; while i < inputArray->size() do ( (     if (inputArray[i+1] > maxValue) then (     maxValue := inputArray[i+1] ) else skip )  ;     i := i + 1 ) ; 
     return maxValue );
  static   operation minSteps( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var maxVal : int ; maxVal := getMax(arr) ;
     return maxVal );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minSteps(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  Scanner sc=new Scanner(in);
  void run(){
    char[][] c={
      {
        '\'',',','.','!','?' },{
          'a','b','c','A','B','C' },{
            'd','e','f','D','E','F' },{
              'g','h','i','G','H','I' },{
                'j','k','l','J','K','L' },{
                  'm','n','o','M','N','O' },{
                    'p','q','r','s','P','Q','R','S' },{
                      't','u','v','T','U','V' },{
                        'w','x','y','z','W','X','Y','Z' }
                      };
                      while(sc.hasNext()){
                        String s=sc.next();
                        int len=s.length();
                        int i=0 ;
                        StringBuilder sb=new StringBuilder();
                        while(i<len){
                          int count=0 ;
                          while(i+count<len && s.charAt(i)==s.charAt(i+count))count++;
                          if(s.charAt(i)=='0'){
                            for(int j=0 ; j<count-1 ; j++)sb.append(' ');
                          }
                          else {
                            int k=Integer.parseInt(""+s.charAt(i))-1 ;
                            sb.append(c[k][(count-1)% c[k] .length]);
                          }
                          i+=count ;
                        }
                        out.println(sb);
                      }
                    }
                    public static void main(String[] args){
                      new Main().run();
                    }
                  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   operation run() : void
  pre: true
  post: true
  activity: (     var c : Sequence(Sequence(String)) ; c := Sequence{Sequence{'\'',',','.','!','?'},Sequence{'a','b','c','A','B','C'},Sequence{'d','e','f','D','E','F'},Sequence{'g','h','i','G','H','I'},Sequence{'j','k','l','J','K','L'},Sequence{'m','n','o','M','N','O'},Sequence{'p','q','r','s','P','Q','R','S'},Sequence{'t','u','v','T','U','V'},Sequence{'w','x','y','z','W','X','Y','Z'}} ;
     while (sc.hasNext()) do (     var s : String ; s := sc.getCurrent() ;
     var len : int ; len := s->size() ;
    var i : int ; i := 0 ;
    var sb : String ; sb := StringLib.newString() ;
    while (i < len) do (     var count : int ; count := 0 ;
     while (i + count < len & s->at(i+1) = s->at(i + count+1)) do     count := count + 1 ; ; 
     if (s->at(i+1) = '0') then (         var j : int ; j := 0 ; while j < (count)->char2byte() - 1 do (     sb := sb + StringLib.newString(' ') ;  ;     j := j + 1 ) ) else (     var k : int ; k := ("" + s->at(i+1))->toInteger() - 1 ;
     sb := sb + StringLib.newString(c[k+1][((count)->char2byte() - 1) mod c[k+1]->size()+1]) ) ;  
     i := i+(count) ) ; 
    out.println(sb) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static char[][] key={
    {
      ' ' },{
        '\'',',','.','!','?' },{
          'a','b','c','A','B','C' },{
            'd','e','f','D','E','F' },{
              'g','h','i','G','H','I' },{
                'j','k','l','J','K','L' },{
                  'm','n','o','M','N','O' },{
                    'p','q','r','s','P','Q','R','S' },{
                      't','u','v','T','U','V' },{
                        'w','x','y','z','W','X','Y','Z' }
                      };
                      public static void main(String[] args){
                        Scanner sc=new Scanner(System.in);
                        while(sc.hasNext()){
                          char[] s=(sc.next()+"0").toCharArray();
                          StringBuilder sb=new StringBuilder();
                          int i=0 ;
                          while(i<s.length){
                            char p=s[i];
                            int k=(int)(s[i]-'0');
                            int c=0 ;
                            i++;
                            if(k==0){
                              sb.append(' ');
                              continue ;
                            }
                            while(i<s.length && p==s[i]){
                              i++;
                              c++;
                            }
                            sb.append(key[k][c % key[k] .length]);
                            if(s[i]=='0')i++;
                          }
                          System.out.println(sb);
                        }
                      }
                    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute key : Sequence(Sequence(String)) := Sequence{Sequence{' '},Sequence{'\'',',','.','!','?'},Sequence{'a','b','c','A','B','C'},Sequence{'d','e','f','D','E','F'},Sequence{'g','h','i','G','H','I'},Sequence{'j','k','l','J','K','L'},Sequence{'m','n','o','M','N','O'},Sequence{'p','q','r','s','P','Q','R','S'},Sequence{'t','u','v','T','U','V'},Sequence{'w','x','y','z','W','X','Y','Z'}};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var s : Sequence(String) ; s := (sc.getCurrent() + "0")->characters() ;
     var sb : String ; sb := StringLib.newString() ;
    var i : int ; i := 0 ;
    while (i < s->size()) do (     var p : String ; p := s[i+1] ;
     var k : int ; k := (s[i+1] - ('0')->char2byte())->oclAsType(int) ;
    var c : int ; c := 0 ;
    i := i + 1 ; 
    if (k = 0) then (     sb := sb + StringLib.newString(' ') ; 
     continue ) else skip ; 
    while (i < s->size() & p = s[i+1]) do (     i := i + 1 ; 
     c := c + 1 ) ; 
    sb := sb + StringLib.newString(key[k+1][c mod key[k+1]->size()+1]) ; 
    if (s[i+1] = '0') then     i := i + 1 ; else skip ; 
 ) ; 
    OclFile["System.out"].println(sb) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
import java.awt.geom.*;
import java.io.*;
public class Main {
  static char[][] key=new char[][] {
    {
    },{
    '\'',',','.','!','?' },{
      'a','b','c','A','B','C' },{
        'd','e','f','D','E','F' },{
          'g','h','i','G','H','I' },{
            'j','k','l','J','K','L' },{
              'm','n','o','M','N','O' },{
                'p','q','r','s','P','Q','R','S' },{
                  't','u','v','T','U','V' },{
                    'w','x','y','z','W','X','Y','Z' }
                  };
                  public static void main(String[] args){
                    Scanner sc=new Scanner(System.in);
                    while(sc.hasNext()){
                      String in=sc.next();
                      int id=-1 ;
                      int count=0 ;
                      for(int i=0 ; i<in.length(); i++){
                        int a=in.charAt(i)-'0' ;
                        if(a!=id){
                          if(id!=-1 && id!=0){
                            System.out.print(key[id][count]);
                          }
                          id=a ;
                          count=0 ;
                        }
                        else if(a==id){
                          if(a==0)System.out.print(' ');
                          count++;
                        }
                      }
                      if(id!=-1 && id!=0){
                        System.out.print(key[id][count]);
                      }
                      System.out.println();
                    }
                  }
                }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute key : Sequence(Sequence(String)) := Sequence{Sequence{},Sequence{'\'',',','.','!','?'},Sequence{'a','b','c','A','B','C'},Sequence{'d','e','f','D','E','F'},Sequence{'g','h','i','G','H','I'},Sequence{'j','k','l','J','K','L'},Sequence{'m','n','o','M','N','O'},Sequence{'p','q','r','s','P','Q','R','S'},Sequence{'t','u','v','T','U','V'},Sequence{'w','x','y','z','W','X','Y','Z'}};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var in : String ; in := sc.getCurrent() ;
     var id : int ; id := -1 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < in->size() do ( (     var a : int ; a := in->at(i+1) - ('0')->char2byte() ;
     if (a /= id) then (     if (id /= -1 & id /= 0) then (     OclFile["System.out"].print(key[id+1][count+1]) ) else skip ; 
     id := a ; 
     count := 0 ) else     if (a = id) then (     if (a = 0) then     OclFile["System.out"].print(' ') ; else skip ; 
     count := count + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    if (id /= -1 & id /= 0) then (     OclFile["System.out"].print(key[id+1][count+1]) ) else skip ; 
    OclFile["System.out"].println() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String a ;
    while((a=in.readLine())!=null){
      int x=0 ;
      char b=a.charAt(0);
      int c=0 ;
      while(x<a.length()){
        if(a.charAt(x)==b){
++c ;
        }
        else {
          gfk(Integer.parseInt((new Character(b)).toString()),c);
          c=1 ;
          b=a.charAt(x);
        }
++x ;
      }
      gfk(Integer.parseInt(new Character(b).toString()),c);
      System.out.println("");
    }
  }
  static void gfk(int a,int b){
    if(a==0){
      for(int i=1 ; i<b ; ++i){
        System.out.print(" ");
      }
    }
    else {
--b ;
--a ;
      System.out.print(key[a][b % key[a] .length]);
    }
  }
  static char key[][]={
    {
      '\'',',','.','!','?' },{
        'a','b','c','A','B','C' },{
          'd','e','f','D','E','F' },{
            'g','h','i','G','H','I' },{
              'j','k','l','J','K','L' },{
                'm','n','o','M','N','O' },{
                  'p','q','r','s','P','Q','R','S' },{
                    't','u','v','T','U','V' },{
                      'w','x','y','z','W','Z','Y','Z' }
                    };
                  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var a : String ;
         a := in.readLine() ;
    while ((a) /= null) do (    skip ; (     var x : int ; x := 0 ;
     var b : String ; b := a->at(0+1) ;
    var c : int ; c := 0 ;
    while (x < a->size()) do (     if (a->at(x+1) = b) then (     c := c + 1 ) else (     execute gfk(((String(b))+"")->toInteger(), c) ; 
     c := 1 ; 
     b := a->at(x+1) ) ;  
     x := x + 1 ) ; 
    execute gfk((String(b)+"")->toInteger(), c) ; 
    OclFile["System.out"].println("") ; 
 ) ;     a := in.readLine() ;
 ) );
  static   operation gfk( a : int, b : int) : void
  pre: true
  post: true
  activity: (     if (a = 0) then (         var i : int ; i := 1 ; while i < b do ( (     OclFile["System.out"].print(" ") )  ;     i := i + 1 ) ) else (     b := b - 1 ; 
     a := a - 1 ; 
     OclFile["System.out"].print(key[a+1][b mod key[a+1]->size()+1]) ) );
  static   attribute key : String := Sequence{Sequence{'\'',',','.','!','?'},Sequence{'a','b','c','A','B','C'},Sequence{'d','e','f','D','E','F'},Sequence{'g','h','i','G','H','I'},Sequence{'j','k','l','J','K','L'},Sequence{'m','n','o','M','N','O'},Sequence{'p','q','r','s','P','Q','R','S'},Sequence{'t','u','v','T','U','V'},Sequence{'w','x','y','z','W','Z','Y','Z'}};
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int CountCharacters(String str,int k){
    int cnt=0 ;
    int len=str.length();
    for(int i=0 ; i<len ; i++){
      if(((int)str.charAt(i))<k)cnt++;
    }
    return cnt ;
  }
  public static void main(String args[]){
    String str="GeeksForGeeks" ;
    int k=90 ;
    int count=CountCharacters(str,k);
    System.out.println("Characters with ASCII values less than K are "+count);
    System.out.println("Characters with ASCII values greater than or equal to K are "+(str.length()-count));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation CountCharacters( str : String, k : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var len : int ; len := str->size() ;
         var i : int ; i := 0 ; while i < len do ( (     if ((str->at(i+1)->oclAsType(int)) < k) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "GeeksForGeeks" ;
     var k : int ; k := 90 ;
    var count : int ; count := CountCharacters(str, k) ;
    OclFile["System.out"].println("Characters with ASCII values less than K are " + count) ; 
    OclFile["System.out"].println("Characters with ASCII values greater than or equal to K are " + (str->size() - count)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] a=new long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
    }
    Arrays.sort(a);
    boolean first=false ;
    boolean second=false ;
    long firstNum=0 ;
    long secondNum=0 ;
    long tmp=a[0];
    int count=1 ;
    for(int i=1 ; i<n ; i++){
      if(tmp==a[i]){
        count++;
        if(count % 2==1)continue ;
        if(! first && ! second){
          firstNum=tmp ;
          first=true ;
        }
        else if(first && ! second){
          secondNum=tmp ;
          second=true ;
        }
        else if(first && second){
          long x=secondNum ;
          secondNum=a[i];
          firstNum=x ;
        }
      }
      else {
        tmp=a[i];
        count=1 ;
      }
    }
    long ans=firstNum*secondNum ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var first : boolean ; first := false ;
    var second : boolean ; second := false ;
    var firstNum : long ; firstNum := 0 ;
    var secondNum : long ; secondNum := 0 ;
    var tmp : long ; tmp := a[0+1] ;
    var count : int ; count := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     if (tmp = a[i+1]) then (     count := count + 1 ; 
     if (count mod 2 = 1) then     continue else skip ; 
     if (not(first) & not(second)) then (     firstNum := tmp ; 
     first := true ) else     if (first & not(second)) then (     secondNum := tmp ; 
     second := true ) else     if (first & second) then (     var x : long ; x := secondNum ;
     secondNum := a[i+1] ; 
     firstNum := x ) else skip ; ;  ) else (     tmp := a[i+1] ; 
     count := 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := firstNum * secondNum ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static void getPermutation(boolean[] D,int level,int curr,List<Integer>permutation){
    if(level==6){
      return ;
    }
    permutation.add(curr);
    for(int i=0 ; i<10 ; i++){
      if(D[i]){
        continue ;
      }
      getPermutation(D,level+1,curr*10+i,permutation);
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    boolean[] D=new boolean[10];
    for(int i=0 ; i<K ; i++){
      int d=sc.nextInt();
      D[d]=true ;
    }
    int ans=Integer.MAX_VALUE ;
    List<Integer>permutation=new ArrayList<>();
    getPermutation(D,0,0,permutation);
    for(int v : permutation){
      if(v>=N){
        ans=Math.min(ans,v);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation getPermutation( D : Sequence(boolean), level : int, curr : int, permutation : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (level = 6) then (     return ) else skip ; 
     permutation->excludes(curr) ; 
         var i : int ; i := 0 ; while i < 10 do ( (     if (D[i+1]) then (     continue ) else skip ; 
     execute getPermutation(D, level + 1, curr * 10 + i, permutation) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var D : Sequence(boolean) ; D := Integer.subrange(1,10)->collect(false) ;
        var i : int ; i := 0 ; while i < K do ( (     var d : int ; d := sc.getCurrent()->toInteger() ;
     D[d+1] := true )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 2147483647 ;
    var permutation : Sequence(int) ; permutation := Sequence{} ;
    execute getPermutation(D, 0, 0, permutation) ; 
    for (v : permutation) do ( (     if (v >= N) then (     ans := Set{ans, v}->min() ) else skip )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    int maxa=-1 ;
    int mina=2001 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      if(maxa<a[i]){
        maxa=a[i];
      }
      if(mina>a[i]){
        mina=a[i];
      }
    }
    int min=2001 ;
    for(int i=mina ; i<=maxa ; i++){
      int max=-1 ;
      for(int j=0 ; j<n ; j++){
        if(max<Math.abs(i-a[j])){
          max=Math.abs(i-a[j]);
        }
      }
      if(min>max){
        min=max ;
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var maxa : int ; maxa := -1 ;
    var mina : int ; mina := 2001 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     if (maxa < a[i+1]) then (     maxa := a[i+1] ) else skip ; 
     if (mina > a[i+1]) then (     mina := a[i+1] ) else skip )  ;     i := i + 1 ) ; 
    var min : int ; min := 2001 ;
        var i : int ; i := mina ; while i <= maxa do ( (     var max : int ; max := -1 ;
         var j : int ; j := 0 ; while j < n do ( (     if (max < if i - a[j+1] < 0 then -(i - a[j+1]) else i - a[j+1] endif) then (     max := if i - a[j+1] < 0 then -(i - a[j+1]) else i - a[j+1] endif ) else skip )  ;     j := j + 1 ) ; 
     if (min > max) then (     min := max ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=scan.nextInt();
    List<Bar>barlist=new ArrayList<>();
    HashMap<Long,Bar>bars=new HashMap<>();
    for(int i=0 ; i<N ; i++){
      long a=scan.nextLong();
      if(! bars.containsKey(a)){
        Bar b=new Bar();
        b.x=a ;
        b.count=1 ;
        barlist.add(b);
        bars.put(a,b);
      }
      else {
        Bar b=bars.get(a);
        b.count+=1 ;
      }
    }
    barlist.sort(new BarComparetor());
    long first=0 ;
    long second=0 ;
    for(int i=0 ; i<N &&(first==0 || second==0); i++){
      Bar b=barlist.get(i);
      if(b.count==1){
        continue ;
      }
      if(first==0){
        if(4<=b.count){
          first=b.x ;
          second=b.x ;
        }
        else {
          first=b.x ;
        }
        continue ;
      }
      if(second==0){
        second=b.x ;
      }
    }
    System.out.println(first*second);
  }
  class Bar {
    long x ;
    int count ;
  }
  class BarComparetor implements Comparator<Bar>{
    @ Override public int compare(Bar o1,Bar o2){
      if(o1.x==o2.x){
        return-Integer.compare(o1.count,o2.count);
      }
      return-Long.compare(o1.x,o2.x);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var barlist : Sequence(Bar) ; barlist := Sequence{} ;
    var bars : Map(long,Bar) ; bars := Map{} ;
        var i : int ; i := 0 ; while i < N do ( (     var a : long ; a := scan.getCurrent()->toLong() ;
     if (not(bars->keys()->includes(a))) then (     var b : Bar ; b := Bar.newBar() ;
     b.x := a ; 
    b.count := 1 ; 
    barlist := barlist->including(b) ; 
    bars := bars->union(Map{a |-> b}) ; 
 ) else (     var b : Bar ; b := bars->at(a) ;
     b.count := b.count+(1) ) )  ;     i := i + 1 ) ; 
    barlist := barlist.sort(BarComparetor.newBarComparetor()) ; 
    var first : long ; first := 0 ;
    var second : long ; second := 0 ;
        var i : int ; i := 0 ; while i < N & (first = 0 or second = 0) do ( (     var b : Bar ; b := barlist->at(i+1) ;
     if (b.count = 1) then (     continue ) else skip ; 
     if (first = 0) then (     if (4 <= b.count) then (     first := b.x ; 
     second := b.x ) else (     first := b.x ) ;  
     continue ) else skip ; 
     if (second = 0) then (     second := b.x ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(first * second) ; 
 );
 class Bar {
   attribute x : long;
   attribute count : int;
}
 class BarComparetor implements Function(<Bar>,(<Bar>,boolean)) {
      operation compare( o1 : Bar, o2 : Bar) : int
  pre: true
  post: true
  activity: (     if (o1.x = o2.x) then (     return -compare(o1.count, o2.count) ) else skip ; 
     return -compare(o1.x, o2.x) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    new Main().compute();
  }
  void compute(){
    int N=scanner.nextInt();
    List<Integer>A=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      A.add(scanner.nextInt());
    }
    A.sort((o1,o2)->o2-o1);
    int[] max=new int[2];
    max[0]=0 ;
    max[1]=0 ;
    int twin=0,prev=-1 ;
    for(int Ai : A){
      if(Ai==prev){
        max[twin]=Ai ;
        twin++;
        prev=-1 ;
        if(twin==2){
          break ;
        }
      }
      else {
        prev=Ai ;
      }
    }
    System.out.println((long)max[0]*max[1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().compute() );
   operation compute() : void
  pre: true
  post: true
  activity: (     var N : int ; N := scanner.getCurrent()->toInteger() ;
     var A : Sequence(int) ; A := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     A := A->including(scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    A := A.sort(lambda (o1 , o2) : OclAny in o2 - o1) ; 
    var max : Sequence(int) ; max := Integer.subrange(1,2)->collect(0) ;
    max[0+1] := 0 ; 
    max[1+1] := 0 ; 
    var twin : int ; twin := 0 ;
    var prev : int ; prev := -1 ;
    for (Ai : A) do ( (     if (Ai = prev) then (     max[twin+1] := Ai ; 
     twin := twin + 1 ; 
     prev := -1 ; 
     if (twin = 2) then (     break ) else skip ) else (     prev := Ai ) )  ) ; 
    OclFile["System.out"].println(max[0+1]->oclAsType(long) * max[1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Map.Entry ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    Map<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(map.containsKey(a[i])){
        map.put(a[i],map.get(a[i])+1);
      }
      else {
        map.put(a[i],1);
      }
    }
    List<Entry<Integer,Integer>>entry=new ArrayList<>(map.entrySet());
    Collections.sort(entry,new Comparator<Entry<Integer,Integer>>(){
      public int compare(Entry<Integer,Integer>obj1,Entry<Integer,Integer>obj2){
        if(obj1.getValue()>=2 && obj2.getValue()>=2)return obj2.getKey()-obj1.getKey();
        else return obj2.getValue()-obj1.getValue();
      }
    }
);
    if(entry.get(0).getValue()>=4){
      System.out.println(1L*entry.get(0).getKey()*entry.get(0).getKey());
    }
    else if(entry.get(0).getValue()>=2 && entry.get(1).getValue()>=2){
      System.out.println(1L*entry.get(0).getKey()*entry.get(1).getKey());
    }
    else {
      System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (map->keys()->includes(a[i+1])) then (     map := map->union(Map{a[i+1] |-> map->at(a[i+1]) + 1}) ) else (     map := map->union(Map{a[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var entry : Sequence(Entry<int,int>) ; entry := Sequence{}->union(map->asSet()) ;
    entry, OclComparator<Entry<int,int>>.newOclComparator() := entry, OclComparator<Entry<int,int>>.newOclComparator()->sort() ; 
    if (entry->at(0+1).getValue() >= 4) then (     OclFile["System.out"].println(1L * entry->at(0+1).getKey() * entry->at(0+1).getKey()) ) else     if (entry->at(0+1).getValue() >= 2 & entry->at(1+1).getValue() >= 2) then (     OclFile["System.out"].println(1L * entry->at(0+1).getKey() * entry->at(1+1).getKey()) ) else (     OclFile["System.out"].println(0) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    PriorityQueue<Long>queue=new PriorityQueue<Long>(Collections.reverseOrder());
    HashSet<Long>has=new HashSet<Long>();
    queue.add((long)0);
    queue.add((long)0);
    for(int i=1 ; i<=N ; i++){
      long n=sc.nextInt();
      if(has.contains(n)){
        queue.add((n));
        has.remove(n);
      }
      else {
        has.add(n);
      }
    }
    System.out.println(queue.poll()*queue.poll());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var queue : Sequence(long) ; queue := Sequence{}->union(reverseOrder()) ;
    var has : Set(long) ; has := Set{} ;
    queue := queue->including(0->oclAsType(long)) ; 
    queue := queue->including(0->oclAsType(long)) ; 
        var i : int ; i := 1 ; while i <= N do ( (     var n : long ; n := sc.getCurrent()->toInteger() ;
     if (has->includes(n)) then (     queue := queue->including((n)) ; 
     has := has->excludingAt(n+1) ) else (     has := has->including(n) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(queue->min() * queue->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int countSteps(int x,int y){
    if(x<y){
      return x+y+2*((y-x)/2);
    }
    else {
      return x+y+2*(((x-y)+1)/2);
    }
  }
  public static void main(String[] args){
    int x=4,y=3 ;
    System.out.println(countSteps(x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation countSteps( x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (x < y) then (     return x + y + 2 * ((y - x) / 2) ) else (     return x + y + 2 * (((x - y) + 1) / 2) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 4 ;
    var y : int ; y := 3 ;
     OclFile["System.out"].println(countSteps(x, y)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countSolutions(int n){
    int x=0,yCount,res=0 ;
    for(yCount=0 ; yCount*yCount<n ; yCount++);
    while(yCount!=0){
      res+=yCount ;
      x++;
      while(yCount!=0 &&(x*x+(yCount-1)*(yCount-1)>=n))yCount--;
    }
    return res ;
  }
  public static void main(String args[]){
    System.out.println("Total Number of distinct Non-Negative pairs is "+countSolutions(6));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countSolutions( n : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := 0 ;
    var yCount : int ;
    var res : int ; res := 0 ;
         yCount := 0 ; while yCount * yCount < n do (   ;     yCount := yCount + 1 ) ; 
     while (yCount /= 0) do (     res := res+(yCount) ; 
     x := x + 1 ; 
     while (yCount /= 0 & (x * x + (yCount - 1) * (yCount - 1) >= n)) do     yCount := yCount - 1 ; ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Total Number of distinct Non-Negative pairs is " + countSolutions(6)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int rotateRec(int n,int L[],int B[]){
    int m=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(Math.max(L[i],B[i])<=m)m=Math.max(L[i],B[i]);
      else if(Math.min(L[i],B[i])<=m)m=Math.min(L[i],B[i]);
      else {
        return 0 ;
      }
    }
    return 1 ;
  }
  public static void main(String[] args){
    int n=3 ;
    int L[]={
      5,5,6 };
      int B[]={
        6,7,8 };
        if(rotateRec(n,L,B)==1)System.out.println("YES");
        else System.out.println("NO");
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation rotateRec( n : int, L : Sequence(int), B : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var m : int ; m := 2147483647 ;
         var i : int ; i := 0 ; while i < n do ( (     if (Set{L[i+1], B[i+1]}->max() <= m) then     m := Set{L[i+1], B[i+1]}->max() ; else     if (Set{L[i+1], B[i+1]}->min() <= m) then     m := Set{L[i+1], B[i+1]}->min() else (     return 0 ) ;  )  ;     i := i + 1 ) ; 
     return 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var L : Sequence(int) ; L := Sequence{5,5,6} ;
     var B : Sequence(int) ; B := Sequence{6,7,8} ;
     if (rotateRec(n, L, B) = 1) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int input1=scan.nextInt();
    Tree main=new Tree(-2147483648);
    for(int loopCount=0 ; loopCount<input1 ; loopCount++){
      char[] s=scan.next().toCharArray();
      if(s[0]=='i')main.insert(scan.nextInt());
      else if(s[0]=='f')System.out.println(main.find(scan.nextInt()));
      else if(s[0]=='p'){
        if(main.right!=null){
          main.right.printMiddle();
          System.out.println();
          main.right.printFirst();
          System.out.println();
        }
      }
    }
  }
}
class Tree {
  int key ;
  Tree left,right ;
  Tree(int _key){
    this.key=_key ;
  }
  void insert(int _num){
    if(key<_num){
      if(right==null){
        right=new Tree(_num);
      }
      else {
        right.insert(_num);
      }
    }
    else if(key>_num){
      if(left==null){
        left=new Tree(_num);
      }
      else {
        left.insert(_num);
      }
    }
  }
  String find(int _num){
    if(key==_num)return "yes" ;
    else {
      if(key>_num && left!=null)return left.find(_num);
      if(key<_num && right!=null)return right.find(_num);
      return "no" ;
    }
  }
  void printFirst(){
    System.out.print(" "+key);
    if(left!=null)left.printFirst();
    if(right!=null)right.printFirst();
  }
  void printMiddle(){
    if(left!=null)left.printMiddle();
    System.out.print(" "+key);
    if(right!=null)right.printMiddle();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input1 : int ; input1 := scan.getCurrent()->toInteger() ;
     var main : Tree ; main := Tree.newTree(-2147483648) ;
         var loopCount : int ; loopCount := 0 ; while loopCount < input1 do ( (     var s : Sequence(String) ; s := scan.getCurrent()->characters() ;
     if (s[0+1] = 'i') then     main := main.insertAt(scan.getCurrent()->toInteger()+1, StringLib.newString()) ; else     if (s[0+1] = 'f') then     OclFile["System.out"].println(main.find(scan.getCurrent()->toInteger())) else     if (s[0+1] = 'p') then (     if (main.right /= null) then (     main.right.printMiddle() ; 
     OclFile["System.out"].println() ; 
     main.right.printFirst() ; 
     OclFile["System.out"].println() ) else skip ) else skip ; ;  )  ;     loopCount := loopCount + 1 ) );
}
class Tree {
   attribute key : int;
   attribute left : Tree;
   static operation newTree( _key : int) : Tree
  pre: true
  post: true
  activity:
  ( var self : Tree ;
    self := createTree();
    self.initialise(_key);
    return self );
  operation initialise( _key : int) : void
  pre: true  post: true
  activity: (     self.key := _key );
   operation insert( _num : int) : void
  pre: true
  post: true
  activity: (     if (key < _num) then (     if (right = null) then (     right := Tree.newTree(_num) ) else (     right := right.insertAt(_num+1, StringLib.newString()) ) ) else     if (key > _num) then (     if (left = null) then (     left := Tree.newTree(_num) ) else (     left := left.insertAt(_num+1, StringLib.newString()) ) ) else skip ; );
   operation find( _num : int) : String
  pre: true
  post: true
  activity: (     if (key = _num) then     return "yes" else (     if (key > _num & left /= null) then     return left.find(_num) else skip ; 
     if (key < _num & right /= null) then     return right.find(_num) else skip ; 
     return "no" ) );
   operation printFirst() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(" " + key) ; 
     if (left /= null) then     left.printFirst() ; else skip ; 
     if (right /= null) then     right.printFirst() ; else skip );
   operation printMiddle() : void
  pre: true
  post: true
  activity: (     if (left /= null) then     left.printMiddle() ; else skip ; 
     OclFile["System.out"].print(" " + key) ; 
     if (right /= null) then     right.printMiddle() ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.HashSet ;
class GFG {
  static int countPiles(int n,int[] a){
    HashMap<Integer,Integer>occ=new HashMap<>();
    for(int i=0 ; i<n ; i++)occ.put(a[i],occ.get(a[i])==null ? 1 : occ.get(a[i])+1);
    int pile=0 ;
    while(! occ.isEmpty()){
      pile++;
      int size=0 ;
      HashSet<Integer>toRemove=new HashSet<>();
      for(HashMap.Entry<Integer,Integer>tm : occ.entrySet()){
        int mx=tm.getKey();
        int ct=tm.getValue();
        int use=Math.min(ct,mx-size+1);
        occ.put(mx,occ.get(mx)-use);
        size+=use ;
        if(occ.get(mx)==0)toRemove.add(mx);
      }
      for(int tm : toRemove)occ.remove(tm);
    }
    return pile ;
  }
  public static void main(String[] args){
    int[] a={
      0,0,1,1,2 };
      int n=a.length ;
      System.out.println(countPiles(n,a));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPiles( n : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var occ : Map(int,int) ; occ := Map{} ;
         var i : int ; i := 0 ; while i < n do (     occ := occ->union(Map{a[i+1] |-> if occ->at(a[i+1]) = null then 1 else occ->at(a[i+1]) + 1 endif}) ;  ;     i := i + 1 ) ; 
    var pile : int ; pile := 0 ;
    while (not(occ->isEmpty())) do (     pile := pile + 1 ; 
     var size : int ; size := 0 ;
    var toRemove : Set(int) ; toRemove := Set{} ;
    for (tm : occ->asSet()) do ( (     var mx : int ; mx := tm.getKey() ;
     var ct : int ; ct := tm.getValue() ;
    var use : int ; use := Set{ct, mx - size + 1}->min() ;
    occ := occ->union(Map{mx |-> occ->at(mx) - use}) ; 
    size := size+(use) ; 
    if (occ->at(mx) = 0) then     toRemove := toRemove->including(mx) ; else skip ; 
 )  ) ; 
    for (tm : toRemove) do (     occ := occ->antirestrict(Set{tm}) ;  ) ; 
 ) ; 
    return pile 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{0,0,1,1,2} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(countPiles(n, a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printMaxValPair(Vector<Long>v,int n){
    Collections.sort(v);
    long N=v.get((int)n-1);
    if(N % 2==1){
      long first_maxima=N/2 ;
      long second_maxima=first_maxima+1 ;
      long ans1=(long)3e18,ans2=(long)3e18 ;
      long from_left=-1,from_right=-1 ;
      long from=-1 ;
      for(long i=0 ; i<n ; ++i){
        if(v.get((int)i)>first_maxima){
          from=i ;
          break ;
        }
        else {
          long diff=first_maxima-v.get((int)i);
          if(diff<ans1){
            ans1=diff ;
            from_left=v.get((int)i);
          }
        }
      }
      from_right=v.get((int)from);
      long diff1=first_maxima-from_left ;
      long diff2=from_right-second_maxima ;
      if(diff1<diff2)System.out.println(N+" "+from_left);
      else System.out.println(N+" "+from_right);
    }
    else {
      long maxima=N/2 ;
      long ans1=(int)3e18 ;
      long R=-1 ;
      for(long i=0 ; i<n-1 ; ++i){
        long diff=Math.abs(v.get((int)i)-maxima);
        if(diff<ans1){
          ans1=diff ;
          R=v.get((int)i);
        }
      }
      System.out.println(N+" "+R);
    }
  }
  public static void main(String args[]){
    long arr[]={
      1,1,2,3,6,1 };
      Vector<Long>v=new Vector<Long>();
      for(int i=0 ; i<arr.length ; i++)v.add(arr[i]);
      int n=v.size();
      printMaxValPair(v,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printMaxValPair( v : Sequence(long), n : int) : void
  pre: true
  post: true
  activity: (     v := v->sort() ; 
     var N : long ; N := v->at(n->oclAsType(int) - 1+1) ;
     if (N mod 2 = 1) then (     var first_maxima : long ; first_maxima := N / 2 ;
     var second_maxima : long ; second_maxima := first_maxima + 1 ;
    var ans1 : long ; ans1 := 3e18->oclAsType(long) ;
    var ans2 : long ; ans2 := 3e18->oclAsType(long) ;
    var from_left : long ; from_left := -1 ;
    var from_right : long ; from_right := -1 ;
    var from : long ; from := -1 ;
        var i : long ; i := 0 ; while i < n do ( (     if (v->at(i->oclAsType(int)+1) > first_maxima) then (     from := i ; 
     break ) else (     var diff : long ; diff := first_maxima - v->at(i->oclAsType(int)+1) ;
     if (diff < ans1) then (     ans1 := diff ; 
     from_left := v->at(i->oclAsType(int)+1) ) else skip ) )  ;     i := i + 1 ) ; 
    from_right := v->at(from->oclAsType(int)+1) ; 
    var diff1 : long ; diff1 := first_maxima - from_left ;
    var diff2 : long ; diff2 := from_right - second_maxima ;
    if (diff1 < diff2) then     OclFile["System.out"].println(N + " " + from_left) else     OclFile["System.out"].println(N + " " + from_right) ; ;  
 ) else (     var maxima : long ; maxima := N / 2 ;
     var ans1 : long ; ans1 := 3e18->oclAsType(int) ;
    var R : long ; R := -1 ;
        var i : long ; i := 0 ; while i < n - 1 do ( (     var diff : long ; diff := if v->at(i->oclAsType(int)+1) - maxima < 0 then -(v->at(i->oclAsType(int)+1) - maxima) else v->at(i->oclAsType(int)+1) - maxima endif ;
     if (diff < ans1) then (     ans1 := diff ; 
     R := v->at(i->oclAsType(int)+1) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(N + " " + R) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(long) ; arr := Sequence{1,1,2,3,6,1} ;
     var v : Sequence(long) ; v := Sequence{} ;
        var i : int ; i := 0 ; while i < arr->size() do (     v := v->including(arr[i+1]) ;  ;     i := i + 1 ) ; 
    var n : int ; n := v->size() ;
    execute printMaxValPair(v, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int xmin=2000,xmax=0 ;
    for(int i=0 ; i<n ; ++i){
      int x=sc.nextInt();
      if(x<xmin)xmin=x ;
      if(x>xmax)xmax=x ;
    }
    System.out.println(xmax-(xmin+xmax)/2);
  }
  public static void main(String[] a){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var xmin : int ; xmin := 2000 ;
    var xmax : int ; xmax := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x < xmin) then     xmin := x ; else skip ; 
     if (x > xmax) then     xmax := x ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(xmax - (xmin + xmax) / 2) ; 
 );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static boolean like(int n,List<Integer>d_lst){
    while(n>0){
      int mod=n % 10 ;
      int q=n/10 ;
      if(d_lst.contains(mod)){
        return false ;
      }
      if(q==0){
        break ;
      }
      else {
        n=q ;
      }
    }
    return true ;
  }
  public static void main(String[] args)throws IOException {
    PrintWriter out=new PrintWriter(System.out);
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int k=Integer.parseInt(sc.next());
    List<Integer>d_lst=new ArrayList<>();
    for(int i=0 ; i<k ; i++){
      d_lst.add(Integer.parseInt(sc.next()));
    }
    int cand_n=n ;
    while(true){
      if(like(cand_n,d_lst)){
        out.println(cand_n);
        break ;
      }
      cand_n++;
    }
    out.flush();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation like( n : int, d_lst : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     while (n > 0) do (     var mod : int ; mod := n mod 10 ;
     var q : int ; q := n / 10 ;
     if (d_lst->includes(mod)) then (     return false ) else skip ; 
     if (q = 0) then (     break ) else (     n := q ) ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := (sc.getCurrent())->toInteger() ;
    var k : int ; k := (sc.getCurrent())->toInteger() ;
    var d_lst : Sequence(int) ; d_lst := Sequence{} ;
        var i : int ; i := 0 ; while i < k do ( (     d_lst := d_lst->including((sc.getCurrent())->toInteger()) )  ;     i := i + 1 ) ; 
    var cand_n : int ; cand_n := n ;
    while (true) do (     if (like(cand_n, d_lst)) then (     skip ; 
     break ) else skip ; 
     cand_n := cand_n + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class Main {
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  int INF=1<<28 ;
  double EPS=1e-12 ;
  int n,m ;
  int[] a ;
  void run(){
    try {
      String[] ss=br.readLine().split(" ");
      n=Integer.parseInt(ss[0]);
      m=Integer.parseInt(ss[1]);
      a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=Integer.parseInt(br.readLine());
      }
      solve();
    }
    catch(IOException e){
    }
  }
  void solve(){
    TreeSet<Integer>set=new TreeSet<Integer>();
    int count=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(! set.contains(a[i])){
        println(a[i]+"");
        if(++count==m){
          break ;
        }
      }
      set.add(a[i]);
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-12;
   attribute n : int;
   attribute a : Sequence(int);
   operation run() : void
  pre: true
  post: true
  activity: (     try (     var ss : Sequence(String) ; ss := br.readLine()->split(" ") ;
     n := (ss[0+1])->toInteger() ; 
    m := (ss[1+1])->toInteger() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    execute solve() ; 
 )   catch (e : IOException) do skip
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var set : Set(int) ; set := Set{} ;
     var count : int ; count := 0 ;
         var i : int ; i := n - 1 ; while i >= 0 do ( (     if (not(set->includes(a[i+1]))) then (     execute println(a[i+1] + "") ; 
     if ((count + 1) = m) then (     break ) else skip ) else skip ; 
     set := set->including(a[i+1]) )  ;     i := i - 1 ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
    try {
      String[] st=sc.readLine().split(" ");
      int N=Integer.valueOf(st[0]),M=Integer.valueOf(st[1]);
      int[] pool=new int[N];
      TreeSet<Integer>aa=new TreeSet<Integer>();
      for(int i=0 ; i<N ; i++)pool[i]=Integer.valueOf(sc.readLine());
      int c=0 ;
      for(int i=N-1 ; i>=0 ; i--){
        if(! aa.contains(pool[i])){
          System.out.println(pool[i]);
          aa.add(pool[i]);
          if(++c==M)break ;
        }
      }
    }
    catch(Exception e){
      System.out.println("Error");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var st : Sequence(String) ; st := sc.readLine()->split(" ") ;
     var N : int ; N := (st[0+1])->toInteger() ;
    var M : int ; M := (st[1+1])->toInteger() ;
    var pool : Sequence(int) ; pool := Integer.subrange(1,N)->collect(0) ;
    var aa : Set(int) ; aa := Set{} ;
        var i : int ; i := 0 ; while i < N do (     pool[i+1] := (sc.readLine())->toInteger() ;  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
        var i : int ; i := N - 1 ; while i >= 0 do ( (     if (not(aa->includes(pool[i+1]))) then (     OclFile["System.out"].println(pool[i+1]) ; 
     aa := aa->including(pool[i+1]) ; 
     if ((c + 1) = M) then     break else skip ) else skip )  ;     i := i - 1 ) ; 
 )   catch (e : ProgramException) do (     OclFile["System.out"].println("Error") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long findTriangularNumber(int n){
    return(n*(n+1))/2 ;
  }
  static void printSeries(int n){
    long prev=0 ;
    long curr ;
    for(int i=1 ; i<=n ; i++){
      curr=findTriangularNumber(i);
      curr=curr+prev ;
      System.out.print(curr+" ");
      prev=curr ;
    }
  }
  public static void main(String[] args){
    int n=10 ;
    printSeries(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findTriangularNumber( n : int) : long
  pre: true
  post: true
  activity: (     return (n * (n + 1)) / 2 );
  static   operation printSeries( n : int) : void
  pre: true
  post: true
  activity: (     var prev : long ; prev := 0 ;
     var curr : long ;
         var i : int ; i := 1 ; while i <= n do ( (     curr := findTriangularNumber(i) ; 
     curr := curr + prev ; 
     OclFile["System.out"].print(curr + " ") ; 
     prev := curr )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     execute printSeries(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Set ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] input=br.readLine().split(" ");
    Map<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<input.length ; i++){
      int elem=Integer.parseInt(input[i]);
      if(map.containsKey(elem)){
        map.put(elem,map.get(elem)+1);
      }
      else {
        map.put(elem,1);
      }
    }
    int count=0 ;
    Set<Integer>keys=map.keySet();
    for(int key : keys){
      int value=map.get(key);
      if(value>key){
        count+=(value-key);
      }
      else if(value<key){
        count+=value ;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var input : Sequence(String) ; input := br.readLine()->split(" ") ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < input->size() do ( (     var elem : int ; elem := (input[i+1])->toInteger() ;
     if (map->keys()->includes(elem)) then (     map := map->union(Map{elem |-> map->at(elem) + 1}) ) else (     map := map->union(Map{elem |-> 1}) ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var keys : Set(int) ; keys := map->keys() ;
    for (key : keys) do ( (     var value : int ; value := map->at(key) ;
     if (value > key) then (     count := count+((value - key)) ) else     if (value < key) then (     count := count+(value) ) else skip ; )  ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static void Sequence(int[] a){
    Map<Integer,Integer>sequence=new HashMap<Integer,Integer>();
    for(int i=0 ; i<a.length ; i++){
      if(! sequence.containsKey(a[i])){
        sequence.put(a[i],1);
      }
      else {
        sequence.put(a[i],sequence.get(a[i])+1);
      }
    }
    int remove=0 ;
    for(Integer key : sequence.keySet()){
      if(key>sequence.get(key))remove+=sequence.get(key);
      else if(sequence.get(key)>key)remove+=sequence.get(key)-key ;
    }
    System.out.println(remove);
  }
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int N=input.nextInt();
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++){
      a[i]=input.nextInt();
    }
    input.close();
    Sequence(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation Sequence( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var sequence : Map(int,int) ; sequence := Map{} ;
         var i : int ; i := 0 ; while i < a->size() do ( (     if (not(sequence->keys()->includes(a[i+1]))) then (     sequence := sequence->union(Map{a[i+1] |-> 1}) ) else (     sequence := sequence->union(Map{a[i+1] |-> sequence->at(a[i+1]) + 1}) ) )  ;     i := i + 1 ) ; 
    var remove : int ; remove := 0 ;
    for (key : sequence->keys()) do ( (     if (key > sequence->at(key)) then     remove := remove+(sequence->at(key)) ; else     if (sequence->at(key) > key) then     remove := remove+(sequence->at(key) - key) ; else skip ; )  ) ; 
    OclFile["System.out"].println(remove) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := input.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    execute Sequence(a) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    StringTokenizer s=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(s.nextToken());
    s=new StringTokenizer(br.readLine());
    int a[]=new int[n];
    HashMap<Integer,Integer>hm=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(s.nextToken());
      if(! hm.containsKey(a[i]))hm.put(a[i],1);
      else hm.put(a[i],hm.get(a[i])+1);
    }
    int ans=0 ;
    for(int val : hm.keySet()){
      if(hm.get(val)>val)ans+=hm.get(val)-val ;
      else if(hm.get(val)<val)ans+=hm.get(val);
    }
    pw.println(ans);
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    var s : OclIterator ; s := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (s.next())->toInteger() ;
    s := OclIterator.newOclIterator_String(br.readLine()) ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var hm : Map(int,int) ; hm := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (s.next())->toInteger() ; 
     if (not(hm->keys()->includes(a[i+1]))) then     hm := hm->union(Map{a[i+1] |-> 1}) ; else     hm := hm->union(Map{a[i+1] |-> hm->at(a[i+1]) + 1}) ; )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (val : hm->keys()) do ( (     if (hm->at(val) > val) then     ans := ans+(hm->at(val) - val) ; else     if (hm->at(val) < val) then     ans := ans+(hm->at(val)) ; else skip ; )  ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  int n ;
  int[] as ;
  public static void main(String args[]){
    new Main().run();
  }
  void run(){
    FastReader sc=new FastReader();
    n=sc.nextInt();
    as=new int[n];
    for(int i=0 ; i<n ; i++){
      as[i]=sc.nextInt();
    }
    solve();
  }
  void solve(){
    Arrays.sort(as);
    int ans=0 ;
    int count=0 ;
    for(int i=1 ; i<n ; i++){
      count++;
      if(as[i-1]<as[i]){
        if(count<as[i-1]){
          ans+=count ;
        }
        else {
          ans+=count-as[i-1];
        }
        count=0 ;
      }
    }
    count++;
    if(count<as[as.length-1]){
      ans+=count ;
    }
    else {
      ans+=count-as[as.length-1];
    }
    System.out.println(ans);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute as : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     n := sc.nextInt() ; 
    as := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     as[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    execute solve() ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     as := as->sort() ; 
     var ans : int ; ans := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     count := count + 1 ; 
     if (as[i - 1+1] < as[i+1]) then (     if (count < as[i - 1+1]) then (     ans := ans+(count) ) else (     ans := ans+(count - as[i - 1+1]) ) ;  
     count := 0 ) else skip )  ;     i := i + 1 ) ; 
    count := count + 1 ; 
    if (count < as[as->size() - 1+1]) then (     ans := ans+(count) ) else (     ans := ans+(count - as[as->size() - 1+1]) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Map<Integer,Integer>map=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      if(map.keySet().contains(a)){
        map.put(a,map.get(a)+1);
      }
      else {
        map.put(a,1);
      }
    }
    int sum=0 ;
    for(int key : map.keySet()){
      int v=map.get(key);
      sum+=v>=key ? v-key : v ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (map->keys()->includes(a)) then (     map := map->union(Map{a |-> map->at(a) + 1}) ) else (     map := map->union(Map{a |-> 1}) ) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    for (key : map->keys()) do ( (     var v : int ; v := map->at(key) ;
     sum := sum+(if v >= key then v - key else v endif) )  ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.regex.Matcher ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] arr=new int[n];
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
      if(arr[i] % 2==0){
        arr[i]=arr[i]/2 ;
      }
      else if(count>0){
        arr[i]=arr[i]+1 ;
        arr[i]=arr[i]/2 ;
        count--;
      }
      else {
        arr[i]=arr[i]-1 ;
        arr[i]=arr[i]/2 ;
        count++;
      }
      System.out.println(arr[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() ; 
     if (arr[i+1] mod 2 = 0) then (     arr[i+1] := arr[i+1] / 2 ) else     if (count > 0) then (     arr[i+1] := arr[i+1] + 1 ; 
     arr[i+1] := arr[i+1] / 2 ; 
     count := count - 1 ) else (     arr[i+1] := arr[i+1] - 1 ; 
     arr[i+1] := arr[i+1] / 2 ; 
     count := count + 1 ) ;  ;  
     OclFile["System.out"].println(arr[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Set ;
public final class p074 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p074().run());
  }
  private static final int LIMIT=Library.pow(10,6);
  public String run(){
    int count=0 ;
    for(int i=0 ; i<LIMIT ; i++){
      if(getChainLength(i)==60)count++;
    }
    return Integer.toString(count);
  }
  private static int getChainLength(int n){
    Set<Integer>seen=new HashSet<>();
    while(true){
      if(! seen.add(n))return seen.size();
      n=factorialize(n);
    }
  }
  private static int[] FACTORIAL={
    1,1,2,6,24,120,720,5040,40320,362880 };
    private static int factorialize(int n){
      int sum=0 ;
      for(; n!=0 ; n/=10)sum+=FACTORIAL[n % 10];
      return sum ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class p074 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p074.newp074().run()) );
  static    attribute LIMIT : int := Library.pow(10, 6);
   operation run() : String
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < LIMIT do ( (     if (getChainLength(i) = 60) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return ((count) + "") );
  static   operation getChainLength( n : int) : int
  pre: true
  post: true
  activity: (     var seen : Set(int) ; seen := Set{} ;
     while (true) do (     if (not(seen->excludes(n))) then     return seen->size() else skip ; 
     n := factorialize(n) ) );
  static   attribute FACTORIAL : Sequence(int) := Sequence{1,1,2,6,24,120,720,5040,40320,362880};
  static   operation factorialize( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
       while n /= 0 do (     sum := sum+(FACTORIAL[n mod 10+1]) ;  ;     n := n/(10) ) ; 
     return sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.image.AreaAveragingScaleFilter ;
import java.sql.Array ;
import java.util.*;
import java.lang.*;
import java.io.*;
public class Solution {
  static BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
  public static void main(String[] args)throws IOException {
    int t=1 ;
    int i=0 ;
    while(i<t){
      i++;
      solve();
    }
  }
  static void solve()throws IOException {
    Scanner s=new Scanner(System.in);
    ArrayList<Integer>al=new ArrayList<>();
    int countodd=0 ;
    int n=s.nextInt();
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      int temp=s.nextInt();
      al.add(temp);
    }
    int flag=1 ;
    for(int i=0 ; i<n ; i++){
      if(al.get(i)% 2==0)al.set(i,al.get(i)/2);
      else {
        if(flag==1){
          al.set(i,(int)Math.floor(al.get(i)/2.0));
          flag=-1 ;
        }
        else {
          al.set(i,(int)Math.ceil(al.get(i)/2.0));
          flag=1 ;
        }
      }
    }
    for(int i : al){
      System.out.println(i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
     var i : int ; i := 0 ;
     while (i < t) do (     i := i + 1 ; 
     execute solve() ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var al : Sequence(int) ; al := Sequence{} ;
    var countodd : int ; countodd := 0 ;
    var n : int ; n := s.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : int ; temp := s.getCurrent()->toInteger() ;
     al := al->including(temp) )  ;     i := i + 1 ) ; 
    var flag : int ; flag := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (al->at(i+1) mod 2 = 0) then     al := al.setAt(i+1,al->at(i+1) / 2) ; else (     if (flag = 1) then (     al := al.setAt(i+1,(al->at(i+1) / 2.0)->floor()->oclAsType(int)) ; 
     flag := -1 ) else (     al := al.setAt(i+1,(al->at(i+1) / 2.0)->ceil()->oclAsType(int)) ; 
     flag := 1 ) ) )  ;     i := i + 1 ) ; 
    for (i : al) do ( (     OclFile["System.out"].println(i) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static double sum(int x,int n){
    double total=1.0 ;
    double previous=1.0 ;
    for(int i=1 ; i<=n ; i++){
      previous=(previous*x)/(i+1);
      total=total+previous ;
    }
    return total ;
  }
  public static void main(String[] args){
    int x=5,n=4 ;
    System.out.print("Sum is: "+sum(x,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sum( x : int, n : int) : double
  pre: true
  post: true
  activity: (     var total : double ; total := 1.0 ;
     var previous : double ; previous := 1.0 ;
         var i : int ; i := 1 ; while i <= n do ( (     previous := (previous * x) / (i + 1) ; 
     total := total + previous )  ;     i := i + 1 ) ; 
     return total );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 5 ;
    var n : int ; n := 4 ;
     OclFile["System.out"].print("Sum is: " + sum(x, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      int[] b=new int[t];
      int j=1,sum=0 ;
      while(t-->0){
        int n=sc.nextInt();
        if(n % 2==0)System.out.println(n/2);
        else {
          System.out.println((j+n)/2);
          j=(-1)*j ;
        }
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Integer.subrange(1,t)->collect(0) ;
    var j : int ; j := 1 ;
    var sum : int ; sum := 0 ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then     OclFile["System.out"].println(n / 2) ; else (     OclFile["System.out"].println((j + n) / 2) ; 
     j := (-1) * j ) ) ;  ) ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String smallestString(int N,int[] A){
    char ch='a' ;
    String S="" ;
    if(N<1 || A[0]!=1){
      S="-1" ;
      return S ;
    }
    S+=ch ;
    ch++;
    for(int i=1 ; i<N ; i++){
      int diff=A[i]-A[i-1];
      if(diff>1 || diff<0 || A[i]>26){
        S="-1" ;
        return S ;
      }
      else if(diff==0)S+='a' ;
      else {
        S+=ch ;
        ch++;
      }
    }
    return S ;
  }
  public static void main(String args[]){
    int[] arr={
      1,1,2,3,3 };
      int n=arr.length ;
      System.out.println(smallestString(n,arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation smallestString( N : int, A : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var ch : String ; ch := 'a' ;
     var S : String ; S := "" ;
    if (N < 1 or A[0+1] /= 1) then (     S := "-1" ; 
     return S ) else skip ; 
    S := S+(ch) ; 
    ch := ch + 1 ; 
        var i : int ; i := 1 ; while i < N do ( (     var diff : int ; diff := A[i+1] - A[(i)->char2byte() - 1+1] ;
     if (diff > 1 or diff < 0 or A[i+1] > 26) then (     S := "-1" ; 
     return S ) else     if (diff = 0) then     S := S+('a') else (     S := S+(ch) ; 
     ch := ch + 1 ) ;  )  ;     i := i + 1 ) ; 
    return S 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,2,3,3} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(smallestString(n, arr)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Set ;
public class MaxPossibleSuminWindow {
  static int returnMaxSum(int A[],int B[],int n){
    Set<Integer>mp=new HashSet<Integer>();
    int result=0 ;
    int curr_sum=0,curr_begin=0 ;
    for(int i=0 ; i<n ; ++i){
      while(mp.contains(A[i])){
        mp.remove(A[curr_begin]);
        curr_sum-=B[curr_begin];
        curr_begin++;
      }
      mp.add(A[i]);
      curr_sum+=B[i];
      result=Integer.max(result,curr_sum);
    }
    return result ;
  }
  public static void main(String[] args){
    int A[]={
      0,1,2,3,0,1,4 };
      int B[]={
        9,8,1,2,3,4,5 };
        int n=A.length ;
        System.out.println(returnMaxSum(A,B,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class MaxPossibleSuminWindow {
  static   operation returnMaxSum( A : Sequence(int), B : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var mp : Set(int) ; mp := Set{} ;
     var result : int ; result := 0 ;
    var curr_sum : int ; curr_sum := 0 ;
    var curr_begin : int ; curr_begin := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     while (mp->includes(A[i+1])) do (     mp := mp->excludingFirst(A[curr_begin+1]) ; 
     curr_sum := curr_sum-(B[curr_begin+1]) ; 
     curr_begin := curr_begin + 1 ) ; 
     mp := mp->including(A[i+1]) ; 
     curr_sum := curr_sum+(B[i+1]) ; 
     result := Set{result, curr_sum}->max() )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{0,1,2,3,0,1,4} ;
     var B : Sequence(int) ; B := Sequence{9,8,1,2,3,4,5} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].println(returnMaxSum(A, B, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isDivisible(int[] arr,int n,int y){
    int d=0,i=0 ;
    while(i<n){
      while(d<y && i<n)d=d*10+arr[i++];
      d=d % y ;
    }
    if(d==0)return true ;
    return false ;
  }
  public static void main(String[] args){
    int[] arr={
      1,2,1,5,6 };
      int x=arr.length ;
      int y=4 ;
      System.out.println(isDivisible(arr,x,y)? "Yes" : "No");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isDivisible( arr : Sequence(int), n : int, y : int) : boolean
  pre: true
  post: true
  activity: (     var d : int ; d := 0 ;
    var i : int ; i := 0 ;
     while (i < n) do (     while (d < y & i < n) do      d := d * 10 + arr[i+1]  ; i := i + 1 ; ; 
     d := d mod y ) ; 
     if (d = 0) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,1,5,6} ;
     var x : int ; x := arr->size() ;
     var y : int ; y := 4 ;
     OclFile["System.out"].println(if isDivisible(arr, x, y) then "Yes" else "No" endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int seriesFunc(int n){
    int sumSquare=(n*(n+1)*(2*n+1))/6 ;
    int sumNatural=(n*(n+1)/2);
    return(sumSquare+sumNatural+1);
  }
  public static void main(String args[]){
    int n=8 ;
    System.out.println(seriesFunc(n));
    n=13 ;
    System.out.println(seriesFunc(13));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation seriesFunc( n : int) : int
  pre: true
  post: true
  activity: (     var sumSquare : int ; sumSquare := (n * (n + 1) * (2 * n + 1)) / 6 ;
     var sumNatural : int ; sumNatural := (n * (n + 1) / 2) ;
     return (sumSquare + sumNatural + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     OclFile["System.out"].println(seriesFunc(n)) ; 
     n := 13 ; 
     OclFile["System.out"].println(seriesFunc(13)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static void Alphabet_N_Pattern(int N){
    int index,side_index,size ;
    int Right=1,Left=1,Diagonal=2 ;
    for(index=0 ; index<N ; index++){
      System.out.print(Left++);
      for(side_index=0 ; side_index<2*(index); side_index++)System.out.print(" ");
      if(index!=0 && index!=N-1)System.out.print(Diagonal++);
      else System.out.print(" ");
      for(side_index=0 ; side_index<2*(N-index-1); side_index++)System.out.print(" ");
      System.out.print(Right++);
      System.out.println();
    }
  }
  public static void main(String args[]){
    int Size=6 ;
    Alphabet_N_Pattern(Size);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation Alphabet_N_Pattern( N : int) : void
  pre: true
  post: true
  activity: (     var index : int ;
    var side_index : int ;
    var size : int ;
     var Right : int ; Right := 1 ;
    var Left : int ; Left := 1 ;
    var Diagonal : int ; Diagonal := 2 ;
         index := 0 ; while index < N do ( (     OclFile["System.out"].print(Left) ; 
         side_index := 0 ; while side_index < 2 * (index) do (     OclFile["System.out"].print(" ") ;  ;     side_index := side_index + 1 ) ; 
    if (index /= 0 & index /= N - 1) then     OclFile["System.out"].print(Diagonal) else     OclFile["System.out"].print(" ") ; ;  
        side_index := 0 ; while side_index < 2 * (N - index - 1) do (     OclFile["System.out"].print(" ") ;  ;     side_index := side_index + 1 ) ; 
    OclFile["System.out"].print(Right) ; 
    OclFile["System.out"].println() ; 
 )  ;     index := index + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Size : int ; Size := 6 ;
     execute Alphabet_N_Pattern(Size) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String str=input.readLine();
      String str_ary[]=str.split(" ");
      if(str_ary[0] .equals("0")&& str_ary[1] .equals("0"))break ;
      int x,y,big,small,count=0 ;
      x=Integer.parseInt(str_ary[0]);
      y=Integer.parseInt(str_ary[1]);
      if(x>y){
        big=x ;
        small=y ;
      }
      else {
        big=y ;
        small=x ;
      }
      while(true){
        if((big % small)==0){
          count++;
          break ;
        }
        int tmp=big % small ;
        big=small ;
        small=tmp ;
        count++;
      }
      System.out.println(small+" "+count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var str : String ; str := input.readLine() ;
     var str_ary : Sequence(String) ; str_ary := str->split(" ") ;
    if (str_ary[0+1] = "0" & str_ary[1+1] = "0") then     break else skip ; 
    var x : int ;
    var y : int ;
    var big : int ;
    var small : int ;
    var count : int ; count := 0 ;
    x := (str_ary[0+1])->toInteger() ; 
    y := (str_ary[1+1])->toInteger() ; 
    if (x > y) then (     big := x ; 
     small := y ) else (     big := y ; 
     small := x ) ;  
    while (true) do (     if ((big mod small) = 0) then (     count := count + 1 ; 
     break ) else skip ; 
     var tmp : int ; tmp := big mod small ;
    big := small ; 
    small := tmp ; 
    count := count + 1 ; 
 ) ; 
    OclFile["System.out"].println(small + " " + count) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int colourVisible(int height[],int colour[],int K){
    int arr[]=new int[K+1];
    int visible=0 ;
    int max=height[K-1];
    arr[colour[K-1] ]=1 ;
    for(int i=K-2 ; i>=0 ; i--){
      if(height[i]>max){
        max=height[i];
        arr[colour[i] ]=1 ;
      }
    }
    for(int i=1 ; i<=K ; i++){
      if(arr[i]==1)visible++;
    }
    return visible ;
  }
  public static void main(String[] args){
    int height[]={
      3,5,1,2,3 };
      int colour[]={
        1,2,3,4,3 };
        int K=colour.length ;
        System.out.println(colourVisible(height,colour,K));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation colourVisible( height : Sequence(int), colour : Sequence(int), K : int) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,K + 1)->collect(0) ;
     var visible : int ; visible := 0 ;
    var max : int ; max := height[K - 1+1] ;
    arr[colour[K - 1+1]+1] := 1 ; 
        var i : int ; i := K - 2 ; while i >= 0 do ( (     if (height[i+1] > max) then (     max := height[i+1] ; 
     arr[colour[i+1]+1] := 1 ) else skip )  ;     i := i - 1 ) ; 
        var i : int ; i := 1 ; while i <= K do ( (     if (arr[i+1] = 1) then     visible := visible + 1 ; else skip )  ;     i := i + 1 ) ; 
    return visible 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var height : Sequence(int) ; height := Sequence{3,5,1,2,3} ;
     var colour : Sequence(int) ; colour := Sequence{1,2,3,4,3} ;
     var K : int ; K := colour->size() ;
     OclFile["System.out"].println(colourVisible(height, colour, K)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    for(; ; ){
      int x=sc.nextInt();
      int y=sc.nextInt();
      if((x | y)==0){
        break ;
      }
      if(x<y){
        int t=x ;
        x=y ;
        y=t ;
      }
      for(int i=0 ; ; i++){
        if(y==0){
          println(x+" "+i);
          break ;
        }
        x=x % y ;
        int t=x ;
        x=y ;
        y=t ;
      }
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(x,y)) = 0) then (     break ) else skip ; 
    if (x < y) then (     var t : int ; t := x ;
     x := y ; 
     y := t ) else skip ; 
        var i : int ; i := 0 ; while true do ( (     if (y = 0) then (     execute println(x + " " + i) ; 
     break ) else skip ; 
     x := x mod y ; 
    var t : int ; t := x ;
    x := y ; 
    y := t ; 
 )  ;     i := i + 1 ) ; 
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int count=0 ;
  static int gcd(int a,int b){
    count++;
    int r=a % b ;
    if(r==0){
      return b ;
    }
    else {
      return gcd(b,r);
    }
  }
  void main(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int a=sc.nextInt();
      int b=sc.nextInt();
      if(a+b==0)break ;
      if(a<b){
        int temp=a ;
        a=b ;
        b=temp ;
      }
      int ans=gcd(a,b);
      System.out.println(ans+" "+count);
      count=0 ;
    }
  }
  public static void main(String[] args){
    new Main().main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute count : int := 0;
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     count := count + 1 ; 
     var r : int ; r := a mod b ;
     if (r = 0) then (     return b ) else (     return gcd(b, r) ) );
   operation main() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    if (a + b = 0) then     break else skip ; 
    if (a < b) then (     var temp : int ; temp := a ;
     a := b ; 
     b := temp ) else skip ; 
    var ans : int ; ans := gcd(a, b) ;
    OclFile["System.out"].println(ans + " " + count) ; 
    count := 0 ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().main() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void ModifiedSieveOfEratosthenes(int N,boolean Expo_Prime[]){
    boolean[] primes=new boolean[N];
    Arrays.fill(primes,true);
    for(int i=2 ; i<N ; i++){
      if(primes[i]){
        int no=i ;
        while(no<=N){
          Expo_Prime[no]=true ;
          no*=i ;
        }
        for(int j=i*i ; j<N ; j+=i)primes[j]=false ;
      }
    }
  }
  static void Display(int arr[],boolean Expo_Prime[],int n){
    for(int i=0 ; i<n ; i++)if(Expo_Prime[arr[i] ])System.out.print(arr[i]+" ");
  }
  static void FindExpoPrime(int arr[],int n){
    int max=0 ;
    for(int i=0 ; i<n ; i++){
      if(max<arr[i])max=arr[i];
    }
    boolean[] Expo_Prime=new boolean[max+1];
    ModifiedSieveOfEratosthenes(max+1,Expo_Prime);
    Display(arr,Expo_Prime,n);
  }
  public static void main(String[] args){
    int arr[]={
      4,6,9,16,1,3,12,36,625,1000 };
      int n=arr.length ;
      FindExpoPrime(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation ModifiedSieveOfEratosthenes( N : int, Expo_Prime : Sequence(boolean)) : void
  pre: true
  post: true
  activity: (     var primes : Sequence(boolean) ; primes := Integer.subrange(1,N)->collect(false) ;
     primes := primes->collect(true) ; 
         var i : int ; i := 2 ; while i < N do ( (     if (primes[i+1]) then (     var no : int ; no := i ;
     while (no <= N) do (     Expo_Prime[no+1] := true ; 
     no := no*(i) ) ; 
         var j : int ; j := i * i ; while j < N do (     primes[j+1] := false ;  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) );
  static   operation Display( arr : Sequence(int), Expo_Prime : Sequence(boolean), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     if (Expo_Prime[arr[i+1]+1]) then     OclFile["System.out"].print(arr[i+1] + " ") ; else skip ;  ;     i := i + 1 ) );
  static   operation FindExpoPrime( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var max : int ; max := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (max < arr[i+1]) then     max := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
    var Expo_Prime : Sequence(boolean) ; Expo_Prime := Integer.subrange(1,max + 1)->collect(false) ;
    execute ModifiedSieveOfEratosthenes(max + 1, Expo_Prime) ; 
    execute Display(arr, Expo_Prime, n) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,6,9,16,1,3,12,36,625,1000} ;
     var n : int ; n := arr->size() ;
     execute FindExpoPrime(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    double[] nums=new double[6];
    while(sc.hasNext()){
      for(int i=0 ; i<nums.length ; i++){
        nums[i]=sc.nextDouble();
      }
      simuEqu(nums);
    }
    sc.close();
  }
  private static void simuEqu(double[] nums){
    double a=nums[0];
    double b=nums[1];
    double c=nums[2];
    double d=nums[3];
    double e=nums[4];
    double f=nums[5];
    double x=(c*e-f*b)/(a*e-b*d);
    double y=(c-a*x)/b ;
    if(x==0.0){
      x=0.0 ;
    }
    if(y==0.0){
      y=0.0 ;
    }
    System.out.printf("%.3f %.3f\n",x,y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var nums : Sequence(double) ; nums := Integer.subrange(1,6)->collect(0.0) ;
     while (sc.hasNext()) do (         var i : int ; i := 0 ; while i < nums->size() do ( (     nums[i+1] := sc.getCurrent()->toReal() )  ;     i := i + 1 ) ; 
     execute simuEqu(nums) ) ; 
     skip );
  static   operation simuEqu( nums : Sequence(double)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := nums[0+1] ;
     var b : double ; b := nums[1+1] ;
    var c : double ; c := nums[2+1] ;
    var d : double ; d := nums[3+1] ;
    var e : double ; e := nums[4+1] ;
    var f : double ; f := nums[5+1] ;
    var x : double ; x := (c * e - f * b) / (a * e - b * d) ;
    var y : double ; y := (c - a * x) / b ;
    if (x = 0.0) then (     x := 0.0 ) else skip ; 
    if (y = 0.0) then (     y := 0.0 ) else skip ; 
    OclFile["System.out"].printf("%.3f %.3f\n", x, y) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int _x,_y,x,y ;
      _x=parseInt(line.substring(0,line.indexOf(' ')));
      _y=parseInt(line.substring(line.indexOf(' ')+1));
      if((_x | _y)==0)break ;
      x=_x>_y ? _x : _y ;
      y=_x>_y ? _y : _x ;
      int t,step=0,gcd ;
      while(true){
        x %=y ;
        t=y ;
        y=x ;
        x=t ;
        step++;
        if(y==0){
          gcd=x ;
          break ;
        }
      }
      System.out.println(gcd+" "+step);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var _x : int ;
    var _y : int ;
    var x : int ;
    var y : int ;
     _x := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    _y := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    if ((MathLib.bitwiseOr(_x,_y)) = 0) then     break else skip ; 
    x := if _x > _y then _x else _y endif ; 
    y := if _x > _y then _y else _x endif ; 
    var t : int ;
    var step : int ; step := 0 ;
    var gcd : int ;
    while (true) do (     x := x mod y ; 
     t := y ; 
    y := x ; 
    x := t ; 
    step := step + 1 ; 
    if (y = 0) then (     gcd := x ; 
     break ) else skip ; 
 ) ; 
    OclFile["System.out"].println(gcd + " " + step) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void euc(int n,int m){
    int x,y,z,t=0 ;
    if(n<m){
      x=m ;
      y=n ;
    }
    else {
      x=n ;
      y=m ;
    }
    while(y>0){
      x %=y ;
      z=y ;
      y=x ;
      x=z ;
      t++;
    }
    System.out.println(String.valueOf(x)+" "+String.valueOf(t));
    return ;
  }
  Main(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt(),m=sc.nextInt();
      if(n+m==0)break ;
      euc(n,m);
    }
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation euc( n : int, m : int) : void
  pre: true
  post: true
  activity: (     var x : int ;
    var y : int ;
    var z : int ;
    var t : int ; t := 0 ;
     if (n < m) then (     x := m ; 
     y := n ) else (     x := n ; 
     y := m ) ;  
    while (y > 0) do (     x := x mod y ; 
     z := y ; 
    y := x ; 
    x := z ; 
    t := t + 1 ; 
 ) ; 
    OclFile["System.out"].println(((x) + "") + " " + ((t) + "")) ; 
    return 
 );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
     if (n + m = 0) then     break else skip ; 
     execute euc(n, m) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A173 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    char[] A=in.next().toCharArray();
    char[] B=in.next().toCharArray();
    int period=A.length*B.length/gcd(A.length,B.length);
    int a=0 ;
    int b=0 ;
    for(int i=0 ; i<period ; i++){
      char ca=A[i % A.length];
      char cb=B[i % B.length];
      int count=(N-i+period-1)/period ;
      if(ca=='R' && cb=='S'){
        b+=count ;
      }
      else if(ca=='R' && cb=='P'){
        a+=count ;
      }
      else if(ca=='S' && cb=='R'){
        a+=count ;
      }
      else if(ca=='S' && cb=='P'){
        b+=count ;
      }
      else if(ca=='P' && cb=='R'){
        b+=count ;
      }
      else if(ca=='P' && cb=='S'){
        a+=count ;
      }
    }
    System.out.println(a+" "+b);
  }
  static int gcd(int a,int b){
    return(b==0)? a : gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A173 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var A : Sequence(String) ; A := in.getCurrent()->characters() ;
    var B : Sequence(String) ; B := in.getCurrent()->characters() ;
    var period : int ; period := A->size() * B->size() / gcd(A->size(), B->size()) ;
    var a : int ; a := 0 ;
    var b : int ; b := 0 ;
        var i : int ; i := 0 ; while i < period do ( (     var ca : String ; ca := A[i mod A->size()+1] ;
     var cb : String ; cb := B[i mod B->size()+1] ;
     var count : int ; count := (N - i + period - 1) / period ;
     if (ca = 'R' & cb = 'S') then (     b := b+(count) ) else     if (ca = 'R' & cb = 'P') then (     a := a+(count) ) else     if (ca = 'S' & cb = 'R') then (     a := a+(count) ) else     if (ca = 'S' & cb = 'P') then (     b := b+(count) ) else     if (ca = 'P' & cb = 'R') then (     b := b+(count) ) else     if (ca = 'P' & cb = 'S') then (     a := a+(count) ) else skip ; ;  ;  ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a + " " + b) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if (b = 0) then a else gcd(b, a mod b) endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    int[] s=new int[m];
    int[] c=new int[m];
    for(int i=0 ; i<m ; i++){
      s[i]=sc.nextInt();
      c[i]=sc.nextInt();
    }
    for(int i=0 ; i<m ; i++){
      if(n!=1 && s[i]==1 && c[i]==0){
        System.out.println(-1);
        return ;
      }
      for(int j=0 ; j<i ; j++){
        if(s[i]==s[j] && c[i]!=c[j]){
          System.out.println(-1);
          return ;
        }
      }
    }
    for(int i=0 ; i<1000 ; i++){
      String tmp=""+i ;
      if(tmp.length()!=n)continue ;
      boolean b=true ;
      for(int j=0 ; j<m ; j++){
        if(tmp.charAt(s[j]-1)-'0'!=c[j]){
          b=false ;
          break ;
        }
      }
      if(b==false)continue ;
      System.out.println(i);
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var s : Sequence(int) ; s := Integer.subrange(1,m)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     s[i+1] := sc.getCurrent()->toInteger() ; 
     c[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     if (n /= 1 & s[i+1] = 1 & c[i+1] = 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
         var j : int ; j := 0 ; while j < i do ( (     if (s[i+1] = s[j+1] & c[i+1] /= c[j+1]) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 1000 do ( (     var tmp : String ; tmp := "" + i ;
     if (tmp->size() /= n) then     continue else skip ; 
    var b : boolean ; b := true ;
        var j : int ; j := 0 ; while j < m do ( (     if (tmp->at(s[j+1] - 1+1) - ('0')->char2byte() /= c[j+1]) then (     b := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (b = false) then     continue else skip ; 
    OclFile["System.out"].println(i) ; 
    return 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.HashMap ;
import java.util.TreeMap ;
import java.util.Map ;
import java.util.Collections ;
import java.util.List ;
import java.util.Arrays ;
import java.util.ArrayList ;
import java.lang.Math ;
public class Main {
  private static Scanner sc=new Scanner(System.in);
  private static int mod=(int)10e8+7 ;
  public static void main(String[] args){
    int n=sc.nextInt();
    int m=sc.nextInt();
    Map<Integer,Integer>maps=new HashMap<Integer,Integer>();
    int key ;
    int value ;
    for(int i=0 ; i<m ; i++){
      key=sc.nextInt();
      value=sc.nextInt();
      if((maps.containsKey(key)&& maps.get(key)!=value)||(key==1 && value==0 && n!=1)){
        System.out.println(-1);
        return ;
      }
      maps.put(key,value);
    }
    String first_digit="0" ;
    String second_digit="0" ;
    String third_digit="0" ;
    for(Map.Entry<Integer,Integer>map : maps.entrySet()){
      if(map.getKey()==1){
        first_digit=String.valueOf(map.getValue());
      }
      else if(map.getKey()==2){
        second_digit=String.valueOf(map.getValue());
      }
      else if(map.getKey()==3){
        third_digit=String.valueOf(map.getValue());
      }
    }
    if(n==1){
      System.out.println(first_digit);
    }
    else if(n==2){
      if(maps.containsKey(1)){
        System.out.println(first_digit+second_digit);
      }
      else {
        System.out.println("1"+second_digit);
      }
    }
    else {
      if(maps.containsKey(1)){
        System.out.println(first_digit+second_digit+third_digit);
      }
      else {
        System.out.println("1"+second_digit+third_digit);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute mod : int := 10e8->oclAsType(int) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var maps : Map(int,int) ; maps := Map{} ;
    var key : int ;
    var value : int ;
        var i : int ; i := 0 ; while i < m do ( (     key := sc.getCurrent()->toInteger() ; 
     value := sc.getCurrent()->toInteger() ; 
     if ((maps->keys()->includes(key) & maps->at(key) /= value) or (key = 1 & value = 0 & n /= 1)) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
     maps := maps->union(Map{key |-> value}) )  ;     i := i + 1 ) ; 
    var first_digit : String ; first_digit := "0" ;
    var second_digit : String ; second_digit := "0" ;
    var third_digit : String ; third_digit := "0" ;
    for (map : maps->asSet()) do ( (     if (map.getKey() = 1) then (     first_digit := ((map.getValue()) + "") ) else     if (map.getKey() = 2) then (     second_digit := ((map.getValue()) + "") ) else     if (map.getKey() = 3) then (     third_digit := ((map.getValue()) + "") ) else skip ; ;  )  ) ; 
    if (n = 1) then (     OclFile["System.out"].println(first_digit) ) else     if (n = 2) then (     if (maps->keys()->includes(1)) then (     OclFile["System.out"].println(first_digit + second_digit) ) else (     OclFile["System.out"].println("1" + second_digit) ) ) else (     if (maps->keys()->includes(1)) then (     OclFile["System.out"].println(first_digit + second_digit + third_digit) ) else (     OclFile["System.out"].println("1" + second_digit + third_digit) ) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String data=sc.nextLine();
    String[] array=data.split(" ");
    int n=Integer.parseInt(array[0]);
    int m=Integer.parseInt(array[1]);
    int[][] table=new int[m][2];
    for(int i=0 ; i<m ; i++){
      for(int j=0 ; j<2 ; j++){
        table[i][j]=sc.nextInt();
      }
    }
    int[] seisu=new int[n];
    String[] memo=new String[n];
    int result=0 ;
    for(int i=0 ; i<m ; i++){
      int keta=table[i][0];
      int suuji=table[i][1];
      if(memo[keta-1]==null){
        seisu[keta-1]=suuji ;
        memo[keta-1]="x" ;
      }
      else {
        if(suuji!=seisu[keta-1])result=-1 ;
      }
    }
    if(n>=2 && memo[0]!="x" && seisu[0]==0){
      seisu[0]=1 ;
    }
    if(result!=-1){
      String buf="" ;
      for(int i=0 ; i<n ; i++){
        buf=buf+String.valueOf(seisu[i]);
      }
      result=Integer.parseInt(buf);
      int resultlen=String.valueOf(result).length();
      if(resultlen<n){
        result=-1 ;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var data : String ; data := sc.nextLine() ;
    var array : Sequence(String) ; array := data->split(" ") ;
    var n : int ; n := (array[0+1])->toInteger() ;
    var m : int ; m := (array[1+1])->toInteger() ;
    var table : Sequence(Sequence(int)) ; table := Integer.subrange(1,m)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j < 2 do ( (     table[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var seisu : Sequence(int) ; seisu := Integer.subrange(1,n)->collect(0) ;
    var memo : Sequence(String) ; memo := Integer.subrange(1,n)->collect(null) ;
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var keta : int ; keta := table[i+1][0+1] ;
     var suuji : int ; suuji := table[i+1][1+1] ;
     if (memo[keta - 1+1] = null) then (     seisu[keta - 1+1] := suuji ; 
     memo[keta - 1+1] := "x" ) else (     if (suuji /= seisu[keta - 1+1]) then     result := -1 ; else skip ) )  ;     i := i + 1 ) ; 
    if (n >= 2 & memo[0+1] /= "x" & seisu[0+1] = 0) then (     seisu[0+1] := 1 ) else skip ; 
    if (result /= -1) then (     var buf : String ; buf := "" ;
         var i : int ; i := 0 ; while i < n do ( (     buf := buf + ((seisu[i+1]) + "") )  ;     i := i + 1 ) ; 
    result := (buf)->toInteger() ; 
    var resultlen : int ; resultlen := ((result) + "")->size() ;
    if (resultlen < n) then (     result := -1 ) else skip ; 
 ) else skip ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean checkPowerof8(int n){
    double i=Math.log(n)/Math.log(8);
    return(i-Math.floor(i)<0.000001);
  }
  public static void main(String args[]){
    int n=65 ;
    if(checkPowerof8(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkPowerof8( n : int) : boolean
  pre: true
  post: true
  activity: (     var i : double ; i := (n)->log() / (8)->log() ;
     return (i - (i)->floor() < 0.000001) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 65 ;
     if (checkPowerof8(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  Main(){
    Scanner SC=new Scanner(System.in);
    int N=Integer.parseInt(SC.next());
    int M=Integer.parseInt(SC.next());
    int[] R=new int[N];
    for(int i=0 ; i<N ; i++){
      R[i]=-1 ;
    }
    for(int i=0 ; i<M ; i++){
      int S=Integer.parseInt(SC.next());
      int C=Integer.parseInt(SC.next());
      if(R[S-1]==-1){
        R[S-1]=C ;
      }
      else {
        if(R[S-1]!=C){
          System.out.println(-1);
          return ;
        }
      }
    }
    if(N==1){
      if(R[0]==-1){
        R[0]=0 ;
      }
    }
    else {
      if(R[0]==0){
        System.out.println(-1);
        return ;
      }
      else if(R[0]==-1){
        R[0]=1 ;
      }
      for(int i=1 ; i<N ; i++){
        if(R[i]==-1){
          R[i]=0 ;
        }
      }
    }
    for(int i=0 ; i<N ; i++){
      System.out.print(R[i]);
    }
    System.out.println("");
  }
  public static void main(String[] args){
    Main main=new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var SC : OclFile ; SC := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (SC.getCurrent())->toInteger() ;
    var M : int ; M := (SC.getCurrent())->toInteger() ;
    var R : Sequence(int) ; R := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     R[i+1] := -1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var S : int ; S := (SC.getCurrent())->toInteger() ;
     var C : int ; C := (SC.getCurrent())->toInteger() ;
     if (R[S - 1+1] = -1) then (     R[S - 1+1] := C ) else (     if (R[S - 1+1] /= C) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ) )  ;     i := i + 1 ) ; 
    if (N = 1) then (     if (R[0+1] = -1) then (     R[0+1] := 0 ) else skip ) else (     if (R[0+1] = 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else     if (R[0+1] = -1) then (     R[0+1] := 1 ) else skip ; ;  
         var i : int ; i := 1 ; while i < N do ( (     if (R[i+1] = -1) then (     R[i+1] := 0 ) else skip )  ;     i := i + 1 ) ) ;  
        var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].print(R[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    boolean flag=true ;
    HashMap<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<M ; i++){
      int s=sc.nextInt();
      int c=sc.nextInt();
      if(map.containsKey(s)){
        if(map.get(s)!=c){
          flag=false ;
        }
      }
      else {
        if(s==1 && c==0 && N>=2){
          flag=false ;
        }
        else {
          map.put(s,c);
        }
      }
    }
    sc.close();
    Integer[] ans={
-1,-1,-1 };
      for(Map.Entry<Integer,Integer>entry : map.entrySet()){
        ans[entry.getKey()-1]=entry.getValue();
      }
      if(flag){
        for(int i=0 ; i<N ; i++){
          if(ans[i]>=0){
            System.out.print(ans[i]);
          }
          else {
            if(i==0){
              if(N==1){
                System.out.print("0");
              }
              else {
                System.out.print("1");
              }
            }
            else {
              System.out.print("0");
            }
          }
        }
      }
      else {
        System.out.println(-1);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var flag : boolean ; flag := true ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < M do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var c : int ; c := sc.getCurrent()->toInteger() ;
     if (map->keys()->includes(s)) then (     if (map->at(s) /= c) then (     flag := false ) else skip ) else (     if (s = 1 & c = 0 & N >= 2) then (     flag := false ) else (     map := map->union(Map{s |-> c}) ) ) )  ;     i := i + 1 ) ; 
    skip ; 
    var ans : Sequence(int) ; ans := Sequence{-1,-1,-1} ;
    for (entry : map->asSet()) do ( (     ans[entry.getKey() - 1+1] := entry.getValue() )  ) ; 
    if (flag) then (         var i : int ; i := 0 ; while i < N do ( (     if (ans[i+1] >= 0) then (     OclFile["System.out"].print(ans[i+1]) ) else (     if (i = 0) then (     if (N = 1) then (     OclFile["System.out"].print("0") ) else (     OclFile["System.out"].print("1") ) ) else (     OclFile["System.out"].print("0") ) ) )  ;     i := i + 1 ) ) else (     OclFile["System.out"].println(-1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    char c[]=scan.next().toCharArray();
    if((c[0]==c[1] && c[1]==c[2])||(c[3]==c[2] && c[1]==c[2]))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : Sequence(String) ; c := scan.getCurrent()->characters() ;
     if ((c[0+1] = c[1+1] & c[1+1] = c[2+1]) or (c[3+1] = c[2+1] & c[1+1] = c[2+1])) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      String str=in.nextLine();
      if(str.contains("000")){
        out.print("Yes");
        return ;
      }
      for(int i=111 ; i<1000 ; i+=111){
        if(str.contains(String.valueOf(i))){
          out.print("Yes");
          return ;
        }
      }
      out.print("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var str : String ; str := in.nextLine() ;
     if (str->includes("000")) then (     skip ; 
     return ) else skip ; 
         var i : int ; i := 111 ; while i < 1000 do ( (     if (str->includes(((i) + ""))) then (     skip ; 
     return ) else skip )  ;     i := i+(111) ) ; 
     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class Main {
  public static void main(String[] args)throws IOException {
    List<String>ans=new ArrayList<String>();
    for(int[] in=readInts(); in!=null ; in=readInts()){
      String format=b(in);
      System.out.println(format);
    }
  }
  private static String b(int[] in){
    int a11=in[0],a12=in[1],b1=in[2];
    int a21=in[3],a22=in[4],b2=in[5];
    double D=a11*a22-a12*a21 ;
    if(Double.compare(D,0.0)==0){
    }
    int xx=+a22*b1-a12*b2 ;
    int yy=+a11*b2-a21*b1 ;
    double ansX=(xx/D);
    double ansY=(yy/D);
    if(ansX==0){
      ansX=0.0/1.0 ;
    }
    if(ansY==0){
      ansY=+0.0/1.0 ;
    }
    String format=String.format("%.3f %.3f",ansX,ansY);
    return format ;
  }
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  private static int[] readInts()throws IOException {
    String readLine=br.readLine();
    if(readLine==null || readLine.equals("")){
      return null ;
    }
    String[] s=readLine.split(" ");
    int[] result=new int[s.length];
    for(int i=0 ; i<result.length ; i++)result[i]=Integer.parseInt(s[i],10);
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ans : Sequence(String) ; ans := Sequence{} ;
         var in : Sequence(int) ; in := readInts() ; while in /= null do ( (     var format : String ; format := b(in) ;
     OclFile["System.out"].println(format) )  ;     in := readInts() ) );
  static   operation b( in : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var a11 : int ; a11 := in[0+1] ;
    var a12 : int ; a12 := in[1+1] ;
    var b1 : int ; b1 := in[2+1] ;
     var a21 : int ; a21 := in[3+1] ;
    var a22 : int ; a22 := in[4+1] ;
    var b2 : int ; b2 := in[5+1] ;
    var D : double ; D := a11 * a22 - a12 * a21 ;
    if ((D)->compareTo(0.0) = 0) then skip else skip ; 
    var xx : int ; xx := a22 * b1 - a12 * b2 ;
    var yy : int ; yy := a11 * b2 - a21 * b1 ;
    var ansX : double ; ansX := (xx / D) ;
    var ansY : double ; ansY := (yy / D) ;
    if (ansX = 0) then (     ansX := 0.0 / 1.0 ) else skip ; 
    if (ansY = 0) then (     ansY := 0.0 / 1.0 ) else skip ; 
    var format : String ; format := StringLib.format("%.3f %.3f",Sequence{ansX,ansY}) ;
    return format 
 );
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   operation readInts() : Sequence(int)
  pre: true
  post: true
  activity: (     var readLine : String ; readLine := br.readLine() ;
     if (readLine = null or readLine = "") then (     return null ) else skip ; 
    var s : Sequence(String) ; s := readLine->split(" ") ;
    var result : Sequence(int) ; result := Integer.subrange(1,s->size())->collect(0) ;
        var i : int ; i := 0 ; while i < result->size() do (     result[i+1] := (s[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner();
    String s=sc.next();
    boolean b=s.charAt(1)==s.charAt(2);
    b &=s.charAt(0)==s.charAt(1)|| s.charAt(2)==s.charAt(3);
    System.out.println(b ? "Yes" : "No");
  }
}
class Scanner {
  private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  private static final int SPACE=(int)' ' ;
  private static final int LINE_END_0=13 ;
  private static final int LINE_END_1=10 ;
  private static final int BEFORE=-1 ;
  public boolean ready(){
    try {
      return br.ready();
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return false ;
  }
  public String next(){
    StringBuilder sb=new StringBuilder();
    int length=BEFORE ;
    readLoop : while(true){
      try {
        int value=br.read();
        switch(value){
          case LINE_END_1 : if(length==BEFORE)break ;
          if((int)sb.charAt(length)==LINE_END_0)sb.deleteCharAt(length);
          case SPACE : break readLoop ;
        }
        sb.append((char)value);
        length++;
      }
      catch(IOException e){
        e.printStackTrace();
      }
    }
    return sb.toString();
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public double nextDouble(){
    return Double.parseDouble(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := (arguments ( )) ;
     var s : String ; s := sc.getCurrent() ;
    var b : boolean ; b := s->at(1+1) = s->at(2+1) ;
    b := MathLib.bitwiseAnd(b, s->at(0+1) = s->at(1+1) or s->at(2+1) = s->at(3+1)) ; 
    OclFile["System.out"].println(if b then "Yes" else "No" endif) ; 
 );
}
class Scanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static    attribute SPACE : int := (' ')->char2byte();
  static    attribute LINE_END_0 : int := 13;
  static    attribute LINE_END    var LINE_ENDint : boolean ; LINE_ENDint := 10 : int := 10;
  static    attribute BEFORE : int := -1;
   operation ready() : boolean
  pre: true
  post: true
  activity: (     try (     return br.canRead() )   catch (e : IOException) do (     e.printStackTrace() )
     return false );
   operation next() : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     var length : int ; length := BEFORE ;
     while (true) do (     try (     var value : int ; value := br.read() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (value) ; 
       if _switchval = LINE_END    try (     var value : int ; value := br.read() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (value) ; 
       if _switchval = LINE_END    try (     var value : int ; value := br.read() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (value) ; 
       if _switchval = LINE_END_1 then
     if (length = BEFORE) then     break else skip ; 
    if (sb->at(length+1)->oclAsType(int) = LINE_END_0) then     sb := sb->excludingAt(length+1) ; else skip ; 
   else skip ;
       if _switchval = SPACE then
     break 
   else skip ;
 )
     sb := sb + StringLib.newString(value->oclAsType(String)) ; 
     length := length + 1 )   catch (e : IOException) do (     e.printStackTrace() )
 then
     if (length = BEFORE) then     break else skip ; 
    if (sb->at(length+1)->oclAsType(int) = LINE_END_0) then     sb := sb->excludingAt(length+1) ; else skip ; 
   else skip ;
       if _switchval = SPACE then
     break 
   else skip ;
 )
     sb := sb + StringLib.newString(value->oclAsType(String)) ; 
     length := length + 1 )   catch (e : IOException) do (     e.printStackTrace() )
 then
     if (length = BEFORE) then     break else skip ; 
    if (sb->at(length+1)->oclAsType(int) = LINE_END_0) then     sb := sb->excludingAt(length+1) ; else skip ; 
   else skip ;
       if _switchval = SPACE then
     break 
   else skip ;
 )
     sb := sb + StringLib.newString(value->oclAsType(String)) ; 
     length := length + 1 )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return sb+"" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.List ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=a/10 ;
    int c=a-(a/1000)*1000 ;
    if(b % 111==0 || c % 111==0){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := a / 10 ;
    var c : int ; c := a - (a / 1000) * 1000 ;
    if (b mod 111 = 0 or c mod 111 = 0) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=scan.nextInt();
    String d=Integer.toString(N);
    char[] data=d.toCharArray();
    boolean answer=false ;
    if(1000<=N){
      if(data[0]==data[1] && data[1]==data[2]){
        answer=true ;
      }
      if(data[1]==data[2] && data[2]==data[3]){
        answer=true ;
      }
    }
    System.out.println(answer ? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var d : String ; d := ((N) + "") ;
    var data : Sequence(String) ; data := d->characters() ;
    var answer : boolean ; answer := false ;
    if (1000 <= N) then (     if (data[0+1] = data[1+1] & data[1+1] = data[2+1]) then (     answer := true ) else skip ; 
     if (data[1+1] = data[2+1] & data[2+1] = data[3+1]) then (     answer := true ) else skip ) else skip ; 
    OclFile["System.out"].println(if answer then "Yes" else "No" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void complement(String number1){
    char[] number=number1.toCharArray();
    for(int i=0 ; i<number.length ; i++)if(number[i]!='.')number[i]=(char)((int)('9')-(int)(number[i])+(int)('0'));
    System.out.println("9's complement is : "+String.valueOf(number));
  }
  public static void main(String[] args){
    String number="345.45" ;
    complement(number);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation complement( number1 : String) : void
  pre: true
  post: true
  activity: (     var number : Sequence(String) ; number := number1->characters() ;
         var i : int ; i := 0 ; while i < number->size() do (     if (number[i+1] /= '.') then     number[i+1] := (('9')->oclAsType(int) - (number[i+1])->oclAsType(int) + ('0')->oclAsType(int))->oclAsType(String) ; else skip ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("9's complement is : " + (number)->sum() ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var number : String ; number := "345.45" ;
     execute complement(number) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.Closeable ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.PriorityQueue ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    final int n=sc.nextInt();
    final int m=sc.nextInt();
    if(n % 2!=0){
      final int fst=n/2+1 ;
      final int snd=n/2 ;
      for(int i=0 ; i<fst ; i++){
        System.out.print((i==0 ? "" : " ")+0);
      }
      for(int i=0 ; i<snd ; i++){
        System.out.print(" "+m);
      }
      System.out.println();
    }
    else {
      final int fst=n/2 ;
      for(int i=0 ; i<=fst ; i++){
        System.out.print((i==0 ? "" : " ")+0);
      }
      for(int i=0 ; i<fst-1 ; i++){
        System.out.print(" "+m);
      }
      System.out.println();
    }
  }
  public static class Scanner implements Closeable {
    private BufferedReader br ;
    private StringTokenizer tok ;
    public Scanner(InputStream is)throws IOException {
      br=new BufferedReader(new InputStreamReader(is));
    }
    private void getLine()throws IOException {
      while(! hasNext()){
        tok=new StringTokenizer(br.readLine());
      }
    }
    private boolean hasNext(){
      return tok!=null && tok.hasMoreTokens();
    }
    public String next()throws IOException {
      getLine();
      return tok.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public void close()throws IOException {
      br.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     if (n mod 2 /= 0) then (     var fst : int ; fst := n / 2 + 1 ;
     var snd : int ; snd := n / 2 ;
        var i : int ; i := 0 ; while i < fst do ( (     OclFile["System.out"].print((if i = 0 then "" else " " endif) + 0) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < snd do ( (     OclFile["System.out"].print(" " + m) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) else (     var fst : int ; fst := n / 2 ;
         var i : int ; i := 0 ; while i <= fst do ( (     OclFile["System.out"].print((if i = 0 then "" else " " endif) + 0) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < fst - 1 do ( (     OclFile["System.out"].print(" " + m) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) );
  static class Scanner implements Closeable {
   attribute br : OclFile;
   attribute tok : OclIterator;
   static operation newScanner( is : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) );
   operation getLine() : void
  pre: true
  post: true
  activity: (     while (not(hasNext())) do (     tok := OclIterator.newOclIterator_String(br.readLine()) ) );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return tok /= null & tok.hasNext() );
   operation next() : String
  pre: true
  post: true
  activity: (     execute getLine() ; 
     return tok.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    for(int t=in.nextInt(); t>0 ; t--){
      int a=in.nextInt();
      int b=in.nextInt();
      int res=Math.min((a+b)/4,Math.min(a,b));
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var t : int ; t := in.getCurrent()->toInteger() ; while t > 0 do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
     var res : int ; res := Set{(a + b) / 4, Set{a, b}->min()}->min() ;
     OclFile["System.out"].println(res) )  ;     t := t - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String line ;
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] ns=new int[n];
    if(n>2){
      for(int i=n/2+1 ; i<n ; i++){
        ns[i]=m ;
      }
    }
    System.out.print(ns[0]);
    for(int i=1 ; i<n ; i++){
      System.out.print(" "+ns[i]);
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : String ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var ns : Sequence(int) ; ns := Integer.subrange(1,n)->collect(0) ;
    if (n > 2) then (         var i : int ; i := n / 2 + 1 ; while i < n do ( (     ns[i+1] := m )  ;     i := i + 1 ) ) else skip ; 
    OclFile["System.out"].print(ns[0+1]) ; 
        var i : int ; i := 1 ; while i < n do ( (     OclFile["System.out"].print(" " + ns[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Prime {
  static boolean isprime(int x){
    for(int i=2 ; i*i<=x ; i++)if(x % i==0)return false ;
    return true ;
  }
  static boolean isSumOfKprimes(int N,int K){
    if(N<2*K)return false ;
    if(K==1)return isprime(N);
    if(K==2){
      if(N % 2==0)return true ;
      return isprime(N-2);
    }
    return true ;
  }
  public static void main(String[] args){
    int n=10,k=2 ;
    if(isSumOfKprimes(n,k))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class Prime {
  static   operation isprime( x : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= x do (     if (x mod i = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation isSumOfKprimes( N : int, K : int) : boolean
  pre: true
  post: true
  activity: (     if (N < 2 * K) then     return false else skip ; 
     if (K = 1) then     return isprime(N) else skip ; 
     if (K = 2) then (     if (N mod 2 = 0) then     return true else skip ; 
     return isprime(N - 2) ) else skip ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
    var k : int ; k := 2 ;
     if (isSumOfKprimes(n, k)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class D {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int T=sc.nextInt();
    for(int i=1 ; i<=T ; ++i){
      System.out.println("Case #"+i+": "+solve());
    }
  }
  static String solve(){
    int N=sc.nextInt();
    int L=sc.nextInt();
    String[] G=new String[N];
    for(int i=0 ; i<N ; ++i){
      G[i]=sc.next();
    }
    String B=sc.next();
    for(int i=0 ; i<N ; ++i){
      if(G[i] .equals(B)){
        return "IMPOSSIBLE" ;
      }
    }
    if(L==1){
      return "? 0" ;
    }
    char[] p1=new char[L-1];
    Arrays.fill(p1,'?');
    StringBuilder p2=new StringBuilder();
    for(int i=0 ; i<49 ; ++i){
      p2.append((char)('0'+i % 2));
    }
    p2.append('?');
    for(int i=0 ; i<49 ; ++i){
      p2.append((char)('0'+(i+1)% 2));
    }
    return String.valueOf(p1)+" "+p2.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= T do ( (     OclFile["System.out"].println("Case #" + i + ": " + solve()) )  ;     i := i + 1 ) );
  static   operation solve() : String
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var L : int ; L := sc.getCurrent()->toInteger() ;
    var G : Sequence(String) ; G := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     G[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    var B : String ; B := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < N do ( (     if (G[i+1] = B) then (     return "IMPOSSIBLE" ) else skip )  ;     i := i + 1 ) ; 
    if (L = 1) then (     return "? 0" ) else skip ; 
    var p1 : Sequence(String) ; p1 := Integer.subrange(1,L - 1)->collect(0) ;
    p1 := p1->collect('?') ; 
    var p2 : String ; p2 := StringLib.newString() ;
        var i : int ; i := 0 ; while i < 49 do ( (     p2 := p2 + StringLib.newString(('0' + i mod 2)->oclAsType(String)) )  ;     i := i + 1 ) ; 
    p2 := p2 + StringLib.newString('?') ; 
        var i : int ; i := 0 ; while i < 49 do ( (     p2 := p2 + StringLib.newString(('0' + (i + 1) mod 2)->oclAsType(String)) )  ;     i := i + 1 ) ; 
    return (p1)->sum()  + " " + p2+"" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static lib.Util.*;
public class D {
  static int ans ;
  public static void main(String...orange)throws Exception {
    Scanner input=new Scanner(System.in);
    int numCases=input.nextInt();
    for(int n=0 ; n<numCases ; n++){
      int N=input.nextInt();
      int L=input.nextInt();
      String[] Gs=new String[N];
      for(int i=0 ; i<N ; i++)Gs[i]=input.next();
      String B=input.next();
      boolean bad=false ;
      for(String G : Gs)if(G.equals(B))bad=true ;
      if(bad){
        System.out.printf("Case #%d: IMPOSSIBLE\n",n+1);
        continue ;
      }
      if(L==1){
        System.out.printf("Case #%d: 0 ?\n",n+1);
        continue ;
      }
      StringBuilder p1=new StringBuilder();
      StringBuilder p2=new StringBuilder();
      for(int i=0 ; i<L ; i++){
        if(i==L-1){
          if(i % 2==0)p2.append("?1");
          else p1.append("?1");
        }
        else if(i % 2==0){
          p1.append("10");
          p2.append("?");
        }
        else {
          p1.append("?");
          p2.append("10");
        }
      }
      System.out.printf("Case #%d: %s %s\n",n+1,p1,p2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   attribute ans : int;
  static   operation main( orange : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numCases : int ; numCases := input.getCurrent()->toInteger() ;
         var n : int ; n := 0 ; while n < numCases do ( (     var N : int ; N := input.getCurrent()->toInteger() ;
     var L : int ; L := input.getCurrent()->toInteger() ;
    var Gs : Sequence(String) ; Gs := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do (     Gs[i+1] := input.getCurrent() ;  ;     i := i + 1 ) ; 
    var B : String ; B := input.getCurrent() ;
    var bad : boolean ; bad := false ;
    for (G : Gs) do (     if (G = B) then     bad := true ; else skip ;  ) ; 
    if (bad) then (     OclFile["System.out"].printf("Case #%d: IMPOSSIBLE\n", n + 1) ; 
     continue ) else skip ; 
    if (L = 1) then (     OclFile["System.out"].printf("Case #%d: 0 ?\n", n + 1) ; 
     continue ) else skip ; 
    var p1 : String ; p1 := StringLib.newString() ;
    var p2 : String ; p2 := StringLib.newString() ;
        var i : int ; i := 0 ; while i < L do ( (     if (i = L - 1) then (     if (i mod 2 = 0) then     p2 := p2 + StringLib.newString("?1") ; else     p1 := p1 + StringLib.newString("?1") ; ) else     if (i mod 2 = 0) then (     p1 := p1 + StringLib.newString("10") ; 
     p2 := p2 + StringLib.newString("?") ) else (     p1 := p1 + StringLib.newString("?") ; 
     p2 := p2 + StringLib.newString("10") ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("Case #%d: %s %s\n", n + 1, p1, p2) ; 
 )  ;     n := n + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class D {
  String solveOne(Scanner in){
    int size=in.nextInt();
    int len=in.nextInt();
    String g[]=new String[size];
    for(int i=0 ; i<size ; i++){
      g[i]=in.next();
    }
    String bad=in.next();
    if(bad.contains("0")){
      throw new Error();
    }
    for(String s : g){
      if(! s.contains("0")){
        return "IMPOSSIBLE" ;
      }
    }
    String ans="0" ;
    for(int i=1 ; i<len ; i++){
      ans+="1" ;
    }
    ans+=" " ;
    for(int i=0 ; i<len ; i++){
      ans+="0?" ;
    }
    return ans ;
  }
  void solve(Scanner in,PrintWriter out){
    int nTests=in.nextInt();
    for(int iTest=1 ; iTest<=nTests ; iTest++){
      out.printf("Case #%d: %s%n",iTest,solveOne(in));
    }
  }
  void run(){
    try(Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
){
      solve(in,out);
    }
  }
  public static void main(String args[]){
    new D().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
   operation solveOne( in : OclFile) : String
  pre: true
  post: true
  activity: (     var size : int ; size := in.nextInt() ;
     var len : int ; len := in.nextInt() ;
    var g : Sequence(String) ; g := Integer.subrange(1,size)->collect(null) ;
        var i : int ; i := 0 ; while i < size do ( (     g[i+1] := in.next() )  ;     i := i + 1 ) ; 
    var bad : String ; bad := in.next() ;
    if (bad->includes("0")) then (     error SystemException() ) else skip ; 
    for (s : g) do ( (     if (not(s->includes("0"))) then (     return "IMPOSSIBLE" ) else skip )  ) ; 
    var ans : String ; ans := "0" ;
        var i : int ; i := 1 ; while i < len do ( (     ans := ans+("1") )  ;     i := i + 1 ) ; 
    ans := ans+(" ") ; 
        var i : int ; i := 0 ; while i < len do ( (     ans := ans+("0?") )  ;     i := i + 1 ) ; 
    return ans 
 );
   operation solve( in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var nTests : int ; nTests := in.nextInt() ;
         var iTest : int ; iTest := 1 ; while iTest <= nTests do ( (     out.printf("Case #%d: %s%n", iTest, solveOne(in)) )  ;     iTest := iTest + 1 ) );
   operation run() : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]) ;
 (     execute solve(in, out) ))  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     D.newD().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.math.BigDecimal ;
class Main {
  public static void main(String[] a){
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      double g=scan.nextDouble();
      double b=scan.nextDouble();
      double c=scan.nextDouble();
      double d=scan.nextDouble();
      double e=scan.nextDouble();
      double f=scan.nextDouble();
      double x=(c*e-b*f)/(g*e-b*d);
      double y=(c*d-g*f)/(b*d-g*e);
      BigDecimal bx=new BigDecimal(String.valueOf(x));
      BigDecimal by=new BigDecimal(String.valueOf(y));
      double outx=bx.setScale(3,BigDecimal.ROUND_HALF_UP).doubleValue();
      if(outx*10==(int)(outx*10))System.out.print(outx+"00 ");
      else if(outx*100==(int)(outx*100))System.out.print(outx+"0 ");
      else System.out.print(outx+" ");
      double outy=by.setScale(3,BigDecimal.ROUND_HALF_UP).doubleValue();
      if(outy*10==(int)(outy*10))System.out.print(outy+"00\n");
      else if(outy*100==(int)(outy*100))System.out.print(outy+"0\n");
      else System.out.print(outy+"\n");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var g : double ; g := scan.getCurrent()->toReal() ;
     var b : double ; b := scan.getCurrent()->toReal() ;
    var c : double ; c := scan.getCurrent()->toReal() ;
    var d : double ; d := scan.getCurrent()->toReal() ;
    var e : double ; e := scan.getCurrent()->toReal() ;
    var f : double ; f := scan.getCurrent()->toReal() ;
    var x : double ; x := (c * e - b * f) / (g * e - b * d) ;
    var y : double ; y := (c * d - g * f) / (b * d - g * e) ;
    var bx : double ; bx := double(((x) + "")) ;
    var by : double ; by := double(((y) + "")) ;
    var outx : double ; outx := bx.setScale(3, ROUND_HALF_UP)->oclAsType(double) ;
    if (outx * 10 = (outx * 10)->oclAsType(int)) then     OclFile["System.out"].print(outx + "00 ") else     if (outx * 100 = (outx * 100)->oclAsType(int)) then     OclFile["System.out"].print(outx + "0 ") else     OclFile["System.out"].print(outx + " ") ; ;  ;  
    var outy : double ; outy := by.setScale(3, ROUND_HALF_UP)->oclAsType(double) ;
    if (outy * 10 = (outy * 10)->oclAsType(int)) then     OclFile["System.out"].print(outy + "00\n") else     if (outy * 100 = (outy * 100)->oclAsType(int)) then     OclFile["System.out"].print(outy + "0\n") else     OclFile["System.out"].print(outy + "\n") ; ;  ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.PrintWriter ;
import java.io.StreamTokenizer ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Go implements Runnable {
  private static final String NAME="go" ;
  private StreamTokenizer in ;
  int nextInt()throws Exception {
    in.nextToken();
    return(int)in.nval ;
  }
  long nextLong()throws Exception {
    in.nextToken();
    return(long)in.nval ;
  }
  @ Override public void run(){
    try {
      Scanner in=new Scanner(new File(NAME+".in"));
      PrintWriter out=new PrintWriter(NAME+".out");
      int tests=in.nextInt();
      for(int test=1 ; test<=tests ; test++){
        int n=in.nextInt();
        int l=in.nextInt();
        Set<String>s=new HashSet<String>();
        for(int i=0 ; i<n ; i++){
          s.add(in.next());
        }
        String b=in.next();
        if(b.contains("0")){
          throw new IllegalStateException();
        }
        if(s.contains(b)){
          out.println("Case #"+test+": IMPOSSIBLE");
        }
        else {
          String r1="" ;
          String r2="" ;
          for(int i=0 ; i<l ; i++){
            r1+="0?" ;
          }
          r2+="0" ;
          for(int i=0 ; i<l-1 ; i++){
            r2+="01" ;
          }
          r2+="0" ;
          out.println("Case #"+test+": "+r1+" "+r2);
        }
      }
      out.close();
    }
    catch(Exception e){
      throw new RuntimeException(e);
    }
  }
  public static void main(String[] args){
    new Thread(new Go()).start();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Go implements Runnable {
  static    attribute NAME : String := "go";
   attribute in : StreamTokenizer;
   operation nextInt() : int
  pre: true
  post: true
  activity: (     in.next() ; 
     return in.nval->oclAsType(int) );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     in.next() ; 
     return in.nval->oclAsType(long) );
      operation run() : void
  pre: true
  post: true
  activity: (     try (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile(NAME + ".in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(NAME + ".out") ;
    var tests : int ; tests := in.getCurrent()->toInteger() ;
        var test : int ; test := 1 ; while test <= tests do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var l : int ; l := in.getCurrent()->toInteger() ;
    var s : Set(String) ; s := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     s := s->including(in.getCurrent()) )  ;     i := i + 1 ) ; 
    var b : String ; b := in.getCurrent() ;
    if (b->includes("0")) then (     error IncorrectElementException() ) else skip ; 
    if (s->includes(b)) then (     skip ) else (     var r1 : String ; r1 := "" ;
     var r2 : String ; r2 := "" ;
        var i : int ; i := 0 ; while i < l do ( (     r1 := r1+("0?") )  ;     i := i + 1 ) ; 
    r2 := r2+("0") ; 
        var i : int ; i := 0 ; while i < l - 1 do ( (     r2 := r2+("01") )  ;     i := i + 1 ) ; 
    r2 := r2+("0") ; 
    skip ; 
 ) ;  
 )  ;     test := test + 1 ) ; 
    skip ; 
 )   catch (e : ProgramException) do (     error ProgramException(e) )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(Go.newGo()).start() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintStream ;
import java.util.Arrays ;
import java.util.Scanner ;
public class GoPlusPlus {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner cin=new Scanner(new File("D-small-attempt0.in"));
    PrintStream cout=new PrintStream("D-small-attempt0.out");
    int _case=0 ;
    for(int T=cin.nextInt(); T>0 ; T--){
      _case++;
      StringBuilder ans=new StringBuilder();
      int N=cin.nextInt();
      int L=cin.nextInt();
      String[] a=new String[N];
      boolean impossible=false ;
      for(int i=0 ; i<N ; i++)a[i]=cin.next();
      String shit=cin.next();
      for(String each : a)if(each.equals(shit))impossible=true ;
      if(impossible)ans.append("IMPOSSIBLE");
      else {
        String one="0" ;
        for(int i=0 ; i<L-1 ; i++)one+="1" ;
        String two="" ;
        for(int i=0 ; i<L ; i++)two+="0?" ;
        ans.append(one);
        ans.append(" ");
        ans.append(two);
      }
      cout.printf("Case #%d: %s%n",_case,ans.toString());
    }
    cin.close();
    cout.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class GoPlusPlus {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile("D-small-attempt0.in")) ;
     var cout : OclFile ; cout := OclFile.newOclFile_Write(OclFile.newOclFile("D-small-attempt0.out")) ;
    var _case : int ; _case := 0 ;
        var T : int ; T := cin.getCurrent()->toInteger() ; while T > 0 do ( (     _case := _case + 1 ; 
     var ans : String ; ans := StringLib.newString() ;
    var N : int ; N := cin.getCurrent()->toInteger() ;
    var L : int ; L := cin.getCurrent()->toInteger() ;
    var a : Sequence(String) ; a := Integer.subrange(1,N)->collect(null) ;
    var impossible : boolean ; impossible := false ;
        var i : int ; i := 0 ; while i < N do (     a[i+1] := cin.getCurrent() ;  ;     i := i + 1 ) ; 
    var shit : String ; shit := cin.getCurrent() ;
    for (each : a) do (     if (each = shit) then     impossible := true ; else skip ;  ) ; 
    if (impossible) then     ans := ans + StringLib.newString("IMPOSSIBLE") else (     var one : String ; one := "0" ;
         var i : int ; i := 0 ; while i < L - 1 do (     one := one+("1") ;  ;     i := i + 1 ) ; 
    var two : String ; two := "" ;
        var i : int ; i := 0 ; while i < L do (     two := two+("0?") ;  ;     i := i + 1 ) ; 
    ans := ans + StringLib.newString(one) ; 
    ans := ans + StringLib.newString(" ") ; 
    ans := ans + StringLib.newString(two) ; 
 ) ;  
    skip ; 
 )  ;     T := T - 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static boolean check_elements(int arr[],int n,int A,int B){
    int range=B-A ;
    for(int i=0 ; i<n ; i++){
      if(Math.abs(arr[i])>=A && Math.abs(arr[i])<=B){
        int z=Math.abs(arr[i])-A ;
        if(arr[z]>0){
          arr[z]=arr[z]*-1 ;
        }
      }
    }
    int count=0 ;
    for(int i=0 ; i<=range && i<n ; i++){
      if(arr[i]>0)return false ;
      else count++;
    }
    if(count!=(range+1))return false ;
    return true ;
  }
  public static void main(String[] args){
    int arr[]={
      1,4,5,2,7,8,3 };
      int n=arr.length ;
      int A=2,B=5 ;
      if(check_elements(arr,n,A,B))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check_elements( arr : Sequence(int), n : int, A : int, B : int) : boolean
  pre: true
  post: true
  activity: (     var range : int ; range := B - A ;
         var i : int ; i := 0 ; while i < n do ( (     if (if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif >= A & if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif <= B) then (     var z : int ; z := if arr[i+1] < 0 then -(arr[i+1]) else arr[i+1] endif - A ;
     if (arr[z+1] > 0) then (     arr[z+1] := arr[z+1] * -1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i <= range & i < n do ( (     if (arr[i+1] > 0) then     return false else     count := count + 1 ; )  ;     i := i + 1 ) ; 
    if (count /= (range + 1)) then     return false else skip ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,4,5,2,7,8,3} ;
     var n : int ; n := arr->size() ;
     var A : int ; A := 2 ;
    var B : int ; B := 5 ;
     if (check_elements(arr, n, A, B)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findPowerPrime(int fact,int p){
    int res=0 ;
    while(fact>0){
      res+=fact/p ;
      fact/=p ;
    }
    return res ;
  }
  static int findPowerComposite(int fact,int n){
    int res=Integer.MAX_VALUE ;
    for(int i=2 ; i<=Math.sqrt(n); i++){
      int count=0 ;
      if(n % i==0){
        count++;
        n=n/i ;
      }
      if(count>0){
        int curr_pow=findPowerPrime(fact,i)/count ;
        res=Math.min(res,curr_pow);
      }
    }
    if(n>=2){
      int curr_pow=findPowerPrime(fact,n);
      res=Math.min(res,curr_pow);
    }
    return res ;
  }
  public static void main(String[] args){
    int fact=146,n=5 ;
    System.out.println(findPowerComposite(fact,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findPowerPrime( fact : int, p : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     while (fact > 0) do (     res := res+(fact / p) ; 
     fact := fact/(p) ) ; 
     return res );
  static   operation findPowerComposite( fact : int, n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 2147483647 ;
         var i : int ; i := 2 ; while i <= (n)->sqrt() do ( (     var count : int ; count := 0 ;
     if (n mod i = 0) then (     count := count + 1 ; 
     n := n / i ) else skip ; 
     if (count > 0) then (     var curr_pow : int ; curr_pow := findPowerPrime(fact, i) / count ;
     res := Set{res, curr_pow}->min() ) else skip )  ;     i := i + 1 ) ; 
     if (n >= 2) then (     var curr_pow : int ; curr_pow := findPowerPrime(fact, n) ;
     res := Set{res, curr_pow}->min() ) else skip ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fact : int ; fact := 146 ;
    var n : int ; n := 5 ;
     OclFile["System.out"].println(findPowerComposite(fact, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class ques {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int[] arr=new int[2];
      arr[0]=sc.nextInt();
      arr[1]=sc.nextInt();
      int div=(arr[0]+arr[1])/4 ;
      int ans=div ;
      int min=arr[0];
      if(arr[1]<min){
        min=arr[1];
      }
      if(min<div){
        ans=min ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ques {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var arr : Sequence(int) ; arr := Integer.subrange(1,2)->collect(0) ;
     arr[0+1] := sc.getCurrent()->toInteger() ; 
    arr[1+1] := sc.getCurrent()->toInteger() ; 
    var div : int ; div := (arr[0+1] + arr[1+1]) / 4 ;
    var ans : int ; ans := div ;
    var min : int ; min := arr[0+1] ;
    if (arr[1+1] < min) then (     min := arr[1+1] ) else skip ; 
    if (min < div) then (     ans := min ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CodeForces1408B {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=input.nextInt();
      int k=input.nextInt();
      Set<Integer>set=new HashSet<>();
      for(int j=0 ; j<n ; j++){
        set.add(input.nextInt());
      }
      if(k==1){
        if(set.size()>1){
          System.out.println(-1);
        }
        else {
          System.out.println(1);
        }
      }
      else {
        if(set.size()>1){
          System.out.println(1+(set.size()-2)/(k-1));
        }
        else {
          System.out.println(1);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces1408B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var k : int ; k := input.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
        var j : int ; j := 0 ; while j < n do ( (     set := set->including(input.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
    if (k = 1) then (     if (set->size() > 1) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(1) ) ) else (     if (set->size() > 1) then (     OclFile["System.out"].println(1 + (set->size() - 2) / (k - 1)) ) else (     OclFile["System.out"].println(1) ) ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static void printUnique(int l,int r){
    for(int i=l ; i<=r ; i++){
      int num=i ;
      boolean visited[]=new boolean[10];
      while(num!=0){
        if(visited[num % 10])break ;
        visited[num % 10]=true ;
        num=num/10 ;
      }
      if(num==0)System.out.print(i+" ");
    }
  }
  public static void main(String args[]){
    int l=1,r=20 ;
    printUnique(l,r);
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation printUnique( l : int, r : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := l ; while i <= r do ( (     var num : int ; num := i ;
     var visited : Sequence(boolean) ; visited := Integer.subrange(1,10)->collect(false) ;
     while (num /= 0) do (     if (visited[num mod 10+1]) then     break else skip ; 
     visited[num mod 10+1] := true ; 
     num := num / 10 ) ; 
     if (num = 0) then     OclFile["System.out"].print(i + " ") ; else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 1 ;
    var r : int ; r := 20 ;
     execute printUnique(l, r) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printTrib(int n){
    if(n<1)return ;
    int first=0,second=0 ;
    int third=1 ;
    System.out.print(first+" ");
    if(n>1)System.out.print(second+" ");
    if(n>2)System.out.print(second+" ");
    for(int i=3 ; i<n ; i++){
      int curr=first+second+third ;
      first=second ;
      second=third ;
      third=curr ;
      System.out.print(curr+" ");
    }
  }
  public static void main(String args[]){
    int n=10 ;
    printTrib(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printTrib( n : int) : void
  pre: true
  post: true
  activity: (     if (n < 1) then     return else skip ; 
     var first : int ; first := 0 ;
    var second : int ; second := 0 ;
    var third : int ; third := 1 ;
    OclFile["System.out"].print(first + " ") ; 
    if (n > 1) then     OclFile["System.out"].print(second + " ") ; else skip ; 
    if (n > 2) then     OclFile["System.out"].print(second + " ") ; else skip ; 
        var i : int ; i := 3 ; while i < n do ( (     var curr : int ; curr := first + second + third ;
     first := second ; 
    second := third ; 
    third := curr ; 
    OclFile["System.out"].print(curr + " ") ; 
 )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     execute printTrib(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static boolean isDivisible(int num,int x,int y){
    while(num % x==0 || num % y==0){
      if(num % x==0)num/=x ;
      if(num % y==0)num/=y ;
    }
    if(num>1)return false ;
    return true ;
  }
  public static int _gcd(int a,int b){
    while(a!=b){
      if(a>b)a=a-b ;
      else b=b-a ;
    }
    return a ;
  }
  public static boolean isPossible(int[] arr,int n,int x,int y){
    int gcd=arr[0];
    for(int i=1 ; i<n ; i++)gcd=_gcd(gcd,arr[i]);
    for(int i=0 ; i<n ; i++){
      if(! isDivisible(arr[i]/gcd,x,y))return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    int[] arr={
      2,4,6,8 };
      int n=arr.length ;
      int x=2,y=3 ;
      if(isPossible(arr,n,x,y))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isDivisible( num : int, x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     while (num mod x = 0 or num mod y = 0) do (     if (num mod x = 0) then     num := num/(x) ; else skip ; 
     if (num mod y = 0) then     num := num/(y) ; else skip ) ; 
     if (num > 1) then     return false else skip ; 
     return true );
  static   operation _gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     while (a /= b) do (     if (a > b) then     a := a - b ; else     b := b - a ; ) ; 
     return a );
  static   operation isPossible( arr : Sequence(int), n : int, x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     var gcd : int ; gcd := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do (     gcd := _gcd(gcd, arr[i+1]) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (not(isDivisible(arr[i+1] / gcd, x, y))) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,6,8} ;
     var n : int ; n := arr->size() ;
     var x : int ; x := 2 ;
    var y : int ; y := 3 ;
     if (isPossible(arr, n, x, y)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long power(long a,long n){
    if(n==0)return 1 ;
    long p=power(a,n/2);
    p=p*p ;
    if(n % 2==1)p=p*a ;
    return p ;
  }
  static int countIntegers(long l,long r){
    long ans=0,i=1 ;
    long v=power(2,i);
    while(v<=r){
      while(v<=r){
        if(v>=l)ans++;
        v=v*3 ;
      }
      i++;
      v=power(2,i);
    }
    if(l==1)ans++;
    return(int)ans ;
  }
  public static void main(String[] args){
    long l=12,r=21 ;
    System.out.println(countIntegers(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation power( a : long, n : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     var p : long ; p := power(a, n / 2) ;
    p := p * p ; 
    if (n mod 2 = 1) then     p := p * a ; else skip ; 
    return p 
 );
  static   operation countIntegers( l : long, r : long) : int
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
    var i : long ; i := 1 ;
     var v : long ; v := power(2, i) ;
    while (v <= r) do (     while (v <= r) do (     if (v >= l) then     ans := ans + 1 ; else skip ; 
     v := v * 3 ) ; 
     i := i + 1 ; 
     v := power(2, i) ) ; 
    if (l = 1) then     ans := ans + 1 ; else skip ; 
    return ans->oclAsType(int) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : long ; l := 12 ;
    var r : long ; r := 21 ;
     OclFile["System.out"].println(countIntegers(l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int N=3 ;
  static int maxPathSum(int tri[][]){
    int ans=0 ;
    for(int i=N-2 ; i>=0 ; i--){
      for(int j=0 ; j<N-i ; j++){
        if(j-1>=0)tri[i][j]+=Math.max(tri[i+1][j],tri[i+1][j-1]);
        else tri[i][j]+=tri[i+1][j];
        ans=Math.max(ans,tri[i][j]);
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int tri[][]={
      {
        1,5,3 },{
          4,8,0 },{
            1,0,0 }
          };
          System.out.println(maxPathSum(tri));
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 3;
  static   operation maxPathSum( tri : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := N - 2 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < N - i do ( (     if (j - 1 >= 0) then     tri[i+1][j+1] := tri[i+1][j+1]+(Set{tri[i + 1+1][j+1], tri[i + 1+1][j - 1+1]}->max()) else     tri[i+1][j+1] := tri[i+1][j+1]+(tri[i + 1+1][j+1]) ; ;  
     ans := Set{ans, tri[i+1][j+1]}->max() )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var tri : Sequence(Sequence(int)) ; tri := Sequence{Sequence{1,5,3},Sequence{4,8,0},Sequence{1,0,0}} ;
     OclFile["System.out"].println(maxPathSum(tri)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  void run(){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String inputString ;
    try {
      while((inputString=br.readLine())!=null){
        if(inputString.length()==0)break ;
        String[] s=inputString.split(" ");
        double[] inputs=new double[6];
        for(int i=0 ; i<6 ; i++)inputs[i]=Double.parseDouble(s[i]);
        double[][] matrix={
          {
            inputs[0],inputs[1] },{
              inputs[3],inputs[4] }
            };
            double[] vector={
              inputs[2],inputs[5] };
              double det=matrix[0][0]*matrix[1][1]-matrix[0][1]*matrix[1][0];
              double[][] inverse={
                {
                  matrix[1][1]/det,-1*matrix[0][1]/det },{
-1*matrix[1][0]/det,matrix[0][0]/det }
                  };
                  double[] solution={
                    inverse[0][0]*vector[0]+inverse[0][1]*vector[1],inverse[1][0]*vector[0]+inverse[1][1]*vector[1] };
                    System.out.printf("%1.3f %1.3f\n",solution[0]+0.00005,solution[1]+0.00005);
                  }
                }
                catch(IOException e){
                  e.printStackTrace();
                }
              }
              public static void main(String args[]){
                new Main().run();
              }
              private double[] stringsToDoubles(String[] s){
                double[] results=new double[6];
                for(int i=0 ; i<6 ; i++)results[i]=Double.parseDouble(s[i]);
                return results ;
              }
            }

------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var inputString : String ;
     try (         inputString := br.readLine() ;
    while ((inputString) /= null) do (    skip ; (     if (inputString->size() = 0) then     break else skip ; 
     var s : Sequence(String) ; s := inputString->split(" ") ;
    var inputs : Sequence(double) ; inputs := Integer.subrange(1,6)->collect(0.0) ;
        var i : int ; i := 0 ; while i < 6 do (     inputs[i+1] := (s[i+1])->toReal() ;  ;     i := i + 1 ) ; 
    var matrix : Sequence(Sequence(double)) ; matrix := Sequence{Sequence{inputs[0+1],inputs[1+1]},Sequence{inputs[3+1],inputs[4+1]}} ;
    var vector : Sequence(double) ; vector := Sequence{inputs[2+1],inputs[5+1]} ;
    var det : double ; det := matrix[0+1][0+1] * matrix[1+1][1+1] - matrix[0+1][1+1] * matrix[1+1][0+1] ;
    var inverse : Sequence(Sequence(double)) ; inverse := Sequence{Sequence{matrix[1+1][1+1] / det,-1 * matrix[0+1][1+1] / det},Sequence{-1 * matrix[1+1][0+1] / det,matrix[0+1][0+1] / det}} ;
    var solution : Sequence(double) ; solution := Sequence{inverse[0+1][0+1] * vector[0+1] + inverse[0+1][1+1] * vector[1+1],inverse[1+1][0+1] * vector[0+1] + inverse[1+1][1+1] * vector[1+1]} ;
    OclFile["System.out"].printf("%1.3f %1.3f\n", solution[0+1] + 0.00005, solution[1+1] + 0.00005) ; 
 ) ;     inputString := br.readLine() ;
 ) )   catch (e : IOException) do (     e.printStackTrace() )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation stringsToDoubles( s : Sequence(String)) : Sequence(double)
  pre: true
  post: true
  activity: (     var results : Sequence(double) ; results := Integer.subrange(1,6)->collect(0.0) ;
         var i : int ; i := 0 ; while i < 6 do (     results[i+1] := (s[i+1])->toReal() ;  ;     i := i + 1 ) ; 
     return results );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    Queue<Integer>q=new PriorityQueue<>(Collections.reverseOrder());
    for(int i=0 ; i<N ; i++){
      q.add(sc.nextInt());
    }
    while(M!=0){
      q.add(q.poll()/2);
      M--;
    }
    long answer=0 ;
    for(int item : q){
      answer+=item ;
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var q : Sequence(int) ; q := Sequence{}->union(reverseOrder()) ;
        var i : int ; i := 0 ; while i < N do ( (     q := q->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    while (M /= 0) do (     q := q->including(q->min() / 2) ; 
     M := M - 1 ) ; 
    var answer : long ; answer := 0 ;
    for (item : q) do ( (     answer := answer+(item) )  ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
@ SuppressWarnings("unchecked")public class Main {
  public static String joinInt(int[] a,String separator){
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<a.length ; i++){
      if(i>0){
        sb.append(separator);
      }
      sb.append(a[i]);
    }
    return sb.toString();
  }
  static int[] nextIntArray(Scanner sc,int N){
    int[] arr=new int[N];
    for(int i=0 ; i<N ; i++){
      arr[i]=sc.nextInt();
    }
    return arr ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    long sum=0 ;
    PriorityQueue<Integer>q=new PriorityQueue<>();
    for(int i=0 ; i<N ; i++){
      int A=sc.nextInt();
      q.add(-A);
      sum+=A ;
    }
    for(int i=0 ; i<M ; i++){
      int A=-q.poll();
      int A2=A/2 ;
      sum-=(A-A2);
      q.add(-A2);
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation joinInt( a : Sequence(int), separator : String) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < a->size() do ( (     if (i > 0) then (     sb := sb + StringLib.newString(separator) ) else skip ; 
     sb := sb + StringLib.newString(a[i+1]) )  ;     i := i + 1 ) ; 
     return sb+"" );
  static   operation nextIntArray( sc : OclFile, N : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
         var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
     return arr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var sum : long ; sum := 0 ;
    var q : Sequence(int) ; q := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var A : int ; A := sc.getCurrent()->toInteger() ;
     q := q->including(-A) ; 
     sum := sum+(A) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var A : int ; A := -q->min() ;
     var A2 : int ; A2 := A / 2 ;
     sum := sum-((A - A2)) ; 
     q := q->including(-A2) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Comparator ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
class DiscountedItem {
  final long original ;
  int count ;
  DiscountedItem(long value){
    this.original=value ;
  }
  double actualPayment(){
    return original/Math.pow(2,count);
  }
  long actualPaymentExact(){
    return new BigDecimal(original).divideToIntegralValue(new BigDecimal(2).pow(count)).longValueExact();
  }
}
class Solver {
  void solve(Scanner sc){
    int N=sc.nextInt();
    int M=sc.nextInt();
    PriorityQueue<DiscountedItem>A=new PriorityQueue<>(Comparator.comparingDouble(DiscountedItem :: actualPayment).reversed());
    for(int i=0 ; i<N ; i++){
      A.add(new DiscountedItem(sc.nextLong()));
    }
    for(int i=0 ; i<M ; i++){
      DiscountedItem peek=A.remove();
      peek.count++;
      A.add(peek);
    }
    System.out.println(A.stream().mapToLong(DiscountedItem :: actualPaymentExact).sum());
  }
}
class Main {
  public static void main(String...args){
    Scanner in=new Scanner(System.in);
    new Solver().solve(in);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class DiscountedItem {
   attribute original : long;
   attribute count : int;
   static operation newDiscountedItem( value : long) : DiscountedItem
  pre: true
  post: true
  activity:
  ( var self : DiscountedItem ;
    self := createDiscountedItem();
    self.initialise(value);
    return self );
  operation initialise( value : long) : void
  pre: true  post: true
  activity: (     self.original := value );
   operation actualPayment() : double
  pre: true
  post: true
  activity: (     return original / 2->pow(count) );
   operation actualPaymentExact() : long
  pre: true
  post: true
  activity: (     return double(original).divideToIntegralValue(double(2).pow(count)).longValueExact() );
}
class Solver {
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.nextInt() ;
     var M : int ; M := sc.nextInt() ;
    var A : Sequence(DiscountedItem) ; A := Sequence{}->union(Comparator.comparingDouble(lambda _pars : OclAny in DiscountedItem.newDiscountedItem().actualPayment(_pars)).reversed()) ;
        var i : int ; i := 0 ; while i < N do ( (     A := A->including(DiscountedItem.newDiscountedItem(sc.nextLong())) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var peek : DiscountedItem ; peek := A.remove() ;
     peek.count := peek.count + 1 ; 
     A := A->including(peek) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(A->collect( _x1 | (lambda _pars : OclAny in DiscountedItem.newDiscountedItem().actualPaymentExact(_pars))->apply(_x1) )->sum()) ; 
 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Solver.newSolver().solve(in) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class team {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    while(t-->0){
      int a=scan.nextInt();
      int b=scan.nextInt();
      int totalPPL=a+b ;
      System.out.println(Math.min(Math.min(a,b),totalPPL/4));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class team {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := scan.getCurrent()->toInteger() ;
     var b : int ; b := scan.getCurrent()->toInteger() ;
     var totalPPL : int ; totalPPL := a + b ;
     OclFile["System.out"].println(Set{Set{a, b}->min(), totalPPL / 4}->min()) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    int n=sc.nextInt();
    int m=sc.nextInt();
    PriorityQueue<Integer>queue=new PriorityQueue<>(Comparator.reverseOrder());
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      queue.add(a);
    }
    int cnt=0 ;
    while(cnt<m){
      queue.add(queue.poll()/2);
      cnt++;
    }
    long ans=0 ;
    for(int i : queue){
      ans+=i ;
    }
    System.out.println(ans);
  }
  static class MyScanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),1<<15);
    StringTokenizer tokenizer ;
    String next(){
      try {
        while(tokenizer==null || ! tokenizer.hasMoreTokens()){
          tokenizer=new StringTokenizer(reader.readLine());
        }
      }
      catch(IOException ignored){
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var n : int ; n := sc.nextInt() ;
    var m : int ; m := sc.nextInt() ;
    var queue : Sequence(int) ; queue := Sequence{}->union(Comparator.reverseOrder()) ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.nextInt() ;
     queue := queue->including(a) )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    while (cnt < m) do (     queue := queue->including(queue->min() / 2) ; 
     cnt := cnt + 1 ) ; 
    var ans : long ; ans := 0 ;
    for (i : queue) do ( (     ans := ans+(i) )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class MyScanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (1*(2->pow(15)))->oclAsType(long));
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (ignored : IOException) do skip
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    while(input.hasNext()){
      int N=input.nextInt();
      int M=input.nextInt();
      PriorityQueue<Integer>pq=new PriorityQueue<Integer>(Collections.reverseOrder());
      for(int i=0 ; i<N ; ++i){
        pq.add(input.nextInt());
      }
      while(M-->0){
        int a=pq.poll();
        pq.add(a>>1);
      }
      long cost=0 ;
      while(pq.isEmpty()==false){
        cost+=pq.poll();
      }
      System.out.println(cost);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (input.hasNext()) do (     var N : int ; N := input.getCurrent()->toInteger() ;
     var M : int ; M := input.getCurrent()->toInteger() ;
    var pq : Sequence(int) ; pq := Sequence{}->union(reverseOrder()) ;
        var i : int ; i := 0 ; while i < N do ( (     pq := pq->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        while (M > 0) do (        M := M - 1 ;     skip ; (     var a : int ; a := pq->min() ;
     pq := pq->including((a/(2->pow(1)))->oclAsType(long)) ) ;  ) ;  
    var cost : long ; cost := 0 ;
    while (pq->isEmpty() = false) do (     cost := cost + pq->min() ;     pq := pq->sort()->tail() ) ; 
    OclFile["System.out"].println(cost) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double nthRoot(int A,int N){
    double xPre=Math.random()*10 % 10 ;
    double eps=1e-3 ;
    double delX=Integer.MAX_VALUE ;
    double xK=0 ;
    while(delX>eps){
      xK=((N-1.0)*xPre+(double)A/Math.pow(xPre,N-1))/(double)N ;
      delX=Math.abs(xK-xPre);
      xPre=xK ;
    }
    return xK ;
  }
  static int countPowers(int a,int b,int k){
    return(int)(Math.floor(nthRoot(b,k))-Math.ceil(nthRoot(a,k))+1);
  }
  public static void main(String[] args){
    int a=7,b=28,k=2 ;
    System.out.print("Count of Powers is "+countPowers(a,b,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nthRoot( A : int, N : int) : double
  pre: true
  post: true
  activity: (     var xPre : double ; xPre := MathLib.random() * 10 mod 10 ;
     var eps : double ; eps := 1e-3 ;
    var delX : double ; delX := 2147483647 ;
    var xK : double ; xK := 0 ;
    while (delX > eps) do (     xK := ((N - 1.0) * xPre + A->oclAsType(double) / xPre->pow(N - 1)) / N->oclAsType(double) ; 
     delX := if xK - xPre < 0 then -(xK - xPre) else xK - xPre endif ; 
     xPre := xK ) ; 
    return xK 
 );
  static   operation countPowers( a : int, b : int, k : int) : int
  pre: true
  post: true
  activity: (     return ((nthRoot(b, k))->floor() - (nthRoot(a, k))->ceil() + 1)->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 7 ;
    var b : int ; b := 28 ;
    var k : int ; k := 2 ;
     OclFile["System.out"].print("Count of Powers is " + countPowers(a, b, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int checkSparse(int n){
    if((n &(n>>1))>=1)return 0 ;
    return 1 ;
  }
  public static void main(String[] args){
    System.out.println(checkSparse(72));
    System.out.println(checkSparse(12));
    System.out.println(checkSparse(2));
    System.out.println(checkSparse(3));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkSparse( n : int) : int
  pre: true
  post: true
  activity: (     if ((n & ((n/(2->pow(1)))->oclAsType(long))) >= 1) then     return 0 else skip ; 
     return 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(checkSparse(72)) ; 
     OclFile["System.out"].println(checkSparse(12)) ; 
     OclFile["System.out"].println(checkSparse(2)) ; 
     OclFile["System.out"].println(checkSparse(3)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int minRadius(int k,int[] x,int[] y,int n){
    int[] dis=new int[n];
    for(int i=0 ; i<n ; i++)dis[i]=x[i]*x[i]+y[i]*y[i];
    Arrays.sort(dis);
    return dis[k-1];
  }
  public static void main(String[] args){
    int k=3 ;
    int[] x={
      1,-1,1 };
      int[] y={
        1,-1,-1 };
        int n=x.length ;
        System.out.println(minRadius(k,x,y,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minRadius( k : int, x : Sequence(int), y : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var dis : Sequence(int) ; dis := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     dis[i+1] := x[i+1] * x[i+1] + y[i+1] * y[i+1] ;  ;     i := i + 1 ) ; 
     dis := dis->sort() ; 
     return dis[k - 1+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 3 ;
     var x : Sequence(int) ; x := Sequence{1,-1,1} ;
    var y : Sequence(int) ; y := Sequence{1,-1,-1} ;
    var n : int ; n := x->size() ;
    OclFile["System.out"].println(minRadius(k, x, y, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class LittlePonyAndCrystalMine {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int level=1 ;
    while(level<n){
      printLine(n,level);
      level+=2 ;
    }
    while(level>=1){
      printLine(n,level);
      level-=2 ;
    }
  }
  public static void printLine(int n,int level){
    int stars=(n-level)/2 ;
    for(int i=0 ; i<stars ; i++)System.out.print("*");
    for(int i=0 ; i<level ; i++)System.out.print("D");
    for(int i=0 ; i<stars ; i++)System.out.print("*");
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class LittlePonyAndCrystalMine {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var level : int ; level := 1 ;
    while (level < n) do (     execute printLine(n, level) ; 
     level := level+(2) ) ; 
    while (level >= 1) do (     execute printLine(n, level) ; 
     level := level-(2) ) ; 
 );
  static   operation printLine( n : int, level : int) : void
  pre: true
  post: true
  activity: (     var stars : int ; stars := (n - level) / 2 ;
         var i : int ; i := 0 ; while i < stars do (     OclFile["System.out"].print("*") ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < level do (     OclFile["System.out"].print("D") ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < stars do (     OclFile["System.out"].print("*") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication51 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    int counter=1 ;
    int count=0 ;
    for(int i=0 ; i<num ; i++){
      for(int j=0 ; j<(num-counter)/2 ; j++){
        System.out.print("*");
      }
      for(int n=0 ; n<counter ; n++){
        System.out.print("D");
        if(counter==num){
          count++;
        }
      }
      for(int k=0 ; k<(num-counter)/2 ; k++){
        System.out.print("*");
      }
      System.out.println("");
      if(counter<num && count==0){
        counter+=2 ;
      }
      else {
        counter-=2 ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication51 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
    var counter : int ; counter := 1 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < num do ( (         var j : int ; j := 0 ; while j < (num - counter) / 2 do ( (     OclFile["System.out"].print("*") )  ;     j := j + 1 ) ; 
         var n : int ; n := 0 ; while n < counter do ( (     OclFile["System.out"].print("D") ; 
     if (counter = num) then (     count := count + 1 ) else skip )  ;     n := n + 1 ) ; 
        var k : int ; k := 0 ; while k < (num - counter) / 2 do ( (     OclFile["System.out"].print("*") )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println("") ; 
    if (counter < num & count = 0) then (     counter := counter+(2) ) else (     counter := counter-(2) ) ;  
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.NoSuchElementException ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static ArrayList<Double>answerX=new ArrayList<Double>();
  static ArrayList<Double>answerY=new ArrayList<Double>();
  public static void main(String[] args){
    try {
      setAnswerFromInputs();
    }
    catch(NoSuchElementException e){
    }
    for(int i=0 ; i<answerX.size(); i++){
      System.out.printf("%.3f %.3f\n",answerX.get(i),answerY.get(i));
    }
  }
  private static void setAnswerFromInputs()throws NoSuchElementException {
    while(true){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int d=sc.nextInt();
      int e=sc.nextInt();
      int f=sc.nextInt();
      double x=getX(a,b,c,d,e,f);
      double y=getY(a,b,c,d,e,f);
      x=fixIncorrectNumber(x);
      y=fixIncorrectNumber(y);
      answerX.add(x);
      answerY.add(y);
    }
  }
  private static double getX(int a,int b,int c,int d,int e,int f){
    int denominator=a*e-b*d ;
    int numerator=c*e-b*f ;
    return(double)numerator/(double)denominator ;
  }
  private static double getY(int a,int b,int c,int d,int e,int f){
    int denominator=b*d-a*e ;
    int numerator=c*d-a*f ;
    return(double)numerator/(double)denominator ;
  }
  private static double fixIncorrectNumber(double x){
    if(x==(-0.0)){
      x=0.0 ;
    }
    return x ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute answerX : Sequence(double) := Sequence{};
  static   attribute answerY : Sequence(double) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     execute setAnswerFromInputs() )   catch (e : IncorrectElementException) do skip
         var i : int ; i := 0 ; while i < answerX->size() do ( (     OclFile["System.out"].printf("%.3f %.3f\n", answerX->at(i+1), answerY->at(i+1)) )  ;     i := i + 1 ) );
  static   operation setAnswerFromInputs() : void
  pre: true
  post: true
  activity: (     while (true) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var e : int ; e := sc.getCurrent()->toInteger() ;
    var f : int ; f := sc.getCurrent()->toInteger() ;
    var x : double ; x := getX(a, b, c, d, e, f) ;
    var y : double ; y := getY(a, b, c, d, e, f) ;
    x := fixIncorrectNumber(x) ; 
    y := fixIncorrectNumber(y) ; 
    answerX := answerX->including(x) ; 
    answerY := answerY->including(y) ; 
 ) );
  static   operation getX( a : int, b : int, c : int, d : int, e : int, f : int) : double
  pre: true
  post: true
  activity: (     var denominator : int ; denominator := a * e - b * d ;
     var numerator : int ; numerator := c * e - b * f ;
     return numerator->oclAsType(double) / denominator->oclAsType(double) );
  static   operation getY( a : int, b : int, c : int, d : int, e : int, f : int) : double
  pre: true
  post: true
  activity: (     var denominator : int ; denominator := b * d - a * e ;
     var numerator : int ; numerator := c * d - a * f ;
     return numerator->oclAsType(double) / denominator->oclAsType(double) );
  static   operation fixIncorrectNumber( x : double) : double
  pre: true
  post: true
  activity: (     if (x = (-0.0)) then (     x := 0.0 ) else skip ; 
     return x );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int n,x ;
    Scanner scanner=new Scanner(System.in);
    n=scanner.nextInt();
    x=(n/2)+1 ;
    for(int i=1 ; i<=n/2 ; i++){
      for(int k=1 ; k<=x-i ; k++){
        System.out.print('*');
      }
      for(int k=1 ; k<=(2*i)-1 ; k++){
        System.out.print('D');
      }
      for(int k=1 ; k<=x-i ; k++){
        System.out.print('*');
      }
      System.out.println("");
    }
    for(int i=1 ; i<=n ; i++){
      System.out.print('D');
    }
    System.out.println("");
    for(int i=n/2 ; i>=1 ; i--){
      for(int k=1 ; k<=x-i ; k++){
        System.out.print('*');
      }
      for(int k=1 ; k<=(2*i)-1 ; k++){
        System.out.print('D');
      }
      for(int k=1 ; k<=x-i ; k++){
        System.out.print('*');
      }
      System.out.println("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var x : int ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := scanner.getCurrent()->toInteger() ; 
    x := (n / 2) + 1 ; 
        var i : int ; i := 1 ; while i <= n / 2 do ( (         var k : int ; k := 1 ; while k <= x - i do ( (     OclFile["System.out"].print('*') )  ;     k := k + 1 ) ; 
         var k : int ; k := 1 ; while k <= (2 * i) - 1 do ( (     OclFile["System.out"].print('D') )  ;     k := k + 1 ) ; 
         var k : int ; k := 1 ; while k <= x - i do ( (     OclFile["System.out"].print('*') )  ;     k := k + 1 ) ; 
     OclFile["System.out"].println("") )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].print('D') )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
        var i : int ; i := n / 2 ; while i >= 1 do ( (         var k : int ; k := 1 ; while k <= x - i do ( (     OclFile["System.out"].print('*') )  ;     k := k + 1 ) ; 
         var k : int ; k := 1 ; while k <= (2 * i) - 1 do ( (     OclFile["System.out"].print('D') )  ;     k := k + 1 ) ; 
         var k : int ; k := 1 ; while k <= x - i do ( (     OclFile["System.out"].print('*') )  ;     k := k + 1 ) ; 
     OclFile["System.out"].println("") )  ;     i := i - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int c=1 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(i<=n/2){
          if(j>=(n/2)-i && j<=(n/2)+i){
            System.out.print("D");
          }
          else System.out.print("*");
        }
        if(i>n/2){
          if(j>=i-(n/2)&& j<(i-(n/2))+(((n-i)*2)-1)){
            System.out.print("D");
          }
          else System.out.print("*");
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
     var c : int ; c := 1 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (i <= n / 2) then (     if (j >= (n / 2) - i & j <= (n / 2) + i) then (     OclFile["System.out"].print("D") ) else     OclFile["System.out"].print("*") ; ) else skip ; 
     if (i > n / 2) then (     if (j >= i - (n / 2) & j < (i - (n / 2)) + (((n - i) * 2) - 1)) then (     OclFile["System.out"].print("D") ) else     OclFile["System.out"].print("*") ; ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf1611B {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    while(t-->0){
      int a=scan.nextInt();
      int b=scan.nextInt();
      int totolPPl=a+b ;
      System.out.println(Math.min(Math.min(a,b),totolPPl/4));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1611B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := scan.getCurrent()->toInteger() ;
     var b : int ; b := scan.getCurrent()->toInteger() ;
     var totolPPl : int ; totolPPl := a + b ;
     OclFile["System.out"].println(Set{Set{a, b}->min(), totolPPl / 4}->min()) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem465A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String bits=sc.next();
    int total=0 ;
    for(int i=0 ; i<n ; i++){
      if(bits.charAt(i)=='0'){
        total=i+1 ;
        break ;
      }
    }
    if(total==0)total=n ;
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem465A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var bits : String ; bits := sc.getCurrent() ;
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (bits->at(i+1) = '0') then (     total := i + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (total = 0) then     total := n ; else skip ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A465 {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    String str=scan.next();
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      char a=str.charAt(i);
      if(a=='1'){
        cnt++;
      }
      else {
        cnt++;
        break ;
      }
    }
    System.out.print(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A465 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var str : String ; str := scan.getCurrent() ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : String ; a := str->at(i+1) ;
     if (a = '1') then (     cnt := cnt + 1 ) else (     cnt := cnt + 1 ; 
     break ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      String s=sc.next();
      boolean ok=true ;
      if(s.charAt(0)=='0')System.out.println(1);
      else {
        int c=0 ;
        for(int i=0 ; i<n ; i++){
          if(s.charAt(i)=='0'){
            ok=false ;
            break ;
          }
          else c++;
        }
        if(ok)System.out.println(c);
        else System.out.println(c+1);
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var ok : boolean ; ok := true ;
    if (s->at(0+1) = '0') then     OclFile["System.out"].println(1) else (     var c : int ; c := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = '0') then (     ok := false ; 
     break ) else     c := c + 1 ; )  ;     i := i + 1 ) ; 
     if (ok) then     OclFile["System.out"].println(c) ; else     OclFile["System.out"].println(c + 1) ; ) ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countBits(int n){
    int count=0 ;
    while(n>0){
      count++;
      n>>=1 ;
    }
    return count ;
  }
  public static void main(String[] args){
    int n=32 ;
    System.out.println("Minimum value of K is="+countBits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countBits( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     count := count + 1 ; 
     n := n/(2->pow(1)) ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 32 ;
     OclFile["System.out"].println("Minimum value of K is=" + countBits(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int henkan(String n){
    return Integer.decode("0x"+n);
  }
  static double dk(String n,String k){
    k=k.substring(1);
    int r=henkan(k.substring(0,2));
    int g=henkan(k.substring(2,4));
    int b=henkan(k.substring(4,6));
    n=n.substring(1);
    int r2=henkan(n.substring(0,2));
    int g2=henkan(n.substring(2,4));
    int b2=henkan(n.substring(4,6));
    double result=((r-r2)*(r-r2)+(g-g2)*(g-g2)+(b-b2)*(b-b2));
    return Math.sqrt(result);
  }
  static String doIt(String n){
    double min=dk(n,hyou[0]);
    int memo=0 ;
    for(int i=1 ; i<hyou.length ; i++){
      double test=dk(n,hyou[i]);
      if(test<min){
        min=test ;
        memo=i ;
      }
    }
    return hyou2[memo];
  }
  static String hyou[]={
    "#000000","#0000ff","#00ff00","#00ffff","#ff0000","#ff00ff","#ffff00","#ffffff" };
    static String hyou2[]={
      "black","blue","lime","aqua","red","fuchsia","yellow","white" };
      public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNext()){
          String n=in.next();
          if(n.equals("0"))break ;
          System.out.println(doIt(n));
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation henkan( n : String) : int
  pre: true
  post: true
  activity: (     return ("0x" + n)->toInteger() );
  static   operation dk( n : String, k : String) : double
  pre: true
  post: true
  activity: (     k := k.subrange(1+1,1) ; 
     var r : int ; r := henkan(k.subrange(0+1,2)) ;
    var g : int ; g := henkan(k.subrange(2+1,4)) ;
    var b : int ; b := henkan(k.subrange(4+1,6)) ;
    n := n.subrange(1+1,1) ; 
    var r2 : int ; r2 := henkan(n.subrange(0+1,2)) ;
    var g2 : int ; g2 := henkan(n.subrange(2+1,4)) ;
    var b2 : int ; b2 := henkan(n.subrange(4+1,6)) ;
    var result : double ; result := ((r - r2) * (r - r2) + (g - g2) * (g - g2) + (b - b2) * (b - b2)) ;
    return (result)->sqrt() 
 );
  static   operation doIt( n : String) : String
  pre: true
  post: true
  activity: (     var min : double ; min := dk(n, hyou[0+1]) ;
     var memo : int ; memo := 0 ;
         var i : int ; i := 1 ; while i < hyou->size() do ( (     var test : double ; test := dk(n, hyou[i+1]) ;
     if (test < min) then (     min := test ; 
     memo := i ) else skip )  ;     i := i + 1 ) ; 
     return hyou2[memo+1] );
  static   attribute hyou : String := Sequence{"#000000","#0000ff","#00ff00","#00ffff","#ff0000","#ff00ff","#ffff00","#ffffff"};
  static   attribute hyou2 : String := Sequence{"black","blue","lime","aqua","red","fuchsia","yellow","white"};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var n : String ; n := in.getCurrent() ;
     if (n = "0") then     break else skip ; 
     OclFile["System.out"].println(doIt(n)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import static java.lang.System.out ;
class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    String name[]={
      "black","blue","lime","aqua","red","fuchsia","yellow","white" };
      int color[][]={
        {
          0,0,0 },{
            0,0,255 },{
              0,255,0 },{
                0,255,255 },{
                  255,0,0 },{
                    255,0,255 },{
                      255,255,0 },{
                        255,255,255 }
                      };
                      while(true){
                        String str=scan.next();
                        if(str.equals("0"))break ;
                        int R=Integer.parseInt(str.substring(1,3),16);
                        int G=Integer.parseInt(str.substring(3,5),16);
                        int B=Integer.parseInt(str.substring(5,7),16);
                        double min=Double.MAX_VALUE ;
                        int Index=0 ;
                        for(int i=0 ; i<8 ; i++){
                          double near=Math.sqrt(Math.pow(R-color[i][0],2)+Math.pow(G-color[i][1],2)+Math.pow(B-color[i][2],2));
                          if(near<min){
                            min=near ;
                            Index=i ;
                          }
                        }
                        out.println(name[Index]);
                      }
                    }
                  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var name : Sequence(String) ; name := Sequence{"black","blue","lime","aqua","red","fuchsia","yellow","white"} ;
     var color : Sequence(Sequence(int)) ; color := Sequence{Sequence{0,0,0},Sequence{0,0,255},Sequence{0,255,0},Sequence{0,255,255},Sequence{255,0,0},Sequence{255,0,255},Sequence{255,255,0},Sequence{255,255,255}} ;
     while (true) do (     var str : String ; str := scan.getCurrent() ;
     if (str = "0") then     break else skip ; 
    var R : int ; R := (str.subrange(1+1,3))->toInteger() ;
    var G : int ; G := (str.subrange(3+1,5))->toInteger() ;
    var B : int ; B := (str.subrange(5+1,7))->toInteger() ;
    var min : double ; min := (2 - 2->pow(-52))*(2->pow(1023)) ;
    var Index : int ; Index := 0 ;
        var i : int ; i := 0 ; while i < 8 do ( (     var near : double ; near := ((R)->char2byte() - color[i+1][0+1]->pow(2) + G - color[i+1][1+1]->pow(2) + B - color[i+1][2+1]->pow(2))->sqrt() ;
     if (near < min) then (     min := near ; 
     Index := i ) else skip )  ;     i := i + 1 ) ; 
    out.println(name[Index+1]) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Integer.*;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      char[] n=sc.next().toCharArray();
      if(n[0]=='0'){
        break ;
      }
      System.out.println("black blue lime aqua red fuchsia yellow white".split(" ")[parseInt(""+n[1]+n[2],16)/128*4+parseInt(""+n[3]+n[4],16)/128*2+parseInt(""+n[5]+n[6],16)/128]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : Sequence(String) ; n := sc.getCurrent()->characters() ;
     if (n[0+1] = '0') then (     break ) else skip ; 
     OclFile["System.out"].println("black blue lime aqua red fuchsia yellow white"->split(" ")[("" + n[1+1] + n[2+1], 16 + "")->toInteger() / 128 * 4 + ("" + n[3+1] + n[4+1], 16 + "")->toInteger() / 128 * 2 + ("" + n[5+1] + n[6+1], 16 + "")->toInteger() / 128+1]) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static int MAX=1000000 ;
  static ArrayList<Integer>primes=new ArrayList<Integer>();
  static void sieveSundaram(){
    boolean[] marked=new boolean[MAX];
    for(int i=1 ; i<=(Math.sqrt(MAX)-1)/2 ; i++){
      for(int j=(i*(i+1))<<1 ; j<=MAX/2 ; j+=2*i+1){
        marked[j]=true ;
      }
    }
    primes.add(2);
    for(int i=1 ; i<=MAX/2 ; i++){
      if(marked[i]==false){
        primes.add(2*i+1);
      }
    }
  }
  static int calculatePrimorial(int n){
    int result=1 ;
    for(int i=0 ; i<n ; i++){
      result=result*primes.get(i);
    }
    return result ;
  }
  public static void main(String[] args){
    int n=5 ;
    sieveSundaram();
    for(int i=1 ; i<=n ; i++){
      System.out.println("Primorial(P#)of "+i+" is "+calculatePrimorial(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 1000000;
  static   attribute primes : Sequence(int) := Sequence{};
  static   operation sieveSundaram() : void
  pre: true
  post: true
  activity: (     var marked : Sequence(boolean) ; marked := Integer.subrange(1,MAX)->collect(false) ;
         var i : int ; i := 1 ; while i <= ((MAX)->sqrt() - 1) / 2 do ( (         var j : int ; j := ((i * (i + 1))*(2->pow(1)))->oclAsType(long) ; while j <= MAX / 2 do ( (     marked[j+1] := true )  ;     j := j+(2 * i + 1) ) )  ;     i := i + 1 ) ; 
     primes := primes->including(2) ; 
         var i : int ; i := 1 ; while i <= MAX / 2 do ( (     if (marked[i+1] = false) then (     primes := primes->including(2 * i + 1) ) else skip )  ;     i := i + 1 ) );
  static   operation calculatePrimorial( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     result := result * primes->at(i+1) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute sieveSundaram() ; 
         var i : int ; i := 1 ; while i <= n do ( (     OclFile["System.out"].println("Primorial(P#)of " + i + " is " + calculatePrimorial(i)) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int[][] list={
    {
      0,0,0 },{
        0,0,255 },{
          0,255,0 },{
            0,255,255 },{
              255,0,0 },{
                255,0,255 },{
                  255,255,0 },{
                    255,255,255 },};
                    static String[] name={
                      "black","blue","lime","aqua","red","fuchsia","yellow","white" };
                      static int trans(char jyu,char ichi){
                        int sum=0 ;
                        if('a'<=jyu && jyu<='f'){
                          sum+=jyu-'a'+10 ;
                        }
                        else {
                          sum+=jyu-'0' ;
                        }
                        sum*=16 ;
                        if('a'<=ichi && ichi<='f'){
                          sum+=ichi-'a'+10 ;
                        }
                        else {
                          sum+=ichi-'0' ;
                        }
                        return sum ;
                      }
                      public static void main(String[] args){
                        Scanner stdIn=new Scanner(System.in);
                        while(true){
                          char[] in=stdIn.next().toCharArray();
                          if(in[0]=='0'){
                            return ;
                          }
                          int r=trans(in[1],in[2]);
                          int g=trans(in[3],in[4]);
                          int b=trans(in[5],in[6]);
                          double min=Double.MAX_VALUE ;
                          int min_idx=-1 ;
                          for(int k=0 ; k<8 ; k++){
                            double tmp=Math.abs(Math.sqrt(Math.pow(r-list[k][0],2)+Math.pow(g-list[k][1],2)+Math.pow(b-list[k][2],2)));
                            if(tmp<min){
                              min=tmp ;
                              min_idx=k ;
                            }
                          }
                          System.out.println(name[min_idx]);
                        }
                      }
                    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute list : Sequence(Sequence(int)) := Sequence{Sequence{0,0,0},Sequence{0,0,255},Sequence{0,255,0},Sequence{0,255,255},Sequence{255,0,0},Sequence{255,0,255},Sequence{255,255,0},Sequence{255,255,255},};
  static   attribute name : Sequence(String) := Sequence{"black","blue","lime","aqua","red","fuchsia","yellow","white"};
  static   operation trans( jyu : String, ichi : String) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     if ('a' <= jyu & jyu <= 'f') then (     sum := sum+(jyu - ('a')->char2byte() + 10) ) else (     sum := sum+(jyu - ('0')->char2byte()) ) ;  
    sum := sum*(16) ; 
    if ('a' <= ichi & ichi <= 'f') then (     sum := sum+(ichi - ('a')->char2byte() + 10) ) else (     sum := sum+(ichi - ('0')->char2byte()) ) ;  
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var in : Sequence(String) ; in := stdIn.getCurrent()->characters() ;
     if (in[0+1] = '0') then (     return ) else skip ; 
    var r : int ; r := trans(in[1+1], in[2+1]) ;
    var g : int ; g := trans(in[3+1], in[4+1]) ;
    var b : int ; b := trans(in[5+1], in[6+1]) ;
    var min : double ; min := (2 - 2->pow(-52))*(2->pow(1023)) ;
    var min_idx : int ; min_idx := -1 ;
        var k : int ; k := 0 ; while k < 8 do ( (     var tmp : double ; tmp := if (r - list[k+1][0+1]->pow(2) + g - list[k+1][1+1]->pow(2) + b - list[k+1][2+1]->pow(2))->sqrt() < 0 then -((r - list[k+1][0+1]->pow(2) + g - list[k+1][1+1]->pow(2) + b - list[k+1][2+1]->pow(2))->sqrt()) else (r - list[k+1][0+1]->pow(2) + g - list[k+1][1+1]->pow(2) + b - list[k+1][2+1]->pow(2))->sqrt() endif ;
     if (tmp < min) then (     min := tmp ; 
     min_idx := k ) else skip )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(name[min_idx+1]) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public final static int SIZE=26 ;
  public static int longSubstring(String str1,int k){
    int[] freq=new int[SIZE];
    char[] str=str1.toCharArray();
    int start=0 ;
    int maxLen=0 ;
    char ch ;
    int n=str1.length();
    for(int i=0 ; i<n ; i++){
      ch=str[i];
      freq[ch-'a']++;
      if(freq[ch-'a']>k){
        if(maxLen<(i-start))maxLen=i-start ;
        while(freq[ch-'a']>k){
          freq[str[start]-'a']--;
          start++;
        }
      }
    }
    if(maxLen<(n-start))maxLen=n-start ;
    return maxLen ;
  }
  public static void main(String argc[]){
    String str="babcaag" ;
    int k=1 ;
    System.out.println("Length="+longSubstring(str,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   attribute SIZE : int := 26;
  static   operation longSubstring( str1 : String, k : int) : int
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,SIZE)->collect(0) ;
     var str : Sequence(String) ; str := str1->characters() ;
    var start : int ; start := 0 ;
    var maxLen : int ; maxLen := 0 ;
    var ch : String ;
    var n : int ; n := str1->size() ;
        var i : int ; i := 0 ; while i < n do ( (     ch := str[i+1] ; 
     freq[(ch)->char2byte() - ('a')->char2byte()+1] := freq[(ch)->char2byte() - ('a')->char2byte()+1] + 1 ; 
     if (freq[(ch)->char2byte() - ('a')->char2byte()+1] > k) then (     if (maxLen < (i - start)) then     maxLen := i - start ; else skip ; 
     while (freq[(ch)->char2byte() - ('a')->char2byte()+1] > k) do (     freq[str[start+1] - ('a')->char2byte()+1] := freq[str[start+1] - ('a')->char2byte()+1] - 1 ; 
     start := start + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    if (maxLen < ((n)->char2byte() - start)) then     maxLen := (n)->char2byte() - start ; else skip ; 
    return maxLen 
 );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "babcaag" ;
     var k : int ; k := 1 ;
     OclFile["System.out"].println("Length=" + longSubstring(str, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test295 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int m=in.nextInt();
      if((m+n)/4>Math.min(n,m)){
        System.out.println(Math.min(n,m));
      }
      else {
        System.out.println((m+n)/4);
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test295 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
     if ((m + n) / 4 > Set{n, m}->min()) then (     OclFile["System.out"].println(Set{n, m}->min()) ) else (     OclFile["System.out"].println((m + n) / 4) ) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    int cnt=0 ;
    while(N/K!=0){
      N=N/K ;
      cnt++;
    }
    System.out.println(cnt+1);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var cnt : int ; cnt := 0 ;
    while (N / K /= 0) do (     N := N / K ; 
     cnt := cnt + 1 ) ; 
    OclFile["System.out"].println(cnt + 1) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileNotFoundException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    int q=K ;
    int count=1 ;
    while(q<=N){
      q*=K ;
      count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var q : int ; q := K ;
    var count : int ; count := 1 ;
    while (q <= N) do (     q := q*(K) ; 
     count := count + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.List ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int K=scanner.nextInt();
    List<Integer>list=new ArrayList<>();
    if(N<K){
      list.add(N);
    }
    else {
      while(N>=K){
        list.add(N % K);
        N=N/K ;
      }
      if(N!=0)list.add(N);
    }
    System.out.println(list.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var K : int ; K := scanner.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
    if (N < K) then (     list := list->including(N) ) else (     while (N >= K) do (     list := list->including(N mod K) ; 
     N := N / K ) ; 
     if (N /= 0) then     list := list->including(N) ; else skip ) ;  
    OclFile["System.out"].println(list->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int count=0 ;
    while(n>1){
      n=n/k ;
      count++;
    }
    if(n % k!=0){
      System.out.println(count+1);
    }
    else {
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    while (n > 1) do (     n := n / k ; 
     count := count + 1 ) ; 
    if (n mod k /= 0) then (     OclFile["System.out"].println(count + 1) ) else (     OclFile["System.out"].println(count) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    int K=sc.nextInt();
    for(int i=0 ; ; i++){
      if((Math.pow(K,i))>N){
        System.out.println(i);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while true do ( (     if ((K->pow(i)) > N) then (     OclFile["System.out"].println(i) ; 
     break ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static int sum(int N){
    int S1,S2,S3 ;
    S1=((N/2))*(2*2+(N/2-1)*2)/2 ;
    S2=((N/7))*(2*7+(N/7-1)*7)/2 ;
    S3=((N/14))*(2*14+(N/14-1)*14)/2 ;
    return S1+S2-S3 ;
  }
  public static void main(String[] args){
    int N=20 ;
    System.out.println(sum(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sum( N : int) : int
  pre: true
  post: true
  activity: (     var S1 : int ;
    var S2 : int ;
    var S3 : int ;
     S1 := ((N / 2)) * (2 * 2 + (N / 2 - 1) * 2) / 2 ; 
    S2 := ((N / 7)) * (2 * 7 + (N / 7 - 1) * 7) / 2 ; 
    S3 := ((N / 14)) * (2 * 14 + (N / 14 - 1) * 14) / 2 ; 
    return S1 + S2 - S3 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 20 ;
     OclFile["System.out"].println(sum(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new AOJ0227();
  }
  class AOJ0227 {
    public AOJ0227(){
      while(true){
        int n=in.nextInt();
        int m=in.nextInt();
        if(n==0 && m==0)break ;
        int[] p=new int[n];
        for(int i=0 ; i<n ; i++)p[i]=in.nextInt();
        Arrays.sort(p);
        int result=0 ;
        int sum=0 ;
        for(int i=0 ; i<n ; i++)sum+=p[i];
        int cnt=0 ;
        for(int i=n-1 ; i>=0 ; i--){
          cnt++;
          if(cnt==m){
            cnt=0 ;
            result+=p[i];
          }
        }
        System.out.println(sum-result);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: ( AOJ0227.newAOJ0227() );
 class AOJ0227 {
   static operation newAOJ0227() : AOJ0227
  pre: true
  post: true
  activity:
  ( var self : AOJ0227 ;
    self := createAOJ0227();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     while (true) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    if (n = 0 & m = 0) then     break else skip ; 
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     p[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    p := p->sort() ; 
    var result : int ; result := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (     sum := sum+(p[i+1]) ;  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     cnt := cnt + 1 ; 
     if (cnt = m) then (     cnt := 0 ; 
     result := result+(p[i+1]) ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(sum - result) ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.List ;
public class Main {
  public static void main(String[] args){
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    String line=null ;
    String[] in=null ;
    int numBuy,numIn ;
    ArrayList<Integer>costVegitables=new ArrayList<>();
    try {
      while((line=input.readLine())!=null){
        in=line.split(" ");
        if(in[0] .equals("0")&& in[1] .equals("0")){
          break ;
        }
        numBuy=Integer.parseInt(in[0]);
        numIn=Integer.parseInt(in[1]);
        line=input.readLine();
        in=line.split(" ");
        costVegitables.clear();
        for(String str : in){
          int cost=Integer.parseInt(str);
          costVegitables.add(cost);
        }
        Collections.sort(costVegitables,Collections.reverseOrder());
        int index=1 ;
        int minimumCost=0 ;
        for(int i : costVegitables){
          if(index % numIn!=0){
            minimumCost+=i ;
          }
          index++;
        }
        System.out.println(minimumCost);
      }
    }
    catch(IOException e){
      System.out.println("IOException");
    }
    catch(NumberFormatException e){
      System.out.println("including not int");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := null ;
    var in : Sequence(String) ; in := null ;
    var numBuy : int ;
    var numIn : int ;
    var costVegitables : Sequence(int) ; costVegitables := Sequence{} ;
    try (         line := input.readLine() ;
    while ((line) /= null) do (    skip ; (     in := line->split(" ") ; 
     if (in[0+1] = "0" & in[1+1] = "0") then (     break ) else skip ; 
    numBuy := (in[0+1])->toInteger() ; 
    numIn := (in[1+1])->toInteger() ; 
    line := input.readLine() ; 
    in := line->split(" ") ; 
    costVegitables := costVegitables->intersection(Set{}) ; 
    for (str : in) do ( (     var cost : int ; cost := (str)->toInteger() ;
     costVegitables := costVegitables->including(cost) )  ) ; 
    costVegitables, reverseOrder() := costVegitables, reverseOrder()->sort() ; 
    var index : int ; index := 1 ;
    var minimumCost : int ; minimumCost := 0 ;
    for (i : costVegitables) do ( (     if (index mod numIn /= 0) then (     minimumCost := minimumCost+(i) ) else skip ; 
     index := index + 1 )  ) ; 
    OclFile["System.out"].println(minimumCost) ; 
 ) ;     line := input.readLine() ;
 ) )   catch (e : IOException) do (     OclFile["System.out"].println("IOException") )
   catch (e : IncorrectElementException) do (     OclFile["System.out"].println("including not int") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.util.Arrays.*;
class Main {
  int[] ns ;
  int n,m ;
  void run(){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      n=in.nextInt();
      m=in.nextInt();
      if(n==0)return ;
      ns=new int[n];
      for(int i=0 ; i<n ; i++)ns[i]=in.nextInt();
      System.out.println(solve());
    }
  }
  int solve(){
    int ans=0 ;
    sort(ns);
    for(int i=0 ; i<n ; i++)if(i % m!=m-1)ans+=ns[n-i-1];
    return ans ;
  }
  public static void main(String args[]){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute ns : Sequence(int);
   attribute n : int;
   operation run() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     n := in.getCurrent()->toInteger() ; 
     m := in.getCurrent()->toInteger() ; 
    if (n = 0) then     return else skip ; 
    ns := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     ns[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve()) ; 
 )  ) );
   operation solve() : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     execute sort(ns) ; 
         var i : int ; i := 0 ; while i < n do (     if (i mod m /= m - 1) then     ans := ans+(ns[n - i - 1+1]) ; else skip ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int gcd(int a,int b){
    return b>0 ? gcd(b,a % b): a ;
  }
  static int countGCD(int L,int R,int g){
    L=(L+g-1)/g ;
    R=R/g ;
    int ans=0 ;
    for(int i=L ; i<=R ; i++)for(int j=L ; j<=R ; j++)if(gcd(i,j)==1)ans++;
    return ans ;
  }
  public static void main(String[] args){
    int L=1,R=11,g=5 ;
    System.out.println(countGCD(L,R,g));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b > 0 then gcd(b, a mod b) else a endif );
  static   operation countGCD( L : int, R : int, g : int) : int
  pre: true
  post: true
  activity: (     L := (L + g - 1) / g ; 
     R := R / g ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := L ; while i <= R do (         var j : int ; j := L ; while j <= R do (     if (gcd(i, j) = 1) then     ans := ans + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 1 ;
    var R : int ; R := 11 ;
    var g : int ; g := 5 ;
     OclFile["System.out"].println(countGCD(L, R, g)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    int[] indexes=new int[n+1];
    TreeSet<Integer>set=new TreeSet<>();
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      indexes[arr[i] ]=i ;
      set.add(i);
    }
    set.add(n);
    set.add(-1);
    long ans=0 ;
    for(int i=n ; i>=1 ; i--){
      int idx=indexes[i];
      long left=set.lower(idx)+1 ;
      long right=set.higher(idx)-1 ;
      ans+=(idx-left+1)*(right-idx+1)*i ;
      set.remove(idx);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var indexes : Sequence(int) ; indexes := Integer.subrange(1,n + 1)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     indexes[arr[i+1]+1] := i ; 
     set := set->including(i) )  ;     i := i + 1 ) ; 
    set := set->including(n) ; 
    set := set->including(-1) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := n ; while i >= 1 do ( (     var idx : int ; idx := indexes[i+1] ;
     var left : long ; left := set.lower(idx) + 1 ;
    var right : long ; right := set.higher(idx) - 1 ;
    ans := ans+((idx - left + 1) * (right - idx + 1) * i) ; 
    set := set->excludingAt(idx+1) ; 
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if((n | m)==0)break ;
      Integer[] ps=new Integer[n];
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        ps[i]=sc.nextInt();
        sum+=ps[i];
      }
      Arrays.sort(ps,new Comparator<Integer>(){
        public int compare(Integer a,Integer b){
          return b-a ;
        }
      }
);
      for(int i=0 ; i<ps.length/m ; i++){
        sum-=ps[i*m+m-1];
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,m)) = 0) then     break else skip ; 
    var ps : Sequence(int) ; ps := Integer.subrange(1,n)->collect(null) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ps[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(ps[i+1]) )  ;     i := i + 1 ) ; 
    ps := OclComparator.sortWith(ps, OclComparator<int>.newOclComparator()) ; 
        var i : int ; i := 0 ; while i < ps->size() / m do ( (     sum := sum-(ps[i * m + m - 1+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    while(s.hasNextLine()){
      int purchaceCnt=s.nextInt();
      int canPackCnt=s.nextInt();
      if(purchaceCnt==0 && canPackCnt==0)return ;
      s.nextLine();
      String[] values=s.nextLine().split(" ");
      Integer[] value=new Integer[values.length];
      for(int i=0 ; i<values.length ; i++){
        value[i]=new Integer(values[i]);
      }
      System.out.println(solve(purchaceCnt,canPackCnt,value));
    }
  }
  public static int solve(int purchaceCnt,int canPackCnt,Integer[] values){
    int value=0 ;
    int cnt=0 ;
    if(purchaceCnt>=canPackCnt){
      Arrays.sort(values,Collections.reverseOrder());
      for(int i=0 ; i<purchaceCnt ; i++){
        cnt++;
        if(cnt==canPackCnt){
          cnt=0 ;
        }
        else {
          value+=values[i] .intValue();
        }
      }
    }
    else {
      Arrays.sort(values);
      for(int i=0 ; i<purchaceCnt ; i++){
        value+=values[i] .intValue();
      }
    }
    return value ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (s.hasNextLine()) do (     var purchaceCnt : int ; purchaceCnt := s.getCurrent()->toInteger() ;
     var canPackCnt : int ; canPackCnt := s.getCurrent()->toInteger() ;
    if (purchaceCnt = 0 & canPackCnt = 0) then     return else skip ; 
    skip ; 
    var values : Sequence(String) ; values := s.nextLine()->split(" ") ;
    var value : Sequence(int) ; value := Integer.subrange(1,values->size())->collect(null) ;
        var i : int ; i := 0 ; while i < values->size() do ( (     value[i+1] := ("" + (values[i+1]))->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(purchaceCnt, canPackCnt, value)) ; 
 ) );
  static   operation solve( purchaceCnt : int, canPackCnt : int, values : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var value : int ; value := 0 ;
     var cnt : int ; cnt := 0 ;
     if (purchaceCnt >= canPackCnt) then (     values := OclComparator.sortWith(values, reverseOrder()) ; 
         var i : int ; i := 0 ; while i < purchaceCnt do ( (     cnt := cnt + 1 ; 
     if (cnt = canPackCnt) then (     cnt := 0 ) else (     value := value+(values[i+1]->oclAsType(int)) ) )  ;     i := i + 1 ) ) else (     values := values->sort() ; 
         var i : int ; i := 0 ; while i < purchaceCnt do ( (     value := value+(values[i+1]->oclAsType(int)) )  ;     i := i + 1 ) ) ;  
     return value );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public List<Integer>findAnagrams(String s,String p){
    List<Integer>list=new ArrayList<>();
    if(s==null || s.length()==0 || p==null || p.length()==0)return list ;
    int[] hash=new int[256];
    for(char c : p.toCharArray()){
      hash[c]++;
    }
    int left=0,right=0,count=p.length();
    while(right<s.length()){
      if(hash[s.charAt(right++)]-->=1)count--;
      if(count==0)list.add(left);
      if(right-left==p.length()&& hash[s.charAt(left++)]++>=0)count++;
    }
    return list ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation findAnagrams( s : String, p : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     if (s = null or s->size() = 0 or p = null or p->size() = 0) then     return list else skip ; 
    var hash : Sequence(int) ; hash := Integer.subrange(1,256)->collect(0) ;
    for (c : p->characters()) do ( (     hash[c+1] := hash[c+1] + 1 )  ) ; 
    var left : int ; left := 0 ;
    var right : int ; right := 0 ;
    var count : int ; count := p->size() ;
    while (right < s->size()) do (     if (hash[s->at(right+1)+1] >= 1) then     count := count - 1 ; else skip ; 
     if (count = 0) then     list := list->including(left) ; else skip ; 
     if (right - left = p->size() & hash[s->at(left+1)+1] >= 0) then     count := count + 1 ; else skip ) ; 
    return list 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
import java.awt.geom.*;
public class Elevator {
  static int ppl,top ;
  public static int solve(int floorCount,int from,int to,int time){
    if(from==to)return 0 ;
    floorCount--;
    time %=2*floorCount ;
    if(from<to){
      if(time<=from-1)return to-1-time ;
      else return 2*floorCount+to-1-time ;
    }
    else {
      if(time<=2*floorCount-from+1)return 2*floorCount-to+1-time ;
      else return 4*floorCount-to+1-time ;
    }
  }
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    ppl=sc.ni();
    top=sc.ni();
    while(ppl-->0){
      int from=sc.ni();
      int to=sc.ni();
      int time=sc.ni();
      int floorCount=top ;
      System.out.println(solve(floorCount,from,to,time)+time);
    }
  }
  private 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 ni(){
      return Integer.parseInt(next());
    }
    float nf(){
      return Float.parseFloat(next());
    }
    long nl(){
      return Long.parseLong(next());
    }
    double nd(){
      return Double.parseDouble(next());
    }
    String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Elevator {
  static   attribute ppl : int;
  static   operation solve( floorCount : int, from : int, to : int, time : int) : int
  pre: true
  post: true
  activity: (     if (from = to) then     return 0 else skip ; 
     floorCount := floorCount - 1 ; 
     time := time mod 2 * floorCount ; 
     if (from < to) then (     if (time <= from - 1) then     return to - 1 - time else     return 2 * floorCount + to - 1 - time ) else (     if (time <= 2 * floorCount - from + 1) then     return 2 * floorCount - to + 1 - time else     return 4 * floorCount - to + 1 - time ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     ppl := sc.ni() ; 
     top := sc.ni() ; 
         while (ppl > 0) do (        ppl := ppl - 1 ;     skip ; (     var from : int ; from := sc.ni() ;
     var to : int ; to := sc.ni() ;
    var time : int ; time := sc.ni() ;
    var floorCount : int ; floorCount := top ;
    OclFile["System.out"].println(solve(floorCount, from, to, time) + time) ; 
 ) ;  ) );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nf() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nl() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nd() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A117 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int M=in.nextInt();
    StringBuilder output=new StringBuilder();
    for(int n=0 ; n<N ; n++){
      int S=in.nextInt();
      int F=in.nextInt();
      int T=in.nextInt();
      int answer ;
      if(S==F){
        answer=T ;
      }
      else if(S<F){
        int t=T %(2*(M-1));
        answer=T+F-1-t ;
        if(t>=S){
          answer+=2*(M-1);
        }
      }
      else {
        int t=T %(2*(M-1));
        answer=T+2*(M-1)-(F-1)-t ;
        if(t>2*(M-1)-(S-1)){
          answer+=2*(M-1);
        }
      }
      output.append(answer).append('\n');
    }
    System.out.print(output);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A117 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var M : int ; M := in.getCurrent()->toInteger() ;
    var output : String ; output := StringLib.newString() ;
        var n : int ; n := 0 ; while n < N do ( (     var S : int ; S := in.getCurrent()->toInteger() ;
     var F : int ; F := in.getCurrent()->toInteger() ;
    var T : int ; T := in.getCurrent()->toInteger() ;
    var answer : int ;
    if (S = F) then (     answer := T ) else     if (S < F) then (     var t : int ; t := T mod (2 * (M - 1)) ;
     answer := T + F - 1 - t ; 
     if (t >= S) then (     answer := answer+(2 * (M - 1)) ) else skip ) else (     var t : int ; t := T mod (2 * (M - 1)) ;
     answer := T + 2 * (M - 1) - (F - 1) - t ; 
     if (t > 2 * (M - 1) - (S - 1)) then (     answer := answer+(2 * (M - 1)) ) else skip ) ;  ;  
    output := output + StringLib.newString(answer) + StringLib.newString('
') ; 
 )  ;     n := n + 1 ) ; 
    OclFile["System.out"].print(output) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Lottery {
  static BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
  static StringTokenizer st=new StringTokenizer("");
  static String readString()throws Exception {
    while(! st.hasMoreTokens()){
      st=new StringTokenizer(stdin.readLine());
    }
    return st.nextToken();
  }
  static int readInt()throws Exception {
    return Integer.parseInt(readString());
  }
  static double readDouble()throws Exception {
    return Double.parseDouble(readString());
  }
  public static void main(String[] args)throws Exception {
    int T=readInt();
    for(int t=1 ; t<=T ; t++){
      System.out.printf("Case #%d: ",t);
      solve();
    }
  }
  static void solve()throws Exception {
    int A,B,K ;
    A=readInt();
    B=readInt();
    K=readInt();
    long total=0L ;
    for(int a=0 ; a<A ; a++){
      for(int b=0 ; b<B ; b++){
        if((a & b)<K)total++;
      }
    }
    System.out.printf("%d\n",total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Lottery {
  static   attribute stdin : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute st : OclIterator := OclIterator.newOclIterator_String("");
  static   operation readString() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(stdin.readLine()) ) ; 
     return st.next() );
  static   operation readInt() : int
  pre: true
  post: true
  activity: (     return (readString())->toInteger() );
  static   operation readDouble() : double
  pre: true
  post: true
  activity: (     return (readString())->toReal() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := readInt() ;
         var t : int ; t := 1 ; while t <= T do ( (     OclFile["System.out"].printf("Case #%d: ", t) ; 
     execute solve() )  ;     t := t + 1 ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var A : int ;
    var B : int ;
    var K : int ;
     A := readInt() ; 
    B := readInt() ; 
    K := readInt() ; 
    var total : long ; total := 0L ;
        var a : int ; a := 0 ; while a < A do ( (         var b : int ; b := 0 ; while b < B do ( (     if ((MathLib.bitwiseAnd(a,b)) < K) then     total := total + 1 ; else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    OclFile["System.out"].printf("%d\n", total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class watchingMovie {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int x=sc.nextInt();
    int min=0 ;
    int time=1 ;
    while(n-->0){
      int l=sc.nextInt();
      int r=sc.nextInt();
      while(time<l &&(time+x)<=l){
        time=time+x ;
      }
      for(int i=time ; i<=r ; i++){
        min++;
        time++;
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class watchingMovie {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var min : int ; min := 0 ;
    var time : int ; time := 1 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
     while (time < l & (time + x) <= l) do (     time := time + x ) ; 
         var i : int ; i := time ; while i <= r do ( (     min := min + 1 ; 
     time := time + 1 )  ;     i := i + 1 ) ) ;  ) ;  
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.List ;
import java.util.LinkedList ;
import java.util.ArrayList ;
import java.util.TreeSet ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.io.PrintWriter ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    long n=sc.nextLong(),s=sc.nextLong();
    long time=0 ;
    long start=1 ;
    for(long i=1 ; i<=n ; i++){
      long x1=sc.nextLong();
      long x2=sc.nextLong();
      time+=(x1-start)% s+(x2-x1+1);
      start=x2+1 ;
    }
    out.println(time);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := sc.getCurrent()->toLong() ;
    var s : long ; s := sc.getCurrent()->toLong() ;
    var time : long ; time := 0 ;
    var start : long ; start := 1 ;
        var i : long ; i := 1 ; while i <= n do ( (     var x1 : long ; x1 := sc.getCurrent()->toLong() ;
     var x2 : long ; x2 := sc.getCurrent()->toLong() ;
     time := time+((x1 - start) mod s + (x2 - x1 + 1)) ; 
     start := x2 + 1 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Watchingamovie {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int m=Integer.parseInt(st.nextToken());
    int x=Integer.parseInt(st.nextToken());
    int time=0 ;
    int nthmin=1 ;
    for(int i=0 ; i<m ; i++){
      st=new StringTokenizer(br.readLine());
      int starting=Integer.parseInt(st.nextToken());
      int ending=Integer.parseInt(st.nextToken());
      while(nthmin+x<=starting)nthmin+=x ;
      time+=ending-Math.min(nthmin,starting)+1 ;
      nthmin=ending+1 ;
    }
    System.out.println(time);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Watchingamovie {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var m : int ; m := (st.next())->toInteger() ;
    var x : int ; x := (st.next())->toInteger() ;
    var time : int ; time := 0 ;
    var nthmin : int ; nthmin := 1 ;
        var i : int ; i := 0 ; while i < m do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var starting : int ; starting := (st.next())->toInteger() ;
    var ending : int ; ending := (st.next())->toInteger() ;
    while (nthmin + x <= starting) do     nthmin := nthmin+(x) ; ; 
    time := time+(ending - Set{nthmin, starting}->min() + 1) ; 
    nthmin := ending + 1 ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(time) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public ArrayList<Integer>maxes ;
  public static void main(String[] args){
(new Main()).go();
  }
  public void go(){
    this.maxes=new ArrayList<Integer>();
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      int m=sc.nextInt();
      if(n==0 && m==0){
        break ;
      }
      int[] points=new int[n];
      int max=0 ;
      for(int i=0 ; i<m ; i++){
        for(int j=0 ; j<n ; j++){
          points[j]+=sc.nextInt();
          if(i==m-1 && max<points[j]){
            max=points[j];
          }
        }
      }
      this.maxes.add(max);
    }
    for(Integer max : maxes){
      System.out.println(max);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute maxes : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).go() );
   operation go() : void
  pre: true
  post: true
  activity: (     self.maxes := Sequence{} ; 
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    if (n = 0 & m = 0) then (     break ) else skip ; 
    var points : Sequence(int) ; points := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j < n do ( (     points[j+1] := points[j+1]+(sc.getCurrent()->toInteger()) ; 
     if (i = m - 1 & max < points[j+1]) then (     max := points[j+1] ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    self.maxes->excludes(max) ; 
 ) ; 
    for (max : maxes) do ( (     OclFile["System.out"].println(max) )  ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public long solve(long N,long X){
    long longEdge=Math.max(X,N-X);
    long shortEdge=Math.min(X,N-X);
    long length=X+N-X ;
    long times=1 ;
    while(shortEdge>0){
      long num=longEdge/shortEdge ;
      long left=longEdge-(shortEdge*num);
      length+=(shortEdge*num*2);
      longEdge=shortEdge ;
      shortEdge=left ;
      times++;
    }
    length-=longEdge ;
    return length ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long N=in.nextLong();
    long X=in.nextLong();
    in.close();
    Main main=new Main();
    long result=main.solve(N,X);
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve( N : long, X : long) : long
  pre: true
  post: true
  activity: (     var longEdge : long ; longEdge := Set{X, N - X}->max() ;
     var shortEdge : long ; shortEdge := Set{X, N - X}->min() ;
    var length : long ; length := X + N - X ;
    var times : long ; times := 1 ;
    while (shortEdge > 0) do (     var num : long ; num := longEdge / shortEdge ;
     var left : long ; left := longEdge - (shortEdge * num) ;
    length := length+((shortEdge * num * 2)) ; 
    longEdge := shortEdge ; 
    shortEdge := left ; 
    times := times + 1 ; 
 ) ; 
    length := length-(longEdge) ; 
    return length 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := in.getCurrent()->toLong() ;
    var X : long ; X := in.getCurrent()->toLong() ;
    skip ; 
    var main : Main ; main := Main.newMain() ;
    var result : long ; result := main.solve(N, X) ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.Math ;
public final class Mycode {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int n,x,temp1,temp2,total_minutes=0 ;
    n=in.nextInt();
    x=in.nextInt();
    temp2=0 ;
    for(int i=0 ; i<n ; i++){
      temp1=in.nextInt();
      total_minutes+=(temp1-temp2-1)-((temp1-temp2-1)/x)*x ;
      temp2=in.nextInt();
      total_minutes+=(temp2-temp1+1);
    }
    System.out.println(total_minutes);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mycode {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var x : int ;
    var temp1 : int ;
    var temp2 : int ;
    var total_minutes : int ; total_minutes := 0 ;
    n := in.getCurrent()->toInteger() ; 
    x := in.getCurrent()->toInteger() ; 
    temp2 := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     temp1 := in.getCurrent()->toInteger() ; 
     total_minutes := total_minutes+((temp1 - temp2 - 1) - ((temp1 - temp2 - 1) / x) * x) ; 
     temp2 := in.getCurrent()->toInteger() ; 
     total_minutes := total_minutes+((temp2 - temp1 + 1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total_minutes) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minimumflip(int mat[][],int n){
    int transpose[][]=new int[n][n];
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)transpose[i][j]=mat[j][i];
    int flip=0 ;
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)if(transpose[i][j]!=mat[i][j])flip++;
    return flip/2 ;
  }
  public static void main(String[] args){
    int n=3 ;
    int mat[][]={
      {
        0,0,1 },{
          1,1,1 },{
            1,0,0 }
          };
          System.out.println(minimumflip(mat,n));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumflip( mat : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     var transpose : Sequence(Sequence(int)) ; transpose := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (     transpose[i+1][j+1] := mat[j+1][i+1] ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var flip : int ; flip := 0 ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (     if (transpose[i+1][j+1] /= mat[i+1][j+1]) then     flip := flip + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return flip / 2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{0,0,1},Sequence{1,1,1},Sequence{1,0,0}} ;
     OclFile["System.out"].println(minimumflip(mat, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] l=new int[n];
    for(int i=0 ; i<n ; i++){
      l[i]=sc.nextInt();
    }
    Arrays.sort(l);
    int len=0 ;
    for(int i=0 ; i<k ; i++){
      len+=l[n-i-1];
    }
    System.out.println(len);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     l[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    l := l->sort() ; 
    var len : int ; len := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     len := len+(l[n - i - 1+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(len) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskB solver=new TaskB();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskB {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt(),k=in.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; ++i)a[i]=in.nextInt();
      Arrays.sort(a);
      int res=0,cur=n-1 ;
      while(k-->0)res+=a[cur--];
      out.println(res);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskB ; solver := TaskB.newTaskB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskB {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
    var k : int ; k := in.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.nextInt() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var res : int ; res := 0 ;
    var cur : int ; cur := n - 1 ;
        while (k > 0) do (        k := k - 1 ;     skip ;      res := res + a[cur+1]  ; cur := cur - 1 ; ;  ) ;  
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.util.stream.Stream ;
public class Main {
  public static Scanner stdIn=new Scanner(System.in);
  public static void main(String[] args){
    String L1=stdIn.nextLine();
    String L2=stdIn.nextLine();
    String[] s1=L1.split(" ",0);
    String[] s2=L2.split(" ",0);
    int[] i2=Stream.of(s2).mapToInt(Integer :: parseInt).toArray();
    Arrays.sort(i2);
    int r=0 ;
    for(int i=Integer.parseInt(s1[0]); i>Integer.parseInt(s1[0])-Integer.parseInt(s1[1]); i--){
      r+=i2[i-1];
    }
    System.out.println(r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute stdIn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L1 : String ; L1 := stdIn.nextLine() ;
     var L2 : String ; L2 := stdIn.nextLine() ;
    var s1 : Sequence(String) ; s1 := L1->split(" ") ;
    var s2 : Sequence(String) ; s2 := L2->split(" ") ;
    var i2 : Sequence(int) ; i2 := Sequence{s2}->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    i2 := i2->sort() ; 
    var r : int ; r := 0 ;
        var i : int ; i := (s1[0+1])->toInteger() ; while i > (s1[0+1])->toInteger() - (s1[1+1])->toInteger() do ( (     r := r+(i2[i - 1+1]) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(r) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args)throws IOException {
    Scanner Input=new Scanner(System.in);
    int N=Input.nextInt();
    int K=Input.nextInt();
    ArrayList<Integer>Li=new ArrayList();
    for(int I=0 ; I<N ; I++){
      Li.add(Input.nextInt());
    }
    Collections.sort(Li);
    long Sum=0 ;
    for(int I=Li.size()-1 ; I>=Li.size()-K ; I--){
      Sum+=Li.get(I);
    }
    System.out.println(Sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Input : OclFile ; Input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := Input.getCurrent()->toInteger() ;
    var K : int ; K := Input.getCurrent()->toInteger() ;
    var Li : Sequence(int) ; Li := Sequence{} ;
        var I : int ; I := 0 ; while I < N do ( (     Li := Li->including(Input.getCurrent()->toInteger()) )  ;     I := I + 1 ) ; 
    Li := Li->sort() ; 
    var Sum : long ; Sum := 0 ;
        var I : int ; I := Li->size() - 1 ; while I >= Li->size() - K do ( (     Sum := Sum+(Li->at(I+1)) )  ;     I := I - 1 ) ; 
    OclFile["System.out"].println(Sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.Comparator ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    B solver=new B();
    solver.solve(1,in,out);
    out.close();
  }
  static class B {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=Integer.parseInt(in.next());
      int k=Integer.parseInt(in.next());
      Integer l[]=new Integer[n];
      for(int i=0 ; i<n ; i++){
        l[i]=Integer.valueOf(in.next());
      }
      int ans=0 ;
      Arrays.sort(l,Comparator.reverseOrder());
      for(int i=0 ; i<k ; i++){
        ans+=l[i];
      }
      out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : B ; solver := B.newB() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class B {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (in.getCurrent())->toInteger() ;
     var k : int ; k := (in.getCurrent())->toInteger() ;
    var l : Sequence(int) ; l := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     l[i+1] := (in.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    l := OclComparator.sortWith(l, Comparator.reverseOrder()) ; 
        var i : int ; i := 0 ; while i < k do ( (     ans := ans+(l[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),k=sc.nextInt();
    int sz=(n-1)/k,extra=(n-1)% k ;
    System.out.println(2*sz+Math.min(extra,2));
    for(int i=1,cur=k+2 ; i<=k ; i++){
      int size=sz ;
      if(i>extra){
        size--;
      }
      System.out.println(k+1+" "+i);
      if(size>0){
        System.out.println(i+" "+cur);
        cur++;
      }
      for(int j=1 ; j<size ; j++){
        System.out.println(cur-1+" "+cur);
        cur++;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var sz : int ; sz := (n - 1) / k ;
    var extra : int ; extra := (n - 1) mod k ;
    OclFile["System.out"].println(2 * sz + Set{extra, 2}->min()) ; 
        var i : int ; i := 1 ;
    var cur : int ; cur := k + 2 ; while i <= k do ( (     var size : int ; size := sz ;
     if (i > extra) then (     size := size - 1 ) else skip ; 
    OclFile["System.out"].println(k + 1 + " " + i) ; 
    if (size > 0) then (     OclFile["System.out"].println(i + " " + cur) ; 
     cur := cur + 1 ) else skip ; 
        var j : int ; j := 1 ; while j < size do ( (     OclFile["System.out"].println(cur - 1 + " " + cur) ; 
     cur := cur + 1 )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class dd {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int ans=(n-1)/k*2 ;
    if((n-1)% k==1){
      ans++;
    }
    else if((n-1)% k!=0){
      ans+=2 ;
    }
    System.out.println(ans);
    for(int i=2 ; i<=k ; i++){
      System.out.println("1 "+i);
    }
    for(int i=k+1 ; i<=n ; i++){
      System.out.println(i-k+" "+i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class dd {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := (n - 1) / k * 2 ;
    if ((n - 1) mod k = 1) then (     ans := ans + 1 ) else     if ((n - 1) mod k /= 0) then (     ans := ans+(2) ) else skip ; ;  
    OclFile["System.out"].println(ans) ; 
        var i : int ; i := 2 ; while i <= k do ( (     OclFile["System.out"].println("1 " + i) )  ;     i := i + 1 ) ; 
        var i : int ; i := k + 1 ; while i <= n do ( (     OclFile["System.out"].println(i - k + " " + i) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=Integer.parseInt(sc.next());
      int m=Integer.parseInt(sc.next());
      if(n==0 && m==0){
        break ;
      }
      int[][] Scores=new int[n][m];
      for(int i=0 ; i<m ; i++){
        for(int j=0 ; j<n ; j++){
          Scores[j][i]=Integer.parseInt(sc.next());
        }
      }
      int max=0 ;
      int sum ;
      for(int i=0 ; i<n ; i++){
        sum=0 ;
        for(int j=0 ; j<m ; j++){
          sum+=Scores[i][j];
        }
        if(sum>max){
          max=sum ;
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := (sc.getCurrent())->toInteger() ;
     var m : int ; m := (sc.getCurrent())->toInteger() ;
    if (n = 0 & m = 0) then (     break ) else skip ; 
    var Scores : Sequence(Sequence(int)) ; Scores := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (         var j : int ; j := 0 ; while j < n do ( (     Scores[j+1][i+1] := (sc.getCurrent())->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var sum : int ;
        var i : int ; i := 0 ; while i < n do ( (     sum := 0 ; 
         var j : int ; j := 0 ; while j < m do ( (     sum := sum+(Scores[i+1][j+1]) )  ;     j := j + 1 ) ; 
     if (sum > max) then (     max := sum ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int ans=(n-1)/k*2 ;
    if((n-1)% k==1){
      ans++;
    }
    else if((n-1)% k!=0){
      ans+=2 ;
    }
    System.out.println(ans);
    for(int i=2 ; i<=k ; i++){
      System.out.println("1 "+i);
    }
    for(int i=k+1 ; i<=n ; i++){
      System.out.println(i-k+" "+i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := (n - 1) / k * 2 ;
    if ((n - 1) mod k = 1) then (     ans := ans + 1 ) else     if ((n - 1) mod k /= 0) then (     ans := ans+(2) ) else skip ; ;  
    OclFile["System.out"].println(ans) ; 
        var i : int ; i := 2 ; while i <= k do ( (     OclFile["System.out"].println("1 " + i) )  ;     i := i + 1 ) ; 
        var i : int ; i := k + 1 ; while i <= n do ( (     OclFile["System.out"].println(i - k + " " + i) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BMysteriousLight solver=new BMysteriousLight();
    solver.solve(1,in,out);
    out.close();
  }
  static class BMysteriousLight {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      long n,x ;
      n=in.nextLong();
      x=in.nextLong();
      out.println(3*(n-gcd(n,x)));
    }
    public long gcd(long n,long x){
      if(n==0)return x ;
      return gcd(x % n,n);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BMysteriousLight ; solver := BMysteriousLight.newBMysteriousLight() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BMysteriousLight {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : long ;
    var x : long ;
     n := in.nextLong() ; 
     x := in.nextLong() ; 
     skip );
   operation gcd( n : long, x : long) : long
  pre: true
  post: true
  activity: (     if (n = 0) then     return x else skip ; 
     return gcd(x mod n, n) );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Integer.parseInt ;
import static java.lang.System.out ;
import java.io.File ;
import java.util.Scanner ;
public class Main extends BaseExe {
  public static int maxSize=1000000 ;
  public static boolean[] prime=new boolean[maxSize];
  public static void main(String[] args){
    new Main().exeSysIn();
  }
  @ Override protected void execute(Scanner scan){
    setPrime();
    String inData="" ;
    while(scan.hasNextLine()&& ! "".equals(inData=scan.nextLine())){
      out.println(primeCount(parseInt(inData)));
    }
  }
  private void setPrime(){
    prime[2]=true ;
    for(int i=3 ; i<maxSize ; i++){
      if(i % 2==0){
        continue ;
      }
      setOddPrime(i);
    }
  }
  private void setOddPrime(int i){
    boolean isPrime=true ;
    for(int j=1 ; j<=Math.sqrt(i); j++){
      if(prime[j] && i % j==0){
        isPrime=false ;
        break ;
      }
    }
    prime[i]=(isPrime)? true : false ;
  }
  private int primeCount(int inData){
    int count=0 ;
    for(int i=2 ; i<=inData ; i++){
      if(i!=2 && i % 2==0){
        continue ;
      }
      count=(prime[i])?++count : count ;
    }
    return count ;
  }
}
abstract class BaseExe {
  public void exeSysIn(){
    try(Scanner scan=new Scanner(System.in)){
      execute(scan);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  public void exeFileIn(String inDataPath){
    try(Scanner scan=new Scanner(new File(inDataPath))){
      execute(scan);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  protected abstract void execute(Scanner scan);
}
------------------------------------------------------------
OCL File:
---------
 class Main extends BaseExe {
  static   attribute maxSize : int := 1000000;
  static   attribute prime : Sequence(boolean) := Integer.subrange(1,maxSize)->collect(false);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().exeSysIn() );
      operation execute( scan : OclFile) : void
  pre: true
  post: true
  activity: (     execute setPrime() ; 
     var inData : String ; inData := "" ;
     while (scan.hasNextLine() & not("" = inData)) do (     out.println(primeCount((inData + "")->toInteger())) ) );
   operation setPrime() : void
  pre: true
  post: true
  activity: (     prime[2+1] := true ; 
         var i : int ; i := 3 ; while i < maxSize do ( (     if (i mod 2 = 0) then (     continue ) else skip ; 
     execute setOddPrime(i) )  ;     i := i + 1 ) );
   operation setOddPrime( i : int) : void
  pre: true
  post: true
  activity: (     var isPrime : boolean ; isPrime := true ;
         var j : int ; j := 1 ; while j <= (i)->sqrt() do ( (     if (prime[j+1] & i mod j = 0) then (     isPrime := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     prime[i+1] := if (isPrime) then true else false endif );
   operation primeCount( inData : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 2 ; while i <= inData do ( (     if (i /= 2 & i mod 2 = 0) then (     continue ) else skip ; 
         count := count + 1 ;
 count := if (prime[i+1]) then count else count endif  )  ;     i := i + 1 ) ; 
     return count );
}
class BaseExe {
   operation exeSysIn() : void
  pre: true
  post: true
  activity: (     try (    var scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     execute execute(scan) ))   catch (e : ProgramException) do (     e.printStackTrace() )
  );
   operation exeFileIn( inDataPath : String) : void
  pre: true
  post: true
  activity: (     try (    var scan : OclFile := OclFile.newOclFile_Read(OclFile(inDataPath)) ;
 (     execute execute(scan) ))   catch (e : ProgramException) do (     e.printStackTrace() )
  );
      operation execute( scan : OclFile) : void
  pre: true
  post: true;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  void AOJ0009(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int count=0 ;
      boolean[] prime=new boolean[n+1];
      Arrays.fill(prime,true);
      for(int i=2 ; i<=n ; i++){
        if(prime[i]){
          count++;
          for(int j=i+i ; j<=n ; j+=i)prime[j]=false ;
        }
      }
      System.out.println(count);
    }
  }
  ArrayList<Integer>Sieve(int n){
    ArrayList<Integer>prime=new ArrayList<Integer>();
    if(n<2)return prime ;
    boolean[] list=new boolean[n];
    Arrays.fill(list,true);
    list[1]=false ;
    for(int i=2 ; i<n ; i++){
      if(list[i]){
        prime.add(i);
        for(int j=i+i ; j<n ; j+=i)list[j]=false ;
      }
    }
    return prime ;
  }
  public static void main(String[] args){
    new Main().AOJ0009();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation AOJ0009() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var count : int ; count := 0 ;
    var prime : Sequence(boolean) ; prime := Integer.subrange(1,n + 1)->collect(false) ;
    prime := prime->collect(true) ; 
        var i : int ; i := 2 ; while i <= n do ( (     if (prime[i+1]) then (     count := count + 1 ; 
         var j : int ; j := i + i ; while j <= n do (     prime[j+1] := false ;  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
   operation Sieve( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var prime : Sequence(int) ; prime := Sequence{} ;
     if (n < 2) then     return prime else skip ; 
    var list : Sequence(boolean) ; list := Integer.subrange(1,n)->collect(false) ;
    list := list->collect(true) ; 
    list[1+1] := false ; 
        var i : int ; i := 2 ; while i < n do ( (     if (list[i+1]) then (     prime := prime->including(i) ; 
         var j : int ; j := i + i ; while j < n do (     list[j+1] := false ;  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    return prime 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().AOJ0009() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    boolean[] notPrime=new boolean[1000000];
    int[] counts=new int[1000000];
    for(int i=2 ; i<1000000 ; i++){
      counts[i]+=counts[i-1];
      if(notPrime[i]){
        continue ;
      }
      counts[i]++;
      for(int j=2 ; i*j<1000000 ; j++){
        notPrime[i*j]=true ;
      }
    }
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    while(true){
      String s=br.readLine();
      if(s==null){
        break ;
      }
      sb.append(counts[Integer.parseInt(s)]).append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var notPrime : Sequence(boolean) ; notPrime := Integer.subrange(1,1000000)->collect(false) ;
     var counts : Sequence(int) ; counts := Integer.subrange(1,1000000)->collect(0) ;
        var i : int ; i := 2 ; while i < 1000000 do ( (     counts[i+1] := counts[i+1]+(counts[i - 1+1]) ; 
     if (notPrime[i+1]) then (     continue ) else skip ; 
     counts[i+1] := counts[i+1] + 1 ; 
         var j : int ; j := 2 ; while i * j < 1000000 do ( (     notPrime[i * j+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var sb : String ; sb := StringLib.newString() ;
    while (true) do (     var s : String ; s := br.readLine() ;
     if (s = null) then (     break ) else skip ; 
     sb := sb + StringLib.newString(counts[(s)->toInteger()+1]) + StringLib.newString("\n") ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void survival(int S,int N,int M){
    if(((N*6)<(M*7)&& S>6)|| M>N)System.out.println("No");
    else {
      int days=(M*S)/N ;
      if(((M*S)% N)!=0)days++;
      System.out.println("Yes "+days);
    }
  }
  public static void main(String[] args){
    int S=10,N=16,M=2 ;
    survival(S,N,M);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation survival( S : int, N : int, M : int) : void
  pre: true
  post: true
  activity: (     if (((N * 6) < (M * 7) & S > 6) or M > N) then     OclFile["System.out"].println("No") ; else (     var days : int ; days := (M * S) / N ;
     if (((M * S) mod N) /= 0) then     days := days + 1 ; else skip ; 
     OclFile["System.out"].println("Yes " + days) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : int ; S := 10 ;
    var N : int ; N := 16 ;
    var M : int ; M := 2 ;
     execute survival(S, N, M) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.abs ;
import static java.lang.Math.pow ;
import static java.lang.System.*;
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static int[] freq=new int[1001];
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    int nums=Integer.parseInt(sc.next());
    char opened_bracet='(' ;
    char closed_bracket=')' ;
    int counter_open=0 ;
    int counter_close=0 ;
    for(int i=0 ; i<nums ; i++){
      String sen=sc.next();
      for(int j=0 ; j<sen.length(); j++){
        if(sen.charAt(j)==opened_bracet)counter_open++;
        if(sen.charAt(j)==closed_bracket)counter_close++;
      }
      if(sen.length()% 2==0 && counter_open==counter_close && sen.charAt(0)!=')' && sen.charAt(sen.length()-1)!='(')out.println("YES");
      else out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute freq : Sequence(int) := Integer.subrange(1,1001)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var nums : int ; nums := (sc.getCurrent())->toInteger() ;
    var opened_bracet : String ; opened_bracet := '(' ;
    var closed_bracket : String ; closed_bracket := ')' ;
    var counter_open : int ; counter_open := 0 ;
    var counter_close : int ; counter_close := 0 ;
        var i : int ; i := 0 ; while i < nums do ( (     var sen : String ; sen := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < sen->size() do ( (     if (sen->at(j+1) = opened_bracet) then     counter_open := counter_open + 1 ; else skip ; 
     if (sen->at(j+1) = closed_bracket) then     counter_close := counter_close + 1 ; else skip )  ;     j := j + 1 ) ; 
     if (sen->size() mod 2 = 0 & counter_open = counter_close & sen->at(0+1) /= ')' & sen->at(sen->size() - 1+1) /= '(') then     out.println("YES") ; else     out.println("NO") ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Scanner ;
public class Codeforces {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int tests=sc.nextInt();
    sc.nextLine();
    for(int t=0 ; t<tests ; t++){
      String str=sc.nextLine();
      String[] tab=str.split("");
      boolean correct=true ;
      if(tab[0] .contentEquals(")")){
        correct=false ;
      }
      if(tab.length % 2!=0){
        correct=false ;
      }
      if(tab[tab.length-1] .contentEquals("(")){
        correct=false ;
      }
      if(correct){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tests : int ; tests := sc.getCurrent()->toInteger() ;
     skip ; 
         var t : int ; t := 0 ; while t < tests do ( (     var str : String ; str := sc.nextLine() ;
     var tab : Sequence(String) ; tab := str->split("") ;
    var correct : boolean ; correct := true ;
    if (tab[0+1] = (")" + "")) then (     correct := false ) else skip ; 
    if (tab->size() mod 2 /= 0) then (     correct := false ) else skip ; 
    if (tab[tab->size() - 1+1] = ("(" + "")) then (     correct := false ) else skip ; 
    if (correct) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws Exception {
    try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in))){
      Integer numDataSet=0 ;
      String[] data ;
      Integer numStudent ;
      Integer numSubject ;
      Integer[] total ;
      String[] point ;
      Integer max ;
      Integer[] result=new Integer[100];
      while(true){
        data=reader.readLine().split(" ");
        numStudent=Integer.parseInt(data[0]);
        numSubject=Integer.parseInt(data[1]);
        if(numStudent==0 && numSubject==0)break ;
        total=new Integer[numStudent];
        for(int i=0 ; i<numSubject ; i++){
          point=reader.readLine().split(" ");
          for(int j=0 ; j<numStudent ; j++){
            if(i==0)total[j]=Integer.parseInt(point[j]);
            else total[j]+=Integer.parseInt(point[j]);
          }
        }
        max=total[0];
        for(int i=1 ; i<total.length ; i++){
          int val=total[i];
          if(val>max)max=val ;
        }
        result[numDataSet]=max ;
        numDataSet++;
      }
      for(int i=0 ; i<numDataSet ; i++){
        System.out.println(result[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var numDataSet : int ; numDataSet := 0 ;
     var data : Sequence(String) ;
    var numStudent : int ;
    var numSubject : int ;
    var total : Sequence(int) ;
    var point : Sequence(String) ;
    var max : int ;
    var result : Sequence(int) ; result := Integer.subrange(1,100)->collect(null) ;
    while (true) do (     data := reader.readLine()->split(" ") ; 
     numStudent := (data[0+1])->toInteger() ; 
    numSubject := (data[1+1])->toInteger() ; 
    if (numStudent = 0 & numSubject = 0) then     break else skip ; 
    total := Integer.subrange(1,numStudent)->collect(null) ; 
        var i : int ; i := 0 ; while i < numSubject do ( (     point := reader.readLine()->split(" ") ; 
         var j : int ; j := 0 ; while j < numStudent do ( (     if (i = 0) then     total[j+1] := (point[j+1])->toInteger() ; else     total[j+1] := total[j+1]+((point[j+1])->toInteger()) ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    max := total[0+1] ; 
        var i : int ; i := 1 ; while i < total->size() do ( (     var val : int ; val := total[i+1] ;
     if (val > max) then     max := val ; else skip )  ;     i := i + 1 ) ; 
    result[numDataSet+1] := max ; 
    numDataSet := numDataSet + 1 ; 
 ) ; 
        var i : int ; i := 0 ; while i < numDataSet do ( (     OclFile["System.out"].println(result[i+1]) )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class cf1469A {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    while(t-->0){
      String s=scan.next();
      if(s.length()% 2==0 && s.charAt(0)!=')' && s.charAt(s.length()-1)!='('){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1469A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : String ; s := scan.getCurrent() ;
     if (s->size() mod 2 = 0 & s->at(0+1) /= ')' & s->at(s->size() - 1+1) /= '(') then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      String s=sc.next();
      char arr[]=s.toCharArray();
      int n=s.length();
      if(n % 2!=0 || arr[0]==')' || arr[n-1]=='('){
        System.out.println("NO");
        continue ;
      }
      else System.out.println("YES");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : String ; s := sc.getCurrent() ;
     var arr : Sequence(String) ; arr := s->characters() ;
     var n : int ; n := s->size() ;
     if (n mod 2 /= 0 or arr[0+1] = ')' or arr[(n)->char2byte() - 1+1] = '(') then (     OclFile["System.out"].println("NO") ; 
     continue ) else     OclFile["System.out"].println("YES") ; ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=false ;
  private static PrintWriter _out=new PrintWriter(System.out);
  private static PrintWriter _err=new PrintWriter(System.err);
  private void solve(Scanner sc){
    long N=sc.nextLong();
    long X=sc.nextLong();
    _out.println((3*(N-gcd(N,X))));
  }
  private static long gcd(long a,long b){
    if(a<b){
      return gcd(b,a);
    }
    if(b==0){
      return a ;
    }
    return gcd(b,a % b);
  }
  private static BigInteger C(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    for(long i=r ; i>1 ; --i){
      res=res.divide(BigInteger.valueOf(i));
    }
    return res ;
  }
  private static BigInteger P(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    return res ;
  }
  public static void main(String[] args){
    long S=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    new Main().solve(sc);
    _out.flush();
    long G=System.currentTimeMillis();
    if(elapsed){
      _err.println((G-S)+"ms");
    }
    _err.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := false;
  static   attribute _out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute _err : OclFile := OclFile.newOclFile_Write(OclFile["System.err"]);
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var N : long ; N := sc.nextLong() ;
     var X : long ; X := sc.nextLong() ;
     skip );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a < b) then (     return gcd(b, a) ) else skip ; 
     if (b = 0) then (     return a ) else skip ; 
     return gcd(b, a mod b) );
  static   operation C( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
         var i : long ; i := r ; while i > 1 do ( (     res := res.divide((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation P( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    Main.newMain().solve(sc) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Longest_common_prefix {
  static final int ALPHABET_SIZE=26 ;
  static class TrieNode {
    TrieNode[] children=new TrieNode[ALPHABET_SIZE];
    boolean isLeaf ;
    public TrieNode(){
      isLeaf=false ;
      for(int i=0 ; i<ALPHABET_SIZE ; i++)children[i]=null ;
    }
  };
  static TrieNode root ;
  static int indexs ;
  static void insert(String key){
    int length=key.length();
    int index ;
    TrieNode pCrawl=root ;
    for(int level=0 ; level<length ; level++){
      index=key.charAt(level)-'a' ;
      if(pCrawl.children[index]==null)pCrawl.children[index]=new TrieNode();
      pCrawl=pCrawl.children[index];
    }
    pCrawl.isLeaf=true ;
  }
  static int countChildren(TrieNode node){
    int count=0 ;
    for(int i=0 ; i<ALPHABET_SIZE ; i++){
      if(node.children[i]!=null){
        count++;
        indexs=i ;
      }
    }
    return(count);
  }
  static String walkTrie(){
    TrieNode pCrawl=root ;
    indexs=0 ;
    String prefix="" ;
    while(countChildren(pCrawl)==1 && pCrawl.isLeaf==false){
      pCrawl=pCrawl.children[indexs];
      prefix+=(char)('a'+indexs);
    }
    return prefix ;
  }
  static void constructTrie(String arr[],int n){
    for(int i=0 ; i<n ; i++)insert(arr[i]);
    return ;
  }
  static String commonPrefix(String arr[],int n){
    root=new TrieNode();
    constructTrie(arr,n);
    return walkTrie();
  }
  public static void main(String args[]){
    String arr[]={
      "geeksforgeeks","geeks","geek","geezer" };
      int n=arr.length ;
      String ans=commonPrefix(arr,n);
      if(ans.length()!=0)System.out.println("The longest common prefix is "+ans);
      else System.out.println("There is no common prefix");
    }
  }

------------------------------------------------------------
OCL File:
---------
class Longest_common_prefix {
  static    attribute ALPHABET_SIZE : int := 26;
  static class TrieNode {
   attribute children : Sequence(TrieNode) := Integer.subrange(1,ALPHABET_SIZE)->collect(null);
   attribute isLeaf : boolean;
   static operation newTrieNode() : TrieNode
  pre: true
  post: true
  activity:
  ( var self : TrieNode ;
    self := createTrieNode();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     isLeaf := false ; 
         var i : int ; i := 0 ; while i < ALPHABET_SIZE do (     children[i+1] := null ;  ;     i := i + 1 ) );
}
  static   attribute root : TrieNode;
  static   attribute indexs : int;
  static   operation insert( key : String) : void
  pre: true
  post: true
  activity: (     var length : int ; length := key->size() ;
     var index : int ;
    var pCrawl : TrieNode ; pCrawl := root ;
        var level : int ; level := 0 ; while level < length do ( (     index := key->at(level+1) - ('a')->char2byte() ; 
     if (pCrawl.children[index+1] = null) then     pCrawl.children[index+1] := TrieNode.newTrieNode() ; else skip ; 
     pCrawl := pCrawl.children[index+1] )  ;     level := level + 1 ) ; 
    pCrawl.isLeaf := true ; 
 );
  static   operation countChildren( node : TrieNode) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < ALPHABET_SIZE do ( (     if (node.children[i+1] /= null) then (     count := count + 1 ; 
     indexs := i ) else skip )  ;     i := i + 1 ) ; 
     return (count) );
  static   operation walkTrie() : String
  pre: true
  post: true
  activity: (     var pCrawl : TrieNode ; pCrawl := root ;
     indexs := 0 ; 
    var prefix : String ; prefix := "" ;
    while (countChildren(pCrawl) = 1 & pCrawl.isLeaf = false) do (     pCrawl := pCrawl.children[indexs+1] ; 
     prefix := prefix+(('a' + indexs)->oclAsType(String)) ) ; 
    return prefix 
 );
  static   operation constructTrie( arr : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     execute insert(arr[i+1]) ;  ;     i := i + 1 ) ; 
     return );
  static   operation commonPrefix( arr : Sequence(String), n : int) : String
  pre: true
  post: true
  activity: (     root := TrieNode.newTrieNode() ; 
     execute constructTrie(arr, n) ; 
     return walkTrie() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"geeksforgeeks","geeks","geek","geezer"} ;
     var n : int ; n := arr->size() ;
     var ans : String ; ans := commonPrefix(arr, n) ;
     if (ans->size() /= 0) then     OclFile["System.out"].println("The longest common prefix is " + ans) ; else     OclFile["System.out"].println("There is no common prefix") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  static boolean[] arr ;
  public static void main(String[] args)throws Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(reader.readLine());
    char[] str=reader.readLine().toCharArray();
    arr=new boolean[n];
    for(int i=0 ; i<n ; i++)arr[i]=str[i]=='o' ;
    boolean[] animal=new boolean[n+1];
    animal[0]=true ;
    animal[1]=true ;
    if(calc(animal))return ;
    animal[0]=false ;
    animal[1]=false ;
    if(calc(animal))return ;
    animal[0]=true ;
    animal[1]=false ;
    if(calc(animal))return ;
    animal[0]=false ;
    animal[1]=true ;
    if(calc(animal))return ;
    System.out.println(-1);
  }
  static boolean calc(boolean[] animal){
    for(int i=0 ; i<animal.length-2 ; i++){
      animal[i+2]=!(animal[i+1] ^ !(animal[i] ^ arr[i+1]));
    }
    boolean result=animal[animal.length-1]==animal[0];
    boolean last=!(animal[0] ^ !(animal[1] ^ arr[0]));
    result &=last==animal[animal.length-2];
    if(result){
      StringBuilder sb=new StringBuilder();
      for(int i=0 ; i<animal.length-1 ; i++)sb.append((animal[i])? 'S' : 'W');
      System.out.println(sb.toString());
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute arr : Sequence(boolean);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (reader.readLine())->toInteger() ;
    var str : Sequence(String) ; str := reader.readLine()->characters() ;
    arr := Integer.subrange(1,n)->collect(false) ; 
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := str[i+1] = 'o' ;  ;     i := i + 1 ) ; 
    var animal : Sequence(boolean) ; animal := Integer.subrange(1,n + 1)->collect(false) ;
    animal[0+1] := true ; 
    animal[1+1] := true ; 
    if (calc(animal)) then     return else skip ; 
    animal[0+1] := false ; 
    animal[1+1] := false ; 
    if (calc(animal)) then     return else skip ; 
    animal[0+1] := true ; 
    animal[1+1] := false ; 
    if (calc(animal)) then     return else skip ; 
    animal[0+1] := false ; 
    animal[1+1] := true ; 
    if (calc(animal)) then     return else skip ; 
    OclFile["System.out"].println(-1) ; 
 );
  static   operation calc( animal : Sequence(boolean)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < animal->size() - 2 do ( (     animal[i + 2+1] := not((animal[i + 1+1] xor not((animal[i+1] xor arr[i + 1+1])))) )  ;     i := i + 1 ) ; 
     var result : boolean ; result := animal[animal->size() - 1+1] = animal[0+1] ;
    var last : boolean ; last := not((MathLib.bitwiseXor(animal[0+1],not((MathLib.bitwiseXor(animal[1+1],arr[0+1])))))) ;
    result := MathLib.bitwiseAnd(result, last = animal[animal->size() - 2+1]) ; 
    if (result) then (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < animal->size() - 1 do (     sb := sb + StringLib.newString(if (animal[i+1]) then 'S' else 'W' endif) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sb+"") ) else skip ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String str=sc.next();
    boolean[] s=new boolean[n];
    for(int i=0 ; i<n ; i++){
      s[i]=str.charAt(i)=='o' ;
    }
    next : for(int i=0 ;
    i<4 ;
    i++){
      boolean[] t=new boolean[n];
      switch(i){
        case 0 : t[0]=true ;
        t[1]=true ;
        break ;
        case 1 : t[0]=true ;
        t[1]=false ;
        break ;
        case 2 : t[0]=false ;
        t[1]=true ;
        break ;
        case 3 : t[0]=false ;
        t[1]=false ;
        break ;
      }
      for(int j=2 ; j<n ; j++){
        t[j]=(t[j-1]==s[j-1])==t[j-2];
      }
      StringBuilder sb=new StringBuilder();
      if((s[0]==t[0])!=(t[n-1]==t[1])){
        continue next ;
      }
      sb.append(t[0] ? "S" : "W");
      for(int j=1 ; j<n-1 ; j++){
        if((s[j]==t[j])!=(t[j-1]==t[j+1])){
          continue next ;
        }
        sb.append(t[j] ? "S" : "W");
      }
      if((s[n-1]==t[n-1])!=(t[n-2]==t[0])){
        continue next ;
      }
      sb.append(t[n-1] ? "S" : "W");
      System.out.println(sb.toString());
      return ;
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var str : String ; str := sc.getCurrent() ;
    var s : Sequence(boolean) ; s := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := str->at(i+1) = 'o' )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 4 do ( (     var t : Sequence(boolean) ; t := Integer.subrange(1,n)->collect(false) ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (i) ; 
       if _switchval = 0 then
     t[0+1] := true ; 
    t[1+1] := true ; 
    break 
   else skip ;
       if _switchval = 1 then
     t[0+1] := true ; 
    t[1+1] := false ; 
    break 
   else skip ;
       if _switchval = 2 then
     t[0+1] := false ; 
    t[1+1] := true ; 
    break 
   else skip ;
       if _switchval = 3 then
     t[0+1] := false ; 
    t[1+1] := false ; 
    break 
   else skip ;
 )
        var j : int ; j := 2 ; while j < n do ( (     t[j+1] := (t[j - 1+1] = s[j - 1+1]) = t[j - 2+1] )  ;     j := j + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    if ((s[0+1] = t[0+1]) /= (t[n - 1+1] = t[1+1])) then (     continue ) else skip ; 
    sb := sb + StringLib.newString(if t[0+1] then "S" else "W" endif) ; 
        var j : int ; j := 1 ; while j < n - 1 do ( (     if ((s[j+1] = t[j+1]) /= (t[(j)->char2byte() - 1+1] = t[j + 1+1])) then (     continue ) else skip ; 
     sb := sb + StringLib.newString(if t[j+1] then "S" else "W" endif) )  ;     j := j + 1 ) ; 
    if ((s[n - 1+1] = t[n - 1+1]) /= (t[n - 2+1] = t[0+1])) then (     continue ) else skip ; 
    sb := sb + StringLib.newString(if t[n - 1+1] then "S" else "W" endif) ; 
    OclFile["System.out"].println(sb+"") ; 
    return 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  final static boolean S=true ;
  final static boolean W=false ;
  public static void main(String[] args){
    try(Scanner scan=new Scanner(System.in)){
      int N=scan.nextInt();
      scan.nextLine();
      String s=scan.nextLine();
      boolean[] ans=new boolean[N+1];
      boolean[][] init={
        {
          S,S },{
            S,W },{
              W,S },{
                W,W }
              };
              for(int i=0 ; i<4 ; i++){
                ans[0]=init[i][0];
                ans[1]=init[i][1];
                for(int j=1 ; j<N ; j++){
                  boolean a=true ;
                  if(s.charAt(j)=='x'){
                    a=false ;
                  }
                  boolean hanten=a ^ ans[j];
                  if(hanten){
                    ans[j+1]=! ans[j-1];
                  }
                  else {
                    ans[j+1]=ans[j-1];
                  }
                }
                boolean b=S ;
                boolean a=true ;
                if(s.charAt(0)=='x'){
                  a=false ;
                }
                boolean hanten=a ^ ans[0];
                if(hanten){
                  b=! ans[N-1];
                }
                else {
                  b=ans[N-1];
                }
                if((ans[0]==ans[N])&&(ans[1]==b)){
                  for(int j=0 ; j<N ; j++){
                    String c=ans[j] ? "S" : "W" ;
                    System.out.print(c);
                  }
                  System.out.println();
                  return ;
                }
              }
              System.out.println(-1);
            }
          }
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute S : boolean := true;
  static   attribute W : boolean := false;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := scan.getCurrent()->toInteger() ;
     skip ; 
    var s : String ; s := scan.nextLine() ;
    var ans : Sequence(boolean) ; ans := Integer.subrange(1,N + 1)->collect(false) ;
    var init : Sequence(Sequence(boolean)) ; init := Sequence{Sequence{S,S},Sequence{S,W},Sequence{W,S},Sequence{W,W}} ;
        var i : int ; i := 0 ; while i < 4 do ( (     ans[0+1] := init[i+1][0+1] ; 
     ans[1+1] := init[i+1][1+1] ; 
        var j : int ; j := 1 ; while j < N do ( (     var a : boolean ; a := true ;
     if (s->at(j+1) = 'x') then (     a := false ) else skip ; 
     var hanten : boolean ; hanten := MathLib.bitwiseXor(a,ans[j+1]) ;
     if (hanten) then (     ans[j + 1+1] := not(ans[j - 1+1]) ) else (     ans[j + 1+1] := ans[j - 1+1] ) )  ;     j := j + 1 ) ; 
    var b : boolean ; b := S ;
    var a : boolean ; a := true ;
    if (s->at(0+1) = 'x') then (     a := false ) else skip ; 
    var hanten : boolean ; hanten := MathLib.bitwiseXor(a,ans[0+1]) ;
    if (hanten) then (     b := not(ans[N - 1+1]) ) else (     b := ans[N - 1+1] ) ;  
    if ((ans[0+1] = ans[N+1]) & (ans[1+1] = b)) then (         var j : int ; j := 0 ; while j < N do ( (     var c : String ; c := if ans[j+1] then "S" else "W" endif ;
     OclFile["System.out"].print(c) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() ; 
     return ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(-1) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] $){
    int n=scanner.nextInt();
    String s=scanner.next();
    for(int i=0 ; i<4 ; i++){
      boolean[] a=new boolean[n+2];
      a[0]=(i & 1)==0 ;
      a[1]=(i & 2)==0 ;
      for(int j=0 ; j<n ; j++){
        a[j+2]=a[j] ^ a[j+1] ^ s.charAt(j)=='o' ;
      }
      if(a[0]==a[n] && a[1]==a[n+1]){
        for(int j=1 ; j<=n ; j++){
          System.out.print(a[j] ? "S" : "W");
        }
        System.out.println();
        return ;
      }
    }
    System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var s : String ; s := scanner.getCurrent() ;
         var i : int ; i := 0 ; while i < 4 do ( (     var a : Sequence(boolean) ; a := Integer.subrange(1,n + 2)->collect(false) ;
     a[0+1] := (MathLib.bitwiseAnd(i,1)) = 0 ; 
    a[1+1] := (MathLib.bitwiseAnd(i,2)) = 0 ; 
        var j : int ; j := 0 ; while j < n do ( (     a[j + 2+1] := a[j+1] xor a[j + 1+1] xor s->at(j+1) = 'o' )  ;     j := j + 1 ) ; 
    if (a[0+1] = a[n+1] & a[1+1] = a[n + 1+1]) then (         var j : int ; j := 1 ; while j <= n do ( (     OclFile["System.out"].print(if a[j+1] then "S" else "W" endif) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() ; 
     return ) else skip ; 
 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(-1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static final Integer ZERO=Integer.valueOf(0);
  Scanner sc ;
  int N,K ;
  HashMap<Long,Integer>h ;
  long[] S ;
  private void calc(){
    sc=new Scanner(System.in);
    N=sc.nextInt();
    K=sc.nextInt();
    S=new long[N+1];
    h=new HashMap<>(N*4/3);
    S[0]=0 ;
    for(int i=1 ; i<N+1 ; i++)S[i]=(S[i-1]+(sc.nextInt()-1))% K ;
    long cnt=0 ;
    for(int i=1 ; i<N+1 ; i++){
      long r=S[i-1];
      h.put(r,h.getOrDefault(r,ZERO)+1);
      if(i>=K){
        r=S[i-K];
        int v=h.get(r);
        if(v>1)h.put(r,v-1);
        else h.remove(r);
      }
      cnt+=h.getOrDefault(S[i] % K,ZERO);
    }
    System.out.println(cnt);
  }
  public static void main(String[] args){
    new Main().calc();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute ZERO : int := (0)->toInteger();
   attribute sc : OclFile;
   attribute N : int;
   attribute h : Map(long,int);
   attribute S : Sequence(long);
   operation calc() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     N := sc.getCurrent()->toInteger() ; 
    K := sc.getCurrent()->toInteger() ; 
    S := Integer.subrange(1,N + 1)->collect(0) ; 
    h := Map{}->union(N * 4 / 3) ; 
    S[0+1] := 0 ; 
        var i : int ; i := 1 ; while i < N + 1 do (     S[i+1] := (S[i - 1+1] + (sc.getCurrent()->toInteger() - 1)) mod K ;  ;     i := i + 1 ) ; 
    var cnt : long ; cnt := 0 ;
        var i : int ; i := 1 ; while i < N + 1 do ( (     var r : long ; r := S[i - 1+1] ;
     h := h->union(Map{r |-> (if h->keys()->contains(r) then h->at(r) else ZERO endif) + 1}) ; 
     if (i >= K) then (     r := S[i - K+1] ; 
     var v : int ; v := h->at(r) ;
     if (v > 1) then     h := h->union(Map{r |-> v - 1}) ; else     h := h->antirestrict(Set{r}) ; ) else skip ; 
     cnt := cnt+((if h->keys()->contains(S[i+1] mod K) then h->at(S[i+1] mod K) else ZERO endif)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().calc() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.HashMap ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ERemOfSumIsNum solver=new ERemOfSumIsNum();
    solver.solve(1,in,out);
    out.close();
  }
  static class ERemOfSumIsNum {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int k=in.nextInt();
      int[] acc=new int[n+1];
      long res=0 ;
      for(int i=1 ; i<=n ; i++){
        acc[i]=(acc[i-1]+(in.nextInt()-1))% k ;
      }
      HashMap<Integer,Integer>hm=new HashMap<>();
      for(int i=0 ; i<Math.min(n+1,k); i++){
        hm.merge(acc[i],1,Integer :: sum);
      }
      for(Integer i : hm.keySet()){
        res+=(long)hm.get(i)*(long)(hm.get(i)-1)/2 ;
      }
      for(int i=k ; i<=n ; i++){
        hm.merge(acc[i-k],-1,Integer :: sum);
        if(hm.containsKey(acc[i])){
          res+=hm.get(acc[i]);
        }
        hm.merge(acc[i],1,Integer :: sum);
      }
      out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ERemOfSumIsNum ; solver := ERemOfSumIsNum.newERemOfSumIsNum() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ERemOfSumIsNum {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var acc : Sequence(int) ; acc := Integer.subrange(1,n + 1)->collect(0) ;
    var res : long ; res := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     acc[i+1] := (acc[i - 1+1] + (in.getCurrent()->toInteger() - 1)) mod k )  ;     i := i + 1 ) ; 
    var hm : Map(int,int) ; hm := Map{} ;
        var i : int ; i := 0 ; while i < Set{n + 1, k}->min() do ( (     hm := hm.merge(acc[i+1], 1, lambda _pars : OclAny in Integer.newInteger().sum(_pars)) )  ;     i := i + 1 ) ; 
    for (i : hm->keys()) do ( (     res := res+(hm->at(i)->oclAsType(long) * (hm->at(i) - 1)->oclAsType(long) / 2) )  ) ; 
        var i : int ; i := k ; while i <= n do ( (     hm := hm.merge(acc[i - k+1], -1, lambda _pars : OclAny in Integer.newInteger().sum(_pars)) ; 
     if (hm->keys()->includes(acc[i+1])) then (     res := res+(hm->at(acc[i+1])) ) else skip ; 
     hm := hm.merge(acc[i+1], 1, lambda _pars : OclAny in Integer.newInteger().sum(_pars)) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    while(in.hasNextLine()){
      int N=in.nextInt();
      int M=in.nextInt();
      if(N==0 && M==0)break ;
      int[] arr=new int[N];
      int max=-99 ;
      for(int m=0 ; m<M ; m++){
        for(int n=0 ; n<N ; n++){
          arr[n]+=in.nextInt();
          if(m==M-1){
            max=Math.max(max,arr[n]);
          }
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNextLine()) do (     var N : int ; N := in.getCurrent()->toInteger() ;
     var M : int ; M := in.getCurrent()->toInteger() ;
    if (N = 0 & M = 0) then     break else skip ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
    var max : int ; max := -99 ;
        var m : int ; m := 0 ; while m < M do ( (         var n : int ; n := 0 ; while n < N do ( (     arr[n+1] := arr[n+1]+(in.getCurrent()->toInteger()) ; 
     if (m = M - 1) then (     max := Set{max, arr[n+1]}->max() ) else skip )  ;     n := n + 1 ) )  ;     m := m + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long k=sc.nextLong();
    long[] a=new long[n];
    long[] sum=new long[n+1];
    HashMap<Long,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
      sum[i+1]=(sum[i]+a[i]-1+k)% k ;
    }
    long ans=0 ;
    int j=0 ;
    for(int i=0 ; i<=n ; i++){
      if(i-j==k){
        map.put(sum[j],map.get(sum[j])-1);
        j++;
      }
      if(map.containsKey(sum[i])){
        ans+=map.get(sum[i]);
        map.put(sum[i],map.get(sum[i])+1);
      }
      else {
        map.put(sum[i],1);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : Sequence(long) ; sum := Integer.subrange(1,n + 1)->collect(0) ;
    var map : Map(long,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() ; 
     sum[i + 1+1] := (sum[i+1] + a[i+1] - 1 + k) mod k )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i <= n do ( (     if (i - j = k) then (     map := map->union(Map{sum[j+1] |-> map->at(sum[j+1]) - 1}) ; 
     j := j + 1 ) else skip ; 
     if (map->keys()->includes(sum[i+1])) then (     ans := ans+(map->at(sum[i+1])) ; 
     map := map->union(Map{sum[i+1] |-> map->at(sum[i+1]) + 1}) ) else (     map := map->union(Map{sum[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int K=scanner.nextInt();
    int[] a=new int[N+1];
    for(int i=0 ; i<N ; i++)a[i+1]=scanner.nextInt();
    for(int i=1 ; i<=N ; i++){
      a[i]+=a[i-1];
      a[i] %=K ;
    }
    for(int i=1 ; i<=N ; i++){
      a[i]-=i % K ;
      if(a[i]<0)a[i]+=K ;
    }
    long count=0 ;
    HashMap<Integer,Integer>freq=new HashMap<>();
    for(int i=0 ; i<=N ; i++){
      count+=freq.getOrDefault(a[i],0);
      freq.put(a[i],freq.getOrDefault(a[i],0)+1);
      if(i>=K-1)freq.put(a[i-K+1],freq.get(a[i-K+1])-1);
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var K : int ; K := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     a[i + 1+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (     a[i+1] := a[i+1]+(a[i - 1+1]) ; 
     a[i+1] := a[i+1] mod K )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (     a[i+1] := a[i+1]-(i mod K) ; 
     if (a[i+1] < 0) then     a[i+1] := a[i+1]+(K) ; else skip )  ;     i := i + 1 ) ; 
    var count : long ; count := 0 ;
    var freq : Map(int,int) ; freq := Map{} ;
        var i : int ; i := 0 ; while i <= N do ( (     count := count+((if freq->keys()->contains(a[i+1]) then freq->at(a[i+1]) else 0 endif)) ; 
     freq := freq->union(Map{a[i+1] |-> (if freq->keys()->contains(a[i+1]) then freq->at(a[i+1]) else 0 endif) + 1}) ; 
     if (i >= K - 1) then     freq := freq->union(Map{a[i - K + 1+1] |-> freq->at(a[i - K + 1+1]) - 1}) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt(),K=sc.nextInt();
    int A[]=new int[N];
    for(int i=0 ; i<N ; i++)A[i]=sc.nextInt();
    sc.close();
    int sum[]=new int[N+1];
    sum[0]=0 ;
    for(int i=0 ; i<N ; i++)sum[i+1]=(int)((long)sum[i]+A[i])% K ;
    int T[]=new int[N+1];
    for(int i=0 ; i<N+1 ; i++){
      T[i]=(sum[i]-i)% K ;
      if(T[i]<0)T[i]+=K ;
    }
    Map<Integer,Integer>map=new HashMap();
    long ans=0 ;
    Queue<Integer>q=new ArrayDeque();
    for(int j=0 ; j<N+1 ; j++){
      int cnt=0 ;
      if(map.containsKey(T[j])){
        cnt=map.get(T[j]);
        ans+=cnt ;
      }
      map.put(T[j],++cnt);
      q.offer(T[j]);
      while(q.size()>=K){
        int rm=q.poll();
        map.put(rm,map.get(rm)-1);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     A[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    skip ; 
    var sum : Sequence(int) ; sum := Integer.subrange(1,N + 1)->collect(0) ;
    sum[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < N do (     sum[i + 1+1] := (sum[i+1]->oclAsType(long) + A[i+1])->oclAsType(int) mod K ;  ;     i := i + 1 ) ; 
    var T : Sequence(int) ; T := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N + 1 do ( (     T[i+1] := (sum[i+1] - i) mod K ; 
     if (T[i+1] < 0) then     T[i+1] := T[i+1]+(K) ; else skip )  ;     i := i + 1 ) ; 
    var map : Map(int,int) ; map := Map{} ;
    var ans : long ; ans := 0 ;
    var q : Sequence(int) ; q := Sequence{} ;
        var j : int ; j := 0 ; while j < N + 1 do ( (     var cnt : int ; cnt := 0 ;
     if (map->keys()->includes(T[j+1])) then (     cnt := map->at(T[j+1]) ; 
     ans := ans+(cnt) ) else skip ; 
    map := map->union(Map{T[j+1] |-> (cnt + 1)}) ; 
    q := q->including(T[j+1]) ; 
    while (q->size() >= K) do (     var rm : int ; rm := q->min() ;
     map := map->union(Map{rm |-> map->at(rm) - 1}) ) ; 
 )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long num=sc.nextLong();
    long start=sc.nextLong();
    System.out.println(num+cal(start,num-start));
  }
  public static long cal(long width,long height){
    if(width*height==0){
      return-Math.max(width,height);
    }
    else if(width==height){
      return width ;
    }
    else if(width>height){
      return width/height*height*2+cal(width % height,height);
    }
    else {
      return height/width*width*2+cal(width,height % width);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : long ; num := sc.getCurrent()->toLong() ;
     var start : long ; start := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println(num + cal(start, num - start)) );
  static   operation cal( width : long, height : long) : long
  pre: true
  post: true
  activity: (     if (width * height = 0) then (     return -Set{width, height}->max() ) else     if (width = height) then (     return width ) else     if (width > height) then (     return width / height * height * 2 + cal(width mod height, height) ) else (     return height / width * width * 2 + cal(width, height mod width) ) ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt(),k=sc.nextInt(),c=0 ;
    if(n<k){
      out.print(n+k);
      out.close();
    }
    else {
      for(int i=k-1 ; i>=1 ; i--){
        if(n % i==0){
          c=i ;
        }
        if(c!=0)break ;
      }
      out.print((k*n/c)+c);
    }
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream system){
      br=new BufferedReader(new InputStreamReader(system));
    }
    public Scanner(String file)throws Exception {
      br=new BufferedReader(new FileReader(file));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public char nextChar()throws IOException {
      return next().charAt(0);
    }
    public Long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
    public void waitForInput()throws InterruptedException {
      Thread.sleep(3000);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
    if (n < k) then (     skip ; 
     skip ) else (         var i : int ; i := k - 1 ; while i >= 1 do ( (     if (n mod i = 0) then (     c := i ) else skip ; 
     if (c /= 0) then     break else skip )  ;     i := i - 1 ) ; 
     skip ) ;  
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( system : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(system);
    return self );
  operation initialise( system : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(system)) );
   static operation newScanner( file : String) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextChar() : String
  pre: true
  post: true
  activity: (     return next()->at(0+1) );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
   operation waitForInput() : void
  pre: true
  post: true
  activity: (     OclProcess.sleep(3000) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DivMod {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),k=in.nextInt();
    int min=Integer.MAX_VALUE ;
    int x ;
    if(n==0)System.out.println(k);
    else {
      for(int i=1 ; i<k ; i++){
        if(n % i==0){
          int a=n/i ;
          x=a*k+i ;
          if(x<min)min=x ;
        }
      }
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class DivMod {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var min : int ; min := 2147483647 ;
    var x : int ;
    if (n = 0) then     OclFile["System.out"].println(k) else (         var i : int ; i := 1 ; while i < k do ( (     if (n mod i = 0) then (     var a : int ; a := n / i ;
     x := a * k + i ; 
     if (x < min) then     min := x ; else skip ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(min) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int k=s.nextInt();
    int p=k ;
    int i=2 ;
    while(n>=k){
      while(n % i!=0){
        i++;
      }
      if(n/i<k){
        n=n/i ;
        p=p*i ;
      }
      i++;
    }
    System.out.println(p+n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var k : int ; k := s.getCurrent()->toInteger() ;
    var p : int ; p := k ;
    var i : int ; i := 2 ;
    while (n >= k) do (     while (n mod i /= 0) do (     i := i + 1 ) ; 
     if (n / i < k) then (     n := n / i ; 
     p := p * i ) else skip ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println(p + n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Random ;
import java.util.Scanner ;
public class C {
  static Scanner sc=new Scanner(System.in);
  static class Solver {
    int N ;
    int[] x ;
    void solve(){
      N=sc.nextInt();
      x=new int[N-1];
      for(int i=0 ; i<N-1 ; ++i){
        x[i]=sc.nextInt()-1 ;
      }
      for(int i=0 ; i<N-1 ; ++i){
        for(int j=0 ; j<i ; ++j){
          if(x[j]>i && x[j]<x[i]){
            System.out.println("Impossible");
            return ;
          }
        }
      }
      int[] h=new int[N];
      Random rand=new Random();
      while(true){
        for(int i=0 ; i<N ; ++i){
          h[i]=rand.nextInt(100000000+1);
        }
        boolean success=true ;
        for(int i=0 ; i<N-1 ; ++i){
          double slopeMax=Integer.MIN_VALUE ;
          double mi=0 ;
          for(int j=i+1 ; j<N ; ++j){
            double slope=1.0*(h[j]-h[i])/(j-i);
            if(slope>slopeMax){
              slopeMax=slope ;
              mi=j ;
            }
          }
          if(mi!=x[i]){
            success=false ;
            break ;
          }
        }
        if(success){
          for(int i=0 ; i<N ; ++i){
            System.out.print(h[i]);
            if(i!=N-1){
              System.out.print(" ");
            }
          }
          System.out.println();
          return ;
        }
      }
    }
  }
  public static void main(String[] args){
    int T=sc.nextInt();
    for(int i=1 ; i<=T ; ++i){
      System.out.print("Case #"+i+": ");
      Solver solver=new Solver();
      solver.solve();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static class Solver {
   attribute N : int;
   attribute x : Sequence(int);
   operation solve() : void
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     x := Integer.subrange(1,N - 1)->collect(0) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (     x[i+1] := sc.getCurrent()->toInteger() - 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N - 1 do ( (         var j : int ; j := 0 ; while j < i do ( (     if (x[j+1] > i & x[j+1] < x[i+1]) then (     OclFile["System.out"].println("Impossible") ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var h : Sequence(int) ; h := Integer.subrange(1,N)->collect(0) ;
    var rand : OclRandom ; rand := OclRandom.newOclRandom() ;
    while (true) do (         var i : int ; i := 0 ; while i < N do ( (     h[i+1] := rand.nextInt(100000000 + 1) )  ;     i := i + 1 ) ; 
     var success : boolean ; success := true ;
         var i : int ; i := 0 ; while i < N - 1 do ( (     var slopeMax : double ; slopeMax := -2147483648 ;
     var mi : double ; mi := 0 ;
         var j : int ; j := i + 1 ; while j < N do ( (     var slope : double ; slope := 1.0 * (h[j+1] - h[i+1]) / (j - i) ;
     if (slope > slopeMax) then (     slopeMax := slope ; 
     mi := j ) else skip )  ;     j := j + 1 ) ; 
     if (mi /= x[i+1]) then (     success := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (success) then (         var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].print(h[i+1]) ; 
     if (i /= N - 1) then (     OclFile["System.out"].print(" ") ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ; 
     return ) else skip ) ; 
 );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= T do ( (     OclFile["System.out"].print("Case #" + i + ": ") ; 
     var solver : Solver ; solver := Solver.newSolver() ;
     solver.solve() )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.*;
import java.math.*;
public class C {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int T=scan.nextInt();
    for(int ca=1 ; ca<=T ; ca++){
      boolean rtn=false ;
      int n=scan.nextInt();
      int[] a=new int[n-1];
      for(int i=0 ; i<n-1 ; i++)a[i]=scan.nextInt()-1 ;
      int TRIALS=10000000 ;
      int[] h=new int[n];
      while(TRIALS-->0){
        boolean good=true ;
        for(int i=0 ; i<n-1 ; i++){
          double m=-999999999 ;
          int max=-1 ;
          for(int j=i+1 ; j<n ; j++){
            double tm=(double)(h[j]-h[i])/(j-i);
            if(tm>m){
              m=tm ;
              max=j ;
            }
          }
          if(max!=a[i]){
            good=false ;
            h[a[i] ]++;
            break ;
          }
        }
        if(good)break ;
      }
      System.out.print("Case #"+ca+":");
      if(TRIALS<=0)System.out.println(" Impossible");
      else {
        for(int i=0 ; i<n ; i++)System.out.print(" "+h[i]);
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := scan.getCurrent()->toInteger() ;
         var ca : int ; ca := 1 ; while ca <= T do ( (     var rtn : boolean ; rtn := false ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n - 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n - 1 do (     a[i+1] := scan.getCurrent()->toInteger() - 1 ;  ;     i := i + 1 ) ; 
    var TRIALS : int ; TRIALS := 10000000 ;
    var h : Sequence(int) ; h := Integer.subrange(1,n)->collect(0) ;
        while (TRIALS > 0) do (        TRIALS := TRIALS - 1 ;     skip ; (     var good : boolean ; good := true ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     var m : double ; m := -999999999 ;
     var max : int ; max := -1 ;
         var j : int ; j := i + 1 ; while j < n do ( (     var tm : double ; tm := (h[j+1] - h[i+1])->oclAsType(double) / (j - i) ;
     if (tm > m) then (     m := tm ; 
     max := j ) else skip )  ;     j := j + 1 ) ; 
     if (max /= a[i+1]) then (     good := false ; 
     h[a[i+1]+1] := h[a[i+1]+1] + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (good) then     break else skip ) ;  ) ;  
    OclFile["System.out"].print("Case #" + ca + ":") ; 
    if (TRIALS <= 0) then     OclFile["System.out"].println(" Impossible") else (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(" " + h[i+1]) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ;  
 )  ;     ca := ca + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      int[] l=new int[n];
      int[] r=new int[n];
      for(int i=0 ; i<n ; i++){
        l[i]=in.nextInt();
        r[i]=in.nextInt();
      }
      int s=0 ;
      for(int i=0 ; i<n ; i++){
        if(s<r[i]){
          if(l[i]>s)s=l[i];
          else {
            s++;
          }
          System.out.print(s+" ");
        }
        else {
          System.out.print(0+" ");
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var l : Sequence(int) ; l := Integer.subrange(1,n)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     l[i+1] := in.getCurrent()->toInteger() ; 
     r[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var s : int ; s := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s < r[i+1]) then (     if (l[i+1] > s) then     s := l[i+1] else (     s := s + 1 ) ;  
     OclFile["System.out"].print(s + " ") ) else (     OclFile["System.out"].print(0 + " ") ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Map.Entry ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=Integer.parseInt(scanner.nextLine());
    char[] t=scanner.nextLine().toCharArray();
    int ans=0 ;
    int rcn=0 ;
    int wcn=0 ;
    for(int i=0 ; i<n ; i++){
      if(t[i]=='R'){
        rcn++;
      }
    }
    for(int i=0 ; i<rcn ; i++){
      if(t[i]=='W'){
        wcn++;
      }
    }
    System.out.println(wcn);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (scanner.nextLine())->toInteger() ;
    var t : Sequence(String) ; t := scanner.nextLine()->characters() ;
    var ans : int ; ans := 0 ;
    var rcn : int ; rcn := 0 ;
    var wcn : int ; wcn := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (t[i+1] = 'R') then (     rcn := rcn + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < rcn do ( (     if (t[i+1] = 'W') then (     wcn := wcn + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(wcn) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  public static void main(String args[])throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    int n=Integer.parseInt(br.readLine());
    char c[]=br.readLine().toCharArray();
    int r=0,w=0 ;
    for(int i=0 ; i<n ; i++){
      if(c[i]=='R')r++;
      else w++;
    }
    if(w==0 || r==0)pw.println(0);
    else {
      int cntr=0 ;
      for(int i=0 ; i<r ; i++){
        if(c[i]=='W')cntr++;
      }
      pw.println(cntr);
    }
    pw.flush();
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var c : Sequence(String) ; c := br.readLine()->characters() ;
    var r : int ; r := 0 ;
    var w : int ; w := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (c[i+1] = 'R') then     r := r + 1 ; else     w := w + 1 ; )  ;     i := i + 1 ) ; 
    if (w = 0 or r = 0) then     skip else (     var cntr : int ; cntr := 0 ;
         var i : int ; i := 0 ; while i < r do ( (     if (c[i+1] = 'W') then     cntr := cntr + 1 ; else skip )  ;     i := i + 1 ) ; 
     skip ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.Stream ;
import java.util.Arrays ;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    String str=sc.next();
    sc.close();
    long count=0 ;
    String[] strList=str.split("");
    long white=Stream.of(strList).filter(e->e.equals("W")).count();
    long red=n-white ;
    String[] copyList=strList.clone();
    Arrays.sort(copyList);
    for(int i=0 ; i<n ; i++){
      if(! strList[i] .equals(copyList[i])){
        count++;
      }
    }
    count=count/2 ;
    System.out.println(Math.min(white,Math.min(red,count)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var str : String ; str := sc.getCurrent() ;
    skip ; 
    var count : long ; count := 0 ;
    var strList : Sequence(String) ; strList := str->split("") ;
    var white : long ; white := Sequence{strList}->select( _x1 | (lambda e : OclAny in e = "W")->apply(_x1) )->size() ;
    var red : long ; red := n - white ;
    var copyList : Sequence(String) ; copyList := strList->copy() ;
    copyList := copyList->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (not(strList[i+1] = copyList[i+1])) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    count := count / 2 ; 
    OclFile["System.out"].println(Set{white, Set{red, count}->min()}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Deque ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Map ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    execute17_1();
  }
  private static void execute17_2(){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      if(n % 2==0){
        System.out.println(-1);
      }
      else {
        long a=0 ;
      }
    }
  }
  private static void execute17_1(){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      String str=sc.next();
      char[] c=new char[n];
      int red=0 ;
      int white=0 ;
      for(int i=0 ; i<n ; i++){
        c[i]=str.charAt(i);
        if(c[i]=='R'){
          red++;
        }
        else {
          white++;
        }
      }
      long ans=0 ;
      for(int i=0 ; i<n-1 ; i++){
        if(red>=i+1 && c[i]=='W'){
          ans++;
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute execute17execute17execute17    execute execute17execute17execute17    execute execute17execute17execute17_1()()() ; 
()()() ;()()() );
  static   operation execute17_2() : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (     OclFile["System.out"].println(-1) ) else (     var a : long ; a := 0 ) ))  );
  static   operation execute17_1() : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var str : String ; str := sc.getCurrent() ;
    var c : Sequence(String) ; c := Integer.subrange(1,n)->collect(0) ;
    var red : int ; red := 0 ;
    var white : int ; white := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := str->at(i+1) ; 
     if (c[i+1] = 'R') then (     red := red + 1 ) else (     white := white + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (red >= i + 1 & c[i+1] = 'W') then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String s=in.next();
    int i=0,j=s.length()-1 ;
    int count=0 ;
    while(i<j){
      if(s.charAt(i)=='W' && s.charAt(j)=='R'){
        count++;
        i++;
        j--;
      }
      else {
        if(s.charAt(i)=='R' && s.charAt(j)=='W'){
          i++;
          j--;
        }
        else {
          if(s.charAt(i)=='W'){
            j--;
          }
          else {
            i++;
          }
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var i : int ; i := 0 ;
    var j : int ; j := s->size() - 1 ;
    var count : int ; count := 0 ;
    while (i < j) do (     if (s->at(i+1) = 'W' & s->at(j+1) = 'R') then (     count := count + 1 ; 
     i := i + 1 ; 
     j := j - 1 ) else (     if (s->at(i+1) = 'R' & s->at(j+1) = 'W') then (     i := i + 1 ; 
     j := j - 1 ) else (     if (s->at(i+1) = 'W') then (     j := j - 1 ) else (     i := i + 1 ) ) ) ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    SC sc=new SC(System.in);
    long N=sc.nextLong();
    long X=sc.nextLong();
    long sum=0 ;
    if(X>N/2){
      X=N-X ;
    }
    long big=N-X ;
    long mini=X ;
    sum=N ;
    while(true){
      if(big % mini!=0){
        sum+=mini*2*(big/mini);
        long tmp=mini ;
        mini=big % mini ;
        big=tmp ;
      }
      else {
        sum+=mini*((big/mini)*2-1);
        break ;
      }
    }
    pl(sum);
  }
  static class SC {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public SC(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        throw new UncheckedIOException(e);
      }
    }
  }
  public static void pl(Object o){
    System.out.println(o);
  }
  public static void pl(){
    System.out.println();
  }
  public static void p(Object o){
    System.out.print(o);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : SC ; sc := SC.newSC(OclFile["System.in"]) ;
     var N : long ; N := sc.nextLong() ;
    var X : long ; X := sc.nextLong() ;
    var sum : long ; sum := 0 ;
    if (X > N / 2) then (     X := N - X ) else skip ; 
    var big : long ; big := N - X ;
    var mini : long ; mini := X ;
    sum := N ; 
    while (true) do (     if (big mod mini /= 0) then (     sum := sum+(mini * 2 * (big / mini)) ; 
     var tmp : long ; tmp := mini ;
     mini := big mod mini ; 
     big := tmp ) else (     sum := sum+(mini * ((big / mini) * 2 - 1)) ; 
     break ) ) ; 
    execute pl(sum) ; 
 );
  static class SC {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newSC( in : OclFile) : SC
  pre: true
  post: true
  activity:
  ( var self : SC ;
    self := createSC();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 );
}
  static   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation pl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String addBinaryUtil(String a,String b){
    String result="" ;
    int s=0 ;
    int i=a.length()-1,j=b.length()-1 ;
    while(i>=0 || j>=0 || s==1){
      s+=((i>=0)? a.charAt(i)-'0' : 0);
      s+=((j>=0)? b.charAt(j)-'0' : 0);
      result=s % 2+result ;
      s/=2 ;
      i--;
      j--;
    }
    return result ;
  }
  static String addBinary(String arr[],int n){
    String result="" ;
    for(int i=0 ; i<n ; i++){
      result=addBinaryUtil(result,arr[i]);
    }
    return result ;
  }
  public static void main(String[] args){
    String arr[]={
      "1","10","11" };
      int n=arr.length ;
      System.out.println(addBinary(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation addBinaryUtil( a : String, b : String) : String
  pre: true
  post: true
  activity: (     var result : String ; result := "" ;
     var s : int ; s := 0 ;
    var i : int ; i := a->size() - 1 ;
    var j : int ; j := b->size() - 1 ;
    while (i >= 0 or j >= 0 or s = 1) do (     s := s+((if (i >= 0) then a->at(i+1) - ('0')->char2byte() else 0 endif)) ; 
     s := s+((if (j >= 0) then b->at(j+1) - ('0')->char2byte() else 0 endif)) ; 
    result := s mod 2 + result ; 
    s := s/(2) ; 
    i := i - 1 ; 
    j := j - 1 ; 
 ) ; 
    return result 
 );
  static   operation addBinary( arr : Sequence(String), n : int) : String
  pre: true
  post: true
  activity: (     var result : String ; result := "" ;
         var i : int ; i := 0 ; while i < n do ( (     result := addBinaryUtil(result, arr[i+1]) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"1","10","11"} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(addBinary(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Map.Entry ;
public class practice {
  public static boolean check(HashMap<Integer,Integer>hs,int k,int n){
    int c=0 ;
    if(k==0){
      return true ;
    }
    for(Map.Entry<Integer,Integer>entry : hs.entrySet()){
      int p=entry.getValue();
      c=c+(p/k);
    }
    if(c>=n){
      return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int m=s.nextInt();
    int arr[]=new int[m];
    HashMap<Integer,Integer>hs=new HashMap();
    for(int i=0 ; i<m ; i++){
      arr[i]=s.nextInt();
      hs.put(arr[i],hs.getOrDefault(arr[i],0)+1);
    }
    int l=0 ;
    int h=m/n ;
    int ans=0 ;
    while(l<=h){
      int mid=(l+h)/2 ;
      boolean p=check(hs,mid,n);
      if(p){
        ans=mid ;
        l=mid+1 ;
      }
      else {
        h=mid-1 ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice {
  static   operation check( hs : Map(int,int), k : int, n : int) : boolean
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
     if (k = 0) then (     return true ) else skip ; 
    for (entry : hs->asSet()) do ( (     var p : int ; p := entry.getValue() ;
     c := c + (p / k) )  ) ; 
    if (c >= n) then (     return true ) else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var m : int ; m := s.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,m)->collect(0) ;
    var hs : Map(int,int) ; hs := Map{} ;
        var i : int ; i := 0 ; while i < m do ( (     arr[i+1] := s.getCurrent()->toInteger() ; 
     hs := hs->union(Map{arr[i+1] |-> (if hs->keys()->contains(arr[i+1]) then hs->at(arr[i+1]) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var l : int ; l := 0 ;
    var h : int ; h := m / n ;
    var ans : int ; ans := 0 ;
    while (l <= h) do (     var mid : int ; mid := (l + h) / 2 ;
     var p : boolean ; p := check(hs, mid, n) ;
     if (p) then (     ans := mid ; 
     l := mid + 1 ) else (     h := mid - 1 ) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class B_Planning_The_Expedition {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[] a=new int[m];
    for(int i=0 ; i<a.length ; i++){
      a[i]=sc.nextInt();
    }
    System.out.println(solve(n,a));
    sc.close();
  }
  static int solve(int n,int[] a){
    Map<Integer,Integer>typeToCount=new HashMap<>();
    for(int type : a){
      typeToCount.put(type,typeToCount.getOrDefault(type,0)+1);
    }
    for(int day=a.length/n ; ; day--){
      if(day==0 || computePeopleNum(typeToCount,day)>=n){
        return day ;
      }
    }
  }
  static int computePeopleNum(Map<Integer,Integer>typeToCount,int day){
    return typeToCount.values().stream().mapToInt(count->count/day).sum();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Planning_The_Expedition {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(n, a)) ; 
    skip ; 
 );
  static   operation solve( n : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var typeToCount : Map(int,int) ; typeToCount := Map{} ;
     for (type : a) do ( (     typeToCount := typeToCount->union(Map{type |-> (if typeToCount->keys()->contains(type) then typeToCount->at(type) else 0 endif) + 1}) )  ) ; 
         var day : int ; day := a->size() / n ; while true do ( (     if (day = 0 or computePeopleNum(typeToCount, day) >= n) then (     return day ) else skip )  ;     day := day - 1 ) );
  static   operation computePeopleNum( typeToCount : Map(int,int), day : int) : int
  pre: true
  post: true
  activity: (     return typeToCount->values()->collect( _x1 | (lambda count : OclAny in count / day)->apply(_x1) )->sum() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class trailzero {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int a[]=new int[101];
    int ans=0 ;
    for(int i=0 ; i<m ; i++){
      a[sc.nextInt()]++;
    }
    for(int i=1 ; i<101 ; i++){
      int c=0 ;
      for(int y : a){
        c+=y/i ;
      }
      if(c>=n){
        ans=i ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class trailzero {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,101)->collect(0) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     a[sc.getCurrent()->toInteger()+1] := a[sc.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < 101 do ( (     var c : int ; c := 0 ;
     for (y : a) do ( (     c := c+(y / i) )  ) ; 
     if (c >= n) then (     ans := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.security.spec.RSAOtherPrimeInfo ;
import java.util.StringTokenizer ;
public class TeaQueue {
  public static void main(String[] args){
    FastReader in=new FastReader();
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      int c=1 ;
      for(int i=1 ; i<=n ; i++){
        int l=in.nextInt();
        int r=in.nextInt();
        if(l>=c)c=l ;
        if(r<c && i!=1){
          System.out.print(0+" ");
        }
        else {
          System.out.print(c+" ");
          c++;
        }
      }
      System.out.println();
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TeaQueue {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var t : int ; t := in.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.nextInt() ;
     var c : int ; c := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (     var l : int ; l := in.nextInt() ;
     var r : int ; r := in.nextInt() ;
     if (l >= c) then     c := l ; else skip ; 
     if (r < c & i /= 1) then (     OclFile["System.out"].print(0 + " ") ) else (     OclFile["System.out"].print(c + " ") ; 
     c := c + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ;  ) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PlanningExpedition {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),m=in.nextInt(),i,a[]=new int[101],o=0 ;
    for(i=0 ; i<m ; i++)a[in.nextInt()]++;
    in.close();
    for(i=1 ; i<101 ; i++){
      int x=0 ;
      for(int y : a)x+=y/i ;
      if(x>=n)o=i ;
    }
    System.out.println(o);
  }
}
------------------------------------------------------------
OCL File:
---------
 class PlanningExpedition {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var i : int ;
    var a : Sequence(void) ; a := Integer.subrange(1,101)->collect(0) ;
    var o : int ; o := 0 ;
        i := 0 ; while i < m do (     a[in.getCurrent()->toInteger()+1] := a[in.getCurrent()->toInteger()+1] + 1 ;  ;     i := i + 1 ) ; 
    skip ; 
        i := 1 ; while i < 101 do ( (     var x : int ; x := 0 ;
     for (y : a) do (     x := x+(y / i) ;  ) ; 
     if (x >= n) then     o := i ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(o) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int m=in.nextInt();
    int[] cnt=new int[100+5];
    for(int i=0 ; i<m ; i++)cnt[in.nextInt()]++;
    ArrayList<Integer>ls=new ArrayList<>();
    for(int i : cnt)if(i>0)ls.add(i);
    Collections.sort(ls);
    pw.println(solve(ls,n));
    pw.close();
  }
  static int solve(ArrayList<Integer>ls,int n){
    Collections.reverse(ls);
    int ans=0 ;
    int l=1,r=1000 ;
    while(l<=r){
      int mid=(l+r)/2 ;
      if(possible(ls,n,mid)){
        l=mid+1 ;
        ans=mid ;
      }
      else r=mid-1 ;
    }
    return ans ;
  }
  static boolean possible(ArrayList<Integer>ls,int n,int day){
    int temp=n ;
    for(int i=0 ; i<ls.size(); i++){
      if(ls.get(i)<day)return false ;
      int cnt=ls.get(i)/day ;
      temp-=cnt ;
      if(temp<=0)return true ;
    }
    if(temp<=0)return true ;
    return false ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,100 + 5)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     cnt[in.getCurrent()->toInteger()+1] := cnt[in.getCurrent()->toInteger()+1] + 1 ;  ;     i := i + 1 ) ; 
    var ls : Sequence(int) ; ls := Sequence{} ;
    for (i : cnt) do (     if (i > 0) then     ls := ls->including(i) ; else skip ;  ) ; 
    ls := ls->sort() ; 
    skip ; 
    skip ; 
 );
  static   operation solve( ls : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     ls := ls->reverse() ; 
     var ans : int ; ans := 0 ;
    var l : int ; l := 1 ;
    var r : int ; r := 1000 ;
    while (l <= r) do (     var mid : int ; mid := (l + r) / 2 ;
     if (possible(ls, n, mid)) then (     l := mid + 1 ; 
     ans := mid ) else     r := mid - 1 ; ) ; 
    return ans 
 );
  static   operation possible( ls : Sequence(int), n : int, day : int) : boolean
  pre: true
  post: true
  activity: (     var temp : int ; temp := n ;
         var i : int ; i := 0 ; while i < ls->size() do ( (     if (ls->at(i+1) < day) then     return false else skip ; 
     var cnt : int ; cnt := ls->at(i+1) / day ;
     temp := temp-(cnt) ; 
     if (temp <= 0) then     return true else skip )  ;     i := i + 1 ) ; 
     if (temp <= 0) then     return true else skip ; 
     return false );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isSemiPrime(int num){
    int cnt=0 ;
    for(int i=2 ; cnt<2 && i*i<=num ; ++i)while(num % i==0){
      num/=i ;
++cnt ;
    }
    if(num>1)++cnt ;
    return cnt==2 ? true : false ;
  }
  static boolean isPrime(int n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static boolean isChenPrime(int n){
    if(isPrime(n)&&(isSemiPrime(n+2)|| isPrime(n+2)))return true ;
    else return false ;
  }
  public static void main(String[] args){
    int n=7 ;
    if(isChenPrime(n))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isSemiPrime( num : int) : boolean
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 2 ; while cnt < 2 & i * i <= num do (     while (num mod i = 0) do (     num := num/(i) ; 
     cnt := cnt + 1 ) ;  ;     i := i + 1 ) ; 
     if (num > 1) then     cnt := cnt + 1 ; else skip ; 
     return if cnt = 2 then true else false endif );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do ( (     if (n mod i = 0 or n mod (i + 2) = 0) then (     return false ) else skip )  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation isChenPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (isPrime(n) & (isSemiPrime(n + 2) or isPrime(n + 2))) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     if (isChenPrime(n)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    String s=sc.next().replace("egg","E").replace("chicken","C");
    List<String>l=new ArrayList<String>();
    int p=0 ;
    for(int i=0 ; i+1<s.length(); i++){
      if(s.charAt(i)==s.charAt(i+1)){
        l.add(s.substring(p,i+1));
        p=i+1 ;
      }
    }
    l.add(s.substring(p,s.length()));
    String res="" ;
    int m=0 ;
    for(String t : l){
      if(m<t.length()){
        m=t.length();
        res=t.charAt(m-1)=='E' ? "egg" : "chicken" ;
      }
    }
    System.out.println(res);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent().replace("egg", "E").replace("chicken", "C") ;
    var l : Sequence(String) ; l := Sequence{} ;
    var p : int ; p := 0 ;
        var i : int ; i := 0 ; while i + 1 < s->size() do ( (     if (s->at(i+1) = s->at(i + 1+1)) then (     l := l->including(s.subrange(p+1,i + 1)) ; 
     p := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    l := l->including(s.subrange(p+1,s->size())) ; 
    var res : String ; res := "" ;
    var m : int ; m := 0 ;
    for (t : l) do ( (     if (m < t->size()) then (     m := t->size() ; 
     res := if t->at((m)->char2byte() - 1+1) = 'E' then "egg" else "chicken" endif ) else skip )  ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String s=sc.next();
      boolean flag=true ;
      int max=1 ;
      int i=3 ;
      int count=0 ;
      String ans="egg" ;
      if(s.charAt(0)=='c'){
        ans="chicken" ;
        flag=false ;
        i=7 ;
      }
      while(i<s.length()){
        count++;
        if(s.charAt(i)=='e' && flag==false){
          flag=true ;
          i+=3 ;
        }
        else if(s.charAt(i)=='c' && flag==true){
          flag=false ;
          i+=7 ;
        }
        else if(s.charAt(i)=='e' && flag==true){
          if(max<count){
            max=count ;
            ans="egg" ;
          }
          i+=3 ;
          count=0 ;
        }
        else if(s.charAt(i)=='c' && flag==false){
          if(max<count){
            max=count ;
            ans="chicken" ;
          }
          i+=7 ;
          count=0 ;
        }
      }
      count++;
      if(flag==true)i-=3 ;
      else if(flag==false)i-=7 ;
      if(s.charAt(i)=='e' && max<count)ans="egg" ;
      else if(s.charAt(i)=='c' && max<count)ans="chicken" ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var s : String ; s := sc.getCurrent() ;
     var flag : boolean ; flag := true ;
    var max : int ; max := 1 ;
    var i : int ; i := 3 ;
    var count : int ; count := 0 ;
    var ans : String ; ans := "egg" ;
    if (s->at(0+1) = 'c') then (     ans := "chicken" ; 
     flag := false ; 
     i := 7 ) else skip ; 
    while (i < s->size()) do (     count := count + 1 ; 
     if (s->at(i+1) = 'e' & flag = false) then (     flag := true ; 
     i := i+(3) ) else     if (s->at(i+1) = 'c' & flag = true) then (     flag := false ; 
     i := i+(7) ) else     if (s->at(i+1) = 'e' & flag = true) then (     if (max < count) then (     max := count ; 
     ans := "egg" ) else skip ; 
     i := i+(3) ; 
     count := 0 ) else     if (s->at(i+1) = 'c' & flag = false) then (     if (max < count) then (     max := count ; 
     ans := "chicken" ) else skip ; 
     i := i+(7) ; 
     count := 0 ) else skip ; ;  ;  ) ; 
    count := count + 1 ; 
    if (flag = true) then     i := i-(3) else     if (flag = false) then     i := i-(7) ; else skip ; ;  
    if (s->at(i+1) = 'e' & max < count) then     ans := "egg" else     if (s->at(i+1) = 'c' & max < count) then     ans := "chicken" ; else skip ; ;  
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    String input=sc.next();
    LinkedList<LinkedList<String>>parse=new LinkedList<LinkedList<String>>();
    String prev="" ;
    LinkedList<String>tmp=new LinkedList<String>();
    while(! input.isEmpty()){
      if(input.startsWith("egg")){
        if(prev.equals("egg")){
          parse.add(tmp);
          tmp=new LinkedList<String>();
        }
        tmp.add("egg");
        prev="egg" ;
        input=input.substring("egg".length());
      }
      else {
        if(prev.equals("chicken")){
          parse.add(tmp);
          tmp=new LinkedList<String>();
        }
        tmp.add("chicken");
        prev="chicken" ;
        input=input.substring("chicken".length());
      }
    }
    if(! tmp.isEmpty()){
      parse.add(tmp);
    }
    int max=Integer.MIN_VALUE ;
    String str=null ;
    for(LinkedList<String>list : parse){
      if(max<list.size()){
        max=list.size();
        str=list.getLast();
      }
    }
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : String ; input := sc.getCurrent() ;
    var parse : Sequence(Sequence(String)) ; parse := Sequence{} ;
    var prev : String ; prev := "" ;
    var tmp : Sequence(String) ; tmp := Sequence{} ;
    while (not(input->isEmpty())) do (     if (input->hasPrefix("egg")) then (     if (prev = "egg") then (     parse := parse->including(tmp) ; 
     tmp := Sequence{} ) else skip ; 
     tmp := tmp->including("egg") ; 
     prev := "egg" ; 
     input := input.subrange("egg"->size()+1,"egg"->size()) ) else (     if (prev = "chicken") then (     parse := parse->including(tmp) ; 
     tmp := Sequence{} ) else skip ; 
     tmp := tmp->including("chicken") ; 
     prev := "chicken" ; 
     input := input.subrange("chicken"->size()+1,"chicken"->size()) ) ) ; 
    if (not(tmp->isEmpty())) then (     parse := parse->including(tmp) ) else skip ; 
    var max : int ; max := -2147483648 ;
    var str : String ; str := null ;
    for (list : parse) do ( (     if (max < list->size()) then (     max := list->size() ; 
     str := list->last() ) else skip )  ) ; 
    OclFile["System.out"].println(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long m=sc.nextLong();
    long ans=0 ;
    if(m/2>=n){
      ans+=n ;
    }
    else {
      ans+=m/2 ;
    }
    m-=2*ans ;
    if(m>=0){
      ans+=m/4 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var m : long ; m := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
    if (m / 2 >= n) then (     ans := ans+(n) ) else (     ans := ans+(m / 2) ) ;  
    m := m-(2 * ans) ; 
    if (m >= 0) then (     ans := ans+(m / 4) ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    String str=stdIn.next();
    String[] s=new String[1000];
    int index=0 ;
    int start=0 ;
    for(int i=0 ; i<str.length(); i++){
      if(i+3<str.length()){
        s[index]=str.substring(start);
      }
      if(str.charAt(i)=='e'){
        if(i+3<str.length()){
          if(str.charAt(i+3)=='e'){
            s[index]=str.substring(start,i+3);
            start=i+3 ;
            index++;
          }
          i+=2 ;
        }
        else {
          s[index]=str.substring(start);
          index++;
          break ;
        }
      }
      else {
        if(i+7<str.length()){
          if(str.charAt(i+7)=='c'){
            s[index]=str.substring(start,i+7);
            start=i+7 ;
            index++;
          }
          i+=6 ;
        }
        else {
          s[index]=str.substring(start);
          index++;
          break ;
        }
      }
    }
    int ans=0 ;
    int max=0 ;
    for(int i=0 ; i<index ; i++){
      if(s[i] .length()>max){
        max=s[i] .length();
        ans=i ;
      }
    }
    if(s[ans] .charAt(s[ans] .length()-1)=='n'){
      System.out.println("chicken");
    }
    else {
      System.out.println("egg");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := stdIn.getCurrent() ;
    var s : Sequence(String) ; s := Integer.subrange(1,1000)->collect(null) ;
    var index : int ; index := 0 ;
    var start : int ; start := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (i + 3 < str->size()) then (     s[index+1] := str.subrange(start+1,start) ) else skip ; 
     if (str->at(i+1) = 'e') then (     if (i + 3 < str->size()) then (     if (str->at(i + 3+1) = 'e') then (     s[index+1] := str.subrange(start+1,i + 3) ; 
     start := i + 3 ; 
     index := index + 1 ) else skip ; 
     i := i+(2) ) else (     s[index+1] := str.subrange(start+1,start) ; 
     index := index + 1 ; 
     break ) ) else (     if (i + 7 < str->size()) then (     if (str->at(i + 7+1) = 'c') then (     s[index+1] := str.subrange(start+1,i + 7) ; 
     start := i + 7 ; 
     index := index + 1 ) else skip ; 
     i := i+(6) ) else (     s[index+1] := str.subrange(start+1,start) ; 
     index := index + 1 ; 
     break ) ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < index do ( (     if (s[i+1]->size() > max) then (     max := s[i+1]->size() ; 
     ans := i ) else skip )  ;     i := i + 1 ) ; 
    if (s[ans+1]->at(s[ans+1]->size() - 1+1) = 'n') then (     OclFile["System.out"].println("chicken") ) else (     OclFile["System.out"].println("egg") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAX=26 ;
  static int countMinimalReplacements(char[] s){
    int n=s.length ;
    int cnt=0 ;
    for(int i=1 ; i<n ; i++){
      if(s[i]==s[i-1]){
        cnt+=1 ;
        if(i!=(n-1)){
          for(char it : "012".toCharArray()){
            if(it!=s[i+1] && it!=s[i-1]){
              s[i]=it ;
              break ;
            }
          }
        }
        else {
          for(char it : "012".toCharArray()){
            if(it!=s[i-1]){
              s[i]=it ;
              break ;
            }
          }
        }
      }
    }
    return cnt ;
  }
  public static void main(String[] args){
    String s="201220211" ;
    System.out.println(countMinimalReplacements(s.toCharArray()));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAX : int := 26;
  static   operation countMinimalReplacements( s : Sequence(String)) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var cnt : int ; cnt := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     if (s[i+1] = s[i - 1+1]) then (     cnt := cnt+(1) ; 
     if (i /= (n - 1)) then (     for (it : "012"->characters()) do ( (     if (it /= s[i + 1+1] & it /= s[i - 1+1]) then (     s[i+1] := it ; 
     break ) else skip )  ) ) else (     for (it : "012"->characters()) do ( (     if (it /= s[i - 1+1]) then (     s[i+1] := it ; 
     break ) else skip )  ) ) ) else skip )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "201220211" ;
     OclFile["System.out"].println(countMinimalReplacements(s->characters())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countWays(int n,int m){
    int count[]=new int[n+1];
    count[0]=0 ;
    int i ;
    for(i=1 ; i<=n ; i++){
      if(i>m)count[i]=count[i-1]+count[i-m];
      else if(i<m)count[i]=1 ;
      else count[i]=2 ;
    }
    return count[n];
  }
  public static void main(String[] args){
    int n=7 ;
    int m=4 ;
    System.out.println("Number of ways="+countWays(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countWays( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var count : Sequence(int) ; count := Integer.subrange(1,n + 1)->collect(0) ;
     count[0+1] := 0 ; 
    var i : int ;
        i := 1 ; while i <= n do ( (     if (i > m) then     count[i+1] := count[i - 1+1] + count[i - m+1] ; else     if (i < m) then     count[i+1] := 1 else     count[i+1] := 2 ; ;  )  ;     i := i + 1 ) ; 
    return count[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     var m : int ; m := 4 ;
     OclFile["System.out"].println("Number of ways=" + countWays(n, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    solve(System.in,System.out);
  }
  static void solve(InputStream is,PrintStream os){
    Scanner sc=new Scanner(is);
    String s=sc.next();
    if(s.equals("A")){
      os.println("T");
    }
    if(s.equals("T")){
      os.println("A");
    }
    if(s.equals("G")){
      os.println("C");
    }
    if(s.equals("C")){
      os.println("G");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation solve( is : OclFile, os : OclFile) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(is) ;
     var s : String ; s := sc.getCurrent() ;
    if (s = "A") then (     os.println("T") ) else skip ; 
    if (s = "T") then (     os.println("A") ) else skip ; 
    if (s = "G") then (     os.println("C") ) else skip ; 
    if (s = "C") then (     os.println("G") ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=br.readLine();
    if(str.equals("A")){
      System.out.println("T");
    }
    else if(str.equals("T")){
      System.out.println("A");
    }
    else if(str.equals("C")){
      System.out.println("G");
    }
    else {
      System.out.println("C");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := br.readLine() ;
     if (str = "A") then (     OclFile["System.out"].println("T") ) else     if (str = "T") then (     OclFile["System.out"].println("A") ) else     if (str = "C") then (     OclFile["System.out"].println("G") ) else (     OclFile["System.out"].println("C") ) ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public static void main(String[] args)throws Exception {
    char c=(char)System.in.read();
    char res='\0' ;
    switch(c){
      case 'A' : res='T' ;
      break ;
      case 'T' : res='A' ;
      break ;
      case 'C' : res='G' ;
      break ;
      case 'G' : res='C' ;
      break ;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var c : String ; c := OclFile["System.in"].read()->oclAsType(String) ;
     var res : String ; res := '\0' ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
       if _switchval = 'A' then
     res := 'T' ; 
    break 
   else skip ;
       if _switchval = 'T' then
     res := 'A' ; 
    break 
   else skip ;
       if _switchval = 'C' then
     res := 'G' ; 
    break 
   else skip ;
       if _switchval = 'G' then
     res := 'C' ; 
    break 
   else skip ;
 )
     OclFile["System.out"].println(res) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      String n=reader.readLine();
      if(n.equals("A")){
        System.out.println("T");
      }
      else if(n.equals("T")){
        System.out.println("A");
      }
      else if(n.equals("C")){
        System.out.println("G");
      }
      else {
        System.out.println("C");
      }
    }
    catch(IOException e){
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var n : String ; n := reader.readLine() ;
     if (n = "A") then (     OclFile["System.out"].println("T") ) else     if (n = "T") then (     OclFile["System.out"].println("A") ) else     if (n = "C") then (     OclFile["System.out"].println("G") ) else (     OclFile["System.out"].println("C") ) ;  ;  )   catch (e : IOException) do (     OclFile["System.out"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc ;
  static String input ;
  public static void main(String[] args){
    init();
    String ans="" ;
    switch(input){
      case "A" : ans="T" ;
      break ;
      case "T" : ans="A" ;
      break ;
      case "G" : ans="C" ;
      break ;
      case "C" : ans="G" ;
      break ;
    }
    System.out.println(ans);
    sc.close();
  }
  private static void init(){
    sc=new Scanner(System.in);
    input=sc.nextLine();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile;
  static   attribute input : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute init() ; 
     var ans : String ; ans := "" ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (input) ; 
       if _switchval = "A" then
     ans := "T" ; 
    break 
   else skip ;
       if _switchval = "T" then
     ans := "A" ; 
    break 
   else skip ;
       if _switchval = "G" then
     ans := "C" ; 
    break 
   else skip ;
       if _switchval = "C" then
     ans := "G" ; 
    break 
   else skip ;
 )
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
  static   operation init() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     input := sc.nextLine() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int binomialCoeff(int n,int k){
    int C[][]=new int[n+1][k+1];
    int i,j ;
    for(i=0 ; i<=n ; i++){
      for(j=0 ; j<=Math.min(i,k); j++){
        if(j==0 || j==i)C[i][j]=1 ;
        else C[i][j]=C[i-1][j-1]+C[i-1][j];
      }
    }
    return C[n][k];
  }
  static int cntSubSeq(int arr[],int n,int k){
    Arrays.sort(arr);
    int num=arr[k-1];
    int Y=0 ;
    for(int i=k-1 ; i>=0 ; i--){
      if(arr[i]==num)Y++;
    }
    int cntX=Y ;
    for(int i=k ; i<n ; i++){
      if(arr[i]==num)cntX++;
    }
    return binomialCoeff(cntX,Y);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4 };
      int n=arr.length ;
      int k=2 ;
      System.out.println(cntSubSeq(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation binomialCoeff( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var C : Sequence(Sequence(int)) ; C := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,k + 1)->collect(0)) ;
     var i : int ;
    var j : int ;
         i := 0 ; while i <= n do ( (         j := 0 ; while j <= Set{i, k}->min() do ( (     if (j = 0 or j = i) then     C[i+1][j+1] := 1 ; else     C[i+1][j+1] := C[i - 1+1][j - 1+1] + C[i - 1+1][j+1] ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return C[n+1][k+1] );
  static   operation cntSubSeq( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var num : int ; num := arr[k - 1+1] ;
    var Y : int ; Y := 0 ;
        var i : int ; i := k - 1 ; while i >= 0 do ( (     if (arr[i+1] = num) then     Y := Y + 1 ; else skip )  ;     i := i - 1 ) ; 
    var cntX : int ; cntX := Y ;
        var i : int ; i := k ; while i < n do ( (     if (arr[i+1] = num) then     cntX := cntX + 1 ; else skip )  ;     i := i + 1 ) ; 
    return binomialCoeff(cntX, Y) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(cntSubSeq(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class SolB implements Runnable {
  public static void main(String[] args){
    new Thread(new SolB()).start();
  }
  @ Override public void run(){
    try {
      br=new BufferedReader(new FileReader(FNAME+".in"));
      out=new PrintWriter(FNAME+".out");
      solve();
      out.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  BufferedReader br ;
  StringTokenizer st ;
  PrintWriter out ;
  boolean eof=false ;
  String nextToken(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
        eof=true ;
        return "0" ;
      }
    }
    return st.nextToken();
  }
  int nextInt(){
    return Integer.parseInt(nextToken());
  }
  double nextDouble(){
    return Double.parseDouble(nextToken());
  }
  long nextLong(){
    return Long.parseLong(nextToken());
  }
  private final String FNAME="B-small-attempt0" ;
  int[] dx=new int[] {
-1,0,0,1 };
    int[] dy=new int[] {
      0,-1,1,0 };
      char[] dirch=new char[] {
        'W','S','N','E' };
        void solve(){
          int tests=nextInt();
          for(int test=1 ; test<=tests ; test++){
            out.print("Case #"+test+": ");
            int xf=nextInt();
            int yf=nextInt();
            String ans="" ;
            for(int i=0 ; i<Math.abs(xf); i++){
              if(xf<0){
                ans+="EW" ;
              }
              else {
                ans+="WE" ;
              }
            }
            for(int i=0 ; i<Math.abs(yf); i++){
              if(yf<0){
                ans+="NS" ;
              }
              else {
                ans+="SN" ;
              }
            }
            out.println(ans);
          }
        }
      }

------------------------------------------------------------
OCL File:
---------
 class SolB implements Runnable {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(SolB.newSolB()).start() );
      operation run() : void
  pre: true
  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(FNAME + ".in")) ; 
     out := OclFile.newOclFile_Write(FNAME + ".out") ; 
     execute solve() ; 
     out.close() )   catch (e : IOException) do (     e.printStackTrace() )
 );
   attribute br : OclFile;
   attribute st : OclIterator;
   attribute out : OclFile;
   attribute eof : boolean := false;
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     eof := true ; 
     return "0" )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   attribute FNAME : String := "B-small-attempt0";
   attribute dx : Sequence(int) := Sequence{-1,0,0,1};
   attribute dy : Sequence(int) := Sequence{0,-1,1,0};
   attribute dirch : Sequence(String) := Sequence{'W','S','N','E'};
   operation solve() : void
  pre: true
  post: true
  activity: (     var tests : int ; tests := nextInt() ;
         var test : int ; test := 1 ; while test <= tests do ( (     skip ; 
     var xf : int ; xf := nextInt() ;
    var yf : int ; yf := nextInt() ;
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < if xf < 0 then -(xf) else xf endif do ( (     if (xf < 0) then (     ans := ans+("EW") ) else (     ans := ans+("WE") ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < if yf < 0 then -(yf) else yf endif do ( (     if (yf < 0) then (     ans := ans+("NS") ) else (     ans := ans+("SN") ) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     test := test + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=false ;
  private static PrintWriter _out=new PrintWriter(System.out);
  private static PrintWriter _err=new PrintWriter(System.err);
  private void solve(Scanner sc){
    long N=sc.nextLong();
    long M=sc.nextLong();
    long ans1=Math.min(N,M/2);
    long ans2=0 ;
    if(M-2*ans1>0){
      ans2=(M-2*ans1)/4 ;
    }
    _out.println(ans1+ans2);
  }
  private static BigInteger C(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    for(long i=r ; i>1 ; --i){
      res=res.divide(BigInteger.valueOf(i));
    }
    return res ;
  }
  private static BigInteger P(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    return res ;
  }
  public static void main(String[] args){
    long S=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    new Main().solve(sc);
    _out.flush();
    long G=System.currentTimeMillis();
    if(elapsed){
      _err.println((G-S)+"ms");
    }
    _err.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := false;
  static   attribute _out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute _err : OclFile := OclFile.newOclFile_Write(OclFile["System.err"]);
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var N : long ; N := sc.nextLong() ;
     var M : long ; M := sc.nextLong() ;
    var ans1 : long ; ans1 := Set{N, M / 2}->min() ;
    var ans2 : long ; ans2 := 0 ;
    if (M - 2 * ans1 > 0) then (     ans2 := (M - 2 * ans1) / 4 ) else skip ; 
    skip ; 
 );
  static   operation C( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
         var i : long ; i := r ; while i > 1 do ( (     res := res.divide((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation P( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    Main.newMain().solve(sc) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileWriter ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class GCJ_2013_C2 {
  public static String solve(int x,int y){
    StringBuffer s=new StringBuffer("");
    for(int i=0 ; i<Math.abs(x); i++){
      if(x<0)s.append("EW");
      else s.append("WE");
    }
    for(int i=0 ; i<Math.abs(y); i++){
      if(y<0)s.append("NS");
      else s.append("SN");
    }
    return s.toString();
  }
  public static void main(String[] args)throws Exception {
    String fname="B_small" ;
    File file=new File(fname+"_in.txt");
    Scanner scanner=new Scanner(file);
    FileWriter outFile=new FileWriter(fname+"_out.txt");
    PrintWriter outp=new PrintWriter(outFile);
    int T=scanner.nextInt();
    for(int i=1 ; i<=T ; i++){
      int x=scanner.nextInt();
      int y=scanner.nextInt();
      outp.printf("Case #%d: %s\n",i,solve(x,y));
    }
    outp.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class GCJ{
  static   operation solve( x : int, y : int) : String
  pre: true
  post: true
  activity: (     var s : String ; s := StringLib.newString("") ;
         var i : int ; i := 0 ; while i < if x < 0 then -(x) else x endif do ( (     if (x < 0) then     s := s + StringLib.newString("EW") ; else     s := s + StringLib.newString("WE") ; )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < if y < 0 then -(y) else y endif do ( (     if (y < 0) then     s := s + StringLib.newString("NS") ; else     s := s + StringLib.newString("SN") ; )  ;     i := i + 1 ) ; 
     return s+"" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fname : String ; fname := "B_small" ;
     var file : OclFile ; file := OclFile(fname + "_in.txt") ;
    var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile.newOclFile(file)) ;
    var outFile : OclFile ; outFile := OclFile.newOclFile_Write(fname + "_out.txt") ;
    var outp : OclFile ; outp := OclFile.newOclFile_Write(outFile) ;
    var T : int ; T := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= T do ( (     var x : int ; x := scanner.getCurrent()->toInteger() ;
     var y : int ; y := scanner.getCurrent()->toInteger() ;
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
013_C2 {
  static   operation solve( x : int, y : int) : String
  pre: true
  post: true
  activity: (     var s : String ; s := StringLib.newString("") ;
         var i : int ; i := 0 ; while i < if x < 0 then -(x) else x endif do ( (     if (x < 0) then     s := s + StringLib.newString("EW") ; else     s := s + StringLib.newString("WE") ; )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < if y < 0 then -(y) else y endif do ( (     if (y < 0) then     s := s + StringLib.newString("NS") ; else     s := s + StringLib.newString("SN") ; )  ;     i := i + 1 ) ; 
     return s+"" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fname : String ; fname := "B_small" ;
     var file : OclFile ; file := OclFile(fname + "_in.txt") ;
    var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile.newOclFile(file)) ;
    var outFile : OclFile ; outFile := OclFile.newOclFile_Write(fname + "_out.txt") ;
    var outp : OclFile ; outp := OclFile.newOclFile_Write(outFile) ;
    var T : int ; T := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= T do ( (     var x : int ; x := scanner.getCurrent()->toInteger() ;
     var y : int ; y := scanner.getCurrent()->toInteger() ;
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class B {
  FastScanner in ;
  PrintWriter out ;
  public void solve()throws IOException {
    int tests=in.nextInt();
    for(int testcase=1 ; testcase<=tests ; testcase++){
      int x=in.nextInt();
      int y=in.nextInt();
      StringBuilder answer=new StringBuilder();
      while(x>0){
        answer.append("WE");
        x--;
      }
      while(x<0){
        answer.append("EW");
        x++;
      }
      while(y>0){
        answer.append("SN");
        y--;
      }
      while(y<0){
        answer.append("NS");
        y++;
      }
      out.println("Case #"+testcase+": "+answer.toString());
    }
  }
  public void run(){
    try {
      in=new FastScanner(new File("B-small-attempt0.in"));
      out=new PrintWriter(new File("B-small.out"));
      solve();
      out.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    FastScanner(File f){
      try {
        br=new BufferedReader(new FileReader(f));
      }
      catch(FileNotFoundException e){
        e.printStackTrace();
      }
    }
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
  }
  public static void main(String[] arg){
    new B().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
   attribute in : FastScanner;
   attribute out : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     var tests : int ; tests := in.nextInt() ;
         var testcase : int ; testcase := 1 ; while testcase <= tests do ( (     var x : int ; x := in.nextInt() ;
     var y : int ; y := in.nextInt() ;
    var answer : String ; answer := StringLib.newString() ;
    while (x > 0) do (     answer := answer + StringLib.newString("WE") ; 
     x := x - 1 ) ; 
    while (x < 0) do (     answer := answer + StringLib.newString("EW") ; 
     x := x + 1 ) ; 
    while (y > 0) do (     answer := answer + StringLib.newString("SN") ; 
     y := y - 1 ) ; 
    while (y < 0) do (     answer := answer + StringLib.newString("NS") ; 
     y := y + 1 ) ; 
    skip ; 
 )  ;     testcase := testcase + 1 ) );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     in := FastScanner.newFastScanner(OclFile("B-small-attempt0.in")) ; 
     out := OclFile.newOclFile_Write(OclFile("B-small.out")) ; 
     execute solve() ; 
     skip )   catch (e : IOException) do (     e.printStackTrace() )
 );
 class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( f : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(f);
    return self );
  operation initialise( f : OclFile) : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(f)) )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     B.newB().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void print(int n){
    System.out.println(n+n/2);
    for(int i=2 ; i<=n ; i+=2)System.out.print(i+" ");
    for(int i=1 ; i<=n ; i+=2)System.out.print(i+" ");
    for(int i=2 ; i<=n ; i+=2)System.out.print(i+" ");
  }
  public static void main(String[] args){
    int n=3 ;
    print(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation print( n : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(n + n / 2) ; 
         var i : int ; i := 2 ; while i <= n do (     OclFile["System.out"].print(i + " ") ;  ;     i := i+(2) ) ; 
         var i : int ; i := 1 ; while i <= n do (     OclFile["System.out"].print(i + " ") ;  ;     i := i+(2) ) ; 
         var i : int ; i := 2 ; while i <= n do (     OclFile["System.out"].print(i + " ") ;  ;     i := i+(2) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     execute print(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.LineNumberReader ;
public class B {
  static String result(int x,int y){
    StringBuilder sb=new StringBuilder();
    while(x<0){
      x++;
      sb.append("EW");
    }
    while(x>0){
      x--;
      sb.append("WE");
    }
    while(y<0){
      y++;
      sb.append("NS");
    }
    while(y>0){
      y--;
      sb.append("SN");
    }
    return sb.toString();
  }
  static void go(String inputFile)throws Exception {
    LineNumberReader in=new LineNumberReader(new FileReader(inputFile));
    FileWriter out=new FileWriter(inputFile+".out");
    int nCases=Integer.parseInt(in.readLine());
    for(int c=1 ; c<=nCases ; c++){
      int[] dims=toInts(in.readLine());
      String res=result(dims[0],dims[1]);
      String line="Case #"+c+": "+res ;
      System.out.println(line);
      out.write(line+"\n");
    }
    out.close();
  }
  static int[] toInts(String s){
    String[] tmp=s.trim().split(" ");
    int n=tmp.length ;
    int[] res=new int[n];
    for(int a=0 ; a<n ; a++)res[a]=Integer.parseInt(tmp[a]);
    return res ;
  }
  public static void main(String[] args)throws Exception {
    LineNumberReader sysIn=new LineNumberReader(new InputStreamReader(System.in));
    String line ;
    while((line=sysIn.readLine())!=null){
      go(line.trim());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation result( x : int, y : int) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     while (x < 0) do (     x := x + 1 ; 
     sb := sb + StringLib.newString("EW") ) ; 
    while (x > 0) do (     x := x - 1 ; 
     sb := sb + StringLib.newString("WE") ) ; 
    while (y < 0) do (     y := y + 1 ; 
     sb := sb + StringLib.newString("NS") ) ; 
    while (y > 0) do (     y := y - 1 ; 
     sb := sb + StringLib.newString("SN") ) ; 
    return sb+"" 
 );
  static   operation go( inputFile : String) : void
  pre: true
  post: true
  activity: (     var in : LineNumberReader ; in := LineNumberReader.newLineNumberReader(OclFile.newOclFile_Read(inputFile)) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(inputFile + ".out") ;
    var nCases : int ; nCases := (in.readLine())->toInteger() ;
        var c : int ; c := 1 ; while c <= nCases do ( (     var dims : Sequence(int) ; dims := toInts(in.readLine()) ;
     var res : String ; res := result(dims[0+1], dims[1+1]) ;
    var line : String ; line := "Case #" + c + ": " + res ;
    OclFile["System.out"].println(line) ; 
    skip ; 
 )  ;     c := c + 1 ) ; 
    skip ; 
 );
  static   operation toInts( s : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var tmp : Sequence(String) ; tmp := s->trim()->split(" ") ;
     var n : int ; n := tmp->size() ;
    var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
        var a : int ; a := 0 ; while a < n do (     res[a+1] := (tmp[a+1])->toInteger() ;  ;     a := a + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sysIn : LineNumberReader ; sysIn := LineNumberReader.newLineNumberReader(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := sysIn.readLine() ;
    while ((line) /= null) do (    skip ; (     execute go(line->trim()) ) ;     line := sysIn.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    int p=in.nextInt();
    int x=in.nextInt();
    int y=in.nextInt();
    int lowerAllowed=n/2 ;
    int testLeft=n-k ;
    int scoreLeft=x ;
    int input ;
    for(int i=0 ; i<k ; i++){
      input=in.nextInt();
      scoreLeft-=input ;
      if(y>input){
        lowerAllowed--;
      }
    }
    if((lowerAllowed<0)||(scoreLeft<Math.min(lowerAllowed,testLeft)+Math.max(0,testLeft-lowerAllowed)*y)){
      System.out.println(-1);
      return ;
    }
    int nextScore ;
    int overed ;
    while(testLeft>0){
      overed=testLeft*y-scoreLeft ;
      if(overed>0){
        nextScore=y-Math.min(y-1,overed);
        lowerAllowed--;
      }
      else {
        nextScore=y ;
      }
      testLeft--;
      scoreLeft-=nextScore ;
      System.out.print(nextScore+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var p : int ; p := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
    var y : int ; y := in.getCurrent()->toInteger() ;
    var lowerAllowed : int ; lowerAllowed := n / 2 ;
    var testLeft : int ; testLeft := n - k ;
    var scoreLeft : int ; scoreLeft := x ;
    var input : int ;
        var i : int ; i := 0 ; while i < k do ( (     input := in.getCurrent()->toInteger() ; 
     scoreLeft := scoreLeft-(input) ; 
     if (y > input) then (     lowerAllowed := lowerAllowed - 1 ) else skip )  ;     i := i + 1 ) ; 
    if ((lowerAllowed < 0) or (scoreLeft < Set{lowerAllowed, testLeft}->min() + Set{0, testLeft - lowerAllowed}->max() * y)) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var nextScore : int ;
    var overed : int ;
    while (testLeft > 0) do (     overed := testLeft * y - scoreLeft ; 
     if (overed > 0) then (     nextScore := y - Set{y - 1, overed}->min() ; 
     lowerAllowed := lowerAllowed - 1 ) else (     nextScore := y ) ;  
    testLeft := testLeft - 1 ; 
    scoreLeft := scoreLeft-(nextScore) ; 
    OclFile["System.out"].print(nextScore + " ") ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int sumKRepeating(int arr[],int n,int k){
    int sum=0 ;
    Vector<Boolean>visited=new Vector<Boolean>();
    for(int i=0 ; i<n ; i++)visited.add(false);
    for(int i=0 ; i<n ; i++){
      if(visited.get(i)==true)continue ;
      int count=1 ;
      for(int j=i+1 ; j<n ; j++){
        if(arr[i]==arr[j]){
          count++;
          visited.add(j,true);
        }
      }
      if(count==k)sum+=arr[i];
    }
    return sum ;
  }
  public static void main(String args[]){
    int arr[]={
      9,9,10,11,8,8,9,8 };
      int n=arr.length ;
      int k=3 ;
      System.out.println(sumKRepeating(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumKRepeating( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var visited : Sequence(Boolean) ; visited := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     visited := visited->including(false) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (visited->at(i+1) = true) then     continue else skip ; 
     var count : int ; count := 1 ;
         var j : int ; j := i + 1 ; while j < n do ( (     if (arr[i+1] = arr[j+1]) then (     count := count + 1 ; 
     visited := visited.insertAt(j+1,true) ) else skip )  ;     j := j + 1 ) ; 
     if (count = k) then     sum := sum+(arr[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{9,9,10,11,8,8,9,8} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println(sumKRepeating(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Increasing {
  void findStrictlyIncreasingNum(int start,String out,int n){
    if(n==0){
      System.out.print(out+" ");
      return ;
    }
    for(int i=start ; i<=9 ; i++){
      String str=out+Integer.toString(i);
      findStrictlyIncreasingNum(i+1,str,n-1);
    }
  }
  public static void main(String args[])throws IOException {
    Increasing obj=new Increasing();
    int n=3 ;
    obj.findStrictlyIncreasingNum(0," ",n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Increasing {
   operation findStrictlyIncreasingNum( start : int, out : String, n : int) : void
  pre: true
  post: true
  activity: (     if (n = 0) then (     OclFile["System.out"].print(out + " ") ; 
     return ) else skip ; 
         var i : int ; i := start ; while i <= 9 do ( (     var str : String ; str := out + ((i) + "") ;
     execute findStrictlyIncreasingNum(i + 1, str, n - 1) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Increasing ; obj := Increasing.newIncreasing() ;
     var n : int ; n := 3 ;
     obj.findStrictlyIncreasingNum(0, " ", n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class practice2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    for(int i=0 ; i<n-1 ; i++){
      int p=Math.min(arr[i],arr[i+1]);
      int q=Math.max(arr[i],arr[i+1]);
      for(int j=0 ; j<n-1 ; j++){
        if((arr[j]>p && arr[j]<q &&(arr[j+1]<p || arr[j+1]>q))||((arr[j]<p || arr[j]>q)&& arr[j+1]>p && arr[j+1]<q)){
          System.out.println("yes");
          return ;
        }
      }
    }
    System.out.println("no");
  }
}
------------------------------------------------------------
OCL File:
---------
 class practice2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var p : int ; p := Set{arr[i+1], arr[i + 1+1]}->min() ;
     var q : int ; q := Set{arr[i+1], arr[i + 1+1]}->max() ;
         var j : int ; j := 0 ; while j < n - 1 do ( (     if ((arr[j+1] > p & arr[j+1] < q & (arr[j + 1+1] < p or arr[j + 1+1] > q)) or ((arr[j+1] < p or arr[j+1] > q) & arr[j + 1+1] > p & arr[j + 1+1] < q)) then (     OclFile["System.out"].println("yes") ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("no") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class cp {
  public static void findAllFactor(int[][] div,int n){
    int divCnt[]=new int[n+1];
    int ptr[]=new int[n+1];
    for(int i=n ; i>=1 ; --i){
      for(int j=i ; j<=n ; j+=i)divCnt[j]++;
    }
    for(int i=1 ; i<=n ; ++i)div[i]=new int[divCnt[i] ];
    for(int i=n ; i>=1 ; --i){
      for(int j=i ; j<=n ; j+=i)div[j][ptr[j]++]=i ;
    }
  }
  public static void main(String[] args)throws Exception {
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=scn.nextInt();
    }
    for(int i=0 ; i<n-1 ; i++){
      int x1=arr[i]<arr[i+1] ? arr[i] : arr[i+1];
      int x2=arr[i]>arr[i+1] ? arr[i] : arr[i+1];
      for(int j=i+2 ; j<n-1 ; j++){
        int x3=arr[j]<arr[j+1] ? arr[j] : arr[j+1];
        int x4=arr[j]>arr[j+1] ? arr[j] : arr[j+1];
        if((x1<x3 && x3<x2 && x2<x4)||(x3<x1 && x1<x4 && x4<x2)){
          System.out.println("yes");
          return ;
        }
      }
    }
    System.out.println("no");
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp {
  static   operation findAllFactor( div : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (     var divCnt : Sequence(int) ; divCnt := Integer.subrange(1,n + 1)->collect(0) ;
     var ptr : Sequence(int) ; ptr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := n ; while i >= 1 do ( (         var j : int ; j := i ; while j <= n do (     divCnt[j+1] := divCnt[j+1] + 1 ;  ;     j := j+(i) ) )  ;     i := i - 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (     div[i+1] := Integer.subrange(1,divCnt[i+1])->collect(0) ;  ;     i := i + 1 ) ; 
        var i : int ; i := n ; while i >= 1 do ( (         var j : int ; j := i ; while j <= n do (      div[j+1][ptr[j+1]+1] := i  ; ptr[j+1] := ptr[j+1] + 1 ;  ;     j := j+(i) ) )  ;     i := i - 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var x1 : int ; x1 := if arr[i+1] < arr[i + 1+1] then arr[i+1] else arr[i + 1+1] endif ;
     var x2 : int ; x2 := if arr[i+1] > arr[i + 1+1] then arr[i+1] else arr[i + 1+1] endif ;
         var j : int ; j := i + 2 ; while j < n - 1 do ( (     var x3 : int ; x3 := if arr[j+1] < arr[j + 1+1] then arr[j+1] else arr[j + 1+1] endif ;
     var x4 : int ; x4 := if arr[j+1] > arr[j + 1+1] then arr[j+1] else arr[j + 1+1] endif ;
     if ((x1 < x3 & x3 < x2 & x2 < x4) or (x3 < x1 & x1 < x4 & x4 < x2)) then (     OclFile["System.out"].println("yes") ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("no") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int max=Integer.MIN_VALUE ;
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    int cnt=0 ;
    for(int j=0 ; j<n-1 ; j++){
      if(check(arr,arr[j],arr[j+1])){
        cnt++;
        break ;
      }
    }
    for(int j=n-1 ; j>0 ; j--){
      if(check(arr,arr[j],arr[j-1])){
        cnt++;
        break ;
      }
    }
    if(n>1 && check(arr,arr[n-1],arr[n-2]))cnt++;
    if(cnt>0)System.out.println("yes");
    else System.out.println("no");
  }
  static boolean check(int[] arr,int l,int r){
    int n=arr.length ;
    for(int i=1 ; i<n ; i++){
      if(arr[i]>l && arr[i]<r){
        if(arr[i-1]<l || arr[i-1]>r)return true ;
      }
      else if(arr[i]<l && arr[i]>r){
        if(arr[i]>l || arr[i-1]<r)return true ;
      }
    }
    for(int i=n-2 ; i>0 ; i--){
      if(arr[i]<l && arr[i]>r){
        if(arr[i+1]>l || arr[i+1]<r)return true ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var max : int ; max := -2147483648 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var j : int ; j := 0 ; while j < n - 1 do ( (     if (check(arr, arr[j+1], arr[j + 1+1])) then (     cnt := cnt + 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
        var j : int ; j := n - 1 ; while j > 0 do ( (     if (check(arr, arr[j+1], arr[j - 1+1])) then (     cnt := cnt + 1 ; 
     break ) else skip )  ;     j := j - 1 ) ; 
    if (n > 1 & check(arr, arr[n - 1+1], arr[n - 2+1])) then     cnt := cnt + 1 ; else skip ; 
    if (cnt > 0) then     OclFile["System.out"].println("yes") else     OclFile["System.out"].println("no") ; ;  
 );
  static   operation check( arr : Sequence(int), l : int, r : int) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
         var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] > l & arr[i+1] < r) then (     if (arr[i - 1+1] < l or arr[i - 1+1] > r) then     return true else skip ) else     if (arr[i+1] < l & arr[i+1] > r) then (     if (arr[i+1] > l or arr[i - 1+1] < r) then     return true else skip ) else skip ; )  ;     i := i + 1 ) ; 
         var i : int ; i := n - 2 ; while i > 0 do ( (     if (arr[i+1] < l & arr[i+1] > r) then (     if (arr[i + 1+1] > l or arr[i + 1+1] < r) then     return true else skip ) else skip )  ;     i := i - 1 ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] in=br.readLine().split(" ");
    long n=Long.parseLong(in[0]);
    long m=Long.parseLong(in[1]);
    long answer=(n<m/2)?((m+n*2)/4):(m/2);
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var in : Sequence(String) ; in := br.readLine()->split(" ") ;
    var n : long ; n := (in[0+1])->toLong() ;
    var m : long ; m := (in[1+1])->toLong() ;
    var answer : long ; answer := if (n < m / 2) then ((m + n * 2) / 4) else (m / 2) endif ;
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float squareRoot(int number,int precision){
    int start=0,end=number ;
    int mid ;
    double ans=0.0 ;
    while(start<=end){
      mid=(start+end)/2 ;
      if(mid*mid==number){
        ans=mid ;
        break ;
      }
      if(mid*mid<number){
        start=mid+1 ;
        ans=mid ;
      }
      else {
        end=mid-1 ;
      }
    }
    double increment=0.1 ;
    for(int i=0 ; i<precision ; i++){
      while(ans*ans<=number){
        ans+=increment ;
      }
      ans=ans-increment ;
      increment=increment/10 ;
    }
    return(float)ans ;
  }
  public static void main(String[] args){
    System.out.println(squareRoot(50,3));
    System.out.println(squareRoot(10,4));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation squareRoot( number : int, precision : int) : double
  pre: true
  post: true
  activity: (     var start : int ; start := 0 ;
    var end : int ; end := number ;
     var mid : int ;
    var ans : double ; ans := 0.0 ;
    while (start <= end) do (     mid := (start + end) / 2 ; 
     if (mid * mid = number) then (     ans := mid ; 
     break ) else skip ; 
     if (mid * mid < number) then (     start := mid + 1 ; 
     ans := mid ) else (     end := mid - 1 ) ) ; 
    var increment : double ; increment := 0.1 ;
        var i : int ; i := 0 ; while i < precision do ( (     while (ans * ans <= number) do (     ans := ans+(increment) ) ; 
     ans := ans - increment ; 
     increment := increment / 10 )  ;     i := i + 1 ) ; 
    return ans->oclAsType(double) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(squareRoot(50, 3)) ; 
     OclFile["System.out"].println(squareRoot(10, 4)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.Spliterator ;
import java.util.Spliterators ;
import java.util.concurrent.ThreadLocalRandom ;
import java.util.concurrent.atomic.AtomicInteger ;
import java.util.stream.IntStream ;
import java.util.stream.Stream ;
import java.util.stream.StreamSupport ;
public class Main {
  static final Scanner s=new Scanner(System.in);
  static final long[] fal_rnd(int size){
    AtomicInteger l=new AtomicInteger(-1),r=new AtomicInteger(size);
    long[] res=new long[size];
    INS(size).unordered().parallel().mapToLong(Long :: parseLong).forEach(v->res[ThreadLocalRandom.current().nextBoolean()? l.incrementAndGet(): r.decrementAndGet()]=v);
    return res ;
  }
  static final IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static final Stream<String>INS(long size){
    return StreamSupport.stream(Spliterators.spliterator(s,size,Spliterator.NONNULL & Spliterator.IMMUTABLE),false).limit(size);
  }
  public static void main(String __[]){
    int n,min,max ;
    while(true){
      n=s.nextInt();
      if(n==0)return ;
      min=s.nextInt();
      max=s.nextInt();
      long[] in=fal_rnd(n);
      Arrays.parallelSort(in);
      long v=-114514,r=-114514 ;
      for(int i=min ; i<=max ; i++){
        if(in[n-i]-in[n-i-1]>=v){
          v=in[n-i]-in[n-i-1];
          r=i ;
        }
      }
      System.out.println(r);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    operation fal_rnd( size : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var l : int ; l := (-1) ;
    var r : int ; r := (size) ;
     var res : Sequence(long) ; res := Integer.subrange(1,size)->collect(0) ;
     for v : INS(size)->collect( _x1 | (lambda _s : String in _s->toLong())->apply(_x1) ) do
    (    res[if MathLib.nextBoolean() then l+1 else r-1 endif+1] := v) ; 
     return res );
  static    operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static    operation INS( size : long) : Stream<String>
  pre: true
  post: true
  activity: (     return (OclIterator.newOclIterator_Sequence(s)).elements.subrange(1,size) );
  static   operation main( __ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var min : int ;
    var max : int ;
     while (true) do (     n := s.getCurrent()->toInteger() ; 
     if (n = 0) then     return else skip ; 
    min := s.getCurrent()->toInteger() ; 
    max := s.getCurrent()->toInteger() ; 
    var in : Sequence(long) ; in := fal_rnd(n) ;
    in := in->sort() ; 
    var v : long ; v := -114514 ;
    var r : long ; r := -114514 ;
        var i : int ; i := min ; while i <= max do ( (     if (in[n - i+1] - in[n - i - 1+1] >= v) then (     v := in[n - i+1] - in[n - i - 1+1] ; 
     r := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(r) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ArrayElimination {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      int n=scan.nextInt();
      int[] bit=new int[32];
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=scan.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<32 ; j++){
          int temp=(1<<(j-1));
          int bitwiseAnd=arr[i] & temp ;
          if(bitwiseAnd>0)bit[j]++;
        }
      }
      for(int i=1 ; i<=n ; i++){
        boolean possible=true ;
        for(int j=0 ; j<32 ; j++){
          if(bit[j] % i!=0){
            possible=false ;
            break ;
          }
        }
        if(possible)System.out.print(i+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ArrayElimination {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         var tt : int ; tt := 0 ; while tt < t do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var bit : Sequence(int) ; bit := Integer.subrange(1,32)->collect(0) ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 32 do ( (     var temp : int ; temp := ((1*(2->pow((j - 1))))->oclAsType(long)) ;
     var bitwiseAnd : int ; bitwiseAnd := MathLib.bitwiseAnd(arr[i+1],temp) ;
     if (bitwiseAnd > 0) then     bit[j+1] := bit[j+1] + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     var possible : boolean ; possible := true ;
         var j : int ; j := 0 ; while j < 32 do ( (     if (bit[j+1] mod i /= 0) then (     possible := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (possible) then     OclFile["System.out"].print(i + " ") ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     tt := tt + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    char[] a=fs.next().toCharArray();
    System.out.println(a[2]==a[3] && a[4]==a[5] ? "Yes" : "No");
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=nextInt();
      }
      return a ;
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var a : Sequence(String) ; a := fs.next()->characters() ;
     OclFile["System.out"].println(if a[2+1] = a[3+1] & a[4+1] = a[5+1] then "Yes" else "No" endif) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return a );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    String s=sc.next();
    if(s.charAt(2)==s.charAt(3)&& s.charAt(4)==s.charAt(5)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := sc.getCurrent() ;
     if (s->at(2+1) = s->at(3+1) & s->at(4+1) = s->at(5+1)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    char[] strChar=new char[str.length()];
    for(int i=0 ; i<str.length(); i++){
      strChar[i]=str.charAt(i);
    }
    boolean judge=false ;
    if(strChar[2]==strChar[3]){
      if(strChar[4]==strChar[5]){
        judge=true ;
      }
    }
    System.out.println(judge ? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var strChar : Sequence(String) ; strChar := Integer.subrange(1,str->size())->collect(0) ;
        var i : int ; i := 0 ; while i < str->size() do ( (     strChar[i+1] := str->at(i+1) )  ;     i := i + 1 ) ; 
    var judge : boolean ; judge := false ;
    if (strChar[2+1] = strChar[3+1]) then (     if (strChar[4+1] = strChar[5+1]) then (     judge := true ) else skip ) else skip ; 
    OclFile["System.out"].println(if judge then "Yes" else "No" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastReader s=new FastReader();
    String str=s.next();
    if((str.charAt(2)==str.charAt(3))&&(str.charAt(4)==str.charAt(5)))System.out.println("Yes");
    else System.out.println("No");
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : FastReader ; s := FastReader.newFastReader() ;
     var str : String ; str := s.next() ;
     if ((str->at(2+1) = str->at(3+1)) & (str->at(4+1) = str->at(5+1))) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char[] s=sc.next().toCharArray();
    if(s.length<6){
      System.out.println("No");
      return ;
    }
    if(s[2]==s[3] && s[4]==s[5]){
      System.out.println("Yes");
      return ;
    }
    System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    if (s->size() < 6) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
    if (s[2+1] = s[3+1] & s[4+1] = s[5+1]) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
    OclFile["System.out"].println("No") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test {
  static boolean check(long x){
    while(x!=0){
      long temp=Math.abs(x % 10);
      if(temp==8)return true ;
      x/=10 ;
    }
    return false ;
  }
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int n=cin.nextInt();
    int k=cin.nextInt();
    int x=cin.nextInt();
    int a[]=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      a[i]=cin.nextInt();
    }
    int cnt=0 ;
    int ans=0 ;
    for(int i=1 ; i<=n-1 ; i++){
      if(a[i]==a[i+1] && x==a[i]){
        cnt=2 ;
        int l=i ;
        int r=i+1 ;
        l--;
        r++;
        int test=-1 ;
        if(l>=1 && r<=n && a[l]==a[r]){
          test=a[l];
        }
        while(l>=1 && r<=n &&(a[l]==test || a[r]==test)){
          int temp=0 ;
          while(l>=1 && a[l]==test){
            temp++;
            l--;
          }
          while(r<=n && a[r]==test){
            temp++;
            r++;
          }
          if(l>=1)test=a[l];
          if(r<=n)test=a[r];
          if(temp>=3){
            cnt+=temp ;
          }
          else break ;
        }
        ans=Math.max(ans,cnt);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation check( x : long) : boolean
  pre: true
  post: true
  activity: (     while (x /= 0) do (     var temp : long ; temp := if x mod 10 < 0 then -(x mod 10) else x mod 10 endif ;
     if (temp = 8) then     return true else skip ; 
     x := x/(10) ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := cin.getCurrent()->toInteger() ;
    var k : int ; k := cin.getCurrent()->toInteger() ;
    var x : int ; x := cin.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := cin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n - 1 do ( (     if (a[i+1] = a[i + 1+1] & x = a[i+1]) then (     cnt := 2 ; 
     var l : int ; l := i ;
    var r : int ; r := i + 1 ;
    l := l - 1 ; 
    r := r + 1 ; 
    var test : int ; test := -1 ;
    if (l >= 1 & r <= n & a[l+1] = a[r+1]) then (     test := a[l+1] ) else skip ; 
    while (l >= 1 & r <= n & (a[l+1] = test or a[r+1] = test)) do (     var temp : int ; temp := 0 ;
     while (l >= 1 & a[l+1] = test) do (     temp := temp + 1 ; 
     l := l - 1 ) ; 
    while (r <= n & a[r+1] = test) do (     temp := temp + 1 ; 
     r := r + 1 ) ; 
    if (l >= 1) then     test := a[l+1] ; else skip ; 
    if (r <= n) then     test := a[r+1] ; else skip ; 
    if (temp >= 3) then (     cnt := cnt+(temp) ) else     break ;  
 ) ; 
    ans := Set{ans, cnt}->max() ; 
 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test {
  static boolean check(long x){
    while(x!=0){
      long temp=Math.abs(x % 10);
      if(temp==8)return true ;
      x/=10 ;
    }
    return false ;
  }
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int n=cin.nextInt();
    int k=cin.nextInt();
    int x=cin.nextInt();
    int a[]=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      a[i]=cin.nextInt();
    }
    int cnt=0 ;
    int ans=0 ;
    for(int i=1 ; i<=n-1 ; i++){
      if(a[i]==a[i+1] && x==a[i]){
        cnt=2 ;
        int l=i ;
        int r=i+1 ;
        l--;
        r++;
        int test=-1 ;
        if(l>=1 && r<=n && a[l]==a[r]){
          test=a[l];
        }
        while(true){
          int temp=0 ;
          if(l<=1)test=a[l];
          else if(r<=n)test=a[r];
          else break ;
          while(l>=1 && a[l]==test){
            l--;
            temp++;
          }
          while(r<=n && a[r]==test){
            r++;
            temp++;
          }
          if(temp>=3)cnt+=temp ;
          else break ;
        }
        ans=Math.max(ans,cnt);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation check( x : long) : boolean
  pre: true
  post: true
  activity: (     while (x /= 0) do (     var temp : long ; temp := if x mod 10 < 0 then -(x mod 10) else x mod 10 endif ;
     if (temp = 8) then     return true else skip ; 
     x := x/(10) ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := cin.getCurrent()->toInteger() ;
    var k : int ; k := cin.getCurrent()->toInteger() ;
    var x : int ; x := cin.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := cin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n - 1 do ( (     if (a[i+1] = a[i + 1+1] & x = a[i+1]) then (     cnt := 2 ; 
     var l : int ; l := i ;
    var r : int ; r := i + 1 ;
    l := l - 1 ; 
    r := r + 1 ; 
    var test : int ; test := -1 ;
    if (l >= 1 & r <= n & a[l+1] = a[r+1]) then (     test := a[l+1] ) else skip ; 
    while (true) do (     var temp : int ; temp := 0 ;
     if (l <= 1) then     test := a[l+1] else     if (r <= n) then     test := a[r+1] else     break ;  ;  
    while (l >= 1 & a[l+1] = test) do (     l := l - 1 ; 
     temp := temp + 1 ) ; 
    while (r <= n & a[r+1] = test) do (     r := r + 1 ; 
     temp := temp + 1 ) ; 
    if (temp >= 3) then     cnt := cnt+(temp) else     break ;  
 ) ; 
    ans := Set{ans, cnt}->max() ; 
 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int returnWinner(String s,int l){
    int freq[]=new int[26];
    for(int i=0 ; i<l ; i++){
      freq[s.charAt(i)-'a']++;
    }
    int cnt=0 ;
    for(int i=0 ; i<26 ; i++){
      if(freq[i] % 2!=0)cnt++;
    }
    if((cnt==0)||(cnt & 1)==1)return 1 ;
    else return 2 ;
  }
  public static void main(String[] args){
    String s="abaaab" ;
    int l=s.length();
    int winner=returnWinner(s,l);
    System.out.println("Player-"+winner);
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation returnWinner( s : String, l : int) : int
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
         var i : int ; i := 0 ; while i < l do ( (     freq[s->at(i+1) - ('a')->char2byte()+1] := freq[s->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < 26 do ( (     if (freq[i+1] mod 2 /= 0) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
    if ((cnt = 0) or (MathLib.bitwiseAnd(cnt,1)) = 1) then     return 1 else     return 2 ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abaaab" ;
     var l : int ; l := s->size() ;
     var winner : int ; winner := returnWinner(s, l) ;
     OclFile["System.out"].println("Player-" + winner) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Hello {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int val=0 ;
    int i=0 ;
    int a=0 ;
    int min=Integer.MAX_VALUE ;
    int l=-1 ;
    int u=-1 ;
    while(val<=n){
      val=i*7 ;
      if(val>n)break ;
      if((n-val)% 4==0){
        a=(n-val)/4 ;
        if(min>(a+i)){
          min=a+i ;
          l=a ;
          u=i ;
        }
      }
      i++;
    }
    if(l==-1 && u==-1){
      System.out.println("-1");
    }
    else {
      for(i=0 ; i<l ; i++){
        System.out.print("4");
      }
      for(i=0 ; i<u ; i++){
        System.out.print("7");
      }
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hello {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var val : int ; val := 0 ;
    var i : int ; i := 0 ;
    var a : int ; a := 0 ;
    var min : int ; min := 2147483647 ;
    var l : int ; l := -1 ;
    var u : int ; u := -1 ;
    while (val <= n) do (     val := i * 7 ; 
     if (val > n) then     break else skip ; 
     if ((n - val) mod 4 = 0) then (     a := (n - val) / 4 ; 
     if (min > (a + i)) then (     min := a + i ; 
     l := a ; 
     u := i ) else skip ) else skip ; 
     i := i + 1 ) ; 
    if (l = -1 & u = -1) then (     OclFile["System.out"].println("-1") ) else (         i := 0 ; while i < l do ( (     OclFile["System.out"].print("4") )  ;     i := i + 1 ) ; 
         i := 0 ; while i < u do ( (     OclFile["System.out"].print("7") )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[])throws Exception {
    Scanner Input=new Scanner(System.in);
    long N=Input.nextLong();
    long M=Input.nextLong();
    long X=Math.min(N,M/2);
    long Ans=0 ;
    Ans+=X ;
    M-=X*2 ;
    Ans+=M/4 ;
    System.out.println(Ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Input : OclFile ; Input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := Input.getCurrent()->toLong() ;
    var M : long ; M := Input.getCurrent()->toLong() ;
    var X : long ; X := Set{N, M / 2}->min() ;
    var Ans : long ; Ans := 0 ;
    Ans := Ans+(X) ; 
    M := M-(X * 2) ; 
    Ans := Ans+(M / 4) ; 
    OclFile["System.out"].println(Ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    while(s.contains("0B")|| s.contains("1B")){
      s=s.replaceAll("0B","");
      s=s.replaceAll("1B","");
    }
    s=s.replaceAll("B","");
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    while (s->includes("0B") or s->includes("1B")) do (     s := s.replaceAllMatches("0B", "" ) ; 
     s := s.replaceAllMatches("1B", "" ) ) ; 
    s := s.replaceAllMatches("B", "" ) ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class luckySumOfDigits1000 {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    StringBuilder sb=new StringBuilder();
    while(num>0 && num % 7!=0){
      num-=4 ;
      sb.append(4);
    }
    while(num>0 && num % 7==0){
      num-=7 ;
      sb.append(7);
    }
    if(num==0)System.out.println(sb.toString());
    else System.out.println("-1");
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class luckySumOfDigits1000 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
    while (num > 0 & num mod 7 /= 0) do (     num := num-(4) ; 
     sb := sb + StringLib.newString(4) ) ; 
    while (num > 0 & num mod 7 = 0) do (     num := num-(7) ; 
     sb := sb + StringLib.newString(7) ) ; 
    if (num = 0) then     OclFile["System.out"].println(sb+"") else     OclFile["System.out"].println("-1") ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class CF0254A_CardsWithNumbers {
  static class Pair implements Comparable<Pair>{
    int val,id ;
    public Pair(int v,int i){
      val=v ;
      id=i ;
    }
    @ Override public int compareTo(Pair o){
      return val-o.val ;
    }
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new FileReader("input.txt"));
    PrintWriter wr=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    StringTokenizer tk=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(tk.nextToken());
    tk=new StringTokenizer(br.readLine());
    Pair[] pairs=new Pair[2*n];
    for(int i=0 ; i<2*n ; i++)pairs[i]=new Pair(Integer.parseInt(tk.nextToken()),i+1);
    Arrays.sort(pairs);
    Pair[] ans=new Pair[n];
    boolean flag=false ;
    for(int i=0 ; i<n ; i++){
      if(pairs[2*i] .val==pairs[2*i+1] .val)ans[i]=new Pair(pairs[2*i] .id,pairs[2*i+1] .id);
      else {
        flag=true ;
        break ;
      }
    }
    if(flag){
      wr.println(-1);
    }
    else {
      for(int i=0 ; i<n ; i++)wr.println(ans[i] .val+" "+ans[i] .id);
    }
    br.close();
    wr.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF0254A_CardsWithNumbers {
  static class Pair implements Comparable<Map> {
   attribute val : int;
   static operation newPair( v : int, i : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(v, i);
    return self );
  operation initialise( v : int, i : int) : void
  pre: true  post: true
  activity: (     val := v ; 
     id := i );
      operation compareTo( o : Map) : int
  pre: true
  post: true
  activity: (     return val - o.val );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ;
     var wr : OclFile ; wr := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ;
    var tk : OclIterator ; tk := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (tk.next())->toInteger() ;
    tk := OclIterator.newOclIterator_String(br.readLine()) ; 
    var pairs : Sequence(Map) ; pairs := Integer.subrange(1,2 * n)->collect(null) ;
        var i : int ; i := 0 ; while i < 2 * n do (     pairs[i+1] := Map((tk.next())->toInteger(), i + 1) ;  ;     i := i + 1 ) ; 
    pairs := pairs->sort() ; 
    var ans : Sequence(Map) ; ans := Integer.subrange(1,n)->collect(null) ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < n do ( (     if (pairs[2 * i+1].val = pairs[2 * i + 1+1].val) then     ans[i+1] := Map(pairs[2 * i+1].id, pairs[2 * i + 1+1].id) ; else (     flag := true ; 
     break ) )  ;     i := i + 1 ) ; 
    if (flag) then (     skip ) else (         var i : int ; i := 0 ; while i < n do (     skip ;  ;     i := i + 1 ) ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(new File("input.txt"));
    int n=sc.nextInt();
    int[] arr=new int[5001];
    StringBuilder sb=new StringBuilder();
    for(int i=1 ; i<=2*n ; i++){
      int v=sc.nextInt();
      if(arr[v]==0){
        arr[v]=i ;
      }
      else {
        sb.append(arr[v]+" "+i+"\n");
        arr[v]=0 ;
      }
    }
    boolean poss=true ;
    for(int i : arr){
      if(i!=0){
        poss=false ;
        break ;
      }
    }
    PrintWriter pw=new PrintWriter("output.txt");
    if(poss){
      pw.print(sb);
    }
    else {
      pw.print(-1);
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile("input.txt")) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,5001)->collect(0) ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 1 ; while i <= 2 * n do ( (     var v : int ; v := sc.getCurrent()->toInteger() ;
     if (arr[v+1] = 0) then (     arr[v+1] := i ) else (     sb := sb + StringLib.newString(arr[v+1] + " " + i + "\n") ; 
     arr[v+1] := 0 ) )  ;     i := i + 1 ) ; 
    var poss : boolean ; poss := true ;
    for (i : arr) do ( (     if (i /= 0) then (     poss := false ; 
     break ) else skip )  ) ; 
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
    if (poss) then (     skip ) else (     skip ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int[] num_to_bits=new int[] {
    0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4 };
    static int countSetBitsRec(int num){
      int nibble=0 ;
      if(0==num)return num_to_bits[0];
      nibble=num & 0xf ;
      return num_to_bits[nibble]+countSetBitsRec(num>>4);
    }
    public static void main(String[] args){
      int num=31 ;
      System.out.println(countSetBitsRec(num));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute num_to_bits : Sequence(int) := Sequence{0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4};
  static   operation countSetBitsRec( num : int) : int
  pre: true
  post: true
  activity: (     var nibble : int ; nibble := 0 ;
     if (0 = num) then     return num_to_bits[0+1] else skip ; 
     nibble := num & 0xf ; 
     return num_to_bits[nibble+1] + countSetBitsRec((num/(2->pow(4)))->oclAsType(long)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 31 ;
     OclFile["System.out"].println(countSetBitsRec(num)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.math.*;
public class WhoMadeThisUselessQuestion {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    BigInteger l=in.nextBigInteger();
    BigInteger r=in.nextBigInteger();
    BigInteger k=in.nextBigInteger();
    BigInteger t=BigInteger.valueOf(1);
    while(t.compareTo(l)<0)t=t.multiply(k);
    if(t.compareTo(r)>0){
      System.out.println(-1);
      return ;
    }
    while(t.compareTo(r)<=0){
      System.out.print(t+" ");
      t=t.multiply(k);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class WhoMadeThisUselessQuestion {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : long ; l := in.nextBigInteger() ;
    var r : long ; r := in.nextBigInteger() ;
    var k : long ; k := in.nextBigInteger() ;
    var t : long ; t := (1 + "")->toLong() ;
    while (t->compareTo(l) < 0) do     t := t.multiply(k) ; ; 
    if (t->compareTo(r) > 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    while (t->compareTo(r) <= 0) do (     OclFile["System.out"].print(t + " ") ; 
     t := t.multiply(k) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Reader in=new Reader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    long l,r,k ;
    l=in.nextLong();
    r=in.nextLong();
    k=in.nextLong();
    long now=1 ;
    List<Long>ans=new Vector<>();
    while(now<=r){
      if(l<=now){
        ans.add(now);
      }
      if(now>Long.MAX_VALUE/k){
        break ;
      }
      now*=k ;
    }
    if(ans.isEmpty()){
      out.println(-1);
    }
    else {
      for(long value : ans){
        out.print(value);
        out.print(' ');
      }
      out.println();
    }
    out.flush();
    in.close();
    out.close();
  }
  static class Reader {
    BufferedReader reader ;
    StringTokenizer st ;
    Reader(InputStreamReader stream){
      reader=new BufferedReader(stream);
      st=null ;
    }
    void close()throws IOException {
      reader.close();
    }
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    String nextLine()throws IOException {
      return reader.readLine();
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var l : long ;
    var r : long ;
    var k : long ;
    l := in.getCurrent()->toLong() ; 
    r := in.getCurrent()->toLong() ; 
    k := in.getCurrent()->toLong() ; 
    var now : long ; now := 1 ;
    var ans : Sequence(long) ; ans := Sequence{} ;
    while (now <= r) do (     if (l <= now) then (     ans := ans->including(now) ) else skip ; 
     if (now > "9223372036854775807"->toLong() / k) then (     break ) else skip ; 
     now := now*(k) ) ; 
    if (ans->isEmpty()) then (     skip ) else (     for (value : ans) do ( (     skip ; 
     skip )  ) ; 
     skip ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static class Reader {
   attribute reader : OclFile;
   attribute st : OclIterator;
   static operation newReader( stream : OclFile) : Reader
  pre: true
  post: true
  activity:
  ( var self : Reader ;
    self := createReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(stream) ; 
     st := null );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return reader.readLine() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printPartition(int n,int m){
    int k=n/m ;
    int ct=n % m ;
    int i ;
    for(i=1 ; i<=ct ; i++)System.out.print(k+1+" ");
    for(; i<=m ; i++)System.out.print(k+" ");
  }
  public static void main(String[] args){
    int n=5,m=2 ;
    printPartition(n,m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printPartition( n : int, m : int) : void
  pre: true
  post: true
  activity: (     var k : int ; k := n / m ;
     var ct : int ; ct := n mod m ;
    var i : int ;
        i := 1 ; while i <= ct do (     OclFile["System.out"].print(k + 1 + " ") ;  ;     i := i + 1 ) ; 
      while i <= m do (     OclFile["System.out"].print(k + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var m : int ; m := 2 ;
     execute printPartition(n, m) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int count_element(int N,int K,int[] arr){
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(int i=0 ; i<N ; ++i)if(mp.containsKey(arr[i])){
      mp.put(arr[i],mp.get(arr[i])+1);
    }
    else {
      mp.put(arr[i],1);
    }
    int answer=0 ;
    for(Map.Entry<Integer,Integer>i : mp.entrySet()){
      if(mp.containsKey(i.getKey()+K))answer+=i.getValue();
    }
    return answer ;
  }
  public static void main(String[] args){
    int arr[]={
      3,6,2,8,7,6,5,9 };
      int N=arr.length ;
      int K=2 ;
      System.out.print(count_element(N,K,arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count_element( N : int, K : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < N do (     if (mp->keys()->includes(arr[i+1])) then (     mp := mp->union(Map{arr[i+1] |-> mp->at(arr[i+1]) + 1}) ) else (     mp := mp->union(Map{arr[i+1] |-> 1}) ) ;   ;     i := i + 1 ) ; 
    var answer : int ; answer := 0 ;
    for (i : mp->asSet()) do ( (     if (mp->keys()->includes(i.getKey() + K)) then     answer := answer+(i.getValue()) ; else skip )  ) ; 
    return answer 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,6,2,8,7,6,5,9} ;
     var N : int ; N := arr->size() ;
     var K : int ; K := 2 ;
     OclFile["System.out"].print(count_element(N, K, arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
import java.util.*;
import java.util.function.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] A=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
    }
    sc.close();
    BigInteger lcm=BigInteger.ONE ;
    for(int ai : A){
      BigInteger a=BigInteger.valueOf(ai);
      lcm=lcm.divide(lcm.gcd(a)).multiply(a);
    }
    long mod=1000000007 ;
    long modLcm=lcm.remainder(BigInteger.valueOf(mod)).longValue();
    long ans=0 ;
    for(int ai : A)ans=(ans+modDiv(modLcm,ai,mod))% mod ;
    System.out.println(ans);
  }
  private static long modDiv(long a,long b,long mod){
    return(a % mod)*modInv(b,mod)% mod ;
  }
  private static long modInv(long x,long mod){
    return modPow(x,mod-2,mod);
  }
  private static long modPow(long b,long e,long mod){
    long ans=1 ;
    long x=b % mod ;
    for(long y=e ; y!=0 ; y>>=1){
      if((y & 1)==1)ans=(ans*x)% mod ;
      x=(x*x)% mod ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var lcm : long ; lcm := 1 ;
    for (ai : A) do ( (     var a : long ; a := (ai + "")->toLong() ;
     lcm := lcm.divide(lcm.gcd(a)).multiply(a) )  ) ; 
    var mod : long ; mod := 1000000007 ;
    var modLcm : long ; modLcm := lcm.remainder((mod + "")->toLong())->oclAsType(long) ;
    var ans : long ; ans := 0 ;
    for (ai : A) do (     ans := (ans + modDiv(modLcm, ai, mod)) mod mod ;  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation modDiv( a : long, b : long, mod : long) : long
  pre: true
  post: true
  activity: (     return (a mod mod) * modInv(b, mod) mod mod );
  static   operation modInv( x : long, mod : long) : long
  pre: true
  post: true
  activity: (     return modPow(x, mod - 2, mod) );
  static   operation modPow( b : long, e : long, mod : long) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
     var x : long ; x := b mod mod ;
         var y : long ; y := e ; while y /= 0 do ( (     if ((MathLib.bitwiseAnd(y,1)) = 1) then     ans := (ans * x) mod mod ; else skip ; 
     x := (x * x) mod mod )  ;     y := y/(2->pow(1)) ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    new Main().solve();
  }
  void solve(){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    long M=sc.nextLong();
    long ans=0 ;
    if(N*2<=M){
      M-=2*N ;
      ans+=N ;
    }
    else {
      M=M/2 ;
      System.out.println(M);
      return ;
    }
    M=M/4 ;
    ans+=M ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    var M : long ; M := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
    if (N * 2 <= M) then (     M := M-(2 * N) ; 
     ans := ans+(N) ) else (     M := M / 2 ; 
     OclFile["System.out"].println(M) ; 
     return ) ;  
    M := M / 4 ; 
    ans := ans+(M) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Vector<Integer>arr=new Vector<Integer>();
  static void generateDivisors(int n){
    for(int i=1 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        if(n/i==i)arr.add(i);
        else {
          arr.add(i);
          arr.add(n/i);
        }
      }
    }
  }
  static double harmonicMean(int n){
    generateDivisors(n);
    double sum=0.0 ;
    int len=arr.size();
    for(int i=0 ; i<len ; i++)sum=sum+n/arr.get(i);
    sum=sum/n ;
    return arr.size()/sum ;
  }
  static boolean isOreNumber(int n){
    double mean=harmonicMean(n);
    if(mean-Math.floor(mean)==0)return true ;
    else return false ;
  }
  public static void main(String[] args){
    int n=28 ;
    if(isOreNumber(n))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute arr : Sequence(int) := Sequence{};
  static   operation generateDivisors( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     if (n / i = i) then     arr := arr->including(i) ; else (     arr := arr->including(i) ; 
     arr := arr->including(n / i) ) ) else skip )  ;     i := i + 1 ) );
  static   operation harmonicMean( n : int) : double
  pre: true
  post: true
  activity: (     execute generateDivisors(n) ; 
     var sum : double ; sum := 0.0 ;
    var len : int ; len := arr->size() ;
        var i : int ; i := 0 ; while i < len do (     sum := sum + n / arr->at(i+1) ;  ;     i := i + 1 ) ; 
    sum := sum / n ; 
    return arr->size() / sum 
 );
  static   operation isOreNumber( n : int) : boolean
  pre: true
  post: true
  activity: (     var mean : double ; mean := harmonicMean(n) ;
     if (mean - (mean)->floor() = 0) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 28 ;
     if (isOreNumber(n)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int subsetSum(int arr[],int n,int i,int sum,int count){
    if(i==n){
      if(sum==0){
        count++;
      }
      return count ;
    }
    count=subsetSum(arr,n,i+1,sum-arr[i],count);
    count=subsetSum(arr,n,i+1,sum,count);
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5 };
      int sum=10 ;
      int n=arr.length ;
      System.out.print(subsetSum(arr,n,0,sum,0));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation subsetSum( arr : Sequence(int), n : int, i : int, sum : int, count : int) : int
  pre: true
  post: true
  activity: (     if (i = n) then (     if (sum = 0) then (     count := count + 1 ) else skip ; 
     return count ) else skip ; 
     count := subsetSum(arr, n, i + 1, sum - arr[i+1], count) ; 
     count := subsetSum(arr, n, i + 1, sum, count) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var sum : int ; sum := 10 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(subsetSum(arr, n, 0, sum, 0)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static long mod=(long)(1e9+7);
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    boolean flag=false ;
    for(int tt=1 ; tt<=test ; tt++){
      int n=in.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      long sum=a[0]+a[n-1];
      if(n==1){
        sum=a[0];
      }
      for(int i=1 ; i<n-1 ; i++){
        if(a[i]>a[i-1] || a[i]>a[i+1]){
          sum+=a[i]-Math.min(a[i-1],a[i+1]);
        }
      }
      pw.println(sum);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : long := (1e9 + 7)->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
    var flag : boolean ; flag := false ;
        var tt : int ; tt := 1 ; while tt <= test do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := a[0+1] + a[n - 1+1] ;
    if (n = 1) then (     sum := a[0+1] ) else skip ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     if (a[i+1] > a[i - 1+1] or a[i+1] > a[i + 1+1]) then (     sum := sum+(a[i+1] - Set{a[i - 1+1], a[i + 1+1]}->min()) ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     tt := tt + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
public class HistogramUgliness {
  public static void main(String[] args){
    Scanner a=new Scanner(System.in);
    int test=a.nextInt();
    for(int b=0 ; b<test ; b++){
      int n=a.nextInt();
      int[] array=new int[n];
      for(int c=0 ; c<n ; c++)array[c]=a.nextInt();
      BigInteger sum=BigInteger.ZERO ;
      for(int c=0 ; c<n ; c++){
        if(c==0){
          sum=sum.add(new BigInteger(""+array[0]));
          if(array.length>1)if(array[1]<array[0])array[0]=array[1];
        }
        else if(c==n-1){
          sum=sum.add(new BigInteger(""+array[c]));
          if(array[c-1]>array[c])sum=sum.add(new BigInteger(""+(array[c-1]-array[c])));
        }
        else {
          sum=sum.add(new BigInteger(""+Math.abs(array[c]-array[c-1])));
          if(array[c]>array[c-1] && array[c]>array[c+1])array[c]-=Math.min(array[c]-array[c-1],array[c]-array[c+1]);
        }
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HistogramUgliness {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : OclFile ; a := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := a.getCurrent()->toInteger() ;
         var b : int ; b := 0 ; while b < test do ( (     var n : int ; n := a.getCurrent()->toInteger() ;
     var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
        var c : int ; c := 0 ; while c < n do (     array[c+1] := a.getCurrent()->toInteger() ;  ;     c := c + 1 ) ; 
    var sum : long ; sum := 0 ;
        var c : int ; c := 0 ; while c < n do ( (     if (c = 0) then (     sum := sum->excludes(long("" + array[0+1])) ; 
     if (array->size() > 1) then     if (array[1+1] < array[0+1]) then     array[0+1] := array[1+1] ; else skip ; else skip ) else     if (c = n - 1) then (     sum := sum->excludes(long("" + array[c+1])) ; 
     if (array[c - 1+1] > array[c+1]) then     sum := sum->excludes(long("" + (array[c - 1+1] - array[c+1]))) ; else skip ) else (     sum := sum->excludes(long("" + if array[c+1] - array[c - 1+1] < 0 then -(array[c+1] - array[c - 1+1]) else array[c+1] - array[c - 1+1] endif)) ; 
     if (array[c+1] > array[c - 1+1] & array[c+1] > array[c + 1+1]) then     array[c+1] := array[c+1]-(Set{array[c+1] - array[c - 1+1], array[c+1] - array[c + 1+1]}->min()) ; else skip ) ;  )  ;     c := c + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     b := b + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int solve(int A[],int B[],int n){
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i ; j<n ; j++){
        if(Integer.bitCount(A[i] & A[j])==B[j]){
          cnt++;
        }
      }
    }
    return cnt ;
  }
  public static void main(String[] args){
    int A[]={
      2,3,1,4,5 };
      int B[]={
        2,2,1,4,2 };
        int size=A.length ;
        System.out.println(solve(A,B,size));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( A : Sequence(int), B : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i ; while j < n do ( (     if (bitCount(A[i+1] & A[j+1]) = B[j+1]) then (     cnt := cnt + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{2,3,1,4,5} ;
     var B : Sequence(int) ; B := Sequence{2,2,1,4,2} ;
     var size : int ; size := A->size() ;
     OclFile["System.out"].println(solve(A, B, size)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int solve(int A[],int B[],int n){
    int cnt=0 ;
    for(int i=0 ; i<n ; i++)for(int j=i ; j<n ; j++)if(Integer.bitCount(A[i] | A[j])==B[j]){
      cnt++;
    }
    return cnt ;
  }
  public static void main(String args[]){
    int A[]={
      5,3,2,4,6,1 };
      int B[]={
        2,2,1,4,2,3 };
        int size=A.length ;
        System.out.println(solve(A,B,size));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation solve( A : Sequence(int), B : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := i ; while j < n do (     if (bitCount(A[i+1] or A[j+1]) = B[j+1]) then (     cnt := cnt + 1 ) else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{5,3,2,4,6,1} ;
     var B : Sequence(int) ; B := Sequence{2,2,1,4,2,3} ;
     var size : int ; size := A->size() ;
     OclFile["System.out"].println(solve(A, B, size)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean rightRotationDivisor(int N){
    int lastDigit=N % 10 ;
    int rightRotation=(int)(lastDigit*Math.pow(10,(int)(Math.log10(N)))+Math.floor(N/10));
    return(rightRotation % N==0);
  }
  static void generateNumbers(int m){
    for(int i=(int)Math.pow(10,(m-1)); i<Math.pow(10,m); i++)if(rightRotationDivisor(i))System.out.println(i);
  }
  public static void main(String args[]){
    int m=3 ;
    generateNumbers(m);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation rightRotationDivisor( N : int) : boolean
  pre: true
  post: true
  activity: (     var lastDigit : int ; lastDigit := N mod 10 ;
     var rightRotation : int ; rightRotation := (lastDigit * 10->pow(((N)->log10())->oclAsType(int)) + (N / 10)->floor())->oclAsType(int) ;
     return (rightRotation mod N = 0) );
  static   operation generateNumbers( m : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 10->pow((m - 1))->oclAsType(int) ; while i < 10->pow(m) do (     if (rightRotationDivisor(i)) then     OclFile["System.out"].println(i) ; else skip ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 3 ;
     execute generateNumbers(m) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printArr(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  static void generateArr(int A[],int n){
    int[] B=new int[n];
    for(int i=0 ; i<n ; i++){
      int cnt=0 ;
      for(int j=0 ; j<i ; j++){
        if(A[j] % A[i]==0)cnt++;
      }
      B[i]=cnt ;
    }
    printArr(B,n);
  }
  public static void main(String args[]){
    int A[]={
      3,5,1 };
      int n=A.length ;
      generateArr(A,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation generateArr( A : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var B : Sequence(int) ; B := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     var cnt : int ; cnt := 0 ;
         var j : int ; j := 0 ; while j < i do ( (     if (A[j+1] mod A[i+1] = 0) then     cnt := cnt + 1 ; else skip )  ;     j := j + 1 ) ; 
     B[i+1] := cnt )  ;     i := i + 1 ) ; 
     execute printArr(B, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{3,5,1} ;
     var n : int ; n := A->size() ;
     execute generateArr(A, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countUnique(int arr[],int n){
    HashSet<Integer>s=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      s.add(arr[i]);
    }
    int count=(int)Math.pow(s.size(),2);
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,2,4,2,5,3,5 };
      int n=arr.length ;
      System.out.println(countUnique(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countUnique( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     s := s->including(arr[i+1]) )  ;     i := i + 1 ) ; 
     var count : int ; count := s->size()->pow(2)->oclAsType(int) ;
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,2,4,2,5,3,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countUnique(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    LightScanner in=new LightScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BUnhappyHackingABCEdit solver=new BUnhappyHackingABCEdit();
    solver.solve(1,in,out);
    out.close();
  }
  static class BUnhappyHackingABCEdit {
    public void solve(int testNumber,LightScanner in,PrintWriter out){
      String s=in.string();
      StringBuilder d=new StringBuilder();
      for(char c : s.toCharArray()){
        switch(c){
          case '0' : d.append("0");
          break ;
          case '1' : d.append("1");
          break ;
          case 'B' : if(d.length()>0){
            d.setLength(d.length()-1);
            d.trimToSize();
          }
          break ;
        }
      }
      out.println(d);
    }
  }
  static class LightScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public LightScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String string(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : LightScanner ; in := LightScanner.newLightScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BUnhappyHackingABCEdit ; solver := BUnhappyHackingABCEdit.newBUnhappyHackingABCEdit() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BUnhappyHackingABCEdit {
   operation solve( testNumber : int, in : LightScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.string() ;
     var d : String ; d := StringLib.newString() ;
     for (c : s->characters()) do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
       if _switchval = '0' then
     d := d + StringLib.newString("0") ; 
    break 
   else skip ;
       if _switchval = '1' then
     d := d + StringLib.newString("1") ; 
    break 
   else skip ;
       if _switchval = 'B' then
     if (d->size() > 0) then (     d := d.subrange(1,d->size() - 1) ; 
     d.trimToSize() ) else skip ; 
    break 
   else skip ;
 )
 )  ) ; 
     skip );
}
  static class LightScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newLightScanner( in : OclFile) : LightScanner
  pre: true
  post: true
  activity:
  ( var self : LightScanner ;
    self := createLightScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation string() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class Node {
    int key ;
    Node next ;
  };
  static Node push(Node head_ref,int new_key){
    Node new_node=new Node();
    new_node.key=new_key ;
    new_node.next=(head_ref);
(head_ref)=new_node ;
    return head_ref ;
  }
  static int countMinimum(Node head){
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    Node current=head ;
    while(current!=null){
      int data=current.key ;
      mp.put(data,(mp.get(data)==null ? 1 : mp.get(data)+1));
      current=current.next ;
    }
    current=head ;
    int min_frequency=Integer.MAX_VALUE,countMin=0 ;
    for(Map.Entry<Integer,Integer>it : mp.entrySet()){
      if(it.getValue()<=min_frequency){
        min_frequency=it.getValue();
      }
    }
    for(Map.Entry<Integer,Integer>it : mp.entrySet()){
      if(it.getValue()==min_frequency){
        countMin+=(it.getValue());
      }
    }
    return countMin ;
  }
  public static void main(String args[]){
    Node head=null ;
    int x=21 ;
    head=push(head,10);
    head=push(head,30);
    head=push(head,11);
    head=push(head,10);
    head=push(head,10);
    System.out.println(countMinimum(head));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Node {
   attribute key : int;
   attribute next : Node;
}
  static   operation push( head_ref : Node, new_key : int) : Node
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode() ;
     new_node.key := new_key ; 
    new_node.next := (head_ref) ; 
    (head_ref) := new_node ; 
    return head_ref 
 );
  static   operation countMinimum( head : Node) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
     var current : Node ; current := head ;
    while (current /= null) do (     var data : int ; data := current.key ;
     mp := mp->union(Map{data |-> (if mp->at(data) = null then 1 else mp->at(data) + 1 endif)}) ; 
     current := current.next ) ; 
    current := head ; 
    var min_frequency : int ; min_frequency := 2147483647 ;
    var countMin : int ; countMin := 0 ;
    for (it : mp->asSet()) do ( (     if (it.getValue() <= min_frequency) then (     min_frequency := it.getValue() ) else skip )  ) ; 
    for (it : mp->asSet()) do ( (     if (it.getValue() = min_frequency) then (     countMin := countMin+((it.getValue())) ) else skip )  ) ; 
    return countMin 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := null ;
     var x : int ; x := 21 ;
    head := push(head, 10) ; 
    head := push(head, 30) ; 
    head := push(head, 11) ; 
    head := push(head, 10) ; 
    head := push(head, 10) ; 
    OclFile["System.out"].println(countMinimum(head)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void subString(char str[],int n){
    for(int len=1 ; len<=n ; len++){
      for(int i=0 ; i<=n-len ; i++){
        int j=i+len-1 ;
        for(int k=i ; k<=j ; k++){
          System.out.print(str[k]);
        }
        System.out.println();
      }
    }
  }
  public static void main(String[] args){
    char str[]={
      'a','b','c' };
      subString(str,str.length);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation subString( str : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (         var len : int ; len := 1 ; while len <= n do ( (         var i : int ; i := 0 ; while i <= n - len do ( (     var j : int ; j := i + len - 1 ;
         var k : int ; k := i ; while k <= j do ( (     OclFile["System.out"].print(str[k+1]) )  ;     k := k + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) )  ;     len := len + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := Sequence{'a','b','c'} ;
     execute subString(str, str->size()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] a=new int[N];
    int sum=0 ;
    int squareSum=0 ;
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextInt();
      sum+=a[i];
      squareSum+=a[i]*a[i];
    }
    long x=Math.round(sum/(double)N);
    System.out.println(N*x*x-2*x*sum+squareSum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var sum : int ; sum := 0 ;
    var squareSum : int ; squareSum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) ; 
     squareSum := squareSum+(a[i+1] * a[i+1]) )  ;     i := i + 1 ) ; 
    var x : long ; x := (sum / N->oclAsType(double))->round() ;
    OclFile["System.out"].println(N * x * x - 2 * x * sum + squareSum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  static class IO {
    BufferedReader br ;
    StringTokenizer st ;
    public IO(){
      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 ;
    }
    long[] readarray(int sz){
      long[] ret=new long[sz];
      for(int i=0 ; i<sz ; i++)ret[i]=nextLong();
      return ret ;
    }
  }
  public static void main(String[] args){
    IO fs=new IO();
    int n=fs.nextInt();
    long[] a=fs.readarray(n);
    long ans=Long.MAX_VALUE ;
    for(long i=-1000000 ; i<=1000000 ; i++){
      long curr=0 ;
      for(int j=0 ; j<n ; j++){
        curr+=((a[j]-i)*(a[j]-i));
      }
      ans=Math.min(ans,curr);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class IO {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newIO() : IO
  pre: true
  post: true
  activity:
  ( var self : IO ;
    self := createIO();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation readarray( sz : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var ret : Sequence(long) ; ret := Integer.subrange(1,sz)->collect(0) ;
         var i : int ; i := 0 ; while i < sz do (     ret[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return ret );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : IO ; fs := IO.newIO() ;
     var n : int ; n := fs.nextInt() ;
    var a : Sequence(long) ; a := fs.readarray(n) ;
    var ans : long ; ans := "9223372036854775807"->toLong() ;
        var i : long ; i := -1000000 ; while i <= 1000000 do ( (     var curr : long ; curr := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     curr := curr+(((a[j+1] - i) * (a[j+1] - i))) )  ;     j := j + 1 ) ; 
     ans := Set{ans, curr}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int count=sc.nextInt();
      List<Integer>list=new ArrayList<>();
      int max=Integer.MIN_VALUE ;
      int min=Integer.MAX_VALUE ;
      while(count-->0){
        int a=sc.nextInt();
        if(a>max)max=a ;
        if(a<min)min=a ;
        list.add(a);
      }
      if(max==min){
        System.out.println(0);
      }
      else {
        int res=Integer.MAX_VALUE ;
        for(int i=min ; i<=max ; i++){
          int minValue=getMinValue(list,i);
          if(minValue<res)res=minValue ;
        }
        System.out.println(res);
      }
    }
  }
  public static int getMinValue(List<Integer>list,int value){
    int sum=0 ;
    for(Integer x : list){
      sum+=(x-value)*(x-value);
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var count : int ; count := sc.getCurrent()->toInteger() ;
     var list : Sequence(int) ; list := Sequence{} ;
    var max : int ; max := -2147483648 ;
    var min : int ; min := 2147483647 ;
        while (count > 0) do (        count := count - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (a > max) then     max := a ; else skip ; 
     if (a < min) then     min := a ; else skip ; 
     list := list->including(a) ) ;  ) ;  
    if (max = min) then (     OclFile["System.out"].println(0) ) else (     var res : int ; res := 2147483647 ;
         var i : int ; i := min ; while i <= max do ( (     var minValue : int ; minValue := getMinValue(list, i) ;
     if (minValue < res) then     res := minValue ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(res) ) ;  
 ) );
  static   operation getMinValue( list : Sequence(int), value : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     for (x : list) do ( (     sum := sum+((x - value) * (x - value)) )  ) ; 
     return sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    InputReader in=new InputReader();
    int n=in.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=in.nextInt();
    long res=Long.MAX_VALUE ;
    for(int i=-100 ; i<=100 ; i++){
      long cost=0 ;
      for(int j=0 ; j<n ; j++)cost+=(arr[j]-i)*(arr[j]-i);
      res=Math.min(res,cost);
    }
    System.out.println(res);
  }
  static class InputReader {
    public BufferedReader br ;
    public StringTokenizer st ;
    public InputReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
      st=null ;
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : InputReader ; in := InputReader.newInputReader() ;
     var n : int ; n := in.nextInt() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := in.nextInt() ;  ;     i := i + 1 ) ; 
    var res : long ; res := "9223372036854775807"->toLong() ;
        var i : int ; i := -100 ; while i <= 100 do ( (     var cost : long ; cost := 0 ;
         var j : int ; j := 0 ; while j < n do (     cost := cost+((arr[j+1] - i) * (arr[j+1] - i)) ;  ;     j := j + 1 ) ; 
     res := Set{res, cost}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static class InputReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newInputReader() : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    boolean isSame=false ;
    for(int i=0 ; i<a.length-1 ; i++){
      if(!(a[i]==a[i+1])){
        break ;
      }
      if(i==a.length-2){
        isSame=true ;
      }
    }
    int c=0 ;
    if(!(isSame)){
      Arrays.sort(a);
      int minC=999999999 ;
      for(int i=a[0]; i<=a[n-1]; i++){
        int temp=0 ;
        for(int j=0 ; j<n ; j++){
          if(!(i==a[j])){
            temp+=Math.pow(a[j]-i,2);
          }
        }
        if(temp<minC){
          minC=temp ;
        }
      }
      c=minC ;
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var isSame : boolean ; isSame := false ;
        var i : int ; i := 0 ; while i < a->size() - 1 do ( (     if (not((a[i+1] = a[i + 1+1]))) then (     break ) else skip ; 
     if (i = a->size() - 2) then (     isSame := true ) else skip )  ;     i := i + 1 ) ; 
    var c : int ; c := 0 ;
    if (not((isSame))) then (     a := a->sort() ; 
     var minC : int ; minC := 999999999 ;
         var i : int ; i := a[0+1] ; while i <= a[n - 1+1] do ( (     var temp : int ; temp := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (not((i = a[j+1]))) then (     temp := temp+(a[j+1] - i->pow(2)) ) else skip )  ;     j := j + 1 ) ; 
     if (temp < minC) then (     minC := temp ) else skip )  ;     i := i + 1 ) ; 
     c := minC ) else skip ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String nextGreater(String num){
    int l=num.length();
    int i ;
    for(i=l-1 ; i>=0 ; i--){
      if(num.charAt(i)=='0'){
        num=num.substring(0,i)+'1'+num.substring(i+1);
        break ;
      }
      else {
        num=num.substring(0,i)+'0'+num.substring(i+1);
      }
    }
    if(i<0){
      num="1"+num ;
    }
    return num ;
  }
  public static void main(String[] args){
    String num="10011" ;
    System.out.println("Binary representation of next number="+nextGreater(num));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nextGreater( num : String) : String
  pre: true
  post: true
  activity: (     var l : int ; l := num->size() ;
     var i : int ;
        i := l - 1 ; while i >= 0 do ( (     if (num->at(i+1) = '0') then (     num := num.subrange(0+1,i) + '1' + num.subrange(i + 1+1,i + 1) ; 
     break ) else (     num := num.subrange(0+1,i) + '0' + num.subrange(i + 1+1,i + 1) ) )  ;     i := i - 1 ) ; 
    if (i < 0) then (     num := "1" + num ) else skip ; 
    return num 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : String ; num := "10011" ;
     OclFile["System.out"].println("Binary representation of next number=" + nextGreater(num)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PupilsRedistribution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr1=new int[6];
    int[] arr2=new int[6];
    for(int i=0 ; i<n ; i++){
      arr1[sc.nextInt()]++;
    }
    for(int i=0 ; i<n ; i++){
      arr2[sc.nextInt()]++;
    }
    if(n==1 && arr1[0]!=arr2[0]){
      System.out.println(-1);
      return ;
    }
    int sum=0 ;
    int[] difference=new int[6];
    for(int i=1 ; i<=5 ; i++){
      sum=arr1[i]+arr2[i];
      if(sum % 2!=0){
        System.out.println(-1);
        return ;
      }
      else {
        difference[i]=arr1[i]-arr2[i];
      }
    }
    int sum2=0 ;
    int zheng=0 ;
    for(int i=1 ; i<=5 ; i++){
      sum2+=difference[i];
      if(difference[i]>0){
        zheng+=difference[i];
      }
    }
    if(sum2==0){
      System.out.println(zheng/2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PupilsRedistribution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,6)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,6)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr1[sc.getCurrent()->toInteger()+1] := arr1[sc.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr2[sc.getCurrent()->toInteger()+1] := arr2[sc.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
    if (n = 1 & arr1[0+1] /= arr2[0+1]) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    var sum : int ; sum := 0 ;
    var difference : Sequence(int) ; difference := Integer.subrange(1,6)->collect(0) ;
        var i : int ; i := 1 ; while i <= 5 do ( (     sum := arr1[i+1] + arr2[i+1] ; 
     if (sum mod 2 /= 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else (     difference[i+1] := arr1[i+1] - arr2[i+1] ) )  ;     i := i + 1 ) ; 
    var sum2 : int ; sum2 := 0 ;
    var zheng : int ; zheng := 0 ;
        var i : int ; i := 1 ; while i <= 5 do ( (     sum2 := sum2+(difference[i+1]) ; 
     if (difference[i+1] > 0) then (     zheng := zheng+(difference[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    if (sum2 = 0) then (     OclFile["System.out"].println(zheng / 2) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int[] a=new int[5],b=new int[5];
    for(int i=0 ; i<n ; i++){
      int c=scanner.nextInt()-1 ;
      a[c]+=1 ;
      b[c]+=1 ;
    }
    for(int i=0 ; i<n ; i++){
      int c=scanner.nextInt()-1 ;
      a[c]+=1 ;
    }
    for(int i=0 ; i<5 ; i++){
      if((a[i] & 1)!=0){
        System.out.println(-1);
        return ;
      }
      else {
        a[i]>>=1 ;
      }
    }
    int ans=0 ;
    for(int i=0 ; i<5 ; i++){
      ans+=Math.abs(a[i]-b[i]);
    }
    System.out.println(ans/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,5)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,5)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var c : int ; c := scanner.getCurrent()->toInteger() - 1 ;
     a[c+1] := a[c+1]+(1) ; 
     b[c+1] := b[c+1]+(1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var c : int ; c := scanner.getCurrent()->toInteger() - 1 ;
     a[c+1] := a[c+1]+(1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 5 do ( (     if ((a[i+1] & 1) /= 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else (     a[i+1] := a[i+1]/(2->pow(1)) ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 5 do ( (     ans := ans+(if a[i+1] - b[i+1] < 0 then -(a[i+1] - b[i+1]) else a[i+1] - b[i+1] endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Map ;
import java.util.HashMap ;
public class Main {
  String s ;
  public static void main(String args[]){
    new Main().solve();
  }
  void solve(){
    in();
    String ans="" ;
    for(int i=0 ; i<s.length(); i++){
      String c=String.valueOf(s.charAt(i));
      if(! c.equals("B")){
        ans+=c ;
      }
      else {
        if(ans.length()>0)ans=ans.substring(0,ans.length()-1);
      }
    }
    out(ans);
  }
  void in(){
    Scanner sc=new Scanner(System.in);
    s=sc.next();
  }
  void out(){
  }
  void out(int n){
    System.out.println(n);
  }
  void out(double n){
    System.out.println(n);
  }
  void out(long n){
    System.out.println(n);
  }
  void out(char c){
    System.out.print(c);
  }
  void out(String s){
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute s : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     execute in() ; 
     var ans : String ; ans := "" ;
         var i : int ; i := 0 ; while i < s->size() do ( (     var c : String ; c := ((s->at(i+1)) + "") ;
     if (not(c = "B")) then (     ans := ans+(c) ) else (     if (ans->size() > 0) then     ans := ans.subrange(0+1,ans->size() - 1) ; else skip ) )  ;     i := i + 1 ) ; 
     execute out(ans) );
   operation in() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     s := sc.getCurrent() );
   operation out() : void
  pre: true
  post: true
  activity: skip;
   operation out( n : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(n) );
   operation out( n : double) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(n) );
   operation out( n : long) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(n) );
   operation out( c : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(c) );
   operation out( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class NewMain_111 {
  public static void main(String[] args){
    FastReader s=new FastReader();
    int n=s.nextInt();
    int[] ar=new int[6];
    int[] ar2=new int[6];
    for(int i=0 ; i<n ; i++){
      ar[s.nextInt()]++;
    }
    for(int i=0 ; i<n ; i++){
      ar2[s.nextInt()]++;
    }
    int count=0 ;
    for(int i=1 ; i<6 ; i++){
      if((ar[i]+ar2[i])% 2==1){
        System.out.println("-1");
        return ;
      }
      else {
        count+=Math.max(ar[i],ar2[i])-((ar[i]+ar2[i])/2);
      }
    }
    System.out.println(count/2);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewMain_111 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : FastReader ; s := FastReader.newFastReader() ;
     var n : int ; n := s.nextInt() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,6)->collect(0) ;
    var ar2 : Sequence(int) ; ar2 := Integer.subrange(1,6)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ar[s.nextInt()+1] := ar[s.nextInt()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     ar2[s.nextInt()+1] := ar2[s.nextInt()+1] + 1 )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < 6 do ( (     if ((ar[i+1] + ar2[i+1]) mod 2 = 1) then (     OclFile["System.out"].println("-1") ; 
     return ) else (     count := count+(Set{ar[i+1], ar2[i+1]}->max() - ((ar[i+1] + ar2[i+1]) / 2)) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count / 2) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int a[]=new int[6];
    int b[]=new int[6];
    for(int i=0 ; i<n ; i++){
      a[scan.nextInt()]++;
    }
    for(int i=0 ; i<n ; i++){
      b[scan.nextInt()]++;
    }
    int ans=0 ;
    int i ;
    for(i=1 ; i<=5 ; i++){
      int diff=Math.abs(a[i]-b[i]);
      if(diff % 2!=0){
        System.out.println(-1);
        break ;
      }
      ans+=diff/2 ;
    }
    if(i==6)System.out.println(ans/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,6)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,6)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[scan.getCurrent()->toInteger()+1] := a[scan.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[scan.getCurrent()->toInteger()+1] := b[scan.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var i : int ;
        i := 1 ; while i <= 5 do ( (     var diff : int ; diff := if a[i+1] - b[i+1] < 0 then -(a[i+1] - b[i+1]) else a[i+1] - b[i+1] endif ;
     if (diff mod 2 /= 0) then (     OclFile["System.out"].println(-1) ; 
     break ) else skip ; 
     ans := ans+(diff / 2) )  ;     i := i + 1 ) ; 
    if (i = 6) then     OclFile["System.out"].println(ans / 2) ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class GFG {
  static int firstElement(int arr[],int n,int k){
    HashMap<Integer,Integer>count_map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int a=0 ;
      if(count_map.get(arr[i])!=null){
        a=count_map.get(arr[i]);
      }
      count_map.put(arr[i],a+1);
    }
    for(int i=0 ; i<n ; i++){
      if(count_map.get(arr[i])==k){
        return arr[i];
      }
    }
    return-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      1,7,4,3,4,8,7 };
      int n=arr.length ;
      int k=2 ;
      System.out.println(firstElement(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation firstElement( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var count_map : Map(int,int) ; count_map := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := 0 ;
     if (count_map->at(arr[i+1]) /= null) then (     a := count_map->at(arr[i+1]) ) else skip ; 
     count_map := count_map->union(Map{arr[i+1] |-> a + 1}) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (count_map->at(arr[i+1]) = k) then (     return arr[i+1] ) else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,7,4,3,4,8,7} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(firstElement(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PupilsRedistribution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr1=new int[6];
    int[] arr2=new int[6];
    for(int i=0 ; i<n ; i++){
      arr1[sc.nextInt()]++;
    }
    for(int i=0 ; i<n ; i++){
      arr2[sc.nextInt()]++;
    }
    int sum=0,sum2=0 ;
    for(int i=1 ; i<=5 ; i++){
      sum=arr1[i]+arr2[i];
      if(sum % 2!=0){
        System.out.println(-1);
        return ;
      }
      else {
        sum2+=Math.max(arr1[i]-arr2[i],0);
      }
    }
    System.out.println(sum2/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class PupilsRedistribution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,6)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,6)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr1[sc.getCurrent()->toInteger()+1] := arr1[sc.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr2[sc.getCurrent()->toInteger()+1] := arr2[sc.getCurrent()->toInteger()+1] + 1 )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var sum2 : int ; sum2 := 0 ;
        var i : int ; i := 1 ; while i <= 5 do ( (     sum := arr1[i+1] + arr2[i+1] ; 
     if (sum mod 2 /= 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else (     sum2 := sum2+(Set{arr1[i+1] - arr2[i+1], 0}->max()) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum2 / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String findNumber(int s,int d){
    String num="" ;
    int val=s/d ;
    int rem=s % d ;
    int i ;
    for(i=1 ; i<=d-rem ; i++){
      num=num+String.valueOf(val);
    }
    if(rem>0){
      val++;
      for(i=d-rem+1 ; i<=d ; i++){
        num=num+String.valueOf(val);
      }
    }
    return num ;
  }
  public static void main(String[] args){
    int s=25,d=4 ;
    System.out.print(findNumber(s,d));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNumber( s : int, d : int) : String
  pre: true
  post: true
  activity: (     var num : String ; num := "" ;
     var val : int ; val := s / d ;
    var rem : int ; rem := s mod d ;
    var i : int ;
        i := 1 ; while i <= d - rem do ( (     num := num + ((val) + "") )  ;     i := i + 1 ) ; 
    if (rem > 0) then (     val := val + 1 ; 
         i := d - rem + 1 ; while i <= d do ( (     num := num + ((val) + "") )  ;     i := i + 1 ) ) else skip ; 
    return num 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : int ; s := 25 ;
    var d : int ; d := 4 ;
     OclFile["System.out"].print(findNumber(s, d)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int N=100 ;
  static void pre_process(boolean dp[][],char[] s){
    int n=s.length ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        dp[i][j]=false ;
      }
    }
    for(int j=1 ; j<=n ; j++){
      for(int i=0 ; i<=n-j ; i++){
        if(j<=2){
          if(s[i]==s[i+j-1]){
            dp[i][i+j-1]=true ;
          }
        }
        else if(s[i]==s[i+j-1]){
          dp[i][i+j-1]=dp[i+1][i+j-2];
        }
      }
    }
  }
  static void answerQuery(int l,int r,boolean dp[][]){
    if(dp[l][r]){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
  public static void main(String[] args){
    String s="abaaab" ;
    boolean[][] dp=new boolean[N][N];
    pre_process(dp,s.toCharArray());
    int queries[][]={
      {
        0,1 },{
          1,5 }
        };
        int q=queries.length ;
        for(int i=0 ; i<q ; i++){
          answerQuery(queries[i][0],queries[i][1],dp);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 100;
  static   operation pre_process( dp : Sequence(Sequence(boolean)), s : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     dp[i+1][j+1] := false )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
         var j : int ; j := 1 ; while j <= n do ( (         var i : int ; i := 0 ; while i <= n - j do ( (     if (j <= 2) then (     if (s[i+1] = s[i + j - 1+1]) then (     dp[i+1][i + j - 1+1] := true ) else skip ) else     if (s[i+1] = s[i + j - 1+1]) then (     dp[i+1][i + j - 1+1] := dp[i + 1+1][i + j - 2+1] ) else skip ; )  ;     i := i + 1 ) )  ;     j := j + 1 ) );
  static   operation answerQuery( l : int, r : int, dp : Sequence(Sequence(boolean))) : void
  pre: true
  post: true
  activity: (     if (dp[l+1][r+1]) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abaaab" ;
     var dp : Sequence(Sequence(boolean)) ; dp := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(false)) ;
    execute pre_process(dp, s->characters()) ; 
    var queries : Sequence(Sequence(int)) ; queries := Sequence{Sequence{0,1},Sequence{1,5}} ;
    var q : int ; q := queries->size() ;
        var i : int ; i := 0 ; while i < q do ( (     execute answerQuery(queries[i+1][0+1], queries[i+1][1+1], dp) )  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),a=sc.nextInt(),b=sc.nextInt();
    int[] x=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=sc.nextInt();
    }
    long sum=0 ;
    for(int i=0 ; i<n-1 ; i++){
      long t=x[i+1]-x[i];
      if(t*a<=b)sum+=t*a ;
      else sum+=b ;
    }
    System.out.print(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var t : long ; t := x[i + 1+1] - x[i+1] ;
     if (t * a <= b) then     sum := sum+(t * a) ; else     sum := sum+(b) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskD solver=new TaskD();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskD {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      long A=in.nextInt();
      long B=in.nextInt();
      int x[]=new int[n];
      for(int i=0 ; i<n ; ++i){
        x[i]=in.nextInt();
      }
      long r=0 ;
      for(int i=1 ; i<n ; ++i){
        r+=min(B,A*(x[i]-x[i-1]));
      }
      out.println(r);
    }
    long min(long a,long b){
      if(a<b)return a ;
      else return b ;
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskD ; solver := TaskD.newTaskD() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskD {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var A : long ; A := in.nextInt() ;
    var B : long ; B := in.nextInt() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    var r : long ; r := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     r := r+(Set{B, A * (x[i+1] - x[i - 1+1])}->min()) )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation min( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a < b) then     return a else     return b );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    long a=Long.parseLong(sc.next());
    long b=Long.parseLong(sc.next());
    long sum=0 ;
    long from=Long.parseLong(sc.next());
    long to=Long.parseLong(sc.next());
    sum+=(a*(to-from)<b)? a*(to-from): b ;
    for(int i=0 ; i<n-2 ; i++){
      from=to ;
      to=Long.parseLong(sc.next());
      sum+=(a*(to-from)<b)? a*(to-from): b ;
    }
    System.out.println(String.valueOf(sum));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var a : long ; a := (sc.getCurrent())->toLong() ;
    var b : long ; b := (sc.getCurrent())->toLong() ;
    var sum : long ; sum := 0 ;
    var from : long ; from := (sc.getCurrent())->toLong() ;
    var to : long ; to := (sc.getCurrent())->toLong() ;
    sum := sum+(if (a * (to - from) < b) then a * (to - from) else b endif) ; 
        var i : int ; i := 0 ; while i < n - 2 do ( (     from := to ; 
     to := (sc.getCurrent())->toLong() ; 
     sum := sum+(if (a * (to - from) < b) then a * (to - from) else b endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(((sum) + "")) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    InputReader in=new InputReader();
    PrintWriter out=new PrintWriter(System.out);
    int t=1 ;
    Solver s=new Solver();
    for(int i=1 ; i<=t ; i++){
      s.solve(i,in,out);
    }
    out.close();
  }
}
class Solver {
  void solve(int test,InputReader in,PrintWriter out)throws IOException {
    int n=in.nextInt();
    int[] a=new int[n];
    long ans=0 ;
    long A=in.nextLong();
    long B=in.nextLong();
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    for(int i=1 ; i<n ; i++){
      long d1=a[i]-a[i-1];
      d1*=A ;
      ans+=Math.min(d1,B);
    }
    out.println(ans);
  }
}
class InputReader {
  BufferedReader br ;
  StringTokenizer st ;
  public InputReader(){
    br=new BufferedReader(new InputStreamReader(System.in));
    st=null ;
  }
  public String next(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return st.nextToken();
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
  public String nextLine()throws IOException {
    return br.readLine();
  }
  public double nextDouble(){
    return Double.parseDouble(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : InputReader ; in := InputReader.newInputReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := 1 ;
    var s : Solver ; s := Solver.newSolver() ;
        var i : int ; i := 1 ; while i <= t do ( (     s.solve(i, in, out) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
class Solver {
   operation solve( test : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var ans : long ; ans := 0 ;
    var A : long ; A := in.nextLong() ;
    var B : long ; B := in.nextLong() ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     var d1 : long ; d1 := a[i+1] - a[i - 1+1] ;
     d1 := d1*(A) ; 
     ans := ans+(Set{d1, B}->min()) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
class InputReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newInputReader() : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     st := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    StringBuilder b=new StringBuilder();
    int size=s.length();
    for(int i=0 ; i<size ; i++){
      String x=s.substring(i,i+1);
      if(x.equals("B")){
        int a=b.length();
        if(a>0){
          b.deleteCharAt(a-1);
        }
      }
      else {
        b.append(x);
      }
    }
    String result=b.toString();
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var b : String ; b := StringLib.newString() ;
    var size : int ; size := s->size() ;
        var i : int ; i := 0 ; while i < size do ( (     var x : String ; x := s.subrange(i+1,i + 1) ;
     if (x = "B") then (     var a : int ; a := b->size() ;
     if (a > 0) then (     b := b->excludingAt((a)->char2byte() - 1+1) ) else skip ) else (     b := b + StringLib.newString(x) ) )  ;     i := i + 1 ) ; 
    var result : String ; result := b+"" ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextInt()){
      int n=sc.nextInt();
      int a=sc.nextInt();
      int b=sc.nextInt();
      int[] x=new int[n];
      for(int i=0 ; i<n ; i++){
        x[i]=sc.nextInt();
      }
      long ans=0 ;
      for(int i=0 ; i<n-1 ; i++){
        long dist=x[i+1]-x[i];
        long walkCost=dist*a ;
        if(walkCost<b){
          ans+=walkCost ;
        }
        else {
          ans+=b ;
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextInt()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var dist : long ; dist := x[i + 1+1] - x[i+1] ;
     var walkCost : long ; walkCost := dist * a ;
     if (walkCost < b) then (     ans := ans+(walkCost) ) else (     ans := ans+(b) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(new File("input.txt"));
    int b=sc.nextInt();
    int g=sc.nextInt();
    StringBuilder sb=new StringBuilder();
    if(b==g){
      for(int i=1 ; i<=b ; i++){
        sb.append("GB");
      }
    }
    else if(b>g){
      for(int i=1 ; i<=g ; i++){
        sb.append("BG");
      }
      for(int i=g+1 ; i<=b ; i++){
        sb.append("B");
      }
    }
    else {
      for(int i=1 ; i<=b ; i++){
        sb.append("GB");
      }
      for(int i=b+1 ; i<=g ; i++){
        sb.append("G");
      }
    }
    PrintWriter pw=new PrintWriter("output.txt");
    pw.println(sb.toString());
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile("input.txt")) ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var g : int ; g := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
    if (b = g) then (         var i : int ; i := 1 ; while i <= b do ( (     sb := sb + StringLib.newString("GB") )  ;     i := i + 1 ) ) else     if (b > g) then (         var i : int ; i := 1 ; while i <= g do ( (     sb := sb + StringLib.newString("BG") )  ;     i := i + 1 ) ; 
         var i : int ; i := g + 1 ; while i <= b do ( (     sb := sb + StringLib.newString("B") )  ;     i := i + 1 ) ) else (         var i : int ; i := 1 ; while i <= b do ( (     sb := sb + StringLib.newString("GB") )  ;     i := i + 1 ) ; 
         var i : int ; i := b + 1 ; while i <= g do ( (     sb := sb + StringLib.newString("G") )  ;     i := i + 1 ) ) ;  ;  
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemA {
  public static void main(String[] args)throws IOException {
    Scanner s=new Scanner(new File("input.txt"));
    int n=s.nextInt();
    int m=s.nextInt();
    StringBuilder sb=new StringBuilder();
    String c=n>=m ? "BG" : "GB" ;
    char ch=n>=m ? 'B' : 'G' ;
    for(int j=0 ; j<Math.min(n,m); ++j)sb.append(c);
    for(int j=Math.min(n,m); j<Math.max(n,m); ++j)sb.append(ch);
    PrintWriter pw=new PrintWriter("output.txt");
    pw.println(sb.toString());
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile("input.txt")) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var m : int ; m := s.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
    var c : String ; c := if n >= m then "BG" else "GB" endif ;
    var ch : String ; ch := if n >= m then 'B' else 'G' endif ;
        var j : int ; j := 0 ; while j < Set{n, m}->min() do (     sb := sb + StringLib.newString(c) ;  ;     j := j + 1 ) ; 
        var j : int ; j := Set{n, m}->min() ; while j < Set{n, m}->max() do (     sb := sb + StringLib.newString(ch) ;  ;     j := j + 1 ) ; 
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.BorderLayout ;
import static java.lang.Math.*;
import java.math.BigDecimal ;
import java.text.DecimalFormat ;
import java.util.Scanner ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.BitSet ;
import java.util.Collection ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.Deque ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Iterator ;
import java.util.List ;
import java.util.Map ;
import java.util.Queue ;
import java.util.Set ;
import java.util.Stack ;
import java.util.TreeSet ;
import java.util.Vector ;
import java.util.concurrent.atomic.AtomicMarkableReference ;
import java.util.Scanner ;
public class NewClass1 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    int l=in.nextInt();
    int c=in.nextInt();
    int d=in.nextInt();
    int p=in.nextInt();
    int nl=in.nextInt();
    int np=in.nextInt();
    int milli=k*l ;
    int limes=c*d ;
    int min=Math.min(p/np,milli/nl);
    min=Math.min(min,limes);
    int count=min/n ;
    System.out.print(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var l : int ; l := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var d : int ; d := in.getCurrent()->toInteger() ;
    var p : int ; p := in.getCurrent()->toInteger() ;
    var nl : int ; nl := in.getCurrent()->toInteger() ;
    var np : int ; np := in.getCurrent()->toInteger() ;
    var milli : int ; milli := k * l ;
    var limes : int ; limes := c * d ;
    var min : int ; min := Set{p / np, milli / nl}->min() ;
    min := Set{min, limes}->min() ; 
    var count : int ; count := min / n ;
    OclFile["System.out"].print(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner in=new Scanner(new File("input.txt"));
    int boys=in.nextInt(),girls=in.nextInt();
    StringBuilder sb=new StringBuilder();
    if(boys==girls){
      for(int i=0 ; i<boys ; i++){
        sb.append("BG");
      }
    }
    else if(boys>girls){
      for(int i=0 ; i<girls ; i++){
        sb.append("BG");
      }
      boys-=girls ;
      for(int i=0 ; i<boys ; i++){
        sb.append("B");
      }
    }
    else {
      for(int i=0 ; i<boys ; i++){
        sb.append("GB");
      }
      girls-=boys ;
      for(int i=0 ; i<girls ; i++){
        sb.append("G");
      }
    }
    PrintWriter pw=new PrintWriter("output.txt");
    pw.print(sb.toString());
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("input.txt")) ;
     var boys : int ; boys := in.getCurrent()->toInteger() ;
    var girls : int ; girls := in.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
    if (boys = girls) then (         var i : int ; i := 0 ; while i < boys do ( (     sb := sb + StringLib.newString("BG") )  ;     i := i + 1 ) ) else     if (boys > girls) then (         var i : int ; i := 0 ; while i < girls do ( (     sb := sb + StringLib.newString("BG") )  ;     i := i + 1 ) ; 
     boys := boys-(girls) ; 
         var i : int ; i := 0 ; while i < boys do ( (     sb := sb + StringLib.newString("B") )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < boys do ( (     sb := sb + StringLib.newString("GB") )  ;     i := i + 1 ) ; 
     girls := girls-(boys) ; 
         var i : int ; i := 0 ; while i < girls do ( (     sb := sb + StringLib.newString("G") )  ;     i := i + 1 ) ) ;  ;  
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")) ;
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Geeks_For_Geeks {
  public static int[] sortArrays(int[] arr){
    int length=arr.length ;
    for(int j=0 ; j<length-1 ; j++){
      if(arr[j]>arr[j+1]){
        int temp=arr[j];
        arr[j]=arr[j+1];
        arr[j+1]=temp ;
        j=-1 ;
      }
    }
    return arr ;
  }
  public static void main(String args[]){
    int arr[]={
      1,2,99,9,8,7,6,0,5,4,3 };
      System.out.println("Original array: "+Arrays.toString(arr));
      arr=sortArrays(arr);
      System.out.println("Sorted array: "+Arrays.toString(arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Geeks_For_Geeks {
  static   operation sortArrays( arr : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var length : int ; length := arr->size() ;
         var j : int ; j := 0 ; while j < length - 1 do ( (     if (arr[j+1] > arr[j + 1+1]) then (     var temp : int ; temp := arr[j+1] ;
     arr[j+1] := arr[j + 1+1] ; 
     arr[j + 1+1] := temp ; 
     j := -1 ) else skip )  ;     j := j + 1 ) ; 
     return arr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,99,9,8,7,6,0,5,4,3} ;
     OclFile["System.out"].println("Original array: " + (arr + "")) ; 
     arr := sortArrays(arr) ; 
     OclFile["System.out"].println("Sorted array: " + (arr + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int squareSum(int n){
    return 2*n*(n+1)*(2*n+1)/3 ;
  }
  public static void main(String args[])throws IOException {
    System.out.println(squareSum(8));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation squareSum( n : int) : int
  pre: true
  post: true
  activity: (     return 2 * n * (n + 1) * (2 * n + 1) / 3 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(squareSum(8)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  public static int squaresum(int n){
    return(n*(n+1)/2)*(2*n+1)/3 ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(squaresum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation squaresum( n : int) : int
  pre: true
  post: true
  activity: (     return (n * (n + 1) / 2) * (2 * n + 1) / 3 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(squaresum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int intersection(int n){
    return n*(n-1);
  }
  public static void main(String[] args)throws IOException {
    System.out.println(intersection(3));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation intersection( n : int) : int
  pre: true
  post: true
  activity: (     return n * (n - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(intersection(3)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int sumOfSeries(int n){
    return(n*(2*n-1)*(2*n+1))/3 ;
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(sumOfSeries(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfSeries( n : int) : int
  pre: true
  post: true
  activity: (     return (n * (2 * n - 1) * (2 * n + 1)) / 3 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(sumOfSeries(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
@ SuppressWarnings("unchecked")public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    Stack<Character>stack=new Stack<>();
    for(int i=0 ; i<s.length(); ++i){
      char ch=s.charAt(i);
      if(ch=='B'){
        if(! stack.isEmpty())stack.pop();
      }
      else {
        stack.push(ch);
      }
    }
    String res="" ;
    while(! stack.isEmpty()){
      res+=stack.pop();
    }
    for(int i=res.length()-1 ; i>=0 ; --i){
      System.out.print(res.charAt(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
    var stack : Sequence(String) ; stack := Sequence{} ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var ch : String ; ch := s->at(i+1) ;
     if (ch = 'B') then (     if (not(stack->isEmpty())) then     stack := stack->front() ; else skip ) else (     stack := stack->append(ch) ) )  ;     i := i + 1 ) ; 
    var res : String ; res := "" ;
    while (not(stack->isEmpty())) do (     res := res + stack->last() ;     stack := stack->front() ) ; 
        var i : int ; i := res->size() - 1 ; while i >= 0 do ( (     OclFile["System.out"].print(res->at(i+1)) )  ;     i := i - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int squaresum(int n){
    return(n*(n+1)*(2*n+1))/6 ;
  }
  public static void main(String args[])throws IOException {
    int n=4 ;
    System.out.println(squaresum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation squaresum( n : int) : int
  pre: true
  post: true
  activity: (     return (n * (n + 1) * (2 * n + 1)) / 6 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(squaresum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int one=0,tow=0 ;
      int ans=0 ;
      for(int j=0 ; j<n ; j++){
        int x=sc.nextInt();
        if(x % 3==0)ans++;
        if(x % 3==1)one++;
        if(x % 3==2)tow++;
      }
      ans+=Math.min(one,tow);
      ans+=((Math.max(one,tow)-Math.min(one,tow))/3);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var one : int ; one := 0 ;
    var tow : int ; tow := 0 ;
    var ans : int ; ans := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x mod 3 = 0) then     ans := ans + 1 ; else skip ; 
     if (x mod 3 = 1) then     one := one + 1 ; else skip ; 
     if (x mod 3 = 2) then     tow := tow + 1 ; else skip )  ;     j := j + 1 ) ; 
    ans := ans+(Set{one, tow}->min()) ; 
    ans := ans+(((Set{one, tow}->max() - Set{one, tow}->min()) / 3)) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int one=0,tow=0 ;
      int ans=0 ;
      for(int j=0 ; j<n ; j++){
        int x=sc.nextInt();
        if(x % 3==0)ans++;
        if(x % 3==1)one++;
        if(x % 3==2)tow++;
      }
      ans+=Math.min(one,tow);
      ans+=((Math.max(one,tow)-Math.min(one,tow))/3);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var one : int ; one := 0 ;
    var tow : int ; tow := 0 ;
    var ans : int ; ans := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x mod 3 = 0) then     ans := ans + 1 ; else skip ; 
     if (x mod 3 = 1) then     one := one + 1 ; else skip ; 
     if (x mod 3 = 2) then     tow := tow + 1 ; else skip )  ;     j := j + 1 ) ; 
    ans := ans+(Set{one, tow}->min()) ; 
    ans := ans+(((Set{one, tow}->max() - Set{one, tow}->min()) / 3)) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int costToPanagram(String str,int cost[]){
    int i,n=str.length();
    int occurrences[]=new int[26];
    for(i=0 ; i<n ; i++)occurrences[str.charAt(i)-'a']++;
    int gain=0 ;
    for(i=0 ; i<26 ; i++){
      if(occurrences[i]==0)gain-=(2*cost[i]);
      else if(occurrences[i]>1)gain+=(cost[i]*(occurrences[i]-1));
    }
    if(gain>=0)return 0 ;
    return(gain*-1);
  }
  public static void main(String[] args){
    int cost[]={
      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 };
      String str="geeksforgeeks" ;
      System.out.println(costToPanagram(str,cost));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation costToPanagram( str : String, cost : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var n : int ; n := str->size() ;
     var occurrences : Sequence(int) ; occurrences := Integer.subrange(1,26)->collect(0) ;
        i := 0 ; while i < n do (     occurrences[str->at(i+1) - ('a')->char2byte()+1] := occurrences[str->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
    var gain : int ; gain := 0 ;
        i := 0 ; while i < 26 do ( (     if (occurrences[i+1] = 0) then     gain := gain-((2 * cost[i+1])) ; else     if (occurrences[i+1] > 1) then     gain := gain+((cost[i+1] * (occurrences[i+1] - 1))) ; else skip ; )  ;     i := i + 1 ) ; 
    if (gain >= 0) then     return 0 else skip ; 
    return (gain * -1) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cost : Sequence(int) ; cost := Sequence{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1} ;
     var str : String ; str := "geeksforgeeks" ;
     OclFile["System.out"].println(costToPanagram(str, cost)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Iterator ;
import java.util.List ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    try {
      while((line=br.readLine())!=null){
        int numOfCards=Integer.parseInt(line);
        if(numOfCards==0){
          break ;
        }
        List<Integer>aCards=new ArrayList<>();
        List<Integer>bCards=new ArrayList<>();
        for(int i=0 ; i<numOfCards ; i++){
          line=br.readLine();
          String[] cardsStr=line.split(" ");
          aCards.add(Integer.parseInt(cardsStr[0]));
          bCards.add(Integer.parseInt(cardsStr[1]));
        }
        List<Integer>result=calcScore(aCards,bCards);
        System.out.println(String.format("%d %d",result.get(0),result.get(1)));
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  private static List<Integer>calcScore(List<Integer>aCards,List<Integer>bCards){
    Integer aScore=0 ;
    Integer bScore=0 ;
    if(aCards.size()!=bCards.size()){
      throw new IllegalArgumentException("??????????????°?????°??????");
    }
    Iterator<Integer>aCardsIter=aCards.iterator();
    Iterator<Integer>bCardsIter=bCards.iterator();
    while(aCardsIter.hasNext()&& bCardsIter.hasNext()){
      Integer aCard=aCardsIter.next();
      Integer bCard=bCardsIter.next();
      if(aCard>bCard){
        aScore+=aCard+bCard ;
      }
      else if(aCard<bCard){
        bScore+=aCard+bCard ;
      }
      else {
        aScore+=aCard ;
        bScore+=bCard ;
      }
    }
    List<Integer>score=Arrays.asList(aScore,bScore);
    return score ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     try (         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     var numOfCards : int ; numOfCards := (line)->toInteger() ;
     if (numOfCards = 0) then (     break ) else skip ; 
    var aCards : Sequence(int) ; aCards := Sequence{} ;
    var bCards : Sequence(int) ; bCards := Sequence{} ;
        var i : int ; i := 0 ; while i < numOfCards do ( (     line := br.readLine() ; 
     var cardsStr : Sequence(String) ; cardsStr := line->split(" ") ;
     aCards := aCards->including((cardsStr[0+1])->toInteger()) ; 
     bCards := bCards->including((cardsStr[1+1])->toInteger()) )  ;     i := i + 1 ) ; 
    var result : Sequence(int) ; result := calcScore(aCards, bCards) ;
    OclFile["System.out"].println(StringLib.format("%d %d",Sequence{result->at(0+1),result->at(1+1)})) ; 
 ) ;     line := br.readLine() ;
 ) )   catch (e : IOException) do (     e.printStackTrace() )
 );
  static   operation calcScore( aCards : Sequence(int), bCards : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var aScore : int ; aScore := 0 ;
     var bScore : int ; bScore := 0 ;
    if (aCards->size() /= bCards->size()) then (     error IllegalArgumentException.newIllegalArgumentException("??????????????�?????�??????") ) else skip ; 
    var aCardsIter : OclIterator ; aCardsIter := aCards->iterator() ;
    var bCardsIter : OclIterator ; bCardsIter := bCards->iterator() ;
    while (aCardsIter.hasNext() & bCardsIter.hasNext()) do (     var aCard : int ; aCard := aCardsIter.next() ;
     var bCard : int ; bCard := bCardsIter.next() ;
     if (aCard > bCard) then (     aScore := aScore+(aCard + bCard) ) else     if (aCard < bCard) then (     bScore := bScore+(aCard + bCard) ) else (     aScore := aScore+(aCard) ; 
     bScore := bScore+(bCard) ) ;  ) ; 
    var score : Sequence(int) ; score := Sequence{aScore,bScore} ;
    return score 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class CodeForces {
  static PrintWriter out=new PrintWriter(System.out);
  static class Scnr {
    BufferedReader br ;
    StringTokenizer st ;
    public Scnr(){
      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 ;
    }
  }
  public static void main(String[] args)throws java.lang.Exception {
    Scnr sc=new Scnr();
    int n=sc.nextInt();
    int k=sc.nextInt();
    int l=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    int p=sc.nextInt();
    int nl=sc.nextInt();
    int np=sc.nextInt();
    int[] arr=new int[] {
(k*l/nl),(d*c),(p/np)};
      Arrays.sort(arr);
      out.println(arr[0]/n);
      out.flush();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static class Scnr {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newScnr() : Scnr
  pre: true
  post: true
  activity:
  ( var self : Scnr ;
    self := createScnr();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : Scnr ; sc := Scnr.newScnr() ;
     var n : int ; n := sc.nextInt() ;
    var k : int ; k := sc.nextInt() ;
    var l : int ; l := sc.nextInt() ;
    var c : int ; c := sc.nextInt() ;
    var d : int ; d := sc.nextInt() ;
    var p : int ; p := sc.nextInt() ;
    var nl : int ; nl := sc.nextInt() ;
    var np : int ; np := sc.nextInt() ;
    var arr : Sequence(int) ; arr := Sequence{(k * l / nl),(d * c),(p / np)} ;
    arr := arr->sort() ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int m=in.nextInt(),f=in.nextInt(),b=in.nextInt();
    int d=m-b,da=Math.abs(d);
    if(d>=0)System.out.println(0);
    else if(da>f)System.out.println("NA");
    else System.out.println(da);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var f : int ; f := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var d : int ; d := m - b ;
    var da : int ; da := if d < 0 then -(d) else d endif ;
    if (d >= 0) then     OclFile["System.out"].println(0) else     if (da > f) then     OclFile["System.out"].println("NA") else     OclFile["System.out"].println(da) ; ;  ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args){
    BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    String str="" ;
    StringTokenizer stk ;
    int[] k1=new int[3];
    int i=0 ;
    try {
      while(true){
        str=bfr.readLine();
        if(str==null){
          System.exit(0);
        }
        stk=new StringTokenizer(str," ");
        while(stk.hasMoreTokens()){
          k1[i]=Integer.parseInt(stk.nextToken());
          i++;
        }
        i=0 ;
        int kariiregaku=k1[2]-k1[0];
        if(kariiregaku<0){
          kariiregaku=0 ;
        }
        if(k1[1]>=kariiregaku){
          System.out.println(kariiregaku);
        }
        else {
          System.out.println("NA");
        }
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bfr : OclFile ; bfr := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := "" ;
    var stk : OclIterator ;
    var k1 : Sequence(int) ; k1 := Integer.subrange(1,3)->collect(0) ;
    var i : int ; i := 0 ;
    try (     while (true) do (     str := bfr.readLine() ; 
     if (str = null) then ( OclProcess.exit(0) ) else skip ; 
    stk := OclIterator.newOclIterator_String_String(str, " ") ; 
    while (stk.hasNext()) do (     k1[i+1] := (stk.next())->toInteger() ; 
     i := i + 1 ) ; 
    i := 0 ; 
    var kariiregaku : int ; kariiregaku := k1[2+1] - k1[0+1] ;
    if (kariiregaku < 0) then (     kariiregaku := 0 ) else skip ; 
    if (k1[1+1] >= kariiregaku) then (     OclFile["System.out"].println(kariiregaku) ) else (     OclFile["System.out"].println("NA") ) ;  
 ) )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  static IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static IntStream REPS(int l,int r){
    return IntStream.rangeClosed(l,r);
  }
  static IntStream INS(int n){
    return REPS(n).map(i->getInt());
  }
  static Scanner s=new Scanner(System.in);
  static int getInt(){
    return Integer.parseInt(s.next());
  }
  public static void main(String[] $){
    int m=getInt(),f=getInt(),b=getInt();
    int v=Math.max(0,b-m);
    System.out.println(f<v ? "NA" : v);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static   operation REPS( l : int, r : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(l, r) );
  static   operation INS( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return REPS(n)->collect( _x1 | (lambda i : OclAny in getInt())->apply(_x1) ) );
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := getInt() ;
    var f : int ; f := getInt() ;
    var b : int ; b := getInt() ;
     var v : int ; v := Set{0, b - m}->max() ;
     OclFile["System.out"].println(if f < v then "NA" else v endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String[] lines=br.readLine().split(" ");
      int m=Integer.parseInt(lines[0]);
      int f=Integer.parseInt(lines[1]);
      int b=Integer.parseInt(lines[2]);
      if(b<=m)System.out.println(0);
      else if(b<=m+f)System.out.println(b-m);
      else System.out.println("NA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var lines : Sequence(String) ; lines := br.readLine()->split(" ") ;
     var m : int ; m := (lines[0+1])->toInteger() ;
    var f : int ; f := (lines[1+1])->toInteger() ;
    var b : int ; b := (lines[2+1])->toInteger() ;
    if (b <= m) then     OclFile["System.out"].println(0) else     if (b <= m + f) then     OclFile["System.out"].println(b - m) else     OclFile["System.out"].println("NA") ; ;  ;  
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
import java.util.concurrent.atomic.AtomicInteger ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    while(true){
      Integer a=scanner.nextInt();
      Integer b=scanner.nextInt();
      if(a==0 && b==0){
        break ;
      }
      AtomicInteger count=new AtomicInteger(0);
      List<String>used=new ArrayList<>();
      IntStream.range(1,a+1).forEach(x->{
        IntStream.range(1,a+1).filter(y->y!=x).forEach(y->{
          IntStream.range(1,a+1).filter(z->z!=x && z!=y).filter(z->x+y+z==b).forEach(z->{
            String sorted=Arrays.asList(x,y,z).stream().sorted().collect(Collectors.toList()).toString();
            if(used.contains(sorted)){
              return ;
            }
            used.add(sorted);
            count.getAndAdd(1);
          }
);
        }
);
      }
);
      System.out.println(count.get());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
    if (a = 0 & b = 0) then (     break ) else skip ; 
    var count : int ; count := (0) ;
    var used : Sequence(String) ; used := Sequence{} ;
    for x : Integer.subrange(1, a + 1-1) do
    (    skip) ; 
    OclFile["System.out"].println(count.get()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int my=in.nextInt(),debt=in.nextInt(),book=in.nextInt();
    int cred=my-book ;
    if(cred<0){
      if(debt+cred>=0)out.println(Math.abs(cred));
      else out.println("NA");
    }
    else out.println(0);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var my : int ; my := in.getCurrent()->toInteger() ;
    var debt : int ; debt := in.getCurrent()->toInteger() ;
    var book : int ; book := in.getCurrent()->toInteger() ;
    var cred : int ; cred := my - book ;
    if (cred < 0) then (     if (debt + cred >= 0) then     skip ; else     skip ; ) else     skip ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int xorPairCount(int arr[],int n,int x){
    int result=0 ;
    HashSet<Integer>s=new HashSet<Integer>();
    for(int i=0 ; i<n ; i++){
      if(s.contains(x ^ arr[i])&&(x ^ arr[i])==(int)s.toArray()[s.size()-1]){
        result++;
      }
      s.add(arr[i]);
    }
    return result ;
  }
  public static void main(String[] args){
    int arr[]={
      5,4,10,15,7,6 };
      int n=arr.length ;
      int x=5 ;
      System.out.print("Count of pairs with given XOR="+xorPairCount(arr,n,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation xorPairCount( arr : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var s : Set(int) ; s := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (s->includes(x xor arr[i+1]) & (x xor arr[i+1]) = s->asSequence()[s->size() - 1+1]->oclAsType(int)) then (     result := result + 1 ) else skip ; 
     s := s->including(arr[i+1]) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,4,10,15,7,6} ;
     var n : int ; n := arr->size() ;
     var x : int ; x := 5 ;
     OclFile["System.out"].print("Count of pairs with given XOR=" + xorPairCount(arr, n, x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.Vector ;
class GFG {
  static int minSum(int arr[],int n){
    Vector<Integer>evenArr=new Vector<>();
    Vector<Integer>oddArr=new Vector<>();
    Arrays.sort(arr);
    for(int i=0 ; i<n ; i++){
      if(i<n/2){
        oddArr.add(arr[i]);
      }
      else {
        evenArr.add(arr[i]);
      }
    }
    Comparator comparator=Collections.reverseOrder();
    Collections.sort(evenArr,comparator);
    int i=0,sum=0 ;
    for(int j=0 ; j<evenArr.size(); j++){
      arr[i++]=evenArr.get(j);
      arr[i++]=oddArr.get(j);
      sum+=evenArr.get(j)*oddArr.get(j);
    }
    return sum ;
  }
  public static void main(String[] args){
    int arr[]={
      1,5,8,9,6,7,3,4,2,0 };
      int n=arr.length ;
      System.out.println("Minimum required sum="+minSum(arr,n));
      System.out.println("Sorted array in required format : ");
      for(int i=0 ; i<n ; i++){
        System.out.print(arr[i]+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var evenArr : Sequence(int) ; evenArr := Sequence{} ;
     var oddArr : Sequence(int) ; oddArr := Sequence{} ;
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i < n / 2) then (     oddArr := oddArr->including(arr[i+1]) ) else (     evenArr := evenArr->including(arr[i+1]) ) )  ;     i := i + 1 ) ; 
    var comparator : Comparator ; comparator := .reverseOrder() ;
    evenArr, comparator := evenArr, comparator->sort() ; 
    var i : int ; i := 0 ;
    var sum : int ; sum := 0 ;
        var j : int ; j := 0 ; while j < evenArr->size() do ( (      arr[i+1] := evenArr->at(j+1)  ; i := i + 1 ; 
      arr[i+1] := oddArr->at(j+1)  ; i := i + 1 ; 
     sum := sum+(evenArr->at(j+1) * oddArr->at(j+1)) )  ;     j := j + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,8,9,6,7,3,4,2,0} ;
     var n : int ; n := arr->size() ;
    OclFile["System.out"].println("Minimum required sum=" + minSum(arr, n)) ; 
    OclFile["System.out"].println("Sorted array in required format : ") ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int x=sc.nextInt();
      int y=sc.nextInt();
      if(x>y){
        int temp=x ;
        x=y ;
        y=temp ;
      }
      if((Math.min(x,y)!=0)||(Math.max(x,y)<=0)||((n-1)% Math.max(x,y))!=0)System.out.println(-1);
      else {
        for(int i=2 ; i<=n ; i+=y){
          for(int j=1 ; j<=y ; j++)System.out.print(i+" ");
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    if (x > y) then (     var temp : int ; temp := x ;
     x := y ; 
     y := temp ) else skip ; 
    if ((Set{x, y}->min() /= 0) or (Set{x, y}->max() <= 0) or ((n - 1) mod Set{x, y}->max()) /= 0) then     OclFile["System.out"].println(-1) else (         var i : int ; i := 2 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= y do (     OclFile["System.out"].print(i + " ") ;  ;     j := j + 1 ) )  ;     i := i+(y) ) ; 
     OclFile["System.out"].println() ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  static long smallestDivisor(long n){
    if(n % 2==0)return 2 ;
    for(long i=3 ; i*i<=n ; i+=2){
      if(n % i==0)return i ;
    }
    return n ;
  }
  ArrayList<Integer>ans=new ArrayList<>();
  public static int solve(int n,int x,int y){
    if(x!=0 && y!=0){
      return-1 ;
    }
    int p=Math.max(x,y);
    if(p==0){
      return-1 ;
    }
    if((n-1)% p!=0){
      return-1 ;
    }
    int condi=0 ;
    int pi=p ;
    int o=1 ;
    for(int j=0 ; j<n-1 ; j+=p){
      for(int i=0 ; i<p ; i++){
        System.out.print(o+" ");
      }
      if(condi==0){
        condi=1 ;
        o+=pi+1 ;
      }
      else {
        o+=pi ;
      }
    }
    System.out.println();
    return 1 ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long t=sc.nextLong();
    while(t>0){
      t--;
      int n=sc.nextInt();
      int x=sc.nextInt();
      int y=sc.nextInt();
      int so=solve(n,x,y);
      if(so==-1){
        System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation smallestDivisor( n : long) : long
  pre: true
  post: true
  activity: (     if (n mod 2 = 0) then     return 2 else skip ; 
         var i : long ; i := 3 ; while i * i <= n do ( (     if (n mod i = 0) then     return i else skip )  ;     i := i+(2) ) ; 
     return n );
   attribute ans : Sequence(int) := Sequence{};
  static   operation solve( n : int, x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (x /= 0 & y /= 0) then (     return -1 ) else skip ; 
     var p : int ; p := Set{x, y}->max() ;
    if (p = 0) then (     return -1 ) else skip ; 
    if ((n - 1) mod p /= 0) then (     return -1 ) else skip ; 
    var condi : int ; condi := 0 ;
    var pi : int ; pi := p ;
    var o : int ; o := 1 ;
        var j : int ; j := 0 ; while j < n - 1 do ( (         var i : int ; i := 0 ; while i < p do ( (     OclFile["System.out"].print(o + " ") )  ;     i := i + 1 ) ; 
     if (condi = 0) then (     condi := 1 ; 
     o := o+(pi + 1) ) else (     o := o+(pi) ) )  ;     j := j+(p) ) ; 
    OclFile["System.out"].println() ; 
    return 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : long ; t := sc.getCurrent()->toLong() ;
     while (t > 0) do (     t := t - 1 ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var so : int ; so := solve(n, x, y) ;
    if (so = -1) then (     OclFile["System.out"].println(-1) ) else skip ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test264 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int a=in.nextInt();
      int b=in.nextInt();
      int c=in.nextInt();
      if((b==0 && c==0)||(b!=0 && c!=0)){
        System.out.println(-1);
      }
      else {
        if((a-1)% Math.max(b,c)==0){
          int x=1 ;
          for(int i=1 ; i<a ; i++){
            System.out.print(x+" ");
            if(i % Math.max(c,b)==0){
              x=i+2 ;
            }
          }
          System.out.println();
        }
        else {
          System.out.println(-1);
        }
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test264 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
     var c : int ; c := in.getCurrent()->toInteger() ;
     if ((b = 0 & c = 0) or (b /= 0 & c /= 0)) then (     OclFile["System.out"].println(-1) ) else (     if ((a - 1) mod Set{b, c}->max() = 0) then (     var x : int ; x := 1 ;
         var i : int ; i := 1 ; while i < a do ( (     OclFile["System.out"].print(x + " ") ; 
     if (i mod Set{c, b}->max() = 0) then (     x := i + 2 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) else (     OclFile["System.out"].println(-1) ) ) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class SoftDrinking {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int[] array=new int[8];
    for(int i=0 ; i<8 ; i++){
      array[i]=in.nextInt();
    }
    int drinkPerPerson=(array[1]*array[2])/array[6];
    int limesPerPerson=array[3]*array[4];
    int saltPerPerson=array[5]/array[7];
    System.out.println(Math.min(Math.min(drinkPerPerson,limesPerPerson),saltPerPerson)/array[0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class SoftDrinking {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var array : Sequence(int) ; array := Integer.subrange(1,8)->collect(0) ;
        var i : int ; i := 0 ; while i < 8 do ( (     array[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var drinkPerPerson : int ; drinkPerPerson := (array[1+1] * array[2+1]) / array[6+1] ;
    var limesPerPerson : int ; limesPerPerson := array[3+1] * array[4+1] ;
    var saltPerPerson : int ; saltPerPerson := array[5+1] / array[7+1] ;
    OclFile["System.out"].println(Set{Set{drinkPerPerson, limesPerPerson}->min(), saltPerPerson}->min() / array[0+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  static int MOD=1000000007 ;
  static int[] arr=new int[100001];
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      solve(s);
    }
  }
  public static void solve(Scanner s){
    int n=s.nextInt();
    int x=s.nextInt();
    int y=s.nextInt();
    if(Math.min(x,y)!=0 || Math.max(x,y)<=0 ||(n-1)% Math.max(x,y)!=0){
      System.out.println(-1);
      return ;
    }
    else {
      int dig=Math.max(x,y);
      int k=0 ;
      for(int i=1 ; i<=n-1 ; i+=dig){
        for(int j=0 ; j<dig ; j++)System.out.print(2+(dig*k)+" ");
        k++;
      }
      System.out.println();
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   attribute MOD : int := 1000000007;
  static   attribute arr : Sequence(int) := Integer.subrange(1,100001)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve(s) ) ;  ) );
  static   operation solve( s : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s.getCurrent()->toInteger() ;
     var x : int ; x := s.getCurrent()->toInteger() ;
     var y : int ; y := s.getCurrent()->toInteger() ;
     if (Set{x, y}->min() /= 0 or Set{x, y}->max() <= 0 or (n - 1) mod Set{x, y}->max() /= 0) then (     OclFile["System.out"].println(-1) ; 
     return ) else (     var dig : int ; dig := Set{x, y}->max() ;
     var k : int ; k := 0 ;
        var i : int ; i := 1 ; while i <= n - 1 do ( (         var j : int ; j := 0 ; while j < dig do (     OclFile["System.out"].print(2 + (dig * k) + " ") ;  ;     j := j + 1 ) ; 
     k := k + 1 )  ;     i := i+(dig) ) ; 
    OclFile["System.out"].println() ; 
    return 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.util.TreeMap ;
public class B {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt(),m=sc.nextInt(),sx=sc.nextInt(),sy=sc.nextInt(),d=sc.nextInt();
      int xmx=Math.min(sx+d,n);
      int xmn=Math.max(sx-d,1);
      int ymx=Math.min(sy+d,m);
      int ymn=Math.max(sy-d,1);
      if(xmn==1 && xmx==n || ymn==1 && ymx==m ||((xmn==1 || ymx==m)&&(ymn==1 || xmx==n))){
        out.println(-1);
      }
      else out.println(n+m-2);
    }
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public boolean hasNext(){
      return st.hasMoreTokens();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var sx : int ; sx := sc.getCurrent()->toInteger() ;
    var sy : int ; sy := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
     var xmx : int ; xmx := Set{sx + d, n}->min() ;
    var xmn : int ; xmn := Set{sx - d, 1}->max() ;
    var ymx : int ; ymx := Set{sy + d, m}->min() ;
    var ymn : int ; ymn := Set{sy - d, 1}->max() ;
    if (xmn = 1 & xmx = n or ymn = 1 & ymx = m or ((xmn = 1 or ymx = m) & (ymn = 1 or xmx = n))) then (     skip ) else     skip ; ;  
 ) ;  ) ;  
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return st.hasNext() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  static int[][] dirs={
    {
      1,0 },{
        0,1 },{
-1,0 },{
            0,-1 }
          };
          public static void main(String[] args)throws IOException {
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            int t=Integer.parseInt(br.readLine());
            for(int i=0 ; i<t ; i++){
              solve(br);
            }
          }
          public static void solve(BufferedReader br)throws IOException {
            int[] in=readLine2IntArray(br);
            if((in[2]-in[4]>1 && in[3]+in[4]<in[1])||(in[2]+in[4]<in[0] && in[3]-in[4]>1)){
              System.out.println(in[0]+in[1]-2);
            }
            else {
              System.out.println(-1);
            }
          }
          private static int[] readLine2IntArray(BufferedReader br)throws IOException {
            String[] strs=br.readLine().split(" ");
            int n=strs.length ;
            int[] res=new int[n];
            for(int i=0 ; i<n ; i++){
              res[i]=Integer.parseInt(strs[i]);
            }
            return res ;
          }
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dirs : Sequence(Sequence(int)) := Sequence{Sequence{1,0},Sequence{0,1},Sequence{-1,0},Sequence{0,-1}};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     execute solve(br) )  ;     i := i + 1 ) );
  static   operation solve( br : OclFile) : void
  pre: true
  post: true
  activity: (     var in : Sequence(int) ; in := readLine2IntArray(br) ;
     if ((in[2+1] - in[4+1] > 1 & in[3+1] + in[4+1] < in[1+1]) or (in[2+1] + in[4+1] < in[0+1] & in[3+1] - in[4+1] > 1)) then (     OclFile["System.out"].println(in[0+1] + in[1+1] - 2) ) else (     OclFile["System.out"].println(-1) ) );
  static   operation readLine2IntArray( br : OclFile) : Sequence(int)
  pre: true
  post: true
  activity: (     var strs : Sequence(String) ; strs := br.readLine()->split(" ") ;
     var n : int ; n := strs->size() ;
    var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     res[i+1] := (strs[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static final Scanner scan=new Scanner(System.in);
  public static void main(String[] args){
    List<Integer>list=new ArrayList<Integer>();
    for(; ; ){
      int n=scan.nextInt();
      int x=scan.nextInt();
      if(n==0 && x==0){
        break ;
      }
      int cnt=0 ;
      for(int i=1 ; i<=n ; i++){
        for(int j=i+1 ; j<=n ; j++){
          for(int k=j+1 ; k<=n ; k++){
            if(i+j+k==x){
              cnt++;
            }
          }
        }
      }
      list.add(cnt);
    }
    for(int c : list){
      System.out.println(c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
       while true do ( (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var x : int ; x := scan.getCurrent()->toInteger() ;
    if (n = 0 & x = 0) then (     break ) else skip ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i + 1 ; while j <= n do ( (         var k : int ; k := j + 1 ; while k <= n do ( (     if (i + j + k = x) then (     cnt := cnt + 1 ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    list := list->including(cnt) ; 
 )  ) ; 
     for (c : list) do ( (     OclFile["System.out"].println(c) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javax.swing.text.MaskFormatter ;
import java.io.*;
import java.util.*;
public class CodeForces {
  public static void main(String[] args){
    FastReader fastReader=new FastReader();
    int t=fastReader.nextInt();
    while(t-->0){
      int n=fastReader.nextInt();
      int m=fastReader.nextInt();
      int sx=fastReader.nextInt();
      int sy=fastReader.nextInt();
      int d=fastReader.nextInt();
      if(d==0)System.out.println(n+m-2);
      else if(Math.min(n-sx,sy-1)<=d && Math.min(m-sy,sx-1)<=d)System.out.println(-1);
      else System.out.println(n+m-2);
    }
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(String s){
    try {
      br=new BufferedReader(new FileReader(s));
    }
    catch(FileNotFoundException e){
      e.printStackTrace();
    }
  }
  public FastReader(){
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  String nextToken(){
    while(st==null || ! st.hasMoreElements()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
    }
    return st.nextToken();
  }
  String nextLine(){
    String str="" ;
    try {
      if(st.hasMoreTokens()){
        str=st.nextToken("\n");
      }
      else {
        str=br.readLine();
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return str ;
  }
  int nextInt(){
    return Integer.parseInt(nextToken());
  }
  long nextLong(){
    return Long.parseLong(nextToken());
  }
  double nextDouble(){
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fastReader : FastReader ; fastReader := FastReader.newFastReader() ;
     var t : int ; t := fastReader.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := fastReader.nextInt() ;
     var m : int ; m := fastReader.nextInt() ;
    var sx : int ; sx := fastReader.nextInt() ;
    var sy : int ; sy := fastReader.nextInt() ;
    var d : int ; d := fastReader.nextInt() ;
    if (d = 0) then     OclFile["System.out"].println(n + m - 2) else     if (Set{n - sx, sy - 1}->min() <= d & Set{m - sy, sx - 1}->min() <= d) then     OclFile["System.out"].println(-1) else     OclFile["System.out"].println(n + m - 2) ; ;  ;  
 ) ;  ) );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader( s : String) : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
 );
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int T ;
    Scanner in=new Scanner(System.in);
    T=in.nextInt();
    while(T!=0){
      T--;
      long a=in.nextLong();
      long b=in.nextLong();
      long c=in.nextLong();
      long d=in.nextLong();
      Frac x=new Frac((a),(b));
      Frac y=new Frac((c),(d));
      if(x.equals(y)){
        System.out.println("0");
        continue ;
      }
      Frac z=new Frac(x.a*y.b,x.b*y.a);
      if(z.a==1 || z.b==1){
        System.out.println("1");
      }
      else {
        System.out.println("2");
      }
    }
  }
}
class Frac {
  long a,b ;
  public Frac(long a,long b){
    this.a=a/gcd(a,b);
    this.b=b/gcd(a,b);
  }
  public static long gcd(long a,long b){
    if(b==0){
      return a ;
    }
    return gcd(b,a % b);
  }
  public boolean equals(Frac x){
    if(a==x.a && b==x.b){
      return true ;
    }
    else {
      return false ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     T := in.getCurrent()->toInteger() ; 
     while (T /= 0) do (     T := T - 1 ; 
     var a : long ; a := in.getCurrent()->toLong() ;
    var b : long ; b := in.getCurrent()->toLong() ;
    var c : long ; c := in.getCurrent()->toLong() ;
    var d : long ; d := in.getCurrent()->toLong() ;
    var x : Frac ; x := Frac.newFrac((a), (b)) ;
    var y : Frac ; y := Frac.newFrac((c), (d)) ;
    if (x = y) then (     OclFile["System.out"].println("0") ; 
     continue ) else skip ; 
    var z : Frac ; z := Frac.newFrac(x.a * y.b, x.b * y.a) ;
    if (z.a = 1 or z.b = 1) then (     OclFile["System.out"].println("1") ) else (     OclFile["System.out"].println("2") ) ;  
 ) );
}
class Frac {
   attribute a : long;
   static operation newFrac( a : long, b : long) : Frac
  pre: true
  post: true
  activity:
  ( var self : Frac ;
    self := createFrac();
    self.initialise(a, b);
    return self );
  operation initialise( a : long, b : long) : void
  pre: true  post: true
  activity: (     self.a := a / gcd(a, b) ; 
     self.b := b / gcd(a, b) );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else skip ; 
     return gcd(b, a mod b) );
   operation equals( x : Frac) : boolean
  pre: true
  post: true
  activity: (     if (a = x.a & b = x.b) then (     return true ) else (     return false ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Map ;
import java.util.Queue ;
import java.util.Scanner ;
public class sneh {
  public static void main(String args[]){
    int tt ;
    Scanner sc=new Scanner(System.in);
    tt=sc.nextInt();
    while(tt>0){
      long a,b,c,d ;
      a=sc.nextInt();
      b=sc.nextInt();
      c=sc.nextInt();
      d=sc.nextInt();
      long x=a*d ;
      long y=b*c ;
      if((x==0 || y==0)&& x!=y){
        System.out.println(1);
        tt--;
        continue ;
      }
      if(x==y){
        System.out.println(0);
      }
      else if(x % y==0 || y % x==0){
        System.out.println(1);
      }
      else {
        System.out.println(2);
      }
      tt--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class sneh {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var tt : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     tt := sc.getCurrent()->toInteger() ; 
     while (tt > 0) do (     var a : long ;
    var b : long ;
    var c : long ;
    var d : long ;
     a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    c := sc.getCurrent()->toInteger() ; 
    d := sc.getCurrent()->toInteger() ; 
    var x : long ; x := a * d ;
    var y : long ; y := b * c ;
    if ((x = 0 or y = 0) & x /= y) then (     OclFile["System.out"].println(1) ; 
     tt := tt - 1 ; 
     continue ) else skip ; 
    if (x = y) then (     OclFile["System.out"].println(0) ) else     if (x mod y = 0 or y mod x = 0) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(2) ) ;  ;  
    tt := tt - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int d=sc.nextInt();
      long x=(long)a*d ;
      long y=(long)b*c ;
      if(x==y)System.out.println((0));
      else {
        long div=gcd(x,y);
        if((x/div)!=1 &&(y/div)!=1)System.out.println(2);
        else if((x/div)!=1 ||(y/div)!=1)System.out.println(1);
        else System.out.println(0);
      }
    }
  }
  static long gcd(long a,long b){
    if(a<b)return gcd(b,a);
    if(b==0)return a ;
    else return gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var x : long ; x := a->oclAsType(long) * d ;
    var y : long ; y := b->oclAsType(long) * c ;
    if (x = y) then     OclFile["System.out"].println((0)) else (     var div : long ; div := gcd(x, y) ;
     if ((x / div) /= 1 & (y / div) /= 1) then     OclFile["System.out"].println(2) ; else     if ((x / div) /= 1 or (y / div) /= 1) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println(0) ; ;  ) ;  
 )  ;     i := i + 1 ) );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a < b) then     return gcd(b, a) else skip ; 
     if (b = 0) then     return a else     return gcd(b, a mod b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static final int MOD=1000000007 ;
  public static void main(String[] args){
    int N=sc.nextInt();
    long[][][] dp=new long[N+1][N+1][N+1];
    dp[0][0][0]=1 ;
    int idx=0 ;
    for(int i=0 ; i<N ; ++i){
      char v=sc.next().charAt(0);
      if(v=='-')continue ;
++idx ;
      if(v=='D'){
        for(int j=0 ; j<idx ; ++j){
          for(int k=1 ; k<idx ; ++k){
            dp[idx][j][k]+=dp[idx-1][j][k]*j ;
            if(j>0)dp[idx][j-1][k-1]+=dp[idx-1][j][k]*j*k ;
          }
        }
      }
      else {
        for(int j=0 ; j<idx ; ++j){
          for(int k=0 ; k<idx ; ++k){
            dp[idx][j+1][k+1]+=dp[idx-1][j][k];
            dp[idx][j][k]+=dp[idx-1][j][k]*j ;
          }
        }
      }
      for(int j=0 ; j<idx ; ++j){
        for(int k=0 ; k<idx ; ++k){
          dp[idx][j][k] %=MOD ;
        }
      }
    }
    System.out.println(dp[idx][0][0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var dp : Sequence(Sequence(Sequence(long))) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(0))) ;
    dp[0+1][0+1][0+1] := 1 ; 
    var idx : int ; idx := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var v : String ; v := sc.getCurrent()->at(0+1) ;
     if (v = '-') then     continue else skip ; 
    idx := idx + 1 ; 
    if (v = 'D') then (         var j : int ; j := 0 ; while j < idx do ( (         var k : int ; k := 1 ; while k < idx do ( (     dp[idx+1][j+1][k+1] := dp[idx+1][j+1][k+1]+(dp[idx - 1+1][j+1][k+1] * j) ; 
     if (j > 0) then     dp[idx+1][(j)->char2byte() - 1+1][k - 1+1] := dp[idx+1][(j)->char2byte() - 1+1][k - 1+1]+(dp[idx - 1+1][j+1][k+1] * j * k) ; else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ) else (         var j : int ; j := 0 ; while j < idx do ( (         var k : int ; k := 0 ; while k < idx do ( (     dp[idx+1][j + 1+1][k + 1+1] := dp[idx+1][j + 1+1][k + 1+1]+(dp[idx - 1+1][j+1][k+1]) ; 
     dp[idx+1][j+1][k+1] := dp[idx+1][j+1][k+1]+(dp[idx - 1+1][j+1][k+1] * j) )  ;     k := k + 1 ) )  ;     j := j + 1 ) ) ;  
        var j : int ; j := 0 ; while j < idx do ( (         var k : int ; k := 0 ; while k < idx do ( (     dp[idx+1][j+1][k+1] := dp[idx+1][j+1][k+1] mod MOD )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[idx+1][0+1][0+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static final int MOD=1000000007 ;
  public static void main(String[] args){
    int N=sc.nextInt();
    long[][][] dp=new long[N+1][N+1][N+1];
    dp[0][0][0]=1 ;
    int idx=0 ;
    for(int i=0 ; i<N ; ++i){
      char v=sc.next().charAt(0);
      if(v=='-')continue ;
++idx ;
      if(v=='D'){
        for(int j=0 ; j<idx ; ++j){
          for(int k=1 ; k<idx ; ++k){
            dp[idx][j][k]+=dp[idx-1][j][k]*j % MOD ;
            if(j>0)dp[idx][j-1][k-1]+=dp[idx-1][j][k]*j*k % MOD ;
          }
        }
      }
      else {
        for(int j=0 ; j<idx ; ++j){
          for(int k=0 ; k<idx ; ++k){
            dp[idx][j+1][k+1]+=dp[idx-1][j][k];
            dp[idx][j][k]+=dp[idx-1][j][k]*j % MOD ;
          }
        }
      }
    }
    System.out.println(dp[idx][0][0] % MOD);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var dp : Sequence(Sequence(Sequence(long))) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(0))) ;
    dp[0+1][0+1][0+1] := 1 ; 
    var idx : int ; idx := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var v : String ; v := sc.getCurrent()->at(0+1) ;
     if (v = '-') then     continue else skip ; 
     idx := idx + 1 ; 
     if (v = 'D') then (         var j : int ; j := 0 ; while j < idx do ( (         var k : int ; k := 1 ; while k < idx do ( (     dp[idx+1][j+1][k+1] := dp[idx+1][j+1][k+1]+(dp[idx - 1+1][j+1][k+1] * j mod MOD) ; 
     if (j > 0) then     dp[idx+1][(j)->char2byte() - 1+1][k - 1+1] := dp[idx+1][(j)->char2byte() - 1+1][k - 1+1]+(dp[idx - 1+1][j+1][k+1] * j * k mod MOD) ; else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ) else (         var j : int ; j := 0 ; while j < idx do ( (         var k : int ; k := 0 ; while k < idx do ( (     dp[idx+1][j + 1+1][k + 1+1] := dp[idx+1][j + 1+1][k + 1+1]+(dp[idx - 1+1][j+1][k+1]) ; 
     dp[idx+1][j+1][k+1] := dp[idx+1][j+1][k+1]+(dp[idx - 1+1][j+1][k+1] * j mod MOD) )  ;     k := k + 1 ) )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[idx+1][0+1][0+1] mod MOD) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static final int MOD=1000000007 ;
  public static void main(String[] args){
    int N=sc.nextInt();
    long[][] dp=new long[N+1][N+1];
    dp[0][0]=1 ;
    int idx=0 ;
    for(int i=0 ; i<N ; ++i){
      char v=sc.next().charAt(0);
      if(v=='-')continue ;
++idx ;
      if(v=='D'){
        for(int j=0 ; j<idx ; ++j){
          dp[idx][j]+=dp[idx-1][j]*j % MOD ;
          if(j>0)dp[idx][j-1]+=dp[idx-1][j]*j*j % MOD ;
        }
      }
      else {
        for(int j=0 ; j<idx ; ++j){
          dp[idx][j+1]+=dp[idx-1][j];
          dp[idx][j]+=dp[idx-1][j]*j % MOD ;
        }
      }
    }
    System.out.println(dp[idx][0] % MOD);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
    var idx : int ; idx := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var v : String ; v := sc.getCurrent()->at(0+1) ;
     if (v = '-') then     continue else skip ; 
     idx := idx + 1 ; 
     if (v = 'D') then (         var j : int ; j := 0 ; while j < idx do ( (     dp[idx+1][j+1] := dp[idx+1][j+1]+(dp[idx - 1+1][j+1] * j mod MOD) ; 
     if (j > 0) then     dp[idx+1][(j)->char2byte() - 1+1] := dp[idx+1][(j)->char2byte() - 1+1]+(dp[idx - 1+1][j+1] * j * j mod MOD) ; else skip )  ;     j := j + 1 ) ) else (         var j : int ; j := 0 ; while j < idx do ( (     dp[idx+1][j + 1+1] := dp[idx+1][j + 1+1]+(dp[idx - 1+1][j+1]) ; 
     dp[idx+1][j+1] := dp[idx+1][j+1]+(dp[idx - 1+1][j+1] * j mod MOD) )  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[idx+1][0+1] mod MOD) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math.*;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int AG=sc.nextInt();
    int op=sc.nextInt();
    int kl=sc.nextInt();
    int er=sc.nextInt();
    int d=sc.nextInt();
    int phy=sc.nextInt();
    int valnl=sc.nextInt();
    int valnp=sc.nextInt();
    int h=op*kl ;
    int dr=(h)/valnl ;
    int sr=(er*d);
    int q=phy/valnp ;
    int slt=(q);
    int valt=Math.min(sr,slt);
    valt=Math.min(valt,dr);
    valt/=AG ;
    System.out.println(valt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var AG : int ; AG := sc.getCurrent()->toInteger() ;
    var op : int ; op := sc.getCurrent()->toInteger() ;
    var kl : int ; kl := sc.getCurrent()->toInteger() ;
    var er : int ; er := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var phy : int ; phy := sc.getCurrent()->toInteger() ;
    var valnl : int ; valnl := sc.getCurrent()->toInteger() ;
    var valnp : int ; valnp := sc.getCurrent()->toInteger() ;
    var h : int ; h := op * kl ;
    var dr : int ; dr := (h) / valnl ;
    var sr : int ; sr := (er * d) ;
    var q : int ; q := phy / valnp ;
    var slt : int ; slt := (q) ;
    var valt : int ; valt := Set{sr, slt}->min() ;
    valt := Set{valt, dr}->min() ; 
    valt := valt/(AG) ; 
    OclFile["System.out"].println(valt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static final int MOD=1000000007 ;
  public static void main(String[] args){
    int N=sc.nextInt();
    long[][] dp=new long[2][N+1];
    dp[0][0]=1 ;
    int t=1 ;
    for(int i=0 ; i<N ; ++i){
      char v=sc.next().charAt(0);
      if(v=='-')continue ;
      Arrays.fill(dp[t],0);
      if(v=='D'){
        for(int j=1 ; j<=i ; ++j){
          dp[t][j]+=dp[1-t][j]*j % MOD ;
          dp[t][j-1]+=dp[1-t][j]*j*j % MOD ;
        }
      }
      else {
        for(int j=0 ; j<=i ; ++j){
          dp[t][j+1]+=dp[1-t][j];
          dp[t][j]+=dp[1-t][j]*j % MOD ;
        }
      }
      t=1-t ;
    }
    System.out.println(dp[1-t][0] % MOD);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute MOD : int := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,2)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
    var t : int ; t := 1 ;
        var i : int ; i := 0 ; while i < N do ( (     var v : String ; v := sc.getCurrent()->at(0+1) ;
     if (v = '-') then     continue else skip ; 
    dp[t+1] := dp[t+1]->collect(0) ; 
    if (v = 'D') then (         var j : int ; j := 1 ; while j <= i do ( (     dp[t+1][j+1] := dp[t+1][j+1]+(dp[1 - t+1][j+1] * j mod MOD) ; 
     dp[t+1][(j)->char2byte() - 1+1] := dp[t+1][(j)->char2byte() - 1+1]+(dp[1 - t+1][j+1] * j * j mod MOD) )  ;     j := j + 1 ) ) else (         var j : int ; j := 0 ; while j <= i do ( (     dp[t+1][j + 1+1] := dp[t+1][j + 1+1]+(dp[1 - t+1][j+1]) ; 
     dp[t+1][j+1] := dp[t+1][j+1]+(dp[1 - t+1][j+1] * j mod MOD) )  ;     j := j + 1 ) ) ;  
    t := 1 - t ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[1 - t+1][0+1] mod MOD) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class NewClass_B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    k : while(T-->0){
      int n=sc.nextInt();
      int arr[]=new int[n];
      int zero=0 ;
      ArrayList<Integer>index=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
        if(arr[i]!=0){
          index.add(i);
        }
      }
      if(n==1){
        if(arr[0]==0){
          System.out.println(0);
        }
        else {
          System.out.println(1);
        }
        continue ;
      }
      if(index.isEmpty()){
        System.out.println(0);
        continue ;
      }
      for(int i=1 ; i<index.size(); i++){
        if(index.get(i)-index.get(i-1)>1){
          System.out.println(2);
          continue k ;
        }
      }
      System.out.println(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass_B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var zero : int ; zero := 0 ;
    var index : Sequence(int) ; index := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr[i+1] /= 0) then (     index := index->including(i) ) else skip )  ;     i := i + 1 ) ; 
    if (n = 1) then (     if (arr[0+1] = 0) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(1) ) ;  
     continue ) else skip ; 
    if (index->isEmpty()) then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
        var i : int ; i := 1 ; while i < index->size() do ( (     if (index->at(i+1) - index->at(i - 1+1) > 1) then (     OclFile["System.out"].println(2) ; 
     continue ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(1) ; 
 ) ;  ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String x="" ;
    try {
      while((x=in.readLine()).equals("0 0")==false){
        String[] data=x.split(" ");
        int n=Integer.parseInt(data[0]);
        int sum=(Integer.parseInt(data[1])-3);
        int num=0 ;
        for(int i=0 ; i<n ; i++){
          for(int j=(i+1); (i+j)<sum ; j++){
            int k=sum-(i+j);
            if((k>j)&&(k<n))num++;
          }
        }
        System.out.println(num);
      }
    }
    catch(NumberFormatException e){
      e.printStackTrace();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var x : String ; x := "" ;
     try (         x := in.readLine() ;
    while ((x) = "0 0" = false) do (        x := in.readLine() ;
    (x) = "0 0" ;     skip ; (     var data : Sequence(String) ; data := x->split(" ") ;
     var n : int ; n := (data[0+1])->toInteger() ;
    var sum : int ; sum := ((data[1+1])->toInteger() - 3) ;
    var num : int ; num := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := (i + 1) ; while (i + j) < sum do ( (     var k : int ; k := sum - (i + j) ;
     if ((k > j) & (k < n)) then     num := num + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(num) ; 
 ) ;     x := in.readLine() ;
 ) )   catch (e : IncorrectElementException) do (     e.printStackTrace() )
   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=in.nextInt();
      int[] arr=new int[n];
      boolean f=true ;
      int l=0 ;
      for(int j=0 ; j<n ; j++){
        int num=in.nextInt();
        if(f && num==0)l++;
        else {
          f=false ;
        }
        arr[j]=num ;
      }
      int r=0 ;
      for(int j=n-1 ; j>=0 ; j--){
        if(arr[j]==0)r++;
        else break ;
      }
      int len=n-l ;
      if(len<=0){
        System.out.println(0);
        continue ;
      }
      int count=0 ;
      for(int j=l ; j<n-r ; j++){
        if(count>0)break ;
        if(arr[j]==0)count++;
      }
      System.out.println(count>0 ? 2 : 1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var f : boolean ; f := true ;
    var l : int ; l := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     var num : int ; num := in.getCurrent()->toInteger() ;
     if (f & num = 0) then     l := l + 1 else (     f := false ) ;  
     arr[j+1] := num )  ;     j := j + 1 ) ; 
    var r : int ; r := 0 ;
        var j : int ; j := n - 1 ; while j >= 0 do ( (     if (arr[j+1] = 0) then     r := r + 1 ; else     break )  ;     j := j - 1 ) ; 
    var len : int ; len := n - l ;
    if (len <= 0) then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
    var count : int ; count := 0 ;
        var j : int ; j := l ; while j < n - r do ( (     if (count > 0) then     break else skip ; 
     if (arr[j+1] = 0) then     count := count + 1 ; else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(if count > 0 then 2 else 1 endif) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int N=9 ;
  static void addEgde(List<Integer>[] adj,int u,int v){
    adj[u] .add(v);
    adj[v] .add(u);
  }
  static void DFS(int node,int parent,int G,int leaf,int val[],List<Integer>[] adj){
    if(node==leaf){
      G=__gcd(G,val[node]);
      System.out.print(G);
      return ;
    }
    for(int it : adj[node]){
      if(it!=parent)DFS(it,node,__gcd(G,val[it]),leaf,val,adj);
    }
  }
  static int __gcd(int a,int b){
    return b==0 ? a : __gcd(b,a % b);
  }
  public static void main(String[] args){
    int n=8 ;
    List<Integer>[] adj=new LinkedList[n+1];
    for(int i=0 ; i<n+1 ; i++)adj[i]=new LinkedList<Integer>();
    addEgde(adj,1,2);
    addEgde(adj,2,4);
    addEgde(adj,1,3);
    addEgde(adj,3,5);
    addEgde(adj,3,6);
    addEgde(adj,6,7);
    addEgde(adj,6,8);
    int leaf=5 ;
    int val[]={
-1,6,2,6,3,4,12,10,18 };
      int G=val[1];
      DFS(1,-1,G,leaf,val,adj);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute N : int := 9;
  static   operation addEgde( adj : Sequence(Sequence(int)), u : int, v : int) : void
  pre: true
  post: true
  activity: (     adj[u+1]->excludes(v) ; 
     adj[v+1]->excludes(u) );
  static   operation DFS( node : int, parent : int, G : int, leaf : int, val : Sequence(int), adj : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     if (node = leaf) then (     G := __gcd(G, val[node+1]) ; 
     OclFile["System.out"].print(G) ; 
     return ) else skip ; 
     for (it : adj[node+1]) do ( (     if (it /= parent) then     execute DFS(it, node, __gcd(G, val[it+1]), leaf, val, adj) ; else skip )  ) );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else __gcd(b, a mod b) endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     var adj : Sequence(Sequence(int)) ; adj := Integer.subrange(1,n + 1)->collect(null) ;
        var i : int ; i := 0 ; while i < n + 1 do (     adj[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
    execute addEgde(adj, 1, 2) ; 
    execute addEgde(adj, 2, 4) ; 
    execute addEgde(adj, 1, 3) ; 
    execute addEgde(adj, 3, 5) ; 
    execute addEgde(adj, 3, 6) ; 
    execute addEgde(adj, 6, 7) ; 
    execute addEgde(adj, 6, 8) ; 
    var leaf : int ; leaf := 5 ;
    var val : Sequence(int) ; val := Sequence{-1,6,2,6,3,4,12,10,18} ;
    var G : int ; G := val[1+1] ;
    execute DFS(1, -1, G, leaf, val, adj) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  void solve(){
    Scanner cin=new Scanner(System.in);
    while(true){
      int n=cin.nextInt();
      if(n==0)return ;
      int[] time=new int[n*2];
      for(int i=0 ; i<2*n ; i++){
        time[i]=gettime(cin.next())+(i+1)% 2 ;
      }
      Arrays.sort(time);
      int ret=0 ;
      int now=0 ;
      for(int a : time){
        if(a % 2==1)now++;
        else now--;
        ret=Math.max(ret,now);
      }
      System.out.println(ret);
    }
  }
  int gettime(String s){
    int ret=0 ;
    ret+=s.charAt(0)-'0' ;
    ret*=10 ;
    ret+=s.charAt(1)-'0' ;
    ret*=10 ;
    ret+=s.charAt(3)-'0' ;
    ret*=10 ;
    ret+=s.charAt(4)-'0' ;
    ret*=10 ;
    ret+=s.charAt(6)-'0' ;
    ret*=10 ;
    ret+=s.charAt(7)-'0' ;
    ret*=10 ;
    return ret ;
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := cin.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var time : Sequence(int) ; time := Integer.subrange(1,n * 2)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     time[i+1] := gettime(cin.getCurrent()) + (i + 1) mod 2 )  ;     i := i + 1 ) ; 
    time := time->sort() ; 
    var ret : int ; ret := 0 ;
    var now : int ; now := 0 ;
    for (a : time) do ( (     if (a mod 2 = 1) then     now := now + 1 else     now := now - 1 ; ;  
     ret := Set{ret, now}->max() )  ) ; 
    OclFile["System.out"].println(ret) ; 
 ) );
   operation gettime( s : String) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
     ret := ret+(s->at(0+1) - ('0')->char2byte()) ; 
    ret := ret*(10) ; 
    ret := ret+(s->at(1+1) - ('0')->char2byte()) ; 
    ret := ret*(10) ; 
    ret := ret+(s->at(3+1) - ('0')->char2byte()) ; 
    ret := ret*(10) ; 
    ret := ret+(s->at(4+1) - ('0')->char2byte()) ; 
    ret := ret*(10) ; 
    ret := ret+(s->at(6+1) - ('0')->char2byte()) ; 
    ret := ret*(10) ; 
    ret := ret+(s->at(7+1) - ('0')->char2byte()) ; 
    ret := ret*(10) ; 
    return ret 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static final int MAX=24*60*60 ;
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      final int n=sc.nextInt();
      if(n==0){
        break ;
      }
      int[] imos=new int[MAX];
      for(int i=0 ; i<n ; i++){
        String[] start_str=sc.next().split(":");
        final int start=(Integer.parseInt(start_str[0])*60+Integer.parseInt(start_str[1]))*60+Integer.parseInt(start_str[2]);
        String[] end_str=sc.next().split(":");
        final int end=(Integer.parseInt(end_str[0])*60+Integer.parseInt(end_str[1]))*60+Integer.parseInt(end_str[2]);
        imos[start]++;
        if(end<MAX){
          imos[end]--;
        }
      }
      int max=0 ;
      for(int i=1 ; i<MAX ; i++){
        imos[i]+=imos[i-1];
        max=Math.max(max,imos[i]);
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 24 * 60 * 60;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var imos : Sequence(int) ; imos := Integer.subrange(1,MAX)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var start_str : Sequence(String) ; start_str := sc.getCurrent()->split(":") ;
     var start : int ; start := ((start_str[0+1])->toInteger() * 60 + (start_str[1+1])->toInteger()) * 60 + (start_str[2+1])->toInteger() ;
    var end_str : Sequence(String) ; end_str := sc.getCurrent()->split(":") ;
    var end : int ; end := ((end_str[0+1])->toInteger() * 60 + (end_str[1+1])->toInteger()) * 60 + (end_str[2+1])->toInteger() ;
    imos[start+1] := imos[start+1] + 1 ; 
    if (end < MAX) then (     imos[end+1] := imos[end+1] - 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i < MAX do ( (     imos[i+1] := imos[i+1]+(imos[i - 1+1]) ; 
     max := Set{max, imos[i+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
class Main {
  public static Scanner sc=new Scanner(in);
  public static Random rand=new Random();
  public int parse(String str){
    String[] l=str.split(":");
    return Integer.parseInt(l[0])*3600+Integer.parseInt(l[1])*60+Integer.parseInt(l[2]);
  }
  public void run(){
    while(true){
      int n=sc.nextInt();
      if(n==0)return ;
      int[] imos=new int[3600*24];
      while(n--!=0){
        int from=parse(sc.next());
        int to=parse(sc.next());
        imos[from]++;
        imos[to]--;
      }
      int max=0 ;
      int now=0 ;
      for(int i=0 ; i<imos.length ; i++){
        now+=imos[i];
        max=Math.max(now,max);
      }
      ln(max);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  public int[] nextIntArray(int n){
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=sc.nextInt();
    }
    return res ;
  }
  public static void pr(Object o){
    out.print(o);
  }
  public static void ln(Object o){
    out.println(o);
  }
  public static void ln(){
    out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(in);
  static   attribute rand : OclRandom := OclRandom.newOclRandom();
   operation parse( str : String) : int
  pre: true
  post: true
  activity: (     var l : Sequence(String) ; l := str->split(":") ;
     return (l[0+1])->toInteger() * 3600 + (l[1+1])->toInteger() * 60 + (l[2+1])->toInteger() );
   operation run() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var imos : Sequence(int) ; imos := Integer.subrange(1,3600 * 24)->collect(0) ;
        while (n /= 0) do (    skip ; (     var from : int ; from := parse(sc.getCurrent()) ;
     var to : int ; to := parse(sc.getCurrent()) ;
     imos[from+1] := imos[from+1] + 1 ; 
     imos[to+1] := imos[to+1] - 1 ) ;  ) ;  
    var max : int ; max := 0 ;
    var now : int ; now := 0 ;
        var i : int ; i := 0 ; while i < imos->size() do ( (     now := now+(imos[i+1]) ; 
     max := Set{now, max}->max() )  ;     i := i + 1 ) ; 
    execute ln(max) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return res );
  static   operation pr( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.print(o) );
  static   operation ln( o : OclAny) : void
  pre: true
  post: true
  activity: (     out.println(o) );
  static   operation ln() : void
  pre: true
  post: true
  activity: (     out.println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    read().stream().map(data->data.getRequiredNumber()).forEach(System.out :: println);
  }
  static List<DataSet>read(){
    Scanner scanner=new Scanner(System.in);
    List<DataSet>dataList=new ArrayList<>();
    while(true){
      int length=scanner.nextInt();
      if(length==0){
        break ;
      }
      else {
        DataSet dataSet=new DataSet();
        for(int i=0 ; i<length ; i++){
          dataSet.add(parse(scanner.next()),parse(scanner.next()));
        }
        dataList.add(dataSet);
      }
    }
    scanner.close();
    return dataList ;
  }
  static int parse(String str){
    return Integer.parseInt(str.replaceAll(":",""));
  }
  static class DataSet {
    private Map<Integer,Integer>timeline=new HashMap<>();
    void add(int departure,int arrival){
      timeline.merge(departure,1,(a,b)->a+b);
      timeline.merge(arrival,-1,(a,b)->a+b);
    }
    int getRequiredNumber(){
      List<Integer>timestamps=timeline.keySet().stream().sorted().collect(Collectors.toList());
      int i=0,max=0 ;
      for(int timestamp : timestamps){
        i=i+timeline.get(timestamp);
        max=Math.max(max,i);
      }
      return max ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     for _forEach : read()->collect( _x1 | (lambda data : OclAny in data.getRequiredNumber())->apply(_x1) ) do
    (    skip ;) );
  static   operation read() : Sequence(DataSet)
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dataList : Sequence(DataSet) ; dataList := Sequence{} ;
    while (true) do (     var length : int ; length := scanner.getCurrent()->toInteger() ;
     if (length = 0) then (     break ) else (     var dataSet : DataSet ; dataSet := DataSet.newDataSet() ;
         var i : int ; i := 0 ; while i < length do ( (     dataSet->excludes(parse(scanner.getCurrent()), parse(scanner.getCurrent())) )  ;     i := i + 1 ) ; 
     dataList := dataList->including(dataSet) ) ) ; 
    skip ; 
    return dataList 
 );
  static   operation parse( str : String) : int
  pre: true
  post: true
  activity: (     return (str.replaceAllMatches(":", "" ))->toInteger() );
  static class DataSet {
   attribute timeline : Map(int,int) := Map{};
   operation add( departure : int, arrival : int) : void
  pre: true
  post: true
  activity: (     timeline := timeline.merge(departure, 1, lambda (a , b) : OclAny in a + b) ; 
     timeline := timeline.merge(arrival, -1, lambda (a , b) : OclAny in a + b) );
   operation getRequiredNumber() : int
  pre: true
  post: true
  activity: (     var timestamps : Sequence(int) ; timestamps := timeline->keys()->sort().collect(Collectors.toList()) ;
     var i : int ; i := 0 ;
    var max : int ; max := 0 ;
     for (timestamp : timestamps) do ( (     i := i + timeline->at(timestamp) ; 
     max := Set{max, i}->max() )  ) ; 
     return max );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      int n=Integer.parseInt(br.readLine());
      if(n==0){
        break ;
      }
      TrainEvent[] events=new TrainEvent[2*n];
      for(int i=0 ; i<events.length ; i+=2){
        String[] tmpArray=br.readLine().split(" ");
        events[i]=new TrainEvent(tmpArray[0],TrainEvent.DEPART);
        events[i+1]=new TrainEvent(tmpArray[1],TrainEvent.ARRIVE);
      }
      System.out.println(solve(events));
    }
  }
  static int solve(TrainEvent[] events){
    int result=0 ;
    Arrays.sort(events);
    int running=0 ;
    for(int i=0 ; i<events.length ; i++){
      if(events[i] .type==TrainEvent.DEPART){
        running++;
        result=Math.max(running,result);
      }
      else {
        running--;
      }
    }
    return result ;
  }
}
class TrainEvent implements Comparable<TrainEvent>{
  String time ;
  int type ;
  static final int DEPART=1 ;
  static final int ARRIVE=0 ;
  public TrainEvent(String time,int type){
    this.time=time ;
    this.type=type ;
  }
  @ Override public int compareTo(TrainEvent event){
    return time.equals(event.time)? this.type-event.type : time.compareTo(event.time);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var n : int ; n := (br.readLine())->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var events : Sequence(TrainEvent) ; events := Integer.subrange(1,2 * n)->collect(null) ;
        var i : int ; i := 0 ; while i < events->size() do ( (     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
     events[i+1] := TrainEvent.newTrainEvent(tmpArray[0+1], TrainEvent.DEPART) ; 
     events[i + 1+1] := TrainEvent.newTrainEvent(tmpArray[1+1], TrainEvent.ARRIVE) )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(solve(events)) ; 
 ) );
  static   operation solve( events : Sequence(TrainEvent)) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     events := events->sort() ; 
    var running : int ; running := 0 ;
        var i : int ; i := 0 ; while i < events->size() do ( (     if (events[i+1].type = TrainEvent.DEPART) then (     running := running + 1 ; 
     result := Set{running, result}->max() ) else (     running := running - 1 ) )  ;     i := i + 1 ) ; 
    return result 
 );
}
class TrainEvent implements Comparable<TrainEvent> {
   attribute time : String;
   attribute type : int;
  static    attribute DEPART : int := 1;
  static    attribute ARRIVE : int := 0;
   static operation newTrainEvent( time : String, type : int) : TrainEvent
  pre: true
  post: true
  activity:
  ( var self : TrainEvent ;
    self := createTrainEvent();
    self.initialise(time, type);
    return self );
  operation initialise( time : String, type : int) : void
  pre: true  post: true
  activity: (     self.time := time ; 
     self.type := type );
      operation compareTo( event : TrainEvent) : int
  pre: true
  post: true
  activity: (     return if time = event.time then self.type - event.type else time->compareTo(event.time) endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String sumBaseB(String a,String b,int base){
    int len_a,len_b ;
    len_a=a.length();
    len_b=b.length();
    String sum,s ;
    s="" ;
    sum="" ;
    int diff ;
    diff=Math.abs(len_a-len_b);
    for(int i=1 ; i<=diff ; i++)s+="0" ;
    if(len_a<len_b)a=s+a ;
    else b=s+b ;
    int curr,carry=0 ;
    for(int i=Math.max(len_a,len_b)-1 ; i>-1 ; i--){
      curr=carry+(a.charAt(i)-'0')+(b.charAt(i)-'0');
      carry=curr/base ;
      curr=curr % base ;
      sum=(char)(curr+'0')+sum ;
    }
    if(carry>0)sum=(char)(carry+'0')+sum ;
    return sum ;
  }
  public static void main(String[] args){
    String a,b,sum ;
    int base ;
    a="123" ;
    b="234" ;
    base=6 ;
    sum=sumBaseB(a,b,base);
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumBaseB( a : String, b : String, base : int) : String
  pre: true
  post: true
  activity: (     var len_a : int ;
    var len_b : int ;
     len_a := a->size() ; 
    len_b := b->size() ; 
    var sum : String ;
    var s : String ;
    s := "" ; 
    sum := "" ; 
    var diff : int ;
    diff := if len_a - len_b < 0 then -(len_a - len_b) else len_a - len_b endif ; 
        var i : int ; i := 1 ; while i <= diff do (     s := s+("0") ;  ;     i := i + 1 ) ; 
    if (len_a < len_b) then     a := s + a else     b := s + b ; ;  
    var curr : int ;
    var carry : int ; carry := 0 ;
        var i : int ; i := Set{len_a, len_b}->max() - 1 ; while i > -1 do ( (     curr := carry + (a->at(i+1) - ('0')->char2byte()) + (b->at(i+1) - ('0')->char2byte()) ; 
     carry := curr / base ; 
     curr := curr mod base ; 
     sum := (curr + '0')->oclAsType(String) + sum )  ;     i := i - 1 ) ; 
    if (carry > 0) then     sum := (carry + '0')->oclAsType(String) + sum ; else skip ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ;
    var b : String ;
    var sum : String ;
     var base : int ;
    a := "123" ; 
    b := "234" ; 
    base := 6 ; 
    sum := sumBaseB(a, b, base) ; 
    OclFile["System.out"].println(sum) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String canMake(String s){
    int o=0,z=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)-'0'==1)o++;
      else z++;
    }
    if(o % 2==1 && z % 2==1)return "NO" ;
    else return "YES" ;
  }
  public static void main(String[] args){
    String s="01011" ;
    System.out.println(canMake(s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation canMake( s : String) : String
  pre: true
  post: true
  activity: (     var o : int ; o := 0 ;
    var z : int ; z := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) - ('0')->char2byte() = 1) then     o := o + 1 ; else     z := z + 1 ; )  ;     i := i + 1 ) ; 
     if (o mod 2 = 1 & z mod 2 = 1) then     return "NO" else     return "YES" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "01011" ;
     OclFile["System.out"].println(canMake(s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int K=sc.nextInt();
    int ans=0 ;
    for(int a=0 ; a<K ; a++){
      for(int b=0 ; b<K ; b++){
        for(int c=0 ; c<K ; c++){
          ans=ans+mgcd(a+1,b+1,c+1);
        }
      }
    }
    System.out.println(ans);
  }
  public static final int mgcd(int a,int b,int c){
    int g=gcd(a,b);
    g=gcd(g,c);
    return g ;
  }
  public static final int gcd(int a,int b){
    if(a<b){
      int tmp=a ;
      a=b ;
      b=tmp ;
    }
    int r=-1 ;
    while(r!=0){
      r=a % b ;
      a=b ;
      b=r ;
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var a : int ; a := 0 ; while a < K do ( (         var b : int ; b := 0 ; while b < K do ( (         var c : int ; c := 0 ; while c < K do ( (     ans := ans + mgcd(a + 1, b + 1, c + 1) )  ;     c := c + 1 ) )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static    operation mgcd( a : int, b : int, c : int) : int
  pre: true
  post: true
  activity: (     var g : int ; g := gcd(a, b) ;
     g := gcd(g, c) ; 
     return g );
  static    operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a < b) then (     var tmp : int ; tmp := a ;
     a := b ; 
     b := tmp ) else skip ; 
     var r : int ; r := -1 ;
     while (r /= 0) do (     r := a mod b ; 
     a := b ; 
     b := r ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class6 {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char ch[]=new char[n];
    int s1=0,s2=0 ;
    int i,j=0,flag=0,dif=0 ;
    for(i=0 ; i<n ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      int temp1=s1+x ;
      int temp2=s2+y ;
      if(Math.abs(temp1-s2)<=500){
        s1+=x ;
        ch[j++]='A' ;
        continue ;
      }
      if(Math.abs(temp2-s1)<=500){
        s2+=y ;
        ch[j++]='G' ;
        continue ;
      }
      flag=1 ;
      break ;
    }
    if(flag==1)System.out.println(-1);
    else {
      String ans="" ;
      ans=ans.valueOf(ch);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class6 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ch : Sequence(String) ; ch := Integer.subrange(1,n)->collect(0) ;
    var s1 : int ; s1 := 0 ;
    var s2 : int ; s2 := 0 ;
    var i : int ;
    var j : int ; j := 0 ;
    var flag : int ; flag := 0 ;
    var dif : int ; dif := 0 ;
        i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var temp1 : int ; temp1 := s1 + x ;
    var temp2 : int ; temp2 := s2 + y ;
    if (if temp1 - (s2)->char2byte() < 0 then -(temp1 - (s2)->char2byte()) else temp1 - (s2)->char2byte() endif <= 500) then (     s1 := s1+(x) ; 
      ch[j+1] := 'A'  ; j := j + 1 ; 
     continue ) else skip ; 
    if (if temp2 - (s1)->char2byte() < 0 then -(temp2 - (s1)->char2byte()) else temp2 - (s1)->char2byte() endif <= 500) then (     s2 := s2+(y) ; 
      ch[j+1] := 'G'  ; j := j + 1 ; 
     continue ) else skip ; 
    flag := 1 ; 
    break 
 )  ;     i := i + 1 ) ; 
    if (flag = 1) then     OclFile["System.out"].println(-1) else (     var ans : String ; ans := "" ;
     ans := ans.valueOf(ch) ; 
     OclFile["System.out"].println(ans) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public int countWays(int n,int x){
    int count=0 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<i ; j++){
        for(int k=1 ; k<j ; k++){
          if(i+j+k==x){
            count++;
          }
        }
      }
    }
    return count ;
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    Main app=new Main();
    while(true){
      int inN,inX ;
      int count ;
      inN=Integer.parseInt(scan.next());
      inX=Integer.parseInt(scan.next());
      if(inN==0 && inX==0)break ;
      count=app.countWays(inN,inX);
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation countWays( n : int, x : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j < i do ( (         var k : int ; k := 1 ; while k < j do ( (     if (i + j + k = x) then (     count := count + 1 ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var app : Main ; app := Main.newMain() ;
     while (true) do (     var inN : int ;
    var inX : int ;
     var count : int ;
    inN := (scan.getCurrent())->toInteger() ; 
    inX := (scan.getCurrent())->toInteger() ; 
    if (inN = 0 & inX = 0) then     break else skip ; 
    count := app.countWays(inN, inX) ; 
    OclFile["System.out"].println(count) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int k=obj.nextInt();
    long sum=0 ;
    for(int i=1 ; i<=k ; i++){
      for(int j=1 ; j<=k ; j++){
        for(int u=1 ; u<=k ; u++)sum+=gcd(i,gcd(j,u));
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var k : int ; k := obj.nextInt() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 1 ; while i <= k do ( (         var j : int ; j := 1 ; while j <= k do ( (         var u : int ; u := 1 ; while u <= k do (     sum := sum+(gcd(i, gcd(j, u))) ;  ;     u := u + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int a1[]={
    0,-1,0,1 };
    static int b1[]={
-1,0,1,0 };
      private static Scanner sc=new Scanner(System.in);
      private static Scanner s=new Scanner(System.in);
      static void p(String ans){
        System.out.println(ans);
      };
      static void p(int ans){
        System.out.println(ans);
      };
      static void p(long ans){
        System.out.println(ans);
      };
      static void p(double ans){
        System.out.println(ans);
      };
      public static void main(String[] args){
        int K=s.nextInt();
        long ans=0 ;
        for(int a=1 ; a<=K ; a++){
          for(int b=1 ; b<=K ; b++){
            for(int c=1 ; c<=K ; c++){
              ans+=gcd(a,gcd(b,c));
            }
          }
        }
        p(ans);
      }
      public static int gcd(int num1,int num2){
        if(num2==0)return num1 ;
        else return gcd(num2,num1 % num2);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a1 : int := Sequence{0,-1,0,1};
  static   attribute b1 : int := Sequence{-1,0,1,0};
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation p( ans : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : long) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : double) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var K : int ; K := s.getCurrent()->toInteger() ;
     var ans : long ; ans := 0 ;
         var a : int ; a := 1 ; while a <= K do ( (         var b : int ; b := 1 ; while b <= K do ( (         var c : int ; c := 1 ; while c <= K do ( (     ans := ans+(gcd(a, gcd(b, c))) )  ;     c := c + 1 ) )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
     execute p(ans) );
  static   operation gcd( num1 : int, num2 : int) : int
  pre: true
  post: true
  activity: (     if (num2 = 0) then     return num1 else     return gcd(num2, num1 mod num2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Map ;
import java.util.StringTokenizer ;
public class Main {
  private static PrintWriter out ;
  public static void main(String[] args){
    Main main=new Main();
    Runtime.getRuntime().addShutdownHook(new Thread(()->out.close()));
    try {
      main.run(args);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  private void run(String[] arguments)throws Exception {
    MyScanner sc=new MyScanner();
    out=new PrintWriter(new BufferedOutputStream(System.out));
    int K=sc.nextInt();
    int ans=0 ;
    for(int i=1 ; i<=K ; i++){
      for(int j=1 ; j<=K ; j++){
        for(int k=1 ; k<=K ; k++){
          int ij=dpf(i,j);
          int ijk=dpf(ij,k);
          ans+=ijk ;
        }
      }
    }
    out.println(ans);
    out.close();
  }
  int dpf(int i,int j){
    if(j>i){
      int k=i ;
      i=j ;
      j=k ;
    }
    int rest=i % j ;
    if(rest==0){
      return j ;
    }
    return dpf(j,rest);
  }
  private class MyScanner {
    BufferedReader br ;
    StringTokenizer st ;
    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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     Runtime.getRuntime().addShutdownHook(OclProcess.newOclProcess((lambdaParameters ( )) out.closeFile())) ; 
     try (     main.run(args) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
   operation run( arguments : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var K : int ; K := sc.nextInt() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= K do ( (         var j : int ; j := 1 ; while j <= K do ( (         var k : int ; k := 1 ; while k <= K do ( (     var ij : int ; ij := dpf(i, j) ;
     var ijk : int ; ijk := dpf(ij, k) ;
     ans := ans+(ijk) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
   operation dpf( i : int, j : int) : int
  pre: true
  post: true
  activity: (     if (j > i) then (     var k : int ; k := i ;
     i := j ; 
     j := k ) else skip ; 
     var rest : int ; rest := i mod j ;
     if (rest = 0) then (     return j ) else skip ; 
     return dpf(j, rest) );
 class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    SumofgcdofTuples solver=new SumofgcdofTuples();
    solver.solve(1,in,out);
    out.close();
  }
  static class SumofgcdofTuples {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int k=in.nextInt();
      long result=0 ;
      for(int i=1 ; i<=k ; i++){
        for(int j=1 ; j<=k ; j++){
          for(int l=1 ; l<=k ; l++){
            result+=gcd(gcd(i,j),l);
          }
        }
      }
      out.append(String.valueOf(result));
    }
    static long gcd(long a,long b){
      return b==0 ? a : gcd(b,a % b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : SumofgcdofTuples ; solver := SumofgcdofTuples.newSumofgcdofTuples() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class SumofgcdofTuples {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var k : int ; k := in.getCurrent()->toInteger() ;
     var result : long ; result := 0 ;
         var i : int ; i := 1 ; while i <= k do ( (         var j : int ; j := 1 ; while j <= k do ( (         var l : int ; l := 1 ; while l <= k do ( (     result := result+(gcd(gcd(i, j), l)) )  ;     l := l + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     skip );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int calNum(int year){
    return(year/4)-(year/100)+(year/400);
  }
  static void leapNum(int l,int r){
    l--;
    int num1=calNum(r);
    int num2=calNum(l);
    System.out.print(num1-num2+"\n");
  }
  public static void main(String[] args){
    int l1=1,r1=400 ;
    leapNum(l1,r1);
    int l2=400,r2=2000 ;
    leapNum(l2,r2);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation calNum( year : int) : int
  pre: true
  post: true
  activity: (     return (year / 4) - (year / 100) + (year / 400) );
  static   operation leapNum( l : int, r : int) : void
  pre: true
  post: true
  activity: (     l := l - 1 ; 
     var num1 : int ; num1 := calNum(r) ;
     var num2 : int ; num2 := calNum(l) ;
     OclFile["System.out"].print(num1 - num2 + "\n") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l1 : int ; l1 := 1 ;
    var r1 : int ; r1 := 400 ;
     execute leapNum(l1, r1) ; 
     var l2 : int ; l2 := 400 ;
    var r2 : int ; r2 := 2000 ;
     execute leapNum(l2, r2) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static long y=1 ;
  static long l=1 ;
  static Scanner cs=new Scanner(System.in);
  public static void main(String args[]){
    while(true){
      int n=cs.nextInt();
      if(n==0)break ;
      long x=cs.nextLong();
      y=cs.nextLong();
      l=1 ;
      for(int i=0 ; i<n ; i++){
        l=l*2 ;
      }
      x=l-x+1 ;
      System.out.println(solve(l,x));
    }
  }
  static String solve(long h,long x){
    String res="" ;
    if(h==1)return("");
    if(x<=h/2){
      res=solve(h/2,x);
      if(y<=l/2){
        res=res+"R" ;
        l=l/2 ;
      }
      else {
        res=res+"L" ;
        y=y-l/2 ;
        l=l/2 ;
      }
    }
    else {
      res=solve(h/2,h-x+1);
      if(y<=l/2){
        res=res+"L" ;
        y=l/2-y+1 ;
        l=l/2 ;
      }
      else {
        res=res+"R" ;
        y=l-y+1 ;
        l=l/2 ;
      }
    }
    return(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute y : long := 1;
  static   attribute l : long := 1;
  static   attribute cs : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := cs.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var x : long ; x := cs.getCurrent()->toLong() ;
    y := cs.getCurrent()->toLong() ; 
    l := 1 ; 
        var i : int ; i := 0 ; while i < n do ( (     l := l * 2 )  ;     i := i + 1 ) ; 
    x := l - x + 1 ; 
    OclFile["System.out"].println(solve(l, x)) ; 
 ) );
  static   operation solve( h : long, x : long) : String
  pre: true
  post: true
  activity: (     var res : String ; res := "" ;
     if (h = 1) then     return ("") else skip ; 
     if (x <= h / 2) then (     res := solve(h / 2, x) ; 
     if (y <= l / 2) then (     res := res + "R" ; 
     l := l / 2 ) else (     res := res + "L" ; 
     y := y - l / 2 ; 
     l := l / 2 ) ) else (     res := solve(h / 2, h - x + 1) ; 
     if (y <= l / 2) then (     res := res + "L" ; 
     y := l / 2 - y + 1 ; 
     l := l / 2 ) else (     res := res + "R" ; 
     y := l - y + 1 ; 
     l := l / 2 ) ) ;  
     return (res) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void printExpansion(String str){
    for(int i=str.length()-1 ; i>=0 ; i--){
      String subStr=str.substring(i);
      System.out.print(subStr);
    }
  }
  public static void main(String args[]){
    String str="geeks" ;
    printExpansion(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printExpansion( str : String) : void
  pre: true
  post: true
  activity: (         var i : int ; i := str->size() - 1 ; while i >= 0 do ( (     var subStr : String ; subStr := str.subrange(i+1,i) ;
     OclFile["System.out"].print(subStr) )  ;     i := i - 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeks" ;
     execute printExpansion(str) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  static Scanner scan=new Scanner(System.in);
  public static void main(String args[]){
    int n=scan.nextInt();
    if(n<9){
      System.out.println(1);
    }
    else {
      int firstDigit=Integer.parseInt((n+"").charAt(0)+"")+1 ;
      String bigNumber=firstDigit+"" ;
      for(int i=0 ; i<(n+"").length()-1 ; i++){
        bigNumber+="0" ;
      }
      System.out.println(Integer.parseInt(bigNumber)-n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scan.getCurrent()->toInteger() ;
     if (n < 9) then (     OclFile["System.out"].println(1) ) else (     var firstDigit : int ; firstDigit := ((n + "")->at(0+1) + "")->toInteger() + 1 ;
     var bigNumber : String ; bigNumber := firstDigit + "" ;
         var i : int ; i := 0 ; while i < (n + "")->size() - 1 do ( (     bigNumber := bigNumber+("0") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println((bigNumber)->toInteger() - n) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    StringBuilder ss=new StringBuilder();
    if(s.length()==1){
      System.out.println("1");
    }
    else {
      if(s.charAt(0)!='9'){
        char ch=(char)((int)s.charAt(0)+1);
        ss.append(ch);
      }
      else ss.append("10");
      for(int i=1 ; i<s.length(); i++)ss.append('0');
      BigInteger x=new BigInteger(s);
      BigInteger y=new BigInteger(ss.toString());
      System.out.println(y.subtract(x));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
     var ss : String ; ss := StringLib.newString() ;
     if (s->size() = 1) then (     OclFile["System.out"].println("1") ) else (     if (s->at(0+1) /= '9') then (     var ch : String ; ch := (s->at(0+1)->oclAsType(int) + 1)->oclAsType(String) ;
     ss := ss + StringLib.newString(ch) ) else     ss := ss + StringLib.newString("10") ; ;  
         var i : int ; i := 1 ; while i < s->size() do (     ss := ss + StringLib.newString('0') ;  ;     i := i + 1 ) ; 
    var x : long ; x := long(s) ;
    var y : long ; y := long(ss+"") ;
    OclFile["System.out"].println(y.subtract(x)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class FindNth {
  static int printNthElement(int n){
    int arr[]=new int[n+1];
    arr[1]=1 ;
    arr[2]=2 ;
    for(int i=3 ; i<=n ; i++){
      if(i % 2!=0)arr[i]=arr[i/2]*10+1 ;
      else arr[i]=arr[(i/2)-1]*10+2 ;
    }
    return arr[n];
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(printNthElement(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class FindNth {
  static   operation printNthElement( n : int) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
     arr[1+1] := 1 ; 
    arr[2+1] := 2 ; 
        var i : int ; i := 3 ; while i <= n do ( (     if (i mod 2 /= 0) then     arr[i+1] := arr[i / 2+1] * 10 + 1 ; else     arr[i+1] := arr[(i / 2) - 1+1] * 10 + 2 ; )  ;     i := i + 1 ) ; 
    return arr[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(printNthElement(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    while(sc.hasNext()){
      int n=sc.nextInt();
      int x=sc.nextInt();
      if(n==0){
        break ;
      }
      int num=0 ;
      for(int i=1 ; i<=n ; i++){
        for(int j=i+1 ; j<=n ; j++){
          for(int k=j+1 ; k<=n ; k++){
            if(i!=j && j!=k && i!=k){
              if(i+j+k==x){
                num++;
              }
            }
          }
        }
      }
      out.println(num);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    if (n = 0) then (     break ) else skip ; 
    var num : int ; num := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i + 1 ; while j <= n do ( (         var k : int ; k := j + 1 ; while k <= n do ( (     if (i /= j & j /= k & i /= k) then (     if (i + j + k = x) then (     num := num + 1 ) else skip ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    out.println(num) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder();
    int n=fs.nextInt();
    long a=1 ;
    while(a<=n){
      a*=10 ;
    }
    a/=10 ;
    long b=a ;
    while(b<=n){
      b+=a ;
    }
    out.print(b-n);
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := fs.nextInt() ;
    var a : long ; a := 1 ;
    while (a <= n) do (     a := a*(10) ) ; 
    a := a/(10) ; 
    var b : long ; b := a ;
    while (b <= n) do (     b := b+(a) ) ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class x {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    StringBuilder ss=new StringBuilder();
    if(s.length()==1){
      System.out.println("1");
    }
    else {
      if(s.charAt(0)!='9'){
        char ch=(char)((int)s.charAt(0)+1);
        ss.append(ch);
      }
      else ss.append("10");
      for(int i=1 ; i<s.length(); i++)ss.append('0');
      BigInteger x=new BigInteger(s);
      BigInteger y=new BigInteger(ss.toString());
      System.out.println(y.subtract(x));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class x {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
     var ss : String ; ss := StringLib.newString() ;
     if (s->size() = 1) then (     OclFile["System.out"].println("1") ) else (     if (s->at(0+1) /= '9') then (     var ch : String ; ch := (s->at(0+1)->oclAsType(int) + 1)->oclAsType(String) ;
     ss := ss + StringLib.newString(ch) ) else     ss := ss + StringLib.newString("10") ; ;  
         var i : int ; i := 1 ; while i < s->size() do (     ss := ss + StringLib.newString('0') ;  ;     i := i + 1 ) ; 
    var x : long ; x := long(s) ;
    var y : long ; y := long(ss+"") ;
    OclFile["System.out"].println(y.subtract(x)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int r=sc.nextInt();
    int g=sc.nextInt();
    int b=sc.nextInt();
    int add=100*r+10*g+b ;
    if(add % 4==0){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var g : int ; g := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var add : int ; add := 100 * r + 10 * g + b ;
    if (add mod 4 = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.math.BigDecimal ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner scan=new Scanner(System.in);
    int r=scan.nextInt();
    int g=scan.nextInt();
    int b=scan.nextInt();
    int sum=r*100+g*10+b ;
    if(sum % 4==0){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
  public static String myReverse(String pStr){
    if(pStr.length()<1){
      return "" ;
    }
    StringBuffer sb=new StringBuffer(pStr);
    return sb.reverse().toString();
  }
  public static long myMod(long a,long b){
    long ret=0 ;
    ret=a % b ;
    if(ret<0){
      ret+=b ;
    }
    return ret ;
  }
  public static long myPowWithMod(long kisu,long josu,long primeNumMod_0){
    long ans=1 ;
    if(josu==0)return 1 ;
    if(primeNumMod_0==0){
      while(josu>0){
        if(josu % 2==0){
          kisu*=kisu ;
          josu=josu/2 ;
        }
        else {
          ans*=kisu ;
          josu--;
        }
      }
      return ans ;
    }
    else {
      kisu=myMod(kisu,primeNumMod_0);
      while(josu>0){
        if(josu % 2==0){
          kisu*=myMod(kisu,primeNumMod_0);
          josu=josu/2 ;
        }
        else {
          ans*=myMod(kisu,primeNumMod_0);
          josu--;
        }
      }
      return myMod(ans,primeNumMod_0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := scan.getCurrent()->toInteger() ;
    var g : int ; g := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    var sum : int ; sum := r * 100 + g * 10 + b ;
    if (sum mod 4 = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
  static   operation myReverse( pStr : String) : String
  pre: true
  post: true
  activity: (     if (pStr->size() < 1) then (     return "" ) else skip ; 
     var sb : String ; sb := StringLib.newString(pStr) ;
     return sb->reverse()+"" );
  static   operation myMod( a : long, b : long) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := 0 ;
     ret := a mod b ; 
     if (ret < 0) then (     ret := ret+(b) ) else skip ; 
     return ret );
  static   operation myPowWithMod( kisu : long, josu : long, primeNumMod_0 : long) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 1 ;
     if (josu = 0) then     return 1 else skip ; 
     if (primeNumMod_0 = 0) then (     while (josu > 0) do (     if (josu mod 2 = 0) then (     kisu := kisu*(kisu) ; 
     josu := josu / 2 ) else (     ans := ans*(kisu) ; 
     josu := josu - 1 ) ) ; 
     return ans ) else (     kisu := myMod(kisu, primeNumMod_0) ; 
     while (josu > 0) do (     if (josu mod 2 = 0) then (     kisu := kisu*(myMod(kisu, primeNumMod_0)) ; 
     josu := josu / 2 ) else (     ans := ans*(myMod(kisu, primeNumMod_0)) ; 
     josu := josu - 1 ) ) ; 
     return myMod(ans, primeNumMod_0) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int r=sc.nextInt()*100 ;
    int g=sc.nextInt()*10 ;
    int b=sc.nextInt();
    if((r+g+b)% 4==0){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var r : int ; r := sc.nextInt() * 100 ;
    var g : int ; g := sc.nextInt() * 10 ;
    var b : int ; b := sc.nextInt() ;
    if ((r + g + b) mod 4 = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.System.in ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    String[] inputs=reader.readLine().split(" ");
    int num=Integer.parseInt(inputs[0]+inputs[1]+inputs[2]);
    if(num % 4==0){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     var inputs : Sequence(String) ; inputs := reader.readLine()->split(" ") ;
     var num : int ; num := (inputs[0+1] + inputs[1+1] + inputs[2+1])->toInteger() ;
     if (num mod 4 = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in);
){
      System.out.println((sc.nextInt()*100+sc.nextInt()*10+sc.nextInt())% 4==0 ? "YES" : "NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     OclFile["System.out"].println(if (sc.getCurrent()->toInteger() * 100 + sc.getCurrent()->toInteger() * 10 + sc.getCurrent()->toInteger()) mod 4 = 0 then "YES" else "NO" endif) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void shuffle(int N,int key){
    int NO_OF_BITS=N ;
    int reverse_num=0,temp ;
    for(int i=0 ; i<NO_OF_BITS ; i++){
      temp=(key &(1<<i));
      if(temp>0)reverse_num |=(1<<((NO_OF_BITS-1)-i));
    }
    System.out.print(reverse_num);
  }
  public static void main(String[] args){
    int N=3 ;
    int key=3 ;
    shuffle(N,key);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation shuffle( N : int, key : int) : void
  pre: true
  post: true
  activity: (     var NO_OF_BITS : int ; NO_OF_BITS := N ;
     var reverse_num : int ; reverse_num := 0 ;
    var temp : int ;
         var i : int ; i := 0 ; while i < NO_OF_BITS do ( (     temp := (key & ((1*(2->pow(i)))->oclAsType(long))) ; 
     if (temp > 0) then     reverse_num := MathLib.bitwiseOr(reverse_num, ((1*(2->pow(((NO_OF_BITS - 1) - i))))->oclAsType(long))) ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(reverse_num) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
     var key : int ; key := 3 ;
     execute shuffle(N, key) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void recaman(int n){
    if(n<=0)return ;
    System.out.printf("%d,",0);
    HashSet<Integer>s=new HashSet<Integer>();
    s.add(0);
    int prev=0 ;
    for(int i=1 ; i<n ; i++){
      int curr=prev-i ;
      if(curr<0 || s.contains(curr))curr=prev+i ;
      s.add(curr);
      System.out.printf("%d,",curr);
      prev=curr ;
    }
  }
  public static void main(String[] args){
    int n=17 ;
    recaman(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation recaman( n : int) : void
  pre: true
  post: true
  activity: (     if (n <= 0) then     return else skip ; 
     OclFile["System.out"].printf("%d,", 0) ; 
    var s : Set(int) ; s := Set{} ;
    s := s->including(0) ; 
    var prev : int ; prev := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     var curr : int ; curr := prev - i ;
     if (curr < 0 or s->includes(curr)) then     curr := prev + i ; else skip ; 
    s := s->including(curr) ; 
    OclFile["System.out"].printf("%d,", curr) ; 
    prev := curr ; 
 )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 17 ;
     execute recaman(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javafx.util.Pair ;
class GFG {
  static Pair<Double,Double>findFoot(double a,double b,double c,double x1,double y1){
    double temp=-1*(a*x1+b*y1+c)/(a*a+b*b);
    double x=temp*a+x1 ;
    double y=temp*b+y1 ;
    return new Pair(x,y);
  }
  public static void main(String[] args){
    double a=0.0 ;
    double b=1.0 ;
    double c=-2 ;
    double x1=3.0 ;
    double y1=3.0 ;
    Pair<Double,Double>foot=findFoot(a,b,c,x1,y1);
    System.out.println(foot.getKey()+" "+foot.getValue());
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findFoot( a : double, b : double, c : double, x1 : double, y1 : double) : Map(String,OclAny)
  pre: true
  post: true
  activity: (     var temp : double ; temp := -1 * (a * x1 + b * y1 + c) / (a * a + b * b) ;
     var x : double ; x := temp * a + x1 ;
     var y : double ; y := temp * b + y1 ;
     return Map(x, y) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 0.0 ;
     var b : double ; b := 1.0 ;
    var c : double ; c := -2 ;
    var x1 : double ; x1 := 3.0 ;
    var y1 : double ; y1 := 3.0 ;
    var foot : Map(String,OclAny) ; foot := findFoot(a, b, c, x1, y1) ;
    OclFile["System.out"].println(foot->keys()->any() + " " + foot->values->any()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=100 ;
  static int recur(int ind,int cnt,int last,int a[],int n,int k,int dp[][]){
    if(cnt==k)return 0 ;
    if(ind==n)return(int)-1e9 ;
    if(dp[ind][cnt]!=-1)return dp[ind][cnt];
    int ans=0 ;
    for(int i=ind ; i<n ; i++){
      if(cnt % 2==0)ans=Math.max(ans,recur(i+1,cnt+1,i,a,n,k,dp));
      else ans=Math.max(ans,__gcd(a[last],a[i])+recur(i+1,cnt+1,0,a,n,k,dp));
    }
    return dp[ind][cnt]=ans ;
  }
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  public static void main(String[] args){
    int a[]={
      4,5,3,7,8,10,9,8 };
      int n=a.length ;
      int k=4 ;
      int[][] dp=new int[n][MAX];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<MAX ; j++){
          dp[i][j]=-1 ;
        }
      }
      System.out.println(recur(0,0,0,a,n,k,dp));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100;
  static   operation recur( ind : int, cnt : int, last : int, a : Sequence(int), n : int, k : int, dp : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     if (cnt = k) then     return 0 else skip ; 
     if (ind = n) then     return -1e9->oclAsType(int) else skip ; 
    if (dp[ind+1][cnt+1] /= -1) then     return dp[ind+1][cnt+1] else skip ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := ind ; while i < n do ( (     if (cnt mod 2 = 0) then     ans := Set{ans, recur(i + 1, cnt + 1, i, a, n, k, dp)}->max() ; else     ans := Set{ans, __gcd(a[last+1], a[i+1]) + recur(i + 1, cnt + 1, 0, a, n, k, dp)}->max() ; )  ;     i := i + 1 ) ; 
    return dp[ind+1][cnt+1] 
 );
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{4,5,3,7,8,10,9,8} ;
     var n : int ; n := a->size() ;
    var k : int ; k := 4 ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,MAX)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < MAX do ( (     dp[i+1][j+1] := -1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(recur(0, 0, 0, a, n, k, dp)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class FindNth {
  static int printNthElement(int n){
    int arr[]=new int[n+1];
    arr[1]=4 ;
    arr[2]=7 ;
    for(int i=3 ; i<=n ; i++){
      if(i % 2!=0)arr[i]=arr[i/2]*10+4 ;
      else arr[i]=arr[(i/2)-1]*10+7 ;
    }
    return arr[n];
  }
  public static void main(String[] args){
    int n=6 ;
    System.out.println(printNthElement(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class FindNth {
  static   operation printNthElement( n : int) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
     arr[1+1] := 4 ; 
    arr[2+1] := 7 ; 
        var i : int ; i := 3 ; while i <= n do ( (     if (i mod 2 /= 0) then     arr[i+1] := arr[i / 2+1] * 10 + 4 ; else     arr[i+1] := arr[(i / 2) - 1+1] * 10 + 7 ; )  ;     i := i + 1 ) ; 
    return arr[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(printNthElement(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int count(int n){
    int table[]=new int[n+1],i ;
    Arrays.fill(table,0);
    table[0]=1 ;
    for(i=3 ; i<=n ; i++)table[i]+=table[i-3];
    for(i=5 ; i<=n ; i++)table[i]+=table[i-5];
    for(i=10 ; i<=n ; i++)table[i]+=table[i-10];
    return table[n];
  }
  public static void main(String[] args){
    int n=20 ;
    System.out.println("Count for "+n+" is "+count(n));
    n=13 ;
    System.out.println("Count for "+n+" is "+count(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count( n : int) : int
  pre: true
  post: true
  activity: (     var table : Sequence(int) ; table := Integer.subrange(1,n + 1)->collect(0) ;
    var i : int ;
     table := table->collect(0) ; 
    table[0+1] := 1 ; 
        i := 3 ; while i <= n do (     table[i+1] := table[i+1]+(table[i - 3+1]) ;  ;     i := i + 1 ) ; 
        i := 5 ; while i <= n do (     table[i+1] := table[i+1]+(table[i - 5+1]) ;  ;     i := i + 1 ) ; 
        i := 10 ; while i <= n do (     table[i+1] := table[i+1]+(table[i - 10+1]) ;  ;     i := i + 1 ) ; 
    return table[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 20 ;
     OclFile["System.out"].println("Count for " + n + " is " + count(n)) ; 
     n := 13 ; 
     OclFile["System.out"].println("Count for " + n + " is " + count(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void moveZerosToEnd(int arr[],int n){
    int count=0 ;
    int temp ;
    for(int i=0 ; i<n ; i++){
      if((arr[i]!=0)){
        temp=arr[count];
        arr[count]=arr[i];
        arr[i]=temp ;
        count=count+1 ;
      }
    }
  }
  static void printArray(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String args[]){
    int arr[]={
      0,1,9,8,4,0,0,2,7,0,6,0,9 };
      int n=arr.length ;
      System.out.print("Original array: ");
      printArray(arr,n);
      moveZerosToEnd(arr,n);
      System.out.print("\nModified array: ");
      printArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation moveZerosToEnd( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var temp : int ;
         var i : int ; i := 0 ; while i < n do ( (     if ((arr[i+1] /= 0)) then (     temp := arr[count+1] ; 
     arr[count+1] := arr[i+1] ; 
     arr[i+1] := temp ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) );
  static   operation printArray( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,1,9,8,4,0,0,2,7,0,6,0,9} ;
     var n : int ; n := arr->size() ;
    OclFile["System.out"].print("Original array: ") ; 
    execute printArray(arr, n) ; 
    execute moveZerosToEnd(arr, n) ; 
    OclFile["System.out"].print("\nModified array: ") ; 
    execute printArray(arr, n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Numbers {
  public static void main(String[] args){
    try(java.util.Scanner sc=new java.util.Scanner(System.in)){
      int A=sc.nextInt();
      int sum=0 ;
      int yy=A-2 ;
      for(int i=2 ; i<A ; i++){
        int n=A ;
        int m=0 ;
        while(n!=0){
          m+=n % i ;
          n/=i ;
        }
        sum+=m ;
      }
      int gcd=getGCD(sum,yy);
      sum/=gcd ;
      yy/=gcd ;
      System.out.println(String.format("%s/%s",sum,yy));
    }
  }
  private static int getGCD(int m,int n){
    int r=m % n ;
    while(r!=0){
      m=n ;
      n=r ;
      r=m % n ;
    }
    return n ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Numbers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : Scanner := Scanner.newScanner(OclFile["System.in"]) ;
 (     var A : int ; A := sc.nextInt() ;
     var sum : int ; sum := 0 ;
    var yy : int ; yy := A - 2 ;
        var i : int ; i := 2 ; while i < A do ( (     var n : int ; n := A ;
     var m : int ; m := 0 ;
     while (n /= 0) do (     m := m+(n mod i) ; 
     n := n/(i) ) ; 
     sum := sum+(m) )  ;     i := i + 1 ) ; 
    var gcd : int ; gcd := getGCD(sum, yy) ;
    sum := sum/(gcd) ; 
    yy := yy/(gcd) ; 
    OclFile["System.out"].println(StringLib.format("%s/%s",Sequence{sum,yy})) ; 
 ))  );
  static   operation getGCD( m : int, n : int) : int
  pre: true
  post: true
  activity: (     var r : int ; r := m mod n ;
     while (r /= 0) do (     m := n ; 
     n := r ; 
     r := m mod n ) ; 
     return n );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class q2cp101 {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    out=new PrintWriter(new BufferedOutputStream(System.out));
    int n=sc.nextInt();
    int t=n ;
    int unitDigit,sum=0 ;
    for(int i=2 ; i<n ; i++){
      while(n>0){
        unitDigit=n % i ;
        sum+=unitDigit ;
        n=n/i ;
      }
      n=t ;
    }
    int z=gcd(sum,n-2);
    int a1=sum/z ;
    int a2=(n-2)/z ;
    out.println(a1+"/"+a2);
    out.close();
  }
  static int gcd(int a,int b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  public static PrintWriter out ;
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class q2cp101 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var n : int ; n := sc.nextInt() ;
    var t : int ; t := n ;
    var unitDigit : int ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 2 ; while i < n do ( (     while (n > 0) do (     unitDigit := n mod i ; 
     sum := sum+(unitDigit) ; 
     n := n / i ) ; 
     n := t )  ;     i := i + 1 ) ; 
    var z : int ; z := gcd(sum, n - 2) ;
    var a1 : int ; a1 := sum / z ;
    var a2 : int ; a2 := (n - 2) / z ;
    out.println(a1 + "/" + a2) ; 
    out.close() ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   attribute out : OclFile;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static int hcf(int n1,int n2){
    if(n1==0)return n2 ;
    return hcf(n2 % n1,n1);
  }
  public static int basesum(int n,int x){
    int arr[]=new int[40];
    int index=0 ;
    while(n>0){
      arr[index++]=n % x ;
      n=n/x ;
    }
    int sum=0 ;
    for(int i=0 ; i<index ; i++){
      sum=sum+arr[i];
    }
    return sum ;
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int sum=0 ;
    for(int x=2 ; x<n ; x++){
      sum=sum+basesum(n,x);
    }
    int div=hcf(sum,(n-2));
    System.out.println((sum/div)+"/"+((n-2)/div));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation hcf( n1 : int, n2 : int) : int
  pre: true
  post: true
  activity: (     if (n1 = 0) then     return n2 else skip ; 
     return hcf(n2 mod n1, n1) );
  static   operation basesum( n : int, x : int) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,40)->collect(0) ;
     var index : int ; index := 0 ;
    while (n > 0) do (      arr[index+1] := n mod x  ; index := index + 1 ; 
     n := n / x ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < index do ( (     sum := sum + arr[i+1] )  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
        var x : int ; x := 2 ; while x < n do ( (     sum := sum + basesum(n, x) )  ;     x := x + 1 ) ; 
    var div : int ; div := hcf(sum, (n - 2)) ;
    OclFile["System.out"].println((sum / div) + "/" + ((n - 2) / div)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Task13A {
  public static void main(String[] args)throws IOException {
    Task13A task13A=new Task13A();
    task13A.resolve();
  }
  private void resolve()throws IOException {
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    int number=Integer.parseInt(bufferedReader.readLine());
    int digitSum=0 ;
    for(int i=2 ; i<number ; i++){
      int num=number ;
      while(num>0){
        digitSum+=num % i ;
        num/=i ;
      }
    }
    System.out.println(createFraction(digitSum,number-2));
  }
  private static String createFraction(int numerator,int denominator){
    int min=Math.min(numerator,denominator);
    for(int i=2 ; i<min ; i++){
      while(numerator % i==0 && denominator % i==0){
        numerator/=i ;
        denominator/=i ;
      }
    }
    return numerator+"/"+denominator ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Task13A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var task13A : Task13A ; task13A := Task13A.newTask13A() ;
     task13A.resolve() );
   operation resolve() : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var number : int ; number := (bufferedReader.readLine())->toInteger() ;
    var digitSum : int ; digitSum := 0 ;
        var i : int ; i := 2 ; while i < number do ( (     var num : int ; num := number ;
     while (num > 0) do (     digitSum := digitSum+(num mod i) ; 
     num := num/(i) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(createFraction(digitSum, number - 2)) ; 
 );
  static   operation createFraction( numerator : int, denominator : int) : String
  pre: true
  post: true
  activity: (     var min : int ; min := Set{numerator, denominator}->min() ;
         var i : int ; i := 2 ; while i < min do ( (     while (numerator mod i = 0 & denominator mod i = 0) do (     numerator := numerator/(i) ; 
     denominator := denominator/(i) ) )  ;     i := i + 1 ) ; 
     return numerator + "/" + denominator );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Arrays ;
public class Main {
  static int inf=1000000000 ;
  public static void main(String ards[]){
    Scanner cin=new Scanner(System.in);
    int n=cin.nextInt();
    int k=cin.nextInt();
    String str=cin.next();
    StringBuilder ans=new StringBuilder().append(str);
    StringBuilder s=new StringBuilder();
    for(int i=0 ; i<k ; i++){
      s.append(str.charAt(i));
    }
    for(int i=k ; i<n ; i++){
      ans.setCharAt(i,s.charAt(i % k));
    }
    for(int i=k ; i<n ; i++){
      if(str.charAt(i)<ans.charAt(i)){
        break ;
      }
      if(str.charAt(i)==ans.charAt(i)){
        continue ;
      }
      if(str.charAt(i)>ans.charAt(i)){
        int cnt=k-1 ;
        while(s.charAt(cnt)=='9'){
          s.setCharAt(cnt,'0');
          cnt--;
        }
        int x=(int)s.charAt(cnt)+1 ;
        s.setCharAt(cnt,(char)x);
        break ;
      }
    }
    for(int i=0 ; i<n ; i++){
      ans.setCharAt(i,s.charAt(i % k));
    }
    System.out.println(ans.length());
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute inf : int := 1000000000;
  static   operation main( ards : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := cin.getCurrent()->toInteger() ;
    var k : int ; k := cin.getCurrent()->toInteger() ;
    var str : String ; str := cin.getCurrent() ;
    var ans : String ; ans := StringLib.newString() + StringLib.newString(str) ;
    var s : String ; s := StringLib.newString() ;
        var i : int ; i := 0 ; while i < k do ( (     s := s + StringLib.newString(str->at(i+1)) )  ;     i := i + 1 ) ; 
        var i : int ; i := k ; while i < n do ( (     ans := ans.setAt(i+1, s->at(i mod k+1)) )  ;     i := i + 1 ) ; 
        var i : int ; i := k ; while i < n do ( (     if (str->at(i+1) < ans->at(i+1)) then (     break ) else skip ; 
     if (str->at(i+1) = ans->at(i+1)) then (     continue ) else skip ; 
     if (str->at(i+1) > ans->at(i+1)) then (     var cnt : int ; cnt := k - 1 ;
     while (s->at(cnt+1) = '9') do (     s := s.setAt(cnt+1, '0') ; 
     cnt := cnt - 1 ) ; 
    var x : int ; x := s->at(cnt+1)->oclAsType(int) + 1 ;
    s := s.setAt(cnt+1, x->oclAsType(String)) ; 
    break 
 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     ans := ans.setAt(i+1, s->at(i mod k+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans->size()) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    String s=scan.next();
    String s1=s.substring(0,k);
    boolean flag=true ;
    for(int i=k ; i<n ; i+=k){
      int endIndex=(i+k<n)? i+k : n ;
      if(s1.compareTo(s.substring(i,endIndex))>0)break ;
      else if(s1.compareTo(s.substring(i,endIndex))<0){
        flag=false ;
        break ;
      }
    }
    if(! flag){
      BigInteger bi=new BigInteger(s1);
      bi=bi.add(BigInteger.valueOf(1));
      s1=bi.toString();
    }
    System.out.println(n);
    for(int i=0 ; i<n ; i+=k){
      if(i+k>=n){
        System.out.print(s1.substring(0,n-i));
        continue ;
      }
      System.out.print(s1);
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var s : String ; s := scan.getCurrent() ;
    var s1 : String ; s1 := s.subrange(0+1,k) ;
    var flag : boolean ; flag := true ;
        var i : int ; i := k ; while i < n do ( (     var endIndex : int ; endIndex := if (i + k < n) then i + k else n endif ;
     if (s1->compareTo(s.subrange(i+1,endIndex)) > 0) then     break else     if (s1->compareTo(s.subrange(i+1,endIndex)) < 0) then (     flag := false ; 
     break ) else skip ; )  ;     i := i+(k) ) ; 
    if (not(flag)) then (     var bi : long ; bi := long(s1) ;
     bi := bi->excludes((1 + "")->toLong()) ; 
     s1 := bi+"" ) else skip ; 
    OclFile["System.out"].println(n) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i + k >= n) then (     OclFile["System.out"].print(s1.subrange(0+1,n - i)) ; 
     continue ) else skip ; 
     OclFile["System.out"].print(s1) )  ;     i := i+(k) ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class L1268A {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] ss=br.readLine().split(" ");
    int n=Integer.parseInt(ss[0]);
    int k=Integer.parseInt(ss[1]);
    String nstr=br.readLine();
    char[] num=nstr.toCharArray();
    for(int i=0 ; i+k<n ; i++){
      num[i+k]=num[i];
    }
    String str=new String(num);
    if(str.compareTo(nstr)<0){
      for(int i=k-1 ; i>=0 ; --i){
        if(num[i]=='9'){
          num[i]='0' ;
        }
        else {
++num[i];
          for(int j=i ; j+k<n ; j++){
            num[j+k]=num[j];
          }
          break ;
        }
      }
    }
    nstr=new String(num);
    System.out.println(nstr.length());
    System.out.println(nstr);
  }
}
------------------------------------------------------------
OCL File:
---------
 class L1268A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var ss : Sequence(String) ; ss := br.readLine()->split(" ") ;
    var n : int ; n := (ss[0+1])->toInteger() ;
    var k : int ; k := (ss[1+1])->toInteger() ;
    var nstr : String ; nstr := br.readLine() ;
    var num : Sequence(String) ; num := nstr->characters() ;
        var i : int ; i := 0 ; while i + k < n do ( (     num[i + k+1] := num[i+1] )  ;     i := i + 1 ) ; 
    var str : String ; str := StringLib.newString(num) ;
    if (str->compareTo(nstr) < 0) then (         var i : int ; i := k - 1 ; while i >= 0 do ( (     if (num[i+1] = '9') then (     num[i+1] := '0' ) else (     num[i+1] := num[i+1] + 1 ; 
         var j : int ; j := i ; while j + k < n do ( (     num[j + k+1] := num[j+1] )  ;     j := j + 1 ) ; 
     break ) )  ;     i := i - 1 ) ) else skip ; 
    nstr := StringLib.newString(num) ; 
    OclFile["System.out"].println(nstr->size()) ; 
    OclFile["System.out"].println(nstr) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main extends PrintWriter {
  Main(){
    super(System.out,true);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    Main o=new Main();
    o.main();
    o.flush();
  }
  static final int A=1000000,MD=1000000007 ;
  int power(long a,int k){
    long p=1 ;
    while(k>0){
      if((k & 1)==1)p=p*a % MD ;
      a=a*a % MD ;
      k>>=1 ;
    }
    return(int)p ;
  }
  void main(){
    int n=sc.nextInt();
    int[] kk=new int[A];
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      ans=(ans+power(a,MD-2))% MD ;
      for(int p=2 ; p<=a/p ; p++)if(a % p==0){
        int k=0 ;
        while(a % p==0){
          k++;
          a/=p ;
        }
        kk[p]=Math.max(kk[p],k);
      }
      if(a>1)kk[a]=Math.max(kk[a],1);
    }
    for(int a=2 ; a<A ; a++)if(kk[a]>0)ans=ans*power(a,kk[a])% MD ;
    println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends OclFile {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"], true) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : Main ; o := Main.newMain() ;
     o.main() ; 
     o.flush() );
  static    attribute A : int := 1000000;
   operation power( a : long, k : int) : int
  pre: true
  post: true
  activity: (     var p : long ; p := 1 ;
     while (k > 0) do (     if ((k & 1) = 1) then     p := p * a mod MD ; else skip ; 
     a := a * a mod MD ; 
     k := k/(2->pow(1)) ) ; 
     return p->oclAsType(int) );
   operation main() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var kk : Sequence(int) ; kk := Integer.subrange(1,A)->collect(0) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     ans := (ans + power(a, MD - 2)) mod MD ; 
         var p : int ; p := 2 ; while p <= a / p do (     if (a mod p = 0) then (     var k : int ; k := 0 ;
     while (a mod p = 0) do (     k := k + 1 ; 
     a := a/(p) ) ; 
     kk[p+1] := Set{kk[p+1], k}->max() ) else skip ;  ;     p := p + 1 ) ; 
     if (a > 1) then     kk[a+1] := Set{kk[a+1], 1}->max() ; else skip )  ;     i := i + 1 ) ; 
        var a : int ; a := 2 ; while a < A do (     if (kk[a+1] > 0) then     ans := ans * power(a, kk[a+1]) mod MD ; else skip ;  ;     a := a + 1 ) ; 
    execute println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int longestsubarray(int arr[],int n,int k){
    int current_count=0 ;
    int max_count=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] % k==0)current_count++;
      else current_count=0 ;
      max_count=Math.max(current_count,max_count);
    }
    return max_count ;
  }
  public static void main(String[] args){
    int arr[]={
      2,5,11,32,64,88 };
      int n=arr.length ;
      int k=8 ;
      System.out.println(longestsubarray(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation longestsubarray( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var current_count : int ; current_count := 0 ;
     var max_count : int ; max_count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod k = 0) then     current_count := current_count + 1 else     current_count := 0 ; ;  
     max_count := Set{current_count, max_count}->max() )  ;     i := i + 1 ) ; 
     return max_count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,5,11,32,64,88} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 8 ;
     OclFile["System.out"].println(longestsubarray(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class FindNth {
  static int printNthElement(int n){
    int arr[]=new int[n+1];
    arr[1]=3 ;
    arr[2]=5 ;
    for(int i=3 ; i<=n ; i++){
      if(i % 2!=0)arr[i]=arr[i/2]*10+3 ;
      else arr[i]=arr[(i/2)-1]*10+5 ;
    }
    return arr[n];
  }
  public static void main(String[] args){
    int n=6 ;
    System.out.println(printNthElement(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class FindNth {
  static   operation printNthElement( n : int) : int
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
     arr[1+1] := 3 ; 
    arr[2+1] := 5 ; 
        var i : int ; i := 3 ; while i <= n do ( (     if (i mod 2 /= 0) then     arr[i+1] := arr[i / 2+1] * 10 + 3 ; else     arr[i+1] := arr[(i / 2) - 1+1] * 10 + 5 ; )  ;     i := i + 1 ) ; 
    return arr[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(printNthElement(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int N=3 ;
  static int M=3 ;
  static int majorityInMatrix(int arr[][]){
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<M ; j++){
        if(mp.containsKey(arr[i][j]))mp.put(arr[i][j],mp.get(arr[i][j])+1);
        else mp.put(arr[i][j],1);
      }
    }
    int countMajority=0 ;
    Iterator<HashMap.Entry<Integer,Integer>>itr=mp.entrySet().iterator();
    while(itr.hasNext()){
      HashMap.Entry<Integer,Integer>entry=itr.next();
      if(entry.getValue()>=((N*M)/2)){
        countMajority++;
      }
    }
    return countMajority ;
  }
  public static void main(String[] args){
    int mat[][]={
      {
        1,2,2 },{
          1,3,2 },{
            1,2,6 }
          };
          System.out.println(majorityInMatrix(mat));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 3;
  static   attribute M : int := 3;
  static   operation majorityInMatrix( arr : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < M do ( (     if (mp->keys()->includes(arr[i+1][j+1])) then     mp := mp->union(Map{arr[i+1][j+1] |-> mp->at(arr[i+1][j+1]) + 1}) ; else     mp := mp->union(Map{arr[i+1][j+1] |-> 1}) ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var countMajority : int ; countMajority := 0 ;
    var itr : OclIterator ; itr := mp->asSet()->iterator() ;
    while (itr.hasNext()) do (     var entry : Entry<int,int> ; entry := itr.next() ;
     if (entry.getValue() >= ((N * M) / 2)) then (     countMajority := countMajority + 1 ) else skip ) ; 
    return countMajority 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{1,2,2},Sequence{1,3,2},Sequence{1,2,6}} ;
     OclFile["System.out"].println(majorityInMatrix(mat)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    if(T>=0)System.out.println(T);
    else {
      String s=T+"" ;
      StringBuffer res=new StringBuffer("");
      for(int i=0 ; i<s.length()-2 ; i++){
        res.append(s.charAt(i));
      }
      res.append(s.charAt(s.length()-1)>=s.charAt(s.length()-2)? s.charAt(s.length()-2): s.charAt(s.length()-1));
      System.out.println(Integer.parseInt(res.toString()));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
     if (T >= 0) then     OclFile["System.out"].println(T) ; else (     var s : String ; s := T + "" ;
     var res : String ; res := StringLib.newString("") ;
        var i : int ; i := 0 ; while i < s->size() - 2 do ( (     res := res + StringLib.newString(s->at(i+1)) )  ;     i := i + 1 ) ; 
    res := res + StringLib.newString(if s->at(s->size() - 1+1) >= s->at(s->size() - 2+1) then s->at(s->size() - 2+1) else s->at(s->size() - 1+1) endif) ; 
    OclFile["System.out"].println((res+"")->toInteger()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class demo1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n>=0){
      System.out.println(n);
    }
    else {
      n=-n ;
      if((n/100)*10+n % 10<n/10){
        System.out.println(-((n/100)*10+n % 10));
      }
      else {
        System.out.println(-(n/10));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class demo1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n >= 0) then (     OclFile["System.out"].println(n) ) else (     n := -n ; 
     if ((n / 100) * 10 + n mod 10 < n / 10) then (     OclFile["System.out"].println(-((n / 100) * 10 + n mod 10)) ) else (     OclFile["System.out"].println(-(n / 10)) ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class lll {
  public static void main(String[] args){
    FastScanner fastScanner=new FastScanner();
    long n=fastScanner.nextLong();
    if(n>=0)System.out.println(n);
    else {
      String str=String.valueOf(Math.abs(n));
      String sss=str.substring(0,str.length()-1);
      String sFin="" ;
      for(int i=0 ; i<str.length(); i++){
        if(i!=str.length()-2)sFin+=str.charAt(i);
      }
      long l=Integer.parseInt(sss);
      long l2=Integer.parseInt(sFin);
      if(l>l2){
        if(l2==0)System.out.println(0);
        else System.out.println("-"+l2);
      }
      else {
        if(l==0)System.out.println(0);
        else System.out.println("-"+l);
      }
    };
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(String s){
    try {
      br=new BufferedReader(new FileReader(s));
    }
    catch(FileNotFoundException e){
      e.printStackTrace();
    }
  }
  public FastScanner(){
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  String nextToken(){
    while(st==null || ! st.hasMoreElements()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
    }
    return st.nextToken();
  }
  String nextLine(){
    String str="" ;
    try {
      if(st.hasMoreTokens()){
        str=st.nextToken("\n");
      }
      else {
        str=br.readLine();
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
    return str ;
  }
  int nextInt(){
    return Integer.parseInt(nextToken());
  }
  long nextLong(){
    return Long.parseLong(nextToken());
  }
  double nextDouble(){
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class lll {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fastScanner : FastScanner ; fastScanner := FastScanner.newFastScanner() ;
     var n : long ; n := fastScanner.nextLong() ;
     if (n >= 0) then     OclFile["System.out"].println(n) else (     var str : String ; str := ((if n < 0 then -(n) else n endif) + "") ;
     var sss : String ; sss := str.subrange(0+1,str->size() - 1) ;
    var sFin : String ; sFin := "" ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (i /= str->size() - 2) then     sFin := sFin+(str->at(i+1)) ; else skip )  ;     i := i + 1 ) ; 
    var l : long ; l := (sss)->toInteger() ;
    var l2 : long ; l2 := (sFin)->toInteger() ;
    if (l > l2) then (     if (l2 = 0) then     OclFile["System.out"].println(0) ; else     OclFile["System.out"].println("-" + l2) ; ) else (     if (l = 0) then     OclFile["System.out"].println(0) ; else     OclFile["System.out"].println("-" + l) ; ) ;  
 ) ;  
  );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) )   catch (e : FileNotFoundException) do (     e.printStackTrace() )
 );
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    if(a>0)System.out.println(a);
    else {
      System.out.println(Math.max(a/10,a % 10+(a/100)*10));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (a > 0) then     OclFile["System.out"].println(a) ; else (     OclFile["System.out"].println(Set{a / 10, a mod 10 + (a / 100) * 10}->max()) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Funny {
  static boolean checkFunny(String word){
    int i=1 ;
    int j=word.length()-2 ;
    word=word.toLowerCase();
    while(i<=j){
      if((Math.abs(word.charAt(i)-word.charAt(i-1)))!=Math.abs((word.charAt(j)-word.charAt(j+1))))return false ;
      i++;
      j--;
    }
    return true ;
  }
  static void printFunnyWords(String str){
    str=str+" " ;
    String word="" ;
    for(int i=0 ; i<str.length(); i++){
      char ch=str.charAt(i);
      if(ch!=' ')word=word+ch ;
      else {
        if(Funny.checkFunny(word))System.out.println(word);
        word="" ;
      }
    }
  }
  public static void main(String[] args){
    Funny.printFunnyWords("Miss Arora teaches us malayalam bdwy ");
  }
}
------------------------------------------------------------
OCL File:
---------
class Funny {
  static   operation checkFunny( word : String) : boolean
  pre: true
  post: true
  activity: (     var i : int ; i := 1 ;
     var j : int ; j := word->size() - 2 ;
    word := word->toLowerCase() ; 
    while (i <= j) do (     if ((if word->at(i+1) - word->at(i - 1+1) < 0 then -(word->at(i+1) - word->at(i - 1+1)) else word->at(i+1) - word->at(i - 1+1) endif) /= if (word->at(j+1) - word->at(j + 1+1)) < 0 then -((word->at(j+1) - word->at(j + 1+1))) else (word->at(j+1) - word->at(j + 1+1)) endif) then     return false else skip ; 
     i := i + 1 ; 
     j := j - 1 ) ; 
    return true 
 );
  static   operation printFunnyWords( str : String) : void
  pre: true
  post: true
  activity: (     str := str + " " ; 
     var word : String ; word := "" ;
         var i : int ; i := 0 ; while i < str->size() do ( (     var ch : String ; ch := str->at(i+1) ;
     if (ch /= ' ') then     word := word + ch ; else (     if (Funny.checkFunny(word)) then     OclFile["System.out"].println(word) ; else skip ; 
     word := "" ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Funny.printFunnyWords("Miss Arora teaches us malayalam bdwy ") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean checkDistinct(int x){
    int last=x % 10 ;
    while(x>0){
      if(x % 10!=last)return false ;
      x=x/10 ;
    }
    return true ;
  }
  static int findCount(int L,int R){
    int count=0 ;
    for(int i=L ; i<=R ; i++){
      if(checkDistinct(i))count+=1 ;
    }
    return count ;
  }
  public static void main(String[] args){
    int L=10,R=50 ;
    System.out.println(findCount(L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkDistinct( x : int) : boolean
  pre: true
  post: true
  activity: (     var last : int ; last := x mod 10 ;
     while (x > 0) do (     if (x mod 10 /= last) then     return false else skip ; 
     x := x / 10 ) ; 
     return true );
  static   operation findCount( L : int, R : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := L ; while i <= R do ( (     if (checkDistinct(i)) then     count := count+(1) ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 10 ;
    var R : int ; R := 50 ;
     OclFile["System.out"].println(findCount(L, R)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class wub {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    System.out.println(s.replaceAll("WUB"," ").trim());
  }
}
------------------------------------------------------------
OCL File:
---------
 class wub {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
     OclFile["System.out"].println(s.replaceAllMatches("WUB", " " )->trim()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
final public class A {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    StringTokenizer st=new StringTokenizer(br.readLine());
    Double[] arr=new Double[2*n];
    int non_int=0 ;
    double sum_before=0,sum=0 ;
    for(int i=0 ; i<2*n ; i++){
      double num=Double.parseDouble(st.nextToken());
      sum_before+=num ;
      if(num!=Math.floor(num))non_int++;
      sum+=Math.floor(num);
      arr[i]=num ;
    }
    double max_sum=Math.min(n,non_int)+sum ;
    double min_sum=Math.max(0,non_int-n)+sum ;
    double ans ;
    if(min_sum>sum_before)ans=(min_sum-sum_before);
    else if(max_sum<sum_before)ans=(sum_before-max_sum);
    else {
      double x=sum_before-Math.floor(sum_before);
      ans=Math.min(1-x,x);
    }
    System.out.printf("%.3f",ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var arr : Sequence(double) ; arr := Integer.subrange(1,2 * n)->collect(null) ;
    var non_int : int ; non_int := 0 ;
    var sum_before : double ; sum_before := 0 ;
    var sum : double ; sum := 0 ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     var num : double ; num := (st.next())->toReal() ;
     sum_before := sum_before+(num) ; 
    if (num /= (num)->floor()) then     non_int := non_int + 1 ; else skip ; 
    sum := sum+((num)->floor()) ; 
    arr[i+1] := num ; 
 )  ;     i := i + 1 ) ; 
    var max_sum : double ; max_sum := Set{n, non_int}->min() + sum ;
    var min_sum : double ; min_sum := Set{0, non_int - (n)->char2byte()}->max() + sum ;
    var ans : double ;
    if (min_sum > sum_before) then     ans := (min_sum - sum_before) else     if (max_sum < sum_before) then     ans := (sum_before - max_sum) else (     var x : double ; x := sum_before - (sum_before)->floor() ;
     ans := Set{1 - x, x}->min() ) ;  ;  
    OclFile["System.out"].printf("%.3f", ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Dubstep {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] toDecode=br.readLine().split("WUB");
    String output="" ;
    int l=toDecode.length ;
    for(int i=0 ; i<l ; i++){
      if(toDecode[i] .equals(""))continue ;
      output+=toDecode[i]+" " ;
    }
    System.out.println(output.substring(0,output.length()-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Dubstep {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var toDecode : Sequence(String) ; toDecode := br.readLine()->split("WUB") ;
    var output : String ; output := "" ;
    var l : int ; l := toDecode->size() ;
        var i : int ; i := 0 ; while i < l do ( (     if (toDecode[i+1] = "") then     continue else skip ; 
     output := output+(toDecode[i+1] + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(output.subrange(0+1,output->size() - 1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    StringBuilder sb=new StringBuilder(fs.next());
    String s=sb.toString().replace("WUB"," ").trim();
    out.print(s);
    out.close();
  }
  static int isPerfectSquare(int x){
    if(x>=0){
      int sr=(int)Math.sqrt(x);
      if((sr*sr)==x)return sr ;
      else return 0 ;
    }
    return 0 ;
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    Long[] readArray(int n){
      Long[] a=new Long[n];
      for(int i=0 ; i<n ; i++)a[i]=nextLong();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString(fs.next()) ;
    var s : String ; s := sb+"".replace("WUB", " ")->trim() ;
    skip ; 
    skip ; 
 );
  static   operation isPerfectSquare( x : int) : int
  pre: true
  post: true
  activity: (     if (x >= 0) then (     var sr : int ; sr := (x)->sqrt()->oclAsType(int) ;
     if ((sr * sr) = x) then     return sr else     return 0 ) else skip ; 
     return 0 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextLong() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class StronglyConnectedCity {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    sc.nextLine();
    String n1=sc.nextLine();
    String n2=sc.nextLine();
    if((n1.charAt(0)=='>' && n1.charAt(n-1)=='<' && n2.charAt(0)=='^' && n2.charAt(m-1)=='v')||(n1.charAt(0)=='<' && n1.charAt(n-1)=='>' && n2.charAt(0)=='v' && n2.charAt(m-1)=='^')){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class StronglyConnectedCity {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    skip ; 
    var n1 : String ; n1 := sc.nextLine() ;
    var n2 : String ; n2 := sc.nextLine() ;
    if ((n1->at(0+1) = '>' & n1->at(n - 1+1) = '<' & n2->at(0+1) = '^' & n2->at(m - 1+1) = 'v') or (n1->at(0+1) = '<' & n1->at(n - 1+1) = '>' & n2->at(0+1) = 'v' & n2->at(m - 1+1) = '^')) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class dubstep {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    s=s.replace("WUB"," ");
    s=s.trim();
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class dubstep {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    s := s.replace("WUB", " ") ; 
    s := s->trim() ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int Valid(int a,int b,int c){
    if(a+b+c==180 && a!=0 && b!=0 && c!=0)return 1 ;
    else return 0 ;
  }
  public static void main(String args[]){
    int a=60,b=40,c=80 ;
    if((Valid(a,b,c))==1)System.out.print("Valid");
    else System.out.print("Invalid");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Valid( a : int, b : int, c : int) : int
  pre: true
  post: true
  activity: (     if (a + b + c = 180 & a /= 0 & b /= 0 & c /= 0) then     return 1 else     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 60 ;
    var b : int ; b := 40 ;
    var c : int ; c := 80 ;
     if ((Valid(a, b, c)) = 1) then     OclFile["System.out"].print("Valid") ; else     OclFile["System.out"].print("Invalid") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public static int checkValidity(int a,int b,int c){
    if(a+b<=c || a+c<=b || b+c<=a)return 0 ;
    else return 1 ;
  }
  public static void main(String args[]){
    int a=7,b=10,c=5 ;
    if((checkValidity(a,b,c))==1)System.out.print("Valid");
    else System.out.print("Invalid");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkValidity( a : int, b : int, c : int) : int
  pre: true
  post: true
  activity: (     if (a + b <= c or a + c <= b or b + c <= a) then     return 0 else     return 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 7 ;
    var b : int ; b := 10 ;
    var c : int ; c := 5 ;
     if ((checkValidity(a, b, c)) = 1) then     OclFile["System.out"].print("Valid") ; else     OclFile["System.out"].print("Invalid") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      String s=sc.nextLine();
      String s1=sc.nextLine();
      String s2=sc.nextLine();
      int count=0,count1=0,count2=0 ;
      for(int i=0 ; i<s.length(); i++){
        if(s.charAt(i)=='a' || s.charAt(i)=='e' || s.charAt(i)=='i' || s.charAt(i)=='o' || s.charAt(i)=='u')count++;
      }
      for(int i=0 ; i<s1.length(); i++){
        if(s1.charAt(i)=='a' || s1.charAt(i)=='e' || s1.charAt(i)=='i' || s1.charAt(i)=='o' || s1.charAt(i)=='u')count1++;
      }
      for(int i=0 ; i<s2.length(); i++){
        if(s2.charAt(i)=='a' || s2.charAt(i)=='e' || s2.charAt(i)=='i' || s2.charAt(i)=='o' || s2.charAt(i)=='u')count2++;
      }
      if(count==5 && count1==7 && count2==5)System.out.println("YES");
      else System.out.println("NO");
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var s1 : String ; s1 := sc.nextLine() ;
    var s2 : String ; s2 := sc.nextLine() ;
    var count : int ; count := 0 ;
    var count1 : int ; count1 := 0 ;
    var count2 : int ; count2 := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'a' or s->at(i+1) = 'e' or s->at(i+1) = 'i' or s->at(i+1) = 'o' or s->at(i+1) = 'u') then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < s1->size() do ( (     if (s1->at(i+1) = 'a' or s1->at(i+1) = 'e' or s1->at(i+1) = 'i' or s1->at(i+1) = 'o' or s1->at(i+1) = 'u') then     count1 := count1 + 1 ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < s2->size() do ( (     if (s2->at(i+1) = 'a' or s2->at(i+1) = 'e' or s2->at(i+1) = 'i' or s2->at(i+1) = 'o' or s2->at(i+1) = 'u') then     count2 := count2 + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (count = 5 & count1 = 7 & count2 = 5) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class First_project {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String[] word=new String[3];
    int count=0 ;
    word[0]=input.nextLine();
    word[1]=input.nextLine();
    word[2]=input.nextLine();
    word[0]=word[0] .trim();
    word[1]=word[1] .trim();
    word[2]=word[2] .trim();
    for(int j=0 ; j<word.length ; j++){
      for(int i=0 ; i<word[j] .length(); i++){
        if(word[j] .charAt(i)=='a' || word[j] .charAt(i)=='e' || word[j] .charAt(i)=='i' || word[j] .charAt(i)=='o' || word[j] .charAt(i)=='u'){
          count++;
        }
      }
      if(j==0 || j==2){
        if(count!=5){
          System.out.print("NO");
          System.exit(0);
        }
      }
      else {
        if(count!=7){
          System.out.print("NO");
          System.exit(0);
        }
      }
      count=0 ;
    }
    System.out.print("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class First_project {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var word : Sequence(String) ; word := Integer.subrange(1,3)->collect(null) ;
    var count : int ; count := 0 ;
    word[0+1] := input.nextLine() ; 
    word[1+1] := input.nextLine() ; 
    word[2+1] := input.nextLine() ; 
    word[0+1] := word[0+1]->trim() ; 
    word[1+1] := word[1+1]->trim() ; 
    word[2+1] := word[2+1]->trim() ; 
        var j : int ; j := 0 ; while j < word->size() do ( (         var i : int ; i := 0 ; while i < word[j+1]->size() do ( (     if (word[j+1]->at(i+1) = 'a' or word[j+1]->at(i+1) = 'e' or word[j+1]->at(i+1) = 'i' or word[j+1]->at(i+1) = 'o' or word[j+1]->at(i+1) = 'u') then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (j = 0 or j = 2) then (     if (count /= 5) then (     OclFile["System.out"].print("NO") ; 
 OclProcess.exit(0) ) else skip ) else (     if (count /= 7) then (     OclFile["System.out"].print("NO") ; 
 OclProcess.exit(0) ) else skip ) ;  
     count := 0 )  ;     j := j + 1 ) ; 
    OclFile["System.out"].print("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int calculateSum(int n){
    return 2*(n*(n+1)*(2*n+1)/6)+n*(n+1)/2+2*(n);
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.print("Sum="+calculateSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculateSum( n : int) : int
  pre: true
  post: true
  activity: (     return 2 * (n * (n + 1) * (2 * n + 1) / 6) + n * (n + 1) / 2 + 2 * (n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].print("Sum=" + calculateSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int calculateSum(int n){
    return n*(n+1)/2+n*(n+1)*(2*n+1)/6 ;
  }
  public static void main(String args[]){
    int n=3 ;
    System.out.print("Sum="+calculateSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculateSum( n : int) : int
  pre: true
  post: true
  activity: (     return n * (n + 1) / 2 + n * (n + 1) * (2 * n + 1) / 6 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].print("Sum=" + calculateSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int equivalentBase4(String bin){
    if(bin.compareTo("00")==0)return 0 ;
    if(bin.compareTo("01")==0)return 1 ;
    if(bin.compareTo("10")==0)return 2 ;
    return 3 ;
  }
  static String isDivisibleBy5(String bin){
    int l=bin.length();
    if(l % 2!=0)bin='0'+bin ;
    int odd_sum=0,even_sum=0 ;
    int isOddDigit=1 ;
    for(int i=0 ; i<bin.length(); i+=2){
      if(isOddDigit!=0)odd_sum+=equivalentBase4(bin.substring(i,i+2));
      else even_sum+=equivalentBase4(bin.substring(i,i+2));
      isOddDigit ^=1 ;
    }
    if(Math.abs(odd_sum-even_sum)% 5==0)return "Yes" ;
    return "No" ;
  }
  public static void main(String[] args){
    String bin="10000101001" ;
    System.out.println(isDivisibleBy5(bin));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation equivalentBase4( bin : String) : int
  pre: true
  post: true
  activity: (     if (bin->compareTo("00") = 0) then     return 0 else skip ; 
     if (bin->compareTo("01") = 0) then     return 1 else skip ; 
     if (bin->compareTo("10") = 0) then     return 2 else skip ; 
     return 3 );
  static   operation isDivisibleBy5( bin : String) : String
  pre: true
  post: true
  activity: (     var l : int ; l := bin->size() ;
     if (l mod 2 /= 0) then     bin := '0' + bin ; else skip ; 
    var odd_sum : int ; odd_sum := 0 ;
    var even_sum : int ; even_sum := 0 ;
    var isOddDigit : int ; isOddDigit := 1 ;
        var i : int ; i := 0 ; while i < bin->size() do ( (     if (isOddDigit /= 0) then     odd_sum := odd_sum+(equivalentBase4(bin.subrange(i+1,i + 2))) else     even_sum := even_sum+(equivalentBase4(bin.subrange(i+1,i + 2))) ; ;  
     isOddDigit := MathLib.bitwiseXor(isOddDigit,1) )  ;     i := i+(2) ) ; 
    if (if odd_sum - even_sum < 0 then -(odd_sum - even_sum) else odd_sum - even_sum endif mod 5 = 0) then     return "Yes" else skip ; 
    return "No" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bin : String ; bin := "10000101001" ;
     OclFile["System.out"].println(isDivisibleBy5(bin)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static double sum(int n){
    if(n==0)return 1 ;
    double ans=1/(double)Math.pow(3,n)+sum(n-1);
    return ans ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(sum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sum( n : int) : double
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     var ans : double ; ans := 1 / 3->pow(n)->oclAsType(double) + sum(n - 1) ;
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(sum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  public static void main(String[] args){
    Scanner kali=new Scanner(System.in);
    String guests=kali.next();
    String owner=kali.next();
    String random_word=kali.next();
    String temp1=guests+owner ;
    String finalniy=sort(temp1);
    if(finalniy.equals(sort(random_word))){
      System.out.println("YES");
    }
    else System.out.println("NO");
  }
  public static String sort(String temp){
    char[] arr=temp.toCharArray();
    Arrays.sort(arr);
    return new String(arr);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var kali : OclFile ; kali := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var guests : String ; guests := kali.getCurrent() ;
    var owner : String ; owner := kali.getCurrent() ;
    var random_word : String ; random_word := kali.getCurrent() ;
    var temp1 : String ; temp1 := guests + owner ;
    var finalniy : String ; finalniy := sort(temp1) ;
    if (finalniy = sort(random_word)) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; ;  
 );
  static   operation sort( temp : String) : String
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := temp->characters() ;
     arr := arr->sort() ; 
     return StringLib.newString(arr) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class problemC {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String stringA=sc.nextLine();
    String stringB=sc.nextLine();
    String letters=sc.nextLine();
    String stringAB=stringA+stringB ;
    if(letters.length()>100 | stringAB.length()>100 | letters.length()!=stringAB.length()){
      System.out.println("NO");
    }
    else {
      char[] arrAB=new char[100];
      char[] arrLetters=new char[100];
      for(int i=0 ; i<stringAB.length(); i++){
        arrAB[i]=stringAB.charAt(i);
        arrLetters[i]=letters.charAt(i);
      }
      bubble(arrAB);
      bubble(arrLetters);
      boolean no=false ;
      for(int i=0 ; i<arrLetters.length ; i++){
        if(arrAB[i]!=arrLetters[i]){
          no=true ;
          break ;
        }
      }
      if(no){
        System.out.println("NO");
      }
      else {
        System.out.println("YES");
      }
    }
  }
  public static void bubble(char[] arr){
    for(int j=arr.length ; j>0 ; j--){
      for(int i=0 ; i<arr.length-1 ; i++){
        if(arr[i]>=arr[i+1]){
          char switchear=arr[i];
          arr[i]=arr[i+1];
          arr[i+1]=switchear ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class problemC {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var stringA : String ; stringA := sc.nextLine() ;
    var stringB : String ; stringB := sc.nextLine() ;
    var letters : String ; letters := sc.nextLine() ;
    var stringAB : String ; stringAB := stringA + stringB ;
    if (letters->size() > 100 or stringAB->size() > 100 or letters->size() /= stringAB->size()) then (     OclFile["System.out"].println("NO") ) else (     var arrAB : Sequence(String) ; arrAB := Integer.subrange(1,100)->collect(0) ;
     var arrLetters : Sequence(String) ; arrLetters := Integer.subrange(1,100)->collect(0) ;
        var i : int ; i := 0 ; while i < stringAB->size() do ( (     arrAB[i+1] := stringAB->at(i+1) ; 
     arrLetters[i+1] := letters->at(i+1) )  ;     i := i + 1 ) ; 
    execute bubble(arrAB) ; 
    execute bubble(arrLetters) ; 
    var no : boolean ; no := false ;
        var i : int ; i := 0 ; while i < arrLetters->size() do ( (     if (arrAB[i+1] /= arrLetters[i+1]) then (     no := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (no) then (     OclFile["System.out"].println("NO") ) else (     OclFile["System.out"].println("YES") ) ;  
 ) ;  
 );
  static   operation bubble( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (         var j : int ; j := arr->size() ; while j > 0 do ( (         var i : int ; i := 0 ; while i < arr->size() - 1 do ( (     if (arr[i+1] >= arr[i + 1+1]) then (     var switchear : String ; switchear := arr[i+1] ;
     arr[i+1] := arr[i + 1+1] ; 
     arr[i + 1+1] := switchear ) else skip )  ;     i := i + 1 ) )  ;     j := j - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class tasks {
  public static void main(String...args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str,str1 ;
    int flag=0 ;
    try {
      str=br.readLine();
      str+=br.readLine();
      str1=br.readLine();
    }
    catch(IOException e){
      throw new RuntimeException(e);
    }
    if(str.length()!=str1.length()){
      System.out.println("NO");
    }
    else {
      char[] ch=str.toCharArray();
      Arrays.sort(ch);
      char[] ch1=str1.toCharArray();
      Arrays.sort(ch1);
      for(int i=0 ; i<ch.length ; i++){
        if(ch[i]!=ch1[i]){
          System.out.println("NO");
          flag++;
          break ;
        }
      }
      if(flag==0){
        System.out.println("YES");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class tasks {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ;
    var str1 : String ;
    var flag : int ; flag := 0 ;
    try (     str := br.readLine() ; 
     str := str+(br.readLine()) ; 
     str1 := br.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
    if (str->size() /= str1->size()) then (     OclFile["System.out"].println("NO") ) else (     var ch : Sequence(String) ; ch := str->characters() ;
     ch := ch->sort() ; 
    var ch1 : Sequence(String) ; ch1 := str1->characters() ;
    ch1 := ch1->sort() ; 
        var i : int ; i := 0 ; while i < ch->size() do ( (     if (ch[i+1] /= ch1[i+1]) then (     OclFile["System.out"].println("NO") ; 
     flag := flag + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag = 0) then (     OclFile["System.out"].println("YES") ) else skip ; 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int findMissingNo(int[] arr,int n){
    int val ;
    int nextval ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]<=0 || arr[i]>n)continue ;
      val=arr[i];
      while(arr[val-1]!=val){
        nextval=arr[val-1];
        arr[val-1]=val ;
        val=nextval ;
        if(val<=0 || val>n)break ;
      }
    }
    for(int i=0 ; i<n ; i++){
      if(arr[i]!=i+1){
        return i+1 ;
      }
    }
    return n+1 ;
  }
  public static void main(String[] args){
    int arr[]={
      2,3,7,6,8,-1,-10,15 };
      int arr_size=arr.length ;
      int missing=findMissingNo(arr,arr_size);
      System.out.println("The smallest positive"+" missing number is "+missing);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMissingNo( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var val : int ;
     var nextval : int ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] <= 0 or arr[i+1] > n) then     continue else skip ; 
     val := arr[i+1] ; 
     while (arr[val - 1+1] /= val) do (     nextval := arr[val - 1+1] ; 
     arr[val - 1+1] := val ; 
     val := nextval ; 
     if (val <= 0 or val > n) then     break else skip ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] /= i + 1) then (     return i + 1 ) else skip )  ;     i := i + 1 ) ; 
    return n + 1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,7,6,8,-1,-10,15} ;
     var arr_size : int ; arr_size := arr->size() ;
     var missing : int ; missing := findMissingNo(arr, arr_size) ;
     OclFile["System.out"].println("The smallest positive" + " missing number is " + missing) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void reduceArray(int arr[],int n,int K){
    Vector<Integer>vec=new Vector<Integer>();
    int size=0 ;
    int curr_ele=arr[0],curr_freq=1 ;
    for(int i=0 ; i<n ; i++){
      if(curr_ele==arr[i] && curr_freq<=K){
        vec.add(arr[i]);
        size++;
      }
      else if(curr_ele!=arr[i]){
        curr_ele=arr[i];
        vec.add(arr[i]);
        size++;
        curr_freq=1 ;
      }
      curr_freq++;
    }
    System.out.print("{");
    for(int i=0 ; i<size ; i++){
      System.out.print(vec.get(i)+",");
    }
    System.out.print("}");
  }
  public static void main(String[] args){
    int arr[]={
      1,1,1,2,2,2,3,3,3,3,3,3,4,5 };
      int n=arr.length ;
      int K=2 ;
      reduceArray(arr,n,K);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation reduceArray( arr : Sequence(int), n : int, K : int) : void
  pre: true
  post: true
  activity: (     var vec : Sequence(int) ; vec := Sequence{} ;
     var size : int ; size := 0 ;
    var curr_ele : int ; curr_ele := arr[0+1] ;
    var curr_freq : int ; curr_freq := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (curr_ele = arr[i+1] & curr_freq <= K) then (     vec := vec->including(arr[i+1]) ; 
     size := size + 1 ) else     if (curr_ele /= arr[i+1]) then (     curr_ele := arr[i+1] ; 
     vec := vec->including(arr[i+1]) ; 
     size := size + 1 ; 
     curr_freq := 1 ) else skip ; ;  
     curr_freq := curr_freq + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("{") ; 
        var i : int ; i := 0 ; while i < size do ( (     OclFile["System.out"].print(vec->at(i+1) + ",") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("}") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,1,2,2,2,3,3,3,3,3,3,4,5} ;
     var n : int ; n := arr->size() ;
     var K : int ; K := 2 ;
     execute reduceArray(arr, n, K) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int highestPowerof2(int n){
    int res=0 ;
    for(int i=n ; i>=1 ; i--){
      if((i &(i-1))==0){
        res=i ;
        break ;
      }
    }
    return res ;
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(highestPowerof2(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation highestPowerof2( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := n ; while i >= 1 do ( (     if ((MathLib.bitwiseAnd(i,(i - 1))) = 0) then (     res := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(highestPowerof2(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSetBits(int n){
    n++;
    int powerOf2=2 ;
    int cnt=n/2 ;
    while(powerOf2<=n){
      int totalPairs=n/powerOf2 ;
      cnt+=(totalPairs/2)*powerOf2 ;
      cnt+=(totalPairs % 2==1)?(n % powerOf2): 0 ;
      powerOf2<<=1 ;
    }
    return cnt ;
  }
  public static void main(String[] args){
    int n=14 ;
    System.out.println(countSetBits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     n := n + 1 ; 
     var powerOf2 : int ; powerOf2 := 2 ;
    var cnt : int ; cnt := n / 2 ;
    while (powerOf2 <= n) do (     var totalPairs : int ; totalPairs := n / powerOf2 ;
     cnt := cnt+((totalPairs / 2) * powerOf2) ; 
     cnt := cnt+(if (totalPairs mod 2 = 1) then (n mod powerOf2) else 0 endif) ; 
     powerOf2 := powerOf2*(2->pow(1)) ) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 14 ;
     OclFile["System.out"].println(countSetBits(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int GCD(int a,int b){
    if(b==0)return a ;
    return GCD(b,a % b);
  }
  static int findReachable(int[] arr,int D,int A,int B,int n){
    int gcd_AB=GCD(A,B);
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if((arr[i]-D)% gcd_AB==0)count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      4,5,6,7,8,9 };
      int n=arr.length ;
      int D=4,A=4,B=6 ;
      System.out.println(findReachable(arr,D,A,B,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation GCD( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return GCD(b, a mod b) );
  static   operation findReachable( arr : Sequence(int), D : int, A : int, B : int, n : int) : int
  pre: true
  post: true
  activity: (     var gcd_AB : int ; gcd_AB := GCD(A, B) ;
     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if ((arr[i+1] - D) mod gcd_AB = 0) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,5,6,7,8,9} ;
     var n : int ; n := arr->size() ;
     var D : int ; D := 4 ;
    var A : int ; A := 4 ;
    var B : int ; B := 6 ;
     OclFile["System.out"].println(findReachable(arr, D, A, B, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.LinkedList ;
import java.util.Map ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  static Queue<String>queue=new LinkedList<>();
  static Map<String,Integer>map=new HashMap<>();
  static String str ;
  static int[][] d={
    {
      0,1,4 },{
-1,1,4 },{
-1,1,4 },{
-1,0,4 },{
              0,1,-4 },{
-1,1,-4 },{
-1,1,-4 },{
-1,0,-4 }
                  };
                  static void bfs(){
                    while(! queue.isEmpty()){
                      String str1=queue.remove();
                      int point=map.get(str1);
                      String str2="" ;
                      for(int i=0 ; i<8 ; i++){
                        if(str1.charAt(i)=='0'){
                          for(int j=0 ; j<3 ; j++){
                            char change=str1.charAt(i+d[i][j]);
                            str2=str1.replace('0','9');
                            str2=str2.replace(change,'0');
                            str2=str2.replace('9',change);
                            if(map.get(str2)==null){
                              map.put(str2,point+1);
                              queue.add(str2);
                            }
                          }
                          break ;
                        }
                      }
                    }
                  }
                  public static void main(String args[]){
                    try(Scanner sc=new Scanner(System.in)){
                      queue.add("01234567");
                      map.put("01234567",0);
                      bfs();
                      while(sc.hasNext()){
                        String s=sc.nextLine();
                        String[] token=s.split(" ");
                        str="" ;
                        for(String t : token){
                          str+=t ;
                        }
                        System.out.println(map.get(str));
                      }
                    }
                  }
                }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute queue : Sequence(String) := Sequence{};
  static   attribute map : Map(String,int) := Map{};
  static   attribute str : String;
  static   attribute d : Sequence(Sequence(int)) := Sequence{Sequence{0,1,4},Sequence{-1,1,4},Sequence{-1,1,4},Sequence{-1,0,4},Sequence{0,1,-4},Sequence{-1,1,-4},Sequence{-1,1,-4},Sequence{-1,0,-4}};
  static   operation bfs() : void
  pre: true
  post: true
  activity: (     while (not(queue->isEmpty())) do (     var str1 : String ; str1 := queue.remove() ;
     var point : int ; point := map->at(str1) ;
     var str2 : String ; str2 := "" ;
         var i : int ; i := 0 ; while i < 8 do ( (     if (str1->at(i+1) = '0') then (         var j : int ; j := 0 ; while j < 3 do ( (     var change : String ; change := str1->at(i + d[i+1][j+1]+1) ;
     str2 := str1.replace('0', '9') ; 
    str2 := str2.replace(change, '0') ; 
    str2 := str2.replace('9', change) ; 
    if (map->at(str2) = null) then (     map := map->union(Map{str2 |-> point + 1}) ; 
     queue := queue->including(str2) ) else skip ; 
 )  ;     j := j + 1 ) ; 
     break ) else skip )  ;     i := i + 1 ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     queue := queue->including("01234567") ; 
     map := map->union(Map{"01234567" |-> 0}) ; 
     execute bfs() ; 
     while (sc.hasNext()) do (     var s : String ; s := sc.nextLine() ;
     var token : Sequence(String) ; token := s->split(" ") ;
    str := "" ; 
    for (t : token) do ( (     str := str+(t) )  ) ; 
    OclFile["System.out"].println(map->at(str)) ; 
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static boolean judgeSquareSum(int c){
    for(long a=0 ; a*a<=c ; a++){
      int b=c-(int)(a*a);
      if(binary_search(0,b,b))return true ;
    }
    return false ;
  }
  public static boolean binary_search(long s,long e,int n){
    if(s>e)return false ;
    long mid=s+(e-s)/2 ;
    if(mid*mid==n)return true ;
    if(mid*mid>n)return binary_search(s,mid-1,n);
    return binary_search(mid+1,e,n);
  }
  public static void main(String argc[]){
    int c=17 ;
    System.out.println(judgeSquareSum(c));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation judgeSquareSum( c : int) : boolean
  pre: true
  post: true
  activity: (         var a : long ; a := 0 ; while a * a <= c do ( (     var b : int ; b := c - (a * a)->oclAsType(int) ;
     if (binary_search(0, b, b)) then     return true else skip )  ;     a := a + 1 ) ; 
     return false );
  static   operation binary_search( s : long, e : long, n : int) : boolean
  pre: true
  post: true
  activity: (     if (s > e) then     return false else skip ; 
     var mid : long ; mid := s + (e - s) / 2 ;
    if (mid * mid = n) then     return true else skip ; 
    if (mid * mid > n) then     return binary_search(s, mid - 1, n) else skip ; 
    return binary_search(mid + 1, e, n) 
 );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var c : int ; c := 17 ;
     OclFile["System.out"].println(judgeSquareSum(c)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final int max_size=100 ;
    final char flag=1 ;
    char map[][]=new char[max_size][max_size];
    Scanner scanner=new Scanner(System.in);
    int w,h ;
    h=scanner.nextInt();
    w=scanner.nextInt();
    scanner.nextLine();
    while(w!=0 || h!=0){
      map=new char[max_size][max_size];
      for(int i=0 ; i<h ; i++){
        String s=scanner.nextLine();
        map[i]=s.toCharArray();
      }
      int x=0 ;
      int y=0 ;
      while(map[y][x]!=flag && map[y][x]!='.'){
        switch(map[y][x]){
          case '>' : map[y][x]=flag ;
          x++;
          break ;
          case 'v' : map[y][x]=flag ;
          y++;
          break ;
          case '<' : map[y][x]=flag ;
          x--;
          break ;
          case '^' : map[y][x]=flag ;
          y--;
          break ;
        }
      }
      if(map[y][x]==flag){
        System.out.println("LOOP");
      }
      else {
        System.out.println(String.format("%d %d",x,y));
      }
      h=scanner.nextInt();
      w=scanner.nextInt();
      scanner.nextLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var max_size : int ; max_size := 100 ;
     var flag : String ; flag := 1 ;
    var map : Sequence(Sequence(String)) ; map := Integer.subrange(1,max_size)->collect(Integer.subrange(1,max_size)->collect(0)) ;
    var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var w : int ;
    var h : int ;
    h := scanner.getCurrent()->toInteger() ; 
    w := scanner.getCurrent()->toInteger() ; 
    skip ; 
    while (w /= 0 or h /= 0) do (     map := Integer.subrange(1,max_size)->collect(Integer.subrange(1,max_size)->collect(0)) ; 
         var i : int ; i := 0 ; while i < h do ( (     var s : String ; s := scanner.nextLine() ;
     map[i+1] := s->characters() )  ;     i := i + 1 ) ; 
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    while (map[y+1][x+1] /= flag & map[y+1][x+1] /= '.') do ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (map[y+1][x+1]) ; 
       if _switchval = '>' then
     map[y+1][x+1] := flag ; 
    x := x + 1 ; 
    break 
   else skip ;
       if _switchval = 'v' then
     map[y+1][x+1] := flag ; 
    y := y + 1 ; 
    break 
   else skip ;
       if _switchval = '<' then
     map[y+1][x+1] := flag ; 
    x := x - 1 ; 
    break 
   else skip ;
       if _switchval = '^' then
     map[y+1][x+1] := flag ; 
    y := y - 1 ; 
    break 
   else skip ;
 )
 ) ; 
    if (map[y+1][x+1] = flag) then (     OclFile["System.out"].println("LOOP") ) else (     OclFile["System.out"].println(StringLib.format("%d %d",Sequence{x,y})) ) ;  
    h := scanner.getCurrent()->toInteger() ; 
    w := scanner.getCurrent()->toInteger() ; 
    skip ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int i,j,h,w ;
    char[][] f ;
    String s ;
    int[][] v ;
    for(; ; ){
      h=sc.nextInt();
      w=sc.nextInt();
      if(h==0 && w==0)break ;
      f=new char[h][w];
      v=new int[h][w];
      for(i=0 ; i<h ; i++){
        s=sc.next();
        for(j=0 ; j<w ; j++)f[i][j]=s.charAt(j);
      }
      i=0 ;
      j=0 ;
      v[0][0]=1 ;
      s="GO" ;
      for(; ; ){
        if(f[i][j]=='>'){
          v[i][++j]++;
          if(v[i][j]==2){
            s="LOOP" ;
            break ;
          }
        }
        else if(f[i][j]=='<'){
          v[i][--j]++;
          if(v[i][j]==2){
            s="LOOP" ;
            break ;
          }
        }
        else if(f[i][j]=='^'){
          v[--i][j]++;
          if(v[i][j]==2){
            s="LOOP" ;
            break ;
          }
        }
        else if(f[i][j]=='v'){
          v[++i][j]++;
          if(v[i][j]==2){
            s="LOOP" ;
            break ;
          }
        }
        else break ;
      }
      if("LOOP".equals(s))out.println(s);
      else out.println(j+" "+i);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var i : int ;
    var j : int ;
    var h : int ;
    var w : int ;
    var f : Sequence(Sequence(String)) ;
    var s : String ;
    var v : Sequence(Sequence(int)) ;
      while true do ( (     h := sc.nextInt() ; 
     w := sc.nextInt() ; 
    if (h = 0 & w = 0) then     break else skip ; 
    f := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ; 
    v := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ; 
        i := 0 ; while i < h do ( (     s := sc.next() ; 
         j := 0 ; while j < w do (     f[i+1][j+1] := s->at(j+1) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    i := 0 ; 
    j := 0 ; 
    v[0+1][0+1] := 1 ; 
    s := "GO" ; 
      while true do ( (     if (f[i+1][j+1] = '>') then (     v[i+1][j+1] := v[i+1][j+1] + 1 ; 
     if (v[i+1][j+1] = 2) then (     s := "LOOP" ; 
     break ) else skip ) else     if (f[i+1][j+1] = '<') then (     v[i+1][j+1] := v[i+1][j+1] + 1 ; 
     if (v[i+1][j+1] = 2) then (     s := "LOOP" ; 
     break ) else skip ) else     if (f[i+1][j+1] = '^') then (     v[i+1][j+1] := v[i+1][j+1] + 1 ; 
     if (v[i+1][j+1] = 2) then (     s := "LOOP" ; 
     break ) else skip ) else     if (f[i+1][j+1] = 'v') then (     v[i+1][j+1] := v[i+1][j+1] + 1 ; 
     if (v[i+1][j+1] = 2) then (     s := "LOOP" ; 
     break ) else skip ) else     break ;  ;  ;  )  ) ; 
    if ("LOOP" = s) then     out.println(s) else     out.println(j + " " + i) ; ;  
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.awt.geom.Point2D ;
import java.io.BufferedReader ;
import java.util.*;
public class Main {
  public Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new aoj0104().doIt();
  }
  class aoj0104 {
    int map[][];
    char ctr[]={
      '>','<','^','v','.' };
      int xm[]={
        1,-1,0,0 };
        int ym[]={
          0,0,-1,1 };
          String ans="" ;
          String dfs(int y,int x){
            if(map[y][x]==4)ans=x+" "+y ;
            else if(map[y][x]==-1)ans="LOOP" ;
            for(int i=0 ; i<4 ; i++){
              if(map[y][x]==i){
                map[y][x]=-1 ;
                dfs(y+ym[i],x+xm[i]);
              }
            }
            return ans ;
          }
          void doIt(){
            while(true){
              int y=sc.nextInt();
              int x=sc.nextInt();
              if(y+x==0)break ;
              map=new int[y][x];
              for(int i=0 ; i<y ; i++){
                String str=sc.next();
                char[] c=str.toCharArray();
                for(int j=0 ; j<x ; j++){
                  for(int k=0 ; k<5 ; k++){
                    if(c[j]==ctr[k])map[i][j]=k ;
                  }
                }
              }
              System.out.println(dfs(0,0));
            }
          }
        }
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     aoj0104.newaoj0104().doIt() );
 class aoj0104 {
   attribute map : Sequence(Sequence(int));
   attribute ctr : String := Sequence{'>','<','^','v','.'};
   attribute xm : int := Sequence{1,-1,0,0};
   attribute ym : int := Sequence{0,0,-1,1};
   attribute ans : String := "";
   operation dfs( y : int, x : int) : String
  pre: true
  post: true
  activity: (     if (map[y+1][x+1] = 4) then     ans := x + " " + y else     if (map[y+1][x+1] = -1) then     ans := "LOOP" ; else skip ; ;  
         var i : int ; i := 0 ; while i < 4 do ( (     if (map[y+1][x+1] = i) then (     map[y+1][x+1] := -1 ; 
     execute dfs(y + ym[i+1], x + xm[i+1]) ) else skip )  ;     i := i + 1 ) ; 
     return ans );
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (true) do (     var y : int ; y := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    if (y + x = 0) then     break else skip ; 
    map := Integer.subrange(1,y)->collect(Integer.subrange(1,x)->collect(0)) ; 
        var i : int ; i := 0 ; while i < y do ( (     var str : String ; str := sc.getCurrent() ;
     var c : Sequence(String) ; c := str->characters() ;
         var j : int ; j := 0 ; while j < x do ( (         var k : int ; k := 0 ; while k < 5 do ( (     if (c[j+1] = ctr[k+1]) then     map[i+1][j+1] := k ; else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dfs(0, 0)) ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public char[][] tile ;
  public int[][] movedTile ;
  public static void main(String[] args)throws IOException {
    BufferedReader bReader=new BufferedReader(new InputStreamReader(System.in));
    String inputedStr ;
    while(! "0 0".equals(inputedStr=bReader.readLine())){
      boolean loopFlag=true ;
      String[] editedstr=inputedStr.split(" ");
      int X=Integer.parseInt(editedstr[0]);
      int Y=Integer.parseInt(editedstr[1]);
      char[][] tile=new char[X][Y];
      int[][] movedTile=new int[X][Y];
      int xcurrentloc=0 ;
      int ycurrentloc=0 ;
      for(int i=0 ; i<X ; i++){
        tile[i]=bReader.readLine().toCharArray();
      }
      while(movedTile[xcurrentloc][ycurrentloc]!=1){
        if(tile[xcurrentloc][ycurrentloc]=='>'){
          movedTile[xcurrentloc][ycurrentloc++]=1 ;
        }
        else if(tile[xcurrentloc][ycurrentloc]=='<'){
          movedTile[xcurrentloc][ycurrentloc--]=1 ;
        }
        else if(tile[xcurrentloc][ycurrentloc]=='v'){
          movedTile[xcurrentloc++][ycurrentloc]=1 ;
        }
        else if(tile[xcurrentloc][ycurrentloc]=='^'){
          movedTile[xcurrentloc--][ycurrentloc]=1 ;
        }
        else if(tile[xcurrentloc][ycurrentloc]=='.'){
          loopFlag=false ;
          break ;
        }
        else {
        }
      }
      if(loopFlag){
        System.out.println("LOOP");
        loopFlag=true ;
      }
      else {
        System.out.println(ycurrentloc+" "+xcurrentloc);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute tile : Sequence(Sequence(String));
   attribute movedTile : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bReader : OclFile ; bReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var inputedStr : String ;
     while (not("0 0" = inputedStr)) do (     var loopFlag : boolean ; loopFlag := true ;
     var editedstr : Sequence(String) ; editedstr := inputedStr->split(" ") ;
    var X : int ; X := (editedstr[0+1])->toInteger() ;
    var Y : int ; Y := (editedstr[1+1])->toInteger() ;
    var tile : Sequence(Sequence(String)) ; tile := Integer.subrange(1,X)->collect(Integer.subrange(1,Y)->collect(0)) ;
    var movedTile : Sequence(Sequence(int)) ; movedTile := Integer.subrange(1,X)->collect(Integer.subrange(1,Y)->collect(0)) ;
    var xcurrentloc : int ; xcurrentloc := 0 ;
    var ycurrentloc : int ; ycurrentloc := 0 ;
        var i : int ; i := 0 ; while i < X do ( (     tile[i+1] := bReader.readLine()->characters() )  ;     i := i + 1 ) ; 
    while (movedTile[xcurrentloc+1][ycurrentloc+1] /= 1) do (     if (tile[xcurrentloc+1][ycurrentloc+1] = '>') then (      movedTile[xcurrentloc+1][ycurrentloc+1] := 1  ; ycurrentloc := ycurrentloc + 1 ) else     if (tile[xcurrentloc+1][ycurrentloc+1] = '<') then (      movedTile[xcurrentloc+1][ycurrentloc+1] := 1  ; ycurrentloc := ycurrentloc - 1 ) else     if (tile[xcurrentloc+1][ycurrentloc+1] = 'v') then (      movedTile[xcurrentloc+1][ycurrentloc+1] := 1  ; xcurrentloc := xcurrentloc + 1 ) else     if (tile[xcurrentloc+1][ycurrentloc+1] = '^') then (      movedTile[xcurrentloc+1][ycurrentloc+1] := 1  ; xcurrentloc := xcurrentloc - 1 ) else     if (tile[xcurrentloc+1][ycurrentloc+1] = '.') then (     loopFlag := false ; 
     break ) else skip ;  ;  ;  ;  ) ; 
    if (loopFlag) then (     OclFile["System.out"].println("LOOP") ; 
     loopFlag := true ) else (     OclFile["System.out"].println(ycurrentloc + " " + xcurrentloc) ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.System.*;
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static char[] d={
    '>','<','^','v' };
    static int[] dx={
      1,-1,0,0 };
      static int[] dy={
        0,0,-1,1 };
        public static void main(String[] args){
          while(sc.hasNext()){
            int h=sc.nextInt();
            int w=sc.nextInt();
            if(h==0 && w==0)break ;
            char[][] map=new char[h][w];
            for(int i=0 ; i<h ; i++){
              String s=sc.next();
              for(int j=0 ; j<w ; j++){
                map[i][j]=s.charAt(j);
              }
            }
            boolean[][] memo=new boolean[h][w];
            int x=0 ;
            int y=0 ;
            boolean loop=false ;
            memo[y][x]=true ;
            loop1 : while(map[y][x]!='.'){
              for(int i=0 ; i<4 ; i++){
                if(map[y][x]==d[i]){
                  x+=dx[i];
                  y+=dy[i];
                  if(memo[y][x]){
                    loop=true ;
                    break loop1 ;
                  }
                  else memo[y][x]=true ;
                }
              }
            }
            out.println(loop ? "LOOP" : x+" "+y);
          }
        }
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute d : Sequence(String) := Sequence{'>','<','^','v'};
  static   attribute dx : Sequence(int) := Sequence{1,-1,0,0};
  static   attribute dy : Sequence(int) := Sequence{0,0,-1,1};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     var h : int ; h := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
    if (h = 0 & w = 0) then     break else skip ; 
    var map : Sequence(Sequence(String)) ; map := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (     var s : String ; s := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < w do ( (     map[i+1][j+1] := s->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var memo : Sequence(Sequence(boolean)) ; memo := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(false)) ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var loop : boolean ; loop := false ;
    memo[y+1][x+1] := true ; 
    while (map[y+1][x+1] /= '.') do (         var i : int ; i := 0 ; while i < 4 do ( (     if (map[y+1][x+1] = d[i+1]) then (     x := x+(dx[i+1]) ; 
     y := y+(dy[i+1]) ; 
     if (memo[y+1][x+1]) then (     loop := true ; 
     break ) else     memo[y+1][x+1] := true ; ) else skip )  ;     i := i + 1 ) ) ; 
    out.println(if loop then "LOOP" else x + " " + y endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Set<String>set=new HashSet<String>();
    for(int i=0 ; i<n ; i++){
      String s1=sc.next();
      String s2=sc.next();
      if(s1.equals("insert")){
        set.add(s2);
      }
      else if(set.contains(s2)){
        System.out.println("yes");
      }
      else {
        System.out.println("no");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var set : Set(String) ; set := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     var s1 : String ; s1 := sc.getCurrent() ;
     var s2 : String ; s2 := sc.getCurrent() ;
     if (s1 = "insert") then (     set := set->including(s2) ) else     if (set->includes(s2)) then (     OclFile["System.out"].println("yes") ) else (     OclFile["System.out"].println("no") ) ;  )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.io.IOException ;
import java.util.Set ;
import java.util.TreeSet ;
public class Main {
  @ SuppressWarnings("unchecked")public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    int n=Integer.parseInt(br.readLine());
    Set<String>dictionary=new TreeSet<String>();
    while(n-->0){
      String[] command=br.readLine().split(" ");
      switch(command[0]){
        case "insert" : dictionary.add(command[1]);
        break ;
        case "find" : bw.append(dictionary.contains(command[1])? "yes\n" : "no\n");
        break ;
      }
    }
    bw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var dictionary : Set(String) ; dictionary := Set{} ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var command : Sequence(String) ; command := br.readLine()->split(" ") ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (command[0+1]) ; 
       if _switchval = "insert" then
     dictionary := dictionary->including(command[1+1]) ; 
    break 
   else skip ;
       if _switchval = "find" then
     skip ; 
    break 
   else skip ;
 )
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static final int M=48828125 ;
  public static boolean[] H=new boolean[M];
  public static void main(String[] args){
    try {
      BufferedReader kb=new BufferedReader(new InputStreamReader(System.in));
      int n=Integer.parseInt(kb.readLine());
      String[] str=new String[3];
      for(int i=0 ; i<n ; i++){
        str=kb.readLine().split(" ");
        if("insert".equals(str[0])){
          insert(str[1]);
        }
        else if("find".equals(str[0])){
          if(find(str[1])){
            System.out.println("yes");
          }
          else {
            System.out.println("no");
          }
        }
      }
    }
    catch(IOException e){
      System.err.println(e);
    }
  }
  public static int getChar(char ch){
    if(ch=='A'){
      return 1 ;
    }
    else if(ch=='C'){
      return 2 ;
    }
    else if(ch=='G'){
      return 3 ;
    }
    else if(ch=='T'){
      return 4 ;
    }
    return 0 ;
  }
  public static int getKey(String str){
    int i ;
    int key=0,base=1 ;
    char[] str2=str.toCharArray();
    for(i=0 ; i<str.length(); i++){
      key+=base*(getChar(str2[i]));
      base*=5 ;
    }
    return key ;
  }
  public static boolean find(String str){
    if(true==H[getKey(str)]){
      return true ;
    }
    else {
      return false ;
    }
  }
  public static void insert(String str){
    H[getKey(str)]=true ;
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute M : int := 48828125;
  static   attribute H : Sequence(boolean) := Integer.subrange(1,M)->collect(false);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var kb : OclFile ; kb := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (kb.readLine())->toInteger() ;
     var str : Sequence(String) ; str := Integer.subrange(1,3)->collect(null) ;
         var i : int ; i := 0 ; while i < n do ( (     str := kb.readLine()->split(" ") ; 
     if ("insert" = str[0+1]) then (     execute insert(str[1+1]) ) else     if ("find" = str[0+1]) then (     if (find(str[1+1])) then (     OclFile["System.out"].println("yes") ) else (     OclFile["System.out"].println("no") ) ) else skip ; )  ;     i := i + 1 ) )   catch (e : IOException) do (     OclFile["System.err"].println(e) )
 );
  static   operation getChar( ch : String) : int
  pre: true
  post: true
  activity: (     if (ch = 'A') then (     return 1 ) else     if (ch = 'C') then (     return 2 ) else     if (ch = 'G') then (     return 3 ) else     if (ch = 'T') then (     return 4 ) else skip ; ;  ;  ;  
     return 0 );
  static   operation getKey( str : String) : int
  pre: true
  post: true
  activity: (     var i : int ;
     var key : int ; key := 0 ;
    var base : int ; base := 1 ;
    var str2 : Sequence(String) ; str2 := str->characters() ;
        i := 0 ; while i < str->size() do ( (     key := key+(base * (getChar(str2[i+1]))) ; 
     base := base*(5) )  ;     i := i + 1 ) ; 
    return key 
 );
  static   operation find( str : String) : boolean
  pre: true
  post: true
  activity: (     if (true = H[getKey(str)+1]) then (     return true ) else (     return false ) );
  static   operation insert( str : String) : void
  pre: true
  post: true
  activity: (     H[getKey(str)+1] := true ; 
     return );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.LinkedList ;
import java.util.Map ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  private static int[] d=new int[] {
    1,-1,4,-4 };
    private static Map<String,Integer>map ;
    private static String state ;
    public static void main(String[] a){
      map=new HashMap<String,Integer>();
      bfs();
      Scanner sc=new Scanner(System.in);
      while(sc.hasNext()){
        StringBuilder sb=new StringBuilder();
        for(int i=0 ; i<8 ; i++){
          sb.append(sc.nextInt());
        }
        state=sb.toString();
        System.out.println(map.get(state));
      }
      sc.close();
    }
    private static int getInitialPos(String str){
      return str.indexOf('0');
    }
    private static void bfs(){
      Queue<String>queue=new LinkedList<String>();
      queue.add("01234567");
      map.put("01234567",0);
      int initialPos=0 ;
      while(queue.size()>0){
        String p=queue.poll();
        initialPos=getInitialPos(p);
        for(int i=0 ; i<4 ; i++){
          int pos=initialPos+d[i];
          if(pos<0 || pos>=8){
            continue ;
          }
          if(initialPos==3 && pos==4){
            continue ;
          }
          if(initialPos==4 && pos==3){
            continue ;
          }
          char[] tmp=p.toCharArray();
          tmp[initialPos]=p.charAt(pos);
          tmp[pos]='0' ;
          String newStr=new String(tmp);
          if(map.get(newStr)==null){
            queue.add(newStr);
            map.put(newStr,map.get(p)+1);
          }
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute d : Sequence(int) := Sequence{1,-1,4,-4};
  static   attribute map : Map(String,int);
  static   attribute state : String;
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     map := Map{} ; 
     execute bfs() ; 
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (sc.hasNext()) do (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < 8 do ( (     sb := sb + StringLib.newString(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
     state := sb+"" ; 
     OclFile["System.out"].println(map->at(state)) ) ; 
    skip ; 
 );
  static   operation getInitialPos( str : String) : int
  pre: true
  post: true
  activity: (     return str->indexOf('0')-1 );
  static   operation bfs() : void
  pre: true
  post: true
  activity: (     var queue : Sequence(String) ; queue := Sequence{} ;
     queue := queue->including("01234567") ; 
    map := map->union(Map{"01234567" |-> 0}) ; 
    var initialPos : int ; initialPos := 0 ;
    while (queue->size() > 0) do (     var p : String ; p := queue->min() ;
     initialPos := getInitialPos(p) ; 
         var i : int ; i := 0 ; while i < 4 do ( (     var pos : int ; pos := initialPos + d[i+1] ;
     if (pos < 0 or pos >= 8) then (     continue ) else skip ; 
    if (initialPos = 3 & pos = 4) then (     continue ) else skip ; 
    if (initialPos = 4 & pos = 3) then (     continue ) else skip ; 
    var tmp : Sequence(String) ; tmp := p->characters() ;
    tmp[initialPos+1] := p->at(pos+1) ; 
    tmp[pos+1] := '0' ; 
    var newStr : String ; newStr := StringLib.newString(tmp) ;
    if (map->at(newStr) = null) then (     queue := queue->including(newStr) ; 
     map := map->union(Map{newStr |-> map->at(p) + 1}) ) else skip ; 
 )  ;     i := i + 1 ) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  final static int MOD=1000000007 ;
  final static int INF=1000000000 ;
  public static void main(String[] args)throws IOException {
    NScanner sc=new NScanner(System.in);
    int n=sc.nextInt();
    HashSet<String>dic=new HashSet<String>();
    for(int i=0 ; i<n ; ++i){
      String com=sc.next();
      String str=sc.next();
      if(com.equals("insert")){
        dic.add(str);
      }
      else {
        System.out.println(dic.contains(str)? "yes" : "no");
      }
    }
  }
}
class NScanner {
  private BufferedReader br ;
  private StringTokenizer tok ;
  public NScanner(InputStream is)throws IOException {
    br=new BufferedReader(new InputStreamReader(is));
    getLine();
  }
  private void getLine()throws IOException {
    while(tok==null || ! hasNext()){
      tok=new StringTokenizer(br.readLine());
    }
  }
  public boolean hasNext(){
    return tok.hasMoreTokens();
  }
  public String next()throws IOException {
    if(hasNext()){
      return tok.nextToken();
    }
    else {
      getLine();
      return tok.nextToken();
    }
  }
  public int nextInt()throws IOException {
    if(hasNext()){
      return Integer.parseInt(tok.nextToken());
    }
    else {
      getLine();
      return Integer.parseInt(tok.nextToken());
    }
  }
  public long nextLong()throws IOException {
    if(hasNext()){
      return Long.parseLong(tok.nextToken());
    }
    else {
      getLine();
      return Long.parseLong(tok.nextToken());
    }
  }
  public double nextDouble()throws IOException {
    if(hasNext()){
      return Double.parseDouble(tok.nextToken());
    }
    else {
      getLine();
      return Double.parseDouble(tok.nextToken());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : int := 1000000007;
  static   attribute INF : int := 1000000000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : NScanner ; sc := NScanner.newNScanner(OclFile["System.in"]) ;
     var n : int ; n := sc.nextInt() ;
     var dic : Set(String) ; dic := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     var com : String ; com := sc.next() ;
     var str : String ; str := sc.next() ;
     if (com = "insert") then (     dic := dic->including(str) ) else (     OclFile["System.out"].println(if dic->includes(str) then "yes" else "no" endif) ) )  ;     i := i + 1 ) );
}
class NScanner {
   attribute br : OclFile;
   attribute tok : OclIterator;
   static operation newNScanner( is : OclFile) : NScanner
  pre: true
  post: true
  activity:
  ( var self : NScanner ;
    self := createNScanner();
    self.initialise(is);
    return self );
  operation initialise( is : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(is)) ; 
     execute getLine() );
   operation getLine() : void
  pre: true
  post: true
  activity: (     while (tok = null or not(hasNext())) do (     tok := OclIterator.newOclIterator_String(br.readLine()) ) );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return tok.hasNext() );
   operation next() : String
  pre: true
  post: true
  activity: (     if (hasNext()) then (     return tok.next() ) else (     execute getLine() ; 
     return tok.next() ) );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     if (hasNext()) then (     return (tok.next())->toInteger() ) else (     execute getLine() ; 
     return (tok.next())->toInteger() ) );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     if (hasNext()) then (     return (tok.next())->toLong() ) else (     execute getLine() ; 
     return (tok.next())->toLong() ) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     if (hasNext()) then (     return (tok.next())->toReal() ) else (     execute getLine() ; 
     return (tok.next())->toReal() ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    final int len=Integer.parseInt(sc.nextLine());
    int[] hash=new int[10000003];
    for(int i=0 ; i<len ; i++){
      String[] command=sc.nextLine().split(" ");
      int key=Node.convertToInt(command[1])*3 % 10000003 ;
      switch(command[0]){
        case "insert" : hash[key]=1 ;
        break ;
        case "find" : String res=hash[key]==1 ? "yes" : "no" ;
        System.out.println(res);
        break ;
      }
    }
    sc.close();
  }
}
class Node {
  public static int convertToInt(String str){
    int len=str.length();
    int converted=0 ;
    for(int i=0 ; i<len ; i++){
      converted+=toInt(str.charAt(i))*Math.pow(5,i);
    }
    return converted ;
  }
  private static int toInt(char c){
    int result=-1 ;
    switch(c){
      case 'A' : result=3 ;
      break ;
      case 'C' : result=2 ;
      break ;
      case 'G' : result=1 ;
      break ;
      case 'T' : result=4 ;
      break ;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := (sc.nextLine())->toInteger() ;
    var hash : Sequence(int) ; hash := Integer.subrange(1,10000003)->collect(0) ;
        var i : int ; i := 0 ; while i < len do ( (     var command : Sequence(String) ; command := sc.nextLine()->split(" ") ;
     var key : int ; key := Node.convertToInt(command[1+1]) * 3 mod 10000003 ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (command[0+1]) ; 
       if _switchval = "insert" then
     hash[key+1] := 1 ; 
    break 
   else skip ;
       if _switchval = "find" then
     var res : String ; res := if hash[key+1] = 1 then "yes" else "no" endif ;
    OclFile["System.out"].println(res) ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
class Node {
  static   operation convertToInt( str : String) : int
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     var converted : int ; converted := 0 ;
         var i : int ; i := 0 ; while i < len do ( (     converted := converted+(toInt(str->at(i+1)) * 5->pow(i)) )  ;     i := i + 1 ) ; 
     return converted );
  static   operation toInt( c : String) : int
  pre: true
  post: true
  activity: (     var result : int ; result := -1 ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
       if _switchval = 'A' then
     result := 3 ; 
    break 
   else skip ;
       if _switchval = 'C' then
     result := 2 ; 
    break 
   else skip ;
       if _switchval = 'G' then
     result := 1 ; 
    break 
   else skip ;
       if _switchval = 'T' then
     result := 4 ; 
    break 
   else skip ;
 )
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static int subset(int ar[],int n){
    int res=0 ;
    Arrays.sort(ar);
    for(int i=0 ; i<n ; i++){
      int count=1 ;
      for(; i<n-1 ; i++){
        if(ar[i]==ar[i+1])count++;
        else break ;
      }
      res=Math.max(res,count);
    }
    return res ;
  }
  public static void main(String argc[]){
    int arr[]={
      5,6,9,3,4,3,4 };
      int n=7 ;
      System.out.println(subset(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation subset( ar : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     ar := ar->sort() ; 
         var i : int ; i := 0 ; while i < n do ( (     var count : int ; count := 1 ;
       while i < n - 1 do ( (     if (ar[i+1] = ar[i + 1+1]) then     count := count + 1 ; else     break )  ;     i := i + 1 ) ; 
     res := Set{res, count}->max() )  ;     i := i + 1 ) ; 
     return res );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,6,9,3,4,3,4} ;
     var n : int ; n := 7 ;
     OclFile["System.out"].println(subset(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int k=scanner.nextInt();
    int c=scanner.nextInt();
    scanner.nextLine();
    char[] chars=scanner.nextLine().toCharArray();
    boolean[] canWork=new boolean[n];
    for(int i=0 ; i<n ; i++){
      canWork[i]=chars[i]=='o' ;
    }
    if(c==0){
      int count=0 ;
      for(boolean b : canWork)if(b)count++;
      if(k==count){
        for(int i=0 ; i<n ; i++){
          if(canWork[i]){
            System.out.println(i+1);
          }
        }
      }
      return ;
    }
    else {
      int[] lg=new int[k];
      int[] rg=new int[k];
      int counter=0 ;
      int i=0 ;
      while(counter<k){
        while(! canWork[i])i++;
        lg[counter]=i ;
        i+=c+1 ;
        counter++;
      }
      counter=k-1 ;
      i=n-1 ;
      while(counter>=0){
        while(! canWork[i])i--;
        rg[counter]=i ;
        i-=c+1 ;
        counter--;
      }
      for(int j=0 ; j<k ; j++){
        if(lg[j]==rg[j])System.out.println(lg[j]+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    skip ; 
    var chars : Sequence(String) ; chars := scanner.nextLine()->characters() ;
    var canWork : Sequence(boolean) ; canWork := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     canWork[i+1] := chars[i+1] = 'o' )  ;     i := i + 1 ) ; 
    if (c = 0) then (     var count : int ; count := 0 ;
     for (b : canWork) do (     if (b) then     count := count + 1 ; else skip ;  ) ; 
     if (k = count) then (         var i : int ; i := 0 ; while i < n do ( (     if (canWork[i+1]) then (     OclFile["System.out"].println(i + 1) ) else skip )  ;     i := i + 1 ) ) else skip ; 
     return ) else (     var lg : Sequence(int) ; lg := Integer.subrange(1,k)->collect(0) ;
     var rg : Sequence(int) ; rg := Integer.subrange(1,k)->collect(0) ;
    var counter : int ; counter := 0 ;
    var i : int ; i := 0 ;
    while (counter < k) do (     while (not(canWork[i+1])) do     i := i + 1 ; ; 
     lg[counter+1] := i ; 
     i := i+(c + 1) ; 
     counter := counter + 1 ) ; 
    counter := k - 1 ; 
    i := n - 1 ; 
    while (counter >= 0) do (     while (not(canWork[i+1])) do     i := i - 1 ; ; 
     rg[counter+1] := i ; 
     i := i-(c + 1) ; 
     counter := counter - 1 ) ; 
        var j : int ; j := 0 ; while j < k do ( (     if (lg[j+1] = rg[j+1]) then     OclFile["System.out"].println(lg[j+1] + 1) ; else skip )  ;     j := j + 1 ) ; 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.Comparator ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    EYutori solver=new EYutori();
    solver.solve(1,in,out);
    out.close();
  }
  static class EYutori {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int k=in.nextInt();
      int c=in.nextInt();
      char[] s=in.next().toCharArray();
      ArrayList<Integer>saisoku=new ArrayList<>();
      ArrayList<Integer>saichi=new ArrayList<>();
      int time=-1 ;
      for(int i=0 ; i<n ; i++){
        if(s[i]=='o' && time<i){
          time=i+c ;
          saisoku.add(i+1);
        }
        if(saisoku.size()==k){
          break ;
        }
      }
      time=10000000 ;
      for(int i=n-1 ; i>=0 ; i--){
        if(s[i]=='o' && i+c<time){
          time=i ;
          saichi.add(i+1);
        }
        if(saichi.size()==k){
          break ;
        }
      }
      saichi.sort(Comparator.naturalOrder());
      for(int i=0 ; i<saisoku.size(); i++){
        int x=saisoku.get(i);
        int y=saichi.get(i);
        if(x==y){
          out.println(x);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : EYutori ; solver := EYutori.newEYutori() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class EYutori {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var c : int ; c := in.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := in.getCurrent()->characters() ;
    var saisoku : Sequence(int) ; saisoku := Sequence{} ;
    var saichi : Sequence(int) ; saichi := Sequence{} ;
    var time : int ; time := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] = 'o' & time < i) then (     time := i + c ; 
     saisoku := saisoku->including(i + 1) ) else skip ; 
     if (saisoku->size() = k) then (     break ) else skip )  ;     i := i + 1 ) ; 
    time := 10000000 ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (s[i+1] = 'o' & i + c < time) then (     time := i ; 
     saichi := saichi->including(i + 1) ) else skip ; 
     if (saichi->size() = k) then (     break ) else skip )  ;     i := i - 1 ) ; 
    saichi := saichi.sort(Comparator.naturalOrder()) ; 
        var i : int ; i := 0 ; while i < saisoku->size() do ( (     var x : int ; x := saisoku->at(i+1) ;
     var y : int ; y := saichi->at(i+1) ;
     if (x = y) then (     skip ) else skip )  ;     i := i + 1 ) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static boolean solve(){
    int n=in.nextInt();
    if(n==0)return false ;
    int sa=0,sb=0 ;
    for(int i=0 ; i<n ; i++){
      int a=in.nextInt();
      int b=in.nextInt();
      if(a==b){
        sa+=a ;
        sb+=b ;
      }
      else if(a>b){
        sa+=a+b ;
      }
      else {
        sb+=a+b ;
      }
    }
    out.println(sa+" "+sb);
    return true ;
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.currentTimeMillis();
    while(solve());
    out.flush();
    long end=System.currentTimeMillis();
    dump((end-start)+"ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return false else skip ; 
    var sa : int ; sa := 0 ;
    var sb : int ; sb := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
     if (a = b) then (     sa := sa+(a) ; 
     sb := sb+(b) ) else     if (a > b) then (     sa := sa+(a + b) ) else (     sb := sb+(a + b) ) ;  )  ;     i := i + 1 ) ; 
    skip ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := OclDate.getSystemTime() ;
    while (solve()) do  ; 
    skip ; 
    var end : long ; end := OclDate.getSystemTime() ;
    execute dump((end - start) + "ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int x=sc.nextInt();
      int n=sc.nextInt();
      int e=sc.nextInt();
      if((x | n | e)==0)break ;
      int[] v=new int[x];
      for(int i=0 ; i<x ; i++)v[i]=sc.nextInt();
      int[][] ev=new int[n+1][2];
      while(e--!=0){
        int p=sc.nextInt();
        int k=sc.nextInt();
        int val=sc.nextInt();
        ev[p][0]=k ;
        ev[p][1]=val ;
      }
      double[][] p=new double[5001][n+1];
      p[0][0]=1 ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<5001 ; j++){
          if(p[j][i]==0)continue ;
          for(int k=0 ; k<x ; k++){
            int np=Math.min(n,i+v[k]);
            int nm=j ;
            if(ev[np][0]==1){
              np=Math.min(n,np+ev[np][1]);
            }
            else if(ev[np][0]==2){
              nm+=ev[np][1];
            }
            else if(ev[np][0]==3){
              nm=Math.max(0,nm-ev[np][1]);
            }
            p[nm][np]+=p[j][i]/x ;
          }
        }
      }
      double exp=0 ;
      for(int i=0 ; i<5001 ; i++)exp+=i*p[i][n];
      System.out.println((int)exp);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var e : int ; e := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(MathLib.bitwiseOr(x,n),e)) = 0) then     break else skip ; 
    var v : Sequence(int) ; v := Integer.subrange(1,x)->collect(0) ;
        var i : int ; i := 0 ; while i < x do (     v[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ev : Sequence(Sequence(int)) ; ev := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,2)->collect(0)) ;
        while (e /= 0) do (    skip ; (     var p : int ; p := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var val : int ; val := sc.getCurrent()->toInteger() ;
    ev[p+1][0+1] := k ; 
    ev[p+1][1+1] := val ; 
 ) ;  ) ;  
    var p : Sequence(Sequence(double)) ; p := Integer.subrange(1,5001)->collect(Integer.subrange(1,n + 1)->collect(0.0)) ;
    p[0+1][0+1] := 1 ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 5001 do ( (     if (p[j+1][i+1] = 0) then     continue else skip ; 
         var k : int ; k := 0 ; while k < x do ( (     var np : int ; np := Set{n, i + v[k+1]}->min() ;
     var nm : int ; nm := j ;
     if (ev[np+1][0+1] = 1) then (     np := Set{n, np + ev[np+1][1+1]}->min() ) else     if (ev[np+1][0+1] = 2) then (     nm := nm+(ev[np+1][1+1]) ) else     if (ev[np+1][0+1] = 3) then (     nm := Set{0, nm - ev[np+1][1+1]}->max() ) else skip ; ;  ;  
     p[nm+1][np+1] := p[nm+1][np+1]+(p[j+1][i+1] / x) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var exp : double ; exp := 0 ;
        var i : int ; i := 0 ; while i < 5001 do (     exp := exp+(i * p[i+1][n+1]) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(exp->oclAsType(int)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    solve(System.in,System.out);
  }
  static void solve(InputStream is,PrintStream os){
    Scanner scan=new Scanner(is);
    int N=scan.nextInt();
    int K=scan.nextInt();
    int C=scan.nextInt();
    String S=scan.next();
    int l[]=new int[N];
    int r[]=new int[N];
    int day=0 ;
    int lastL[]=new int[N];
    int lastPos=-1 ;
    int notAvailable=0 ;
    for(int i=0 ; i<N ; i++){
      if(S.charAt(i)=='o' && notAvailable==0){
        notAvailable=C ;
        l[i]=day++;
        lastL[i]=lastPos ;
        lastPos=i ;
      }
      else {
        if(notAvailable!=0)notAvailable--;
        l[i]=day ;
        lastL[i]=lastPos ;
      }
    }
    day=0 ;
    int lastR[]=new int[N];
    lastPos=-1 ;
    notAvailable=0 ;
    for(int i=N-1 ; i>=0 ; i--){
      if(S.charAt(i)=='o' && notAvailable==0){
        notAvailable=C ;
        r[i]=day++;
        lastR[i]=lastPos ;
        lastPos=i ;
      }
      else {
        if(notAvailable!=0)notAvailable--;
        r[i]=day ;
        lastR[i]=lastPos ;
      }
    }
    for(int i=0 ; i<N ; i++){
      if(S.charAt(i)=='o'){
        int lrc=l[i]+r[i];
        if(lastL[i]!=-1 && lastR[i]!=-1 && lastR[i]-lastL[i]<=C)lrc--;
        if(lrc>=K)continue ;
        os.println(i+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation solve( is : OclFile, os : OclFile) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(is) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var K : int ; K := scan.getCurrent()->toInteger() ;
    var C : int ; C := scan.getCurrent()->toInteger() ;
    var S : String ; S := scan.getCurrent() ;
    var l : Sequence(int) ; l := Integer.subrange(1,N)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,N)->collect(0) ;
    var day : int ; day := 0 ;
    var lastL : Sequence(int) ; lastL := Integer.subrange(1,N)->collect(0) ;
    var lastPos : int ; lastPos := -1 ;
    var notAvailable : int ; notAvailable := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (S->at(i+1) = 'o' & notAvailable = 0) then (     notAvailable := C ; 
      l[i+1] := day  ; day := day + 1 ; 
     lastL[i+1] := lastPos ; 
     lastPos := i ) else (     if (notAvailable /= 0) then     notAvailable := notAvailable - 1 ; else skip ; 
     l[i+1] := day ; 
     lastL[i+1] := lastPos ) )  ;     i := i + 1 ) ; 
    day := 0 ; 
    var lastR : Sequence(int) ; lastR := Integer.subrange(1,N)->collect(0) ;
    lastPos := -1 ; 
    notAvailable := 0 ; 
        var i : int ; i := N - 1 ; while i >= 0 do ( (     if (S->at(i+1) = 'o' & notAvailable = 0) then (     notAvailable := C ; 
      r[i+1] := day  ; day := day + 1 ; 
     lastR[i+1] := lastPos ; 
     lastPos := i ) else (     if (notAvailable /= 0) then     notAvailable := notAvailable - 1 ; else skip ; 
     r[i+1] := day ; 
     lastR[i+1] := lastPos ) )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (S->at(i+1) = 'o') then (     var lrc : int ; lrc := l[i+1] + r[i+1] ;
     if (lastL[i+1] /= -1 & lastR[i+1] /= -1 & lastR[i+1] - lastL[i+1] <= C) then     lrc := lrc - 1 ; else skip ; 
     if (lrc >= K) then     continue else skip ; 
     os.println(i + 1) ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    final int N=Integer.parseInt(in.next());
    final int K=Integer.parseInt(in.next());
    final int C=Integer.parseInt(in.next());
    final String S=in.next();
    int[] right_count=new int[N];
    int cnt=N-1 ;
    int right_range=0 ;
    while(cnt>=0){
      if(S.charAt(cnt)=='o'){
        right_range+=1 ;
        right_count[cnt]=right_range ;
        for(int i=0 ; i<C ; i++){
          cnt-=1 ;
          cnt=Math.max(0,cnt);
          right_count[cnt]=right_range ;
        }
      }
      else {
        right_count[cnt]=right_range ;
      }
      cnt-=1 ;
    }
    int range_seen=0 ;
    List<Integer>ans=new ArrayList<Integer>();
    if(right_range==K){
      cnt=0 ;
      while(cnt<N){
        if(S.charAt(cnt)=='o'){
          range_seen+=1 ;
          ans.add(cnt+1);
          boolean flag=false ;
          for(int i=0 ; i<C ; i++){
            cnt+=1 ;
            if(cnt<N){
              if((S.charAt(cnt)=='o')&&(cnt+C+1<N)){
                if(right_count[cnt+C+1]==K-range_seen)flag=true ;
              }
              else if((S.charAt(cnt)=='o')&&(range_seen==K))flag=true ;
            }
          }
          if(flag==true){
            ans.remove(ans.size()-1);
          }
        }
        cnt+=1 ;
      }
    }
    for(int i=0 ; i<ans.size(); i++)System.out.println(ans.get(i));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (in.getCurrent())->toInteger() ;
    var K : int ; K := (in.getCurrent())->toInteger() ;
    var C : int ; C := (in.getCurrent())->toInteger() ;
    var S : String ; S := in.getCurrent() ;
    var right_count : Sequence(int) ; right_count := Integer.subrange(1,N)->collect(0) ;
    var cnt : int ; cnt := N - 1 ;
    var right_range : int ; right_range := 0 ;
    while (cnt >= 0) do (     if (S->at(cnt+1) = 'o') then (     right_range := right_range+(1) ; 
     right_count[cnt+1] := right_range ; 
         var i : int ; i := 0 ; while i < C do ( (     cnt := cnt-(1) ; 
     cnt := Set{0, cnt}->max() ; 
     right_count[cnt+1] := right_range )  ;     i := i + 1 ) ) else (     right_count[cnt+1] := right_range ) ;  
     cnt := cnt-(1) ) ; 
    var range_seen : int ; range_seen := 0 ;
    var ans : Sequence(int) ; ans := Sequence{} ;
    if (right_range = K) then (     cnt := 0 ; 
     while (cnt < N) do (     if (S->at(cnt+1) = 'o') then (     range_seen := range_seen+(1) ; 
     ans := ans->including(cnt + 1) ; 
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < C do ( (     cnt := cnt+(1) ; 
     if (cnt < N) then (     if ((S->at(cnt+1) = 'o') & (cnt + C + 1 < N)) then (     if (right_count[cnt + C + 1+1] = K - range_seen) then     flag := true ; else skip ) else     if ((S->at(cnt+1) = 'o') & (range_seen = K)) then     flag := true ; else skip ; ) else skip )  ;     i := i + 1 ) ; 
    if (flag = true) then (     ans := ans->excludingFirst(ans->size() - 1) ) else skip ; 
 ) else skip ; 
     cnt := cnt+(1) ) ) else skip ; 
        var i : int ; i := 0 ; while i < ans->size() do (     OclFile["System.out"].println(ans->at(i+1)) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  LinkedList<String>getAdj(String puzzle){
    LinkedList<String>a=new LinkedList<String>();
    int index=puzzle.indexOf('0');
    int[] adj={
-1,1,-4,4 };
      for(int i=0 ; i<4 ; i++){
        int ni=index+adj[i];
        if(ni<0)continue ;
        if(ni>7)continue ;
        if(index==3 && ni==4)continue ;
        if(index==4 && ni==3)continue ;
        char buffer=puzzle.charAt(ni);
        char ch[]=puzzle.toCharArray();
        ch[ni]='0' ;
        ch[index]=buffer ;
        String str=new String(ch);
        a.add(str);
      }
      return a ;
    }
    void run(){
      LinkedList<String>memo=new LinkedList<String>();
      memo.add("01234567");
      HashMap<String,Integer>map=new HashMap<String,Integer>();
      map.put("01234567",0);
      int step=1 ;
      int sum=0 ;
      for(; ! memo.isEmpty(); ){
        LinkedList<String>nextMemo=new LinkedList<String>();
        for(String str : memo){
          for(String adj : getAdj(str)){
            if(map.containsKey(adj)){
              continue ;
            }
            if(nextMemo.contains(adj)){
              continue ;
            }
            map.put(adj,step);
            nextMemo.add(adj);
          }
        }
        step++;
        memo=nextMemo ;
      }
      for(; sc.hasNextLine(); ){
        System.out.println(map.get(sc.nextLine().replace(" ","")));
      }
    }
    public static void main(String[] args){
      Main m=new Main();
      m.run();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation getAdj( puzzle : String) : Sequence(String)
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := Sequence{} ;
     var index : int ; index := puzzle->indexOf('0')-1 ;
    var adj : Sequence(int) ; adj := Sequence{-1,1,-4,4} ;
        var i : int ; i := 0 ; while i < 4 do ( (     var ni : int ; ni := index + adj[i+1] ;
     if (ni < 0) then     continue else skip ; 
    if (ni > 7) then     continue else skip ; 
    if (index = 3 & ni = 4) then     continue else skip ; 
    if (index = 4 & ni = 3) then     continue else skip ; 
    var buffer : String ; buffer := puzzle->at(ni+1) ;
    var ch : Sequence(String) ; ch := puzzle->characters() ;
    ch[ni+1] := '0' ; 
    ch[index+1] := buffer ; 
    var str : String ; str := StringLib.newString(ch) ;
    a := a->including(str) ; 
 )  ;     i := i + 1 ) ; 
    return a 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     var memo : Sequence(String) ; memo := Sequence{} ;
     memo := memo->including("01234567") ; 
    var map : Map(String,int) ; map := Map{} ;
    map := map->union(Map{"01234567" |-> 0}) ; 
    var step : int ; step := 1 ;
    var sum : int ; sum := 0 ;
      while not(memo->isEmpty()) do ( (     var nextMemo : Sequence(String) ; nextMemo := Sequence{} ;
     for (str : memo) do ( (     for (adj : getAdj(str)) do ( (     if (map->keys()->includes(adj)) then (     continue ) else skip ; 
     if (nextMemo->includes(adj)) then (     continue ) else skip ; 
     map := map->union(Map{adj |-> step}) ; 
     nextMemo := nextMemo->including(adj) )  ) )  ) ; 
     step := step + 1 ; 
     memo := nextMemo )  ) ; 
      while sc.hasNextLine() do ( (     OclFile["System.out"].println(map->at(sc.nextLine().replace(" ", ""))) )  ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int b=s.nextInt();
    int sum=(n+b)/2 ;
    int n1=(Math.abs(n-sum)*(Math.abs(n-sum)+1))/2 ;
    int n2=(Math.abs(b-sum)*(Math.abs(b-sum)+1))/2 ;
    System.out.println(n1+n2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var b : int ; b := s.getCurrent()->toInteger() ;
    var sum : int ; sum := (n + b) / 2 ;
    var n1 : int ; n1 := (if n - sum < 0 then -(n - sum) else n - sum endif * (if n - sum < 0 then -(n - sum) else n - sum endif + 1)) / 2 ;
    var n2 : int ; n2 := (if b - sum < 0 then -(b - sum) else b - sum endif * (if b - sum < 0 then -(b - sum) else b - sum endif + 1)) / 2 ;
    OclFile["System.out"].println(n1 + n2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void K_multiple(int a[],int n,int k){
    Arrays.sort(a);
    HashSet<Integer>s=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      if((a[i] % k==0 && ! s.contains(a[i]/k))|| a[i] % k!=0)s.add(a[i]);
    }
    for(Integer i : s)System.out.print(i+" ");
  }
  public static void main(String args[]){
    int a[]={
      2,3,4,5,6,10 };
      int k=2 ;
      int n=a.length ;
      K_multiple(a,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation K_multiple( a : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var s : Set(int) ; s := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     if ((a[i+1] mod k = 0 & not(s->includes(a[i+1] / k))) or a[i+1] mod k /= 0) then     s := s->including(a[i+1]) ; else skip )  ;     i := i + 1 ) ; 
     for (i : s) do (     OclFile["System.out"].print(i + " ") ;  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,3,4,5,6,10} ;
     var k : int ; k := 2 ;
     var n : int ; n := a->size() ;
     execute K_multiple(a, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Sol {
  static class Node {
    int data ;
    Node next ;
    Node prev ;
  };
  static void reversePrint(Node head_ref){
    Node tail=head_ref ;
    while(tail.next!=null){
      tail=tail.next ;
    }
    while(tail!=head_ref){
      System.out.print(tail.data+" ");
      tail=tail.prev ;
    }
    System.out.println(tail.data);
  }
  static Node push(Node head_ref,int new_data){
    Node new_node=new Node();
    new_node.data=new_data ;
    new_node.prev=null ;
    new_node.next=(head_ref);
    if((head_ref)!=null)(head_ref).prev=new_node ;
(head_ref)=new_node ;
    return head_ref ;
  }
  public static void main(String args[]){
    Node head=null ;
    head=push(head,2);
    head=push(head,4);
    head=push(head,8);
    head=push(head,10);
    System.out.print("Linked List elements in reverse order : ");
    reversePrint(head);
  }
}
------------------------------------------------------------
OCL File:
---------
class Sol {
  static class Node {
   attribute data : int;
   attribute next : Node;
   attribute prev : Node;
}
  static   operation reversePrint( head_ref : Node) : void
  pre: true
  post: true
  activity: (     var tail : Node ; tail := head_ref ;
     while (tail.next /= null) do (     tail := tail.next ) ; 
     while (tail /= head_ref) do (     OclFile["System.out"].print(tail.data + " ") ; 
     tail := tail.prev ) ; 
     OclFile["System.out"].println(tail.data) );
  static   operation push( head_ref : Node, new_data : int) : Node
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode() ;
     new_node.data := new_data ; 
    new_node.prev := null ; 
    new_node.next := (head_ref) ; 
    if ((head_ref) /= null) then     (head_ref).prev := new_node ; else skip ; 
    (head_ref) := new_node ; 
    return head_ref 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := null ;
     head := push(head, 2) ; 
    head := push(head, 4) ; 
    head := push(head, 8) ; 
    head := push(head, 10) ; 
    OclFile["System.out"].print("Linked List elements in reverse order : ") ; 
    execute reversePrint(head) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static int num=200000 ;
  static int[] hoge=new int[num];
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Map<Long,Long>human=new HashMap<>();
    int[] a=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      a[i]=sc.nextInt();
    }
    Long count=0L ;
    for(int i=1 ; i<=n ; i++){
      Long v=(long)a[i]+i ;
      if(human.containsKey(v)){
        human.put(v,human.get(v)+1);
      }
      else {
        human.put(v,1L);
      }
    }
    for(int i=1 ; i<=n ; i++){
      Long v=(long)i-a[i];
      if(human.containsKey(v)){
        count+=human.get(v);
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute num : int := 200000;
  static   attribute hoge : Sequence(int) := Integer.subrange(1,num)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var human : Map(long,long) ; human := Map{} ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : long ; count := 0L ;
        var i : int ; i := 1 ; while i <= n do ( (     var v : long ; v := a[i+1]->oclAsType(long) + i ;
     if (human->keys()->includes(v)) then (     human := human->union(Map{v |-> human->at(v) + 1}) ) else (     human := human->union(Map{v |-> 1L}) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     var v : long ; v := i->oclAsType(long) - a[i+1] ;
     if (human->keys()->includes(v)) then (     count := count+(human->at(v)) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.util.HashMap ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    EThisMessageWillSelfDestructIn5s solver=new EThisMessageWillSelfDestructIn5s();
    solver.solve(1,in,out);
    out.close();
  }
  static class EThisMessageWillSelfDestructIn5s {
    public void solve(int testNumber,Scanner sc,PrintWriter pw){
      int n=sc.nextInt();
      long ans=0 ;
      HashMap<Integer,Integer>map=new HashMap<>();
      for(int i=0 ; i<n ; i++){
        int x=sc.nextInt();
        ans+=map.getOrDefault(i-x,0);
        map.put(x+i,map.getOrDefault(x+i,0)+1);
      }
      pw.println(ans);
    }
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(FileReader r){
      br=new BufferedReader(r);
    }
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : EThisMessageWillSelfDestructIn5s ; solver := EThisMessageWillSelfDestructIn5s.newEThisMessageWillSelfDestructIn5s() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class EThisMessageWillSelfDestructIn5s {
   operation solve( testNumber : int, sc : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var ans : long ; ans := 0 ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.nextInt() ;
     ans := ans+((if map->keys()->contains(i - x) then map->at(i - x) else 0 endif)) ; 
     map := map->union(Map{x + i |-> (if map->keys()->contains(x + i) then map->at(x + i) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    pw.println(ans) ; 
 );
}
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( r : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(r);
    return self );
  operation initialise( r : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(r) );
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static BufferedReader s1 ;
  static BufferedWriter out ;
  static String read()throws IOException {
    String line="" ;
    while(line.length()==0){
      line=s1.readLine();
      continue ;
    }
    return line ;
  }
  static int int_v(String s1){
    return Integer.parseInt(s1);
  }
  static long long_v(String s1){
    return Long.parseLong(s1);
  }
  static int[] int_arr()throws IOException {
    String[] a=read().split(" ");
    int[] b=new int[a.length];
    for(int i=0 ; i<a.length ; i++){
      b[i]=int_v(a[i]);
    }
    return b ;
  }
  static long[] long_arr()throws IOException {
    String[] a=read().split(" ");
    long[] b=new long[a.length];
    for(int i=0 ; i<a.length ; i++){
      b[i]=long_v(a[i]);
    }
    return b ;
  }
  static void assign(){
    s1=new BufferedReader(new InputStreamReader(System.in));
    out=new BufferedWriter(new OutputStreamWriter(System.out));
  }
  static Long find(int x,int y){
    long xx=(long)(x+y)*(x+y+1);
    return xx/2 ;
  }
  public static void main(String[] args)throws IOException {
    assign();
    int n=int_v(read());
    int[] a=int_arr();
    Map<Integer,Integer>map=new HashMap<>();
    long res=0 ;
    for(int i=0 ; i<n ; i++){
      int t2=i+1-a[i],t1=i+1+a[i];
      res+=map.getOrDefault(t2,0);
      map.put(t1,map.getOrDefault(t1,0)+1);
    }
    out.write(res+"");
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s1 : OclFile;
  static   attribute out : OclFile;
  static   operation read() : String
  pre: true
  post: true
  activity: (     var line : String ; line := "" ;
     while (line->size() = 0) do (     line := s1.readLine() ; 
     continue ) ; 
     return line );
  static   operation int_v( s1 : String) : int
  pre: true
  post: true
  activity: (     return (s1)->toInteger() );
  static   operation long_v( s1 : String) : long
  pre: true
  post: true
  activity: (     return (s1)->toLong() );
  static   operation int_arr() : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := read()->split(" ") ;
     var b : Sequence(int) ; b := Integer.subrange(1,a->size())->collect(0) ;
         var i : int ; i := 0 ; while i < a->size() do ( (     b[i+1] := int_v(a[i+1]) )  ;     i := i + 1 ) ; 
     return b );
  static   operation long_arr() : Sequence(long)
  pre: true
  post: true
  activity: (     var a : Sequence(String) ; a := read()->split(" ") ;
     var b : Sequence(long) ; b := Integer.subrange(1,a->size())->collect(0) ;
         var i : int ; i := 0 ; while i < a->size() do ( (     b[i+1] := long_v(a[i+1]) )  ;     i := i + 1 ) ; 
     return b );
  static   operation assign() : void
  pre: true
  post: true
  activity: (     s1 := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) );
  static   operation find( x : int, y : int) : long
  pre: true
  post: true
  activity: (     var xx : long ; xx := (x + y)->oclAsType(long) * (x + y + 1) ;
     return xx / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute assign() ; 
     var n : int ; n := int_v(read()) ;
    var a : Sequence(int) ; a := int_arr() ;
    var map : Map(int,int) ; map := Map{} ;
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var t2 : int ; t2 := i + 1 - a[i+1] ;
    var t1 : int ; t1 := i + 1 + a[i+1] ;
     res := res+((if map->keys()->contains(t2) then map->at(t2) else 0 endif)) ; 
     map := map->union(Map{t1 |-> (if map->keys()->contains(t1) then map->at(t1) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      int[] a=new int[n];
      Map<Integer,Integer>map=new HashMap<>();
      IntStream.range(0,n).forEach(i->map.merge(i+(a[i]=scanner.nextInt()),1,Integer :: sum));
      System.out.println(IntStream.range(0,n).mapToLong(i->map.getOrDefault(i-a[i],0)).sum());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var map : Map(int,int) ; map := Map{} ;
    for i : Integer.subrange(0, n-1) do
    (    map := map.merge(i + (a[i+1]), 1, lambda _pars : OclAny in Integer.newInteger().sum(_pars))) ; 
    OclFile["System.out"].println(Integer.subrange(0, n-1)->collect( _x1 | (lambda i : OclAny in (if map->keys()->contains(i - a[i+1]) then map->at(i - a[i+1]) else 0 endif))->apply(_x1) )->sum()) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int MMAX=5000+1 ;
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    while(true){
      int x=sc.nextInt();
      int y=sc.nextInt();
      int z=sc.nextInt();
      if(x+y+z==0){
        break ;
      }
      int v[]=new int[x];
      for(int i=0 ; i<x ; i++){
        v[i]=sc.nextInt();
      }
      double p[][]=new double[y+1][MMAX];
      p[0][0]=1.0d ;
      int event[]=new int[y+1];
      int eventa[]=new int[y+1];
      for(int i=0 ; i<z ; i++){
        int n=sc.nextInt();
        int e=sc.nextInt();
        int a=sc.nextInt();
        event[n]=e ;
        eventa[n]=a ;
      }
      for(int i=0 ; i<y ; i++){
        for(int m=0 ; m<MMAX ; m++){
          if(p[i][m]==0.0){
            continue ;
          }
          for(int j=0 ; j<x ; j++){
            int money=m ;
            int target=i+v[j];
            if(target>y){
              target=y ;
            }
            switch(event[target]){
              case 1 : target+=eventa[target];
              if(target>y){
                target=y ;
              }
              break ;
              case 2 : money+=eventa[target];
              break ;
              case 3 : money-=eventa[target];
              if(money<0){
                money=0 ;
              }
              break ;
            }
            p[target][money]+=p[i][m]/x ;
          }
        }
      }
      double ans=0.0 ;
      for(int i=0 ; i<MMAX ; i++){
        ans+=p[y][i]*i ;
      }
      System.out.println((int)ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MMAX : int := 5000 + 1;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var z : int ; z := sc.getCurrent()->toInteger() ;
    if (x + y + z = 0) then (     break ) else skip ; 
    var v : Sequence(int) ; v := Integer.subrange(1,x)->collect(0) ;
        var i : int ; i := 0 ; while i < x do ( (     v[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var p : Sequence(Sequence(double)) ; p := Integer.subrange(1,y + 1)->collect(Integer.subrange(1,MMAX)->collect(0.0)) ;
    p[0+1][0+1] := 1.0d ; 
    var event : Sequence(int) ; event := Integer.subrange(1,y + 1)->collect(0) ;
    var eventa : Sequence(int) ; eventa := Integer.subrange(1,y + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < z do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var e : int ; e := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    event[n+1] := e ; 
    eventa[n+1] := a ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < y do ( (         var m : int ; m := 0 ; while m < MMAX do ( (     if (p[i+1][m+1] = 0.0) then (     continue ) else skip ; 
         var j : int ; j := 0 ; while j < x do ( (     var money : int ; money := m ;
     var target : int ; target := i + v[j+1] ;
    if (target > y) then (     target := y ) else skip ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (event[target+1]) ; 
       if _switchval = 1 then
     target := target+(eventa[target+1]) ; 
    if (target > y) then (     target := y ) else skip ; 
    break 
   else skip ;
       if _switchval = 2 then
     money := money+(eventa[target+1]) ; 
    break 
   else skip ;
       if _switchval = 3 then
     money := money-(eventa[target+1]) ; 
    if (money < 0) then (     money := 0 ) else skip ; 
    break 
   else skip ;
 )
    p[target+1][money+1] := p[target+1][money+1]+(p[i+1][m+1] / x) ; 
 )  ;     j := j + 1 ) )  ;     m := m + 1 ) )  ;     i := i + 1 ) ; 
    var ans : double ; ans := 0.0 ;
        var i : int ; i := 0 ; while i < MMAX do ( (     ans := ans+(p[y+1][i+1] * i) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans->oclAsType(int)) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=Integer.parseInt(sc.next());
    Long[] d=new Long[n];
    Arrays.fill(d,0L);
    long s=0 ;
    for(int i=0 ; i<n ; i++){
      int a=Integer.parseInt(sc.next());
      if(i+a<n)d[i+a]++;
      if(i-a>=0)s+=d[i-a];
    }
    out.println(s);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := (sc.getCurrent())->toInteger() ;
    var d : Sequence(long) ; d := Integer.subrange(1,n)->collect(null) ;
    d := d->collect(0L) ; 
    var s : long ; s := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := (sc.getCurrent())->toInteger() ;
     if (i + a < n) then     d[i + a+1] := d[i + a+1] + 1 ; else skip ; 
     if (i - a >= 0) then     s := s+(d[i - a+1]) ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    HashMap<Integer,ArrayList<Integer>>map=new HashMap<>();
    int[] array=new int[n];
    int count=0 ;
    for(int i=0 ; i<m ; i++){
      int start=sc.nextInt();
      int end=sc.nextInt();
      map.computeIfAbsent(start,k->new ArrayList<>()).add(end);
      map.computeIfAbsent(end,k->new ArrayList<>()).add(start);
    }
    Deque<Integer>deque=new ArrayDeque<>();
    deque.add(1);
    while(! deque.isEmpty()){
      int parent=deque.poll();
      ArrayList<Integer>list=map.get(parent);
      if(list==null){
        continue ;
      }
      for(Integer v : list){
        if(array[v-1]==0){
          array[v-1]=parent ;
          deque.add(v);
          count++;
        }
      }
    }
    if(count!=n){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
      for(int i=1 ; i<n ; i++){
        System.out.println(array[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var map : Map(int,Sequence(int)) ; map := Map{} ;
    var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     var start : int ; start := sc.getCurrent()->toInteger() ;
     var end : int ; end := sc.getCurrent()->toInteger() ;
     map.computeIfAbsent(start, lambda k : OclAny in Sequence{})->excludes(end) ; 
     map.computeIfAbsent(end, lambda k : OclAny in Sequence{})->excludes(start) )  ;     i := i + 1 ) ; 
    var deque : Sequence(int) ; deque := ArrayDeque<OclAny>.newArrayDeque() ;
    deque := deque->including(1) ; 
    while (not(deque->isEmpty())) do (     var parent : int ; parent := deque->min() ;
     var list : Sequence(int) ; list := map->at(parent) ;
     if (list = null) then (     continue ) else skip ; 
     for (v : list) do ( (     if (array[v - 1+1] = 0) then (     array[v - 1+1] := parent ; 
     deque := deque->including(v) ; 
     count := count + 1 ) else skip )  ) ) ; 
    if (count /= n) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ; 
         var i : int ; i := 1 ; while i < n do ( (     OclFile["System.out"].println(array[i+1]) )  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static int[] move={
    1,-1,4,-4 };
    private static Map<String,Integer>map=new HashMap<>();
    public static void main(String[] args){
      Scanner in=new Scanner(System.in);
      dsf();
      while(in.hasNext()){
        String str=in.nextLine();
        str=str.replaceAll("\\s+","");
        System.out.println(map.get(str));
      }
    }
    private static void dsf(){
      Queue<String>q=new LinkedList<>();
      map.put("01234567",0);
      q.add("01234567");
      while(! q.isEmpty()){
        String init=q.peek();
        q.poll();
        int p=0 ;
        for(int i=0 ; i<8 ; i++){
          if(init.charAt(i)=='0'){
            p=i ;
            break ;
          }
        }
        for(int i=0 ; i<4 ; i++){
          int dx=p+move[i];
          if(0<=dx && dx<8 && !(p==3 && i==0)&& !(p==4 && i==1)){
            String next=swap(init,p,dx);
            if(! map.containsKey(next)){
              int val=map.get(init)+1 ;
              map.put(next,val);
              q.add(next);
            }
          }
        }
      }
    }
    private static String swap(String str,int init,int toChange){
      char[] chars=str.toCharArray();
      char temp=chars[init];
      chars[init]=chars[toChange];
      chars[toChange]=temp ;
      return new String(chars);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute move : Sequence(int) := Sequence{1,-1,4,-4};
  static   attribute map : Map(String,int) := Map{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     execute dsf() ; 
     while (in.hasNext()) do (     var str : String ; str := in.nextLine() ;
     str := str.replaceAllMatches("\\s+", "" ) ; 
     OclFile["System.out"].println(map->at(str)) ) );
  static   operation dsf() : void
  pre: true
  post: true
  activity: (     var q : Sequence(String) ; q := Sequence{} ;
     map := map->union(Map{"01234567" |-> 0}) ; 
     q := q->including("01234567") ; 
     while (not(q->isEmpty())) do (     var init : String ; init := q->min() ;
     q := q->sort()->tail() ; 
    var p : int ; p := 0 ;
        var i : int ; i := 0 ; while i < 8 do ( (     if (init->at(i+1) = '0') then (     p := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 4 do ( (     var dx : int ; dx := p + move[i+1] ;
     if (0 <= dx & dx < 8 & not((p = 3 & i = 0)) & not((p = 4 & i = 1))) then (     var next : String ; next := swap(init, p, dx) ;
     if (not(map->keys()->includes(next))) then (     var val : int ; val := map->at(init) + 1 ;
     map := map->union(Map{next |-> val}) ; 
     q := q->including(next) ) else skip ) else skip )  ;     i := i + 1 ) ; 
 ) );
  static   operation swap( str : String, init : int, toChange : int) : String
  pre: true
  post: true
  activity: (     var chars : Sequence(String) ; chars := str->characters() ;
     var temp : String ; temp := chars[init+1] ;
    chars[init+1] := chars[toChange+1] ; 
    chars[toChange+1] := temp ; 
    return StringLib.newString(chars) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.Iterator ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    Set<Integer>adj[]=new HashSet[n+1];
    for(int i=1 ; i<adj.length ; i++){
      adj[i]=new HashSet<Integer>();
    }
    for(int i=0 ; i<m ; i++){
      int a=scan.nextInt();
      int b=scan.nextInt();
      adj[a] .add(b);
      adj[b] .add(a);
    }
    int[] dist=new int[n+1];
    dist[0]=0 ;
    int[] ans=new int[n+1];
    int[] end=new int[n+1];
    end[1]++;
    ArrayDeque<Integer>q=new ArrayDeque<>();
    q.add(1);
    while(! q.isEmpty()){
      int v1=q.poll();
      int tdist=dist[v1]+1 ;
      Iterator<Integer>adjit=adj[v1] .iterator();
      while(adjit.hasNext()){
        int v2=adjit.next();
        if(end[v2]<1){
          q.add(v2);
          end[v2]++;
          dist[v2]=tdist ;
          ans[v2]=v1 ;
        }
      }
    }
    System.out.println("Yes");
    for(int i=2 ; i<n+1 ; i++){
      System.out.println(ans[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var adj : Sequence(Set(int)) ; adj := Integer.subrange(1,n + 1)->collect(null) ;
        var i : int ; i := 1 ; while i < adj->size() do ( (     adj[i+1] := Set{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := scan.getCurrent()->toInteger() ;
     var b : int ; b := scan.getCurrent()->toInteger() ;
     adj[a+1]->excludes(b) ; 
     adj[b+1]->excludes(a) )  ;     i := i + 1 ) ; 
    var dist : Sequence(int) ; dist := Integer.subrange(1,n + 1)->collect(0) ;
    dist[0+1] := 0 ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,n + 1)->collect(0) ;
    var end : Sequence(int) ; end := Integer.subrange(1,n + 1)->collect(0) ;
    end[1+1] := end[1+1] + 1 ; 
    var q : Sequence(int) ; q := ArrayDeque<OclAny>.newArrayDeque() ;
    q := q->including(1) ; 
    while (not(q->isEmpty())) do (     var v1 : int ; v1 := q->min() ;
     var tdist : int ; tdist := dist[v1+1] + 1 ;
     var adjit : OclIterator ; adjit := adj[v1+1]->iterator() ;
     while (adjit.hasNext()) do (     var v2 : int ; v2 := adjit.next() ;
     if (end[v2+1] < 1) then (     q := q->including(v2) ; 
     end[v2+1] := end[v2+1] + 1 ; 
     dist[v2+1] := tdist ; 
     ans[v2+1] := v1 ) else skip ) ) ; 
    OclFile["System.out"].println("Yes") ; 
        var i : int ; i := 2 ; while i < n + 1 do ( (     OclFile["System.out"].println(ans[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int N=Integer.parseInt(st.nextToken());
    int M=Integer.parseInt(st.nextToken());
    List<List<Integer>>g=new ArrayList();
    for(int i=0 ; i<N ; i++){
      g.add(new ArrayList());
    }
    for(int i=0 ; i<M ; i++){
      st=new StringTokenizer(br.readLine());
      int A=Integer.parseInt(st.nextToken())-1 ;
      int B=Integer.parseInt(st.nextToken())-1 ;
      g.get(A).add(B);
      g.get(B).add(A);
    }
    HashSet<Integer>vis=new HashSet();
    Queue<Integer>q=new LinkedList();
    q.offer(0);
    int[] signPost=new int[N];
    signPost[0]=1 ;
    vis.add(0);
    while(! q.isEmpty()){
      int cur=q.poll();
      for(int neigh : g.get(cur)){
        if(! vis.contains(neigh)){
          vis.add(neigh);
          q.offer(neigh);
          signPost[neigh]=cur+1 ;
        }
      }
    }
    if(vis.size()<N){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
      for(int i=1 ; i<N ; i++){
        System.out.println(signPost[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var N : int ; N := (st.next())->toInteger() ;
    var M : int ; M := (st.next())->toInteger() ;
    var g : Sequence(Sequence(int)) ; g := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     g := g->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     var A : int ; A := (st.next())->toInteger() - 1 ;
    var B : int ; B := (st.next())->toInteger() - 1 ;
    g->at(A+1)->excludes(B) ; 
    g->at(B+1)->excludes(A) ; 
 )  ;     i := i + 1 ) ; 
    var vis : Set(int) ; vis := Set{} ;
    var q : Sequence(int) ; q := Sequence{} ;
    q := q->including(0) ; 
    var signPost : Sequence(int) ; signPost := Integer.subrange(1,N)->collect(0) ;
    signPost[0+1] := 1 ; 
    vis := vis->including(0) ; 
    while (not(q->isEmpty())) do (     var cur : int ; cur := q->min() ;
     for (neigh : g->at(cur+1)) do ( (     if (not(vis->includes(neigh))) then (     vis := vis->including(neigh) ; 
     q := q->including(neigh) ; 
     signPost[neigh+1] := cur + 1 ) else skip )  ) ) ; 
    if (vis->size() < N) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ; 
         var i : int ; i := 1 ; while i < N do ( (     OclFile["System.out"].println(signPost[i+1]) )  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    while(input.hasNext()){
      int N=input.nextInt();
      int M=input.nextInt();
      ArrayList<ArrayList<Integer>>g=new ArrayList<ArrayList<Integer>>(N+1);
      for(int i=0 ; i<N+1 ; ++i){
        g.add(new ArrayList<Integer>());
      }
      for(int i=0 ; i<M ; ++i){
        int A=input.nextInt();
        int B=input.nextInt();
        g.get(A).add(B);
        g.get(B).add(A);
      }
      int[] nextRoom=new int[N+1];
      Arrays.fill(nextRoom,-1);
      Queue<Integer>q=new LinkedList<Integer>();
      q.add(1);
      while(q.isEmpty()==false){
        int currentRoom=q.poll();
        ArrayList<Integer>neighborRoom=g.get(currentRoom);
        for(int i=0 ; i<neighborRoom.size(); ++i){
          if(nextRoom[neighborRoom.get(i)]==-1){
            nextRoom[neighborRoom.get(i)]=currentRoom ;
            q.add(neighborRoom.get(i));
          }
        }
      }
      System.out.println("Yes");
      for(int i=2 ; i<nextRoom.length ; ++i){
        System.out.println(nextRoom[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (input.hasNext()) do (     var N : int ; N := input.getCurrent()->toInteger() ;
     var M : int ; M := input.getCurrent()->toInteger() ;
    var g : Sequence(Sequence(int)) ; g := Sequence{}->union(N + 1) ;
        var i : int ; i := 0 ; while i < N + 1 do ( (     g := g->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var A : int ; A := input.getCurrent()->toInteger() ;
     var B : int ; B := input.getCurrent()->toInteger() ;
     g->at(A+1)->excludes(B) ; 
     g->at(B+1)->excludes(A) )  ;     i := i + 1 ) ; 
    var nextRoom : Sequence(int) ; nextRoom := Integer.subrange(1,N + 1)->collect(0) ;
    nextRoom := nextRoom->collect(-1) ; 
    var q : Sequence(int) ; q := Sequence{} ;
    q := q->including(1) ; 
    while (q->isEmpty() = false) do (     var currentRoom : int ; currentRoom := q->min() ;
     var neighborRoom : Sequence(int) ; neighborRoom := g->at(currentRoom+1) ;
         var i : int ; i := 0 ; while i < neighborRoom->size() do ( (     if (nextRoom[neighborRoom->at(i+1)+1] = -1) then (     nextRoom[neighborRoom->at(i+1)+1] := currentRoom ; 
     q := q->including(neighborRoom->at(i+1)) ) else skip )  ;     i := i + 1 ) ) ; 
    OclFile["System.out"].println("Yes") ; 
        var i : int ; i := 2 ; while i < nextRoom->size() do ( (     OclFile["System.out"].println(nextRoom[i+1]) )  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[] post=new int[N+1];
    for(int i=0 ; i<=N ; i++)post[i]=-1 ;
    List<List<Integer>>room=new ArrayList<>();
    for(int i=0 ; i<=N ; i++){
      List<Integer>path=new ArrayList<>();
      room.add(path);
    }
    for(int i=0 ; i<M ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      room.get(a).add(b);
      room.get(b).add(a);
    }
    Deque<Integer>dq=new ArrayDeque<>();
    dq.addLast(1);
    dq.addLast(0);
    while(! dq.isEmpty()){
      int q=dq.removeFirst();
      int pre=dq.removeFirst();
      if(post[q]==-1){
        post[q]=pre ;
        for(int i=0 ; i<room.get(q).size(); i++){
          int x=room.get(q).get(i);
          if(post[x]==-1){
            dq.addLast(x);
            dq.addLast(q);
          }
        }
      }
    }
    for(int i=2 ; i<=N ; i++){
      if(post[i]==-1){
        System.out.println("No");
        return ;
      }
    }
    System.out.println("Yes");
    for(int i=2 ; i<=N ; i++){
      System.out.println(post[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var post : Sequence(int) ; post := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i <= N do (     post[i+1] := -1 ;  ;     i := i + 1 ) ; 
    var room : Sequence(Sequence(int)) ; room := Sequence{} ;
        var i : int ; i := 0 ; while i <= N do ( (     var path : Sequence(int) ; path := Sequence{} ;
     room := room->including(path) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     room->at(a+1)->excludes(b) ; 
     room->at(b+1)->excludes(a) )  ;     i := i + 1 ) ; 
    var dq : Sequence(int) ; dq := ArrayDeque<OclAny>.newArrayDeque() ;
    dq := dq->append(1) ; 
    dq := dq->append(0) ; 
    while (not(dq->isEmpty())) do (     var q : int ; q := dq->first() ;
     var pre : int ; pre := dq->first() ;
     if (post[q+1] = -1) then (     post[q+1] := pre ; 
         var i : int ; i := 0 ; while i < room->at(q+1)->size() do ( (     var x : int ; x := room->at(q+1)->at(i+1) ;
     if (post[x+1] = -1) then (     dq := dq->append(x) ; 
     dq := dq->append(q) ) else skip )  ;     i := i + 1 ) ) else skip ) ; 
        var i : int ; i := 2 ; while i <= N do ( (     if (post[i+1] = -1) then (     OclFile["System.out"].println("No") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Yes") ; 
        var i : int ; i := 2 ; while i <= N do ( (     OclFile["System.out"].println(post[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class B1106 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    StringBuilder out=new StringBuilder();
    int N=in.nextInt();
    int M=in.nextInt();
    int[] A=new int[N];
    for(int n=0 ; n<N ; n++){
      A[n]=in.nextInt();
    }
    int[] C=new int[N];
    Point[] P=new Point[N];
    for(int n=0 ; n<N ; n++){
      int c=in.nextInt();
      C[n]=c ;
      P[n]=new Point(c,n);
    }
    Arrays.sort(P,new Comparator<Point>(){
      @ Override public int compare(Point o1,Point o2){
        int diff=o1.x-o2.x ;
        return(diff==0)?(o1.y-o2.y): diff ;
      }
    }
);
    int cheapestPos=0 ;
    for(int m=0 ; m<M ; m++){
      int type=in.nextInt()-1 ;
      int amount=in.nextInt();
      long cost=0 ;
      int count=Math.min(amount,A[type]);
      A[type]-=count ;
      amount-=count ;
      cost+=C[type]*(long)count ;
      while(amount>0 && cheapestPos<N){
        int cheapestIdx=P[cheapestPos] .y ;
        count=Math.min(amount,A[cheapestIdx]);
        A[cheapestIdx]-=count ;
        amount-=count ;
        cost+=C[cheapestIdx]*(long)count ;
        if(A[cheapestIdx]==0){
          cheapestPos++;
        }
      }
      if(amount>0){
        cost=0 ;
      }
      out.append(cost).append('\n');
    }
    System.out.print(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1106 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : String ; out := StringLib.newString() ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var M : int ; M := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var C : Sequence(int) ; C := Integer.subrange(1,N)->collect(0) ;
    var P : Sequence(Point) ; P := Integer.subrange(1,N)->collect(null) ;
        var n : int ; n := 0 ; while n < N do ( (     var c : int ; c := in.getCurrent()->toInteger() ;
     C[n+1] := c ; 
     P[n+1] := Point.newPoint(c, n) )  ;     n := n + 1 ) ; 
    P := OclComparator.sortWith(P, OclComparator<Point>.newOclComparator()) ; 
    var cheapestPos : int ; cheapestPos := 0 ;
        var m : int ; m := 0 ; while m < M do ( (     var type : int ; type := in.getCurrent()->toInteger() - 1 ;
     var amount : int ; amount := in.getCurrent()->toInteger() ;
    var cost : long ; cost := 0 ;
    var count : int ; count := Set{amount, A[type+1]}->min() ;
    A[type+1] := A[type+1]-(count) ; 
    amount := amount-(count) ; 
    cost := cost+(C[type+1] * count->oclAsType(long)) ; 
    while (amount > 0 & cheapestPos < N) do (     var cheapestIdx : int ; cheapestIdx := P[cheapestPos+1].y ;
     count := Set{amount, A[cheapestIdx+1]}->min() ; 
    A[cheapestIdx+1] := A[cheapestIdx+1]-(count) ; 
    amount := amount-(count) ; 
    cost := cost+(C[cheapestIdx+1] * count->oclAsType(long)) ; 
    if (A[cheapestIdx+1] = 0) then (     cheapestPos := cheapestPos + 1 ) else skip ; 
 ) ; 
    if (amount > 0) then (     cost := 0 ) else skip ; 
    out := out + StringLib.newString(cost) + StringLib.newString('
') ; 
 )  ;     m := m + 1 ) ; 
    OclFile["System.out"].print(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class B574 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int M=in.nextInt();
    List<Integer>[] lists=new List[N];
    boolean[][] edge=new boolean[N][N];
    int[] degree=new int[N];
    for(int n=0 ; n<N ; n++){
      lists[n]=new ArrayList<>();
    }
    for(int m=0 ; m<M ; m++){
      int u=in.nextInt()-1 ;
      int v=in.nextInt()-1 ;
      lists[u] .add(v);
      lists[v] .add(u);
      edge[u][v]=true ;
      edge[v][u]=true ;
      degree[u]++;
      degree[v]++;
    }
    int min=Integer.MAX_VALUE ;
    for(int n=0 ; n<N ; n++){
      List<Integer>list=lists[n];
      for(int i=0 ; i<list.size(); i++){
        int u=list.get(i);
        for(int j=i+1 ; j<list.size(); j++){
          int v=list.get(j);
          if(edge[u][v]){
            int current=degree[n]+degree[u]+degree[v];
            min=Math.min(min,current);
          }
        }
      }
    }
    System.out.println((min==Integer.MAX_VALUE)?-1 :(min-6));
  }
}
------------------------------------------------------------
OCL File:
---------
 class B574 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var M : int ; M := in.getCurrent()->toInteger() ;
    var lists : Sequence(Sequence(int)) ; lists := Integer.subrange(1,N)->collect(null) ;
    var edge : Sequence(Sequence(boolean)) ; edge := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(false)) ;
    var degree : Sequence(int) ; degree := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     lists[n+1] := Sequence{} )  ;     n := n + 1 ) ; 
        var m : int ; m := 0 ; while m < M do ( (     var u : int ; u := in.getCurrent()->toInteger() - 1 ;
     var v : int ; v := in.getCurrent()->toInteger() - 1 ;
    lists[u+1]->excludes(v) ; 
    lists[v+1]->excludes(u) ; 
    edge[u+1][v+1] := true ; 
    edge[v+1][u+1] := true ; 
    degree[u+1] := degree[u+1] + 1 ; 
    degree[v+1] := degree[v+1] + 1 ; 
 )  ;     m := m + 1 ) ; 
    var min : int ; min := 2147483647 ;
        var n : int ; n := 0 ; while n < N do ( (     var list : Sequence(int) ; list := lists[n+1] ;
         var i : int ; i := 0 ; while i < list->size() do ( (     var u : int ; u := list->at(i+1) ;
         var j : int ; j := i + 1 ; while j < list->size() do ( (     var v : int ; v := list->at(j+1) ;
     if (edge[u+1][v+1]) then (     var current : int ; current := degree[n+1] + degree[u+1] + degree[v+1] ;
     min := Set{min, current}->min() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(if (min = 2147483647) then -1 else (min - 6) endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  static class pair {
    int a ;
    int b ;
    pair(int a,int b){
      this.a=a ;
      this.b=b ;
    }
  }
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int m=sc.nextInt();
    int n=sc.nextInt();
    ArrayList<Integer>[] graph=new ArrayList[m+1];
    Set<pair>set=new HashSet<>();
    int degree[]=new int[m+1];
    for(int i=0 ; i<=m ; i++){
      graph[i]=new ArrayList<Integer>();
    }
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      degree[a]++;
      degree[b]++;
      graph[a] .add(b);
      graph[b] .add(a);
      set.add(new pair(a,b));
    }
    int res=Integer.MAX_VALUE ;
    for(int i=1 ; i<=m ; i++){
      for(int j=0 ; j<graph[i] .size(); j++){
        int temp=graph[i] .get(j);
        for(int k=0 ; k<graph[temp] .size(); k++){
          int temp2=graph[temp] .get(k);
          if(graph[i] .contains(temp2)){
            res=Math.min(res,degree[i]+degree[temp]+degree[temp2]-6);
          }
        }
      }
    }
    if(res==Integer.MAX_VALUE)System.out.println(-1);
    else {
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class pair {
   attribute a : int;
   attribute b : int;
   static operation newpair( a : int, b : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var graph : Sequence(Sequence(int)) ; graph := Integer.subrange(1,m + 1)->collect(null) ;
    var set : Set(pair) ; set := Set{} ;
    var degree : Sequence(int) ; degree := Integer.subrange(1,m + 1)->collect(0) ;
        var i : int ; i := 0 ; while i <= m do ( (     graph[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    degree[a+1] := degree[a+1] + 1 ; 
    degree[b+1] := degree[b+1] + 1 ; 
    graph[a+1]->excludes(b) ; 
    graph[b+1]->excludes(a) ; 
    set := set->including(pair.newpair(a, b)) ; 
 )  ;     i := i + 1 ) ; 
    var res : int ; res := 2147483647 ;
        var i : int ; i := 1 ; while i <= m do ( (         var j : int ; j := 0 ; while j < graph[i+1]->size() do ( (     var temp : int ; temp := graph[i+1]->at(j+1) ;
         var k : int ; k := 0 ; while k < graph[temp+1]->size() do ( (     var temp2 : int ; temp2 := graph[temp+1]->at(k+1) ;
     if (graph[i+1]->includes(temp2)) then (     res := Set{res, degree[i+1] + degree[temp+1] + degree[temp2+1] - 6}->min() ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (res = 2147483647) then     OclFile["System.out"].println(-1) else (     OclFile["System.out"].println(res) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s=sc.next();
    int count=0 ;
    int istack=0 ;
    int count_min ;
    if(s.charAt(0)=='E')istack=1 ;
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)=='E')count++;
    }
    count_min=count-istack ;
    for(int i=0 ; i<n-1 ; i++){
      istack=0 ;
      if(s.charAt(i+1)=='E')istack=1 ;
      if(s.charAt(i)=='E')count--;
      else count++;
      if(count-istack<count_min)count_min=count-istack ;
    }
    System.out.println(count_min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var count : int ; count := 0 ;
    var istack : int ; istack := 0 ;
    var count_min : int ;
    if (s->at(0+1) = 'E') then     istack := 1 ; else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = 'E') then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    count_min := (count)->char2byte() - istack ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     istack := 0 ; 
     if (s->at(i + 1+1) = 'E') then     istack := 1 ; else skip ; 
     if (s->at(i+1) = 'E') then     count := count - 1 else     count := count + 1 ; ;  
     if ((count)->char2byte() - istack < count_min) then     count_min := (count)->char2byte() - istack ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count_min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Bear {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    boolean adj[][]=new boolean[n+1][n+1];
    int li[]=new int[n+1];
    for(int i=0 ; i<m ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      adj[a][b]=true ;
      adj[b][a]=true ;
      li[a]++;
      li[b]++;
    }
    int mi=100000005 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=i+1 ; j<=n ; j++){
        if(adj[i][j]){
          for(int k=j+1 ; k<=n ; k++){
            if(adj[i][k] && adj[j][k]){
              int curr=li[i]+li[j]+li[k];
              mi=Math.min(curr,mi);
            }
          }
        }
      }
    }
    if(mi==100000005){
      System.out.print("-1");
      return ;
    }
    System.out.print((mi-6));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Bear {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var adj : Sequence(Sequence(boolean)) ; adj := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(false)) ;
    var li : Sequence(int) ; li := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    adj[a+1][b+1] := true ; 
    adj[b+1][a+1] := true ; 
    li[a+1] := li[a+1] + 1 ; 
    li[b+1] := li[b+1] + 1 ; 
 )  ;     i := i + 1 ) ; 
    var mi : int ; mi := 100000005 ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i + 1 ; while j <= n do ( (     if (adj[i+1][j+1]) then (         var k : int ; k := j + 1 ; while k <= n do ( (     if (adj[i+1][k+1] & adj[j+1][k+1]) then (     var curr : int ; curr := li[i+1] + li[j+1] + li[k+1] ;
     mi := Set{curr, mi}->min() ) else skip )  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (mi = 100000005) then (     OclFile["System.out"].print("-1") ; 
     return ) else skip ; 
    OclFile["System.out"].print((mi - 6)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class class6 {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char ch[]=new char[n];
    int s1=0,s2=0 ;
    int i,j=0,flag=0,dif=0 ;
    for(i=0 ; i<n ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      int temp1=s1+x ;
      int temp2=s2+y ;
      if(Math.abs(temp1-s2)<=500){
        s1+=x ;
        ch[j++]='A' ;
        continue ;
      }
      if(Math.abs(temp2-s1)<=500){
        s2+=y ;
        ch[j++]='G' ;
        continue ;
      }
      flag=1 ;
      break ;
    }
    if(flag==1)System.out.println(-1);
    else {
      String ans="" ;
      ans=ans.valueOf(ch);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class6 {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ch : Sequence(String) ; ch := Integer.subrange(1,n)->collect(0) ;
    var s1 : int ; s1 := 0 ;
    var s2 : int ; s2 := 0 ;
    var i : int ;
    var j : int ; j := 0 ;
    var flag : int ; flag := 0 ;
    var dif : int ; dif := 0 ;
        i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var temp1 : int ; temp1 := s1 + x ;
    var temp2 : int ; temp2 := s2 + y ;
    if (if temp1 - (s2)->char2byte() < 0 then -(temp1 - (s2)->char2byte()) else temp1 - (s2)->char2byte() endif <= 500) then (     s1 := s1+(x) ; 
      ch[j+1] := 'A'  ; j := j + 1 ; 
     continue ) else skip ; 
    if (if temp2 - (s1)->char2byte() < 0 then -(temp2 - (s1)->char2byte()) else temp2 - (s1)->char2byte() endif <= 500) then (     s2 := s2+(y) ; 
      ch[j+1] := 'G'  ; j := j + 1 ; 
     continue ) else skip ; 
    flag := 1 ; 
    break 
 )  ;     i := i + 1 ) ; 
    if (flag = 1) then     OclFile["System.out"].println(-1) else (     var ans : String ; ans := "" ;
     ans := ans.valueOf(ch) ; 
     OclFile["System.out"].println(ans) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
import java.util.*;
public class Main {
  static HashMap<String,Integer>dp=new HashMap<String,Integer>();
  static int distance[]={
    1,-1,4,-4 };
    public static void main(String[] args){
      bfs();
      Scanner scan=new Scanner(System.in);
      while(scan.hasNext()){
        String s=scan.nextLine();
        s=s.replace(" ","");
        System.out.println(dp.get(s));
      }
    }
    public static void bfs(){
      Queue<String>que=new LinkedList<String>();
      que.add("01234567");
      dp.put("01234567",0);
      while(que.size()>0){
        String now=que.poll();
        int p=0 ;
        for(int j=0 ; j<8 ; j++){
          if(now.charAt(j)=='0'){
            p=j ;
            break ;
          }
        }
        for(int i=0 ; i<4 ; i++){
          int n=p+distance[i];
          if(n>=0 && n<8 && !(p==3 && i==0)&& !(p==4 && i==1)){
            char next[]=now.toCharArray();
            next[p]=now.charAt(n);
            next[n]=now.charAt(p);
            String find=String.valueOf(next);
            if(! dp.containsKey(find)){
              dp.put(find,dp.get(now)+1);
              que.add(find);
            }
          }
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dp : Map(String,int) := Map{};
  static   attribute distance : int := Sequence{1,-1,4,-4};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute bfs() ; 
     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var s : String ; s := scan.nextLine() ;
     s := s.replace(" ", "") ; 
     OclFile["System.out"].println(dp->at(s)) ) );
  static   operation bfs() : void
  pre: true
  post: true
  activity: (     var que : Sequence(String) ; que := Sequence{} ;
     que := que->including("01234567") ; 
     dp := dp->union(Map{"01234567" |-> 0}) ; 
     while (que->size() > 0) do (     var now : String ; now := que->min() ;
     var p : int ; p := 0 ;
         var j : int ; j := 0 ; while j < 8 do ( (     if (now->at(j+1) = '0') then (     p := j ; 
     break ) else skip )  ;     j := j + 1 ) ; 
         var i : int ; i := 0 ; while i < 4 do ( (     var n : int ; n := p + distance[i+1] ;
     if (n >= 0 & n < 8 & not((p = 3 & i = 0)) & not((p = 4 & i = 1))) then (     var next : Sequence(String) ; next := now->characters() ;
     next[p+1] := now->at(n+1) ; 
    next[n+1] := now->at(p+1) ; 
    var find : String ; find := ((next) + "") ;
    if (not(dp->keys()->includes(find))) then (     dp := dp->union(Map{find |-> dp->at(now) + 1}) ; 
     que := que->including(find) ) else skip ; 
 ) else skip )  ;     i := i + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class new1 {
  public static void main(String[] args)throws IOException {
    FastReader s=new FastReader();
    BufferedWriter output=new BufferedWriter(new OutputStreamWriter(System.out));
    int t=1 ;
    for(int z=0 ; z<t ; z++){
      int n=s.nextInt();
      String str=s.next();
      int count=1 ;
      for(int i=1 ; i<n ; i++){
        if(str.charAt(i)!=str.charAt(i-1))count++;
      }
      int dist=n-count ;
      if(dist==1){
        System.out.println(count+1);
      }
      else if(dist>=2){
        System.out.println(count+2);
      }
      else System.out.println(count);
    }
    output.flush();
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    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();
  }
  public 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 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class new1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : FastReader ; s := FastReader.newFastReader() ;
     var output : OclFile ; output := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var t : int ; t := 1 ;
        var z : int ; z := 0 ; while z < t do ( (     var n : int ; n := s.nextInt() ;
     var str : String ; str := s.next() ;
    var count : int ; count := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     if (str->at(i+1) /= str->at(i - 1+1)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    var dist : int ; dist := n - (count)->char2byte() ;
    if (dist = 1) then (     OclFile["System.out"].println(count + 1) ) else     if (dist >= 2) then (     OclFile["System.out"].println(count + 2) ) else     OclFile["System.out"].println(count) ; ;  ;  
 )  ;     z := z + 1 ) ; 
    skip ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class AlternateThinking {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    if(scanner.hasNext()){
      int n=scanner.nextInt();
      String s=scanner.next();
      int res=1 ;
      for(int i=1 ; i<n ; i++){
        if(s.charAt(i)!=s.charAt(i-1))res++;
      }
      System.out.println(Math.min(res+2,n));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AlternateThinking {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     if (scanner.hasNext()) then (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var s : String ; s := scanner.getCurrent() ;
    var res : int ; res := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     if (s->at(i+1) /= s->at(i - 1+1)) then     res := res + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{res + 2, n}->min()) ; 
 ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int q ;
    double[] xp0,yp0,xp1,yp1,xp2,yp2,xp3,yp3 ;
    int i ;
    double s1x,s1y,s2x,s2y ;
    q=sc.nextInt();
    xp0=new double[q];
    yp0=new double[q];
    xp1=new double[q];
    yp1=new double[q];
    xp2=new double[q];
    yp2=new double[q];
    xp3=new double[q];
    yp3=new double[q];
    for(i=0 ; i<q ; i++){
      xp0[i]=sc.nextDouble();
      yp0[i]=sc.nextDouble();
      xp1[i]=sc.nextDouble();
      yp1[i]=sc.nextDouble();
      xp2[i]=sc.nextDouble();
      yp2[i]=sc.nextDouble();
      xp3[i]=sc.nextDouble();
      yp3[i]=sc.nextDouble();
    }
    for(i=0 ; i<q ; i++){
      s1x=xp1[i]-xp0[i];
      s1y=yp1[i]-yp0[i];
      s2x=xp3[i]-xp2[i];
      s2y=yp3[i]-yp2[i];
      if((s1y*s2x)==(s2y*s1x)){
        System.out.println("2");
      }
      else if((s1x*s2x+s1y*s2y)==0.0){
        System.out.println("1");
      }
      else {
        System.out.println("0");
      }
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var q : int ;
    var xp0 : Sequence(double) ;
    var yp0 : Sequence(double) ;
    var xp1 : Sequence(double) ;
    var yp1 : Sequence(double) ;
    var xp2 : Sequence(double) ;
    var yp2 : Sequence(double) ;
    var xp3 : Sequence(double) ;
    var yp3 : Sequence(double) ;
    var i : int ;
    var s1x : double ;
    var s1y : double ;
    var s2x : double ;
    var s2y : double ;
    q := sc.nextInt() ; 
    xp0 := Integer.subrange(1,q)->collect(0.0) ; 
    yp0 := Integer.subrange(1,q)->collect(0.0) ; 
    xp1 := Integer.subrange(1,q)->collect(0.0) ; 
    yp1 := Integer.subrange(1,q)->collect(0.0) ; 
    xp2 := Integer.subrange(1,q)->collect(0.0) ; 
    yp2 := Integer.subrange(1,q)->collect(0.0) ; 
    xp3 := Integer.subrange(1,q)->collect(0.0) ; 
    yp3 := Integer.subrange(1,q)->collect(0.0) ; 
        i := 0 ; while i < q do ( (     xp0[i+1] := sc.nextDouble() ; 
     yp0[i+1] := sc.nextDouble() ; 
    xp1[i+1] := sc.nextDouble() ; 
    yp1[i+1] := sc.nextDouble() ; 
    xp2[i+1] := sc.nextDouble() ; 
    yp2[i+1] := sc.nextDouble() ; 
    xp3[i+1] := sc.nextDouble() ; 
    yp3[i+1] := sc.nextDouble() ; 
 )  ;     i := i + 1 ) ; 
        i := 0 ; while i < q do ( (     s1x := xp1[i+1] - xp0[i+1] ; 
     s1y := yp1[i+1] - yp0[i+1] ; 
    s2x := xp3[i+1] - xp2[i+1] ; 
    s2y := yp3[i+1] - yp2[i+1] ; 
    if ((s1y * s2x) = (s2y * s1x)) then (     OclFile["System.out"].println("2") ) else     if ((s1x * s2x + s1y * s2y) = 0.0) then (     OclFile["System.out"].println("1") ) else (     OclFile["System.out"].println("0") ) ;  ;  
 )  ;     i := i + 1 ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      int xp0=sc.nextInt();
      int yp0=sc.nextInt();
      int xp1=sc.nextInt();
      int yp1=sc.nextInt();
      int xp2=sc.nextInt();
      int yp2=sc.nextInt();
      int xp3=sc.nextInt();
      int yp3=sc.nextInt();
      int ax=xp1-xp0 ;
      int ay=yp1-yp0 ;
      int bx=xp3-xp2 ;
      int by=yp3-yp2 ;
      int dot=Geom.dot(ax,ay,bx,by);
      int cross=Geom.cross(ax,ay,bx,by);
      if(cross==0){
        System.out.println("2");
      }
      else if(dot==0){
        System.out.println("1");
      }
      else {
        System.out.println("0");
      }
    }
    sc.close();
  }
  @ SuppressWarnings("unused")private static class Geom {
    static int dot(int xa,int ya,int xb,int yb){
      return xa*xb+ya*yb ;
    }
    static int cross(int xa,int ya,int xb,int yb){
      return xa*yb-xb*ya ;
    }
    static int sumofsquare(int xa,int ya){
      return xa*xa+ya*ya ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < q do ( (     var xp0 : int ; xp0 := sc.getCurrent()->toInteger() ;
     var yp0 : int ; yp0 := sc.getCurrent()->toInteger() ;
    var xp1 : int ; xp1 := sc.getCurrent()->toInteger() ;
    var yp1 : int ; yp1 := sc.getCurrent()->toInteger() ;
    var xp2 : int ; xp2 := sc.getCurrent()->toInteger() ;
    var yp2 : int ; yp2 := sc.getCurrent()->toInteger() ;
    var xp3 : int ; xp3 := sc.getCurrent()->toInteger() ;
    var yp3 : int ; yp3 := sc.getCurrent()->toInteger() ;
    var ax : int ; ax := xp1 - xp0 ;
    var ay : int ; ay := yp1 - yp0 ;
    var bx : int ; bx := xp3 - xp2 ;
    var by : int ; by := yp3 - yp2 ;
    var dot : int ; dot := Geom.dot(ax, ay, bx, by) ;
    var cross : int ; cross := Geom.cross(ax, ay, bx, by) ;
    if (cross = 0) then (     OclFile["System.out"].println("2") ) else     if (dot = 0) then (     OclFile["System.out"].println("1") ) else (     OclFile["System.out"].println("0") ) ;  ;  
 )  ;     i := i + 1 ) ; 
     skip );
   static class Geom {
  static   operation dot( xa : int, ya : int, xb : int, yb : int) : int
  pre: true
  post: true
  activity: (     return xa * xb + ya * yb );
  static   operation cross( xa : int, ya : int, xb : int, yb : int) : int
  pre: true
  post: true
  activity: (     return xa * yb - xb * ya );
  static   operation sumofsquare( xa : int, ya : int) : int
  pre: true
  post: true
  activity: (     return xa * xa + ya * ya );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int q ;
    double x0,y0,x1,y1,x2,y2,x3,y3 ;
    q=scan.nextInt();
    for(int i=0 ; i<q ; i++){
      x0=scan.nextDouble();
      y0=scan.nextDouble();
      x1=scan.nextDouble();
      y1=scan.nextDouble();
      x2=scan.nextDouble();
      y2=scan.nextDouble();
      x3=scan.nextDouble();
      y3=scan.nextDouble();
      if(y0==y1){
        if(y2==y3){
          System.out.println(2);
        }
        else if(x2==x3){
          System.out.println(1);
        }
        else {
          System.out.println(0);
        }
      }
      else if(x0==x1){
        if(x2==x3){
          System.out.println(2);
        }
        else if(y2==y3){
          System.out.println(1);
        }
        else {
          System.out.println(0);
        }
      }
      else {
        if(((y1-y0)/(x1-x0))==((y3-y2)/(x3-x2))){
          System.out.println(2);
        }
        else if(((y1-y0)/(x1-x0)*(y3-y2)/(x3-x2))==-1){
          System.out.println(1);
        }
        else {
          System.out.println(0);
        }
      }
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ;
    var x0 : double ;
    var y0 : double ;
    var x1 : double ;
    var y1 : double ;
    var x2 : double ;
    var y2 : double ;
    var x3 : double ;
    var y3 : double ;
    q := scan.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < q do ( (     x0 := scan.getCurrent()->toReal() ; 
     y0 := scan.getCurrent()->toReal() ; 
    x1 := scan.getCurrent()->toReal() ; 
    y1 := scan.getCurrent()->toReal() ; 
    x2 := scan.getCurrent()->toReal() ; 
    y2 := scan.getCurrent()->toReal() ; 
    x3 := scan.getCurrent()->toReal() ; 
    y3 := scan.getCurrent()->toReal() ; 
    if (y0 = y1) then (     if (y2 = y3) then (     OclFile["System.out"].println(2) ) else     if (x2 = x3) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(0) ) ;  ) else     if (x0 = x1) then (     if (x2 = x3) then (     OclFile["System.out"].println(2) ) else     if (y2 = y3) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(0) ) ;  ) else (     if (((y1 - y0) / (x1 - x0)) = ((y3 - y2) / (x3 - x2))) then (     OclFile["System.out"].println(2) ) else     if (((y1 - y0) / (x1 - x0) * (y3 - y2) / (x3 - x2)) = -1) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(0) ) ;  ) ;  ;  
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int check(int x1,int y1,int x2,int y2,int x3,int y3,int x4,int y4){
    if(x1==x2){
      if(x3==x4)return 2 ;
      else if(y3==y4)return 1 ;
      else return 0 ;
    }
    else if(x3==x4){
      if(y1==y2)return 1 ;
      else return 0 ;
    }
    else {
      if((double)(y2-y1)/(x2-x1)==(double)(y4-y3)/(x4-x3))return 2 ;
      else if((y1-y2)*(y4-y3)==(x2-x1)*(x4-x3))return 1 ;
      else return 0 ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      int x1=sc.nextInt();
      int y1=sc.nextInt();
      int x2=sc.nextInt();
      int y2=sc.nextInt();
      int x3=sc.nextInt();
      int y3=sc.nextInt();
      int x4=sc.nextInt();
      int y4=sc.nextInt();
      System.out.println(check(x1,y1,x2,y2,x3,y3,x4,y4));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation check( x1 : int, y1 : int, x2 : int, y2 : int, x3 : int, y3 : int, x4 : int, y4 : int) : int
  pre: true
  post: true
  activity: (     if (x1 = x2) then (     if (x3 = x4) then     return 2 else     if (y3 = y4) then     return 1 else     return 0 ;  ) else     if (x3 = x4) then (     if (y1 = y2) then     return 1 else     return 0 ) else (     if ((y2 - y1)->oclAsType(double) / (x2 - x1) = (y4 - y3)->oclAsType(double) / (x4 - x3)) then     return 2 else     if ((y1 - y2) * (y4 - y3) = (x2 - x1) * (x4 - x3)) then     return 1 else     return 0 ;  ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < q do ( (     var x1 : int ; x1 := sc.getCurrent()->toInteger() ;
     var y1 : int ; y1 := sc.getCurrent()->toInteger() ;
    var x2 : int ; x2 := sc.getCurrent()->toInteger() ;
    var y2 : int ; y2 := sc.getCurrent()->toInteger() ;
    var x3 : int ; x3 := sc.getCurrent()->toInteger() ;
    var y3 : int ; y3 := sc.getCurrent()->toInteger() ;
    var x4 : int ; x4 := sc.getCurrent()->toInteger() ;
    var y4 : int ; y4 := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(check(x1, y1, x2, y2, x3, y3, x4, y4)) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int q=scan.nextInt();
    for(int i=0 ; i<q ; i++){
      int[] p0=new int[2];
      int[] p1=new int[2];
      int[] p2=new int[2];
      int[] p3=new int[2];
      p0[0]=scan.nextInt();
      p0[1]=scan.nextInt();
      p1[0]=scan.nextInt();
      p1[1]=scan.nextInt();
      p2[0]=scan.nextInt();
      p2[1]=scan.nextInt();
      p3[0]=scan.nextInt();
      p3[1]=scan.nextInt();
      int[] u=vec(p0,p1);
      int[] v=vec(p2,p3);
      if(dot(u,v)==0){
        System.out.println(1);
      }
      else if(u[0]*v[1]-u[1]*v[0]==0){
        System.out.println(2);
      }
      else {
        System.out.println(0);
      }
    }
  }
  static int norm(int[] p){
    return p[0]*p[0]+p[1]*p[1];
  }
  static int[] vec(int[] p1,int[] p2){
    int[] u={
      p2[0]-p1[0],p2[1]-p1[1] };
      return u ;
    }
    static int dot(int[] u,int[] v){
      return u[0]*v[0]+u[1]*v[1];
    }
    static int cross(int[] u,int[] v){
      return u[0]*v[1]+u[1]*v[0];
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < q do ( (     var p0 : Sequence(int) ; p0 := Integer.subrange(1,2)->collect(0) ;
     var p1 : Sequence(int) ; p1 := Integer.subrange(1,2)->collect(0) ;
    var p2 : Sequence(int) ; p2 := Integer.subrange(1,2)->collect(0) ;
    var p3 : Sequence(int) ; p3 := Integer.subrange(1,2)->collect(0) ;
    p0[0+1] := scan.getCurrent()->toInteger() ; 
    p0[1+1] := scan.getCurrent()->toInteger() ; 
    p1[0+1] := scan.getCurrent()->toInteger() ; 
    p1[1+1] := scan.getCurrent()->toInteger() ; 
    p2[0+1] := scan.getCurrent()->toInteger() ; 
    p2[1+1] := scan.getCurrent()->toInteger() ; 
    p3[0+1] := scan.getCurrent()->toInteger() ; 
    p3[1+1] := scan.getCurrent()->toInteger() ; 
    var u : Sequence(int) ; u := vec(p0, p1) ;
    var v : Sequence(int) ; v := vec(p2, p3) ;
    if (dot(u, v) = 0) then (     OclFile["System.out"].println(1) ) else     if (u[0+1] * v[1+1] - u[1+1] * v[0+1] = 0) then (     OclFile["System.out"].println(2) ) else (     OclFile["System.out"].println(0) ) ;  ;  
 )  ;     i := i + 1 ) );
  static   operation norm( p : Sequence(int)) : int
  pre: true
  post: true
  activity: (     return p[0+1] * p[0+1] + p[1+1] * p[1+1] );
  static   operation vec( p1 : Sequence(int), p2 : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var u : Sequence(int) ; u := Sequence{p2[0+1] - p1[0+1],p2[1+1] - p1[1+1]} ;
     return u );
  static   operation dot( u : Sequence(int), v : Sequence(int)) : int
  pre: true
  post: true
  activity: (     return u[0+1] * v[0+1] + u[1+1] * v[1+1] );
  static   operation cross( u : Sequence(int), v : Sequence(int)) : int
  pre: true
  post: true
  activity: (     return u[0+1] * v[1+1] + u[1+1] * v[0+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        int n=sc.nextInt();
        int n1=sc.nextInt();
        if(n==n1 && n==1)System.out.println(0);
        else if(Math.min(n,n1)==1)System.out.println(1);
        else System.out.println(2);
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var n1 : int ; n1 := sc.getCurrent()->toInteger() ;
     if (n = n1 & n = 1) then     OclFile["System.out"].println(0) ; else     if (Set{n, n1}->min() = 1) then     OclFile["System.out"].println(1) else     OclFile["System.out"].println(2) ; ;  ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static InputReader in ;
  public static PrintWriter out ;
  public static void main(String[] args){
    in=new InputReader(System.in);
    out=new PrintWriter(System.out);
    int n=in.nextInt();
    String s=in.next();
    int[] sumE=new int[n];
    for(int i=0 ; i<n ; i++){
      sumE[i]=(s.charAt(i)=='E' ? 1 : 0);
      if(i>0)sumE[i]+=sumE[i-1];
    }
    int ans=n ;
    for(int i=0 ; i<n ; i++){
      int cur=0 ;
      if(i-1>=0)cur+=i-sumE[i-1];
      if(i+1<n)cur+=sumE[n-1]-sumE[i];
      ans=Math.min(ans,cur);
    }
    out.println(ans);
    out.close();
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public Long nextLong(){
      return Long.parseLong(next());
    }
    public Double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : InputReader;
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := InputReader.newInputReader(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    var n : int ; n := in.nextInt() ;
    var s : String ; s := in.next() ;
    var sumE : Sequence(int) ; sumE := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     sumE[i+1] := (if s->at(i+1) = 'E' then 1 else 0 endif) ; 
     if (i > 0) then     sumE[i+1] := sumE[i+1]+(sumE[i - 1+1]) ; else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := n ;
        var i : int ; i := 0 ; while i < n do ( (     var cur : int ; cur := 0 ;
     if (i - 1 >= 0) then     cur := cur+(i - sumE[i - 1+1]) ; else skip ; 
     if (i + 1 < n) then     cur := cur+(sumE[n - 1+1] - sumE[i+1]) ; else skip ; 
     ans := Set{ans, cur}->min() )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class SmallestNumber {
  static long min ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    min=Long.MAX_VALUE ;
    ArrayList<Long>arr=new ArrayList<>();
    for(int i=0 ; i<4 ; i++){
      arr.add(sc.nextLong());
    }
    String[] ops=new String[3];
    for(int i=0 ; i<3 ; i++){
      ops[i]=sc.next();
    }
    util(arr,ops,0);
    System.out.println(min);
  }
  public static void util(ArrayList<Long>arr,String[] ops,int idx){
    if(idx==3){
      min=Math.min(min,arr.get(0));
      return ;
    }
    for(int i=0 ; i<arr.size(); i++){
      for(int j=i+1 ; j<arr.size(); j++){
        ArrayList<Long>a=new ArrayList<>();
        for(int k=0 ; k<arr.size(); k++){
          if(k!=j && k!=i){
            a.add(arr.get(k));
          }
        }
        long res ;
        if(idx<3 && ops[idx] .equals("+")){
          res=arr.get(i)+arr.get(j);
        }
        else {
          res=arr.get(i)*arr.get(j);
        }
        a.add(res);
        util(a,ops,idx+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SmallestNumber {
  static   attribute min : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     min := "9223372036854775807"->toLong() ; 
    var arr : Sequence(long) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < 4 do ( (     arr := arr->including(sc.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    var ops : Sequence(String) ; ops := Integer.subrange(1,3)->collect(null) ;
        var i : int ; i := 0 ; while i < 3 do ( (     ops[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    execute util(arr, ops, 0) ; 
    OclFile["System.out"].println(min) ; 
 );
  static   operation util( arr : Sequence(long), ops : Sequence(String), idx : int) : void
  pre: true
  post: true
  activity: (     if (idx = 3) then (     min := Set{min, arr->at(0+1)}->min() ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < arr->size() do ( (         var j : int ; j := i + 1 ; while j < arr->size() do ( (     var a : Sequence(long) ; a := Sequence{} ;
         var k : int ; k := 0 ; while k < arr->size() do ( (     if (k /= j & k /= i) then (     a := a->including(arr->at(k+1)) ) else skip )  ;     k := k + 1 ) ; 
    var res : long ;
    if (idx < 3 & ops[idx+1] = "+") then (     res := arr->at(i+1) + arr->at(j+1) ) else (     res := arr->at(i+1) * arr->at(j+1) ) ;  
    a := a->including(res) ; 
    execute util(a, ops, idx + 1) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int a,b ;
    for(int i=0 ; i<n ; i++){
      a=scanner.nextInt();
      b=scanner.nextInt();
      if(a==1 && b==1)System.out.println(0);
      else {
        if(a==1 || b==1)System.out.println(1);
        else System.out.println(2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : int ;
    var b : int ;
         var i : int ; i := 0 ; while i < n do ( (     a := scanner.getCurrent()->toInteger() ; 
     b := scanner.getCurrent()->toInteger() ; 
     if (a = 1 & b = 1) then     OclFile["System.out"].println(0) ; else (     if (a = 1 or b = 1) then     OclFile["System.out"].println(1) ; else     OclFile["System.out"].println(2) ; ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int min_element(int a[]){
    int min=Integer.MAX_VALUE,i ;
    for(i=0 ; i<a.length ; i++){
      if(a[i]<min)min=a[i];
    }
    return min ;
  }
  static int findSmallest(int a[],int n){
    int smallest=min_element(a);
    for(int i=1 ; i<n ; i++)if(a[i] % smallest>=1)return-1 ;
    return smallest ;
  }
  public static void main(String args[]){
    int a[]={
      25,20,5,10,100 };
      int n=a.length ;
      System.out.println(findSmallest(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation min_element( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var min : int ; min := 2147483647 ;
    var i : int ;
         i := 0 ; while i < a->size() do ( (     if (a[i+1] < min) then     min := a[i+1] ; else skip )  ;     i := i + 1 ) ; 
     return min );
  static   operation findSmallest( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var smallest : int ; smallest := min_element(a) ;
         var i : int ; i := 1 ; while i < n do (     if (a[i+1] mod smallest >= 1) then     return -1 else skip ;  ;     i := i + 1 ) ; 
     return smallest );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{25,20,5,10,100} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(findSmallest(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int maxSize=(int)1e5+1 ;
  static boolean isPrime[]=new boolean[maxSize];
  static int prefix[]=new int[maxSize];
  static int digitSum(int num){
    int s=0 ;
    while(num!=0){
      s=s+num % 10 ;
      num=num/10 ;
    }
    return s ;
  }
  static void sieveOfEratosthenes(){
    for(int i=2 ; i<maxSize ; i++){
      isPrime[i]=true ;
    }
    for(int i=2 ; i*i<=maxSize ; i++){
      if(isPrime[i]){
        for(int j=i*i ; j<maxSize ; j+=i){
          isPrime[j]=false ;
        }
      }
    }
  }
  static void precompute(int k){
    sieveOfEratosthenes();
    for(int i=1 ; i<maxSize ; i++){
      int sum=digitSum(i);
      if(isPrime[sum]==true && sum % k==0){
        prefix[i]++;
      }
    }
    for(int i=1 ; i<maxSize ; i++){
      prefix[i]=prefix[i]+prefix[i-1];
    }
  }
  static void performQueries(int k,int q,int query[][]){
    precompute(k);
    for(int i=0 ; i<q ; i++){
      int l=query[i][0],r=query[i][1];
      int cnt=prefix[r]-prefix[l-1];
      System.out.println(cnt);
    }
  }
  public static void main(String[] args){
    int query[][]={
      {
        1,11 },{
          5,15 },{
            2,24 }
          };
          int k=2,q=query.length ;
          performQueries(k,q,query);
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute maxSize : int := 1e5->oclAsType(int) + 1;
  static   attribute isPrime : boolean := Integer.subrange(1,maxSize)->collect(false);
  static   attribute prefix : int := Integer.subrange(1,maxSize)->collect(0);
  static   operation digitSum( num : int) : int
  pre: true
  post: true
  activity: (     var s : int ; s := 0 ;
     while (num /= 0) do (     s := s + num mod 10 ; 
     num := num / 10 ) ; 
     return s );
  static   operation sieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i < maxSize do ( (     isPrime[i+1] := true )  ;     i := i + 1 ) ; 
         var i : int ; i := 2 ; while i * i <= maxSize do ( (     if (isPrime[i+1]) then (         var j : int ; j := i * i ; while j < maxSize do ( (     isPrime[j+1] := false )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) );
  static   operation precompute( k : int) : void
  pre: true
  post: true
  activity: (     execute sieveOfEratosthenes() ; 
         var i : int ; i := 1 ; while i < maxSize do ( (     var sum : int ; sum := digitSum(i) ;
     if (isPrime[sum+1] = true & sum mod k = 0) then (     prefix[i+1] := prefix[i+1] + 1 ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i < maxSize do ( (     prefix[i+1] := prefix[i+1] + prefix[i - 1+1] )  ;     i := i + 1 ) );
  static   operation performQueries( k : int, q : int, query : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     execute precompute(k) ; 
         var i : int ; i := 0 ; while i < q do ( (     var l : int ; l := query[i+1][0+1] ;
    var r : int ; r := query[i+1][1+1] ;
     var cnt : int ; cnt := prefix[r+1] - prefix[l - 1+1] ;
     OclFile["System.out"].println(cnt) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var query : Sequence(Sequence(int)) ; query := Sequence{Sequence{1,11},Sequence{5,15},Sequence{2,24}} ;
     var k : int ; k := 2 ;
    var q : int ; q := query->size() ;
     execute performQueries(k, q, query) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
public class anagramPairCount {
  public static void main(String[] args){
    subString("kkkk");
  }
  static void subString(String s){
    HashMap<String,Integer>map=new HashMap<>();
    for(int i=0 ; i<s.length(); i++){
      for(int j=i ; j<s.length(); j++){
        char[] valC=s.substring(i,j+1).toCharArray();
        Arrays.sort(valC);
        String val=new String(valC);
        if(map.containsKey(val))map.put(val,map.get(val)+1);
        else map.put(val,1);
      }
    }
    int anagramPairCount=0 ;
    for(String key : map.keySet()){
      int n=map.get(key);
      anagramPairCount+=(n*(n-1))/2 ;
    }
    System.out.println(anagramPairCount);
  }
}
------------------------------------------------------------
OCL File:
---------
 class anagramPairCount {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute subString("kkkk") );
  static   operation subString( s : String) : void
  pre: true
  post: true
  activity: (     var map : Map(String,int) ; map := Map{} ;
         var i : int ; i := 0 ; while i < s->size() do ( (         var j : int ; j := i ; while j < s->size() do ( (     var valC : Sequence(String) ; valC := s.subrange(i+1,j + 1)->characters() ;
     valC := valC->sort() ; 
     var val : String ; val := StringLib.newString(valC) ;
     if (map->keys()->includes(val)) then     map := map->union(Map{val |-> map->at(val) + 1}) ; else     map := map->union(Map{val |-> 1}) ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var anagramPairCount : int ; anagramPairCount := 0 ;
    for (key : map->keys()) do ( (     var n : int ; n := map->at(key) ;
     anagramPairCount := anagramPairCount+((n * (n - 1)) / 2) )  ) ; 
    OclFile["System.out"].println(anagramPairCount) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int CountPairs(int n){
    int k=n ;
    int imin=1 ;
    int ans=0 ;
    while(imin<=n){
      int imax=n/k ;
      ans+=k*(imax-imin+1);
      imin=imax+1 ;
      k=n/imin ;
    }
    return ans ;
  }
  public static void main(String[] args){
    System.out.println(CountPairs(1));
    System.out.println(CountPairs(2));
    System.out.println(CountPairs(3));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation CountPairs( n : int) : int
  pre: true
  post: true
  activity: (     var k : int ; k := n ;
     var imin : int ; imin := 1 ;
    var ans : int ; ans := 0 ;
    while (imin <= n) do (     var imax : int ; imax := n / k ;
     ans := ans+(k * (imax - imin + 1)) ; 
     imin := imax + 1 ; 
     k := n / imin ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(CountPairs(1)) ; 
     OclFile["System.out"].println(CountPairs(2)) ; 
     OclFile["System.out"].println(CountPairs(3)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    String T=sc.next();
    int max=0 ;
    for(int i=0 ; i<S.length()-T.length()+1 ; i++){
      int cnt=0 ;
      String test=S.substring(i,i+T.length());
      for(int ind=0 ; ind<T.length(); ind++){
        if(test.charAt(ind)==T.charAt(ind)){
          cnt++;
        }
      }
      if(max<cnt){
        max=cnt ;
      }
    }
    System.out.println(T.length()-max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    var T : String ; T := sc.getCurrent() ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < S->size() - T->size() + 1 do ( (     var cnt : int ; cnt := 0 ;
     var test : String ; test := S.subrange(i+1,i + T->size()) ;
         var ind : int ; ind := 0 ; while ind < T->size() do ( (     if (test->at(ind+1) = T->at(ind+1)) then (     cnt := cnt + 1 ) else skip )  ;     ind := ind + 1 ) ; 
     if (max < cnt) then (     max := cnt ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(T->size() - (max)->char2byte()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileNotFoundException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    String T=sc.next();
    char[] s=S.toCharArray();
    char[] t=T.toCharArray();
    int ls=S.length();
    int lt=T.length();
    int ans=lt ;
    for(int i=0 ; i<=ls-lt ; i++){
      int cnt=0 ;
      for(int j=0 ; j<lt ; j++){
        if(t[j]!=s[i+j]){
          cnt++;
        }
      }
      if(cnt<ans){
        ans=cnt ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    var T : String ; T := sc.getCurrent() ;
    var s : Sequence(String) ; s := S->characters() ;
    var t : Sequence(String) ; t := T->characters() ;
    var ls : int ; ls := S->size() ;
    var lt : int ; lt := T->size() ;
    var ans : int ; ans := lt ;
        var i : int ; i := 0 ; while i <= ls - lt do ( (     var cnt : int ; cnt := 0 ;
         var j : int ; j := 0 ; while j < lt do ( (     if (t[j+1] /= s[i + j+1]) then (     cnt := cnt + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (cnt < ans) then (     ans := cnt ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static FastReader in=new FastReader();
  public static void main(String[] args){
    solve();
  }
  static void solve(){
    char[] s=in.nextLine().toCharArray();
    char[] t=in.nextLine().toCharArray();
    int n=s.length ;
    int n2=t.length ;
    int min=n2 ;
    for(int i=0 ; i<n-n2+1 ; i++){
      int curr=0 ;
      int count=0 ;
      for(int j=i ; j<i+n2 ; j++){
        if(s[j]!=t[count])curr++;
        count++;
      }
      min=Math.min(curr,min);
    }
    System.out.println(min);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
    int[] readarr(int abc){
      int[] a=new int[abc];
      for(int i=0 ; i<abc ; i++)a[i]=nextInt();
      return a ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : FastReader := FastReader.newFastReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := in.nextLine()->characters() ;
     var t : Sequence(String) ; t := in.nextLine()->characters() ;
    var n : int ; n := s->size() ;
    var n2 : int ; n2 := t->size() ;
    var min : int ; min := n2 ;
        var i : int ; i := 0 ; while i < n - n2 + 1 do ( (     var curr : int ; curr := 0 ;
     var count : int ; count := 0 ;
         var j : int ; j := i ; while j < i + n2 do ( (     if (s[j+1] /= t[count+1]) then     curr := curr + 1 ; else skip ; 
     count := count + 1 )  ;     j := j + 1 ) ; 
     min := Set{curr, min}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation readarr( abc : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,abc)->collect(0) ;
         var i : int ; i := 0 ; while i < abc do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class Main {
  public static String S ;
  public static String T ;
  public static int sub=Integer.MAX_VALUE ;
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    S=scan.next();
    T=scan.next();
    System.out.println(search());
  }
  private static int search(){
    for(int i=0 ; i<=S.length()-T.length(); i++){
      int count=0 ;
      for(int j=0 ; j<T.length(); j++){
        String s_i=S.substring(i+j,i+j+1);
        String t_i=T.substring(j,j+1);
        if(! s_i.equals(t_i))count++;
      }
      sub=Math.min(sub,count);
    }
    return sub ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute S : String;
  static   attribute T : String;
  static   attribute sub : int := 2147483647;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     S := scan.getCurrent() ; 
     T := scan.getCurrent() ; 
     OclFile["System.out"].println(search()) );
  static   operation search() : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= S->size() - T->size() do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < T->size() do ( (     var s_i : String ; s_i := S.subrange(i + j+1,i + j + 1) ;
     var t_i : String ; t_i := T.subrange(j+1,j + 1) ;
     if (not(s_i = t_i)) then     count := count + 1 ; else skip )  ;     j := j + 1 ) ; 
     sub := Set{sub, count}->min() )  ;     i := i + 1 ) ; 
     return sub );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.*;
import java.io.*;
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new TestB().doIt();
  }
  class TestB {
    void doIt(){
      String S=sc.next();
      String T=sc.next();
      char SubT[]=T.toCharArray();
      int lengthS=S.length();
      int lengthT=T.length();
      int length=lengthS-lengthT ;
      int min=10000 ;
      for(int i=0 ; i<=length ; i++){
        char SubS[]=S.substring(i,i+lengthT).toCharArray();
        int count=0 ;
        for(int j=0 ; j<lengthT ; j++){
          if(SubS[j]!=SubT[j]){
            count++;
          }
        }
        min=Math.min(min,count);
      }
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     TestB.newTestB().doIt() );
 class TestB {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var S : String ; S := sc.getCurrent() ;
     var T : String ; T := sc.getCurrent() ;
    var SubT : Sequence(String) ; SubT := T->characters() ;
    var lengthS : int ; lengthS := S->size() ;
    var lengthT : int ; lengthT := T->size() ;
    var length : int ; length := (lengthS)->char2byte() - lengthT ;
    var min : int ; min := 10000 ;
        var i : int ; i := 0 ; while i <= length do ( (     var SubS : Sequence(String) ; SubS := S.subrange(i+1,i + lengthT)->characters() ;
     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < lengthT do ( (     if (SubS[j+1] /= SubT[j+1]) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
     min := Set{min, count}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class Main {
  private static long minNum=Long.MAX_VALUE ;
  public static void main(String[] args)throws Exception {
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    String[] splits=bf.readLine().trim().split("\\s+");
    List<Long>arr=new ArrayList<>();
    for(int i=0 ; i<4 ; i++){
      arr.add(Long.parseLong(splits[i]));
    }
    String[] ops=bf.readLine().trim().split("\\s+");
    helper(arr,ops,0);
    System.out.println(minNum);
  }
  private static void helper(List<Long>arr,String[] ops,int idx){
    if(arr.size()==1){
      minNum=Math.min(arr.get(0),minNum);
      return ;
    }
    for(int i=0 ; i<arr.size(); i++){
      for(int j=i+1 ; j<arr.size(); j++){
        List<Long>lst=new ArrayList<>();
        for(int k=0 ; k<arr.size(); k++){
          if(k!=i && k!=j){
            lst.add(arr.get(k));
          }
        }
        if(ops[idx] .equals("*")){
          lst.add(arr.get(i)*arr.get(j));
        }
        else {
          lst.add(arr.get(i)+arr.get(j));
        }
        helper(lst,ops,idx+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute minNum : long := "9223372036854775807"->toLong();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var splits : Sequence(String) ; splits := bf.readLine()->trim()->split("\\s+") ;
    var arr : Sequence(long) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < 4 do ( (     arr := arr->including((splits[i+1])->toLong()) )  ;     i := i + 1 ) ; 
    var ops : Sequence(String) ; ops := bf.readLine()->trim()->split("\\s+") ;
    execute helper(arr, ops, 0) ; 
    OclFile["System.out"].println(minNum) ; 
 );
  static   operation helper( arr : Sequence(long), ops : Sequence(String), idx : int) : void
  pre: true
  post: true
  activity: (     if (arr->size() = 1) then (     minNum := Set{arr->at(0+1), minNum}->min() ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < arr->size() do ( (         var j : int ; j := i + 1 ; while j < arr->size() do ( (     var lst : Sequence(long) ; lst := Sequence{} ;
         var k : int ; k := 0 ; while k < arr->size() do ( (     if (k /= i & k /= j) then (     lst := lst->including(arr->at(k+1)) ) else skip )  ;     k := k + 1 ) ; 
     if (ops[idx+1] = "*") then (     lst := lst->including(arr->at(i+1) * arr->at(j+1)) ) else (     lst := lst->including(arr->at(i+1) + arr->at(j+1)) ) ;  
     execute helper(lst, ops, idx + 1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.FileNotFoundException ;
import java.io.FileReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] s=sc.nextLine().toCharArray();
    int west=0 ;
    for(char c : s)if(c=='W')west++;
    int east=n-west ;
    int west_left=0 ;
    int ans=n ;
    for(int i=0 ; i<n ; i++){
      int east_left=i-west_left ;
      int east_right=east-east_left ;
      if(s[i]=='E')east_right--;
      ans=Math.min(ans,west_left+east_right);
      if(s[i]=='W')west_left++;
    }
    System.out.println(ans);
  }
  static class Scanner {
    BufferedReader br ;
    StringTokenizer st ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public Scanner(String s)throws FileNotFoundException {
      br=new BufferedReader(new FileReader(s));
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := sc.nextLine()->characters() ;
    var west : int ; west := 0 ;
    for (c : s) do (     if (c = 'W') then     west := west + 1 ; else skip ;  ) ; 
    var east : int ; east := n - west ;
    var west_left : int ; west_left := 0 ;
    var ans : int ; ans := n ;
        var i : int ; i := 0 ; while i < n do ( (     var east_left : int ; east_left := i - west_left ;
     var east_right : int ; east_right := east - east_left ;
    if (s[i+1] = 'E') then     east_right := east_right - 1 ; else skip ; 
    ans := Set{ans, west_left + east_right}->min() ; 
    if (s[i+1] = 'W') then     west_left := west_left + 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newScanner( s : String) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      BigInteger s=sc.nextBigInteger();
      BigInteger b1=new BigInteger("-128");
      BigInteger b2=new BigInteger("127");
      BigInteger s1=new BigInteger("-32768");
      BigInteger s2=new BigInteger("32767");
      BigInteger l1=new BigInteger("-2147483648");
      BigInteger l2=new BigInteger("2147483647");
      BigInteger bg1=new BigInteger("-9223372036854775808");
      BigInteger bg2=new BigInteger("9223372036854775807");
      if((s.compareTo(b1)==1 || s.compareTo(b1)==0)&&(s.compareTo(b2)==-1 || s.compareTo(b2)==0))System.out.println("byte");
      else if((s.compareTo(s1)==1 || s.compareTo(s1)==0)&&(s.compareTo(s2)==-1 || s.compareTo(s2)==0))System.out.println("short");
      else if((s.compareTo(l1)==1 || s.compareTo(l1)==0)&&(s.compareTo(l2)==-1 || s.compareTo(l2)==0))System.out.println("int");
      else if((s.compareTo(bg1)==1 || s.compareTo(bg1)==0)&&(s.compareTo(bg2)==-1 || s.compareTo(bg2)==0))System.out.println("long");
      else System.out.println("BigInteger");
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : long ; s := sc.nextBigInteger() ;
    var b1 : long ; b1 := long("-128") ;
    var b2 : long ; b2 := long("127") ;
    var s1 : long ; s1 := long("-32768") ;
    var s2 : long ; s2 := long("32767") ;
    var l1 : long ; l1 := long("-2147483648") ;
    var l2 : long ; l2 := long("2147483647") ;
    var bg1 : long ; bg1 := long("-9223372036854775808") ;
    var bg2 : long ; bg2 := long("9223372036854775807") ;
    if ((s->compareTo(b1) = 1 or s->compareTo(b1) = 0) & (s->compareTo(b2) = -1 or s->compareTo(b2) = 0)) then     OclFile["System.out"].println("byte") else     if ((s->compareTo(s1) = 1 or s->compareTo(s1) = 0) & (s->compareTo(s2) = -1 or s->compareTo(s2) = 0)) then     OclFile["System.out"].println("short") else     if ((s->compareTo(l1) = 1 or s->compareTo(l1) = 0) & (s->compareTo(l2) = -1 or s->compareTo(l2) = 0)) then     OclFile["System.out"].println("int") else     if ((s->compareTo(bg1) = 1 or s->compareTo(bg1) = 0) & (s->compareTo(bg2) = -1 or s->compareTo(bg2) = 0)) then     OclFile["System.out"].println("long") else     OclFile["System.out"].println("BigInteger") ; ;  ;  ;  ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class PetyaAndJava {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter writer=new PrintWriter(new OutputStreamWriter(System.out));
    try {
      long num=Long.parseLong(reader.readLine());
      if(num<=127)writer.println("byte");
      else if(num<=32767)writer.println("short");
      else if(num<=2147483647)writer.println("int");
      else writer.println("long");
      writer.flush();
    }
    catch(Exception e){
      writer.println("BigInteger");
      writer.flush();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PetyaAndJava {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     try (     var num : long ; num := (reader.readLine())->toLong() ;
     if (num <= 127) then     skip else     if (num <= 32767) then     skip else     if (num <= 2147483647) then     skip else     skip ; ;  ;  ;  
     skip )   catch (e : ProgramException) do (     skip ; 
     skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    String s=bf.readLine();
    BigInteger n=new BigInteger(s);
    int b=n.bitLength()/8 ;
    if(b<1){
      System.out.println("byte");
    }
    else if(b<2){
      System.out.println("short");
    }
    else if(b<4){
      System.out.println("int");
    }
    else if(b<8){
      System.out.println("long");
    }
    else System.out.println("BigInteger");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := bf.readLine() ;
    var n : long ; n := long(s) ;
    var b : int ; b := n.bitLength() / 8 ;
    if (b < 1) then (     OclFile["System.out"].println("byte") ) else     if (b < 2) then (     OclFile["System.out"].println("short") ) else     if (b < 4) then (     OclFile["System.out"].println("int") ) else     if (b < 8) then (     OclFile["System.out"].println("long") ) else     OclFile["System.out"].println("BigInteger") ; ;  ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void SubarraysWithSumS(int n,int k,int s){
    for(int i=0 ; i<k ; i++)System.out.print(s+" ");
    for(int i=k ; i<n ; i++)System.out.print(s+1+" ");
  }
  public static void main(String[] args){
    int n=4,k=2,s=3 ;
    SubarraysWithSumS(n,k,s);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation SubarraysWithSumS( n : int, k : int, s : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < k do (     OclFile["System.out"].print(s + " ") ;  ;     i := i + 1 ) ; 
         var i : int ; i := k ; while i < n do (     OclFile["System.out"].print(s + 1 + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
    var k : int ; k := 2 ;
    var s : int ; s := 3 ;
     execute SubarraysWithSumS(n, k, s) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int poorPigs(int buckets,int minutesToDie,int minutesToTest){
    int n=minutesToTest/minutesToDie+1 ;
    int pigs=0 ;
    while(Math.pow(n,pigs)<buckets)pigs++;
    return pigs ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation poorPigs( buckets : int, minutesToDie : int, minutesToTest : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := minutesToTest / minutesToDie + 1 ;
     var pigs : int ; pigs := 0 ;
     while (n->pow(pigs) < buckets) do     pigs := pigs + 1 ; ; 
     return pigs );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Solution {
  public TreeNode constructMaximumBinaryTree(int[] nums){
    return construct(nums,0,nums.length);
  }
  public TreeNode construct(int[] nums,int l,int r){
    if(l==r)return null ;
    int max_i=max(nums,l,r);
    TreeNode root=new TreeNode(nums[max_i]);
    root.left=construct(nums,l,max_i);
    root.right=construct(nums,max_i+1,r);
    return root ;
  }
  public int max(int[] nums,int l,int r){
    int max_i=l ;
    for(int i=l ; i<r ; i++){
      if(nums[max_i]<nums[i])max_i=i ;
    }
    return max_i ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation constructMaximumBinaryTree( nums : Sequence(int)) : TreeNode
  pre: true
  post: true
  activity: (     return construct(nums, 0, nums->size()) );
   operation construct( nums : Sequence(int), l : int, r : int) : TreeNode
  pre: true
  post: true
  activity: (     if (l = r) then     return null else skip ; 
     var max_i : int ; max_i := max(nums, l, r) ;
    var root : TreeNode ; root := TreeNode.newTreeNode(nums[max_i+1]) ;
    root.left := construct(nums, l, max_i) ; 
    root.right := construct(nums, max_i + 1, r) ; 
    return root 
 );
   operation max( nums : Sequence(int), l : int, r : int) : int
  pre: true
  post: true
  activity: (     var max_i : int ; max_i := l ;
         var i : int ; i := l ; while i < r do ( (     if (nums[max_i+1] < nums[i+1]) then     max_i := i ; else skip )  ;     i := i + 1 ) ; 
     return max_i );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Stack ;
public class GFG {
  static Stack<Integer>st=new Stack<>();
  static void push_digits(int number){
    while(number!=0){
      st.push(number % 10);
      number=number/10 ;
    }
  }
  static int reverse_number(int number){
    push_digits(number);
    int reverse=0 ;
    int i=1 ;
    while(! st.isEmpty()){
      reverse=reverse+(st.peek()*i);
      st.pop();
      i=i*10 ;
    }
    return reverse ;
  }
  public static void main(String[] args){
    int number=39997 ;
    System.out.println(reverse_number(number));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute st : Sequence(int) := Sequence{};
  static   operation push_digits( number : int) : void
  pre: true
  post: true
  activity: (     while (number /= 0) do (     st := st->append(number mod 10) ; 
     number := number / 10 ) );
  static   operation reverse_number( number : int) : int
  pre: true
  post: true
  activity: (     execute push_digits(number) ; 
     var reverse : int ; reverse := 0 ;
    var i : int ; i := 1 ;
    while (not(st->isEmpty())) do (     reverse := reverse + (st->min() * i) ; 
     st := st->front() ; 
     i := i * 10 ) ; 
    return reverse 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var number : int ; number := 39997 ;
     OclFile["System.out"].println(reverse_number(number)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=sc.nextInt();
    long S=sc.nextInt();
    long[] x=new long[N],p=new long[N];
    for(int i=0 ; i<N ; i++){
      x[i]=sc.nextInt();
      p[i]=sc.nextInt();
    }
    int left=0,right=N-1 ;
    long[] order=new long[N];
    int idx=0 ;
    while(x[left]<S && S<x[right]){
      if(p[left]>=p[right]){
        order[idx++]=x[right];
        p[left]+=p[right];
        right--;
      }
      else {
        order[idx++]=x[left];
        p[right]+=p[left];
        left++;
      }
    }
    while(right>=0 && S<x[right]){
      order[idx++]=x[right];
      right--;
    }
    while(left<N && x[left]<S){
      order[idx++]=x[left];
      left++;
    }
    long ans=0 ;
    for(int i=N-1 ; i>=0 ; i--){
      ans+=Math.abs(order[i]-S);
      S=order[i];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var S : long ; S := sc.getCurrent()->toInteger() ;
    var x : Sequence(long) ; x := Integer.subrange(1,N)->collect(0) ;
    var p : Sequence(long) ; p := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     p[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var left : int ; left := 0 ;
    var right : int ; right := N - 1 ;
    var order : Sequence(long) ; order := Integer.subrange(1,N)->collect(0) ;
    var idx : int ; idx := 0 ;
    while (x[left+1] < S & S < x[right+1]) do (     if (p[left+1] >= p[right+1]) then (      order[idx+1] := x[right+1]  ; idx := idx + 1 ; 
     p[left+1] := p[left+1]+(p[right+1]) ; 
     right := right - 1 ) else (      order[idx+1] := x[left+1]  ; idx := idx + 1 ; 
     p[right+1] := p[right+1]+(p[left+1]) ; 
     left := left + 1 ) ) ; 
    while (right >= 0 & S < x[right+1]) do (      order[idx+1] := x[right+1]  ; idx := idx + 1 ; 
     right := right - 1 ) ; 
    while (left < N & x[left+1] < S) do (      order[idx+1] := x[left+1]  ; idx := idx + 1 ; 
     left := left + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := N - 1 ; while i >= 0 do ( (     ans := ans+(if order[i+1] - S < 0 then -(order[i+1] - S) else order[i+1] - S endif) ; 
     S := order[i+1] )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayList<Long>arr=new ArrayList<>();
    char[] signs=new char[3];
    for(int i=0 ; i<4 ; i++){
      arr.add(sc.nextLong());
    }
    for(int i=0 ; i<3 ; i++){
      signs[i]=sc.next().charAt(0);
    }
    long[] res={
      Long.MAX_VALUE };
      helper(arr,signs,0,res);
      System.out.println(res[0]);
    }
    public static void helper(ArrayList<Long>arr,char[] signs,int signIndex,long[] res){
      int size=arr.size();
      if(size==1){
        res[0]=Math.min(res[0],arr.get(0));
        return ;
      }
      for(int i=0 ; i<size-1 ; i++){
        for(int j=i+1 ; j<size ; j++){
          long val=0 ;
          if(signs[signIndex]=='+'){
            val=arr.get(i)+arr.get(j);
          }
          else if(signs[signIndex]=='*'){
            val=arr.get(i)*arr.get(j);
          }
          long back_track_i=arr.get(i);
          long back_track_j=arr.get(j);
          arr.set(i,val);
          arr.remove(j);
          helper(arr,signs,signIndex+1,res);
          arr.set(i,back_track_i);
          arr.add(j,back_track_j);
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(long) ; arr := Sequence{} ;
    var signs : Sequence(String) ; signs := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     arr := arr->including(sc.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do ( (     signs[i+1] := sc.getCurrent()->at(0+1) )  ;     i := i + 1 ) ; 
    var res : Sequence(long) ; res := Sequence{"9223372036854775807"->toLong()} ;
    execute helper(arr, signs, 0, res) ; 
    OclFile["System.out"].println(res[0+1]) ; 
 );
  static   operation helper( arr : Sequence(long), signs : Sequence(String), signIndex : int, res : Sequence(long)) : void
  pre: true
  post: true
  activity: (     var size : int ; size := arr->size() ;
     if (size = 1) then (     res[0+1] := Set{res[0+1], arr->at(0+1)}->min() ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < size - 1 do ( (         var j : int ; j := i + 1 ; while j < size do ( (     var val : long ; val := 0 ;
     if (signs[signIndex+1] = '+') then (     val := arr->at(i+1) + arr->at(j+1) ) else     if (signs[signIndex+1] = '*') then (     val := arr->at(i+1) * arr->at(j+1) ) else skip ; ;  
    var back_track_i : long ; back_track_i := arr->at(i+1) ;
    var back_track_j : long ; back_track_j := arr->at(j+1) ;
    arr := arr.setAt(i+1,val) ; 
    arr := arr->excludingAt(j+1) ; 
    execute helper(arr, signs, signIndex + 1, res) ; 
    arr := arr.setAt(i+1,back_track_i) ; 
    arr := arr.insertAt(j+1,back_track_j) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int[] solve(int[] arr,int n){
    int[] b=new int[n];
    int p=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      b[p]=arr[i--];
      if(i>=0)b[n-1-p]=arr[i];
      p++;
    }
    return b ;
  }
  public static void main(String[] args){
    int[] arr={
      1,2,3,4 };
      int n=arr.length ;
      int[] b=solve(arr,n);
      System.out.println(Arrays.toString(b));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( arr : Sequence(int), n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
     var p : int ; p := 0 ;
         var i : int ; i := n - 1 ; while i >= 0 do ( (      b[p+1] := arr[i+1]  ; i := i - 1 ; 
     if (i >= 0) then     b[n - 1 - p+1] := arr[i+1] ; else skip ; 
     p := p + 1 )  ;     i := i - 1 ) ; 
     return b );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4} ;
     var n : int ; n := arr->size() ;
     var b : Sequence(int) ; b := solve(arr, n) ;
     OclFile["System.out"].println((b + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    int rep=1 ;
    if(args.length>0){
      rep=Integer.parseInt(args[0]);
    }
(new Main()).__solve(rep);
  }
  void __solve(int rep){
    try(Scanner cin=new Scanner(System.in);
){
      for(int i=0 ; i<rep ; ++i){
        __solve(cin);
      }
    }
  }
  void __solve(Scanner cin){
    int N=cin.nextInt();
    String s=cin.next();
    int Ecount=0 ;
    for(int i=0 ; i<N ; ++i){
      Ecount+=(s.charAt(i)=='E' ? 1 : 0);
    }
    int min=N ;
    int Wcount=0 ;
    for(int i=0 ; i<N ; ++i){
      if(s.charAt(i)=='W'){
        min=Math.min(min,Wcount+Ecount);
++Wcount ;
      }
      else {
--Ecount ;
        min=Math.min(min,Wcount+Ecount);
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var rep : int ; rep := 1 ;
     if (args->size() > 0) then (     rep := (args[0+1])->toInteger() ) else skip ; 
     (Main.newMain()).__solve(rep) );
   operation __solve( rep : int) : void
  pre: true
  post: true
  activity: (     try (    var cin : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (         var i : int ; i := 0 ; while i < rep do ( (     execute __solve(cin) )  ;     i := i + 1 ) ))  );
   operation __solve( cin : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := cin.getCurrent()->toInteger() ;
     var s : String ; s := cin.getCurrent() ;
    var Ecount : int ; Ecount := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     Ecount := Ecount+((if s->at(i+1) = 'E' then 1 else 0 endif)) )  ;     i := i + 1 ) ; 
    var min : int ; min := N ;
    var Wcount : int ; Wcount := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (s->at(i+1) = 'W') then (     min := Set{min, Wcount + Ecount}->min() ; 
     Wcount := Wcount + 1 ) else (     Ecount := Ecount - 1 ; 
     min := Set{min, Wcount + Ecount}->min() ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Point2D ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n ;
    Point2D.Double p[];
    int start ;
    int count ;
    n=sc.nextInt();
    while(n!=0){
      p=new Point2D.Double[n];
      start=0 ;
      count=0 ;
      for(int i=0 ; i<n ; i++){
        String s[]=sc.next().split(",");
        p[i]=new Point2D.Double(Double.valueOf(s[0]),Double.valueOf(s[1]));
        if(p[i] .x<p[start] .x){
          start=i ;
        }
      }
      int pre=start ;
      while(true){
        for(int i=0 ; i<n ; i++){
          if(i!=pre){
            boolean flag=true ;
            for(int j=0 ; j<n && flag ; j++){
              if(j!=i && j!=pre){
                flag=isLeft(p[pre],p[i],p[j]);
              }
            }
            if(flag){
              count++;
              pre=i ;
              break ;
            }
          }
        }
        if(pre==start){
          break ;
        }
      }
      System.out.println(n-count);
      n=sc.nextInt();
    }
  }
  public static boolean isLeft(Point2D.Double p,Point2D.Double q,Point2D.Double x){
    double dx1=q.x-p.x ;
    double dy1=q.y-p.y ;
    double dx2=x.x-p.x ;
    double dy2=x.y-p.y ;
    if(0<dx1*dy2-dx2*dy1){
      return true ;
    }
    else {
      return false ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var p : Sequence(double) ;
    var start : int ;
    var count : int ;
    n := sc.getCurrent()->toInteger() ; 
    while (n /= 0) do (     p := Integer.subrange(1,n)->collect(null) ; 
     start := 0 ; 
    count := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     var s : Sequence(String) ; s := sc.getCurrent()->split(",") ;
     p[i+1] := Double.newDouble((s[0+1])->toReal(), (s[1+1])->toReal()) ; 
     if (p[i+1].x < p[start+1].x) then (     start := i ) else skip )  ;     i := i + 1 ) ; 
    var pre : int ; pre := start ;
    while (true) do (         var i : int ; i := 0 ; while i < n do ( (     if (i /= pre) then (     var flag : boolean ; flag := true ;
         var j : int ; j := 0 ; while j < n & flag do ( (     if (j /= i & j /= pre) then (     flag := isLeft(p[pre+1], p[i+1], p[j+1]) ) else skip )  ;     j := j + 1 ) ; 
     if (flag) then (     count := count + 1 ; 
     pre := i ; 
     break ) else skip ) else skip )  ;     i := i + 1 ) ; 
     if (pre = start) then (     break ) else skip ) ; 
    OclFile["System.out"].println(n - count) ; 
    n := sc.getCurrent()->toInteger() ; 
 ) ; 
 );
  static   operation isLeft( p : Double, q : Double, x : Double) : boolean
  pre: true
  post: true
  activity: (     var dx1 : double ; dx1 := q.x - p.x ;
     var dy1 : double ; dy1 := q.y - p.y ;
    var dx2 : double ; dx2 := x.x - p.x ;
    var dy2 : double ; dy2 := x.y - p.y ;
    if (0 < dx1 * dy2 - dx2 * dy1) then (     return true ) else (     return false ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  class Point {
    public double x,y ;
    public String toString(){
      return "("+x+","+y+")" ;
    }
    public Point(double x,double y){
      this.x=x ;
      this.y=y ;
    }
  }
  double getTheta(Point p,Point p0){
    double theta=Math.acos((p.x-p0.x)/Math.hypot(p.x-p0.x,p.y-p0.y));
    if(p.y<p0.y)theta=Math.PI*2-theta ;
    return theta ;
  }
  int solve(Point[] points){
    Point start=points[0];
    for(Point v : points){
      if(v.y<start.y)start=v ;
    }
    Point p0=start ;
    int n=0 ;
    double prev=0 ;
    do {
      double min=Math.PI*3 ;
      Point next=p0 ;
      for(Point p : points){
        double theta=getTheta(p,p0);
        if(theta>=prev && theta<min){
          min=theta ;
          next=p ;
        }
      }
      p0=next ;
      prev=min ;
++n ;
    }
    while(p0!=start);
    return points.length-n ;
  }
  double nd(){
    return sc.nextDouble();
  }
  int ni(){
    return sc.nextInt();
  }
  void io(){
    sc=new Scanner(System.in).useDelimiter(",|\r\n|\n");
    int n ;
    Point[] points ;
    while((n=ni())!=0){
      points=new Point[n];
      for(int i=0 ; i<n ; ++i){
        points[i]=new Point(nd(),nd());
      }
      System.out.println(solve(points));
    }
    sc.close();
  }
  public static void main(String[] args){
    new Main().io();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
 class Point {
   attribute x : double;
   operation toString() : String
  pre: true
  post: true
  activity: (     return "(" + x + "," + y + ")" );
   static operation newPoint( x : double, y : double) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}
   operation getTheta( p : Point, p0 : Point) : double
  pre: true
  post: true
  activity: (     var theta : double ; theta := ((p.x - p0.x) / hypot(p.x - p0.x, p.y - p0.y))->acos() ;
     if (p.y < p0.y) then     theta := 3.141592653589793 * 2 - theta ; else skip ; 
     return theta );
   operation solve( points : Sequence(Point)) : int
  pre: true
  post: true
  activity: (     var start : Point ; start := points[0+1] ;
     for (v : points) do ( (     if (v.y < start.y) then     start := v ; else skip )  ) ; 
    var p0 : Point ; p0 := start ;
    var n : int ; n := 0 ;
    var prev : double ; prev := 0 ;
  while true do ((     var min : double ; min := 3.141592653589793 * 3 ;
     var next : Point ; next := p0 ;
    for (p : points) do ( (     var theta : double ; theta := getTheta(p, p0) ;
     if (theta >= prev & theta < min) then (     min := theta ; 
     next := p ) else skip )  ) ; 
    p0 := next ; 
    prev := min ; 
    n := n + 1 ; 
 ) ;
    if (p0 /= start) then skip else break) ; 
    return points->size() - n 
 );
   operation nd() : double
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toReal() );
   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
   operation io() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]).useDelimiter(",|\r\n|\n") ; 
     var n : int ;
    var points : Sequence(Point) ;
        n := ni() ;
    while ((n) /= 0) do (    skip ; (     points := Integer.subrange(1,n)->collect(null) ; 
         var i : int ; i := 0 ; while i < n do ( (     points[i+1] := Point.newPoint(nd(), nd()) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(solve(points)) ) ;     n := ni() ;
 ) ;  
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().io() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean canBeEqual(char[] a,char[] b,int n){
    Vector<Character>A=new Vector<>();
    Vector<Character>B=new Vector<>();
    for(int i=0 ; i<n ; i++){
      if(a[i]!=b[i]){
        A.add(a[i]);
        B.add(b[i]);
      }
    }
    if(A.size()==B.size()&& B.size()==0)return true ;
    if(A.size()==B.size()&& B.size()==2){
      if(A.get(0)==A.get(1)&& B.get(0)==B.get(1))return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    char[] A="SEEKSFORGEEKS".toCharArray();
    char[] B="GEEKSFORGEEKG".toCharArray();
    if(canBeEqual(A,B,A.length))System.out.printf("Yes");
    else System.out.printf("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation canBeEqual( a : Sequence(String), b : Sequence(String), n : int) : boolean
  pre: true
  post: true
  activity: (     var A : Sequence(String) ; A := Sequence{} ;
     var B : Sequence(String) ; B := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] /= b[i+1]) then (     A := A->including(a[i+1]) ; 
     B := B->including(b[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    if (A->size() = B->size() & B->size() = 0) then     return true else skip ; 
    if (A->size() = B->size() & B->size() = 2) then (     if (A->at(0+1) = A->at(1+1) & B->at(0+1) = B->at(1+1)) then     return true else skip ) else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(String) ; A := "SEEKSFORGEEKS"->characters() ;
     var B : Sequence(String) ; B := "GEEKSFORGEEKG"->characters() ;
     if (canBeEqual(A, B, A->size())) then     OclFile["System.out"].printf("Yes") ; else     OclFile["System.out"].printf("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int MOD=100000 ;
  public static void main(String[] args){
    while(true){
      int N=sc.nextInt();
      N*=N ;
      int M=sc.nextInt();
      int S=sc.nextInt();
      if(N==0)break ;
      int[][] dp=new int[S+1][N+1];
      dp[0][0]=1 ;
      for(int i=1 ; i<=M ; ++i){
        for(int j=S-i ; j>=0 ; --j){
          for(int k=N-1 ; k>=0 ; --k){
            dp[j+i][k+1]+=dp[j][k];
            if(dp[j+i][k+1]>=MOD)dp[j+i][k+1]-=MOD ;
          }
        }
      }
      System.out.println(dp[S][N]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute MOD : int := 100000;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     N := N*(N) ; 
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var S : int ; S := sc.getCurrent()->toInteger() ;
    if (N = 0) then     break else skip ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,S + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= M do ( (         var j : int ; j := S - i ; while j >= 0 do ( (         var k : int ; k := N - 1 ; while k >= 0 do ( (     dp[j + i+1][k + 1+1] := dp[j + i+1][k + 1+1]+(dp[j+1][k+1]) ; 
     if (dp[j + i+1][k + 1+1] >= MOD) then     dp[j + i+1][k + 1+1] := dp[j + i+1][k + 1+1]-(MOD) ; else skip )  ;     k := k - 1 ) )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[S+1][N+1]) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int MOD=100000 ;
    for(; ; ){
      int N=sc.nextInt(),M=sc.nextInt(),S=sc.nextInt();
      if((N | M | S)==0)break ;
      N*=N ;
      int[][] dp=new int[N+1][S+1];
      dp[0][0]=1 ;
      for(int m=1 ; m<=M ; m++)for(int k=N ; k>0 ; k--)for(int s=m ; s<=S ; s++){
        dp[k][s]+=dp[k-1][s-m];
        if(MOD<=dp[k][s])dp[k][s]-=MOD ;
      }
      System.out.println(dp[N][S]);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var MOD : int ; MOD := 100000 ;
       while true do ( (     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var S : int ; S := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseOr(MathLib.bitwiseOr(N,M),S)) = 0) then     break else skip ; 
    N := N*(N) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,S + 1)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var m : int ; m := 1 ; while m <= M do (         var k : int ; k := N ; while k > 0 do (         var s : int ; s := m ; while s <= S do ( (     dp[k+1][s+1] := dp[k+1][s+1]+(dp[k - 1+1][s - m+1]) ; 
     if (MOD <= dp[k+1][s+1]) then     dp[k+1][s+1] := dp[k+1][s+1]-(MOD) ; else skip )  ;     s := s + 1 ) ;  ;     k := k - 1 ) ;  ;     m := m + 1 ) ; 
    OclFile["System.out"].println(dp[N+1][S+1]) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt(),m=sc.nextInt(),s=sc.nextInt();
      if((n | m | s)==0)break ;
      int[][] dp=new int[n*n+1][s+1];
      dp[0][0]=1 ;
      for(int j=1 ; j<=m ; j++)for(int i=n*n ; i>=1 ; i--)for(int k=s ; k>=j ; k--){
        dp[i][k]=(dp[i][k]+dp[i-1][k-j])% 100000 ;
      }
      System.out.println(dp[n*n][s]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseOr(MathLib.bitwiseOr(n,m),s)) = 0) then     break else skip ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n * n + 1)->collect(Integer.subrange(1,s + 1)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var j : int ; j := 1 ; while j <= m do (         var i : int ; i := n * n ; while i >= 1 do (         var k : int ; k := s ; while k >= j do ( (     dp[i+1][k+1] := (dp[i+1][k+1] + dp[i - 1+1][k - j+1]) mod 100000 )  ;     k := k - 1 ) ;  ;     i := i - 1 ) ;  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(dp[n * n+1][s+1]) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int[] runningSum(int[] nums){
    if(nums.length<=1)return nums ;
    for(int i=1 ; i<nums.length ; i++)nums[i]+=nums[i-1];
    return nums ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation runningSum( nums : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     if (nums->size() <= 1) then     return nums else skip ; 
         var i : int ; i := 1 ; while i < nums->size() do (     nums[i+1] := nums[i+1]+(nums[i - 1+1]) ;  ;     i := i + 1 ) ; 
     return nums );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p017 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p017().run());
  }
  public String run(){
    int sum=0 ;
    for(int i=1 ; i<=1000 ; i++)sum+=toEnglish(i).length();
    return Integer.toString(sum);
  }
  private static String toEnglish(int n){
    if(0<=n && n<20)return ONES[n];
    else if(20<=n && n<100)return TENS[n/10]+(n % 10!=0 ? ONES[n % 10] : "");
    else if(100<=n && n<1000)return ONES[n/100]+"hundred"+(n % 100!=0 ? "and"+toEnglish(n % 100): "");
    else if(1000<=n && n<1000000)return toEnglish(n/1000)+"thousand"+(n % 1000!=0 ? toEnglish(n % 1000): "");
    else throw new IllegalArgumentException();
  }
  private static String[] ONES={
    "zero","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen" };
    private static String[] TENS={
      "","","twenty","thirty","forty","fifty","sixty","seventy","eighty","ninety" };
    }

------------------------------------------------------------
OCL File:
---------
class p017 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p017.newp017().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= 1000 do (     sum := sum+(toEnglish(i)->size()) ;  ;     i := i + 1 ) ; 
     return ((sum) + "") );
  static   operation toEnglish( n : int) : String
  pre: true
  post: true
  activity: (     if (0 <= n & n < 20) then     return ONES[n+1] else     if (20 <= n & n < 100) then     return TENS[n / 10+1] + (if n mod 10 /= 0 then ONES[n mod 10+1] else "" endif) else     if (100 <= n & n < 1000) then     return ONES[n / 100+1] + "hundred" + (if n mod 100 /= 0 then "and" + toEnglish(n mod 100) else "" endif) else     if (1000 <= n & n < 1000000) then     return toEnglish(n / 1000) + "thousand" + (if n mod 1000 /= 0 then toEnglish(n mod 1000) else "" endif) else     error IllegalArgumentException.newIllegalArgumentException() ; ;  ;  ;  );
  static   attribute ONES : Sequence(String) := Sequence{"zero","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen"};
  static   attribute TENS : Sequence(String) := Sequence{"","","twenty","thirty","forty","fifty","sixty","seventy","eighty","ninety"};
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.util.Comparator.*;
import java.math.BigInteger ;
public class Main {
  private static BigInteger MOD=BigInteger.valueOf(1000000007L);
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    List<BigInteger>numList=new LinkedList<>();
    for(int i=0 ; i<N ; i++){
      numList.add(BigInteger.valueOf(Long.parseLong(sc.next())));
    }
    BigInteger lcmNum=numList.stream().sorted(reverseOrder()).reduce(numList.get(0),(s1,s2)->s1.multiply(s2.divide(s1.gcd(s2))));
    BigInteger res=numList.stream().parallel().map(s->lcmNum.divide(s)).reduce(BigInteger.ZERO,(s1,s2)->s1.add(s2));
    System.out.println(res.mod(MOD));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute MOD : long := (1000000007L + "")->toLong();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var numList : Sequence(long) ; numList := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     numList := numList->including(((sc.getCurrent())->toLong() + "")->toLong()) )  ;     i := i + 1 ) ; 
    var lcmNum : long ; lcmNum := numList->sort()->iterate( _var; _acc : OclAny | numList->at(0+1), lambda (s1 , s2) : OclAny in s1.multiply(s2.divide(s1.gcd(s2)))->apply((_acc,_var)) ) ;
    var res : long ; res := numList->collect( _x1 | (lambda s : OclAny in lcmNum.divide(s))->apply(_x1) )->iterate( _var; _acc : OclAny | 0, lambda (s1 , s2) : OclAny in s1->excludes(s2)->apply((_acc,_var)) ) ;
    OclFile["System.out"].println(res.mod(MOD)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class CodeTest {
  public static void main(String[] args){
    ArrayList<Integer>bookNum=new ArrayList<>();
    int sum=0,count=0 ;
    int freq[]=new int[10001];
    int day,ex ;
    Scanner input=new Scanner(System.in);
    day=input.nextInt();
    for(int i=0 ; i<day ; i++){
      ex=input.nextInt();
      freq[ex]++;
      bookNum.add(ex);
    }
    for(int i=1 ; i<=day ; i++){
      sum++;
      if(sum==freq[i]){
        count++;
        sum=0 ;
      }
      else {
        sum-=freq[i];
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeTest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bookNum : Sequence(int) ; bookNum := Sequence{} ;
     var sum : int ; sum := 0 ;
    var count : int ; count := 0 ;
    var freq : Sequence(int) ; freq := Integer.subrange(1,10001)->collect(0) ;
    var day : int ;
    var ex : int ;
    var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    day := input.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < day do ( (     ex := input.getCurrent()->toInteger() ; 
     freq[ex+1] := freq[ex+1] + 1 ; 
     bookNum := bookNum->including(ex) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= day do ( (     sum := sum + 1 ; 
     if (sum = freq[i+1]) then (     count := count + 1 ; 
     sum := 0 ) else (     sum := sum-(freq[i+1]) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Div2A {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    FastReader fsr=new FastReader();
    int n=fsr.nextInt();
    int[] mysteries=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      mysteries[i]=fsr.nextInt();
    }
    solution(n,mysteries,out);
    out.flush();
    out.close();
  }
  private static void solution(int n,int[] mysteries,PrintWriter out){
    int page=1 ;
    int numDays=0 ;
    int furthestMystery=0 ;
    while(page<=n){
      numDays++;
      for(int i=page ; i<=n ; i++){
        furthestMystery=Math.max(furthestMystery,mysteries[i]);
        if(i>=furthestMystery){
          page=i+1 ;
          break ;
        }
      }
    }
    out.println(numDays);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Div2A {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var fsr : FastReader ; fsr := FastReader.newFastReader() ;
    var n : int ; n := fsr.nextInt() ;
    var mysteries : Sequence(int) ; mysteries := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     mysteries[i+1] := fsr.nextInt() )  ;     i := i + 1 ) ; 
    execute solution(n, mysteries, out) ; 
    skip ; 
    skip ; 
 );
  static   operation solution( n : int, mysteries : Sequence(int), out : OclFile) : void
  pre: true
  post: true
  activity: (     var page : int ; page := 1 ;
     var numDays : int ; numDays := 0 ;
    var furthestMystery : int ; furthestMystery := 0 ;
    while (page <= n) do (     numDays := numDays + 1 ; 
         var i : int ; i := page ; while i <= n do ( (     furthestMystery := Set{furthestMystery, mysteries[i+1]}->max() ; 
     if (i >= furthestMystery) then (     page := i + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    char[] s=sc.next().toCharArray();
    long ans=Long.MAX_VALUE ;
    int[] WL=new int[n];
    int[] EL=new int[n];
    for(int i=0 ; i<n ; i++){
      if(s[i]=='E'){
        EL[i]++;
      }
      else {
        WL[i]++;
      }
      if(i!=0){
        WL[i]+=WL[i-1];
        EL[i]+=EL[i-1];
      }
    }
    for(int i=0 ; i<n ; i++){
      if(i==0){
        ans=Math.min(ans,EL[n-1]-EL[i]);
      }
      else {
        ans=Math.min(ans,WL[i-1]+EL[n-1]-EL[i]);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var ans : long ; ans := "9223372036854775807"->toLong() ;
    var WL : Sequence(int) ; WL := Integer.subrange(1,n)->collect(0) ;
    var EL : Sequence(int) ; EL := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] = 'E') then (     EL[i+1] := EL[i+1] + 1 ) else (     WL[i+1] := WL[i+1] + 1 ) ;  
     if (i /= 0) then (     WL[i+1] := WL[i+1]+(WL[i - 1+1]) ; 
     EL[i+1] := EL[i+1]+(EL[i - 1+1]) ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i = 0) then (     ans := Set{ans, EL[n - 1+1] - EL[i+1]}->min() ) else (     ans := Set{ans, WL[i - 1+1] + EL[n - 1+1] - EL[i+1]}->min() ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<a.length ; i++){
      a[i]=sc.nextInt();
    }
    System.out.println(solve(a));
    sc.close();
  }
  static int solve(int[] a){
    int result=0 ;
    int maxPage=-1 ;
    for(int i=0 ; i<a.length ; i++){
      maxPage=Math.max(maxPage,a[i]);
      if(maxPage==i+1){
        result++;
      }
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(a)) ; 
    skip ; 
 );
  static   operation solve( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var maxPage : int ; maxPage := -1 ;
         var i : int ; i := 0 ; while i < a->size() do ( (     maxPage := Set{maxPage, a[i+1]}->max() ; 
     if (maxPage = i + 1) then (     result := result + 1 ) else skip )  ;     i := i + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  private static int ans[]=new int[1000];
  private static int pos ;
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      int n=in.nextInt();
      if(n==0)return ;
      rec(n,n);
    }
  }
  private static void rec(int res,int ub){
    if(res==0){
      for(int i=0 ; ; i++){
        System.out.print(ans[i]+((ans[i+1]>0)? " " : "\n"));
        if(ans[i+1]==0)return ;
      }
    }
    for(int i=Math.min(res,ub); i>=1 ; i--){
      ans[pos]=i ;
      pos++;
      rec(res-i,i);
      pos--;
      ans[pos]=0 ;
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ans : int := Integer.subrange(1,1000)->collect(0);
  static   attribute pos : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
     execute rec(n, n) )  ) );
  static   operation rec( res : int, ub : int) : void
  pre: true
  post: true
  activity: (     if (res = 0) then (         var i : int ; i := 0 ; while true do ( (     OclFile["System.out"].print(ans[i+1] + (if (ans[i + 1+1] > 0) then " " else "\n" endif)) ; 
     if (ans[i + 1+1] = 0) then     return else skip )  ;     i := i + 1 ) ) else skip ; 
         var i : int ; i := Set{res, ub}->min() ; while i >= 1 do ( (     ans[pos+1] := i ; 
     pos := pos + 1 ; 
    execute rec(res - i, i) ; 
    pos := pos - 1 ; 
    ans[pos+1] := 0 ; 
 )  ;     i := i - 1 ) ; 
     return );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int n ;
  ArrayList<Integer>list ;
  void loop(int x){
    for(int i=n-x ; i>0 ; i--){
      if(list.size()==0 || list.get(list.size()-1)>=i){
        list.add(i);
        if(x+i==n)print();
        else loop(x+i);
        list.remove(list.size()-1);
      }
    }
  }
  void print(){
    for(int i=0 ; i<list.size(); i++){
      if(i!=0)System.out.print(" ");
      System.out.print(list.get(i));
    }
    System.out.println();
  }
  void solve(){
    Scanner sc=new Scanner(System.in);
    while(true){
      n=sc.nextInt();
      if(n==0)break ;
      list=new ArrayList<Integer>();
      loop(0);
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute list : Sequence(int);
   operation loop( x : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := n - x ; while i > 0 do ( (     if (list->size() = 0 or list->at(list->size() - 1+1) >= i) then (     list := list->including(i) ; 
     if (x + i = n) then     execute print() else     execute loop(x + i) ; ;  
     list := list->excludingFirst(list->size() - 1) ) else skip )  ;     i := i - 1 ) );
   operation print() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < list->size() do ( (     if (i /= 0) then     OclFile["System.out"].print(" ") ; else skip ; 
     OclFile["System.out"].print(list->at(i+1)) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
     list := Sequence{} ; 
     execute loop(0) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
  private void run(){
    Scanner scan=new Scanner(System.in);
    int number=scan.nextInt();
    while(number!=0){
      int[] string=new int[number];
      for(int i=0 ; i<number ; i++){
        string[i]=0 ;
      }
      string[0]=number ;
      System.out.println(string[0]);
      int digit=decrease(string,number);
      while(digit!=number){
        for(int i=0 ; i<=digit ; i++){
          System.out.print(string[i]);
          if(i!=digit){
            System.out.print(" ");
          }
          else {
            System.out.println();
          }
        }
        digit=decrease(string,number);
      }
      number=scan.nextInt();
    }
  }
  private int decrease(int[] string,int number){
    for(int i=number-1 ; i>=0 ; i--){
      if(string[i]>1){
        string[i]--;
        if(string[i]==1){
          int digit=0 ;
          for(int j=0 ; j<number ; j++){
            if(string[j]==0){
              string[j]=1 ;
              digit=j ;
              break ;
            }
          }
          return digit ;
        }
        else {
          int sum ;
          int end=i ;
          do {
            sum=0 ;
            for(int j=0 ; j<end+1 ; j++){
              sum+=string[j];
            }
            if(sum<number){
              if(number-sum>string[end]){
                string[end+1]=string[end];
              }
              else {
                string[end+1]=number-sum ;
              }
            }
            end++;
          }
          while(sum!=number);
          for(int p=end ; p<number ; p++){
            string[p]=0 ;
          }
          return end-1 ;
        }
      }
    }
    return number ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := scan.getCurrent()->toInteger() ;
     while (number /= 0) do (     var string : Sequence(int) ; string := Integer.subrange(1,number)->collect(0) ;
         var i : int ; i := 0 ; while i < number do ( (     string[i+1] := 0 )  ;     i := i + 1 ) ; 
    string[0+1] := number ; 
    OclFile["System.out"].println(string[0+1]) ; 
    var digit : int ; digit := decrease(string, number) ;
    while (digit /= number) do (         var i : int ; i := 0 ; while i <= digit do ( (     OclFile["System.out"].print(string[i+1]) ; 
     if (i /= digit) then (     OclFile["System.out"].print(" ") ) else (     OclFile["System.out"].println() ) )  ;     i := i + 1 ) ; 
     digit := decrease(string, number) ) ; 
    number := scan.getCurrent()->toInteger() ; 
 ) );
   operation decrease( string : Sequence(int), number : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := number - 1 ; while i >= 0 do ( (     if (string[i+1] > 1) then (     string[i+1] := string[i+1] - 1 ; 
     if (string[i+1] = 1) then (     var digit : int ; digit := 0 ;
         var j : int ; j := 0 ; while j < number do ( (     if (string[j+1] = 0) then (     string[j+1] := 1 ; 
     digit := j ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     return digit ) else (     var sum : int ;
     var end : int ; end := i ;
  while true do ((     sum := 0 ; 
         var j : int ; j := 0 ; while j < end + 1 do ( (     sum := sum+(string[j+1]) )  ;     j := j + 1 ) ; 
     if (sum < number) then (     if (number - sum > string[end+1]) then (     string[end + 1+1] := string[end+1] ) else (     string[end + 1+1] := number - sum ) ) else skip ; 
     end := end + 1 ) ;
    if (sum /= number) then skip else break) ; 
        var p : int ; p := end ; while p < number do ( (     string[p+1] := 0 )  ;     p := p + 1 ) ; 
    return end - 1 
 ) ) else skip )  ;     i := i - 1 ) ; 
     return number );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      int n=Integer.parseInt(br.readLine());
      if(n==0){
        break ;
      }
      writeNumbers("",n,n);
    }
  }
  static void writeNumbers(String str,int n,int prev){
    for(int i=n ; i>=1 ; i--){
      String[] tmpArray=str.split(" ");
      if(i==n && i<=prev){
        System.out.println(str+n);
      }
      else if(i<=prev){
        if(str.equals("")){
          writeNumbers(i+" ",n-i,i);
        }
        else {
          writeNumbers(str+i+" ",n-i,i);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var n : int ; n := (br.readLine())->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
     execute writeNumbers("", n, n) ) );
  static   operation writeNumbers( str : String, n : int, prev : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := n ; while i >= 1 do ( (     var tmpArray : Sequence(String) ; tmpArray := str->split(" ") ;
     if (i = n & i <= prev) then (     OclFile["System.out"].println(str + n) ) else     if (i <= prev) then (     if (str = "") then (     execute writeNumbers(i + " ", n - i, i) ) else (     execute writeNumbers(str + i + " ", n - i, i) ) ) else skip ; )  ;     i := i - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static public void main(String[] argv){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      while(true){
        String buf=br.readLine();
        int n ;
        n=Integer.valueOf(buf);
        if(n==0)break ;
        solve(n,n,"");
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  static void solve(int max,int total,String str){
    for(int i=max ; i>=1 ; i--){
      int rest=total-i ;
      if(rest<0){
        continue ;
      }
      else if(rest==0){
        String buf=str+i ;
        System.out.println(buf);
      }
      else if(rest>0){
        String buf=str+(i+" ");
        solve(i,rest,buf);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    operation main( argv : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var buf : String ; buf := br.readLine() ;
     var n : int ;
    n := (buf)->toInteger() ; 
    if (n = 0) then     break else skip ; 
    execute solve(n, n, "") ; 
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
  static   operation solve( max : int, total : int, str : String) : void
  pre: true
  post: true
  activity: (         var i : int ; i := max ; while i >= 1 do ( (     var rest : int ; rest := total - i ;
     if (rest < 0) then (     continue ) else     if (rest = 0) then (     var buf : String ; buf := str + i ;
     OclFile["System.out"].println(buf) ) else     if (rest > 0) then (     var buf : String ; buf := str + (i + " ") ;
     execute solve(i, rest, buf) ) else skip ; ;  )  ;     i := i - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastReader in=new FastReader();
    int n=in.nextInt();
    int[][] ara=new int[n][2];
    for(int i=1 ; i<=n ; i++){
      ara[i-1][0]=in.nextInt();
      ara[i-1][1]=in.nextInt();
    }
    int mark=in.nextInt();
    for(int i=1 ; i<=n ; i++){
      if(ara[i-1][0]<=mark && mark<=ara[i-1][1]){
        System.out.println(n-i+1);
        break ;
      }
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
    String next(){
      while(st==null || ! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var n : int ; n := in.nextInt() ;
    var ara : Sequence(Sequence(int)) ; ara := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (     ara[i - 1+1][0+1] := in.nextInt() ; 
     ara[i - 1+1][1+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    var mark : int ; mark := in.nextInt() ;
        var i : int ; i := 1 ; while i <= n do ( (     if (ara[i - 1+1][0+1] <= mark & mark <= ara[i - 1+1][1+1]) then (     OclFile["System.out"].println(n - i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector ;
public class GFG {
  static final int MAX=1005 ;
  static void SieveOfEratosthenes(Vector<Integer>primes){
    boolean prime[]=new boolean[MAX];
    for(int i=0 ; i<prime.length ; i++){
      prime[i]=true ;
    }
    for(int p=2 ; p*p<MAX ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<MAX ; i+=p){
          prime[i]=false ;
        }
      }
    }
    for(int p=2 ; p<MAX ; p++){
      if(prime[p]){
        primes.add(primes.size(),p);
      }
    }
  }
  static int minimumSquareFreeDivisors(int N){
    Vector<Integer>primes=new Vector<>();
    SieveOfEratosthenes(primes);
    int max_count=0 ;
    for(int i=0 ; i<primes.size()&& primes.get(i)*primes.get(i)<=N ; i++){
      if(N % primes.get(i)==0){
        int tmp=0 ;
        while(N % primes.get(i)==0){
          tmp++;
          N/=primes.get(i);
        }
        max_count=Math.max(max_count,tmp);
      }
    }
    if(max_count==0){
      max_count=1 ;
    }
    return max_count ;
  }
  public static void main(String[] args){
    int N=24 ;
    System.out.println("Minimum Number of Square Free Divisors is "+minimumSquareFreeDivisors(N));
    N=6 ;
    System.out.println("Minimum Number of Square Free Divisors is "+minimumSquareFreeDivisors(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX : int := 1005;
  static   operation SieveOfEratosthenes( primes : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,MAX)->collect(false) ;
         var i : int ; i := 0 ; while i < prime->size() do ( (     prime[i+1] := true )  ;     i := i + 1 ) ; 
         var p : int ; p := 2 ; while p * p < MAX do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i < MAX do ( (     prime[i+1] := false )  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
         var p : int ; p := 2 ; while p < MAX do ( (     if (prime[p+1]) then (     primes->excludes(primes->size(), p) ) else skip )  ;     p := p + 1 ) );
  static   operation minimumSquareFreeDivisors( N : int) : int
  pre: true
  post: true
  activity: (     var primes : Sequence(int) ; primes := Sequence{} ;
     execute SieveOfEratosthenes(primes) ; 
    var max_count : int ; max_count := 0 ;
        var i : int ; i := 0 ; while i < primes->size() & primes->at(i+1) * primes->at(i+1) <= N do ( (     if (N mod primes->at(i+1) = 0) then (     var tmp : int ; tmp := 0 ;
     while (N mod primes->at(i+1) = 0) do (     tmp := tmp + 1 ; 
     N := N/(primes->at(i+1)) ) ; 
     max_count := Set{max_count, tmp}->max() ) else skip )  ;     i := i + 1 ) ; 
    if (max_count = 0) then (     max_count := 1 ) else skip ; 
    return max_count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 24 ;
     OclFile["System.out"].println("Minimum Number of Square Free Divisors is " + minimumSquareFreeDivisors(N)) ; 
     N := 6 ; 
     OclFile["System.out"].println("Minimum Number of Square Free Divisors is " + minimumSquareFreeDivisors(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class NastyaReadingBook {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[] A=new int[2*n];
    for(int i=0 ; i<2*n ; i+=2){
      scan.nextLine();
      A[i]=scan.nextInt();
      A[i+1]=scan.nextInt();
    }
    scan.nextLine();
    int k=scan.nextInt();
    for(int i=1 ; i<A.length ; i+=2){
      if(k<=A[i]){
        System.out.println(n-i/2);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NastyaReadingBook {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,2 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     skip ; 
     A[i+1] := scan.getCurrent()->toInteger() ; 
     A[i + 1+1] := scan.getCurrent()->toInteger() )  ;     i := i+(2) ) ; 
    skip ; 
    var k : int ; k := scan.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i < A->size() do ( (     if (k <= A[i+1]) then (     OclFile["System.out"].println(n - i / 2) ; 
     return ) else skip )  ;     i := i+(2) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class NastyaReadingBook {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[] A=new int[2*n];
    int j=0 ;
    for(int i=0 ; i<n ; i++){
      scan.nextLine();
      A[j]=scan.nextInt();
      j++;
      A[j]=scan.nextInt();
      j++;
    }
    scan.nextLine();
    int k=scan.nextInt();
    for(int i=1 ; i<A.length ; i+=2){
      if(k<=A[i]){
        System.out.println(n-i/2);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NastyaReadingBook {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,2 * n)->collect(0) ;
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     skip ; 
     A[j+1] := scan.getCurrent()->toInteger() ; 
    j := j + 1 ; 
    A[j+1] := scan.getCurrent()->toInteger() ; 
    j := j + 1 ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    var k : int ; k := scan.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i < A->size() do ( (     if (k <= A[i+1]) then (     OclFile["System.out"].println(n - i / 2) ; 
     return ) else skip )  ;     i := i+(2) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class problem1136A {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int supterNumber=input.nextInt();
    int[] supterNumber1stPage=new int[supterNumber];
    int[] supterNumberLastPage=new int[supterNumber];
    int count=0 ;
    for(int i=0 ; i<supterNumber ; i++){
      supterNumber1stPage[i]=input.nextInt();
      supterNumberLastPage[i]=input.nextInt();
    }
    int readThePageNumber=input.nextInt();
    for(int i=0 ; i<supterNumber ; i++){
      if(supterNumberLastPage[i]>=readThePageNumber){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class problem1136A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var supterNumber : int ; supterNumber := input.getCurrent()->toInteger() ;
    var supterNumber1stPage : Sequence(int) ; supterNumber1stPage := Integer.subrange(1,supterNumber)->collect(0) ;
    var supterNumberLastPage : Sequence(int) ; supterNumberLastPage := Integer.subrange(1,supterNumber)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < supterNumber do ( (     supterNumber1stPage[i+1] := input.getCurrent()->toInteger() ; 
     supterNumberLastPage[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var readThePageNumber : int ; readThePageNumber := input.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < supterNumber do ( (     if (supterNumberLastPage[i+1] >= readThePageNumber) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
public class GFG {
  static int perfectSquare(String s){
    int n=s.length();
    int ans=-1 ;
    String num="" ;
    for(int i=1 ; i<(1<<n); i++){
      String str="" ;
      for(int j=0 ; j<n ; j++){
        if(((i>>j)& 1)==1){
          str+=s.charAt(j);
        }
      }
      if(str.charAt(0)!='0'){
        int temp=0 ;
        for(int j=0 ; j<str.length(); j++)temp=temp*10+(int)(str.charAt(j)-'0');
        int k=(int)Math.sqrt(temp);
        if(k*k==temp){
          if(ans<(int)str.length()){
            ans=(int)str.length();
            num=str ;
          }
        }
      }
    }
    if(ans==-1)return ans ;
    else {
      System.out.print(num+" ");
      return n-ans ;
    }
  }
  public static void main(String args[]){
    System.out.println(perfectSquare("8314"));
    System.out.println(perfectSquare("753"));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation perfectSquare( s : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var ans : int ; ans := -1 ;
    var num : String ; num := "" ;
        var i : int ; i := 1 ; while i < ((1*(2->pow(n)))->oclAsType(long)) do ( (     var str : String ; str := "" ;
         var j : int ; j := 0 ; while j < n do ( (     if ((((i/(2->pow(j)))->oclAsType(long)) & 1) = 1) then (     str := str+(s->at(j+1)) ) else skip )  ;     j := j + 1 ) ; 
     if (str->at(0+1) /= '0') then (     var temp : int ; temp := 0 ;
         var j : int ; j := 0 ; while j < str->size() do (     temp := temp * 10 + (str->at(j+1) - ('0')->char2byte())->oclAsType(int) ;  ;     j := j + 1 ) ; 
     var k : int ; k := (temp)->sqrt()->oclAsType(int) ;
     if (k * k = temp) then (     if (ans < str->size()->oclAsType(int)) then (     ans := str->size()->oclAsType(int) ; 
     num := str ) else skip ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (ans = -1) then     return ans else (     OclFile["System.out"].print(num + " ") ; 
     return n - ans ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(perfectSquare("8314")) ; 
     OclFile["System.out"].println(perfectSquare("753")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<List<Integer>>ans=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      List<Integer>l1=new ArrayList<>();
      int p=sc.nextInt();
      int q=sc.nextInt();
      l1.add(p);
      l1.add(q);
      ans.add(l1);
    }
    int k=sc.nextInt();
    int answer=0 ;
    for(List i : ans){
      int flag=0 ;
      List<Integer>l2=new ArrayList<>(i);
      for(Integer j : l2){
        if(j>k){
          flag=1 ;
          break ;
        }
        else if(j<k){
          answer=answer+1 ;
        }
      }
      if(flag==1){
        break ;
      }
    }
    System.out.println(n-(answer/2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ans : Sequence(Sequence(int)) ; ans := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var l1 : Sequence(int) ; l1 := Sequence{} ;
     var p : int ; p := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    l1 := l1->including(p) ; 
    l1 := l1->including(q) ; 
    ans := ans->including(l1) ; 
 )  ;     i := i + 1 ) ; 
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var answer : int ; answer := 0 ;
    for (i : ans) do ( (     var flag : int ; flag := 0 ;
     var l2 : Sequence(int) ; l2 := Sequence{} ;
     for (j : l2) do ( (     if (j > k) then (     flag := 1 ; 
     break ) else     if (j < k) then (     answer := answer + 1 ) else skip ; )  ) ; 
     if (flag = 1) then (     break ) else skip )  ) ; 
    OclFile["System.out"].println(n - (answer / 2)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean allBitsSetInTheGivenRange(int n,int l,int r){
    int num=((1<<r)-1)^((1<<(l-1))-1);
    int new_num=n & num ;
    if(num==new_num)return true ;
    return false ;
  }
  static boolean bitsAreComplement(int a,int b,int l,int r){
    int xor_value=a ^ b ;
    return allBitsSetInTheGivenRange(xor_value,l,r);
  }
  public static void main(String[] args){
    int a=10,b=5 ;
    int l=1,r=3 ;
    if(bitsAreComplement(a,b,l,r))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation allBitsSetInTheGivenRange( n : int, l : int, r : int) : boolean
  pre: true
  post: true
  activity: (     var num : int ; num := MathLib.bitwiseXor((((1*(2->pow(r)))->oclAsType(long)) - 1),(((1*(2->pow((l - 1))))->oclAsType(long)) - 1)) ;
     var new_num : int ; new_num := MathLib.bitwiseAnd(n,num) ;
     if (num = new_num) then     return true else skip ; 
     return false );
  static   operation bitsAreComplement( a : int, b : int, l : int, r : int) : boolean
  pre: true
  post: true
  activity: (     var xor_value : int ; xor_value := MathLib.bitwiseXor(a,b) ;
     return allBitsSetInTheGivenRange(xor_value, l, r) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 10 ;
    var b : int ; b := 5 ;
     var l : int ; l := 1 ;
    var r : int ; r := 3 ;
     if (bitsAreComplement(a, b, l, r)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int a=stdIn.nextInt();
    if(a>=30){
      System.out.print("Yes");
    }
    else {
      System.out.print("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := stdIn.getCurrent()->toInteger() ;
     if (a >= 30) then (     OclFile["System.out"].print("Yes") ) else (     OclFile["System.out"].print("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String args[])throws IOException {
    FastScanner fs=new FastScanner();
    int N=fs.nextInt();
    System.out.println((N>=30)? "Yes" : "No");
  }
}
class FastScanner {
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer str=new StringTokenizer("");
  String next()throws IOException {
    while(! str.hasMoreTokens())str=new StringTokenizer(br.readLine());
    return str.nextToken();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  float nextfloat()throws IOException {
    return Float.parseFloat(next());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  int[] arrayIn(int n)throws IOException {
    int arr[]=new int[n];
    arr[0]=0 ;
    for(int i=1 ; i<n ; i++){
      arr[i]=nextInt();
    }
    return arr ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var N : int ; N := fs.nextInt() ;
     OclFile["System.out"].println(if (N >= 30) then "Yes" else "No" endif) );
}
class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute str : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(str.hasNext())) do     str := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return str.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextfloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation arrayIn( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
     arr[0+1] := 0 ; 
         var i : int ; i := 1 ; while i < n do ( (     arr[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return arr );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.Math ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int X=sc.nextInt();
    if(X<30){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : int ; X := sc.getCurrent()->toInteger() ;
     if (X < 30) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    Main mainObj=new Main();
    mainObj.solve();
  }
  public void solve()throws IOException {
    FastScanner fs=new FastScanner();
    int x=fs.nextInt();
    if(x>=30){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
  public class FastScanner {
    BufferedReader reader ;
    private StringTokenizer st ;
    public FastScanner(){
      st=null ;
      reader=new BufferedReader(new InputStreamReader(System.in));
    }
    public String next()throws IOException {
      if(st==null || ! st.hasMoreElements()){
        st=new StringTokenizer(reader.readLine());
      }
      return st.nextToken();
    }
    public String nextLine()throws IOException {
      st=null ;
      String readLine=null ;
      readLine=reader.readLine();
      return readLine ;
    }
    public int nextInt()throws NumberFormatException,IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws NumberFormatException,IOException {
      return Long.parseLong(next());
    }
    public int[] nextIntArr(int n)throws NumberFormatException,IOException {
      int[] retArr=new int[n];
      for(int i=0 ; i<n ; i++){
        retArr[i]=nextInt();
      }
      return retArr ;
    }
    public long[] nextLongArr(int n)throws NumberFormatException,IOException {
      long[] retArr=new long[n];
      for(int i=0 ; i<n ; i++){
        retArr[i]=nextLong();
      }
      return retArr ;
    }
    public void close()throws IOException {
      reader.close();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mainObj : Main ; mainObj := Main.newMain() ;
     mainObj.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var x : int ; x := fs.nextInt() ;
     if (x >= 30) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
 class FastScanner {
   attribute reader : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     st := null ; 
     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (st = null or not(st.hasNext())) then (     st := OclIterator.newOclIterator_String(reader.readLine()) ) else skip ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     st := null ; 
     var readLine : String ; readLine := null ;
     readLine := reader.readLine() ; 
     return readLine );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextIntArr( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var retArr : Sequence(int) ; retArr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     retArr[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return retArr );
   operation nextLongArr( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var retArr : Sequence(long) ; retArr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     retArr[i+1] := nextLong() )  ;     i := i + 1 ) ; 
     return retArr );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    System.out.println((x-a)% b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println((x - a) mod b) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int gcd(int a,int b){
    return b>0 ? gcd(b,a % b): a ;
  }
  static long mod=1000000007 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    if(N>=30){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b > 0 then gcd(b, a mod b) else a endif );
  static   attribute mod : long := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N >= 30) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void makePermutation(int[] a,int n){
    HashMap<Integer,Integer>count=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      if(count.containsKey(a[i])){
        count.put(a[i],count.get(a[i])+1);
      }
      else {
        count.put(a[i],1);
      }
    }
    int next_missing=1 ;
    for(int i=0 ; i<n ; i++){
      if(count.containsKey(a[i])&& count.get(a[i])!=1 || a[i]>n || a[i]<1){
        count.put(a[i],count.get(a[i])-1);
        while(count.containsKey(next_missing))next_missing++;
        a[i]=next_missing ;
        count.put(next_missing,1);
      }
    }
  }
  public static void main(String[] args){
    int A[]={
      2,2,3,3 };
      int n=A.length ;
      makePermutation(A,n);
      for(int i=0 ; i<n ; i++)System.out.print(A[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation makePermutation( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var count : Map(int,int) ; count := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (count->keys()->includes(a[i+1])) then (     count := count->union(Map{a[i+1] |-> count->at(a[i+1]) + 1}) ) else (     count := count->union(Map{a[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
     var next_missing : int ; next_missing := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (count->keys()->includes(a[i+1]) & count->at(a[i+1]) /= 1 or a[i+1] > n or a[i+1] < 1) then (     count := count->union(Map{a[i+1] |-> count->at(a[i+1]) - 1}) ; 
     while (count->keys()->includes(next_missing)) do     next_missing := next_missing + 1 ; ; 
     a[i+1] := next_missing ; 
     count := count->union(Map{next_missing |-> 1}) ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{2,2,3,3} ;
     var n : int ; n := A->size() ;
     execute makePermutation(A, n) ; 
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(A[i+1] + " ") ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void kFactors(int n,int k){
    ArrayList<Integer>P=new ArrayList<Integer>();
    while(n % 2==0){
      P.add(2);
      n/=2 ;
    }
    for(int i=3 ; i*i<=n ; i=i+2){
      while(n % i==0){
        n=n/i ;
        P.add(i);
      }
    }
    if(n>2)P.add(n);
    if(P.size()<k){
      System.out.println("-1");
      return ;
    }
    for(int i=0 ; i<k-1 ; i++)System.out.print(P.get(i)+",");
    int product=1 ;
    for(int i=k-1 ; i<P.size(); i++)product=product*P.get(i);
    System.out.println(product);
  }
  public static void main(String[] args){
    int n=54,k=3 ;
    kFactors(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation kFactors( n : int, k : int) : void
  pre: true
  post: true
  activity: (     var P : Sequence(int) ; P := Sequence{} ;
     while (n mod 2 = 0) do (     P := P->including(2) ; 
     n := n/(2) ) ; 
        var i : int ; i := 3 ; while i * i <= n do ( (     while (n mod i = 0) do (     n := n / i ; 
     P := P->including(i) ) )  ;     i := i + 2 ) ; 
    if (n > 2) then     P := P->including(n) ; else skip ; 
    if (P->size() < k) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < k - 1 do (     OclFile["System.out"].print(P->at(i+1) + ",") ;  ;     i := i + 1 ) ; 
    var product : int ; product := 1 ;
        var i : int ; i := k - 1 ; while i < P->size() do (     product := product * P->at(i+1) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(product) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 54 ;
    var k : int ; k := 3 ;
     execute kFactors(n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float squarearea(float a,float b){
    if(a<0 || b<0)return-1 ;
    float area=4*(float)((Math.pow(a,2)+Math.pow(b,2))/(Math.pow(a,2)*Math.pow(b,2)));
    return area ;
  }
  public static void main(String[] args){
    float a=4,b=2 ;
    System.out.println(squarearea(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation squarearea( a : double, b : double) : double
  pre: true
  post: true
  activity: (     if (a < 0 or b < 0) then     return -1 else skip ; 
     var area : double ; area := 4 * ((a->pow(2) + b->pow(2)) / (a->pow(2) * b->pow(2)))->oclAsType(double) ;
     return area );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 4 ;
    var b : double ; b := 2 ;
     OclFile["System.out"].println(squarearea(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  Scanner sc ;
  int N ;
  long K ;
  long[] A,F ;
  Main(){
    sc=new Scanner(System.in);
  }
  private void calc(){
    N=sc.nextInt();
    A=new long[N];
    F=new long[N];
    K=sc.nextLong();
    for(int i=0 ; i<N ; i++)A[i]=sc.nextLong();
    for(int i=0 ; i<N ; i++)F[i]=sc.nextLong();
    Arrays.sort(A);
    Arrays.sort(F);
    for(int i=0 ; i<N/2 ; i++){
      F[i] ^=F[N-1-i];
      F[N-1-i] ^=F[i];
      F[i] ^=F[N-1-i];
    }
    long ans=0x7fffffffffffffffL ;
    for(long bit=1L<<62 ; bit>0L ; bit>>>=1){
      if(requiredK(ans & ~ bit)>K)continue ;
      ans &=~ bit ;
    }
    System.out.println(ans);
  }
  private long requiredK(long minVal){
    long s=0L ;
    for(int i=0 ; i<N ; i++){
      long x=minVal/F[i];
      if(A[i]>x)s+=(A[i]-x);
    }
    return s ;
  }
  public static void main(String[] args)throws Exception {
    new Main().calc();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute N : int;
   attribute K : long;
   attribute A : Sequence(long);
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation calc() : void
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     A := Integer.subrange(1,N)->collect(0) ; 
    F := Integer.subrange(1,N)->collect(0) ; 
    K := sc.getCurrent()->toLong() ; 
        var i : int ; i := 0 ; while i < N do (     A[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do (     F[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    F := F->sort() ; 
        var i : int ; i := 0 ; while i < N / 2 do ( (     F[i+1] := MathLib.bitwiseXor(F[i+1],F[N - 1 - i+1]) ; 
     F[N - 1 - i+1] := MathLib.bitwiseXor(F[N - 1 - i+1],F[i+1]) ; 
     F[i+1] := MathLib.bitwiseXor(F[i+1],F[N - 1 - i+1]) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0x7fffffffffffffffL ;
        var bit : long ; bit := (1L*(2->pow(62)))->oclAsType(long) ; while bit > 0L do ( (     if (requiredK(MathLib.bitwiseAnd(ans,-(bit + 1))) > K) then     continue else skip ; 
     ans := MathLib.bitwiseAnd(ans, -(bit + 1)) )  ;     bit := bit/(2->pow(1)) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation requiredK( minVal : long) : long
  pre: true
  post: true
  activity: (     var s : long ; s := 0L ;
         var i : int ; i := 0 ; while i < N do ( (     var x : long ; x := minVal / F[i+1] ;
     if (A[i+1] > x) then     s := s+((A[i+1] - x)) ; else skip )  ;     i := i + 1 ) ; 
     return s );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().calc() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long K=sc.nextLong();
    long[] A=new long[N];
    long[] F=new long[N];
    long allcost=0 ;
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextLong();
      allcost=allcost+A[i];
    }
    for(int i=0 ; i<N ; i++){
      F[i]=sc.nextLong();
    }
    if(allcost<=K){
      System.out.println(0);
      return ;
    }
    Arrays.sort(A);
    Arrays.sort(F);
    long ok=A[N-1]*F[N-1];
    long ng=0 ;
    while(ok-ng>1){
      long h=(ok+ng)/2 ;
      long tot=0 ;
      for(int i=0 ; i<N ; i++){
        tot=tot+Math.max(A[N-i-1]-h/F[i],0);
      }
      if(tot>K){
        ng=h ;
      }
      else {
        ok=h ;
      }
    }
    System.out.println(ok);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : long ; K := sc.getCurrent()->toLong() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
    var F : Sequence(long) ; F := Integer.subrange(1,N)->collect(0) ;
    var allcost : long ; allcost := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toLong() ; 
     allcost := allcost + A[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     F[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    if (allcost <= K) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    A := A->sort() ; 
    F := F->sort() ; 
    var ok : long ; ok := A[N - 1+1] * F[N - 1+1] ;
    var ng : long ; ng := 0 ;
    while (ok - ng > 1) do (     var h : long ; h := (ok + ng) / 2 ;
     var tot : long ; tot := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     tot := tot + Set{A[N - i - 1+1] - h / F[i+1], 0}->max() )  ;     i := i + 1 ) ; 
     if (tot > K) then (     ng := h ) else (     ok := h ) ) ; 
    OclFile["System.out"].println(ok) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Map.Entry ;
class Main {
  static int mod=(int)(Math.pow(10,9)+7);
  static long N ;
  static long K ;
  static Integer[] a ;
  static Integer[] f ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    K=sc.nextLong();
    a=new Integer[(int)N];
    long max=0 ;
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextInt();
    }
    f=new Integer[(int)N];
    for(int i=0 ; i<N ; i++){
      f[i]=sc.nextInt();
    }
    Arrays.sort(a);
    Arrays.sort(f,Collections.reverseOrder());
    long left=0 ;
    long right=2200200200200200200l ;
    left=-1 ;
    while(right-left>1){
      long mid=left+(right-left)/2 ;
      if(IsOK(mid))right=mid ;
      else left=mid ;
    }
    System.out.println(right);
  }
  public static boolean IsOK(long p){
    long cnt=0 ;
    long tmp=0 ;
    for(int i=0 ; i<N ; i++){
      tmp=a[i]-p/f[i];
      if(tmp<0){
        tmp=0 ;
      }
      cnt=cnt+tmp ;
    }
    return cnt<=K ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mod : int := (10->pow(9) + 7)->oclAsType(int);
  static   attribute N : long;
  static   attribute K : long;
  static   attribute a : Sequence(int);
  static   attribute f : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
    K := sc.getCurrent()->toLong() ; 
    a := Integer.subrange(1,N->oclAsType(int))->collect(null) ; 
    var max : long ; max := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    f := Integer.subrange(1,N->oclAsType(int))->collect(null) ; 
        var i : int ; i := 0 ; while i < N do ( (     f[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    f := OclComparator.sortWith(f, reverseOrder()) ; 
    var left : long ; left := 0 ;
    var right : long ; right := 2200200200200200200l ;
    left := -1 ; 
    while (right - left > 1) do (     var mid : long ; mid := left + (right - left) / 2 ;
     if (IsOK(mid)) then     right := mid ; else     left := mid ; ) ; 
    OclFile["System.out"].println(right) ; 
 );
  static   operation IsOK( p : long) : boolean
  pre: true
  post: true
  activity: (     var cnt : long ; cnt := 0 ;
     var tmp : long ; tmp := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     tmp := a[i+1] - p / f[i+1] ; 
     if (tmp < 0) then (     tmp := 0 ) else skip ; 
     cnt := cnt + tmp )  ;     i := i + 1 ) ; 
     return cnt <= K );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long K=sc.nextLong();
    int[] A=new int[N];
    int[] F=new int[N];
    long sumA=0 ;
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
      sumA+=A[i];
    }
    if(sumA<=K){
      System.out.println(0);
      return ;
    }
    for(int i=0 ; i<N ; i++){
      F[i]=sc.nextInt();
    }
    A=Arrays.stream(A).boxed().sorted(Comparator.reverseOrder()).mapToInt(Integer :: intValue).toArray();
    Arrays.sort(F);
    long l=0,r=Long.MAX_VALUE ;
    while(l<r){
      long m=(l+r)/2 ;
      if(isPossible(m,A,F,K)){
        r=m ;
      }
      else {
        l=m+1 ;
      }
    }
    System.out.println(l);
  }
  static boolean isPossible(long af,int[] A,int[] F,long K){
    long prep=0 ;
    for(int i=0 ; i<A.length ; i++){
      long need=af/F[i];
      prep+=Math.max(0,A[i]-need);
    }
    return prep<=K ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : long ; K := sc.getCurrent()->toLong() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var F : Sequence(int) ; F := Integer.subrange(1,N)->collect(0) ;
    var sumA : long ; sumA := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() ; 
     sumA := sumA+(A[i+1]) )  ;     i := i + 1 ) ; 
    if (sumA <= K) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < N do ( (     F[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    A := stream(A)->sort()->collect( _x1 | (lambda _pars : OclAny in Integer.newInteger().intValue(_pars))->apply(_x1) )->asSequence() ; 
    F := F->sort() ; 
    var l : long ; l := 0 ;
    var r : long ; r := "9223372036854775807"->toLong() ;
    while (l < r) do (     var m : long ; m := (l + r) / 2 ;
     if (isPossible(m, A, F, K)) then (     r := m ) else (     l := m + 1 ) ) ; 
    OclFile["System.out"].println(l) ; 
 );
  static   operation isPossible( af : long, A : Sequence(int), F : Sequence(int), K : long) : boolean
  pre: true
  post: true
  activity: (     var prep : long ; prep := 0 ;
         var i : int ; i := 0 ; while i < A->size() do ( (     var need : long ; need := af / F[i+1] ;
     prep := prep+(Set{0, A[i+1] - need}->max()) )  ;     i := i + 1 ) ; 
     return prep <= K );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long K=sc.nextLong();
    long[] A=new long[N];
    long[] F=new long[N];
    Arrays.setAll(A,i->sc.nextInt());
    Arrays.setAll(F,i->sc.nextInt());
    Arrays.sort(A);
    Arrays.sort(F);
    long lb=0,ub=1000000000000L ;
    do {
      long mid=(ub+lb)/2 ;
      long c=0 ;
      for(int i=0 ; i<N ; i++)if(mid<A[i]*F[N-1-i])c+=A[i]-mid/F[N-1-i];
      if(c>K)lb=mid+1 ;
      else ub=mid ;
    }
    while(lb<ub);
    System.out.println(ub);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : long ; K := sc.getCurrent()->toLong() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
    var F : Sequence(long) ; F := Integer.subrange(1,N)->collect(0) ;
setAll(A, lambda i : OclAny in sc.getCurrent()->toInteger()) ; 
setAll(F, lambda i : OclAny in sc.getCurrent()->toInteger()) ; 
    A := A->sort() ; 
    F := F->sort() ; 
    var lb : long ; lb := 0 ;
    var ub : long ; ub := 1000000000000L ;
  while true do ((     var mid : long ; mid := (ub + lb) / 2 ;
     var c : long ; c := 0 ;
         var i : int ; i := 0 ; while i < N do (     if (mid < A[i+1] * F[N - 1 - i+1]) then     c := c+(A[i+1] - mid / F[N - 1 - i+1]) ; else skip ;  ;     i := i + 1 ) ; 
     if (c > K) then     lb := mid + 1 ; else     ub := mid ; ) ;
    if (lb < ub) then skip else break) ; 
    OclFile["System.out"].println(ub) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
  Scanner sc=new Scanner(System.in);
  void run(){
    int x=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    System.out.println(solve(x,a,b));
  }
  int solve(int x,int a,int b){
    return(x-a)% b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(solve(x, a, b)) );
   operation solve( x : int, a : int, b : int) : int
  pre: true
  post: true
  activity: (     return (x - a) mod b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int N=100000 ;
  static void createHash(HashSet<Integer>hash,int maxElement){
    int prev=0,curr=1 ;
    hash.add(prev);
    hash.add(curr);
    while(curr<=maxElement){
      int temp=curr+prev ;
      hash.add(temp);
      prev=curr ;
      curr=temp ;
    }
  }
  static int longestFibSubarray(int arr[],int n){
    int max_val=Arrays.stream(arr).max().getAsInt();
    HashSet<Integer>hash=new HashSet<Integer>();
    createHash(hash,max_val);
    int[] left=new int[n];
    int[] right=new int[n];
    int fibcount=0,res=-1 ;
    for(int i=0 ; i<n ; i++){
      left[i]=fibcount ;
      if(hash.contains(arr[i])){
        fibcount++;
      }
      else fibcount=0 ;
    }
    fibcount=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      right[i]=fibcount ;
      if(hash.contains(arr[i])){
        fibcount++;
      }
      else fibcount=0 ;
    }
    for(int i=0 ; i<n ; i++)res=Math.max(res,left[i]+right[i]);
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      2,8,5,7,3,5,7 };
      int n=arr.length ;
      System.out.print(longestFibSubarray(arr,n)+"\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute N : int := 100000;
  static   operation createHash( hash : Set(int), maxElement : int) : void
  pre: true
  post: true
  activity: (     var prev : int ; prev := 0 ;
    var curr : int ; curr := 1 ;
     hash->excludes(prev) ; 
     hash->excludes(curr) ; 
     while (curr <= maxElement) do (     var temp : int ; temp := curr + prev ;
     hash->excludes(temp) ; 
     prev := curr ; 
     curr := temp ) );
  static   operation longestFibSubarray( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max_val : int ; max_val := stream(arr).max().getAsInt() ;
     var hash : Set(int) ; hash := Set{} ;
    execute createHash(hash, max_val) ; 
    var left : Sequence(int) ; left := Integer.subrange(1,n)->collect(0) ;
    var right : Sequence(int) ; right := Integer.subrange(1,n)->collect(0) ;
    var fibcount : int ; fibcount := 0 ;
    var res : int ; res := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     left[i+1] := fibcount ; 
     if (hash->includes(arr[i+1])) then (     fibcount := fibcount + 1 ) else     fibcount := 0 ; )  ;     i := i + 1 ) ; 
    fibcount := 0 ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     right[i+1] := fibcount ; 
     if (hash->includes(arr[i+1])) then (     fibcount := fibcount + 1 ) else     fibcount := 0 ; )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     res := Set{res, left[i+1] + right[i+1]}->max() ;  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,8,5,7,3,5,7} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(longestFibSubarray(arr, n) + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findNumberOfTimes(String str1,String str2){
    int freq[]=new int[26];
    int l1=str1.length();
    for(int i=0 ; i<l1 ; i++){
      freq[str1.charAt(i)-'a']+=1 ;
    }
    int l2=str2.length();
    int count=Integer.MAX_VALUE ;
    for(int i=0 ; i<l2 ; i++){
      count=Math.min(count,freq[str2.charAt(i)-'a']);
    }
    return count ;
  }
  public static void main(String[] args){
    String str1="foreeksgekseg" ;
    String str2="geeks" ;
    System.out.println(findNumberOfTimes(str1,str2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNumberOfTimes( str1 : String, str2 : String) : int
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,26)->collect(0) ;
     var l1 : int ; l1 := str1->size() ;
        var i : int ; i := 0 ; while i < l1 do ( (     freq[str1->at(i+1) - ('a')->char2byte()+1] := freq[str1->at(i+1) - ('a')->char2byte()+1]+(1) )  ;     i := i + 1 ) ; 
    var l2 : int ; l2 := str2->size() ;
    var count : int ; count := 2147483647 ;
        var i : int ; i := 0 ; while i < l2 do ( (     count := Set{count, freq[str2->at(i+1) - ('a')->char2byte()+1]}->min() )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "foreeksgekseg" ;
     var str2 : String ; str2 := "geeks" ;
     OclFile["System.out"].println(findNumberOfTimes(str1, str2)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.util.*;
class GFG {
  static int countUnique(int arr[],int n){
    Set<Point>s=new HashSet<>();
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<n ; j++)s.add(new Point(arr[i],arr[j]));
    return s.size();
  }
  public static void main(String[] args){
    int arr[]={
      1,2,2,4,2,5,3,5 };
      int n=arr.length ;
      System.out.print(countUnique(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countUnique( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var s : Set(Point) ; s := Set{} ;
         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < n do (     s := s->including(Point.newPoint(arr[i+1], arr[j+1])) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return s->size() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,2,4,2,5,3,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(countUnique(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int GCD(int a,int b){
    return(b!=0 ? GCD(b,a % b): a);
  }
  static void ratiotang(int r1,int r2){
    System.out.println("The ratio is "+r1/GCD(r1,r2)+" : "+r2/GCD(r1,r2));
  }
  public static void main(String args[]){
    int r1=4,r2=6 ;
    ratiotang(r1,r2);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation GCD( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return (if b /= 0 then GCD(b, a mod b) else a endif) );
  static   operation ratiotang( r1 : int, r2 : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("The ratio is " + r1 / GCD(r1, r2) + " : " + r2 / GCD(r1, r2)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r1 : int ; r1 := 4 ;
    var r2 : int ; r2 := 6 ;
     execute ratiotang(r1, r2) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class a {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new FileReader(args[0]));
    String str ;
    int numCases=Integer.parseInt(br.readLine());
    for(int nCase=1 ; nCase<=numCases ; nCase++){
      int N=Integer.parseInt(br.readLine());
      int[][] lines=new int[N][2];
      for(int i=0 ; i<N ; i++){
        String[] sa=br.readLine().split(" ");
        lines[i][0]=Integer.parseInt(sa[0]);
        lines[i][1]=Integer.parseInt(sa[1]);
      }
      int answer=0 ;
      if(N==1)answer=0 ;
      else if(N==2){
        if((lines[0][0]<lines[1][0] && lines[0][1]>lines[1][1])||(lines[0][0]>lines[1][0] && lines[0][1]<lines[1][1]))answer=1 ;
      }
      else answer=666 ;
      System.out.println("Case #"+nCase+": "+answer);
    }
    br.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class a {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(args[0+1])) ;
     var str : String ;
    var numCases : int ; numCases := (br.readLine())->toInteger() ;
        var nCase : int ; nCase := 1 ; while nCase <= numCases do ( (     var N : int ; N := (br.readLine())->toInteger() ;
     var lines : Sequence(Sequence(int)) ; lines := Integer.subrange(1,N)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
     lines[i+1][0+1] := (sa[0+1])->toInteger() ; 
     lines[i+1][1+1] := (sa[1+1])->toInteger() )  ;     i := i + 1 ) ; 
    var answer : int ; answer := 0 ;
    if (N = 1) then     answer := 0 else     if (N = 2) then (     if ((lines[0+1][0+1] < lines[1+1][0+1] & lines[0+1][1+1] > lines[1+1][1+1]) or (lines[0+1][0+1] > lines[1+1][0+1] & lines[0+1][1+1] < lines[1+1][1+1])) then     answer := 1 ; else skip ) else     answer := 666 ; ;  ;  
    OclFile["System.out"].println("Case #" + nCase + ": " + answer) ; 
 )  ;     nCase := nCase + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B1373 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    sc.nextLine();
    while(t-->0){
      String s=sc.nextLine();
      StringBuilder sb=new StringBuilder(s);
      int count=0 ;
      for(int i=1 ; i<sb.length(); i++){
        for(int j=0 ; j<sb.length(); j++){
          if(sb.charAt(i-1)!=sb.charAt(i)){
            sb.deleteCharAt(i);
            sb.deleteCharAt(i-1);
            i=0 ;
            j=0 ;
            count++;
            break ;
          }
          else {
            break ;
          }
        }
      }
      if(count % 2==0)System.out.println("NET");
      else System.out.println("DA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1373 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     skip ; 
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : String ; s := sc.nextLine() ;
     var sb : String ; sb := StringLib.newString(s) ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < sb->size() do ( (         var j : int ; j := 0 ; while j < sb->size() do ( (     if (sb->at(i - 1+1) /= sb->at(i+1)) then (     sb := sb->excludingAt(i+1) ; 
     sb := sb->excludingAt(i - 1+1) ; 
    i := 0 ; 
    j := 0 ; 
    count := count + 1 ; 
    break 
 ) else (     break ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (count mod 2 = 0) then     OclFile["System.out"].println("NET") else     OclFile["System.out"].println("DA") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileNotFoundException ;
import java.io.IOException ;
import java.io.RandomAccessFile ;
import java.util.LinkedList ;
import java.util.List ;
public class RopeIntranet {
  public static void main(String[] args)throws IOException {
    RandomAccessFile in=new RandomAccessFile(args[0],"r");
    RandomAccessFile out=new RandomAccessFile(args[1],"rw");
    int caseCount=Integer.parseInt(in.readLine());
    for(int i=1 ; i<=caseCount ; i++){
      List<Integer>A=new LinkedList<Integer>();
      List<Integer>B=new LinkedList<Integer>();
      int N=Integer.parseInt(in.readLine().trim());
      for(int j=0 ; j<N ; j++){
        String[] temp=in.readLine().trim().split(" ");
        A.add(Integer.parseInt(temp[0]));
        B.add(Integer.parseInt(temp[1]));
      }
      String result="Case #" ;
      int retCode=calculate(A,B);
      result=result+i+": "+retCode+"\n" ;
      out.writeBytes(result);
    }
  }
  public static int calculate(List<Integer>A,List<Integer>B){
    int ret=0 ;
    int length=A.size();
    for(int i=1 ; i<length ; i++)for(int j=0 ; j<i ; j++){
      if((A.get(i)-A.get(j))*(B.get(i)-B.get(j))<0){
        ret++;
      }
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class RopeIntranet {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile(args[0+1], "r") ;
     var out : OclFile ; out := OclFile.newOclFile(args[1+1], "rw") ;
     var caseCount : int ; caseCount := (in.readLine())->toInteger() ;
         var i : int ; i := 1 ; while i <= caseCount do ( (     var A : Sequence(int) ; A := Sequence{} ;
     var B : Sequence(int) ; B := Sequence{} ;
    var N : int ; N := (in.readLine()->trim())->toInteger() ;
        var j : int ; j := 0 ; while j < N do ( (     var temp : Sequence(String) ; temp := in.readLine()->trim()->split(" ") ;
     A := A->including((temp[0+1])->toInteger()) ; 
     B := B->including((temp[1+1])->toInteger()) )  ;     j := j + 1 ) ; 
    var result : String ; result := "Case #" ;
    var retCode : int ; retCode := calculate(A, B) ;
    result := result + i + ": " + retCode + "\n" ; 
    skip ; 
 )  ;     i := i + 1 ) );
  static   operation calculate( A : Sequence(int), B : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
     var length : int ; length := A->size() ;
         var i : int ; i := 1 ; while i < length do (         var j : int ; j := 0 ; while j < i do ( (     if ((A->at(i+1) - A->at(j+1)) * (B->at(i+1) - B->at(j+1)) < 0) then (     ret := ret + 1 ) else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package QualC2010 ;
import java.io.BufferedReader ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Rope {
  public static void main(String[] args)throws Exception {
    BufferedReader B=new BufferedReader(new FileReader("A-large.in"));
    PrintWriter A=new PrintWriter(new FileWriter("A-large.out"));
    int N,n,x,y,i,j,k ;
    StringTokenizer st ;
    int[][] wire ;
    int t=Integer.parseInt(B.readLine());
    for(int T=0 ; T<t ; T++){
      n=0 ;
      N=Integer.parseInt(B.readLine());
      wire=new int[N][2];
      for(i=0 ; i<N ; i++){
        st=new StringTokenizer(B.readLine());
        wire[i][0]=Integer.parseInt(st.nextToken());
        wire[i][1]=Integer.parseInt(st.nextToken());
      }
      for(i=0 ; i<N ; i++){
        for(j=0 ; j<i ; j++){
          if((wire[i][0]-wire[j][0])*(wire[i][1]-wire[j][1])<0){
            n++;
          }
        }
      }
      A.println("Case #"+(T+1)+": "+n);
    }
    A.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Rope {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var B : OclFile ; B := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("A-large.in"))) ;
     var A : OclFile ; A := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("A-large.out"))) ;
    var N : int ;
    var n : int ;
    var x : int ;
    var y : int ;
    var i : int ;
    var j : int ;
    var k : int ;
    var st : OclIterator ;
    var wire : Sequence(Sequence(int)) ;
    var t : int ; t := (B.readLine())->toInteger() ;
        var T : int ; T := 0 ; while T < t do ( (     n := 0 ; 
     N := (B.readLine())->toInteger() ; 
    wire := Integer.subrange(1,N)->collect(Integer.subrange(1,2)->collect(0)) ; 
        i := 0 ; while i < N do ( (     st := OclIterator.newOclIterator_String(B.readLine()) ; 
     wire[i+1][0+1] := (st.next())->toInteger() ; 
     wire[i+1][1+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
        i := 0 ; while i < N do ( (         j := 0 ; while j < i do ( (     if ((wire[i+1][0+1] - wire[j+1][0+1]) * (wire[i+1][1+1] - wire[j+1][1+1]) < 0) then (     n := n + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     T := T + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Locale ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
public class Problem implements Runnable {
  private final Scanner scanner ;
  private final PrintWriter printer ;
  private String solveSingle(){
    int n=scanner.nextInt();
    int[] a=new int[n];
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scanner.nextInt();
      b[i]=scanner.nextInt();
    }
    int isect=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(a[i]>a[j] && b[i]<b[j]){
          isect++;
        }
      }
    }
    return String.valueOf(isect);
  }
  private void solve()throws Exception {
    int cases=scanner.nextInt();
    for(int test=1 ; test<=cases ; test++){
      printer.println("Case #"+test+": "+solveSingle());
    }
  }
  private Problem()throws FileNotFoundException {
    scanner=new Scanner(new File("a-large.in"));
    printer=new PrintWriter(new File("a-large.out"));
  }
  public void run(){
    try {
      solve();
    }
    catch(Exception e){
      e.printStackTrace();
      throw new RuntimeException(e);
    }
    finally {
      printer.close();
    }
  }
  public static void main(String[] args)throws FileNotFoundException {
    Locale.setDefault(Locale.US);
    new Thread(new Problem()).start();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem implements Runnable {
   attribute scanner : OclFile;
   attribute printer : OclFile;
   operation solveSingle() : String
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() ; 
     b[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var isect : int ; isect := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (a[i+1] > a[j+1] & b[i+1] < b[j+1]) then (     isect := isect + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return ((isect) + "") 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var cases : int ; cases := scanner.getCurrent()->toInteger() ;
         var test : int ; test := 1 ; while test <= cases do ( (     skip )  ;     test := test + 1 ) );
   static operation newProblem() : Problem
  pre: true
  post: true
  activity:
  ( var self : Problem ;
    self := createProblem();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile("a-large.in")) ; 
     printer := OclFile.newOclFile_Write(OclFile("a-large.out")) );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     execute solve() )   catch (e : ProgramException) do (     e.printStackTrace() ; 
     error ProgramException(e) )
   finally (     skip )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.US) ; 
     OclProcess.newOclProcess(Problem.newProblem()).start() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedWriter ;
import java.io.File ;
import java.io.FileWriter ;
import java.util.Scanner ;
public class A {
  A()throws Exception {
    File input=new File("input.txt"),output=new File("output.txt");
    Scanner scanner=new Scanner(input);
    BufferedWriter writer=new BufferedWriter(new FileWriter(output));
    int TestCases=scanner.nextInt();
    for(int Case=1 ; Case<=TestCases ; Case++){
      writer.write("Case #"+Case+": ");
      int Wires=scanner.nextInt();
      int[] A=new int[Wires],B=new int[Wires];
      int count=0 ;
      for(int i=0 ; i<Wires ; i++){
        A[i]=scanner.nextInt();
        B[i]=scanner.nextInt();
        for(int j=0 ; j<i ; j++){
          if(A[i]>A[j] && B[i]<B[j] || A[i]<A[j] && B[i]>B[j])count++;
        }
      }
      writer.write(count+"");
      writer.newLine();
    }
    scanner.close();
    writer.close();
  }
  public static void main(String[] args)throws Exception {
    new A();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   static operation newA() : A
  pre: true
  post: true
  activity:
  ( var self : A ;
    self := createA();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var input : OclFile ; input := OclFile("input.txt") ;
    var output : OclFile ; output := OclFile("output.txt") ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(input) ;
    var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(output)) ;
    var TestCases : int ; TestCases := scanner.getCurrent()->toInteger() ;
        var Case : int ; Case := 1 ; while Case <= TestCases do ( (     skip ; 
     var Wires : int ; Wires := scanner.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,Wires)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,Wires)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < Wires do ( (     A[i+1] := scanner.getCurrent()->toInteger() ; 
     B[i+1] := scanner.getCurrent()->toInteger() ; 
         var j : int ; j := 0 ; while j < i do ( (     if (A[i+1] > A[j+1] & B[i+1] < B[j+1] or A[i+1] < A[j+1] & B[i+1] > B[j+1]) then     count := count + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 )  ;     Case := Case + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( A.newA() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    int c=Integer.parseInt(sc.next());
    a=a-b ;
    for(; ; ){
      a-=c ;
      if(a<c){
        break ;
      }
    }
    System.out.println(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := (sc.getCurrent())->toInteger() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    var c : int ; c := (sc.getCurrent())->toInteger() ;
    a := a - b ; 
      while true do ( (     a := a-(c) ; 
     if (a < c) then (     break ) else skip )  ) ; 
    OclFile["System.out"].println(a) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  int[] res,t ;
  void add(int D){
    t[0]=1/D ;
    int R=1 % D,id=1 ;
    while(id<t.length){
      R*=10 ;
      t[id++]=R/D ;
      R %=D ;
    }
    for(int i=t.length-1 ; i>0 ; i--){
      res[i]+=t[i];
      res[i-1]+=res[i]/10 ;
      res[i] %=10 ;
    }
    res[0]+=t[0];
  }
  void div(int n){
    t[0]=res[0]/n ;
    int R=res[0] % n,id=1 ;
    while(id<t.length){
      R=R*10+res[id];
      t[id++]=R/n ;
      R %=n ;
    }
    for(int i=0 ; i<t.length ; i++)res[i]=t[i];
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt(),k=sc.nextInt(),m=sc.nextInt(),r=sc.nextInt();
      if((n | k | m | r)==0)break ;
      res=new int[r+10];
      t=new int[r+10];
      if(m==0){
        add(n);
      }
      else {
        for(int i=1 ; i<n ; i++)add(i);
        div(n);
        add(n);
      }
      System.out.print(res[0]+".");
      for(int i=1 ; i<=r ; i++)System.out.print(res[i]+(i==r ? "\n" : ""));
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute res : Sequence(int);
   operation add( D : int) : void
  pre: true
  post: true
  activity: (     t[0+1] := 1 / D ; 
     var R : int ; R := 1 mod D ;
    var id : int ; id := 1 ;
    while (id < t->size()) do (     R := R*(10) ; 
      t[id+1] := R / D  ; id := id + 1 ; 
     R := R mod D ) ; 
        var i : int ; i := t->size() - 1 ; while i > 0 do ( (     res[i+1] := res[i+1]+(t[i+1]) ; 
     res[i - 1+1] := res[i - 1+1]+(res[i+1] / 10) ; 
     res[i+1] := res[i+1] mod 10 )  ;     i := i - 1 ) ; 
    res[0+1] := res[0+1]+(t[0+1]) ; 
 );
   operation div( n : int) : void
  pre: true
  post: true
  activity: (     t[0+1] := res[0+1] / n ; 
     var R : int ; R := res[0+1] mod n ;
    var id : int ; id := 1 ;
     while (id < t->size()) do (     R := R * 10 + res[id+1] ; 
      t[id+1] := R / n  ; id := id + 1 ; 
     R := R mod n ) ; 
         var i : int ; i := 0 ; while i < t->size() do (     res[i+1] := t[i+1] ;  ;     i := i + 1 ) );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseOr(MathLib.bitwiseOr(MathLib.bitwiseOr(n,k),m),r)) = 0) then     break else skip ; 
    res := Integer.subrange(1,r + 10)->collect(0) ; 
    t := Integer.subrange(1,r + 10)->collect(0) ; 
    if (m = 0) then (     execute add(n) ) else (         var i : int ; i := 1 ; while i < n do (     execute add(i) ;  ;     i := i + 1 ) ; 
     execute div(n) ; 
     execute add(n) ) ;  
    OclFile["System.out"].print(res[0+1] + ".") ; 
        var i : int ; i := 1 ; while i <= r do (     OclFile["System.out"].print(res[i+1] + (if i = r then "\n" else "" endif)) ;  ;     i := i + 1 ) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    while(s.hasNext()){
      int a=s.nextInt();
      int b=s.nextInt();
      int c=s.nextInt();
      int d=s.nextInt();
      if(a+b+c+d==0)System.exit(0);
      if(c==0){
        if(a==1)System.out.print("1.");
        else System.out.print("0.");
        int now=1 ;
        if(a==1)now=0 ;
        for(int i=0 ; i<d ; i++){
          now*=10 ;
          System.out.print(now/a);
          now %=a ;
        }
        System.out.println();
      }
      else {
        BigInteger kaijo=new BigInteger("1");
        for(int i=1 ; i<a ; i++)kaijo=kaijo.multiply(new BigInteger(""+i));
        BigInteger bunbo=kaijo.multiply(new BigInteger(""+a));
        BigInteger bunshi=BigInteger.ZERO ;
        for(int i=1 ; i<=a ; i++){
          bunshi=bunshi.add(kaijo.divide(new BigInteger(""+Math.max(1,i-1))));
        }
        if(a<3)System.out.print("1.");
        else System.out.print("0.");
        if(a<3)bunshi=BigInteger.ZERO ;
        for(int i=0 ; i<d ; i++){
          bunshi=bunshi.multiply(new BigInteger(""+10));
          System.out.print(bunshi.divide(bunbo).toString());
          bunshi=bunshi.mod(bunbo);
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (s.hasNext()) do (     var a : int ; a := s.getCurrent()->toInteger() ;
     var b : int ; b := s.getCurrent()->toInteger() ;
    var c : int ; c := s.getCurrent()->toInteger() ;
    var d : int ; d := s.getCurrent()->toInteger() ;
    if (a + b + c + d = 0) then OclProcess.exit(0) ; else skip ; 
    if (c = 0) then (     if (a = 1) then     OclFile["System.out"].print("1.") else     OclFile["System.out"].print("0.") ; ;  
     var now : int ; now := 1 ;
    if (a = 1) then     now := 0 ; else skip ; 
        var i : int ; i := 0 ; while i < d do ( (     now := now*(10) ; 
     OclFile["System.out"].print(now / a) ; 
     now := now mod a )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) else (     var kaijo : long ; kaijo := long("1") ;
         var i : int ; i := 1 ; while i < a do (     kaijo := kaijo.multiply(long("" + i)) ;  ;     i := i + 1 ) ; 
    var bunbo : long ; bunbo := kaijo.multiply(long("" + a)) ;
    var bunshi : long ; bunshi := 0 ;
        var i : int ; i := 1 ; while i <= a do ( (     bunshi := bunshi->excludes(kaijo.divide(long("" + Set{1, i - 1}->max()))) )  ;     i := i + 1 ) ; 
    if (a < 3) then     OclFile["System.out"].print("1.") else     OclFile["System.out"].print("0.") ; ;  
    if (a < 3) then     bunshi := 0 ; else skip ; 
        var i : int ; i := 0 ; while i < d do ( (     bunshi := bunshi.multiply(long("" + 10)) ; 
     OclFile["System.out"].print(bunshi.divide(bunbo)+"") ; 
     bunshi := bunshi.mod(bunbo) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  static final int MOD=10 ;
  static final int LOG=11000 ;
  static int numerator[]=new int[LOG];
  static int answer[]=new int[LOG];
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      Arrays.fill(numerator,0);
      Arrays.fill(answer,0);
      String line[]=br.readLine().split(" ");
      int n=Integer.parseInt(line[0]);
      boolean m=line[2] .equals("1");
      int r=Integer.parseInt(line[3]);
      if(n==0){
        break ;
      }
      numerator[4]=1 ;
      answer[4]=1 ;
      if(m){
        for(int i=1 ; i<n ; i++){
          Arrays.fill(numerator,0);
          numerator[4]=1 ;
          div(numerator,i);
          add(answer,numerator);
        }
      }
      div(answer,n);
      System.out.print(answer[4]+".");
      for(int i=1 ; i<=r ; i++){
        System.out.print(answer[4+i]);
      }
      System.out.println();
    }
  }
  static void div(int[] base,int hoge){
    int carry=0 ;
    for(int i=0 ; i<LOG ; i++){
      base[i]+=carry*MOD ;
      carry=(base[i] % hoge);
      base[i]/=hoge ;
    }
  }
  static void add(int[] base,int[] hoge){
    int carry=0 ;
    for(int i=LOG-1 ; i>=0 ; i--){
      base[i]+=hoge[i]+carry ;
      carry=base[i]/MOD ;
      base[i] %=MOD ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 10;
  static    attribute LOG : int := 11000;
  static   attribute numerator : int := Integer.subrange(1,LOG)->collect(0);
  static   attribute answer : int := Integer.subrange(1,LOG)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     numerator := numerator->collect(0) ; 
     answer := answer->collect(0) ; 
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var n : int ; n := (line[0+1])->toInteger() ;
    var m : boolean ; m := line[2+1] = "1" ;
    var r : int ; r := (line[3+1])->toInteger() ;
    if (n = 0) then (     break ) else skip ; 
    numerator[4+1] := 1 ; 
    answer[4+1] := 1 ; 
    if (m) then (         var i : int ; i := 1 ; while i < n do ( (     numerator := numerator->collect(0) ; 
     numerator[4+1] := 1 ; 
     execute div(numerator, i) ; 
     execute add(answer, numerator) )  ;     i := i + 1 ) ) else skip ; 
    execute div(answer, n) ; 
    OclFile["System.out"].print(answer[4+1] + ".") ; 
        var i : int ; i := 1 ; while i <= r do ( (     OclFile["System.out"].print(answer[4 + i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) );
  static   operation div( base : Sequence(int), hoge : int) : void
  pre: true
  post: true
  activity: (     var carry : int ; carry := 0 ;
         var i : int ; i := 0 ; while i < LOG do ( (     base[i+1] := base[i+1]+(carry * MOD) ; 
     carry := (base[i+1] mod hoge) ; 
     base[i+1] := base[i+1]/(hoge) )  ;     i := i + 1 ) );
  static   operation add( base : Sequence(int), hoge : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var carry : int ; carry := 0 ;
         var i : int ; i := LOG - 1 ; while i >= 0 do ( (     base[i+1] := base[i+1]+(hoge[i+1] + carry) ; 
     carry := base[i+1] / MOD ; 
     base[i+1] := base[i+1] mod MOD )  ;     i := i - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String arg[]){
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      double a[]=new double[n];
      int b[]=new int[7];
      Arrays.fill(b,0);
      for(int i=0 ; i<n ; i++)a[i]=sc.nextDouble();
      for(int i=0 ; i<n ; i++){
        if(a[i]<165.0)b[1]++;
        if(165.0<=a[i] && a[i]<170.0)b[2]++;
        if(170.0<=a[i] && a[i]<175.0)b[3]++;
        if(175.0<=a[i] && a[i]<180.0)b[4]++;
        if(180.0<=a[i] && a[i]<185.0)b[5]++;
        if(a[i]>=185.0)b[6]++;
      }
      for(int i=1 ; i<=6 ; i++){
        System.out.print(i+":");
        for(int j=0 ; j<b[i]; j++)System.out.print("*");
        System.out.println();
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(double) ; a := Integer.subrange(1,n)->collect(0.0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,7)->collect(0) ;
    b := b->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toReal() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] < 165.0) then     b[1+1] := b[1+1] + 1 ; else skip ; 
     if (165.0 <= a[i+1] & a[i+1] < 170.0) then     b[2+1] := b[2+1] + 1 ; else skip ; 
    if (170.0 <= a[i+1] & a[i+1] < 175.0) then     b[3+1] := b[3+1] + 1 ; else skip ; 
    if (175.0 <= a[i+1] & a[i+1] < 180.0) then     b[4+1] := b[4+1] + 1 ; else skip ; 
    if (180.0 <= a[i+1] & a[i+1] < 185.0) then     b[5+1] := b[5+1] + 1 ; else skip ; 
    if (a[i+1] >= 185.0) then     b[6+1] := b[6+1] + 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 6 do ( (     OclFile["System.out"].print(i + ":") ; 
         var j : int ; j := 0 ; while j < b[i+1] do (     OclFile["System.out"].print("*") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String line=br.readLine();
      int N=Integer.parseInt(line);
      if(N==0){
        return ;
      }
      int myScore=0 ;
      int yourScore=0 ;
      for(int i=0 ; i<N ; i++){
        String readLine=br.readLine();
        readLine=readLine.trim();
        String[] readLineArray=readLine.split(" ");
        int mine=Integer.parseInt(readLineArray[0]);
        int yours=Integer.parseInt(readLineArray[1]);
        if(mine<yours){
          yourScore+=mine+yours ;
        }
        else if(mine>yours){
          myScore+=mine+yours ;
        }
        else {
          myScore+=mine ;
          yourScore+=yours ;
        }
      }
      System.out.printf("%d %d\n",myScore,yourScore);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var line : String ; line := br.readLine() ;
     var N : int ; N := (line)->toInteger() ;
    if (N = 0) then (     return ) else skip ; 
    var myScore : int ; myScore := 0 ;
    var yourScore : int ; yourScore := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var readLine : String ; readLine := br.readLine() ;
     readLine := readLine->trim() ; 
    var readLineArray : Sequence(String) ; readLineArray := readLine->split(" ") ;
    var mine : int ; mine := (readLineArray[0+1])->toInteger() ;
    var yours : int ; yours := (readLineArray[1+1])->toInteger() ;
    if (mine < yours) then (     yourScore := yourScore+(mine + yours) ) else     if (mine > yours) then (     myScore := myScore+(mine + yours) ) else (     myScore := myScore+(mine) ; 
     yourScore := yourScore+(yours) ) ;  ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%d %d\n", myScore, yourScore) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Mridul5 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    int k=0 ;
    while(k!=t){
      k=k+1 ;
      String str=sc.next();
      int u=str.length();
      int i=-1 ;
      int x=0,y=0 ;
      int zero=0,one=0 ;
      while(i!=u-1){
        i=i+1 ;
        if(str.charAt(i)=='1'){
          one=one+1 ;
        }
        else {
          zero=zero+1 ;
        }
      }
      x=Math.min(zero,one);
      if(x % 2==0){
        System.out.println("NET");
      }
      else {
        System.out.println("DA");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mridul5 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     var k : int ; k := 0 ;
     while (k /= t) do (     k := k + 1 ; 
     var str : String ; str := sc.getCurrent() ;
    var u : int ; u := str->size() ;
    var i : int ; i := -1 ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var zero : int ; zero := 0 ;
    var one : int ; one := 0 ;
    while (i /= (u)->char2byte() - 1) do (     i := i + 1 ; 
     if (str->at(i+1) = '1') then (     one := one + 1 ) else (     zero := zero + 1 ) ) ; 
    x := Set{zero, one}->min() ; 
    if (x mod 2 = 0) then (     OclFile["System.out"].println("NET") ) else (     OclFile["System.out"].println("DA") ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int[] data=new int[6];
    Arrays.fill(data,0);
    int n=Integer.parseInt(br.readLine());
    for(int i=0 ; i<n ; i++){
      double height=Double.parseDouble(br.readLine());
      if(height<165)data[0]++;
      else if(height<170)data[1]++;
      else if(height<175)data[2]++;
      else if(height<180)data[3]++;
      else if(height<185)data[4]++;
      else data[5]++;
    }
    for(int i=0 ; i<6 ; i++){
      System.out.print((i+1)+":");
      for(int j=0 ; j<data[i]; j++){
        System.out.print("*");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var data : Sequence(int) ; data := Integer.subrange(1,6)->collect(0) ;
    data := data->collect(0) ; 
    var n : int ; n := (br.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var height : double ; height := (br.readLine())->toReal() ;
     if (height < 165) then     data[0+1] := data[0+1] + 1 ; else     if (height < 170) then     data[1+1] := data[1+1] + 1 else     if (height < 175) then     data[2+1] := data[2+1] + 1 else     if (height < 180) then     data[3+1] := data[3+1] + 1 else     if (height < 185) then     data[4+1] := data[4+1] + 1 else     data[5+1] := data[5+1] + 1 ; ;  ;  ;  ;  )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 6 do ( (     OclFile["System.out"].print((i + 1) + ":") ; 
         var j : int ; j := 0 ; while j < data[i+1] do ( (     OclFile["System.out"].print("*") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static final Scanner scn=new Scanner(System.in);
  public static void main(String[] args){
    printArray(createArray(scn.nextInt()));
  }
  public static int[] createArray(int n){
    int[] ary=new int[6];
    for(int i=0 ; i<n ; i++){
      int idx=((int)scn.nextDouble()-160)/5 ;
      ary[idx>0 ?(idx<5 ? idx : 5): 0]++;
    }
    return ary ;
  }
  public static void printArray(int[] ary){
    for(int i=0 ; i<6 ; i++){
      StringBuilder sb=new StringBuilder(i+1+":");
      for(int j=0 ; j<ary[i]; j++){
        sb.append("*");
      }
      System.out.println(sb);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute scn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute printArray(createArray(scn.getCurrent()->toInteger())) );
  static   operation createArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ary : Sequence(int) ; ary := Integer.subrange(1,6)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     var idx : int ; idx := (scn.getCurrent()->toReal()->oclAsType(int) - 160) / 5 ;
     ary[if idx > 0 then (if idx < 5 then idx else 5 endif) else 0 endif+1] := ary[if idx > 0 then (if idx < 5 then idx else 5 endif) else 0 endif+1] + 1 )  ;     i := i + 1 ) ; 
     return ary );
  static   operation printArray( ary : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 6 do ( (     var sb : String ; sb := StringLib.newString(i + 1 + ":") ;
         var j : int ; j := 0 ; while j < ary[i+1] do ( (     sb := sb + StringLib.newString("*") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(sb) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner inp=new Scanner(System.in);
    int x=inp.nextInt();
    int a=inp.nextInt();
    int b=inp.nextInt();
    inp.close();
    x-=a ;
    int p=(int)Math.floor(x/b);
    System.out.println(x-b*p);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inp : OclFile ; inp := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := inp.getCurrent()->toInteger() ;
    var a : int ; a := inp.getCurrent()->toInteger() ;
    var b : int ; b := inp.getCurrent()->toInteger() ;
    skip ; 
    x := x-(a) ; 
    var p : int ; p := (x / b)->floor()->oclAsType(int) ;
    OclFile["System.out"].println(x - b * p) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class Main {
  public static void main(String[] args)throws java.lang.Exception {
    int[] arr=new int[6];
    int num=0 ;
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      if(num==0){
        num=sc.nextInt();
      }
      else {
        Double dbl=sc.nextDouble();
        if(dbl<165){
          arr[0]++;
        }
        else if(dbl<170){
          arr[1]++;
        }
        else if(dbl<175){
          arr[2]++;
        }
        else if(dbl<180){
          arr[3]++;
        }
        else if(dbl<185){
          arr[4]++;
        }
        else {
          arr[5]++;
        }
      }
    }
    Output(arr);
  }
  private static void Output(int[] arr){
    String str="" ;
    for(int i=0 ; i<arr.length ; i++){
      str=i+1+":" ;
      for(int j=0 ; j<arr[i]; j++){
        str=str+"*" ;
      }
      System.out.println(str);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,6)->collect(0) ;
     var num : int ; num := 0 ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (sc.hasNext()) do (     if (num = 0) then (     num := sc.getCurrent()->toInteger() ) else (     var dbl : double ; dbl := sc.getCurrent()->toReal() ;
     if (dbl < 165) then (     arr[0+1] := arr[0+1] + 1 ) else     if (dbl < 170) then (     arr[1+1] := arr[1+1] + 1 ) else     if (dbl < 175) then (     arr[2+1] := arr[2+1] + 1 ) else     if (dbl < 180) then (     arr[3+1] := arr[3+1] + 1 ) else     if (dbl < 185) then (     arr[4+1] := arr[4+1] + 1 ) else (     arr[5+1] := arr[5+1] + 1 ) ;  ;  ;  ;  ) ) ; 
    execute Output(arr) ; 
 );
  static   operation Output( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     str := i + 1 + ":" ; 
         var j : int ; j := 0 ; while j < arr[i+1] do ( (     str := str + "*" )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(str) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  double[] hgt={
    185.0,180.0,175.0,170.0,165.0,0.0 };
    Main(){
      Scanner sc=new Scanner(System.in);
      while(sc.hasNext()){
        int n=sc.nextInt();
        if(n==0)break ;
        String[] str=new String[6];
        for(int i=5 ; i>=0 ; i--)str[i]=Integer.toString(6-i)+":" ;
        for(int i=0 ; i<n ; i++){
          double t=sc.nextDouble();
          for(int j=0 ; j<6 ; j++)if(t>=hgt[j]){
            str[j]+="*" ;
            break ;
          }
        }
        for(int i=5 ; i>=0 ; i--)System.out.println(str[i]);
      }
    }
    public static void main(String[] args){
      new Main();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute hgt : Sequence(double) := Sequence{185.0,180.0,175.0,170.0,165.0,0.0};
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var str : Sequence(String) ; str := Integer.subrange(1,6)->collect(null) ;
        var i : int ; i := 5 ; while i >= 0 do (     str[i+1] := ((6 - i) + "") + ":" ;  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var t : double ; t := sc.getCurrent()->toReal() ;
         var j : int ; j := 0 ; while j < 6 do (     if (t >= hgt[j+1]) then (     str[j+1] := str[j+1]+("*") ; 
     break ) else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 5 ; while i >= 0 do (     OclFile["System.out"].println(str[i+1]) ;  ;     i := i - 1 ) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maxSum(int arr[],int n){
    int cum_sum=0 ;
    for(int i=0 ; i<n ; i++)cum_sum+=arr[i];
    int curr_val=0 ;
    for(int i=0 ; i<n ; i++)curr_val+=i*arr[i];
    int res=curr_val ;
    for(int i=1 ; i<n ; i++){
      int next_val=curr_val-(cum_sum-arr[i-1])+arr[i-1]*(n-1);
      curr_val=next_val ;
      res=Math.max(res,next_val);
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      8,3,1,2 };
      int n=arr.length ;
      System.out.println(maxSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var cum_sum : int ; cum_sum := 0 ;
         var i : int ; i := 0 ; while i < n do (     cum_sum := cum_sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    var curr_val : int ; curr_val := 0 ;
        var i : int ; i := 0 ; while i < n do (     curr_val := curr_val+(i * arr[i+1]) ;  ;     i := i + 1 ) ; 
    var res : int ; res := curr_val ;
        var i : int ; i := 1 ; while i < n do ( (     var next_val : int ; next_val := curr_val - (cum_sum - arr[i - 1+1]) + arr[i - 1+1] * (n - 1) ;
     curr_val := next_val ; 
     res := Set{res, next_val}->max() )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,3,1,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().main();
  }
  void main(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[][] mat=new int[n+1][n+1];
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=n ; j++){
        mat[i][j]=sc.nextInt();
      }
    }
    int[][] dp1=new int[n+1][n+1];
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=n ; j++){
        dp1[i][j]=dp1[i-1][j]+dp1[i][j-1]-dp1[i-1][j-1]+mat[i][j];
      }
    }
    int[][] dp2=new int[n+1][n+1];
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=n ; j++){
        int max=dp1[i][j];
        for(int k=1 ; k<=i ; k++){
          for(int l=1 ; l<=j ; l++){
            max=Math.max(dp1[i][j]-dp1[k-1][j]-dp1[i][l-1]+dp1[k-1][l-1],max);
          }
        }
        dp2[i][j]=max ;
      }
    }
    int max=dp2[1][1];
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=n ; j++){
        max=Math.max(dp2[i][j],max);
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().main() );
   operation main() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var mat : Sequence(Sequence(int)) ; mat := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     mat[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var dp1 : Sequence(Sequence(int)) ; dp1 := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     dp1[i+1][j+1] := dp1[i - 1+1][j+1] + dp1[i+1][j - 1+1] - dp1[i - 1+1][j - 1+1] + mat[i+1][j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var dp2 : Sequence(Sequence(int)) ; dp2 := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     var max : int ; max := dp1[i+1][j+1] ;
         var k : int ; k := 1 ; while k <= i do ( (         var l : int ; l := 1 ; while l <= j do ( (     max := Set{dp1[i+1][j+1] - dp1[k - 1+1][j+1] - dp1[i+1][l - 1+1] + dp1[k - 1+1][l - 1+1], max}->max() )  ;     l := l + 1 ) )  ;     k := k + 1 ) ; 
     dp2[i+1][j+1] := max )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := dp2[1+1][1+1] ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do ( (     max := Set{dp2[i+1][j+1], max}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(final java.util.Scanner sc,final java.io.PrintStream out){
    int[][] a ;
    int N ;
    int i,j,k,l ;
    int res ;
    N=sc.nextInt();
    a=new int[N][N+1];
    for(i=0 ; i<N ; ++i)for(j=1 ; j<=N ; ++j)a[i][j]=sc.nextInt();
    for(i=0 ; i<N ; ++i)for(j=1 ; j<=N ; ++j)a[i][j]+=a[i][j-1];
    res=a[0][1];
    for(i=0 ; i<N ; ++i)for(j=i+1 ; j<=N ; ++j){
      for(k=0 ; k<N ; ++k){
        int t=0 ;
        for(l=k ; l<N ; ++l){
          t+=a[l][j]-a[l][i];
          res=Math.max(res,t);
        }
      }
    }
    out.println(res);
  }
  public static void main(String[] args){
(new Main()).run(new java.util.Scanner(System.in),System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( sc : Scanner, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var a : Sequence(Sequence(int)) ;
     var N : int ;
    var i : int ;
    var j : int ;
    var k : int ;
    var l : int ;
    var res : int ;
    N := sc.nextInt() ; 
    a := Integer.subrange(1,N)->collect(Integer.subrange(1,N + 1)->collect(0)) ; 
        i := 0 ; while i < N do (         j := 1 ; while j <= N do (     a[i+1][j+1] := sc.nextInt() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < N do (         j := 1 ; while j <= N do (     a[i+1][j+1] := a[i+1][j+1]+(a[i+1][j - 1+1]) ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    res := a[0+1][1+1] ; 
        i := 0 ; while i < N do (         j := i + 1 ; while j <= N do ( (         k := 0 ; while k < N do ( (     var t : int ; t := 0 ;
         l := k ; while l < N do ( (     t := t+(a[l+1][j+1] - a[l+1][i+1]) ; 
     res := Set{res, t}->max() )  ;     l := l + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    out.println(res) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(Scanner.newScanner(OclFile["System.in"]), OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n=parseInt(line);
      int[][] matrix=new int[n+2][n+2];
      for(int i=1 ; i<n+1 ; i++){
        StringTokenizer st=new StringTokenizer(br.readLine());
        for(int j=1 ; j<n+1 ; j++){
          matrix[i][j]=parseInt(st.nextToken())+matrix[i-1][j]+matrix[i][j-1]-matrix[i-1][j-1];
        }
      }
      int max=Integer.MIN_VALUE ;
      for(int i=0 ; i<n ; i++){
        for(int j=i+1 ; j<n+1 ; j++){
          for(int k=0 ; k<n ; k++){
            for(int l=k+1 ; l<n+1 ; l++){
              max=Math.max(max,matrix[j][l]-matrix[j][k]-matrix[i][l]+matrix[i][k]);
            }
          }
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ; n := parseInt(line) ;
     var matrix : Sequence(Sequence(int)) ; matrix := Integer.subrange(1,n + 2)->collect(Integer.subrange(1,n + 2)->collect(0)) ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
         var j : int ; j := 1 ; while j < n + 1 do ( (     matrix[i+1][j+1] := parseInt(st.next()) + matrix[i - 1+1][j+1] + matrix[i+1][j - 1+1] - matrix[i - 1+1][j - 1+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n + 1 do ( (         var k : int ; k := 0 ; while k < n do ( (         var l : int ; l := k + 1 ; while l < n + 1 do ( (     max := Set{max, matrix[j+1][l+1] - matrix[j+1][k+1] - matrix[i+1][l+1] + matrix[i+1][k+1]}->max() )  ;     l := l + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args)throws Exception {
    new Main().run();
  }
  void run()throws Exception {
    int n=sc.nextInt();
    int[][] s=new int[n+1][n+1];
    for(int y=1 ; y<=n ; y++){
      for(int x=1 ; x<=n ; x++){
        s[y][x]=sc.nextInt();
        s[y][x]+=s[y-1][x]+s[y][x-1]-s[y-1][x-1];
      }
    }
    int max=s[n][n];
    for(int b=1 ; b<=n ; b++){
      for(int t=0 ; t<b ; t++){
        for(int r=1 ; r<=n ; r++){
          for(int l=0 ; l<r ; l++){
            max=Math.max(max,s[b][r]-s[b][l]+s[t][l]-s[t][r]);
          }
        }
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : Sequence(Sequence(int)) ; s := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var y : int ; y := 1 ; while y <= n do ( (         var x : int ; x := 1 ; while x <= n do ( (     s[y+1][x+1] := sc.getCurrent()->toInteger() ; 
     s[y+1][x+1] := s[y+1][x+1]+(s[y - 1+1][x+1] + s[y+1][x - 1+1] - s[y - 1+1][x - 1+1]) )  ;     x := x + 1 ) )  ;     y := y + 1 ) ; 
    var max : int ; max := s[n+1][n+1] ;
        var b : int ; b := 1 ; while b <= n do ( (         var t : int ; t := 0 ; while t < b do ( (         var r : int ; r := 1 ; while r <= n do ( (         var l : int ; l := 0 ; while l < r do ( (     max := Set{max, s[b+1][r+1] - s[b+1][l+1] + s[t+1][l+1] - s[t+1][r+1]}->max() )  ;     l := l + 1 ) )  ;     r := r + 1 ) )  ;     t := t + 1 ) )  ;     b := b + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    sc.nextLine();
    while(t--!=0){
      String val=sc.nextLine();
      int cnt0=0 ;
      for(int i=0 ; i<val.length(); i++){
        if(val.charAt(i)=='0'){
          cnt0++;
        }
      }
      int ans=Math.min(cnt0,Math.abs(val.length()-cnt0));
      if(ans % 2==0)System.out.println("NET");
      else System.out.println("DA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     skip ; 
         while (t /= 0) do (    skip ; (     var val : String ; val := sc.nextLine() ;
     var cnt0 : int ; cnt0 := 0 ;
        var i : int ; i := 0 ; while i < val->size() do ( (     if (val->at(i+1) = '0') then (     cnt0 := cnt0 + 1 ) else skip )  ;     i := i + 1 ) ; 
    var ans : int ; ans := Set{cnt0, if val->size() - (cnt0)->char2byte() < 0 then -(val->size() - (cnt0)->char2byte()) else val->size() - (cnt0)->char2byte() endif}->min() ;
    if (ans mod 2 = 0) then     OclFile["System.out"].println("NET") else     OclFile["System.out"].println("DA") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    long countMax=sc.nextLong();
    long array[]=new long[num];
    long sorted[][]=new long[num][2];
    for(int i=0 ; i<num ; i++){
      array[i]=sc.nextLong();
      sorted[i][0]=array[i];
      sorted[i][1]=i ;
    }
    Arrays.sort(sorted,(a,b)->Long.compare(a[0],b[0]));
    int next[]=new int[num];
    int prv=(int)sorted[0][1];
    for(int i=1 ; i<num ; i++){
      if(sorted[i][0]==sorted[i-1][0]){
        next[(int)sorted[i-1][1] ]=(int)sorted[i][1];
      }
      else {
        next[(int)sorted[i-1][1] ]=prv ;
        prv=(int)sorted[i][1];
      }
    }
    next[(int)sorted[num-1][1] ]=prv ;
    int count=1 ;
    int tmpIndex=0 ;
    int lastIndex[]=new int[num];
    while(tmpIndex!=num){
      if(next[tmpIndex]<=tmpIndex){
        lastIndex[count-1]=tmpIndex ;
        count++;
      }
      tmpIndex=next[tmpIndex]+1 ;
    }
    countMax=(countMax-1)% count ;
    if(countMax==count-1){
      System.out.println();
      return ;
    }
    StringBuilder ans=new StringBuilder();
    tmpIndex=lastIndex[(int)countMax];
    while(tmpIndex<num){
      if(next[tmpIndex]<=tmpIndex){
        ans.append(array[tmpIndex]+" ");
        tmpIndex++;
      }
      else {
        tmpIndex=next[tmpIndex]+1 ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
    var countMax : long ; countMax := sc.getCurrent()->toLong() ;
    var array : Sequence(long) ; array := Integer.subrange(1,num)->collect(0) ;
    var sorted : Sequence(Sequence(long)) ; sorted := Integer.subrange(1,num)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < num do ( (     array[i+1] := sc.getCurrent()->toLong() ; 
     sorted[i+1][0+1] := array[i+1] ; 
     sorted[i+1][1+1] := i )  ;     i := i + 1 ) ; 
    sorted := OclComparator.sortWith(sorted, lambda (a , b) : OclAny in compare(a[0+1], b[0+1])) ; 
    var next : Sequence(int) ; next := Integer.subrange(1,num)->collect(0) ;
    var prv : int ; prv := sorted[0+1][1+1]->oclAsType(int) ;
        var i : int ; i := 1 ; while i < num do ( (     if (sorted[i+1][0+1] = sorted[i - 1+1][0+1]) then (     next[sorted[i - 1+1][1+1]->oclAsType(int)+1] := sorted[i+1][1+1]->oclAsType(int) ) else (     next[sorted[i - 1+1][1+1]->oclAsType(int)+1] := prv ; 
     prv := sorted[i+1][1+1]->oclAsType(int) ) )  ;     i := i + 1 ) ; 
    next[sorted[num - 1+1][1+1]->oclAsType(int)+1] := prv ; 
    var count : int ; count := 1 ;
    var tmpIndex : int ; tmpIndex := 0 ;
    var lastIndex : Sequence(int) ; lastIndex := Integer.subrange(1,num)->collect(0) ;
    while (tmpIndex /= num) do (     if (next[tmpIndex+1] <= tmpIndex) then (     lastIndex[count - 1+1] := tmpIndex ; 
     count := count + 1 ) else skip ; 
     tmpIndex := next[tmpIndex+1] + 1 ) ; 
    countMax := (countMax - 1) mod count ; 
    if (countMax = count - 1) then (     OclFile["System.out"].println() ; 
     return ) else skip ; 
    var ans : String ; ans := StringLib.newString() ;
    tmpIndex := lastIndex[countMax->oclAsType(int)+1] ; 
    while (tmpIndex < num) do (     if (next[tmpIndex+1] <= tmpIndex) then (     ans := ans + StringLib.newString(array[tmpIndex+1] + " ") ; 
     tmpIndex := tmpIndex + 1 ) else (     tmpIndex := next[tmpIndex+1] + 1 ) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.time.chrono.MinguoChronology ;
import java.util.*;
public class LC {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[][] arr=new int[n][2];
    StringBuilder s=new StringBuilder();
    int sum=0 ;
    boolean flag=true ;
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      if(x<y){
        if(sum+x>500){
          if(sum-y<-500){
            System.out.println(-1);
            return ;
          }
          else {
            sum-=y ;
            s.append('G');
          }
        }
        else {
          sum+=x ;
          s.append('A');
        }
      }
      else {
        if(sum-y<-500){
          if(sum+x>500){
            System.out.println(-1);
            return ;
          }
          else {
            sum+=x ;
            s.append('A');
          }
        }
        else {
          sum-=y ;
          s.append('G');
        }
      }
    }
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class LC {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
    var s : String ; s := StringLib.newString() ;
    var sum : int ; sum := 0 ;
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     if (x < y) then (     if (sum + x > 500) then (     if ((sum)->char2byte() - y < -500) then (     OclFile["System.out"].println(-1) ; 
     return ) else (     sum := sum-(y) ; 
     s := s + StringLib.newString('G') ) ) else (     sum := sum+(x) ; 
     s := s + StringLib.newString('A') ) ) else (     if ((sum)->char2byte() - y < -500) then (     if (sum + x > 500) then (     OclFile["System.out"].println(-1) ; 
     return ) else (     sum := sum+(x) ; 
     s := s + StringLib.newString('A') ) ) else (     sum := sum-(y) ; 
     s := s + StringLib.newString('G') ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdin=new Scanner(System.in);
    System.out.println((stdin.nextInt()-stdin.nextInt())% stdin.nextInt());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     OclFile["System.out"].println((stdin.getCurrent()->toInteger() - stdin.getCurrent()->toInteger()) mod stdin.getCurrent()->toInteger()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num=sc.nextInt();
    long countMax=sc.nextLong();
    long array[]=new long[num];
    long sorted[][]=new long[num][2];
    for(int i=0 ; i<num ; i++){
      array[i]=sc.nextLong();
      sorted[i][0]=array[i];
      sorted[i][1]=i ;
    }
    Arrays.sort(sorted,(a,b)->Long.compare(a[0],b[0]));
    int next[]=new int[num];
    int prv=(int)sorted[0][1];
    for(int i=1 ; i<num ; i++){
      if(sorted[i][0]==sorted[i-1][0]){
        next[(int)sorted[i-1][1] ]=(int)sorted[i][1];
      }
      else {
        next[(int)sorted[i-1][1] ]=prv ;
        prv=(int)sorted[i][1];
      }
    }
    next[(int)sorted[num-1][1] ]=prv ;
    int count=1 ;
    int tmpIndex=0 ;
    int lastIndex[]=new int[num];
    while(tmpIndex!=num){
      if(next[tmpIndex]<=tmpIndex){
        lastIndex[count-1]=tmpIndex ;
        count++;
      }
      tmpIndex=next[tmpIndex]+1 ;
    }
    countMax=(countMax-1)% count ;
    if(countMax==count-1){
      System.out.println();
      return ;
    }
    StringBuilder ans=new StringBuilder();
    tmpIndex=lastIndex[(int)countMax];
    while(tmpIndex<num){
      if(next[tmpIndex]<=tmpIndex){
        ans.append(array[tmpIndex]+" ");
        tmpIndex++;
      }
      else {
        tmpIndex=next[tmpIndex]+1 ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := sc.getCurrent()->toInteger() ;
    var countMax : long ; countMax := sc.getCurrent()->toLong() ;
    var array : Sequence(long) ; array := Integer.subrange(1,num)->collect(0) ;
    var sorted : Sequence(Sequence(long)) ; sorted := Integer.subrange(1,num)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < num do ( (     array[i+1] := sc.getCurrent()->toLong() ; 
     sorted[i+1][0+1] := array[i+1] ; 
     sorted[i+1][1+1] := i )  ;     i := i + 1 ) ; 
    sorted := OclComparator.sortWith(sorted, lambda (a , b) : OclAny in compare(a[0+1], b[0+1])) ; 
    var next : Sequence(int) ; next := Integer.subrange(1,num)->collect(0) ;
    var prv : int ; prv := sorted[0+1][1+1]->oclAsType(int) ;
        var i : int ; i := 1 ; while i < num do ( (     if (sorted[i+1][0+1] = sorted[i - 1+1][0+1]) then (     next[sorted[i - 1+1][1+1]->oclAsType(int)+1] := sorted[i+1][1+1]->oclAsType(int) ) else (     next[sorted[i - 1+1][1+1]->oclAsType(int)+1] := prv ; 
     prv := sorted[i+1][1+1]->oclAsType(int) ) )  ;     i := i + 1 ) ; 
    next[sorted[num - 1+1][1+1]->oclAsType(int)+1] := prv ; 
    var count : int ; count := 1 ;
    var tmpIndex : int ; tmpIndex := 0 ;
    var lastIndex : Sequence(int) ; lastIndex := Integer.subrange(1,num)->collect(0) ;
    while (tmpIndex /= num) do (     if (next[tmpIndex+1] <= tmpIndex) then (     lastIndex[count - 1+1] := tmpIndex ; 
     count := count + 1 ) else skip ; 
     tmpIndex := next[tmpIndex+1] + 1 ) ; 
    countMax := (countMax - 1) mod count ; 
    if (countMax = count - 1) then (     OclFile["System.out"].println() ; 
     return ) else skip ; 
    var ans : String ; ans := StringLib.newString() ;
    tmpIndex := lastIndex[countMax->oclAsType(int)+1] ; 
    while (tmpIndex < num) do (     if (next[tmpIndex+1] <= tmpIndex) then (     ans := ans + StringLib.newString(array[tmpIndex+1] + " ") ; 
     tmpIndex := tmpIndex + 1 ) else (     tmpIndex := next[tmpIndex+1] + 1 ) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int N=sc.nextInt(),A=sc.nextInt();
      int[] D=new int[N];
      for(int i=0 ; i<N ; i++){
        D[i]=sc.nextInt();
      }
      int ans=0 ;
      for(int i=0 ; i<N ; i++){
        if(i!=0 && i*A % N==0){
          break ;
        }
        int vmax=0,vmin=101 ;
        for(int j=0 ; j<A ; j++){
          vmax=Math.max(vmax,D[(i*A+j)% N]);
          vmin=Math.min(vmin,D[(i*A+j)% N]);
        }
        ans+=vmax-vmin ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
     var D : Sequence(int) ; D := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     D[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (i /= 0 & i * A mod N = 0) then (     break ) else skip ; 
     var vmax : int ; vmax := 0 ;
    var vmin : int ; vmin := 101 ;
         var j : int ; j := 0 ; while j < A do ( (     vmax := Set{vmax, D[(i * A + j) mod N+1]}->max() ; 
     vmin := Set{vmin, D[(i * A + j) mod N+1]}->min() )  ;     j := j + 1 ) ; 
     ans := ans+(vmax - vmin) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
  Scanner sc=new Scanner(System.in);
  void run(){
    int n=sc.nextInt();
    int m=sc.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    int result=0 ;
    int x=0 ;
    for(; ; ){
      int min=a[x];
      int max=a[x];
      for(int i=0 ; i<m ; i++){
        min=Math.min(min,a[x]);
        max=Math.max(max,a[x]);
        x++;
        if(x==n)x=0 ;
      }
      result+=max-min ;
      if(x==0){
        break ;
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var result : int ; result := 0 ;
    var x : int ; x := 0 ;
      while true do ( (     var min : int ; min := a[x+1] ;
     var max : int ; max := a[x+1] ;
        var i : int ; i := 0 ; while i < m do ( (     min := Set{min, a[x+1]}->min() ; 
     max := Set{max, a[x+1]}->max() ; 
     x := x + 1 ; 
     if (x = n) then     x := 0 ; else skip )  ;     i := i + 1 ) ; 
    result := result+(max - min) ; 
    if (x = 0) then (     break ) else skip ; 
 )  ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int gcd(int m,int n){
    if(m<n)return gcd(n,m);
    if(n==0)return m ;
    return gcd(n,m % n);
  }
  static int lcm(int m,int n){
    return m*n/gcd(m,n);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[] a=new int[N+1];
    for(int i=0 ; i<N ; i++){
      a[i]=sc.nextInt();
    }
    int MAX,MIN,sum=0 ;
    for(int i=0 ; i<lcm(N,M); i=i+M){
      MAX=0 ;
      MIN=110 ;
      for(int j=i ; j<i+M ; j++){
        MAX=Math.max(MAX,a[j % N]);
        MIN=Math.min(MIN,a[j % N]);
      }
      sum+=MAX-MIN ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( m : int, n : int) : int
  pre: true
  post: true
  activity: (     if (m < n) then     return gcd(n, m) else skip ; 
     if (n = 0) then     return m else skip ; 
     return gcd(n, m mod n) );
  static   operation lcm( m : int, n : int) : int
  pre: true
  post: true
  activity: (     return m * n / gcd(m, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var MAX : int ;
    var MIN : int ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < lcm(N, M) do ( (     MAX := 0 ; 
     MIN := 110 ; 
         var j : int ; j := i ; while j < i + M do ( (     MAX := Set{MAX, a[j mod N+1]}->max() ; 
     MIN := Set{MIN, a[j mod N+1]}->min() )  ;     j := j + 1 ) ; 
     sum := sum+(MAX - MIN) )  ;     i := i + M ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    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 upto=lcm(n,m);
    int max=0 ;
    int min=0 ;
    long total=0 ;
    for(int i=0 ; i<upto ; i++){
      if(i % m==0){
        total+=max-min ;
        max=0 ;
        min=Integer.MAX_VALUE ;
      }
      max=Math.max(max,arr[i % n]);
      min=Math.min(min,arr[i % n]);
    }
    total+=max-min ;
    System.out.println(total);
  }
  static int lcm(int x,int y){
    return x/gcd(x,y)*y ;
  }
  static int gcd(int x,int y){
    if(x % y==0){
      return y ;
    }
    else {
      return gcd(y,x % y);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var upto : int ; upto := lcm(n, m) ;
    var max : int ; max := 0 ;
    var min : int ; min := 0 ;
    var total : long ; total := 0 ;
        var i : int ; i := 0 ; while i < upto do ( (     if (i mod m = 0) then (     total := total+(max - min) ; 
     max := 0 ; 
     min := 2147483647 ) else skip ; 
     max := Set{max, arr[i mod n+1]}->max() ; 
     min := Set{min, arr[i mod n+1]}->min() )  ;     i := i + 1 ) ; 
    total := total+(max - min) ; 
    OclFile["System.out"].println(total) ; 
 );
  static   operation lcm( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return x / gcd(x, y) * y );
  static   operation gcd( x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (x mod y = 0) then (     return y ) else (     return gcd(y, x mod y) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int phi(int n){
    float result=n ;
    for(int p=2 ; p*p<=n ; ++p){
      if(n % p==0){
        while(n % p==0)n/=p ;
        result*=(1.0-(1.0/(float)p));
      }
    }
    if(n>1)result*=(1.0-(1.0/(float)n));
    return(int)result ;
  }
  public static void main(String args[]){
    int n ;
    for(n=1 ; n<=10 ; n++)System.out.println("phi("+n+")="+phi(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation phi( n : int) : int
  pre: true
  post: true
  activity: (     var result : double ; result := n ;
         var p : int ; p := 2 ; while p * p <= n do ( (     if (n mod p = 0) then (     while (n mod p = 0) do     n := n/(p) ; ; 
     result := result*((1.0 - (1.0 / p->oclAsType(double)))) ) else skip )  ;     p := p + 1 ) ; 
     if (n > 1) then     result := result*((1.0 - (1.0 / n->oclAsType(double)))) ; else skip ; 
     return result->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
         n := 1 ; while n <= 10 do (     OclFile["System.out"].println("phi(" + n + ")=" + phi(n)) ;  ;     n := n + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int phi(int n){
    int result=n ;
    for(int p=2 ; p*p<=n ; ++p){
      if(n % p==0){
        while(n % p==0)n/=p ;
        result-=result/p ;
      }
    }
    if(n>1)result-=result/n ;
    return result ;
  }
  public static void main(String[] args){
    int n ;
    for(n=1 ; n<=10 ; n++)System.out.println("phi("+n+")="+phi(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation phi( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := n ;
         var p : int ; p := 2 ; while p * p <= n do ( (     if (n mod p = 0) then (     while (n mod p = 0) do     n := n/(p) ; ; 
     result := result-(result / p) ) else skip )  ;     p := p + 1 ) ; 
     if (n > 1) then     result := result-(result / n) ; else skip ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
         n := 1 ; while n <= 10 do (     OclFile["System.out"].println("phi(" + n + ")=" + phi(n)) ;  ;     n := n + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    String a=sc.nextLine();
    String b=sc.nextLine();
    int x=0 ;
    if(s.indexOf(a)!=-1 && s.indexOf(b,s.indexOf(a)+a.length())!=-1)++x ;
    s=reverse(s);
    if(s.indexOf(a)!=-1 && s.indexOf(b,s.indexOf(a)+a.length())!=-1)x+=2 ;
    String[] arr={
      "fantasy","forward","backward","both" };
      System.out.println(arr[x]);
    }
    public static String reverse(String input){
      byte[] strAsByteArray=input.getBytes();
      byte[] result=new byte[strAsByteArray.length];
      for(int i=0 ; i<strAsByteArray.length ; ++i)result[i]=strAsByteArray[strAsByteArray.length-i-1];
      return new String(result);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var a : String ; a := sc.nextLine() ;
    var b : String ; b := sc.nextLine() ;
    var x : int ; x := 0 ;
    if (s->indexOf(a)-1 /= -1 & s.subrange(s->indexOf(a)-1 + a->size()+1)->indexOf(b+"") + s->indexOf(a)-1 + a->size() - 1  /= -1) then     x := x + 1 ; else skip ; 
    s := reverse(s) ; 
    if (s->indexOf(a)-1 /= -1 & s.subrange(s->indexOf(a)-1 + a->size()+1)->indexOf(b+"") + s->indexOf(a)-1 + a->size() - 1  /= -1) then     x := x+(2) ; else skip ; 
    var arr : Sequence(String) ; arr := Sequence{"fantasy","forward","backward","both"} ;
    OclFile["System.out"].println(arr[x+1]) ; 
 );
  static   operation reverse( input : String) : String
  pre: true
  post: true
  activity: (     var strAsByteArray : Sequence(int) ; strAsByteArray := input->characters()->collect( _c | _c->char2byte() ) ;
     var result : Sequence(int) ; result := Integer.subrange(1,strAsByteArray->size())->collect(0) ;
         var i : int ; i := 0 ; while i < strAsByteArray->size() do (     result[i+1] := strAsByteArray[strAsByteArray->size() - i - 1+1] ;  ;     i := i + 1 ) ; 
     return StringLib.newString(result) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=1 ; i<=n ; i++){
      int num_zero=0,num_one=0 ;
      String s=sc.next();
      char[] c=s.toCharArray();
      int len=c.length ;
      for(int j=0 ; j<len ; j++){
        if(c[j]=='0'){
          num_zero++;
        }
        else {
          num_one++;
        }
      }
      if(num_one==0 || num_zero==0){
        System.out.println("NET");
        continue ;
      }
      else {
        int min=num_one>num_zero ? num_zero : num_one ;
        if(min % 2==0){
          System.out.println("NET");
        }
        else {
          System.out.println("DA");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= n do ( (     var num_zero : int ; num_zero := 0 ;
    var num_one : int ; num_one := 0 ;
     var s : String ; s := sc.getCurrent() ;
    var c : Sequence(String) ; c := s->characters() ;
    var len : int ; len := c->size() ;
        var j : int ; j := 0 ; while j < len do ( (     if (c[j+1] = '0') then (     num_zero := num_zero + 1 ) else (     num_one := num_one + 1 ) )  ;     j := j + 1 ) ; 
    if (num_one = 0 or num_zero = 0) then (     OclFile["System.out"].println("NET") ; 
     continue ) else (     var min : int ; min := if num_one > num_zero then num_zero else num_one endif ;
     if (min mod 2 = 0) then (     OclFile["System.out"].println("NET") ) else (     OclFile["System.out"].println("DA") ) ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    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 idx=k-1 ;
    boolean flag=true ;
    while(idx<n){
      if(arr[idx]!=arr[k-1]){
        flag=false ;
        break ;
      }
      idx++;
    }
    if(! flag){
      System.out.print(-1);
    }
    else {
      int i=k-1 ;
      while(i>=0){
        if(arr[i]!=arr[k-1])break ;
        i--;
      }
      System.out.println(i+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var idx : int ; idx := k - 1 ;
    var flag : boolean ; flag := true ;
    while (idx < n) do (     if (arr[idx+1] /= arr[k - 1+1]) then (     flag := false ; 
     break ) else skip ; 
     idx := idx + 1 ) ; 
    if (not(flag)) then (     OclFile["System.out"].print(-1) ) else (     var i : int ; i := k - 1 ;
     while (i >= 0) do (     if (arr[i+1] /= arr[k - 1+1]) then     break else skip ; 
     i := i - 1 ) ; 
     OclFile["System.out"].println(i + 1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class T8A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String flags=in.nextLine();
    String first=in.nextLine();
    String second=in.nextLine();
    boolean isForward=checkOccurrenceTwoSubstring(flags,first,second);
    boolean isBack=checkOccurrenceTwoSubstring(new StringBuilder(flags).reverse().toString(),first,second);
    if(isForward && isBack){
      System.out.println("both");
    }
    else if(isForward){
      System.out.println("forward");
    }
    else if(isBack){
      System.out.println("backward");
    }
    else {
      System.out.println("fantasy");
    }
  }
  public static boolean checkOccurrenceTwoSubstring(String str,String first,String second){
    boolean check=true ;
    int firstIndex=str.indexOf(first);
    if(firstIndex>=0){
      int secondIndex=str.substring(firstIndex+first.length()).indexOf(second);
      if(secondIndex<0){
        check=false ;
      }
    }
    else {
      check=false ;
    }
    return check ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class T8A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var flags : String ; flags := in.nextLine() ;
    var first : String ; first := in.nextLine() ;
    var second : String ; second := in.nextLine() ;
    var isForward : boolean ; isForward := checkOccurrenceTwoSubstring(flags, first, second) ;
    var isBack : boolean ; isBack := checkOccurrenceTwoSubstring(StringLib.newString(flags)->reverse()+"", first, second) ;
    if (isForward & isBack) then (     OclFile["System.out"].println("both") ) else     if (isForward) then (     OclFile["System.out"].println("forward") ) else     if (isBack) then (     OclFile["System.out"].println("backward") ) else (     OclFile["System.out"].println("fantasy") ) ;  ;  ;  
 );
  static   operation checkOccurrenceTwoSubstring( str : String, first : String, second : String) : boolean
  pre: true
  post: true
  activity: (     var check : boolean ; check := true ;
     var firstIndex : int ; firstIndex := str->indexOf(first)-1 ;
     if (firstIndex >= 0) then (     var secondIndex : int ; secondIndex := str.subrange(firstIndex + first->size()+1,firstIndex + first->size())->indexOf(second)-1 ;
     if (secondIndex < 0) then (     check := false ) else skip ) else (     check := false ) ;  
     return check );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main8A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String flags=scanner.nextLine();
    String flags11=scanner.nextLine();
    String flags12=scanner.nextLine();
    String flags21=new StringBuilder(flags12).reverse().toString();
    String flags22=new StringBuilder(flags11).reverse().toString();
    boolean b1=false ;
    boolean b2=false ;
    int index1 ;
    if(((index1=flags.indexOf(flags11))!=-1)&&(flags.substring(index1+flags11.length()).contains(flags12))){
      b1=true ;
    }
    if(((index1=flags.indexOf(flags21))!=-1)&&(flags.substring(index1+flags21.length()).contains(flags22))){
      b2=true ;
    }
    if(b1 & b2){
      System.out.println("both");
      return ;
    }
    if(b1){
      System.out.println("forward");
      return ;
    }
    if(b2){
      System.out.println("backward");
      return ;
    }
    System.out.println("fantasy");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main8A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var flags : String ; flags := scanner.nextLine() ;
    var flags11 : String ; flags11 := scanner.nextLine() ;
    var flags12 : String ; flags12 := scanner.nextLine() ;
    var flags21 : String ; flags21 := StringLib.newString(flags12)->reverse()+"" ;
    var flags22 : String ; flags22 := StringLib.newString(flags11)->reverse()+"" ;
    var b1 : boolean ; b1 := false ;
    var b2 : boolean ; b2 := false ;
    var index1 : int ;
    if (((index1) /= -1) & (flags.subrange(index1 + flags11->size()+1,index1 + flags11->size())->includes(flags12))) then (     b1 := true ) else skip ; 
    if (((index1) /= -1) & (flags.subrange(index1 + flags21->size()+1,index1 + flags21->size())->includes(flags22))) then (     b2 := true ) else skip ; 
    if (b1 & b2) then (     OclFile["System.out"].println("both") ; 
     return ) else skip ; 
    if (b1) then (     OclFile["System.out"].println("forward") ; 
     return ) else skip ; 
    if (b2) then (     OclFile["System.out"].println("backward") ; 
     return ) else skip ; 
    OclFile["System.out"].println("fantasy") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String[] tokens=in.nextLine().split(" ");
    int a=Integer.parseInt(tokens[0]);
    int b=Integer.parseInt(tokens[1]);
    int c=Integer.parseInt(tokens[2]);
    int x=Integer.parseInt(tokens[3]);
    int y=Integer.parseInt(tokens[4]);
    if((a+b)<=(2*c)){
      int result=a*x+b*y ;
      System.out.println(result);
    }
    else {
      int r=2*c*Math.max(x,y);
      if(x<=y){
        int cNum=2*x ;
        int bNum=y-x ;
        int result=Math.min(cNum*c+bNum*b,r);
        System.out.println(result);
      }
      else {
        int cNum=2*y ;
        int aNum=x-y ;
        int result=Math.min(cNum*c+aNum*a,r);
        System.out.println(result);
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tokens : Sequence(String) ; tokens := in.nextLine()->split(" ") ;
    var a : int ; a := (tokens[0+1])->toInteger() ;
    var b : int ; b := (tokens[1+1])->toInteger() ;
    var c : int ; c := (tokens[2+1])->toInteger() ;
    var x : int ; x := (tokens[3+1])->toInteger() ;
    var y : int ; y := (tokens[4+1])->toInteger() ;
    if ((a + b) <= (2 * c)) then (     var result : int ; result := a * x + b * y ;
     OclFile["System.out"].println(result) ) else (     var r : int ; r := 2 * c * Set{x, y}->max() ;
     if (x <= y) then (     var cNum : int ; cNum := 2 * x ;
     var bNum : int ; bNum := y - x ;
     var result : int ; result := Set{cNum * c + bNum * b, r}->min() ;
     OclFile["System.out"].println(result) ) else (     var cNum : int ; cNum := 2 * y ;
     var aNum : int ; aNum := x - y ;
     var result : int ; result := Set{cNum * c + aNum * a, r}->min() ;
     OclFile["System.out"].println(result) ) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] tmpArray=br.readLine().split(" ");
    int a=Integer.parseInt(tmpArray[0]);
    int b=Integer.parseInt(tmpArray[1]);
    int c=Integer.parseInt(tmpArray[2]);
    int x=Integer.parseInt(tmpArray[3]);
    int y=Integer.parseInt(tmpArray[4]);
    int AB=(a+b)/2 ;
    long result=0 ;
    if(AB>=c){
      int tmp=Math.min(x,y);
      x-=tmp ;
      y-=tmp ;
      result+=tmp*2*c ;
    }
    if(a>2*c){
      a=2*c ;
    }
    if(b>2*c){
      b=2*c ;
    }
    result+=x*a ;
    result+=y*b ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
    var a : int ; a := (tmpArray[0+1])->toInteger() ;
    var b : int ; b := (tmpArray[1+1])->toInteger() ;
    var c : int ; c := (tmpArray[2+1])->toInteger() ;
    var x : int ; x := (tmpArray[3+1])->toInteger() ;
    var y : int ; y := (tmpArray[4+1])->toInteger() ;
    var AB : int ; AB := (a + b) / 2 ;
    var result : long ; result := 0 ;
    if (AB >= c) then (     var tmp : int ; tmp := Set{x, y}->min() ;
     x := x-(tmp) ; 
     y := y-(tmp) ; 
     result := result+(tmp * 2 * c) ) else skip ; 
    if (a > 2 * c) then (     a := 2 * c ) else skip ; 
    if (b > 2 * c) then (     b := 2 * c ) else skip ; 
    result := result+(x * a) ; 
    result := result+(y * b) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int x=sc.nextInt();
    int y=sc.nextInt();
    int cost=0 ;
    if(a+b>2*c){
      int min=Math.min(x,y);
      cost+=2*c*min ;
      x-=min ;
      y-=min ;
      if(a>2*c){
        cost+=2*c*x ;
      }
      else {
        cost+=a*x ;
      }
      if(b>2*c){
        cost+=2*c*y ;
      }
      else {
        cost+=b*y ;
      }
    }
    else {
      cost=cost+a*x+b*y ;
    }
    System.out.println(cost);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var cost : int ; cost := 0 ;
    if (a + b > 2 * c) then (     var min : int ; min := Set{x, y}->min() ;
     cost := cost+(2 * c * min) ; 
    x := x-(min) ; 
    y := y-(min) ; 
    if (a > 2 * c) then (     cost := cost+(2 * c * x) ) else (     cost := cost+(a * x) ) ;  
    if (b > 2 * c) then (     cost := cost+(2 * c * y) ) else (     cost := cost+(b * y) ) ;  
 ) else (     cost := cost + a * x + b * y ) ;  
    OclFile["System.out"].println(cost) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    HalfAndHalf solver=new HalfAndHalf();
    solver.readInput();
    solver.solve();
    solver.writeOutput();
  }
  static class HalfAndHalf {
    private int a ;
    private int b ;
    private int c ;
    private int x ;
    private int y ;
    private Scanner scanner ;
    private int output ;
    public HalfAndHalf(){
      scanner=new Scanner(System.in);
      output=0 ;
    }
    public void readInput(){
      a=Integer.parseInt(scanner.next());
      b=Integer.parseInt(scanner.next());
      c=Integer.parseInt(scanner.next());
      x=Integer.parseInt(scanner.next());
      y=Integer.parseInt(scanner.next());
    }
    public void solve(){
      if((a+b)>=c*2){
        output+=(c*2)*Math.min(x,y);
        if(x<y){
          if(b<c*2){
            output+=b*(y-x);
          }
          else {
            output+=(c*2)*(y-x);
          }
        }
        else if(y<x){
          if(a<c*2){
            output+=a*(x-y);
          }
          else {
            output+=c*2*(x-y);
          }
        }
      }
      else {
        output+=a*x+y*b ;
      }
    }
    public void writeOutput(){
      System.out.println(output);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var solver : HalfAndHalf ; solver := HalfAndHalf.newHalfAndHalf() ;
     solver.readInput() ; 
     solver.solve() ; 
     solver.writeOutput() );
  static class HalfAndHalf {
   attribute a : int;
   attribute b : int;
   attribute c : int;
   attribute x : int;
   attribute y : int;
   attribute scanner : OclFile;
   attribute output : int;
   static operation newHalfAndHalf() : HalfAndHalf
  pre: true
  post: true
  activity:
  ( var self : HalfAndHalf ;
    self := createHalfAndHalf();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     output := 0 );
   operation readInput() : void
  pre: true
  post: true
  activity: (     a := (scanner.getCurrent())->toInteger() ; 
     b := (scanner.getCurrent())->toInteger() ; 
    c := (scanner.getCurrent())->toInteger() ; 
    x := (scanner.getCurrent())->toInteger() ; 
    y := (scanner.getCurrent())->toInteger() ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     if ((a + b) >= c * 2) then (     output := output+((c * 2) * Set{x, y}->min()) ; 
     if (x < y) then (     if (b < c * 2) then (     output := output+(b * (y - x)) ) else (     output := output+((c * 2) * (y - x)) ) ) else     if (y < x) then (     if (a < c * 2) then (     output := output+(a * (x - y)) ) else (     output := output+(c * 2 * (x - y)) ) ) else skip ; ) else (     output := output+(a * x + y * b) ) );
   operation writeOutput() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(output) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF1514B {
  public static Scanner scanner ;
  public static int MOD=(int)Math.pow(10,9)+7 ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int test=scanner.nextInt();
    while(test-->0){
      int n=scanner.nextInt();
      int k=scanner.nextInt();
      long res=1 ;
      for(int i=0 ; i<k ; i++){
        res=(res*n)% MOD ;
      }
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF1514B {
  static   attribute scanner : OclFile;
  static   attribute MOD : int := 10->pow(9)->oclAsType(int) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var test : int ; test := scanner.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var k : int ; k := scanner.getCurrent()->toInteger() ;
    var res : long ; res := 1 ;
        var i : int ; i := 0 ; while i < k do ( (     res := (res * n) mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static Scanner scanner=new Scanner(System.in);
  public static void main(String[] args){
    int k=scanner.nextInt();
    int s=scanner.nextInt();
    int answer=0 ;
    for(int x=0 ; x<=k ; x++)answer+=(s-x+1)-Math.min(s-x+1,Math.max(0,((s-x-k)*2)));
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := scanner.getCurrent()->toInteger() ;
     var s : int ; s := scanner.getCurrent()->toInteger() ;
    var answer : int ; answer := 0 ;
        var x : int ; x := 0 ; while x <= k do (     answer := answer+((s - x + 1) - Set{s - x + 1, Set{0, ((s - x - k) * 2)}->max()}->min()) ;  ;     x := x + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
final class Solver {
  static final Solver INSTANCE=new Solver();
  void solve(Iterator<String>sc){
    int K=Integer.parseInt(sc.next());
    int S=Integer.parseInt(sc.next());
    int sum=0 ;
    for(int x=0 ; x<=K && x<=S ; x++){
      int remaining=S-x ;
      sum+=Math.max(Math.min(remaining,K)-Math.max(remaining-K,0)+1,0);
    }
    System.out.println(sum);
  }
}
class Main {
  public static void main(String...args){
    try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in))){
      Iterator<String>tokens=reader.lines().map(s->s.split(" ")).flatMap(Arrays :: stream).iterator();
      Solver.INSTANCE.solve(tokens);
    }
    catch(IOException e){
      throw new UncheckedIOException(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solver {
  static    attribute INSTANCE : Solver := Solver.newSolver();
   operation solve( sc : OclIterator) : void
  pre: true
  post: true
  activity: (     var K : int ; K := (sc.next())->toInteger() ;
     var S : int ; S := (sc.next())->toInteger() ;
    var sum : int ; sum := 0 ;
        var x : int ; x := 0 ; while x <= K & x <= S do ( (     var remaining : int ; remaining := S - x ;
     sum := sum+(Set{Set{remaining, K}->min() - Set{remaining - K, 0}->max() + 1, 0}->max()) )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var tokens : OclIterator ; tokens := reader.lines()->collect( _x1 | (lambda s : OclAny in s->split(" "))->apply(_x1) )->concatenateAll( _x1 | (lambda _pars : OclAny in Arrays.newArrays().stream(_pars))->apply(_x1) )->iterator() ;
     Solver.INSTANCE.solve(tokens) ))   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class NewClass {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),k=in.nextInt(),arr[]=new int[n],ans=1 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
      if(i>k-1 && arr[i]!=arr[k-1])ans=-1 ;
    }
    if(ans==1){
      int i=k-1 ;
      while(i-->0 && arr[i]==arr[k-1]);
      System.out.println(i+1);
    }
    else System.out.println("-1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,n)->collect(0) ;
    var ans : int ; ans := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() ; 
     if (i > k - 1 & arr[i+1] /= arr[k - 1+1]) then     ans := -1 ; else skip )  ;     i := i + 1 ) ; 
     if (ans = 1) then (     var i : int ; i := k - 1 ;
         while (i > 0 & arr[i+1] = arr[k - 1+1]) do (    skip ;  ;  ) ;  
     OclFile["System.out"].println(i + 1) ) else     OclFile["System.out"].println("-1") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.ArrayList ;
public class codforce {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n-->0){
      int sum_0=0 ;
      int count_1=0 ;
      String str=sc.next();
      for(int i=0 ; i<str.length(); i++){
        if(str.charAt(i)=='0'){
          sum_0++;
        }
        else count_1++;
      }
      if(Math.min(sum_0,count_1)% 2==0){
        System.out.println("NET");
      }
      else System.out.println("DA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codforce {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var sum_0 : int ; sum_0 := 0 ;
     var count    var countint : int ; countint := 0 : int ; count    var countint : int ; countint := 0 := 0 ;
    var str : String ; str := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount        while (n > 0) do (        n := n - 1 ;     skip ; (     var sum_0 : int ; sum_0 := 0 ;
     var count    var countint : int ; countint := 0 : int ; count    var countint : int ; countint := 0 := 0 ;
    var str : String ; str := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 + 1 ; ;  := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 + 1 ; ;  + 1 ; )  ;     i := i + 1 ) ; 
    if (Set{sum_0, countsum_0}->min() mod 2 = 0) then (     OclFile["System.out"].println("NET") ) else     OclFile["System.out"].println("DA") ; ;  
 ) ;  ) ;  := countcountcount        while (n > 0) do (        n := n - 1 ;     skip ; (     var sum_0 : int ; sum_0 := 0 ;
     var count    var countint : int ; countint := 0 : int ; count    var countint : int ; countint := 0 := 0 ;
    var str : String ; str := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 + 1 ; ;  := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 + 1 ; ;  + 1 ; )  ;     i := i + 1 ) ; 
    if (Set{sum_0, countsum_0}->min() mod 2 = 0) then (     OclFile["System.out"].println("NET") ) else     OclFile["System.out"].println("DA") ; ;  
 ) ;  ) ;  + 1 ; ;  
 := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount        while (n > 0) do (        n := n - 1 ;     skip ; (     var sum_0 : int ; sum_0 := 0 ;
     var count    var countint : int ; countint := 0 : int ; count    var countint : int ; countint := 0 := 0 ;
    var str : String ; str := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 + 1 ; ;  := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 + 1 ; ;  + 1 ; )  ;     i := i + 1 ) ; 
    if (Set{sum_0, countsum_0}->min() mod 2 = 0) then (     OclFile["System.out"].println("NET") ) else     OclFile["System.out"].println("DA") ; ;  
 ) ;  ) ;  := countcountcount        while (n > 0) do (        n := n - 1 ;     skip ; (     var sum_0 : int ; sum_0 := 0 ;
     var count    var countint : int ; countint := 0 : int ; count    var countint : int ; countint := 0 := 0 ;
    var str : String ; str := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 + 1 ; ;  := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 + 1 ; ;  + 1 ; )  ;     i := i + 1 ) ; 
    if (Set{sum_0, countsum_0}->min() mod 2 = 0) then (     OclFile["System.out"].println("NET") ) else     OclFile["System.out"].println("DA") ; ;  
 ) ;  ) ;  + 1 ; ;  
 + 1 ; ;  := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount        while (n > 0) do (        n := n - 1 ;     skip ; (     var sum_0 : int ; sum_0 := 0 ;
     var count    var countint : int ; countint := 0 : int ; count    var countint : int ; countint := 0 := 0 ;
    var str : String ; str := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 + 1 ; ;  := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 + 1 ; ;  + 1 ; )  ;     i := i + 1 ) ; 
    if (Set{sum_0, countsum_0}->min() mod 2 = 0) then (     OclFile["System.out"].println("NET") ) else     OclFile["System.out"].println("DA") ; ;  
 ) ;  ) ;  := countcountcount        while (n > 0) do (        n := n - 1 ;     skip ; (     var sum_0 : int ; sum_0 := 0 ;
     var count    var countint : int ; countint := 0 : int ; count    var countint : int ; countint := 0 := 0 ;
    var str : String ; str := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 + 1 ; ;  := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 + 1 ; ;  + 1 ; )  ;     i := i + 1 ) ; 
    if (Set{sum_0, countsum_0}->min() mod 2 = 0) then (     OclFile["System.out"].println("NET") ) else     OclFile["System.out"].println("DA") ; ;  
 ) ;  ) ;  + 1 ; ;  
 := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount        while (n > 0) do (        n := n - 1 ;     skip ; (     var sum_0 : int ; sum_0 := 0 ;
     var count    var countint : int ; countint := 0 : int ; count    var countint : int ; countint := 0 := 0 ;
    var str : String ; str := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 + 1 ; ;  := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 + 1 ; ;  + 1 ; )  ;     i := i + 1 ) ; 
    if (Set{sum_0, countsum_0}->min() mod 2 = 0) then (     OclFile["System.out"].println("NET") ) else     OclFile["System.out"].println("DA") ; ;  
 ) ;  ) ;  := countcountcount        while (n > 0) do (        n := n - 1 ;     skip ; (     var sum_0 : int ; sum_0 := 0 ;
     var count    var countint : int ; countint := 0 : int ; count    var countint : int ; countint := 0 := 0 ;
    var str : String ; str := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 + 1 ; ;  := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 := countcountcount    if (str->at(i+1) = '0') then (     sum_0 := sum_0 + 1 ) else     countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 := countcountcount    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 + 1 ; ;  
 + 1 ; ;  + 1 ; )  ;     i := i + 1 ) ; 
    if (Set{sum_0, countsum_0}->min() mod 2 = 0) then (     OclFile["System.out"].println("NET") ) else     OclFile["System.out"].println("DA") ; ;  
 ) ;  ) ;  + 1 ; ;  
 + 1 ; ;  + 1 ; )  ;     i := i + 1 ) ; 
    if (Set{sum_0, countsum_0}->min() mod 2 = 0) then (     OclFile["System.out"].println("NET") ) else     OclFile["System.out"].println("DA") ; ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String...args){
    try(Scanner sc=new Scanner(System.in)){
      final int K=sc.nextInt();
      final int S=sc.nextInt();
      int count=0 ;
      for(int X=0 ; X<=K ; X++){
        for(int Y=0 ; Y<=K ; Y++){
          if(X+Y>S)break ;
          if(S-X-Y<=K)count++;
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var K : int ; K := sc.getCurrent()->toInteger() ;
     var S : int ; S := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var X : int ; X := 0 ; while X <= K do ( (         var Y : int ; Y := 0 ; while Y <= K do ( (     if (X + Y > S) then     break else skip ; 
     if (S - X - Y <= K) then     count := count + 1 ; else skip )  ;     Y := Y + 1 ) )  ;     X := X + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static PrintWriter out ;
  public static FastScanner in ;
  private void solve(){
    int k=in.nextInt();
    int s=in.nextInt();
    int cnt=0 ;
    for(int i=0 ; i<=k ; i++){
      for(int j=0 ; j<=k ; j++){
        int a=s-i-j ;
        if(a<=k && a>=0)cnt++;
      }
    }
    out.print(cnt);
  }
  private void runIO(){
    in=new FastScanner();
    out=new PrintWriter(new BufferedOutputStream(System.out));
    solve();
    out.close();
  }
  private static class FastScanner {
    BufferedReader bufferedReader ;
    StringTokenizer stringTokenizer ;
    private FastScanner(){
      bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    }
    private String next(){
      if(stringTokenizer==null || ! stringTokenizer.hasMoreElements()){
        try {
          stringTokenizer=new StringTokenizer(bufferedReader.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return stringTokenizer.nextToken();
    }
    private int nextInt(){
      return Integer.parseInt(next());
    }
    private long nextLong(){
      return Long.parseLong(next());
    }
    private String nextLine(){
      String ret="" ;
      try {
        ret=bufferedReader.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return ret ;
    }
  }
  public static void main(String[] args){
    new Main().runIO();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute out : OclFile;
  static   attribute in : FastScanner;
   operation solve() : void
  pre: true
  post: true
  activity: (     var k : int ; k := in.nextInt() ;
     var s : int ; s := in.nextInt() ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i <= k do ( (         var j : int ; j := 0 ; while j <= k do ( (     var a : int ; a := s - i - j ;
     if (a <= k & a >= 0) then     cnt := cnt + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation runIO() : void
  pre: true
  post: true
  activity: (     in := FastScanner.newFastScanner() ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
     execute solve() ; 
     skip );
  static class FastScanner {
   attribute bufferedReader : OclFile;
   attribute stringTokenizer : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (stringTokenizer = null or not(stringTokenizer.hasNext())) then (     try (     stringTokenizer := OclIterator.newOclIterator_String(bufferedReader.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) else skip ; 
     return stringTokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var ret : String ; ret := "" ;
     try (     ret := bufferedReader.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return ret );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().runIO() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner scanner=new Scanner(System.in);
    int k=scanner.nextInt()+1 ;
    int s=scanner.nextInt();
    int count=0 ;
    for(int i=0 ; i<k ; i++){
      for(int j=0 ; j<k ; j++){
        int a=s-(i+j);
        if(a<=k-1 && a>=0){
          count++;
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := scanner.getCurrent()->toInteger() + 1 ;
    var s : int ; s := scanner.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < k do ( (         var j : int ; j := 0 ; while j < k do ( (     var a : int ; a := s - (i + j) ;
     if (a <= k - 1 & a >= 0) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p091 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p091().run());
  }
  private static final int LIMIT=50 ;
  public String run(){
    int count=0 ;
    for(int x1=0 ; x1<=LIMIT ; x1++){
      for(int y1=0 ; y1<=LIMIT ; y1++){
        for(int x2=0 ; x2<=LIMIT ; x2++){
          for(int y2=0 ; y2<=LIMIT ; y2++){
            if(y2*x1<y1*x2 && isRightTriangle(x1,y1,x2,y2))count++;
          }
        }
      }
    }
    return Integer.toString(count);
  }
  private static boolean isRightTriangle(int x1,int y1,int x2,int y2){
    int a=x1*x1+y1*y1 ;
    int b=x2*x2+y2*y2 ;
    int c=(x2-x1)*(x2-x1)+(y2-y1)*(y2-y1);
    return a+b==c || b+c==a || c+a==b ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p091 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p091.newp091().run()) );
  static    attribute LIMIT : int := 50;
   operation run() : String
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var x1 : int ; x1 := 0 ; while x1 <= LIMIT do ( (         var y1 : int ; y1 := 0 ; while y1 <= LIMIT do ( (         var x2 : int ; x2 := 0 ; while x2 <= LIMIT do ( (         var y2 : int ; y2 := 0 ; while y2 <= LIMIT do ( (     if (y2 * x1 < y1 * x2 & isRightTriangle(x1, y1, x2, y2)) then     count := count + 1 ; else skip )  ;     y2 := y2 + 1 ) )  ;     x2 := x2 + 1 ) )  ;     y1 := y1 + 1 ) )  ;     x1 := x1 + 1 ) ; 
     return ((count) + "") );
  static   operation isRightTriangle( x1 : int, y1 : int, x2 : int, y2 : int) : boolean
  pre: true
  post: true
  activity: (     var a : int ; a := x1 * x1 + y1 * y1 ;
     var b : int ; b := x2 * x2 + y2 * y2 ;
     var c : int ; c := (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1) ;
     return a + b = c or b + c = a or c + a = b );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=100 ;
  static void permutatedRows(int mat[][],int m,int n,int r){
    LinkedHashSet<Integer>s=new LinkedHashSet<>();
    for(int j=0 ; j<n ; j++)s.add(mat[r][j]);
    for(int i=0 ; i<m ; i++){
      if(i==r)continue ;
      int j ;
      for(j=0 ; j<n ; j++)if(! s.contains(mat[i][j]))break ;
      if(j!=n)continue ;
      System.out.print(i+",");
    }
  }
  public static void main(String[] args){
    int m=4,n=4,r=3 ;
    int mat[][]={
      {
        3,1,4,2 },{
          1,6,9,3 },{
            1,2,3,4 },{
              4,3,2,1 }
            };
            permutatedRows(mat,m,n,r);
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100;
  static   operation permutatedRows( mat : Sequence(Sequence(int)), m : int, n : int, r : int) : void
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
         var j : int ; j := 0 ; while j < n do (     s := s->including(mat[r+1][j+1]) ;  ;     j := j + 1 ) ; 
         var i : int ; i := 0 ; while i < m do ( (     if (i = r) then     continue else skip ; 
     var j : int ;
        j := 0 ; while j < n do (     if (not(s->includes(mat[i+1][j+1]))) then     break else skip ;  ;     j := j + 1 ) ; 
    if (j /= n) then     continue else skip ; 
    OclFile["System.out"].print(i + ",") ; 
 )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 4 ;
    var n : int ; n := 4 ;
    var r : int ; r := 3 ;
     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{3,1,4,2},Sequence{1,6,9,3},Sequence{1,2,3,4},Sequence{4,3,2,1}} ;
     execute permutatedRows(mat, m, n, r) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class Solution {
  public static void main(String[] args){
    boolean debug=false ;
    Scanner input=new Scanner(System.in);
    String s=input.next();
    int count=0 ;
    int currentCount=1 ;
    for(int i=1 ; i<s.length(); i++){
      if(s.charAt(i)==s.charAt(i-1)){
        currentCount++;
        if(i==s.length()-1){
          if(currentCount % 2==0)count++;
        }
      }
      else {
        if(currentCount % 2==0)count++;
        currentCount=1 ;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var debug : boolean ; debug := false ;
     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var s : String ; s := input.getCurrent() ;
    var count : int ; count := 0 ;
    var currentCount : int ; currentCount := 1 ;
        var i : int ; i := 1 ; while i < s->size() do ( (     if (s->at(i+1) = s->at(i - 1+1)) then (     currentCount := currentCount + 1 ; 
     if (i = s->size() - 1) then (     if (currentCount mod 2 = 0) then     count := count + 1 ; else skip ) else skip ) else (     if (currentCount mod 2 = 0) then     count := count + 1 ; else skip ; 
     currentCount := 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Program {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    String str=scn.nextLine();
    int slow=0 ;
    int fast=1 ;
    int count=1 ;
    int ans=0 ;
    while(fast<str.length()){
      char ch=str.charAt(slow);
      char ch1=str.charAt(fast);
      if(ch==ch1){
        count++;
      }
      else {
        if(count % 2==0){
          ans++;
        }
        slow=fast ;
        count=1 ;
      }
      fast++;
    }
    if(count % 2==0){
      ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Program {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := scn.nextLine() ;
    var slow : int ; slow := 0 ;
    var fast : int ; fast := 1 ;
    var count : int ; count := 1 ;
    var ans : int ; ans := 0 ;
    while (fast < str->size()) do (     var ch : String ; ch := str->at(slow+1) ;
     var ch1 : String ; ch1 := str->at(fast+1) ;
     if (ch = ch1) then (     count := count + 1 ) else (     if (count mod 2 = 0) then (     ans := ans + 1 ) else skip ; 
     slow := fast ; 
     count := 1 ) ;  
     fast := fast + 1 ) ; 
    if (count mod 2 = 0) then (     ans := ans + 1 ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.util.StringTokenizer ;
public class GeneticEngineering {
  public static void main(String[] args)throws IOException {
    MyScanner s=new MyScanner();
    Print p=new Print();
    char[] arr=s.nextLine().toCharArray();
    char ch='S' ;
    int count=0 ;
    int ins=0 ;
    for(int i=0 ; i<arr.length ; i++){
      if(ch==arr[i]){
        count++;
      }
      else {
        ch=arr[i];
        if(count!=0 && count % 2==0){
          ins++;
        }
        count=1 ;
      }
    }
    if(count!=0 && count % 2==0){
      ins++;
    }
    p.println(ins);
    p.close();
  }
  static class Print {
    private BufferedWriter bw ;
    public Print(){
      this.bw=new BufferedWriter(new OutputStreamWriter(System.out));
    }
    public void print(Object object)throws IOException {
      bw.append(""+object);
    }
    public void println(Object object)throws IOException {
      print(object);
      bw.append("\n");
    }
    public void close()throws IOException {
      bw.close();
    }
  }
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GeneticEngineering {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : MyScanner ; s := MyScanner.newMyScanner() ;
     var p : Print ; p := Print.newPrint() ;
    var arr : Sequence(String) ; arr := s.nextLine()->characters() ;
    var ch : String ; ch := 'S' ;
    var count : int ; count := 0 ;
    var ins : int ; ins := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (ch = arr[i+1]) then (     count := count + 1 ) else (     ch := arr[i+1] ; 
     if (count /= 0 & count mod 2 = 0) then (     ins := ins + 1 ) else skip ; 
     count := 1 ) )  ;     i := i + 1 ) ; 
    if (count /= 0 & count mod 2 = 0) then (     ins := ins + 1 ) else skip ; 
    p.println(ins) ; 
    p.close() ; 
 );
  static class Print {
   attribute bw : OclFile;
   static operation newPrint() : Print
  pre: true
  post: true
  activity:
  ( var self : Print ;
    self := createPrint();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) );
   operation print( object : OclAny) : void
  pre: true
  post: true
  activity: (     skip );
   operation println( object : OclAny) : void
  pre: true
  post: true
  activity: (     execute print(object) ; 
     skip );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GeneticEngineering {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.nextLine();
    int count=1 ;
    int insert=0 ;
    for(int i=0 ; i<s.length()-1 ; i++){
      if(s.charAt(i)==s.charAt(i+1)){
        count++;
      }
      else {
        if(count % 2==0){
          insert++;
        }
        count=1 ;
      }
    }
    if(count % 2==0)insert++;
    System.out.println(insert);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GeneticEngineering {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.nextLine() ;
    var count : int ; count := 1 ;
    var insert : int ; insert := 0 ;
        var i : int ; i := 0 ; while i < s->size() - 1 do ( (     if (s->at(i+1) = s->at(i + 1+1)) then (     count := count + 1 ) else (     if (count mod 2 = 0) then (     insert := insert + 1 ) else skip ; 
     count := 1 ) )  ;     i := i + 1 ) ; 
    if (count mod 2 = 0) then     insert := insert + 1 ; else skip ; 
    OclFile["System.out"].println(insert) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javafx.util.Pair ;
import java.util.*;
import java.lang.*;
public class solve {
  static Scanner sc ;
  public static void main(String[] args){
    sc=new Scanner(System.in);
    int testCases=1 ;
    while(testCases>0){
      justDoIt();
      testCases--;
    }
  }
  static void justDoIt(){
    int n=sc.nextInt(),k=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    for(int i=k ; i<n ; i++){
      if(arr[i]!=arr[k-1]){
        System.out.println(-1);
        return ;
      }
    }
    int i=k-2 ;
    while(i>=0 && arr[i]==arr[k-1])i--;
    System.out.println(i+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solve {
  static   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var testCases : int ; testCases := 1 ;
     while (testCases > 0) do (     execute justDoIt() ; 
     testCases := testCases - 1 ) );
  static   operation justDoIt() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := k ; while i < n do ( (     if (arr[i+1] /= arr[k - 1+1]) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    var i : int ; i := k - 2 ;
    while (i >= 0 & arr[i+1] = arr[k - 1+1]) do     i := i - 1 ; ; 
    OclFile["System.out"].println(i + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class GeneticEngineering {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.nextLine();
    int i=0,j=1 ;
    int n=str.length();
    int count=1,res=0 ;
    while(i<n && j<n && i<j){
      if(str.charAt(i)==str.charAt(j)){
        count++;
        j++;
      }
      else {
        if(count % 2==0)res++;
        count=1 ;
        i=j ;
        j++;
      }
    }
    if(count % 2==0)res++;
    System.out.print(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GeneticEngineering {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.nextLine() ;
    var i : int ; i := 0 ;
    var j : int ; j := 1 ;
    var n : int ; n := str->size() ;
    var count : int ; count := 1 ;
    var res : int ; res := 0 ;
    while (i < n & j < n & i < j) do (     if (str->at(i+1) = str->at(j+1)) then (     count := count + 1 ; 
     j := j + 1 ) else (     if (count mod 2 = 0) then     res := res + 1 ; else skip ; 
     count := 1 ; 
     i := j ; 
     j := j + 1 ) ) ; 
    if (count mod 2 = 0) then     res := res + 1 ; else skip ; 
    OclFile["System.out"].print(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minOperations(String s,String t,int n){
    int ct0=0,ct1=0 ;
    for(int i=0 ; i<n ; i++){
      if(s.charAt(i)==t.charAt(i))continue ;
      if(s.charAt(i)=='0')ct0++;
      else ct1++;
    }
    return Math.max(ct0,ct1);
  }
  public static void main(String args[]){
    String s="010",t="101" ;
    int n=s.length();
    System.out.println(minOperations(s,t,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minOperations( s : String, t : String, n : int) : int
  pre: true
  post: true
  activity: (     var ct0 : int ; ct0 := 0 ;
    var ct1 : int ; ct1 := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = t->at(i+1)) then     continue else skip ; 
     if (s->at(i+1) = '0') then     ct0 := ct0 + 1 ; else     ct1 := ct1 + 1 ; )  ;     i := i + 1 ) ; 
     return Set{ct0, ct1}->max() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "010" ;
    var t : String ; t := "101" ;
     var n : int ; n := s->size() ;
     OclFile["System.out"].println(minOperations(s, t, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static ArrayList<Integer>allPrimes=new ArrayList<Integer>();
  static void sieve(int n){
    boolean[] prime=new boolean[n+1];
    for(int p=2 ; p*p<=n ; p++){
      if(prime[p]==false){
        for(int i=p*2 ; i<=n ; i+=p)prime[i]=true ;
      }
    }
    for(int p=2 ; p<=n ; p++)if(prime[p]==false)allPrimes.add(p);
  }
  static int factorialDivisors(int n){
    sieve(n);
    int result=1 ;
    for(int i=0 ; i<allPrimes.size(); i++){
      int p=allPrimes.get(i);
      int exp=0 ;
      while(p<=n){
        exp=exp+(n/p);
        p=p*allPrimes.get(i);
      }
      result=result*((int)Math.pow(allPrimes.get(i),exp+1)-1)/(allPrimes.get(i)-1);
    }
    return result ;
  }
  public static void main(String[] args){
    System.out.println(factorialDivisors(4));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute allPrimes : Sequence(int) := Sequence{};
  static   operation sieve( n : int) : void
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,n + 1)->collect(false) ;
         var p : int ; p := 2 ; while p * p <= n do ( (     if (prime[p+1] = false) then (         var i : int ; i := p * 2 ; while i <= n do (     prime[i+1] := true ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
         var p : int ; p := 2 ; while p <= n do (     if (prime[p+1] = false) then     allPrimes := allPrimes->including(p) ; else skip ;  ;     p := p + 1 ) );
  static   operation factorialDivisors( n : int) : int
  pre: true
  post: true
  activity: (     execute sieve(n) ; 
     var result : int ; result := 1 ;
         var i : int ; i := 0 ; while i < allPrimes->size() do ( (     var p : int ; p := allPrimes->at(i+1) ;
     var exp : int ; exp := 0 ;
     while (p <= n) do (     exp := exp + (n / p) ; 
     p := p * allPrimes->at(i+1) ) ; 
     result := result * (allPrimes->at(i+1)->pow(exp + 1)->oclAsType(int) - 1) / (allPrimes->at(i+1) - 1) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(factorialDivisors(4)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Vector<Integer>allPrimes=new Vector<Integer>();
  static void sieve(int n){
    boolean[] prime=new boolean[n+1];
    for(int i=0 ; i<=n ; i++)prime[i]=true ;
    for(int p=2 ; p*p<=n ; p++){
      if(prime[p]==true){
        for(int i=p*2 ; i<=n ; i+=p)prime[i]=false ;
      }
    }
    for(int p=2 ; p<=n ; p++)if(prime[p])allPrimes.add(p);
  }
  static long factorialDivisors(int n){
    sieve(n);
    long result=1 ;
    for(int i=0 ; i<allPrimes.size(); i++){
      long p=allPrimes.get(i);
      long exp=0 ;
      while(p<=n){
        exp=exp+(n/p);
        p=p*allPrimes.get(i);
      }
      result=result*(exp+1);
    }
    return result ;
  }
  public static void main(String[] args){
    System.out.println(factorialDivisors(6));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute allPrimes : Sequence(int) := Sequence{};
  static   operation sieve( n : int) : void
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,n + 1)->collect(false) ;
         var i : int ; i := 0 ; while i <= n do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
         var p : int ; p := 2 ; while p * p <= n do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * 2 ; while i <= n do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
         var p : int ; p := 2 ; while p <= n do (     if (prime[p+1]) then     allPrimes := allPrimes->including(p) ; else skip ;  ;     p := p + 1 ) );
  static   operation factorialDivisors( n : int) : long
  pre: true
  post: true
  activity: (     execute sieve(n) ; 
     var result : long ; result := 1 ;
         var i : int ; i := 0 ; while i < allPrimes->size() do ( (     var p : long ; p := allPrimes->at(i+1) ;
     var exp : long ; exp := 0 ;
     while (p <= n) do (     exp := exp + (n / p) ; 
     p := p * allPrimes->at(i+1) ) ; 
     result := result * (exp + 1) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(factorialDivisors(6)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int pos=0 ;
  static int c=0 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k ;
    int[] pre=new int[n];
    int[] in=new int[n];
    int[] post=new int[n];
    for(int i=0 ; i<n ; i++){
      pre[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      in[i]=sc.nextInt();
    }
    solve(n,pre,in,post);
  }
  static void rec(int n,int l,int r,int[] pre,int[] in,int[] post){
    if(l>=r)return ;
    int cnt=n ;
    int root=pre[pos];
    pos++;
    for(int i=0 ; i<n ; i++){
      if(in[i]==root)cnt=i ;
    }
    rec(n,l,cnt,pre,in,post);
    rec(n,cnt+1,r,pre,in,post);
    post[c]=root ;
    c++;
  }
  static void solve(int n,int[] pre,int[] in,int[] post){
    pos=0 ;
    rec(n,0,n,pre,in,post);
    for(int i=0 ; i<n-1 ; i++){
      System.out.print(post[i]+" ");
    }
    System.out.println(post[n-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute pos : int := 0;
  static   attribute c : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ;
    var pre : Sequence(int) ; pre := Integer.subrange(1,n)->collect(0) ;
    var in : Sequence(int) ; in := Integer.subrange(1,n)->collect(0) ;
    var post : Sequence(int) ; post := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     pre[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     in[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute solve(n, pre, in, post) ; 
 );
  static   operation rec( n : int, l : int, r : int, pre : Sequence(int), in : Sequence(int), post : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (l >= r) then     return else skip ; 
     var cnt : int ; cnt := n ;
    var root : int ; root := pre[pos+1] ;
    pos := pos + 1 ; 
        var i : int ; i := 0 ; while i < n do ( (     if (in[i+1] = root) then     cnt := i ; else skip )  ;     i := i + 1 ) ; 
    execute rec(n, l, cnt, pre, in, post) ; 
    execute rec(n, cnt + 1, r, pre, in, post) ; 
    post[c+1] := root ; 
    c := c + 1 ; 
 );
  static   operation solve( n : int, pre : Sequence(int), in : Sequence(int), post : Sequence(int)) : void
  pre: true
  post: true
  activity: (     pos := 0 ; 
     execute rec(n, 0, n, pre, in, post) ; 
         var i : int ; i := 0 ; while i < n - 1 do ( (     OclFile["System.out"].print(post[i+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(post[n - 1+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  static StringBuilder sb=new StringBuilder("");
  static int index=0 ;
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] preorder=new int[n];
    int[] inorder=new int[n];
    for(int i=0 ; i<n ; i++){
      preorder[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      inorder[i]=sc.nextInt();
    }
    Node[] nodes=new Node[n];
    reconstruct(nodes,preorder,inorder,0,n);
    sb.deleteCharAt(0);
    System.out.println(sb);
  }
  public static int reconstruct(Node[] nodes,int[] preorder,int[] inorder,int right,int left){
    if(left==right)return-1 ;
    int root=0 ;
    outside : for(int i=0 ;
    i<preorder.length ;
    i++){
      for(int j=right ; j<left ; j++){
        if(preorder[i]==inorder[j]){
          root=j ;
          break outside ;
        }
      }
    }
    int tempIndex=index ;
    index++;
    nodes[tempIndex]=new Node(inorder[root],-1,-1);
    nodes[tempIndex] .left=reconstruct(nodes,preorder,inorder,right,root);
    nodes[tempIndex] .right=reconstruct(nodes,preorder,inorder,root+1,left);
    sb.append(" ").append(nodes[tempIndex] .id);
    return tempIndex ;
  }
}
class Node {
  public int id ;
  public int left ;
  public int right ;
  public Node(int id,int left,int right){
    this.id=id ;
    this.left=left ;
    this.right=right ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sb : String := StringLib.newString("");
  static   attribute index : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var preorder : Sequence(int) ; preorder := Integer.subrange(1,n)->collect(0) ;
    var inorder : Sequence(int) ; inorder := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     preorder[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     inorder[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var nodes : Sequence(Node) ; nodes := Integer.subrange(1,n)->collect(null) ;
    execute reconstruct(nodes, preorder, inorder, 0, n) ; 
    sb := sb->excludingAt(0+1) ; 
    OclFile["System.out"].println(sb) ; 
 );
  static   operation reconstruct( nodes : Sequence(Node), preorder : Sequence(int), inorder : Sequence(int), right : int, left : int) : int
  pre: true
  post: true
  activity: (     if (left = right) then     return -1 else skip ; 
     var root : int ; root := 0 ;
        var i : int ; i := 0 ; while i < preorder->size() do ( (         var j : int ; j := right ; while j < left do ( (     if (preorder[i+1] = inorder[j+1]) then (     root := j ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var tempIndex : int ; tempIndex := index ;
    index := index + 1 ; 
    nodes[tempIndex+1] := Node.newNode(inorder[root+1], -1, -1) ; 
    nodes[tempIndex+1].left := reconstruct(nodes, preorder, inorder, right, root) ; 
    nodes[tempIndex+1].right := reconstruct(nodes, preorder, inorder, root + 1, left) ; 
    sb := sb + StringLib.newString(" ") + StringLib.newString(nodes[tempIndex+1].id) ; 
    return tempIndex 
 );
}
class Node {
   attribute id : int;
   attribute left : int;
   attribute right : int;
   static operation newNode( id : int, left : int, right : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(id, left,right);
    return self );
  operation initialise( id : int, left : int, right : int) : void
  pre: true  post: true
  activity: (     self.id := id ; 
     self.left := left ; 
     self.right := right );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int n,pos ;
  static ArrayList<Integer>preorder=new ArrayList<Integer>();
  static ArrayList<Integer>inorder=new ArrayList<Integer>();
  public static BinaryTree reconstruction(int l,int r){
    if(l>=r){
      return new BinaryTree();
    }
    int node=preorder.get(pos++);
    int i=inorder.indexOf(node);
    BinaryTree left=reconstruction(l,i);
    BinaryTree right=reconstruction(i+1,r);
    return new BinaryTree(node,left,right);
  }
  public static void read(){
    n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      preorder.add(sc.nextInt());
    }
    for(int i=0 ; i<n ; i++){
      inorder.add(sc.nextInt());
    }
  }
  public static void main(String[] args){
    read();
    pos=0 ;
    BinaryTree bt=reconstruction(0,preorder.size());
    System.out.println(bt);
  }
  public static class BinaryTree {
    boolean isEmpty ;
    int node ;
    BinaryTree left ;
    BinaryTree right ;
    public BinaryTree(int node,BinaryTree left,BinaryTree right){
      this.isEmpty=false ;
      this.node=node ;
      this.left=left ;
      this.right=right ;
    }
    public BinaryTree(){
      this.isEmpty=true ;
    }
    public String toString(){
      if(this.isEmpty)return "" ;
      String l=this.left.toString()+" " ;
      String r=this.right.toString()+" " ;
      if(l.trim().equals("")){
        l="" ;
      }
      if(r.trim().equals("")){
        r="" ;
      }
      return l+r+this.node ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   attribute preorder : Sequence(int) := Sequence{};
  static   attribute inorder : Sequence(int) := Sequence{};
  static   operation reconstruction( l : int, r : int) : BinaryTree
  pre: true
  post: true
  activity: (     if (l >= r) then (     return BinaryTree.newBinaryTree() ) else skip ; 
     var node : int ; node := preorder->at(pos+1) ;
    var i : int ; i := inorder->indexOf(node)-1 ;
    var left : BinaryTree ; left := reconstruction(l, i) ;
    var right : BinaryTree ; right := reconstruction(i + 1, r) ;
    return BinaryTree.newBinaryTree(node, left, right) 
 );
  static   operation read() : void
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
         var i : int ; i := 0 ; while i < n do ( (     preorder := preorder->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n do ( (     inorder := inorder->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute read() ; 
     pos := 0 ; 
     var bt : BinaryTree ; bt := reconstruction(0, preorder->size()) ;
     OclFile["System.out"].println(bt) );
  static class BinaryTree {
   attribute isEmpty : boolean;
   attribute node : int;
   attribute left : BinaryTree;
   attribute right : BinaryTree;
   static operation newBinaryTree( node : int, left : BinaryTree, right : BinaryTree) : BinaryTree
  pre: true
  post: true
  activity:
  ( var self : BinaryTree ;
    self := createBinaryTree();
    self.initialise(node, left,right);
    return self );
  operation initialise( node : int, left : BinaryTree, right : BinaryTree) : void
  pre: true  post: true
  activity: (     self.isEmpty := false ; 
     self.node := node ; 
     self.left := left ; 
     self.right := right );
   static operation newBinaryTree() : BinaryTree
  pre: true
  post: true
  activity:
  ( var self : BinaryTree ;
    self := createBinaryTree();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.isEmpty := true );
   operation toString() : String
  pre: true
  post: true
  activity: (     if (self.isEmpty) then     return "" else skip ; 
     var l : String ; l := self.left+"" + " " ;
    var r : String ; r := self.right+"" + " " ;
    if (l->trim() = "") then (     l := "" ) else skip ; 
    if (r->trim() = "") then (     r := "" ) else skip ; 
    return l + r + self.node 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    boolean go=true ;
    int[] stat=new int[6];
    for(int i=0 ; i<n ; i++){
      int input=in.nextInt();
      if(input==7 || input==5){
        go=false ;
        break ;
      }
      else {
        stat[input-1]++;
      }
    }
    if(go){
      if(stat[0]==n/3 && stat[1]+stat[2]==stat[3]+stat[5] && stat[2]<=stat[5]){
        for(int i=0 ; i<stat[2]; i++){
          System.out.print("1 3 6 ");
        }
        stat[5]-=stat[2];
        for(int i=0 ; i<stat[5]; i++){
          System.out.print("1 2 6 ");
        }
        for(int i=0 ; i<stat[3]; i++){
          System.out.print("1 2 4 ");
        }
      }
      else {
        System.out.println(-1);
      }
    }
    else {
      System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var go : boolean ; go := true ;
    var stat : Sequence(int) ; stat := Integer.subrange(1,6)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var input : int ; input := in.getCurrent()->toInteger() ;
     if (input = 7 or input = 5) then (     go := false ; 
     break ) else (     stat[input - 1+1] := stat[input - 1+1] + 1 ) )  ;     i := i + 1 ) ; 
    if (go) then (     if (stat[0+1] = n / 3 & stat[1+1] + stat[2+1] = stat[3+1] + stat[5+1] & stat[2+1] <= stat[5+1]) then (         var i : int ; i := 0 ; while i < stat[2+1] do ( (     OclFile["System.out"].print("1 3 6 ") )  ;     i := i + 1 ) ; 
     stat[5+1] := stat[5+1]-(stat[2+1]) ; 
         var i : int ; i := 0 ; while i < stat[5+1] do ( (     OclFile["System.out"].print("1 2 6 ") )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < stat[3+1] do ( (     OclFile["System.out"].print("1 2 4 ") )  ;     i := i + 1 ) ) else (     OclFile["System.out"].println(-1) ) ) else (     OclFile["System.out"].println(-1) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),k=in.nextInt(),l=0,c=1 ;
    for(int i=0 ; i<n ; i++){
      int a=in.nextInt();
      if(a==l)c+=1 ;
      else c=1 ;
      l=a ;
    }
    if(c+k>n)System.out.println(n-c);
    else System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var l : int ; l := 0 ;
    var c : int ; c := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     if (a = l) then     c := c+(1) else     c := 1 ; ;  
     l := a )  ;     i := i + 1 ) ; 
     if (c + k > n) then     OclFile["System.out"].println(n - c) ; else     OclFile["System.out"].println(-1) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int k=Integer.parseInt(sc.next());
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(sc.next());
    }
    int[] b=new int[n];
    for(int i=0 ; i<n-1 ; i++){
      b[i+1]=(a[i]<a[i+1])? 1 : 0 ;
      b[i+1]+=b[i];
    }
    TreeSet<Integer>set=new TreeSet<>();
    for(int i=0 ; i<k ; i++){
      set.add(a[i]);
    }
    int ct=(b[k-1]==k-1)? 1 : 0 ;
    int ans=ct ^ 1 ;
    for(int i=k ; i<n ; i++){
      set.add(a[i]);
      boolean ok=(set.first()!=a[i-k])||(set.last()!=a[i]);
      set.remove(a[i-k]);
      if(b[i]-b[i-k+1]==k-1){
        ct=1 ;
      }
      else if(ok){
        ans++;
      }
    }
    System.out.println(ans+ct);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var k : int ; k := (sc.getCurrent())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     b[i + 1+1] := if (a[i+1] < a[i + 1+1]) then 1 else 0 endif ; 
     b[i + 1+1] := b[i + 1+1]+(b[i+1]) )  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < k do ( (     set := set->including(a[i+1]) )  ;     i := i + 1 ) ; 
    var ct : int ; ct := if (b[k - 1+1] = k - 1) then 1 else 0 endif ;
    var ans : int ; ans := MathLib.bitwiseXor(ct,1) ;
        var i : int ; i := k ; while i < n do ( (     set := set->including(a[i+1]) ; 
     var ok : boolean ; ok := (set->first() /= a[i - k+1]) or (set->last() /= a[i+1]) ;
     set := set->excludingFirst(a[i - k+1]) ; 
     if (b[i+1] - b[i - k + 1+1] = k - 1) then (     ct := 1 ) else     if (ok) then (     ans := ans + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans + ct) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    solve(System.in,System.out);
  }
  static void solve(InputStream is,PrintStream os){
    Scanner sc=new Scanner(is);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    SortedSet<Integer>set=new TreeSet<>();
    Set<Integer>orderedIndexes=new HashSet<>();
    int l=0 ;
    int r=1 ;
    for(l=0 ; l<n ; l++){
      if(l==r)r++;
      while(r<n && a[r-1]<a[r])r++;
      if(k==r-l)orderedIndexes.add(l);
    }
    for(int i=0 ; i<k ; i++){
      set.add(a[i]);
    }
    int res=n-k+1 ;
    for(int i=0 ; i<n-k ; i++){
      int min=set.first();
      int max=set.last();
      set.remove(a[i]);
      set.add(a[i+k]);
      if(min==a[i] && max<a[i+k])res--;
    }
    if(orderedIndexes.size()>1){
      res-=orderedIndexes.size()-1 ;
    }
    os.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation solve( is : OclFile, os : OclFile) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(is) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
    var orderedIndexes : Set(int) ; orderedIndexes := Set{} ;
    var l : int ; l := 0 ;
    var r : int ; r := 1 ;
        l := 0 ; while l < n do ( (     if (l = r) then     r := r + 1 ; else skip ; 
     while (r < n & a[r - 1+1] < a[r+1]) do     r := r + 1 ; ; 
     if (k = r - l) then     orderedIndexes := orderedIndexes->including(l) ; else skip )  ;     l := l + 1 ) ; 
        var i : int ; i := 0 ; while i < k do ( (     set := set->including(a[i+1]) )  ;     i := i + 1 ) ; 
    var res : int ; res := n - k + 1 ;
        var i : int ; i := 0 ; while i < n - k do ( (     var min : int ; min := set->first() ;
     var max : int ; max := set->last() ;
    set := set->excludingFirst(a[i+1]) ; 
    set := set->including(a[i + k+1]) ; 
    if (min = a[i+1] & max < a[i + k+1]) then     res := res - 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
    if (orderedIndexes->size() > 1) then (     res := res-(orderedIndexes->size() - 1) ) else skip ; 
    os.println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] ans=new int[5];
    for(int i=0 ; i<5 ; i++)ans[i]=sc.nextInt();
    Arrays.sort(ans);
    for(int j=4 ; j>=0 ; j--){
      if(j!=0){
        System.out.print(ans[j]+" ");
      }
      else {
        System.out.println(ans[j]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ans : Sequence(int) ; ans := Integer.subrange(1,5)->collect(0) ;
        var i : int ; i := 0 ; while i < 5 do (     ans[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    ans := ans->sort() ; 
        var j : int ; j := 4 ; while j >= 0 do ( (     if (j /= 0) then (     OclFile["System.out"].print(ans[j+1] + " ") ) else (     OclFile["System.out"].println(ans[j+1]) ) )  ;     j := j - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  public static void main(String omkar[])throws Exception {
    BufferedReader infile=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(infile.readLine());
    int N=Integer.parseInt(st.nextToken());
    int K=Integer.parseInt(st.nextToken());
    int[] arr=new int[N];
    st=new StringTokenizer(infile.readLine());
    for(int i=0 ; i<N ; i++)arr[i]=Integer.parseInt(st.nextToken());
    int res=1 ;
    int[] dp=new int[N];
    dp[0]=1 ;
    for(int i=1 ; i<N ; i++){
      if(arr[i]>arr[i-1])dp[i]=dp[i-1]+1 ;
      else dp[i]=1 ;
    }
    TreeSet<Integer>curr=new TreeSet<Integer>();
    for(int i=0 ; i<K ; i++)curr.add(arr[i]);
    boolean yeet=dp[K-1]>=K ;
    if(yeet)res--;
    for(int i=1 ; i<N-K+1 ; i++){
      int right=arr[K-1+i];
      int left=arr[i-1];
      if((curr.first()!=left || curr.last()>right)&& dp[K-1+i]<K)res++;
      else if(dp[K-1+i]>=K)yeet=true ;
      curr.remove(left);
      curr.add(right);
    }
    if(yeet)res++;
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( omkar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var infile : OclFile ; infile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(infile.readLine()) ;
    var N : int ; N := (st.next())->toInteger() ;
    var K : int ; K := (st.next())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
    st := OclIterator.newOclIterator_String(infile.readLine()) ; 
        var i : int ; i := 0 ; while i < N do (     arr[i+1] := (st.next())->toInteger() ;  ;     i := i + 1 ) ; 
    var res : int ; res := 1 ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,N)->collect(0) ;
    dp[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < N do ( (     if (arr[i+1] > arr[i - 1+1]) then     dp[i+1] := dp[i - 1+1] + 1 ; else     dp[i+1] := 1 ; )  ;     i := i + 1 ) ; 
    var curr : Set(int) ; curr := Set{} ;
        var i : int ; i := 0 ; while i < K do (     curr := curr->including(arr[i+1]) ;  ;     i := i + 1 ) ; 
    var yeet : boolean ; yeet := dp[K - 1+1] >= K ;
    if (yeet) then     res := res - 1 ; else skip ; 
        var i : int ; i := 1 ; while i < N - K + 1 do ( (     var right : int ; right := arr[K - 1 + i+1] ;
     var left : int ; left := arr[i - 1+1] ;
    if ((curr->first() /= left or curr->last() > right) & dp[K - 1 + i+1] < K) then     res := res + 1 else     if (dp[K - 1 + i+1] >= K) then     yeet := true ; else skip ; ;  
    curr := curr->excludingAt(left+1) ; 
    curr := curr->including(right) ; 
 )  ;     i := i + 1 ) ; 
    if (yeet) then     res := res + 1 ; else skip ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    String[] s=br.readLine().split(" ");
    int n=Integer.parseInt(s[0]);
    int k=Integer.parseInt(s[1]);
    s=br.readLine().split(" ");
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(s[i]);
    }
    TreeSet<Integer>window=new TreeSet<>();
    int tail=1 ;
    boolean noChangeSeen=false ;
    for(int i=0 ; i<k ; i++){
      window.add(arr[i]);
    }
    for(int i=k-1 ; i>0 ; i--){
      if(arr[i]>arr[i-1]){
        tail++;
      }
      else {
        break ;
      }
    }
    if(tail==k){
      noChangeSeen=true ;
    }
    int count=1 ;
    for(int i=k ; i<n ; i++){
      if(arr[i]>arr[i-1]){
        if(tail<k){
          tail++;
        }
      }
      else {
        tail=1 ;
      }
      if(tail==k && ! noChangeSeen){
        count++;
        noChangeSeen=true ;
      }
      if(tail!=k){
        if(!(arr[i]>window.last()&& arr[i-k]==window.first())){
          count++;
        }
      }
      window.remove(arr[i-k]);
      window.add(arr[i]);
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var s : Sequence(String) ; s := br.readLine()->split(" ") ;
    var n : int ; n := (s[0+1])->toInteger() ;
    var k : int ; k := (s[1+1])->toInteger() ;
    s := br.readLine()->split(" ") ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (s[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var window : Set(int) ; window := Set{} ;
    var tail : int ; tail := 1 ;
    var noChangeSeen : boolean ; noChangeSeen := false ;
        var i : int ; i := 0 ; while i < k do ( (     window := window->including(arr[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := k - 1 ; while i > 0 do ( (     if (arr[i+1] > arr[i - 1+1]) then (     tail := tail + 1 ) else (     break ) )  ;     i := i - 1 ) ; 
    if (tail = k) then (     noChangeSeen := true ) else skip ; 
    var count : int ; count := 1 ;
        var i : int ; i := k ; while i < n do ( (     if (arr[i+1] > arr[i - 1+1]) then (     if (tail < k) then (     tail := tail + 1 ) else skip ) else (     tail := 1 ) ;  
     if (tail = k & not(noChangeSeen)) then (     count := count + 1 ; 
     noChangeSeen := true ) else skip ; 
    if (tail /= k) then (     if (not((arr[i+1] > window->last() & arr[i - k+1] = window->first()))) then (     count := count + 1 ) else skip ) else skip ; 
    window := window->excludingFirst(arr[i - k+1]) ; 
    window := window->including(arr[i+1]) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  static Scanner scanner=new Scanner();
  static long mod=1000000007 ;
  public static void main(String[] $){
    int n=scanner.nextInt();
    int k=scanner.nextInt();
    int[] a=new int[n];
    TreeSet<Integer>set=new TreeSet<>();
    for(int i=0 ; i<n ; i++){
      a[i]=scanner.nextInt();
      if(i<=k){
        set.add(a[i]);
      }
    }
    int count=0 ;
    int c=0 ;
    for(int i=1 ; i<n ; i++){
      if(a[i-1]<a[i]){
        c++;
      }
      else {
        if(c>=k-1){
          count++;
        }
        c=0 ;
      }
    }
    if(c>=k-1){
      count++;
    }
    if(count>0){
      count--;
    }
    if(n!=k){
      for(int i=k+1 ; i<=n ; i++){
        if(set.first().equals(a[i-k-1])&& set.last().equals(a[i-1])){
          count++;
        }
        if(i<n){
          set.remove(a[i-k-1]);
          set.add(a[i]);
        }
      }
    }
    System.out.println(n-k+1-count);
  }
  static class Scanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),1<<15);
    StringTokenizer tokenizer ;
    String next(){
      try {
        while(tokenizer==null || ! tokenizer.hasMoreTokens()){
          tokenizer=new StringTokenizer(reader.readLine());
        }
      }
      catch(IOException ignored){
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := (arguments ( ));
  static   attribute mod : long := 1000000007;
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var k : int ; k := scanner.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() ; 
     if (i <= k) then (     set := set->including(a[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var c : int ; c := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i - 1+1] < a[i+1]) then (     c := c + 1 ) else (     if (c >= k - 1) then (     count := count + 1 ) else skip ; 
     c := 0 ) )  ;     i := i + 1 ) ; 
    if (c >= k - 1) then (     count := count + 1 ) else skip ; 
    if (count > 0) then (     count := count - 1 ) else skip ; 
    if (n /= k) then (         var i : int ; i := k + 1 ; while i <= n do ( (     if (set->first() = a[i - k - 1+1] & set->last() = a[i - 1+1]) then (     count := count + 1 ) else skip ; 
     if (i < n) then (     set := set->excludingFirst(a[i - k - 1+1]) ; 
     set := set->including(a[i+1]) ) else skip )  ;     i := i + 1 ) ) else skip ; 
    OclFile["System.out"].println(n - k + 1 - count) ; 
 );
  static class Scanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), (1*(2->pow(15)))->oclAsType(long));
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (ignored : IOException) do skip
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    String lis[]={
      "","Man","Oku","Cho","Kei","Gai","Jo","Jou","Ko","Kan","Sei","Sai","Gok","Ggs","Asg","Nyt","Fks","Mts" };
      BigInteger[] val=new BigInteger[18];
      val[0]=BigInteger.ONE ;
      for(int i=1 ; i<18 ; i++)val[i]=val[i-1] .multiply(new BigInteger("10000"));
      Scanner s=new Scanner(System.in);
      while(true){
        BigInteger a=s.nextBigInteger();
        int b=s.nextInt();
        if(b==0){
          break ;
        }
        BigInteger ret=BigInteger.ONE ;
        for(int i=0 ; i<b ; i++)ret=ret.multiply(a);
        for(int i=17 ; i>=0 ; i--){
          BigInteger ks=ret.divide(val[i]);
          ret=ret.remainder(val[i]);
          if(! ks.equals(BigInteger.ZERO))System.out.print(ks.toString()+lis[i]);
        }
        System.out.println();
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var lis : Sequence(String) ; lis := Sequence{"","Man","Oku","Cho","Kei","Gai","Jo","Jou","Ko","Kan","Sei","Sai","Gok","Ggs","Asg","Nyt","Fks","Mts"} ;
     var val : Sequence(long) ; val := Integer.subrange(1,18)->collect(null) ;
    val[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < 18 do (     val[i+1] := val[i - 1+1].multiply(long("10000")) ;  ;     i := i + 1 ) ; 
    var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    while (true) do (     var a : long ; a := s.nextBigInteger() ;
     var b : int ; b := s.getCurrent()->toInteger() ;
    if (b = 0) then (     break ) else skip ; 
    var ret : long ; ret := 1 ;
        var i : int ; i := 0 ; while i < b do (     ret := ret.multiply(a) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 17 ; while i >= 0 do ( (     var ks : long ; ks := ret.divide(val[i+1]) ;
     ret := ret.remainder(val[i+1]) ; 
     if (not(ks = 0)) then     OclFile["System.out"].print(ks+"" + lis[i+1]) ; else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.math.BigInteger ;
import java.util.Deque ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      String a=scanner.next();
      int b=scanner.nextInt();
      if(a.equals("0")&& b==0)break ;
      BigInteger big=new BigInteger(a).pow(b);
      Deque<String>ans=new LinkedList<String>();
      String an=big.mod(man).toString();
      if(! an.equals("0"))ans.push(an);
      big=big.divide(man);
      for(String s : list){
        an=big.mod(man).toString();
        if(! an.equals("0"))ans.push(an+s);
        big=big.divide(man);
        if(big.equals(BigInteger.ZERO))break ;
      }
      while(! ans.isEmpty()){
        System.out.print(ans.poll());
      }
      System.out.println();
    }
  }
  BigInteger man=new BigInteger("10000");
  String[] list={
    "Man","Oku","Cho","Kei","Gai","Jo","Jou","Ko","Kan","Sei","Sai","Gok","Ggs","Asg","Nyt","Fks","Mts" };
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var a : String ; a := scanner.getCurrent() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
    if (a = "0" & b = 0) then     break else skip ; 
    var big : long ; big := long(a).pow(b) ;
    var ans : Sequence(String) ; ans := Sequence{} ;
    var an : String ; an := big.mod(man)+"" ;
    if (not(an = "0")) then     ans := ans->append(an) ; else skip ; 
    big := big.divide(man) ; 
    for (s : list) do ( (     an := big.mod(man)+"" ; 
     if (not(an = "0")) then     ans := ans->append(an + s) ; else skip ; 
     big := big.divide(man) ; 
     if (big = 0) then     break else skip )  ) ; 
    while (not(ans->isEmpty())) do (     OclFile["System.out"].print(ans->min()) ) ; 
    OclFile["System.out"].println() ; 
 ) );
   attribute man : long := long("10000");
   attribute list : Sequence(String) := Sequence{"Man","Oku","Cho","Kei","Gai","Jo","Jou","Ko","Kan","Sei","Sai","Gok","Ggs","Asg","Nyt","Fks","Mts"};
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
class Main {
  public static void main(String[] args){
    Solve s=new Solve();
    s.solve();
  }
}
class Solve {
  Solve(){
  }
  Scanner in=new Scanner(System.in);
  void solve(){
    String[] k={
      "Mts","Fks","Nyt","Asg","Ggs","Gok","Sai","Sei","Kan","Ko","Jou","Jo","Gai","Kei","Cho","Oku","Man","" };
      BigInteger zero=new BigInteger("0");
      while(in.hasNext()){
        String s=in.next();
        int n=in.nextInt();
        if(s.equals("0")&& n==0)return ;
        BigInteger m=new BigInteger(s);
        m=m.pow(n);
        s=new String(m.toString());
        int d=(s.length()-1)/4,a=s.length()% 4 ;
        StringBuilder temp=new StringBuilder();
        StringBuilder ans=new StringBuilder();
        for(int i=0 ; i<s.length(); i++){
          temp.append(s.charAt(i));
          if((i!=0 &&(i-a)% 4==3)||(i<a && i==a-1)){
            while(temp.length()>0 && temp.charAt(0)=='0'){
              temp.deleteCharAt(0);
            }
            if(temp.length()>0){
              ans.append(temp.toString()+k[k.length-1-d+i/4]);
            }
            temp=new StringBuilder();
          }
        }
        System.out.println(ans.toString());
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Solve ; s := Solve.newSolve() ;
     s.solve() );
}
class Solve {
   static operation newSolve() : Solve
  pre: true
  post: true
  activity:
  ( var self : Solve ;
    self := createSolve();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation solve() : void
  pre: true
  post: true
  activity: (     var k : Sequence(String) ; k := Sequence{"Mts","Fks","Nyt","Asg","Ggs","Gok","Sai","Sei","Kan","Ko","Jou","Jo","Gai","Kei","Cho","Oku","Man",""} ;
     var zero : long ; zero := long("0") ;
     while (in.hasNext()) do (     var s : String ; s := in.getCurrent() ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    if (s = "0" & n = 0) then     return else skip ; 
    var m : long ; m := long(s) ;
    m := m.pow(n) ; 
    s := StringLib.newString(m+"") ; 
    var d : int ; d := (s->size() - 1) / 4 ;
    var a : int ; a := s->size() mod 4 ;
    var temp : String ; temp := StringLib.newString() ;
    var ans : String ; ans := StringLib.newString() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     temp := temp + StringLib.newString(s->at(i+1)) ; 
     if ((i /= 0 & ((i)->char2byte() - a) mod 4 = 3) or (i < a & i = a - 1)) then (     while (temp->size() > 0 & temp->at(0+1) = '0') do (     temp := temp->excludingAt(0+1) ) ; 
     if (temp->size() > 0) then (     ans := ans + StringLib.newString(temp+"" + k[k->size() - 1 - d + i / 4+1]) ) else skip ; 
     temp := StringLib.newString() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans+"") ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class Main {
  static final String[] unit={
    "","Man","Oku","Cho","Kei","Gai","Jo","Jou","Ko","Kan","Sei","Sai","Gok","Ggs","Asg","Nyt","Fks","Mts" };
    public static void main(String[] args)throws IOException {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      PrintWriter pw=new PrintWriter(System.out);
      for(; ; ){
        String[] str=br.readLine().split(" ");
        int m=Integer.parseInt(str[0]);
        int n=Integer.parseInt(str[1]);
        if(m==0 && n==0)break ;
        BigInteger num=BigInteger.ONE ;
        for(int i=0 ; i<n ; i++){
          num=num.multiply(BigInteger.valueOf(m));
        }
        String res=new String();
        for(int i=0 ; i<unit.length ; i++){
          BigInteger rem=num.remainder(BigInteger.valueOf(10000));
          num=num.divide(BigInteger.valueOf(10000));
          if(rem.compareTo(BigInteger.ZERO)==0)continue ;
          res=rem.toString()+unit[i]+res ;
        }
        pw.println(res);
      }
      pw.close();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute unit : Sequence(String) := Sequence{"","Man","Oku","Cho","Kei","Gai","Jo","Jou","Ko","Kan","Sei","Sai","Gok","Ggs","Asg","Nyt","Fks","Mts"};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
       while true do ( (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     var m : int ; m := (str[0+1])->toInteger() ;
    var n : int ; n := (str[1+1])->toInteger() ;
    if (m = 0 & n = 0) then     break else skip ; 
    var num : long ; num := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     num := num.multiply((m + "")->toLong()) )  ;     i := i + 1 ) ; 
    var res : String ; res := StringLib.newString() ;
        var i : int ; i := 0 ; while i < unit->size() do ( (     var rem : long ; rem := num.remainder((10000 + "")->toLong()) ;
     num := num.divide((10000 + "")->toLong()) ; 
     if (rem->compareTo(0) = 0) then     continue else skip ; 
     res := rem+"" + unit[i+1] + res )  ;     i := i + 1 ) ; 
    skip ; 
 )  ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static final int MOD=(int)1e9+7 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int[] a=new int[n];
    ModLcm ml=new ModLcm((int)1e6+6);
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(sc.next());
      ml.lcm(a[i]);
    }
    int lcm=ml.getModLcm(MOD);
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      long inv=ModLcm.mod_pow(a[i],MOD-2,MOD);
      ans+=lcm*inv ;
      ans %=MOD ;
    }
    System.out.println(ans);
  }
}
class ModLcm {
  private int max ;
  private int[] exponent ;
  public ModLcm(int max){
    this.max=max ;
    exponent=new int[max];
  }
  public void lcm(int n){
    for(int i=2 ; i*i<=n ; i++){
      int ex=0 ;
      while(n % i==0){
        ex++;
        n/=i ;
      }
      exponent[i]=Math.max(exponent[i],ex);
    }
    if(n!=1){
      exponent[n]=Math.max(1,exponent[n]);
    }
  }
  public static long mod_pow(long x,long p,long m){
    long a=1 ;
    while(p>0){
      if(p % 2==1){
        a=a*x % m ;
      }
      x=x*x % m ;
      p/=2 ;
    }
    return a ;
  }
  public int getModLcm(int mod){
    long res=1 ;
    for(int i=0 ; i<max ; i++){
      if(exponent[i]==0){
        continue ;
      }
      res*=mod_pow(i,exponent[i],mod);
      res %=mod ;
    }
    return(int)res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1e9->oclAsType(int) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var ml : ModLcm ; ml := ModLcm.newModLcm(1e6->oclAsType(int) + 6) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sc.getCurrent())->toInteger() ; 
     ml.lcm(a[i+1]) )  ;     i := i + 1 ) ; 
    var lcm : int ; lcm := ml.getModLcm(MOD) ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var inv : long ; inv := ModLcm.mod_pow(a[i+1], MOD - 2, MOD) ;
     ans := ans+(lcm * inv) ; 
     ans := ans mod MOD )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}
class ModLcm {
   attribute max : int;
   attribute exponent : Sequence(int);
   static operation newModLcm( max : int) : ModLcm
  pre: true
  post: true
  activity:
  ( var self : ModLcm ;
    self := createModLcm();
    self.initialise(max);
    return self );
  operation initialise( max : int) : void
  pre: true  post: true
  activity: (     self.max := max ; 
     exponent := Integer.subrange(1,max)->collect(0) );
   operation lcm( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= n do ( (     var ex : int ; ex := 0 ;
     while (n mod i = 0) do (     ex := ex + 1 ; 
     n := n/(i) ) ; 
     exponent[i+1] := Set{exponent[i+1], ex}->max() )  ;     i := i + 1 ) ; 
     if (n /= 1) then (     exponent[n+1] := Set{1, exponent[n+1]}->max() ) else skip );
  static   operation mod_pow( x : long, p : long, m : long) : long
  pre: true
  post: true
  activity: (     var a : long ; a := 1 ;
     while (p > 0) do (     if (p mod 2 = 1) then (     a := a * x mod m ) else skip ; 
     x := x * x mod m ; 
     p := p/(2) ) ; 
     return a );
   operation getModLcm( mod : int) : int
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : int ; i := 0 ; while i < max do ( (     if (exponent[i+1] = 0) then (     continue ) else skip ; 
     res := res*(mod_pow(i, exponent[i+1], mod)) ; 
     res := res mod mod )  ;     i := i + 1 ) ; 
     return res->oclAsType(int) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String[] r="::Man:Oku:Cho:Kei:Gai:Jo:Jou:Ko:Kan:Sei:Sai:Gok:Ggs:Asg:Nyt:Fks:Mts".split(":");
    for(; ; ){
      int n=sc.nextInt(),m=sc.nextInt();
      if((n | m)==0){
        break ;
      }
      String b=new BigInteger(n+"").pow(m).toString();
      if(b.length()% 4>0){
        int s=4-b.length()% 4 ;
        while(s-->0){
          b="0"+b ;
        }
      }
      int l=b.length()/4 ;
      for(int i=0 ; i<b.length(); i+=4){
        int a=Integer.parseInt(b.substring(i,i+4));
        System.out.print(a>0 ? a+r[l--] : "");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : Sequence(String) ; r := "::Man:Oku:Cho:Kei:Gai:Jo:Jou:Ko:Kan:Sei:Sai:Gok:Ggs:Asg:Nyt:Fks:Mts"->split(":") ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseOr(n,m)) = 0) then (     break ) else skip ; 
    var b : String ; b := long(n + "").pow(m)+"" ;
    if (b->size() mod 4 > 0) then (     var s : int ; s := 4 - b->size() mod 4 ;
         while (s > 0) do (        s := s - 1 ;     skip ; (     b := "0" + b ) ;  ) ) else skip ; 
    var l : int ; l := b->size() / 4 ;
        var i : int ; i := 0 ; while i < b->size() do ( (     var a : int ; a := (b.subrange(i+1,i + 4))->toInteger() ;
     OclFile["System.out"].print(if a > 0 then a + r[l+1] else "" endif) )  ;     i := i+(4) ) ; 
    OclFile["System.out"].println() ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int a=in.nextInt();
    int b=in.nextInt();
    long answer ;
    if(n==1 && a!=b){
      System.out.println(0);
    }
    else if(a>b){
      System.out.println(0);
    }
    else {
      Integer iB=b ;
      BigInteger bigB=new BigInteger(iB.toString());
      Integer iA=a ;
      BigInteger bigA=new BigInteger(iA.toString());
      Integer iN=n-2 ;
      BigInteger bigN=new BigInteger(iN.toString());
      BigInteger big=bigB.subtract(bigA);
      big=big.multiply(bigN);
      BigInteger one=new BigInteger("1");
      big=big.add(one);
      System.out.println(big);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var answer : long ;
    if (n = 1 & a /= b) then (     OclFile["System.out"].println(0) ) else     if (a > b) then (     OclFile["System.out"].println(0) ) else (     var iB : int ; iB := b ;
     var bigB : long ; bigB := long(iB+"") ;
    var iA : int ; iA := a ;
    var bigA : long ; bigA := long(iA+"") ;
    var iN : int ; iN := n - 2 ;
    var bigN : long ; bigN := long(iN+"") ;
    var big : long ; big := bigB.subtract(bigA) ;
    big := big.multiply(bigN) ; 
    var one : long ; one := long("1") ;
    big := big->excludes(one) ; 
    OclFile["System.out"].println(big) ; 
 ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    FastScanner in=new FastScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskAA solver=new TaskAA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskAA {
    public void solve(int testNumber,FastScanner in,PrintWriter out){
      long n=in.nextInt();
      long a=in.nextInt();
      long b=in.nextInt();
      long min=(n-1)*a+b ;
      long max=(n-1)*b+a ;
      out.println(Math.max(0,max-min+1));
    }
  }
  static class FastScanner {
    private BufferedReader in ;
    private StringTokenizer st ;
    public FastScanner(InputStream stream){
      in=new BufferedReader(new InputStreamReader(stream));
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(in.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : FastScanner ; in := FastScanner.newFastScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskAA ; solver := TaskAA.newTaskAA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskAA {
   operation solve( testNumber : int, in : FastScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : long ; n := in.nextInt() ;
     var a : long ; a := in.nextInt() ;
    var b : long ; b := in.nextInt() ;
    var min : long ; min := (n - 1) * a + b ;
    var max : long ; max := (n - 1) * b + a ;
    skip ; 
 );
}
  static class FastScanner {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( stream : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(in.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
import java.util.Arrays ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    String line=reader.readLine();
    String[] vals=line.split(" ");
    Integer[] nums={
      Integer.parseInt(vals[0]),Integer.parseInt(vals[1]),Integer.parseInt(vals[2]),Integer.parseInt(vals[3]),Integer.parseInt(vals[4])};
      Arrays.sort(nums);
      out.println(String.format("%d %d %d %d %d",nums[4],nums[3],nums[2],nums[1],nums[0]));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     var line : String ; line := reader.readLine() ;
    var vals : Sequence(String) ; vals := line->split(" ") ;
    var nums : Sequence(int) ; nums := Sequence{(vals[0+1])->toInteger(),(vals[1+1])->toInteger(),(vals[2+1])->toInteger(),(vals[3+1])->toInteger(),(vals[4+1])->toInteger()} ;
    nums := nums->sort() ; 
    out.println(StringLib.format("%d %d %d %d %d",Sequence{nums[4+1],nums[3+1],nums[2+1],nums[1+1],nums[0+1]})) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main implements Runnable {
  private void solve()throws IOException {
    int N=nextInt();
    long A=nextLong();
    long B=nextLong();
    if(A>B){
      writer.println(0);
    }
    else {
      if(N==1){
        if(A!=B){
          writer.println(0);
        }
        else writer.println(1);
      }
      else {
        if(A==B){
          writer.println(1);
        }
        else {
          long huge=(long)(N-2)*(long)B ;
          long small=(long)(N-2)*(long)A ;
          writer.println((huge-small+1));
        }
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  BufferedReader reader ;
  StringTokenizer tokenizer ;
  PrintWriter writer ;
  public void run(){
    try {
      reader=new BufferedReader(new InputStreamReader(System.in));
      tokenizer=null ;
      writer=new PrintWriter(System.out);
      solve();
      reader.close();
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  short nextShort()throws IOException {
    return Short.parseShort(nextToken());
  }
  String nextToken()throws IOException {
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : int ; N := nextInt() ;
     var A : long ; A := nextLong() ;
     var B : long ; B := nextLong() ;
     if (A > B) then (     writer.println(0) ) else (     if (N = 1) then (     if (A /= B) then (     writer.println(0) ) else     writer.println(1) ; ) else (     if (A = B) then (     writer.println(1) ) else (     var huge : long ; huge := (N - 2)->oclAsType(long) * B->oclAsType(long) ;
     var small : long ; small := (N - 2)->oclAsType(long) * A->oclAsType(long) ;
     writer.println((huge - small + 1)) ) ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   attribute writer : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     try (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := null ; 
    writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String args[]){
    FastScanner cin=new FastScanner();
    PrintWriter cout=new PrintWriter(System.out);
    solve(cin,cout);
    cout.flush();
  }
  private static void solve(FastScanner cin,PrintWriter cout){
    assert solve(4,4,6)==5 ;
    assert solve(5,4,3)==0 ;
    assert solve(1,7,10)==0 ;
    assert solve(1,3,3)==1 ;
    long n=cin.nextInt();
    long a=cin.nextInt();
    long b=cin.nextInt();
    long ans=solve(n,a,b);
    cout.println(ans);
  }
  private static long solve(long n,long a,long b){
    long min=a*(n-1)+b ;
    long max=b*(n-1)+a ;
    long ans=Math.max(max-min+1,0);
    return ans ;
  }
  static class FastScanner {
    private BufferedReader br ;
    private StringTokenizer st ;
    FastScanner(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(st==null || ! st.hasMoreElements())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        throw new IllegalStateException(e);
      }
      return st.nextToken();
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        throw new IllegalStateException(e);
      }
      return str ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : FastScanner ; cin := FastScanner.newFastScanner() ;
     var cout : OclFile ; cout := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     execute solve(cin, cout) ; 
     skip );
  static   operation solve( cin : FastScanner, cout : OclFile) : void
  pre: true
  post: true
  activity: (     assert solve(4, 4, 6) = 5 ; 
     assert solve(5, 4, 3) = 0 ; 
    assert solve(1, 7, 10) = 0 ; 
    assert solve(1, 3, 3) = 1 ; 
    var n : long ; n := cin.nextInt() ;
    var a : long ; a := cin.nextInt() ;
    var b : long ; b := cin.nextInt() ;
    var ans : long ; ans := solve(n, a, b) ;
    skip ; 
 );
  static   operation solve( n : long, a : long, b : long) : long
  pre: true
  post: true
  activity: (     var min : long ; min := a * (n - 1) + b ;
     var max : long ; max := b * (n - 1) + a ;
     var ans : long ; ans := Set{max - min + 1, 0}->max() ;
     return ans );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     error IncorrectElementException(e) )
 ; 
     return st.next() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     error IncorrectElementException(e) )
     return str );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    int N=in.nextInt(),A=in.nextInt(),B=in.nextInt();
    if(A>B ||(N==1 && A!=B)){
      System.out.println("0");
    }
    else if(A==B && N==1){
      System.out.println("1");
    }
    else {
      long min=(long)A*(N-2);
      long max=(long)B*(N-2);
      System.out.println(max-min+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
    var A : int ; A := in.getCurrent()->toInteger() ;
    var B : int ; B := in.getCurrent()->toInteger() ;
     if (A > B or (N = 1 & A /= B)) then (     OclFile["System.out"].println("0") ) else     if (A = B & N = 1) then (     OclFile["System.out"].println("1") ) else (     var min : long ; min := A->oclAsType(long) * (N - 2) ;
     var max : long ; max := B->oclAsType(long) * (N - 2) ;
     OclFile["System.out"].println(max - min + 1) ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countNumbers(int X,int Y,int N){
    int count=0 ;
    for(int i=1 ; i<=N ; i++){
      if((i % X==0)&&(i % Y!=0))count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int X=2,Y=3,N=10 ;
    System.out.println(countNumbers(X,Y,N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countNumbers( X : int, Y : int, N : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i <= N do ( (     if ((i mod X = 0) & (i mod Y /= 0)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 2 ;
    var Y : int ; Y := 3 ;
    var N : int ; N := 10 ;
     OclFile["System.out"].println(countNumbers(X, Y, N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class FINDSUM {
  static long mod=1000000007 ;
  public static long findSum(long n){
    return((n % mod)*(n % mod))% mod ;
  }
  public static void main(String[] args){
    long n=229137999 ;
    System.out.print(findSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class FINDSUM {
  static   attribute mod : long := 1000000007;
  static   operation findSum( n : long) : long
  pre: true
  post: true
  activity: (     return ((n mod mod) * (n mod mod)) mod mod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 229137999 ;
     OclFile["System.out"].print(findSum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
class GfG {
  static void solve(int arr[],int n,int k){
    HashMap<Integer,Integer>m=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(! m.containsKey(arr[i]))m.put(arr[i],0);
      m.put(arr[i],m.get(arr[i])+1);
    }
    int max=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      if(m.get(arr[i])==k && max==Integer.MIN_VALUE){
        max=arr[i];
      }
      else if(m.get(arr[i])==k && max<arr[i]){
        max=arr[i];
      }
    }
    if(max==Integer.MIN_VALUE)System.out.println("No such element");
    else System.out.println(max);
  }
  public static void main(String[] args){
    int arr[]={
      1,1,2,3,3,4,5,5,6,6,6 };
      int k=4 ;
      int n=arr.length ;
      solve(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation solve( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var m : Map(int,int) ; m := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (not(m->keys()->includes(arr[i+1]))) then     m := m->union(Map{arr[i+1] |-> 0}) ; else skip ; 
     m := m->union(Map{arr[i+1] |-> m->at(arr[i+1]) + 1}) )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     if (m->at(arr[i+1]) = k & max = -2147483648) then (     max := arr[i+1] ) else     if (m->at(arr[i+1]) = k & max < arr[i+1]) then (     max := arr[i+1] ) else skip ; )  ;     i := i + 1 ) ; 
    if (max = -2147483648) then     OclFile["System.out"].println("No such element") else     OclFile["System.out"].println(max) ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,2,3,3,4,5,5,6,6,6} ;
     var k : int ; k := 4 ;
     var n : int ; n := arr->size() ;
     execute solve(arr, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int fun(int n){
    return n &(n-1);
  }
  public static void main(String arg[]){
    int n=7 ;
    System.out.print("The number after unsetting "+"the rightmost set bit "+fun(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation fun( n : int) : int
  pre: true
  post: true
  activity: (     return n & (n - 1) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
     OclFile["System.out"].print("The number after unsetting " + "the rightmost set bit " + fun(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    @ SuppressWarnings("resource")Scanner scan=new Scanner(System.in);
    int[] guys=new int[5];
    int tmp=scan.nextInt();
    while(tmp!=0){
      boolean[] check=new boolean[3];
      guys[0]=tmp ;
      check[tmp-1]=true ;
      for(int i=1 ; i<5 ; i++){
        guys[i]=scan.nextInt();
        check[guys[i]-1]=true ;
      }
      int fl=0 ;
      for(int i=0 ; i<3 ; i++){
        if(check[i]){
          fl++;
        }
      }
      if(fl==1 || fl==3){
        for(int i=0 ; i<5 ; i++){
          System.out.println(3);
        }
      }
      else {
        if(! check[0]){
          for(int i=0 ; i<5 ; i++){
            if(guys[i]==2){
              System.out.println(1);
            }
            else {
              System.out.println(2);
            }
          }
        }
        else if(! check[1]){
          for(int i=0 ; i<5 ; i++){
            if(guys[i]==3){
              System.out.println(1);
            }
            else {
              System.out.println(2);
            }
          }
        }
        else if(! check[2]){
          for(int i=0 ; i<5 ; i++){
            if(guys[i]==1){
              System.out.println(1);
            }
            else {
              System.out.println(2);
            }
          }
        }
      }
      tmp=scan.nextInt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var guys : Sequence(int) ; guys := Integer.subrange(1,5)->collect(0) ;
     var tmp : int ; tmp := scan.getCurrent()->toInteger() ;
     while (tmp /= 0) do (     var check : Sequence(boolean) ; check := Integer.subrange(1,3)->collect(false) ;
     guys[0+1] := tmp ; 
    check[tmp - 1+1] := true ; 
        var i : int ; i := 1 ; while i < 5 do ( (     guys[i+1] := scan.getCurrent()->toInteger() ; 
     check[guys[i+1] - 1+1] := true )  ;     i := i + 1 ) ; 
    var fl : int ; fl := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (check[i+1]) then (     fl := fl + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (fl = 1 or fl = 3) then (         var i : int ; i := 0 ; while i < 5 do ( (     OclFile["System.out"].println(3) )  ;     i := i + 1 ) ) else (     if (not(check[0+1])) then (         var i : int ; i := 0 ; while i < 5 do ( (     if (guys[i+1] = 2) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(2) ) )  ;     i := i + 1 ) ) else     if (not(check[1+1])) then (         var i : int ; i := 0 ; while i < 5 do ( (     if (guys[i+1] = 3) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(2) ) )  ;     i := i + 1 ) ) else     if (not(check[2+1])) then (         var i : int ; i := 0 ; while i < 5 do ( (     if (guys[i+1] = 1) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(2) ) )  ;     i := i + 1 ) ) else skip ; ;  ) ;  
    tmp := scan.getCurrent()->toInteger() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    for(; ; ){
      int n=5 ;
      int[] a=new int[n];
      boolean[] exist=new boolean[3];
      for(int i=0 ; i<n ; i++){
        if((a[i]=sc.nextInt()-1)==-1){
          return ;
        }
        exist[a[i] ]=true ;
      }
      int s=0 ;
      for(int i=0 ; i<3 ; i++){
        if(exist[i]){
          s++;
        }
      }
      if(s==2){
        for(int i=0 ; i<n ; i++){
          if(exist[(a[i]+1)% 3]){
            println("1");
          }
          else {
            println("2");
          }
        }
      }
      else {
        println("3\n3\n3\n3\n3");
        continue ;
      }
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := 5 ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var exist : Sequence(boolean) ; exist := Integer.subrange(1,3)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     if ((a[i+1]) = -1) then (     return ) else skip ; 
     exist[a[i+1]+1] := true )  ;     i := i + 1 ) ; 
    var s : int ; s := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (exist[i+1]) then (     s := s + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (s = 2) then (         var i : int ; i := 0 ; while i < n do ( (     if (exist[(a[i+1] + 1) mod 3+1]) then (     execute println("1") ) else (     execute println("2") ) )  ;     i := i + 1 ) ) else (     execute println("3\n3\n3\n3\n3") ; 
     continue ) ;  
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
class Main {
  static final int WIN=1 ;
  static final int LOSE=2 ;
  static final int EVEN=3 ;
  public static void main(final String[] args){
    final Scanner stdin=new Scanner(System.in);
    while(true){
      final int[] array=new int[5];
      array[0]=stdin.nextInt();
      if(array[0]==0)break ;
      for(int i=1 ; i<5 ; i++){
        array[i]=stdin.nextInt();
      }
      int sum=0 ;
      for(final int val : array){
        sum |=1<<(val-1);
      }
      final int count=Integer.bitCount(sum);
      if(count==2){
        int winIndex=-1 ;
        int loseIndex=-1 ;
        if(sum==3){
          winIndex=1 ;
          loseIndex=2 ;
        }
        else if(sum==5){
          winIndex=3 ;
          loseIndex=1 ;
        }
        else {
          winIndex=2 ;
          loseIndex=3 ;
        }
        for(int i=0 ; i<5 ; i++){
          if(array[i]==winIndex){
            array[i]=WIN ;
          }
          else if(array[i]==loseIndex){
            array[i]=LOSE ;
          }
        }
      }
      else {
        Arrays.fill(array,EVEN);
      }
      for(final int val : array){
        System.out.println(val);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute WIN : int := 1;
  static    attribute LOSE : int := 2;
  static    attribute EVEN : int := 3;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var array : Sequence(int) ; array := Integer.subrange(1,5)->collect(0) ;
     array[0+1] := stdin.getCurrent()->toInteger() ; 
    if (array[0+1] = 0) then     break else skip ; 
        var i : int ; i := 1 ; while i < 5 do ( (     array[i+1] := stdin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    for (val : array) do ( (     sum := MathLib.bitwiseOr(sum, (1*(2->pow((val - 1))))->oclAsType(long)) )  ) ; 
    var count : int ; count := bitCount(sum) ;
    if (count = 2) then (     var winIndex : int ; winIndex := -1 ;
     var loseIndex : int ; loseIndex := -1 ;
     if (sum = 3) then (     winIndex := 1 ; 
     loseIndex := 2 ) else     if (sum = 5) then (     winIndex := 3 ; 
     loseIndex := 1 ) else (     winIndex := 2 ; 
     loseIndex := 3 ) ;  ;  
         var i : int ; i := 0 ; while i < 5 do ( (     if (array[i+1] = winIndex) then (     array[i+1] := WIN ) else     if (array[i+1] = loseIndex) then (     array[i+1] := LOSE ) else skip ; )  ;     i := i + 1 ) ) else (     array := array->collect(EVEN) ) ;  
    for (val : array) do ( (     OclFile["System.out"].println(val) )  ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.ArrayList ;
public class Main {
  static int person=5 ;
  public static void main(String args[])throws IOException {
    boolean flg=true ;
    while(flg){
      BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
      ArrayList<String>fivehands=new ArrayList<String>();
      for(int i=0 ; i<person ; i++){
        fivehands.add(bf.readLine());
        if(fivehands.get(0).equals("0")){
          person=-1 ;
          flg=false ;
        }
        if(person==i+1){
          judge(fivehands);
          fivehands.removeAll(fivehands);
          i=-1 ;
        }
      }
    }
  }
  private static void judge(ArrayList<String>fivehands){
    int sum=1000 ;
    for(String a : fivehands){
      if(a.equals("1")){
        sum=sum+100 ;
      }
      else if(a.equals("2")){
        sum=sum+10 ;
      }
      else if(a.equals("3")){
        sum=sum+1 ;
      }
    }
    String judgeSum=String.valueOf(sum);
    if(judgeSum.contains("0")&& ! judgeSum.contains(String.valueOf(person))){
      if(judgeSum.charAt(1)=='0'){
        judgeDetail(fivehands,"2","3");
      }
      else if(judgeSum.charAt(2)=='0'){
        judgeDetail(fivehands,"3","1");
      }
      else if(judgeSum.charAt(3)=='0'){
        judgeDetail(fivehands,"1","2");
      }
    }
    else {
      for(int i=0 ; i<person ; i++){
        System.out.println("3");
      }
    }
  }
  private static void judgeDetail(ArrayList<String>fivehands,String win,String lose){
    for(String a : fivehands){
      if(a.equals(win)){
        System.out.println("1");
      }
      else if(a.equals(lose)){
        System.out.println("2");
      }
      else {
        System.out.println("-1");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute person : int := 5;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var flg : boolean ; flg := true ;
     while (flg) do (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var fivehands : Sequence(String) ; fivehands := Sequence{} ;
         var i : int ; i := 0 ; while i < person do ( (     fivehands := fivehands->including(bf.readLine()) ; 
     if (fivehands->at(0+1) = "0") then (     person := -1 ; 
     flg := false ) else skip ; 
     if (person = i + 1) then (     execute judge(fivehands) ; 
     fivehands := fivehands - fivehands ; 
     i := -1 ) else skip )  ;     i := i + 1 ) ) );
  static   operation judge( fivehands : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 1000 ;
     for (a : fivehands) do ( (     if (a = "1") then (     sum := sum + 100 ) else     if (a = "2") then (     sum := sum + 10 ) else     if (a = "3") then (     sum := sum + 1 ) else skip ; ;  )  ) ; 
     var judgeSum : String ; judgeSum := ((sum) + "") ;
     if (judgeSum->includes("0") & not(judgeSum->includes(((person) + "")))) then (     if (judgeSum->at(1+1) = '0') then (     execute judgeDetail(fivehands, "2", "3") ) else     if (judgeSum->at(2+1) = '0') then (     execute judgeDetail(fivehands, "3", "1") ) else     if (judgeSum->at(3+1) = '0') then (     execute judgeDetail(fivehands, "1", "2") ) else skip ; ;  ) else (         var i : int ; i := 0 ; while i < person do ( (     OclFile["System.out"].println("3") )  ;     i := i + 1 ) ) );
  static   operation judgeDetail( fivehands : Sequence(String), win : String, lose : String) : void
  pre: true
  post: true
  activity: (     for (a : fivehands) do ( (     if (a = win) then (     OclFile["System.out"].println("1") ) else     if (a = lose) then (     OclFile["System.out"].println("2") ) else (     OclFile["System.out"].println("-1") ) ;  )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void quickSort(int[] arr,int left,int right){
    if(left<=right){
      int p=arr[(left+right)/2];
      int l=left ;
      int r=right ;
      while(l<=r){
        while(arr[l]<p){
          l++;
        }
        while(arr[r]>p){
          r--;
        }
        if(l<=r){
          int tmp=arr[l];
          arr[l]=arr[r];
          arr[r]=tmp ;
          l++;
          r--;
        }
      }
      quickSort(arr,left,r);
      quickSort(arr,l,right);
    }
  }
  public static void arrayPrintln(int[] arr){
    for(int i=arr.length-1 ; i>=0 ; i--){
      if(i!=0){
        System.out.print(arr[i]+" ");
      }
      else System.out.print(arr[i]);
    }
    System.out.println("");
  }
  public static void main(String args[])throws IOException {
    String str ;
    int[] inp=new int[5];
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      for(int i=0 ; i<5 ; i++){
        str=scan.next();
        int x=Integer.valueOf(str).intValue();
        inp[i]=x ;
      }
      quickSort(inp,0,inp.length-1);
      arrayPrintln(inp);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation quickSort( arr : Sequence(int), left : int, right : int) : void
  pre: true
  post: true
  activity: (     if (left <= right) then (     var p : int ; p := arr[(left + right) / 2+1] ;
     var l : int ; l := left ;
    var r : int ; r := right ;
    while (l <= r) do (     while (arr[l+1] < p) do (     l := l + 1 ) ; 
     while (arr[r+1] > p) do (     r := r - 1 ) ; 
     if (l <= r) then (     var tmp : int ; tmp := arr[l+1] ;
     arr[l+1] := arr[r+1] ; 
    arr[r+1] := tmp ; 
    l := l + 1 ; 
    r := r - 1 ; 
 ) else skip ) ; 
    execute quickSort(arr, left, r) ; 
    execute quickSort(arr, l, right) ; 
 ) else skip );
  static   operation arrayPrintln( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := arr->size() - 1 ; while i >= 0 do ( (     if (i /= 0) then (     OclFile["System.out"].print(arr[i+1] + " ") ) else     OclFile["System.out"].print(arr[i+1]) ; )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println("") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ;
     var inp : Sequence(int) ; inp := Integer.subrange(1,5)->collect(0) ;
     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (         var i : int ; i := 0 ; while i < 5 do ( (     str := scan.getCurrent() ; 
     var x : int ; x := (str)->toInteger()->oclAsType(int) ;
     inp[i+1] := x )  ;     i := i + 1 ) ; 
     execute quickSort(inp, 0, inp->size() - 1) ; 
     execute arrayPrintln(inp) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int[] a ;
    int[] count ;
    int i ;
    count=new int[3];
    a=new int[5];
    for(; ; ){
      for(i=0 ; i<3 ; i++)count[i]=0 ;
      a[0]=sc.nextInt();
      if(a[0]==0)break ;
      count[a[0]-1]++;
      for(i=1 ; i<5 ; i++){
        a[i]=sc.nextInt();
        count[a[i]-1]++;
      }
      if(count[0]*count[1]*count[2]!=0){
        out.printf("3%n3%n3%n3%n3%n");
      }
      else if(count[0]==5){
        out.printf("3%n3%n3%n3%n3%n");
      }
      else if(count[1]==5){
        out.printf("3%n3%n3%n3%n3%n");
      }
      else if(count[2]==5){
        out.printf("3%n3%n3%n3%n3%n");
      }
      else if(count[0]==0){
        for(i=0 ; i<5 ; i++){
          if(a[i]==2)out.println("1");
          else out.println("2");
        }
      }
      else if(count[1]==0){
        for(i=0 ; i<5 ; i++){
          if(a[i]==3)out.println("1");
          else out.println("2");
        }
      }
      else if(count[2]==0){
        for(i=0 ; i<5 ; i++){
          if(a[i]==1)out.println("1");
          else out.println("2");
        }
      }
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var a : Sequence(int) ;
    var count : Sequence(int) ;
    var i : int ;
    count := Integer.subrange(1,3)->collect(0) ; 
    a := Integer.subrange(1,5)->collect(0) ; 
      while true do ( (         i := 0 ; while i < 3 do (     count[i+1] := 0 ;  ;     i := i + 1 ) ; 
     a[0+1] := sc.nextInt() ; 
    if (a[0+1] = 0) then     break else skip ; 
    count[a[0+1] - 1+1] := count[a[0+1] - 1+1] + 1 ; 
        i := 1 ; while i < 5 do ( (     a[i+1] := sc.nextInt() ; 
     count[a[i+1] - 1+1] := count[a[i+1] - 1+1] + 1 )  ;     i := i + 1 ) ; 
    if (count[0+1] * count[1+1] * count[2+1] /= 0) then (     out.printf("3%n3%n3%n3%n3%n") ) else     if (count[0+1] = 5) then (     out.printf("3%n3%n3%n3%n3%n") ) else     if (count[1+1] = 5) then (     out.printf("3%n3%n3%n3%n3%n") ) else     if (count[2+1] = 5) then (     out.printf("3%n3%n3%n3%n3%n") ) else     if (count[0+1] = 0) then (         i := 0 ; while i < 5 do ( (     if (a[i+1] = 2) then     out.println("1") ; else     out.println("2") ; )  ;     i := i + 1 ) ) else     if (count[1+1] = 0) then (         i := 0 ; while i < 5 do ( (     if (a[i+1] = 3) then     out.println("1") ; else     out.println("2") ; )  ;     i := i + 1 ) ) else     if (count[2+1] = 0) then (         i := 0 ; while i < 5 do ( (     if (a[i+1] = 1) then     out.println("1") ; else     out.println("2") ; )  ;     i := i + 1 ) ) else skip ; ;  ;  ;  ;  ;  ;  
 )  ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int[] dp=new int[310];
    dp[0]=1 ;
    for(int i=1 ; i*i<=300 ; i++){
      for(int j=300 ; j>=0 ; j--){
        for(int k=1 ; i*i*k+j<=300 ; k++){
          if(dp[j]==0)continue ;
          dp[j+i*i*k]+=dp[j];
        }
      }
    }
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      System.out.println(dp[n]);
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dp : Sequence(int) ; dp := Integer.subrange(1,310)->collect(0) ;
    dp[0+1] := 1 ; 
        var i : int ; i := 1 ; while i * i <= 300 do ( (         var j : int ; j := 300 ; while j >= 0 do ( (         var k : int ; k := 1 ; while i * i * k + j <= 300 do ( (     if (dp[j+1] = 0) then     continue else skip ; 
     dp[j + i * i * k+1] := dp[j + i * i * k+1]+(dp[j+1]) )  ;     k := k + 1 ) )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
     OclFile["System.out"].println(dp[n+1]) ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Point2D ;
import java.awt.geom.Point2D.Double ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new B().doIt();
  }
  class B {
    int dp[]=new int[301];
    void dp_table(){
      dp[0]=1 ;
      for(int i=1 ; i<17 ; i++){
        for(int j=0 ; j<301 ; j++){
          if(j+(i*i)>300)break ;
          dp[j+(i*i)]=dp[j+(i*i)]+dp[j];
        }
      }
    }
    void doIt(){
      dp_table();
      while(true){
        int n=sc.nextInt();
        if(n==0)break ;
        System.out.println(dp[n]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     B.newB().doIt() );
 class B {
   attribute dp : int := Integer.subrange(1,301)->collect(0);
   operation dp_table() : void
  pre: true
  post: true
  activity: (     dp[0+1] := 1 ; 
         var i : int ; i := 1 ; while i < 17 do ( (         var j : int ; j := 0 ; while j < 301 do ( (     if (j + (i * i) > 300) then     break else skip ; 
     dp[j + (i * i)+1] := dp[j + (i * i)+1] + dp[j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
   operation doIt() : void
  pre: true
  post: true
  activity: (     execute dp_table() ; 
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
     OclFile["System.out"].println(dp[n+1]) ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  static int[] map=new int[300];
  public static void main(String[] args){
    BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
    try {
      fillup(1,0);
      while(true){
        int n=Integer.valueOf(sc.readLine()),sum=0 ;
        if(n==0)break ;
        System.out.println(map[n]);
      }
    }
    catch(Exception e){
      System.out.println("Error");
    }
  }
  static void fillup(int k,int sum){
    if(k==18)return ;
    for(int i=k ; sum+i*i<300 ; i++){
      map[sum+i*i]++;
      fillup(i,sum+i*i);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute map : Sequence(int) := Integer.subrange(1,300)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     execute fillup(1, 0) ; 
     while (true) do (     var n : int ; n := (sc.readLine())->toInteger() ;
    var sum : int ; sum := 0 ;
     if (n = 0) then     break else skip ; 
     OclFile["System.out"].println(map[n+1]) ) )   catch (e : ProgramException) do (     OclFile["System.out"].println("Error") )
 );
  static   operation fillup( k : int, sum : int) : void
  pre: true
  post: true
  activity: (     if (k = 18) then     return else skip ; 
         var i : int ; i := k ; while sum + i * i < 300 do ( (     map[sum + i * i+1] := map[sum + i * i+1] + 1 ; 
     execute fillup(i, sum + i * i) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  int k ;
  void run(){
    int n=17 ;
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=(i+1)*(i+1);
    }
    int max=300 ;
    int[] dp=new int[max];
    dp[0]=1 ;
    for(int j=0 ; j<n ; j++){
      for(int i=a[j]; i<max ; i++){
        dp[i]+=dp[i-a[j] ];
      }
    }
    for(; ; ){
      k=sc.nextInt();
      if(k==0){
        break ;
      }
      println(""+dp[k]);
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   attribute k : int;
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := 17 ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (i + 1) * (i + 1) )  ;     i := i + 1 ) ; 
    var max : int ; max := 300 ;
    var dp : Sequence(int) ; dp := Integer.subrange(1,max)->collect(0) ;
    dp[0+1] := 1 ; 
        var j : int ; j := 0 ; while j < n do ( (         var i : int ; i := a[j+1] ; while i < max do ( (     dp[i+1] := dp[i+1]+(dp[i - a[j+1]+1]) )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
      while true do ( (     k := sc.getCurrent()->toInteger() ; 
     if (k = 0) then (     break ) else skip ; 
     execute println("" + dp[k+1]) )  ) ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GFG {
  static int LongestFibSubseq(int A[],int n){
    TreeSet<Integer>S=new TreeSet<>();
    for(int t : A){
      S.add(t);
    }
    int maxLen=0,x,y ;
    for(int i=0 ; i<n ; ++i){
      for(int j=i+1 ; j<n ; ++j){
        x=A[j];
        y=A[i]+A[j];
        int length=3 ;
        while(S.contains(y)&&(y!=S.last())){
          int z=x+y ;
          x=y ;
          y=z ;
          maxLen=Math.max(maxLen,++length);
        }
      }
    }
    return maxLen>=3 ? maxLen : 0 ;
  }
  public static void main(String[] args){
    int A[]={
      1,2,3,4,5,6,7,8 };
      int n=A.length ;
      System.out.print(LongestFibSubseq(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation LongestFibSubseq( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var S : Set(int) ; S := Set{} ;
     for (t : A) do ( (     S := S->including(t) )  ) ; 
    var maxLen : int ; maxLen := 0 ;
    var x : int ;
    var y : int ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     x := A[j+1] ; 
     y := A[i+1] + A[j+1] ; 
     var length : int ; length := 3 ;
     while (S->includes(y) & (y /= S->last())) do (     var z : int ; z := x + y ;
     x := y ; 
     y := z ; 
     maxLen := Set{maxLen, (length + 1)}->max() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return if maxLen >= 3 then maxLen else 0 endif 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{1,2,3,4,5,6,7,8} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].print(LongestFibSubseq(A, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int[] sq={
    1,4,9,16,25,36,49,64,81,100,121,144,169,14*14,15*15,16*16,17*17 };
    static boolean[][] dp ;
    static int n,ans ;
    public static void main(String[] args){
      Scanner cin=new Scanner(System.in);
      while(true){
        n=cin.nextInt();
        if(n==0)break ;
        ans=0 ;
        dp=new boolean[301][sq.length];
        for(int i=0 ; i<301 ; i++){
          for(int j=0 ; j<sq.length ; j++){
            dp[i][j]=false ;
          }
        }
        dp[0][0]=dfs(0,0);
        System.out.println(ans);
      }
    }
    static boolean dfs(int sum,int depth){
      if(depth==sq.length)return false ;
      if(dp[sum][depth]){
        ans++;
        return true ;
      }
      if(sum==n){
        dp[sum][depth]=true ;
        ans++;
        return true ;
      }
      for(; sum<=n ; ){
        dp[sum][depth]=dfs(sum,depth+1);
        sum+=sq[depth];
      }
      return false ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sq : Sequence(int) := Sequence{1,4,9,16,25,36,49,64,81,100,121,144,169,14 * 14,15 * 15,16 * 16,17 * 17};
  static   attribute dp : Sequence(Sequence(boolean));
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     n := cin.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
    ans := 0 ; 
    dp := Integer.subrange(1,301)->collect(Integer.subrange(1,sq->size())->collect(false)) ; 
        var i : int ; i := 0 ; while i < 301 do ( (         var j : int ; j := 0 ; while j < sq->size() do ( (     dp[i+1][j+1] := false )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    dp[0+1][0+1] := dfs(0, 0) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation dfs( sum : int, depth : int) : boolean
  pre: true
  post: true
  activity: (     if (depth = sq->size()) then     return false else skip ; 
     if (dp[sum+1][depth+1]) then (     ans := ans + 1 ; 
     return true ) else skip ; 
    if (sum = n) then (     dp[sum+1][depth+1] := true ; 
     ans := ans + 1 ; 
     return true ) else skip ; 
      while sum <= n do ( (     dp[sum+1][depth+1] := dfs(sum, depth + 1) ; 
     sum := sum+(sq[depth+1]) )  ) ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minOperations(int[] A,int n){
    if((n & 1)>0)return-1 ;
    int zeros=0,consZeros=0,ones=0 ;
    for(int i=0 ; i<n ; ++i){
      if(A[i]==0)zeros++;
      else ones++;
      if(i+1<n){
        if(A[i]==0 && A[i+1]==0)consZeros++;
      }
    }
    if(A[0]==A[n-1] && A[0]==0)consZeros++;
    if(zeros==ones)return consZeros ;
    else return-1 ;
  }
  public static void main(String[] args){
    int[] A=new int[] {
      1,1,0,0 };
      int n=A.length ;
      System.out.println(minOperations(A,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minOperations( A : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if ((n & 1) > 0) then     return -1 else skip ; 
     var zeros : int ; zeros := 0 ;
    var consZeros : int ; consZeros := 0 ;
    var ones : int ; ones := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (A[i+1] = 0) then     zeros := zeros + 1 else     ones := ones + 1 ; ;  
     if (i + 1 < n) then (     if (A[i+1] = 0 & A[i + 1+1] = 0) then     consZeros := consZeros + 1 ; else skip ) else skip )  ;     i := i + 1 ) ; 
    if (A[0+1] = A[n - 1+1] & A[0+1] = 0) then     consZeros := consZeros + 1 ; else skip ; 
    if (zeros = ones) then     return consZeros else     return -1 ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{1,1,0,0} ;
     var n : int ; n := A->size() ;
     OclFile["System.out"].println(minOperations(A, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int SieveOfSundaram(int n){
    int nNew=(n-2)/2 ;
    boolean marked[]=new boolean[nNew+1];
    Arrays.fill(marked,false);
    for(int i=1 ; i<=nNew ; i++)for(int j=i ; (i+j+2*i*j)<=nNew ; j++)marked[i+j+2*i*j]=true ;
    if(n>2)System.out.print(2+" ");
    for(int i=1 ; i<=nNew ; i++)if(marked[i]==false)System.out.print(2*i+1+" ");
    return-1 ;
  }
  public static void main(String[] args){
    int n=20 ;
    SieveOfSundaram(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation SieveOfSundaram( n : int) : int
  pre: true
  post: true
  activity: (     var nNew : int ; nNew := (n - 2) / 2 ;
     var marked : Sequence(boolean) ; marked := Integer.subrange(1,nNew + 1)->collect(false) ;
    marked := marked->collect(false) ; 
        var i : int ; i := 1 ; while i <= nNew do (         var j : int ; j := i ; while (i + j + 2 * i * j) <= nNew do (     marked[i + j + 2 * i * j+1] := true ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    if (n > 2) then     OclFile["System.out"].print(2 + " ") ; else skip ; 
        var i : int ; i := 1 ; while i <= nNew do (     if (marked[i+1] = false) then     OclFile["System.out"].print(2 * i + 1 + " ") ; else skip ;  ;     i := i + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 20 ;
     execute SieveOfSundaram(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int setallbitgivenrange(int n,int l,int r){
    int range=(((1<<(l-1))-1)^((1<<(r))-1));
    return(n | range);
  }
  public static void main(String[] args){
    int n=17,l=2,r=3 ;
    System.out.println(setallbitgivenrange(n,l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation setallbitgivenrange( n : int, l : int, r : int) : int
  pre: true
  post: true
  activity: (     var range : int ; range := (MathLib.bitwiseXor((((1*(2->pow((l - 1))))->oclAsType(long)) - 1),(((1*(2->pow((r))))->oclAsType(long)) - 1))) ;
     return (n or range) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 17 ;
    var l : int ; l := 2 ;
    var r : int ; r := 3 ;
     OclFile["System.out"].println(setallbitgivenrange(n, l, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printSorted(int a[],int n){
    int front=-1,back=-1 ;
    for(int i=1 ; i<n ; i++){
      if(a[i]<a[i-1]){
        front=i-1 ;
        break ;
      }
    }
    for(int i=n-2 ; i>=0 ; i--){
      if(a[i]>a[i+1]){
        back=i+1 ;
        break ;
      }
    }
    if(front==-1 && back==-1){
      for(int i=0 ; i<n ; i++)System.out.println(a[i]+" ");
      return ;
    }
    while(front<=back){
      int temp=a[front];
      a[front]=a[back];
      a[back]=temp ;
      front++;
      back--;
    }
    for(int i=0 ; i<n ; i++)System.out.print(a[i]+" ");
  }
  public static void main(String[] args){
    int a[]={
      1,7,6,5,4,3,2,8 };
      int n=a.length ;
      printSorted(a,n);
      ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printSorted( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var front : int ; front := -1 ;
    var back : int ; back := -1 ;
         var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] < a[i - 1+1]) then (     front := i - 1 ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (a[i+1] > a[i + 1+1]) then (     back := i + 1 ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    if (front = -1 & back = -1) then (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].println(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
     return ) else skip ; 
    while (front <= back) do (     var temp : int ; temp := a[front+1] ;
     a[front+1] := a[back+1] ; 
    a[back+1] := temp ; 
    front := front + 1 ; 
    back := back - 1 ; 
 ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,7,6,5,4,3,2,8} ;
     var n : int ; n := a->size() ;
     execute printSorted(a, n) ; 
  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  private static final int NUM_NUMBERS=5 ;
  public static void main(String[] args){
    ArrayList<Integer>num=new ArrayList<Integer>(NUM_NUMBERS);
    setInputsToList(num);
    sort(num);
    printList(num);
  }
  private static void setInputsToList(ArrayList<Integer>list){
    Scanner sc=new Scanner(System.in);
    for(int i=0 ; i<NUM_NUMBERS ; i++){
      list.add(sc.nextInt());
    }
    sc.close();
  }
  private static void printList(ArrayList<Integer>list){
    for(int i=0 ; i<list.size(); i++){
      System.out.printf("%d",list.get(i));
      if(i!=(list.size()-1)){
        System.out.printf(" ");
      }
      else {
        System.out.printf("\n");
      }
    }
  }
  public static void sort(ArrayList<Integer>list){
    int listSize=list.size();
    for(int i=listSize-1 ; i>-1 ; i--){
      int pivot=list.get(i);
      for(int j=0 ; j<i ; j++){
        int target=list.get(j);
        if(target<pivot){
          list.set(j,pivot);
          list.set(i,target);
          pivot=target ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute NUM_NUMBERS : int := 5;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : Sequence(int) ; num := Sequence{} ;
     execute setInputsToList(num) ; 
     execute sort(num) ; 
     execute printList(num) );
  static   operation setInputsToList( list : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var i : int ; i := 0 ; while i < NUM_NUMBERS do ( (     list->excludes(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
     skip );
  static   operation printList( list : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < list->size() do ( (     OclFile["System.out"].printf("%d", list->at(i+1)) ; 
     if (i /= (list->size() - 1)) then (     OclFile["System.out"].printf(" ") ) else (     OclFile["System.out"].printf("\n") ) )  ;     i := i + 1 ) );
  static   operation sort( list : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var listSize : int ; listSize := list->size() ;
         var i : int ; i := listSize - 1 ; while i > -1 do ( (     var pivot : int ; pivot := list->at(i+1) ;
         var j : int ; j := 0 ; while j < i do ( (     var target : int ; target := list->at(j+1) ;
     if (target < pivot) then (     list := list.setAt(j+1, pivot) ; 
     list := list.setAt(i+1, target) ; 
     pivot := target ) else skip )  ;     j := j + 1 ) )  ;     i := i - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int[] arr=new int[a];
    int ma=0,mi=101,maxi=-1,mini=-1 ;
    for(int i=0 ; i<a ; i++){
      arr[i]=sc.nextInt();
      ;
      if(arr[i]>ma){
        ma=arr[i];
        maxi=i ;
      }
      if(arr[i]<=mi){
        mi=arr[i];
        mini=i ;
      }
    }
    if(maxi>mini){
      mini++;
    }
    System.out.println(maxi+(a-1)-mini);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,a)->collect(0) ;
    var ma : int ; ma := 0 ;
    var mi : int ; mi := 101 ;
    var maxi : int ; maxi := -1 ;
    var mini : int ; mini := -1 ;
        var i : int ; i := 0 ; while i < a do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr[i+1] > ma) then (     ma := arr[i+1] ; 
     maxi := i ) else skip ; 
     if (arr[i+1] <= mi) then (     mi := arr[i+1] ; 
     mini := i ) else skip )  ;     i := i + 1 ) ; 
    if (maxi > mini) then (     mini := mini + 1 ) else skip ; 
    OclFile["System.out"].println(maxi + (a - 1) - mini) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Code_144A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int pos[]=new int[n];
    int min=Integer.MAX_VALUE,max=Integer.MIN_VALUE ;
    int maxIdx=-1,minIdx=-1 ;
    for(int i=0 ; i<n ; i++){
      pos[i]=sc.nextInt();
      if(pos[i]>max){
        max=pos[i];
        maxIdx=i ;
      }
      if(pos[i]<=min){
        min=pos[i];
        minIdx=i ;
      }
    }
    int result=maxIdx+(n-1)-minIdx ;
    if(maxIdx>minIdx)result--;
    System.out.println(result);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code_144A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var pos : Sequence(int) ; pos := Integer.subrange(1,n)->collect(0) ;
    var min : int ; min := 2147483647 ;
    var max : int ; max := -2147483648 ;
    var maxIdx : int ; maxIdx := -1 ;
    var minIdx : int ; minIdx := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     pos[i+1] := sc.getCurrent()->toInteger() ; 
     if (pos[i+1] > max) then (     max := pos[i+1] ; 
     maxIdx := i ) else skip ; 
     if (pos[i+1] <= min) then (     min := pos[i+1] ; 
     minIdx := i ) else skip )  ;     i := i + 1 ) ; 
    var result : int ; result := maxIdx + (n - 1) - minIdx ;
    if (maxIdx > minIdx) then     result := result - 1 ; else skip ; 
    OclFile["System.out"].println(result) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int changeToOnes(String str){
    int i,l,ctr=0 ;
    l=str.length();
    for(i=l-1 ; i>=0 ; i--){
      if(str.charAt(i)=='1')ctr++;
      else break ;
    }
    return l-ctr ;
  }
  static String removeZeroesFromFront(String str){
    String s ;
    int i=0 ;
    while(i<str.length()&& str.charAt(i)=='0')i++;
    if(i==str.length())s="0" ;
    else s=str.substring(i,str.length()-i);
    return s ;
  }
  public static void main(String[] args){
    String str="10010111" ;
    str=removeZeroesFromFront(str);
    System.out.println(changeToOnes(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation changeToOnes( str : String) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var l : int ;
    var ctr : int ; ctr := 0 ;
     l := str->size() ; 
         i := l - 1 ; while i >= 0 do ( (     if (str->at(i+1) = '1') then     ctr := ctr + 1 ; else     break )  ;     i := i - 1 ) ; 
     return l - ctr );
  static   operation removeZeroesFromFront( str : String) : String
  pre: true
  post: true
  activity: (     var s : String ;
     var i : int ; i := 0 ;
    while (i < str->size() & str->at(i+1) = '0') do     i := i + 1 ; ; 
    if (i = str->size()) then     s := "0" else     s := str.subrange(i+1,str->size() - (i)->char2byte()) ; ;  
    return s 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "10010111" ;
     str := removeZeroesFromFront(str) ; 
     OclFile["System.out"].println(changeToOnes(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A1709 {
  public static void main(String ar[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    long left[]=new long[n];
    left[0]=0 ;
    for(int i=1 ; i<n ; i++){
      if(a[i]<a[i-1]){
        left[i]=left[i-1]+a[i-1]-a[i];
      }
      else {
        left[i]=left[i-1];
      }
    }
    long right[]=new long[n];
    right[n-1]=0 ;
    for(int i=n-2 ; i>=0 ; i--){
      if(a[i+1]>a[i]){
        right[i]=right[i+1]+a[i+1]-a[i];
      }
      else {
        right[i]=right[i+1];
      }
    }
    for(int j=0 ; j<m ; j++){
      int s=sc.nextInt();
      int t=sc.nextInt();
      if(s<t){
        System.out.println(left[t-1]-left[s-1]);
      }
      else {
        System.out.println(right[t-1]-right[s-1]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1709 {
  static   operation main( ar : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var left : Sequence(long) ; left := Integer.subrange(1,n)->collect(0) ;
    left[0+1] := 0 ; 
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] < a[i - 1+1]) then (     left[i+1] := left[i - 1+1] + a[i - 1+1] - a[i+1] ) else (     left[i+1] := left[i - 1+1] ) )  ;     i := i + 1 ) ; 
    var right : Sequence(long) ; right := Integer.subrange(1,n)->collect(0) ;
    right[n - 1+1] := 0 ; 
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (a[i + 1+1] > a[i+1]) then (     right[i+1] := right[i + 1+1] + a[i + 1+1] - a[i+1] ) else (     right[i+1] := right[i + 1+1] ) )  ;     i := i - 1 ) ; 
        var j : int ; j := 0 ; while j < m do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     if (s < t) then (     OclFile["System.out"].println(left[t - 1+1] - left[s - 1+1]) ) else (     OclFile["System.out"].println(right[t - 1+1] - right[s - 1+1]) ) )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countPairs(int a[],int b[],int n,int m){
    int cnt=0 ;
    HashSet<Integer>s=new HashSet<Integer>();
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        int sum=a[i]+b[j];
        if(s.contains(sum)==false){
          cnt++;
          s.add(sum);
        }
      }
    }
    return cnt ;
  }
  static public void main(String args[]){
    int a[]={
      12,2,7 };
      int n=a.length ;
      int b[]={
        4,3,8 };
        int m=b.length ;
        System.out.println(countPairs(a,b,n,m));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPairs( a : Sequence(int), b : Sequence(int), n : int, m : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var s : Set(int) ; s := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     var sum : int ; sum := a[i+1] + b[j+1] ;
     if (s->includes(sum) = false) then (     cnt := cnt + 1 ; 
     s := s->including(sum) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return cnt );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{12,2,7} ;
     var n : int ; n := a->size() ;
    var b : Sequence(int) ; b := Sequence{4,3,8} ;
    var m : int ; m := b->size() ;
    OclFile["System.out"].println(countPairs(a, b, n, m)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int largest_sum(int arr[],int n){
    int maximum=-1 ;
    HashMap<Integer,Integer>m=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      if(m.containsKey(arr[i])){
        m.put(arr[i],m.get(arr[i])+1);
      }
      else {
        m.put(arr[i],1);
      }
    }
    for(int i=0 ; i<n ; i++){
      if(m.get(arr[i])>1){
        if(m.containsKey(2*arr[i])){
          m.put(2*arr[i],m.get(2*arr[i])+m.get(arr[i])/2);
        }
        else {
          m.put(2*arr[i],m.get(arr[i])/2);
        }
        if(2*arr[i]>maximum)maximum=2*arr[i];
      }
    }
    return maximum ;
  }
  public static void main(String[] args){
    int arr[]={
      1,1,2,4,7,8 };
      int n=arr.length ;
      System.out.println(largest_sum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation largest_sum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var maximum : int ; maximum := -1 ;
     var m : Map(int,int) ; m := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (m->keys()->includes(arr[i+1])) then (     m := m->union(Map{arr[i+1] |-> m->at(arr[i+1]) + 1}) ) else (     m := m->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (m->at(arr[i+1]) > 1) then (     if (m->keys()->includes(2 * arr[i+1])) then (     m := m->union(Map{2 * arr[i+1] |-> m->at(2 * arr[i+1]) + m->at(arr[i+1]) / 2}) ) else (     m := m->union(Map{2 * arr[i+1] |-> m->at(arr[i+1]) / 2}) ) ;  
     if (2 * arr[i+1] > maximum) then     maximum := 2 * arr[i+1] ; else skip ) else skip )  ;     i := i + 1 ) ; 
    return maximum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,2,4,7,8} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(largest_sum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static boolean isEven(int[] arr){
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i] % 2!=0)return false ;
    }
    return true ;
  }
  public static boolean isOdd(int[] arr){
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i] % 2==0)return false ;
    }
    return true ;
  }
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      while(t-->0){
        int n=sc.nextInt();
        int[] arr=new int[n];
        for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
        if(isEven(arr)|| isOdd(arr))System.out.println("YES");
        else System.out.println("NO");
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation isEven( arr : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] mod 2 /= 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation isOdd( arr : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] mod 2 = 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
     if (isEven(arr) or isOdd(arr)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) ;  ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class ProblemA {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int test=Integer.parseInt(br.readLine());
    while(test-->0){
      int n=Integer.parseInt(br.readLine());
      String line[]=br.readLine().split(" ");
      int arr[]=new int[n];
      HashSet<Integer>parity=new HashSet<>();
      for(int i=0 ; i<n ; i++){
        arr[i]=Integer.parseInt(line[i]);
        parity.add(arr[i] % 2);
      }
      int count=0,count2=0 ;
      String ans="No" ;
      if(parity.size()==1)ans="Yes" ;
      sb.append(ans);
      sb.append("\n");
    }
    System.out.println(sb);
  }
  public static void sort(int arr[]){
    ArrayList<Integer>list=new ArrayList<>();
    for(int it : arr)list.add(it);
    Collections.sort(list);
    for(int i=0 ; i<list.size(); i++)arr[i]=list.get(i);
  }
}
class Pair {
  int l,r ;
  public Pair(int l,int r){
    this.l=l ;
    this.r=r ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var test : int ; test := (br.readLine())->toInteger() ;
        while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := (br.readLine())->toInteger() ;
     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var parity : Set(int) ; parity := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (line[i+1])->toInteger() ; 
     parity := parity->including(arr[i+1] mod 2) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var count2 : int ; count2 := 0 ;
    var ans : String ; ans := "No" ;
    if (parity->size() = 1) then     ans := "Yes" ; else skip ; 
    sb := sb + StringLib.newString(ans) ; 
    sb := sb + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
  static   operation sort( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     for (it : arr) do (     list := list->including(it) ;  ) ; 
     list := list->sort() ; 
         var i : int ; i := 0 ; while i < list->size() do (     arr[i+1] := list->at(i+1) ;  ;     i := i + 1 ) );
}
class Pair {
   attribute l : int;
   static operation newPair( l : int, r : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(l, r);
    return self );
  operation initialise( l : int, r : int) : void
  pre: true  post: true
  activity: (     self.l := l ; 
     self.r := r );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testCases=sc.nextInt();
    for(int i=0 ; i<testCases ; i++){
      int contador=0 ;
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int d=sc.nextInt();
      if(a<b)contador++;
      if(a<c)contador++;
      if(a<d)contador++;
      System.out.println(contador);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < testCases do ( (     var contador : int ; contador := 0 ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    if (a < b) then     contador := contador + 1 ; else skip ; 
    if (a < c) then     contador := contador + 1 ; else skip ; 
    if (a < d) then     contador := contador + 1 ; else skip ; 
    OclFile["System.out"].println(contador) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t--!=0){
      int[] arr=new int[4];
      int ans=0 ;
      for(int i=0 ; i<4 ; i++){
        arr[i]=in.nextInt();
        if(i>0 && arr[i]>arr[0])ans++;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var arr : Sequence(int) ; arr := Integer.subrange(1,4)->collect(0) ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < 4 do ( (     arr[i+1] := in.getCurrent()->toInteger() ; 
     if (i > 0 & arr[i+1] > arr[0+1]) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class cf1692A {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    int n,count ;
    for(int i=1 ; i<=t ; i++){
      n=input.nextInt();
      count=0 ;
      for(int j=1 ; j<=3 ; j++){
        if(input.nextInt()>n)count++;
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cf1692A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
     var n : int ;
    var count : int ;
         var i : int ; i := 1 ; while i <= t do ( (     n := input.getCurrent()->toInteger() ; 
     count := 0 ; 
         var j : int ; j := 1 ; while j <= 3 do ( (     if (input.getCurrent()->toInteger() > n) then     count := count + 1 ; else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(count) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] a){
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    String tmpString=null ;
    try {
      if(null!=(tmpString=bf.readLine())){
        String[] tmp=tmpString.split(" ");
        int count=tmp.length ;
        int[] numbers=new int[count];
        for(int i=0 ; i<count ; i++){
          numbers[i]=Integer.parseInt(tmp[i]);
        }
        int[] ans=quickSort(numbers);
        for(int i=0 ; i<count ; i++){
          if(i!=0)System.out.print(" ");
          System.out.print(ans[i]);
        }
        System.out.println("");
      }
    }
    catch(IOException e){
    }
  }
  private static int[] quickSort(int[] numbers){
    int count=numbers.length ;
    for(int i=0 ; i<count-1 ; i++){
      for(int j=i+1 ; j<count ; j++){
        if(numbers[i]<numbers[j]){
          int tmp=numbers[i];
          numbers[i]=numbers[j];
          numbers[j]=tmp ;
        }
      }
    }
    return numbers ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmpString : String ; tmpString := null ;
     try (     if (null /= (tmpString)) then (     var tmp : Sequence(String) ; tmp := tmpString->split(" ") ;
     var count : int ; count := tmp->size() ;
    var numbers : Sequence(int) ; numbers := Integer.subrange(1,count)->collect(0) ;
        var i : int ; i := 0 ; while i < count do ( (     numbers[i+1] := (tmp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var ans : Sequence(int) ; ans := quickSort(numbers) ;
        var i : int ; i := 0 ; while i < count do ( (     if (i /= 0) then     OclFile["System.out"].print(" ") ; else skip ; 
     OclFile["System.out"].print(ans[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
 ) else skip )   catch (e : IOException) do skip
 );
  static   operation quickSort( numbers : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var count : int ; count := numbers->size() ;
         var i : int ; i := 0 ; while i < count - 1 do ( (         var j : int ; j := i + 1 ; while j < count do ( (     if (numbers[i+1] < numbers[j+1]) then (     var tmp : int ; tmp := numbers[i+1] ;
     numbers[i+1] := numbers[j+1] ; 
     numbers[j+1] := tmp ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return numbers );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
public class Sequence {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    StringBuilder result=new StringBuilder();
    for(int i=0 ; i<t ; i++){
      int a=scan.nextInt();
      int b=scan.nextInt();
      int c=scan.nextInt();
      int d=scan.nextInt();
      int res=0 ;
      if(b>a)res++;
      if(c>a)res++;
      if(d>a)res++;
      result.append(res+"\n");
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sequence {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
    var result : String ; result := StringLib.newString() ;
        var i : int ; i := 0 ; while i < t do ( (     var a : int ; a := scan.getCurrent()->toInteger() ;
     var b : int ; b := scan.getCurrent()->toInteger() ;
    var c : int ; c := scan.getCurrent()->toInteger() ;
    var d : int ; d := scan.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
    if (b > a) then     res := res + 1 ; else skip ; 
    if (c > a) then     res := res + 1 ; else skip ; 
    if (d > a) then     res := res + 1 ; else skip ; 
    result := result + StringLib.newString(res + "\n") ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_Marathon {
  public static void main(String[] args){
    Scanner sn=new Scanner(System.in);
    int t=sn.nextInt();
    while(t-->0){
      int a=sn.nextInt();
      int b=sn.nextInt();
      int c=sn.nextInt();
      int d=sn.nextInt();
      int ans=0 ;
      if(b>a)ans++;
      if(c>a)ans++;
      if(d>a)ans++;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Marathon {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sn : OclFile ; sn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sn.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := sn.getCurrent()->toInteger() ;
     var b : int ; b := sn.getCurrent()->toInteger() ;
    var c : int ; c := sn.getCurrent()->toInteger() ;
    var d : int ; d := sn.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    if (b > a) then     ans := ans + 1 ; else skip ; 
    if (c > a) then     ans := ans + 1 ; else skip ; 
    if (d > a) then     ans := ans + 1 ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean check(int arr[],int x,int n){
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      double y=Math.sqrt(arr[i]);
      if(Math.floor(y)==Math.ceil(y)){
        sum+=arr[i];
      }
    }
    if(sum % x==0)return true ;
    else return false ;
  }
  public static void main(String[] args){
    int arr[]={
      2,3,4,9,10 };
      int n=arr.length ;
      int x=13 ;
      if(check(arr,x,n)){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation check( arr : Sequence(int), x : int, n : int) : boolean
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var y : double ; y := (arr[i+1])->sqrt() ;
     if ((y)->floor() = (y)->ceil()) then (     sum := sum+(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
     if (sum mod x = 0) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4,9,10} ;
     var n : int ; n := arr->size() ;
     var x : int ; x := 13 ;
     if (check(arr, x, n)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
public class P977B_TwoGram {
  public static void main(String[] subhani)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String s=br.readLine();
    solve(n,s);
  }
  public static void solve(int n,String s){
    HashMap<String,Integer>map=new HashMap<>();
    int max=0 ;
    String result="" ;
    for(int i=0 ; i<n-1 ; ++i){
      String t=s.substring(i,i+2);
      map.put(t,map.getOrDefault(t,0)+1);
      if(map.get(t)>max){
        result=t ;
        max=map.get(t);
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class P977B_TwoGram {
  static   operation main( subhani : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
     var s : String ; s := br.readLine() ;
     execute solve(n, s) );
  static   operation solve( n : int, s : String) : void
  pre: true
  post: true
  activity: (     var map : Map(String,int) ; map := Map{} ;
     var max : int ; max := 0 ;
    var result : String ; result := "" ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var t : String ; t := s.subrange(i+1,i + 2) ;
     map := map->union(Map{t |-> (if map->keys()->contains(t) then map->at(t) else 0 endif) + 1}) ; 
     if (map->at(t) > max) then (     result := t ; 
     max := map->at(t) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static void solve(){
    int n=sc.nextInt();
    String s=sc.next();
    HashMap<String,Integer>stringIntegerHashMap=new HashMap<>();
    for(int i=0 ; i<n-1 ; i+=1){
      stringIntegerHashMap.put(s.substring(i,i+2),stringIntegerHashMap.getOrDefault(s.substring(i,i+2),0)+1);
    }
    int max_=stringIntegerHashMap.values().stream().max(Integer :: compare).get();
    for(String key : stringIntegerHashMap.keySet()){
      if(stringIntegerHashMap.get(key)==max_){
        System.out.println(key);
        break ;
      }
    }
  }
  private static final Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var s : String ; s := sc.next() ;
    var stringIntegerHashMap : Map(String,int) ; stringIntegerHashMap := Map{} ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     stringIntegerHashMap := stringIntegerHashMap->union(Map{s.subrange(i+1,i + 2) |-> (if stringIntegerHashMap->keys()->contains(s.subrange(i+1,i + 2)) then stringIntegerHashMap->at(s.subrange(i+1,i + 2)) else 0 endif) + 1}) )  ;     i := i+(1) ) ; 
    var max_ : int ; max_ := stringIntegerHashMap->values()->max().get() ;
    for (key : stringIntegerHashMap->keys()) do ( (     if (stringIntegerHashMap->at(key) = max_) then (     OclFile["System.out"].println(key) ; 
     break ) else skip )  ) ; 
 );
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String s=in.next();
    int max=0 ;
    String c="" ;
    for(int i=0 ; i<n-1 ; i++){
      String str=s.substring(i,i+2);
      int ans=1 ;
      for(int j=i+1 ; j<n-1 ; j++){
        String ss=s.substring(j,j+2);
        if(str.equals(ss))ans++;
      }
      if(ans>max){
        max=ans ;
        c=str ;
      }
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var max : int ; max := 0 ;
    var c : String ; c := "" ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var str : String ; str := s.subrange(i+1,i + 2) ;
     var ans : int ; ans := 1 ;
         var j : int ; j := i + 1 ; while j < n - 1 do ( (     var ss : String ; ss := s.subrange(j+1,j + 2) ;
     if (str = ss) then     ans := ans + 1 ; else skip )  ;     j := j + 1 ) ; 
     if (ans > max) then (     max := ans ; 
     c := str ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.io.*;
import java.util.*;
public class CodeForces1626 {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    String s=scn.next();
    HashMap<String,Integer>map=new HashMap<>();
    for(int i=0 ; i<s.length()-1 ; i++){
      String s1=s.substring(i,i+2);
      map.put(s1,map.getOrDefault(s1,0)+1);
    }
    int max=Integer.MIN_VALUE ;
    String ans="" ;
    for(int i=0 ; i<s.length()-1 ; i++){
      String s1=s.substring(i,i+2);
      int x=map.getOrDefault(s1,0);
      if(x>max){
        max=x ;
        ans=s1 ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces1626 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var s : String ; s := scn.getCurrent() ;
    var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < s->size() - 1 do ( (     var s1 : String ; s1 := s.subrange(i+1,i + 2) ;
     map := map->union(Map{s1 |-> (if map->keys()->contains(s1) then map->at(s1) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < s->size() - 1 do ( (     var s1 : String ; s1 := s.subrange(i+1,i + 2) ;
     var x : int ; x := (if map->keys()->contains(s1) then map->at(s1) else 0 endif) ;
     if (x > max) then (     max := x ; 
     ans := s1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int dig[]={
    1,1,2,6,4,2,2,4,2,8 };
    static int lastNon0Digit(int n){
      if(n<10)return dig[n];
      if(((n/10)% 10)% 2==0)return(6*lastNon0Digit(n/5)*dig[n % 10])% 10 ;
      else return(4*lastNon0Digit(n/5)*dig[n % 10])% 10 ;
    }
    public static void main(String[] args){
      int n=14 ;
      System.out.print(lastNon0Digit(n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute dig : int := Sequence{1,1,2,6,4,2,2,4,2,8};
  static   operation lastNon0Digit( n : int) : int
  pre: true
  post: true
  activity: (     if (n < 10) then     return dig[n+1] else skip ; 
     if (((n / 10) mod 10) mod 2 = 0) then     return (6 * lastNon0Digit(n / 5) * dig[n mod 10+1]) mod 10 else     return (4 * lastNon0Digit(n / 5) * dig[n mod 10+1]) mod 10 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 14 ;
     OclFile["System.out"].print(lastNon0Digit(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ProblemSolving {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int testCases=input.nextInt();
    for(int index=1 ; index<=testCases ; index++){
      long row=input.nextLong();
      long column=input.nextLong();
      if(row==1 && column==1){
        System.out.println(0);
      }
      else if(row==column){
        System.out.println(row+column-2);
      }
      else if(row==1 && column>2 || column==1 && row>2){
        System.out.println(-1);
      }
      else if(row==column+1 || column==row+1){
        System.out.println(row+column-2);
      }
      else if(row>column){
        if((row-column)% 2==0){
          System.out.println(2*column-2+2*(row-column));
        }
        else {
          System.out.println(2*column-2+2*(row-column)-1);
        }
      }
      else if(column>row){
        if((column-row)% 2==0){
          System.out.println(2*row-2+2*(column-row));
        }
        else {
          System.out.println(2*row-2+2*(column-row)-1);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemSolving {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := input.getCurrent()->toInteger() ;
         var index : int ; index := 1 ; while index <= testCases do ( (     var row : long ; row := input.getCurrent()->toLong() ;
     var column : long ; column := input.getCurrent()->toLong() ;
     if (row = 1 & column = 1) then (     OclFile["System.out"].println(0) ) else     if (row = column) then (     OclFile["System.out"].println(row + column - 2) ) else     if (row = 1 & column > 2 or column = 1 & row > 2) then (     OclFile["System.out"].println(-1) ) else     if (row = column + 1 or column = row + 1) then (     OclFile["System.out"].println(row + column - 2) ) else     if (row > column) then (     if ((row - column) mod 2 = 0) then (     OclFile["System.out"].println(2 * column - 2 + 2 * (row - column)) ) else (     OclFile["System.out"].println(2 * column - 2 + 2 * (row - column) - 1) ) ) else     if (column > row) then (     if ((column - row) mod 2 = 0) then (     OclFile["System.out"].println(2 * row - 2 + 2 * (column - row)) ) else (     OclFile["System.out"].println(2 * row - 2 + 2 * (column - row) - 1) ) ) else skip ; ;  ;  ;  ;  )  ;     index := index + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
import java.io.*;
public class codeHundredSixty {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=input.nextInt();
      int m=input.nextInt();
      int k=Math.min(n,m);
      int l=Math.max(n,m);
      if(n==1 && m>2 || m==1 && n>2){
        System.out.println(-1);
      }
      else {
        if((l-k)% 2!=0){
          System.out.println(2*(k-1)+2*(l-k-1)+1);
        }
        else {
          System.out.println(2*(k-1)+2*(l-k));
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var m : int ; m := input.getCurrent()->toInteger() ;
    var k : int ; k := Set{n, m}->min() ;
    var l : int ; l := Set{n, m}->max() ;
    if (n = 1 & m > 2 or m = 1 & n > 2) then (     OclFile["System.out"].println(-1) ) else (     if ((l - k) mod 2 /= 0) then (     OclFile["System.out"].println(2 * (k - 1) + 2 * (l - k - 1) + 1) ) else (     OclFile["System.out"].println(2 * (k - 1) + 2 * (l - k)) ) ) ;  
 )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void FermatFactors(int n){
    if(n<=0){
      System.out.print("["+n+"] ");
      return ;
    }
    if((n & 1)==0){
      System.out.print("["+n/2.0+","+2+"] ");
      return ;
    }
    int a=(int)Math.ceil(Math.sqrt(n));
    if(a*a==n){
      System.out.print("["+a+","+a+"] ");
      return ;
    }
    int b ;
    while(true){
      int b1=a*a-n ;
      b=(int)(Math.sqrt(b1));
      if(b*b==b1)break ;
      else a+=1 ;
    }
    System.out.print("["+(a-b)+","+(a+b)+"] ");
    return ;
  }
  public static void main(String[] args){
    FermatFactors(6557);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation FermatFactors( n : int) : void
  pre: true
  post: true
  activity: (     if (n <= 0) then (     OclFile["System.out"].print("[" + n + "] ") ; 
     return ) else skip ; 
     if ((n & 1) = 0) then (     OclFile["System.out"].print("[" + n / 2.0 + "," + 2 + "] ") ; 
     return ) else skip ; 
    var a : int ; a := ((n)->sqrt())->ceil()->oclAsType(int) ;
    if (a * a = n) then (     OclFile["System.out"].print("[" + a + "," + a + "] ") ; 
     return ) else skip ; 
    var b : int ;
    while (true) do (     var b1 : int ; b1 := a * a - n ;
     b := ((b1)->sqrt())->oclAsType(int) ; 
     if (b * b = b1) then     break else     a := a+(1) ; ) ; 
    OclFile["System.out"].print("[" + (a - b) + "," + (a + b) + "] ") ; 
    return 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute FermatFactors(6557) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    read();
  }
  public static void read(){
    String vec[],line="" ;
    int cases ;
    BufferedReader buffer=new BufferedReader(new InputStreamReader(System.in));
    long n,m,rel ;
    try {
      cases=Integer.parseInt(buffer.readLine());
      for(int i=0 ; i<cases ; i++){
        line=buffer.readLine();
        vec=line.split(" ");
        n=Long.parseLong(vec[0]);
        m=Long.parseLong(vec[1]);
        if(n>m){
          n=n+m ;
          m=n-m ;
          n=n-m ;
        }
        if(m>2 && n==1)System.out.println(-1);
        else if(m==2 && n==1)System.out.println(1);
        else if(n==1 && m==1)System.out.println(0);
        else {
          rel=m-n-1 ;
          if(rel % 2==0)System.out.println(m*2-3);
          else System.out.println(m*2-2);
        }
      }
      buffer.close();
    }
    catch(NullPointerException e){
      e.printStackTrace();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute read() );
  static   operation read() : void
  pre: true
  post: true
  activity: (     var vec : Sequence(String) ;
    var line : String ; line := "" ;
     var cases : int ;
    var buffer : OclFile ; buffer := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var n : long ;
    var m : long ;
    var rel : long ;
    try (     cases := (buffer.readLine())->toInteger() ; 
         var i : int ; i := 0 ; while i < cases do ( (     line := buffer.readLine() ; 
     vec := line->split(" ") ; 
    n := (vec[0+1])->toLong() ; 
    m := (vec[1+1])->toLong() ; 
    if (n > m) then (     n := n + m ; 
     m := n - m ; 
     n := n - m ) else skip ; 
    if (m > 2 & n = 1) then     OclFile["System.out"].println(-1) else     if (m = 2 & n = 1) then     OclFile["System.out"].println(1) else     if (n = 1 & m = 1) then     OclFile["System.out"].println(0) else (     rel := m - n - 1 ; 
     if (rel mod 2 = 0) then     OclFile["System.out"].println(m * 2 - 3) ; else     OclFile["System.out"].println(m * 2 - 2) ; ) ;  ;  ;  
 )  ;     i := i + 1 ) ; 
     skip )   catch (e : NullAccessException) do (     e.printStackTrace() )
   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class PaintingEggs {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(reader.readLine());
    StringBuilder ans=new StringBuilder();
    long totalA=0 ;
    long totalG=0 ;
    long diff=0 ;
    while(n>0){
      String costs[]=reader.readLine().split(" ");
      int costA=Integer.parseInt(costs[0]);
      int costG=Integer.parseInt(costs[1]);
      if(Math.abs(totalA+costA-totalG)<Math.abs(totalG+costG-totalA)){
        totalA+=costA ;
        ans.append("A");
      }
      else {
        totalG+=costG ;
        ans.append("G");
      }
      diff=Math.abs(totalA-totalG);
      n--;
    }
    if(diff<=500)System.out.println(ans);
    else System.out.println("-1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class PaintingEggs {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (reader.readLine())->toInteger() ;
    var ans : String ; ans := StringLib.newString() ;
    var totalA : long ; totalA := 0 ;
    var totalG : long ; totalG := 0 ;
    var diff : long ; diff := 0 ;
    while (n > 0) do (     var costs : Sequence(String) ; costs := reader.readLine()->split(" ") ;
     var costA : int ; costA := (costs[0+1])->toInteger() ;
    var costG : int ; costG := (costs[1+1])->toInteger() ;
    if (if totalA + costA - totalG < 0 then -(totalA + costA - totalG) else totalA + costA - totalG endif < if totalG + costG - (totalA)->char2byte() < 0 then -(totalG + costG - (totalA)->char2byte()) else totalG + costG - (totalA)->char2byte() endif) then (     totalA := totalA+(costA) ; 
     ans := ans + StringLib.newString("A") ) else (     totalG := totalG+(costG) ; 
     ans := ans + StringLib.newString("G") ) ;  
    diff := if (totalA)->char2byte() - totalG < 0 then -((totalA)->char2byte() - totalG) else (totalA)->char2byte() - totalG endif ; 
    n := n - 1 ; 
 ) ; 
    if (diff <= 500) then     OclFile["System.out"].println(ans) else     OclFile["System.out"].println("-1") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Comparator ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<PriorityQueue<Integer>>pque=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      pque.add(new PriorityQueue<Integer>(Comparator.reverseOrder()));
    }
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      int command=sc.nextInt();
      int t=sc.nextInt();
      switch(command){
        case 0 : int x=sc.nextInt();
        pque.get(t).offer(x);
        break ;
        case 1 : if(! pque.get(t).isEmpty()){
          System.out.println(pque.get(t).peek());
        }
        break ;
        case 2 : if(! pque.get(t).isEmpty()){
          pque.get(t).poll();
        }
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var pque : Sequence(Sequence(int)) ; pque := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     pque := pque->including(Sequence{}->union(Comparator.reverseOrder())) )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var command : int ; command := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (command) ; 
       if _switchval = 0 then
     var x : int ; x := sc.getCurrent()->toInteger() ;
    pque := pque->at(t+1)->including(x) ; 
    break 
   else skip ;
       if _switchval = 1 then
     if (not(pque->at(t+1)->isEmpty())) then (     OclFile["System.out"].println(pque->at(t+1)->min()) ) else skip ; 
    break 
   else skip ;
       if _switchval = 2 then
     if (not(pque->at(t+1)->isEmpty())) then (     pque := pque->at(t+1)->sort()->tail() ) else skip ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class JavaApplication143 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    ArrayList<Integer>arrE=new ArrayList<>();
    ArrayList<Integer>arrO=new ArrayList<>();
    int num=sc.nextInt();
    if(num==1){
      System.out.println(1);
      System.out.println(1);
    }
    else if(num==2 || num==3){
      System.out.println(num-1);
      for(int i=1 ; i<=num ; i++){
        if(i % 2!=0){
          System.out.print(i+" ");
        }
      }
    }
    else if(num==4){
      System.out.println(num);
      System.out.println("3 1 4 2");
    }
    else {
      System.out.println(num);
      for(int i=1 ; i<=num ; i++){
        if(i % 2!=0){
          System.out.print(i+" ");
        }
      }
      for(int i=1 ; i<=num ; i++){
        if(i % 2==0){
          System.out.print(i+" ");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication143 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arrE : Sequence(int) ; arrE := Sequence{} ;
    var arrO : Sequence(int) ; arrO := Sequence{} ;
    var num : int ; num := sc.getCurrent()->toInteger() ;
    if (num = 1) then (     OclFile["System.out"].println(1) ; 
     OclFile["System.out"].println(1) ) else     if (num = 2 or num = 3) then (     OclFile["System.out"].println(num - 1) ; 
         var i : int ; i := 1 ; while i <= num do ( (     if (i mod 2 /= 0) then (     OclFile["System.out"].print(i + " ") ) else skip )  ;     i := i + 1 ) ) else     if (num = 4) then (     OclFile["System.out"].println(num) ; 
     OclFile["System.out"].println("3 1 4 2") ) else (     OclFile["System.out"].println(num) ; 
         var i : int ; i := 1 ; while i <= num do ( (     if (i mod 2 /= 0) then (     OclFile["System.out"].print(i + " ") ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i <= num do ( (     if (i mod 2 = 0) then (     OclFile["System.out"].print(i + " ") ) else skip )  ;     i := i + 1 ) ) ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    ArrayDeque<Integer>ans=solve(n);
    pw.println(ans.size());
    for(int i : ans)pw.print(i+" ");
    pw.close();
  }
  static ArrayDeque<Integer>solve(int n){
    ArrayDeque<Integer>ans=new ArrayDeque<>();
    if(n==1 || n==2){
      ans.add(1);
      return ans ;
    }
    if(n==3){
      ans.add(1);
      ans.add(3);
      return ans ;
    }
    ans.add(1);
    int itr=0 ;
    while(true){
      if(n==1)break ;
      if(itr % 2==0){
        ans.addLast(n);
      }
      else ans.addFirst(n);
      n--;
      itr++;
    }
    return ans ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var ans : Sequence(int) ; ans := solve(n) ;
    skip ; 
    for (i : ans) do (     skip ;  ) ; 
    skip ; 
 );
  static   operation solve( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := ArrayDeque<OclAny>.newArrayDeque() ;
     if (n = 1 or n = 2) then (     ans := ans->including(1) ; 
     return ans ) else skip ; 
    if (n = 3) then (     ans := ans->including(1) ; 
     ans := ans->including(3) ; 
     return ans ) else skip ; 
    ans := ans->including(1) ; 
    var itr : int ; itr := 0 ;
    while (true) do (     if (n = 1) then     break else skip ; 
     if (itr mod 2 = 0) then (     ans := ans->append(n) ) else     ans := ans->prepend(n) ; ;  
     n := n - 1 ; 
     itr := itr + 1 ) ; 
    return ans 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class A_Exam {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=Integer.parseInt(sc.next());
    if(t==1 || t==2){
      System.out.println(1);
      System.out.println(1);
    }
    else if(t==3){
      System.out.println(2);
      System.out.println(3+" "+1);
    }
    else {
      System.out.println(t);
      for(int i=t-1 ; i>0 ; i-=2){
        System.out.print(i+" ");
      }
      for(int i=t ; i>0 ; i-=2){
        System.out.print(i+" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Exam {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := (sc.getCurrent())->toInteger() ;
     if (t = 1 or t = 2) then (     OclFile["System.out"].println(1) ; 
     OclFile["System.out"].println(1) ) else     if (t = 3) then (     OclFile["System.out"].println(2) ; 
     OclFile["System.out"].println(3 + " " + 1) ) else (     OclFile["System.out"].println(t) ; 
         var i : int ; i := t - 1 ; while i > 0 do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i-(2) ) ; 
         var i : int ; i := t ; while i > 0 do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i-(2) ) ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.stream.LongStream ;
import java.util.function.Predicate ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    DWidespread solver=new DWidespread();
    solver.solve(1,in,out);
    out.close();
  }
  static class DWidespread {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      long n=in.nextInt(),a=in.nextInt(),b=in.nextInt();
      long[] h=LongStream.range(0,n).map(x->in.nextInt()).toArray();
      Predicate<Long>p=k->Arrays.stream(h).map(i->i-b*k).filter(i->i>0).map(i->(i+a-b-1)/(a-b)).sum()<=k ;
      long min=0,max=1000_000_000 ;
      while(max-min>1){
        long mid=(min+max)/2 ;
        if(p.test(mid)){
          max=mid ;
        }
        else {
          min=mid ;
        }
      }
      out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : DWidespread ; solver := DWidespread.newDWidespread() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class DWidespread {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : long ; n := in.getCurrent()->toInteger() ;
    var a : long ; a := in.getCurrent()->toInteger() ;
    var b : long ; b := in.getCurrent()->toInteger() ;
     var h : Sequence(long) ; h := Integer.subrange(0, n-1)->collect( _x1 | (lambda x : OclAny in in.getCurrent()->toInteger())->apply(_x1) )->asSequence() ;
    var p : Function(<long>,boolean) ; p := lambda k : OclAny in stream(h)->collect( _x1 | (lambda i : OclAny in i - b * k)->apply(_x1) )->select( _x1 | (lambda i : OclAny in i > 0)->apply(_x1) )->collect( _x1 | (lambda i : OclAny in (i + a - b - 1) / (a - b))->apply(_x1) )->sum() <= k ;
    var min : long ; min := 0 ;
    var max : long ; max := 1000_000_000 ;
    while (max - min > 1) do (     var mid : long ; mid := (min + max) / 2 ;
     if (p->apply(mid)) then (     max := mid ) else (     min := mid ) ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main extends PrintWriter {
  Main(){
    super(System.out,true);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    Main o=new Main();
    o.main();
    o.flush();
  }
  void main(){
    int n=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=a-b ;
    int[] aa=new int[n];
    for(int i=0 ; i<n ; i++)aa[i]=sc.nextInt();
    int lower=0,upper=1000000000 ;
    while(upper-lower>1){
      int k=(lower+upper)/2 ;
      long x=0 ;
      for(int i=0 ; i<n ; i++){
        long d=aa[i]-(long)b*k ;
        if(d>0)x+=(d+c-1)/c ;
      }
      if(x<=k)upper=k ;
      else lower=k ;
    }
    println(upper);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends OclFile {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"], true) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : Main ; o := Main.newMain() ;
     o.main() ; 
     o.flush() );
   operation main() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := a - b ;
    var aa : Sequence(int) ; aa := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     aa[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var lower : int ; lower := 0 ;
    var upper : int ; upper := 1000000000 ;
    while (upper - lower > 1) do (     var k : int ; k := (lower + upper) / 2 ;
     var x : long ; x := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var d : long ; d := aa[i+1] - b->oclAsType(long) * k ;
     if (d > 0) then     x := x+((d + c - 1) / c) ; else skip )  ;     i := i + 1 ) ; 
     if (x <= k) then     upper := k ; else     lower := k ; ) ; 
    execute println(upper) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static boolean enough(long a,long b,long[] enemyTairyoku,long t){
    long count=0 ;
    for(int i=0 ; i<enemyTairyoku.length ; i++){
      if(enemyTairyoku[i]>b*t){
        count+=(int)Math.ceil((enemyTairyoku[i]-b*t)/((double)a-b));
      }
    }
    return count<=t ;
  }
  public static long calcMinAttackNum(long a,long b,long[] enemyTairyoku){
    long min=0 ;
    long max=1000000000 ;
    while(min+1<max){
      long c=(min+max)/2 ;
      if(enough(a,b,enemyTairyoku,c)){
        max=c ;
      }
      else {
        min=c ;
      }
    }
    return min==max ? min+1 : max ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long a=sc.nextInt();
    long b=sc.nextInt();
    long[] enemyTairyoku=new long[n];
    for(int i=0 ; i<enemyTairyoku.length ; i++)enemyTairyoku[i]=sc.nextInt();
    sc.close();
    System.out.println(calcMinAttackNum(a,b,enemyTairyoku));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation enough( a : long, b : long, enemyTairyoku : Sequence(long), t : long) : boolean
  pre: true
  post: true
  activity: (     var count : long ; count := 0 ;
         var i : int ; i := 0 ; while i < enemyTairyoku->size() do ( (     if (enemyTairyoku[i+1] > b * t) then (     count := count+(((enemyTairyoku[i+1] - b * t) / (a->oclAsType(double) - b))->ceil()->oclAsType(int)) ) else skip )  ;     i := i + 1 ) ; 
     return count <= t );
  static   operation calcMinAttackNum( a : long, b : long, enemyTairyoku : Sequence(long)) : long
  pre: true
  post: true
  activity: (     var min : long ; min := 0 ;
     var max : long ; max := 1000000000 ;
     while (min + 1 < max) do (     var c : long ; c := (min + max) / 2 ;
     if (enough(a, b, enemyTairyoku, c)) then (     max := c ) else (     min := c ) ) ; 
     return if min = max then min + 1 else max endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : long ; a := sc.getCurrent()->toInteger() ;
    var b : long ; b := sc.getCurrent()->toInteger() ;
    var enemyTairyoku : Sequence(long) ; enemyTairyoku := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < enemyTairyoku->size() do (     enemyTairyoku[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(calcMinAttackNum(a, b, enemyTairyoku)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  static int N ;
  static long A,B ;
  static Long[] h ;
  public static void main(String[] args){
    Scanner io=new Scanner(System.in);
    N=io.nextInt();
    A=io.nextLong();
    B=io.nextLong();
    h=new Long[N];
    for(int i=0 ; i<N ; i++){
      h[i]=io.nextLong();
    }
    Arrays.sort(h,Collections.reverseOrder());
    Long ansMin=h[0]/A+((h[0] % A==0)? 0 : 1)-1 ;
    Long ansMax=h[0]/B+((h[0] % B==0)? 0 : 1);
    System.out.println(ans(ansMin,ansMax));
  }
  public static long ans(long min,long max){
    if(max-min<=1)return max ;
    long cand=(min+max)/2 ;
    if(possible(cand,cand,0))return ans(min,cand);
    else return ans(cand,max);
  }
  public static boolean possible(long count,long maxA,int i){
    if(i>=N)return true ;
    long num=h[i]-B*(count-maxA);
    if(A*maxA<num)return false ;
    if(B*maxA>=num)return true ;
    long nextMaxA=(A*maxA-num)/(A-B);
    return possible(count,nextMaxA,i+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute A : long;
  static   attribute h : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := io.getCurrent()->toInteger() ; 
    A := io.getCurrent()->toLong() ; 
    B := io.getCurrent()->toLong() ; 
    h := Integer.subrange(1,N)->collect(null) ; 
        var i : int ; i := 0 ; while i < N do ( (     h[i+1] := io.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    h := OclComparator.sortWith(h, reverseOrder()) ; 
    var ansMin : long ; ansMin := h[0+1] / A + (if (h[0+1] mod A = 0) then 0 else 1 endif) - 1 ;
    var ansMax : long ; ansMax := h[0+1] / B + (if (h[0+1] mod B = 0) then 0 else 1 endif) ;
    OclFile["System.out"].println(ans(ansMin, ansMax)) ; 
 );
  static   operation ans( min : long, max : long) : long
  pre: true
  post: true
  activity: (     if (max - min <= 1) then     return max else skip ; 
     var cand : long ; cand := (min + max) / 2 ;
     if (possible(cand, cand, 0)) then     return ans(min, cand) else     return ans(cand, max) );
  static   operation possible( count : long, maxA : long, i : int) : boolean
  pre: true
  post: true
  activity: (     if (i >= N) then     return true else skip ; 
     var num : long ; num := h[i+1] - B * (count - maxA) ;
    if (A * maxA < num) then     return false else skip ; 
    if (B * maxA >= num) then     return true else skip ; 
    var nextMaxA : long ; nextMaxA := (A * maxA - num) / (A - B) ;
    return possible(count, nextMaxA, i + 1) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  static FastScanner in=new FastScanner();
  static PrintWriter out=new PrintWriter(System.out);
  public static long gcd(long a,long b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  public static void main(String[] args){
    long l=in.nextLong(),r=in.nextLong();
    long a=l,b=l+1,c=l+2 ;
    if(c>r)out.println(-1);
    else {
      while(a<=r-2){
        long temp=1 ;
        while(c<=r &&(temp=gcd(a,c))==1)c++;
        if(gcd(b,c)==1 && temp!=1)break ;
        a++;
        b++;
        c=a+1 ;
      }
      if(a<=r-2)out.println(a+" "+b+" "+c);
      else out.println(-1);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   attribute in : FastScanner := FastScanner.newFastScanner();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : long ; l := in.nextLong() ;
    var r : long ; r := in.nextLong() ;
     var a : long ; a := l ;
    var b : long ; b := l + 1 ;
    var c : long ; c := l + 2 ;
     if (c > r) then     skip else (     while (a <= r - 2) do (     var temp : long ; temp := 1 ;
         temp := gcd(a, c) ;
    while (c <= r & (temp) = 1) do (    skip ;     c := c + 1 ; ;     temp := gcd(a, c) ;
 ) ;  
    if (gcd(b, c) = 1 & temp /= 1) then     break else skip ; 
    a := a + 1 ; 
    b := b + 1 ; 
    c := a + 1 ; 
 ) ; 
     if (a <= r - 2) then     skip ; else     skip ; ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    ArrayList<String>stack=new ArrayList<String>();
    ArrayList<String>ans=new ArrayList<String>();
    String data=null ;
    while(true){
      StringTokenizer st=new StringTokenizer(br.readLine()," ");
      String command=st.nextToken();
      if(command.equals("quit")){
        break ;
      }
      if(command.equals("push")){
        stack.add(st.nextToken());
      }
      else {
        ans.add(stack.get(stack.size()-1));
        stack.remove(stack.size()-1);
      }
    }
    for(String a : ans){
      System.out.println(a);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var stack : Sequence(String) ; stack := Sequence{} ;
    var ans : Sequence(String) ; ans := Sequence{} ;
    var data : String ; data := null ;
    while (true) do (     var st : OclIterator ; st := OclIterator.newOclIterator_String_String(br.readLine(), " ") ;
     var command : String ; command := st.next() ;
     if (command = "quit") then (     break ) else skip ; 
     if (command = "push") then (     stack := stack->including(st.next()) ) else (     ans := ans->including(stack->at(stack->size() - 1+1)) ; 
     stack := stack->excludingFirst(stack->size() - 1) ) ) ; 
    for (a : ans) do ( (     OclFile["System.out"].println(a) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Array ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long n=in.nextLong();
    long r=in.nextLong();
    long l=r ;
    if(n % 2!=0){
      n+=1 ;
    }
    if(Math.abs(n-r)<2){
      System.out.println("-1");
    }
    else {
      System.out.println(n+" "+(n+1)+" "+(n+2));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := in.getCurrent()->toLong() ;
    var r : long ; r := in.getCurrent()->toLong() ;
    var l : long ; l := r ;
    if (n mod 2 /= 0) then (     n := n+(1) ) else skip ; 
    if (if n - r < 0 then -(n - r) else n - r endif < 2) then (     OclFile["System.out"].println("-1") ) else (     OclFile["System.out"].println(n + " " + (n + 1) + " " + (n + 2)) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    long n=input.nextLong();
    long m=input.nextLong();
    long c=0 ;
    if(n % 2==0){
      if(n+2<=m)System.out.println(n+" "+(n+1)+" "+(n+2));
      else System.out.println(-1);
    }
    else {
      if((n+1)>n &&(n+3)<=m)System.out.println((n+1)+" "+(n+2)+" "+(n+3));
      else System.out.println(-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := input.getCurrent()->toLong() ;
    var m : long ; m := input.getCurrent()->toLong() ;
    var c : long ; c := 0 ;
    if (n mod 2 = 0) then (     if (n + 2 <= m) then     OclFile["System.out"].println(n + " " + (n + 1) + " " + (n + 2)) ; else     OclFile["System.out"].println(-1) ; ) else (     if ((n + 1) > n & (n + 3) <= m) then     OclFile["System.out"].println((n + 1) + " " + (n + 2) + " " + (n + 3)) ; else     OclFile["System.out"].println(-1) ; ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Ahmedd {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long l=in.nextLong();
    long r=in.nextLong();
    if((l % 2)!=0)l++;
    if((Math.abs(l-r))<2)System.out.print("-1");
    else System.out.print(l+" "+(l+1)+" "+(l+2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ahmedd {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : long ; l := in.getCurrent()->toLong() ;
    var r : long ; r := in.getCurrent()->toLong() ;
    if ((l mod 2) /= 0) then     l := l + 1 ; else skip ; 
    if ((if l - r < 0 then -(l - r) else l - r endif) < 2) then     OclFile["System.out"].print("-1") else     OclFile["System.out"].print(l + " " + (l + 1) + " " + (l + 2)) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long l=in.nextLong(),r=in.nextLong();
    if(l % 2!=0)l++;
    if(Math.abs(l-r)<2)System.out.println("-1");
    else System.out.println(l+" "+(l+1)+" "+(l+2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : long ; l := in.getCurrent()->toLong() ;
    var r : long ; r := in.getCurrent()->toLong() ;
     if (l mod 2 /= 0) then     l := l + 1 ; else skip ; 
     if (if l - r < 0 then -(l - r) else l - r endif < 2) then     OclFile["System.out"].println("-1") ; else     OclFile["System.out"].println(l + " " + (l + 1) + " " + (l + 2)) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minSteps(int arr[],int n){
    boolean[] v=new boolean[n];
    Queue<Integer>q=new LinkedList<>();
    q.add(0);
    int depth=0 ;
    while(q.size()>0){
      int x=q.size();
      while(x-->0){
        int i=q.peek();
        q.poll();
        if(v[i])continue ;
        if(i==n-1)return depth ;
        v[i]=true ;
        if(i+arr[i]<n)q.add(i+arr[i]);
        if(i-arr[i]>=0)q.add(i-arr[i]);
      }
      depth++;
    }
    return-1 ;
  }
  public static void main(String[] args){
    int arr[]={
      1,1,1,1,1,1 };
      int n=arr.length ;
      System.out.println(minSteps(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minSteps( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var v : Sequence(boolean) ; v := Integer.subrange(1,n)->collect(false) ;
     var q : Sequence(int) ; q := Sequence{} ;
    q := q->including(0) ; 
    var depth : int ; depth := 0 ;
    while (q->size() > 0) do (     var x : int ; x := q->size() ;
         while (x > 0) do (        x := x - 1 ;     skip ; (     var i : int ; i := q->min() ;
     q := q->sort()->tail() ; 
    if (v[i+1]) then     continue else skip ; 
    if (i = n - 1) then     return depth else skip ; 
    v[i+1] := true ; 
    if (i + arr[i+1] < n) then     q := q->including(i + arr[i+1]) ; else skip ; 
    if (i - arr[i+1] >= 0) then     q := q->including(i - arr[i+1]) ; else skip ; 
 ) ;  ) ;  
     depth := depth + 1 ) ; 
    return -1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,1,1,1,1} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minSteps(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isEven(int n){
    if((n ^ 1)==n+1)return true ;
    else return false ;
  }
  public static void main(String[] args){
    int n=100 ;
    System.out.print(isEven(n)==true ? "Even" : "Odd");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isEven( n : int) : boolean
  pre: true
  post: true
  activity: (     if ((n xor 1) = n + 1) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 100 ;
     OclFile["System.out"].print(if isEven(n) = true then "Even" else "Odd" endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static boolean isEven(int n){
    if((n & 1)==0)return true ;
    else return false ;
  }
  public static void main(String[] args){
    int n=101 ;
    if(isEven(n)==true)System.out.print("Even");
    else System.out.print("Odd");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isEven( n : int) : boolean
  pre: true
  post: true
  activity: (     if ((n & 1) = 0) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 101 ;
     if (isEven(n) = true) then     OclFile["System.out"].print("Even") ; else     OclFile["System.out"].print("Odd") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static boolean isEven(int n){
    return(n % 2==0);
  }
  public static void main(String[] args){
    int n=101 ;
    if(isEven(n)==true)System.out.print("Even");
    else System.out.print("Odd");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isEven( n : int) : boolean
  pre: true
  post: true
  activity: (     return (n mod 2 = 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 101 ;
     if (isEven(n) = true) then     OclFile["System.out"].print("Even") ; else     OclFile["System.out"].print("Odd") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isEven(int n){
    return((n & 1)!=1);
  }
  public static void main(String[] args){
    int n=101 ;
    System.out.print(isEven(n)==true ? "Even" : "Odd");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isEven( n : int) : boolean
  pre: true
  post: true
  activity: (     return ((n & 1) /= 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 101 ;
     OclFile["System.out"].print(if isEven(n) = true then "Even" else "Odd" endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Problem1 {
  public static void main(String[] args)throws IOException {
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int t=Integer.parseInt(f.readLine());
    while(t-->0){
      int n=Integer.parseInt(f.readLine());
      ArrayList<String>strs=new ArrayList<String>();
      for(int i=0 ; i<n ; i++){
        strs.add(f.readLine());
      }
      int cnt=0 ;
      for(int i=0 ; i<n ; i++){
        boolean repeat=false ;
        for(int j=i+1 ; j<n ; j++){
          if(strs.get(i).equals(strs.get(j))){
            repeat=true ;
            break ;
          }
        }
        if(repeat){
          cnt++;
          boolean[] digits=new boolean[10];
          for(int j=0 ; j<n ; j++){
            digits[(strs.get(j).charAt(0))-'0']=true ;
          }
          for(int j=0 ; j<10 ; j++){
            if(! digits[j]){
              String nstr=""+(char)(j+'0')+strs.get(i).substring(1);
              strs.set(i,nstr);
              break ;
            }
          }
        }
      }
      out.println(cnt);
      for(int i=0 ; i<n ; i++){
        out.println(strs.get(i));
      }
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var t : int ; t := (f.readLine())->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := (f.readLine())->toInteger() ;
     var strs : Sequence(String) ; strs := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     strs := strs->including(f.readLine()) )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var repeat : boolean ; repeat := false ;
         var j : int ; j := i + 1 ; while j < n do ( (     if (strs->at(i+1) = strs->at(j+1)) then (     repeat := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (repeat) then (     cnt := cnt + 1 ; 
     var digits : Sequence(boolean) ; digits := Integer.subrange(1,10)->collect(false) ;
         var j : int ; j := 0 ; while j < n do ( (     digits[(strs->at(j+1)->at(0+1)) - ('0')->char2byte()+1] := true )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < 10 do ( (     if (not(digits[j+1])) then (     var nstr : String ; nstr := "" + (j + '0')->oclAsType(String) + strs->at(i+1).subrange(1+1,1) ;
     strs := strs.setAt(i+1,nstr) ; 
     break ) else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
        var i : int ; i := 0 ; while i < n do ( (     skip )  ;     i := i + 1 ) ; 
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Deque ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.Stack ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      ArrayList<PriorityQueue<Integer>>PQ=new ArrayList<>();
      int n=sc.nextInt();
      for(int i=0 ; i<n ; i++){
        PQ.add(new PriorityQueue<Integer>(Collections.reverseOrder()));
      }
      int qn=sc.nextInt();
      for(int i=0 ; i<qn ; i++){
        int q=sc.nextInt();
        switch(q){
          case 0 : {
            int t=sc.nextInt();
            int x=sc.nextInt();
            PQ.get(t).add(x);
            break ;
          }
          case 1 : {
            int t=sc.nextInt();
            if(! PQ.get(t).isEmpty()){
              System.out.println(PQ.get(t).peek());
            }
            break ;
          }
          case 2 : {
            int t=sc.nextInt();
            if(! PQ.get(t).isEmpty()){
              PQ.get(t).remove();
            }
            break ;
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var PQ : Sequence(Sequence(int)) ; PQ := Sequence{} ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     PQ := PQ->including(Sequence{}->union(reverseOrder())) )  ;     i := i + 1 ) ; 
    var qn : int ; qn := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < qn do ( (     var q : int ; q := sc.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (q) ; 
       if _switchval = 0 then
 (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     PQ->at(t+1)->excludes(x) ; 
     break ) 
   else skip ;
       if _switchval = 1 then
 (     var t : int ; t := sc.getCurrent()->toInteger() ;
     if (not(PQ->at(t+1)->isEmpty())) then (     OclFile["System.out"].println(PQ->at(t+1)->min()) ) else skip ; 
     break ) 
   else skip ;
       if _switchval = 2 then
 (     var t : int ; t := sc.getCurrent()->toInteger() ;
     if (not(PQ->at(t+1)->isEmpty())) then (     PQ := PQ->at(t+1).remove() ) else skip ; 
     break ) 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(){
    java.util.Stack<String>lis=new java.util.Stack<String>();
    java.util.Scanner sc=new java.util.Scanner(System.in);
    for(; ; ){
      final String cmd=sc.next();
      if(cmd.equals("push")){
        lis.push(sc.next());
      }
      else if(cmd.equals("pop")){
        System.out.println(lis.pop());
      }
      else {
        break ;
      }
    }
    return ;
  }
  public static void main(String[] args){
(new Main()).run();
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var lis : Stack<String> ; lis := Stack<String>.newStack() ;
     var sc : Scanner ; sc := Scanner.newScanner(OclFile["System.in"]) ;
       while true do ( (     var cmd : String ; cmd := sc.next() ;
     if (cmd = "push") then (     lis := lis->append(sc.next()) ) else     if (cmd = "pop") then (     OclFile["System.out"].println(lis->last()) ) else (     break ) ;  )  ) ; 
     return );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run() ; 
     return );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class EdB {
  public static void main(String[] args)throws Exception {
    int num=998244353 ;
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    int t=Integer.parseInt(bf.readLine());
    for(int i=0 ; i<t ; i++){
      Map<String,Integer>map=new HashMap<String,Integer>();
      Set<String>seen=new HashSet<String>();
      Set<String>seen1=new HashSet<String>();
      Set<Integer>seendigits=new HashSet<Integer>();
      Queue<String>q=new LinkedList<String>();
      int n=Integer.parseInt(bf.readLine());
      for(int j=0 ; j<n ; j++){
        String a=bf.readLine().trim();
        q.add(a);
        seen.add(a);
        if(! map.containsKey(a)){
          map.put(a,1);
        }
        else {
          map.put(a,map.get(a)+1);
        }
      }
      int sum=0 ;
      for(String j : map.keySet()){
        sum+=(map.get(j)-1);
        seendigits.add(Integer.parseInt(j.charAt(j.length()-1)+""));
      }
      out.println(sum);
      while(! q.isEmpty()){
        String j=q.remove();
        if(! seen1.contains(j)){
          out.println(j);
          seen1.add(j);
        }
        else {
          int digit=Integer.parseInt(j.charAt(j.length()-1)+"");
          while(seendigits.contains(digit)){
            digit+=1 ;
            digit %=10 ;
          }
          out.println(j.substring(0,3)+digit);
          seendigits.add(digit);
        }
      }
    }
    out.println();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class EdB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : int ; num := 998244353 ;
     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := (bf.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < t do ( (     var map : Map(String,int) ; map := Map{} ;
     var seen : Set(String) ; seen := Set{} ;
    var seen1 : Set(String) ; seen1 := Set{} ;
    var seendigits : Set(int) ; seendigits := Set{} ;
    var q : Sequence(String) ; q := Sequence{} ;
    var n : int ; n := (bf.readLine())->toInteger() ;
        var j : int ; j := 0 ; while j < n do ( (     var a : String ; a := bf.readLine()->trim() ;
     q := q->including(a) ; 
     seen := seen->including(a) ; 
     if (not(map->keys()->includes(a))) then (     map := map->union(Map{a |-> 1}) ) else (     map := map->union(Map{a |-> map->at(a) + 1}) ) )  ;     j := j + 1 ) ; 
    var sum : int ; sum := 0 ;
    for (j : map->keys()) do ( (     sum := sum+((map->at(j) - 1)) ; 
     seendigits := seendigits->including((j->at(j->size() - 1+1) + "")->toInteger()) )  ) ; 
    skip ; 
    while (not(q->isEmpty())) do (     var j : String ; j := q.remove() ;
     if (not(seen1->includes(j))) then (     skip ; 
     seen1 := seen1->including(j) ) else (     var digit : int ; digit := (j->at(j->size() - 1+1) + "")->toInteger() ;
     while (seendigits->includes(digit)) do (     digit := digit+(1) ; 
     digit := digit mod 10 ) ; 
     skip ; 
     seendigits := seendigits->including(digit) ) ) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=s.nextInt();
      int b=a[0] % 10 ;
      int sum=0 ;
      for(int i=1 ; i<n ; i++){
        boolean bl=false ;
        int c=a[i] % 10 ;
        for(int j=0 ; j<n ; j++){
          if(i==j)continue ;
          if(a[i]==a[j]){
            j=-1 ;
            a[i]++;
            c++;
            bl=true ;
            if(c>9){
              c=0 ;
              a[i]=a[i]-10 ;
            }
          }
        }
        if(bl)sum++;
      }
      System.out.println(sum);
      for(int i=0 ; i<a.length ; i++)System.out.printf("%04d\n",a[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := s.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var b : int ; b := a[0+1] mod 10 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     var bl : boolean ; bl := false ;
     var c : int ; c := a[i+1] mod 10 ;
         var j : int ; j := 0 ; while j < n do ( (     if (i = j) then     continue else skip ; 
     if (a[i+1] = a[j+1]) then (     j := -1 ; 
     a[i+1] := a[i+1] + 1 ; 
    c := c + 1 ; 
    bl := true ; 
    if (c > 9) then (     c := 0 ; 
     a[i+1] := a[i+1] - 10 ) else skip ; 
 ) else skip )  ;     j := j + 1 ) ; 
     if (bl) then     sum := sum + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
        var i : int ; i := 0 ; while i < a->size() do (     OclFile["System.out"].printf("%04d\n", a[i+1]) ;  ;     i := i + 1 ) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSubstring(String S,int n){
    int ans=0 ;
    int i=0 ;
    while(i<n){
      int cnt0=0,cnt1=0 ;
      if(S.charAt(i)=='0'){
        while(i<n && S.charAt(i)=='0'){
          cnt0++;
          i++;
        }
        int j=i ;
        while(j<n && S.charAt(j)=='1'){
          cnt1++;
          j++;
        }
      }
      else {
        while(i<n && S.charAt(i)=='1'){
          cnt1++;
          i++;
        }
        int j=i ;
        while(j<n && S.charAt(j)=='0'){
          cnt0++;
          j++;
        }
      }
      ans+=Math.min(cnt0,cnt1);
    }
    return ans ;
  }
  static public void main(String args[]){
    String S="0001110010" ;
    int n=S.length();
    System.out.println(countSubstring(S,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSubstring( S : String, n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var i : int ; i := 0 ;
     while (i < n) do (     var cnt0 : int ; cnt0 := 0 ;
    var cnt1 : int ; cnt1 := 0 ;
     if (S->at(i+1) = '0') then (     while (i < n & S->at(i+1) = '0') do (     cnt0 := cnt0 + 1 ; 
     i := i + 1 ) ; 
     var j : int ; j := i ;
     while (j < n & S->at(j+1) = '1') do (     cnt1 := cnt1 + 1 ; 
     j := j + 1 ) ) else (     while (i < n & S->at(i+1) = '1') do (     cnt1 := cnt1 + 1 ; 
     i := i + 1 ) ; 
     var j : int ; j := i ;
     while (j < n & S->at(j+1) = '0') do (     cnt0 := cnt0 + 1 ; 
     j := j + 1 ) ) ;  
     ans := ans+(Set{cnt0, cnt1}->min()) ) ; 
     return ans );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := "0001110010" ;
     var n : int ; n := S->size() ;
     OclFile["System.out"].println(countSubstring(S, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public boolean canConstruct(String ransomNote,String magazine){
    int[] table=new int[128];
    for(char c : magazine.toCharArray())table[c]++;
    for(char c : ransomNote.toCharArray())if(--table[c]<0)return false ;
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation canConstruct( ransomNote : String, magazine : String) : boolean
  pre: true
  post: true
  activity: (     var table : Sequence(int) ; table := Integer.subrange(1,128)->collect(0) ;
     for (c : magazine->characters()) do (     table[c+1] := table[c+1] + 1 ;  ) ; 
     for (c : ransomNote->characters()) do (     if ((table[c+1] - 1) < 0) then     return false else skip ;  ) ; 
     return true );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int lis(int arr[],int n){
    int result=0 ;
    int[] lis=new int[n];
    for(int i=0 ; i<n ; i++)lis[i]=1 ;
    for(int i=1 ; i<n ; i++)for(int j=0 ; j<i ; j++)if(arr[i]>arr[j] && lis[i]<lis[j]+1)lis[i]=lis[j]+1 ;
    for(int i=0 ; i<n ; i++)if(result<lis[i])result=lis[i];
    return result ;
  }
  static int minimumNumberOfDeletions(int arr[],int n){
    int len=lis(arr,n);
    return(n-len);
  }
  public static void main(String[] args){
    int arr[]={
      30,40,2,5,1,7,45,50,8 };
      int n=arr.length ;
      System.out.println("Minimum number of"+" deletions="+minimumNumberOfDeletions(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation lis( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var lis : Sequence(int) ; lis := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     lis[i+1] := 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do (         var j : int ; j := 0 ; while j < i do (     if (arr[i+1] > arr[j+1] & lis[i+1] < lis[j+1] + 1) then     lis[i+1] := lis[j+1] + 1 ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     if (result < lis[i+1]) then     result := lis[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation minimumNumberOfDeletions( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var len : int ; len := lis(arr, n) ;
     return (n - len) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{30,40,2,5,1,7,45,50,8} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("Minimum number of" + " deletions=" + minimumNumberOfDeletions(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int X=scan.nextInt();
    long[] x=new long[n+1];
    for(int i=0 ; i<n ; i++){
      x[i]=scan.nextLong();
    }
    x[n]=X ;
    Arrays.sort(x);
    if(x.length==2){
      System.out.println(x[1]-x[0]);
      return ;
    }
    long[] s=new long[n];
    for(int i=0 ; i<n ; i++){
      s[i]=x[i+1]-x[i];
    }
    long g=0 ;
    if(s[1]>=s[0]){
      g=gcd(s[1],s[0]);
    }
    else {
      g=gcd(s[0],s[1]);
    }
    for(int i=1 ; i<n-1 ; i++){
      g=gcd(g,s[i+1]);
    }
    System.out.println(g);
  }
  public static long gcd(long a,long b){
    if(b==0){
      return a ;
    }
    return gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var X : int ; X := scan.getCurrent()->toInteger() ;
    var x : Sequence(long) ; x := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := scan.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    x[n+1] := X ; 
    x := x->sort() ; 
    if (x->size() = 2) then (     OclFile["System.out"].println(x[1+1] - x[0+1]) ; 
     return ) else skip ; 
    var s : Sequence(long) ; s := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := x[i + 1+1] - x[i+1] )  ;     i := i + 1 ) ; 
    var g : long ; g := 0 ;
    if (s[1+1] >= s[0+1]) then (     g := gcd(s[1+1], s[0+1]) ) else (     g := gcd(s[0+1], s[1+1]) ) ;  
        var i : int ; i := 1 ; while i < n - 1 do ( (     g := gcd(g, s[i + 1+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(g) ; 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else skip ; 
     return gcd(b, a mod b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] strs=br.readLine().split(" ");
    int n=Integer.parseInt(strs[0]);
    int ref=Integer.parseInt(strs[1]);
    strs=br.readLine().split(" ");
    int[] px=new int[n];
    for(int i=0 ; i<n ; i++){
      px[i]=Math.abs(Integer.parseInt(strs[i])-ref);
    }
    int res=px[0];
    for(int i=0 ; i<px.length ; i++){
      int a=(px[i]>res)? px[i] : res ;
      int b=(px[i]>res)? res : px[i];
      while(a % b!=0){
        int buff=b ;
        b=a % b ;
        a=buff ;
      }
      res=b ;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var strs : Sequence(String) ; strs := br.readLine()->split(" ") ;
    var n : int ; n := (strs[0+1])->toInteger() ;
    var ref : int ; ref := (strs[1+1])->toInteger() ;
    strs := br.readLine()->split(" ") ; 
    var px : Sequence(int) ; px := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     px[i+1] := if (strs[i+1])->toInteger() - ref < 0 then -((strs[i+1])->toInteger() - ref) else (strs[i+1])->toInteger() - ref endif )  ;     i := i + 1 ) ; 
    var res : int ; res := px[0+1] ;
        var i : int ; i := 0 ; while i < px->size() do ( (     var a : int ; a := if (px[i+1] > res) then px[i+1] else res endif ;
     var b : int ; b := if (px[i+1] > res) then res else px[i+1] endif ;
     while (a mod b /= 0) do (     var buff : int ; buff := b ;
     b := a mod b ; 
     a := buff ) ; 
     res := b )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main implements Runnable {
  private static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Thread(null,new Main(),"",128*1024*1024).start();
  }
  public void run(){
    int n=sc.nextInt(),x=sc.nextInt();
    int[] c=new int[n+1];
    for(int i=0 ; i<n ; i++){
      c[i]=sc.nextInt();
    }
    c[n]=x ;
    c=sortDescending(c);
    int[] diff=new int[n];
    for(int i=0 ; i<n ; i++){
      diff[i]=c[i]-c[i+1];
    }
    System.out.println(gcd(diff));
  }
  private static int gcd(int[] c){
    return Arrays.stream(c).mapToObj(BigInteger :: valueOf).reduce(BigInteger :: gcd).orElse(BigInteger.ZERO).intValue();
  }
  private static int[] sortDescending(int[] array){
    return IntStream.of(array).boxed().sorted(Comparator.reverseOrder()).mapToInt(Integer :: intValue).toArray();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(null, Main.newMain(), "", 128 * 1024 * 1024).start() );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
     var c : Sequence(int) ; c := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    c[n+1] := x ; 
    c := sortDescending(c) ; 
    var diff : Sequence(int) ; diff := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     diff[i+1] := c[i+1] - c[i + 1+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(gcd(diff)) ; 
 );
  static   operation gcd( c : Sequence(int)) : int
  pre: true
  post: true
  activity: (     return stream(c).mapToObj(lambda _pars : OclAny in BigInteger.newBigInteger().valueOf(_pars))->iterate( _var; _acc : OclAny | lambda _pars : OclAny in BigInteger.newBigInteger().gcd(_pars)->apply((_acc,_var)) ).orElse(0)->oclAsType(int) );
  static   operation sortDescending( array : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     return Sequence{array}->sort()->collect( _x1 | (lambda _pars : OclAny in Integer.newInteger().intValue(_pars))->apply(_x1) )->asSequence() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  @ SuppressWarnings("resource")public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int x=scanner.nextInt();
    int dis[]=new int[n];
    int ans=0 ;
    int min=2000000000 ;
    for(int i=0 ; i<n ; i++){
      int tar=Math.abs(scanner.nextInt()-x);
      min=Math.min(min,tar);
      dis[i]=tar ;
    }
    boolean judge=true ;
    for(int j=1 ; j<=min ; j++){
      int tar=min/j ;
      if(tar==1){
        System.out.println(1);
        return ;
      }
      for(int i=0 ; i<n ; i++){
        if(dis[i] % tar!=0){
          judge=false ;
          break ;
        }
        else {
          judge=true ;
          ans=tar ;
        }
      }
      if(judge){
        System.out.println(ans);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var x : int ; x := scanner.getCurrent()->toInteger() ;
    var dis : Sequence(int) ; dis := Integer.subrange(1,n)->collect(0) ;
    var ans : int ; ans := 0 ;
    var min : int ; min := 2000000000 ;
        var i : int ; i := 0 ; while i < n do ( (     var tar : int ; tar := if scanner.getCurrent()->toInteger() - x < 0 then -(scanner.getCurrent()->toInteger() - x) else scanner.getCurrent()->toInteger() - x endif ;
     min := Set{min, tar}->min() ; 
     dis[i+1] := tar )  ;     i := i + 1 ) ; 
    var judge : boolean ; judge := true ;
        var j : int ; j := 1 ; while j <= min do ( (     var tar : int ; tar := min / j ;
     if (tar = 1) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < n do ( (     if (dis[i+1] mod tar /= 0) then (     judge := false ; 
     break ) else (     judge := true ; 
     ans := tar ) )  ;     i := i + 1 ) ; 
     if (judge) then (     OclFile["System.out"].println(ans) ; 
     return ) else skip )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int X=sc.nextInt();
    int[] citiesPos=new int[N];
    for(int i=0 ; i<N ; i++){
      citiesPos[i]=sc.nextInt();
    }
    Arrays.sort(citiesPos);
    int min=1000000000 ;
    if(citiesPos.length==1){
      min=Math.abs(citiesPos[0]-X);
    }
    else {
      for(int cityPos : citiesPos){
        min=Math.min(min,Math.abs(X-cityPos));
      }
    }
    boolean indivisibleFlg=false ;
    for(int cityPos : citiesPos){
      if(indivisibleFlg){
        break ;
      }
      if((cityPos-X)% min!=0){
        indivisibleFlg=true ;
      }
    }
    if(indivisibleFlg){
      int[] absDiffs=new int[citiesPos.length];
      for(int i=0 ; i<citiesPos.length ; i++){
        absDiffs[i]=Math.abs(X-citiesPos[i]);
      }
      int ans=gcd(absDiffs[0],absDiffs[1]);
      if(absDiffs.length>2){
        for(int i=2 ; i<absDiffs.length ; i++){
          ans=gcd(ans,absDiffs[i]);
        }
      }
      System.out.println(ans);
    }
    else {
      System.out.println(min);
    }
  }
  public static int gcd(int a,int b){
    int r=a % b ;
    if(b % r!=0){
      r=gcd(b,r);
    }
    return r ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var X : int ; X := sc.getCurrent()->toInteger() ;
    var citiesPos : Sequence(int) ; citiesPos := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     citiesPos[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    citiesPos := citiesPos->sort() ; 
    var min : int ; min := 1000000000 ;
    if (citiesPos->size() = 1) then (     min := if citiesPos[0+1] - X < 0 then -(citiesPos[0+1] - X) else citiesPos[0+1] - X endif ) else (     for (cityPos : citiesPos) do ( (     min := Set{min, if X - cityPos < 0 then -(X - cityPos) else X - cityPos endif}->min() )  ) ) ;  
    var indivisibleFlg : boolean ; indivisibleFlg := false ;
    for (cityPos : citiesPos) do ( (     if (indivisibleFlg) then (     break ) else skip ; 
     if ((cityPos - X) mod min /= 0) then (     indivisibleFlg := true ) else skip )  ) ; 
    if (indivisibleFlg) then (     var absDiffs : Sequence(int) ; absDiffs := Integer.subrange(1,citiesPos->size())->collect(0) ;
         var i : int ; i := 0 ; while i < citiesPos->size() do ( (     absDiffs[i+1] := if X - citiesPos[i+1] < 0 then -(X - citiesPos[i+1]) else X - citiesPos[i+1] endif )  ;     i := i + 1 ) ; 
    var ans : int ; ans := gcd(absDiffs[0+1], absDiffs[1+1]) ;
    if (absDiffs->size() > 2) then (         var i : int ; i := 2 ; while i < absDiffs->size() do ( (     ans := gcd(ans, absDiffs[i+1]) )  ;     i := i + 1 ) ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 ) else (     OclFile["System.out"].println(min) ) ;  
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var r : int ; r := a mod b ;
     if (b mod r /= 0) then (     r := gcd(b, r) ) else skip ; 
     return r );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String[] stack=new String[1000];
    int pointer=0 ;
    while(scan.hasNext()){
      String[] aaa=scan.nextLine().split(" ");
      if(aaa[0] .equals("push")){
        stack[pointer]=aaa[1];
        pointer++;
      }
      else if(aaa[0] .equals("pop")){
        pointer--;
        System.out.println(stack[pointer]);
      }
      else if(aaa[0] .equals("quit")){
        break ;
      }
      else {
        System.out.println("Error");
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var stack : Sequence(String) ; stack := Integer.subrange(1,1000)->collect(null) ;
     var pointer : int ; pointer := 0 ;
     while (scan.hasNext()) do (     var aaa : Sequence(String) ; aaa := scan.nextLine()->split(" ") ;
     if (aaa[0+1] = "push") then (     stack[pointer+1] := aaa[1+1] ; 
     pointer := pointer + 1 ) else     if (aaa[0+1] = "pop") then (     pointer := pointer - 1 ; 
     OclFile["System.out"].println(stack[pointer+1]) ) else     if (aaa[0+1] = "quit") then (     break ) else (     OclFile["System.out"].println("Error") ; 
     break ) ;  ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package r1c ;
import java.io.FileReader ;
import java.util.Scanner ;
public class B {
  public static void answer(Scanner in){
    double sx,sy,sz,svx,svy,svz ;
    sx=0 ;
    sy=0 ;
    sz=0 ;
    svx=0 ;
    svy=0 ;
    svz=0 ;
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      sx+=in.nextDouble();
      sy+=in.nextDouble();
      sz+=in.nextDouble();
      svx+=in.nextDouble();
      svy+=in.nextDouble();
      svz+=in.nextDouble();
    }
    double a,b,c ;
    a=svx*svx+svy*svy+svz*svz ;
    b=2*(sx*svx+sy*svy+sz*svz);
    c=sx*sx+sy*sy+sz*sz ;
    double outT ;
    if(a!=0){
      outT=-b/(2*a);
      if(outT<0){
        outT=0 ;
      }
    }
    else {
      outT=0 ;
    }
    double outD=a*outT*outT+b*outT+c ;
    if(outD<0){
      outD=0 ;
    }
    outD=Math.sqrt(outD)/n ;
    System.out.println(outD+" "+outT);
  }
  public static void main(String[] args){
    try {
      Scanner infile=new Scanner(new FileReader(args[0]));
      int t=infile.nextInt();
      infile.nextLine();
      for(int i=0 ; i<t ; i++){
        System.out.print("Case #"+(i+1)+": ");
        answer(infile);
      }
      infile.close();
    }
    catch(Exception e){
      System.out.println("Exception occured,stacktrace to follow.");
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation answer( in : OclFile) : void
  pre: true
  post: true
  activity: (     var sx : double ;
    var sy : double ;
    var sz : double ;
    var svx : double ;
    var svy : double ;
    var svz : double ;
     sx := 0 ; 
    sy := 0 ; 
    sz := 0 ; 
    svx := 0 ; 
    svy := 0 ; 
    svz := 0 ; 
    var n : int ; n := in.nextInt() ;
        var i : int ; i := 0 ; while i < n do ( (     sx := sx+(in.nextDouble()) ; 
     sy := sy+(in.nextDouble()) ; 
    sz := sz+(in.nextDouble()) ; 
    svx := svx+(in.nextDouble()) ; 
    svy := svy+(in.nextDouble()) ; 
    svz := svz+(in.nextDouble()) ; 
 )  ;     i := i + 1 ) ; 
    var a : double ;
    var b : double ;
    var c : double ;
    a := svx * svx + svy * svy + svz * svz ; 
    b := 2 * (sx * svx + sy * svy + sz * svz) ; 
    c := sx * sx + sy * sy + sz * sz ; 
    var outT : double ;
    if (a /= 0) then (     outT := -b / (2 * a) ; 
     if (outT < 0) then (     outT := 0 ) else skip ) else (     outT := 0 ) ;  
    var outD : double ; outD := a * outT * outT + b * outT + c ;
    if (outD < 0) then (     outD := 0 ) else skip ; 
    outD := (outD)->sqrt() / n ; 
    OclFile["System.out"].println(outD + " " + outT) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var infile : OclFile ; infile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(args[0+1])) ;
     var t : int ; t := infile.getCurrent()->toInteger() ;
    skip ; 
        var i : int ; i := 0 ; while i < t do ( (     OclFile["System.out"].print("Case #" + (i + 1) + ": ") ; 
     execute answer(infile) )  ;     i := i + 1 ) ; 
    skip ; 
 )   catch (e : ProgramException) do (     OclFile["System.out"].println("Exception occured,stacktrace to follow.") ; 
     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
class Main {
  public static void main(String[] argv){
    Scanner sc=new Scanner(System.in);
    int tests=sc.nextInt();
    for(int t=1 ; t<=tests ; t++){
      int n=sc.nextInt();
      double x=0.,y=0,z=0,dx=0,dy=0,dz=0 ;
      for(int i=0 ; i<n ; i++){
        x+=sc.nextDouble();
        y+=sc.nextDouble();
        z+=sc.nextDouble();
        dx+=sc.nextDouble();
        dy+=sc.nextDouble();
        dz+=sc.nextDouble();
      }
      x/=n ;
      y/=n ;
      z/=n ;
      dx/=n ;
      dy/=n ;
      dz/=n ;
      double a=dx*dx+dy*dy+dz*dz ;
      double b=2*(dx*x+dy*y+dz*z);
      double c=x*x+y*y+z*z ;
      double s ;
      if(a==0 && b==0){
        s=0 ;
      }
      else if(a==0 && b/c>0){
        s=0 ;
      }
      else if(a==0){
        s=-c/b ;
      }
      else if(b/a>0){
        s=0 ;
      }
      else {
        s=-b/a/2 ;
      }
      double v=a*s*s+b*s+c ;
      if(v<0){
        v=0 ;
      }
      v=Math.sqrt(v);
      System.err.println(t);
      System.out.printf("Case #%d: %.08f %.08f\n",t,v,s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( argv : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tests : int ; tests := sc.getCurrent()->toInteger() ;
         var t : int ; t := 1 ; while t <= tests do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : double ; x := 0. ;
    var y : double ; y := 0 ;
    var z : double ; z := 0 ;
    var dx : double ; dx := 0 ;
    var dy : double ; dy := 0 ;
    var dz : double ; dz := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x := x+(sc.getCurrent()->toReal()) ; 
     y := y+(sc.getCurrent()->toReal()) ; 
    z := z+(sc.getCurrent()->toReal()) ; 
    dx := dx+(sc.getCurrent()->toReal()) ; 
    dy := dy+(sc.getCurrent()->toReal()) ; 
    dz := dz+(sc.getCurrent()->toReal()) ; 
 )  ;     i := i + 1 ) ; 
    x := x/(n) ; 
    y := y/(n) ; 
    z := z/(n) ; 
    dx := dx/(n) ; 
    dy := dy/(n) ; 
    dz := dz/(n) ; 
    var a : double ; a := dx * dx + dy * dy + dz * dz ;
    var b : double ; b := 2 * (dx * x + dy * y + dz * z) ;
    var c : double ; c := x * x + y * y + z * z ;
    var s : double ;
    if (a = 0 & b = 0) then (     s := 0 ) else     if (a = 0 & b / c > 0) then (     s := 0 ) else     if (a = 0) then (     s := -c / b ) else     if (b / a > 0) then (     s := 0 ) else (     s := -b / a / 2 ) ;  ;  ;  ;  
    var v : double ; v := a * s * s + b * s + c ;
    if (v < 0) then (     v := 0 ) else skip ; 
    v := (v)->sqrt() ; 
    OclFile["System.err"].println(t) ; 
    OclFile["System.out"].printf("Case #%d: %.08f %.08f\n", t, v, s) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  PrintWriter out ;
  Scanner in ;
  String testCase="b2" ;
  public static void main(String[] args)throws Exception {
    new B().solve();
  }
  long sqr(long a){
    return a*a ;
  }
  double sqrt(double a){
    if(a<1E-8){
      return 0 ;
    }
    else {
      return Math.sqrt(a);
    }
  }
  void solve()throws Exception {
    Locale.setDefault(Locale.ENGLISH);
    out=new PrintWriter(new FileOutputStream(testCase+".out"));
    in=new Scanner(new BufferedReader(new InputStreamReader(new FileInputStream(testCase+".in"))));
    int N=in.nextInt();
    for(int t=1 ; t<=N ; ++t){
      out.print("Case #"+t+": ");
      int n=in.nextInt();
      long x=0,y=0,z=0,vx=0,vy=0,vz=0 ;
      for(int i=0 ; i<n ; ++i){
        x+=in.nextInt();
        y+=in.nextInt();
        z+=in.nextInt();
        vx+=in.nextInt();
        vy+=in.nextInt();
        vz+=in.nextInt();
      }
      long a=sqr(vx)+sqr(vy)+sqr(vz);
      long b=2*(x*vx+y*vy+z*vz);
      long c=sqr(x)+sqr(y)+sqr(z);
      double time ;
      if(a!=0){
        time=-b/(2.0*a);
      }
      else {
        time=0 ;
      }
      if(time<0){
        time=0 ;
      }
      double d=sqrt((a*time*time+b*time+c))/n ;
      out.println(d+" "+time);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
   attribute out : OclFile;
   attribute in : OclFile;
   attribute testCase : String := "b2";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     B.newB().solve() );
   operation sqr( a : long) : long
  pre: true
  post: true
  activity: (     return a * a );
   operation sqrt( a : double) : double
  pre: true
  post: true
  activity: (     if (a < 1E-8) then (     return 0 ) else (     return (a)->sqrt() ) );
   operation solve() : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.ENGLISH) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(testCase + ".out")) ; 
    in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(testCase + ".in")))) ; 
    var N : int ; N := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= N do ( (     skip ; 
     var n : int ; n := in.getCurrent()->toInteger() ;
    var x : long ; x := 0 ;
    var y : long ; y := 0 ;
    var z : long ; z := 0 ;
    var vx : long ; vx := 0 ;
    var vy : long ; vy := 0 ;
    var vz : long ; vz := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x := x+(in.getCurrent()->toInteger()) ; 
     y := y+(in.getCurrent()->toInteger()) ; 
    z := z+(in.getCurrent()->toInteger()) ; 
    vx := vx+(in.getCurrent()->toInteger()) ; 
    vy := vy+(in.getCurrent()->toInteger()) ; 
    vz := vz+(in.getCurrent()->toInteger()) ; 
 )  ;     i := i + 1 ) ; 
    var a : long ; a := sqr(vx) + sqr(vy) + sqr(vz) ;
    var b : long ; b := 2 * (x * vx + y * vy + z * vz) ;
    var c : long ; c := sqr(x) + sqr(y) + sqr(z) ;
    var time : double ;
    if (a /= 0) then (     time := -b / (2.0 * a) ) else (     time := 0 ) ;  
    if (time < 0) then (     time := 0 ) else skip ; 
    var d : double ; d := sqrt((a * time * time + b * time + c)) / n ;
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CenterOfMass {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new FileReader("B.in"));
    PrintWriter out=new PrintWriter(new BufferedWriter(new FileWriter("B.out")));
    StringTokenizer st ;
    int T=Integer.parseInt(in.readLine());
    for(int caseNum=1 ; caseNum<=T ; caseNum++){
      int N=Integer.parseInt(in.readLine());
      double xPos=0.0 ;
      double yPos=0.0 ;
      double zPos=0.0 ;
      double xVel=0.0 ;
      double yVel=0.0 ;
      double zVel=0.0 ;
      double time ;
      double distance ;
      for(int i=0 ; i<N ; i++){
        st=new StringTokenizer(in.readLine());
        xPos+=Double.parseDouble(st.nextToken());
        yPos+=Double.parseDouble(st.nextToken());
        zPos+=Double.parseDouble(st.nextToken());
        xVel+=Double.parseDouble(st.nextToken());
        yVel+=Double.parseDouble(st.nextToken());
        zVel+=Double.parseDouble(st.nextToken());
      }
      xPos/=(double)N ;
      yPos/=(double)N ;
      zPos/=(double)N ;
      xVel/=(double)N ;
      yVel/=(double)N ;
      zVel/=(double)N ;
      if(xVel==0.0 && yVel==0.0 && zVel==0.0){
        time=0 ;
        distance=Math.sqrt(xPos*xPos+yPos*yPos+zPos*zPos);
      }
      else {
        time=-(xPos*xVel+yPos*yVel+zPos*zVel)/(xVel*xVel+yVel*yVel+zVel*zVel);
        if(time<0)time=0 ;
        double xNew=xPos+time*xVel ;
        double yNew=yPos+time*yVel ;
        double zNew=zPos+time*zVel ;
        distance=Math.sqrt(xNew*xNew+yNew*yNew+zNew*zNew);
      }
      out.println("Case #"+caseNum+": "+distance+" "+time);
    }
    in.close();
    out.close();
    System.exit(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CenterOfMass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("B.in"))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("B.out")))) ;
    var st : OclIterator ;
    var T : int ; T := (in.readLine())->toInteger() ;
        var caseNum : int ; caseNum := 1 ; while caseNum <= T do ( (     var N : int ; N := (in.readLine())->toInteger() ;
     var xPos : double ; xPos := 0.0 ;
    var yPos : double ; yPos := 0.0 ;
    var zPos : double ; zPos := 0.0 ;
    var xVel : double ; xVel := 0.0 ;
    var yVel : double ; yVel := 0.0 ;
    var zVel : double ; zVel := 0.0 ;
    var time : double ;
    var distance : double ;
        var i : int ; i := 0 ; while i < N do ( (     st := OclIterator.newOclIterator_String(in.readLine()) ; 
     xPos := xPos+((st.next())->toReal()) ; 
    yPos := yPos+((st.next())->toReal()) ; 
    zPos := zPos+((st.next())->toReal()) ; 
    xVel := xVel+((st.next())->toReal()) ; 
    yVel := yVel+((st.next())->toReal()) ; 
    zVel := zVel+((st.next())->toReal()) ; 
 )  ;     i := i + 1 ) ; 
    xPos := xPos/(N->oclAsType(double)) ; 
    yPos := yPos/(N->oclAsType(double)) ; 
    zPos := zPos/(N->oclAsType(double)) ; 
    xVel := xVel/(N->oclAsType(double)) ; 
    yVel := yVel/(N->oclAsType(double)) ; 
    zVel := zVel/(N->oclAsType(double)) ; 
    if (xVel = 0.0 & yVel = 0.0 & zVel = 0.0) then (     time := 0 ; 
     distance := (xPos * xPos + yPos * yPos + zPos * zPos)->sqrt() ) else (     time := -(xPos * xVel + yPos * yVel + zPos * zVel) / (xVel * xVel + yVel * yVel + zVel * zVel) ; 
     if (time < 0) then     time := 0 ; else skip ; 
    var xNew : double ; xNew := xPos + time * xVel ;
    var yNew : double ; yNew := yPos + time * yVel ;
    var zNew : double ; zNew := zPos + time * zVel ;
    distance := (xNew * xNew + yNew * yNew + zNew * zNew)->sqrt() ; 
 ) ;  
    skip ; 
 )  ;     caseNum := caseNum + 1 ) ; 
    skip ; 
    skip ; 
OclProcess.exit(0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int countStrings(String s){
    int sum=1 ;
    for(int i=0 ; i<s.length(); i++){
      if(i % 2==0 && s.charAt(i)=='$')sum*=21 ;
      else if(s.charAt(i)=='$')sum*=5 ;
    }
    return sum ;
  }
  public static void main(String args[]){
    String str="s$$e$" ;
    System.out.println(countStrings(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countStrings( s : String) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 1 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (i mod 2 = 0 & s->at(i+1) = '$') then     sum := sum*(21) ; else     if (s->at(i+1) = '$') then     sum := sum*(5) ; else skip ; )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "s$$e$" ;
     OclFile["System.out"].println(countStrings(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import java.io.*;
public class Hello {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    ArrayList<Integer>l=new ArrayList<>();
    int i=1,c=0 ;
    while(true){
      int sum=(i*(i+1))/2 ;
      if(sum<=n){
        l.add(i);
        c++;
      }
      else {
        break ;
      }
      i++;
    }
    pw.println(l.size());
    if(l.size()==1){
      pw.println(n);
    }
    else {
      int val=(l.size()*(l.size()+1))/2 ;
      if(val==n){
        for(int t=1 ; t<=l.size(); t++){
          pw.print(t+" ");
        }
      }
      else {
        int s=1 ;
        pw.print(1+" ");
        for(int t=2 ; t<=l.size()-1 ; t++){
          s+=t ;
          pw.print(t+" ");
        }
        pw.print(n-s);
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hello {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Sequence{} ;
    var i : int ; i := 1 ;
    var c : int ; c := 0 ;
    while (true) do (     var sum : int ; sum := (i * (i + 1)) / 2 ;
     if (sum <= n) then (     l := l->including(i) ; 
     c := c + 1 ) else (     break ) ;  
     i := i + 1 ) ; 
    skip ; 
    if (l->size() = 1) then (     skip ) else (     var val : int ; val := (l->size() * (l->size() + 1)) / 2 ;
     if (val = n) then (         var t : int ; t := 1 ; while t <= l->size() do ( (     skip )  ;     t := t + 1 ) ) else (     var s : int ; s := 1 ;
     skip ; 
         var t : int ; t := 2 ; while t <= l->size() - 1 do ( (     s := s+(t) ; 
     skip )  ;     t := t + 1 ) ; 
     skip ) ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    ArrayDeque<Integer>arr=new ArrayDeque<>();
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    if(N==0){
      System.out.println(0);
      return ;
    }
    int sum=N ;
    int counter=0 ;
    for(int i=1 ; i<=N ; i++){
      if(sum-i>=0){
        sum-=i ;
        arr.push(i);
      }
    }
    sum+=arr.getFirst();
    arr.pop();
    for(int i=N ; i>=1 ; i--){
      if(sum-i>=0){
        arr.push(i);
        break ;
      }
    }
    System.out.println(arr.size());
    for(int n : arr){
      System.out.print(n+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := ArrayDeque<OclAny>.newArrayDeque() ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var N : int ; N := scanner.getCurrent()->toInteger() ;
    if (N = 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var sum : int ; sum := N ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     if (sum - i >= 0) then (     sum := sum-(i) ; 
     arr := arr->append(i) ) else skip )  ;     i := i + 1 ) ; 
    sum := sum+(arr->first()) ; 
    arr := arr->front() ; 
        var i : int ; i := N ; while i >= 1 do ( (     if (sum - i >= 0) then (     arr := arr->append(i) ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(arr->size()) ; 
    for (n : arr) do ( (     OclFile["System.out"].print(n + " ") )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=0 ;
    while(n>t){
      t++;
      n=n-t ;
    }
    System.out.println(t);
    for(int i=1 ; i<t ; i++){
      System.out.print(i+" ");
    }
    System.out.println(n+t);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := 0 ;
    while (n > t) do (     t := t + 1 ; 
     n := n - t ) ; 
    OclFile["System.out"].println(t) ; 
        var i : int ; i := 1 ; while i < t do ( (     OclFile["System.out"].print(i + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n + t) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import java.io.*;
public class Hello {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    ArrayList<Integer>l=new ArrayList<>();
    int i=1,c=0 ;
    while(true){
      int sum=(i*(i+1))/2 ;
      if(sum<=n){
        l.add(i);
        c++;
      }
      else {
        break ;
      }
      i++;
    }
    pw.println(l.size());
    if(l.size()==1){
      pw.println(n);
    }
    else {
      int s=1 ;
      pw.print(1+" ");
      for(int t=2 ; t<=l.size()-1 ; t++){
        s+=t ;
        pw.print(t+" ");
      }
      pw.print(n-s);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hello {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Sequence{} ;
    var i : int ; i := 1 ;
    var c : int ; c := 0 ;
    while (true) do (     var sum : int ; sum := (i * (i + 1)) / 2 ;
     if (sum <= n) then (     l := l->including(i) ; 
     c := c + 1 ) else (     break ) ;  
     i := i + 1 ) ; 
    skip ; 
    if (l->size() = 1) then (     skip ) else (     var s : int ; s := 1 ;
     skip ; 
         var t : int ; t := 2 ; while t <= l->size() - 1 do ( (     s := s+(t) ; 
     skip )  ;     t := t + 1 ) ; 
     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int GIF(double n){
    return(int)Math.floor(n);
  }
  public static void main(String[] args){
    double n=2.3 ;
    System.out.println(GIF(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation GIF( n : double) : int
  pre: true
  post: true
  activity: (     return (n)->floor()->oclAsType(int) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 2.3 ;
     OclFile["System.out"].println(GIF(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.Stack ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    ArrayList<String>list=new ArrayList<String>();
    Stack<String>stack=new Stack<String>();
    for(int i=0 ; ; i++){
      String[] s=br.readLine().split(" ");
      if(s.length==2){
        stack.add(s[1]);
      }
      else {
        if(s[0] .equals("quit")){
          break ;
        }
        else {
          list.add(stack.pop());
        }
      }
    }
    for(int i=0 ; i<list.size(); i++){
      System.out.println(list.get(i));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
    var list : Sequence(String) ; list := Sequence{} ;
    var stack : Sequence(String) ; stack := Sequence{} ;
        var i : int ; i := 0 ; while true do ( (     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
     if (s->size() = 2) then (     stack := stack->including(s[1+1]) ) else (     if (s[0+1] = "quit") then (     break ) else (     list := list->including(stack->last()) ) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < list->size() do ( (     OclFile["System.out"].println(list->at(i+1)) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.Math.*;
import static java.lang.System.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    long a=parseLong(sc.next());
    long b=parseLong(sc.next());
    long c=parseLong(sc.next());
    long k=parseLong(sc.next());
    sc.close();
    out.println(k % 2==0 ? a-b : b-a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var a : long ; a := parseLong(sc.getCurrent()) ;
    var b : long ; b := parseLong(sc.getCurrent()) ;
    var c : long ; c := parseLong(sc.getCurrent()) ;
    var k : long ; k := parseLong(sc.getCurrent()) ;
    skip ; 
    out.println(if k mod 2 = 0 then a - b else b - a endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    AFairness solver=new AFairness();
    solver.solve(1,in,out);
    out.close();
  }
  static class AFairness {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      long a=in.nextLong(),b=in.nextLong(),c=in.nextLong();
      long k=in.nextLong();
      long answer=a-b ;
      if(k % 2==1){
        answer*=-1 ;
      }
      out.println(answer);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : AFairness ; solver := AFairness.newAFairness() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class AFairness {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : long ; a := in.nextLong() ;
    var b : long ; b := in.nextLong() ;
    var c : long ; c := in.nextLong() ;
     var k : long ; k := in.nextLong() ;
    var answer : long ; answer := a - b ;
    if (k mod 2 = 1) then (     answer := answer*(-1) ) else skip ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int[] guu={
      1,-1,0 };
      int[] ki={
-1,1,0 };
        Scanner sc=new Scanner(System.in);
        long A=sc.nextLong();
        long B=sc.nextLong();
        long C=sc.nextLong();
        long K=sc.nextLong();
        long ans=0 ;
        if(K % 2==0){
          ans=A-B ;
        }
        else {
          ans=-A+B ;
        }
        if(ans>Math.pow(10,18)){
          System.out.println("Unfair");
          return ;
        }
        System.out.println(ans);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var guu : Sequence(int) ; guu := Sequence{1,-1,0} ;
     var ki : Sequence(int) ; ki := Sequence{-1,1,0} ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var A : long ; A := sc.getCurrent()->toLong() ;
    var B : long ; B := sc.getCurrent()->toLong() ;
    var C : long ; C := sc.getCurrent()->toLong() ;
    var K : long ; K := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
    if (K mod 2 = 0) then (     ans := A - B ) else (     ans := -A + B ) ;  
    if (ans > 10->pow(18)) then (     OclFile["System.out"].println("Unfair") ; 
     return ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static final long x=(long)Math.pow(10,18);
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long a=sc.nextInt();
    long b=sc.nextInt();
    long c=sc.nextInt();
    long k=sc.nextLong();
    if(k % 2==0){
      System.out.println(a-b);
    }
    else {
      System.out.println(b-a);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute x : long := 10->pow(18)->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := sc.getCurrent()->toInteger() ;
    var b : long ; b := sc.getCurrent()->toInteger() ;
    var c : long ; c := sc.getCurrent()->toInteger() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    if (k mod 2 = 0) then (     OclFile["System.out"].println(a - b) ) else (     OclFile["System.out"].println(b - a) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG1 {
  static long findMinValue(long arr[],int n){
    Arrays.sort(arr);
    double val=0 ;
    for(int i=0 ; i<n ; i++){
      val+=(double)(Math.log((double)(arr[i])));
    }
    long left=arr[0],right=arr[n-1];
    long ans=0 ;
    while(left<=right){
      long mid=(left+right)/2 ;
      double temp=(double)n*(double)(Math.log((double)(mid)));
      if(val<temp){
        ans=mid ;
        right=mid-1 ;
      }
      else {
        left=mid+1 ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    long arr[]={
      4,2,1,10,6 };
      int n=arr.length ;
      System.out.println(findMinValue(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG1 {
  static   operation findMinValue( arr : Sequence(long), n : int) : long
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var val : double ; val := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     val := val+((((arr[i+1])->oclAsType(double))->log())->oclAsType(double)) )  ;     i := i + 1 ) ; 
    var left : long ; left := arr[0+1] ;
    var right : long ; right := arr[n - 1+1] ;
    var ans : long ; ans := 0 ;
    while (left <= right) do (     var mid : long ; mid := (left + right) / 2 ;
     var temp : double ; temp := n->oclAsType(double) * (((mid)->oclAsType(double))->log())->oclAsType(double) ;
     if (val < temp) then (     ans := mid ; 
     right := mid - 1 ) else (     left := mid + 1 ) ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(long) ; arr := Sequence{4,2,1,10,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findMinValue(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static int countZeroso(int[] a,int n){
    int count2=0,count5=0 ;
    for(int i=0 ; i<n ; i++){
      while(a[i] % 2==0){
        a[i]=a[i]/2 ;
        count2++;
      }
      while(a[i] % 5==0){
        a[i]=a[i]/5 ;
        count5++;
      }
    }
    return(count2<count5)? count2 : count5 ;
  }
  public static void main(String argc[]){
    int[] a=new int[] {
      10,100,20,30,50,91,12,80 };
      int n=8 ;
      System.out.println(countZeroso(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation countZeroso( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count2 : int ; count2 := 0 ;
    var count5 : int ; count5 := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     while (a[i+1] mod 2 = 0) do (     a[i+1] := a[i+1] / 2 ; 
     count2 := count2 + 1 ) ; 
     while (a[i+1] mod 5 = 0) do (     a[i+1] := a[i+1] / 5 ; 
     count5 := count5 + 1 ) )  ;     i := i + 1 ) ; 
     return if (count2 < count5) then count2 else count5 endif );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{10,100,20,30,50,91,12,80} ;
     var n : int ; n := 8 ;
     OclFile["System.out"].println(countZeroso(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int calculate_min_sum(int[] a,int n){
    Arrays.sort(a);
    int min_sum=0 ;
    for(int i=1 ; i<n ; i+=2){
      min_sum+=Math.abs(a[i]-a[i-1]);
    }
    return min_sum ;
  }
  static int calculate_max_sum(int[] a,int n){
    Arrays.sort(a);
    int max_sum=0 ;
    for(int i=0 ; i<n/2 ; i++){
      max_sum+=Math.abs(a[n-1-i]-a[i]);
    }
    return max_sum ;
  }
  public static void main(String[] args){
    int[] a={
      10,-10,20,-40 };
      int n=a.length ;
      System.out.println("The minimum sum of pairs is "+calculate_min_sum(a,n));
      System.out.println("The maximum sum of pairs is "+calculate_max_sum(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation calculate_min_sum( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var min_sum : int ; min_sum := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     min_sum := min_sum+(if a[i+1] - a[i - 1+1] < 0 then -(a[i+1] - a[i - 1+1]) else a[i+1] - a[i - 1+1] endif) )  ;     i := i+(2) ) ; 
     return min_sum );
  static   operation calculate_max_sum( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var max_sum : int ; max_sum := 0 ;
         var i : int ; i := 0 ; while i < n / 2 do ( (     max_sum := max_sum+(if a[n - 1 - i+1] - a[i+1] < 0 then -(a[n - 1 - i+1] - a[i+1]) else a[n - 1 - i+1] - a[i+1] endif) )  ;     i := i + 1 ) ; 
     return max_sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{10,-10,20,-40} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println("The minimum sum of pairs is " + calculate_min_sum(a, n)) ; 
     OclFile["System.out"].println("The maximum sum of pairs is " + calculate_max_sum(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int printTribRec(int n){
    if(n==0 || n==1 || n==2)return 0 ;
    if(n==3)return 1 ;
    else return printTribRec(n-1)+printTribRec(n-2)+printTribRec(n-3);
  }
  static void printTrib(int n){
    for(int i=1 ; i<n ; i++)System.out.print(printTribRec(i)+" ");
  }
  public static void main(String args[]){
    int n=10 ;
    printTrib(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printTribRec( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0 or n = 1 or n = 2) then     return 0 else skip ; 
     if (n = 3) then     return 1 else     return printTribRec(n - 1) + printTribRec(n - 2) + printTribRec(n - 3) );
  static   operation printTrib( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < n do (     OclFile["System.out"].print(printTribRec(i) + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     execute printTrib(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findCount(int N){
    Vector list=new Vector();
    int sum=0 ;
    int i ;
    for(i=0 ; i<20 ; i++){
      sum+=Math.pow(2,i);
      list.add(sum);
    }
    for(i=0 ; i<20 ; i++){
      if((int)list.get(i)>N)return(list.indexOf(list.get(i))+1);
    }
    return 0 ;
  }
  public static void main(String[] args){
    int N=10 ;
    System.out.println(findCount(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findCount( N : int) : int
  pre: true
  post: true
  activity: (     var list : Sequence ; list := Sequence{} ;
     var sum : int ; sum := 0 ;
    var i : int ;
        i := 0 ; while i < 20 do ( (     sum := sum+(2->pow(i)) ; 
     list := list->including(sum) )  ;     i := i + 1 ) ; 
        i := 0 ; while i < 20 do ( (     if (list->at(i+1)->oclAsType(int) > N) then     return (list->indexOf(list->at(i+1))-1 + 1) else skip )  ;     i := i + 1 ) ; 
    return 0 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 10 ;
     OclFile["System.out"].println(findCount(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class GFG {
  public static void SplitAndAdd(int[] A,int length,int rotation){
    int[] tmp=new int[length*2];
    System.arraycopy(A,0,tmp,0,length);
    System.arraycopy(A,0,tmp,length,length);
    for(int i=rotation ; i<rotation+length ; i++)A[i-rotation]=tmp[i];
  }
  public static void main(String[] args){
    int arr[]={
      12,10,5,6,52,36 };
      int n=arr.length ;
      int position=2 ;
      SplitAndAdd(arr,n,position);
      for(int i=0 ; i<n ; ++i)System.out.print(arr[i]+" ");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation SplitAndAdd( A : Sequence(int), length : int, rotation : int) : void
  pre: true
  post: true
  activity: (     var tmp : Sequence(int) ; tmp := Integer.subrange(1,length * 2)->collect(0) ;
     for _x : Integer.subrange(1,length) do tmp[0 + _x] := A[0 + _x] ; 
     for _x : Integer.subrange(1,length) do tmp[length + _x] := A[0 + _x] ; 
         var i : int ; i := rotation ; while i < rotation + length do (     A[i - rotation+1] := tmp[i+1] ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,10,5,6,52,36} ;
     var n : int ; n := arr->size() ;
    var position : int ; position := 2 ;
    execute SplitAndAdd(arr, n, position) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Deque ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Deque<String>stack=new ArrayDeque<String>();
    Scanner scan=new Scanner(System.in);
    while(true){
      String instruction=scan.next();
      String block ;
      switch(instruction){
        case "quit" : return ;
        case "push" : block=scan.next();
        stack.push(block);
        break ;
        case "pop" : block=stack.pop();
        System.out.println(block);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stack : Sequence(String) ; stack := ArrayDeque<String>.newArrayDeque() ;
     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var instruction : String ; instruction := scan.getCurrent() ;
     var block : String ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (instruction) ; 
       if _switchval = "quit" then
     return 
   else skip ;
       if _switchval = "push" then
     block := scan.getCurrent() ; 
    stack := stack->append(block) ; 
    break 
   else skip ;
       if _switchval = "pop" then
     block := stack->last() ;     stack := stack->front() ; 
    OclFile["System.out"].println(block) ; 
    break 
   else skip ;
 )
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p018 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p018().run());
  }
  public String run(){
    for(int i=triangle.length-2 ; i>=0 ; i--){
      for(int j=0 ; j<triangle[i] .length ; j++)triangle[i][j]+=Math.max(triangle[i+1][j],triangle[i+1][j+1]);
    }
    return Integer.toString(triangle[0][0]);
  }
  private int[][] triangle={
    {
      75 },{
        95,64 },{
          17,47,82 },{
            18,35,87,10 },{
              20,4,82,47,65 },{
                19,1,23,75,3,34 },{
                  88,2,77,73,7,63,67 },{
                    99,65,4,28,6,16,70,92 },{
                      41,41,26,56,83,40,80,70,33 },{
                        41,48,72,33,47,32,37,16,94,29 },{
                          53,71,44,65,25,43,91,52,97,51,14 },{
                            70,11,33,28,77,73,17,78,39,68,17,57 },{
                              91,71,52,38,17,14,91,43,58,50,27,29,48 },{
                                63,66,4,68,89,53,67,30,73,16,69,87,40,31 },{
                                  4,62,98,27,23,9,70,98,73,93,38,53,60,4,23 },};
                                }

------------------------------------------------------------
OCL File:
---------
class p018 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p018.newp018().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (         var i : int ; i := triangle->size() - 2 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < triangle[i+1]->size() do (     triangle[i+1][j+1] := triangle[i+1][j+1]+(Set{triangle[i + 1+1][j+1], triangle[i + 1+1][j + 1+1]}->max()) ;  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
     return ((triangle[0+1][0+1]) + "") );
   attribute triangle : Sequence(Sequence(int)) := Sequence{Sequence{75},Sequence{95,64},Sequence{17,47,82},Sequence{18,35,87,10},Sequence{20,4,82,47,65},Sequence{19,1,23,75,3,34},Sequence{88,2,77,73,7,63,67},Sequence{99,65,4,28,6,16,70,92},Sequence{41,41,26,56,83,40,80,70,33},Sequence{41,48,72,33,47,32,37,16,94,29},Sequence{53,71,44,65,25,43,91,52,97,51,14},Sequence{70,11,33,28,77,73,17,78,39,68,17,57},Sequence{91,71,52,38,17,14,91,43,58,50,27,29,48},Sequence{63,66,4,68,89,53,67,30,73,16,69,87,40,31},Sequence{4,62,98,27,23,9,70,98,73,93,38,53,60,4,23},};
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static void solve(){
    while(true){
      int outer=0 ;
      int[] num=new int[6];
      for(int i=0 ; i<6 ; i++){
        num[i]=in.nextInt();
        outer+=num[i];
      }
      if(outer==0)break ;
      int[] p=new int[3];
      for(int i=0 ; i<3 ; i++){
        p[i]=num[i]+num[i+3];
      }
      int ans=0 ;
      for(int i=0 ; i<3 ; i++){
        int tmp=i ;
        for(int j=0 ; j<3 ; j++){
          if(p[j]-i<0){
            tmp=-1 ;
            break ;
          }
          else {
            tmp+=(p[j]-i)/3 ;
          }
        }
        ans=Math.max(ans,tmp);
      }
      System.out.println(ans);
    }
  }
  public static void main(String[] args){
    long start=System.currentTimeMillis();
    solve();
    out.flush();
    long end=System.currentTimeMillis();
    in.close();
    out.close();
  }
  static void trace(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     while (true) do (     var outer : int ; outer := 0 ;
     var num : Sequence(int) ; num := Integer.subrange(1,6)->collect(0) ;
        var i : int ; i := 0 ; while i < 6 do ( (     num[i+1] := in.getCurrent()->toInteger() ; 
     outer := outer+(num[i+1]) )  ;     i := i + 1 ) ; 
    if (outer = 0) then     break else skip ; 
    var p : Sequence(int) ; p := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do ( (     p[i+1] := num[i+1] + num[i + 3+1] )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     var tmp : int ; tmp := i ;
         var j : int ; j := 0 ; while j < 3 do ( (     if (p[j+1] - i < 0) then (     tmp := -1 ; 
     break ) else (     tmp := tmp+((p[j+1] - i) / 3) ) )  ;     j := j + 1 ) ; 
     ans := Set{ans, tmp}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : long ; start := OclDate.getSystemTime() ;
     execute solve() ; 
    skip ; 
    var end : long ; end := OclDate.getSystemTime() ;
    skip ; 
    skip ; 
 );
  static   operation trace( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  private static void solve(){
    final Scanner scanner=new Scanner(System.in);
    while(true){
      int math=scanner.nextInt();
      int algorithm=scanner.nextInt();
      int impl=scanner.nextInt();
      math+=scanner.nextInt();
      algorithm+=scanner.nextInt();
      impl+=scanner.nextInt();
      if(math+algorithm+impl==0){
        break ;
      }
      int maximum=math/3+algorithm/3+impl/3 ;
      maximum+=Math.min(Math.min(math % 3,algorithm % 3),impl % 3);
      if(math % 3==2 && algorithm % 3==2 && impl % 3==0 && impl>0 || algorithm % 3==2 && impl % 3==2 && math % 3==0 && math>0 || impl % 3==2 && math % 3==2 && algorithm % 3==0 && algorithm>0){
        maximum++;
      }
      System.out.println(maximum);
    }
  }
  public static void main(String...args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var math : int ; math := scanner.getCurrent()->toInteger() ;
     var algorithm : int ; algorithm := scanner.getCurrent()->toInteger() ;
    var impl : int ; impl := scanner.getCurrent()->toInteger() ;
    math := math+(scanner.getCurrent()->toInteger()) ; 
    algorithm := algorithm+(scanner.getCurrent()->toInteger()) ; 
    impl := impl+(scanner.getCurrent()->toInteger()) ; 
    if (math + algorithm + impl = 0) then (     break ) else skip ; 
    var maximum : int ; maximum := math / 3 + algorithm / 3 + impl / 3 ;
    maximum := maximum+(Set{Set{math mod 3, algorithm mod 3}->min(), impl mod 3}->min()) ; 
    if (math mod 3 = 2 & algorithm mod 3 = 2 & impl mod 3 = 0 & impl > 0 or algorithm mod 3 = 2 & impl mod 3 = 2 & math mod 3 = 0 & math > 0 or impl mod 3 = 2 & math mod 3 = 2 & algorithm mod 3 = 0 & algorithm > 0) then (     maximum := maximum + 1 ) else skip ; 
    OclFile["System.out"].println(maximum) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int[] c=new int[3];
  static int solve(){
    int ret=0 ;
    int min=Math.min(c[0],Math.min(c[1],c[2]));
    for(int i=0 ; i<=Math.min(3,min); ++i){
      int count=(c[0]-i)/3+(c[1]-i)/3+(c[2]-i)/3+i ;
      ret=Math.max(ret,count);
    }
    return ret ;
  }
  public static void main(String[] args)throws Exception {
    while(true){
      Arrays.fill(c,0);
      c[0]+=sc.nextInt();
      c[1]+=sc.nextInt();
      c[2]+=sc.nextInt();
      c[0]+=sc.nextInt();
      c[1]+=sc.nextInt();
      c[2]+=sc.nextInt();
      if(c[0]+c[1]+c[2]==0)break ;
      System.out.println(solve());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute c : Sequence(int) := Integer.subrange(1,3)->collect(0);
  static   operation solve() : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
     var min : int ; min := Set{c[0+1], Set{c[1+1], c[2+1]}->min()}->min() ;
         var i : int ; i := 0 ; while i <= Set{3, min}->min() do ( (     var count : int ; count := (c[0+1] - i) / 3 + (c[1+1] - i) / 3 + (c[2+1] - i) / 3 + i ;
     ret := Set{ret, count}->max() )  ;     i := i + 1 ) ; 
     return ret );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     c := c->collect(0) ; 
     c[0+1] := c[0+1]+(sc.getCurrent()->toInteger()) ; 
    c[1+1] := c[1+1]+(sc.getCurrent()->toInteger()) ; 
    c[2+1] := c[2+1]+(sc.getCurrent()->toInteger()) ; 
    c[0+1] := c[0+1]+(sc.getCurrent()->toInteger()) ; 
    c[1+1] := c[1+1]+(sc.getCurrent()->toInteger()) ; 
    c[2+1] := c[2+1]+(sc.getCurrent()->toInteger()) ; 
    if (c[0+1] + c[1+1] + c[2+1] = 0) then     break else skip ; 
    OclFile["System.out"].println(solve()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int a=sc.nextInt(),b=sc.nextInt(),c=sc.nextInt(),d=sc.nextInt(),e=sc.nextInt(),f=sc.nextInt();
      if((a | b | c | d | e | f)==0)break ;
      int A=a+d,B=b+e,C=c+f,res=0 ;
      for(int i=0 ; i<3 ; i++)if(A>=i && B>=i && C>=i)res=Math.max(res,i+(A-i)/3+(B-i)/3+(C-i)/3);
      System.out.println(res);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var e : int ; e := sc.getCurrent()->toInteger() ;
    var f : int ; f := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseOr(MathLib.bitwiseOr(MathLib.bitwiseOr(MathLib.bitwiseOr(MathLib.bitwiseOr(a,b),c),d),e),f)) = 0) then     break else skip ; 
    var A : int ; A := a + d ;
    var B : int ; B := b + e ;
    var C : int ; C := c + f ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < 3 do (     if (A >= i & B >= i & C >= i) then     res := Set{res, i + (A - i) / 3 + (B - i) / 3 + (C - i) / 3}->max() ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static final long mod=(long)1e9+7 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    long lcm=1 ;
    long ans=0 ;
    int max=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      max=Math.max(max,a[i]);
    }
    int[] a2=a.clone();
    int[] fact=new int[max+1];
    for(int i=0 ; i<n ; i++){
      for(int j=2 ; j*j<=a[i]; j++){
        int count=0 ;
        while(a[i] % j==0){
          a[i]/=j ;
          count++;
        }
        fact[j]=Math.max(fact[j],count);
      }
      if(a[i]!=1)fact[a[i] ]=Math.max(fact[a[i] ],1);
    }
    for(int i=2 ; i<=max ; i++){
      lcm*=pow(i,fact[i]);
      lcm %=mod ;
    }
    for(int i=0 ; i<n ; i++){
      long t=lcm*pow(a2[i],mod-2)% mod ;
      ans+=lcm*pow(a2[i],mod-2);
      ans %=mod ;
    }
    System.out.println(ans);
    sc.close();
  }
  public static long pow(long x,long n){
    long sum=1 ;
    while(n>0){
      if((n & 1)==1){
        sum=sum*x % mod ;
      }
      x=x*x % mod ;
      n>>=1 ;
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute mod : long := 1e9->oclAsType(long) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var lcm : long ; lcm := 1 ;
    var ans : long ; ans := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     max := Set{max, a[i+1]}->max() )  ;     i := i + 1 ) ; 
    var a2 : Sequence(int) ; a2 := a->copy() ;
    var fact : Sequence(int) ; fact := Integer.subrange(1,max + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 2 ; while j * j <= a[i+1] do ( (     var count : int ; count := 0 ;
     while (a[i+1] mod j = 0) do (     a[i+1] := a[i+1]/(j) ; 
     count := count + 1 ) ; 
     fact[j+1] := Set{fact[j+1], count}->max() )  ;     j := j + 1 ) ; 
     if (a[i+1] /= 1) then     fact[a[i+1]+1] := Set{fact[a[i+1]+1], 1}->max() ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= max do ( (     lcm := lcm*(pow(i, fact[i+1])) ; 
     lcm := lcm mod mod )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var t : long ; t := lcm * pow(a2[i+1], mod - 2) mod mod ;
     ans := ans+(lcm * pow(a2[i+1], mod - 2)) ; 
     ans := ans mod mod )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
  static   operation pow( x : long, n : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 1 ;
     while (n > 0) do (     if ((MathLib.bitwiseAnd(n,1)) = 1) then (     sum := sum * x mod mod ) else skip ; 
     x := x * x mod mod ; 
     n := n/(2->pow(1)) ) ; 
     return sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  PrintStream log=new PrintStream(new OutputStream(){
    public void write(int b){
    }
  }
);
  PrintStream result=System.out ;
  Scanner sc=new Scanner(System.in);
  int get13f(int y2,int m2,int d2){
    int y=0 ;
    int m=1 ;
    int d=1 ;
    int w=6 ;
    int cnt=0 ;
    for(; ; ){
      if(d==13 && w==5)cnt++;
      if(y==y2 && m==m2 && d==d2){
        return cnt ;
      }
      d++;
      w=(w+1)% 7 ;
      int md=31 ;
      if(m==2){
        if((y % 4==0 && y % 100!=0)|| y % 400==0)md=29 ;
        else md=28 ;
      }
      else if(m==4 || m==6 || m==9 || m==11){
        md=30 ;
      }
      if(d>md){
        d=1 ;
        m++;
        if(m>12){
          m=1 ;
          y++;
        }
      }
    }
  }
  void main()throws IOException {
    long y1=sc.nextLong();
    int m1=sc.nextInt();
    int d1=sc.nextInt();
    long y2=sc.nextLong();
    int m2=sc.nextInt();
    int d2=sc.nextInt();
    long y1s=y1/400 ;
    int y1a=(int)(y1 % 400);
    if(d1==13)d1=12 ;
    long c1=get13f(y1a,m1,d1);
    long y2s=y2/400 ;
    int y2a=(int)(y2 % 400);
    long c2=get13f(y2a,m2,d2);
    result.println(688*(y2s-y1s)+c2-c1);
  }
  public static void main(String[] args)throws IOException {
    new Main().main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute log : OclFile := OclFile.newOclFile_Write(OclFile());
   attribute result : OclFile := OclFile["System.out"];
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation get13f( y2 : int, m2 : int, d2 : int) : int
  pre: true
  post: true
  activity: (     var y : int ; y := 0 ;
     var m : int ; m := 1 ;
    var d : int ; d := 1 ;
    var w : int ; w := 6 ;
    var cnt : int ; cnt := 0 ;
      while true do ( (     if (d = 13 & w = 5) then     cnt := cnt + 1 ; else skip ; 
     if (y = y2 & m = m2 & d = d2) then (     return cnt ) else skip ; 
    d := d + 1 ; 
    w := (w + 1) mod 7 ; 
    var md : int ; md := 31 ;
    if (m = 2) then (     if ((y mod 4 = 0 & y mod 100 /= 0) or y mod 400 = 0) then     md := 29 ; else     md := 28 ; ) else     if (m = 4 or m = 6 or m = 9 or m = 11) then (     md := 30 ) else skip ; ;  
    if (d > md) then (     d := 1 ; 
     m := m + 1 ; 
     if (m > 12) then (     m := 1 ; 
     y := y + 1 ) else skip ) else skip ; 
 )  ) ; 
 );
   operation main() : void
  pre: true
  post: true
  activity: (     var y1 : long ; y1 := sc.getCurrent()->toLong() ;
     var m1 : int ; m1 := sc.getCurrent()->toInteger() ;
    var d1 : int ; d1 := sc.getCurrent()->toInteger() ;
    var y2 : long ; y2 := sc.getCurrent()->toLong() ;
    var m2 : int ; m2 := sc.getCurrent()->toInteger() ;
    var d2 : int ; d2 := sc.getCurrent()->toInteger() ;
    var y1s : long ; y1s := y1 / 400 ;
    var y1a : int ; y1a := (y1 mod 400)->oclAsType(int) ;
    if (d1 = 13) then     d1 := 12 ; else skip ; 
    var c1 : long ; c1 := get13f(y1a, m1, d1) ;
    var y2s : long ; y2s := y2 / 400 ;
    var y2a : int ; y2a := (y2 mod 400)->oclAsType(int) ;
    var c2 : long ; c2 := get13f(y2a, m2, d2) ;
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().main() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Fibonacci {
  static boolean isMultipleOf10(int n){
    if(n % 15==0)return true ;
    return false ;
  }
  public static void main(String[] args){
    int n=30 ;
    if(isMultipleOf10(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class Fibonacci {
  static   operation isMultipleOf10( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n mod 15 = 0) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 30 ;
     if (isMultipleOf10(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Solution {
  public String reverseWords(String s){
    String words[]=s.split(" ");
    StringBuilder ans=new StringBuilder();
    for(String word : words)ans.append(new StringBuffer(word).reverse().toString()+" ");
    return ans.toString().trim();
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation reverseWords( s : String) : String
  pre: true
  post: true
  activity: (     var words : Sequence(String) ; words := s->split(" ") ;
     var ans : String ; ans := StringLib.newString() ;
     for (word : words) do (     ans := ans + StringLib.newString(StringLib.newString(word)->reverse()+"" + " ") ;  ) ; 
     return ans+""->trim() );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static final int MAX_TIME=12 ;
  public static final double EPS=1e-10 ;
  public static double dfs(final int K,int day,double r,double l,final double PP,final double P,final double E,final double T){
    if(T-E>l){
      return 0 ;
    }
    if(T+E<r){
      return 0 ;
    }
    final double H=(r+l)/2 ;
    if(day>=K){
      if(Math.abs(T-H)<=E){
        return PP ;
      }
      else {
        return 0 ;
      }
    }
    double ret=0 ;
    if(H>=T){
      ret+=dfs(K,day+1,r,H,PP*(1.0-P),P,E,T);
      ret+=dfs(K,day+1,H,l,PP*P,P,E,T);
    }
    else {
      ret+=dfs(K,day+1,H,l,PP*(1.0-P),P,E,T);
      ret+=dfs(K,day+1,r,H,PP*P,P,E,T);
    }
    return ret ;
  }
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    final int K=sc.nextInt();
    final int R=sc.nextInt();
    final int L=sc.nextInt();
    final double P=sc.nextDouble();
    final double E=sc.nextDouble();
    final double T=sc.nextDouble();
    System.out.printf("%.6f\n",dfs(K,0,R,L,1,P,E,T));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX_TIME : int := 12;
  static    attribute EPS : double := 1e-10;
  static   operation dfs( K : int, day : int, r : double, l : double, PP : double, P : double, E : double, T : double) : double
  pre: true
  post: true
  activity: (     if (T - E > l) then (     return 0 ) else skip ; 
     if (T + E < r) then (     return 0 ) else skip ; 
    var H : double ; H := (r + l) / 2 ;
    if (day >= K) then (     if (if T - H < 0 then -(T - H) else T - H endif <= E) then (     return PP ) else (     return 0 ) ) else skip ; 
    var ret : double ; ret := 0 ;
    if (H >= T) then (     ret := ret+(dfs(K, day + 1, r, H, PP * (1.0 - P), P, E, T)) ; 
     ret := ret+(dfs(K, day + 1, H, l, PP * P, P, E, T)) ) else (     ret := ret+(dfs(K, day + 1, H, l, PP * (1.0 - P), P, E, T)) ; 
     ret := ret+(dfs(K, day + 1, r, H, PP * P, P, E, T)) ) ;  
    return ret 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    var R : int ; R := sc.getCurrent()->toInteger() ;
    var L : int ; L := sc.getCurrent()->toInteger() ;
    var P : double ; P := sc.getCurrent()->toReal() ;
    var E : double ; E := sc.getCurrent()->toReal() ;
    var T : double ; T := sc.getCurrent()->toReal() ;
    OclFile["System.out"].printf("%.6f\n", dfs(K, 0, R, L, 1, P, E, T)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Ex3 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=1 ;
    for(int oo=0 ; oo<t ; oo++){
      int n=in.nextInt();
      if(n % 2==0){
        System.out.println("Mahmoud");
      }
      else {
        n=n-(n-1);
        if(n % 2==0){
          System.out.println("Mahmoud");
        }
        else {
          System.out.println("Ehab");
        }
      }
    }
  }
  public class ListNode<E>{
    private E value ;
    private ListNode next ;
    public ListNode(E newVal,ListNode<E>newNext){
      value=newVal ;
      next=newNext ;
    }
    public E getValue(){
      return value ;
    }
    public ListNode<E>getNext(){
      return next ;
    }
    public void setValue(E newValue){
      value=newValue ;
    }
    public void setNext(ListNode<E>newNext){
      next=newNext ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ex3 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
         var oo : int ; oo := 0 ; while oo < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (     OclFile["System.out"].println("Mahmoud") ) else (     n := n - (n - 1) ; 
     if (n mod 2 = 0) then (     OclFile["System.out"].println("Mahmoud") ) else (     OclFile["System.out"].println("Ehab") ) ) )  ;     oo := oo + 1 ) );
 class ListNode<E> {
   attribute value : E;
   attribute next : ListNode;
   static operation newListNode( newVal : E, newNext : ListNode<E>) : ListNode
  pre: true
  post: true
  activity:
  ( var self : ListNode ;
    self := createListNode();
    self.initialise(newVal, newNext);
    return self );
  operation initialise( newVal : E, newNext : ListNode<E>) : void
  pre: true  post: true
  activity: (     value := newVal ; 
     next := newNext );
   operation getValue() : E
  pre: true
  post: true
  activity: (     return value );
   operation getNext() : ListNode<E>
  pre: true
  post: true
  activity: (     return next );
   operation setValue( newValue : E) : void
  pre: true
  post: true
  activity: (     value := newValue );
   operation setNext( newNext : ListNode<E>) : void
  pre: true
  post: true
  activity: (     next := newNext );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n % 2==0)System.out.print("Mahmoud");
    else {
      System.out.print("Ehab");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then     OclFile["System.out"].print("Mahmoud") ; else (     OclFile["System.out"].print("Ehab") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    int m=sc.nextInt();
    int[] b=new int[m];
    for(int i=0 ; i<m ; i++){
      b[i]=sc.nextInt();
    }
    int i=0 ;
    while(true){
      if(i>=b.length){
        System.out.println("0");
        break ;
      }
      if(i>=a.length){
        System.out.println("1");
        break ;
      }
      if(a[i]>b[i]){
        System.out.println("0");
        break ;
      }
      if(a[i]<b[i]){
        System.out.println("1");
        break ;
      }
      i++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var i : int ; i := 0 ;
    while (true) do (     if (i >= b->size()) then (     OclFile["System.out"].println("0") ; 
     break ) else skip ; 
     if (i >= a->size()) then (     OclFile["System.out"].println("1") ; 
     break ) else skip ; 
    if (a[i+1] > b[i+1]) then (     OclFile["System.out"].println("0") ; 
     break ) else skip ; 
    if (a[i+1] < b[i+1]) then (     OclFile["System.out"].println("1") ; 
     break ) else skip ; 
    i := i + 1 ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test165 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    if(in.nextInt()% 2==0){
      System.out.println("Mahmoud");
    }
    else {
      System.out.println("Ehab");
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test165 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     if (in.getCurrent()->toInteger() mod 2 = 0) then (     OclFile["System.out"].println("Mahmoud") ) else (     OclFile["System.out"].println("Ehab") ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class codeforce {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n % 2==0)System.out.println("Mahmoud");
    else System.out.println("Ehab");
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforce {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then     OclFile["System.out"].println("Mahmoud") ; else     OclFile["System.out"].println("Ehab") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ehab {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    if(t % 2==0){
      System.out.println("Mahmoud");
    }
    else {
      System.out.println("Ehab");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ehab {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
     if (t mod 2 = 0) then (     OclFile["System.out"].println("Mahmoud") ) else (     OclFile["System.out"].println("Ehab") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.awt.geom.Point2D ;
import java.awt.geom.Point2D.Double ;
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new aoj1157().doIt();
  }
  class aoj1157 {
    void doIt(){
      String str=sc.next();
      char ctr[]=str.toCharArray();
      int num[]=new int[12];
      int v=0 ;
      int cnt=0 ;
      int ans=0 ;
      for(int i=0 ; i<ctr.length ; i++){
        if(ctr[i]=='?'){
          v=11-i ;
        }
        else {
          num[11-i]=ctr[i]-'0' ;
        }
      }
      for(int i=0 ; i<10 ; i++){
        int sum=0 ;
        int q=0 ;
        num[v]=i ;
        for(int j=1 ; j<12 ; j++){
          if(j<=6)q=j+1 ;
          else q=j-5 ;
          sum=sum+q*num[j];
        }
        if(sum % 11==1)sum=0 ;
        else sum=sum % 11 ;
        if((11-sum)% 11==num[0]){
          cnt++;
          ans=i ;
        }
      }
      if(cnt==1)System.out.println(ans);
      else System.out.println("MULTIPLE");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     aoj1157.newaoj1157().doIt() );
 class aoj1157 {
   operation doIt() : void
  pre: true
  post: true
  activity: (     var str : String ; str := sc.getCurrent() ;
     var ctr : Sequence(String) ; ctr := str->characters() ;
    var num : Sequence(int) ; num := Integer.subrange(1,12)->collect(0) ;
    var v : int ; v := 0 ;
    var cnt : int ; cnt := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < ctr->size() do ( (     if (ctr[i+1] = '?') then (     v := 11 - i ) else (     num[11 - i+1] := ctr[i+1] - ('0')->char2byte() ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 10 do ( (     var sum : int ; sum := 0 ;
     var q : int ; q := 0 ;
    num[v+1] := i ; 
        var j : int ; j := 1 ; while j < 12 do ( (     if (j <= 6) then     q := j + 1 else     q := j - 5 ; ;  
     sum := sum + q * num[j+1] )  ;     j := j + 1 ) ; 
    if (sum mod 11 = 1) then     sum := 0 else     sum := sum mod 11 ; ;  
    if ((11 - sum) mod 11 = num[0+1]) then (     cnt := cnt + 1 ; 
     ans := i ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (cnt = 1) then     OclFile["System.out"].println(ans) else     OclFile["System.out"].println("MULTIPLE") ; ;  
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int[] num=new int[12];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    for(int i=0,j=11 ; i<12 ; i++,j--){
      if(S.charAt(i)=='?'){
        num[j]=-1 ;
      }
      else {
        num[j]=S.charAt(i)-'0' ;
      }
    }
    int count=0 ;
    int ans=0 ;
    for(int i=0 ; i<12 ; i++){
      if(num[i]==-1){
        for(int j=0 ; j<=9 ; j++){
          num[i]=j ;
          if(check()){
            count++;
            ans=j ;
          }
          num[i]=-1 ;
        }
      }
    }
    if(count>1){
      System.out.println("MULTIPLE");
    }
    else {
      System.out.println(ans);
    }
  }
  static boolean check(){
    int digit=0 ;
    for(int i=11 ; i>=1 ; i--){
      if(i>=7){
        digit+=num[i]*(i-5);
      }
      else {
        digit+=num[i]*(i+1);
      }
    }
    digit %=11 ;
    if(digit<=1){
      digit=0 ;
    }
    else {
      digit=11-digit ;
    }
    return digit==num[0];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute num : Sequence(int) := Integer.subrange(1,12)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
        var i : int ; i := 0 ;
    var j : int ; j := 11 ; while i < 12 do ( (     if (S->at(i+1) = '?') then (     num[j+1] := -1 ) else (     num[j+1] := S->at(i+1) - ('0')->char2byte() ) )  ;     i := i + 1 ;     j := j - 1 ) ; 
    var count : int ; count := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 12 do ( (     if (num[i+1] = -1) then (         var j : int ; j := 0 ; while j <= 9 do ( (     num[i+1] := j ; 
     if (check()) then (     count := count + 1 ; 
     ans := j ) else skip ; 
     num[i+1] := -1 )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    if (count > 1) then (     OclFile["System.out"].println("MULTIPLE") ) else (     OclFile["System.out"].println(ans) ) ;  
 );
  static   operation check() : boolean
  pre: true
  post: true
  activity: (     var digit : int ; digit := 0 ;
         var i : int ; i := 11 ; while i >= 1 do ( (     if (i >= 7) then (     digit := digit+(num[i+1] * ((i)->char2byte() - 5)) ) else (     digit := digit+(num[i+1] * (i + 1)) ) )  ;     i := i - 1 ) ; 
    digit := digit mod 11 ; 
    if (digit <= 1) then (     digit := 0 ) else (     digit := 11 - digit ) ;  
    return digit = num[0+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MOD=1000000007 ;
  static int product(int ar[],int n){
    int result=1 ;
    for(int i=0 ; i<n ; i++)result=(result*ar[i])% MOD ;
    return result ;
  }
  public static void main(String[] args){
    int ar[]={
      1,2,3,4,5 };
      int n=ar.length ;
      System.out.printf("%d",product(ar,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MOD : int := 1000000007;
  static   operation product( ar : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 1 ;
         var i : int ; i := 0 ; while i < n do (     result := (result * ar[i+1]) mod MOD ;  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ar : Sequence(int) ; ar := Sequence{1,2,3,4,5} ;
     var n : int ; n := ar->size() ;
     OclFile["System.out"].printf("%d", product(ar, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String p=sc.next();
    int[] num=new int[13];
    int sum,k=0,count=0,ans=0 ;
    for(int i=11 ; i>=0 ; i--){
      if(p.charAt(11-i)=='?'){
        k=i ;
      }
      else {
        num[i]=p.charAt(11-i)-'0' ;
      }
    }
    for(int j=0 ; j<=9 ; j++){
      num[k]=j ;
      sum=0 ;
      for(int n=11 ; n>=1 ; n--){
        if(n<=6){
          sum+=num[n]*(n+1);
        }
        else if(n>6){
          sum+=num[n]*(n-5);
        }
      }
      sum %=11 ;
      if(sum<=1)sum=0 ;
      else sum=11-sum ;
      if(sum==num[0]){
        ans=num[k];
        count++;
      }
    }
    if(count>1)System.out.println("MULTIPLE");
    else System.out.printf("%d\n",ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : String ; p := sc.getCurrent() ;
    var num : Sequence(int) ; num := Integer.subrange(1,13)->collect(0) ;
    var sum : int ;
    var k : int ; k := 0 ;
    var count : int ; count := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 11 ; while i >= 0 do ( (     if (p->at(11 - i+1) = '?') then (     k := i ) else (     num[i+1] := p->at(11 - i+1) - ('0')->char2byte() ) )  ;     i := i - 1 ) ; 
        var j : int ; j := 0 ; while j <= 9 do ( (     num[k+1] := j ; 
     sum := 0 ; 
        var n : int ; n := 11 ; while n >= 1 do ( (     if (n <= 6) then (     sum := sum+(num[n+1] * (n + 1)) ) else     if (n > 6) then (     sum := sum+(num[n+1] * (n - 5)) ) else skip ; )  ;     n := n - 1 ) ; 
    sum := sum mod 11 ; 
    if (sum <= 1) then     sum := 0 else     sum := 11 - sum ; ;  
    if (sum = num[0+1]) then (     ans := num[k+1] ; 
     count := count + 1 ) else skip ; 
 )  ;     j := j + 1 ) ; 
    if (count > 1) then     OclFile["System.out"].println("MULTIPLE") else     OclFile["System.out"].printf("%d\n", ans) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int[] num=new int[12];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    for(int i=0,j=11 ; i<12 ; i++,j--){
      if(S.charAt(i)=='?'){
        num[j]=-1 ;
      }
      else {
        num[j]=S.charAt(i)-'0' ;
      }
    }
    int count=0 ;
    int ans=0 ;
    for(int i=0 ; i<12 ; i++){
      if(num[i]==-1){
        for(int j=0 ; j<=9 ; j++){
          num[i]=j ;
          if(check()){
            count++;
            ans=j ;
          }
          num[i]=-1 ;
        }
      }
    }
    if(count>1){
      System.out.println("MULTIPLE");
    }
    else {
      System.out.println(ans);
    }
  }
  static boolean check(){
    int digit=0 ;
    for(int i=11 ; i>=1 ; i--){
      if(i>=7){
        digit+=num[i]*(i-5);
      }
      else {
        digit+=num[i]*(i+1);
      }
    }
    digit %=11 ;
    if(digit<=1){
      digit=0 ;
    }
    else {
      digit=11-digit ;
    }
    return digit==num[0];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute num : Sequence(int) := Integer.subrange(1,12)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
        var i : int ; i := 0 ;
    var j : int ; j := 11 ; while i < 12 do ( (     if (S->at(i+1) = '?') then (     num[j+1] := -1 ) else (     num[j+1] := S->at(i+1) - ('0')->char2byte() ) )  ;     i := i + 1 ;     j := j - 1 ) ; 
    var count : int ; count := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 12 do ( (     if (num[i+1] = -1) then (         var j : int ; j := 0 ; while j <= 9 do ( (     num[i+1] := j ; 
     if (check()) then (     count := count + 1 ; 
     ans := j ) else skip ; 
     num[i+1] := -1 )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    if (count > 1) then (     OclFile["System.out"].println("MULTIPLE") ) else (     OclFile["System.out"].println(ans) ) ;  
 );
  static   operation check() : boolean
  pre: true
  post: true
  activity: (     var digit : int ; digit := 0 ;
         var i : int ; i := 11 ; while i >= 1 do ( (     if (i >= 7) then (     digit := digit+(num[i+1] * ((i)->char2byte() - 5)) ) else (     digit := digit+(num[i+1] * (i + 1)) ) )  ;     i := i - 1 ) ; 
    digit := digit mod 11 ; 
    if (digit <= 1) then (     digit := 0 ) else (     digit := 11 - digit ) ;  
    return digit = num[0+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public void duplicateZeros(int[] arr){
    int movePos=0 ;
    int lastPos=arr.length-1 ;
    for(int i=0 ; i<=lastPos-movePos ; i++){
      if(arr[i]==0){
        if(i==lastPos-movePos){
          arr[lastPos]=0 ;
          lastPos--;
          break ;
        }
        movePos++;
      }
    }
    lastPos=lastPos-movePos ;
    for(int i=lastPos ; i>=0 ; i--){
      if(arr[i]==0){
        arr[i+movePos]=0 ;
        movePos--;
        arr[i+movePos]=0 ;
      }
      else {
        arr[i+movePos]=arr[i];
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation duplicateZeros( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var movePos : int ; movePos := 0 ;
     var lastPos : int ; lastPos := arr->size() - 1 ;
        var i : int ; i := 0 ; while i <= lastPos - movePos do ( (     if (arr[i+1] = 0) then (     if (i = lastPos - movePos) then (     arr[lastPos+1] := 0 ; 
     lastPos := lastPos - 1 ; 
     break ) else skip ; 
     movePos := movePos + 1 ) else skip )  ;     i := i + 1 ) ; 
    lastPos := lastPos - movePos ; 
        var i : int ; i := lastPos ; while i >= 0 do ( (     if (arr[i+1] = 0) then (     arr[i + movePos+1] := 0 ; 
     movePos := movePos - 1 ; 
     arr[i + movePos+1] := 0 ) else (     arr[i + movePos+1] := arr[i+1] ) )  ;     i := i - 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPalindrome(String str,int i,int j){
    while(i<j){
      if(str.charAt(i)!=str.charAt(j)){
        return false ;
      }
      i++;
      j--;
    }
    return true ;
  }
  static int maxLenPalindrome(String str,int n,char ch){
    int maxLen=0 ;
    for(int i=0 ; i<n ; i++){
      if(str.charAt(i)==ch){
        for(int j=n-1 ; j>=i ; j--){
          if(str.charAt(j)==ch){
            if(isPalindrome(str,i,j)){
              maxLen=Math.max(maxLen,j-i+1);
              break ;
            }
          }
        }
      }
    }
    return maxLen ;
  }
  public static void main(String[] args){
    String str="lapqooqpqpl" ;
    int n=str.length();
    char ch='p' ;
    System.out.println(maxLenPalindrome(str,n,ch));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPalindrome( str : String, i : int, j : int) : boolean
  pre: true
  post: true
  activity: (     while (i < j) do (     if (str->at(i+1) /= str->at(j+1)) then (     return false ) else skip ; 
     i := i + 1 ; 
     j := j - 1 ) ; 
     return true );
  static   operation maxLenPalindrome( str : String, n : int, ch : String) : int
  pre: true
  post: true
  activity: (     var maxLen : int ; maxLen := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (str->at(i+1) = ch) then (         var j : int ; j := n - 1 ; while j >= i do ( (     if (str->at(j+1) = ch) then (     if (isPalindrome(str, i, j)) then (     maxLen := Set{maxLen, j - i + 1}->max() ; 
     break ) else skip ) else skip )  ;     j := j - 1 ) ) else skip )  ;     i := i + 1 ) ; 
     return maxLen );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "lapqooqpqpl" ;
     var n : int ; n := str->size() ;
     var ch : String ; ch := 'p' ;
     OclFile["System.out"].println(maxLenPalindrome(str, n, ch)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static Scanner scInputData=new Scanner(System.in);
  static ArrayList<Integer>arrA=new ArrayList<Integer>();
  static ArrayList<Integer>arrB=new ArrayList<Integer>();
  public static void main(String[] args){
    getArr(arrA);
    getArr(arrB);
    compareArr(arrA,arrB);
  }
  private static void compareArr(ArrayList<Integer>arrX,ArrayList<Integer>arrY){
    int indexToCompare=(arrX.size()<=arrY.size())? arrX.size(): arrY.size();
    boolean compareCheck=false ;
    for(int index=0 ; index<indexToCompare ; index++){
      compareCheck=compareVal(arrX.get(index),arrY.get(index));
      if(compareCheck){
        break ;
      }
    }
    if(compareCheck==false){
      if(arrX.size()<arrY.size()){
        winB();
      }
      else {
        winA();
      }
    }
  }
  private static boolean compareVal(int valX,int valY){
    if(valX==valY){
      return false ;
    }
    else if(valX<valY){
      winB();
      return true ;
    }
    else {
      winA();
      return true ;
    }
  }
  private static void winA(){
    System.out.println(0);
  }
  private static void winB(){
    System.out.println(1);
  }
  private static void getArr(ArrayList<Integer>arr){
    int iArrNum=0 ;
    iArrNum=scInputData.nextInt();
    while(arr.size()<iArrNum){
      arr.add(scInputData.nextInt());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scInputData : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute arrA : Sequence(int) := Sequence{};
  static   attribute arrB : Sequence(int) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute getArr(arrA) ; 
     execute getArr(arrB) ; 
     execute compareArr(arrA, arrB) );
  static   operation compareArr( arrX : Sequence(int), arrY : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var indexToCompare : int ; indexToCompare := if (arrX->size() <= arrY->size()) then arrX->size() else arrY->size() endif ;
     var compareCheck : boolean ; compareCheck := false ;
         var index : int ; index := 0 ; while index < indexToCompare do ( (     compareCheck := compareVal(arrX->at(index+1), arrY->at(index+1)) ; 
     if (compareCheck) then (     break ) else skip )  ;     index := index + 1 ) ; 
     if (compareCheck = false) then (     if (arrX->size() < arrY->size()) then (     execute winB() ) else (     execute winA() ) ) else skip );
  static   operation compareVal( valX : int, valY : int) : boolean
  pre: true
  post: true
  activity: (     if (valX = valY) then (     return false ) else     if (valX < valY) then (     execute winB() ; 
     return true ) else (     execute winA() ; 
     return true ) ;  );
  static   operation winA() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(0) );
  static   operation winB() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(1) );
  static   operation getArr( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var iArrNum : int ; iArrNum := 0 ;
     iArrNum := scInputData.getCurrent()->toInteger() ; 
     while (arr->size() < iArrNum) do (     arr->excludes(scInputData.getCurrent()->toInteger()) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Digits {
  public static int getFirstDigit(int x){
    while(x>=10)x/=10 ;
    return x ;
  }
  public static int getCountWithSameStartAndEndFrom1(int x){
    if(x<10)return x ;
    int tens=x/10 ;
    int res=tens+9 ;
    int firstDigit=getFirstDigit(x);
    int lastDigit=x % 10 ;
    if(lastDigit<firstDigit)res--;
    return res ;
  }
  public static int getCountWithSameStartAndEnd(int start,int end){
    return getCountWithSameStartAndEndFrom1(end)-getCountWithSameStartAndEndFrom1(start-1);
  }
  public static void main(String[] args){
    int start=5,end=40 ;
    System.out.print(getCountWithSameStartAndEnd(start,end));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Digits {
  static   operation getFirstDigit( x : int) : int
  pre: true
  post: true
  activity: (     while (x >= 10) do     x := x/(10) ; ; 
     return x );
  static   operation getCountWithSameStartAndEndFrom1( x : int) : int
  pre: true
  post: true
  activity: (     if (x < 10) then     return x else skip ; 
     var tens : int ; tens := x / 10 ;
    var res : int ; res := tens + 9 ;
    var firstDigit : int ; firstDigit := getFirstDigit(x) ;
    var lastDigit : int ; lastDigit := x mod 10 ;
    if (lastDigit < firstDigit) then     res := res - 1 ; else skip ; 
    return res 
 );
  static   operation getCountWithSameStartAndEnd( start : int, end : int) : int
  pre: true
  post: true
  activity: (     return getCountWithSameStartAndEndFrom1(end) - getCountWithSameStartAndEndFrom1(start - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var start : int ; start := 5 ;
    var end : int ; end := 40 ;
     OclFile["System.out"].print(getCountWithSameStartAndEnd(start, end)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BREAK {
  public static void main(String[] args){
    Scanner obj=new Scanner(System.in);
    int n=obj.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=obj.nextInt();
    }
    int k=0 ;
    for(int i=0 ; ; i++){
      if(i==n)i=0 ;
      if(arr[i]-k<=0){
        System.out.println(i+1);
        break ;
      }
      k++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BREAK {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : OclFile ; obj := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := obj.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := obj.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var k : int ; k := 0 ;
        var i : int ; i := 0 ; while true do ( (     if (i = n) then     i := 0 ; else skip ; 
     if (arr[i+1] - k <= 0) then (     OclFile["System.out"].println(i + 1) ; 
     break ) else skip ; 
     k := k + 1 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class MyClass {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    long n=Integer.valueOf(br.readLine());
    String[] numbers=br.readLine().split(" ");
    long max=Integer.MAX_VALUE ;
    long max_index=Integer.MAX_VALUE ;
    for(int i=0 ; i<numbers.length ; i++){
      long val=Long.valueOf(numbers[i]);
      long calc=n*(long)Math.ceil((double)(val-i)/n)+i ;
      if(calc<=max){
        max=calc ;
        max_index=i ;
      }
    }
    System.out.println(max_index+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : long ; n := (br.readLine())->toInteger() ;
    var numbers : Sequence(String) ; numbers := br.readLine()->split(" ") ;
    var max : long ; max := 2147483647 ;
    var max_index : long ; max_index := 2147483647 ;
        var i : int ; i := 0 ; while i < numbers->size() do ( (     var val : long ; val := (numbers[i+1])->toLong() ;
     var calc : long ; calc := n * ((val - i)->oclAsType(double) / n)->ceil()->oclAsType(long) + i ;
     if (calc <= max) then (     max := calc ; 
     max_index := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max_index + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int[] a=new int[n];
    Arrays.setAll(a,i->in.nextInt());
    int min=Integer.MAX_VALUE ;
    int res=-1 ;
    for(int i=0 ; i<n ; i++){
      int round=(a[i]-(i+1)+n)/n ;
      if(round<min){
        res=i+1 ;
        min=round ;
      }
    }
    pw.println(res);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
setAll(a, lambda i : OclAny in in.getCurrent()->toInteger()) ; 
    var min : int ; min := 2147483647 ;
    var res : int ; res := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var round : int ; round := (a[i+1] - (i + 1) + n) / n ;
     if (round < min) then (     res := i + 1 ; 
     min := round ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B_World_Cup {
  static Scanner in=new Scanner(System.in);
  static int n ;
  static long a[];
  static void solve(){
    long b[]=new long[n];
    for(int i=0 ; i<n ; ++i){
      b[i]=a[i];
      b[i]=Math.max(0,b[i]-i);
      b[i]=(b[i]/n)+((b[i] % n)>=1 ? 1 : 0);
    }
    int path=0 ;
    long max=Long.MAX_VALUE ;
    for(int i=0 ; i<n ; ++i){
      if(max>b[i]){
        max=b[i];
        path=i+1 ;
      }
    }
    System.out.print(path);
  }
  public static void main(String[] amit){
    n=in.nextInt();
    a=new long[n];
    for(int i=0 ; i<n ; ++i){
      a[i]=in.nextLong();
    }
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_World_Cup {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   attribute a : Sequence(long);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     b[i+1] := a[i+1] ; 
     b[i+1] := Set{0, b[i+1] - i}->max() ; 
     b[i+1] := (b[i+1] / n) + (if (b[i+1] mod n) >= 1 then 1 else 0 endif) )  ;     i := i + 1 ) ; 
    var path : int ; path := 0 ;
    var max : long ; max := "9223372036854775807"->toLong() ;
        var i : int ; i := 0 ; while i < n do ( (     if (max > b[i+1]) then (     max := b[i+1] ; 
     path := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(path) ; 
 );
  static   operation main( amit : Sequence(String)) : void
  pre: true
  post: true
  activity: (     n := in.getCurrent()->toInteger() ; 
     a := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    matrix=new boolean[n][n];
    for(int i=0 ; i<m ; i++){
      int a=sc.nextInt()-1 ;
      int b=sc.nextInt()-1 ;
      matrix[a][b]=true ;
      matrix[b][a]=true ;
    }
    visit=new boolean[n];
    dfs(0);
    System.out.println(result);
  }
  static boolean matrix[][];
  static boolean visit[];
  static int result=0 ;
  static void dfs(int v){
    visit[v]=true ;
    int n=visit.length ;
    boolean end=true ;
    for(int i=0 ; i<n ; i++){
      if(! visit[i] && matrix[v][i]){
        end=false ;
        dfs(i);
      }
    }
    if(end){
      int count=0 ;
      for(int i=0 ; i<n ; i++){
        if(visit[i]){
          count++;
        }
      }
      if(count==n){
        result++;
      }
    }
    visit[v]=false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    matrix := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ; 
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
     var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
     matrix[a+1][b+1] := true ; 
     matrix[b+1][a+1] := true )  ;     i := i + 1 ) ; 
    visit := Integer.subrange(1,n)->collect(false) ; 
    execute dfs(0) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   attribute matrix : Sequence(Sequence(boolean));
  static   attribute visit : Sequence(boolean);
  static   attribute result : int := 0;
  static   operation dfs( v : int) : void
  pre: true
  post: true
  activity: (     visit[v+1] := true ; 
     var n : int ; n := visit->size() ;
    var end : boolean ; end := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (not(visit[i+1]) & matrix[v+1][i+1]) then (     end := false ; 
     execute dfs(i) ) else skip )  ;     i := i + 1 ) ; 
    if (end) then (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (visit[i+1]) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (count = n) then (     result := result + 1 ) else skip ) else skip ; 
    visit[v+1] := false ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int product(int ar[],int n){
    int result=1 ;
    for(int i=0 ; i<n ; i++)result=result*ar[i];
    return result ;
  }
  public static void main(String[] args){
    int ar[]={
      1,2,3,4,5 };
      int n=ar.length ;
      System.out.printf("%d",product(ar,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation product( ar : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 1 ;
         var i : int ; i := 0 ; while i < n do (     result := result * ar[i+1] ;  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ar : Sequence(int) ; ar := Sequence{1,2,3,4,5} ;
     var n : int ; n := ar->size() ;
     OclFile["System.out"].printf("%d", product(ar, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  private int count=0 ;
  private ArrayList[] graph ;
  boolean[] visited ;
  public int undirectedGraphTraversalWays(int[][] nums,int n){
    graph=new ArrayList[n];
    for(int i=0 ; i<n ; i++){
      graph[i]=new ArrayList();
    }
    visited=new boolean[n];
    for(int i=0 ; i<nums.length ; i++){
      graph[nums[i][0]-1] .add(nums[i][1]-1);
      graph[nums[i][1]-1] .add(nums[i][0]-1);
    }
    visited[0]=true ;
    undirectedGraphTraversalWaysHelper(graph[0]);
    return count ;
  }
  private boolean undirectedGraphTraversalWaysHelper(ArrayList nodes){
    boolean flag=true ;
    for(boolean visitedFlag : visited){
      flag &=visitedFlag ;
    }
    if(flag){
      return true ;
    }
    for(Object node : nodes){
      int index=((Integer)node).intValue();
      if(visited[index]){
        continue ;
      }
      visited[index]=true ;
      if(undirectedGraphTraversalWaysHelper(graph[index])){
        count++;
      }
      visited[index]=false ;
    }
    return false ;
  }
  public static void main(String[] args){
    Main sol=new Main();
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int[][] edges=new int[m][2];
    for(int i=0 ; i<m ; i++){
      edges[i][0]=sc.nextInt();
      edges[i][1]=sc.nextInt();
    }
    System.out.println(sol.undirectedGraphTraversalWays(edges,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute count : int := 0;
   attribute graph : Sequence(Sequence);
   attribute visited : Sequence(boolean);
   operation undirectedGraphTraversalWays( nums : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     graph := Integer.subrange(1,n)->collect(null) ; 
         var i : int ; i := 0 ; while i < n do ( (     graph[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
    visited := Integer.subrange(1,n)->collect(false) ; 
        var i : int ; i := 0 ; while i < nums->size() do ( (     graph[nums[i+1][0+1] - 1+1]->excludes(nums[i+1][1+1] - 1) ; 
     graph[nums[i+1][1+1] - 1+1]->excludes(nums[i+1][0+1] - 1) )  ;     i := i + 1 ) ; 
    visited[0+1] := true ; 
    execute undirectedGraphTraversalWaysHelper(graph[0+1]) ; 
    return count 
 );
   operation undirectedGraphTraversalWaysHelper( nodes : Sequence) : boolean
  pre: true
  post: true
  activity: (     var flag : boolean ; flag := true ;
     for (visitedFlag : visited) do ( (     flag := MathLib.bitwiseAnd(flag, visitedFlag) )  ) ; 
    if (flag) then (     return true ) else skip ; 
    for (node : nodes) do ( (     var index : int ; index := (node->oclAsType(int))->oclAsType(int) ;
     if (visited[index+1]) then (     continue ) else skip ; 
    visited[index+1] := true ; 
    if (undirectedGraphTraversalWaysHelper(graph[index+1])) then (     count := count + 1 ) else skip ; 
    visited[index+1] := false ; 
 )  ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sol : Main ; sol := Main.newMain() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var edges : Sequence(Sequence(int)) ; edges := Integer.subrange(1,m)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < m do ( (     edges[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     edges[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sol.undirectedGraphTraversalWays(edges, n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(final String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int n=scanner.nextInt();
    final int m=scanner.nextInt();
    final Map<Integer,List<Integer>>graph=new HashMap<>();
    for(int i=0 ; i<m ; i++){
      final int a=scanner.nextInt();
      final int b=scanner.nextInt();
      graph.computeIfAbsent(a,v->new ArrayList<>()).add(b);
      graph.computeIfAbsent(b,v->new ArrayList<>()).add(a);
    }
    final boolean[] isVisited=new boolean[n+1];
    final int answer=dfs(graph,1,isVisited);
    System.out.println(answer);
  }
  private static int dfs(final Map<Integer,List<Integer>>graph,final int current,final boolean[] isVisited){
    isVisited[current]=true ;
    if(isVisitedAll(isVisited)){
      return 1 ;
    }
    int sum=0 ;
    for(final int next : graph.get(current)){
      if(! isVisited[next]){
        sum+=dfs(graph,next,Arrays.copyOf(isVisited,isVisited.length));
      }
    }
    return sum ;
  }
  private static boolean isVisitedAll(final boolean[] isVisited){
    return IntStream.range(1,isVisited.length).mapToObj(i->isVisited[i]).allMatch(Boolean :: booleanValue);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var graph : Map(int,Sequence(int)) ; graph := Map{} ;
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
     graph.computeIfAbsent(a, lambda v : OclAny in Sequence{})->excludes(b) ; 
     graph.computeIfAbsent(b, lambda v : OclAny in Sequence{})->excludes(a) )  ;     i := i + 1 ) ; 
    var isVisited : Sequence(boolean) ; isVisited := Integer.subrange(1,n + 1)->collect(false) ;
    var answer : int ; answer := dfs(graph, 1, isVisited) ;
    OclFile["System.out"].println(answer) ; 
 );
  static   operation dfs( graph : Map(int,Sequence(int)), current : int, isVisited : Sequence(boolean)) : int
  pre: true
  post: true
  activity: (     isVisited[current+1] := true ; 
     if (isVisitedAll(isVisited)) then (     return 1 ) else skip ; 
    var sum : int ; sum := 0 ;
    for (next : graph->at(current)) do ( (     if (not(isVisited[next+1])) then (     sum := sum+(dfs(graph, next, isVisited.subrange(1,isVisited->size()))) ) else skip )  ) ; 
    return sum 
 );
  static   operation isVisitedAll( isVisited : Sequence(boolean)) : boolean
  pre: true
  post: true
  activity: (     return Integer.subrange(1, isVisited->size()-1).mapToObj(lambda i : OclAny in isVisited[i+1])->forAll( _x2 | (lambda _pars : OclAny in Boolean.newBoolean().booleanValue(_pars))->apply(_x2) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.stream.Collectors ;
import java.util.stream.IntStream ;
public class Main {
  private static int solve(Set<int[]>nodes,Set<Integer>vertexes,int pos){
    if(vertexes.contains(pos)){
      if(vertexes.size()==1){
        return 1 ;
      }
    }
    else {
      return 0 ;
    }
    int count=0 ;
    for(int[] node : nodes){
      if(node[0]==pos){
        count+=solve(nodes,vertexes.stream().filter(x->x!=pos).collect(Collectors.toSet()),node[1]);
      }
      else if(node[1]==pos){
        count+=solve(nodes,vertexes.stream().filter(x->x!=pos).collect(Collectors.toSet()),node[0]);
      }
    }
    return count ;
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int m=scanner.nextInt();
    Set<int[]>xs=new HashSet<>();
    for(int i=0 ; i<m ; i++){
      int[] node=new int[2];
      node[0]=scanner.nextInt();
      node[1]=scanner.nextInt();
      xs.add(node);
    }
    Set<Integer>vertexes=IntStream.rangeClosed(1,n).boxed().collect(Collectors.toSet());
    System.out.println(solve(xs,vertexes,1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( nodes : Set(Sequence(int)), vertexes : Set(int), pos : int) : int
  pre: true
  post: true
  activity: (     if (vertexes->includes(pos)) then (     if (vertexes->size() = 1) then (     return 1 ) else skip ) else (     return 0 ) ;  
     var count : int ; count := 0 ;
     for (node : nodes) do ( (     if (node[0+1] = pos) then (     count := count+(solve(nodes, vertexes->select( _x1 | (lambda x : OclAny in x /= pos)->apply(_x1) ).collect(Collectors.toSet()), node[1+1])) ) else     if (node[1+1] = pos) then (     count := count+(solve(nodes, vertexes->select( _x1 | (lambda x : OclAny in x /= pos)->apply(_x1) ).collect(Collectors.toSet()), node[0+1])) ) else skip ; )  ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var xs : Set(Sequence(int)) ; xs := Set{} ;
        var i : int ; i := 0 ; while i < m do ( (     var node : Sequence(int) ; node := Integer.subrange(1,2)->collect(0) ;
     node[0+1] := scanner.getCurrent()->toInteger() ; 
     node[1+1] := scanner.getCurrent()->toInteger() ; 
     xs := xs->including(node) )  ;     i := i + 1 ) ; 
    var vertexes : Set(int) ; vertexes := Integer.subrange(1, n).collect(Collectors.toSet()) ;
    OclFile["System.out"].println(solve(xs, vertexes, 1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static int compare(int A[],int B[]){
    int i=0 ;
    while(i<A.length && i<B.length){
      if(A[i]==B[i]);
      else if(A[i]>B[i])return 0 ;
      else return 1 ;
      i++;
    }
    if(A.length==B.length || i==B.length)return 0 ;
    else return 1 ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int A[]=new int[n];
    for(int i=0 ; i<n ; i++)A[i]=sc.nextInt();
    int m=sc.nextInt();
    int B[]=new int[m];
    for(int i=0 ; i<m ; i++)B[i]=sc.nextInt();
    System.out.println(compare(A,B));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation compare( A : Sequence(int), B : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     while (i < A->size() & i < B->size()) do (     if (A[i+1] = B[i+1]) then  else     if (A[i+1] > B[i+1]) then     return 0 else     return 1 ;  ;  
     i := i + 1 ) ; 
     if (A->size() = B->size() or i = B->size()) then     return 0 else     return 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     A[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var B : Sequence(int) ; B := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     B[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(compare(A, B)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  private static boolean[][] graph ;
  private static boolean allVisited(boolean[] visited){
    for(int i=0 ; i<visited.length ; i++){
      if(! visited[i]){
        return false ;
      }
    }
    return true ;
  }
  private static int dfs(int v,int n,boolean[] visited){
    if(allVisited(visited)){
      return 1 ;
    }
    int result=0 ;
    for(int i=0 ; i<n ; i++){
      if(! graph[v][i] || visited[i]){
        continue ;
      }
      visited[i]=true ;
      result+=dfs(i,n,visited);
      visited[i]=false ;
    }
    return result ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    List<Integer>a=new ArrayList<>();
    List<Integer>b=new ArrayList<>();
    graph=new boolean[n][n];
    for(int i=0 ; i<m ; i++){
      a.add(sc.nextInt());
      b.add(sc.nextInt());
    }
    for(int i=0 ; i<m ; i++){
      graph[a.get(i)-1][b.get(i)-1]=true ;
      graph[b.get(i)-1][a.get(i)-1]=true ;
    }
    boolean[] visited=new boolean[n];
    for(int i=0 ; i<n ; i++){
      visited[i]=false ;
    }
    visited[0]=true ;
    System.out.println(dfs(0,n,visited));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute graph : Sequence(Sequence(boolean));
  static   operation allVisited( visited : Sequence(boolean)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < visited->size() do ( (     if (not(visited[i+1])) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation dfs( v : int, n : int, visited : Sequence(boolean)) : int
  pre: true
  post: true
  activity: (     if (allVisited(visited)) then (     return 1 ) else skip ; 
     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (not(graph[v+1][i+1]) or visited[i+1]) then (     continue ) else skip ; 
     visited[i+1] := true ; 
     result := result+(dfs(i, n, visited)) ; 
     visited[i+1] := false )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{} ;
    var b : Sequence(int) ; b := Sequence{} ;
    graph := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ; 
        var i : int ; i := 0 ; while i < m do ( (     a := a->including(sc.getCurrent()->toInteger()) ; 
     b := b->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     graph[a->at(i+1) - 1+1][b->at(i+1) - 1+1] := true ; 
     graph[b->at(i+1) - 1+1][a->at(i+1) - 1+1] := true )  ;     i := i + 1 ) ; 
    var visited : Sequence(boolean) ; visited := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     visited[i+1] := false )  ;     i := i + 1 ) ; 
    visited[0+1] := true ; 
    OclFile["System.out"].println(dfs(0, n, visited)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    var sc=new Scanner(System.in);
    var s=sc.next();
    var t=sc.next();
    sc.close();
    var count=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(! s.substring(i,i+1).equals(t.substring(i,i+1))){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : var ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : var ; s := sc.next() ;
    var t : var ; t := sc.next() ;
    sc.close() ; 
    var count : var ; count := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (not(s.subrange(i+1,i + 1) = t.subrange(i+1,i + 1))) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    FastReader in=new FastReader();
    FastWriter out=new FastWriter();
    String s=in.nextLine();
    String t=in.nextLine();
    int ans=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)!=t.charAt(i))ans++;
    }
    out.pl(ans);
    out.close();
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    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 ;
  }
}
class FastWriter {
  PrintWriter out ;
  FastWriter(){
    out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    out.flush();
  }
  void pl(Object o){
    out.write(o.toString());
    out.write("\n");
    out.flush();
  }
  void pl(){
    out.write("\n");
  }
  void p(Object o){
    out.write(o.toString());
  }
  void close(){
    out.flush();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : FastWriter ; out := FastWriter.newFastWriter() ;
    var s : String ; s := in.nextLine() ;
    var t : String ; t := in.nextLine() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) /= t->at(i+1)) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    out.pl(ans) ; 
    out.close() ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
class FastWriter {
   attribute out : OclFile;
   static operation newFastWriter() : FastWriter
  pre: true
  post: true
  activity:
  ( var self : FastWriter ;
    self := createFastWriter();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ; 
     skip );
   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     skip ; 
     skip ; 
     skip );
   operation pl() : void
  pre: true
  post: true
  activity: (     skip );
   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     skip );
   operation close() : void
  pre: true
  post: true
  activity: (     skip ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[])throws IOException {
    FastReader sc=new FastReader();
    PrintWriter wr=new PrintWriter(System.out);
    String s=sc.nextLine();
    String t=sc.nextLine();
    int count=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)!=t.charAt(i))count++;
    }
    wr.println(count);
    wr.flush();
    wr.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var wr : OclFile ; wr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : String ; s := sc.nextLine() ;
    var t : String ; t := sc.nextLine() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) /= t->at(i+1)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    char[] s=sc.nextLine().toCharArray();
    char[] t=sc.nextLine().toCharArray();
    int cnt=0 ;
    for(int i=0 ; i<s.length ; i++){
      if(s[i]!=t[i])cnt++;
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := sc.nextLine()->characters() ;
     var t : Sequence(String) ; t := sc.nextLine()->characters() ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s[i+1] /= t[i+1]) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(final String args[]){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    String T=sc.next();
    int c=S.length();
    int cnt=0 ;
    for(int i=0 ; i<c ; i++)if(S.charAt(i)!=T.charAt(i)){
      cnt++;
    }
    System.out.println(cnt);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : String) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    var T : String ; T := sc.getCurrent() ;
    var c : int ; c := S->size() ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < c do (     if (S->at(i+1) /= T->at(i+1)) then (     cnt := cnt + 1 ) else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GFG {
  static int fact(int n){
    if(n<=1)return 1 ;
    return n*fact(n-1);
  }
  static int nPr(int n,int r){
    return fact(n)/fact(n-r);
  }
  public static void main(String args[]){
    int n=5 ;
    int r=2 ;
    System.out.println(n+"P"+r+"="+nPr(n,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fact( n : int) : int
  pre: true
  post: true
  activity: (     if (n <= 1) then     return 1 else skip ; 
     return n * fact(n - 1) );
  static   operation nPr( n : int, r : int) : int
  pre: true
  post: true
  activity: (     return fact(n) / fact(n - r) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var r : int ; r := 2 ;
     OclFile["System.out"].println(n + "P" + r + "=" + nPr(n, r)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int totEdge(int n){
    int result=0 ;
    result=(n*(n-1))/2 ;
    return result ;
  }
  public static void main(String[] args){
    int n=6 ;
    System.out.println(totEdge(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation totEdge( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     result := (n * (n - 1)) / 2 ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(totEdge(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ApproximatingConstantRange {
  private Scanner sc ;
  public void approximatingConstantRange(){
  }
  public void approximatingConstantRangeV2(){
    sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] cnt=new int[100001];
    int[] a=new int[100001];
    int countDiff=0 ;
    for(int i=0 ; i<n ; ++i){
      a[i]=sc.nextInt();
    }
    int l=0 ;
    int maxLen=0 ;
    for(int r=0 ; r<n ; ++r){
      if(cnt[a[r] ]==0){
        countDiff++;
      }
      cnt[a[r] ]++;
      while(countDiff>2){
        cnt[a[l] ]--;
        if(cnt[a[l] ]==0){
          countDiff--;
        }
        l++;
      }
      maxLen=Math.max(maxLen,r-l+1);
    }
    System.out.println(""+maxLen);
  }
  public static void main(String[] args){
    ApproximatingConstantRange approximatingConstantRange=new ApproximatingConstantRange();
    approximatingConstantRange.approximatingConstantRangeV2();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ApproximatingConstantRange {
   attribute sc : OclFile;
   operation approximatingConstantRange() : void
  pre: true
  post: true
  activity: skip;
   operation approximatingConstantRangeV2() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,100001)->collect(0) ;
    var a : Sequence(int) ; a := Integer.subrange(1,100001)->collect(0) ;
    var countDiff : int ; countDiff := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var l : int ; l := 0 ;
    var maxLen : int ; maxLen := 0 ;
        var r : int ; r := 0 ; while r < n do ( (     if (cnt[a[r+1]+1] = 0) then (     countDiff := countDiff + 1 ) else skip ; 
     cnt[a[r+1]+1] := cnt[a[r+1]+1] + 1 ; 
     while (countDiff > 2) do (     cnt[a[l+1]+1] := cnt[a[l+1]+1] - 1 ; 
     if (cnt[a[l+1]+1] = 0) then (     countDiff := countDiff - 1 ) else skip ; 
     l := l + 1 ) ; 
     maxLen := Set{maxLen, r - l + 1}->max() )  ;     r := r + 1 ) ; 
    OclFile["System.out"].println("" + maxLen) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var approximatingConstantRange : ApproximatingConstantRange ; approximatingConstantRange := ApproximatingConstantRange.newApproximatingConstantRange() ;
     approximatingConstantRange.approximatingConstantRangeV2() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ApproximatingaConstantRange {
  static Scanner sc ;
  public static void main(String[] args){
    sc=new Scanner(System.in);
    int n=sc.nextInt();
    int prev=-1 ;
    int current,next ;
    int prevCount=0,currentCount=1 ;
    int longest=1 ;
    current=sc.nextInt();
    for(int i=1 ; i<n ; i++){
      next=sc.nextInt();
      if(next==current){
        currentCount++;
      }
      else if(next==prev){
        prevCount+=currentCount ;
        prev=current ;
        current=next ;
        currentCount=1 ;
      }
      else {
        longest=Math.max(longest,currentCount+prevCount);
        prev=current ;
        prevCount=currentCount ;
        current=next ;
        currentCount=1 ;
      }
    }
    System.out.println(Math.max(longest,currentCount+prevCount));
  }
}
------------------------------------------------------------
OCL File:
---------
 class ApproximatingaConstantRange {
  static   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var prev : int ; prev := -1 ;
    var current : int ;
    var next : int ;
    var prevCount : int ; prevCount := 0 ;
    var currentCount : int ; currentCount := 1 ;
    var longest : int ; longest := 1 ;
    current := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i < n do ( (     next := sc.getCurrent()->toInteger() ; 
     if (next = current) then (     currentCount := currentCount + 1 ) else     if (next = prev) then (     prevCount := prevCount+(currentCount) ; 
     prev := current ; 
     current := next ; 
     currentCount := 1 ) else (     longest := Set{longest, currentCount + prevCount}->max() ; 
     prev := current ; 
    prevCount := currentCount ; 
    current := next ; 
    currentCount := 1 ; 
 ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{longest, currentCount + prevCount}->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import com.sun.corba.se.spi.orbutil.fsm.Guard.Result ;
class Solution {
  public String toHex(int num){
    String hex_map="0123456789abcdef" ;
    if(num==0)return "0" ;
    String res="" ;
    while(num!=0 && res.length()<8){
      res=hex_map.charAt(num & 15)+res ;
      num=num>>4 ;
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
   operation toHex( num : int) : String
  pre: true
  post: true
  activity: (     var hex_map : String ; hex_map := "0123456789abcdef" ;
     if (num = 0) then     return "0" else skip ; 
    var res : String ; res := "" ;
    while (num /= 0 & res->size() < 8) do (     res := hex_map->at(num & 15+1) + res ; 
     num := (num/(2->pow(4)))->oclAsType(long) ) ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int[] A=new int[1001],B=new int[1001];
    int a=in.nextInt();
    for(int i=0 ; i<a ; i++)A[i]=Integer.parseInt(in.next());
    int b=in.nextInt();
    for(int i=0 ; i<b ; i++)B[i]=Integer.parseInt(in.next());
    int comparate=compare(0,A,B);
    if(comparate==-1){
      if(a<b)comparate=1 ;
      else comparate=0 ;
    }
    System.out.println(comparate);
    in.close();
  }
  static int compare(int idx,int[] A,int[] B){
    if(idx==1001)return-1 ;
    if(A[idx]<B[idx])return 1 ;
    else if(A[idx]>B[idx])return 0 ;
    else return compare(idx+1,A,B);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : Sequence(int) ; A := Integer.subrange(1,1001)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,1001)->collect(0) ;
    var a : int ; a := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < a do (     A[i+1] := (in.getCurrent())->toInteger() ;  ;     i := i + 1 ) ; 
    var b : int ; b := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < b do (     B[i+1] := (in.getCurrent())->toInteger() ;  ;     i := i + 1 ) ; 
    var comparate : int ; comparate := compare(0, A, B) ;
    if (comparate = -1) then (     if (a < b) then     comparate := 1 ; else     comparate := 0 ; ) else skip ; 
    OclFile["System.out"].println(comparate) ; 
    skip ; 
 );
  static   operation compare( idx : int, A : Sequence(int), B : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (idx = 1001) then     return -1 else skip ; 
     if (A[idx+1] < B[idx+1]) then     return 1 else     if (A[idx+1] > B[idx+1]) then     return 0 else     return compare(idx + 1, A, B) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.max ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a[]=new int[100005];
    int cnt[]=new int[100005];
    int n ;
    int res=1,count_diff=0 ;
    n=sc.nextInt();
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    int l=0 ;
    for(int r=0 ; r<n ; r++){
      if(cnt[a[r] ]==0){
        count_diff++;
      }
      cnt[a[r] ]++;
      while(count_diff>2){
        cnt[a[l] ]--;
        if(cnt[a[l] ]==0){
          count_diff--;
        }
        l++;
      }
      res=max(res,r-l+1);
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,100005)->collect(0) ;
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,100005)->collect(0) ;
    var n : int ;
    var res : int ; res := 1 ;
    var count_diff : int ; count_diff := 0 ;
    n := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var l : int ; l := 0 ;
        var r : int ; r := 0 ; while r < n do ( (     if (cnt[a[r+1]+1] = 0) then (     count_diff := count_diff + 1 ) else skip ; 
     cnt[a[r+1]+1] := cnt[a[r+1]+1] + 1 ; 
     while (count_diff > 2) do (     cnt[a[l+1]+1] := cnt[a[l+1]+1] - 1 ; 
     if (cnt[a[l+1]+1] = 0) then (     count_diff := count_diff - 1 ) else skip ; 
     l := l + 1 ) ; 
     res := Set{res, r - l + 1}->max() )  ;     r := r + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int arr[]={
    1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,4,1,2,3,1,2,3,4 };
    public static int countKeyPressed(String str,int len){
      int count=0 ;
      for(int i=0 ; i<len ; i++)count=count+arr[str.charAt(i)-'a'];
      return count ;
    }
    public static void main(String[] args){
      String str="abcdef" ;
      int len=str.length();
      System.out.print(countKeyPressed(str,len));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute arr : int := Sequence{1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,4,1,2,3,1,2,3,4};
  static   operation countKeyPressed( str : String, len : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < len do (     count := count + arr[str->at(i+1) - ('a')->char2byte()+1] ;  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abcdef" ;
     var len : int ; len := str->size() ;
     OclFile["System.out"].print(countKeyPressed(str, len)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int height=sc.nextInt();
    int[] a=readArray(sc,m);
    int[] b=readArray(sc,n);
    int[][] h=new int[n][];
    for(int i=0 ; i<h.length ; i++){
      h[i]=readArray(sc,m);
    }
    System.out.print(solve(h,a,b,height));
    sc.close();
  }
  static int[] readArray(Scanner sc,int size){
    int[] result=new int[size];
    for(int i=0 ; i<result.length ; i++){
      result[i]=sc.nextInt();
    }
    return result ;
  }
  static String solve(int[][] h,int[] a,int[] b,int height){
    int n=h.length ;
    int m=h[0] .length ;
    int[][] heights=new int[n][m];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        heights[i][j]=(h[i][j]==0)? 0 : Math.min(a[j],b[i]);
      }
    }
    return Arrays.stream(heights).map(row->Arrays.stream(row).mapToObj(String :: valueOf).collect(Collectors.joining(" "))).collect(Collectors.joining("\n"));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var height : int ; height := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := readArray(sc, m) ;
    var b : Sequence(int) ; b := readArray(sc, n) ;
    var h : Sequence(Sequence(int)) ; h := Integer.subrange(1,n)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < h->size() do ( (     h[i+1] := readArray(sc, m) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(solve(h, a, b, height)) ; 
    skip ; 
 );
  static   operation readArray( sc : OclFile, size : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var result : Sequence(int) ; result := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < result->size() do ( (     result[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return result );
  static   operation solve( h : Sequence(Sequence(int)), a : Sequence(int), b : Sequence(int), height : int) : String
  pre: true
  post: true
  activity: (     var n : int ; n := h->size() ;
     var m : int ; m := h[0+1]->size() ;
    var heights : Sequence(Sequence(int)) ; heights := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     heights[i+1][j+1] := if (h[i+1][j+1] = 0) then 0 else Set{a[j+1], b[i+1]}->min() endif )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return stream(heights)->collect( _x1 | (lambda row : OclAny in stream(row).mapToObj(lambda _pars : OclAny in String.newString().valueOf(_pars)).collect(Collectors.joining(" ")))->apply(_x1) ).collect(Collectors.joining("\n")) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.TreeMap ;
import java.util.TreeSet ;
public class trailzero {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int h=sc.nextInt();
    int a[]=new int[n];
    int b[]=new int[m];
    int c[][]=new int[n][m];
    int p[][]=new int[n][m];
    for(int j=0 ; j<m ; j++){
      b[j]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        c[i][j]=sc.nextInt();
        if(c[i][j]==0){
          p[i][j]=0 ;
        }
        else {
          p[i][j]=Math.min(a[i],b[j]);
        }
      }
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        System.out.print(p[i][j]+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class trailzero {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
    var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var p : Sequence(Sequence(int)) ; p := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
        var j : int ; j := 0 ; while j < m do ( (     b[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     c[i+1][j+1] := sc.getCurrent()->toInteger() ; 
     if (c[i+1][j+1] = 0) then (     p[i+1][j+1] := 0 ) else (     p[i+1][j+1] := Set{a[i+1], b[j+1]}->min() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     OclFile["System.out"].print(p[i+1][j+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import org.w3c.dom.ls.LSOutput ;
import java.util.*;
import java.util.function.IntBinaryOperator ;
public class Example {
  static long[][] dp ;
  static int mod=1000000000+7 ;
  static long[] ans=new long[100000+1];
  static List<List<Integer>>adj ;
  static int[] vis ;
  static int[] dis ;
  static int row ;
  static boolean[] chosen ;
  static List<Integer>permutation ;
  static int k ;
  static int count ;
  static int[][] arr ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int h=sc.nextInt();
    int[] font=new int[m+1];
    int[] left=new int[n+1];
    for(int i=1 ; i<=m ; i++){
      font[i]=sc.nextInt();
    }
    for(int j=1 ; j<=n ; j++){
      left[j]=sc.nextInt();
    }
    int[][] ans=new int[n+1][m+1];
    int[][] top=new int[n+1][m+1];
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=m ; j++){
        top[i][j]=sc.nextInt();
        if(top[i][j]==1){
          ans[i][j]=Math.min(left[i],font[j]);
        }
      }
    }
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=m ; j++){
        System.out.print(ans[i][j]+" ");
      }
      System.out.println();
    }
  }
}
class Pair {
  int a,b ;
  public Pair(int a,int b){
    this.a=a ;
    this.b=b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Example {
  static   attribute dp : Sequence(Sequence(long));
  static   attribute mod : int := 1000000000 + 7;
  static   attribute ans : Sequence(long) := Integer.subrange(1,100000 + 1)->collect(0);
  static   attribute adj : Sequence(Sequence(int));
  static   attribute vis : Sequence(int);
  static   attribute dis : Sequence(int);
  static   attribute row : int;
  static   attribute chosen : Sequence(boolean);
  static   attribute permutation : Sequence(int);
  static   attribute k : int;
  static   attribute count : int;
  static   attribute arr : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var font : Sequence(int) ; font := Integer.subrange(1,m + 1)->collect(0) ;
    var left : Sequence(int) ; left := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= m do ( (     font[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var j : int ; j := 1 ; while j <= n do ( (     left[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    var ans : Sequence(Sequence(int)) ; ans := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
    var top : Sequence(Sequence(int)) ; top := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= m do ( (     top[i+1][j+1] := sc.getCurrent()->toInteger() ; 
     if (top[i+1][j+1] = 1) then (     ans[i+1][j+1] := Set{left[i+1], font[j+1]}->min() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= m do ( (     OclFile["System.out"].print(ans[i+1][j+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}
class Pair {
   attribute a : int;
   static operation newPair( a : int, b : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static long squareRoot(int n){
    int x=n ;
    int y=1 ;
    while(x>y){
      x=(x+y)/2 ;
      y=n/x ;
    }
    return(long)x ;
  }
  static public void main(String[] args){
    int n=49 ;
    System.out.println("root of "+n+" is "+squareRoot(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation squareRoot( n : int) : long
  pre: true
  post: true
  activity: (     var x : int ; x := n ;
     var y : int ; y := 1 ;
     while (x > y) do (     x := (x + y) / 2 ; 
     y := n / x ) ; 
     return x->oclAsType(long) );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 49 ;
     OclFile["System.out"].println("root of " + n + " is " + squareRoot(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  int n ;
  int map[][];
  int w[];
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      n=sc.nextInt();
      if(n==0)break ;
      map=new int[n][4];
      for(int i=0 ; i<n ; i++)for(int j=0 ; j<4 ; j++){
        map[i][j]=sc.nextInt();
      }
      w=new int[n+1];
      fill(w,-1);
      int max=0 ;
      for(int i=0 ; i<n ; i++){
        max=max(max,solve(i));
      }
      System.out.println(max);
    }
  }
  int solve(int i){
    if(w[i]>=0)return w[i];
    int l=map[i][2]!=0 ? solve(map[i][2]-1): 1 ;
    int r=map[i][3]!=0 ? solve(map[i][3]-1): 1 ;
    int wait=0 ;
    wait=lcm(l*map[i][0],r*map[i][1]);
    wait=wait/map[i][0]+wait/map[i][1];
    return w[i]=wait ;
  }
  int lcm(int x,int y){
    int x_=x ;
    int y_=y ;
    int z=x_ % y_ ;
    while(z!=0){
      x_=y_ ;
      y_=z ;
      z=x_ % y_ ;
    }
    return x/y_*y ;
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute n : int;
   attribute map : Sequence(Sequence(int));
   attribute w : Sequence(int);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
    map := Integer.subrange(1,n)->collect(Integer.subrange(1,4)->collect(0)) ; 
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < 4 do ( (     map[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    w := Integer.subrange(1,n + 1)->collect(0) ; 
    execute fill(w, -1) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     max := Set{max, solve(i)}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 )  ) );
   operation solve( i : int) : int
  pre: true
  post: true
  activity: (     if (w[i+1] >= 0) then     return w[i+1] else skip ; 
     var l : int ; l := if map[i+1][2+1] /= 0 then solve(map[i+1][2+1] - 1) else 1 endif ;
    var r : int ; r := if map[i+1][3+1] /= 0 then solve(map[i+1][3+1] - 1) else 1 endif ;
    var wait : int ; wait := 0 ;
    wait := lcm(l * map[i+1][0+1], r * map[i+1][1+1]) ; 
    wait := wait / map[i+1][0+1] + wait / map[i+1][1+1] ; 
    return w[i+1] 
 );
   operation lcm( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var x_ : int ; x_ := x ;
     var y_ : int ; y_ := y ;
    var z : int ; z := x_ mod y_ ;
    while (z /= 0) do (     x_ := y_ ; 
     y_ := z ; 
     z := x_ mod y_ ) ; 
    return x / y_ * y 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static int mobile[][];
  static int n ;
  static long weight[];
  public static long f(int id){
    if(0<weight[id]){
      return weight[id];
    }
    long le=1 ;
    long ri=1 ;
    if(mobile[id][2]!=0){
      le=f(mobile[id][2]-1);
    }
    if(mobile[id][3]!=0){
      ri=f(mobile[id][3]-1);
    }
    long kle=1 ;
    long kri=1 ;
    while(true){
      if(le*kle*mobile[id][0]==ri*kri*mobile[id][1]){
        break ;
      }
      else if(le*kle*mobile[id][0]<ri*kri*mobile[id][1]){
        kle++;
      }
      else {
        kri++;
      }
    }
    return weight[id]=le*kle+ri*kri ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      n=sc.nextInt();
      if(n==0){
        break ;
      }
      mobile=new int[n][4];
      weight=new long[n];
      for(int i=0 ; i<n ; i++){
        mobile[i][0]=sc.nextInt();
        mobile[i][1]=sc.nextInt();
        mobile[i][2]=sc.nextInt();
        mobile[i][3]=sc.nextInt();
      }
      Arrays.fill(weight,-1);
      for(int i=0 ; i<n ; i++){
        f(i);
      }
      Arrays.sort(weight);
      System.out.println(weight[n-1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute mobile : Sequence(Sequence(int));
  static   attribute n : int;
  static   attribute weight : Sequence(long);
  static   operation f( id : int) : long
  pre: true
  post: true
  activity: (     if (0 < weight[id+1]) then (     return weight[id+1] ) else skip ; 
     var le : long ; le := 1 ;
    var ri : long ; ri := 1 ;
    if (mobile[id+1][2+1] /= 0) then (     le := f(mobile[id+1][2+1] - 1) ) else skip ; 
    if (mobile[id+1][3+1] /= 0) then (     ri := f(mobile[id+1][3+1] - 1) ) else skip ; 
    var kle : long ; kle := 1 ;
    var kri : long ; kri := 1 ;
    while (true) do (     if (le * kle * mobile[id+1][0+1] = ri * kri * mobile[id+1][1+1]) then (     break ) else     if (le * kle * mobile[id+1][0+1] < ri * kri * mobile[id+1][1+1]) then (     kle := kle + 1 ) else (     kri := kri + 1 ) ;  ) ; 
    return weight[id+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then (     break ) else skip ; 
    mobile := Integer.subrange(1,n)->collect(Integer.subrange(1,4)->collect(0)) ; 
    weight := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     mobile[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     mobile[i+1][1+1] := sc.getCurrent()->toInteger() ; 
     mobile[i+1][2+1] := sc.getCurrent()->toInteger() ; 
     mobile[i+1][3+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    weight := weight->collect(-1) ; 
        var i : int ; i := 0 ; while i < n do ( (     execute f(i) )  ;     i := i + 1 ) ; 
    weight := weight->sort() ; 
    OclFile["System.out"].println(weight[n - 1+1]) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF1204_D2_A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String num=scanner.nextLine();
    int pos=0 ;
    for(int i=0 ; i<num.length(); i++){
      if(num.charAt(i)=='1')pos=i ;
    }
    if(pos==0){
      if((num.length()-1)% 2==1){
        System.out.println((num.length()-1)/2+1);
      }
      else {
        System.out.println((num.length()-1)/2);
      }
    }
    else {
      System.out.println((num.length()-1)/2+1);
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF1204_D2_A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : String ; num := scanner.nextLine() ;
    var pos : int ; pos := 0 ;
        var i : int ; i := 0 ; while i < num->size() do ( (     if (num->at(i+1) = '1') then     pos := i ; else skip )  ;     i := i + 1 ) ; 
    if (pos = 0) then (     if ((num->size() - 1) mod 2 = 1) then (     OclFile["System.out"].println((num->size() - 1) / 2 + 1) ) else (     OclFile["System.out"].println((num->size() - 1) / 2) ) ) else (     OclFile["System.out"].println((num->size() - 1) / 2 + 1) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class A809 {
  public static void main(String[] args){
    long mod=1000000007 ;
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    long[] power=new long[N];
    power[0]=1 ;
    for(int n=1 ; n<N ; n++){
      power[n]=(2*power[n-1])% mod ;
    }
    Integer[] A=new Integer[N];
    for(int n=0 ; n<N ; n++){
      A[n]=in.nextInt();
    }
    Arrays.sort(A);
    long plus=0 ;
    long minus=0 ;
    for(int n=0 ; n<N ; n++){
      plus+=power[n]*A[n];
      plus %=mod ;
      minus+=power[N-1-n]*A[n];
      minus %=mod ;
    }
    long answer=(plus+mod-minus)% mod ;
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A809 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mod : long ; mod := 1000000007 ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var power : Sequence(long) ; power := Integer.subrange(1,N)->collect(0) ;
    power[0+1] := 1 ; 
        var n : int ; n := 1 ; while n < N do ( (     power[n+1] := (2 * power[n - 1+1]) mod mod )  ;     n := n + 1 ) ; 
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(null) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    A := A->sort() ; 
    var plus : long ; plus := 0 ;
    var minus : long ; minus := 0 ;
        var n : int ; n := 0 ; while n < N do ( (     plus := plus+(power[n+1] * A[n+1]) ; 
     plus := plus mod mod ; 
     minus := minus+(power[N - 1 - n+1] * A[n+1]) ; 
     minus := minus mod mod )  ;     n := n + 1 ) ; 
    var answer : long ; answer := (plus + mod - minus) mod mod ;
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    String numA=s.nextLine();
    String a=s.nextLine();
    String numB=s.nextLine();
    String b=s.nextLine();
    String[] aa=a.split(" ");
    String[] bb=b.split(" ");
    int[] ai=Arrays.stream(aa).mapToInt(Integer :: parseInt).toArray();
    int[] bi=Arrays.stream(bb).mapToInt(Integer :: parseInt).toArray();
    int index=0 ;
    while(true){
      if(index>=bi.length){
        System.out.println(0);
        break ;
      }
      else if(index>=ai.length){
        System.out.println(1);
        break ;
      }
      if(bi[index]>ai[index]){
        System.out.println(1);
        break ;
      }
      else if(ai[index]>bi[index]){
        System.out.println(0);
        break ;
      }
      index++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numA : String ; numA := s.nextLine() ;
    var a : String ; a := s.nextLine() ;
    var numB : String ; numB := s.nextLine() ;
    var b : String ; b := s.nextLine() ;
    var aa : Sequence(String) ; aa := a->split(" ") ;
    var bb : Sequence(String) ; bb := b->split(" ") ;
    var ai : Sequence(int) ; ai := stream(aa)->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var bi : Sequence(int) ; bi := stream(bb)->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var index : int ; index := 0 ;
    while (true) do (     if (index >= bi->size()) then (     OclFile["System.out"].println(0) ; 
     break ) else     if (index >= ai->size()) then (     OclFile["System.out"].println(1) ; 
     break ) else skip ; ;  
     if (bi[index+1] > ai[index+1]) then (     OclFile["System.out"].println(1) ; 
     break ) else     if (ai[index+1] > bi[index+1]) then (     OclFile["System.out"].println(0) ; 
     break ) else skip ; ;  
     index := index + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int result=0 ;
    for(int i=1 ; i<=9 ; i++)for(int j=1 ; j<=9 ; j++){
      result+=num(N,i,j)*num(N,j,i);
    }
    System.out.println(result);
  }
  static int num(int max,int head,int tail){
    int result=0 ;
    for(int i=1 ; i<=max ; i++)if(i % 10==tail && head(i)==head)result++;
    return result ;
  }
  static int head(int i){
    while(i>9){
      i/=10 ;
    }
    return i ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var result : int ; result := 0 ;
        var i : int ; i := 1 ; while i <= 9 do (         var j : int ; j := 1 ; while j <= 9 do ( (     result := result+(num(N, i, j) * num(N, j, i)) )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation num( max : int, head : int, tail : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
         var i : int ; i := 1 ; while i <= max do (     if (i mod 10 = tail & head(i) = head) then     result := result + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return result );
  static   operation head( i : int) : int
  pre: true
  post: true
  activity: (     while (i > 9) do (     i := i/(10) ) ; 
     return i );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class demo {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int input=s.nextInt();
    int ans=0 ;
    for(int i=0 ; i<input ; i++){
      ans+=s.nextInt()*i*4 ;
    }
    System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class demo {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : int ; input := s.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < input do ( (     ans := ans+(s.getCurrent()->toInteger() * i * 4) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class CodeForces {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n,i,m,s=0 ;
    n=sc.nextInt();
    int a[]=new int[n];
    for(i=0 ; i<n ; i++)a[i]=sc.nextInt();
    m=0 ;
    s=0 ;
    for(i=0 ; i<n ; i++){
      if(i>=m)s+=a[i]*i ;
      else s+=a[i]*m ;
    }
    System.out.println(4*s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var i : int ;
    var m : int ;
    var s : int ; s := 0 ;
    n := sc.getCurrent()->toInteger() ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    m := 0 ; 
    s := 0 ; 
        i := 0 ; while i < n do ( (     if (i >= m) then     s := s+(a[i+1] * i) ; else     s := s+(a[i+1] * m) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(4 * s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TheFairNutAndElevator {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] a=new int[n];
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
      sum=2*a[i]*2*(i)+sum ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class TheFairNutAndElevator {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     sum := 2 * a[i+1] * 2 * (i) + sum )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] num=new int[n];
    for(int i=0 ; i<n ; i++){
      num[i]=sc.nextInt();
    }
    ArrayList<Integer>t=new ArrayList<Integer>(n);
    for(int i1=0 ; i1<n ; i1++){
      int b=0 ;
      for(int i2=0 ; i2<n ; i2++){
        if(i2<=i1){
          b+=(4*(i1+1)-4)*num[i2];
        }
        else b+=(4*(i2+1)-4)*num[i2];
      }
      t.add(b);
    }
    t.sort(null);
    System.out.println(t.get(0));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var num : Sequence(int) ; num := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     num[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var t : Sequence(int) ; t := Sequence{} ;
        var i1 : int ; i1 := 0 ; while i1 < n do ( (     var b : int ; b := 0 ;
         var i2 : int ; i2 := 0 ; while i2 < n do ( (     if (i2 <= i1) then (     b := b+((4 * (i1 + 1) - 4) * num[i2+1]) ) else     b := b+((4 * (i2 + 1) - 4) * num[i2+1]) ; )  ;     i2 := i2 + 1 ) ; 
     t := t->including(b) )  ;     i1 := i1 + 1 ) ; 
    t := t.sort(null) ; 
    OclFile["System.out"].println(t->at(0+1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static boolean isDivisible7(String num){
    int n=num.length();
    if(n==0 && num.charAt(0)=='0')return true ;
    if(n % 3==1)num="00"+num ;
    if(n % 3==2)num="0"+num ;
    n=num.length();
    int gSum=0,p=1 ;
    for(int i=n-1 ; i>=0 ; i--){
      int group=0 ;
      group+=num.charAt(i--)-'0' ;
      group+=(num.charAt(i--)-'0')*10 ;
      group+=(num.charAt(i)-'0')*100 ;
      gSum=gSum+group*p ;
      p=p*-1 ;
    }
    return(gSum % 7==0);
  }
  public static void main(String args[]){
    String num="8955795758" ;
    System.out.println(isDivisible7(num)? "Divisible by 7" : "Not Divisible  by 7");
  }
}
------------------------------------------------------------
OCL File:
---------
class Test {
  static   operation isDivisible7( num : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := num->size() ;
     if (n = 0 & num->at(0+1) = '0') then     return true else skip ; 
    if (n mod 3 = 1) then     num := "00" + num ; else skip ; 
    if (n mod 3 = 2) then     num := "0" + num ; else skip ; 
    n := num->size() ; 
    var gSum : int ; gSum := 0 ;
    var p : int ; p := 1 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     var group : int ; group := 0 ;
     group := group+(num->at(i+1) - ('0')->char2byte()) ; 
    group := group+((num->at(i+1) - ('0')->char2byte()) * 10) ; 
    group := group+((num->at(i+1) - ('0')->char2byte()) * 100) ; 
    gSum := gSum + group * p ; 
    p := p * -1 ; 
 )  ;     i := i - 1 ) ; 
    return (gSum mod 7 = 0) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : String ; num := "8955795758" ;
     OclFile["System.out"].println(if isDivisible7(num) then "Divisible by 7" else "Not Divisible  by 7" endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static long reverseBits(long n){
    long rev=0 ;
    while(n>0){
      rev<<=1 ;
      if((n & 1)==1)rev ^=1 ;
      n>>=1 ;
    }
    return rev ;
  }
  public static boolean isPalindrome(long n){
    long rev=reverseBits(n);
    return(n==rev);
  }
  public static void main(String argc[]){
    long n=9 ;
    if(isPalindrome(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation reverseBits( n : long) : long
  pre: true
  post: true
  activity: (     var rev : long ; rev := 0 ;
     while (n > 0) do (     rev := rev*(2->pow(1)) ; 
     if ((n & 1) = 1) then     rev := MathLib.bitwiseXor(rev,1) ; else skip ; 
     n := n/(2->pow(1)) ) ; 
     return rev );
  static   operation isPalindrome( n : long) : boolean
  pre: true
  post: true
  activity: (     var rev : long ; rev := reverseBits(n) ;
     return (n = rev) );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 9 ;
     if (isPalindrome(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int Remainder(String str,int R){
    int len=str.length();
    int Num,Rem=0 ;
    for(int i=0 ; i<len ; i++){
      Num=Rem*10+(str.charAt(i)-'0');
      Rem=Num % R ;
    }
    return Rem ;
  }
  public static void main(String[] args){
    String str="13589234356546756" ;
    int R=13 ;
    System.out.println(Remainder(str,R));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation Remainder( str : String, R : int) : int
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     var Num : int ;
    var Rem : int ; Rem := 0 ;
         var i : int ; i := 0 ; while i < len do ( (     Num := Rem * 10 + (str->at(i+1) - ('0')->char2byte()) ; 
     Rem := Num mod R )  ;     i := i + 1 ) ; 
     return Rem );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "13589234356546756" ;
     var R : int ; R := 13 ;
     OclFile["System.out"].println(Remainder(str, R)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.nio.charset.StandardCharsets ;
import java.util.*;
public class Main {
  int[] inputArray ;
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    char[] array=sc.next().toCharArray();
    Set<String>set=new HashSet<>();
    for(int i=0 ; i<array.length ; i++){
      set.add(String.valueOf(array[i]));
    }
    if(set.size()==array.length)System.out.println("yes");
    else System.out.println("no");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute inputArray : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var array : Sequence(String) ; array := sc.getCurrent()->characters() ;
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := 0 ; while i < array->size() do ( (     set := set->including(((array[i+1]) + "")) )  ;     i := i + 1 ) ; 
    if (set->size() = array->size()) then     OclFile["System.out"].println("yes") else     OclFile["System.out"].println("no") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    String S=gs();
    Map<String,Integer>m=new HashMap<String,Integer>();
    for(int i=0 ; i<S.length(); i++){
      String s=String.valueOf(S.charAt(i));
      if(m.containsKey(s)){
        System.out.println("no");
        return ;
      }
      else {
        m.put(s,1);
      }
    }
    System.out.println("yes");
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var S : String ; S := gs() ;
    var m : Map(String,int) ; m := Map{} ;
        var i : int ; i := 0 ; while i < S->size() do ( (     var s : String ; s := ((S->at(i+1)) + "") ;
     if (m->keys()->includes(s)) then (     OclFile["System.out"].println("no") ; 
     return ) else (     m := m->union(Map{s |-> 1}) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("yes") ; 
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int sum ;
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    ArrayList<Integer>stateList=new ArrayList<Integer>();
    int cnt4=0 ;
    int cnt2=0 ;
    int work=0 ;
    for(int i=0 ; i<a ; i++){
      stateList.add(sc.nextInt());
      work=stateList.get(i)% 4 ;
      if(work==0){
        cnt4++;
      }
      else {
        work=stateList.get(i)% 2 ;
        if(work==0){
          cnt2++;
        }
      }
    }
    work=a/2 ;
    if(work<=cnt4){
      System.out.println("Yes");
      return ;
    }
    work=a-(cnt4*2);
    if((work==0)|(cnt2==0)){
      System.out.println("No");
      return ;
    }
    if(work==cnt2){
      System.out.println("Yes");
      return ;
    }
    System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sum : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var stateList : Sequence(int) ; stateList := Sequence{} ;
    var cnt4 : int ; cnt4 := 0 ;
    var cnt2 : int ; cnt2 := 0 ;
    var work : int ; work := 0 ;
        var i : int ; i := 0 ; while i < a do ( (     stateList := stateList->including(sc.getCurrent()->toInteger()) ; 
     work := stateList->at(i+1) mod 4 ; 
     if (work = 0) then (     cnt4 := cnt4 + 1 ) else (     work := stateList->at(i+1) mod 2 ; 
     if (work = 0) then (     cnt2 := cnt2 + 1 ) else skip ) )  ;     i := i + 1 ) ; 
    work := a / 2 ; 
    if (work <= cnt4) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
    work := a - (cnt4 * 2) ; 
    if ((work = 0) or (cnt2 = 0)) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
    if (work = cnt2) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
    OclFile["System.out"].println("No") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    Solver solver=new Solver();
    solver.init();
    solver.readHead(in.readLine());
  }
}
class Solver {
  int N ;
  int cnt ;
  public void init(){
    N=0 ;
    cnt=0 ;
  }
  public void readHead(String str){
    HashSet<Character>cset=new HashSet<Character>();
    for(char c : str.toCharArray()){
      if(cset.contains(c)){
        System.out.println("no");
        return ;
      }
      cset.add(c);
    }
    System.out.println("yes");
  }
  public boolean hasNext(){
    return cnt<N ;
  }
  public void readBody(String str){
    cnt++;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var solver : Solver ; solver := Solver.newSolver() ;
     solver.init() ; 
     solver.readHead(in.readLine()) );
}
class Solver {
   attribute N : int;
   attribute cnt : int;
   operation init() : void
  pre: true
  post: true
  activity: (     N := 0 ; 
     cnt := 0 );
   operation readHead( str : String) : void
  pre: true
  post: true
  activity: (     var cset : Set(String) ; cset := Set{} ;
     for (c : str->characters()) do ( (     if (cset->includes(c)) then (     OclFile["System.out"].println("no") ; 
     return ) else skip ; 
     cset := cset->including(c) )  ) ; 
     OclFile["System.out"].println("yes") );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return cnt < N );
   operation readBody( str : String) : void
  pre: true
  post: true
  activity: (     cnt := cnt + 1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static boolean isOK(int i,int j){
    char[] str_i=String.valueOf(i).toCharArray();
    char[] str_j=String.valueOf(j).toCharArray();
    return str_i[0]==str_j[str_j.length-1] && str_i[str_i.length-1]==str_j[0];
  }
  public static Integer hash(int n){
    char[] str=String.valueOf(n).toCharArray();
    if(str[0]=='0' || str[str.length-1]=='0'){
      return-1 ;
    }
    String a=String.valueOf(new char[] {
      str[0],str[str.length-1] }
);
      return Integer.parseInt(a);
    }
    public static void main(String[] args){
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      Map<Integer,List<Integer>>map=new HashMap<>();
      for(int i=1 ; i<=9 ; i++){
        for(int j=1 ; j<=9 ; j++){
          map.put(i*10+j,new ArrayList<Integer>());
        }
      }
      for(int i=1 ; i<=n ; i++){
        int h=hash(i);
        if(h<=0){
          continue ;
        }
        List<Integer>l=map.get(h);
        l.add(i);
        map.put(h,l);
      }
      int ans=0 ;
      for(int i=1 ; i<=9 ; i++){
        for(int j=1 ; j<=9 ; j++){
          int a=map.get(i*10+j).size();
          int b=map.get(j*10+i).size();
          ans+=a*b ;
        }
      }
      System.out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation isOK( i : int, j : int) : boolean
  pre: true
  post: true
  activity: (     var str_i : Sequence(String) ; str_i := ((i) + "")->characters() ;
     var str_j : Sequence(String) ; str_j := ((j) + "")->characters() ;
     return str_i[0+1] = str_j[str_j->size() - 1+1] & str_i[str_i->size() - 1+1] = str_j[0+1] );
  static   operation hash( n : int) : int
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := ((n) + "")->characters() ;
     if (str[0+1] = '0' or str[str->size() - 1+1] = '0') then (     return -1 ) else skip ; 
     var a : String ; a := ((Sequence{str[0+1],str[str->size() - 1+1]}) + "") ;
     return (a)->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var map : Map(int,Sequence(int)) ; map := Map{} ;
        var i : int ; i := 1 ; while i <= 9 do ( (         var j : int ; j := 1 ; while j <= 9 do ( (     map := map->union(Map{i * 10 + j |-> Sequence{}}) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     var h : int ; h := hash(i) ;
     if (h <= 0) then (     continue ) else skip ; 
    var l : Sequence(int) ; l := map->at(h) ;
    l := l->including(i) ; 
    map := map->union(Map{h |-> l}) ; 
 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= 9 do ( (         var j : int ; j := 1 ; while j <= 9 do ( (     var a : int ; a := map->at(i * 10 + j)->size() ;
     var b : int ; b := map->at(j * 10 + i)->size() ;
     ans := ans+(a * b) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.text.*;
public class Main {
  public static void main(String[] args)throws ParseException {
    Scanner sc=new Scanner(System.in);
    String line=sc.nextLine();
    char[] words=line.toCharArray();
    int count=0 ;
    for(int i=0 ; i<line.length(); i++){
      for(int j=1 ; j<line.length()-i ; j++){
        if(words[i]==words[i+j]){
          count++;
        }
      }
    }
    if(count==0){
      System.out.println("yes");
    }
    else {
      System.out.println("no");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : String ; line := sc.nextLine() ;
    var words : Sequence(String) ; words := line->characters() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < line->size() do ( (         var j : int ; j := 1 ; while j < line->size() - i do ( (     if (words[i+1] = words[i + j+1]) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (count = 0) then (     OclFile["System.out"].println("yes") ) else (     OclFile["System.out"].println("no") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    char[] S=scanner.next().toCharArray();
    Arrays.sort(S);
    for(int i=1 ; i<S.length ; i++){
      if(S[i]==S[i-1]){
        System.out.println("no");
        return ;
      }
    }
    System.out.println("yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : Sequence(String) ; S := scanner.getCurrent()->characters() ;
    S := S->sort() ; 
        var i : int ; i := 1 ; while i < S->size() do ( (     if (S[i+1] = S[i - 1+1]) then (     OclFile["System.out"].println("no") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("yes") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int N=3 ;
  static int numberOfCells(int mat[][]){
    boolean[][] row=new boolean[N][N];
    boolean[][] col=new boolean[N][N];
    for(int i=0 ; i<N ; i++){
      for(int j=N-1 ; j>=0 ; j--){
        if(mat[i][j]==1){
          row[i][j]=(j+1<N)? row[i][j+1] : true ;
        }
        else {
          row[i][j]=false ;
        }
      }
    }
    for(int j=0 ; j<N ; j++){
      for(int i=N-1 ; i>=0 ; i--){
        if(mat[i][j]==1){
          col[i][j]=(i+1<N)? col[i+1][j] : true ;
        }
        else {
          col[i][j]=false ;
        }
      }
    }
    int cnt=0 ;
    for(int i=0 ; i<N-1 ; i++){
      for(int j=0 ; j<N-1 ; j++){
        if(row[i][j] && col[i][j]){
          cnt++;
        }
      }
    }
    for(int i=0 ; i<N ; i++){
      if(col[i][N-1])cnt++;
    }
    for(int j=0 ; j<N-1 ; j++){
      if(row[N-1][j])cnt++;
    }
    return cnt ;
  }
  public static void main(String[] args){
    int mat[][]={
      {
        0,1,1 },{
          0,1,1 },{
            0,1,1 }
          };
          System.out.print(numberOfCells(mat));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 3;
  static   operation numberOfCells( mat : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var row : Sequence(Sequence(boolean)) ; row := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(false)) ;
     var col : Sequence(Sequence(boolean)) ; col := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(false)) ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := N - 1 ; while j >= 0 do ( (     if (mat[i+1][j+1] = 1) then (     row[i+1][j+1] := if (j + 1 < N) then row[i+1][j + 1+1] else true endif ) else (     row[i+1][j+1] := false ) )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < N do ( (         var i : int ; i := N - 1 ; while i >= 0 do ( (     if (mat[i+1][j+1] = 1) then (     col[i+1][j+1] := if (i + 1 < N) then col[i + 1+1][j+1] else true endif ) else (     col[i+1][j+1] := false ) )  ;     i := i - 1 ) )  ;     j := j + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < N - 1 do ( (         var j : int ; j := 0 ; while j < N - 1 do ( (     if (row[i+1][j+1] & col[i+1][j+1]) then (     cnt := cnt + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (col[i+1][N - 1+1]) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < N - 1 do ( (     if (row[N - 1+1][j+1]) then     cnt := cnt + 1 ; else skip )  ;     j := j + 1 ) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{0,1,1},Sequence{0,1,1},Sequence{0,1,1}} ;
     OclFile["System.out"].print(numberOfCells(mat)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner scan=new Scanner(System.in);
    while(true){
      int n=scan.nextInt();
      if(n==0)return ;
      int[] w=new int[n];
      for(int i=0 ; i<n ; i++)w[i]=scan.nextInt();
      int[][] dp=new int[n][n];
      for(int j=1 ; j<n ; j++){
        for(int i=0 ; i+j<n ; i++){
          if(dp[i+1][i+j-1]==(i+j)-i-1){
            if(Math.abs(w[i]-w[i+j])<=1){
              dp[i][i+j]=dp[i+1][i+j-1]+2 ;
            }
          }
          for(int k=i ; k<i+j ; k++){
            dp[i][i+j]=Math.max(dp[i][i+j],dp[i][k]+dp[k+1][i+j]);
          }
        }
      }
      System.out.println(dp[0][n-1]);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scan.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var w : Sequence(int) ; w := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     w[i+1] := scan.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var j : int ; j := 1 ; while j < n do ( (         var i : int ; i := 0 ; while i + j < n do ( (     if (dp[i + 1+1][i + j - 1+1] = (i + j) - i - 1) then (     if (if w[i+1] - w[i + j+1] < 0 then -(w[i+1] - w[i + j+1]) else w[i+1] - w[i + j+1] endif <= 1) then (     dp[i+1][i + j+1] := dp[i + 1+1][i + j - 1+1] + 2 ) else skip ) else skip ; 
         var k : int ; k := i ; while k < i + j do ( (     dp[i+1][i + j+1] := Set{dp[i+1][i + j+1], dp[i+1][k+1] + dp[k + 1+1][i + j+1]}->max() )  ;     k := k + 1 ) )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(dp[0+1][n - 1+1]) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static int[][] dp ;
  public static void main(String[] args){
    Scanner ir=new Scanner(System.in);
    outer : for(;
    ;
){
      int n=ir.nextInt();
      if(n==0){
        System.exit(0);
      }
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=ir.nextInt();
      }
      dp=new int[n][n];
      int MIN=-(1<<30);
      for(int i=0 ; i<n ; i++){
        Arrays.fill(dp[i],MIN);
        dp[i][i]=0 ;
      }
      System.out.println(dfs(0,n-1,a));
    }
  }
  static int dfs(int l,int r,int[] a){
    if(l>=r){
      return 0 ;
    }
    if(dp[l][r]>=0){
      return dp[l][r];
    }
    int res=dfs(l+1,r,a);
    for(int i=l+1 ; i<=r ; i++){
      if(Math.abs(a[l]-a[i])<=1 && dfs(l+1,i-1,a)==i-l-1){
        res=Math.max(res,2+dfs(l+1,i-1,a)+dfs(i+1,r,a));
      }
    }
    return dp[l][r]=res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dp : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ir : OclFile ; ir := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := ir.getCurrent()->toInteger() ;
     if (n = 0) then ( OclProcess.exit(0) ) else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := ir.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    dp := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
    var MIN : int ; MIN := -((1*(2->pow(30)))->oclAsType(long)) ;
        var i : int ; i := 0 ; while i < n do ( (     dp[i+1] := dp[i+1]->collect(MIN) ; 
     dp[i+1][i+1] := 0 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dfs(0, n - 1, a)) ; 
 )  ) ; );
  static   operation dfs( l : int, r : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     if (l >= r) then (     return 0 ) else skip ; 
     if (dp[l+1][r+1] >= 0) then (     return dp[l+1][r+1] ) else skip ; 
    var res : int ; res := dfs(l + 1, r, a) ;
        var i : int ; i := l + 1 ; while i <= r do ( (     if (if a[l+1] - a[i+1] < 0 then -(a[l+1] - a[i+1]) else a[l+1] - a[i+1] endif <= 1 & dfs(l + 1, i - 1, a) = i - l - 1) then (     res := Set{res, 2 + dfs(l + 1, i - 1, a) + dfs(i + 1, r, a)}->max() ) else skip )  ;     i := i + 1 ) ; 
    return dp[l+1][r+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    while(true){
      int n=Integer.parseInt(scan.next());
      if(n==0){
        break ;
      }
      int[] w=new int[n];
      for(int i=0 ; i<n ; i++){
        w[i]=Integer.parseInt(scan.next());
      }
      int dp[][]=new int[n+1][n+1];
      for(int i=2 ; i<=n ; i++){
        for(int j=0 ; j+i<=n ; j++){
          for(int k=j ; k<=j+i ; k++){
            dp[j][j+i]=Math.max(dp[j][j+i],dp[j][k]+dp[k][j+i]);
          }
          if(dp[j+1][j+i-1]==i-2 && Math.abs(w[j]-w[j+i-1])<=1){
            dp[j][j+i]=i ;
          }
        }
      }
      System.out.println(dp[0][n]);
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := (scan.getCurrent())->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var w : Sequence(int) ; w := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     w[i+1] := (scan.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 2 ; while i <= n do ( (         var j : int ; j := 0 ; while j + i <= n do ( (         var k : int ; k := j ; while k <= j + i do ( (     dp[j+1][j + i+1] := Set{dp[j+1][j + i+1], dp[j+1][k+1] + dp[k+1][j + i+1]}->max() )  ;     k := k + 1 ) ; 
     if (dp[j + 1+1][j + i - 1+1] = i - 2 & if w[j+1] - w[j + i - 1+1] < 0 then -(w[j+1] - w[j + i - 1+1]) else w[j+1] - w[j + i - 1+1] endif <= 1) then (     dp[j+1][j + i+1] := i ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[0+1][n+1]) ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static int[] darmas ;
  static int[][] memo ;
  static int max(int i,int j){
    if(memo[i][j]==-1){
      int n=j-i ;
      if(n==1){
        memo[i][j]=0 ;
      }
      else if(n==2){
        assert(j-1==i+1);
        memo[i][j]=(Math.abs(darmas[i]-darmas[i+1])<=1)? 2 : 0 ;
      }
      else {
        int lmax=0 ;
        if(n>=4){
          lmax=max(i+1,j-1);
          lmax+=(lmax==n-2)?(Math.abs(darmas[i]-darmas[j-1])<=1 ? 2 : 0): 0 ;
        }
        for(int k=i+1 ; k+1<j ; k++){
          int top=max(i,k);
          int bot=max(k,j);
          if(lmax<top+bot){
            lmax=top+bot ;
          }
        }
        memo[i][j]=lmax ;
      }
    }
    return memo[i][j];
  }
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      for(int n=sc.nextInt(); n!=0 ; n=sc.nextInt()){
        darmas=new int[n];
        memo=new int[n][n+1];
        for(int i=0 ; i<n ; i++){
          darmas[i]=sc.nextInt();
          Arrays.fill(memo[i],-1);
        }
        System.out.println(max(0,n));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute darmas : Sequence(int);
  static   attribute memo : Sequence(Sequence(int));
  static   operation max( i : int, j : int) : int
  pre: true
  post: true
  activity: (     if (memo[i+1][j+1] = -1) then (     var n : int ; n := j - i ;
     if (n = 1) then (     memo[i+1][j+1] := 0 ) else     if (n = 2) then (     assert (j - 1 = i + 1) ; 
     memo[i+1][j+1] := if (if darmas[i+1] - darmas[i + 1+1] < 0 then -(darmas[i+1] - darmas[i + 1+1]) else darmas[i+1] - darmas[i + 1+1] endif <= 1) then 2 else 0 endif ) else (     var lmax : int ; lmax := 0 ;
     if (n >= 4) then (     lmax := Set{i + 1, j - 1}->max() ; 
     lmax := lmax+(if (lmax = n - 2) then (if if darmas[i+1] - darmas[j - 1+1] < 0 then -(darmas[i+1] - darmas[j - 1+1]) else darmas[i+1] - darmas[j - 1+1] endif <= 1 then 2 else 0 endif) else 0 endif) ) else skip ; 
         var k : int ; k := i + 1 ; while k + 1 < j do ( (     var top : int ; top := max(i, k) ;
     var bot : int ; bot := max(k, j) ;
     if (lmax < top + bot) then (     lmax := top + bot ) else skip )  ;     k := k + 1 ) ; 
     memo[i+1][j+1] := lmax ) ;  ) else skip ; 
     return memo[i+1][j+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (         var n : int ; n := sc.getCurrent()->toInteger() ; while n /= 0 do ( (     darmas := Integer.subrange(1,n)->collect(0) ; 
     memo := Integer.subrange(1,n)->collect(Integer.subrange(1,n + 1)->collect(0)) ; 
         var i : int ; i := 0 ; while i < n do ( (     darmas[i+1] := sc.getCurrent()->toInteger() ; 
     memo[i+1] := memo[i+1]->collect(-1) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(Set{0, n}->max()) )  ;     n := sc.getCurrent()->toInteger() ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new AOJ1611().doIt();
  }
  class AOJ1611 {
    void doIt(){
      while(true){
        int n=sc.nextInt();
        if(n==0)break ;
        int w[]=new int[n];
        for(int i=0 ; i<n ; i++)w[i]=sc.nextInt();
        int dp[][]=new int[n][n];
        for(int W=2 ; W<n+1 ; W++){
          for(int i=0 ; i<n ; i++){
            int j=i+W-1 ;
            if(j>=n)break ;
            if(dp[i+1][j-1]==W-2 && Math.abs(w[i]-w[j])<=1)dp[i][j]=W ;
            for(int k=i ; k<j ; k++){
              dp[i][j]=Math.max(dp[i][j],dp[i][k]+dp[k+1][j]);
            }
          }
        }
        System.out.println(dp[0][n-1]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     AOJ1611.newAOJ1611().doIt() );
 class AOJ1611 {
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var w : Sequence(int) ; w := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     w[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var W : int ; W := 2 ; while W < n + 1 do ( (         var i : int ; i := 0 ; while i < n do ( (     var j : int ; j := i + W - 1 ;
     if (j >= n) then     break else skip ; 
     if (dp[i + 1+1][j - 1+1] = W - 2 & if w[i+1] - w[j+1] < 0 then -(w[i+1] - w[j+1]) else w[i+1] - w[j+1] endif <= 1) then     dp[i+1][j+1] := W ; else skip ; 
         var k : int ; k := i ; while k < j do ( (     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i+1][k+1] + dp[k + 1+1][j+1]}->max() )  ;     k := k + 1 ) )  ;     i := i + 1 ) )  ;     W := W + 1 ) ; 
    OclFile["System.out"].println(dp[0+1][n - 1+1]) ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Fouradjacent solver=new Fouradjacent();
    solver.solve(1,in,out);
    out.close();
  }
  static class Fouradjacent {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int is_two=0 ;
      int is_four=0 ;
      int is_one=0 ;
      for(int i=0 ; i<n ; i++){
        long a=in.nextLong();
        if(a % 4==0){
          is_four++;
        }
        else if(a % 2==0){
          is_two++;
        }
        else {
          is_one++;
        }
      }
      if(is_two>0){
        is_one++;
      }
      if(is_one>(is_four+1)){
        out.print("No");
      }
      else {
        out.print("Yes");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Fouradjacent ; solver := Fouradjacent.newFouradjacent() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class Fouradjacent {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var is_two : int ; is_two := 0 ;
    var is_four : int ; is_four := 0 ;
    var is_one : int ; is_one := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : long ; a := in.getCurrent()->toLong() ;
     if (a mod 4 = 0) then (     is_four := is_four + 1 ) else     if (a mod 2 = 0) then (     is_two := is_two + 1 ) else (     is_one := is_one + 1 ) ;  )  ;     i := i + 1 ) ; 
    if (is_two > 0) then (     is_one := is_one + 1 ) else skip ; 
    if (is_one > (is_four + 1)) then (     skip ) else (     skip ) ;  
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] cnt=new int['z'-'a'+1];
    Arrays.fill(cnt,Integer.MAX_VALUE);
    for(int i=0 ; i<n ; ++i){
      char[] s=sc.next().toCharArray();
      int[] cur_cnt=new int['z'-'a'+1];
      for(char c : s){
        cur_cnt[c-'a']++;
      }
      for(int j=0 ; j<cur_cnt.length ; ++j){
        cnt[j]=Math.min(cnt[j],cur_cnt[j]);
      }
    }
    String ans="" ;
    for(int i=0 ; i<cnt.length ; ++i){
      for(int j=0 ; j<cnt[i]; ++j)ans+=(char)('a'+i);
    }
    System.out.println(ans);
  }
  void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,('z')->char2byte() - ('a')->char2byte() + 1)->collect(0) ;
    cnt := cnt->collect(2147483647) ; 
        var i : int ; i := 0 ; while i < n do ( (     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
     var cur_cnt : Sequence(int) ; cur_cnt := Integer.subrange(1,('z')->char2byte() - ('a')->char2byte() + 1)->collect(0) ;
     for (c : s) do ( (     cur_cnt[c - ('a')->char2byte()+1] := cur_cnt[c - ('a')->char2byte()+1] + 1 )  ) ; 
         var j : int ; j := 0 ; while j < cur_cnt->size() do ( (     cnt[j+1] := Set{cnt[j+1], cur_cnt[j+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < cnt->size() do ( (         var j : int ; j := 0 ; while j < cnt[i+1] do (     ans := ans+(('a' + i)->oclAsType(String)) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int ni(){
    return cin.nextInt();
  }
  long nl(){
    return cin.nextLong();
  }
  String line(){
    return cin.nextLine();
  }
  void println(String str){
    System.out.println(str);
  }
  void print(String str){
    System.out.print(str);
  }
  static final int MOD=1000000007 ;
  Scanner cin=new Scanner(System.in);
  String output ;
  public static void main(String[] args){
    new Main().run();
  }
  public void run(){
    input();
    output=solve();
    println(output);
  }
  int N ;
  String[] words ;
  void input(){
    N=ni();
    words=new String[N];
    line();
    for(int i=0 ; i<N ; i++){
      words[i]=line();
    }
  }
  String solve(){
    int[] cnt1=new int[26];
    int[] cnt2 ;
    for(char c : words[0] .toCharArray()){
      cnt1[c-'a']++;
    }
    for(int i=1 ; i<N ; i++){
      cnt2=new int[26];
      for(char c : words[i] .toCharArray()){
        cnt2[c-'a']++;
      }
      for(int j=0 ; j<26 ; j++){
        if(cnt1[j]==0){
          continue ;
        }
        cnt1[j]=Math.min(cnt1[j],cnt2[j]);
      }
    }
    StringBuilder res=new StringBuilder();
    for(int i=0 ; i<26 ; i++){
      if(cnt1[i]==0){
        continue ;
      }
      for(int j=0 ; j<cnt1[i]; j++){
        res.append((char)(i+'a'));
      }
    }
    return res.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation ni() : int
  pre: true
  post: true
  activity: (     return cin.nextInt() );
   operation nl() : long
  pre: true
  post: true
  activity: (     return cin.nextLong() );
   operation line() : String
  pre: true
  post: true
  activity: (     return cin.nextLine() );
   operation println( str : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(str) );
   operation print( str : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(str) );
  static    attribute MOD : int := 1000000007;
   attribute cin : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute output : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     execute input() ; 
     output := solve() ; 
     execute println(output) );
   attribute N : int;
   attribute words : Sequence(String);
   operation input() : void
  pre: true
  post: true
  activity: (     N := ni() ; 
     words := Integer.subrange(1,N)->collect(null) ; 
     execute line() ; 
         var i : int ; i := 0 ; while i < N do ( (     words[i+1] := line() )  ;     i := i + 1 ) );
   operation solve() : String
  pre: true
  post: true
  activity: (     var cnt1 : Sequence(int) ; cnt1 := Integer.subrange(1,26)->collect(0) ;
     var cnt2 : Sequence(int) ;
    for (c : words[0+1]->characters()) do ( (     cnt1[c - ('a')->char2byte()+1] := cnt1[c - ('a')->char2byte()+1] + 1 )  ) ; 
        var i : int ; i := 1 ; while i < N do ( (     cnt2 := Integer.subrange(1,26)->collect(0) ; 
     for (c : words[i+1]->characters()) do ( (     cnt2[c - ('a')->char2byte()+1] := cnt2[c - ('a')->char2byte()+1] + 1 )  ) ; 
         var j : int ; j := 0 ; while j < 26 do ( (     if (cnt1[j+1] = 0) then (     continue ) else skip ; 
     cnt1[j+1] := Set{cnt1[j+1], cnt2[j+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : String ; res := StringLib.newString() ;
        var i : int ; i := 0 ; while i < 26 do ( (     if (cnt1[i+1] = 0) then (     continue ) else skip ; 
         var j : int ; j := 0 ; while j < cnt1[i+1] do ( (     res := res + StringLib.newString((i + 'a')->oclAsType(String)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return res+"" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(1,in,out);
    out.close();
  }
  static class Task {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int[][] dp=new int[10][10];
      for(int i=0 ; i<10 ; i++)for(int j=0 ; j<10 ; j++)dp[i][j]=0 ;
      for(int i=1 ; i<=n ; i++){
        String s=Integer.toString(i);
        dp[s.charAt(0)-'0'][(int)s.charAt(s.length()-1)-'0']+=1 ;
      }
      long ans=0 ;
      for(int i=1 ; i<10 ; i++){
        for(int j=1 ; j<10 ; j++){
          ans+=(dp[i][j]*dp[j][i]);
        }
      }
      out.print(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,10)->collect(Integer.subrange(1,10)->collect(0)) ;
        var i : int ; i := 0 ; while i < 10 do (         var j : int ; j := 0 ; while j < 10 do (     dp[i+1][j+1] := 0 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     var s : String ; s := ((i) + "") ;
     dp[s->at(0+1) - ('0')->char2byte()+1][s->at(s->size() - 1+1)->oclAsType(int) - ('0')->char2byte()+1] := dp[s->at(0+1) - ('0')->char2byte()+1][s->at(s->size() - 1+1)->oclAsType(int) - ('0')->char2byte()+1]+(1) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i < 10 do ( (         var j : int ; j := 1 ; while j < 10 do ( (     ans := ans+((dp[i+1][j+1] * dp[j+1][i+1])) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public final class Main {
  static int N ;
  static int[] array ;
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    array=new int['z'-('a'-1)];
    N=s.nextInt();
    String first[]=s.next().split("");
    for(int j=0 ; j<first.length ; j++){
      char k=first[j] .charAt(0);
      array[k-'a']++;
    }
    for(int i=1 ; i<N ; i++){
      int[] now=new int[array.length];
      String line[]=s.next().split("");
      for(int j=0 ; j<line.length ; j++){
        char k=line[j] .charAt(0);
        if(array[k-'a']>0){
          array[k-'a']--;
          now[k-'a']++;
        }
      }
      array=now ;
    }
    for(int i=0 ; i<array.length ; i++){
      char k=(char)(i+'a');
      for(int j=0 ; j<array[i]; j++){
        System.out.print(k);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute array : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     array := Integer.subrange(1,('z')->char2byte() - (('a')->char2byte() - 1))->collect(0) ; 
    N := s.getCurrent()->toInteger() ; 
    var first : Sequence(String) ; first := s.getCurrent()->split("") ;
        var j : int ; j := 0 ; while j < first->size() do ( (     var k : String ; k := first[j+1]->at(0+1) ;
     array[(k)->char2byte() - ('a')->char2byte()+1] := array[(k)->char2byte() - ('a')->char2byte()+1] + 1 )  ;     j := j + 1 ) ; 
        var i : int ; i := 1 ; while i < N do ( (     var now : Sequence(int) ; now := Integer.subrange(1,array->size())->collect(0) ;
     var line : Sequence(String) ; line := s.getCurrent()->split("") ;
         var j : int ; j := 0 ; while j < line->size() do ( (     var k : String ; k := line[j+1]->at(0+1) ;
     if (array[(k)->char2byte() - ('a')->char2byte()+1] > 0) then (     array[(k)->char2byte() - ('a')->char2byte()+1] := array[(k)->char2byte() - ('a')->char2byte()+1] - 1 ; 
     now[(k)->char2byte() - ('a')->char2byte()+1] := now[(k)->char2byte() - ('a')->char2byte()+1] + 1 ) else skip )  ;     j := j + 1 ) ; 
     array := now )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < array->size() do ( (     var k : String ; k := (i + 'a')->oclAsType(String) ;
         var j : int ; j := 0 ; while j < array[i+1] do ( (     OclFile["System.out"].print(k) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static int order(long a){
    int o=0 ;
    long d=1 ;
    while(d<=a){
      o++;
      d*=10 ;
    }
    return o ;
  }
  public static int ABCNumber(char a){
    int num=-1 ;
    char[] abc="abcdefghijklmnopqrstuvwxyz".toCharArray();
    for(int n=0 ; n<26 ; n++){
      if(a==abc[n])num=n ;
    }
    return num ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    String[] S=new String[N];
    for(int i=0 ; i<N ; i++){
      S[i]=sc.next();
    }
    int[] xmin=new int[26];
    for(int n=0 ; n<26 ; n++)xmin[n]=50 ;
    for(int i=0 ; i<N ; i++){
      int[] x=new int[26];
      for(char a : S[i] .toCharArray()){
        x[ABCNumber(a)]++;
      }
      for(int n=0 ; n<26 ; n++){
        xmin[n]=Math.min(xmin[n],x[n]);
      }
    }
    char[] abc="abcdefghijklmnopqrstuvwxyz".toCharArray();
    StringBuilder sb=new StringBuilder();
    for(int n=0 ; n<26 ; n++){
      for(int cnt=0 ; cnt<xmin[n]; cnt++)sb.append(abc[n]);
    }
    System.out.println(sb.toString());
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation order( a : long) : int
  pre: true
  post: true
  activity: (     var o : int ; o := 0 ;
     var d : long ; d := 1 ;
     while (d <= a) do (     o := o + 1 ; 
     d := d*(10) ) ; 
     return o );
  static   operation ABCNumber( a : String) : int
  pre: true
  post: true
  activity: (     var num : int ; num := -1 ;
     var abc : Sequence(String) ; abc := "abcdefghijklmnopqrstuvwxyz"->characters() ;
         var n : int ; n := 0 ; while n < 26 do ( (     if (a = abc[n+1]) then     num := n ; else skip )  ;     n := n + 1 ) ; 
     return num );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var S : Sequence(String) ; S := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     S[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    var xmin : Sequence(int) ; xmin := Integer.subrange(1,26)->collect(0) ;
        var n : int ; n := 0 ; while n < 26 do (     xmin[n+1] := 50 ;  ;     n := n + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     var x : Sequence(int) ; x := Integer.subrange(1,26)->collect(0) ;
     for (a : S[i+1]->characters()) do ( (     x[ABCNumber(a)+1] := x[ABCNumber(a)+1] + 1 )  ) ; 
         var n : int ; n := 0 ; while n < 26 do ( (     xmin[n+1] := Set{xmin[n+1], x[n+1]}->min() )  ;     n := n + 1 ) )  ;     i := i + 1 ) ; 
    var abc : Sequence(String) ; abc := "abcdefghijklmnopqrstuvwxyz"->characters() ;
    var sb : String ; sb := StringLib.newString() ;
        var n : int ; n := 0 ; while n < 26 do ( (         var cnt : int ; cnt := 0 ; while cnt < xmin[n+1] do (     sb := sb + StringLib.newString(abc[n+1]) ;  ;     cnt := cnt + 1 ) )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    int A[]=new int[26];
    int z=0,y=0 ;
    while(z<n){
      String a=stdIn.next();
      int G[]=new int[26];
      while(y<a.length()){
        char b=a.charAt(y);
        G[b-'a']++;
        y++;
      }
      y=0 ;
      while(y<26){
        if(z==0 || A[y]>G[y])A[y]=G[y];
        G[y]=0 ;
        y++;
      }
      y=0 ;
      z++;
    }
    z=0 ;
    while(z<26){
      while(y<A[z]){
        System.out.print((char)(z+97));
        y++;
      }
      y=0 ;
      z++;
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,26)->collect(0) ;
    var z : int ; z := 0 ;
    var y : int ; y := 0 ;
    while (z < n) do (     var a : String ; a := stdIn.getCurrent() ;
     var G : Sequence(int) ; G := Integer.subrange(1,26)->collect(0) ;
    while (y < a->size()) do (     var b : String ; b := a->at(y+1) ;
     G[(b)->char2byte() - ('a')->char2byte()+1] := G[(b)->char2byte() - ('a')->char2byte()+1] + 1 ; 
     y := y + 1 ) ; 
    y := 0 ; 
    while (y < 26) do (     if (z = 0 or A[y+1] > G[y+1]) then     A[y+1] := G[y+1] ; else skip ; 
     G[y+1] := 0 ; 
     y := y + 1 ) ; 
    y := 0 ; 
    z := z + 1 ; 
 ) ; 
    z := 0 ; 
    while (z < 26) do (     while (y < A[z+1]) do (     OclFile["System.out"].print((z + 97)->oclAsType(String)) ; 
     y := y + 1 ) ; 
     y := 0 ; 
     z := z + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPowerful(int n){
    while(n % 2==0){
      int power=0 ;
      while(n % 2==0){
        n/=2 ;
        power++;
      }
      if(power==1)return false ;
    }
    for(int factor=3 ; factor<=Math.sqrt(n); factor+=2){
      int power=0 ;
      while(n % factor==0){
        n=n/factor ;
        power++;
      }
      if(power==1)return false ;
    }
    return(n==1);
  }
  static boolean isPower(int a){
    if(a==1)return true ;
    for(int i=2 ; i*i<=a ; i++){
      double val=Math.log(a)/Math.log(i);
      if((val-(int)val)<0.00000001)return true ;
    }
    return false ;
  }
  static boolean isAchillesNumber(int n){
    if(isPowerful(n)&& ! isPower(n))return true ;
    else return false ;
  }
  public static void main(String[] args){
    int n=72 ;
    if(isAchillesNumber(n))System.out.println("YES");
    else System.out.println("NO");
    n=36 ;
    if(isAchillesNumber(n))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPowerful( n : int) : boolean
  pre: true
  post: true
  activity: (     while (n mod 2 = 0) do (     var power : int ; power := 0 ;
     while (n mod 2 = 0) do (     n := n/(2) ; 
     power := power + 1 ) ; 
     if (power = 1) then     return false else skip ) ; 
         var factor : int ; factor := 3 ; while factor <= (n)->sqrt() do ( (     var power : int ; power := 0 ;
     while (n mod factor = 0) do (     n := n / factor ; 
     power := power + 1 ) ; 
     if (power = 1) then     return false else skip )  ;     factor := factor+(2) ) ; 
     return (n = 1) );
  static   operation isPower( a : int) : boolean
  pre: true
  post: true
  activity: (     if (a = 1) then     return true else skip ; 
         var i : int ; i := 2 ; while i * i <= a do ( (     var val : double ; val := (a)->log() / (i)->log() ;
     if ((val - val->oclAsType(int)) < 0.00000001) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation isAchillesNumber( n : int) : boolean
  pre: true
  post: true
  activity: (     if (isPowerful(n) & not(isPower(n))) then     return true else     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 72 ;
     if (isAchillesNumber(n)) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
     n := 36 ; 
     if (isAchillesNumber(n)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class D {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int zz=1 ; zz<=T ; zz++){
      String S=in.next();
      long v=0 ;
      long nv=0 ;
      for(int i=0 ; i<S.length(); i++){
        int at=S.length()-i-1 ;
        if(S.charAt(i)=='?'){
          nv |=1L<<at ;
        }
        else if(S.charAt(i)=='1'){
          v |=1L<<at ;
        }
      }
      long ans=0 ;
      for(long c=nv ; ; c=(c-1)& nv){
        long test=v+c ;
        if(issquare(test)){
          ans=test ;
          break ;
        }
        if(c==0)break ;
      }
      System.out.format("Case #%d: %s\n",zz,Long.toBinaryString(ans));
    }
  }
  private static boolean issquare(long t){
    long low=1 ;
    long high=Integer.MAX_VALUE ;
    while(low<=high){
      long mid=(low+high)/2 ;
      long v=mid*mid ;
      if(v==t){
        return true ;
      }
      if(v<t){
        low=mid+1 ;
      }
      else {
        high=mid-1 ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var zz : int ; zz := 1 ; while zz <= T do ( (     var S : String ; S := in.getCurrent() ;
     var v : long ; v := 0 ;
    var nv : long ; nv := 0 ;
        var i : int ; i := 0 ; while i < S->size() do ( (     var at : int ; at := S->size() - i - 1 ;
     if (S->at(i+1) = '?') then (     nv := MathLib.bitwiseOr(nv, (1L*(2->pow(at)))->oclAsType(long)) ) else     if (S->at(i+1) = '1') then (     v := MathLib.bitwiseOr(v, (1L*(2->pow(at)))->oclAsType(long)) ) else skip ; )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var c : long ; c := nv ; while true do ( (     var test : long ; test := v + c ;
     if (issquare(test)) then (     ans := test ; 
     break ) else skip ; 
     if (c = 0) then     break else skip )  ;     c := (c - 1) & nv ) ; 
    OclFile["System.out"].format("Case #%d: %s\n", zz, (MathLib.decimal2binary(ans) + "")) ; 
 )  ;     zz := zz + 1 ) );
  static   operation issquare( t : long) : boolean
  pre: true
  post: true
  activity: (     var low : long ; low := 1 ;
     var high : long ; high := 2147483647 ;
     while (low <= high) do (     var mid : long ; mid := (low + high) / 2 ;
     var v : long ; v := mid * mid ;
     if (v = t) then (     return true ) else skip ; 
     if (v < t) then (     low := mid + 1 ) else (     high := mid - 1 ) ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class D {
  private static String fileName=D.class.getSimpleName().replaceFirst("_.*","").toLowerCase();
  private static String inputFileName=fileName+".in" ;
  private static String outputFileName=fileName+".out" ;
  private static Scanner in ;
  private static PrintWriter out ;
  private void solve(){
    String s=in.next();
    int n=s.length();
    int[] a=new int[n];
    int q=0 ;
    for(int i=0 ; i<n ; i++){
      switch(s.charAt(i)){
        case '0' : a[i]=0 ;
        break ;
        case '1' : a[i]=1 ;
        break ;
        case '?' : a[i]=2 ;
        q++;
        break ;
      }
    }
    for(int mask=0 ; mask<(1<<q); mask++){
      long v=0 ;
      for(int i=0,j=0 ; i<n ; i++){
        int c=a[i];
        if(c==2){
          c=(mask>>j)& 1 ;
          j++;
        }
        v=2*v+c ;
      }
      long u=Math.round(Math.sqrt(v));
      if(u*u==v){
        out.println(Long.toBinaryString(v));
        return ;
      }
    }
    throw new RuntimeException();
  }
  public static void main(String[] args)throws IOException {
    Locale.setDefault(Locale.US);
    if(args.length>=2){
      inputFileName=args[0];
      outputFileName=args[1];
    }
    in=new Scanner(new FileReader(inputFileName));
    out=new PrintWriter(outputFileName);
    int tests=in.nextInt();
    in.nextLine();
    for(int t=1 ; t<=tests ; t++){
      out.print("Case #"+t+": ");
      new D().solve();
      System.out.println("Case #"+t+": solved");
    }
    in.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   attribute fileName : String := OclType["D"].getSimpleName().replaceFirstMatch("_.*", "")->toLowerCase();
  static   attribute inputFileName : String := fileName + ".in";
  static   attribute outputFileName : String := fileName + ".out";
  static   attribute in : OclFile;
  static   attribute out : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.getCurrent() ;
     var n : int ; n := s->size() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var q : int ; q := 0 ;
        var i : int ; i := 0 ; while i < n do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (s->at(i+1)) ; 
       if _switchval = '0' then
     a[i+1] := 0 ; 
    break 
   else skip ;
       if _switchval = '1' then
     a[i+1] := 1 ; 
    break 
   else skip ;
       if _switchval = '?' then
     a[i+1] := 2 ; 
    q := q + 1 ; 
    break 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
        var mask : int ; mask := 0 ; while mask < ((1*(2->pow(q)))->oclAsType(long)) do ( (     var v : long ; v := 0 ;
         var i : int ; i := 0 ;
    var j : int ; j := 0 ; while i < n do ( (     var c : int ; c := a[i+1] ;
     if (c = 2) then (     c := ((mask/(2->pow(j)))->oclAsType(long)) & 1 ; 
     j := j + 1 ) else skip ; 
     v := 2 * v + c )  ;     i := i + 1 ) ; 
     var u : long ; u := ((v)->sqrt())->round() ;
     if (u * u = v) then (     skip ; 
     return ) else skip )  ;     mask := mask + 1 ) ; 
    error ProgramException() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.US) ; 
     if (args->size() >= 2) then (     inputFileName := args[0+1] ; 
     outputFileName := args[1+1] ) else skip ; 
    in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile(inputFileName))) ; 
    out := OclFile.newOclFile_Write(OclFile.newOclFile(outputFileName)) ; 
    var tests : int ; tests := in.getCurrent()->toInteger() ;
    skip ; 
        var t : int ; t := 1 ; while t <= tests do ( (     skip ; 
     D.newD().solve() ; 
     OclFile["System.out"].println("Case #" + t + ": solved") )  ;     t := t + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.util.*;
public class D {
  Scanner sc=new Scanner(System.in);
  void solve(){
    char[] cs=sc.next().toCharArray();
    int m=0 ;
    for(char c : cs)if(c=='?')m++;
    for(int i=0 ; i<1<<m ; i++){
      char[] ds=cs.clone();
      int p=0 ;
      for(int j=0 ; j<cs.length ; j++)if(cs[j]=='?'){
        ds[j]=(char)('0'+(i>>p & 1));
        p++;
      }
      long v=0 ;
      for(char c : ds)v=v*2+c-'0' ;
      long a=(long)sqrt(v);
      while(a*a<v)a++;
      while(a*a>v)a--;
      if(a*a==v){
        System.out.println(Long.toBinaryString(v));
        return ;
      }
    }
  }
  void run(){
    int caseN=sc.nextInt();
    for(int caseID=1 ; caseID<=caseN ; caseID++){
      System.out.printf("Case #%d: ",caseID);
      solve();
      System.out.flush();
    }
  }
  void debug(Object...os){
    System.err.println(deepToString(os));
  }
  public static void main(String[] args){
    try {
      System.setIn(new BufferedInputStream(new FileInputStream(args.length>0 ? args[0] :(D.class.getName()+".in"))));
    }
    catch(Exception e){
    }
    new D().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation solve() : void
  pre: true
  post: true
  activity: (     var cs : Sequence(String) ; cs := sc.getCurrent()->characters() ;
     var m : int ; m := 0 ;
     for (c : cs) do (     if (c = '?') then     m := m + 1 ; else skip ;  ) ; 
         var i : int ; i := 0 ; while i < (1*(2->pow(m)))->oclAsType(long) do ( (     var ds : Sequence(String) ; ds := cs->copy() ;
     var p : int ; p := 0 ;
        var j : int ; j := 0 ; while j < cs->size() do (     if (cs[j+1] = '?') then (     ds[j+1] := ('0' + (MathLib.bitwiseAnd((i/(2->pow(p)))->oclAsType(long),1)))->oclAsType(String) ; 
     p := p + 1 ) else skip ;  ;     j := j + 1 ) ; 
    var v : long ; v := 0 ;
    for (c : ds) do (     v := v * 2 + c - ('0')->char2byte() ;  ) ; 
    var a : long ; a := sqrt(v)->oclAsType(long) ;
    while (a * a < v) do     a := a + 1 ; ; 
    while (a * a > v) do     a := a - 1 ; ; 
    if (a * a = v) then (     OclFile["System.out"].println((MathLib.decimal2binary(v) + "")) ; 
     return ) else skip ; 
 )  ;     i := i + 1 ) );
   operation run() : void
  pre: true
  post: true
  activity: (     var caseN : int ; caseN := sc.getCurrent()->toInteger() ;
         var caseID : int ; caseID := 1 ; while caseID <= caseN do ( (     OclFile["System.out"].printf("Case #%d: ", caseID) ; 
     execute solve() ; 
     OclFile["System.out"].flush() )  ;     caseID := caseID + 1 ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile_Read(if args->size() > 0 then args[0+1] else (OclType["D"].getName() + ".in") endif))) )   catch (e : ProgramException) do skip
     D.newD().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  InputStream in=System.in ;
  PrintStream out=System.out ;
  public void _main(String[] args){
    Scanner sc=new Scanner(in);
    int N=sc.nextInt();
    int[] a=nextIntArray(sc,N);
    sc.close();
    int c4=0,c2=0,other=0 ;
    for(int x : a){
      if(x % 4==0){
        c4++;
      }
      else if(x % 2==0){
        c2++;
      }
      else {
        other++;
      }
    }
    c2 %=2 ;
    other+=c2 ;
    if(other-1<=c4){
      out.println("Yes");
    }
    else {
      out.println("No");
    }
  }
  public static void main(String[] args){
    new Main()._main(args);
  }
  @ SuppressWarnings("unused")private int[] nextIntArray(Scanner sc,int n){
    int[] result=new int[n];
    for(int i=0 ; i<n ; i++){
      result[i]=sc.nextInt();
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile["System.in"];
   attribute out : OclFile := OclFile["System.out"];
   operation _main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := nextIntArray(sc, N) ;
    skip ; 
    var c4 : int ; c4 := 0 ;
    var c2 : int ; c2 := 0 ;
    var other : int ; other := 0 ;
    for (x : a) do ( (     if (x mod 4 = 0) then (     c4 := c4 + 1 ) else     if (x mod 2 = 0) then (     c2 := c2 + 1 ) else (     other := other + 1 ) ;  )  ) ; 
    c2 := c2 mod 2 ; 
    other := other+(c2) ; 
    if (other - 1 <= c4) then (     skip ) else (     skip ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain()._main(args) );
      operation nextIntArray( sc : OclFile, n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var result : Sequence(int) ; result := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     result[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round3 ;
import java.io.File ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class D {
  static long[] stepeni=new long[62];
  static {
    stepeni[0]=1 ;
    for(int i=1 ; i<stepeni.length ; i++)stepeni[i]=2*stepeni[i-1];
  }
  static boolean jePotpunKvadrat(long a){
    long koren=Math.round(Math.sqrt(a));
    return koren*koren==a ;
  }
  static long resi(String s,long value,int position){
    if(jePotpunKvadrat(value))return value ;
    if(position==s.length())return-1 ;
    if(s.charAt(position)=='?'){
      long res=resi(s,value,position+1);
      if(res!=-1)return res ;
      return resi(s,value+stepeni[s.length()-position-1],position+1);
    }
    else return resi(s,value,position+1);
  }
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(new File("D.in"));
    PrintWriter out=new PrintWriter(new File("D.out"));
    int tt=in.nextInt();
    for(int ttt=1 ; ttt<=tt ; ttt++){
      String s=in.next();
      long min=0 ;
      for(int i=0 ; i<s.length(); i++)if(s.charAt(s.length()-i-1)=='1')min+=stepeni[i];
      long res=resi(s,min,0);
      out.printf("Case #%d: %s",ttt,Long.toBinaryString(res));
      out.println();
    }
    out.flush();
    out.close();
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   attribute stepeni : Sequence(long) := Integer.subrange(1,62)->collect(0);
  static operation initialiseClass()
  pre: true post: true
  activity:     stepeni[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < stepeni->size() do (     stepeni[i+1] := 2 * stepeni[i - 1+1] ;  ;     i := i + 1 ) ; 
;
  static   operation jePotpunKvadrat( a : long) : boolean
  pre: true
  post: true
  activity: (     var koren : long ; koren := ((a)->sqrt())->round() ;
     return koren * koren = a );
  static   operation resi( s : String, value : long, position : int) : long
  pre: true
  post: true
  activity: (     if (jePotpunKvadrat(value)) then     return value else skip ; 
     if (position = s->size()) then     return -1 else skip ; 
     if (s->at(position+1) = '?') then (     var res : long ; res := resi(s, value, position + 1) ;
     if (res /= -1) then     return res else skip ; 
     return resi(s, value + stepeni[s->size() - position - 1+1], position + 1) ) else     return resi(s, value, position + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("D.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("D.out")) ;
    var tt : int ; tt := in.getCurrent()->toInteger() ;
        var ttt : int ; ttt := 1 ; while ttt <= tt do ( (     var s : String ; s := in.getCurrent() ;
     var min : long ; min := 0 ;
        var i : int ; i := 0 ; while i < s->size() do (     if (s->at(s->size() - i - 1+1) = '1') then     min := min+(stepeni[i+1]) ; else skip ;  ;     i := i + 1 ) ; 
    var res : long ; res := resi(s, min, 0) ;
    skip ; 
    skip ; 
 )  ;     ttt := ttt + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public StringBuffer s ;
  public boolean ok ;
  public String ans ;
  public void rec(){
    if(ok)return ;
    int pos=-1 ;
    for(int i=0 ; i<s.length(); i++)if(s.charAt(i)=='?'){
      pos=i ;
      break ;
    }
    if(pos==-1){
      BigInteger b=BigInteger.ZERO ;
      for(int i=0 ; i<s.length(); i++)if(s.charAt(i)=='1')b=b.add(BigInteger.ONE.shiftLeft(s.length()-1-i));
      BigInteger l=BigInteger.ONE,r=BigInteger.TEN.pow(25);
      while(l.compareTo(r)!=0){
        BigInteger x=l.add(r).shiftRight(1);
        BigInteger xx=x.multiply(x);
        if(xx.compareTo(b)>=0)r=x ;
        else l=x.add(BigInteger.ONE);
      }
      BigInteger test=l.multiply(l);
      if(test.compareTo(b)==0){
        ok=true ;
        ans=test.toString(2);
      }
    }
    else {
      s.setCharAt(pos,'0');
      rec();
      s.setCharAt(pos,'1');
      rec();
      s.setCharAt(pos,'?');
    }
  }
  public void run()throws IOException {
    Scanner in=new Scanner(new File("D.in"));
    PrintWriter out=new PrintWriter(new File("D.out"));
    int T=in.nextInt();
    in.nextLine();
    for(int t=1 ; t<=T ; t++){
      out.print("Case #"+t+": ");
      String ss=in.nextLine();
      s=new StringBuffer(ss);
      ok=false ;
      rec();
      out.println(ans);
      out.flush();
    }
  }
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute s : String;
   attribute ok : boolean;
   attribute ans : String;
   operation rec() : void
  pre: true
  post: true
  activity: (     if (ok) then     return else skip ; 
     var pos : int ; pos := -1 ;
         var i : int ; i := 0 ; while i < s->size() do (     if (s->at(i+1) = '?') then (     pos := i ; 
     break ) else skip ;  ;     i := i + 1 ) ; 
     if (pos = -1) then (     var b : long ; b := 0 ;
         var i : int ; i := 0 ; while i < s->size() do (     if (s->at(i+1) = '1') then     b := b->excludes(1.shiftLeft(s->size() - 1 - i)) ; else skip ;  ;     i := i + 1 ) ; 
    var l : long ; l := 1 ;
    var r : long ; r := 10.pow(25) ;
    while (l->compareTo(r) /= 0) do (     var x : long ; x := l->excludes(r).shiftRight(1) ;
     var xx : long ; xx := x.multiply(x) ;
     if (xx->compareTo(b) >= 0) then     r := x ; else     l := x->excludes(1) ; ) ; 
    var test : long ; test := l.multiply(l) ;
    if (test->compareTo(b) = 0) then (     ok := true ; 
     ans := test.toString(2) ) else skip ; 
 ) else (     s := s.setAt(pos+1, '0') ; 
     execute rec() ; 
    s := s.setAt(pos+1, '1') ; 
    execute rec() ; 
    s := s.setAt(pos+1, '?') ; 
 ) );
   operation run() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("D.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("D.out")) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
    skip ; 
        var t : int ; t := 1 ; while t <= T do ( (     skip ; 
     var ss : String ; ss := in.nextLine() ;
    s := StringLib.newString(ss) ; 
    ok := false ; 
    execute rec() ; 
    skip ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static String findNumber(int n,int d){
    String ans="" ;
    if(d!=10){
      ans+=Integer.toString(d);
      for(int i=1 ; i<n ; i++)ans+='0' ;
    }
    else {
      if(n==1)ans+="Impossible" ;
      else {
        ans+='1' ;
        for(int i=1 ; i<n ; i++)ans+='0' ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int n=12,d=3 ;
    System.out.println(findNumber(n,d));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNumber( n : int, d : int) : String
  pre: true
  post: true
  activity: (     var ans : String ; ans := "" ;
     if (d /= 10) then (     ans := ans+(((d) + "")) ; 
         var i : int ; i := 1 ; while i < n do (     ans := ans+('0') ;  ;     i := i + 1 ) ) else (     if (n = 1) then     ans := ans+("Impossible") ; else (     ans := ans+('1') ; 
         var i : int ; i := 1 ; while i < n do (     ans := ans+('0') ;  ;     i := i + 1 ) ) ) ;  
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
    var d : int ; d := 3 ;
     OclFile["System.out"].println(findNumber(n, d)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(final String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int n=scanner.nextInt();
    final int[] array=new int[100];
    for(int i=1 ; i<=n ; i++){
      if(i % 10==0){
        continue ;
      }
      final String s=Integer.toString(i);
      array[(s.charAt(0)-'0')*10+s.charAt(s.length()-1)-'0']++;
    }
    int count=0 ;
    for(int i=11 ; i<=99 ; i++){
      final int reverseNum=i % 10*10+i/10 ;
      count+=array[i]*array[reverseNum];
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,100)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     if (i mod 10 = 0) then (     continue ) else skip ; 
     var s : String ; s := ((i) + "") ;
     array[(s->at(0+1) - ('0')->char2byte()) * 10 + s->at(s->size() - 1+1) - ('0')->char2byte()+1] := array[(s->at(0+1) - ('0')->char2byte()) * 10 + s->at(s->size() - 1+1) - ('0')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 11 ; while i <= 99 do ( (     var reverseNum : int ; reverseNum := i mod 10 * 10 + i / 10 ;
     count := count+(array[i+1] * array[reverseNum+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countRectangles(int radius){
    int rectangles=0 ;
    int diameter=2*radius ;
    int diameterSquare=diameter*diameter ;
    for(int a=1 ; a<2*radius ; a++){
      for(int b=1 ; b<2*radius ; b++){
        int diagnalLengthSquare=(a*a+b*b);
        if(diagnalLengthSquare<=diameterSquare){
          rectangles++;
        }
      }
    }
    return rectangles ;
  }
  public static void main(String[] args){
    int radius=2 ;
    int totalRectangles ;
    totalRectangles=countRectangles(radius);
    System.out.println(totalRectangles+" rectangles can be "+"cut from a circle of"+" Radius "+radius);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countRectangles( radius : int) : int
  pre: true
  post: true
  activity: (     var rectangles : int ; rectangles := 0 ;
     var diameter : int ; diameter := 2 * radius ;
    var diameterSquare : int ; diameterSquare := diameter * diameter ;
        var a : int ; a := 1 ; while a < 2 * radius do ( (         var b : int ; b := 1 ; while b < 2 * radius do ( (     var diagnalLengthSquare : int ; diagnalLengthSquare := (a * a + b * b) ;
     if (diagnalLengthSquare <= diameterSquare) then (     rectangles := rectangles + 1 ) else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    return rectangles 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var radius : int ; radius := 2 ;
     var totalRectangles : int ;
     totalRectangles := countRectangles(radius) ; 
     OclFile["System.out"].println(totalRectangles + " rectangles can be " + "cut from a circle of" + " Radius " + radius) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int log_a_to_base_b(int a,int b){
    int rslt=(a>b-1)? 1+log_a_to_base_b(a/b,b): 0 ;
    return rslt ;
  }
  public static void main(String[] args){
    int a=3 ;
    int b=2 ;
    System.out.println(log_a_to_base_b(a,b));
    a=256 ;
    b=4 ;
    System.out.println(log_a_to_base_b(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation log_a_to_base_b( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var rslt : int ; rslt := if (a > b - 1) then 1 + log_a_to_base_b(a / b, b) else 0 endif ;
     return rslt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
     var b : int ; b := 2 ;
    OclFile["System.out"].println(log_a_to_base_b(a, b)) ; 
    a := 256 ; 
    b := 4 ; 
    OclFile["System.out"].println(log_a_to_base_b(a, b)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Token implements Comparable<Token>{
  public int ope ;
  public int weight ;
  private int time ;
  Token(int o,int m,int t){
    this.ope=o ;
    this.weight=m ;
    this.time=t ;
  }
  public int compareTo(Token t){
    int ret ;
    ret=this.time-t.time ;
    if(ret==0){
      ret=this.ope-t.ope ;
    }
    return ret ;
  }
}
class Main {
  private static ArrayList<Token>ar=new ArrayList<Token>();
  public static void main(String[] args){
    int n,m,sum ;
    String result ;
    Scanner sc=new Scanner(System.in);
    while((n=sc.nextInt())!=0){
      ar.clear();
      while(n-->0){
        m=sc.nextInt();
        ar.add(new Token(1,m,sc.nextInt()));
        ar.add(new Token(-1,m,sc.nextInt()));
      }
      Collections.sort(ar);
      sum=0 ;
      result="OK" ;
      for(Token t : ar){
        sum+=t.weight*t.ope ;
        if(sum>150){
          result="NG" ;
          break ;
        }
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Token implements Comparable<Token> {
   attribute ope : int;
   attribute weight : int;
   attribute time : int;
   static operation newToken( o : int, m : int, t : int) : Token
  pre: true
  post: true
  activity:
  ( var self : Token ;
    self := createToken();
    self.initialise(o, m,t);
    return self );
  operation initialise( o : int, m : int, t : int) : void
  pre: true  post: true
  activity: (     self.ope := o ; 
     self.weight := m ; 
     self.time := t );
   operation compareTo( t : Token) : int
  pre: true
  post: true
  activity: (     var ret : int ;
     ret := self.time - t.time ; 
     if (ret = 0) then (     ret := self.ope - t.ope ) else skip ; 
     return ret );
}
class Main {
  static   attribute ar : Sequence(Token) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ;
    var m : int ;
    var sum : int ;
     var result : String ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         n := sc.getCurrent()->toInteger() ;
    while ((n) /= 0) do (    skip ; (     ar := ar->intersection(Set{}) ; 
         while (n > 0) do (        n := n - 1 ;     skip ; (     m := sc.getCurrent()->toInteger() ; 
     ar := ar->including(Token.newToken(1, m, sc.getCurrent()->toInteger())) ; 
     ar := ar->including(Token.newToken(-1, m, sc.getCurrent()->toInteger())) ) ;  ) ;  
    ar := ar->sort() ; 
    sum := 0 ; 
    result := "OK" ; 
    for (t : ar) do ( (     sum := sum+(t.weight * t.ope) ; 
     if (sum > 150) then (     result := "NG" ; 
     break ) else skip )  ) ; 
    OclFile["System.out"].println(result) ; 
 ) ;     n := sc.getCurrent()->toInteger() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      final int n=sc.nextInt();
      if(n==0){
        break ;
      }
      TreeSet<Integer>set=new TreeSet<Integer>();
      int[][] post=new int[n][3];
      for(int i=0 ; i<n ; i++){
        post[i][0]=sc.nextInt();
        post[i][1]=sc.nextInt();
        post[i][2]=sc.nextInt();
        set.add(post[i][1]);
        set.add(post[i][2]);
      }
      ArrayList<Integer>list=new ArrayList<Integer>(set);
      int[] array=new int[set.size()];
      int max=0 ;
      for(int i=0 ; i<n ; i++){
        final int end=Collections.binarySearch(list,post[i][2]);
        for(int j=Collections.binarySearch(list,post[i][1]); j<end ; j++){
          array[j]+=post[i][0];
          max=Math.max(max,array[j]);
        }
      }
      System.out.println(max>150 ? "NG" : "OK");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var set : Set(int) ; set := Set{} ;
    var post : Sequence(Sequence(int)) ; post := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     post[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     post[i+1][1+1] := sc.getCurrent()->toInteger() ; 
    post[i+1][2+1] := sc.getCurrent()->toInteger() ; 
    set := set->including(post[i+1][1+1]) ; 
    set := set->including(post[i+1][2+1]) ; 
 )  ;     i := i + 1 ) ; 
    var list : Sequence(int) ; list := Sequence{}->union(set) ;
    var array : Sequence(int) ; array := Integer.subrange(1,set->size())->collect(0) ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var end : int ; end := .binarySearch(list, post[i+1][2+1]) ;
         var j : int ; j := .binarySearch(list, post[i+1][1+1]) ; while j < end do ( (     array[j+1] := array[j+1]+(post[i+1][0+1]) ; 
     max := Set{max, array[j+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if max > 150 then "NG" else "OK" endif) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    boolean count2=false ;
    int count4=0 ;
    int countodd=0 ;
    boolean ok=false ;
    int n=scan.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scan.nextInt();
      if(a[i] % 2==0 && a[i] % 4!=0){
        count2=true ;
      }
      if(a[i] % 4==0){
        count4++;
      }
      if(a[i] % 2!=0){
        countodd++;
      }
    }
    if(count2){
      if(count4>=countodd){
        ok=true ;
      }
    }
    else {
      if((count4+1)>=countodd){
        ok=true ;
      }
    }
    if(ok){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
    System.out.println("");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count2 : boolean ; count2 := false ;
    var count4 : int ; count4 := 0 ;
    var countodd : int ; countodd := 0 ;
    var ok : boolean ; ok := false ;
    var n : int ; n := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() ; 
     if (a[i+1] mod 2 = 0 & a[i+1] mod 4 /= 0) then (     count2 := true ) else skip ; 
     if (a[i+1] mod 4 = 0) then (     count4 := count4 + 1 ) else skip ; 
     if (a[i+1] mod 2 /= 0) then (     countodd := countodd + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (count2) then (     if (count4 >= countodd) then (     ok := true ) else skip ) else (     if ((count4 + 1) >= countodd) then (     ok := true ) else skip ) ;  
    if (ok) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
    OclFile["System.out"].println("") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args){
    BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
    try {
      while(true){
        int n=Integer.valueOf(sc.readLine());
        if(n==0)break ;
        TreeMap<Integer,Integer>used=new TreeMap<Integer,Integer>();
        for(int i=0 ; i<n ; i++){
          String[] sp=sc.readLine().split(" ");
          int m=Integer.valueOf(sp[0]);
          int a=Integer.valueOf(sp[1]);
          int b=Integer.valueOf(sp[2]);
          if(used.containsKey(a)){
            int t=used.get(a);
            used.remove(a);
            used.put(a,t+m);
          }
          else used.put(a,m);
          if(used.containsKey(b)){
            int t=used.get(b);
            used.remove(b);
            used.put(b,t-m);
          }
          else used.put(b,0-m);
        }
        int sum=0 ;
        String out="OK" ;
        for(int i : used.keySet()){
          sum+=used.get(i);
          if(sum>150){
            out="NG" ;
            break ;
          }
        }
        System.out.println(out);
      }
    }
    catch(Exception e){
      System.out.println("Error");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     while (true) do (     var n : int ; n := (sc.readLine())->toInteger() ;
     if (n = 0) then     break else skip ; 
    var used : Map(int,int) ; used := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var sp : Sequence(String) ; sp := sc.readLine()->split(" ") ;
     var m : int ; m := (sp[0+1])->toInteger() ;
    var a : int ; a := (sp[1+1])->toInteger() ;
    var b : int ; b := (sp[2+1])->toInteger() ;
    if (used->keys()->includes(a)) then (     var t : int ; t := used->at(a) ;
     used := used->antirestrict(Set{a}) ; 
     used := used->union(Map{a |-> t + m}) ) else     used := used->union(Map{a |-> m}) ; ;  
    if (used->keys()->includes(b)) then (     var t : int ; t := used->at(b) ;
     used := used->antirestrict(Set{b}) ; 
     used := used->union(Map{b |-> t - m}) ) else     used := used->union(Map{b |-> 0 - m}) ; ;  
 )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var out : String ; out := "OK" ;
    for (i : used->keys()) do ( (     sum := sum+(used->at(i)) ; 
     if (sum > 150) then (     out := "NG" ; 
     break ) else skip )  ) ; 
    OclFile["System.out"].println(out) ; 
 ) )   catch (e : ProgramException) do (     OclFile["System.out"].println("Error") )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B {
  static Scanner sc=new Scanner(System.in);
  static int N ;
  static long P ;
  public static void main(String[] args)throws Exception {
    int T=sc.nextInt();
    for(int t=1 ; t<=T ; ++t){
      N=sc.nextInt();
      P=sc.nextLong();
      System.out.println("Case #"+t+": "+(solveGuarantee(1L<<N,P)-1)+" "+(solveCould(1L<<N,P)-1));
    }
  }
  static long solveGuarantee(long n,long p){
    if(p==n)return n ;
    if(p<=n/2)return 1 ;
    return solveGuarantee(n/2,p-n/2)*2+1 ;
  }
  static long solveCould(long n,long p){
    if(p==n)return n ;
    if(p>=n/2)return n-1 ;
    long c=solveCould(n/2,p);
    return c+c-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int;
  static   attribute P : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := sc.getCurrent()->toInteger() ;
         var t : int ; t := 1 ; while t <= T do ( (     N := sc.getCurrent()->toInteger() ; 
     P := sc.getCurrent()->toLong() ; 
     OclFile["System.out"].println("Case #" + t + ": " + (solveGuarantee((1L*(2->pow(N)))->oclAsType(long), P) - 1) + " " + (solveCould((1L*(2->pow(N)))->oclAsType(long), P) - 1)) )  ;     t := t + 1 ) );
  static   operation solveGuarantee( n : long, p : long) : long
  pre: true
  post: true
  activity: (     if (p = n) then     return n else skip ; 
     if (p <= n / 2) then     return 1 else skip ; 
     return solveGuarantee(n / 2, p - n / 2) * 2 + 1 );
  static   operation solveCould( n : long, p : long) : long
  pre: true
  post: true
  activity: (     if (p = n) then     return n else skip ; 
     if (p >= n / 2) then     return n - 1 else skip ; 
     var c : long ; c := solveCould(n / 2, p) ;
     return c + c - 1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package contest;
import java.util.*;
import java.io.*;
public class ManyPrizes {
    final static String PROBLEM_NAME = "mprizes";
    final static String WORK_DIR = "D:\\Gcj\\" + PROBLEM_NAME + "\\";
    void solve(Scanner sc, PrintWriter pw) {
        int N = sc.nextInt();
        long P = sc.nextLong();
        long ans1 = -1;
        long sum = 0;
        for (int i = N - 1; i >= 0; i--) {
            sum += (1L << i);
            if (P <= sum) {
                ans1 = (1L << (N - i)) - 1;
                break;
            }
        }
        if (ans1 == -1) ans1 = (1L << N);
        long ans2 = -1;
        int needWins = 0;
        while ((1L << (N - needWins)) > P) needWins++;
        ans2 = (1L << N) - (1L << needWins) + 1;
        ans1--;
        ans2--;
        pw.println(ans1 + " " + ans2);
    }
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(new FileReader(WORK_DIR + "input.txt"));
        PrintWriter pw = new PrintWriter(new FileWriter(WORK_DIR + "output.txt"));
        int caseCnt = sc.nextInt();
        for (int caseNum = 0; caseNum < caseCnt; caseNum++) {
            System.out.println("Processing test case " + (caseNum + 1));
            pw.print("Case #" + (caseNum + 1) + ": ");
            new ManyPrizes().solve(sc, pw);
        }
        pw.flush();
        pw.close();
        sc.close();
    }
}

------------------------------------------------------------
OCL File:
---------
 class ManyPrizes {
  static   attribute PROBLEM_NAME : String := "mprizes";
  static   attribute WORK_DIR : String := "D:\\Gcj\\" + PROBLEM_NAME + "\\";
   operation solve( sc : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.nextInt() ;
     var P : long ; P := sc.nextLong() ;
    var ans1 : long ; ans1 := -1 ;
    var sum : long ; sum := 0 ;
        var i : int ; i := N - 1 ; while i >= 0 do ( (     sum := sum+(((1L*(2->pow(i)))->oclAsType(long))) ; 
     if (P <= sum) then (     ans1 := ((1L*(2->pow((N - i))))->oclAsType(long)) - 1 ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    if (ans1 = -1) then     ans1 := ((1L*(2->pow(N)))->oclAsType(long)) ; else skip ; 
    var ans2 : long ; ans2 := -1 ;
    var needWins : int ; needWins := 0 ;
    while (((1L*(2->pow((N - needWins))))->oclAsType(long)) > P) do     needWins := needWins + 1 ; ; 
    ans2 := ((1L*(2->pow(N)))->oclAsType(long)) - ((1L*(2->pow(needWins)))->oclAsType(long)) + 1 ; 
    ans1 := ans1 - 1 ; 
    ans2 := ans2 - 1 ; 
    pw.println(ans1 + " " + ans2) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(WORK_DIR + "input.txt")) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(WORK_DIR + "output.txt")) ;
    var caseCnt : int ; caseCnt := sc.getCurrent()->toInteger() ;
        var caseNum : int ; caseNum := 0 ; while caseNum < caseCnt do ( (     OclFile["System.out"].println("Processing test case " + (caseNum + 1)) ; 
     skip ; 
     ManyPrizes.newManyPrizes().solve(sc, pw) )  ;     caseNum := caseNum + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n<10){
      System.out.println(n);
      return ;
    }
    int[][] field=new int[10][10];
    for(int i=1 ; i<10 ; i++){
      field[i][i]++;
    }
    int base=10 ;
    int top=1 ;
    int level=1 ;
    while(base<=n){
      for(int j=1 ; j<=level ; j++){
        for(int i=0 ; i<10 && base<=n ; i++){
          field[top][i]++;
          base++;
        }
      }
      top++;
      if(top==10){
        top=1 ;
        level*=10 ;
      }
    }
    long count=0 ;
    for(int i=1 ; i<10 ; i++){
      for(int j=1 ; j<10 ; j++){
        count+=field[i][j]*field[j][i];
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    if (n < 10) then (     OclFile["System.out"].println(n) ; 
     return ) else skip ; 
    var field : Sequence(Sequence(int)) ; field := Integer.subrange(1,10)->collect(Integer.subrange(1,10)->collect(0)) ;
        var i : int ; i := 1 ; while i < 10 do ( (     field[i+1][i+1] := field[i+1][i+1] + 1 )  ;     i := i + 1 ) ; 
    var base : int ; base := 10 ;
    var top : int ; top := 1 ;
    var level : int ; level := 1 ;
    while (base <= n) do (         var j : int ; j := 1 ; while j <= level do ( (         var i : int ; i := 0 ; while i < 10 & base <= n do ( (     field[top+1][i+1] := field[top+1][i+1] + 1 ; 
     base := base + 1 )  ;     i := i + 1 ) )  ;     j := j + 1 ) ; 
     top := top + 1 ; 
     if (top = 10) then (     top := 1 ; 
     level := level*(10) ) else skip ) ; 
    var count : long ; count := 0 ;
        var i : int ; i := 1 ; while i < 10 do ( (         var j : int ; j := 1 ; while j < 10 do ( (     count := count+(field[i+1][j+1] * field[j+1][i+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
public class B {
  static BigInteger B(long n){
    return BigInteger.valueOf(n);
  }
  static BigInteger A(BigInteger A,BigInteger B){
    return A.add(B);
  }
  static BigInteger M(BigInteger A,BigInteger B){
    return A.multiply(B);
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int cas=1 ; cas<=T ; cas++){
      int n=in.nextInt();
      BigInteger P=new BigInteger(in.next());
      BigInteger last_pos=B(2).pow(n).subtract(P);
      int min_ones=0 ;
      for(min_ones=0 ; min_ones<=n ; min_ones++){
        BigInteger val=B(0);
        for(int i=0 ; i<min_ones ; i++)val=A(val,B(2).pow(n-1-i));
        if(val.compareTo(last_pos)>=0)break ;
      }
      BigInteger last_win=B(2).pow(n).subtract(B(2).pow(min_ones));
      int min_zeroes=0 ;
      for(min_zeroes=0 ; min_zeroes<=n ; min_zeroes++){
        BigInteger val=B(2).pow(n).subtract(B(1));
        for(int i=0 ; i<min_zeroes ; i++)val=val.subtract(B(2).pow(n-1-i));
        if(val.compareTo(last_pos)<0)break ;
      }
      BigInteger last_guarantee=B(2).pow(min_zeroes).subtract(B(2));
      if(last_pos.equals(B(0)))last_guarantee=B(2).pow(n).subtract(B(1));
      System.out.printf("Case #%d: %s %s\n",cas,last_guarantee,last_win);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation B( n : long) : long
  pre: true
  post: true
  activity: (     return (n + "")->toLong() );
  static   operation A( A : long, B : long) : long
  pre: true
  post: true
  activity: (     return A->excludes(B) );
  static   operation M( A : long, B : long) : long
  pre: true
  post: true
  activity: (     return A.multiply(B) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var cas : int ; cas := 1 ; while cas <= T do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var P : long ; P := long(in.getCurrent()) ;
    var last_pos : long ; last_pos := B(2).pow(n).subtract(P) ;
    var min_ones : int ; min_ones := 0 ;
        min_ones := 0 ; while min_ones <= n do ( (     var val : long ; val := B(0) ;
         var i : int ; i := 0 ; while i < min_ones do (     val := A(val, B(2).pow(n - 1 - i)) ;  ;     i := i + 1 ) ; 
     if (val->compareTo(last_pos) >= 0) then     break else skip )  ;     min_ones := min_ones + 1 ) ; 
    var last_win : long ; last_win := B(2).pow(n).subtract(B(2).pow(min_ones)) ;
    var min_zeroes : int ; min_zeroes := 0 ;
        min_zeroes := 0 ; while min_zeroes <= n do ( (     var val : long ; val := B(2).pow(n).subtract(B(1)) ;
         var i : int ; i := 0 ; while i < min_zeroes do (     val := val.subtract(B(2).pow(n - 1 - i)) ;  ;     i := i + 1 ) ; 
     if (val->compareTo(last_pos) < 0) then     break else skip )  ;     min_zeroes := min_zeroes + 1 ) ; 
    var last_guarantee : long ; last_guarantee := B(2).pow(min_zeroes).subtract(B(2)) ;
    if (last_pos = B(0)) then     last_guarantee := B(2).pow(n).subtract(B(1)) ; else skip ; 
    OclFile["System.out"].printf("Case #%d: %s %s\n", cas, last_guarantee, last_win) ; 
 )  ;     cas := cas + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class B {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner in=new Scanner(new File(B.class.getSimpleName()+".in"));
    PrintWriter out=new PrintWriter(new File(B.class.getSimpleName()+".out"));
    int T=in.nextInt();
    for(int i=0 ; i<T ; i++){
      String s="Case #"+(i+1)+": "+new B().solve(in);
      out.println(s);
      System.out.println(s);
    }
    out.close();
  }
  private String solve(Scanner in){
    int n=in.nextInt();
    long p=in.nextLong();
    p--;
    long b=1 ;
    if(p==((1L<<n)-1)){
      b=((1L<<n)-1)+2 ;
    }
    else {
      long pp=(1L<<n)-1-(p+1);
      for(int i=n-1 ; i>=0 ; i--){
        if(((pp>>i)& 1)==0){
          b*=2 ;
        }
        else {
          for(int j=i-1 ; j>=0 ; j--){
            if(((pp>>j)& 1)==0){
              b*=2 ;
              break ;
            }
          }
          break ;
        }
      }
    }
    long pp=(1L<<n)-1-p ;
    long c=1 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(((pp>>i)& 1)==1){
        c*=2 ;
      }
      else {
        for(int j=i-1 ; j>=0 ; j--){
          if(((pp>>j)& 1)==1){
            c*=2 ;
            break ;
          }
        }
        break ;
      }
    }
    return(b-2)+" "+((1L<<n)-c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile(OclType["B"].getSimpleName() + ".in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile(OclType["B"].getSimpleName() + ".out")) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < T do ( (     var s : String ; s := "Case #" + (i + 1) + ": " + B.newB().solve(in) ;
     skip ; 
     OclFile["System.out"].println(s) )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation solve( in : OclFile) : String
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var p : long ; p := in.getCurrent()->toLong() ;
    p := p - 1 ; 
    var b : long ; b := 1 ;
    if (p = (((1L*(2->pow(n)))->oclAsType(long)) - 1)) then (     b := (((1L*(2->pow(n)))->oclAsType(long)) - 1) + 2 ) else (     var pp : long ; pp := ((1L*(2->pow(n)))->oclAsType(long)) - 1 - (p + 1) ;
         var i : int ; i := (n)->char2byte() - 1 ; while i >= 0 do ( (     if ((((pp/(2->pow(i)))->oclAsType(long)) & 1) = 0) then (     b := b*(2) ) else (         var j : int ; j := i - 1 ; while j >= 0 do ( (     if ((((pp/(2->pow(j)))->oclAsType(long)) & 1) = 0) then (     b := b*(2) ; 
     break ) else skip )  ;     j := j - 1 ) ; 
     break ) )  ;     i := i - 1 ) ) ;  
    var pp : long ; pp := ((1L*(2->pow(n)))->oclAsType(long)) - 1 - p ;
    var c : long ; c := 1 ;
        var i : int ; i := (n)->char2byte() - 1 ; while i >= 0 do ( (     if ((((pp/(2->pow(i)))->oclAsType(long)) & 1) = 1) then (     c := c*(2) ) else (         var j : int ; j := i - 1 ; while j >= 0 do ( (     if ((((pp/(2->pow(j)))->oclAsType(long)) & 1) = 1) then (     c := c*(2) ; 
     break ) else skip )  ;     j := j - 1 ) ; 
     break ) )  ;     i := i - 1 ) ; 
    return (b - 2) + " " + (((1L*(2->pow(n)))->oclAsType(long)) - c) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int getNumber(int n,int k){
    int pos ;
    if((n % 2)==0){
      pos=n/2 ;
    }
    else {
      pos=(n/2)+1 ;
    }
    if(k<=pos){
      return(k*2-1);
    }
    else return((k-pos)*2);
  }
  public static void main(String[] args){
    int n=8,k=5 ;
    System.out.println(getNumber(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getNumber( n : int, k : int) : int
  pre: true
  post: true
  activity: (     var pos : int ;
     if ((n mod 2) = 0) then (     pos := n / 2 ) else (     pos := (n / 2) + 1 ) ;  
     if (k <= pos) then (     return (k * 2 - 1) ) else     return ((k - pos) * 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
    var k : int ; k := 5 ;
     OclFile["System.out"].println(getNumber(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static boolean isCubeFree(int n){
    if(n==1)return false ;
    for(int i=2 ; i*i*i<=n ; i++)if(n %(i*i*i)==0)return false ;
    return true ;
  }
  public static void printCubeFree(int n){
    for(int i=2 ; i<=n ; i++){
      if(isCubeFree(i)){
        System.out.print(i+" ");
      }
    }
  }
  public static void main(String[] args){
    int n=20 ;
    printCubeFree(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isCubeFree( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n = 1) then     return false else skip ; 
         var i : int ; i := 2 ; while i * i * i <= n do (     if (n mod (i * i * i) = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
     return true );
  static   operation printCubeFree( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i <= n do ( (     if (isCubeFree(i)) then (     OclFile["System.out"].print(i + " ") ) else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 20 ;
     execute printCubeFree(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean makeAndCheckString(Vector<String>words,String str){
    int n=words.size();
    boolean first=false,second=false ;
    for(int i=0 ; i<n ; i++){
      if(words.get(i)==str)return true ;
      if(str.charAt(0)==words.get(i).charAt(1))first=true ;
      if(str.charAt(1)==words.get(i).charAt(0))second=true ;
      if(first && second)return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    String str="ya" ;
    String[] array={
      "ah","oy","to","ha" };
      Vector<String>words=new Vector<String>(Arrays.asList(array));
      if(makeAndCheckString(words,str))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation makeAndCheckString( words : Sequence(String), str : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := words->size() ;
     var first : boolean ; first := false ;
    var second : boolean ; second := false ;
         var i : int ; i := 0 ; while i < n do ( (     if (words->at(i+1) = str) then     return true else skip ; 
     if (str->at(0+1) = words->at(i+1)->at(1+1)) then     first := true ; else skip ; 
     if (str->at(1+1) = words->at(i+1)->at(0+1)) then     second := true ; else skip ; 
     if (first & second) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "ya" ;
     var array : Sequence(String) ; array := Sequence{"ah","oy","to","ha"} ;
     var words : Sequence(String) ; words := Sequence{}->union(array) ;
     if (makeAndCheckString(words, str)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner((System.in));
    int N=sc.nextInt();
    int[] n=new int[N+1];
    String ans="No" ;
    int c4=0,c2=0 ;
    for(int i=0 ; i<N ; i++){
      n[i]=sc.nextInt();
      if(n[i] % 4==0){
        c4++;
      }
      else if(n[i] % 2==0){
        c2++;
      }
    }
    if(c2==N){
      ans="Yes" ;
    }
    else {
      if(c2>=2){
        N-=c2 ;
        if((N % 2)==0 &&(N/2)<=c4){
          ans="Yes" ;
        }
        else if((N % 2)!=0 &&(c4*2)>=(N+1)){
          ans="Yes" ;
        }
      }
      else {
        if((N % 2)==0 &&(N/2)<=c4){
          ans="Yes" ;
        }
        else if((N % 2)!=0 &&(c4*2)>=(N-1)){
          ans="Yes" ;
        }
      }
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read((OclFile["System.in"])) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var n : Sequence(int) ; n := Integer.subrange(1,N + 1)->collect(0) ;
    var ans : String ; ans := "No" ;
    var c4 : int ; c4 := 0 ;
    var c2 : int ; c2 := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     n[i+1] := sc.getCurrent()->toInteger() ; 
     if (n[i+1] mod 4 = 0) then (     c4 := c4 + 1 ) else     if (n[i+1] mod 2 = 0) then (     c2 := c2 + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    if (c2 = N) then (     ans := "Yes" ) else (     if (c2 >= 2) then (     N := N-(c2) ; 
     if ((N mod 2) = 0 & (N / 2) <= c4) then (     ans := "Yes" ) else     if ((N mod 2) /= 0 & (c4 * 2) >= (N + 1)) then (     ans := "Yes" ) else skip ; ) else (     if ((N mod 2) = 0 & (N / 2) <= c4) then (     ans := "Yes" ) else     if ((N mod 2) /= 0 & (c4 * 2) >= (N - 1)) then (     ans := "Yes" ) else skip ; ) ) ;  
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minSum(int n){
    int sum=0 ;
    while(n>0){
      sum+=(n % 10);
      n/=10 ;
    }
    if(sum==1)return 10 ;
    return sum ;
  }
  public static void main(String[] args){
    int n=1884 ;
    System.out.print(minSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n > 0) do (     sum := sum+((n mod 10)) ; 
     n := n/(10) ) ; 
     if (sum = 1) then     return 10 else skip ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1884 ;
     OclFile["System.out"].print(minSum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
    int t=Integer.parseInt(in.readLine());
    while(t-->0){
      String[] s0=in.readLine().split(" ");
      String[] s1=in.readLine().split(" ");
      long n=Long.parseLong(s0[0]);
      long k=Long.parseLong(s0[1]);
      long[] nums=new long[(int)k];
      for(int i=0 ; i<k ; i++){
        nums[i]=Long.parseLong(s1[i]);
      }
      boolean isPos=true ;
      long curr ;
      if(nums[0]>0){
        curr=nums[0]/(n-k+1);
        if((nums[0] %(n-k+1))>0){
          curr++;
        }
      }
      else {
        curr=nums[0]/(n-k+1);
      }
      for(int i=1 ; i<k ; i++){
        long next=nums[i]-nums[i-1];
        if(curr<=next){
          curr=next ;
        }
        else {
          isPos=false ;
          break ;
        }
      }
      if(isPos){
        out.write("Yes\n");
      }
      else {
        out.write("No\n");
      }
      out.flush();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
     var t : int ; t := (in.readLine())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s0 : Sequence(String) ; s0 := in.readLine()->split(" ") ;
     var s1 : Sequence(String) ; s1 := in.readLine()->split(" ") ;
    var n : long ; n := (s0[0+1])->toLong() ;
    var k : long ; k := (s0[1+1])->toLong() ;
    var nums : Sequence(long) ; nums := Integer.subrange(1,k->oclAsType(int))->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     nums[i+1] := (s1[i+1])->toLong() )  ;     i := i + 1 ) ; 
    var isPos : boolean ; isPos := true ;
    var curr : long ;
    if (nums[0+1] > 0) then (     curr := nums[0+1] / (n - k + 1) ; 
     if ((nums[0+1] mod (n - k + 1)) > 0) then (     curr := curr + 1 ) else skip ) else (     curr := nums[0+1] / (n - k + 1) ) ;  
        var i : int ; i := 1 ; while i < k do ( (     var next : long ; next := nums[i+1] - nums[i - 1+1] ;
     if (curr <= next) then (     curr := next ) else (     isPos := false ; 
     break ) )  ;     i := i + 1 ) ; 
    if (isPos) then (     skip ) else (     skip ) ;  
    skip ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1738 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    StringBuilder out=new StringBuilder();
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      int K=in.nextInt();
      int[] S=new int[K];
      for(int k=0 ; k<K ; k++){
        S[k]=in.nextInt();
      }
      boolean possible=true ;
      int last=Integer.MAX_VALUE ;
      for(int k=K-1 ; k>0 ; k--){
        int current=S[k]-S[k-1];
        if(current>last){
          possible=false ;
          break ;
        }
        last=current ;
      }
      if((N-K+1)*(long)last<S[0]){
        possible=false ;
      }
      out.append(possible ? "YES\n" : "NO\n");
    }
    System.out.print(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1738 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : String ; out := StringLib.newString() ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var K : int ; K := in.getCurrent()->toInteger() ;
    var S : Sequence(int) ; S := Integer.subrange(1,K)->collect(0) ;
        var k : int ; k := 0 ; while k < K do ( (     S[k+1] := in.getCurrent()->toInteger() )  ;     k := k + 1 ) ; 
    var possible : boolean ; possible := true ;
    var last : int ; last := 2147483647 ;
        var k : int ; k := K - 1 ; while k > 0 do ( (     var current : int ; current := S[k+1] - S[k - 1+1] ;
     if (current > last) then (     possible := false ; 
     break ) else skip ; 
     last := current )  ;     k := k - 1 ) ; 
    if ((N - K + 1) * last->oclAsType(long) < S[0+1]) then (     possible := false ) else skip ; 
    out := out + StringLib.newString(if possible then "YES\n" else "NO\n" endif) ; 
 )  ;     t := t + 1 ) ; 
    OclFile["System.out"].print(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    StringBuilder sb_s=new StringBuilder(input.nextLine());
    StringBuilder sb1=new StringBuilder(input.nextLine());
    sb_s=sb_s.append(sb1.reverse());
    StringBuilder sb_e=new StringBuilder(input.nextLine());
    StringBuilder sb2=new StringBuilder(input.nextLine());
    sb_e=sb_e.append(sb2.reverse());
    String str_s=sb_s.toString();
    String str_e=sb_e.toString();
    char ch_s[]=str_s.toCharArray();
    int x=str_s.indexOf("X");
    for(int j=0 ; j<12 ; j++){
      if(x==0){
        ch_s[x]=ch_s[3];
        ch_s[3]='X' ;
        x=3 ;
      }
      else {
        ch_s[x]=ch_s[x-1];
        ch_s[x-1]='X' ;
        x--;
      }
      str_s=str_s.valueOf(ch_s);
      boolean flag=str_s.equals(str_e)? true : false ;
      if(flag==true){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb_s : String ; sb_s := StringLib.newString(input.nextLine()) ;
    var sb1 : String ; sb1 := StringLib.newString(input.nextLine()) ;
    sb_s := sb_s + StringLib.newString(sb1->reverse()) ;     sb_s := sb_s + StringLib.newString(sb1->reverse()) ; 
    var sb_e : String ; sb_e := StringLib.newString(input.nextLine()) ;
    var sb2 : String ; sb2 := StringLib.newString(input.nextLine()) ;
    sb_e := sb_e + StringLib.newString(sb2->reverse()) ;     sb_e := sb_e + StringLib.newString(sb2->reverse()) ; 
    var str_s : String ; str_s := sb_s+"" ;
    var str_e : String ; str_e := sb_e+"" ;
    var ch_s : Sequence(String) ; ch_s := str_s->characters() ;
    var x : int ; x := str_s->indexOf("X")-1 ;
        var j : int ; j := 0 ; while j < 12 do ( (     if (x = 0) then (     ch_s[x+1] := ch_s[3+1] ; 
     ch_s[3+1] := 'X' ; 
     x := 3 ) else (     ch_s[x+1] := ch_s[(x)->char2byte() - 1+1] ; 
     ch_s[(x)->char2byte() - 1+1] := 'X' ; 
     x := x - 1 ) ;  
     str_s := str_s.valueOf(ch_s) ; 
     var flag : boolean ; flag := if str_s = str_e then true else false endif ;
     if (flag = true) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String[] arr=new String[4];
    for(int i=0 ; i<4 ; i++){
      arr[i]=scan.nextLine();
    }
    String ans=check(arr);
    System.out.println(ans);
  }
  public static String check(String[] arr){
    StringBuilder sb1=new StringBuilder();
    appendForward(arr[0] .toCharArray(),sb1);
    appendReverse(arr[1] .toCharArray(),sb1);
    String s1=sb1.append(sb1).toString();
    StringBuilder sb2=new StringBuilder();
    appendForward(arr[2] .toCharArray(),sb2);
    appendReverse(arr[3] .toCharArray(),sb2);
    String s2=sb2.toString();
    return s1.contains(s2)? "YES" : "NO" ;
  }
  public static void appendForward(char[] s,StringBuilder sb){
    if(s[0]!='X'){
      sb.append(s[0]);
    }
    if(s[1]!='X'){
      sb.append(s[1]);
    }
  }
  public static void appendReverse(char[] s,StringBuilder sb){
    if(s[1]!='X'){
      sb.append(s[1]);
    }
    if(s[0]!='X'){
      sb.append(s[0]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(String) ; arr := Integer.subrange(1,4)->collect(null) ;
        var i : int ; i := 0 ; while i < 4 do ( (     arr[i+1] := scan.nextLine() )  ;     i := i + 1 ) ; 
    var ans : String ; ans := check(arr) ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation check( arr : Sequence(String)) : String
  pre: true
  post: true
  activity: (     var sb1 : String ; sb1 := StringLib.newString() ;
     execute appendForward(arr[0+1]->characters(), sb1) ; 
    execute appendReverse(arr[1+1]->characters(), sb1) ; 
    var s1 : String ; s1 := sb1 + StringLib.newString(sb1)+"" ;
    var sb2 : String ; sb2 := StringLib.newString() ;
    execute appendForward(arr[2+1]->characters(), sb2) ; 
    execute appendReverse(arr[3+1]->characters(), sb2) ; 
    var s2 : String ; s2 := sb2+"" ;
    return if s1->includes(s2) then "YES" else "NO" endif 
 );
  static   operation appendForward( s : Sequence(String), sb : String) : void
  pre: true
  post: true
  activity: (     if (s[0+1] /= 'X') then (     sb := sb + StringLib.newString(s[0+1]) ) else skip ; 
     if (s[1+1] /= 'X') then (     sb := sb + StringLib.newString(s[1+1]) ) else skip );
  static   operation appendReverse( s : Sequence(String), sb : String) : void
  pre: true
  post: true
  activity: (     if (s[1+1] /= 'X') then (     sb := sb + StringLib.newString(s[1+1]) ) else skip ; 
     if (s[0+1] /= 'X') then (     sb := sb + StringLib.newString(s[0+1]) ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CowAndFriend {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      int x=in.nextInt();
      int[] arr=new int[n];
      int max=0 ;
      boolean flag=false ;
      for(int i=0 ; i<n ; i++){
        arr[i]=in.nextInt();
        max=Math.max(max,arr[i]);
        if(arr[i]==x)flag=true ;
      }
      System.out.println(flag==true ? 1 : Math.max(2,(x+max-1)/max));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CowAndFriend {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var x : int ; x := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := 0 ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() ; 
     max := Set{max, arr[i+1]}->max() ; 
     if (arr[i+1] = x) then     flag := true ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if flag = true then 1 else Set{2, (x + max - 1) / max}->max() endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String[] arr=new String[4];
    for(int i=0 ; i<4 ; i++){
      arr[i]=scan.nextLine();
    }
    String ans=check(arr[0],arr[1],arr[2],arr[3]);
    System.out.println(ans);
  }
  public static String check(String line1,String line2,String line3,String line4){
    String s1=(line1+line2.charAt(1)+line2.charAt(0)).replace("X","");
    String s2=(line3+line4.charAt(1)+line4.charAt(0)).replace("X","");
    return(s2+s2).contains(s1)? "YES" : "NO" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var arr : Sequence(String) ; arr := Integer.subrange(1,4)->collect(null) ;
        var i : int ; i := 0 ; while i < 4 do ( (     arr[i+1] := scan.nextLine() )  ;     i := i + 1 ) ; 
    var ans : String ; ans := check(arr[0+1], arr[1+1], arr[2+1], arr[3+1]) ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation check( line1 : String, line2 : String, line3 : String, line4 : String) : String
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := (line1 + line2->at(1+1) + line2->at(0+1)).replace("X", "") ;
     var s2 : String ; s2 := (line3 + line4->at(1+1) + line4->at(0+1)).replace("X", "") ;
     return if (s2 + s2)->includes(s1) then "YES" else "NO" endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String line1=scan.nextLine();
    String line2=scan.nextLine();
    String line3=scan.nextLine();
    String line4=scan.nextLine();
    String ans=check2(line1,line2,line3,line4);
    System.out.println(ans);
  }
  public static String check2(String line1,String line2,String line3,String line4){
    String input1=(line1+line2.charAt(1)+line2.charAt(0)).replace("X","");
    String input2=(line3+line4.charAt(1)+line4.charAt(0)).replace("X","");
    return(input2+input2).contains(input1)? "YES" : "NO" ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line1 : String ; line1 := scan.nextLine() ;
    var line2 : String ; line2 := scan.nextLine() ;
    var line3 : String ; line3 := scan.nextLine() ;
    var line4 : String ; line4 := scan.nextLine() ;
    var ans : String ; ans := check2(line1, line2, line3, line4) ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation check2( line1 : String, line2 : String, line3 : String, line4 : String) : String
  pre: true
  post: true
  activity: (     var input1 : String ; input1 := (line1 + line2->at(1+1) + line2->at(0+1)).replace("X", "") ;
     var input2 : String ; input2 := (line3 + line4->at(1+1) + line4->at(0+1)).replace("X", "") ;
     return if (input2 + input2)->includes(input1) then "YES" else "NO" endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    StringBuilder sb_s=new StringBuilder(input.nextLine());
    StringBuilder sb1=new StringBuilder(input.nextLine());
    sb_s=sb_s.append(sb1.reverse());
    StringBuilder sb_e=new StringBuilder(input.nextLine());
    StringBuilder sb2=new StringBuilder(input.nextLine());
    sb_e=sb_e.append(sb2.reverse());
    String str_s=sb_s.toString();
    String str_e=sb_e.toString();
    char ch_s[]=str_s.toCharArray();
    int x=str_s.indexOf("X");
    for(int j=0 ; j<12 ; j++){
      if(x==0){
        ch_s[x]=ch_s[3];
        ch_s[3]='X' ;
        x=3 ;
      }
      else {
        ch_s[x]=ch_s[x-1];
        ch_s[x-1]='X' ;
        x--;
      }
      str_s=str_s.valueOf(ch_s);
      boolean flag=str_s.equals(str_e)? true : false ;
      if(flag==true){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb_s : String ; sb_s := StringLib.newString(input.nextLine()) ;
    var sb1 : String ; sb1 := StringLib.newString(input.nextLine()) ;
    sb_s := sb_s + StringLib.newString(sb1->reverse()) ;     sb_s := sb_s + StringLib.newString(sb1->reverse()) ; 
    var sb_e : String ; sb_e := StringLib.newString(input.nextLine()) ;
    var sb2 : String ; sb2 := StringLib.newString(input.nextLine()) ;
    sb_e := sb_e + StringLib.newString(sb2->reverse()) ;     sb_e := sb_e + StringLib.newString(sb2->reverse()) ; 
    var str_s : String ; str_s := sb_s+"" ;
    var str_e : String ; str_e := sb_e+"" ;
    var ch_s : Sequence(String) ; ch_s := str_s->characters() ;
    var x : int ; x := str_s->indexOf("X")-1 ;
        var j : int ; j := 0 ; while j < 12 do ( (     if (x = 0) then (     ch_s[x+1] := ch_s[3+1] ; 
     ch_s[3+1] := 'X' ; 
     x := 3 ) else (     ch_s[x+1] := ch_s[(x)->char2byte() - 1+1] ; 
     ch_s[(x)->char2byte() - 1+1] := 'X' ; 
     x := x - 1 ) ;  
     str_s := str_s.valueOf(ch_s) ; 
     var flag : boolean ; flag := if str_s = str_e then true else false endif ;
     if (flag = true) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean solve(int n,int k){
    if(n>=(k*(k+1))/2){
      return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    int n=12,k=4 ;
    if(solve(n,k))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( n : int, k : int) : boolean
  pre: true
  post: true
  activity: (     if (n >= (k * (k + 1)) / 2) then (     return true ) else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
    var k : int ; k := 4 ;
     if (solve(n, k)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class B1579 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      int[] A=new int[N];
      for(int n=0 ; n<N ; n++){
        A[n]=in.nextInt();
      }
      List<Shift>list=new ArrayList<>();
      for(int n=0 ; n<N-1 ; n++){
        int min=Integer.MAX_VALUE ;
        int minIdx=-1 ;
        for(int i=n ; i<N ; i++){
          int a=A[i];
          if(a<min){
            min=a ;
            minIdx=i ;
          }
        }
        if(minIdx!=n){
          list.add(new Shift(n+1,minIdx+1,minIdx-n));
          for(int c=0 ; c<minIdx-n ; c++){
            int first=A[n];
            for(int i=n+1 ; i<=minIdx ; i++){
              A[i-1]=A[i];
            }
            A[minIdx]=first ;
          }
        }
      }
      StringBuilder answer=new StringBuilder();
      answer.append(list.size()).append('\n');
      for(Shift shift : list){
        answer.append(shift.L).append(' ').append(shift.R).append(' ').append(shift.D).append('\n');
      }
      System.out.print(answer);
    }
  }
  static class Shift {
    int L ;
    int R ;
    int D ;
    Shift(int L,int R,int D){
      this.L=L ;
      this.R=R ;
      this.D=D ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1579 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var list : Sequence(Shift) ; list := Sequence{} ;
        var n : int ; n := 0 ; while n < N - 1 do ( (     var min : int ; min := 2147483647 ;
     var minIdx : int ; minIdx := -1 ;
         var i : int ; i := n ; while i < N do ( (     var a : int ; a := A[i+1] ;
     if (a < min) then (     min := a ; 
     minIdx := i ) else skip )  ;     i := i + 1 ) ; 
     if (minIdx /= n) then (     list := list->including(Shift.newShift(n + 1, minIdx + 1, minIdx - n)) ; 
         var c : int ; c := 0 ; while c < minIdx - n do ( (     var first : int ; first := A[n+1] ;
         var i : int ; i := n + 1 ; while i <= minIdx do ( (     A[i - 1+1] := A[i+1] )  ;     i := i + 1 ) ; 
     A[minIdx+1] := first )  ;     c := c + 1 ) ) else skip )  ;     n := n + 1 ) ; 
    var answer : String ; answer := StringLib.newString() ;
    answer := answer + StringLib.newString(list->size()) + StringLib.newString('
') ; 
    for (shift : list) do ( (     answer := answer + StringLib.newString(shift.L) + StringLib.newString(' ') + StringLib.newString(shift.R) + StringLib.newString(' ') + StringLib.newString(shift.D) + StringLib.newString('
') )  ) ; 
    OclFile["System.out"].print(answer) ; 
 )  ;     t := t + 1 ) );
  static class Shift {
   attribute L : int;
   attribute R : int;
   attribute D : int;
   static operation newShift( L : int, R : int, D : int) : Shift
  pre: true
  post: true
  activity:
  ( var self : Shift ;
    self := createShift();
    self.initialise(L, R,D);
    return self );
  operation initialise( L : int, R : int, D : int) : void
  pre: true  post: true
  activity: (     self.L := L ; 
     self.R := R ; 
     self.D := D );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  long ll ;
  static void solve(long n){
    if(n==1){
      System.out.println(-1);
    }
    else {
      int num=2 ;
      for(long i=0 ; i<n-1 ; i++){
        num=(num*10)+3 ;
      }
      System.out.println(num);
    }
  }
  public static void main(String[] args){
    long n=4 ;
    solve(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
   attribute ll : long;
  static   operation solve( n : long) : void
  pre: true
  post: true
  activity: (     if (n = 1) then (     OclFile["System.out"].println(-1) ) else (     var num : int ; num := 2 ;
         var i : long ; i := 0 ; while i < n - 1 do ( (     num := (num * 10) + 3 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(num) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 4 ;
     execute solve(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int largestNumber(int n){
    String s="" ;
    int duplicate=n ;
    while(n>0){
      s=(char)(n % 10+48)+s ;
      n/=10 ;
    }
    int index=-1 ;
    for(int i=0 ; i<s.length(); i++){
      if((((int)(s.charAt(i)-'0')% 2)& 1)>0){
        index=i ;
        break ;
      }
    }
    if(index==-1)return duplicate ;
    int num=0 ;
    for(int i=0 ; i<index ; i++)num=num*10+(int)(s.charAt(i)-'0');
    num=num*10+((int)s.charAt(index)-(int)('0')-1);
    for(int i=index+1 ; i<s.length(); i++)num=num*10+8 ;
    return num ;
  }
  public static void main(String[] args){
    int N=24578 ;
    System.out.println(largestNumber(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation largestNumber( n : int) : int
  pre: true
  post: true
  activity: (     var s : String ; s := "" ;
     var duplicate : int ; duplicate := n ;
    while (n > 0) do (     s := (n mod 10 + 48)->oclAsType(String) + s ; 
     n := n/(10) ) ; 
    var index : int ; index := -1 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if ((((s->at(i+1) - ('0')->char2byte())->oclAsType(int) mod 2) & 1) > 0) then (     index := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (index = -1) then     return duplicate else skip ; 
    var num : int ; num := 0 ;
        var i : int ; i := 0 ; while i < index do (     num := num * 10 + (s->at(i+1) - ('0')->char2byte())->oclAsType(int) ;  ;     i := i + 1 ) ; 
    num := num * 10 + (s->at(index+1)->oclAsType(int) - ('0')->oclAsType(int) - 1) ; 
        var i : int ; i := index + 1 ; while i < s->size() do (     num := num * 10 + 8 ;  ;     i := i + 1 ) ; 
    return num 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 24578 ;
     OclFile["System.out"].println(largestNumber(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int largestNumber(int n){
    String s="" ;
    int duplicate=n ;
    while(n>0){
      s=(char)(n % 10+48)+s ;
      n/=10 ;
    }
    int index=-1 ;
    for(int i=0 ; i<s.length(); i++){
      if(((int)(s.charAt(i)-'0')% 2 & 1)==0){
        index=i ;
        break ;
      }
    }
    if(index==-1)return duplicate ;
    int num=0 ;
    for(int i=0 ; i<index ; i++)num=num*10+(int)(s.charAt(i)-'0');
    num=num*10+((int)s.charAt(index)-(int)('0')-1);
    for(int i=index+1 ; i<s.length(); i++)num=num*10+9 ;
    return num ;
  }
  public static void main(String[] args){
    int N=24578 ;
    System.out.println(largestNumber(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation largestNumber( n : int) : int
  pre: true
  post: true
  activity: (     var s : String ; s := "" ;
     var duplicate : int ; duplicate := n ;
    while (n > 0) do (     s := (n mod 10 + 48)->oclAsType(String) + s ; 
     n := n/(10) ) ; 
    var index : int ; index := -1 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if ((MathLib.bitwiseAnd((s->at(i+1) - ('0')->char2byte())->oclAsType(int) mod 2,1)) = 0) then (     index := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (index = -1) then     return duplicate else skip ; 
    var num : int ; num := 0 ;
        var i : int ; i := 0 ; while i < index do (     num := num * 10 + (s->at(i+1) - ('0')->char2byte())->oclAsType(int) ;  ;     i := i + 1 ) ; 
    num := num * 10 + (s->at(index+1)->oclAsType(int) - ('0')->oclAsType(int) - 1) ; 
        var i : int ; i := index + 1 ; while i < s->size() do (     num := num * 10 + 9 ;  ;     i := i + 1 ) ; 
    return num 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 24578 ;
     OclFile["System.out"].println(largestNumber(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int smallestNumber(int n){
    int num=0 ;
    String s="" ;
    int duplicate=n ;
    while(n>0){
      s=(char)(n % 10+48)+s ;
      n/=10 ;
    }
    int index=-1 ;
    for(int i=0 ; i<s.length(); i++){
      int digit=s.charAt(i)-'0' ;
      if((digit & 1)==0){
        index=i ;
        break ;
      }
    }
    if(index==-1){
      return duplicate ;
    }
    for(int i=0 ; i<index ; i++){
      num=num*10+(s.charAt(i)-'0');
    }
    num=num*10+(s.charAt(index)-'0'+1);
    for(int i=index+1 ; i<s.length(); i++){
      num=num*10+1 ;
    }
    return num ;
  }
  static public void main(String[] args){
    int N=2397 ;
    System.out.println(smallestNumber(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation smallestNumber( n : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := 0 ;
     var s : String ; s := "" ;
    var duplicate : int ; duplicate := n ;
    while (n > 0) do (     s := (n mod 10 + 48)->oclAsType(String) + s ; 
     n := n/(10) ) ; 
    var index : int ; index := -1 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var digit : int ; digit := s->at(i+1) - ('0')->char2byte() ;
     if ((MathLib.bitwiseAnd(digit,1)) = 0) then (     index := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (index = -1) then (     return duplicate ) else skip ; 
        var i : int ; i := 0 ; while i < index do ( (     num := num * 10 + (s->at(i+1) - ('0')->char2byte()) )  ;     i := i + 1 ) ; 
    num := num * 10 + (s->at(index+1) - ('0')->char2byte() + 1) ; 
        var i : int ; i := index + 1 ; while i < s->size() do ( (     num := num * 10 + 1 )  ;     i := i + 1 ) ; 
    return num 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 2397 ;
     OclFile["System.out"].println(smallestNumber(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int count(int n){
    int x=(n/3)-1 ;
    if(n % 3>0){
      x++;
    }
    return(4*x+4*n);
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.print(count(n)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation count( n : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := (n / 3) - 1 ;
     if (n mod 3 > 0) then (     x := x + 1 ) else skip ; 
     return (4 * x + 4 * n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].print(count(n) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner in=new Scanner(new File("Main.in"));
    PrintWriter out=new PrintWriter(new File("Main.out"));
    int tests=in.nextInt();
    for(int test=1 ; test<=tests ; test++){
      out.print("Case #"+test+": ");
      int n=in.nextInt();
      int k=in.nextInt();
      int B=in.nextInt();
      int T=in.nextInt();
      int[] x=new int[n];
      int[] v=new int[n];
      for(int i=0 ; i<n ; i++)x[i]=in.nextInt();
      for(int i=0 ; i<n ; i++)v[i]=in.nextInt();
      boolean[] can=new boolean[n];
      int z=0 ;
      for(int i=0 ; i<n ; i++){
        can[i]=x[i]+v[i]*T>=B ;
        if(can[i])z++;
      }
      if(z<k){
        out.println("IMPOSSIBLE");
        continue ;
      }
      int ans=0 ;
      z=0 ;
      for(int i=n-1 ; i>=0 && k>0 ; i--)if(can[i]){
        ans+=z ;
        k--;
      }
      else z++;
      out.println(ans);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("Main.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("Main.out")) ;
    var tests : int ; tests := in.getCurrent()->toInteger() ;
        var test : int ; test := 1 ; while test <= tests do ( (     skip ; 
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var B : int ; B := in.getCurrent()->toInteger() ;
    var T : int ; T := in.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     x[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     v[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var can : Sequence(boolean) ; can := Integer.subrange(1,n)->collect(false) ;
    var z : int ; z := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     can[i+1] := x[i+1] + v[i+1] * T >= B ; 
     if (can[i+1]) then     z := z + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (z < k) then (     skip ; 
     continue ) else skip ; 
    var ans : int ; ans := 0 ;
    z := 0 ; 
        var i : int ; i := n - 1 ; while i >= 0 & k > 0 do (     if (can[i+1]) then (     ans := ans+(z) ; 
     k := k - 1 ) else     z := z + 1 ; ;   ;     i := i - 1 ) ; 
    skip ; 
 )  ;     test := test + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static int n ;
  static long x ;
  static long a[];
  static long solve(){
    long mx=-1 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]==x)return 1 ;
      mx=Math.max(mx,a[i]);
    }
    return Math.max(2,(x+mx-1)/mx);
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    int q=Integer.parseInt(bf.readLine().trim());
    while(q-->0){
      String[] s=bf.readLine().trim().split("\\s+");
      n=Integer.parseInt(s[0]);
      x=Long.parseLong(s[1]);
      a=new long[n];
      s=bf.readLine().trim().split("\\s+");
      for(int i=0 ; i<n ; i++)a[i]=Long.parseLong(s[i]);
      str.append(solve()).append("\n");
    }
    pw.print(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute n : int;
  static   attribute x : long;
  static   attribute a : Sequence(long);
  static   operation solve() : long
  pre: true
  post: true
  activity: (     var mx : long ; mx := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = x) then     return 1 else skip ; 
     mx := Set{mx, a[i+1]}->max() )  ;     i := i + 1 ) ; 
     return Set{2, (x + mx - 1) / mx}->max() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var q : int ; q := (bf.readLine()->trim())->toInteger() ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     var s : Sequence(String) ; s := bf.readLine()->trim()->split("\\s+") ;
     n := (s[0+1])->toInteger() ; 
    x := (s[1+1])->toLong() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
    s := bf.readLine()->trim()->split("\\s+") ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (s[i+1])->toLong() ;  ;     i := i + 1 ) ; 
    str := str + StringLib.newString(solve()) + StringLib.newString("\n") ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class R1B {
  public static void main(String args[])throws Exception {
    Scanner in=new Scanner(new File("B-large.in"));
    PrintStream out=new PrintStream(new File("B-large.out"));
    int cas=in.nextInt();
    for(int iii=0 ; iii<cas ; iii++){
      int N=in.nextInt();
      int K=in.nextInt();
      int B=in.nextInt();
      int T=in.nextInt();
      int pos[]=new int[N];
      int speed[]=new int[N];
      for(int i=0 ; i<N ; i++)pos[i]=B-in.nextInt();
      for(int i=0 ; i<N ; i++)speed[i]=in.nextInt();
      for(int i=0 ; i<N ; i++)pos[i]=((pos[i]-1)/speed[i])+1 ;
      int count=0 ;
      int seen=0 ;
      int done=0 ;
      for(int i=N-1 ; i>=0 ; i--){
        if(pos[i]>T){
          seen++;
        }
        else {
          count+=seen ;
          done++;
          if(done==K)break ;
        }
      }
      out.println("Case #"+(iii+1)+": "+(done>=K ? ""+count : "IMPOSSIBLE"));
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class R1B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("B-large.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("B-large.out")) ;
    var cas : int ; cas := in.getCurrent()->toInteger() ;
        var iii : int ; iii := 0 ; while iii < cas do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var K : int ; K := in.getCurrent()->toInteger() ;
    var B : int ; B := in.getCurrent()->toInteger() ;
    var T : int ; T := in.getCurrent()->toInteger() ;
    var pos : Sequence(int) ; pos := Integer.subrange(1,N)->collect(0) ;
    var speed : Sequence(int) ; speed := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     pos[i+1] := B - in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do (     speed[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do (     pos[i+1] := ((pos[i+1] - 1) / speed[i+1]) + 1 ;  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var seen : int ; seen := 0 ;
    var done : int ; done := 0 ;
        var i : int ; i := N - 1 ; while i >= 0 do ( (     if (pos[i+1] > T) then (     seen := seen + 1 ) else (     count := count+(seen) ; 
     done := done + 1 ; 
     if (done = K) then     break else skip ) )  ;     i := i - 1 ) ; 
    skip ; 
 )  ;     iii := iii + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Solution {
  public void doMain()throws Exception {
    Scanner sc=new Scanner(new FileReader("input.txt"));
    PrintWriter pw=new PrintWriter(new FileWriter("output.txt"));
    int caseCnt=sc.nextInt();
    long time=System.currentTimeMillis();
    for(int caseNum=1 ; caseNum<=caseCnt ; caseNum++){
      pw.print("Case #"+caseNum+": ");
      int N=sc.nextInt(),K=sc.nextInt();
      long B=sc.nextLong(),T=sc.nextInt();
      long[] X=new long[N];
      long[] V=new long[N];
      boolean[] can=new boolean[N];
      for(int i=0 ; i<N ; i++)X[i]=sc.nextLong();
      for(int i=0 ; i<N ; i++){
        V[i]=sc.nextLong();
        can[i]=X[i]+T*V[i]>=B ;
      }
      int good=0 ;
      int swaps=0 ;
      for(int i=N-1 ; i>=0 ; i--)if(can[i] && good<K){
        good++;
        for(int j=i+1 ; j<N ; j++)if(! can[j])swaps++;
      }
      if(good<K)pw.println("IMPOSSIBLE");
      else pw.println(swaps);
      System.out.println("Finished testcase "+caseNum+",time="+(System.currentTimeMillis()-time));
    }
    pw.flush();
    pw.close();
    sc.close();
  }
  public static void main(String[] args)throws Exception {
(new Solution()).doMain();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
   operation doMain() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt"))) ;
    var caseCnt : int ; caseCnt := sc.getCurrent()->toInteger() ;
    var time : long ; time := OclDate.getSystemTime() ;
        var caseNum : int ; caseNum := 1 ; while caseNum <= caseCnt do ( (     skip ; 
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var B : long ; B := sc.getCurrent()->toLong() ;
    var T : long ; T := sc.getCurrent()->toInteger() ;
    var X : Sequence(long) ; X := Integer.subrange(1,N)->collect(0) ;
    var V : Sequence(long) ; V := Integer.subrange(1,N)->collect(0) ;
    var can : Sequence(boolean) ; can := Integer.subrange(1,N)->collect(false) ;
        var i : int ; i := 0 ; while i < N do (     X[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     V[i+1] := sc.getCurrent()->toLong() ; 
     can[i+1] := X[i+1] + T * V[i+1] >= B )  ;     i := i + 1 ) ; 
    var good : int ; good := 0 ;
    var swaps : int ; swaps := 0 ;
        var i : int ; i := N - 1 ; while i >= 0 do (     if (can[i+1] & good < K) then (     good := good + 1 ; 
         var j : int ; j := i + 1 ; while j < N do (     if (not(can[j+1])) then     swaps := swaps + 1 ; else skip ;  ;     j := j + 1 ) ) else skip ;  ;     i := i - 1 ) ; 
    if (good < K) then     skip else     skip ; ;  
    OclFile["System.out"].println("Finished testcase " + caseNum + ",time=" + (OclDate.getSystemTime() - time)) ; 
 )  ;     caseNum := caseNum + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Solution.newSolution()).doMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static boolean isPalindrome(String s){
    for(int i=0 ; i<s.length(); ++i){
      if(s.charAt(i)!=s.charAt(s.length()-i-1)){
        return false ;
      }
    }
    return true ;
  }
  static boolean ans(String s){
    String s2=s ;
    for(int i=0 ; i<s.length(); ++i){
      s2=s2.charAt(s2.length()-1)+s2 ;
      s2=s2.substring(0,s2.length()-1);
      if((s==null ? s2!=null : ! s.equals(s2))&& isPalindrome(s2)){
        return true ;
      }
    }
    return false ;
  }
  static int solve(String s){
    if(s.length()<=3){
      return-1 ;
    }
    int cnt[]=new int[25];
    for(int i=0 ; i<s.length(); i++){
      cnt[s.charAt(i)-'a']++;
    }
    if(Arrays.stream(cnt).max().getAsInt()>=(s.length()-1)){
      return-1 ;
    }
    else {
      return(ans(s)? 1 : 2);
    }
  }
  public static void main(String[] args){
    String s="nolon" ;
    System.out.println(solve(s));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPalindrome( s : String) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) /= s->at(s->size() - i - 1+1)) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation ans( s : String) : boolean
  pre: true
  post: true
  activity: (     var s2 : String ; s2 := s ;
         var i : int ; i := 0 ; while i < s->size() do ( (     s2 := s2->at(s2->size() - 1+1) + s2 ; 
     s2 := s2.subrange(0+1,s2->size() - 1) ; 
     if ((if s = null then s2 /= null else not(s = s2) endif) & isPalindrome(s2)) then (     return true ) else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation solve( s : String) : int
  pre: true
  post: true
  activity: (     if (s->size() <= 3) then (     return -1 ) else skip ; 
     var cnt : Sequence(int) ; cnt := Integer.subrange(1,25)->collect(0) ;
         var i : int ; i := 0 ; while i < s->size() do ( (     cnt[s->at(i+1) - ('a')->char2byte()+1] := cnt[s->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
     if (stream(cnt).max().getAsInt() >= (s->size() - 1)) then (     return -1 ) else (     return (if ans(s) then 1 else 2 endif) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "nolon" ;
     OclFile["System.out"].println(solve(s)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round1 ;
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class B {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner in=new Scanner(new File(B.class.getSimpleName()+".in"));
    PrintWriter out=new PrintWriter(new File(B.class.getSimpleName()+".out"));
    int T=in.nextInt();
    for(int i=0 ; i<T ; i++){
      out.println("Case #"+(i+1)+": "+new B().solve(in));
    }
    out.close();
  }
  private String solve(Scanner in){
    int n=in.nextInt();
    int k=in.nextInt();
    int b=in.nextInt();
    int t=in.nextInt();
    int[] x=new int[n];
    int[] v=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=in.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      v[i]=in.nextInt();
    }
    boolean[] z=new boolean[n];
    for(int i=0 ; i<n ; i++){
      z[i]=x[i]+v[i]*t>=b ;
    }
    int[] q=new int[n];
    int m=0 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(z[i]){
        q[m++]=i ;
      }
    }
    if(m<k)return "IMPOSSIBLE" ;
    int s=0 ;
    for(int i=0 ; i<k ; i++){
      int j=n-i-1 ;
      s+=(j-q[i]);
    }
    return ""+s ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile(OclType["B"].getSimpleName() + ".in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile(OclType["B"].getSimpleName() + ".out")) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < T do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation solve( in : OclFile) : String
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var t : int ; t := in.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     v[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var z : Sequence(boolean) ; z := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     z[i+1] := x[i+1] + v[i+1] * t >= b )  ;     i := i + 1 ) ; 
    var q : Sequence(int) ; q := Integer.subrange(1,n)->collect(0) ;
    var m : int ; m := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (z[i+1]) then (      q[m+1] := i  ; m := m + 1 ) else skip )  ;     i := i - 1 ) ; 
    if (m < k) then     return "IMPOSSIBLE" else skip ; 
    var s : int ; s := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     var j : int ; j := n - i - 1 ;
     s := s+((j - q[i+1])) )  ;     i := i + 1 ) ; 
    return "" + s 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    ArrayList<Integer>[] list=new ArrayList[n+1];
    for(int i=1 ; i<=n ; i++){
      list[i]=new ArrayList<Integer>();
    }
    for(int i=0 ; i<m ; i++){
      int from=sc.nextInt();
      int to=sc.nextInt();
      list[from] .add(to);
    }
    double result=Double.MAX_VALUE ;
    for(int k=0 ; k<=n-1 ; k++){
      double[] dp=new double[n+1];
      for(int i=n-1 ; i>=1 ; i--){
        if(i==k && list[i] .size()<=1){
          dp[i]=0 ;
          continue ;
        }
        int cnt=list[i] .size();
        if(i==k)cnt--;
        double q=(double)1/cnt ;
        double max=0 ;
        for(int to : list[i]){
          if(dp[to]==0 && to!=n){
            dp[i]=0 ;
            break ;
          }
          else {
            dp[i]+=(1+dp[to])*q ;
            max=max(max,dp[to]);
          }
        }
        if(i==k)dp[i]-=(1+max)*q ;
      }
      if(dp[1]!=0)result=min(result,dp[1]);
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var list : Sequence(Sequence(int)) ; list := Integer.subrange(1,n + 1)->collect(null) ;
        var i : int ; i := 1 ; while i <= n do ( (     list[i+1] := Sequence{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var from : int ; from := sc.getCurrent()->toInteger() ;
     var to : int ; to := sc.getCurrent()->toInteger() ;
     list[from+1]->excludes(to) )  ;     i := i + 1 ) ; 
    var result : double ; result := (2 - 2->pow(-52))*(2->pow(1023)) ;
        var k : int ; k := 0 ; while k <= n - 1 do ( (     var dp : Sequence(double) ; dp := Integer.subrange(1,n + 1)->collect(0.0) ;
         var i : int ; i := n - 1 ; while i >= 1 do ( (     if (i = k & list[i+1]->size() <= 1) then (     dp[i+1] := 0 ; 
     continue ) else skip ; 
     var cnt : int ; cnt := list[i+1]->size() ;
    if (i = k) then     cnt := cnt - 1 ; else skip ; 
    var q : double ; q := 1->oclAsType(double) / cnt ;
    var max : double ; max := 0 ;
    for (to : list[i+1]) do ( (     if (dp[to+1] = 0 & to /= n) then (     dp[i+1] := 0 ; 
     break ) else (     dp[i+1] := dp[i+1]+((1 + dp[to+1]) * q) ; 
     max := Set{max, dp[to+1]}->max() ) )  ) ; 
    if (i = k) then     dp[i+1] := dp[i+1]-((1 + max) * q) ; else skip ; 
 )  ;     i := i - 1 ) ; 
     if (dp[1+1] /= 0) then     result := Set{result, dp[1+1]}->min() ; else skip )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    ArrayList<ArrayList<Integer>>graph=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      graph.add(new ArrayList<>());
    }
    for(int i=0 ; i<m ; i++){
      graph.get(sc.nextInt()-1).add(sc.nextInt()-1);
    }
    double[] dp=new double[n];
    for(int i=n-2 ; i>=0 ; i--){
      for(int x : graph.get(i)){
        dp[i]+=(dp[x]+1)/graph.get(i).size();
      }
    }
    double min=dp[0];
    for(int i=0 ; i<n ; i++){
      if(graph.get(i).size()<=1){
        continue ;
      }
      dp[i]=0 ;
      double max=0 ;
      for(int x : graph.get(i)){
        max=Math.max(max,dp[x]+1);
        dp[i]+=dp[x]+1 ;
      }
      dp[i]-=max ;
      dp[i]/=graph.get(i).size()-1 ;
      for(int j=i-1 ; j>=0 ; j--){
        dp[j]=0 ;
        for(int x : graph.get(j)){
          dp[j]+=(dp[x]+1)/graph.get(j).size();
        }
      }
      min=Math.min(min,dp[0]);
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var graph : Sequence(Sequence(int)) ; graph := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     graph := graph->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     graph->at(sc.getCurrent()->toInteger() - 1+1)->excludes(sc.getCurrent()->toInteger() - 1) )  ;     i := i + 1 ) ; 
    var dp : Sequence(double) ; dp := Integer.subrange(1,n)->collect(0.0) ;
        var i : int ; i := n - 2 ; while i >= 0 do ( (     for (x : graph->at(i+1)) do ( (     dp[i+1] := dp[i+1]+((dp[x+1] + 1) / graph->at(i+1)->size()) )  ) )  ;     i := i - 1 ) ; 
    var min : double ; min := dp[0+1] ;
        var i : int ; i := 0 ; while i < n do ( (     if (graph->at(i+1)->size() <= 1) then (     continue ) else skip ; 
     dp[i+1] := 0 ; 
    var max : double ; max := 0 ;
    for (x : graph->at(i+1)) do ( (     max := Set{max, dp[x+1] + 1}->max() ; 
     dp[i+1] := dp[i+1]+(dp[x+1] + 1) )  ) ; 
    dp[i+1] := dp[i+1]-(max) ; 
    dp[i+1] := dp[i+1]/(graph->at(i+1)->size() - 1) ; 
        var j : int ; j := i - 1 ; while j >= 0 do ( (     dp[j+1] := 0 ; 
     for (x : graph->at(j+1)) do ( (     dp[j+1] := dp[j+1]+((dp[x+1] + 1) / graph->at(j+1)->size()) )  ) )  ;     j := j - 1 ) ; 
    min := Set{min, dp[0+1]}->min() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    HashSet<Integer>[] graph=new HashSet[n+1];
    for(int i=1 ; i<=n ; i++){
      graph[i]=new HashSet<Integer>();
    }
    for(int i=0 ; i<m ; i++){
      graph[sc.nextInt()] .add(sc.nextInt());
    }
    double[] dp=new double[n+1];
    for(int i=n-1 ; i>=1 ; i--){
      for(int x : graph[i]){
        dp[i]+=(dp[x]+1)/graph[i] .size();
      }
    }
    double min=dp[1];
    for(int i=1 ; i<n ; i++){
      if(graph[i] .size()<=1){
        continue ;
      }
      double max=0 ;
      dp[i]=0 ;
      for(int x : graph[i]){
        max=Math.max(dp[x]+1,max);
        dp[i]+=dp[x]+1 ;
      }
      dp[i]-=max ;
      dp[i]/=(graph[i] .size()-1);
      for(int j=i-1 ; j>=1 ; j--){
        dp[j]=0 ;
        for(int x : graph[j]){
          dp[j]+=(dp[x]+1)/graph[j] .size();
        }
      }
      min=Math.min(min,dp[1]);
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var graph : Sequence(Set(int)) ; graph := Integer.subrange(1,n + 1)->collect(null) ;
        var i : int ; i := 1 ; while i <= n do ( (     graph[i+1] := Set{} )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     graph[sc.getCurrent()->toInteger()+1]->excludes(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var dp : Sequence(double) ; dp := Integer.subrange(1,n + 1)->collect(0.0) ;
        var i : int ; i := n - 1 ; while i >= 1 do ( (     for (x : graph[i+1]) do ( (     dp[i+1] := dp[i+1]+((dp[x+1] + 1) / graph[i+1]->size()) )  ) )  ;     i := i - 1 ) ; 
    var min : double ; min := dp[1+1] ;
        var i : int ; i := 1 ; while i < n do ( (     if (graph[i+1]->size() <= 1) then (     continue ) else skip ; 
     var max : double ; max := 0 ;
    dp[i+1] := 0 ; 
    for (x : graph[i+1]) do ( (     max := Set{dp[x+1] + 1, max}->max() ; 
     dp[i+1] := dp[i+1]+(dp[x+1] + 1) )  ) ; 
    dp[i+1] := dp[i+1]-(max) ; 
    dp[i+1] := dp[i+1]/((graph[i+1]->size() - 1)) ; 
        var j : int ; j := i - 1 ; while j >= 1 do ( (     dp[j+1] := 0 ; 
     for (x : graph[j+1]) do ( (     dp[j+1] := dp[j+1]+((dp[x+1] + 1) / graph[j+1]->size()) )  ) )  ;     j := j - 1 ) ; 
    min := Set{min, dp[1+1]}->min() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    ArrayList<ArrayList<Integer>>passages=new ArrayList<ArrayList<Integer>>();
    for(int i=0 ; i<N-1 ; i++){
      passages.add(new ArrayList<Integer>());
    }
    for(int i=0 ; i<M ; i++){
      int s=sc.nextInt();
      int t=sc.nextInt();
      passages.get(s-1).add(t-1);
    }
    double[] E=new double[N];
    for(int i=N-2 ; i>=0 ; i--){
      double sum=0 ;
      for(int dest : passages.get(i)){
        sum+=E[dest];
      }
      E[i]=sum/passages.get(i).size()+1 ;
    }
    double minE=E[0];
    for(int i=0 ; i<N-1 ; i++){
      int len=passages.get(i).size();
      if(len==1){
        continue ;
      }
      double maxE=0 ;
      for(int dest : passages.get(i)){
        maxE=Math.max(maxE,E[dest]);
      }
      E[i]=((E[i]-1)*len-maxE)/(len-1)+1 ;
      if(i>0){
        for(int j=i-1 ; j>=0 ; j--){
          double sum=0 ;
          for(int dest : passages.get(j)){
            sum+=E[dest];
          }
          E[j]=sum/passages.get(j).size()+1 ;
        }
      }
      minE=Math.min(minE,E[0]);
    }
    System.out.println(minE);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var passages : Sequence(Sequence(int)) ; passages := Sequence{} ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     passages := passages->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     passages->at(s - 1+1)->excludes(t - 1) )  ;     i := i + 1 ) ; 
    var E : Sequence(double) ; E := Integer.subrange(1,N)->collect(0.0) ;
        var i : int ; i := N - 2 ; while i >= 0 do ( (     var sum : double ; sum := 0 ;
     for (dest : passages->at(i+1)) do ( (     sum := sum+(E[dest+1]) )  ) ; 
     E[i+1] := sum / passages->at(i+1)->size() + 1 )  ;     i := i - 1 ) ; 
    var minE : double ; minE := E[0+1] ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     var len : int ; len := passages->at(i+1)->size() ;
     if (len = 1) then (     continue ) else skip ; 
    var maxE : double ; maxE := 0 ;
    for (dest : passages->at(i+1)) do ( (     maxE := Set{maxE, E[dest+1]}->max() )  ) ; 
    E[i+1] := ((E[i+1] - 1) * len - maxE) / (len - 1) + 1 ; 
    if (i > 0) then (         var j : int ; j := i - 1 ; while j >= 0 do ( (     var sum : double ; sum := 0 ;
     for (dest : passages->at(j+1)) do ( (     sum := sum+(E[dest+1]) )  ) ; 
     E[j+1] := sum / passages->at(j+1)->size() + 1 )  ;     j := j - 1 ) ) else skip ; 
    minE := Set{minE, E[0+1]}->min() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(minE) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int longestPrefixSuffix(String s){
    int n=s.length();
    if(n<2){
      return 0 ;
    }
    int len=0 ;
    int i=n/2 ;
    while(i<n){
      if(s.charAt(i)==s.charAt(len)){
++len ;
++i ;
      }
      else {
        if(len==0){
++i ;
        }
        else {
--len ;
        }
      }
    }
    return len ;
  }
  public static void main(String[] args){
    String s="blablabla" ;
    System.out.println(longestPrefixSuffix(s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation longestPrefixSuffix( s : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     if (n < 2) then (     return 0 ) else skip ; 
    var len : int ; len := 0 ;
    var i : int ; i := n / 2 ;
    while (i < n) do (     if (s->at(i+1) = s->at(len+1)) then (     len := len + 1 ; 
     i := i + 1 ) else (     if (len = 0) then (     i := i + 1 ) else (     len := len - 1 ) ) ) ; 
    return len 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "blablabla" ;
     OclFile["System.out"].println(longestPrefixSuffix(s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Pair {
  final int id ;
  final double BMI ;
  public Pair(double weight,double height,int id){
    this.id=id ;
    BMI=weight/(height*height)*10000.0 ;
  }
}
class Main {
  public static void main(String[] args){
    final Scanner stdin=new Scanner(System.in);
    while(true){
      final int n=stdin.nextInt();
      if(n==0){
        break ;
      }
      Pair maxPair=new Pair(1000000,1,-1);
      for(int i=0 ; i<n ; i++){
        final int id=stdin.nextInt();
        final int height=stdin.nextInt();
        final int weight=stdin.nextInt();
        final Pair p=new Pair(weight,height,id);
        if(Math.abs(maxPair.BMI-22.0)>Math.abs(p.BMI-22.0)){
          maxPair=p ;
        }
      }
      System.out.println(maxPair.id);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Pair {
   attribute id : int;
   attribute BMI : double;
   static operation newPair( weight : double, height : double, id : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(weight, height,id);
    return self );
  operation initialise( weight : double, height : double, id : int) : void
  pre: true  post: true
  activity: (     self.id := id ; 
     BMI := weight / (height * height) * 10000.0 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := stdin.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var maxPair : Map ; maxPair := Map(1000000, 1, -1) ;
        var i : int ; i := 0 ; while i < n do ( (     var id : int ; id := stdin.getCurrent()->toInteger() ;
     var height : int ; height := stdin.getCurrent()->toInteger() ;
    var weight : int ; weight := stdin.getCurrent()->toInteger() ;
    var p : Map ; p := Map(weight, height, id) ;
    if (if maxPair.BMI - 22.0 < 0 then -(maxPair.BMI - 22.0) else maxPair.BMI - 22.0 endif > if p.BMI - 22.0 < 0 then -(p.BMI - 22.0) else p.BMI - 22.0 endif) then (     maxPair := p ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(maxPair.id) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class B_Cow_and_Friend {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int x=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; ++i){
        a[i]=sc.nextInt();
      }
      System.out.println(solve(a,x));
    }
    sc.close();
  }
  static int solve(int[] a,int x){
    if(Arrays.stream(a).anyMatch(ai->ai==x)){
      return 1 ;
    }
    return Math.max(2,divideToCeil(x,Arrays.stream(a).max().getAsInt()));
  }
  static int divideToCeil(int p,int q){
    return p/q+(p % q==0 ? 0 : 1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Cow_and_Friend {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(a, x)) ; 
 )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : Sequence(int), x : int) : int
  pre: true
  post: true
  activity: (     if (stream(a)->exists( _x2 | (lambda ai : OclAny in ai = x)->apply(_x2) )) then (     return 1 ) else skip ; 
     return Set{2, divideToCeil(x, stream(a).max().getAsInt())}->max() );
  static   operation divideToCeil( p : int, q : int) : int
  pre: true
  post: true
  activity: (     return p / q + (if p mod q = 0 then 0 else 1 endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  final double EPS=1e-7 ;
  class Pair {
    public int first ;
    public double second ;
    public Pair(int a,double b){
      first=a ;
      second=b ;
    }
    public String toString(){
      return first+" "+second ;
    }
  }
  class PairComparator implements Comparator<Pair>{
    private boolean first ;
    PairComparator(boolean first){
      this.first=first ;
    }
    @ Override public int compare(Pair o1,Pair o2){
      if(first){
        return o1.first-o2.first ;
      }
      else {
        double d1=o1.second,d2=o2.second ;
        if(Math.abs(d1-d2)<EPS)return 0 ;
        else if(d1<d2)return-1 ;
        else return 1 ;
      }
    }
  }
  int ni(){
    return sc.nextInt();
  }
  double BMI(int h,int w){
    return((double)w)/h/h*10000 ;
  }
  void io(){
    sc=new Scanner(System.in);
    int n ;
    while((n=ni())!=0){
      Pair[] person=new Pair[n];
      for(int i=0 ; i<n ; ++i){
        person[i]=new Pair(ni(),Math.abs(BMI(ni(),ni())-22.0));
      }
      Arrays.sort(person,new PairComparator(true));
      Arrays.sort(person,new PairComparator(false));
      System.out.println(person[0] .first);
    }
  }
  public static void main(String[] args){
    new Main().io();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute EPS : double := 1e-7;
 class Pair {
   attribute first : int;
   attribute second : double;
   static operation newPair( a : int, b : double) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : double) : void
  pre: true  post: true
  activity: (     first := a ; 
     second := b );
   operation toString() : String
  pre: true
  post: true
  activity: (     return first + " " + second );
}
 class PairComparator implements Function(<Map>,(<Map>,boolean)) {
   attribute first : boolean;
   static operation newPairComparator( first : boolean) : PairComparator
  pre: true
  post: true
  activity:
  ( var self : PairComparator ;
    self := createPairComparator();
    self.initialise(first);
    return self );
  operation initialise( first : boolean) : void
  pre: true  post: true
  activity: (     self->at("first") := first );
      operation compare( o1 : Map, o2 : Map) : int
  pre: true
  post: true
  activity: (     if (first) then (     return o1->at("first") - o2->at("first") ) else (     var d1 : double ; d1 := o1->at("second") ;
    var d2 : double ; d2 := o2->at("second") ;
     if (if d1 - d2 < 0 then -(d1 - d2) else d1 - d2 endif < EPS) then     return 0 else     if (d1 < d2) then     return -1 else     return 1 ;  ) );
}
   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
   operation BMI( h : int, w : int) : double
  pre: true
  post: true
  activity: (     return (w->oclAsType(double)) / h / h * 10000 );
   operation io() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ;
         n := ni() ;
    while ((n) /= 0) do (    skip ; (     var person : Sequence(Map) ; person := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do ( (     person[i+1] := Map(ni(), if BMI(ni(), ni()) - 22.0 < 0 then -(BMI(ni(), ni()) - 22.0) else BMI(ni(), ni()) - 22.0 endif) )  ;     i := i + 1 ) ; 
    person := OclComparator.sortWith(person, PairComparator.newPairComparator(true)) ; 
    person := OclComparator.sortWith(person, PairComparator.newPairComparator(false)) ; 
    OclFile["System.out"].println(person[0+1]->at("first")) ; 
 ) ;     n := ni() ;
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().io() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int count_numbers(int k,int n){
    int[][] dp=new int[n+1][2];
    dp[1][0]=0 ;
    dp[1][1]=k-1 ;
    for(int i=2 ; i<=n ; i++){
      dp[i][0]=dp[i-1][1];
      dp[i][1]=(dp[i-1][0]+dp[i-1][1])*(k-1);
    }
    return dp[n][0]+dp[n][1];
  }
  public static void main(String[] args){
    int k=10 ;
    int n=3 ;
    System.out.println(count_numbers(k,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation count_numbers( k : int, n : int) : int
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,2)->collect(0)) ;
     dp[1+1][0+1] := 0 ; 
    dp[1+1][1+1] := k - 1 ; 
        var i : int ; i := 2 ; while i <= n do ( (     dp[i+1][0+1] := dp[i - 1+1][1+1] ; 
     dp[i+1][1+1] := (dp[i - 1+1][0+1] + dp[i - 1+1][1+1]) * (k - 1) )  ;     i := i + 1 ) ; 
    return dp[n+1][0+1] + dp[n+1][1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := 10 ;
     var n : int ; n := 3 ;
     OclFile["System.out"].println(count_numbers(k, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[]){
    try {
      new Main();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  public Main()throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=in.readLine())!=null){
      int size=Integer.parseInt(line);
      if(size==0)break ;
      Body[] data=new Body[size];
      for(int n=0 ; n<size ; n++){
        line=in.readLine();
        String[] tmp=line.split(" ");
        int id=Integer.parseInt(tmp[0]);
        int h=Integer.parseInt(tmp[1]);
        int w=Integer.parseInt(tmp[2]);
        data[n]=new Body(id,h,w);
      }
      int idx=0 ;
      double min=Math.abs(data[0] .bmi-22.0);
      for(int n=1 ; n<size ; n++){
        double delta=Math.abs(data[n] .bmi-22.0);
        if(delta<min){
          idx=n ;
          min=delta ;
        }
        else if(delta==min){
          if(data[idx] .id>data[n] .id){
            idx=n ;
          }
        }
      }
      System.out.println(data[idx] .id);
    }
  }
}
class Body {
  int id ;
  double bmi ;
  public Body(int id,int height,int weight){
    this.id=id ;
    this.bmi=(double)weight/(height*height/10000.0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( Main.newMain() )   catch (e : IOException) do (     e.printStackTrace() )
 );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := in.readLine() ;
    while ((line) /= null) do (    skip ; (     var size : int ; size := (line)->toInteger() ;
     if (size = 0) then     break else skip ; 
    var data : Sequence(Body) ; data := Integer.subrange(1,size)->collect(null) ;
        var n : int ; n := 0 ; while n < size do ( (     line := in.readLine() ; 
     var tmp : Sequence(String) ; tmp := line->split(" ") ;
    var id : int ; id := (tmp[0+1])->toInteger() ;
    var h : int ; h := (tmp[1+1])->toInteger() ;
    var w : int ; w := (tmp[2+1])->toInteger() ;
    data[n+1] := Body.newBody(id, h, w) ; 
 )  ;     n := n + 1 ) ; 
    var idx : int ; idx := 0 ;
    var min : double ; min := if data[0+1].bmi - 22.0 < 0 then -(data[0+1].bmi - 22.0) else data[0+1].bmi - 22.0 endif ;
        var n : int ; n := 1 ; while n < size do ( (     var delta : double ; delta := if data[n+1].bmi - 22.0 < 0 then -(data[n+1].bmi - 22.0) else data[n+1].bmi - 22.0 endif ;
     if (delta < min) then (     idx := n ; 
     min := delta ) else     if (delta = min) then (     if (data[idx+1].id > data[n+1].id) then (     idx := n ) else skip ) else skip ; )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(data[idx+1].id) ; 
 ) ;     line := in.readLine() ;
 ) );
}
class Body {
   attribute id : int;
   attribute bmi : double;
   static operation newBody( id : int, height : int, weight : int) : Body
  pre: true
  post: true
  activity:
  ( var self : Body ;
    self := createBody();
    self.initialise(id, height,weight);
    return self );
  operation initialise( id : int, height : int, weight : int) : void
  pre: true  post: true
  activity: (     self.id := id ; 
     self.bmi := weight->oclAsType(double) / (height * height / 10000.0) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  int n ;
  R[] rs ;
  void run(){
    for(; ; ){
      n=sc.nextInt();
      if(n==0){
        break ;
      }
      rs=new R[n];
      for(int i=0 ; i<n ; i++){
        int id=sc.nextInt();
        int h=sc.nextInt();
        int w=sc.nextInt();
        rs[i]=new R(id,h,w);
      }
      solve();
    }
  }
  void solve(){
    Arrays.sort(rs);
    println(""+rs[0] .id);
  }
  class R implements Comparable<R>{
    int id ;
    double error ;
    R(int id,int h,int w){
      this.id=id ;
      error=Math.abs(22-10000.*w/h/h);
    }
    @ Override public int compareTo(R r){
      if(error+EPS<r.error){
        return-1 ;
      }
      else if(error>r.error+EPS){
        return 1 ;
      }
      else {
        return id-r.id ;
      }
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   attribute n : int;
   attribute rs : Sequence(R);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then (     break ) else skip ; 
    rs := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do ( (     var id : int ; id := sc.getCurrent()->toInteger() ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
     rs[i+1] := R.newR(id, h, w) )  ;     i := i + 1 ) ; 
    execute solve() ; 
 )  ) );
   operation solve() : void
  pre: true
  post: true
  activity: (     rs := rs->sort() ; 
     execute println("" + rs[0+1].id) );
 class R implements Comparable<R> {
   attribute id : int;
   attribute error : double;
   static operation newR( id : int, h : int, w : int) : R
  pre: true
  post: true
  activity:
  ( var self : R ;
    self := createR();
    self.initialise(id, h,w);
    return self );
  operation initialise( id : int, h : int, w : int) : void
  pre: true  post: true
  activity: (     self.id := id ; 
     error := if 22 - 10000. * w / h / h < 0 then -(22 - 10000. * w / h / h) else 22 - 10000. * w / h / h endif );
      operation compareTo( r : R) : int
  pre: true
  post: true
  activity: (     if (error + EPS < r.error) then (     return -1 ) else     if (error > r.error + EPS) then (     return 1 ) else (     return id - r.id ) ;  );
}
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void cumm(int[] x,int[] y,int[] cummx,int[] cummy,int[] cummx2,int[] cummy2,int n){
    for(int i=1 ; i<=n ; i++){
      cummx[i]=cummx[i-1]+x[i];
      cummy[i]=cummy[i-1]+y[i];
      cummx2[i]=cummx2[i-1]+x[i]*x[i];
      cummy2[i]=cummy2[i-1]+y[i]*y[i];
    }
  }
  static int calHammeredDistance(int n,int[] x,int[] y){
    int[] cummx=new int[n+1];
    int[] cummy=new int[n+1];
    int[] cummx2=new int[n+1];
    int[] cummy2=new int[n+1];
    cumm(x,y,cummx,cummy,cummx2,cummy2,n);
    int hdx=0,hdy=0 ;
    for(int i=1 ; i<=n ; i++){
      hdx+=(i-1)*x[i]*x[i]+cummx2[i-1]-2*x[i]*cummx[i-1];
      hdy+=(i-1)*y[i]*y[i]+cummy2[i-1]-2*y[i]*cummy[i-1];
    }
    int total=hdx+hdy ;
    return total ;
  }
  public static void main(String[] args){
    int n=3 ;
    int[] x=new int[n+1];
    int[] y=new int[n+1];
    x[2]=1 ;
    y[0]=1 ;
    System.out.print(calHammeredDistance(n,x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation cumm( x : Sequence(int), y : Sequence(int), cummx : Sequence(int), cummy : Sequence(int), cummx2 : Sequence(int), cummy2 : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= n do ( (     cummx[i+1] := cummx[i - 1+1] + x[i+1] ; 
     cummy[i+1] := cummy[i - 1+1] + y[i+1] ; 
     cummx2[i+1] := cummx2[i - 1+1] + x[i+1] * x[i+1] ; 
     cummy2[i+1] := cummy2[i - 1+1] + y[i+1] * y[i+1] )  ;     i := i + 1 ) );
  static   operation calHammeredDistance( n : int, x : Sequence(int), y : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var cummx : Sequence(int) ; cummx := Integer.subrange(1,n + 1)->collect(0) ;
     var cummy : Sequence(int) ; cummy := Integer.subrange(1,n + 1)->collect(0) ;
    var cummx2 : Sequence(int) ; cummx2 := Integer.subrange(1,n + 1)->collect(0) ;
    var cummy2 : Sequence(int) ; cummy2 := Integer.subrange(1,n + 1)->collect(0) ;
    execute cumm(x, y, cummx, cummy, cummx2, cummy2, n) ; 
    var hdx : int ; hdx := 0 ;
    var hdy : int ; hdy := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     hdx := hdx+((i - 1) * x[i+1] * x[i+1] + cummx2[i - 1+1] - 2 * x[i+1] * cummx[i - 1+1]) ; 
     hdy := hdy+((i - 1) * y[i+1] * y[i+1] + cummy2[i - 1+1] - 2 * y[i+1] * cummy[i - 1+1]) )  ;     i := i + 1 ) ; 
    var total : int ; total := hdx + hdy ;
    return total 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     var x : Sequence(int) ; x := Integer.subrange(1,n + 1)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n + 1)->collect(0) ;
    x[2+1] := 1 ; 
    y[0+1] := 1 ; 
    OclFile["System.out"].print(calHammeredDistance(n, x, y)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  static boolean isPossible(int[] arr,int n,int p){
    int gcd=0 ;
    for(int i=0 ; i<n ; i++)gcd=__gcd(gcd,arr[i]);
    if(p % gcd==0)return true ;
    return false ;
  }
  public static void main(String[] args){
    int arr[]={
      6,9 };
      int n=arr.length ;
      int p=3 ;
      if(isPossible(arr,n,p))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation isPossible( arr : Sequence(int), n : int, p : int) : boolean
  pre: true
  post: true
  activity: (     var gcd : int ; gcd := 0 ;
         var i : int ; i := 0 ; while i < n do (     gcd := __gcd(gcd, arr[i+1]) ;  ;     i := i + 1 ) ; 
     if (p mod gcd = 0) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,9} ;
     var n : int ; n := arr->size() ;
     var p : int ; p := 3 ;
     if (isPossible(arr, n, p)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.NoSuchElementException ;
import java.util.Scanner ;
public class Main {
  private static final int MAX_NUM=100 ;
  private static int[] numInput=new int[MAX_NUM];
  private static ArrayList<Integer>result=new ArrayList<Integer>(1);
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    try {
      while(true){
        checkInput(sc.nextInt());
      }
    }
    catch(NoSuchElementException e){
    }
    addNumMostInput();
    for(int i=0 ; i<result.size(); i++){
      System.out.println(result.get(i));
    }
  }
  private static void checkInput(int input){
    numInput[input-1]++;
  }
  private static void addNumMostInput(){
    int maxTimesInput=getMaxTimesInput();
    for(int i=0 ; i<MAX_NUM ; i++){
      if(numInput[i]==maxTimesInput){
        result.add(i+1);
      }
    }
  }
  private static int getMaxTimesInput(){
    int count=0 ;
    for(int i=0 ; i<MAX_NUM ; i++){
      if(count<numInput[i]){
        count=numInput[i];
      }
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX_NUM : int := 100;
  static   attribute numInput : Sequence(int) := Integer.subrange(1,MAX_NUM)->collect(0);
  static   attribute result : Sequence(int) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     try (     while (true) do (     execute checkInput(sc.getCurrent()->toInteger()) ) )   catch (e : IncorrectElementException) do skip
     execute addNumMostInput() ; 
         var i : int ; i := 0 ; while i < result->size() do ( (     OclFile["System.out"].println(result->at(i+1)) )  ;     i := i + 1 ) );
  static   operation checkInput( input : int) : void
  pre: true
  post: true
  activity: (     numInput[input - 1+1] := numInput[input - 1+1] + 1 );
  static   operation addNumMostInput() : void
  pre: true
  post: true
  activity: (     var maxTimesInput : int ; maxTimesInput := getMaxTimesInput() ;
         var i : int ; i := 0 ; while i < MAX_NUM do ( (     if (numInput[i+1] = maxTimesInput) then (     result := result->including(i + 1) ) else skip )  ;     i := i + 1 ) );
  static   operation getMaxTimesInput() : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < MAX_NUM do ( (     if (count < numInput[i+1]) then (     count := numInput[i+1] ) else skip )  ;     i := i + 1 ) ; 
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintStream ;
class Main {
  public static void main(String[] args)throws IOException {
    doit(args,System.in,System.out);
  }
  static void doit(String[] args,InputStream in,PrintStream out)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(in));
    int[] counts=new int[101];
    int max=0 ;
    while(true){
      String line=reader.readLine();
      if(line==null || line.isEmpty()){
        break ;
      }
      int n=Integer.parseInt(line);
      max=Math.max(++counts[n],max);
    }
    for(int i=1 ; i<=100 ; i++){
      if(counts[i]==max){
        out.println(i);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doit(args, OclFile["System.in"], OclFile["System.out"]) );
  static   operation doit( args : Sequence(String), in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ;
     var counts : Sequence(int) ; counts := Integer.subrange(1,101)->collect(0) ;
    var max : int ; max := 0 ;
    while (true) do (     var line : String ; line := reader.readLine() ;
     if (line = null or line->isEmpty()) then (     break ) else skip ; 
     var n : int ; n := (line)->toInteger() ;
     max := Set{(counts[n+1] + 1), max}->max() ) ; 
        var i : int ; i := 1 ; while i <= 100 do ( (     if (counts[i+1] = max) then (     out.println(i) ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int cnt(int[] a,int x){
    int cnt=0 ;
    for(int i=0 ; i<a.length ; i++)if(a[i]==x)cnt++;
    return cnt ;
  }
  static int max(int[] a){
    int m=a[0];
    for(int i : a)if(m<i)m=i ;
    return m ;
  }
  static int[] Idx(int[] a,int c,int m){
    int[] idx=new int[c];
    int j=0 ;
    for(int i=0 ; i<100 ; i++)if(a[i]==m)idx[j++]=i ;
    return idx ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] data=new int[100];
    int[] jd=new int[100];
    for(int i=0 ; sc.hasNext(); i++){
      data[i]=sc.nextInt();
    }
    for(int i=0 ; i<100 ; i++){
      jd[i]=cnt(data,i+1);
    }
    for(int i : Idx(jd,cnt(jd,max(jd)),max(jd)))System.out.println(i+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation cnt( a : Sequence(int), x : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < a->size() do (     if (a[i+1] = x) then     cnt := cnt + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return cnt );
  static   operation max( a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var m : int ; m := a[0+1] ;
     for (i : a) do (     if (m < i) then     m := i ; else skip ;  ) ; 
     return m );
  static   operation Idx( a : Sequence(int), c : int, m : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var idx : Sequence(int) ; idx := Integer.subrange(1,c)->collect(0) ;
     var j : int ; j := 0 ;
         var i : int ; i := 0 ; while i < 100 do (     if (a[i+1] = m) then      idx[j+1] := i  ; j := j + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return idx );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var data : Sequence(int) ; data := Integer.subrange(1,100)->collect(0) ;
    var jd : Sequence(int) ; jd := Integer.subrange(1,100)->collect(0) ;
        var i : int ; i := 0 ; while sc.hasNext() do ( (     data[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 100 do ( (     jd[i+1] := cnt(data, i + 1) )  ;     i := i + 1 ) ; 
    for (i : Idx(jd, cnt(jd, Set{jd}->max()), Set{jd}->max())) do (     OclFile["System.out"].println(i + 1) ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static final Scanner scan=new Scanner(System.in);
  public static void main(String[] args){
    int[] counts=new int[100];
    int max=0 ;
    while(scan.hasNext()){
      int a=scan.nextInt();
      counts[a-1]++;
      if(max<counts[a-1]){
        max=counts[a-1];
      }
    }
    for(int i=0 ; i<100 ; i++){
      if(max==counts[i]){
        System.out.printf("%d\n",i+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var counts : Sequence(int) ; counts := Integer.subrange(1,100)->collect(0) ;
     var max : int ; max := 0 ;
     while (scan.hasNext()) do (     var a : int ; a := scan.getCurrent()->toInteger() ;
     counts[a - 1+1] := counts[a - 1+1] + 1 ; 
     if (max < counts[a - 1+1]) then (     max := counts[a - 1+1] ) else skip ) ; 
         var i : int ; i := 0 ; while i < 100 do ( (     if (max = counts[i+1]) then (     OclFile["System.out"].printf("%d\n", i + 1) ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class SmallestSubArraySum {
  static int smallestSubWithSum(int arr[],int n,int x){
    int min_len=n+1 ;
    for(int start=0 ; start<n ; start++){
      int curr_sum=arr[start];
      if(curr_sum>x)return 1 ;
      for(int end=start+1 ; end<n ; end++){
        curr_sum+=arr[end];
        if(curr_sum>x &&(end-start+1)<min_len)min_len=(end-start+1);
      }
    }
    return min_len ;
  }
  public static void main(String[] args){
    int arr1[]={
      1,4,45,6,10,19 };
      int x=51 ;
      int n1=arr1.length ;
      int res1=smallestSubWithSum(arr1,n1,x);
      if(res1==n1+1)System.out.println("Not Possible");
      else System.out.println(res1);
      int arr2[]={
        1,10,5,2,7 };
        int n2=arr2.length ;
        x=9 ;
        int res2=smallestSubWithSum(arr2,n2,x);
        if(res2==n2+1)System.out.println("Not Possible");
        else System.out.println(res2);
        int arr3[]={
          1,11,100,1,0,200,3,2,1,250 };
          int n3=arr3.length ;
          x=280 ;
          int res3=smallestSubWithSum(arr3,n3,x);
          if(res3==n3+1)System.out.println("Not Possible");
          else System.out.println(res3);
        }
      }

------------------------------------------------------------
OCL File:
---------
class SmallestSubArraySum {
  static   operation smallestSubWithSum( arr : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var min_len : int ; min_len := n + 1 ;
         var start : int ; start := 0 ; while start < n do ( (     var curr_sum : int ; curr_sum := arr[start+1] ;
     if (curr_sum > x) then     return 1 else skip ; 
         var end : int ; end := start + 1 ; while end < n do ( (     curr_sum := curr_sum+(arr[end+1]) ; 
     if (curr_sum > x & (end - start + 1) < min_len) then     min_len := (end - start + 1) ; else skip )  ;     end := end + 1 ) )  ;     start := start + 1 ) ; 
     return min_len );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{1,4,45,6,10,19} ;
     var x : int ; x := 51 ;
    var n1 : int ; n1 := arr1->size() ;
    var res1 : int ; res1 := smallestSubWithSum(arr1, n1, x) ;
    if (res1 = n1 + 1) then     OclFile["System.out"].println("Not Possible") else     OclFile["System.out"].println(res1) ; ;  
    var arr2 : Sequence(int) ; arr2 := Sequence{1,10,5,2,7} ;
    var n2 : int ; n2 := arr2->size() ;
    x := 9 ; 
    var res2 : int ; res2 := smallestSubWithSum(arr2, n2, x) ;
    if (res2 = n2 + 1) then     OclFile["System.out"].println("Not Possible") else     OclFile["System.out"].println(res2) ; ;  
    var arr3 : Sequence(int) ; arr3 := Sequence{1,11,100,1,0,200,3,2,1,250} ;
    var n3 : int ; n3 := arr3->size() ;
    x := 280 ; 
    var res3 : int ; res3 := smallestSubWithSum(arr3, n3, x) ;
    if (res3 = n3 + 1) then     OclFile["System.out"].println("Not Possible") else     OclFile["System.out"].println(res3) ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Map ;
import java.util.TreeMap ;
import java.util.Scanner ;
import static java.lang.Math.*;
public class Main {
  static Scanner scan=new Scanner(System.in);
  static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    TreeMap<Integer,Integer>map=new TreeMap<Integer,Integer>();
    int max=0 ;
    while(scan.hasNext()){
      int a=si();
      if(! map.containsKey(a)){
        map.put(a,1);
        max=max(max,1);
      }
      else {
        int tmp=map.get(a)+1 ;
        map.put(a,tmp);
        max=max(max,tmp);
      }
    }
    for(Map.Entry<Integer,Integer>e : map.entrySet())if(e.getValue()==max)out.println(e.getKey());
    out.flush();
  }
  static int si(){
    return Integer.parseInt(scan.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var map : Map(int,int) ; map := Map{} ;
     var max : int ; max := 0 ;
    while (scan.hasNext()) do (     var a : int ; a := si() ;
     if (not(map->keys()->includes(a))) then (     map := map->union(Map{a |-> 1}) ; 
     max := Set{max, 1}->max() ) else (     var tmp : int ; tmp := map->at(a) + 1 ;
     map := map->union(Map{a |-> tmp}) ; 
     max := Set{max, tmp}->max() ) ) ; 
    for (e : map->asSet()) do (     if (e.getValue() = max) then     skip ; else skip ;  ) ; 
    skip ; 
 );
  static   operation si() : int
  pre: true
  post: true
  activity: (     return (scan.getCurrent())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int count=scan.nextInt();
    printIsland(n,count);
  }
  public static void printIsland(int n,int count){
    int a=(n+1)/2 ;
    int b=n/2 ;
    int max=a*a+b*b ;
    if(count>max){
      System.out.println("NO");
      return ;
    }
    System.out.println("YES");
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if((i+j)% 2==0 && count>0){
          sb.append('L');
          count--;
        }
        else {
          sb.append('S');
        }
      }
      sb.append("\n");
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
     var count : int ; count := scan.getCurrent()->toInteger() ;
     execute printIsland(n, count) );
  static   operation printIsland( n : int, count : int) : void
  pre: true
  post: true
  activity: (     var a : int ; a := (n + 1) / 2 ;
     var b : int ; b := n / 2 ;
    var max : int ; max := a * a + b * b ;
    if (count > max) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    OclFile["System.out"].println("YES") ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if ((i + j) mod 2 = 0 & count > 0) then (     sb := sb + StringLib.newString('L') ; 
     count := count - 1 ) else (     sb := sb + StringLib.newString('S') ) )  ;     j := j + 1 ) ; 
     sb := sb + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GfG {
  static int minCost(int n,int arr[],int cost){
    int sum=0,totalCost=0 ;
    for(int i=0 ; i<n-1 ; i++)sum+=arr[i];
    totalCost+=cost*sum ;
    arr[n-1]+=sum ;
    totalCost+=(2*cost*arr[n-1]);
    return totalCost ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,4,5 };
      int n=arr.length ;
      int cost=1 ;
      System.out.println(minCost(n,arr,cost));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation minCost( n : int, arr : Sequence(int), cost : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
    var totalCost : int ; totalCost := 0 ;
         var i : int ; i := 0 ; while i < n - 1 do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    totalCost := totalCost+(cost * sum) ; 
    arr[n - 1+1] := arr[n - 1+1]+(sum) ; 
    totalCost := totalCost+((2 * cost * arr[n - 1+1])) ; 
    return totalCost 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,4,5} ;
     var n : int ; n := arr->size() ;
     var cost : int ; cost := 1 ;
     OclFile["System.out"].println(minCost(n, arr, cost)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A50 {
  public static void main(String[] args){
    FastIO io=new FastIO();
    io.read();
    String s=io.next().toLowerCase(Locale.ROOT);
    StringBuffer sb=new StringBuffer();
    char c=0 ;
    for(int i=0 ; i<s.length(); i++){
      c=s.charAt(i);
      if(!(c=='a' || c=='o' || c=='y' || c=='e' || c=='u' || c=='i'))sb.append("."+c);
    }
    io.append(sb.toString());
    io.print();
  }
}
class FastIO {
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  StringTokenizer st ;
  void read(){
    try {
      st=new StringTokenizer(br.readLine());
    }
    catch(Exception e){
    }
  }
  String next(){
    if(st.hasMoreElements())return st.nextToken();
    else {
      read();
      return st.nextToken();
    }
  }
  int nextInt(){
    return Integer.parseInt(next());
  }
  void append(Object o){
    try {
      bw.write(o.toString());
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  void print(){
    try {
      bw.flush();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A50 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : FastIO ; io := FastIO.newFastIO() ;
     io.read() ; 
    var s : String ; s := io.next().toLowerCase(Locale.ROOT) ;
    var sb : String ; sb := StringLib.newString() ;
    var c : String ; c := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     c := s->at(i+1) ; 
     if (not((c = 'a' or c = 'o' or c = 'y' or c = 'e' or c = 'u' or c = 'i'))) then     sb := sb + StringLib.newString("." + c) ; else skip )  ;     i := i + 1 ) ; 
    io := io + StringLib.newString(sb+"") ; 
    io.print() ; 
 );
}
class FastIO {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
   attribute st : OclIterator;
   operation read() : void
  pre: true
  post: true
  activity: (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do skip
 );
   operation next() : String
  pre: true
  post: true
  activity: (     if (st.hasNext()) then     return st.next() else (     execute read() ; 
     return st.next() ) );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation append( o : OclAny) : void
  pre: true
  post: true
  activity: (     try (     skip )   catch (e : IOException) do (     e.printStackTrace() )
 );
   operation print() : void
  pre: true
  post: true
  activity: (     try (     skip )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.*;
public class MyClass {
  private static BufferedReader br=null ;
  private static int readInt()throws Exception {
    return Integer.parseInt(br.readLine());
  }
  private static int[] readIntArr()throws Exception {
    return Arrays.stream(br.readLine().split("\\s+")).mapToInt(Integer :: parseInt).toArray();
  }
  private static String readStr()throws Exception {
    return br.readLine();
  }
  private static void print(String s){
    System.out.println(s);
  }
  public static void main(String args[])throws Exception {
    br=new BufferedReader(new InputStreamReader(System.in));
    String str=readStr();
    str=str.toLowerCase();
    String s="" ;
    int n=str.length();
    for(int i=0 ; i<n ; i++){
      if(str.charAt(i)=='a' || str.charAt(i)=='e' || str.charAt(i)=='i' || str.charAt(i)=='o' || str.charAt(i)=='u' || str.charAt(i)=='y'){
        continue ;
      }
      s+="."+str.charAt(i);
    }
    print(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   attribute br : OclFile := null;
  static   operation readInt() : int
  pre: true
  post: true
  activity: (     return (br.readLine())->toInteger() );
  static   operation readIntArr() : Sequence(int)
  pre: true
  post: true
  activity: (     return stream(br.readLine()->split("\\s+"))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() );
  static   operation readStr() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
  static   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     var str : String ; str := readStr() ;
    str := str->toLowerCase() ; 
    var s : String ; s := "" ;
    var n : int ; n := str->size() ;
        var i : int ; i := 0 ; while i < n do ( (     if (str->at(i+1) = 'a' or str->at(i+1) = 'e' or str->at(i+1) = 'i' or str->at(i+1) = 'o' or str->at(i+1) = 'u' or str->at(i+1) = 'y') then (     continue ) else skip ; 
     s := s+("." + str->at(i+1)) )  ;     i := i + 1 ) ; 
    execute print(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class StringTask {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(st==null || ! st.hasMoreTokens()){
        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().trim();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  static class FastWriter {
    private final BufferedWriter bw ;
    public FastWriter(){
      this.bw=new BufferedWriter(new OutputStreamWriter(System.out));
    }
    public void print(Object object)throws IOException {
      bw.append(""+object);
    }
    public void println(Object object)throws IOException {
      print(object);
      bw.append("\n");
    }
    public void close()throws IOException {
      bw.close();
    }
  }
  public static void main(String[] args){
    try {
      FastReader in=new FastReader();
      FastWriter out=new FastWriter();
      String s=in.nextLine();
      String ans=s.toLowerCase();
      String ans2=ans.replaceAll("[aeiouy] ","");
      String replaceMent="" ;
      for(int i=0 ; i<ans2.length(); i++){
        replaceMent+="."+""+ans2.charAt(i);
      }
      out.println(replaceMent);
      out.close();
    }
    catch(Exception e){
      System.out.println(e);
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class StringTask {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine()->trim() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return str );
}
  static class FastWriter {
   attribute bw : OclFile;
   static operation newFastWriter() : FastWriter
  pre: true
  post: true
  activity:
  ( var self : FastWriter ;
    self := createFastWriter();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) );
   operation print( object : OclAny) : void
  pre: true
  post: true
  activity: (     skip );
   operation println( object : OclAny) : void
  pre: true
  post: true
  activity: (     execute print(object) ; 
     skip );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : FastWriter ; out := FastWriter.newFastWriter() ;
    var s : String ; s := in.nextLine() ;
    var ans : String ; ans := s->toLowerCase() ;
    var ans2 : String ; ans2 := ans.replaceAllMatches("[aeiouy] ", "" ) ;
    var replaceMent : String ; replaceMent := "" ;
        var i : int ; i := 0 ; while i < ans2->size() do ( (     replaceMent := replaceMent+("." + "" + ans2->at(i+1)) )  ;     i := i + 1 ) ; 
    out.println(replaceMent) ; 
    out.close() ; 
 )   catch (e : ProgramException) do (     OclFile["System.out"].println(e) ; 
     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    String str=s.next(),ans="" ;
    char ch=str.charAt(0);
    if(!(ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u' || ch=='A' || ch=='E' || ch=='I' || ch=='O' || ch=='U' || ch=='y' || ch=='Y'))ans+=(char)'.' ;
    for(int i=0 ; i<str.length(); i++){
      ch=str.charAt(i);
      if(!(ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u' || ch=='A' || ch=='E' || ch=='I' || ch=='O' || ch=='U' || ch=='y' || ch=='Y')){
        if(ch<='z' && ch>='a')ans+=ch ;
        else ans+=(char)(ch-'A'+'a');
      }
      if(i+1<str.length()){
        ch=str.charAt(i+1);
        if(!(ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u' || ch=='A' || ch=='E' || ch=='I' || ch=='O' || ch=='U' || ch=='y' || ch=='Y'))ans+='.' ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := s.getCurrent() ;
    var ans : String ; ans := "" ;
    var ch : String ; ch := str->at(0+1) ;
    if (not((ch = 'a' or ch = 'e' or ch = 'i' or ch = 'o' or ch = 'u' or ch = 'A' or ch = 'E' or ch = 'I' or ch = 'O' or ch = 'U' or ch = 'y' or ch = 'Y'))) then     ans := ans+('.'->oclAsType(String)) ; else skip ; 
        var i : int ; i := 0 ; while i < str->size() do ( (     ch := str->at(i+1) ; 
     if (not((ch = 'a' or ch = 'e' or ch = 'i' or ch = 'o' or ch = 'u' or ch = 'A' or ch = 'E' or ch = 'I' or ch = 'O' or ch = 'U' or ch = 'y' or ch = 'Y'))) then (     if (ch <= 'z' & ch >= 'a') then     ans := ans+(ch) ; else     ans := ans+(((ch)->char2byte() - ('A')->char2byte() + 'a')->oclAsType(String)) ; ) else skip ; 
     if (i + 1 < str->size()) then (     ch := str->at(i + 1+1) ; 
     if (not((ch = 'a' or ch = 'e' or ch = 'i' or ch = 'o' or ch = 'u' or ch = 'A' or ch = 'E' or ch = 'I' or ch = 'O' or ch = 'U' or ch = 'y' or ch = 'Y'))) then     ans := ans+('.') ; else skip ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static int counLastDigitK(int low,int high,int k){
    int count=0 ;
    for(int i=low ; i<=high ; i++)if(i % 10==k)count++;
    return count ;
  }
  public static void main(String args[]){
    int low=3,high=35,k=3 ;
    System.out.println(counLastDigitK(low,high,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation counLastDigitK( low : int, high : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := low ; while i <= high do (     if (i mod 10 = k) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var low : int ; low := 3 ;
    var high : int ; high := 35 ;
    var k : int ; k := 3 ;
     OclFile["System.out"].println(counLastDigitK(low, high, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static int counLastDigitK(int low,int high,int k){
    int count=(high-low)/10 ;
    if(high % 10>=k)count++;
    if(low % 10>k)count--;
    return count ;
  }
  public static void main(String argc[]){
    int low=3,high=35,k=3 ;
    System.out.println(counLastDigitK(low,high,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation counLastDigitK( low : int, high : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := (high - low) / 10 ;
     if (high mod 10 >= k) then     count := count + 1 ; else skip ; 
     if (low mod 10 > k) then     count := count - 1 ; else skip ; 
     return count );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var low : int ; low := 3 ;
    var high : int ; high := 35 ;
    var k : int ; k := 3 ;
     OclFile["System.out"].println(counLastDigitK(low, high, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findCnt(int[] arr,int n,int k){
    int ret=0 ;
    int i=0 ;
    while(i<n){
      int j=i+1 ;
      while(j<n && arr[j]>=arr[j-1])j++;
      int x=Math.max(0,j-i-k+1);
      ret+=(x*(x+1))/2 ;
      i=j ;
    }
    return ret ;
  }
  public static void main(String[] args){
    int arr[]={
      5,4,3,2,1 };
      int n=arr.length ;
      int k=2 ;
      System.out.println(findCnt(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findCnt( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
     var i : int ; i := 0 ;
     while (i < n) do (     var j : int ; j := i + 1 ;
     while (j < n & arr[j+1] >= arr[j - 1+1]) do     j := j + 1 ; ; 
    var x : int ; x := Set{0, j - i - k + 1}->max() ;
    ret := ret+((x * (x + 1)) / 2) ; 
    i := j ; 
 ) ; 
     return ret );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,4,3,2,1} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(findCnt(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class SmallestSubArraySum {
  static int smallestSubWithSum(int arr[],int n,int x){
    int curr_sum=0,min_len=n+1 ;
    int start=0,end=0 ;
    while(end<n){
      while(curr_sum<=x && end<n)curr_sum+=arr[end++];
      while(curr_sum>x && start<n){
        if(end-start<min_len)min_len=end-start ;
        curr_sum-=arr[start++];
      }
    }
    return min_len ;
  }
  public static void main(String[] args){
    int arr1[]={
      1,4,45,6,10,19 };
      int x=51 ;
      int n1=arr1.length ;
      int res1=smallestSubWithSum(arr1,n1,x);
      if(res1==n1+1)System.out.println("Not Possible");
      else System.out.println(res1);
      int arr2[]={
        1,10,5,2,7 };
        int n2=arr2.length ;
        x=9 ;
        int res2=smallestSubWithSum(arr2,n2,x);
        if(res2==n2+1)System.out.println("Not Possible");
        else System.out.println(res2);
        int arr3[]={
          1,11,100,1,0,200,3,2,1,250 };
          int n3=arr3.length ;
          x=280 ;
          int res3=smallestSubWithSum(arr3,n3,x);
          if(res3==n3+1)System.out.println("Not Possible");
          else System.out.println(res3);
        }
      }

------------------------------------------------------------
OCL File:
---------
class SmallestSubArraySum {
  static   operation smallestSubWithSum( arr : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var curr_sum : int ; curr_sum := 0 ;
    var min_len : int ; min_len := n + 1 ;
     var start : int ; start := 0 ;
    var end : int ; end := 0 ;
     while (end < n) do (     while (curr_sum <= x & end < n) do      curr_sum := curr_sum + arr[end+1]  ; end := end + 1 ; ; 
     while (curr_sum > x & start < n) do (     if (end - start < min_len) then     min_len := end - start ; else skip ; 
      curr_sum := curr_sum - (arr[start+1])  ; start := start + 1 ) ) ; 
     return min_len );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{1,4,45,6,10,19} ;
     var x : int ; x := 51 ;
    var n1 : int ; n1 := arr1->size() ;
    var res1 : int ; res1 := smallestSubWithSum(arr1, n1, x) ;
    if (res1 = n1 + 1) then     OclFile["System.out"].println("Not Possible") else     OclFile["System.out"].println(res1) ; ;  
    var arr2 : Sequence(int) ; arr2 := Sequence{1,10,5,2,7} ;
    var n2 : int ; n2 := arr2->size() ;
    x := 9 ; 
    var res2 : int ; res2 := smallestSubWithSum(arr2, n2, x) ;
    if (res2 = n2 + 1) then     OclFile["System.out"].println("Not Possible") else     OclFile["System.out"].println(res2) ; ;  
    var arr3 : Sequence(int) ; arr3 := Sequence{1,11,100,1,0,200,3,2,1,250} ;
    var n3 : int ; n3 := arr3->size() ;
    x := 280 ; 
    var res3 : int ; res3 := smallestSubWithSum(arr3, n3, x) ;
    if (res3 = n3 + 1) then     OclFile["System.out"].println("Not Possible") else     OclFile["System.out"].println(res3) ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.LinkedList ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.teamFormationMake();
    return ;
  }
  private void teamFormationMake(){
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    try {
      String inputStr=bufferedReader.readLine();
      int yearNum=Integer.parseInt(inputStr);
      LinkedList<LinkedList<Integer>>programmerList=new LinkedList<LinkedList<Integer>>();
      int teamNum=0 ;
      for(int i=0 ; i<yearNum ; i++){
        String teamStr=bufferedReader.readLine();
        String[] teamStrs=teamStr.split(" ");
        programmerList.add(new LinkedList<Integer>());
        for(int j=0 ; j<teamStrs.length ; j++){
          programmerList.get(i).add(Integer.parseInt(teamStrs[j]));
        }
      }
      for(int i=0 ; i<yearNum ; i++){
        int c=programmerList.get(i).get(0);
        int a=programmerList.get(i).get(1);
        int n=programmerList.get(i).get(2);
        while(true){
          if(c>=1 && a>=1 && n>=1){
            teamNum++;
            c--;
            a--;
            n--;
          }
          else if(c>=2 && a>=1){
            teamNum++;
            c=c-2 ;
            a--;
          }
          else if(c>=3){
            teamNum++;
            c=c-3 ;
          }
          else {
            break ;
          }
        }
        System.out.println(teamNum);
        teamNum=0 ;
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.teamFormationMake() ; 
     return );
   operation teamFormationMake() : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var inputStr : String ; inputStr := bufferedReader.readLine() ;
     var yearNum : int ; yearNum := (inputStr)->toInteger() ;
    var programmerList : Sequence(Sequence(int)) ; programmerList := Sequence{} ;
    var teamNum : int ; teamNum := 0 ;
        var i : int ; i := 0 ; while i < yearNum do ( (     var teamStr : String ; teamStr := bufferedReader.readLine() ;
     var teamStrs : Sequence(String) ; teamStrs := teamStr->split(" ") ;
     programmerList := programmerList->including(Sequence{}) ; 
         var j : int ; j := 0 ; while j < teamStrs->size() do ( (     programmerList->at(i+1)->excludes((teamStrs[j+1])->toInteger()) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < yearNum do ( (     var c : int ; c := programmerList->at(i+1)->at(0+1) ;
     var a : int ; a := programmerList->at(i+1)->at(1+1) ;
    var n : int ; n := programmerList->at(i+1)->at(2+1) ;
    while (true) do (     if (c >= 1 & a >= 1 & n >= 1) then (     teamNum := teamNum + 1 ; 
     c := c - 1 ; 
     a := a - 1 ; 
     n := n - 1 ) else     if (c >= 2 & a >= 1) then (     teamNum := teamNum + 1 ; 
     c := c - 2 ; 
     a := a - 1 ) else     if (c >= 3) then (     teamNum := teamNum + 1 ; 
     c := c - 3 ) else (     break ) ;  ;  ) ; 
    OclFile["System.out"].println(teamNum) ; 
    teamNum := 0 ; 
 )  ;     i := i + 1 ) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  static int smallestEven(int n){
    if(n==1)return 0 ;
    return Math.pow(10,n-1);
  }
  public static void main(String args[]){
    int n=4 ;
    System.out.println(smallestEven(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
  static   operation smallestEven( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 0 else skip ; 
     return 10->pow(n - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(smallestEven(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  static int smallestOdd(int n){
    if(n==1)return 0 ;
    return Math.pow(10,n-1)+1 ;
  }
  public static void main(String args[]){
    int n=4 ;
    System.out.println(smallestOdd(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
  static   operation smallestOdd( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 0 else skip ; 
     return 10->pow(n - 1) + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(smallestOdd(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean sumSquare(int n){
    for(long i=1 ; i*i<=n ; i++)for(long j=1 ; j*j<=n ; j++)if(i*i+j*j==n){
      System.out.println(i+"^2+"+j+"^2");
      return true ;
    }
    return false ;
  }
  public static void main(String args[]){
    int n=25 ;
    if(sumSquare(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sumSquare( n : int) : boolean
  pre: true
  post: true
  activity: (         var i : long ; i := 1 ; while i * i <= n do (         var j : long ; j := 1 ; while j * j <= n do (     if (i * i + j * j = n) then (     OclFile["System.out"].println(i + "^2+" + j + "^2") ; 
     return true ) else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 25 ;
     if (sumSquare(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int ans ;
  static String s ;
  static ArrayList<String>sArray ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      s=sc.next();
      if(s.equals("#")){
        break ;
      }
      sArray=new ArrayList<String>();
      char[] sca=s.toCharArray();
      ans=0 ;
      decode(sca,0);
      Collections.sort(sArray);
      System.out.println(ans);
      for(int i=0 ; i<sArray.size(); i++){
        System.out.println(sArray.get(i));
      }
    }
  }
  public static void decode(char[] sca,int pos){
    if(pos==sca.length){
      if(encode(sca)){
        ans++;
        String tmp=new String(sca);
        sArray.add(tmp);
        Collections.sort(sArray);
        if(sArray.size()>10){
          sArray.remove(5);
        }
      }
      return ;
    }
    decode(sca,pos+1);
    if(sca[pos]!='z'){
      sca[pos]++;
      decode(sca,pos+1);
      sca[pos]--;
    }
  }
  public static boolean encode(char[] sca){
    char[] tmp=Arrays.copyOf(sca,sca.length);
    for(int i=1 ; i<=25 ; i++){
      char c=(char)('a'+i);
      for(int j=0 ; j<tmp.length ; j++){
        if(tmp[j]==c){
          tmp[j]--;
          break ;
        }
      }
    }
    if(s.equals(new String(tmp))){
      return true ;
    }
    else {
      return false ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ans : int;
  static   attribute s : String;
  static   attribute sArray : Sequence(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     s := sc.getCurrent() ; 
     if (s = "#") then (     break ) else skip ; 
    sArray := Sequence{} ; 
    var sca : Sequence(String) ; sca := s->characters() ;
    ans := 0 ; 
    execute decode(sca, 0) ; 
    sArray := sArray->sort() ; 
    OclFile["System.out"].println(ans) ; 
        var i : int ; i := 0 ; while i < sArray->size() do ( (     OclFile["System.out"].println(sArray->at(i+1)) )  ;     i := i + 1 ) ; 
 ) );
  static   operation decode( sca : Sequence(String), pos : int) : void
  pre: true
  post: true
  activity: (     if (pos = sca->size()) then (     if (encode(sca)) then (     ans := ans + 1 ; 
     var tmp : String ; tmp := StringLib.newString(sca) ;
    sArray := sArray->including(tmp) ; 
    sArray := sArray->sort() ; 
    if (sArray->size() > 10) then (     sArray := sArray->excludingAt(5+1) ) else skip ; 
 ) else skip ; 
     return ) else skip ; 
     execute decode(sca, pos + 1) ; 
     if (sca[pos+1] /= 'z') then (     sca[pos+1] := sca[pos+1] + 1 ; 
     execute decode(sca, pos + 1) ; 
     sca[pos+1] := sca[pos+1] - 1 ) else skip );
  static   operation encode( sca : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     var tmp : Sequence(String) ; tmp := sca.subrange(1,sca->size()) ;
         var i : int ; i := 1 ; while i <= 25 do ( (     var c : String ; c := ('a' + i)->oclAsType(String) ;
         var j : int ; j := 0 ; while j < tmp->size() do ( (     if (tmp[j+1] = c) then (     tmp[j+1] := tmp[j+1] - 1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (s = StringLib.newString(tmp)) then (     return true ) else (     return false ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int ans ;
  static String s ;
  static ArrayList<String>sArray ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      s=sc.next();
      if(s.equals("#")){
        break ;
      }
      sArray=new ArrayList<String>();
      char[] sca=s.toCharArray();
      ans=0 ;
      decode(sca,0,0);
      System.out.println(ans);
      for(int i=0 ; i<sArray.size(); i++){
        System.out.println(sArray.get(i));
      }
    }
  }
  public static void decode(char[] sca,int pos,int decodeBit){
    if(pos==sca.length){
      if(encode(sca)){
        ans++;
        sArray.add(new String(sca));
        Collections.sort(sArray);
        if(sArray.size()>10){
          sArray.remove(5);
        }
      }
      return ;
    }
    decode(sca,pos+1,decodeBit);
    if(sca[pos]!='z' &&(decodeBit &(1<<(sca[pos]-'a')))==0){
      sca[pos]++;
      decode(sca,pos+1,decodeBit |(1<<(sca[pos]-1-'a')));
      sca[pos]--;
    }
  }
  public static boolean encode(char[] sca){
    char[] tmp=Arrays.copyOf(sca,sca.length);
    for(int i=1 ; i<=25 ; i++){
      char c=(char)('a'+i);
      for(int j=0 ; j<tmp.length ; j++){
        if(tmp[j]==c){
          tmp[j]--;
          break ;
        }
      }
    }
    if(s.equals(new String(tmp))){
      return true ;
    }
    else {
      return false ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ans : int;
  static   attribute s : String;
  static   attribute sArray : Sequence(String);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     s := sc.getCurrent() ; 
     if (s = "#") then (     break ) else skip ; 
    sArray := Sequence{} ; 
    var sca : Sequence(String) ; sca := s->characters() ;
    ans := 0 ; 
    execute decode(sca, 0, 0) ; 
    OclFile["System.out"].println(ans) ; 
        var i : int ; i := 0 ; while i < sArray->size() do ( (     OclFile["System.out"].println(sArray->at(i+1)) )  ;     i := i + 1 ) ; 
 ) );
  static   operation decode( sca : Sequence(String), pos : int, decodeBit : int) : void
  pre: true
  post: true
  activity: (     if (pos = sca->size()) then (     if (encode(sca)) then (     ans := ans + 1 ; 
     sArray := sArray->including(StringLib.newString(sca)) ; 
     sArray := sArray->sort() ; 
     if (sArray->size() > 10) then (     sArray := sArray->excludingAt(5+1) ) else skip ) else skip ; 
     return ) else skip ; 
     execute decode(sca, pos + 1, decodeBit) ; 
     if (sca[pos+1] /= 'z' & (decodeBit & ((1*(2->pow((sca[pos+1] - ('a')->char2byte()))))->oclAsType(long))) = 0) then (     sca[pos+1] := sca[pos+1] + 1 ; 
     execute decode(sca, pos + 1, decodeBit or ((1*(2->pow((sca[pos+1] - 1 - ('a')->char2byte()))))->oclAsType(long))) ; 
     sca[pos+1] := sca[pos+1] - 1 ) else skip );
  static   operation encode( sca : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     var tmp : Sequence(String) ; tmp := sca.subrange(1,sca->size()) ;
         var i : int ; i := 1 ; while i <= 25 do ( (     var c : String ; c := ('a' + i)->oclAsType(String) ;
         var j : int ; j := 0 ; while j < tmp->size() do ( (     if (tmp[j+1] = c) then (     tmp[j+1] := tmp[j+1] - 1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (s = StringLib.newString(tmp)) then (     return true ) else (     return false ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  Main(){
    sc=new Scanner(System.in);
  }
  int ni(){
    return sc.nextInt();
  }
  public static void main(String[] args){
    new Main().run();
  }
  String ans ;
  ArrayList<String>list ;
  int count ;
  void dfs(String str){
    char[] rep=str.toCharArray();
    for(int i='b' ; i<='z' ; ++i){
      for(int j=0 ; j<str.length(); ++j){
        if(str.charAt(j)==i){
          rep[j]=(char)(i-1);
          break ;
        }
      }
    }
    boolean flag=true ;
    for(int i=0 ; i<str.length(); ++i){
      flag &=rep[i]==ans.charAt(i);
    }
    if(! flag){
      return ;
    }
    if(str.length()==ans.length()){
      if(list.size()<10){
        list.add(str);
      }
      else {
        list.remove(5);
        list.add(str);
      }
++count ;
    }
    else {
      char c=ans.charAt(str.length());
      dfs(str+c);
      if(c!='z'){
        dfs(str+(char)(c+1));
      }
    }
  }
  void run(){
    for(; ; ){
      ans=sc.next();
      if(ans.equals("#")){
        break ;
      }
      list=new ArrayList<>();
      count=0 ;
      dfs("");
      System.out.println(count);
      for(int i=0 ; i<Math.min(count,10); ++i){
        System.out.println(list.get(i));
      }
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute ans : String;
   attribute list : Sequence(String);
   attribute count : int;
   operation dfs( str : String) : void
  pre: true
  post: true
  activity: (     var rep : Sequence(String) ; rep := str->characters() ;
         var i : int ; i := 'b' ; while i <= 'z' do ( (         var j : int ; j := 0 ; while j < str->size() do ( (     if (str->at(j+1) = i) then (     rep[j+1] := (i - 1)->oclAsType(String) ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < str->size() do ( (     flag := MathLib.bitwiseAnd(flag, rep[i+1] = ans->at(i+1)) )  ;     i := i + 1 ) ; 
    if (not(flag)) then (     return ) else skip ; 
    if (str->size() = ans->size()) then (     if (list->size() < 10) then (     list := list->including(str) ) else (     list := list->excludingAt(5+1) ; 
     list := list->including(str) ) ;  
     count := count + 1 ) else (     var c : String ; c := ans->at(str->size()+1) ;
     execute dfs(str + c) ; 
     if (c /= 'z') then (     execute dfs(str + (c + 1)->oclAsType(String)) ) else skip ) ;  
 );
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     ans := sc.getCurrent() ; 
     if (ans = "#") then (     break ) else skip ; 
    list := Sequence{} ; 
    count := 0 ; 
    execute dfs("") ; 
    OclFile["System.out"].println(count) ; 
        var i : int ; i := 0 ; while i < Set{count, 10}->min() do ( (     OclFile["System.out"].println(list->at(i+1)) )  ;     i := i + 1 ) ; 
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=in.nextInt();
      int m=in.nextInt();
      int c=0 ;
      for(int j=0 ; j<n ; j++){
        c+=in.nextInt();
      }
      if(c>=m)System.out.println(c-m);
      else System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     c := c+(in.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
    if (c >= m) then     OclFile["System.out"].println(c - m) else     OclFile["System.out"].println(0) ; ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=in.nextInt();
      int m=in.nextInt();
      int c=0 ;
      for(int j=0 ; j<n ; j++){
        c+=in.nextInt();
      }
      if(c>=m)System.out.println(c-m);
      else System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     c := c+(in.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
    if (c >= m) then     OclFile["System.out"].println(c - m) else     OclFile["System.out"].println(0) ; ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileReader ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Solution {
  static PrintWriter pw ;
  static FastScanner s ;
  public static void main(String[] args)throws Exception {
    pw=new PrintWriter(System.out);
    s=new FastScanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int m=s.nextInt();
      long sum=0 ;
      for(int i=0 ; i<n ; i++){
        sum+=s.nextInt();
      }
      if(m>=sum)pw.println(0);
      else pw.println(sum-m);
    }
    pw.flush();
  }
}
class FastScanner {
  BufferedReader br ;
  StringTokenizer st ;
  public FastScanner(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public FastScanner(String s)throws Exception {
    br=new BufferedReader(new FileReader(new File(s)));
  }
  public String next()throws Exception {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws Exception {
    return Integer.parseInt(next());
  }
  public long nextLong()throws Exception {
    return Long.parseLong(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute pw : OclFile;
  static   attribute s : FastScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     pw := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     s := FastScanner.newFastScanner(OclFile["System.in"]) ; 
    var t : int ; t := s.nextInt() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.nextInt() ;
     var m : int ; m := s.nextInt() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(s.nextInt()) )  ;     i := i + 1 ) ; 
    if (m >= sum) then     skip else     skip ; ;  
 ) ;  ) ;  
    skip ; 
 );
}
class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( s : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFastScanner( s : String) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile(s))) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test289 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int m=in.nextInt();
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        sum+=in.nextInt();
      }
      if(sum>m){
        System.out.println(sum-m);
      }
      else {
        System.out.println(0);
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test289 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    if (sum > m) then (     OclFile["System.out"].println(sum - m) ) else (     OclFile["System.out"].println(0) ) ;  
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
class Main {
  public static void main(String[] args){
    Solve s=new Solve();
    s.solve();
  }
}
class Solve {
  Solve(){
  }
  Scanner in=new Scanner(System.in);
  void solve(){
    int q=in.nextInt();
    for(int i=0 ; i<q ; i++){
      int c=in.nextInt(),a=in.nextInt(),n=in.nextInt();
      int ans=0 ;
      int k=Math.min(c,Math.min(a,n));
      ans+=k ;
      c-=k ;
      a-=k ;
      k=Math.min(c/2,a);
      if(k<0)k=0 ;
      ans+=k ;
      c-=k*2 ;
      if(c<0)c=0 ;
      ans+=c/3 ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Solve ; s := Solve.newSolve() ;
     s.solve() );
}
class Solve {
   static operation newSolve() : Solve
  pre: true
  post: true
  activity:
  ( var self : Solve ;
    self := createSolve();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation solve() : void
  pre: true
  post: true
  activity: (     var q : int ; q := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < q do ( (     var c : int ; c := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var n : int ; n := in.getCurrent()->toInteger() ;
     var ans : int ; ans := 0 ;
    var k : int ; k := Set{c, Set{a, n}->min()}->min() ;
    ans := ans+(k) ; 
    c := c-(k) ; 
    a := a-(k) ; 
    k := Set{c / 2, a}->min() ; 
    if (k < 0) then     k := 0 ; else skip ; 
    ans := ans+(k) ; 
    c := c-(k * 2) ; 
    if (c < 0) then     c := 0 ; else skip ; 
    ans := ans+(c / 3) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  static int findMaximum(int arr[],int low,int high){
    int max=arr[low];
    int i ;
    for(i=low ; i<=high ; i++){
      if(arr[i]>max)max=arr[i];
    }
    return max ;
  }
  public static void main(String[] args){
    int arr[]={
      1,30,40,50,60,70,23,20 };
      int n=arr.length ;
      System.out.println("The maximum element is "+findMaximum(arr,0,n-1));
    }
  }

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation findMaximum( arr : Sequence(int), low : int, high : int) : int
  pre: true
  post: true
  activity: (     var max : int ; max := arr[low+1] ;
     var i : int ;
         i := low ; while i <= high do ( (     if (arr[i+1] > max) then     max := arr[i+1] ; else skip )  ;     i := i + 1 ) ; 
     return max );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,30,40,50,60,70,23,20} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("The maximum element is " + findMaximum(arr, 0, n - 1)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minIndex(int arr[],int n,int pos){
    int num=arr[pos];
    int i=pos-1 ;
    while(i>=0){
      if(arr[i]!=num)break ;
      i--;
    }
    return i+1 ;
  }
  public static void main(String[] args){
    int arr[]={
      2,1,1,1,5,2 };
      int n=arr.length ;
      int pos=4 ;
      System.out.println(minIndex(arr,n,pos));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minIndex( arr : Sequence(int), n : int, pos : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := arr[pos+1] ;
     var i : int ; i := pos - 1 ;
     while (i >= 0) do (     if (arr[i+1] /= num) then     break else skip ; 
     i := i - 1 ) ; 
     return i + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,1,1,1,5,2} ;
     var n : int ; n := arr->size() ;
     var pos : int ; pos := 4 ;
     OclFile["System.out"].println(minIndex(arr, n, pos)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Code {
  public static void main(String arg[]){
    try {
      System.setIn(new FileInputStream("input.txt"));
      System.setOut(new PrintStream(new FileOutputStream("output.txt")));
    }
    catch(Exception e){
      System.err.println("Error");
    }
    solveProblem();
  }
  public static void solveProblem(){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      int sum=0 ;
      for(int j=0 ; j<n ; j++){
        sum+=sc.nextInt();
      }
      if(sum-n>=0)System.out.println(sum-n);
      else System.out.println(1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Code {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) )   catch (e : ProgramException) do (     OclFile["System.err"].println("Error") )
     execute solveProblem() );
  static   operation solveProblem() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var sum : int ; sum := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     sum := sum+(sc.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
     if (sum - n >= 0) then     OclFile["System.out"].println(sum - n) ; else     OclFile["System.out"].println(1) ; )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test185 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        sum+=in.nextInt();
      }
      if(sum>=n){
        System.out.println(sum-n);
      }
      else {
        System.out.println("1");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test185 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
     if (sum >= n) then (     OclFile["System.out"].println(sum - n) ) else (     OclFile["System.out"].println("1") ) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Arithmetic {
  int number ;
  public Arithmetic(int number){
    this.number=number ;
  }
  static int calc=0 ;
  public void input(int index,int n,int num){
    if(index==0){
      calc=0 ;
    }
    calc+=num ;
    if(index==n-1){
      if(calc>=n){
        System.out.println((calc-n));
      }
      else {
        System.out.println(1);
      }
    }
  }
  public int getNumber(){
    return number ;
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    int number=input.nextInt();
    Arithmetic instance=new Arithmetic(number);
    for(int i=0 ; i<instance.getNumber(); i++){
      int num=input.nextInt();
      for(int k=0 ; k<num ; k++){
        int n=input.nextInt();
        instance.input(k,num,n);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Arithmetic {
   attribute number : int;
   static operation newArithmetic( number : int) : Arithmetic
  pre: true
  post: true
  activity:
  ( var self : Arithmetic ;
    self := createArithmetic();
    self.initialise(number);
    return self );
  operation initialise( number : int) : void
  pre: true  post: true
  activity: (     self.number := number );
  static   attribute calc : int := 0;
   operation input( index : int, n : int, num : int) : void
  pre: true
  post: true
  activity: (     if (index = 0) then (     calc := 0 ) else skip ; 
     calc := calc+(num) ; 
     if (index = n - 1) then (     if (calc >= n) then (     OclFile["System.out"].println((calc - n)) ) else (     OclFile["System.out"].println(1) ) ) else skip );
   operation getNumber() : int
  pre: true
  post: true
  activity: (     return number );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := input.getCurrent()->toInteger() ;
     var instance : Arithmetic ; instance := Arithmetic.newArithmetic(number) ;
         var i : int ; i := 0 ; while i < instance.getNumber() do ( (     var num : int ; num := input.getCurrent()->toInteger() ;
         var k : int ; k := 0 ; while k < num do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     instance.input(k, num, n) )  ;     k := k + 1 ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Arithmetic_array {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      int[] a=new int[n];
      int sum=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        sum+=a[i];
      }
      if(sum==n){
        System.out.println("0");
      }
      else if(sum<n){
        System.out.println("1");
      }
      else {
        System.out.println(sum-n);
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Arithmetic_array {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    if (sum = n) then (     OclFile["System.out"].println("0") ) else     if (sum < n) then (     OclFile["System.out"].println("1") ) else (     OclFile["System.out"].println(sum - n) ) ;  ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedWriter ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    int n=sc.nextInt();
    if(n>2 && n % 2==0){
      pw.println("YES");
    }
    else {
      pw.println("NO");
    }
    pw.flush();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    if (n > 2 & n mod 2 = 0) then (     skip ) else (     skip ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class watermelon {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String strInput=scanner.nextLine();
    int input=Integer.parseInt(strInput);
    if(input % 2==0 && input>2){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class watermelon {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var strInput : String ; strInput := scanner.nextLine() ;
     var input : int ; input := (strInput)->toInteger() ;
     if (input mod 2 = 0 & input > 2) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int number=in.nextInt();
    if(number % 2==0 && number>2){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : int ; number := in.getCurrent()->toInteger() ;
     if (number mod 2 = 0 & number > 2) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class CP {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    if(a>2 && a % 2==0){
      System.out.println("YES");
    }
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class CP {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
     if (a > 2 & a mod 2 = 0) then (     OclFile["System.out"].println("YES") ) else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.math.BigInteger ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    final int Q=sc.nextInt();
    for(int q=0 ; q<Q ; q++){
      final int c=sc.nextInt();
      final int a=sc.nextInt();
      final int n=sc.nextInt();
      int count=0 ;
      final int min_n=Math.min(c,Math.min(a,n));
      count+=min_n ;
      final int c_=c-min_n ;
      final int a_=a-min_n ;
      final int min_a=Math.min(c_/2,a_);
      count+=min_a ;
      final int c__=c_-min_a*2 ;
      count+=c__/3 ;
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var Q : int ; Q := sc.getCurrent()->toInteger() ;
         var q : int ; q := 0 ; while q < Q do ( (     var c : int ; c := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var min_n : int ; min_n := Set{c, Set{a, n}->min()}->min() ;
    count := count+(min_n) ; 
    var c_ : int ; c_ := c - min_n ;
    var a_ : int ; a_ := a - min_n ;
    var min_a : int ; min_a := Set{c_ / 2, a_}->min() ;
    count := count+(min_a) ; 
    var c__ : int ; c__ := c_ - min_a * 2 ;
    count := count+(c__ / 3) ; 
    OclFile["System.out"].println(count) ; 
 )  ;     q := q + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Watermelon_1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int w=sc.nextInt();
    Watermelon_1.check(w);
  }
  public static void check(int w){
    if(w<=2){
      System.out.println("NO");
      return ;
    }
    if(w % 2==0)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Watermelon_1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var w : int ; w := sc.getCurrent()->toInteger() ;
     WatermelonWatermelonWatermelon    WatermelonWatermelonWatermelon    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
.check(w).check(w) ;.check(w).check(w) );
  static   operation check( w : int) : void
  pre: true
  post: true
  activity: (     if (w <= 2) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
     if (w mod 2 = 0) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void sortArray(int a[],int n){
    Vector<Integer>ans=new Vector<>();
    for(int i=0 ; i<n ; i++){
      if(a[i]>=0)ans.add(a[i]);
    }
    Collections.sort(ans);
    int j=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i]>=0){
        a[i]=ans.get(j);
        j++;
      }
    }
    for(int i=0 ; i<n ; i++)System.out.print(a[i]+" ");
  }
  public static void main(String[] args){
    int arr[]={
      2,-6,-3,8,4,1 };
      int n=arr.length ;
      sortArray(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sortArray( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var ans : Sequence(int) ; ans := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] >= 0) then     ans := ans->including(a[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    ans := ans->sort() ; 
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] >= 0) then (     a[i+1] := ans->at(j+1) ; 
     j := j + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,-6,-3,8,4,1} ;
     var n : int ; n := arr->size() ;
     execute sortArray(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  private final static int SIZE=100 ;
  public static int calculateEnergy(int mat[][],int n){
    int i_des,j_des,q ;
    int tot_energy=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        q=mat[i][j]/n ;
        i_des=q ;
        j_des=mat[i][j]-(n*q);
        tot_energy+=Math.abs(i_des-i)+Math.abs(j_des-j);
      }
    }
    return tot_energy ;
  }
  public static void main(String argc[]){
    int[][] mat=new int[][] {
      {
        4,7,0,3 },{
          8,5,6,1 },{
            9,11,10,2 },{
              15,13,14,12 }
            };
            int n=4 ;
            System.out.println("Total energy required="+calculateEnergy(mat,n)+" units");
          }
        }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   attribute SIZE : int := 100;
  static   operation calculateEnergy( mat : Sequence(Sequence(int)), n : int) : int
  pre: true
  post: true
  activity: (     var i_des : int ;
    var j_des : int ;
    var q : int ;
     var tot_energy : int ; tot_energy := 0 ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     q := mat[i+1][j+1] / n ; 
     i_des := q ; 
     j_des := mat[i+1][j+1] - (n * q) ; 
     tot_energy := tot_energy+(if i_des - i < 0 then -(i_des - i) else i_des - i endif + if j_des - j < 0 then -(j_des - j) else j_des - j endif) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return tot_energy );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{4,7,0,3},Sequence{8,5,6,1},Sequence{9,11,10,2},Sequence{15,13,14,12}} ;
     var n : int ; n := 4 ;
     OclFile["System.out"].println("Total energy required=" + calculateEnergy(mat, n) + " units") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void overflow(int H,int r,int h,int N,int R){
    double tank_cap=3.14*r*r*H ;
    double water_vol=3.14*r*r*h ;
    double balls_vol=N*(4/3)*3.14*R*R*R ;
    double vol=water_vol+balls_vol ;
    if(vol>tank_cap){
      System.out.println("Overflow");
    }
    else {
      System.out.println("Not in overflow state");
    }
  }
  public static void main(String[] args){
    int H=10,r=5,h=5,N=2,R=2 ;
    overflow(H,r,h,N,R);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation overflow( H : int, r : int, h : int, N : int, R : int) : void
  pre: true
  post: true
  activity: (     var tank_cap : double ; tank_cap := 3.14 * r * r * H ;
     var water_vol : double ; water_vol := 3.14 * r * r * h ;
    var balls_vol : double ; balls_vol := N * (4 / 3) * 3.14 * R * R * R ;
    var vol : double ; vol := water_vol + balls_vol ;
    if (vol > tank_cap) then (     OclFile["System.out"].println("Overflow") ) else (     OclFile["System.out"].println("Not in overflow state") ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var H : int ; H := 10 ;
    var r : int ; r := 5 ;
    var h : int ; h := 5 ;
    var N : int ; N := 2 ;
    var R : int ; R := 2 ;
     execute overflow(H, r, h, N, R) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Solver {
  void solve(Scanner sc){
    int N=sc.nextInt();
    String S=sc.next();
    int[] len=new int[(N-1)*N];
    int max=0 ;
    char[] chars=S.toCharArray();
    for(int i=0 ; i<N-1 ; i++){
      char c=chars[i];
      for(int offset=N-i-1 ; offset>max ; offset--){
        if(c!=chars[i+offset])continue ;
        int combo=i>0 ? len[(offset-1)*N+i-1]+1 : 1 ;
        if(combo>=offset){
          max=offset ;
          break ;
        }
        max=Math.max(max,len[(offset-1)*N+i]=combo);
      }
    }
    System.out.println(max);
  }
}
class Main {
  public static void main(String...args){
    Scanner in=new Scanner(System.in);
    new Solver().solve(in);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solver {
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.nextInt() ;
     var S : String ; S := sc.next() ;
    var len : Sequence(int) ; len := Integer.subrange(1,(N - 1) * N)->collect(0) ;
    var max : int ; max := 0 ;
    var chars : Sequence(String) ; chars := S->characters() ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     var c : String ; c := chars[i+1] ;
         var offset : int ; offset := N - i - 1 ; while offset > max do ( (     if (c /= chars[i + offset+1]) then     continue else skip ; 
     var combo : int ; combo := if i > 0 then len[((offset)->char2byte() - 1) * N + i - 1+1] + 1 else 1 endif ;
     if (combo >= offset) then (     max := offset ; 
     break ) else skip ; 
     max := Set{max, len[((offset)->char2byte() - 1) * N + i+1]}->max() )  ;     offset := offset - 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Solver.newSolver().solve(in) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
@ SuppressWarnings("unchecked")public class Main {
  public static String joinInt(int[] a,String separator){
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<a.length ; i++){
      if(i>0){
        sb.append(separator);
      }
      sb.append(a[i]);
    }
    return sb.toString();
  }
  static int[] nextIntArray(Scanner sc,int N){
    int[] arr=new int[N];
    for(int i=0 ; i<N ; i++){
      arr[i]=sc.nextInt();
    }
    return arr ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    char[] S=sc.next().toCharArray();
    int max=0 ;
    for(int i=0 ; i<S.length-1 ; i++){
      int[] lens=zalgo(S,i);
      for(int j=1 ; j<lens.length ; j++){
        int v=Math.min(lens[j],j);
        if(v>max){
          max=v ;
        }
      }
    }
    System.out.println(max);
  }
  static int[] zalgo(char[] chars,int offset){
    int n=chars.length-offset ;
    int[] ret=new int[n];
    ret[0]=n ;
    int i=1,j=0 ;
    while(i<n){
      while(i+j<n && chars[j+offset]==chars[i+j+offset])++j ;
      ret[i]=j ;
      if(j==0){
++i ;
        continue ;
      }
      int k=1 ;
      while(i+k<n && k+ret[k]<j){
        ret[i+k]=ret[k];
++k ;
      }
      i+=k ;
      j-=k ;
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation joinInt( a : Sequence(int), separator : String) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < a->size() do ( (     if (i > 0) then (     sb := sb + StringLib.newString(separator) ) else skip ; 
     sb := sb + StringLib.newString(a[i+1]) )  ;     i := i + 1 ) ; 
     return sb+"" );
  static   operation nextIntArray( sc : OclFile, N : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
         var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
     return arr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var S : Sequence(String) ; S := sc.getCurrent()->characters() ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < S->size() - 1 do ( (     var lens : Sequence(int) ; lens := zalgo(S, i) ;
         var j : int ; j := 1 ; while j < lens->size() do ( (     var v : int ; v := Set{lens[j+1], j}->min() ;
     if (v > max) then (     max := v ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static   operation zalgo( chars : Sequence(String), offset : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var n : int ; n := chars->size() - offset ;
     var ret : Sequence(int) ; ret := Integer.subrange(1,n)->collect(0) ;
    ret[0+1] := n ; 
    var i : int ; i := 1 ;
    var j : int ; j := 0 ;
    while (i < n) do (     while (i + j < n & chars[j + offset+1] = chars[i + j + offset+1]) do     j := j + 1 ; ; 
     ret[i+1] := j ; 
    if (j = 0) then (     i := i + 1 ; 
     continue ) else skip ; 
    var k : int ; k := 1 ;
    while (i + k < n & k + ret[k+1] < j) do (     ret[i + k+1] := ret[k+1] ; 
     k := k + 1 ) ; 
    i := i+(k) ; 
    j := j-(k) ; 
 ) ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
  }
  public void solve(){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=scan.nextInt();
    String S=scan.next();
    char[] d=S.toCharArray();
    int[][] dp=new int[N+1][N+1];
    for(int i=N-1 ; 0<=i ; i--){
      for(int j=N-1 ; i<j ; j--){
        if(d[i]==d[j]){
          dp[i][j]=Math.max(dp[i][j],dp[i+1][j+1]+1);
          continue ;
        }
      }
    }
    long ans=0 ;
    for(int i=0 ; i<N ; i++){
      for(int j=i+1 ; j<N ; j++){
        ans=Math.max(ans,Math.min(j-i,dp[i][j]));
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var S : String ; S := scan.getCurrent() ;
    var d : Sequence(String) ; d := S->characters() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
        var i : int ; i := N - 1 ; while 0 <= i do ( (         var j : int ; j := N - 1 ; while i < j do ( (     if (d[i+1] = d[j+1]) then (     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i + 1+1][j + 1+1] + 1}->max() ; 
     continue ) else skip )  ;     j := j - 1 ) )  ;     i := i - 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := i + 1 ; while j < N do ( (     ans := Set{ans, Set{j - i, dp[i+1][j+1]}->min()}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    String s=in.next();
    int len=1 ;
    int lenMax=0 ;
    for(int st=0 ; st+len-1<n ; st++){
      String temp=s.substring(st,st+len);
      while(s.indexOf(temp,st+len)>st){
        len++;
        temp=s.substring(st,st+len);
      }
      lenMax=Math.max(lenMax,len-1);
      if(lenMax>1)len=lenMax ;
    }
    System.out.println(lenMax);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var s : String ; s := in.getCurrent() ;
    var len : int ; len := 1 ;
    var lenMax : int ; lenMax := 0 ;
        var st : int ; st := 0 ; while st + len - 1 < n do ( (     var temp : String ; temp := s.subrange(st+1,st + len) ;
     while (s.subrange(st + len+1)->indexOf(temp+"") + st + len - 1  > st) do (     len := len + 1 ; 
     temp := s.subrange(st+1,st + len) ) ; 
     lenMax := Set{lenMax, (len)->char2byte() - 1}->max() ; 
     if (lenMax > 1) then     len := lenMax ; else skip )  ;     st := st + 1 ) ; 
    OclFile["System.out"].println(lenMax) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintStream ;
import java.util.Scanner ;
public class Main {
  static final PrintStream out=System.out ;
  static final Scanner sc=new Scanner(System.in);
  static final long Mod=1000_000_007L ;
  public static void main(String[] args){
    Main main=new Main();
    main.solve();
    System.exit(0);
  }
  void solve(){
    int N=nextInt();
    String S=next();
    char[] C=S.toCharArray();
    int[][] dp=new int[5005][5005];
    for(int i=N-1 ; i>=0 ; i--){
      for(int j=N-1 ; j>=0 ; j--){
        if(C[i]!=C[j])dp[i][j]=0 ;
        else dp[i][j]=dp[i+1][j+1]+1 ;
      }
    }
    int res=0 ;
    for(int i=0 ; i<N ; i++){
      for(int j=i+1 ; j<N ; j++){
        int now=Math.min(dp[i][j],Math.abs(j-i));
        res=Math.max(res,now);
      }
    }
    out.println(res);
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public long nextLong(){
    return Long.parseLong(next());
  }
  public String next(){
    return sc.next();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute out : OclFile := OclFile["System.out"];
  static    attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute Mod : long := 1000_000_007L;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solve() ; 
 OclProcess.exit(0) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : int ; N := nextInt() ;
     var S : String ; S := next() ;
    var C : Sequence(String) ; C := S->characters() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,5005)->collect(Integer.subrange(1,5005)->collect(0)) ;
        var i : int ; i := N - 1 ; while i >= 0 do ( (         var j : int ; j := N - 1 ; while j >= 0 do ( (     if (C[i+1] /= C[j+1]) then     dp[i+1][j+1] := 0 ; else     dp[i+1][j+1] := dp[i + 1+1][j + 1+1] + 1 ; )  ;     j := j - 1 ) )  ;     i := i - 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := i + 1 ; while j < N do ( (     var now : int ; now := Set{dp[i+1][j+1], if j - i < 0 then -(j - i) else j - i endif}->min() ;
     res := Set{res, now}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation next() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int q=Integer.parseInt(line);
      for(int i=0 ; i<q ; i++){
        StringTokenizer st=new StringTokenizer(br.readLine());
        int c=Integer.parseInt(st.nextToken());
        int a=Integer.parseInt(st.nextToken());
        int n=Integer.parseInt(st.nextToken());
        int count=0 ;
        while(true){
          if(c>0 && a>0 && n>0){
            c--;
            a--;
            n--;
            count++;
          }
          else if(c>1 && a>0){
            c-=2 ;
            a--;
            count++;
          }
          else if(c>2){
            c-=3 ;
            count++;
          }
          else {
            break ;
          }
        }
        System.out.println(count);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var q : int ; q := (line)->toInteger() ;
         var i : int ; i := 0 ; while i < q do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var c : int ; c := (st.next())->toInteger() ;
    var a : int ; a := (st.next())->toInteger() ;
    var n : int ; n := (st.next())->toInteger() ;
    var count : int ; count := 0 ;
    while (true) do (     if (c > 0 & a > 0 & n > 0) then (     c := c - 1 ; 
     a := a - 1 ; 
     n := n - 1 ; 
     count := count + 1 ) else     if (c > 1 & a > 0) then (     c := c-(2) ; 
     a := a - 1 ; 
     count := count + 1 ) else     if (c > 2) then (     c := c-(3) ; 
     count := count + 1 ) else (     break ) ;  ;  ) ; 
    OclFile["System.out"].println(count) ; 
 )  ;     i := i + 1 ) ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printArray(int arr[],int len){
    int i ;
    for(i=0 ; i<len ; i++){
      System.out.printf("%d ",arr[i]);
    }
  }
  public static void main(String[] args){
    int original_arr[]={
      1,2,3,4,5 };
      int len=original_arr.length ;
      int copied_arr[]=new int[len],i,j ;
      for(i=0 ; i<len ; i++){
        copied_arr[i]=original_arr[len-i-1];
      }
      System.out.printf("\nOriginal array: ");
      printArray(original_arr,len);
      System.out.printf("\nResultant array: ");
      printArray(copied_arr,len);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printArray( arr : Sequence(int), len : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
         i := 0 ; while i < len do ( (     OclFile["System.out"].printf("%d ", arr[i+1]) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var original_arr : Sequence(int) ; original_arr := Sequence{1,2,3,4,5} ;
     var len : int ; len := original_arr->size() ;
    var copied_arr : Sequence(void) ; copied_arr := Integer.subrange(1,len)->collect(0) ;
    var i : int ;
    var j : int ;
        i := 0 ; while i < len do ( (     copied_arr[i+1] := original_arr[len - i - 1+1] )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("\nOriginal array: ") ; 
    execute printArray(original_arr, len) ; 
    OclFile["System.out"].printf("\nResultant array: ") ; 
    execute printArray(copied_arr, len) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int dp[][]=new int[1000][1000];
  static boolean isprime(long num){
    int i ;
    if(num<=1)return false ;
    for(i=2 ; i*i<=num ; i++){
      if(num % i==0){
        return false ;
      }
    }
    return true ;
  }
  static long convert(String s,int i,int j){
    long temp=0 ;
    int k ;
    for(k=i ; k<=j ; k++){
      temp=temp*10+(s.charAt(k)-'0');
    }
    return temp ;
  }
  static int solve(String s,int i,int j){
    int k ;
    long num=convert(s,i,j);
    if(isprime(num)){
      return 0 ;
    }
    if(i==j && isprime(num))return 0 ;
    if(i==j && isprime(num)==false)return Integer.MAX_VALUE ;
    if(dp[i][j]!=0)return dp[i][j];
    int ans=Integer.MAX_VALUE ;
    for(k=i ; k<j ; k++){
      int left=solve(s,i,k);
      if(left==Integer.MAX_VALUE){
        continue ;
      }
      int right=solve(s,k+1,j);
      if(right==Integer.MAX_VALUE){
        continue ;
      }
      ans=Math.min(ans,1+left+right);
    }
    return dp[i][j]=ans ;
  }
  public static void main(String[] args){
    String s="2352" ;
    int n=s.length();
    int cuts=solve(s,0,n-1);
    if(cuts!=Integer.MAX_VALUE){
      System.out.print(cuts);
    }
    else {
      System.out.print("Not Possible");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute dp : int := Integer.subrange(1,1000)->collect(Integer.subrange(1,1000)->collect(0));
  static   operation isprime( num : long) : boolean
  pre: true
  post: true
  activity: (     var i : int ;
     if (num <= 1) then     return false else skip ; 
         i := 2 ; while i * i <= num do ( (     if (num mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation convert( s : String, i : int, j : int) : long
  pre: true
  post: true
  activity: (     var temp : long ; temp := 0 ;
     var k : int ;
         k := i ; while k <= j do ( (     temp := temp * 10 + (s->at(k+1) - ('0')->char2byte()) )  ;     k := k + 1 ) ; 
     return temp );
  static   operation solve( s : String, i : int, j : int) : int
  pre: true
  post: true
  activity: (     var k : int ;
     var num : long ; num := convert(s, i, j) ;
    if (isprime(num)) then (     return 0 ) else skip ; 
    if (i = j & isprime(num)) then     return 0 else skip ; 
    if (i = j & isprime(num) = false) then     return 2147483647 else skip ; 
    if (dp[i+1][j+1] /= 0) then     return dp[i+1][j+1] else skip ; 
    var ans : int ; ans := 2147483647 ;
        k := i ; while k < j do ( (     var left : int ; left := solve(s, i, k) ;
     if (left = 2147483647) then (     continue ) else skip ; 
    var right : int ; right := solve(s, k + 1, j) ;
    if (right = 2147483647) then (     continue ) else skip ; 
    ans := Set{ans, 1 + left + right}->min() ; 
 )  ;     k := k + 1 ) ; 
    return dp[i+1][j+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "2352" ;
     var n : int ; n := s->size() ;
     var cuts : int ; cuts := solve(s, 0, (n)->char2byte() - 1) ;
     if (cuts /= 2147483647) then (     OclFile["System.out"].print(cuts) ) else (     OclFile["System.out"].print("Not Possible") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int nthDigit(int a,int n,int b){
    for(int i=1 ; i<n ; i++)a=a/b ;
    return a % b ;
  }
  public static void main(String[] args){
    int a=100 ;
    int n=3 ;
    int b=4 ;
    System.out.print(nthDigit(a,n,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation nthDigit( a : int, n : int, b : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < n do (     a := a / b ;  ;     i := i + 1 ) ; 
     return a mod b );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 100 ;
     var n : int ; n := 3 ;
     var b : int ; b := 4 ;
     OclFile["System.out"].print(nthDigit(a, n, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String[] s=sc.next().split(",");
      double w=Double.parseDouble(s[1]);
      double h=Double.parseDouble(s[2]);
      if(w/(h*h)>=25.0){
        System.out.println(s[0]);
      }
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var s : Sequence(String) ; s := sc.getCurrent()->split(",") ;
     var w : double ; w := (s[1+1])->toReal() ;
     var h : double ; h := (s[2+1])->toReal() ;
     if (w / (h * h) >= 25.0) then (     OclFile["System.out"].println(s[0+1]) ) else skip ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    ArrayList<Student>student=new ArrayList<Student>();
    String buf ;
    while((buf=br.readLine())!=null){
      String[] input=buf.split(",");
      student.add(new Student(Integer.parseInt(input[0]),Double.parseDouble(input[1]),Double.parseDouble(input[2])));
    }
    for(Student s : student){
      if(isFat(s)){
        System.out.println(s.id);
      }
    }
  }
  public static boolean isFat(Student student){
    boolean isFat=false ;
    double bmi=student.weight/(student.height*student.height);
    if(bmi>=25.0){
      isFat=true ;
    }
    return isFat ;
  }
}
class Student {
  int id ;
  double weight ;
  double height ;
  Student(int id,double weight,double height){
    this.id=id ;
    this.weight=weight ;
    this.height=height ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var student : Sequence(Student) ; student := Sequence{} ;
    var buf : String ;
        buf := br.readLine() ;
    while ((buf) /= null) do (    skip ; (     var input : Sequence(String) ; input := buf->split(",") ;
     student := student->including(Student.newStudent((input[0+1])->toInteger(), (input[1+1])->toReal(), (input[2+1])->toReal())) ) ;     buf := br.readLine() ;
 ) ;  
    for (s : student) do ( (     if (isFat(s)) then (     OclFile["System.out"].println(s.id) ) else skip )  ) ; 
 );
  static   operation isFat( student : Student) : boolean
  pre: true
  post: true
  activity: (     var isFat : boolean ; isFat := false ;
     var bmi : double ; bmi := student.weight / (student.height * student.height) ;
     if (bmi >= 25.0) then (     isFat := true ) else skip ; 
     return isFat );
}
class Student {
   attribute id : int;
   attribute weight : double;
   attribute height : double;
   static operation newStudent( id : int, weight : double, height : double) : Student
  pre: true
  post: true
  activity:
  ( var self : Student ;
    self := createStudent();
    self.initialise(id, weight,height);
    return self );
  operation initialise( id : int, weight : double, height : double) : void
  pre: true  post: true
  activity: (     self.id := id ; 
     self.weight := weight ; 
     self.height := height );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; sc.hasNextLine(); ){
      String buffer=sc.nextLine();
      String[] data=buffer.split(",");
      int id=Integer.valueOf(data[0]);
      double weight=Double.valueOf(data[1]);
      double tall=Double.valueOf(data[2]);
      if(weight-25*tall*tall>=0){
        System.out.println(id);
      }
    }
  }
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNextLine() do ( (     var buffer : String ; buffer := sc.nextLine() ;
     var data : Sequence(String) ; data := buffer->split(",") ;
    var id : int ; id := (data[0+1])->toInteger() ;
    var weight : double ; weight := (data[1+1])->toReal() ;
    var tall : double ; tall := (data[2+1])->toReal() ;
    if (weight - 25 * tall * tall >= 0) then (     OclFile["System.out"].println(id) ) else skip ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    double[] data=null ;
    double bmi=0.0 ;
    while((data=parseData())!=null){
      bmi=data[1]/Math.pow(data[2],2.0);
      if(bmi>=25.0){
        System.out.println((int)data[0]);
      }
    }
  }
  private static double[] parseData(){
    double[] data=null ;
    String[] split=null ;
    String strIn=null ;
    if((strIn=parseStdin())!=null){
      split=strIn.split(",");
      data=new double[3];
      data[0]=Double.parseDouble(split[0]);
      data[1]=Double.parseDouble(split[1]);
      data[2]=Double.parseDouble(split[2]);
    }
    return data ;
  }
  private static String parseStdin(){
    String strNum=null ;
    try {
      String line=br.readLine();
      if(line!=null){
        if(! line.isEmpty()){
          strNum=line ;
        }
      }
    }
    catch(IOException e){
    }
    return strNum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var data : Sequence(double) ; data := null ;
     var bmi : double ; bmi := 0.0 ;
         data := parseData() ;
    while ((data) /= null) do (    skip ; (     bmi := data[1+1] / data[2+1]->pow(2.0) ; 
     if (bmi >= 25.0) then (     OclFile["System.out"].println(data[0+1]->oclAsType(int)) ) else skip ) ;     data := parseData() ;
 ) );
  static   operation parseData() : Sequence(double)
  pre: true
  post: true
  activity: (     var data : Sequence(double) ; data := null ;
     var split : Sequence(String) ; split := null ;
    var strIn : String ; strIn := null ;
    if ((strIn) /= null) then (     split := strIn->split(",") ; 
     data := Integer.subrange(1,3)->collect(0.0) ; 
    data[0+1] := (split[0+1])->toReal() ; 
    data[1+1] := (split[1+1])->toReal() ; 
    data[2+1] := (split[2+1])->toReal() ; 
 ) else skip ; 
    return data 
 );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var strNum : String ; strNum := null ;
     try (     var line : String ; line := br.readLine() ;
     if (line /= null) then (     if (not(line->isEmpty())) then (     strNum := line ) else skip ) else skip )   catch (e : IOException) do skip
     return strNum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    System.out.println((a-30)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println((a - 30) / 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] a=new int[3];
    int ans,q ;
    q=sc.nextInt();
    for(; q>0 ; q--){
      ans=0 ;
      for(int i=0 ; i<3 ; i++){
        a[i]=sc.nextInt();
      }
      for(; ; ){
        if(a[0]>=1 && a[1]>=1 && a[2]>=1){
          ans++;
          a[0]--;
          a[1]--;
          a[2]--;
        }
        else if(a[0]>=2 && a[1]>=1){
          ans++;
          a[0]-=2 ;
          a[1]--;
        }
        else if(a[0]>=3){
          ans++;
          a[0]-=3 ;
        }
        else break ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := Integer.subrange(1,3)->collect(0) ;
    var ans : int ;
    var q : int ;
    q := sc.getCurrent()->toInteger() ; 
      while q > 0 do ( (     ans := 0 ; 
         var i : int ; i := 0 ; while i < 3 do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
       while true do ( (     if (a[0+1] >= 1 & a[1+1] >= 1 & a[2+1] >= 1) then (     ans := ans + 1 ; 
     a[0+1] := a[0+1] - 1 ; 
     a[1+1] := a[1+1] - 1 ; 
     a[2+1] := a[2+1] - 1 ) else     if (a[0+1] >= 2 & a[1+1] >= 1) then (     ans := ans + 1 ; 
     a[0+1] := a[0+1]-(2) ; 
     a[1+1] := a[1+1] - 1 ) else     if (a[0+1] >= 3) then (     ans := ans + 1 ; 
     a[0+1] := a[0+1]-(3) ) else     break ;  ;  )  ) ; 
     OclFile["System.out"].println(ans) )  ;     q := q - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    SC sc=new SC(System.in);
    int a=sc.nextInt();
    pl((a-30)/2);
  }
  static class SC {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public SC(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        throw new UncheckedIOException(e);
      }
    }
  }
  public static void pl(Object o){
    System.out.println(o);
  }
  public static void pl(){
    System.out.println();
  }
  public static void p(Object o){
    System.out.print(o);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : SC ; sc := SC.newSC(OclFile["System.in"]) ;
     var a : int ; a := sc.nextInt() ;
     execute pl((a - 30) / 2) );
  static class SC {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newSC( in : OclFile) : SC
  pre: true
  post: true
  activity:
  ( var self : SC ;
    self := createSC();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 );
}
  static   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation pl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int F=sc.nextInt();
    System.out.println((F-30)/2);
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var F : int ; F := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println((F - 30) / 2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int F=parseInt(br.readLine());
    System.out.println((F-30)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var F : int ; F := parseInt(br.readLine()) ;
    OclFile["System.out"].println((F - 30) / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      while(scanner.hasNextLine()){
        int f=Integer.valueOf(scanner.nextLine());
        System.out.println(solver(f));
      }
    }
  }
  private static int solver(int f){
    return(f-30)/2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (scanner.hasNextLine()) do (     var f : int ; f := (scanner.nextLine())->toInteger() ;
     OclFile["System.out"].println(solver(f)) ) ))  );
  static   operation solver( f : int) : int
  pre: true
  post: true
  activity: (     return (f - 30) / 2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean checkArray(int arr[],int n){
    int zero=0,one=0,minusone=0,other=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==0)zero++;
      else if(arr[i]==1)one++;
      else if(arr[i]==-1)minusone++;
      else other++;
    }
    if(other>1)return false ;
    else if(other!=0 && minusone!=0)return false ;
    else if(minusone>=1 && one==0)return false ;
    return true ;
  }
  public static void main(String[] args){
    int arr[]={
      0,1,1,10 };
      int n=arr.length ;
      if(checkArray(arr,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkArray( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var zero : int ; zero := 0 ;
    var one : int ; one := 0 ;
    var minusone : int ; minusone := 0 ;
    var other : int ; other := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 0) then     zero := zero + 1 ; else     if (arr[i+1] = 1) then     one := one + 1 else     if (arr[i+1] = -1) then     minusone := minusone + 1 else     other := other + 1 ; ;  ;  )  ;     i := i + 1 ) ; 
     if (other > 1) then     return false else     if (other /= 0 & minusone /= 0) then     return false else     if (minusone >= 1 & one = 0) then     return false else skip ; ;  ;  
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{0,1,1,10} ;
     var n : int ; n := arr->size() ;
     if (checkArray(arr, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  static final Scanner s=new Scanner(System.in);
  static IntStream REPS(int v){
    return IntStream.range(0,v);
  }
  static IntStream INS(int n){
    return REPS(n).map(i->getInt());
  }
  static int getInt(){
    return Integer.parseInt(s.next());
  }
  public static void main(String[] $){
    System.out.println(INS(10).sorted().skip(7).sum()+" "+INS(10).sorted().skip(7).sum());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation REPS( v : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return Integer.subrange(0, v-1) );
  static   operation INS( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     return REPS(n)->collect( _x1 | (lambda i : OclAny in getInt())->apply(_x1) ) );
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(INS(10)->sort().subrange(7+1)->sum() + " " + INS(10)->sort().subrange(7+1)->sum()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.UncheckedIOException ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args){
    SC sc=new SC(System.in);
    int[] W=new int[10];
    int[] K=new int[10];
    for(int i=0 ; i<10 ; i++){
      W[i]=sc.nextInt();
    }
    for(int i=0 ; i<10 ; i++){
      K[i]=sc.nextInt();
    }
    Arrays.sort(W);
    Arrays.sort(K);
    pl(W[9]+W[8]+W[7]+" "+(K[9]+K[8]+K[7]));
  }
  public static void pl(Object o){
    System.out.println(o);
  }
  public static void pl(){
    System.out.println();
  }
  public static void p(Object o){
    System.out.print(o);
  }
  static class SC {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public SC(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        throw new UncheckedIOException(e);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : SC ; sc := SC.newSC(OclFile["System.in"]) ;
     var W : Sequence(int) ; W := Integer.subrange(1,10)->collect(0) ;
    var K : Sequence(int) ; K := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < 10 do ( (     W[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 10 do ( (     K[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    W := W->sort() ; 
    K := K->sort() ; 
    execute pl(W[9+1] + W[8+1] + W[7+1] + " " + (K[9+1] + K[8+1] + K[7+1])) ; 
 );
  static   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation pl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
  static class SC {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newSC( in : OclFile) : SC
  pre: true
  post: true
  activity:
  ( var self : SC ;
    self := createSC();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    for(int i=0 ; i<2 ; i++){
      int[] num=new int[10];
      for(int j=0 ; j<10 ; j++){
        num[j]=scanner.nextInt();
      }
      Arrays.sort(num);
      int ans=0 ;
      for(int j=9 ; j>6 ; j--)ans+=num[j];
      System.out.print(ans);
      System.out.print(i==0 ? ' ' : '\n');
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var i : int ; i := 0 ; while i < 2 do ( (     var num : Sequence(int) ; num := Integer.subrange(1,10)->collect(0) ;
         var j : int ; j := 0 ; while j < 10 do ( (     num[j+1] := scanner.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    num := num->sort() ; 
    var ans : int ; ans := 0 ;
        var j : int ; j := 9 ; while j > 6 do (     ans := ans+(num[j+1]) ;  ;     j := j - 1 ) ; 
    OclFile["System.out"].print(ans) ; 
    OclFile["System.out"].print(if i = 0 then ' ' else '
' endif) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      int[] wPoint=new int[10];
      for(int i=0 ; i<10 ; i++){
        wPoint[i]=Integer.parseInt(scan.nextLine());
      }
      int[] kPoint=new int[10];
      for(int i=0 ; i<10 ; i++){
        kPoint[i]=Integer.parseInt(scan.nextLine());
      }
      Point w=new Point(wPoint);
      Point k=new Point(kPoint);
      System.out.println(w.getPoint()+" "+k.getPoint());
    }
  }
}
class Point {
  private int p ;
  public Point(){
    p=0 ;
  }
  public Point(int[] num){
    getSumPoint(num);
  }
  public int getPoint(){
    return p ;
  }
  public void getSumPoint(int[] num){
    int sum=0 ;
    int[] maxPoint={
      0,0,0 };
      Scanner scan=new Scanner(System.in);
      for(int i=0 ; i<10 ; i++){
        if(maxPoint[0]<num[i]){
          maxPoint[2]=maxPoint[1];
          maxPoint[1]=maxPoint[0];
          maxPoint[0]=num[i];
        }
        else if(maxPoint[1]<num[i]){
          maxPoint[2]=maxPoint[1];
          maxPoint[1]=num[i];
        }
        else if(maxPoint[2]<num[i]){
          maxPoint[2]=num[i];
        }
      }
      for(int i=0 ; i<3 ; i++){
        sum+=maxPoint[i];
      }
      p=sum ;
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var wPoint : Sequence(int) ; wPoint := Integer.subrange(1,10)->collect(0) ;
         var i : int ; i := 0 ; while i < 10 do ( (     wPoint[i+1] := (scan.nextLine())->toInteger() )  ;     i := i + 1 ) ; 
    var kPoint : Sequence(int) ; kPoint := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < 10 do ( (     kPoint[i+1] := (scan.nextLine())->toInteger() )  ;     i := i + 1 ) ; 
    var w : Point ; w := Point.newPoint(wPoint) ;
    var k : Point ; k := Point.newPoint(kPoint) ;
    OclFile["System.out"].println(w.getPoint() + " " + k.getPoint()) ; 
 ) );
}
class Point {
   attribute p : int;
   static operation newPoint() : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     p := 0 );
   static operation newPoint( num : Sequence(int)) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(num);
    return self );
  operation initialise( num : Sequence(int)) : void
  pre: true  post: true
  activity: (     execute getSumPoint(num) );
   operation getPoint() : int
  pre: true
  post: true
  activity: (     return p );
   operation getSumPoint( num : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var maxPoint : Sequence(int) ; maxPoint := Sequence{0,0,0} ;
    var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
        var i : int ; i := 0 ; while i < 10 do ( (     if (maxPoint[0+1] < num[i+1]) then (     maxPoint[2+1] := maxPoint[1+1] ; 
     maxPoint[1+1] := maxPoint[0+1] ; 
     maxPoint[0+1] := num[i+1] ) else     if (maxPoint[1+1] < num[i+1]) then (     maxPoint[2+1] := maxPoint[1+1] ; 
     maxPoint[1+1] := num[i+1] ) else     if (maxPoint[2+1] < num[i+1]) then (     maxPoint[2+1] := num[i+1] ) else skip ; ;  )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do ( (     sum := sum+(maxPoint[i+1]) )  ;     i := i + 1 ) ; 
    p := sum ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    int i=0 ;
    int[] w=new int[10],k=new int[10];
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      String line ;
      while((line=br.readLine())!=null){
        if(i<10){
          w[i]=Integer.parseInt(line);
        }
        else {
          k[i-10]=Integer.parseInt(line);
        }
        i++;
        if(i==20){
          break ;
        }
      }
      int maxk=0,maxw=0 ;
      int resultk=0,resultw=0 ;
      int storek=0,storew=0 ;
      for(int l=0 ; l<3 ; l++){
        maxk=0 ;
        maxw=0 ;
        storek=0 ;
        storew=0 ;
        for(int j=0 ; j<w.length ; j++){
          if(maxk<k[j]){
            storek=j ;
            maxk=k[j];
          }
          if(maxw<w[j]){
            storew=j ;
            maxw=w[j];
          }
        }
        resultk+=maxk ;
        resultw+=maxw ;
        k[storek]=-1 ;
        w[storew]=-1 ;
      }
      System.out.println(resultw+" "+resultk);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     var w : Sequence(int) ; w := Integer.subrange(1,10)->collect(0) ;
    var k : Sequence(int) ; k := Integer.subrange(1,10)->collect(0) ;
     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var line : String ;
         line := br.readLine() ;
    while ((line) /= null) do (    skip ; (     if (i < 10) then (     w[i+1] := (line)->toInteger() ) else (     k[i - 10+1] := (line)->toInteger() ) ;  
     i := i + 1 ; 
     if (i = 20) then (     break ) else skip ) ;     line := br.readLine() ;
 ) ;  
    var maxk : int ; maxk := 0 ;
    var maxw : int ; maxw := 0 ;
    var resultk : int ; resultk := 0 ;
    var resultw : int ; resultw := 0 ;
    var storek : int ; storek := 0 ;
    var storew : int ; storew := 0 ;
        var l : int ; l := 0 ; while l < 3 do ( (     maxk := 0 ; 
     maxw := 0 ; 
    storek := 0 ; 
    storew := 0 ; 
        var j : int ; j := 0 ; while j < w->size() do ( (     if (maxk < k[j+1]) then (     storek := j ; 
     maxk := k[j+1] ) else skip ; 
     if (maxw < w[j+1]) then (     storew := j ; 
     maxw := w[j+1] ) else skip )  ;     j := j + 1 ) ; 
    resultk := resultk+(maxk) ; 
    resultw := resultw+(maxw) ; 
    k[storek+1] := -1 ; 
    w[storew+1] := -1 ; 
 )  ;     l := l + 1 ) ; 
    OclFile["System.out"].println(resultw + " " + resultk) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      int n=scan.nextInt();
      if(n==0){
        break ;
      }
      int m=scan.nextInt()-(n<<1);
      char[] ch=(scan.next()).toCharArray();
      int count=0 ;
      for(int i=0 ; i<m ; i++){
        if(ch[i]=='I'){
          for(int j=0 ; j<n ; j++){
            if(ch[i+1+(j<<1)]!='O' || ch[i+((j+1)<<1)]!='I'){
              break ;
            }
            else if(j==n-1){
              count++;
              i++;
            }
          }
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var n : int ; n := scan.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var m : int ; m := scan.getCurrent()->toInteger() - ((n*(2->pow(1)))->oclAsType(long)) ;
    var ch : Sequence(String) ; ch := (scan.getCurrent())->characters() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     if (ch[i+1] = 'I') then (         var j : int ; j := 0 ; while j < n do ( (     if (ch[i + 1 + ((j*(2->pow(1)))->oclAsType(long))+1] /= 'O' or ch[i + (((j + 1)*(2->pow(1)))->oclAsType(long))+1] /= 'I') then (     break ) else     if (j = n - 1) then (     count := count + 1 ; 
     i := i + 1 ) else skip ; )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
class Main {
  static long ans=0 ;
  public static void main(String[] args){
    SC sc=new SC(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    long[] dp=new long[K+1];
    for(int i=0 ; i<=K ; i++){
      dp[i]=0 ;
    }
    if(N>K){
      pl(0);
    }
    else {
      long ans=1 ;
      long mod=1000000007 ;
      for(int i=K ; i>=K-N+1 ; i--){
        ans=(ans*((long)i))% mod ;
      }
      pl(ans);
    }
  }
  public static void dfs(int nokori,int kosu,int kei){
  }
  public static void pl(Object o){
    System.out.println(o);
  }
  public static void pl(){
    System.out.println();
  }
  public static void p(Object o){
    System.out.print(o);
  }
  static class SC {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public SC(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        throw new UncheckedIOException(e);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ans : long := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : SC ; sc := SC.newSC(OclFile["System.in"]) ;
     var N : int ; N := sc.nextInt() ;
    var K : int ; K := sc.nextInt() ;
    var dp : Sequence(long) ; dp := Integer.subrange(1,K + 1)->collect(0) ;
        var i : int ; i := 0 ; while i <= K do ( (     dp[i+1] := 0 )  ;     i := i + 1 ) ; 
    if (N > K) then (     execute pl(0) ) else (     var ans : long ; ans := 1 ;
     var mod : long ; mod := 1000000007 ;
         var i : int ; i := K ; while i >= K - N + 1 do ( (     ans := (ans * (i->oclAsType(long))) mod mod )  ;     i := i - 1 ) ; 
     execute pl(ans) ) ;  
 );
  static   operation dfs( nokori : int, kosu : int, kei : int) : void
  pre: true
  post: true
  activity: skip;
  static   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation pl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
  static class SC {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newSC( in : OclFile) : SC
  pre: true
  post: true
  activity:
  ( var self : SC ;
    self := createSC();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  Scanner kbd=new Scanner(System.in);
  void run(){
    int days=kbd.nextInt();
    int jap=kbd.nextInt();
    int math=kbd.nextInt();
    int maxJ=kbd.nextInt();
    int maxM=kbd.nextInt();
    while(jap>0 || math>0){
      jap-=maxJ ;
      math-=maxM ;
      days--;
    }
    System.out.println(days);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute kbd : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var days : int ; days := kbd.getCurrent()->toInteger() ;
     var jap : int ; jap := kbd.getCurrent()->toInteger() ;
    var math : int ; math := kbd.getCurrent()->toInteger() ;
    var maxJ : int ; maxJ := kbd.getCurrent()->toInteger() ;
    var maxM : int ; maxM := kbd.getCurrent()->toInteger() ;
    while (jap > 0 or math > 0) do (     jap := jap-(maxJ) ; 
     math := math-(maxM) ; 
     days := days - 1 ) ; 
    OclFile["System.out"].println(days) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.playDaysCalculation();
    return ;
  }
  private void playDaysCalculation(){
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    try {
      String inputStr=bufferedReader.readLine();
      int winterBreakDays=Integer.parseInt(inputStr);
      String inputStr2=bufferedReader.readLine();
      double languageWorkbookPageNum=Double.parseDouble(inputStr2);
      String inputStr3=bufferedReader.readLine();
      double arithmeticWorkbookPageNum=Double.parseDouble(inputStr3);
      String inputStr4=bufferedReader.readLine();
      double languageProgressNum=Double.parseDouble(inputStr4);
      String inputStr5=bufferedReader.readLine();
      double arithmeticProgressNum=Double.parseDouble(inputStr5);
      double languageWorkbookEndDays=languageWorkbookPageNum/languageProgressNum ;
      double arithmeticWorkbookEndDays=arithmeticWorkbookPageNum/arithmeticProgressNum ;
      int workbookEndDays=0 ;
      if(languageWorkbookEndDays>arithmeticWorkbookEndDays){
        workbookEndDays=(int)Math.ceil(languageWorkbookEndDays);
      }
      else if(languageWorkbookEndDays<arithmeticWorkbookEndDays){
        workbookEndDays=(int)Math.ceil(arithmeticWorkbookEndDays);
      }
      else if(languageWorkbookEndDays==arithmeticWorkbookEndDays){
        workbookEndDays=(int)Math.ceil(languageWorkbookEndDays);
      }
      System.out.println(winterBreakDays-workbookEndDays);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.playDaysCalculation() ; 
     return );
   operation playDaysCalculation() : void
  pre: true
  post: true
  activity: (     var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var inputStr : String ; inputStr := bufferedReader.readLine() ;
     var winterBreakDays : int ; winterBreakDays := (inputStr)->toInteger() ;
    var inputStr2 : String ; inputStr2 := bufferedReader.readLine() ;
    var languageWorkbookPageNum : double ; languageWorkbookPageNum := (inputStr2)->toReal() ;
    var inputStr3 : String ; inputStr3 := bufferedReader.readLine() ;
    var arithmeticWorkbookPageNum : double ; arithmeticWorkbookPageNum := (inputStr3)->toReal() ;
    var inputStr4 : String ; inputStr4 := bufferedReader.readLine() ;
    var languageProgressNum : double ; languageProgressNum := (inputStr4)->toReal() ;
    var inputStr5 : String ; inputStr5 := bufferedReader.readLine() ;
    var arithmeticProgressNum : double ; arithmeticProgressNum := (inputStr5)->toReal() ;
    var languageWorkbookEndDays : double ; languageWorkbookEndDays := languageWorkbookPageNum / languageProgressNum ;
    var arithmeticWorkbookEndDays : double ; arithmeticWorkbookEndDays := arithmeticWorkbookPageNum / arithmeticProgressNum ;
    var workbookEndDays : int ; workbookEndDays := 0 ;
    if (languageWorkbookEndDays > arithmeticWorkbookEndDays) then (     workbookEndDays := (languageWorkbookEndDays)->ceil()->oclAsType(int) ) else     if (languageWorkbookEndDays < arithmeticWorkbookEndDays) then (     workbookEndDays := (arithmeticWorkbookEndDays)->ceil()->oclAsType(int) ) else     if (languageWorkbookEndDays = arithmeticWorkbookEndDays) then (     workbookEndDays := (languageWorkbookEndDays)->ceil()->oclAsType(int) ) else skip ; ;  ;  
    OclFile["System.out"].println((winterBreakDays)->char2byte() - workbookEndDays) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    SC sc=new SC(System.in);
    int L=sc.nextInt();
    int J=sc.nextInt();
    int M=sc.nextInt();
    int JS=sc.nextInt();
    int MS=sc.nextInt();
    pl(L-Math.max((J+JS-1)/JS,(M+MS-1)/MS));
  }
  public static void pl(Object o){
    System.out.println(o);
  }
  public static void pl(){
    System.out.println();
  }
  public static void p(Object o){
    System.out.print(o);
  }
  static class SC {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public SC(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        throw new UncheckedIOException(e);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : SC ; sc := SC.newSC(OclFile["System.in"]) ;
     var L : int ; L := sc.nextInt() ;
    var J : int ; J := sc.nextInt() ;
    var M : int ; M := sc.nextInt() ;
    var JS : int ; JS := sc.nextInt() ;
    var MS : int ; MS := sc.nextInt() ;
    execute pl(L - Set{(J + JS - 1) / JS, (M + MS - 1) / MS}->max()) ; 
 );
  static   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation pl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
  static class SC {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newSC( in : OclFile) : SC
  pre: true
  post: true
  activity:
  ( var self : SC ;
    self := createSC();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  Scanner sc=new Scanner(in);
  void run(){
    int l=sc.nextInt(),a=sc.nextInt(),b=sc.nextInt(),c=sc.nextInt(),d=sc.nextInt();
    if(a/c<b/d){
      if(b % d==0)out.printf("%d\n",l-b/d);
      else out.printf("%d\n",l-b/d-1);
    }
    else if(b/d<a/c){
      if(a % c==0)out.printf("%d\n",l-a/c);
      else out.printf("%d\n",l-a/c-1);
    }
    else {
      if(a % c==0 && b % d==0)out.printf("%d\n",l-a/c);
      else out.printf("%d\n",l-a/c-1);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   operation run() : void
  pre: true
  post: true
  activity: (     var l : int ; l := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
     if (a / c < b / d) then (     if (b mod d = 0) then     out.printf("%d\n", l - b / d) ; else     out.printf("%d\n", l - b / d - 1) ; ) else     if (b / d < a / c) then (     if (a mod c = 0) then     out.printf("%d\n", l - a / c) ; else     out.printf("%d\n", l - a / c - 1) ; ) else (     if (a mod c = 0 & b mod d = 0) then     out.printf("%d\n", l - a / c) ; else     out.printf("%d\n", l - a / c - 1) ; ) ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int sameOccurrence(int arr[],int n,int x,int y){
    int[] countX=new int[n];
    int[] countY=new int[n];
    Map<Integer,Integer>m=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      if(arr[i]==x){
        if(i!=0)countX[i]=countX[i-1]+1 ;
        else countX[i]=1 ;
      }
      else {
        if(i!=0)countX[i]=countX[i-1];
        else countX[i]=0 ;
      }
      if(arr[i]==y){
        if(i!=0)countY[i]=countY[i-1]+1 ;
        else countY[i]=1 ;
      }
      else {
        if(i!=0)countY[i]=countY[i-1];
        else countY[i]=0 ;
      }
      if(m.containsKey(countX[i]-countY[i])){
        m.put(countX[i]-countY[i],m.get(countX[i]-countY[i])+1);
      }
      else {
        m.put(countX[i]-countY[i],1);
      }
    }
    int result=m.get(0);
    for(Map.Entry<Integer,Integer>it : m.entrySet())result=result+((it.getValue())*((it.getValue())-1))/2 ;
    return(result);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,2,3,4,1 };
      int n=arr.length ;
      int x=2,y=3 ;
      System.out.println(sameOccurrence(arr,n,x,y));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sameOccurrence( arr : Sequence(int), n : int, x : int, y : int) : int
  pre: true
  post: true
  activity: (     var countX : Sequence(int) ; countX := Integer.subrange(1,n)->collect(0) ;
     var countY : Sequence(int) ; countY := Integer.subrange(1,n)->collect(0) ;
    var m : Map(int,int) ; m := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = x) then (     if (i /= 0) then     countX[i+1] := countX[i - 1+1] + 1 ; else     countX[i+1] := 1 ; ) else (     if (i /= 0) then     countX[i+1] := countX[i - 1+1] ; else     countX[i+1] := 0 ; ) ;  
     if (arr[i+1] = y) then (     if (i /= 0) then     countY[i+1] := countY[i - 1+1] + 1 ; else     countY[i+1] := 1 ; ) else (     if (i /= 0) then     countY[i+1] := countY[i - 1+1] ; else     countY[i+1] := 0 ; ) ;  
     if (m->keys()->includes(countX[i+1] - countY[i+1])) then (     m := m->union(Map{countX[i+1] - countY[i+1] |-> m->at(countX[i+1] - countY[i+1]) + 1}) ) else (     m := m->union(Map{countX[i+1] - countY[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var result : int ; result := m->at(0) ;
    for (it : m->asSet()) do (     result := result + ((it.getValue()) * ((it.getValue()) - 1)) / 2 ;  ) ; 
    return (result) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,2,3,4,1} ;
     var n : int ; n := arr->size() ;
     var x : int ; x := 2 ;
    var y : int ; y := 3 ;
     OclFile["System.out"].println(sameOccurrence(arr, n, x, y)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int page ;
  int max ;
  boolean flg=true ;
  void doIt(){
    Scanner sc=new Scanner(System.in);
    int l,ans=0 ;
    l=sc.nextInt();
    Main ko=new Main();
    Main su=new Main();
    ko.page=sc.nextInt();
    su.page=sc.nextInt();
    ko.max=sc.nextInt();
    su.max=sc.nextInt();
    while(ko.flg || su.flg){
      ko.study();
      su.study();
      ans++;
    }
    System.out.println(l-(ans));
  }
  public void study(){
    this.page-=this.max ;
    if(this.page<=0){
      this.page=0 ;
      this.flg=false ;
    }
  }
  public static void main(String[] args){
    new Main().doIt();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute page : int;
   attribute max : int;
   attribute flg : boolean := true;
   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var l : int ;
    var ans : int ; ans := 0 ;
    l := sc.getCurrent()->toInteger() ; 
    var ko : Main ; ko := Main.newMain() ;
    var su : Main ; su := Main.newMain() ;
    ko.page := sc.getCurrent()->toInteger() ; 
    su.page := sc.getCurrent()->toInteger() ; 
    ko.max := sc.getCurrent()->toInteger() ; 
    su.max := sc.getCurrent()->toInteger() ; 
    while (ko.flg or su.flg) do (     ko.study() ; 
     su.study() ; 
     ans := ans + 1 ) ; 
    OclFile["System.out"].println(l - (ans)) ; 
 );
   operation study() : void
  pre: true
  post: true
  activity: (     self.page := self.page-(self.max) ; 
     if (self.page <= 0) then (     self.page := 0 ; 
     self.flg := false ) else skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doIt() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String[] args){
    SC sc=new SC(System.in);
    long MOD=1000000007 ;
    long n=sc.nextLong();
    long k=sc.nextLong();
    long ans=1 ;
    for(long i=0 ; i<n ; i++){
      ans=(ans*k)% MOD ;
    }
    pl(ans);
  }
  public static void pl(Object o){
    System.out.println(o);
  }
  public static void pl(){
    System.out.println();
  }
  public static void p(Object o){
    System.out.print(o);
  }
  static class SC {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public SC(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        throw new UncheckedIOException(e);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : SC ; sc := SC.newSC(OclFile["System.in"]) ;
     var MOD : long ; MOD := 1000000007 ;
    var n : long ; n := sc.nextLong() ;
    var k : long ; k := sc.nextLong() ;
    var ans : long ; ans := 1 ;
        var i : long ; i := 0 ; while i < n do ( (     ans := (ans * k) mod MOD )  ;     i := i + 1 ) ; 
    execute pl(ans) ; 
 );
  static   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation pl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
  static class SC {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newSC( in : OclFile) : SC
  pre: true
  post: true
  activity:
  ( var self : SC ;
    self := createSC();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Geeks {
  static int CountTheElements(int arr[],int n,int k){
    int counter=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] % k==0)counter++;
    }
    return counter ;
  }
  public static void main(String args[]){
    int arr[]={
      2,6,7,12,14,18 };
      int n=arr.length ;
      int k=3 ;
      System.out.println(CountTheElements(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Geeks {
  static   operation CountTheElements( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var counter : int ; counter := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod k = 0) then     counter := counter + 1 ; else skip )  ;     i := i + 1 ) ; 
     return counter );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,6,7,12,14,18} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println(CountTheElements(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class SashaHisTrip {
  static int findMinCost(int n,int f){
    if(n<=f)return n-1 ;
    int min_cost=f-1 ;
    for(int i=1 ; i<=n-f ; i++){
      min_cost+=i ;
    }
    return min_cost ;
  }
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] inp=br.readLine().split(" ");
    int n=Integer.parseInt(inp[0]);
    int f=Integer.parseInt(inp[1]);
    int cost=findMinCost(n,f);
    System.out.println(cost);
  }
}
------------------------------------------------------------
OCL File:
---------
 class SashaHisTrip {
  static   operation findMinCost( n : int, f : int) : int
  pre: true
  post: true
  activity: (     if (n <= f) then     return n - 1 else skip ; 
     var min_cost : int ; min_cost := f - 1 ;
         var i : int ; i := 1 ; while i <= n - f do ( (     min_cost := min_cost+(i) )  ;     i := i + 1 ) ; 
     return min_cost );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var inp : Sequence(String) ; inp := br.readLine()->split(" ") ;
    var n : int ; n := (inp[0+1])->toInteger() ;
    var f : int ; f := (inp[1+1])->toInteger() ;
    var cost : int ; cost := findMinCost(n, f) ;
    OclFile["System.out"].println(cost) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int n,m ;
  char[] c ;
  int[][] dp ;
  void solve(){
    Scanner sc=new Scanner(System.in);
    while(true){
      n=sc.nextInt();
      if(n==0)break ;
      m=sc.nextInt();
      c=sc.next().toCharArray();
      int idx=0 ;
      while(c[idx]!='I')idx++;
      int ans=0 ;
      int num=n*2+1 ;
      for(int i=idx ; i<c.length ; i++){
        if(i==c.length-1){
          if(c[i]=='O'){
            if(i-idx+1>=num)ans+=(i-idx+1-num)/2+1 ;
          }
          else {
            if(i-idx+1>=num)ans+=(i-idx+1-num)/2+1 ;
          }
        }
        else if(c[i]=='O' && c[i+1]=='O'){
          if(i-idx+1>=num)ans+=(i-idx+1-num)/2+1 ;
          idx=i ;
          while(idx<c.length && c[idx]!='I')idx++;
          i=idx-1 ;
        }
        else if(c[i]=='I' && c[i+1]=='I'){
          if(i-idx+1>=num)ans+=(i-idx+1-num)/2+1 ;
          idx=i+1 ;
          i=idx-1 ;
        }
      }
      System.out.println(ans);
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute c : Sequence(String);
   attribute dp : Sequence(Sequence(int));
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
    m := sc.getCurrent()->toInteger() ; 
    c := sc.getCurrent()->characters() ; 
    var idx : int ; idx := 0 ;
    while (c[idx+1] /= 'I') do     idx := idx + 1 ; ; 
    var ans : int ; ans := 0 ;
    var num : int ; num := n * 2 + 1 ;
        var i : int ; i := idx ; while i < c->size() do ( (     if (i = c->size() - 1) then (     if (c[i+1] = 'O') then (     if (i - idx + 1 >= num) then     ans := ans+((i - idx + 1 - num) / 2 + 1) ; else skip ) else (     if (i - idx + 1 >= num) then     ans := ans+((i - idx + 1 - num) / 2 + 1) ; else skip ) ) else     if (c[i+1] = 'O' & c[i + 1+1] = 'O') then (     if (i - idx + 1 >= num) then     ans := ans+((i - idx + 1 - num) / 2 + 1) ; else skip ; 
     idx := i ; 
     while (idx < c->size() & c[idx+1] /= 'I') do     idx := idx + 1 ; ; 
     i := idx - 1 ) else     if (c[i+1] = 'I' & c[i + 1+1] = 'I') then (     if (i - idx + 1 >= num) then     ans := ans+((i - idx + 1 - num) / 2 + 1) ; else skip ; 
     idx := i + 1 ; 
     i := idx - 1 ) else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Problem {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int v=sc.nextInt();
    int price=0 ;
    int cur=0,i=1 ;
    while(i<=n){
      if(i+cur<n){
        int lit=Math.min(v-cur,n-i-cur);
        price+=i*lit ;
        cur+=lit ;
      }
      if(i+cur>=n)break ;
      cur--;
      i++;
    }
    System.out.println(price);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var v : int ; v := sc.getCurrent()->toInteger() ;
    var price : int ; price := 0 ;
    var cur : int ; cur := 0 ;
    var i : int ; i := 1 ;
    while (i <= n) do (     if (i + cur < n) then (     var lit : int ; lit := Set{v - cur, n - i - cur}->min() ;
     price := price+(i * lit) ; 
     cur := cur+(lit) ) else skip ; 
     if (i + cur >= n) then     break else skip ; 
     cur := cur - 1 ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println(price) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Sasha {
  public static void main(String[] agrs){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int v=sc.nextInt();
    System.out.println(calculate(n,v));
  }
  public static int calculate(int n,int v){
    int cost=v ;
    if(cost>=n-1)return n-1 ;
    for(int i=2 ; i<n ; i++){
      cost+=i ;
      if(v==n-i){
        break ;
      }
    }
    return cost ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Sasha {
  static   operation main( agrs : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var v : int ; v := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(calculate(n, v)) );
  static   operation calculate( n : int, v : int) : int
  pre: true
  post: true
  activity: (     var cost : int ; cost := v ;
     if (cost >= n - 1) then     return n - 1 else skip ; 
         var i : int ; i := 2 ; while i < n do ( (     cost := cost+(i) ; 
     if (v = n - i) then (     break ) else skip )  ;     i := i + 1 ) ; 
     return cost );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int exclude(int a[],int n){
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int s=0 ;
      int maximum=0 ;
      for(int j=i ; j<Math.min(n,i+60); j++){
        s+=a[j];
        maximum=Math.max(a[j],maximum);
        if(s % 2==0 && 2*maximum>s)count++;
      }
    }
    return count ;
  }
  static int countSubarrays(int a[],int n){
    for(int i=0 ; i<n ; i++)a[i]=Integer.bitCount(a[i]);
    int[] pre=new int[n];
    for(int i=0 ; i<n ; i++){
      pre[i]=a[i];
      if(i!=0)pre[i]+=pre[i-1];
    }
    int odd=0,even=0 ;
    for(int i=0 ; i<n ; i++){
      if(pre[i] % 2==1)odd++;
    }
    even=n-odd ;
    even++;
    int answer=(odd*(odd-1)/2)+(even*(even-1)/2);
    System.out.println(answer);
    answer=answer-exclude(a,n);
    return answer ;
  }
  public static void main(String[] args){
    int a[]={
      6,7,14 };
      int n=a.length ;
      System.out.println(countSubarrays(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation exclude( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var s : int ; s := 0 ;
     var maximum : int ; maximum := 0 ;
         var j : int ; j := i ; while j < Set{n, i + 60}->min() do ( (     s := s+(a[j+1]) ; 
     maximum := Set{a[j+1], maximum}->max() ; 
     if (s mod 2 = 0 & 2 * maximum > s) then     count := count + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation countSubarrays( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     a[i+1] := bitCount(a[i+1]) ;  ;     i := i + 1 ) ; 
     var pre : Sequence(int) ; pre := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     pre[i+1] := a[i+1] ; 
     if (i /= 0) then     pre[i+1] := pre[i+1]+(pre[i - 1+1]) ; else skip )  ;     i := i + 1 ) ; 
    var odd : int ; odd := 0 ;
    var even : int ; even := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (pre[i+1] mod 2 = 1) then     odd := odd + 1 ; else skip )  ;     i := i + 1 ) ; 
    even := n - odd ; 
    even := even + 1 ; 
    var answer : int ; answer := (odd * (odd - 1) / 2) + (even * (even - 1) / 2) ;
    OclFile["System.out"].println(answer) ; 
    answer := answer - exclude(a, n) ; 
    return answer 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{6,7,14} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(countSubarrays(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void lexicoSmallestPermuatation(int arr[],int n){
    int cnt[]=new int[n+1];
    for(int i=0 ; i<n ; ++i){
++cnt[arr[i] ];
    }
    int ele=1,replacement=0 ;
    boolean vis[]=new boolean[n+1];
    for(int i=0 ; i<n ; ++i){
      if(cnt[arr[i] ]==1){
        continue ;
      }
      while(cnt[ele]>0){
++ele ;
      }
      if(ele>arr[i] && ! vis[arr[i] ]){
        vis[arr[i] ]=true ;
      }
      else {
--cnt[arr[i] ];
        arr[i]=ele ;
++replacement ;
++ele ;
      }
    }
    System.out.print(replacement+"\n");
    for(int i=0 ; i<n ; ++i){
      System.out.print(arr[i]+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      2,3,4,3,2 };
      int sz=arr.length ;
      lexicoSmallestPermuatation(arr,sz);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation lexicoSmallestPermuatation( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var cnt : Sequence(int) ; cnt := Integer.subrange(1,n + 1)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     cnt[arr[i+1]+1] := cnt[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var ele : int ; ele := 1 ;
    var replacement : int ; replacement := 0 ;
    var vis : Sequence(boolean) ; vis := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     if (cnt[arr[i+1]+1] = 1) then (     continue ) else skip ; 
     while (cnt[ele+1] > 0) do (     ele := ele + 1 ) ; 
     if (ele > arr[i+1] & not(vis[arr[i+1]+1])) then (     vis[arr[i+1]+1] := true ) else (     cnt[arr[i+1]+1] := cnt[arr[i+1]+1] - 1 ; 
     arr[i+1] := ele ; 
     replacement := replacement + 1 ; 
     ele := ele + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(replacement + "\n") ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,3,4,3,2} ;
     var sz : int ; sz := arr->size() ;
     execute lexicoSmallestPermuatation(arr, sz) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Download_More_RAM {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int testcase=sc.nextInt();
    while(testcase!=0){
      testcase--;
      int n=sc.nextInt(),k=sc.nextInt();
      int[] arrA=new int[n],arrB=new int[n];
      for(int i=0 ; i<n ; i++)arrA[i]=sc.nextInt();
      for(int i=0 ; i<n ; i++)arrB[i]=sc.nextInt();
      for(int i=0 ; i<n ; i++){
        if(arrA[i]!=0 && k>=arrA[i]){
          arrA[i]=0 ;
          k+=arrB[i];
          i=-1 ;
        }
      }
      System.out.print(k);
      if(testcase>0)System.out.println();
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Download_More_RAM {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testcase : int ; testcase := sc.getCurrent()->toInteger() ;
     while (testcase /= 0) do (     testcase := testcase - 1 ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arrA : Sequence(int) ; arrA := Integer.subrange(1,n)->collect(0) ;
    var arrB : Sequence(int) ; arrB := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arrA[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     arrB[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arrA[i+1] /= 0 & k >= arrA[i+1]) then (     arrA[i+1] := 0 ; 
     k := k+(arrB[i+1]) ; 
     i := -1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(k) ; 
    if (testcase > 0) then     OclFile["System.out"].println() ; else skip ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maxPrimeFactors(int n){
    int num=n ;
    int maxPrime=-1 ;
    while(n % 2==0){
      maxPrime=2 ;
      n/=2 ;
    }
    for(int i=3 ; i<=Math.sqrt(n); i+=2){
      while(n % i==0){
        maxPrime=i ;
        n=n/i ;
      }
    }
    if(n>2){
      maxPrime=n ;
    }
    int sum=maxPrime+num ;
    return sum ;
  }
  public static void main(String[] args){
    int n=19 ;
    System.out.println(maxPrimeFactors(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxPrimeFactors( n : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := n ;
     var maxPrime : int ; maxPrime := -1 ;
    while (n mod 2 = 0) do (     maxPrime := 2 ; 
     n := n/(2) ) ; 
        var i : int ; i := 3 ; while i <= (n)->sqrt() do ( (     while (n mod i = 0) do (     maxPrime := i ; 
     n := n / i ) )  ;     i := i+(2) ) ; 
    if (n > 2) then (     maxPrime := n ) else skip ; 
    var sum : int ; sum := maxPrime + num ;
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 19 ;
     OclFile["System.out"].println(maxPrimeFactors(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  static class Pair {
    int ram ;
    int additionalRam ;
    Pair(int x,int y){
      ram=x ;
      additionalRam=y ;
    }
  }
  public static int downloadRam(List<Pair>p,int freeRam,int len){
    PriorityQueue<Pair>pq=new PriorityQueue<>((Pair a,Pair b)->a.ram-b.ram);
    for(int i=0 ; i<len ; i++){
      pq.add(p.get(i));
    }
    while(! pq.isEmpty()&& freeRam>=pq.peek().ram){
      freeRam=freeRam+pq.poll().additionalRam ;
    }
    return freeRam ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int tests=sc.nextInt();
    for(int test=0 ; test<tests ; test++){
      int n=sc.nextInt(),k=sc.nextInt();
      int[] arr1=new int[n];
      int[] arr2=new int[n];
      for(int i=0 ; i<n ; i++){
        arr1[i]=sc.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        arr2[i]=sc.nextInt();
      }
      ArrayList<Pair>list=new ArrayList<>();
      for(int i=0 ; i<arr2.length ; i++){
        list.add(new Pair(arr1[i],arr2[i]));
      }
      System.out.println(downloadRam(list,k,n));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Pair {
   attribute ram : int;
   attribute additionalRam : int;
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     ram := x ; 
     additionalRam := y );
}
  static   operation downloadRam( p : Sequence(Map), freeRam : int, len : int) : int
  pre: true
  post: true
  activity: (     var pq : Sequence(Map) ; pq := Sequence{}->union(lambda  a : Map, b : Map : OclAny in a.ram - b.ram) ;
         var i : int ; i := 0 ; while i < len do ( (     pq := pq->including(p->at(i+1)) )  ;     i := i + 1 ) ; 
     while (not(pq->isEmpty()) & freeRam >= pq->min().ram) do (     freeRam := freeRam + pq->min().additionalRam ) ; 
     return freeRam );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tests : int ; tests := sc.getCurrent()->toInteger() ;
         var test : int ; test := 0 ; while test < tests do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
     var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr1[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr2[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var list : Sequence(Map) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < arr2->size() do ( (     list := list->including(Map(arr1[i+1], arr2[i+1])) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(downloadRam(list, k, n)) ; 
 )  ;     test := test + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test229 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int k=in.nextInt();
      int a[]=new int[n];
      int b[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        b[i]=in.nextInt();
      }
      for(int l=0 ; l<n ; l++){
        for(int i=1 ; i<n ; i++){
          if(a[i]<a[i-1]){
            int temp=a[i];
            a[i]=a[i-1];
            a[i-1]=temp ;
            temp=b[i];
            b[i]=b[i-1];
            b[i-1]=temp ;
          }
        }
      }
      for(int i=0 ; i<n ; i++){
        if(k>=a[i]){
          k+=b[i];
        }
        else {
          break ;
        }
      }
      System.out.println(k);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test229 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var l : int ; l := 0 ; while l < n do ( (         var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] < a[i - 1+1]) then (     var temp : int ; temp := a[i+1] ;
     a[i+1] := a[i - 1+1] ; 
    a[i - 1+1] := temp ; 
    temp := b[i+1] ; 
    b[i+1] := b[i - 1+1] ; 
    b[i - 1+1] := temp ; 
 ) else skip )  ;     i := i + 1 ) )  ;     l := l + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (k >= a[i+1]) then (     k := k+(b[i+1]) ) else (     break ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(k) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Vector<Integer>createSemiPrimeSieve(int n){
    int v[]=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      v[i]=i ;
    }
    int countDivision[]=new int[n+1];
    for(int i=0 ; i<n+1 ; i++){
      countDivision[i]=2 ;
    }
    for(int i=2 ; i<=n ; i++){
      if(v[i]==i && countDivision[i]==2){
        for(int j=2*i ; j<=n ; j+=i){
          if(countDivision[j]>0){
            v[j]=v[j]/i ;
            countDivision[j]--;
          }
        }
      }
    }
    Vector<Integer>res=new Vector<>();
    for(int i=2 ; i<=n ; i++){
      if(v[i]==1 && countDivision[i]==0){
        res.add(i);
      }
    }
    return res ;
  }
  public static void main(String[] args){
    int n=16 ;
    Vector<Integer>semiPrime=createSemiPrimeSieve(n);
    for(int i=0 ; i<semiPrime.size(); i++){
      System.out.print(semiPrime.get(i)+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation createSemiPrimeSieve( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var v : Sequence(int) ; v := Integer.subrange(1,n + 1)->collect(0) ;
         var i : int ; i := 1 ; while i <= n do ( (     v[i+1] := i )  ;     i := i + 1 ) ; 
    var countDivision : Sequence(int) ; countDivision := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n + 1 do ( (     countDivision[i+1] := 2 )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= n do ( (     if (v[i+1] = i & countDivision[i+1] = 2) then (         var j : int ; j := 2 * i ; while j <= n do ( (     if (countDivision[j+1] > 0) then (     v[j+1] := v[j+1] / i ; 
     countDivision[j+1] := countDivision[j+1] - 1 ) else skip )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    var res : Sequence(int) ; res := Sequence{} ;
        var i : int ; i := 2 ; while i <= n do ( (     if (v[i+1] = 1 & countDivision[i+1] = 0) then (     res := res->including(i) ) else skip )  ;     i := i + 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 16 ;
     var semiPrime : Sequence(int) ; semiPrime := createSemiPrimeSieve(n) ;
         var i : int ; i := 0 ; while i < semiPrime->size() do ( (     OclFile["System.out"].print(semiPrime->at(i+1) + " ") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class LPS {
  static int max(int x,int y){
    return(x>y)? x : y ;
  }
  static int lps(String seq){
    int n=seq.length();
    int i,j,cl ;
    int L[][]=new int[n][n];
    for(i=0 ; i<n ; i++)L[i][i]=1 ;
    for(cl=2 ; cl<=n ; cl++){
      for(i=0 ; i<n-cl+1 ; i++){
        j=i+cl-1 ;
        if(seq.charAt(i)==seq.charAt(j)&& cl==2)L[i][j]=2 ;
        else if(seq.charAt(i)==seq.charAt(j))L[i][j]=L[i+1][j-1]+2 ;
        else L[i][j]=max(L[i][j-1],L[i+1][j]);
      }
    }
    return L[0][n-1];
  }
  public static void main(String args[]){
    String seq="GEEKSFORGEEKS" ;
    int n=seq.length();
    System.out.println("The lnegth of the lps is "+lps(seq));
  }
}
------------------------------------------------------------
OCL File:
---------
class LPS {
  static   operation max( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return if (x > y) then x else y endif );
  static   operation lps( seq : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := seq->size() ;
     var i : int ;
    var j : int ;
    var cl : int ;
    var L : Sequence(Sequence(int)) ; L := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        i := 0 ; while i < n do (     L[i+1][i+1] := 1 ;  ;     i := i + 1 ) ; 
        cl := 2 ; while cl <= n do ( (         i := 0 ; while i < n - cl + 1 do ( (     j := i + cl - 1 ; 
     if (seq->at(i+1) = seq->at(j+1) & cl = 2) then     L[i+1][j+1] := 2 ; else     if (seq->at(i+1) = seq->at(j+1)) then     L[i+1][j+1] := L[i + 1+1][j - 1+1] + 2 else     L[i+1][j+1] := Set{L[i+1][j - 1+1], L[i + 1+1][j+1]}->max() ; ;  )  ;     i := i + 1 ) )  ;     cl := cl + 1 ) ; 
    return L[0+1][n - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var seq : String ; seq := "GEEKSFORGEEKS" ;
     var n : int ; n := seq->size() ;
     OclFile["System.out"].println("The lnegth of the lps is " + lps(seq)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int editDistanceWith2Ops(String X,String Y){
    int m=X.length(),n=Y.length();
    int L[][]=new int[m+1][n+1];
    for(int i=0 ; i<=m ; i++){
      for(int j=0 ; j<=n ; j++){
        if(i==0 || j==0){
          L[i][j]=0 ;
        }
        else if(X.charAt(i-1)==Y.charAt(j-1)){
          L[i][j]=L[i-1][j-1]+1 ;
        }
        else {
          L[i][j]=Math.max(L[i-1][j],L[i][j-1]);
        }
      }
    }
    int lcs=L[m][n];
    return(m-lcs)+(n-lcs);
  }
  public static void main(String[] args){
    String X="abc",Y="acd" ;
    System.out.println(editDistanceWith2Ops(X,Y));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation editDistanceWith2Ops( X : String, Y : String) : int
  pre: true
  post: true
  activity: (     var m : int ; m := X->size() ;
    var n : int ; n := Y->size() ;
     var L : Sequence(Sequence(int)) ; L := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i <= m do ( (         var j : int ; j := 0 ; while j <= n do ( (     if (i = 0 or j = 0) then (     L[i+1][j+1] := 0 ) else     if (X->at(i - 1+1) = Y->at(j - 1+1)) then (     L[i+1][j+1] := L[i - 1+1][j - 1+1] + 1 ) else (     L[i+1][j+1] := Set{L[i - 1+1][j+1], L[i+1][j - 1+1]}->max() ) ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var lcs : int ; lcs := L[m+1][n+1] ;
    return (m - lcs) + (n - lcs) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : String ; X := "abc" ;
    var Y : String ; Y := "acd" ;
     OclFile["System.out"].println(editDistanceWith2Ops(X, Y)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public String defangIPaddr(String address){
    return address.replace(".","[.] ");
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation defangIPaddr( address : String) : String
  pre: true
  post: true
  activity: (     return address.replace(".", "[.] ") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.text.*;
public class B_Cover_Points {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int max=0 ;
    while(n-->0){
      int x=sc.nextInt();
      int y=sc.nextInt();
      max=Math.max(max,x+y);
    }
    System.out.println(max);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Cover_Points {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var max : int ; max := 0 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     max := Set{max, x + y}->max() ) ;  ) ;  
    OclFile["System.out"].println(max) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Cover_Points {
  static class RealScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
  public static void main(String[] args){
    RealScanner sc=new RealScanner();
    int t=sc.nextInt();
    List<Integer>l=new ArrayList<>();
    while(t-->0){
      int a,b ;
      a=sc.nextInt();
      b=sc.nextInt();
      l.add(a+b);
    }
    System.out.println(Collections.max(l));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cover_Points {
  static class RealScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : RealScanner ; sc := RealScanner.newRealScanner() ;
     var t : int ; t := sc.nextInt() ;
    var l : Sequence(int) ; l := Sequence{} ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ;
    var b : int ;
     a := sc.nextInt() ; 
     b := sc.nextInt() ; 
     l := l->including(a + b) ) ;  ) ;  
    OclFile["System.out"].println( l->max()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int countSegments(String s){
    int segmentCount=0 ;
    for(int i=0 ; i<s.length(); i++){
      if((i==0 || s.charAt(i-1)==' ')&& s.charAt(i)!=' '){
        segmentCount++;
      }
    }
    return segmentCount ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation countSegments( s : String) : int
  pre: true
  post: true
  activity: (     var segmentCount : int ; segmentCount := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if ((i = 0 or s->at(i - 1+1) = ' ') & s->at(i+1) /= ' ') then (     segmentCount := segmentCount + 1 ) else skip )  ;     i := i + 1 ) ; 
     return segmentCount );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GFG {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int[] a=new int[n];
      int[] b=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=s.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        b[i]=s.nextInt();
      }
      long ans=0 ;
      for(int i=0 ; i<n-1 ; i++){
        int x1=Math.abs(a[i+1]-a[i])+Math.abs(b[i+1]-b[i]);
        int x2=Math.abs(a[i+1]-b[i])+Math.abs(b[i+1]-a[i]);
        ans+=Math.min(x1,x2);
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var x1 : int ; x1 := if a[i + 1+1] - a[i+1] < 0 then -(a[i + 1+1] - a[i+1]) else a[i + 1+1] - a[i+1] endif + if b[i + 1+1] - b[i+1] < 0 then -(b[i + 1+1] - b[i+1]) else b[i + 1+1] - b[i+1] endif ;
     var x2 : int ; x2 := if a[i + 1+1] - b[i+1] < 0 then -(a[i + 1+1] - b[i+1]) else a[i + 1+1] - b[i+1] endif + if b[i + 1+1] - a[i+1] < 0 then -(b[i + 1+1] - a[i+1]) else b[i + 1+1] - a[i+1] endif ;
     ans := ans+(Set{x1, x2}->min()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; ++i){
        a[i]=sc.nextInt();
      }
      int[] b=new int[n];
      for(int i=0 ; i<b.length ; ++i){
        b[i]=sc.nextInt();
      }
      System.out.println(solve(a,b));
    }
    sc.close();
  }
  static long solve(int[] a,int[] b){
    return IntStream.range(0,a.length-1).map(i->Math.min(Math.abs(a[i]-a[i+1])+Math.abs(b[i]-b[i+1]),Math.abs(a[i]-b[i+1])+Math.abs(b[i]-a[i+1]))).asLongStream().sum();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < b->size() do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(a, b)) ; 
 )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : Sequence(int), b : Sequence(int)) : long
  pre: true
  post: true
  activity: (     return Integer.subrange(0, a->size() - 1-1)->collect( _x1 | (lambda i : OclAny in Set{if a[i+1] - a[i + 1+1] < 0 then -(a[i+1] - a[i + 1+1]) else a[i+1] - a[i + 1+1] endif + if b[i+1] - b[i + 1+1] < 0 then -(b[i+1] - b[i + 1+1]) else b[i+1] - b[i + 1+1] endif, if a[i+1] - b[i + 1+1] < 0 then -(a[i+1] - b[i + 1+1]) else a[i+1] - b[i + 1+1] endif + if b[i+1] - a[i + 1+1] < 0 then -(b[i+1] - a[i + 1+1]) else b[i+1] - a[i + 1+1] endif}->min())->apply(_x1) )->sum() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String aabc=" " ;
    int m ;
    int sum ;
    for(; ! aabc.equals("-"); ){
      aabc=sc.next();
      if(aabc.equals("-"))break ;
      char array[]=aabc.toCharArray();
      sum=0 ;
      m=sc.nextInt();
      for(int i=0 ; i<m ; ++i){
        sum=sum+sc.nextInt();
      }
      for(int i=0 ; i<array.length ; ++i){
        System.out.print(array[(sum+i)%(array.length)]);
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var aabc : String ; aabc := " " ;
    var m : int ;
    var sum : int ;
      while not(aabc = "-") do ( (     aabc := sc.getCurrent() ; 
     if (aabc = "-") then     break else skip ; 
    var array : Sequence(String) ; array := aabc->characters() ;
    sum := 0 ; 
    m := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < m do ( (     sum := sum + sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < array->size() do ( (     OclFile["System.out"].print(array[(sum + i) mod (array->size())+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class h1668 {
  static long a[],b[];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t,n,j,i ;
    long sum,q ;
    t=sc.nextInt();
    for(j=1 ; j<=t ; j++){
      n=sc.nextInt();
      a=new long[n+1];
      b=new long[n+1];
      for(i=1 ; i<=n ; i++)a[i]=sc.nextLong();
      for(i=1 ; i<=n ; i++)b[i]=sc.nextLong();
      sum=0 ;
      for(i=1 ; i<=n ; i++){
        if(a[i]>b[i]){
          q=a[i];
          a[i]=b[i];
          b[i]=q ;
        }
      }
      for(i=1 ; i<n ; i++)sum+=Math.abs(a[i]-a[i+1])+Math.abs(b[i]-b[i+1]);
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class h1668 {
  static   attribute a : long;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ;
    var n : int ;
    var j : int ;
    var i : int ;
    var sum : long ;
    var q : long ;
    t := sc.getCurrent()->toInteger() ; 
        j := 1 ; while j <= t do ( (     n := sc.getCurrent()->toInteger() ; 
     a := Integer.subrange(1,n + 1)->collect(0) ; 
    b := Integer.subrange(1,n + 1)->collect(0) ; 
        i := 1 ; while i <= n do (     a[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
        i := 1 ; while i <= n do (     b[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    sum := 0 ; 
        i := 1 ; while i <= n do ( (     if (a[i+1] > b[i+1]) then (     q := a[i+1] ; 
     a[i+1] := b[i+1] ; 
     b[i+1] := q ) else skip )  ;     i := i + 1 ) ; 
        i := 1 ; while i < n do (     sum := sum+(if a[i+1] - a[i + 1+1] < 0 then -(a[i+1] - a[i + 1+1]) else a[i+1] - a[i + 1+1] endif + if b[i+1] - b[i + 1+1] < 0 then -(b[i+1] - b[i + 1+1]) else b[i+1] - b[i + 1+1] endif) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.*;
public class Main {
  public static void main(String[] args)throws IOException {
    FastReader in=new FastReader();
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt();
    int[] count=new int[10000];
    for(int i=0 ; i<n ; i++){
      count[in.nextInt()]++;
    }
    int ans=0 ;
    for(int i=0 ; i<10000 ; i++){
      while(count[i]>1){
        ans+=1 ;
        count[i]-=1 ;
        count[i+1]+=1 ;
      }
    }
    out.println(ans);
    out.close();
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.nextInt() ;
    var count : Sequence(int) ; count := Integer.subrange(1,10000)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     count[in.nextInt()+1] := count[in.nextInt()+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 10000 do ( (     while (count[i+1] > 1) do (     ans := ans+(1) ; 
     count[i+1] := count[i+1]-(1) ; 
     count[i + 1+1] := count[i + 1+1]+(1) ) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayDeque ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n,m ;
      n=Integer.parseInt(line);
      if(n==0){
        break ;
      }
      m=Integer.parseInt(br.readLine());
      line=br.readLine();
      ArrayDeque<Integer>count=new ArrayDeque<Integer>();
      count.add(0);
      int j=-1 ;
      for(int i=1 ; i<m-1 ; i++){
        if(line.charAt(i)=='O'){
          if((line.charAt(i-1)| line.charAt(i+1))=='I'){
            if(i-j==2){
              count.offer(count.pollLast()+1);
            }
            else {
              count.offer(1);
            }
            j=i ;
          }
        }
      }
      int sum=0 ;
      for(int c : count){
        if(c>=n){
          sum+=c-n+1 ;
        }
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ;
    var m : int ;
     n := (line)->toInteger() ; 
    if (n = 0) then (     break ) else skip ; 
    m := (br.readLine())->toInteger() ; 
    line := br.readLine() ; 
    var count : Sequence(int) ; count := ArrayDeque<int>.newArrayDeque() ;
    count := count->including(0) ; 
    var j : int ; j := -1 ;
        var i : int ; i := 1 ; while i < (m)->char2byte() - 1 do ( (     if (line->at(i+1) = 'O') then (     if ((line->at(i - 1+1) or line->at(i + 1+1)) = 'I') then (     if (i - j = 2) then (     count := count->including(count->last() + 1) ) else (     count := count->including(1) ) ;  
     j := i ) else skip ) else skip )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    for (c : count) do ( (     if (c >= n) then (     sum := sum+(c - (n)->char2byte() + 1) ) else skip )  ) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  public static void main(String[] Args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    HashSet<Integer>set=new HashSet<>();
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      int value=input.nextInt();
      while(! set.add(value)){
        value++;
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( Args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var value : int ; value := input.getCurrent()->toInteger() ;
     while (not(set->excludes(value))) do (     value := value + 1 ; 
     ans := ans + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class CCTrial {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String s[]=br.readLine().split(" ");
    int a[]=new int[n];
    HashSet<Integer>hs=new HashSet<>();
    ArrayList<Integer>ar=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(s[i]);
      if(hs.size()==0 || ! hs.contains(a[i]))hs.add(a[i]);
      else ar.add(a[i]);
    }
    if(ar.size()==0)System.out.println("0");
    else {
      int sum=0 ;
      for(int i=0 ; i<ar.size(); i++){
        int k=ar.get(i);
        while(hs.contains(k)){
          k++;
        }
        hs.add(k);
        sum+=k-ar.get(i);
      }
      System.out.println(sum);
    }
  }
  public static String sub(String s,int i){
    return s.substring(0,i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CCTrial {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var s : Sequence(String) ; s := br.readLine()->split(" ") ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var hs : Set(int) ; hs := Set{} ;
    var ar : Sequence(int) ; ar := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (s[i+1])->toInteger() ; 
     if (hs->size() = 0 or not(hs->includes(a[i+1]))) then     hs := hs->including(a[i+1]) ; else     ar := ar->including(a[i+1]) ; )  ;     i := i + 1 ) ; 
    if (ar->size() = 0) then     OclFile["System.out"].println("0") else (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < ar->size() do ( (     var k : int ; k := ar->at(i+1) ;
     while (hs->includes(k)) do (     k := k + 1 ) ; 
     hs := hs->including(k) ; 
     sum := sum+(k - ar->at(i+1)) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sum) ) ;  
 );
  static   operation sub( s : String, i : int) : String
  pre: true
  post: true
  activity: (     return s.subrange(0+1,i) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    int T=1,n,i,j=0,k=0 ;
    long m,l,ans=0l,ans2=0l,ans3=0l,b,c ;
    for(int tt=0 ; tt<T ; tt++){
      n=fs.nextInt();
      int[] a=new int[30001];
      for(i=0 ; i<n ; i++)a[fs.nextInt()]++;
      for(i=1 ; i<=n ; i++){
        if(a[i]>1){
          j=i ;
          while(a[i]!=1){
            while(a[j]!=0)j++;
            ans+=j-i ;
            a[j]++;
            a[i]--;
          }
        }
      }
      System.out.println(ans);
    }
  }
  static final Random random=new Random();
  static void ruffleSort(int[] a){
    int n=a.length ;
    for(int i=0 ; i<n ; i++){
      int oi=random.nextInt(n),temp=a[oi];
      a[oi]=a[i];
      a[i]=temp ;
    }
    Arrays.sort(a);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] readArray(int n){
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=nextInt();
      return a ;
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var T : int ; T := 1 ;
    var n : int ;
    var i : int ;
    var j : int ; j := 0 ;
    var k : int ; k := 0 ;
     var m : long ;
    var l : long ;
    var ans : long ; ans := 0l ;
    var ans2 : long ; ans2 := 0l ;
    var ans3 : long ; ans3 := 0l ;
    var b : long ;
    var c : long ;
         var tt : int ; tt := 0 ; while tt < T do ( (     n := fs.nextInt() ; 
     var a : Sequence(int) ; a := Integer.subrange(1,30001)->collect(0) ;
        i := 0 ; while i < n do (     a[fs.nextInt()+1] := a[fs.nextInt()+1] + 1 ;  ;     i := i + 1 ) ; 
        i := 1 ; while i <= n do ( (     if (a[i+1] > 1) then (     j := i ; 
     while (a[i+1] /= 1) do (     while (a[j+1] /= 0) do     j := j + 1 ; ; 
     ans := ans+(j - i) ; 
     a[j+1] := a[j+1] + 1 ; 
     a[i+1] := a[i+1] - 1 ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     tt := tt + 1 ) );
  static    attribute random : OclRandom := OclRandom.newOclRandom();
  static   operation ruffleSort( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() ;
         var i : int ; i := 0 ; while i < n do ( (     var oi : int ; oi := random.nextInt(n) ;
    var temp : int ; temp := a[oi+1] ;
     a[oi+1] := a[i+1] ; 
     a[i+1] := temp )  ;     i := i + 1 ) ; 
     a := a->sort() );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation readArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF546_D2_B {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int[] arr=new int[6000];
    for(int i=0 ; i<n ; i++){
      int x=scanner.nextInt();
      arr[x]+=1 ;
    }
    int sum=0 ;
    for(int i=0 ; i<arr.length ; i++){
      while(arr[i]>1){
        int change=0 ;
        for(int j=i ; j<arr.length ; j++){
          if(arr[j]==0){
            change=j ;
            arr[j]=1 ;
            break ;
          }
        }
        sum+=change-i ;
        arr[i]--;
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF546_D2_B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,6000)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := scanner.getCurrent()->toInteger() ;
     arr[x+1] := arr[x+1]+(1) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     while (arr[i+1] > 1) do (     var change : int ; change := 0 ;
         var j : int ; j := i ; while j < arr->size() do ( (     if (arr[j+1] = 0) then (     change := j ; 
     arr[j+1] := 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     sum := sum+(change - i) ; 
     arr[i+1] := arr[i+1] - 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int factors(int n){
    HashMap<Integer,Integer>prime=new HashMap<Integer,Integer>();
    for(int i=2 ; i<=Math.sqrt(n); ++i){
      while(n % i==0){
        if(prime.containsKey(i)){
          prime.put(i,prime.get(i)+1);
        }
        else {
          prime.put(i,1);
        }
        n=n/i ;
      }
    }
    if(n>2){
      if(prime.containsKey(n)){
        prime.put(n,prime.get(n)+1);
      }
      else {
        prime.put(n,1);
      }
    }
    int ans1=1,ans2=1 ;
    for(Map.Entry<Integer,Integer>it : prime.entrySet()){
      ans1*=2*it.getValue()+1 ;
      ans2*=it.getValue()+1 ;
    }
    return ans1-ans2 ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(factors(n));
    n=8 ;
    System.out.println(factors(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation factors( n : int) : int
  pre: true
  post: true
  activity: (     var prime : Map(int,int) ; prime := Map{} ;
         var i : int ; i := 2 ; while i <= (n)->sqrt() do ( (     while (n mod i = 0) do (     if (prime->keys()->includes(i)) then (     prime := prime->union(Map{i |-> prime->at(i) + 1}) ) else (     prime := prime->union(Map{i |-> 1}) ) ;  
     n := n / i ) )  ;     i := i + 1 ) ; 
    if (n > 2) then (     if (prime->keys()->includes(n)) then (     prime := prime->union(Map{n |-> prime->at(n) + 1}) ) else (     prime := prime->union(Map{n |-> 1}) ) ) else skip ; 
    var ans1 : int ; ans1 := 1 ;
    var ans2 : int ; ans2 := 1 ;
    for (it : prime->asSet()) do ( (     ans1 := ans1*(2 * it.getValue() + 1) ; 
     ans2 := ans2*(it.getValue() + 1) )  ) ; 
    return ans1 - ans2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(factors(n)) ; 
     n := 8 ; 
     OclFile["System.out"].println(factors(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CodeForces {
  public static final int BUFFERSIZE=512000 ;
  private static Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in),BUFFERSIZE));
  private static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out,BUFFERSIZE));
  public static void solve(){
    int n=sc.nextInt();
    int b=sc.nextInt();
    int t=sc.nextInt();
    int towels=n*t ;
    int bottles=0 ;
    while(n>1){
      int matches=n/2 ;
      bottles+=matches*(1+b*2);
      n-=matches ;
    }
    out.println(bottles+" "+towels);
  }
  public static void main(String args[])throws Exception {
    in.init(System.in);
    solve();
    out.close();
  }
  public static class in {
    static BufferedReader reader ;
    static StringTokenizer tokenizer ;
    static void init(InputStream input){
      reader=new BufferedReader(new InputStreamReader(input),BUFFERSIZE);
      tokenizer=new StringTokenizer("");
    }
    static String next()throws IOException {
      while(! tokenizer.hasMoreTokens())tokenizer=new StringTokenizer(reader.readLine());
      return tokenizer.nextToken();
    }
    static int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    static double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    static long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeForces {
  static    attribute BUFFERSIZE : int := 512000;
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), BUFFERSIZE));
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"], BUFFERSIZE));
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var towels : int ; towels := n * t ;
    var bottles : int ; bottles := 0 ;
    while (n > 1) do (     var matches : int ; matches := n / 2 ;
     bottles := bottles+(matches * (1 + b * 2)) ; 
     n := n-(matches) ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in.init(OclFile["System.in"]) ; 
     execute solve() ; 
     skip );
  static class in {
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   operation init( input : OclFile) : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(input), BUFFERSIZE) ; 
     tokenizer := OclIterator.newOclIterator_String("") );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ; ; 
     return tokenizer.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
  static   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TennisTournament {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int b=in.nextInt();
    int p=in.nextInt();
    System.out.println((((n-1))*b*2+n-1)+" "+(n*p));
  }
}
------------------------------------------------------------
OCL File:
---------
 class TennisTournament {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var p : int ; p := in.getCurrent()->toInteger() ;
    OclFile["System.out"].println((((n - 1)) * b * 2 + n - 1) + " " + (n * p)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.Closeable ;
import java.io.FileInputStream ;
import java.io.FileNotFoundException ;
import java.io.FileOutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
import static java.lang.Math.*;
public class TennisTournament implements Closeable {
  private final InputReader in ;
  private final PrintWriter out ;
  public TennisTournament(){
    in=new InputReader(System.in);
    out=new PrintWriter(System.out);
  }
  public TennisTournament(String input,String output)throws FileNotFoundException {
    in=new InputReader(new FileInputStream(input));
    out=new PrintWriter(new FileOutputStream(output));
  }
  public void solve(){
    int n=in.ni(),b=in.ni(),p=in.ni(),towels=n*p,bottles=0 ;
    while(n>1){
      int k=1 ;
      while(k*2<=n){
        k*=2 ;
      }
      bottles+=k*b+k/2 ;
      n=(n-k)+k/2 ;
    }
    out.println(bottles+" "+towels);
  }
  @ Override public void close()throws IOException {
    in.close();
    out.close();
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int ni(){
      return Integer.parseInt(next());
    }
    public long nl(){
      return Long.parseLong(next());
    }
    public void close()throws IOException {
      reader.close();
    }
  }
  public static void main(String[] args)throws IOException {
    try(TennisTournament instance=new TennisTournament()){
      instance.solve();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TennisTournament implements Closeable {
   attribute in : InputReader;
   attribute out : OclFile;
   static operation newTennisTournament() : TennisTournament
  pre: true
  post: true
  activity:
  ( var self : TennisTournament ;
    self := createTennisTournament();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     in := InputReader.newInputReader(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) );
   static operation newTennisTournament( input : String, output : String) : TennisTournament
  pre: true
  post: true
  activity:
  ( var self : TennisTournament ;
    self := createTennisTournament();
    self.initialise(input, output);
    return self );
  operation initialise( input : String, output : String) : void
  pre: true  post: true
  activity: (     in := InputReader.newInputReader(OclFile.newOclFile_Read(input)) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(output)) );
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.ni() ;
    var b : int ; b := in.ni() ;
    var p : int ; p := in.ni() ;
    var towels : int ; towels := n * p ;
    var bottles : int ; bottles := 0 ;
     while (n > 1) do (     var k : int ; k := 1 ;
     while (k * 2 <= n) do (     k := k*(2) ) ; 
     bottles := bottles+(k * b + k / 2) ; 
     n := (n - k) + k / 2 ) ; 
     skip );
      operation close() : void
  pre: true
  post: true
  activity: (     in.close() ; 
     skip );
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nl() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation close() : void
  pre: true
  post: true
  activity: (     skip );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var instance : TennisTournament := TennisTournament.newTennisTournament() ;
 (     instance.solve() ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    try {
      BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
      String cards ;
      String str ;
      int h ;
      String begin ;
      String end ;
      while(!(cards=reader.readLine()).equals("-")){
        str=reader.readLine();
        int m=Integer.parseInt(str);
        for(int i=0 ; i<m ; i++){
          str=reader.readLine();
          h=Integer.parseInt(str);
          begin=cards.substring(0,h);
          end=cards.substring(h,cards.length());
          cards=end.concat(begin);
        }
        System.out.println(cards);
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var cards : String ;
    var str : String ;
    var h : int ;
    var begin : String ;
    var end : String ;
    while (not((cards) = "-")) do (     str := reader.readLine() ; 
     var m : int ; m := (str)->toInteger() ;
         var i : int ; i := 0 ; while i < m do ( (     str := reader.readLine() ; 
     h := (str)->toInteger() ; 
    begin := cards.subrange(0+1,h) ; 
    end := cards.subrange(h+1,cards->size()) ; 
    cards := end+begin ; 
 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(cards) ) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class CodeChef {
  public static void main(String[] args)throws java.lang.Exception {
    out=new PrintWriter(new BufferedOutputStream(System.out));
    sc=new FastReader();
    int test=1 ;
    for(int t=0 ; t<test ; t++){
      solve();
    }
    out.close();
  }
  private static void solve(){
    long n=sc.nextLong();
    long b=sc.nextLong();
    long p=sc.nextLong();
    long bottles=0 ;
    long towels=n*p ;
    while(n>1){
      long k=1 ;
      while(k*2<=n){
        k*=2 ;
      }
      bottles+=k*b+k/2 ;
      n=n-k+k/2 ;
    }
    out.println(bottles+" "+towels);
  }
  public static FastReader sc ;
  public static PrintWriter out ;
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeChef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
     sc := FastReader.newFastReader() ; 
    var test : int ; test := 1 ;
        var t : int ; t := 0 ; while t < test do ( (     execute solve() )  ;     t := t + 1 ) ; 
    out.close() ; 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.nextLong() ;
     var b : long ; b := sc.nextLong() ;
    var p : long ; p := sc.nextLong() ;
    var bottles : long ; bottles := 0 ;
    var towels : long ; towels := n * p ;
    while (n > 1) do (     var k : long ; k := 1 ;
     while (k * 2 <= n) do (     k := k*(2) ) ; 
     bottles := bottles+(k * b + k / 2) ; 
     n := n - k + k / 2 ) ; 
    out.println(bottles + " " + towels) ; 
 );
  static   attribute sc : FastReader;
  static   attribute out : OclFile;
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int count=scan.nextInt();
    printIsland(n,count);
  }
  public static void printIsland(int n,int count){
    int a=(n+1)/2 ;
    int b=n/2 ;
    int max=a*a+b*b ;
    if(count>max){
      System.out.println("NO");
      return ;
    }
    System.out.println("YES");
    for(int i=0 ; i<n ; i++){
      StringBuilder sb=new StringBuilder();
      for(int j=0 ; j<n ; j++){
        if((i+j)% 2==0 && count>0){
          sb.append('L');
          count--;
        }
        else {
          sb.append('S');
        }
      }
      System.out.println(sb);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
     var count : int ; count := scan.getCurrent()->toInteger() ;
     execute printIsland(n, count) );
  static   operation printIsland( n : int, count : int) : void
  pre: true
  post: true
  activity: (     var a : int ; a := (n + 1) / 2 ;
     var b : int ; b := n / 2 ;
    var max : int ; max := a * a + b * b ;
    if (count > max) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    OclFile["System.out"].println("YES") ; 
        var i : int ; i := 0 ; while i < n do ( (     var sb : String ; sb := StringLib.newString() ;
         var j : int ; j := 0 ; while j < n do ( (     if ((i + j) mod 2 = 0 & count > 0) then (     sb := sb + StringLib.newString('L') ; 
     count := count - 1 ) else (     sb := sb + StringLib.newString('S') ) )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(sb) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      int m=sc.nextInt();
      String str=sc.next();
      int cnt=0 ;
      int ioi=0 ;
      for(int i=0 ; i<m ; i++){
        if(str.charAt(i)=='I'){
          if(ioi % 2==0){
            ioi++;
            if(ioi/2>=n)cnt++;
          }
          else ioi=1 ;
        }
        else if(str.charAt(i)=='O'){
          if(ioi % 2==1)ioi++;
          else ioi=0 ;
        }
      }
      System.out.println(cnt);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var str : String ; str := sc.getCurrent() ;
    var cnt : int ; cnt := 0 ;
    var ioi : int ; ioi := 0 ;
        var i : int ; i := 0 ; while i < m do ( (     if (str->at(i+1) = 'I') then (     if (ioi mod 2 = 0) then (     ioi := ioi + 1 ; 
     if (ioi / 2 >= n) then     cnt := cnt + 1 ; else skip ) else     ioi := 1 ; ) else     if (str->at(i+1) = 'O') then (     if (ioi mod 2 = 1) then     ioi := ioi + 1 ; else     ioi := 0 ; ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class TennisTournament {
  static long bottle=0 ;
  static long towel=0 ;
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int b=Integer.parseInt(str[1]);
    int p=Integer.parseInt(str[2]);
    findSumBottles(n,b,p);
    System.out.print(bottle+" "+n*p);
  }
  private static void findSumBottles(int n,int b,int p){
    if(n==1){
      return ;
    }
    int k=maxPow2(n);
    bottle+=(k/2)*((2*b)+1);
    findSumBottles((k/2)+n-k,b,p);
  }
  public static int maxPow2(int n){
    int a=1 ;
    while((2*a)<=n){
      a=a*2 ;
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class TennisTournament {
  static   attribute bottle : long := 0;
  static   attribute towel : long := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var b : int ; b := (str[1+1])->toInteger() ;
    var p : int ; p := (str[2+1])->toInteger() ;
    execute findSumBottles(n, b, p) ; 
    OclFile["System.out"].print(bottle + " " + n * p) ; 
 );
  static   operation findSumBottles( n : int, b : int, p : int) : void
  pre: true
  post: true
  activity: (     if (n = 1) then (     return ) else skip ; 
     var k : int ; k := maxPow2(n) ;
     bottle := bottle+((k / 2) * ((2 * b) + 1)) ; 
     execute findSumBottles((k / 2) + n - k, b, p) );
  static   operation maxPow2( n : int) : int
  pre: true
  post: true
  activity: (     var a : int ; a := 1 ;
     while ((2 * a) <= n) do (     a := a * 2 ) ; 
     return a );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=10 ;
  static boolean isFactorion(int n){
    int fact[]=new int[MAX];
    fact[0]=1 ;
    for(int i=1 ; i<MAX ; i++)fact[i]=i*fact[i-1];
    int org=n ;
    int sum=0 ;
    while(n>0){
      int d=n % 10 ;
      sum+=fact[d];
      n/=10 ;
    }
    if(sum==org)return true ;
    return false ;
  }
  public static void main(String[] args){
    int n=40585 ;
    if(isFactorion(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 10;
  static   operation isFactorion( n : int) : boolean
  pre: true
  post: true
  activity: (     var fact : Sequence(int) ; fact := Integer.subrange(1,MAX)->collect(0) ;
     fact[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < MAX do (     fact[i+1] := i * fact[i - 1+1] ;  ;     i := i + 1 ) ; 
    var org : int ; org := n ;
    var sum : int ; sum := 0 ;
    while (n > 0) do (     var d : int ; d := n mod 10 ;
     sum := sum+(fact[d+1]) ; 
     n := n/(10) ) ; 
    if (sum = org) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 40585 ;
     if (isFactorion(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Stack ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    int dir=0 ;
    Stack<Integer>stack=new Stack<Integer>();
    stack.add(0);
    int result=0 ;
    for(int i=0 ; i<str.length(); i++){
      char command=str.charAt(i);
      if(command=='R'){
        dir++;
      }
      else {
        dir+=3 ;
      }
      dir %=4 ;
      if(dir==0 && stack==null){
        stack=new Stack<Integer>();
        stack.add(0);
      }
      else if(stack!=null){
        if(command=='L'){
          stack.pop();
          if(stack.size()==0){
            stack=null ;
          }
        }
        else {
          stack.push(0);
          if(stack.size()==5){
            result++;
            stack.removeAllElements();
            stack.add(0);
          }
        }
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var dir : int ; dir := 0 ;
    var stack : Sequence(int) ; stack := Sequence{} ;
    stack := stack->including(0) ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     var command : String ; command := str->at(i+1) ;
     if (command = 'R') then (     dir := dir + 1 ) else (     dir := dir+(3) ) ;  
     dir := dir mod 4 ; 
     if (dir = 0 & stack = null) then (     stack := Sequence{} ; 
     stack := stack->including(0) ) else     if (stack /= null) then (     if (command = 'L') then (     stack := stack->front() ; 
     if (stack->size() = 0) then (     stack := null ) else skip ) else (     stack := stack->append(0) ; 
     if (stack->size() = 5) then (     result := result + 1 ; 
     stack := stack->intersection(Set{}) ; 
     stack := stack->including(0) ) else skip ) ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String winner(String moves){
    HashMap<Character,Integer>data=new HashMap<Character,Integer>();
    data.put('R',0);
    data.put('P',1);
    data.put('S',2);
    if(moves.charAt(0)==moves.charAt(1)){
      return "Draw" ;
    }
    if(((data.get(moves.charAt(0))| 1<<(2))-(data.get(moves.charAt(1))| 0<<(2)))% 3!=0){
      return "A" ;
    }
    return "B" ;
  }
  static void performQueries(String arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(winner(arr[i])+"\n");
  }
  public static void main(String[] args){
    String arr[]={
      "RS","SR","SP","PP" };
      int n=arr.length ;
      performQueries(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation winner( moves : String) : String
  pre: true
  post: true
  activity: (     var data : Map(String,int) ; data := Map{} ;
     data := data->union(Map{'R' |-> 0}) ; 
    data := data->union(Map{'P' |-> 1}) ; 
    data := data->union(Map{'S' |-> 2}) ; 
    if (moves->at(0+1) = moves->at(1+1)) then (     return "Draw" ) else skip ; 
    if (((MathLib.bitwiseOr(data->at(moves->at(0+1)),(1*(2->pow((2))))->oclAsType(long))) - (MathLib.bitwiseOr(data->at(moves->at(1+1)),(0*(2->pow((2))))->oclAsType(long)))) mod 3 /= 0) then (     return "A" ) else skip ; 
    return "B" 
 );
  static   operation performQueries( arr : Sequence(String), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(winner(arr[i+1]) + "\n") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{"RS","SR","SP","PP"} ;
     var n : int ; n := arr->size() ;
     execute performQueries(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static long noOfTriples(long arr[],int n){
    Arrays.sort(arr);
    long count=0 ;
    for(int i=0 ; i<n ; i++)if(arr[i]==arr[2])count++;
    if(arr[0]==arr[2])return(count-2)*(count-1)*(count)/6 ;
    else if(arr[1]==arr[2])return(count-1)*(count)/2 ;
    return count ;
  }
  public static void main(String arg[]){
    long arr[]={
      1,3,3,4 };
      int n=arr.length ;
      System.out.print(noOfTriples(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation noOfTriples( arr : Sequence(long), n : int) : long
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var count : long ; count := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (arr[i+1] = arr[2+1]) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
    if (arr[0+1] = arr[2+1]) then     return (count - 2) * (count - 1) * (count) / 6 else     if (arr[1+1] = arr[2+1]) then     return (count - 1) * (count) / 2 else skip ; ;  
    return count 
 );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(long) ; arr := Sequence{1,3,3,4} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(noOfTriples(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Hulk {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String s="I hate" ;
    String hate="I hate" ;
    String love="I love" ;
    for(int i=1 ; i<n ; i++){
      if(i % 2==0){
        s=s+" that "+hate ;
      }
      else {
        s=s+" that "+love ;
      }
    }
    s=s+" it" ;
    if(n==1){
      s="I hate it" ;
    }
    System.out.print(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hulk {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : String ; s := "I hate" ;
    var hate : String ; hate := "I hate" ;
    var love : String ; love := "I love" ;
        var i : int ; i := 1 ; while i < n do ( (     if (i mod 2 = 0) then (     s := s + " that " + hate ) else (     s := s + " that " + love ) )  ;     i := i + 1 ) ; 
    s := s + " it" ; 
    if (n = 1) then (     s := "I hate it" ) else skip ; 
    OclFile["System.out"].print(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    for(int i=1 ; i<=n ; i++){
      if(i % 2!=0)System.out.print("I hate ");
      else System.out.print("I love ");
      System.out.print((i==n)? "it" : "that ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i <= n do ( (     if (i mod 2 /= 0) then     OclFile["System.out"].print("I hate ") else     OclFile["System.out"].print("I love ") ; ;  
     OclFile["System.out"].print(if (i = n) then "it" else "that " endif) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int n=0 ;
    int i=1 ;
    n=in.nextInt();
    while(i<=n){
      if(n==1){
        System.out.print("I hate ");
        break ;
      }
      else {
        if(i % 2!=0)System.out.print("I hate ");
        else System.out.print("I love ");
      }
      i++;
      if(i<=n)System.out.print("that ");
    }
    System.out.print("it");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := 0 ;
    var i : int ; i := 1 ;
    n := in.getCurrent()->toInteger() ; 
    while (i <= n) do (     if (n = 1) then (     OclFile["System.out"].print("I hate ") ; 
     break ) else (     if (i mod 2 /= 0) then     OclFile["System.out"].print("I hate ") ; else     OclFile["System.out"].print("I love ") ; ) ;  
     i := i + 1 ; 
     if (i <= n) then     OclFile["System.out"].print("that ") ; else skip ) ; 
    OclFile["System.out"].print("it") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ProblemSolving {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int testCases=input.nextInt();
    for(int index=1 ; index<=testCases ; index++){
      if(index==testCases && index % 2==0){
        System.out.print("I love it");
      }
      else if(index==testCases && index % 2!=0){
        System.out.print("I hate it");
      }
      else if(index % 2==0){
        System.out.print("I love that ");
      }
      else {
        System.out.print("I hate that ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemSolving {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := input.getCurrent()->toInteger() ;
         var index : int ; index := 1 ; while index <= testCases do ( (     if (index = testCases & index mod 2 = 0) then (     OclFile["System.out"].print("I love it") ) else     if (index = testCases & index mod 2 /= 0) then (     OclFile["System.out"].print("I hate it") ) else     if (index mod 2 = 0) then (     OclFile["System.out"].print("I love that ") ) else (     OclFile["System.out"].print("I hate that ") ) ;  ;  )  ;     index := index + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder result=new StringBuilder();
    while(true){
      String line=br.readLine();
      if("-".equals(line))break ;
      int shuffleCount=Integer.parseInt(br.readLine());
      for(int i=0 ; i<shuffleCount ; i++){
        int h=Integer.parseInt(br.readLine());
        line=line.substring(h,line.length())+line.substring(0,h);
      }
      result.append(line).append("\n");
    }
    System.out.print(result.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var result : String ; result := StringLib.newString() ;
     while (true) do (     var line : String ; line := br.readLine() ;
     if ("-" = line) then     break else skip ; 
    var shuffleCount : int ; shuffleCount := (br.readLine())->toInteger() ;
        var i : int ; i := 0 ; while i < shuffleCount do ( (     var h : int ; h := (br.readLine())->toInteger() ;
     line := line.subrange(h+1,line->size()) + line.subrange(0+1,h) )  ;     i := i + 1 ) ; 
    result := result + StringLib.newString(line) + StringLib.newString("\n") ; 
 ) ; 
     OclFile["System.out"].print(result+"") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      int n=scan.nextInt();
      if(n==0)break ;
      int m=scan.nextInt();
      String s=scan.next();
      Str str=new Str(s);
      System.out.println(str.count(n));
    }
    scan.close();
    System.exit(0);
  }
}
class Str {
  String S ;
  public Str(String s){
    S=s ;
  }
  public int count(int n){
    int result=0 ;
    int cur=0 ;
    int i=0 ;
    while(i<=S.length()){
      if(i<S.length()-2 && S.charAt(i)=='I' && S.charAt(i+1)=='O' && S.charAt(i+2)=='I'){
        cur++;
        i+=2 ;
        continue ;
      }
      if(cur>=n)result+=(cur-n+1);
      cur=0 ;
      i++;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var n : int ; n := scan.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var s : String ; s := scan.getCurrent() ;
    var str : Str ; str := Str.newStr(s) ;
    OclFile["System.out"].println(str.count(n)) ; 
 ) ; 
     skip ; 
 OclProcess.exit(0) );
}
class Str {
   attribute S : String;
   static operation newStr( s : String) : Str
  pre: true
  post: true
  activity:
  ( var self : Str ;
    self := createStr();
    self.initialise(s);
    return self );
  operation initialise( s : String) : void
  pre: true  post: true
  activity: (     S := s );
   operation count( n : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var cur : int ; cur := 0 ;
    var i : int ; i := 0 ;
    while (i <= S->size()) do (     if (i < S->size() - 2 & S->at(i+1) = 'I' & S->at(i + 1+1) = 'O' & S->at(i + 2+1) = 'I') then (     cur := cur + 1 ; 
     i := i+(2) ; 
     continue ) else skip ; 
     if (cur >= n) then     result := result+((cur - n + 1)) ; else skip ; 
     cur := 0 ; 
     i := i + 1 ) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Hulk {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String h="I hate it" ;
    String l="I love it" ;
    for(int i=1 ; i<=n ; i++){
      if(i % 2==0 && i!=n){
        l=l.replace("it","that ");
        System.out.print(l);
      }
      if(i % 2!=0 && i!=n){
        h=h.replace("it","that ");
        System.out.print(h);
      }
      if(i % 2==0 && i==n){
        System.out.print("I love it");
      }
      if(i % 2!=0 && i==n){
        System.out.print("I hate it");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hulk {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var h : String ; h := "I hate it" ;
    var l : String ; l := "I love it" ;
        var i : int ; i := 1 ; while i <= n do ( (     if (i mod 2 = 0 & i /= n) then (     l := l.replace("it", "that ") ; 
     OclFile["System.out"].print(l) ) else skip ; 
     if (i mod 2 /= 0 & i /= n) then (     h := h.replace("it", "that ") ; 
     OclFile["System.out"].print(h) ) else skip ; 
     if (i mod 2 = 0 & i = n) then (     OclFile["System.out"].print("I love it") ) else skip ; 
     if (i mod 2 /= 0 & i = n) then (     OclFile["System.out"].print("I hate it") ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int getMin(int arr[],int n){
    int minVal=Arrays.stream(arr).min().getAsInt();
    return minVal ;
  }
  public static void main(String[] args){
    int arr[]={
      5,3,1,6,9 };
      int n=arr.length ;
      System.out.println(getMin(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getMin( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var minVal : int ; minVal := stream(arr).min().getAsInt() ;
     return minVal );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,3,1,6,9} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(getMin(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findpair(int l,int r){
    int c=0 ;
    for(int i=l ; i<=r ; i++){
      for(int j=i+1 ; j<=r ; j++){
        if(j % i==0 && j!=i){
          System.out.println(i+","+j);
          c=1 ;
          break ;
        }
      }
      if(c==1)break ;
    }
  }
  public static void main(String args[]){
    int l=1,r=10 ;
    findpair(l,r);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findpair( l : int, r : int) : void
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
         var i : int ; i := l ; while i <= r do ( (         var j : int ; j := i + 1 ; while j <= r do ( (     if (j mod i = 0 & j /= i) then (     OclFile["System.out"].println(i + "," + j) ; 
     c := 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (c = 1) then     break else skip )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 1 ;
    var r : int ; r := 10 ;
     execute findpair(l, r) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MyClass {
  static int mod=1000000007 ;
  static int[] kmp(String s){
    int n=s.length();
    int dp[]=new int[n];
    int i=1,len=0 ;
    while(i<n){
      if(s.charAt(i)==s.charAt(len)){
        len++;
        dp[i]=len ;
        i++;
      }
      else {
        if(len==0){
          dp[i]=0 ;
          i++;
        }
        else {
          len=dp[len-1];
        }
      }
    }
    return dp ;
  }
  static String reverse(String s){
    return new String(new StringBuilder(s).reverse());
  }
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str[]=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int m=Integer.parseInt(str[1]);
    int q=Integer.parseInt(str[2]);
    String s=br.readLine();
    String t=br.readLine();
    int dp[]=kmp(t);
    while(q-->0){
      str=br.readLine().split(" ");
      int l=Integer.parseInt(str[0])-1 ;
      int r=Integer.parseInt(str[1])-1 ;
      int count=0 ;
      int i=l,j=0 ;
      while(i<=r){
        if(s.charAt(i)==t.charAt(j)){
          i++;
          j++;
          if(j==m){
            count++;
            j=dp[j-1];
          }
        }
        else {
          if(j==0)i++;
          else j=dp[j-1];
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   attribute mod : int := 1000000007;
  static   operation kmp( s : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
    var i : int ; i := 1 ;
    var len : int ; len := 0 ;
    while (i < n) do (     if (s->at(i+1) = s->at(len+1)) then (     len := len + 1 ; 
     dp[i+1] := len ; 
     i := i + 1 ) else (     if (len = 0) then (     dp[i+1] := 0 ; 
     i := i + 1 ) else (     len := dp[len - 1+1] ) ) ) ; 
    return dp 
 );
  static   operation reverse( s : String) : String
  pre: true
  post: true
  activity: (     return StringLib.newString(StringLib.newString(s)->reverse()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var m : int ; m := (str[1+1])->toInteger() ;
    var q : int ; q := (str[2+1])->toInteger() ;
    var s : String ; s := br.readLine() ;
    var t : String ; t := br.readLine() ;
    var dp : Sequence(int) ; dp := kmp(t) ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     str := br.readLine()->split(" ") ; 
     var l : int ; l := (str[0+1])->toInteger() - 1 ;
    var r : int ; r := (str[1+1])->toInteger() - 1 ;
    var count : int ; count := 0 ;
    var i : int ; i := l ;
    var j : int ; j := 0 ;
    while (i <= r) do (     if (s->at(i+1) = t->at(j+1)) then (     i := i + 1 ; 
     j := j + 1 ; 
     if (j = m) then (     count := count + 1 ; 
     j := dp[j - 1+1] ) else skip ) else (     if (j = 0) then     i := i + 1 ; else     j := dp[j - 1+1] ; ) ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),m=in.nextInt(),q=in.nextInt();
    String S=in.next();
    String T=in.next();
    boolean[] match=new boolean[n];
    for(int i=0 ; i<n ; i++){
      match[i]=S.substring(i).startsWith(T);
    }
    for(int i=0 ; i<q ; i++){
      int l=in.nextInt()-1 ;
      int r=in.nextInt()-1 ;
      r-=(m-1);
      int ans=0 ;
      for(int j=l ; j<=r ; j++)if(match[j])ans++;
      pw.println(ans);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var q : int ; q := in.getCurrent()->toInteger() ;
    var S : String ; S := in.getCurrent() ;
    var T : String ; T := in.getCurrent() ;
    var match : Sequence(boolean) ; match := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     match[i+1] := S.subrange(i+1,i)->hasPrefix(T) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var l : int ; l := in.getCurrent()->toInteger() - 1 ;
     var r : int ; r := in.getCurrent()->toInteger() - 1 ;
    r := r-((m - 1)) ; 
    var ans : int ; ans := 0 ;
        var j : int ; j := l ; while j <= r do (     if (match[j+1]) then     ans := ans + 1 ; else skip ;  ;     j := j + 1 ) ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int q=sc.nextInt();
    List<Integer>arr=new ArrayList<Integer>();
    String str=sc.next();
    String cpy=sc.next();
    for(int i=0 ; i<=(n-m); i++){
      if(str.substring(i,i+m).equals(cpy)){
        arr.add(i+1);
        arr.add(i+m);
      }
    }
    int len=arr.size();
    while(q-->0){
      int st=sc.nextInt();
      int end=sc.nextInt();
      if(len==0 ||(end-st)+1<m)System.out.println(0);
      else {
        if(st<arr.get(0))st=arr.get(0);
        int c=0 ;
        for(int i=0 ; i<len ; i+=2){
          if(arr.get(i)>=st && arr.get(i+1)<=end)c+=1 ;
        }
        System.out.println(c);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Sequence{} ;
    var str : String ; str := sc.getCurrent() ;
    var cpy : String ; cpy := sc.getCurrent() ;
        var i : int ; i := 0 ; while i <= (n - m) do ( (     if (str.subrange(i+1,i + m) = cpy) then (     arr := arr->including(i + 1) ; 
     arr := arr->including(i + m) ) else skip )  ;     i := i + 1 ) ; 
    var len : int ; len := arr->size() ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     var st : int ; st := sc.getCurrent()->toInteger() ;
     var end : int ; end := sc.getCurrent()->toInteger() ;
     if (len = 0 or (end - st) + 1 < m) then     OclFile["System.out"].println(0) ; else (     if (st < arr->at(0+1)) then     st := arr->at(0+1) ; else skip ; 
     var c : int ; c := 0 ;
         var i : int ; i := 0 ; while i < len do ( (     if (arr->at(i+1) >= st & arr->at(i + 1+1) <= end) then     c := c+(1) ; else skip )  ;     i := i+(2) ) ; 
     OclFile["System.out"].println(c) ) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static long INF=(long)1e18 ;
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    if(n==1){
      System.out.println(1);
      return ;
    }
    List<Long>list=divisorList(2*n);
    long ans=INF ;
    for(Long a : list){
      long b=2*n/a ;
      long[] eg=extgcd(a,b);
      long g=eg[0];
      long x=eg[1];
      long y=eg[2];
      if(x==0 || y==0)continue ;
      if(g==1){
        if(y<0){
          ans=Math.min(ans,-b*y);
        }
      }
    }
    System.out.println(ans);
  }
  public static List<Long>divisorList(long n){
    List<Long>res=new ArrayList<Long>();
    for(long i=1 ; i*i<=n ; i++){
      if(n % i==0){
        res.add(i);
        long j=n/i ;
        if(j!=i){
          res.add(j);
        }
      }
    }
    res.sort(Comparator.naturalOrder());
    return res ;
  }
  public static long[] extgcd(long a,long b){
    long x0=1,x1=0 ;
    long y0=0,y1=1 ;
    while(b!=0){
      long q=a/b ;
      long r=a % b ;
      long x2=x0-q*x1 ;
      long y2=y0-q*y1 ;
      a=b ;
      b=r ;
      x0=x1 ;
      x1=x2 ;
      y0=y1 ;
      y1=y2 ;
    }
    return new long[] {
      a,x0,y0 };
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute INF : long := 1e18->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    if (n = 1) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    var list : Sequence(long) ; list := divisorList(2 * n) ;
    var ans : long ; ans := INF ;
    for (a : list) do ( (     var b : long ; b := 2 * n / a ;
     var eg : Sequence(long) ; eg := extgcd(a, b) ;
    var g : long ; g := eg[0+1] ;
    var x : long ; x := eg[1+1] ;
    var y : long ; y := eg[2+1] ;
    if (x = 0 or y = 0) then     continue else skip ; 
    if (g = 1) then (     if (y < 0) then (     ans := Set{ans, -b * y}->min() ) else skip ) else skip ; 
 )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation divisorList( n : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var res : Sequence(long) ; res := Sequence{} ;
         var i : long ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     res := res->including(i) ; 
     var j : long ; j := n / i ;
     if (j /= i) then (     res := res->including(j) ) else skip ) else skip )  ;     i := i + 1 ) ; 
     res := res.sort(Comparator.naturalOrder()) ; 
     return res );
  static   operation extgcd( a : long, b : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var x0 : long ; x0 := 1 ;
    var x1 : long ; x1 := 0 ;
     var y0 : long ; y0 := 0 ;
    var y1 : long ; y1 := 1 ;
     while (b /= 0) do (     var q : long ; q := a / b ;
     var r : long ; r := a mod b ;
    var x2 : long ; x2 := x0 - q * x1 ;
    var y2 : long ; y2 := y0 - q * y1 ;
    a := b ; 
    b := r ; 
    x0 := x1 ; 
    x1 := x2 ; 
    y0 := y1 ; 
    y1 := y2 ; 
 ) ; 
     return Sequence{a,x0,y0} );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] $){
    new Main().run();
  }
  long gcd(long a,long b){
    return a==0 ? b : gcd(b % a,a);
  }
  long inv(long a,long M){
    return a==1 ? a :(M+(-M*inv(M % a,a)+1)/a);
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    if(N==1){
      System.out.println(1);
      return ;
    }
    N*=2 ;
    ArrayList<Long>a=new ArrayList<>();
    {
      long N_=N ;
      for(long p=2 ; p*p<=N_ ; ++p){
        long pe=1 ;
        while(N_ % p==0){
          pe*=p ;
          N_/=p ;
        }
        if(pe!=1)a.add(pe);
      }
      if(N_!=1)a.add(N_);
    }
    int n=a.size();
    long ans=Long.MAX_VALUE ;
    for(int s=1 ; s<(1<<n)-1 ; ++s){
      long P=1 ;
      for(int shift=0 ; shift<n ; ++shift){
        if((s>>shift)% 2==1)P*=a.get(shift);
      }
      long Q=N/P ;
      long u=inv(P,Q);
      long v=(u*P-1)/Q ;
      ans=Math.min(ans,v*Q);
    }
    System.out.println(ans);
  }
  void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return if a = 0 then b else gcd(b mod a, a) endif );
   operation inv( a : long, M : long) : long
  pre: true
  post: true
  activity: (     return if a = 1 then a else (M + (-M * inv(M mod a, a) + 1) / a) endif );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    if (N = 1) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    N := N*(2) ; 
    var a : Sequence(long) ; a := Sequence{} ;
(     var N_ : long ; N_ := N ;
         var p : long ; p := 2 ; while p * p <= N_ do ( (     var pe : long ; pe := 1 ;
     while (N_ mod p = 0) do (     pe := pe*(p) ; 
     N_ := N_/(p) ) ; 
     if (pe /= 1) then     a := a->including(pe) ; else skip )  ;     p := p + 1 ) ; 
     if (N_ /= 1) then     a := a->including(N_) ; else skip ) 
    var n : int ; n := a->size() ;
    var ans : long ; ans := "9223372036854775807"->toLong() ;
        var s : int ; s := 1 ; while s < ((1*(2->pow(n)))->oclAsType(long)) - 1 do ( (     var P : long ; P := 1 ;
         var shift : int ; shift := 0 ; while shift < n do ( (     if (((s/(2->pow(shift)))->oclAsType(long)) mod 2 = 1) then     P := P*(a->at(shift+1)) ; else skip )  ;     shift := shift + 1 ) ; 
    var Q : long ; Q := N / P ;
    var u : long ; u := inv(P, Q) ;
    var v : long ; v := (u * P - 1) / Q ;
    ans := Set{ans, v * Q}->min() ; 
 )  ;     s := s + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static ArrayList<Long>arl ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    long N=2*Long.parseLong(br.readLine());
    arl=new ArrayList<>();
    fact(N);
    int n=arl.size();
    long ans=N-1 ;
    for(int i=0 ; i<(1<<n); i++){
      long A=1 ;
      for(int j=0 ; j<n ; j++){
        if((i &(1<<j))>0){
          A*=arl.get(j);
        }
      }
      long B=N/A ;
      long x=inv(B,A);
      if(x*B>1){
        ans=Math.min(ans,x*B-1);
      }
    }
    System.out.println(ans);
  }
  public static void fact(long i){
    for(int j=2 ; j<=Math.sqrt(i); j++){
      long cur=1 ;
      while(i % j==0){
        i/=j ;
        cur*=j ;
      }
      if(cur>1){
        arl.add(cur);
      }
    }
    if(i>1){
      arl.add(i);
    }
  }
  public static long inv(long a,long b){
    if(a==1)return 1 ;
    long q=b/a ;
    long r=b-q*a ;
    long y=-inv(r,a);
    return((b*y+1)/a)+b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute arl : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var N : long ; N := 2 * (br.readLine())->toLong() ;
    arl := Sequence{} ; 
    execute fact(N) ; 
    var n : int ; n := arl->size() ;
    var ans : long ; ans := N - 1 ;
        var i : int ; i := 0 ; while i < ((1*(2->pow(n)))->oclAsType(long)) do ( (     var A : long ; A := 1 ;
         var j : int ; j := 0 ; while j < n do ( (     if ((MathLib.bitwiseAnd(i,((1*(2->pow(j)))->oclAsType(long)))) > 0) then (     A := A*(arl->at(j+1)) ) else skip )  ;     j := j + 1 ) ; 
    var B : long ; B := N / A ;
    var x : long ; x := inv(B, A) ;
    if (x * B > 1) then (     ans := Set{ans, x * B - 1}->min() ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation fact( i : long) : void
  pre: true
  post: true
  activity: (         var j : int ; j := 2 ; while j <= (i)->sqrt() do ( (     var cur : long ; cur := 1 ;
     while (i mod j = 0) do (     i := i/(j) ; 
     cur := cur*(j) ) ; 
     if (cur > 1) then (     arl := arl->including(cur) ) else skip )  ;     j := j + 1 ) ; 
     if (i > 1) then (     arl := arl->including(i) ) else skip );
  static   operation inv( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 1) then     return 1 else skip ; 
     var q : long ; q := b / a ;
    var r : long ; r := b - q * a ;
    var y : long ; y := -inv(r, a) ;
    return ((b * y + 1) / a) + b 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] $){
    new Main().run();
  }
  long gcd(long a,long b){
    return a==0 ? b : gcd(b % a,a);
  }
  long inv(long a,long M){
    return a==1 ? a :(M+(-M*inv(M % a,a)+1)/a);
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    if(N==1){
      System.out.println(1);
      return ;
    }
    N*=2 ;
    long ans=Long.MAX_VALUE ;
    for(long d=2 ; d*d<=N ; ++d)if(N % d==0){
      for(long P : new long[] { d,N/d } ){
          long Q=N/P ;
          if(gcd(P,Q)!=1)continue ;
          long u=inv(P,Q);
          long v=(u*P-1)/Q ;
          ans=Math.min(ans,v*Q);
        }
      }
      System.out.println(ans);
    }
    void tr(Object...objects){
      System.out.println(Arrays.deepToString(objects));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return if a = 0 then b else gcd(b mod a, a) endif );
   operation inv( a : long, M : long) : long
  pre: true
  post: true
  activity: (     return if a = 1 then a else (M + (-M * inv(M mod a, a) + 1) / a) endif );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    if (N = 1) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    N := N*(2) ; 
    var ans : long ; ans := "9223372036854775807"->toLong() ;
        var d : long ; d := 2 ; while d * d <= N do (     if (N mod d = 0) then (     for (P : Sequence{d,N / d}) do ( (     var Q : long ; Q := N / P ;
     if (gcd(P, Q) /= 1) then     continue else skip ; 
    var u : long ; u := inv(P, Q) ;
    var v : long ; v := (u * P - 1) / Q ;
    ans := Set{ans, v * Q}->min() ; 
 )  ) ) else skip ;  ;     d := d + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
public class B1593 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      String s=scanner.next();
      int ans=0 ;
      List<String>list=new LinkedList<>();
      for(int i=s.length()-1 ; i>=0 ; i--){
        char ch=s.charAt(i);
        if(list.size()==0){
          if(ch=='0' || ch=='5'){
            list.add(ch+"");
          }
          else {
            ans++;
          }
        }
        else {
          boolean found=false ;
          for(String str : list){
            if(Integer.valueOf(ch+str)% 25==0){
              found=true ;
              ans+=list.size()-1 ;
              break ;
            }
          }
          if(found){
            break ;
          }
          if(ch=='0' || ch=='5'){
            list.add(ch+"");
          }
          else {
            ans++;
          }
        }
      }
      System.out.println(ans);
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1593 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : String ; s := scanner.getCurrent() ;
     var ans : int ; ans := 0 ;
    var list : Sequence(String) ; list := Sequence{} ;
        var i : int ; i := s->size() - 1 ; while i >= 0 do ( (     var ch : String ; ch := s->at(i+1) ;
     if (list->size() = 0) then (     if (ch = '0' or ch = '5') then (     list := list->including(ch + "") ) else (     ans := ans + 1 ) ) else (     var found : boolean ; found := false ;
     for (str : list) do ( (     if ((ch + str)->toInteger() mod 25 = 0) then (     found := true ; 
     ans := ans+(list->size() - 1) ; 
     break ) else skip )  ) ; 
     if (found) then (     break ) else skip ; 
     if (ch = '0' or ch = '5') then (     list := list->including(ch + "") ) else (     ans := ans + 1 ) ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner scan=new Scanner(System.in);
  public static void main(String[] args){
    String now_script=scan.next();
    char[] swap=null ;
    int i=0 ;
    for(int num=scan.nextInt(); i<=num ; i++){
      if(!(isInteger(now_script))){
        swap=now_script.toCharArray();
        now_script=scan.next();
      }
      else {
        int getcard_num=Integer.parseInt(now_script);
        swap=shuffle(swap,getcard_num);
        if(scan.hasNext("-")){
          System.out.print(swap);
          break ;
        }
        else if(! scan.hasNextInt()){
          i=-1 ;
          System.out.println(swap);
          swap=null ;
          now_script=scan.next();
          num=scan.nextInt();
        }
        else {
          now_script=scan.next();
        }
      }
    }
    System.out.println();
  }
  static boolean isInteger(String num){
    try {
      int n=Integer.parseInt(num);
      return true ;
    }
    catch(NumberFormatException e){
      return false ;
    }
  }
  public static char[] shuffle(char[] swap,int getcard_num){
    char[] tmp=new char[swap.length];
    for(int i=getcard_num ; i<swap.length ; i++){
      tmp[i-getcard_num]=swap[i];
    }
    for(int j=0 ; j<getcard_num ; j++){
      tmp[j+swap.length-getcard_num]=swap[j];
    }
    return tmp ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var now_script : String ; now_script := scan.getCurrent() ;
     var swap : Sequence(String) ; swap := null ;
    var i : int ; i := 0 ;
        var num : int ; num := scan.getCurrent()->toInteger() ; while i <= num do ( (     if (not((isInteger(now_script)))) then (     swap := now_script->characters() ; 
     now_script := scan.getCurrent() ) else (     var getcard_num : int ; getcard_num := (now_script)->toInteger() ;
     swap := shuffle(swap, getcard_num) ; 
     if (scan.hasNext("-")) then (     OclFile["System.out"].print(swap) ; 
     break ) else     if (not(scan.hasNextInt())) then (     i := -1 ; 
     OclFile["System.out"].println(swap) ; 
    swap := null ; 
    now_script := scan.getCurrent() ; 
    num := scan.getCurrent()->toInteger() ; 
 ) else (     now_script := scan.getCurrent() ) ;  ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation isInteger( num : String) : boolean
  pre: true
  post: true
  activity: (     try (     var n : int ; n := (num)->toInteger() ;
     return true )   catch (e : IncorrectElementException) do (     return false )
 );
  static   operation shuffle( swap : Sequence(String), getcard_num : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var tmp : Sequence(String) ; tmp := Integer.subrange(1,swap->size())->collect(0) ;
         var i : int ; i := getcard_num ; while i < swap->size() do ( (     tmp[i - getcard_num+1] := swap[i+1] )  ;     i := i + 1 ) ; 
         var j : int ; j := 0 ; while j < getcard_num do ( (     tmp[j + swap->size() - getcard_num+1] := swap[j+1] )  ;     j := j + 1 ) ; 
     return tmp );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static long INF=(long)1e18 ;
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    if(n==1){
      System.out.println(1);
      return ;
    }
    List<Long>list=divisorList(2*n);
    long ans=INF ;
    for(Long a : list){
      long b=2*n/a ;
      long[] eg=extgcd(a,b);
      long g=eg[0];
      long x=eg[1];
      long y=eg[2];
      if(x==0 || y==0)continue ;
      if(g==1){
        if(y<0){
          ans=Math.min(ans,-b*y);
        }
      }
    }
    System.out.println(ans);
  }
  public static List<Long>divisorList(long n){
    List<Long>res=new ArrayList<Long>();
    for(long i=1 ; i*i<=n ; i++){
      if(n % i==0){
        res.add(i);
        long j=n/i ;
        if(j!=i){
          res.add(j);
        }
      }
    }
    res.sort(Comparator.naturalOrder());
    return res ;
  }
  public static long[] extgcd(long a,long b){
    long x0=1,x1=0 ;
    long y0=0,y1=1 ;
    while(b!=0){
      long q=a/b ;
      long r=a % b ;
      long x2=x0-q*x1 ;
      long y2=y0-q*y1 ;
      a=b ;
      b=r ;
      x0=x1 ;
      x1=x2 ;
      y0=y1 ;
      y1=y2 ;
    }
    return new long[] {
      a,x0,y0 };
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute INF : long := 1e18->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    if (n = 1) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    var list : Sequence(long) ; list := divisorList(2 * n) ;
    var ans : long ; ans := INF ;
    for (a : list) do ( (     var b : long ; b := 2 * n / a ;
     var eg : Sequence(long) ; eg := extgcd(a, b) ;
    var g : long ; g := eg[0+1] ;
    var x : long ; x := eg[1+1] ;
    var y : long ; y := eg[2+1] ;
    if (x = 0 or y = 0) then     continue else skip ; 
    if (g = 1) then (     if (y < 0) then (     ans := Set{ans, -b * y}->min() ) else skip ) else skip ; 
 )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation divisorList( n : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var res : Sequence(long) ; res := Sequence{} ;
         var i : long ; i := 1 ; while i * i <= n do ( (     if (n mod i = 0) then (     res := res->including(i) ; 
     var j : long ; j := n / i ;
     if (j /= i) then (     res := res->including(j) ) else skip ) else skip )  ;     i := i + 1 ) ; 
     res := res.sort(Comparator.naturalOrder()) ; 
     return res );
  static   operation extgcd( a : long, b : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var x0 : long ; x0 := 1 ;
    var x1 : long ; x1 := 0 ;
     var y0 : long ; y0 := 0 ;
    var y1 : long ; y1 := 1 ;
     while (b /= 0) do (     var q : long ; q := a / b ;
     var r : long ; r := a mod b ;
    var x2 : long ; x2 := x0 - q * x1 ;
    var y2 : long ; y2 := y0 - q * y1 ;
    a := b ; 
    b := r ; 
    x0 := x1 ; 
    x1 := x2 ; 
    y0 := y1 ; 
    y1 := y2 ; 
 ) ; 
     return Sequence{a,x0,y0} );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int nthTerm(int N){
    return(2*N+3)*(2*N+3)-2*N ;
  }
  public static void main(String[] args){
    int N=4 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nthTerm( N : int) : int
  pre: true
  post: true
  activity: (     return (2 * N + 3) * (2 * N + 3) - 2 * N );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     OclFile["System.out"].println(nthTerm(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int oddTriangularNumber(int N){
    return(N*((2*N)-1));
  }
  public static void main(String[] args){
    int N=3 ;
    System.out.println(oddTriangularNumber(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation oddTriangularNumber( N : int) : int
  pre: true
  post: true
  activity: (     return (N * ((2 * N) - 1)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
     OclFile["System.out"].println(oddTriangularNumber(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int triplets(int N){
    return((N+1)*(N+2))/2 ;
  }
  public static void main(String[] args){
    int N=50 ;
    System.out.println(triplets(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation triplets( N : int) : int
  pre: true
  post: true
  activity: (     return ((N + 1) * (N + 2)) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 50 ;
     OclFile["System.out"].println(triplets(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int nthTerm(int N){
    int nth=0 ;
    if(N % 2==1)nth=(N*N)+1 ;
    else nth=(N*N)-1 ;
    return nth ;
  }
  public static void main(String[] args){
    int N=5 ;
    System.out.print(nthTerm(N)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nthTerm( N : int) : int
  pre: true
  post: true
  activity: (     var nth : int ; nth := 0 ;
     if (N mod 2 = 1) then     nth := (N * N) + 1 else     nth := (N * N) - 1 ; ;  
     return nth );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     OclFile["System.out"].print(nthTerm(N) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int nthTerm(int N){
    int nth=0 ;
    nth=(N*N*(N+1))/2 ;
    return nth ;
  }
  public static void main(String[] args){
    int N=5 ;
    System.out.println(nthTerm(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation nthTerm( N : int) : int
  pre: true
  post: true
  activity: (     var nth : int ; nth := 0 ;
     nth := (N * N * (N + 1)) / 2 ; 
     return nth );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     OclFile["System.out"].println(nthTerm(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean check(int arr[],int n){
    int modify=0 ;
    if(arr[0]>arr[1]){
      arr[0]=arr[1]/2 ;
      modify++;
    }
    for(int i=1 ; i<n-1 ; i++){
      if((arr[i-1]<arr[i] && arr[i+1]<arr[i])||(arr[i-1]>arr[i] && arr[i+1]>arr[i])){
        arr[i]=(arr[i-1]+arr[i+1])/2 ;
        if(arr[i]==arr[i-1] || arr[i]==arr[i+1])return false ;
        modify++;
      }
    }
    if(arr[n-1]<arr[n-2])modify++;
    if(modify>1)return false ;
    return true ;
  }
  public static void main(String[] args){
    int[] arr={
      2,4,8,6,9,12 };
      int n=arr.length ;
      if(check(arr,n))System.out.print("Yes");
      else System.out.print("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation check( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var modify : int ; modify := 0 ;
     if (arr[0+1] > arr[1+1]) then (     arr[0+1] := arr[1+1] / 2 ; 
     modify := modify + 1 ) else skip ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     if ((arr[i - 1+1] < arr[i+1] & arr[i + 1+1] < arr[i+1]) or (arr[i - 1+1] > arr[i+1] & arr[i + 1+1] > arr[i+1])) then (     arr[i+1] := (arr[i - 1+1] + arr[i + 1+1]) / 2 ; 
     if (arr[i+1] = arr[i - 1+1] or arr[i+1] = arr[i + 1+1]) then     return false else skip ; 
     modify := modify + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (arr[n - 1+1] < arr[n - 2+1]) then     modify := modify + 1 ; else skip ; 
    if (modify > 1) then     return false else skip ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,8,6,9,12} ;
     var n : int ; n := arr->size() ;
     if (check(arr, n)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class C {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    if(check("AB","BA",s)|| check("BA","AB",s)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
  public static boolean check(String s1,String s2,String s){
    int check=0 ;
    int ind=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(check==0){
        if(s.charAt(i)==s1.charAt(ind)){
          ind++;
        }
        else {
          ind=0 ;
          if(s.charAt(i)==s1.charAt(ind)){
            ind++;
          }
        }
        if(ind==2){
          check=1 ;
          ind=0 ;
        }
      }
      else {
        if(s.charAt(i)==s2.charAt(ind)){
          ind++;
        }
        else {
          ind=0 ;
          if(s.charAt(i)==s2.charAt(ind)){
            ind++;
          }
        }
        if(ind==2){
          return true ;
        }
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
     if (check("AB", "BA", s) or check("BA", "AB", s)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
  static   operation check( s1 : String, s2 : String, s : String) : boolean
  pre: true
  post: true
  activity: (     var check : int ; check := 0 ;
     var ind : int ; ind := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (check = 0) then (     if (s->at(i+1) = s1->at(ind+1)) then (     ind := ind + 1 ) else (     ind := 0 ; 
     if (s->at(i+1) = s1->at(ind+1)) then (     ind := ind + 1 ) else skip ) ;  
     if (ind = 2) then (     check := 1 ; 
     ind := 0 ) else skip ) else (     if (s->at(i+1) = s2->at(ind+1)) then (     ind := ind + 1 ) else (     ind := 0 ; 
     if (s->at(i+1) = s2->at(ind+1)) then (     ind := ind + 1 ) else skip ) ;  
     if (ind = 2) then (     return true ) else skip ) )  ;     i := i + 1 ) ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class TwoString {
  String letter ;
  public TwoString(String letter){
    this.letter=letter ;
  }
  public void printYesOrNo(){
    boolean ba=true ;
    boolean ab=true ;
    int countBa=0 ;
    int countAb=0 ;
    int countBAB=0 ;
    int countABA=0 ;
    for(int i=0 ; i<letter.length(); i++){
      if(i!=letter.length()-1){
        if(letter.charAt(i)=='A' && letter.charAt(i+1)=='B'){
          if(i<letter.length()-2){
            if(letter.charAt(i+2)=='A'){
              i+=2 ;
              countABA++;
            }
            else {
              ab=false ;
              i++;
            }
          }
          else {
            ab=false ;
            i++;
          }
        }
        else if(letter.charAt(i)=='B' && letter.charAt(i+1)=='A'){
          if(i<letter.length()-2){
            if(letter.charAt(i+2)=='B'){
              i+=2 ;
              countBAB++;
            }
            else {
              ba=false ;
              i++;
            }
          }
          else {
            ba=false ;
            i++;
          }
        }
      }
    }
    if((countABA>=1 || countBAB>=1)&& ab==true && ba==false){
      ab=false ;
    }
    else if((countABA>=1 || countBAB>=1)&& ab==false && ba==true){
      ba=false ;
    }
    else if(countBAB+countABA>1 && ab==true && ba==true){
      ab=false ;
      ba=false ;
    }
    if(ba==false && ab==false){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
  public static void main(String[] a){
    Scanner input=new Scanner(System.in);
    String s=input.next();
    TwoString instance=new TwoString(s);
    instance.printYesOrNo();
  }
}
------------------------------------------------------------
OCL File:
---------
 class TwoString {
   attribute letter : String;
   static operation newTwoString( letter : String) : TwoString
  pre: true
  post: true
  activity:
  ( var self : TwoString ;
    self := createTwoString();
    self.initialise(letter);
    return self );
  operation initialise( letter : String) : void
  pre: true  post: true
  activity: (     self.letter := letter );
   operation printYesOrNo() : void
  pre: true
  post: true
  activity: (     var ba : boolean ; ba := true ;
     var ab : boolean ; ab := true ;
    var countBa : int ; countBa := 0 ;
    var countAb : int ; countAb := 0 ;
    var countBAB : int ; countBAB := 0 ;
    var countABA : int ; countABA := 0 ;
        var i : int ; i := 0 ; while i < letter->size() do ( (     if (i /= letter->size() - 1) then (     if (letter->at(i+1) = 'A' & letter->at(i + 1+1) = 'B') then (     if (i < letter->size() - 2) then (     if (letter->at(i + 2+1) = 'A') then (     i := i+(2) ; 
     countABA := countABA + 1 ) else (     ab := false ; 
     i := i + 1 ) ) else (     ab := false ; 
     i := i + 1 ) ) else     if (letter->at(i+1) = 'B' & letter->at(i + 1+1) = 'A') then (     if (i < letter->size() - 2) then (     if (letter->at(i + 2+1) = 'B') then (     i := i+(2) ; 
     countBAB := countBAB + 1 ) else (     ba := false ; 
     i := i + 1 ) ) else (     ba := false ; 
     i := i + 1 ) ) else skip ; ) else skip )  ;     i := i + 1 ) ; 
    if ((countABA >= 1 or countBAB >= 1) & ab = true & ba = false) then (     ab := false ) else     if ((countABA >= 1 or countBAB >= 1) & ab = false & ba = true) then (     ba := false ) else     if (countBAB + countABA > 1 & ab = true & ba = true) then (     ab := false ; 
     ba := false ) else skip ; ;  ;  
    if (ba = false & ab = false) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := input.getCurrent() ;
     var instance : TwoString ; instance := TwoString.newTwoString(s) ;
     instance.printYesOrNo() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static int dfs(String str){
    List<String>first=new ArrayList<>();
    first.add("0");
    first.add("5");
    int ans=0 ;
    int i=0 ;
    int f=Integer.MAX_VALUE ;
    String temp="" ;
    for(i=str.length()-1 ; i>=0 ; i--){
      if(str.charAt(i)=='0'){
        int j=i-1 ;
        int p=0 ;
        while(j>=0){
          if(j>=0 &&(str.charAt(j)=='0' || str.charAt(j)=='5')){
            f=Math.min(ans+p,f);
            break ;
          }
          else {
            p+=1 ;
          }
          j--;
        }
      }
      else if(str.charAt(i)=='5'){
        int j=i-1 ;
        int p=0 ;
        while(j>=0){
          if(j>=0 &&(str.charAt(j)=='7' || str.charAt(j)=='2')){
            f=Math.min(ans+p,f);
            break ;
          }
          else {
            p+=1 ;
          }
          j--;
        }
      }
      ans+=1 ;
    }
    return f ;
  }
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      String s=sc.next();
      if(Long.parseLong(s)% 25==0){
        System.out.println(0);
      }
      else {
        int k=dfs(s);
        System.out.println(k);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation dfs( str : String) : int
  pre: true
  post: true
  activity: (     var first : Sequence(String) ; first := Sequence{} ;
     first := first->including("0") ; 
    first := first->including("5") ; 
    var ans : int ; ans := 0 ;
    var i : int ; i := 0 ;
    var f : int ; f := 2147483647 ;
    var temp : String ; temp := "" ;
        i := str->size() - 1 ; while i >= 0 do ( (     if (str->at(i+1) = '0') then (     var j : int ; j := i - 1 ;
     var p : int ; p := 0 ;
     while (j >= 0) do (     if (j >= 0 & (str->at(j+1) = '0' or str->at(j+1) = '5')) then (     f := Set{ans + p, f}->min() ; 
     break ) else (     p := p+(1) ) ;  
     j := j - 1 ) ) else     if (str->at(i+1) = '5') then (     var j : int ; j := i - 1 ;
     var p : int ; p := 0 ;
     while (j >= 0) do (     if (j >= 0 & (str->at(j+1) = '7' or str->at(j+1) = '2')) then (     f := Set{ans + p, f}->min() ; 
     break ) else (     p := p+(1) ) ;  
     j := j - 1 ) ) else skip ; ;  
     ans := ans+(1) )  ;     i := i - 1 ) ; 
    return f 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : String ; s := sc.getCurrent() ;
     if ((s)->toLong() mod 25 = 0) then (     OclFile["System.out"].println(0) ) else (     var k : int ; k := dfs(s) ;
     OclFile["System.out"].println(k) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void solve(String s,int k){
    int count=0,length=0,pos=0 ;
    HashMap<Character,Integer>m=new HashMap<Character,Integer>();
    for(int i=0 ; i<s.length(); i++){
      if(m.containsKey(s.charAt(i)))m.put(s.charAt(i),m.get(s.charAt(i))+1);
      else m.put(s.charAt(i),1);
      length++;
      if(length>k){
        m.put(s.charAt(pos),m.get(s.charAt(pos))-1);
        pos++;
        length--;
      }
      if(length==k && m.get(s.charAt(i))==length)count++;
    }
    System.out.println(count);
  }
  public static void main(String[] args){
    String s="aaaabbbccdddd" ;
    int k=4 ;
    solve(s,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( s : String, k : int) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
    var length : int ; length := 0 ;
    var pos : int ; pos := 0 ;
     var m : Map(String,int) ; m := Map{} ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (m->keys()->includes(s->at(i+1))) then     m := m->union(Map{s->at(i+1) |-> m->at(s->at(i+1)) + 1}) else     m := m->union(Map{s->at(i+1) |-> 1}) ; ;  
     length := length + 1 ; 
     if (length > k) then (     m := m->union(Map{s->at(pos+1) |-> m->at(s->at(pos+1)) - 1}) ; 
     pos := pos + 1 ; 
     length := length - 1 ) else skip ; 
     if (length = k & m->at(s->at(i+1)) = length) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "aaaabbbccdddd" ;
     var k : int ; k := 4 ;
     execute solve(s, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int freqPairs(int arr[],int n){
    int max=Arrays.stream(arr).max().getAsInt();
    int freq[]=new int[max+1];
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      freq[arr[i] ]++;
    }
    for(int i=0 ; i<n ; i++){
      for(int j=2*arr[i]; j<=max ; j+=arr[i]){
        if(freq[j]>=1){
          count+=freq[j];
        }
      }
      if(freq[arr[i] ]>1){
        count+=freq[arr[i] ]-1 ;
        freq[arr[i] ]--;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      3,2,4,2,6 };
      int n=arr.length ;
      System.out.println(freqPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation freqPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var max : int ; max := stream(arr).max().getAsInt() ;
     var freq : Sequence(int) ; freq := Integer.subrange(1,max + 1)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     freq[arr[i+1]+1] := freq[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 2 * arr[i+1] ; while j <= max do ( (     if (freq[j+1] >= 1) then (     count := count+(freq[j+1]) ) else skip )  ;     j := j+(arr[i+1]) ) ; 
     if (freq[arr[i+1]+1] > 1) then (     count := count+(freq[arr[i+1]+1] - 1) ; 
     freq[arr[i+1]+1] := freq[arr[i+1]+1] - 1 ) else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,2,4,2,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(freqPairs(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    ArrayList<String>list=new ArrayList<>();
    while(true){
      StringBuilder str=new StringBuilder(in.next());
      if(str.substring(0).equals("-")){
        break ;
      }
      else {
        int shuffle_num=in.nextInt();
        for(int i=0 ; i<shuffle_num ; i++){
          int card_num=in.nextInt();
          String shuffle_word=str.substring(0,card_num);
          str.delete(0,card_num);
          str.append(shuffle_word);
        }
      }
      list.add(str.toString());
    }
    for(String result : list){
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(String) ; list := Sequence{} ;
     while (true) do (     var str : String ; str := StringLib.newString(in.getCurrent()) ;
     if (str.subrange(0+1,0) = "-") then (     break ) else (     var shuffle_num : int ; shuffle_num := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < shuffle_num do ( (     var card_num : int ; card_num := in.getCurrent()->toInteger() ;
     var shuffle_word : String ; shuffle_word := str.subrange(0+1,card_num) ;
     str := str->antirestrict( Integer.subrange(0+1,card_num) ) ; 
     str := str + StringLib.newString(shuffle_word) )  ;     i := i + 1 ) ) ;  
     list := list->including(str+"") ) ; 
     for (result : list) do ( (     OclFile["System.out"].println(result) )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxOperations(int X,int Y){
    if(X>Y)return-1 ;
    int diff=Y-X ;
    if(diff==1)return-1 ;
    if(diff % 2==0)return(diff/2);
    return(1+((diff-3)/2));
  }
  public static void main(String[] args){
    int X=5,Y=16 ;
    System.out.println(maxOperations(X,Y));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxOperations( X : int, Y : int) : int
  pre: true
  post: true
  activity: (     if (X > Y) then     return -1 else skip ; 
     var diff : int ; diff := Y - X ;
    if (diff = 1) then     return -1 else skip ; 
    if (diff mod 2 = 0) then     return (diff / 2) else skip ; 
    return (1 + ((diff - 3) / 2)) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 5 ;
    var Y : int ; Y := 16 ;
     OclFile["System.out"].println(maxOperations(X, Y)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void ReplaceElements(int arr[],int n){
    int min_ele=arr[0];
    arr[0]=-1 ;
    for(int i=1 ; i<n ; ++i){
      if(min_ele<arr[i]){
        arr[i]=min_ele ;
      }
      else if(min_ele>=arr[i]){
        int temp=arr[i];
        arr[i]=min_ele ;
        min_ele=temp ;
      }
    }
  }
  public static void main(String[] args){
    int arr[]={
      4,5,2,1,7,6 };
      int n=arr.length ;
      ReplaceElements(arr,n);
      for(int i=0 ; i<n ; ++i){
        System.out.print(arr[i]+" ");
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation ReplaceElements( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var min_ele : int ; min_ele := arr[0+1] ;
     arr[0+1] := -1 ; 
         var i : int ; i := 1 ; while i < n do ( (     if (min_ele < arr[i+1]) then (     arr[i+1] := min_ele ) else     if (min_ele >= arr[i+1]) then (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := min_ele ; 
     min_ele := temp ) else skip ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,5,2,1,7,6} ;
     var n : int ; n := arr->size() ;
     execute ReplaceElements(arr, n) ; 
         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args){
    final int PENALTY_TIME=1200 ;
    Scanner sc=new Scanner(System.in);
    while(true){
      int t=sc.nextInt();
      int p=sc.nextInt();
      int r=sc.nextInt();
      if(t==0){
        break ;
      }
      Team[] teamArray=new Team[t];
      for(int i=0 ; i<teamArray.length ; i++){
        teamArray[i]=new Team(i+1,p);
      }
      for(int i=0 ; i<r ; i++){
        int tId=sc.nextInt();
        int pId=sc.nextInt();
        int time=sc.nextInt();
        String message=sc.next();
        if(message.equals("CORRECT")){
          teamArray[tId-1] .ans++;
          teamArray[tId-1] .time+=teamArray[tId-1] .wrongAnswer[pId-1]*PENALTY_TIME+time ;
        }
        else if(message.equals("WRONG")){
          teamArray[tId-1] .wrongAnswer[pId-1]++;
        }
      }
      Arrays.sort(teamArray);
      for(int i=0 ; i<teamArray.length ; i++){
        System.out.println(teamArray[i] .id+" "+teamArray[i] .ans+" "+teamArray[i] .time);
      }
    }
  }
}
class Team implements Comparable<Team>{
  int id ;
  int ans ;
  int time ;
  int[] wrongAnswer ;
  Team(int id,int p){
    this.id=id ;
    this.ans=0 ;
    this.time=0 ;
    this.wrongAnswer=new int[p];
  }
  public int compareTo(Team o){
    if(this.ans!=o.ans){
      return o.ans-this.ans ;
    }
    else if(this.time!=o.time){
      return this.time-o.time ;
    }
    else if(this.id!=o.id){
      return this.id-o.id ;
    }
    else {
      return 0 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var PENALTY_TIME : int ; PENALTY_TIME := 1200 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var t : int ; t := sc.getCurrent()->toInteger() ;
     var p : int ; p := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    if (t = 0) then (     break ) else skip ; 
    var teamArray : Sequence(Team) ; teamArray := Integer.subrange(1,t)->collect(null) ;
        var i : int ; i := 0 ; while i < teamArray->size() do ( (     teamArray[i+1] := Team.newTeam(i + 1, p) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < r do ( (     var tId : int ; tId := sc.getCurrent()->toInteger() ;
     var pId : int ; pId := sc.getCurrent()->toInteger() ;
    var time : int ; time := sc.getCurrent()->toInteger() ;
    var message : String ; message := sc.getCurrent() ;
    if (message = "CORRECT") then (     teamArray[tId - 1+1].ans := teamArray[tId - 1+1].ans + 1 ; 
     teamArray[tId - 1+1].time := teamArray[tId - 1+1].time+(teamArray[tId - 1+1].wrongAnswer[pId - 1+1] * PENALTY_TIME + time) ) else     if (message = "WRONG") then (     teamArray[tId - 1+1].wrongAnswer[pId - 1+1] := teamArray[tId - 1+1].wrongAnswer[pId - 1+1] + 1 ) else skip ; ;  
 )  ;     i := i + 1 ) ; 
    teamArray := teamArray->sort() ; 
        var i : int ; i := 0 ; while i < teamArray->size() do ( (     OclFile["System.out"].println(teamArray[i+1].id + " " + teamArray[i+1].ans + " " + teamArray[i+1].time) )  ;     i := i + 1 ) ; 
 ) );
}
class Team implements Comparable<Team> {
   attribute id : int;
   attribute ans : int;
   attribute time : int;
   attribute wrongAnswer : Sequence(int);
   static operation newTeam( id : int, p : int) : Team
  pre: true
  post: true
  activity:
  ( var self : Team ;
    self := createTeam();
    self.initialise(id, p);
    return self );
  operation initialise( id : int, p : int) : void
  pre: true  post: true
  activity: (     self.id := id ; 
     self.ans := 0 ; 
     self.time := 0 ; 
     self.wrongAnswer := Integer.subrange(1,p)->collect(0) );
   operation compareTo( o : Team) : int
  pre: true
  post: true
  activity: (     if (self.ans /= o.ans) then (     return o.ans - self.ans ) else     if (self.time /= o.time) then (     return self.time - o.time ) else     if (self.id /= o.id) then (     return self.id - o.id ) else (     return 0 ) ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class GeeksForGeeks {
  public static int longestAr(int n,int arr[]){
    Hashtable<Integer,Integer>count=new Hashtable<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      if(count.containsKey(arr[i]))count.put(arr[i],count.get(arr[i])+1);
      else count.put(arr[i],1);
    }
    Set<Integer>kset=count.keySet();
    Iterator<Integer>it=kset.iterator();
    int max=0 ;
    while(it.hasNext()){
      int a=(int)it.next();
      int cur=0 ;
      int cur1=0 ;
      int cur2=0 ;
      if(count.containsKey(a+1))cur1=count.get(a+1);
      if(count.containsKey(a-1))cur2=count.get(a-1);
      cur=count.get(a)+Math.max(cur1,cur2);
      if(cur>max)max=cur ;
    }
    return(max);
  }
  public static void main(String[] args){
    int n=8 ;
    int arr[]={
      2,2,3,5,5,6,6,6 };
      int maxLen=longestAr(n,arr);
      System.out.println(maxLen);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GeeksForGeeks {
  static   operation longestAr( n : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var count : Map(int,int) ; count := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (count->keys()->includes(arr[i+1])) then     count := count->union(Map{arr[i+1] |-> count->at(arr[i+1]) + 1}) ; else     count := count->union(Map{arr[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
    var kset : Set(int) ; kset := count->keys() ;
    var it : OclIterator ; it := kset->iterator() ;
    var max : int ; max := 0 ;
    while (it.hasNext()) do (     var a : int ; a := it.next()->oclAsType(int) ;
     var cur : int ; cur := 0 ;
    var cur1 : int ; cur1 := 0 ;
    var cur2 : int ; cur2 := 0 ;
    if (count->keys()->includes(a + 1)) then     cur1 := count->at(a + 1) ; else skip ; 
    if (count->keys()->includes(a - 1)) then     cur2 := count->at(a - 1) ; else skip ; 
    cur := count->at(a) + Set{cur1, cur2}->max() ; 
    if (cur > max) then     max := cur ; else skip ; 
 ) ; 
    return (max) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     var arr : Sequence(int) ; arr := Sequence{2,2,3,5,5,6,6,6} ;
     var maxLen : int ; maxLen := longestAr(n, arr) ;
     OclFile["System.out"].println(maxLen) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
public class Main {
  Scanner sc ;
  int N,K ;
  int[] a ;
  int sum ;
  public Main(){
    sc=new Scanner(System.in);
  }
  private void calc(){
    N=sc.nextInt();
    K=sc.nextInt();
    a=new int[N+1];
    sum=0 ;
    for(int i=1 ; i<=N ; i++){
      a[i]=sc.nextInt();
      sum+=a[i];
    }
    Set<Integer>divisors=new HashSet<>();
    int sqrt=(int)Math.sqrt(sum);
    for(int d=1 ; d<=sqrt ; d++){
      if(sum % d!=0)continue ;
      divisors.add(d);
      divisors.add(sum/d);
    }
    int max=-1 ;
    for(int d : divisors){
      int c=check(d);
      if(c>K)continue ;
      if(max<d)max=d ;
    }
    out(max);
  }
  private int check(int d){
    int[] diff=new int[N+1];
    int remain=0 ;
    for(int i=1 ; i<=N ; i++){
      diff[i]=a[i] % d ;
      remain+=diff[i];
    }
    Arrays.sort(diff,1,diff.length);
    int result=remain ;
    for(int i=N ; i>=1 ; i--){
      if(remain==0)break ;
      remain-=d ;
      result=result+(d-diff[i])-diff[i];
      diff[i]-=d ;
    }
    return result/2 ;
  }
  private void out(Object o){
    System.out.println(o);
    System.out.flush();
  }
  public static void main(String[] args){
    Main m=new Main();
    m.calc();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   attribute N : int;
   attribute a : Sequence(int);
   attribute sum : int;
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) );
   operation calc() : void
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     K := sc.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,N + 1)->collect(0) ; 
    sum := 0 ; 
        var i : int ; i := 1 ; while i <= N do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    var divisors : Set(int) ; divisors := Set{} ;
    var sqrt : int ; sqrt := (sum)->sqrt()->oclAsType(int) ;
        var d : int ; d := 1 ; while d <= sqrt do ( (     if (sum mod d /= 0) then     continue else skip ; 
     divisors := divisors->including(d) ; 
     divisors := divisors->including(sum / d) )  ;     d := d + 1 ) ; 
    var max : int ; max := -1 ;
    for (d : divisors) do ( (     var c : int ; c := check(d) ;
     if (c > K) then     continue else skip ; 
     if (max < d) then     max := d ; else skip )  ) ; 
    execute out(max) ; 
 );
   operation check( d : int) : int
  pre: true
  post: true
  activity: (     var diff : Sequence(int) ; diff := Integer.subrange(1,N + 1)->collect(0) ;
     var remain : int ; remain := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     diff[i+1] := a[i+1] mod d ; 
     remain := remain+(diff[i+1]) )  ;     i := i + 1 ) ; 
    diff := diff.subrange(1,1)^(diff.subrange(1+1,diff->size())->sort())^diff.subrange(diff->size()+1,diff.size) ; 
    var result : int ; result := remain ;
        var i : int ; i := N ; while i >= 1 do ( (     if (remain = 0) then     break else skip ; 
     remain := remain-(d) ; 
     result := result + (d - diff[i+1]) - diff[i+1] ; 
     diff[i+1] := diff[i+1]-(d) )  ;     i := i - 1 ) ; 
    return result / 2 
 );
   operation out( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) ; 
     OclFile["System.out"].flush() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.calc() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    solve(System.in,System.out);
  }
  static void solve(InputStream is,PrintStream os){
    Scanner sc=new Scanner(is);
    int n=sc.nextInt();
    long k=sc.nextLong();
    int[] a=new int[n];
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      sum+=a[i];
    }
    for(int divS=1 ; divS<=sum ; divS++){
      if(sum % divS!=0)continue ;
      int divL=sum/divS ;
      if(isValid(divL,k,n,a)){
        os.println(divL);
        return ;
      }
    }
  }
  private static boolean isValid(int d,long k,int n,int[] a){
    int[] rest=new int[n];
    for(int i=0 ; i<n ; i++){
      int r=a[i] % d ;
      rest[i]=r ;
      if(k<r && k<d-r)return false ;
    }
    int count=0 ;
    Arrays.sort(rest);
    int remain=0 ;
    int l=0 ;
    int r=n-1 ;
    while(l<=r){
      if(0<=remain){
        int val=rest[r];
        remain+=val-d ;
        count+=d-val ;
        r--;
      }
      else {
        int val=rest[l];
        remain+=val ;
        count+=val ;
        l++;
      }
    }
    return count<=2*k ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation solve( is : OclFile, os : OclFile) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(is) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
        var divS : int ; divS := 1 ; while divS <= sum do ( (     if (sum mod divS /= 0) then     continue else skip ; 
     var divL : int ; divL := sum / divS ;
     if (isValid(divL, k, n, a)) then (     os.println(divL) ; 
     return ) else skip )  ;     divS := divS + 1 ) ; 
 );
  static   operation isValid( d : int, k : long, n : int, a : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var rest : Sequence(int) ; rest := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     var r : int ; r := a[i+1] mod d ;
     rest[i+1] := r ; 
     if (k < r & k < d - r) then     return false else skip )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    rest := rest->sort() ; 
    var remain : int ; remain := 0 ;
    var l : int ; l := 0 ;
    var r : int ; r := n - 1 ;
    while (l <= r) do (     if (0 <= remain) then (     var val : int ; val := rest[r+1] ;
     remain := remain+(val - d) ; 
     count := count+(d - val) ; 
     r := r - 1 ) else (     var val : int ; val := rest[l+1] ;
     remain := remain+(val) ; 
     count := count+(val) ; 
     l := l + 1 ) ) ; 
    return count <= 2 * k 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String str=in.next();
    int first1=str.indexOf("[");
    if(first1==-1)System.out.print(-1);
    else {
      int first2=str.indexOf(":",first1);
      if(first2==-1)System.out.print(-1);
      else {
        int last1=str.lastIndexOf("] ");
        if(last1==-1 || last1<=first2+1)System.out.print(-1);
        else {
          int last2=str.lastIndexOf(":",last1);
          if(last2==first2)System.out.print(-1);
          else {
            int sum=0 ;
            for(int i=first2+1 ; i<last2 ; i++){
              if(str.charAt(i)=='|')sum++;
            }
            System.out.print(sum+4);
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := in.getCurrent() ;
     var first1 : int ; first1 := str->indexOf("[")-1 ;
     if (first1 = -1) then     OclFile["System.out"].print(-1) ; else (     var first2 : int ; first2 := str.subrange(first1+1)->indexOf(":"+"") + first1 - 1  ;
     if (first2 = -1) then     OclFile["System.out"].print(-1) ; else (     var last1 : int ; last1 := str->lastIndexOf("] ")-1 ;
     if (last1 = -1 or last1 <= first2 + 1) then     OclFile["System.out"].print(-1) ; else (     var last2 : int ; last2 := str.subrange(1,last1+1)->lastIndexOf(":"+"")-1  ;
     if (last2 = first2) then     OclFile["System.out"].print(-1) ; else (     var sum : int ; sum := 0 ;
         var i : int ; i := first2 + 1 ; while i < last2 do ( (     if (str->at(i+1) = '|') then     sum := sum + 1 ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(sum + 4) ) ) ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static boolean solve(int N,int K,int[] A,int max){
    int[] B=new int[N];
    for(int j=0 ; j<N ; j++){
      B[j]=A[j] % max ;
    }
    int k=0 ;
    Arrays.sort(B);
    int l=0 ;
    int r=N-1 ;
    while(l<r){
      int v1=B[l];
      int v2=max-B[r];
      if(v1<=v2){
        k+=v1 ;
        B[l]-=v1 ;
        B[r]+=v1 ;
        l++;
      }
      else {
        k+=v2 ;
        B[l]-=v2 ;
        B[r]+=v2 ;
        r--;
      }
    }
    if(k<=K){
      System.out.println(max);
      return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int K=sc.nextInt();
    int[] A=intArray(sc,N);
    int sum=0 ;
    for(int i=0 ; i<N ; i++){
      sum+=A[i];
    }
    int lim=(int)Math.sqrt(sum)+1 ;
    boolean ok=false ;
    for(int i=1 ; i<lim ; i++){
      if(sum % i!=0)continue ;
      int max=sum/i ;
      ok=solve(N,K,A,max);
      if(ok)break ;
    }
    if(! ok){
      for(int i=lim ; i>=1 ; i--){
        if(sum % i!=0)continue ;
        ok=solve(N,K,A,i);
        if(ok)break ;
      }
    }
  }
  static int[] intArray(Scanner sc,int N){
    int[] arr=new int[N];
    for(int i=0 ; i<N ; i++){
      arr[i]=sc.nextInt();
    }
    return arr ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( N : int, K : int, A : Sequence(int), max : int) : boolean
  pre: true
  post: true
  activity: (     var B : Sequence(int) ; B := Integer.subrange(1,N)->collect(0) ;
         var j : int ; j := 0 ; while j < N do ( (     B[j+1] := A[j+1] mod max )  ;     j := j + 1 ) ; 
    var k : int ; k := 0 ;
    B := B->sort() ; 
    var l : int ; l := 0 ;
    var r : int ; r := N - 1 ;
    while (l < r) do (     var v1 : int ; v1 := B[l+1] ;
     var v2 : int ; v2 := max - B[r+1] ;
     if (v1 <= v2) then (     k := k+(v1) ; 
     B[l+1] := B[l+1]-(v1) ; 
     B[r+1] := B[r+1]+(v1) ; 
     l := l + 1 ) else (     k := k+(v2) ; 
     B[l+1] := B[l+1]-(v2) ; 
     B[r+1] := B[r+1]+(v2) ; 
     r := r - 1 ) ) ; 
    if (k <= K) then (     OclFile["System.out"].println(max) ; 
     return true ) else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := intArray(sc, N) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     sum := sum+(A[i+1]) )  ;     i := i + 1 ) ; 
    var lim : int ; lim := (sum)->sqrt()->oclAsType(int) + 1 ;
    var ok : boolean ; ok := false ;
        var i : int ; i := 1 ; while i < lim do ( (     if (sum mod i /= 0) then     continue else skip ; 
     var max : int ; max := sum / i ;
     ok := solve(N, K, A, max) ; 
     if (ok) then     break else skip )  ;     i := i + 1 ) ; 
    if (not(ok)) then (         var i : int ; i := lim ; while i >= 1 do ( (     if (sum mod i /= 0) then     continue else skip ; 
     ok := solve(N, K, A, i) ; 
     if (ok) then     break else skip )  ;     i := i - 1 ) ) else skip ; 
 );
  static   operation intArray( sc : OclFile, N : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
         var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return arr );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final TreeMap<Long,Integer>factorization=new TreeMap<>();
  static final List<Long>factors=new ArrayList<>();
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    long ln=n ;
    long k=in.nextInt();
    long[] array=new long[n];
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      array[i]=in.nextLong();
      sum+=array[i];
    }
    long sumTemp=sum ;
    for(long p=2 ; p<22361 ; p++){
      int power ;
      for(power=0 ; sumTemp % p==0 ; sumTemp/=p,power++);
      if(power>0){
        factorization.put(p,power);
      }
    }
    if(sumTemp!=1L){
      factorization.put(sumTemp,1);
    }
    generateFactors(1);
    factors.sort(Comparator.reverseOrder());
    for(long f : factors){
      Long[] residues=new Long[n];
      long residueSum=0 ;
      for(int i=0 ; i<n ; i++){
        residues[i]=array[i] % f ;
        residueSum+=residues[i];
      }
      Arrays.sort(residues);
      long req=0 ;
      long li=0 ;
      for(int i=0 ; li<ln-(residueSum/f); i++,li++){
        req+=residues[i];
      }
      if(k>=req){
        System.out.println(f);
        return ;
      }
    }
  }
  static void generateFactors(long curr){
    if(factorization.isEmpty()){
      factors.add(curr);
    }
    else {
      long p=factorization.firstKey();
      int power=factorization.remove(p);
      for(int e=0 ; e<=power ; e++,curr*=p){
        generateFactors(curr);
      }
      factorization.put(p,power);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute factorization : Map(long,int) := Map{};
  static    attribute factors : Sequence(long) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var ln : long ; ln := n ;
    var k : long ; k := in.getCurrent()->toInteger() ;
    var array : Sequence(long) ; array := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := in.getCurrent()->toLong() ; 
     sum := sum+(array[i+1]) )  ;     i := i + 1 ) ; 
    var sumTemp : long ; sumTemp := sum ;
        var p : long ; p := 2 ; while p < 22361 do ( (     var power : int ;
         power := 0 ; while sumTemp mod p = 0 do (   ;     sumTemp := sumTemp/(p) ;     power := power + 1 ) ; 
     if (power > 0) then (     factorization := factorization->union(Map{p |-> power}) ) else skip )  ;     p := p + 1 ) ; 
    if (sumTemp /= 1L) then (     factorization := factorization->union(Map{sumTemp |-> 1}) ) else skip ; 
    execute generateFactors(1) ; 
    factors := factors.sort(Comparator.reverseOrder()) ; 
    for (f : factors) do ( (     var residues : Sequence(long) ; residues := Integer.subrange(1,n)->collect(null) ;
     var residueSum : long ; residueSum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     residues[i+1] := array[i+1] mod f ; 
     residueSum := residueSum+(residues[i+1]) )  ;     i := i + 1 ) ; 
    residues := residues->sort() ; 
    var req : long ; req := 0 ;
    var li : long ; li := 0 ;
        var i : int ; i := 0 ; while li < ln - (residueSum / f) do ( (     req := req+(residues[i+1]) )  ;     i := i + 1 ;     li := li + 1 ) ; 
    if (k >= req) then (     OclFile["System.out"].println(f) ; 
     return ) else skip ; 
 )  ) ; 
 );
  static   operation generateFactors( curr : long) : void
  pre: true
  post: true
  activity: (     if (factorization->isEmpty()) then (     factors := factors->including(curr) ) else (     var p : long ; p := factorization->keys()->min() ;
     var power : int ; power := factorization->at(p) ;
         var e : int ; e := 0 ; while e <= power do ( (     execute generateFactors(curr) )  ;     e := e + 1 ;     curr := curr*(p) ) ; 
     factorization := factorization->union(Map{p |-> power}) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int pay(int price,int tax){
    return price*(100+tax)/100 ;
  }
  static int max(int a,int b){
    if(a>b){
      return a ;
    }
    else {
      return b ;
    }
  }
  static int solve(int x,int y,int sum){
    int answer=0 ;
    for(int i=1 ; i<sum ; ++i){
      for(int j=i ; j<sum ; ++j){
        if(pay(i,x)+pay(j,x)==sum){
          answer=max(answer,pay(i,y)+pay(j,y));
        }
      }
    }
    return answer ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    int s=sc.nextInt();
    while(x>0){
      System.out.println(solve(x,y,s));
      x=sc.nextInt();
      y=sc.nextInt();
      s=sc.nextInt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation pay( price : int, tax : int) : int
  pre: true
  post: true
  activity: (     return price * (100 + tax) / 100 );
  static   operation max( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a > b) then (     return a ) else (     return b ) );
  static   operation solve( x : int, y : int, sum : int) : int
  pre: true
  post: true
  activity: (     var answer : int ; answer := 0 ;
         var i : int ; i := 1 ; while i < sum do ( (         var j : int ; j := i ; while j < sum do ( (     if (pay(i, x) + pay(j, x) = sum) then (     answer := Set{answer, pay(i, y) + pay(j, y)}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return answer );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    while (x > 0) do (     OclFile["System.out"].println(solve(x, y, s)) ; 
     x := sc.getCurrent()->toInteger() ; 
     y := sc.getCurrent()->toInteger() ; 
     s := sc.getCurrent()->toInteger() ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new A().doIt();
  }
  class A {
    void doIt(){
      while(true){
        int x=sc.nextInt();
        int y=sc.nextInt();
        int s=sc.nextInt();
        if(x+y+s==0)break ;
        int length=(s/2)+1 ;
        int max=0 ;
        for(int i=1 ; i<length ; i++){
          int low=(i*100)/(100+x);
          int high=((s-i)*100)/(100+x);
          if((i*100)%(100+x)!=0){
            low+=1 ;
          }
          if(((s-i)*100)%(100+x)!=0){
            high+=1 ;
          }
          if((low*(100+x))/100!=i)continue ;
          if((high*(100+x))/100!=(s-i))continue ;
          low=(low*(100+y))/100 ;
          high=(high*(100+y))/100 ;
          max=Math.max(max,low+high);
        }
        System.out.println(max);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     A.newA().doIt() );
 class A {
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (true) do (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    if (x + y + s = 0) then     break else skip ; 
    var length : int ; length := (s / 2) + 1 ;
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i < length do ( (     var low : int ; low := (i * 100) / (100 + x) ;
     var high : int ; high := ((s - i) * 100) / (100 + x) ;
    if ((i * 100) mod (100 + x) /= 0) then (     low := low+(1) ) else skip ; 
    if (((s - i) * 100) mod (100 + x) /= 0) then (     high := high+(1) ) else skip ; 
    if ((low * (100 + x)) / 100 /= i) then     continue else skip ; 
    if ((high * (100 + x)) / 100 /= (s - i)) then     continue else skip ; 
    low := (low * (100 + y)) / 100 ; 
    high := (high * (100 + y)) / 100 ; 
    max := Set{max, low + high}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
class Main {
  private static BufferedReader br ;
  public static void main(String args[])throws Exception {
    br=new BufferedReader(new InputStreamReader(System.in));
    for(; ; ){
      String input=br.readLine();
      if(input.equals("0 0 0"))break ;
      Scanner scanner=new Scanner(input);
      int oldRate=scanner.nextInt();
      int newRate=scanner.nextInt();
      int sum_before_change=scanner.nextInt();
      scanner.close();
      int max_sum=0 ;
      for(int price1=1 ; ; price1++){
        int price2=roundUp((sum_before_change-tax(oldRate,price1))*100/(double)(100+oldRate));
        if(price2<=0)break ;
        if(sum_before_change!=tax(oldRate,price1)+tax(oldRate,price2))continue ;
        int sum=tax(newRate,price1)+tax(newRate,price2);
        if(max_sum<sum)max_sum=sum ;
      }
      System.out.println(max_sum);
    }
    br.close();
  }
  private static int tax(int rate,int price_without_tax){
    return price_without_tax*(100+rate)/100 ;
  }
  private static int roundUp(double val){
    int ret=(int)val ;
    if(val-ret>0)ret++;
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
       while true do ( (     var input : String ; input := br.readLine() ;
     if (input = "0 0 0") then     break else skip ; 
    var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile.newOclFile(input)) ;
    var oldRate : int ; oldRate := scanner.getCurrent()->toInteger() ;
    var newRate : int ; newRate := scanner.getCurrent()->toInteger() ;
    var sum_before_change : int ; sum_before_change := scanner.getCurrent()->toInteger() ;
    skip ; 
    var max_sum : int ; max_sum := 0 ;
        var price1 : int ; price1 := 1 ; while true do ( (     var price2 : int ; price2 := roundUp((sum_before_change - tax(oldRate, price1)) * 100 / (100 + oldRate)->oclAsType(double)) ;
     if (price2 <= 0) then     break else skip ; 
    if (sum_before_change /= tax(oldRate, price1) + tax(oldRate, price2)) then     continue else skip ; 
    var sum : int ; sum := tax(newRate, price1) + tax(newRate, price2) ;
    if (max_sum < sum) then     max_sum := sum ; else skip ; 
 )  ;     price1 := price1 + 1 ) ; 
    OclFile["System.out"].println(max_sum) ; 
 )  ) ; 
     skip );
  static   operation tax( rate : int, price_without_tax : int) : int
  pre: true
  post: true
  activity: (     return price_without_tax * (100 + rate) / 100 );
  static   operation roundUp( val : double) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := val->oclAsType(int) ;
     if (val - ret > 0) then     ret := ret + 1 ; else skip ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  final static int MAX_CHAR=26 ;
  static String removeChars(String str,int k){
    int hash[]=new int[MAX_CHAR];
    int n=str.length();
    for(int i=0 ; i<n ; ++i){
      hash[str.charAt(i)-'a']++;
    }
    String res="" ;
    for(int i=0 ; i<n ; ++i){
      if(hash[str.charAt(i)-'a']>=k){
        res+=str.charAt(i);
      }
    }
    return res ;
  }
  static public void main(String[] args){
    String str="geeksforgeeks" ;
    int k=2 ;
    System.out.println(removeChars(str,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX_CHAR : int := 26;
  static   operation removeChars( str : String, k : int) : String
  pre: true
  post: true
  activity: (     var hash : Sequence(int) ; hash := Integer.subrange(1,MAX_CHAR)->collect(0) ;
     var n : int ; n := str->size() ;
        var i : int ; i := 0 ; while i < n do ( (     hash[str->at(i+1) - ('a')->char2byte()+1] := hash[str->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    var res : String ; res := "" ;
        var i : int ; i := 0 ; while i < n do ( (     if (hash[str->at(i+1) - ('a')->char2byte()+1] >= k) then (     res := res+(str->at(i+1)) ) else skip )  ;     i := i + 1 ) ; 
    return res 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(removeChars(str, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int max=0 ;
      int x=sc.nextInt();
      int y=sc.nextInt();
      int s=sc.nextInt();
      if(x==0 && y==0 && s==0)break ;
      for(int i=1 ; i<s ; i++){
        for(int j=1 ; j<s ; j++){
          int taxFistProduct1=((i*100)+(i*x))/100 ;
          int taxFistProduct2=((j*100)+(j*x))/100 ;
          if(s==taxFistProduct1+taxFistProduct2){
            int taxSecondProduct1=((i*100)+(i*y))/100 ;
            int taxSecondProduct2=((j*100)+(j*y))/100 ;
            if(max<=taxSecondProduct1+taxSecondProduct2){
              max=taxSecondProduct1+taxSecondProduct2 ;
            }
          }
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var max : int ; max := 0 ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    if (x = 0 & y = 0 & s = 0) then     break else skip ; 
        var i : int ; i := 1 ; while i < s do ( (         var j : int ; j := 1 ; while j < s do ( (     var taxFistProduct1 : int ; taxFistProduct1 := ((i * 100) + (i * x)) / 100 ;
     var taxFistProduct2 : int ; taxFistProduct2 := ((j * 100) + (j * x)) / 100 ;
     if (s = taxFistProduct1 + taxFistProduct2) then (     var taxSecondProduct1 : int ; taxSecondProduct1 := ((i * 100) + (i * y)) / 100 ;
     var taxSecondProduct2 : int ; taxSecondProduct2 := ((j * 100) + (j * y)) / 100 ;
     if (max <= taxSecondProduct1 + taxSecondProduct2) then (     max := taxSecondProduct1 + taxSecondProduct2 ) else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.PriorityQueue ;
import java.util.Queue ;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String str[]=br.readLine().split(" ");
      int x=Integer.parseInt(str[0]);
      int y=Integer.parseInt(str[1]);
      int s=Integer.parseInt(str[2]);
      if(x==0 && y==0 && s==0)break ;
      int max=0 ;
      for(int i=1 ; i<s ; i++){
        for(int j=1 ; j<s ; j++){
          int a=changeTax(x,i);
          int b=changeTax(x,j);
          if(a+b==s){
            int c=changeTax(y,i);
            int d=changeTax(y,j);
            max=Math.max(max,c+d);
          }
        }
      }
      System.out.println(max);
    }
  }
  static int changeTax(int x,int p){
    double d=(double)(p*(100+x))/100 ;
    return(int)Math.floor(d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     var x : int ; x := (str[0+1])->toInteger() ;
    var y : int ; y := (str[1+1])->toInteger() ;
    var s : int ; s := (str[2+1])->toInteger() ;
    if (x = 0 & y = 0 & s = 0) then     break else skip ; 
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i < s do ( (         var j : int ; j := 1 ; while j < s do ( (     var a : int ; a := changeTax(x, i) ;
     var b : int ; b := changeTax(x, j) ;
     if (a + b = s) then (     var c : int ; c := changeTax(y, i) ;
     var d : int ; d := changeTax(y, j) ;
     max := Set{max, c + d}->max() ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
  static   operation changeTax( x : int, p : int) : int
  pre: true
  post: true
  activity: (     var d : double ; d := (p * (100 + x))->oclAsType(double) / 100 ;
     return (d)->floor()->oclAsType(int) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner inte=new Scanner(System.in);
    int a=inte.nextInt();
    int b=inte.nextInt();
    if(a<b){
      System.out.println("a<b");
    }
    else if(a>b){
      System.out.println("a>b");
    }
    else {
      System.out.println("a==b");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inte : OclFile ; inte := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := inte.getCurrent()->toInteger() ;
     var b : int ; b := inte.getCurrent()->toInteger() ;
     if (a < b) then (     OclFile["System.out"].println("a<b") ) else     if (a > b) then (     OclFile["System.out"].println("a>b") ) else (     OclFile["System.out"].println("a==b") ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String s="" ;
      while((s=br.readLine())!=null){
        StringTokenizer st=new StringTokenizer(s," ");
        int x=Integer.parseInt(st.nextToken());
        int y=Integer.parseInt(st.nextToken());
        if(x>y){
          System.out.println("a>b");
        }
        else if(x<y){
          System.out.println("a<b");
        }
        else {
          System.out.println("a==b");
        }
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var s : String ; s := "" ;
         s := br.readLine() ;
    while ((s) /= null) do (    skip ; (     var st : OclIterator ; st := OclIterator.newOclIterator_String_String(s, " ") ;
     var x : int ; x := (st.next())->toInteger() ;
     var y : int ; y := (st.next())->toInteger() ;
     if (x > y) then (     OclFile["System.out"].println("a>b") ) else     if (x < y) then (     OclFile["System.out"].println("a<b") ) else (     OclFile["System.out"].println("a==b") ) ;  ) ;     s := br.readLine() ;
 ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String str=in.next();
    int first1=str.indexOf("[");
    if(first1==-1)System.out.print(-1);
    else {
      int first2=str.indexOf(":",first1);
      if(first2==-1)System.out.print(-1);
      else {
        int last1=str.lastIndexOf("] ");
        if(last1==-1 || last1<=first2+1)System.out.print(-1);
        else {
          int last2=str.lastIndexOf(":",last1);
          if(last2==first2)System.out.print(-1);
          else {
            int sum=0 ;
            for(int i=first2+1 ; i<last2 ; i++){
              if(str.charAt(i)=='|')sum++;
            }
            System.out.print(sum+4);
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := in.getCurrent() ;
     var first1 : int ; first1 := str->indexOf("[")-1 ;
     if (first1 = -1) then     OclFile["System.out"].print(-1) ; else (     var first2 : int ; first2 := str.subrange(first1+1)->indexOf(":"+"") + first1 - 1  ;
     if (first2 = -1) then     OclFile["System.out"].print(-1) ; else (     var last1 : int ; last1 := str->lastIndexOf("] ")-1 ;
     if (last1 = -1 or last1 <= first2 + 1) then     OclFile["System.out"].print(-1) ; else (     var last2 : int ; last2 := str.subrange(1,last1+1)->lastIndexOf(":"+"")-1  ;
     if (last2 = first2) then     OclFile["System.out"].print(-1) ; else (     var sum : int ; sum := 0 ;
         var i : int ; i := first2 + 1 ; while i < last2 do ( (     if (str->at(i+1) = '|') then     sum := sum + 1 ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(sum + 4) ) ) ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    String str=input.readLine();
    String[] ary=str.split(" ");
    Integer a=new Integer(ary[0]);
    Integer b=new Integer(ary[1]);
    if(a<b)System.out.println("a<b");
    else if(a>b)System.out.println("a>b");
    else System.out.println("a==b");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := input.readLine() ;
    var ary : Sequence(String) ; ary := str->split(" ") ;
    var a : int ; a := ("" + (ary[0+1]))->toInteger() ;
    var b : int ; b := ("" + (ary[1+1]))->toInteger() ;
    if (a < b) then     OclFile["System.out"].println("a<b") else     if (a > b) then     OclFile["System.out"].println("a>b") else     OclFile["System.out"].println("a==b") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(isr);
    String buf ;
    try {
      while(br.ready()){
        buf=br.readLine();
        Scanner scanner=new Scanner(buf);
        int vL=Integer.parseInt(scanner.next());
        int vR=Integer.parseInt(scanner.next());
        if(vL<vR){
          System.out.println("a<b");
        }
        else if(vL>vR){
          System.out.println("a>b");
        }
        else {
          System.out.println("a==b");
        }
      }
    }
    catch(IOException e){
      System.out.print("Read error.");
      return ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
     var buf : String ;
     try (     while (br.canRead()) do (     buf := br.readLine() ; 
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile.newOclFile(buf)) ;
    var vL : int ; vL := (scanner.getCurrent())->toInteger() ;
    var vR : int ; vR := (scanner.getCurrent())->toInteger() ;
    if (vL < vR) then (     OclFile["System.out"].println("a<b") ) else     if (vL > vR) then (     OclFile["System.out"].println("a>b") ) else (     OclFile["System.out"].println("a==b") ) ;  ;  
 ) )   catch (e : IOException) do (     OclFile["System.out"].print("Read error.") ; 
     return )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int a=0,b=0 ;
    try {
      Scanner in=new Scanner(System.in);
      a=in.nextInt();
      b=in.nextInt();
    }
    catch(InputMismatchException e){
      e.printStackTrace();
      System.err.println("aa aa");
      System.exit(1);
    }
    if(a>b)System.out.println("a>b");
    else if(a<b)System.out.println("a<b");
    else System.out.println("a==b");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 0 ;
    var b : int ; b := 0 ;
     try (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     a := in.getCurrent()->toInteger() ; 
     b := in.getCurrent()->toInteger() )   catch (e : IncorrectElementException) do (     e.printStackTrace() ; 
     OclFile["System.err"].println("aa aa") ; 
 OclProcess.exit(1) )
     if (a > b) then     OclFile["System.out"].println("a>b") ; else     if (a < b) then     OclFile["System.out"].println("a<b") else     OclFile["System.out"].println("a==b") ; ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Fast f=new Fast(System.in);
    int n=f.nextInt();
    while(n--!=0){
      int a=f.nextInt(),b=f.nextInt(),ans=0 ;
      System.out.println(a % b!=0 ? b-a % b : 0);
    }
    System.out.flush();
    System.out.close();
  }
}
class Fast {
  StringTokenizer st ;
  BufferedReader br ;
  public Fast(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public Fast(String file)throws IOException {
    br=new BufferedReader(new FileReader(file));
  }
  public Fast(FileReader r){
    br=new BufferedReader(r);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String readAllLines(BufferedReader reader)throws IOException {
    StringBuilder content=new StringBuilder();
    String line ;
    while((line=reader.readLine())!=null){
      content.append(line);
      content.append(System.lineSeparator());
    }
    return content.toString();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public int[] nextIntArray(int n)throws IOException {
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
}
class Pair {
  int d ;
  int k ;
  public Pair(int d,int k){
    this.d=d ;
    this.k=k ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : Fast ; f := Fast.newFast(OclFile["System.in"]) ;
     var n : int ; n := f.nextInt() ;
        while (n /= 0) do (    skip ; (     var a : int ; a := f.nextInt() ;
    var b : int ; b := f.nextInt() ;
    var ans : int ; ans := 0 ;
     OclFile["System.out"].println(if a mod b /= 0 then b - a mod b else 0 endif) ) ;  ) ;  
    OclFile["System.out"].flush() ; 
    OclFile["System.out"].close() ; 
 );
}
class Fast {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newFast( s : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFast( file : String) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   static operation newFast( r : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(r);
    return self );
  operation initialise( r : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(r) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation readAllLines( reader : OclFile) : String
  pre: true
  post: true
  activity: (     var content : String ; content := StringLib.newString() ;
     var line : String ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     content := content + StringLib.newString(line) ; 
     content := content + StringLib.newString(lineSeparator()) ) ;     line := reader.readLine() ;
 ) ;  
     return content+"" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
class Pair {
   attribute d : int;
   attribute k : int;
   static operation newPair( d : int, k : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(d, k);
    return self );
  operation initialise( d : int, k : int) : void
  pre: true  post: true
  activity: (     self.d := d ; 
     self.k := k );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Fast f=new Fast(System.in);
    int n=f.nextInt();
    while(n--!=0){
      int a=f.nextInt(),b=f.nextInt(),ans=0 ;
      if(a % b!=0)ans=b-a % b ;
      System.out.println(ans);
    }
    System.out.flush();
    System.out.close();
  }
}
class Fast {
  StringTokenizer st ;
  BufferedReader br ;
  public Fast(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public Fast(String file)throws IOException {
    br=new BufferedReader(new FileReader(file));
  }
  public Fast(FileReader r){
    br=new BufferedReader(r);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String readAllLines(BufferedReader reader)throws IOException {
    StringBuilder content=new StringBuilder();
    String line ;
    while((line=reader.readLine())!=null){
      content.append(line);
      content.append(System.lineSeparator());
    }
    return content.toString();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public int[] nextIntArray(int n)throws IOException {
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
}
class Pair {
  int d ;
  int k ;
  public Pair(int d,int k){
    this.d=d ;
    this.k=k ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : Fast ; f := Fast.newFast(OclFile["System.in"]) ;
     var n : int ; n := f.nextInt() ;
        while (n /= 0) do (    skip ; (     var a : int ; a := f.nextInt() ;
    var b : int ; b := f.nextInt() ;
    var ans : int ; ans := 0 ;
     if (a mod b /= 0) then     ans := b - a mod b ; else skip ; 
     OclFile["System.out"].println(ans) ) ;  ) ;  
    OclFile["System.out"].flush() ; 
    OclFile["System.out"].close() ; 
 );
}
class Fast {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newFast( s : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFast( file : String) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   static operation newFast( r : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(r);
    return self );
  operation initialise( r : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(r) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation readAllLines( reader : OclFile) : String
  pre: true
  post: true
  activity: (     var content : String ; content := StringLib.newString() ;
     var line : String ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     content := content + StringLib.newString(line) ; 
     content := content + StringLib.newString(lineSeparator()) ) ;     line := reader.readLine() ;
 ) ;  
     return content+"" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
class Pair {
   attribute d : int;
   attribute k : int;
   static operation newPair( d : int, k : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(d, k);
    return self );
  operation initialise( d : int, k : int) : void
  pre: true  post: true
  activity: (     self.d := d ; 
     self.k := k );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class LongestCommonSubSequence {
  static int LCSubStr(char X[],char Y[],int m,int n){
    int LCStuff[][]=new int[m+1][n+1];
    int result=0 ;
    for(int i=0 ; i<=m ; i++){
      for(int j=0 ; j<=n ; j++){
        if(i==0 || j==0)LCStuff[i][j]=0 ;
        else if(X[i-1]==Y[j-1]){
          LCStuff[i][j]=LCStuff[i-1][j-1]+1 ;
          result=Integer.max(result,LCStuff[i][j]);
        }
        else LCStuff[i][j]=0 ;
      }
    }
    return result ;
  }
  public static void main(String[] args){
    String X="OldSite:GeeksforGeeks.org" ;
    String Y="NewSite:GeeksQuiz.com" ;
    int m=X.length();
    int n=Y.length();
    System.out.println("Length of Longest Common Substring is "+LCSubStr(X.toCharArray(),Y.toCharArray(),m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class LongestCommonSubSequence {
  static   operation LCSubStr( X : Sequence(String), Y : Sequence(String), m : int, n : int) : int
  pre: true
  post: true
  activity: (     var LCStuff : Sequence(Sequence(int)) ; LCStuff := Integer.subrange(1,m + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
     var result : int ; result := 0 ;
         var i : int ; i := 0 ; while i <= m do ( (         var j : int ; j := 0 ; while j <= n do ( (     if (i = 0 or j = 0) then     LCStuff[i+1][j+1] := 0 ; else     if (X[i - 1+1] = Y[j - 1+1]) then (     LCStuff[i+1][j+1] := LCStuff[i - 1+1][j - 1+1] + 1 ; 
     result := Set{result, LCStuff[i+1][j+1]}->max() ) else     LCStuff[i+1][j+1] := 0 ; ;  )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : String ; X := "OldSite:GeeksforGeeks.org" ;
     var Y : String ; Y := "NewSite:GeeksQuiz.com" ;
    var m : int ; m := X->size() ;
    var n : int ; n := Y->size() ;
    OclFile["System.out"].println("Length of Longest Common Substring is " + LCSubStr(X->characters(), Y->characters(), m, n)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Fast f=new Fast(System.in);
    int n=f.nextInt();
    while(n--!=0){
      int a=f.nextInt(),b=f.nextInt(),ans=0 ;
      if(a % b!=0)ans=a<b ? b-a : b-a % b ;
      System.out.println(ans);
    }
    System.out.flush();
    System.out.close();
  }
}
class Fast {
  StringTokenizer st ;
  BufferedReader br ;
  public Fast(InputStream s){
    br=new BufferedReader(new InputStreamReader(s));
  }
  public Fast(String file)throws IOException {
    br=new BufferedReader(new FileReader(file));
  }
  public Fast(FileReader r){
    br=new BufferedReader(r);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String readAllLines(BufferedReader reader)throws IOException {
    StringBuilder content=new StringBuilder();
    String line ;
    while((line=reader.readLine())!=null){
      content.append(line);
      content.append(System.lineSeparator());
    }
    return content.toString();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public int[] nextIntArray(int n)throws IOException {
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=nextInt();
    return a ;
  }
  public boolean ready()throws IOException {
    return br.ready();
  }
}
class Pair {
  int d ;
  int k ;
  public Pair(int d,int k){
    this.d=d ;
    this.k=k ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var f : Fast ; f := Fast.newFast(OclFile["System.in"]) ;
     var n : int ; n := f.nextInt() ;
        while (n /= 0) do (    skip ; (     var a : int ; a := f.nextInt() ;
    var b : int ; b := f.nextInt() ;
    var ans : int ; ans := 0 ;
     if (a mod b /= 0) then     ans := if a < b then b - a else b - a mod b endif ; else skip ; 
     OclFile["System.out"].println(ans) ) ;  ) ;  
    OclFile["System.out"].flush() ; 
    OclFile["System.out"].close() ; 
 );
}
class Fast {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newFast( s : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   static operation newFast( file : String) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(file);
    return self );
  operation initialise( file : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) );
   static operation newFast( r : OclFile) : Fast
  pre: true
  post: true
  activity:
  ( var self : Fast ;
    self := createFast();
    self.initialise(r);
    return self );
  operation initialise( r : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(r) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation readAllLines( reader : OclFile) : String
  pre: true
  post: true
  activity: (     var content : String ; content := StringLib.newString() ;
     var line : String ;
         line := reader.readLine() ;
    while ((line) /= null) do (    skip ; (     content := content + StringLib.newString(line) ; 
     content := content + StringLib.newString(lineSeparator()) ) ;     line := reader.readLine() ;
 ) ;  
     return content+"" );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     a[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return a );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
class Pair {
   attribute d : int;
   attribute k : int;
   static operation newPair( d : int, k : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(d, k);
    return self );
  operation initialise( d : int, k : int) : void
  pre: true  post: true
  activity: (     self.d := d ; 
     self.k := k );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long AG ;
    AG=sc.nextLong();
    while(AG-->0){
      long q ;
      long w ;
      q=sc.nextLong();
      w=sc.nextLong();
      long mod ;
      long h=q % w ;
      mod=(h);
      long valt ;
      valt=(mod>0)?(w-mod): 0 ;
      System.out.println(""+valt);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var AG : long ;
     AG := sc.getCurrent()->toLong() ; 
         while (AG > 0) do (        AG := AG - 1 ;     skip ; (     var q : long ;
     var w : long ;
    q := sc.getCurrent()->toLong() ; 
    w := sc.getCurrent()->toLong() ; 
    var mod : long ;
    var h : long ; h := q mod w ;
    mod := (h) ; 
    var valt : long ;
    valt := if (mod > 0) then (w - mod) else 0 endif ; 
    OclFile["System.out"].println("" + valt) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean pointIsOnLine(int m,int c,int x,int y){
    if(y==((m*x)+c))return true ;
    return false ;
  }
  public static void main(String[] args){
    int m=3,c=2 ;
    int x=1,y=5 ;
    if(pointIsOnLine(m,c,x,y))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation pointIsOnLine( m : int, c : int, x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     if (y = ((m * x) + c)) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 3 ;
    var c : int ; c := 2 ;
     var x : int ; x := 1 ;
    var y : int ; y := 5 ;
     if (pointIsOnLine(m, c, x, y)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int gcd(int a,int b){
    if((a % b)==0)return b ;
    return gcd(b,a % b);
  }
  static int firstFactorialDivisibleNumber(int x){
    int i=1 ;
    int new_x=x ;
    for(i=1 ; i<x ; i++){
      new_x/=gcd(i,new_x);
      if(new_x==1)break ;
    }
    return i ;
  }
  public static void main(String[] args){
    int x=16 ;
    System.out.print(firstFactorialDivisibleNumber(x));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if ((a mod b) = 0) then     return b else skip ; 
     return gcd(b, a mod b) );
  static   operation firstFactorialDivisibleNumber( x : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 1 ;
     var new_x : int ; new_x := x ;
         i := 1 ; while i < x do ( (     new_x := new_x/(gcd(i, new_x)) ; 
     if (new_x = 1) then     break else skip )  ;     i := i + 1 ) ; 
     return i );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 16 ;
     OclFile["System.out"].print(firstFactorialDivisibleNumber(x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int gcd(int a,int b){
    if((a % b)==0)return b ;
    return gcd(b,a % b);
  }
  static int firstFactorialDivisibleNumber(int x){
    int i=1 ;
    int new_x=x ;
    for(i=1 ; i<x ; i++){
      new_x/=gcd(i,new_x);
      if(new_x==1)break ;
    }
    return i ;
  }
  static int countFactorialXNotY(int x,int y){
    return(firstFactorialDivisibleNumber(y)-firstFactorialDivisibleNumber(x));
  }
  public static void main(String[] args){
    int x=15,y=25 ;
    System.out.print(countFactorialXNotY(x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if ((a mod b) = 0) then     return b else skip ; 
     return gcd(b, a mod b) );
  static   operation firstFactorialDivisibleNumber( x : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 1 ;
     var new_x : int ; new_x := x ;
         i := 1 ; while i < x do ( (     new_x := new_x/(gcd(i, new_x)) ; 
     if (new_x = 1) then     break else skip )  ;     i := i + 1 ) ; 
     return i );
  static   operation countFactorialXNotY( x : int, y : int) : int
  pre: true
  post: true
  activity: (     return (firstFactorialDivisibleNumber(y) - firstFactorialDivisibleNumber(x)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 15 ;
    var y : int ; y := 25 ;
     OclFile["System.out"].print(countFactorialXNotY(x, y)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class _04_Accordion {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    int pLeft=0 ;
    int pRight=s.length()-1 ;
    int count=0 ;
    int flagOpenBracket=0 ;
    int flagCloseBracket=0 ;
    int posOpeningColon=-1 ;
    int posClosingColon=-1 ;
    while(pLeft<pRight){
      if(flagOpenBracket==0 && s.charAt(pLeft)=='['){
        flagOpenBracket=1 ;
      }
      else if(flagOpenBracket==1 && s.charAt(pLeft)==':' && posOpeningColon==-1){
        posOpeningColon=pLeft ;
      }
      if(flagCloseBracket==0 && s.charAt(pRight)==']'){
        flagCloseBracket=1 ;
      }
      else if(flagCloseBracket==1 && s.charAt(pRight)==':' && posClosingColon==-1){
        posClosingColon=pRight ;
      }
      if(posOpeningColon==-1){
        pLeft++;
      }
      if(posClosingColon==-1){
        pRight--;
      }
      if(posClosingColon!=-1 && posOpeningColon!=-1){
        break ;
      }
    }
    if(posClosingColon!=-1 && posOpeningColon!=-1 && posClosingColon!=posOpeningColon){
      for(int i=posOpeningColon+1 ; i<posClosingColon ; i++){
        if(s.charAt(i)=='|'){
          count++;
        }
      }
      System.out.println(count+4);
    }
    else {
      System.out.println("-1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _04_Accordion {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var pLeft : int ; pLeft := 0 ;
    var pRight : int ; pRight := s->size() - 1 ;
    var count : int ; count := 0 ;
    var flagOpenBracket : int ; flagOpenBracket := 0 ;
    var flagCloseBracket : int ; flagCloseBracket := 0 ;
    var posOpeningColon : int ; posOpeningColon := -1 ;
    var posClosingColon : int ; posClosingColon := -1 ;
    while (pLeft < pRight) do (     if (flagOpenBracket = 0 & s->at(pLeft+1) = '[') then (     flagOpenBracket := 1 ) else     if (flagOpenBracket = 1 & s->at(pLeft+1) = ':' & posOpeningColon = -1) then (     posOpeningColon := pLeft ) else skip ; ;  
     if (flagCloseBracket = 0 & s->at(pRight+1) = ']') then (     flagCloseBracket := 1 ) else     if (flagCloseBracket = 1 & s->at(pRight+1) = ':' & posClosingColon = -1) then (     posClosingColon := pRight ) else skip ; ;  
    if (posOpeningColon = -1) then (     pLeft := pLeft + 1 ) else skip ; 
    if (posClosingColon = -1) then (     pRight := pRight - 1 ) else skip ; 
    if (posClosingColon /= -1 & posOpeningColon /= -1) then (     break ) else skip ; 
 ) ; 
    if (posClosingColon /= -1 & posOpeningColon /= -1 & posClosingColon /= posOpeningColon) then (         var i : int ; i := posOpeningColon + 1 ; while i < posClosingColon do ( (     if (s->at(i+1) = '|') then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(count + 4) ) else (     OclFile["System.out"].println("-1") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n % 2==0)System.out.println("NO");
    else {
      System.out.println("YES");
      int t=0,s=0,e=n ;
      int a[]=new int[2*n];
      for(int i=1 ; i<=2*n ; i+=2){
        if(t==0){
          a[s++]=i ;
          a[e++]=i+1 ;
          t=1 ;
        }
        else {
          a[s++]=i+1 ;
          a[e++]=i ;
          t=0 ;
        }
      }
      for(int i=0 ; i<2*n ; i++)System.out.print(a[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then     OclFile["System.out"].println("NO") ; else (     OclFile["System.out"].println("YES") ; 
     var t : int ; t := 0 ;
    var s : int ; s := 0 ;
    var e : int ; e := n ;
    var a : Sequence(int) ; a := Integer.subrange(1,2 * n)->collect(0) ;
        var i : int ; i := 1 ; while i <= 2 * n do ( (     if (t = 0) then (      a[s+1] := i  ; s := s + 1 ; 
      a[e+1] := i + 1  ; e := e + 1 ; 
     t := 1 ) else (      a[s+1] := i + 1  ; s := s + 1 ; 
      a[e+1] := i  ; e := e + 1 ; 
     t := 0 ) )  ;     i := i+(2) ) ; 
        var i : int ; i := 0 ; while i < 2 * n do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
import java.util.*;
public class Test {
  static Scanner sc=new Scanner(System.in);
  static BufferedWriter write=new BufferedWriter(new OutputStreamWriter(System.out));
  static PrintWriter out=new PrintWriter(write);
  public static void main(String[] args)throws java.lang.Exception {
    long n=sc.nextLong();
    long min=sc.nextLong();
    long sum=0 ;
    for(int i=0 ; i<n ; i++)sum+=sc.nextLong();
    sum+=((n-1)*10);
    if(sum<=min){
      long left=min-sum ;
      out.println((((n-1)*2)+(left/5)));
    }
    else out.println(-1);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute write : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute out : OclFile := OclFile.newOclFile_Write(write);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.getCurrent()->toLong() ;
     var min : long ; min := sc.getCurrent()->toLong() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (     sum := sum+(sc.getCurrent()->toLong()) ;  ;     i := i + 1 ) ; 
    sum := sum+(((n - 1) * 10)) ; 
    if (sum <= min) then (     var left : long ; left := min - sum ;
     skip ) else     skip ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int d=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      int sum=0 ;
      for(int i=0 ; i<n-1 ; i++){
        sum+=arr[i]+10 ;
      }
      sum+=arr[n-1];
      if(sum>d)System.out.println(-1);
      else {
        int res=(n-1)*2+((d-sum)/5);
        System.out.println(res);
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     sum := sum+(arr[i+1] + 10) )  ;     i := i + 1 ) ; 
    sum := sum+(arr[n - 1+1]) ; 
    if (sum > d) then     OclFile["System.out"].println(-1) else (     var res : int ; res := (n - 1) * 2 + ((d - sum) / 5) ;
     OclFile["System.out"].println(res) ) ;  
 )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    int ans1=0 ;
    int ans2=0 ;
    for(int i=0 ; i<s.length(); i++){
      char c=s.charAt(i);
      if(i % 2==0){
        if(c=='0'){
          ans1++;
        }
        else {
          ans2++;
        }
      }
      else {
        if(c=='1'){
          ans1++;
        }
        else {
          ans2++;
        }
      }
    }
    System.out.println(Math.min(ans1,ans2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var ans1 : int ; ans1 := 0 ;
    var ans2 : int ; ans2 := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var c : String ; c := s->at(i+1) ;
     if (i mod 2 = 0) then (     if (c = '0') then (     ans1 := ans1 + 1 ) else (     ans2 := ans2 + 1 ) ) else (     if (c = '1') then (     ans1 := ans1 + 1 ) else (     ans2 := ans2 + 1 ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Set{ans1, ans2}->min()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int d=sc.nextInt();
    int t=0 ;
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      t+=a ;
      if(i==n-1){
        count+=(d-t)/5 ;
      }
      else {
        count+=2 ;
        t+=10 ;
      }
    }
    if(t>d)System.out.println("-1");
    else System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var t : int ; t := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     t := t+(a) ; 
     if (i = n - 1) then (     count := count+((d - t) / 5) ) else (     count := count+(2) ; 
     t := t+(10) ) )  ;     i := i + 1 ) ; 
    if (t > d) then     OclFile["System.out"].println("-1") else     OclFile["System.out"].println(count) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String[] array=s.split("");
    List<String>list=new ArrayList<>();
    list.add(array[0]);
    String word="" ;
    for(int i=1 ; i<array.length ; i++){
      word+=array[i];
      if(! word.equals(list.get(list.size()-1))){
        list.add(word);
        word="" ;
      }
    }
    int result=list.size();
    System.out.println(result);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var array : Sequence(String) ; array := s->split("") ;
    var list : Sequence(String) ; list := Sequence{} ;
    list := list->including(array[0+1]) ; 
    var word : String ; word := "" ;
        var i : int ; i := 1 ; while i < array->size() do ( (     word := word+(array[i+1]) ; 
     if (not(word = list->at(list->size() - 1+1))) then (     list := list->including(word) ; 
     word := "" ) else skip )  ;     i := i + 1 ) ; 
    var result : int ; result := list->size() ;
    OclFile["System.out"].println(result) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  static int a1[]={
    0,-1,0,1 };
    static int b1[]={
-1,0,1,0 };
      private static Scanner sc=new Scanner(System.in);
      public static void main(String[] args){
        String S=sc.next();
        String v="" ;
        int ctn=0 ;
        String past=""+S.charAt(0);
        ctn++;
        for(int i=1 ; i<S.length(); i++){
          v+=S.charAt(i);
          if(v.equals(past))continue ;
          else {
            past=v ;
            v="" ;
            ctn++;
          }
        }
        p(ctn);
      }
      static void p(String ans){
        System.out.println(ans);
      };
      static void p(int ans){
        System.out.println(ans);
      };
      static void p(){
        System.out.println();
      };
      static void p(long ans){
        System.out.println(ans);
      };
      static void p(double ans){
        System.out.println(ans);
      };
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a1 : int := Sequence{0,-1,0,1};
  static   attribute b1 : int := Sequence{-1,0,1,0};
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ; S := sc.getCurrent() ;
     var v : String ; v := "" ;
    var ctn : int ; ctn := 0 ;
    var past : String ; past := "" + S->at(0+1) ;
    ctn := ctn + 1 ; 
        var i : int ; i := 1 ; while i < S->size() do ( (     v := v+(S->at(i+1)) ; 
     if (v = past) then     continue else (     past := v ; 
     v := "" ; 
     ctn := ctn + 1 ) )  ;     i := i + 1 ) ; 
    execute p(ctn) ; 
 );
  static   operation p( ans : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( ans : long) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
  static   operation p( ans : double) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    List<String>list=new ArrayList<String>(Arrays.asList(s.split("")));
    List<String>list_moji=new ArrayList<String>();
    loop : for(int i=0 ;
    list.size()>i ;
    i++){
      if(i==0){
        list_moji.add(list.get(i));
        continue ;
      }
      else if(i!=0){
        String add="" ;
        while(true){
          if(i==list.size())break loop ;
          add=add+list.get(i);
          if(add.equals(list_moji.get(list_moji.size()-1))){
            i++;
            continue ;
          }
          else {
            list_moji.add(add);
            break ;
          }
        }
      }
    }
    System.out.println(list_moji.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var list : Sequence(String) ; list := Sequence{}->union(s->split("")) ;
    var list_moji : Sequence(String) ; list_moji := Sequence{} ;
        var i : int ; i := 0 ; while list->size() > i do ( (     if (i = 0) then (     list_moji := list_moji->including(list->at(i+1)) ; 
     continue ) else     if (i /= 0) then (     var add : String ; add := "" ;
     while (true) do (     if (i = list->size()) then     break else skip ; 
     add := add + list->at(i+1) ; 
     if (add = list_moji->at(list_moji->size() - 1+1)) then (     i := i + 1 ; 
     continue ) else (     list_moji := list_moji->including(add) ; 
     break ) ) ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(list_moji->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.PrintWriter ;
class Main {
  static int divideStr(String str){
    int count=0 ;
    int pre='\0' ;
    char cur ;
    for(int i=0 ; i<str.length(); i++){
      cur=str.charAt(i);
      if(pre==cur && i!=str.length()-1){
        count++;
        i++;
        pre='\0' ;
      }
      else if(pre!=cur){
        count++;
        pre=cur ;
      }
    }
    return count ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    String str=sc.nextLine();
    out.println(divideStr(str));
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation divideStr( str : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var pre : int ; pre := '\0' ;
    var cur : String ;
        var i : int ; i := 0 ; while i < str->size() do ( (     cur := str->at(i+1) ; 
     if (pre = cur & i /= str->size() - 1) then (     count := count + 1 ; 
     i := i + 1 ; 
     pre := '\0' ) else     if (pre /= cur) then (     count := count + 1 ; 
     pre := cur ) else skip ; )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var str : String ; str := sc.nextLine() ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test2 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.nextLine();
    int n=str.length();
    String[] list=new String[n];
    for(int i=0 ; i<n ; i++){
      list[i]=str.substring(i,i+1);
    }
    int flag=1 ;
    int startCnt=-1 ;
    for(int i=0 ; i<n ; i++){
      if(flag==1 && list[i] .equals("[")){
        flag++;
      }
      else if(flag==2 && list[i] .equals(":")){
        startCnt=i ;
        break ;
      }
    }
    int flag2=1 ;
    int endCnt=-1 ;
    if(startCnt>-1){
      for(int i=n-1 ; i>startCnt ; i--){
        if(flag2==1 && list[i] .equals("] ")){
          flag2++;
        }
        else if(flag2==2 && list[i] .equals(":")){
          endCnt=i ;
          break ;
        }
      }
    }
    int totalCnt=-1 ;
    if(startCnt>-1 && endCnt>-1){
      totalCnt=4 ;
      for(int i=startCnt ; i<endCnt ; i++){
        if(list[i] .equals("|")){
          totalCnt++;
        }
      }
    }
    System.out.println(totalCnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class test2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.nextLine() ;
    var n : int ; n := str->size() ;
    var list : Sequence(String) ; list := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     list[i+1] := str.subrange(i+1,i + 1) )  ;     i := i + 1 ) ; 
    var flag : int ; flag := 1 ;
    var startCnt : int ; startCnt := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (flag = 1 & list[i+1] = "[") then (     flag := flag + 1 ) else     if (flag = 2 & list[i+1] = ":") then (     startCnt := i ; 
     break ) else skip ; )  ;     i := i + 1 ) ; 
    var flag2 : int ; flag2 := 1 ;
    var endCnt : int ; endCnt := -1 ;
    if (startCnt > -1) then (         var i : int ; i := (n)->char2byte() - 1 ; while i > startCnt do ( (     if (flag2 = 1 & list[i+1] = "] ") then (     flag2 := flag2 + 1 ) else     if (flag2 = 2 & list[i+1] = ":") then (     endCnt := i ; 
     break ) else skip ; )  ;     i := i - 1 ) ) else skip ; 
    var totalCnt : int ; totalCnt := -1 ;
    if (startCnt > -1 & endCnt > -1) then (     totalCnt := 4 ; 
         var i : int ; i := startCnt ; while i < endCnt do ( (     if (list[i+1] = "|") then (     totalCnt := totalCnt + 1 ) else skip )  ;     i := i + 1 ) ) else skip ; 
    OclFile["System.out"].println(totalCnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static long countWays(int n,int k){
    long dp[]=new long[n+1];
    Arrays.fill(dp,0);
    int mod=1000000007 ;
    dp[1]=k ;
    int same=0,diff=k ;
    for(int i=2 ; i<=n ; i++){
      same=diff ;
      diff=(int)(dp[i-1]*(k-1));
      diff=diff % mod ;
      dp[i]=(same+diff)% mod ;
    }
    return dp[n];
  }
  public static void main(String[] args){
    int n=3,k=2 ;
    System.out.println(countWays(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation countWays( n : int, k : int) : long
  pre: true
  post: true
  activity: (     var dp : Sequence(long) ; dp := Integer.subrange(1,n + 1)->collect(0) ;
     dp := dp->collect(0) ; 
    var mod : int ; mod := 1000000007 ;
    dp[1+1] := k ; 
    var same : int ; same := 0 ;
    var diff : int ; diff := k ;
        var i : int ; i := 2 ; while i <= n do ( (     same := diff ; 
     diff := (dp[i - 1+1] * (k - 1))->oclAsType(int) ; 
     diff := diff mod mod ; 
     dp[i+1] := (same + diff) mod mod )  ;     i := i + 1 ) ; 
    return dp[n+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
    var k : int ; k := 2 ;
     OclFile["System.out"].println(countWays(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Equidistant545B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s1=in.next();
    String s2=in.next();
    StringBuffer sb=new StringBuffer();
    int size=s1.length();
    int counter=0,differ=0 ;
    for(int i=0 ; i<size ; i++){
      if(s1.charAt(i)==s2.charAt(i))sb.append(s1.charAt(i));
      else {
        if(counter % 2==0){
          sb.append(s1.charAt(i));
          counter++;
        }
        else {
          sb.append(s2.charAt(i));
          counter++;
        }
        differ++;
      }
    }
    if(differ % 2!=0){
      System.out.println("impossible");
      return ;
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Equidistant545B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := in.getCurrent() ;
    var s2 : String ; s2 := in.getCurrent() ;
    var sb : String ; sb := StringLib.newString() ;
    var size : int ; size := s1->size() ;
    var counter : int ; counter := 0 ;
    var differ : int ; differ := 0 ;
        var i : int ; i := 0 ; while i < size do ( (     if (s1->at(i+1) = s2->at(i+1)) then     sb := sb + StringLib.newString(s1->at(i+1)) ; else (     if (counter mod 2 = 0) then (     sb := sb + StringLib.newString(s1->at(i+1)) ; 
     counter := counter + 1 ) else (     sb := sb + StringLib.newString(s2->at(i+1)) ; 
     counter := counter + 1 ) ;  
     differ := differ + 1 ) )  ;     i := i + 1 ) ; 
    if (differ mod 2 /= 0) then (     OclFile["System.out"].println("impossible") ; 
     return ) else skip ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int getValueOfF(int n){
    if(n==1)return 0 ;
    if(n==2)return 1 ;
    int cnt=0 ;
    while(n % 2==0){
      cnt+=1 ;
      n/=2 ;
    }
    return 2*cnt ;
  }
  public static void main(String[] args){
    int n=20 ;
    System.out.println(getValueOfF(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getValueOfF( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 0 else skip ; 
     if (n = 2) then     return 1 else skip ; 
    var cnt : int ; cnt := 0 ;
    while (n mod 2 = 0) do (     cnt := cnt+(1) ; 
     n := n/(2) ) ; 
    return 2 * cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 20 ;
     OclFile["System.out"].println(getValueOfF(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CColoringColorfully solver=new CColoringColorfully();
    solver.solve(1,in,out);
    out.close();
  }
  static class CColoringColorfully {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      String x=in.next();
      StringBuilder a=new StringBuilder(x);
      StringBuilder b=new StringBuilder(x);
      int a1=0 ;
      int a2=0 ;
      for(int i=1 ; i<x.length(); i++){
        if(a.charAt(i)==a.charAt(i-1)){
          if(a.charAt(i)=='1')a.setCharAt(i,'0');
          else a.setCharAt(i,'1');
          a1++;
        }
      }
      for(int i=x.length()-1 ; i>0 ; i--){
        if(b.charAt(i)==b.charAt(i-1)){
          if(b.charAt(i-1)=='1')b.setCharAt(i-1,'0');
          else b.setCharAt(i-1,'1');
          a2++;
        }
      }
      out.println(Math.min(a1,a2));
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CColoringColorfully ; solver := CColoringColorfully.newCColoringColorfully() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CColoringColorfully {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var x : String ; x := in.next() ;
     var a : String ; a := StringLib.newString(x) ;
    var b : String ; b := StringLib.newString(x) ;
    var a1 : int ; a1 := 0 ;
    var a2 : int ; a2 := 0 ;
        var i : int ; i := 1 ; while i < x->size() do ( (     if (a->at(i+1) = a->at(i - 1+1)) then (     if (a->at(i+1) = '1') then     a := a.setAt(i+1, '0') else     a := a.setAt(i+1, '1') ; ;  
     a1 := a1 + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := x->size() - 1 ; while i > 0 do ( (     if (b->at(i+1) = b->at(i - 1+1)) then (     if (b->at(i - 1+1) = '1') then     b := b.setAt(i - 1+1, '0') else     b := b.setAt(i - 1+1, '1') ; ;  
     a2 := a2 + 1 ) else skip )  ;     i := i - 1 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class AngryStudents {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int i=0 ; i<t ; i++){
      int k=input.nextInt();
      input.nextLine();
      int max=0 ;
      String s=input.nextLine();
      int count=0 ;
      boolean start=false ;
      int a=0 ;
      int check=0 ;
      for(int j=0 ; j<k ; j++){
        if(! start){
          if(s.charAt(j)=='A'){
            a=j ;
            start=true ;
          }
        }
        else {
          if(s.charAt(j)=='A'){
            check=j-a ;
            check--;
            a=j ;
            if(check>max)max=check ;
          }
          else if(j+1==k && start){
            check=j-a ;
            if(check>max)max=check ;
          }
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class AngryStudents {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var k : int ; k := input.getCurrent()->toInteger() ;
     skip ; 
    var max : int ; max := 0 ;
    var s : String ; s := input.nextLine() ;
    var count : int ; count := 0 ;
    var start : boolean ; start := false ;
    var a : int ; a := 0 ;
    var check : int ; check := 0 ;
        var j : int ; j := 0 ; while j < k do ( (     if (not(start)) then (     if (s->at(j+1) = 'A') then (     a := j ; 
     start := true ) else skip ) else (     if (s->at(j+1) = 'A') then (     check := j - a ; 
     check := check - 1 ; 
     a := j ; 
     if (check > max) then     max := check ; else skip ) else     if (j + 1 = k & start) then (     check := j - a ; 
     if (check > max) then     max := check ; else skip ) else skip ; ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int n=cin.nextInt();
    while(n-->0){
      int t=cin.nextInt();
      String s=cin.next();
      char[] ch=s.toCharArray();
      int index=s.indexOf('A');
      int count=0 ;
      int ans=0 ;
      if(index==-1){
        System.out.println(0);
        continue ;
      }
      for(int i=index+1 ; i<ch.length ; i++){
        if(ch[i]=='P'){
          count++;
        }
        else {
          ans=Math.max(count,ans);
          count=0 ;
        }
      }
      ans=Math.max(count,ans);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := cin.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var t : int ; t := cin.getCurrent()->toInteger() ;
     var s : String ; s := cin.getCurrent() ;
    var ch : Sequence(String) ; ch := s->characters() ;
    var index : int ; index := s->indexOf('A')-1 ;
    var count : int ; count := 0 ;
    var ans : int ; ans := 0 ;
    if (index = -1) then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
        var i : int ; i := index + 1 ; while i < ch->size() do ( (     if (ch[i+1] = 'P') then (     count := count + 1 ) else (     ans := Set{count, ans}->max() ; 
     count := 0 ) )  ;     i := i + 1 ) ; 
    ans := Set{count, ans}->max() ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner kb=new Scanner(System.in);
    int cases=kb.nextInt();
    for(int i=0 ; i<cases ; i++){
      int n=kb.nextInt();
      kb.nextLine();
      String s=kb.next();
      ArrayList<Integer>count=new ArrayList<>();
      for(int j=0 ; j<n ; j++){
        if(s.charAt(j)=='A'){
          count.add(0);
        }
        else if(! count.isEmpty())count.set(count.size()-1,count.get(count.size()-1)+1);
      }
      int max=0 ;
      for(int j=0 ; j<count.size(); j++){
        if(count.get(j)>max)max=count.get(j);
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var kb : OclFile ; kb := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cases : int ; cases := kb.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < cases do ( (     var n : int ; n := kb.getCurrent()->toInteger() ;
     skip ; 
    var s : String ; s := kb.getCurrent() ;
    var count : Sequence(int) ; count := Sequence{} ;
        var j : int ; j := 0 ; while j < n do ( (     if (s->at(j+1) = 'A') then (     count := count->including(0) ) else     if (not(count->isEmpty())) then     count := count.setAt(count->size() - 1+1,count->at(count->size() - 1+1) + 1) ; else skip ; )  ;     j := j + 1 ) ; 
    var max : int ; max := 0 ;
        var j : int ; j := 0 ; while j < count->size() do ( (     if (count->at(j+1) > max) then     max := count->at(j+1) ; else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class HelloWorld {
  public static void solve(char s[]){
    int n=s.length ;
    int ans=0 ;
    for(int i=0 ; i<n ; ++i){
      if(s[i]=='Q')for(int j=i+1 ;
      j<n ;
++j){
        if(s[j]=='A')for(int k=j+1 ;
        k<n ;
++k){
          if(s[k]=='Q'){
            ans++;
          }
        }
      }
    }
    System.out.println(ans);
  }
  public static void sol(){
    Scanner sc=new Scanner(System.in);
    int testcases=sc.nextInt();
    for(int t=0 ; t<testcases ; ++t){
      int n=sc.nextInt();
      char s[]=sc.next().toCharArray();
      int ans=0 ;
      int p=0 ;
      int cnt=1 ;
      for(; p<n && s[p]!='A' ; ++p){
      }
      p++;
      for(; p<n+1 ; ++p){
        if(p<n && s[p]!=s[p-1]){
          if(s[p-1]=='P'){
            ans=Math.max(ans,cnt);
          }
          cnt=1 ;
        }
        else if(p<n){
          cnt++;
        }
        if(s[p-1]=='P'){
          ans=Math.max(ans,cnt);
        }
      }
      System.out.println(ans);
    }
    sc.close();
  }
  public static void main(String[] args){
    sol();
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation solve( s : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] = 'Q') then         var j : int ; j := i + 1 ; while j < n do ( (     if (s[j+1] = 'A') then         var k : int ; k := j + 1 ; while k < n do ( (     if (s[k+1] = 'Q') then (     ans := ans + 1 ) else skip )  ;     k := k + 1 ) ; else skip )  ;     j := j + 1 ) ; else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) );
  static   operation sol() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testcases : int ; testcases := sc.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < testcases do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var ans : int ; ans := 0 ;
    var p : int ; p := 0 ;
    var cnt : int ; cnt := 1 ;
      while p < n & s[p+1] /= 'A' do ( skip  ;     p := p + 1 ) ; 
    p := p + 1 ; 
      while p < n + 1 do ( (     if (p < n & s[p+1] /= s[p - 1+1]) then (     if (s[p - 1+1] = 'P') then (     ans := Set{ans, cnt}->max() ) else skip ; 
     cnt := 1 ) else     if (p < n) then (     cnt := cnt + 1 ) else skip ; ;  
     if (s[p - 1+1] = 'P') then (     ans := Set{ans, cnt}->max() ) else skip )  ;     p := p + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     t := t + 1 ) ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute sol() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long[][] dp=new long[31][50];
    while(true){
      final int n=sc.nextInt();
      if(n==0){
        break ;
      }
      for(int day=0 ; day<31 ; day++){
        Arrays.fill(dp[day],0);
      }
      for(int i=0 ; i<n ; i++){
        dp[0][i]=1L<<i ;
      }
      ArrayList<Set<Integer>>list=new ArrayList<Set<Integer>>();
      for(int day=0 ; day<31 ; day++){
        list.add(new HashSet<Integer>());
      }
      for(int i=0 ; i<n ; i++){
        final int m=sc.nextInt();
        for(int j=0 ; j<m ; j++){
          final int day=sc.nextInt()-1 ;
          list.get(day).add(i);
        }
      }
      boolean flag=false ;
      for(int day=1 ; day<31 ; day++){
        for(int person=0 ; person<n ; person++){
          if(! list.get(day-1).contains(person)){
            dp[day][person]=dp[day-1][person];
          }
          else {
            for(int arrival : list.get(day-1)){
              dp[day][person] |=dp[day-1][arrival];
            }
          }
          if(dp[day][person]==(1L<<n)-1){
            System.out.println(day);
            flag=true ;
            break ;
          }
        }
        if(flag){
          break ;
        }
      }
      if(! flag){
        System.out.println(-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,31)->collect(Integer.subrange(1,50)->collect(0)) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
        var day : int ; day := 0 ; while day < 31 do ( (     dp[day+1] := dp[day+1]->collect(0) )  ;     day := day + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     dp[0+1][i+1] := (1L*(2->pow(i)))->oclAsType(long) )  ;     i := i + 1 ) ; 
    var list : Sequence(Set(int)) ; list := Sequence{} ;
        var day : int ; day := 0 ; while day < 31 do ( (     list := list->including(Set{}) )  ;     day := day + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var m : int ; m := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < m do ( (     var day : int ; day := sc.getCurrent()->toInteger() - 1 ;
     list->at(day+1)->excludes(i) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := false ;
        var day : int ; day := 1 ; while day < 31 do ( (         var person : int ; person := 0 ; while person < n do ( (     if (not(list->at(day - 1+1)->includes(person))) then (     dp[day+1][person+1] := dp[day - 1+1][person+1] ) else (     for (arrival : list->at(day - 1+1)) do ( (     dp[day+1][person+1] := MathLib.bitwiseOr(dp[day+1][person+1], dp[day - 1+1][arrival+1]) )  ) ) ;  
     if (dp[day+1][person+1] = ((1L*(2->pow(n)))->oclAsType(long)) - 1) then (     OclFile["System.out"].println(day) ; 
     flag := true ; 
     break ) else skip )  ;     person := person + 1 ) ; 
     if (flag) then (     break ) else skip )  ;     day := day + 1 ) ; 
    if (not(flag)) then (     OclFile["System.out"].println(-1) ) else skip ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.util.*;
import java.io.*;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      boolean[][] ok=new boolean[n][31];
      for(int i=0 ; i<n ; i++)for(int j=0,m=sc.nextInt(); j<m ; j++)ok[i][sc.nextInt()]=true ;
      long[] dp=new long[n];
      int i=1 ;
      boolean f=false ;
      for(i=1 ; i<=30 ; i++){
        long meet=0 ;
        for(int j=0 ; j<n ; j++)if(ok[j][i])meet |=1L<<j | dp[j];
        for(int j=0 ; j<n ; j++)if(ok[j][i]){
          dp[j] |=meet ;
          if(dp[j]==(1L<<n)-1)f=true ;
        }
        if(f)break ;
      }
      System.out.println((i==31 ?-1 : i));
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var ok : Sequence(Sequence(boolean)) ; ok := Integer.subrange(1,n)->collect(Integer.subrange(1,31)->collect(false)) ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ;
    var m : int ; m := sc.getCurrent()->toInteger() ; while j < m do (     ok[i+1][sc.getCurrent()->toInteger()+1] := true ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var dp : Sequence(long) ; dp := Integer.subrange(1,n)->collect(0) ;
    var i : int ; i := 1 ;
    var f : boolean ; f := false ;
        i := 1 ; while i <= 30 do ( (     var meet : long ; meet := 0 ;
         var j : int ; j := 0 ; while j < n do (     if (ok[j+1][i+1]) then     meet := MathLib.bitwiseOr(meet, MathLib.bitwiseOr((1L*(2->pow(j)))->oclAsType(long),dp[j+1])) ; else skip ;  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < n do (     if (ok[j+1][i+1]) then (     dp[j+1] := MathLib.bitwiseOr(dp[j+1], meet) ; 
     if (dp[j+1] = ((1L*(2->pow(n)))->oclAsType(long)) - 1) then     f := true ; else skip ) else skip ;  ;     j := j + 1 ) ; 
     if (f) then     break else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((if i = 31 then -1 else i endif)) ; 
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    double xp0,xp1,yp0,yp1,xp2,yp2,xp3,yp3 ;
    int q ;
    int i ;
    double s0x,s0y,s1x,s1y,s,t,x,y ;
    q=sc.nextInt();
    for(i=0 ; i<q ; i++){
      xp0=sc.nextDouble();
      yp0=sc.nextDouble();
      xp1=sc.nextDouble();
      yp1=sc.nextDouble();
      xp2=sc.nextDouble();
      yp2=sc.nextDouble();
      xp3=sc.nextDouble();
      yp3=sc.nextDouble();
      s0x=xp1-xp0 ;
      s0y=yp1-yp0 ;
      s1x=xp3-xp2 ;
      s1y=yp3-yp2 ;
      s=s0x*s1y-s1x*s0y ;
      if(xp0==xp2 && yp0==yp2){
        x=xp0 ;
        y=yp0 ;
      }
      else if(xp0==xp3 && yp0==yp3){
        x=xp0 ;
        y=yp0 ;
      }
      else if(xp1==xp2 && yp1==yp2){
        x=xp1 ;
        y=yp1 ;
      }
      else if(xp1==xp3 && yp1==yp3){
        x=xp1 ;
        y=yp1 ;
      }
      else {
        t=(s1y*(xp2-xp0)-s1x*(yp2-yp0))/s ;
        x=xp0+t*s0x ;
        y=yp0+t*s0y ;
      }
      System.out.println(x+" "+y);
    }
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var xp0 : double ;
    var xp1 : double ;
    var yp0 : double ;
    var yp1 : double ;
    var xp2 : double ;
    var yp2 : double ;
    var xp3 : double ;
    var yp3 : double ;
    var q : int ;
    var i : int ;
    var s0x : double ;
    var s0y : double ;
    var s1x : double ;
    var s1y : double ;
    var s : double ;
    var t : double ;
    var x : double ;
    var y : double ;
    q := sc.nextInt() ; 
        i := 0 ; while i < q do ( (     xp0 := sc.nextDouble() ; 
     yp0 := sc.nextDouble() ; 
    xp1 := sc.nextDouble() ; 
    yp1 := sc.nextDouble() ; 
    xp2 := sc.nextDouble() ; 
    yp2 := sc.nextDouble() ; 
    xp3 := sc.nextDouble() ; 
    yp3 := sc.nextDouble() ; 
    s0x := xp1 - xp0 ; 
    s0y := yp1 - yp0 ; 
    s1x := xp3 - xp2 ; 
    s1y := yp3 - yp2 ; 
    s := s0x * s1y - s1x * s0y ; 
    if (xp0 = xp2 & yp0 = yp2) then (     x := xp0 ; 
     y := yp0 ) else     if (xp0 = xp3 & yp0 = yp3) then (     x := xp0 ; 
     y := yp0 ) else     if (xp1 = xp2 & yp1 = yp2) then (     x := xp1 ; 
     y := yp1 ) else     if (xp1 = xp3 & yp1 = yp3) then (     x := xp1 ; 
     y := yp1 ) else (     t := (s1y * (xp2 - xp0) - s1x * (yp2 - yp0)) / s ; 
     x := xp0 + t * s0x ; 
     y := yp0 + t * s0y ) ;  ;  ;  ;  
    OclFile["System.out"].println(x + " " + y) ; 
 )  ;     i := i + 1 ) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileInputStream ;
import java.io.IOException ;
import java.io.PrintStream ;
import java.io.Reader ;
import java.io.StringReader ;
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.Iterator ;
import java.util.Scanner ;
public class Main {
  static int n ;
  static int[][] scedule ;
  public static void main(String[] args){
    Scanner sca=new Scanner(System.in);
    scedule=new int[50][30];
    while(true){
      n=sca.nextInt();
      if(n==0)break ;
      int i,j,k ;
      for(i=0 ; i<n ; i++)for(j=0 ; j<30 ; j++)scedule[i][j]=0 ;
      for(i=0 ; i<n ; i++){
        int m=sca.nextInt();
        for(j=0 ; j<m ; j++)scedule[i][sca.nextInt()-1]=1 ;
      }
      ArrayList<HashSet<String>>having=new ArrayList<HashSet<String>>();
      for(i=0 ; i<n ; i++){
        HashSet<String>tmp=new HashSet<String>();
        tmp.add(String.valueOf(i));
        having.add(tmp);
      }
      int result=-1 ;
      for(i=0 ; i<30 ; i++){
        HashSet<String>canget=new HashSet<String>();
        for(j=0 ; j<n ; j++){
          if(scedule[j][i]==1){
            HashSet<String>tmp=having.get(j);
            canget.addAll(tmp);
          }
        }
        if(canget.size()==n){
          result=i+1 ;
          break ;
        }
        for(j=0 ; j<n ; j++){
          if(scedule[j][i]==1){
            HashSet<String>tmp=having.get(j);
            tmp.addAll(canget);
          }
        }
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute scedule : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sca : OclFile ; sca := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     scedule := Integer.subrange(1,50)->collect(Integer.subrange(1,30)->collect(0)) ; 
     while (true) do (     n := sca.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
    var i : int ;
    var j : int ;
    var k : int ;
        i := 0 ; while i < n do (         j := 0 ; while j < 30 do (     scedule[i+1][j+1] := 0 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     var m : int ; m := sca.getCurrent()->toInteger() ;
         j := 0 ; while j < m do (     scedule[i+1][sca.getCurrent()->toInteger() - 1+1] := 1 ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var having : Sequence(Set(String)) ; having := Sequence{} ;
        i := 0 ; while i < n do ( (     var tmp : Set(String) ; tmp := Set{} ;
     tmp := tmp->including(((i) + "")) ; 
     having := having->including(tmp) )  ;     i := i + 1 ) ; 
    var result : int ; result := -1 ;
        i := 0 ; while i < 30 do ( (     var canget : Set(String) ; canget := Set{} ;
         j := 0 ; while j < n do ( (     if (scedule[j+1][i+1] = 1) then (     var tmp : Set(String) ; tmp := having->at(j+1) ;
     canget := canget->union(tmp) ) else skip )  ;     j := j + 1 ) ; 
     if (canget->size() = n) then (     result := i + 1 ; 
     break ) else skip ; 
         j := 0 ; while j < n do ( (     if (scedule[j+1][i+1] = 1) then (     var tmp : Set(String) ; tmp := having->at(j+1) ;
     tmp := tmp->union(canget) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Iterator ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      int n=in.nextInt();
      if(n==0)return ;
      int a[][]=new int[n+1][31];
      int b[][]=new int[n][n];
      int ans=31 ;
      boolean judge ;
      for(int i=0 ; i<n ; i++){
        b[i][i]=1 ;
        int f=in.nextInt();
        for(int j=0 ; j<f ; j++)a[i][in.nextInt()]=1 ;
      }
      int t ;
      for(t=1 ; t<=30 ; t++){
        LinkedList<Integer>LL=new LinkedList<Integer>();
        HashSet<Integer>HS=new HashSet<Integer>();
        for(int i=0 ; i<n ; i++)if(a[i][t]==1)LL.add(i);
        for(int i=0 ; i<LL.size(); i++){
          int k=LL.get(i);
          for(int j=0 ; j<n ; j++){
            if(b[k][j]==1){
              HS.add(j);
            }
          }
        }
        if(HS.size()==n)break ;
        for(int i=0 ; i<LL.size(); i++){
          int k=LL.get(i);
          Iterator it=HS.iterator();
          while(it.hasNext()){
            int I=(Integer)it.next();
            b[k][I]=1 ;
          }
        }
      }
      System.out.println(t>30 ?-1 : t);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,31)->collect(0)) ;
    var b : Sequence(Sequence(int)) ; b := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var ans : int ; ans := 31 ;
    var judge : boolean ;
        var i : int ; i := 0 ; while i < n do ( (     b[i+1][i+1] := 1 ; 
     var f : int ; f := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < f do (     a[i+1][in.getCurrent()->toInteger()+1] := 1 ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var t : int ;
        t := 1 ; while t <= 30 do ( (     var LL : Sequence(int) ; LL := Sequence{} ;
     var HS : Set(int) ; HS := Set{} ;
        var i : int ; i := 0 ; while i < n do (     if (a[i+1][t+1] = 1) then     LL := LL->including(i) ; else skip ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < LL->size() do ( (     var k : int ; k := LL->at(i+1) ;
         var j : int ; j := 0 ; while j < n do ( (     if (b[k+1][j+1] = 1) then (     HS := HS->including(j) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (HS->size() = n) then     break else skip ; 
        var i : int ; i := 0 ; while i < LL->size() do ( (     var k : int ; k := LL->at(i+1) ;
     var it : OclIterator ; it := HS->iterator() ;
     while (it.hasNext()) do (     var I : int ; I := it.next()->oclAsType(int) ;
     b[k+1][I+1] := 1 ) )  ;     i := i + 1 ) ; 
 )  ;     t := t + 1 ) ; 
    OclFile["System.out"].println(if t > 30 then -1 else t endif) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static void printConsecutive(int last,int first){
    System.out.print(first++);
    for(int x=first ; x<=last ; x++)System.out.print("+"+x);
  }
  static void findConsecutive(int N){
    for(int last=1 ; last<N ; last++){
      for(int first=0 ; first<last ; first++){
        if(2*N==(last-first)*(last+first+1)){
          System.out.printf(N+"=");
          printConsecutive(last,first+1);
          return ;
        }
      }
    }
    System.out.print("-1");
  }
  public static void main(String[] args){
    int n=12 ;
    findConsecutive(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation printConsecutive( last : int, first : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(first) ; 
         var x : int ; x := first ; while x <= last do (     OclFile["System.out"].print("+" + x) ;  ;     x := x + 1 ) );
  static   operation findConsecutive( N : int) : void
  pre: true
  post: true
  activity: (         var last : int ; last := 1 ; while last < N do ( (         var first : int ; first := 0 ; while first < last do ( (     if (2 * N = (last - first) * (last + first + 1)) then (     OclFile["System.out"].printf(N + "=") ; 
     execute printConsecutive(last, first + 1) ; 
     return ) else skip )  ;     first := first + 1 ) )  ;     last := last + 1 ) ; 
     OclFile["System.out"].print("-1") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     execute findConsecutive(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemB {
  static boolean vis[];
  static ArrayList<Integer>graph[];
  static int counter=0 ;
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int test=Integer.parseInt(br.readLine());
    while(test-->0){
      String line[]=br.readLine().split(" ");
      int n=Integer.parseInt(line[0]);
      int k=Integer.parseInt(line[1]);
      long arr[]=new long[n];
      line=br.readLine().split(" ");
      long count=0 ;
      for(int i=0 ; i<n ; i++){
        arr[i]=Long.parseLong(line[i]);
        count+=(arr[i] % 2);
      }
      String ans="NO" ;
      if(count>=k){
        count-=(k-1);
        if(count % 2==1)ans="YES" ;
      }
      sb.append(ans);
      if(ans.equals("YES")){
        sb.append("\n");
        count=0 ;
        for(int i=0 ; i<n ; i++){
          if(arr[i] % 2==1 && count<k-1){
            sb.append((i+1)+" ");
            count++;
          }
        }
        sb.append(n);
      }
      sb.append("\n");
    }
    System.out.println(sb);
  }
  public static void go(int root,int arr[]){
    if(vis[root]){
      arr[root]=counter ;
      return ;
    }
    vis[root]=true ;
    counter++;
    for(int i=0 ; i<graph[root] .size(); i++){
      int child=graph[root] .get(i);
      go(child,arr);
      arr[child]=counter ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   attribute vis : Sequence(boolean);
  static   attribute graph : Sequence(Sequence(int));
  static   attribute counter : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var test : int ; test := (br.readLine())->toInteger() ;
        while (test > 0) do (        test := test - 1 ;     skip ; (     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
     var n : int ; n := (line[0+1])->toInteger() ;
    var k : int ; k := (line[1+1])->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
    line := br.readLine()->split(" ") ; 
    var count : long ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (line[i+1])->toLong() ; 
     count := count+((arr[i+1] mod 2)) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "NO" ;
    if (count >= k) then (     count := count-((k - 1)) ; 
     if (count mod 2 = 1) then     ans := "YES" ; else skip ) else skip ; 
    sb := sb + StringLib.newString(ans) ; 
    if (ans = "YES") then (     sb := sb + StringLib.newString("\n") ; 
     count := 0 ; 
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 = 1 & count < k - 1) then (     sb := sb + StringLib.newString((i + 1) + " ") ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     sb := sb + StringLib.newString(n) ) else skip ; 
    sb := sb + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
  static   operation go( root : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (vis[root+1]) then (     arr[root+1] := counter ; 
     return ) else skip ; 
     vis[root+1] := true ; 
     counter := counter + 1 ; 
         var i : int ; i := 0 ; while i < graph[root+1]->size() do ( (     var child : int ; child := graph[root+1]->at(i+1) ;
     execute go(child, arr) ; 
     arr[child+1] := counter )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Vector ;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    StringBuilder res=new StringBuilder();
    for(int j=0 ; j<t ; ++j){
      int n=in.nextInt();
      int k=in.nextInt();
      StringBuilder str=new StringBuilder();
      int count=0 ;
      for(int i=1 ; i<=n ; ++i){
        int a=in.nextInt();
        if(k==1 && a % 2==1)count++;
        else if(a % 2==1){
          str.append(i+" ");
          k--;
        }
      }
      if(k==1 && count % 2==1)res.append("YES\n"+str.toString()+n+"\n");
      else res.append("NO\n");
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var res : String ; res := StringLib.newString() ;
        var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var str : String ; str := StringLib.newString() ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     if (k = 1 & a mod 2 = 1) then     count := count + 1 ; else     if (a mod 2 = 1) then (     str := str + StringLib.newString(i + " ") ; 
     k := k - 1 ) else skip ; )  ;     i := i + 1 ) ; 
    if (k = 1 & count mod 2 = 1) then     res := res + StringLib.newString("YES\n" + str+"" + n + "\n") else     res := res + StringLib.newString("NO\n") ; ;  
 )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void EvenOddProduct(int arr[],int n){
    int even=1 ;
    int odd=1 ;
    for(int i=0 ; i<n ; i++){
      if(i % 2==0)even*=arr[i];
      else odd*=arr[i];
    }
    System.out.println("Even Index Product : "+even);
    System.out.println("Odd Index Product : "+odd);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,6 };
      int n=arr.length ;
      EvenOddProduct(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation EvenOddProduct( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var even : int ; even := 1 ;
     var odd : int ; odd := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then     even := even*(arr[i+1]) ; else     odd := odd*(arr[i+1]) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Even Index Product : " + even) ; 
    OclFile["System.out"].println("Odd Index Product : " + odd) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6} ;
     var n : int ; n := arr->size() ;
     execute EvenOddProduct(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printArr(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.printf("%d ",arr[i]);
    System.out.println("");
  }
  static void generateUtil(int x,int arr[],int curr_sum,int curr_idx){
    if(curr_sum==x){
      printArr(arr,curr_idx);
      return ;
    }
    int num=1 ;
    while(num<=x-curr_sum &&(curr_idx==0 || num<=arr[curr_idx-1])){
      arr[curr_idx]=num ;
      generateUtil(x,arr,curr_sum+num,curr_idx+1);
      num++;
    }
  }
  static void generate(int x){
    int arr[]=new int[x];
    generateUtil(x,arr,0,0);
  }
  public static void main(String[] args){
    int x=5 ;
    generate(x);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].printf("%d ", arr[i+1]) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("") );
  static   operation generateUtil( x : int, arr : Sequence(int), curr_sum : int, curr_idx : int) : void
  pre: true
  post: true
  activity: (     if (curr_sum = x) then (     execute printArr(arr, curr_idx) ; 
     return ) else skip ; 
     var num : int ; num := 1 ;
     while (num <= x - curr_sum & (curr_idx = 0 or num <= arr[curr_idx - 1+1])) do (     arr[curr_idx+1] := num ; 
     execute generateUtil(x, arr, curr_sum + num, curr_idx + 1) ; 
     num := num + 1 ) );
  static   operation generate( x : int) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,x)->collect(0) ;
     execute generateUtil(x, arr, 0, 0) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 5 ;
     execute generate(x) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  static int countSetBits(int n){
    int count=0 ;
    while(n>0){
      n &=(n-1);
      count++;
    }
    return count ;
  }
  static int findSum(int n){
    int sum=0 ;
    for(int i=1 ; i<=n ; i++)if(countSetBits(i)==2)sum+=i ;
    return sum ;
  }
  public static void main(String[] args){
    int n=10 ;
    System.out.println(findSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     n := MathLib.bitwiseAnd(n, (n - 1)) ; 
     count := count + 1 ) ; 
     return count );
  static   operation findSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do (     if (countSetBits(i) = 2) then     sum := sum+(i) ; else skip ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(findSum(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float Area(float a,float b){
    if(a<0 && b<0)return-1 ;
    float h=(float)Math.sqrt(((Math.pow(a,2)+Math.pow(b,2))/(Math.pow(a,2)*Math.pow(b,2))));
    float A=(float)(0.70477*Math.pow(h,2));
    return A ;
  }
  public static void main(String[] args){
    float a=5,b=4 ;
    System.out.println(Area(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Area( a : double, b : double) : double
  pre: true
  post: true
  activity: (     if (a < 0 & b < 0) then     return -1 else skip ; 
     var h : double ; h := (((a->pow(2) + b->pow(2)) / (a->pow(2) * b->pow(2))))->sqrt()->oclAsType(double) ;
     var A : double ; A := (0.70477 * h->pow(2))->oclAsType(double) ;
     return A );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 5 ;
    var b : double ; b := 4 ;
     OclFile["System.out"].println(Area(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Map ;
class Solution {
  public int[] smallerNumbersThanCurrent(int[] nums){
    int[] countList=new int[101];
    int[] res=new int[nums.length];
    for(int i=0 ; i<nums.length ; i++)countList[nums[i] ]++;
    for(int i=1 ; i<101 ; i++)countList[i]+=countList[i-1];
    for(int i=0 ; i<nums.length ; i++){
      if(nums[i]==0)res[i]=0 ;
      else res[i]=countList[nums[i]-1];
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
   operation smallerNumbersThanCurrent( nums : Sequence(int)) : Sequence(int)
  pre: true
  post: true
  activity: (     var countList : Sequence(int) ; countList := Integer.subrange(1,101)->collect(0) ;
     var res : Sequence(int) ; res := Integer.subrange(1,nums->size())->collect(0) ;
        var i : int ; i := 0 ; while i < nums->size() do (     countList[nums[i+1]+1] := countList[nums[i+1]+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < 101 do (     countList[i+1] := countList[i+1]+(countList[i - 1+1]) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < nums->size() do ( (     if (nums[i+1] = 0) then     res[i+1] := 0 ; else     res[i+1] := countList[nums[i+1] - 1+1] ; )  ;     i := i + 1 ) ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    int q=scan.nextInt();
    double x0,y0,x1,y1,x2,y2,x3,y3,s1,s2 ;
    for(int i=0 ; i<q ; i++){
      x0=scan.nextDouble();
      y0=scan.nextDouble();
      x1=scan.nextDouble();
      y1=scan.nextDouble();
      x2=scan.nextDouble();
      y2=scan.nextDouble();
      x3=scan.nextDouble();
      y3=scan.nextDouble();
      s1=((x3-x2)*(y0-y2)-(y3-y2)*(x0-x2))/2 ;
      s2=((x3-x2)*(y2-y1)-(y3-y2)*(x2-x1))/2 ;
      System.out.print(x0+(x1-x0)*s1/(s1+s2));
      System.out.print(" ");
      System.out.println(y0+(y1-y0)*s1/(s1+s2));
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := scan.getCurrent()->toInteger() ;
    var x0 : double ;
    var y0 : double ;
    var x1 : double ;
    var y1 : double ;
    var x2 : double ;
    var y2 : double ;
    var x3 : double ;
    var y3 : double ;
    var s1 : double ;
    var s2 : double ;
        var i : int ; i := 0 ; while i < q do ( (     x0 := scan.getCurrent()->toReal() ; 
     y0 := scan.getCurrent()->toReal() ; 
    x1 := scan.getCurrent()->toReal() ; 
    y1 := scan.getCurrent()->toReal() ; 
    x2 := scan.getCurrent()->toReal() ; 
    y2 := scan.getCurrent()->toReal() ; 
    x3 := scan.getCurrent()->toReal() ; 
    y3 := scan.getCurrent()->toReal() ; 
    s1 := ((x3 - x2) * (y0 - y2) - (y3 - y2) * (x0 - x2)) / 2 ; 
    s2 := ((x3 - x2) * (y2 - y1) - (y3 - y2) * (x2 - x1)) / 2 ; 
    OclFile["System.out"].print(x0 + (x1 - x0) * s1 / (s1 + s2)) ; 
    OclFile["System.out"].print(" ") ; 
    OclFile["System.out"].println(y0 + (y1 - y0) * s1 / (s1 + s2)) ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void findsolution(long n,long x,long y){
    if((y-n+1)*(y-n+1)+n-1<x || y<n){
      System.out.println("No solution");
      return ;
    }
    System.out.println(y-n+1);
    while(n-->1)System.out.println("1");
  }
  public static void main(String[] args){
    long n,x,y ;
    n=5 ;
    x=15 ;
    y=15 ;
    findsolution(n,x,y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findsolution( n : long, x : long, y : long) : void
  pre: true
  post: true
  activity: (     if ((y - n + 1) * (y - n + 1) + n - 1 < x or y < n) then (     OclFile["System.out"].println("No solution") ; 
     return ) else skip ; 
     OclFile["System.out"].println(y - n + 1) ; 
         while (n > 1) do (        n := n - 1 ;     skip ;     OclFile["System.out"].println("1") ; ;  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ;
    var x : long ;
    var y : long ;
     n := 5 ; 
    x := 15 ; 
    y := 15 ; 
    execute findsolution(n, x, y) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void longestString(String str1,String str2){
    int count1[]=new int[26],count2[]=new int[26];
    for(int i=0 ; i<str1.length(); i++){
      count1[str1.charAt(i)-'a']++;
    }
    for(int i=0 ; i<str2.length(); i++){
      count2[str2.charAt(i)-'a']++;
    }
    String result="" ;
    for(int i=0 ; i<26 ; i++){
      for(int j=1 ; j<=Math.min(count1[i],count2[i]); j++){
        result+=(char)('a'+i);
      }
    }
    System.out.println(result);
  }
  public static void main(String[] args){
    String str1="geeks",str2="cake" ;
    longestString(str1,str2);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation longestString( str1 : String, str2 : String) : void
  pre: true
  post: true
  activity: (     var count1 : Sequence(int) ; count1 := Integer.subrange(1,26)->collect(0) ;
    var count2 : Sequence(void) ; count2 := Integer.subrange(1,26)->collect(0) ;
         var i : int ; i := 0 ; while i < str1->size() do ( (     count1[str1->at(i+1) - ('a')->char2byte()+1] := count1[str1->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < str2->size() do ( (     count2[str2->at(i+1) - ('a')->char2byte()+1] := count2[str2->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    var result : String ; result := "" ;
        var i : int ; i := 0 ; while i < 26 do ( (         var j : int ; j := 1 ; while j <= Set{count1[i+1], count2[i+1]}->min() do ( (     result := result+(('a' + i)->oclAsType(String)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "geeks" ;
    var str2 : String ; str2 := "cake" ;
     execute longestString(str1, str2) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    String tiles=input.readLine();
    System.out.println(Math.min(getCount(tiles,'0'),getCount(tiles,'1')));
  }
  public static int getCount(String tiles,char tile){
    int count=0 ;
    for(int i=0 ; i<tiles.length(); i++){
      if(tile!=tiles.charAt(i))count++;
      tile=tile=='0' ? '1' : '0' ;
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tiles : String ; tiles := input.readLine() ;
     OclFile["System.out"].println(Set{getCount(tiles, '0'), getCount(tiles, '1')}->min()) );
  static   operation getCount( tiles : String, tile : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < tiles->size() do ( (     if (tile /= tiles->at(i+1)) then     count := count + 1 ; else skip ; 
     tile := if tile = '0' then '1' else '0' endif )  ;     i := i + 1 ) ; 
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    long n=in.nextInt();
    long n2=n*n ;
    long result=0 ;
    for(long x=0 ; x>=1-n ; x--){
      long y2=(long)Math.sqrt(n2-x*x)-1 ;
      while((x-1)*(x-1)+y2*y2>n2){
        result+=1 ;
        y2-=1 ;
      }
    }
    result+=n ;
    result*=4 ;
    if(result<=0)result=1 ;
    out.println(result);
    out.close();
  }
  public static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
  public static MyScanner in=new MyScanner();
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : long ; n := in.nextInt() ;
     var n2 : long ; n2 := n * n ;
    var result : long ; result := 0 ;
        var x : long ; x := 0 ; while x >= 1 - n do ( (     var y2 : long ; y2 := (n2 - x * x)->sqrt()->oclAsType(long) - 1 ;
     while ((x - 1) * (x - 1) + y2 * y2 > n2) do (     result := result+(1) ; 
     y2 := y2-(1) ) )  ;     x := x - 1 ) ; 
    result := result+(n) ; 
    result := result*(4) ; 
    if (result <= 0) then     result := 1 ; else skip ; 
    out.println(result) ; 
    out.close() ; 
 );
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute in : MyScanner := MyScanner.newMyScanner();
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
public class P392A {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(in,out);
    out.close();
  }
  static class Task {
    public void solve(InputReader in,PrintWriter out){
      int n=in.nextInt();
      int x=0,y=n,d=0 ;
      int cnt=0 ;
      while(x<y){
        int de=d+2*x+1 ;
        int dse=d+2*x-2*y+2 ;
        x++;
        if(de>0){
          y--;
          d=dse ;
        }
        else {
          d=de ;
        }
        if(x<y)cnt+=2 ;
        else if(x==y)cnt++;
      }
      out.println(n==0 ? 1 :(cnt+1)<<2);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    public int[] nextIntArray(int n){
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=nextInt();
      return arr ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class P392A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var x : int ; x := 0 ;
    var y : int ; y := n ;
    var d : int ; d := 0 ;
    var cnt : int ; cnt := 0 ;
    while (x < y) do (     var de : int ; de := d + 2 * x + 1 ;
     var dse : int ; dse := d + 2 * x - 2 * y + 2 ;
    x := x + 1 ; 
    if (de > 0) then (     y := y - 1 ; 
     d := dse ) else (     d := de ) ;  
    if (x < y) then     cnt := cnt+(2) else     if (x = y) then     cnt := cnt + 1 ; else skip ; ;  
 ) ; 
    skip ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     arr[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return arr );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.Math ;
import java.io.*;
public class HelloWorld {
  public static void main(String[] args)throws IOException {
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(bf.readLine());
    PrintWriter pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    pw.write((int)Math.max(1,4*(int)(Math.sqrt(2)*n))+"\n");
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (bf.readLine())->toInteger() ;
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]))) ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.ByteArrayInputStream ;
import java.io.File ;
import java.io.PrintWriter ;
import java.util.Scanner ;
import static java.lang.Math.sqrt ;
public class A {
  int USE_FILE=0 ;
  int HAS_TESTCASES=0 ;
  String INPUT="30426905" ;
  void solve(int caseNr){
    int n=in.nextInt();
    if(n==0){
      System.out.println(1);
      return ;
    }
    int ans=4*(int)(n*sqrt(2.0));
    System.out.println(ans);
  }
  private int inf=Integer.MAX_VALUE ;
  private int MOD=(int)1e9+7 ;
  static boolean LOCAL=java.lang.System.getProperty("ONLINE_JUDGE")==null ;
  static Scanner in ;
  static PrintWriter output_writer=new PrintWriter(java.lang.System.out);
  static class System {
    static PrintWriter out=null ;
  }
  void setup()throws Exception {
    System.out=output_writer ;
    if(LOCAL && USE_FILE==0){
      java.lang.System.setIn(new ByteArrayInputStream(INPUT.getBytes()));
      in=new Scanner(java.lang.System.in);
    }
    if(LOCAL && USE_FILE>0){
      String filename=String.format("in/cf%d.txt",USE_FILE);
      File inputFile=new File(filename);
      in=new Scanner(inputFile);
      System.out.printf("[%s] \n",filename);
    }
    if(! LOCAL){
      in=new Scanner(java.lang.System.in);
    }
    long startTime=java.lang.System.currentTimeMillis();
    int t=HAS_TESTCASES>0 ? in.nextInt(): 1 ;
    for(int i=1 ; i<=t ; i++){
      solve(i);
    }
    in.close();
    if(LOCAL){
      System.out.printf("[%dms] \n",java.lang.System.currentTimeMillis()-startTime);
    }
    output_writer.flush();
  }
  public static void main(String[] args)throws Exception {
    new A().setup();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
   attribute USE_FILE : int := 0;
   attribute HAS_TESTCASES : int := 0;
   attribute INPUT : String := "30426905";
   operation solve( caseNr : int) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     if (n = 0) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
     var ans : int ; ans := 4 * (n * sqrt(2.0))->oclAsType(int) ;
     OclFile["System.out"].println(ans) );
   attribute inf : int := 2147483647;
   attribute MOD : int := 1e9->oclAsType(int) + 7;
  static   attribute LOCAL : boolean := java.lang.System.getProperty("ONLINE_JUDGE") = null;
  static   attribute in : OclFile;
  static   attribute output_writer : OclFile := OclFile.newOclFile_Write(java.lang.System.out);
  static class System {
  static   attribute out : OclFile := null;
}
   operation setup() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"] := output_writer ; 
     if (LOCAL & USE_FILE = 0) then (     java.lang.System.setIn(ByteArrayInputStream.newByteArrayInputStream(INPUT->characters()->collect( _c | _c->char2byte() ))) ; 
     in := OclFile.newOclFile_Read(java.lang.System.in) ) else skip ; 
    if (LOCAL & USE_FILE > 0) then (     var filename : String ; filename := StringLib.format("in/cf%d.txt",Sequence{USE_FILE}) ;
     var inputFile : OclFile ; inputFile := OclFile(filename) ;
     in := OclFile.newOclFile_Read(OclFile.newOclFile(inputFile)) ; 
     OclFile["System.out"].printf("[%s] \n", filename) ) else skip ; 
    if (not(LOCAL)) then (     in := OclFile.newOclFile_Read(java.lang.System.in) ) else skip ; 
    var startTime : long ; startTime := java.lang.System.currentTimeMillis() ;
    var t : int ; t := if HAS_TESTCASES > 0 then in.getCurrent()->toInteger() else 1 endif ;
        var i : int ; i := 1 ; while i <= t do ( (     execute solve(i) )  ;     i := i + 1 ) ; 
    skip ; 
    if (LOCAL) then (     OclFile["System.out"].printf("[%dms] \n", java.lang.System.currentTimeMillis() - startTime) ) else skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     A.newA().setup() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static char city ;
  static int flag ;
  public static void check(int nn){
    if(nn==0){
      if(city=='A'){
        city='X' ;
        flag=0 ;
      }
      else if(city=='B'){
        city='Y' ;
        flag=0 ;
      }
      else if(city=='X'){
        flag=2 ;
      }
      else if(city=='Y'){
        city='X' ;
        flag=0 ;
      }
      else if(city=='Z'){
        city='W' ;
        flag=0 ;
      }
      else if(city=='W'){
        city='B' ;
        flag=1 ;
      }
    }
    else if(nn==1){
      if(city=='A'){
        city='Y' ;
        flag=0 ;
      }
      else if(city=='B'){
        city='X' ;
        flag=0 ;
      }
      else if(city=='Y'){
        flag=2 ;
      }
      else if(city=='X'){
        city='Z' ;
        flag=0 ;
      }
      else if(city=='Z'){
        city='B' ;
        flag=1 ;
      }
      else if(city=='W'){
        city='Y' ;
        flag=0 ;
      }
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      city='A' ;
      flag=0 ;
      String s=sc.next();
      if(s.equals("#"))break ;
      for(int i=0 ; i<s.length(); i++){
        char c=s.charAt(i);
        int n=Integer.parseInt(""+c);
        check(n);
        if(flag==2)break ;
      }
      if(flag==1)System.out.println("Yes");
      else System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute city : String;
  static   attribute flag : int;
  static   operation check( nn : int) : void
  pre: true
  post: true
  activity: (     if (nn = 0) then (     if (city = 'A') then (     city := 'X' ; 
     flag := 0 ) else     if (city = 'B') then (     city := 'Y' ; 
     flag := 0 ) else     if (city = 'X') then (     flag := 2 ) else     if (city = 'Y') then (     city := 'X' ; 
     flag := 0 ) else     if (city = 'Z') then (     city := 'W' ; 
     flag := 0 ) else     if (city = 'W') then (     city := 'B' ; 
     flag := 1 ) else skip ; ;  ;  ;  ;  ) else     if (nn = 1) then (     if (city = 'A') then (     city := 'Y' ; 
     flag := 0 ) else     if (city = 'B') then (     city := 'X' ; 
     flag := 0 ) else     if (city = 'Y') then (     flag := 2 ) else     if (city = 'X') then (     city := 'Z' ; 
     flag := 0 ) else     if (city = 'Z') then (     city := 'B' ; 
     flag := 1 ) else     if (city = 'W') then (     city := 'Y' ; 
     flag := 0 ) else skip ; ;  ;  ;  ;  ) else skip ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     city := 'A' ; 
     flag := 0 ; 
    var s : String ; s := sc.getCurrent() ;
    if (s = "#") then     break else skip ; 
        var i : int ; i := 0 ; while i < s->size() do ( (     var c : String ; c := s->at(i+1) ;
     var n : int ; n := ("" + c)->toInteger() ;
     execute check(n) ; 
     if (flag = 2) then     break else skip )  ;     i := i + 1 ) ; 
    if (flag = 1) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(true){
      String s=sc.next();
      if(s.equals("#")){
        break ;
      }
      int[][] g=new int[200][2];
      for(int i=0 ; i<200 ; i++){
        Arrays.fill(g[i],-1);
      }
      g['a'][0]='x' ;
      g['a'][1]='y' ;
      g['x'][1]='z' ;
      g['y'][0]='x' ;
      g['z'][0]='w' ;
      g['z'][1]='b' ;
      g['w'][0]='b' ;
      g['w'][1]='y' ;
      g['b'][0]='y' ;
      g['b'][1]='x' ;
      int now='a' ;
      boolean flg=false ;
      for(int i=0 ; i<s.length(); i++){
        int ind=s.charAt(i)-'0' ;
        if(ind>=2){
          flg=true ;
          break ;
        }
        int c=g[now][ind];
        if(c==-1){
          flg=true ;
          break ;
        }
        now=c ;
      }
      if(! flg && now=='b'){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var s : String ; s := sc.getCurrent() ;
     if (s = "#") then (     break ) else skip ; 
    var g : Sequence(Sequence(int)) ; g := Integer.subrange(1,200)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < 200 do ( (     g[i+1] := g[i+1]->collect(-1) )  ;     i := i + 1 ) ; 
    g['a'+1][0+1] := 'x' ; 
    g['a'+1][1+1] := 'y' ; 
    g['x'+1][1+1] := 'z' ; 
    g['y'+1][0+1] := 'x' ; 
    g['z'+1][0+1] := 'w' ; 
    g['z'+1][1+1] := 'b' ; 
    g['w'+1][0+1] := 'b' ; 
    g['w'+1][1+1] := 'y' ; 
    g['b'+1][0+1] := 'y' ; 
    g['b'+1][1+1] := 'x' ; 
    var now : int ; now := 'a' ;
    var flg : boolean ; flg := false ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var ind : int ; ind := s->at(i+1) - ('0')->char2byte() ;
     if (ind >= 2) then (     flg := true ; 
     break ) else skip ; 
    var c : int ; c := g[now+1][ind+1] ;
    if (c = -1) then (     flg := true ; 
     break ) else skip ; 
    now := c ; 
 )  ;     i := i + 1 ) ; 
    if (not(flg) & now = 'b') then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      char c[]=in.next().toCharArray();
      if(c[0]=='#')return ;
      char state='A' ;
      boolean judge=true ;
      for(int i=0 ; i<c.length ; i++){
        if(state=='A'){
          if(c[i]=='0')state='X' ;
          else state='Y' ;
        }
        else if(state=='X'){
          if(c[i]=='0')judge=false ;
          else state='Z' ;
        }
        else if(state=='Y'){
          if(c[i]=='0')state='X' ;
          else judge=false ;
        }
        else if(state=='Z'){
          if(c[i]=='0')state='W' ;
          else state='B' ;
        }
        else if(state=='W'){
          if(c[i]=='0')state='B' ;
          else state='Y' ;
        }
        else if(state=='B'){
          if(c[i]=='0')state='Y' ;
          else state='X' ;
        }
        if(! judge)break ;
        if(i==c.length-1){
          if(state=='B')break ;
          else judge=false ;
        }
      }
      System.out.println(judge ? "Yes" : "No");
    }
  }
  static public void debug(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var c : Sequence(String) ; c := in.getCurrent()->characters() ;
     if (c[0+1] = '#') then     return else skip ; 
    var state : String ; state := 'A' ;
    var judge : boolean ; judge := true ;
        var i : int ; i := 0 ; while i < c->size() do ( (     if (state = 'A') then (     if (c[i+1] = '0') then     state := 'X' ; else     state := 'Y' ; ) else     if (state = 'X') then (     if (c[i+1] = '0') then     judge := false ; else     state := 'Z' ; ) else     if (state = 'Y') then (     if (c[i+1] = '0') then     state := 'X' ; else     judge := false ; ) else     if (state = 'Z') then (     if (c[i+1] = '0') then     state := 'W' ; else     state := 'B' ; ) else     if (state = 'W') then (     if (c[i+1] = '0') then     state := 'B' ; else     state := 'Y' ; ) else     if (state = 'B') then (     if (c[i+1] = '0') then     state := 'Y' ; else     state := 'X' ; ) else skip ; ;  ;  ;  ;  ;  
     if (not(judge)) then     break else skip ; 
     if (i = c->size() - 1) then (     if (state = 'B') then     break else     judge := false ; ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if judge then "Yes" else "No" endif) ; 
 )  ) );
  static    operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    while(scan.hasNext()){
      String str=scan.next();
      if(str.equals("#")){
        break ;
      }
      char city='A' ;
      for(int i=0 ; i<str.length()&& city!='M' ; i++){
        city=ans(city,str.charAt(i));
      }
      System.out.println((city=='B')? "Yes" : "No");
    }
  }
  public static char ans(char city,char road){
    switch(city){
      case 'A' : return(road=='0')? 'X' : 'Y' ;
      case 'X' : return(road=='0')? 'M' : 'Z' ;
      case 'Y' : return(road=='0')? 'X' : 'M' ;
      case 'W' : return(road=='0')? 'B' : 'Y' ;
      case 'Z' : return(road=='0')? 'W' : 'B' ;
      case 'B' : return(road=='0')? 'Y' : 'X' ;
    }
    return city ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (scan.hasNext()) do (     var str : String ; str := scan.getCurrent() ;
     if (str = "#") then (     break ) else skip ; 
    var city : String ; city := 'A' ;
        var i : int ; i := 0 ; while i < str->size() & city /= 'M' do ( (     city := ans(city, str->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if (city = 'B') then "Yes" else "No" endif) ; 
 ) );
  static   operation ans( city : String, road : String) : String
  pre: true
  post: true
  activity: ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (city) ; 
       if _switchval = 'A' then
     return if (road = '0') then 'X' else 'Y' endif 
   else skip ;
       if _switchval = 'X' then
     return if (road = '0') then 'M' else 'Z' endif 
   else skip ;
       if _switchval = 'Y' then
     return if (road = '0') then 'X' else 'M' endif 
   else skip ;
       if _switchval = 'W' then
     return if (road = '0') then 'B' else 'Y' endif 
   else skip ;
       if _switchval = 'Z' then
     return if (road = '0') then 'W' else 'B' endif 
   else skip ;
       if _switchval = 'B' then
     return if (road = '0') then 'Y' else 'X' endif 
   else skip ;
 )
     return city );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    HashMap<Character,HashMap<Character,Character>>map=new HashMap<>();
    map.put('A',new HashMap<>());
    map.get('A').put('0','X');
    map.get('A').put('1','Y');
    map.put('X',new HashMap<>());
    map.get('X').put('1','Z');
    map.put('Y',new HashMap<>());
    map.get('Y').put('0','X');
    map.put('Z',new HashMap<>());
    map.get('Z').put('0','W');
    map.get('Z').put('1','B');
    map.put('W',new HashMap<>());
    map.get('W').put('0','B');
    map.get('W').put('1','Y');
    map.put('B',new HashMap<>());
    map.get('B').put('0','Y');
    map.get('B').put('1','X');
    while(true){
      char[] arr=sc.next().toCharArray();
      if(arr[0]=='#'){
        break ;
      }
      char cur='A' ;
      boolean flag=true ;
      for(char c : arr){
        if(map.get(cur).containsKey(c)){
          cur=map.get(cur).get(c);
        }
        else {
          flag=false ;
          break ;
        }
      }
      if(flag){
        if(cur!='B'){
          flag=false ;
        }
      }
      if(flag){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
      System.out.flush();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var map : Map(String,Map(String,String)) ; map := Map{} ;
    map := map->union(Map{'A' |-> Map{}}) ; 
    map := map->at('A')->union(Map{'0' |-> 'X'}) ; 
    map := map->at('A')->union(Map{'1' |-> 'Y'}) ; 
    map := map->union(Map{'X' |-> Map{}}) ; 
    map := map->at('X')->union(Map{'1' |-> 'Z'}) ; 
    map := map->union(Map{'Y' |-> Map{}}) ; 
    map := map->at('Y')->union(Map{'0' |-> 'X'}) ; 
    map := map->union(Map{'Z' |-> Map{}}) ; 
    map := map->at('Z')->union(Map{'0' |-> 'W'}) ; 
    map := map->at('Z')->union(Map{'1' |-> 'B'}) ; 
    map := map->union(Map{'W' |-> Map{}}) ; 
    map := map->at('W')->union(Map{'0' |-> 'B'}) ; 
    map := map->at('W')->union(Map{'1' |-> 'Y'}) ; 
    map := map->union(Map{'B' |-> Map{}}) ; 
    map := map->at('B')->union(Map{'0' |-> 'Y'}) ; 
    map := map->at('B')->union(Map{'1' |-> 'X'}) ; 
    while (true) do (     var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
     if (arr[0+1] = '#') then (     break ) else skip ; 
    var cur : String ; cur := 'A' ;
    var flag : boolean ; flag := true ;
    for (c : arr) do ( (     if (map->at(cur).containsKey(c)) then (     cur := map->at(cur)->at(c+1) ) else (     flag := false ; 
     break ) )  ) ; 
    if (flag) then (     if (cur /= 'B') then (     flag := false ) else skip ) else skip ; 
    if (flag) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
    OclFile["System.out"].flush() ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.awt.geom.Point2D ;
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    int q=in.nextInt();
    for(int i=0 ; i<q ; i++)new CGL_2B().doIt();
  }
  class CGL_2B {
    double cross(Point2D p1,Point2D p2){
      return p1.getX()*p2.getY()-p1.getY()*p2.getX();
    }
    Point2D sum(Point2D p1,Point2D p2){
      return new Point2D.Double(p1.getX()+p2.getX(),p1.getY()+p2.getY());
    }
    Point2D mul(double n,Point2D p1){
      return new Point2D.Double(p1.getX()*n,p1.getY()*n);
    }
    Point2D diff(Point2D p1,Point2D p2){
      return new Point2D.Double(p1.getX()-p2.getX(),p1.getY()-p2.getY());
    }
    Point2D intersectionPoint(Line2D l1,Line2D l2){
      return intersectionPoint(l1.getP1(),l1.getP2(),l2.getP1(),l2.getP2());
    }
    Point2D intersectionPoint(Point2D a1,Point2D a2,Point2D b1,Point2D b2){
      Point2D a=diff(a2,a1),b=diff(b2,b1);
      return sum(a1,mul(cross(b,diff(b1,a1))/cross(b,a),a));
    }
    void doIt(){
      Line2D l1=new Line2D.Double(in.nextDouble(),in.nextDouble(),in.nextDouble(),in.nextDouble());
      ;
      Line2D l2=new Line2D.Double(in.nextDouble(),in.nextDouble(),in.nextDouble(),in.nextDouble());
      ;
      Point2D p=intersectionPoint(l1,l2);
      System.out.printf("%.10f %.10f\n",p.getX(),p.getY());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var q : int ; q := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < q do (     CGL()B.newCGL()B().doIt() ;  ;     i := i + 1 ) );
 class CGL{
   operation cross( p1 : Point2D, p2 : Point2D) : double
  pre: true
  post: true
  activity: (     return p1.getX() * p2.getY() - p1.getY() * p2.getX() );
   operation sum( p1 : Point2D, p2 : Point2D) : Point2D
  pre: true
  post: true
  activity: (     return Double.newDouble(p1.getX() + p2.getX(), p1.getY() + p2.getY()) );
   operation mul( n : double, p1 : Point2D) : Point2D
  pre: true
  post: true
  activity: (     return Double.newDouble(p1.getX() * n, p1.getY() * n) );
   operation diff( p1 : Point2D, p2 : Point2D) : Point2D
  pre: true
  post: true
  activity: (     return Double.newDouble(p1.getX() - p2.getX(), p1.getY() - p2.getY()) );
   operation intersectionPoint( l1 : Line2D, l2 : Line2D) : Point2D
  pre: true
  post: true
  activity: (     return intersectionPoint(l1.getP1(), l1.getP2(), l2.getP1(), l2.getP2()) );
   operation intersectionPoint( a1 : Point2D, a2 : Point2D, b1 : Point2D, b2 : Point2D) : Point2D
  pre: true
  post: true
  activity: (     var a : Point2D ; a := diff(a2, a1) ;
    var b : Point2D ; b := diff(b2, b1) ;
     return sum(a1, mul(cross(b, diff(b1, a1)) / cross(b, a), a)) );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var l1 : Line2D ; l1 := Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal()) ;
    var l2 : Line2D ; l2 := Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal()) ;
    var p : Point2D ; p := intersectionPoint(l1, l2) ;
    OclFile["System.out"].printf("%.10f %.10f\n", p.getX(), p.getY()) ; 
 );
}
B {
   operation cross( p1 : Point2D, p2 : Point2D) : double
  pre: true
  post: true
  activity: (     return p1.getX() * p2.getY() - p1.getY() * p2.getX() );
   operation sum( p1 : Point2D, p2 : Point2D) : Point2D
  pre: true
  post: true
  activity: (     return Double.newDouble(p1.getX() + p2.getX(), p1.getY() + p2.getY()) );
   operation mul( n : double, p1 : Point2D) : Point2D
  pre: true
  post: true
  activity: (     return Double.newDouble(p1.getX() * n, p1.getY() * n) );
   operation diff( p1 : Point2D, p2 : Point2D) : Point2D
  pre: true
  post: true
  activity: (     return Double.newDouble(p1.getX() - p2.getX(), p1.getY() - p2.getY()) );
   operation intersectionPoint( l1 : Line2D, l2 : Line2D) : Point2D
  pre: true
  post: true
  activity: (     return intersectionPoint(l1.getP1(), l1.getP2(), l2.getP1(), l2.getP2()) );
   operation intersectionPoint( a1 : Point2D, a2 : Point2D, b1 : Point2D, b2 : Point2D) : Point2D
  pre: true
  post: true
  activity: (     var a : Point2D ; a := diff(a2, a1) ;
    var b : Point2D ; b := diff(b2, b1) ;
     return sum(a1, mul(cross(b, diff(b1, a1)) / cross(b, a), a)) );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var l1 : Line2D ; l1 := Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal()) ;
    var l2 : Line2D ; l2 := Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal(), in.getCurrent()->toReal()) ;
    var p : Point2D ; p := intersectionPoint(l1, l2) ;
    OclFile["System.out"].printf("%.10f %.10f\n", p.getX(), p.getY()) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  static int startWithBlack(String S){
    int N=S.length();
    int ans=0 ;
    for(int n=0 ; n<N ; n++){
      if((n % 2==0)^(S.charAt(n)=='0')){
        ans++;
      }
    }
    return ans ;
  }
  static int startWithWhite(String S){
    int N=S.length();
    int ans=0 ;
    for(int n=0 ; n<N ; n++){
      if((n % 2==0)^(S.charAt(n)=='1')){
        ans++;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    System.out.println(Math.min(startWithBlack(S),startWithWhite(S)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation startWithBlack( S : String) : int
  pre: true
  post: true
  activity: (     var N : int ; N := S->size() ;
     var ans : int ; ans := 0 ;
         var n : int ; n := 0 ; while n < N do ( (     if ((n mod 2 = 0) xor (S->at(n+1) = '0')) then (     ans := ans + 1 ) else skip )  ;     n := n + 1 ) ; 
     return ans );
  static   operation startWithWhite( S : String) : int
  pre: true
  post: true
  activity: (     var N : int ; N := S->size() ;
     var ans : int ; ans := 0 ;
         var n : int ; n := 0 ; while n < N do ( (     if ((n mod 2 = 0) xor (S->at(n+1) = '1')) then (     ans := ans + 1 ) else skip )  ;     n := n + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
     OclFile["System.out"].println(Set{startWithBlack(S), startWithWhite(S)}->min()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(final java.util.Scanner sc,final java.io.PrintStream out){
    int[][] d ;
    int[] a,b ;
    int n ;
    int i,j,k ;
    n=sc.nextInt();
    a=new int[n];
    b=new int[n];
    for(i=0 ; i<n ; ++i){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
    }
    d=new int[n][n];
    for(j=0 ; j<n ; ++j)d[0][j]=0 ;
    for(i=1 ; i<n ; ++i)for(j=0 ; j+i<n ; ++j){
      d[i][j]=d[0][j]+d[i-1][j+1]+a[j]*b[j]*a[j+1]*b[j+i];
      for(k=1 ; k<i ; ++k)d[i][j]=Math.min(d[i][j],d[k][j]+d[i-k-1][j+k+1]+a[j]*b[j+k]*a[j+k+1]*b[j+i]);
    }
    out.println(d[n-1][0]);
  }
  public static void main(final String[] args){
(new Main()).run(new java.util.Scanner(System.in),System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( sc : Scanner, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var d : Sequence(Sequence(int)) ;
     var a : Sequence(int) ;
    var b : Sequence(int) ;
    var n : int ;
    var i : int ;
    var j : int ;
    var k : int ;
    n := sc.nextInt() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
    b := Integer.subrange(1,n)->collect(0) ; 
        i := 0 ; while i < n do ( (     a[i+1] := sc.nextInt() ; 
     b[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    d := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
        j := 0 ; while j < n do (     d[0+1][j+1] := 0 ;  ;     j := j + 1 ) ; 
        i := 1 ; while i < n do (         j := 0 ; while j + i < n do ( (     d[i+1][j+1] := d[0+1][j+1] + d[i - 1+1][j + 1+1] + a[j+1] * b[j+1] * a[j + 1+1] * b[j + i+1] ; 
         k := 1 ; while k < i do (     d[i+1][j+1] := Set{d[i+1][j+1], d[k+1][j+1] + d[i - k - 1+1][j + k + 1+1] + a[j+1] * b[j + k+1] * a[j + k + 1+1] * b[j + i+1]}->min() ;  ;     k := k + 1 ) )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    out.println(d[n - 1+1][0+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(Scanner.newScanner(OclFile["System.in"]), OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  final int INF=Integer.MAX_VALUE/4 ;
  private void doit(){
    Scanner sc=new Scanner(System.in);
    String a=sc.next();
    int n=Integer.parseInt(a);
    int[][] data=new int[n][2];
    int[][] memo=new int[n][n];
    for(int i=0 ; i<n ; i++){
      Arrays.fill(memo[i],INF);
      memo[i][i]=0 ;
    }
    for(int i=0 ; i<n ; i++){
      data[i][0]=sc.nextInt();
      data[i][1]=sc.nextInt();
    }
    for(int i=0 ; i<n-1 ; i++){
      memo[i][i+1]=data[i][0]*data[i][1]*data[i+1][0]*data[i+1][1];
    }
    for(int k=2 ; k<n ; k++){
      for(int i=0 ; i+k<n ; i++){
        for(int j=i ; j<i+k ; j++){
          int value2=(data[i][0]*data[j][1])*(data[j+1][0]*data[i+k][1]);
          int value=memo[i][j]+memo[j+1][i+k]+value2 ;
          memo[i][i+k]=Math.min(memo[i][i+k],value);
        }
      }
    }
    System.out.println(memo[0][n-1]);
  }
  public static void main(String[] args){
    Main obj=new Main();
    obj.doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := 2147483647 / 4;
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := sc.getCurrent() ;
    var n : int ; n := (a)->toInteger() ;
    var data : Sequence(Sequence(int)) ; data := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
    var memo : Sequence(Sequence(int)) ; memo := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     memo[i+1] := memo[i+1]->collect(INF) ; 
     memo[i+1][i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     data[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     data[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < (n)->char2byte() - 1 do ( (     memo[i+1][i + 1+1] := data[i+1][0+1] * data[i+1][1+1] * data[i + 1+1][0+1] * data[i + 1+1][1+1] )  ;     i := i + 1 ) ; 
        var k : int ; k := 2 ; while k < n do ( (         var i : int ; i := 0 ; while i + k < n do ( (         var j : int ; j := i ; while j < i + k do ( (     var value2 : int ; value2 := (data[i+1][0+1] * data[j+1][1+1]) * (data[j + 1+1][0+1] * data[i + k+1][1+1]) ;
     var value : int ; value := memo[i+1][j+1] + memo[j + 1+1][i + k+1] + value2 ;
     memo[i+1][i + k+1] := Set{memo[i+1][i + k+1], value}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(memo[0+1][(n)->char2byte() - 1+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : Main ; obj := Main.newMain() ;
     obj.doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
public class Main {
  public static void main(String[] args){
    int n=parseNum();
    int[][] c=new int[n][2];
    int[][] d=new int[n][n];
    for(int i=0 ; i<n ; i++){
      c[i][0]=parseNum();
      c[i][1]=parseNum();
    }
    for(int l=1 ; l<n ; l++){
      for(int i=0 ; i+l<n ; i++){
        for(int j=i+l,k=i ; k<j ; k++){
          int t=d[i][k]+d[k+1][j]+c[i][0]*c[k][1]*c[k+1][0]*c[j][1];
          d[i][j]=(d[i][j]==0)? t : Math.min(d[i][j],t);
        }
      }
    }
    System.out.println(d[0][n-1]);
  }
  private static int parseNum(){
    try {
      int buf=0 ;
      int num=0 ;
      int mns=0 ;
      int skp=1 ;
      while(true){
        buf=System.in.read();
        if(buf=='-'){
          mns=1 ;
          skp=0 ;
        }
        else if(buf>='0' && buf<='9'){
          num=num*10+(buf-'0');
          skp=0 ;
        }
        else if(skp==0){
          return(mns==0)? num : num*(-1);
        }
      }
    }
    catch(IOException e){
    }
    return-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := parseNum() ;
     var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
    var d : Sequence(Sequence(int)) ; d := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1][0+1] := parseNum() ; 
     c[i+1][1+1] := parseNum() )  ;     i := i + 1 ) ; 
        var l : int ; l := 1 ; while l < n do ( (         var i : int ; i := 0 ; while i + l < n do ( (         var j : int ; j := i + l ;
    var k : int ; k := i ; while k < j do ( (     var t : int ; t := d[i+1][k+1] + d[k + 1+1][j+1] + c[i+1][0+1] * c[k+1][1+1] * c[k + 1+1][0+1] * c[j+1][1+1] ;
     d[i+1][j+1] := if (d[i+1][j+1] = 0) then t else Set{d[i+1][j+1], t}->min() endif )  ;     k := k + 1 ) )  ;     i := i + 1 ) )  ;     l := l + 1 ) ; 
    OclFile["System.out"].println(d[0+1][n - 1+1]) ; 
 );
  static   operation parseNum() : int
  pre: true
  post: true
  activity: (     try (     var buf : int ; buf := 0 ;
     var num : int ; num := 0 ;
    var mns : int ; mns := 0 ;
    var skp : int ; skp := 1 ;
    while (true) do (     buf := OclFile["System.in"].read() ; 
     if (buf = '-') then (     mns := 1 ; 
     skp := 0 ) else     if (buf >= '0' & buf <= '9') then (     num := num * 10 + (buf - ('0')->char2byte()) ; 
     skp := 0 ) else     if (skp = 0) then (     return if (mns = 0) then num else num * (-1) endif ) else skip ; ;  ) ; 
 )   catch (e : IOException) do skip
     return -1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final int n=sc.nextInt();
    int[][] over=new int[n][];
    for(int i=0 ; i<n ; i++){
      over[i]=new int[n-i];
    }
    int[][] under=new int[n][];
    for(int i=0 ; i<n ; i++){
      under[i]=new int[n-i];
    }
    int[][] DP=new int[n][];
    for(int i=0 ; i<n ; i++){
      DP[i]=new int[n-i];
      Arrays.fill(DP[i],Integer.MAX_VALUE);
    }
    for(int i=0 ; i<n ; i++){
      over[0][i]=sc.nextInt();
      under[0][i]=sc.nextInt();
      DP[0][i]=0 ;
    }
    for(int i=1 ; i<n ; i++){
      for(int j=0 ; j<n-i ; j++){
        for(int k=0 ; k<i ; k++){
          final int left_range=k ;
          final int left_start=j ;
          final int right_range=i-k-1 ;
          final int right_start=j+k+1 ;
          final int cost=DP[left_range][left_start]+DP[right_range][right_start]+over[left_range][left_start]*under[left_range][left_start]*over[right_range][right_start]*under[right_range][right_start];
          if(DP[i][j]>cost){
            DP[i][j]=cost ;
            under[i][j]=under[right_range][right_start];
            over[i][j]=over[left_range][left_start];
          }
        }
      }
    }
    System.out.println(DP[n-1][0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var over : Sequence(Sequence(int)) ; over := Integer.subrange(1,n)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < n do ( (     over[i+1] := Integer.subrange(1,n - i)->collect(0) )  ;     i := i + 1 ) ; 
    var under : Sequence(Sequence(int)) ; under := Integer.subrange(1,n)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < n do ( (     under[i+1] := Integer.subrange(1,n - i)->collect(0) )  ;     i := i + 1 ) ; 
    var DP : Sequence(Sequence(int)) ; DP := Integer.subrange(1,n)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < n do ( (     DP[i+1] := Integer.subrange(1,n - i)->collect(0) ; 
     DP[i+1] := DP[i+1]->collect(2147483647) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     over[0+1][i+1] := sc.getCurrent()->toInteger() ; 
     under[0+1][i+1] := sc.getCurrent()->toInteger() ; 
     DP[0+1][i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 0 ; while j < n - i do ( (         var k : int ; k := 0 ; while k < i do ( (     var left_range : int ; left_range := k ;
     var left_start : int ; left_start := j ;
    var right_range : int ; right_range := i - k - 1 ;
    var right_start : int ; right_start := j + k + 1 ;
    var cost : int ; cost := DP[left_range+1][left_start+1] + DP[right_range+1][right_start+1] + over[left_range+1][left_start+1] * under[left_range+1][left_start+1] * over[right_range+1][right_start+1] * under[right_range+1][right_start+1] ;
    if (DP[i+1][j+1] > cost) then (     DP[i+1][j+1] := cost ; 
     under[i+1][j+1] := under[right_range+1][right_start+1] ; 
     over[i+1][j+1] := over[left_range+1][left_start+1] ) else skip ; 
 )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(DP[n - 1+1][0+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  int n ;
  int[] a,b ;
  void run(){
    n=sc.nextInt();
    a=new int[n];
    b=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
      b[i]=sc.nextInt();
    }
    solve();
  }
  void solve(){
    int[][] dp=new int[n][n];
    for(int i=0 ; i<n ; i++){
      Arrays.fill(dp[i],INF);
      dp[i][i]=0 ;
    }
    for(int m=1 ; m<n ; m++){
      for(int i=0,j=m ; j<n ; i++,j++){
        for(int k=i ; k<j ; k++){
          dp[i][j]=Math.min(dp[i][j],dp[i][k]+dp[k+1][j]+a[i]*b[k]*a[k+1]*b[j]);
        }
      }
    }
    println(""+dp[0][n-1]);
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   attribute n : int;
   attribute a : Sequence(int);
   operation run() : void
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
     a := Integer.subrange(1,n)->collect(0) ; 
    b := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute solve() ; 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do ( (     dp[i+1] := dp[i+1]->collect(INF) ; 
     dp[i+1][i+1] := 0 )  ;     i := i + 1 ) ; 
         var m : int ; m := 1 ; while m < n do ( (         var i : int ; i := 0 ;
    var j : int ; j := m ; while j < n do ( (         var k : int ; k := i ; while k < j do ( (     dp[i+1][j+1] := Set{dp[i+1][j+1], dp[i+1][k+1] + dp[k + 1+1][j+1] + a[i+1] * b[k+1] * a[k + 1+1] * b[j+1]}->min() )  ;     k := k + 1 ) )  ;     i := i + 1 ;     j := j + 1 ) )  ;     m := m + 1 ) ; 
     execute println("" + dp[0+1][n - 1+1]) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public String formation(String str){
    LinkedList<Character>list=new LinkedList<Character>();
    list.add(str.charAt(0));
    int now=0 ;
    for(int i=3 ; i<str.length(); i+=3){
      if(str.charAt(i-1)=='>'){
        now++;
      }
      else {
        now--;
      }
      if(now>=list.size()){
        list.addLast(str.charAt(i));
      }
      else if(now<0){
        list.addFirst(str.charAt(i));
        now=0 ;
      }
    }
    StringBuilder ans=new StringBuilder();
    for(Character x : list){
      ans.append(x);
    }
    return ans.toString();
  }
  public void solve()throws IOException {
    int n=nextInt();
    for(int i=0 ; i<n ; i++){
      String str=nextToken();
      writer.println(formation(str));
    }
    writer.flush();
  }
  public static void main(String args[])throws IOException {
    new Main().run();
  }
  BufferedReader reader ;
  StringTokenizer tokenizer ;
  PrintWriter writer ;
  public void run()throws IOException {
    try {
      reader=new BufferedReader(new InputStreamReader(System.in));
      tokenizer=null ;
      writer=new PrintWriter(System.out);
      solve();
      reader.close();
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public String nextToken()throws IOException {
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation formation( str : String) : String
  pre: true
  post: true
  activity: (     var list : Sequence(String) ; list := Sequence{} ;
     list := list->including(str->at(0+1)) ; 
    var now : int ; now := 0 ;
        var i : int ; i := 3 ; while i < str->size() do ( (     if (str->at(i - 1+1) = '>') then (     now := now + 1 ) else (     now := now - 1 ) ;  
     if (now >= list->size()) then (     list := list->append(str->at(i+1)) ) else     if (now < 0) then (     list := list->prepend(str->at(i+1)) ; 
     now := 0 ) else skip ; )  ;     i := i+(3) ) ; 
    var ans : String ; ans := StringLib.newString() ;
    for (x : list) do ( (     ans := ans + StringLib.newString(x) )  ) ; 
    return ans+"" 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
         var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := nextToken() ;
     writer.println(formation(str)) )  ;     i := i + 1 ) ; 
     writer.flush() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   attribute writer : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     try (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := null ; 
    writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int[][] result=null ;
    for(int t=0 ; t<n ; t++){
      char[] train=s.next().toCharArray();
      if(train.length>1){
        result=createTrainGraph(train);
        int next=NO_CONNECTION ;
        for(int i=0 ; i<result.length ; i++){
          if(result[i][0]==NO_CONNECTION && result[i][1]!=NO_CONNECTION){
            next=i ;
          }
        }
        while(next!=-1){
          System.out.printf("%c",next+'a');
          next=result[next][REAR];
        }
        System.out.println();
      }
      else {
        System.out.println(train[0]);
      }
    }
  }
  static final int FRONT=0 ;
  static final int REAR=1 ;
  static final int NO_CONNECTION=-1 ;
  static int[][] createTrainGraph(char[] input){
    int[][] train=new int[26][2];
    for(int i=0 ; i<train.length ; i++){
      for(int j=0 ; j<train[0] .length ; j++){
        train[i][j]=NO_CONNECTION ;
      }
    }
    boolean front=false ;
    int before=input[0];
    for(int i=1 ; i<input.length ; i++){
      int current=input[i];
      if('a'<=current && current<='z'){
        if(front){
          train[before-'a'][FRONT]=current-'a' ;
          train[current-'a'][REAR]=before-'a' ;
        }
        else {
          train[before-'a'][REAR]=current-'a' ;
          train[current-'a'][FRONT]=before-'a' ;
        }
        before=current ;
      }
      else if(current=='>'){
        front=false ;
      }
      else if(current=='<'){
        front=true ;
      }
    }
    return train ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
     var result : Sequence(Sequence(int)) ; result := null ;
         var t : int ; t := 0 ; while t < n do ( (     var train : Sequence(String) ; train := s.getCurrent()->characters() ;
     if (train->size() > 1) then (     result := createTrainGraph(train) ; 
     var next : int ; next := NO_CONNECTION ;
        var i : int ; i := 0 ; while i < result->size() do ( (     if (result[i+1][0+1] = NO_CONNECTION & result[i+1][1+1] /= NO_CONNECTION) then (     next := i ) else skip )  ;     i := i + 1 ) ; 
    while (next /= -1) do (     OclFile["System.out"].printf("%c", next + 'a') ; 
     next := result[next+1][REAR+1] ) ; 
    OclFile["System.out"].println() ; 
 ) else (     OclFile["System.out"].println(train[0+1]) ) )  ;     t := t + 1 ) );
  static    attribute FRONT : int := 0;
  static    attribute REAR : int := 1;
  static    attribute NO_CONNECTION : int := -1;
  static   operation createTrainGraph( input : Sequence(String)) : Sequence(Sequence(int))
  pre: true
  post: true
  activity: (     var train : Sequence(Sequence(int)) ; train := Integer.subrange(1,26)->collect(Integer.subrange(1,2)->collect(0)) ;
         var i : int ; i := 0 ; while i < train->size() do ( (         var j : int ; j := 0 ; while j < train[0+1]->size() do ( (     train[i+1][j+1] := NO_CONNECTION )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var front : boolean ; front := false ;
    var before : int ; before := input[0+1] ;
        var i : int ; i := 1 ; while i < input->size() do ( (     var current : int ; current := input[i+1] ;
     if ('a' <= current & current <= 'z') then (     if (front) then (     train[before - ('a')->char2byte()+1][FRONT+1] := current - ('a')->char2byte() ; 
     train[current - ('a')->char2byte()+1][REAR+1] := before - ('a')->char2byte() ) else (     train[before - ('a')->char2byte()+1][REAR+1] := current - ('a')->char2byte() ; 
     train[current - ('a')->char2byte()+1][FRONT+1] := before - ('a')->char2byte() ) ;  
     before := current ) else     if (current = '>') then (     front := false ) else     if (current = '<') then (     front := true ) else skip ; ;  )  ;     i := i + 1 ) ; 
    return train 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    int cnt=parseCnt();
    while(cnt-->0){
      solve(parseStdin());
    }
  }
  private static void solve(String stdin){
    Train ct=null ;
    Train pt=new Train();
    Train ht=pt ;
    Train tt=pt ;
    int ti=0 ;
    String ot="" ;
    pt.tc=stdin.charAt(ti);
    while((ti=stdin.indexOf('-',ti))!=-1){
      ct=new Train();
      if(stdin.charAt(ti+1)=='>'){
        ct.tc=stdin.charAt(ti+2);
        if(tt.tc==pt.tc){
          tt.nt=ct ;
          tt=ct ;
        }
        ti+=3 ;
      }
      else {
        ct.tc=stdin.charAt(ti+1);
        if(ht.tc==pt.tc){
          ct.nt=ht ;
          ht=ct ;
        }
        ti+=2 ;
      }
      pt=ct ;
    }
    while(ht!=null){
      ot+=ht.tc ;
      ht=ht.nt ;
    }
    System.out.println(ot);
  }
  private static int parseCnt(){
    int cnt=0 ;
    String str=null ;
    if((str=parseStdin())!=null){
      cnt=Integer.parseInt(str);
    }
    return cnt ;
  }
  private static String parseStdin(){
    String stdin=null ;
    try {
      String tmp=br.readLine();
      if(tmp!=null){
        if(! tmp.isEmpty())stdin=tmp ;
      }
    }
    catch(IOException e){
    }
    return stdin ;
  }
}
class Train {
  char tc=0 ;
  Train nt=null ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := parseCnt() ;
         while (cnt > 0) do (        cnt := cnt - 1 ;     skip ; (     execute solve(parseStdin()) ) ;  ) );
  static   operation solve( stdin : String) : void
  pre: true
  post: true
  activity: (     var ct : Train ; ct := null ;
     var pt : Train ; pt := Train.newTrain() ;
    var ht : Train ; ht := pt ;
    var tt : Train ; tt := pt ;
    var ti : int ; ti := 0 ;
    var ot : String ; ot := "" ;
    pt.tc := stdin->at(ti+1) ; 
        ti := stdin.subrange(ti+1)->indexOf('-'+"") + ti - 1  ;
    while ((ti) /= -1) do (    skip ; (     ct := Train.newTrain() ; 
     if (stdin->at(ti + 1+1) = '>') then (     ct.tc := stdin->at(ti + 2+1) ; 
     if (tt.tc = pt.tc) then (     tt.nt := ct ; 
     tt := ct ) else skip ; 
     ti := ti+(3) ) else (     ct.tc := stdin->at(ti + 1+1) ; 
     if (ht.tc = pt.tc) then (     ct.nt := ht ; 
     ht := ct ) else skip ; 
     ti := ti+(2) ) ;  
     pt := ct ) ;     ti := stdin.subrange(ti+1)->indexOf('-'+"") + ti - 1  ;
 ) ;  
    while (ht /= null) do (     ot := ot+(ht.tc) ; 
     ht := ht.nt ) ; 
    OclFile["System.out"].println(ot) ; 
 );
  static   operation parseCnt() : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var str : String ; str := null ;
     if ((str) /= null) then (     cnt := (str)->toInteger() ) else skip ; 
     return cnt );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var stdin : String ; stdin := null ;
     try (     var tmp : String ; tmp := br.readLine() ;
     if (tmp /= null) then (     if (not(tmp->isEmpty())) then     stdin := tmp ; else skip ) else skip )   catch (e : IOException) do skip
     return stdin );
}
class Train {
   attribute tc : String := 0;
   attribute nt : Train := null;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String N=sc.nextLine();
    String Array[]=N.split("");
    int total1=0,total2=0 ;
    if(1==Array.length){
      System.out.println(0);
      System.exit(0);
    }
    for(int i=0 ; i<Array.length ; i++){
      if(i % 2==0){
        if(Array[i] .equals("1")){
          total1++;
        }
      }
      else {
        if(Array[i] .equals("0")){
          total1++;
        }
      }
    }
    for(int i=0 ; i<Array.length ; i++){
      if(i % 2==0){
        if(Array[i] .equals("0")){
          total2++;
        }
      }
      else {
        if(Array[i] .equals("1")){
          total2++;
        }
      }
    }
    if(total1<total2){
      System.out.println(total1);
    }
    else {
      System.out.println(total2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : String ; N := sc.nextLine() ;
    var Array : Sequence(String) ; Array := N->split("") ;
    var total1 : int ; total1 := 0 ;
    var total2 : int ; total2 := 0 ;
    if (1 = Array->size()) then (     OclFile["System.out"].println(0) ; 
 OclProcess.exit(0) ) else skip ; 
        var i : int ; i := 0 ; while i < Array->size() do ( (     if (i mod 2 = 0) then (     if (Array[i+1] = "1") then (     total1 := total1 + 1 ) else skip ) else (     if (Array[i+1] = "0") then (     total1 := total1 + 1 ) else skip ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Array->size() do ( (     if (i mod 2 = 0) then (     if (Array[i+1] = "0") then (     total2 := total2 + 1 ) else skip ) else (     if (Array[i+1] = "1") then (     total2 := total2 + 1 ) else skip ) )  ;     i := i + 1 ) ; 
    if (total1 < total2) then (     OclFile["System.out"].println(total1) ) else (     OclFile["System.out"].println(total2) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  public static void countFreq(int arr[],int n){
    boolean visited[]=new boolean[n];
    Arrays.fill(visited,false);
    for(int i=0 ; i<n ; i++){
      if(visited[i]==true)continue ;
      int count=1 ;
      for(int j=i+1 ; j<n ; j++){
        if(arr[i]==arr[j]){
          visited[j]=true ;
          count++;
        }
      }
      System.out.println(arr[i]+" "+count);
    }
  }
  public static void main(String[] args){
    int arr[]=new int[] {
      10,20,20,10,10,20,5,20 };
      int n=arr.length ;
      countFreq(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countFreq( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var visited : Sequence(boolean) ; visited := Integer.subrange(1,n)->collect(false) ;
     visited := visited->collect(false) ; 
         var i : int ; i := 0 ; while i < n do ( (     if (visited[i+1] = true) then     continue else skip ; 
     var count : int ; count := 1 ;
         var j : int ; j := i + 1 ; while j < n do ( (     if (arr[i+1] = arr[j+1]) then (     visited[j+1] := true ; 
     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(arr[i+1] + " " + count) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,20,20,10,10,20,5,20} ;
     var n : int ; n := arr->size() ;
     execute countFreq(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int count=0 ;
    for(int i=a ; i<=b ; i++){
      if(c % i==0){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var i : int ; i := a ; while i <= b do ( (     if (c mod i = 0) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    int a,b,c,sum=0 ;
    String[] str=new BufferedReader(new InputStreamReader(System.in)).readLine().split(" ");
    a=Integer.parseInt(str[0]);
    b=Integer.parseInt(str[1]);
    c=Integer.parseInt(str[2]);
    for(int i=a ; i<=b ; i++)sum+=c % i==0 ? 1 : 0 ;
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ;
    var b : int ;
    var c : int ;
    var sum : int ; sum := 0 ;
     var str : Sequence(String) ; str := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])).readLine()->split(" ") ;
    a := (str[0+1])->toInteger() ; 
    b := (str[1+1])->toInteger() ; 
    c := (str[2+1])->toInteger() ; 
        var i : int ; i := a ; while i <= b do (     sum := sum+(if c mod i = 0 then 1 else 0 endif) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public void exec()throws IOException {
    Scanner input=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int a=input.nextInt();
    int b=input.nextInt();
    int c=input.nextInt();
    int cSqrt=(int)Math.sqrt(c);
    int divcnt=0 ;
    int div=0 ;
    for(int i=1 ; i<=cSqrt && i<=b ; i++){
      if(c % i==0){
        if(a<=i && i<=b)divcnt++;
        div=c/i ;
        if(i!=div && a<=div && div<=b)divcnt++;
      }
    }
    out.println(divcnt);
    out.flush();
    input.close();
  }
  public static void main(String[] args)throws IOException {
    new Main().exec();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation exec() : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : int ; a := input.getCurrent()->toInteger() ;
    var b : int ; b := input.getCurrent()->toInteger() ;
    var c : int ; c := input.getCurrent()->toInteger() ;
    var cSqrt : int ; cSqrt := (c)->sqrt()->oclAsType(int) ;
    var divcnt : int ; divcnt := 0 ;
    var div : int ; div := 0 ;
        var i : int ; i := 1 ; while i <= cSqrt & i <= b do ( (     if (c mod i = 0) then (     if (a <= i & i <= b) then     divcnt := divcnt + 1 ; else skip ; 
     div := c / i ; 
     if (i /= div & a <= div & div <= b) then     divcnt := divcnt + 1 ; else skip ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().exec() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int a,b,c ;
    int count=0 ;
    a=scan.nextInt();
    b=scan.nextInt();
    c=scan.nextInt();
    if(a>b){
      throw new RuntimeException("error:You must write a<=b");
    }
    if(a<1 || 10000<a || b<1 || 10000<b || c<1 || 10000<c){
      throw new RuntimeException("error:You must write 1<=a,b,c<=10000");
    }
    for(int i=a ; i<=b ; i+=1){
      if(c % i==0){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ;
    var b : int ;
    var c : int ;
    var count : int ; count := 0 ;
    a := scan.getCurrent()->toInteger() ; 
    b := scan.getCurrent()->toInteger() ; 
    c := scan.getCurrent()->toInteger() ; 
    if (a > b) then (     error ProgramException("error:You must write a<=b") ) else skip ; 
    if (a < 1 or 10000 < a or b < 1 or 10000 < b or c < 1 or 10000 < c) then (     error ProgramException("error:You must write 1<=a,b,c<=10000") ) else skip ; 
        var i : int ; i := a ; while i <= b do ( (     if (c mod i = 0) then (     count := count + 1 ) else skip )  ;     i := i+(1) ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    try {
      String ab ;
      String[] strAry ;
      int a ;
      int b ;
      int c ;
      int yaku ;
      int count=0 ;
      ab=input.readLine();
      strAry=ab.split(" ");
      a=Integer.parseInt(strAry[0]);
      b=Integer.parseInt(strAry[1]);
      c=Integer.parseInt(strAry[2]);
      for(int i=a ; i<=b ; i++){
        yaku=c % i ;
        if(yaku==0){
          count++;
        }
      }
      System.out.println(count);
    }
    catch(IOException e){
      System.out.println("Exception : "+e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var ab : String ;
     var strAry : Sequence(String) ;
    var a : int ;
    var b : int ;
    var c : int ;
    var yaku : int ;
    var count : int ; count := 0 ;
    ab := input.readLine() ; 
    strAry := ab->split(" ") ; 
    a := (strAry[0+1])->toInteger() ; 
    b := (strAry[1+1])->toInteger() ; 
    c := (strAry[2+1])->toInteger() ; 
        var i : int ; i := a ; while i <= b do ( (     yaku := c mod i ; 
     if (yaku = 0) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )   catch (e : IOException) do (     OclFile["System.out"].println("Exception : " + e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int N=in.nextInt();
    Integer[] A=new Integer[N];
    for(int n=0 ; n<N ; n++){
      A[n]=in.nextInt();
    }
    Arrays.sort(A);
    int idx=0 ;
    for(int n=1 ; n<N ; n++){
      if(A[idx]<A[n]){
        idx++;
      }
    }
    pw.println(idx);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(null) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    A := A->sort() ; 
    var idx : int ; idx := 0 ;
        var n : int ; n := 1 ; while n < N do ( (     if (A[idx+1] < A[n+1]) then (     idx := idx + 1 ) else skip )  ;     n := n + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class first {
  public static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int n=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    Arrays.sort(arr);
    ;
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]>arr[count])count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class first {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] > arr[count+1]) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static int n ;
  static int a[];
  static int solve(){
    List<Integer>l=new ArrayList<>();
    List<Integer>l1=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      l.add(a[i]);
      l1.add(a[i]);
    }
    Collections.sort(l,Collections.reverseOrder());
    Collections.sort(l1,Collections.reverseOrder());
    int ptr=0,ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(l.get(i)>=l1.get(ptr))continue ;
      else {
        ans++;
        ptr++;
      }
    }
    return ans ;
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    String s[]=bf.readLine().trim().split("\\s+");
    n=Integer.parseInt(s[0]);
    a=new int[n];
    s=bf.readLine().trim().split("\\s+");
    for(int i=0 ; i<n ; i++)a[i]=Integer.parseInt(s[i]);
    str.append(solve()).append("\n");
    pw.print(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute n : int;
  static   attribute a : Sequence(int);
  static   operation solve() : int
  pre: true
  post: true
  activity: (     var l : Sequence(int) ; l := Sequence{} ;
     var l1 : Sequence(int) ; l1 := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     l := l->including(a[i+1]) ; 
     l1 := l1->including(a[i+1]) )  ;     i := i + 1 ) ; 
    l, reverseOrder() := l, reverseOrder()->sort() ; 
    l1, reverseOrder() := l1, reverseOrder()->sort() ; 
    var ptr : int ; ptr := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (l->at(i+1) >= l1->at(ptr+1)) then     continue else (     ans := ans + 1 ; 
     ptr := ptr + 1 ) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var s : Sequence(String) ; s := bf.readLine()->trim()->split("\\s+") ;
    n := (s[0+1])->toInteger() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
    s := bf.readLine()->trim()->split("\\s+") ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (s[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    str := str + StringLib.newString(solve()) + StringLib.newString("\n") ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.TreeMap ;
public class CF1007A {
  public static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    TreeMap<Integer,Integer>map=new TreeMap<>();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      int e=Integer.parseInt(scanner.next());
      map.put(e,map.getOrDefault(e,0)+1);
      arr[i]=e ;
    }
    long res=0 ;
    for(int i=0 ; i<arr.length ; i++){
      int e=arr[i];
      Integer element=map.higherKey(e);
      if(element!=null){
        map.put(element,map.get(element)-1);
        if(map.get(element)==0)map.remove(element);
        res++;
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF1007A {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var map : Map(int,int) ; map := Map{} ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var e : int ; e := (scanner.getCurrent())->toInteger() ;
     map := map->union(Map{e |-> (if map->keys()->contains(e) then map->at(e) else 0 endif) + 1}) ; 
     arr[i+1] := e )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     var e : int ; e := arr[i+1] ;
     var element : int ; element := map.higherKey(e) ;
     if (element /= null) then (     map := map->union(Map{element |-> map->at(element) - 1}) ; 
     if (map->at(element) = 0) then     map := map->antirestrict(Set{element}) ; else skip ; 
     res := res + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countOccurrences(int x,int d){
    int count=0 ;
    while(x>0){
      if(x % 10==d)count++;
      x=x/10 ;
    }
    return count ;
  }
  static int maxOccurring(int x){
    if(x<0)x=-x ;
    int result=0 ;
    int max_count=1 ;
    for(int d=0 ; d<=9 ; d++){
      int count=countOccurrences(x,d);
      if(count>=max_count){
        max_count=count ;
        result=d ;
      }
    }
    return result ;
  }
  public static void main(String[] args){
    int x=1223355 ;
    System.out.println("Max occurring digit is "+maxOccurring(x));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countOccurrences( x : int, d : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (x > 0) do (     if (x mod 10 = d) then     count := count + 1 ; else skip ; 
     x := x / 10 ) ; 
     return count );
  static   operation maxOccurring( x : int) : int
  pre: true
  post: true
  activity: (     if (x < 0) then     x := -x ; else skip ; 
     var result : int ; result := 0 ;
    var max_count : int ; max_count := 1 ;
        var d : int ; d := 0 ; while d <= 9 do ( (     var count : int ; count := countOccurrences(x, d) ;
     if (count >= max_count) then (     max_count := count ; 
     result := d ) else skip )  ;     d := d + 1 ) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 1223355 ;
     OclFile["System.out"].println("Max occurring digit is " + maxOccurring(x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
public class Main {
  static int d[];
  static List<edge>edges ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] v_e_r=br.readLine().split(" ");
    int v=Integer.parseInt(v_e_r[0]);
    int e=Integer.parseInt(v_e_r[1]);
    int r=Integer.parseInt(v_e_r[2]);
    d=new int[v];
    edges=new ArrayList<>();
    for(int i=0 ; i<e ; i++){
      String[] from_to_cost_edge=br.readLine().split(" ");
      edges.add(new edge(Integer.parseInt(from_to_cost_edge[0]),Integer.parseInt(from_to_cost_edge[1]),Integer.parseInt(from_to_cost_edge[2])));
    }
    bellford(r);
    for(int i=0 ; i<d.length ; i++){
      if(d[i]==Integer.MAX_VALUE/2){
        System.out.println("INF");
      }
      else {
        System.out.println(d[i]);
      }
    }
  }
  static void bellford(int now){
    Arrays.fill(d,Integer.MAX_VALUE/2);
    d[now]=0 ;
    while(true){
      boolean judge=false ;
      for(edge e : edges){
        if(d[e.to]>d[e.from]+e.cost){
          d[e.to]=d[e.from]+e.cost ;
          judge=true ;
        }
      }
      if(! judge){
        break ;
      }
    }
  }
  static class edge {
    int from ;
    int to ;
    int cost ;
    public edge(int a,int b,int c){
      this.from=a ;
      this.to=b ;
      this.cost=c ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute d : Sequence(int);
  static   attribute edges : Sequence(edge);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var v_e_r : Sequence(String) ; v_e_r := br.readLine()->split(" ") ;
    var v : int ; v := (v_e_r[0+1])->toInteger() ;
    var e : int ; e := (v_e_r[1+1])->toInteger() ;
    var r : int ; r := (v_e_r[2+1])->toInteger() ;
    d := Integer.subrange(1,v)->collect(0) ; 
    edges := Sequence{} ; 
        var i : int ; i := 0 ; while i < e do ( (     var from_to_cost_edge : Sequence(String) ; from_to_cost_edge := br.readLine()->split(" ") ;
     edges := edges->including(edge.newedge((from_to_cost_edge[0+1])->toInteger(), (from_to_cost_edge[1+1])->toInteger(), (from_to_cost_edge[2+1])->toInteger())) )  ;     i := i + 1 ) ; 
    execute bellford(r) ; 
        var i : int ; i := 0 ; while i < d->size() do ( (     if (d[i+1] = 2147483647 / 2) then (     OclFile["System.out"].println("INF") ) else (     OclFile["System.out"].println(d[i+1]) ) )  ;     i := i + 1 ) ; 
 );
  static   operation bellford( now : int) : void
  pre: true
  post: true
  activity: (     d := d->collect(2147483647 / 2) ; 
     d[now+1] := 0 ; 
     while (true) do (     var judge : boolean ; judge := false ;
     for (e : edges) do ( (     if (d[e.to+1] > d[e.from+1] + e.cost) then (     d[e.to+1] := d[e.from+1] + e.cost ; 
     judge := true ) else skip )  ) ; 
     if (not(judge)) then (     break ) else skip ) );
  static class edge {
   attribute from : int;
   attribute to : int;
   attribute cost : int;
   static operation newedge( a : int, b : int, c : int) : edge
  pre: true
  post: true
  activity:
  ( var self : edge ;
    self := createedge();
    self.initialise(a, b,c);
    return self );
  operation initialise( a : int, b : int, c : int) : void
  pre: true  post: true
  activity: (     self.from := a ; 
     self.to := b ; 
     self.cost := c );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Arrays ;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long n=sc.nextLong();
      long k=sc.nextLong();
      long b=sc.nextLong();
      long s=sc.nextLong();
      long min=b*k ;
      long max=(n-1)*(k-1)+b*k+(k-1);
      if(s<min || s>max){
        System.out.println(-1);
      }
      else {
        long temp=b*k+(k-1);
        if(temp>s)System.out.print(s+" ");
        else System.out.print(temp+" ");
        s-=temp ;
        for(int i=0 ; i<n-1 ; i++){
          if(s<=0)System.out.print(0+" ");
          else if(s<(k-1)&& s>0)System.out.print(s+" ");
          else System.out.print((k-1)+" ");
          s-=(k-1);
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := sc.getCurrent()->toLong() ;
     var k : long ; k := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var s : long ; s := sc.getCurrent()->toLong() ;
    var min : long ; min := b * k ;
    var max : long ; max := (n - 1) * (k - 1) + b * k + (k - 1) ;
    if (s < min or s > max) then (     OclFile["System.out"].println(-1) ) else (     var temp : long ; temp := b * k + (k - 1) ;
     if (temp > s) then     OclFile["System.out"].print(s + " ") else     OclFile["System.out"].print(temp + " ") ; ;  
    s := s-(temp) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (s <= 0) then     OclFile["System.out"].print(0 + " ") else     if (s < (k - 1) & s > 0) then     OclFile["System.out"].print(s + " ") else     OclFile["System.out"].print((k - 1) + " ") ; ;  ;  
     s := s-((k - 1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int source=sc.nextInt();
    Map<Integer,Integer>cost=new HashMap<Integer,Integer>();
    cost.put(source,0);
    PriorityQueue<int[]>pq=new PriorityQueue<int[]>(new Comparator<int[]>(){
      public int compare(int[] v1,int[] v2){
        return Integer.compare(v1[1],v2[1]);
      }
    }
);
    ArrayList<ArrayList<int[]>>adj=new ArrayList<ArrayList<int[]>>();
    for(int i=0 ; i<n ; ++i)adj.add(new ArrayList<int[]>());
    for(int i=0 ; i<m ; ++i){
      int src=sc.nextInt();
      int dst=sc.nextInt();
      int edgeCost=sc.nextInt();
      adj.get(src).add(new int[] {
        dst,edgeCost }
);
      }
      for(int[] e : adj.get(source)){
        pq.add(new int[] {
          e[0],e[1] }
);
        }
        while(! pq.isEmpty()&& cost.size()<n){
          int[] v=pq.remove();
          if(! cost.containsKey(v[0])){
            cost.put(v[0],v[1]);
            for(int[] e : adj.get(v[0])){
              pq.add(new int[] {
                e[0],v[1]+e[1] }
);
              }
            }
          }
          for(int i=0 ; i<n ; ++i){
            if(cost.containsKey(i)){
              System.out.println(cost.get(i));
            }
            else {
              System.out.println("INF");
            }
          }
        }
      }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var source : int ; source := sc.getCurrent()->toInteger() ;
    var cost : Map(int,int) ; cost := Map{} ;
    cost := cost->union(Map{source |-> 0}) ; 
    var pq : Sequence(Sequence(int)) ; pq := Sequence{}->union(OclComparator<Sequence(int)>.newOclComparator()) ;
    var adj : Sequence(Sequence(Sequence(int))) ; adj := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     adj := adj->including(Sequence{}) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var src : int ; src := sc.getCurrent()->toInteger() ;
     var dst : int ; dst := sc.getCurrent()->toInteger() ;
     var edgeCost : int ; edgeCost := sc.getCurrent()->toInteger() ;
     adj->at(src+1)->excludes(Sequence{dst,edgeCost}) )  ;     i := i + 1 ) ; 
    for (e : adj->at(source+1)) do ( (     pq := pq->including(Sequence{e[0+1],e[1+1]}) )  ) ; 
    while (not(pq->isEmpty()) & cost.size() < n) do (     var v : Sequence(int) ; v := pq.remove() ;
     if (not(cost->keys()->includes(v[0+1]))) then (     cost := cost->union(Map{v[0+1] |-> v[1+1]}) ; 
     for (e : adj->at(v[0+1]+1)) do ( (     pq := pq->including(Sequence{e[0+1],v[1+1] + e[1+1]}) )  ) ) else skip ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (cost->keys()->includes(i)) then (     OclFile["System.out"].println(cost->at(i)) ) else (     OclFile["System.out"].println("INF") ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static final int INF=Integer.MAX_VALUE ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int vn=sc.nextInt();
    int ve=sc.nextInt();
    int s=sc.nextInt();
    List<List<Edge>>edges=new ArrayList<>();
    for(int i=0 ; i<vn ; i++){
      edges.add(new ArrayList<>());
    }
    for(int i=0 ; i<ve ; i++){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int f=sc.nextInt();
      edges.get(a).add(new Edge(a,b,f));
    }
    int[] distance=new int[vn];
    Arrays.fill(distance,INF);
    distance[s]=0 ;
    Queue<Edge>queue=new PriorityQueue<>();
    queue.add(new Edge(s,s,0));
    while(! queue.isEmpty()){
      Edge e1=queue.poll();
      if(distance[e1.target]<e1.cost){
        continue ;
      }
      for(Edge e2 : edges.get(e1.target)){
        if(distance[e2.target]>distance[e1.target]+e2.cost){
          distance[e2.target]=distance[e1.target]+e2.cost ;
          queue.add(new Edge(e1.target,e2.target,distance[e2.target]));
        }
      }
    }
    for(int i=0 ; i<vn ; i++){
      System.out.println(distance[i]==INF ? "INF" : distance[i]);
    }
  }
  static class Edge implements Comparable<Edge>{
    public int source ;
    public int target ;
    public int cost ;
    public Edge(int source,int target,int cost){
      this.source=source ;
      this.target=target ;
      this.cost=cost ;
    }
    @ Override public int compareTo(Edge o){
      return this.cost-o.cost ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : int := 2147483647;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var vn : int ; vn := sc.getCurrent()->toInteger() ;
    var ve : int ; ve := sc.getCurrent()->toInteger() ;
    var s : int ; s := sc.getCurrent()->toInteger() ;
    var edges : Sequence(Sequence(Edge)) ; edges := Sequence{} ;
        var i : int ; i := 0 ; while i < vn do ( (     edges := edges->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < ve do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     var f : int ; f := sc.getCurrent()->toInteger() ;
     edges->at(a+1)->excludes(Edge.newEdge(a, b, f)) )  ;     i := i + 1 ) ; 
    var distance : Sequence(int) ; distance := Integer.subrange(1,vn)->collect(0) ;
    distance := distance->collect(INF) ; 
    distance[s+1] := 0 ; 
    var queue : Sequence(Edge) ; queue := Sequence{} ;
    queue := queue->including(Edge.newEdge(s, s, 0)) ; 
    while (not(queue->isEmpty())) do (     var e1 : Edge ; e1 := queue->min() ;
     if (distance[e1.target+1] < e1.cost) then (     continue ) else skip ; 
     for (e2 : edges->at(e1.target+1)) do ( (     if (distance[e2.target+1] > distance[e1.target+1] + e2.cost) then (     distance[e2.target+1] := distance[e1.target+1] + e2.cost ; 
     queue := queue->including(Edge.newEdge(e1.target, e2.target, distance[e2.target+1])) ) else skip )  ) ) ; 
        var i : int ; i := 0 ; while i < vn do ( (     OclFile["System.out"].println(if distance[i+1] = INF then "INF" else distance[i+1] endif) )  ;     i := i + 1 ) ; 
 );
  static class Edge implements Comparable<Edge> {
   attribute source : int;
   attribute target : int;
   attribute cost : int;
   static operation newEdge( source : int, target : int, cost : int) : Edge
  pre: true
  post: true
  activity:
  ( var self : Edge ;
    self := createEdge();
    self.initialise(source, target,cost);
    return self );
  operation initialise( source : int, target : int, cost : int) : void
  pre: true  post: true
  activity: (     self.source := source ; 
     self.target := target ; 
     self.cost := cost );
      operation compareTo( o : Edge) : int
  pre: true
  post: true
  activity: (     return self.cost - o.cost );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPossible(int arr[],int p,int n,int m){
    int sum=0 ;
    for(int i=0 ; i<p ; i++)sum+=arr[i];
    if(sum==(n*m))return true ;
    return false ;
  }
  public static void main(String[] args){
    int n=3,m=4 ;
    int arr[]={
      6,3,2,1 };
      int p=arr.length ;
      if(isPossible(arr,p,n,m))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPossible( arr : Sequence(int), p : int, n : int, m : int) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < p do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
     if (sum = (n * m)) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
    var m : int ; m := 4 ;
     var arr : Sequence(int) ; arr := Sequence{6,3,2,1} ;
     var p : int ; p := arr->size() ;
     if (isPossible(arr, p, n, m)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test {
  static int arr[]={
    10,324,45,90,9808 };
    static int largest(){
      int i ;
      int max=arr[0];
      for(i=1 ; i<arr.length ; i++)if(arr[i]>max)max=arr[i];
      return max ;
    }
    public static void main(String[] args){
      System.out.println("Largest in given array is "+largest());
    }
  }

------------------------------------------------------------
OCL File:
---------
class Test {
  static   attribute arr : int := Sequence{10,324,45,90,9808};
  static   operation largest() : int
  pre: true
  post: true
  activity: (     var i : int ;
     var max : int ; max := arr[0+1] ;
         i := 1 ; while i < arr->size() do (     if (arr[i+1] > max) then     max := arr[i+1] ; else skip ;  ;     i := i + 1 ) ; 
     return max );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Largest in given array is " + largest()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int M=3 ;
  static final int N=3 ;
  static void rotateMatrix(int matrix[][],int k){
    int temp[]=new int[M];
    k=k % M ;
    for(int i=0 ; i<N ; i++){
      for(int t=0 ; t<M-k ; t++)temp[t]=matrix[i][t];
      for(int j=M-k ; j<M ; j++)matrix[i][j-M+k]=matrix[i][j];
      for(int j=k ; j<M ; j++)matrix[i][j]=temp[j-k];
    }
  }
  static void displayMatrix(int matrix[][]){
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<M ; j++)System.out.print(matrix[i][j]+" ");
      System.out.println();
    }
  }
  public static void main(String[] args){
    int matrix[][]={
      {
        12,23,34 },{
          45,56,67 },{
            78,89,91 }
          };
          int k=2 ;
          rotateMatrix(matrix,k);
          displayMatrix(matrix);
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute M : int := 3;
  static    attribute N : int := 3;
  static   operation rotateMatrix( matrix : Sequence(Sequence(int)), k : int) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(int) ; temp := Integer.subrange(1,M)->collect(0) ;
     k := k mod M ; 
         var i : int ; i := 0 ; while i < N do ( (         var t : int ; t := 0 ; while t < M - k do (     temp[t+1] := matrix[i+1][t+1] ;  ;     t := t + 1 ) ; 
         var j : int ; j := M - k ; while j < M do (     matrix[i+1][j - M + k+1] := matrix[i+1][j+1] ;  ;     j := j + 1 ) ; 
         var j : int ; j := k ; while j < M do (     matrix[i+1][j+1] := temp[j - k+1] ;  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation displayMatrix( matrix : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < M do (     OclFile["System.out"].print(matrix[i+1][j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var matrix : Sequence(Sequence(int)) ; matrix := Sequence{Sequence{12,23,34},Sequence{45,56,67},Sequence{78,89,91}} ;
     var k : int ; k := 2 ;
     execute rotateMatrix(matrix, k) ; 
     execute displayMatrix(matrix) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      long[] masks=new long[sc.nextInt()];
      for(int i=0 ; i<masks.length ; i++){
        int maskLength=sc.nextInt();
        for(int j=0 ; j<maskLength ; j++){
          masks[i]+=1L<<sc.nextInt();
        }
      }
      int q=sc.nextInt();
      long flags=0 ;
      for(int k=0 ; k<q ; k++){
        switch(sc.nextInt()){
          case 0 : System.out.println((flags>>sc.nextInt())& 1L);
          break ;
          case 1 : flags=flags | masks[sc.nextInt()];
          break ;
          case 2 : flags=flags & ~ masks[sc.nextInt()];
          break ;
          case 3 : flags=flags ^ masks[sc.nextInt()];
          break ;
          case 4 : System.out.println((flags | masks[sc.nextInt()])==flags ? 1 : 0);
          break ;
          case 5 : System.out.println((flags & ~ masks[sc.nextInt()])!=flags ? 1 : 0);
          break ;
          case 6 : System.out.println((flags & ~ masks[sc.nextInt()])==flags ? 1 : 0);
          break ;
          case 7 : {
            int cnt=0 ;
            int i=sc.nextInt();
            for(int j=0 ; j<64 ; j++){
              if(((masks[i]>>j)& 1L)>0 &&((flags>>j)& 1L)>0)cnt++;
            }
            System.out.println(cnt);
            break ;
          }
          case 8 : System.out.println(Long.toUnsignedString(flags & masks[sc.nextInt()]));
          break ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var masks : Sequence(long) ; masks := Integer.subrange(1,sc.getCurrent()->toInteger())->collect(0) ;
         var i : int ; i := 0 ; while i < masks->size() do ( (     var maskLength : int ; maskLength := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < maskLength do ( (     masks[i+1] := masks[i+1]+((1L*(2->pow(sc.getCurrent()->toInteger())))->oclAsType(long)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var flags : long ; flags := 0 ;
        var k : int ; k := 0 ; while k < q do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (sc.getCurrent()->toInteger()) ; 
       if _switchval = 0 then
     OclFile["System.out"].println(((flags/(2->pow(sc.getCurrent()->toInteger())))->oclAsType(long)) & 1L) ; 
    break 
   else skip ;
       if _switchval = 1 then
     flags := MathLib.bitwiseOr(flags,masks[sc.getCurrent()->toInteger()+1]) ; 
    break 
   else skip ;
       if _switchval = 2 then
     flags := MathLib.bitwiseAnd(flags,-(masks[sc.getCurrent()->toInteger()+1] + 1)) ; 
    break 
   else skip ;
       if _switchval = 3 then
     flags := MathLib.bitwiseXor(flags,masks[sc.getCurrent()->toInteger()+1]) ; 
    break 
   else skip ;
       if _switchval = 4 then
     OclFile["System.out"].println(if (MathLib.bitwiseOr(flags,masks[sc.getCurrent()->toInteger()+1])) = flags then 1 else 0 endif) ; 
    break 
   else skip ;
       if _switchval = 5 then
     OclFile["System.out"].println(if (MathLib.bitwiseAnd(flags,-(masks[sc.getCurrent()->toInteger()+1] + 1))) /= flags then 1 else 0 endif) ; 
    break 
   else skip ;
       if _switchval = 6 then
     OclFile["System.out"].println(if (MathLib.bitwiseAnd(flags,-(masks[sc.getCurrent()->toInteger()+1] + 1))) = flags then 1 else 0 endif) ; 
    break 
   else skip ;
       if _switchval = 7 then
 (     var cnt : int ; cnt := 0 ;
     var i : int ; i := sc.getCurrent()->toInteger() ;
        var j : int ; j := 0 ; while j < 64 do ( (     if ((((masks[i+1]/(2->pow(j)))->oclAsType(long)) & 1L) > 0 & (((flags/(2->pow(j)))->oclAsType(long)) & 1L) > 0) then     cnt := cnt + 1 ; else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
    break 
 ) 
   else skip ;
       if _switchval = 8 then
     OclFile["System.out"].println(toUnsignedString(MathLib.bitwiseAnd(flags,masks[sc.getCurrent()->toInteger()+1]))) ; 
    break 
   else skip ;
 )
 )  ;     k := k + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Node {
    int data ;
    Node next ;
  };
  static int getIntesectionNode(Node head1,Node head2){
    Node current1=head1 ;
    Node current2=head2 ;
    if(current1==null || current2==null)return-1 ;
    while(current1!=null && current2!=null && current1!=current2){
      current1=current1.next ;
      current2=current2.next ;
      if(current1==current2)return current1.data ;
      if(current1==null)current1=head2 ;
      if(current2==null)current2=head1 ;
    }
    return current1.data ;
  }
  public static void main(String[] args){
    Node newNode ;
    Node head1=new Node();
    head1.data=10 ;
    Node head2=new Node();
    head2.data=3 ;
    newNode=new Node();
    newNode.data=6 ;
    head2.next=newNode ;
    newNode=new Node();
    newNode.data=9 ;
    head2.next.next=newNode ;
    newNode=new Node();
    newNode.data=15 ;
    head1.next=newNode ;
    head2.next.next.next=newNode ;
    newNode=new Node();
    newNode.data=30 ;
    head1.next.next=newNode ;
    head1.next.next.next=null ;
    System.out.print(getIntesectionNode(head1,head2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   operation getIntesectionNode( head1 : Node, head2 : Node) : int
  pre: true
  post: true
  activity: (     var current1 : Node ; current1 := head1 ;
     var current2 : Node ; current2 := head2 ;
    if (current1 = null or current2 = null) then     return -1 else skip ; 
    while (current1 /= null & current2 /= null & current1 /= current2) do (     current1 := current1.next ; 
     current2 := current2.next ; 
    if (current1 = current2) then     return current1.data else skip ; 
    if (current1 = null) then     current1 := head2 ; else skip ; 
    if (current2 = null) then     current2 := head1 ; else skip ; 
 ) ; 
    return current1.data 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var newNode : Node ;
     var head1 : Node ; head1 := Node.newNode() ;
    head1.data := 10 ; 
    var head2 : Node ; head2 := Node.newNode() ;
    head2.data := 3 ; 
    newNode := Node.newNode() ; 
    newNode.data := 6 ; 
    head2.next := newNode ; 
    newNode := Node.newNode() ; 
    newNode.data := 9 ; 
    head2.next.next := newNode ; 
    newNode := Node.newNode() ; 
    newNode.data := 15 ; 
    head1.next := newNode ; 
    head2.next.next.next := newNode ; 
    newNode := Node.newNode() ; 
    newNode.data := 30 ; 
    head1.next.next := newNode ; 
    head1.next.next.next := null ; 
    OclFile["System.out"].print(getIntesectionNode(head1, head2)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static Vector<Long>gen(long n,Vector<Long>r){
    long a=r.get(r.size()-1);
    a++;
    for(int i=1 ; i<=n ; a+=2,i++){
      r.add(a);
    }
    return r ;
  }
  static Vector<Long>conell(long n){
    Vector<Long>res=new Vector<Long>();
    long k=1 ;
    res.add(0L);
    while(true){
      res=gen(k,res);
      k++;
      int j=res.size()-1 ;
      while(j!=n && j+k>n){
        k--;
      }
      if(j>=n){
        break ;
      }
    }
    res.remove(0);
    return res ;
  }
  public static void main(String[] args){
    long n=10 ;
    System.out.println("The first "+n+" terms are");
    Vector<Long>res=conell(n);
    for(int i=0 ; i<res.size(); i++){
      System.out.print(res.get(i)+" ");
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation gen( n : long, r : Sequence(long)) : Sequence(long)
  pre: true
  post: true
  activity: (     var a : long ; a := r->at(r->size() - 1+1) ;
     a := a + 1 ; 
         var i : int ; i := 1 ; while i <= n do ( (     r->excludes(a) )  ;     a := a+(2) ;     i := i + 1 ) ; 
     return r );
  static   operation conell( n : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var res : Sequence(long) ; res := Sequence{} ;
     var k : long ; k := 1 ;
    res := res->including(0L) ; 
    while (true) do (     res := gen(k, res) ; 
     k := k + 1 ; 
    var j : int ; j := res->size() - 1 ;
    while (j /= n & j + k > n) do (     k := k - 1 ) ; 
    if (j >= n) then (     break ) else skip ; 
 ) ; 
    res := res->excludingAt(0+1) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 10 ;
     OclFile["System.out"].println("The first " + n + " terms are") ; 
    var res : Sequence(long) ; res := conell(n) ;
        var i : int ; i := 0 ; while i < res->size() do ( (     OclFile["System.out"].print(res->at(i+1) + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  public static void printLogestIncSubArr(int arr[],int n){
    int max=1,len=1,maxIndex=0 ;
    for(int i=1 ; i<n ; i++){
      if(arr[i]>arr[i-1])len++;
      else {
        if(max<len){
          max=len ;
          maxIndex=i-max ;
        }
        len=1 ;
      }
    }
    if(max<len){
      max=len ;
      maxIndex=n-max ;
    }
    for(int i=maxIndex ; i<max+maxIndex ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String[] args){
    int arr[]={
      5,6,3,5,7,8,9,1,2 };
      int n=arr.length ;
      printLogestIncSubArr(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printLogestIncSubArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var max : int ; max := 1 ;
    var len : int ; len := 1 ;
    var maxIndex : int ; maxIndex := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] > arr[i - 1+1]) then     len := len + 1 ; else (     if (max < len) then (     max := len ; 
     maxIndex := i - max ) else skip ; 
     len := 1 ) )  ;     i := i + 1 ) ; 
     if (max < len) then (     max := len ; 
     maxIndex := n - max ) else skip ; 
         var i : int ; i := maxIndex ; while i < max + maxIndex do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,6,3,5,7,8,9,1,2} ;
     var n : int ; n := arr->size() ;
     execute printLogestIncSubArr(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    sc.nextLine();
    String A1=sc.nextLine();
    String A2=sc.nextLine();
    sc.close();
    int max=0 ;
    int[][] A=new int[2][N];
    for(int j=0 ; j<N ; j++){
      String[] s1=A1.split(" ");
      String[] s2=A2.split(" ");
      A[0][j]=Integer.valueOf(s1[j]);
      A[1][j]=Integer.valueOf(s2[j]);
    }
    for(int j=0 ; j<N ; j++){
      max=Math.max(max,candies(j,A));
    }
    System.out.println(max);
  }
  public static int candies(int down,int A[][]){
    int count=0 ;
    for(int i=0 ; i<=down ; i++){
      count+=A[0][i];
    }
    for(int i=down ; i<A[0] .length ; i++){
      count+=A[1][i];
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    skip ; 
    var A1 : String ; A1 := sc.nextLine() ;
    var A2 : String ; A2 := sc.nextLine() ;
    skip ; 
    var max : int ; max := 0 ;
    var A : Sequence(Sequence(int)) ; A := Integer.subrange(1,2)->collect(Integer.subrange(1,N)->collect(0)) ;
        var j : int ; j := 0 ; while j < N do ( (     var s1 : Sequence(String) ; s1 := A1->split(" ") ;
     var s2 : Sequence(String) ; s2 := A2->split(" ") ;
     A[0+1][j+1] := (s1[j+1])->toInteger() ; 
     A[1+1][j+1] := (s2[j+1])->toInteger() )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < N do ( (     max := Set{max, candies(j, A)}->max() )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static   operation candies( down : int, A : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i <= down do ( (     count := count+(A[0+1][i+1]) )  ;     i := i + 1 ) ; 
         var i : int ; i := down ; while i < A[0+1]->size() do ( (     count := count+(A[1+1][i+1]) )  ;     i := i + 1 ) ; 
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int N=Integer.parseInt(br.readLine());
    List<Integer>A1=new ArrayList<Integer>();
    List<Integer>A2=new ArrayList<Integer>();
    String[] inp=br.readLine().split(" ");
    String[] inp2=br.readLine().split(" ");
    int sum=0,sum1=0 ;
    for(int i=0 ; i<inp.length ; i++){
      sum+=Integer.parseInt(inp[i]);
      sum1+=Integer.parseInt(inp2[i]);
      A1.add(sum);
      A2.add(sum1);
    }
    int maxCandy=A1.get(0)+A2.get(N-1);
    for(int i=1 ; i<N ; i++){
      int now=A1.get(i)+(A2.get(N-1)-A2.get(i-1));
      maxCandy=Math.max(now,maxCandy);
    }
    System.out.println(maxCandy);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var N : int ; N := (br.readLine())->toInteger() ;
    var A1 : Sequence(int) ; A1 := Sequence{} ;
    var A2 : Sequence(int) ; A2 := Sequence{} ;
    var inp : Sequence(String) ; inp := br.readLine()->split(" ") ;
    var inp2 : Sequence(String) ; inp2 := br.readLine()->split(" ") ;
    var sum : int ; sum := 0 ;
    var sum1 : int ; sum1 := 0 ;
        var i : int ; i := 0 ; while i < inp->size() do ( (     sum := sum+((inp[i+1])->toInteger()) ; 
     sum1 := sum1+((inp2[i+1])->toInteger()) ; 
     A1 := A1->including(sum) ; 
     A2 := A2->including(sum1) )  ;     i := i + 1 ) ; 
    var maxCandy : int ; maxCandy := A1->at(0+1) + A2->at(N - 1+1) ;
        var i : int ; i := 1 ; while i < N do ( (     var now : int ; now := A1->at(i+1) + (A2->at(N - 1+1) - A2->at(i - 1+1)) ;
     maxCandy := Set{now, maxCandy}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(maxCandy) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean existsTriplet(int a[],int b[],int c[],int x,int l1,int l2,int l3){
    if(l2<=l1 && l2<=l3){
      swap(l2,l1);
      swap(a,b);
    }
    else if(l3<=l1 && l3<=l2){
      swap(l3,l1);
      swap(a,c);
    }
    for(int i=0 ; i<l1 ; i++){
      int j=0,k=l3-1 ;
      while(j<l2 && k>=0){
        if(a[i]+b[j]+c[k]==x)return true ;
        if(a[i]+b[j]+c[k]<x)j++;
        else k--;
      }
    }
    return false ;
  }
  private static void swap(int x,int y){
    int temp=x ;
    x=y ;
    y=temp ;
  }
  private static void swap(int[] x,int[] y){
    int[] temp=x ;
    x=y ;
    y=temp ;
  }
  public static void main(String[] args){
    int a[]={
      2,7,8,10,15 };
      int b[]={
        1,6,7,8 };
        int c[]={
          4,5,5 };
          int l1=a.length ;
          int l2=b.length ;
          int l3=c.length ;
          int x=14 ;
          if(existsTriplet(a,b,c,x,l1,l2,l3))System.out.println("Yes");
          else System.out.println("No");
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation existsTriplet( a : Sequence(int), b : Sequence(int), c : Sequence(int), x : int, l1 : int, l2 : int, l3 : int) : boolean
  pre: true
  post: true
  activity: (     if (l2 <= l1 & l2 <= l3) then (     execute swap(l2, l1) ; 
     execute swap(a, b) ) else     if (l3 <= l1 & l3 <= l2) then (     execute swap(l3, l1) ; 
     execute swap(a, c) ) else skip ; ;  
         var i : int ; i := 0 ; while i < l1 do ( (     var j : int ; j := 0 ;
    var k : int ; k := l3 - 1 ;
     while (j < l2 & k >= 0) do (     if (a[i+1] + b[j+1] + c[k+1] = x) then     return true else skip ; 
     if (a[i+1] + b[j+1] + c[k+1] < x) then     j := j + 1 ; else     k := k - 1 ; ) )  ;     i := i + 1 ) ; 
     return false );
  static   operation swap( x : int, y : int) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := x ;
     x := y ; 
     y := temp );
  static   operation swap( x : Sequence(int), y : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var temp : Sequence(int) ; temp := x ;
     x := y ; 
     y := temp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,7,8,10,15} ;
     var b : Sequence(int) ; b := Sequence{1,6,7,8} ;
    var c : Sequence(int) ; c := Sequence{4,5,5} ;
    var l1 : int ; l1 := a->size() ;
    var l2 : int ; l2 := b->size() ;
    var l3 : int ; l3 := c->size() ;
    var x : int ; x := 14 ;
    if (existsTriplet(a, b, c, x, l1, l2, l3)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforce22 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int x=0 ; x<t ; x++){
      int n=sc.nextInt();
      long k=sc.nextLong();
      long b=sc.nextLong();
      long s=sc.nextLong();
      if(s<k*b || s>(k*(b+1)-1+((n-1)*(k-1)))){
        System.out.println(-1);
        continue ;
      }
      else if(s>=k*b && s<=(k*(b+1)-1)){
        for(int i=0 ; i<n-1 ; i++)System.out.print(0+" ");
        System.out.println(s+" ");
      }
      else {
        System.out.print(k*(b+1)-1+" ");
        s-=k*(b+1)-1 ;
        int a=n-1 ;
        while(a>0){
          if(s<k-1){
            System.out.print(s+" ");
            s=0 ;
          }
          else {
            System.out.print(k-1+" ");
            s-=k-1 ;
          }
          a--;
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforce22 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var x : int ; x := 0 ; while x < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : long ; k := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var s : long ; s := sc.getCurrent()->toLong() ;
    if (s < k * b or s > (k * (b + 1) - 1 + ((n - 1) * (k - 1)))) then (     OclFile["System.out"].println(-1) ; 
     continue ) else     if (s >= k * b & s <= (k * (b + 1) - 1)) then (         var i : int ; i := 0 ; while i < n - 1 do (     OclFile["System.out"].print(0 + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(s + " ") ) else (     OclFile["System.out"].print(k * (b + 1) - 1 + " ") ; 
     s := s-(k * (b + 1) - 1) ; 
    var a : int ; a := n - 1 ;
    while (a > 0) do (     if (s < k - 1) then (     OclFile["System.out"].print(s + " ") ; 
     s := 0 ) else (     OclFile["System.out"].print(k - 1 + " ") ; 
     s := s-(k - 1) ) ;  
     a := a - 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ;  
 )  ;     x := x + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[][] A=new int[2][N];
    for(int i=0 ; i<2 ; i++){
      for(int j=0 ; j<N ; j++){
        A[i][j]=sc.nextInt();
      }
    }
    int max=0 ;
    for(int k=0 ; k<N ; k++){
      int tmpMax=0 ;
      for(int j=0 ; j<=k ; j++){
        tmpMax+=A[0][j];
      }
      for(int j=k ; j<N ; j++){
        tmpMax+=A[1][j];
      }
      max=Math.max(max,tmpMax);
    }
    out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(Sequence(int)) ; A := Integer.subrange(1,2)->collect(Integer.subrange(1,N)->collect(0)) ;
        var i : int ; i := 0 ; while i < 2 do ( (         var j : int ; j := 0 ; while j < N do ( (     A[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var k : int ; k := 0 ; while k < N do ( (     var tmpMax : int ; tmpMax := 0 ;
         var j : int ; j := 0 ; while j <= k do ( (     tmpMax := tmpMax+(A[0+1][j+1]) )  ;     j := j + 1 ) ; 
         var j : int ; j := k ; while j < N do ( (     tmpMax := tmpMax+(A[1+1][j+1]) )  ;     j := j + 1 ) ; 
     max := Set{max, tmpMax}->max() )  ;     k := k + 1 ) ; 
    out.println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  private static int n ;
  public static void main(String[] args){
    Main main=new Main();
    Set<Integer>set=new HashSet<>(5);
    int[][] arr=main.scan();
    int candies=0 ;
    int f=0 ;
    for(int i=0 ; i<n ; i++){
      f+=arr[0][i];
      for(int j=i ; j<n ; j++){
        candies+=arr[1][j];
      }
      set.add(f+candies);
      candies=0 ;
    }
    System.out.println(Collections.max(set));
  }
  private int[][] scan(){
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    int[][] arr=new int[2][n];
    for(int i=0 ; i<2 ; i++){
      for(int j=0 ; j<n ; j++){
        arr[i][j]=sc.nextInt();
      }
    }
    sc.close();
    return arr ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     var set : Set(int) ; set := Set{} ;
    var arr : Sequence(Sequence(int)) ; arr := main.scan() ;
    var candies : int ; candies := 0 ;
    var f : int ; f := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     f := f+(arr[0+1][i+1]) ; 
         var j : int ; j := i ; while j < n do ( (     candies := candies+(arr[1+1][j+1]) )  ;     j := j + 1 ) ; 
     set := set->including(f + candies) ; 
     candies := 0 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println( set->max()) ; 
 );
   operation scan() : Sequence(Sequence(int))
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := sc.getCurrent()->toInteger() ; 
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,2)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < 2 do ( (         var j : int ; j := 0 ; while j < n do ( (     arr[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    return arr 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  private static int calcScore(int[][] a,int down){
    int count=0 ;
    for(int j=0 ; j<a[0] .length ; j++){
      if(j==down){
        count+=a[0][j];
        count+=a[1][j];
      }
      else if(j<down){
        count+=a[0][j];
      }
      else if(j>down){
        count+=a[1][j];
      }
    }
    return count ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    sc.nextLine();
    String A1=sc.nextLine();
    String A2=sc.nextLine();
    sc.close();
    String[] a1_ary=A1.split(" ");
    String[] a2_ary=A2.split(" ");
    int[] a1=new int[N];
    int[] a2=new int[N];
    int[][] a=new int[2][N];
    int max=0 ;
    for(int i=0 ; i<N ; i++){
      a1[i]=Integer.valueOf(a1_ary[i]);
      a2[i]=Integer.valueOf(a2_ary[i]);
    }
    for(int i=0 ; i<N ; i++){
      a[0][i]=a1[i];
    }
    for(int i=0 ; i<N ; i++){
      a[1][i]=a2[i];
    }
    for(int i=0 ; i<N ; i++){
      max=Math.max(calcScore(a,i),max);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation calcScore( a : Sequence(Sequence(int)), down : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < a[0+1]->size() do ( (     if (j = down) then (     count := count+(a[0+1][j+1]) ; 
     count := count+(a[1+1][j+1]) ) else     if (j < down) then (     count := count+(a[0+1][j+1]) ) else     if (j > down) then (     count := count+(a[1+1][j+1]) ) else skip ; ;  )  ;     j := j + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    skip ; 
    var A1 : String ; A1 := sc.nextLine() ;
    var A2 : String ; A2 := sc.nextLine() ;
    skip ; 
    var a1_ary : Sequence(String) ; a1_ary := A1->split(" ") ;
    var a2_ary : Sequence(String) ; a2_ary := A2->split(" ") ;
    var a1 : Sequence(int) ; a1 := Integer.subrange(1,N)->collect(0) ;
    var a2 : Sequence(int) ; a2 := Integer.subrange(1,N)->collect(0) ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,2)->collect(Integer.subrange(1,N)->collect(0)) ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     a1[i+1] := (a1_ary[i+1])->toInteger() ; 
     a2[i+1] := (a2_ary[i+1])->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     a[0+1][i+1] := a1[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     a[1+1][i+1] := a2[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     max := Set{calcScore(a, i), max}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static int count(String s,char value){
    int cnt=0 ;
    for(int i=0 ; i<s.length(); i++)if(s.charAt(i)==value)cnt++;
    return cnt ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int q=sc.nextInt();
    int res=0 ;
    String[] s=new String[q];
    for(int i=0 ; i<q ; i++)s[i]=sc.next();
    for(int i=0 ; i<s[0] .length(); i++){
      for(int j=1 ; j<q ; j++){
        if(s[j] .charAt(i)!=s[0] .charAt(i)){
          System.out.println(res);
          return ;
        }
      }
      res++;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation count( s : String, value : String) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < s->size() do (     if (s->at(i+1) = value) then     cnt := cnt + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return cnt );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : int ; q := sc.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
    var s : Sequence(String) ; s := Integer.subrange(1,q)->collect(null) ;
        var i : int ; i := 0 ; while i < q do (     s[i+1] := sc.getCurrent() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < s[0+1]->size() do ( (         var j : int ; j := 1 ; while j < q do ( (     if (s[j+1]->at(i+1) /= s[0+1]->at(i+1)) then (     OclFile["System.out"].println(res) ; 
     return ) else skip )  ;     j := j + 1 ) ; 
     res := res + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.rmi.server.RemoteServer ;
import java.rmi.server.SocketSecurityException ;
import java.security.cert.CollectionCertStoreParameters ;
import java.util.*;
import javax.xml.transform.SourceLocator ;
public class A_Phone_Code {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    String arr[]=new String[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=s.next();
    }
    int l=arr[0] .length();
    int c=0 ;
    search : {
      for(int i=0 ; i<l ; i++){
        for(int j=1 ; j<n ; j++){
          if(arr[0] .charAt(i)!=arr[j] .charAt(i)){
            break search ;
          }
        }
        c++;
      }
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Phone_Code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent() )  ;     i := i + 1 ) ; 
    var l : int ; l := arr[0+1]->size() ;
    var c : int ; c := 0 ;
(         var i : int ; i := 0 ; while i < l do ( (         var j : int ; j := 1 ; while j < n do ( (     if (arr[0+1]->at(i+1) /= arr[j+1]->at(i+1)) then (     break ) else skip )  ;     j := j + 1 ) ; 
     c := c + 1 )  ;     i := i + 1 ) ) 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Javabasics {
  public static void main(String[] args){
    Scanner enter=new Scanner(System.in);
    int friends=enter.nextInt();
    String fornow=enter.next();
    int min=fornow.length();
    for(int i=0 ; i<friends-1 ; i++){
      String current=enter.next();
      for(int j=0 ; j<min ; j++){
        if(current.charAt(j)!=fornow.charAt(j)){
          min=j ;
          fornow=current.substring(0,j);
          break ;
        }
      }
    }
    System.out.println(min);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Javabasics {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var enter : OclFile ; enter := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var friends : int ; friends := enter.getCurrent()->toInteger() ;
    var fornow : String ; fornow := enter.getCurrent() ;
    var min : int ; min := fornow->size() ;
        var i : int ; i := 0 ; while i < friends - 1 do ( (     var current : String ; current := enter.getCurrent() ;
         var j : int ; j := 0 ; while j < min do ( (     if (current->at(j+1) /= fornow->at(j+1)) then (     min := j ; 
     fornow := current.subrange(0+1,j) ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    System.out.println(n+" ");
    int m=n ;
    for(int i=n-1 ; i>0 ; i--){
      if(m % i==0){
        System.out.println(i+" ");
        m=i ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(n + " ") ; 
    var m : int ; m := n ;
        var i : int ; i := n - 1 ; while i > 0 do ( (     if (m mod i = 0) then (     OclFile["System.out"].println(i + " ") ; 
     m := i ) else skip )  ;     i := i - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.io.BufferedReader ;
import java.util.StringTokenizer ;
import java.util.*;
public class Match {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int t=Integer.parseInt(st.nextToken());
    String s[]=new String[t];
    for(int i=0 ; i<t ; i++){
      s[i]=br.readLine();
    }
    String ans=commonPrefix(s,t);
    System.out.println(ans.length());
  }
  static String commonPrefix(String arr[],int n){
    String prefix=arr[0];
    for(int i=1 ; i<=n-1 ; i++)prefix=commonPrefixUtil(prefix,arr[i]);
    return(prefix);
  }
  static String commonPrefixUtil(String str1,String str2){
    String result="" ;
    int n1=str1.length(),n2=str2.length();
    for(int i=0,j=0 ; i<=n1-1 && j<=n2-1 ; i++,j++){
      if(str1.charAt(i)!=str2.charAt(j))break ;
      result+=str1.charAt(i);
    }
    return(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Match {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var t : int ; t := (st.next())->toInteger() ;
    var s : Sequence(String) ; s := Integer.subrange(1,t)->collect(null) ;
        var i : int ; i := 0 ; while i < t do ( (     s[i+1] := br.readLine() )  ;     i := i + 1 ) ; 
    var ans : String ; ans := commonPrefix(s, t) ;
    OclFile["System.out"].println(ans->size()) ; 
 );
  static   operation commonPrefix( arr : Sequence(String), n : int) : String
  pre: true
  post: true
  activity: (     var prefix : String ; prefix := arr[0+1] ;
         var i : int ; i := 1 ; while i <= n - 1 do (     prefix := commonPrefixUtil(prefix, arr[i+1]) ;  ;     i := i + 1 ) ; 
     return (prefix) );
  static   operation commonPrefixUtil( str1 : String, str2 : String) : String
  pre: true
  post: true
  activity: (     var result : String ; result := "" ;
     var n1 : int ; n1 := str1->size() ;
    var n2 : int ; n2 := str2->size() ;
         var i : int ; i := 0 ;
    var j : int ; j := 0 ; while i <= (n1)->char2byte() - 1 & j <= (n2)->char2byte() - 1 do ( (     if (str1->at(i+1) /= str2->at(j+1)) then     break else skip ; 
     result := result+(str1->at(i+1)) )  ;     i := i + 1 ;     j := j + 1 ) ; 
     return (result) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Random ;
public class GFG {
  static int res=0 ;
  static int count=0 ;
  static int selectRandom(int x){
    count++;
    if(count==1)res=x ;
    else {
      Random r=new Random();
      int i=r.nextInt(count);
      if(i==count-1)res=x ;
    }
    return res ;
  }
  public static void main(String[] args){
    int stream[]={
      1,2,3,4 };
      int n=stream.length ;
      for(int i=0 ; i<n ; i++)System.out.println("Random number from first "+(i+1)+" numbers is "+selectRandom(stream[i]));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute res : int := 0;
  static   attribute count : int := 0;
  static   operation selectRandom( x : int) : int
  pre: true
  post: true
  activity: (     count := count + 1 ; 
     if (count = 1) then     res := x else (     var r : OclRandom ; r := OclRandom.newOclRandom() ;
     var i : int ; i := r.nextInt(count) ;
     if (i = count - 1) then     res := x ; else skip ) ;  
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stream : Sequence(int) ; stream := Sequence{1,2,3,4} ;
     var n : int ; n := stream->size() ;
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].println("Random number from first " + (i + 1) + " numbers is " + selectRandom(stream[i+1])) ;  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
class GFG {
  public double CountDigits(int n){
    if(n==1)return 1 ;
    double sum=0 ;
    for(int i=2 ; i<=n ; ++i){
      sum+=((double)Math.log(i)/(double)Math.log(10));
    }
    sum*=n ;
    return Math.ceil(sum);
  }
  public static void main(String args[]){
    GFG g=new GFG();
    int N=5 ;
    System.out.println(g.CountDigits(N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
   operation CountDigits( n : int) : double
  pre: true
  post: true
  activity: (     if (n = 1) then     return 1 else skip ; 
     var sum : double ; sum := 0 ;
        var i : int ; i := 2 ; while i <= n do ( (     sum := sum+(((i)->log()->oclAsType(double) / (10)->log()->oclAsType(double))) )  ;     i := i + 1 ) ; 
    sum := sum*(n) ; 
    return (sum)->ceil() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : GFG ; g := GFG.newGFG() ;
     var N : int ; N := 5 ;
     OclFile["System.out"].println(g.CountDigits(N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Stack ;
public class C {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String word=sc.next();
    Stack<Character>dataStack=new Stack<>();
    int seq=0 ;
    for(int indx=0 ; indx<word.length(); indx++){
      if(! dataStack.isEmpty()&& word.charAt(indx)==dataStack.peek()){
        seq++;
        dataStack.pop();
      }
      else {
        dataStack.push(word.charAt(indx));
      }
    }
    System.out.println(seq % 2==0 ? "No" : "Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var word : String ; word := sc.getCurrent() ;
    var dataStack : Sequence(String) ; dataStack := Sequence{} ;
    var seq : int ; seq := 0 ;
        var indx : int ; indx := 0 ; while indx < word->size() do ( (     if (not(dataStack->isEmpty()) & word->at(indx+1) = dataStack->min()) then (     seq := seq + 1 ; 
     dataStack := dataStack->front() ) else (     dataStack := dataStack->append(word->at(indx+1)) ) )  ;     indx := indx + 1 ) ; 
    OclFile["System.out"].println(if seq mod 2 = 0 then "No" else "Yes" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void CalculatePairs(int a[],int n){
    int cnt_zero=0 ;
    int cnt_one=0 ;
    for(int i=0 ; i<n ; i++){
      if(a[i] % 2==0)cnt_zero+=1 ;
      else cnt_one+=1 ;
    }
    int total_XOR_pairs=cnt_zero*cnt_one ;
    int total_AND_pairs=(cnt_one)*(cnt_one-1)/2 ;
    int total_OR_pairs=cnt_zero*cnt_one+(cnt_one)*(cnt_one-1)/2 ;
    System.out.println("cntXOR="+total_XOR_pairs);
    System.out.println("cntAND="+total_AND_pairs);
    System.out.println("cntOR="+total_OR_pairs);
  }
  public static void main(String[] args){
    int a[]={
      1,3,4,2 };
      int n=a.length ;
      CalculatePairs(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation CalculatePairs( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var cnt_zero : int ; cnt_zero := 0 ;
     var cnt_one : int ; cnt_one := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] mod 2 = 0) then     cnt_zero := cnt_zero+(1) ; else     cnt_one := cnt_one+(1) ; )  ;     i := i + 1 ) ; 
    var total_XOR_pairs : int ; total_XOR_pairs := cnt_zero * cnt_one ;
    var total_AND_pairs : int ; total_AND_pairs := (cnt_one) * (cnt_one - 1) / 2 ;
    var total_OR_pairs : int ; total_OR_pairs := cnt_zero * cnt_one + (cnt_one) * (cnt_one - 1) / 2 ;
    OclFile["System.out"].println("cntXOR=" + total_XOR_pairs) ; 
    OclFile["System.out"].println("cntAND=" + total_AND_pairs) ; 
    OclFile["System.out"].println("cntOR=" + total_OR_pairs) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,3,4,2} ;
     var n : int ; n := a->size() ;
     execute CalculatePairs(a, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.Stack ;
public class GamingwithString {
  public static void main(String[] args){
    Stack<Character>stk=new Stack<>();
    Scanner in=new Scanner(System.in);
    String str=in.next();
    stk.push(str.charAt(0));
    int cnt=0 ;
    for(int i=1 ; i<str.length(); i++){
      if(stk.isEmpty()){
        stk.push(str.charAt(i));
        continue ;
      }
      if(stk.peek()==str.charAt(i)){
        stk.pop();
        cnt++;
      }
      else {
        stk.push(str.charAt(i));
      }
    }
    if(cnt % 2==0){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GamingwithString {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stk : Sequence(String) ; stk := Sequence{} ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var str : String ; str := in.getCurrent() ;
    stk := stk->append(str->at(0+1)) ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 1 ; while i < str->size() do ( (     if (stk->isEmpty()) then (     stk := stk->append(str->at(i+1)) ; 
     continue ) else skip ; 
     if (stk->min() = str->at(i+1)) then (     stk := stk->front() ; 
     cnt := cnt + 1 ) else (     stk := stk->append(str->at(i+1)) ) )  ;     i := i + 1 ) ; 
    if (cnt mod 2 = 0) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Stack ;
public class GameWithString {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    Stack<Character>num=new Stack<>();
    String line=in.nextLine();
    int cnt=0 ;
    num.add(line.charAt(0));
    for(int i=1 ; i<line.length(); i++){
      if(! num.isEmpty()&& line.charAt(i)==num.peek()){
        num.pop();
        cnt+=1 ;
      }
      else {
        num.add(line.charAt(i));
      }
    }
    if(cnt % 2==0){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GameWithString {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : Sequence(String) ; num := Sequence{} ;
    var line : String ; line := in.nextLine() ;
    var cnt : int ; cnt := 0 ;
    num := num->including(line->at(0+1)) ; 
        var i : int ; i := 1 ; while i < line->size() do ( (     if (not(num->isEmpty()) & line->at(i+1) = num->min()) then (     num := num->front() ; 
     cnt := cnt+(1) ) else (     num := num->including(line->at(i+1)) ) )  ;     i := i + 1 ) ; 
    if (cnt mod 2 = 0) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Stack ;
public class SG {
  public static void main(String[] args){
    new SG().runApp();
  }
  void runApp(){
    Scanner in=new Scanner(System.in);
    String p=in.next();
    int player=-1 ;
    Stack<Character>chara=new Stack<Character>();
    Stack<Character>storechara=new Stack<Character>();
    for(int i=0 ; i<p.length(); i++){
      chara.push(p.charAt(i));
    }
    while(chara.size()>=1){
      if(! storechara.empty()){
        while(chara.peek()==storechara.peek()){
          chara.pop();
          storechara.pop();
          player=player*-1 ;
          if(chara.empty()|| storechara.empty()){
            break ;
          }
        }
      }
      if(chara.empty()){
        break ;
      }
      storechara.push(chara.peek());
      chara.pop();
      if(chara.empty()){
        break ;
      }
      if(chara.peek()==storechara.peek()){
        chara.pop();
        storechara.pop();
        player=player*-1 ;
      }
    }
    if(player==1){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     SG.newSG().runApp() );
   operation runApp() : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : String ; p := in.getCurrent() ;
    var player : int ; player := -1 ;
    var chara : Sequence(String) ; chara := Sequence{} ;
    var storechara : Sequence(String) ; storechara := Sequence{} ;
        var i : int ; i := 0 ; while i < p->size() do ( (     chara := chara->append(p->at(i+1)) )  ;     i := i + 1 ) ; 
    while (chara->size() >= 1) do (     if (not(storechara->isEmpty())) then (     while (chara->min() = storechara->min()) do (     chara := chara->front() ; 
     storechara := storechara->front() ; 
     player := player * -1 ; 
     if (chara->isEmpty() or storechara->isEmpty()) then (     break ) else skip ) ) else skip ; 
     if (chara->isEmpty()) then (     break ) else skip ; 
    storechara := storechara->append(chara->min()) ; 
    chara := chara->front() ; 
    if (chara->isEmpty()) then (     break ) else skip ; 
    if (chara->min() = storechara->min()) then (     chara := chara->front() ; 
     storechara := storechara->front() ; 
     player := player * -1 ) else skip ; 
 ) ; 
    if (player = 1) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.util.*;
class GFG {
  static final int MAX_CHAR=26 ;
  public static int minChanges(String str){
    int n=str.length();
    if(n>MAX_CHAR)return-1 ;
    int dist_count=0 ;
    int count[]=new int[MAX_CHAR];
    for(int i=0 ; i<MAX_CHAR ; i++)count[i]=0 ;
    for(int i=0 ; i<n ; i++){
      if(count[str.charAt(i)-'a']==0)dist_count++;
      count[str.charAt(i)-'a']++;
    }
    return(n-dist_count);
  }
  public static void main(String[] args){
    String str="aebaecedabbee" ;
    System.out.println(minChanges(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX_CHAR : int := 26;
  static   operation minChanges( str : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     if (n > MAX_CHAR) then     return -1 else skip ; 
    var dist_count : int ; dist_count := 0 ;
    var count : Sequence(int) ; count := Integer.subrange(1,MAX_CHAR)->collect(0) ;
        var i : int ; i := 0 ; while i < MAX_CHAR do (     count[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (count[str->at(i+1) - ('a')->char2byte()+1] = 0) then     dist_count := dist_count + 1 ; else skip ; 
     count[str->at(i+1) - ('a')->char2byte()+1] := count[str->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    return (n - dist_count) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "aebaecedabbee" ;
     OclFile["System.out"].println(minChanges(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String maximumNum(String curr_num,String res){
    int len1=curr_num.length();
    int len2=res.length();
    if(len1==len2){
      int i=0 ;
      while(curr_num.charAt(i)==res.charAt(i))i++;
      if(curr_num.charAt(i)<res.charAt(i))return res ;
      else return curr_num ;
    }
    return len1<len2 ? res : curr_num ;
  }
  static String extractMaximum(String str){
    int n=str.length();
    String curr_num="" ;
    String res="" ;
    for(int i=0 ; i<n ; i++){
      while(i<n && str.charAt(i)=='0')i++;
      while(i<n && Character.isDigit(str.charAt(i))){
        curr_num=curr_num+str.charAt(i);
        i++;
      }
      if(i==n)break ;
      if(curr_num.length()>0)i--;
      res=maximumNum(curr_num,res);
      curr_num="" ;
    }
    if(curr_num.length()==0 && res.length()==0)res=res+'0' ;
    return maximumNum(curr_num,res);
  }
  public static void main(String[] args){
    String str="100klh564abc365bg" ;
    System.out.println(extractMaximum(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maximumNum( curr_num : String, res : String) : String
  pre: true
  post: true
  activity: (     var len1 : int ; len1 := curr_num->size() ;
     var len2 : int ; len2 := res->size() ;
     if (len1 = len2) then (     var i : int ; i := 0 ;
     while (curr_num->at(i+1) = res->at(i+1)) do     i := i + 1 ; ; 
     if (curr_num->at(i+1) < res->at(i+1)) then     return res else     return curr_num ) else skip ; 
     return if len1 < len2 then res else curr_num endif );
  static   operation extractMaximum( str : String) : String
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var curr_num : String ; curr_num := "" ;
    var res : String ; res := "" ;
        var i : int ; i := 0 ; while i < n do ( (     while (i < n & str->at(i+1) = '0') do     i := i + 1 ; ; 
     while (i < n & (str->at(i+1) + "")->isMatch("[0-9]")) do (     curr_num := curr_num + str->at(i+1) ; 
     i := i + 1 ) ; 
    if (i = n) then     break else skip ; 
    if (curr_num->size() > 0) then     i := i - 1 ; else skip ; 
    res := maximumNum(curr_num, res) ; 
    curr_num := "" ; 
 )  ;     i := i + 1 ) ; 
    if (curr_num->size() = 0 & res->size() = 0) then     res := res + '0' ; else skip ; 
    return maximumNum(curr_num, res) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "100klh564abc365bg" ;
     OclFile["System.out"].println(extractMaximum(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class program {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sf=new Scanner(System.in);
    int t=1 ;
    for(int t1=0 ; t1<t ; t1++){
      int n=sf.nextInt();
      int m=sf.nextInt();
      int[] p=new int[n];
      int[] hash=new int[n+1];
      for(int i=0 ; i<n ; i++){
        p[i]=sf.nextInt();
        hash[i]=p[i];
      }
      for(int i=0 ; i<m ; i++){
        int l=sf.nextInt();
        int r=sf.nextInt();
        int x=sf.nextInt();
        l--;
        r--;
        x--;
        int ind=x ;
        if(ind<l || ind>r){
          System.out.println("Yes");
        }
        else {
          int[] hash1=new int[n+1];
          for(int j=0 ; j<l ; j++)hash1[p[j] ]++;
          for(int j=r+1 ; j<n ; j++)hash1[p[j] ]++;
          int cnt=0 ;
          for(int j=1 ; j<=n ; j++){
            if(hash1[j]==0){
              cnt++;
            }
            if(j==hash[x])break ;
          }
          int dif1=ind-l+1 ;
          if(dif1!=cnt){
            System.out.println("No");
          }
          else {
            System.out.println("Yes");
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class program {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sf : OclFile ; sf := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
         var t1 : int ; t1 := 0 ; while t1 < t do ( (     var n : int ; n := sf.getCurrent()->toInteger() ;
     var m : int ; m := sf.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    var hash : Sequence(int) ; hash := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := sf.getCurrent()->toInteger() ; 
     hash[i+1] := p[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var l : int ; l := sf.getCurrent()->toInteger() ;
     var r : int ; r := sf.getCurrent()->toInteger() ;
    var x : int ; x := sf.getCurrent()->toInteger() ;
    l := l - 1 ; 
    r := r - 1 ; 
    x := x - 1 ; 
    var ind : int ; ind := x ;
    if (ind < l or ind > r) then (     OclFile["System.out"].println("Yes") ) else (     var hash1 : Sequence(int) ; hash1 := Integer.subrange(1,n + 1)->collect(0) ;
         var j : int ; j := 0 ; while j < l do (     hash1[p[j+1]+1] := hash1[p[j+1]+1] + 1 ;  ;     j := j + 1 ) ; 
        var j : int ; j := r + 1 ; while j < n do (     hash1[p[j+1]+1] := hash1[p[j+1]+1] + 1 ;  ;     j := j + 1 ) ; 
    var cnt : int ; cnt := 0 ;
        var j : int ; j := 1 ; while j <= n do ( (     if (hash1[j+1] = 0) then (     cnt := cnt + 1 ) else skip ; 
     if (j = hash[x+1]) then     break else skip )  ;     j := j + 1 ) ; 
    var dif1 : int ; dif1 := ind - l + 1 ;
    if (dif1 /= cnt) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ) ;  
 ) ;  
 )  ;     i := i + 1 ) ; 
 )  ;     t1 := t1 + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.System.in ;
class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt(),K=sc.nextInt();
    System.out.println(help(N,K));
  }
  static long help(int N,int K){
    if(K==0)return((long)N)*((long)N);
    long ans=0 ;
    for(int a=K ; a<=N ; a++)ans+=N-a ;
    for(int b=K+1 ; b<N ; b++){
      int x0=N/b ;
      ans+=(x0-1)*(b-K);
      ans+=Math.max(0,N-x0*b-K+1);
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(help(N, K)) );
  static   operation help( N : int, K : int) : long
  pre: true
  post: true
  activity: (     if (K = 0) then     return (N->oclAsType(long)) * (N->oclAsType(long)) else skip ; 
     var ans : long ; ans := 0 ;
        var a : int ; a := K ; while a <= N do (     ans := ans+(N - a) ;  ;     a := a + 1 ) ; 
        var b : int ; b := K + 1 ; while b < N do ( (     var x0 : int ; x0 := N / b ;
     ans := ans+((x0 - 1) * (b - K)) ; 
     ans := ans+(Set{0, N - x0 * b - K + 1}->max()) )  ;     b := b + 1 ) ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    RemainderReminder solver=new RemainderReminder();
    solver.solve(1,in,out);
    out.close();
  }
  static class RemainderReminder {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      long n=in.nextLong();
      long k=in.nextLong();
      long result=0 ;
      if(k==0){
        out.println(n*n);
        return ;
      }
      for(long b=k+1 ; b<=n ; b++){
        result+=(n/b)*(b-k);
        result+=Math.max(0,n % b-k+1);
      }
      out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : RemainderReminder ; solver := RemainderReminder.newRemainderReminder() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class RemainderReminder {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : long ; n := in.getCurrent()->toLong() ;
     var k : long ; k := in.getCurrent()->toLong() ;
    var result : long ; result := 0 ;
    if (k = 0) then (     skip ; 
     return ) else skip ; 
        var b : long ; b := k + 1 ; while b <= n do ( (     result := result+((n / b) * (b - k)) ; 
     result := result+(Set{0, n mod b - k + 1}->max()) )  ;     b := b + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner();
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt();
    int k=sc.nextInt();
    long ans=0 ;
    for(int b=k+1 ; b<=n ; b++){
      int laps=n/b ;
      int extra=n % b ;
      int bigger=b-k ;
      ans+=1l*laps*bigger ;
      ans+=Math.max(0,extra-k+(k==0 ? 0 : 1));
    }
    out.println(ans);
    out.flush();
    out.close();
  }
  static class Scanner {
    BufferedReader br ;
    StringTokenizer st ;
    Scanner(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := (arguments ( )) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var ans : long ; ans := 0 ;
        var b : int ; b := k + 1 ; while b <= n do ( (     var laps : int ; laps := n / b ;
     var extra : int ; extra := n mod b ;
    var bigger : int ; bigger := b - k ;
    ans := ans+(1l * laps * bigger) ; 
    ans := ans+(Set{0, extra - k + (if k = 0 then 0 else 1 endif)}->max()) ; 
 )  ;     b := b + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newScanner() : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    long n=sc.nextLong();
    long k=sc.nextLong();
    if(k==0){
      out.print(n*n);
      out.flush();
      return ;
    }
    long ans=0 ;
    for(long b=k+1 ; b<=n ; b++){
      long base=b-k ;
      long div=n/b ;
      long remain=n % b ;
      ans+=base*div ;
      if(remain>=k){
        ans+=remain-k+1 ;
      }
    }
    out.print(ans);
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.getCurrent()->toLong() ;
     var k : long ; k := sc.getCurrent()->toLong() ;
    if (k = 0) then (     skip ; 
     skip ; 
     return ) else skip ; 
    var ans : long ; ans := 0 ;
        var b : long ; b := k + 1 ; while b <= n do ( (     var base : long ; base := b - k ;
     var div : long ; div := n / b ;
    var remain : long ; remain := n mod b ;
    ans := ans+(base * div) ; 
    if (remain >= k) then (     ans := ans+(remain - k + 1) ) else skip ; 
 )  ;     b := b + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    long K=sc.nextLong();
    long sum=0 ;
    if(K==0){
      System.out.println(N*N);
      System.exit(0);
    }
    for(int i=1 ; i<=N ; i++)sum+=(N/i)*Math.max(0,i-K)+Math.max(0,(N % i)-K+1);
    System.out.println(sum);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
    var K : long ; K := sc.getCurrent()->toLong() ;
    var sum : long ; sum := 0 ;
    if (K = 0) then (     OclFile["System.out"].println(N * N) ; 
 OclProcess.exit(0) ) else skip ; 
        var i : int ; i := 1 ; while i <= N do (     sum := sum+((N / i) * Set{0, i - K}->max() + Set{0, (N mod i) - K + 1}->max()) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Main {
  static boolean checkForSorting(int arr[],int n){
    for(int i=0 ; i<n-1 ; i++){
      if(arr[i]>arr[i+1]){
        if(arr[i]-arr[i+1]==1){
          int temp=arr[i];
          arr[i]=arr[i+1];
          arr[i+1]=temp ;
        }
        else return false ;
      }
    }
    return true ;
  }
  public static void main(String args[]){
    int arr[]={
      1,0,3,2 };
      int n=arr.length ;
      if(checkForSorting(arr,n))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation checkForSorting( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n - 1 do ( (     if (arr[i+1] > arr[i + 1+1]) then (     if (arr[i+1] - arr[i + 1+1] = 1) then (     var temp : int ; temp := arr[i+1] ;
     arr[i+1] := arr[i + 1+1] ; 
     arr[i + 1+1] := temp ) else     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,0,3,2} ;
     var n : int ; n := arr->size() ;
     if (checkForSorting(arr, n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int d,tptn=0 ;
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] p=new int[n];
    int[][] pattern=new int[n][6];
    for(int i=0 ; i<k ; i++){
      d=sc.nextInt();
      p[d-1]=sc.nextInt();
    }
    if(p[0]==0){
      for(int i=0 ; i<3 ; i++)pattern[0][i]=1 ;
    }
    else pattern[0][p[0]-1]=1 ;
    for(int i=1 ; i<n ; i++){
      for(int h=0 ; h<6 ; h++)tptn+=pattern[i-1][h] % 10000 ;
      if(p[i]==0){
        for(int j=0 ; j<6 ; j++){
          if(j<3)pattern[i][j]=(tptn-pattern[i-1][j]-pattern[i-1][j+3])% 10000 ;
          else pattern[i][j]=pattern[i-1][j-3];
        }
      }
      else {
        pattern[i][p[i]-1]=(tptn-pattern[i-1][p[i]-1]-pattern[i-1][p[i]+2])% 10000 ;
        pattern[i][p[i]+2]=pattern[i-1][p[i]-1];
      }
      tptn=0 ;
      if(i==n-1)for(int h=0 ;
      h<6 ;
      h++)tptn+=pattern[n-1][h] % 10000 ;
    }
    System.out.println(tptn % 10000);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var d : int ;
    var tptn : int ; tptn := 0 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
    var pattern : Sequence(Sequence(int)) ; pattern := Integer.subrange(1,n)->collect(Integer.subrange(1,6)->collect(0)) ;
        var i : int ; i := 0 ; while i < k do ( (     d := sc.getCurrent()->toInteger() ; 
     p[d - 1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (p[0+1] = 0) then (         var i : int ; i := 0 ; while i < 3 do (     pattern[0+1][i+1] := 1 ;  ;     i := i + 1 ) ) else     pattern[0+1][p[0+1] - 1+1] := 1 ; ;  
        var i : int ; i := 1 ; while i < n do ( (         var h : int ; h := 0 ; while h < 6 do (     tptn := tptn+(pattern[i - 1+1][h+1] mod 10000) ;  ;     h := h + 1 ) ; 
     if (p[i+1] = 0) then (         var j : int ; j := 0 ; while j < 6 do ( (     if (j < 3) then     pattern[i+1][j+1] := (tptn - pattern[i - 1+1][j+1] - pattern[i - 1+1][j + 3+1]) mod 10000 ; else     pattern[i+1][j+1] := pattern[i - 1+1][j - 3+1] ; )  ;     j := j + 1 ) ) else (     pattern[i+1][p[i+1] - 1+1] := (tptn - pattern[i - 1+1][p[i+1] - 1+1] - pattern[i - 1+1][p[i+1] + 2+1]) mod 10000 ; 
     pattern[i+1][p[i+1] + 2+1] := pattern[i - 1+1][p[i+1] - 1+1] ) ;  
     tptn := 0 ; 
     if (i = n - 1) then         var h : int ; h := 0 ; while h < 6 do (     tptn := tptn+(pattern[n - 1+1][h+1] mod 10000) ;  ;     h := h + 1 ) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(tptn mod 10000) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int N,K ;
  static int[] A ;
  static int[][][] check ;
  public static void main(String[] args){
    int ans=0 ;
    Scanner scanner=new Scanner(System.in);
    N=scanner.nextInt();
    K=scanner.nextInt();
    A=new int[N+1];
    Arrays.fill(A,-1);
    for(; K!=0 ; K--){
      A[scanner.nextInt()]=scanner.nextInt()-1 ;
    }
    check=new int[N+1][3][3];
    for(int i=0 ; i<check.length ; i++){
      for(int j=0 ; j<check[i] .length ; j++){
        Arrays.fill(check[i][j],-1);
      }
    }
    for(int i=0 ; i<3 ; i++){
      for(int j=1 ; j<3 ; j++){
        ans+=count_pasta(1,i,j);
      }
    }
    System.out.println(ans % 10000);
  }
  public static int count_pasta(int v,int s,int c){
    if(A[v]!=-1 && A[v]!=s)return 0 ;
    if(v==N)return c==1 ? 1 : 0 ;
    if(check[v][s][c]!=-1)return check[v][s][c];
    int ans=0 ;
    if(c==1){
      for(int j=0 ; j<3 ; j++){
        if(s==j)continue ;
        ans=(ans+count_pasta(v+1,j,1)+count_pasta(v+1,j,2))% 10000 ;
      }
    }
    else ans=count_pasta(v+1,s,1);
    check[v][s][c]=ans ;
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute A : Sequence(int);
  static   attribute check : Sequence(Sequence(Sequence(int)));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    N := scanner.getCurrent()->toInteger() ; 
    K := scanner.getCurrent()->toInteger() ; 
    A := Integer.subrange(1,N + 1)->collect(0) ; 
    A := A->collect(-1) ; 
      while K /= 0 do ( (     A[scanner.getCurrent()->toInteger()+1] := scanner.getCurrent()->toInteger() - 1 )  ;     K := K - 1 ) ; 
    check := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0))) ; 
        var i : int ; i := 0 ; while i < check->size() do ( (         var j : int ; j := 0 ; while j < check[i+1]->size() do ( (     check[i+1][j+1] := check[i+1][j+1]->collect(-1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := 1 ; while j < 3 do ( (     ans := ans+(count_pasta(1, i, j)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans mod 10000) ; 
 );
  static   operation count_pasta( v : int, s : int, c : int) : int
  pre: true
  post: true
  activity: (     if (A[v+1] /= -1 & A[v+1] /= s) then     return 0 else skip ; 
     if (v = N) then     return if c = 1 then 1 else 0 endif else skip ; 
    if (check[v+1][s+1][c+1] /= -1) then     return check[v+1][s+1][c+1] else skip ; 
    var ans : int ; ans := 0 ;
    if (c = 1) then (         var j : int ; j := 0 ; while j < 3 do ( (     if (s = j) then     continue else skip ; 
     ans := (ans + count_pasta(v + 1, j, 1) + count_pasta(v + 1, j, 2)) mod 10000 )  ;     j := j + 1 ) ) else     ans := count_pasta(v + 1, s, 1) ; ;  
    check[v+1][s+1][c+1] := ans ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    n=scanner.nextInt();
    k=scanner.nextInt();
    plan=new int[n+1];
    for(int i=0 ; i<k ; i++)plan[scanner.nextInt()]=scanner.nextInt();
    dp=new int[n+1][4][4];
    for(int[][] dpp : dp)for(int[] dppp : dpp)Arrays.fill(dppp,-1);
    System.out.println(slove(1,0,0));
  }
  private int slove(int day,int pre1,int pre2){
    if(day==n+1)return 1 ;
    if(dp[day][pre1][pre2]!=-1)return dp[day][pre1][pre2];
    if(plan[day]!=0)if(pre2==pre1 && pre1==plan[day])return 0 ;
    else return slove(day+1,plan[day],pre1)% mod ;
    int ret=0 ;
    for(int i=1 ; i<4 ; i++){
      if(i==pre1 && pre1==pre2)continue ;
      ret+=slove(day+1,i,pre1)% mod ;
    }
    return dp[day][pre1][pre2]=ret % mod ;
  }
  int n,k ;
  int[] plan ;
  int[][][] dp ;
  int mod=10000 ;
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     n := scanner.getCurrent()->toInteger() ; 
    k := scanner.getCurrent()->toInteger() ; 
    plan := Integer.subrange(1,n + 1)->collect(0) ; 
        var i : int ; i := 0 ; while i < k do (     plan[scanner.getCurrent()->toInteger()+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,4)->collect(Integer.subrange(1,4)->collect(0))) ; 
    for (dpp : dp) do (     for (dppp : dpp) do (     dppp := dppp->collect(-1) ;  ) ;  ) ; 
    OclFile["System.out"].println(slove(1, 0, 0)) ; 
 );
   operation slove( day : int, pre1 : int, pre2 : int) : int
  pre: true
  post: true
  activity: (     if (day = n + 1) then     return 1 else skip ; 
     if (dp[day+1][pre1+1][pre2+1] /= -1) then     return dp[day+1][pre1+1][pre2+1] else skip ; 
    if (plan[day+1] /= 0) then     if (pre2 = pre1 & pre1 = plan[day+1]) then     return 0 else     return slove(day + 1, plan[day+1], pre1) mod mod ;  else skip ; 
    var ret : int ; ret := 0 ;
        var i : int ; i := 1 ; while i < 4 do ( (     if (i = pre1 & pre1 = pre2) then     continue else skip ; 
     ret := ret+(slove(day + 1, i, pre1) mod mod) )  ;     i := i + 1 ) ; 
    return dp[day+1][pre1+1][pre2+1] 
 );
   attribute n : int;
   attribute plan : Sequence(int);
   attribute dp : Sequence(Sequence(Sequence(int)));
   attribute mod : int := 10000;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),q=sc.nextInt();
    int[] p=new int[n];
    for(int i=0 ; i<n ; i++)p[i]=sc.nextInt()-1 ;
    while(q-->0){
      int l=sc.nextInt()-1,r=sc.nextInt(),pos=sc.nextInt()-1 ;
      int cnt=0 ;
      for(int i=l ; i<r ; i++)if(p[i]<p[pos])cnt++;
      System.out.println(cnt==pos-l ? "Yes" : "No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     p[i+1] := sc.getCurrent()->toInteger() - 1 ;  ;     i := i + 1 ) ; 
        while (q > 0) do (        q := q - 1 ;     skip ; (     var l : int ; l := sc.getCurrent()->toInteger() - 1 ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var pos : int ; pos := sc.getCurrent()->toInteger() - 1 ;
     var cnt : int ; cnt := 0 ;
         var i : int ; i := l ; while i < r do (     if (p[i+1] < p[pos+1]) then     cnt := cnt + 1 ; else skip ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if cnt = pos - l then "Yes" else "No" endif) ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    HashMap<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<k ; i++){
      map.put(sc.nextInt(),sc.nextInt());
    }
    int[][][] dp=new int[n+1][4][4];
    dp[0][0][0]=1 ;
    for(int i=1 ; i<=n ; i++){
      for(int a=0 ; a<4 ; a++){
        for(int b=0 ; b<4 ; b++){
          for(int c=1 ; c<4 ; c++){
            if(map.containsKey(i)&& map.get(i)!=c){
              continue ;
            }
            if(a==b && b==c){
              continue ;
            }
            dp[i][b][c]+=dp[i-1][a][b];
            dp[i][b][c] %=10000 ;
          }
        }
      }
    }
    int sum=0 ;
    for(int a=0 ; a<4 ; a++){
      for(int b=0 ; b<4 ; b++){
        sum+=dp[n][a][b];
        sum %=10000 ;
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < k do ( (     map := map->union(Map{sc.getCurrent()->toInteger() |-> sc.getCurrent()->toInteger()}) )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(Sequence(int))) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,4)->collect(Integer.subrange(1,4)->collect(0))) ;
    dp[0+1][0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do ( (         var a : int ; a := 0 ; while a < 4 do ( (         var b : int ; b := 0 ; while b < 4 do ( (         var c : int ; c := 1 ; while c < 4 do ( (     if (map->keys()->includes(i) & map->at(i) /= c) then (     continue ) else skip ; 
     if (a = b & b = c) then (     continue ) else skip ; 
     dp[i+1][b+1][c+1] := dp[i+1][b+1][c+1]+(dp[i - 1+1][a+1][b+1]) ; 
     dp[i+1][b+1][c+1] := dp[i+1][b+1][c+1] mod 10000 )  ;     c := c + 1 ) )  ;     b := b + 1 ) )  ;     a := a + 1 ) )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var a : int ; a := 0 ; while a < 4 do ( (         var b : int ; b := 0 ; while b < 4 do ( (     sum := sum+(dp[n+1][a+1][b+1]) ; 
     sum := sum mod 10000 )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedHashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Obfuscation765B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.next();
    Set set=new LinkedHashSet<String>();
    int size=s.length();
    if(s.charAt(0)!='a'){
      System.out.println("NO");
      return ;
    }
    for(int i=0 ; i<size ; i++){
      set.add(s.charAt(i));
    }
    s=set.toString();
    s=s.replaceAll(" ","");
    s=s.replaceAll("] ","");
    s=s.replaceAll(",","");
    size=s.length();
    for(int i=1 ; i<size-1 ; i++){
      if(s.charAt(i+1)-s.charAt(i)>1){
        System.out.println("NO");
        return ;
      }
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Obfuscation765B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.getCurrent() ;
    var set : Set ; set := Set{} ;
    var size : int ; size := s->size() ;
    if (s->at(0+1) /= 'a') then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < size do ( (     set := set->including(s->at(i+1)) )  ;     i := i + 1 ) ; 
    s := set+"" ; 
    s := s.replaceAllMatches(" ", "" ) ; 
    s := s.replaceAllMatches("] ", "" ) ; 
    s := s.replaceAllMatches(",", "" ) ; 
    size := s->size() ; 
        var i : int ; i := 1 ; while i < size - 1 do ( (     if (s->at(i + 1+1) - s->at(i+1) > 1) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class submitfinal {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    char c='a' ;
    boolean flag=true ;
    String s=sc.next();
    for(int i=0 ; i<s.length(); ++i){
      if(s.charAt(i)>='a' && s.charAt(i)<=c){
        if(s.charAt(i)==c)c++;
      }
      else {
        flag=false ;
        System.out.println("NO");
        break ;
      }
    }
    if(flag==true)System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class submitfinal {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : String ; c := 'a' ;
    var flag : boolean ; flag := true ;
    var s : String ; s := sc.getCurrent() ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) >= 'a' & s->at(i+1) <= c) then (     if (s->at(i+1) = c) then     c := c + 1 ; else skip ) else (     flag := false ; 
     OclFile["System.out"].println("NO") ; 
     break ) )  ;     i := i + 1 ) ; 
    if (flag = true) then     OclFile["System.out"].println("YES") ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    String s=in.next();
    char c='a' ;
    boolean flag=true ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)>c){
        flag=false ;
        break ;
      }
      else if(s.charAt(i)==c){
        c++;
      }
    }
    if(flag){
      pw.println("Yes");
    }
    else {
      pw.println("No");
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var s : String ; s := in.getCurrent() ;
    var c : String ; c := 'a' ;
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) > c) then (     flag := false ; 
     break ) else     if (s->at(i+1) = c) then (     c := c + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    if (flag) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class BinaryLiterature_715A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=Integer.parseInt(sc.nextLine());
    while(t-->0){
      int n=Integer.parseInt(sc.nextLine());
      String[] strs=new String[3];
      int[] idx=new int[3];
      for(int i=0 ; i<3 ; i++)strs[i]=sc.nextLine();
      StringBuilder sb=new StringBuilder();
      while(idx[0]<2*n && idx[1]<2*n && idx[2]<2*n){
        int ones=0,zeros=0 ;
        for(int i=0 ; i<3 ; i++){
          if(strs[i] .charAt(idx[i])=='0'){
            zeros++;
          }
          else {
            ones++;
          }
        }
        char majority=ones>zeros ? '1' : '0' ;
        sb.append(majority);
        for(int i=0 ; i<3 ; i++){
          if(strs[i] .charAt(idx[i])==majority)idx[i]++;
        }
      }
      int j=0,inProgress=0 ;
      for(int i=0 ; i<3 ; i++){
        if(idx[i]==2*n)continue ;
        j=Math.max(j,idx[i]);
        inProgress++;
      }
      if(inProgress>1){
        for(int i=0 ; i<3 ; i++){
          if(idx[i]!=j)continue ;
          sb.append(strs[i] .substring(idx[i]));
          break ;
        }
      }
      System.out.println(sb.toString());
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class BinaryLiterature_715A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := (sc.nextLine())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := (sc.nextLine())->toInteger() ;
     var strs : Sequence(String) ; strs := Integer.subrange(1,3)->collect(null) ;
    var idx : Sequence(int) ; idx := Integer.subrange(1,3)->collect(0) ;
        var i : int ; i := 0 ; while i < 3 do (     strs[i+1] := sc.nextLine() ;  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    while (idx[0+1] < 2 * n & idx[1+1] < 2 * n & idx[2+1] < 2 * n) do (     var ones : int ; ones := 0 ;
    var zeros : int ; zeros := 0 ;
         var i : int ; i := 0 ; while i < 3 do ( (     if (strs[i+1]->at(idx[i+1]+1) = '0') then (     zeros := zeros + 1 ) else (     ones := ones + 1 ) )  ;     i := i + 1 ) ; 
    var majority : String ; majority := if ones > zeros then '1' else '0' endif ;
    sb := sb + StringLib.newString(majority) ; 
        var i : int ; i := 0 ; while i < 3 do ( (     if (strs[i+1]->at(idx[i+1]+1) = majority) then     idx[i+1] := idx[i+1] + 1 ; else skip )  ;     i := i + 1 ) ; 
 ) ; 
    var j : int ; j := 0 ;
    var inProgress : int ; inProgress := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     if (idx[i+1] = 2 * n) then     continue else skip ; 
     j := Set{j, idx[i+1]}->max() ; 
     inProgress := inProgress + 1 )  ;     i := i + 1 ) ; 
    if (inProgress > 1) then (         var i : int ; i := 0 ; while i < 3 do ( (     if (idx[i+1] /= j) then     continue else skip ; 
     sb := sb + StringLib.newString(strs[i+1].subrange(idx[i+1]+1,idx[i+1])) ; 
     break )  ;     i := i + 1 ) ) else skip ; 
    OclFile["System.out"].println(sb+"") ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int N=gi();
    int[] a=new int[N];
    for(int i=0 ; i<N ; i++){
      a[i]=gi();
    }
    Arrays.parallelSort(a);
    if(N % 3==0){
      int a1=a[0];
      int a2=a[N/3];
      int a3=a[N*2/3];
      int[] as={
        a1,a2,a3 };
        int t=a1 ^ a2 ^ a3 ;
        if(t!=0){
          System.out.println("No");
          return ;
        }
        for(int i=0 ; i<3 ; i++){
          for(int j=i*N/3 ; j<(i+1)*N/3 ; j++){
            if(as[i]!=a[j]){
              System.out.println("No");
              return ;
            }
          }
        }
      }
      else {
        for(int i=0 ; i<N ; i++){
          if(a[i]!=0){
            System.out.println("No");
            return ;
          }
        }
      }
      System.out.println("Yes");
    }
    public static String gs(){
      return scanner.next();
    }
    public static int gi(){
      return Integer.parseInt(scanner.next());
    }
    public static long gl(){
      return Long.parseLong(scanner.next());
    }
    public static double gd(){
      return Double.parseDouble(scanner.next());
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : int ; N := gi() ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := gi() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    if (N mod 3 = 0) then (     var a1 : int ; a1 := a[0+1] ;
     var a2 : int ; a2 := a[N / 3+1] ;
    var a3 : int ; a3 := a[N * 2 / 3+1] ;
    var as : Sequence(int) ; as := Sequence{a1,a2,a3} ;
    var t : int ; t := MathLib.bitwiseXor(MathLib.bitwiseXor(a1,a2),a3) ;
    if (t /= 0) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
        var i : int ; i := 0 ; while i < 3 do ( (         var j : int ; j := i * N / 3 ; while j < (i + 1) * N / 3 do ( (     if (as[i+1] /= a[j+1]) then (     OclFile["System.out"].println("No") ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 ) else (         var i : int ; i := 0 ; while i < N do ( (     if (a[i+1] /= 0) then (     OclFile["System.out"].println("No") ; 
     return ) else skip )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println("Yes") ; 
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextInt()){
      int N=sc.nextInt();
      Map<Long,Integer>cnt=new HashMap<>();
      Set<Long>set=new HashSet<>();
      for(int i=0 ; i<N ; i++){
        long x=sc.nextLong();
        int nowCnt=cnt.getOrDefault(x,0);
        nowCnt++;
        cnt.put(x,nowCnt);
        set.add(x);
      }
      List<Long>sortList=new ArrayList<>(set);
      sortList.sort(Long :: compareTo);
      long ans=0 ;
      List<Long>hen=new ArrayList<>();
      for(int i=sortList.size()-1 ; hen.size()<2 && i>=0 ; i--){
        long len=sortList.get(i);
        if(cnt.get(len)>=2){
          hen.add(len);
        }
        if(cnt.get(len)>=4){
          hen.add(len);
        }
      }
      if(hen.size()>=2){
        ans=hen.get(0)*hen.get(1);
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextInt()) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var cnt : Map(long,int) ; cnt := Map{} ;
    var set : Set(long) ; set := Set{} ;
        var i : int ; i := 0 ; while i < N do ( (     var x : long ; x := sc.getCurrent()->toLong() ;
     var nowCnt : int ; nowCnt := (if cnt->keys()->contains(x) then cnt->at(x) else 0 endif) ;
    nowCnt := nowCnt + 1 ; 
    cnt := cnt->union(Map{x |-> nowCnt}) ; 
    set := set->including(x) ; 
 )  ;     i := i + 1 ) ; 
    var sortList : Sequence(long) ; sortList := Sequence{}->union(set) ;
    sortList := sortList.sort(lambda _pars : OclAny in Long.newLong().compareTo(_pars)) ; 
    var ans : long ; ans := 0 ;
    var hen : Sequence(long) ; hen := Sequence{} ;
        var i : int ; i := sortList->size() - 1 ; while hen->size() < 2 & i >= 0 do ( (     var len : long ; len := sortList->at(i+1) ;
     if (cnt->at(len) >= 2) then (     hen := hen->including(len) ) else skip ; 
     if (cnt->at(len) >= 4) then (     hen := hen->including(len) ) else skip )  ;     i := i - 1 ) ; 
    if (hen->size() >= 2) then (     ans := hen->at(0+1) * hen->at(1+1) ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(sc.next());
    }
    sc.close();
    Map<Integer,Integer>h=new TreeMap<>();
    for(int i=0 ; i<n ; i++){
      if(h.containsKey(a[i])){
        h.put(a[i],h.get(a[i])+1);
      }
      else {
        h.put(a[i],1);
      }
    }
    long max4=0 ;
    long max21=0 ;
    long max22=0 ;
    for(int k : h.keySet()){
      if(h.get(k)>=4){
        max4=(max4<k)? k : max4 ;
      }
      if(h.get(k)>=2){
        if(max21<k){
          max22=max21 ;
          max21=k ;
        }
        else if(max22<k){
          max22=k ;
        }
      }
    }
    long ans=(max4*max4>max21*max22)? max4*max4 : max21*max22 ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var h : Map(int,int) ; h := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (h->keys()->includes(a[i+1])) then (     h := h->union(Map{a[i+1] |-> h->at(a[i+1]) + 1}) ) else (     h := h->union(Map{a[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var max4 : long ; max4 := 0 ;
    var max21 : long ; max21 := 0 ;
    var max22 : long ; max22 := 0 ;
    for (k : h->keys()) do ( (     if (h->at(k) >= 4) then (     max4 := if (max4 < k) then k else max4 endif ) else skip ; 
     if (h->at(k) >= 2) then (     if (max21 < k) then (     max22 := max21 ; 
     max21 := k ) else     if (max22 < k) then (     max22 := k ) else skip ; ) else skip )  ) ; 
    var ans : long ; ans := if (max4 * max4 > max21 * max22) then max4 * max4 else max21 * max22 endif ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
import java.util.ArrayList ;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String[] args){
    FastReader s=new FastReader();
    int n=s.nextInt();
    long a[]=new long[n];
    int c=0 ;
    ArrayList<Long>arr=new ArrayList<Long>(2);
    for(int i=0 ; i<n ; i++)a[i]=s.nextLong();
    Arrays.sort(a);
    for(int i=n-1 ; i>0 ; i--){
      if(c==2)break ;
      if(a[i]==a[i-1]){
        i--;
        arr.add(a[i]);
        c++;
      }
    }
    if(c==2)System.out.println(arr.get(0)*arr.get(1));
    else System.out.println("0");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : FastReader ; s := FastReader.newFastReader() ;
     var n : int ; n := s.nextInt() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var c : int ; c := 0 ;
    var arr : Sequence(long) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := s.nextLong() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
        var i : int ; i := n - 1 ; while i > 0 do ( (     if (c = 2) then     break else skip ; 
     if (a[i+1] = a[i - 1+1]) then (     i := i - 1 ; 
     arr := arr->including(a[i+1]) ; 
     c := c + 1 ) else skip )  ;     i := i - 1 ) ; 
    if (c = 2) then     OclFile["System.out"].println(arr->at(0+1) * arr->at(1+1)) else     OclFile["System.out"].println("0") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.util.*;
public class B811 {
  public static void main(String[] args)throws IOException {
    StringBuffer ans=new StringBuffer();
    StringTokenizer st ;
    BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
    st=new StringTokenizer(f.readLine());
    int n=Integer.parseInt(st.nextToken());
    int m=Integer.parseInt(st.nextToken());
    int[] arr=new int[n];
    st=new StringTokenizer(f.readLine());
    for(int i=0 ; i<n ; i++){
      arr[i]=Integer.parseInt(st.nextToken());
    }
    for(int i=0 ; i<m ; i++){
      st=new StringTokenizer(f.readLine());
      int ft=Integer.parseInt(st.nextToken())-1 ;
      int sc=Integer.parseInt(st.nextToken())-1 ;
      int k=Integer.parseInt(st.nextToken())-1 ;
      boolean flag=false ;
      int r=0 ;
      int curr=0 ;
      for(int x=ft ; x<=sc ; x++){
        if(x<k && arr[x]>arr[k])r++;
        else if(x>k && arr[x]<arr[k])curr++;
      }
      if(curr==r){
        ans.append("Yes");
      }
      else {
        ans.append("No");
      }
      ans.append("\n");
    }
    f.close();
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B811 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ans : String ; ans := StringLib.newString() ;
     var st : OclIterator ;
    var f : OclFile ; f := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    st := OclIterator.newOclIterator_String(f.readLine()) ; 
    var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    st := OclIterator.newOclIterator_String(f.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     st := OclIterator.newOclIterator_String(f.readLine()) ; 
     var ft : int ; ft := (st.next())->toInteger() - 1 ;
    var sc : int ; sc := (st.next())->toInteger() - 1 ;
    var k : int ; k := (st.next())->toInteger() - 1 ;
    var flag : boolean ; flag := false ;
    var r : int ; r := 0 ;
    var curr : int ; curr := 0 ;
        var x : int ; x := ft ; while x <= sc do ( (     if (x < k & arr[x+1] > arr[k+1]) then     r := r + 1 ; else     if (x > k & arr[x+1] < arr[k+1]) then     curr := curr + 1 ; else skip ; )  ;     x := x + 1 ) ; 
    if (curr = r) then (     ans := ans + StringLib.newString("Yes") ) else (     ans := ans + StringLib.newString("No") ) ;  
    ans := ans + StringLib.newString("\n") ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int a=scan.nextInt();
    long w=0,h=0 ;
    int d[]=new int[a];
    int e[]=new int[a];
    int count=0 ;
    for(int i=0 ; i<a ; i++){
      d[i]=scan.nextInt();
    }
    Arrays.sort(d);
    for(int i=0 ; i<a ; i++){
      e[i]=d[a-i-1];
    }
    for(int i=1 ; i<a ; i++){
      if(e[i]==e[i-1]){
        i++;
        if(count==0){
          w=e[i-1];
          count++;
        }
        else {
          h=e[i-1];
          break ;
        }
      }
    }
    System.out.println(w*h);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
    var w : long ; w := 0 ;
    var h : long ; h := 0 ;
    var d : Sequence(int) ; d := Integer.subrange(1,a)->collect(0) ;
    var e : Sequence(int) ; e := Integer.subrange(1,a)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < a do ( (     d[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    d := d->sort() ; 
        var i : int ; i := 0 ; while i < a do ( (     e[i+1] := d[a - i - 1+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < a do ( (     if (e[i+1] = e[i - 1+1]) then (     i := i + 1 ; 
     if (count = 0) then (     w := e[i - 1+1] ; 
     count := count + 1 ) else (     h := e[i - 1+1] ; 
     break ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(w * h) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  private static final int MOD=1_000_000_007 ;
  private static final String YES="Yes" ;
  private static final String NO="No" ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[] A=new long[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
    }
    System.out.println(solve(N,A));
  }
  private static long solve(int N,long[] A){
    long area=0 ;
    Arrays.sort(A);
    for(int i=N-2 ; i>=0 ; i--){
      if(A[i]==A[i+1]){
        if(area==0){
          area=A[i];
          i-=1 ;
        }
        else {
          area*=A[i];
          return area ;
        }
      }
    }
    return 0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 1_000_000_007;
  static    attribute YES : String := "Yes";
  static    attribute NO : String := "No";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(N, A)) ; 
 );
  static   operation solve( N : int, A : Sequence(long)) : long
  pre: true
  post: true
  activity: (     var area : long ; area := 0 ;
     A := A->sort() ; 
         var i : int ; i := N - 2 ; while i >= 0 do ( (     if (A[i+1] = A[i + 1+1]) then (     if (area = 0) then (     area := A[i+1] ; 
     i := i-(1) ) else (     area := area*(A[i+1]) ; 
     return area ) ) else skip )  ;     i := i - 1 ) ; 
     return 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static int solve(int n){
    int bound3=n/3 ;
    int bound2=n/2 ;
    int count2=bound2-bound3 ;
    int count1=n-bound2 ;
    return bound3*5+count2*3+count1 ;
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      System.out.println(solve(in.nextInt()));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( n : int) : int
  pre: true
  post: true
  activity: (     var bound3 : int ; bound3 := n / 3 ;
     var bound2 : int ; bound2 := n / 2 ;
    var count2 : int ; count2 := bound2 - bound3 ;
    var count1 : int ; count1 := n - bound2 ;
    return bound3 * 5 + count2 * 3 + count1 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     OclFile["System.out"].println(solve(in.getCurrent()->toInteger())) )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  public static void main(String arg[]){
    try(Scanner in=new Scanner(System.in)){
      int t=in.nextInt();
      while(t-->0){
        int n=in.nextInt();
        int ans=n+n/2*2+n/3*2 ;
        System.out.println(ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var ans : int ; ans := n + n / 2 * 2 + n / 3 * 2 ;
     OclFile["System.out"].println(ans) ) ;  ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class strangeThoughts {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t>0){
      int n=sc.nextInt();
      int ans=n+2*((n/2)+(n/3));
      System.out.println(ans);
      t--;
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class strangeThoughts {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var ans : int ; ans := n + 2 * ((n / 2) + (n / 3)) ;
     OclFile["System.out"].println(ans) ; 
     t := t - 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Arrays ;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long n=sc.nextLong();
      long ans=n+(n/2+n/3)*2 ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : long ; n := sc.getCurrent()->toLong() ;
     var ans : long ; ans := n + (n / 2 + n / 3) * 2 ;
     OclFile["System.out"].println(ans) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] perguntas=new int[1000];
    int index=0 ;
    if(n==1){
      System.out.println(0);
      System.out.println();
    }
    else {
      for(int i=2 ; i<=n ; i++){
        if(ehPrimo(i)){
          perguntas[index]=i ;
          index++;
          for(int j=2 ; j>0 ; j++){
            if(Math.pow(i,j)<=n){
              perguntas[index]=(int)Math.pow(i,j);
              index++;
            }
            else break ;
          }
        }
      }
      System.out.println(index);
      for(int i=0 ; i<index-1 ; i++)System.out.print(perguntas[i]+" ");
      System.out.println(perguntas[index-1]);
    }
    sc.close();
  }
  public static boolean ehPrimo(int x){
    boolean res=true ;
    for(int j=2 ; j<x ; j++){
      if(x % j==0){
        res=false ;
        break ;
      }
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var perguntas : Sequence(int) ; perguntas := Integer.subrange(1,1000)->collect(0) ;
    var index : int ; index := 0 ;
    if (n = 1) then (     OclFile["System.out"].println(0) ; 
     OclFile["System.out"].println() ) else (         var i : int ; i := 2 ; while i <= n do ( (     if (ehPrimo(i)) then (     perguntas[index+1] := i ; 
     index := index + 1 ; 
         var j : int ; j := 2 ; while j > 0 do ( (     if (i->pow(j) <= n) then (     perguntas[index+1] := i->pow(j)->oclAsType(int) ; 
     index := index + 1 ) else     break )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(index) ; 
         var i : int ; i := 0 ; while i < index - 1 do (     OclFile["System.out"].print(perguntas[i+1] + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(perguntas[index - 1+1]) ) ;  
    skip ; 
 );
  static   operation ehPrimo( x : int) : boolean
  pre: true
  post: true
  activity: (     var res : boolean ; res := true ;
         var j : int ; j := 2 ; while j < x do ( (     if (x mod j = 0) then (     res := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    AXORCircle solver=new AXORCircle();
    solver.solve(1,in,out);
    out.close();
  }
  static class AXORCircle {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int n=in.nextInt();
      int[] a=new int[n];
      boolean f=false ;
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      Arrays.sort(a);
      if(n % 3==0){
        int k=n/3 ;
        if(a[0]==a[k-1] && a[k]==a[2*k-1] && a[2*k]==a[3*k-1] &&(a[0] ^ a[k])==a[2*k])f=true ;
        if(a[k-1]==0 && a[k]>0 && a[k]==a[3*k-1])f=true ;
      }
      if(a[n-1]==0)f=true ;
      out.println(f ? "Yes" : "No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : AXORCircle ; solver := AXORCircle.newAXORCircle() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class AXORCircle {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var f : boolean ; f := false ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    if (n mod 3 = 0) then (     var k : int ; k := n / 3 ;
     if (a[0+1] = a[k - 1+1] & a[k+1] = a[2 * k - 1+1] & a[2 * k+1] = a[3 * k - 1+1] & (a[0+1] xor a[k+1]) = a[2 * k+1]) then     f := true ; else skip ; 
     if (a[k - 1+1] = 0 & a[k+1] > 0 & a[k+1] = a[3 * k - 1+1]) then     f := true ; else skip ) else skip ; 
    if (a[n - 1+1] = 0) then     f := true ; else skip ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    int n=nextInt();
    TreeSet<Integer>a=new TreeSet<>();
    for(int i=2 ; i<=n ; i++){
      if(prost(i)&& ! a.contains(i)){
        int j=i ;
        while(j<=n){
          a.add(j);
          j*=i ;
        }
      }
    }
    System.out.println(a.size());
    while(! a.isEmpty()){
      System.out.print(a.pollFirst()+" ");
    }
  }
  static boolean prost(int x){
    for(int i=2 ; i<=(int)Math.sqrt(x); i++){
      if(x % i==0)return false ;
    }
    return true ;
  }
  static BufferedReader br ;
  static StringTokenizer in=new StringTokenizer("");
  static String next()throws IOException {
    while(in==null || ! in.hasMoreTokens()){
      in=new StringTokenizer(br.readLine());
    }
    return in.nextToken();
  }
  static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := nextInt() ;
    var a : Set(int) ; a := Set{} ;
        var i : int ; i := 2 ; while i <= n do ( (     if (prost(i) & not(a->includes(i))) then (     var j : int ; j := i ;
     while (j <= n) do (     a := a->including(j) ; 
     j := j*(i) ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a->size()) ; 
    while (not(a->isEmpty())) do (     OclFile["System.out"].print(a->first() + " ") ) ; 
 );
  static   operation prost( x : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i <= (x)->sqrt()->oclAsType(int) do ( (     if (x mod i = 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   attribute br : OclFile;
  static   attribute in : OclIterator := OclIterator.newOclIterator_String("");
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (in = null or not(in.hasNext())) do (     in := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return in.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
public class VasyaPetyaGame {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int seive[]=new int[n+1];
    if(n==1){
      System.out.println("0");
      return ;
    }
    ArrayList<Integer>primes=new ArrayList<>();
    for(int i=2 ; i<=n ; i++){
      if(seive[i]==0){
        for(int j=2*i ; j<=n ; j+=i){
          seive[j]=1 ;
        }
        primes.add(i);
      }
    }
    StringBuilder ans=new StringBuilder();
    long temp=0 ;
    for(int i=0 ; i<primes.size(); i++){
      int prime=primes.get(i);
      while(prime<=n){
        temp++;
        ans.append(prime+" ");
        prime*=primes.get(i);
      }
    }
    System.out.println(temp);
    System.out.println(ans.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class VasyaPetyaGame {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var seive : Sequence(int) ; seive := Integer.subrange(1,n + 1)->collect(0) ;
    if (n = 1) then (     OclFile["System.out"].println("0") ; 
     return ) else skip ; 
    var primes : Sequence(int) ; primes := Sequence{} ;
        var i : int ; i := 2 ; while i <= n do ( (     if (seive[i+1] = 0) then (         var j : int ; j := 2 * i ; while j <= n do ( (     seive[j+1] := 1 )  ;     j := j+(i) ) ; 
     primes := primes->including(i) ) else skip )  ;     i := i + 1 ) ; 
    var ans : String ; ans := StringLib.newString() ;
    var temp : long ; temp := 0 ;
        var i : int ; i := 0 ; while i < primes->size() do ( (     var prime : int ; prime := primes->at(i+1) ;
     while (prime <= n) do (     temp := temp + 1 ; 
     ans := ans + StringLib.newString(prime + " ") ; 
     prime := prime*(primes->at(i+1)) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(temp) ; 
    OclFile["System.out"].println(ans+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int m=input.nextInt();
    int a[]=new int[n];
    StringBuilder ans=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      a[i]=input.nextInt();
    }
    for(int i=0 ; i<m ; i++){
      int l=input.nextInt();
      int r=input.nextInt();
      int x=input.nextInt();
      int count=0 ;
      for(int j=l ; j<=r ; j++){
        if(a[j-1]<a[x-1])count++;
      }
      if(count==x-l)ans.append("Yes\n");
      else ans.append("No\n");
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var m : int ; m := input.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var ans : String ; ans := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var l : int ; l := input.getCurrent()->toInteger() ;
     var r : int ; r := input.getCurrent()->toInteger() ;
    var x : int ; x := input.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
        var j : int ; j := l ; while j <= r do ( (     if (a[j - 1+1] < a[x - 1+1]) then     count := count + 1 ; else skip )  ;     j := j + 1 ) ; 
    if (count = x - l) then     ans := ans + StringLib.newString("Yes\n") else     ans := ans + StringLib.newString("No\n") ; ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args){
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
    String s ;
    int w ;
    int todayfee ;
    try {
      while((s=r.readLine())!=null){
        w=Integer.parseInt(s);
        if(w==-1){
          break ;
        }
        if(w<=10){
          todayfee=1150 ;
        }
        else if(w>10 && w<=20){
          todayfee=1150+125*(w-10);
        }
        else if(w>20 && w<=30){
          todayfee=1150+125*10+140*(w-20);
        }
        else {
          todayfee=1150+1250+1400+160*(w-30);
        }
        System.out.println(4280-todayfee);
      }
    }
    catch(IOException e){
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ;
    var w : int ;
    var todayfee : int ;
    try (         s := r.readLine() ;
    while ((s) /= null) do (    skip ; (     w := (s)->toInteger() ; 
     if (w = -1) then (     break ) else skip ; 
     if (w <= 10) then (     todayfee := 1150 ) else     if (w > 10 & w <= 20) then (     todayfee := 1150 + 125 * ((w)->char2byte() - 10) ) else     if (w > 20 & w <= 30) then (     todayfee := 1150 + 125 * 10 + 140 * ((w)->char2byte() - 20) ) else (     todayfee := 1150 + 1250 + 1400 + 160 * ((w)->char2byte() - 30) ) ;  ;  ;  
     OclFile["System.out"].println(4280 - todayfee) ) ;     s := r.readLine() ;
 ) )   catch (e : IOException) do (     OclFile["System.out"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    for(; ; ){
      int w=sc.nextInt();
      if(w==-1){
        break ;
      }
      int sum=0 ;
      if(w>30){
        sum+=160*(w-30);
        w=30 ;
      }
      if(w>20){
        sum+=140*(w-20);
        w=20 ;
      }
      if(w>10){
        sum+=125*(w-10);
        w=10 ;
      }
      sum+=1150 ;
      println(""+(4280-sum));
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  void print(String s){
    System.out.print(s);
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var w : int ; w := sc.getCurrent()->toInteger() ;
     if (w = -1) then (     break ) else skip ; 
    var sum : int ; sum := 0 ;
    if (w > 30) then (     sum := sum+(160 * (w - 30)) ; 
     w := 30 ) else skip ; 
    if (w > 20) then (     sum := sum+(140 * (w - 20)) ; 
     w := 20 ) else skip ; 
    if (w > 10) then (     sum := sum+(125 * (w - 10)) ; 
     w := 10 ) else skip ; 
    sum := sum+(1150) ; 
    execute println("" + (4280 - sum)) ; 
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   operation print( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(s) );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    final int l=4280 ;
    while(!(line=br.readLine()).equals("-1")){
      int w=Integer.parseInt(line);
      int t=1150 ;
      if(w>10)t+=(w-10)*125 ;
      if(w>20)t+=(w-20)*15 ;
      if(w>30)t+=(w-30)*20 ;
      System.out.println(l-t);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
     var l : int ; l := 4280 ;
     while (not((line) = "-1")) do (     var w : int ; w := (line)->toInteger() ;
     var t : int ; t := 1150 ;
    if (w > 10) then     t := t+((w - 10) * 125) ; else skip ; 
    if (w > 20) then     t := t+((w - 20) * 15) ; else skip ; 
    if (w > 30) then     t := t+((w - 30) * 20) ; else skip ; 
    OclFile["System.out"].println((l)->char2byte() - t) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int w ;
    for(; ; out.println(-solve(w)+4280)){
      w=sc.nextInt();
      if(w==-1)break ;
    }
    sc.close();
  }
  private static int solve(int w){
    int res=0 ;
    if(w<10)return 1150 ;
    res+=1150 ;
    w-=10 ;
    if(w<10)return(res+125*w);
    res+=1250 ;
    w-=10 ;
    if(w<10)return(res+140*w);
    res+=1400 ;
    w-=10 ;
    return(res+160*w);
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var w : int ;
       while true do ( (     w := sc.nextInt() ; 
     if (w = -1) then     break else skip )  ;     out.println(-solve(w) + 4280) ) ; 
     sc.close() );
  static   operation solve( w : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     if (w < 10) then     return 1150 else skip ; 
    res := res+(1150) ; 
    w := w-(10) ; 
    if (w < 10) then     return (res + 125 * w) else skip ; 
    res := res+(1250) ; 
    w := w-(10) ; 
    if (w < 10) then     return (res + 140 * w) else skip ; 
    res := res+(1400) ; 
    w := w-(10) ; 
    return (res + 160 * w) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  static int countWays(int n){
    int count=0 ;
    for(int i=1 ; i*i<n ; i++)if(n % i==0)count++;
    return count ;
  }
  public static void main(String[] args){
    int n=12 ;
    System.out.println(countWays(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation countWays( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i * i < n do (     if (n mod i = 0) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 12 ;
     OclFile["System.out"].println(countWays(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=26 ;
  static boolean targetstring(String str1,String str2){
    int l1=str1.length();
    int l2=str2.length();
    if(l1!=l2)return false ;
    int[] map=new int[MAX];
    for(int i=0 ; i<l1 ; i++)map[str1.charAt(i)-'a']++;
    for(int i=0 ; i<l2 ; i++){
      map[str2.charAt(i)-'a']--;
      if(map[str2.charAt(i)-'a']<0)return false ;
    }
    return true ;
  }
  public static void main(String args[]){
    String str1="geeksforgeeks" ;
    String str2="geegeeksksfor" ;
    if(targetstring(str1,str2))System.out.print("YES");
    else System.out.print("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 26;
  static   operation targetstring( str1 : String, str2 : String) : boolean
  pre: true
  post: true
  activity: (     var l1 : int ; l1 := str1->size() ;
     var l2 : int ; l2 := str2->size() ;
    if (l1 /= l2) then     return false else skip ; 
    var map : Sequence(int) ; map := Integer.subrange(1,MAX)->collect(0) ;
        var i : int ; i := 0 ; while i < l1 do (     map[str1->at(i+1) - ('a')->char2byte()+1] := map[str1->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < l2 do ( (     map[str2->at(i+1) - ('a')->char2byte()+1] := map[str2->at(i+1) - ('a')->char2byte()+1] - 1 ; 
     if (map[str2->at(i+1) - ('a')->char2byte()+1] < 0) then     return false else skip )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := "geeksforgeeks" ;
     var str2 : String ; str2 := "geegeeksksfor" ;
     if (targetstring(str1, str2)) then     OclFile["System.out"].print("YES") ; else     OclFile["System.out"].print("NO") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Diagonals {
  static int numberOfDiagonals(int n){
    return n*(n-3)/2 ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.print(n+" sided convex polygon have ");
    System.out.println(numberOfDiagonals(n)+" diagonals");
  }
}
------------------------------------------------------------
OCL File:
---------
class Diagonals {
  static   operation numberOfDiagonals( n : int) : int
  pre: true
  post: true
  activity: (     return n * (n - 3) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].print(n + " sided convex polygon have ") ; 
     OclFile["System.out"].println(numberOfDiagonals(n) + " diagonals") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    MyReader r=new MyReader();
    int N=r.i();
    String[] s=r.ss();
    int b=0 ;
    for(String a : s)b ^=Int(a);
    println(b==0 ? "Yes" : "No");
  }
  static void print(Object o){
    System.out.print(o.toString());
  }
  static void println(Object o){
    System.out.println(o.toString());
  }
  static int Int(String s){
    return Integer.parseInt(s);
  }
  static long Long(String s){
    return Long.parseLong(s);
  }
  static class MyReader extends BufferedReader {
    MyReader(){
      super(new InputStreamReader(System.in));
    }
    String s()throws IOException {
      return readLine();
    }
    String[] ss()throws IOException {
      return s().split(" ");
    }
    int i()throws IOException {
      return Int(s());
    }
    int[] ii()throws IOException {
      String[] ss=ss();
      int size=ss.length ;
      int[] ii=new int[size];
      for(int j=0 ; j<size ; j++)ii[j]=Integer.parseInt(ss[j]);
      return ii ;
    }
    long l()throws IOException {
      return Long(s());
    }
    long[] ll()throws IOException {
      String[] ss=ss();
      int size=ss.length ;
      long[] ll=new long[size];
      for(int j=0 ; j<size ; j++)ll[j]=Long.parseLong(ss[j]);
      return ll ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : MyReader ; r := MyReader.newMyReader() ;
     var N : int ; N := r.i() ;
    var s : Sequence(String) ; s := r.ss() ;
    var b : int ; b := 0 ;
    for (a : s) do (     b := MathLib.bitwiseXor(b,Int(a)) ;  ) ; 
    execute println(if b = 0 then "Yes" else "No" endif) ; 
 );
  static   operation print( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o+"") );
  static   operation println( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o+"") );
  static   operation Int( s : String) : int
  pre: true
  post: true
  activity: (     return (s)->toInteger() );
  static   operation Long( s : String) : long
  pre: true
  post: true
  activity: (     return (s)->toLong() );
  static class MyReader extends OclFile {
   static operation newMyReader() : MyReader
  pre: true
  post: true
  activity:
  ( var self : MyReader ;
    self := createMyReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation s() : String
  pre: true
  post: true
  activity: (     return readLine() );
   operation ss() : Sequence(String)
  pre: true
  post: true
  activity: (     return s()->split(" ") );
   operation i() : int
  pre: true
  post: true
  activity: (     return Int(s()) );
   operation ii() : Sequence(int)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var size : int ; size := ss->size() ;
    var ii : Sequence(int) ; ii := Integer.subrange(1,size)->collect(0) ;
        var j : int ; j := 0 ; while j < size do (     ii[j+1] := (ss[j+1])->toInteger() ;  ;     j := j + 1 ) ; 
    return ii 
 );
   operation l() : long
  pre: true
  post: true
  activity: (     return Long(s()) );
   operation ll() : Sequence(long)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var size : int ; size := ss->size() ;
    var ll : Sequence(long) ; ll := Integer.subrange(1,size)->collect(0) ;
        var j : int ; j := 0 ; while j < size do (     ll[j+1] := (ss[j+1])->toLong() ;  ;     j := j + 1 ) ; 
    return ll 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    solver();
  }
  static void solver(){
    Scanner sc=new Scanner(System.in);
    long s=sc.nextLong();
    long l=0 ;
    long r=200000000000000000L ;
    ;
    while(r-l>1){
      long mid=(l+r)/2 ;
      if(calc(mid)>=s)r=mid ;
      else l=mid ;
    }
    StringBuilder sb=new StringBuilder("");
    for(int i=0 ; i<25 ; i++){
      long ns=l+i+1 ;
      if(ns % 15==0){
        sb.append("FizzBuzz");
      }
      else if(ns % 3==0){
        sb.append("Fizz");
      }
      else if(ns % 5==0){
        sb.append("Buzz");
      }
      else {
        sb.append(ns);
      }
    }
    System.out.println(sb.toString().substring((int)(s-calc(l)-1),20+(int)(s-calc(l)-1)));
  }
  static long calc(long a){
    long ret=a/3*4+a/5*4 ;
    long l=0 ;
    for(long p=1 ; a>=p ; p*=10){
      l++;
      long R=Math.min(a,p*10-1);
      long L=p-1 ;
      ret+=((R-R/3-R/5+R/15)-(L-L/3-L/5+L/15))*l ;
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solver() );
  static   operation solver() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : long ; s := sc.getCurrent()->toLong() ;
    var l : long ; l := 0 ;
    var r : long ; r := 200000000000000000L ;
    while (r - l > 1) do (     var mid : long ; mid := (l + r) / 2 ;
     if (calc(mid) >= s) then     r := mid ; else     l := mid ; ) ; 
    var sb : String ; sb := StringLib.newString("") ;
        var i : int ; i := 0 ; while i < 25 do ( (     var ns : long ; ns := l + i + 1 ;
     if (ns mod 15 = 0) then (     sb := sb + StringLib.newString("FizzBuzz") ) else     if (ns mod 3 = 0) then (     sb := sb + StringLib.newString("Fizz") ) else     if (ns mod 5 = 0) then (     sb := sb + StringLib.newString("Buzz") ) else (     sb := sb + StringLib.newString(ns) ) ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"".subrange((s - calc(l) - 1)->oclAsType(int)+1,20 + (s - calc(l) - 1)->oclAsType(int))) ; 
 );
  static   operation calc( a : long) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := a / 3 * 4 + a / 5 * 4 ;
     var l : long ; l := 0 ;
         var p : long ; p := 1 ; while a >= p do ( (     l := l + 1 ; 
     var R : long ; R := Set{a, p * 10 - 1}->min() ;
     var L : long ; L := p - 1 ;
     ret := ret+(((R - R / 3 - R / 5 + R / 15) - (L - L / 3 - L / 5 + L / 15)) * l) )  ;     p := p*(10) ) ; 
     return ret );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int msb(int x){
    int ret=0 ;
    while((x>>(ret+1))!=0)ret++;
    return ret ;
  }
  static int xorRange(int l,int r){
    int max_bit=msb(r);
    int mul=2 ;
    int ans=0 ;
    for(int i=1 ; i<=max_bit ; i++){
      if((l/mul)*mul==(r/mul)*mul){
        if(((l &(1<<i))!=0)&&(r-l+1)% 2==1)ans+=mul ;
        mul*=2 ;
        continue ;
      }
      int odd_c=0 ;
      if(((l &(1<<i))!=0)&& l % 2==1)odd_c=(odd_c ^ 1);
      if(((r &(1<<i))!=0)&& r % 2==0)odd_c=(odd_c ^ 1);
      if(odd_c!=0)ans+=mul ;
      mul*=2 ;
    }
    int zero_bit_cnt=zero_bit_cnt=(r-l+1)/2 ;
    if(l % 2==1 && r % 2==1)zero_bit_cnt++;
    if(zero_bit_cnt % 2==1)ans++;
    return ans ;
  }
  public static void main(String args[]){
    int l=1,r=4 ;
    System.out.print(xorRange(l,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation msb( x : int) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := 0 ;
     while (((x/(2->pow((ret + 1))))->oclAsType(long)) /= 0) do     ret := ret + 1 ; ; 
     return ret );
  static   operation xorRange( l : int, r : int) : int
  pre: true
  post: true
  activity: (     var max_bit : int ; max_bit := msb(r) ;
     var mul : int ; mul := 2 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= max_bit do ( (     if ((l / mul) * mul = (r / mul) * mul) then (     if (((l & ((1*(2->pow(i)))->oclAsType(long))) /= 0) & (r - l + 1) mod 2 = 1) then     ans := ans+(mul) ; else skip ; 
     mul := mul*(2) ; 
     continue ) else skip ; 
     var odd_c : int ; odd_c := 0 ;
    if (((l & ((1*(2->pow(i)))->oclAsType(long))) /= 0) & l mod 2 = 1) then     odd_c := (MathLib.bitwiseXor(odd_c,1)) ; else skip ; 
    if (((r & ((1*(2->pow(i)))->oclAsType(long))) /= 0) & r mod 2 = 0) then     odd_c := (MathLib.bitwiseXor(odd_c,1)) ; else skip ; 
    if (odd_c /= 0) then     ans := ans+(mul) ; else skip ; 
    mul := mul*(2) ; 
 )  ;     i := i + 1 ) ; 
    var zero_bit_cnt : int ;     zero_bit_cnt := (r - l + 1) / 2 ;
zero_bit_cnt := zero_bit_cnt ;
    if (l mod 2 = 1 & r mod 2 = 1) then     zero_bit_cnt := zero_bit_cnt + 1 ; else skip ; 
    if (zero_bit_cnt mod 2 = 1) then     ans := ans + 1 ; else skip ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var l : int ; l := 1 ;
    var r : int ; r := 4 ;
     OclFile["System.out"].print(xorRange(l, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void mul_table(int N,int i){
    if(i>10)return ;
    System.out.println(N+"*"+i+"="+N*i);
    mul_table(N,i+1);
  }
  public static void main(String[] args){
    int N=8 ;
    mul_table(N,1);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation mul_table( N : int, i : int) : void
  pre: true
  post: true
  activity: (     if (i > 10) then     return else skip ; 
     OclFile["System.out"].println(N + "*" + i + "=" + N * i) ; 
     execute mul_table(N, i + 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 8 ;
     execute mul_table(N, 1) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long s=sc.nextLong();
    long left=0 ;
    long right=(long)1e17 ;
    while(left+1<right){
      long c=(left+right)>>>1 ;
      if(length(c)<s){
        left=c ;
      }
      else {
        right=c ;
      }
    }
    int begin=(int)(s-length(left)-1);
    System.out.println(fizzbuzzFrom(left+1,20).substring(begin,begin+20));
  }
  public static long length(long x){
    long sum=(x/3+x/5)*4 ;
    long min=1 ;
    for(int i=0 ; i<18 ; i++){
      if(x<min)break ;
      long max=Math.min(x,min*10-1);
      long nonFizzBuzz=nonFizzBuzz(max)-nonFizzBuzz(min-1);
      sum+=nonFizzBuzz*(i+1);
      min*=10 ;
    }
    return sum ;
  }
  public static String fizzbuzzFrom(long x,int n){
    StringBuilder sb=new StringBuilder();
    for(long i=x ; i<x+n ; i++){
      if(x==0)continue ;
      if(i % 15==0){
        sb.append("FizzBuzz");
      }
      else if(i % 3==0){
        sb.append("Fizz");
      }
      else if(i % 5==0){
        sb.append("Buzz");
      }
      else {
        sb.append(i);
      }
    }
    return sb.toString();
  }
  public static long nonFizzBuzz(long x){
    return x-(x/3+x/5-x/15);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : long ; s := sc.getCurrent()->toLong() ;
    var left : long ; left := 0 ;
    var right : long ; right := 1e17->oclAsType(long) ;
    while (left + 1 < right) do (     var c : long ; c := ((left + right)/(2->pow(1)))->oclAsType(long) ;
     if (length(c) < s) then (     left := c ) else (     right := c ) ) ; 
    var begin : int ; begin := (s - length(left) - 1)->oclAsType(int) ;
    OclFile["System.out"].println(fizzbuzzFrom(left + 1, 20).subrange(begin+1,begin + 20)) ; 
 );
  static   operation length( x : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := (x / 3 + x / 5) * 4 ;
     var min : long ; min := 1 ;
         var i : int ; i := 0 ; while i < 18 do ( (     if (x < min) then     break else skip ; 
     var max : long ; max := Set{x, min * 10 - 1}->min() ;
    var nonFizzBuzz : long ; nonFizzBuzz := nonFizzBuzz(max) - nonFizzBuzz(min - 1) ;
    sum := sum+(nonFizzBuzz * (i + 1)) ; 
    min := min*(10) ; 
 )  ;     i := i + 1 ) ; 
     return sum );
  static   operation fizzbuzzFrom( x : long, n : int) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : long ; i := x ; while i < x + n do ( (     if (x = 0) then     continue else skip ; 
     if (i mod 15 = 0) then (     sb := sb + StringLib.newString("FizzBuzz") ) else     if (i mod 3 = 0) then (     sb := sb + StringLib.newString("Fizz") ) else     if (i mod 5 = 0) then (     sb := sb + StringLib.newString("Buzz") ) else (     sb := sb + StringLib.newString(i) ) ;  ;  )  ;     i := i + 1 ) ; 
     return sb+"" );
  static   operation nonFizzBuzz( x : long) : long
  pre: true
  post: true
  activity: (     return x - (x / 3 + x / 5 - x / 15) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  long n ;
  void run(){
    n=sc.nextLong();
    solve();
  }
  void solve(){
    long left=0,right=(long)1e17 ;
    for(; left<right-1 ; ){
      long mid=(left+right)/2 ;
      if(length(mid)<n){
        left=mid ;
      }
      else {
        right=mid ;
      }
    }
    int margin=(int)(n-length(right-1)-1);
    String ans="" ;
    for(int i=0 ; i<20 ; i++){
      ans+=fizzBuzz(right+i);
    }
    println(ans.substring(margin,margin+20));
  }
  long length(long n){
    long length=0 ;
    long b=1 ;
    for(int i=1 ; i<=18 ; i++){
      long left=b-1,right=min(b*10-1,n);
      if(left>=right){
        break ;
      }
      long nFizz=right/3-left/3 ;
      long nBuzz=right/5-left/5 ;
      long nFizzBuzz=right/15-left/15 ;
      long nString=nFizz+nBuzz-nFizzBuzz ;
      length+=(right-left-nString)*i+nFizz*4+nBuzz*4 ;
      b*=10 ;
    }
    return length ;
  }
  String fizzBuzz(long n){
    if(n % 15==0){
      return "FizzBuzz" ;
    }
    else if(n % 3==0){
      return "Fizz" ;
    }
    else if(n % 5==0){
      return "Buzz" ;
    }
    else {
      return ""+n ;
    }
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute n : long;
   operation run() : void
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toLong() ; 
     execute solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var left : long ; left := 0 ;
    var right : long ; right := 1e17->oclAsType(long) ;
       while left < right - 1 do ( (     var mid : long ; mid := (left + right) / 2 ;
     if (length(mid) < n) then (     left := mid ) else (     right := mid ) )  ) ; 
    var margin : int ; margin := (n - length(right - 1) - 1)->oclAsType(int) ;
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < 20 do ( (     ans := ans+(fizzBuzz(right + i)) )  ;     i := i + 1 ) ; 
    execute println(ans.subrange(margin+1,margin + 20)) ; 
 );
   operation length( n : long) : long
  pre: true
  post: true
  activity: (     var length : long ; length := 0 ;
     var b : long ; b := 1 ;
         var i : int ; i := 1 ; while i <= 18 do ( (     var left : long ; left := b - 1 ;
    var right : long ; right := min(b * 10 - 1, n) ;
     if (left >= right) then (     break ) else skip ; 
    var nFizz : long ; nFizz := right / 3 - left / 3 ;
    var nBuzz : long ; nBuzz := right / 5 - left / 5 ;
    var nFizzBuzz : long ; nFizzBuzz := right / 15 - left / 15 ;
    var nString : long ; nString := nFizz + nBuzz - nFizzBuzz ;
    length := length+((right - left - nString) * i + nFizz * 4 + nBuzz * 4) ; 
    b := b*(10) ; 
 )  ;     i := i + 1 ) ; 
     return length );
   operation fizzBuzz( n : long) : String
  pre: true
  post: true
  activity: (     if (n mod 15 = 0) then (     return "FizzBuzz" ) else     if (n mod 3 = 0) then (     return "Fizz" ) else     if (n mod 5 = 0) then (     return "Buzz" ) else (     return "" + n ) ;  ;  );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static long calc(long a){
    long ret=a/3*4+a/5*4 ;
    int l=0 ;
    for(long p=1 ; a>=p ; p*=10){
      l++;
      long R=Math.min(a,p*10);
      long L=p-1 ;
      ret+=((R-R/3-R/5+R/15)-(L-L/3-L/5+L/15))*l ;
    }
    return ret ;
  }
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    long a=s.nextLong();
    long left=0L ;
    long right=200000000000000000L ;
    while(left+1<right){
      long M=(left+right)/2 ;
      if(calc(M)>=a)right=M ;
      else left=M ;
    }
    String str="" ;
    long M=left ;
    for(int i=1 ; i<20 ; i++){
      if((M+i)% 15==0)str+="FizzBuzz" ;
      else if((M+i)% 3==0)str+="Fizz" ;
      else if((M+i)% 5==0)str+="Buzz" ;
      else str+=""+(M+i);
    }
    int ss=(int)(a-calc(M)-1);
    String ret="" ;
    for(int i=0 ; i<20 ; i++)ret+=str.charAt(i+ss);
    System.out.println(ret);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation calc( a : long) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := a / 3 * 4 + a / 5 * 4 ;
     var l : int ; l := 0 ;
         var p : long ; p := 1 ; while a >= p do ( (     l := l + 1 ; 
     var R : long ; R := Set{a, p * 10}->min() ;
     var L : long ; L := p - 1 ;
     ret := ret+(((R - R / 3 - R / 5 + R / 15) - (L - L / 3 - L / 5 + L / 15)) * l) )  ;     p := p*(10) ) ; 
     return ret );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := s.getCurrent()->toLong() ;
    var left : long ; left := 0L ;
    var right : long ; right := 200000000000000000L ;
    while (left + 1 < right) do (     var M : long ; M := (left + right) / 2 ;
     if (calc(M) >= a) then     right := M ; else     left := M ; ) ; 
    var str : String ; str := "" ;
    var M : long ; M := left ;
        var i : int ; i := 1 ; while i < 20 do ( (     if ((M + i) mod 15 = 0) then     str := str+("FizzBuzz") ; else     if ((M + i) mod 3 = 0) then     str := str+("Fizz") else     if ((M + i) mod 5 = 0) then     str := str+("Buzz") else     str := str+("" + (M + i)) ; ;  ;  )  ;     i := i + 1 ) ; 
    var ss : int ; ss := (a - calc(M) - 1)->oclAsType(int) ;
    var ret : String ; ret := "" ;
        var i : int ; i := 0 ; while i < 20 do (     ret := ret+(str->at(i + ss+1)) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ret) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    long S=sc.nextLong()-1 ;
    long sum=0 ;
    long left=0 ;
    long right=100000000000000000L ;
    while(sum<S-1000){
      long m=(left+right)/2 ;
      long ms=count(m);
      if(ms<=S){
        sum=ms ;
        left=m ;
      }
      else {
        right=m ;
      }
    }
    StringBuilder sb=new StringBuilder();
    for(long i=left+1 ; sb.length()<S-sum+20 ; ++i){
      boolean d3=i % 3==0 ;
      boolean d5=i % 5==0 ;
      if(d3){
        sb.append(d5 ? "FizzBuzz" : "Fizz");
      }
      else {
        sb.append(d5 ? "Buzz" : ""+i);
      }
    }
    System.out.println(sb.toString().substring((int)(S-sum),(int)(S-sum+20)));
  }
  static long count(long max){
    long sum=0 ;
    long base=10 ;
    while(base-1<=max){
      sum+=count(base/10,base-1);
      base*=10 ;
    }
    sum+=count(base/10,max);
    return sum ;
  }
  static long count(long min,long max){
    long c3=max/3-(min-1)/3 ;
    long c5=max/5-(min-1)/5 ;
    long c15=max/15-(min-1)/15 ;
    long all=c3+c5-c15 ;
    return(""+min).length()*(max-min+1-all)+(c3+c5)*4 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := sc.getCurrent()->toLong() - 1 ;
     var sum : long ; sum := 0 ;
    var left : long ; left := 0 ;
    var right : long ; right := 100000000000000000L ;
    while (sum < S - 1000) do (     var m : long ; m := (left + right) / 2 ;
     var ms : long ; ms := count(m) ;
     if (ms <= S) then (     sum := ms ; 
     left := m ) else (     right := m ) ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : long ; i := left + 1 ; while sb->size() < S - sum + 20 do ( (     var d3 : boolean ; d3 := i mod 3 = 0 ;
     var d5 : boolean ; d5 := i mod 5 = 0 ;
     if (d3) then (     sb := sb + StringLib.newString(if d5 then "FizzBuzz" else "Fizz" endif) ) else (     sb := sb + StringLib.newString(if d5 then "Buzz" else "" + i endif) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"".subrange((S - sum)->oclAsType(int)+1,(S - sum + 20)->oclAsType(int))) ; 
 );
  static   operation count( max : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     var base : long ; base := 10 ;
    while (base - 1 <= max) do (     sum := sum+(count(base / 10, base - 1)) ; 
     base := base*(10) ) ; 
    sum := sum+(count(base / 10, max)) ; 
    return sum 
 );
  static   operation count( min : long, max : long) : long
  pre: true
  post: true
  activity: (     var c3 : long ; c3 := max / 3 - (min - 1) / 3 ;
     var c5 : long ; c5 := max / 5 - (min - 1) / 5 ;
    var c15 : long ; c15 := max / 15 - (min - 1) / 15 ;
    var all : long ; all := c3 + c5 - c15 ;
    return ("" + min)->size() * (max - min + 1 - all) + (c3 + c5) * 4 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class program {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int x=sc.nextInt();
    int y=sc.nextInt();
    int a[]=new int[n];
    int b[]=new int[m];
    ArrayList<Integer>arr1=new ArrayList<Integer>();
    ArrayList<Integer>arr2=new ArrayList<Integer>();
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    for(int i=0 ; i<m ; i++)b[i]=sc.nextInt();
    int i=0 ;
    int j=0 ;
    while(i<n && j<m){
      int x1=a[i];
      int y1=a[i]-x ;
      int z1=a[i]+y ;
      int arr=b[j];
      if(arr<y1)j++;
      else if(arr>=y1 && arr<=z1){
        arr1.add(i+1);
        arr2.add(j+1);
        i++;
        j++;
      }
      else i++;
    }
    System.out.println(arr1.size());
    for(int k=0 ; k<arr1.size(); k++)System.out.println(arr1.get(k)+" "+arr2.get(k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class program {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,m)->collect(0) ;
    var arr1 : Sequence(int) ; arr1 := Sequence{} ;
    var arr2 : Sequence(int) ; arr2 := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     b[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    while (i < n & j < m) do (     var x1 : int ; x1 := a[i+1] ;
     var y1 : int ; y1 := a[i+1] - x ;
    var z1 : int ; z1 := a[i+1] + y ;
    var arr : int ; arr := b[j+1] ;
    if (arr < y1) then     j := j + 1 else     if (arr >= y1 & arr <= z1) then (     arr1 := arr1->including(i + 1) ; 
     arr2 := arr2->including(j + 1) ; 
     i := i + 1 ; 
     j := j + 1 ) else     i := i + 1 ; ;  ;  
 ) ; 
    OclFile["System.out"].println(arr1->size()) ; 
        var k : int ; k := 0 ; while k < arr1->size() do (     OclFile["System.out"].println(arr1->at(k+1) + " " + arr2->at(k+1)) ;  ;     k := k + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BigO1804 {
  public static void main(String[] args){
    Scanner UserInput=new Scanner(System.in);
    int numS=UserInput.nextInt();
    int numV=UserInput.nextInt();
    int x=UserInput.nextInt();
    int y=UserInput.nextInt();
    int[] listS=new int[numS];
    int[] listV=new int[numV];
    for(int i=0 ; i<numS ; i++){
      listS[i]=UserInput.nextInt();
    }
    for(int i=0 ; i<numV ; i++){
      listV[i]=UserInput.nextInt();
    }
    int v=0 ;
    int s=0 ;
    int maxP=Math.min(numS,numV);
    int[] listS2=new int[maxP];
    int countS2=0 ;
    int[] listV2=new int[maxP];
    int countV2=0 ;
    while(s<numS && v<numV){
      if(listV[v]>=listS[s]-x && listV[v]<=listS[s]+y){
        listS2[countS2++]=s+++1 ;
        listV2[countV2++]=v+++1 ;
      }
      else if(listV[v]<listS[s]-x)v++;
      else if(listV[v]>listS[s]+y)s++;
    }
    System.out.println(countS2);
    for(int i=0 ; i<countS2 ; i++){
      System.out.print(listS2[i]+" "+listV2[i]+"\n");
    }
    UserInput.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class BigO1804 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var UserInput : OclFile ; UserInput := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numS : int ; numS := UserInput.getCurrent()->toInteger() ;
    var numV : int ; numV := UserInput.getCurrent()->toInteger() ;
    var x : int ; x := UserInput.getCurrent()->toInteger() ;
    var y : int ; y := UserInput.getCurrent()->toInteger() ;
    var listS : Sequence(int) ; listS := Integer.subrange(1,numS)->collect(0) ;
    var listV : Sequence(int) ; listV := Integer.subrange(1,numV)->collect(0) ;
        var i : int ; i := 0 ; while i < numS do ( (     listS[i+1] := UserInput.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < numV do ( (     listV[i+1] := UserInput.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var v : int ; v := 0 ;
    var s : int ; s := 0 ;
    var maxP : int ; maxP := Set{numS, numV}->min() ;
    var listS2 : Sequence(int) ; listS2 := Integer.subrange(1,maxP)->collect(0) ;
    var countS2 : int ; countS2 := 0 ;
    var listV2 : Sequence(int) ; listV2 := Integer.subrange(1,maxP)->collect(0) ;
    var countV2 : int ; countV2 := 0 ;
    while (s < numS & v < numV) do (     if (listV[v+1] >= listS[s+1] - x & listV[v+1] <= listS[s+1] + y) then (       listS2[countS2+1] := s + 1  ; countS2 := countS2 + 1  ; s := s + 1 ; 
       listV2[countV2+1] := v + 1  ; countV2 := countV2 + 1  ; v := v + 1 ) else     if (listV[v+1] < listS[s+1] - x) then     v := v + 1 else     if (listV[v+1] > listS[s+1] + y) then     s := s + 1 ; else skip ; ;  ) ; 
    OclFile["System.out"].println(countS2) ; 
        var i : int ; i := 0 ; while i < countS2 do ( (     OclFile["System.out"].print(listS2[i+1] + " " + listV2[i+1] + "\n") )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner input=new Scanner(System.in);
  public static void main(String[] args){
    solve();
  }
  private static void solve(){
    int n=input.nextInt();
    int m=input.nextInt();
    int minx=Integer.MAX_VALUE ;
    int maxx=Integer.MIN_VALUE ;
    int miny=Integer.MAX_VALUE ;
    int maxy=Integer.MIN_VALUE ;
    int b=0 ;
    int len=0 ;
    String s[]=new String[n];
    for(int i=0 ; i<n ; i++){
      s[i]=input.next();
      for(int j=0 ; j<s[i] .length(); j++){
        if(s[i] .charAt(j)=='B'){
          b++;
          minx=Math.min(minx,i+1);
          maxx=Math.max(maxx,i+1);
          miny=Math.min(miny,j+1);
          maxy=Math.max(maxy,j+1);
        }
      }
    }
    if(b>0)len=Math.max(maxx-minx+1,maxy-miny+1);
    if(b==0){
      System.out.println(1);
    }
    else if(len>n || len>m){
      System.out.println(-1);
    }
    else {
      System.out.println(len*len-b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute input : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := input.getCurrent()->toInteger() ;
     var m : int ; m := input.getCurrent()->toInteger() ;
    var minx : int ; minx := 2147483647 ;
    var maxx : int ; maxx := -2147483648 ;
    var miny : int ; miny := 2147483647 ;
    var maxy : int ; maxy := -2147483648 ;
    var b : int ; b := 0 ;
    var len : int ; len := 0 ;
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := input.getCurrent() ; 
         var j : int ; j := 0 ; while j < s[i+1]->size() do ( (     if (s[i+1]->at(j+1) = 'B') then (     b := b + 1 ; 
     minx := Set{minx, i + 1}->min() ; 
    maxx := Set{maxx, i + 1}->max() ; 
    miny := Set{miny, j + 1}->min() ; 
    maxy := Set{maxy, j + 1}->max() ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (b > 0) then     len := Set{maxx - minx + 1, maxy - miny + 1}->max() ; else skip ; 
    if (b = 0) then (     OclFile["System.out"].println(1) ) else     if (len > n or len > m) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(len * len - b) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int m=input.nextInt();
    String[] s=new String[n];
    int alreadyBlack=0 ;
    for(int i=0 ; i<n ; i++){
      s[i]=input.next();
    }
    int maxx=0 ;
    int minx=Integer.MAX_VALUE ;
    int maxy=0 ;
    int miny=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        if(s[i] .charAt(j)=='B'){
          alreadyBlack++;
          maxx=Math.max(maxx,i);
          maxy=Math.max(maxy,j);
          minx=Math.min(minx,i);
          miny=Math.min(miny,j);
        }
      }
    }
    int lenx=maxx-minx+1 ;
    int leny=maxy-miny+1 ;
    int len=Math.max(lenx,leny);
    if(alreadyBlack==0){
      System.out.println("1");
    }
    else if(len>n || len>m){
      System.out.println("-1");
    }
    else if(Math.sqrt(len*len)!=len){
      System.out.println("-1");
    }
    else {
      System.out.println(len*len-alreadyBlack);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var m : int ; m := input.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := Integer.subrange(1,n)->collect(null) ;
    var alreadyBlack : int ; alreadyBlack := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := input.getCurrent() )  ;     i := i + 1 ) ; 
    var maxx : int ; maxx := 0 ;
    var minx : int ; minx := 2147483647 ;
    var maxy : int ; maxy := 0 ;
    var miny : int ; miny := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     if (s[i+1]->at(j+1) = 'B') then (     alreadyBlack := alreadyBlack + 1 ; 
     maxx := Set{maxx, i}->max() ; 
    maxy := Set{maxy, j}->max() ; 
    minx := Set{minx, i}->min() ; 
    miny := Set{miny, j}->min() ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var lenx : int ; lenx := maxx - minx + 1 ;
    var leny : int ; leny := maxy - miny + 1 ;
    var len : int ; len := Set{lenx, leny}->max() ;
    if (alreadyBlack = 0) then (     OclFile["System.out"].println("1") ) else     if (len > n or len > m) then (     OclFile["System.out"].println("-1") ) else     if ((len * len)->sqrt() /= len) then (     OclFile["System.out"].println("-1") ) else (     OclFile["System.out"].println(len * len - alreadyBlack) ) ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=Integer.parseInt(sc.next());
    HashMap<Integer,Integer>map=new HashMap<>();
    int a ;
    for(int i=0 ; i<n ; i++){
      a=Integer.parseInt(sc.next());
      map.put(a,map.getOrDefault(a,0)+1);
    }
    String ans="No" ;
    if(map.size()==1 && map.containsKey(0)){
      ans="Yes" ;
    }
    else if(n % 3==0){
      if(map.size()==2 && map.getOrDefault(0,-1)==n/3){
        ans="Yes" ;
      }
      else if(map.size()==3){
        List<Integer>list=new ArrayList<>(map.keySet());
        if(map.get(list.get(0))==n/3 && map.get(list.get(1))==n/3 && map.get(list.get(2))==n/3){
          int x=list.get(0)^ list.get(1)^ list.get(2);
          if(x==0){
            ans="Yes" ;
          }
        }
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := (sc.getCurrent())->toInteger() ;
    var map : Map(int,int) ; map := Map{} ;
    var a : int ;
        var i : int ; i := 0 ; while i < n do ( (     a := (sc.getCurrent())->toInteger() ; 
     map := map->union(Map{a |-> (if map->keys()->contains(a) then map->at(a) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "No" ;
    if (map.size() = 1 & map->keys()->includes(0)) then (     ans := "Yes" ) else     if (n mod 3 = 0) then (     if (map.size() = 2 & (if map->keys()->contains(0) then map->at(0) else -1 endif) = n / 3) then (     ans := "Yes" ) else     if (map.size() = 3) then (     var list : Sequence(int) ; list := Sequence{}->union(map->keys()) ;
     if (map->at(list->at(0+1)) = n / 3 & map->at(list->at(1+1)) = n / 3 & map->at(list->at(2+1)) = n / 3) then (     var x : int ; x := MathLib.bitwiseXor(MathLib.bitwiseXor(list->at(0+1),list->at(1+1)),list->at(2+1)) ;
     if (x = 0) then (     ans := "Yes" ) else skip ) else skip ) else skip ; ) else skip ; ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int even=in.nextInt(),odd=in.nextInt();
    if(even==0 && odd==0){
      pw.println("NO");
    }
    else {
      int sub=Math.abs(even-odd);
      if(sub<=1){
        pw.println("YES");
      }
      else {
        pw.println("NO");
      }
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var even : int ; even := in.getCurrent()->toInteger() ;
    var odd : int ; odd := in.getCurrent()->toInteger() ;
    if (even = 0 & odd = 0) then (     skip ) else (     var sub : int ; sub := if even - odd < 0 then -(even - odd) else even - odd endif ;
     if (sub <= 1) then (     skip ) else (     skip ) ) ;  
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    char mat[][]=new char[n][m];
    int black=0 ;
    int minX=999,maxX=-1,minY=999,maxY=-1 ;
    for(int i=0 ; i<n ; i++){
      String str=sc.next();
      for(int j=0 ; j<m ; j++){
        mat[i][j]=str.charAt(j);
        if(mat[i][j]=='B'){
          black++;
          minX=Math.min(minX,i);
          maxX=Math.max(maxX,i);
          minY=Math.min(minY,j);
          maxY=Math.max(maxY,j);
        }
      }
    }
    if(black==0){
      System.out.print("1");
    }
    else {
      int len=Math.max(maxX-minX,maxY-minY)+1 ;
      if(len>n || len>m){
        System.out.print("-1");
      }
      else {
        System.out.print(len*len-black);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var mat : Sequence(Sequence(String)) ; mat := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var black : int ; black := 0 ;
    var minX : int ; minX := 999 ;
    var maxX : int ; maxX := -1 ;
    var minY : int ; minY := 999 ;
    var maxY : int ; maxY := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < m do ( (     mat[i+1][j+1] := str->at(j+1) ; 
     if (mat[i+1][j+1] = 'B') then (     black := black + 1 ; 
     minX := Set{minX, i}->min() ; 
    maxX := Set{maxX, i}->max() ; 
    minY := Set{minY, j}->min() ; 
    maxY := Set{maxY, j}->max() ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (black = 0) then (     OclFile["System.out"].print("1") ) else (     var len : int ; len := Set{maxX - minX, maxY - minY}->max() + 1 ;
     if (len > n or len > m) then (     OclFile["System.out"].print("-1") ) else (     OclFile["System.out"].print(len * len - (black)->char2byte()) ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int power(long x,int y,int mod){
    long res=1 ;
    while(y!=0){
      if((y & 1)==1)res=(res*x)% mod ;
      x=(x*x)% mod ;
      y=(y>>1);
    }
    return(int)(res % mod);
  }
  static int ncr(int n,int r,int mod){
    long res=1 ;
    for(int i=1 ; i<=r ; i+=1){
      res=(res*(n-i+1))% mod ;
      int inv=power(i,mod-2,mod);
      res=(res*inv)% mod ;
    }
    return(int)(res % mod);
  }
  static int NoOfChords(int A){
    int mod=(int)(1e9+7);
    long ans=ncr(2*A,A,mod);
    int inv=power(A+1,mod-2,mod);
    ans=(ans*inv)% mod ;
    return(int)(ans % mod);
  }
  public static void main(String[] args){
    int N=2 ;
    System.out.println(NoOfChords(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation power( x : long, y : int, mod : int) : int
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
     while (y /= 0) do (     if ((y & 1) = 1) then     res := (res * x) mod mod ; else skip ; 
     x := (x * x) mod mod ; 
     y := ((y/(2->pow(1)))->oclAsType(long)) ) ; 
     return (res mod mod)->oclAsType(int) );
  static   operation ncr( n : int, r : int, mod : int) : int
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : int ; i := 1 ; while i <= r do ( (     res := (res * (n - i + 1)) mod mod ; 
     var inv : int ; inv := power(i, mod - 2, mod) ;
     res := (res * inv) mod mod )  ;     i := i+(1) ) ; 
     return (res mod mod)->oclAsType(int) );
  static   operation NoOfChords( A : int) : int
  pre: true
  post: true
  activity: (     var mod : int ; mod := (1e9 + 7)->oclAsType(int) ;
     var ans : long ; ans := ncr(2 * A, A, mod) ;
    var inv : int ; inv := power(A + 1, mod - 2, mod) ;
    ans := (ans * inv) mod mod ; 
    return (ans mod mod)->oclAsType(int) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 2 ;
     OclFile["System.out"].println(NoOfChords(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static double countdigits(int n,int k){
    if(n==0)return 0 ;
    int digit=n % 10 ;
    if(digit==k)return 1+countdigits(n/10,k);
    return countdigits(n/10,k);
  }
  public static void main(String[] args){
    int n=1000 ;
    int k=0 ;
    System.out.println(countdigits(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countdigits( n : int, k : int) : double
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else skip ; 
     var digit : int ; digit := n mod 10 ;
     if (digit = k) then     return 1 + countdigits(n / 10, k) else skip ; 
     return countdigits(n / 10, k) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1000 ;
     var k : int ; k := 0 ;
     OclFile["System.out"].println(countdigits(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s1=in.next(),s2=in.next(),s3=in.next();
    in.close();
    if(s1.charAt(s1.length()-1)==s2.charAt(0)&& s2.charAt(s2.length()-1)==s3.charAt(0)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := in.getCurrent() ;
    var s2 : String ; s2 := in.getCurrent() ;
    var s3 : String ; s3 := in.getCurrent() ;
     skip ; 
     if (s1->at(s1->size() - 1+1) = s2->at(0+1) & s2->at(s2->size() - 1+1) = s3->at(0+1)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String a=sc.next();
    String b=sc.next();
    String c=sc.next();
    String ans="NO" ;
    if(a.charAt(a.length()-1)==b.charAt(0)&& b.charAt(b.length()-1)==c.charAt(0))ans="YES" ;
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := sc.getCurrent() ;
    var b : String ; b := sc.getCurrent() ;
    var c : String ; c := sc.getCurrent() ;
    var ans : String ; ans := "NO" ;
    if (a->at(a->size() - 1+1) = b->at(0+1) & b->at(b->size() - 1+1) = c->at(0+1)) then     ans := "YES" ; else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner io=new Scanner(System.in);
    String A=io.next();
    String B=io.next();
    String C=io.next();
    System.out.println((A.charAt(A.length()-1)==B.charAt(0)&& B.charAt(B.length()-1)==C.charAt(0))? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : String ; A := io.getCurrent() ;
    var B : String ; B := io.getCurrent() ;
    var C : String ; C := io.getCurrent() ;
    OclFile["System.out"].println(if (A->at(A->size() - 1+1) = B->at(0+1) & B->at(B->size() - 1+1) = C->at(0+1)) then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String input=scanner.nextLine();
    String[] data=input.split(" ");
    char data1End=data[0] .charAt(data[0] .length()-1);
    char data2Head=data[1] .charAt(0);
    char data2End=data[1] .charAt(data[1] .length()-1);
    char data3Head=data[2] .charAt(0);
    if(data1End==data2Head){
      if(data2End==data3Head){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : String ; input := scanner.nextLine() ;
    var data : Sequence(String) ; data := input->split(" ") ;
    var data1End : String ; data1End := data[0+1]->at(data[0+1]->size() - 1+1) ;
    var data2Head : String ; data2Head := data[1+1]->at(0+1) ;
    var data2End : String ; data2End := data[1+1]->at(data[1+1]->size() - 1+1) ;
    var data3Head : String ; data3Head := data[2+1]->at(0+1) ;
    if (data1End = data2Head) then (     if (data2End = data3Head) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static char left(String s){
    return s.charAt(0);
  }
  public static char right(String s){
    return s.charAt(s.length()-1);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String a,b,c ;
    a=sc.next();
    b=sc.next();
    c=sc.next();
    boolean ans=(left(b)==right(a))&&(right(b)==left(c));
    if(ans){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation left( s : String) : String
  pre: true
  post: true
  activity: (     return s->at(0+1) );
  static   operation right( s : String) : String
  pre: true
  post: true
  activity: (     return s->at(s->size() - 1+1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ;
    var b : String ;
    var c : String ;
    a := sc.getCurrent() ; 
    b := sc.getCurrent() ; 
    c := sc.getCurrent() ; 
    var ans : boolean ; ans := (left(b) = right(a)) & (right(b) = left(c)) ;
    if (ans) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class sss {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] nums=new long[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=sc.nextLong();
    }
    long zeroCount=0 ;
    long tcount=0 ;
    long ncount=0 ;
    for(int i=0 ; i<n ; i++){
      if(nums[i]==0){
        zeroCount++;
      }
      else if(nums[i]>0){
        tcount+=nums[i]-1 ;
      }
      else {
        ncount++;
        tcount+=-1-nums[i];
      }
    }
    if(zeroCount>0){
      tcount+=zeroCount ;
    }
    else {
      if(ncount % 2==0){
      }
      else {
        tcount+=2 ;
      }
    }
    System.out.println(tcount);
  }
}
------------------------------------------------------------
OCL File:
---------
 class sss {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var nums : Sequence(long) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var zeroCount : long ; zeroCount := 0 ;
    var tcount : long ; tcount := 0 ;
    var ncount : long ; ncount := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (nums[i+1] = 0) then (     zeroCount := zeroCount + 1 ) else     if (nums[i+1] > 0) then (     tcount := tcount+(nums[i+1] - 1) ) else (     ncount := ncount + 1 ; 
     tcount := tcount+(-1 - nums[i+1]) ) ;  )  ;     i := i + 1 ) ; 
    if (zeroCount > 0) then (     tcount := tcount+(zeroCount) ) else (     if (ncount mod 2 = 0) then skip else (     tcount := tcount+(2) ) ) ;  
    OclFile["System.out"].println(tcount) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int Max_Sum(int a[],int n){
    int[] b=new int[n];
    int S=0 ;
    int res=0 ;
    for(int i=0 ; i<n ; i++){
      b[i]=res ;
      res+=a[i];
      S+=a[i];
      res=Math.max(res,-S);
    }
    int ans=S ;
    ans=Math.max(ans,res);
    int g=0 ;
    for(int i=n-1 ; i>=0 ; --i){
      g-=a[i];
      ans=Math.max(ans,g+b[i]);
    }
    return ans ;
  }
  public static void main(String[] args){
    int a[]={
-6,10,-3,10,-2 };
      int n=a.length ;
      System.out.println("Maximum sum is: "+Max_Sum(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Max_Sum( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
     var S : int ; S := 0 ;
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := res ; 
     res := res+(a[i+1]) ; 
     S := S+(a[i+1]) ; 
     res := Set{res, -S}->max() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := S ;
    ans := Set{ans, res}->max() ; 
    var g : int ; g := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     g := g-(a[i+1]) ; 
     ans := Set{ans, g + b[i+1]}->max() )  ;     i := i - 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{-6,10,-3,10,-2} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println("Maximum sum is: " + Max_Sum(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] $){
    int n=scanner.nextInt();
    Map<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      map.compute(scanner.nextInt(),(key,value)->value==null ? 1 : value+1);
    }
    System.out.println(f(map)? "Yes" : "No");
  }
  static boolean f(Map<Integer,Integer>map){
    int s=map.size();
    int[][] a=new int[s][2];
    int i=0 ;
    for(Map.Entry<Integer,Integer>entry : map.entrySet()){
      a[i][0]=entry.getKey();
      a[i++][1]=entry.getValue();
    }
    if(s>3){
      return false ;
    }
    Arrays.sort(a,Comparator.comparingInt(array->array[0]));
    if(s==1){
      return a[0][0]==0 ;
    }
    else if(s==2){
      return a[0][0]==0 && a[0][1]*2==a[1][1];
    }
    else {
      return a[0][1]==a[1][1] && a[1][1]==a[2][1] &&(a[0][0] ^ a[1][0] ^ a[2][0])==0 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var map : Map(int,int) ; map := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     map := map.compute(scanner.getCurrent()->toInteger(), lambda (key , value) : OclAny in if value = null then 1 else value + 1 endif) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(if f(map) then "Yes" else "No" endif) );
  static   operation f( map : Map(int,int)) : boolean
  pre: true
  post: true
  activity: (     var s : int ; s := map.size() ;
     var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,s)->collect(Integer.subrange(1,2)->collect(0)) ;
    var i : int ; i := 0 ;
    for (entry : map->asSet()) do ( (     a[i+1][0+1] := entry.getKey() ; 
      a[i+1][1+1] := entry.getValue()  ; i := i + 1 )  ) ; 
    if (s > 3) then (     return false ) else skip ; 
    a := OclComparator.sortWith(a, Comparator.comparingInt(lambda array : OclAny in array[0+1])) ; 
    if (s = 1) then (     return a[0+1][0+1] = 0 ) else     if (s = 2) then (     return a[0+1][0+1] = 0 & a[0+1][1+1] * 2 = a[1+1][1+1] ) else (     return a[0+1][1+1] = a[1+1][1+1] & a[1+1][1+1] = a[2+1][1+1] & (a[0+1][0+1] xor a[1+1][0+1] xor a[2+1][0+1]) = 0 ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MakeProductEqualOne {
  public static void main(String[] args)throws NumberFormatException,Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter output=new BufferedWriter(new OutputStreamWriter(System.out));
    int n=toInt(br.readLine());
    String[] str=br.readLine().split(" ");
    long[] nums=toIntArr(str);
    int check=0,check2=0 ;
    for(int i=0 ; i<n ; i++){
      if(nums[i]<0)check++;
    }
    for(int i=0 ; i<n ; i++){
      if(nums[i]==0)check2++;
    }
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      ans+=Math.abs((Math.abs(nums[i])-1));
    }
    if(check % 2!=0 && check2==0){
      ans+=2 ;
    }
    System.out.println(ans);
    output.flush();
  }
  private static int toInt(String str){
    return Integer.parseInt(str);
  }
  static long[] toIntArr(String[] str){
    long[] arr=new long[str.length];
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=toInt(str[i]);
    }
    return arr ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class MakeProductEqualOne {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var output : OclFile ; output := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := toInt(br.readLine()) ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var nums : Sequence(long) ; nums := toIntArr(str) ;
    var check : int ; check := 0 ;
    var check2 : int ; check2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (nums[i+1] < 0) then     check := check + 1 ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (nums[i+1] = 0) then     check2 := check2 + 1 ; else skip )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans+(if (if nums[i+1] < 0 then -(nums[i+1]) else nums[i+1] endif - 1) < 0 then -((if nums[i+1] < 0 then -(nums[i+1]) else nums[i+1] endif - 1)) else (if nums[i+1] < 0 then -(nums[i+1]) else nums[i+1] endif - 1) endif) )  ;     i := i + 1 ) ; 
    if (check mod 2 /= 0 & check2 = 0) then (     ans := ans+(2) ) else skip ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
  static   operation toInt( str : String) : int
  pre: true
  post: true
  activity: (     return (str)->toInteger() );
  static   operation toIntArr( str : Sequence(String)) : Sequence(long)
  pre: true
  post: true
  activity: (     var arr : Sequence(long) ; arr := Integer.subrange(1,str->size())->collect(0) ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := toInt(str[i+1]) )  ;     i := i + 1 ) ; 
     return arr );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=26 ;
  public static boolean canBeMapped(String s1,int l1,String s2,int l2){
    if(l1!=l2)return false ;
    int[] freq1=new int[MAX];
    int[] freq2=new int[MAX];
    for(int i=0 ; i<l1 ; i++)freq1[s1.charAt(i)-'a']++;
    for(int i=0 ; i<l2 ; i++)freq2[s2.charAt(i)-'a']++;
    for(int i=0 ; i<MAX ; i++){
      if(freq1[i]==0)continue ;
      boolean found=false ;
      for(int j=0 ; j<MAX ; j++){
        if(freq1[i]==freq2[j]){
          freq2[j]=-1 ;
          found=true ;
          break ;
        }
      }
      if(! found)return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    String s1="axx" ;
    String s2="cbc" ;
    int l1=s1.length();
    int l2=s2.length();
    if(canBeMapped(s1,l1,s2,l2))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 26;
  static   operation canBeMapped( s1 : String, l1 : int, s2 : String, l2 : int) : boolean
  pre: true
  post: true
  activity: (     if (l1 /= l2) then     return false else skip ; 
     var freq1 : Sequence(int) ; freq1 := Integer.subrange(1,MAX)->collect(0) ;
    var freq2 : Sequence(int) ; freq2 := Integer.subrange(1,MAX)->collect(0) ;
        var i : int ; i := 0 ; while i < l1 do (     freq1[s1->at(i+1) - ('a')->char2byte()+1] := freq1[s1->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < l2 do (     freq2[s2->at(i+1) - ('a')->char2byte()+1] := freq2[s2->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < MAX do ( (     if (freq1[i+1] = 0) then     continue else skip ; 
     var found : boolean ; found := false ;
         var j : int ; j := 0 ; while j < MAX do ( (     if (freq1[i+1] = freq2[j+1]) then (     freq2[j+1] := -1 ; 
     found := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (not(found)) then     return false else skip )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "axx" ;
     var s2 : String ; s2 := "cbc" ;
    var l1 : int ; l1 := s1->size() ;
    var l2 : int ; l2 := s2->size() ;
    if (canBeMapped(s1, l1, s2, l2)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static void find(int n,int m,int p,int q[][]){
    Vector<Integer>z=new Vector<Integer>();
    int i ;
    for(i=0 ; i<p ; i++)z.add(q[i][1]);
    Collections.sort(z);
    System.out.print(z.get(z.size()-1)-z.get(0));
  }
  public static void main(String args[]){
    int n=2 ;
    int m=2 ;
    int p=2 ;
    int q[][]={
      {
        0,0 },{
          0,1 }
        };
        find(n,m,p,q);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation find( n : int, m : int, p : int, q : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var z : Sequence(int) ; z := Sequence{} ;
     var i : int ;
        i := 0 ; while i < p do (     z := z->including(q[i+1][1+1]) ;  ;     i := i + 1 ) ; 
    z := z->sort() ; 
    OclFile["System.out"].print(z->at(z->size() - 1+1) - z->at(0+1)) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     var m : int ; m := 2 ;
    var p : int ; p := 2 ;
    var q : Sequence(Sequence(int)) ; q := Sequence{Sequence{0,0},Sequence{0,1}} ;
    execute find(n, m, p, q) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String...args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int c=sc.nextInt();
    int sum=0 ;
    for(int i=0 ; i<c ; i++){
      sum+=sc.nextInt();
    }
    System.out.println((sum %(n+1)==0)? sum/(n+1): sum/(n+1)+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < c do ( (     sum := sum+(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if (sum mod (n + 1) = 0) then sum / (n + 1) else sum / (n + 1) + 1 endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int N,C ;
    line=br.readLine();
    N=parseInt(line.substring(0,line.indexOf(' ')));
    C=parseInt(line.substring(line.indexOf(' ')+1));
    int sum=0 ;
    StringTokenizer st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<C ; i++){
      sum+=parseInt(st.nextToken());
    }
    int ans=sum/(N+1);
    if(sum %(N+1)>0){
      ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var N : int ;
    var C : int ;
    line := br.readLine() ; 
    N := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    C := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    var sum : int ; sum := 0 ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < C do ( (     sum := sum+((st.next() + "")->toInteger()) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := sum / (N + 1) ;
    if (sum mod (N + 1) > 0) then (     ans := ans + 1 ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      String[] tmp=sc.nextLine().split(" ");
      final int N=Integer.parseInt(tmp[0]);
      final int C=Integer.parseInt(tmp[1]);
      tmp=sc.nextLine().split(" ");
      int[] P=new int[C];
      for(int i=0 ; i<C ; i++){
        P[i]=Integer.parseInt(tmp[i]);
      }
      System.out.println(solve(N,C,P));
    }
  }
  private static int solve(int N,int C,int[] P){
    int sumCakePiace=0 ;
    for(int i : P){
      sumCakePiace+=i ;
    }
    int ret=sumCakePiace/(N+1);
    if(sumCakePiace %(N+1)>0){
      ret++;
    }
    return ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var tmp : Sequence(String) ; tmp := sc.nextLine()->split(" ") ;
     var N : int ; N := (tmp[0+1])->toInteger() ;
    var C : int ; C := (tmp[1+1])->toInteger() ;
    tmp := sc.nextLine()->split(" ") ; 
    var P : Sequence(int) ; P := Integer.subrange(1,C)->collect(0) ;
        var i : int ; i := 0 ; while i < C do ( (     P[i+1] := (tmp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(N, C, P)) ; 
 ))  );
  static   operation solve( N : int, C : int, P : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var sumCakePiace : int ; sumCakePiace := 0 ;
     for (i : P) do ( (     sumCakePiace := sumCakePiace+(i) )  ) ; 
    var ret : int ; ret := sumCakePiace / (N + 1) ;
    if (sumCakePiace mod (N + 1) > 0) then (     ret := ret + 1 ) else skip ; 
    return ret 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    @ SuppressWarnings("resource")Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    int[] i=ArrconvAtoi(s);
    i[0]++;
    s=sc.nextLine();
    int[] pc=ArrconvAtoi(s);
    int cakesum=0 ;
    for(int c : pc){
      cakesum+=c ;
    }
    System.out.println(cakesum % i[0]==0 ? cakesum/i[0] : cakesum/i[0]+1);
  }
  private static int[] ArrconvAtoi(String s){
    String[] strs=s.split(" ");
    int[] ints=new int[strs.length];
    int i=0 ;
    for(String st : strs){
      ints[i]=Integer.parseInt(st);
      i++;
    }
    return ints ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var i : Sequence(int) ; i := ArrconvAtoi(s) ;
    i[0+1] := i[0+1] + 1 ; 
    s := sc.nextLine() ; 
    var pc : Sequence(int) ; pc := ArrconvAtoi(s) ;
    var cakesum : int ; cakesum := 0 ;
    for (c : pc) do ( (     cakesum := cakesum+(c) )  ) ; 
    OclFile["System.out"].println(if cakesum mod i[0+1] = 0 then cakesum / i[0+1] else cakesum / i[0+1] + 1 endif) ; 
 );
  static   operation ArrconvAtoi( s : String) : Sequence(int)
  pre: true
  post: true
  activity: (     var strs : Sequence(String) ; strs := s->split(" ") ;
     var ints : Sequence(int) ; ints := Integer.subrange(1,strs->size())->collect(0) ;
    var i : int ; i := 0 ;
    for (st : strs) do ( (     ints[i+1] := (st)->toInteger() ; 
     i := i + 1 )  ) ; 
    return ints 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void solve(){
    int N,C,sum=0 ;
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    C=sc.nextInt();
    for(int i=0 ; i<C ; i++){
      int x=sc.nextInt();
      sum+=x ;
    }
    N++;
    System.out.println(sum/N+(sum % N==0 ? 0 : 1));
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : int ;
    var C : int ;
    var sum : int ; sum := 0 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    N := sc.getCurrent()->toInteger() ; 
    C := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < C do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     sum := sum+(x) )  ;     i := i + 1 ) ; 
    N := N + 1 ; 
    OclFile["System.out"].println(sum / N + (if sum mod N = 0 then 0 else 1 endif)) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner scan=new Scanner(System.in);
    int t=scan.nextInt();
    while(t-->0){
      solve(scan);
    }
  }
  public static void solve(Scanner scan){
    int n=scan.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=scan.nextInt();
    }
    ArrayList<Integer>odd=new ArrayList<>();
    ArrayList<Integer>oddChange=new ArrayList<>();
    ArrayList<Integer>even=new ArrayList<>();
    ArrayList<Integer>evenChange=new ArrayList<>();
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i] % 2==0){
        even.add(arr[i]);
        evenChange.add(arr[i]);
      }
      else {
        odd.add(arr[i]);
        oddChange.add(arr[i]);
      }
    }
    Collections.sort(evenChange);
    Collections.sort(oddChange);
    if(even.equals(evenChange)&& odd.equals(oddChange)){
      System.out.println("Yes");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve(scan) ) ;  ) );
  static   operation solve( scan : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var odd : Sequence(int) ; odd := Sequence{} ;
    var oddChange : Sequence(int) ; oddChange := Sequence{} ;
    var even : Sequence(int) ; even := Sequence{} ;
    var evenChange : Sequence(int) ; evenChange := Sequence{} ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] mod 2 = 0) then (     even := even->including(arr[i+1]) ; 
     evenChange := evenChange->including(arr[i+1]) ) else (     odd := odd->including(arr[i+1]) ; 
     oddChange := oddChange->including(arr[i+1]) ) )  ;     i := i + 1 ) ; 
    evenChange := evenChange->sort() ; 
    oddChange := oddChange->sort() ; 
    if (even = evenChange & odd = oddChange) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class A1452 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      int[] a=new int[2];
      a[0]=scanner.nextInt();
      a[1]=scanner.nextInt();
      Arrays.sort(a);
      if(a[0]==a[1]){
        System.out.println(2*a[0]);
      }
      else {
        System.out.println(2*a[1]-1);
      }
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1452 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : Sequence(int) ; a := Integer.subrange(1,2)->collect(0) ;
     a[0+1] := scanner.getCurrent()->toInteger() ; 
    a[1+1] := scanner.getCurrent()->toInteger() ; 
    a := a->sort() ; 
    if (a[0+1] = a[1+1]) then (     OclFile["System.out"].println(2 * a[0+1]) ) else (     OclFile["System.out"].println(2 * a[1+1] - 1) ) ;  
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static int n,k ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    k=sc.nextInt();
    n=sc.nextInt();
    if((k & 1)==0){
      System.out.print(k/2);
      for(int i=1 ; i<n ; i++){
        System.out.print(" ");
        System.out.print(k);
      }
      return ;
    }
    int[] ns=new int[n];
    Arrays.fill(ns,(k+1)/2);
    int cnt=n/2 ;
    int trg=n-1 ;
    for(int i=0 ; i<cnt ; i++){
      while(trg>=0 && ns[trg]==0)trg--;
      if(ns[trg]==1){
        ns[trg]=0 ;
        continue ;
      }
      ns[trg]--;
      for(int j=trg+1 ; j<n ; j++){
        ns[j]=k ;
        trg++;
      }
    }
    for(int n : ns){
      if(n!=0){
        System.out.print(n);
        System.out.print(" ");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     k := sc.getCurrent()->toInteger() ; 
    n := sc.getCurrent()->toInteger() ; 
    if ((k & 1) = 0) then (     OclFile["System.out"].print(k / 2) ; 
         var i : int ; i := 1 ; while i < n do ( (     OclFile["System.out"].print(" ") ; 
     OclFile["System.out"].print(k) )  ;     i := i + 1 ) ; 
     return ) else skip ; 
    var ns : Sequence(int) ; ns := Integer.subrange(1,n)->collect(0) ;
    ns := ns->collect((k + 1) / 2) ; 
    var cnt : int ; cnt := n / 2 ;
    var trg : int ; trg := n - 1 ;
        var i : int ; i := 0 ; while i < cnt do ( (     while (trg >= 0 & ns[trg+1] = 0) do     trg := trg - 1 ; ; 
     if (ns[trg+1] = 1) then (     ns[trg+1] := 0 ; 
     continue ) else skip ; 
     ns[trg+1] := ns[trg+1] - 1 ; 
         var j : int ; j := trg + 1 ; while j < n do ( (     ns[j+1] := k ; 
     trg := trg + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    for (n : ns) do ( (     if (n /= 0) then (     OclFile["System.out"].print(n) ; 
     OclFile["System.out"].print(" ") ) else skip )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    long count=1 ;
    while(true){
      long d=count*(count+1)/2 ;
      if(d>=x){
        System.out.println(count);
        return ;
      }
      count++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     var count : long ; count := 1 ;
     while (true) do (     var d : long ; d := count * (count + 1) / 2 ;
     if (d >= x) then (     OclFile["System.out"].println(count) ; 
     return ) else skip ; 
     count := count + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  private static void Even(int K,int N,PrintWriter output){
    output.print(K/2);
    for(int i=1 ; i<N ; ++i)output.print(" "+K);
    output.println();
  }
  private static void Odd(int K,int N,PrintWriter output){
    ArrayList<Integer>arrayMid=new ArrayList<Integer>();
    for(int i=0 ; i<N ; ++i)arrayMid.add(i,(K+1)/2);
    for(int i=0 ; i<N/2 ; ++i){
      if(arrayMid.get(arrayMid.size()-1)<=1)arrayMid.remove(arrayMid.size()-1);
      else {
        arrayMid.set((arrayMid.size()-1),arrayMid.get(arrayMid.size()-1)-1);
        while(arrayMid.size()<N)arrayMid.add(K);
      }
    }
    for(int i=0 ; i<arrayMid.size(); ++i){
      output.print(arrayMid.get(i));
      if(i<arrayMid.size()-1)output.print(" ");
      else output.println();
    }
  }
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner input=new Scanner(inputStream);
    PrintWriter output=new PrintWriter(outputStream);
    int K=input.nextInt();
    int N=input.nextInt();
    if(K % 2==0)Even(K,N,output);
    else Odd(K,N,output);
    input.close();
    output.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation Even( K : int, N : int, output : OclFile) : void
  pre: true
  post: true
  activity: (     output.print(K / 2) ; 
         var i : int ; i := 1 ; while i < N do (     output.print(" " + K) ;  ;     i := i + 1 ) ; 
     output.println() );
  static   operation Odd( K : int, N : int, output : OclFile) : void
  pre: true
  post: true
  activity: (     var arrayMid : Sequence(int) ; arrayMid := Sequence{} ;
         var i : int ; i := 0 ; while i < N do (     arrayMid := arrayMid.insertAt(i+1,(K + 1) / 2) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < N / 2 do ( (     if (arrayMid->at(arrayMid->size() - 1+1) <= 1) then     arrayMid := arrayMid->excludingFirst(arrayMid->size() - 1) ; else (     arrayMid := arrayMid.setAt((arrayMid->size() - 1)+1,arrayMid->at(arrayMid->size() - 1+1) - 1) ; 
     while (arrayMid->size() < N) do     arrayMid := arrayMid->including(K) ; ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < arrayMid->size() do ( (     output.print(arrayMid->at(i+1)) ; 
     if (i < arrayMid->size() - 1) then     output.print(" ") ; else     output.println() ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var input : OclFile ; input := OclFile.newOclFile_Read(inputStream) ;
    var output : OclFile ; output := OclFile.newOclFile_Write(outputStream) ;
    var K : int ; K := input.getCurrent()->toInteger() ;
    var N : int ; N := input.getCurrent()->toInteger() ;
    if (K mod 2 = 0) then     execute Even(K, N, output) else     execute Odd(K, N, output) ; ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Deque ;
import java.util.ArrayDeque ;
import java.util.Scanner ;
class Main {
  static int K ;
  static int N ;
  static void dec(Deque<Integer>list){
    if(list.peekLast()==1)list.pollLast();
    else {
      list.addLast(list.pollLast()-1);
      while(list.size()<N)list.addLast(K);
    }
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    K=scan.nextInt();
    N=scan.nextInt();
    Deque<Integer>ans=new ArrayDeque<>();
    if(K % 2==0){
      ans.add(K/2);
      while(N-->1)ans.add(K);
    }
    else {
      for(int i=0 ; i<N ; ++i)ans.add((K+1)/2);
      for(int i=0 ; i<(N/2); ++i)dec(ans);
    }
    PrintWriter pw=new PrintWriter(System.out);
    StringBuffer sb=new StringBuffer();
    for(int i : ans)if(i!=0)sb.append(i+" ");
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute K : int;
  static   attribute N : int;
  static   operation dec( list : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (list.peekLast() = 1) then     list := list->front() ; else (     list := list->append(list->last() - 1) ; 
     while (list->size() < N) do     list := list->append(K) ; ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     K := scan.getCurrent()->toInteger() ; 
    N := scan.getCurrent()->toInteger() ; 
    var ans : Sequence(int) ; ans := ArrayDeque<OclAny>.newArrayDeque() ;
    if (K mod 2 = 0) then (     ans := ans->including(K / 2) ; 
         while (N > 1) do (        N := N - 1 ;     skip ;     ans := ans->including(K) ; ;  ) ) else (         var i : int ; i := 0 ; while i < N do (     ans := ans->including((K + 1) / 2) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < (N / 2) do (     execute dec(ans) ;  ;     i := i + 1 ) ) ;  
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sb : String ; sb := StringLib.newString() ;
    for (i : ans) do (     if (i /= 0) then     sb := sb + StringLib.newString(i + " ") ; else skip ;  ) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.List ;
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskE solver=new TaskE();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskE {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int k=in.nextInt();
      int n=in.nextInt();
      if(k % 2==0){
        out.print(k/2);
        for(int i=1 ; i<n ; ++i){
          out.print(" "+k);
        }
        out.println();
      }
      else {
        List<Integer>res=new ArrayList<>();
        for(int i=0 ; i<n ; ++i)res.add((k+1)/2);
        int cnt=n/2 ;
        for(int i=0 ; i<cnt ; ++i){
          if(res.get(res.size()-1)>1){
            res.set(res.size()-1,res.get(res.size()-1)-1);
            while(res.size()<n)res.add(k);
          }
          else {
            res.remove(res.size()-1);
          }
        }
        for(int i=0 ; i<res.size(); ++i){
          out.print(res.get(i));
          if(i<res.size()-1){
            out.print(" ");
          }
          else {
            out.println();
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskE ; solver := TaskE.newTaskE() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskE {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var k : int ; k := in.getCurrent()->toInteger() ;
     var n : int ; n := in.getCurrent()->toInteger() ;
     if (k mod 2 = 0) then (     skip ; 
         var i : int ; i := 1 ; while i < n do ( (     skip )  ;     i := i + 1 ) ; 
     skip ) else (     var res : Sequence(int) ; res := Sequence{} ;
         var i : int ; i := 0 ; while i < n do (     res := res->including((k + 1) / 2) ;  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := n / 2 ;
        var i : int ; i := 0 ; while i < cnt do ( (     if (res->at(res->size() - 1+1) > 1) then (     res := res.setAt(res->size() - 1+1,res->at(res->size() - 1+1) - 1) ; 
     while (res->size() < n) do     res := res->including(k) ; ) else (     res := res->excludingFirst(res->size() - 1) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < res->size() do ( (     skip ; 
     if (i < res->size() - 1) then (     skip ) else (     skip ) )  ;     i := i + 1 ) ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private void print(ArrayList<Integer>arrayMid){
    StringBuilder Mid=new StringBuilder();
    for(int i=0 ; i<arrayMid.size(); i++){
      Mid.append(arrayMid.get(i)+" ");
    }
    System.out.print(Mid);
  }
  private void Even(int K,int N){
    ArrayList<Integer>arrayMid=new ArrayList<Integer>(N);
    arrayMid.add(0,K/2);
    for(int i=1 ; i<N ; i++)arrayMid.add(i,K);
    print(arrayMid);
  }
  private void Odd(int K,int N){
    ArrayList<Integer>arrayMid=new ArrayList<Integer>(N);
    for(int i=0 ; i<N ; i++)arrayMid.add(i,(K+1)/2);
    for(int i=0 ; i<N/2 ; i++){
      if(arrayMid.get(arrayMid.size()-1)==1)arrayMid.remove(arrayMid.size()-1);
      else {
        arrayMid.set((arrayMid.size()-1),arrayMid.get(arrayMid.size()-1)-1);
        for(int j=arrayMid.size(); j<N ; j++)arrayMid.add(j,K);
      }
    }
    print(arrayMid);
  }
  private void Judge(int K,int N){
    if(K % 2==0)Even(K,N);
    else Odd(K,N);
  }
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int[] in=new int[2];
    for(int i=0 ; i<2 ; i++){
      in[i]=input.nextInt();
    }
    Main myEncyclopedia=new Main();
    myEncyclopedia.Judge(in[0],in[1]);
    input.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation print( arrayMid : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var Mid : String ; Mid := StringLib.newString() ;
         var i : int ; i := 0 ; while i < arrayMid->size() do ( (     Mid := Mid + StringLib.newString(arrayMid->at(i+1) + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].print(Mid) );
   operation Even( K : int, N : int) : void
  pre: true
  post: true
  activity: (     var arrayMid : Sequence(int) ; arrayMid := Sequence{}->union(N) ;
     arrayMid := arrayMid.insertAt(0+1,K / 2) ; 
         var i : int ; i := 1 ; while i < N do (     arrayMid := arrayMid.insertAt(i+1,K) ;  ;     i := i + 1 ) ; 
     execute print(arrayMid) );
   operation Odd( K : int, N : int) : void
  pre: true
  post: true
  activity: (     var arrayMid : Sequence(int) ; arrayMid := Sequence{}->union(N) ;
         var i : int ; i := 0 ; while i < N do (     arrayMid := arrayMid.insertAt(i+1,(K + 1) / 2) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < N / 2 do ( (     if (arrayMid->at(arrayMid->size() - 1+1) = 1) then     arrayMid := arrayMid->excludingFirst(arrayMid->size() - 1) ; else (     arrayMid := arrayMid.setAt((arrayMid->size() - 1)+1,arrayMid->at(arrayMid->size() - 1+1) - 1) ; 
         var j : int ; j := arrayMid->size() ; while j < N do (     arrayMid := arrayMid.insertAt(j+1,K) ;  ;     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
     execute print(arrayMid) );
   operation Judge( K : int, N : int) : void
  pre: true
  post: true
  activity: (     if (K mod 2 = 0) then     execute Even(K, N) ; else     execute Odd(K, N) ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var in : Sequence(int) ; in := Integer.subrange(1,2)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 do ( (     in[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var myEncyclopedia : Main ; myEncyclopedia := Main.newMain() ;
    myEncyclopedia.Judge(in[0+1], in[1+1]) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.Locale ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=sc.nextInt(),m=sc.nextInt(),x=sc.nextInt(),y=sc.nextInt(),a=sc.nextInt(),b=sc.nextInt();
    int gcd=gcd(a,b);
    int k=Math.min(n/(a/gcd),m/(b/gcd));
    int w=a/gcd*k,h=b/gcd*k ;
    int x1=Math.max(x-(w+1)/2,0),x2=Math.min(x1+w,n);
    int y1=Math.max(y-(h+1)/2,0),y2=Math.min(y1+h,m);
    x1=x2-w ;
    y1=y2-h ;
    out.println(x1+" "+y1+" "+x2+" "+y2);
    out.flush();
    out.close();
  }
  static int gcd(int a,int b){
    return b==0 ? a : gcd(b,a % b);
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var gcd : int ; gcd := gcd(a, b) ;
    var k : int ; k := Set{n / (a / gcd), m / (b / gcd)}->min() ;
    var w : int ; w := a / gcd * k ;
    var h : int ; h := b / gcd * k ;
    var x1 : int ; x1 := Set{x - (w + 1) / 2, 0}->max() ;
    var x2 : int ; x2 := Set{x1 + w, n}->min() ;
    var y1 : int ; y1 := Set{y - (h + 1) / 2, 0}->max() ;
    var y2 : int ; y2 := Set{y1 + h, m}->min() ;
    x1 := x2 - w ; 
    y1 := y2 - h ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class b {
  public static void main(String[] args){
    FS in=new FS(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt();
    int m=in.nextInt();
    int x=in.nextInt();
    int y=in.nextInt();
    int a=in.nextInt();
    int b=in.nextInt();
    int gcd=gcd(a,b);
    a/=gcd ;
    b/=gcd ;
    int tmp=Math.min(n/a,m/b);
    a*=tmp ;
    b*=tmp ;
    int cornX=Math.max(0,Math.min(n,x-(a+1)/2));
    int cornY=Math.max(0,Math.min(m,y-(b+1)/2));
    int otherCornX=cornX+a ;
    int otherCornY=cornY+b ;
    cornX-=Math.max(0,otherCornX-n);
    cornY-=Math.max(0,otherCornY-m);
    System.out.println(cornX+" "+cornY+" "+(cornX+a)+" "+(cornY+b));
    out.close();
  }
  static int gcd(int a,int b){
    return b==0 ? a : gcd(b,a % b);
  }
  static class FS {
    BufferedReader in ;
    StringTokenizer token ;
    public FS(InputStream str){
      in=new BufferedReader(new InputStreamReader(str));
    }
    public String next(){
      if(token==null || ! token.hasMoreElements()){
        try {
          token=new StringTokenizer(in.readLine());
        }
        catch(IOException ex){
        }
        return next();
      }
      return token.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FS ; in := FS.newFS(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.nextInt() ;
    var m : int ; m := in.nextInt() ;
    var x : int ; x := in.nextInt() ;
    var y : int ; y := in.nextInt() ;
    var a : int ; a := in.nextInt() ;
    var b : int ; b := in.nextInt() ;
    var gcd : int ; gcd := gcd(a, b) ;
    a := a/(gcd) ; 
    b := b/(gcd) ; 
    var tmp : int ; tmp := Set{n / a, m / b}->min() ;
    a := a*(tmp) ; 
    b := b*(tmp) ; 
    var cornX : int ; cornX := Set{0, Set{n, x - (a + 1) / 2}->min()}->max() ;
    var cornY : int ; cornY := Set{0, Set{m, y - (b + 1) / 2}->min()}->max() ;
    var otherCornX : int ; otherCornX := cornX + a ;
    var otherCornY : int ; otherCornY := cornY + b ;
    cornX := cornX-(Set{0, otherCornX - n}->max()) ; 
    cornY := cornY-(Set{0, otherCornY - m}->max()) ; 
    OclFile["System.out"].println(cornX + " " + cornY + " " + (cornX + a) + " " + (cornY + b)) ; 
    skip ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
  static class FS {
   attribute in : OclFile;
   attribute token : OclIterator;
   static operation newFS( str : OclFile) : FS
  pre: true
  post: true
  activity:
  ( var self : FS ;
    self := createFS();
    self.initialise(str);
    return self );
  operation initialise( str : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(str)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (token = null or not(token.hasNext())) then (     try (     token := OclIterator.newOclIterator_String(in.readLine()) )   catch (ex : IOException) do skip
     return next() ) else skip ; 
     return token.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countOccurrances(int n,int d){
    int count=0 ;
    while(n>0){
      count=(n % 10==d)? count+1 : count ;
      n=n/10 ;
    }
    return count ;
  }
  public static void main(String args[]){
    int d=2 ;
    int n=214215421 ;
    System.out.println(countOccurrances(n,d));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countOccurrances( n : int, d : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n > 0) do (     count := if (n mod 10 = d) then count + 1 else count endif ; 
     n := n / 10 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : int ; d := 2 ;
     var n : int ; n := 214215421 ;
     OclFile["System.out"].println(countOccurrances(n, d)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1609 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int Q=in.nextInt();
    char[] S=in.next().toCharArray();
    int count=0 ;
    for(int n=2 ; n<N ; n++){
      if(S[n-2]=='a' && S[n-1]=='b' && S[n]=='c'){
        count++;
      }
    }
    StringBuilder output=new StringBuilder();
    for(int q=0 ; q<Q ; q++){
      int idx=in.nextInt()-1 ;
      char c=in.next().charAt(0);
      int diff=0 ;
      int from=Math.max(idx,2);
      int to=Math.min(N-1,idx+2);
      for(int i=from ; i<=to ; i++){
        if(S[i-2]=='a' && S[i-1]=='b' && S[i]=='c'){
          diff--;
        }
      }
      S[idx]=c ;
      for(int i=from ; i<=to ; i++){
        if(S[i-2]=='a' && S[i-1]=='b' && S[i]=='c'){
          diff++;
        }
      }
      count+=diff ;
      output.append(count).append('\n');
    }
    System.out.print(output);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1609 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var Q : int ; Q := in.getCurrent()->toInteger() ;
    var S : Sequence(String) ; S := in.getCurrent()->characters() ;
    var count : int ; count := 0 ;
        var n : int ; n := 2 ; while n < N do ( (     if (S[n - 2+1] = 'a' & S[n - 1+1] = 'b' & S[n+1] = 'c') then (     count := count + 1 ) else skip )  ;     n := n + 1 ) ; 
    var output : String ; output := StringLib.newString() ;
        var q : int ; q := 0 ; while q < Q do ( (     var idx : int ; idx := in.getCurrent()->toInteger() - 1 ;
     var c : String ; c := in.getCurrent()->at(0+1) ;
    var diff : int ; diff := 0 ;
    var from : int ; from := Set{idx, 2}->max() ;
    var to : int ; to := Set{N - 1, idx + 2}->min() ;
        var i : int ; i := from ; while i <= to do ( (     if (S[i - 2+1] = 'a' & S[i - 1+1] = 'b' & S[i+1] = 'c') then (     diff := diff - 1 ) else skip )  ;     i := i + 1 ) ; 
    S[idx+1] := c ; 
        var i : int ; i := from ; while i <= to do ( (     if (S[i - 2+1] = 'a' & S[i - 1+1] = 'b' & S[i+1] = 'c') then (     diff := diff + 1 ) else skip )  ;     i := i + 1 ) ; 
    count := count+(diff) ; 
    output := output + StringLib.newString(count) + StringLib.newString('
') ; 
 )  ;     q := q + 1 ) ; 
    OclFile["System.out"].print(output) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1452 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n-->0){
      int x=sc.nextInt();
      int y=sc.nextInt();
      if(x==y){
        System.out.println(x+y);
      }
      else {
        System.out.println(2*Math.max(x,y)-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1452 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     if (x = y) then (     OclFile["System.out"].println(x + y) ) else (     OclFile["System.out"].println(2 * Set{x, y}->max() - 1) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),query=in.nextInt();
    char ch[]=in.next().toCharArray();
    int count=0 ;
    for(int i=0 ; i<n-2 ; i++){
      if(ch[i]=='a' && ch[i+1]=='b' && ch[i+2]=='c'){
        count++;
      }
    }
    for(int q=0 ; q<query ; q++){
      int index=in.nextInt()-1 ;
      char c=in.next().charAt(0);
      int from=Math.max(2,index);
      int to=Math.min(n-1,index+2);
      int dif=0 ;
      for(int i=from ; i<=to ; i++){
        if(ch[i-2]=='a' && ch[i-1]=='b' && ch[i]=='c'){
          dif--;
        }
      }
      ch[index]=c ;
      for(int i=from ; i<=to ; i++){
        if(ch[i-2]=='a' && ch[i-1]=='b' && ch[i]=='c'){
          dif++;
        }
      }
      count+=dif ;
      pw.println(count);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var query : int ; query := in.getCurrent()->toInteger() ;
    var ch : Sequence(String) ; ch := in.getCurrent()->characters() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n - 2 do ( (     if (ch[i+1] = 'a' & ch[i + 1+1] = 'b' & ch[i + 2+1] = 'c') then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
        var q : int ; q := 0 ; while q < query do ( (     var index : int ; index := in.getCurrent()->toInteger() - 1 ;
     var c : String ; c := in.getCurrent()->at(0+1) ;
    var from : int ; from := Set{2, index}->max() ;
    var to : int ; to := Set{n - 1, index + 2}->min() ;
    var dif : int ; dif := 0 ;
        var i : int ; i := from ; while i <= to do ( (     if (ch[i - 2+1] = 'a' & ch[i - 1+1] = 'b' & ch[i+1] = 'c') then (     dif := dif - 1 ) else skip )  ;     i := i + 1 ) ; 
    ch[index+1] := c ; 
        var i : int ; i := from ; while i <= to do ( (     if (ch[i - 2+1] = 'a' & ch[i - 1+1] = 'b' & ch[i+1] = 'c') then (     dif := dif + 1 ) else skip )  ;     i := i + 1 ) ; 
    count := count+(dif) ; 
    skip ; 
 )  ;     q := q + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class test263 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=in.nextInt();
      int k=in.nextInt();
      int a[]=new int[n];
      int b[]=new int[n];
      int sum=0 ;
      for(int i=0 ; i<a.length ; i++){
        a[i]=in.nextInt();
        sum+=a[i];
      }
      for(int i=0 ; i<b.length ; i++){
        b[i]=in.nextInt();
      }
      Arrays.sort(a);
      Arrays.sort(b);
      for(int i=0 ; i<k ; i++){
        if(a[i]<b[n-1-i]){
          sum+=b[n-1-i]-a[i];
        }
      }
      System.out.println(sum);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test263 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < b->size() do ( (     b[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
        var i : int ; i := 0 ; while i < k do ( (     if (a[i+1] < b[n - 1 - i+1]) then (     sum := sum+(b[n - 1 - i+1] - a[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    C solver=new C();
    solver.solve(1,in,out);
    out.close();
  }
  static class C {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int x=Integer.parseInt(in.next());
      int ans=0 ;
      for(int i=0 ; ; i++){
        ans+=i ;
        if(ans>=x){
          out.println(i);
          return ;
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : C ; solver := C.newC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class C {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var x : int ; x := (in.getCurrent())->toInteger() ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while true do ( (     ans := ans+(i) ; 
     if (ans >= x) then (     skip ; 
     return ) else skip )  ;     i := i + 1 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    int n,k=0 ;
    int[] a,b ;
    for(int i=0 ; i<t ; i++){
      n=in.nextInt();
      k=in.nextInt();
      a=new int[n];
      b=new int[n];
      int sum=0 ;
      for(int j=0 ; j<n ; j++){
        a[j]=in.nextInt();
        sum+=a[j];
      }
      for(int j=0 ; j<n ; j++){
        b[j]=in.nextInt();
      }
      Arrays.sort(a);
      Arrays.sort(b);
      int newSum=0 ;
      int ind=(a.length-1);
      for(int j=0 ; j<k ; j++){
        if(a[j]<b[ind]){
          newSum+=b[ind];
        }
        else {
          newSum+=a[j];
        }
        ind=ind-1 ;
      }
      for(int j=k ; j<n ; j++){
        newSum+=a[j];
      }
      if(newSum>sum){
        System.out.println(newSum);
      }
      else System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var n : int ;
    var k : int ; k := 0 ;
    var a : Sequence(int) ;
    var b : Sequence(int) ;
        var i : int ; i := 0 ; while i < t do ( (     n := in.getCurrent()->toInteger() ; 
     k := in.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
    b := Integer.subrange(1,n)->collect(0) ; 
    var sum : int ; sum := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     a[j+1] := in.getCurrent()->toInteger() ; 
     sum := sum+(a[j+1]) )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < n do ( (     b[j+1] := in.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    var newSum : int ; newSum := 0 ;
    var ind : int ; ind := (a->size() - 1) ;
        var j : int ; j := 0 ; while j < k do ( (     if (a[j+1] < b[ind+1]) then (     newSum := newSum+(b[ind+1]) ) else (     newSum := newSum+(a[j+1]) ) ;  
     ind := ind - 1 )  ;     j := j + 1 ) ; 
        var j : int ; j := k ; while j < n do ( (     newSum := newSum+(a[j+1]) )  ;     j := j + 1 ) ; 
    if (newSum > sum) then (     OclFile["System.out"].println(newSum) ) else     OclFile["System.out"].println(sum) ; ;  
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class p4 {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long k=sc.nextLong();
    Long ans=(long)0 ;
    if((2*k)>=n-1){
      ans=(long)(n*(n-1)/2);
    }
    else {
      ans=(long)((n*(n-1)-((n-k*2)*(n-k*2-1)))/2);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p4 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 0->oclAsType(long) ;
    if ((2 * k) >= n - 1) then (     ans := (n * (n - 1) / 2)->oclAsType(long) ) else (     ans := ((n * (n - 1) - ((n - k * 2) * (n - k * 2 - 1))) / 2)->oclAsType(long) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countOp(int arr[],int n,int k){
    int operations=0 ;
    for(int i=1 ; i<n ; i++){
      if(Math.abs(arr[i]-arr[i-1])>k){
        int absDiff=Math.abs(arr[i]-arr[i-1]);
        int currOp=absDiff-k ;
        if(arr[i]<arr[i-1])arr[i]+=currOp ;
        else arr[i]-=currOp ;
        operations+=currOp ;
      }
    }
    return operations ;
  }
  static public void main(String[] arg){
    int arr[]={
      1,2,5,9 };
      int n=arr.length ;
      int k=2 ;
      System.out.println(countOp(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countOp( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var operations : int ; operations := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     if (if arr[i+1] - arr[i - 1+1] < 0 then -(arr[i+1] - arr[i - 1+1]) else arr[i+1] - arr[i - 1+1] endif > k) then (     var absDiff : int ; absDiff := if arr[i+1] - arr[i - 1+1] < 0 then -(arr[i+1] - arr[i - 1+1]) else arr[i+1] - arr[i - 1+1] endif ;
     var currOp : int ; currOp := absDiff - k ;
     if (arr[i+1] < arr[i - 1+1]) then     arr[i+1] := arr[i+1]+(currOp) else     arr[i+1] := arr[i+1]-(currOp) ; ;  
     operations := operations+(currOp) ) else skip )  ;     i := i + 1 ) ; 
     return operations );
  static    operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,5,9} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(countOp(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countOfSubarrays(int[] arr,int n){
    int count=0 ;
    int[] v=new int[n+1];
    for(int i=0 ; i<n ; i++)v[arr[i] ]=i ;
    int maximum=Integer.MIN_VALUE ;
    int minimum=Integer.MAX_VALUE ;
    for(int i=1 ; i<=n ; i++){
      maximum=Math.max(maximum,v[i]);
      minimum=Math.min(minimum,v[i]);
      if(maximum-minimum<i)count=count+1 ;
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      4,1,3,2,5,6 };
      int n=arr.length ;
      System.out.print(countOfSubarrays(arr,n)+"\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countOfSubarrays( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var v : Sequence(int) ; v := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     v[arr[i+1]+1] := i ;  ;     i := i + 1 ) ; 
    var maximum : int ; maximum := -2147483648 ;
    var minimum : int ; minimum := 2147483647 ;
        var i : int ; i := 1 ; while i <= n do ( (     maximum := Set{maximum, v[i+1]}->max() ; 
     minimum := Set{minimum, v[i+1]}->min() ; 
     if (maximum - minimum < i) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,1,3,2,5,6} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(countOfSubarrays(arr, n) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    FastScanner in=new FastScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    ProblemC solver=new ProblemC();
    solver.solve(1,in,out);
    out.close();
  }
  static class ProblemC {
    public void solve(int testNumber,FastScanner in,PrintWriter out){
      int n=in.nextInt();
      int[] l=new int[n+1];
      int[] r=new int[n+1];
      for(int i=0 ; i<n ; i++){
        l[i]=in.nextInt();
        r[i]=in.nextInt();
      }
      Arrays.sort(l);
      Arrays.sort(r);
      long ans=0 ;
      for(int i=0 ; i<n+1 ; i++){
        ans+=Math.max(0,l[n-i]-r[i]);
      }
      ans*=2 ;
      out.println(ans);
    }
  }
  static class FastScanner {
    private BufferedReader in ;
    private StringTokenizer st ;
    public FastScanner(InputStream stream){
      in=new BufferedReader(new InputStreamReader(stream));
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          String rl=in.readLine();
          if(rl==null){
            return null ;
          }
          st=new StringTokenizer(rl);
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : FastScanner ; in := FastScanner.newFastScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : ProblemC ; solver := ProblemC.newProblemC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class ProblemC {
   operation solve( testNumber : int, in : FastScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var l : Sequence(int) ; l := Integer.subrange(1,n + 1)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     l[i+1] := in.nextInt() ; 
     r[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    l := l->sort() ; 
    r := r->sort() ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n + 1 do ( (     ans := ans+(Set{0, l[n - i+1] - r[i+1]}->max()) )  ;     i := i + 1 ) ; 
    ans := ans*(2) ; 
    skip ; 
 );
}
  static class FastScanner {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( stream : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     var rl : String ; rl := in.readLine() ;
     if (rl = null) then (     return null ) else skip ; 
     st := OclIterator.newOclIterator_String(rl) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileNotFoundException ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws FileNotFoundException {
    new Main().run();
  }
  void run()throws FileNotFoundException {
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] L=new int[N+1];
    int[] R=new int[N+1];
    for(int i=0 ; i<N ; ++i){
      L[i]=sc.nextInt();
      R[i]=-sc.nextInt();
    }
    long ans=0 ;
    Arrays.sort(L);
    Arrays.sort(R);
    for(int i=N ; i>=0 ; --i){
      if(L[i]+R[i]>0){
        ans+=2*(L[i]+R[i]);
      }
    }
    System.out.println(ans);
  }
  void tr(Object...objects){
    System.out.println(Arrays.deepToString(objects));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var L : Sequence(int) ; L := Integer.subrange(1,N + 1)->collect(0) ;
    var R : Sequence(int) ; R := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     L[i+1] := sc.getCurrent()->toInteger() ; 
     R[i+1] := -sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    L := L->sort() ; 
    R := R->sort() ; 
        var i : int ; i := N ; while i >= 0 do ( (     if (L[i+1] + R[i+1] > 0) then (     ans := ans+(2 * (L[i+1] + R[i+1])) ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
   operation tr( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((objects + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class PatternA {
  void display(int n){
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<=n/2 ; j++){
        if((j==0 || j==n/2)&& i!=0 || i==0 && j!=0 && j!=n/2 || i==n/2)System.out.print("*");
        else System.out.print(" ");
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    PatternA a=new PatternA();
    a.display(7);
  }
}
------------------------------------------------------------
OCL File:
---------
 class PatternA {
   operation display( n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j <= n / 2 do ( (     if ((j = 0 or j = n / 2) & i /= 0 or i = 0 & j /= 0 & j /= n / 2 or i = n / 2) then     OclFile["System.out"].print("*") ; else     OclFile["System.out"].print(" ") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : PatternA ; a := PatternA.newPatternA() ;
     a.display(7) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int i=scanner.nextInt();
    for(int j=0 ; j<i ; j++){
      int x=scanner.nextInt();
      int y=scanner.nextInt();
      if(Math.abs(x-y)<=1){
        System.out.println(x+y);
      }
      else {
        System.out.println(2*Math.max(x,y)-1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ; i := scanner.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < i do ( (     var x : int ; x := scanner.getCurrent()->toInteger() ;
     var y : int ; y := scanner.getCurrent()->toInteger() ;
     if (if x - y < 0 then -(x - y) else x - y endif <= 1) then (     OclFile["System.out"].println(x + y) ) else (     OclFile["System.out"].println(2 * Set{x, y}->max() - 1) ) )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class B769 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int sum=0 ;
    Student[] students=new Student[N];
    for(int n=0 ; n<N ; n++){
      Student student=new Student();
      student.id=n+1 ;
      int a=in.nextInt();
      student.messages=a ;
      sum+=a ;
      students[n]=student ;
    }
    boolean possible=students[0] .messages>0 && sum>=N-1 ;
    if(possible){
      Arrays.sort(students,1,students.length,new Comparator<Student>(){
        @ Override public int compare(Student o1,Student o2){
          return o2.messages-o1.messages ;
        }
      }
);
      int remains=N-1 ;
      System.out.println(remains);
      int from=0 ;
      int to=1 ;
      while(remains>0){
        Student fromStudent=students[from];
        if(fromStudent.messages>0){
          fromStudent.messages--;
          remains--;
          System.out.println(fromStudent.id+" "+students[to++] .id);
        }
        else {
          from++;
        }
      }
    }
    else {
      System.out.println("-1");
    }
  }
  static class Student {
    int id ;
    int messages ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B769 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var students : Sequence(Student) ; students := Integer.subrange(1,N)->collect(null) ;
        var n : int ; n := 0 ; while n < N do ( (     var student : Student ; student := Student.newStudent() ;
     student.id := n + 1 ; 
    var a : int ; a := in.getCurrent()->toInteger() ;
    student.messages := a ; 
    sum := sum+(a) ; 
    students[n+1] := student ; 
 )  ;     n := n + 1 ) ; 
    var possible : boolean ; possible := students[0+1].messages > 0 & sum >= N - 1 ;
    if (possible) then (     students, 1, students->size(), OclComparator<Student>.newOclComparator() := students, 1, students->size(), OclComparator<Student>.newOclComparator()->sort() ; 
     var remains : int ; remains := N - 1 ;
    OclFile["System.out"].println(remains) ; 
    var from : int ; from := 0 ;
    var to : int ; to := 1 ;
    while (remains > 0) do (     var fromStudent : Student ; fromStudent := students[from+1] ;
     if (fromStudent.messages > 0) then (     fromStudent.messages := fromStudent.messages - 1 ; 
     remains := remains - 1 ; 
     OclFile["System.out"].println(fromStudent.id + " " + students[to+1].id) ) else (     from := from + 1 ) ) ; 
 ) else (     OclFile["System.out"].println("-1") ) ;  
 );
  static class Student {
   attribute id : int;
   attribute messages : int;
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int N=10 ;
  static int findMinimumDeletion(int l,int r,int dp[][],String s){
    if(l>r){
      return 0 ;
    }
    if(l==r){
      return 1 ;
    }
    if(dp[l][r]!=-1){
      return dp[l][r];
    }
    int res=1+findMinimumDeletion(l+1,r,dp,s);
    for(int i=l+1 ; i<=r ; ++i){
      if(s.charAt(l)==s.charAt(i)){
        res=Math.min(res,findMinimumDeletion(l+1,i-1,dp,s)+findMinimumDeletion(i,r,dp,s));
      }
    }
    return dp[l][r]=res ;
  }
  public static void main(String[] args){
    String s="abcddcba" ;
    int n=s.length();
    int dp[][]=new int[N][N];
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        dp[i][j]=-1 ;
      }
    }
    System.out.println(findMinimumDeletion(0,n-1,dp,s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute N : int := 10;
  static   operation findMinimumDeletion( l : int, r : int, dp : Sequence(Sequence(int)), s : String) : int
  pre: true
  post: true
  activity: (     if (l > r) then (     return 0 ) else skip ; 
     if (l = r) then (     return 1 ) else skip ; 
    if (dp[l+1][r+1] /= -1) then (     return dp[l+1][r+1] ) else skip ; 
    var res : int ; res := 1 + findMinimumDeletion(l + 1, r, dp, s) ;
        var i : int ; i := l + 1 ; while i <= r do ( (     if (s->at(l+1) = s->at(i+1)) then (     res := Set{res, findMinimumDeletion(l + 1, i - 1, dp, s) + findMinimumDeletion(i, r, dp, s)}->min() ) else skip )  ;     i := i + 1 ) ; 
    return dp[l+1][r+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abcddcba" ;
     var n : int ; n := s->size() ;
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     dp[i+1][j+1] := -1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(findMinimumDeletion(0, (n)->char2byte() - 1, dp, s)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
import java.awt.geom.*;
import java.io.*;
public class Main {
  static int month[]=new int[] {
    31,29,31,30,31,30,31,31,30,31,30,31 };
    static int day[]=new int[13];
    public static void main(String[] args){
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int k=sc.nextInt();
      boolean[][] bunny=new boolean[k][n];
      for(int i=0 ; i<k ; i++){
        int m=sc.nextInt();
        for(int j=0 ; j<m ; j++){
          bunny[i][sc.nextInt()-1]=true ;
        }
      }
      int r=sc.nextInt();
      boolean[] check=new boolean[n];
      for(int i=0 ; i<r ; i++){
        int p=sc.nextInt()-1 ;
        int q=sc.nextInt()-1 ;
        for(int j=0 ; j<k ; j++){
          if(bunny[j][p] && bunny[j][q]){
            check[p]=true ;
            check[q]=true ;
          }
        }
      }
      int count=0 ;
      for(int i=0 ; i<n ; i++){
        if(check[i])count++;
      }
      System.out.println(count);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute month : int := Sequence{31,29,31,30,31,30,31,31,30,31,30,31};
  static   attribute day : int := Integer.subrange(1,13)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var bunny : Sequence(Sequence(boolean)) ; bunny := Integer.subrange(1,k)->collect(Integer.subrange(1,n)->collect(false)) ;
        var i : int ; i := 0 ; while i < k do ( (     var m : int ; m := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < m do ( (     bunny[i+1][sc.getCurrent()->toInteger() - 1+1] := true )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var check : Sequence(boolean) ; check := Integer.subrange(1,n)->collect(false) ;
        var i : int ; i := 0 ; while i < r do ( (     var p : int ; p := sc.getCurrent()->toInteger() - 1 ;
     var q : int ; q := sc.getCurrent()->toInteger() - 1 ;
         var j : int ; j := 0 ; while j < k do ( (     if (bunny[j+1][p+1] & bunny[j+1][q+1]) then (     check[p+1] := true ; 
     check[q+1] := true ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (check[i+1]) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class c {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int T=input.nextInt();
    for(int t=1 ; t<=T ; t++){
      System.out.print("Case #"+t+": ");
      int n=input.nextInt();
      PriorityQueue<Double>finish=new PriorityQueue<Double>();
      PriorityQueue<Hiker>lap=new PriorityQueue<Hiker>();
      for(int i=0 ; i<n ; i++){
        int d=input.nextInt();
        int h=input.nextInt();
        int m=input.nextInt();
        for(int j=0 ; j<h ; j++){
          int time=m+j ;
          double ft=time*(360.0-d)/360 ;
          finish.add(ft);
          lap.add(new Hiker(ft+time,time));
        }
      }
      int size=lap.size();
      int res=size,count=size ;
      while(! finish.isEmpty()){
        while(count<2*size && lap.peek().time<=finish.peek()){
          Hiker h=lap.poll();
          count++;
          h.time+=h.add ;
          lap.add(h);
        }
        if(count==2*size)break ;
        count--;
        res=Math.min(res,count);
        double x=finish.poll();
      }
      System.out.println(res);
    }
  }
  static class Hiker implements Comparable<Hiker>{
    double time ;
    double add ;
    public Hiker(double tt,double aa){
      time=tt ;
      add=aa ;
    }
    @ Override public int compareTo(Hiker o){
      return Double.compare(time,o.time);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class c {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := input.getCurrent()->toInteger() ;
         var t : int ; t := 1 ; while t <= T do ( (     OclFile["System.out"].print("Case #" + t + ": ") ; 
     var n : int ; n := input.getCurrent()->toInteger() ;
    var finish : Sequence(double) ; finish := Sequence{} ;
    var lap : Sequence(Hiker) ; lap := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var d : int ; d := input.getCurrent()->toInteger() ;
     var h : int ; h := input.getCurrent()->toInteger() ;
     var m : int ; m := input.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < h do ( (     var time : int ; time := m + j ;
     var ft : double ; ft := time * (360.0 - d) / 360 ;
     finish := finish->including(ft) ; 
     lap := lap->including(Hiker.newHiker(ft + time, time)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var size : int ; size := lap->size() ;
    var res : int ; res := size ;
    var count : int ; count := size ;
    while (not(finish->isEmpty())) do (     while (count < 2 * size & lap->min().time <= finish->min()) do (     var h : Hiker ; h := lap->min() ;
     count := count + 1 ; 
     h.time := h.time+(h.add) ; 
     lap := lap->including(h) ) ; 
     if (count = 2 * size) then     break else skip ; 
    count := count - 1 ; 
    res := Set{res, count}->min() ; 
    var x : double ; x := finish->min() ;
 ) ; 
    OclFile["System.out"].println(res) ; 
 )  ;     t := t + 1 ) );
  static class Hiker implements Comparable<Hiker> {
   attribute time : double;
   attribute add : double;
   static operation newHiker( tt : double, aa : double) : Hiker
  pre: true
  post: true
  activity:
  ( var self : Hiker ;
    self := createHiker();
    self.initialise(tt, aa);
    return self );
  operation initialise( tt : double, aa : double) : void
  pre: true  post: true
  activity: (     time := tt ; 
     add := aa );
      operation compareTo( o : Hiker) : int
  pre: true
  post: true
  activity: (     return (time)->compareTo(o.time) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    MyReader r=new MyReader();
    long X=r.i();
    long t=(long)(-1+Math.sqrt(8*X+1))/2 ;
    while(t*(t+1)<X*2)t++;
    println(t);
  }
  static void print(Object o){
    System.out.print(o.toString());
  }
  static void println(Object o){
    System.out.println(o.toString());
  }
  static int Int(String s){
    return Integer.parseInt(s);
  }
  static long Long(String s){
    return Long.parseLong(s);
  }
  static class MyReader extends BufferedReader {
    MyReader(){
      super(new InputStreamReader(System.in));
    }
    String s()throws IOException {
      return readLine();
    }
    String[] ss()throws IOException {
      return s().split(" ");
    }
    int i()throws IOException {
      return Int(s());
    }
    int[] ii()throws IOException {
      String[] ss=ss();
      int size=ss.length ;
      int[] ii=new int[size];
      for(int j=0 ; j<size ; j++)ii[j]=Integer.parseInt(ss[j]);
      return ii ;
    }
    long l()throws IOException {
      return Long(s());
    }
    long[] ll()throws IOException {
      String[] ss=ss();
      int size=ss.length ;
      long[] ll=new long[size];
      for(int j=0 ; j<size ; j++)ll[j]=Long.parseLong(ss[j]);
      return ll ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : MyReader ; r := MyReader.newMyReader() ;
     var X : long ; X := r.i() ;
    var t : long ; t := (-1 + (8 * X + 1)->sqrt())->oclAsType(long) / 2 ;
    while (t * (t + 1) < X * 2) do     t := t + 1 ; ; 
    execute println(t) ; 
 );
  static   operation print( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o+"") );
  static   operation println( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o+"") );
  static   operation Int( s : String) : int
  pre: true
  post: true
  activity: (     return (s)->toInteger() );
  static   operation Long( s : String) : long
  pre: true
  post: true
  activity: (     return (s)->toLong() );
  static class MyReader extends OclFile {
   static operation newMyReader() : MyReader
  pre: true
  post: true
  activity:
  ( var self : MyReader ;
    self := createMyReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation s() : String
  pre: true
  post: true
  activity: (     return readLine() );
   operation ss() : Sequence(String)
  pre: true
  post: true
  activity: (     return s()->split(" ") );
   operation i() : int
  pre: true
  post: true
  activity: (     return Int(s()) );
   operation ii() : Sequence(int)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var size : int ; size := ss->size() ;
    var ii : Sequence(int) ; ii := Integer.subrange(1,size)->collect(0) ;
        var j : int ; j := 0 ; while j < size do (     ii[j+1] := (ss[j+1])->toInteger() ;  ;     j := j + 1 ) ; 
    return ii 
 );
   operation l() : long
  pre: true
  post: true
  activity: (     return Long(s()) );
   operation ll() : Sequence(long)
  pre: true
  post: true
  activity: (     var ss : Sequence(String) ; ss := ss() ;
     var size : int ; size := ss->size() ;
    var ll : Sequence(long) ; ll := Integer.subrange(1,size)->collect(0) ;
        var j : int ; j := 0 ; while j < size do (     ll[j+1] := (ss[j+1])->toLong() ;  ;     j := j + 1 ) ; 
    return ll 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main extends Template {
  public void solve()throws IOException {
    int n=nextInt();
    int k=nextInt();
    int[] rabbit=new int[n+1];
    for(int i=0 ; i<k ; i++){
      int num=nextInt();
      for(int j=0 ; j<num ; j++){
        rabbit[nextInt()]=i ;
      }
    }
    int count=0 ;
    int r=nextInt();
    boolean[] check=new boolean[n+1];
    for(int i=0 ; i<r ; i++){
      int x=nextInt();
      int y=nextInt();
      if(rabbit[x]==rabbit[y]){
        check[x]=true ;
        check[y]=true ;
      }
    }
    for(int i=1 ; i<=n ; i++){
      if(check[i]){
        count++;
      }
    }
    System.out.println(count);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
abstract class Template implements Runnable {
  public abstract void solve()throws IOException ;
  BufferedReader reader ;
  StringTokenizer tokenizer ;
  PrintWriter writer ;
  public void run(){
    try {
      reader=new BufferedReader(new InputStreamReader(System.in));
      tokenizer=null ;
      writer=new PrintWriter(System.out);
      solve();
      reader.close();
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  public String nextToken()throws IOException {
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends Template {
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var k : int ; k := nextInt() ;
    var rabbit : Sequence(int) ; rabbit := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     var num : int ; num := nextInt() ;
         var j : int ; j := 0 ; while j < num do ( (     rabbit[nextInt()+1] := i )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var r : int ; r := nextInt() ;
    var check : Sequence(boolean) ; check := Integer.subrange(1,n + 1)->collect(false) ;
        var i : int ; i := 0 ; while i < r do ( (     var x : int ; x := nextInt() ;
     var y : int ; y := nextInt() ;
     if (rabbit[x+1] = rabbit[y+1]) then (     check[x+1] := true ; 
     check[y+1] := true ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (check[i+1]) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}
class Template implements Runnable {
     operation solve() : void
  pre: true
  post: true;
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   attribute writer : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     try (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := null ; 
    writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static ArrayList<HashSet<Integer>>list=new ArrayList<HashSet<Integer>>();
  static int N,K ;
  static boolean[] areYouFine ;
  static int[][] pair ;
  public static void main(String[] args){
    while(read()){
      solve();
      list.removeAll(list);
    }
  }
  static boolean read(){
    if(! sc.hasNext())return false ;
    N=sc.nextInt();
    areYouFine=new boolean[N+1];
    Arrays.fill(areYouFine,true);
    K=sc.nextInt();
    for(int i=0 ; i<K ; i++){
      int rabbitsRidingOnBoat=sc.nextInt();
      HashSet<Integer>boat=new HashSet<Integer>();
      for(int j=0 ; j<rabbitsRidingOnBoat ; j++){
        boat.add(sc.nextInt());
      }
      list.add(boat);
    }
    int row=sc.nextInt();
    pair=new int[row][2];
    for(int i=0 ; i<pair.length ; i++){
      pair[i][0]=sc.nextInt();
      pair[i][1]=sc.nextInt();
    }
    return true ;
  }
  static void solve(){
    int res=0 ;
    for(int i=0 ; i<pair.length ; i++){
      int rabbit1=pair[i][0],rabbit2=pair[i][1];
      for(int j=0 ; j<list.size(); j++){
        HashSet<Integer>boat=list.get(j);
        if(boat.contains(rabbit1)&& boat.contains(rabbit2)){
          areYouFine[rabbit1]=false ;
          areYouFine[rabbit2]=false ;
        }
      }
    }
    for(boolean rabbt : areYouFine){
      if(! rabbt)res++;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute list : Sequence(Set(int)) := Sequence{};
  static   attribute N : int;
  static   attribute areYouFine : Sequence(boolean);
  static   attribute pair : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (read()) do (     execute solve() ; 
     list := list - list ) );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     if (not(sc.hasNext())) then     return false else skip ; 
     N := sc.getCurrent()->toInteger() ; 
    areYouFine := Integer.subrange(1,N + 1)->collect(false) ; 
    areYouFine := areYouFine->collect(true) ; 
    K := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < K do ( (     var rabbitsRidingOnBoat : int ; rabbitsRidingOnBoat := sc.getCurrent()->toInteger() ;
     var boat : Set(int) ; boat := Set{} ;
         var j : int ; j := 0 ; while j < rabbitsRidingOnBoat do ( (     boat := boat->including(sc.getCurrent()->toInteger()) )  ;     j := j + 1 ) ; 
     list := list->including(boat) )  ;     i := i + 1 ) ; 
    var row : int ; row := sc.getCurrent()->toInteger() ;
    pair := Integer.subrange(1,row)->collect(Integer.subrange(1,2)->collect(0)) ; 
        var i : int ; i := 0 ; while i < pair->size() do ( (     pair[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     pair[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < pair->size() do ( (     var rabbit1 : int ; rabbit1 := pair[i+1][0+1] ;
    var rabbit2 : int ; rabbit2 := pair[i+1][1+1] ;
         var j : int ; j := 0 ; while j < list->size() do ( (     var boat : Set(int) ; boat := list->at(j+1) ;
     if (boat->includes(rabbit1) & boat->includes(rabbit2)) then (     areYouFine[rabbit1+1] := false ; 
     areYouFine[rabbit2+1] := false ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     for (rabbt : areYouFine) do ( (     if (not(rabbt)) then     res := res + 1 ; else skip )  ) ; 
     OclFile["System.out"].println(res) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.List ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      int N=in.nextInt();
      int K=in.nextInt();
      HashMap<Integer,ArrayList<Integer>>HM=new HashMap<Integer,ArrayList<Integer>>();
      HashSet<Integer>Ans=new HashSet<Integer>();
      for(int i=0 ; i<K ; i++){
        int n=in.nextInt();
        ArrayList<Integer>AL=new ArrayList<Integer>();
        for(int j=0 ; j<n ; j++)AL.add(in.nextInt());
        HM.put(i,AL);
      }
      int R=in.nextInt();
      for(int i=0 ; i<R ; i++){
        int a=in.nextInt();
        int b=in.nextInt();
        for(int j=0 ; j<HM.size(); j++){
          boolean j1=false ;
          boolean j2=false ;
          ArrayList<Integer>A=new ArrayList<Integer>(HM.get(j));
          for(int k=0 ; k<A.size(); k++){
            if(a==A.get(k))j1=true ;
            if(b==A.get(k))j2=true ;
          }
          if(j1 && j2){
            Ans.add(a);
            Ans.add(b);
          }
        }
      }
      System.out.println(Ans.size());
    }
  }
  static public void debug(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var N : int ; N := in.getCurrent()->toInteger() ;
     var K : int ; K := in.getCurrent()->toInteger() ;
    var HM : Map(int,Sequence(int)) ; HM := Map{} ;
    var Ans : Set(int) ; Ans := Set{} ;
        var i : int ; i := 0 ; while i < K do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var AL : Sequence(int) ; AL := Sequence{} ;
         var j : int ; j := 0 ; while j < n do (     AL := AL->including(in.getCurrent()->toInteger()) ;  ;     j := j + 1 ) ; 
     HM := HM->union(Map{i |-> AL}) )  ;     i := i + 1 ) ; 
    var R : int ; R := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < R do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < HM.size() do ( (     var j1 : boolean ; j1 := false ;
     var j2 : boolean ; j2 := false ;
    var A : Sequence(int) ; A := Sequence{}->union(HM->at(j)) ;
        var k : int ; k := 0 ; while k < A->size() do ( (     if (a = A->at(k+1)) then     j1 := true ; else skip ; 
     if (b = A->at(k+1)) then     j2 := true ; else skip )  ;     k := k + 1 ) ; 
    if (j1 & j2) then (     Ans := Ans->including(a) ; 
     Ans := Ans->including(b) ) else skip ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Ans->size()) ; 
 ) );
  static    operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int MOD=1_000_000_007 ;
    char[] T=sc.next().toCharArray();
    long[] dp=new long[5];
    dp[1]=1 ;
    for(int i=0 ; i<T.length ; i++){
      if(T[i]=='?'){
        for(int j=4 ; j>=1 ; j--)dp[j]=(3*dp[j]+dp[j-1])% MOD ;
      }
      else dp[T[i]-'A'+2]=dp[T[i]-'A'+2]+dp[T[i]-'A'+1];
    }
    System.out.println(dp[4] % MOD);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var MOD : int ; MOD := 1_000_000_007 ;
    var T : Sequence(String) ; T := sc.getCurrent()->characters() ;
    var dp : Sequence(long) ; dp := Integer.subrange(1,5)->collect(0) ;
    dp[1+1] := 1 ; 
        var i : int ; i := 0 ; while i < T->size() do ( (     if (T[i+1] = '?') then (         var j : int ; j := 4 ; while j >= 1 do (     dp[j+1] := (3 * dp[j+1] + dp[j - 1+1]) mod MOD ;  ;     j := j - 1 ) ) else     dp[T[i+1] - ('A')->char2byte() + 2+1] := dp[T[i+1] - ('A')->char2byte() + 2+1] + dp[T[i+1] - ('A')->char2byte() + 1+1] ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[4+1] mod MOD) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class RobotProgram {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      if(x==y)System.out.println(x+y);
      else {
        int result=2*Math.max(x,y)-1 ;
        System.out.println(result);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class RobotProgram {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     if (x = y) then     OclFile["System.out"].println(x + y) ; else (     var result : int ; result := 2 * Set{x, y}->max() - 1 ;
     OclFile["System.out"].println(result) ) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    long N=1_000_000_007L ;
    Scanner scanner=new Scanner(System.in);
    String str=scanner.next();
    long[][] d=new long[str.length()+1][4];
    d[0][0]=1 ;
    for(int i=1 ; i<=str.length(); i++){
      char ch=str.charAt(i-1);
      int m=ch=='?' ? 3 : 1 ;
      d[i][0]=d[i-1][0]*m % N ;
      d[i][1]=d[i-1][1]*m % N ;
      d[i][2]=d[i-1][2]*m % N ;
      d[i][3]=d[i-1][3]*m % N ;
      switch(ch){
        case 'A' : d[i][1]+=d[i-1][0];
        break ;
        case 'B' : d[i][2]+=d[i-1][1];
        break ;
        case 'C' : d[i][3]+=d[i-1][2];
        break ;
        case '?' : d[i][1]+=d[i-1][0];
        d[i][2]+=d[i-1][1];
        d[i][3]+=d[i-1][2];
        break ;
        default : throw new IllegalArgumentException();
      }
      for(int j=0 ; j<4 ; j++){
        d[i][j] %=N ;
      }
    }
    System.out.println(d[str.length()][3]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := 1_000_000_007L ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var str : String ; str := scanner.getCurrent() ;
    var d : Sequence(Sequence(long)) ; d := Integer.subrange(1,str->size() + 1)->collect(Integer.subrange(1,4)->collect(0)) ;
    d[0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= str->size() do ( (     var ch : String ; ch := str->at(i - 1+1) ;
     var m : int ; m := if ch = '?' then 3 else 1 endif ;
    d[i+1][0+1] := d[i - 1+1][0+1] * m mod N ; 
    d[i+1][1+1] := d[i - 1+1][1+1] * m mod N ; 
    d[i+1][2+1] := d[i - 1+1][2+1] * m mod N ; 
    d[i+1][3+1] := d[i - 1+1][3+1] * m mod N ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (ch) ; 
       if _switchval = 'A' then
     d[i+1][1+1] := d[i+1][1+1]+(d[i - 1+1][0+1]) ; 
    break 
   else skip ;
       if _switchval = 'B' then
     d[i+1][2+1] := d[i+1][2+1]+(d[i - 1+1][1+1]) ; 
    break 
   else skip ;
       if _switchval = 'C' then
     d[i+1][3+1] := d[i+1][3+1]+(d[i - 1+1][2+1]) ; 
    break 
   else skip ;
       if _switchval = '?' then
     d[i+1][1+1] := d[i+1][1+1]+(d[i - 1+1][0+1]) ; 
    d[i+1][2+1] := d[i+1][2+1]+(d[i - 1+1][1+1]) ; 
    d[i+1][3+1] := d[i+1][3+1]+(d[i - 1+1][2+1]) ; 
    break 
   else skip ;
       if true then
     error IllegalArgumentException.newIllegalArgumentException() ; 
   else skip ;
 )
        var j : int ; j := 0 ; while j < 4 do ( (     d[i+1][j+1] := d[i+1][j+1] mod N )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(d[str->size()+1][3+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static void main(String...args){
    int M=1_000_000_007 ;
    String S=IN.next();
    long a=0 ;
    long ab=0 ;
    long abc=0 ;
    long t=1 ;
    for(int i=0 ; i<S.length(); i++){
      switch(S.charAt(i)){
        case 'A' : a=(a+t)% M ;
        break ;
        case 'B' : ab=(ab+a)% M ;
        break ;
        case 'C' : abc=(abc+ab)% M ;
        break ;
        default : abc=(abc*3+ab)% M ;
        ab=(ab*3+a)% M ;
        a=(a*3+t)% M ;
        t=(t*3)% M ;
      }
    }
    puts(abc);
    flush();
  }
  static final Scanner IN=new Scanner(System.in);
  static final PrintWriter OUT=new PrintWriter(System.out);
  static<T>void puts(T arg){
    OUT.println(arg);
  }
  static void flush(){
    OUT.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var M : int ; M := 1_000_000_007 ;
     var S : String ; S := IN.next() ;
    var a : long ; a := 0 ;
    var ab : long ; ab := 0 ;
    var abc : long ; abc := 0 ;
    var t : long ; t := 1 ;
        var i : int ; i := 0 ; while i < S->size() do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (S->at(i+1)) ; 
       if _switchval = 'A' then
     a := (a + t) mod M ; 
    break 
   else skip ;
       if _switchval = 'B' then
     ab := (ab + a) mod M ; 
    break 
   else skip ;
       if _switchval = 'C' then
     abc := (abc + ab) mod M ; 
    break 
   else skip ;
       if true then
     abc := (abc * 3 + ab) mod M ; 
    ab := (ab * 3 + a) mod M ; 
    a := (a * 3 + t) mod M ; 
    t := (t * 3) mod M ; 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    execute puts(abc) ; 
    execute flush() ; 
 );
  static    attribute IN : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute OUT : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation puts<T>( arg : T) : void
  pre: true
  post: true
  activity: (     skip );
  static   operation flush() : void
  pre: true
  post: true
  activity: (     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    long mod=1000000007L ;
    String ABC="ABC" ;
    long[][] dp=new long[S.length()][4];
    if(S.charAt(0)=='?'){
      dp[0][0]=3 ;
    }
    else {
      dp[0][0]=1 ;
    }
    if(S.charAt(0)=='A' || S.charAt(0)=='?'){
      dp[0][1]=1 ;
    }
    for(int i=1 ; i<S.length(); i++){
      for(int j=0 ; j<4 ; j++){
        if(j==0){
          if(S.charAt(i)=='A' || S.charAt(i)=='B' || S.charAt(i)=='C'){
            dp[i][0]=dp[i-1][0];
          }
          else {
            dp[i][0]=dp[i-1][0]*3L ;
          }
          dp[i][j] %=mod ;
        }
        else {
          long x=(S.charAt(i)=='?' ? 3L : 1L);
          long y=((S.charAt(i)==ABC.charAt(j-1)|| S.charAt(i)=='?')? 1L : 0L);
          dp[i][j]=(dp[i-1][j]*x)+(dp[i-1][j-1]*y);
          dp[i][j] %=mod ;
        }
      }
    }
    System.out.println(dp[S.length()-1][3]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
    var mod : long ; mod := 1000000007L ;
    var ABC : String ; ABC := "ABC" ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,S->size())->collect(Integer.subrange(1,4)->collect(0)) ;
    if (S->at(0+1) = '?') then (     dp[0+1][0+1] := 3 ) else (     dp[0+1][0+1] := 1 ) ;  
    if (S->at(0+1) = 'A' or S->at(0+1) = '?') then (     dp[0+1][1+1] := 1 ) else skip ; 
        var i : int ; i := 1 ; while i < S->size() do ( (         var j : int ; j := 0 ; while j < 4 do ( (     if (j = 0) then (     if (S->at(i+1) = 'A' or S->at(i+1) = 'B' or S->at(i+1) = 'C') then (     dp[i+1][0+1] := dp[i - 1+1][0+1] ) else (     dp[i+1][0+1] := dp[i - 1+1][0+1] * 3L ) ;  
     dp[i+1][j+1] := dp[i+1][j+1] mod mod ) else (     var x : long ; x := (if S->at(i+1) = '?' then 3L else 1L endif) ;
     var y : long ; y := (if (S->at(i+1) = ABC->at(j - 1+1) or S->at(i+1) = '?') then 1L else 0L endif) ;
     dp[i+1][j+1] := (dp[i - 1+1][j+1] * x) + (dp[i - 1+1][j - 1+1] * y) ; 
     dp[i+1][j+1] := dp[i+1][j+1] mod mod ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[S->size() - 1+1][3+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
public class Main {
  public static final long MOD=1_000_000_007 ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String s=in.nextLine();
    long[][] dp=new long[s.length()+1][4];
    for(int i=s.length(); 0<=i ; i--){
      for(int j=3 ; 0<=j ; j--){
        if(i==s.length()){
          dp[i][j]=j==3 ? 1L : 0L ;
        }
        else {
          dp[i][j]=dp[i+1][j]*(s.charAt(i)=='?' ? 3L : 1L);
          if(j<3 &&(s.charAt(i)=='?' || s.charAt(i)=="ABC".charAt(j))){
            dp[i][j]+=dp[i+1][j+1];
          }
          dp[i][j] %=MOD ;
        }
      }
    }
    System.out.println(dp[0][0]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := in.nextLine() ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,s->size() + 1)->collect(Integer.subrange(1,4)->collect(0)) ;
        var i : int ; i := s->size() ; while 0 <= i do ( (         var j : int ; j := 3 ; while 0 <= j do ( (     if (i = s->size()) then (     dp[i+1][j+1] := if j = 3 then 1L else 0L endif ) else (     dp[i+1][j+1] := dp[i + 1+1][j+1] * (if s->at(i+1) = '?' then 3L else 1L endif) ; 
     if (j < 3 & (s->at(i+1) = '?' or s->at(i+1) = "ABC"->at(j+1))) then (     dp[i+1][j+1] := dp[i+1][j+1]+(dp[i + 1+1][j + 1+1]) ) else skip ; 
     dp[i+1][j+1] := dp[i+1][j+1] mod MOD ) )  ;     j := j - 1 ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(dp[0+1][0+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int uniqueRows(int[][] s,int m,int n){
    int i,j,count=0 ;
    for(i=0 ; i<n ; i++){
      for(j=0 ; j<i ; j++){
        if(s[i]==s[j]){
          count++;
          break ;
        }
      }
    }
    if(count>=1)System.out.println("No");
    else System.out.println("Yes");
    return 0 ;
  }
  public static void main(String[] args){
    int m=3,n=3 ;
    int s[][]={
      {
        1,0,1 },{
          0,0,0 },{
            1,0,0 }
          };
          uniqueRows(s,m,n);
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation uniqueRows( s : Sequence(Sequence(int)), m : int, n : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var count : int ; count := 0 ;
         i := 0 ; while i < n do ( (         j := 0 ; while j < i do ( (     if (s[i+1] = s[j+1]) then (     count := count + 1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     if (count >= 1) then     OclFile["System.out"].println("No") else     OclFile["System.out"].println("Yes") ; ;  
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 3 ;
    var n : int ; n := 3 ;
     var s : Sequence(Sequence(int)) ; s := Sequence{Sequence{1,0,1},Sequence{0,0,0},Sequence{1,0,0}} ;
     execute uniqueRows(s, m, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    long X=scan.nextLong();
    long answer=0 ;
    for(long i=1 ; i<=100000 ; i++){
      if(X<=i*(i+1)/2){
        answer=i ;
        break ;
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var X : long ; X := scan.getCurrent()->toLong() ;
    var answer : long ; answer := 0 ;
        var i : long ; i := 1 ; while i <= 100000 do ( (     if (X <= i * (i + 1) / 2) then (     answer := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int PositionRightmostSetbit(int n){
    int position=1 ;
    int m=1 ;
    while((n & m)==0){
      m=m<<1 ;
      position++;
    }
    return position ;
  }
  public static void main(String[] args){
    int n=16 ;
    System.out.println(PositionRightmostSetbit(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation PositionRightmostSetbit( n : int) : int
  pre: true
  post: true
  activity: (     var position : int ; position := 1 ;
     var m : int ; m := 1 ;
     while ((n & m) = 0) do (     m := (m*(2->pow(1)))->oclAsType(long) ; 
     position := position + 1 ) ; 
     return position );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 16 ;
     OclFile["System.out"].println(PositionRightmostSetbit(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class MajorityElement {
  private static void findMajority(int[] arr){
    HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();
    for(int i=0 ; i<arr.length ; i++){
      if(map.containsKey(arr[i])){
        int count=map.get(arr[i])+1 ;
        if(count>arr.length/2){
          System.out.println("Majority found :-"+arr[i]);
          return ;
        }
        else map.put(arr[i],count);
      }
      else map.put(arr[i],1);
    }
    System.out.println(" No Majority element");
  }
  public static void main(String[] args){
    int a[]=new int[] {
      2,2,2,2,5,5,2,3,3 };
      findMajority(a);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class MajorityElement {
  static   operation findMajority( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var map : Map(int,int) ; map := Map{} ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     if (map->keys()->includes(arr[i+1])) then (     var count : int ; count := map->at(arr[i+1]) + 1 ;
     if (count > arr->size() / 2) then (     OclFile["System.out"].println("Majority found :-" + arr[i+1]) ; 
     return ) else     map := map->union(Map{arr[i+1] |-> count}) ; ) else     map := map->union(Map{arr[i+1] |-> 1}) ; )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(" No Majority element") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{2,2,2,2,5,5,2,3,3} ;
     execute findMajority(a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float rectanglearea(float r){
    if(r<0)return-1 ;
    float a=r*r ;
    return a ;
  }
  public static void main(String[] args){
    float r=5 ;
    System.out.println((int)rectanglearea(r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation rectanglearea( r : double) : double
  pre: true
  post: true
  activity: (     if (r < 0) then     return -1 else skip ; 
     var a : double ; a := r * r ;
     return a );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : double ; r := 5 ;
     OclFile["System.out"].println(rectanglearea(r)->oclAsType(int)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float ellipsearea(float r){
    if(r<0)return-1 ;
    float a=(float)((3.14f*r*r)/4);
    return a ;
  }
  public static void main(String[] args){
    float r=5 ;
    System.out.println(ellipsearea(r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation ellipsearea( r : double) : double
  pre: true
  post: true
  activity: (     if (r < 0) then     return -1 else skip ; 
     var a : double ; a := ((3.14f * r * r) / 4)->oclAsType(double) ;
     return a );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : double ; r := 5 ;
     OclFile["System.out"].println(ellipsearea(r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static void reverse(String str,int x){
    int n=(str.length()-x)/2 ;
    for(int i=0 ; i<n ; i++)System.out.print(str.charAt(i));
    for(int i=n+x-1 ; i>=n ; i--)System.out.print(str.charAt(i));
    for(int i=n+x ; i<str.length(); i++)System.out.print(str.charAt(i));
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    int x=3 ;
    reverse(str,x);
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation reverse( str : String, x : int) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (str->size() - x) / 2 ;
         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(str->at(i+1)) ;  ;     i := i + 1 ) ; 
         var i : int ; i := n + x - 1 ; while i >= n do (     OclFile["System.out"].print(str->at(i+1)) ;  ;     i := i - 1 ) ; 
         var i : int ; i := n + x ; while i < str->size() do (     OclFile["System.out"].print(str->at(i+1)) ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     var x : int ; x := 3 ;
     execute reverse(str, x) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class lol {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int a=in.nextInt();
    int sum=0 ;
    int[] arr=new int[12];
    int jok=0 ;
    for(int i=0 ; i<12 ; i++){
      arr[i]=in.nextInt();
      jok+=arr[i];
    }
    Arrays.sort(arr);
    int cnt=0 ;
    if(a==0){
      System.out.println("0");
      return ;
    }
    else if(jok<a){
      System.out.println("-1");
      return ;
    }
    for(int i=arr.length-1 ; i>=0 ; i--){
      sum+=arr[i];
      cnt++;
      if(sum>=a){
        break ;
      }
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class lol {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := in.getCurrent()->toInteger() ;
    var sum : int ; sum := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,12)->collect(0) ;
    var jok : int ; jok := 0 ;
        var i : int ; i := 0 ; while i < 12 do ( (     arr[i+1] := in.getCurrent()->toInteger() ; 
     jok := jok+(arr[i+1]) )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var cnt : int ; cnt := 0 ;
    if (a = 0) then (     OclFile["System.out"].println("0") ; 
     return ) else     if (jok < a) then (     OclFile["System.out"].println("-1") ; 
     return ) else skip ; ;  
        var i : int ; i := arr->size() - 1 ; while i >= 0 do ( (     sum := sum+(arr[i+1]) ; 
     cnt := cnt + 1 ; 
     if (sum >= a) then (     break ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Codeforces {
  static int MOD=1000000007 ;
  static int[] arr=new int[100001];
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=1 ;
    while(t-->0){
      solve(s);
    }
  }
  public static void solve(Scanner s){
    int k=s.nextInt();
    int sum=0 ;
    int zero=0 ;
    for(int i=1 ; i<=12 ; i++){
      arr[i]=s.nextInt();
      if(arr[i]==0)zero++;
      sum+=arr[i];
    }
    if(sum<k){
      System.out.println(-1);
    }
    else if(sum==k){
      System.out.println(12-zero);
    }
    else {
      Arrays.sort(arr,1,13);
      int ans=0 ;
      for(int i=12 ; i>=1 && k>0 ; i--){
        k-=arr[i];
        ans++;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codeforces {
  static   attribute MOD : int := 1000000007;
  static   attribute arr : Sequence(int) := Integer.subrange(1,100001)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := 1 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve(s) ) ;  ) );
  static   operation solve( s : OclFile) : void
  pre: true
  post: true
  activity: (     var k : int ; k := s.getCurrent()->toInteger() ;
     var sum : int ; sum := 0 ;
    var zero : int ; zero := 0 ;
        var i : int ; i := 1 ; while i <= 12 do ( (     arr[i+1] := s.getCurrent()->toInteger() ; 
     if (arr[i+1] = 0) then     zero := zero + 1 ; else skip ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    if (sum < k) then (     OclFile["System.out"].println(-1) ) else     if (sum = k) then (     OclFile["System.out"].println(12 - zero) ) else (     arr := arr.subrange(1,1)^(arr.subrange(1+1,13)->sort())^arr.subrange(13+1,arr.size) ; 
     var ans : int ; ans := 0 ;
         var i : int ; i := 12 ; while i >= 1 & k > 0 do ( (     k := k-(arr[i+1]) ; 
     ans := ans + 1 )  ;     i := i - 1 ) ; 
     OclFile["System.out"].println(ans) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class code {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int k=sc.nextInt();
    int[] arr=new int[12];
    int count=0,sum=0 ;
    for(int i=0 ; i<12 ; i++){
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr);
    for(int i=0 ; i<12 ; i++){
      if(sum>=k){
        break ;
      }
      else {
        sum+=arr[11-i];
        count++;
      }
    }
    if(sum>=k)System.out.println(count);
    else System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,12)->collect(0) ;
    var count : int ; count := 0 ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 12 do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < 12 do ( (     if (sum >= k) then (     break ) else (     sum := sum+(arr[11 - i+1]) ; 
     count := count + 1 ) )  ;     i := i + 1 ) ; 
    if (sum >= k) then     OclFile["System.out"].println(count) else     OclFile["System.out"].println(-1) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class GFG {
  private static int mergeAndCount(int[] arr,int l,int m,int r){
    int[] left=Arrays.copyOfRange(arr,l,m+1);
    int[] right=Arrays.copyOfRange(arr,m+1,r+1);
    int i=0,j=0,k=l,swaps=0 ;
    while(i<left.length && j<right.length){
      if(left[i]<=right[j])arr[k++]=left[i++];
      else {
        arr[k++]=right[j++];
        swaps+=(m+1)-(l+i);
      }
    }
    while(i<left.length)arr[k++]=left[i++];
    while(j<right.length)arr[k++]=right[j++];
    return swaps ;
  }
  private static int mergeSortAndCount(int[] arr,int l,int r){
    int count=0 ;
    if(l<r){
      int m=(l+r)/2 ;
      count+=mergeSortAndCount(arr,l,m);
      count+=mergeSortAndCount(arr,m+1,r);
      count+=mergeAndCount(arr,l,m,r);
    }
    return count ;
  }
  public static void main(String[] args){
    int[] arr={
      1,20,6,4,5 };
      System.out.println(mergeSortAndCount(arr,0,arr.length-1));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation mergeAndCount( arr : Sequence(int), l : int, m : int, r : int) : int
  pre: true
  post: true
  activity: (     var left : Sequence(int) ; left := arr.subrange(l+1,m + 1) ;
     var right : Sequence(int) ; right := arr.subrange(m + 1+1,r + 1) ;
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    var k : int ; k := l ;
    var swaps : int ; swaps := 0 ;
    while (i < left->size() & j < right->size()) do (     if (left[i+1] <= right[j+1]) then       arr[k+1] := left[i+1]  ; k := k + 1  ; i := i + 1 ; else (       arr[k+1] := right[j+1]  ; k := k + 1  ; j := j + 1 ; 
     swaps := swaps+((m + 1) - (l + i)) ) ) ; 
    while (i < left->size()) do       arr[k+1] := left[i+1]  ; k := k + 1  ; i := i + 1 ; ; 
    while (j < right->size()) do       arr[k+1] := right[j+1]  ; k := k + 1  ; j := j + 1 ; ; 
    return swaps 
 );
  static   operation mergeSortAndCount( arr : Sequence(int), l : int, r : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     if (l < r) then (     var m : int ; m := (l + r) / 2 ;
     count := count+(mergeSortAndCount(arr, l, m)) ; 
     count := count+(mergeSortAndCount(arr, m + 1, r)) ; 
     count := count+(mergeAndCount(arr, l, m, r)) ) else skip ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,20,6,4,5} ;
     OclFile["System.out"].println(mergeSortAndCount(arr, 0, arr->size() - 1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Application {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    for(int i=0 ; i<n ; i++){
      int a=scan.nextInt();
      int b=scan.nextInt();
      String word="" ;
      for(int j=0 ; j<a && j<b ; j++){
        word+="0" ;
        word+="1" ;
      }
      if(a>b){
        for(int j=0 ; j<a-b ; j++){
          word+="0" ;
        }
      }
      else {
        for(int j=0 ; j<b-a ; j++){
          word+="1" ;
        }
      }
      System.out.println(word);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Application {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scan.getCurrent()->toInteger() ;
     var b : int ; b := scan.getCurrent()->toInteger() ;
    var word : String ; word := "" ;
        var j : int ; j := 0 ; while j < a & j < b do ( (     word := word+("0") ; 
     word := word+("1") )  ;     j := j + 1 ) ; 
    if (a > b) then (         var j : int ; j := 0 ; while j < a - b do ( (     word := word+("0") )  ;     j := j + 1 ) ) else (         var j : int ; j := 0 ; while j < b - a do ( (     word := word+("1") )  ;     j := j + 1 ) ) ;  
    OclFile["System.out"].println(word) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A1694 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int zeros=in.nextInt();
      int ones=in.nextInt();
      StringBuilder out=new StringBuilder();
      while(zeros!=0 || ones!=0){
        if(zeros!=0){
          out.append('0');
          zeros--;
        }
        if(ones!=0){
          out.append('1');
          ones--;
        }
      }
      System.out.println(out);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1694 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var zeros : int ; zeros := in.getCurrent()->toInteger() ;
     var ones : int ; ones := in.getCurrent()->toInteger() ;
    var out : String ; out := StringLib.newString() ;
    while (zeros /= 0 or ones /= 0) do (     if (zeros /= 0) then (     out := out + StringLib.newString('0') ; 
     zeros := zeros - 1 ) else skip ; 
     if (ones /= 0) then (     out := out + StringLib.newString('1') ; 
     ones := ones - 1 ) else skip ) ; 
    OclFile["System.out"].println(out) ; 
 )  ;     t := t + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    try {
      InputStreamReader isr=new InputStreamReader(System.in);
      BufferedReader br=new BufferedReader(isr);
      int x=Integer.parseInt(br.readLine());
      int i=1 ;
      int temp=0 ;
      int min=0 ;
      int max=0 ;
      while(true){
        temp+=i ;
        min=-1*temp ;
        max=temp ;
        if(min<=min && x<=max){
          System.out.println(i);
          break ;
        }
        i++;
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
    var x : int ; x := (br.readLine())->toInteger() ;
    var i : int ; i := 1 ;
    var temp : int ; temp := 0 ;
    var min : int ; min := 0 ;
    var max : int ; max := 0 ;
    while (true) do (     temp := temp+(i) ; 
     min := -1 * temp ; 
    max := temp ; 
    if (min <= min & x <= max) then (     OclFile["System.out"].println(i) ; 
     break ) else skip ; 
    i := i + 1 ; 
 ) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void swap(long[] a,int i,int j){
    long temp=a[i];
    a[i]=a[j];
    a[j]=temp ;
  }
  public static void main(String[] args){
    FastReader t=new FastReader();
    PrintWriter o=new PrintWriter(System.out);
    int test=t.nextInt();
    while(test-->0){
      long a=t.nextLong();
      long b=t.nextLong();
      StringBuilder sb=new StringBuilder();
      long min=Math.min(a,b);
      a-=min ;
      b-=min ;
      while(min>0){
        sb.append("01");
        min--;
      }
      min=a ;
      while(min>0){
        sb.append("0");
        min--;
      }
      min=b ;
      while(min>0){
        sb.append("1");
        min--;
      }
      o.println(sb.toString());
    }
    o.flush();
    o.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation swap( a : Sequence(long), i : int, j : int) : void
  pre: true
  post: true
  activity: (     var temp : long ; temp := a[i+1] ;
     a[i+1] := a[j+1] ; 
     a[j+1] := temp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : FastReader ; t := FastReader.newFastReader() ;
     var o : OclFile ; o := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := t.nextInt() ;
        while (test > 0) do (        test := test - 1 ;     skip ; (     var a : long ; a := t.nextLong() ;
     var b : long ; b := t.nextLong() ;
    var sb : String ; sb := StringLib.newString() ;
    var min : long ; min := Set{a, b}->min() ;
    a := a-(min) ; 
    b := b-(min) ; 
    while (min > 0) do (     sb := sb + StringLib.newString("01") ; 
     min := min - 1 ) ; 
    min := a ; 
    while (min > 0) do (     sb := sb + StringLib.newString("0") ; 
     min := min - 1 ) ; 
    min := b ; 
    while (min > 0) do (     sb := sb + StringLib.newString("1") ; 
     min := min - 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Creep {
  public static PrintWriter out ;
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner();
    out=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int a=sc.nextInt();
      int b=sc.nextInt();
      String ans="" ;
      if(b>a){
        int last=0 ;
        while(b>0 && a>0){
          if(last==0){
            ans+='1' ;
            b--;
          }
          else {
            ans+='0' ;
            a--;
          }
          last=1-last ;
        }
        while(b>0){
          ans+='1' ;
          b--;
        }
      }
      else {
        int last=0 ;
        while(b>0 && a>0){
          if(last==0){
            ans+='1' ;
            b--;
          }
          else {
            ans+='0' ;
            a--;
          }
          last=1-last ;
        }
        while(b>0){
          ans+='1' ;
          b--;
        }
        while(a>0){
          ans+='0' ;
          a--;
        }
      }
      out.println(ans);
    }
    out.close();
  }
  public static class Scanner {
    BufferedReader br ;
    StringTokenizer st ;
    public Scanner(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Creep {
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := (arguments ( )) ;
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var ans : String ; ans := "" ;
    if (b > a) then (     var last : int ; last := 0 ;
     while (b > 0 & a > 0) do (     if (last = 0) then (     ans := ans+('1') ; 
     b := b - 1 ) else (     ans := ans+('0') ; 
     a := a - 1 ) ;  
     last := 1 - (last)->char2byte() ) ; 
     while (b > 0) do (     ans := ans+('1') ; 
     b := b - 1 ) ) else (     var last : int ; last := 0 ;
     while (b > 0 & a > 0) do (     if (last = 0) then (     ans := ans+('1') ; 
     b := b - 1 ) else (     ans := ans+('0') ; 
     a := a - 1 ) ;  
     last := 1 - (last)->char2byte() ) ; 
     while (b > 0) do (     ans := ans+('1') ; 
     b := b - 1 ) ; 
     while (a > 0) do (     ans := ans+('0') ; 
     a := a - 1 ) ) ;  
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newScanner() : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int squareDigitSum(String number){
    int summ=0 ;
    int num=Integer.parseInt(number);
    int squareNum=num*num ;
    while(squareNum>0){
      summ=summ+(squareNum % 10);
      squareNum=squareNum/10 ;
    }
    return summ ;
  }
  public static void main(String[] args){
    String N="1111" ;
    System.out.println(squareDigitSum(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation squareDigitSum( number : String) : int
  pre: true
  post: true
  activity: (     var summ : int ; summ := 0 ;
     var num : int ; num := (number)->toInteger() ;
    var squareNum : int ; squareNum := num * num ;
    while (squareNum > 0) do (     summ := summ + (squareNum mod 10) ; 
     squareNum := squareNum / 10 ) ; 
    return summ 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : String ; N := "1111" ;
     OclFile["System.out"].println(squareDigitSum(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int lps(String str){
    int n=str.length();
    int L[][]=new int[n][n];
    for(int i=0 ; i<n ; i++)L[i][i]=1 ;
    for(int cl=2 ; cl<=n ; cl++){
      for(int i=0 ; i<n-cl+1 ; i++){
        int j=i+cl-1 ;
        if(str.charAt(i)==str.charAt(j)&& cl==2)L[i][j]=2 ;
        else if(str.charAt(i)==str.charAt(j))L[i][j]=L[i+1][j-1]+2 ;
        else L[i][j]=Integer.max(L[i][j-1],L[i+1][j]);
      }
    }
    return L[0][n-1];
  }
  static int minimumNumberOfDeletions(String str){
    int n=str.length();
    int len=lps(str);
    return(n-len);
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    System.out.println("Minimum number "+"of deletions="+minimumNumberOfDeletions(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation lps( str : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var L : Sequence(Sequence(int)) ; L := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do (     L[i+1][i+1] := 1 ;  ;     i := i + 1 ) ; 
        var cl : int ; cl := 2 ; while cl <= n do ( (         var i : int ; i := 0 ; while i < n - cl + 1 do ( (     var j : int ; j := i + cl - 1 ;
     if (str->at(i+1) = str->at(j+1) & cl = 2) then     L[i+1][j+1] := 2 ; else     if (str->at(i+1) = str->at(j+1)) then     L[i+1][j+1] := L[i + 1+1][j - 1+1] + 2 else     L[i+1][j+1] := Set{L[i+1][j - 1+1], L[i + 1+1][j+1]}->max() ; ;  )  ;     i := i + 1 ) )  ;     cl := cl + 1 ) ; 
    return L[0+1][n - 1+1] 
 );
  static   operation minimumNumberOfDeletions( str : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var len : int ; len := lps(str) ;
     return (n - len) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     OclFile["System.out"].println("Minimum number " + "of deletions=" + minimumNumberOfDeletions(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void quadrant(String s){
    int l=s.length();
    int i ;
    if(s.contains("+")){
      i=s.indexOf('+');
    }
    else {
      i=s.indexOf('-');
    }
    String real=s.substring(0,i);
    String imaginary=s.substring(i+1,l-1);
    int x=Integer.valueOf(real);
    int y=Integer.valueOf(imaginary);
    if(x>0 && y>0)System.out.print("Quadrant 1");
    else if(x<0 && y>0)System.out.print("Quadrant 2");
    else if(x<0 && y<0)System.out.print("Quadrant 3");
    else if(x>0 && y<0)System.out.print("Quadrant 4");
    else if(x==0 && y>0)System.out.print("Lies on positive"+" Imaginary axis");
    else if(x==0 && y<0)System.out.print("Lies on negative"+" Imaginary axis");
    else if(y==0 && x<0)System.out.print("Lies on negative"+" X-axis");
    else if(y==0 && x>0)System.out.print("Lies on positive"+" X-axis");
    else System.out.print("Lies on the Origin");
  }
  public static void main(String[] args){
    String s="5+3i" ;
    quadrant(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation quadrant( s : String) : void
  pre: true
  post: true
  activity: (     var l : int ; l := s->size() ;
     var i : int ;
    if (s->includes("+")) then (     i := s->indexOf('+')-1 ) else (     i := s->indexOf('-')-1 ) ;  
    var real : String ; real := s.subrange(0+1,i) ;
    var imaginary : String ; imaginary := s.subrange(i + 1+1,l - 1) ;
    var x : int ; x := (real)->toInteger() ;
    var y : int ; y := (imaginary)->toInteger() ;
    if (x > 0 & y > 0) then     OclFile["System.out"].print("Quadrant 1") else     if (x < 0 & y > 0) then     OclFile["System.out"].print("Quadrant 2") else     if (x < 0 & y < 0) then     OclFile["System.out"].print("Quadrant 3") else     if (x > 0 & y < 0) then     OclFile["System.out"].print("Quadrant 4") else     if (x = 0 & y > 0) then     OclFile["System.out"].print("Lies on positive" + " Imaginary axis") else     if (x = 0 & y < 0) then     OclFile["System.out"].print("Lies on negative" + " Imaginary axis") else     if (y = 0 & x < 0) then     OclFile["System.out"].print("Lies on negative" + " X-axis") else     if (y = 0 & x > 0) then     OclFile["System.out"].print("Lies on positive" + " X-axis") else     OclFile["System.out"].print("Lies on the Origin") ; ;  ;  ;  ;  ;  ;  ;  ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "5+3i" ;
     execute quadrant(s) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String check(int[] Arr,int n,int M,int K){
    int flag=0 ;
    for(int i=0 ; i<n ; i++){
      if(Arr[i]==0)flag=1 ;
    }
    if(K % 2!=0 && flag==0)return "No" ;
    else return "Yes" ;
  }
  public static void main(String args[]){
    int[] Arr={
      1,1,2,4,7,8 };
      int M=5 ;
      int K=6 ;
      int n=Arr.length ;
      System.out.println(check(Arr,n,M,K));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation check( Arr : Sequence(int), n : int, M : int, K : int) : String
  pre: true
  post: true
  activity: (     var flag : int ; flag := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (Arr[i+1] = 0) then     flag := 1 ; else skip )  ;     i := i + 1 ) ; 
     if (K mod 2 /= 0 & flag = 0) then     return "No" else     return "Yes" );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var Arr : Sequence(int) ; Arr := Sequence{1,1,2,4,7,8} ;
     var M : int ; M := 5 ;
    var K : int ; K := 6 ;
    var n : int ; n := Arr->size() ;
    OclFile["System.out"].println(check(Arr, n, M, K)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long a=sc.nextLong();
      long b=sc.nextLong();
      long cnt=0 ;
      long ans=Long.MAX_VALUE ;
      long q=0 ;
      for(long i=0 ; i*i<=a ; i++){
        if(b==1){
          b++;
          q=1 ;
        }
        cnt=i+q ;
        long c=a ;
        while(c>0){
          c=c/(b+i);
          cnt++;
        }
        ans=Math.min(ans,cnt);
        cnt=0 ;
      }
      System.out.println(ans);
    }
  }
  static boolean isPrime(long n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static long gcd(long a,long b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static long lcm(long a,long b){
    return(a/gcd(a,b))*b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
    var cnt : long ; cnt := 0 ;
    var ans : long ; ans := "9223372036854775807"->toLong() ;
    var q : long ; q := 0 ;
        var i : long ; i := 0 ; while i * i <= a do ( (     if (b = 1) then (     b := b + 1 ; 
     q := 1 ) else skip ; 
     cnt := i + q ; 
    var c : long ; c := a ;
    while (c > 0) do (     c := c / (b + i) ; 
     cnt := cnt + 1 ) ; 
    ans := Set{ans, cnt}->min() ; 
    cnt := 0 ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a / gcd(a, b)) * b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPrime(long n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static boolean isFactorialPrime(long n){
    if(! isPrime(n))return false ;
    long fact=1 ;
    int i=1 ;
    while(fact<=n+1){
      fact=fact*i ;
      if(n+1==fact || n-1==fact)return true ;
      i++;
    }
    return false ;
  }
  public static void main(String args[]){
    int n=23 ;
    if(isFactorialPrime(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation isFactorialPrime( n : long) : boolean
  pre: true
  post: true
  activity: (     if (not(isPrime(n))) then     return false else skip ; 
     var fact : long ; fact := 1 ;
    var i : int ; i := 1 ;
    while (fact <= n + 1) do (     fact := fact * i ; 
     if (n + 1 = fact or n - 1 = fact) then     return true else skip ; 
     i := i + 1 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 23 ;
     if (isFactorialPrime(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPrime(int n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static boolean isDivisible(int n){
    if(isPrime(n+1))return false ;
    return true ;
  }
  public static void main(String[] args){
    int n=6 ;
    if(isDivisible(n))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation isDivisible( n : int) : boolean
  pre: true
  post: true
  activity: (     if (isPrime(n + 1)) then     return false else skip ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     if (isDivisible(n)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int findNumber(int arr[],int n){
    Arrays.sort(arr);
    int max=arr[n-1];
    int table[]=new int[(2*max)+1];
    table[0]=0 ;
    for(int i=1 ; i<(2*max)+1 ; i++)table[i]=Integer.MAX_VALUE ;
    int ans=-1 ;
    for(int i=1 ; i<(2*max)+1 ; i++){
      for(int j=0 ; j<n ; j++){
        if(arr[j]<=i){
          int res=table[i-arr[j] ];
          if(res!=Integer.MAX_VALUE && res+1<table[i])table[i]=res+1 ;
        }
      }
      if(i>arr[n-1] && table[i]==Integer.MAX_VALUE){
        ans=i ;
        break ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int arr[]={
      6,7,15 };
      int n=arr.length ;
      System.out.println(findNumber(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNumber( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     arr := arr->sort() ; 
     var max : int ; max := arr[n - 1+1] ;
    var table : Sequence(int) ; table := Integer.subrange(1,(2 * max) + 1)->collect(0) ;
    table[0+1] := 0 ; 
        var i : int ; i := 1 ; while i < (2 * max) + 1 do (     table[i+1] := 2147483647 ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := -1 ;
        var i : int ; i := 1 ; while i < (2 * max) + 1 do ( (         var j : int ; j := 0 ; while j < n do ( (     if (arr[j+1] <= i) then (     var res : int ; res := table[i - arr[j+1]+1] ;
     if (res /= 2147483647 & res + 1 < table[i+1]) then     table[i+1] := res + 1 ; else skip ) else skip )  ;     j := j + 1 ) ; 
     if (i > arr[n - 1+1] & table[i+1] = 2147483647) then (     ans := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{6,7,15} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(findNumber(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int maxEvenLenSum(int arr[],int n){
    if(n<2)return 0 ;
    int[] dp=new int[n];
    dp[n-1]=0 ;
    dp[n-2]=arr[n-2]+arr[n-1];
    for(int i=n-3 ; i>=0 ; i--){
      dp[i]=arr[i]+arr[i+1];
      if(dp[i+2]>0)dp[i]+=dp[i+2];
    }
    int maxSum=Arrays.stream(dp).max().getAsInt();
    return maxSum ;
  }
  public static void main(String[] args){
    int arr[]={
      8,9,-8,9,10 };
      int n=arr.length ;
      System.out.println(maxEvenLenSum(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxEvenLenSum( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n < 2) then     return 0 else skip ; 
     var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
    dp[n - 1+1] := 0 ; 
    dp[n - 2+1] := arr[n - 2+1] + arr[n - 1+1] ; 
        var i : int ; i := n - 3 ; while i >= 0 do ( (     dp[i+1] := arr[i+1] + arr[i + 1+1] ; 
     if (dp[i + 2+1] > 0) then     dp[i+1] := dp[i+1]+(dp[i + 2+1]) ; else skip )  ;     i := i - 1 ) ; 
    var maxSum : int ; maxSum := stream(dp).max().getAsInt() ;
    return maxSum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{8,9,-8,9,10} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxEvenLenSum(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int makeOdd(int n){
    if(n % 2!=0)return 1 ;
    int ans=1 ;
    while(n % 2==0){
      n/=2 ;
      ans*=2 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int n=36 ;
    int res=makeOdd(n);
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation makeOdd( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 /= 0) then     return 1 else skip ; 
     var ans : int ; ans := 1 ;
     while (n mod 2 = 0) do (     n := n/(2) ; 
     ans := ans*(2) ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 36 ;
     var res : int ; res := makeOdd(n) ;
     OclFile["System.out"].println(res) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A891 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int[] A=new int[N];
    for(int n=0 ; n<N ; n++){
      A[n]=in.nextInt();
    }
    int minWidth=Integer.MAX_VALUE ;
    for(int start=0 ; start<N ; start++){
      int gcd=A[start];
      for(int end=start ; end<N ; end++){
        gcd=gcd(gcd,A[end]);
        if(gcd==1){
          minWidth=Math.min(minWidth,end-start+1);
          break ;
        }
      }
    }
    int answer ;
    if(minWidth==Integer.MAX_VALUE){
      answer=-1 ;
    }
    else if(minWidth==1){
      answer=0 ;
      for(int a : A){
        if(a!=1){
          answer++;
        }
      }
    }
    else {
      answer=minWidth-1+N-1 ;
    }
    System.out.println(answer);
  }
  static int gcd(int a,int b){
    return(b==0)? a : gcd(b,a % b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A891 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var minWidth : int ; minWidth := 2147483647 ;
        var start : int ; start := 0 ; while start < N do ( (     var gcd : int ; gcd := A[start+1] ;
         var end : int ; end := start ; while end < N do ( (     gcd := gcd(gcd, A[end+1]) ; 
     if (gcd = 1) then (     minWidth := Set{minWidth, end - start + 1}->min() ; 
     break ) else skip )  ;     end := end + 1 ) )  ;     start := start + 1 ) ; 
    var answer : int ;
    if (minWidth = 2147483647) then (     answer := -1 ) else     if (minWidth = 1) then (     answer := 0 ; 
     for (a : A) do ( (     if (a /= 1) then (     answer := answer + 1 ) else skip )  ) ) else (     answer := minWidth - 1 + N - 1 ) ;  ;  
    OclFile["System.out"].println(answer) ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if (b = 0) then a else gcd(b, a mod b) endif );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean bit_check(int n){
    if((n &(n-1))==0)return true ;
    return false ;
  }
  public static void main(String args[]){
    int n=14 ;
    if(bit_check(n))System.out.println('1');
    else System.out.println('0');
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation bit_check( n : int) : boolean
  pre: true
  post: true
  activity: (     if ((n & (n - 1)) = 0) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 14 ;
     if (bit_check(n)) then     OclFile["System.out"].println('1') ; else     OclFile["System.out"].println('0') ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A891 {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    if(find(a,n)>1){
      System.out.println(-1);
    }
    else {
      int count=0 ;
      for(int i=0 ; i<n ; i++){
        if(a[i]==1){
          count++;
        }
      }
      if(count>0){
        System.out.println(n-count);
      }
      else {
        int min=Integer.MAX_VALUE ;
        for(int i=0 ; i<n ; i++){
          int g=a[i];
          for(int j=i+1 ; j<n ; j++){
            g=gcd(g,a[j]);
            if(g==1){
              min=Math.min(min,j-i+n-1);
              break ;
            }
          }
        }
        System.out.println(min);
      }
    }
  }
  static int find(int a[],int n){
    int g=a[0];
    for(int i=1 ; i<n ; i++){
      g=gcd(g,a[i]);
    }
    return g ;
  }
  static int gcd(int a,int b){
    if(b==0){
      return a ;
    }
    else {
      return gcd(b,a % b);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A891 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    if (find(a, n) > 1) then (     OclFile["System.out"].println(-1) ) else (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] = 1) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (count > 0) then (     OclFile["System.out"].println(n - count) ) else (     var min : int ; min := 2147483647 ;
         var i : int ; i := 0 ; while i < n do ( (     var g : int ; g := a[i+1] ;
         var j : int ; j := i + 1 ; while j < n do ( (     g := gcd(g, a[j+1]) ; 
     if (g = 1) then (     min := Set{min, j - i + n - 1}->min() ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(min) ) ) ;  
 );
  static   operation find( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var g : int ; g := a[0+1] ;
         var i : int ; i := 1 ; while i < n do ( (     g := gcd(g, a[i+1]) )  ;     i := i + 1 ) ; 
     return g );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else (     return gcd(b, a mod b) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String inputN=scanner.nextLine();
    String inputP=scanner.nextLine();
    String[] pStr=inputP.split(" ",0);
    int n=Integer.parseInt(inputN);
    int pInt[]=new int[n];
    for(int i=0 ; i<n ; i++){
      pInt[i]=Integer.parseInt(pStr[i]);
    }
    for(int i=1 ; i<n ; i++){
      if(pInt[i]>pInt[i-1]){
        pInt[i]--;
      }
    }
    boolean isStair=true ;
    for(int i=1 ; i<n ; i++){
      if(pInt[i]<pInt[i-1]){
        isStair=false ;
      }
    }
    String show=isStair ? "Yes" : "No" ;
    System.out.println(show);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inputN : String ; inputN := scanner.nextLine() ;
    var inputP : String ; inputP := scanner.nextLine() ;
    var pStr : Sequence(String) ; pStr := inputP->split(" ") ;
    var n : int ; n := (inputN)->toInteger() ;
    var pInt : Sequence(int) ; pInt := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     pInt[i+1] := (pStr[i+1])->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (pInt[i+1] > pInt[i - 1+1]) then (     pInt[i+1] := pInt[i+1] - 1 ) else skip )  ;     i := i + 1 ) ; 
    var isStair : boolean ; isStair := true ;
        var i : int ; i := 1 ; while i < n do ( (     if (pInt[i+1] < pInt[i - 1+1]) then (     isStair := false ) else skip )  ;     i := i + 1 ) ; 
    var show : String ; show := if isStair then "Yes" else "No" endif ;
    OclFile["System.out"].println(show) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  static Scanner scanner=new Scanner();
  public static void main(String[] $){
    int n=scanner.nextInt();
    int last=scanner.nextInt();
    for(int i=1 ; i<n ; i++){
      int h=scanner.nextInt();
      if(last<=h){
        last=h ;
      }
      else if(last<=h+1){
        last=h+1 ;
      }
      else {
        System.out.println("No");
        return ;
      }
    }
    System.out.println("Yes");
  }
  static class Scanner {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in),32768);
    StringTokenizer tokenizer ;
    String next(){
      try {
        while(tokenizer==null || ! tokenizer.hasMoreTokens()){
          tokenizer=new StringTokenizer(reader.readLine());
        }
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := (arguments ( ));
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var last : int ; last := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 1 ; while i < n do ( (     var h : int ; h := scanner.getCurrent()->toInteger() ;
     if (last <= h) then (     last := h ) else     if (last <= h + 1) then (     last := h + 1 ) else (     OclFile["System.out"].println("No") ; 
     return ) ;  )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("Yes") );
  static class Scanner {
   attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 32768);
   attribute tokenizer : OclIterator;
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) )   catch (e : IOException) do (     error ProgramException(e) )
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.*;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import java.util.List ;
public class Main {
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Integer arr[]=new Integer[n];
    Integer arrToSort[]=new Integer[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      arrToSort[i]=arr[i];
    }
    Arrays.sort(arr);
    for(int i=0 ; i<n ; i++){
      if(! arr[i] .equals(arrToSort[i])&& arr[i]!=arrToSort[i]-1 && arr[i]!=arrToSort[i]+1){
        System.out.println("No");
        System.exit(0);
      }
    }
    System.out.println("Yes");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(null) ;
    var arrToSort : Sequence(int) ; arrToSort := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     arrToSort[i+1] := arr[i+1] )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (not(arr[i+1] = arrToSort[i+1]) & arr[i+1] /= arrToSort[i+1] - 1 & arr[i+1] /= arrToSort[i+1] + 1) then (     OclFile["System.out"].println("No") ; 
 OclProcess.exit(0) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Yes") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] H=new int[N];
    for(int i=0 ; i<N ; i++){
      H[i]=sc.nextInt();
    }
    for(int i=N-1 ; i>0 ; i--){
      if(H[i-1]>H[i]){
        H[i-1]--;
        if(H[i-1]>H[i]){
          System.out.print("No");
          return ;
        }
      }
    }
    System.out.print("Yes");
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var H : Sequence(int) ; H := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     H[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := N - 1 ; while i > 0 do ( (     if (H[i - 1+1] > H[i+1]) then (     H[i - 1+1] := H[i - 1+1] - 1 ; 
     if (H[i - 1+1] > H[i+1]) then (     OclFile["System.out"].print("No") ; 
     return ) else skip ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].print("Yes") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int max=0 ;
    int a=0 ;
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<=n ; i++){
      if(i==n){
        System.out.println("Yes");
        break ;
      }
      a=sc.nextInt();
      if(max<a)max=a-1 ;
      else if(max==a)max=a ;
      else {
        System.out.println("No");
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var max : int ; max := 0 ;
     var a : int ; a := 0 ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i <= n do ( (     if (i = n) then (     OclFile["System.out"].println("Yes") ; 
     break ) else skip ; 
     a := sc.getCurrent()->toInteger() ; 
     if (max < a) then     max := a - 1 ; else     if (max = a) then     max := a else (     OclFile["System.out"].println("No") ; 
     break ) ;  )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int missingNumber(int a[],int n){
    Map<Integer,Integer>mp=new LinkedHashMap<>();
    for(int i=0 ; i<n ; i++){
      if(a[i]>0){
        mp.put(a[i],mp.get(a[i])==null ? 1 : mp.get(a[i])+1);
      }
    }
    int index=1 ;
    while(true){
      if(! mp.containsKey(index)){
        return index ;
      }
      index++;
    }
  }
  public static void main(String[] args){
    int a[]={
      1,1,1,0,-1,-2 };
      int size=a.length ;
      System.out.println("Smallest positive missing number is : "+missingNumber(a,size));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation missingNumber( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] > 0) then (     mp := mp->union(Map{a[i+1] |-> if mp->at(a[i+1]) = null then 1 else mp->at(a[i+1]) + 1 endif}) ) else skip )  ;     i := i + 1 ) ; 
     var index : int ; index := 1 ;
     while (true) do (     if (not(mp->keys()->includes(index))) then (     return index ) else skip ; 
     index := index + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,1,1,0,-1,-2} ;
     var size : int ; size := a->size() ;
     OclFile["System.out"].println("Smallest positive missing number is : " + missingNumber(a, size)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void prime(int arr[],int n){
    int max_val=Arrays.stream(arr).max().getAsInt();
    Vector<Boolean>prime=new Vector<Boolean>();
    for(int i=0 ; i<max_val+1 ; i++)prime.add(Boolean.TRUE);
    prime.add(0,Boolean.FALSE);
    prime.add(1,Boolean.FALSE);
    for(int p=2 ; p*p<=max_val ; p++){
      if(prime.get(p)==true){
        for(int i=p*2 ; i<=max_val ; i+=p)prime.add(i,Boolean.FALSE);
      }
    }
    int minimum=Integer.MAX_VALUE ;
    int maximum=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++)if(prime.get(arr[i])){
      minimum=Math.min(minimum,arr[i]);
      maximum=Math.max(maximum,arr[i]);
    }
    System.out.println("Minimum : "+minimum);
    System.out.println("Maximum : "+maximum);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,6,7 };
      int n=arr.length ;
      prime(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation prime( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var max_val : int ; max_val := stream(arr).max().getAsInt() ;
     var prime : Sequence(Boolean) ; prime := Sequence{} ;
        var i : int ; i := 0 ; while i < max_val + 1 do (     prime := prime->including(true) ;  ;     i := i + 1 ) ; 
    prime := prime.insertAt(0+1,false) ; 
    prime := prime.insertAt(1+1,false) ; 
        var p : int ; p := 2 ; while p * p <= max_val do ( (     if (prime->at(p+1) = true) then (         var i : int ; i := p * 2 ; while i <= max_val do (     prime := prime.insertAt(i+1,false) ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) ; 
    var minimum : int ; minimum := 2147483647 ;
    var maximum : int ; maximum := -2147483648 ;
        var i : int ; i := 0 ; while i < n do (     if (prime->at(arr[i+1]+1)) then (     minimum := Set{minimum, arr[i+1]}->min() ; 
     maximum := Set{maximum, arr[i+1]}->max() ) else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Minimum : " + minimum) ; 
    OclFile["System.out"].println("Maximum : " + maximum) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6,7} ;
     var n : int ; n := arr->size() ;
     execute prime(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countPairs(int arr1[],int arr2[],int m,int n,int x){
    int count=0 ;
    HashSet<Integer>us=new HashSet<Integer>();
    for(int i=0 ; i<m ; i++)us.add(arr1[i]);
    for(int j=0 ; j<n ; j++)if(us.contains(x-arr2[j]))count++;
    return count ;
  }
  public static void main(String[] args){
    int arr1[]={
      1,3,5,7 };
      int arr2[]={
        2,3,5,8 };
        int m=arr1.length ;
        int n=arr2.length ;
        int x=10 ;
        System.out.print("Count="+countPairs(arr1,arr2,m,n,x));
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPairs( arr1 : Sequence(int), arr2 : Sequence(int), m : int, n : int, x : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var us : Set(int) ; us := Set{} ;
        var i : int ; i := 0 ; while i < m do (     us := us->including(arr1[i+1]) ;  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < n do (     if (us->includes(x - arr2[j+1])) then     count := count + 1 ; else skip ;  ;     j := j + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{1,3,5,7} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{2,3,5,8} ;
    var m : int ; m := arr1->size() ;
    var n : int ; n := arr2->size() ;
    var x : int ; x := 10 ;
    OclFile["System.out"].print("Count=" + countPairs(arr1, arr2, m, n, x)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int m=sc.nextInt();
      int nMin=sc.nextInt();
      int nMax=sc.nextInt();
      if(m==0 && nMin==0 && nMax==0){
        System.exit(0);
      }
      int n=nMin ;
      int maxGap=0 ;
      int successMin=sc.nextInt();
      for(int i=2 ; i<=m ; i++){
        int failMax=sc.nextInt();
        if(i>nMax+1){
          continue ;
        }
        if(i>nMin){
          int gap=successMin-failMax ;
          if(gap>=maxGap){
            maxGap=gap ;
            n=i-1 ;
          }
        }
        successMin=failMax ;
      }
      System.out.println(n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var m : int ; m := sc.getCurrent()->toInteger() ;
     var nMin : int ; nMin := sc.getCurrent()->toInteger() ;
    var nMax : int ; nMax := sc.getCurrent()->toInteger() ;
    if (m = 0 & nMin = 0 & nMax = 0) then ( OclProcess.exit(0) ) else skip ; 
    var n : int ; n := nMin ;
    var maxGap : int ; maxGap := 0 ;
    var successMin : int ; successMin := sc.getCurrent()->toInteger() ;
        var i : int ; i := 2 ; while i <= m do ( (     var failMax : int ; failMax := sc.getCurrent()->toInteger() ;
     if (i > nMax + 1) then (     continue ) else skip ; 
     if (i > nMin) then (     var gap : int ; gap := successMin - failMax ;
     if (gap >= maxGap) then (     maxGap := gap ; 
     n := i - 1 ) else skip ) else skip ; 
     successMin := failMax )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void q1(String s,int i){
    if(i==s.length()){
      System.out.println("Yes");
      return ;
    }
    if(s.charAt(i)=='a')q1(s,i+1);
    else q2(s,i+1);
  }
  static void q2(String s,int i){
    if(i==s.length()){
      System.out.println("No");
      return ;
    }
    if(s.charAt(i)=='a')q1(s,i+1);
    else q2(s,i+1);
  }
  static void q3(String s,int i){
    if(i==s.length()){
      System.out.println("Yes");
      return ;
    }
    if(s.charAt(i)=='a')q4(s,i+1);
    else q3(s,i+1);
  }
  static void q4(String s,int i){
    if(i==s.length()){
      System.out.println("No");
      return ;
    }
    if(s.charAt(i)=='a')q4(s,i+1);
    else q3(s,i+1);
  }
  static void q0(String s,int i){
    if(i==s.length()){
      System.out.println("No");
      return ;
    }
    if(s.charAt(i)=='a')q1(s,i+1);
    else q3(s,i+1);
  }
  public static void main(String[] args){
    String s="abbaabb" ;
    q0(s,0);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation q1( s : String, i : int) : void
  pre: true
  post: true
  activity: (     if (i = s->size()) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
     if (s->at(i+1) = 'a') then     execute q1(s, i + 1) ; else     execute q2(s, i + 1) ; );
  static   operation q2( s : String, i : int) : void
  pre: true
  post: true
  activity: (     if (i = s->size()) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
     if (s->at(i+1) = 'a') then     execute q1(s, i + 1) ; else     execute q2(s, i + 1) ; );
  static   operation q3( s : String, i : int) : void
  pre: true
  post: true
  activity: (     if (i = s->size()) then (     OclFile["System.out"].println("Yes") ; 
     return ) else skip ; 
     if (s->at(i+1) = 'a') then     execute q4(s, i + 1) ; else     execute q3(s, i + 1) ; );
  static   operation q4( s : String, i : int) : void
  pre: true
  post: true
  activity: (     if (i = s->size()) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
     if (s->at(i+1) = 'a') then     execute q4(s, i + 1) ; else     execute q3(s, i + 1) ; );
  static   operation q0( s : String, i : int) : void
  pre: true
  post: true
  activity: (     if (i = s->size()) then (     OclFile["System.out"].println("No") ; 
     return ) else skip ; 
     if (s->at(i+1) = 'a') then     execute q1(s, i + 1) ; else     execute q3(s, i + 1) ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abbaabb" ;
     execute q0(s, 0) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public final class Test {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
      int curr=arr[n-1];
      int c=0 ;
      for(int i=n-2 ; i>=0 ; i--){
        if(arr[i]<=curr){
          curr=arr[i];
        }
        else c++;
      }
      System.out.println(c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var curr : int ; curr := arr[n - 1+1] ;
    var c : int ; c := 0 ;
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (arr[i+1] <= curr) then (     curr := arr[i+1] ) else     c := c + 1 ; )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(c) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class supercentral {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int x[]=new int[n];
    int y[]=new int[n];
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      x[i]=in.nextInt();
      y[i]=in.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      boolean l=false,r=false,u=false,d=false ;
      for(int j=0 ; j<n ; j++){
        if(x[i]==x[j] && y[i]<y[j])u=true ;
        if(x[i]==x[j] && y[i]>y[j])d=true ;
        if(x[i]<x[j] && y[i]==y[j])r=true ;
        if(x[i]>x[j] && y[i]==y[j])l=true ;
      }
      if(u==true && d==true && r==true && l==true)cnt++;
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class supercentral {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
    var y : Sequence(int) ; y := Integer.subrange(1,n)->collect(0) ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := in.getCurrent()->toInteger() ; 
     y[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var l : boolean ; l := false ;
    var r : boolean ; r := false ;
    var u : boolean ; u := false ;
    var d : boolean ; d := false ;
         var j : int ; j := 0 ; while j < n do ( (     if (x[i+1] = x[j+1] & y[i+1] < y[j+1]) then     u := true ; else skip ; 
     if (x[i+1] = x[j+1] & y[i+1] > y[j+1]) then     d := true ; else skip ; 
     if (x[i+1] < x[j+1] & y[i+1] = y[j+1]) then     r := true ; else skip ; 
     if (x[i+1] > x[j+1] & y[i+1] = y[j+1]) then     l := true ; else skip )  ;     j := j + 1 ) ; 
     if (u = true & d = true & r = true & l = true) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class SupercentralPoint {
  public static void main(String[] args){
    class Coordinate {
      int x ;
      int y ;
      Coordinate(int x,int y){
        this.x=x ;
        this.y=y ;
      }
    }
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    ArrayList<Coordinate>arr=new ArrayList<Coordinate>();
    for(int i=0 ; i<n ; i++){
      arr.add(new Coordinate(sc.nextInt(),sc.nextInt()));
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      boolean left=false ;
      boolean right=false ;
      boolean upper=false ;
      boolean lower=false ;
      Coordinate central=arr.get(i);
      for(int j=0 ; j<n ; j++){
        if(i==j)continue ;
        Coordinate curr=arr.get(j);
        if(central.x==curr.x){
          if(curr.y>central.y)upper=true ;
          else lower=true ;
        }
        else if(central.y==curr.y){
          if(curr.x>central.x)right=true ;
          else left=true ;
        }
        if(left && right && upper && lower==true){
          count++;
          break ;
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class SupercentralPoint {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( class Coordinate {
   attribute x : int;
   attribute y : int;
   static operation newCoordinate( x : int, y : int) : Coordinate
  pre: true
  post: true
  activity:
  ( var self : Coordinate ;
    self := createCoordinate();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(Coordinate) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     arr := arr->including(Coordinate.newCoordinate(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger())) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var left : boolean ; left := false ;
     var right : boolean ; right := false ;
    var upper : boolean ; upper := false ;
    var lower : boolean ; lower := false ;
    var central : Coordinate ; central := arr->at(i+1) ;
        var j : int ; j := 0 ; while j < n do ( (     if (i = j) then     continue else skip ; 
     var curr : Coordinate ; curr := arr->at(j+1) ;
     if (central.x = curr.x) then (     if (curr.y > central.y) then     upper := true ; else     lower := true ; ) else     if (central.y = curr.y) then (     if (curr.x > central.x) then     right := true ; else     left := true ; ) else skip ; ;  
     if (left & right & upper & lower = true) then (     count := count + 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int binaryToDecimal(String n){
    String num=n ;
    int dec_value=0 ;
    int base=1 ;
    int len=num.length();
    for(int i=len-1 ; i>=0 ; i--){
      if(num.charAt(i)=='1')dec_value+=base ;
      base=base*2 ;
    }
    return dec_value ;
  }
  static int numberSequence(int n){
    if(n==1)return 1 ;
    String s="" ;
    for(int i=1 ; i<n ; i++)s+='1' ;
    s+='0' ;
    for(int i=1 ; i<=n ; i++)s+='1' ;
    int num=binaryToDecimal(s);
    return num ;
  }
  public static void main(String args[]){
    int n=4 ;
    System.out.println(numberSequence(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation binaryToDecimal( n : String) : int
  pre: true
  post: true
  activity: (     var num : String ; num := n ;
     var dec_value : int ; dec_value := 0 ;
    var base : int ; base := 1 ;
    var len : int ; len := num->size() ;
        var i : int ; i := len - 1 ; while i >= 0 do ( (     if (num->at(i+1) = '1') then     dec_value := dec_value+(base) ; else skip ; 
     base := base * 2 )  ;     i := i - 1 ) ; 
    return dec_value 
 );
  static   operation numberSequence( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 1 else skip ; 
     var s : String ; s := "" ;
        var i : int ; i := 1 ; while i < n do (     s := s+('1') ;  ;     i := i + 1 ) ; 
    s := s+('0') ; 
        var i : int ; i := 1 ; while i <= n do (     s := s+('1') ;  ;     i := i + 1 ) ; 
    var num : int ; num := binaryToDecimal(s) ;
    return num 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(numberSequence(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static String constructString(int n){
    String s="" ;
    for(int i=0 ; i<n ; i++){
      s+="10" ;
    }
    return s ;
  }
  static int binaryToDecimal(String n){
    String num=n ;
    int dec_value=0 ;
    int base=1 ;
    int len=num.length();
    for(int i=len-1 ; i>=0 ; i--){
      if(num.charAt(i)=='1')dec_value+=base ;
      base=base*2 ;
    }
    return dec_value ;
  }
  static int findNumber(int n){
    String s=constructString(n-1);
    int num=binaryToDecimal(s);
    return num ;
  }
  public static void main(String[] args){
    int n=4 ;
    System.out.println(findNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation constructString( n : int) : String
  pre: true
  post: true
  activity: (     var s : String ; s := "" ;
         var i : int ; i := 0 ; while i < n do ( (     s := s+("10") )  ;     i := i + 1 ) ; 
     return s );
  static   operation binaryToDecimal( n : String) : int
  pre: true
  post: true
  activity: (     var num : String ; num := n ;
     var dec_value : int ; dec_value := 0 ;
    var base : int ; base := 1 ;
    var len : int ; len := num->size() ;
        var i : int ; i := len - 1 ; while i >= 0 do ( (     if (num->at(i+1) = '1') then     dec_value := dec_value+(base) ; else skip ; 
     base := base * 2 )  ;     i := i - 1 ) ; 
    return dec_value 
 );
  static   operation findNumber( n : int) : int
  pre: true
  post: true
  activity: (     var s : String ; s := constructString(n - 1) ;
     var num : int ; num := binaryToDecimal(s) ;
     return num );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     OclFile["System.out"].println(findNumber(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int t=in.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      int a=in.nextInt(),b=in.nextInt();
      TreeSet<Integer>set=new TreeSet<>();
      int total=a+b ;
      {
        int l=Math.min(a,(total+1)/2);
        int r=a-l ;
        int empL=(total+1)/2-l ;
        int empR=total/2-r ;
        int minScore=empL+r ;
        int maxAdd=Math.min(empR,l);
        for(int i=0 ; i<=maxAdd ; i++){
          set.add(minScore+2*i);
        }
      }
      {
        int l=Math.min(a,total/2);
        int r=a-l ;
        int empR=(total+1)/2-r ;
        int empL=(total/2)-l ;
        int minScore=empL+r ;
        int maxAdd=Math.min(empR,l);
        for(int i=0 ; i<=maxAdd ; i++){
          set.add(minScore+2*i);
        }
      }
      pw.println(set.size());
      for(int x : set)pw.print(x+" ");
      pw.println();
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        var tt : int ; tt := 0 ; while tt < t do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
     var set : Set(int) ; set := Set{} ;
    var total : int ; total := a + b ;
(     var l : int ; l := Set{a, (total + 1) / 2}->min() ;
     var r : int ; r := a - l ;
    var empL : int ; empL := (total + 1) / 2 - l ;
    var empR : int ; empR := total / 2 - r ;
    var minScore : int ; minScore := empL + r ;
    var maxAdd : int ; maxAdd := Set{empR, l}->min() ;
        var i : int ; i := 0 ; while i <= maxAdd do ( (     set := set->including(minScore + 2 * i) )  ;     i := i + 1 ) ; 
 ) 
(     var l : int ; l := Set{a, total / 2}->min() ;
     var r : int ; r := a - l ;
    var empR : int ; empR := (total + 1) / 2 - r ;
    var empL : int ; empL := (total / 2) - l ;
    var minScore : int ; minScore := empL + r ;
    var maxAdd : int ; maxAdd := Set{empR, l}->min() ;
        var i : int ; i := 0 ; while i <= maxAdd do ( (     set := set->including(minScore + 2 * i) )  ;     i := i + 1 ) ; 
 ) 
    skip ; 
    for (x : set) do (     skip ;  ) ; 
    skip ; 
 )  ;     tt := tt + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int[][] flipAndInvertImage(int[][] A){
    int C=A[0] .length ;
    for(int[] row : A)for(int i=0 ; i<(C+1)/2 ; ++i){
      int tmp=row[i] ^ 1 ;
      row[i]=row[C-1-i] ^ 1 ;
      row[C-1-i]=tmp ;
    }
    return A ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation flipAndInvertImage( A : Sequence(Sequence(int))) : Sequence(Sequence(int))
  pre: true
  post: true
  activity: (     var C : int ; C := A[0+1]->size() ;
     for (row : A) do (         var i : int ; i := 0 ; while i < (C + 1) / 2 do ( (     var tmp : int ; tmp := MathLib.bitwiseXor(row[i+1],1) ;
     row[i+1] := row[C - 1 - i+1] xor 1 ; 
     row[C - 1 - i+1] := tmp )  ;     i := i + 1 ) ;  ) ; 
     return A );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countConsecutive(String s){
    int count=0 ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)==s.charAt(i+1)){
        i++;
      }
      else {
        count++;
      }
    }
    return count ;
  }
  public static void main(String args[]){
    String str="44522255" ;
    System.out.println(countConsecutive(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countConsecutive( s : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = s->at(i + 1+1)) then (     i := i + 1 ) else (     count := count + 1 ) )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "44522255" ;
     OclFile["System.out"].println(countConsecutive(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  static int findKHCF(int x,int y,int k){
    int small=Math.min(x,y);
    int count=1 ;
    for(int i=2 ; i<=small ; i++){
      if(x % i==0 && y % i==0)count++;
      if(count==k)return i ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    int x=4,y=24,k=3 ;
    System.out.print(findKHCF(x,y,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findKHCF( x : int, y : int, k : int) : int
  pre: true
  post: true
  activity: (     var small : int ; small := Set{x, y}->min() ;
     var count : int ; count := 1 ;
         var i : int ; i := 2 ; while i <= small do ( (     if (x mod i = 0 & y mod i = 0) then     count := count + 1 ; else skip ; 
     if (count = k) then     return i else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 4 ;
    var y : int ; y := 24 ;
    var k : int ; k := 3 ;
     OclFile["System.out"].print(findKHCF(x, y, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int Largestpower(int n,int p){
    int ans=0 ;
    while(n>0){
      n/=p ;
      ans+=n ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int n=10 ;
    int p=3 ;
    System.out.println(" The largest power of "+p+" that divides "+n+"! is "+Largestpower(n,p));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Largestpower( n : int, p : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     while (n > 0) do (     n := n/(p) ; 
     ans := ans+(n) ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     var p : int ; p := 3 ;
     OclFile["System.out"].println(" The largest power of " + p + " that divides " + n + "! is " + Largestpower(n, p)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[] nums=new int[n];
    for(int i=0 ; i<n ; i++){
      nums[i]=scan.nextInt();
    }
    int max=0 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=0 ; j<=n-i ; j++){
        int[] new_nums=Arrays.copyOfRange(nums,j,j+i);
        int sum=new_nums[0];
        for(int k=1 ; k<i ; k++){
          sum ^=new_nums[k];
        }
        if(sum>max){
          max=sum ;
        }
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= n - i do ( (     var new_nums : Sequence(int) ; new_nums := nums.subrange(j+1,j + i) ;
     var sum : int ; sum := new_nums[0+1] ;
         var k : int ; k := 1 ; while k < i do ( (     sum := MathLib.bitwiseXor(sum,new_nums[k+1]) )  ;     k := k + 1 ) ; 
     if (sum > max) then (     max := sum ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BadPRices {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=in.nextInt();
      int min=a[n-1];
      int count=0 ;
      for(int i=n-2 ; i>=0 ; i--){
        if(a[i]>min){
          count++;
        }
        min=Math.min(a[i],min);
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BadPRices {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var min : int ; min := a[n - 1+1] ;
    var count : int ; count := 0 ;
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (a[i+1] > min) then (     count := count + 1 ) else skip ; 
     min := Set{a[i+1], min}->min() )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int Largestpower(int n,int p){
    int ans=0 ;
    while(n>0){
      n/=p ;
      ans+=n ;
    }
    return ans ;
  }
  public static void main(String[] args){
    int n=10 ;
    int p=3 ;
    System.out.println(" The largest power of "+p+" that divides "+n+"! is "+Largestpower(n,p));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Largestpower( n : int, p : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     while (n > 0) do (     n := n/(p) ; 
     ans := ans+(n) ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     var p : int ; p := 3 ;
     OclFile["System.out"].println(" The largest power of " + p + " that divides " + n + "! is " + Largestpower(n, p)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      while(sc.hasNext()){
        long L=sc.nextLong();
        if(L==0)break ;
        long ans=1 ;
        for(long i=2 ; i*i<=L ; i++){
          if(L % i!=0)continue ;
          L/=i ;
          int count=1 ;
          while(L % i==0){
            L/=i ;
            count++;
          }
          ans*=(count+1)*(count+1)-count*count ;
        }
        if(L!=1){
          ans*=2*2-1*1 ;
        }
        System.out.println((ans+1)/2);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (sc.hasNext()) do (     var L : long ; L := sc.getCurrent()->toLong() ;
     if (L = 0) then     break else skip ; 
    var ans : long ; ans := 1 ;
        var i : long ; i := 2 ; while i * i <= L do ( (     if (L mod i /= 0) then     continue else skip ; 
     L := L/(i) ; 
    var count : int ; count := 1 ;
    while (L mod i = 0) do (     L := L/(i) ; 
     count := count + 1 ) ; 
    ans := ans*((count + 1) * (count + 1) - count * count) ; 
 )  ;     i := i + 1 ) ; 
    if (L /= 1) then (     ans := ans*(2 * 2 - 1 * 1) ) else skip ; 
    OclFile["System.out"].println((ans + 1) / 2) ; 
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import static java.lang.Math.sqrt ;
class Main {
  private static int[] calcPrimes(int n){
    boolean[] table=new boolean[n+1];
    for(int i=2 ; i<=Math.sqrt(n); i++){
      if(! table[i]){
        for(int j=i+i ; j<=n ; j+=i){
          table[j]=true ;
        }
      }
    }
    int counter=0 ;
    for(int i=2 ; i<=n ; i++){
      if(! table[i]){
        counter++;
      }
    }
    int[] result=new int[counter];
    int index=0 ;
    for(int i=2 ; i<=n ; i++){
      if(! table[i]){
        result[index++]=i ;
      }
    }
    return result ;
  }
  private static void solve(){
    Scanner scanner=new Scanner(System.in);
    int[] primes=calcPrimes(1000000);
    while(scanner.hasNextLong()){
      long l=scanner.nextLong();
      if(l==0){
        break ;
      }
      int result=1 ;
      for(int i=0 ; i<primes.length && primes[i]<=sqrt(l); i++){
        if(l % primes[i]==0){
          int counter=0 ;
          while(l % primes[i]==0){
            l/=primes[i];
            counter++;
          }
          result*=(2*counter)+1 ;
        }
      }
      if(l!=1){
        result*=3 ;
      }
      result=result/2+1 ;
      System.out.println(result);
    }
  }
  public static void main(String...args){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation calcPrimes( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var table : Sequence(boolean) ; table := Integer.subrange(1,n + 1)->collect(false) ;
         var i : int ; i := 2 ; while i <= (n)->sqrt() do ( (     if (not(table[i+1])) then (         var j : int ; j := i + i ; while j <= n do ( (     table[j+1] := true )  ;     j := j+(i) ) ) else skip )  ;     i := i + 1 ) ; 
    var counter : int ; counter := 0 ;
        var i : int ; i := 2 ; while i <= n do ( (     if (not(table[i+1])) then (     counter := counter + 1 ) else skip )  ;     i := i + 1 ) ; 
    var result : Sequence(int) ; result := Integer.subrange(1,counter)->collect(0) ;
    var index : int ; index := 0 ;
        var i : int ; i := 2 ; while i <= n do ( (     if (not(table[i+1])) then (      result[index+1] := i  ; index := index + 1 ) else skip )  ;     i := i + 1 ) ; 
    return result 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var primes : Sequence(int) ; primes := calcPrimes(1000000) ;
     while (scanner.hasNextLong()) do (     var l : long ; l := scanner.getCurrent()->toLong() ;
     if (l = 0) then (     break ) else skip ; 
    var result : int ; result := 1 ;
        var i : int ; i := 0 ; while i < primes->size() & primes[i+1] <= sqrt(l) do ( (     if (l mod primes[i+1] = 0) then (     var counter : int ; counter := 0 ;
     while (l mod primes[i+1] = 0) do (     l := l/(primes[i+1]) ; 
     counter := counter + 1 ) ; 
     result := result*((2 * counter) + 1) ) else skip )  ;     i := i + 1 ) ; 
    if (l /= 1) then (     result := result*(3) ) else skip ; 
    result := result / 2 + 1 ; 
    OclFile["System.out"].println(result) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    while(true){
      long L=sc.nextLong();
      if(L==0)break ;
      long ans=1 ;
      for(long i=2 ; i*i<=L ; ++i){
        if(L % i!=0)continue ;
        int c=1 ;
        L/=i ;
        while(L % i==0){
          L/=i ;
++c ;
        }
        ans*=c*2+1 ;
      }
      if(L!=1){
        ans*=3 ;
      }
      System.out.println((ans-1)/2+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var L : long ; L := sc.getCurrent()->toLong() ;
     if (L = 0) then     break else skip ; 
    var ans : long ; ans := 1 ;
        var i : long ; i := 2 ; while i * i <= L do ( (     if (L mod i /= 0) then     continue else skip ; 
     var c : int ; c := 1 ;
    L := L/(i) ; 
    while (L mod i = 0) do (     L := L/(i) ; 
     c := c + 1 ) ; 
    ans := ans*(c * 2 + 1) ; 
 )  ;     i := i + 1 ) ; 
    if (L /= 1) then (     ans := ans*(3) ) else skip ; 
    OclFile["System.out"].println((ans - 1) / 2 + 1) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Stack ;
class GFG {
  public static void countEle(Stack<Integer>s,int[] a,int N){
    HashMap<Integer,Boolean>mp=new HashMap<>();
    for(int i=0 ; i<N ; ++i){
      int num=a[i];
      if(mp.containsKey(num))System.out.print("0 ");
      else {
        int cnt=0 ;
        while(s.peek()!=num){
          mp.put(s.peek(),true);
          s.pop();
          cnt++;
        }
        s.pop();
        cnt++;
        System.out.print(cnt+" ");
      }
    }
  }
  public static void main(String[] args){
    int N=5 ;
    Stack<Integer>s=new Stack<>();
    s.add(1);
    s.add(2);
    s.add(3);
    s.add(4);
    s.add(6);
    int[] a={
      6,3,4,1,2 };
      countEle(s,a,N);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countEle( s : Sequence(int), a : Sequence(int), N : int) : void
  pre: true
  post: true
  activity: (     var mp : Map(int,Boolean) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < N do ( (     var num : int ; num := a[i+1] ;
     if (mp->keys()->includes(num)) then     OclFile["System.out"].print("0 ") ; else (     var cnt : int ; cnt := 0 ;
     while (s->min() /= num) do (     mp := mp->union(Map{s->min() |-> true}) ; 
     s := s->front() ; 
     cnt := cnt + 1 ) ; 
    s := s->front() ; 
    cnt := cnt + 1 ; 
    OclFile["System.out"].print(cnt + " ") ; 
 ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     var s : Sequence(int) ; s := Sequence{} ;
    s := s->including(1) ; 
    s := s->including(2) ; 
    s := s->including(3) ; 
    s := s->including(4) ; 
    s := s->including(6) ; 
    var a : Sequence(int) ; a := Sequence{6,3,4,1,2} ;
    execute countEle(s, a, N) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int min(int a,int b){
    return(a>b)? b : a ;
  }
  static int minCostJumpsDP(int[] A,int k){
    int size=A.length ;
    int[] x=new int[size];
    Arrays.fill(x,Integer.MAX_VALUE);
    x[0]=0 ;
    for(int i=0 ; i<size ; i++){
      for(int j=i+1 ; j<i+k+1 && j<size ; j++){
        x[j]=min(x[j],x[i]+Math.abs(A[i]-A[j]));
      }
    }
    return x[size-1];
  }
  public static void main(String[] args){
    int[] input={
      83,26,37,35,33,35,56 };
      System.out.println(minCostJumpsDP(input,3));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation min( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if (a > b) then b else a endif );
  static   operation minCostJumpsDP( A : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     var size : int ; size := A->size() ;
     var x : Sequence(int) ; x := Integer.subrange(1,size)->collect(0) ;
    x := x->collect(2147483647) ; 
    x[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < size do ( (         var j : int ; j := i + 1 ; while j < i + k + 1 & j < size do ( (     x[j+1] := Set{x[j+1], x[i+1] + if A[i+1] - A[j+1] < 0 then -(A[i+1] - A[j+1]) else A[i+1] - A[j+1] endif}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return x[size - 1+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : Sequence(int) ; input := Sequence{83,26,37,35,33,35,56} ;
     OclFile["System.out"].println(minCostJumpsDP(input, 3)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float find_prob(int N,float P){
    double dp[]=new double[N+1];
    dp[0]=1 ;
    dp[1]=0 ;
    dp[2]=P ;
    dp[3]=1-P ;
    for(int i=4 ; i<=N ; ++i)dp[i]=(P)*dp[i-2]+(1-P)*dp[i-3];
    return((float)(dp[N]));
  }
  public static void main(String args[]){
    int n=5 ;
    float p=0.2f ;
    System.out.printf("%.2f",find_prob(n,p));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation find_prob( N : int, P : double) : double
  pre: true
  post: true
  activity: (     var dp : Sequence(double) ; dp := Integer.subrange(1,N + 1)->collect(0.0) ;
     dp[0+1] := 1 ; 
    dp[1+1] := 0 ; 
    dp[2+1] := P ; 
    dp[3+1] := 1 - P ; 
        var i : int ; i := 4 ; while i <= N do (     dp[i+1] := (P) * dp[i - 2+1] + (1 - P) * dp[i - 3+1] ;  ;     i := i + 1 ) ; 
    return ((dp[N+1])->oclAsType(double)) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var p : double ; p := 0.2f ;
     OclFile["System.out"].printf("%.2f", find_prob(n, p)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class AA {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int e=Math.abs(sc.nextInt())+Math.abs(sc.nextInt());
    int y=sc.nextInt()-e ;
    if(y>=0 && y % 2==0)System.out.print("Yes");
    else System.out.print("No");
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class AA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var e : int ; e := if sc.getCurrent()->toInteger() < 0 then -(sc.getCurrent()->toInteger()) else sc.getCurrent()->toInteger() endif + if sc.getCurrent()->toInteger() < 0 then -(sc.getCurrent()->toInteger()) else sc.getCurrent()->toInteger() endif ;
    var y : int ; y := sc.getCurrent()->toInteger() - e ;
    if (y >= 0 & y mod 2 = 0) then     OclFile["System.out"].print("Yes") else     OclFile["System.out"].print("No") ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class JavaApplication77 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int num1=Math.abs(sc.nextInt());
    int num2=Math.abs(sc.nextInt());
    int num3=Math.abs(sc.nextInt());
    if(num3>=num1+num2){
      if((num1+num2)% 2==0 && num3 % 2==0){
        System.out.println("Yes");
      }
      else if((num1+num2)% 2!=0 && num3 % 2!=0){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JavaApplication77 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num1 : int ; num1 := if sc.getCurrent()->toInteger() < 0 then -(sc.getCurrent()->toInteger()) else sc.getCurrent()->toInteger() endif ;
    var num2 : int ; num2 := if sc.getCurrent()->toInteger() < 0 then -(sc.getCurrent()->toInteger()) else sc.getCurrent()->toInteger() endif ;
    var num3 : int ; num3 := if sc.getCurrent()->toInteger() < 0 then -(sc.getCurrent()->toInteger()) else sc.getCurrent()->toInteger() endif ;
    if (num3 >= num1 + num2) then (     if ((num1 + num2) mod 2 = 0 & num3 mod 2 = 0) then (     OclFile["System.out"].println("Yes") ) else     if ((num1 + num2) mod 2 /= 0 & num3 mod 2 /= 0) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class student {
  public static void main(String[] args){
    Scanner obj=new Scanner(System.in);
    int a=obj.nextInt();
    int b=obj.nextInt();
    if(Math.abs(b-a)==1)System.out.println("YES");
    else {
      if(Math.abs(a-b)==0 && a!=0 && b!=0)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class student {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : OclFile ; obj := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := obj.getCurrent()->toInteger() ;
     var b : int ; b := obj.getCurrent()->toInteger() ;
     if (if b - a < 0 then -(b - a) else b - a endif = 1) then     OclFile["System.out"].println("YES") ; else (     if (if a - b < 0 then -(a - b) else a - b endif = 0 & a /= 0 & b /= 0) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner read=new Scanner(System.in);
    long ans=0 ;
    int n=read.nextInt();
    long[] arr=new long[n+1];
    long[] pref=new long[n+1];
    for(int i=1 ; i<=n ; i++){
      arr[i]=read.nextLong();
      pref[i]=pref[i-1] ^ arr[i];
    }
    for(int i=1 ; i<=n ; i++){
      for(int j=i ; j<=n ; j++){
        ans=Math.max(ans,pref[j] ^ pref[i-1]);
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : OclFile ; read := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ans : long ; ans := 0 ;
    var n : int ; n := read.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
    var pref : Sequence(long) ; pref := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := read.getCurrent()->toLong() ; 
     pref[i+1] := pref[i - 1+1] xor arr[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i ; while j <= n do ( (     ans := Set{ans, pref[j+1] xor pref[i - 1+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static boolean isSubSeqDivisible(String str){
    int n=str.length();
    int dp[][]=new int[n+1][10];
    int arr[]=new int[n+1];
    for(int i=1 ; i<=n ; i++)arr[i]=(int)(str.charAt(i-1)-'0');
    for(int i=1 ; i<=n ; i++){
      dp[i][arr[i] % 8]=1 ;
      for(int j=0 ; j<8 ; j++){
        if(dp[i-1][j]>dp[i][(j*10+arr[i])% 8])dp[i][(j*10+arr[i])% 8]=dp[i-1][j];
        if(dp[i-1][j]>dp[i][j])dp[i][j]=dp[i-1][j];
      }
    }
    for(int i=1 ; i<=n ; i++){
      if(dp[i][0]==1)return true ;
    }
    return false ;
  }
  public static void main(String args[]){
    String str="3144" ;
    if(isSubSeqDivisible(str))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isSubSeqDivisible( str : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := str->size() ;
     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,10)->collect(0)) ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     arr[i+1] := (str->at(i - 1+1) - ('0')->char2byte())->oclAsType(int) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     dp[i+1][arr[i+1] mod 8+1] := 1 ; 
         var j : int ; j := 0 ; while j < 8 do ( (     if (dp[i - 1+1][j+1] > dp[i+1][(j * 10 + arr[i+1]) mod 8+1]) then     dp[i+1][(j * 10 + arr[i+1]) mod 8+1] := dp[i - 1+1][j+1] ; else skip ; 
     if (dp[i - 1+1][j+1] > dp[i+1][j+1]) then     dp[i+1][j+1] := dp[i - 1+1][j+1] ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (dp[i+1][0+1] = 1) then     return true else skip )  ;     i := i + 1 ) ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "3144" ;
     if (isSubSeqDivisible(str)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int StrictlyPositiveXor(int[] A,int N){
    int allxor=0 ;
    boolean checkallzero=true ;
    for(int i=0 ; i<N ; i+=1){
      allxor ^=A[i];
      if(A[i]>0)checkallzero=false ;
    }
    if(allxor!=0)return N ;
    if(checkallzero)return-1 ;
    int l=N,r=-1 ;
    for(int i=0 ; i<N ; i+=1){
      if(A[i]>0){
        l=i+1 ;
        break ;
      }
    }
    for(int i=N-1 ; i>=0 ; i-=1){
      if(A[i]>0){
        r=i+1 ;
        break ;
      }
    }
    return Math.max(N-l,r-1);
  }
  public static void main(String[] args){
    int A[]={
      1,0,0,1 };
      int N=A.length ;
      System.out.print(StrictlyPositiveXor(A,N));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation StrictlyPositiveXor( A : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var allxor : int ; allxor := 0 ;
     var checkallzero : boolean ; checkallzero := true ;
        var i : int ; i := 0 ; while i < N do ( (     allxor := MathLib.bitwiseXor(allxor,A[i+1]) ; 
     if (A[i+1] > 0) then     checkallzero := false ; else skip )  ;     i := i+(1) ) ; 
    if (allxor /= 0) then     return N else skip ; 
    if (checkallzero) then     return -1 else skip ; 
    var l : int ; l := N ;
    var r : int ; r := -1 ;
        var i : int ; i := 0 ; while i < N do ( (     if (A[i+1] > 0) then (     l := i + 1 ; 
     break ) else skip )  ;     i := i+(1) ) ; 
        var i : int ; i := N - 1 ; while i >= 0 do ( (     if (A[i+1] > 0) then (     r := i + 1 ; 
     break ) else skip )  ;     i := i-(1) ) ; 
    return Set{N - l, r - 1}->max() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{1,0,0,1} ;
     var N : int ; N := A->size() ;
     OclFile["System.out"].print(StrictlyPositiveXor(A, N)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Chess2 {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw=new PrintWriter(System.out);
    char[][] c=new char[8][8];
    for(int i=0 ; i<8 ; i++){
      c[i]=br.readLine().toCharArray();
    }
    int mina=9 ;
    int minb=9 ;
    for(int i=0 ; i<8 ; i++){
      for(int j=0 ; j<8 ; j++){
        if(c[i][j]=='W')mina=Math.min(mina,movesToWin(c,i,j));
        else if(c[i][j]=='B')minb=Math.min(minb,movesToWin(c,i,j));
      }
    }
    if(minb<mina)pw.println("B");
    else pw.println("A");
    pw.close();
  }
  public static int movesToWin(char[][] arr,int i,int j){
    if(arr[i][j]=='W'){
      int x=0 ;
      for(int k=i-1 ; k>=0 ; k--){
        x++;
        if(arr[k][j]!='.')return 10 ;
      }
      return x ;
    }
    else {
      int x=0 ;
      for(int k=i+1 ; k<=7 ; k++){
        x++;
        if(arr[k][j]!='.')return 10 ;
      }
      return x ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Chess2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var c : Sequence(Sequence(String)) ; c := Integer.subrange(1,8)->collect(Integer.subrange(1,8)->collect(0)) ;
        var i : int ; i := 0 ; while i < 8 do ( (     c[i+1] := br.readLine()->characters() )  ;     i := i + 1 ) ; 
    var mina : int ; mina := 9 ;
    var minb : int ; minb := 9 ;
        var i : int ; i := 0 ; while i < 8 do ( (         var j : int ; j := 0 ; while j < 8 do ( (     if (c[i+1][j+1] = 'W') then     mina := Set{mina, movesToWin(c, i, j)}->min() ; else     if (c[i+1][j+1] = 'B') then     minb := Set{minb, movesToWin(c, i, j)}->min() ; else skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (minb < mina) then     skip else     skip ; ;  
    skip ; 
 );
  static   operation movesToWin( arr : Sequence(Sequence(String)), i : int, j : int) : int
  pre: true
  post: true
  activity: (     if (arr[i+1][j+1] = 'W') then (     var x : int ; x := 0 ;
         var k : int ; k := i - 1 ; while k >= 0 do ( (     x := x + 1 ; 
     if (arr[k+1][j+1] /= '.') then     return 10 else skip )  ;     k := k - 1 ) ; 
     return x ) else (     var x : int ; x := 0 ;
         var k : int ; k := i + 1 ; while k <= 7 do ( (     x := x + 1 ; 
     if (arr[k+1][j+1] /= '.') then     return 10 else skip )  ;     k := k + 1 ) ; 
     return x ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      String[][] a=new String[9][9];
      for(int i=1 ; i<=8 ; i++){
        String b="a"+in.next();
        String[] c=b.split("");
        for(int j=1 ; j<=8 ; j++){
          a[i][j]=c[j];
        }
      }
      int min=Integer.MAX_VALUE ;
      int minn=Integer.MAX_VALUE ;
      for(int i=1 ; i<9 ; i++){
        for(int j=1 ; j<9 ; j++){
          if(a[i][j] .equals("B")){
            int s=0 ;
            for(int k=i+1 ; k<9 ; k++){
              if(a[k][j] .equals("."))s++;
            }
            if(s==8-i)min=Math.min(min,s);
          }
          else if(a[i][j] .equals("W")){
            int ss=0 ;
            for(int k=i-1 ; k>=1 ; k--){
              if(a[k][j] .equals("."))ss++;
            }
            if(ss==i-1)minn=Math.min(minn,ss);
          }
        }
      }
      if(minn<=min)System.out.println("A");
      else System.out.println("B");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,9)->collect(Integer.subrange(1,9)->collect(null)) ;
         var i : int ; i := 1 ; while i <= 8 do ( (     var b : String ; b := "a" + in.getCurrent() ;
     var c : Sequence(String) ; c := b->split("") ;
         var j : int ; j := 1 ; while j <= 8 do ( (     a[i+1][j+1] := c[j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
    var minn : int ; minn := 2147483647 ;
        var i : int ; i := 1 ; while i < 9 do ( (         var j : int ; j := 1 ; while j < 9 do ( (     if (a[i+1][j+1] = "B") then (     var s : int ; s := 0 ;
         var k : int ; k := i + 1 ; while k < 9 do ( (     if (a[k+1][j+1] = ".") then     s := s + 1 ; else skip )  ;     k := k + 1 ) ; 
     if (s = 8 - i) then     min := Set{min, s}->min() ; else skip ) else     if (a[i+1][j+1] = "W") then (     var ss : int ; ss := 0 ;
         var k : int ; k := i - 1 ; while k >= 1 do ( (     if (a[k+1][j+1] = ".") then     ss := ss + 1 ; else skip )  ;     k := k - 1 ) ; 
     if (ss = i - 1) then     minn := Set{minn, ss}->min() ; else skip ) else skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (minn <= min) then     OclFile["System.out"].println("A") else     OclFile["System.out"].println("B") ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  private static final Comparator<int[]>COMPARATOR=new Comparator<int[]>(){
    @ Override public int compare(int[] o1,int[] o2){
      int result=-(o1[2]-o2[2]);
      if(result==0){
        result=o1[3]-o2[3];
        if(result==0){
          result=(o1[0]-o2[0]);
        }
      }
      return result ;
    }
  };
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int[][] team=new int[300][4];
    int[] count=new int[1000];
    for(int n=in.nextInt(); n>0 ; n=in.nextInt()){
      for(int i=0 ; i<n ; i++){
        team[i][0]=in.nextInt();
        team[i][1]=in.nextInt()-1 ;
        team[i][2]=in.nextInt();
        team[i][3]=in.nextInt();
      }
      Arrays.sort(team,0,n,COMPARATOR);
      Arrays.fill(count,0);
      int selected=0 ;
      for(int i=0 ; i<n ; i++){
        final int[] t=team[i];
        final int group=t[1];
        if(selected<10 && count[group]<3 || selected<20 && count[group]<2 || selected<26 && count[group]==0){
          selected++;
          count[group]++;
          System.out.println(t[0]);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute COMPARATOR : Function(<Sequence(int)>,(<Sequence(int)>,boolean)) := OclComparator<Sequence(int)>.newOclComparator();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var team : Sequence(Sequence(int)) ; team := Integer.subrange(1,300)->collect(Integer.subrange(1,4)->collect(0)) ;
     var count : Sequence(int) ; count := Integer.subrange(1,1000)->collect(0) ;
         var n : int ; n := in.getCurrent()->toInteger() ; while n > 0 do ( (         var i : int ; i := 0 ; while i < n do ( (     team[i+1][0+1] := in.getCurrent()->toInteger() ; 
     team[i+1][1+1] := in.getCurrent()->toInteger() - 1 ; 
     team[i+1][2+1] := in.getCurrent()->toInteger() ; 
     team[i+1][3+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     team, 0, n, COMPARATOR := team, 0, n, COMPARATOR->sort() ; 
    count := count->collect(0) ; 
    var selected : int ; selected := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var t : Sequence(int) ; t := team[i+1] ;
     var group : int ; group := t[1+1] ;
     if (selected < 10 & count[group+1] < 3 or selected < 20 & count[group+1] < 2 or selected < 26 & count[group+1] = 0) then (     selected := selected + 1 ; 
     count[group+1] := count[group+1] + 1 ; 
     OclFile["System.out"].println(t[0+1]) ) else skip )  ;     i := i + 1 ) ; 
 )  ;     n := in.getCurrent()->toInteger() ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] a=new int[n];
      int[] b=new int[n];
      int[] c=new int[n];
      int[] d=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
        b[i]=sc.nextInt();
        c[i]=sc.nextInt();
        d[i]=sc.nextInt();
      }
      int[] s=new int[1001];
      int p ;
      int count=0 ;
      PriorityQueue<Integer>q=new PriorityQueue<Integer>();
      PriorityQueue<Integer>r=new PriorityQueue<Integer>();
      for(int i=10 ; i>=0 ; i--){
        for(int j=0 ; j<n ; j++){
          if(c[j]==i && q.contains(d[j])==false)q.add(d[j]);
        }
        while(q.size()!=0){
          p=q.poll();
          for(int j=0 ; j<n ; j++){
            if(c[j]==i && d[j]==p)r.add(a[j]);
          }
          while(r.size()!=0){
            p=r.poll();
            for(int j=0 ; j<n ; j++){
              if(a[j]==p){
                if((count<10 && s[b[j] ]<3)||(count<20 && s[b[j] ]<2)||(count<26 && s[b[j] ]==0)){
                  System.out.println(p);
                  count++;
                  s[b[j] ]++;
                  break ;
                }
              }
            }
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    var d : Sequence(int) ; d := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() ; 
     c[i+1] := sc.getCurrent()->toInteger() ; 
     d[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var s : Sequence(int) ; s := Integer.subrange(1,1001)->collect(0) ;
    var p : int ;
    var count : int ; count := 0 ;
    var q : Sequence(int) ; q := Sequence{} ;
    var r : Sequence(int) ; r := Sequence{} ;
        var i : int ; i := 10 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < n do ( (     if (c[j+1] = i & q->includes(d[j+1]) = false) then     q := q->including(d[j+1]) ; else skip )  ;     j := j + 1 ) ; 
     while (q->size() /= 0) do (     p := q->min() ;     q := q->sort()->tail() ; 
         var j : int ; j := 0 ; while j < n do ( (     if (c[j+1] = i & d[j+1] = p) then     r := r->including(a[j+1]) ; else skip )  ;     j := j + 1 ) ; 
     while (r->size() /= 0) do (     p := r->min() ;     r := r->sort()->tail() ; 
         var j : int ; j := 0 ; while j < n do ( (     if (a[j+1] = p) then (     if ((count < 10 & s[b[j+1]+1] < 3) or (count < 20 & s[b[j+1]+1] < 2) or (count < 26 & s[b[j+1]+1] = 0)) then (     OclFile["System.out"].println(p) ; 
     count := count + 1 ; 
     s[b[j+1]+1] := s[b[j+1]+1] + 1 ; 
     break ) else skip ) else skip )  ;     j := j + 1 ) ) ) )  ;     i := i - 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->=1){
      int n=sc.nextInt();
      int[] prices=new int[n];
      for(int i=0 ; i<n ; i++)prices[i]=sc.nextInt();
      int min=prices[n-1];
      int count=0 ;
      for(int i=n-2 ; i>=0 ; i--){
        if(prices[i]>min)count++;
        min=Math.min(prices[i],min);
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t >= 1) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var prices : Sequence(int) ; prices := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     prices[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var min : int ; min := prices[n - 1+1] ;
    var count : int ; count := 0 ;
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (prices[i+1] > min) then     count := count + 1 ; else skip ; 
     min := Set{prices[i+1], min}->min() )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean isPalindrome(int n){
    int divisor=1 ;
    while(n/divisor>=10)divisor*=10 ;
    while(n!=0){
      int leading=n/divisor ;
      int trailing=n % 10 ;
      if(leading!=trailing)return false ;
      n=(n % divisor)/10 ;
      divisor=divisor/100 ;
    }
    return true ;
  }
  public static void main(String args[]){
    if(isPalindrome(1001))System.out.println("Yes,it is Palindrome");
    else System.out.println("No,not Palindrome");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPalindrome( n : int) : boolean
  pre: true
  post: true
  activity: (     var divisor : int ; divisor := 1 ;
     while (n / divisor >= 10) do     divisor := divisor*(10) ; ; 
     while (n /= 0) do (     var leading : int ; leading := n / divisor ;
     var trailing : int ; trailing := n mod 10 ;
    if (leading /= trailing) then     return false else skip ; 
    n := (n mod divisor) / 10 ; 
    divisor := divisor / 100 ; 
 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (isPalindrome(1001)) then     OclFile["System.out"].println("Yes,it is Palindrome") ; else     OclFile["System.out"].println("No,not Palindrome") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=0 ;
    int[] x=new int[n+1];
    x[1]=sc.nextInt();
    for(int i=2 ; i<=n ; i++){
      x[i]=sc.nextInt()^ x[i-1];
    }
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<=n ; j++){
        t=Math.max(t,x[i] ^ x[j]);
      }
    }
    System.out.println(t);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := 0 ;
    var x : Sequence(int) ; x := Integer.subrange(1,n + 1)->collect(0) ;
    x[1+1] := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 2 ; while i <= n do ( (     x[i+1] := sc.getCurrent()->toInteger() xor x[i - 1+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j <= n do ( (     t := Set{t, x[i+1] xor x[j+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(t) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int x=26 ;
  static int mod=3001 ;
  static void CntSubstr(char[] s,int l){
    int hash=0 ;
    for(int i=0 ; i<l ; i++){
      hash=(hash*x+(s[i]-97))% mod ;
    }
    int pow_l=1 ;
    for(int i=0 ; i<l-1 ; i++){
      pow_l=(pow_l*x)% mod ;
    }
    HashSet<Integer>result=new HashSet<Integer>();
    result.add(hash);
    for(int i=l ; i<s.length ; i++){
      hash=((hash-pow_l*(s[i-l]-97)+2*mod)*x+(s[i]-97))% mod ;
      result.add(hash);
    }
    System.out.println(result.size());
  }
  public static void main(String[] args){
    String s="abcba" ;
    int l=2 ;
    CntSubstr(s.toCharArray(),l);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute x : int := 26;
  static   attribute mod : int := 3001;
  static   operation CntSubstr( s : Sequence(String), l : int) : void
  pre: true
  post: true
  activity: (     var hash : int ; hash := 0 ;
         var i : int ; i := 0 ; while i < l do ( (     hash := (hash * x + (s[i+1] - 97)) mod mod )  ;     i := i + 1 ) ; 
    var pow_l : int ; pow_l := 1 ;
        var i : int ; i := 0 ; while i < l - 1 do ( (     pow_l := (pow_l * x) mod mod )  ;     i := i + 1 ) ; 
    var result : Set(int) ; result := Set{} ;
    result := result->including(hash) ; 
        var i : int ; i := l ; while i < s->size() do ( (     hash := ((hash - pow_l * (s[i - l+1] - 97) + 2 * mod) * x + (s[i+1] - 97)) mod mod ; 
     result := result->including(hash) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result->size()) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abcba" ;
     var l : int ; l := 2 ;
     execute CntSubstr(s->characters(), l) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    int count=0 ;
    int len=0 ;
    line=br.readLine();
    len=line.length();
    if(len % 2==1){
      char c=line.charAt(len/2);
      if(c=='(' || c==')')count++;
    }
    for(int i=0 ; i<len/2 ; i++){
      char l=line.charAt(i);
      char r=line.charAt(len-1-i);
      if(l=='i' || l=='w' || r=='i' || r=='w'){
        if(l!=r)count++;
      }
      else {
        if(l==r)count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var count : int ; count := 0 ;
    var len : int ; len := 0 ;
    line := br.readLine() ; 
    len := line->size() ; 
    if (len mod 2 = 1) then (     var c : String ; c := line->at(len / 2+1) ;
     if (c = '(' or c = ')') then     count := count + 1 ; else skip ) else skip ; 
        var i : int ; i := 0 ; while i < len / 2 do ( (     var l : String ; l := line->at(i+1) ;
     var r : String ; r := line->at(len - 1 - (i)->char2byte()+1) ;
     if (l = 'i' or l = 'w' or r = 'i' or r = 'w') then (     if (l /= r) then     count := count + 1 ; else skip ) else (     if (l = r) then     count := count + 1 ; else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  char[] input ;
  char[] iwistr={
    'i','w','(',')' };
    int INF=1<<28 ;
    int min=INF ;
    void run(){
      solve(0,sc.next().toCharArray(),0);
      System.out.println(min);
    }
    void solve(int n,char[] str,int cost){
      if(cost>=min){
        return ;
      }
      if(n==str.length){
        if(isSymmetry(str)){
          min=cost ;
        }
        return ;
      }
      for(int i=0 ; i<4 ; i++){
        char[] nstr=Arrays.copyOf(str,str.length);
        nstr[n]=iwistr[i];
        solve(n+1,nstr,cost+(str[n]==nstr[n] ? 0 : 1));
      }
    }
    boolean isSymmetry(char[] str){
      for(int i=0 ; i<str.length/2 ; i++){
        int init=i ;
        int tail=str.length-1-i ;
        if(str[init]=='(' && str[tail]==')'){
          continue ;
        }
        if(str[init]==')' && str[tail]=='('){
          continue ;
        }
        if(str[init]!=str[tail] || str[init]=='(' || str[init]==')'){
          return false ;
        }
      }
      if(str.length % 2==1 &&(str[str.length/2]=='(' || str[str.length/2]==')'))return false ;
      return true ;
    }
    public static void main(String[] args){
      new Main().run();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute input : Sequence(String);
   attribute iwistr : Sequence(String) := Sequence{'i','w','(',')'};
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute min : int := INF;
   operation run() : void
  pre: true
  post: true
  activity: (     execute solve(0, sc.getCurrent()->characters(), 0) ; 
     OclFile["System.out"].println(min) );
   operation solve( n : int, str : Sequence(String), cost : int) : void
  pre: true
  post: true
  activity: (     if (cost >= min) then (     return ) else skip ; 
     if (n = str->size()) then (     if (isSymmetry(str)) then (     min := cost ) else skip ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < 4 do ( (     var nstr : Sequence(String) ; nstr := str.subrange(1,str->size()) ;
     nstr[n+1] := iwistr[i+1] ; 
     execute solve(n + 1, nstr, cost + (if str[n+1] = nstr[n+1] then 0 else 1 endif)) )  ;     i := i + 1 ) );
   operation isSymmetry( str : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < str->size() / 2 do ( (     var init : int ; init := i ;
     var tail : int ; tail := str->size() - 1 - i ;
    if (str[init+1] = '(' & str[tail+1] = ')') then (     continue ) else skip ; 
    if (str[init+1] = ')' & str[tail+1] = '(') then (     continue ) else skip ; 
    if (str[init+1] /= str[tail+1] or str[init+1] = '(' or str[init+1] = ')') then (     return false ) else skip ; 
 )  ;     i := i + 1 ) ; 
     if (str->size() mod 2 = 1 & (str[str->size() / 2+1] = '(' or str[str->size() / 2+1] = ')')) then     return false else skip ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    String str=stdIn.next();
    int size=str.length();
    int count=0 ;
    if(size % 2==0){
      if(str.charAt(size/2-1)=='i' && str.charAt(size/2)=='i' || str.charAt(size/2-1)=='w' && str.charAt(size/2)=='w' || str.charAt(size/2-1)=='(' && str.charAt(size/2)==')' || str.charAt(size/2-1)==')' && str.charAt(size/2)=='('){
        ;
      }
      else {
++count ;
      }
      for(int i=0 ; i<size/2-1 ; ++i){
        if(str.charAt(i)=='i' && str.charAt(size-i-1)=='i' || str.charAt(i)=='w' && str.charAt(size-i-1)=='w' || str.charAt(i)=='(' && str.charAt(size-i-1)==')' || str.charAt(i)==')' && str.charAt(size-i-1)=='('){
          ;
        }
        else {
++count ;
        }
      }
    }
    else {
      if(str.charAt(size/2)=='i' || str.charAt(size/2)=='w'){
        ;
      }
      else {
++count ;
      }
      for(int i=0 ; i<size/2 ; ++i){
        if(str.charAt(i)=='i' && str.charAt(size-i-1)=='i' || str.charAt(i)=='w' && str.charAt(size-i-1)=='w' || str.charAt(i)=='(' && str.charAt(size-i-1)==')' || str.charAt(i)==')' && str.charAt(size-i-1)=='('){
          ;
        }
        else {
++count ;
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := stdIn.getCurrent() ;
    var size : int ; size := str->size() ;
    var count : int ; count := 0 ;
    if (size mod 2 = 0) then (     if (str->at(size / 2 - 1+1) = 'i' & str->at(size / 2+1) = 'i' or str->at(size / 2 - 1+1) = 'w' & str->at(size / 2+1) = 'w' or str->at(size / 2 - 1+1) = '(' & str->at(size / 2+1) = ')' or str->at(size / 2 - 1+1) = ')' & str->at(size / 2+1) = '(') then (  ) else (     count := count + 1 ) ;  
         var i : int ; i := 0 ; while i < size / 2 - 1 do ( (     if (str->at(i+1) = 'i' & str->at((size)->char2byte() - i - 1+1) = 'i' or str->at(i+1) = 'w' & str->at((size)->char2byte() - i - 1+1) = 'w' or str->at(i+1) = '(' & str->at((size)->char2byte() - i - 1+1) = ')' or str->at(i+1) = ')' & str->at((size)->char2byte() - i - 1+1) = '(') then (  ) else (     count := count + 1 ) )  ;     i := i + 1 ) ) else (     if (str->at(size / 2+1) = 'i' or str->at(size / 2+1) = 'w') then (  ) else (     count := count + 1 ) ;  
         var i : int ; i := 0 ; while i < size / 2 do ( (     if (str->at(i+1) = 'i' & str->at((size)->char2byte() - i - 1+1) = 'i' or str->at(i+1) = 'w' & str->at((size)->char2byte() - i - 1+1) = 'w' or str->at(i+1) = '(' & str->at((size)->char2byte() - i - 1+1) = ')' or str->at(i+1) = ')' & str->at((size)->char2byte() - i - 1+1) = '(') then (  ) else (     count := count + 1 ) )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args)throws Exception {
    String str=sc.next();
    int ans=0 ;
    for(int i=0 ; i<str.length()/2 ; ++i){
      if(! syn(str.charAt(i),str.charAt(str.length()-1-i))){
++ans ;
      }
    }
    if(str.length()% 2==1){
      char center=str.charAt(str.length()/2);
      if(center=='(' || center==')'){
++ans ;
      }
    }
    System.out.println(ans);
  }
  static boolean syn(char c1,char c2){
    if(c1=='i' && c2=='i'){
      return true ;
    }
    if(c1=='w' && c2=='w'){
      return true ;
    }
    if(c1=='(' && c2==')'){
      return true ;
    }
    if(c1==')' && c2=='('){
      return true ;
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := sc.getCurrent() ;
     var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < str->size() / 2 do ( (     if (not(syn(str->at(i+1), str->at(str->size() - 1 - i+1)))) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (str->size() mod 2 = 1) then (     var center : String ; center := str->at(str->size() / 2+1) ;
     if (center = '(' or center = ')') then (     ans := ans + 1 ) else skip ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation syn( c1 : String, c2 : String) : boolean
  pre: true
  post: true
  activity: (     if (c1 = 'i' & c2 = 'i') then (     return true ) else skip ; 
     if (c1 = 'w' & c2 = 'w') then (     return true ) else skip ; 
    if (c1 = '(' & c2 = ')') then (     return true ) else skip ; 
    if (c1 = ')' & c2 = '(') then (     return true ) else skip ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int cnt ;
  void solve(){
    Scanner sc=new Scanner(System.in);
    String line=sc.next();
    char[] c=line.toCharArray();
    cnt=0 ;
    for(int i=0 ; i<=c.length/2 ; i++){
      if(c[i]=='(' && c[c.length-i-1]!=')'){
        cnt++;
        c[c.length-i-1]=')' ;
        continue ;
      }
      if(c[i]==')' && c[c.length-i-1]!='('){
        cnt++;
        c[c.length-i-1]='(' ;
        continue ;
      }
      if(c[i]=='w' && c[c.length-i-1]!='w'){
        cnt++;
        c[c.length-i-1]='w' ;
        continue ;
      }
      if(c[i]=='i' && c[c.length-i-1]!='i'){
        cnt++;
        c[c.length-i-1]='i' ;
        continue ;
      }
    }
    System.out.println(cnt);
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute cnt : int;
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : String ; line := sc.getCurrent() ;
    var c : Sequence(String) ; c := line->characters() ;
    cnt := 0 ; 
        var i : int ; i := 0 ; while i <= c->size() / 2 do ( (     if (c[i+1] = '(' & c[c->size() - i - 1+1] /= ')') then (     cnt := cnt + 1 ; 
     c[c->size() - i - 1+1] := ')' ; 
     continue ) else skip ; 
     if (c[i+1] = ')' & c[c->size() - i - 1+1] /= '(') then (     cnt := cnt + 1 ; 
     c[c->size() - i - 1+1] := '(' ; 
     continue ) else skip ; 
     if (c[i+1] = 'w' & c[c->size() - i - 1+1] /= 'w') then (     cnt := cnt + 1 ; 
     c[c->size() - i - 1+1] := 'w' ; 
     continue ) else skip ; 
     if (c[i+1] = 'i' & c[c->size() - i - 1+1] /= 'i') then (     cnt := cnt + 1 ; 
     c[c->size() - i - 1+1] := 'i' ; 
     continue ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] args)throws IOException {
    new SolA().solve();
    IO.reader.close();
    IO.writer.close();
  }
}
class SolA {
  public void solve()throws IOException {
    StringTokenizer rgbTokens=new StringTokenizer(IO.reader.readLine());
    int r=Integer.parseInt(rgbTokens.nextToken());
    int g=Integer.parseInt(rgbTokens.nextToken());
    int b=Integer.parseInt(rgbTokens.nextToken());
    int rc=(r+1)/2,gc=(g+1)/2,bc=(b+1)/2 ;
    int v=Integer.max(rc,Integer.max(gc,bc));
    int ans=30+3*(v-1);
    if(v==bc){
      ans+=2 ;
    }
    else if(v==gc){
      ans+=1 ;
    }
    IO.writer.println(ans);
  }
}
class IO {
  public static final BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
  public static final PrintWriter writer=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     SolA.newSolA().solve() ; 
     IO.reader.close() ; 
     IO.writer.close() );
}
class SolA {
   operation solve() : void
  pre: true
  post: true
  activity: (     var rgbTokens : OclIterator ; rgbTokens := OclIterator.newOclIterator_String(IO.reader.readLine()) ;
     var r : int ; r := (rgbTokens.next())->toInteger() ;
    var g : int ; g := (rgbTokens.next())->toInteger() ;
    var b : int ; b := (rgbTokens.next())->toInteger() ;
    var rc : int ; rc := (r + 1) / 2 ;
    var gc : int ; gc := (g + 1) / 2 ;
    var bc : int ; bc := (b + 1) / 2 ;
    var v : int ; v := Set{rc, Set{gc, bc}->max()}->max() ;
    var ans : int ; ans := 30 + 3 * (v - 1) ;
    if (v = bc) then (     ans := ans+(2) ) else     if (v = gc) then (     ans := ans+(1) ) else skip ; ;  
    IO.writer.println(ans) ; 
 );
}
class IO {
  static    attribute reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static    attribute writer : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])));
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A90_1000_Cableway_greedy_math_Round74 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int r,g,b,ans=29 ;
    r=sc.nextInt();
    g=sc.nextInt();
    b=sc.nextInt();
    for(int i=0 ; i<300 ; i++){
      if(r>0 &&(i % 3==0)){
        r--;
        r--;
        ans++;
      }
      else if(g>0 &&((i-1)% 3==0)){
        g--;
        g--;
        ans++;
      }
      else if(b>0 &&((i-2)% 3==0)){
        b--;
        b--;
        ans++;
      }
      else if(r>0 || b>0 || g>0){
        ans++;
      }
    }
    System.out.println(ans);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A90_1000_Cableway_greedy_math_Round74 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ;
    var g : int ;
    var b : int ;
    var ans : int ; ans := 29 ;
    r := sc.getCurrent()->toInteger() ; 
    g := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < 300 do ( (     if (r > 0 & (i mod 3 = 0)) then (     r := r - 1 ; 
     r := r - 1 ; 
     ans := ans + 1 ) else     if (g > 0 & ((i - 1) mod 3 = 0)) then (     g := g - 1 ; 
     g := g - 1 ; 
     ans := ans + 1 ) else     if (b > 0 & ((i - 2) mod 3 = 0)) then (     b := b - 1 ; 
     b := b - 1 ; 
     ans := ans + 1 ) else     if (r > 0 or b > 0 or g > 0) then (     ans := ans + 1 ) else skip ; ;  ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->=1){
      int n=sc.nextInt();
      int[] prices=new int[n];
      for(int i=0 ; i<n ; i++)prices[i]=sc.nextInt();
      int min=prices[n-1];
      int count=0 ;
      for(int i=n-2 ; i>=0 ; i--){
        if(prices[i]>min)count++;
        min=Math.min(prices[i],min);
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t >= 1) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var prices : Sequence(int) ; prices := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     prices[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var min : int ; min := prices[n - 1+1] ;
    var count : int ; count := 0 ;
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (prices[i+1] > min) then     count := count + 1 ; else skip ; 
     min := Set{prices[i+1], min}->min() )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void numOfSubseq(int arr[],int n){
    int i,inc_count,dec_count ;
    int max[]=new int[n];
    int min[]=new int[n];
    int k1=0,k2=0 ;
    if(arr[0]<arr[1])min[k1++]=0 ;
    else max[k2++]=0 ;
    for(i=1 ; i<n-1 ; i++){
      if(arr[i]<arr[i-1] && arr[i]<arr[i+1])min[k1++]=i ;
      if(arr[i]>arr[i-1] && arr[i]>arr[i+1])max[k2++]=i ;
    }
    if(arr[n-1]<arr[n-2])min[k1++]=n-1 ;
    else max[k2++]=n-1 ;
    if(min[0]==0){
      inc_count=k2 ;
      dec_count=k1-1 ;
    }
    else {
      inc_count=k2-1 ;
      dec_count=k1 ;
    }
    System.out.println("Increasing Subsequence"+" Count: "+inc_count);
    System.out.println("Decreasing Subsequence"+" Count: "+dec_count);
  }
  public static void main(String[] args){
    int arr[]={
      12,8,11,13,10,15,14,16,20 };
      int n=arr.length ;
      numOfSubseq(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation numOfSubseq( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var inc_count : int ;
    var dec_count : int ;
     var max : Sequence(int) ; max := Integer.subrange(1,n)->collect(0) ;
    var min : Sequence(int) ; min := Integer.subrange(1,n)->collect(0) ;
    var k1 : int ; k1 := 0 ;
    var k2 : int ; k2 := 0 ;
    if (arr[0+1] < arr[1+1]) then      min[k1+1] := 0  ; k1 := k1 + 1 else      max[k2+1] := 0  ; k2 := k2 + 1 ; ;  
        i := 1 ; while i < n - 1 do ( (     if (arr[i+1] < arr[i - 1+1] & arr[i+1] < arr[i + 1+1]) then      min[k1+1] := i  ; k1 := k1 + 1 ; else skip ; 
     if (arr[i+1] > arr[i - 1+1] & arr[i+1] > arr[i + 1+1]) then      max[k2+1] := i  ; k2 := k2 + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (arr[n - 1+1] < arr[n - 2+1]) then      min[k1+1] := n - 1  ; k1 := k1 + 1 else      max[k2+1] := n - 1  ; k2 := k2 + 1 ; ;  
    if (min[0+1] = 0) then (     inc_count := k2 ; 
     dec_count := k1 - 1 ) else (     inc_count := k2 - 1 ; 
     dec_count := k1 ) ;  
    OclFile["System.out"].println("Increasing Subsequence" + " Count: " + inc_count) ; 
    OclFile["System.out"].println("Decreasing Subsequence" + " Count: " + dec_count) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{12,8,11,13,10,15,14,16,20} ;
     var n : int ; n := arr->size() ;
     execute numOfSubseq(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  static int smallestDivisor(int x){
    if(x % 2==0)return 2 ;
    for(int i=3 ; i*i<=x ; i+=2){
      if(x % i==0)return i ;
    }
    return x ;
  }
  static int smallestInteger(int[] arr,int n){
    int gcd=0 ;
    for(int i=0 ; i<n ; i++)gcd=__gcd(gcd,arr[i]);
    return smallestDivisor(gcd);
  }
  public static void main(String[] args){
    int[] arr={
      2,4,8 };
      int n=arr.length ;
      System.out.println(smallestInteger(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation smallestDivisor( x : int) : int
  pre: true
  post: true
  activity: (     if (x mod 2 = 0) then     return 2 else skip ; 
         var i : int ; i := 3 ; while i * i <= x do ( (     if (x mod i = 0) then     return i else skip )  ;     i := i+(2) ) ; 
     return x );
  static   operation smallestInteger( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var gcd : int ; gcd := 0 ;
         var i : int ; i := 0 ; while i < n do (     gcd := __gcd(gcd, arr[i+1]) ;  ;     i := i + 1 ) ; 
     return smallestDivisor(gcd) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,4,8} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(smallestInteger(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int[] a=new int[105],b=new int[105];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=1 ; i<=n ; ++i){
      a[i]=sc.nextInt();
      b[i]=(b[i-1] ^ a[i]);
    };
    int ans=0 ;
    for(int i=1 ; i<=n ; ++i){
      for(int j=i ; j<=n ; ++j){
        ans=Math.max(ans,b[j] ^ b[i-1]);
      }
    }
    System.out.print(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute a : Sequence(int) := Integer.subrange(1,105)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := (b[i - 1+1] xor a[i+1]) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := i ; while j <= n do ( (     ans := Set{ans, b[j+1] xor b[i - 1+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    String str[]=br.readLine().split(" ");
    int n=Integer.valueOf(str[0]);
    int m=Integer.valueOf(str[1]);
    int arr[][]=new int[n+1][m+1];
    int k=Integer.valueOf(str[2]);
    int r[]=new int[n+1];
    int c[]=new int[m+1];
    for(int i=1 ; i<=n ; i++){
      r[i]=i ;
      str=br.readLine().split(" ");
      for(int ii=1 ; ii<=m ; ii++){
        c[ii]=ii ;
        arr[i][ii]=Integer.valueOf(str[ii-1]);
      }
    }
    for(int i=0 ; i<k ; i++){
      str=br.readLine().split(" ");
      if(str[0] .equals("g")){
        bw.write(arr[r[Integer.valueOf(str[1])] ][c[Integer.valueOf(str[2])] ]+"\n");
      }
      else if(str[0] .equals("c")){
        int c1=Integer.valueOf(str[1]);
        int c2=Integer.valueOf(str[2]);
        int cc=c[c1];
        c[c1]=c[c2];
        c[c2]=cc ;
      }
      else {
        int r1=Integer.valueOf(str[1]);
        int r2=Integer.valueOf(str[2]);
        int y=r[r1];
        r[r1]=r[r2];
        r[r2]=y ;
      }
    }
    bw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var m : int ; m := (str[1+1])->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
    var k : int ; k := (str[2+1])->toInteger() ;
    var r : Sequence(int) ; r := Integer.subrange(1,n + 1)->collect(0) ;
    var c : Sequence(int) ; c := Integer.subrange(1,m + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     r[i+1] := i ; 
     str := br.readLine()->split(" ") ; 
         var ii : int ; ii := 1 ; while ii <= m do ( (     c[ii+1] := ii ; 
     arr[i+1][ii+1] := (str[ii - 1+1])->toInteger() )  ;     ii := ii + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do ( (     str := br.readLine()->split(" ") ; 
     if (str[0+1] = "g") then (     skip ) else     if (str[0+1] = "c") then (     var c1 : int ; c1 := (str[1+1])->toInteger() ;
     var c2 : int ; c2 := (str[2+1])->toInteger() ;
    var cc : int ; cc := c[c1+1] ;
    c[c1+1] := c[c2+1] ; 
    c[c2+1] := cc ; 
 ) else (     var r1 : int ; r1 := (str[1+1])->toInteger() ;
     var r2 : int ; r2 := (str[2+1])->toInteger() ;
    var y : int ; y := r[r1+1] ;
    r[r1+1] := r[r2+1] ; 
    r[r2+1] := y ; 
 ) ;  )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static boolean isPrime(int a[],int lower,int upper){
    int n=0 ;
    for(int i=lower-1 ; i<=upper-1 ; i++)n+=a[i];
    if(n<=1)return false ;
    for(int i=2 ; i<n ; i++)if(n % i==0)return false ;
    return true ;
  }
  public static void main(String[] args){
    int a[]={
      1,2,3,5,5,4,7,8,9 };
      int lower=3,upper=6 ;
      if(isPrime(a,lower,upper))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPrime( a : Sequence(int), lower : int, upper : int) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := 0 ;
         var i : int ; i := lower - 1 ; while i <= upper - 1 do (     n := n+(a[i+1]) ;  ;     i := i + 1 ) ; 
    if (n <= 1) then     return false else skip ; 
        var i : int ; i := 2 ; while i < n do (     if (n mod i = 0) then     return false else skip ;  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,5,5,4,7,8,9} ;
     var lower : int ; lower := 3 ;
    var upper : int ; upper := 6 ;
     if (isPrime(a, lower, upper)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int checkSemiprime(int num){
    int cnt=0 ;
    for(int i=2 ; cnt<2 && i*i<=num ; ++i)while(num % i==0){
      num/=i ;
++cnt ;
    }
    if(num>1)++cnt ;
    return cnt==2 ? 1 : 0 ;
  }
  static void semiprime(int n){
    if(checkSemiprime(n)!=0)System.out.printf("True\n");
    else System.out.printf("False\n");
  }
  public static void main(String[] args){
    int n=6 ;
    semiprime(n);
    n=8 ;
    semiprime(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation checkSemiprime( num : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 2 ; while cnt < 2 & i * i <= num do (     while (num mod i = 0) do (     num := num/(i) ; 
     cnt := cnt + 1 ) ;  ;     i := i + 1 ) ; 
     if (num > 1) then     cnt := cnt + 1 ; else skip ; 
     return if cnt = 2 then 1 else 0 endif );
  static   operation semiprime( n : int) : void
  pre: true
  post: true
  activity: (     if (checkSemiprime(n) /= 0) then     OclFile["System.out"].printf("True\n") ; else     OclFile["System.out"].printf("False\n") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     execute semiprime(n) ; 
     n := 8 ; 
     execute semiprime(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Test {
  static HashSet<String>set ;
  public static long solve(long n){
    long ans=0 ;
    if(n==1)ans=1 ;
    else if(n==2)ans=2 ;
    else if(n==3)ans=6 ;
    else if(n % 2==0){
      if(n % 3==0)ans=(n-1)*(n-2)*(n-3);
      else ans=n*(n-1)*(n-3);
    }
    else ans=n*(n-1)*(n-2);
    return ans ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    System.out.println(solve(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   attribute set : Set(String);
  static   operation solve( n : long) : long
  pre: true
  post: true
  activity: (     var ans : long ; ans := 0 ;
     if (n = 1) then     ans := 1 else     if (n = 2) then     ans := 2 else     if (n = 3) then     ans := 6 else     if (n mod 2 = 0) then (     if (n mod 3 = 0) then     ans := (n - 1) * (n - 2) * (n - 3) ; else     ans := n * (n - 1) * (n - 3) ; ) else     ans := n * (n - 1) * (n - 2) ; ;  ;  ;  ;  
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println(solve(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class lcmChallenge {
  public static long gcd(long a,long b){
    if(b==0)return a ;
    return gcd(b,a % b);
  }
  public static void main(String[] args){
    int n=(new Scanner(System.in)).nextInt();
    long s=Math.max(1,n-20);
    long res=0 ;
    for(long i=s ; i<=n ; i++)for(long j=s ; j<=n ; j++){
      long lcmij=i*j/gcd(i,j);
      for(long k=s ; k<=n ; k++)res=Math.max(res,lcmij*k/gcd(lcmij,k));
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class lcmChallenge {
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := (OclFile.newOclFile_Read(OclFile["System.in"])).nextInt() ;
     var s : long ; s := Set{1, n - 20}->max() ;
    var res : long ; res := 0 ;
        var i : long ; i := s ; while i <= n do (         var j : long ; j := s ; while j <= n do ( (     var lcmij : long ; lcmij := i * j / gcd(i, j) ;
         var k : long ; k := s ; while k <= n do (     res := Set{res, lcmij * k / gcd(lcmij, k)}->max() ;  ;     k := k + 1 ) )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class B {
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    int caseN=cin.nextInt();
    for(int caseI=1 ; caseI<=caseN ; caseI++){
      int n=cin.nextInt();
      BigInteger[] times=new BigInteger[n];
      for(int i=0 ; i<n ; i++)times[i]=new BigInteger(cin.next());
      BigInteger ans=times[0] .subtract(times[1]).abs();
      for(int i=2 ; i<n ; i++)ans=ans.gcd(times[i] .subtract(times[i-1]).abs());
      ans=ans.subtract(times[0] .mod(ans)).mod(ans);
      System.out.printf("Case #%d: %s",caseI,ans.toString());
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var caseN : int ; caseN := cin.getCurrent()->toInteger() ;
         var caseI : int ; caseI := 1 ; while caseI <= caseN do ( (     var n : int ; n := cin.getCurrent()->toInteger() ;
     var times : Sequence(long) ; times := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     times[i+1] := long(cin.getCurrent()) ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := times[0+1].subtract(times[1+1]).abs() ;
        var i : int ; i := 2 ; while i < n do (     ans := ans.gcd(times[i+1].subtract(times[i - 1+1]).abs()) ;  ;     i := i + 1 ) ; 
    ans := ans.subtract(times[0+1].mod(ans)).mod(ans) ; 
    OclFile["System.out"].printf("Case #%d: %s", caseI, ans+"") ; 
    OclFile["System.out"].println() ; 
 )  ;     caseI := caseI + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  BigInteger[] data ;
  BigInteger solve(){
    int N=in.nextInt();
    for(int i=0 ; i<N ; i++)data[i]=in.nextBigInteger();
    Arrays.sort(data,0,N);
    BigInteger g=data[1] .subtract(data[0]);
    for(int i=2 ; i<N ; i++)g=g.gcd(data[i] .subtract(data[i-1]));
    return g.subtract(data[0] .remainder(g)).remainder(g);
  }
  void cases(){
    data=new BigInteger[1000];
    int T=in.nextInt();
    for(int c=1 ; c<=T ; c++)System.out.println("Case #"+c+": "+solve());
  }
  public static void main(String[] args)throws Exception {
(new Main()).cases();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute data : Sequence(long);
   operation solve() : long
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < N do (     data[i+1] := in.nextBigInteger() ;  ;     i := i + 1 ) ; 
    data := data.subrange(1,0)^(data.subrange(0+1,N)->sort())^data.subrange(N+1,data.size) ; 
    var g : long ; g := data[1+1].subtract(data[0+1]) ;
        var i : int ; i := 2 ; while i < N do (     g := g.gcd(data[i+1].subtract(data[i - 1+1])) ;  ;     i := i + 1 ) ; 
    return g.subtract(data[0+1].remainder(g)).remainder(g) 
 );
   operation cases() : void
  pre: true
  post: true
  activity: (     data := Integer.subrange(1,1000)->collect(null) ; 
     var T : int ; T := in.getCurrent()->toInteger() ;
         var c : int ; c := 1 ; while c <= T do (     OclFile["System.out"].println("Case #" + c + ": " + solve()) ;  ;     c := c + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).cases() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public final class Test {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
      int curr=arr[n-1];
      int c=0 ;
      for(int i=n-2 ; i>=0 ; i--){
        if(arr[i]<=curr){
          curr=arr[i];
        }
        else c++;
      }
      System.out.println(c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var curr : int ; curr := arr[n - 1+1] ;
    var c : int ; c := 0 ;
        var i : int ; i := n - 2 ; while i >= 0 do ( (     if (arr[i+1] <= curr) then (     curr := arr[i+1] ) else     c := c + 1 ; )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(c) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  Scanner in ;
  BufferedReader br ;
  PrintWriter out ;
  public void run()throws Exception {
    in=new Scanner(System.in);
    out=new PrintWriter(System.out);
    int tests=in.nextInt();
    for(int test=1 ; test<=tests ; test++){
      TreeSet<BigInteger>hs=new TreeSet<BigInteger>();
      int nnn=in.nextInt();
      for(int i=0 ; i<nnn ; i++)hs.add(in.nextBigInteger());
      int n=hs.size();
      BigInteger[] a=new BigInteger[n];
      nnn=0 ;
      for(BigInteger x : hs)a[nnn++]=x ;
      BigInteger g=a[1] .subtract(a[0]);
      for(int i=0 ; i<n ; i++){
        for(int j=i+1 ; j<n ; j++){
          g=g.gcd(a[j] .subtract(a[i]));
        }
      }
      BigInteger mn=BigInteger.valueOf(10).pow(100);
      BigInteger g1=g.subtract(BigInteger.ONE);
      for(int i=0 ; i<n ; i++){
        BigInteger cur=a[i] .add(g1).divide(g).multiply(g).subtract(a[i]);
        mn=mn.min(cur);
      }
      out.println("Case #"+test+": "+mn);
    }
    out.close();
  }
  public static void main(String[] args)throws Exception {
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile;
   attribute br : OclFile;
   attribute out : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    var tests : int ; tests := in.getCurrent()->toInteger() ;
        var test : int ; test := 1 ; while test <= tests do ( (     var hs : Set(long) ; hs := Set{} ;
     var nnn : int ; nnn := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < nnn do (     hs := hs->including(in.nextBigInteger()) ;  ;     i := i + 1 ) ; 
    var n : int ; n := hs->size() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(null) ;
    nnn := 0 ; 
    for (x : hs) do (      a[nnn+1] := x  ; nnn := nnn + 1 ;  ) ; 
    var g : long ; g := a[1+1].subtract(a[0+1]) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     g := g.gcd(a[j+1].subtract(a[i+1])) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var mn : long ; mn := (10 + "")->toLong().pow(100) ;
    var g1 : long ; g1 := g.subtract(1) ;
        var i : int ; i := 0 ; while i < n do ( (     var cur : long ; cur := a[i+1]->excludes(g1).divide(g).multiply(g).subtract(a[i+1]) ;
     mn := mn->min() )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     test := test + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main implements Runnable {
  static Scanner scanner ;
  static BufferedReader input ;
  static PrintWriter pw ;
  public static void main(String[] args)throws Exception {
    new Thread(new Main()).start();
  }
  public void run(){
    try {
      input=new BufferedReader(new FileReader("input.txt"));
      scanner=new Scanner(input);
      pw=new PrintWriter(new File("output.txt"));
      solve();
      pw.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  public void solve()throws Exception {
    int qq=scanner.nextInt();
    for(int ii=0 ; ii<qq ; ii++){
      int n=scanner.nextInt();
      BigInteger[] a=new BigInteger[n];
      for(int i=0 ; i<n ; i++){
        a[i]=scanner.nextBigInteger();
      }
      BigInteger x=BigInteger.ZERO ;
      for(int i=1 ; i<n ; i++){
        x=x.gcd(a[i] .subtract(a[0]));
      }
      BigInteger ans=(x.subtract(a[0] .mod(x))).mod(x);
      pw.println("Case #"+(ii+1)+": "+ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
  static   attribute scanner : OclFile;
  static   attribute input : OclFile;
  static   attribute pw : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(Main.newMain()).start() );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     scanner := OclFile.newOclFile_Read(input) ; 
    pw := OclFile.newOclFile_Write(OclFile("output.txt")) ; 
    execute solve() ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var qq : int ; qq := scanner.getCurrent()->toInteger() ;
         var ii : int ; ii := 0 ; while ii < qq do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.nextBigInteger() )  ;     i := i + 1 ) ; 
    var x : long ; x := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     x := x.gcd(a[i+1].subtract(a[0+1])) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := (x.subtract(a[0+1].mod(x))).mod(x) ;
    skip ; 
 )  ;     ii := ii + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.io.*;
import java.math.BigInteger ;
public class Main {
  public static BigInteger gcd(BigInteger aa,BigInteger bb){
    BigInteger a=aa,b=bb,c ;
    while(true){
      c=a.mod(b);
      if(c==BigInteger.ZERO)break ;
      a=b ;
      b=c ;
    }
    return b ;
  }
  public static void main(String[] args)throws FileNotFoundException {
    Scanner cin=new Scanner(System.in);
    cin=new Scanner(new File("E:\\Program Files\\WinZip\\Source\\������\\JAVA\\src\\B-large.in"));
    BigInteger[] s ;
    int n,t=cin.nextInt();
    for(int tt=1 ; tt<=t ; ++tt){
      n=cin.nextInt();
      s=new BigInteger[n];
      for(int i=0 ; i<n ; ++i){
        s[i]=cin.nextBigInteger();
      }
      Arrays.sort(s);
      for(int i=1 ; i<n ; ++i){
        s[i]=s[i] .subtract(s[0]);
      }
      BigInteger tmp=s[1],ans ;
      for(int i=2 ; i<n ; ++i){
        if(s[i]==BigInteger.ZERO)continue ;
        tmp=gcd(tmp,s[i]);
      }
      ans=s[0] .mod(tmp);
      System.out.println("Case #"+tt+": "+tmp.subtract(ans).mod(tmp));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( aa : long, bb : long) : long
  pre: true
  post: true
  activity: (     var a : long ; a := aa ;
    var b : long ; b := bb ;
    var c : long ;
     while (true) do (     c := a.mod(b) ; 
     if (c = 0) then     break else skip ; 
     a := b ; 
     b := c ) ; 
     return b );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     cin := OclFile.newOclFile_Read(OclFile("E:\\Program Files\\WinZip\\Source\\??????\\JAVA\\src\\B-large.in")) ; 
    var s : Sequence(long) ;
    var n : int ;
    var t : int ; t := cin.getCurrent()->toInteger() ;
        var tt : int ; tt := 1 ; while tt <= t do ( (     n := cin.getCurrent()->toInteger() ; 
     s := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := cin.nextBigInteger() )  ;     i := i + 1 ) ; 
    s := s->sort() ; 
        var i : int ; i := 1 ; while i < n do ( (     s[i+1] := s[i+1].subtract(s[0+1]) )  ;     i := i + 1 ) ; 
    var tmp : long ; tmp := s[1+1] ;
    var ans : long ;
        var i : int ; i := 2 ; while i < n do ( (     if (s[i+1] = 0) then     continue else skip ; 
     tmp := gcd(tmp, s[i+1]) )  ;     i := i + 1 ) ; 
    ans := s[0+1].mod(tmp) ; 
    OclFile["System.out"].println("Case #" + tt + ": " + tmp.subtract(ans).mod(tmp)) ; 
 )  ;     tt := tt + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class DivisibleParts {
  static void printTwoDivisibleParts(String num,int f,int s){
    int N=num.length();
    int[] prefixReminder=new int[N+1];
    int[] suffixReminder=new int[N+1];
    suffixReminder[0]=0 ;
    for(int i=1 ; i<N ; i++)suffixReminder[i]=(suffixReminder[i-1]*10+(num.charAt(i-1)-'0'))% f ;
    prefixReminder[N]=0 ;
    int base=1 ;
    for(int i=N-1 ; i>=0 ; i--){
      prefixReminder[i]=(prefixReminder[i+1]+(num.charAt(i)-'0')*base)% s ;
      base=(base*10)% s ;
    }
    for(int i=0 ; i<N ; i++){
      if(prefixReminder[i]==0 && suffixReminder[i]==0 && num.charAt(i)!='0'){
        System.out.println(num.substring(0,i)+" "+num.substring(i));
        return ;
      }
    }
    System.out.println("Not Possible");
  }
  public static void main(String[] args){
    String num="246904096" ;
    int f=12345 ;
    int s=1024 ;
    printTwoDivisibleParts(num,f,s);
  }
}
------------------------------------------------------------
OCL File:
---------
class DivisibleParts {
  static   operation printTwoDivisibleParts( num : String, f : int, s : int) : void
  pre: true
  post: true
  activity: (     var N : int ; N := num->size() ;
     var prefixReminder : Sequence(int) ; prefixReminder := Integer.subrange(1,N + 1)->collect(0) ;
    var suffixReminder : Sequence(int) ; suffixReminder := Integer.subrange(1,N + 1)->collect(0) ;
    suffixReminder[0+1] := 0 ; 
        var i : int ; i := 1 ; while i < N do (     suffixReminder[i+1] := (suffixReminder[i - 1+1] * 10 + (num->at(i - 1+1) - ('0')->char2byte())) mod f ;  ;     i := i + 1 ) ; 
    prefixReminder[N+1] := 0 ; 
    var base : int ; base := 1 ;
        var i : int ; i := N - 1 ; while i >= 0 do ( (     prefixReminder[i+1] := (prefixReminder[i + 1+1] + (num->at(i+1) - ('0')->char2byte()) * base) mod s ; 
     base := (base * 10) mod s )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (prefixReminder[i+1] = 0 & suffixReminder[i+1] = 0 & num->at(i+1) /= '0') then (     OclFile["System.out"].println(num.subrange(0+1,i) + " " + num.subrange(i+1,i)) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Not Possible") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : String ; num := "246904096" ;
     var f : int ; f := 12345 ;
     var s : int ; s := 1024 ;
     execute printTwoDivisibleParts(num, f, s) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    int c=Integer.parseInt(sc.next());
    int d=Integer.parseInt(sc.next());
    sc.close();
    int result=Math.max(a*b,c*d);
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := (sc.getCurrent())->toInteger() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    var c : int ; c := (sc.getCurrent())->toInteger() ;
    var d : int ; d := (sc.getCurrent())->toInteger() ;
    skip ; 
    var result : int ; result := Set{a * b, c * d}->max() ;
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] ss0=br.readLine().trim().split(" ",0);
    int a=Integer.parseInt(ss0[0]);
    int b=Integer.parseInt(ss0[1]);
    int c=Integer.parseInt(ss0[2]);
    int d=Integer.parseInt(ss0[3]);
    System.out.println(((a*b)>(c*d))?(a*b):(c*d));
    return ;
  }
  static void dp(String s){
    System.out.println(s);
  }
  static void dp(StringBuilder s){
    dp(s.toString());
  }
  static void dp(int i){
    dp(String.valueOf(i));
  }
  static void dp(long i){
    dp(String.valueOf(i));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var ss0 : Sequence(String) ; ss0 := br.readLine()->trim()->split(" ") ;
    var a : int ; a := (ss0[0+1])->toInteger() ;
    var b : int ; b := (ss0[1+1])->toInteger() ;
    var c : int ; c := (ss0[2+1])->toInteger() ;
    var d : int ; d := (ss0[3+1])->toInteger() ;
    OclFile["System.out"].println(if ((a * b) > (c * d)) then (a * b) else (c * d) endif) ; 
    return 
 );
  static   operation dp( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation dp( s : String) : void
  pre: true
  post: true
  activity: (     execute dp(s+"") );
  static   operation dp( i : int) : void
  pre: true
  post: true
  activity: (     execute dp(((i) + "")) );
  static   operation dp( i : long) : void
  pre: true
  post: true
  activity: (     execute dp(((i) + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner s=new Scanner(System.in);
  public static void main(String[] args){
    System.out.println(Math.max(s.nextInt()*s.nextInt(),s.nextInt()*s.nextInt()));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(Set{s.getCurrent()->toInteger() * s.getCurrent()->toInteger(), s.getCurrent()->toInteger() * s.getCurrent()->toInteger()}->max()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner scanner=new Scanner(System.in);
    String inputString=scanner.nextLine();
    String[] strStdIn=inputString.split(" ",0);
    int firstVertical=Integer.parseInt(strStdIn[0]);
    int firstHorizon=Integer.parseInt(strStdIn[1]);
    int secondVertical=Integer.parseInt(strStdIn[2]);
    int secondHorizon=Integer.parseInt(strStdIn[3]);
    if((firstVertical*firstHorizon)>=(secondVertical*secondHorizon)){
      System.out.println((firstVertical*firstHorizon));
    }
    else {
      System.out.println((secondVertical*secondHorizon));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inputString : String ; inputString := scanner.nextLine() ;
    var strStdIn : Sequence(String) ; strStdIn := inputString->split(" ") ;
    var firstVertical : int ; firstVertical := (strStdIn[0+1])->toInteger() ;
    var firstHorizon : int ; firstHorizon := (strStdIn[1+1])->toInteger() ;
    var secondVertical : int ; secondVertical := (strStdIn[2+1])->toInteger() ;
    var secondHorizon : int ; secondHorizon := (strStdIn[3+1])->toInteger() ;
    if ((firstVertical * firstHorizon) >= (secondVertical * secondHorizon)) then (     OclFile["System.out"].println((firstVertical * firstHorizon)) ) else (     OclFile["System.out"].println((secondVertical * secondHorizon)) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s=br.readLine();
    String[] line=s.split(" ");
    int a=Integer.parseInt(line[0]);
    int b=Integer.parseInt(line[1]);
    int c=Integer.parseInt(line[2]);
    int d=Integer.parseInt(line[3]);
    int s1=a*b ;
    int s2=c*d ;
    if(s1==s2){
      System.out.println(s1);
    }
    else if(s1>s2){
      System.out.println(s1);
    }
    else {
      System.out.println(s2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : String ; s := br.readLine() ;
    var line : Sequence(String) ; line := s->split(" ") ;
    var a : int ; a := (line[0+1])->toInteger() ;
    var b : int ; b := (line[1+1])->toInteger() ;
    var c : int ; c := (line[2+1])->toInteger() ;
    var d : int ; d := (line[3+1])->toInteger() ;
    var s1 : int ; s1 := a * b ;
    var s2 : int ; s2 := c * d ;
    if (s1 = s2) then (     OclFile["System.out"].println(s1) ) else     if (s1 > s2) then (     OclFile["System.out"].println(s1) ) else (     OclFile["System.out"].println(s2) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CP19 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt(),m=in.nextInt(),res=-1 ;
    if(n<m){
      res=-1 ;
    }
    else {
      if(n % 2==0){
        res=n/2 ;
      }
      else {
        res=n/2+1 ;
      }
      while(res % m!=0){
        res++;
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CP19 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var res : int ; res := -1 ;
     if (n < m) then (     res := -1 ) else (     if (n mod 2 = 0) then (     res := n / 2 ) else (     res := n / 2 + 1 ) ;  
     while (res mod m /= 0) do (     res := res + 1 ) ) ;  
     OclFile["System.out"].println(res) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public final class p187 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p187().run());
  }
  private static final int LIMIT=Library.pow(10,8)-1 ;
  public String run(){
    int count=0 ;
    int[] primes=Library.listPrimes(LIMIT/2);
    for(int i=0,sqrt=Library.sqrt(LIMIT); i<primes.length && primes[i]<=sqrt ; i++){
      int end=Arrays.binarySearch(primes,LIMIT/primes[i]);
      if(end>=0)end++;
      else end=-end-1 ;
      count+=end-i ;
    }
    return Integer.toString(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class p187 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p187.newp187().run()) );
  static    attribute LIMIT : int := Library.pow(10, 8) - 1;
   operation run() : String
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var primes : Sequence(int) ; primes := Library.listPrimes(LIMIT / 2) ;
         var i : int ; i := 0 ;
    var sqrt : int ; sqrt := Library.sqrt(LIMIT) ; while i < primes->size() & primes[i+1] <= sqrt do ( (     var end : int ; end := (primes->indexOf(LIMIT / primes[i+1]) - 1) ;
     if (end >= 0) then     end := end + 1 else     end := -end - 1 ; ;  
     count := count+(end - i) )  ;     i := i + 1 ) ; 
     return ((count) + "") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    System.out.println(fun(n,m));
  }
  static int fun(int n,int m){
    int res=0 ;
    int p ;
    if(n % 2!=0){
      p=n/2 ;
      p++;
    }
    else {
      p=n/2 ;
    }
    for(int i=p ; i<=n ; i++){
      if(i % m==0){
        res=i ;
        break ;
      }
    }
    return res>0 ? res :-1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(fun(n, m)) );
  static   operation fun( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     var p : int ;
    if (n mod 2 /= 0) then (     p := n / 2 ; 
     p := p + 1 ) else (     p := n / 2 ) ;  
        var i : int ; i := p ; while i <= n do ( (     if (i mod m = 0) then (     res := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    return if res > 0 then res else -1 endif 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int x=0 ;
    if(n % 2==0)x=n/2 ;
    else x=n/2+1 ;
    while(x<=n){
      if(x % m==0){
        System.out.print(x);
        System.exit(0);
      }
      x++;
    }
    System.out.print(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : int ; x := 0 ;
    if (n mod 2 = 0) then     x := n / 2 else     x := n / 2 + 1 ; ;  
    while (x <= n) do (     if (x mod m = 0) then (     OclFile["System.out"].print(x) ; 
 OclProcess.exit(0) ) else skip ; 
     x := x + 1 ) ; 
    OclFile["System.out"].print(-1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Scanner ;
public class dreamoonAndStairs1000 {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int res=0 ;
    if(m>n)System.out.println("-1");
    else {
      if(n % 2==0)res=n/2 ;
      else res=n/2+1 ;
      while(res % m!=0)res++;
      System.out.println(res);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class dreamoonAndStairs1000 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
    if (m > n) then     OclFile["System.out"].println("-1") else (     if (n mod 2 = 0) then     res := n / 2 else     res := n / 2 + 1 ; ;  
     while (res mod m /= 0) do     res := res + 1 ; ; 
     OclFile["System.out"].println(res) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class DreamoonStairs {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    int res=0 ;
    if(m>n){
      res=-1 ;
    }
    else {
      if(n % 2!=0){
        res=n/2+1 ;
      }
      else {
        res=n/2 ;
      }
      while(res % m>0){
        res++;
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class DreamoonStairs {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var res : int ; res := 0 ;
    if (m > n) then (     res := -1 ) else (     if (n mod 2 /= 0) then (     res := n / 2 + 1 ) else (     res := n / 2 ) ;  
     while (res mod m > 0) do (     res := res + 1 ) ) ;  
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class C {
  public static void main(String...orange)throws Exception {
    Scanner input=new Scanner(System.in);
    int numCases=input.nextInt();
    for(int n=0 ; n<numCases ; n++){
      int N=input.nextInt();
      PriorityQueue<Hiker>hikers=new PriorityQueue<Hiker>();
      for(int i=0 ; i<N ; i++){
        int D=input.nextInt();
        int H=input.nextInt();
        int M=input.nextInt();
        for(int j=0 ; j<H ; j++)hikers.add(new Hiker(D,M+j));
      }
      long minEncounters=Long.MAX_VALUE ;
      int numHikers=hikers.size();
      int numEncounters=0 ;
      int numPassed=0 ;
      for(int i=0 ; i<3*numHikers ; i++){
        Hiker next=hikers.poll();
        if(next.passed)numEncounters++;
        else numPassed++;
        next.passed=true ;
        next.cross+=360L*next.M ;
        hikers.add(next);
        if(numEncounters+numHikers-numPassed<minEncounters)minEncounters=numEncounters+numHikers-numPassed ;
      }
      System.out.printf("Case #%d: ",n+1);
      System.out.println(minEncounters);
    }
  }
  static class Hiker implements Comparable<Hiker>{
    int D ;
    int M ;
    long cross ;
    boolean passed ;
    Hiker(int D,int M){
      this.D=D ;
      this.M=M ;
      this.cross=(360L-D)*M ;
      this.passed=false ;
    }
    public int compareTo(Hiker other){
      if(cross>other.cross)return 1 ;
      else if(cross<other.cross)return-1 ;
      else if(passed && ! other.passed)return-1 ;
      else if(! passed && other.passed)return 1 ;
      return 0 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( orange : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numCases : int ; numCases := input.getCurrent()->toInteger() ;
         var n : int ; n := 0 ; while n < numCases do ( (     var N : int ; N := input.getCurrent()->toInteger() ;
     var hikers : Sequence(Hiker) ; hikers := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var D : int ; D := input.getCurrent()->toInteger() ;
     var H : int ; H := input.getCurrent()->toInteger() ;
     var M : int ; M := input.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < H do (     hikers := hikers->including(Hiker.newHiker(D, M + j)) ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var minEncounters : long ; minEncounters := "9223372036854775807"->toLong() ;
    var numHikers : int ; numHikers := hikers->size() ;
    var numEncounters : int ; numEncounters := 0 ;
    var numPassed : int ; numPassed := 0 ;
        var i : int ; i := 0 ; while i < 3 * numHikers do ( (     var next : Hiker ; next := hikers->min() ;
     if (next.passed) then     numEncounters := numEncounters + 1 else     numPassed := numPassed + 1 ; ;  
    next.passed := true ; 
    next.cross := next.cross+(360L * next.M) ; 
    hikers := hikers->including(next) ; 
    if (numEncounters + numHikers - numPassed < minEncounters) then     minEncounters := numEncounters + numHikers - numPassed ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("Case #%d: ", n + 1) ; 
    OclFile["System.out"].println(minEncounters) ; 
 )  ;     n := n + 1 ) );
  static class Hiker implements Comparable<Hiker> {
   attribute D : int;
   attribute M : int;
   attribute cross : long;
   attribute passed : boolean;
   static operation newHiker( D : int, M : int) : Hiker
  pre: true
  post: true
  activity:
  ( var self : Hiker ;
    self := createHiker();
    self.initialise(D, M);
    return self );
  operation initialise( D : int, M : int) : void
  pre: true  post: true
  activity: (     self.D := D ; 
     self.M := M ; 
     self.cross := (360L - D) * M ; 
     self.passed := false );
   operation compareTo( other : Hiker) : int
  pre: true
  post: true
  activity: (     if (cross > other.cross) then     return 1 else     if (cross < other.cross) then     return -1 else     if (passed & not(other.passed)) then     return -1 else     if (not(passed) & other.passed) then     return 1 else skip ; ;  ;  ;  
     return 0 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Count {
  public static int countSetBits(int n){
    int count=0 ;
    while(n!=0){
      count++;
      n &=(n-1);
    }
    return count ;
  }
  public static int FlippedCount(int a,int b){
    return countSetBits(a ^ b);
  }
  public static void main(String[] args){
    int a=10 ;
    int b=20 ;
    System.out.print(FlippedCount(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Count {
  static   operation countSetBits( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (n /= 0) do (     count := count + 1 ; 
     n := MathLib.bitwiseAnd(n, (n - 1)) ) ; 
     return count );
  static   operation FlippedCount( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return countSetBits(a xor b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 10 ;
     var b : int ; b := 20 ;
     OclFile["System.out"].print(FlippedCount(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int remainder(String str){
    int len=str.length();
    int num,rem=0 ;
    for(int i=0 ; i<len ; i++){
      num=rem*10+(str.charAt(i)-'0');
      rem=num % 11 ;
    }
    return rem ;
  }
  public static void main(String args[]){
    String str="3435346456547566345436457867978" ;
    System.out.println(remainder(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation remainder( str : String) : int
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     var num : int ;
    var rem : int ; rem := 0 ;
         var i : int ; i := 0 ; while i < len do ( (     num := rem * 10 + (str->at(i+1) - ('0')->char2byte()) ; 
     rem := num mod 11 )  ;     i := i + 1 ) ; 
     return rem );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "3435346456547566345436457867978" ;
     OclFile["System.out"].println(remainder(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigDecimal ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int N=parseInt(br.readLine());
    int[] a=new int[N];
    StringTokenizer st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<N ; i++)a[i]=parseInt(st.nextToken());
    Arrays.sort(a);
    double max=0.0 ;
    BigDecimal AB,CD ;
    for(int i=0 ; i<N-3 ; i++){
      AB=BigDecimal.valueOf(a[N-1]+a[N-2]);
      CD=BigDecimal.valueOf(a[i+1]-a[i]);
      max=Math.max(max,AB.divide(CD,7,BigDecimal.ROUND_HALF_UP).doubleValue());
    }
    AB=BigDecimal.valueOf(a[N-1]+a[N-4]);
    CD=BigDecimal.valueOf(a[N-2]-a[N-3]);
    max=Math.max(max,AB.divide(CD,7,BigDecimal.ROUND_HALF_UP).doubleValue());
    AB=BigDecimal.valueOf(a[N-3]+a[N-4]);
    CD=BigDecimal.valueOf(a[N-1]-a[N-2]);
    max=Math.max(max,AB.divide(CD,7,BigDecimal.ROUND_HALF_UP).doubleValue());
    System.out.format("%.6f%n",max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var N : int ; N := parseInt(br.readLine()) ;
    var a : Sequence(int) ; a := Integer.subrange(1,N)->collect(0) ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
        var i : int ; i := 0 ; while i < N do (     a[i+1] := (st.next() + "")->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var max : double ; max := 0.0 ;
    var AB : double ;
    var CD : double ;
        var i : int ; i := 0 ; while i < N - 3 do ( (     AB := (a[N - 1+1] + a[N - 2+1] + "")->toReal() ; 
     CD := (a[i + 1+1] - a[i+1] + "")->toReal() ; 
     max := Set{max, AB.divide(CD, 7, ROUND_HALF_UP)->oclAsType(double)}->max() )  ;     i := i + 1 ) ; 
    AB := (a[N - 1+1] + a[N - 4+1] + "")->toReal() ; 
    CD := (a[N - 2+1] - a[N - 3+1] + "")->toReal() ; 
    max := Set{max, AB.divide(CD, 7, ROUND_HALF_UP)->oclAsType(double)}->max() ; 
    AB := (a[N - 3+1] + a[N - 4+1] + "")->toReal() ; 
    CD := (a[N - 1+1] - a[N - 2+1] + "")->toReal() ; 
    max := Set{max, AB.divide(CD, 7, ROUND_HALF_UP)->oclAsType(double)}->max() ; 
    OclFile["System.out"].format("%.6f%n", max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
import java.math.BigDecimal ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    BigDecimal tmp=BigDecimal.ZERO ;
    int i,j,a,b ;
    BigDecimal meu,rinrin,hoga ;
    BigDecimal[] array=new BigDecimal[n];
    BigDecimal[] fuga=new BigDecimal[n];
    for(i=0 ; i<n ; ++i){
      array[i]=BigDecimal.valueOf(sc.nextInt());
    }
    Arrays.sort(array);
    for(i=0 ; i<n ; ++i){
      meu=array[i];
      for(j=0 ; j<n ; ++j){
        if(j!=i){
          if((i==n-1 && j==n-2)||(j==n-2 && i==n-1)){
            a=2 ;
          }
          else if(i==n-1 || j==n-1 || i==n-2 || j==n-2){
            a=1 ;
          }
          else {
            a=0 ;
          }
          rinrin=array[j];
          fuga=array.clone();
          fuga[j]=BigDecimal.ZERO ;
          fuga[i]=BigDecimal.ZERO ;
          hoga=fuga[n-1-a] .add(fuga[n-2-a]).divide(meu.subtract(rinrin).abs(),8,BigDecimal.ROUND_HALF_UP);
          if(tmp.compareTo(hoga)<0)tmp=hoga ;
        }
      }
    }
    System.out.println(tmp);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var tmp : double ; tmp := 0.0 ;
    var i : int ;
    var j : int ;
    var a : int ;
    var b : int ;
    var meu : double ;
    var rinrin : double ;
    var hoga : double ;
    var array : Sequence(double) ; array := Integer.subrange(1,n)->collect(null) ;
    var fuga : Sequence(double) ; fuga := Integer.subrange(1,n)->collect(null) ;
        i := 0 ; while i < n do ( (     array[i+1] := (sc.getCurrent()->toInteger() + "")->toReal() )  ;     i := i + 1 ) ; 
    array := array->sort() ; 
        i := 0 ; while i < n do ( (     meu := array[i+1] ; 
         j := 0 ; while j < n do ( (     if (j /= i) then (     if ((i = n - 1 & j = n - 2) or (j = n - 2 & i = n - 1)) then (     a := 2 ) else     if (i = n - 1 or j = n - 1 or i = n - 2 or j = n - 2) then (     a := 1 ) else (     a := 0 ) ;  ;  
     rinrin := array[j+1] ; 
    fuga := array->copy() ; 
    fuga[j+1] := 0.0 ; 
    fuga[i+1] := 0.0 ; 
    hoga := fuga[n - 1 - a+1]->excludes(fuga[n - 2 - a+1]).divide(meu.subtract(rinrin).abs(), 8, ROUND_HALF_UP) ; 
    if (tmp->compareTo(hoga) < 0) then     tmp := hoga ; else skip ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(tmp) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    double ans=0.0 ;
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Double>x=new LinkedList<>();
    for(int i=0 ; i<n ; ++i){
      x.add(sc.nextDouble());
    }
    double max=Double.MIN_VALUE ;
    Collections.sort(x);
    for(int i=0 ; i<n-1 ; ++i){
      double res=0.0 ;
      int c=i+1 ;
      int a=n-1 ;
      int b=n-2 ;
      if(i==n-3){
        b=i-1 ;
      }
      else if(i==n-2){
        a=i-1 ;
        b=i-2 ;
      }
      res=(x.get(a)+x.get(b))/(x.get(c)-x.get(i));
      if(max<res){
        max=res ;
      }
    }
    System.out.println(String.format("%.7f",max));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ans : double ; ans := 0.0 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : Sequence(double) ; x := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     x := x->including(sc.getCurrent()->toReal()) )  ;     i := i + 1 ) ; 
    var max : double ; max := 2->pow(-1074) ;
    x := x->sort() ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var res : double ; res := 0.0 ;
     var c : int ; c := i + 1 ;
    var a : int ; a := n - 1 ;
    var b : int ; b := n - 2 ;
    if (i = n - 3) then (     b := i - 1 ) else     if (i = n - 2) then (     a := i - 1 ; 
     b := i - 2 ) else skip ; ;  
    res := (x->at(a+1) + x->at(b+1)) / (x->at(c+1) - x->at(i+1)) ; 
    if (max < res) then (     max := res ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(StringLib.format("%.7f",Sequence{max})) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] a=new long[n];
    long cd,ab ;
    double result ;
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
    }
    Arrays.sort(a);
    result=(double)(a[n-1]+a[n-2])/(double)(a[1]-a[0]);
    for(int i=1 ; i<n-1 ; i++){
      if(i+1==n-1){
        cd=a[n-1]-a[n-2];
        ab=a[n-3]+a[n-4];
      }
      else if(i+1==n-2){
        cd=a[n-2]-a[n-3];
        ab=a[n-1]+a[n-4];
      }
      else {
        cd=a[i+1]-a[i];
        ab=a[n-1]+a[n-2];
      }
      result=Math.max(result,(double)ab/(double)cd);
    }
    System.out.printf("%.6f\n",result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var cd : long ;
    var ab : long ;
    var result : double ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    result := (a[n - 1+1] + a[n - 2+1])->oclAsType(double) / (a[1+1] - a[0+1])->oclAsType(double) ; 
        var i : int ; i := 1 ; while i < n - 1 do ( (     if (i + 1 = n - 1) then (     cd := a[n - 1+1] - a[n - 2+1] ; 
     ab := a[n - 3+1] + a[n - 4+1] ) else     if (i + 1 = n - 2) then (     cd := a[n - 2+1] - a[n - 3+1] ; 
     ab := a[n - 1+1] + a[n - 4+1] ) else (     cd := a[i + 1+1] - a[i+1] ; 
     ab := a[n - 1+1] + a[n - 2+1] ) ;  ;  
     result := Set{result, ab->oclAsType(double) / cd->oclAsType(double)}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%.6f\n", result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.Scanner ;
public class Main {
  static Integer[] l ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    l=new Integer[n];
    for(int i=0 ; i<n ; i++){
      l[i]=sc.nextInt();
    }
    Arrays.sort(l,Comparator.reverseOrder());
    double max=Math.max(f(2,3,0,1),f(0,3,1,2));
    for(int i=2 ; i<n-1 ; i++){
      max=Math.max(max,f(0,1,i,i+1));
    }
    System.out.printf("%5f",max);
  }
  static double f(int a,int b,int c,int d){
    return(double)(l[a]+l[b])/(double)(l[c]-l[d]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute l : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    l := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do ( (     l[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    l := OclComparator.sortWith(l, Comparator.reverseOrder()) ; 
    var max : double ; max := Set{f(2, 3, 0, 1), f(0, 3, 1, 2)}->max() ;
        var i : int ; i := 2 ; while i < n - 1 do ( (     max := Set{max, f(0, 1, i, i + 1)}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%5f", max) ; 
 );
  static   operation f( a : int, b : int, c : int, d : int) : double
  pre: true
  post: true
  activity: (     return (l[a+1] + l[b+1])->oclAsType(double) / (l[c+1] - l[d+1])->oclAsType(double) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isAnagram(String s1,String s2){
    s1=sortString(s1);
    s2=sortString(s2);
    return(s1.equals(s2));
  }
  public static String sortString(String inputString){
    char tempArray[]=inputString.toCharArray();
    Arrays.sort(tempArray);
    return new String(tempArray);
  }
  static int CountSteps(char[] s1,char[] s2,int size){
    int i=0,j=0 ;
    int result=0 ;
    while(i<size){
      j=i ;
      while(s1[j]!=s2[i]){
        j+=1 ;
      }
      while(i<j){
        char temp=s1[j];
        s1[j]=s1[j-1];
        s1[j-1]=temp ;
        j-=1 ;
        result+=1 ;
      }
      i+=1 ;
    }
    return result ;
  }
  public static void main(String[] args){
    String s1="abcd" ;
    String s2="cdab" ;
    int size=s2.length();
    if(isAnagram(s1,s2))System.out.println(CountSteps(s1.toCharArray(),s2.toCharArray(),size));
    else System.out.println(-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isAnagram( s1 : String, s2 : String) : boolean
  pre: true
  post: true
  activity: (     s1 := sortString(s1) ; 
     s2 := sortString(s2) ; 
     return (s1 = s2) );
  static   operation sortString( inputString : String) : String
  pre: true
  post: true
  activity: (     var tempArray : Sequence(String) ; tempArray := inputString->characters() ;
     tempArray := tempArray->sort() ; 
     return StringLib.newString(tempArray) );
  static   operation CountSteps( s1 : Sequence(String), s2 : Sequence(String), size : int) : int
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var j : int ; j := 0 ;
     var result : int ; result := 0 ;
     while (i < size) do (     j := i ; 
     while (s1[j+1] /= s2[i+1]) do (     j := j+(1) ) ; 
     while (i < j) do (     var temp : String ; temp := s1[j+1] ;
     s1[j+1] := s1[(j)->char2byte() - 1+1] ; 
    s1[(j)->char2byte() - 1+1] := temp ; 
    j := j-(1) ; 
    result := result+(1) ; 
 ) ; 
     i := i+(1) ) ; 
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "abcd" ;
     var s2 : String ; s2 := "cdab" ;
     var size : int ; size := s2->size() ;
     if (isAnagram(s1, s2)) then     OclFile["System.out"].println(CountSteps(s1->characters(), s2->characters(), size)) ; else     OclFile["System.out"].println(-1) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPossible(int[] arr,int n,int C,int mid){
    int magnet=1,currPosition=arr[0];
    for(int i=1 ; i<n ; i++){
      if(arr[i]-currPosition>=mid){
        magnet++;
        currPosition=arr[i];
        if(magnet==C)return true ;
      }
    }
    return false ;
  }
  static int binarySearch(int n,int C,int[] arr){
    int lo,hi,mid,ans ;
    Arrays.sort(arr);
    lo=0 ;
    hi=arr[n-1];
    ans=0 ;
    while(lo<=hi){
      mid=(lo+hi)/2 ;
      if(! isPossible(arr,n,C,mid))hi=mid-1 ;
      else {
        ans=Math.max(ans,mid);
        lo=mid+1 ;
      }
    }
    return ans ;
  }
  public static void main(String args[]){
    int C=4 ;
    int[] arr={
      1,2,5,8,10,18 };
      int n=arr.length ;
      System.out.println(binarySearch(n,C,arr));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPossible( arr : Sequence(int), n : int, C : int, mid : int) : boolean
  pre: true
  post: true
  activity: (     var magnet : int ; magnet := 1 ;
    var currPosition : int ; currPosition := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] - currPosition >= mid) then (     magnet := magnet + 1 ; 
     currPosition := arr[i+1] ; 
     if (magnet = C) then     return true else skip ) else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation binarySearch( n : int, C : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var lo : int ;
    var hi : int ;
    var mid : int ;
    var ans : int ;
     arr := arr->sort() ; 
    lo := 0 ; 
    hi := arr[n - 1+1] ; 
    ans := 0 ; 
    while (lo <= hi) do (     mid := (lo + hi) / 2 ; 
     if (not(isPossible(arr, n, C, mid))) then     hi := mid - 1 ; else (     ans := Set{ans, mid}->max() ; 
     lo := mid + 1 ) ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var C : int ; C := 4 ;
     var arr : Sequence(int) ; arr := Sequence{1,2,5,8,10,18} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(binarySearch(n, C, arr)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static boolean findParity(int x){
    int y=x ^(x>>1);
    y=y ^(y>>2);
    y=y ^(y>>4);
    y=y ^(y>>8);
    y=y ^(y>>16);
    if((y & 1)>0)return true ;
    return false ;
  }
  public static void main(String[] args){
    if((findParity(9)==false))System.out.println("Even Parity");
    else System.out.println("Odd Parity");
    if(findParity(13)==false)System.out.println("Even Parity");
    else System.out.println("Odd Parity");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findParity( x : int) : boolean
  pre: true
  post: true
  activity: (     var y : int ; y := MathLib.bitwiseXor(x,((x/(2->pow(1)))->oclAsType(long))) ;
     y := MathLib.bitwiseXor(y,((y/(2->pow(2)))->oclAsType(long))) ; 
    y := MathLib.bitwiseXor(y,((y/(2->pow(4)))->oclAsType(long))) ; 
    y := MathLib.bitwiseXor(y,((y/(2->pow(8)))->oclAsType(long))) ; 
    y := MathLib.bitwiseXor(y,((y/(2->pow(16)))->oclAsType(long))) ; 
    if ((MathLib.bitwiseAnd(y,1)) > 0) then     return true else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if ((findParity(9) = false)) then     OclFile["System.out"].println("Even Parity") else     OclFile["System.out"].println("Odd Parity") ; ;  
     if (findParity(13) = false) then     OclFile["System.out"].println("Even Parity") ; else     OclFile["System.out"].println("Odd Parity") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double n1=sc.nextInt();
    double n2=sc.nextInt();
    double big=Math.max(n1,n2);
    double small=Math.min(n1,n2);
    double ans ;
    if(big-small>=180){
      ans=(big-360+small)/2 ;
      if(ans<0){
        ans+=360 ;
      }
    }
    else {
      ans=(big+small)/2 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n1 : double ; n1 := sc.getCurrent()->toInteger() ;
    var n2 : double ; n2 := sc.getCurrent()->toInteger() ;
    var big : double ; big := Set{n1, n2}->max() ;
    var small : double ; small := Set{n1, n2}->min() ;
    var ans : double ;
    if (big - small >= 180) then (     ans := (big - 360 + small) / 2 ; 
     if (ans < 0) then (     ans := ans+(360) ) else skip ) else (     ans := (big + small) / 2 ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int[] number=new int[200000+100];
    int n=input.nextInt();
    for(int i=0 ; i<n ; i++){
      number[i]=input.nextInt();
    }
    int ans=0,sum=1 ;
    for(int i=0 ; i<n-1 ; i++){
      if(number[i]*2>=number[i+1]){
        sum++;
      }
      else {
        ans=Math.max(ans,sum);
        sum=1 ;
      }
    }
    ans=Math.max(ans,sum);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var number : Sequence(int) ; number := Integer.subrange(1,200000 + 100)->collect(0) ;
    var n : int ; n := input.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     number[i+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var sum : int ; sum := 1 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (number[i+1] * 2 >= number[i + 1+1]) then (     sum := sum + 1 ) else (     ans := Set{ans, sum}->max() ; 
     sum := 1 ) )  ;     i := i + 1 ) ; 
    ans := Set{ans, sum}->max() ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int maxArea(int[] height){
    int maxArea=0 ;
    int left=0 ;
    int right=height.length-1 ;
    while(left<right){
      maxArea=Math.max(maxArea,(right-left)*Math.min(height[left],height[right]));
      if(height[left]<height[right])left++;
      else right--;
    }
    return maxArea ;
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation maxArea( height : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var maxArea : int ; maxArea := 0 ;
     var left : int ; left := 0 ;
    var right : int ; right := height->size() - 1 ;
    while (left < right) do (     maxArea := Set{maxArea, (right - left) * Set{height[left+1], height[right+1]}->min()}->max() ; 
     if (height[left+1] < height[right+1]) then     left := left + 1 ; else     right := right - 1 ; ) ; 
    return maxArea 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static long maxProd(int arr[],int n,int k){
    long product=1 ;
    HashMap<Integer,Integer>s=new HashMap<Integer,Integer>();
    Arrays.sort(arr);
    for(int i=0 ; i<n ; i++){
      if(s.containsKey(arr[i])==false){
        product=product*arr[i];
        s.put(arr[i],1);
      }
      else s.put(arr[i],s.get(arr[i])+1);
    }
    for(int j=n-1 ; j>=0 && k>0 ; j--){
      if((k>(s.get(arr[j])-1))&&((s.get(arr[j])-1)>0)){
        product*=Math.pow(arr[j],s.get(arr[j])-1);
        k=k-s.get(arr[j])+1 ;
        s.put(arr[j],0);
      }
      if(k<=(s.get(arr[j])-1)&&((s.get(arr[j])-1)>0)){
        product*=Math.pow(arr[j],k);
        break ;
      }
    }
    return product ;
  }
  public static void main(String[] args){
    int arr[]={
      5,6,7,8,2,5,6,8 };
      int n=arr.length ;
      int k=2 ;
      System.out.println(maxProd(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxProd( arr : Sequence(int), n : int, k : int) : long
  pre: true
  post: true
  activity: (     var product : long ; product := 1 ;
     var s : Map(int,int) ; s := Map{} ;
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (s->keys()->includes(arr[i+1]) = false) then (     product := product * arr[i+1] ; 
     s := s->union(Map{arr[i+1] |-> 1}) ) else     s := s->union(Map{arr[i+1] |-> s->at(arr[i+1]) + 1}) ; )  ;     i := i + 1 ) ; 
        var j : int ; j := n - 1 ; while j >= 0 & k > 0 do ( (     if ((k > (s->at(arr[j+1]) - 1)) & ((s->at(arr[j+1]) - 1) > 0)) then (     product := product*(arr[j+1]->pow(s->at(arr[j+1]) - 1)) ; 
     k := k - s->at(arr[j+1]) + 1 ; 
     s := s->union(Map{arr[j+1] |-> 0}) ) else skip ; 
     if (k <= (s->at(arr[j+1]) - 1) & ((s->at(arr[j+1]) - 1) > 0)) then (     product := product*(arr[j+1]->pow(k)) ; 
     break ) else skip )  ;     j := j - 1 ) ; 
    return product 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,6,7,8,2,5,6,8} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(maxProd(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int findLargest(int n,Vector<Integer>v){
    int flag=0 ;
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      if(v.get(i)==0)flag=1 ;
      sum+=v.get(i);
    }
    if(flag!=1)System.out.println("Not possible");
    else {
      Collections.sort(v,Collections.reverseOrder());
      if(v.get(0)==0){
        System.out.println("0");
        return 0 ;
      }
      else {
        int flags=0 ;
        int y=(int)(sum % 3);
        if(y!=0){
          for(int i=n-1 ; i>=0 ; i--){
            if(v.get(i)% 3==y){
              v.remove(i);
              flags=1 ;
              break ;
            }
          }
          if(flags==0){
            y=3-y ;
            int cnt=0 ;
            for(int i=n-1 ; i>=0 ; i--){
              if(v.get(i)% 3==y){
                v.remove(i);
                cnt++;
                if(cnt>=2)break ;
              }
            }
          }
        }
        if(v.get(0)==0)System.out.println("0");
        else for(Integer i : v){
          System.out.print(i);
        }
      }
    }
    return Integer.MIN_VALUE ;
  }
  public static void main(String[] args){
    int arr[]={
      3,9,9,6,4,3,6,4,9,6,0 };
      int n=11 ;
      Vector<Integer>v=new Vector<Integer>();
      for(int i=0 ; i<n ; i++)v.add(i,arr[i]);
      findLargest(n,v);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findLargest( n : int, v : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var flag : int ; flag := 0 ;
     var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (v->at(i+1) = 0) then     flag := 1 ; else skip ; 
     sum := sum+(v->at(i+1)) )  ;     i := i + 1 ) ; 
    if (flag /= 1) then     OclFile["System.out"].println("Not possible") else (     v, reverseOrder() := v, reverseOrder()->sort() ; 
     if (v->at(0+1) = 0) then (     OclFile["System.out"].println("0") ; 
     return 0 ) else (     var flags : int ; flags := 0 ;
     var y : int ; y := (sum mod 3)->oclAsType(int) ;
     if (y /= 0) then (         var i : int ; i := n - 1 ; while i >= 0 do ( (     if (v->at(i+1) mod 3 = y) then (     v := v->excludingAt(i+1) ; 
     flags := 1 ; 
     break ) else skip )  ;     i := i - 1 ) ; 
     if (flags = 0) then (     y := 3 - y ; 
     var cnt : int ; cnt := 0 ;
         var i : int ; i := n - 1 ; while i >= 0 do ( (     if (v->at(i+1) mod 3 = y) then (     v := v->excludingAt(i+1) ; 
     cnt := cnt + 1 ; 
     if (cnt >= 2) then     break else skip ) else skip )  ;     i := i - 1 ) ) else skip ) else skip ; 
     if (v->at(0+1) = 0) then     OclFile["System.out"].println("0") ; else     for (i : v) do ( (     OclFile["System.out"].print(i) )  ) ; ) ) ;  
    return -2147483648 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,9,9,6,4,3,6,4,9,6,0} ;
     var n : int ; n := 11 ;
    var v : Sequence(int) ; v := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     v := v.insertAt(i+1,arr[i+1]) ;  ;     i := i + 1 ) ; 
    execute findLargest(n, v) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Test1 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    List<Long>list=new ArrayList<>();
    long x=sc.nextLong();
    while(x>0){
      long r=x % 10 ;
      if(9-r<r){
        if(x/10==0 && 9-r==0)list.add(r);
        else list.add(9-r);
      }
      else list.add(r);
      x=x/10 ;
    }
    int pow=0 ;
    long newNumber=0 ;
    for(int i=0 ; i<list.size(); i++){
      newNumber=newNumber+list.get(i)*(long)Math.pow(10,pow);
      pow++;
    }
    System.out.println(newNumber);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(long) ; list := Sequence{} ;
    var x : long ; x := sc.getCurrent()->toLong() ;
    while (x > 0) do (     var r : long ; r := x mod 10 ;
     if (9 - r < r) then (     if (x / 10 = 0 & 9 - r = 0) then     list := list->including(r) ; else     list := list->including(9 - r) ; ) else     list := list->including(r) ; ;  
     x := x / 10 ) ; 
    var pow : int ; pow := 0 ;
    var newNumber : long ; newNumber := 0 ;
        var i : int ; i := 0 ; while i < list->size() do ( (     newNumber := newNumber + list->at(i+1) * 10->pow(pow)->oclAsType(long) ; 
     pow := pow + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(newNumber) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Geeks {
  static int countways(int n){
    if(n==1)return 0 ;
    else if(n % 2==0)return 1+countways(n/2);
    else return 1+Math.min(countways(n-1),countways(n+1));
  }
  public static void main(String args[]){
    int n=15 ;
    System.out.println(countways(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class Geeks {
  static   operation countways( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 0 else     if (n mod 2 = 0) then     return 1 + countways(n / 2) else     return 1 + Set{countways(n - 1), countways(n + 1)}->min() ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     OclFile["System.out"].println(countways(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void main(String[] args){
    int first,second ;
    for(first=1 ; first<=5 ; ++first)for(second=1 ; second<=5 ; ++second)System.out.printf("%d \n",5*first+second-5);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var first : int ;
    var second : int ;
         first := 1 ; while first <= 5 do (         second := 1 ; while second <= 5 do (     OclFile["System.out"].printf("%d \n", 5 * first + second - 5) ;  ;     second := second + 1 ) ;  ;     first := first + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new C().doIt();
  }
  class C {
    double map[][];
    double DP[][];
    void doIt(){
      int n=sc.nextInt();
      int m=sc.nextInt();
      map=new double[n][401];
      DP=new double[n][401];
      for(int i=0 ; i<n ; i++){
        int s=sc.nextInt();
        double Hsum=0 ;
        double start=1 ;
        for(int j=0 ; j<s ; j++){
          double S=sc.nextDouble();
          double H=sc.nextDouble();
          Hsum=Hsum+(H*S);
          for(int k=(int)start ; k<=Hsum ; k++){
            if(k>400)break ;
            map[i][k]=map[i][k-1]+(1.0/S);
          }
          start=Hsum+1 ;
        }
      }
      for(int i=1 ; i<=400 ; i++){
        DP[0][i]=map[0][i];
        if(DP[0][i]==0)DP[0][i]=DP[0][i-1];
      }
      for(int i=1 ; i<n ; i++){
        for(int j=1 ; j<=400 ; j++){
          for(int k=0 ; k<=j ; k++){
            DP[i][j]=Math.max(DP[i][j],DP[i-1][j-k]+map[i][k]);
          }
        }
      }
      System.out.println(DP[n-1][m]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     C.newC().doIt() );
 class C {
   attribute map : Sequence(Sequence(double));
   attribute DP : Sequence(Sequence(double));
   operation doIt() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    map := Integer.subrange(1,n)->collect(Integer.subrange(1,401)->collect(0.0)) ; 
    DP := Integer.subrange(1,n)->collect(Integer.subrange(1,401)->collect(0.0)) ; 
        var i : int ; i := 0 ; while i < n do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var Hsum : double ; Hsum := 0 ;
     var start : double ; start := 1 ;
         var j : int ; j := 0 ; while j < s do ( (     var S : double ; S := sc.getCurrent()->toReal() ;
     var H : double ; H := sc.getCurrent()->toReal() ;
    Hsum := Hsum + (H * S) ; 
        var k : int ; k := start->oclAsType(int) ; while k <= Hsum do ( (     if (k > 400) then     break else skip ; 
     map[i+1][k+1] := map[i+1][k - 1+1] + (1.0 / S) )  ;     k := k + 1 ) ; 
    start := Hsum + 1 ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 400 do ( (     DP[0+1][i+1] := map[0+1][i+1] ; 
     if (DP[0+1][i+1] = 0) then     DP[0+1][i+1] := DP[0+1][i - 1+1] ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 1 ; while j <= 400 do ( (         var k : int ; k := 0 ; while k <= j do ( (     DP[i+1][j+1] := Set{DP[i+1][j+1], DP[i - 1+1][j - k+1] + map[i+1][k+1]}->max() )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(DP[n - 1+1][m+1]) ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class H {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    int k=sc.nextInt();
    int max2=0 ;
    int max5=0 ;
    for(int i=0 ; i<9 ; i++){
      if(n % Math.pow(2,i)==0){
        max2=i ;
      }
      if(n % Math.pow(5,i)==0){
        max5=i ;
      }
    }
    long pot2=k>=max2 ?(long)Math.pow(2,k-max2): 1 ;
    long pot5=k>=max5 ?(long)Math.pow(5,k-max5): 1 ;
    System.out.print(n*pot2*pot5);
  }
}
------------------------------------------------------------
OCL File:
---------
 class H {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var max2 : int ; max2 := 0 ;
    var max5 : int ; max5 := 0 ;
        var i : int ; i := 0 ; while i < 9 do ( (     if (n mod 2->pow(i) = 0) then (     max2 := i ) else skip ; 
     if (n mod 5->pow(i) = 0) then (     max5 := i ) else skip )  ;     i := i + 1 ) ; 
    var pot2 : long ; pot2 := if k >= max2 then 2->pow(k - max2)->oclAsType(long) else 1 endif ;
    var pot5 : long ; pot5 := if k >= max5 then 5->pow(k - max5)->oclAsType(long) else 1 endif ;
    OclFile["System.out"].print(n * pot2 * pot5) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class problems {
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    long nn=n ;
    int k=in.nextInt();
    int two=0,five=0 ;
    while(n % 2==0){
      n/=2 ;
      two++;
      if(two==k)break ;
    }
    while(n % 5==0){
      n/=5 ;
      five++;
      if(five==k)break ;
    }
    while(two<k){
      nn*=2 ;
      two++;
    }
    while(five<k){
      nn*=5 ;
      five++;
    }
    System.out.print(nn);
  }
}
------------------------------------------------------------
OCL File:
---------
 class problems {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var nn : long ; nn := n ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var two : int ; two := 0 ;
    var five : int ; five := 0 ;
    while (n mod 2 = 0) do (     n := n/(2) ; 
     two := two + 1 ; 
     if (two = k) then     break else skip ) ; 
    while (n mod 5 = 0) do (     n := n/(5) ; 
     five := five + 1 ; 
     if (five = k) then     break else skip ) ; 
    while (two < k) do (     nn := nn*(2) ; 
     two := two + 1 ) ; 
    while (five < k) do (     nn := nn*(5) ; 
     five := five + 1 ) ; 
    OclFile["System.out"].print(nn) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
import java.util.LinkedList ;
public class kRounding {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int i,j,k ;
    int t,N ;
    i=0 ;
    j=0 ;
    int min=0 ;
    N=Integer.parseInt(sc.next());
    k=Integer.parseInt(sc.next());
    int m=N ;
    BigInteger cat ;
    t=1 ;
    while(m % 2==0){
      i++;
      m/=2 ;
    }
    m=N ;
    min=i ;
    while(m % 5==0){
      j++;
      m/=5 ;
    }
    if(j<min)min=j ;
    cat=BigInteger.valueOf(N);
    if(min>=k)System.out.println(N);
    else {
      i-=min ;
      j-=min ;
      k-=min ;
      if(i<0)i=0 ;
      if(j<0)j=0 ;
      if(i==0){
        t=(int)Math.pow(2,k);
        cat=cat.multiply(BigInteger.valueOf(t));
        if(k-j<0)j=k ;
        t=(int)Math.pow(5,k-j);
        cat=cat.multiply(BigInteger.valueOf(t));
      }
      else {
        if(k-i<0)i=k ;
        t=(int)Math.pow(2,k-i);
        cat=cat.multiply(BigInteger.valueOf(t));
        t=(int)Math.pow(5,k);
        cat=cat.multiply(BigInteger.valueOf(t));
      }
      System.out.println(cat);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class kRounding {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ;
    var j : int ;
    var k : int ;
    var t : int ;
    var N : int ;
    i := 0 ; 
    j := 0 ; 
    var min : int ; min := 0 ;
    N := (sc.getCurrent())->toInteger() ; 
    k := (sc.getCurrent())->toInteger() ; 
    var m : int ; m := N ;
    var cat : long ;
    t := 1 ; 
    while (m mod 2 = 0) do (     i := i + 1 ; 
     m := m/(2) ) ; 
    m := N ; 
    min := i ; 
    while (m mod 5 = 0) do (     j := j + 1 ; 
     m := m/(5) ) ; 
    if (j < min) then     min := j ; else skip ; 
    cat := (N + "")->toLong() ; 
    if (min >= k) then     OclFile["System.out"].println(N) else (     i := i-(min) ; 
     j := j-(min) ; 
    k := k-(min) ; 
    if (i < 0) then     i := 0 ; else skip ; 
    if (j < 0) then     j := 0 ; else skip ; 
    if (i = 0) then (     t := 2->pow(k)->oclAsType(int) ; 
     cat := cat.multiply((t + "")->toLong()) ; 
    if (k - j < 0) then     j := k ; else skip ; 
    t := 5->pow(k - j)->oclAsType(int) ; 
    cat := cat.multiply((t + "")->toLong()) ; 
 ) else (     if (k - i < 0) then     i := k ; else skip ; 
     t := 2->pow(k - i)->oclAsType(int) ; 
    cat := cat.multiply((t + "")->toLong()) ; 
    t := 5->pow(k)->oclAsType(int) ; 
    cat := cat.multiply((t + "")->toLong()) ; 
 ) ;  
    OclFile["System.out"].println(cat) ; 
 ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class k_round {
  private int n ;
  private int k ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    k_round kRound=new k_round();
    kRound.n=in.nextInt();
    kRound.k=in.nextInt();
    System.out.println(kRound.realround());
  }
  long gcd(long a,long b){
    return b==0 ? a : gcd(b,a % b);
  }
  long lcm(long a,long b){
    return a/gcd(a,b)*b ;
  }
  public long realround(){
    long s=1*(long)Math.pow(10,k);
    s=lcm(s,n);
    return s ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class k_round {
   attribute n : int;
   attribute k : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var kRound : k_round ; kRound := k_round.newk_round() ;
    kRound.n := in.getCurrent()->toInteger() ; 
    kRound.k := in.getCurrent()->toInteger() ; 
    OclFile["System.out"].println(kRound.realround()) ; 
 );
   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return if b = 0 then a else gcd(b, a mod b) endif );
   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return a / gcd(a, b) * b );
   operation realround() : long
  pre: true
  post: true
  activity: (     var s : long ; s := 1 * 10->pow(k)->oclAsType(long) ;
     s := lcm(s, n) ; 
     return s );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigDecimal ;
import java.math.MathContext ;
import java.util.*;
public class ProblemD {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int n=Integer.parseInt(br.readLine());
    String line[]=br.readLine().split(" ");
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=Integer.parseInt(line[i]);
    int ans=1,curr=0,left=0 ;
    for(int i=0 ; i<n ; i++){
      int index=search(i+1,n-1,2*arr[i],arr);
      curr++;
      ans=Math.max(curr,ans);
      if(index==-1)curr=0 ;
    }
    System.out.println(ans);
  }
  public static int search(int l,int r,int target,int arr[]){
    int ans=-1 ;
    while(l<=r){
      int mid=(l+r)/2 ;
      if(arr[mid]<=target){
        ans=mid ;
        l=mid+1 ;
      }
      else r=mid-1 ;
    }
    return ans ;
  }
}
class Pair {
  int x,y ;
  public Pair(int x,int y){
    this.x=x ;
    this.y=y ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemD {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var line : Sequence(String) ; line := br.readLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := (line[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 1 ;
    var curr : int ; curr := 0 ;
    var left : int ; left := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var index : int ; index := search(i + 1, (n)->char2byte() - 1, 2 * arr[i+1], arr) ;
     curr := curr + 1 ; 
     ans := Set{curr, ans}->max() ; 
     if (index = -1) then     curr := 0 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation search( l : int, r : int, target : int, arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := -1 ;
     while (l <= r) do (     var mid : int ; mid := (l + r) / 2 ;
     if (arr[mid+1] <= target) then (     ans := mid ; 
     l := mid + 1 ) else     r := mid - 1 ; ) ; 
     return ans );
}
class Pair {
   attribute x : int;
   static operation newPair( x : int, y : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    long N=fs.nextLong();
    long Q=fs.nextLong();
    Long[] A=new Long[(int)N];
    for(int i=0 ; i<N ; i++){
      A[i]=fs.nextLong();
    }
    Arrays.sort(A);
    Long[] ans=new Long[(int)N];
    ans[(int)N-1]=A[(int)N-1];
    for(int j=(int)N-2 ; j>=0 ; j--){
      ans[j]=A[j]+ans[j+1];
    }
    for(int j=0 ; j<Q ; j++){
      long a=fs.nextLong();
      long b=fs.nextLong();
      if(a==b){
        out.println(ans[(int)N-(int)a]);
        continue ;
      }
      long diff=a-b ;
      out.println(ans[(int)N-(int)a]-ans[(int)N-(int)diff]);
    }
    out.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : long ; N := fs.nextLong() ;
    var Q : long ; Q := fs.nextLong() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N->oclAsType(int))->collect(null) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := fs.nextLong() )  ;     i := i + 1 ) ; 
    A := A->sort() ; 
    var ans : Sequence(long) ; ans := Integer.subrange(1,N->oclAsType(int))->collect(null) ;
    ans[N->oclAsType(int) - 1+1] := A[N->oclAsType(int) - 1+1] ; 
        var j : int ; j := N->oclAsType(int) - 2 ; while j >= 0 do ( (     ans[j+1] := A[j+1] + ans[j + 1+1] )  ;     j := j - 1 ) ; 
        var j : int ; j := 0 ; while j < Q do ( (     var a : long ; a := fs.nextLong() ;
     var b : long ; b := fs.nextLong() ;
    if (a = b) then (     skip ; 
     continue ) else skip ; 
    var diff : long ; diff := a - b ;
    skip ; 
 )  ;     j := j + 1 ) ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MyClass {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int t=1 ;
    while(t-->0){
      int n=sc.nextInt();
      int m=sc.nextInt();
      Integer[] Ar=new Integer[n];
      for(int i=0 ; i<n ; i++)Ar[i]=sc.nextInt();
      Arrays.sort(Ar,Collections.reverseOrder());
      long preSum=0 ;
      List<Long>li=new ArrayList<>();
      for(int i : Ar){
        li.add(preSum);
        preSum+=i ;
      }
      li.add(preSum);
      while(m-->0){
        int x=sc.nextInt();
        int y=sc.nextInt();
        long valHere=li.get(x)-li.get(x-y);
        pw.println(valHere);
      }
    }
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := 1 ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var Ar : Sequence(int) ; Ar := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     Ar[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    Ar := OclComparator.sortWith(Ar, reverseOrder()) ; 
    var preSum : long ; preSum := 0 ;
    var li : Sequence(long) ; li := Sequence{} ;
    for (i : Ar) do ( (     li := li->including(preSum) ; 
     preSum := preSum+(i) )  ) ; 
    li := li->including(preSum) ; 
        while (m > 0) do (        m := m - 1 ;     skip ; (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     var valHere : long ; valHere := li->at(x+1) - li->at(x - y+1) ;
     skip ) ;  ) ;  
 ) ;  ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class ch_number {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    Long n=scan.nextLong();
    String s=String.valueOf(n);
    char[] arr=s.toCharArray();
    int k=arr[0]-'0' ;
    if(9-k<k && 9-k!=0){
      arr[0]=(char)('0'+9-k);
    }
    for(int i=1 ; i<s.length(); i++){
      int c=arr[i]-'0' ;
      if(9-c<c){
        arr[i]=(char)('0'+9-c);
      }
    }
    String ans="" ;
    for(int i=0 ; i<s.length(); i++){
      ans+=arr[i];
    }
    System.out.println(Long.parseLong(ans));
  }
}
------------------------------------------------------------
OCL File:
---------
 class ch_number {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := scan.getCurrent()->toLong() ;
    var s : String ; s := ((n) + "") ;
    var arr : Sequence(String) ; arr := s->characters() ;
    var k : int ; k := arr[0+1] - ('0')->char2byte() ;
    if (9 - k < k & 9 - k /= 0) then (     arr[0+1] := ('0' + 9 - k)->oclAsType(String) ) else skip ; 
        var i : int ; i := 1 ; while i < s->size() do ( (     var c : int ; c := arr[i+1] - ('0')->char2byte() ;
     if (9 - c < c) then (     arr[i+1] := ('0' + 9 - c)->oclAsType(String) ) else skip )  ;     i := i + 1 ) ; 
    var ans : String ; ans := "" ;
        var i : int ; i := 0 ; while i < s->size() do ( (     ans := ans+(arr[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((ans)->toLong()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void binaryRightAngleTriangle(int n){
    int row,col ;
    for(row=0 ; row<n ; row++){
      for(col=0 ; col<=row ; col++){
        if(((row+col)% 2)==0)System.out.print("0");
        else System.out.print("1");
        System.out.print("\t");
      }
      System.out.print("\n");
    }
  }
  public static void main(String[] args){
    int n=4 ;
    binaryRightAngleTriangle(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation binaryRightAngleTriangle( n : int) : void
  pre: true
  post: true
  activity: (     var row : int ;
    var col : int ;
         row := 0 ; while row < n do ( (         col := 0 ; while col <= row do ( (     if (((row + col) mod 2) = 0) then     OclFile["System.out"].print("0") else     OclFile["System.out"].print("1") ; ;  
     OclFile["System.out"].print("\t") )  ;     col := col + 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     row := row + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     execute binaryRightAngleTriangle(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=s.nextInt();
    }
    Arrays.sort(arr);
    if(arr[0]>1){
      System.out.println(1);
      return ;
    }
    int i ;
    for(i=1 ; i<n ; i++){
      if(arr[i]-arr[i-1]>1){
        System.out.println(arr[i-1]+1);
        break ;
      }
    }
    if(i==n){
      int op=arr[n-1]+1 ;
      System.out.println(op);
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    if (arr[0+1] > 1) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    var i : int ;
        i := 1 ; while i < n do ( (     if (arr[i+1] - arr[i - 1+1] > 1) then (     OclFile["System.out"].println(arr[i - 1+1] + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (i = n) then (     var op : int ; op := arr[n - 1+1] + 1 ;
     OclFile["System.out"].println(op) ) else skip ; 
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class NextTest {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    int sm_num=1 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr);
    for(int i=0 ; i<n ; i++){
      if(arr[i]==sm_num){
        sm_num++;
      }
    }
    System.out.print(sm_num);
  }
}
------------------------------------------------------------
OCL File:
---------
 class NextTest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sm_num : int ; sm_num := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = sm_num) then (     sm_num := sm_num + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sm_num) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[3000+100];
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      a[x]++;
    }
    for(int i=1 ; i<=3001 ; i++){
      if(a[i]==0){
        System.out.println(i);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,3000 + 100)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     a[x+1] := a[x+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 3001 do ( (     if (a[i+1] = 0) then (     OclFile["System.out"].println(i) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main1 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a[]=new int[3000+100];
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      a[x]++;
    }
    for(int i=1 ; i<=3001 ; i++){
      if(a[i]==0){
        System.out.println(i);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,3000 + 100)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     a[x+1] := a[x+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 3001 do ( (     if (a[i+1] = 0) then (     OclFile["System.out"].println(i) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Mridul8 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    int i=-1 ;
    while(i!=n-1){
      i=i+1 ;
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr);
    i=-1 ;
    int yes=0 ;
    while(i!=n-1){
      i=i+1 ;
      if(arr[i]-i!=1){
        yes=1 ;
        break ;
      }
    }
    if(yes==1){
      System.out.println(i+1);
    }
    else {
      int g=n+1 ;
      System.out.println(g);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mridul8 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var i : int ; i := -1 ;
    while (i /= n - 1) do (     i := i + 1 ; 
     arr[i+1] := sc.getCurrent()->toInteger() ) ; 
    arr := arr->sort() ; 
    i := -1 ; 
    var yes : int ; yes := 0 ;
    while (i /= n - 1) do (     i := i + 1 ; 
     if (arr[i+1] - i /= 1) then (     yes := 1 ; 
     break ) else skip ) ; 
    if (yes = 1) then (     OclFile["System.out"].println(i + 1) ) else (     var g : int ; g := n + 1 ;
     OclFile["System.out"].println(g) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int N=2 ;
  static int M=2 ;
  static void Matrix(char a[][]){
    char ch='1' ;
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<M ; j++){
        if(a[i][j]=='.')a[i][j]=ch ;
        ch=(ch=='1')? '0' : '1' ;
        System.out.print(a[i][j]+" ");
      }
      System.out.println();
      if(i % 2==0)ch='0' ;
      else ch='1' ;
    }
  }
  public static void main(String[] args){
    char a[][]={
      {
        '.','_' },{
          '_','.' }
        };
        Matrix(a);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 2;
  static   attribute M : int := 2;
  static   operation Matrix( a : Sequence(Sequence(String))) : void
  pre: true
  post: true
  activity: (     var ch : String ; ch := '1' ;
         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < M do ( (     if (a[i+1][j+1] = '.') then     a[i+1][j+1] := ch ; else skip ; 
     ch := if (ch = '1') then '0' else '1' endif ; 
     OclFile["System.out"].print(a[i+1][j+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() ; 
     if (i mod 2 = 0) then     ch := '0' ; else     ch := '1' ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(Sequence(String)) ; a := Sequence{Sequence{'.','_'},Sequence{'_','.'}} ;
     execute Matrix(a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new AOJ1180().doIt();
  }
  class AOJ1180 {
    int input,l ;
    int rehyou(int a){
      int result=0 ;
      ArrayList<Integer>list=new ArrayList<Integer>();
      String b=Integer.toString(a);
      for(int i=0 ; i<Integer.toString(a).length(); i++)list.add(Integer.parseInt(b.charAt(i)+""));
      while(list.size()<l)list.add(0);
      Collections.sort(list);
      int c=0,d=0 ;
      for(int i=list.size()-1 ; i>=0 ; i--){
        c*=10 ;
        c+=list.get(i);
      }
      for(int i=0 ; i<list.size(); i++){
        d*=10 ;
        d+=list.get(i);
      }
      return c-d ;
    }
    void solve(){
      HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();
      int a=input ;
      map.put(a,0);
      for(int i=1 ; ; i++){
        a=rehyou(a);
        if(map.containsKey(a)){
          System.out.print(map.get(a)+" ");
          System.out.print(a+" ");
          System.out.println(i-map.get(a));
          break ;
        }
        map.put(a,i);
      }
    }
    void doIt(){
      while(in.hasNext()){
        input=in.nextInt();
        l=in.nextInt();
        if(input+l==0)break ;
        solve();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     AOJ1180.newAOJ1180().doIt() );
 class AOJ1180 {
   attribute input : int;
   operation rehyou( a : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var list : Sequence(int) ; list := Sequence{} ;
    var b : String ; b := ((a) + "") ;
        var i : int ; i := 0 ; while i < ((a) + "")->size() do (     list := list->including((b->at(i+1) + "")->toInteger()) ;  ;     i := i + 1 ) ; 
    while (list->size() < l) do     list := list->including(0) ; ; 
    list := list->sort() ; 
    var c : int ; c := 0 ;
    var d : int ; d := 0 ;
        var i : int ; i := list->size() - 1 ; while i >= 0 do ( (     c := c*(10) ; 
     c := c+(list->at(i+1)) )  ;     i := i - 1 ) ; 
        var i : int ; i := 0 ; while i < list->size() do ( (     d := d*(10) ; 
     d := d+(list->at(i+1)) )  ;     i := i + 1 ) ; 
    return c - d 
 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var map : Map(int,int) ; map := Map{} ;
     var a : int ; a := input ;
     map := map->union(Map{a |-> 0}) ; 
         var i : int ; i := 1 ; while true do ( (     a := rehyou(a) ; 
     if (map->keys()->includes(a)) then (     OclFile["System.out"].print(map->at(a) + " ") ; 
     OclFile["System.out"].print(a + " ") ; 
     OclFile["System.out"].println((i)->char2byte() - map->at(a)) ; 
     break ) else skip ; 
     map := map->union(Map{a |-> i}) )  ;     i := i + 1 ) );
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (in.hasNext()) do (     input := in.getCurrent()->toInteger() ; 
     l := in.getCurrent()->toInteger() ; 
     if (input + l = 0) then     break else skip ; 
     execute solve() ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.*;
import java.io.*;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.StringTokenizer ;
import java.util.HashMap ;
import java.util.Map ;
public class creatingTheContest {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer str ;
    int n=Integer.parseInt(br.readLine());
    int[] a=new int[n];
    str=new StringTokenizer(br.readLine());
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(str.nextToken());
    }
    if(n==1){
      System.out.println(1);
      return ;
    }
    int max=-1 ;
    int count=0 ;
    for(int i=n-1 ; i>0 ; i--){
      if(a[i]-a[i-1]<=a[i-1])count++;
      else count=0 ;
      if(count>max)max=count ;
    }
    System.out.println(max+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class creatingTheContest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : OclIterator ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    str := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (str.next())->toInteger() )  ;     i := i + 1 ) ; 
    if (n = 1) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    var max : int ; max := -1 ;
    var count : int ; count := 0 ;
        var i : int ; i := n - 1 ; while i > 0 do ( (     if (a[i+1] - a[i - 1+1] <= a[i - 1+1]) then     count := count + 1 else     count := 0 ; ;  
     if (count > max) then     max := count ; else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(max + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.Scanner ;
public class Main {
  private static int change(int a,int n){
    int b=String.valueOf(a).length();
    String str=String.valueOf(a);
    while(str.length()<n)str+="0" ;
    char[] c=str.toCharArray();
    Arrays.sort(c);
    int max=0 ;
    int min=0 ;
    for(int i=0 ; i<str.length(); i++)min=min*10+(c[i]-'0');
    for(int i=str.length()-1 ; i>=0 ; i--)max=max*10+(c[i]-'0');
    return max-min ;
  }
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      while(sc.hasNext()){
        int a=sc.nextInt();
        int n=sc.nextInt();
        if(a+n==0)break ;
        int c=a ;
        HashMap<Integer,Integer>hm=new HashMap<>();
        hm.put(a,0);
        for(int i=1 ; ; i++){
          c=change(c,n);
          if(hm.containsKey(c)){
            System.out.println((hm.get(c))+" "+c+" "+(i-hm.get(c)));
            break ;
          }
          else hm.put(c,i);
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation change( a : int, n : int) : int
  pre: true
  post: true
  activity: (     var b : int ; b := ((a) + "")->size() ;
     var str : String ; str := ((a) + "") ;
    while (str->size() < n) do     str := str+("0") ; ; 
    var c : Sequence(String) ; c := str->characters() ;
    c := c->sort() ; 
    var max : int ; max := 0 ;
    var min : int ; min := 0 ;
        var i : int ; i := 0 ; while i < str->size() do (     min := min * 10 + (c[i+1] - ('0')->char2byte()) ;  ;     i := i + 1 ) ; 
        var i : int ; i := str->size() - 1 ; while i >= 0 do (     max := max * 10 + (c[i+1] - ('0')->char2byte()) ;  ;     i := i - 1 ) ; 
    return max - min 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     while (sc.hasNext()) do (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    if (a + n = 0) then     break else skip ; 
    var c : int ; c := a ;
    var hm : Map(int,int) ; hm := Map{} ;
    hm := hm->union(Map{a |-> 0}) ; 
        var i : int ; i := 1 ; while true do ( (     c := change(c, n) ; 
     if (hm->keys()->includes(c)) then (     OclFile["System.out"].println((hm->at(c)) + " " + c + " " + (i - hm->at(c))) ; 
     break ) else     hm := hm->union(Map{c |-> i}) ; )  ;     i := i + 1 ) ; 
 ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Div2_751C {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int t=in.nextInt();
    for(int tt=0 ; tt<t ; tt++){
      int n=in.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      int gcd=0 ;
      for(int b=0 ; b<30 ; b++){
        int mask=1<<b ;
        int cnt=0 ;
        for(int i : a){
          if((mask & i)!=0)cnt++;
        }
        gcd=gcd(cnt,gcd);
      }
      if(gcd==0){
        for(int i=1 ; i<=n ; i++)pw.print(i+" ");
        pw.println();
      }
      else {
        for(int d=1 ; d<=gcd ; d++){
          if(gcd % d==0)pw.print(d+" ");
        }
        pw.println();
      }
    }
    pw.close();
  }
  static int gcd(int a,int b){
    return(b==0)? a : gcd(b,a % b);
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Div2_751C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        var tt : int ; tt := 0 ; while tt < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var gcd : int ; gcd := 0 ;
        var b : int ; b := 0 ; while b < 30 do ( (     var mask : int ; mask := (1*(2->pow(b)))->oclAsType(long) ;
     var cnt : int ; cnt := 0 ;
     for (i : a) do ( (     if ((MathLib.bitwiseAnd(mask,i)) /= 0) then     cnt := cnt + 1 ; else skip )  ) ; 
     gcd := gcd(cnt, gcd) )  ;     b := b + 1 ) ; 
    if (gcd = 0) then (         var i : int ; i := 1 ; while i <= n do (     skip ;  ;     i := i + 1 ) ; 
     skip ) else (         var d : int ; d := 1 ; while d <= gcd do ( (     if (gcd mod d = 0) then     skip ; else skip )  ;     d := d + 1 ) ; 
     skip ) ;  
 )  ;     tt := tt + 1 ) ; 
    skip ; 
 );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if (b = 0) then a else gcd(b, a mod b) endif );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    int i=0 ;
    StringBuilder sb=new StringBuilder();
    if(str.charAt(0)=='9'){
      sb.append(str.charAt(0));
      i++;
    }
    for(int j=i ; j<str.length(); j++){
      char ch=str.charAt(j);
      if(ch>='5'){
        sb.append(9-(ch-'0'));
      }
      else {
        sb.append(ch);
      }
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var i : int ; i := 0 ;
    var sb : String ; sb := StringLib.newString() ;
    if (str->at(0+1) = '9') then (     sb := sb + StringLib.newString(str->at(0+1)) ; 
     i := i + 1 ) else skip ; 
        var j : int ; j := i ; while j < str->size() do ( (     var ch : String ; ch := str->at(j+1) ;
     if (ch >= '5') then (     sb := sb + StringLib.newString(9 - ((ch)->char2byte() - ('0')->char2byte())) ) else (     sb := sb + StringLib.newString(ch) ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.HashSet ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String[] tmpArray=br.readLine().split(" ");
      int num=Integer.parseInt(tmpArray[0]);
      int len=Integer.parseInt(tmpArray[1]);
      if(num==0 && len==0){
        break ;
      }
      HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();
      map.put(num,0);
      int i=1 ;
      while(true){
        int maxnum=maxDecimal(num,len);
        int minnum=minDecimal(num,len);
        num=maxnum-minnum ;
        if(map.containsKey(num)){
          System.out.println(map.get(num)+" "+num+" "+(i-map.get(num)));
          break ;
        }
        else {
          map.put(num,i);
        }
        i++;
      }
    }
  }
  static int maxDecimal(int num,int len){
    String tmpStr=Integer.toString(num);
    char[] carray=tmpStr.toCharArray();
    Arrays.sort(carray);
    StringBuffer sb=new StringBuffer(new String(carray));
    int tmpResult=Integer.parseInt(sb.reverse().toString());
    if(sb.length()<len){
      tmpResult*=Math.pow(10,len-sb.length());
    }
    return tmpResult ;
  }
  static int minDecimal(int num,int len){
    String tmpStr=Integer.toString(num);
    char[] carray=tmpStr.toCharArray();
    Arrays.sort(carray);
    StringBuffer sb=new StringBuffer(new String(carray));
    int tmpResult=Integer.parseInt(sb.toString());
    return tmpResult ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
     var num : int ; num := (tmpArray[0+1])->toInteger() ;
    var len : int ; len := (tmpArray[1+1])->toInteger() ;
    if (num = 0 & len = 0) then (     break ) else skip ; 
    var map : Map(int,int) ; map := Map{} ;
    map := map->union(Map{num |-> 0}) ; 
    var i : int ; i := 1 ;
    while (true) do (     var maxnum : int ; maxnum := maxDecimal(num, len) ;
     var minnum : int ; minnum := minDecimal(num, len) ;
    num := maxnum - minnum ; 
    if (map->keys()->includes(num)) then (     OclFile["System.out"].println(map->at(num) + " " + num + " " + (i - map->at(num))) ; 
     break ) else (     map := map->union(Map{num |-> i}) ) ;  
    i := i + 1 ; 
 ) ; 
 ) );
  static   operation maxDecimal( num : int, len : int) : int
  pre: true
  post: true
  activity: (     var tmpStr : String ; tmpStr := ((num) + "") ;
     var carray : Sequence(String) ; carray := tmpStr->characters() ;
    carray := carray->sort() ; 
    var sb : String ; sb := StringLib.newString(StringLib.newString(carray)) ;
    var tmpResult : int ; tmpResult := (sb->reverse()+"")->toInteger() ;
    if (sb->size() < len) then (     tmpResult := tmpResult*(10->pow(len - sb->size())) ) else skip ; 
    return tmpResult 
 );
  static   operation minDecimal( num : int, len : int) : int
  pre: true
  post: true
  activity: (     var tmpStr : String ; tmpStr := ((num) + "") ;
     var carray : Sequence(String) ; carray := tmpStr->characters() ;
    carray := carray->sort() ; 
    var sb : String ; sb := StringLib.newString(StringLib.newString(carray)) ;
    var tmpResult : int ; tmpResult := (sb+"")->toInteger() ;
    return tmpResult 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  Scanner sc=new Scanner(in);
  int value(List<Integer>list){
    int v=0 ;
    for(int i : list)v=v*10+i ;
    return v ;
  }
  void run(){
    String a ;
    int l ;
    List<Integer>list=new ArrayList<Integer>();
    List<Integer>save=new ArrayList<Integer>();
    while(true){
      a=sc.next();
      l=sc.nextInt();
      if(a.equals("0")&& l==0)break ;
      save.clear();
      save.add(Integer.parseInt(a));
      while(true){
        list.clear();
        for(int i=0 ; i<a.length(); i++)list.add(Character.getNumericValue(a.charAt(i)));
        for(int i=0 ; i<l-a.length(); i++)list.add(0);
        int temp1,temp2 ;
        Collections.sort(list);
        temp1=value(list);
        Collections.reverse(list);
        temp2=value(list);
        int v=temp2-temp1 ;
        if(save.contains(v)){
          out.printf("%d %d %d\n",save.indexOf(v),v,save.size()-save.indexOf(v));
          break ;
        }
        else {
          save.add(v);
          a=String.valueOf(v);
        }
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   operation value( list : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var v : int ; v := 0 ;
     for (i : list) do (     v := v * 10 + i ;  ) ; 
     return v );
   operation run() : void
  pre: true
  post: true
  activity: (     var a : String ;
     var l : int ;
    var list : Sequence(int) ; list := Sequence{} ;
    var save : Sequence(int) ; save := Sequence{} ;
    while (true) do (     a := sc.getCurrent() ; 
     l := sc.getCurrent()->toInteger() ; 
    if (a = "0" & l = 0) then     break else skip ; 
    save := save->intersection(Set{}) ; 
    save := save->including((a)->toInteger()) ; 
    while (true) do (     list := list->intersection(Set{}) ; 
         var i : int ; i := 0 ; while i < a->size() do (     list := list->including(("" + a->at(i+1))->toInteger()) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < (l)->char2byte() - a->size() do (     list := list->including(0) ;  ;     i := i + 1 ) ; 
    var temp1 : int ;
    var temp2 : int ;
    list := list->sort() ; 
    temp1 := value(list) ; 
    list := list->reverse() ; 
    temp2 := value(list) ; 
    var v : int ; v := temp2 - temp1 ;
    if (save->includes(v)) then (     out.printf("%d %d %d\n", save->indexOf(v)-1, v, save->size() - save->indexOf(v)-1) ; 
     break ) else (     save := save->including(v) ; 
     a := ((v) + "") ) ;  
 ) ; 
 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner s=new Scanner(System.in);
  public static void main(String[] __){
    while(true){
      String in=s.next();
      int length=s.nextInt();
      if(length==0)return ;
      ArrayList<Integer>list=new ArrayList<>();
      list.add(Integer.parseInt(in));
      in=String.format("%0"+length+"d",list.get(0));
      for(int l=1 ; true ; l++){
        char[] buf=in.toCharArray();
        Arrays.sort(buf);
        int small=Integer.parseInt(String.valueOf(buf)),large=Integer.parseInt(String.valueOf(reverse(buf))),i ;
        if((i=list.indexOf(large-small))>=0){
          System.out.printf("%d %d %d\n",i,large-small,l-i);
          break ;
        }
        list.add(large-small);
        in=String.format("%0"+length+"d",large-small);
      }
    }
  }
  public static char[] swap(char[] c,int a,int b){
    char x=c[b];
    c[b]=c[a];
    c[a]=x ;
    return c ;
  }
  public static char[] reverse(char[] c,int l,int r){
    int buf=(l+r+1)/2 ;
    for(int i=l ; i<buf ; i++){
      swap(c,i,r-i+l);
    }
    return c ;
  }
  public static char[] reverse(char[] c){
    return reverse(c,0,c.length-1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( __ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var in : String ; in := s.getCurrent() ;
     var length : int ; length := s.getCurrent()->toInteger() ;
    if (length = 0) then     return else skip ; 
    var list : Sequence(int) ; list := Sequence{} ;
    list := list->including((in)->toInteger()) ; 
    in := StringLib.format("%0" + length + "d",Sequence{list->at(0+1)}) ; 
        var l : int ; l := 1 ; while true do ( (     var buf : Sequence(String) ; buf := in->characters() ;
     buf := buf->sort() ; 
    var small : int ; small := ((buf)->sum() )->toInteger() ;
    var large : int ; large := (((reverse(buf)) + ""))->toInteger() ;
    var i : int ;
    if ((i) >= 0) then (     OclFile["System.out"].printf("%d %d %d\n", i, large - small, l - i) ; 
     break ) else skip ; 
    list := list->including(large - small) ; 
    in := StringLib.format("%0" + length + "d",Sequence{large - small}) ; 
 )  ;     l := l + 1 ) ; 
 ) );
  static   operation swap( c : Sequence(String), a : int, b : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var x : String ; x := c[b+1] ;
     c[b+1] := c[a+1] ; 
     c[a+1] := x ; 
     return c );
  static   operation reverse( c : Sequence(String), l : int, r : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var buf : int ; buf := (l + r + 1) / 2 ;
         var i : int ; i := l ; while i < buf do ( (     execute swap(c, i, r - i + l) )  ;     i := i + 1 ) ; 
     return c );
  static   operation reverse( c : Sequence(String)) : Sequence(String)
  pre: true
  post: true
  activity: (     return reverse(c, 0, c->size() - 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int M=sc.nextInt();
      int[] c=new int[n];
      int[][] p=new int[n][3];
      for(int i=0 ; i<n ; i++){
        sc.nextLine();
        sc.nextLine();
        c[i]=sc.nextInt();
        for(int j=0 ; j<3 ; j++)p[i][j]=sc.nextInt();
      }
      int[][][] dp=new int[3][n][M+1];
      for(int x=0 ; x<3 ; x++){
        for(int i=0 ; i<n ; i++){
          for(int j=1 ; j<=M ; j++){
            dp[x][i][j]=dp[x][i][j-1];
            if(j-c[i]>=0)dp[x][i][j]=Math.max(dp[x][i][j],dp[x][i][j-c[i] ]+p[i][x]);
            if(i>0)dp[x][i][j]=Math.max(dp[x][i][j],dp[x][i-1][j]);
          }
        }
      }
      int max=0 ;
      for(int i=0 ; i<3 ; i++)max=Math.max(max,dp[i][n-1][M]);
      System.out.println(max);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var M : int ; M := sc.getCurrent()->toInteger() ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
    var p : Sequence(Sequence(int)) ; p := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     skip ; 
     skip ; 
     c[i+1] := sc.getCurrent()->toInteger() ; 
         var j : int ; j := 0 ; while j < 3 do (     p[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(Sequence(int))) ; dp := Integer.subrange(1,3)->collect(Integer.subrange(1,n)->collect(Integer.subrange(1,M + 1)->collect(0))) ;
        var x : int ; x := 0 ; while x < 3 do ( (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 1 ; while j <= M do ( (     dp[x+1][i+1][j+1] := dp[x+1][i+1][j - 1+1] ; 
     if (j - c[i+1] >= 0) then     dp[x+1][i+1][j+1] := Set{dp[x+1][i+1][j+1], dp[x+1][i+1][j - c[i+1]+1] + p[i+1][x+1]}->max() ; else skip ; 
     if (i > 0) then     dp[x+1][i+1][j+1] := Set{dp[x+1][i+1][j+1], dp[x+1][i - 1+1][j+1]}->max() ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     x := x + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < 3 do (     max := Set{max, dp[i+1][n - 1+1][M+1]}->max() ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static final int C=0 ;
  public static final int V=1 ;
  public static final int D=2 ;
  public static final int L=3 ;
  public static void main(String[] args){
    doIt();
  }
  public static void doIt(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int[][] bydol=new int[n][4];
      for(int i=0 ; i<n ; i++){
        sc.nextLine();
        sc.nextLine();
        bydol[i][C]=sc.nextInt();
        bydol[i][V]=sc.nextInt();
        bydol[i][D]=sc.nextInt();
        bydol[i][L]=sc.nextInt();
      }
      int max=0 ;
      for(int i=1 ; i<=3 ; i++){
        int dp[][]=new int[n+1][m+1];
        for(int j=1 ; j<n+1 ; j++){
          for(int k=1 ; k<m+1 ; k++){
            dp[j][k]=dp[j-1][k];
            for(int l=1 ; l*bydol[j-1][C]<=k ; l++){
              dp[j][k]=Math.max(dp[j][k],dp[j-1][k-l*bydol[j-1][C] ]+l*bydol[j-1][i]);
            }
          }
        }
        if(max<dp[n][m]){
          max=dp[n][m];
        }
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute C : int := 0;
  static    attribute V : int := 1;
  static    attribute D : int := 2;
  static    attribute L : int := 3;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute doIt() );
  static   operation doIt() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var bydol : Sequence(Sequence(int)) ; bydol := Integer.subrange(1,n)->collect(Integer.subrange(1,4)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     skip ; 
     skip ; 
    bydol[i+1][C+1] := sc.getCurrent()->toInteger() ; 
    bydol[i+1][V+1] := sc.getCurrent()->toInteger() ; 
    bydol[i+1][D+1] := sc.getCurrent()->toInteger() ; 
    bydol[i+1][L+1] := sc.getCurrent()->toInteger() ; 
 )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i <= 3 do ( (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
         var j : int ; j := 1 ; while j < n + 1 do ( (         var k : int ; k := 1 ; while k < m + 1 do ( (     dp[j+1][k+1] := dp[j - 1+1][k+1] ; 
         var l : int ; l := 1 ; while l * bydol[j - 1+1][C+1] <= k do ( (     dp[j+1][k+1] := Set{dp[j+1][k+1], dp[j - 1+1][k - l * bydol[j - 1+1][C+1]+1] + l * bydol[j - 1+1][i+1]}->max() )  ;     l := l + 1 ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
     if (max < dp[n+1][m+1]) then (     max := dp[n+1][m+1] ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int N,M ;
  static int[] C=new int[300];
  static int[][] P=new int[300][3];
  public static void main(String[] args){
    int[] dp=new int[301];
    while(sc.hasNext()){
      N=sc.nextInt();
      M=sc.nextInt();
      for(int i=0 ; i<N ; ++i){
        sc.nextLine();
        sc.nextLine();
        C[i]=sc.nextInt();
        P[i][0]=sc.nextInt();
        P[i][1]=sc.nextInt();
        P[i][2]=sc.nextInt();
      }
      int ans=0 ;
      for(int i=0 ; i<3 ; ++i){
        Arrays.fill(dp,-1);
        dp[M]=0 ;
        for(int j=0 ; j<N ; ++j){
          for(int k=M-C[j]; k>=0 ; --k){
            if(dp[k+C[j] ]!=-1){
              dp[k]=Math.max(dp[k],dp[k+C[j] ]+P[j][i]);
            }
          }
        }
        for(int j=0 ; j<=M ; ++j){
          ans=Math.max(ans,dp[j]);
        }
      }
      System.out.println(ans);
      System.gc();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int;
  static   attribute C : Sequence(int) := Integer.subrange(1,300)->collect(0);
  static   attribute P : Sequence(Sequence(int)) := Integer.subrange(1,300)->collect(Integer.subrange(1,3)->collect(0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var dp : Sequence(int) ; dp := Integer.subrange(1,301)->collect(0) ;
     while (sc.hasNext()) do (     N := sc.getCurrent()->toInteger() ; 
     M := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < N do ( (     skip ; 
     skip ; 
    C[i+1] := sc.getCurrent()->toInteger() ; 
    P[i+1][0+1] := sc.getCurrent()->toInteger() ; 
    P[i+1][1+1] := sc.getCurrent()->toInteger() ; 
    P[i+1][2+1] := sc.getCurrent()->toInteger() ; 
 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     dp := dp->collect(-1) ; 
     dp[M+1] := 0 ; 
         var j : int ; j := 0 ; while j < N do ( (         var k : int ; k := M - C[j+1] ; while k >= 0 do ( (     if (dp[k + C[j+1]+1] /= -1) then (     dp[k+1] := Set{dp[k+1], dp[k + C[j+1]+1] + P[j+1][i+1]}->max() ) else skip )  ;     k := k - 1 ) )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j <= M do ( (     ans := Set{ans, dp[j+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
gc() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int[][] a=new int[n][4];
      for(int i=0 ; i<n ; i++){
        sc.nextLine();
        sc.nextLine();
        for(int j=0 ; j<4 ; j++)a[i][j]=sc.nextInt();
      }
      int max=0 ;
      for(int k=1 ; k<4 ; k++){
        int[][] dp=new int[n+1][m+1];
        for(int i=0 ; i<n ; i++){
          for(int j=0 ; j<=m ; j++){
            if(j<a[i][0])dp[i+1][j]=dp[i][j];
            else dp[i+1][j]=Math.max(dp[i][j],dp[i+1][j-a[i][0] ]+a[i][k]);
          }
        }
        max=Math.max(max,dp[n][m]);
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,4)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     skip ; 
     skip ; 
         var j : int ; j := 0 ; while j < 4 do (     a[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
        var k : int ; k := 1 ; while k < 4 do ( (     var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j <= m do ( (     if (j < a[i+1][0+1]) then     dp[i + 1+1][j+1] := dp[i+1][j+1] ; else     dp[i + 1+1][j+1] := Set{dp[i+1][j+1], dp[i + 1+1][j - a[i+1][0+1]+1] + a[i+1][k+1]}->max() ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     max := Set{max, dp[n+1][m+1]}->max() )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  int n,c ;
  int dp[];
  int max=0 ;
  int value[][];
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; sc.hasNext(); ){
      n=sc.nextInt();
      c=sc.nextInt();
      value=new int[n][4];
      max=0 ;
      for(int i=0 ; i<n ; i++){
        while(! sc.hasNextInt())sc.next();
        for(int j=0 ; j<4 ; j++)value[i][j]=sc.nextInt();
      }
      for(int i=1 ; i<=3 ; i++){
        dp=new int[c+1];
        fill(dp,-1);
        dp[0]=0 ;
        for(int j=0 ; j<=c ; j++)for(int k=0 ; k<n ; k++){
          if(dp[j]>=0 && j+value[k][0]<=c)dp[j+value[k][0] ]=max(dp[j+value[k][0] ],dp[j]+value[k][i]);
        }
        for(int j=c ; j>=0 ; j--){
          if(dp[j]>0){
            max=max(max,dp[j]);
          }
        }
      }
      System.out.println(max);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute n : int;
   attribute dp : Sequence(int);
   attribute max : int := 0;
   attribute value : Sequence(Sequence(int));
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while sc.hasNext() do ( (     n := sc.getCurrent()->toInteger() ; 
     c := sc.getCurrent()->toInteger() ; 
    value := Integer.subrange(1,n)->collect(Integer.subrange(1,4)->collect(0)) ; 
    max := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     while (not(sc.hasNextInt())) do     skip ; ; 
         var j : int ; j := 0 ; while j < 4 do (     value[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= 3 do ( (     dp := Integer.subrange(1,c + 1)->collect(0) ; 
     execute fill(dp, -1) ; 
    dp[0+1] := 0 ; 
        var j : int ; j := 0 ; while j <= c do (         var k : int ; k := 0 ; while k < n do ( (     if (dp[j+1] >= 0 & j + value[k+1][0+1] <= c) then     dp[j + value[k+1][0+1]+1] := Set{dp[j + value[k+1][0+1]+1], dp[j+1] + value[k+1][i+1]}->max() ; else skip )  ;     k := k + 1 ) ;  ;     j := j + 1 ) ; 
        var j : int ; j := c ; while j >= 0 do ( (     if (dp[j+1] > 0) then (     max := Set{max, dp[j+1]}->max() ) else skip )  ;     j := j - 1 ) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void swap(int a,int b,int c,int d){
    a=a+b ;
    b=a-b ;
    a=a-b ;
    b=b+c ;
    c=b-c ;
    b=b-c ;
    c=c+d ;
    d=c-d ;
    c=c-d ;
    System.out.println("values after "+"swapping are : ");
    System.out.println("a="+a);
    System.out.println("b="+b);
    System.out.println("c="+c);
    System.out.println("d="+d);
  }
  public static void main(String[] args){
    int a=1 ;
    int b=2 ;
    int c=3 ;
    int d=4 ;
    System.out.println("values before "+"swapping are : ");
    System.out.println("a="+a);
    System.out.println("b="+b);
    System.out.println("c="+c);
    System.out.println("d="+d);
    System.out.println("");
    swap(a,b,c,d);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation swap( a : int, b : int, c : int, d : int) : void
  pre: true
  post: true
  activity: (     a := a + b ; 
     b := a - b ; 
    a := a - b ; 
    b := b + c ; 
    c := b - c ; 
    b := b - c ; 
    c := c + d ; 
    d := c - d ; 
    c := c - d ; 
    OclFile["System.out"].println("values after " + "swapping are : ") ; 
    OclFile["System.out"].println("a=" + a) ; 
    OclFile["System.out"].println("b=" + b) ; 
    OclFile["System.out"].println("c=" + c) ; 
    OclFile["System.out"].println("d=" + d) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 1 ;
     var b : int ; b := 2 ;
    var c : int ; c := 3 ;
    var d : int ; d := 4 ;
    OclFile["System.out"].println("values before " + "swapping are : ") ; 
    OclFile["System.out"].println("a=" + a) ; 
    OclFile["System.out"].println("b=" + b) ; 
    OclFile["System.out"].println("c=" + c) ; 
    OclFile["System.out"].println("d=" + d) ; 
    OclFile["System.out"].println("") ; 
    execute swap(a, b, c, d) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minsteps(int n,int m){
    if(m>n){
      return-1 ;
    }
    else {
      return((n+1)/2+m-1)/m*m ;
    }
  }
  public static void main(String[] args){
    int n=17,m=4 ;
    int ans=minsteps(n,m);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minsteps( n : int, m : int) : int
  pre: true
  post: true
  activity: (     if (m > n) then (     return -1 ) else (     return ((n + 1) / 2 + m - 1) / m * m ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 17 ;
    var m : int ; m := 4 ;
     var ans : int ; ans := minsteps(n, m) ;
     OclFile["System.out"].println(ans) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
public class CP2 {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    String n=sc.next();
    int l=n.length(),i=0 ;
    long r=0 ;
    while(l!=0){
      char ch=n.charAt(i);
      int d=ch-'0' ;
      if(d>=5){
        if(i==0 && d==9){
          r=d+r*10 ;
        }
        else {
          int t=9-d ;
          r=t+r*10 ;
        }
      }
      else {
        r=d+r*10 ;
      }
      i++;
      l--;
    }
    System.out.println(r);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CP2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : String ; n := sc.getCurrent() ;
    var l : int ; l := n->size() ;
    var i : int ; i := 0 ;
    var r : long ; r := 0 ;
    while (l /= 0) do (     var ch : String ; ch := n->at(i+1) ;
     var d : int ; d := (ch)->char2byte() - ('0')->char2byte() ;
    if (d >= 5) then (     if (i = 0 & d = 9) then (     r := d + r * 10 ) else (     var t : int ; t := 9 - (d)->char2byte() ;
     r := t + r * 10 ) ) else (     r := d + r * 10 ) ;  
    i := i + 1 ; 
    l := l - 1 ; 
 ) ; 
    OclFile["System.out"].println(r) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int setmiddlebits(int n){
    n |=n>>1 ;
    n |=n>>2 ;
    n |=n>>4 ;
    n |=n>>8 ;
    n |=n>>16 ;
    return(n>>1)^ 1 ;
  }
  static int togglemiddlebits(int n){
    if(n==1)return 1 ;
    return n ^ setmiddlebits(n);
  }
  public static void main(String[] args){
    int n=9 ;
    System.out.println(togglemiddlebits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation setmiddlebits( n : int) : int
  pre: true
  post: true
  activity: (     n := MathLib.bitwiseOr(n, (n/(2->pow(1)))->oclAsType(long)) ; 
     n := MathLib.bitwiseOr(n, (n/(2->pow(2)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(4)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(8)))->oclAsType(long)) ; 
    n := MathLib.bitwiseOr(n, (n/(2->pow(16)))->oclAsType(long)) ; 
    return ((n/(2->pow(1)))->oclAsType(long)) xor 1 
 );
  static   operation togglemiddlebits( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 1 else skip ; 
     return n xor setmiddlebits(n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     OclFile["System.out"].println(togglemiddlebits(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t1=sc.nextInt();
    int t2=sc.nextInt();
    int r1=sc.nextInt();
    int r2=sc.nextInt();
    if(r1==-1 || r2==-1){
      r1=-t1 ;
      r2=-t2 ;
    }
    if(r1==r2){
      System.out.println("Draw");
    }
    else if(r1<r2){
      System.out.println("Bob");
    }
    else {
      System.out.println("Alice");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t1 : int ; t1 := sc.getCurrent()->toInteger() ;
    var t2 : int ; t2 := sc.getCurrent()->toInteger() ;
    var r1 : int ; r1 := sc.getCurrent()->toInteger() ;
    var r2 : int ; r2 := sc.getCurrent()->toInteger() ;
    if (r1 = -1 or r2 = -1) then (     r1 := -t1 ; 
     r2 := -t2 ) else skip ; 
    if (r1 = r2) then (     OclFile["System.out"].println("Draw") ) else     if (r1 < r2) then (     OclFile["System.out"].println("Bob") ) else (     OclFile["System.out"].println("Alice") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int _log(double x,double base){
    return(int)(Math.log(x)/Math.log(base));
  }
  static double recursiveLogStar(double n,double b){
    if(n>1.0)return 1.0+recursiveLogStar(_log(n,b),b);
    else return 0 ;
  }
  public static void main(String[] args){
    int n=100,base=5 ;
    System.out.println("Log*("+n+")="+recursiveLogStar(n,base));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation _log( x : double, base : double) : int
  pre: true
  post: true
  activity: (     return ((x)->log() / (base)->log())->oclAsType(int) );
  static   operation recursiveLogStar( n : double, b : double) : double
  pre: true
  post: true
  activity: (     if (n > 1.0) then     return 1.0 + recursiveLogStar(_log(n, b), b) else     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 100 ;
    var base : int ; base := 5 ;
     OclFile["System.out"].println("Log*(" + n + ")=" + recursiveLogStar(n, base)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int product(int a[],int n){
    int ans=1 ;
    int val=(int)Math.pow(2,n-1);
    for(int i=0 ; i<n ; i++){
      ans*=(int)Math.pow(a[i],val);
    }
    return ans ;
  }
  public static void main(String[] args){
    int n=2 ;
    int a[]={
      3,7 };
      System.out.println(product(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation product( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
     var val : int ; val := 2->pow(n - 1)->oclAsType(int) ;
         var i : int ; i := 0 ; while i < n do ( (     ans := ans*(a[i+1]->pow(val)->oclAsType(int)) )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2 ;
     var a : Sequence(int) ; a := Sequence{3,7} ;
     OclFile["System.out"].println(product(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.io.*;
import java.util.*;
class BinaryToString {
  static String printBinary(double num){
    if(num>=1 || num<=0)return "ERROR" ;
    StringBuilder binary=new StringBuilder();
    double frac=0.5 ;
    binary.append(".");
    while(num>0){
      if(binary.length()>=32)return "ERROR" ;
      if(num>=frac){
        binary.append(1);
        num-=frac ;
      }
      else binary.append(0);
      frac/=2 ;
    }
    return binary.toString();
  }
  public static void main(String[] args){
    double num1=0.625 ;
    String output=printBinary(num1);
    System.out.println("(0"+output+")in base 2");
    double num2=0.72 ;
    output=printBinary(num2);
    System.out.println("("+output+")");
  }
}
------------------------------------------------------------
OCL File:
---------
 class BinaryToString {
  static   operation printBinary( num : double) : String
  pre: true
  post: true
  activity: (     if (num >= 1 or num <= 0) then     return "ERROR" else skip ; 
     var binary : String ; binary := StringLib.newString() ;
    var frac : double ; frac := 0.5 ;
    binary := binary + StringLib.newString(".") ; 
    while (num > 0) do (     if (binary->size() >= 32) then     return "ERROR" else skip ; 
     if (num >= frac) then (     binary := binary + StringLib.newString(1) ; 
     num := num-(frac) ) else     binary := binary + StringLib.newString(0) ; ;  
     frac := frac/(2) ) ; 
    return binary+"" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num1 : double ; num1 := 0.625 ;
     var output : String ; output := printBinary(num1) ;
    OclFile["System.out"].println("(0" + output + ")in base 2") ; 
    var num2 : double ; num2 := 0.72 ;
    output := printBinary(num2) ; 
    OclFile["System.out"].println("(" + output + ")") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
import java.io.*;
import java.util.*;
class BinaryToString {
  static String printBinary(double num){
    if(num>=1 || num<=0)return "ERROR" ;
    StringBuilder binary=new StringBuilder();
    binary.append(".");
    while(num>0){
      if(binary.length()>=32)return "ERROR" ;
      double r=num*2 ;
      if(r>=1){
        binary.append(1);
        num=r-1 ;
      }
      else {
        binary.append(0);
        num=r ;
      }
    }
    return binary.toString();
  }
  public static void main(String[] args){
    double num1=0.625 ;
    String output=printBinary(num1);
    System.out.println("(0"+output+")in base 2");
    double num2=0.72 ;
    output=printBinary(num2);
    System.out.println("("+output+")");
  }
}
------------------------------------------------------------
OCL File:
---------
 class BinaryToString {
  static   operation printBinary( num : double) : String
  pre: true
  post: true
  activity: (     if (num >= 1 or num <= 0) then     return "ERROR" else skip ; 
     var binary : String ; binary := StringLib.newString() ;
    binary := binary + StringLib.newString(".") ; 
    while (num > 0) do (     if (binary->size() >= 32) then     return "ERROR" else skip ; 
     var r : double ; r := num * 2 ;
     if (r >= 1) then (     binary := binary + StringLib.newString(1) ; 
     num := (r)->char2byte() - 1 ) else (     binary := binary + StringLib.newString(0) ; 
     num := r ) ) ; 
    return binary+"" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num1 : double ; num1 := 0.625 ;
     var output : String ; output := printBinary(num1) ;
    OclFile["System.out"].println("(0" + output + ")in base 2") ; 
    var num2 : double ; num2 := 0.72 ;
    output := printBinary(num2) ; 
    OclFile["System.out"].println("(" + output + ")") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public class Pair {
    char col ;
    int len ;
    Pair(char a,int b){
      col=a ;
      len=b ;
    }
  }
  static Scanner sc=new Scanner(System.in);
  public void solve(){
    String str=sc.next();
    List<Pair>lst=new ArrayList<Pair>();
    int n=str.length();
    int j=0 ;
    int len=1 ;
    for(int i=1 ; i<n ; i++){
      if(str.charAt(i)==str.charAt(j))len++;
      else {
        lst.add(new Pair(str.charAt(j),len));
        j=i ;
        len=1 ;
      }
    }
    lst.add(new Pair(str.charAt(j),len));
    if(lst.size()% 2==0){
      System.out.println("0");
      return ;
    }
    int mid=(lst.size()-1)/2 ;
    if(lst.get(mid).len<2){
      System.out.println("0");
      return ;
    }
    if(mid==0){
      System.out.println(lst.get(mid).len+1);
      return ;
    }
    boolean flg=true ;
    int l=mid-1 ;
    int h=mid+1 ;
    while(l>=0){
      if(lst.get(l).col!=lst.get(h).col){
        flg=false ;
        break ;
      }
      else if((lst.get(l).len+lst.get(h).len)<3){
        flg=false ;
        break ;
      }
      else {
        l--;
        h++;
      }
    }
    if(flg){
      System.out.println(lst.get(mid).len+1);
    }
    else System.out.println("0");
  }
  public static void main(String[] args){
    int t=1 ;
    Main obj=new Main();
    while(t-->0)obj.solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class Pair {
   attribute col : String;
   attribute len : int;
   static operation newPair( a : String, b : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(a, b);
    return self );
  operation initialise( a : String, b : int) : void
  pre: true  post: true
  activity: (     col := a ; 
     len := b );
}
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation solve() : void
  pre: true
  post: true
  activity: (     var str : String ; str := sc.getCurrent() ;
     var lst : Sequence(Map) ; lst := Sequence{} ;
    var n : int ; n := str->size() ;
    var j : int ; j := 0 ;
    var len : int ; len := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     if (str->at(i+1) = str->at(j+1)) then     len := len + 1 ; else (     lst := lst->including(Map(str->at(j+1), len)) ; 
     j := i ; 
     len := 1 ) )  ;     i := i + 1 ) ; 
    lst := lst->including(Map(str->at(j+1), len)) ; 
    if (lst->size() mod 2 = 0) then (     OclFile["System.out"].println("0") ; 
     return ) else skip ; 
    var mid : int ; mid := (lst->size() - 1) / 2 ;
    if (lst->at(mid+1).len < 2) then (     OclFile["System.out"].println("0") ; 
     return ) else skip ; 
    if (mid = 0) then (     OclFile["System.out"].println(lst->at(mid+1).len + 1) ; 
     return ) else skip ; 
    var flg : boolean ; flg := true ;
    var l : int ; l := mid - 1 ;
    var h : int ; h := mid + 1 ;
    while (l >= 0) do (     if (lst->at(l+1).col /= lst->at(h+1).col) then (     flg := false ; 
     break ) else     if ((lst->at(l+1).len + lst->at(h+1).len) < 3) then (     flg := false ; 
     break ) else (     l := l - 1 ; 
     h := h + 1 ) ;  ) ; 
    if (flg) then (     OclFile["System.out"].println(lst->at(mid+1).len + 1) ) else     OclFile["System.out"].println("0") ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
     var obj : Main ; obj := Main.newMain() ;
         while (t > 0) do (        t := t - 1 ;     skip ;     obj.solve() ; ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ChewbacchaAndNumber {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String str=sc.next();
    String x="" ;
    for(int i=0 ; i<str.length(); i++){
      String s=String.valueOf(str.charAt(i));
      int k=Integer.parseInt(s);
      if(k==9 && i==0){
        x=x.concat("9");
      }
      else {
        int d=9-k ;
        if(d<k){
          x=x.concat(String.valueOf(d));
        }
        else {
          x=x.concat(String.valueOf(k));
        }
      }
    }
    System.out.println(x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ChewbacchaAndNumber {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ; str := sc.getCurrent() ;
    var x : String ; x := "" ;
        var i : int ; i := 0 ; while i < str->size() do ( (     var s : String ; s := ((str->at(i+1)) + "") ;
     var k : int ; k := (s)->toInteger() ;
     if (k = 9 & i = 0) then (     x := x+"9" ) else (     var d : int ; d := 9 - (k)->char2byte() ;
     if (d < k) then (     x := x+((d) + "") ) else (     x := x+((k) + "") ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(x) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class CodeforcesA {
  public static void main(String[] args){
    FastReader read=new FastReader();
    int t=read.nextInt();
    while(t-->0){
      String st=read.next();
      int cnt=0 ;
      for(char ch : st.toCharArray()){
        if(ch=='N')cnt++;
      }
      System.out.println(cnt==1 ? "No" : "Yes");
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CodeforcesA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var read : FastReader ; read := FastReader.newFastReader() ;
     var t : int ; t := read.nextInt() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var st : String ; st := read.next() ;
     var cnt : int ; cnt := 0 ;
     for (ch : st->characters()) do ( (     if (ch = 'N') then     cnt := cnt + 1 ; else skip )  ) ; 
     OclFile["System.out"].println(if cnt = 1 then "No" else "Yes" endif) ) ;  ) );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class B {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    int[] a=new int[300000];
    int[] loc=new int[300000];
    String s=fs.next();
    s+='a' ;
    int num=0 ;
    int len=s.length()-1 ;
    int t=0 ;
    for(int i=0 ; i<len ; i++){
      a[i]=++t ;
      if(s.charAt(i)!=s.charAt(i+1)){
        t=0 ;
        loc[++num]=i ;
      }
    }
    if(num % 2!=1){
      System.out.println(0);
      System.exit(0);
    }
    for(int i=1 ; i<=num/2+1 ; i++){
      if(s.charAt(loc[i])!=s.charAt(loc[num+1-i])|| a[loc[i] ]+a[loc[num+1-i] ]<3){
        System.out.println(0);
        System.exit(0);
      }
    }
    System.out.println(a[loc[num/2+1] ]+1);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! 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());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var a : Sequence(int) ; a := Integer.subrange(1,300000)->collect(0) ;
    var loc : Sequence(int) ; loc := Integer.subrange(1,300000)->collect(0) ;
    var s : String ; s := fs.next() ;
    s := s+('a') ; 
    var num : int ; num := 0 ;
    var len : int ; len := s->size() - 1 ;
    var t : int ; t := 0 ;
        var i : int ; i := 0 ; while i < len do ( (         t := t + 1 ;
 a[i+1] := t  ; 
     if (s->at(i+1) /= s->at(i + 1+1)) then (     t := 0 ; 
         num := num + 1 ;
 loc[num+1] := i  ) else skip )  ;     i := i + 1 ) ; 
    if (num mod 2 /= 1) then (     OclFile["System.out"].println(0) ; 
 OclProcess.exit(0) ) else skip ; 
        var i : int ; i := 1 ; while i <= num / 2 + 1 do ( (     if (s->at(loc[i+1]+1) /= s->at(loc[num + 1 - i+1]+1) or a[loc[i+1]+1] + a[loc[num + 1 - i+1]+1] < 3) then (     OclFile["System.out"].println(0) ; 
 OclProcess.exit(0) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a[loc[num / 2 + 1+1]+1] + 1) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int gcd(int x,int y){
    if(x % y!=0)return gcd(y,x % y);
    else return y ;
  }
  public static void main(String[] arts){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int y=sc.nextInt();
    System.out.println(gcd(x,y));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation gcd( x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (x mod y /= 0) then     return gcd(y, x mod y) else     return y );
  static   operation main( arts : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(gcd(x, y)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
import java.math.BigDecimal ;
public class Main {
  static InputReader in ;
  static PrintWriter out ;
  static class Solution {
    void solve()throws IOException {
      int x=in.nextInt();
      int y=in.nextInt();
      int gcd=gcd(x,y);
      out.println(gcd);
    }
    int gcd(int x,int y){
      if(x<y){
        int tmp=x ;
        x=y ;
        y=tmp ;
      }
      while(y>0){
        int r=x % y ;
        x=y ;
        y=r ;
      }
      return x ;
    }
  }
  public static void main(String[] args)throws IOException {
    in=new InputReader(System.in);
    out=new PrintWriter(System.out);
    Solution solver=new Solution();
    solver.solve();
    out.close();
  }
  static class InputReader {
    public BufferedReader br ;
    public StringTokenizer st ;
    public InputReader(InputStream stream){
      br=new BufferedReader(new InputStreamReader(stream));
    }
    public int nextInt()throws IOException {
      while(st==null || ! st.hasMoreTokens()){
        st=new StringTokenizer(br.readLine());
      }
      return Integer.parseInt(st.nextToken());
    }
    public long nextLong()throws IOException {
      while(st==null || ! st.hasMoreTokens()){
        st=new StringTokenizer(br.readLine());
      }
      return Long.parseLong(st.nextToken());
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens()){
        st=new StringTokenizer(br.readLine());
      }
      return st.nextToken();
    }
    public double nextDouble()throws IOException {
      while(st==null || ! st.hasMoreTokens()){
        st=new StringTokenizer(br.readLine());
      }
      return Double.parseDouble(st.nextToken());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : InputReader;
  static   attribute out : OclFile;
  static class Solution {
   operation solve() : void
  pre: true
  post: true
  activity: (     var x : int ; x := in.nextInt() ;
     var y : int ; y := in.nextInt() ;
     var gcd : int ; gcd := gcd(x, y) ;
     skip );
   operation gcd( x : int, y : int) : int
  pre: true
  post: true
  activity: (     if (x < y) then (     var tmp : int ; tmp := x ;
     x := y ; 
     y := tmp ) else skip ; 
     while (y > 0) do (     var r : int ; r := x mod y ;
     x := y ; 
     y := r ) ; 
     return x );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := InputReader.newInputReader(OclFile["System.in"]) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    var solver : Solution ; solver := Solution.newSolution() ;
    solver.solve() ; 
    skip ; 
 );
  static class InputReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return (st.next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return (st.next())->toLong() );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return (st.next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int a ;
    int b ;
    a=input.nextInt();
    b=input.nextInt();
    input.close();
    if(GreatestCommonDivisor(a,b)!=-1){
      System.out.println(GreatestCommonDivisor(a,b));
    }
  }
  public static int GreatestCommonDivisor(int a,int b){
    if((a>=1)&&(a<=1000000000)&&(b>=1)&&(b<=1000000000)){
      if(a>b){
        if((a % b)==0){
          return b ;
        }
        else {
          return GreatestCommonDivisor(b,a % b);
        }
      }
      else if(b>a){
        if((b % a)==0){
          return a ;
        }
        else {
          return GreatestCommonDivisor(a,b % a);
        }
      }
      else {
        return a ;
      }
    }
    else {
      System.out.println("Enter a number between 1 and 1000000000 for both numbers.");
      return-1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ;
    var b : int ;
    a := input.getCurrent()->toInteger() ; 
    b := input.getCurrent()->toInteger() ; 
    skip ; 
    if (GreatestCommonDivisor(a, b) /= -1) then (     OclFile["System.out"].println(GreatestCommonDivisor(a, b)) ) else skip ; 
 );
  static   operation GreatestCommonDivisor( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if ((a >= 1) & (a <= 1000000000) & (b >= 1) & (b <= 1000000000)) then (     if (a > b) then (     if ((a mod b) = 0) then (     return b ) else (     return GreatestCommonDivisor(b, a mod b) ) ) else     if (b > a) then (     if ((b mod a) = 0) then (     return a ) else (     return GreatestCommonDivisor(a, b mod a) ) ) else (     return a ) ;  ) else (     OclFile["System.out"].println("Enter a number between 1 and 1000000000 for both numbers.") ; 
     return -1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Main {
  private static FastScanner sc=new FastScanner();
  public static void main(String[] args){
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(b>a){
      int temp=b ;
      b=a ;
      a=temp ;
    }
    int c=a % b ;
    while(c!=0){
      a=b ;
      b=c ;
      c=a % b ;
    }
    System.out.println(b);
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : FastScanner := FastScanner.newFastScanner();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.nextInt() ;
     var b : int ; b := sc.nextInt() ;
    if (b > a) then (     var temp : int ; temp := b ;
     b := a ; 
     a := temp ) else skip ; 
    var c : int ; c := a mod b ;
    while (c /= 0) do (     a := b ; 
     b := c ; 
     c := a mod b ) ; 
    OclFile["System.out"].println(b) ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Random ;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n1=scanner.nextInt();
    int n2=scanner.nextInt();
    scanner.close();
    System.out.println(gcd(n1,n2));
  }
  public static int gcd(int num1,int num2){
    if(num1==num2)return num1 ;
    if(num1>num2)return gcd(num1-num2,num2);
    return gcd(num1,num2-num1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n1 : int ; n1 := scanner.getCurrent()->toInteger() ;
    var n2 : int ; n2 := scanner.getCurrent()->toInteger() ;
    skip ; 
    OclFile["System.out"].println(gcd(n1, n2)) ; 
 );
  static   operation gcd( num1 : int, num2 : int) : int
  pre: true
  post: true
  activity: (     if (num1 = num2) then     return num1 else skip ; 
     if (num1 > num2) then     return gcd(num1 - num2, num2) else skip ; 
     return gcd(num1, num2 - num1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    int c[][]=new int[10][10];
    int A[][]=new int[H][W];
    for(int i=0 ; i<10 ; i++){
      for(int j=0 ; j<10 ; j++){
        c[i][j]=sc.nextInt();
      }
    }
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        A[i][j]=sc.nextInt();
      }
    }
    for(int k=0 ; k<10 ; k++){
      for(int i=0 ; i<10 ; i++){
        for(int j=0 ; j<10 ; j++){
          c[i][j]=Math.min(c[i][j],c[i][k]+c[k][j]);
        }
      }
    }
    int sum=0 ;
    for(int i=0 ; i<H ; i++){
      for(int j=0 ; j<W ; j++){
        if(A[i][j]==-1)continue ;
        sum+=c[A[i][j] ][1];
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,10)->collect(Integer.subrange(1,10)->collect(0)) ;
    var A : Sequence(Sequence(int)) ; A := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
        var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < 10 do ( (     c[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     A[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < 10 do ( (         var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < 10 do ( (     c[i+1][j+1] := Set{c[i+1][j+1], c[i+1][k+1] + c[k+1][j+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (A[i+1][j+1] = -1) then     continue else skip ; 
     sum := sum+(c[A[i+1][j+1]+1][1+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int[][] c ;
  static boolean[] passed ;
  static int maryoku ;
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt(),w=sc.nextInt();
    c=new int[10][10];
    for(int i=0 ; i<10 ; i++){
      for(int j=0 ; j<10 ; j++){
        c[i][j]=sc.nextInt();
      }
    }
    int[][] a=new int[h][w];
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        a[i][j]=sc.nextInt();
      }
    }
    passed=new boolean[10];
    int[] m=new int[10];
    for(int i=0 ; i<=9 ; i++){
      Arrays.fill(passed,false);
      maryoku=10000 ;
      dfs(i,0);
      m[i]=maryoku ;
    }
    int ans=0 ;
    for(int i=0 ; i<h ; i++){
      for(int j=0 ; j<w ; j++){
        if(a[i][j]!=-1)ans+=m[a[i][j] ];
      }
    }
    System.out.println(ans);
  }
  public static void dfs(int now,int count){
    if(now==1){
      maryoku=Math.min(maryoku,count);
      return ;
    }
    passed[now]=true ;
    for(int i=0 ; i<=9 ; i++){
      if(! passed[i] && now!=i){
        dfs(i,count+c[now][i]);
        passed[i]=false ;
      }
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute c : Sequence(Sequence(int));
  static   attribute passed : Sequence(boolean);
  static   attribute maryoku : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    c := Integer.subrange(1,10)->collect(Integer.subrange(1,10)->collect(0)) ; 
        var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < 10 do ( (     c[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,h)->collect(Integer.subrange(1,w)->collect(0)) ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     a[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    passed := Integer.subrange(1,10)->collect(false) ; 
    var m : Sequence(int) ; m := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i <= 9 do ( (     passed := passed->collect(false) ; 
     maryoku := 10000 ; 
     execute dfs(i, 0) ; 
     m[i+1] := maryoku )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < h do ( (         var j : int ; j := 0 ; while j < w do ( (     if (a[i+1][j+1] /= -1) then     ans := ans+(m[a[i+1][j+1]+1]) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation dfs( now : int, count : int) : void
  pre: true
  post: true
  activity: (     if (now = 1) then (     maryoku := Set{maryoku, count}->min() ; 
     return ) else skip ; 
     passed[now+1] := true ; 
         var i : int ; i := 0 ; while i <= 9 do ( (     if (not(passed[i+1]) & now /= i) then (     execute dfs(i, count + c[now+1][i+1]) ; 
     passed[i+1] := false ) else skip )  ;     i := i + 1 ) ; 
     return );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void solve(int a,int b){
    if(a==0 && b==0){
      System.out.println("NO");
      return ;
    }
    int n=a+b ;
    if(n % 2==0){
      System.out.println(a==b ? "YES" : "NO");
    }
    else {
      if(a+1==b || b+1==a){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int c=scan.nextInt();
    solve(n,c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( a : int, b : int) : void
  pre: true
  post: true
  activity: (     if (a = 0 & b = 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
     var n : int ; n := a + b ;
     if (n mod 2 = 0) then (     OclFile["System.out"].println(if a = b then "YES" else "NO" endif) ) else (     if (a + 1 = b or b + 1 = a) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
     var c : int ; c := scan.getCurrent()->toInteger() ;
     execute solve(n, c) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n,m ;
    int edge[][]=new int[15][15];
    int a[][]=new int[205][205];
    n=in.nextInt();
    m=in.nextInt();
    for(int i=0 ; i<=9 ; i++)for(int j=0 ; j<=9 ; j++)edge[i][j]=in.nextInt();
    for(int k=0 ; k<=9 ; k++)for(int i=0 ; i<=9 ; i++)for(int j=0 ; j<=9 ; j++)edge[i][j]=Math.min(edge[i][j],edge[i][k]+edge[k][j]);
    long ans=0 ;
    for(int i=1 ; i<=n ; i++)for(int j=1 ; j<=m ; j++){
      a[i][j]=in.nextInt();
      if(a[i][j]!=-1)ans+=edge[a[i][j] ][1];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var m : int ;
    var edge : Sequence(Sequence(int)) ; edge := Integer.subrange(1,15)->collect(Integer.subrange(1,15)->collect(0)) ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,205)->collect(Integer.subrange(1,205)->collect(0)) ;
    n := in.getCurrent()->toInteger() ; 
    m := in.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i <= 9 do (         var j : int ; j := 0 ; while j <= 9 do (     edge[i+1][j+1] := in.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k <= 9 do (         var i : int ; i := 0 ; while i <= 9 do (         var j : int ; j := 0 ; while j <= 9 do (     edge[i+1][j+1] := Set{edge[i+1][j+1], edge[i+1][k+1] + edge[k+1][j+1]}->min() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ;  ;     k := k + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do (         var j : int ; j := 1 ; while j <= m do ( (     a[i+1][j+1] := in.getCurrent()->toInteger() ; 
     if (a[i+1][j+1] /= -1) then     ans := ans+(edge[a[i+1][j+1]+1][1+1]) ; else skip )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.*;
public class App {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws Exception {
    if(System.getProperty("ONLINE_JUDGE")==null){
      File inputFile=new File("/Users/vipinjain/self/cp/input.txt");
      File outputFile=new File("/Users/vipinjain/self/cp/output.txt");
      br=new BufferedReader(new FileReader(inputFile));
      bw=new BufferedWriter(new FileWriter(outputFile));
    }
    int tests ;
    tests=Integer.parseInt(br.readLine());
    while(tests-->0){
      solve();
    }
    bw.flush();
    bw.close();
    br.close();
  }
  static void solve()throws Exception {
    String str=br.readLine();
    int count=0 ;
    for(int i=0 ; i<str.length(); ++i){
      if(str.charAt(i)=='N'){
        count++;
      }
    }
    String result=count==1 ? "NO" : "YES" ;
    bw.write(result+"\n");
  }
  static String queueOutput(Queue<Integer>queue){
    StringBuilder sb=new StringBuilder();
    for(Integer num : queue){
      sb.append(num+" ");
    }
    return sb.toString().trim();
  }
  static int gcd(int a,int b){
    if(a==0){
      return b ;
    }
    return gcd(b % a,a);
  }
  static boolean isPrime(long n){
    for(long i=2 ; i*i<=n ; i++){
      if(n % i==0){
        return false ;
      }
    }
    return true ;
  }
  static long minDivisor(long n){
    for(long i=2 ; i*i<=n ; ++i){
      if(n % i==0){
        return i ;
      }
    }
    return n ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null) then (     var inputFile : OclFile ; inputFile := OclFile("/Users/vipinjain/self/cp/input.txt") ;
     var outputFile : OclFile ; outputFile := OclFile("/Users/vipinjain/self/cp/output.txt") ;
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputFile)) ; 
     bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputFile)) ) else skip ; 
     var tests : int ;
    tests := (br.readLine())->toInteger() ; 
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var str : String ; str := br.readLine() ;
     var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = 'N') then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    var result : String ; result := if count = 1 then "NO" else "YES" endif ;
    skip ; 
 );
  static   operation queueOutput( queue : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     for (num : queue) do ( (     sb := sb + StringLib.newString(num + " ") )  ) ; 
     return sb+""->trim() );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then (     return b ) else skip ; 
     return gcd(b mod a, a) );
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (         var i : long ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation minDivisor( n : long) : long
  pre: true
  post: true
  activity: (         var i : long ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     return i ) else skip )  ;     i := i + 1 ) ; 
     return n );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long[][][] warshall=new long[11][10][10];
    int h=sc.nextInt();
    int w=sc.nextInt();
    for(int i=0 ; i<10 ; i++){
      for(int j=0 ; j<10 ; j++){
        warshall[0][i][j]=sc.nextInt();
      }
    }
    for(int i=0 ; i<10 ; i++){
      for(int j=0 ; j<10 ; j++){
        for(int k=0 ; k<10 ; k++){
          warshall[i+1][j][k]=Math.min(warshall[i][j][k],warshall[i][j][i]+warshall[i][i][k]);
        }
      }
    }
    long ans=0 ;
    int tmp ;
    for(int i=0 ; i<h*w ; i++){
      tmp=sc.nextInt();
      if(tmp>=0)ans+=warshall[10][tmp][1];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var warshall : Sequence(Sequence(Sequence(long))) ; warshall := Integer.subrange(1,11)->collect(Integer.subrange(1,10)->collect(Integer.subrange(1,10)->collect(0))) ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < 10 do ( (     warshall[0+1][i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 0 ; while j < 10 do ( (         var k : int ; k := 0 ; while k < 10 do ( (     warshall[i + 1+1][j+1][k+1] := Set{warshall[i+1][j+1][k+1], warshall[i+1][j+1][i+1] + warshall[i+1][i+1][k+1]}->min() )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var tmp : int ;
        var i : int ; i := 0 ; while i < h * w do ( (     tmp := sc.getCurrent()->toInteger() ; 
     if (tmp >= 0) then     ans := ans+(warshall[10+1][tmp+1][1+1]) ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] v=new int[n];
    long sum=0 ;
    for(int i=0 ; i<n ; ++i){
      v[i]=in.nextInt();
      sum+=v[i];
    }
    long res=Long.MAX_VALUE,x=0 ;
    for(int i=0 ; i<n-1 ; ++i){
      x+=v[i];
      long y=sum-x ;
      res=Math.min(Math.abs(x-y),res);
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     v[i+1] := in.getCurrent()->toInteger() ; 
     sum := sum+(v[i+1]) )  ;     i := i + 1 ) ; 
    var res : long ; res := "9223372036854775807"->toLong() ;
    var x : long ; x := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     x := x+(v[i+1]) ; 
     var y : long ; y := sum - x ;
     res := Set{if x - y < 0 then -(x - y) else x - y endif, res}->min() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Reader.init(System.in);
    try {
      int n=Reader.nextInt();
      List<Integer>A=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        A.add(Reader.nextInt());
      }
      System.out.println(solve(n,A));
    }
    catch(IOException e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  public static long solve(int n,List<Integer>A){
    long sum=0 ;
    for(long a : A){
      sum+=a ;
    }
    long min=Math.abs(2*A.get(0)-sum);
    long runningSum=A.get(0);
    for(int i=1 ; i<A.size()-1 ; i++){
      runningSum+=A.get(i);
      min=Math.min(min,Math.abs(2*runningSum-sum));
    }
    return min ;
  }
}
class Reader {
  static BufferedReader reader ;
  static StringTokenizer tokenizer ;
  static void init(InputStream input){
    reader=new BufferedReader(new InputStreamReader(input));
    tokenizer=new StringTokenizer("");
  }
  static String next()throws IOException {
    while(! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
  static int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  static double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Reader.init(OclFile["System.in"]) ; 
     try (     var n : int ; n := Reader.nextInt() ;
     var A : Sequence(int) ; A := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     A := A->including(Reader.nextInt()) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(solve(n, A)) )   catch (e : IOException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
  static   operation solve( n : int, A : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     for (a : A) do ( (     sum := sum+(a) )  ) ; 
    var min : long ; min := if 2 * A->at(0+1) - sum < 0 then -(2 * A->at(0+1) - sum) else 2 * A->at(0+1) - sum endif ;
    var runningSum : long ; runningSum := A->at(0+1) ;
        var i : int ; i := 1 ; while i < A->size() - 1 do ( (     runningSum := runningSum+(A->at(i+1)) ; 
     min := Set{min, if 2 * runningSum - sum < 0 then -(2 * runningSum - sum) else 2 * runningSum - sum endif}->min() )  ;     i := i + 1 ) ; 
    return min 
 );
}
class Reader {
  static   attribute reader : OclFile;
  static   attribute tokenizer : OclIterator;
  static   operation init( input : OclFile) : void
  pre: true
  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(input)) ; 
     tokenizer := OclIterator.newOclIterator_String("") );
  static   operation next() : String
  pre: true
  post: true
  activity: (     while (not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
  static   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[] a=new int[n];
    long[] diff=new long[n-1];
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=scan.nextInt();
      sum+=a[i];
    }
    long s=0 ;
    for(int i=0 ; i<n-1 ; i++){
      s+=a[i];
      sum-=a[i];
      diff[i]=Math.abs(sum-(s));
    }
    Arrays.sort(diff);
    System.out.println(diff[0]);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var diff : Sequence(long) ; diff := Integer.subrange(1,n - 1)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() ; 
     sum := sum+(a[i+1]) )  ;     i := i + 1 ) ; 
    var s : long ; s := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     s := s+(a[i+1]) ; 
     sum := sum-(a[i+1]) ; 
     diff[i+1] := if sum - (s) < 0 then -(sum - (s)) else sum - (s) endif )  ;     i := i + 1 ) ; 
    diff := diff->sort() ; 
    OclFile["System.out"].println(diff[0+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    FastScanner in=new FastScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskC solver=new TaskC();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskC {
    public void solve(int testNumber,FastScanner in,PrintWriter out){
      int n=in.nextInt();
      int[] a=new int[n];
      long s=0 ;
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
        s+=a[i];
      }
      long ans=Long.MAX_VALUE ;
      long t=0 ;
      for(int i=0 ; i+1<n ; i++){
        s-=a[i];
        t+=a[i];
        ans=Math.min(ans,Math.abs(s-t));
      }
      out.println(ans);
    }
  }
  static class FastScanner {
    private BufferedReader in ;
    private StringTokenizer st ;
    public FastScanner(InputStream stream){
      in=new BufferedReader(new InputStreamReader(stream));
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          String rl=in.readLine();
          if(rl==null){
            return null ;
          }
          st=new StringTokenizer(rl);
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : FastScanner ; in := FastScanner.newFastScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskC ; solver := TaskC.newTaskC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskC {
   operation solve( testNumber : int, in : FastScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var s : long ; s := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.nextInt() ; 
     s := s+(a[i+1]) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := "9223372036854775807"->toLong() ;
    var t : long ; t := 0 ;
        var i : int ; i := 0 ; while i + 1 < n do ( (     s := s-(a[i+1]) ; 
     t := t+(a[i+1]) ; 
     ans := Set{ans, if s - t < 0 then -(s - t) else s - t endif}->min() )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
  static class FastScanner {
   attribute in : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( stream : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     var rl : String ; rl := in.readLine() ;
     if (rl = null) then (     return null ) else skip ; 
     st := OclIterator.newOclIterator_String(rl) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String args[]){
    ConsoleScanner cin=new ConsoleScanner();
    PrintWriter cout=new PrintWriter(System.out);
    solve(cin,cout);
    cout.flush();
  }
  static long now(){
    return System.currentTimeMillis();
  }
  static void trace(Object...objects){
    assert null!=System.out.format("trace:%s\n",Arrays.deepToString(objects));
  }
  private static void solve(ConsoleScanner cin,PrintWriter cout){
    int n=cin.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<a.length ; i++)a[i]=cin.nextInt();
    long start=now();
    long ans=solve(n,a);
    cout.println(ans);
    trace("elapsed",now()-start);
  }
  private static long solve(int n,int[] a){
    long total=Arrays.stream(a).mapToLong(x->x).sum();
    long ans=Long.MAX_VALUE ;
    long s=0 ;
    for(int i=0 ; i<n-1 ; i++){
      s+=a[i];
      ans=Math.min(ans,Math.abs(total-2*s));
    }
    return ans ;
  }
  static class ConsoleScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      try {
        while(! st.hasMoreElements())st=new StringTokenizer(br.readLine());
        return st.nextToken();
      }
      catch(IOException e){
        throw new AssertionError(e);
      }
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : ConsoleScanner ; cin := ConsoleScanner.newConsoleScanner() ;
     var cout : OclFile ; cout := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     execute solve(cin, cout) ; 
     skip );
  static   operation now() : long
  pre: true
  post: true
  activity: (     return OclDate.getSystemTime() );
  static   operation trace( objects : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     assert null /= OclFile["System.out"].format("trace:%s\n", (objects + "")) );
  static   operation solve( cin : ConsoleScanner, cout : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := cin.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do (     a[i+1] := cin.nextInt() ;  ;     i := i + 1 ) ; 
    var start : long ; start := now() ;
    var ans : long ; ans := solve(n, a) ;
    skip ; 
    execute trace("elapsed", now() - start) ; 
 );
  static   operation solve( n : int, a : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var total : long ; total := stream(a)->collect( _x1 | (lambda x : OclAny in x)->apply(_x1) )->sum() ;
     var ans : long ; ans := "9223372036854775807"->toLong() ;
    var s : long ; s := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     s := s+(a[i+1]) ; 
     ans := Set{ans, if total - 2 * s < 0 then -(total - 2 * s) else total - 2 * s endif}->min() )  ;     i := i + 1 ) ; 
    return ans 
 );
  static class ConsoleScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() )   catch (e : IOException) do (     error AssertionException(e) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countSum(int N,int L,int R){
    if(L>R){
      return 0 ;
    }
    if(N==1){
      return R-L+1 ;
    }
    if(N>1){
      return(N-2)*(R-L)+1 ;
    }
    return 0 ;
  }
  public static void main(String[] args){
    int N=4,L=4,R=6 ;
    System.out.print(countSum(N,L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countSum( N : int, L : int, R : int) : int
  pre: true
  post: true
  activity: (     if (L > R) then (     return 0 ) else skip ; 
     if (N = 1) then (     return R - L + 1 ) else skip ; 
     if (N > 1) then (     return (N - 2) * (R - L) + 1 ) else skip ; 
     return 0 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
    var L : int ; L := 4 ;
    var R : int ; R := 6 ;
     OclFile["System.out"].print(countSum(N, L, R)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void maxCircularSum(int[] arr,int n,int k){
    if(n<k){
      System.out.println("Invalid");
      return ;
    }
    int sum=0,start=0,end=k-1 ;
    for(int i=0 ; i<k ; i++)sum+=arr[i];
    int ans=sum ;
    for(int i=k ; i<n+k ; i++){
      sum+=arr[i % n]-arr[(i-k)% n];
      if(sum>ans){
        ans=sum ;
        start=(i-k+1)% n ;
        end=i % n ;
      }
    }
    System.out.println("max circular sum="+ans);
    System.out.println("start index="+start+"\nend index="+end);
  }
  public static void main(String[] args){
    int[] arr={
      18,4,3,4,5,6,7,8,2,10 };
      int n=arr.length ;
      int k=3 ;
      maxCircularSum(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxCircularSum( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     if (n < k) then (     OclFile["System.out"].println("Invalid") ; 
     return ) else skip ; 
     var sum : int ; sum := 0 ;
    var start : int ; start := 0 ;
    var end : int ; end := k - 1 ;
        var i : int ; i := 0 ; while i < k do (     sum := sum+(arr[i+1]) ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := sum ;
        var i : int ; i := k ; while i < n + k do ( (     sum := sum+(arr[i mod n+1] - arr[(i - k) mod n+1]) ; 
     if (sum > ans) then (     ans := sum ; 
     start := (i - k + 1) mod n ; 
     end := i mod n ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("max circular sum=" + ans) ; 
    OclFile["System.out"].println("start index=" + start + "\nend index=" + end) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{18,4,3,4,5,6,7,8,2,10} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     execute maxCircularSum(arr, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] min=new long[n];
    int count=1 ;
    min[0]=sc.nextLong();
    for(int i=1 ; i<n ; i++){
      long p=sc.nextLong();
      if(p<=min[i-1]){
        min[i]=p ;
        count++;
      }
      else {
        min[i]=min[i-1];
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var min : Sequence(long) ; min := Integer.subrange(1,n)->collect(0) ;
    var count : int ; count := 1 ;
    min[0+1] := sc.getCurrent()->toLong() ; 
        var i : int ; i := 1 ; while i < n do ( (     var p : long ; p := sc.getCurrent()->toLong() ;
     if (p <= min[i - 1+1]) then (     min[i+1] := p ; 
     count := count + 1 ) else (     min[i+1] := min[i - 1+1] ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean check(String s){
    for(int i=0 ; i<s.length()-1 ; i++)if(s.charAt(i)==s.charAt(i+1))return true ;
    return false ;
  }
  public static void main(String[] args){
    String s="xzyyz" ;
    if(check(s))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation check( s : String) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() - 1 do (     if (s->at(i+1) = s->at(i + 1+1)) then     return true else skip ;  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "xzyyz" ;
     if (check(s)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class T1620A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    in.nextLine();
    for(int i=0 ; i<t ; i++){
      String line=in.nextLine();
      int numberN=0 ;
      int firstN=line.indexOf("N");
      int lastN=line.lastIndexOf("N");
      if(firstN==-1 || firstN!=lastN){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class T1620A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
     skip ; 
         var i : int ; i := 0 ; while i < t do ( (     var line : String ; line := in.nextLine() ;
     var numberN : int ; numberN := 0 ;
    var firstN : int ; firstN := line->indexOf("N")-1 ;
    var lastN : int ; lastN := line->lastIndexOf("N")-1 ;
    if (firstN = -1 or firstN /= lastN) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int sumofproduct(int n){
    int ans=0 ;
    for(int x=1 ; x<=n ; x++){
      int y=n/x ;
      ans+=(y*x);
    }
    return ans ;
  }
  static public void main(String[] args){
    int n=10 ;
    System.out.println(sumofproduct(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumofproduct( n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var x : int ; x := 1 ; while x <= n do ( (     var y : int ; y := n / x ;
     ans := ans+((y * x)) )  ;     x := x + 1 ) ; 
     return ans );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
     OclFile["System.out"].println(sumofproduct(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int firstDigit(int n){
    int fact=1 ;
    for(int i=2 ; i<=n ; i++){
      fact=fact*i ;
      while(fact % 10==0)fact=fact/10 ;
    }
    while(fact>=10)fact=fact/10 ;
    return fact ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(firstDigit(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation firstDigit( n : int) : int
  pre: true
  post: true
  activity: (     var fact : int ; fact := 1 ;
         var i : int ; i := 2 ; while i <= n do ( (     fact := fact * i ; 
     while (fact mod 10 = 0) do     fact := fact / 10 ; )  ;     i := i + 1 ) ; 
     while (fact >= 10) do     fact := fact / 10 ; ; 
     return fact );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(firstDigit(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int[] A=new int[N];
    for(int i=0 ; i<N ; ++i)A[i]=scanner.nextInt();
    for(int i=1 ; i<=A.length-1 ; ++i){
      int key=A[i];
      int j=i-1 ;
      while(j>=0 && A[j]>key){
        A[j+1]=A[j];
        j--;
      }
      A[j+1]=key ;
    }
    int left=0 ;
    int right=A.length-1 ;
    boolean firstPlayer=true ;
    while(left<right){
      if(firstPlayer)--right ;
      else++left ;
      firstPlayer=! firstPlayer ;
    }
    System.out.println(A[left]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     A[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= A->size() - 1 do ( (     var key : int ; key := A[i+1] ;
     var j : int ; j := i - 1 ;
     while (j >= 0 & A[j+1] > key) do (     A[j + 1+1] := A[j+1] ; 
     j := j - 1 ) ; 
     A[j + 1+1] := key )  ;     i := i + 1 ) ; 
    var left : int ; left := 0 ;
    var right : int ; right := A->size() - 1 ;
    var firstPlayer : boolean ; firstPlayer := true ;
    while (left < right) do (     if (firstPlayer) then     right := right - 1 else     left := left + 1 ; ;  
     firstPlayer := not(firstPlayer) ) ; 
    OclFile["System.out"].println(A[left+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    eDosJugadores();
  }
  public static void eDosJugadores(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] array=new int[n];
    for(int i=0 ; i<n ; i++)array[i]=sc.nextInt();
    Arrays.sort(array);
    System.out.print(array[(n-1)/2]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute eDosJugadores() );
  static   operation eDosJugadores() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     array[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    array := array->sort() ; 
    OclFile["System.out"].print(array[(n - 1) / 2+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=scanner.nextInt();
      int ans=n ;
      for(int i=0 ; i<n ; i++)for(int j=1 ; j<4 ; j++){
        if(a[i]==j)continue ;
        int tmp=a[i];
        a[i]=j ;
        int l=i ;
        int r=i ;
        int cnt=0 ;
        while(l>=0){
          int cc=a[l];
          while(l>0 && cc==a[l-1])l--;
          while(r<n-1 && cc==a[r+1])r++;
          if(r-l-cnt+1<4)break ;
          cnt+=r-l-cnt+1 ;
          l--;
        }
        a[i]=tmp ;
        ans=Math.min(ans,n-cnt);
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := n ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 1 ; while j < 4 do ( (     if (a[i+1] = j) then     continue else skip ; 
     var tmp : int ; tmp := a[i+1] ;
    a[i+1] := j ; 
    var l : int ; l := i ;
    var r : int ; r := i ;
    var cnt : int ; cnt := 0 ;
    while (l >= 0) do (     var cc : int ; cc := a[l+1] ;
     while (l > 0 & cc = a[l - 1+1]) do     l := l - 1 ; ; 
    while (r < n - 1 & cc = a[r + 1+1]) do     r := r + 1 ; ; 
    if (r - l - cnt + 1 < 4) then     break else skip ; 
    cnt := cnt+(r - l - cnt + 1) ; 
    l := l - 1 ; 
 ) ; 
    a[i+1] := tmp ; 
    ans := Set{ans, n - cnt}->min() ; 
 )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int[] v ;
  static int solve(int pos,int c){
    int tmp=v[pos];
    v[pos]=c ;
    int up=pos ;
    int dp=pos ;
    int count=0 ;
    while(0<=up && dp<v.length && v[up]==v[dp]){
      int color=v[up];
      int num=up==dp ?-1 : 0 ;
      while(0<=up && v[up]==color){
--up ;
++num ;
      }
      while(dp<v.length && v[dp]==color){
++dp ;
++num ;
      }
      if(num<4)break ;
      count+=num ;
    }
    v[pos]=tmp ;
    return count ;
  }
  public static void main(String[] args){
    while(true){
      int N=sc.nextInt();
      if(N==0)break ;
      v=new int[N];
      for(int i=0 ; i<N ; ++i){
        v[i]=sc.next().charAt(0)-'0' ;
      }
      int ans=0 ;
      for(int i=0 ; i<N ; ++i){
        int u=i==0 ?-1 : v[i-1];
        int d=i==N-1 ?-1 : v[i+1];
        if(u!=-1 && u!=v[i]){
          ans=Math.max(ans,solve(i,u));
        }
        if(d!=-1 && d!=v[i] && u!=d){
          ans=Math.max(ans,solve(i,d));
        }
      }
      System.out.println(N-ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute v : Sequence(int);
  static   operation solve( pos : int, c : int) : int
  pre: true
  post: true
  activity: (     var tmp : int ; tmp := v[pos+1] ;
     v[pos+1] := c ; 
    var up : int ; up := pos ;
    var dp : int ; dp := pos ;
    var count : int ; count := 0 ;
    while (0 <= up & dp < v->size() & v[up+1] = v[dp+1]) do (     var color : int ; color := v[up+1] ;
     var num : int ; num := if up = dp then -1 else 0 endif ;
    while (0 <= up & v[up+1] = color) do (     up := up - 1 ; 
     num := num + 1 ) ; 
    while (dp < v->size() & v[dp+1] = color) do (     dp := dp + 1 ; 
     num := num + 1 ) ; 
    if (num < 4) then     break else skip ; 
    count := count+(num) ; 
 ) ; 
    v[pos+1] := tmp ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then     break else skip ; 
    v := Integer.subrange(1,N)->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     v[i+1] := sc.getCurrent()->at(0+1) - ('0')->char2byte() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var u : int ; u := if i = 0 then -1 else v[i - 1+1] endif ;
     var d : int ; d := if i = N - 1 then -1 else v[i + 1+1] endif ;
     if (u /= -1 & u /= v[i+1]) then (     ans := Set{ans, solve(i, u)}->max() ) else skip ; 
     if (d /= -1 & d /= v[i+1] & u /= d) then (     ans := Set{ans, solve(i, d)}->max() ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(N - ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    System.out.println(solve());
  }
  public static int solve(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] arr=new int[N];
    for(int i=0 ; i<N ; i++){
      arr[i]=sc.nextInt();
    }
    int sum=0 ;
    Queue<Integer>q=new PriorityQueue<>();
    for(int i=0 ; i<arr.length ; i++){
      q.add(arr[i]);
      if(arr[i]<=q.peek()){
        sum++;
      }
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(solve()) );
  static   operation solve() : int
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var q : Sequence(int) ; q := Sequence{} ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     q := q->including(arr[i+1]) ; 
     if (arr[i+1] <= q->min()) then (     sum := sum + 1 ) else skip )  ;     i := i + 1 ) ; 
    return sum 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
class Main {
  public static void main(final String[] args){
    final Scanner stdin=new Scanner(System.in);
    while(true){
      final int n=stdin.nextInt();
      if(n==0){
        break ;
      }
      int[] color=new int[n];
      for(int i=0 ; i<n ; i++){
        color[i]=stdin.nextInt();
      }
      int minSize=n ;
      for(int i=0 ; i<n ; i++){
        int preColor=color[i];
        if(preColor!=1){
          color[i]=1 ;
          minSize=Math.min(minSize,n-simulate(color,i));
        }
        if(preColor!=2){
          color[i]=2 ;
          minSize=Math.min(minSize,n-simulate(color,i));
        }
        if(preColor!=3){
          color[i]=3 ;
          minSize=Math.min(minSize,n-simulate(color,i));
        }
        color[i]=preColor ;
      }
      System.out.println(minSize);
    }
  }
  static int simulate(final int[] color,final int index){
    int left=index ;
    int right=index ;
    int number=0 ;
    while(0<=left && right<color.length && color[left]==color[right]){
      final int pColor=color[left];
      int localCount=0 ;
      while(0<=left && color[left]==pColor){
        if(left!=right){
          localCount++;
        }
        left--;
      }
      while(right<color.length && color[right]==pColor){
        right++;
        localCount++;
      }
      if(localCount>=4){
        number+=localCount ;
      }
    }
    return number ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := stdin.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var color : Sequence(int) ; color := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     color[i+1] := stdin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var minSize : int ; minSize := n ;
        var i : int ; i := 0 ; while i < n do ( (     var preColor : int ; preColor := color[i+1] ;
     if (preColor /= 1) then (     color[i+1] := 1 ; 
     minSize := Set{minSize, n - simulate(color, i)}->min() ) else skip ; 
    if (preColor /= 2) then (     color[i+1] := 2 ; 
     minSize := Set{minSize, n - simulate(color, i)}->min() ) else skip ; 
    if (preColor /= 3) then (     color[i+1] := 3 ; 
     minSize := Set{minSize, n - simulate(color, i)}->min() ) else skip ; 
    color[i+1] := preColor ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(minSize) ; 
 ) );
  static   operation simulate( color : Sequence(int), index : int) : int
  pre: true
  post: true
  activity: (     var left : int ; left := index ;
     var right : int ; right := index ;
    var number : int ; number := 0 ;
    while (0 <= left & right < color->size() & color[left+1] = color[right+1]) do (     var pColor : int ; pColor := color[left+1] ;
     var localCount : int ; localCount := 0 ;
    while (0 <= left & color[left+1] = pColor) do (     if (left /= right) then (     localCount := localCount + 1 ) else skip ; 
     left := left - 1 ) ; 
    while (right < color->size() & color[right+1] = pColor) do (     right := right + 1 ; 
     localCount := localCount + 1 ) ; 
    if (localCount >= 4) then (     number := number+(localCount) ) else skip ; 
 ) ; 
    return number 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      StringBuilder sb=new StringBuilder();
      for(int i=0 ; i<n ; i++)sb.append(sc.nextInt());
      debug(sb);
      int min=n ;
      for(int i=0 ; i<sb.length(); i++)for(int c=1 ; c<=3 ; c++){
        StringBuilder tmp=new StringBuilder(sb.substring(0,i)+c+sb.substring(i+1));
        debug(tmp);
        int l=i,r=i,cnt=0 ;
        while(l>=0){
          int cc=tmp.charAt(l)-'0' ;
          while(l>0 && cc==(tmp.charAt(l-1)-'0'))l--;
          while(r<sb.length()-1 && cc==(tmp.charAt(r+1)-'0'))r++;
          debug(l,r,r-l-cnt+1);
          if(r-l-cnt+1<4)break ;
          cnt+=r-l-cnt+1 ;
          l--;
        }
        min=min(sb.length()-cnt,min);
      }
      System.out.println(min);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < n do (     sb := sb + StringLib.newString(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    execute debug(sb) ; 
    var min : int ; min := n ;
        var i : int ; i := 0 ; while i < sb->size() do (         var c : int ; c := 1 ; while c <= 3 do ( (     var tmp : String ; tmp := StringLib.newString(sb.subrange(0+1,i) + c + sb.subrange(i + 1+1,i + 1)) ;
     execute debug(tmp) ; 
    var l : int ; l := i ;
    var r : int ; r := i ;
    var cnt : int ; cnt := 0 ;
    while (l >= 0) do (     var cc : int ; cc := tmp->at(l+1) - ('0')->char2byte() ;
     while (l > 0 & cc = (tmp->at((l)->char2byte() - 1+1) - ('0')->char2byte())) do     l := l - 1 ; ; 
    while (r < sb->size() - 1 & cc = (tmp->at(r + 1+1) - ('0')->char2byte())) do     r := r + 1 ; ; 
    execute debug(l, r, (r)->char2byte() - (l)->char2byte() - (cnt)->char2byte() + 1) ; 
    if ((r)->char2byte() - (l)->char2byte() - (cnt)->char2byte() + 1 < 4) then     break else skip ; 
    cnt := cnt+((r)->char2byte() - (l)->char2byte() - (cnt)->char2byte() + 1) ; 
    l := l - 1 ; 
 ) ; 
    min := Set{sb->size() - (cnt)->char2byte(), min}->min() ; 
 )  ;     c := c + 1 ) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: skip;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] a=new int[n+2];
      for(int i=1 ; i<=n ; i++)a[i]=sc.nextInt();
      a[0]=4 ;
      a[n+1]=5 ;
      int max=0 ;
      for(int i=1 ; i<=n ; i++){
        for(int j=1 ; j<=3 ; j++){
          if(a[i]!=j){
            int p=i+1 ;
            int q=i-1 ;
            int r=j ;
            int sum=0 ;
            while(true){
              while(a[p]==r)p++;
              while(a[q]==r)q--;
              if(p-q-1-sum<4){
                max=Math.max(max,sum);
                break ;
              }
              sum=p-q-1 ;
              if(a[p]!=a[q]){
                max=Math.max(max,sum);
                break ;
              }
              r=a[p];
            }
          }
        }
      }
      System.out.println(n-max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n + 2)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a[0+1] := 4 ; 
    a[n + 1+1] := 5 ; 
    var max : int ; max := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= 3 do ( (     if (a[i+1] /= j) then (     var p : int ; p := i + 1 ;
     var q : int ; q := i - 1 ;
    var r : int ; r := j ;
    var sum : int ; sum := 0 ;
    while (true) do (     while (a[p+1] = r) do     p := p + 1 ; ; 
     while (a[q+1] = r) do     q := q - 1 ; ; 
    if (p - q - 1 - sum < 4) then (     max := Set{max, sum}->max() ; 
     break ) else skip ; 
    sum := p - q - 1 ; 
    if (a[p+1] /= a[q+1]) then (     max := Set{max, sum}->max() ; 
     break ) else skip ; 
    r := a[p+1] ; 
 ) ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n - max) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
public class EqualOrNot {
  public static void main(String[] args)throws Exception {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out));
    int t=Integer.parseInt(reader.readLine());
    int Es=0 ;
    int Ns=0 ;
    boolean test=false ;
    String result[]=new String[t];
    for(int i=0 ; i<t ; i++){
      String s=reader.readLine();
      for(int j=0 ; j<s.length(); j++){
        if(s.charAt(j)=='N')Ns++;
      }
      if(Ns==1)result[i]="NO" ;
      else result[i]="YES" ;
      Ns=0 ;
    }
    for(int i=0 ; i<result.length ; i++){
      writer.write(result[i]);
      writer.newLine();
      writer.flush();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class EqualOrNot {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var t : int ; t := (reader.readLine())->toInteger() ;
    var Es : int ; Es := 0 ;
    var Ns : int ; Ns := 0 ;
    var test : boolean ; test := false ;
    var result : Sequence(String) ; result := Integer.subrange(1,t)->collect(null) ;
        var i : int ; i := 0 ; while i < t do ( (     var s : String ; s := reader.readLine() ;
         var j : int ; j := 0 ; while j < s->size() do ( (     if (s->at(j+1) = 'N') then     Ns := Ns + 1 ; else skip )  ;     j := j + 1 ) ; 
     if (Ns = 1) then     result[i+1] := "NO" else     result[i+1] := "YES" ; ;  
     Ns := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < result->size() do ( (     skip ; 
     skip ; 
     skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printmaxSubseq(int arr[],int n){
    int i ;
    for(i=0 ; i<n ; i++){
      if(i+1<n && arr[i]<arr[i+1])System.out.print(arr[i]+" ");
      else System.out.print(arr[i]+"\n");
    }
  }
  public static void main(String[] args){
    int arr[]={
      9,8,11,13,10,15,14,16,20,5 };
      int n=arr.length ;
      printmaxSubseq(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printmaxSubseq( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
         i := 0 ; while i < n do ( (     if (i + 1 < n & arr[i+1] < arr[i + 1+1]) then     OclFile["System.out"].print(arr[i+1] + " ") ; else     OclFile["System.out"].print(arr[i+1] + "\n") ; )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{9,8,11,13,10,15,14,16,20,5} ;
     var n : int ; n := arr->size() ;
     execute printmaxSubseq(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    String q=s.nextLine();
    String[] key=q.split("\\.");
    int now=1 ;
    int n=key.length ;
    int d[]=new int[120];
    for(int i=0 ; i<120 ; i++)d[i]=-1 ;
    d[1]=0 ;
    boolean ok=false ;
    while(s.hasNext()){
      String str=s.nextLine();
      int cnt=0 ;
      for(int i=0 ; i<str.length(); i++){
        if(str.charAt(i)!=' ')break ;
        cnt++;
      }
      if(d[now]==-1)d[now]=cnt ;
      while(cnt<d[now]){
        d[now]=-1 ;
        now--;
      }
      String tmp=str.split(":")[0] .substring(cnt);
      if(tmp.equals(key[now])){
        now++;
        if(n==now){
          if(str.split(":").length>1)System.out.println("string \""+str.split(":")[1] .substring(1)+"\"");
          else System.out.println("object");
          ok=true ;
          break ;
        }
      }
    }
    if(! ok)System.out.println("no such property");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var q : String ; q := s.nextLine() ;
    var key : Sequence(String) ; key := q->split("\\.") ;
    var now : int ; now := 1 ;
    var n : int ; n := key->size() ;
    var d : Sequence(int) ; d := Integer.subrange(1,120)->collect(0) ;
        var i : int ; i := 0 ; while i < 120 do (     d[i+1] := -1 ;  ;     i := i + 1 ) ; 
    d[1+1] := 0 ; 
    var ok : boolean ; ok := false ;
    while (s.hasNext()) do (     var str : String ; str := s.nextLine() ;
     var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) /= ' ') then     break else skip ; 
     cnt := cnt + 1 )  ;     i := i + 1 ) ; 
    if (d[now+1] = -1) then     d[now+1] := cnt ; else skip ; 
    while (cnt < d[now+1]) do (     d[now+1] := -1 ; 
     now := now - 1 ) ; 
    var tmp : String ; tmp := str->split(":")[0+1].subrange(cnt+1,cnt) ;
    if (tmp = key[now+1]) then (     now := now + 1 ; 
     if (n = now) then (     if (str->split(":")->size() > 1) then     OclFile["System.out"].println("string \"" + str->split(":")[1+1].subrange(1+1,1) + "\"") else     OclFile["System.out"].println("object") ; ;  
     ok := true ; 
     break ) else skip ) else skip ; 
 ) ; 
    if (not(ok)) then     OclFile["System.out"].println("no such property") ; else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String[] input=scan.nextLine().split(java.util.regex.Pattern.quote("."));
    Stack<Integer>indentLengths=new Stack<>();
    int maxDepth=0 ;
    indentLengths.push(0);
    while(scan.hasNext()){
      String[] line=scan.nextLine().split(":");
      int indents=0 ;
      for(char c : line[0] .toCharArray())if(c==' ')indents++;
      else break ;
      line[0]=line[0] .substring(indents);
      if(indentLengths.peek()==indents){
      }
      else if(indentLengths.peek()<indents){
        indentLengths.push(indents);
      }
      else {
        while(indentLengths.peek()!=indents){
          indentLengths.pop();
        }
        if(indentLengths.size()<=maxDepth)break ;
      }
      if(input.length>indentLengths.size()&& input[indentLengths.size()] .equals(line[0])){
        maxDepth++;
        if(maxDepth+1==input.length){
          if(line.length==1)System.out.println("object");
          else System.out.println("string \""+line[1] .substring(1)+"\"");
          return ;
        }
      }
    }
    System.out.println("no such property");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : Sequence(String) ; input := scan.nextLine()->split(java.util.regex.Pattern.quote(".")) ;
    var indentLengths : Sequence(int) ; indentLengths := Sequence{} ;
    var maxDepth : int ; maxDepth := 0 ;
    indentLengths := indentLengths->append(0) ; 
    while (scan.hasNext()) do (     var line : Sequence(String) ; line := scan.nextLine()->split(":") ;
     var indents : int ; indents := 0 ;
    for (c : line[0+1]->characters()) do (     if (c = ' ') then     indents := indents + 1 else     break ;   ) ; 
    line[0+1] := line[0+1].subrange(indents+1,indents) ; 
    if (indentLengths->min() = indents) then skip else     if (indentLengths->min() < indents) then (     indentLengths := indentLengths->append(indents) ) else (     while (indentLengths->min() /= indents) do (     indentLengths := indentLengths->front() ) ; 
     if (indentLengths->size() <= maxDepth) then     break else skip ) ;  ;  
    if (input->size() > indentLengths->size() & input[indentLengths->size()+1] = line[0+1]) then (     maxDepth := maxDepth + 1 ; 
     if (maxDepth + 1 = input->size()) then (     if (line->size() = 1) then     OclFile["System.out"].println("object") else     OclFile["System.out"].println("string \"" + line[1+1].subrange(1+1,1) + "\"") ; ;  
     return ) else skip ) else skip ; 
 ) ; 
    OclFile["System.out"].println("no such property") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    String[] ps=sc.nextLine().split("\\.");
    char[][] s=new char[15000][];
    int n=0 ;
    while(sc.hasNext()){
      s[n++]=sc.nextLine().toCharArray();
    }
    int now=0,indent=0 ;
    for(int i=1 ; i<ps.length ; i++){
      boolean find=false ;
      while(now<n){
        int cnt=0,idx=0 ;
        while(s[now][idx]==' '){
          cnt++;
          idx++;
        }
        if(cnt<indent){
          System.out.println("no such property");
          return ;
        }
        else if(cnt==indent){
          String name="" ;
          while(s[now][idx]!=':'){
            name+=s[now][idx++];
          }
          if(ps[i] .equals(name)){
            if(i==ps.length-1){
              if(idx==s[now] .length-1){
                System.out.println("object");
                return ;
              }
              idx+=2 ;
              String res="" ;
              while(idx<s[now] .length)res+=s[now][idx++];
              System.out.println("string \""+res+"\"");
              return ;
            }
            if(now==n-1){
              System.out.println("no such property");
              return ;
            }
            indent=0 ;
            while(s[now+1][indent]==' ')indent++;
            find=true ;
            now++;
            break ;
          }
          else now++;
        }
        else now++;
      }
      if(! find){
        System.out.println("no such property");
        return ;
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ps : Sequence(String) ; ps := sc.nextLine()->split("\\.") ;
    var s : Sequence(Sequence(String)) ; s := Integer.subrange(1,15000)->collect(Sequence{}) ;
    var n : int ; n := 0 ;
    while (sc.hasNext()) do (      s[n+1] := sc.nextLine()->characters()  ; n := n + 1 ) ; 
    var now : int ; now := 0 ;
    var indent : int ; indent := 0 ;
        var i : int ; i := 1 ; while i < ps->size() do ( (     var find : boolean ; find := false ;
     while (now < n) do (     var cnt : int ; cnt := 0 ;
    var idx : int ; idx := 0 ;
     while (s[now+1][idx+1] = ' ') do (     cnt := cnt + 1 ; 
     idx := idx + 1 ) ; 
     if (cnt < indent) then (     OclFile["System.out"].println("no such property") ; 
     return ) else     if (cnt = indent) then (     var name : String ; name := "" ;
     while (s[now+1][idx+1] /= ':') do (      name := name + s[now+1][idx+1]  ; idx := idx + 1 ) ; 
     if (ps[i+1] = name) then (     if (i = ps->size() - 1) then (     if (idx = s[now+1]->size() - 1) then (     OclFile["System.out"].println("object") ; 
     return ) else skip ; 
     idx := idx+(2) ; 
    var res : String ; res := "" ;
    while (idx < s[now+1]->size()) do      res := res + s[now+1][idx+1]  ; idx := idx + 1 ; ; 
    OclFile["System.out"].println("string \"" + res + "\"") ; 
    return 
 ) else skip ; 
     if (now = n - 1) then (     OclFile["System.out"].println("no such property") ; 
     return ) else skip ; 
    indent := 0 ; 
    while (s[now + 1+1][indent+1] = ' ') do     indent := indent + 1 ; ; 
    find := true ; 
    now := now + 1 ; 
    break 
 ) else     now := now + 1 ; ) else     now := now + 1 ; ;  ) ; 
     if (not(find)) then (     OclFile["System.out"].println("no such property") ; 
     return ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long p=sc.nextInt();
    long q=sc.nextInt();
    long n=1,x=p ;
    if(x>q)x=q ;
    for(int i=0 ; i<x ; i++)n=n*(i+1);
    System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : long ; p := sc.getCurrent()->toInteger() ;
    var q : long ; q := sc.getCurrent()->toInteger() ;
    var n : long ; n := 1 ;
    var x : long ; x := p ;
    if (x > q) then     x := q ; else skip ; 
        var i : int ; i := 0 ; while i < x do (     n := n * (i + 1) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long p=sc.nextInt();
    long q=sc.nextInt();
    long n=1,x=p ;
    if(x>q)x=q ;
    for(int i=0 ; i<x ; i++)n=n*(i+1);
    System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : long ; p := sc.getCurrent()->toInteger() ;
    var q : long ; q := sc.getCurrent()->toInteger() ;
    var n : long ; n := 1 ;
    var x : long ; x := p ;
    if (x > q) then     x := q ; else skip ; 
        var i : int ; i := 0 ; while i < x do (     n := n * (i + 1) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.List ;
import java.util.ArrayList ;
class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    List<Integer>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      list.add(scanner.nextInt());
    }
    scanner.close();
    int count=0 ;
    int min=list.get(0);
    for(int i=0 ; i<list.size(); i++){
      if(list.get(i).compareTo(min)==1){
        continue ;
      }
      count+=1 ;
      min=list.get(i);
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    skip ; 
    var count : int ; count := 0 ;
    var min : int ; min := list->at(0+1) ;
        var i : int ; i := 0 ; while i < list->size() do ( (     if (list->at(i+1)->compareTo(min) = 1) then (     continue ) else skip ; 
     count := count+(1) ; 
     min := list->at(i+1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int factorial(int x){
    if(x<=1)return 1 ;
    int res=2 ;
    for(int i=3 ; i<=x ; i++)res=res*i ;
    return res ;
  }
  static int gcd(int M,int N){
    int min=M<N ? M : N ;
    return factorial(min);
  }
  public static void main(String[] args){
    int M,N ;
    Scanner s=new Scanner(System.in);
    M=s.nextInt();
    N=s.nextInt();
    System.out.println(gcd(M,N));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation factorial( x : int) : int
  pre: true
  post: true
  activity: (     if (x <= 1) then     return 1 else skip ; 
     var res : int ; res := 2 ;
         var i : int ; i := 3 ; while i <= x do (     res := res * i ;  ;     i := i + 1 ) ; 
     return res );
  static   operation gcd( M : int, N : int) : int
  pre: true
  post: true
  activity: (     var min : int ; min := if M < N then M else N endif ;
     return factorial(min) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var M : int ;
    var N : int ;
     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    M := s.getCurrent()->toInteger() ; 
    N := s.getCurrent()->toInteger() ; 
    OclFile["System.out"].println(gcd(M, N)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _822A_ImBoredWithLife {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int a=input.nextInt();
    int b=input.nextInt();
    input.nextLine();
    int min=Math.min(a,b);
    int result=1 ;
    while(min>1){
      result*=min ;
      min--;
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _822A_ImBoredWithLife {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := input.getCurrent()->toInteger() ;
    var b : int ; b := input.getCurrent()->toInteger() ;
    skip ; 
    var min : int ; min := Set{a, b}->min() ;
    var result : int ; result := 1 ;
    while (min > 1) do (     result := result*(min) ; 
     min := min - 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int factorial(int x){
    if(x<=1)return 1 ;
    int result=2 ;
    for(int i=3 ; i<=x ; i++)result=result*i ;
    return result ;
  }
  static int gcd(int h,int r){
    int min=h<r ? h : r ;
    return factorial(min);
  }
  public static void main(String[] args){
    int h,r ;
    Scanner sr=new Scanner(System.in);
    h=sr.nextInt();
    r=sr.nextInt();
    System.out.println(gcd(h,r));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation factorial( x : int) : int
  pre: true
  post: true
  activity: (     if (x <= 1) then     return 1 else skip ; 
     var result : int ; result := 2 ;
         var i : int ; i := 3 ; while i <= x do (     result := result * i ;  ;     i := i + 1 ) ; 
     return result );
  static   operation gcd( h : int, r : int) : int
  pre: true
  post: true
  activity: (     var min : int ; min := if h < r then h else r endif ;
     return factorial(min) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var h : int ;
    var r : int ;
     var sr : OclFile ; sr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    h := sr.getCurrent()->toInteger() ; 
    r := sr.getCurrent()->toInteger() ; 
    OclFile["System.out"].println(gcd(h, r)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    String string=input.nextLine();
    char first=' ' ;
    int counter=0 ;
    for(char b : string.toCharArray()){
      if(first==' '){
        first=b ;
      }
      else {
        if(b==first){
        }
        else {
          first=b ;
          counter++;
        }
      }
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var string : String ; string := input.nextLine() ;
    var first : String ; first := ' ' ;
    var counter : int ; counter := 0 ;
    for (b : string->characters()) do ( (     if (first = ' ') then (     first := b ) else (     if (b = first) then skip else (     first := b ; 
     counter := counter + 1 ) ) )  ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.*;
public class Solution {
  static Scanner str=new Scanner(System.in);
  public static void main(String[] args)throws IOException {
    int T=1 ;
    while(T-->0){
      solve();
    }
  }
  static void solve()throws IOException {
    long a=l(),b=l();
    long res=1 ;
    for(long i=a+1 ; i<=b ; i++){
      if(res==0){
        System.out.println(0);
        return ;
      }
      res*=i ;
      res %=10 ;
    }
    System.out.println(res);
  }
  public static int i()throws IOException {
    return str.nextInt();
  }
  public static long l()throws IOException {
    return str.nextLong();
  }
  public static double d()throws IOException {
    return str.nextDouble();
  }
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute str : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : int ; T := 1 ;
         while (T > 0) do (        T := T - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var a : long ; a := l() ;
    var b : long ; b := l() ;
     var res : long ; res := 1 ;
         var i : long ; i := a + 1 ; while i <= b do ( (     if (res = 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
     res := res*(i) ; 
     res := res mod 10 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(res) );
  static   operation i() : int
  pre: true
  post: true
  activity: (     return str.getCurrent()->toInteger() );
  static   operation l() : long
  pre: true
  post: true
  activity: (     return str.getCurrent()->toLong() );
  static   operation d() : double
  pre: true
  post: true
  activity: (     return str.getCurrent()->toReal() );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskC solver=new TaskC();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskC {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      String word=in.next();
      int cnt=0 ;
      for(int i=1 ; i<word.length(); i++){
        if(word.charAt(i)!=word.charAt(i-1))cnt++;
      }
      out.println(cnt);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskC ; solver := TaskC.newTaskC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskC {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var word : String ; word := in.next() ;
     var cnt : int ; cnt := 0 ;
         var i : int ; i := 1 ; while i < word->size() do ( (     if (word->at(i+1) /= word->at(i - 1+1)) then     cnt := cnt + 1 ; else skip )  ;     i := i + 1 ) ; 
     skip );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;
public class Main {
  static final Scanner in=new Scanner(System.in);
  static final PrintWriter out=new PrintWriter(System.out,false);
  static boolean debug=false ;
  static void solve(){
    String s=in.next();
    int n=s.length();
    int ans=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if(s.charAt(i)!=s.charAt(i+1)){
        ans++;
      }
    }
    out.println(ans);
  }
  public static void main(String[] args){
    debug=args.length>0 ;
    long start=System.nanoTime();
    solve();
    out.flush();
    long end=System.nanoTime();
    dump((end-start)/1000000+" ms");
    in.close();
    out.close();
  }
  static void dump(Object...o){
    if(debug)System.err.println(Arrays.deepToString(o));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], false);
  static   attribute debug : boolean := false;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.getCurrent() ;
     var n : int ; n := s->size() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < (n)->char2byte() - 1 do ( (     if (s->at(i+1) /= s->at(i + 1+1)) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     debug := args->size() > 0 ; 
     var start : long ; start := nanoTime() ;
    execute solve() ; 
    skip ; 
    var end : long ; end := nanoTime() ;
    execute dump((end - start) / 1000000 + " ms") ; 
    skip ; 
    skip ; 
 );
  static   operation dump( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     if (debug) then     OclFile["System.err"].println((o + "")) ; else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    String s=gs();
    int g=0 ;
    int p=0 ;
    int c=0 ;
    for(int i=1 ; i<s.length(); i++){
      if(s.charAt(i-1)!=s.charAt(i))c++;
    }
    System.out.println(c);
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var s : String ; s := gs() ;
    var g : int ; g := 0 ;
    var p : int ; p := 0 ;
    var c : int ; c := 0 ;
        var i : int ; i := 1 ; while i < s->size() do ( (     if (s->at(i - 1+1) /= s->at(i+1)) then     c := c + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    while(input.hasNext()){
      String S=input.next();
      int countDiff=0 ;
      for(int i=1 ; i<S.length(); ++i){
        if(S.charAt(i)!=S.charAt(i-1)){
++countDiff ;
        }
      }
      System.out.println(countDiff);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (input.hasNext()) do (     var S : String ; S := input.getCurrent() ;
     var countDiff : int ; countDiff := 0 ;
         var i : int ; i := 1 ; while i < S->size() do ( (     if (S->at(i+1) /= S->at(i - 1+1)) then (     countDiff := countDiff + 1 ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(countDiff) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int countBits(int a){
    int count=0 ;
    while(a>0){
      if((a & 1)>0)count+=1 ;
      a=a>>1 ;
    }
    return count ;
  }
  static void insertionSort(int arr[],int aux[],int n){
    for(int i=1 ; i<n ; i++){
      int key1=aux[i];
      int key2=arr[i];
      int j=i-1 ;
      while(j>=0 && aux[j]<key1){
        aux[j+1]=aux[j];
        arr[j+1]=arr[j];
        j=j-1 ;
      }
      aux[j+1]=key1 ;
      arr[j+1]=key2 ;
    }
  }
  static void sortBySetBitCount(int arr[],int n){
    int aux[]=new int[n];
    for(int i=0 ; i<n ; i++)aux[i]=countBits(arr[i]);
    insertionSort(arr,aux,n);
  }
  static void printArr(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4,5,6 };
      int n=arr.length ;
      sortBySetBitCount(arr,n);
      printArr(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countBits( a : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (a > 0) do (     if ((a & 1) > 0) then     count := count+(1) ; else skip ; 
     a := (a/(2->pow(1)))->oclAsType(long) ) ; 
     return count );
  static   operation insertionSort( arr : Sequence(int), aux : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < n do ( (     var key1 : int ; key1 := aux[i+1] ;
     var key2 : int ; key2 := arr[i+1] ;
    var j : int ; j := i - 1 ;
    while (j >= 0 & aux[j+1] < key1) do (     aux[j + 1+1] := aux[j+1] ; 
     arr[j + 1+1] := arr[j+1] ; 
     j := j - 1 ) ; 
    aux[j + 1+1] := key1 ; 
    arr[j + 1+1] := key2 ; 
 )  ;     i := i + 1 ) );
  static   operation sortBySetBitCount( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var aux : Sequence(int) ; aux := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     aux[i+1] := countBits(arr[i+1]) ;  ;     i := i + 1 ) ; 
     execute insertionSort(arr, aux, n) );
  static   operation printArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6} ;
     var n : int ; n := arr->size() ;
     execute sortBySetBitCount(arr, n) ; 
     execute printArr(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int count=0 ;
    boolean sw=false ;
    int max=Integer.MIN_VALUE ;
    int min=Integer.MAX_VALUE ;
    double dMax=Double.MIN_VALUE ;
    double dMin=Double.MAX_VALUE ;
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Integer>list=new ArrayList<>();
    for(int i=0 ; i<n ; ++i)list.add(sc.nextInt());
    for(int i=0 ; i<n ; ++i){
      int pi=list.get(i);
      if(i==0){
++count ;
      }
      else if(pi<=min){
++count ;
      }
      if(min>pi)min=pi ;
    }
    System.out.println(count);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var sw : boolean ; sw := false ;
    var max : int ; max := -2147483648 ;
    var min : int ; min := 2147483647 ;
    var dMax : double ; dMax := 2->pow(-1074) ;
    var dMin : double ; dMin := (2 - 2->pow(-52))*(2->pow(1023)) ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     list := list->including(sc.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var pi : int ; pi := list->at(i+1) ;
     if (i = 0) then (     count := count + 1 ) else     if (pi <= min) then (     count := count + 1 ) else skip ; ;  
     if (min > pi) then     min := pi ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void modInverse(int a,int m){
    int g=gcd(a,m);
    if(g!=1)System.out.println("Inverse doesn't exist");
    else {
      System.out.println("Modular multiplicative inverse is "+power(a,m-2,m));
    }
  }
  static int power(int x,int y,int m){
    if(y==0)return 1 ;
    int p=power(x,y/2,m)% m ;
    p=(p*p)% m ;
    if(y % 2==0)return p ;
    else return(x*p)% m ;
  }
  static int gcd(int a,int b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  public static void main(String args[]){
    int a=3,m=11 ;
    modInverse(a,m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation modInverse( a : int, m : int) : void
  pre: true
  post: true
  activity: (     var g : int ; g := gcd(a, m) ;
     if (g /= 1) then     OclFile["System.out"].println("Inverse doesn't exist") ; else (     OclFile["System.out"].println("Modular multiplicative inverse is " + power(a, m - 2, m)) ) );
  static   operation power( x : int, y : int, m : int) : int
  pre: true
  post: true
  activity: (     if (y = 0) then     return 1 else skip ; 
     var p : int ; p := power(x, y / 2, m) mod m ;
     p := (p * p) mod m ; 
     if (y mod 2 = 0) then     return p else     return (x * p) mod m );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var m : int ; m := 11 ;
     execute modInverse(a, m) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int minimumMoves(int n,int a[],int s,int t){
    int i,x ;
    x=s ;
    for(i=1 ; i<=n ; i++){
      if(x==t)break ;
      x=a[x];
    }
    if(x==t)return i-1 ;
    else return-1 ;
  }
  public static void main(String[] args){
    int s=2,t=1,i ;
    int a[]={
-1,2,3,4,1 };
      int n=a.length ;
      System.out.println(minimumMoves(n,a,s,t));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minimumMoves( n : int, a : Sequence(int), s : int, t : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var x : int ;
     x := s ; 
         i := 1 ; while i <= n do ( (     if (x = t) then     break else skip ; 
     x := a[x+1] )  ;     i := i + 1 ) ; 
     if (x = t) then     return i - 1 else     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : int ; s := 2 ;
    var t : int ; t := 1 ;
    var i : int ;
     var a : Sequence(int) ; a := Sequence{-1,2,3,4,1} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(minimumMoves(n, a, s, t)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  static void countOddRotations(int n){
    int odd_count=0,even_count=0 ;
    do {
      int digit=n % 10 ;
      if(digit % 2==1)odd_count++;
      else even_count++;
      n=n/10 ;
    }
    while(n!=0);
    System.out.println("Odd="+odd_count);
    System.out.println("Even="+even_count);
  }
  public static void main(String[] args){
    int n=1234 ;
    countOddRotations(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
  static   operation countOddRotations( n : int) : void
  pre: true
  post: true
  activity: (     var odd_count : int ; odd_count := 0 ;
    var even_count : int ; even_count := 0 ;
   while true do ((     var digit : int ; digit := n mod 10 ;
     if (digit mod 2 = 1) then     odd_count := odd_count + 1 else     even_count := even_count + 1 ; ;  
     n := n / 10 ) ;
    if (n /= 0) then skip else break) ; 
     OclFile["System.out"].println("Odd=" + odd_count) ; 
     OclFile["System.out"].println("Even=" + even_count) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1234 ;
     execute countOddRotations(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class GFG {
  static int fact(int n){
    return(n<=1)? 1 : n*fact(n-1);
  }
  static int findSmallerInRight(String str,int low,int high){
    int countRight=0,i ;
    for(i=low+1 ; i<=high ; ++i)if(str.charAt(i)<str.charAt(low))++countRight ;
    return countRight ;
  }
  static int findRank(String str){
    int len=str.length();
    int mul=fact(len);
    int rank=1 ;
    int countRight ;
    for(int i=0 ; i<len ; ++i){
      mul/=len-i ;
      countRight=findSmallerInRight(str,i,len-1);
      rank+=countRight*mul ;
    }
    return rank ;
  }
  public static void main(String[] args){
    String str="string" ;
    System.out.println(findRank(str));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fact( n : int) : int
  pre: true
  post: true
  activity: (     return if (n <= 1) then 1 else n * fact(n - 1) endif );
  static   operation findSmallerInRight( str : String, low : int, high : int) : int
  pre: true
  post: true
  activity: (     var countRight : int ; countRight := 0 ;
    var i : int ;
         i := low + 1 ; while i <= high do (     if (str->at(i+1) < str->at(low+1)) then     countRight := countRight + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return countRight );
  static   operation findRank( str : String) : int
  pre: true
  post: true
  activity: (     var len : int ; len := str->size() ;
     var mul : int ; mul := fact(len) ;
    var rank : int ; rank := 1 ;
    var countRight : int ;
        var i : int ; i := 0 ; while i < len do ( (     mul := mul/(len - i) ; 
     countRight := findSmallerInRight(str, i, len - 1) ; 
     rank := rank+(countRight * mul) )  ;     i := i + 1 ) ; 
    return rank 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "string" ;
     OclFile["System.out"].println(findRank(str)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Improve {
  public static void main(String args[]){
    String s="ABCdcba" ;
    int u[]=new int[26];
    int n=s.length();
    for(int i=0 ; i<n ; i++){
      if(Character.isUpperCase(s.charAt(i))){
        u[s.charAt(i)-65]+=1 ;
      }
      else {
        u[s.charAt(i)-97]-=1 ;
      }
    }
    boolean f1=true ;
    int po=0 ;
    int ne=0 ;
    for(int i=0 ; i<26 ; i++){
      if(u[i]>0)po+=u[i];
      if(u[i]<0)ne+=u[i];
    }
    if(po==0 && ne==0)System.out.println("YES");
    else if(po==1 && ne==0)System.out.println("YES");
    else if(po==0 && ne==-1)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
class Improve {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "ABCdcba" ;
     var u : Sequence(int) ; u := Integer.subrange(1,26)->collect(0) ;
    var n : int ; n := s->size() ;
        var i : int ; i := 0 ; while i < n do ( (     if ((s->at(i+1)->toUpperCase() = s->at(i+1))) then (     u[s->at(i+1) - 65+1] := u[s->at(i+1) - 65+1]+(1) ) else (     u[s->at(i+1) - 97+1] := u[s->at(i+1) - 97+1]-(1) ) )  ;     i := i + 1 ) ; 
    var f1 : boolean ; f1 := true ;
    var po : int ; po := 0 ;
    var ne : int ; ne := 0 ;
        var i : int ; i := 0 ; while i < 26 do ( (     if (u[i+1] > 0) then     po := po+(u[i+1]) ; else skip ; 
     if (u[i+1] < 0) then     ne := ne+(u[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    if (po = 0 & ne = 0) then     OclFile["System.out"].println("YES") else     if (po = 1 & ne = 0) then     OclFile["System.out"].println("YES") else     if (po = 0 & ne = -1) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  ;  ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class C {
  private class Hiker implements Comparable<Hiker>{
    long nextCompletion ;
    long timeForLap ;
    int lap ;
    Hiker(long nextCompletion,long timeForLap,int lap){
      this.nextCompletion=nextCompletion ;
      this.timeForLap=timeForLap ;
      this.lap=lap ;
    }
    @ Override public int compareTo(Hiker that){
      if(this.nextCompletion<that.nextCompletion){
        return-1 ;
      }
      else if(this.nextCompletion>that.nextCompletion){
        return 1 ;
      }
      else {
        return that.lap-this.lap ;
      }
    }
  }
  String solve(Scanner sc){
    PriorityQueue<Hiker>pq=new PriorityQueue<Hiker>();
    int N=sc.nextInt();
    for(int i=0 ; i<N ; i++){
      int D=sc.nextInt();
      int H=sc.nextInt();
      long M=sc.nextLong();
      for(int j=0 ; j<H ; j++){
        long timeForLap=M+j ;
        pq.add(new Hiker((360-D)*timeForLap,timeForLap,0));
      }
    }
    int s=pq.size();
    int limit=s*2 ;
    int min=s ;
    for(int i=0 ; i<10*limit ; i++){
      Hiker h=pq.poll();
      if(h.lap==0){
        s--;
      }
      else {
        s++;
      }
      min=Math.min(min,s);
      pq.add(new Hiker(h.nextCompletion+360*h.timeForLap,h.timeForLap,h.lap+1));
    }
    return ""+min ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    for(int cs=1 ; cs<=T ; cs++){
      String res=new C().solve(sc);
      System.out.println("Case #"+cs+": "+res);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
 class Hiker implements Comparable<Hiker> {
   attribute nextCompletion : long;
   attribute timeForLap : long;
   attribute lap : int;
   static operation newHiker( nextCompletion : long, timeForLap : long, lap : int) : Hiker
  pre: true
  post: true
  activity:
  ( var self : Hiker ;
    self := createHiker();
    self.initialise(nextCompletion, timeForLap,lap);
    return self );
  operation initialise( nextCompletion : long, timeForLap : long, lap : int) : void
  pre: true  post: true
  activity: (     self.nextCompletion := nextCompletion ; 
     self.timeForLap := timeForLap ; 
     self.lap := lap );
      operation compareTo( that : Hiker) : int
  pre: true
  post: true
  activity: (     if (self.nextCompletion < that.nextCompletion) then (     return -1 ) else     if (self.nextCompletion > that.nextCompletion) then (     return 1 ) else (     return that.lap - self.lap ) ;  );
}
   operation solve( sc : OclFile) : String
  pre: true
  post: true
  activity: (     var pq : Sequence(Hiker) ; pq := Sequence{} ;
     var N : int ; N := sc.nextInt() ;
        var i : int ; i := 0 ; while i < N do ( (     var D : int ; D := sc.nextInt() ;
     var H : int ; H := sc.nextInt() ;
     var M : long ; M := sc.nextLong() ;
         var j : int ; j := 0 ; while j < H do ( (     var timeForLap : long ; timeForLap := M + j ;
     pq := pq->including(Hiker.newHiker((360 - D) * timeForLap, timeForLap, 0)) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var s : int ; s := pq->size() ;
    var limit : int ; limit := s * 2 ;
    var min : int ; min := s ;
        var i : int ; i := 0 ; while i < 10 * limit do ( (     var h : Hiker ; h := pq->min() ;
     if (h.lap = 0) then (     s := s - 1 ) else (     s := s + 1 ) ;  
     min := Set{min, s}->min() ; 
     pq := pq->including(Hiker.newHiker(h.nextCompletion + 360 * h.timeForLap, h.timeForLap, h.lap + 1)) )  ;     i := i + 1 ) ; 
    return "" + min 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var cs : int ; cs := 1 ; while cs <= T do ( (     var res : String ; res := C.newC().solve(sc) ;
     OclFile["System.out"].println("Case #" + cs + ": " + res) )  ;     cs := cs + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long a=in.nextLong();
    long b=in.nextLong();
    long mul=1 ;
    while(b>a){
      long rem=b % 10 ;
      mul*=rem ;
      if(mul==0)break ;
      b--;
    }
    if(mul>9)System.out.println(mul % 10);
    else System.out.println(mul);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : long ; a := in.getCurrent()->toLong() ;
    var b : long ; b := in.getCurrent()->toLong() ;
    var mul : long ; mul := 1 ;
    while (b > a) do (     var rem : long ; rem := b mod 10 ;
     mul := mul*(rem) ; 
     if (mul = 0) then     break else skip ; 
     b := b - 1 ) ; 
    if (mul > 9) then     OclFile["System.out"].println(mul mod 10) else     OclFile["System.out"].println(mul) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int[][] dp=new int[15][2];
  static String convertToString(int num){
    return String.valueOf(num);
  }
  static int calculate(int pos,int tight,int D[],int sz,String num){
    if(pos==num.length())return 1 ;
    if(dp[pos][tight]!=-1)return dp[pos][tight];
    int val=0 ;
    if(tight==0){
      for(int i=0 ; i<sz ; i++){
        if(D[i]<(num.charAt(pos)-'0')){
          val+=calculate(pos+1,1,D,sz,num);
        }
        else if(D[i]==num.charAt(pos)-'0')val+=calculate(pos+1,tight,D,sz,num);
      }
    }
    else {
      for(int i=0 ; i<sz ; i++){
        val+=calculate(pos+1,tight,D,sz,num);
      }
    }
    return dp[pos][tight]=val ;
  }
  static int countNumbers(int D[],int N,int sz){
    String num=convertToString(N);
    int len=num.length();
    for(int i=0 ; i<15 ; i++)for(int j=0 ; j<2 ; j++)dp[i][j]=-1 ;
    int ans=calculate(0,0,D,sz,num);
    for(int i=1 ; i<len ; i++)ans+=calculate(i,1,D,sz,num);
    return ans ;
  }
  public static void main(String[] args){
    int sz=3 ;
    int D[]={
      1,4,9 };
      int N=10 ;
      System.out.print(countNumbers(D,N,sz));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute dp : Sequence(Sequence(int)) := Integer.subrange(1,15)->collect(Integer.subrange(1,2)->collect(0));
  static   operation convertToString( num : int) : String
  pre: true
  post: true
  activity: (     return ((num) + "") );
  static   operation calculate( pos : int, tight : int, D : Sequence(int), sz : int, num : String) : int
  pre: true
  post: true
  activity: (     if (pos = num->size()) then     return 1 else skip ; 
     if (dp[pos+1][tight+1] /= -1) then     return dp[pos+1][tight+1] else skip ; 
    var val : int ; val := 0 ;
    if (tight = 0) then (         var i : int ; i := 0 ; while i < sz do ( (     if (D[i+1] < (num->at(pos+1) - ('0')->char2byte())) then (     val := val+(calculate(pos + 1, 1, D, sz, num)) ) else     if (D[i+1] = num->at(pos+1) - ('0')->char2byte()) then     val := val+(calculate(pos + 1, tight, D, sz, num)) ; else skip ; )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < sz do ( (     val := val+(calculate(pos + 1, tight, D, sz, num)) )  ;     i := i + 1 ) ) ;  
    return dp[pos+1][tight+1] 
 );
  static   operation countNumbers( D : Sequence(int), N : int, sz : int) : int
  pre: true
  post: true
  activity: (     var num : String ; num := convertToString(N) ;
     var len : int ; len := num->size() ;
        var i : int ; i := 0 ; while i < 15 do (         var j : int ; j := 0 ; while j < 2 do (     dp[i+1][j+1] := -1 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := calculate(0, 0, D, sz, num) ;
        var i : int ; i := 1 ; while i < len do (     ans := ans+(calculate(i, 1, D, sz, num)) ;  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sz : int ; sz := 3 ;
     var D : Sequence(int) ; D := Sequence{1,4,9} ;
     var N : int ; N := 10 ;
     OclFile["System.out"].print(countNumbers(D, N, sz)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GfG {
  static class Node {
    int data ;
    Node next ;
  }
  static Node head=null ;
  static Node Reverse(Node head,int k){
    Stack<Node>mystack=new Stack<Node>();
    Node current=head ;
    Node prev=null ;
    while(current!=null){
      int count=0 ;
      while(current!=null && count<k){
        mystack.push(current);
        current=current.next ;
        count++;
      }
      while(mystack.size()>0){
        if(prev==null){
          prev=mystack.peek();
          head=prev ;
          mystack.pop();
        }
        else {
          prev.next=mystack.peek();
          prev=prev.next ;
          mystack.pop();
        }
      }
    }
    prev.next=null ;
    return head ;
  }
  static void push(int new_data){
    Node new_node=new Node();
    new_node.data=new_data ;
    new_node.next=head ;
    head=new_node ;
  }
  static void printList(Node node){
    while(node!=null){
      System.out.print(node.data+" ");
      node=node.next ;
    }
  }
  public static void main(String[] args){
    push(9);
    push(8);
    push(7);
    push(6);
    push(5);
    push(4);
    push(3);
    push(2);
    push(1);
    System.out.println("Given linked list ");
    printList(head);
    head=Reverse(head,3);
    System.out.println();
    System.out.println("Reversed Linked list ");
    printList(head);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   attribute head : Node := null;
  static   operation Reverse( head : Node, k : int) : Node
  pre: true
  post: true
  activity: (     var mystack : Sequence(Node) ; mystack := Sequence{} ;
     var current : Node ; current := head ;
    var prev : Node ; prev := null ;
    while (current /= null) do (     var count : int ; count := 0 ;
     while (current /= null & count < k) do (     mystack := mystack->append(current) ; 
     current := current.next ; 
     count := count + 1 ) ; 
     while (mystack->size() > 0) do (     if (prev = null) then (     prev := mystack->min() ; 
     head := prev ; 
     mystack := mystack->front() ) else (     prev.next := mystack->min() ; 
     prev := prev.next ; 
     mystack := mystack->front() ) ) ) ; 
    prev.next := null ; 
    return head 
 );
  static   operation push( new_data : int) : void
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode() ;
     new_node.data := new_data ; 
     new_node.next := head ; 
     head := new_node );
  static   operation printList( node : Node) : void
  pre: true
  post: true
  activity: (     while (node /= null) do (     OclFile["System.out"].print(node.data + " ") ; 
     node := node.next ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute push(9) ; 
     execute push(8) ; 
    execute push(7) ; 
    execute push(6) ; 
    execute push(5) ; 
    execute push(4) ; 
    execute push(3) ; 
    execute push(2) ; 
    execute push(1) ; 
    OclFile["System.out"].println("Given linked list ") ; 
    execute printList(head) ; 
    head := Reverse(head, 3) ; 
    OclFile["System.out"].println() ; 
    OclFile["System.out"].println("Reversed Linked list ") ; 
    execute printList(head) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int i,j,n ;
    ArrayList<Article>list=new ArrayList<Article>();
    try(Scanner sc=new Scanner(System.in)){
      n=sc.nextInt();
      for(i=0 ; i<n ; i++){
        Article article=new Article(sc.nextInt(),sc.nextInt(),sc.next(),sc.nextLong(),sc.next());
        list.add(article);
      }
      Comparator<Article>comparator=Comparator.comparing(Article :: getValue).thenComparing(Article :: getHeight).thenComparing(Article :: gettype).thenComparing(Article :: getDate).thenComparing(Article :: getName);
      list.stream().sorted(comparator).forEach(a->System.out.println(a.getValue()+" "+a.getHeight()+" "+a.gettype()+" "+a.getDate()+" "+a.getName()));
    }
  }
}
class Article {
  private int value ;
  private int height ;
  private String type ;
  private long date ;
  private String name ;
  public Article(int value,int height,String type,long date,String name){
    this.value=value ;
    this.height=height ;
    this.type=type ;
    this.date=date ;
    this.name=name ;
  }
  public int getValue(){
    return this.value ;
  }
  public int getHeight(){
    return this.height ;
  }
  public String gettype(){
    return this.type ;
  }
  public long getDate(){
    return this.date ;
  }
  public String getName(){
    return this.name ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var n : int ;
     var list : Sequence(Article) ; list := Sequence{} ;
     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     n := sc.getCurrent()->toInteger() ; 
         i := 0 ; while i < n do ( (     var article : Article ; article := Article.newArticle(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger(), sc.getCurrent(), sc.getCurrent()->toLong(), sc.getCurrent()) ;
     list := list->including(article) )  ;     i := i + 1 ) ; 
     var comparator : Function(<Article>,(<Article>,boolean)) ; comparator := Comparator.comparing(lambda _pars : OclAny in Article.newArticle().getValue(_pars)).thenComparing(lambda _pars : OclAny in Article.newArticle().getHeight(_pars)).thenComparing(lambda _pars : OclAny in Article.newArticle().gettype(_pars)).thenComparing(lambda _pars : OclAny in Article.newArticle().getDate(_pars)).thenComparing(lambda _pars : OclAny in Article.newArticle().getName(_pars)) ;
     for a : list->sort() do
    (    OclFile["System.out"].println(a.getValue() + " " + a.getHeight() + " " + a.gettype() + " " + a.getDate() + " " + a.getName())) ))  );
}
class Article {
   attribute value : int;
   attribute height : int;
   attribute type : String;
   attribute date : long;
   attribute name : String;
   static operation newArticle( value : int, height : int, type : String, date : long, name : String) : Article
  pre: true
  post: true
  activity:
  ( var self : Article ;
    self := createArticle();
    self.initialise(value, height,type,date,name);
    return self );
  operation initialise( value : int, height : int, type : String, date : long, name : String) : void
  pre: true  post: true
  activity: (     self.value := value ; 
     self.height := height ; 
    self.type := type ; 
    self.date := date ; 
    self.name := name ; 
 );
   operation getValue() : int
  pre: true
  post: true
  activity: (     return self.value );
   operation getHeight() : int
  pre: true
  post: true
  activity: (     return self.height );
   operation gettype() : String
  pre: true
  post: true
  activity: (     return self.type );
   operation getDate() : long
  pre: true
  post: true
  activity: (     return self.date );
   operation getName() : String
  pre: true
  post: true
  activity: (     return self.name );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    final int n=scanner.nextInt();
    int min=200001 ;
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      int p=scanner.nextInt();
      if(p<=min){
        count++;
        min=p ;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var min : int ; min := 200001 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var p : int ; p := scanner.getCurrent()->toInteger() ;
     if (p <= min) then (     count := count + 1 ; 
     min := p ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Product[] products=new Product[n];
    for(int i=0 ; i<n ; i++){
      products[i]=new Product(sc.nextInt(),sc.nextInt(),sc.next().charAt(0),sc.nextLong(),sc.next());
    }
    Arrays.sort(products);
    StringBuilder sb=new StringBuilder();
    for(Product p : products){
      sb.append(p).append("\n");
    }
    System.out.print(sb);
  }
  static class Product implements Comparable<Product>{
    int value ;
    int weight ;
    char type ;
    long datetime ;
    String name ;
    public Product(int value,int weight,char type,long datetime,String name){
      this.value=value ;
      this.weight=weight ;
      this.type=type ;
      this.datetime=datetime ;
      this.name=name ;
    }
    public int compareTo(Product another){
      if(value!=another.value){
        return value-another.value ;
      }
      else if(weight!=another.weight){
        return weight-another.weight ;
      }
      else if(type!=another.type){
        return type-another.type ;
      }
      else if(datetime!=another.datetime){
        if(datetime<another.datetime){
          return-1 ;
        }
        else {
          return 1 ;
        }
      }
      else {
        return name.compareTo(another.name);
      }
    }
    public String toString(){
      return value+" "+weight+" "+type+" "+datetime+" "+name ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var products : Sequence(Product) ; products := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     products[i+1] := Product.newProduct(sc.getCurrent()->toInteger(), sc.getCurrent()->toInteger(), sc.getCurrent()->at(0+1), sc.getCurrent()->toLong(), sc.getCurrent()) )  ;     i := i + 1 ) ; 
    products := products->sort() ; 
    var sb : String ; sb := StringLib.newString() ;
    for (p : products) do ( (     sb := sb + StringLib.newString(p) + StringLib.newString("\n") )  ) ; 
    OclFile["System.out"].print(sb) ; 
 );
  static class Product implements Comparable<Product> {
   attribute value : int;
   attribute weight : int;
   attribute type : String;
   attribute datetime : long;
   attribute name : String;
   static operation newProduct( value : int, weight : int, type : String, datetime : long, name : String) : Product
  pre: true
  post: true
  activity:
  ( var self : Product ;
    self := createProduct();
    self.initialise(value, weight,type,datetime,name);
    return self );
  operation initialise( value : int, weight : int, type : String, datetime : long, name : String) : void
  pre: true  post: true
  activity: (     self.value := value ; 
     self.weight := weight ; 
    self.type := type ; 
    self.datetime := datetime ; 
    self.name := name ; 
 );
   operation compareTo( another : Product) : int
  pre: true
  post: true
  activity: (     if (value /= another.value) then (     return (value)->char2byte() - another.value ) else     if (weight /= another.weight) then (     return (weight)->char2byte() - another.weight ) else     if (type /= another.type) then (     return (type)->char2byte() - another.type ) else     if (datetime /= another.datetime) then (     if (datetime < another.datetime) then (     return -1 ) else (     return 1 ) ) else (     return name->compareTo(another.name) ) ;  ;  ;  );
   operation toString() : String
  pre: true
  post: true
  activity: (     return value + " " + weight + " " + type + " " + datetime + " " + name );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] arg){
    Scanner sc=new Scanner(System.in);
    List<Sortingtuples>list=new ArrayList<Sortingtuples>();
    int cnt=sc.nextInt();
    for(int i=0 ; i<cnt ; i++){
      int money=sc.nextInt();
      int weight=sc.nextInt();
      String type=sc.next();
      long date=sc.nextLong();
      String name=sc.next();
      list.add(new Sortingtuples(money,weight,type,date,name));
    }
    list.sort(Comparator.comparing(Sortingtuples :: getmoney).thenComparing(Sortingtuples :: getweight).thenComparing(Sortingtuples :: gettype).thenComparingLong(Sortingtuples :: getdate).thenComparing(Sortingtuples :: getname));
    for(Sortingtuples demo : list){
      System.out.println(demo);
    }
  }
}
class Sortingtuples {
  private int money ;
  private int weight ;
  private String type ;
  private long date ;
  private String name ;
  public Sortingtuples(int money,int weight,String type,long date,String name){
    this.money=money ;
    this.weight=weight ;
    this.type=type ;
    this.date=date ;
    this.name=name ;
  }
  public int getmoney(){
    return money ;
  }
  public int getweight(){
    return weight ;
  }
  public String gettype(){
    return type ;
  }
  public long getdate(){
    return date ;
  }
  public String getname(){
    return name ;
  }
  public String toString(){
    return money+" "+weight+" "+type+" "+date+" "+name ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var list : Sequence(Sortingtuples) ; list := Sequence{} ;
    var cnt : int ; cnt := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < cnt do ( (     var money : int ; money := sc.getCurrent()->toInteger() ;
     var weight : int ; weight := sc.getCurrent()->toInteger() ;
    var type : String ; type := sc.getCurrent() ;
    var date : long ; date := sc.getCurrent()->toLong() ;
    var name : String ; name := sc.getCurrent() ;
    list := list->including(Sortingtuples.newSortingtuples(money, weight, type, date, name)) ; 
 )  ;     i := i + 1 ) ; 
    list := list.sort(Comparator.comparing(lambda _pars : OclAny in Sortingtuples.newSortingtuples().getmoney(_pars)).thenComparing(lambda _pars : OclAny in Sortingtuples.newSortingtuples().getweight(_pars)).thenComparing(lambda _pars : OclAny in Sortingtuples.newSortingtuples().gettype(_pars)).thenComparingLong(lambda _pars : OclAny in Sortingtuples.newSortingtuples().getdate(_pars)).thenComparing(lambda _pars : OclAny in Sortingtuples.newSortingtuples().getname(_pars))) ; 
    for (demo : list) do ( (     OclFile["System.out"].println(demo) )  ) ; 
 );
}
class Sortingtuples {
   attribute money : int;
   attribute weight : int;
   attribute type : String;
   attribute date : long;
   attribute name : String;
   static operation newSortingtuples( money : int, weight : int, type : String, date : long, name : String) : Sortingtuples
  pre: true
  post: true
  activity:
  ( var self : Sortingtuples ;
    self := createSortingtuples();
    self.initialise(money, weight,type,date,name);
    return self );
  operation initialise( money : int, weight : int, type : String, date : long, name : String) : void
  pre: true  post: true
  activity: (     self.money := money ; 
     self.weight := weight ; 
    self.type := type ; 
    self.date := date ; 
    self.name := name ; 
 );
   operation getmoney() : int
  pre: true
  post: true
  activity: (     return money );
   operation getweight() : int
  pre: true
  post: true
  activity: (     return weight );
   operation gettype() : String
  pre: true
  post: true
  activity: (     return type );
   operation getdate() : long
  pre: true
  post: true
  activity: (     return date );
   operation getname() : String
  pre: true
  post: true
  activity: (     return name );
   operation toString() : String
  pre: true
  post: true
  activity: (     return money + " " + weight + " " + type + " " + date + " " + name );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static void checkIfPossibleRec(int x,int a,int b,boolean isPossible[],int n){
    if(x>n)return ;
    if(isPossible[x])return ;
    isPossible[x]=true ;
    checkIfPossibleRec(x+a,a,b,isPossible,n);
    checkIfPossibleRec(x+b,a,b,isPossible,n);
  }
  static boolean checkPossible(int n,int a,int b){
    boolean isPossible[]=new boolean[n+1];
    for(int i=0 ; i<=n ; i++)isPossible[i]=false ;
    checkIfPossibleRec(0,a,b,isPossible,n);
    return isPossible[n];
  }
  public static void main(String args[]){
    int a=3,b=7,n=8 ;
    if(checkPossible(a,b,n))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation checkIfPossibleRec( x : int, a : int, b : int, isPossible : Sequence(boolean), n : int) : void
  pre: true
  post: true
  activity: (     if (x > n) then     return else skip ; 
     if (isPossible[x+1]) then     return else skip ; 
    isPossible[x+1] := true ; 
    execute checkIfPossibleRec(x + a, a, b, isPossible, n) ; 
    execute checkIfPossibleRec(x + b, a, b, isPossible, n) ; 
 );
  static   operation checkPossible( n : int, a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     var isPossible : Sequence(boolean) ; isPossible := Integer.subrange(1,n + 1)->collect(false) ;
         var i : int ; i := 0 ; while i <= n do (     isPossible[i+1] := false ;  ;     i := i + 1 ) ; 
     execute checkIfPossibleRec(0, a, b, isPossible, n) ; 
     return isPossible[n+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var b : int ; b := 7 ;
    var n : int ; n := 8 ;
     if (checkPossible(a, b, n)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
class Test {
  static int arr[]=new int[] {
    1,2,3,4 };
    static void printSubsequences(int n){
      int opsize=(int)Math.pow(2,n);
      for(int counter=1 ; counter<opsize ; counter++){
        for(int j=0 ; j<n ; j++){
          if(BigInteger.valueOf(counter).testBit(j))System.out.print(arr[j]+" ");
        }
        System.out.println();
      }
    }
    public static void main(String[] args){
      System.out.println("All Non-empty Subsequences");
      printSubsequences(arr.length);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Test {
  static   attribute arr : int := Sequence{1,2,3,4};
  static   operation printSubsequences( n : int) : void
  pre: true
  post: true
  activity: (     var opsize : int ; opsize := 2->pow(n)->oclAsType(int) ;
         var counter : int ; counter := 1 ; while counter < opsize do ( (         var j : int ; j := 0 ; while j < n do ( (     if ((counter + "")->toLong().testBit(j)) then     OclFile["System.out"].print(arr[j+1] + " ") ; else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     counter := counter + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("All Non-empty Subsequences") ; 
     execute printSubsequences(arr->size()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int c=sc.nextInt();
    int d=sc.nextInt();
    int e=sc.nextInt();
    int k=sc.nextInt();
    System.out.println(e-a<=k ? "Yay!" : ":(");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var e : int ; e := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(if e - a <= k then "Yay!" else ":(" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.nio.charset.MalformedInputException ;
import java.util.StringTokenizer ;
import java.util.Arrays ;
public class Cv {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    Scanner sc=new Scanner(System.in);
    PrintWriter o=new PrintWriter(System.out);
    long a=sc.nextLong();
    long b=sc.nextLong();
    if((b-a)>=5){
      o.println(0);
    }
    else {
      long h=a % 10 ;
      long j=b % 10 ;
      long k=1 ;
      while(h % 10!=j){
        h++;
        k*=h ;
      }
      o.println(k % 10);
    }
    o.close();
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! st.hasMoreElements()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
    byte nextByte(){
      return Byte.parseByte(next());
    }
    short nextShort(){
      return Short.parseShort(next());
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return java.lang.Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Cv {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var o : OclFile ; o := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    if ((b - a) >= 5) then (     skip ) else (     var h : long ; h := a mod 10 ;
     var j : long ; j := b mod 10 ;
    var k : long ; k := 1 ;
    while (h mod 10 /= j) do (     h := h + 1 ; 
     k := k*(h) ) ; 
    skip ; 
 ) ;  
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
   operation nextByte() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextShort() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return java.lang.Long.parseLong(next()) );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    int D=sc.nextInt();
    int E=sc.nextInt();
    int K=sc.nextInt();
    if(E-A<=K){
      System.out.println("Yay!");
    }
    else {
      System.out.println(":(");
    }
  }
}
class Pair implements Comparable {
  int from ;
  int end ;
  @ Override public int compareTo(Object other){
    Pair otherpair=(Pair)other ;
    return from-otherpair.from ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    var C : int ; C := sc.getCurrent()->toInteger() ;
    var D : int ; D := sc.getCurrent()->toInteger() ;
    var E : int ; E := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    if (E - A <= K) then (     OclFile["System.out"].println("Yay!") ) else (     OclFile["System.out"].println(":(") ) ;  
 );
}
class Pair implements OclAny {
   attribute from : int;
   attribute end : int;
      operation compareTo( other : OclAny) : int
  pre: true
  post: true
  activity: (     var otherpair : Map ; otherpair := other->oclAsType(Map) ;
     return from - otherpair.from );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    A solver=new A();
    solver.solve(1,in,out);
    out.close();
  }
  static class A {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int a,b,c,d,e,k ;
      a=in.nextInt();
      b=in.nextInt();
      c=in.nextInt();
      d=in.nextInt();
      e=in.nextInt();
      k=in.nextInt();
      if(e-a>k){
        out.println(":(");
      }
      else {
        out.println("Yay!");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : A ; solver := A.newA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class A {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ;
    var b : int ;
    var c : int ;
    var d : int ;
    var e : int ;
    var k : int ;
     a := in.getCurrent()->toInteger() ; 
    b := in.getCurrent()->toInteger() ; 
    c := in.getCurrent()->toInteger() ; 
    d := in.getCurrent()->toInteger() ; 
    e := in.getCurrent()->toInteger() ; 
    k := in.getCurrent()->toInteger() ; 
    if (e - a > k) then (     skip ) else (     skip ) ;  
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
import java.util.function.*;
public class Main {
  public static void main(String[] args)throws Exception {
    System.out.println(solve());
  }
  private static int solve(){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(a==b){
      return a*2 ;
    }
    else if(a>b){
      return a*2-1 ;
    }
    else {
      return b*2-1 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(solve()) );
  static   operation solve() : int
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (a = b) then (     return a * 2 ) else     if (a > b) then (     return a * 2 - 1 ) else (     return b * 2 - 1 ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  private static final int ANTENNA_COUNT=5 ;
  public static void main(String[] args)throws Exception {
    try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in))){
      int[] antennas=new int[ANTENNA_COUNT];
      for(int i=0 ; i<ANTENNA_COUNT ; ++i){
        antennas[i]=Integer.parseInt(reader.readLine());
      }
      int maxDistance=Integer.parseInt(reader.readLine());
      test(antennas,maxDistance);
    }
  }
  public static void test(int[] antennas,int maxDistance){
    int offset=0 ;
    for(int a=0 ; a<ANTENNA_COUNT ; ++a){
++offset ;
      for(int b=offset ; b<ANTENNA_COUNT ; ++b){
        int distance=antennas[b]-antennas[a];
        if(distance>maxDistance){
          System.out.println(":(");
          return ;
        }
      }
    }
    System.out.println("Yay!");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute ANTENNA_COUNT : int := 5;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var reader : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     var antennas : Sequence(int) ; antennas := Integer.subrange(1,ANTENNA_COUNT)->collect(0) ;
         var i : int ; i := 0 ; while i < ANTENNA_COUNT do ( (     antennas[i+1] := (reader.readLine())->toInteger() )  ;     i := i + 1 ) ; 
     var maxDistance : int ; maxDistance := (reader.readLine())->toInteger() ;
     execute test(antennas, maxDistance) ))  );
  static   operation test( antennas : Sequence(int), maxDistance : int) : void
  pre: true
  post: true
  activity: (     var offset : int ; offset := 0 ;
         var a : int ; a := 0 ; while a < ANTENNA_COUNT do ( (     offset := offset + 1 ; 
         var b : int ; b := offset ; while b < ANTENNA_COUNT do ( (     var distance : int ; distance := antennas[b+1] - antennas[a+1] ;
     if (distance > maxDistance) then (     OclFile["System.out"].println(":(") ; 
     return ) else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
     OclFile["System.out"].println("Yay!") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int[] antennas=new int[5];
    int k=0 ;
    for(int i=0 ; i<6 && s.hasNextLine(); i++){
      if(i<5){
        antennas[i]=Integer.parseInt(s.nextLine());
      }
      else if(i==5){
        k=Integer.parseInt(s.nextLine());
      }
      else {
        System.exit(-1);
      }
    }
    if(available(antennas,k)){
      System.out.print("Yay!");
    }
    else {
      System.out.print(":(");
    }
  }
  public static boolean available(int[] antennas,int k){
    for(int i=0 ; i<antennas.length ; i++){
      for(int j=i+1 ; j<antennas.length ; j++){
        int distance=Math.abs(antennas[i]-antennas[j]);
        if(distance>k){
          return false ;
        }
      }
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var antennas : Sequence(int) ; antennas := Integer.subrange(1,5)->collect(0) ;
    var k : int ; k := 0 ;
        var i : int ; i := 0 ; while i < 6 & s.hasNextLine() do ( (     if (i < 5) then (     antennas[i+1] := (s.nextLine())->toInteger() ) else     if (i = 5) then (     k := (s.nextLine())->toInteger() ) else ( OclProcess.exit(-1) ) ;  )  ;     i := i + 1 ) ; 
    if (available(antennas, k)) then (     OclFile["System.out"].print("Yay!") ) else (     OclFile["System.out"].print(":(") ) ;  
 );
  static   operation available( antennas : Sequence(int), k : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < antennas->size() do ( (         var j : int ; j := i + 1 ; while j < antennas->size() do ( (     var distance : int ; distance := if antennas[i+1] - antennas[j+1] < 0 then -(antennas[i+1] - antennas[j+1]) else antennas[i+1] - antennas[j+1] endif ;
     if (distance > k) then (     return false ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int MAX=1000000 ;
  static Vector<Integer>arr=new Vector<>();
  static boolean[] sprime=new boolean[MAX];
  static void computeSemiPrime(){
    for(int i=0 ; i<MAX ; i++)sprime[i]=false ;
    for(int i=2 ; i<MAX ; i++){
      int cnt=0 ;
      int num=i ;
      for(int j=2 ; cnt<2 && j*j<=num ; ++j){
        while(num % j==0){
          num/=j ;
++cnt ;
        }
      }
      if(num>1)++cnt ;
      if(cnt==2){
        sprime[i]=true ;
        arr.add(i);
      }
    }
  }
  static boolean checkSemiPrime(int n){
    int i=0 ;
    while(arr.get(i)<=n/2){
      if(sprime[n-arr.get(i)]){
        return true ;
      }
      i++;
    }
    return false ;
  }
  public static void main(String[] args){
    computeSemiPrime();
    int n=30 ;
    if(checkSemiPrime(n))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute MAX : int := 1000000;
  static   attribute arr : Sequence(int) := Sequence{};
  static   attribute sprime : Sequence(boolean) := Integer.subrange(1,MAX)->collect(false);
  static   operation computeSemiPrime() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < MAX do (     sprime[i+1] := false ;  ;     i := i + 1 ) ; 
         var i : int ; i := 2 ; while i < MAX do ( (     var cnt : int ; cnt := 0 ;
     var num : int ; num := i ;
        var j : int ; j := 2 ; while cnt < 2 & j * j <= num do ( (     while (num mod j = 0) do (     num := num/(j) ; 
     cnt := cnt + 1 ) )  ;     j := j + 1 ) ; 
    if (num > 1) then     cnt := cnt + 1 ; else skip ; 
    if (cnt = 2) then (     sprime[i+1] := true ; 
     arr := arr->including(i) ) else skip ; 
 )  ;     i := i + 1 ) );
  static   operation checkSemiPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
     while (arr->at(i+1) <= n / 2) do (     if (sprime[n - arr->at(i+1)+1]) then (     return true ) else skip ; 
     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute computeSemiPrime() ; 
     var n : int ; n := 30 ;
     if (checkSemiPrime(n)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A1501 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int T=in.nextInt();
    for(int t=0 ; t<T ; t++){
      int N=in.nextInt();
      int[] A=new int[N];
      int[] B=new int[N];
      for(int n=0 ; n<N ; n++){
        A[n]=in.nextInt();
        B[n]=in.nextInt();
      }
      int[] M=new int[N];
      for(int n=0 ; n<N ; n++){
        M[n]=in.nextInt();
      }
      int arrival=0 ;
      int departure=0 ;
      for(int n=0 ; n<N ; n++){
        arrival=departure+A[n]-(n==0 ? 0 : B[n-1])+M[n];
        departure=Math.max(B[n],arrival+(B[n]-A[n]+1)/2);
      }
      pw.println(arrival);
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A1501 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() ; 
     B[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var M : Sequence(int) ; M := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     M[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var arrival : int ; arrival := 0 ;
    var departure : int ; departure := 0 ;
        var n : int ; n := 0 ; while n < N do ( (     arrival := departure + A[n+1] - (if n = 0 then 0 else B[n - 1+1] endif) + M[n+1] ; 
     departure := Set{B[n+1], arrival + (B[n+1] - A[n+1] + 1) / 2}->max() )  ;     n := n + 1 ) ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int[] a=new int[n];
      int[] b=new int[n];
      for(int i=0 ; i<n ; ++i){
        a[i]=sc.nextInt();
        b[i]=sc.nextInt();
      }
      int[] tm=new int[n];
      for(int i=0 ; i<tm.length ; ++i){
        tm[i]=sc.nextInt();
      }
      System.out.println(solve(a,b,tm));
    }
    sc.close();
  }
  static int solve(int[] a,int[] b,int[] tm){
    int time=0 ;
    for(int i=0 ; i<a.length ; ++i){
      time+=a[i]-((i==0)? 0 : b[i-1])+tm[i];
      if(i!=a.length-1){
        time=Math.max(b[i],time+(b[i]-a[i]+1)/2);
      }
    }
    return time ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var tm : Sequence(int) ; tm := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < tm->size() do ( (     tm[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(a, b, tm)) ; 
 )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : Sequence(int), b : Sequence(int), tm : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var time : int ; time := 0 ;
         var i : int ; i := 0 ; while i < a->size() do ( (     time := time+(a[i+1] - (if (i = 0) then 0 else b[i - 1+1] endif) + tm[i+1]) ; 
     if (i /= a->size() - 1) then (     time := Set{b[i+1], time + (b[i+1] - a[i+1] + 1) / 2}->max() ) else skip )  ;     i := i + 1 ) ; 
     return time );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int anli=sc.nextInt();
    for(int i=0 ; i<anli ; i++){
      int nation=sc.nextInt();
      int[] a=new int[nation+1];
      int[] b=new int[nation+1];
      int[] t=new int[nation+1];
      a[0]=0 ;
      b[0]=0 ;
      for(int j=1 ; j<=nation ; j++){
        a[j]=sc.nextInt();
        b[j]=sc.nextInt();
      }
      for(int j=1 ; j<=nation ; j++){
        t[j]=sc.nextInt();
      }
      int c=0 ;
      for(int j=1 ; j<nation ; j++){
        c=c+a[j]-b[j-1]+t[j];
        c=c+(b[j]-a[j]+1)/2 ;
        if(c<b[j])c=b[j];
      }
      c=c+(a[nation]-b[nation-1])+t[nation];
      System.out.println(c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var anli : int ; anli := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < anli do ( (     var nation : int ; nation := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,nation + 1)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,nation + 1)->collect(0) ;
    var t : Sequence(int) ; t := Integer.subrange(1,nation + 1)->collect(0) ;
    a[0+1] := 0 ; 
    b[0+1] := 0 ; 
        var j : int ; j := 1 ; while j <= nation do ( (     a[j+1] := sc.getCurrent()->toInteger() ; 
     b[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
        var j : int ; j := 1 ; while j <= nation do ( (     t[j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    var c : int ; c := 0 ;
        var j : int ; j := 1 ; while j < nation do ( (     c := c + a[j+1] - b[j - 1+1] + t[j+1] ; 
     c := c + (b[j+1] - a[j+1] + 1) / 2 ; 
     if (c < b[j+1]) then     c := b[j+1] ; else skip )  ;     j := j + 1 ) ; 
    c := c + (a[nation+1] - b[nation - 1+1]) + t[nation+1] ; 
    OclFile["System.out"].println(c) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] count=new int[26];
    while(sc.hasNext()){
      String line=sc.nextLine();
      line=line.toLowerCase();
      char[] ch=line.toCharArray();
      for(int i=0 ; i<ch.length ; i++){
        int n=ch[i]-'a' ;
        if(0<=n && n<=25){
          count[n]++;
        }
      }
    }
    for(int i=0 ; i<count.length ; i++){
      char c=(char)(i+'a');
      System.out.println(c+" : "+count[i]);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var count : Sequence(int) ; count := Integer.subrange(1,26)->collect(0) ;
    while (sc.hasNext()) do (     var line : String ; line := sc.nextLine() ;
     line := line->toLowerCase() ; 
     var ch : Sequence(String) ; ch := line->characters() ;
         var i : int ; i := 0 ; while i < ch->size() do ( (     var n : int ; n := ch[i+1] - ('a')->char2byte() ;
     if (0 <= n & n <= 25) then (     count[n+1] := count[n+1] + 1 ) else skip )  ;     i := i + 1 ) ) ; 
        var i : int ; i := 0 ; while i < count->size() do ( (     var c : String ; c := (i + 'a')->oclAsType(String) ;
     OclFile["System.out"].println(c + " : " + count[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    char[] alpha=new char[] {
      'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z' };
      int[] countList=new int[alpha.length];
      String str ;
      while((str=br.readLine())!=null){
        char[] input=str.toLowerCase().toCharArray();
        for(int i=0 ; i<input.length ; i++){
          for(int j=0 ; j<alpha.length ; j++){
            if(input[i]==alpha[j]){
              countList[j]+=1 ;
            }
          }
        }
      }
      for(int i=0 ; i<alpha.length ; i++){
        System.out.println(alpha[i]+" : "+countList[i]);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var alpha : Sequence(String) ; alpha := Sequence{'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'} ;
    var countList : Sequence(int) ; countList := Integer.subrange(1,alpha->size())->collect(0) ;
    var str : String ;
        str := br.readLine() ;
    while ((str) /= null) do (    skip ; (     var input : Sequence(String) ; input := str->toLowerCase()->characters() ;
         var i : int ; i := 0 ; while i < input->size() do ( (         var j : int ; j := 0 ; while j < alpha->size() do ( (     if (input[i+1] = alpha[j+1]) then (     countList[j+1] := countList[j+1]+(1) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) ;     str := br.readLine() ;
 ) ;  
        var i : int ; i := 0 ; while i < alpha->size() do ( (     OclFile["System.out"].println(alpha[i+1] + " : " + countList[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import static java.lang.Math.max ;
import static java.lang.Math.min ;
import static java.lang.System.out ;
public class pre127 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    long a=obj.nextLong(),b=obj.nextLong();
    long ans=1 ;
    for(long i=b ; i>a ; i--){
      ans*=i ;
      ans %=10 ;
      if(ans==0)break ;
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre127 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var a : long ; a := obj.nextLong() ;
    var b : long ; b := obj.nextLong() ;
    var ans : long ; ans := 1 ;
        var i : long ; i := b ; while i > a do ( (     ans := ans*(i) ; 
     ans := ans mod 10 ; 
     if (ans = 0) then     break else skip )  ;     i := i - 1 ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Alphabet {
  char ch ;
  int count=0 ;
  boolean with=false ;
  static List<Alphabet>abc=new ArrayList<Alphabet>();
  Alphabet(char ch){
    this.ch=ch ;
  }
}
public class Main {
  public static void main(String[] args)throws IOException {
    char a='a' ;
    for(int i=0 ; i<26 ; i++){
      Alphabet.abc.add(new Alphabet(a++));
    }
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str ;
    while((str=br.readLine())!=null){
      for(char c : str.toCharArray()){
        if(Character.isUpperCase(c)){
          c=Character.toLowerCase(c);
        }
        for(Alphabet x : Alphabet.abc){
          if(c==x.ch){
            x.with=true ;
            x.count++;
          }
        }
      }
    }
    for(Alphabet x : Alphabet.abc){
      System.out.println(x.ch+" : "+x.count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Alphabet {
   attribute ch : String;
   attribute count : int := 0;
   attribute with : boolean := false;
  static   attribute abc : Sequence(Alphabet) := Sequence{};
   static operation newAlphabet( ch : String) : Alphabet
  pre: true
  post: true
  activity:
  ( var self : Alphabet ;
    self := createAlphabet();
    self.initialise(ch);
    return self );
  operation initialise( ch : String) : void
  pre: true  post: true
  activity: (     self.ch := ch );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : String ; a := 'a' ;
         var i : int ; i := 0 ; while i < 26 do ( (     Alphabet.abc->excludes(Alphabet.newAlphabet(a)) )  ;     i := i + 1 ) ; 
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var str : String ;
        str := br.readLine() ;
    while ((str) /= null) do (    skip ; (     for (c : str->characters()) do ( (     if ((c->toUpperCase() = c)) then (     c := (c + "")->toLowerCase() ) else skip ; 
     for (x : Alphabet.abc) do ( (     if (c = x.ch) then (     x.with := true ; 
     x.count := x.count + 1 ) else skip )  ) )  ) ) ;     str := br.readLine() ;
 ) ;  
    for (x : Alphabet.abc) do ( (     OclFile["System.out"].println(x.ch + " : " + x.count) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
    }
    int[] copy=Arrays.copyOf(arr,arr.length);
    Arrays.sort(copy);
    int left=0,right=n ;
    long x=(long)n*(long)(n+1)/4 ;
    while(left+1<right){
      int mid=(left+right)/2 ;
      int am=copy[mid];
      int[] s=new int[n+1];
      for(int i=0 ; i<n ; i++){
        s[i+1]=am<=arr[i] ? 1 :-1 ;
      }
      for(int i=1 ; i<n+1 ; i++){
        s[i]+=s[i-1];
      }
      BIT bit=new BIT(2*n+1);
      long sum=0 ;
      for(int i=0 ; i<n+1 ; i++){
        sum+=bit.sum(s[i]+n);
        bit.add(s[i]+n,1);
      }
      if(x<=sum){
        left=mid ;
      }
      else {
        right=mid ;
      }
    }
    System.out.println(copy[left]);
  }
}
class BIT {
  private long[] bit ;
  public BIT(int size){
    bit=new long[size];
  }
  public long sum(int i){
    long s=0 ;
    while(0<i){
      s+=bit[i];
      i-=i &-i ;
    }
    return s ;
  }
  public void add(int i,long x){
    while(i<bit.length){
      bit[i]+=x ;
      i+=i &-i ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var copy : Sequence(int) ; copy := arr.subrange(1,arr->size()) ;
    copy := copy->sort() ; 
    var left : int ; left := 0 ;
    var right : int ; right := n ;
    var x : long ; x := n->oclAsType(long) * (n + 1)->oclAsType(long) / 4 ;
    while (left + 1 < right) do (     var mid : int ; mid := (left + right) / 2 ;
     var am : int ; am := copy[mid+1] ;
    var s : Sequence(int) ; s := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i + 1+1] := if am <= arr[i+1] then 1 else -1 endif )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n + 1 do ( (     s[i+1] := s[i+1]+(s[i - 1+1]) )  ;     i := i + 1 ) ; 
    var bit : BIT ; bit := BIT.newBIT(2 * n + 1) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n + 1 do ( (     sum := sum+(bit.sum(s[i+1] + n)) ; 
     bit->excludes(s[i+1] + n, 1) )  ;     i := i + 1 ) ; 
    if (x <= sum) then (     left := mid ) else (     right := mid ) ;  
 ) ; 
    OclFile["System.out"].println(copy[left+1]) ; 
 );
}
class BIT {
   attribute bit : Sequence(long);
   static operation newBIT( size : int) : BIT
  pre: true
  post: true
  activity:
  ( var self : BIT ;
    self := createBIT();
    self.initialise(size);
    return self );
  operation initialise( size : int) : void
  pre: true  post: true
  activity: (     bit := Integer.subrange(1,size)->collect(0) );
   operation sum( i : int) : long
  pre: true
  post: true
  activity: (     var s : long ; s := 0 ;
     while (0 < i) do (     s := s+(bit[i+1]) ; 
     i := i-(MathLib.bitwiseAnd(i,-i)) ) ; 
     return s );
   operation add( i : int, x : long) : void
  pre: true
  post: true
  activity: (     while (i < bit->size()) do (     bit[i+1] := bit[i+1]+(x) ; 
     i := i+(MathLib.bitwiseAnd(i,-i)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    sc.close();
    int sum=0 ;
    if(a>=b){
      sum+=a ;
      a=a-1 ;
    }
    else {
      sum+=b ;
      b=b-1 ;
    }
    if(a>=b){
      sum+=a ;
      a=a-1 ;
    }
    else {
      sum+=b ;
      b=b-1 ;
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    skip ; 
    var sum : int ; sum := 0 ;
    if (a >= b) then (     sum := sum+(a) ; 
     a := a - 1 ) else (     sum := sum+(b) ; 
     b := b - 1 ) ;  
    if (a >= b) then (     sum := sum+(a) ; 
     a := a - 1 ) else (     sum := sum+(b) ; 
     b := b - 1 ) ;  
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.*;
import java.awt.Graphics.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] $){
    Scanner sc=new Scanner(in);
    int[] ans=new int[1000000];
    while(sc.hasNext()){
      String s=sc.nextLine();
      for(int i=0 ; i<s.length(); i++){
        ans[Character.toLowerCase(s.charAt(i))]++;
      }
    }
    for(int i='a' ; i<='z' ; i++){
      out.println((char)i+" : "+ans[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var ans : Sequence(int) ; ans := Integer.subrange(1,1000000)->collect(0) ;
     while (sc.hasNext()) do (     var s : String ; s := sc.nextLine() ;
         var i : int ; i := 0 ; while i < s->size() do ( (     ans[(s->at(i+1) + "")->toLowerCase()+1] := ans[(s->at(i+1) + "")->toLowerCase()+1] + 1 )  ;     i := i + 1 ) ) ; 
         var i : int ; i := 'a' ; while i <= 'z' do ( (     out.println(i->oclAsType(String) + " : " + ans[i+1]) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedHashMap ;
import java.util.Map ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String abc="abcdefghijklmnopqrstuvwxyz" ;
    Map<String,Integer>map=new LinkedHashMap<String,Integer>();
    int i ;
    for(i=0 ; i<abc.length(); i++){
      map.put(abc.substring(i,i+1),0);
    }
    while(in.hasNext()){
      String input=in.next();
      for(i=0 ; i<input.length(); i++){
        String c=input.substring(i,i+1).toLowerCase();
        if(map.containsKey(c)){
          map.put(c,map.get(c)+1);
        }
      }
    }
    for(Map.Entry<String,Integer>e : map.entrySet()){
      System.out.println(e.getKey()+" : "+e.getValue());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var abc : String ; abc := "abcdefghijklmnopqrstuvwxyz" ;
    var map : Map(String,int) ; map := Map{} ;
    var i : int ;
        i := 0 ; while i < abc->size() do ( (     map := map->union(Map{abc.subrange(i+1,i + 1) |-> 0}) )  ;     i := i + 1 ) ; 
    while (in.hasNext()) do (     var input : String ; input := in.getCurrent() ;
         i := 0 ; while i < input->size() do ( (     var c : String ; c := input.subrange(i+1,i + 1)->toLowerCase() ;
     if (map->keys()->includes(c)) then (     map := map->union(Map{c |-> map->at(c) + 1}) ) else skip )  ;     i := i + 1 ) ) ; 
    for (e : map->asSet()) do ( (     OclFile["System.out"].println(e.getKey() + " : " + e.getValue()) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N,t ;
    N=sc.nextInt();
    t=sc.nextInt();
    BigDecimal tan=new BigDecimal(0);
    for(int i=0 ; i<N ; i++){
      BigDecimal x,h,_tan ;
      x=new BigDecimal(sc.next());
      h=new BigDecimal(sc.next());
      _tan=h.divide(x,10,BigDecimal.ROUND_HALF_UP);
      if(tan.compareTo(_tan)<0){
        tan=_tan ;
      }
    }
    System.out.println(tan.multiply(new BigDecimal(t)).toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ;
    var t : int ;
    N := sc.getCurrent()->toInteger() ; 
    t := sc.getCurrent()->toInteger() ; 
    var tan : double ; tan := double(0) ;
        var i : int ; i := 0 ; while i < N do ( (     var x : double ;
    var h : double ;
    var _tan : double ;
     x := double(sc.getCurrent()) ; 
    h := double(sc.getCurrent()) ; 
    _tan := h.divide(x, 10, ROUND_HALF_UP) ; 
    if (tan->compareTo(_tan) < 0) then (     tan := _tan ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(tan.multiply(double(t))+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigDecimal ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String args[]){
    BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    String str="" ;
    StringTokenizer stk ;
    try {
      str=bfr.readLine();
      if(str==""){
        System.exit(0);
      }
      stk=new StringTokenizer(str," ");
      int tatemono_kazu=Integer.parseInt(stk.nextToken());
      int tower_basyo=Integer.parseInt(stk.nextToken());
      int[][] tatemono=new int[tatemono_kazu][2];
      double[] katamuki=new double[tatemono_kazu];
      double katamuki_max=0 ;
      for(int i=0 ; i<tatemono_kazu ; i++){
        str=bfr.readLine();
        stk=new StringTokenizer(str," ");
        for(int j=0 ; j<2 ; j++){
          tatemono[i][j]=Integer.parseInt(stk.nextToken());
        }
        katamuki[i]=((double)(tatemono[i][1]))/((double)(tatemono[i][0]));
        if(katamuki_max<katamuki[i]){
          katamuki_max=katamuki[i];
        }
        if(str==""){
          System.exit(0);
        }
      }
      System.out.println(BigDecimal.valueOf(katamuki_max*((double)(tower_basyo))).toPlainString());
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bfr : OclFile ; bfr := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := "" ;
     var stk : OclIterator ;
     try (     str := bfr.readLine() ; 
     if (str = "") then ( OclProcess.exit(0) ) else skip ; 
    stk := OclIterator.newOclIterator_String_String(str, " ") ; 
    var tatemono_kazu : int ; tatemono_kazu := (stk.next())->toInteger() ;
    var tower_basyo : int ; tower_basyo := (stk.next())->toInteger() ;
    var tatemono : Sequence(Sequence(int)) ; tatemono := Integer.subrange(1,tatemono_kazu)->collect(Integer.subrange(1,2)->collect(0)) ;
    var katamuki : Sequence(double) ; katamuki := Integer.subrange(1,tatemono_kazu)->collect(0.0) ;
    var katamuki_max : double ; katamuki_max := 0 ;
        var i : int ; i := 0 ; while i < tatemono_kazu do ( (     str := bfr.readLine() ; 
     stk := OclIterator.newOclIterator_String_String(str, " ") ; 
        var j : int ; j := 0 ; while j < 2 do ( (     tatemono[i+1][j+1] := (stk.next())->toInteger() )  ;     j := j + 1 ) ; 
    katamuki[i+1] := ((tatemono[i+1][1+1])->oclAsType(double)) / ((tatemono[i+1][0+1])->oclAsType(double)) ; 
    if (katamuki_max < katamuki[i+1]) then (     katamuki_max := katamuki[i+1] ) else skip ; 
    if (str = "") then ( OclProcess.exit(0) ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((katamuki_max * ((tower_basyo)->oclAsType(double)) + "")->toReal().toPlainString()) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    double x=sc.nextDouble();
    double max_slope=0.0 ;
    for(int i=0 ; i<n ; ++i){
      double xi=sc.nextDouble();
      double hi=sc.nextDouble();
      double slope=hi/xi ;
      if(slope>max_slope)max_slope=slope ;
    }
    System.out.printf("%f",x*max_slope);
  }
  public static void main(String[] a){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : double ; x := sc.getCurrent()->toReal() ;
    var max_slope : double ; max_slope := 0.0 ;
        var i : int ; i := 0 ; while i < n do ( (     var xi : double ; xi := sc.getCurrent()->toReal() ;
     var hi : double ; hi := sc.getCurrent()->toReal() ;
     var slope : double ; slope := hi / xi ;
     if (slope > max_slope) then     max_slope := slope ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%f", x * max_slope) ; 
 );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    List<Double>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      list.add((double)y/(double)x);
    }
    Double max=list.stream().mapToDouble(Double :: doubleValue).max().getAsDouble();
    System.out.println(BigDecimal.valueOf(max*t).toPlainString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var list : Sequence(double) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
     list := list->including(y->oclAsType(double) / x->oclAsType(double)) )  ;     i := i + 1 ) ; 
    var max : double ; max := list->collect( _x1 | (lambda _pars : OclAny in Double.newDouble().doubleValue(_pars))->apply(_x1) ).max().getAsDouble() ;
    OclFile["System.out"].println((max * t + "")->toReal().toPlainString()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),m=sc.nextInt();
    double max=0 ;
    while(n-->0){
      double x=sc.nextDouble(),h=sc.nextDouble();
      max=Math.max(max,h/x);
    }
    System.out.printf("%.4f",max*m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var max : double ; max := 0 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var x : double ; x := sc.getCurrent()->toReal() ;
    var h : double ; h := sc.getCurrent()->toReal() ;
     max := Set{max, h / x}->max() ) ;  ) ;  
    OclFile["System.out"].printf("%.4f", max * m) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    HashMap<Integer,Integer>map=new HashMap<>();
    int n=sc.nextInt();
    int and=sc.nextInt();
    int x[]=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=sc.nextInt();
      if(map.containsKey(x[i])){
        System.out.println("0");
        System.exit(0);
      }
      else {
        map.put(x[i],1);
      }
    }
    for(int i=0 ; i<n ; i++){
      int temp=x[i] & and ;
      if(temp==x[i])continue ;
      if(map.containsKey(temp)){
        System.out.println("1");
        System.exit(0);
      }
    }
    HashMap<Integer,Integer>ands=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int temp=x[i] & and ;
      if(temp==x[i])continue ;
      if(ands.containsKey(temp)){
        System.out.println("2");
        System.exit(0);
      }
      else {
        ands.put(temp,1);
      }
    }
    System.out.println("-1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var map : Map(int,int) ; map := Map{} ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var and : int ; and := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toInteger() ; 
     if (map->keys()->includes(x[i+1])) then (     OclFile["System.out"].println("0") ; 
 OclProcess.exit(0) ) else (     map := map->union(Map{x[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var temp : int ; temp := MathLib.bitwiseAnd(x[i+1],and) ;
     if (temp = x[i+1]) then     continue else skip ; 
     if (map->keys()->includes(temp)) then (     OclFile["System.out"].println("1") ; 
 OclProcess.exit(0) ) else skip )  ;     i := i + 1 ) ; 
    var ands : Map(int,int) ; ands := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : int ; temp := MathLib.bitwiseAnd(x[i+1],and) ;
     if (temp = x[i+1]) then     continue else skip ; 
     if (ands->keys()->includes(temp)) then (     OclFile["System.out"].println("2") ; 
 OclProcess.exit(0) ) else (     ands := ands->union(Map{temp |-> 1}) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("-1") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int count(int n,int x){
    int count=0 ;
    for(int i=1 ; i<=n && i<=x ; i++){
      if(x/i<=n && x % i==0)count++;
    }
    return count ;
  }
  public static void main(String args[]){
    int n=8 ;
    int x=24 ;
    System.out.println(count(n,x));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation count( n : int, x : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 1 ; while i <= n & i <= x do ( (     if (x / i <= n & x mod i = 0) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 8 ;
     var x : int ; x := 24 ;
     OclFile["System.out"].println(count(n, x)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class B_The_Eternal_Immortality {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    long A=reader.nextLong();
    long B=reader.nextLong();
    long res=1 ;
    long i=B ;
    while(i>A){
      res=((res % 10)*(i % 10))% 10 ;
      if(res==0){
        break ;
      }
      i--;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_The_Eternal_Immortality {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var A : long ; A := reader.nextLong() ;
    var B : long ; B := reader.nextLong() ;
    var res : long ; res := 1 ;
    var i : long ; i := B ;
    while (i > A) do (     res := ((res mod 10) * (i mod 10)) mod 10 ; 
     if (res = 0) then (     break ) else skip ; 
     i := i - 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      if(a>b){
        System.out.println(a+Math.max(a-1,b));
      }
      else {
        System.out.println(b+Math.max(a,b-1));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     var b : int ; b := scanner.getCurrent()->toInteger() ;
     if (a > b) then (     OclFile["System.out"].println(a + Set{a - 1, b}->max()) ) else (     OclFile["System.out"].println(b + Set{a, b - 1}->max()) ) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static StringBuilder findMaximumNum(StringBuilder str,int n,int k){
    for(int i=0 ; i<n ; i++){
      if(k<1)break ;
      if(str.charAt(i)!='9'){
        str.setCharAt(i,'9');
        k--;
      }
    }
    return str ;
  }
  public static void main(String[] args){
    StringBuilder str=new StringBuilder("569431");
    int n=str.length();
    int k=3 ;
    System.out.println(findMaximumNum(str,n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMaximumNum( str : String, n : int, k : int) : String
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (k < 1) then     break else skip ; 
     if (str->at(i+1) /= '9') then (     str := str.setAt(i+1, '9') ; 
     k := k - 1 ) else skip )  ;     i := i + 1 ) ; 
     return str );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := StringLib.newString("569431") ;
     var n : int ; n := str->size() ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println(findMaximumNum(str, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Div2B {
  private static int ceiling(int a,int b){
    return(a % b==0)?(a/b):(a/b)+1 ;
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=Integer.parseInt(scanner.nextLine());
    int n ;
    int ceil ;
    StringBuilder sb ;
    for(int i=0 ; i<t ; i++){
      n=Integer.parseInt(scanner.nextLine());
      ceil=ceiling(n,4);
      sb=new StringBuilder(n);
      for(int j=0 ; j<n-ceil ; j++){
        sb.append(9);
      }
      for(int j=0 ; j<ceil ; j++){
        sb.append(8);
      }
      System.out.println(sb.toString());
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Div2B {
  static   operation ceiling( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return if (a mod b = 0) then (a / b) else (a / b) + 1 endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := (scanner.nextLine())->toInteger() ;
    var n : int ;
    var ceil : int ;
    var sb : String ;
        var i : int ; i := 0 ; while i < t do ( (     n := (scanner.nextLine())->toInteger() ; 
     ceil := ceiling(n, 4) ; 
    sb := StringLib.newString(n) ; 
        var j : int ; j := 0 ; while j < n - ceil do ( (     sb := sb + StringLib.newString(9) )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < ceil do ( (     sb := sb + StringLib.newString(8) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    Map<String,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      String handle=in.next();
      int sum=0 ;
      int hack=(in.nextInt()*100)-(in.nextInt()*50);
      for(int j=0 ; j<5 ; j++){
        sum=sum+in.nextInt();
      }
      sum+=hack ;
      map.put(handle,sum);
    }
    String name="" ;
    int max=Collections.max(map.values());
    for(String h : map.keySet()){
      if(max==map.get(h)){
        name=h ;
      }
    }
    pw.println(name);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var handle : String ; handle := in.getCurrent() ;
     var sum : int ; sum := 0 ;
    var hack : int ; hack := (in.getCurrent()->toInteger() * 100) - (in.getCurrent()->toInteger() * 50) ;
        var j : int ; j := 0 ; while j < 5 do ( (     sum := sum + in.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    sum := sum+(hack) ; 
    map := map->union(Map{handle |-> sum}) ; 
 )  ;     i := i + 1 ) ; 
    var name : String ; name := "" ;
    var max : int ; max := .max(map->values()) ;
    for (h : map->keys()) do ( (     if (max = map->at(h)) then (     name := h ) else skip )  ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    Map<String,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      String handle=in.next();
      int sum=0 ;
      int hack=(in.nextInt()*100)-(in.nextInt()*50);
      for(int j=0 ; j<5 ; j++){
        sum=sum+in.nextInt();
      }
      sum+=hack ;
      map.put(handle,sum);
    }
    int max=Collections.max(map.values());
    List<String>keys=new ArrayList<>();
    for(Map.Entry<String,Integer>entry : map.entrySet()){
      if(entry.getValue()==max){
        keys.add(entry.getKey());
      }
    }
    pw.println(keys.get(0));
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var map : Map(String,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var handle : String ; handle := in.getCurrent() ;
     var sum : int ; sum := 0 ;
    var hack : int ; hack := (in.getCurrent()->toInteger() * 100) - (in.getCurrent()->toInteger() * 50) ;
        var j : int ; j := 0 ; while j < 5 do ( (     sum := sum + in.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    sum := sum+(hack) ; 
    map := map->union(Map{handle |-> sum}) ; 
 )  ;     i := i + 1 ) ; 
    var max : int ; max := .max(map->values()) ;
    var keys : Sequence(String) ; keys := Sequence{} ;
    for (entry : map->asSet()) do ( (     if (entry.getValue() = max) then (     keys := keys->including(entry.getKey()) ) else skip )  ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int sum=Integer.MIN_VALUE ;
    String[] name=new String[n];
    int suc,unsuc,a,b,c,d,e ;
    int t=0 ;
    for(int i=0 ; i<n ; i++){
      int total=0 ;
      name[i]=sc.next();
      suc=sc.nextInt();
      unsuc=sc.nextInt();
      a=sc.nextInt();
      b=sc.nextInt();
      c=sc.nextInt();
      d=sc.nextInt();
      e=sc.nextInt();
      total=100*suc-50*unsuc+a+b+c+d+e ;
      if(total>sum){
        sum=total ;
        t=i ;
      }
    }
    System.out.println(name[t]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var sum : int ; sum := -2147483648 ;
    var name : Sequence(String) ; name := Integer.subrange(1,n)->collect(null) ;
    var suc : int ;
    var unsuc : int ;
    var a : int ;
    var b : int ;
    var c : int ;
    var d : int ;
    var e : int ;
    var t : int ; t := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var total : int ; total := 0 ;
     name[i+1] := sc.getCurrent() ; 
    suc := sc.getCurrent()->toInteger() ; 
    unsuc := sc.getCurrent()->toInteger() ; 
    a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
    c := sc.getCurrent()->toInteger() ; 
    d := sc.getCurrent()->toInteger() ; 
    e := sc.getCurrent()->toInteger() ; 
    total := 100 * suc - 50 * unsuc + a + b + c + d + e ; 
    if (total > sum) then (     sum := total ; 
     t := i ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(name[t+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class codeforces {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String win="" ;
    int max=Integer.MIN_VALUE ;
    while(n-->0){
      String s=sc.next();
      int p=sc.nextInt();
      int m=sc.nextInt();
      int a=sc.nextInt();
      int b=sc.nextInt();
      int c=sc.nextInt();
      int d=sc.nextInt();
      int e=sc.nextInt();
      int x=p*100-m*50+a+b+c+d+e ;
      if(max<x){
        max=x ;
        win=s ;
      }
    }
    System.out.println(win);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var win : String ; win := "" ;
    var max : int ; max := -2147483648 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var s : String ; s := sc.getCurrent() ;
     var p : int ; p := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var d : int ; d := sc.getCurrent()->toInteger() ;
    var e : int ; e := sc.getCurrent()->toInteger() ;
    var x : int ; x := p * 100 - m * 50 + a + b + c + d + e ;
    if (max < x) then (     max := x ; 
     win := s ) else skip ; 
 ) ;  ) ;  
    OclFile["System.out"].println(win) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.Arrays ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader bi=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(bi.readLine());
    String ans="" ;
    int prev=-2501 ;
    while(n-->0){
      String s[];
      s=bi.readLine().split(" ");
      String handle=s[0];
      int plus=Integer.parseInt(s[1]),minus=Integer.parseInt(s[2]),a=Integer.parseInt(s[3]),b=Integer.parseInt(s[4]),c=Integer.parseInt(s[5]),d=Integer.parseInt(s[6]),e=Integer.parseInt(s[7]);
      int tot=0 ;
      tot=plus*100-minus*50+a+b+c+d+e ;
      if(tot>prev){
        prev=tot ;
        ans=handle ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bi : OclFile ; bi := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (bi.readLine())->toInteger() ;
    var ans : String ; ans := "" ;
    var prev : int ; prev := -2501 ;
        while (n > 0) do (        n := n - 1 ;     skip ; (     var s : Sequence(String) ;
     s := bi.readLine()->split(" ") ; 
    var handle : String ; handle := s[0+1] ;
    var plus : int ; plus := (s[1+1])->toInteger() ;
    var minus : int ; minus := (s[2+1])->toInteger() ;
    var a : int ; a := (s[3+1])->toInteger() ;
    var b : int ; b := (s[4+1])->toInteger() ;
    var c : int ; c := (s[5+1])->toInteger() ;
    var d : int ; d := (s[6+1])->toInteger() ;
    var e : int ; e := (s[7+1])->toInteger() ;
    var tot : int ; tot := 0 ;
    tot := plus * 100 - minus * 50 + a + b + c + d + e ; 
    if (tot > prev) then (     prev := tot ; 
     ans := handle ) else skip ; 
 ) ;  ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF884A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int t=scanner.nextInt();
    for(int i=0 ; i<n ; i++){
      int a=scanner.nextInt();
      t-=(86400-a);
      if(t<=0){
        System.out.println(i+1);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF884A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     t := t-((86400 - a)) ; 
     if (t <= 0) then (     OclFile["System.out"].println(i + 1) ; 
     return ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int temp=0 ;
    int sum=0 ;
    int arr[]=new int[100];
    int n=scanner.nextInt();
    int t=scanner.nextInt();
    for(int i=0 ; i<n ; i++){
      temp=scanner.nextInt();
      arr[i]=86400-temp ;
    }
    for(int i=0 ; i<n ; i++){
      sum+=arr[i];
      if(sum>=t){
        System.out.println(i+1);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var temp : int ; temp := 0 ;
    var sum : int ; sum := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,100)->collect(0) ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var t : int ; t := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     temp := scanner.getCurrent()->toInteger() ; 
     arr[i+1] := 86400 - temp )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(arr[i+1]) ; 
     if (sum >= t) then (     OclFile["System.out"].println(i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int temp=0 ;
    int sum=0 ;
    int arr[]=new int[100];
    int n=scanner.nextInt();
    int t=scanner.nextInt();
    for(int i=0 ; i<n ; i++){
      temp=scanner.nextInt();
      arr[i]=86400-temp ;
    }
    for(int i=0 ; i<n ; i++){
      sum+=arr[i];
      if(sum>=t){
        System.out.println(i+1);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var temp : int ; temp := 0 ;
    var sum : int ; sum := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,100)->collect(0) ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var t : int ; t := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     temp := scanner.getCurrent()->toInteger() ; 
     arr[i+1] := 86400 - temp )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(arr[i+1]) ; 
     if (sum >= t) then (     OclFile["System.out"].println(i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String[] line=sc.nextLine().split(" ");
    int buttonA=Integer.parseInt(line[0]);
    int buttonB=Integer.parseInt(line[1]);
    int ans=0 ;
    if(buttonA>buttonB){
      ans+=buttonA ;
      buttonA--;
    }
    else {
      ans+=buttonB ;
      buttonB--;
    }
    if(buttonA>buttonB){
      ans+=buttonA ;
    }
    else {
      ans+=buttonB ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : Sequence(String) ; line := sc.nextLine()->split(" ") ;
    var buttonA : int ; buttonA := (line[0+1])->toInteger() ;
    var buttonB : int ; buttonB := (line[1+1])->toInteger() ;
    var ans : int ; ans := 0 ;
    if (buttonA > buttonB) then (     ans := ans+(buttonA) ; 
     buttonA := buttonA - 1 ) else (     ans := ans+(buttonB) ; 
     buttonB := buttonB - 1 ) ;  
    if (buttonA > buttonB) then (     ans := ans+(buttonA) ) else (     ans := ans+(buttonB) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.System.*;
import static java.lang.Math.max ;
import static java.lang.Math.min ;
import static java.lang.Math.abs ;
public class pre1 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int n=obj.nextInt();
    char mat[][]=new char[n+1][n+1];
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=n ; j++)mat[i][j]=(i+j)% 2==0 ? 'W' : 'B' ;
    }
    for(int i=1 ; i<=n ; i++){
      for(int j=1 ; j<=n ; j++)out.print(mat[i][j]);
      out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre1 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var n : int ; n := obj.nextInt() ;
    var mat : Sequence(Sequence(String)) ; mat := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do (     mat[i+1][j+1] := if (i + j) mod 2 = 0 then 'W' else 'B' endif ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 1 ; while j <= n do (     out.print(mat[i+1][j+1]) ;  ;     j := j + 1 ) ; 
     out.println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int temp=0 ;
    int sum=0 ;
    int arr[]=new int[100];
    int n=scanner.nextInt();
    int t=scanner.nextInt();
    for(int i=0 ; i<n ; i++){
      temp=scanner.nextInt();
      arr[i]=86400-temp ;
    }
    for(int i=0 ; i<n ; i++){
      sum+=arr[i];
      if(sum>=t){
        System.out.println(i+1);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var temp : int ; temp := 0 ;
    var sum : int ; sum := 0 ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,100)->collect(0) ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    var t : int ; t := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     temp := scanner.getCurrent()->toInteger() ; 
     arr[i+1] := 86400 - temp )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(arr[i+1]) ; 
     if (sum >= t) then (     OclFile["System.out"].println(i + 1) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF884A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int t=scanner.nextInt();
    for(int i=0 ; i<n ; i++){
      int a=scanner.nextInt();
      t-=(86400-a);
      if(t<=0){
        System.out.println(i+1);
        return ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF884A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     t := t-((86400 - a)) ; 
     if (t <= 0) then (     OclFile["System.out"].println(i + 1) ; 
     return ) else skip )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int C_MAX=30 ;
  static int max_arr_len=10 ;
  static int dp[][]=new int[max_arr_len][C_MAX+1];
  static boolean v[][]=new boolean[max_arr_len][C_MAX+1];
  static int findMax(int i,int r,int w[],int n){
    if(r<0)return Integer.MIN_VALUE ;
    if(i==n)return 0 ;
    if(v[i][r])return dp[i][r];
    v[i][r]=true ;
    dp[i][r]=Math.max(w[i]+findMax(i+1,r-w[i],w,n),findMax(i+1,r,w,n));
    return dp[i][r];
  }
  static void preCompute(int w[],int n){
    for(int i=C_MAX ; i>=0 ; i--)findMax(0,i,w,n);
  }
  static int ansQuery(int w){
    return dp[0][w];
  }
  public static void main(String[] args){
    int w[]=new int[] {
      3,8,9 };
      int n=w.length ;
      preCompute(w,n);
      int queries[]=new int[] {
        11,10,4 };
        int q=queries.length ;
        for(int i=0 ; i<q ; i++)System.out.println(ansQuery(queries[i]));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute C_MAX : int := 30;
  static   attribute max_arr_len : int := 10;
  static   attribute dp : int := Integer.subrange(1,max_arr_len)->collect(Integer.subrange(1,C_MAX + 1)->collect(0));
  static   attribute v : boolean := Integer.subrange(1,max_arr_len)->collect(Integer.subrange(1,C_MAX + 1)->collect(false));
  static   operation findMax( i : int, r : int, w : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (r < 0) then     return -2147483648 else skip ; 
     if (i = n) then     return 0 else skip ; 
    if (v[i+1][r+1]) then     return dp[i+1][r+1] else skip ; 
    v[i+1][r+1] := true ; 
    dp[i+1][r+1] := Set{w[i+1] + findMax(i + 1, r - w[i+1], w, n), findMax(i + 1, r, w, n)}->max() ; 
    return dp[i+1][r+1] 
 );
  static   operation preCompute( w : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := C_MAX ; while i >= 0 do (     execute findMax(0, i, w, n) ;  ;     i := i - 1 ) );
  static   operation ansQuery( w : int) : int
  pre: true
  post: true
  activity: (     return dp[0+1][w+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var w : Sequence(int) ; w := Sequence{3,8,9} ;
     var n : int ; n := w->size() ;
    execute preCompute(w, n) ; 
    var queries : Sequence(int) ; queries := Sequence{11,10,4} ;
    var q : int ; q := queries->size() ;
        var i : int ; i := 0 ; while i < q do (     OclFile["System.out"].println(ansQuery(queries[i+1])) ;  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B807 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int P=in.nextInt();
    int X=in.nextInt();
    int Y=in.nextInt();
    int score=X ;
    while(score>=Y){
      score-=50 ;
    }
    score+=50 ;
    main : while(true){
      int i=(score/50)% 475 ;
      for(int j=0 ; j<25 ; j++){
        i=(i*96+42)% 475 ;
        if(26+i==P){
          break main ;
        }
      }
      score+=50 ;
    }
    int hacks=Math.max(0,(score-X+50)/100);
    System.out.println(hacks);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B807 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var P : int ; P := in.getCurrent()->toInteger() ;
    var X : int ; X := in.getCurrent()->toInteger() ;
    var Y : int ; Y := in.getCurrent()->toInteger() ;
    var score : int ; score := X ;
    while (score >= Y) do (     score := score-(50) ) ; 
    score := score+(50) ; 
    while (true) do (     var i : int ; i := (score / 50) mod 475 ;
         var j : int ; j := 0 ; while j < 25 do ( (     i := (i * 96 + 42) mod 475 ; 
     if (26 + i = P) then (     break ) else skip )  ;     j := j + 1 ) ; 
     score := score+(50) ) ; 
    var hacks : int ; hacks := Set{0, (score - X + 50) / 100}->max() ;
    OclFile["System.out"].println(hacks) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.File ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.math.BigInteger ;
import java.util.*;
import javafx.util.Pair ;
public class Main {
  public static void main(String args[]){
    FastScanner input=new FastScanner();
    int p=input.nextInt();
    int x=input.nextInt();
    int y=input.nextInt();
    for(int s=y ; s<=1000000 ; s++){
      if((s % 50)!=(x % 50)){
        continue ;
      }
      int i=(s/50)% 475 ;
      for(int j=0 ; j<25 ; j++){
        i=(i*96+42)% 475 ;
        if(i+26==p){
          System.out.println((Math.max(0,s-x)+50)/100);
          return ;
        }
      }
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var p : int ; p := input.nextInt() ;
    var x : int ; x := input.nextInt() ;
    var y : int ; y := input.nextInt() ;
        var s : int ; s := y ; while s <= 1000000 do ( (     if ((s mod 50) /= (x mod 50)) then (     continue ) else skip ; 
     var i : int ; i := (s / 50) mod 475 ;
         var j : int ; j := 0 ; while j < 25 do ( (     i := (i * 96 + 42) mod 475 ; 
     if (i + 26 = p) then (     OclFile["System.out"].println((Set{0, s - x}->max() + 50) / 100) ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     s := s + 1 ) ; 
 );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class TshirtHunt {
  public static boolean winTshirt(int s,int p){
    int a=(s/50)% 475 ;
    for(int i=0 ; i<25 ; i++){
      a=(a*96+42)% 475 ;
      if(p==26+a)return true ;
    }
    return false ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int p=Integer.parseInt(st.nextToken());
    int x=Integer.parseInt(st.nextToken());
    int y=Integer.parseInt(st.nextToken());
    for(int i=x ; i>=y ; i-=50){
      if(winTshirt(i,p)){
        System.out.println(0);
        return ;
      }
    }
    int counter=0 ;
    while(true){
      counter++;
      x+=100 ;
      if(x<y)continue ;
      if(winTshirt(x,p)){
        break ;
      }
      if(x-50>=y && winTshirt(x-50,p)){
        break ;
      }
    }
    System.out.println(counter);
  }
}
------------------------------------------------------------
OCL File:
---------
 class TshirtHunt {
  static   operation winTshirt( s : int, p : int) : boolean
  pre: true
  post: true
  activity: (     var a : int ; a := (s / 50) mod 475 ;
         var i : int ; i := 0 ; while i < 25 do ( (     a := (a * 96 + 42) mod 475 ; 
     if (p = 26 + a) then     return true else skip )  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var p : int ; p := (st.next())->toInteger() ;
    var x : int ; x := (st.next())->toInteger() ;
    var y : int ; y := (st.next())->toInteger() ;
        var i : int ; i := x ; while i >= y do ( (     if (winTshirt(i, p)) then (     OclFile["System.out"].println(0) ; 
     return ) else skip )  ;     i := i-(50) ) ; 
    var counter : int ; counter := 0 ;
    while (true) do (     counter := counter + 1 ; 
     x := x+(100) ; 
    if (x < y) then     continue else skip ; 
    if (winTshirt(x, p)) then (     break ) else skip ; 
    if (x - 50 >= y & winTshirt(x - 50, p)) then (     break ) else skip ; 
 ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class TShirtHunt {
  public boolean shirt(int s,int x){
    int i=(s/50)% 475 ;
    for(int j=0 ; j<25 ; j++){
      i=(i*96+42)% 475 ;
      if(26+i==x)return true ;
    }
    return false ;
  }
  public void solve(){
    FastScanner in=new FastScanner(System.in);
    int p=in.nextInt();
    int x=in.nextInt();
    int y=in.nextInt();
    for(int k=x ; k>=y ; k-=50){
      if(shirt(k,p)){
        System.out.println(0);
        return ;
      }
    }
    int w=x ;
    while(! shirt(w,p)){
      w+=50 ;
    }
    double ans=(double)(w-x+50)/100 ;
    if(ans<0){
      System.out.println(0);
    }
    else System.out.println((int)ans);
  }
  public static void main(String[] args){
    TShirtHunt t=new TShirtHunt();
    t.solve();
  }
  private class FastScanner {
    public BufferedReader r ;
    public StringTokenizer st=null ;
    public FastScanner(InputStream stream){
      r=new BufferedReader(new InputStreamReader(stream),32728);
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(r.readLine());
        }
        catch(IOException e){
          throw new RuntimeException();
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public Long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class TShirtHunt {
   operation shirt( s : int, x : int) : boolean
  pre: true
  post: true
  activity: (     var i : int ; i := (s / 50) mod 475 ;
         var j : int ; j := 0 ; while j < 25 do ( (     i := (i * 96 + 42) mod 475 ; 
     if (26 + i = x) then     return true else skip )  ;     j := j + 1 ) ; 
     return false );
   operation solve() : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var p : int ; p := in.nextInt() ;
    var x : int ; x := in.nextInt() ;
    var y : int ; y := in.nextInt() ;
        var k : int ; k := x ; while k >= y do ( (     if (shirt(k, p)) then (     OclFile["System.out"].println(0) ; 
     return ) else skip )  ;     k := k-(50) ) ; 
    var w : int ; w := x ;
    while (not(shirt(w, p))) do (     w := w+(50) ) ; 
    var ans : double ; ans := (w - x + 50)->oclAsType(double) / 100 ;
    if (ans < 0) then (     OclFile["System.out"].println(0) ) else     OclFile["System.out"].println(ans->oclAsType(int)) ; ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : TShirtHunt ; t := TShirtHunt.newTShirtHunt() ;
     t.solve() );
 class FastScanner {
   attribute r : OclFile;
   attribute st : OclIterator := null;
   static operation newFastScanner( stream : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32728) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(r.readLine()) )   catch (e : IOException) do (     error ProgramException() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class SignFliping {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      for(int i=0 ; i<n ; i++){
        int temp=sc.nextInt();
        if((i & 1)==0){
          System.out.print((temp<0 ? temp :-temp)+" ");
        }
        else System.out.print((temp>0 ? temp :-temp)+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SignFliping {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var temp : int ; temp := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseAnd(i,1)) = 0) then (     OclFile["System.out"].print((if temp < 0 then temp else -temp endif) + " ") ) else     OclFile["System.out"].print((if temp > 0 then temp else -temp endif) + " ") ; )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class SignFliping {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      for(int i=0 ; i<n ; i++){
        int temp=sc.nextInt();
        if((i & 1)==0){
          System.out.print((temp<0 ? temp :-temp)+" ");
        }
        else System.out.print((temp>0 ? temp :-temp)+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class SignFliping {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var temp : int ; temp := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseAnd(i,1)) = 0) then (     OclFile["System.out"].print((if temp < 0 then temp else -temp endif) + " ") ) else     OclFile["System.out"].print((if temp > 0 then temp else -temp endif) + " ") ; )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    ;
    int sum=0 ;
    for(int i=0 ; i<2 ; i++){
      if(a>=b){
        sum+=a ;
        a=a-1 ;
      }
      else {
        sum+=b ;
        b=b-1 ;
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := (sc.getCurrent())->toInteger() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 2 do ( (     if (a >= b) then (     sum := sum+(a) ; 
     a := a - 1 ) else (     sum := sum+(b) ; 
     b := b - 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import static java.lang.System.*;
import static java.lang.Math.*;
public class pre12 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int tc=obj.nextInt();
    while(tc--!=0){
      int n=obj.nextInt(),arr[]=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=abs(obj.nextInt());
      for(int i=0 ; i<n ; i++){
        if(i % 2==0)continue ;
        else arr[i]=arr[i]*-1 ;
      }
      for(int i=0 ; i<n ; i++)out.print(arr[i]+" ");
      out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre12 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var tc : int ; tc := obj.nextInt() ;
         while (tc /= 0) do (    skip ; (     var n : int ; n := obj.nextInt() ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     arr[i+1] := abs(obj.nextInt()) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then     continue else     arr[i+1] := arr[i+1] * -1 ; )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     out.print(arr[i+1] + " ") ;  ;     i := i + 1 ) ; 
    out.println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class pre5 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int n=obj.nextInt();
    char arr[][]=new char[n][n];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(j==0)arr[i][j]=(i % 2==0)? 'W' : 'B' ;
        else arr[i][j]=arr[i][j-1]=='W' ? 'B' : 'W' ;
      }
    }
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++)out.print(arr[i][j]);
      out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre5 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var n : int ; n := obj.nextInt() ;
    var arr : Sequence(Sequence(String)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (j = 0) then     arr[i+1][j+1] := if (i mod 2 = 0) then 'W' else 'B' endif ; else     arr[i+1][j+1] := if arr[i+1][j - 1+1] = 'W' then 'B' else 'W' endif ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do (     out.print(arr[i+1][j+1]) ;  ;     j := j + 1 ) ; 
     out.println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class CF {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int t=0 ; t<test ; t++){
      int n=in.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<a.length ; i++){
        a[i]=in.nextInt();
      }
      for(int i=0 ; i<a.length ; i++){
        if(i % 2==0){
          pw.print(Math.abs(a[i])+" ");
        }
        else {
          pw.print(-1*Math.abs(a[i])+" ");
        }
      }
      pw.println();
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 0 ; while t < test do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < a->size() do ( (     if (i mod 2 = 0) then (     skip ) else (     skip ) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Hamster939B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long humster=in.nextLong();
    long box=in.nextInt();
    long capacity=0,min=(long)1e18,index=0,ans=0 ;
    for(int i=0 ; i<box ; i++){
      capacity=in.nextLong();
      if(humster % capacity<min){
        min=(humster % capacity);
        index=i ;
        ans=humster/capacity ;
      }
    }
    System.out.println(index+1+" "+ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hamster939B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var humster : long ; humster := in.getCurrent()->toLong() ;
    var box : long ; box := in.getCurrent()->toInteger() ;
    var capacity : long ; capacity := 0 ;
    var min : long ; min := 1e18->oclAsType(long) ;
    var index : long ; index := 0 ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < box do ( (     capacity := in.getCurrent()->toLong() ; 
     if (humster mod capacity < min) then (     min := (humster mod capacity) ; 
     index := i ; 
     ans := humster / capacity ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(index + 1 + " " + ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class farm {
  public static void main(String[] args){
    long k ;
    int n ;
    Scanner sc=new Scanner(System.in);
    k=sc.nextLong();
    n=sc.nextInt();
    long[] a=new long[n];
    int j=1,i ;
    for(i=0 ; i<n ; i++)a[i]=sc.nextLong();
    long min=k,q=0 ;
    for(i=0 ; i<n ; i++){
      if(k % a[i]<min){
        min=k % a[i];
        q=k/a[i];
        j=i+1 ;
      }
    }
    System.out.println(j+" "+q);
  }
}
------------------------------------------------------------
OCL File:
---------
 class farm {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : long ;
     var n : int ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    k := sc.getCurrent()->toLong() ; 
    n := sc.getCurrent()->toInteger() ; 
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var j : int ; j := 1 ;
    var i : int ;
        i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var min : long ; min := k ;
    var q : long ; q := 0 ;
        i := 0 ; while i < n do ( (     if (k mod a[i+1] < min) then (     min := k mod a[i+1] ; 
     q := k / a[i+1] ; 
     j := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(j + " " + q) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class Ideone {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner in=new Scanner(System.in);
    long n ;
    int m ;
    n=in.nextLong();
    m=in.nextInt();
    long a[]=new long[m];
    for(int i=0 ; i<m ; i++)a[i]=in.nextLong();
    long min=n % a[0];
    int pos=0 ;
    for(int i=1 ; i<m ; i++){
      if((n % a[i])<min){
        min=n % a[i];
        pos=i ;
      }
    }
    System.out.print((pos+1)+" "+(n/a[pos]));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ideone {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ;
    var m : int ;
    n := in.getCurrent()->toLong() ; 
    m := in.getCurrent()->toInteger() ; 
    var a : Sequence(long) ; a := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do (     a[i+1] := in.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    var min : long ; min := n mod a[0+1] ;
    var pos : int ; pos := 0 ;
        var i : int ; i := 1 ; while i < m do ( (     if ((n mod a[i+1]) < min) then (     min := n mod a[i+1] ; 
     pos := i ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print((pos + 1) + " " + (n / a[pos+1])) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long n=scanner.nextLong();
    long k=scanner.nextLong();
    ArrayList<Long>boxes=new ArrayList<>();
    while(k>0){
      boxes.add(scanner.nextLong());
      k--;
    }
    long currentHighest=0 ;
    long currentNumber=1 ;
    long numberOfBoxes=0 ;
    for(int i=0 ; i<boxes.size(); i++){
      long tmp=boxes.get(i);
      long g=n/tmp ;
      long t=g*tmp ;
      if(t>currentHighest){
        currentHighest=t ;
        currentNumber=i+1 ;
        numberOfBoxes=g ;
      }
    }
    System.out.println(currentNumber+" "+numberOfBoxes);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := scanner.getCurrent()->toLong() ;
    var k : long ; k := scanner.getCurrent()->toLong() ;
    var boxes : Sequence(long) ; boxes := Sequence{} ;
    while (k > 0) do (     boxes := boxes->including(scanner.getCurrent()->toLong()) ; 
     k := k - 1 ) ; 
    var currentHighest : long ; currentHighest := 0 ;
    var currentNumber : long ; currentNumber := 1 ;
    var numberOfBoxes : long ; numberOfBoxes := 0 ;
        var i : int ; i := 0 ; while i < boxes->size() do ( (     var tmp : long ; tmp := boxes->at(i+1) ;
     var g : long ; g := n / tmp ;
     var t : long ; t := g * tmp ;
     if (t > currentHighest) then (     currentHighest := t ; 
     currentNumber := i + 1 ; 
     numberOfBoxes := g ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(currentNumber + " " + numberOfBoxes) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class RotateArray {
  void leftRotate(int arr[],int d,int n){
    d=d % n ;
    int i,j,k,temp ;
    int g_c_d=gcd(d,n);
    for(i=0 ; i<g_c_d ; i++){
      temp=arr[i];
      j=i ;
      while(true){
        k=j+d ;
        if(k>=n)k=k-n ;
        if(k==i)break ;
        arr[j]=arr[k];
        j=k ;
      }
      arr[j]=temp ;
    }
  }
  void printArray(int arr[],int size){
    int i ;
    for(i=0 ; i<size ; i++)System.out.print(arr[i]+" ");
  }
  int gcd(int a,int b){
    if(b==0)return a ;
    else return gcd(b,a % b);
  }
  public static void main(String[] args){
    RotateArray rotate=new RotateArray();
    int arr[]={
      1,2,3,4,5,6,7 };
      rotate.leftRotate(arr,2,7);
      rotate.printArray(arr,7);
    }
  }

------------------------------------------------------------
OCL File:
---------
class RotateArray {
   operation leftRotate( arr : Sequence(int), d : int, n : int) : void
  pre: true
  post: true
  activity: (     d := d mod n ; 
     var i : int ;
    var j : int ;
    var k : int ;
    var temp : int ;
     var g_c_d : int ; g_c_d := gcd(d, n) ;
         i := 0 ; while i < g_c_d do ( (     temp := arr[i+1] ; 
     j := i ; 
     while (true) do (     k := j + d ; 
     if (k >= n) then     k := k - n ; else skip ; 
    if (k = i) then     break else skip ; 
    arr[j+1] := arr[k+1] ; 
    j := k ; 
 ) ; 
     arr[j+1] := temp )  ;     i := i + 1 ) );
   operation printArray( arr : Sequence(int), size : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
         i := 0 ; while i < size do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else     return gcd(b, a mod b) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var rotate : RotateArray ; rotate := RotateArray.newRotateArray() ;
     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6,7} ;
     rotate.leftRotate(arr, 2, 7) ; 
     rotate.printArray(arr, 7) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      sum+=arr[i];
    }
    Arrays.sort(arr);
    if(arr.length==1){
      System.out.println(sum);
      System.exit(0);
    }
    int f=0 ;
    int sum2=sum ;
    for(int i=0 ; i<n ; i++){
      for(int j=2 ; j<=arr[i]; j++){
        if(arr[i] % j==0){
          int temp=arr[i]/j ;
          int dec=arr[i]-temp ;
          int inc=0 ;
          if(i==0)inc=arr[i+1]*(j-1);
          else inc=arr[0]*(j-1);
          if(dec>inc){
            int aa=sum2+(inc-dec);
            if(aa<sum)sum=aa ;
          }
        }
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    if (arr->size() = 1) then (     OclFile["System.out"].println(sum) ; 
 OclProcess.exit(0) ) else skip ; 
    var f : int ; f := 0 ;
    var sum2 : int ; sum2 := sum ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 2 ; while j <= arr[i+1] do ( (     if (arr[i+1] mod j = 0) then (     var temp : int ; temp := arr[i+1] / j ;
     var dec : int ; dec := arr[i+1] - temp ;
    var inc : int ; inc := 0 ;
    if (i = 0) then     inc := arr[i + 1+1] * (j - 1) else     inc := arr[0+1] * (j - 1) ; ;  
    if (dec > inc) then (     var aa : int ; aa := sum2 + (inc - dec) ;
     if (aa < sum) then     sum := aa ; else skip ) else skip ; 
 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import java.io.*;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.HashMap ;
import java.util.InputMismatchException ;
import java.util.List ;
import java.util.Map ;
import java.util.Scanner ;
public class Exercise {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Integer>array=new ArrayList<>();
    int mn=(int)1e9 ;
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      int nmb=sc.nextInt();
      array.add(nmb);
      mn=min(mn,nmb);
      sum+=nmb ;
    }
    int res=sum ;
    for(int i=0 ; i<n ; i++){
      for(int b=1 ; b<=array.get(i); b++){
        if(array.get(i)% b!=0)continue ;
        int cur=sum-mn-array.get(i);
        cur+=mn*b+array.get(i)/b ;
        res=min(cur,res);
      }
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Exercise {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Sequence{} ;
    var mn : int ; mn := 1e9->oclAsType(int) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var nmb : int ; nmb := sc.getCurrent()->toInteger() ;
     array := array->including(nmb) ; 
     mn := Set{mn, nmb}->min() ; 
     sum := sum+(nmb) )  ;     i := i + 1 ) ; 
    var res : int ; res := sum ;
        var i : int ; i := 0 ; while i < n do ( (         var b : int ; b := 1 ; while b <= array->at(i+1) do ( (     if (array->at(i+1) mod b /= 0) then     continue else skip ; 
     var cur : int ; cur := sum - mn - array->at(i+1) ;
     cur := cur+(mn * b + array->at(i+1) / b) ; 
     res := Set{cur, res}->min() )  ;     b := b + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int __gcd(int a,int b){
    if(a==0 || b==0)return 0 ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static int NumberOfSquares(int x,int y){
    int s=__gcd(x,y);
    int ans=(x*y)/(s*s);
    return ans ;
  }
  public static void main(String[] args){
    int m=385,n=60 ;
    System.out.println(NumberOfSquares(m,n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0 or b = 0) then     return 0 else skip ; 
     if (a = b) then     return a else skip ; 
     if (a > b) then     return __gcd(a - b, b) else skip ; 
     return __gcd(a, b - a) );
  static   operation NumberOfSquares( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var s : int ; s := __gcd(x, y) ;
     var ans : int ; ans := (x * y) / (s * s) ;
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 385 ;
    var n : int ; n := 60 ;
     OclFile["System.out"].println(NumberOfSquares(m, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minimizeDiff(int[] arr,int n,int k){
    int max=Arrays.stream(arr).max().getAsInt();
    int min=Arrays.stream(arr).min().getAsInt();
    if((max-min)<=k){
      return(max-min);
    }
    int avg=(max+min)/2 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]>avg){
        arr[i]-=k ;
      }
      else {
        arr[i]+=k ;
      }
    }
    max=Arrays.stream(arr).max().getAsInt();
    min=Arrays.stream(arr).min().getAsInt();
    return(max-min);
  }
  public static void main(String[] args){
    int arr[]={
      3,16,12,9,20 };
      int n=5 ;
      int k=3 ;
      System.out.println("Max height difference="+minimizeDiff(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimizeDiff( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var max : int ; max := stream(arr).max().getAsInt() ;
     var min : int ; min := stream(arr).min().getAsInt() ;
    if ((max - min) <= k) then (     return (max - min) ) else skip ; 
    var avg : int ; avg := (max + min) / 2 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] > avg) then (     arr[i+1] := arr[i+1]-(k) ) else (     arr[i+1] := arr[i+1]+(k) ) )  ;     i := i + 1 ) ; 
    max := stream(arr).max().getAsInt() ; 
    min := stream(arr).min().getAsInt() ; 
    return (max - min) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,16,12,9,20} ;
     var n : int ; n := 5 ;
     var k : int ; k := 3 ;
     OclFile["System.out"].println("Max height difference=" + minimizeDiff(arr, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class submitfinal {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    if(n==1)System.out.println("2");
    else {
      long count=0 ;
      long h=(long)Math.sqrt(n);
      if(n %(h)==0)System.out.println((n-(h*h))/h+2*h);
      else System.out.println((n-(h*h))/h+1+2*h);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class submitfinal {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
     if (n = 1) then     OclFile["System.out"].println("2") ; else (     var count : long ; count := 0 ;
     var h : long ; h := (n)->sqrt()->oclAsType(long) ;
     if (n mod (h) = 0) then     OclFile["System.out"].println((n - (h * h)) / h + 2 * h) ; else     OclFile["System.out"].println((n - (h * h)) / h + 1 + 2 * h) ; ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[] X=new long[N+1];
    long[] xx=new long[N+1];
    for(int i=1 ; i<=N ; i++){
      X[i]=sc.nextLong();
      xx[i]=X[i];
    }
    Arrays.sort(xx);
    long med1=xx[N/2];
    long med2=xx[N/2+1];
    for(int i=1 ; i<=N ; i++){
      if(X[i]<=med1){
        System.out.println(med2);
      }
      else {
        System.out.println(med1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var X : Sequence(long) ; X := Integer.subrange(1,N + 1)->collect(0) ;
    var xx : Sequence(long) ; xx := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do ( (     X[i+1] := sc.getCurrent()->toLong() ; 
     xx[i+1] := X[i+1] )  ;     i := i + 1 ) ; 
    xx := xx->sort() ; 
    var med1 : long ; med1 := xx[N / 2+1] ;
    var med2 : long ; med2 := xx[N / 2 + 1+1] ;
        var i : int ; i := 1 ; while i <= N do ( (     if (X[i+1] <= med1) then (     OclFile["System.out"].println(med2) ) else (     OclFile["System.out"].println(med1) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[] X=new long[N+10];
    long[] copy=new long[N+10];
    for(int i=1 ; i<=N ; i++){
      X[i]=sc.nextLong();
      copy[i]=X[i];
    }
    quickSort(X,1,N);
    long C1=X[N/2];
    long C2=X[N/2+1];
    for(int i=1 ; i<=N ; i++){
      if(copy[i]<=C1){
        System.out.println(C2);
      }
      else if(copy[i]>=C2){
        System.out.println(C1);
      }
    }
    sc.close();
  }
  public static void quickSort(long[] array,int left,int right){
    int curleft=left ;
    int curright=right ;
    long pivot=array[(curleft+curright)/2];
    do {
      while(array[curleft]<pivot){
        curleft++;
      }
      while(array[curright]>pivot){
        curright--;
      }
      if(curleft<=curright){
        swap(array,curleft++,curright--);
      }
    }
    while(curleft<=curright);
    if(left<curright){
      quickSort(array,left,curright);
    }
    if(curleft<right){
      quickSort(array,curleft,right);
    }
  }
  private static void swap(long[] array,int idx1,int idx2){
    long tmp=array[idx1];
    array[idx1]=array[idx2];
    array[idx2]=tmp ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var X : Sequence(long) ; X := Integer.subrange(1,N + 10)->collect(0) ;
    var copy : Sequence(long) ; copy := Integer.subrange(1,N + 10)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do ( (     X[i+1] := sc.getCurrent()->toLong() ; 
     copy[i+1] := X[i+1] )  ;     i := i + 1 ) ; 
    execute quickSort(X, 1, N) ; 
    var C1 : long ; C1 := X[N / 2+1] ;
    var C2 : long ; C2 := X[N / 2 + 1+1] ;
        var i : int ; i := 1 ; while i <= N do ( (     if (copy[i+1] <= C1) then (     OclFile["System.out"].println(C2) ) else     if (copy[i+1] >= C2) then (     OclFile["System.out"].println(C1) ) else skip ; )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation quickSort( array : Sequence(long), left : int, right : int) : void
  pre: true
  post: true
  activity: (     var curleft : int ; curleft := left ;
     var curright : int ; curright := right ;
    var pivot : long ; pivot := array[(curleft + curright) / 2+1] ;
  while true do ((     while (array[curleft+1] < pivot) do (     curleft := curleft + 1 ) ; 
     while (array[curright+1] > pivot) do (     curright := curright - 1 ) ; 
     if (curleft <= curright) then (     execute swap(array, curleft, curright) ) else skip ) ;
    if (curleft <= curright) then skip else break) ; 
    if (left < curright) then (     execute quickSort(array, left, curright) ) else skip ; 
    if (curleft < right) then (     execute quickSort(array, curleft, right) ) else skip ; 
 );
  static   operation swap( array : Sequence(long), idx1 : int, idx2 : int) : void
  pre: true
  post: true
  activity: (     var tmp : long ; tmp := array[idx1+1] ;
     array[idx1+1] := array[idx2+1] ; 
     array[idx2+1] := tmp );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.PriorityQueue ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    int[] input=new int[n];
    String[] tmpArray=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      input[i]=Integer.parseInt(tmpArray[i]);
    }
    int[] inputClone=Arrays.copyOf(input,n);
    Arrays.sort(inputClone);
    int med=n/2 ;
    for(int i=0 ; i<n ; i++){
      if(input[i]<inputClone[med]){
        System.out.println(inputClone[med]);
      }
      else {
        System.out.println(inputClone[med-1]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var input : Sequence(int) ; input := Integer.subrange(1,n)->collect(0) ;
    var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < n do ( (     input[i+1] := (tmpArray[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var inputClone : Sequence(int) ; inputClone := input.subrange(1,n) ;
    inputClone := inputClone->sort() ; 
    var med : int ; med := n / 2 ;
        var i : int ; i := 0 ; while i < n do ( (     if (input[i+1] < inputClone[med+1]) then (     OclFile["System.out"].println(inputClone[med+1]) ) else (     OclFile["System.out"].println(inputClone[med - 1+1]) ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Comparator ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    List<Integer>ai=new ArrayList<>();
    for(int i=0 ; i<N ; i++){
      ai.add(sc.nextInt());
    }
    List<Integer>sorted=new ArrayList<>(ai);
    sorted.sort(Comparator.naturalOrder());
    int medLow=sorted.get(N/2-1);
    int medHigh=sorted.get(N/2);
    for(int a : ai){
      System.out.println((a<=medLow)? medHigh : medLow);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var ai : Sequence(int) ; ai := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     ai := ai->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var sorted : Sequence(int) ; sorted := Sequence{}->union(ai) ;
    sorted := sorted.sort(Comparator.naturalOrder()) ; 
    var medLow : int ; medLow := sorted->at(N / 2 - 1+1) ;
    var medHigh : int ; medHigh := sorted->at(N / 2+1) ;
    for (a : ai) do ( (     OclFile["System.out"].println(if (a <= medLow) then medHigh else medLow endif) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class GfG {
  public static void printSmall(int arr[],int n,int k){
    for(int i=k ; i<n ; ++i){
      int max_var=arr[k-1];
      int pos=k-1 ;
      for(int j=k-2 ; j>=0 ; j--){
        if(arr[j]>max_var){
          max_var=arr[j];
          pos=j ;
        }
      }
      if(max_var>arr[i]){
        int j=pos ;
        while(j<k-1){
          arr[j]=arr[j+1];
          j++;
        }
        arr[k-1]=arr[i];
      }
    }
    for(int i=0 ; i<k ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String argc[]){
    int[] arr={
      1,5,8,9,6,7,3,4,2,0 };
      int n=10 ;
      int k=5 ;
      printSmall(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation printSmall( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := k ; while i < n do ( (     var max_var : int ; max_var := arr[k - 1+1] ;
     var pos : int ; pos := k - 1 ;
         var j : int ; j := k - 2 ; while j >= 0 do ( (     if (arr[j+1] > max_var) then (     max_var := arr[j+1] ; 
     pos := j ) else skip )  ;     j := j - 1 ) ; 
     if (max_var > arr[i+1]) then (     var j : int ; j := pos ;
     while (j < k - 1) do (     arr[j+1] := arr[j + 1+1] ; 
     j := j + 1 ) ; 
     arr[k - 1+1] := arr[i+1] ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < k do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( argc : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,8,9,6,7,3,4,2,0} ;
     var n : int ; n := 10 ;
     var k : int ; k := 5 ;
     execute printSmall(arr, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  int INF=1<<28 ;
  double EPS=1e-10 ;
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    String a=sc.next();
    int ans=0 ;
    for(int i=0 ; i<a.length(); i++){
      String head=a.substring(0,i);
      String tail=a.substring(i,a.length());
      int h,t ;
      if(head.equals("")){
        h=0 ;
      }
      else if(head.equals("-")){
        continue ;
      }
      else {
        h=Integer.parseInt(head);
      }
      if(tail.equals("")){
        t=0 ;
      }
      else if(tail.charAt(0)=='0'){
        continue ;
      }
      else {
        t=Integer.parseInt(tail);
      }
      if(t<0){
        continue ;
      }
      if(h>t)continue ;
      if((h+t)% 2!=0){
        continue ;
      }
      if((t-h)% 2!=0){
        continue ;
      }
      ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var a : String ; a := sc.getCurrent() ;
     var ans : int ; ans := 0 ;
         var i : int ; i := 0 ; while i < a->size() do ( (     var head : String ; head := a.subrange(0+1,i) ;
     var tail : String ; tail := a.subrange(i+1,a->size()) ;
    var h : int ;
    var t : int ;
    if (head = "") then (     h := 0 ) else     if (head = "-") then (     continue ) else (     h := (head)->toInteger() ) ;  ;  
    if (tail = "") then (     t := 0 ) else     if (tail->at(0+1) = '0') then (     continue ) else (     t := (tail)->toInteger() ) ;  ;  
    if (t < 0) then (     continue ) else skip ; 
    if (h > t) then     continue else skip ; 
    if ((h + t) mod 2 /= 0) then (     continue ) else skip ; 
    if (((t)->char2byte() - (h)->char2byte()) mod 2 /= 0) then (     continue ) else skip ; 
    ans := ans + 1 ; 
 )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    sc.nextLine();
    while(n-->0){
      String st=sc.nextLine();
      Fun(st);
    }
  }
  static void Fun(String st){
    char s=st.charAt(0);
    int id=0 ;
    String res=new String();
    for(int i=1 ; i<st.length(); i++){
      if(st.charAt(i)<=s){
        s=st.charAt(i);
        id=i ;
      }
    }
    for(int i=0 ; i<st.length(); i++){
      if(id==i)continue ;
      res+=st.charAt(i);
    }
    System.out.println(s+" "+res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     skip ; 
         while (n > 0) do (        n := n - 1 ;     skip ; (     var st : String ; st := sc.nextLine() ;
     execute Fun(st) ) ;  ) );
  static   operation Fun( st : String) : void
  pre: true
  post: true
  activity: (     var s : String ; s := st->at(0+1) ;
     var id : int ; id := 0 ;
    var res : String ; res := StringLib.newString() ;
        var i : int ; i := 1 ; while i < st->size() do ( (     if (st->at(i+1) <= s) then (     s := st->at(i+1) ; 
     id := i ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < st->size() do ( (     if (id = i) then     continue else skip ; 
     res := res+(st->at(i+1)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s + " " + res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line="" ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int i=Integer.parseInt(line);
      int count=0 ;
      if(i % 2==0){
        count++;
      }
      for(int j=1 ; j<line.length(); j++){
        if(line.charAt(j)!='0'){
          int l=Integer.parseInt(line.substring(0,j));
          int r=Integer.parseInt(line.substring(j));
          if(l<=r &&(r-l)% 2==0){
            count++;
          }
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := "" ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var i : int ; i := (line)->toInteger() ;
     var count : int ; count := 0 ;
    if (i mod 2 = 0) then (     count := count + 1 ) else skip ; 
        var j : int ; j := 1 ; while j < line->size() do ( (     if (line->at(j+1) /= '0') then (     var l : int ; l := (line.subrange(0+1,j))->toInteger() ;
     var r : int ; r := (line.subrange(j+1,j))->toInteger() ;
     if (l <= r & (r - l) mod 2 = 0) then (     count := count + 1 ) else skip ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static boolean is_leading_zero(String str){
    if(str.length()==0){
      return false ;
    }
    else {
      return str.charAt(0)=='0' ;
    }
  }
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    final int a=sc.nextInt();
    String input=Integer.toString(a);
    int count=0 ;
    for(int pos=0 ; pos<=input.length(); pos++){
      String fst=input.substring(0,pos);
      String snd=input.substring(pos);
      if(is_leading_zero(fst)|| is_leading_zero(snd)){
        continue ;
      }
      if(fst.equals("")){
        fst="0" ;
      }
      if(snd.equals("")){
        snd="0" ;
      }
      final int sub=Integer.parseInt(fst);
      final int add=Integer.parseInt(snd);
      if((add+sub)% 2!=0){
        continue ;
      }
      final int x=(add+sub)/2 ;
      final int y=add-x ;
      if(x<0 || y<0){
        continue ;
      }
      count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation is_leading_zero( str : String) : boolean
  pre: true
  post: true
  activity: (     if (str->size() = 0) then (     return false ) else (     return str->at(0+1) = '0' ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var input : String ; input := ((a) + "") ;
    var count : int ; count := 0 ;
        var pos : int ; pos := 0 ; while pos <= input->size() do ( (     var fst : String ; fst := input.subrange(0+1,pos) ;
     var snd : String ; snd := input.subrange(pos+1,pos) ;
    if (is_leading_zero(fst) or is_leading_zero(snd)) then (     continue ) else skip ; 
    if (fst = "") then (     fst := "0" ) else skip ; 
    if (snd = "") then (     snd := "0" ) else skip ; 
    var sub : int ; sub := (fst)->toInteger() ;
    var add : int ; add := (snd)->toInteger() ;
    if ((add + sub) mod 2 /= 0) then (     continue ) else skip ; 
    var x : int ; x := (add + sub) / 2 ;
    var y : int ; y := add - x ;
    if (x < 0 or y < 0) then (     continue ) else skip ; 
    count := count + 1 ; 
 )  ;     pos := pos + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int a,al,ar,i,x,y,count=0 ;
    char[] c ;
    String s ;
    s=sc.next();
    c=new char[s.length()+1];
    c[0]='0' ;
    for(i=0 ; i<s.length(); i++)c[i+1]=s.charAt(i);
    for(i=0 ; i<s.length(); i++){
      if(c[i+1]!='0'){
        al=readint(c,0,i+1);
        ar=readint(c,i+1,s.length()+1);
        x=al+ar ;
        y=ar-al ;
        if(x % 2==0 && y % 2==0 && y>=0)count++;
      }
    }
    out.println(count);
    sc.close();
  }
  private static int readint(char[] ch,int l,int r){
    int i,d,res,s ;
    d=1 ;
    res=0 ;
    s=1 ;
    if(ch[l]=='-'){
      s=-1 ;
      l++;
    }
    for(i=r-1 ; i>=l ; i--){
      res+=d*(int)(ch[i]-'0');
      d*=10 ;
    }
    return res*s ;
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var a : int ;
    var al : int ;
    var ar : int ;
    var i : int ;
    var x : int ;
    var y : int ;
    var count : int ; count := 0 ;
    var c : Sequence(String) ;
    var s : String ;
    s := sc.next() ; 
    c := Integer.subrange(1,s->size() + 1)->collect(0) ; 
    c[0+1] := '0' ; 
        i := 0 ; while i < s->size() do (     c[i + 1+1] := s->at(i+1) ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < s->size() do ( (     if (c[i + 1+1] /= '0') then (     al := readint(c, 0, i + 1) ; 
     ar := readint(c, i + 1, s->size() + 1) ; 
    x := al + ar ; 
    y := ar - al ; 
    if (x mod 2 = 0 & y mod 2 = 0 & y >= 0) then     count := count + 1 ; else skip ; 
 ) else skip )  ;     i := i + 1 ) ; 
    out.println(count) ; 
    sc.close() ; 
 );
  static   operation readint( ch : Sequence(String), l : int, r : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var d : int ;
    var res : int ;
    var s : int ;
     d := 1 ; 
    res := 0 ; 
    s := 1 ; 
    if (ch[l+1] = '-') then (     s := -1 ; 
     l := l + 1 ) else skip ; 
        i := r - 1 ; while i >= l do ( (     res := res+(d * (ch[i+1] - ('0')->char2byte())->oclAsType(int)) ; 
     d := d*(10) )  ;     i := i - 1 ) ; 
    return res * s 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long n=in.nextLong();
    pw.println((int)Math.ceil(Math.sqrt(n)*2));
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := in.getCurrent()->toLong() ;
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class Main {
  Scanner sc=new Scanner(System.in);
  String s ;
  void run(){
    s=sc.nextLine();
    solve();
  }
  void solve(){
    HashSet<Long>set=new HashSet<Long>();
    for(int i=0 ; i<s.length(); i++){
      int sub=i==0 ? 0 : Integer.parseInt(s.substring(0,i));
      int add=Integer.parseInt(s.substring(i,s.length()));
      int a=(sub+add)/2,b=(-sub+add)/2 ;
      if(a>=0 && b>=0 && Integer.parseInt((a-b)+""+(a+b))==Integer.parseInt(s)){
        set.add(a*(1L<<64)+b);
      }
    }
    println(set.size()+"");
  }
  void println(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute s : String;
   operation run() : void
  pre: true
  post: true
  activity: (     s := sc.nextLine() ; 
     execute solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var set : Set(long) ; set := Set{} ;
         var i : int ; i := 0 ; while i < s->size() do ( (     var sub : int ; sub := if i = 0 then 0 else (s.subrange(0+1,i))->toInteger() endif ;
     var add : int ; add := (s.subrange(i+1,s->size()))->toInteger() ;
     var a : int ; a := (sub + add) / 2 ;
    var b : int ; b := (-sub + add) / 2 ;
     if (a >= 0 & b >= 0 & ((a - b) + "" + (a + b))->toInteger() = (s)->toInteger()) then (     set := set->including(a * ((1L*(2->pow(64)))->oclAsType(long)) + b) ) else skip )  ;     i := i + 1 ) ; 
     execute println(set->size() + "") );
   operation println( s : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(s) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class z {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    int max=0,newMax=0 ;
    for(int i=0 ; i<n ; i++){
      newMax=before(a,i)+after(a,i)+1 ;
      if(max<newMax)max=newMax ;
    }
    System.out.println(max);
  }
  public static int before(int[] array,int index){
    if(index==0)return 0 ;
    if(array[index-1]<=array[index])return 1+before(array,index-1);
    return 0 ;
  }
  public static int after(int[] array,int index){
    if(index+1==array.length)return 0 ;
    if(array[index]>=array[index+1])return 1+after(array,index+1);
    return 0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class z {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var max : int ; max := 0 ;
    var newMax : int ; newMax := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     newMax := before(a, i) + after(a, i) + 1 ; 
     if (max < newMax) then     max := newMax ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
  static   operation before( array : Sequence(int), index : int) : int
  pre: true
  post: true
  activity: (     if (index = 0) then     return 0 else skip ; 
     if (array[index - 1+1] <= array[index+1]) then     return 1 + before(array, index - 1) else skip ; 
     return 0 );
  static   operation after( array : Sequence(int), index : int) : int
  pre: true
  post: true
  activity: (     if (index + 1 = array->size()) then     return 0 else skip ; 
     if (array[index+1] >= array[index + 1+1]) then     return 1 + after(array, index + 1) else skip ; 
     return 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class codeforces {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=s.nextInt();
    }
    int max=Integer.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      int temp=1 ;
      for(int j=i-1 ; j>-1 ; j--){
        if(arr[j]<=arr[j+1]){
          temp++;
        }
        else {
          break ;
        }
      }
      for(int j=i+1 ; j<n ; j++){
        if(arr[j]<=arr[j-1]){
          temp++;
        }
        else {
          break ;
        }
      }
      if(max<temp){
        max=temp ;
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
        var i : int ; i := 0 ; while i < n do ( (     var temp : int ; temp := 1 ;
         var j : int ; j := i - 1 ; while j > -1 do ( (     if (arr[j+1] <= arr[j + 1+1]) then (     temp := temp + 1 ) else (     break ) )  ;     j := j - 1 ) ; 
         var j : int ; j := i + 1 ; while j < n do ( (     if (arr[j+1] <= arr[j - 1+1]) then (     temp := temp + 1 ) else (     break ) )  ;     j := j + 1 ) ; 
     if (max < temp) then (     max := temp ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PetyaAndCountryside {
  public static int getMaximal(int n,int[] a){
    int maximum=0 ;
    int current=0 ;
    for(int i=0 ; i<n ; i++){
      int l=i-1 ;
      int r=i+1 ;
      while(l>=0 && a[l]<=a[l+1]){
        l--;
      }
      l++;
      while(r<=a.length-1 && a[r]<=a[r-1]){
        r++;
      }
      r--;
      current=r-l+1 ;
      maximum=Math.max(maximum,current);
    }
    return maximum ;
  }
  public static void main(String[] args){
    Scanner obj=new Scanner(System.in);
    int n=obj.nextInt();
    int[] a=new int[n];
    for(int j=0 ; j<n ; j++){
      a[j]=obj.nextInt();
    }
    System.out.println(getMaximal(n,a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class PetyaAndCountryside {
  static   operation getMaximal( n : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var maximum : int ; maximum := 0 ;
     var current : int ; current := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     var l : int ; l := i - 1 ;
     var r : int ; r := i + 1 ;
    while (l >= 0 & a[l+1] <= a[l + 1+1]) do (     l := l - 1 ) ; 
    l := l + 1 ; 
    while (r <= a->size() - 1 & a[r+1] <= a[r - 1+1]) do (     r := r + 1 ) ; 
    r := r - 1 ; 
    current := r - l + 1 ; 
    maximum := Set{maximum, current}->max() ; 
 )  ;     i := i + 1 ) ; 
     return maximum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : OclFile ; obj := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := obj.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var j : int ; j := 0 ; while j < n do ( (     a[j+1] := obj.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(getMaximal(n, a)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int K=sc.nextInt();
    long mod=1_000_000_007L ;
    long ans=0L ;
    for(int i=0 ; i<M ; i++){
      ans+=(N*i % mod*(M-i)% mod*N % mod)% mod ;
      ans=ans % mod ;
    }
    for(int i=0 ; i<N ; i++){
      ans+=(M*i % mod*(N-i)% mod*M % mod)% mod ;
      ans=ans % mod ;
    }
    long cnt=calcNumOfCombination(N*M-2,K-2);
    System.out.println((ans*cnt)% mod);
  }
  static long calcNumOfCombination(int n,int r){
    long mod=1_000_000_007L ;
    return((factorial(n)*modinv(factorial(n-r),mod))% mod*modinv(factorial(r),mod))% mod ;
  }
  static long factorial(int n){
    long num=1L ;
    long mod=1_000_000_007L ;
    for(int i=n ; i>0 ; i--){
      num=num*i ;
      num %=mod ;
    }
    return num ;
  }
  static long pow(long a,long n){
    long mod=1_000_000_007L ;
    long res=1 ;
    while(n>0){
      if((n-n/2*2)==1){
        res=res*a % mod ;
      }
      a=a*a % mod ;
      n>>=1 ;
    }
    return res ;
  }
  static long modinv(long a,long mod){
    return pow(a,mod-2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var mod : long ; mod := 1_000_000_007L ;
    var ans : long ; ans := 0L ;
        var i : int ; i := 0 ; while i < M do ( (     ans := ans+((N * i mod mod * (M - i) mod mod * N mod mod) mod mod) ; 
     ans := ans mod mod )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     ans := ans+((M * i mod mod * (N - i) mod mod * M mod mod) mod mod) ; 
     ans := ans mod mod )  ;     i := i + 1 ) ; 
    var cnt : long ; cnt := calcNumOfCombination(N * M - 2, K - 2) ;
    OclFile["System.out"].println((ans * cnt) mod mod) ; 
 );
  static   operation calcNumOfCombination( n : int, r : int) : long
  pre: true
  post: true
  activity: (     var mod : long ; mod := 1_000_000_007L ;
     return ((factorial(n) * modinv(factorial(n - r), mod)) mod mod * modinv(factorial(r), mod)) mod mod );
  static   operation factorial( n : int) : long
  pre: true
  post: true
  activity: (     var num : long ; num := 1L ;
     var mod : long ; mod := 1_000_000_007L ;
         var i : int ; i := n ; while i > 0 do ( (     num := num * i ; 
     num := num mod mod )  ;     i := i - 1 ) ; 
     return num );
  static   operation pow( a : long, n : long) : long
  pre: true
  post: true
  activity: (     var mod : long ; mod := 1_000_000_007L ;
     var res : long ; res := 1 ;
     while (n > 0) do (     if ((n - n / 2 * 2) = 1) then (     res := res * a mod mod ) else skip ; 
     a := a * a mod mod ; 
     n := n/(2->pow(1)) ) ; 
     return res );
  static   operation modinv( a : long, mod : long) : long
  pre: true
  post: true
  activity: (     return pow(a, mod - 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static OutputStream outputStream=System.out ;
  static PrintWriter out=new PrintWriter(outputStream);
  static int n,m ;
  static long mod=1000000007 ;
  static long[] fact ;
  static long power(long x,long y){
    if(y==0)return 1 ;
    long cp=power(x,y/2);
    if(y % 2==0)return(cp*cp)% mod ;
    return((cp*cp)% mod*x)% mod ;
  }
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] s=br.readLine().split(" ");
    n=Integer.parseInt(s[0]);
    m=Integer.parseInt(s[1]);
    int k=Integer.parseInt(s[2]);
    long dis=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<m ; j++){
        long left=j ;
        left*=(left+1);
        left/=2 ;
        left*=n ;
        dis+=(left)% mod ;
        left=i ;
        left*=(left+1);
        left/=2 ;
        left*=m ;
        dis+=(left)% mod ;
      }
    }
    dis %=mod ;
    fact=new long[n*m+10];
    fact[0]=1 ;
    for(int i=1 ; i<n*m+10 ; i++){
      fact[i]=(i*fact[i-1])% mod ;
    }
    long ans=fact[n*m-2];
    ans*=power(fact[k-2],mod-2);
    ans %=mod ;
    ans*=power(fact[n*m-k],mod-2);
    ans %=mod ;
    ans*=dis ;
    ans %=mod ;
    out.println(ans);
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute outputStream : OclFile := OclFile["System.out"];
  static   attribute out : OclFile := OclFile.newOclFile_Write(outputStream);
  static   attribute n : int;
  static   attribute mod : long := 1000000007;
  static   attribute fact : Sequence(long);
  static   operation power( x : long, y : long) : long
  pre: true
  post: true
  activity: (     if (y = 0) then     return 1 else skip ; 
     var cp : long ; cp := power(x, y / 2) ;
     if (y mod 2 = 0) then     return (cp * cp) mod mod else skip ; 
     return ((cp * cp) mod mod * x) mod mod );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
    n := (s[0+1])->toInteger() ; 
    m := (s[1+1])->toInteger() ; 
    var k : int ; k := (s[2+1])->toInteger() ;
    var dis : long ; dis := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < m do ( (     var left : long ; left := j ;
     left := left*((left + 1)) ; 
    left := left/(2) ; 
    left := left*(n) ; 
    dis := dis+((left) mod mod) ; 
    left := i ; 
    left := left*((left + 1)) ; 
    left := left/(2) ; 
    left := left*(m) ; 
    dis := dis+((left) mod mod) ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    dis := dis mod mod ; 
    fact := Integer.subrange(1,n * m + 10)->collect(0) ; 
    fact[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < n * m + 10 do ( (     fact[i+1] := (i * fact[i - 1+1]) mod mod )  ;     i := i + 1 ) ; 
    var ans : long ; ans := fact[n * m - 2+1] ;
    ans := ans*(power(fact[k - 2+1], mod - 2)) ; 
    ans := ans mod mod ; 
    ans := ans*(power(fact[n * m - k+1], mod - 2)) ; 
    ans := ans mod mod ; 
    ans := ans*(dis) ; 
    ans := ans mod mod ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class _1602a_TowSubseqwences {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int test=in.nextInt();
    while(test-->0){
      solve(in);
    }
  }
  static void solve(Scanner in){
    String str=in.next();
    char min=str.charAt(0);
    for(int i=0 ; i<str.length(); i++){
      if(min>str.charAt(i)){
        min=str.charAt(i);
      }
    }
    String part2=str.substring(0,str.indexOf(""+min))+str.substring(str.indexOf(""+min)+1,str.length());
    System.out.println(min+" "+part2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1602a_TowSubseqwences {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := in.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     execute solve(in) ) ;  ) );
  static   operation solve( in : OclFile) : void
  pre: true
  post: true
  activity: (     var str : String ; str := in.getCurrent() ;
     var min : String ; min := str->at(0+1) ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (min > str->at(i+1)) then (     min := str->at(i+1) ) else skip )  ;     i := i + 1 ) ; 
    var part2 : String ; part2 := str.subrange(0+1,str->indexOf("" + min)-1) + str.subrange(str->indexOf("" + min)-1 + 1+1,str->size()) ;
    OclFile["System.out"].println(min + " " + part2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int m=in.nextInt();
    int k=in.nextInt();
    int mod=1000000007 ;
    long count=0 ;
    for(long i=n-1 ; i>=1 ; i--)count=(count+(i*(i+1)*m*m)/2)% mod ;
    for(long i=m-1 ; i>=1 ; i--)count=(count+(i*(i+1)*n*n)/2)% mod ;
    System.out.println((count*nCk(n*m-2,k-2,mod))% mod);
    in.close();
  }
  public static long pow(long a,long b,int M){
    long ret=1 ;
    long tmp=a ;
    while(b>0){
      if((b & 1)==1)ret=(ret*tmp)% M ;
      tmp=(tmp*tmp)% M ;
      b=b>>1 ;
    }
    return ret ;
  }
  public static int nCk(int n,int k,int M){
    long ret=1 ;
    int min=Math.min(k,n-k);
    for(int i=1 ; i<=min ; i++){
      ret=(ret*pow(i,M-2,M))% M ;
    }
    for(int i=n-min+1 ; i<=n ; i++){
      ret=(ret*i)% M ;
    }
    return(int)ret ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var m : int ; m := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var mod : int ; mod := 1000000007 ;
    var count : long ; count := 0 ;
        var i : long ; i := n - 1 ; while i >= 1 do (     count := (count + (i * (i + 1) * m * m) / 2) mod mod ;  ;     i := i - 1 ) ; 
        var i : long ; i := m - 1 ; while i >= 1 do (     count := (count + (i * (i + 1) * n * n) / 2) mod mod ;  ;     i := i - 1 ) ; 
    OclFile["System.out"].println((count * nCk(n * m - 2, k - 2, mod)) mod mod) ; 
    skip ; 
 );
  static   operation pow( a : long, b : long, M : int) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := 1 ;
     var tmp : long ; tmp := a ;
     while (b > 0) do (     if ((b & 1) = 1) then     ret := (ret * tmp) mod M ; else skip ; 
     tmp := (tmp * tmp) mod M ; 
     b := (b/(2->pow(1)))->oclAsType(long) ) ; 
     return ret );
  static   operation nCk( n : int, k : int, M : int) : int
  pre: true
  post: true
  activity: (     var ret : long ; ret := 1 ;
     var min : int ; min := Set{k, n - k}->min() ;
        var i : int ; i := 1 ; while i <= min do ( (     ret := (ret * pow(i, M - 2, M)) mod M )  ;     i := i + 1 ) ; 
        var i : int ; i := n - min + 1 ; while i <= n do ( (     ret := (ret * i) mod M )  ;     i := i + 1 ) ; 
    return ret->oclAsType(int) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.LongStream ;
public class Main {
  private static final long MOD=1_000_000_007 ;
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt(),m=scanner.nextInt(),k=scanner.nextInt();
      long xSum=n*m % MOD*(n-1)% MOD*(m % MOD*(n+1)% MOD+(m-1)% MOD*(m+1)% MOD)% MOD*powMod(6,MOD-2)% MOD ;
      long ySum=n*m % MOD*(m-1)% MOD*(m+1)% MOD*powMod(6,MOD-2)% MOD ;
      System.out.println((xSum+ySum+MOD)% MOD*combinationMod(n*m-2,k-2)% MOD);
    }
  }
  private static long combinationMod(long n,int m){
    long min=Math.min(m,n-m),max=Math.max(m,n-m);
    long factorialMin=LongStream.rangeClosed(1,min).reduce(1L,(result,next)->result=result*next % MOD);
    long factorialMax=LongStream.rangeClosed(min+1,max).reduce(factorialMin,(result,next)->result=result*next % MOD);
    long factorialN=LongStream.rangeClosed(max+1,n).reduce(factorialMax,(result,next)->result=result*next % MOD);
    return factorialN*powMod(factorialMin,MOD-2)% MOD*powMod(factorialMax,MOD-2)% MOD ;
  }
  private static long powMod(long n,long m){
    long result=1L ;
    while(m>0){
      if(1==(1 & m)){
        result=result*n % MOD ;
      }
      n=n*n % MOD ;
      m>>=1 ;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
     var xSum : long ; xSum := n * m mod MOD * (n - 1) mod MOD * (m mod MOD * (n + 1) mod MOD + (m - 1) mod MOD * (m + 1) mod MOD) mod MOD * powMod(6, MOD - 2) mod MOD ;
     var ySum : long ; ySum := n * m mod MOD * (m - 1) mod MOD * (m + 1) mod MOD * powMod(6, MOD - 2) mod MOD ;
     OclFile["System.out"].println((xSum + ySum + MOD) mod MOD * combinationMod(n * m - 2, k - 2) mod MOD) ))  );
  static   operation combinationMod( n : long, m : int) : long
  pre: true
  post: true
  activity: (     var min : long ; min := Set{m, n - m}->min() ;
    var max : long ; max := Set{m, n - m}->max() ;
     var factorialMin : long ; factorialMin := Integer.subrange(1, min)->iterate( _var; _acc : OclAny | 1L, lambda lambda (result , next) : OclAny in in (    result := result * next mod MOD & result)->apply((_acc,_var)) ) ;
    var factorialMax : long ; factorialMax := Integer.subrange(min + 1, max)->iterate( _var; _acc : OclAny | factorialMin, lambda lambda (result , next) : OclAny in in (    result := result * next mod MOD & result)->apply((_acc,_var)) ) ;
    var factorialN : long ; factorialN := Integer.subrange(max + 1, n)->iterate( _var; _acc : OclAny | factorialMax, lambda lambda (result , next) : OclAny in in (    result := result * next mod MOD & result)->apply((_acc,_var)) ) ;
    return factorialN * powMod(factorialMin, MOD - 2) mod MOD * powMod(factorialMax, MOD - 2) mod MOD 
 );
  static   operation powMod( n : long, m : long) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 1L ;
     while (m > 0) do (     if (1 = (MathLib.bitwiseAnd(1,m))) then (     result := result * n mod MOD ) else skip ; 
     n := n * n mod MOD ; 
     m := m/(2->pow(1)) ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.stream.LongStream ;
public class Main {
  private static final long MOD=1_000_000_007 ;
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt(),m=scanner.nextInt(),k=scanner.nextInt();
      long xSum=LongStream.range(1,n).reduce(0L,(sum,next)->(sum+next*(n-next)% MOD*m % MOD*m % MOD)% MOD);
      long ySum=LongStream.range(1,m).reduce(0L,(sum,next)->(sum+next*(m-next)% MOD*n % MOD*n % MOD)% MOD);
      System.out.println((xSum+ySum)% MOD*combinationMod(n*m-2,k-2)% MOD);
    }
  }
  private static long combinationMod(long n,int m){
    long min=Math.min(m,n-m),max=Math.max(m,n-m);
    long factorialMin=LongStream.rangeClosed(1,min).reduce(1L,(result,next)->result=result*next % MOD);
    long factorialMax=LongStream.rangeClosed(min+1,max).reduce(factorialMin,(result,next)->result=result*next % MOD);
    long factorialN=LongStream.rangeClosed(max+1,n).reduce(factorialMax,(result,next)->result=result*next % MOD);
    return factorialN*powMod(factorialMin,MOD-2)% MOD*powMod(factorialMax,MOD-2)% MOD ;
  }
  private static long powMod(long n,long m){
    long result=1L ;
    while(m>0){
      if(1==(1 & m)){
        result=result*n % MOD ;
      }
      n=n*n % MOD ;
      m>>=1 ;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 1_000_000_007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var m : int ; m := scanner.getCurrent()->toInteger() ;
    var k : int ; k := scanner.getCurrent()->toInteger() ;
     var xSum : long ; xSum := Integer.subrange(1, n-1)->iterate( _var; _acc : OclAny | 0L, lambda (sum , next) : OclAny in (sum + next * (n - next) mod MOD * m mod MOD * m mod MOD) mod MOD->apply((_acc,_var)) ) ;
     var ySum : long ; ySum := Integer.subrange(1, m-1)->iterate( _var; _acc : OclAny | 0L, lambda (sum , next) : OclAny in (sum + next * (m - next) mod MOD * n mod MOD * n mod MOD) mod MOD->apply((_acc,_var)) ) ;
     OclFile["System.out"].println((xSum + ySum) mod MOD * combinationMod(n * m - 2, k - 2) mod MOD) ))  );
  static   operation combinationMod( n : long, m : int) : long
  pre: true
  post: true
  activity: (     var min : long ; min := Set{m, n - m}->min() ;
    var max : long ; max := Set{m, n - m}->max() ;
     var factorialMin : long ; factorialMin := Integer.subrange(1, min)->iterate( _var; _acc : OclAny | 1L, lambda lambda (result , next) : OclAny in in (    result := result * next mod MOD & result)->apply((_acc,_var)) ) ;
    var factorialMax : long ; factorialMax := Integer.subrange(min + 1, max)->iterate( _var; _acc : OclAny | factorialMin, lambda lambda (result , next) : OclAny in in (    result := result * next mod MOD & result)->apply((_acc,_var)) ) ;
    var factorialN : long ; factorialN := Integer.subrange(max + 1, n)->iterate( _var; _acc : OclAny | factorialMax, lambda lambda (result , next) : OclAny in in (    result := result * next mod MOD & result)->apply((_acc,_var)) ) ;
    return factorialN * powMod(factorialMin, MOD - 2) mod MOD * powMod(factorialMax, MOD - 2) mod MOD 
 );
  static   operation powMod( n : long, m : long) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 1L ;
     while (m > 0) do (     if (1 = (MathLib.bitwiseAnd(1,m))) then (     result := result * n mod MOD ) else skip ; 
     n := n * n mod MOD ; 
     m := m/(2->pow(1)) ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int n=stdIn.nextInt();
    int m=stdIn.nextInt();
    if(n==1 && m==1){
      System.out.println(1);
    }
    else if(n==1 && m!=1){
      System.out.println(m-2);
    }
    else if(m==1 && n!=1){
      System.out.println(n-2);
    }
    else {
      System.out.println((long)(m-2)*(n-2));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     var m : int ; m := stdIn.getCurrent()->toInteger() ;
     if (n = 1 & m = 1) then (     OclFile["System.out"].println(1) ) else     if (n = 1 & m /= 1) then (     OclFile["System.out"].println(m - 2) ) else     if (m = 1 & n /= 1) then (     OclFile["System.out"].println(n - 2) ) else (     OclFile["System.out"].println((m - 2)->oclAsType(long) * (n - 2)) ) ;  ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Link2 {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int r=1 ;
    int c=1 ;
    int i=0 ;
    while(true){
      if(r*c>=n){
        break ;
      }
      else {
        if(i % 2==0){
          r++;
        }
        else if(i % 2!=0){
          c++;
        }
      }
      i++;
    }
    System.out.println(r+c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Link2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var r : int ; r := 1 ;
    var c : int ; c := 1 ;
    var i : int ; i := 0 ;
    while (true) do (     if (r * c >= n) then (     break ) else (     if (i mod 2 = 0) then (     r := r + 1 ) else     if (i mod 2 /= 0) then (     c := c + 1 ) else skip ; ) ;  
     i := i + 1 ) ; 
    OclFile["System.out"].println(r + c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] tmp=br.readLine().split(" ");
    long N=Integer.parseInt(tmp[0]);
    long M=Integer.parseInt(tmp[1]);
    if(N==1 && M==1)System.out.println(1);
    else if(N==1 || M==1)System.out.println(N*M-2);
    else System.out.println(N*M-2*(N+M-2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmp : Sequence(String) ; tmp := br.readLine()->split(" ") ;
    var N : long ; N := (tmp[0+1])->toInteger() ;
    var M : long ; M := (tmp[1+1])->toInteger() ;
    if (N = 1 & M = 1) then     OclFile["System.out"].println(1) else     if (N = 1 or M = 1) then     OclFile["System.out"].println(N * M - 2) else     OclFile["System.out"].println(N * M - 2 * (N + M - 2)) ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Scanner ;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int mi=Math.min(N,M);
    int ma=Math.max(N,M);
    if(mi==1 && ma==1){
      System.out.println(1);
    }
    else if(mi==1){
      System.out.println(ma-2);
    }
    else {
      System.out.println((long)(N-2)*(M-2));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var mi : int ; mi := Set{N, M}->min() ;
    var ma : int ; ma := Set{N, M}->max() ;
    if (mi = 1 & ma = 1) then (     OclFile["System.out"].println(1) ) else     if (mi = 1) then (     OclFile["System.out"].println(ma - 2) ) else (     OclFile["System.out"].println((N - 2)->oclAsType(long) * (M - 2)) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long m=sc.nextLong();
    sc.close();
    long x=Math.min(n,m);
    long y=Math.max(n,m);
    if(x==1){
      if(y==1){
        System.out.println(1);
      }
      else if(y==2){
        System.out.println(0);
      }
      else {
        System.out.println(y-2);
      }
    }
    else if(x==2){
      System.out.println(0);
    }
    else {
      System.out.println((x-2)*(y-2));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var m : long ; m := sc.getCurrent()->toLong() ;
    skip ; 
    var x : long ; x := Set{n, m}->min() ;
    var y : long ; y := Set{n, m}->max() ;
    if (x = 1) then (     if (y = 1) then (     OclFile["System.out"].println(1) ) else     if (y = 2) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println(y - 2) ) ;  ) else     if (x = 2) then (     OclFile["System.out"].println(0) ) else (     OclFile["System.out"].println((x - 2) * (y - 2)) ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] tmpArray=br.readLine().split(" ");
    long n=Integer.parseInt(tmpArray[0]);
    long m=Integer.parseInt(tmpArray[1]);
    if(n>m){
      long tmp=n ;
      n=m ;
      m=tmp ;
    }
    if(n==1){
      if(m==1){
        System.out.println(1);
      }
      else {
        System.out.println(m-2);
      }
      return ;
    }
    System.out.println((m-2)*(n-2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
    var n : long ; n := (tmpArray[0+1])->toInteger() ;
    var m : long ; m := (tmpArray[1+1])->toInteger() ;
    if (n > m) then (     var tmp : long ; tmp := n ;
     n := m ; 
     m := tmp ) else skip ; 
    if (n = 1) then (     if (m = 1) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(m - 2) ) ;  
     return ) else skip ; 
    OclFile["System.out"].println((m - 2) * (n - 2)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    Movie[] movies=new Movie[n];
    for(int i=0 ; i<n ; i++){
      String[] tmpArray=br.readLine().split(" ");
      movies[i]=new Movie(Integer.parseInt(tmpArray[0]),Integer.parseInt(tmpArray[1]));
    }
    Arrays.sort(movies);
    int first=0 ;
    int date=0 ;
    boolean[] isFirst=new boolean[32];
    for(int i=0 ; i<n ; i++){
      for(int j=movies[i] .start ; j<=movies[i] .end ; j++){
        if(! isFirst[j]){
          isFirst[j]=true ;
          first++;
          break ;
        }
      }
    }
    System.out.println(50*31+50*first);
  }
}
class Movie implements Comparable<Movie>{
  int start ;
  int end ;
  int interval ;
  public Movie(int s,int e){
    this.start=s ;
    this.end=e ;
    this.interval=e-s+1 ;
  }
  @ Override public int compareTo(Movie m){
    return this.interval==m.interval ?(this.start==m.start ? 0 : this.start-m.start): this.interval-m.interval ;
  }
  public String toString(){
    return "from "+start+" to "+end ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var movies : Sequence(Movie) ; movies := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
     movies[i+1] := Movie.newMovie((tmpArray[0+1])->toInteger(), (tmpArray[1+1])->toInteger()) )  ;     i := i + 1 ) ; 
    movies := movies->sort() ; 
    var first : int ; first := 0 ;
    var date : int ; date := 0 ;
    var isFirst : Sequence(boolean) ; isFirst := Integer.subrange(1,32)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := movies[i+1].start ; while j <= movies[i+1].end do ( (     if (not(isFirst[j+1])) then (     isFirst[j+1] := true ; 
     first := first + 1 ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(50 * 31 + 50 * first) ; 
 );
}
class Movie implements Comparable<Movie> {
   attribute start : int;
   attribute end : int;
   attribute interval : int;
   static operation newMovie( s : int, e : int) : Movie
  pre: true
  post: true
  activity:
  ( var self : Movie ;
    self := createMovie();
    self.initialise(s, e);
    return self );
  operation initialise( s : int, e : int) : void
  pre: true  post: true
  activity: (     self.start := s ; 
     self.end := e ; 
     self.interval := e - s + 1 );
      operation compareTo( m : Movie) : int
  pre: true
  post: true
  activity: (     return if self.interval = m.interval then (if self.start = m.start then 0 else self.start - m.start endif) else self.interval - m.interval endif );
   operation toString() : String
  pre: true
  post: true
  activity: (     return "from " + start + " to " + end );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPeak(int arr[],int n,int num,int i,int j){
    if(i>=0 && arr[i]>num){
      return false ;
    }
    if(j<n && arr[j]>num){
      return false ;
    }
    return true ;
  }
  static boolean isTrough(int arr[],int n,int num,int i,int j){
    if(i>=0 && arr[i]<num){
      return false ;
    }
    if(j<n && arr[j]<num){
      return false ;
    }
    return true ;
  }
  static void printPeaksTroughs(int arr[],int n){
    System.out.print("Peaks : ");
    for(int i=0 ; i<n ; i++){
      if(isPeak(arr,n,arr[i],i-1,i+1)){
        System.out.print(arr[i]+" ");
      }
    }
    System.out.println("");
    System.out.print("Troughs : ");
    for(int i=0 ; i<n ; i++){
      if(isTrough(arr,n,arr[i],i-1,i+1)){
        System.out.print(arr[i]+" ");
      }
    }
  }
  public static void main(String[] args){
    int arr[]={
      5,10,5,7,4,3,5 };
      int n=arr.length ;
      printPeaksTroughs(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPeak( arr : Sequence(int), n : int, num : int, i : int, j : int) : boolean
  pre: true
  post: true
  activity: (     if (i >= 0 & arr[i+1] > num) then (     return false ) else skip ; 
     if (j < n & arr[j+1] > num) then (     return false ) else skip ; 
     return true );
  static   operation isTrough( arr : Sequence(int), n : int, num : int, i : int, j : int) : boolean
  pre: true
  post: true
  activity: (     if (i >= 0 & arr[i+1] < num) then (     return false ) else skip ; 
     if (j < n & arr[j+1] < num) then (     return false ) else skip ; 
     return true );
  static   operation printPeaksTroughs( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("Peaks : ") ; 
         var i : int ; i := 0 ; while i < n do ( (     if (isPeak(arr, n, arr[i+1], i - 1, i + 1)) then (     OclFile["System.out"].print(arr[i+1] + " ") ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
    OclFile["System.out"].print("Troughs : ") ; 
        var i : int ; i := 0 ; while i < n do ( (     if (isTrough(arr, n, arr[i+1], i - 1, i + 1)) then (     OclFile["System.out"].print(arr[i+1] + " ") ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,10,5,7,4,3,5} ;
     var n : int ; n := arr->size() ;
     execute printPeaksTroughs(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int getPosOfRightmostSetBit(int n){
    return(int)((Math.log10(n &-n))/(Math.log10(2)))+1 ;
  }
  static int setRightmostUnsetBit(int n){
    if(n==0)return 1 ;
    if((n &(n+1))==0)return n ;
    int pos=getPosOfRightmostSetBit(~ n);
    return((1<<(pos-1))| n);
  }
  public static void main(String arg[]){
    int n=21 ;
    System.out.print(setRightmostUnsetBit(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation getPosOfRightmostSetBit( n : int) : int
  pre: true
  post: true
  activity: (     return (((n & -n)->log10()) / ((2)->log10()))->oclAsType(int) + 1 );
  static   operation setRightmostUnsetBit( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 1 else skip ; 
     if ((n & (n + 1)) = 0) then     return n else skip ; 
     var pos : int ; pos := getPosOfRightmostSetBit(-(n + 1)) ;
     return (((1*(2->pow((pos - 1))))->oclAsType(long)) or n) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 21 ;
     OclFile["System.out"].print(setRightmostUnsetBit(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void modularEquation(int a,int b){
    if(a<b){
      System.out.println("No solution possible ");
      return ;
    }
    if(a==b){
      System.out.println("Infinite Solution possible ");
      return ;
    }
    int count=0 ;
    int n=a-b ;
    int y=(int)Math.sqrt(a-b);
    for(int i=1 ; i<=y ; ++i){
      if(n % i==0){
        if(n/i>b)count++;
        if(i>b)count++;
      }
    }
    if(y*y==n && y>b)count--;
    System.out.println(count);
  }
  public static void main(String[] args){
    int a=21,b=5 ;
    modularEquation(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation modularEquation( a : int, b : int) : void
  pre: true
  post: true
  activity: (     if (a < b) then (     OclFile["System.out"].println("No solution possible ") ; 
     return ) else skip ; 
     if (a = b) then (     OclFile["System.out"].println("Infinite Solution possible ") ; 
     return ) else skip ; 
    var count : int ; count := 0 ;
    var n : int ; n := a - b ;
    var y : int ; y := (a - b)->sqrt()->oclAsType(int) ;
        var i : int ; i := 1 ; while i <= y do ( (     if (n mod i = 0) then (     if (n / i > b) then     count := count + 1 ; else skip ; 
     if (i > b) then     count := count + 1 ; else skip ) else skip )  ;     i := i + 1 ) ; 
    if (y * y = n & y > b) then     count := count - 1 ; else skip ; 
    OclFile["System.out"].println(count) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 21 ;
    var b : int ; b := 5 ;
     execute modularEquation(a, b) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findSplTripletsSum(int a[],int b[],int c[],int p,int q,int r){
    int sum=0 ;
    for(int i=0 ; i<p ; i++){
      for(int j=0 ; j<q ; j++){
        for(int k=0 ; k<r ; k++){
          if(a[i]<=b[j] && c[k]<=b[j]){
            sum+=(a[i]+b[j])*(b[j]+c[k]);
          }
        }
      }
    }
    return sum ;
  }
  public static void main(String[] args){
    int A[]={
      1,4,5 };
      int B[]={
        2,3 };
        int C[]={
          2,1,3 };
          int p=A.length ;
          int q=B.length ;
          int r=C.length ;
          System.out.print("Sum of values of all special triplets="+findSplTripletsSum(A,B,C,p,q,r)+"\n");
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findSplTripletsSum( a : Sequence(int), b : Sequence(int), c : Sequence(int), p : int, q : int, r : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < p do ( (         var j : int ; j := 0 ; while j < q do ( (         var k : int ; k := 0 ; while k < r do ( (     if (a[i+1] <= b[j+1] & c[k+1] <= b[j+1]) then (     sum := sum+((a[i+1] + b[j+1]) * (b[j+1] + c[k+1])) ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : Sequence(int) ; A := Sequence{1,4,5} ;
     var B : Sequence(int) ; B := Sequence{2,3} ;
    var C : Sequence(int) ; C := Sequence{2,1,3} ;
    var p : int ; p := A->size() ;
    var q : int ; q := B->size() ;
    var r : int ; r := C->size() ;
    OclFile["System.out"].print("Sum of values of all special triplets=" + findSplTripletsSum(A, B, C, p, q, r) + "\n") ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static double aver(int[] arr){
    int sum=0 ;
    for(int i=0 ; i<arr.length ; i++){
      sum=sum+arr[i];
    }
    return sum/arr.length ;
  }
  public static int fac(int x){
    int sum=1 ;
    while(x>0){
      sum=sum*x ;
      x=x-1 ;
    }
    return sum ;
  }
  public static int comb(int x,int y){
    int sum=0 ;
    sum=fac(x);
    int temp=(fac(y)*fac(x-y));
    return sum/temp ;
  }
  public static int comp(String x,String y){
    int count=0 ;
    String[] arr=x.split("");
    String[] arrr=y.split("");
    for(int i=0 ; i<arrr.length ; i++){
      if(! arr[i] .equals(arrr[i]))count+=1 ;
    }
    return count ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n>0){
      String[] arr=sc.next().split("");
      String x=sc.next();
      boolean flag=false ;
      for(int i=0 ; i<arr.length ; i++){
        if(arr[i] .equals(x)){
          if(i % 2==0 &&((arr.length-1)-i)% 2==0)flag=true ;
        }
      }
      n=n-1 ;
      if(flag)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation aver( arr : Sequence(int)) : double
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     sum := sum + arr[i+1] )  ;     i := i + 1 ) ; 
     return sum / arr->size() );
  static   operation fac( x : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 1 ;
     while (x > 0) do (     sum := sum * x ; 
     x := x - 1 ) ; 
     return sum );
  static   operation comb( x : int, y : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     sum := fac(x) ; 
     var temp : int ; temp := (fac(y) * fac(x - y)) ;
     return sum / temp );
  static   operation comp( x : String, y : String) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var arr : Sequence(String) ; arr := x->split("") ;
    var arrr : Sequence(String) ; arrr := y->split("") ;
        var i : int ; i := 0 ; while i < arrr->size() do ( (     if (not(arr[i+1] = arrr[i+1])) then     count := count+(1) ; else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     while (n > 0) do (     var arr : Sequence(String) ; arr := sc.getCurrent()->split("") ;
     var x : String ; x := sc.getCurrent() ;
    var flag : boolean ; flag := false ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1] = x) then (     if (i mod 2 = 0 & ((arr->size() - 1) - i) mod 2 = 0) then     flag := true ; else skip ) else skip )  ;     i := i + 1 ) ; 
    n := n - 1 ; 
    if (flag) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CD {
  private static int max ;
  public static void main(String[] args){
    Scanner st=new Scanner(System.in);
    int t=st.nextInt();
    while(t-->0){
      String s=st.next();
      String c=st.next();
      HashMap<String,Integer>map=new HashMap<>();
      String[] arr=s.split("");
      int amt=0 ;
      for(int i=0 ; i<arr.length ; i++){
        if(map.containsKey(arr[i])){
          if(map.get(arr[i])% 2==0){
            amt++;
          }
          else {
            map.put(arr[i],i);
          }
        }
        else {
          map.put(arr[i],i);
        }
      }
      if(map.containsKey(c)){
        if(map.get(c)% 2==0){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
      else {
        System.out.println("NO");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CD {
  static   attribute max : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var st : OclFile ; st := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := st.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var s : String ; s := st.getCurrent() ;
     var c : String ; c := st.getCurrent() ;
    var map : Map(String,int) ; map := Map{} ;
    var arr : Sequence(String) ; arr := s->split("") ;
    var amt : int ; amt := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (map->keys()->includes(arr[i+1])) then (     if (map->at(arr[i+1]) mod 2 = 0) then (     amt := amt + 1 ) else (     map := map->union(Map{arr[i+1] |-> i}) ) ) else (     map := map->union(Map{arr[i+1] |-> i}) ) )  ;     i := i + 1 ) ; 
    if (map->keys()->includes(c)) then (     if (map->at(c) mod 2 = 0) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ) else (     OclFile["System.out"].println("NO") ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class pre5 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int n=obj.nextInt();
    int sq=(int)sqrt(n);
    if(sq*sq==n)out.println(sq*2);
    else {
      if((sq+1)*sq>=n)out.println(2*sq+1);
      else out.println(2*sq+2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre5 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var n : int ; n := obj.nextInt() ;
     var sq : int ; sq := sqrt(n)->oclAsType(int) ;
     if (sq * sq = n) then     out.println(sq * 2) ; else (     if ((sq + 1) * sq >= n) then     out.println(2 * sq + 1) ; else     out.println(2 * sq + 2) ; ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test190 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      char a[]=in.next().toCharArray();
      char c=in.next().charAt(0);
      boolean x=false ;
      for(int i=0 ; i<a.length ; i++){
        if(a[i]==c && i % 2==0){
          x=true ;
          break ;
        }
      }
      if(x){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test190 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var a : Sequence(String) ; a := in.getCurrent()->characters() ;
     var c : String ; c := in.getCurrent()->at(0+1) ;
    var x : boolean ; x := false ;
        var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] = c & i mod 2 = 0) then (     x := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (x) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      String s=sc.next();
      char c=sc.next().charAt(0);
      int count=-1 ;
      for(int j=0 ; j<s.length(); j++){
        if(s.charAt(j)==c){
          if(j % 2==0){
            count=j ;
          }
        }
      }
      if(count!=-1){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var s : String ; s := sc.getCurrent() ;
     var c : String ; c := sc.getCurrent()->at(0+1) ;
    var count : int ; count := -1 ;
        var j : int ; j := 0 ; while j < s->size() do ( (     if (s->at(j+1) = c) then (     if (j mod 2 = 0) then (     count := j ) else skip ) else skip )  ;     j := j + 1 ) ; 
    if (count /= -1) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPalindrome(int n){
    if(n % 11==0){
      return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    System.out.println(isPalindrome(123321)? "Palindrome" : "Not Palindrome");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPalindrome( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n mod 11 = 0) then (     return true ) else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(if isPalindrome(123321) then "Palindrome" else "Not Palindrome" endif) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    if(A==B){
      System.out.println("Draw");
    }
    else if((A>B && B!=1)|| A==1){
      System.out.println("Alice");
    }
    else {
      System.out.println("Bob");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
     if (A = B) then (     OclFile["System.out"].println("Draw") ) else     if ((A > B & B /= 1) or A = 1) then (     OclFile["System.out"].println("Alice") ) else (     OclFile["System.out"].println("Bob") ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int index(int i){
    return 1+(i>>31)-(-i>>31);
  }
  static void check(int n){
    String s[]={
      "negative","zero","positive" };
      int val=index(n);
      System.out.println(n+" is "+s[val]);
    }
    public static void main(String[] args){
      check(30);
      check(-20);
      check(0);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation index( i : int) : int
  pre: true
  post: true
  activity: (     return 1 + ((i/(2->pow(31)))->oclAsType(long)) - ((-i/(2->pow(31)))->oclAsType(long)) );
  static   operation check( n : int) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := Sequence{"negative","zero","positive"} ;
     var val : int ; val := index(n) ;
     OclFile["System.out"].println(n + " is " + s[val+1]) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute check(30) ; 
     execute check(-20) ; 
     execute check(0) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.*;
public class Main {
  void solve()throws IOException {
    int a=ni();
    int b=ni();
    if(a==1)a=14 ;
    if(b==1)b=14 ;
    if(a==b){
      out.println("Draw");
    }
    else if(a<b){
      out.println("Bob");
    }
    else {
      out.println("Alice");
    }
  }
  String ns()throws IOException {
    while(! tok.hasMoreTokens()){
      tok=new StringTokenizer(in.readLine()," ");
    }
    return tok.nextToken();
  }
  int ni()throws IOException {
    return Integer.parseInt(ns());
  }
  long nl()throws IOException {
    return Long.parseLong(ns());
  }
  double nd()throws IOException {
    return Double.parseDouble(ns());
  }
  String[] nsa(int n)throws IOException {
    String[] res=new String[n];
    for(int i=0 ; i<n ; i++){
      res[i]=ns();
    }
    return res ;
  }
  int[] nia(int n)throws IOException {
    int[] res=new int[n];
    for(int i=0 ; i<n ; i++){
      res[i]=ni();
    }
    return res ;
  }
  long[] nla(int n)throws IOException {
    long[] res=new long[n];
    for(int i=0 ; i<n ; i++){
      res[i]=nl();
    }
    return res ;
  }
  static BufferedReader in ;
  static PrintWriter out ;
  static StringTokenizer tok ;
  public static void main(String[] args)throws IOException {
    in=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(System.out);
    tok=new StringTokenizer("");
    Main main=new Main();
    main.solve();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var a : int ; a := ni() ;
     var b : int ; b := ni() ;
    if (a = 1) then     a := 14 ; else skip ; 
    if (b = 1) then     b := 14 ; else skip ; 
    if (a = b) then (     out.println("Draw") ) else     if (a < b) then (     out.println("Bob") ) else (     out.println("Alice") ) ;  ;  
 );
   operation ns() : String
  pre: true
  post: true
  activity: (     while (not(tok.hasNext())) do (     tok := OclIterator.newOclIterator_String_String(in.readLine(), " ") ) ; 
     return tok.next() );
   operation ni() : int
  pre: true
  post: true
  activity: (     return (ns())->toInteger() );
   operation nl() : long
  pre: true
  post: true
  activity: (     return (ns())->toLong() );
   operation nd() : double
  pre: true
  post: true
  activity: (     return (ns())->toReal() );
   operation nsa( n : int) : Sequence(String)
  pre: true
  post: true
  activity: (     var res : Sequence(String) ; res := Integer.subrange(1,n)->collect(null) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := ns() )  ;     i := i + 1 ) ; 
     return res );
   operation nia( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := ni() )  ;     i := i + 1 ) ; 
     return res );
   operation nla( n : int) : Sequence(long)
  pre: true
  post: true
  activity: (     var res : Sequence(long) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := nl() )  ;     i := i + 1 ) ; 
     return res );
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   attribute tok : OclIterator;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    tok := OclIterator.newOclIterator_String("") ; 
    var main : Main ; main := Main.newMain() ;
    main.solve() ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
  private static boolean debug=false ;
  private static boolean elapsed=false ;
  private static PrintWriter _out=new PrintWriter(System.out);
  private static PrintWriter _err=new PrintWriter(System.err);
  private void solve(Scanner sc){
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(a==b){
      _out.println("Draw");
    }
    else if(a==1){
      _out.println("Alice");
    }
    else if(b==1){
      _out.println("Bob");
    }
    else {
      _out.println((a>b ? "Alice" : "Bob"));
    }
  }
  private static BigInteger C(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    for(long i=r ; i>1 ; --i){
      res=res.divide(BigInteger.valueOf(i));
    }
    return res ;
  }
  private static BigInteger P(long n,long r){
    BigInteger res=BigInteger.ONE ;
    for(long i=n ; i>n-r ; --i){
      res=res.multiply(BigInteger.valueOf(i));
    }
    return res ;
  }
  public static void main(String[] args){
    long S=System.currentTimeMillis();
    Scanner sc=new Scanner(System.in);
    new Main().solve(sc);
    _out.flush();
    long G=System.currentTimeMillis();
    if(elapsed){
      _err.println((G-S)+"ms");
    }
    _err.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute debug : boolean := false;
  static   attribute elapsed : boolean := false;
  static   attribute _out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   attribute _err : OclFile := OclFile.newOclFile_Write(OclFile["System.err"]);
   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.nextInt() ;
     var b : int ; b := sc.nextInt() ;
     if (a = b) then (     skip ) else     if (a = 1) then (     skip ) else     if (b = 1) then (     skip ) else (     skip ) ;  ;  );
  static   operation C( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
         var i : long ; i := r ; while i > 1 do ( (     res := res.divide((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation P( n : long, r : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 1 ;
         var i : long ; i := n ; while i > n - r do ( (     res := res.multiply((i + "")->toLong()) )  ;     i := i - 1 ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : long ; S := OclDate.getSystemTime() ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    Main.newMain().solve(sc) ; 
    skip ; 
    var G : long ; G := OclDate.getSystemTime() ;
    if (elapsed) then (     skip ) else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    a=a==1 ? 14 : a ;
    b=b==1 ? 14 : b ;
    if(a-b>0)System.out.println("Alice");
    else if(a-b<0)System.out.println("Bob");
    else System.out.println("Draw");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    a := if a = 1 then 14 else a endif ; 
    b := if b = 1 then 14 else b endif ; 
    if (a - b > 0) then     OclFile["System.out"].println("Alice") else     if (a - b < 0) then     OclFile["System.out"].println("Bob") else     OclFile["System.out"].println("Draw") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in);
){
      solve(sc);
    }
  }
  public static void solve(Scanner sc){
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(a==b){
      System.out.println("Draw");
      return ;
    }
    if(a==1){
      System.out.println("Alice");
      return ;
    }
    if(b==1){
      System.out.println("Bob");
      return ;
    }
    System.out.println(a>b ? "Alice" : "Bob");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     execute solve(sc) ))  );
  static   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    if (a = b) then (     OclFile["System.out"].println("Draw") ; 
     return ) else skip ; 
    if (a = 1) then (     OclFile["System.out"].println("Alice") ; 
     return ) else skip ; 
    if (b = 1) then (     OclFile["System.out"].println("Bob") ; 
     return ) else skip ; 
    OclFile["System.out"].println(if a > b then "Alice" else "Bob" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int minSwaps(int arr[],int n){
    int noOfOnes=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==1)noOfOnes++;
    }
    int x=noOfOnes ;
    int maxOnes=Integer.MIN_VALUE ;
    int preCompute[]=new int[n];
    if(arr[0]==1)preCompute[0]=1 ;
    for(int i=1 ; i<n ; i++){
      if(arr[i]==1){
        preCompute[i]=preCompute[i-1]+1 ;
      }
      else preCompute[i]=preCompute[i-1];
    }
    for(int i=x-1 ; i<n ; i++){
      if(i==(x-1))noOfOnes=preCompute[i];
      else noOfOnes=preCompute[i]-preCompute[i-x];
      if(maxOnes<noOfOnes)maxOnes=noOfOnes ;
    }
    int noOfZeroes=x-maxOnes ;
    return noOfZeroes ;
  }
  public static void main(String[] args){
    int a[]={
      1,0,1,0,1 };
      int n=a.length ;
      System.out.println(minSwaps(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minSwaps( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var noOfOnes : int ; noOfOnes := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 1) then     noOfOnes := noOfOnes + 1 ; else skip )  ;     i := i + 1 ) ; 
    var x : int ; x := noOfOnes ;
    var maxOnes : int ; maxOnes := -2147483648 ;
    var preCompute : Sequence(int) ; preCompute := Integer.subrange(1,n)->collect(0) ;
    if (arr[0+1] = 1) then     preCompute[0+1] := 1 ; else skip ; 
        var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] = 1) then (     preCompute[i+1] := preCompute[i - 1+1] + 1 ) else     preCompute[i+1] := preCompute[i - 1+1] ; )  ;     i := i + 1 ) ; 
        var i : int ; i := x - 1 ; while i < n do ( (     if (i = (x - 1)) then     noOfOnes := preCompute[i+1] else     noOfOnes := preCompute[i+1] - preCompute[i - x+1] ; ;  
     if (maxOnes < noOfOnes) then     maxOnes := noOfOnes ; else skip )  ;     i := i + 1 ) ; 
    var noOfZeroes : int ; noOfZeroes := x - maxOnes ;
    return noOfZeroes 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,0,1,0,1} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(minSwaps(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float findArea(float a){
    float area ;
    area=(float)(Math.sqrt(5*(5+2*(Math.sqrt(5))))*a*a)/4 ;
    return area ;
  }
  public static void main(String[] args){
    float a=5 ;
    System.out.println("Area of Pentagon: "+findArea(a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findArea( a : double) : double
  pre: true
  post: true
  activity: (     var area : double ;
     area := ((5 * (5 + 2 * ((5)->sqrt())))->sqrt() * a * a)->oclAsType(double) / 4 ; 
     return area );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : double ; a := 5 ;
     OclFile["System.out"].println("Area of Pentagon: " + findArea(a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Herb {
  static int val(){
    int groups=sc.nextInt();
    long[] start=new long[groups];
    long[] size=new long[groups];
    long[] period=new long[groups];
    int total=0 ;
    for(int i=0 ; i<groups ; i++){
      start[i]=sc.nextInt();
      size[i]=sc.nextInt();
      total+=size[i];
      period[i]=sc.nextInt();
    }
    long[] first=new long[total];
    long[] diff=new long[total];
    {
      int j=0 ;
      for(int i=0 ; i<groups ; i++){
        for(int k=0 ; k<size[i]; k++){
          first[j]=(period[i]+k)*2*(360-start[i]);
          diff[j]=2*360*period[i];
          j++;
        }
      }
    }
    long opt=total+1 ;
    for(int i=0 ; i<total ; i++){
      long crossings=0 ;
      for(int j=0 ; j<total ; j++){
        if(first[i]+1<=first[j])crossings+=1 ;
        else if(first[i]+1<=first[j]+diff[j])crossings+=0 ;
        else crossings+=(first[i]+1-first[j])/diff[j];
      }
      opt=Math.min(opt,crossings);
    }
    return(int)opt ;
  }
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int k=sc.nextInt();
    for(int kk=1 ; kk<=k ; kk++)System.out.println("Case #"+kk+": "+val());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Herb {
  static   operation val() : int
  pre: true
  post: true
  activity: (     var groups : int ; groups := sc.nextInt() ;
     var start : Sequence(long) ; start := Integer.subrange(1,groups)->collect(0) ;
    var size : Sequence(long) ; size := Integer.subrange(1,groups)->collect(0) ;
    var period : Sequence(long) ; period := Integer.subrange(1,groups)->collect(0) ;
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < groups do ( (     start[i+1] := sc.nextInt() ; 
     size[i+1] := sc.nextInt() ; 
     total := total+(size[i+1]) ; 
     period[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    var first : Sequence(long) ; first := Integer.subrange(1,total)->collect(0) ;
    var diff : Sequence(long) ; diff := Integer.subrange(1,total)->collect(0) ;
(     var j : int ; j := 0 ;
         var i : int ; i := 0 ; while i < groups do ( (         var k : int ; k := 0 ; while k < size[i+1] do ( (     first[j+1] := (period[i+1] + k) * 2 * (360 - start[i+1]) ; 
     diff[j+1] := 2 * 360 * period[i+1] ; 
     j := j + 1 )  ;     k := k + 1 ) )  ;     i := i + 1 ) ) 
    var opt : long ; opt := total + 1 ;
        var i : int ; i := 0 ; while i < total do ( (     var crossings : long ; crossings := 0 ;
         var j : int ; j := 0 ; while j < total do ( (     if (first[i+1] + 1 <= first[j+1]) then     crossings := crossings+(1) ; else     if (first[i+1] + 1 <= first[j+1] + diff[j+1]) then     crossings := crossings+(0) else     crossings := crossings+((first[i+1] + 1 - first[j+1]) / diff[j+1]) ; ;  )  ;     j := j + 1 ) ; 
     opt := Set{opt, crossings}->min() )  ;     i := i + 1 ) ; 
    return opt->oclAsType(int) 
 );
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : int ; k := sc.getCurrent()->toInteger() ;
         var kk : int ; kk := 1 ; while kk <= k do (     OclFile["System.out"].println("Case #" + kk + ": " + val()) ;  ;     kk := kk + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
public class Main {
  static List<List<Integer>>perms=new ArrayList<>();
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int b=sc.nextInt();
    int g=sc.nextInt();
    int n=sc.nextInt();
    int turnOut=n ;
    int numOfDecks=n+1 ;
    int cnt=0 ;
    for(int i=0 ; i<numOfDecks ; i++){
      int B=i ;
      int G=n-i ;
      if(B<=b && G<=g){
        cnt++;
      }
    }
    System.out.println(cnt);
  }
  public static void heapsAlgo(int k,int[] A){
    if(k==1){
      List<Integer>list=new ArrayList<>();
      for(int i=0 ; i<A.length ; i++){
        list.add(A[i]);
      }
      perms.add(list);
    }
    else {
      heapsAlgo(k-1,A);
      for(int i=0 ; i<k-1 ; i++){
        if(k % 2==0){
          int temp=A[i];
          A[i]=A[k-1];
          A[k-1]=temp ;
        }
        else {
          int temp=A[0];
          A[0]=A[k-1];
          A[k-1]=temp ;
        }
        heapsAlgo(k-1,A);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute perms : Sequence(Sequence(int)) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
    var g : int ; g := sc.getCurrent()->toInteger() ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var turnOut : int ; turnOut := n ;
    var numOfDecks : int ; numOfDecks := n + 1 ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < numOfDecks do ( (     var B : int ; B := i ;
     var G : int ; G := n - i ;
     if (B <= b & G <= g) then (     cnt := cnt + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
  static   operation heapsAlgo( k : int, A : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (k = 1) then (     var list : Sequence(int) ; list := Sequence{} ;
         var i : int ; i := 0 ; while i < A->size() do ( (     list := list->including(A[i+1]) )  ;     i := i + 1 ) ; 
     perms := perms->including(list) ) else (     execute heapsAlgo(k - 1, A) ; 
         var i : int ; i := 0 ; while i < k - 1 do ( (     if (k mod 2 = 0) then (     var temp : int ; temp := A[i+1] ;
     A[i+1] := A[k - 1+1] ; 
     A[k - 1+1] := temp ) else (     var temp : int ; temp := A[0+1] ;
     A[0+1] := A[k - 1+1] ; 
     A[k - 1+1] := temp ) ;  
     execute heapsAlgo(k - 1, A) )  ;     i := i + 1 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countOrderedPairs(int N){
    int count_pairs=0 ;
    for(int i=1 ; i<=(int)Math.sqrt(N-1); ++i){
      for(int j=i ; j*i<N ; ++j)++count_pairs ;
    }
    count_pairs*=2 ;
    count_pairs-=(int)(Math.sqrt(N-1));
    return count_pairs ;
  }
  public static void main(String[] args){
    int N=5 ;
    System.out.println(countOrderedPairs(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countOrderedPairs( N : int) : int
  pre: true
  post: true
  activity: (     var count_pairs : int ; count_pairs := 0 ;
         var i : int ; i := 1 ; while i <= (N - 1)->sqrt()->oclAsType(int) do ( (         var j : int ; j := i ; while j * i < N do (     count_pairs := count_pairs + 1 ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    count_pairs := count_pairs*(2) ; 
    count_pairs := count_pairs-(((N - 1)->sqrt())->oclAsType(int)) ; 
    return count_pairs 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     OclFile["System.out"].println(countOrderedPairs(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int MAX=1000 ;
  static int NthPrime(int n){
    int count=0 ;
    int i ;
    for(i=2 ; i<=MAX ; i++){
      int check=0 ;
      for(int j=2 ; j<=Math.sqrt(i); j++){
        if(i % j==0){
          check=1 ;
          break ;
        }
      }
      if(check==0)count++;
      if(count==n){
        return i ;
      }
    }
    return 0 ;
  }
  static int NthFib(int n){
    int[] f=new int[n+2];
    int i ;
    f[0]=0 ;
    f[1]=1 ;
    for(i=2 ; i<=n ; i++){
      f[i]=f[i-1]+f[i-2];
    }
    return f[n];
  }
  static void findNthTerm(int n){
    if(n % 2==0){
      n=n/2 ;
      n=NthPrime(n);
      System.out.println(n);
    }
    else {
      n=(n/2)+1 ;
      n=NthFib(n-1);
      System.out.println(n);
    }
  }
  public static void main(String[] args){
    int X=5 ;
    findNthTerm(X);
    X=10 ;
    findNthTerm(X);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 1000;
  static   operation NthPrime( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var i : int ;
         i := 2 ; while i <= MAX do ( (     var check : int ; check := 0 ;
         var j : int ; j := 2 ; while j <= (i)->sqrt() do ( (     if (i mod j = 0) then (     check := 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (check = 0) then     count := count + 1 ; else skip ; 
     if (count = n) then (     return i ) else skip )  ;     i := i + 1 ) ; 
     return 0 );
  static   operation NthFib( n : int) : int
  pre: true
  post: true
  activity: (     var f : Sequence(int) ; f := Integer.subrange(1,n + 2)->collect(0) ;
     var i : int ;
    f[0+1] := 0 ; 
    f[1+1] := 1 ; 
        i := 2 ; while i <= n do ( (     f[i+1] := f[i - 1+1] + f[i - 2+1] )  ;     i := i + 1 ) ; 
    return f[n+1] 
 );
  static   operation findNthTerm( n : int) : void
  pre: true
  post: true
  activity: (     if (n mod 2 = 0) then (     n := n / 2 ; 
     n := NthPrime(n) ; 
     OclFile["System.out"].println(n) ) else (     n := (n / 2) + 1 ; 
     n := NthFib(n - 1) ; 
     OclFile["System.out"].println(n) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var X : int ; X := 5 ;
     execute findNthTerm(X) ; 
     X := 10 ; 
     execute findNthTerm(X) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int frequency(int a[],int n,int x){
    int count=0 ;
    for(int i=0 ; i<n ; i++)if(a[i]==x)count++;
    return count ;
  }
  public static void main(String[] args){
    int a[]={
      0,5,5,5,4 };
      int x=5 ;
      int n=a.length ;
      System.out.println(frequency(a,n,x));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation frequency( a : Sequence(int), n : int, x : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n do (     if (a[i+1] = x) then     count := count + 1 ; else skip ;  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{0,5,5,5,4} ;
     var x : int ; x := 5 ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(frequency(a, n, x)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static String C[]={
    "dream","dreamer","erase","eraser" };
    static int len[]={
      5,7,5,6 };
      static char[] s ;
      static int ptr ;
      static char[][] c ;
      public static void main(String[] args){
        String S ;
        Scanner sc=new Scanner(System.in);
        S=sc.next();
        s=S.toCharArray();
        c=new char[4][];
        for(int i=0 ; i<4 ; i++){
          c[i]=C[i] .toCharArray();
        }
        ptr=S.length()-1 ;
        while(0<=ptr){
          switch(s[ptr]){
            case 'm' : if(match(0))ptr=ptr-5 ;
            break ;
            case 'e' : if(match(2))ptr=ptr-5 ;
            break ;
            case 'r' : if(match(1)){
              ptr=ptr-7 ;
              break ;
            }
            if(match(3)){
              ptr=ptr-6 ;
              break ;
            }
            default : ptr=-999 ;
          }
        }
        if(ptr==-1){
          System.out.println("YES");
        }
        else {
          System.out.println("NO");
        }
      }
      static boolean match(int i){
        int flag=0 ;
        int ptr2=ptr ;
        for(int k=len[i]-1 ; 0<=k ; k--){
          if(s[ptr2]==c[i][k]){
            ptr2--;
            continue ;
          }
          else {
            flag=-1 ;
            break ;
          }
        }
        if(flag==-1)return false ;
        else return true ;
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute C : String := Sequence{"dream","dreamer","erase","eraser"};
  static   attribute len : int := Sequence{5,7,5,6};
  static   attribute s : Sequence(String);
  static   attribute ptr : int;
  static   attribute c : Sequence(Sequence(String));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S : String ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    S := sc.getCurrent() ; 
    s := S->characters() ; 
    c := Integer.subrange(1,4)->collect(Sequence{}) ; 
        var i : int ; i := 0 ; while i < 4 do ( (     c[i+1] := C[i+1]->characters() )  ;     i := i + 1 ) ; 
    ptr := S->size() - 1 ; 
    while (0 <= ptr) do ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (s[ptr+1]) ; 
       if _switchval = 'm' then
     if (match(0)) then     ptr := ptr - 5 ; else skip ; 
    break 
   else skip ;
       if _switchval = 'e' then
     if (match(2)) then     ptr := ptr - 5 ; else skip ; 
    break 
   else skip ;
       if _switchval = 'r' then
     if (match(1)) then (     ptr := ptr - 7 ; 
     break ) else skip ; 
    if (match(3)) then (     ptr := ptr - 6 ; 
     break ) else skip ; 
   else skip ;
       if true then
     ptr := -999 ; 
   else skip ;
 )
 ) ; 
    if (ptr = -1) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
  static   operation match( i : int) : boolean
  pre: true
  post: true
  activity: (     var flag : int ; flag := 0 ;
     var ptr2 : int ; ptr2 := ptr ;
         var k : int ; k := len[i+1] - 1 ; while 0 <= k do ( (     if (s[ptr2+1] = c[i+1][k+1]) then (     ptr2 := ptr2 - 1 ; 
     continue ) else (     flag := -1 ; 
     break ) )  ;     k := k - 1 ) ; 
     if (flag = -1) then     return false else     return true );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String input=sc.next();
    String[] PARTS={
      "dream","dreamer","erase","eraser" };
      boolean flag=true ;
      boolean able=true ;
      int cnt=0 ;
      while(flag){
        flag=false ;
        if(input.regionMatches(input.length()-5-cnt,PARTS[0],0,5)|| input.regionMatches(input.length()-5-cnt,PARTS[2],0,5)){
          cnt+=5 ;
          flag=true ;
        }
        else {
          if(input.regionMatches(input.length()-6-cnt,PARTS[3],0,6)){
            cnt+=6 ;
            flag=true ;
          }
          else {
            if(input.regionMatches(input.length()-7-cnt,PARTS[1],0,7)){
              cnt+=7 ;
              flag=true ;
            }
          }
        }
        if(input.length()==cnt)able=true ;
        else able=false ;
      }
      if(able){
        System.out.println("YES");
      }
      else {
        System.out.println("NO");
      }
      sc.close();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : String ; input := sc.getCurrent() ;
    var PARTS : Sequence(String) ; PARTS := Sequence{"dream","dreamer","erase","eraser"} ;
    var flag : boolean ; flag := true ;
    var able : boolean ; able := true ;
    var cnt : int ; cnt := 0 ;
    while (flag) do (     flag := false ; 
     if (input.subrange(input->size() - 5 - cnt+1,input->size() - 5 - cnt+5) = PARTS[0+1].subrange(0+1,0+5) or input.subrange(input->size() - 5 - cnt+1,input->size() - 5 - cnt+5) = PARTS[2+1].subrange(0+1,0+5)) then (     cnt := cnt+(5) ; 
     flag := true ) else (     if (input.subrange(input->size() - 6 - cnt+1,input->size() - 6 - cnt+6) = PARTS[3+1].subrange(0+1,0+6)) then (     cnt := cnt+(6) ; 
     flag := true ) else (     if (input.subrange(input->size() - 7 - cnt+1,input->size() - 7 - cnt+7) = PARTS[1+1].subrange(0+1,0+7)) then (     cnt := cnt+(7) ; 
     flag := true ) else skip ) ) ;  
     if (input->size() = cnt) then     able := true ; else     able := false ; ) ; 
    if (able) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String inputText=sc.next();
    char[] p1={
      'm','a','e','r','d' };
      char[] p2={
        'r','e','m','a','e','r','d' };
        char[] p3={
          'e','s','a','r','e' };
          char[] p4={
            'r','e','s','a','r','e' };
            char[] inputArray=inputText.toCharArray();
            int wordIndex=0 ;
            char[] targetArray=null ;
            for(int i=inputArray.length-1 ; i>=0 ; i--){
              if(wordIndex==0){
                if(inputArray[i]=='m'){
                  targetArray=p1 ;
                }
                else if(inputArray[i]=='e'){
                  targetArray=p3 ;
                }
                else if(inputArray[i]=='r'){
                  if(i-2>0){
                    if(inputArray[i-2]=='m'){
                      targetArray=p2 ;
                    }
                    else if(inputArray[i-2]=='s'){
                      targetArray=p4 ;
                    }
                    else {
                      System.out.println("NO");
                      return ;
                    }
                  }
                  else {
                    System.out.println("NO");
                    return ;
                  }
                }
                else {
                  System.out.println("NO");
                  return ;
                }
              }
              else {
                if(targetArray[wordIndex]!=inputArray[i]){
                  System.out.println("NO");
                  return ;
                }
              }
              if(wordIndex<targetArray.length-1){
                wordIndex++;
              }
              else {
                wordIndex=0 ;
                targetArray=null ;
              }
            }
            System.out.println("YES");
          }
        }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inputText : String ; inputText := sc.getCurrent() ;
    var p1 : Sequence(String) ; p1 := Sequence{'m','a','e','r','d'} ;
    var p2 : Sequence(String) ; p2 := Sequence{'r','e','m','a','e','r','d'} ;
    var p3 : Sequence(String) ; p3 := Sequence{'e','s','a','r','e'} ;
    var p4 : Sequence(String) ; p4 := Sequence{'r','e','s','a','r','e'} ;
    var inputArray : Sequence(String) ; inputArray := inputText->characters() ;
    var wordIndex : int ; wordIndex := 0 ;
    var targetArray : Sequence(String) ; targetArray := null ;
        var i : int ; i := inputArray->size() - 1 ; while i >= 0 do ( (     if (wordIndex = 0) then (     if (inputArray[i+1] = 'm') then (     targetArray := p1 ) else     if (inputArray[i+1] = 'e') then (     targetArray := p3 ) else     if (inputArray[i+1] = 'r') then (     if (i - 2 > 0) then (     if (inputArray[i - 2+1] = 'm') then (     targetArray := p2 ) else     if (inputArray[i - 2+1] = 's') then (     targetArray := p4 ) else (     OclFile["System.out"].println("NO") ; 
     return ) ;  ) else (     OclFile["System.out"].println("NO") ; 
     return ) ) else (     OclFile["System.out"].println("NO") ; 
     return ) ;  ;  ) else (     if (targetArray[wordIndex+1] /= inputArray[i+1]) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ) ;  
     if (wordIndex < targetArray->size() - 1) then (     wordIndex := wordIndex + 1 ) else (     wordIndex := 0 ; 
     targetArray := null ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println("YES") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  static String[] checkArr={
    "dreamer","dream","eraser","erase" };
    public static void main(String[] args){
      Scanner scan=new Scanner(System.in);
      String in=scan.next();
      int last=in.length();
      LABEL : while(true){
        if(last==0){
          System.out.println("YES");
          return ;
        }
        for(String com : checkArr){
          int dum=in.lastIndexOf(com,last-1);
          if(dum>=0 && last-dum==com.length()){
            last-=com.length();
            continue LABEL ;
          }
        }
        System.out.println("NO");
        return ;
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute checkArr : Sequence(String) := Sequence{"dreamer","dream","eraser","erase"};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var in : String ; in := scan.getCurrent() ;
     var last : int ; last := in->size() ;
     while (true) do (     if (last = 0) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip ; 
     for (com : checkArr) do ( (     var dum : int ; dum := in.subrange(1,(last)->char2byte() - 1+1)->lastIndexOf(com+"")-1  ;
     if (dum >= 0 & (last)->char2byte() - dum = com->size()) then (     last := last-(com->size()) ; 
     continue ) else skip )  ) ; 
     OclFile["System.out"].println("NO") ; 
     return ) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.*;
class GFG {
  static int lastKDigits(int a[],int n,int k){
    int num=(int)(Math.pow(10,k));
    int mul=a[0] % num ;
    for(int i=1 ; i<n ; i++){
      a[i]=a[i] % num ;
      mul=(a[i]*mul)% num ;
    }
    return mul ;
  }
  public static void main(String args[]){
    int a[]={
      22,31,44,27,37,43 };
      int k=2 ;
      int n=a.length ;
      System.out.println(lastKDigits(a,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation lastKDigits( a : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var num : int ; num := (10->pow(k))->oclAsType(int) ;
     var mul : int ; mul := a[0+1] mod num ;
         var i : int ; i := 1 ; while i < n do ( (     a[i+1] := a[i+1] mod num ; 
     mul := (a[i+1] * mul) mod num )  ;     i := i + 1 ) ; 
     return mul );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{22,31,44,27,37,43} ;
     var k : int ; k := 2 ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(lastKDigits(a, n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int minimumChar(String S1,String S2){
    int n=S1.length();
    int m=S2.length();
    int ans=Integer.MAX_VALUE ;
    for(int i=0 ; i<m-n+1 ; i++){
      int minRemovedChar=0 ;
      for(int j=0 ; j<n ; j++){
        if(S1.charAt(j)!=S2.charAt(i+j)){
          minRemovedChar++;
        }
      }
      ans=Math.min(minRemovedChar,ans);
    }
    return ans ;
  }
  public static void main(String[] args){
    String S1="abc" ;
    String S2="paxzk" ;
    System.out.println(minimumChar(S1,S2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumChar( S1 : String, S2 : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := S1->size() ;
     var m : int ; m := S2->size() ;
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 0 ; while i < m - n + 1 do ( (     var minRemovedChar : int ; minRemovedChar := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (S1->at(j+1) /= S2->at(i + j+1)) then (     minRemovedChar := minRemovedChar + 1 ) else skip )  ;     j := j + 1 ) ; 
     ans := Set{minRemovedChar, ans}->min() )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var S1 : String ; S1 := "abc" ;
     var S2 : String ; S2 := "paxzk" ;
     OclFile["System.out"].println(minimumChar(S1, S2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long k=sc.nextInt();
    long max=Long.MIN_VALUE ;
    for(int i=0 ; i<n ; i++){
      long fi=sc.nextInt();
      long ti=sc.nextInt();
      if(ti>k)max=Math.max(max,fi-(ti-k));
      else max=Math.max(max,fi);
    }
    System.out.print(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : long ; k := sc.getCurrent()->toInteger() ;
    var max : long ; max := "-9223372036854775808"->toLong() ;
        var i : int ; i := 0 ; while i < n do ( (     var fi : long ; fi := sc.getCurrent()->toInteger() ;
     var ti : long ; ti := sc.getCurrent()->toInteger() ;
     if (ti > k) then     max := Set{max, fi - (ti - k)}->max() ; else     max := Set{max, fi}->max() ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class pre5 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int b=obj.nextInt(),g=obj.nextInt(),n=obj.nextInt();
    int ans=0 ;
    for(int i=0 ; i<=n ; i++){
      if((i<=b && n-i<=g))ans++;
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre5 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var b : int ; b := obj.nextInt() ;
    var g : int ; g := obj.nextInt() ;
    var n : int ; n := obj.nextInt() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i <= n do ( (     if ((i <= b & n - i <= g)) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.Math ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n ;
    int timeAllowance ;
    int joy,time ;
    int maxJoy=0,potMaxJoy ;
    n=input.nextInt();
    timeAllowance=input.nextInt();
    for(int i=0 ; i<n ; i++){
      joy=input.nextInt();
      time=input.nextInt();
      if(timeAllowance-time>=0){
        potMaxJoy=joy ;
      }
      else {
        potMaxJoy=joy-(time-timeAllowance);
      }
      if(i==0){
        maxJoy=potMaxJoy ;
      }
      if(potMaxJoy>maxJoy)maxJoy=potMaxJoy ;
    }
    System.out.println(maxJoy);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var timeAllowance : int ;
    var joy : int ;
    var time : int ;
    var maxJoy : int ; maxJoy := 0 ;
    var potMaxJoy : int ;
    n := input.getCurrent()->toInteger() ; 
    timeAllowance := input.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     joy := input.getCurrent()->toInteger() ; 
     time := input.getCurrent()->toInteger() ; 
    if (timeAllowance - time >= 0) then (     potMaxJoy := joy ) else (     potMaxJoy := joy - (time - timeAllowance) ) ;  
    if (i = 0) then (     maxJoy := potMaxJoy ) else skip ; 
    if (potMaxJoy > maxJoy) then     maxJoy := potMaxJoy ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(maxJoy) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.stream.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=in.nextInt();
    }
    int[] copy=Arrays.copyOf(arr,arr.length);
    Arrays.sort(copy);
    int left=0,right=n ;
    long x=(long)n*(long)(n+1)/4 ;
    while(left+1<right){
      int mid=(left+right)/2 ;
      int am=copy[mid];
      int[] s=new int[n+1];
      for(int i=0 ; i<n ; i++){
        s[i+1]=am<=arr[i] ? 1 :-1 ;
      }
      for(int i=1 ; i<n+1 ; i++){
        s[i]+=s[i-1];
      }
      BIT bit=new BIT(2*n+1);
      long sum=0 ;
      for(int i=0 ; i<n+1 ; i++){
        sum+=bit.sum(s[i]+n);
        bit.add(s[i]+n,1);
      }
      if(x<=sum){
        left=mid ;
      }
      else {
        right=mid ;
      }
    }
    System.out.println(copy[left]);
  }
}
class BIT {
  private long[] bit ;
  public BIT(int size){
    bit=new long[size];
  }
  public long sum(int i){
    long s=0 ;
    while(0<i){
      s+=bit[i];
      i-=i &-i ;
    }
    return s ;
  }
  public void add(int i,long x){
    while(i<bit.length){
      bit[i]+=x ;
      i+=i &-i ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var copy : Sequence(int) ; copy := arr.subrange(1,arr->size()) ;
    copy := copy->sort() ; 
    var left : int ; left := 0 ;
    var right : int ; right := n ;
    var x : long ; x := n->oclAsType(long) * (n + 1)->oclAsType(long) / 4 ;
    while (left + 1 < right) do (     var mid : int ; mid := (left + right) / 2 ;
     var am : int ; am := copy[mid+1] ;
    var s : Sequence(int) ; s := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i + 1+1] := if am <= arr[i+1] then 1 else -1 endif )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n + 1 do ( (     s[i+1] := s[i+1]+(s[i - 1+1]) )  ;     i := i + 1 ) ; 
    var bit : BIT ; bit := BIT.newBIT(2 * n + 1) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n + 1 do ( (     sum := sum+(bit.sum(s[i+1] + n)) ; 
     bit->excludes(s[i+1] + n, 1) )  ;     i := i + 1 ) ; 
    if (x <= sum) then (     left := mid ) else (     right := mid ) ;  
 ) ; 
    OclFile["System.out"].println(copy[left+1]) ; 
 );
}
class BIT {
   attribute bit : Sequence(long);
   static operation newBIT( size : int) : BIT
  pre: true
  post: true
  activity:
  ( var self : BIT ;
    self := createBIT();
    self.initialise(size);
    return self );
  operation initialise( size : int) : void
  pre: true  post: true
  activity: (     bit := Integer.subrange(1,size)->collect(0) );
   operation sum( i : int) : long
  pre: true
  post: true
  activity: (     var s : long ; s := 0 ;
     while (0 < i) do (     s := s+(bit[i+1]) ; 
     i := i-(MathLib.bitwiseAnd(i,-i)) ) ; 
     return s );
   operation add( i : int, x : long) : void
  pre: true
  post: true
  activity: (     while (i < bit->size()) do (     bit[i+1] := bit[i+1]+(x) ; 
     i := i+(MathLib.bitwiseAnd(i,-i)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static boolean isNumBalanced(int num){
    num=Math.abs(num);
    String str=num+"" ;
    char[] ch_arr=str.toCharArray();
    HashSet<Character>hs=new HashSet<Character>();
    for(char ch : ch_arr){
      hs.add(ch);
    }
    int str_len=str.length();
    int hs_len=hs.size();
    if(hs_len<=str_len/2 || hs_len==str_len){
      return true ;
    }
    return false ;
  }
  public static void main(String[] args){
    int N=1234567890 ;
    boolean flag=isNumBalanced(N);
    if(flag)System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation isNumBalanced( num : int) : boolean
  pre: true
  post: true
  activity: (     num := if num < 0 then -(num) else num endif ; 
     var str : String ; str := num + "" ;
    var ch_arr : Sequence(String) ; ch_arr := str->characters() ;
    var hs : Set(String) ; hs := Set{} ;
    for (ch : ch_arr) do ( (     hs := hs->including(ch) )  ) ; 
    var str_len : int ; str_len := str->size() ;
    var hs_len : int ; hs_len := hs->size() ;
    if (hs_len <= str_len / 2 or hs_len = str_len) then (     return true ) else skip ; 
    return false 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 1234567890 ;
     var flag : boolean ; flag := isNumBalanced(N) ;
     if (flag) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int T=sc.nextInt();
    int res=-2000000000 ;
    for(int i=0 ; i<n ; ++i){
      int f=sc.nextInt();
      int t=sc.nextInt();
      int cur=f ;
      if(t>T)cur-=(t-T);
      res=Math.max(res,cur);
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
    var res : int ; res := -2000000000 ;
        var i : int ; i := 0 ; while i < n do ( (     var f : int ; f := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var cur : int ; cur := f ;
    if (t > T) then     cur := cur-((t - T)) ; else skip ; 
    res := Set{res, cur}->max() ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String args[]){
    BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    String str="" ;
    try {
      str=bfr.readLine();
      if(str==""){
        System.exit(0);
      }
      int input=Integer.parseInt(str);
      String ai_IS_nekama="ai1333" ;
      for(int i=0 ; i<input/100 ; i++){
        ai_IS_nekama+="3" ;
      }
      System.out.println(ai_IS_nekama);
    }
    catch(IOException e){
      System.exit(0);
    }
    catch(NumberFormatException e){
      System.exit(0);
    }
    catch(NullPointerException e){
      System.exit(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bfr : OclFile ; bfr := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := "" ;
     try (     str := bfr.readLine() ; 
     if (str = "") then ( OclProcess.exit(0) ) else skip ; 
    var input : int ; input := (str)->toInteger() ;
    var ai_IS_nekama : String ; ai_IS_nekama := "ai1333" ;
        var i : int ; i := 0 ; while i < input / 100 do ( (     ai_IS_nekama := ai_IS_nekama+("3") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ai_IS_nekama) ; 
 )   catch (e : IOException) do ( OclProcess.exit(0) )
   catch (e : IncorrectElementException) do ( OclProcess.exit(0) )
  catch (e : NullAccessException) do ( OclProcess.exit(0) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    System.out.println(id(x));
    sc.close();
  }
  private static String id(int x){
    StringBuilder sb=new StringBuilder();
    int n=x/100 ;
    sb.append("ai1333");
    for(int t=0 ; t<n ; t++){
      sb.append("3");
    }
    return sb.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(id(x)) ; 
     skip );
  static   operation id( x : int) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     var n : int ; n := x / 100 ;
    sb := sb + StringLib.newString("ai1333") ; 
        var t : int ; t := 0 ; while t < n do ( (     sb := sb + StringLib.newString("3") )  ;     t := t + 1 ) ; 
    return sb+"" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Objects ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int x=sc.nextInt();
      String id="ai1333" ;
      for(int i=0 ; i<x/100 ; i++){
        id+="3" ;
      }
      System.out.println(id);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var id : String ; id := "ai1333" ;
         var i : int ; i := 0 ; while i < x / 100 do ( (     id := id+("3") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(id) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      String u="ai1333" ;
      int x=sc.nextInt();
      int y=x/100 ;
      if(y>0){
        for(int i=1 ; i<=y ; i++){
          u+=3 ;
        }
      }
      System.out.println(u);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var u : String ; u := "ai1333" ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := x / 100 ;
    if (y > 0) then (         var i : int ; i := 1 ; while i <= y do ( (     u := u+(3) )  ;     i := i + 1 ) ) else skip ; 
    OclFile["System.out"].println(u) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int year=sc.nextInt();
    int number=year/100 ;
    StringBuilder sb=new StringBuilder();
    sb.append("ai1333");
    for(int i=0 ; i<number ; i++){
      sb.append("3");
    }
    System.out.println(new String(sb));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var year : int ; year := sc.getCurrent()->toInteger() ;
    var number : int ; number := year / 100 ;
    var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString("ai1333") ; 
        var i : int ; i := 0 ; while i < number do ( (     sb := sb + StringLib.newString("3") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(StringLib.newString(sb)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static final int N=100005 ;
  static void createHash(HashSet<Integer>hash,int maxElement){
    int prev=0,curr=1 ;
    hash.add(prev);
    hash.add(curr);
    while(curr<=maxElement){
      int temp=curr+prev ;
      hash.add(temp);
      prev=curr ;
      curr=temp ;
    }
  }
  static int longestFibonacciSubsequence(int arr[],int n){
    HashSet<Integer>hash=new HashSet<Integer>();
    createHash(hash,Arrays.stream(arr).max().getAsInt());
    int answer=0 ;
    for(int i=0 ; i<n ; i++){
      if(hash.contains(arr[i])){
        answer++;
      }
    }
    return answer ;
  }
  public static void main(String[] args){
    int arr[]={
      3,4,11,2,9,21 };
      int n=arr.length ;
      System.out.print(longestFibonacciSubsequence(arr,n)+"\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static    attribute N : int := 100005;
  static   operation createHash( hash : Set(int), maxElement : int) : void
  pre: true
  post: true
  activity: (     var prev : int ; prev := 0 ;
    var curr : int ; curr := 1 ;
     hash->excludes(prev) ; 
     hash->excludes(curr) ; 
     while (curr <= maxElement) do (     var temp : int ; temp := curr + prev ;
     hash->excludes(temp) ; 
     prev := curr ; 
     curr := temp ) );
  static   operation longestFibonacciSubsequence( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var hash : Set(int) ; hash := Set{} ;
     execute createHash(hash, stream(arr).max().getAsInt()) ; 
    var answer : int ; answer := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (hash->includes(arr[i+1])) then (     answer := answer + 1 ) else skip )  ;     i := i + 1 ) ; 
    return answer 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{3,4,11,2,9,21} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(longestFibonacciSubsequence(arr, n) + "\n") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class pre5 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int b=obj.nextInt(),g=obj.nextInt(),n=obj.nextInt();
    int ans=0 ;
    for(int i=0 ; i<=n ; i++){
      if((i<=b && n-i<=g))ans++;
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre5 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var b : int ; b := obj.nextInt() ;
    var g : int ; g := obj.nextInt() ;
    var n : int ; n := obj.nextInt() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i <= n do ( (     if ((i <= b & n - i <= g)) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean isPrime(int n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static boolean isThreeDisctFactors(long n){
    int sq=(int)Math.sqrt(n);
    if(1L*sq*sq!=n)return false ;
    return isPrime(sq)? true : false ;
  }
  public static void main(String[] args){
    long num=9 ;
    if(isThreeDisctFactors(num))System.out.println("Yes");
    else System.out.println("No");
    num=15 ;
    if(isThreeDisctFactors(num))System.out.println("Yes");
    else System.out.println("No");
    num=12397923568441L ;
    if(isThreeDisctFactors(num))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation isThreeDisctFactors( n : long) : boolean
  pre: true
  post: true
  activity: (     var sq : int ; sq := (n)->sqrt()->oclAsType(int) ;
     if (1L * sq * sq /= n) then     return false else skip ; 
     return if isPrime(sq) then true else false endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num : long ; num := 9 ;
     if (isThreeDisctFactors(num)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
    num := 15 ; 
    if (isThreeDisctFactors(num)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
    num := 12397923568441L ; 
    if (isThreeDisctFactors(num)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  private void solve()throws IOException {
    int H=nextInt();
    int W=nextInt();
    int h=nextInt();
    int w=nextInt();
    if(H % h==0 && W % w==0){
      out.println("No");
    }
    else {
      out.println("Yes");
      int s=0 ;
      for(int i=0 ; i<H ; i++){
        for(int j=0 ; j<W ; j++){
          int c=1000 ;
          if(i % h==h-1 && j % w==w-1){
            c=-1000*(h*w-1)-1 ;
          }
          s+=c ;
          out.print(c+" ");
        }
        out.println();
      }
      System.err.println(s);
    }
  }
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer st ;
  PrintWriter out=new PrintWriter(System.out);
  String next()throws IOException {
    while(st==null || ! st.hasMoreTokens()){
      st=new StringTokenizer(br.readLine());
    }
    return st.nextToken();
  }
  int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    solve();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var H : int ; H := nextInt() ;
     var W : int ; W := nextInt() ;
    var h : int ; h := nextInt() ;
    var w : int ; w := nextInt() ;
    if (H mod h = 0 & W mod w = 0) then (     out.println("No") ) else (     out.println("Yes") ; 
     var s : int ; s := 0 ;
         var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     var c : int ; c := 1000 ;
     if (i mod h = h - 1 & j mod w = w - 1) then (     c := -1000 * (h * w - 1) - 1 ) else skip ; 
     s := s+(c) ; 
     out.print(c + " ") )  ;     j := j + 1 ) ; 
     out.println() )  ;     i := i + 1 ) ; 
     OclFile["System.err"].println(s) ) ;  
 );
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator;
   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     execute solve() ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    int h=sc.nextInt();
    int w=sc.nextInt();
    if((H % h==0)&&(W % w==0)){
      System.out.println("No");
    }
    else {
      System.out.println("Yes");
      int[][] ans=new int[H][W];
      if(H % h==0){
        for(int i=0 ; i<H ; i++){
          for(int j=0 ; j<W ; j++){
            if(j % w==0){
              ans[i][j]=1000*w-1001 ;
            }
            else {
              ans[i][j]=-1000 ;
            }
          }
        }
      }
      else {
        for(int i=0 ; i<H ; i++){
          for(int j=0 ; j<W ; j++){
            if(i % h==0){
              ans[i][j]=1000*h-1001 ;
            }
            else {
              ans[i][j]=-1000 ;
            }
          }
        }
      }
      for(int i=0 ; i<H ; i++){
        for(int j=0 ; j<W ; j++){
          System.out.print(ans[i][j]);
          if(j<W-1){
            System.out.print(" ");
          }
          else {
            System.out.println();
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    if ((H mod h = 0) & (W mod w = 0)) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println("Yes") ; 
     var ans : Sequence(Sequence(int)) ; ans := Integer.subrange(1,H)->collect(Integer.subrange(1,W)->collect(0)) ;
     if (H mod h = 0) then (         var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (j mod w = 0) then (     ans[i+1][j+1] := 1000 * w - 1001 ) else (     ans[i+1][j+1] := -1000 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     if (i mod h = 0) then (     ans[i+1][j+1] := 1000 * h - 1001 ) else (     ans[i+1][j+1] := -1000 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) ;  
         var i : int ; i := 0 ; while i < H do ( (         var j : int ; j := 0 ; while j < W do ( (     OclFile["System.out"].print(ans[i+1][j+1]) ; 
     if (j < W - 1) then (     OclFile["System.out"].print(" ") ) else (     OclFile["System.out"].println() ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskC solver=new TaskC();
    solver.solve(in,out);
    out.close();
  }
  static class TaskC {
    public void solve(InputReader in,PrintWriter out){
      int H,W,h,w=0 ;
      H=in.nextInt();
      W=in.nextInt();
      h=in.nextInt();
      w=in.nextInt();
      if(H % h==0 && W % w==0){
        out.println("No");
      }
      else {
        out.println("Yes");
        for(int r=1 ; r<=H ; r++){
          for(int c=1 ; c<=W ; c++){
            if(r % h==0 && c % w==0){
              out.print(" "+(-1000*w*h+999));
            }
            else {
              out.print(" "+1000);
            }
          }
          out.println("");
        }
      }
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskC ; solver := TaskC.newTaskC() ;
    solver.solve(in, out) ; 
    skip ; 
 );
  static class TaskC {
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var H : int ;
    var W : int ;
    var h : int ;
    var w : int ; w := 0 ;
     H := in.nextInt() ; 
    W := in.nextInt() ; 
    h := in.nextInt() ; 
    w := in.nextInt() ; 
    if (H mod h = 0 & W mod w = 0) then (     skip ) else (     skip ; 
         var r : int ; r := 1 ; while r <= H do ( (         var c : int ; c := 1 ; while c <= W do ( (     if (r mod h = 0 & c mod w = 0) then (     skip ) else (     skip ) )  ;     c := c + 1 ) ; 
     skip )  ;     r := r + 1 ) ) ;  
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int H=sc.nextInt();
    int W=sc.nextInt();
    long h=sc.nextLong();
    long w=sc.nextLong();
    long x=(-1000)*(h*w-1)-1 ;
    String[] ans=new String[H];
    for(int i=0 ; i<H ; ++i){
      ans[i]="" ;
    }
    long sum=0 ;
    for(int i=1 ; i<=H ; ++i){
      StringBuilder sb=new StringBuilder();
      for(int j=1 ; j<=W ; j++){
        if(i % h==0 && j % w==0){
          sb.append(x);
          sb.append(" ");
          sum+=x ;
        }
        else {
          sb.append(1000);
          sb.append(" ");
          sum+=1000 ;
        }
      }
      sb.deleteCharAt(sb.length()-1);
      ans[i-1]=sb.toString();
    }
    if(sum<=0)System.out.println("No");
    else {
      System.out.println("Yes");
      for(int i=0 ; i<H ; i++){
        System.out.println(ans[i]);
      }
    }
    return ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var H : int ; H := sc.getCurrent()->toInteger() ;
    var W : int ; W := sc.getCurrent()->toInteger() ;
    var h : long ; h := sc.getCurrent()->toLong() ;
    var w : long ; w := sc.getCurrent()->toLong() ;
    var x : long ; x := (-1000) * (h * w - 1) - 1 ;
    var ans : Sequence(String) ; ans := Integer.subrange(1,H)->collect(null) ;
        var i : int ; i := 0 ; while i < H do ( (     ans[i+1] := "" )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 1 ; while i <= H do ( (     var sb : String ; sb := StringLib.newString() ;
         var j : int ; j := 1 ; while j <= W do ( (     if (i mod h = 0 & j mod w = 0) then (     sb := sb + StringLib.newString(x) ; 
     sb := sb + StringLib.newString(" ") ; 
     sum := sum+(x) ) else (     sb := sb + StringLib.newString(1000) ; 
     sb := sb + StringLib.newString(" ") ; 
     sum := sum+(1000) ) )  ;     j := j + 1 ) ; 
     sb := sb->excludingAt(sb->size() - 1+1) ; 
     ans[i - 1+1] := sb+"" )  ;     i := i + 1 ) ; 
    if (sum <= 0) then     OclFile["System.out"].println("No") else (     OclFile["System.out"].println("Yes") ; 
         var i : int ; i := 0 ; while i < H do ( (     OclFile["System.out"].println(ans[i+1]) )  ;     i := i + 1 ) ) ;  
    return 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Div2_306B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),l=in.nextInt(),r=in.nextInt(),x=in.nextInt();
    int[] c=new int[n];
    for(int i=0 ; i<n ; i++)c[i]=in.nextInt();
    pw.println(solve(n,l,r,x,c));
    pw.close();
  }
  static int solve(int n,int l,int r,int x,int[] C){
    int tot=1<<n ;
    int ans=0 ;
    for(int mask=1 ; mask<tot ; mask++){
      if(Integer.bitCount(mask)==1)continue ;
      int min=Integer.MAX_VALUE ;
      int max=Integer.MIN_VALUE ;
      int sum=0 ;
      for(int bit=0 ; bit<n ; bit++){
        if((mask &(1<<bit))!=0){
          min=Math.min(min,C[bit]);
          max=Math.max(max,C[bit]);
          sum+=C[bit];
        }
      }
      if(sum>=l && sum<=r &&(max-min)>=x)ans++;
    }
    return ans ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Div2_306B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var l : int ; l := in.getCurrent()->toInteger() ;
    var r : int ; r := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
    var c : Sequence(int) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     c[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( n : int, l : int, r : int, x : int, C : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var tot : int ; tot := (1*(2->pow(n)))->oclAsType(long) ;
     var ans : int ; ans := 0 ;
         var mask : int ; mask := 1 ; while mask < tot do ( (     if (bitCount(mask) = 1) then     continue else skip ; 
     var min : int ; min := 2147483647 ;
    var max : int ; max := -2147483648 ;
    var sum : int ; sum := 0 ;
        var bit : int ; bit := 0 ; while bit < n do ( (     if ((MathLib.bitwiseAnd(mask,((1*(2->pow(bit)))->oclAsType(long)))) /= 0) then (     min := Set{min, C[bit+1]}->min() ; 
     max := Set{max, C[bit+1]}->max() ; 
     sum := sum+(C[bit+1]) ) else skip )  ;     bit := bit + 1 ) ; 
    if (sum >= l & sum <= r & (max - min) >= x) then     ans := ans + 1 ; else skip ; 
 )  ;     mask := mask + 1 ) ; 
     return ans );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class ProblemSet {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt(),l=sc.nextInt(),r=sc.nextInt(),x=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    int count=0 ;
    for(int mask=0 ; mask<1<<n ; mask++){
      long total=0 ;
      int nP=0 ;
      int max=Integer.MIN_VALUE ;
      int min=Integer.MAX_VALUE ;
      for(int i=0 ; i<n ; i++){
        if((mask &(1<<i))!=0){
          nP++;
          total+=arr[i];
          max=Math.max(max,arr[i]);
          min=Math.min(min,arr[i]);
        }
      }
      if(total>=l && total<=r &&(max-min)>=x && nP>=2){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemSet {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var l : int ; l := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var mask : int ; mask := 0 ; while mask < (1*(2->pow(n)))->oclAsType(long) do ( (     var total : long ; total := 0 ;
     var nP : int ; nP := 0 ;
    var max : int ; max := -2147483648 ;
    var min : int ; min := 2147483647 ;
        var i : int ; i := 0 ; while i < n do ( (     if ((MathLib.bitwiseAnd(mask,((1*(2->pow(i)))->oclAsType(long)))) /= 0) then (     nP := nP + 1 ; 
     total := total+(arr[i+1]) ; 
     max := Set{max, arr[i+1]}->max() ; 
     min := Set{min, arr[i+1]}->min() ) else skip )  ;     i := i + 1 ) ; 
    if (total >= l & total <= r & (max - min) >= x & nP >= 2) then (     count := count + 1 ) else skip ; 
 )  ;     mask := mask + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void DisplayMatrix(int[][] Matrix){
    int dimensi=Matrix.length ;
    for(int i=0 ; i<dimensi ; i++){
      for(int j=0 ; j<dimensi ; j++){
        System.out.print(Matrix[i][j]+" ");
      }
      System.out.println();
    }
  }
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    for(int tc=0 ; tc<n ; tc++){
      int r,c,a,b ;
      r=scan.nextInt();
      c=scan.nextInt();
      a=scan.nextInt();
      b=scan.nextInt();
      int[][] mat=new int[r][c];
      for(int i=0 ; i<r ; i++){
        String tmp=scan.next();
        for(int j=0 ; j<c ; j++){
          if(tmp.charAt(j)=='.'){
            mat[i][j]=0 ;
          }
          else {
            mat[i][j]=1 ;
          }
        }
      }
      int ans=0 ;
      for(int i=0 ; i<r ; i++){
        int j=0 ;
        while(j<c){
          if(mat[i][j]==0){
            if(j<c-1 && mat[i][j+1]==0){
              ans+=Math.min(b,2*a);
              j++;
            }
            else ans+=a ;
          }
          j++;
        }
      }
      System.out.println(ans);
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation DisplayMatrix( Matrix : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var dimensi : int ; dimensi := Matrix->size() ;
         var i : int ; i := 0 ; while i < dimensi do ( (         var j : int ; j := 0 ; while j < dimensi do ( (     OclFile["System.out"].print(Matrix[i+1][j+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < n do ( (     var r : int ;
    var c : int ;
    var a : int ;
    var b : int ;
     r := scan.getCurrent()->toInteger() ; 
    c := scan.getCurrent()->toInteger() ; 
    a := scan.getCurrent()->toInteger() ; 
    b := scan.getCurrent()->toInteger() ; 
    var mat : Sequence(Sequence(int)) ; mat := Integer.subrange(1,r)->collect(Integer.subrange(1,c)->collect(0)) ;
        var i : int ; i := 0 ; while i < r do ( (     var tmp : String ; tmp := scan.getCurrent() ;
         var j : int ; j := 0 ; while j < c do ( (     if (tmp->at(j+1) = '.') then (     mat[i+1][j+1] := 0 ) else (     mat[i+1][j+1] := 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < r do ( (     var j : int ; j := 0 ;
     while (j < c) do (     if (mat[i+1][j+1] = 0) then (     if (j < c - 1 & mat[i+1][j + 1+1] = 0) then (     ans := ans+(Set{b, 2 * a}->min()) ; 
     j := j + 1 ) else     ans := ans+(a) ; ) else skip ; 
     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     tc := tc + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Scanner ;
public class Practice {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int x=sc.nextInt();
      int y=sc.nextInt();
      String[] arr=new String[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.next();
      }
      long sum=0 ;
      for(int i=0 ; i<n ; i++){
        int res=0 ;
        int j=0 ;
        while(j<m){
          while(j<m && arr[i] .charAt(j)=='.'){
            res++;
            j++;
          }
          if(res>=1){
            int a=res/2 ;
            int b=res % 2 ;
            int temp=a*y+b*x ;
            sum+=Math.min(temp,res*x);
          }
          while(j<m && arr[i] .charAt(j)=='*'){
            res=0 ;
            j++;
          }
        }
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var arr : Sequence(String) ; arr := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var res : int ; res := 0 ;
     var j : int ; j := 0 ;
     while (j < m) do (     while (j < m & arr[i+1]->at(j+1) = '.') do (     res := res + 1 ; 
     j := j + 1 ) ; 
     if (res >= 1) then (     var a : int ; a := res / 2 ;
     var b : int ; b := res mod 2 ;
     var temp : int ; temp := a * y + b * x ;
     sum := sum+(Set{temp, res * x}->min()) ) else skip ; 
     while (j < m & arr[i+1]->at(j+1) = '*') do (     res := 0 ; 
     j := j + 1 ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class NewTheatreSquare {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    while(t>0){
      StringTokenizer st=new StringTokenizer(br.readLine());
      int n=Integer.parseInt(st.nextToken());
      int m=Integer.parseInt(st.nextToken());
      int x=Integer.parseInt(st.nextToken());
      int y=Integer.parseInt(st.nextToken());
      int price=0 ;
      for(int i=0 ; i<n ; i++){
        String str=br.readLine();
        for(int j=0 ; j<m ; j++){
          if(str.charAt(j)=='.' && j+1<m && str.charAt(j+1)=='.'){
            price+=Math.min(2*x,y);
            j++;
          }
          else if(str.charAt(j)=='.')price+=x ;
        }
      }
      System.out.println(price);
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewTheatreSquare {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
     while (t > 0) do (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var x : int ; x := (st.next())->toInteger() ;
    var y : int ; y := (st.next())->toInteger() ;
    var price : int ; price := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := br.readLine() ;
         var j : int ; j := 0 ; while j < m do ( (     if (str->at(j+1) = '.' & j + 1 < m & str->at(j + 1+1) = '.') then (     price := price+(Set{2 * x, y}->min()) ; 
     j := j + 1 ) else     if (str->at(j+1) = '.') then     price := price+(x) ; else skip ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(price) ; 
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int len=in.nextInt();
    for(int idx=0 ; idx<len ; idx++){
      int n=in.nextInt();
      int m=in.nextInt();
      int x=in.nextInt();
      int y=in.nextInt();
      boolean[][] g=new boolean[n][m];
      for(int i=0 ; i<n ; i++){
        String s=in.next();
        for(int j=0 ; j<m ; j++){
          if(s.charAt(j)=='.')g[i][j]=true ;
        }
      }
      System.out.println(helper(g,x,y));
    }
    in.close();
  }
  private static String helper(boolean[][] g,int x,int y){
    int sum=0 ;
    boolean chaper=((x*2>y)? true : false);
    for(int i=0 ; i<g.length ; i++){
      for(int j=0 ; j<g[0] .length ; j++){
        if(g[i][j]){
          g[i][j]=false ;
          if(j+1<g[0] .length && g[i][j+1] && chaper){
            g[i][j+1]=false ;
            sum+=y ;
          }
          else {
            sum+=x ;
          }
        }
      }
    }
    return String.valueOf(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var len : int ; len := in.getCurrent()->toInteger() ;
         var idx : int ; idx := 0 ; while idx < len do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var m : int ; m := in.getCurrent()->toInteger() ;
    var x : int ; x := in.getCurrent()->toInteger() ;
    var y : int ; y := in.getCurrent()->toInteger() ;
    var g : Sequence(Sequence(boolean)) ; g := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(false)) ;
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := in.getCurrent() ;
         var j : int ; j := 0 ; while j < m do ( (     if (s->at(j+1) = '.') then     g[i+1][j+1] := true ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(helper(g, x, y)) ; 
 )  ;     idx := idx + 1 ) ; 
     skip );
  static   operation helper( g : Sequence(Sequence(boolean)), x : int, y : int) : String
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     var chaper : boolean ; chaper := (if (x * 2 > y) then true else false endif) ;
         var i : int ; i := 0 ; while i < g->size() do ( (         var j : int ; j := 0 ; while j < g[0+1]->size() do ( (     if (g[i+1][j+1]) then (     g[i+1][j+1] := false ; 
     if (j + 1 < g[0+1]->size() & g[i+1][j + 1+1] & chaper) then (     g[i+1][j + 1+1] := false ; 
     sum := sum+(y) ) else (     sum := sum+(x) ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return ((sum) + "") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
public final class p065 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p065().run());
  }
  public String run(){
    BigInteger n=BigInteger.ONE ;
    BigInteger d=BigInteger.ZERO ;
    for(int i=99 ; i>=0 ; i--){
      BigInteger temp=BigInteger.valueOf(continuedFractionTerm(i)).multiply(n).add(d);
      d=n ;
      n=temp ;
    }
    int sum=0 ;
    while(! n.equals(BigInteger.ZERO)){
      BigInteger[] divrem=n.divideAndRemainder(BigInteger.TEN);
      sum+=divrem[1] .intValue();
      n=divrem[0];
    }
    return Integer.toString(sum);
  }
  private static int continuedFractionTerm(int i){
    if(i==0)return 2 ;
    else if(i % 3==2)return i/3*2+2 ;
    else return 1 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class p065 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p065.newp065().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var n : long ; n := 1 ;
     var d : long ; d := 0 ;
        var i : int ; i := 99 ; while i >= 0 do ( (     var temp : long ; temp := (continuedFractionTerm(i) + "")->toLong().multiply(n)->excludes(d) ;
     d := n ; 
     n := temp )  ;     i := i - 1 ) ; 
    var sum : int ; sum := 0 ;
    while (not(n = 0)) do (     var divrem : Sequence(long) ; divrem := n.divideAndRemainder(10) ;
     sum := sum+(divrem[1+1]->oclAsType(int)) ; 
     n := divrem[0+1] ) ; 
    return ((sum) + "") 
 );
  static   operation continuedFractionTerm( i : int) : int
  pre: true
  post: true
  activity: (     if (i = 0) then     return 2 else     if (i mod 3 = 2) then     return i / 3 * 2 + 2 else     return 1 ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class Badges {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st!=null && st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader scn=new FastReader();
    int b=scn.nextInt();
    int g=scn.nextInt();
    int n=scn.nextInt();
    b=Math.min(n,b);
    g=Math.min(n,g);
    System.out.println(b-(n-g)+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Badges {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st /= null & st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : FastReader ; scn := FastReader.newFastReader() ;
     var b : int ; b := scn.nextInt() ;
    var g : int ; g := scn.nextInt() ;
    var n : int ; n := scn.nextInt() ;
    b := Set{n, b}->min() ; 
    g := Set{n, g}->min() ; 
    OclFile["System.out"].println(b - (n - g) + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.IOException ;
import java.lang.Long ;
public class NewTheatreSquare {
  public static void main(String[] args)throws IOException {
    BufferedReader inp=new BufferedReader(new InputStreamReader(System.in));
    long ans=0 ;
    int t=Integer.parseInt(inp.readLine());
    while(t-->0){
      String values[]=inp.readLine().split(" ");
      int n=Integer.parseInt(values[0]);
      int m=Integer.parseInt(values[1]);
      int x=Integer.parseInt(values[2]);
      int y=Integer.parseInt(values[3]);
      int two=2*x<y ? 2*x : y ;
      for(int i=0 ; i<n ; i++){
        String row=inp.readLine();
        for(int j=0 ; j<m ; j++){
          if(row.charAt(j)=='.'){
            if(j+1<m && row.charAt(j+1)=='.'){
              ans+=two ;
            }
            else {
              ans+=x ;
            }
            j++;
          }
        }
      }
      System.out.println(ans);
      ans=0 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewTheatreSquare {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inp : OclFile ; inp := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var ans : long ; ans := 0 ;
     var t : int ; t := (inp.readLine())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var values : Sequence(String) ; values := inp.readLine()->split(" ") ;
     var n : int ; n := (values[0+1])->toInteger() ;
    var m : int ; m := (values[1+1])->toInteger() ;
    var x : int ; x := (values[2+1])->toInteger() ;
    var y : int ; y := (values[3+1])->toInteger() ;
    var two : int ; two := if 2 * x < y then 2 * x else y endif ;
        var i : int ; i := 0 ; while i < n do ( (     var row : String ; row := inp.readLine() ;
         var j : int ; j := 0 ; while j < m do ( (     if (row->at(j+1) = '.') then (     if (j + 1 < m & row->at(j + 1+1) = '.') then (     ans := ans+(two) ) else (     ans := ans+(x) ) ;  
     j := j + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
    ans := 0 ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class B {
  public static void main(String[] args)throws IOException {
    MyScanner sc=new MyScanner();
    PrintWriter out=new PrintWriter(System.out);
    int N=sc.nextInt();
    if(N/2 % 2==1){
      output(-1,out);
    }
    else {
      int half=N/2 ;
      int l=1,r=half ;
      int first=query(half,out,sc);
      int next=query(2*half,out,sc);
      if(first==next){
        output(half,out);
        return ;
      }
      boolean less=first<next ;
      while(l+1<r){
        int med=(l+r)/2 ;
        first=query(med,out,sc);
        next=query(med+half,out,sc);
        if(first==next){
          output(med,out);
          return ;
        }
        else if(first<next==less){
          r=med ;
        }
        else {
          l=med+1 ;
        }
      }
      output(l,out);
    }
  }
  static int query(int pos,PrintWriter out,MyScanner sc){
    out.println("? "+pos);
    out.flush();
    return sc.nextInt();
  }
  static void output(int pos,PrintWriter out){
    out.println("! "+pos);
    out.flush();
  }
  static class MyScanner {
    private BufferedReader br ;
    private StringTokenizer tokenizer ;
    public MyScanner(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(br.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var N : int ; N := sc.nextInt() ;
     if (N / 2 mod 2 = 1) then (     execute output(-1, out) ) else (     var half : int ; half := N / 2 ;
     var l : int ; l := 1 ;
    var r : int ; r := half ;
    var first : int ; first := query(half, out, sc) ;
    var next : int ; next := query(2 * half, out, sc) ;
    if (first = next) then (     execute output(half, out) ; 
     return ) else skip ; 
    var less : boolean ; less := first < next ;
    while (l + 1 < r) do (     var med : int ; med := (l + r) / 2 ;
     first := query(med, out, sc) ; 
     next := query(med + half, out, sc) ; 
     if (first = next) then (     execute output(med, out) ; 
     return ) else     if (first < next = less) then (     r := med ) else (     l := med + 1 ) ;  ) ; 
    execute output(l, out) ; 
 ) );
  static   operation query( pos : int, out : OclFile, sc : MyScanner) : int
  pre: true
  post: true
  activity: (     skip ; 
     skip ; 
     return sc.nextInt() );
  static   operation output( pos : int, out : OclFile) : void
  pre: true
  post: true
  activity: (     skip ; 
     skip );
  static class MyScanner {
   attribute br : OclFile;
   attribute tokenizer : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class NewSolution {
  static Reader myReader ;
  public static void main(String[] args){
    myReader=new Reader();
    int n=myReader.nextInt();
    int xL=ask(1);
    int xR=ask(1+n/2);
    if(Math.abs((xL-xR)% 2)==1){
      System.out.println("!-1");
      System.out.flush();
      return ;
    }
    if(xL==xR){
      System.out.println("! 1");
      System.out.flush();
      return ;
    }
    boolean less=xL<xR ;
    int l=1,r=1+n/2 ;
    while(l+1<r){
      int mid=(l+r)/2 ;
      int xMid=ask(mid);
      int xRev=ask(mid+n/2);
      if(xMid==xRev){
        System.out.println("! "+mid);
        System.out.flush();
        return ;
      }
      if((xMid<xRev)==less)l=mid ;
      else r=mid ;
    }
  }
  private static int ask(int x){
    System.out.println("? "+x);
    System.out.flush();
    int elem=myReader.nextInt();
    return elem ;
  }
  static class Reader {
    StringTokenizer st ;
    BufferedReader reader ;
    Reader(){
      reader=new BufferedReader(new InputStreamReader(System.in));
    }
    void updateSt(){
      try {
        if(st==null || ! st.hasMoreElements())st=new StringTokenizer(reader.readLine());
      }
      catch(IOException e){
        e.printStackTrace();
      }
    }
    int nextInt(){
      updateSt();
      return Integer.parseInt(st.nextToken());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class NewSolution {
  static   attribute myReader : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     myReader := OclFile() ; 
     var n : int ; n := myReader.getCurrent()->toInteger() ;
    var xL : int ; xL := ask(1) ;
    var xR : int ; xR := ask(1 + n / 2) ;
    if (if (xL - xR) mod 2 < 0 then -((xL - xR) mod 2) else (xL - xR) mod 2 endif = 1) then (     OclFile["System.out"].println("!-1") ; 
     OclFile["System.out"].flush() ; 
     return ) else skip ; 
    if (xL = xR) then (     OclFile["System.out"].println("! 1") ; 
     OclFile["System.out"].flush() ; 
     return ) else skip ; 
    var less : boolean ; less := xL < xR ;
    var l : int ; l := 1 ;
    var r : int ; r := 1 + n / 2 ;
    while (l + 1 < r) do (     var mid : int ; mid := (l + r) / 2 ;
     var xMid : int ; xMid := ask(mid) ;
    var xRev : int ; xRev := ask(mid + n / 2) ;
    if (xMid = xRev) then (     OclFile["System.out"].println("! " + mid) ; 
     OclFile["System.out"].flush() ; 
     return ) else skip ; 
    if ((xMid < xRev) = less) then     l := mid else     r := mid ; ;  
 ) ; 
 );
  static   operation ask( x : int) : int
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("? " + x) ; 
     OclFile["System.out"].flush() ; 
     var elem : int ; elem := myReader.getCurrent()->toInteger() ;
     return elem );
  static class Reader {
   attribute st : OclIterator;
   attribute reader : OclFile;
   static operation newReader() : Reader
  pre: true
  post: true
  activity:
  ( var self : Reader ;
    self := createReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation updateSt() : void
  pre: true
  post: true
  activity: (     try (     if (st = null or not(st.hasNext())) then     st := OclIterator.newOclIterator_String(reader.readLine()) ; else skip )   catch (e : IOException) do (     e.printStackTrace() )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     execute updateSt() ; 
     return (st.next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p039 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p039().run());
  }
  public String run(){
    int maxPerimeter=0 ;
    int maxTriangles=0 ;
    for(int p=1 ; p<=1000 ; p++){
      int triangles=countSolutions(p);
      if(triangles>maxTriangles){
        maxTriangles=triangles ;
        maxPerimeter=p ;
      }
    }
    return Integer.toString(maxPerimeter);
  }
  private static int countSolutions(int p){
    int count=0 ;
    for(int a=1 ; a<=p ; a++){
      for(int b=a ; b<=p ; b++){
        int c=p-a-b ;
        if(b<=c && a*a+b*b==c*c)count++;
      }
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
class p039 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p039.newp039().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var maxPerimeter : int ; maxPerimeter := 0 ;
     var maxTriangles : int ; maxTriangles := 0 ;
         var p : int ; p := 1 ; while p <= 1000 do ( (     var triangles : int ; triangles := countSolutions(p) ;
     if (triangles > maxTriangles) then (     maxTriangles := triangles ; 
     maxPerimeter := p ) else skip )  ;     p := p + 1 ) ; 
     return ((maxPerimeter) + "") );
  static   operation countSolutions( p : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var a : int ; a := 1 ; while a <= p do ( (         var b : int ; b := a ; while b <= p do ( (     var c : int ; c := p - a - b ;
     if (b <= c & a * a + b * b = c * c) then     count := count + 1 ; else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
     return count );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    List<Integer>list=new ArrayList<>();
    for(int i=6 ; i<=N ; i*=6)list.add(i);
    for(int i=9 ; i<=N ; i*=9)list.add(i);
    Collections.sort(list);
    int[] dp=new int[N+1];
    for(int i=1 ; i<dp.length ; i++)dp[i]=i ;
    for(int m : list)for(int i=m ; i<dp.length ; i++)if(dp[i]>dp[i-m]+1)dp[i]=dp[i-m]+1 ;
    System.out.println(dp[N]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 6 ; while i <= N do (     list := list->including(i) ;  ;     i := i*(6) ) ; 
        var i : int ; i := 9 ; while i <= N do (     list := list->including(i) ;  ;     i := i*(9) ) ; 
    list := list->sort() ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i < dp->size() do (     dp[i+1] := i ;  ;     i := i + 1 ) ; 
    for (m : list) do (         var i : int ; i := m ; while i < dp->size() do (     if (dp[i+1] > dp[i - m+1] + 1) then     dp[i+1] := dp[i - m+1] + 1 ; else skip ;  ;     i := i + 1 ) ;  ) ; 
    OclFile["System.out"].println(dp[N+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.nio.charset.StandardCharsets ;
import java.util.*;
public class Main {
  List<Integer>array=new ArrayList<>();
  int[] ans ;
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    ans=new int[N+1];
    array.add(1);
    for(int i=6 ; i<=N ; i*=6){
      array.add(i);
    }
    for(int i=9 ; i<=N ; i*=9){
      array.add(i);
    }
    Collections.sort(array);
    for(int i=0 ; i<=N ; i++){
      ans[i]=100000 ;
    }
    ans[0]=0 ;
    for(int i=1 ; i<=N ; i++){
      for(int j : array){
        if(i<j)break ;
        ans[i]=Math.min(ans[i],ans[i-j]+1);
      }
    }
    System.out.println(ans[N]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute array : Sequence(int) := Sequence{};
   attribute ans : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    ans := Integer.subrange(1,N + 1)->collect(0) ; 
    array := array->including(1) ; 
        var i : int ; i := 6 ; while i <= N do ( (     array := array->including(i) )  ;     i := i*(6) ) ; 
        var i : int ; i := 9 ; while i <= N do ( (     array := array->including(i) )  ;     i := i*(9) ) ; 
    array := array->sort() ; 
        var i : int ; i := 0 ; while i <= N do ( (     ans[i+1] := 100000 )  ;     i := i + 1 ) ; 
    ans[0+1] := 0 ; 
        var i : int ; i := 1 ; while i <= N do ( (     for (j : array) do ( (     if (i < j) then     break else skip ; 
     ans[i+1] := Set{ans[i+1], ans[i - j+1] + 1}->min() )  ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans[N+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  static int ks[]={
    1,6,9,36,81,216,729,1296,6561,7776,46656,59049 };
    static int lm[]={
      0,2,4,4,8,6,9,6,9,6,6,9 };
      static int mem[][]=new int[100001][12];
      public static void main(String[] args)throws IOException {
        BufferedReader r=new BufferedReader(new InputStreamReader(System.in),1);
        int n=Integer.parseInt(r.readLine());
        Arrays.sort(ks);
        int ans=search(n,11);
        System.out.println(ans);
      }
      public static int search(int m,int k){
        if(m<=5){
          return m ;
        }
        if(k<0){
          return 999999 ;
        }
        if(mem[m][k]>0){
          return mem[m][k];
        }
        int z=999999 ;
        int v=m ;
        for(int i=0 ; m>=0 && i<lm[k]; i++){
          z=Math.min(z,i+search(m,k-1));
          m-=ks[k];
        }
        mem[v][k]=z ;
        return z ;
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute ks : int := Sequence{1,6,9,36,81,216,729,1296,6561,7776,46656,59049};
  static   attribute lm : int := Sequence{0,2,4,4,8,6,9,6,9,6,6,9};
  static   attribute mem : int := Integer.subrange(1,100001)->collect(Integer.subrange(1,12)->collect(0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 1) ;
     var n : int ; n := (r.readLine())->toInteger() ;
    ks := ks->sort() ; 
    var ans : int ; ans := search(n, 11) ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation search( m : int, k : int) : int
  pre: true
  post: true
  activity: (     if (m <= 5) then (     return m ) else skip ; 
     if (k < 0) then (     return 999999 ) else skip ; 
    if (mem[m+1][k+1] > 0) then (     return mem[m+1][k+1] ) else skip ; 
    var z : int ; z := 999999 ;
    var v : int ; v := m ;
        var i : int ; i := 0 ; while m >= 0 & i < lm[k+1] do ( (     z := Set{z, i + search(m, k - 1)}->min() ; 
     m := m-(ks[k+1]) )  ;     i := i + 1 ) ; 
    mem[v+1][k+1] := z ; 
    return z 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,i,cnt=1 ;
    n=sc.nextInt();
    System.out.println(sum(n,0,100000));
  }
  public static int sum(int n,int cnt,int min){
    int six=6,nine=9 ;
    int tmp ;
    if(cnt>min){
      return 100000 ;
    }
    if(n<6){
      return cnt+n ;
    }
    while(six<=n){
      six*=6 ;
    }
    six/=6 ;
    tmp=sum(n-six,cnt+1,min);
    if(tmp<min){
      min=tmp ;
    }
    while(nine<=n){
      nine*=9 ;
    }
    nine/=9 ;
    tmp=sum(n-nine,cnt+1,min);
    if(tmp<min){
      min=tmp ;
    }
    return min ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var i : int ;
    var cnt : int ; cnt := 1 ;
     n := sc.getCurrent()->toInteger() ; 
     OclFile["System.out"].println(sum(n, 0, 100000)) );
  static   operation sum( n : int, cnt : int, min : int) : int
  pre: true
  post: true
  activity: (     var six : int ; six := 6 ;
    var nine : int ; nine := 9 ;
     var tmp : int ;
    if (cnt > min) then (     return 100000 ) else skip ; 
    if (n < 6) then (     return cnt + n ) else skip ; 
    while (six <= n) do (     six := six*(6) ) ; 
    six := six/(6) ; 
    tmp := sum(n - six, cnt + 1, min) ; 
    if (tmp < min) then (     min := tmp ) else skip ; 
    while (nine <= n) do (     nine := nine*(9) ) ; 
    nine := nine/(9) ; 
    tmp := sum(n - nine, cnt + 1, min) ; 
    if (tmp < min) then (     min := tmp ) else skip ; 
    return min 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class Main {
  static int dp[];
  static ArrayList<Integer>arr ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    ArrayList<Integer>six=new ArrayList<>(),nine=new ArrayList<>();
    int i=6 ;
    while(i<=100000){
      six.add(i);
      i=i*6 ;
    }
    i=9 ;
    while(i<=100000){
      nine.add(i);
      i=i*9 ;
    }
    arr=new ArrayList<>();
    arr.addAll(six);
    arr.addAll(nine);
    arr.add(1);
    dp=new int[n+1];
    Arrays.fill(dp,(int)1e9);
    System.out.println(r(n));
  }
  static int r(int n){
    dp[0]=0 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=0 ; j<arr.size(); j++){
        if(i-arr.get(j)>=0){
          dp[i]=Math.min(dp[i],dp[i-arr.get(j)]);
        }
      }
      dp[i]++;
    }
    return dp[n];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dp : Sequence(int);
  static   attribute arr : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var six : Sequence(int) ; six := Sequence{} ;
    var nine : Sequence(int) ; nine := Sequence{} ;
    var i : int ; i := 6 ;
    while (i <= 100000) do (     six := six->including(i) ; 
     i := i * 6 ) ; 
    i := 9 ; 
    while (i <= 100000) do (     nine->excludes(i) ; 
     i := i * 9 ) ; 
    arr := Sequence{} ; 
    arr := arr->union(six) ; 
    arr := arr->union(nine) ; 
    arr := arr->including(1) ; 
    dp := Integer.subrange(1,n + 1)->collect(0) ; 
    dp := dp->collect(1e9->oclAsType(int)) ; 
    OclFile["System.out"].println(r(n)) ; 
 );
  static   operation r( n : int) : int
  pre: true
  post: true
  activity: (     dp[0+1] := 0 ; 
         var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 0 ; while j < arr->size() do ( (     if (i - arr->at(j+1) >= 0) then (     dp[i+1] := Set{dp[i+1], dp[i - arr->at(j+1)+1]}->min() ) else skip )  ;     j := j + 1 ) ; 
     dp[i+1] := dp[i+1] + 1 )  ;     i := i + 1 ) ; 
     return dp[n+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t1=sc.nextInt();
    int[] t=new int[n];
    int sum=t1 ;
    t[0]=sc.nextInt();
    for(int i=1 ; i<n ; i++){
      t[i]=sc.nextInt();
      if(t[i]-t[i-1]<=t1){
        sum=t[i]-t[i-1]+sum ;
      }
      else {
        sum=t1+sum ;
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t1 : int ; t1 := sc.getCurrent()->toInteger() ;
    var t : Sequence(int) ; t := Integer.subrange(1,n)->collect(0) ;
    var sum : int ; sum := t1 ;
    t[0+1] := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 1 ; while i < n do ( (     t[i+1] := sc.getCurrent()->toInteger() ; 
     if (t[i+1] - t[i - 1+1] <= t1) then (     sum := t[i+1] - t[i - 1+1] + sum ) else (     sum := t1 + sum ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static String solveEquation(String equation){
    int n=equation.length(),sign=1,coeff=0 ;
    int total=0,i=0 ;
    for(int j=0 ; j<n ; j++){
      if(equation.charAt(j)=='+' || equation.charAt(j)=='-'){
        if(j>i)total+=sign*Integer.parseInt(equation.substring(i,j));
        i=j ;
      }
      else if(equation.charAt(j)=='x'){
        if((i==j)|| equation.charAt(j-1)=='+')coeff+=sign ;
        else if(equation.charAt(j-1)=='-')coeff-=sign ;
        else coeff+=sign*Integer.parseInt(equation.substring(i,j));
        i=j+1 ;
      }
      else if(equation.charAt(j)=='='){
        if(j>i)total+=sign*Integer.parseInt(equation.substring(i,j));
        sign=-1 ;
        i=j+1 ;
      }
    }
    if(i<n)total=total+sign*Integer.parseInt(equation.substring(i));
    if(coeff==0 && total==0)return "Infinite solutions" ;
    if(coeff==0 && total!=0)return "No solution" ;
    int ans=-total/coeff ;
    return(Integer.toString(ans));
  }
  public static void main(String args[]){
    String equation=new String("x+5-3+x=6+x-2");
    System.out.print("x="+solveEquation(equation));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solveEquation( equation : String) : String
  pre: true
  post: true
  activity: (     var n : int ; n := equation->size() ;
    var sign : int ; sign := 1 ;
    var coeff : int ; coeff := 0 ;
     var total : int ; total := 0 ;
    var i : int ; i := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     if (equation->at(j+1) = '+' or equation->at(j+1) = '-') then (     if (j > i) then     total := total+(sign * (equation.subrange(i+1,j))->toInteger()) ; else skip ; 
     i := j ) else     if (equation->at(j+1) = 'x') then (     if ((i = j) or equation->at(j - 1+1) = '+') then     coeff := coeff+(sign) else     if (equation->at(j - 1+1) = '-') then     coeff := coeff-(sign) else     coeff := coeff+(sign * (equation.subrange(i+1,j))->toInteger()) ; ;  ;  
     i := j + 1 ) else     if (equation->at(j+1) = '=') then (     if (j > i) then     total := total+(sign * (equation.subrange(i+1,j))->toInteger()) ; else skip ; 
     sign := -1 ; 
     i := j + 1 ) else skip ; ;  )  ;     j := j + 1 ) ; 
    if (i < n) then     total := total + sign * (equation.subrange(i+1,i))->toInteger() ; else skip ; 
    if (coeff = 0 & total = 0) then     return "Infinite solutions" else skip ; 
    if (coeff = 0 & total /= 0) then     return "No solution" else skip ; 
    var ans : int ; ans := -total / coeff ;
    return (((ans) + "")) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var equation : String ; equation := StringLib.newString("x+5-3+x=6+x-2") ;
     OclFile["System.out"].print("x=" + solveEquation(equation)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Proper898B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int money=in.nextInt();
    int cola=in.nextInt();
    int bars=in.nextInt();
    if(cola>money && bars>money || money % 2!=0 && cola % 2==0 && bars % 2==0 || cola==bars && money % cola!=0){
      System.out.println("NO");
      return ;
    }
    if(money % cola==0){
      System.out.println("YES");
      System.out.println(money/cola+" 0");
      return ;
    }
    if(money % bars==0){
      System.out.println("YES");
      System.out.println("0 "+money/bars);
      return ;
    }
    int i=0 ;
    while(true){
      if((money-i*cola)% bars==0 &&(money-i*cola)>=bars){
        System.out.println("YES");
        System.out.println(i+" "+(money-i*cola)/bars);
        return ;
      }
      if(money-i*cola<0)break ;
      i++;
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Proper898B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var money : int ; money := in.getCurrent()->toInteger() ;
    var cola : int ; cola := in.getCurrent()->toInteger() ;
    var bars : int ; bars := in.getCurrent()->toInteger() ;
    if (cola > money & bars > money or money mod 2 /= 0 & cola mod 2 = 0 & bars mod 2 = 0 or cola = bars & money mod cola /= 0) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip ; 
    if (money mod cola = 0) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(money / cola + " 0") ; 
     return ) else skip ; 
    if (money mod bars = 0) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println("0 " + money / bars) ; 
     return ) else skip ; 
    var i : int ; i := 0 ;
    while (true) do (     if ((money - i * cola) mod bars = 0 & (money - i * cola) >= bars) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(i + " " + (money - i * cola) / bars) ; 
     return ) else skip ; 
     if (money - i * cola < 0) then     break else skip ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    int c,code ;
    Scanner sc=new Scanner(System.in);
    c=sc.nextInt();
    if(c>=65 && c<=90)code=1 ;
    else if(c>=97 && c<=122)code=2 ;
    else code=0 ;
    System.out.println(code);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var c : int ;
    var code : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    c := sc.getCurrent()->toInteger() ; 
    if (c >= 65 & c <= 90) then     code := 1 else     if (c >= 97 & c <= 122) then     code := 2 else     code := 0 ; ;  ;  
    OclFile["System.out"].println(code) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    Scanner sc=new Scanner(systemin);
    int N=sc.nextInt();
    int r=0 ;
    if('A'<=N && N<='Z')r=1 ;
    else if('a'<=N && N<='z')r=2 ;
    result.printf("%d\n",r);
    sc.close();
    return false ;
  }
  PrintStream log ;
  PrintStream result=System.out ;
  BufferedReader systemin ;
  static Main instance=new Main();
  Main(){
    systemin=new BufferedReader(new InputStreamReader(System.in));
    log=new PrintStream(new OutputStream(){
      public void write(int b){
      }
    }
);
  }
  public static void main(String[] args)throws IOException {
    instance.main();
    instance.systemin.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(systemin) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var r : int ; r := 0 ;
    if ('A' <= N & N <= 'Z') then     r := 1 else     if ('a' <= N & N <= 'z') then     r := 2 ; else skip ; ;  
    result.printf("%d\n", r) ; 
    skip ; 
    return false 
 );
   attribute log : OclFile;
   attribute result : OclFile := OclFile["System.out"];
   attribute systemin : OclFile;
  static   attribute instance : Main := Main.newMain();
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     systemin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     log := OclFile.newOclFile_Write(OclFile()) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     instance.main() ; 
     instance.systemin.close() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    FastScanner sc=new FastScanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int input=sc.nextInt();
    int ans=0 ;
    if(input>=65 && input<=90){
      ans=1 ;
    }
    else if(input>=97 && input<=122){
      ans=2 ;
    }
    out.println(ans);
    out.flush();
  }
  static class FastScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public FastScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
      tokenizer=null ;
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          return reader.readLine();
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken("\n");
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastScanner ; sc := FastScanner.newFastScanner(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var input : int ; input := sc.nextInt() ;
    var ans : int ; ans := 0 ;
    if (input >= 65 & input <= 90) then (     ans := 1 ) else     if (input >= 97 & input <= 122) then (     ans := 2 ) else skip ; ;  
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     return reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return tokenizer.nextToken("\n") );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void solve(){
    int N ;
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    if('A'<=N && N<='Z')System.out.println("1");
    else if('a'<=N && N<='z')System.out.println("2");
    else System.out.println("0");
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : int ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
     if ('A' <= N & N <= 'Z') then     OclFile["System.out"].println("1") ; else     if ('a' <= N & N <= 'z') then     OclFile["System.out"].println("2") else     OclFile["System.out"].println("0") ; ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n<='Z' && n>='A'){
      System.out.println(1);
    }
    else if(n<='z' && n>='a'){
      System.out.println(2);
    }
    else {
      System.out.println(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n <= 'Z' & n >= 'A') then (     OclFile["System.out"].println(1) ) else     if (n <= 'z' & n >= 'a') then (     OclFile["System.out"].println(2) ) else (     OclFile["System.out"].println(0) ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B875 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    StringBuilder out=new StringBuilder();
    out.append('1');
    int N=in.nextInt();
    boolean[] outOfCirculation=new boolean[N];
    int outAtTheEnd=0 ;
    for(int n=1 ; n<=N ; n++){
      int a=in.nextInt()-1 ;
      outOfCirculation[a]=true ;
      while(outAtTheEnd<N && outOfCirculation[N-1-outAtTheEnd])outAtTheEnd++;
      int answer=n+1-outAtTheEnd ;
      out.append(' ').append(answer);
    }
    System.out.println(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B875 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : String ; out := StringLib.newString() ;
    out := out + StringLib.newString('1') ; 
    var N : int ; N := in.getCurrent()->toInteger() ;
    var outOfCirculation : Sequence(boolean) ; outOfCirculation := Integer.subrange(1,N)->collect(false) ;
    var outAtTheEnd : int ; outAtTheEnd := 0 ;
        var n : int ; n := 1 ; while n <= N do ( (     var a : int ; a := in.getCurrent()->toInteger() - 1 ;
     outOfCirculation[a+1] := true ; 
    while (outAtTheEnd < N & outOfCirculation[(N)->char2byte() - 1 - outAtTheEnd+1]) do     outAtTheEnd := outAtTheEnd + 1 ; ; 
    var answer : int ; answer := n + 1 - outAtTheEnd ;
    out := out + StringLib.newString(' ') + StringLib.newString(answer) ; 
 )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    sc.close();
    sc=null ;
    int i ;
    int cnt=0 ;
    int max=0 ;
    for(i=0 ; i<s.length(); i++){
      if(s.charAt(i)=='A' || s.charAt(i)=='C' || s.charAt(i)=='G' || s.charAt(i)=='T'){
        cnt++;
      }
      else {
        cnt=0 ;
      }
      max=max(max,cnt);
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    skip ; 
    sc := null ; 
    var i : int ;
    var cnt : int ; cnt := 0 ;
    var max : int ; max := 0 ;
        i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'A' or s->at(i+1) = 'C' or s->at(i+1) = 'G' or s->at(i+1) = 'T') then (     cnt := cnt + 1 ) else (     cnt := 0 ) ;  
     max := Set{max, cnt}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
import java.util.Comparator ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    BATCoder solver=new BATCoder();
    solver.solve(1,in,out);
    out.close();
  }
  static class BATCoder {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      String s=in.next();
      PriorityQueue<Integer>pq=new PriorityQueue<>(Comparator.reverseOrder());
      int cnt=0 ;
      for(int i=0 ; i<s.length(); i++){
        if(s.charAt(i)=='A' || s.charAt(i)=='C' || s.charAt(i)=='G' || s.charAt(i)=='T'){
          cnt++;
        }
        else {
          pq.add(cnt);
          cnt=0 ;
        }
      }
      pq.add(cnt);
      out.println(pq.poll());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : BATCoder ; solver := BATCoder.newBATCoder() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class BATCoder {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var s : String ; s := in.getCurrent() ;
     var pq : Sequence(int) ; pq := Sequence{}->union(Comparator.reverseOrder()) ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'A' or s->at(i+1) = 'C' or s->at(i+1) = 'G' or s->at(i+1) = 'T') then (     cnt := cnt + 1 ) else (     pq := pq->including(cnt) ; 
     cnt := 0 ) )  ;     i := i + 1 ) ; 
    pq := pq->including(cnt) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int ni(){
    return cin.nextInt();
  }
  String nl(){
    return cin.nextLine();
  }
  void println(String str){
    System.out.println(str);
  }
  void print(String str){
    System.out.print(str);
  }
  static final int MOD=1000000007 ;
  Scanner cin=new Scanner(System.in);
  String output ;
  public static void main(String[] args){
    new Main().run();
  }
  public void run(){
    input();
    long res=solve();
    output=res+"" ;
    println(output);
  }
  int N,T ;
  int[] times ;
  void input(){
    N=ni();
    T=ni();
    times=new int[N];
    for(int i=0 ; i<N ; i++){
      times[i]=ni();
    }
  }
  long solve(){
    long sum=T ;
    long preEnd=T ;
    for(int i=1 ; i<N ; i++){
      if(times[i]>=preEnd){
        preEnd=times[i]+T ;
        sum+=T ;
      }
      else {
        long diff=times[i]-times[i-1];
        preEnd+=diff ;
        sum+=diff ;
      }
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation ni() : int
  pre: true
  post: true
  activity: (     return cin.nextInt() );
   operation nl() : String
  pre: true
  post: true
  activity: (     return cin.nextLine() );
   operation println( str : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(str) );
   operation print( str : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(str) );
  static    attribute MOD : int := 1000000007;
   attribute cin : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   attribute output : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     execute input() ; 
     var res : long ; res := solve() ;
     output := res + "" ; 
     execute println(output) );
   attribute N : int;
   attribute times : Sequence(int);
   operation input() : void
  pre: true
  post: true
  activity: (     N := ni() ; 
     T := ni() ; 
     times := Integer.subrange(1,N)->collect(0) ; 
         var i : int ; i := 0 ; while i < N do ( (     times[i+1] := ni() )  ;     i := i + 1 ) );
   operation solve() : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := T ;
     var preEnd : long ; preEnd := T ;
         var i : int ; i := 1 ; while i < N do ( (     if (times[i+1] >= preEnd) then (     preEnd := times[i+1] + T ; 
     sum := sum+(T) ) else (     var diff : long ; diff := times[i+1] - times[i - 1+1] ;
     preEnd := preEnd+(diff) ; 
     sum := sum+(diff) ) )  ;     i := i + 1 ) ; 
     return sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private static int getLongest(String str){
    int maxLength=0 ;
    int length=0 ;
    for(char c : str.toCharArray()){
      switch(c){
        case 'A' : case 'T' : case 'C' : case 'G' : length++;
        maxLength=Math.max(maxLength,length);
        break ;
        default : length=0 ;
      }
    }
    return maxLength ;
  }
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    String in=s.next();
    System.out.println(getLongest(in));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation getLongest( str : String) : int
  pre: true
  post: true
  activity: (     var maxLength : int ; maxLength := 0 ;
     var length : int ; length := 0 ;
     for (c : str->characters()) do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (c) ; 
    if _switchval = 'A' or _switchval = 'T' or _switchval = 'C' or _switchval = 'G' then
    length := length + 1 ; 
    maxLength := Set{maxLength, length}->max() ; 
    break 
   else skip ;
       if true then
     length := 0 ; 
   else skip ;
 )
 )  ) ; 
     return maxLength );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var in : String ; in := s.getCurrent() ;
     OclFile["System.out"].println(getLongest(in)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int count=0 ;
    boolean sw=false ;
    int answer=0 ;
    int max=Integer.MIN_VALUE ;
    int min=Integer.MAX_VALUE ;
    String S="" ;
    int slength=0 ;
    String s="" ;
    Scanner sc=new Scanner(System.in);
    S=sc.next();
    slength=S.length();
    for(int i=0 ; i<slength ; i++){
      s=S.substring(i,i+1);
      if(s.equals("A")|| s.equals("C")|| s.equals("G")|| s.equals("T")){
        count++;
        if(count>max){
          max=count ;
        }
      }
      else {
        if(count>max){
          max=count ;
        }
        count=0 ;
      }
    }
    answer=max ;
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     var sw : boolean ; sw := false ;
    var answer : int ; answer := 0 ;
    var max : int ; max := -2147483648 ;
    var min : int ; min := 2147483647 ;
    var S : String ; S := "" ;
    var slength : int ; slength := 0 ;
    var s : String ; s := "" ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    S := sc.getCurrent() ; 
    slength := S->size() ; 
        var i : int ; i := 0 ; while i < slength do ( (     s := S.subrange(i+1,i + 1) ; 
     if (s = "A" or s = "C" or s = "G" or s = "T") then (     count := count + 1 ; 
     if (count > max) then (     max := count ) else skip ) else (     if (count > max) then (     max := count ) else skip ; 
     count := 0 ) )  ;     i := i + 1 ) ; 
    answer := max ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class pre5 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int n=obj.nextInt(),a=obj.nextInt(),b=obj.nextInt();
    for(int i=0 ; i*b<=n ; i++){
      if((n-i*b)% a==0){
        out.println("YES");
        out.println((n-i*b)/a+" "+i);
        return ;
      }
    }
    out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre5 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var n : int ; n := obj.nextInt() ;
    var a : int ; a := obj.nextInt() ;
    var b : int ; b := obj.nextInt() ;
         var i : int ; i := 0 ; while i * b <= n do ( (     if ((n - i * b) mod a = 0) then (     out.println("YES") ; 
     out.println((n - i * b) / a + " " + i) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     out.println("NO") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static final char a='A' ;
  public static final char c='C' ;
  public static final char g='G' ;
  public static final char t='T' ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String S=scanner.next();
    StringBuilder maxSub=new StringBuilder();
    for(int i=0 ; i<S.length(); i++){
      char SAti=S.charAt(i);
      if(judgeContains(SAti)){
        StringBuilder subS=new StringBuilder();
        subS=subS.append(SAti);
        for(int j=i+1 ; j<S.length(); j++){
          char SAtj=S.charAt(j);
          if(judgeContains(SAtj)){
            subS=subS.append(SAtj);
            continue ;
          }
          break ;
        }
        maxSub=subS.length()>maxSub.length()? subS : maxSub ;
      }
    }
    System.out.print(maxSub.length());
    scanner.close();
  }
  public static boolean judgeContains(char chr){
    if(chr==a || chr==c || chr==g || chr==t){
      return true ;
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute a : String := 'A';
  static    attribute c : String := 'C';
  static    attribute g : String := 'G';
  static    attribute t : String := 'T';
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := scanner.getCurrent() ;
    var maxSub : String ; maxSub := StringLib.newString() ;
        var i : int ; i := 0 ; while i < S->size() do ( (     var SAti : String ; SAti := S->at(i+1) ;
     if (judgeContains(SAti)) then (     var subS : String ; subS := StringLib.newString() ;
     subS := subS + StringLib.newString(SAti) ;     subS := subS + StringLib.newString(SAti) ; 
         var j : int ; j := i + 1 ; while j < S->size() do ( (     var SAtj : String ; SAtj := S->at(j+1) ;
     if (judgeContains(SAtj)) then (     subS := subS + StringLib.newString(SAtj) ;     subS := subS + StringLib.newString(SAtj) ; 
     continue ) else skip ; 
     break )  ;     j := j + 1 ) ; 
     maxSub := if subS->size() > maxSub->size() then subS else maxSub endif ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(maxSub->size()) ; 
    skip ; 
 );
  static   operation judgeContains( chr : String) : boolean
  pre: true
  post: true
  activity: (     if (chr = a or chr = c or chr = g or chr = t) then (     return true ) else skip ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Arrays ;
import java.util.Deque ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] cells=new int[N];
    for(int i=0 ; i<cells.length ; i++){
      cells[i]=sc.nextInt();
    }
    sc.close();
    Deque<Integer>bfs=new ArrayDeque<Integer>();
    bfs.add(0);
    int[] dp=new int[N];
    Arrays.fill(dp,10000000);
    dp[0]=0 ;
    while(! bfs.isEmpty()){
      int poll=bfs.pollFirst();
      if(cells[poll]==0){
        for(int d=1 ; d<=6 ; d++){
          int jump=Math.min(poll+d,N-1);
          if(dp[jump]>dp[poll]+1){
            dp[jump]=dp[poll]+1 ;
            bfs.addLast(jump);
          }
        }
      }
      else {
        int jump=poll+cells[poll];
        if(dp[jump]>dp[poll]){
          dp[jump]=dp[poll];
          bfs.addFirst(jump);
        }
      }
    }
    System.out.println(dp[N-1]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var cells : Sequence(int) ; cells := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < cells->size() do ( (     cells[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var bfs : Sequence(int) ; bfs := ArrayDeque<int>.newArrayDeque() ;
    bfs := bfs->including(0) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,N)->collect(0) ;
    dp := dp->collect(10000000) ; 
    dp[0+1] := 0 ; 
    while (not(bfs->isEmpty())) do (     var poll : int ; poll := bfs->first() ;
     if (cells[poll+1] = 0) then (         var d : int ; d := 1 ; while d <= 6 do ( (     var jump : int ; jump := Set{poll + d, N - 1}->min() ;
     if (dp[jump+1] > dp[poll+1] + 1) then (     dp[jump+1] := dp[poll+1] + 1 ; 
     bfs := bfs->append(jump) ) else skip )  ;     d := d + 1 ) ) else (     var jump : int ; jump := poll + cells[poll+1] ;
     if (dp[jump+1] > dp[poll+1]) then (     dp[jump+1] := dp[poll+1] ; 
     bfs := bfs->prepend(jump) ) else skip ) ) ; 
    OclFile["System.out"].println(dp[N - 1+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.geom.*;
public class Main {
  class State implements Comparable<State>{
    int pos,step ;
    public State(int pos,int step){
      this.pos=pos ;
      this.step=step ;
    }
    @ Override public int compareTo(State o){
      return this.step-o.step ;
    }
  }
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] data=new int[n];
      for(int i=0 ; i<n ; i++){
        data[i]=sc.nextInt();
      }
      PriorityQueue<State>open=new PriorityQueue<Main.State>();
      open.add(new State(0,0));
      int[] close=new int[n];
      int INF=1<<24 ;
      Arrays.fill(close,INF);
      close[0]=0 ;
      int ans=-1 ;
      while(! open.isEmpty()){
        State now=open.poll();
        if(now.pos==n-1){
          ans=now.step ;
          break ;
        }
        for(int i=1 ; i<=6 ; i++){
          int npos=now.pos+i ;
          while(true){
            if(npos<0){
              npos=0 ;
            }
            if(npos>=n){
              npos=n-1 ;
            }
            if(close[npos]<=now.step+1)break ;
            close[npos]=now.step+1 ;
            if(data[npos]==0){
              open.add(new State(npos,now.step+1));
              break ;
            }
            npos+=data[npos];
          }
        }
      }
      System.out.println(ans);
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class State implements Comparable<State> {
   attribute pos : int;
   static operation newState( pos : int, step : int) : State
  pre: true
  post: true
  activity:
  ( var self : State ;
    self := createState();
    self.initialise(pos, step);
    return self );
  operation initialise( pos : int, step : int) : void
  pre: true  post: true
  activity: (     self.pos := pos ; 
     self.step := step );
      operation compareTo( o : State) : int
  pre: true
  post: true
  activity: (     return self.step - o.step );
}
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var data : Sequence(int) ; data := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     data[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var open : Sequence(State) ; open := Sequence{} ;
    open := open->including(State.newState(0, 0)) ; 
    var close : Sequence(int) ; close := Integer.subrange(1,n)->collect(0) ;
    var INF : int ; INF := (1*(2->pow(24)))->oclAsType(long) ;
    close := close->collect(INF) ; 
    close[0+1] := 0 ; 
    var ans : int ; ans := -1 ;
    while (not(open->isEmpty())) do (     var now : State ; now := open->min() ;
     if (now.pos = n - 1) then (     ans := now.step ; 
     break ) else skip ; 
         var i : int ; i := 1 ; while i <= 6 do ( (     var npos : int ; npos := now.pos + i ;
     while (true) do (     if (npos < 0) then (     npos := 0 ) else skip ; 
     if (npos >= n) then (     npos := n - 1 ) else skip ; 
    if (close[npos+1] <= now.step + 1) then     break else skip ; 
    close[npos+1] := now.step + 1 ; 
    if (data[npos+1] = 0) then (     open := open->including(State.newState(npos, now.step + 1)) ; 
     break ) else skip ; 
    npos := npos+(data[npos+1]) ; 
 ) )  ;     i := i + 1 ) ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.Scanner ;
public class Main {
  public static class Walk {
    int pos,time ;
    public Walk(int pos,int time){
      super();
      this.pos=pos ;
      this.time=time ;
    }
  }
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    final int N=sc.nextInt();
    int[] array=new int[N];
    for(int i=0 ; i<N ; i++){
      array[i]=sc.nextInt();
    }
    int[] times=new int[N];
    Arrays.fill(times,Integer.MAX_VALUE);
    LinkedList<Walk>queue=new LinkedList<Walk>();
    queue.add(new Walk(0,0));
    while(! queue.isEmpty()){
      Walk walk=queue.poll();
      if(times[Math.min(N-1,walk.pos)]<=walk.time){
        continue ;
      }
      times[Math.min(N-1,walk.pos)]=walk.time ;
      int next=walk.pos+array[Math.min(N-1,walk.pos)];
      if(next!=walk.pos){
        queue.addFirst(new Walk(next,walk.time));
      }
      else {
        if(walk.pos>=N-1){
          System.out.println(walk.time);
          return ;
        }
        for(int i=6 ; i>=1 ; i--){
          queue.addLast(new Walk(walk.pos+i,walk.time+1));
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Walk {
   attribute pos : int;
   static operation newWalk( pos : int, time : int) : Walk
  pre: true
  post: true
  activity:
  ( var self : Walk ;
    self := createWalk();
    self.initialise(pos, time);
    return self );
  operation initialise( pos : int, time : int) : void
  pre: true  post: true
  activity: (     execute super() ; 
     self.pos := pos ; 
     self.time := time );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     array[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var times : Sequence(int) ; times := Integer.subrange(1,N)->collect(0) ;
    times := times->collect(2147483647) ; 
    var queue : Sequence(Walk) ; queue := Sequence{} ;
    queue := queue->including(Walk.newWalk(0, 0)) ; 
    while (not(queue->isEmpty())) do (     var walk : Walk ; walk := queue->min() ;
     if (times[Set{N - 1, walk.pos}->min()+1] <= walk.time) then (     continue ) else skip ; 
    times[Set{N - 1, walk.pos}->min()+1] := walk.time ; 
    var next : int ; next := walk.pos + array[Set{N - 1, walk.pos}->min()+1] ;
    if (next /= walk.pos) then (     queue := queue->prepend(Walk.newWalk(next, walk.time)) ) else (     if (walk.pos >= N - 1) then (     OclFile["System.out"].println(walk.time) ; 
     return ) else skip ; 
         var i : int ; i := 6 ; while i >= 1 do ( (     queue := queue->append(Walk.newWalk(walk.pos + i, walk.time + 1)) )  ;     i := i - 1 ) ) ;  
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public void run(){
    int n=sc.nextInt();
    calc(n);
  }
  public void calc(int n){
    int[] masu=new int[n];
    for(int i=0 ; i<n ; i++){
      masu[i]=sc.nextInt();
    }
    int[] memo=new int[n];
    Arrays.fill(memo,-1);
    memo[0]=0 ;
    ArrayList<Integer>list=new ArrayList<Integer>();
    list.add(0);
    int ans=-1 ;
    while(list.size()!=0){
      int nowMasu=list.get(0);
      list.remove(0);
      for(int m=1 ; m<7 ; m++){
        int nextMasu=nowMasu+m ;
        if(nextMasu>=n-1){
          ans=memo[nowMasu]+1 ;
          break ;
        }
        if(memo[nextMasu]==-1){
          memo[nextMasu]=memo[nowMasu]+1 ;
          if(masu[nextMasu]==0)list.add(nextMasu);
          while(masu[nextMasu]!=0){
            nextMasu=nextMasu+masu[nextMasu];
            if(nextMasu>=n-1){
              ans=memo[nowMasu]+1 ;
              break ;
            }
            if(memo[nextMasu]==-1){
              memo[nextMasu]=memo[nowMasu]+1 ;
              if(masu[nextMasu]==0)list.add(nextMasu);
            }
            else break ;
          }
        }
        if(ans!=-1)break ;
      }
      if(ans!=-1)break ;
    }
    System.out.println(ans);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     execute calc(n) );
   operation calc( n : int) : void
  pre: true
  post: true
  activity: (     var masu : Sequence(int) ; masu := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     masu[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var memo : Sequence(int) ; memo := Integer.subrange(1,n)->collect(0) ;
    memo := memo->collect(-1) ; 
    memo[0+1] := 0 ; 
    var list : Sequence(int) ; list := Sequence{} ;
    list := list->including(0) ; 
    var ans : int ; ans := -1 ;
    while (list->size() /= 0) do (     var nowMasu : int ; nowMasu := list->at(0+1) ;
     list := list->excludingAt(0+1) ; 
         var m : int ; m := 1 ; while m < 7 do ( (     var nextMasu : int ; nextMasu := nowMasu + m ;
     if (nextMasu >= n - 1) then (     ans := memo[nowMasu+1] + 1 ; 
     break ) else skip ; 
     if (memo[nextMasu+1] = -1) then (     memo[nextMasu+1] := memo[nowMasu+1] + 1 ; 
     if (masu[nextMasu+1] = 0) then     list := list->including(nextMasu) ; else skip ; 
     while (masu[nextMasu+1] /= 0) do (     nextMasu := nextMasu + masu[nextMasu+1] ; 
     if (nextMasu >= n - 1) then (     ans := memo[nowMasu+1] + 1 ; 
     break ) else skip ; 
     if (memo[nextMasu+1] = -1) then (     memo[nextMasu+1] := memo[nowMasu+1] + 1 ; 
     if (masu[nextMasu+1] = 0) then     list := list->including(nextMasu) ; else skip ) else     break ) ) else skip ; 
     if (ans /= -1) then     break else skip )  ;     m := m + 1 ) ; 
     if (ans /= -1) then     break else skip ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    int[] cost=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
    int pos ;
    boolean flag=false ;
    cost[0]=1 ;
    for(int i=1 ; ; i++){
      for(int j=0 ; j<n ; j++){
        if(cost[j]==i && a[j]==0){
          for(int k=1 ; k<=6 ; k++){
            pos=j+k ;
            while(true){
              if(cost[pos]==0)cost[pos]=i+1 ;
              else break ;
              pos+=a[pos];
            }
            if(cost[n-1]>0){
              j=n ;
              flag=true ;
              break ;
            }
          }
        }
      }
      if(flag==true){
        System.out.println(i);
        break ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var cost : Sequence(int) ; cost := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var pos : int ;
    var flag : boolean ; flag := false ;
    cost[0+1] := 1 ; 
        var i : int ; i := 1 ; while true do ( (         var j : int ; j := 0 ; while j < n do ( (     if (cost[j+1] = i & a[j+1] = 0) then (         var k : int ; k := 1 ; while k <= 6 do ( (     pos := j + k ; 
     while (true) do (     if (cost[pos+1] = 0) then     cost[pos+1] := i + 1 else     break ;  
     pos := pos+(a[pos+1]) ) ; 
     if (cost[n - 1+1] > 0) then (     j := n ; 
     flag := true ; 
     break ) else skip )  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) ; 
     if (flag = true) then (     OclFile["System.out"].println(i) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int A=scan.nextInt();
    int B=scan.nextInt();
    int C=scan.nextInt();
    int D=scan.nextInt();
    if(A+B==C+D){
      System.out.println("Balanced");
    }
    else if(A+B>C+D){
      System.out.println("Left");
    }
    else if(A+B<C+D){
      System.out.println("Right");
    }
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := scan.getCurrent()->toInteger() ;
    var B : int ; B := scan.getCurrent()->toInteger() ;
    var C : int ; C := scan.getCurrent()->toInteger() ;
    var D : int ; D := scan.getCurrent()->toInteger() ;
    if (A + B = C + D) then (     OclFile["System.out"].println("Balanced") ) else     if (A + B > C + D) then (     OclFile["System.out"].println("Left") ) else     if (A + B < C + D) then (     OclFile["System.out"].println("Right") ) else skip ; ;  ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
public class GFG {
  static boolean isAlphabaticOrder(String s){
    int n=s.length();
    char c[]=new char[n];
    for(int i=0 ; i<n ; i++){
      c[i]=s.charAt(i);
    }
    Arrays.sort(c);
    for(int i=0 ; i<n ; i++)if(c[i]!=s.charAt(i))return false ;
    return true ;
  }
  public static void main(String args[]){
    String s="aabbbcc" ;
    if(isAlphabaticOrder(s))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isAlphabaticOrder( s : String) : boolean
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var c : Sequence(String) ; c := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1] := s->at(i+1) )  ;     i := i + 1 ) ; 
    c := c->sort() ; 
        var i : int ; i := 0 ; while i < n do (     if (c[i+1] /= s->at(i+1)) then     return false else skip ;  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "aabbbcc" ;
     if (isAlphabaticOrder(s)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args)throws Exception {
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String[] weights=br.readLine().split(" ");
      int leftWeight=Integer.parseInt(weights[0])+Integer.parseInt(weights[1]);
      int rightWeight=Integer.parseInt(weights[2])+Integer.parseInt(weights[3]);
      String result="Right" ;
      if(leftWeight>rightWeight){
        result="Left" ;
      }
      else if(leftWeight==rightWeight){
        result="Balanced" ;
      }
      System.out.println(result);
    }
    catch(IOException | NumberFormatException e){
      e.printStackTrace();
      System.exit(0);
    }
    catch(final Exception e){
      e.printStackTrace();
      System.exit(0);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var weights : Sequence(String) ; weights := br.readLine()->split(" ") ;
    var leftWeight : int ; leftWeight := (weights[0+1])->toInteger() + (weights[1+1])->toInteger() ;
    var rightWeight : int ; rightWeight := (weights[2+1])->toInteger() + (weights[3+1])->toInteger() ;
    var result : String ; result := "Right" ;
    if (leftWeight > rightWeight) then (     result := "Left" ) else     if (leftWeight = rightWeight) then (     result := "Balanced" ) else skip ; ;  
    OclFile["System.out"].println(result) ; 
 )   catch (e : OclException) do (     e.printStackTrace() ; 
 OclProcess.exit(0) )
   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(0) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    List<Integer>list=new ArrayList<Integer>();
    HashMap<Integer,Integer>hm=new HashMap<Integer,Integer>();
    int v1=Integer.parseInt(sc.next());
    int v2=Integer.parseInt(sc.next());
    int v3=Integer.parseInt(sc.next());
    int v4=Integer.parseInt(sc.next());
    String ans_str="" ;
    int ans_int=0 ;
    if(v1+v2>v3+v4){
      ans_str="Left" ;
    }
    else if(v1+v2<v3+v4){
      ans_str="Right" ;
    }
    else {
      ans_str="Balanced" ;
    }
    System.out.println(ans_str);
    System.out.flush();
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
     var hm : Map(int,int) ; hm := Map{} ;
    var v1 : int ; v1 := (sc.getCurrent())->toInteger() ;
    var v2 : int ; v2 := (sc.getCurrent())->toInteger() ;
    var v3 : int ; v3 := (sc.getCurrent())->toInteger() ;
    var v4 : int ; v4 := (sc.getCurrent())->toInteger() ;
    var ans_str : String ; ans_str := "" ;
    var ans_int : int ; ans_int := 0 ;
    if (v1 + v2 > v3 + v4) then (     ans_str := "Left" ) else     if (v1 + v2 < v3 + v4) then (     ans_str := "Right" ) else (     ans_str := "Balanced" ) ;  ;  
    OclFile["System.out"].println(ans_str) ; 
    OclFile["System.out"].flush() ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.util.InputMismatchException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int[] a=in.nextIntArray(4);
      int x=Integer.compare(a[0]+a[1],a[2]+a[3]);
      out.println(x==0 ? "Balanced" : x==1 ? "Left" : "Right");
    }
  }
  static class InputReader {
    BufferedReader br ;
    StringTokenizer st ;
    public InputReader(InputStream inputStream){
      br=new BufferedReader(new InputStreamReader(inputStream));
      st=new StringTokenizer("");
    }
    public String nextString(){
      while(! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine()," ");
        }
        catch(IOException e){
          throw new InputMismatchException();
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(nextString());
    }
    public int[] nextIntArray(int n){
      int[] res=new int[n];
      for(int i=0 ; i<n ; i++){
        res[i]=nextInt();
      }
      return res ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := in.nextIntArray(4) ;
     var x : int ; x := compare(a[0+1] + a[1+1], a[2+1] + a[3+1]) ;
     skip );
}
  static class InputReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newInputReader( inputStream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) ; 
     st := OclIterator.newOclIterator_String("") );
   operation nextString() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String_String(br.readLine(), " ") )   catch (e : IOException) do (     error IncorrectElementException() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextString())->toInteger() );
   operation nextIntArray( n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     res[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return res );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    long n=in.nextLong(),a=in.nextLong(),b=in.nextLong();
    long[] ans=solve(n,a,b);
    if(ans[0]==-1)pw.println("NO");
    else {
      pw.println("YES");
      pw.println(ans[0]+" "+ans[1]);
    }
    pw.close();
  }
  static long[] solve(long n,long a,long b){
    long x=-1,y=-1 ;
    for(long i=0 ; i*a<=n ; i++){
      if(i*a>n)break ;
      else {
        long have=i*a ;
        long rest=n-have ;
        if(rest % b==0){
          x=i ;
          y=rest/b ;
          break ;
        }
      }
    }
    return(new long[] {
      x,y }
);
    }
    static void debug(Object...obj){
      System.err.println(Arrays.deepToString(obj));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := in.getCurrent()->toLong() ;
    var a : long ; a := in.getCurrent()->toLong() ;
    var b : long ; b := in.getCurrent()->toLong() ;
    var ans : Sequence(long) ; ans := solve(n, a, b) ;
    if (ans[0+1] = -1) then     skip else (     skip ; 
     skip ) ;  
    skip ; 
 );
  static   operation solve( n : long, a : long, b : long) : Sequence(long)
  pre: true
  post: true
  activity: (     var x : long ; x := -1 ;
    var y : long ; y := -1 ;
         var i : long ; i := 0 ; while i * a <= n do ( (     if (i * a > n) then     break else (     var have : long ; have := i * a ;
     var rest : long ; rest := n - have ;
     if (rest mod b = 0) then (     x := i ; 
     y := rest / b ; 
     break ) else skip ) )  ;     i := i + 1 ) ; 
     return (Sequence{x,y}) );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a,b,c,d ;
    a=Integer.parseInt(sc.next());
    b=Integer.parseInt(sc.next());
    c=Integer.parseInt(sc.next());
    d=Integer.parseInt(sc.next());
    int left=a+b ;
    int right=c+d ;
    if(left>right){
      System.out.println("Left");
    }
    else if(left<right){
      System.out.println("Right");
    }
    else {
      System.out.println("Balanced");
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ;
    var b : int ;
    var c : int ;
    var d : int ;
    a := (sc.getCurrent())->toInteger() ; 
    b := (sc.getCurrent())->toInteger() ; 
    c := (sc.getCurrent())->toInteger() ; 
    d := (sc.getCurrent())->toInteger() ; 
    var left : int ; left := a + b ;
    var right : int ; right := c + d ;
    if (left > right) then (     OclFile["System.out"].println("Left") ) else     if (left < right) then (     OclFile["System.out"].println("Right") ) else (     OclFile["System.out"].println("Balanced") ) ;  ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int[] mono_bit=new int[a+1];
    int tmp=0 ;
    int[] bits={
      1,2,4 };
      for(int i=0 ; i<3 ; i++){
        int kazu=sc.nextInt();
        for(int j=0 ; j<kazu ; j++){
          tmp=sc.nextInt();
          mono_bit[tmp]+=bits[i];
        }
      }
      int ninzu=0 ;
      for(int i=1 ; i<=a ; i++){
        if(mono_bit[i]==4 || mono_bit[i]==6 || mono_bit[i]==7){
          ninzu++;
        }
      }
      System.out.println(ninzu);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var mono_bit : Sequence(int) ; mono_bit := Integer.subrange(1,a + 1)->collect(0) ;
    var tmp : int ; tmp := 0 ;
    var bits : Sequence(int) ; bits := Sequence{1,2,4} ;
        var i : int ; i := 0 ; while i < 3 do ( (     var kazu : int ; kazu := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < kazu do ( (     tmp := sc.getCurrent()->toInteger() ; 
     mono_bit[tmp+1] := mono_bit[tmp+1]+(bits[i+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ninzu : int ; ninzu := 0 ;
        var i : int ; i := 1 ; while i <= a do ( (     if (mono_bit[i+1] = 4 or mono_bit[i+1] = 6 or mono_bit[i+1] = 7) then (     ninzu := ninzu + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ninzu) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int N=parseInt(br.readLine());
    boolean[] A=new boolean[N];
    boolean[] B=new boolean[N];
    boolean[] C=new boolean[N];
    boolean[][] sets={
      A,B,C };
      for(boolean[] set : sets){
        StringTokenizer st=new StringTokenizer(br.readLine());
        st.nextToken();
        while(st.hasMoreTokens()){
          int i=parseInt(st.nextToken());
          set[i-1]=true ;
        }
      }
      int count=0 ;
      for(int i=0 ; i<N ; i++){
        if((! A[i] && C[i])||(B[i] && C[i]))count++;
      }
      System.out.println(count);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var N : int ; N := parseInt(br.readLine()) ;
    var A : Sequence(boolean) ; A := Integer.subrange(1,N)->collect(false) ;
    var B : Sequence(boolean) ; B := Integer.subrange(1,N)->collect(false) ;
    var C : Sequence(boolean) ; C := Integer.subrange(1,N)->collect(false) ;
    var sets : Sequence(Sequence(boolean)) ; sets := Sequence{A,B,C} ;
    for (set : sets) do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     st.next() ; 
     while (st.hasNext()) do (     var i : int ; i := parseInt(st.next()) ;
     set[i - 1+1] := true ) )  ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if ((not(A[i+1]) & C[i+1]) or (B[i+1] & C[i+1])) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  private static Set<Integer>intersection(Set<Integer>a,Set<Integer>b){
    Set<Integer>response=new HashSet<>();
    for(int x : b){
      if(a.contains(x)){
        response.add(x);
      }
    }
    return response ;
  }
  private static Set<Integer>subtract(Set<Integer>a,Set<Integer>b){
    Set<Integer>response=new HashSet<>();
    for(int x : a){
      if(! b.contains(x)){
        response.add(x);
      }
    }
    return response ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNextInt()){
      int N=sc.nextInt();
      List<Set<Integer>>t=new ArrayList<>();
      for(int i=0 ; i<3 ; i++){
        t.add(new HashSet<>());
        int M=sc.nextInt();
        for(int j=0 ; j<M ; j++){
          t.get(i).add(sc.nextInt());
        }
      }
      Set<Integer>AandBandC=intersection(t.get(0),intersection(t.get(1),t.get(2)));
      Set<Integer>CsubA=subtract(t.get(2),t.get(0));
      AandBandC.addAll(CsubA);
      System.out.println(AandBandC.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation intersection( a : Set(int), b : Set(int)) : Set(int)
  pre: true
  post: true
  activity: (     var response : Set(int) ; response := Set{} ;
     for (x : b) do ( (     if (a->includes(x)) then (     response := response->including(x) ) else skip )  ) ; 
     return response );
  static   operation subtract( a : Set(int), b : Set(int)) : Set(int)
  pre: true
  post: true
  activity: (     var response : Set(int) ; response := Set{} ;
     for (x : a) do ( (     if (not(b->includes(x))) then (     response := response->including(x) ) else skip )  ) ; 
     return response );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNextInt()) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var t : Sequence(Set(int)) ; t := Sequence{} ;
        var i : int ; i := 0 ; while i < 3 do ( (     t := t->including(Set{}) ; 
     var M : int ; M := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < M do ( (     t->at(i+1)->excludes(sc.getCurrent()->toInteger()) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var AandBandC : Set(int) ; AandBandC := intersection(t->at(0+1), intersection(t->at(1+1), t->at(2+1))) ;
    var CsubA : Set(int) ; CsubA := subtract(t->at(2+1), t->at(0+1)) ;
    AandBandC := AandBandC->union(CsubA) ; 
    OclFile["System.out"].println(AandBandC->size()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    boolean belongA[]=new boolean[N+1];
    boolean belongB[]=new boolean[N+1];
    boolean hasC[]=new boolean[N+1];
    int X=sc.nextInt();
    for(int i=0 ; i<X ; ++i){
      int a=sc.nextInt();
      belongA[a]=true ;
    }
    int Y=sc.nextInt();
    for(int i=0 ; i<Y ; ++i){
      int a=sc.nextInt();
      belongB[a]=true ;
    }
    int Z=sc.nextInt();
    for(int i=0 ; i<Z ; ++i){
      int a=sc.nextInt();
      hasC[a]=true ;
    }
    int answer=0 ;
    for(int i=1 ; i<=N ; ++i){
      if((! belongA[i] && hasC[i])||(belongB[i] && hasC[i])){
        answer++;
      }
    }
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var belongA : Sequence(boolean) ; belongA := Integer.subrange(1,N + 1)->collect(false) ;
    var belongB : Sequence(boolean) ; belongB := Integer.subrange(1,N + 1)->collect(false) ;
    var hasC : Sequence(boolean) ; hasC := Integer.subrange(1,N + 1)->collect(false) ;
    var X : int ; X := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < X do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     belongA[a+1] := true )  ;     i := i + 1 ) ; 
    var Y : int ; Y := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < Y do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     belongB[a+1] := true )  ;     i := i + 1 ) ; 
    var Z : int ; Z := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < Z do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     hasC[a+1] := true )  ;     i := i + 1 ) ; 
    var answer : int ; answer := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     if ((not(belongA[i+1]) & hasC[i+1]) or (belongB[i+1] & hasC[i+1])) then (     answer := answer + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] tmpArray=br.readLine().split(" ");
    int n=Integer.parseInt(tmpArray[0]);
    int t=Integer.parseInt(tmpArray[1]);
    int input[]=new int[n];
    tmpArray=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      input[i]=Integer.parseInt(tmpArray[i]);
    }
    if(n==1){
      System.out.println(t);
      return ;
    }
    int start=0 ;
    long total=0 ;
    for(int i=1 ; i<n ; i++){
      if(input[i]-input[i-1]>t){
        total+=input[i-1]+t-input[start];
        start=i ;
      }
      if(i==n-1){
        if(start==n-1){
          total+=t ;
        }
        else {
          total+=input[i]+t-input[start];
        }
      }
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
    var n : int ; n := (tmpArray[0+1])->toInteger() ;
    var t : int ; t := (tmpArray[1+1])->toInteger() ;
    var input : Sequence(int) ; input := Integer.subrange(1,n)->collect(0) ;
    tmpArray := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do ( (     input[i+1] := (tmpArray[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    if (n = 1) then (     OclFile["System.out"].println(t) ; 
     return ) else skip ; 
    var start : int ; start := 0 ;
    var total : long ; total := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (input[i+1] - input[i - 1+1] > t) then (     total := total+(input[i - 1+1] + t - input[start+1]) ; 
     start := i ) else skip ; 
     if (i = n - 1) then (     if (start = n - 1) then (     total := total+(t) ) else (     total := total+(input[i+1] + t - input[start+1]) ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class PracticeProblem {
  public static FastReader in=new FastReader();
  public static PrintWriter out=new PrintWriter(System.out);
  public static void main(String[] args){
    long k=in.nextLong();
    long a=in.nextLong();
    long b=in.nextLong();
    long top=roundDownDiv(b,k);
    long bottom=roundUpDiv(a,k);
    System.out.println(top-bottom+1);
  }
  public static long roundUpDiv(long a,long b){
    if(a % b==0)return a/b ;
    if(a<0)return a/b ;
    return(a/b)+1 ;
  }
  public static long roundDownDiv(long a,long b){
    if(a % b==0)return a/b ;
    if(a>=0)return a/b ;
    return a/b-1 ;
  }
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PracticeProblem {
  static   attribute in : FastReader := FastReader.newFastReader();
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var k : long ; k := in.nextLong() ;
     var a : long ; a := in.nextLong() ;
    var b : long ; b := in.nextLong() ;
    var top : long ; top := roundDownDiv(b, k) ;
    var bottom : long ; bottom := roundUpDiv(a, k) ;
    OclFile["System.out"].println(top - bottom + 1) ; 
 );
  static   operation roundUpDiv( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a mod b = 0) then     return a / b else skip ; 
     if (a < 0) then     return a / b else skip ; 
     return (a / b) + 1 );
  static   operation roundDownDiv( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a mod b = 0) then     return a / b else skip ; 
     if (a >= 0) then     return a / b else skip ; 
     return a / b - 1 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class test {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    long k=in.nextLong(),a=in.nextLong(),b=in.nextLong();
    long ans=0 ;
    if(a==0 && b==0){
      System.out.println(1);
      System.exit(0);
    }
    if(a>0 && b>0){
      ans=pos(b,k)-pos(a-1,k);
    }
    else if(a<0 && b<0){
      ans=pos(Math.abs(a),k)-pos(Math.abs(b)-1,k);
    }
    else {
      ans=pos(b,k)+pos(Math.abs(a),k)+1 ;
    }
    System.out.println(ans);
  }
  public static long pos(long g,long k){
    return g/k ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : long ; k := in.getCurrent()->toLong() ;
    var a : long ; a := in.getCurrent()->toLong() ;
    var b : long ; b := in.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
    if (a = 0 & b = 0) then (     OclFile["System.out"].println(1) ; 
 OclProcess.exit(0) ) else skip ; 
    if (a > 0 & b > 0) then (     ans := pos(b, k) - pos(a - 1, k) ) else     if (a < 0 & b < 0) then (     ans := pos(if a < 0 then -(a) else a endif, k) - pos(if b < 0 then -(b) else b endif - 1, k) ) else (     ans := pos(b, k) + pos(if a < 0 then -(a) else a endif, k) + 1 ) ;  ;  
    OclFile["System.out"].println(ans) ; 
 );
  static   operation pos( g : long, k : long) : long
  pre: true
  post: true
  activity: (     return g / k );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Elevator {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    long k=sc.nextLong();
    long a=sc.nextLong();
    long b=sc.nextLong();
    a=a % k==0 ? a : a>0 ?(a/k)*(k)+k :(a/k)*(k);
    b=b % k==0 ? b : b>0 ?(b/k)*k :(b/k)*(k)-k ;
    out.println((b-a)/k+1);
    out.flush();
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public double nextDouble()throws IOException {
      return Double.parseDouble(next());
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
  static class point implements Comparable<point>{
    int x ;
    int y ;
    public point(int x,int y){
      this.x=x ;
      this.y=y ;
    }
    public int compareTo(point o){
      return(this.y-o.y);
    }
    public String toString(){
      return("("+this.x+" "+this.y+")");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Elevator {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var k : long ; k := sc.getCurrent()->toLong() ;
    var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    a := if a mod k = 0 then a else if a > 0 then (a / k) * (k) + k else (a / k) * (k) endif endif ; 
    b := if b mod k = 0 then b else if b > 0 then (b / k) * k else (b / k) * (k) - k endif endif ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
  static class point implements Comparable<point> {
   attribute x : int;
   attribute y : int;
   static operation newpoint( x : int, y : int) : point
  pre: true
  post: true
  activity:
  ( var self : point ;
    self := createpoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation compareTo( o : point) : int
  pre: true
  post: true
  activity: (     return (self.y - o.y) );
   operation toString() : String
  pre: true
  post: true
  activity: (     return ("(" + self.x + " " + self.y + ")") );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import java.io.*;
public class Hello {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt(),a=in.nextInt(),b=in.nextInt();
    for(int i=0 ; i*a<=n ; i++){
      if((n-(i*a))% b==0){
        System.out.println("YES");
        System.out.println(i+" "+((n-(i*a))/b));
        return ;
      }
    }
    pw.println("NO");
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hello {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i * a <= n do ( (     if ((n - (i * a)) mod b = 0) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(i + " " + ((n - (i * a)) / b)) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minimumDeletions(int a[],int n){
    if(n<=2)return 0 ;
    int count=0 ;
    for(int i=0 ; i<n-2 ; i++){
      if((a[i]<a[i+1] && a[i+1]<a[i+2])||(a[i]>a[i+1] && a[i+1]>a[i+2]))count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int a[]={
      5,2,3,6,1 };
      int n=a.length ;
      System.out.println(minimumDeletions(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minimumDeletions( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     if (n <= 2) then     return 0 else skip ; 
     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i < n - 2 do ( (     if ((a[i+1] < a[i + 1+1] & a[i + 1+1] < a[i + 2+1]) or (a[i+1] > a[i + 1+1] & a[i + 1+1] > a[i + 2+1])) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{5,2,3,6,1} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(minimumDeletions(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class gfg {
  static int square(int n){
    return n*n ;
  }
  static int sum(int n){
    if(n==0)return 0 ;
    if(n % 2==1){
      return square((n+1)/2)+sum(n/2);
    }
    else {
      return square(n/2)+sum(n/2);
    }
  }
  static int oddDivSum(int a,int b){
    return sum(b)-sum(a-1);
  }
  public static void main(String[] args){
    int a=3,b=9 ;
    System.out.println(oddDivSum(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
class gfg {
  static   operation square( n : int) : int
  pre: true
  post: true
  activity: (     return n * n );
  static   operation sum( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 0) then     return 0 else skip ; 
     if (n mod 2 = 1) then (     return square((n + 1) / 2) + sum(n / 2) ) else (     return square(n / 2) + sum(n / 2) ) );
  static   operation oddDivSum( a : int, b : int) : int
  pre: true
  post: true
  activity: (     return sum(b) - sum(a - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 3 ;
    var b : int ; b := 9 ;
     OclFile["System.out"].println(oddDivSum(a, b)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner str=new Scanner(System.in);
    int n=str.nextInt();
    while(n>0){
      int k=str.nextInt();
      int arr[]=new int[k];
      for(int i=0 ; i<k ; i++){
        arr[i]=str.nextInt();
      }
      Arrays.sort(arr);
      for(int i=k-1 ; i>=0 ; i--){
        System.out.print(arr[i]+" ");
      }
      n--;
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : OclFile ; str := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := str.getCurrent()->toInteger() ;
     while (n > 0) do (     var k : int ; k := str.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < k do ( (     arr[i+1] := str.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := k - 1 ; while i >= 0 do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i - 1 ) ; 
    n := n - 1 ; 
    OclFile["System.out"].println() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    for(int i=0 ; i<n ; i++){
      int a=scan.nextInt();
      int[] arr=new int[a];
      for(int j=0 ; j<a ; j++){
        arr[j]=scan.nextInt();
      }
      Arrays.sort(arr);
      for(int j=arr.length-1 ; j>=0 ; j--){
        System.out.print(arr[j]+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scan.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,a)->collect(0) ;
        var j : int ; j := 0 ; while j < a do ( (     arr[j+1] := scan.getCurrent()->toInteger() )  ;     j := j + 1 ) ; 
    arr := arr->sort() ; 
        var j : int ; j := arr->size() - 1 ; while j >= 0 do ( (     OclFile["System.out"].print(arr[j+1] + " ") )  ;     j := j - 1 ) ; 
    OclFile["System.out"].println() ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    while(t-->0){
      int n=in.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      Arrays.sort(a);
      for(int i=n-1 ; i>=0 ; i--){
        System.out.print(a[i]+" ");
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     OclFile["System.out"].print(a[i+1] + " ") )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  Scanner cin ;
  void init()throws Exception {
    cin=new Scanner(new BufferedInputStream(System.in));
    solve();
  }
  void solve(){
    int N=cin.nextInt();
    int T=cin.nextInt();
    cin.nextLine();
    int[] t=Arrays.stream(cin.nextLine().split(" ")).mapToInt(Integer :: parseInt).toArray();
    int cnt=0 ;
    for(int i=1 ; i<N ; i++){
      cnt+=min(t[i]-t[i-1],T);
    }
    cnt+=T ;
    System.out.println(cnt);
  }
  public static void main(String[] args)throws Exception {
    Main M=new Main();
    M.init();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute cin : OclFile;
   operation init() : void
  pre: true
  post: true
  activity: (     cin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     execute solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : int ; N := cin.getCurrent()->toInteger() ;
     var T : int ; T := cin.getCurrent()->toInteger() ;
    skip ; 
    var t : Sequence(int) ; t := stream(cin.nextLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) )->asSequence() ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 1 ; while i < N do ( (     cnt := cnt+(Set{t[i+1] - t[i - 1+1], T}->min()) )  ;     i := i + 1 ) ; 
    cnt := cnt+(T) ; 
    OclFile["System.out"].println(cnt) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var M : Main ; M := Main.newMain() ;
     M.init() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int i,N ;
    int T=Integer.parseInt(br.readLine().trim());
    StringBuilder sb=new StringBuilder();
    while(T-->0){
      N=Integer.parseInt(br.readLine().trim());
      ArrayList<Integer>a=new ArrayList<>();
      String[] s=br.readLine().trim().split(" ");
      for(i=0 ; i<N ; i++)a.add(Integer.parseInt(s[i]));
      a.sort(Collections.reverseOrder());
      for(int x : a)sb.append(x).append(" ");
      sb.append("\n");
    }
    System.out.println(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var i : int ;
    var N : int ;
    var T : int ; T := (br.readLine()->trim())->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     N := (br.readLine()->trim())->toInteger() ; 
     var a : Sequence(int) ; a := Sequence{} ;
    var s : Sequence(String) ; s := br.readLine()->trim()->split(" ") ;
        i := 0 ; while i < N do (     a := a->including((s[i+1])->toInteger()) ;  ;     i := i + 1 ) ; 
    a := a.sort(reverseOrder()) ; 
    for (x : a) do (     sb := sb + StringLib.newString(x) + StringLib.newString(" ") ;  ) ; 
    sb := sb + StringLib.newString("\n") ; 
 ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class GFG {
  static void generateNumbers(int m){
    ArrayList<Integer>numbers=new ArrayList<>();
    int k_max,x ;
    for(int y=0 ; y<10 ; y++){
      k_max=(int)(Math.pow(10,m-2)*(10*y+1))/(int)(Math.pow(10,m-1)+y);
      for(int k=1 ; k<=k_max ; k++){
        x=(int)(y*(Math.pow(10,m-1)-k))/(10*k-1);
        if((int)(y*(Math.pow(10,m-1)-k))%(10*k-1)==0)numbers.add(10*x+y);
      }
    }
    Collections.sort(numbers);
    for(int i=0 ; i<numbers.size(); i++)System.out.println(numbers.get(i));
  }
  public static void main(String args[]){
    int m=3 ;
    generateNumbers(m);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation generateNumbers( m : int) : void
  pre: true
  post: true
  activity: (     var numbers : Sequence(int) ; numbers := Sequence{} ;
     var k_max : int ;
    var x : int ;
        var y : int ; y := 0 ; while y < 10 do ( (     k_max := (10->pow(m - 2) * (10 * y + 1))->oclAsType(int) / (10->pow(m - 1) + y)->oclAsType(int) ; 
         var k : int ; k := 1 ; while k <= k_max do ( (     x := (y * (10->pow(m - 1) - k))->oclAsType(int) / (10 * k - 1) ; 
     if ((y * (10->pow(m - 1) - k))->oclAsType(int) mod (10 * k - 1) = 0) then     numbers := numbers->including(10 * x + y) ; else skip )  ;     k := k + 1 ) )  ;     y := y + 1 ) ; 
    numbers := numbers->sort() ; 
        var i : int ; i := 0 ; while i < numbers->size() do (     OclFile["System.out"].println(numbers->at(i+1)) ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : int ; m := 3 ;
     execute generateNumbers(m) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MainClass {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int c=sc.nextInt();
      int sum=sc.nextInt();
      if(c>sum)System.out.println(Math.min(sum,c));
      else if(sum % c==0){
        System.out.println(c*(int)Math.pow(sum/c,2));
      }
      else System.out.println((c-sum % c)*(sum/c)*(sum/c)+(sum % c)*(sum/c+1)*(sum/c+1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var c : int ; c := sc.getCurrent()->toInteger() ;
     var sum : int ; sum := sc.getCurrent()->toInteger() ;
     if (c > sum) then     OclFile["System.out"].println(Set{sum, c}->min()) ; else     if (sum mod c = 0) then (     OclFile["System.out"].println(c * sum / c->pow(2)->oclAsType(int)) ) else     OclFile["System.out"].println((c - sum mod c) * (sum / c) * (sum / c) + (sum mod c) * (sum / c + 1) * (sum / c + 1)) ; ;  ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class MyClass {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String s[]=br.readLine().split(" ");
    int n=Integer.parseInt(s[0]);
    for(int i=0 ; i<n ; i++){
      s=br.readLine().split(" ");
      long c=Long.parseLong(s[0]);
      long su=Long.parseLong(s[1]);
      long ans=su/c ;
      long rem=su % c ;
      long sum=(ans+1)*(ans+1)*rem ;
      sum+=ans*ans*(c-rem);
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
     var n : int ; n := (s[0+1])->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     s := br.readLine()->split(" ") ; 
     var c : long ; c := (s[0+1])->toLong() ;
    var su : long ; su := (s[1+1])->toLong() ;
    var ans : long ; ans := su / c ;
    var rem : long ; rem := su mod c ;
    var sum : long ; sum := (ans + 1) * (ans + 1) * rem ;
    sum := sum+(ans * ans * (c - rem)) ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import static java.lang.Math.max ;
import static java.lang.Math.min ;
import static java.lang.System.out ;
public class pre127 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int n=obj.nextInt();
    ArrayList<int[]>arr=new ArrayList<>();
    for(int i=0 ; i<n ; i++)arr.add(new int[] { obj.nextInt(),i } );
      Collections.sort(arr,(a,b)->(a[0]-b[0]));
      int min=arr.get(0)[0],ans=Integer.MAX_VALUE ;
      for(int i=1 ; i<n ; i++){
        if(arr.get(i)[0]==min)ans=Math.min(ans,Math.abs(arr.get(i)[1]-arr.get(i-1)[1]));
        else break ;
      }
      out.println(ans);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class pre127 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var n : int ; n := obj.nextInt() ;
    var arr : Sequence(Sequence(int)) ; arr := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     arr := arr->including(Sequence{obj.nextInt(),i}) ;  ;     i := i + 1 ) ; 
    arr, lambda (a , b) : OclAny in (a[0+1] - b[0+1]) := arr, lambda (a , b) : OclAny in (a[0+1] - b[0+1])->sort() ; 
    var min : int ; min := arr->at(0+1)[0+1] ;
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 1 ; while i < n do ( (     if (arr->at(i+1)[0+1] = min) then     ans := Set{ans, if arr->at(i+1)[1+1] - arr->at(i - 1+1)[1+1] < 0 then -(arr->at(i+1)[1+1] - arr->at(i - 1+1)[1+1]) else arr->at(i+1)[1+1] - arr->at(i - 1+1)[1+1] endif}->min() ; else     break )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Samyak {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      long cnt=sc.nextLong();
      long s=sc.nextLong();
      long d=(s/cnt);
      long m=(s % cnt);
      long ans=(cnt-m)*d*d+m*(d+1)*(d+1);
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Samyak {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var cnt : long ; cnt := sc.getCurrent()->toLong() ;
     var s : long ; s := sc.getCurrent()->toLong() ;
    var d : long ; d := (s / cnt) ;
    var m : long ; m := (s mod cnt) ;
    var ans : long ; ans := (cnt - m) * d * d + m * (d + 1) * (d + 1) ;
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String str=sc.next();
    int c1=0 ;
    for(int i=0 ; i<str.length(); i++){
      char c=str.charAt(i);
      char d=s.charAt(c1);
      if(c==d){
        c1++;
      }
    }
    System.out.println(c1+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var str : String ; str := sc.getCurrent() ;
    var c1 : int ; c1 := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     var c : String ; c := str->at(i+1) ;
     var d : String ; d := s->at(c1+1) ;
     if (c = d) then (     c1 := c1 + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(c1 + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF265A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String t=sc.next();
    int count=0 ;
    for(int i=0 ; i<t.length(); i++){
      if(s.charAt(count)==t.charAt(i))count++;
    }
    System.out.println(++count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF265A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var t : String ; t := sc.getCurrent() ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < t->size() do ( (     if (s->at(count+1) = t->at(i+1)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println((count + 1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Stones {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String word=scanner.nextLine();
    String instructions=scanner.nextLine();
    ArrayList<Character>insarray=new ArrayList<>();
    for(int i=0 ; i<instructions.length(); i++){
      insarray.add(instructions.charAt(i));
    }
    int pos=0 ;
    while(insarray.size()>0){
      if(insarray.get(0)==word.charAt(pos)){
        pos++;
      }
      insarray.remove(0);
    }
    System.out.println(pos+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Stones {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var word : String ; word := scanner.nextLine() ;
    var instructions : String ; instructions := scanner.nextLine() ;
    var insarray : Sequence(String) ; insarray := Sequence{} ;
        var i : int ; i := 0 ; while i < instructions->size() do ( (     insarray := insarray->including(instructions->at(i+1)) )  ;     i := i + 1 ) ; 
    var pos : int ; pos := 0 ;
    while (insarray->size() > 0) do (     if (insarray->at(0+1) = word->at(pos+1)) then (     pos := pos + 1 ) else skip ; 
     insarray := insarray->excludingAt(0+1) ) ; 
    OclFile["System.out"].println(pos + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    C solver=new C();
    solver.solve(1,in,out);
    out.close();
  }
  static class C {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int N=Integer.parseInt(in.next());
      long T=Long.parseLong(in.next());
      long t[]=new long[N];
      for(int i=0 ; i<N ; i++){
        t[i]=Long.parseLong(in.next());
      }
      long ans=0 ;
      for(int i=1 ; i<N ; i++){
        if(t[i]-t[i-1]<T)ans+=t[i]-t[i-1];
        else ans+=T ;
      }
      out.println(ans+T);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : C ; solver := C.newC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class C {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := (in.getCurrent())->toInteger() ;
     var T : long ; T := (in.getCurrent())->toLong() ;
    var t : Sequence(long) ; t := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     t[i+1] := (in.getCurrent())->toLong() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i < N do ( (     if (t[i+1] - t[i - 1+1] < T) then     ans := ans+(t[i+1] - t[i - 1+1]) ; else     ans := ans+(T) ; )  ;     i := i + 1 ) ; 
    skip ; 
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class ColorfulStones_SimplifiedEdition {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    String t=sc.nextLine();
    int j=1 ;
    for(int i=0 ; i<t.length(); i++){
      if(s.charAt(j-1)==t.charAt(i)){
        j++;
      }
    }
    System.out.println(j);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ColorfulStones_SimplifiedEdition {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.nextLine() ;
    var t : String ; t := sc.nextLine() ;
    var j : int ; j := 1 ;
        var i : int ; i := 0 ; while i < t->size() do ( (     if (s->at((j)->char2byte() - 1+1) = t->at(i+1)) then (     j := j + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(j) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    char[] stones=in.next().toCharArray();
    char[] instructions=in.next().toCharArray();
    int i=0 ;
    for(int j=0 ; j<instructions.length ; j++){
      if(stones[i]==instructions[j])i++;
    }
    out.println(i+1);
    out.flush();
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new FileReader("sub.in"));
      }
      catch(FileNotFoundException ex){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException ex){
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException ex){
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var stones : Sequence(String) ; stones := in.next()->characters() ;
    var instructions : Sequence(String) ; instructions := in.next()->characters() ;
    var i : int ; i := 0 ;
        var j : int ; j := 0 ; while j < instructions->size() do ( (     if (stones[i+1] = instructions[j+1]) then     i := i + 1 ; else skip )  ;     j := j + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("sub.in"))) )   catch (ex : FileNotFoundException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (ex : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (ex : IOException) do skip
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class C_NoToPalindromes {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str[]=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int p=Integer.parseInt(str[1]);
    String s=br.readLine();
    char[] arr=s.toCharArray();
    for(int i=n-1 ; i>=0 ; i--){
      for(int j=arr[i]-'a' ; j<p ; j++){
        char c=(char)(j+'a');
        if((i-1>=0 && arr[i-1]==c)||(i-2>=0 && arr[i-2]==c)||(arr[i]>=c))continue ;
        arr[i]=c ;
        for(int k=i+1 ; k<n ; k++){
          for(int l=0 ; l<p ; l++){
            char ch=(char)(l+'a');
            if((k-1>=0 && arr[k-1]==ch)|| k-2>=0 && arr[k-2]==ch)continue ;
            arr[k]=ch ;
            break ;
          }
        }
        System.out.println(String.valueOf(arr));
        return ;
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class C_NoToPalindromes {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var p : int ; p := (str[1+1])->toInteger() ;
    var s : String ; s := br.readLine() ;
    var arr : Sequence(String) ; arr := s->characters() ;
        var i : int ; i := (n)->char2byte() - 1 ; while i >= 0 do ( (         var j : int ; j := arr[i+1] - ('a')->char2byte() ; while j < p do ( (     var c : String ; c := (j + 'a')->oclAsType(String) ;
     if ((i - 1 >= 0 & arr[i - 1+1] = c) or (i - 2 >= 0 & arr[i - 2+1] = c) or (arr[i+1] >= c)) then     continue else skip ; 
    arr[i+1] := c ; 
        var k : int ; k := i + 1 ; while k < n do ( (         var l : int ; l := 0 ; while l < p do ( (     var ch : String ; ch := (l + 'a')->oclAsType(String) ;
     if (((k)->char2byte() - 1 >= 0 & arr[(k)->char2byte() - 1+1] = ch) or (k)->char2byte() - 2 >= 0 & arr[(k)->char2byte() - 2+1] = ch) then     continue else skip ; 
     arr[k+1] := ch ; 
     break )  ;     l := l + 1 ) )  ;     k := k + 1 ) ; 
    OclFile["System.out"].println((arr)->sum() ) ; 
    return 
 )  ;     j := j + 1 ) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void printMultiples(int N){
    for(int i=1 ; i<=N ; i++){
      for(int j=1 ; j<=i ; j++){
        System.out.print((i*j)+" ");
      }
      System.out.println();
    }
  }
  public static void main(String args[]){
    int N=5 ;
    printMultiples(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printMultiples( N : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := 1 ; while j <= i do ( (     OclFile["System.out"].print((i * j) + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     execute printMultiples(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int trace(int n,int m){
    int A[][]=new int[n][m];
    int B[][]=new int[n][m];
    int C[][]=new int[n][m];
    int cnt=1 ;
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<m ; j++){
      A[i][j]=cnt ;
      cnt++;
    }
    cnt=1 ;
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<m ; j++){
      B[j][i]=cnt ;
      cnt++;
    }
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<m ; j++)C[i][j]=A[i][j]+B[i][j];
    int sum=0 ;
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<m ; j++)if(i==j)sum+=C[i][j];
    return sum ;
  }
  public static void main(String[] args){
    int N=3,M=3 ;
    System.out.println(trace(N,M));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation trace( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var A : Sequence(Sequence(int)) ; A := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
     var B : Sequence(Sequence(int)) ; B := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var C : Sequence(Sequence(int)) ; C := Integer.subrange(1,n)->collect(Integer.subrange(1,m)->collect(0)) ;
    var cnt : int ; cnt := 1 ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < m do ( (     A[i+1][j+1] := cnt ; 
     cnt := cnt + 1 )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    cnt := 1 ; 
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < m do ( (     B[j+1][i+1] := cnt ; 
     cnt := cnt + 1 )  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < m do (     C[i+1][j+1] := A[i+1][j+1] + B[i+1][j+1] ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < m do (     if (i = j) then     sum := sum+(C[i+1][j+1]) ; else skip ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return sum 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 3 ;
    var M : int ; M := 3 ;
     OclFile["System.out"].println(trace(N, M)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class BerlandMusic {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int test=sc.nextInt();
    while(test-->0){
      int n=sc.nextInt();
      int[] nums=new int[n];
      for(int i=0 ; i<n ; i++){
        nums[i]=sc.nextInt();
      }
      String s=sc.next();
      int[] result=findSequence(nums,s,n);
      for(int num : result){
        System.out.print(num+" ");
      }
      System.out.println();
    }
  }
  private static int[] findSequence(int[] nums,String s,int n){
    int[] result=new int[n];
    PriorityQueue<Integer>minHeap0=new PriorityQueue<>((i,j)->Integer.compare(nums[i],nums[j]));
    PriorityQueue<Integer>minHeap1=new PriorityQueue<>((i,j)->Integer.compare(nums[i],nums[j]));
    for(int i=0 ; i<n ; i++){
      char ch=s.charAt(i);
      if(ch=='0'){
        minHeap0.offer(i);
      }
      else {
        minHeap1.offer(i);
      }
    }
    int k=1 ;
    while(! minHeap0.isEmpty()){
      int index=minHeap0.poll();
      result[index]=k++;
    }
    while(! minHeap1.isEmpty()){
      int index=minHeap1.poll();
      result[index]=k++;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class BerlandMusic {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := sc.getCurrent()->toInteger() ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var nums : Sequence(int) ; nums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     nums[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var s : String ; s := sc.getCurrent() ;
    var result : Sequence(int) ; result := findSequence(nums, s, n) ;
    for (num : result) do ( (     OclFile["System.out"].print(num + " ") )  ) ; 
    OclFile["System.out"].println() ; 
 ) ;  ) );
  static   operation findSequence( nums : Sequence(int), s : String, n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var result : Sequence(int) ; result := Integer.subrange(1,n)->collect(0) ;
     var minHeap0 : Sequence(int) ; minHeap0 := Sequence{}->union(lambda (i , j) : OclAny in compare(nums[i+1], nums[j+1])) ;
    var minHeap1 : Sequence(int) ; minHeap1 := Sequence{}->union(lambda (i , j) : OclAny in compare(nums[i+1], nums[j+1])) ;
        var i : int ; i := 0 ; while i < n do ( (     var ch : String ; ch := s->at(i+1) ;
     if (ch = '0') then (     minHeap0 := minHeap0->including(i) ) else (     minHeap1 := minHeap1->including(i) ) )  ;     i := i + 1 ) ; 
    var k : int ; k := 1 ;
    while (not(minHeap0->isEmpty())) do (     var index : int ; index := minHeap0->min() ;
      result[index+1] := k  ; k := k + 1 ) ; 
    while (not(minHeap1->isEmpty())) do (     var index : int ; index := minHeap1->min() ;
      result[index+1] := k  ; k := k + 1 ) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class A {
  public static void main(String[] st){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    long[] arr=new long[n+1];
    long min=Long.MAX_VALUE ;
    for(int i=1 ; i<n+1 ; i++){
      arr[i]=in.nextLong();
      min=Math.min(arr[i],min);
    }
    int prev=0 ;
    int ans=Integer.MAX_VALUE ;
    for(int i=1 ; i<=n ; i++)if(arr[i]==min){
      prev=i ;
      break ;
    }
    int temp=prev ;
    for(int i=temp+1 ; i<=n ; i++){
      if(arr[i]==min){
        int diff=i-prev ;
        prev=i ;
        if(diff<=ans)ans=diff ;
      }
    }
    pw.println(ans);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( st : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
    var min : long ; min := "9223372036854775807"->toLong() ;
        var i : int ; i := 1 ; while i < n + 1 do ( (     arr[i+1] := in.getCurrent()->toLong() ; 
     min := Set{arr[i+1], min}->min() )  ;     i := i + 1 ) ; 
    var prev : int ; prev := 0 ;
    var ans : int ; ans := 2147483647 ;
        var i : int ; i := 1 ; while i <= n do (     if (arr[i+1] = min) then (     prev := i ; 
     break ) else skip ;  ;     i := i + 1 ) ; 
    var temp : int ; temp := prev ;
        var i : int ; i := temp + 1 ; while i <= n do ( (     if (arr[i+1] = min) then (     var diff : int ; diff := i - prev ;
     prev := i ; 
     if (diff <= ans) then     ans := diff ; else skip ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B1550 {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    while(t-->0){
      int n=scanner.nextInt();
      int a=scanner.nextInt();
      int b=scanner.nextInt();
      String s=scanner.next();
      int ans ;
      if(b>=0){
        ans=(a+b)*n ;
      }
      else {
        s=s.replaceAll("[0] {1,}","0");
        s=s.replaceAll("[1] {1,}","1");
        int count0=0 ;
        int count1=0 ;
        for(int i=0 ; i<s.length(); i++){
          if(s.charAt(i)=='0'){
            count0++;
          }
          else {
            count1++;
          }
        }
        int min=Math.min(count1,count0);
        ans=a*n+b*(min+1);
      }
      System.out.println(ans);
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1550 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var s : String ; s := scanner.getCurrent() ;
    var ans : int ;
    if (b >= 0) then (     ans := (a + b) * n ) else (     s := s.replaceAllMatches("[0] {1,}", "0" ) ; 
     s := s.replaceAllMatches("[1] {1,}", "1" ) ; 
    var count0 : int ; count0 := 0 ;
    var count1 : int ; count1 := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = '0') then (     count0 := count0 + 1 ) else (     count1 := count1 + 1 ) )  ;     i := i + 1 ) ; 
    var min : int ; min := Set{count1, count0}->min() ;
    ans := a * n + b * (min + 1) ; 
 ) ;  
    OclFile["System.out"].println(ans) ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class B1550 {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int t=s.nextInt();
    while(t-->0){
      int n=s.nextInt();
      int a=s.nextInt();
      int b=s.nextInt();
      String str=s.next();
      int c=1 ;
      for(int i=1 ; i<n ; i++)if(str.charAt(i)!=str.charAt(i-1))c++;
      System.out.println(b>=0 ?(a+b)*n : a*n+b*(c/2+1));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1550 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := s.getCurrent()->toInteger() ;
     var a : int ; a := s.getCurrent()->toInteger() ;
    var b : int ; b := s.getCurrent()->toInteger() ;
    var str : String ; str := s.getCurrent() ;
    var c : int ; c := 1 ;
        var i : int ; i := 1 ; while i < n do (     if (str->at(i+1) /= str->at(i - 1+1)) then     c := c + 1 ; else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if b >= 0 then (a + b) * n else a * n + b * (c / 2 + 1) endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.util.Arrays ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner scan=new Scanner(System.in);
    int T=scan.nextInt();
    for(int i=0 ; i<T ; i++){
      int N=scan.nextInt(),A=scan.nextInt(),B=scan.nextInt();
      String S=scan.next();
      int count=1 ;
      for(int j=1 ; j<S.length(); j++){
        if(S.charAt(j)!=S.charAt(j-1)){
          count++;
        }
      }
      if(B>=0){
        System.out.println(A*N+B*N);
      }
      else {
        System.out.println(A*N+(B*((count/2)+1)));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := scan.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < T do ( (     var N : int ; N := scan.getCurrent()->toInteger() ;
    var A : int ; A := scan.getCurrent()->toInteger() ;
    var B : int ; B := scan.getCurrent()->toInteger() ;
     var S : String ; S := scan.getCurrent() ;
    var count : int ; count := 1 ;
        var j : int ; j := 1 ; while j < S->size() do ( (     if (S->at(j+1) /= S->at(j - 1+1)) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
    if (B >= 0) then (     OclFile["System.out"].println(A * N + B * N) ) else (     OclFile["System.out"].println(A * N + (B * ((count / 2) + 1))) ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int __gcd(int a,int b){
    if(b==0){
      return a ;
    }
    else {
      return __gcd(b,a % b);
    }
  }
  static int LCM(int x,int y,int z){
    int ans=((x*y)/(__gcd(x,y)));
    return((z*ans)/(__gcd(ans,z)));
  }
  static int findDivisible(int n,int x,int y,int z){
    int lcm=LCM(x,y,z);
    int ndigitnumber=(int)Math.pow(10,n-1);
    int reminder=ndigitnumber % lcm ;
    if(reminder==0)return ndigitnumber ;
    ndigitnumber+=lcm-reminder ;
    if(ndigitnumber<Math.pow(10,n))return ndigitnumber ;
    else return 0 ;
  }
  static public void main(String[] args){
    int n=4,x=2,y=3,z=5 ;
    int res=findDivisible(n,x,y,z);
    if(res!=0)System.out.println(res);
    else System.out.println("Not possible");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else (     return __gcd(b, a mod b) ) );
  static   operation LCM( x : int, y : int, z : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := ((x * y) / (__gcd(x, y))) ;
     return ((z * ans) / (__gcd(ans, z))) );
  static   operation findDivisible( n : int, x : int, y : int, z : int) : int
  pre: true
  post: true
  activity: (     var lcm : int ; lcm := LCM(x, y, z) ;
     var ndigitnumber : int ; ndigitnumber := 10->pow(n - 1)->oclAsType(int) ;
    var reminder : int ; reminder := ndigitnumber mod lcm ;
    if (reminder = 0) then     return ndigitnumber else skip ; 
    ndigitnumber := ndigitnumber+(lcm - reminder) ; 
    if (ndigitnumber < 10->pow(n)) then     return ndigitnumber else     return 0 ;  
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
    var x : int ; x := 2 ;
    var y : int ; y := 3 ;
    var z : int ; z := 5 ;
     var res : int ; res := findDivisible(n, x, y, z) ;
     if (res /= 0) then     OclFile["System.out"].println(res) ; else     OclFile["System.out"].println("Not possible") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  public static int[] arr=new int[300000];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    sc.nextLine();
    while(t>0){
      int n=sc.nextInt();
      int a=sc.nextInt();
      int b=sc.nextInt();
      sc.nextLine();
      String s=sc.nextLine();
      int l=s.length();
      if(b>=0){
        System.out.println(l*(a+b));
      }
      else {
        char prev=s.charAt(0);
        int count=0 ;
        int ans=a*l ;
        int i=0 ;
        while(i<l){
          if(prev!=s.charAt(i)){
            count++;
          }
          prev=s.charAt(i);
          i++;
        }
        ans=ans+((count+1)/2)*b+b ;
        System.out.println(ans);
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute arr : Sequence(int) := Integer.subrange(1,300000)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     skip ; 
     while (t > 0) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    skip ; 
    var s : String ; s := sc.nextLine() ;
    var l : int ; l := s->size() ;
    if (b >= 0) then (     OclFile["System.out"].println(l * (a + b)) ) else (     var prev : String ; prev := s->at(0+1) ;
     var count : int ; count := 0 ;
    var ans : int ; ans := a * l ;
    var i : int ; i := 0 ;
    while (i < l) do (     if (prev /= s->at(i+1)) then (     count := count + 1 ) else skip ; 
     prev := s->at(i+1) ; 
     i := i + 1 ) ; 
    ans := ans + ((count + 1) / 2) * b + b ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  
    t := t - 1 ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  Map<Integer,Integer>dist ;
  public int networkDelayTime(int[][] times,int N,int K){
    Map<Integer,List<int[]>>graph=new HashMap();
    for(int[] edge : times){
      if(! graph.containsKey(edge[0]))graph.put(edge[0],new ArrayList<int[]>());
      graph.get(edge[0]).add(new int[] {
        edge[1],edge[2] }
);
      }
      dist=new HashMap();
      for(int node=1 ; node<=N ; ++node)dist.put(node,Integer.MAX_VALUE);
      dist.put(K,0);
      boolean[] seen=new boolean[N+1];
      while(true){
        int candNode=-1 ;
        int candDist=Integer.MAX_VALUE ;
        for(int i=1 ; i<=N ; ++i){
          if(! seen[i] && dist.get(i)<candDist){
            candDist=dist.get(i);
            candNode=i ;
          }
        }
        if(candNode<0)break ;
        seen[candNode]=true ;
        if(graph.containsKey(candNode))for(int[] info : graph.get(candNode))dist.put(info[0],Math.min(dist.get(info[0]),dist.get(candNode)+info[1]));
      }
      int ans=0 ;
      for(int cand : dist.values()){
        if(cand==Integer.MAX_VALUE)return-1 ;
        ans=Math.max(ans,cand);
      }
      return ans ;
    }
  }

------------------------------------------------------------
OCL File:
---------
class Solution {
   attribute dist : Map(int,int);
   operation networkDelayTime( times : Sequence(Sequence(int)), N : int, K : int) : int
  pre: true
  post: true
  activity: (     var graph : Map(int,Sequence(Sequence(int))) ; graph := Map{} ;
     for (edge : times) do ( (     if (not(graph->keys()->includes(edge[0+1]))) then     graph := graph->union(Map{edge[0+1] |-> Sequence{}}) ; else skip ; 
     graph->at(edge[0+1])->excludes(Sequence{edge[1+1],edge[2+1]}) )  ) ; 
    dist := Map{} ; 
        var node : int ; node := 1 ; while node <= N do (     dist := dist->union(Map{node |-> 2147483647}) ;  ;     node := node + 1 ) ; 
    dist := dist->union(Map{K |-> 0}) ; 
    var seen : Sequence(boolean) ; seen := Integer.subrange(1,N + 1)->collect(false) ;
    while (true) do (     var candNode : int ; candNode := -1 ;
     var candDist : int ; candDist := 2147483647 ;
        var i : int ; i := 1 ; while i <= N do ( (     if (not(seen[i+1]) & dist->at(i) < candDist) then (     candDist := dist->at(i) ; 
     candNode := i ) else skip )  ;     i := i + 1 ) ; 
    if (candNode < 0) then     break else skip ; 
    seen[candNode+1] := true ; 
    if (graph->keys()->includes(candNode)) then     for (info : graph->at(candNode)) do (     dist := dist->union(Map{info[0+1] |-> Set{dist->at(info[0+1]), dist->at(candNode) + info[1+1]}->min()}) ;  ) ; else skip ; 
 ) ; 
    var ans : int ; ans := 0 ;
    for (cand : dist->values()) do ( (     if (cand = 2147483647) then     return -1 else skip ; 
     ans := Set{ans, cand}->max() )  ) ; 
    return ans 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.ArrayList ;
import java.util.List ;
public final class p172 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p172().run());
  }
  private static final int LENGTH=18 ;
  private static final int MAX_COUNT=3 ;
  private static final int BASE=10 ;
  public String run(){
    BigInteger ways=partitionAndCount(LENGTH,MAX_COUNT,new ArrayList<Integer>());
    BigInteger BASE_BI=BigInteger.valueOf(BASE);
    ways=ways.multiply(BASE_BI.subtract(BigInteger.ONE));
    ways=divideExactly(ways,BASE_BI);
    return ways.toString();
  }
  private BigInteger partitionAndCount(int sum,int max,List<Integer>terms){
    if(terms.size()==BASE){
      if(sum==0)return countWays(terms);
      else return BigInteger.ZERO ;
    }
    else {
      BigInteger result=BigInteger.ZERO ;
      for(int i=Math.min(max,sum); i>=0 ; i--){
        terms.add(i);
        result=result.add(partitionAndCount(sum-i,i,terms));
        terms.remove(terms.size()-1);
      }
      return result ;
    }
  }
  private BigInteger countWays(List<Integer>freqs){
    int[] histogram=new int[MAX_COUNT+1];
    for(int x : freqs)histogram[x]++;
    BigInteger ways=Library.factorial(BASE);
    for(int x : histogram)ways=ways.divide(Library.factorial(x));
    ways=ways.multiply(Library.factorial(LENGTH));
    for(int x : freqs)ways=ways.divide(Library.factorial(x));
    return ways ;
  }
  private static BigInteger divideExactly(BigInteger x,BigInteger y){
    BigInteger[] temp=x.divideAndRemainder(y);
    if(temp[1] .signum()!=0)throw new IllegalArgumentException("Not divisible");
    return temp[0];
  }
}
------------------------------------------------------------
OCL File:
---------
 class p172 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p172.newp172().run()) );
  static    attribute LENGTH : int := 18;
  static    attribute MAX_COUNT : int := 3;
  static    attribute BASE : int := 10;
   operation run() : String
  pre: true
  post: true
  activity: (     var ways : long ; ways := partitionAndCount(LENGTH, MAX_COUNT, Sequence{}) ;
     var BASE_BI : long ; BASE_BI := (BASE + "")->toLong() ;
    ways := ways.multiply(BASE_BI.subtract(1)) ; 
    ways := divideExactly(ways, BASE_BI) ; 
    return ways+"" 
 );
   operation partitionAndCount( sum : int, max : int, terms : Sequence(int)) : long
  pre: true
  post: true
  activity: (     if (terms->size() = BASE) then (     if (sum = 0) then     return countWays(terms) else     return 0 ) else (     var result : long ; result := 0 ;
         var i : int ; i := Set{max, sum}->min() ; while i >= 0 do ( (     terms->excludes(i) ; 
     result := result->excludes(partitionAndCount(sum - i, i, terms)) ; 
     terms := terms->excludingFirst(terms->size() - 1) )  ;     i := i - 1 ) ; 
     return result ) );
   operation countWays( freqs : Sequence(int)) : long
  pre: true
  post: true
  activity: (     var histogram : Sequence(int) ; histogram := Integer.subrange(1,MAX_COUNT + 1)->collect(0) ;
     for (x : freqs) do (     histogram[x+1] := histogram[x+1] + 1 ;  ) ; 
    var ways : long ; ways := Library.factorial(BASE) ;
    for (x : histogram) do (     ways := ways.divide(Library.factorial(x)) ;  ) ; 
    ways := ways.multiply(Library.factorial(LENGTH)) ; 
    for (x : freqs) do (     ways := ways.divide(Library.factorial(x)) ;  ) ; 
    return ways 
 );
  static   operation divideExactly( x : long, y : long) : long
  pre: true
  post: true
  activity: (     var temp : Sequence(long) ; temp := x.divideAndRemainder(y) ;
     if (temp[1+1].signum() /= 0) then     error IllegalArgumentException.newIllegalArgumentException("Not divisible") ; else skip ; 
     return temp[0+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Node {
  static void sortWithSetbits(int arr[],int n,int k){
    Vector<Integer>v1=new Vector<>(),v2=new Vector<>();
    for(int i=0 ; i<n ; i++){
      if(Integer.bitCount(arr[i])==k){
        v1.add(i);
        v2.add(arr[i]);
      }
    }
    Collections.sort(v2);
    for(int i=0 ; i<v1.size(); i++){
      arr[v1.get(i)]=v2.get(i);
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(arr[i]+" ");
    }
  }
  public static void main(String[] args){
    int arr[]={
      14,255,1,7,13 };
      int n=arr.length ;
      int k=3 ;
      sortWithSetbits(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Node {
  static   operation sortWithSetbits( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var v1 : Sequence(int) ; v1 := Sequence{} ;
    var v2 : Sequence(int) ; v2 := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (bitCount(arr[i+1]) = k) then (     v1 := v1->including(i) ; 
     v2->excludes(arr[i+1]) ) else skip )  ;     i := i + 1 ) ; 
    v2 := v2->sort() ; 
        var i : int ; i := 0 ; while i < v1->size() do ( (     arr[v1->at(i+1)+1] := v2->at(i+1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{14,255,1,7,13} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 3 ;
     execute sortWithSetbits(arr, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean canConvert(int a,int b){
    while(b>a){
      if(b % 10==1){
        b/=10 ;
        continue ;
      }
      if(b % 2==0){
        b/=2 ;
        continue ;
      }
      return false ;
    }
    if(b==a)return true ;
    return false ;
  }
  public static void main(String[] args){
    int A=2,B=82 ;
    if(canConvert(A,B))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation canConvert( a : int, b : int) : boolean
  pre: true
  post: true
  activity: (     while (b > a) do (     if (b mod 10 = 1) then (     b := b/(10) ; 
     continue ) else skip ; 
     if (b mod 2 = 0) then (     b := b/(2) ; 
     continue ) else skip ; 
     return false ) ; 
     if (b = a) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 2 ;
    var B : int ; B := 82 ;
     if (canConvert(A, B)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int missingNumber(int arr1[],int arr2[],int n){
    int mnum=0 ;
    for(int i=0 ; i<n ; i++)mnum=mnum ^ arr1[i];
    for(int i=0 ; i<n-1 ; i++)mnum=mnum ^ arr2[i];
    return mnum ;
  }
  public static void main(String[] args){
    int arr1[]={
      4,8,1,3,7 };
      int arr2[]={
        7,4,3,1 };
        int n=arr1.length ;
        System.out.println("Missing number="+missingNumber(arr1,arr2,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation missingNumber( arr1 : Sequence(int), arr2 : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var mnum : int ; mnum := 0 ;
         var i : int ; i := 0 ; while i < n do (     mnum := MathLib.bitwiseXor(mnum,arr1[i+1]) ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n - 1 do (     mnum := MathLib.bitwiseXor(mnum,arr2[i+1]) ;  ;     i := i + 1 ) ; 
     return mnum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr1 : Sequence(int) ; arr1 := Sequence{4,8,1,3,7} ;
     var arr2 : Sequence(int) ; arr2 := Sequence{7,4,3,1} ;
     var n : int ; n := arr1->size() ;
     OclFile["System.out"].println("Missing number=" + missingNumber(arr1, arr2, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static float InscribedCircleArea(float n,float a){
    if(a<0 && n<0)return-1 ;
    float r=a/(float)(2*Math.tan((180/n)*3.14159/180));
    float Area=(float)(3.14)*(r)*(r);
    return Area ;
  }
  public static void main(String[] args){
    float n=6 ;
    float a=4 ;
    System.out.println(InscribedCircleArea(n,a));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation InscribedCircleArea( n : double, a : double) : double
  pre: true
  post: true
  activity: (     if (a < 0 & n < 0) then     return -1 else skip ; 
     var r : double ; r := a / (2 * ((180 / n) * 3.14159 / 180)->tan())->oclAsType(double) ;
     var Area : double ; Area := (3.14)->oclAsType(double) * (r) * (r) ;
     return Area );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : double ; n := 6 ;
     var a : double ; a := 4 ;
     OclFile["System.out"].println(InscribedCircleArea(n, a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.Locale ;
import java.util.Scanner ;
public class C {
  private static final int MAXH=10 ;
  static void solve(){
    int tn=in.nextInt();
    for(int test=1 ; test<=tn ; test++){
      int hn=0 ;
      long[] start=new long[MAXH];
      long[] min=new long[MAXH];
      long[] t=new long[MAXH];
      int n=in.nextInt();
      for(int i=0 ; i<n ; i++){
        int d=in.nextInt();
        int h=in.nextInt();
        int m=in.nextInt();
        for(int j=0 ; j<h ; j++){
          start[hn]=d ;
          min[hn]=m+j ;
          t[hn]=min[hn]*(360-start[hn]);
          hn++;
        }
      }
      long r=hn ;
      for(int i=0 ; i<hn ; i++){
        long rr=hn ;
        for(int j=0 ; j<hn ; j++){
          if(t[j]<=t[i]){
            rr--;
            rr+=(t[i]-t[j])/(360*min[j]);
          }
        }
        r=Math.min(r,rr);
      }
      out.println("Case #"+test+": "+r);
    }
  }
  static Scanner in ;
  static PrintWriter out ;
  public static void main(String[] args)throws FileNotFoundException {
    Locale.setDefault(Locale.US);
    in=new Scanner(new File("C:\\programming\\contests\\GCJ\\GCJ_2015\\2015.05.02_Round_1B\\in"));
    out=new PrintWriter(new File("C:\\programming\\contests\\GCJ\\GCJ_2015\\2015.05.02_Round_1B\\out"));
    solve();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static    attribute MAXH : int := 10;
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var tn : int ; tn := in.nextInt() ;
         var test : int ; test := 1 ; while test <= tn do ( (     var hn : int ; hn := 0 ;
     var start : Sequence(long) ; start := Integer.subrange(1,MAXH)->collect(0) ;
    var min : Sequence(long) ; min := Integer.subrange(1,MAXH)->collect(0) ;
    var t : Sequence(long) ; t := Integer.subrange(1,MAXH)->collect(0) ;
    var n : int ; n := in.nextInt() ;
        var i : int ; i := 0 ; while i < n do ( (     var d : int ; d := in.nextInt() ;
     var h : int ; h := in.nextInt() ;
     var m : int ; m := in.nextInt() ;
         var j : int ; j := 0 ; while j < h do ( (     start[hn+1] := d ; 
     min[hn+1] := m + j ; 
     t[hn+1] := min[hn+1] * (360 - start[hn+1]) ; 
     hn := hn + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var r : long ; r := hn ;
        var i : int ; i := 0 ; while i < hn do ( (     var rr : long ; rr := hn ;
         var j : int ; j := 0 ; while j < hn do ( (     if (t[j+1] <= t[i+1]) then (     rr := rr - 1 ; 
     rr := rr+((t[i+1] - t[j+1]) / (360 * min[j+1])) ) else skip )  ;     j := j + 1 ) ; 
     r := Set{r, rr}->min() )  ;     i := i + 1 ) ; 
    out.println("Case #" + test + ": " + r) ; 
 )  ;     test := test + 1 ) );
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Locale.setDefault(Locale.US) ; 
     in := OclFile.newOclFile_Read(OclFile("C:\\programming\\contests\\GCJ\\GCJ_2015\\2015.05.02_Round(OclFile("C:\\programming\\contests\\GCJ\\GCJ_2015\\2015.05.02_Round(OclFile("C:\\programming\\contests\\GCJ\\GCJ_2015\\2015.05.02_RoundinB\\in"))B\\in"))B\\in")) ; 
    out := OclFile.newOclFile_Write(OclFile("C:\\programming\\contests\\GCJ\\GCJ_2015\\2015.05.02_Round(OclFile("C:\\programming\\contests\\GCJ\\GCJ_2015\\2015.05.02_Round(OclFile("C:\\programming\\contests\\GCJ\\GCJ_2015\\2015.05.02_RoundoutB\\out"))B\\out"))B\\out")) ; 
    execute solve() ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class pre5 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int n=obj.nextInt(),t=obj.nextInt(),c=obj.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=obj.nextInt();
    int ans=0,l=0,r=0 ;
    int count=0,high=0 ;
    while(r<n){
      while(r<n && r-l<c){
        if(arr[r]>t)high++;
        r++;
      }
      if(high==0 && r-l==c)ans++;
      while(r-l>=c){
        if(arr[l]>t)high--;
        l++;
      }
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre5 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var n : int ; n := obj.nextInt() ;
    var t : int ; t := obj.nextInt() ;
    var c : int ; c := obj.nextInt() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := obj.nextInt() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    var count : int ; count := 0 ;
    var high : int ; high := 0 ;
    while (r < n) do (     while (r < n & r - l < c) do (     if (arr[r+1] > t) then     high := high + 1 ; else skip ; 
     r := r + 1 ) ; 
     if (high = 0 & r - l = c) then     ans := ans + 1 ; else skip ; 
     while (r - l >= c) do (     if (arr[l+1] > t) then     high := high - 1 ; else skip ; 
     l := l + 1 ) ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  public static long power(long base,long exponent,long mod){
    if(base>=mod){
      base %=mod ;
    }
    if(exponent==0){
      return 1 % mod ;
    }
    long result=power(base,exponent>>1,mod);
    result=result*result % mod ;
    if((exponent & 1)!=0){
      result=result*base % mod ;
    }
    return result ;
  }
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long md=(long)(Math.pow(10,9)+7);
    long res=(power(27,n,md))-(power(7,n,md));
    if(res<0){
      System.out.println(md+res);
    }
    else System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation power( base : long, exponent : long, mod : long) : long
  pre: true
  post: true
  activity: (     if (base >= mod) then (     base := base mod mod ) else skip ; 
     if (exponent = 0) then (     return 1 mod mod ) else skip ; 
    var result : long ; result := power(base, (exponent/(2->pow(1)))->oclAsType(long), mod) ;
    result := result * result mod mod ; 
    if ((exponent & 1) /= 0) then (     result := result * base mod mod ) else skip ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var md : long ; md := (10->pow(9) + 7)->oclAsType(long) ;
    var res : long ; res := (power(27, n, md)) - (power(7, n, md)) ;
    if (res < 0) then (     OclFile["System.out"].println(md + res) ) else     OclFile["System.out"].println(res) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] m=new int[10000];
      int[] t=new int[1];
      int a,b ;
      int max=0 ;
      for(int i=0 ; i<n ; i++){
        Arrays.fill(m,0);
        t[0]=1 ;
        a=sc.nextInt();
        b=sc.nextInt();
        for(int j=0 ; j<=a*b ; j+=a){
          for(int k=0 ; k<=max ; k++){
            if(t[k]>0)m[j+k]+=t[k];
          }
        }
        max+=a*b ;
        t=m.clone();
      }
      int s=sc.nextInt();
      for(int i=0 ; i<s ; i++)System.out.println(m[sc.nextInt()]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var m : Sequence(int) ; m := Integer.subrange(1,10000)->collect(0) ;
    var t : Sequence(int) ; t := Integer.subrange(1,1)->collect(0) ;
    var a : int ;
    var b : int ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     m := m->collect(0) ; 
     t[0+1] := 1 ; 
    a := sc.getCurrent()->toInteger() ; 
    b := sc.getCurrent()->toInteger() ; 
        var j : int ; j := 0 ; while j <= a * b do ( (         var k : int ; k := 0 ; while k <= max do ( (     if (t[k+1] > 0) then     m[j + k+1] := m[j + k+1]+(t[k+1]) ; else skip )  ;     k := k + 1 ) )  ;     j := j+(a) ) ; 
    max := max+(a * b) ; 
    t := m->copy() ; 
 )  ;     i := i + 1 ) ; 
    var s : int ; s := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < s do (     OclFile["System.out"].println(m[sc.getCurrent()->toInteger()+1]) ;  ;     i := i + 1 ) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int MAXN=100001 ;
  static boolean prime[]=new boolean[MAXN];
  static void SieveOfEratosthenes(){
    for(int i=0 ; i<prime.length ; i++)prime[i]=true ;
    prime[0]=false ;
    prime[1]=false ;
    for(int p=2 ; p*p<MAXN ; p++){
      if(prime[p]==true){
        for(int i=p*p ; i<MAXN ; i+=p)prime[i]=false ;
      }
    }
  }
  static void common_prime(int a,int b){
    int gcd=(int)__gcd(a,b);
    for(int i=2 ; i<=(gcd); i++){
      if(prime[i] && gcd % i==0){
        System.out.print(i+" ");
      }
    }
  }
  static long __gcd(long a,long b){
    if(a==0)return b ;
    return __gcd(b % a,a);
  }
  public static void main(String[] args){
    SieveOfEratosthenes();
    int a=6,b=12 ;
    common_prime(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute MAXN : int := 100001;
  static   attribute prime : boolean := Integer.subrange(1,MAXN)->collect(false);
  static   operation SieveOfEratosthenes() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < prime->size() do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
     prime[0+1] := false ; 
     prime[1+1] := false ; 
         var p : int ; p := 2 ; while p * p < MAXN do ( (     if (prime[p+1] = true) then (         var i : int ; i := p * p ; while i < MAXN do (     prime[i+1] := false ;  ;     i := i+(p) ) ) else skip )  ;     p := p + 1 ) );
  static   operation common_prime( a : int, b : int) : void
  pre: true
  post: true
  activity: (     var gcd : int ; gcd := __gcd(a, b)->oclAsType(int) ;
         var i : int ; i := 2 ; while i <= (gcd) do ( (     if (prime[i+1] & gcd mod i = 0) then (     OclFile["System.out"].print(i + " ") ) else skip )  ;     i := i + 1 ) );
  static   operation __gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return __gcd(b mod a, a) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute SieveOfEratosthenes() ; 
     var a : int ; a := 6 ;
    var b : int ; b := 12 ;
     execute common_prime(a, b) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int MSBPosition(long N){
    int msb_p=-1 ;
    while(N>0){
      N=N>>1 ;
      msb_p++;
    }
    return msb_p ;
  }
  static long findBitwiseOR(long L,long R){
    long res=0 ;
    int msb_p1=MSBPosition(L);
    int msb_p2=MSBPosition(R);
    while(msb_p1==msb_p2){
      long res_val=(1<<msb_p1);
      res+=res_val ;
      L-=res_val ;
      R-=res_val ;
      msb_p1=MSBPosition(L);
      msb_p2=MSBPosition(R);
    }
    msb_p1=Math.max(msb_p1,msb_p2);
    for(int i=msb_p1 ; i>=0 ; i--){
      long res_val=(1<<i);
      res+=res_val ;
    }
    return res ;
  }
  public static void main(String[] args){
    int L=12,R=18 ;
    System.out.println(findBitwiseOR(L,R));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation MSBPosition( N : long) : int
  pre: true
  post: true
  activity: (     var msb_p : int ; msb_p := -1 ;
     while (N > 0) do (     N := (N/(2->pow(1)))->oclAsType(long) ; 
     msb_p := msb_p + 1 ) ; 
     return msb_p );
  static   operation findBitwiseOR( L : long, R : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 0 ;
     var msb_p1 : int ; msb_p1 := MSBPosition(L) ;
    var msb_p2 : int ; msb_p2 := MSBPosition(R) ;
    while (msb_p1 = msb_p2) do (     var res_val : long ; res_val := ((1*(2->pow(msb_p1)))->oclAsType(long)) ;
     res := res+(res_val) ; 
    L := L-(res_val) ; 
    R := R-(res_val) ; 
    msb_p1 := MSBPosition(L) ; 
    msb_p2 := MSBPosition(R) ; 
 ) ; 
    msb_p1 := Set{msb_p1, msb_p2}->max() ; 
        var i : int ; i := msb_p1 ; while i >= 0 do ( (     var res_val : long ; res_val := ((1*(2->pow(i)))->oclAsType(long)) ;
     res := res+(res_val) )  ;     i := i - 1 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : int ; L := 12 ;
    var R : int ; R := 18 ;
     OclFile["System.out"].println(findBitwiseOR(L, R)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long oddNumSum(int n){
    int j=0 ;
    long sum=0 ;
    for(int i=1 ; i<=n ; i++){
      j=(2*i-1);
      sum=sum+(j*j*j*j);
    }
    return sum ;
  }
  public static void main(String args[]){
    int n=6 ;
    System.out.println(oddNumSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation oddNumSum( n : int) : long
  pre: true
  post: true
  activity: (     var j : int ; j := 0 ;
     var sum : long ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     j := (2 * i - 1) ; 
     sum := sum + (j * j * j * j) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].println(oddNumSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long evenPowerSum(int n){
    long sum=0 ;
    for(int i=1 ; i<=n ; i++){
      int j=2*i ;
      sum=sum+(j*j*j*j);
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(evenPowerSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation evenPowerSum( n : int) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var i : int ; i := 1 ; while i <= n do ( (     var j : int ; j := 2 * i ;
     sum := sum + (j * j * j * j) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(evenPowerSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int summation(int n){
    int sum=0,j=1 ;
    for(int i=1 ; i<=n ; i++){
      sum=sum+j ;
      j=(j*10)+1 ;
    }
    return sum ;
  }
  public static void main(String args[]){
    int n=5 ;
    System.out.println(summation(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation summation( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
    var j : int ; j := 1 ;
         var i : int ; i := 1 ; while i <= n do ( (     sum := sum + j ; 
     j := (j * 10) + 1 )  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(summation(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] even=new int[100001];
    int[] odd=new int[100001];
    int evenMaxIndex=0 ;
    int evenMaxCount=0 ;
    int oddMaxIndex=0 ;
    int oddMaxCount=0 ;
    for(int i=1 ; i<=N ; i++){
      int num=sc.nextInt();
      if(i % 2==0){
        int tmp=even[num];
        tmp++;
        even[num]=tmp ;
        if(Math.max(evenMaxCount,tmp)==tmp){
          evenMaxIndex=num ;
          evenMaxCount=tmp ;
        }
      }
      else {
        int tmp=odd[num];
        tmp++;
        odd[num]=tmp ;
        if(Math.max(oddMaxCount,tmp)==tmp){
          oddMaxIndex=num ;
          oddMaxCount=tmp ;
        }
      }
    }
    if(evenMaxIndex==oddMaxIndex){
      Arrays.sort(even);
      Arrays.sort(odd);
      oddMaxCount=Math.max(even[even.length-2],odd[odd.length-2]);
    }
    int ans=N-(evenMaxCount+oddMaxCount);
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var even : Sequence(int) ; even := Integer.subrange(1,100001)->collect(0) ;
    var odd : Sequence(int) ; odd := Integer.subrange(1,100001)->collect(0) ;
    var evenMaxIndex : int ; evenMaxIndex := 0 ;
    var evenMaxCount : int ; evenMaxCount := 0 ;
    var oddMaxIndex : int ; oddMaxIndex := 0 ;
    var oddMaxCount : int ; oddMaxCount := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     var num : int ; num := sc.getCurrent()->toInteger() ;
     if (i mod 2 = 0) then (     var tmp : int ; tmp := even[num+1] ;
     tmp := tmp + 1 ; 
     even[num+1] := tmp ; 
     if (Set{evenMaxCount, tmp}->max() = tmp) then (     evenMaxIndex := num ; 
     evenMaxCount := tmp ) else skip ) else (     var tmp : int ; tmp := odd[num+1] ;
     tmp := tmp + 1 ; 
     odd[num+1] := tmp ; 
     if (Set{oddMaxCount, tmp}->max() = tmp) then (     oddMaxIndex := num ; 
     oddMaxCount := tmp ) else skip ) )  ;     i := i + 1 ) ; 
    if (evenMaxIndex = oddMaxIndex) then (     even := even->sort() ; 
     odd := odd->sort() ; 
     oddMaxCount := Set{even[even->size() - 2+1], odd[odd->size() - 2+1]}->max() ) else skip ; 
    var ans : int ; ans := N - (evenMaxCount + oddMaxCount) ;
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Main m=new Main();
    m.run();
  }
  Scanner sc=new Scanner(System.in);
  void run(){
    int n=sc.nextInt();
    int am[]=new int[112345];
    int bm[]=new int[112345];
    int tmp[]=am ;
    int swp[]=bm ;
    int t[];
    for(int i=0 ; i<n ; i++){
      tmp[sc.nextInt()]++;
      t=tmp ;
      tmp=swp ;
      swp=t ;
    }
    int mt1=0 ;
    int mt2=0 ;
    int mti1=0 ;
    int mti2=0 ;
    int ms1=0 ;
    int ms2=0 ;
    int msi1=0 ;
    int msi2=0 ;
    for(int i=0 ; i<112345 ; i++){
      if(tmp[i]>=mt1){
        mt2=mt1 ;
        mti2=mti1 ;
        mt1=tmp[i];
        mti1=i ;
      }
      else if(tmp[i]>=mt2){
        mt2=tmp[i];
        mti2=i ;
      }
      if(swp[i]>=ms1){
        ms2=ms1 ;
        msi2=msi1 ;
        ms1=swp[i];
        msi1=i ;
      }
      else if(swp[i]>=ms2){
        ms2=swp[i];
        msi2=i ;
      }
    }
    if(mti1!=msi1){
      System.out.println(n-mt1-ms1);
    }
    else {
      int max=Math.max((mt1+ms2),(mt2+ms1));
      System.out.println(n-max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var m : Main ; m := Main.newMain() ;
     m.run() );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var am : Sequence(int) ; am := Integer.subrange(1,112345)->collect(0) ;
    var bm : Sequence(int) ; bm := Integer.subrange(1,112345)->collect(0) ;
    var tmp : Sequence(int) ; tmp := am ;
    var swp : Sequence(int) ; swp := bm ;
    var t : Sequence(int) ;
        var i : int ; i := 0 ; while i < n do ( (     tmp[sc.getCurrent()->toInteger()+1] := tmp[sc.getCurrent()->toInteger()+1] + 1 ; 
     t := tmp ; 
     tmp := swp ; 
     swp := t )  ;     i := i + 1 ) ; 
    var mt1 : int ; mt1 := 0 ;
    var mt2 : int ; mt2 := 0 ;
    var mti1 : int ; mti1 := 0 ;
    var mti2 : int ; mti2 := 0 ;
    var ms1 : int ; ms1 := 0 ;
    var ms2 : int ; ms2 := 0 ;
    var msi1 : int ; msi1 := 0 ;
    var msi2 : int ; msi2 := 0 ;
        var i : int ; i := 0 ; while i < 112345 do ( (     if (tmp[i+1] >= mt1) then (     mt2 := mt1 ; 
     mti2 := mti1 ; 
     mt1 := tmp[i+1] ; 
     mti1 := i ) else     if (tmp[i+1] >= mt2) then (     mt2 := tmp[i+1] ; 
     mti2 := i ) else skip ; ;  
     if (swp[i+1] >= ms1) then (     ms2 := ms1 ; 
     msi2 := msi1 ; 
     ms1 := swp[i+1] ; 
     msi1 := i ) else     if (swp[i+1] >= ms2) then (     ms2 := swp[i+1] ; 
     msi2 := i ) else skip ; )  ;     i := i + 1 ) ; 
    if (mti1 /= msi1) then (     OclFile["System.out"].println(n - mt1 - ms1) ) else (     var max : int ; max := Set{(mt1 + ms2), (mt2 + ms1)}->max() ;
     OclFile["System.out"].println(n - max) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    int ans=0 ;
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int list[]=new int[n];
    for(int i=0 ; i<n ; i++){
      list[i]=sc.nextInt();
    }
    int numlist1[]=new int[100000];
    int numlist2[]=new int[100000];
    for(int i=0 ; i<100000 ; i++){
      numlist1[i]=0 ;
      numlist2[i]=0 ;
    }
    for(int i=0 ; i<n ; i+=2){
      numlist1[list[i]-1]+=1 ;
      numlist2[list[i+1]-1]+=1 ;
    }
    int max11=0,max12=0,max21=0,max22=0 ;
    int val1=0,val2=0 ;
    for(int i=0 ; i<100000 ; i++){
      if(numlist1[i]>=max11){
        max12=max11 ;
        max11=numlist1[i];
        val1=i ;
      }
      else if(numlist1[i]>=max12){
        max12=numlist1[i];
      }
      if(numlist2[i]>=max21){
        max22=max21 ;
        max21=numlist2[i];
        val2=i ;
      }
      else if(numlist2[i]>=max22){
        max22=numlist2[i];
      }
    }
    if(val1!=val2){
      ans=n-max11-max21 ;
    }
    else {
      ans=n-Math.max(max12+max21,max11+max22);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     list[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var numlist1 : Sequence(int) ; numlist1 := Integer.subrange(1,100000)->collect(0) ;
    var numlist2 : Sequence(int) ; numlist2 := Integer.subrange(1,100000)->collect(0) ;
        var i : int ; i := 0 ; while i < 100000 do ( (     numlist1[i+1] := 0 ; 
     numlist2[i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     numlist1[list[i+1] - 1+1] := numlist1[list[i+1] - 1+1]+(1) ; 
     numlist2[list[i + 1+1] - 1+1] := numlist2[list[i + 1+1] - 1+1]+(1) )  ;     i := i+(2) ) ; 
    var max11 : int ; max11 := 0 ;
    var max12 : int ; max12 := 0 ;
    var max21 : int ; max21 := 0 ;
    var max22 : int ; max22 := 0 ;
    var val1 : int ; val1 := 0 ;
    var val2 : int ; val2 := 0 ;
        var i : int ; i := 0 ; while i < 100000 do ( (     if (numlist1[i+1] >= max11) then (     max12 := max11 ; 
     max11 := numlist1[i+1] ; 
     val1 := i ) else     if (numlist1[i+1] >= max12) then (     max12 := numlist1[i+1] ) else skip ; ;  
     if (numlist2[i+1] >= max21) then (     max22 := max21 ; 
     max21 := numlist2[i+1] ; 
     val2 := i ) else     if (numlist2[i+1] >= max22) then (     max22 := numlist2[i+1] ) else skip ; )  ;     i := i + 1 ) ; 
    if (val1 /= val2) then (     ans := n - max11 - max21 ) else (     ans := n - Set{max12 + max21, max11 + max22}->max() ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    final Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    final Map<Integer,Integer>a=new HashMap<>();
    final Map<Integer,Integer>b=new HashMap<>();
    int aMaxCount=0 ;
    int aMax2Count=0 ;
    int bMaxCount=0 ;
    int bMax2Count=0 ;
    int aMax=0 ;
    int aMax2=0 ;
    int bMax=0 ;
    int bMax2=0 ;
    for(int i=0 ; i<n ; ++i){
      int current=scanner.nextInt();
      if(i % 2==0){
        int count=a.getOrDefault(current,0)+1 ;
        a.put(current,count);
        if(count>=aMaxCount){
          if(current!=aMax){
            aMax2Count=aMaxCount ;
            aMax2=aMax ;
          }
          aMaxCount=count ;
          aMax=current ;
        }
        else if(count>=aMax2Count){
          aMax2Count=count ;
          aMax2=current ;
        }
      }
      else {
        int count=b.getOrDefault(current,0)+1 ;
        b.put(current,count);
        if(count>=bMaxCount){
          if(current!=bMax){
            bMax2Count=bMaxCount ;
            bMax2=bMax ;
          }
          bMaxCount=count ;
          bMax=current ;
        }
        else if(count>=bMax2Count){
          bMax2Count=count ;
          bMax2=current ;
        }
      }
    }
    if(aMax!=bMax){
      System.out.println(n-aMaxCount-bMaxCount);
    }
    else {
      if(aMax2Count==0 && bMax2Count!=0){
        System.out.println(n-bMaxCount);
      }
      else if(aMax2Count==0 && bMax2Count==0){
        System.out.println(n/2);
      }
      else if(aMax2Count!=0 && bMax2Count==0){
        System.out.println(n-aMaxCount);
      }
      else {
        int change1=n-aMaxCount-bMax2Count ;
        int change2=n-bMaxCount-aMax2Count ;
        System.out.println(Math.min(change1,change2));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var a : Map(int,int) ; a := Map{} ;
    var b : Map(int,int) ; b := Map{} ;
    var aMaxCount : int ; aMaxCount := 0 ;
    var aMax2Count : int ; aMax2Count := 0 ;
    var bMaxCount : int ; bMaxCount := 0 ;
    var bMax2Count : int ; bMax2Count := 0 ;
    var aMax : int ; aMax := 0 ;
    var aMax2 : int ; aMax2 := 0 ;
    var bMax : int ; bMax := 0 ;
    var bMax2 : int ; bMax2 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var current : int ; current := scanner.getCurrent()->toInteger() ;
     if (i mod 2 = 0) then (     var count : int ; count := (if a->keys()->contains(current) then a->at(current) else 0 endif) + 1 ;
     a := a->union(Map{current |-> count}) ; 
     if (count >= aMaxCount) then (     if (current /= aMax) then (     aMax2Count := aMaxCount ; 
     aMax2 := aMax ) else skip ; 
     aMaxCount := count ; 
     aMax := current ) else     if (count >= aMax2Count) then (     aMax2Count := count ; 
     aMax2 := current ) else skip ; ) else (     var count : int ; count := (if b->keys()->contains(current) then b->at(current) else 0 endif) + 1 ;
     b := b->union(Map{current |-> count}) ; 
     if (count >= bMaxCount) then (     if (current /= bMax) then (     bMax2Count := bMaxCount ; 
     bMax2 := bMax ) else skip ; 
     bMaxCount := count ; 
     bMax := current ) else     if (count >= bMax2Count) then (     bMax2Count := count ; 
     bMax2 := current ) else skip ; ) )  ;     i := i + 1 ) ; 
    if (aMax /= bMax) then (     OclFile["System.out"].println(n - aMaxCount - bMaxCount) ) else (     if (aMax2Count = 0 & bMax2Count /= 0) then (     OclFile["System.out"].println(n - bMaxCount) ) else     if (aMax2Count = 0 & bMax2Count = 0) then (     OclFile["System.out"].println(n / 2) ) else     if (aMax2Count /= 0 & bMax2Count = 0) then (     OclFile["System.out"].println(n - aMaxCount) ) else (     var change1 : int ; change1 := n - aMaxCount - bMax2Count ;
     var change2 : int ; change2 := n - bMaxCount - aMax2Count ;
     OclFile["System.out"].println(Set{change1, change2}->min()) ) ;  ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class PrisonTransfer {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    int c=sc.nextInt();
    int arr[]=new int[n];
    int len=0 ;
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
      if(arr[i]<=t){
        len++;
      }
      else {
        len=0 ;
      }
      if(len>=c){
        count++;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class PrisonTransfer {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var len : int ; len := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr[i+1] <= t) then (     len := len + 1 ) else (     len := 0 ) ;  
     if (len >= c) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int len=393 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int s[]=new int[n],l[]=new int[n],p[]=new int[n];
    for(int i=0 ; i<n ; i++){
      s[i]=sc.nextInt();
      l[i]=sc.nextInt();
      p[i]=sc.nextInt();
    }
    int[] dp=new int[len+1];
    fill(dp,-1);
    dp[0]=0 ;
    for(int j=0 ; j<=len ; j++)for(int i=0 ; i<n ; i++)if(dp[j]>=0){
      for(int k=s[i]; k<=l[i]; k++)if(j+k<=len)dp[j+k]=max(dp[j+k],dp[j]+p[i]);
    }
    int m=sc.nextInt();
    int[] ans=new int[m];
    boolean flg=true ;
    for(int i=0 ; i<m ; i++){
      int r=sc.nextInt();
      ans[i]=dp[r];
      if(ans[i]==-1)flg=false ;
    }
    if(! flg)System.out.println(-1);
    else {
      for(int i : ans)System.out.println(i);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute len : int := 393;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(void) ; s := Integer.subrange(1,n)->collect(0) ;
    var l : Sequence(void) ; l := Integer.subrange(1,n)->collect(0) ;
    var p : Sequence(void) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := sc.getCurrent()->toInteger() ; 
     l[i+1] := sc.getCurrent()->toInteger() ; 
     p[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,len + 1)->collect(0) ;
    execute fill(dp, -1) ; 
    dp[0+1] := 0 ; 
        var j : int ; j := 0 ; while j <= len do (         var i : int ; i := 0 ; while i < n do (     if (dp[j+1] >= 0) then (         var k : int ; k := s[i+1] ; while k <= l[i+1] do (     if (j + k <= len) then     dp[j + k+1] := Set{dp[j + k+1], dp[j+1] + p[i+1]}->max() ; else skip ;  ;     k := k + 1 ) ) else skip ;  ;     i := i + 1 ) ;  ;     j := j + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,m)->collect(0) ;
    var flg : boolean ; flg := true ;
        var i : int ; i := 0 ; while i < m do ( (     var r : int ; r := sc.getCurrent()->toInteger() ;
     ans[i+1] := dp[r+1] ; 
     if (ans[i+1] = -1) then     flg := false ; else skip )  ;     i := i + 1 ) ; 
    if (not(flg)) then     OclFile["System.out"].println(-1) else (     for (i : ans) do (     OclFile["System.out"].println(i) ;  ) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Node {
    char data ;
    Node prev ;
    Node next ;
  };
  static int size(Node head_ref){
    Node curr=head_ref ;
    int sz=0 ;
    while(curr!=null){
      curr=curr.next ;
      sz++;
    }
    return sz ;
  }
  static void printList(Node node){
    while(node.next!=null){
      System.out.print(node.data+" "+"<=>"+" ");
      node=node.next ;
    }
    System.out.print(node.data);
  }
  static Node push(Node head_ref,char new_data){
    Node new_node=new Node();
    new_node.data=new_data ;
    new_node.prev=null ;
    new_node.next=head_ref ;
    if(head_ref!=null)head_ref.prev=new_node ;
    head_ref=new_node ;
    return head_ref ;
  }
  static Node rotate(Node head_ref,int N,int sz){
    N=N % sz ;
    N=sz-N ;
    if(N==0)return null ;
    Node current=head_ref ;
    int count=1 ;
    while(count<N && current!=null){
      current=current.next ;
      count++;
    }
    if(current==null)return null ;
    Node NthNode=current ;
    while(current.next!=null)current=current.next ;
    current.next=head_ref ;
    head_ref.prev=current ;
    head_ref=NthNode.next ;
    head_ref.prev=null ;
    NthNode.next=null ;
    return head_ref ;
  }
  public static void main(String[] args){
    Node head=null ;
    head=push(head,'e');
    head=push(head,'d');
    head=push(head,'c');
    head=push(head,'b');
    head=push(head,'a');
    int N=2 ;
    int sz=size(head);
    System.out.println("Given Doubly linked list ");
    printList(head);
    head=rotate(head,N,sz);
    System.out.println("\nRotated Linked list clockwise ");
    printList(head);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : String;
   attribute prev : Node;
   attribute next : Node;
}
  static   operation size( head_ref : Node) : int
  pre: true
  post: true
  activity: (     var curr : Node ; curr := head_ref ;
     var sz : int ; sz := 0 ;
     while (curr /= null) do (     curr := curr.next ; 
     sz := sz + 1 ) ; 
     return sz );
  static   operation printList( node : Node) : void
  pre: true
  post: true
  activity: (     while (node.next /= null) do (     OclFile["System.out"].print(node.data + " " + "<=>" + " ") ; 
     node := node.next ) ; 
     OclFile["System.out"].print(node.data) );
  static   operation push( head_ref : Node, new_data : String) : Node
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode() ;
     new_node.data := new_data ; 
    new_node.prev := null ; 
    new_node.next := head_ref ; 
    if (head_ref /= null) then     head_ref.prev := new_node ; else skip ; 
    head_ref := new_node ; 
    return head_ref 
 );
  static   operation rotate( head_ref : Node, N : int, sz : int) : Node
  pre: true
  post: true
  activity: (     N := N mod sz ; 
     N := sz - N ; 
    if (N = 0) then     return null else skip ; 
    var current : Node ; current := head_ref ;
    var count : int ; count := 1 ;
    while (count < N & current /= null) do (     current := current.next ; 
     count := count + 1 ) ; 
    if (current = null) then     return null else skip ; 
    var NthNode : Node ; NthNode := current ;
    while (current.next /= null) do     current := current.next ; ; 
    current.next := head_ref ; 
    head_ref.prev := current ; 
    head_ref := NthNode.next ; 
    head_ref.prev := null ; 
    NthNode.next := null ; 
    return head_ref 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := null ;
     head := push(head, 'e') ; 
    head := push(head, 'd') ; 
    head := push(head, 'c') ; 
    head := push(head, 'b') ; 
    head := push(head, 'a') ; 
    var N : int ; N := 2 ;
    var sz : int ; sz := size(head) ;
    OclFile["System.out"].println("Given Doubly linked list ") ; 
    execute printList(head) ; 
    head := rotate(head, N, sz) ; 
    OclFile["System.out"].println("\nRotated Linked list clockwise ") ; 
    execute printList(head) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static double sum(int x,int n){
    double i,total=1.0,multi=x ;
    for(i=1 ; i<=n ; i++){
      total=total+multi/i ;
      multi=multi*x ;
    }
    return total ;
  }
  public static void main(String[] args){
    int x=2 ;
    int n=5 ;
    System.out.printf("%.2f",sum(x,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sum( x : int, n : int) : double
  pre: true
  post: true
  activity: (     var i : double ;
    var total : double ; total := 1.0 ;
    var multi : double ; multi := x ;
         i := 1 ; while i <= n do ( (     total := total + multi / i ; 
     multi := multi * x )  ;     i := i + 1 ) ; 
     return total );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 2 ;
     var n : int ; n := 5 ;
     OclFile["System.out"].printf("%.2f", sum(x, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int __gcd(int a,int b){
    if(b==0)return a ;
    return __gcd(b,a % b);
  }
  static int sumAP(int n,int d){
    n/=d ;
    return(n)*(1+n)*d/2 ;
  }
  static int sumMultiples(int A,int B,int n){
    n--;
    int common=(A*B)/__gcd(A,B);
    return sumAP(n,A)+sumAP(n,B)-sumAP(n,common);
  }
  public static void main(String[] args){
    int n=100,A=5,B=10 ;
    System.out.println("Sum="+sumMultiples(A,B,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     return __gcd(b, a mod b) );
  static   operation sumAP( n : int, d : int) : int
  pre: true
  post: true
  activity: (     n := n/(d) ; 
     return (n) * (1 + n) * d / 2 );
  static   operation sumMultiples( A : int, B : int, n : int) : int
  pre: true
  post: true
  activity: (     n := n - 1 ; 
     var common : int ; common := (A * B) / __gcd(A, B) ;
     return sumAP(n, A) + sumAP(n, B) - sumAP(n, common) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 100 ;
    var A : int ; A := 5 ;
    var B : int ; B := 10 ;
     OclFile["System.out"].println("Sum=" + sumMultiples(A, B, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class sub {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    long ans=0 ;
    int i,count=1,tempP,tempN,ax,ay ;
    i=0 ;
    int p[]=new int[400000];
    int np[]=new int[400000];
    int nn[]=new int[400000];
    for(i=0 ; i<n ; i++){
      ax=scan.nextInt();
      ay=scan.nextInt();
      tempP=p[ax+ay];
      p[ax+ay]++;
      if((ax-ay)<0){
        tempN=nn[ay-ax];
        nn[ay-ax]++;
      }
      else {
        tempN=np[ax-ay];
        np[ax-ay]++;
      }
      ans=ans+(tempP+tempN);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class sub {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var ans : long ; ans := 0 ;
    var i : int ;
    var count : int ; count := 1 ;
    var tempP : int ;
    var tempN : int ;
    var ax : int ;
    var ay : int ;
    i := 0 ; 
    var p : Sequence(int) ; p := Integer.subrange(1,400000)->collect(0) ;
    var np : Sequence(int) ; np := Integer.subrange(1,400000)->collect(0) ;
    var nn : Sequence(int) ; nn := Integer.subrange(1,400000)->collect(0) ;
        i := 0 ; while i < n do ( (     ax := scan.getCurrent()->toInteger() ; 
     ay := scan.getCurrent()->toInteger() ; 
    tempP := p[ax + ay+1] ; 
    p[ax + ay+1] := p[ax + ay+1] + 1 ; 
    if ((ax - ay) < 0) then (     tempN := nn[ay - ax+1] ; 
     nn[ay - ax+1] := nn[ay - ax+1] + 1 ) else (     tempN := np[ax - ay+1] ; 
     np[ax - ay+1] := np[ax - ay+1] + 1 ) ;  
    ans := ans + (tempP + tempN) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class WetSharkandBishops {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    HashMap<Integer,ArrayList<Integer>>dm=new HashMap<Integer,ArrayList<Integer>>();
    HashMap<Integer,ArrayList<Integer>>sm=new HashMap<Integer,ArrayList<Integer>>();
    for(int i=0 ; i<n ; i++){
      int r=s.nextInt();
      int c=s.nextInt();
      int diff=r-c ;
      int sum=r+c ;
      if(sm.containsKey(sum)){
        sm.get(sum).add(i+1);
      }
      else {
        ArrayList<Integer>temp=new ArrayList<>();
        temp.add(i+1);
        sm.put(sum,temp);
      }
      if(dm.containsKey(diff)){
        dm.get(diff).add(i+1);
      }
      else {
        ArrayList<Integer>temp=new ArrayList<>();
        temp.add(i+1);
        dm.put(diff,temp);
      }
    }
    int ans=0 ;
    for(Map.Entry<Integer,ArrayList<Integer>>entry : dm.entrySet()){
      ans+=calc(entry.getValue().size());
    }
    for(Map.Entry<Integer,ArrayList<Integer>>entry : sm.entrySet()){
      ans+=calc(entry.getValue().size());
    }
    System.out.println(ans);
  }
  public static int calc(int s){
    return s*(s-1)/2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class WetSharkandBishops {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
    var dm : Map(int,Sequence(int)) ; dm := Map{} ;
    var sm : Map(int,Sequence(int)) ; sm := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var r : int ; r := s.getCurrent()->toInteger() ;
     var c : int ; c := s.getCurrent()->toInteger() ;
    var diff : int ; diff := r - c ;
    var sum : int ; sum := r + c ;
    if (sm->keys()->includes(sum)) then (     sm->at(sum)->excludes(i + 1) ) else (     var temp : Sequence(int) ; temp := Sequence{} ;
     temp := temp->including(i + 1) ; 
     sm := sm->union(Map{sum |-> temp}) ) ;  
    if (dm->keys()->includes(diff)) then (     dm->at(diff)->excludes(i + 1) ) else (     var temp : Sequence(int) ; temp := Sequence{} ;
     temp := temp->including(i + 1) ; 
     dm := dm->union(Map{diff |-> temp}) ) ;  
 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (entry : dm->asSet()) do ( (     ans := ans+(calc(entry.getValue()->size())) )  ) ; 
    for (entry : sm->asSet()) do ( (     ans := ans+(calc(entry.getValue()->size())) )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation calc( s : int) : int
  pre: true
  post: true
  activity: (     return s * (s - 1) / 2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CF621B {
  public static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    HashMap<Integer,Integer>diagonal=new HashMap<>();
    HashMap<Integer,Integer>antiDiagonal=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int from=Integer.parseInt(scanner.next());
      int to=Integer.parseInt(scanner.next());
      int diff=from-to ;
      int add=from+to ;
      diagonal.put(diff,diagonal.getOrDefault(diff,0)+1);
      antiDiagonal.put(add,antiDiagonal.getOrDefault(add,0)+1);
    }
    long res=0 ;
    for(Map.Entry<Integer,Integer>entry : diagonal.entrySet()){
      long combination=(long)(entry.getValue())*(entry.getValue()-1)/2 ;
      res+=combination ;
    }
    for(Map.Entry<Integer,Integer>entry : antiDiagonal.entrySet()){
      long combination=(long)(entry.getValue())*(entry.getValue()-1)/2 ;
      res+=combination ;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF621B {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var diagonal : Map(int,int) ; diagonal := Map{} ;
    var antiDiagonal : Map(int,int) ; antiDiagonal := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var from : int ; from := (scanner.getCurrent())->toInteger() ;
     var to : int ; to := (scanner.getCurrent())->toInteger() ;
    var diff : int ; diff := from - to ;
    var add : int ; add := from + to ;
    diagonal := diagonal->union(Map{diff |-> (if diagonal->keys()->contains(diff) then diagonal->at(diff) else 0 endif) + 1}) ; 
    antiDiagonal := antiDiagonal->union(Map{add |-> (if antiDiagonal->keys()->contains(add) then antiDiagonal->at(add) else 0 endif) + 1}) ; 
 )  ;     i := i + 1 ) ; 
    var res : long ; res := 0 ;
    for (entry : diagonal->asSet()) do ( (     var combination : long ; combination := (entry.getValue())->oclAsType(long) * (entry.getValue() - 1) / 2 ;
     res := res+(combination) )  ) ; 
    for (entry : antiDiagonal->asSet()) do ( (     var combination : long ; combination := (entry.getValue())->oclAsType(long) * (entry.getValue() - 1) / 2 ;
     res := res+(combination) )  ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int X=sc.nextInt();
    int A=sc.nextInt();
    int B=sc.nextInt();
    if(B-A<=0){
      System.out.println("delicious");
    }
    else if(B-A<=X){
      System.out.println("safe");
    }
    else {
      System.out.println("dangerous");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var X : int ; X := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var B : int ; B := sc.getCurrent()->toInteger() ;
    if (B - A <= 0) then (     OclFile["System.out"].println("delicious") ) else     if (B - A <= X) then (     OclFile["System.out"].println("safe") ) else (     OclFile["System.out"].println("dangerous") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.ByteArrayInputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.InputMismatchException ;
import java.io.OutputStream ;
import java.util.StringTokenizer ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
import java.math.BigDecimal ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(1,in,out);
    out.close();
  }
  static class Task {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int X=in.nextInt();
      int A=in.nextInt();
      int B=in.nextInt();
      int res=B-A ;
      if(res>X)out.println("dangerous");
      else if(res>0)out.println("safe");
      else out.println("delicious");
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var X : int ; X := in.nextInt() ;
     var A : int ; A := in.nextInt() ;
    var B : int ; B := in.nextInt() ;
    var res : int ; res := B - A ;
    if (res > X) then     skip else     if (res > 0) then     skip else     skip ; ;  ;  
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import javax.swing.*;
import java.util.*;
public class Main {
  static final long MOD=1000000007 ;
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int a=scanner.nextInt();
    int b=scanner.nextInt();
    int c=scanner.nextInt();
    if(a>=c){
      System.out.println("delicious");
    }
    else {
      if(b+a>=c){
        System.out.println("safe");
      }
      else {
        System.out.println("dangerous");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : long := 1000000007;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
    var c : int ; c := scanner.getCurrent()->toInteger() ;
    if (a >= c) then (     OclFile["System.out"].println("delicious") ) else (     if (b + a >= c) then (     OclFile["System.out"].println("safe") ) else (     OclFile["System.out"].println("dangerous") ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.List ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    if(b<=a){
      System.out.println("delicious");
    }
    else if(b-x>a){
      System.out.println("dangerous");
    }
    else {
      System.out.println("safe");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    if (b <= a) then (     OclFile["System.out"].println("delicious") ) else     if (b - x > a) then (     OclFile["System.out"].println("dangerous") ) else (     OclFile["System.out"].println("safe") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.util.*;
import java.io.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] s=new int[n];
    int[] l=new int[n];
    int[] p=new int[n];
    for(int i=0 ; i<n ; i++){
      s[i]=sc.nextInt();
      l[i]=sc.nextInt();
      p[i]=sc.nextInt();
    }
    int[] dp=new int[400];
    fill(dp,-1);
    dp[0]=0 ;
    for(int i=0 ; i<n ; i++){
      for(int x=0 ; x<400 ; x++){
        for(int j=s[i]; j<=l[i]; j++){
          if(x-j>=0){
            dp[x]=max(dp[x],dp[x-j]+p[i]);
          }
        }
      }
    }
    int m=sc.nextInt();
    int[] ans=new int[m];
    boolean imp=false ;
    for(int i=0 ; i<m ; i++){
      int x=sc.nextInt();
      ans[i]=dp[x];
      if(ans[i]==-1)imp=true ;
    }
    if(imp){
      System.out.println(-1);
    }
    else {
      for(int x : ans){
        System.out.println(x);
      }
    }
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var s : Sequence(int) ; s := Integer.subrange(1,n)->collect(0) ;
    var l : Sequence(int) ; l := Integer.subrange(1,n)->collect(0) ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s[i+1] := sc.getCurrent()->toInteger() ; 
     l[i+1] := sc.getCurrent()->toInteger() ; 
     p[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,400)->collect(0) ;
    execute fill(dp, -1) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (         var x : int ; x := 0 ; while x < 400 do ( (         var j : int ; j := s[i+1] ; while j <= l[i+1] do ( (     if (x - j >= 0) then (     dp[x+1] := Set{dp[x+1], dp[x - j+1] + p[i+1]}->max() ) else skip )  ;     j := j + 1 ) )  ;     x := x + 1 ) )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,m)->collect(0) ;
    var imp : boolean ; imp := false ;
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     ans[i+1] := dp[x+1] ; 
     if (ans[i+1] = -1) then     imp := true ; else skip )  ;     i := i + 1 ) ; 
    if (imp) then (     OclFile["System.out"].println(-1) ) else (     for (x : ans) do ( (     OclFile["System.out"].println(x) )  ) ) ;  
 );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.HashMap ;
import java.util.Map ;
import java.util.Set ;
import java.util.*;
import java.util.Arrays ;
import java.lang.Math ;
import java.util.Collections ;
public class Log {
  class GIATRI {
    public int x=0 ;
    public int y=0 ;
  }
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int t=1 ;
    while(t>0){
      tinh();
      t=t-1 ;
    }
  }
  public static void tinh(){
    int n=sc.nextInt();
    int t=sc.nextInt();
    int c=sc.nextInt();
    int[] A=new int[n];
    for(int i=0 ; i<n ; i++){
      A[i]=sc.nextInt();
    }
    int[] B=new int[n+1];
    int k=0 ;
    int dem=0 ;
    for(int i=0 ; i<n ; i++){
      if(A[i]<=t){
        dem++;
      }
      else {
        B[k]=dem ;
        dem=0 ;
        k++;
      }
      if(i==n-1){
        B[k]=dem ;
        dem=0 ;
        k++;
      }
    }
    int dem1=0 ;
    for(int i=0 ; i<k ; i++){
      if(B[i]>=c){
        if(B[i]==c){
          dem1=dem1+1 ;
        }
        else {
          dem1=dem1+1+Math.abs(B[i]-c);
        }
      }
    }
    System.out.println(dem1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Log {
 class GIATRI {
   attribute x : int := 0;
   attribute y : int := 0;
}
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
     while (t > 0) do (     execute tinh() ; 
     t := t - 1 ) );
  static   operation tinh() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var B : Sequence(int) ; B := Integer.subrange(1,n + 1)->collect(0) ;
    var k : int ; k := 0 ;
    var dem : int ; dem := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (A[i+1] <= t) then (     dem := dem + 1 ) else (     B[k+1] := dem ; 
     dem := 0 ; 
     k := k + 1 ) ;  
     if (i = n - 1) then (     B[k+1] := dem ; 
     dem := 0 ; 
     k := k + 1 ) else skip )  ;     i := i + 1 ) ; 
    var dem1 : int ; dem1 := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     if (B[i+1] >= c) then (     if (B[i+1] = c) then (     dem1 := dem1 + 1 ) else (     dem1 := dem1 + 1 + if B[i+1] - c < 0 then -(B[i+1] - c) else B[i+1] - c endif ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dem1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int X=in.nextInt();
      int A=in.nextInt();
      int B=in.nextInt();
      if(B-A<=0)out.println("delicious");
      else if(B-A<=X)out.println("safe");
      else out.println("dangerous");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var X : int ; X := in.getCurrent()->toInteger() ;
     var A : int ; A := in.getCurrent()->toInteger() ;
     var B : int ; B := in.getCurrent()->toInteger() ;
     if (B - A <= 0) then     skip ; else     if (B - A <= X) then     skip else     skip ; ;  );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int nx=0,ny=0 ;
  static boolean check(String s,int p,int q){
    for(int i=0 ; i<s.length(); ++i){
      if(s.charAt(i)=='x')nx++;
      else ny++;
    }
    if((nx*ny)!=(p+q))return true ;
    else return false ;
  }
  public static String smallestPermutation(String s,int p,int q){
    if(check(s,p,q)==true){
      return "Impossible" ;
    }
    char tempArray[]=s.toCharArray();
    Arrays.sort(tempArray);
    String str=new String(tempArray);
    int a=nx*ny,b=0,i=0,j=0 ;
    if(a==p && b==q){
      return str ;
    }
    while(1>0){
      for(i=0 ; i<str.length()-1 ; ++i){
        if(str.charAt(i)=='x' && str.charAt(i+1)=='y')break ;
      }
      for(j=i ; j<str.length()-1 ; j++){
        if(str.charAt(j)=='x' && str.charAt(j+1)=='y'){
          StringBuilder sb=new StringBuilder(str);
          sb.setCharAt(j,str.charAt(j+1));
          sb.setCharAt(j+1,str.charAt(j));
          str=sb.toString();
          a--;
          b++;
          if(a==p && b==q){
            return str ;
          }
        }
      }
    }
  }
  public static void main(String[] args){
    String s="yxxyx" ;
    int p=3,q=3 ;
    System.out.print(smallestPermutation(s,p,q));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute nx : int := 0;
  static   operation check( s : String, p : int, q : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = 'x') then     nx := nx + 1 ; else     ny := ny + 1 ; )  ;     i := i + 1 ) ; 
     if ((nx * ny) /= (p + q)) then     return true else     return false );
  static   operation smallestPermutation( s : String, p : int, q : int) : String
  pre: true
  post: true
  activity: (     if (check(s, p, q) = true) then (     return "Impossible" ) else skip ; 
     var tempArray : Sequence(String) ; tempArray := s->characters() ;
    tempArray := tempArray->sort() ; 
    var str : String ; str := StringLib.newString(tempArray) ;
    var a : int ; a := nx * ny ;
    var b : int ; b := 0 ;
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
    if (a = p & b = q) then (     return str ) else skip ; 
    while (1 > 0) do (         i := 0 ; while i < str->size() - 1 do ( (     if (str->at(i+1) = 'x' & str->at(i + 1+1) = 'y') then     break else skip )  ;     i := i + 1 ) ; 
         j := i ; while j < str->size() - 1 do ( (     if (str->at(j+1) = 'x' & str->at(j + 1+1) = 'y') then (     var sb : String ; sb := StringLib.newString(str) ;
     sb := sb.setAt(j+1, str->at(j + 1+1)) ; 
    sb := sb.setAt(j + 1+1, str->at(j+1)) ; 
    str := sb+"" ; 
    a := a - 1 ; 
    b := b + 1 ; 
    if (a = p & b = q) then (     return str ) else skip ; 
 ) else skip )  ;     j := j + 1 ) ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "yxxyx" ;
     var p : int ; p := 3 ;
    var q : int ; q := 3 ;
     OclFile["System.out"].print(smallestPermutation(s, p, q)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class code {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int t=sc.nextInt();
    while(t-->0){
      solve();
    }
  }
  static void solve(){
    int n=sc.nextInt();
    ArrayList<Integer>a=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      a.add(sc.nextInt());
    }
    long ans=0 ;
    long x=a.get(0)*2 ;
    x-=1 ;
    for(int i=1 ; i<n ; i++){
      long temp=(a.get(i)% x);
      if(temp==0){
        ans+=(a.get(i)/x)-1 ;
      }
      else ans+=a.get(i)/x ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class code {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     a := a->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var x : long ; x := a->at(0+1) * 2 ;
    x := x-(1) ; 
        var i : int ; i := 1 ; while i < n do ( (     var temp : long ; temp := (a->at(i+1) mod x) ;
     if (temp = 0) then (     ans := ans+((a->at(i+1) / x) - 1) ) else     ans := ans+(a->at(i+1) / x) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class esep {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      int a=in.nextInt();
      long[] arr=new long[a];
      for(int j=0 ; j<a ; j++){
        arr[j]=in.nextLong();
      }
      Arrays.sort(arr);
      long min=arr[0];
      long summa=0 ;
      for(int j=0 ; j<arr.length ; j++){
        if(min*2-1<arr[j]){
          summa+=Math.ceil(1.0*arr[j]/((2*min-1)))-1 ;
        }
      }
      System.out.println(summa);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class esep {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var arr : Sequence(long) ; arr := Integer.subrange(1,a)->collect(0) ;
        var j : int ; j := 0 ; while j < a do ( (     arr[j+1] := in.getCurrent()->toLong() )  ;     j := j + 1 ) ; 
    arr := arr->sort() ; 
    var min : long ; min := arr[0+1] ;
    var summa : long ; summa := 0 ;
        var j : int ; j := 0 ; while j < arr->size() do ( (     if (min * 2 - 1 < arr[j+1]) then (     summa := summa+((1.0 * arr[j+1] / ((2 * min - 1)))->ceil() - 1) ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(summa) ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String args[])throws IOException {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int j=0 ; j<t ; j++){
      int n=sc.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      int min=a[0];
      for(int i=0 ; i<n ; i++)if(a[i]<=min)min=a[i];
      min=min*2-1 ;
      for(int i=0 ; i<n ; i++){
        if(a[i] % min!=0)a[i]=a[i]/min+1 ;
        else a[i]=a[i]/min ;
      }
      long count=0 ;
      for(int i=0 ; i<n ; i++)count+=a[i]-1 ;
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var min : int ; min := a[0+1] ;
        var i : int ; i := 0 ; while i < n do (     if (a[i+1] <= min) then     min := a[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    min := min * 2 - 1 ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] mod min /= 0) then     a[i+1] := a[i+1] / min + 1 ; else     a[i+1] := a[i+1] / min ; )  ;     i := i + 1 ) ; 
    var count : long ; count := 0 ;
        var i : int ; i := 0 ; while i < n do (     count := count+(a[i+1] - 1) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 )  ;     j := j + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Solution {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int T=fs.nextInt();
    for(int i=0 ; i<T ; i++){
      long N=fs.nextLong();
      Long[] A=new Long[(int)N];
      for(int j=0 ; j<N ; j++){
        A[j]=fs.nextLong();
      }
      Arrays.sort(A);
      long min=2*A[0]-1 ;
      long count=0 ;
      for(int j=0 ; j<N ; j++){
        long div=0 ;
        long mod=0 ;
        if(A[j] % min==0){
          div=A[j]/min ;
          if(div>=2){
            count+=div-1 ;
          }
        }
        else {
          div=A[j]/min ;
          mod=A[j] % min ;
          if(div>=1){
            count+=div ;
          }
        }
      }
      out.println(count);
    }
    out.close();
  }
  static long gcd(long a,long b){
    if(b==0){
      return a ;
    }
    else {
      return gcd(b,a % b);
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens())try {
        st=new StringTokenizer(br.readLine());
      }
      catch(IOException e){
      }
      return st.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var T : int ; T := fs.nextInt() ;
        var i : int ; i := 0 ; while i < T do ( (     var N : long ; N := fs.nextLong() ;
     var A : Sequence(long) ; A := Integer.subrange(1,N->oclAsType(int))->collect(null) ;
        var j : int ; j := 0 ; while j < N do ( (     A[j+1] := fs.nextLong() )  ;     j := j + 1 ) ; 
    A := A->sort() ; 
    var min : long ; min := 2 * A[0+1] - 1 ;
    var count : long ; count := 0 ;
        var j : int ; j := 0 ; while j < N do ( (     var div : long ; div := 0 ;
     var mod : long ; mod := 0 ;
     if (A[j+1] mod min = 0) then (     div := A[j+1] / min ; 
     if (div >= 2) then (     count := count+(div - 1) ) else skip ) else (     div := A[j+1] / min ; 
     mod := A[j+1] mod min ; 
     if (div >= 1) then (     count := count+(div) ) else skip ) )  ;     j := j + 1 ) ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else (     return gcd(b, a mod b) ) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do skip
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int i=sc.nextInt();
      if(i==0){
        break ;
      }
      int s=0 ;
      int sqr=(int)Math.floor(Math.sqrt((double)i));
      for(int j=1 ; j<=sqr ; j++){
        if((i!=j)&&(i % j==0)){
          s=s+j ;
          if((j!=1)&&(i!=j*j)){
            s=s+(i/j);
          }
        }
      }
      if(i==s){
        System.out.println("perfect number");
      }
      else {
        if(i<s){
          System.out.println("abundant number");
        }
        else {
          System.out.println("deficient number");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var i : int ; i := sc.getCurrent()->toInteger() ;
     if (i = 0) then (     break ) else skip ; 
    var s : int ; s := 0 ;
    var sqr : int ; sqr := ((i->oclAsType(double))->sqrt())->floor()->oclAsType(int) ;
        var j : int ; j := 1 ; while j <= sqr do ( (     if ((i /= j) & (i mod j = 0)) then (     s := s + j ; 
     if ((j /= 1) & (i /= j * j)) then (     s := s + (i / j) ) else skip ) else skip )  ;     j := j + 1 ) ; 
    if (i = s) then (     OclFile["System.out"].println("perfect number") ) else (     if (i < s) then (     OclFile["System.out"].println("abundant number") ) else (     OclFile["System.out"].println("deficient number") ) ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    try {
      System.setIn(new FileInputStream("src/aoj2101/input.txt"));
      System.setOut(new PrintStream(new FileOutputStream("src/aoj2101/result.txt")));
    }
    catch(FileNotFoundException e){
    }
    new Main().run();
  }
  long divisors(long n){
    long sum=0 ;
    for(long d=2 ; d*d<=n ; d++){
      if(n % d==0){
        sum+=d ;
        if(d*d!=n)sum+=n/d ;
      }
    }
    return sum+1 ;
  }
  Scanner sc ;
  void run(){
    sc=new Scanner(System.in);
    while(true){
      int N=sc.nextInt();
      if(N==0)break ;
      if(N==1){
        System.out.println("deficient number");
        continue ;
      }
      int s=(int)divisors(N);
      if(s>N){
        System.out.println("abundant number");
      }
      else if(s<N){
        System.out.println("deficient number");
      }
      else {
        System.out.println("perfect number");
      }
    }
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( setIn(OclFile.newOclFile_Read(OclFile.newOclFile("src/aoj2101/input.txt"))) ; 
 setOut(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("src/aoj2101/result.txt")))) )   catch (e : FileNotFoundException) do skip
     Main.newMain().run() );
   operation divisors( n : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var d : long ; d := 2 ; while d * d <= n do ( (     if (n mod d = 0) then (     sum := sum+(d) ; 
     if (d * d /= n) then     sum := sum+(n / d) ; else skip ) else skip )  ;     d := d + 1 ) ; 
     return sum + 1 );
   attribute sc : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then     break else skip ; 
    if (N = 1) then (     OclFile["System.out"].println("deficient number") ; 
     continue ) else skip ; 
    var s : int ; s := divisors(N)->oclAsType(int) ;
    if (s > N) then (     OclFile["System.out"].println("abundant number") ) else     if (s < N) then (     OclFile["System.out"].println("deficient number") ) else (     OclFile["System.out"].println("perfect number") ) ;  ;  
 ) );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int N=parseInt(line);
      if(N==0)break ;
      int sum=0 ;
      for(int i=1 ; i*i<=N ; i++){
        if(N % i==0){
          if(i*i==N)sum+=i ;
          else sum+=i+N/i ;
        }
      }
      sum-=N ;
      if(N==sum)System.out.println("perfect number");
      else if(N>sum)System.out.println("deficient number");
      else if(N<sum)System.out.println("abundant number");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var N : int ; N := parseInt(line) ;
     if (N = 0) then     break else skip ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 1 ; while i * i <= N do ( (     if (N mod i = 0) then (     if (i * i = N) then     sum := sum+(i) ; else     sum := sum+(i + N / i) ; ) else skip )  ;     i := i + 1 ) ; 
    sum := sum-(N) ; 
    if (N = sum) then     OclFile["System.out"].println("perfect number") else     if (N > sum) then     OclFile["System.out"].println("deficient number") else     if (N < sum) then     OclFile["System.out"].println("abundant number") ; else skip ; ;  ;  
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int n=parseInt(br.readLine());
    Map<Integer,Integer>P=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      StringTokenizer st=new StringTokenizer(br.readLine());
      int s,l,p ;
      s=parseInt(st.nextToken());
      l=parseInt(st.nextToken());
      p=parseInt(st.nextToken());
      for(int j=s ; j<=l ; j++){
        P.putIfAbsent(j,0);
        P.put(j,Math.max(P.get(j),p));
      }
    }
    int m=parseInt(br.readLine());
    StringBuilder ans=new StringBuilder();
    boolean notfound=false ;
    for(int i=0 ; i<m ; i++){
      int w=parseInt(br.readLine());
      int[] dp=new int[w+1];
      for(Map.Entry<Integer,Integer>p : P.entrySet()){
        for(int j=p.getKey(); j<=w ; j++){
          dp[j]=Math.max(dp[j],dp[j-p.getKey()]+p.getValue());
        }
      }
      if(dp[w]==0){
        notfound=true ;
        break ;
      }
      ans.append(dp[w]).append('\n');
    }
    if(notfound){
      System.out.println(-1);
    }
    else {
      System.out.print(ans.toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var n : int ; n := parseInt(br.readLine()) ;
    var P : Map(int,int) ; P := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
     var s : int ;
    var l : int ;
    var p : int ;
    s := (st.next() + "")->toInteger() ; 
    l := (st.next() + "")->toInteger() ; 
    p := (st.next() + "")->toInteger() ; 
        var j : int ; j := s ; while j <= l do ( (     if P->keys()->includes(j) then skip else P := P->union(Map{j |-> 0}) ; 
     P := P->union(Map{j |-> Set{P->at(j), p}->max()}) )  ;     j := j + 1 ) ; 
 )  ;     i := i + 1 ) ; 
    var m : int ; m := parseInt(br.readLine()) ;
    var ans : String ; ans := StringLib.newString() ;
    var notfound : boolean ; notfound := false ;
        var i : int ; i := 0 ; while i < m do ( (     var w : int ; w := parseInt(br.readLine()) ;
     var dp : Sequence(int) ; dp := Integer.subrange(1,w + 1)->collect(0) ;
    for (p : P->asSet()) do ( (         var j : int ; j := p.getKey() ; while j <= w do ( (     dp[j+1] := Set{dp[j+1], dp[j - p.getKey()+1] + p.getValue()}->max() )  ;     j := j + 1 ) )  ) ; 
    if (dp[w+1] = 0) then (     notfound := true ; 
     break ) else skip ; 
    ans := ans + StringLib.newString(dp[w+1]) + StringLib.newString('
') ; 
 )  ;     i := i + 1 ) ; 
    if (notfound) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].print(ans+"") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  int N ;
  ArrayList<Integer>numList ;
  void solve(){
    Scanner sc=new Scanner(System.in);
    while(true){
      N=sc.nextInt();
      if(N==0)break ;
      numList=new ArrayList<Integer>();
      for(int i=1 ; i*i<=N && i<N ; i++){
        if(N % i==0){
          if(! numList.contains(i))numList.add(i);
          if(N/i!=N && ! numList.contains(N/i))numList.add(N/i);
        }
      }
      long sum=0 ;
      for(int i=0 ; i<numList.size(); i++)sum+=numList.get(i);
      String ans="perfect number" ;
      if(sum>N){
        ans="abundant number" ;
      }
      else if(sum<N){
        ans="deficient number" ;
      }
      System.out.println(ans);
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute N : int;
   attribute numList : Sequence(int);
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     N := sc.getCurrent()->toInteger() ; 
     if (N = 0) then     break else skip ; 
    numList := Sequence{} ; 
        var i : int ; i := 1 ; while i * i <= N & i < N do ( (     if (N mod i = 0) then (     if (not(numList->includes(i))) then     numList := numList->including(i) ; else skip ; 
     if (N / i /= N & not(numList->includes(N / i))) then     numList := numList->including(N / i) ; else skip ) else skip )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < numList->size() do (     sum := sum+(numList->at(i+1)) ;  ;     i := i + 1 ) ; 
    var ans : String ; ans := "perfect number" ;
    if (sum > N) then (     ans := "abundant number" ) else     if (sum < N) then (     ans := "deficient number" ) else skip ; ;  
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.System.*;
import static java.lang.Math.max ;
import static java.lang.Math.min ;
import static java.lang.Math.*;
public class pre1 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int n=obj.nextInt(),a=obj.nextInt(),b=obj.nextInt(),c=0 ;
    int ans=0,arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=obj.nextInt();
    for(int i=0 ; i<n ; i++){
      if(arr[i]==1 && a>0)a--;
      else if(arr[i]==2 && b>0)b--;
      else if(arr[i]==1 && b>0){
        b--;
        c++;
      }
      else if(arr[i]==1 && c>0)c--;
      else ans+=arr[i];
    }
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre1 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var n : int ; n := obj.nextInt() ;
    var a : int ; a := obj.nextInt() ;
    var b : int ; b := obj.nextInt() ;
    var c : int ; c := 0 ;
    var ans : int ; ans := 0 ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := obj.nextInt() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 1 & a > 0) then     a := a - 1 ; else     if (arr[i+1] = 2 & b > 0) then     b := b - 1 else     if (arr[i+1] = 1 & b > 0) then (     b := b - 1 ; 
     c := c + 1 ) else     if (arr[i+1] = 1 & c > 0) then     c := c - 1 else     ans := ans+(arr[i+1]) ; ;  ;  ;  )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      int val=Divsum(n);
      if(n==val)System.out.println("perfect number");
      else if(n>val)System.out.println("deficient number");
      else System.out.println("abundant number");
    }
  }
  int Divsum(int x){
    if(x==1)return 0 ;
    int sum=1 ;
    for(int i=2 ; i*i<=x ; i++)if(x % i==0){
      sum+=i ;
      if(x/i!=i)sum+=x/i ;
    }
    return sum ;
  }
  public static void main(String[] args){
    new Main().run();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
     var val : int ; val := Divsum(n) ;
     if (n = val) then     OclFile["System.out"].println("perfect number") ; else     if (n > val) then     OclFile["System.out"].println("deficient number") else     OclFile["System.out"].println("abundant number") ; ;  )  ) );
   operation Divsum( x : int) : int
  pre: true
  post: true
  activity: (     if (x = 1) then     return 0 else skip ; 
     var sum : int ; sum := 1 ;
         var i : int ; i := 2 ; while i * i <= x do (     if (x mod i = 0) then (     sum := sum+(i) ; 
     if (x / i /= i) then     sum := sum+(x / i) ; else skip ) else skip ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.math.*;
import java.util.*;
public class B2 {
  public static void main(String[] args){
    FastReader fr=new FastReader();
    int n=fr.nextInt();
    int[] ia=new int[n];
    for(int i=0 ; i<n ; i++){
      ia[i]=fr.nextInt();
    }
    int sum=0 ;
    int living=n-1 ;
    for(int i=0 ; i<n ; i++){
      if(n-i-1==living){
        sum++;
      }
      if(n-i-1-ia[n-i-1]-1<living){
        living=n-i-1-ia[n-i-1]-1 ;
      }
    }
    System.out.println(sum);
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  FastReader(){
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  String next(){
    while(st==null || ! st.hasMoreTokens()){
      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 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fr : FastReader ; fr := FastReader.newFastReader() ;
     var n : int ; n := fr.nextInt() ;
    var ia : Sequence(int) ; ia := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ia[i+1] := fr.nextInt() )  ;     i := i + 1 ) ; 
    var sum : int ; sum := 0 ;
    var living : int ; living := n - 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (n - i - 1 = living) then (     sum := sum + 1 ) else skip ; 
     if (n - i - 1 - ia[n - i - 1+1] - 1 < living) then (     living := n - i - 1 - ia[n - i - 1+1] - 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] L=new int[n];
    for(int i=0 ; i<n ; i++){
      L[i]=sc.nextInt();
    }
    int alive=0 ;
    int reach=n ;
    for(int j=n-1 ; j>=0 ; j--){
      if(j<reach)alive++;
      reach=Math.min(reach,j-L[j]);
    }
    System.out.println(alive);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var L : Sequence(int) ; L := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     L[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var alive : int ; alive := 0 ;
    var reach : int ; reach := n ;
        var j : int ; j := n - 1 ; while j >= 0 do ( (     if (j < reach) then     alive := alive + 1 ; else skip ; 
     reach := Set{reach, j - L[j+1]}->min() )  ;     j := j - 1 ) ; 
    OclFile["System.out"].println(alive) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Wrath {
  public static void main(String args[]){
    Scanner cin=new Scanner(System.in);
    int n=cin.nextInt();
    int[] arr=new int[n];
    int ans=0 ;
    int dead=n ;
    for(int i=0 ; i<n ; i++){
      arr[i]=cin.nextInt();
    }
    for(int i=n-1 ; i>=0 ; i--){
      if(i-arr[i]<dead){
        if(dead>i)ans++;
        dead=i-arr[i];
        if(dead<0)break ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Wrath {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := cin.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var ans : int ; ans := 0 ;
    var dead : int ; dead := n ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := cin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (i - arr[i+1] < dead) then (     if (dead > i) then     ans := ans + 1 ; else skip ; 
     dead := i - arr[i+1] ; 
     if (dead < 0) then     break else skip ) else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(in.readLine());
    String[] temp=in.readLine().split(" ");
    int[] len=new int[n];
    for(int i=0 ; i<n ; i++){
      len[i]=Integer.parseInt(temp[i]);
    }
    int survive=1 ;
    int extend=n-1 ;
    for(int i=n-1 ; i>=0 ; i--){
      if(extend>i)survive++;
      extend=Math.min(i-len[i],extend);
    }
    System.out.println(survive);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (in.readLine())->toInteger() ;
    var temp : Sequence(String) ; temp := in.readLine()->split(" ") ;
    var len : Sequence(int) ; len := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     len[i+1] := (temp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    var survive : int ; survive := 1 ;
    var extend : int ; extend := n - 1 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (extend > i) then     survive := survive + 1 ; else skip ; 
     extend := Set{i - len[i+1], extend}->min() )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(survive) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class B892Wrath {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=scan.nextInt();
    }
    int last=n-1 ;
    int curr=last ;
    int count=0 ;
    for(int i=n-1 ; i>0 ; i--){
      if(i<last)last=i ;
      curr=i-arr[i];
      if(curr<0)curr=0 ;
      if(curr<last){
        count+=last-curr ;
        last=curr ;
      }
      if(last<=0)break ;
    }
    System.out.print(n-count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B892Wrath {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var last : int ; last := n - 1 ;
    var curr : int ; curr := last ;
    var count : int ; count := 0 ;
        var i : int ; i := n - 1 ; while i > 0 do ( (     if (i < last) then     last := i ; else skip ; 
     curr := i - arr[i+1] ; 
    if (curr < 0) then     curr := 0 ; else skip ; 
    if (curr < last) then (     count := count+(last - curr) ; 
     last := curr ) else skip ; 
    if (last <= 0) then     break else skip ; 
 )  ;     i := i - 1 ) ; 
    OclFile["System.out"].print(n - count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
  static int Divison(int a[],int n){
    int maxi=Integer.MIN_VALUE,mini=Integer.MAX_VALUE ;
    for(int i=0 ; i<n ; i++){
      maxi=Math.max(a[i],maxi);
      mini=Math.min(a[i],mini);
    }
    return maxi/mini ;
  }
  public static void main(String[] args)throws java.lang.Exception {
    int a[]={
      3,7,9,3,11 };
      int n=a.length ;
      System.out.print(Divison(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Divison( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var maxi : int ; maxi := -2147483648 ;
    var mini : int ; mini := 2147483647 ;
         var i : int ; i := 0 ; while i < n do ( (     maxi := Set{a[i+1], maxi}->max() ; 
     mini := Set{a[i+1], mini}->min() )  ;     i := i + 1 ) ; 
     return maxi / mini );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{3,7,9,3,11} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].print(Divison(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String to_upper(char[] in){
    for(int i=0 ; i<in.length ; i++){
      if('a'<=in[i] & in[i]<='z'){
        in[i]=(char)(in[i]-'a'+'A');
      }
    }
    return String.valueOf(in);
  }
  public static void main(String[] args){
    String str="geeksforgeeks" ;
    System.out.println(to_upper(str.toCharArray()));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation to_upper( in : Sequence(String)) : String
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < in->size() do ( (     if ('a' <= in[i+1] & in[i+1] <= 'z') then (     in[i+1] := (in[i+1] - ('a')->char2byte() + 'A')->oclAsType(String) ) else skip )  ;     i := i + 1 ) ; 
     return ((in) + "") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "geeksforgeeks" ;
     OclFile["System.out"].println(to_upper(str->characters())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    final int n=sc.nextInt();
    int[][] melody=new int[n][3];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<3 ; j++){
        melody[i][j]=sc.nextInt();
      }
    }
    int[] dp=new int[393+1];
    Arrays.fill(dp,-1);
    dp[0]=0 ;
    for(int i=0 ; i<n ; i++){
      for(int len=melody[i][0]; len<=melody[i][1]; len++){
        for(int j=0 ; j<=393-len ; j++){
          if(dp[j]>=0){
            dp[j+len]=Math.max(dp[j+len],dp[j]+melody[i][2]);
          }
        }
      }
    }
    final int m=sc.nextInt();
    int[] array=new int[m];
    for(int i=0 ; i<m ; i++){
      array[i]=dp[sc.nextInt()];
      if(array[i]==-1){
        System.out.println(-1);
        return ;
      }
    }
    for(int num : array){
      System.out.println(num);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var melody : Sequence(Sequence(int)) ; melody := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < 3 do ( (     melody[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,393 + 1)->collect(0) ;
    dp := dp->collect(-1) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (         var len : int ; len := melody[i+1][0+1] ; while len <= melody[i+1][1+1] do ( (         var j : int ; j := 0 ; while j <= 393 - len do ( (     if (dp[j+1] >= 0) then (     dp[j + len+1] := Set{dp[j + len+1], dp[j+1] + melody[i+1][2+1]}->max() ) else skip )  ;     j := j + 1 ) )  ;     len := len + 1 ) )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < m do ( (     array[i+1] := dp[sc.getCurrent()->toInteger()+1] ; 
     if (array[i+1] = -1) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
    for (num : array) do ( (     OclFile["System.out"].println(num) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class TaskA {
  private static final String TEST_NAME="A-large" ;
  private static final String INPUT_FILE=TEST_NAME+".in" ;
  private static final String OUTPUT_FILE=TEST_NAME+".out" ;
  private static Scanner in ;
  private static PrintWriter out ;
  public static void main(String[] args)throws Exception {
    in=new Scanner(new File(INPUT_FILE));
    out=new PrintWriter(OUTPUT_FILE);
    int testCasesNum=in.nextInt();
    for(int i=0 ; i<testCasesNum ; ++i){
      solveTestCase(i+1);
    }
    in.close();
    out.close();
  }
  private static void reverse(int[] a){
    int med=a.length/2 ;
    int len=a.length ;
    for(int i=0 ; i<med ; ++i){
      int t=a[i];
      a[i]=a[len-1-i];
      a[len-1-i]=t ;
    }
  }
  private static void solveTestCase(int testCaseID){
    int P=in.nextInt();
    int K=in.nextInt();
    int L=in.nextInt();
    int[] freq=new int[L];
    for(int i=0 ; i<L ; ++i){
      freq[i]=in.nextInt();
    }
    Arrays.sort(freq);
    reverse(freq);
    int[] keys=new int[K];
    int curKey=-1 ;
    long result=0 ;
    for(int i=0 ; i<L ; ++i){
      curKey=(curKey+1)% K ;
      keys[curKey]+=1 ;
      result+=keys[curKey]*freq[i];
    }
    out.println(String.format("Case #%d: %d",testCaseID,result));
  }
}
------------------------------------------------------------
OCL File:
---------
 class TaskA {
  static    attribute TEST_NAME : String := "A-large";
  static    attribute INPUT_FILE : String := TEST_NAME + ".in";
  static    attribute OUTPUT_FILE : String := TEST_NAME + ".out";
  static   attribute in : OclFile;
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile(INPUT_FILE)) ; 
     out := OclFile.newOclFile_Write(OclFile.newOclFile(OUTPUT_FILE)) ; 
    var testCasesNum : int ; testCasesNum := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < testCasesNum do ( (     execute solveTestCase(i + 1) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation reverse( a : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var med : int ; med := a->size() / 2 ;
     var len : int ; len := a->size() ;
         var i : int ; i := 0 ; while i < med do ( (     var t : int ; t := a[i+1] ;
     a[i+1] := a[len - 1 - i+1] ; 
     a[len - 1 - i+1] := t )  ;     i := i + 1 ) );
  static   operation solveTestCase( testCaseID : int) : void
  pre: true
  post: true
  activity: (     var P : int ; P := in.getCurrent()->toInteger() ;
     var K : int ; K := in.getCurrent()->toInteger() ;
    var L : int ; L := in.getCurrent()->toInteger() ;
    var freq : Sequence(int) ; freq := Integer.subrange(1,L)->collect(0) ;
        var i : int ; i := 0 ; while i < L do ( (     freq[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    freq := freq->sort() ; 
    execute reverse(freq) ; 
    var keys : Sequence(int) ; keys := Integer.subrange(1,K)->collect(0) ;
    var curKey : int ; curKey := -1 ;
    var result : long ; result := 0 ;
        var i : int ; i := 0 ; while i < L do ( (     curKey := (curKey + 1) mod K ; 
     keys[curKey+1] := keys[curKey+1]+(1) ; 
     result := result+(keys[curKey+1] * freq[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class a {
  a(){
    try {
      File f=new File("A-large.in");
      BufferedReader input=new BufferedReader(new FileReader(f));
      BufferedWriter out=new BufferedWriter(new FileWriter("large.out"));
      int nrtests=Integer.parseInt(input.readLine());
      for(int nrt=0 ; nrt<nrtests ; nrt++){
        String[] spl=input.readLine().split(" ");
        long p=Integer.parseInt(spl[0]);
        long k=Integer.parseInt(spl[1]);
        long l=Integer.parseInt(spl[2]);
        spl=input.readLine().split(" ");
        int n=spl.length ;
        long[] v=new long[n];
        for(int i=0 ; i<n ; i++)v[i]=Long.parseLong(spl[i]);
        Arrays.sort(v);
        String ans="Impossible" ;
        if(p*k>=l){
          long rez=0 ;
          for(long pas=0,poz=n-1 ; pas<p ; pas++)for(long j=0 ; j<k ; j++,poz--)if(poz>=0)rez+=(long)(pas+1)*(long)v[(int)poz];
          ans=""+rez ;
        }
        out.write("Case #"+(nrt+1)+": "+ans+"\n");
      }
      out.close();
    }
    catch(IOException e){
    }
  }
  public static void main(String[] args){
    new a();
  }
}
------------------------------------------------------------
OCL File:
---------
 class a {
   static operation newa() : a
  pre: true
  post: true
  activity:
  ( var self : a ;
    self := createa();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     var f : OclFile ; f := OclFile("A-large.in") ;
     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(f)) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("large.out"))) ;
    var nrtests : int ; nrtests := (input.readLine())->toInteger() ;
        var nrt : int ; nrt := 0 ; while nrt < nrtests do ( (     var spl : Sequence(String) ; spl := input.readLine()->split(" ") ;
     var p : long ; p := (spl[0+1])->toInteger() ;
    var k : long ; k := (spl[1+1])->toInteger() ;
    var l : long ; l := (spl[2+1])->toInteger() ;
    spl := input.readLine()->split(" ") ; 
    var n : int ; n := spl->size() ;
    var v : Sequence(long) ; v := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     v[i+1] := (spl[i+1])->toLong() ;  ;     i := i + 1 ) ; 
    v := v->sort() ; 
    var ans : String ; ans := "Impossible" ;
    if (p * k >= l) then (     var rez : long ; rez := 0 ;
         var pas : long ; pas := 0 ;
    var poz : long ; poz := n - 1 ; while pas < p do (         var j : long ; j := 0 ; while j < k do (     if (poz >= 0) then     rez := rez+((pas + 1)->oclAsType(long) * v[poz->oclAsType(int)+1]->oclAsType(long)) ; else skip ;  ;     j := j + 1 ;     poz := poz - 1 ) ;  ;     pas := pas + 1 ) ; 
     ans := "" + rez ) else skip ; 
    skip ; 
 )  ;     nrt := nrt + 1 ) ; 
    skip ; 
 )   catch (e : IOException) do skip
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( a.newa() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int a=in.nextInt();
    int b=in.nextInt();
    int num=0 ;
    int c=0 ;
    for(int i=0 ; i<n ; i++){
      int x=in.nextInt();
      if(x==1){
        if(a!=0)a--;
        else if(b!=0){
          b--;
          c++;
        }
        else if(c!=0)c--;
        else num++;
      }
      else {
        if(b>=1)b-=1 ;
        else num+=2 ;
      }
    }
    System.out.println(num);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : int ; a := in.getCurrent()->toInteger() ;
    var b : int ; b := in.getCurrent()->toInteger() ;
    var num : int ; num := 0 ;
    var c : int ; c := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     if (x = 1) then (     if (a /= 0) then     a := a - 1 ; else     if (b /= 0) then (     b := b - 1 ; 
     c := c + 1 ) else     if (c /= 0) then     c := c - 1 else     num := num + 1 ; ;  ;  ) else (     if (b >= 1) then     b := b-(1) ; else     num := num+(2) ; ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(num) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileOutputStream ;
import java.io.PrintWriter ;
import java.io.IOException ;
import java.util.Set ;
import java.util.HashSet ;
import java.util.Collections ;
import java.util.Arrays ;
public class A {
  public static void main(String[] args){
    try {
      Scanner scanner=new Scanner("c:/input.txt");
      FileOutputStream out=new FileOutputStream("c:/output.txt");
      int numberOfCases ;
      numberOfCases=scanner.nextInt();
      PrintWriter wr=new PrintWriter(out);
      for(int i=0 ; i<numberOfCases ; i++){
        doCase(i+1,scanner,wr);
      }
      wr.close();
      out.close();
    }
    catch(IOException e){
      System.out.println("Error: "+e);
    }
  }
  private static void doCase(int caseNumber,Scanner sc,PrintWriter wr)throws IOException {
    int P,K,L ;
    P=sc.nextInt();
    K=sc.nextInt();
    L=sc.nextInt();
    int[] freq=new int[L];
    for(int i=0 ; i<L ; i++){
      freq[i]=sc.nextInt();
    }
    Arrays.sort(freq);
    long result=0 ;
    int keyPress=1 ;
    int keyCounter=0 ;
    for(int i=L-1 ; i>=0 ; i--){
      if(++keyCounter>K){
        keyCounter=1 ;
        keyPress++;
      }
      result+=freq[i]*keyPress ;
    }
    wr.println("Case #"+caseNumber+": "+result);
    System.out.println("Case #"+caseNumber+": "+result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile.newOclFile("c:/input.txt")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("c:/output.txt")) ;
    var numberOfCases : int ;
    numberOfCases := scanner.getCurrent()->toInteger() ; 
    var wr : OclFile ; wr := OclFile.newOclFile_Write(out) ;
        var i : int ; i := 0 ; while i < numberOfCases do ( (     execute doCase(i + 1, scanner, wr) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 )   catch (e : IOException) do (     OclFile["System.out"].println("Error: " + e) )
 );
  static   operation doCase( caseNumber : int, sc : OclFile, wr : OclFile) : void
  pre: true
  post: true
  activity: (     var P : int ;
    var K : int ;
    var L : int ;
     P := sc.nextInt() ; 
    K := sc.nextInt() ; 
    L := sc.nextInt() ; 
    var freq : Sequence(int) ; freq := Integer.subrange(1,L)->collect(0) ;
        var i : int ; i := 0 ; while i < L do ( (     freq[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    freq := freq->sort() ; 
    var result : long ; result := 0 ;
    var keyPress : int ; keyPress := 1 ;
    var keyCounter : int ; keyCounter := 0 ;
        var i : int ; i := L - 1 ; while i >= 0 do ( (     if ((keyCounter + 1) > K) then (     keyCounter := 1 ; 
     keyPress := keyPress + 1 ) else skip ; 
     result := result+(freq[i+1] * keyPress) )  ;     i := i - 1 ) ; 
    skip ; 
    OclFile["System.out"].println("Case #" + caseNumber + ": " + result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package indy.codejam ;
import java.io.*;
import java.text.DecimalFormat ;
import java.text.DecimalFormatSymbols ;
import java.util.*;
import java.math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
import static java.lang.Double.parseDouble ;
import static java.lang.Float.parseFloat ;
import static java.lang.Long.parseLong ;
import static java.lang.Integer.parseInt ;
public class TextMessagingOutrage {
  public static void main(String[] args)throws Exception {
    String name="A-large" ;
    String path="C:/codejam/" ;
    Scanner sc=new Scanner(new File(path+name+".in"));
    PrintWriter pw=new PrintWriter(path+name+".out");
    int N=sc.nextInt();
    for(int z=1 ; z<=N ; z++){
      int P=sc.nextInt();
      int K=sc.nextInt();
      int L=sc.nextInt();
      long[] f=new long[L];
      for(int i=0 ; i<L ; i++){
        f[i]=sc.nextLong();
      }
      sort(f);
      long res=0 ;
      for(int i=0 ; i<L ; i++){
        long r=i/K+1 ;
        res+=f[L-1-i]*r ;
      }
      pw.print("Case #"+z+": "+res);
      pw.println();
      pw.flush();
    }
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class TextMessagingOutrage {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var name : String ; name := "A-large" ;
     var path : String ; path := "C:/codejam/" ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile(path + name + ".in")) ;
    var pw : OclFile ; pw := OclFile.newOclFile_Write(path + name + ".out") ;
    var N : int ; N := sc.getCurrent()->toInteger() ;
        var z : int ; z := 1 ; while z <= N do ( (     var P : int ; P := sc.getCurrent()->toInteger() ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    var L : int ; L := sc.getCurrent()->toInteger() ;
    var f : Sequence(long) ; f := Integer.subrange(1,L)->collect(0) ;
        var i : int ; i := 0 ; while i < L do ( (     f[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    execute sort(f) ; 
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < L do ( (     var r : long ; r := i / K + 1 ;
     res := res+(f[L - 1 - i+1] * r) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 )  ;     z := z + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package gcj ;
import java.io.BufferedReader ;
import java.io.FileInputStream ;
import java.io.FileNotFoundException ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class MainA {
  public static void reverse(int[] p){
    int i=0,j=p.length-1 ;
    while(i<j){
      int a=p[i];
      p[i]=p[j];
      p[j]=a ;
      i++;
      j--;
    }
  }
  public static void main(String[] args)throws NumberFormatException,IOException {
    BufferedReader cin=new BufferedReader(new InputStreamReader(new FileInputStream("D:\\topcoder\\eclipse-workspace\\ACM\\gcj\\A-small.in")));
    PrintWriter out=new PrintWriter("D:\\topcoder\\eclipse-workspace\\ACM\\gcj\\Aout.txt");
    int testcase=Integer.parseInt(cin.readLine());
    for(int tst=1 ; tst<=testcase ; tst++){
      int P,K,L ;
      StringTokenizer st=new StringTokenizer(cin.readLine());
      P=Integer.parseInt(st.nextToken());
      K=Integer.parseInt(st.nextToken());
      L=Integer.parseInt(st.nextToken());
      int[] hits=new int[L];
      st=new StringTokenizer(cin.readLine());
      for(int i=0 ; i<L ; i++)hits[i]=Integer.parseInt(st.nextToken());
      Arrays.sort(hits);
      reverse(hits);
      long res=0 ;
      for(int i=0 ; i<hits.length ; i++){
        res+=(i/K+1)*hits[i];
      }
      out.println("Case #"+tst+": "+res);
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class MainA {
  static   operation reverse( p : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var j : int ; j := p->size() - 1 ;
     while (i < j) do (     var a : int ; a := p[i+1] ;
     p[i+1] := p[j+1] ; 
    p[j+1] := a ; 
    i := i + 1 ; 
    j := j - 1 ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("D:\\topcoder\\eclipse-workspace\\ACM\\gcj\\A-small.in")))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile("D:\\topcoder\\eclipse-workspace\\ACM\\gcj\\Aout.txt")) ;
    var testcase : int ; testcase := (cin.readLine())->toInteger() ;
        var tst : int ; tst := 1 ; while tst <= testcase do ( (     var P : int ;
    var K : int ;
    var L : int ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(cin.readLine()) ;
    P := (st.next())->toInteger() ; 
    K := (st.next())->toInteger() ; 
    L := (st.next())->toInteger() ; 
    var hits : Sequence(int) ; hits := Integer.subrange(1,L)->collect(0) ;
    st := OclIterator.newOclIterator_String(cin.readLine()) ; 
        var i : int ; i := 0 ; while i < L do (     hits[i+1] := (st.next())->toInteger() ;  ;     i := i + 1 ) ; 
    hits := hits->sort() ; 
    execute reverse(hits) ; 
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < hits->size() do ( (     res := res+((i / K + 1) * hits[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
 )  ;     tst := tst + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.util.*;
public class Main {
  static class Pair {
    int a ;
    int b ;
    public Pair(int a,int b){
      this.a=a ;
      this.b=b ;
    }
  }
  static class SortA implements Comparator<Pair>{
    public int compare(Pair s1,Pair s2){
      if(s1.a>s2.a){
        return-1 ;
      }
      else if(s1.a<s2.a){
        return 1 ;
      }
      return 0 ;
    }
  }
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int z=0 ; z<t ; z++){
      long n=sc.nextLong();
      long m=sc.nextLong();
      int a[]=new int[(int)n];
      PriorityQueue<Pair>pq=new PriorityQueue<>(new SortA());
      for(int i=0 ; i<a.length ; i++){
        a[i]=sc.nextInt();
      }
      long ans=0 ;
      long ans1=-1 ;
      long s=0 ;
      for(int i=0 ; i<a.length ; i++){
        s=s+a[i];
        pq.add(new Pair(a[i],i));
        if(s>m){
          if(ans1==-1){
            ans=pq.poll().b ;
            s=s-ans ;
            ans1=0 ;
          }
        }
      }
      if(ans1==-1){
        System.out.println(0);
        continue ;
      }
      ans++;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Pair {
   attribute a : int;
   attribute b : int;
   static operation newPair( a : int, b : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(a, b);
    return self );
  operation initialise( a : int, b : int) : void
  pre: true  post: true
  activity: (     self.a := a ; 
     self.b := b );
}
  static class SortA implements Function(<Map>,(<Map>,boolean)) {
   operation compare( s1 : Map, s2 : Map) : int
  pre: true
  post: true
  activity: (     if (s1.a > s2.a) then (     return -1 ) else     if (s1.a < s2.a) then (     return 1 ) else skip ; ;  
     return 0 );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var z : int ; z := 0 ; while z < t do ( (     var n : long ; n := sc.getCurrent()->toLong() ;
     var m : long ; m := sc.getCurrent()->toLong() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n->oclAsType(int))->collect(0) ;
    var pq : Sequence(Map) ; pq := Sequence{}->union(SortA.newSortA()) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var ans1 : long ; ans1 := -1 ;
    var s : long ; s := 0 ;
        var i : int ; i := 0 ; while i < a->size() do ( (     s := s + a[i+1] ; 
     pq := pq->including(Map(a[i+1], i)) ; 
     if (s > m) then (     if (ans1 = -1) then (     ans := pq->min().b ; 
     s := s - ans ; 
     ans1 := 0 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (ans1 = -1) then (     OclFile["System.out"].println(0) ; 
     continue ) else skip ; 
    ans := ans + 1 ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     z := z + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B_Verse_For_Santa {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int s=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; ++i){
        a[i]=sc.nextInt();
      }
      System.out.println(solve(a,s));
    }
    sc.close();
  }
  static int solve(int[] a,int s){
    int n=a.length ;
    int leftMaxIndex=-1 ;
    int[] leftMaxIndices=new int[n];
    for(int i=0 ; i<leftMaxIndices.length ; ++i){
      if(leftMaxIndex==-1 || a[i]>a[leftMaxIndex]){
        leftMaxIndex=i ;
      }
      leftMaxIndices[i]=leftMaxIndex ;
    }
    long prefixSum=0 ;
    long[] prefixSums=new long[n];
    for(int i=0 ; i<prefixSums.length ; ++i){
      prefixSum+=a[i];
      prefixSums[i]=prefixSum ;
    }
    for(int i=n-1 ; ; --i){
      if(prefixSums[i]<=s){
        return 0 ;
      }
      if(prefixSums[i]-a[leftMaxIndices[i] ]<=s){
        return leftMaxIndices[i]+1 ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Verse_For_Santa {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s : int ; s := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solve(a, s)) ; 
 )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : Sequence(int), s : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := a->size() ;
     var leftMaxIndex : int ; leftMaxIndex := -1 ;
    var leftMaxIndices : Sequence(int) ; leftMaxIndices := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < leftMaxIndices->size() do ( (     if (leftMaxIndex = -1 or a[i+1] > a[leftMaxIndex+1]) then (     leftMaxIndex := i ) else skip ; 
     leftMaxIndices[i+1] := leftMaxIndex )  ;     i := i + 1 ) ; 
    var prefixSum : long ; prefixSum := 0 ;
    var prefixSums : Sequence(long) ; prefixSums := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < prefixSums->size() do ( (     prefixSum := prefixSum+(a[i+1]) ; 
     prefixSums[i+1] := prefixSum )  ;     i := i + 1 ) ; 
        var i : int ; i := n - 1 ; while true do ( (     if (prefixSums[i+1] <= s) then (     return 0 ) else skip ; 
     if (prefixSums[i+1] - a[leftMaxIndices[i+1]+1] <= s) then (     return leftMaxIndices[i+1] + 1 ) else skip )  ;     i := i - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class _17_Verse_For_Santa {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int test=Integer.parseInt(sc.nextLine());
    for(int i=0 ; i<test ; i++){
      String inputSplit[]=sc.nextLine().split(" ");
      int n=Integer.parseInt(inputSplit[0]);
      int s=Integer.parseInt(inputSplit[1]);
      String ar[]=sc.nextLine().split(" ");
      int sum=0 ;
      int index=0 ;
      int max=0 ;
      for(int j=0 ; j<n ; j++){
        int val=Integer.parseInt(ar[j]);
        sum+=val ;
        if(max<val){
          max=val ;
          index=j ;
        }
        if(sum>s){
          System.out.println(index+1);
          break ;
        }
      }
      if(sum<=s){
        System.out.println("0");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _17_Verse_For_Santa {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := (sc.nextLine())->toInteger() ;
         var i : int ; i := 0 ; while i < test do ( (     var inputSplit : Sequence(String) ; inputSplit := sc.nextLine()->split(" ") ;
     var n : int ; n := (inputSplit[0+1])->toInteger() ;
    var s : int ; s := (inputSplit[1+1])->toInteger() ;
    var ar : Sequence(String) ; ar := sc.nextLine()->split(" ") ;
    var sum : int ; sum := 0 ;
    var index : int ; index := 0 ;
    var max : int ; max := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     var val : int ; val := (ar[j+1])->toInteger() ;
     sum := sum+(val) ; 
     if (max < val) then (     max := val ; 
     index := j ) else skip ; 
     if (sum > s) then (     OclFile["System.out"].println(index + 1) ; 
     break ) else skip )  ;     j := j + 1 ) ; 
    if (sum <= s) then (     OclFile["System.out"].println("0") ) else skip ; 
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class VerseForSanta {
  private static Scanner s=new Scanner(System.in);
  private static void solve(){
    int n=s.nextInt(),secs=s.nextInt();
    long max=Long.MIN_VALUE,maxIndex=-1,sum=0 ;
    long[] arr=new long[n];
    int totalSum=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=s.nextInt();
      totalSum+=arr[i];
    }
    for(int i=0 ; i<n ; i++){
      sum+=arr[i];
      if(max<arr[i]){
        max=arr[i];
        maxIndex=i ;
      }
      if(sum>secs){
        sum-=max ;
        break ;
      }
    }
    System.out.println(totalSum==sum ? 0 : maxIndex+1);
  }
  public static void main(String[] args){
    int t=s.nextInt();
    while(t-->0){
      solve();
    }
    s.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class VerseForSanta {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := s.getCurrent()->toInteger() ;
    var secs : int ; secs := s.getCurrent()->toInteger() ;
     var max : long ; max := "-9223372036854775808"->toLong() ;
    var maxIndex : long ; maxIndex := -1 ;
    var sum : long ; sum := 0 ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
    var totalSum : int ; totalSum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := s.getCurrent()->toInteger() ; 
     totalSum := totalSum+(arr[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(arr[i+1]) ; 
     if (max < arr[i+1]) then (     max := arr[i+1] ; 
     maxIndex := i ) else skip ; 
     if (sum > secs) then (     sum := sum-(max) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if totalSum = sum then 0 else maxIndex + 1 endif) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := s.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve() ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    int[] dp=new int[394];
    Arrays.fill(dp,-1);
    dp[0]=0 ;
    for(int i=0 ; i<N ; ++i){
      int s=sc.nextInt();
      int l=sc.nextInt();
      int p=sc.nextInt();
      for(int j=0 ; j<dp.length-s ; ++j){
        if(dp[j]==-1)continue ;
        for(int k=s ; k<=l && j+k<dp.length ; ++k){
          dp[j+k]=Math.max(dp[j+k],dp[j]+p);
        }
      }
    }
    int M=sc.nextInt();
    int[] ans=new int[M];
    for(int i=0 ; i<M ; ++i){
      ans[i]=dp[sc.nextInt()];
      if(ans[i]==-1){
        System.out.println(-1);
        return ;
      }
    }
    for(int i=0 ; i<M ; ++i){
      System.out.println(ans[i]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var dp : Sequence(int) ; dp := Integer.subrange(1,394)->collect(0) ;
    dp := dp->collect(-1) ; 
    dp[0+1] := 0 ; 
        var i : int ; i := 0 ; while i < N do ( (     var s : int ; s := sc.getCurrent()->toInteger() ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
     var p : int ; p := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < dp->size() - s do ( (     if (dp[j+1] = -1) then     continue else skip ; 
         var k : int ; k := s ; while k <= l & j + k < dp->size() do ( (     dp[j + k+1] := Set{dp[j + k+1], dp[j+1] + p}->max() )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     ans[i+1] := dp[sc.getCurrent()->toInteger()+1] ; 
     if (ans[i+1] = -1) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     OclFile["System.out"].println(ans[i+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.parseInt(br.readLine());
    while(t-->0){
      String str[]=br.readLine().split(" ");
      int n=Integer.parseInt(str[0]);
      long s=Long.parseLong(str[1]);
      long a[]=new long[n];
      int i ;
      String h[]=br.readLine().split(" ");
      for(i=0 ; i<n ; i++)a[i]=Long.parseLong(h[i]);
      TreeMap<Long,Integer>tree=new TreeMap<>();
      long sum=0 ;
      for(i=0 ; i<n ; i++){
        sum+=a[i];
        tree.put(sum,i);
      }
      int ans=-1 ;
      if(sum<=s){
        System.out.println(0);
        continue ;
      }
      else {
        long curr=0 ;
        long res=0 ;
        long max=Integer.MIN_VALUE ;
        int pos=-1 ;
        for(i=0 ; i<n ; i++){
          curr+=a[i];
          if(a[i]>max){
            max=a[i];
            pos=i ;
          }
          if(curr-max<=s){
            ans=pos ;
          }
        }
        System.out.println(ans+1);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (br.readLine())->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
     var n : int ; n := (str[0+1])->toInteger() ;
    var s : long ; s := (str[1+1])->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var i : int ;
    var h : Sequence(String) ; h := br.readLine()->split(" ") ;
        i := 0 ; while i < n do (     a[i+1] := (h[i+1])->toLong() ;  ;     i := i + 1 ) ; 
    var tree : Map(long,int) ; tree := Map{} ;
    var sum : long ; sum := 0 ;
        i := 0 ; while i < n do ( (     sum := sum+(a[i+1]) ; 
     tree := tree->union(Map{sum |-> i}) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := -1 ;
    if (sum <= s) then (     OclFile["System.out"].println(0) ; 
     continue ) else (     var curr : long ; curr := 0 ;
     var res : long ; res := 0 ;
    var max : long ; max := -2147483648 ;
    var pos : int ; pos := -1 ;
        i := 0 ; while i < n do ( (     curr := curr+(a[i+1]) ; 
     if (a[i+1] > max) then (     max := a[i+1] ; 
     pos := i ) else skip ; 
     if (curr - max <= s) then (     ans := pos ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans + 1) ; 
 ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findOddPair(int A[],int N){
    int i,count=0 ;
    for(i=0 ; i<N ; i++){
      if(A[i] % 2==0)count++;
    }
    return count*(N-count);
  }
  public static void main(String[] arg){
    int a[]={
      5,4,7,2,1 };
      int n=a.length ;
      System.out.println(findOddPair(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findOddPair( A : Sequence(int), N : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var count : int ; count := 0 ;
         i := 0 ; while i < N do ( (     if (A[i+1] mod 2 = 0) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count * (N - count) );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{5,4,7,2,1} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(findOddPair(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static public int LongestSubarray(int arr[],int n,int k){
    int count=1 ;
    int max_length=1 ;
    int prev_mod=arr[0] % k ;
    for(int i=1 ; i<n ; i++){
      int curr_mod=arr[i] % k ;
      if(curr_mod==prev_mod){
        count++;
      }
      else {
        max_length=Math.max(max_length,count);
        count=1 ;
        prev_mod=curr_mod ;
      }
    }
    return max_length ;
  }
  public static void main(String[] args){
    int arr[]={
      4,9,7,18,29,11 };
      int n=arr.length ;
      int k=11 ;
      System.out.print(LongestSubarray(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    operation LongestSubarray( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 1 ;
     var max_length : int ; max_length := 1 ;
    var prev_mod : int ; prev_mod := arr[0+1] mod k ;
        var i : int ; i := 1 ; while i < n do ( (     var curr_mod : int ; curr_mod := arr[i+1] mod k ;
     if (curr_mod = prev_mod) then (     count := count + 1 ) else (     max_length := Set{max_length, count}->max() ; 
     count := 1 ; 
     prev_mod := curr_mod ) )  ;     i := i + 1 ) ; 
    return max_length 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,9,7,18,29,11} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 11 ;
     OclFile["System.out"].print(LongestSubarray(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if(n==1){
      System.out.print(1);
      System.exit(0);
    }
    if(n==2){
      System.out.print(2);
      System.exit(0);
    }
    int arr[]=new int[n];
    int maxlen=2 ;
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    int len=2 ;
    for(int i=2 ; i<n ; i++){
      if(arr[i]==arr[i-1]+arr[i-2]){
        len++;
        maxlen=Math.max(maxlen,len);
      }
      else len=2 ;
    }
    System.out.print(maxlen);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    if (n = 1) then (     OclFile["System.out"].print(1) ; 
 OclProcess.exit(0) ) else skip ; 
    if (n = 2) then (     OclFile["System.out"].print(2) ; 
 OclProcess.exit(0) ) else skip ; 
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var maxlen : int ; maxlen := 2 ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var len : int ; len := 2 ;
        var i : int ; i := 2 ; while i < n do ( (     if (arr[i+1] = arr[i - 1+1] + arr[i - 2+1]) then (     len := len + 1 ; 
     maxlen := Set{maxlen, len}->max() ) else     len := 2 ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(maxlen) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxTeams(int N1,int N2){
    int count=0 ;
    while(N1>0 && N2>0 && N1+N2>=3){
      if(N1>N2){
        N1-=2 ;
        N2-=1 ;
      }
      else {
        N1-=1 ;
        N2-=2 ;
      }
      count++;
    }
    return count ;
  }
  public static void main(String[] args){
    int N1=4,N2=5 ;
    System.out.println(maxTeams(N1,N2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxTeams( N1 : int, N2 : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (N1 > 0 & N2 > 0 & N1 + N2 >= 3) do (     if (N1 > N2) then (     N1 := N1-(2) ; 
     N2 := N2-(1) ) else (     N1 := N1-(1) ; 
     N2 := N2-(2) ) ;  
     count := count + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N1 : int ; N1 := 4 ;
    var N2 : int ; N2 := 5 ;
     OclFile["System.out"].println(maxTeams(N1, N2)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    System.out.println(n*800-(n/15)*200);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(n * 800 - (n / 15) * 200) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  private static MyScanner scanner ;
  public static void main(String[] args){
    Main instance=new Main();
    scanner=instance.new MyScanner();
    instance.solve();
  }
  private void solve(){
    try {
      int N=scanner.nextInt();
      int x=N*800 ;
      int y=N/15*200 ;
      System.out.println(x-y);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
  private class MyScanner {
    String[] s ;
    int i ;
    BufferedReader br ;
    String reg=" " ;
    MyScanner(){
      s=new String[0];
      i=0 ;
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public String next()throws IOException {
      if(i<s.length)return s[i++];
      String line=br.readLine();
      while(line.equals("")){
        line=br.readLine();
      }
      s=line.split(reg,0);
      i=0 ;
      return s[i++];
    }
    public int nextInt()throws NumberFormatException,IOException {
      return Integer.parseInt(next());
    }
    public double nextDouble()throws NumberFormatException,IOException {
      return Double.parseDouble(next());
    }
    public long nextLong()throws NumberFormatException,IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : MyScanner;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var instance : Main ; instance := Main.newMain() ;
     scanner := (instance).newMyScanner() ; 
     instance.solve() );
   operation solve() : void
  pre: true
  post: true
  activity: (     try (     var N : int ; N := scanner.nextInt() ;
     var x : int ; x := N * 800 ;
     var y : int ; y := N / 15 * 200 ;
     OclFile["System.out"].println(x - y) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
 class MyScanner {
   attribute s : Sequence(String);
   attribute i : int;
   attribute br : OclFile;
   attribute reg : String := " ";
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     s := Integer.subrange(1,0)->collect(null) ; 
     i := 0 ; 
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (i < s->size()) then     return s[i+1] else skip ; 
     var line : String ; line := br.readLine() ;
    while (line = "") do (     line := br.readLine() ) ; 
    s := line->split(reg) ; 
    i := 0 ; 
    return s[i+1] 
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] temp ;
    line=br.readLine();
    temp=line.split(" ");
    int n=Integer.valueOf(temp[0]);
    int x=800*n ;
    int y=200*(n/15);
    System.out.println(x-y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var temp : Sequence(String) ;
    line := br.readLine() ; 
    temp := line->split(" ") ; 
    var n : int ; n := (temp[0+1])->toInteger() ;
    var x : int ; x := 800 * n ;
    var y : int ; y := 200 * (n / 15) ;
    OclFile["System.out"].println(x - y) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static void solve(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    System.out.println((n*800)-(200*(n/15)));
    sc.close();
  }
  public static void main(String args[]){
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println((n * 800) - (200 * (n / 15))) ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStreamReader ;
import java.io.BufferedReader ;
import java.io.IOException ;
public class Main {
  public static void main(String[] args)throws IOException {
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader reader=new BufferedReader(isr);
    int n ;
    n=Integer.parseInt(reader.readLine());
    System.out.println((n*800)-((n/15)*200));
    reader.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(isr) ;
    var n : int ;
    n := (reader.readLine())->toInteger() ; 
    OclFile["System.out"].println((n * 800) - ((n / 15) * 200)) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static void printKMax(int arr[],int n,int k){
    int j,max ;
    for(int i=0 ; i<=n-k ; i++){
      max=arr[i];
      for(j=1 ; j<k ; j++){
        if(arr[i+j]>max)max=arr[i+j];
      }
      System.out.print(max+" ");
    }
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3,4,5,6,7,8,9,10 };
      int k=3 ;
      printKMax(arr,arr.length,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printKMax( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var j : int ;
    var max : int ;
         var i : int ; i := 0 ; while i <= n - k do ( (     max := arr[i+1] ; 
         j := 1 ; while j < k do ( (     if (arr[i + j+1] > max) then     max := arr[i + j+1] ; else skip )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print(max + " ") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5,6,7,8,9,10} ;
     var k : int ; k := 3 ;
     execute printKMax(arr, arr->size(), k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int numberOfDistinct(int n){
    int ans=0 ;
    for(int i=1 ; i<=Math.sqrt(n); i++){
      if(n % i==0){
        ans++;
        if((n/i)!=i)ans++;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int n=3 ;
    System.out.println(numberOfDistinct(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation numberOfDistinct( n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var i : int ; i := 1 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     ans := ans + 1 ; 
     if ((n / i) /= i) then     ans := ans + 1 ; else skip ) else skip )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(numberOfDistinct(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int p=scan.nextInt();
    int m=scan.nextInt();
    int c=scan.nextInt();
    System.out.println(p+m+c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : int ; p := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var c : int ; c := scan.getCurrent()->toInteger() ;
    OclFile["System.out"].println(p + m + c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.StringTokenizer ;
class Main {
  public static void main(String args[]){
    BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    String str="" ;
    StringTokenizer stk ;
    List kazu=new ArrayList<Integer>();
    int sousuu=0 ;
    try {
      str=bfr.readLine();
      stk=new StringTokenizer(str," ");
      while(stk.hasMoreTokens()){
        sousuu+=Integer.parseInt(stk.nextToken());
      }
      System.out.println(sousuu);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bfr : OclFile ; bfr := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := "" ;
    var stk : OclIterator ;
    var kazu : Sequence ; kazu := Sequence{} ;
    var sousuu : int ; sousuu := 0 ;
    try (     str := bfr.readLine() ; 
     stk := OclIterator.newOclIterator_String_String(str, " ") ; 
     while (stk.hasNext()) do (     sousuu := sousuu+((stk.next())->toInteger()) ) ; 
     OclFile["System.out"].println(sousuu) )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    int p,m,c ;
    StringTokenizer st=new StringTokenizer(br.readLine());
    p=parseInt(st.nextToken());
    m=parseInt(st.nextToken());
    c=parseInt(st.nextToken());
    System.out.println(p+m+c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
    var words : Sequence(String) ;
    var p : int ;
    var m : int ;
    var c : int ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    p := (st.next() + "")->toInteger() ; 
    m := (st.next() + "")->toInteger() ; 
    c := (st.next() + "")->toInteger() ; 
    OclFile["System.out"].println(p + m + c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.*;
import java.io.*;
public class Hello {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int n=in.nextInt();
    int a[]=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    int min=2 ;
    if(n<=2){
      min=n ;
    }
    else {
      int count=2 ;
      for(int i=2 ; i<n ; i++){
        if(a[i-1]+a[i-2]==a[i]){
          count++;
        }
        else {
          count=2 ;
        }
        min=Math.max(count,min);
      }
    }
    pw.println(min);
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Hello {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var min : int ; min := 2 ;
    if (n <= 2) then (     min := n ) else (     var count : int ; count := 2 ;
         var i : int ; i := 2 ; while i < n do ( (     if (a[i - 1+1] + a[i - 2+1] = a[i+1]) then (     count := count + 1 ) else (     count := 2 ) ;  
     min := Set{count, min}->max() )  ;     i := i + 1 ) ) ;  
    skip ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    out.println(sc.nextInt()+sc.nextInt()+sc.nextInt());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     out.println(sc.getCurrent()->toInteger() + sc.getCurrent()->toInteger() + sc.getCurrent()->toInteger()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    try {
      String str=reader.readLine();
      String s[]=str.split(" ");
      int i1=Integer.parseInt(s[0]);
      int i2=Integer.parseInt(s[1]);
      int i3=Integer.parseInt(s[2]);
      System.out.println(i1+i2+i3);
      reader.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var str : String ; str := reader.readLine() ;
     var s : Sequence(String) ; s := str->split(" ") ;
    var i1 : int ; i1 := (s[0+1])->toInteger() ;
    var i2 : int ; i2 := (s[1+1])->toInteger() ;
    var i3 : int ; i3 := (s[2+1])->toInteger() ;
    OclFile["System.out"].println(i1 + i2 + i3) ; 
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class Main {
  private static List<Long>primes=new ArrayList<Long>();
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String str=br.readLine();
    long n=Long.parseLong(str);
    PrimeFactorize(n);
    long phi=n ;
    for(long prime : primes){
      phi=phi*(prime-1)/prime ;
    }
    System.out.println(phi);
  }
  private static void PrimeFactorize(long a){
    long div=a ;
    Boolean isBig=true ;
    for(long i=2 ; isBig ; i++){
      if(div % i==0){
        div=div/i ;
        if(primes.size()==0){
          primes.add(i);
        }
        else if(i!=primes.get(primes.size()-1)){
          primes.add(i);
        }
        i--;
      }
      isBig=i<Math.pow(div,0.5);
    }
    if(div!=1){
      if(primes.size()==0){
        primes.add(div);
      }
      else if(div!=primes.get(primes.size()-1)){
        primes.add(div);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute primes : Sequence(long) := Sequence{};
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := br.readLine() ;
    var n : long ; n := (str)->toLong() ;
    execute PrimeFactorize(n) ; 
    var phi : long ; phi := n ;
    for (prime : primes) do ( (     phi := phi * (prime - 1) / prime )  ) ; 
    OclFile["System.out"].println(phi) ; 
 );
  static   operation PrimeFactorize( a : long) : void
  pre: true
  post: true
  activity: (     var div : long ; div := a ;
     var isBig : Boolean ; isBig := true ;
         var i : long ; i := 2 ; while isBig do ( (     if (div mod i = 0) then (     div := div / i ; 
     if (primes->size() = 0) then (     primes := primes->including(i) ) else     if (i /= primes->at(primes->size() - 1+1)) then (     primes := primes->including(i) ) else skip ; ;  
     i := i - 1 ) else skip ; 
     isBig := i < div->pow(0.5) )  ;     i := i + 1 ) ; 
     if (div /= 1) then (     if (primes->size() = 0) then (     primes := primes->including(div) ) else     if (div /= primes->at(primes->size() - 1+1)) then (     primes := primes->including(div) ) else skip ; ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static boolean prime(long n){
    if(n<2){
      return false ;
    }
    else if(n==2){
      return true ;
    }
    else {
      if(n % 2==0){
        return false ;
      }
      else {
        for(int i=3 ; i<=Math.sqrt(n); i++){
          if(n % i==0){
            return false ;
          }
        }
        return true ;
      }
    }
  }
  public static void bunnkai(long n,HashMap<Long,Long>hm){
    while(n % 2==0){
      if(! hm.containsKey(2L))hm.put(2L,1L);
      else hm.put(2L,hm.get(2L)+1L);
      n/=2 ;
    }
    long res=n ;
    for(long i=3 ; i<Math.sqrt(n); i+=2){
      if(res==1)return ;
      else if(prime(i)&& res % i==0){
        while(res % i==0){
          if(! hm.containsKey(i))hm.put(i,1L);
          else hm.put(i,hm.get(i)+1L);
          res/=i ;
        }
      }
    }
    if(prime(res))hm.put(res,1L);
    return ;
  }
  public static void main(String[] args){
    HashMap<Long,Long>hm=new HashMap<Long,Long>();
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    bunnkai(n,hm);
    long ans=n ;
    for(long key : hm.keySet()){
      ans*=(key-1);
      ans/=key ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation prime( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n < 2) then (     return false ) else     if (n = 2) then (     return true ) else (     if (n mod 2 = 0) then (     return false ) else (         var i : int ; i := 3 ; while i <= (n)->sqrt() do ( (     if (n mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true ) ) ;  );
  static   operation bunnkai( n : long, hm : Map(long,long)) : void
  pre: true
  post: true
  activity: (     while (n mod 2 = 0) do (     if (not(hm.containsKey(2L))) then     hm := hm->union(Map{2L |-> 1L}) else     hm := hm->union(Map{2L |-> hm->at(2L+1) + 1L}) ; ;  
     n := n/(2) ) ; 
     var res : long ; res := n ;
        var i : long ; i := 3 ; while i < (n)->sqrt() do ( (     if (res = 1) then     return else     if (prime(i) & res mod i = 0) then (     while (res mod i = 0) do (     if (not(hm.containsKey(i))) then     hm := hm->union(Map{i |-> 1L}) else     hm := hm->union(Map{i |-> hm->at(i+1) + 1L}) ; ;  
     res := res/(i) ) ) else skip ; )  ;     i := i+(2) ) ; 
    if (prime(res)) then     hm := hm->union(Map{res |-> 1L}) ; else skip ; 
    return 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var hm : Map(long,long) ; hm := Map{} ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var n : long ; n := sc.getCurrent()->toLong() ;
    execute bunnkai(n, hm) ; 
    var ans : long ; ans := n ;
    for (key : hm->keys()) do ( (     ans := ans*((key - 1)) ; 
     ans := ans/(key) )  ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n ;
    int[] p ;
    int i,j,res ;
    n=sc.nextInt();
    p=new int[30];
    j=0 ;
    res=n ;
    for(; n!=1 ; ){
      for(i=2 ; i*i<=n ; i++){
        if(n % i==0){
          p[j]=i ;
          if(j>0 && p[j]==p[j-1]){
          }
          else j++;
          n=n/i ;
          break ;
        }
      }
      if(i*i>n){
        p[j]=n ;
        if(j>0 && p[j]==p[j-1]){
        }
        else j++;
        break ;
      }
    }
    for(i=0 ; i<j ; i++)res=res/p[i]*(p[i]-1);
    out.println(res);
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var p : Sequence(int) ;
    var i : int ;
    var j : int ;
    var res : int ;
    n := sc.nextInt() ; 
    p := Integer.subrange(1,30)->collect(0) ; 
    j := 0 ; 
    res := n ; 
      while n /= 1 do ( (         i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     p[j+1] := i ; 
     if (j > 0 & p[j+1] = p[j - 1+1]) then skip else     j := j + 1 ; ;  
     n := n / i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
     if (i * i > n) then (     p[j+1] := n ; 
     if (j > 0 & p[j+1] = p[j - 1+1]) then skip else     j := j + 1 ; ;  
     break ) else skip )  ) ; 
        i := 0 ; while i < j do (     res := res / p[i+1] * (p[i+1] - 1) ;  ;     i := i + 1 ) ; 
    out.println(res) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  static ArrayList<Integer>[] g ;
  static int maxMatching(int v,int p){
    int a=0 ;
    int o=0 ;
    for(int w : g[v]){
      if(w==p)continue ;
      int r=maxMatching(w,v);
      a+=r/2 ;
      o+=r % 2 ;
    }
    return 2*a+Math.min(1,o)+1 ;
  }
  @ SuppressWarnings("unchecked")public static void main(String[] args){
    MyScanner sc=new MyScanner();
    out=new PrintWriter(new BufferedOutputStream(System.out));
    int n=sc.nextInt();
    g=new ArrayList[n];
    Arrays.setAll(g,x->new ArrayList<Integer>());
    for(int i=0 ; i<n-1 ; ++i){
      int a=sc.nextInt()-1 ;
      int b=sc.nextInt()-1 ;
      g[a] .add(b);
      g[b] .add(a);
    }
    int m=maxMatching(0,-1)/2 ;
    out.println(2*m==n ? "Second" : "First");
    out.close();
  }
  public static PrintWriter out ;
  public 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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute g : Sequence(Sequence(int));
  static   operation maxMatching( v : int, p : int) : int
  pre: true
  post: true
  activity: (     var a : int ; a := 0 ;
     var o : int ; o := 0 ;
     for (w : g[v+1]) do ( (     if (w = p) then     continue else skip ; 
     var r : int ; r := maxMatching(w, v) ;
     a := a+(r / 2) ; 
     o := o+(r mod 2) )  ) ; 
     return 2 * a + Set{1, o}->min() + 1 );
   static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var n : int ; n := sc.nextInt() ;
    g := Integer.subrange(1,n)->collect(null) ; 
setAll(g, lambda x : OclAny in Sequence{}) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     var a : int ; a := sc.nextInt() - 1 ;
     var b : int ; b := sc.nextInt() - 1 ;
     g[a+1]->excludes(b) ; 
     g[b+1]->excludes(a) )  ;     i := i + 1 ) ; 
    var m : int ; m := maxMatching(0, -1) / 2 ;
    out.println(if 2 * m = n then "Second" else "First" endif) ; 
    out.close() ; 
 );
  static   attribute out : OclFile;
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.Iterator ;
import java.util.List ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    List<Integer>unko=new ArrayList<Integer>();
    fra(N,unko);
    HashSet<Integer>buri=new HashSet<Integer>();
    for(int i=0 ; i<unko.size(); i++){
      int a=unko.get(i);
      if(a!=1){
        buri.add(a);
      }
    }
    long aa=N ;
    Iterator<Integer>bubu=buri.iterator();
    for(int i=0 ; i<buri.size(); i++){
      long tmp=(long)bubu.next();
      aa=aa*(tmp-1)/tmp ;
    }
    System.out.println(aa);
  }
  public static void fra(int a,List<Integer>p){
    for(int i=2 ; i*i<=a ; i++){
      if(a % i==0){
        p.add(i);
        fra(a/i,p);
        return ;
      }
    }
    p.add(a);
  }
  public static void fra(long a,List<Long>p){
    for(long i=2 ; i*i<=a ; i++){
      if(a % i==0){
        p.add(i);
        fra(a/i,p);
        return ;
      }
    }
    p.add(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var unko : Sequence(int) ; unko := Sequence{} ;
    execute fra(N, unko) ; 
    var buri : Set(int) ; buri := Set{} ;
        var i : int ; i := 0 ; while i < unko->size() do ( (     var a : int ; a := unko->at(i+1) ;
     if (a /= 1) then (     buri := buri->including(a) ) else skip )  ;     i := i + 1 ) ; 
    var aa : long ; aa := N ;
    var bubu : OclIterator ; bubu := buri->iterator() ;
        var i : int ; i := 0 ; while i < buri->size() do ( (     var tmp : long ; tmp := bubu.next()->oclAsType(long) ;
     aa := aa * (tmp - 1) / tmp )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(aa) ; 
 );
  static   operation fra( a : int, p : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 2 ; while i * i <= a do ( (     if (a mod i = 0) then (     p->excludes(i) ; 
     execute fra(a / i, p) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     p->excludes(a) );
  static   operation fra( a : long, p : Sequence(long)) : void
  pre: true
  post: true
  activity: (         var i : long ; i := 2 ; while i * i <= a do ( (     if (a mod i = 0) then (     p->excludes(i) ; 
     execute fra(a / i, p) ; 
     return ) else skip )  ;     i := i + 1 ) ; 
     p->excludes(a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    final long n=sc.nextLong();
    System.out.println(euler(n,primeFactorize(n)));
  }
  private static List<Map<Long,Integer>>primeFactorize(long n){
    List<Map<Long,Integer>>res=new ArrayList<>();
    for(long a=2 ; a*a<=n ; a++){
      if(n % a!=0){
        continue ;
      }
      int ex=0 ;
      while(n % a==0){
        ex++;
        n/=a ;
      }
      res.add(Collections.singletonMap(a,ex));
    }
    if(n!=1){
      res.add(Collections.singletonMap(n,1));
    }
    return res ;
  }
  private static long euler(final long n,final List<Map<Long,Integer>>pfs){
    long res=n ;
    for(Map<Long,Integer>pf : pfs){
      for(Map.Entry<Long,Integer>entry : pf.entrySet()){
        res*=entry.getKey()-1 ;
        res/=entry.getKey();
      }
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
     OclFile["System.out"].println(euler(n, primeFactorize(n))) );
  static   operation primeFactorize( n : long) : Sequence(Map(long,int))
  pre: true
  post: true
  activity: (     var res : Sequence(Map(long,int)) ; res := Sequence{} ;
         var a : long ; a := 2 ; while a * a <= n do ( (     if (n mod a /= 0) then (     continue ) else skip ; 
     var ex : int ; ex := 0 ;
     while (n mod a = 0) do (     ex := ex + 1 ; 
     n := n/(a) ) ; 
     res := res->including(Map{a, ex}) )  ;     a := a + 1 ) ; 
     if (n /= 1) then (     res := res->including(Map{n, 1}) ) else skip ; 
     return res );
  static   operation euler( n : long, pfs : Sequence(Map(long,int))) : long
  pre: true
  post: true
  activity: (     var res : long ; res := n ;
     for (pf : pfs) do ( (     for (entry : pf->asSet()) do ( (     res := res*(entry.getKey() - 1) ; 
     res := res/(entry.getKey()) )  ) )  ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean CompareAlphanumeric(char[] str1,char[] str2){
    int i,j ;
    i=0 ;
    j=0 ;
    int len1=str1.length ;
    int len2=str2.length ;
    while(i<=len1 && j<=len2){
      while(i<len1 &&(!((str1[i]>='a' && str1[i]<='z')||(str1[i]>='A' && str1[i]<='Z')||(str1[i]>='0' && str1[i]<='9')))){
        i++;
      }
      while(j<len2 &&(!((str2[j]>='a' && str2[j]<='z')||(str2[j]>='A' && str2[j]<='Z')||(str2[j]>='0' && str2[j]<='9')))){
        j++;
      }
      if(i==len1 && j==len2){
        return true ;
      }
      else if(str1[i]!=str2[j]){
        return false ;
      }
      else {
        i++;
        j++;
      }
    }
    return false ;
  }
  static void CompareAlphanumericUtil(String str1,String str2){
    boolean res ;
    res=CompareAlphanumeric(str1.toCharArray(),str2.toCharArray());
    if(res==true){
      System.out.println("Equal");
    }
    else {
      System.out.println("Unequal");
    }
  }
  public static void main(String[] args){
    String str1,str2 ;
    str1="Ram,Shyam" ;
    str2=" Ram-Shyam." ;
    CompareAlphanumericUtil(str1,str2);
    str1="abc123" ;
    str2="123abc" ;
    CompareAlphanumericUtil(str1,str2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation CompareAlphanumeric( str1 : Sequence(String), str2 : Sequence(String)) : boolean
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     i := 0 ; 
    j := 0 ; 
    var len1 : int ; len1 := str1->size() ;
    var len2 : int ; len2 := str2->size() ;
    while (i <= len1 & j <= len2) do (     while (i < len1 & (not(((str1[i+1] >= 'a' & str1[i+1] <= 'z') or (str1[i+1] >= 'A' & str1[i+1] <= 'Z') or (str1[i+1] >= '0' & str1[i+1] <= '9'))))) do (     i := i + 1 ) ; 
     while (j < len2 & (not(((str2[j+1] >= 'a' & str2[j+1] <= 'z') or (str2[j+1] >= 'A' & str2[j+1] <= 'Z') or (str2[j+1] >= '0' & str2[j+1] <= '9'))))) do (     j := j + 1 ) ; 
     if (i = len1 & j = len2) then (     return true ) else     if (str1[i+1] /= str2[j+1]) then (     return false ) else (     i := i + 1 ; 
     j := j + 1 ) ;  ) ; 
    return false 
 );
  static   operation CompareAlphanumericUtil( str1 : String, str2 : String) : void
  pre: true
  post: true
  activity: (     var res : boolean ;
     res := CompareAlphanumeric(str1->characters(), str2->characters()) ; 
     if (res = true) then (     OclFile["System.out"].println("Equal") ) else (     OclFile["System.out"].println("Unequal") ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ;
    var str2 : String ;
     str1 := "Ram,Shyam" ; 
    str2 := " Ram-Shyam." ; 
    execute CompareAlphanumericUtil(str1, str2) ; 
    str1 := "abc123" ; 
    str2 := "123abc" ; 
    execute CompareAlphanumericUtil(str1, str2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0){
        break ;
      }
      double y=sc.nextInt();
      int x=0 ;
      double max=0 ;
      for(int i=0 ; i<n ; i++){
        int b=sc.nextInt();
        double r=sc.nextInt();
        int t=sc.nextInt();
        if(t==1){
          double sum=1+y*(r/100);
          if(sum>max){
            max=sum ;
            x=b ;
          }
        }
        else {
          double sum=Math.pow(1+(r/100),y);
          if(sum>max){
            max=sum ;
            x=b ;
          }
        }
      }
      System.out.println(x);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var y : double ; y := sc.getCurrent()->toInteger() ;
    var x : int ; x := 0 ;
    var max : double ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var b : int ; b := sc.getCurrent()->toInteger() ;
     var r : double ; r := sc.getCurrent()->toInteger() ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     if (t = 1) then (     var sum : double ; sum := 1 + y * (r / 100) ;
     if (sum > max) then (     max := sum ; 
     x := b ) else skip ) else (     var sum : double ; sum := 1 + (r / 100)->pow(y) ;
     if (sum > max) then (     max := sum ; 
     x := b ) else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(x) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  void run(){
    while(true){
      int n=readInt();
      if(n==0)break ;
      int y=readInt();
      double mMax=0 ;
      int idMax=-1 ;
      for(int i=0 ; i<n ; i++){
        int b=readInt();
        int r=readInt();
        int t=readInt();
        double m ;
        if(t==1){
          m=1+1.0*y*r/100 ;
        }
        else {
          m=Math.pow(1+1.0*r/100,y);
        }
        if(mMax<m){
          mMax=m ;
          idMax=b ;
        }
      }
      sysout.println(idMax);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
  PrintWriter sysout=new PrintWriter(System.out,true);
  BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
  StringTokenizer buffer=new StringTokenizer("");
  String read(){
    if(! buffer.hasMoreTokens()){
      try {
        buffer=new StringTokenizer(in.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return buffer.nextToken();
  }
  int readInt(){
    return Integer.parseInt(read());
  }
  long readLong(){
    return Long.parseLong(read());
  }
  double readDouble(){
    return Double.parseDouble(read());
  }
  String readLine(){
    buffer=new StringTokenizer("");
    try {
      return in.readLine();
    }
    catch(IOException e){
      throw new RuntimeException(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := readInt() ;
     if (n = 0) then     break else skip ; 
    var y : int ; y := readInt() ;
    var mMax : double ; mMax := 0 ;
    var idMax : int ; idMax := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var b : int ; b := readInt() ;
     var r : int ; r := readInt() ;
    var t : int ; t := readInt() ;
    var m : double ;
    if (t = 1) then (     m := 1 + 1.0 * y * r / 100 ) else (     m := 1 + 1.0 * r / 100->pow(y) ) ;  
    if (mMax < m) then (     mMax := m ; 
     idMax := b ) else skip ; 
 )  ;     i := i + 1 ) ; 
    sysout.println(idMax) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute sysout : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], true);
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute buffer : OclIterator := OclIterator.newOclIterator_String("");
   operation read() : String
  pre: true
  post: true
  activity: (     if (not(buffer.hasNext())) then (     try (     buffer := OclIterator.newOclIterator_String(in.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) else skip ; 
     return buffer.next() );
   operation readInt() : int
  pre: true
  post: true
  activity: (     return (read())->toInteger() );
   operation readLong() : long
  pre: true
  post: true
  activity: (     return (read())->toLong() );
   operation readDouble() : double
  pre: true
  post: true
  activity: (     return (read())->toReal() );
   operation readLine() : String
  pre: true
  post: true
  activity: (     buffer := OclIterator.newOclIterator_String("") ; 
     try (     return in.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import static java.lang.Math.max ;
import static java.lang.Math.min ;
import static java.lang.System.out ;
public class pre127 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int n=obj.nextInt(),arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=obj.nextInt();
    int dp[]=new int[n];
    dp[0]=1 ;
    for(int i=1 ; i<n ; i++){
      if(i==1)dp[i]=2 ;
      else dp[i]=(arr[i]==arr[i-1]+arr[i-2] ? dp[i-1]+1 : 2);
    }
    int ans=0 ;
    for(int i : dp)ans=max(ans,i);
    out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class pre127 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var n : int ; n := obj.nextInt() ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := obj.nextInt() ;  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
    dp[0+1] := 1 ; 
        var i : int ; i := 1 ; while i < n do ( (     if (i = 1) then     dp[i+1] := 2 ; else     dp[i+1] := (if arr[i+1] = arr[i - 1+1] + arr[i - 2+1] then dp[i - 1+1] + 1 else 2 endif) ; )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    for (i : dp) do (     ans := Set{ans, i}->max() ;  ) ; 
    out.println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int n,y ;
  static int[][] banks ;
  public static void main(String[] args){
    while(read()){
      solve();
    }
  }
  static boolean read(){
    n=sc.nextInt();
    if(n==0)return false ;
    banks=new int[n][3];
    y=sc.nextInt();
    for(int i=0 ; i<banks.length ; i++){
      banks[i][0]=sc.nextInt();
      banks[i][1]=sc.nextInt();
      banks[i][2]=sc.nextInt();
    }
    return true ;
  }
  static void solve(){
    double max=-1.0 ;
    int res=-1 ;
    for(int i=0 ; i<banks.length ; i++){
      double money=0.0 ;
      if(banks[i][2]==1){
        money=getSimpleInterest(banks[i]);
      }
      else {
        money=getCompoundInterest(banks[i]);
      }
      if(max<money){
        res=banks[i][0];
        max=money ;
      }
    }
    System.out.println(res);
  }
  static double getSimpleInterest(int[] data){
    double r=(double)data[1];
    return 10000*(1+y*r/100);
  }
  static double getCompoundInterest(int[] data){
    double r=(double)data[1];
    return 10000*Math.pow(1+r/100,y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute n : int;
  static   attribute banks : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (read()) do (     execute solve() ) );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     return false else skip ; 
    banks := Integer.subrange(1,n)->collect(Integer.subrange(1,3)->collect(0)) ; 
    y := sc.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < banks->size() do ( (     banks[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     banks[i+1][1+1] := sc.getCurrent()->toInteger() ; 
     banks[i+1][2+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    return true 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var max : double ; max := -1.0 ;
     var res : int ; res := -1 ;
         var i : int ; i := 0 ; while i < banks->size() do ( (     var money : double ; money := 0.0 ;
     if (banks[i+1][2+1] = 1) then (     money := getSimpleInterest(banks[i+1]) ) else (     money := getCompoundInterest(banks[i+1]) ) ;  
     if (max < money) then (     res := banks[i+1][0+1] ; 
     max := money ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(res) );
  static   operation getSimpleInterest( data : Sequence(int)) : double
  pre: true
  post: true
  activity: (     var r : double ; r := data[1+1]->oclAsType(double) ;
     return 10000 * (1 + y * r / 100) );
  static   operation getCompoundInterest( data : Sequence(int)) : double
  pre: true
  post: true
  activity: (     var r : double ; r := data[1+1]->oclAsType(double) ;
     return 10000 * 1 + r / 100->pow(y) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    while(stdIn.hasNext()){
      int n=stdIn.nextInt();
      if(n==0){
        break ;
      }
      int y=stdIn.nextInt();
      int ans=0 ;
      double max=0 ;
      while(n--!=0){
        int b=stdIn.nextInt();
        int r=stdIn.nextInt();
        int t=stdIn.nextInt();
        double sum=1 ;
        if(t==1){
          sum=1+y*r/100.0 ;
        }
        else {
          sum=Math.pow(1+r/100.0,y);
        }
        if(sum>max){
          ans=b ;
          max=sum ;
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (stdIn.hasNext()) do (     var n : int ; n := stdIn.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var y : int ; y := stdIn.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
    var max : double ; max := 0 ;
        while (n /= 0) do (    skip ; (     var b : int ; b := stdIn.getCurrent()->toInteger() ;
     var r : int ; r := stdIn.getCurrent()->toInteger() ;
    var t : int ; t := stdIn.getCurrent()->toInteger() ;
    var sum : double ; sum := 1 ;
    if (t = 1) then (     sum := 1 + y * r / 100.0 ) else (     sum := 1 + r / 100.0->pow(y) ) ;  
    if (sum > max) then (     ans := b ; 
     max := sum ) else skip ; 
 ) ;  ) ;  
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static int n,y ;
  static Bank bank[];
  public static void main(String[] args){
    Scanner cin=new Scanner(System.in);
    while(true){
      int N=cin.nextInt();
      if(N==0){
        break ;
      }
      int y=cin.nextInt();
      bank=new Bank[N];
      for(int i=0 ; i<N ; i++){
        int a=cin.nextInt();
        double b=cin.nextDouble();
        int t=cin.nextInt();
        bank[i]=new Bank(a,b,t);
        bank[i] .calc(y);
      }
      Arrays.sort(bank);
      System.out.println(bank[bank.length-1] .b);
    }
  }
}
class Bank implements Comparable {
  double money ;
  int b ;
  double r ;
  int type ;
  public int compareTo(Object o){
    Bank b=(Bank)o ;
    if(this.money>b.money){
      return 1 ;
    }
    else if(this.money==b.money){
      return 0 ;
    }
    else {
      return-1 ;
    }
  }
  Bank(int a,double d,int x){
    b=a ;
    r=d ;
    type=x ;
  }
  void calc(int year){
    money=1 ;
    if(type==2){
      money=money*Math.pow((1.0+r/100),year);
    }
    else {
      money=money*(1.0+year*(r/100));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   attribute bank : Sequence(Bank);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var cin : OclFile ; cin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var N : int ; N := cin.getCurrent()->toInteger() ;
     if (N = 0) then (     break ) else skip ; 
    var y : int ; y := cin.getCurrent()->toInteger() ;
    bank := Integer.subrange(1,N)->collect(null) ; 
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := cin.getCurrent()->toInteger() ;
     var b : double ; b := cin.getCurrent()->toReal() ;
    var t : int ; t := cin.getCurrent()->toInteger() ;
    bank[i+1] := Bank.newBank(a, b, t) ; 
    bank[i+1].calc(y) ; 
 )  ;     i := i + 1 ) ; 
    bank := bank->sort() ; 
    OclFile["System.out"].println(bank[bank->size() - 1+1].b) ; 
 ) );
}
class Bank implements OclAny {
   attribute money : double;
   attribute b : int;
   attribute r : double;
   attribute type : int;
   operation compareTo( o : OclAny) : int
  pre: true
  post: true
  activity: (     var b : Bank ; b := o->oclAsType(Bank) ;
     if (self.money > b.money) then (     return 1 ) else     if (self.money = b.money) then (     return 0 ) else (     return -1 ) ;  );
   static operation newBank( a : int, d : double, x : int) : Bank
  pre: true
  post: true
  activity:
  ( var self : Bank ;
    self := createBank();
    self.initialise(a, d,x);
    return self );
  operation initialise( a : int, d : double, x : int) : void
  pre: true  post: true
  activity: (     b := a ; 
     r := d ; 
     type := x );
   operation calc( year : int) : void
  pre: true
  post: true
  activity: (     money := 1 ; 
     if (type = 2) then (     money := money * (1.0 + r / 100)->pow(year) ) else (     money := money * (1.0 + year * (r / 100)) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.List ;
public class Main {
  static List<Integer>path ;
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] sa=br.readLine().split(" ");
    int n=Integer.parseInt(sa[0]);
    int a=Integer.parseInt(sa[1]);
    sa=br.readLine().split(" ");
    int[] x=new int[n+1];
    for(int i=0 ; i<n ; i++){
      x[i+1]=Integer.parseInt(sa[i]);
    }
    br.close();
    long[][][] dp=new long[n+1][n+1][n*50+1];
    dp[0][0][0]=1 ;
    for(int i=1 ; i<=n ; i++){
      dp[i][0][0]=1 ;
      for(int j=1 ; j<=i ; j++){
        for(int k=0 ; k<=j*50 ; k++){
          dp[i][j][k]=dp[i-1][j][k];
          int pre=k-x[i];
          if(0<=pre && pre<=(j-1)*50){
            dp[i][j][k]+=dp[i-1][j-1][pre];
          }
        }
      }
    }
    long ans=0 ;
    for(int j=1 ; j<=n ; j++){
      ans+=dp[n][j][j*a];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute path : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sa : Sequence(String) ; sa := br.readLine()->split(" ") ;
    var n : int ; n := (sa[0+1])->toInteger() ;
    var a : int ; a := (sa[1+1])->toInteger() ;
    sa := br.readLine()->split(" ") ; 
    var x : Sequence(int) ; x := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i + 1+1] := (sa[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    skip ; 
    var dp : Sequence(Sequence(Sequence(long))) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n * 50 + 1)->collect(0))) ;
    dp[0+1][0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do ( (     dp[i+1][0+1][0+1] := 1 ; 
         var j : int ; j := 1 ; while j <= i do ( (         var k : int ; k := 0 ; while k <= j * 50 do ( (     dp[i+1][j+1][k+1] := dp[i - 1+1][j+1][k+1] ; 
     var pre : int ; pre := k - x[i+1] ;
     if (0 <= pre & pre <= (j - 1) * 50) then (     dp[i+1][j+1][k+1] := dp[i+1][j+1][k+1]+(dp[i - 1+1][j - 1+1][pre+1]) ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var j : int ; j := 1 ; while j <= n do ( (     ans := ans+(dp[n+1][j+1][j * a+1]) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int N=205,M=205 ;
  static int[][] grid=new int[N][M];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      solve(sc);
    }
  }
  static void solve(Scanner sc){
    int n=sc.nextInt(),m=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      String line=sc.next();
      for(int j=0 ; j<m ; j++){
        grid[i][j]=line.charAt(j)-'0' ;
      }
    }
    for(int i=0 ; i<n-1 ; i++){
      for(int j=0 ; j<m-1 ; j++){
        int sum=grid[i][j]+grid[i+1][j]+grid[i][j+1]+grid[i+1][j+1];
        if(sum==3){
          System.out.println("NO");
          return ;
        }
      }
    }
    System.out.println("YES");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int := 205;
  static   attribute grid : Sequence(Sequence(int)) := Integer.subrange(1,N)->collect(Integer.subrange(1,M)->collect(0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     execute solve(sc) ) ;  ) );
  static   operation solve( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var line : String ; line := sc.getCurrent() ;
         var j : int ; j := 0 ; while j < m do ( (     grid[i+1][j+1] := line->at(j+1) - ('0')->char2byte() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := 0 ; while j < m - 1 do ( (     var sum : int ; sum := grid[i+1][j+1] + grid[i + 1+1][j+1] + grid[i+1][j + 1+1] + grid[i + 1+1][j + 1+1] ;
     if (sum = 3) then (     OclFile["System.out"].println("NO") ; 
     return ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println("YES") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    Printer pr=new Printer(System.out);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int[] x=new int[n];
    for(int i=0 ; i<n ; i++){
      x[i]=sc.nextInt();
    }
    Arrays.sort(x);
    long[][][] dp=new long[n+1][n+1][a*n+1];
    dp[0][0][0]=1 ;
    for(int i=1 ; i<=n ; i++){
      for(int j=0 ; j<=n ; j++){
        for(int k=0 ; k<=j*a ; k++){
          dp[i][j][k]=dp[i-1][j][k];
          if(k-x[i-1]<0 || j==0){
            continue ;
          }
          dp[i][j][k]+=dp[i-1][j-1][k-x[i-1] ];
        }
      }
    }
    long ret=0 ;
    for(int i=1 ; i<=n ; i++){
      ret+=dp[n][i][i*a];
    }
    pr.println(ret);
    pr.close();
    sc.close();
  }
  private static class Printer extends PrintWriter {
    Printer(PrintStream out){
      super(out);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pr : Printer ; pr := Printer.newPrinter(OclFile["System.out"]) ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    x := x->sort() ; 
    var dp : Sequence(Sequence(Sequence(long))) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(Integer.subrange(1,a * n + 1)->collect(0))) ;
    dp[0+1][0+1][0+1] := 1 ; 
        var i : int ; i := 1 ; while i <= n do ( (         var j : int ; j := 0 ; while j <= n do ( (         var k : int ; k := 0 ; while k <= j * a do ( (     dp[i+1][j+1][k+1] := dp[i - 1+1][j+1][k+1] ; 
     if (k - x[i - 1+1] < 0 or j = 0) then (     continue ) else skip ; 
     dp[i+1][j+1][k+1] := dp[i+1][j+1][k+1]+(dp[i - 1+1][j - 1+1][k - x[i - 1+1]+1]) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ret : long ; ret := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     ret := ret+(dp[n+1][i+1][i * a+1]) )  ;     i := i + 1 ) ; 
    pr.println(ret) ; 
    pr.close() ; 
    skip ; 
 );
  static class Printer extends OclFile {
   static operation newPrinter( out : OclFile) : Printer
  pre: true
  post: true
  activity:
  ( var self : Printer ;
    self := createPrinter();
    self.initialise(out);
    return self );
  operation initialise( out : OclFile) : void
  pre: true  post: true
  activity: (     execute super(out) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String[] S=sc.nextLine().split(" ");
    int N=Integer.parseInt(S[0]);
    int A=Integer.parseInt(S[1]);
    int[] num=new int[N];
    int max=A ;
    for(int i=0 ; i<N ; i++){
      num[i]=Integer.parseInt(sc.next());
      max=max<num[i] ? num[i] : max ;
    }
    int M=N*max ;
    long[][][] dp=new long[N+1][N+1][M+1];
    for(int i=0 ; i<=N ; i++){
      dp[i][0][0]=1 ;
    }
    for(int i=1 ; i<=N ; i++){
      for(int j=1 ; j<=i ; j++){
        for(int k=0 ; k<=M ; k++){
          int z=num[i-1];
          if(z>k){
            dp[i][j][k]=dp[i-1][j][k];
          }
          else {
            dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-z];
          }
        }
      }
    }
    long ans=0 ;
    for(int i=1 ; i<=N ; i++){
      ans+=dp[N][i][i*A];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : Sequence(String) ; S := sc.nextLine()->split(" ") ;
    var N : int ; N := (S[0+1])->toInteger() ;
    var A : int ; A := (S[1+1])->toInteger() ;
    var num : Sequence(int) ; num := Integer.subrange(1,N)->collect(0) ;
    var max : int ; max := A ;
        var i : int ; i := 0 ; while i < N do ( (     num[i+1] := (sc.getCurrent())->toInteger() ; 
     max := if max < num[i+1] then num[i+1] else max endif )  ;     i := i + 1 ) ; 
    var M : int ; M := N * max ;
    var dp : Sequence(Sequence(Sequence(long))) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(Integer.subrange(1,M + 1)->collect(0))) ;
        var i : int ; i := 0 ; while i <= N do ( (     dp[i+1][0+1][0+1] := 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := 1 ; while j <= i do ( (         var k : int ; k := 0 ; while k <= M do ( (     var z : int ; z := num[i - 1+1] ;
     if (z > k) then (     dp[i+1][j+1][k+1] := dp[i - 1+1][j+1][k+1] ) else (     dp[i+1][j+1][k+1] := dp[i - 1+1][j+1][k+1] + dp[i - 1+1][j - 1+1][k - z+1] ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= N do ( (     ans := ans+(dp[N+1][i+1][i * A+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner keyboard=new Scanner(System.in);
    int N=keyboard.nextInt();
    int A=keyboard.nextInt();
    int[] in=new int[N];
    for(int i=0 ; i<N ; i++){
      in[i]=keyboard.nextInt();
    }
    for(int i=0 ; i<N ; i++){
      in[i]-=A ;
    }
    long[][] masu=new long[51][5001];
    masu[0][2500]=1 ;
    for(int j=1 ; j<N+1 ; j++){
      for(int k=0 ; k<5001 ; k++){
        if(k-in[j-1]>=0 && k-in[j-1]<=5000){
          masu[j][k]+=masu[j-1][k-in[j-1] ];
          masu[j][k]+=masu[j-1][k];
        }
      }
    }
    System.out.println(masu[N][2500]-1);
    keyboard.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var keyboard : OclFile ; keyboard := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := keyboard.getCurrent()->toInteger() ;
    var A : int ; A := keyboard.getCurrent()->toInteger() ;
    var in : Sequence(int) ; in := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     in[i+1] := keyboard.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     in[i+1] := in[i+1]-(A) )  ;     i := i + 1 ) ; 
    var masu : Sequence(Sequence(long)) ; masu := Integer.subrange(1,51)->collect(Integer.subrange(1,5001)->collect(0)) ;
    masu[0+1][2500+1] := 1 ; 
        var j : int ; j := 1 ; while j < N + 1 do ( (         var k : int ; k := 0 ; while k < 5001 do ( (     if (k - in[j - 1+1] >= 0 & k - in[j - 1+1] <= 5000) then (     masu[j+1][k+1] := masu[j+1][k+1]+(masu[j - 1+1][k - in[j - 1+1]+1]) ; 
     masu[j+1][k+1] := masu[j+1][k+1]+(masu[j - 1+1][k+1]) ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(masu[N+1][2500+1] - 1) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int A=sc.nextInt();
    int[] x=new int[N+1];
    for(int i=1 ; i<=N ; ++i){
      x[i]=sc.nextInt();
    }
    long[][][] dp=new long[N+1][N+1][N*A+1];
    for(int i=0 ; i<N ; ++i){
      dp[i][0][0]=1 ;
    }
    for(int i=1 ; i<=N ; ++i){
      for(int j=1 ; j<=i ; ++j){
        for(int k=1 ; k<=N*A ; ++k){
          if(k<x[i]){
            dp[i][j][k]=dp[i-1][j][k];
          }
          else {
            dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-x[i] ];
          }
        }
      }
    }
    long ans=0 ;
    for(int j=1 ; j<=N ; ++j){
      ans+=dp[N][j][j*A];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : int ; A := sc.getCurrent()->toInteger() ;
    var x : Sequence(int) ; x := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= N do ( (     x[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(Sequence(long))) ; dp := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N * A + 1)->collect(0))) ;
        var i : int ; i := 0 ; while i < N do ( (     dp[i+1][0+1][0+1] := 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do ( (         var j : int ; j := 1 ; while j <= i do ( (         var k : int ; k := 1 ; while k <= N * A do ( (     if (k < x[i+1]) then (     dp[i+1][j+1][k+1] := dp[i - 1+1][j+1][k+1] ) else (     dp[i+1][j+1][k+1] := dp[i - 1+1][j+1][k+1] + dp[i - 1+1][j - 1+1][k - x[i+1]+1] ) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var j : int ; j := 1 ; while j <= N do ( (     ans := ans+(dp[N+1][j+1][j * A+1]) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int MAX=100001 ;
  static ArrayList<Integer>p=new ArrayList<Integer>();
  static void sieve(){
    int[] isPrime=new int[MAX+1];
    for(int i=2 ; i<=MAX ; i++){
      if(isPrime[i]==0){
        p.add(i);
        for(int j=2 ; i*j<=MAX ; j++)isPrime[i*j]=1 ;
      }
    }
  }
  static int phi(int n){
    int res=n ;
    for(int i=0 ; p.get(i)*p.get(i)<=n ; i++){
      if(n % p.get(i)==0){
        res-=(res/p.get(i));
        while(n % p.get(i)==0)n/=p.get(i);
      }
    }
    if(n>1)res-=(res/n);
    return res ;
  }
  public static void main(String[] args){
    sieve();
    System.out.println(phi(11));
    System.out.println(phi(21));
    System.out.println(phi(31));
    System.out.println(phi(41));
    System.out.println(phi(51));
    System.out.println(phi(61));
    System.out.println(phi(91));
    System.out.println(phi(101));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX : int := 100001;
  static   attribute p : Sequence(int) := Sequence{};
  static   operation sieve() : void
  pre: true
  post: true
  activity: (     var isPrime : Sequence(int) ; isPrime := Integer.subrange(1,MAX + 1)->collect(0) ;
         var i : int ; i := 2 ; while i <= MAX do ( (     if (isPrime[i+1] = 0) then (     p := p->including(i) ; 
         var j : int ; j := 2 ; while i * j <= MAX do (     isPrime[i * j+1] := 1 ;  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) );
  static   operation phi( n : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := n ;
         var i : int ; i := 0 ; while p->at(i+1) * p->at(i+1) <= n do ( (     if (n mod p->at(i+1) = 0) then (     res := res-((res / p->at(i+1))) ; 
     while (n mod p->at(i+1) = 0) do     n := n/(p->at(i+1)) ; ) else skip )  ;     i := i + 1 ) ; 
     if (n > 1) then     res := res-((res / n)) ; else skip ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute sieve() ; 
     OclFile["System.out"].println(phi(11)) ; 
    OclFile["System.out"].println(phi(21)) ; 
    OclFile["System.out"].println(phi(31)) ; 
    OclFile["System.out"].println(phi(41)) ; 
    OclFile["System.out"].println(phi(51)) ; 
    OclFile["System.out"].println(phi(61)) ; 
    OclFile["System.out"].println(phi(91)) ; 
    OclFile["System.out"].println(phi(101)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPossible(Vector<String>v,String str){
    str=sortString(str);
    for(int i=0 ; i<v.size()-1 ; i++){
      for(int j=i+1 ; j<v.size(); j++){
        String temp=v.get(i)+v.get(j);
        temp=sortString(temp);
        if(temp.compareTo(str)==0){
          return true ;
        }
      }
    }
    return false ;
  }
  public static String sortString(String inputString){
    char tempArray[]=inputString.toCharArray();
    Arrays.sort(tempArray);
    return new String(tempArray);
  }
  public static void main(String[] args){
    String str="amazon" ;
    String[] arr={
      "fds","oxq","zoa","epw","amn" };
      Vector<String>v=new Vector<String>(Arrays.asList(arr));
      if(isPossible(v,str))System.out.println("Yes");
      else System.out.println("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPossible( v : Sequence(String), str : String) : boolean
  pre: true
  post: true
  activity: (     str := sortString(str) ; 
         var i : int ; i := 0 ; while i < v->size() - 1 do ( (         var j : int ; j := i + 1 ; while j < v->size() do ( (     var temp : String ; temp := v->at(i+1) + v->at(j+1) ;
     temp := sortString(temp) ; 
     if (temp->compareTo(str) = 0) then (     return true ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return false );
  static   operation sortString( inputString : String) : String
  pre: true
  post: true
  activity: (     var tempArray : Sequence(String) ; tempArray := inputString->characters() ;
     tempArray := tempArray->sort() ; 
     return StringLib.newString(tempArray) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "amazon" ;
     var arr : Sequence(String) ; arr := Sequence{"fds","oxq","zoa","epw","amn"} ;
     var v : Sequence(String) ; v := Sequence{}->union(arr) ;
     if (isPossible(v, str)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Div2_365B {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int N=in.nextInt();
    int[] A=new int[N];
    for(int n=0 ; n<N ; n++){
      A[n]=in.nextInt();
    }
    int start=0 ;
    int end=2 ;
    int max=Math.min(N,2);
    while(end<N){
      if(A[end]==A[end-1]+A[end-2]){
        end++;
        max=Math.max(max,end-start);
      }
      else {
        start=end-1 ;
        end=start+2 ;
      }
    }
    pw.println(max);
    pw.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Div2_365B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var N : int ; N := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var start : int ; start := 0 ;
    var end : int ; end := 2 ;
    var max : int ; max := Set{N, 2}->min() ;
    while (end < N) do (     if (A[end+1] = A[end - 1+1] + A[end - 2+1]) then (     end := end + 1 ; 
     max := Set{max, end - start}->max() ) else (     start := end - 1 ; 
     end := start + 2 ) ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int __gcd(int a,int b){
    if(a==0 || b==0)return 0 ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static void coprime(int a,int b){
    if(__gcd(a,b)==1)System.out.println("Co-Prime");
    else System.out.println("Not Co-Prime");
  }
  public static void main(String[] args){
    int a=5,b=6 ;
    coprime(a,b);
    a=8 ;
    b=16 ;
    coprime(a,b);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0 or b = 0) then     return 0 else skip ; 
     if (a = b) then     return a else skip ; 
     if (a > b) then     return __gcd(a - b, b) else skip ; 
     return __gcd(a, b - a) );
  static   operation coprime( a : int, b : int) : void
  pre: true
  post: true
  activity: (     if (__gcd(a, b) = 1) then     OclFile["System.out"].println("Co-Prime") ; else     OclFile["System.out"].println("Not Co-Prime") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 5 ;
    var b : int ; b := 6 ;
     execute coprime(a, b) ; 
    a := 8 ; 
    b := 16 ; 
    execute coprime(a, b) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      scanner.nextInt();
      scanner.nextLine();
      Set<Integer>commonSet=new HashSet<>();
      IntStream.range(0,n).forEach(i->{
        int number=scanner.nextInt();
        Set<Integer>set=new HashSet<>();
        IntStream.range(0,number).forEach(j->set.add(scanner.nextInt()));
        scanner.nextLine();
        if(0==i){
          commonSet.addAll(set);
        }
        else {
          Set<Integer>removeSet=new HashSet<>();
          for(Integer integer : commonSet){
            if(! set.contains(integer)){
              removeSet.add(integer);
            }
          }
          commonSet.removeAll(removeSet);
        }
      }
);
      System.out.println(commonSet.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     skip ; 
    skip ; 
    var commonSet : Set(int) ; commonSet := Set{} ;
    for i : Integer.subrange(0, n-1) do
    (    skip) ; 
    OclFile["System.out"].println(commonSet->size()) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String args[])throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    Solver solver=new Solver();
    solver.init();
    solver.readHead(in.readLine());
    for(; solver.hasNext(); ){
      solver.readBody(in.readLine());
    }
    solver.solve();
  }
}
class Solver {
  int N ;
  int cnt ;
  public void init(){
    N=0 ;
    cnt=0 ;
  }
  int M ;
  public void readHead(String str){
    String[] strArr=str.split(" ");
    N=Integer.parseInt(strArr[0]);
    M=Integer.parseInt(strArr[1]);
    A=new int[N][M];
  }
  public boolean hasNext(){
    return cnt<N ;
  }
  int A[][];
  public void readBody(String str){
    String[] strArr=str.split(" ");
    int k=Integer.parseInt(strArr[0]);
    for(int i=1 ; i<=k ; i++){
      A[cnt][Integer.parseInt(strArr[i])-1]=1 ;
    }
    cnt++;
  }
  public void solve(){
    int ans=0 ;
    for(int m=0 ; m<M ; m++){
      int c=0 ;
      for(int n=0 ; n<N ; n++){
        if(A[n][m]==1)c++;
      }
      if(c==N)ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var solver : Solver ; solver := Solver.newSolver() ;
    solver.init() ; 
    solver.readHead(in.readLine()) ; 
      while solver.hasNext() do ( (     solver.readBody(in.readLine()) )  ) ; 
    solver.solve() ; 
 );
}
class Solver {
   attribute N : int;
   attribute cnt : int;
   operation init() : void
  pre: true
  post: true
  activity: (     N := 0 ; 
     cnt := 0 );
   attribute M : int;
   operation readHead( str : String) : void
  pre: true
  post: true
  activity: (     var strArr : Sequence(String) ; strArr := str->split(" ") ;
     N := (strArr[0+1])->toInteger() ; 
     M := (strArr[1+1])->toInteger() ; 
     A := Integer.subrange(1,N)->collect(Integer.subrange(1,M)->collect(0)) );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return cnt < N );
   attribute A : Sequence(Sequence(int));
   operation readBody( str : String) : void
  pre: true
  post: true
  activity: (     var strArr : Sequence(String) ; strArr := str->split(" ") ;
     var k : int ; k := (strArr[0+1])->toInteger() ;
         var i : int ; i := 1 ; while i <= k do ( (     A[cnt+1][(strArr[i+1])->toInteger() - 1+1] := 1 )  ;     i := i + 1 ) ; 
     cnt := cnt + 1 );
   operation solve() : void
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
         var m : int ; m := 0 ; while m < M do ( (     var c : int ; c := 0 ;
         var n : int ; n := 0 ; while n < N do ( (     if (A[n+1][m+1] = 1) then     c := c + 1 ; else skip )  ;     n := n + 1 ) ; 
     if (c = N) then     ans := ans + 1 ; else skip )  ;     m := m + 1 ) ; 
     OclFile["System.out"].println(ans) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class black {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t,n,m,i,j,k,sum ;
    String s[];
    t=sc.nextInt();
    for(j=1 ; j<=t ; j++){
      n=sc.nextInt();
      m=sc.nextInt();
      s=new String[n];
      for(i=0 ; i<n ; i++)s[i]=sc.next();
      for(i=0 ; i<n-1 ; i++){
        for(k=0 ; k<m-1 ; k++){
          sum=(s[i] .charAt(k)-48)+(s[i] .charAt(k+1)-48)+(s[i+1] .charAt(k)-48)+(s[i+1] .charAt(k+1)-48);
          if(sum==3)break ;
        }
        if(k!=m-1)break ;
      }
      if(i==n-1)System.out.println("YES");
      else System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class black {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ;
    var n : int ;
    var m : int ;
    var i : int ;
    var j : int ;
    var k : int ;
    var sum : int ;
    var s : Sequence(String) ;
    t := sc.getCurrent()->toInteger() ; 
        j := 1 ; while j <= t do ( (     n := sc.getCurrent()->toInteger() ; 
     m := sc.getCurrent()->toInteger() ; 
    s := Integer.subrange(1,n)->collect(null) ; 
        i := 0 ; while i < n do (     s[i+1] := sc.getCurrent() ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n - 1 do ( (         k := 0 ; while k < m - 1 do ( (     sum := (s[i+1]->at(k+1) - 48) + (s[i+1]->at(k + 1+1) - 48) + (s[i + 1+1]->at(k+1) - 48) + (s[i + 1+1]->at(k + 1+1) - 48) ; 
     if (sum = 3) then     break else skip )  ;     k := k + 1 ) ; 
     if (k /= m - 1) then     break else skip )  ;     i := i + 1 ) ; 
    if (i = n - 1) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    int[][] like=new int[N][M+1];
    for(int i=0 ; i<N ; ++i){
      like[i][0]=sc.nextInt();
      for(int j=1 ; j<=like[i][0]; ++j){
        like[i][j]=sc.nextInt();
      }
    }
    int count[]=new int[M];
    for(int i=0 ; i<M ; ++i){
      count[i]=0 ;
    }
    for(int i=0 ; i<N ; ++i){
      for(int j=1 ; j<M+1 ; ++j){
        for(int k=1 ; k<=M ; ++k){
          if(k==like[i][j]){
            count[k-1]++;
          }
        }
      }
    }
    int ans=0 ;
    for(int i=0 ; i<M ; ++i){
      if(count[i]==N){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var like : Sequence(Sequence(int)) ; like := Integer.subrange(1,N)->collect(Integer.subrange(1,M + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (     like[i+1][0+1] := sc.getCurrent()->toInteger() ; 
         var j : int ; j := 1 ; while j <= like[i+1][0+1] do ( (     like[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : Sequence(int) ; count := Integer.subrange(1,M)->collect(0) ;
        var i : int ; i := 0 ; while i < M do ( (     count[i+1] := 0 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 1 ; while j < M + 1 do ( (         var k : int ; k := 1 ; while k <= M do ( (     if (k = like[i+1][j+1]) then (     count[k - 1+1] := count[k - 1+1] + 1 ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     if (count[i+1] = N) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Map.Entry ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String[] temp=scanner.nextLine().split(" ");
    int n=Integer.parseInt(temp[0]);
    int m=Integer.parseInt(temp[1]);
    Map<Integer,Integer>ans=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      String[] list=scanner.nextLine().split(" ");
      for(int j=1 ; j<list.length ; j++){
        int put=Integer.parseInt(list[j]);
        if(ans.containsKey(put)){
          ans.put(put,ans.get(put)+1);
        }
        else {
          ans.put(put,1);
        }
      }
    }
    int a=0 ;
    for(Entry<Integer,Integer>entry : ans.entrySet()){
      if(entry.getValue()==n){
        a++;
      }
    }
    System.out.println(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var temp : Sequence(String) ; temp := scanner.nextLine()->split(" ") ;
    var n : int ; n := (temp[0+1])->toInteger() ;
    var m : int ; m := (temp[1+1])->toInteger() ;
    var ans : Map(int,int) ; ans := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var list : Sequence(String) ; list := scanner.nextLine()->split(" ") ;
         var j : int ; j := 1 ; while j < list->size() do ( (     var put : int ; put := (list[j+1])->toInteger() ;
     if (ans->keys()->includes(put)) then (     ans := ans->union(Map{put |-> ans->at(put) + 1}) ) else (     ans := ans->union(Map{put |-> 1}) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var a : int ; a := 0 ;
    for (entry : ans->asSet()) do ( (     if (entry.getValue() = n) then (     a := a + 1 ) else skip )  ) ; 
    OclFile["System.out"].println(a) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    Set<Integer>list=new HashSet<>();
    int persons ;
    try(Scanner sc=new Scanner(System.in);
){
      persons=sc.nextInt();
      sc.nextInt();
      int num=sc.nextInt();
      for(int i=0 ; i<num ; i++){
        list.add(sc.nextInt());
      }
      for(int p=0 ; p<persons-1 ; p++){
        int num1=sc.nextInt();
        Set<Integer>templist=new HashSet<>();
        for(int i=0 ; i<num1 ; i++){
          templist.add(sc.nextInt());
        }
        list.retainAll(templist);
      }
    }
    System.out.println(list.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var list : Set(int) ; list := Set{} ;
     var persons : int ;
     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     persons := sc.getCurrent()->toInteger() ; 
     skip ; 
    var num : int ; num := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < num do ( (     list := list->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
        var p : int ; p := 0 ; while p < persons - 1 do ( (     var num1 : int ; num1 := sc.getCurrent()->toInteger() ;
     var templist : Set(int) ; templist := Set{} ;
         var i : int ; i := 0 ; while i < num1 do ( (     templist := templist->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
     list := list->intersection(templist) )  ;     p := p + 1 ) ; 
 ))  
     OclFile["System.out"].println(list->size()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
import java.util.HashMap ;
import java.lang.Integer ;
import java.lang.StringBuilder ;
import java.lang.Math ;
public class Main {
  private static int N ;
  private static int T ;
  private static int[] a ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    N=in.nextInt();
    T=in.nextInt();
    a=new int[N];
    for(int i=0 ; i<N ; i++){
      a[i]=in.nextInt();
    }
    int cnt=0 ;
    int maxDiff=Integer.MIN_VALUE ;
    int min=a[0];
    for(int i=1 ; i<N ; i++){
      if(min>a[i-1]){
        min=a[i-1];
      }
      int diff=a[i]-min ;
      if(diff<=0){
        continue ;
      }
      if(maxDiff<diff){
        maxDiff=diff ;
        cnt=1 ;
      }
      else if(maxDiff==diff){
        cnt++;
      }
    }
    System.out.println(cnt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute N : int;
  static   attribute T : int;
  static   attribute a : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := in.getCurrent()->toInteger() ; 
    T := in.getCurrent()->toInteger() ; 
    a := Integer.subrange(1,N)->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var cnt : int ; cnt := 0 ;
    var maxDiff : int ; maxDiff := -2147483648 ;
    var min : int ; min := a[0+1] ;
        var i : int ; i := 1 ; while i < N do ( (     if (min > a[i - 1+1]) then (     min := a[i - 1+1] ) else skip ; 
     var diff : int ; diff := a[i+1] - min ;
     if (diff <= 0) then (     continue ) else skip ; 
     if (maxDiff < diff) then (     maxDiff := diff ; 
     cnt := 1 ) else     if (maxDiff = diff) then (     cnt := cnt + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
@ SuppressWarnings("unchecked")public class Main {
  public static String joinInt(int[] a,String separator){
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<a.length ; i++){
      if(i>0){
        sb.append(separator);
      }
      sb.append(a[i]);
    }
    return sb.toString();
  }
  static int[] nextIntArray(Scanner sc,int N){
    int[] arr=new int[N];
    for(int i=0 ; i<N ; i++){
      arr[i]=sc.nextInt();
    }
    return arr ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int T=sc.nextInt();
    int[] A=nextIntArray(sc,N);
    int min=Integer.MAX_VALUE ;
    int maxDiff=0 ;
    int cntMax=0 ;
    for(int a : A){
      if(a<min){
        min=a ;
        continue ;
      }
      int diff=a-min ;
      if(diff>maxDiff){
        maxDiff=diff ;
        cntMax=1 ;
        continue ;
      }
      if(diff==maxDiff){
        cntMax++;
      }
    }
    System.out.println(cntMax);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation joinInt( a : Sequence(int), separator : String) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < a->size() do ( (     if (i > 0) then (     sb := sb + StringLib.newString(separator) ) else skip ; 
     sb := sb + StringLib.newString(a[i+1]) )  ;     i := i + 1 ) ; 
     return sb+"" );
  static   operation nextIntArray( sc : OclFile, N : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,N)->collect(0) ;
         var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
     return arr );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := nextIntArray(sc, N) ;
    var min : int ; min := 2147483647 ;
    var maxDiff : int ; maxDiff := 0 ;
    var cntMax : int ; cntMax := 0 ;
    for (a : A) do ( (     if (a < min) then (     min := a ; 
     continue ) else skip ; 
     var diff : int ; diff := a - min ;
     if (diff > maxDiff) then (     maxDiff := diff ; 
     cntMax := 1 ; 
     continue ) else skip ; 
     if (diff = maxDiff) then (     cntMax := cntMax + 1 ) else skip )  ) ; 
    OclFile["System.out"].println(cntMax) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class Main {
  public static void main(String[] args){
    try(Scanner scanner=new Scanner(System.in)){
      int n=scanner.nextInt();
      scanner.nextInt();
      int[] a=IntStream.range(0,n).map(i->scanner.nextInt()).toArray();
      int[] max=new int[n];
      max[n-1]=a[n-1];
      IntStream.range(1,n).map(i->n-1-i).forEach(i->max[i]=Math.max(max[i+1],a[i]));
      Map<Integer,Integer>map=new HashMap<>();
      int maxResult=IntStream.range(0,n).map(i->{
        int result=max[i]-a[i];
        map.put(result,map.getOrDefault(result,0)+1);
        return result ;
      }
).max().getAsInt();
      System.out.println(map.get(maxResult));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     skip ; 
    var a : Sequence(int) ; a := Integer.subrange(0, n-1)->collect( _x1 | (lambda i : OclAny in scanner.getCurrent()->toInteger())->apply(_x1) )->asSequence() ;
    var max : Sequence(int) ; max := Integer.subrange(1,n)->collect(0) ;
    max[n - 1+1] := a[n - 1+1] ; 
    for i : Integer.subrange(1, n-1)->collect( _x1 | (lambda i : OclAny in n - 1 - i)->apply(_x1) ) do
    (    max[i+1] := Set{max[i + 1+1], a[i+1]}->max()) ; 
    var map : Map(int,int) ; map := Map{} ;
    var maxResult : int ; maxResult := Integer.subrange(0, n-1)->collect( _x1 | (lambda i : OclAny in (     var result : int ; result := max[i+1] - a[i+1] ;
     map := map->union(Map{result |-> (if map->keys()->contains(result) then map->at(result) else 0 endif) + 1}) ; 
     return result ))->apply(_x1) ).max().getAsInt() ;
    OclFile["System.out"].println(map->at(maxResult)) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.awt.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(in);
    int n=sc.nextInt();
    int t=sc.nextInt();
    int[] a=new int[n+1];
    int leftmin=1000000001 ;
    int dmax=0 ;
    int[] ansarr=new int[n+1];
    int count=0 ;
    for(int i=1 ; i<=n ; i++){
      a[i]=sc.nextInt();
      leftmin=min(leftmin,a[i]);
      dmax=max(dmax,a[i]-leftmin);
      if(a[i]-leftmin==dmax){
        ansarr[i]=dmax ;
      }
    }
    for(int i=1 ; i<=n ; i++){
      if(dmax==ansarr[i])count++;
    }
    out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(in) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var leftmin : int ; leftmin := 1000000001 ;
    var dmax : int ; dmax := 0 ;
    var ansarr : Sequence(int) ; ansarr := Integer.subrange(1,n + 1)->collect(0) ;
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     leftmin := Set{leftmin, a[i+1]}->min() ; 
     dmax := Set{dmax, a[i+1] - leftmin}->max() ; 
     if (a[i+1] - leftmin = dmax) then (     ansarr[i+1] := dmax ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (dmax = ansarr[i+1]) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    out.println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class B {
  static class Reader {
    BufferedReader in ;
    Reader()throws IOException {
      in=new BufferedReader(new InputStreamReader(System.in));
    }
    StringTokenizer tokin=new StringTokenizer("");
    String next()throws IOException {
      if(! tokin.hasMoreTokens()){
        tokin=new StringTokenizer(in.readLine());
      }
      return tokin.nextToken();
    }
    int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
  }
  public static void main(String[] args)throws IOException {
    Reader in=new Reader();
    StringBuilder str=new StringBuilder();
    int t=in.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=in.nextInt();
      for(int j=0 ; j<n ; j++){
        in.next();
      }
      int k=n*3 ;
      str.append(k+"\n");
      for(int j=0 ; j<n ; j+=2){
        str.append("1 "+(j+1)+" "+(j+2)+"\n");
        str.append("2 "+(j+1)+" "+(j+2)+"\n");
        str.append("1 "+(j+1)+" "+(j+2)+"\n");
        str.append("2 "+(j+1)+" "+(j+2)+"\n");
        str.append("1 "+(j+1)+" "+(j+2)+"\n");
        str.append("2 "+(j+1)+" "+(j+2)+"\n");
      }
    }
    System.out.print(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static class Reader {
   attribute in : OclFile;
   static operation newReader() : Reader
  pre: true
  post: true
  activity:
  ( var self : Reader ;
    self := createReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   attribute tokin : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     if (not(tokin.hasNext())) then (     tokin := OclIterator.newOclIterator_String(in.readLine()) ) else skip ; 
     return tokin.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile() ;
     var str : String ; str := StringLib.newString() ;
    var t : int ; t := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < n do ( (     skip )  ;     j := j + 1 ) ; 
    var k : int ; k := n * 3 ;
    str := str + StringLib.newString(k + "\n") ; 
        var j : int ; j := 0 ; while j < n do ( (     str := str + StringLib.newString("1 " + (j + 1) + " " + (j + 2) + "\n") ; 
     str := str + StringLib.newString("2 " + (j + 1) + " " + (j + 2) + "\n") ; 
    str := str + StringLib.newString("1 " + (j + 1) + " " + (j + 2) + "\n") ; 
    str := str + StringLib.newString("2 " + (j + 1) + " " + (j + 2) + "\n") ; 
    str := str + StringLib.newString("1 " + (j + 1) + " " + (j + 2) + "\n") ; 
    str := str + StringLib.newString("2 " + (j + 1) + " " + (j + 2) + "\n") ; 
 )  ;     j := j+(2) ) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    int t=Integer.parseInt(st.nextToken());
    int[] a=new int[n];
    st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(st.nextToken());
    }
    int score=0 ;
    int min=a[0],max=a[0];
    for(int i=0 ; i<n ; i++){
      if(min>a[i]){
        max=a[i];
        min=a[i];
      }
      else {
        max=Math.max(a[i],max);
      }
      score=Math.max(score,max-min);
    }
    int second_score=0 ;
    min=a[0];
    max=a[0];
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(min>a[i]){
        max=a[i];
        min=a[i];
        second_score=0 ;
      }
      else {
        max=Math.max(a[i],max);
        if(second_score<max-min){
          second_score=max-min ;
          if(second_score==score){
            count++;
          }
        }
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var t : int ; t := (st.next())->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    var score : int ; score := 0 ;
    var min : int ; min := a[0+1] ;
    var max : int ; max := a[0+1] ;
        var i : int ; i := 0 ; while i < n do ( (     if (min > a[i+1]) then (     max := a[i+1] ; 
     min := a[i+1] ) else (     max := Set{a[i+1], max}->max() ) ;  
     score := Set{score, max - min}->max() )  ;     i := i + 1 ) ; 
    var second_score : int ; second_score := 0 ;
    min := a[0+1] ; 
    max := a[0+1] ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (min > a[i+1]) then (     max := a[i+1] ; 
     min := a[i+1] ; 
     second_score := 0 ) else (     max := Set{a[i+1], max}->max() ; 
     if (second_score < max - min) then (     second_score := max - min ; 
     if (second_score = score) then (     count := count + 1 ) else skip ) else skip ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.rmi.server.RemoteServer ;
import java.security.cert.CollectionCertStoreParameters ;
import java.util.*;
import javax.xml.transform.SourceLocator ;
public class A_Definite_Game {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    if(n==1){
      System.out.println(1);
    }
    else if(n==2){
      System.out.println(2);
    }
    else System.out.println(1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Definite_Game {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
     if (n = 1) then (     OclFile["System.out"].println(1) ) else     if (n = 2) then (     OclFile["System.out"].println(2) ) else     OclFile["System.out"].println(1) ; ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.*;
import java.io.*;
import java.util.*;
public class Main {
  int[] dp ;
  int max=1000 ;
  private void doit(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] value=new int[n];
      int[] number=new int[n];
      for(int i=0 ; i<n ; i++){
        value[i]=sc.nextInt();
        number[i]=sc.nextInt();
      }
      dp=new int[max+1];
      for(int i=0 ; i<n ; i++){
        for(int k=max ; k>0 ; k--){
          if(dp[k]>0){
            for(int j=1 ; j<=number[i]; j++){
              int ind=value[i]*j+k ;
              if(ind>max)continue ;
              dp[ind]+=dp[k];
            }
          }
        }
        for(int j=1 ; j<=number[i]; j++){
          int ind=value[i]*j ;
          if(ind>max)continue ;
          dp[ind]++;
        }
      }
      int m=sc.nextInt();
      StringBuilder ans=new StringBuilder();
      while(m-->0){
        int input=sc.nextInt();
        ans.append(dp[input]+"\n");
      }
      System.out.print(ans.toString());
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute dp : Sequence(int);
   attribute max : int := 1000;
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var value : Sequence(int) ; value := Integer.subrange(1,n)->collect(0) ;
    var number : Sequence(int) ; number := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     value[i+1] := sc.getCurrent()->toInteger() ; 
     number[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    dp := Integer.subrange(1,max + 1)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (         var k : int ; k := max ; while k > 0 do ( (     if (dp[k+1] > 0) then (         var j : int ; j := 1 ; while j <= number[i+1] do ( (     var ind : int ; ind := value[i+1] * j + k ;
     if (ind > max) then     continue else skip ; 
     dp[ind+1] := dp[ind+1]+(dp[k+1]) )  ;     j := j + 1 ) ) else skip )  ;     k := k - 1 ) ; 
         var j : int ; j := 1 ; while j <= number[i+1] do ( (     var ind : int ; ind := value[i+1] * j ;
     if (ind > max) then     continue else skip ; 
     dp[ind+1] := dp[ind+1] + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var ans : String ; ans := StringLib.newString() ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     var input : int ; input := sc.getCurrent()->toInteger() ;
     ans := ans + StringLib.newString(dp[input+1] + "\n") ) ;  ) ;  
    OclFile["System.out"].print(ans+"") ; 
 ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int tc=1 ;
    while(tc-->0){
      int n=sc.nextInt();
      int k=sc.nextInt();
      int len[]=new int[n];
      String s ;
      int min=0,max=0 ;
      for(int i=0 ; i<n ; i++){
        s=sc.next();
        len[i]=s.length();
      }
      String p=sc.next();
      int plen=p.length();
      int kk=k ;
      Arrays.sort(len);
      for(int i=0 ; i<n ; i++){
        if(len[i]==plen){
          min++;
          break ;
        }
        if(k>0){
          k--;
          min++;
        }
        if(k==0){
          k=kk ;
          min+=5 ;
        }
      }
      k=kk ;
      for(int i=0 ; i<n-1 ; i++){
        if((len[i]==plen && len[i+1]>plen)){
          max++;
          break ;
        }
        if(k>0){
          k--;
          max++;
        }
        if(k==0){
          k=kk ;
          max+=5 ;
        }
      }
      if(len[n-1]==plen)max++;
      System.out.println(min+" "+max);
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var tc : int ; tc := 1 ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var len : Sequence(int) ; len := Integer.subrange(1,n)->collect(0) ;
    var s : String ;
    var min : int ; min := 0 ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     s := sc.getCurrent() ; 
     len[i+1] := s->size() )  ;     i := i + 1 ) ; 
    var p : String ; p := sc.getCurrent() ;
    var plen : int ; plen := p->size() ;
    var kk : int ; kk := k ;
    len := len->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     if (len[i+1] = plen) then (     min := min + 1 ; 
     break ) else skip ; 
     if (k > 0) then (     k := k - 1 ; 
     min := min + 1 ) else skip ; 
     if (k = 0) then (     k := kk ; 
     min := min+(5) ) else skip )  ;     i := i + 1 ) ; 
    k := kk ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     if ((len[i+1] = plen & len[i + 1+1] > plen)) then (     max := max + 1 ; 
     break ) else skip ; 
     if (k > 0) then (     k := k - 1 ; 
     max := max + 1 ) else skip ; 
     if (k = 0) then (     k := kk ; 
     max := max+(5) ) else skip )  ;     i := i + 1 ) ; 
    if (len[n - 1+1] = plen) then     max := max + 1 ; else skip ; 
    OclFile["System.out"].println(min + " " + max) ; 
 ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.LinkedList ;
import java.util.Scanner ;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    if(n==2){
      System.out.println(2);
    }
    else System.out.println(1);
  }
  public static int digits(int num){
    int cnt=0 ;
    while(num!=0){
      cnt++;
      num/=10 ;
    }
    return cnt ;
  }
  public static boolean isPalindrome(String s){
    StringBuilder sb=new StringBuilder(s);
    if(sb.toString().equalsIgnoreCase(sb.reverse().toString())){
      return true ;
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 2) then (     OclFile["System.out"].println(2) ) else     OclFile["System.out"].println(1) ; );
  static   operation digits( num : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     while (num /= 0) do (     cnt := cnt + 1 ; 
     num := num/(10) ) ; 
     return cnt );
  static   operation isPalindrome( s : String) : boolean
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString(s) ;
     if (sb+""->equalsIgnoreCase(sb->reverse()+"")) then (     return true ) else skip ; 
     return false );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    if(n==2)System.out.println(2);
    else System.out.println(1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
     if (n = 2) then     OclFile["System.out"].println(2) ; else     OclFile["System.out"].println(1) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static final int UP='A'-'a' ;
  private static final int LOW=-UP ;
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    char s[];
    char targetType ;
    StringBuilder sb=new StringBuilder(100);
    while(in.hasNext()){
      s=in.next().toCharArray();
      sb.setLength(0);
      targetType=in.next().charAt(0);
      if(targetType=='X'){
        break ;
      }
      if(targetType=='U'){
        if(!(s[0]<='Z')){
          s[0]+=UP ;
        }
      }
      else {
        if(s[0]<='Z'){
          s[0]+=LOW ;
        }
      }
      sb.append(s[0]);
      for(int i=1 ; i<s.length ; i++){
        if(s[i]=='_'){
          s[i+1]+=UP ;
        }
        else if(s[i]<='Z' && targetType=='D'){
          s[i]+=LOW ;
          sb.append('_').append(s[i]);
        }
        else {
          sb.append(s[i]);
        }
      }
      System.out.println(sb.toString());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute UP : int := ('A')->char2byte() - ('a')->char2byte();
  static    attribute LOW : int := -UP;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ;
    var targetType : String ;
    var sb : String ; sb := StringLib.newString(100) ;
    while (in.hasNext()) do (     s := in.getCurrent()->characters() ; 
     sb := sb.subrange(1,0) ; 
    targetType := in.getCurrent()->at(0+1) ; 
    if (targetType = 'X') then (     break ) else skip ; 
    if (targetType = 'U') then (     if (not((s[0+1] <= 'Z'))) then (     s[0+1] := s[0+1]+(UP) ) else skip ) else (     if (s[0+1] <= 'Z') then (     s[0+1] := s[0+1]+(LOW) ) else skip ) ;  
    sb := sb + StringLib.newString(s[0+1]) ; 
        var i : int ; i := 1 ; while i < s->size() do ( (     if (s[i+1] = '_') then (     s[i + 1+1] := s[i + 1+1]+(UP) ) else     if (s[i+1] <= 'Z' & targetType = 'D') then (     s[i+1] := s[i+1]+(LOW) ; 
     sb := sb + StringLib.newString('_') + StringLib.newString(s[i+1]) ) else (     sb := sb + StringLib.newString(s[i+1]) ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb+"") ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    while(true){
      String word=sc.next();
      String query=sc.next();
      if(query.equals("X"))break ;
      ArrayList<String>elems=new ArrayList<String>();
      if(word.indexOf("_")>=0){
        String[] vals=word.split("_");
        for(String val : vals){
          elems.add(val);
        }
      }
      else {
        int pos=0 ;
        for(int i=1 ; i<word.length(); ++i){
          if(Character.isUpperCase(word.charAt(i))){
            elems.add(word.substring(pos,i).toLowerCase());
            pos=i ;
          }
        }
        elems.add(word.substring(pos).toLowerCase());
      }
      StringBuilder result=new StringBuilder();
      if(query.equals("U")){
        for(int i=0 ; i<elems.size(); ++i){
          result.append(Character.toUpperCase(elems.get(i).charAt(0)));
          result.append(elems.get(i).substring(1));
        }
      }
      else if(query.equals("L")){
        result.append(elems.get(0));
        for(int i=1 ; i<elems.size(); ++i){
          result.append(Character.toUpperCase(elems.get(i).charAt(0)));
          result.append(elems.get(i).substring(1));
        }
      }
      else {
        result.append(elems.get(0));
        for(int i=1 ; i<elems.size(); ++i){
          result.append("_");
          result.append(elems.get(i));
        }
      }
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (true) do (     var word : String ; word := sc.getCurrent() ;
     var query : String ; query := sc.getCurrent() ;
    if (query = "X") then     break else skip ; 
    var elems : Sequence(String) ; elems := Sequence{} ;
    if (word->indexOf("_")-1 >= 0) then (     var vals : Sequence(String) ; vals := word->split("_") ;
     for (val : vals) do ( (     elems := elems->including(val) )  ) ) else (     var pos : int ; pos := 0 ;
         var i : int ; i := 1 ; while i < word->size() do ( (     if ((word->at(i+1)->toUpperCase() = word->at(i+1))) then (     elems := elems->including(word.subrange(pos+1,i)->toLowerCase()) ; 
     pos := i ) else skip )  ;     i := i + 1 ) ; 
     elems := elems->including(word.subrange(pos+1,pos)->toLowerCase()) ) ;  
    var result : String ; result := StringLib.newString() ;
    if (query = "U") then (         var i : int ; i := 0 ; while i < elems->size() do ( (     result := result + StringLib.newString((elems->at(i+1)->at(0+1) + "")->toUpperCase()) ; 
     result := result + StringLib.newString(elems->at(i+1).subrange(1+1,1)) )  ;     i := i + 1 ) ) else     if (query = "L") then (     result := result + StringLib.newString(elems->at(0+1)) ; 
         var i : int ; i := 1 ; while i < elems->size() do ( (     result := result + StringLib.newString((elems->at(i+1)->at(0+1) + "")->toUpperCase()) ; 
     result := result + StringLib.newString(elems->at(i+1).subrange(1+1,1)) )  ;     i := i + 1 ) ) else (     result := result + StringLib.newString(elems->at(0+1)) ; 
         var i : int ; i := 1 ; while i < elems->size() do ( (     result := result + StringLib.newString("_") ; 
     result := result + StringLib.newString(elems->at(i+1)) )  ;     i := i + 1 ) ) ;  ;  
    OclFile["System.out"].println(result) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      String s=sc.next();
      String t=sc.next();
      if(t.charAt(0)=='X')break ;
      char[] a=s.toCharArray();
      char[] b=t.toCharArray();
      if(s.contains("_")==true){
        if(b[0]=='D')System.out.print(s);
        else {
          if(b[0]=='U' &&(int)a[0]>96)a[0]-=32 ;
          else if(b[0]=='L' &&(int)a[0]<96)a[0]+=32 ;
          for(int i=0 ; i<a.length ; i++){
            if(a[i]=='_')a[i+1]-=32 ;
            else System.out.print(a[i]);
          }
        }
      }
      else {
        if(b[0]=='D'){
          if((int)a[0]<96)a[0]+=32 ;
          for(int i=0 ; i<a.length ; i++){
            if((int)a[i]<96){
              System.out.print('_');
              a[i]+=32 ;
            }
            System.out.print(a[i]);
          }
        }
        else {
          if(b[0]=='U' &&(int)a[0]>96)a[0]-=32 ;
          else if(b[0]=='L' &&(int)a[0]<96)a[0]+=32 ;
          for(int i=0 ; i<a.length ; i++)System.out.print(a[i]);
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var s : String ; s := sc.getCurrent() ;
     var t : String ; t := sc.getCurrent() ;
    if (t->at(0+1) = 'X') then     break else skip ; 
    var a : Sequence(String) ; a := s->characters() ;
    var b : Sequence(String) ; b := t->characters() ;
    if (s->includes("_") = true) then (     if (b[0+1] = 'D') then     OclFile["System.out"].print(s) ; else (     if (b[0+1] = 'U' & a[0+1]->oclAsType(int) > 96) then     a[0+1] := a[0+1]-(32) else     if (b[0+1] = 'L' & a[0+1]->oclAsType(int) < 96) then     a[0+1] := a[0+1]+(32) ; else skip ; ;  
         var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1] = '_') then     a[i + 1+1] := a[i + 1+1]-(32) ; else     OclFile["System.out"].print(a[i+1]) ; )  ;     i := i + 1 ) ) ) else (     if (b[0+1] = 'D') then (     if (a[0+1]->oclAsType(int) < 96) then     a[0+1] := a[0+1]+(32) ; else skip ; 
         var i : int ; i := 0 ; while i < a->size() do ( (     if (a[i+1]->oclAsType(int) < 96) then (     OclFile["System.out"].print('_') ; 
     a[i+1] := a[i+1]+(32) ) else skip ; 
     OclFile["System.out"].print(a[i+1]) )  ;     i := i + 1 ) ) else (     if (b[0+1] = 'U' & a[0+1]->oclAsType(int) > 96) then     a[0+1] := a[0+1]-(32) else     if (b[0+1] = 'L' & a[0+1]->oclAsType(int) < 96) then     a[0+1] := a[0+1]+(32) ; else skip ; ;  
         var i : int ; i := 0 ; while i < a->size() do (     OclFile["System.out"].print(a[i+1]) ;  ;     i := i + 1 ) ) ) ;  
    OclFile["System.out"].println() ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    String str,input ;
    while(true){
      str=s.next();
      input=s.next();
      if(input.charAt(0)=='X')break ;
      String change="" ;
      String[] column=str.split("_");
      switch(input.charAt(0)){
        case 'U' : if(column.length==1){
          change=(char)(str.charAt(0)&(~ 32))+str.substring(1);
        }
        else {
          for(int i=0 ; i<column.length ; i++){
            change+=(char)(column[i] .charAt(0)&(~ 32))+column[i] .substring(1);
          }
        }
        break ;
        case 'L' : if(column.length==1){
          change=(char)(str.charAt(0)|(32))+str.substring(1);
        }
        else {
          change+=column[0];
          for(int i=1 ; i<column.length ; i++){
            change+=(char)(column[i] .charAt(0)&(~ 32))+column[i] .substring(1);
          }
        }
        break ;
        case 'D' : if(column.length!=1)change=str ;
        else for(int i=0 ;
        i<str.length();
        i++){
          if(i>0 && str.charAt(i)>='A' && str.charAt(i)<='Z'){
            change+="_"+(char)(str.charAt(i)| 32);
          }
          else change+=(char)(str.charAt(i)| 32);
        }
        break ;
      }
      System.out.println(change);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var str : String ;
    var input : String ;
     while (true) do (     str := s.getCurrent() ; 
     input := s.getCurrent() ; 
    if (input->at(0+1) = 'X') then     break else skip ; 
    var change : String ; change := "" ;
    var column : Sequence(String) ; column := str->split("_") ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (input->at(0+1)) ; 
       if _switchval = 'U' then
     if (column->size() = 1) then (     change := (str->at(0+1) & (-(32 + 1)))->oclAsType(String) + str.subrange(1+1,1) ) else (         var i : int ; i := 0 ; while i < column->size() do ( (     change := change+((column[i+1]->at(0+1) & (-(32 + 1)))->oclAsType(String) + column[i+1].subrange(1+1,1)) )  ;     i := i + 1 ) ) ;  
    break 
   else skip ;
       if _switchval = 'L' then
     if (column->size() = 1) then (     change := (str->at(0+1) or (32))->oclAsType(String) + str.subrange(1+1,1) ) else (     change := change+(column[0+1]) ; 
         var i : int ; i := 1 ; while i < column->size() do ( (     change := change+((column[i+1]->at(0+1) & (-(32 + 1)))->oclAsType(String) + column[i+1].subrange(1+1,1)) )  ;     i := i + 1 ) ) ;  
    break 
   else skip ;
       if _switchval = 'D' then
     if (column->size() /= 1) then     change := str else         var i : int ; i := 0 ; while i < str->size() do ( (     if (i > 0 & str->at(i+1) >= 'A' & str->at(i+1) <= 'Z') then (     change := change+("_" + (str->at(i+1) or 32)->oclAsType(String)) ) else     change := change+((str->at(i+1) or 32)->oclAsType(String)) ; )  ;     i := i + 1 ) ; ;  
    break 
   else skip ;
 )
    OclFile["System.out"].println(change) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String arg[]){
    Scanner in=new Scanner(System.in);
    for(; ; ){
      char ch[]=in.next().toCharArray();
      String ans="" ;
      String st=in.next();
      if(st.equals("X"))return ;
      else if(st.equals("U"))for(int i=0 ;
      i<ch.length ;
      i++){
        if(ch[i]=='_'){
          ans+=(ch[i+1]+"").toUpperCase();
          i++;
        }
        else {
          String tmp=ch[i]+"" ;
          if(i==0)ans+=tmp.toUpperCase();
          else ans+=tmp ;
        }
      }
      else if(st.equals("L"))for(int i=0 ;
      i<ch.length ;
      i++){
        if(ch[i]=='_'){
          ans+=(ch[i+1]+"").toUpperCase();
          i++;
        }
        else {
          String tmp=ch[i]+"" ;
          if(i==0)ans+=tmp.toLowerCase();
          else ans+=tmp ;
        }
      }
      else if(st.equals("D"))for(int i=0 ;
      i<ch.length ;
      i++){
        if(i!=0 && Character.isUpperCase(ch[i])){
          ans+="_" ;
          ans+=(ch[i]+"").toLowerCase();
        }
        else ans+=(ch[i]+"").toLowerCase();
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var ch : Sequence(String) ; ch := in.getCurrent()->characters() ;
     var ans : String ; ans := "" ;
    var st : String ; st := in.getCurrent() ;
    if (st = "X") then     return else     if (st = "U") then         var i : int ; i := 0 ; while i < ch->size() do ( (     if (ch[i+1] = '_') then (     ans := ans+((ch[i + 1+1] + "")->toUpperCase()) ; 
     i := i + 1 ) else (     var tmp : String ; tmp := ch[i+1] + "" ;
     if (i = 0) then     ans := ans+(tmp->toUpperCase()) ; else     ans := ans+(tmp) ; ) )  ;     i := i + 1 ) else     if (st = "L") then         var i : int ; i := 0 ; while i < ch->size() do ( (     if (ch[i+1] = '_') then (     ans := ans+((ch[i + 1+1] + "")->toUpperCase()) ; 
     i := i + 1 ) else (     var tmp : String ; tmp := ch[i+1] + "" ;
     if (i = 0) then     ans := ans+(tmp->toLowerCase()) ; else     ans := ans+(tmp) ; ) )  ;     i := i + 1 ) else     if (st = "D") then         var i : int ; i := 0 ; while i < ch->size() do ( (     if (i /= 0 & (ch[i+1]->toUpperCase() = ch[i+1])) then (     ans := ans+("_") ; 
     ans := ans+((ch[i+1] + "")->toLowerCase()) ) else     ans := ans+((ch[i+1] + "")->toLowerCase()) ; )  ;     i := i + 1 ) ; else skip ; ;  ;  ;  
    OclFile["System.out"].println(ans) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  public int lengthOfLastWord(final String a){
    int len=0 ;
    String x=a.trim();
    for(int i=0 ; i<x.length(); i++){
      if(x.charAt(i)==' ')len=0 ;
      else len++;
    }
    return len ;
  }
  public static void main(String[] args){
    String input="Geeks For Geeks  " ;
    GFG gfg=new GFG();
    System.out.println("The length of last word is "+gfg.lengthOfLastWord(input));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
   operation lengthOfLastWord( a : String) : int
  pre: true
  post: true
  activity: (     var len : int ; len := 0 ;
     var x : String ; x := a->trim() ;
         var i : int ; i := 0 ; while i < x->size() do ( (     if (x->at(i+1) = ' ') then     len := 0 ; else     len := len + 1 ; )  ;     i := i + 1 ) ; 
     return len );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : String ; input := "Geeks For Geeks  " ;
     var gfg : GFG ; gfg := GFG.newGFG() ;
     OclFile["System.out"].println("The length of last word is " + gfg.lengthOfLastWord(input)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printAsMaximalPrimeSum(int n){
    if(n % 2==1){
      System.out.print("3 ");
      n-=3 ;
    }
    while(n>0){
      System.out.print("2 ");
      n-=2 ;
    }
  }
  public static void main(String[] args){
    int n=5 ;
    printAsMaximalPrimeSum(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printAsMaximalPrimeSum( n : int) : void
  pre: true
  post: true
  activity: (     if (n mod 2 = 1) then (     OclFile["System.out"].print("3 ") ; 
     n := n-(3) ) else skip ; 
     while (n > 0) do (     OclFile["System.out"].print("2 ") ; 
     n := n-(2) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     execute printAsMaximalPrimeSum(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.StringTokenizer ;
import java.util.TreeSet ;
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class pre5 {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
  public static void main(String args[]){
    FastReader obj=new FastReader();
    int tc=obj.nextInt();
    while(tc--!=0){
      int n=obj.nextInt(),arr[]=new int[n];
      for(int i=0 ; i<n ; i++)arr[i]=obj.nextInt();
      int ll[]={
        1,2,1,2,1,2 };
        out.println(ll.length*n/2);
        for(int i=0 ; i<n ; i+=2){
          for(int j=0 ; j<ll.length ; j++)out.println(ll[j]+" "+(i+1)+" "+(i+2));
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class pre5 {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var obj : FastReader ; obj := FastReader.newFastReader() ;
     var tc : int ; tc := obj.nextInt() ;
         while (tc /= 0) do (    skip ; (     var n : int ; n := obj.nextInt() ;
    var arr : Sequence(void) ; arr := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do (     arr[i+1] := obj.nextInt() ;  ;     i := i + 1 ) ; 
    var ll : Sequence(int) ; ll := Sequence{1,2,1,2,1,2} ;
    out.println(ll->size() * n / 2) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < ll->size() do (     out.println(ll[j+1] + " " + (i + 1) + " " + (i + 2)) ;  ;     j := j + 1 ) )  ;     i := i+(2) ) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashSet ;
import java.util.Map ;
import java.util.Set ;
import java.util.TreeMap ;
public class Passwords {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    String[] temp=reader.readLine().split("\\s+");
    int n=Integer.parseInt(temp[0]),k=Integer.parseInt(temp[1]);
    Map<Integer,Set<String>>map=new TreeMap<>();
    for(int i=0 ; i<n ; i++){
      String password=reader.readLine();
      map.putIfAbsent(password.length(),new HashSet<>());
      map.get(password.length()).add(password);
    }
    String password=reader.readLine();
    int minTime=0,maxTime=0 ;
    int wrongAttempts=0 ;
    int smallerPasswords=0 ;
    int sameLengthPasswords=map.get(password.length()).size();
    for(Integer len : map.keySet()){
      if(len==password.length())break ;
      else {
        smallerPasswords+=map.get(len).size();
      }
    }
    minTime+=((smallerPasswords/k)*5)+smallerPasswords ;
    maxTime+=(smallerPasswords/k)*5+smallerPasswords ;
    minTime+=1 ;
    maxTime+=(((smallerPasswords % k)+sameLengthPasswords-1)/k)*5+sameLengthPasswords ;
    System.out.println(String.format("%d %d",minTime,maxTime));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Passwords {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var temp : Sequence(String) ; temp := reader.readLine()->split("\\s+") ;
    var n : int ; n := (temp[0+1])->toInteger() ;
    var k : int ; k := (temp[1+1])->toInteger() ;
    var map : Map(int,Set(String)) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var password : String ; password := reader.readLine() ;
     if map->keys()->includes(password->size()) then skip else map := map->union(Map{password->size() |-> Set{}}) ; 
     map->at(password->size())->excludes(password) )  ;     i := i + 1 ) ; 
    var password : String ; password := reader.readLine() ;
    var minTime : int ; minTime := 0 ;
    var maxTime : int ; maxTime := 0 ;
    var wrongAttempts : int ; wrongAttempts := 0 ;
    var smallerPasswords : int ; smallerPasswords := 0 ;
    var sameLengthPasswords : int ; sameLengthPasswords := map->at(password->size())->size() ;
    for (len : map->keys()) do ( (     if (len = password->size()) then     break else (     smallerPasswords := smallerPasswords+(map->at(len)->size()) ) )  ) ; 
    minTime := minTime+(((smallerPasswords / k) * 5) + smallerPasswords) ; 
    maxTime := maxTime+((smallerPasswords / k) * 5 + smallerPasswords) ; 
    minTime := minTime+(1) ; 
    maxTime := maxTime+((((smallerPasswords mod k) + sameLengthPasswords - 1) / k) * 5 + sameLengthPasswords) ; 
    OclFile["System.out"].println(StringLib.format("%d %d",Sequence{minTime,maxTime})) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int minSwaps(int arr[],int n){
    int numberOfOnes=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==1)numberOfOnes++;
    }
    int x=numberOfOnes ;
    int count_ones=0,maxOnes ;
    for(int i=0 ; i<x ; i++){
      if(arr[i]==1)count_ones++;
    }
    maxOnes=count_ones ;
    for(int i=1 ; i<=n-x ; i++){
      if(arr[i-1]==1)count_ones--;
      if(arr[i+x-1]==1)count_ones++;
      if(maxOnes<count_ones)maxOnes=count_ones ;
    }
    int numberOfZeroes=x-maxOnes ;
    return numberOfZeroes ;
  }
  public static void main(String args[]){
    int a[]=new int[] {
      0,0,1,0,1,1,0,0,1 };
      int n=a.length ;
      System.out.println(minSwaps(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minSwaps( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var numberOfOnes : int ; numberOfOnes := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = 1) then     numberOfOnes := numberOfOnes + 1 ; else skip )  ;     i := i + 1 ) ; 
    var x : int ; x := numberOfOnes ;
    var count_ones : int ; count_ones := 0 ;
    var maxOnes : int ;
        var i : int ; i := 0 ; while i < x do ( (     if (arr[i+1] = 1) then     count_ones := count_ones + 1 ; else skip )  ;     i := i + 1 ) ; 
    maxOnes := count_ones ; 
        var i : int ; i := 1 ; while i <= n - x do ( (     if (arr[i - 1+1] = 1) then     count_ones := count_ones - 1 ; else skip ; 
     if (arr[i + x - 1+1] = 1) then     count_ones := count_ones + 1 ; else skip ; 
     if (maxOnes < count_ones) then     maxOnes := count_ones ; else skip )  ;     i := i + 1 ) ; 
    var numberOfZeroes : int ; numberOfZeroes := x - maxOnes ;
    return numberOfZeroes 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{0,0,1,0,1,1,0,0,1} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(minSwaps(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int countX(int n){
    int count=0 ;
    for(int i=0 ; i<=n ; i++){
      if(n-i==(n ^ i))count++;
    }
    return count ;
  }
  public static void main(String args[]){
    int n=5 ;
    int answer=countX(n);
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countX( n : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := 0 ; while i <= n do ( (     if (n - i = (n xor i)) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     var answer : int ; answer := countX(n) ;
     OclFile["System.out"].println(answer) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void lower(int matrix[][],int row,int col){
    int i,j ;
    for(i=0 ; i<row ; i++){
      for(j=0 ; j<col ; j++){
        if(i<j){
          System.out.print("0"+" ");
        }
        else System.out.print(matrix[i][j]+" ");
      }
      System.out.println();
    }
  }
  static void upper(int matrix[][],int row,int col){
    int i,j ;
    for(i=0 ; i<row ; i++){
      for(j=0 ; j<col ; j++){
        if(i>j){
          System.out.print("0"+" ");
        }
        else System.out.print(matrix[i][j]+" ");
      }
      System.out.println();
    }
  }
  public static void main(String args[]){
    int matrix[][]={
      {
        1,2,3 },{
          4,5,6 },{
            7,8,9 }
          };
          int row=3,col=3 ;
          System.out.println("Lower triangular matrix: ");
          lower(matrix,row,col);
          System.out.println("Upper triangular matrix: ");
          upper(matrix,row,col);
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation lower( matrix : Sequence(Sequence(int)), row : int, col : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := 0 ; while i < row do ( (         j := 0 ; while j < col do ( (     if (i < j) then (     OclFile["System.out"].print("0" + " ") ) else     OclFile["System.out"].print(matrix[i+1][j+1] + " ") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation upper( matrix : Sequence(Sequence(int)), row : int, col : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
         i := 0 ; while i < row do ( (         j := 0 ; while j < col do ( (     if (i > j) then (     OclFile["System.out"].print("0" + " ") ) else     OclFile["System.out"].print(matrix[i+1][j+1] + " ") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var matrix : Sequence(Sequence(int)) ; matrix := Sequence{Sequence{1,2,3},Sequence{4,5,6},Sequence{7,8,9}} ;
     var row : int ; row := 3 ;
    var col : int ; col := 3 ;
    OclFile["System.out"].println("Lower triangular matrix: ") ; 
    execute lower(matrix, row, col) ; 
    OclFile["System.out"].println("Upper triangular matrix: ") ; 
    execute upper(matrix, row, col) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static long difference(long M,long N){
    return M+N ;
  }
  public static void main(String[] args){
    long M=999999999 ;
    long N=1000000000 ;
    System.out.print(difference(M,N)+"\n");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation difference( M : long, N : long) : long
  pre: true
  post: true
  activity: (     return M + N );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var M : long ; M := 999999999 ;
     var N : long ; N := 1000000000 ;
     OclFile["System.out"].print(difference(M, N) + "\n") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int[] a=new int[26];
    for(char c='a' ; c<='z' ; c++){
      int mx=-1 ;
      for(int i=0 ; i<s.length(); i++){
        if(s.charAt(i)==c)mx=i ;
      }
      a[c-'a']=mx ;
    }
    int cur=25 ;
    for(int i=0 ; i<s.length(); i++){
      while(a[cur]==-1)--cur ;
      if(i<=a[cur] && s.charAt(i)==cur+'a'){
        out.print(s.charAt(i));
      }
      else {
        while(i>a[cur])--cur ;
        if(i<=a[cur] && s.charAt(i)==cur+'a'){
          out.print(s.charAt(i));
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var a : Sequence(int) ; a := Integer.subrange(1,26)->collect(0) ;
        var c : String ; c := 'a' ; while c <= 'z' do ( (     var mx : int ; mx := -1 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) = c) then     mx := i ; else skip )  ;     i := i + 1 ) ; 
     a[(c)->char2byte() - ('a')->char2byte()+1] := mx )  ;     c := c + 1 ) ; 
    var cur : int ; cur := 25 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     while (a[cur+1] = -1) do     cur := cur - 1 ; ; 
     if (i <= a[cur+1] & s->at(i+1) = cur + 'a') then (     out.print(s->at(i+1)) ) else (     while (i > a[cur+1]) do     cur := cur - 1 ; ; 
     if (i <= a[cur+1] & s->at(i+1) = cur + 'a') then (     out.print(s->at(i+1)) ) else skip ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class LexicographMaxSeq {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    String s=scan.next();
    char ch='Z' ;
    StringBuilder out=new StringBuilder();
    for(int i=s.length()-1 ; i>=0 ; i--){
      if(s.charAt(i)>=ch){
        ch=s.charAt(i);
        out.append(ch);
      }
    }
    out.reverse();
    System.out.println(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class LexicographMaxSeq {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scan.getCurrent() ;
    var ch : String ; ch := 'Z' ;
    var out : String ; out := StringLib.newString() ;
        var i : int ; i := s->size() - 1 ; while i >= 0 do ( (     if (s->at(i+1) >= ch) then (     ch := s->at(i+1) ; 
     out := out + StringLib.newString(ch) ) else skip )  ;     i := i - 1 ) ; 
    out := out->reverse() ; 
    OclFile["System.out"].println(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Random ;
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    char[][] a=new char[N][N];
    for(int i=0 ; i<N ; i++)a[i]=sc.next().toCharArray();
    int min=N+1,cand=0 ;
    boolean[] win=new boolean[N];
    for(int S=1 ; S<1<<N ; S++){
      int c=Integer.bitCount(S);
      if(min<=c)continue ;
      Arrays.fill(win,false);
      for(int j=0 ; j<N ; j++)if(((S>>j)& 1)>0){
        for(int i=0 ; i<N ; i++)win[i] |=a[j][i]!='x' ;
      }
      boolean ok=true ;
      for(boolean v : win)ok &=v ;
      if(ok){
        min=c ;
        cand=S ;
      }
    }
    List<Integer>use=new ArrayList<Integer>();
    for(int i=0 ; i<N ; i++)if(((cand>>i)& 1)>0)use.add(i);
    Random rand=new Random();
    for(int i=0 ; i<1000 ; i++){
      int me=use.get(rand.nextInt(use.size()));
      System.out.println(me+1);
      System.out.flush();
      sc.nextInt();
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do (     a[i+1] := sc.getCurrent()->characters() ;  ;     i := i + 1 ) ; 
    var min : int ; min := N + 1 ;
    var cand : int ; cand := 0 ;
    var win : Sequence(boolean) ; win := Integer.subrange(1,N)->collect(false) ;
        var S : int ; S := 1 ; while S < (1*(2->pow(N)))->oclAsType(long) do ( (     var c : int ; c := bitCount(S) ;
     if (min <= c) then     continue else skip ; 
    win := win->collect(false) ; 
        var j : int ; j := 0 ; while j < N do (     if ((((S/(2->pow(j)))->oclAsType(long)) & 1) > 0) then (         var i : int ; i := 0 ; while i < N do (     win[i+1] := MathLib.bitwiseOr(win[i+1], a[j+1][i+1] /= 'x') ;  ;     i := i + 1 ) ) else skip ;  ;     j := j + 1 ) ; 
    var ok : boolean ; ok := true ;
    for (v : win) do (     ok := MathLib.bitwiseAnd(ok, v) ;  ) ; 
    if (ok) then (     min := c ; 
     cand := S ) else skip ; 
 )  ;     S := S + 1 ) ; 
    var use : Sequence(int) ; use := Sequence{} ;
        var i : int ; i := 0 ; while i < N do (     if ((((cand/(2->pow(i)))->oclAsType(long)) & 1) > 0) then     use := use->including(i) ; else skip ;  ;     i := i + 1 ) ; 
    var rand : OclRandom ; rand := OclRandom.newOclRandom() ;
        var i : int ; i := 0 ; while i < 1000 do ( (     var me : int ; me := use->at(rand.nextInt(use->size())+1) ;
     OclFile["System.out"].println(me + 1) ; 
     OclFile["System.out"].flush() ; 
     skip )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main extends Template {
  public void solve()throws IOException {
    Random rand=new Random();
    int n=nextInt();
    char[][] judge=new char[n+1][n+1];
    for(int i=0 ; i<n ; i++){
      String str=nextToken();
      for(int j=0 ; j<str.length(); j++){
        judge[i+1][j+1]=str.charAt(j);
      }
    }
    int hand=1 ;
    int count=1000-n*n ;
    int[] trend=new int[n*n];
    for(int i=0 ; i<n*n ; i++){
      System.out.println(hand);
      trend[i]=nextInt();
    }
    for(int i=0 ; i<count ; i++){
      System.out.println(trend[i %(n*n)]);
      int ai_hand=nextInt();
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
abstract class Template implements Runnable {
  public abstract void solve()throws IOException ;
  BufferedReader reader ;
  StringTokenizer tokenizer ;
  PrintWriter writer ;
  public void run(){
    try {
      reader=new BufferedReader(new InputStreamReader(System.in));
      tokenizer=null ;
      writer=new PrintWriter(System.out);
      solve();
      reader.close();
      writer.close();
    }
    catch(Exception e){
      e.printStackTrace();
      System.exit(1);
    }
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  public String nextToken()throws IOException {
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      tokenizer=new StringTokenizer(reader.readLine());
    }
    return tokenizer.nextToken();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends Template {
   operation solve() : void
  pre: true
  post: true
  activity: (     var rand : OclRandom ; rand := OclRandom.newOclRandom() ;
     var n : int ; n := nextInt() ;
    var judge : Sequence(Sequence(String)) ; judge := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,n + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var str : String ; str := nextToken() ;
         var j : int ; j := 0 ; while j < str->size() do ( (     judge[i + 1+1][j + 1+1] := str->at(j+1) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var hand : int ; hand := 1 ;
    var count : int ; count := 1000 - n * n ;
    var trend : Sequence(int) ; trend := Integer.subrange(1,n * n)->collect(0) ;
        var i : int ; i := 0 ; while i < n * n do ( (     OclFile["System.out"].println(hand) ; 
     trend[i+1] := nextInt() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < count do ( (     OclFile["System.out"].println(trend[i mod (n * n)+1]) ; 
     var ai_hand : int ; ai_hand := nextInt() )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}
class Template implements Runnable {
     operation solve() : void
  pre: true
  post: true;
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   attribute writer : OclFile;
   operation run() : void
  pre: true
  post: true
  activity: (     try (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := null ; 
    writer := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    execute solve() ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() ; 
 OclProcess.exit(1) )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) ) ; 
     return tokenizer.next() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Random ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int N ;
  static int[][] g ;
  static void solve(){
    Random rand=new Random();
    int[] hist=new int[N];
    for(int i=0 ; i<100 ; ++i){
      System.out.println(rand.nextInt(N)+1);
      System.out.flush();
      int ai=sc.nextInt()-1 ;
++hist[ai];
    }
    double[] exp=new double[N];
    double sum=0 ;
    for(int i=0 ; i<N ; ++i){
      for(int j=0 ; j<N ; ++j){
        exp[i]+=1.*g[i][j]*hist[j]/100 ;
      }
      sum+=exp[i];
    }
    for(int i=100 ; i<1000 ; ++i){
      double r=rand.nextDouble()*sum ;
      for(int j=0 ; j<N ; ++j){
        r-=exp[j];
        if(r<=0){
          System.out.println(j+1);
          System.out.flush();
          break ;
        }
      }
    }
  }
  public static void main(String[] args){
    N=sc.nextInt();
    g=new int[N][N];
    for(int i=0 ; i<N ; ++i){
      String line=sc.next();
      g[i][i]=1 ;
      for(int j=i+1 ; j<N ; ++j){
        if(line.charAt(j)=='o'){
          g[i][j]=3 ;
        }
        else {
          g[j][i]=3 ;
        }
      }
    }
    solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute N : int;
  static   attribute g : Sequence(Sequence(int));
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var rand : OclRandom ; rand := OclRandom.newOclRandom() ;
     var hist : Sequence(int) ; hist := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < 100 do ( (     OclFile["System.out"].println(rand.nextInt(N) + 1) ; 
     OclFile["System.out"].flush() ; 
     var ai : int ; ai := sc.getCurrent()->toInteger() - 1 ;
     hist[ai+1] := hist[ai+1] + 1 )  ;     i := i + 1 ) ; 
    var exp : Sequence(double) ; exp := Integer.subrange(1,N)->collect(0.0) ;
    var sum : double ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     exp[i+1] := exp[i+1]+(1. * g[i+1][j+1] * hist[j+1] / 100) )  ;     j := j + 1 ) ; 
     sum := sum+(exp[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 100 ; while i < 1000 do ( (     var r : double ; r := rand.nextDouble() * sum ;
         var j : int ; j := 0 ; while j < N do ( (     r := r-(exp[j+1]) ; 
     if (r <= 0) then (     OclFile["System.out"].println(j + 1) ; 
     OclFile["System.out"].flush() ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     N := sc.getCurrent()->toInteger() ; 
     g := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ; 
         var i : int ; i := 0 ; while i < N do ( (     var line : String ; line := sc.getCurrent() ;
     g[i+1][i+1] := 1 ; 
         var j : int ; j := i + 1 ; while j < N do ( (     if (line->at(j+1) = 'o') then (     g[i+1][j+1] := 3 ) else (     g[j+1][i+1] := 3 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     execute solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem374 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String input=sc.nextLine();
    String[] split=input.split(" ");
    int n=Integer.parseInt(split[0]);
    int k=Integer.parseInt(split[1]);
    String[] ar=new String[n];
    for(int i=0 ; i<n ; i++){
      ar[i]=sc.next();
    }
    String pwd=sc.next();
    int count=0 ;
    int grt=0 ;
    for(int i=0 ; i<ar.length ; i++){
      if(pwd.length()>ar[i] .length()){
        count++;
      }
      else if(pwd.length()<ar[i] .length()){
        grt++;
      }
    }
    int best=count+(count/k)*5+1 ;
    int worst=n>1 ?((n-grt-1)/k)*5+n-grt : 1 ;
    System.out.println(best+" "+worst);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem374 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input : String ; input := sc.nextLine() ;
    var split : Sequence(String) ; split := input->split(" ") ;
    var n : int ; n := (split[0+1])->toInteger() ;
    var k : int ; k := (split[1+1])->toInteger() ;
    var ar : Sequence(String) ; ar := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
    var pwd : String ; pwd := sc.getCurrent() ;
    var count : int ; count := 0 ;
    var grt : int ; grt := 0 ;
        var i : int ; i := 0 ; while i < ar->size() do ( (     if (pwd->size() > ar[i+1]->size()) then (     count := count + 1 ) else     if (pwd->size() < ar[i+1]->size()) then (     grt := grt + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    var best : int ; best := count + (count / k) * 5 + 1 ;
    var worst : int ; worst := if n > 1 then ((n - grt - 1) / k) * 5 + n - grt else 1 endif ;
    OclFile["System.out"].println(best + " " + worst) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int findMinimal(int[] a,int n){
    Arrays.sort(a);
    int sum=0 ;
    for(int i=0 ; i<n/2 ; i++)sum+=(a[i]+a[n-i-1])*(a[i]+a[n-i-1]);
    return sum ;
  }
  public static void main(String str[]){
    int[] a={
      8,5,2,3 };
      int n=a.length ;
      System.out.println(findMinimal(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMinimal( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     a := a->sort() ; 
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n / 2 do (     sum := sum+((a[i+1] + a[n - i - 1+1]) * (a[i+1] + a[n - i - 1+1])) ;  ;     i := i + 1 ) ; 
     return sum );
  static   operation main( str : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{8,5,2,3} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(findMinimal(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static long minimumMoves(int a[],int n){
    long operations=0 ;
    Arrays.sort(a);
    for(int i=0 ; i<n ; i++)operations+=(long)Math.abs(a[i]-(i+1));
    return operations ;
  }
  public static void main(String args[]){
    int arr[]={
      5,3,2 };
      int n=arr.length ;
      System.out.print(minimumMoves(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation minimumMoves( a : Sequence(int), n : int) : long
  pre: true
  post: true
  activity: (     var operations : long ; operations := 0 ;
     a := a->sort() ; 
         var i : int ; i := 0 ; while i < n do (     operations := operations+(if a[i+1] - (i + 1) < 0 then -(a[i+1] - (i + 1)) else a[i+1] - (i + 1) endif->oclAsType(long)) ;  ;     i := i + 1 ) ; 
     return operations );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{5,3,2} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].print(minimumMoves(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void solve(){
    int n=sc.nextInt();
    String st=sc.next();
    int min=-1 ;
    for(int i=0 ; i<n ; i++){
      char x=st.charAt(i);
      if(x=='0')min=i ;
    }
    if(min==-1 || min==0){
      System.out.println(0);
      return ;
    }
    int cnt=0 ;
    for(int i=0 ; i<n ; i++)if(st.charAt(i)=='0')cnt++;
    if(cnt==0 || cnt==n){
      System.out.println(0);
      return ;
    }
    int j=0 ;
    int ans[]=new int[n];
    for(int i=0 ; i<cnt ; i++){
      if(st.charAt(i)=='1')ans[j++]=i+1 ;
    }
    if(j==0){
      System.out.println(0);
      return ;
    }
    for(int i=cnt ; i<n ; i++){
      if(st.charAt(i)=='0')ans[j++]=i+1 ;
    }
    System.out.println("1");
    System.out.print(j+" ");
    for(int i=0 ; i<j ; i++)System.out.print(ans[i]+" ");
    System.out.println();
  }
  public static void main(String[] args){
    int t=sc.nextInt();
    while(t-->0)solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var st : String ; st := sc.getCurrent() ;
    var min : int ; min := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : String ; x := st->at(i+1) ;
     if (x = '0') then     min := i ; else skip )  ;     i := i + 1 ) ; 
    if (min = -1 or min = 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do (     if (st->at(i+1) = '0') then     cnt := cnt + 1 ; else skip ;  ;     i := i + 1 ) ; 
    if (cnt = 0 or cnt = n) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
    var j : int ; j := 0 ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < cnt do ( (     if (st->at(i+1) = '1') then      ans[j+1] := i + 1  ; j := j + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (j = 0) then (     OclFile["System.out"].println(0) ; 
     return ) else skip ; 
        var i : int ; i := cnt ; while i < n do ( (     if (st->at(i+1) = '0') then      ans[j+1] := i + 1  ; j := j + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("1") ; 
    OclFile["System.out"].print(j + " ") ; 
        var i : int ; i := 0 ; while i < j do (     OclFile["System.out"].print(ans[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ;     execute solve() ; ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Practice {
  static long pow(long a,long b){
    if(b==0){
      return 1 ;
    }
    long ans=0L ;
    if(b % 2==0){
      long val=pow(a,b/2);
      ans+=val*val ;
    }
    else {
      long val=pow(a,b/2);
      ans+=val*val*2 ;
    }
    return ans ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t--!=0){
      int n=sc.nextInt();
      sc.nextLine();
      String val=sc.nextLine();
      boolean flag=true,flag1=false ;
      int cnt=0 ;
      for(int i=0 ; i<n ; i++){
        if(val.charAt(i)=='1'){
          flag1=true ;
          cnt++;
        }
        else {
          if(flag1){
            flag=false ;
          }
        }
      }
      if(flag){
        System.out.println(0);
      }
      else {
        Stack<Integer>st=new Stack<>();
        int cnt0=0 ;
        for(int i=n-1 ; i>=0 ; i--){
          if(val.charAt(i)=='1'){
            cnt--;
          }
          else {
            cnt0++;
            st.push(i+1);
          }
          if(cnt==cnt0)break ;
        }
        System.out.println(1);
        System.out.print(2*cnt0+" ");
        for(int i=0,j=0 ; i<n && j<cnt0 ; i++){
          if(val.charAt(i)=='1'){
            j++;
            System.out.print((i+1)+" ");
          }
        }
        while(st.size()>0){
          System.out.print(st.pop()+" ");
        }
        System.out.println();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Practice {
  static   operation pow( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return 1 ) else skip ; 
     var ans : long ; ans := 0L ;
     if (b mod 2 = 0) then (     var val : long ; val := pow(a, b / 2) ;
     ans := ans+(val * val) ) else (     var val : long ; val := pow(a, b / 2) ;
     ans := ans+(val * val * 2) ) ;  
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t /= 0) do (    skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     skip ; 
    var val : String ; val := sc.nextLine() ;
    var flag : boolean ; flag := true ;
    var flag1 : boolean ; flag1 := false ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (val->at(i+1) = '1') then (     flag1 := true ; 
     cnt := cnt + 1 ) else (     if (flag1) then (     flag := false ) else skip ) )  ;     i := i + 1 ) ; 
    if (flag) then (     OclFile["System.out"].println(0) ) else (     var st : Sequence(int) ; st := Sequence{} ;
     var cnt0 : int ; cnt0 := 0 ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     if (val->at(i+1) = '1') then (     cnt := cnt - 1 ) else (     cnt0 := cnt0 + 1 ; 
     st := st->append(i + 1) ) ;  
     if (cnt = cnt0) then     break else skip )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(1) ; 
    OclFile["System.out"].print(2 * cnt0 + " ") ; 
        var i : int ; i := 0 ;
    var j : int ; j := 0 ; while i < n & j < cnt0 do ( (     if (val->at(i+1) = '1') then (     j := j + 1 ; 
     OclFile["System.out"].print((i + 1) + " ") ) else skip )  ;     i := i + 1 ) ; 
    while (st->size() > 0) do (     OclFile["System.out"].print(st->last() + " ") ) ; 
    OclFile["System.out"].println() ; 
 ) ;  
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean areChractersUnique(String str){
    int checker=0 ;
    for(int i=0 ; i<str.length(); ++i){
      int val=(str.charAt(i)-'a');
      if((checker &(1<<val))>0)return false ;
      checker |=(1<<val);
    }
    return true ;
  }
  public static void main(String[] args){
    String s="aaabbccdaa" ;
    if(areChractersUnique(s))System.out.print("Yes");
    else System.out.print("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation areChractersUnique( str : String) : boolean
  pre: true
  post: true
  activity: (     var checker : int ; checker := 0 ;
         var i : int ; i := 0 ; while i < str->size() do ( (     var val : int ; val := (str->at(i+1) - ('a')->char2byte()) ;
     if ((MathLib.bitwiseAnd(checker,((1*(2->pow(val)))->oclAsType(long)))) > 0) then     return false else skip ; 
     checker := MathLib.bitwiseOr(checker, ((1*(2->pow(val)))->oclAsType(long))) )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "aaabbccdaa" ;
     if (areChractersUnique(s)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean check(int a[],int n){
    for(int i=0 ; i<n ; i++)if(a[i]==1)return true ;
    return false ;
  }
  public static void main(String[] args){
    int a[]={
      0,1,0,1 };
      int n=a.length ;
      if(check(a,n)==true)System.out.println("YES\n");
      else System.out.println("NO\n");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation check( a : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     if (a[i+1] = 1) then     return true else skip ;  ;     i := i + 1 ) ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{0,1,0,1} ;
     var n : int ; n := a->size() ;
     if (check(a, n) = true) then     OclFile["System.out"].println("YES\n") ; else     OclFile["System.out"].println("NO\n") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean check(int a[],int n){
    if(n % 2==1)return false ;
    for(int i=0 ; i<n/2 ; i++){
      if(a[i]!=a[i+(n/2)])return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    int a[]={
      1,4,1,4 };
      int n=a.length ;
      if(check(a,n))System.out.println("YES");
      else System.out.println("NO");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation check( a : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     if (n mod 2 = 1) then     return false else skip ; 
         var i : int ; i := 0 ; while i < n / 2 do ( (     if (a[i+1] /= a[i + (n / 2)+1]) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,4,1,4} ;
     var n : int ; n := a->size() ;
     if (check(a, n)) then     OclFile["System.out"].println("YES") ; else     OclFile["System.out"].println("NO") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class MAX_LEN_0_1 {
  public static void main(String args[])throws IOException {
    String str="101001000" ;
    HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();
    map.put(0,-1);
    int res=0 ;
    int count_0=0,count_1=0 ;
    for(int i=0 ; i<str.length(); i++){
      if(str.charAt(i)=='0')count_0++;
      else count_1++;
      if(map.containsKey(count_1-count_0))res=Math.max(res,(i-map.get(count_1-count_0)));
      else map.put(count_1-count_0,i);
    }
    System.out.println("Length of longest balanced sub string="+res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MAX_LEN_0_1 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "101001000" ;
     var map : Map(int,int) ; map := Map{} ;
    map := map->union(Map{0 |-> -1}) ; 
    var res : int ; res := 0 ;
    var count_0 : int ; count_0 := 0 ;
    var count    var count    var count_0 : int ; count_0 := 0 : int ; count    var count_0 : int ; count_0 := 0 := 0 : int ; count    var count    var count_0 : int ; count_0 := 0 : int ; count    var count_0 : int ; count_0 := 0 := 0 := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (str->at(i+1) = '0') then     count_0 := count_0 + 1 else     countcountcount_1 := countcountcount_1 + 1 ; ;  
     if (map->keys()->includes(countcountmap - count_0)) then     res := Set{res, (i - map->at(countcountmap - count_0))}->max() ; else     map := map->union(Map{countcountcountcountmap - count_0, i - count_0 |-> i}) ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Length of longest balanced sub string=" + res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.List ;
import java.util.Scanner ;
public class Solution {
  static List<List<Integer>>ans ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    int k=sc.nextInt();
    int[] ar=new int[26];
    int max=0 ;
    for(int i=0 ; i<ar.length ; i++){
      ar[i]=sc.nextInt();
      max=Math.max(max,ar[i]);
    }
    long ans=0 ;
    int i=1 ;
    for(char c : s.toCharArray()){
      ans+=(i*(ar[c-97]));
      i++;
    }
    while(k!=0){
      k--;
      ans=ans+(i*(max));
      i++;
    }
    System.out.println(ans);
  }
  private static int gcd1(int i,int j){
    if(j==0){
      return i ;
    }
    return gcd1(j,i % j);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   attribute ans : Sequence(Sequence(int));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,26)->collect(0) ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < ar->size() do ( (     ar[i+1] := sc.getCurrent()->toInteger() ; 
     max := Set{max, ar[i+1]}->max() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var i : int ; i := 1 ;
    for (c : s->characters()) do ( (     ans := ans+((i * (ar[c - 97+1]))) ; 
     i := i + 1 )  ) ; 
    while (k /= 0) do (     k := k - 1 ; 
     ans := ans + (i * (max)) ; 
     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation gcd1( i : int, j : int) : int
  pre: true
  post: true
  activity: (     if (j = 0) then (     return i ) else skip ; 
     return gcd1(j, i mod j) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class dzylovesstrings {
  public static void main(String[] args){
    String s ;
    int n,k ;
    Scanner sc=new Scanner(System.in);
    s=sc.next();
    n=s.length();
    k=sc.nextInt();
    int v[]=new int[26];
    for(int i=0 ; i<26 ; i++)v[i]=sc.nextInt();
    int max=-1 ;
    for(int i=0 ; i<26 ; i++)if(max<v[i])max=v[i];
    int val=0 ;
    for(int i=0 ; i<n ; i++)val+=(i+1)*v[s.charAt(i)-97];
    for(int i=n+1 ; i<=n+k ; i++)val+=i*max ;
    System.out.println(val);
  }
}
------------------------------------------------------------
OCL File:
---------
 class dzylovesstrings {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ;
     var n : int ;
    var k : int ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    s := sc.getCurrent() ; 
    n := s->size() ; 
    k := sc.getCurrent()->toInteger() ; 
    var v : Sequence(int) ; v := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < 26 do (     v[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var max : int ; max := -1 ;
        var i : int ; i := 0 ; while i < 26 do (     if (max < v[i+1]) then     max := v[i+1] ; else skip ;  ;     i := i + 1 ) ; 
    var val : int ; val := 0 ;
        var i : int ; i := 0 ; while i < n do (     val := val+((i + 1) * v[s->at(i+1) - 97+1]) ;  ;     i := i + 1 ) ; 
        var i : int ; i := n + 1 ; while i <= n + k do (     val := val+(i * max) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(val) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Lab7_Passwords {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int inputN=sc.nextInt();
    int nTrial=sc.nextInt();
    String pass="" ;
    ArrayList<String>listPass=new ArrayList<>();
    for(int i=0 ; i<inputN ; i++){
      pass=sc.next();
      listPass.add(pass);
    }
    String correctPass=sc.next();
    int cnt1=0 ;
    int cnt2=0 ;
    int min=100 ;
    for(int i=0 ; i<inputN ; i++){
      if(listPass.get(i).length()<correctPass.length()){
        cnt1++;
      }
      if(listPass.get(i).length()==correctPass.length()&& ! listPass.get(i).equals(correctPass)){
        cnt2++;
      }
    }
    int bCase=cnt1+(cnt1/nTrial)*5+1 ;
    int wCase=cnt2+cnt1+((cnt2+cnt1)/nTrial)*5+1 ;
    System.out.print(bCase);
    System.out.print(" ");
    System.out.print(wCase);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Lab7_Passwords {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var inputN : int ; inputN := sc.getCurrent()->toInteger() ;
    var nTrial : int ; nTrial := sc.getCurrent()->toInteger() ;
    var pass : String ; pass := "" ;
    var listPass : Sequence(String) ; listPass := Sequence{} ;
        var i : int ; i := 0 ; while i < inputN do ( (     pass := sc.getCurrent() ; 
     listPass := listPass->including(pass) )  ;     i := i + 1 ) ; 
    var correctPass : String ; correctPass := sc.getCurrent() ;
    var cnt1 : int ; cnt1 := 0 ;
    var cnt2 : int ; cnt2 := 0 ;
    var min : int ; min := 100 ;
        var i : int ; i := 0 ; while i < inputN do ( (     if (listPass->at(i+1)->size() < correctPass->size()) then (     cnt1 := cnt1 + 1 ) else skip ; 
     if (listPass->at(i+1)->size() = correctPass->size() & not(listPass->at(i+1) = correctPass)) then (     cnt2 := cnt2 + 1 ) else skip )  ;     i := i + 1 ) ; 
    var bCase : int ; bCase := cnt1 + (cnt1 / nTrial) * 5 + 1 ;
    var wCase : int ; wCase := cnt2 + cnt1 + ((cnt2 + cnt1) / nTrial) * 5 + 1 ;
    OclFile["System.out"].print(bCase) ; 
    OclFile["System.out"].print(" ") ; 
    OclFile["System.out"].print(wCase) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class DZY_string {
  static Scanner sc=new Scanner(System.in);
  public static void main(String args[]){
    String s=sc.next();
    int k=sc.nextInt();
    int a[]=new int[26];
    for(int i=0 ; i<26 ; i++){
      a[i]=sc.nextInt();
    }
    int ans=0 ;
    for(int i=0 ; i<s.length(); i++){
      ans=ans+((i+1)*a[s.charAt(i)-'a']);
    }
    Arrays.sort(a);
    int l=s.length();
    for(int i=s.length()+1 ; i<=s.length()+k ; i++){
      ans=ans+(i*a[25]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class DZY_string {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := sc.getCurrent() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,26)->collect(0) ;
        var i : int ; i := 0 ; while i < 26 do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < s->size() do ( (     ans := ans + ((i + 1) * a[s->at(i+1) - ('a')->char2byte()+1]) )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var l : int ; l := s->size() ;
        var i : int ; i := s->size() + 1 ; while i <= s->size() + k do ( (     ans := ans + (i * a[25+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class ChessCheater {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int z=0 ; z<t ; ++z){
      int n=sc.nextInt();
      int k=sc.nextInt();
      String s=sc.next();
      int cs=0 ;
      int los=0 ;
      for(int i=0 ; i<n ; ++i){
        if(s.charAt(i)=='W'){
++cs ;
          if(i>0 && s.charAt(i-1)=='W')++cs ;
        }
        else {
++los ;
        }
      }
      if(k==0){
        System.out.println(cs);
        continue ;
      }
      if(cs==0){
        System.out.println(k*2-1);
        continue ;
      }
      if(k>=los){
        System.out.println(n*2-1);
        continue ;
      }
      int bet=-10000000 ;
      PriorityQueue<Integer>pq=new PriorityQueue<>();
      for(int i=0 ; i<n ; ++i){
        if(s.charAt(i)=='W'){
          if(bet>0)pq.add(bet);
          bet=0 ;
        }
        else {
++bet ;
        }
      }
      cs+=2*k ;
      while(! pq.isEmpty()){
        int np=pq.poll();
        if(np>k)break ;
        k-=np ;
++cs ;
      }
      System.out.println(cs);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ChessCheater {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var z : int ; z := 0 ; while z < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var cs : int ; cs := 0 ;
    var los : int ; los := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = 'W') then (     cs := cs + 1 ; 
     if (i > 0 & s->at(i - 1+1) = 'W') then     cs := cs + 1 ; else skip ) else (     los := los + 1 ) )  ;     i := i + 1 ) ; 
    if (k = 0) then (     OclFile["System.out"].println(cs) ; 
     continue ) else skip ; 
    if (cs = 0) then (     OclFile["System.out"].println(k * 2 - 1) ; 
     continue ) else skip ; 
    if (k >= los) then (     OclFile["System.out"].println(n * 2 - 1) ; 
     continue ) else skip ; 
    var bet : int ; bet := -10000000 ;
    var pq : Sequence(int) ; pq := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     if (s->at(i+1) = 'W') then (     if (bet > 0) then     pq := pq->including(bet) ; else skip ; 
     bet := 0 ) else (     bet := bet + 1 ) )  ;     i := i + 1 ) ; 
    cs := cs+(2 * k) ; 
    while (not(pq->isEmpty())) do (     var np : int ; np := pq->min() ;
     if (np > k) then     break else skip ; 
     k := k-(np) ; 
     cs := cs + 1 ) ; 
    OclFile["System.out"].println(cs) ; 
 )  ;     z := z + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemB {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    String s=scn.nextLine();
    int k=Integer.parseInt(scn.nextLine());
    String[] parts=scn.nextLine().split(" ");
    int[] arr=new int[26];
    long max=0 ;
    for(int i=0 ; i<arr.length ; i++){
      arr[i]=Integer.parseInt(parts[i]);
      max=Math.max(max,arr[i]);
    }
    long ans=0 ;
    int i=0 ;
    for(i=0 ; i<s.length(); i++){
      char ch=s.charAt(i);
      int val=arr[ch-'a'];
      ans+=val*(i+1);
    }
    for(int j=0 ; j<k ; j++){
      ans+=max*(++i);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := scn.nextLine() ;
    var k : int ; k := (scn.nextLine())->toInteger() ;
    var parts : Sequence(String) ; parts := scn.nextLine()->split(" ") ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,26)->collect(0) ;
    var max : long ; max := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := (parts[i+1])->toInteger() ; 
     max := Set{max, arr[i+1]}->max() )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var i : int ; i := 0 ;
        i := 0 ; while i < s->size() do ( (     var ch : String ; ch := s->at(i+1) ;
     var val : int ; val := arr[(ch)->char2byte() - ('a')->char2byte()+1] ;
     ans := ans+(val * (i + 1)) )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < k do ( (         i := i + 1 ;
 ans := ans + max * (i)  )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Soroban {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String zero="O-|-OOOO" ;
    String two="O-|OO-OO" ;
    String three="O-|OOO-O" ;
    String one="O-|O-OOO" ;
    String four="O-|OOOO-" ;
    String five="-O|-OOOO" ;
    String eight="-O|OOO-O" ;
    String seven="-O|OO-OO" ;
    String six="-O|O-OOO" ;
    String nine="-O|OOOO-" ;
    for(int i=s.length()-1 ; i>=0 ; i--){
      if(s.charAt(i)=='0'){
        System.out.println(zero);
      }
      if(s.charAt(i)=='1'){
        System.out.println(one);
      }
      if(s.charAt(i)=='2'){
        System.out.println(two);
      }
      if(s.charAt(i)=='3'){
        System.out.println(three);
      }
      if(s.charAt(i)=='4'){
        System.out.println(four);
      }
      if(s.charAt(i)=='5'){
        System.out.println(five);
      }
      if(s.charAt(i)=='6'){
        System.out.println(six);
      }
      if(s.charAt(i)=='7'){
        System.out.println(seven);
      }
      if(s.charAt(i)=='8'){
        System.out.println(eight);
      }
      if(s.charAt(i)=='9'){
        System.out.println(nine);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Soroban {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var zero : String ; zero := "O-|-OOOO" ;
    var two : String ; two := "O-|OO-OO" ;
    var three : String ; three := "O-|OOO-O" ;
    var one : String ; one := "O-|O-OOO" ;
    var four : String ; four := "O-|OOOO-" ;
    var five : String ; five := "-O|-OOOO" ;
    var eight : String ; eight := "-O|OOO-O" ;
    var seven : String ; seven := "-O|OO-OO" ;
    var six : String ; six := "-O|O-OOO" ;
    var nine : String ; nine := "-O|OOOO-" ;
        var i : int ; i := s->size() - 1 ; while i >= 0 do ( (     if (s->at(i+1) = '0') then (     OclFile["System.out"].println(zero) ) else skip ; 
     if (s->at(i+1) = '1') then (     OclFile["System.out"].println(one) ) else skip ; 
    if (s->at(i+1) = '2') then (     OclFile["System.out"].println(two) ) else skip ; 
    if (s->at(i+1) = '3') then (     OclFile["System.out"].println(three) ) else skip ; 
    if (s->at(i+1) = '4') then (     OclFile["System.out"].println(four) ) else skip ; 
    if (s->at(i+1) = '5') then (     OclFile["System.out"].println(five) ) else skip ; 
    if (s->at(i+1) = '6') then (     OclFile["System.out"].println(six) ) else skip ; 
    if (s->at(i+1) = '7') then (     OclFile["System.out"].println(seven) ) else skip ; 
    if (s->at(i+1) = '8') then (     OclFile["System.out"].println(eight) ) else skip ; 
    if (s->at(i+1) = '9') then (     OclFile["System.out"].println(nine) ) else skip ; 
 )  ;     i := i - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class cp {
  public static void findAllFactor(int[][] div,int n){
    int divCnt[]=new int[n+1];
    int ptr[]=new int[n+1];
    for(int i=n ; i>=1 ; --i){
      for(int j=i ; j<=n ; j+=i)divCnt[j]++;
    }
    for(int i=1 ; i<=n ; ++i)div[i]=new int[divCnt[i] ];
    for(int i=n ; i>=1 ; --i){
      for(int j=i ; j<=n ; j+=i)div[j][ptr[j]++]=i ;
    }
  }
  public static void main(String[] args)throws Exception {
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    while(n>=0){
      int d=n % 10 ;
      n=n/10 ;
      if(d<5){
        System.out.print("O-|");
        for(int i=1 ; i<=d ; i++){
          System.out.print("O");
        }
        System.out.print("-");
        for(int i=1 ; i<5-d ; i++){
          System.out.print("O");
        }
        System.out.println();
      }
      else {
        System.out.print("-O|");
        for(int i=1 ; i<=d-5 ; i++){
          System.out.print("O");
        }
        System.out.print("-");
        for(int i=1 ; i<5-d+5 ; i++){
          System.out.print("O");
        }
        System.out.println();
      }
      if(n==0)break ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class cp {
  static   operation findAllFactor( div : Sequence(Sequence(int)), n : int) : void
  pre: true
  post: true
  activity: (     var divCnt : Sequence(int) ; divCnt := Integer.subrange(1,n + 1)->collect(0) ;
     var ptr : Sequence(int) ; ptr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := n ; while i >= 1 do ( (         var j : int ; j := i ; while j <= n do (     divCnt[j+1] := divCnt[j+1] + 1 ;  ;     j := j+(i) ) )  ;     i := i - 1 ) ; 
        var i : int ; i := 1 ; while i <= n do (     div[i+1] := Integer.subrange(1,divCnt[i+1])->collect(0) ;  ;     i := i + 1 ) ; 
        var i : int ; i := n ; while i >= 1 do ( (         var j : int ; j := i ; while j <= n do (      div[j+1][ptr[j+1]+1] := i  ; ptr[j+1] := ptr[j+1] + 1 ;  ;     j := j+(i) ) )  ;     i := i - 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
     while (n >= 0) do (     var d : int ; d := n mod 10 ;
     n := n / 10 ; 
     if (d < 5) then (     OclFile["System.out"].print("O-|") ; 
         var i : int ; i := 1 ; while i <= d do ( (     OclFile["System.out"].print("O") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("-") ; 
        var i : int ; i := 1 ; while i < 5 - d do ( (     OclFile["System.out"].print("O") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) else (     OclFile["System.out"].print("-O|") ; 
         var i : int ; i := 1 ; while i <= d - 5 do ( (     OclFile["System.out"].print("O") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("-") ; 
        var i : int ; i := 1 ; while i < 5 - d + 5 do ( (     OclFile["System.out"].print("O") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
 ) ;  
     if (n = 0) then     break else skip ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    HashMap<Integer,String>hm=new HashMap<>();
    hm.put(0,"O-|-OOOO");
    hm.put(1,"O-|O-OOO");
    hm.put(2,"O-|OO-OO");
    hm.put(3,"O-|OOO-O");
    hm.put(4,"O-|OOOO-");
    hm.put(5,"-O|-OOOO");
    hm.put(6,"-O|O-OOO");
    hm.put(7,"-O|OO-OO");
    hm.put(8,"-O|OOO-O");
    hm.put(9,"-O|OOOO-");
    int n=sc.nextInt();
    if(n==0){
      System.out.println(hm.get(0));
      return ;
    }
    while(n>0){
      System.out.println(hm.get(n % 10));
      n/=10 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var hm : Map(int,String) ; hm := Map{} ;
    hm := hm->union(Map{0 |-> "O-|-OOOO"}) ; 
    hm := hm->union(Map{1 |-> "O-|O-OOO"}) ; 
    hm := hm->union(Map{2 |-> "O-|OO-OO"}) ; 
    hm := hm->union(Map{3 |-> "O-|OOO-O"}) ; 
    hm := hm->union(Map{4 |-> "O-|OOOO-"}) ; 
    hm := hm->union(Map{5 |-> "-O|-OOOO"}) ; 
    hm := hm->union(Map{6 |-> "-O|O-OOO"}) ; 
    hm := hm->union(Map{7 |-> "-O|OO-OO"}) ; 
    hm := hm->union(Map{8 |-> "-O|OOO-O"}) ; 
    hm := hm->union(Map{9 |-> "-O|OOOO-"}) ; 
    var n : int ; n := sc.getCurrent()->toInteger() ;
    if (n = 0) then (     OclFile["System.out"].println(hm->at(0)) ; 
     return ) else skip ; 
    while (n > 0) do (     OclFile["System.out"].println(hm->at(n mod 10)) ; 
     n := n/(10) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.net.SocketTimeoutException ;
import java.rmi.StubNotFoundException ;
import java.rmi.server.RemoteServer ;
import java.security.cert.CollectionCertStoreParameters ;
import java.util.*;
import javax.xml.transform.SourceLocator ;
public class A_Soroban {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    long n=s.nextLong();
    if(n==0){
      System.out.println("O-|-OOOO");
    }
    while(n>0){
      String ans="" ;
      long last=n % 10 ;
      n=n/10 ;
      if(last>=5){
        ans+="-O|" ;
        last-=5 ;
      }
      else ans+="O-|" ;
      if(last==0){
        ans+="-OOOO" ;
      }
      else if(last==1)ans+="O-OOO" ;
      else if(last==2)ans+="OO-OO" ;
      else if(last==3)ans+="OOO-O" ;
      else ans+="OOOO-" ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Soroban {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := s.getCurrent()->toLong() ;
     if (n = 0) then (     OclFile["System.out"].println("O-|-OOOO") ) else skip ; 
     while (n > 0) do (     var ans : String ; ans := "" ;
     var last : long ; last := n mod 10 ;
    n := n / 10 ; 
    if (last >= 5) then (     ans := ans+("-O|") ; 
     last := last-(5) ) else     ans := ans+("O-|") ; ;  
    if (last = 0) then (     ans := ans+("-OOOO") ) else     if (last = 1) then     ans := ans+("O-OOO") else     if (last = 2) then     ans := ans+("OO-OO") else     if (last = 3) then     ans := ans+("OOO-O") else     ans := ans+("OOOO-") ; ;  ;  ;  ;  
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int minimumRemoval(int n,int a[]){
    Map<Integer,Integer>c=new HashMap<>();
    for(int i=0 ; i<n ; i++)if(c.containsKey(a[i])){
      c.put(a[i],c.get(a[i])+1);
    }
    else {
      c.put(a[i],1);
    }
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      boolean ok=false ;
      for(int j=0 ; j<31 ; j++){
        int x=(1<<j)-a[i];
        if((c.get(x)!=null &&(c.get(x)>1))|| c.get(x)!=null &&(c.get(x)==1 && x!=a[i])){
          ok=true ;
          break ;
        }
      }
      if(! ok)ans++;
    }
    return ans ;
  }
  public static void main(String[] args){
    int a[]={
      4,7,1,5,4,9 };
      int n=a.length ;
      System.out.println(minimumRemoval(n,a));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation minimumRemoval( n : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var c : Map(int,int) ; c := Map{} ;
         var i : int ; i := 0 ; while i < n do (     if (c->keys()->includes(a[i+1])) then (     c := c->union(Map{a[i+1] |-> c->at(a[i+1]) + 1}) ) else (     c := c->union(Map{a[i+1] |-> 1}) ) ;   ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var ok : boolean ; ok := false ;
         var j : int ; j := 0 ; while j < 31 do ( (     var x : int ; x := ((1*(2->pow(j)))->oclAsType(long)) - a[i+1] ;
     if ((c->at(x) /= null & (c->at(x) > 1)) or c->at(x) /= null & (c->at(x) = 1 & x /= a[i+1])) then (     ok := true ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (not(ok)) then     ans := ans + 1 ; else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{4,7,1,5,4,9} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(minimumRemoval(n, a)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.*;
public class GFG {
  public static void main(String a[]){
    int x=10 ;
    int y=5 ;
    x=x ^ y ;
    y=x ^ y ;
    x=x ^ y ;
    System.out.println("After swap: x="+x+",y="+y);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 10 ;
     var y : int ; y := 5 ;
    x := MathLib.bitwiseXor(x,y) ; 
    y := MathLib.bitwiseXor(x,y) ; 
    x := MathLib.bitwiseXor(x,y) ; 
    OclFile["System.out"].println("After swap: x=" + x + ",y=" + y) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static char findExtraCharcter(String strA,String strB){
    int res=0,i ;
    for(i=0 ; i<strA.length(); i++){
      res ^=strA.charAt(i);
    }
    for(i=0 ; i<strB.length(); i++){
      res ^=strB.charAt(i);
    }
    return((char)(res));
  }
  public static void main(String args[]){
    String strA="abcd" ;
    String strB="cbdad" ;
    System.out.println(findExtraCharcter(strA,strB));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findExtraCharcter( strA : String, strB : String) : String
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
    var i : int ;
         i := 0 ; while i < strA->size() do ( (     res := MathLib.bitwiseXor(res,strA->at(i+1)) )  ;     i := i + 1 ) ; 
         i := 0 ; while i < strB->size() do ( (     res := MathLib.bitwiseXor(res,strB->at(i+1)) )  ;     i := i + 1 ) ; 
     return ((res)->oclAsType(String)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var strA : String ; strA := "abcd" ;
     var strB : String ; strB := "cbdad" ;
     OclFile["System.out"].println(findExtraCharcter(strA, strB)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Test {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    String word1=in.nextLine().replaceAll("[^a-zA-Z] ","").toLowerCase();
    String word2=in.nextLine().replaceAll("[^a-zA-Z] ","").toLowerCase();
    String word3=in.nextLine().replaceAll("[^a-zA-Z] ","").toLowerCase();
    String perm1=word1+word2+word3 ;
    String perm2=word1+word3+word2 ;
    String perm3=word2+word1+word3 ;
    String perm4=word2+word3+word1 ;
    String perm5=word3+word2+word1 ;
    String perm6=word3+word1+word2 ;
    int students=in.nextInt();
    in.nextLine();
    for(int i=0 ; i<students ; i++){
      String testCase=in.nextLine().replaceAll("[^a-zA-Z] ","").toLowerCase();
      if(testCase.equals(perm1)|| testCase.equals(perm2)|| testCase.equals(perm3)|| testCase.equals(perm4)|| testCase.equals(perm5)|| testCase.equals(perm6)){
        System.out.println("ACC");
      }
      else {
        System.out.println("WA");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var word1 : String ; word1 := in.nextLine().replaceAllMatches("[^a-zA-Z] ", "" )->toLowerCase() ;
    var word2 : String ; word2 := in.nextLine().replaceAllMatches("[^a-zA-Z] ", "" )->toLowerCase() ;
    var word3 : String ; word3 := in.nextLine().replaceAllMatches("[^a-zA-Z] ", "" )->toLowerCase() ;
    var perm1 : String ; perm1 := word1 + word2 + word3 ;
    var perm2 : String ; perm2 := word1 + word3 + word2 ;
    var perm3 : String ; perm3 := word2 + word1 + word3 ;
    var perm4 : String ; perm4 := word2 + word3 + word1 ;
    var perm5 : String ; perm5 := word3 + word2 + word1 ;
    var perm6 : String ; perm6 := word3 + word1 + word2 ;
    var students : int ; students := in.getCurrent()->toInteger() ;
    skip ; 
        var i : int ; i := 0 ; while i < students do ( (     var testCase : String ; testCase := in.nextLine().replaceAllMatches("[^a-zA-Z] ", "" )->toLowerCase() ;
     if (testCase = perm1 or testCase = perm2 or testCase = perm3 or testCase = perm4 or testCase = perm5 or testCase = perm6) then (     OclFile["System.out"].println("ACC") ) else (     OclFile["System.out"].println("WA") ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().mainrun();
  }
  Scanner scan ;
  int A,B ;
  private void mainrun(){
    scan=new Scanner(System.in);
    int N=scan.nextInt();
    for(; N!=0 ; N=scan.nextInt()){
      looprun(N);
    }
    scan.close();
  }
  private void looprun(int N){
    int[][] F=new int[N][N];
    int Ans=0 ;
    Integer[] cmin=new Integer[N];
    Integer[] rmax=new Integer[N];
    Arrays.fill(cmin,Integer.MAX_VALUE);
    Arrays.fill(rmax,Integer.MIN_VALUE);
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        F[i][j]=scan.nextInt();
        cmin[i]=Math.min(cmin[i],F[i][j]);
      }
    }
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        rmax[i]=Math.max(rmax[i],F[j][i]);
      }
    }
    for(Integer c : cmin){
      for(Integer r : rmax){
        if(c==r){
          Ans=r ;
        }
      }
    }
    System.out.println(Ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().mainrun() );
   attribute scan : OclFile;
   attribute A : int;
   operation mainrun() : void
  pre: true
  post: true
  activity: (     scan := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : int ; N := scan.getCurrent()->toInteger() ;
       while N /= 0 do ( (     execute looprun(N) )  ;     N := scan.getCurrent()->toInteger() ) ; 
     skip );
   operation looprun( N : int) : void
  pre: true
  post: true
  activity: (     var F : Sequence(Sequence(int)) ; F := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
     var Ans : int ; Ans := 0 ;
    var cmin : Sequence(int) ; cmin := Integer.subrange(1,N)->collect(null) ;
    var rmax : Sequence(int) ; rmax := Integer.subrange(1,N)->collect(null) ;
    cmin := cmin->collect(2147483647) ; 
    rmax := rmax->collect(-2147483648) ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     F[i+1][j+1] := scan.getCurrent()->toInteger() ; 
     cmin[i+1] := Set{cmin[i+1], F[i+1][j+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     rmax[i+1] := Set{rmax[i+1], F[j+1][i+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    for (c : cmin) do ( (     for (r : rmax) do ( (     if (c = r) then (     Ans := r ) else skip )  ) )  ) ; 
    OclFile["System.out"].println(Ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  Scanner sc=new Scanner(in);
  void run(){
    int[][] students=new int[100][100];
    boolean[][] min=new boolean[100][100];
    List<Integer>list=new ArrayList<Integer>();
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int e ;
      for(int i=0 ; i<n ; i++){
        list.clear();
        e=1000000000 ;
        for(int j=0 ; j<n ; j++){
          students[i][j]=sc.nextInt();
          if(students[i][j]<e){
            e=students[i][j];
            list.clear();
            list.add(j);
          }
          else if(students[i][j]==e){
            list.add(j);
          }
          min[i][j]=false ;
        }
        for(int index : list)min[i][index]=true ;
      }
      boolean flag=false ;
      J : for(int j=0 ;
      j<n ;
      j++){
        list.clear();
        e=0 ;
        for(int i=0 ; i<n ; i++){
          if(students[i][j]>e){
            e=students[i][j];
            list.clear();
            list.add(i);
          }
          else if(students[i][j]==e){
            list.add(i);
          }
        }
        for(int index : list){
          if(min[index][j]){
            out.println(students[index][j]);
            flag=true ;
            break J ;
          }
        }
      }
      if(! flag)out.println(0);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   operation run() : void
  pre: true
  post: true
  activity: (     var students : Sequence(Sequence(int)) ; students := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(0)) ;
     var min : Sequence(Sequence(boolean)) ; min := Integer.subrange(1,100)->collect(Integer.subrange(1,100)->collect(false)) ;
     var list : Sequence(int) ; list := Sequence{} ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var e : int ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->intersection(Set{}) ; 
     e := 1000000000 ; 
         var j : int ; j := 0 ; while j < n do ( (     students[i+1][j+1] := sc.getCurrent()->toInteger() ; 
     if (students[i+1][j+1] < e) then (     e := students[i+1][j+1] ; 
     list := list->intersection(Set{}) ; 
     list := list->including(j) ) else     if (students[i+1][j+1] = e) then (     list := list->including(j) ) else skip ; ;  
     min[i+1][j+1] := false )  ;     j := j + 1 ) ; 
     for (index : list) do (     min[i+1][index+1] := true ;  ) )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := false ;
        var j : int ; j := 0 ; while j < n do ( (     list := list->intersection(Set{}) ; 
     e := 0 ; 
         var i : int ; i := 0 ; while i < n do ( (     if (students[i+1][j+1] > e) then (     e := students[i+1][j+1] ; 
     list := list->intersection(Set{}) ; 
     list := list->including(i) ) else     if (students[i+1][j+1] = e) then (     list := list->including(i) ) else skip ; )  ;     i := i + 1 ) ; 
     for (index : list) do ( (     if (min[index+1][j+1]) then (     out.println(students[index+1][j+1]) ; 
     flag := true ; 
     break ) else skip )  ) )  ;     j := j + 1 ) ; 
    if (not(flag)) then     out.println(0) ; else skip ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String s=br.readLine();
      String p=br.readLine();
      if((s+s).indexOf(p)!=-1)System.out.println("Yes");
      else System.out.println("No");
    }
    catch(Exception e){
      System.err.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var s : String ; s := br.readLine() ;
     var p : String ; p := br.readLine() ;
     if ((s + s)->indexOf(p)-1 /= -1) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; )   catch (e : ProgramException) do (     OclFile["System.err"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  int n ;
  int[][] T,H ;
  public Main(){
    Scanner sc=new Scanner(System.in);
    while(true){
      n=sc.nextInt();
      if(n==0)break ;
      T=new int[n][n];
      H=new int[n][n];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          T[i][j]=sc.nextInt();
          H[i][j]=0 ;
        }
      }
      for(int a=0 ; a<n ; a++){
        int minv=getMin(a);
        int maxv=getMax(a);
        for(int b=0 ; b<n ; b++){
          if(T[a][b]==minv)H[a][b]++;
          if(T[b][a]==maxv)H[b][a]++;
        }
      }
      int ans=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          if(H[i][j]==2)ans=T[i][j];
        }
      }
      System.out.println(ans);
    }
  }
  int getMax(int j){
    int maxv=0 ;
    for(int i=0 ; i<n ; i++){
      if(maxv<T[i][j]){
        maxv=T[i][j];
      }
    }
    return maxv ;
  }
  int getMin(int i){
    int minv=Integer.MAX_VALUE ;
    for(int j=0 ; j<n ; j++){
      if(minv>T[i][j]){
        minv=T[i][j];
      }
    }
    return minv ;
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute n : int;
   attribute T : Sequence(Sequence(int));
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     n := sc.getCurrent()->toInteger() ; 
     if (n = 0) then     break else skip ; 
    T := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
    H := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     T[i+1][j+1] := sc.getCurrent()->toInteger() ; 
     H[i+1][j+1] := 0 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var a : int ; a := 0 ; while a < n do ( (     var minv : int ; minv := getMin(a) ;
     var maxv : int ; maxv := getMax(a) ;
         var b : int ; b := 0 ; while b < n do ( (     if (T[a+1][b+1] = minv) then     H[a+1][b+1] := H[a+1][b+1] + 1 ; else skip ; 
     if (T[b+1][a+1] = maxv) then     H[b+1][a+1] := H[b+1][a+1] + 1 ; else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (H[i+1][j+1] = 2) then     ans := T[i+1][j+1] ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
   operation getMax( j : int) : int
  pre: true
  post: true
  activity: (     var maxv : int ; maxv := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if (maxv < T[i+1][j+1]) then (     maxv := T[i+1][j+1] ) else skip )  ;     i := i + 1 ) ; 
     return maxv );
   operation getMin( i : int) : int
  pre: true
  post: true
  activity: (     var minv : int ; minv := 2147483647 ;
         var j : int ; j := 0 ; while j < n do ( (     if (minv > T[i+1][j+1]) then (     minv := T[i+1][j+1] ) else skip )  ;     j := j + 1 ) ; 
     return minv );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
import java.util.Arrays ;
class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String buf ;
    try {
      while(!(buf=br.readLine()).equals("0")){
        int n=Integer.parseInt(buf);
        int min[]=new int[n];
        int max[]=new int[n];
        int h[][]=new int[n][n];
        Arrays.fill(min,-1);
        Arrays.fill(max,0);
        for(int i=0 ; i<n ; i++){
          StringTokenizer st=new StringTokenizer(br.readLine());
          for(int j=0 ; j<n ; j++){
            h[i][j]=Integer.parseInt(st.nextToken());
          }
        }
        boolean flag=true ;
        for(int i=0 ; i<n ; i++){
          for(int j=0 ; j<n ; j++){
            if(max[j]<h[i][j])max[j]=h[i][j];
            if(min[i]==-1 || min[i]>h[i][j])min[i]=h[i][j];
          }
        }
        for(int i=0 ; i<n ; i++){
          for(int j=0 ; j<n ; j++){
            if(h[i][j]==min[i] && h[i][j]==max[j]){
              System.out.println(h[i][j]);
              flag=false ;
              break ;
            }
          }
          if(flag==false)break ;
        }
        if(flag)System.out.println(0);
      }
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var buf : String ;
     try (     while (not((buf) = "0")) do (     var n : int ; n := (buf)->toInteger() ;
     var min : Sequence(int) ; min := Integer.subrange(1,n)->collect(0) ;
    var max : Sequence(int) ; max := Integer.subrange(1,n)->collect(0) ;
    var h : Sequence(Sequence(int)) ; h := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    min := min->collect(-1) ; 
    max := max->collect(0) ; 
        var i : int ; i := 0 ; while i < n do ( (     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
         var j : int ; j := 0 ; while j < n do ( (     h[i+1][j+1] := (st.next())->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (max[j+1] < h[i+1][j+1]) then     max[j+1] := h[i+1][j+1] ; else skip ; 
     if (min[i+1] = -1 or min[i+1] > h[i+1][j+1]) then     min[i+1] := h[i+1][j+1] ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (h[i+1][j+1] = min[i+1] & h[i+1][j+1] = max[j+1]) then (     OclFile["System.out"].println(h[i+1][j+1]) ; 
     flag := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (flag = false) then     break else skip )  ;     i := i + 1 ) ; 
    if (flag) then     OclFile["System.out"].println(0) ; else skip ; 
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int m[][]=new int[n][n];
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          m[i][j]=sc.nextInt();
        }
      }
      int h[][]=new int[n][n];
      for(int i=0 ; i<n ; i++){
        int min=Integer.MAX_VALUE ;
        for(int j=0 ; j<n ; j++){
          if(m[i][j]<min){
            min=m[i][j];
          }
        }
        for(int j=0 ; j<n ; j++){
          if(m[i][j]==min)h[i][j]++;
        }
      }
      for(int i=0 ; i<n ; i++){
        int max=0 ;
        for(int j=0 ; j<n ; j++){
          if(m[j][i]>max){
            max=m[j][i];
          }
        }
        for(int j=0 ; j<n ; j++){
          if(m[j][i]==max)h[j][i]++;
        }
      }
      int ans=0 ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          if(h[i][j]==2)ans=Math.max(ans,m[i][j]);
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var m : Sequence(Sequence(int)) ; m := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     m[i+1][j+1] := sc.getCurrent()->toInteger() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var h : Sequence(Sequence(int)) ; h := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var min : int ; min := 2147483647 ;
         var j : int ; j := 0 ; while j < n do ( (     if (m[i+1][j+1] < min) then (     min := m[i+1][j+1] ) else skip )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < n do ( (     if (m[i+1][j+1] = min) then     h[i+1][j+1] := h[i+1][j+1] + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var max : int ; max := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (m[j+1][i+1] > max) then (     max := m[j+1][i+1] ) else skip )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < n do ( (     if (m[j+1][i+1] = max) then     h[j+1][i+1] := h[j+1][i+1] + 1 ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (h[i+1][j+1] = 2) then     ans := Set{ans, m[i+1][j+1]}->max() ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int countCoins(int n){
    int c=0 ;
    if(n<10){
      return n ;
    }
    if(n>9 && n<25){
      c=n/10+n % 10 ;
      return c ;
    }
    if(n>24){
      c=n/25 ;
      if(n % 25<10){
        c=c+n % 25 ;
        return c ;
      }
      if(n % 25>9){
        c=c+(n % 25)/10+(n % 25)% 10 ;
        return c ;
      }
    }
    return c ;
  }
  public static void main(String[] args){
    int n=14 ;
    System.out.println(countCoins(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation countCoins( n : int) : int
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
     if (n < 10) then (     return n ) else skip ; 
    if (n > 9 & n < 25) then (     c := n / 10 + n mod 10 ; 
     return c ) else skip ; 
    if (n > 24) then (     c := n / 25 ; 
     if (n mod 25 < 10) then (     c := c + n mod 25 ; 
     return c ) else skip ; 
     if (n mod 25 > 9) then (     c := c + (n mod 25) / 10 + (n mod 25) mod 10 ; 
     return c ) else skip ) else skip ; 
    return c 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 14 ;
     OclFile["System.out"].println(countCoins(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
import java.util.Map ;
import java.util.Scanner ;
public class B204 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    Map<Integer,Integer>map=new HashMap<>();
    int[] F=new int[N];
    int[] B=new int[N];
    for(int n=0 ; n<N ; n++){
      int f=in.nextInt();
      int b=in.nextInt();
      F[n]=f ;
      B[n]=b ;
      int count=map.getOrDefault(f,0);
      map.put(f,count+1);
      count=map.getOrDefault(b,0);
      map.put(b,count+1);
    }
    int min=(N+1)/2 ;
    int answer=Integer.MAX_VALUE ;
    for(Map.Entry<Integer,Integer>entry : map.entrySet()){
      if(entry.getValue()>=min){
        int color=entry.getKey();
        int fs=0 ;
        int total=0 ;
        for(int n=0 ; n<N ; n++){
          if(F[n]==color){
            fs++;
            total++;
          }
          else if(B[n]==color){
            total++;
          }
        }
        if(total>=min){
          answer=Math.min(answer,Math.max(0,min-fs));
        }
      }
    }
    System.out.println((answer==Integer.MAX_VALUE)?-1 : answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B204 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var map : Map(int,int) ; map := Map{} ;
    var F : Sequence(int) ; F := Integer.subrange(1,N)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     var f : int ; f := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
    F[n+1] := f ; 
    B[n+1] := b ; 
    var count : int ; count := (if map->keys()->contains(f) then map->at(f) else 0 endif) ;
    map := map->union(Map{f |-> count + 1}) ; 
    count := (if map->keys()->contains(b) then map->at(b) else 0 endif) ; 
    map := map->union(Map{b |-> count + 1}) ; 
 )  ;     n := n + 1 ) ; 
    var min : int ; min := (N + 1) / 2 ;
    var answer : int ; answer := 2147483647 ;
    for (entry : map->asSet()) do ( (     if (entry.getValue() >= min) then (     var color : int ; color := entry.getKey() ;
     var fs : int ; fs := 0 ;
    var total : int ; total := 0 ;
        var n : int ; n := 0 ; while n < N do ( (     if (F[n+1] = color) then (     fs := fs + 1 ; 
     total := total + 1 ) else     if (B[n+1] = color) then (     total := total + 1 ) else skip ; )  ;     n := n + 1 ) ; 
    if (total >= min) then (     answer := Set{answer, Set{0, min - fs}->max()}->min() ) else skip ; 
 ) else skip )  ) ; 
    OclFile["System.out"].println(if (answer = 2147483647) then -1 else answer endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static boolean allOddDigits(int n){
    while(n!=0){
      if((n % 10)% 2==0)return false ;
      n/=10 ;
    }
    return true ;
  }
  static int largestNumber(int n){
    if(n % 2==0)n--;
    for(int i=n ; ; i-=2)if(allOddDigits(i))return i ;
  }
  public static void main(String[] args){
    int N=23 ;
    System.out.println(largestNumber(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation allOddDigits( n : int) : boolean
  pre: true
  post: true
  activity: (     while (n /= 0) do (     if ((n mod 10) mod 2 = 0) then     return false else skip ; 
     n := n/(10) ) ; 
     return true );
  static   operation largestNumber( n : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 = 0) then     n := n - 1 ; else skip ; 
         var i : int ; i := n ; while true do (     if (allOddDigits(i)) then     return i else skip ;  ;     i := i-(2) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 23 ;
     OclFile["System.out"].println(largestNumber(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    FastInputReader in=new FastInputReader(System.in);
    PrintWriter out=new PrintWriter(System.out);
    String word1=in.nextLine().replaceAll("[^a-zA-Z] ","").toLowerCase();
    String word2=in.nextLine().replaceAll("[^a-zA-Z] ","").toLowerCase();
    String word3=in.nextLine().replaceAll("[^a-zA-Z] ","").toLowerCase();
    String test1=word1+word2+word3 ;
    String test2=word1+word3+word2 ;
    String test3=word2+word1+word3 ;
    String test4=word2+word3+word1 ;
    String test5=word3+word2+word1 ;
    String test6=word3+word1+word2 ;
    int num=in.nextInt();
    for(int i=0 ; i<num ; i++){
      String word=in.nextLine().replaceAll("[^a-zA-Z] ","").toLowerCase();
      if(word.equals(test1)|| word.equals(test2)|| word.equals(test3)|| word.equals(test4)|| word.equals(test5)|| word.equals(test6)){
        System.out.println("ACC");
      }
      else {
        System.out.println("WA");
      }
    }
  }
}
class FastInputReader {
  private BufferedReader reader ;
  private StringTokenizer tokenizer ;
  public FastInputReader(InputStream stream){
    reader=new BufferedReader(new InputStreamReader(stream));
    tokenizer=null ;
  }
  public String next(){
    while(tokenizer==null || ! tokenizer.hasMoreTokens()){
      try {
        tokenizer=new StringTokenizer(reader.readLine());
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }
  public String nextLine()throws IOException {
    return reader.readLine();
  }
  public int nextInt(){
    return Integer.parseInt(next());
  }
  public double nextDouble(){
    return Double.parseDouble(next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastInputReader ; in := FastInputReader.newFastInputReader(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var word1 : String ; word1 := in.nextLine().replaceAllMatches("[^a-zA-Z] ", "" )->toLowerCase() ;
    var word2 : String ; word2 := in.nextLine().replaceAllMatches("[^a-zA-Z] ", "" )->toLowerCase() ;
    var word3 : String ; word3 := in.nextLine().replaceAllMatches("[^a-zA-Z] ", "" )->toLowerCase() ;
    var test1 : String ; test1 := word1 + word2 + word3 ;
    var test2 : String ; test2 := word1 + word3 + word2 ;
    var test3 : String ; test3 := word2 + word1 + word3 ;
    var test4 : String ; test4 := word2 + word3 + word1 ;
    var test5 : String ; test5 := word3 + word2 + word1 ;
    var test6 : String ; test6 := word3 + word1 + word2 ;
    var num : int ; num := in.nextInt() ;
        var i : int ; i := 0 ; while i < num do ( (     var word : String ; word := in.nextLine().replaceAllMatches("[^a-zA-Z] ", "" )->toLowerCase() ;
     if (word = test1 or word = test2 or word = test3 or word = test4 or word = test5 or word = test6) then (     OclFile["System.out"].println("ACC") ) else (     OclFile["System.out"].println("WA") ) )  ;     i := i + 1 ) ; 
 );
}
class FastInputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newFastInputReader( stream : OclFile) : FastInputReader
  pre: true
  post: true
  activity:
  ( var self : FastInputReader ;
    self := createFastInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return reader.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static int n,k ;
  static List<int[]>l ;
  static int solve(){
    for(int i=0 ; i<n ; i++){
      boolean isPoss=true ;
      for(int j=0 ; j<n ; j++){
        if(Math.abs(l.get(i)[0]-l.get(j)[0])+Math.abs(l.get(i)[1]-l.get(j)[1])>k){
          isPoss=false ;
        }
      }
      if(isPoss)return 1 ;
    }
    return-1 ;
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    int q=Integer.parseInt(bf.readLine().trim());
    while(q-->0){
      String s[]=bf.readLine().trim().split("\\s+");
      n=Integer.parseInt(s[0]);
      k=Integer.parseInt(s[1]);
      l=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        s=bf.readLine().trim().split("\\s+");
        int x=Integer.parseInt(s[0]);
        int y=Integer.parseInt(s[1]);
        l.add(new int[] {
          x,y }
);
        }
        str.append(solve()).append("\n");
      }
      pw.print(str);
      pw.flush();
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute n : int;
  static   attribute l : Sequence(Sequence(int));
  static   operation solve() : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     var isPoss : boolean ; isPoss := true ;
         var j : int ; j := 0 ; while j < n do ( (     if (if l->at(i+1)[0+1] - l->at(j+1)[0+1] < 0 then -(l->at(i+1)[0+1] - l->at(j+1)[0+1]) else l->at(i+1)[0+1] - l->at(j+1)[0+1] endif + if l->at(i+1)[1+1] - l->at(j+1)[1+1] < 0 then -(l->at(i+1)[1+1] - l->at(j+1)[1+1]) else l->at(i+1)[1+1] - l->at(j+1)[1+1] endif > k) then (     isPoss := false ) else skip )  ;     j := j + 1 ) ; 
     if (isPoss) then     return 1 else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    var q : int ; q := (bf.readLine()->trim())->toInteger() ;
        while (q > 0) do (        q := q - 1 ;     skip ; (     var s : Sequence(String) ; s := bf.readLine()->trim()->split("\\s+") ;
     n := (s[0+1])->toInteger() ; 
    k := (s[1+1])->toInteger() ; 
    l := Sequence{} ; 
        var i : int ; i := 0 ; while i < n do ( (     s := bf.readLine()->trim()->split("\\s+") ; 
     var x : int ; x := (s[0+1])->toInteger() ;
     var y : int ; y := (s[1+1])->toInteger() ;
     l := l->including(Sequence{x,y}) )  ;     i := i + 1 ) ; 
    str := str + StringLib.newString(solve()) + StringLib.newString("\n") ; 
 ) ;  ) ;  
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class BallOfStell {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int k=sc.nextInt();
      int a[][]=new int[n][2];
      for(int i=0 ; i<n ; i++){
        a[i][0]=sc.nextInt();
        a[i][1]=sc.nextInt();
      }
      int dp[]=new int[n];
      boolean ans=false ;
      ;
      for(int i=0 ; i<n ; i++){
        boolean is=true ;
        if(dp[i]==-1)continue ;
        for(int j=0 ; j<n ; j++){
          int x1=a[i][0];
          int y1=a[i][1];
          int x2=a[j][0];
          int y2=a[j][1];
          int dis=Math.abs(x2-x1)+Math.abs(y2-y1);
          if(dis>k){
            dp[j]=-1 ;
            is=false ;
            break ;
          }
        }
        if(is){
          ans=true ;
          break ;
        }
      }
      System.out.println(ans ? 1 :-1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BallOfStell {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
    var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     a[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,n)->collect(0) ;
    var ans : boolean ; ans := false ;
        var i : int ; i := 0 ; while i < n do ( (     var is : boolean ; is := true ;
     if (dp[i+1] = -1) then     continue else skip ; 
         var j : int ; j := 0 ; while j < n do ( (     var x1 : int ; x1 := a[i+1][0+1] ;
     var y1 : int ; y1 := a[i+1][1+1] ;
    var x2 : int ; x2 := a[j+1][0+1] ;
    var y2 : int ; y2 := a[j+1][1+1] ;
    var dis : int ; dis := if x2 - x1 < 0 then -(x2 - x1) else x2 - x1 endif + if y2 - y1 < 0 then -(y2 - y1) else y2 - y1 endif ;
    if (dis > k) then (     dp[j+1] := -1 ; 
     is := false ; 
     break ) else skip ; 
 )  ;     j := j + 1 ) ; 
     if (is) then (     ans := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if ans then 1 else -1 endif) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class handling {
  public static void main(String[] args){
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int m=scn.nextInt();
    int ans=0 ;
    for(int i=0 ; i<n*m ; i++){
      int a=scn.nextInt();
      int b=scn.nextInt();
      if(a>0 || b>0){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class handling {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var m : int ; m := scn.getCurrent()->toInteger() ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n * m do ( (     var a : int ; a := scn.getCurrent()->toInteger() ;
     var b : int ; b := scn.getCurrent()->toInteger() ;
     if (a > 0 or b > 0) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    try {
      BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
      String strLine=reader.readLine();
      char[] chaAryLineS=strLine.toCharArray();
      char[] chaAryLineSAfter=new char[chaAryLineS.length*2];
      strLine=reader.readLine();
      char[] chaAryLineP=strLine.toCharArray();
      System.arraycopy(chaAryLineS,0,chaAryLineSAfter,0,chaAryLineS.length);
      System.arraycopy(chaAryLineS,0,chaAryLineSAfter,chaAryLineS.length,chaAryLineS.length);
      int intlength=chaAryLineSAfter.length-chaAryLineP.length+1 ;
      int intCount=0 ;
      boolean booYes=false ;
      for(int i=0 ; i<intlength ; i++){
        for(int j=0 ; j<chaAryLineP.length ; j++){
          if(chaAryLineSAfter[i+j]==chaAryLineP[j]){
            intCount++;
            if(intCount==chaAryLineP.length){
              booYes=true ;
            }
          }
        }
        intCount=0 ;
      }
      if(booYes){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
    catch(IOException e){
      System.out.println(e);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var strLine : String ; strLine := reader.readLine() ;
    var chaAryLineS : Sequence(String) ; chaAryLineS := strLine->characters() ;
    var chaAryLineSAfter : Sequence(String) ; chaAryLineSAfter := Integer.subrange(1,chaAryLineS->size() * 2)->collect(0) ;
    strLine := reader.readLine() ; 
    var chaAryLineP : Sequence(String) ; chaAryLineP := strLine->characters() ;
    for _x : Integer.subrange(1,chaAryLineS->size()) do chaAryLineSAfter[0 + _x] := chaAryLineS[0 + _x] ; 
    for _x : Integer.subrange(1,chaAryLineS->size()) do chaAryLineSAfter[chaAryLineS->size() + _x] := chaAryLineS[0 + _x] ; 
    var intlength : int ; intlength := chaAryLineSAfter->size() - chaAryLineP->size() + 1 ;
    var intCount : int ; intCount := 0 ;
    var booYes : boolean ; booYes := false ;
        var i : int ; i := 0 ; while i < intlength do ( (         var j : int ; j := 0 ; while j < chaAryLineP->size() do ( (     if (chaAryLineSAfter[i + j+1] = chaAryLineP[j+1]) then (     intCount := intCount + 1 ; 
     if (intCount = chaAryLineP->size()) then (     booYes := true ) else skip ) else skip )  ;     j := j + 1 ) ; 
     intCount := 0 )  ;     i := i + 1 ) ; 
    if (booYes) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 )   catch (e : IOException) do (     OclFile["System.out"].println(e) )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class P595A_VitalyAndNight {
  public static void main(String[] subhani)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken()),m=Integer.parseInt(st.nextToken());
    int flats=0 ;
    for(int i=0 ; i<n ; ++i){
      st=new StringTokenizer(br.readLine());
      for(int j=0 ; j<2*m ; j+=2){
        int w1=Integer.parseInt(st.nextToken());
        int w2=Integer.parseInt(st.nextToken());
        if(w1==1 || w2==1)flats++;
      }
    }
    System.out.println(flats);
  }
}
------------------------------------------------------------
OCL File:
---------
 class P595A_VitalyAndNight {
  static   operation main( subhani : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var m : int ; m := (st.next())->toInteger() ;
    var flats : int ; flats := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
         var j : int ; j := 0 ; while j < 2 * m do ( (     var w1 : int ; w1 := (st.next())->toInteger() ;
     var w2 : int ; w2 := (st.next())->toInteger() ;
     if (w1 = 1 or w2 = 1) then     flats := flats + 1 ; else skip )  ;     j := j+(2) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(flats) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class P595A {
  public static void main(String[] args)throws IOException {
    BufferedReader io=new BufferedReader(new InputStreamReader(System.in));
    String[] nm=io.readLine().split(" ");
    Integer n=Integer.valueOf(nm[0]);
    Integer m=Integer.valueOf(nm[1]);
    Integer rs=0 ;
    while(n>0){
      n--;
      String[] input=io.readLine().split(" ");
      for(int i=0 ; i<input.length ; i=i+2){
        if(input[i] .equals("1")|| input[i+1] .equals("1")){
          rs++;
        }
      }
    }
    System.out.println(rs);
  }
}
------------------------------------------------------------
OCL File:
---------
 class P595A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : OclFile ; io := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var nm : Sequence(String) ; nm := io.readLine()->split(" ") ;
    var n : int ; n := (nm[0+1])->toInteger() ;
    var m : int ; m := (nm[1+1])->toInteger() ;
    var rs : int ; rs := 0 ;
    while (n > 0) do (     n := n - 1 ; 
     var input : Sequence(String) ; input := io.readLine()->split(" ") ;
         var i : int ; i := 0 ; while i < input->size() do ( (     if (input[i+1] = "1" or input[i + 1+1] = "1") then (     rs := rs + 1 ) else skip )  ;     i := i + 2 ) ) ; 
    OclFile["System.out"].println(rs) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  void solve(){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt(),S=sc.nextInt();
      if(n==0 && S==0)break ;
      PriorityQueue<Integer>q=new PriorityQueue<Integer>(10,new Comparator<Integer>(){
        public int compare(Integer i1,Integer i2){
          return(int)i2-i1 ;
        }
      }
);
      for(int i=0 ; i<n ; i++)q.add(new Integer(sc.nextInt()));
      int[] rr=new int[q.size()];
      int idx=0 ;
      while(q.size()>0)rr[idx++]=q.poll();
      int cnt=0 ;
      for(int i=0 ; i<rr.length ; i++){
        int l=i,r=rr.length ;
        while(l+1<r){
          int mid=(l+r)/2 ;
          if(rr[i]+rr[mid]>S)l=mid ;
          else r=mid ;
        }
        cnt+=l-i ;
      }
      System.out.println(cnt);
    }
  }
  public static void main(String[] args){
    new Main().solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation solve() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var S : int ; S := sc.getCurrent()->toInteger() ;
     if (n = 0 & S = 0) then     break else skip ; 
    var q : Sequence(int) ; q := Sequence{} ;
        var i : int ; i := 0 ; while i < n do (     q := q->including(("" + (sc.getCurrent()->toInteger()))->toInteger()) ;  ;     i := i + 1 ) ; 
    var rr : Sequence(int) ; rr := Integer.subrange(1,q->size())->collect(0) ;
    var idx : int ; idx := 0 ;
    while (q->size() > 0) do     rr[idx+1] := q->min() ;     q := q->sort()->tail() ; ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < rr->size() do ( (     var l : int ; l := i ;
    var r : int ; r := rr->size() ;
     while (l + 1 < r) do (     var mid : int ; mid := (l + r) / 2 ;
     if (rr[i+1] + rr[mid+1] > S) then     l := mid ; else     r := mid ; ) ; 
     cnt := cnt+(l - i) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cnt) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import static java.lang.Integer.parseInt ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    String[] words ;
    while((line=br.readLine())!=null && ! line.isEmpty()){
      int n,S ;
      n=parseInt(line.substring(0,line.indexOf(' ')));
      S=parseInt(line.substring(line.indexOf(' ')+1));
      if((n | S)==0)break ;
      int[] r=new int[101];
      for(int i=0 ; i<n ; i++){
        r[parseInt(br.readLine())]++;
      }
      long count=0 ;
      for(int i=S/2 ; i<=100 ; i++){
        if(i*2>S)count+=r[i]*(r[i]-1)/2 ;
      }
      for(int i=1 ; i<100 ; i++){
        for(int j=i+1 ; j<=100 ; j++){
          if(i+j>S)count+=r[i]*r[j];
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
     var words : Sequence(String) ;
         line := br.readLine() ;
    while ((line) /= null & not(line->isEmpty())) do (    skip ; (     var n : int ;
    var S : int ;
     n := (line.subrange(0+1,line->indexOf(' ')-1) + "")->toInteger() ; 
    S := (line.subrange(line->indexOf(' ')-1 + 1+1,line->indexOf(' ')-1 + 1) + "")->toInteger() ; 
    if ((MathLib.bitwiseOr(n,S)) = 0) then     break else skip ; 
    var r : Sequence(int) ; r := Integer.subrange(1,101)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     r[parseInt(br.readLine())+1] := r[parseInt(br.readLine())+1] + 1 )  ;     i := i + 1 ) ; 
    var count : long ; count := 0 ;
        var i : int ; i := S / 2 ; while i <= 100 do ( (     if (i * 2 > S) then     count := count+(r[i+1] * (r[i+1] - 1) / 2) ; else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < 100 do ( (         var j : int ; j := i + 1 ; while j <= 100 do ( (     if (i + j > S) then     count := count+(r[i+1] * r[j+1]) ; else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;     line := br.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    List<Integer>mList=new ArrayList<Integer>();
    int en,n ;
    n=sc.nextInt();
    en=sc.nextInt();
    while(n!=0 || en!=0){
      mList.clear();
      for(int i=0 ; i<n ; i++){
        mList.add(sc.nextInt());
      }
      mList.sort(new Comparator<Integer>(){
        @ Override public int compare(Integer o1,Integer o2){
          return o2-o1 ;
        }
      }
);
      int count=0 ;
      for(int i=0 ; i<mList.size()-1 ; i++){
        for(int j=i+1 ; j<mList.size(); j++){
          if(mList.get(i)+mList.get(j)<=en){
            break ;
          }
          count++;
        }
      }
      System.out.println(count);
      n=sc.nextInt();
      en=sc.nextInt();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var mList : Sequence(int) ; mList := Sequence{} ;
    var en : int ;
    var n : int ;
    n := sc.getCurrent()->toInteger() ; 
    en := sc.getCurrent()->toInteger() ; 
    while (n /= 0 or en /= 0) do (     mList := mList->intersection(Set{}) ; 
         var i : int ; i := 0 ; while i < n do ( (     mList := mList->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    mList := mList.sort(OclComparator<int>.newOclComparator()) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < mList->size() - 1 do ( (         var j : int ; j := i + 1 ; while j < mList->size() do ( (     if (mList->at(i+1) + mList->at(j+1) <= en) then (     break ) else skip ; 
     count := count + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
    n := sc.getCurrent()->toInteger() ; 
    en := sc.getCurrent()->toInteger() ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class the_child_and_set {
  static String check(String s){
    String ss="" ;
    for(int i=0 ; i<s.length(); i++){
      if(s.charAt(i)!='-' && s.charAt(i)!='_' && s.charAt(i)!=';')ss+=s.charAt(i);
    }
    return ss ;
  }
  static void printans(String s,String s1,String s2,String s3){
    int len=s1.length()+s2.length()+s3.length();
    if(len!=s.length())System.out.println("WA");
    else {
      if((s1+s2+s3).equals(s)||(s1+s3+s2).equals(s)||(s2+s3+s1).equals(s)||(s2+s1+s3).equals(s)||(s3+s1+s2).equals(s)||(s3+s2+s1).equals(s))System.out.println("ACC");
      else System.out.println("WA");
    }
  }
  public static void main(String args[]){
    Scanner in=new Scanner(System.in);
    String s1=in.nextLine().toLowerCase();
    String s2=in.nextLine().toLowerCase();
    String s3=in.nextLine().toLowerCase();
    s1=check(s1);
    s2=check(s2);
    s3=check(s3);
    int n=in.nextInt();
    in.nextLine();
    for(int i=0 ; i<n ; i++){
      String s=in.nextLine().toLowerCase();
      s=check(s);
      printans(s,s1,s2,s3);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class the_child_and_set {
  static   operation check( s : String) : String
  pre: true
  post: true
  activity: (     var ss : String ; ss := "" ;
         var i : int ; i := 0 ; while i < s->size() do ( (     if (s->at(i+1) /= '-' & s->at(i+1) /= '_' & s->at(i+1) /= ';') then     ss := ss+(s->at(i+1)) ; else skip )  ;     i := i + 1 ) ; 
     return ss );
  static   operation printans( s : String, s1 : String, s2 : String, s3 : String) : void
  pre: true
  post: true
  activity: (     var len : int ; len := s1->size() + s2->size() + s3->size() ;
     if (len /= s->size()) then     OclFile["System.out"].println("WA") ; else (     if ((s1 + s2 + s3) = s or (s1 + s3 + s2) = s or (s2 + s3 + s1) = s or (s2 + s1 + s3) = s or (s3 + s1 + s2) = s or (s3 + s2 + s1) = s) then     OclFile["System.out"].println("ACC") ; else     OclFile["System.out"].println("WA") ; ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := in.nextLine()->toLowerCase() ;
    var s2 : String ; s2 := in.nextLine()->toLowerCase() ;
    var s3 : String ; s3 := in.nextLine()->toLowerCase() ;
    s1 := check(s1) ; 
    s2 := check(s2) ; 
    s3 := check(s3) ; 
    var n : int ; n := in.getCurrent()->toInteger() ;
    skip ; 
        var i : int ; i := 0 ; while i < n do ( (     var s : String ; s := in.nextLine()->toLowerCase() ;
     s := check(s) ; 
     execute printans(s, s1, s2, s3) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    String a=sc.next();
    int l=0,r=0 ;
    while(l<n && a.charAt(l)==a.charAt(0))l++;
    while(r<n && a.charAt(n-1-r)==a.charAt(n-1))r++;
    if(a.charAt(0)!=a.charAt(n-1))System.out.println((l+r+1)% 998244353);
    else if(l+r>=n)System.out.println(((long)n*(n+1)/2)% 998244353);
    else System.out.println(((long)l+1)*((long)r+1)% 998244353);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : String ; a := sc.getCurrent() ;
    var l : int ; l := 0 ;
    var r : int ; r := 0 ;
    while (l < n & a->at(l+1) = a->at(0+1)) do     l := l + 1 ; ; 
    while (r < n & a->at(n - 1 - (r)->char2byte()+1) = a->at(n - 1+1)) do     r := r + 1 ; ; 
    if (a->at(0+1) /= a->at(n - 1+1)) then     OclFile["System.out"].println((l + r + 1) mod 998244353) else     if (l + r >= n) then     OclFile["System.out"].println((n->oclAsType(long) * (n + 1) / 2) mod 998244353) else     OclFile["System.out"].println(((l)->char2byte() + 1) * ((r)->char2byte() + 1) mod 998244353) ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF1096B {
  public static Scanner scanner ;
  public static int MOD=998244353 ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    String str=scanner.next();
    int index=0,prefix=1 ;
    while(index+1<str.length()&& str.charAt(index+1)==str.charAt(index)){
      index++;
      prefix++;
    }
    index=n-1 ;
    int suffix=1 ;
    while(index-1>=0 && str.charAt(index-1)==str.charAt(index)){
      suffix++;
      index--;
    }
    long res=0 ;
    if(prefix==suffix && prefix==n){
      res=(long)n*(n+1)/2 ;
    }
    else if(str.charAt(0)==str.charAt(n-1)){
      res=(long)(prefix+1)*(suffix+1);
    }
    else {
      res=(prefix+suffix+1);
    }
    if(res<0)res+=MOD ;
    res=res % MOD ;
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF1096B {
  static   attribute scanner : OclFile;
  static   attribute MOD : int := 998244353;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var str : String ; str := scanner.getCurrent() ;
    var index : int ; index := 0 ;
    var prefix : int ; prefix := 1 ;
    while (index + 1 < str->size() & str->at(index + 1+1) = str->at(index+1)) do (     index := index + 1 ; 
     prefix := prefix + 1 ) ; 
    index := n - 1 ; 
    var suffix : int ; suffix := 1 ;
    while ((index)->char2byte() - 1 >= 0 & str->at((index)->char2byte() - 1+1) = str->at(index+1)) do (     suffix := suffix + 1 ; 
     index := index - 1 ) ; 
    var res : long ; res := 0 ;
    if (prefix = suffix & prefix = n) then (     res := n->oclAsType(long) * (n + 1) / 2 ) else     if (str->at(0+1) = str->at(n - 1+1)) then (     res := (prefix + 1)->oclAsType(long) * (suffix + 1) ) else (     res := (prefix + suffix + 1) ) ;  ;  
    if (res < 0) then     res := res+(MOD) ; else skip ; 
    res := res mod MOD ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    Scanner scan=new Scanner(System.in);
    String ringText=scan.nextLine();
    int ringLength=ringText.length();
    char[] ringChar=ringText.toCharArray();
    String target=scan.nextLine();
    int targetLength=target.length();
    String hikaku="" ;
    boolean kai=false ;
    for(int i=0 ; i<ringLength ; i++){
      hikaku="" ;
      kai=false ;
      for(int j=0 ; j<targetLength ; j++){
        int i2=j ;
        if(i+i2>=ringLength){
          i2-=ringLength ;
        }
        hikaku=hikaku+ringChar[i+i2];
      }
      if(target.equals(hikaku)){
        System.out.println("Yes");
        kai=true ;
        break ;
      }
    }
    if(kai==false){
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var ringText : String ; ringText := scan.nextLine() ;
    var ringLength : int ; ringLength := ringText->size() ;
    var ringChar : Sequence(String) ; ringChar := ringText->characters() ;
    var target : String ; target := scan.nextLine() ;
    var targetLength : int ; targetLength := target->size() ;
    var hikaku : String ; hikaku := "" ;
    var kai : boolean ; kai := false ;
        var i : int ; i := 0 ; while i < ringLength do ( (     hikaku := "" ; 
     kai := false ; 
         var j : int ; j := 0 ; while j < targetLength do ( (     var i2 : int ; i2 := j ;
     if (i + i2 >= ringLength) then (     i2 := i2-(ringLength) ) else skip ; 
     hikaku := hikaku + ringChar[i + i2+1] )  ;     j := j + 1 ) ; 
     if (target = hikaku) then (     OclFile["System.out"].println("Yes") ; 
     kai := true ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (kai = false) then (     OclFile["System.out"].println("No") ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void longest(int a[],int n,int k){
    int[] freq=new int[7];
    int start=0,end=0,now=0,l=0 ;
    for(int i=0 ; i<n ; i++){
      freq[a[i] ]++;
      if(freq[a[i] ]==1)now++;
      while(now>k){
        freq[a[l] ]--;
        if(freq[a[l] ]==0)now--;
        l++;
      }
      if(i-l+1>=end-start+1){
        end=i ;
        start=l ;
      }
    }
    for(int i=start ; i<=end ; i++)System.out.print(a[i]+" ");
  }
  public static void main(String args[]){
    int a[]={
      6,5,1,2,3,2,1,4,5 };
      int n=a.length ;
      int k=3 ;
      longest(a,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation longest( a : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,7)->collect(0) ;
     var start : int ; start := 0 ;
    var end : int ; end := 0 ;
    var now : int ; now := 0 ;
    var l : int ; l := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     freq[a[i+1]+1] := freq[a[i+1]+1] + 1 ; 
     if (freq[a[i+1]+1] = 1) then     now := now + 1 ; else skip ; 
     while (now > k) do (     freq[a[l+1]+1] := freq[a[l+1]+1] - 1 ; 
     if (freq[a[l+1]+1] = 0) then     now := now - 1 ; else skip ; 
     l := l + 1 ) ; 
     if (i - l + 1 >= end - start + 1) then (     end := i ; 
     start := l ) else skip )  ;     i := i + 1 ) ; 
         var i : int ; i := start ; while i <= end do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{6,5,1,2,3,2,1,4,5} ;
     var n : int ; n := a->size() ;
     var k : int ; k := 3 ;
     execute longest(a, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class permutations {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer s=new StringTokenizer(in.readLine());
    int n=Integer.parseInt(s.nextToken());
    int[] arr1=new int[n],arr2=new int[n];
    s=new StringTokenizer(in.readLine());
    for(int i=0 ; i<n ; i++)arr1[i]=Integer.parseInt(s.nextToken())-1 ;
    s=new StringTokenizer(in.readLine());
    int[] arr3=new int[n];
    for(int i=0 ; i<n ; i++)arr2[Integer.parseInt(s.nextToken())-1]=i ;
    for(int i=0 ; i<n ; i++)arr3[i]=arr2[arr1[i] ];
    int i=0 ;
    for(i=1 ; i<n ; i++)if(arr3[i]<arr3[i-1])break ;
    System.out.println(n-i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class permutations {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var s : OclIterator ; s := OclIterator.newOclIterator_String(in.readLine()) ;
    var n : int ; n := (s.next())->toInteger() ;
    var arr1 : Sequence(int) ; arr1 := Integer.subrange(1,n)->collect(0) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,n)->collect(0) ;
    s := OclIterator.newOclIterator_String(in.readLine()) ; 
        var i : int ; i := 0 ; while i < n do (     arr1[i+1] := (s.next())->toInteger() - 1 ;  ;     i := i + 1 ) ; 
    s := OclIterator.newOclIterator_String(in.readLine()) ; 
    var arr3 : Sequence(int) ; arr3 := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr2[(s.next())->toInteger() - 1+1] := i ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     arr3[i+1] := arr2[arr1[i+1]+1] ;  ;     i := i + 1 ) ; 
    var i : int ; i := 0 ;
        i := 1 ; while i < n do (     if (arr3[i+1] < arr3[i - 1+1]) then     break else skip ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n - i) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] ar=new int[n];
    int[] br=new int[n];
    HashSet<Integer>set=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      ar[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++)br[i]=sc.nextInt();
    int j=0,k=0,c=0 ;
    while(j<n){
      if(ar[k]!=br[j])c++;
      else k++;
      j++;
    }
    System.out.println(c);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
    var br : Sequence(int) ; br := Integer.subrange(1,n)->collect(0) ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     br[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var j : int ; j := 0 ;
    var k : int ; k := 0 ;
    var c : int ; c := 0 ;
    while (j < n) do (     if (ar[k+1] /= br[j+1]) then     c := c + 1 else     k := k + 1 ; ;  
     j := j + 1 ) ; 
    OclFile["System.out"].println(c) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=0 ;
    int[] a=new int[n];
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      b[i]=in.nextInt();
      if(b[i]==a[k]){
        k++;
      }
    }
    System.out.println(n-k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := in.getCurrent()->toInteger() ; 
     if (b[i+1] = a[k+1]) then (     k := k + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n - k) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=1 ;
    int[] a=new int[n+1];
    int[] b=new int[n+1];
    for(int i=1 ; i<=n ; i++){
      a[i]=in.nextInt();
    }
    for(int i=1 ; i<=n ; i++){
      b[i]=in.nextInt();
      if(b[i]==a[k]){
        k++;
      }
    }
    System.out.println(n-k+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := 1 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     b[i+1] := in.getCurrent()->toInteger() ; 
     if (b[i+1] = a[k+1]) then (     k := k + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n - k + 1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main implements Runnable {
  ArrayList<Integer>[] graph ;
  boolean[] visited ;
  int[] color ;
  long one ;
  long bipartite ;
  long count ;
  boolean mujun ;
  int dfs(int a,int c){
    if(visited[a]){
      if(color[a]>=0 && color[a]!=c)mujun=true ;
      return 0 ;
    }
    visited[a]=true ;
    color[a]=c ;
    int total=1 ;
    for(int b : graph[a]){
      total+=dfs(b,1-c);
    }
    return total ;
  }
  public void run(){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    this.graph=new ArrayList[n];
    for(int i=0 ; i<n ; ++i)this.graph[i]=new ArrayList<Integer>();
    for(int i=0 ; i<m ; ++i){
      int u=scan.nextInt()-1 ;
      int v=scan.nextInt()-1 ;
      this.graph[u] .add(v);
      this.graph[v] .add(u);
    }
    visited=new boolean[n];
    color=new int[n];
    Arrays.fill(color,-1);
    one=0 ;
    bipartite=0 ;
    count=0 ;
    for(int i=0 ; i<n ; ++i){
      if(visited[i])continue ;
      count++;
      mujun=false ;
      int kind=dfs(i,0);
      if(kind==1)one++;
      else if(! mujun)bipartite++;
    }
    long total=one*(2*n-one);
    total+=(count-one)*(count-one);
    total+=bipartite*bipartite ;
    System.out.println(total);
  }
  public static void main(String[] args){
    new Thread(null,new Main(),"",128*1024*1024).start();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Runnable {
   attribute graph : Sequence(Sequence(int));
   attribute visited : Sequence(boolean);
   attribute color : Sequence(int);
   attribute one : long;
   attribute bipartite : long;
   attribute count : long;
   attribute mujun : boolean;
   operation dfs( a : int, c : int) : int
  pre: true
  post: true
  activity: (     if (visited[a+1]) then (     if (color[a+1] >= 0 & color[a+1] /= c) then     mujun := true ; else skip ; 
     return 0 ) else skip ; 
     visited[a+1] := true ; 
    color[a+1] := c ; 
    var total : int ; total := 1 ;
    for (b : graph[a+1]) do ( (     total := total+(dfs(b, 1 - c)) )  ) ; 
    return total 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    self.graph := Integer.subrange(1,n)->collect(null) ; 
        var i : int ; i := 0 ; while i < n do (     self.graph[i+1] := Sequence{} ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do ( (     var u : int ; u := scan.getCurrent()->toInteger() - 1 ;
     var v : int ; v := scan.getCurrent()->toInteger() - 1 ;
     self.graph[u+1]->excludes(v) ; 
     self.graph[v+1]->excludes(u) )  ;     i := i + 1 ) ; 
    visited := Integer.subrange(1,n)->collect(false) ; 
    color := Integer.subrange(1,n)->collect(0) ; 
    color := color->collect(-1) ; 
    one := 0 ; 
    bipartite := 0 ; 
    count := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     if (visited[i+1]) then     continue else skip ; 
     count := count + 1 ; 
    mujun := false ; 
    var kind : int ; kind := dfs(i, 0) ;
    if (kind = 1) then     one := one + 1 else     if (not(mujun)) then     bipartite := bipartite + 1 ; else skip ; ;  
 )  ;     i := i + 1 ) ; 
    var total : long ; total := one * (2 * n - one) ;
    total := total+((count - one) * (count - one)) ; 
    total := total+(bipartite * bipartite) ; 
    OclFile["System.out"].println(total) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(null, Main.newMain(), "", 128 * 1024 * 1024).start() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A187 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int[] first=new int[N];
    for(int n=0 ; n<N ; n++){
      first[n]=in.nextInt()-1 ;
    }
    int[] second=new int[N];
    for(int n=0 ; n<N ; n++){
      second[in.nextInt()-1]=n ;
    }
    int last=-1 ;
    int idx=0 ;
    while(idx<N){
      int next=second[first[idx] ];
      if(next>last){
        last=next ;
        idx++;
      }
      else {
        break ;
      }
    }
    int answer=N-idx ;
    System.out.println(answer);
  }
}
------------------------------------------------------------
OCL File:
---------
 class A187 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var first : Sequence(int) ; first := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     first[n+1] := in.getCurrent()->toInteger() - 1 )  ;     n := n + 1 ) ; 
    var second : Sequence(int) ; second := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     second[in.getCurrent()->toInteger() - 1+1] := n )  ;     n := n + 1 ) ; 
    var last : int ; last := -1 ;
    var idx : int ; idx := 0 ;
    while (idx < N) do (     var next : int ; next := second[first[idx+1]+1] ;
     if (next > last) then (     last := next ; 
     idx := idx + 1 ) else (     break ) ) ; 
    var answer : int ; answer := N - idx ;
    OclFile["System.out"].println(answer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    Scanner scanner=new Scanner(System.in);
    loop : while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      Integer[] a=new Integer[n];
      Integer[] b=new Integer[n];
      for(int i=0 ; i<n ; i++)a[i]=scanner.nextInt();
      for(int i=0 ; i<n ; i++)b[i]=scanner.nextInt();
      Arrays.sort(a,Collections.reverseOrder());
      Arrays.sort(b,Collections.reverseOrder());
      n/=2 ;
      for(int i=0 ; i<n ; i++){
        if(a[i*2]>b[i]){
          System.out.println((i*2)+1);
          continue loop ;
        }
      }
      System.out.println("NA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(null) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     b[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := OclComparator.sortWith(a, reverseOrder()) ; 
    b := OclComparator.sortWith(b, reverseOrder()) ; 
    n := n/(2) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (a[i * 2+1] > b[i+1]) then (     OclFile["System.out"].println((i * 2) + 1) ; 
     continue ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NA") ; 
 ) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  private void run(){
    Scanner scanner=new Scanner(System.in);
    loop : while(true){
      int n=scanner.nextInt();
      if(n==0)break ;
      int[] a=new int[n];
      int[] b=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=scanner.nextInt();
      for(int i=0 ; i<n ; i++)b[i]=scanner.nextInt();
      Arrays.sort(a);
      Arrays.sort(b);
      for(int i=0 ; i<n/2 ; i++){
        if(a[n-1-i*2]>b[n-1-i]){
          System.out.println((i*2)+1);
          continue loop ;
        }
      }
      System.out.println("NA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     b[i+1] := scanner.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
        var i : int ; i := 0 ; while i < n / 2 do ( (     if (a[n - 1 - i * 2+1] > b[n - 1 - i+1]) then (     OclFile["System.out"].println((i * 2) + 1) ; 
     continue ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("NA") ; 
 ) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
import java.awt.geom.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] a=new int[n];
      int[] b=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      for(int i=0 ; i<n ; i++){
        b[i]=sc.nextInt();
      }
      Arrays.sort(a);
      Arrays.sort(b);
      int[] a2=new int[n];
      int[] b2=new int[n];
      for(int i=0 ; i<n ; i++){
        a2[n-i-1]=a[i];
        b2[n-i-1]=b[i];
      }
      a=a2 ;
      b=b2 ;
      int ans=-1 ;
      for(int k=0 ; k<n/2 ; k++){
        if(a[k*2]>b[k]){
          ans=k*2+1 ;
          break ;
        }
      }
      if(ans==-1){
        System.out.println("NA");
      }
      else {
        System.out.println(ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    b := b->sort() ; 
    var a2 : Sequence(int) ; a2 := Integer.subrange(1,n)->collect(0) ;
    var b2 : Sequence(int) ; b2 := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a2[n - i - 1+1] := a[i+1] ; 
     b2[n - i - 1+1] := b[i+1] )  ;     i := i + 1 ) ; 
    a := a2 ; 
    b := b2 ; 
    var ans : int ; ans := -1 ;
        var k : int ; k := 0 ; while k < n / 2 do ( (     if (a[k * 2+1] > b[k+1]) then (     ans := k * 2 + 1 ; 
     break ) else skip )  ;     k := k + 1 ) ; 
    if (ans = -1) then (     OclFile["System.out"].println("NA") ) else (     OclFile["System.out"].println(ans) ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      final int N=sc.nextInt();
      if(N==0){
        break ;
      }
      System.gc();
      int[] own=new int[N];
      ArrayList<Integer>ene=new ArrayList<Integer>();
      for(int i=0 ; i<N ; i++){
        own[i]=-sc.nextInt();
      }
      Arrays.sort(own);
      for(int i=0 ; i<N ; i++){
        own[i]=-own[i];
      }
      for(int i=0 ; i<N ; i++){
        ene.add(sc.nextInt());
      }
      Collections.sort(ene);
      boolean flag=false ;
      int win_count=0 ;
      for(int K=1 ; K<N ; K++){
        final int must=K/2+1 ;
        final int own_num=own[K-1];
        int pos=Collections.binarySearch(ene,own_num);
        if(pos<0){
          pos=-(pos+1);
        }
        if(pos>=ene.size()){
          win_count++;
        }
        else if(own_num>ene.get(pos)){
          win_count++;
        }
        if(win_count>=must){
          flag=true ;
          System.out.println(K);
          break ;
        }
        if(ene.size()>pos){
          ene.remove(pos);
        }
        else {
          ene.remove(0);
        }
      }
      if(! flag){
        System.out.println("NA");
      }
    }
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then (     break ) else skip ; 
gc() ; 
    var own : Sequence(int) ; own := Integer.subrange(1,N)->collect(0) ;
    var ene : Sequence(int) ; ene := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     own[i+1] := -sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    own := own->sort() ; 
        var i : int ; i := 0 ; while i < N do ( (     own[i+1] := -own[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     ene := ene->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    ene := ene->sort() ; 
    var flag : boolean ; flag := false ;
    var win_count : int ; win_count := 0 ;
        var K : int ; K := 1 ; while K < N do ( (     var must : int ; must := K / 2 + 1 ;
     var own_num : int ; own_num := own[K - 1+1] ;
    var pos : int ; pos := .binarySearch(ene, own_num) ;
    if (pos < 0) then (     pos := -(pos + 1) ) else skip ; 
    if (pos >= ene->size()) then (     win_count := win_count + 1 ) else     if (own_num > ene->at(pos+1)) then (     win_count := win_count + 1 ) else skip ; ;  
    if (win_count >= must) then (     flag := true ; 
     OclFile["System.out"].println(K) ; 
     break ) else skip ; 
    if (ene->size() > pos) then (     ene := ene->excludingAt(pos+1) ) else (     ene := ene->excludingAt(0+1) ) ;  
 )  ;     K := K + 1 ) ; 
    if (not(flag)) then (     OclFile["System.out"].println("NA") ) else skip ; 
 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String word=br.readLine();
    String key=br.readLine();
    word=word+word.substring(0,key.length()-1);
    if(bmStringSearch(word,key)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
  private static boolean bmStringSearch(String word,String key){
    int[] table=new int[Character.MAX_VALUE];
    for(int i=0 ; i<table.length ; i++){
      table[i]=key.length();
    }
    for(int i=0 ; i<key.length(); i++){
      table[key.charAt(i)]=key.length()-i-1 ;
    }
    int wordIndex=key.length()-1 ;
    while(wordIndex<word.length()){
      int keyIndex=key.length()-1 ;
      while(word.charAt(wordIndex)==key.charAt(keyIndex)){
        if(keyIndex==0){
          return true ;
        }
        wordIndex--;
        keyIndex--;
      }
      if(table[word.charAt(wordIndex)]>key.length()-keyIndex){
        wordIndex+=table[word.charAt(wordIndex)];
      }
      else {
        wordIndex+=key.length()-keyIndex ;
      }
    }
    return false ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var word : String ; word := br.readLine() ;
    var key : String ; key := br.readLine() ;
    word := word + word.subrange(0+1,key->size() - 1) ; 
    if (bmStringSearch(word, key)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
  static   operation bmStringSearch( word : String, key : String) : boolean
  pre: true
  post: true
  activity: (     var table : Sequence(int) ; table := Integer.subrange(1,"\uFFFF")->collect(0) ;
         var i : int ; i := 0 ; while i < table->size() do ( (     table[i+1] := key->size() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < key->size() do ( (     table[key->at(i+1)+1] := key->size() - i - 1 )  ;     i := i + 1 ) ; 
    var wordIndex : int ; wordIndex := key->size() - 1 ;
    while (wordIndex < word->size()) do (     var keyIndex : int ; keyIndex := key->size() - 1 ;
     while (word->at(wordIndex+1) = key->at(keyIndex+1)) do (     if (keyIndex = 0) then (     return true ) else skip ; 
     wordIndex := wordIndex - 1 ; 
     keyIndex := keyIndex - 1 ) ; 
     if (table[word->at(wordIndex+1)+1] > key->size() - keyIndex) then (     wordIndex := wordIndex+(table[word->at(wordIndex+1)+1]) ) else (     wordIndex := wordIndex+(key->size() - keyIndex) ) ) ; 
    return false 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int Add(int x,int y){
    while(y!=0){
      int carry=x & y ;
      x=x ^ y ;
      y=carry<<1 ;
    }
    return x ;
  }
  public static void main(String arg[]){
    System.out.println(Add(15,32));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Add( x : int, y : int) : int
  pre: true
  post: true
  activity: (     while (y /= 0) do (     var carry : int ; carry := MathLib.bitwiseAnd(x,y) ;
     x := x xor y ; 
     y := (carry*(2->pow(1)))->oclAsType(long) ) ; 
     return x );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(Add(15, 32)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static long[][] dp ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    dp=new long[5][s.length()+1];
    for(int i=0 ; i<5 ; i++){
      Arrays.fill(dp[i],-1L);
    }
    System.out.println(getCount(4,s));
  }
  static long getCount(int size,String s){
    if(dp[size][s.length()]!=-1){
      return dp[size][s.length()];
    }
    if(size==1){
      long ans=0 ;
      if(s.length()>3 || s.length()<=0){
      }
      else if(s.length()>1 && s.charAt(0)=='0'){
      }
      else {
        int x=Integer.parseInt(s);
        if(x>255){
        }
        else {
          ans=1 ;
        }
      }
      dp[size][s.length()]=ans ;
      return ans ;
    }
    long ans=0 ;
    for(int i=1 ; i<=3 && i<s.length(); i++){
      if(i>1 && s.charAt(0)=='0'){
        break ;
      }
      if(i==3 && Integer.parseInt(s.substring(0,3))>255){
        break ;
      }
      ans+=getCount(size-1,s.substring(i,s.length()));
    }
    dp[size][s.length()]=ans ;
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute dp : Sequence(Sequence(long));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    dp := Integer.subrange(1,5)->collect(Integer.subrange(1,s->size() + 1)->collect(0)) ; 
        var i : int ; i := 0 ; while i < 5 do ( (     dp[i+1] := dp[i+1]->collect(-1L) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(getCount(4, s)) ; 
 );
  static   operation getCount( size : int, s : String) : long
  pre: true
  post: true
  activity: (     if (dp[size+1][s->size()+1] /= -1) then (     return dp[size+1][s->size()+1] ) else skip ; 
     if (size = 1) then (     var ans : long ; ans := 0 ;
     if (s->size() > 3 or s->size() <= 0) then skip else     if (s->size() > 1 & s->at(0+1) = '0') then skip else (     var x : int ; x := (s)->toInteger() ;
     if (x > 255) then skip else (     ans := 1 ) ) ;  ;  
     dp[size+1][s->size()+1] := ans ; 
     return ans ) else skip ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 1 ; while i <= 3 & i < s->size() do ( (     if (i > 1 & s->at(0+1) = '0') then (     break ) else skip ; 
     if (i = 3 & (s.subrange(0+1,3))->toInteger() > 255) then (     break ) else skip ; 
     ans := ans+(getCount(size - 1, s.subrange(i+1,s->size()))) )  ;     i := i + 1 ) ; 
    dp[size+1][s->size()+1] := ans ; 
    return ans 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Ekub {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    double answear=0 ;
    while(t-->0){
      int n=sc.nextInt();
      int array[]=new int[n];
      int even=0 ;
      for(int i=0 ; i<n ; i++){
        array[i]=sc.nextInt();
        if(array[i] % 2==0){
          even++;
        }
      }
      answear=(((double)even/2)*(even-1))+(even*(n-even));
      int array_odd[]=new int[n-even];
      int temp=0 ;
      for(int i=0 ; i<array.length ; i++){
        if(array[i] % 2>0){
          array_odd[temp]=array[i];
          temp++;
        }
      }
      for(int i=0 ; i<array_odd.length ; i++){
        for(int j=i+1 ; j<array_odd.length ; j++){
          int ekub=gcd(array_odd[i],array_odd[j]);
          if(ekub>1){
            answear++;
          }
        }
      }
      System.out.println((int)answear);
    }
  }
  static int gcd(int a,int b){
    if(b==0)return a ;
    int i=a % b ;
    return gcd(b,i);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ekub {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     var answear : double ; answear := 0 ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
    var even : int ; even := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := sc.getCurrent()->toInteger() ; 
     if (array[i+1] mod 2 = 0) then (     even := even + 1 ) else skip )  ;     i := i + 1 ) ; 
    answear := ((even->oclAsType(double) / 2) * (even - 1)) + (even * (n - even)) ; 
    var array_odd : Sequence(int) ; array_odd := Integer.subrange(1,n - even)->collect(0) ;
    var temp : int ; temp := 0 ;
        var i : int ; i := 0 ; while i < array->size() do ( (     if (array[i+1] mod 2 > 0) then (     array_odd[temp+1] := array[i+1] ; 
     temp := temp + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < array_odd->size() do ( (         var j : int ; j := i + 1 ; while j < array_odd->size() do ( (     var ekub : int ; ekub := gcd(array_odd[i+1], array_odd[j+1]) ;
     if (ekub > 1) then (     answear := answear + 1 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answear->oclAsType(int)) ; 
 ) ;  ) );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (b = 0) then     return a else skip ; 
     var i : int ; i := a mod b ;
     return gcd(b, i) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class B1535 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextInt();
      }
      int count=0 ;
      int even=0,odd=0 ;
      for(int i=0 ; i<n ; i++){
        if(arr[i] % 2==0)even++;
        else odd++;
      }
      count+=(even*(even-1))/2 ;
      count+=even*odd ;
      for(int i=0 ; i<n-1 ; i++){
        for(int j=i+1 ; j<n ; j++){
          if(arr[i] % 2!=0 && arr[j] % 2!=0){
            if(findGCD(arr[i],2*arr[j])>1)count++;
          }
        }
      }
      System.out.println(count);
    }
    sc.close();
  }
  public static int findGCD(int a,int b){
    int gcd=0,temp ;
    while(b!=0){
      temp=b ;
      b=a % b ;
      a=temp ;
    }
    gcd=a ;
    return gcd ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B1535 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
    var even : int ; even := 0 ;
    var odd : int ; odd := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 = 0) then     even := even + 1 ; else     odd := odd + 1 ; )  ;     i := i + 1 ) ; 
    count := count+((even * (even - 1)) / 2) ; 
    count := count+(even * odd) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (arr[i+1] mod 2 /= 0 & arr[j+1] mod 2 /= 0) then (     if (findGCD(arr[i+1], 2 * arr[j+1]) > 1) then     count := count + 1 ; else skip ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) ;  ) ;  
     skip );
  static   operation findGCD( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var gcd : int ; gcd := 0 ;
    var temp : int ;
     while (b /= 0) do (     temp := b ; 
     b := a mod b ; 
     a := temp ) ; 
     gcd := a ; 
     return gcd );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws Exception {
    HashSet<String>strings=new HashSet<>();
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String[] startStrings=new String[3];
    for(int i=0 ; i<3 ; i++){
      startStrings[i]=in.readLine().toLowerCase().replaceAll("[^a-z] ","");
    }
    strings.add(startStrings[0]+startStrings[1]+startStrings[2]);
    strings.add(startStrings[0]+startStrings[2]+startStrings[1]);
    strings.add(startStrings[1]+startStrings[2]+startStrings[0]);
    strings.add(startStrings[1]+startStrings[0]+startStrings[2]);
    strings.add(startStrings[2]+startStrings[1]+startStrings[0]);
    strings.add(startStrings[2]+startStrings[0]+startStrings[1]);
    int numStudents=Integer.parseInt(in.readLine());
    for(int m=0 ; m<numStudents ; m++){
      String studentString=in.readLine().toLowerCase().replaceAll("[^a-z] ","");
      if(strings.contains(studentString)){
        System.out.println("ACC");
      }
      else {
        System.out.println("WA");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var strings : Set(String) ; strings := Set{} ;
     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
    var startStrings : Sequence(String) ; startStrings := Integer.subrange(1,3)->collect(null) ;
        var i : int ; i := 0 ; while i < 3 do ( (     startStrings[i+1] := in.readLine()->toLowerCase().replaceAllMatches("[^a-z] ", "" ) )  ;     i := i + 1 ) ; 
    strings := strings->including(startStrings[0+1] + startStrings[1+1] + startStrings[2+1]) ; 
    strings := strings->including(startStrings[0+1] + startStrings[2+1] + startStrings[1+1]) ; 
    strings := strings->including(startStrings[1+1] + startStrings[2+1] + startStrings[0+1]) ; 
    strings := strings->including(startStrings[1+1] + startStrings[0+1] + startStrings[2+1]) ; 
    strings := strings->including(startStrings[2+1] + startStrings[1+1] + startStrings[0+1]) ; 
    strings := strings->including(startStrings[2+1] + startStrings[0+1] + startStrings[1+1]) ; 
    var numStudents : int ; numStudents := (in.readLine())->toInteger() ;
        var m : int ; m := 0 ; while m < numStudents do ( (     var studentString : String ; studentString := in.readLine()->toLowerCase().replaceAllMatches("[^a-z] ", "" ) ;
     if (strings->includes(studentString)) then (     OclFile["System.out"].println("ACC") ) else (     OclFile["System.out"].println("WA") ) )  ;     m := m + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class class33 {
  static int gcd(int a,int b){
    int min=Math.min(a,b);
    int max=Math.max(a,b);
    while(true){
      int rem=max % min ;
      if(rem==0){
        break ;
      }
      max=min ;
      min=rem ;
    }
    return min ;
  }
  public static void main(String arg[]){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int sum=0 ;
      int a[]=new int[n];
      int i,j=0,y=n-1 ;
      for(i=0 ; i<n ; i++){
        int x=sc.nextInt();
        if(x % 2==0){
          sum+=y ;
          y--;
        }
        else {
          a[j++]=x ;
        }
      }
      int k ;
      for(i=0 ; i<j ; i++){
        for(k=i+1 ; k<j ; k++){
          if(gcd(a[i],a[k])>1)sum++;
        }
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class class33 {
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var min : int ; min := Set{a, b}->min() ;
     var max : int ; max := Set{a, b}->max() ;
     while (true) do (     var rem : int ; rem := max mod min ;
     if (rem = 0) then (     break ) else skip ; 
     max := min ; 
     min := rem ) ; 
     return min );
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var sum : int ; sum := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var i : int ;
    var j : int ; j := 0 ;
    var y : int ; y := n - 1 ;
        i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x mod 2 = 0) then (     sum := sum+(y) ; 
     y := y - 1 ) else (      a[j+1] := x  ; j := j + 1 ) )  ;     i := i + 1 ) ; 
    var k : int ;
        i := 0 ; while i < j do ( (         k := i + 1 ; while k < j do ( (     if (gcd(a[i+1], a[k+1]) > 1) then     sum := sum + 1 ; else skip )  ;     k := k + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long sumOfLastDig(long n,long m){
    long sum=0,k ;
    k=n/m ;
    long[] arr=new long[10];
    for(int i=0 ; i<10 ; i++){
      arr[i]=m*(i+1)% 10 ;
      sum+=arr[i];
    }
    long rem=k % 10 ;
    long ans=(k/10)*sum ;
    for(int i=0 ; i<rem ; i++){
      ans+=arr[i];
    }
    return ans ;
  }
  public static void main(String[] args){
    long n=100,m=3 ;
    System.out.println(sumOfLastDig(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation sumOfLastDig( n : long, m : long) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
    var k : long ;
     k := n / m ; 
    var arr : Sequence(long) ; arr := Integer.subrange(1,10)->collect(0) ;
        var i : int ; i := 0 ; while i < 10 do ( (     arr[i+1] := m * (i + 1) mod 10 ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    var rem : long ; rem := k mod 10 ;
    var ans : long ; ans := (k / 10) * sum ;
        var i : int ; i := 0 ; while i < rem do ( (     ans := ans+(arr[i+1]) )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 100 ;
    var m : long ; m := 3 ;
     OclFile["System.out"].println(sumOfLastDig(n, m)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class colorRevisited {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[] arr=new int[n];
      int max=0 ;
      int ans=0 ;
      for(int i=0 ; i<arr.length ; i++){
        arr[i]=sc.nextInt();
        if(arr[i]>max){
          max=arr[i];
          ans=i+1 ;
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class colorRevisited {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := 0 ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < arr->size() do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     if (arr[i+1] > max) then (     max := arr[i+1] ; 
     ans := i + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
import java.util.stream.Collectors ;
public class ProblemA {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int testCases=Integer.parseInt(scanner.nextLine());
    for(int i=0 ; i<testCases ; i++){
      int colors=Integer.parseInt(scanner.nextLine());
      List<Integer>colorCount=Arrays.stream(scanner.nextLine().split(" ")).map(Integer :: parseInt).collect(Collectors.toList());
      int maxValue=0 ;
      int maxNumber=-1 ;
      for(int j=0 ; j<colorCount.size(); j++){
        if(colorCount.get(j)>=maxValue){
          maxValue=colorCount.get(j);
          maxNumber=j+1 ;
        }
      }
      System.out.println(maxNumber);
    }
    scanner.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemA {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := (scanner.nextLine())->toInteger() ;
         var i : int ; i := 0 ; while i < testCases do ( (     var colors : int ; colors := (scanner.nextLine())->toInteger() ;
     var colorCount : Sequence(int) ; colorCount := stream(scanner.nextLine()->split(" "))->collect( _x1 | (lambda _s : String in _s->toInteger())->apply(_x1) ).collect(Collectors.toList()) ;
    var maxValue : int ; maxValue := 0 ;
    var maxNumber : int ; maxNumber := -1 ;
        var j : int ; j := 0 ; while j < colorCount->size() do ( (     if (colorCount->at(j+1) >= maxValue) then (     maxValue := colorCount->at(j+1) ; 
     maxNumber := j + 1 ) else skip )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(maxNumber) ; 
 )  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.util.TreeMap ;
public class A {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      int[][] a=new int[n][2];
      for(int i=0 ; i<n ; i++){
        a[i][0]=sc.nextInt();
        a[i][1]=i+1 ;
      }
      if(n==1){
        out.println(1);
        continue ;
      }
      Arrays.sort(a,(u,v)->u[0]-v[0]);
      out.println(a[n-1][1]);
    }
    out.close();
  }
  static class Scanner {
    StringTokenizer st ;
    BufferedReader br ;
    public Scanner(InputStream s){
      br=new BufferedReader(new InputStreamReader(s));
    }
    public String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    public boolean hasNext(){
      return st.hasMoreTokens();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
    public String nextLine()throws IOException {
      return br.readLine();
    }
    public boolean ready()throws IOException {
      return br.ready();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(Sequence(int)) ; a := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     a[i+1][1+1] := i + 1 )  ;     i := i + 1 ) ; 
    if (n = 1) then (     skip ; 
     continue ) else skip ; 
    a := OclComparator.sortWith(a, lambda (u , v) : OclAny in u[0+1] - v[0+1]) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
  static class Scanner {
   attribute st : OclIterator;
   attribute br : OclFile;
   static operation newScanner( s : OclFile) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(s);
    return self );
  operation initialise( s : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(s)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation hasNext() : boolean
  pre: true
  post: true
  activity: (     return st.hasNext() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation ready() : boolean
  pre: true
  post: true
  activity: (     return br.canRead() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      PriorityQueue<int[]>pq=new PriorityQueue<>((a,b)->b[0]-a[0]);
      for(int i=1 ; i<=n ; i++){
        int v=sc.nextInt();
        pq.add(new int[] {
          v,i }
);
        }
        while(pq.size()>1){
          int[] f=pq.poll();
          int[] s=pq.poll();
          pq.add(new int[] {
            f[0]-s[0],f[1] }
);
          }
          System.out.println(pq.peek()[1]);
        }
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var pq : Sequence(Sequence(int)) ; pq := Sequence{}->union(lambda (a , b) : OclAny in b[0+1] - a[0+1]) ;
        var i : int ; i := 1 ; while i <= n do ( (     var v : int ; v := sc.getCurrent()->toInteger() ;
     pq := pq->including(Sequence{v,i}) )  ;     i := i + 1 ) ; 
    while (pq->size() > 1) do (     var f : Sequence(int) ; f := pq->min() ;
     var s : Sequence(int) ; s := pq->min() ;
     pq := pq->including(Sequence{f[0+1] - s[0+1],f[1+1]}) ) ; 
    OclFile["System.out"].println(pq->min()[1+1]) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String p=sc.next();
    String text=s+s ;
    if(text.contains(p))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var p : String ; p := sc.getCurrent() ;
    var text : String ; text := s + s ;
    if (text->includes(p)) then     OclFile["System.out"].println("Yes") else     OclFile["System.out"].println("No") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    OutputStreamWriter osr=new OutputStreamWriter(System.out);
    PrintWriter out=new PrintWriter(osr);
    FastReader fr=new FastReader();
    int t=fr.nextInt();
    while(t--!=0){
      int n=fr.nextInt();
      int[] arr=new int[n];
      int max=0,max_i=0 ;
      for(int i=0 ; i<n ; i++){
        arr[i]=fr.nextInt();
        if(arr[i]>max){
          max=arr[i];
          max_i=i ;
        }
      }
      out.println(max_i+1);
    }
    out.close();
  }
}
class FastReader {
  BufferedReader br ;
  StringTokenizer st ;
  public FastReader(){
    InputStreamReader isr=new InputStreamReader(System.in);
    br=new BufferedReader(isr);
  }
  public String next()throws IOException {
    while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public String nextLine()throws IOException {
    return br.readLine();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(next());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(next());
  }
  public double nextDouble()throws IOException {
    return Double.parseDouble(next());
  }
  public int[] intArray(int size)throws IOException {
    int[] arr=new int[size];
    for(int i=0 ; i<size ; i++)arr[i]=nextInt();
    return arr ;
  }
  public char[] charArray()throws IOException {
    return nextLine().toCharArray();
  }
}
class Pair {
  int d ;
  int k ;
  public Pair(int d,int k){
    this.d=d ;
    this.k=k ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var osr : OclFile ; osr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(osr) ;
    var fr : FastReader ; fr := FastReader.newFastReader() ;
    var t : int ; t := fr.nextInt() ;
        while (t /= 0) do (    skip ; (     var n : int ; n := fr.nextInt() ;
     var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var max : int ; max := 0 ;
    var max_i : int ; max_i := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := fr.nextInt() ; 
     if (arr[i+1] > max) then (     max := arr[i+1] ; 
     max_i := i ) else skip )  ;     i := i + 1 ) ; 
    skip ; 
 ) ;  ) ;  
    skip ; 
 );
}
class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     br := OclFile.newOclFile_Read(isr) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation intArray( size : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < size do (     arr[i+1] := nextInt() ;  ;     i := i + 1 ) ; 
     return arr );
   operation charArray() : Sequence(String)
  pre: true
  post: true
  activity: (     return nextLine()->characters() );
}
class Pair {
   attribute d : int;
   attribute k : int;
   static operation newPair( d : int, k : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(d, k);
    return self );
  operation initialise( d : int, k : int) : void
  pre: true  post: true
  activity: (     self.d := d ; 
     self.k := k );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class B {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int zz=1 ; zz<=T ; zz++){
      int B=in.nextInt();
      long N=in.nextInt();
      long[] M=new long[B];
      for(int i=0 ; i<B ; i++)M[i]=in.nextInt();
      long start=0 ;
      long end=(long)1e16 ;
      while(start<end){
        long mid=(start+end)/2 ;
        long count=0 ;
        for(long t : M){
          count+=(mid/t)+1 ;
        }
        if(count>=N){
          end=mid ;
        }
        else {
          start=mid+1 ;
        }
      }
      long count=0 ;
      long exact=0 ;
      for(long t : M){
        count+=(start/t)+1 ;
        if(start % t==0)exact++;
      }
      long before=count-exact ;
      int ans=-1 ;
      for(int i=0 ; i<B ; i++){
        if(start % M[i]!=0)continue ;
        if(before+1==N){
          ans=i ;
          break ;
        }
        before++;
      }
      System.out.format("Case #%d: %d\n",zz,ans+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var zz : int ; zz := 1 ; while zz <= T do ( (     var B : int ; B := in.getCurrent()->toInteger() ;
     var N : long ; N := in.getCurrent()->toInteger() ;
    var M : Sequence(long) ; M := Integer.subrange(1,B)->collect(0) ;
        var i : int ; i := 0 ; while i < B do (     M[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var start : long ; start := 0 ;
    var end : long ; end := 1e16->oclAsType(long) ;
    while (start < end) do (     var mid : long ; mid := (start + end) / 2 ;
     var count : long ; count := 0 ;
     for (t : M) do ( (     count := count+((mid / t) + 1) )  ) ; 
     if (count >= N) then (     end := mid ) else (     start := mid + 1 ) ) ; 
    var count : long ; count := 0 ;
    var exact : long ; exact := 0 ;
    for (t : M) do ( (     count := count+((start / t) + 1) ; 
     if (start mod t = 0) then     exact := exact + 1 ; else skip )  ) ; 
    var before : long ; before := count - exact ;
    var ans : int ; ans := -1 ;
        var i : int ; i := 0 ; while i < B do ( (     if (start mod M[i+1] /= 0) then     continue else skip ; 
     if (before + 1 = N) then (     ans := i ; 
     break ) else skip ; 
     before := before + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].format("Case #%d: %d\n", zz, ans + 1) ; 
 )  ;     zz := zz + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round1a ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int cases=sc.nextInt();
    for(int caze=1 ; caze<=cases ; caze++){
      int N=sc.nextInt();
      int L=sc.nextInt();
      Set<Long>need=new HashSet<Long>(),have=new HashSet<Long>();
      for(int i=0 ; i<N ; i++){
        String tmp=sc.next();
        long tmp2=0 ;
        for(int j=0 ; j<L ; j++)if(tmp.charAt(j)=='1')tmp2 |=(1L<<j);
        have.add(tmp2);
      }
      long lastNeeded=0 ;
      for(int i=0 ; i<N ; i++){
        String tmp=sc.next();
        long tmp2=0 ;
        for(int j=0 ; j<L ; j++)if(tmp.charAt(j)=='1')tmp2 |=(1L<<j);
        need.add(tmp2);
        lastNeeded=tmp2 ;
      }
      int ans=L+1 ;
      for(Long elem : have){
        long flip=lastNeeded ^ elem ;
        Set<Long>got=new HashSet<Long>();
        for(Long e : need){
          got.add(e ^ flip);
        }
        if(got.equals(have)){
          ans=Math.min(ans,Long.bitCount(flip));
        }
      }
      System.out.println("Case #"+caze+": "+(ans>L ? "NOT POSSIBLE" : ans));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cases : int ; cases := sc.getCurrent()->toInteger() ;
         var caze : int ; caze := 1 ; while caze <= cases do ( (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var L : int ; L := sc.getCurrent()->toInteger() ;
    var need : Set(long) ; need := Set{} ;
    var have : Set(long) ; have := Set{} ;
        var i : int ; i := 0 ; while i < N do ( (     var tmp : String ; tmp := sc.getCurrent() ;
     var tmp2 : long ; tmp2 := 0 ;
         var j : int ; j := 0 ; while j < L do (     if (tmp->at(j+1) = '1') then     tmp2 := MathLib.bitwiseOr(tmp2, ((1L*(2->pow(j)))->oclAsType(long))) ; else skip ;  ;     j := j + 1 ) ; 
     have->excludes(tmp2) )  ;     i := i + 1 ) ; 
    var lastNeeded : long ; lastNeeded := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var tmp : String ; tmp := sc.getCurrent() ;
     var tmp2 : long ; tmp2 := 0 ;
        var j : int ; j := 0 ; while j < L do (     if (tmp->at(j+1) = '1') then     tmp2 := MathLib.bitwiseOr(tmp2, ((1L*(2->pow(j)))->oclAsType(long))) ; else skip ;  ;     j := j + 1 ) ; 
    need := need->including(tmp2) ; 
    lastNeeded := tmp2 ; 
 )  ;     i := i + 1 ) ; 
    var ans : int ; ans := L + 1 ;
    for (elem : have) do ( (     var flip : long ; flip := MathLib.bitwiseXor(lastNeeded,elem) ;
     var got : Set(long) ; got := Set{} ;
     for (e : need) do ( (     got := got->including(e xor flip) )  ) ; 
     if (got = have) then (     ans := Set{ans, bitCount(flip)}->min() ) else skip )  ) ; 
    OclFile["System.out"].println("Case #" + caze + ": " + (if ans > L then "NOT POSSIBLE" else ans endif)) ; 
 )  ;     caze := caze + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package gcj2015.r1 ;
import java.io.*;
import java.util.Scanner ;
public class Haircut {
  static PrintWriter out ;
  public static void main(String[] args)throws IOException {
    String name="gcj2015/r1/B-large" ;
    Scanner s=new Scanner(new File(name+".in"));
    int count=s.nextInt();
    out=new PrintWriter(new BufferedWriter(new FileWriter(name+".out")));
    for(int cc=1 ; cc<=count ; cc++){
      out.print("Case #"+cc+": ");
      int b=s.nextInt();
      int n=s.nextInt();
      int[] m=new int[b];
      for(int i=0 ; i<b ; i++){
        m[i]=s.nextInt();
      }
      int res=solve(b,n,m);
      out.print(res);
      out.println();
    }
    out.close();
  }
  static int solve(int b,int n,int[] m){
    long l=0 ;
    long r=100000l*n+1 ;
    long mid ;
    while(true){
      mid=(l+r)/2 ;
      long num=num(b,m,mid);
      if(num<n){
        l=mid ;
      }
      else {
        r=mid ;
      }
      if(r-mid==1)break ;
    }
    int rem=n-(int)num(b,m,mid);
    for(int i=0 ; i<b ; i++){
      if(mid % m[i]==0){
        rem--;
      }
      if(rem==0)return i+1 ;
    }
    return-1 ;
  }
  static long num(int b,int[] m,long t){
    long res=0 ;
    for(int mm : m){
      res+=(t+mm-1)/mm ;
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Haircut {
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var name : String ; name := "gcj2015/r1/B-large" ;
     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile(name + ".in")) ;
    var count : int ; count := s.getCurrent()->toInteger() ;
    out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(name + ".out"))) ; 
        var cc : int ; cc := 1 ; while cc <= count do ( (     skip ; 
     var b : int ; b := s.getCurrent()->toInteger() ;
    var n : int ; n := s.getCurrent()->toInteger() ;
    var m : Sequence(int) ; m := Integer.subrange(1,b)->collect(0) ;
        var i : int ; i := 0 ; while i < b do ( (     m[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var res : int ; res := solve(b, n, m) ;
    skip ; 
    skip ; 
 )  ;     cc := cc + 1 ) ; 
    skip ; 
 );
  static   operation solve( b : int, n : int, m : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var l : long ; l := 0 ;
     var r : long ; r := 100000l * n + 1 ;
    var mid : long ;
    while (true) do (     mid := (l + r) / 2 ; 
     var num : long ; num := num(b, m, mid) ;
     if (num < n) then (     l := mid ) else (     r := mid ) ;  
     if (r - mid = 1) then     break else skip ) ; 
    var rem : int ; rem := n - num(b, m, mid)->oclAsType(int) ;
        var i : int ; i := 0 ; while i < b do ( (     if (mid mod m[i+1] = 0) then (     rem := rem - 1 ) else skip ; 
     if (rem = 0) then     return i + 1 else skip )  ;     i := i + 1 ) ; 
    return -1 
 );
  static   operation num( b : int, m : Sequence(int), t : long) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 0 ;
     for (mm : m) do ( (     res := res+((t + mm - 1) / mm) )  ) ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Haircut {
    final static String PROBLEM_NAME = "haircut";
    final static String WORK_DIR = "D:\\GCJ\\" + PROBLEM_NAME + "\\";
    void solve(Scanner sc, PrintWriter pw) {
        int B = sc.nextInt();
        long N = sc.nextLong();
        int[] T = new int[B];
        for (int i = 0; i < B; i++) {
            T[i] = sc.nextInt();
        }
        long L = 0, R = 1000000000000000L;
        while (R - L > 1) {
            long mid = (L + R) / 2;
            long servedBefore = 0;
            for (int i = 0; i < B; i++) {
                servedBefore += (mid - 1) / T[i] + 1;
            }
            if (servedBefore < N) {
                L = mid;
            } else {
                R = mid;
            }
        }
        long when = L;
        for (int i = 0; i < B; i++) {
            N -= (when - 1) / T[i] + 1;
        }
        for (int i = 0; i < B; i++) {
            if (when % T[i] == 0) {
                N--;
                if (N == 0) {
                    pw.println(i + 1);
                    return;
                }
            }
        }
    }
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(new FileReader(WORK_DIR + "input.txt"));
        PrintWriter pw = new PrintWriter(new FileWriter(WORK_DIR + "output.txt"));
        int caseCnt = sc.nextInt();
        for (int caseNum = 0; caseNum < caseCnt; caseNum++) {
            System.out.println("Processing test case " + (caseNum + 1));
            pw.print("Case #" + (caseNum + 1) + ": ");
            new Haircut().solve(sc, pw);
        }
        pw.flush();
        pw.close();
        sc.close();
    }
}

------------------------------------------------------------
OCL File:
---------
 class Haircut {
  static   attribute PROBLEM_NAME : String := "haircut";
  static   attribute WORK_DIR : String := "D:\\GCJ\\" + PROBLEM_NAME + "\\";
   operation solve( sc : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var B : int ; B := sc.nextInt() ;
     var N : long ; N := sc.nextLong() ;
    var T : Sequence(int) ; T := Integer.subrange(1,B)->collect(0) ;
        var i : int ; i := 0 ; while i < B do ( (     T[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    var L : long ; L := 0 ;
    var R : long ; R := 1000000000000000L ;
    while (R - L > 1) do (     var mid : long ; mid := (L + R) / 2 ;
     var servedBefore : long ; servedBefore := 0 ;
         var i : int ; i := 0 ; while i < B do ( (     servedBefore := servedBefore+((mid - 1) / T[i+1] + 1) )  ;     i := i + 1 ) ; 
     if (servedBefore < N) then (     L := mid ) else (     R := mid ) ) ; 
    var when : long ; when := L ;
        var i : int ; i := 0 ; while i < B do ( (     N := N-((when - 1) / T[i+1] + 1) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < B do ( (     if (when mod T[i+1] = 0) then (     N := N - 1 ; 
     if (N = 0) then (     pw.println(i + 1) ; 
     return ) else skip ) else skip )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(WORK_DIR + "input.txt")) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(WORK_DIR + "output.txt")) ;
    var caseCnt : int ; caseCnt := sc.getCurrent()->toInteger() ;
        var caseNum : int ; caseNum := 0 ; while caseNum < caseCnt do ( (     OclFile["System.out"].println("Processing test case " + (caseNum + 1)) ; 
     skip ; 
     Haircut.newHaircut().solve(sc, pw) )  ;     caseNum := caseNum + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B {
  static int B ;
  static long N ;
  static long[] M ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int numCases=sc.nextInt();
    for(int caseNum=1 ; caseNum<=numCases ; caseNum++){
      B=sc.nextInt();
      N=sc.nextLong();
      M=new long[B+1];
      for(int i=1 ; i<=B ; i++){
        M[i]=sc.nextLong();
      }
      System.out.println("Case #"+caseNum+": "+solve());
    }
  }
  static long solve(){
    if(N<=B){
      return N ;
    }
    long time=getHaircutTime();
    long customers=numCustomers(time);
    for(int i=B ; i>0 ; i--){
      if(time % M[i]==0){
        if(customers==N){
          return i ;
        }
        customers--;
      }
    }
    throw new IllegalStateException();
  }
  static long getHaircutTime(){
    long min=0 ;
    long max=100_000_000_000_000L ;
    while(min<max){
      long mid=(min+max)/2 ;
      long customers=numCustomers(mid);
      if(customers<N){
        min=mid+1 ;
      }
      else {
        max=mid ;
      }
    }
    return min ;
  }
  private static long numCustomers(long time){
    long customers=0 ;
    for(int i=1 ; i<=B ; i++){
      customers+=1+(time/M[i]);
    }
    return customers ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute B : int;
  static   attribute N : long;
  static   attribute M : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var numCases : int ; numCases := sc.getCurrent()->toInteger() ;
         var caseNum : int ; caseNum := 1 ; while caseNum <= numCases do ( (     B := sc.getCurrent()->toInteger() ; 
     N := sc.getCurrent()->toLong() ; 
    M := Integer.subrange(1,B + 1)->collect(0) ; 
        var i : int ; i := 1 ; while i <= B do ( (     M[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("Case #" + caseNum + ": " + solve()) ; 
 )  ;     caseNum := caseNum + 1 ) );
  static   operation solve() : long
  pre: true
  post: true
  activity: (     if (N <= B) then (     return N ) else skip ; 
     var time : long ; time := getHaircutTime() ;
    var customers : long ; customers := numCustomers(time) ;
        var i : int ; i := B ; while i > 0 do ( (     if (time mod M[i+1] = 0) then (     if (customers = N) then (     return i ) else skip ; 
     customers := customers - 1 ) else skip )  ;     i := i - 1 ) ; 
    error IncorrectElementException() ; 
 );
  static   operation getHaircutTime() : long
  pre: true
  post: true
  activity: (     var min : long ; min := 0 ;
     var max : long ; max := 100_000_000_000_000L ;
     while (min < max) do (     var mid : long ; mid := (min + max) / 2 ;
     var customers : long ; customers := numCustomers(mid) ;
     if (customers < N) then (     min := mid + 1 ) else (     max := mid ) ) ; 
     return min );
  static   operation numCustomers( time : long) : long
  pre: true
  post: true
  activity: (     var customers : long ; customers := 0 ;
         var i : int ; i := 1 ; while i <= B do ( (     customers := customers+(1 + (time / M[i+1])) )  ;     i := i + 1 ) ; 
     return customers );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package round1a ;
import java.util.Scanner ;
public class B {
  private static long[] times ;
  private static long B,N ;
  private static long started(long t){
    long ret=0 ;
    for(int i=0 ; i<times.length ; i++){
      ret+=1+t/times[i];
    }
    return ret ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int cases=sc.nextInt();
    for(int caze=1 ; caze<=cases ; caze++){
      B=sc.nextInt();
      N=sc.nextInt();
      times=new long[(int)B];
      for(int i=0 ; i<times.length ; i++){
        times[i]=sc.nextInt();
      }
      long ret=-1 ;
      if(B>=N){
        ret=N ;
      }
      if(ret==-1){
        long left=0,right=N*1000000 ;
        while(left+1<right){
          long med=(left+right)/2 ;
          if(started(med)<N){
            left=med ;
          }
          else {
            right=med ;
          }
        }
        long dif=N-started(left);
        for(int i=0 ; i<times.length ; i++){
          if(right % times[i]==0)dif--;
          if(dif==0){
            ret=i+1 ;
            break ;
          }
        }
      }
      System.out.println("Case #"+caze+": "+ret);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute times : Sequence(long);
  static   attribute B : long;
  static   operation started( t : long) : long
  pre: true
  post: true
  activity: (     var ret : long ; ret := 0 ;
         var i : int ; i := 0 ; while i < times->size() do ( (     ret := ret+(1 + t / times[i+1]) )  ;     i := i + 1 ) ; 
     return ret );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var cases : int ; cases := sc.getCurrent()->toInteger() ;
         var caze : int ; caze := 1 ; while caze <= cases do ( (     B := sc.getCurrent()->toInteger() ; 
     N := sc.getCurrent()->toInteger() ; 
    times := Integer.subrange(1,B->oclAsType(int))->collect(0) ; 
        var i : int ; i := 0 ; while i < times->size() do ( (     times[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ret : long ; ret := -1 ;
    if (B >= N) then (     ret := N ) else skip ; 
    if (ret = -1) then (     var left : long ; left := 0 ;
    var right : long ; right := N * 1000000 ;
     while (left + 1 < right) do (     var med : long ; med := (left + right) / 2 ;
     if (started(med) < N) then (     left := med ) else (     right := med ) ) ; 
     var dif : long ; dif := N - started(left) ;
         var i : int ; i := 0 ; while i < times->size() do ( (     if (right mod times[i+1] = 0) then     dif := dif - 1 ; else skip ; 
     if (dif = 0) then (     ret := i + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ) else skip ; 
    OclFile["System.out"].println("Case #" + caze + ": " + ret) ; 
 )  ;     caze := caze + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[100001];
    int d=0 ;
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      if(0<a[x])d++;
      a[x]++;
    }
    System.out.println(n-d-(d % 2));
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,100001)->collect(0) ;
    var d : int ; d := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (0 < a[x+1]) then     d := d + 1 ; else skip ; 
     a[x+1] := a[x+1] + 1 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n - d - (d mod 2)) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    st=new StringTokenizer(br.readLine());
    int array[]=new int[100000+100];
    int cnt=0 ;
    for(int i=1 ; i<=n ; i++){
      int a=Integer.parseInt(st.nextToken());
      array[a]++;
    }
    for(int i=1 ; i<array.length ; i++){
      if(array[i]==0)continue ;
      cnt+=array[i]-1 ;
    }
    int left=n-cnt ;
    if(cnt % 2==1)--left ;
    System.out.println(left);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
    var array : Sequence(int) ; array := Integer.subrange(1,100000 + 100)->collect(0) ;
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 1 ; while i <= n do ( (     var a : int ; a := (st.next())->toInteger() ;
     array[a+1] := array[a+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < array->size() do ( (     if (array[i+1] = 0) then     continue else skip ; 
     cnt := cnt+(array[i+1] - 1) )  ;     i := i + 1 ) ; 
    var left : int ; left := n - cnt ;
    if (cnt mod 2 = 1) then     left := left - 1 ; else skip ; 
    OclFile["System.out"].println(left) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.function.Function.*;
import static java.util.stream.Collectors.*;
import java.util.*;
public class Main {
  public void main(Scanner sc){
    int n=sc.nextInt();
    Integer a[]=new Integer[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextInt();
    }
    long cnt=0 ;
    for(long count : Arrays.stream(a).collect(groupingBy(identity(),counting())).values()){
      cnt+=(count-1);
    }
    cnt+=(cnt % 2);
    System.out.println(n-cnt);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    new Main().main(sc);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    var cnt : long ; cnt := 0 ;
    for (count : stream(a).collect(groupingBy(identity(), counting())).allInstances()) do ( (     cnt := cnt+((count - 1)) )  ) ; 
    cnt := cnt+((cnt mod 2)) ; 
    OclFile["System.out"].println(n - cnt) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Main.newMain().main(sc) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static double[][] nums ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    nums=new double[n][2];
    nums[0][0]=sc.nextDouble();
    nums[0][1]=(10.0-sc.nextDouble())/10.0 ;
    for(int i=1 ; i<n ; i++){
      nums[i][0]=sc.nextInt();
      nums[i][1]=nums[i-1][1]*(10-sc.nextInt())/10.0 ;
    }
    int q=sc.nextInt();
    int li ;
    int ri ;
    for(int i=0 ; i<q ; i++){
      li=sc.nextInt();
      ri=sc.nextInt();
      System.out.println((double)((nibu(ri)==-1 ? 1 : nums[nibu(ri)][1])/(nibu(li)==-1 ? 1 : nums[nibu(li)][1])*1000000000));
    }
  }
  static int nibu(int q){
    int ans=nums.length/2 ;
    int toadd=nums.length/2 ;
    while(true){
      if(nums[ans][0]<q){
        ans+=Math.max(1,toadd/=2);
      }
      else {
        ans-=Math.max(1,toadd/=2);
      }
      if(ans<0 || ans>=nums.length-1 ||(nums[ans][0]<q && nums[ans+1][0]>q))break ;
    }
    return ans ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute nums : Sequence(Sequence(double));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    nums := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0.0)) ; 
    nums[0+1][0+1] := sc.getCurrent()->toReal() ; 
    nums[0+1][1+1] := (10.0 - sc.getCurrent()->toReal()) / 10.0 ; 
        var i : int ; i := 1 ; while i < n do ( (     nums[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     nums[i+1][1+1] := nums[i - 1+1][1+1] * (10 - sc.getCurrent()->toInteger()) / 10.0 )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var li : int ;
    var ri : int ;
        var i : int ; i := 0 ; while i < q do ( (     li := sc.getCurrent()->toInteger() ; 
     ri := sc.getCurrent()->toInteger() ; 
     OclFile["System.out"].println(((if nibu(ri) = -1 then 1 else nums[nibu(ri)+1][1+1] endif) / (if nibu(li) = -1 then 1 else nums[nibu(li)+1][1+1] endif) * 1000000000)->oclAsType(double)) )  ;     i := i + 1 ) ; 
 );
  static   operation nibu( q : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := nums->size() / 2 ;
     var toadd : int ; toadd := nums->size() / 2 ;
     while (true) do (     if (nums[ans+1][0+1] < q) then (     ans := ans+(Set{1, toadd}->max()) ) else (     ans := ans-(Set{1, toadd}->max()) ) ;  
     if (ans < 0 or ans >= nums->size() - 1 or (nums[ans+1][0+1] < q & nums[ans + 1+1][0+1] > q)) then     break else skip ) ; 
     return ans );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
class Main {
  public static void main(String[] areg){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int count=0 ;
    HashSet<Integer>set=new HashSet<Integer>();
    for(int i=0 ; i<N ; i++){
      int j=sc.nextInt();
      if(set.contains(j))count++;
      else set.add(j);
    }
    sc.close();
    System.out.println(set.size()-(count % 2==0 ? 0 : 1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( areg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var count : int ; count := 0 ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < N do ( (     var j : int ; j := sc.getCurrent()->toInteger() ;
     if (set->includes(j)) then     count := count + 1 ; else     set := set->including(j) ; )  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(set->size() - (if count mod 2 = 0 then 0 else 1 endif)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeSet ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    Set<Integer>set=new TreeSet<>();
    for(int i=0 ; i<n ; i++){
      set.add(scanner.nextInt());
    }
    int ret=set.size();
    if(ret % 2==0)ret--;
    System.out.println(ret);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     set := set->including(scanner.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var ret : int ; ret := set->size() ;
    if (ret mod 2 = 0) then     ret := ret - 1 ; else skip ; 
    OclFile["System.out"].println(ret) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.util.Arrays.deepToString ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  void tr(Object...os){
    System.err.println(deepToString(os));
  }
  Scanner sc=new Scanner(System.in);
  public void run(){
    for(; sc.hasNext(); ){
      int n=sc.nextInt();
      if(n==0)break ;
      int[] a=new int[n];
      int[] b=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
        b[i]=sc.nextInt();
      }
      int m=1000 ;
      long[][] dp=new long[n+1][m+1];
      dp[0][0]=1 ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<=m ; j++){
          long val=0 ;
          val+=dp[i][j];
          if(j-a[i]>=0)val+=dp[i+1][j-a[i] ];
          if(j-(1+b[i])*a[i]>=0)val-=dp[i][j-(1+b[i])*a[i] ];
          dp[i+1][j]=val ;
        }
      }
      int g=sc.nextInt();
      for(int iii=0 ; iii<g ; iii++){
        int mi=sc.nextInt();
        System.out.println(dp[n][mi]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation tr( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while sc.hasNext() do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     b[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := 1000 ;
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m + 1)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j <= m do ( (     var val : long ; val := 0 ;
     val := val+(dp[i+1][j+1]) ; 
    if (j - a[i+1] >= 0) then     val := val+(dp[i + 1+1][j - a[i+1]+1]) ; else skip ; 
    if (j - (1 + b[i+1]) * a[i+1] >= 0) then     val := val-(dp[i+1][j - (1 + b[i+1]) * a[i+1]+1]) ; else skip ; 
    dp[i + 1+1][j+1] := val ; 
 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var g : int ; g := sc.getCurrent()->toInteger() ;
        var iii : int ; iii := 0 ; while iii < g do ( (     var mi : int ; mi := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(dp[n+1][mi+1]) )  ;     iii := iii + 1 ) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.Scanner ;
public class ChargingChaos {
  public static void main(String[] Args)throws FileNotFoundException {
    Scanner sc=new Scanner(new File("A-large(1).in"));
    PrintWriter out=new PrintWriter(new File("things.out"));
    int t=sc.nextInt(),cc=0 ;
    while(t-->0){
      int n=sc.nextInt();
      int l=sc.nextInt();
      long[] things=new long[n];
      long[] things2=new long[n];
      HashSet<Long>hs=new HashSet<Long>();
      for(int k=0 ; k<n ; k++)things[k]=make(sc.next());
      for(int k=0 ; k<n ; k++){
        things2[k]=make(sc.next());
        hs.add(things2[k]);
      }
      int ans=l+1 ;
      for(int k=0 ; k<n ; k++){
        long swit=things[0] ^ things2[k];
        boolean good=true ;
        for(int j=0 ; good && j<n ; j++)if(! hs.contains(things[j] ^ swit))good=false ;
        if(good)ans=Math.min(Long.bitCount(swit),ans);
      }
      if(ans!=l+1)out.printf("Case #%d: %d%n",++cc,ans);
      else out.printf("Case #%d: NOT POSSIBLE%n",++cc);
    }
    out.close();
  }
  private static long make(String s){
    return Long.parseLong(s,2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class ChargingChaos {
  static   operation main( Args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile("A-large(1).in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("things.out")) ;
    var t : int ; t := sc.getCurrent()->toInteger() ;
    var cc : int ; cc := 0 ;
        while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var things : Sequence(long) ; things := Integer.subrange(1,n)->collect(0) ;
    var things2 : Sequence(long) ; things2 := Integer.subrange(1,n)->collect(0) ;
    var hs : Set(long) ; hs := Set{} ;
        var k : int ; k := 0 ; while k < n do (     things[k+1] := make(sc.getCurrent()) ;  ;     k := k + 1 ) ; 
        var k : int ; k := 0 ; while k < n do ( (     things2[k+1] := make(sc.getCurrent()) ; 
     hs := hs->including(things2[k+1]) )  ;     k := k + 1 ) ; 
    var ans : int ; ans := l + 1 ;
        var k : int ; k := 0 ; while k < n do ( (     var swit : long ; swit := MathLib.bitwiseXor(things[0+1],things2[k+1]) ;
     var good : boolean ; good := true ;
         var j : int ; j := 0 ; while good & j < n do (     if (not(hs->includes(things[j+1] xor swit))) then     good := false ; else skip ;  ;     j := j + 1 ) ; 
     if (good) then     ans := Set{bitCount(swit), ans}->min() ; else skip )  ;     k := k + 1 ) ; 
    if (ans /= l + 1) then     skip else     skip ; ;  
 ) ;  ) ;  
    skip ; 
 );
  static   operation make( s : String) : long
  pre: true
  post: true
  activity: (     return (s)->toLong() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static class Node {
    int data ;
    Node left,right ;
    Node(int val){
      data=val ;
      left=null ;
      right=null ;
    }
  };
  static void spiralOrder(Node root){
    Deque<Node>d=new LinkedList<Node>();
    d.addLast(root);
    int dir=0 ;
    while(d.size()>0){
      int size=d.size();
      while(size-->0){
        if(dir==0){
          Node temp=d.peekLast();
          d.pollLast();
          if(temp.right!=null)d.addFirst(temp.right);
          if(temp.left!=null)d.addFirst(temp.left);
          System.out.print(temp.data+" ");
        }
        else {
          Node temp=d.peekFirst();
          d.pollFirst();
          if(temp.left!=null)d.addLast(temp.left);
          if(temp.right!=null)d.addLast(temp.right);
          System.out.print(temp.data+" ");
        }
      }
      System.out.println();
      dir=1-dir ;
    }
  }
  public static void main(String args[]){
    Node root=new Node(10);
    root.left=new Node(20);
    root.right=new Node(30);
    root.left.left=new Node(40);
    root.left.right=new Node(60);
    spiralOrder(root);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Node {
   attribute data : int;
   attribute left : Node;
   static operation newNode( val : int) : Node
  pre: true
  post: true
  activity:
  ( var self : Node ;
    self := createNode();
    self.initialise(val);
    return self );
  operation initialise( val : int) : void
  pre: true  post: true
  activity: (     data := val ; 
     left := null ; 
     right := null );
}
  static   operation spiralOrder( root : Node) : void
  pre: true
  post: true
  activity: (     var d : Sequence(Node) ; d := Sequence{} ;
     d := d->append(root) ; 
     var dir : int ; dir := 0 ;
     while (d->size() > 0) do (     var size : int ; size := d->size() ;
         while (size > 0) do (        size := size - 1 ;     skip ; (     if (dir = 0) then (     var temp : Node ; temp := d.peekLast() ;
     d := d->front() ; 
    if (temp.right /= null) then     d := d->prepend(temp.right) ; else skip ; 
    if (temp.left /= null) then     d := d->prepend(temp.left) ; else skip ; 
    OclFile["System.out"].print(temp.data + " ") ; 
 ) else (     var temp : Node ; temp := d.peekFirst() ;
     d := d->tail() ; 
    if (temp.left /= null) then     d := d->append(temp.left) ; else skip ; 
    if (temp.right /= null) then     d := d->append(temp.right) ; else skip ; 
    OclFile["System.out"].print(temp.data + " ") ; 
 ) ) ;  ) ;  
     OclFile["System.out"].println() ; 
     dir := 1 - dir ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var root : Node ; root := Node.newNode(10) ;
     root.left := Node.newNode(20) ; 
    root.right := Node.newNode(30) ; 
    root.left.left := Node.newNode(40) ; 
    root.left.right := Node.newNode(60) ; 
    execute spiralOrder(root) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int[] parent ;
  static int[] weights ;
  static void set(int x){
    parent[x]=x ;
    weights[x]=1 ;
  }
  static void union(int x,int y){
    int a=find(x);
    int b=find(y);
    if(a!=b){
      if(weights[a]>weights[b]){
        parent[b]=a ;
        weights[a]+=weights[b];
      }
      else {
        parent[a]=b ;
        weights[b]+=weights[a];
      }
    }
  }
  static int find(int x){
    int curr=x ;
    if(parent[curr]==curr)return curr ;
    parent[curr]=find(parent[curr]);
    return parent[curr];
  }
  static boolean checkConnection(int x,int y){
    return find(x)==find(y);
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int users=in.nextInt();
    parent=new int[users];
    weights=new int[users];
    int relations=in.nextInt();
    parent=new int[users];
    for(int i=0 ; i<users ; i++){
      set(i);
    }
    for(int i=0 ; i<relations ; i++){
      union(in.nextInt(),in.nextInt());
    }
    int queries=in.nextInt();
    for(int i=0 ; i<queries ; i++){
      int a=in.nextInt();
      int b=in.nextInt();
      if(checkConnection(a,b)){
        System.out.println("yes");
      }
      else {
        System.out.println("no");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute parent : Sequence(int);
  static   attribute weights : Sequence(int);
  static   operation set( x : int) : void
  pre: true
  post: true
  activity: (     parent[x+1] := x ; 
     weights[x+1] := 1 );
  static   operation union( x : int, y : int) : void
  pre: true
  post: true
  activity: (     var a : int ; a := find(x) ;
     var b : int ; b := find(y) ;
     if (a /= b) then (     if (weights[a+1] > weights[b+1]) then (     parent[b+1] := a ; 
     weights[a+1] := weights[a+1]+(weights[b+1]) ) else (     parent[a+1] := b ; 
     weights[b+1] := weights[b+1]+(weights[a+1]) ) ) else skip );
  static   operation find( x : int) : int
  pre: true
  post: true
  activity: (     var curr : int ; curr := x ;
     if (parent[curr+1] = curr) then     return curr else skip ; 
     parent[curr+1] := find(parent[curr+1]) ; 
     return parent[curr+1] );
  static   operation checkConnection( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return find(x) = find(y) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var users : int ; users := in.getCurrent()->toInteger() ;
    parent := Integer.subrange(1,users)->collect(0) ; 
    weights := Integer.subrange(1,users)->collect(0) ; 
    var relations : int ; relations := in.getCurrent()->toInteger() ;
    parent := Integer.subrange(1,users)->collect(0) ; 
        var i : int ; i := 0 ; while i < users do ( (     execute set(i) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < relations do ( (     execute union(in.getCurrent()->toInteger(), in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var queries : int ; queries := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < queries do ( (     var a : int ; a := in.getCurrent()->toInteger() ;
     var b : int ; b := in.getCurrent()->toInteger() ;
     if (checkConnection(a, b)) then (     OclFile["System.out"].println("yes") ) else (     OclFile["System.out"].println("no") ) )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class UnionFind {
  private int n ;
  private int par[]=new int[114514];
  public UnionFind(int _n){
    n=_n ;
    for(int i=0 ; i<n ; i++){
      par[i]=i ;
    }
  }
  public int find(int x){
    if(x==par[x])return x ;
    return par[x]=find(par[x]);
  }
  public boolean same(int x,int y){
    return(find(x)==find(y));
  }
  public void unite(int x,int y){
    if(same(x,y))return ;
    par[find(x)]=y ;
  }
}
public class Main implements Runnable {
  public static void main(String[] args){
    new Thread(null,new Main(),"",16*1024*1024).start();
  }
  public void run(){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    UnionFind uf=new UnionFind(n+100);
    for(int i=0 ; i<m ; i++){
      int u=scan.nextInt();
      int v=scan.nextInt();
      uf.unite(u,v);
    }
    int q=scan.nextInt();
    for(int i=0 ; i<q ; i++){
      int u=scan.nextInt();
      int v=scan.nextInt();
      if(uf.same(u,v)){
        System.out.println("yes");
      }
      else {
        System.out.println("no");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class UnionFind {
   attribute n : int;
   attribute par : int := Integer.subrange(1,114514)->collect(0);
   static operation newUnionFind( _n : int) : UnionFind
  pre: true
  post: true
  activity:
  ( var self : UnionFind ;
    self := createUnionFind();
    self.initialise(_n);
    return self );
  operation initialise( _n : int) : void
  pre: true  post: true
  activity: (     n := _n ; 
         var i : int ; i := 0 ; while i < n do ( (     par[i+1] := i )  ;     i := i + 1 ) );
   operation find( x : int) : int
  pre: true
  post: true
  activity: (     if (x = par[x+1]) then     return x else skip ; 
     return par[x+1] );
   operation same( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return (find(x) = find(y)) );
   operation unite( x : int, y : int) : void
  pre: true
  post: true
  activity: (     if (same(x, y)) then     return else skip ; 
     par[find(x)+1] := y );
}
class Main implements Runnable {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclProcess.newOclProcess(null, Main.newMain(), "", 16 * 1024 * 1024).start() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var uf : UnionFind ; uf := UnionFind.newUnionFind(n + 100) ;
        var i : int ; i := 0 ; while i < m do ( (     var u : int ; u := scan.getCurrent()->toInteger() ;
     var v : int ; v := scan.getCurrent()->toInteger() ;
     uf.unite(u, v) )  ;     i := i + 1 ) ; 
    var q : int ; q := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var u : int ; u := scan.getCurrent()->toInteger() ;
     var v : int ; v := scan.getCurrent()->toInteger() ;
     if (uf.same(u, v)) then (     OclFile["System.out"].println("yes") ) else (     OclFile["System.out"].println("no") ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int[] par,rank ;
  static void init(int N){
    for(int i=0 ; i<N ; i++){
      rank[i]=0 ;
      par[i]=i ;
    }
  }
  static int root(int x){
    if(par[x]==x){
      return x ;
    }
    return par[x]=root(par[x]);
  }
  static boolean same(int x,int y){
    return(root(x)==root(y));
  }
  static void unite(int x,int y){
    x=root(x);
    y=root(y);
    if(x==y)return ;
    if(rank[x]<rank[y]){
      par[x]=y ;
    }
    else {
      par[y]=x ;
      if(rank[x]==rank[y])rank[x]++;
    }
  }
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int n=sc.nextInt();
      int m=sc.nextInt();
      rank=new int[n+1];
      par=new int[n+1];
      init(n);
      for(int i=0 ; i<m ; i++){
        int a=sc.nextInt();
        int b=sc.nextInt();
        unite(a,b);
      }
      int q=sc.nextInt();
      for(int i=0 ; i<q ; i++){
        int a=sc.nextInt();
        int b=sc.nextInt();
        if(same(a,b)){
          System.out.println("yes");
        }
        else {
          System.out.println("no");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute par : Sequence(int);
  static   operation init( N : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < N do ( (     rank[i+1] := 0 ; 
     par[i+1] := i )  ;     i := i + 1 ) );
  static   operation root( x : int) : int
  pre: true
  post: true
  activity: (     if (par[x+1] = x) then (     return x ) else skip ; 
     return par[x+1] );
  static   operation same( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return (root(x) = root(y)) );
  static   operation unite( x : int, y : int) : void
  pre: true
  post: true
  activity: (     x := root(x) ; 
     y := root(y) ; 
     if (x = y) then     return else skip ; 
     if (rank[x+1] < rank[y+1]) then (     par[x+1] := y ) else (     par[y+1] := x ; 
     if (rank[x+1] = rank[y+1]) then     rank[x+1] := rank[x+1] + 1 ; else skip ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    rank := Integer.subrange(1,n + 1)->collect(0) ; 
    par := Integer.subrange(1,n + 1)->collect(0) ; 
    execute init(n) ; 
        var i : int ; i := 0 ; while i < m do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     execute unite(a, b) )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     if (same(a, b)) then (     OclFile["System.out"].println("yes") ) else (     OclFile["System.out"].println("no") ) )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static class QuickUnionUF {
    private int[] id ;
    private int[] sz ;
    public QuickUnionUF(int N){
      id=new int[N];
      sz=new int[N];
      for(int i=0 ; i<N ; i++){
        id[i]=i ;
        sz[i]=0 ;
      }
    }
    public void union(int p,int q){
      int i=root(p);
      int j=root(q);
      if(i==j)return ;
      if(sz[i]<sz[j]){
        id[i]=j ;
        sz[j]+=sz[i];
      }
      else {
        id[j]=i ;
        sz[i]+=sz[j];
      }
    }
    private int root(int i){
      while(i!=id[i])i=id[i];
      return i ;
    }
    public boolean connected(int p,int q){
      return root(p)==root(q);
    }
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    int M=scanner.nextInt();
    QuickUnionUF uf=new QuickUnionUF(N);
    for(int i=0 ; i<M ; i++){
      int p=scanner.nextInt();
      int q=scanner.nextInt();
      uf.union(p,q);
    }
    int Q=scanner.nextInt();
    for(int i=0 ; i<Q ; i++){
      int p=scanner.nextInt();
      int q=scanner.nextInt();
      if(uf.connected(p,q))System.out.print("yes\n");
      else System.out.print("no\n");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class QuickUnionUF {
   attribute id : Sequence(int);
   attribute sz : Sequence(int);
   static operation newQuickUnionUF( N : int) : QuickUnionUF
  pre: true
  post: true
  activity:
  ( var self : QuickUnionUF ;
    self := createQuickUnionUF();
    self.initialise(N);
    return self );
  operation initialise( N : int) : void
  pre: true  post: true
  activity: (     id := Integer.subrange(1,N)->collect(0) ; 
     sz := Integer.subrange(1,N)->collect(0) ; 
         var i : int ; i := 0 ; while i < N do ( (     id[i+1] := i ; 
     sz[i+1] := 0 )  ;     i := i + 1 ) );
   operation union( p : int, q : int) : void
  pre: true
  post: true
  activity: (     var i : int ; i := root(p) ;
     var j : int ; j := root(q) ;
     if (i = j) then     return else skip ; 
     if (sz[i+1] < sz[j+1]) then (     id[i+1] := j ; 
     sz[j+1] := sz[j+1]+(sz[i+1]) ) else (     id[j+1] := i ; 
     sz[i+1] := sz[i+1]+(sz[j+1]) ) );
   operation root( i : int) : int
  pre: true
  post: true
  activity: (     while (i /= id[i+1]) do     i := id[i+1] ; ; 
     return i );
   operation connected( p : int, q : int) : boolean
  pre: true
  post: true
  activity: (     return root(p) = root(q) );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var M : int ; M := scanner.getCurrent()->toInteger() ;
    var uf : QuickUnionUF ; uf := QuickUnionUF.newQuickUnionUF(N) ;
        var i : int ; i := 0 ; while i < M do ( (     var p : int ; p := scanner.getCurrent()->toInteger() ;
     var q : int ; q := scanner.getCurrent()->toInteger() ;
     uf.union(p, q) )  ;     i := i + 1 ) ; 
    var Q : int ; Q := scanner.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < Q do ( (     var p : int ; p := scanner.getCurrent()->toInteger() ;
     var q : int ; q := scanner.getCurrent()->toInteger() ;
     if (uf.connected(p, q)) then     OclFile["System.out"].print("yes\n") ; else     OclFile["System.out"].print("no\n") ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  class UnionFind {
    private int[] par,rank ;
    UnionFind(int n){
      par=new int[n];
      rank=new int[n];
      for(int i=0 ; i<n ; i++)par[i]=i ;
    }
    int find(int x){
      if(par[x]==x)return x ;
      else return par[x]=find(par[x]);
    }
    void unite(int x,int y){
      x=find(x);
      y=find(y);
      if(x==y)return ;
      if(rank[x]<rank[y]){
        par[x]=y ;
      }
      else {
        par[y]=x ;
        if(rank[x]==rank[y])rank[x]++;
      }
    }
    boolean same(int x,int y){
      return find(x)==find(y);
    }
  }
  void run(){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int m=scan.nextInt();
    UnionFind uf=new UnionFind(n);
    for(int i=0 ; i<m ; i++){
      int s=scan.nextInt();
      int t=scan.nextInt();
      uf.unite(s,t);
    }
    int q=scan.nextInt();
    for(int i=0 ; i<q ; i++){
      int s=scan.nextInt();
      int t=scan.nextInt();
      System.out.println(uf.same(s,t)? "yes" : "no");
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class UnionFind {
   attribute par : Sequence(int);
   static operation newUnionFind( n : int) : UnionFind
  pre: true
  post: true
  activity:
  ( var self : UnionFind ;
    self := createUnionFind();
    self.initialise(n);
    return self );
  operation initialise( n : int) : void
  pre: true  post: true
  activity: (     par := Integer.subrange(1,n)->collect(0) ; 
     rank := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do (     par[i+1] := i ;  ;     i := i + 1 ) );
   operation find( x : int) : int
  pre: true
  post: true
  activity: (     if (par[x+1] = x) then     return x else     return par[x+1] );
   operation unite( x : int, y : int) : void
  pre: true
  post: true
  activity: (     x := find(x) ; 
     y := find(y) ; 
     if (x = y) then     return else skip ; 
     if (rank[x+1] < rank[y+1]) then (     par[x+1] := y ) else (     par[y+1] := x ; 
     if (rank[x+1] = rank[y+1]) then     rank[x+1] := rank[x+1] + 1 ; else skip ) );
   operation same( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     return find(x) = find(y) );
}
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : int ; m := scan.getCurrent()->toInteger() ;
    var uf : UnionFind ; uf := UnionFind.newUnionFind(n) ;
        var i : int ; i := 0 ; while i < m do ( (     var s : int ; s := scan.getCurrent()->toInteger() ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
     uf.unite(s, t) )  ;     i := i + 1 ) ; 
    var q : int ; q := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var s : int ; s := scan.getCurrent()->toInteger() ;
     var t : int ; t := scan.getCurrent()->toInteger() ;
     OclFile["System.out"].println(if uf.same(s, t) then "yes" else "no" endif) )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class B {
  static void p(Object...o){
    System.out.println(Arrays.deepToString(o));
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int zz=1 ; zz<=T ; zz++){
      int N=in.nextInt();
      int[] A=new int[N];
      int[] B=new int[N];
      for(int i=0 ; i<N ; i++){
        A[i]=in.nextInt();
        B[i]=in.nextInt();
      }
      int[] have=new int[N];
      int stars=0 ;
      int ans=0 ;
      next : while(stars<2*N){
        int best=-1 ;
        for(int i=0 ; i<N ; i++){
          if(have[i]==2)continue ;
          if(stars>=B[i]){
            stars+=2-have[i];
            have[i]=2 ;
            ans++;
            continue next ;
          }
          if(have[i]==1)continue ;
          if(stars<A[i])continue ;
          if(best==-1 || B[i]>B[best]){
            best=i ;
          }
        }
        if(best==-1)break ;
        have[best]=1 ;
        ans++;
        stars++;
      }
      if(stars==2*N)System.out.format("Case #%d: %d\n",zz,ans);
      else System.out.format("Case #%d: Too Bad\n",zz,ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation p( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println((o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var zz : int ; zz := 1 ; while zz <= T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
    var B : Sequence(int) ; B := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := in.getCurrent()->toInteger() ; 
     B[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var have : Sequence(int) ; have := Integer.subrange(1,N)->collect(0) ;
    var stars : int ; stars := 0 ;
    var ans : int ; ans := 0 ;
    while (stars < 2 * N) do (     var best : int ; best := -1 ;
         var i : int ; i := 0 ; while i < N do ( (     if (have[i+1] = 2) then     continue else skip ; 
     if (stars >= B[i+1]) then (     stars := stars+(2 - have[i+1]) ; 
     have[i+1] := 2 ; 
     ans := ans + 1 ; 
     continue ) else skip ; 
    if (have[i+1] = 1) then     continue else skip ; 
    if (stars < A[i+1]) then     continue else skip ; 
    if (best = -1 or B[i+1] > B[best+1]) then (     best := i ) else skip ; 
 )  ;     i := i + 1 ) ; 
    if (best = -1) then     break else skip ; 
    have[best+1] := 1 ; 
    ans := ans + 1 ; 
    stars := stars + 1 ; 
 ) ; 
    if (stars = 2 * N) then     OclFile["System.out"].format("Case #%d: %d\n", zz, ans) else     OclFile["System.out"].format("Case #%d: Too Bad\n", zz, ans) ; ;  
 )  ;     zz := zz + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class B {
  static int[] visit=new int[1024];
  static int[] a=new int[1024];
  static int[] b=new int[1024];
  public static void main(String[] args)throws Exception {
    Scanner s=new Scanner(new File("B.in"));
    PrintWriter out=new PrintWriter(new File("B.out"));
    int T=s.nextInt();
    for(int tc=1 ; tc<=T ; tc++){
      out.print("Case #"+tc+": ");
      int N=s.nextInt();
      Arrays.fill(visit,0);
      for(int i=0 ; i<N ; i++){
        a[i]=s.nextInt();
        b[i]=s.nextInt();
      }
      int ans=0 ;
      int stars=0 ;
      boolean progress=true ;
      outer : while(progress){
        if(stars==2*N)break ;
        ans++;
        progress=false ;
        for(int i=0 ; i<N ; i++){
          if(visit[i]==0 && b[i]<=stars){
            progress=true ;
            stars+=2 ;
            visit[i]=2 ;
            continue outer ;
          }
        }
        for(int i=0 ; i<N ; i++){
          if(visit[i]==1 && b[i]<=stars){
            progress=true ;
            stars+=1 ;
            visit[i]=2 ;
            continue outer ;
          }
        }
        int bestb=0 ;
        int besti=0 ;
        for(int i=0 ; i<N ; i++){
          if(visit[i]==0 && a[i]<=stars){
            progress=true ;
            if(bestb<b[i]){
              bestb=b[i];
              besti=i ;
            }
          }
        }
        if(progress){
          visit[besti]=1 ;
          stars+=1 ;
        }
      }
      if(stars==2*N)out.println(ans);
      else out.println("Too Bad");
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute visit : Sequence(int) := Integer.subrange(1,1024)->collect(0);
  static   attribute a : Sequence(int) := Integer.subrange(1,1024)->collect(0);
  static   attribute b : Sequence(int) := Integer.subrange(1,1024)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile("B.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("B.out")) ;
    var T : int ; T := s.getCurrent()->toInteger() ;
        var tc : int ; tc := 1 ; while tc <= T do ( (     skip ; 
     var N : int ; N := s.getCurrent()->toInteger() ;
    visit := visit->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := s.getCurrent()->toInteger() ; 
     b[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    var stars : int ; stars := 0 ;
    var progress : boolean ; progress := true ;
    while (progress) do (     if (stars = 2 * N) then     break else skip ; 
     ans := ans + 1 ; 
    progress := false ; 
        var i : int ; i := 0 ; while i < N do ( (     if (visit[i+1] = 0 & b[i+1] <= stars) then (     progress := true ; 
     stars := stars+(2) ; 
     visit[i+1] := 2 ; 
     continue ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (visit[i+1] = 1 & b[i+1] <= stars) then (     progress := true ; 
     stars := stars+(1) ; 
     visit[i+1] := 2 ; 
     continue ) else skip )  ;     i := i + 1 ) ; 
    var bestb : int ; bestb := 0 ;
    var besti : int ; besti := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     if (visit[i+1] = 0 & a[i+1] <= stars) then (     progress := true ; 
     if (bestb < b[i+1]) then (     bestb := b[i+1] ; 
     besti := i ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (progress) then (     visit[besti+1] := 1 ; 
     stars := stars+(1) ) else skip ; 
 ) ; 
    if (stars = 2 * N) then     skip else     skip ; ;  
 )  ;     tc := tc + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections ;
import java.util.Arrays ;
public class GfG {
  public static int getMinCost(Integer arr[],int n){
    int min_ele=Collections.min(Arrays.asList(arr));
    return min_ele*(n-1);
  }
  public static void main(String[] args){
    Integer[] arr={
      4,2,5 };
      int n=arr.length ;
      System.out.println(getMinCost(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   operation getMinCost( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var min_ele : int ; min_ele := .min(arr) ;
     return min_ele * (n - 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{4,2,5} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(getMinCost(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Comparator ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.TreeSet ;
public class b {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new b().go();
  }
  private void go(){
    int numc=in.nextInt();
    IN : for(int cnum=0 ;
    cnum<numc ;
    cnum++){
      int n=in.nextInt();
      int[][] q=new int[n][2];
      for(int i=0 ; i<n ; i++){
        q[i][0]=in.nextInt();
        q[i][1]=in.nextInt();
      }
      int min=0,stars=0 ;
      HashSet<Integer>chose1=new HashSet<Integer>(),chose2=new HashSet<Integer>();
      OUT : for(int i=0 ;
      i<2*n ;
      i++){
        if(stars==2*n)break ;
        int max=0,maxIndex=-1 ;
        for(int j=0 ; j<n ; j++){
          if(! chose2.contains(j)){
            if(! chose1.contains(j)){
              if(q[j][1]<=stars){
                stars+=2 ;
                min++;
                chose2.add(j);
                continue OUT ;
              }
              if(q[j][0]<=stars && q[j][1]>max){
                max=q[j][1];
                maxIndex=j ;
              }
            }
            if(q[j][1]<=stars){
              stars+=1 ;
              min++;
              chose2.add(j);
              chose1.remove(j);
              continue OUT ;
            }
          }
        }
        if(maxIndex==-1){
          System.out.printf("Case #%d: Too Bad\n",cnum+1);
          continue IN ;
        }
        chose1.add(maxIndex);
        min++;
        stars+=1 ;
      }
      System.out.printf("Case #%d: %d\n",cnum+1,min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class b {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     b.newb().go() );
   operation go() : void
  pre: true
  post: true
  activity: (     var numc : int ; numc := in.getCurrent()->toInteger() ;
         var cnum : int ; cnum := 0 ; while cnum < numc do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var q : Sequence(Sequence(int)) ; q := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     q[i+1][0+1] := in.getCurrent()->toInteger() ; 
     q[i+1][1+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var min : int ; min := 0 ;
    var stars : int ; stars := 0 ;
    var chose1 : Set(int) ; chose1 := Set{} ;
    var chose2 : Set(int) ; chose2 := Set{} ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     if (stars = 2 * n) then     break else skip ; 
     var max : int ; max := 0 ;
    var maxIndex : int ; maxIndex := -1 ;
        var j : int ; j := 0 ; while j < n do ( (     if (not(chose2->includes(j))) then (     if (not(chose1->includes(j))) then (     if (q[j+1][1+1] <= stars) then (     stars := stars+(2) ; 
     min := min + 1 ; 
     chose2->excludes(j) ; 
     continue ) else skip ; 
     if (q[j+1][0+1] <= stars & q[j+1][1+1] > max) then (     max := q[j+1][1+1] ; 
     maxIndex := j ) else skip ) else skip ; 
     if (q[j+1][1+1] <= stars) then (     stars := stars+(1) ; 
     min := min + 1 ; 
    chose2->excludes(j) ; 
    chose1 := chose1->excludingAt(j+1) ; 
    continue 
 ) else skip ) else skip )  ;     j := j + 1 ) ; 
    if (maxIndex = -1) then (     OclFile["System.out"].printf("Case #%d: Too Bad\n", cnum + 1) ; 
     continue ) else skip ; 
    chose1 := chose1->including(maxIndex) ; 
    min := min + 1 ; 
    stars := stars+(1) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("Case #%d: %d\n", cnum + 1, min) ; 
 )  ;     cnum := cnum + 1 ) ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileNotFoundException ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Ae {
  public static void main(String[] args)throws FileNotFoundException {
    Scanner in=new Scanner(new File("A.in"));
    PrintWriter out=new PrintWriter(new File("A.out"));
    int T=in.nextInt();
    for(int i=0 ; i<T ; i++){
      String s="Case #"+(i+1)+": "+new Ae().solve(in);
      out.println(s);
      System.out.println(s);
    }
    out.close();
  }
  private String solve(Scanner in){
    int n=in.nextInt();
    int l=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=Integer.parseInt(in.next(),2);
    }
    int[] b=new int[n];
    for(int i=0 ; i<n ; i++){
      b[i]=Integer.parseInt(in.next(),2);
    }
    int res=l+1 ;
    Arrays.sort(a);
    for(int m=0 ; m<(1<<l); m++){
      for(int i=0 ; i<n ; i++){
        b[i] ^=m ;
      }
      Arrays.sort(b);
      boolean ok=true ;
      for(int i=0 ; i<n ; i++){
        if(a[i]!=b[i]){
          ok=false ;
          break ;
        }
      }
      if(ok){
        res=Math.min(res,Integer.bitCount(m));
      }
      for(int i=0 ; i<n ; i++){
        b[i] ^=m ;
      }
    }
    return res>l ? "NOT POSSIBLE" :(""+res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ae {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile("A.in")) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile("A.out")) ;
    var T : int ; T := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < T do ( (     var s : String ; s := "Case #" + (i + 1) + ": " + Ae.newAe().solve(in) ;
     skip ; 
     OclFile["System.out"].println(s) )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation solve( in : OclFile) : String
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var l : int ; l := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (in.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var b : Sequence(int) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := (in.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var res : int ; res := l + 1 ;
    a := a->sort() ; 
        var m : int ; m := 0 ; while m < ((1*(2->pow(l)))->oclAsType(long)) do ( (         var i : int ; i := 0 ; while i < n do ( (     b[i+1] := MathLib.bitwiseXor(b[i+1],m) )  ;     i := i + 1 ) ; 
     b := b->sort() ; 
    var ok : boolean ; ok := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] /= b[i+1]) then (     ok := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (ok) then (     res := Set{res, bitCount(m)}->min() ) else skip ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := MathLib.bitwiseXor(b[i+1],m) )  ;     i := i + 1 ) ; 
 )  ;     m := m + 1 ) ; 
    return if res > l then "NOT POSSIBLE" else ("" + res) endif 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
public class Main {
  static class Level implements Comparable<Level>{
    public int low ;
    public int high ;
    public Level(int low,int high){
      this.low=low ;
      this.high=high ;
    }
    @ Override public int compareTo(Level o){
      return high-o.high ;
    }
  }
  public static void main(String[] args)throws Exception {
    Scanner scan=new Scanner(System.in);
    int task=scan.nextInt();
    int current=1 ;
    while(task-->0){
      int N=scan.nextInt();
      Level[] arr=new Level[N];
      int[] status=new int[N];
      int finished=0 ;
      int star=0 ;
      for(int i=0 ; i<N ; i++){
        arr[i]=new Level(scan.nextInt(),scan.nextInt());
      }
      Arrays.sort(arr);
      int result=0 ;
      while(finished<N){
        for(int i=0 ; i<N ; i++){
          if(status[i]==2){
            continue ;
          }
          if(star>=arr[i] .high){
            star+=2-status[i];
            status[i]=2 ;
            finished++;
            result++;
          }
        }
        if(finished==N){
          break ;
        }
        int select=-1 ;
        int max=-1 ;
        for(int i=0 ; i<N ; i++){
          if(status[i]>=1){
            continue ;
          }
          if(star>=arr[i] .low){
            if(arr[i] .high>max){
              select=i ;
              max=arr[i] .high ;
            }
          }
        }
        if(select==-1){
          result=-1 ;
          break ;
        }
        else {
          result++;
          status[select]=1 ;
          star++;
        }
      }
      System.out.println("Case #"+current+": "+(result==-1 ? "Too Bad" : result));
      current++;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class Level implements Comparable<Level> {
   attribute low : int;
   attribute high : int;
   static operation newLevel( low : int, high : int) : Level
  pre: true
  post: true
  activity:
  ( var self : Level ;
    self := createLevel();
    self.initialise(low, high);
    return self );
  operation initialise( low : int, high : int) : void
  pre: true  post: true
  activity: (     self.low := low ; 
     self.high := high );
      operation compareTo( o : Level) : int
  pre: true
  post: true
  activity: (     return high - o.high );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var task : int ; task := scan.getCurrent()->toInteger() ;
     var current : int ; current := 1 ;
         while (task > 0) do (        task := task - 1 ;     skip ; (     var N : int ; N := scan.getCurrent()->toInteger() ;
     var arr : Sequence(Level) ; arr := Integer.subrange(1,N)->collect(null) ;
    var status : Sequence(int) ; status := Integer.subrange(1,N)->collect(0) ;
    var finished : int ; finished := 0 ;
    var star : int ; star := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     arr[i+1] := Level.newLevel(scan.getCurrent()->toInteger(), scan.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var result : int ; result := 0 ;
    while (finished < N) do (         var i : int ; i := 0 ; while i < N do ( (     if (status[i+1] = 2) then (     continue ) else skip ; 
     if (star >= arr[i+1].high) then (     star := star+(2 - status[i+1]) ; 
     status[i+1] := 2 ; 
     finished := finished + 1 ; 
     result := result + 1 ) else skip )  ;     i := i + 1 ) ; 
     if (finished = N) then (     break ) else skip ; 
    var select : int ; select := -1 ;
    var max : int ; max := -1 ;
        var i : int ; i := 0 ; while i < N do ( (     if (status[i+1] >= 1) then (     continue ) else skip ; 
     if (star >= arr[i+1].low) then (     if (arr[i+1].high > max) then (     select := i ; 
     max := arr[i+1].high ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (select = -1) then (     result := -1 ; 
     break ) else (     result := result + 1 ; 
     status[select+1] := 1 ; 
     star := star + 1 ) ;  
 ) ; 
    OclFile["System.out"].println("Case #" + current + ": " + (if result = -1 then "Too Bad" else result endif)) ; 
    current := current + 1 ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B {
  private static Scanner sc ;
  public static void main(String[] args){
    sc=new Scanner(System.in);
    int t=sc.nextInt();
    sc.nextLine();
    for(int i=0 ; i<t ; i++){
      System.out.printf("Case #%d: %s\n",i+1,exec());
    }
  }
  public static String exec(){
    int n=sc.nextInt();
    int[] s1=new int[n];
    int[] s2=new int[n];
    for(int i=0 ; i<n ; i++){
      s1[i]=sc.nextInt();
      s2[i]=sc.nextInt();
    }
    int stars=0 ;
    int goal=n*2 ;
    int[] obtained=new int[n];
    int plays=0 ;
    loop : while(stars<goal){
      for(int i=0 ; i<n ; i++){
        if(s2[i]>stars)continue ;
        if(obtained[i]==2)continue ;
        stars+=2-obtained[i];
        obtained[i]=2 ;
        plays++;
        continue loop ;
      }
      int s2OfWinner=-1 ;
      int idxOfWinner=-1 ;
      for(int i=0 ; i<n ; i++){
        if(obtained[i]!=0)continue ;
        if(s1[i]>stars)continue ;
        if(s2[i]<s2OfWinner)continue ;
        s2OfWinner=s2[i];
        idxOfWinner=i ;
      }
      if(s2OfWinner==-1)return "Too Bad" ;
      stars++;
      obtained[idxOfWinner]=1 ;
      plays++;
    }
    return String.valueOf(plays);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   attribute sc : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var t : int ; t := sc.getCurrent()->toInteger() ;
     skip ; 
         var i : int ; i := 0 ; while i < t do ( (     OclFile["System.out"].printf("Case #%d: %s\n", i + 1, exec()) )  ;     i := i + 1 ) );
  static   operation exec() : String
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var s1 : Sequence(int) ; s1 := Integer.subrange(1,n)->collect(0) ;
    var s2 : Sequence(int) ; s2 := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     s1[i+1] := sc.getCurrent()->toInteger() ; 
     s2[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var stars : int ; stars := 0 ;
    var goal : int ; goal := n * 2 ;
    var obtained : Sequence(int) ; obtained := Integer.subrange(1,n)->collect(0) ;
    var plays : int ; plays := 0 ;
    while (stars < goal) do (         var i : int ; i := 0 ; while i < n do ( (     if (s2[i+1] > stars) then     continue else skip ; 
     if (obtained[i+1] = 2) then     continue else skip ; 
    stars := stars+(2 - obtained[i+1]) ; 
    obtained[i+1] := 2 ; 
    plays := plays + 1 ; 
    continue 
 )  ;     i := i + 1 ) ; 
     var s2OfWinner : int ; s2OfWinner := -1 ;
    var idxOfWinner : int ; idxOfWinner := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (obtained[i+1] /= 0) then     continue else skip ; 
     if (s1[i+1] > stars) then     continue else skip ; 
    if (s2[i+1] < s2OfWinner) then     continue else skip ; 
    s2OfWinner := s2[i+1] ; 
    idxOfWinner := i ; 
 )  ;     i := i + 1 ) ; 
    if (s2OfWinner = -1) then     return "Too Bad" else skip ; 
    stars := stars + 1 ; 
    obtained[idxOfWinner+1] := 1 ; 
    plays := plays + 1 ; 
 ) ; 
    return ((plays) + "") 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int sx=sc.nextInt();
    int sy=sc.nextInt();
    int tx=sc.nextInt();
    int ty=sc.nextInt();
    int i ;
    for(i=0 ; i<ty-sy ; i++)System.out.print("U");
    for(i=0 ; i<tx-sx ; i++)System.out.print("R");
    for(i=0 ; i<ty-sy ; i++)System.out.print("D");
    for(i=0 ; i<tx-sx ; i++)System.out.print("L");
    System.out.print("L");
    for(i=0 ; i<=ty-sy ; i++)System.out.print("U");
    for(i=0 ; i<=tx-sx ; i++)System.out.print("R");
    System.out.print("D");
    System.out.print("R");
    for(i=0 ; i<=ty-sy ; i++)System.out.print("D");
    for(i=0 ; i<=tx-sx ; i++)System.out.print("L");
    System.out.print("U");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sx : int ; sx := sc.getCurrent()->toInteger() ;
    var sy : int ; sy := sc.getCurrent()->toInteger() ;
    var tx : int ; tx := sc.getCurrent()->toInteger() ;
    var ty : int ; ty := sc.getCurrent()->toInteger() ;
    var i : int ;
        i := 0 ; while i < ty - sy do (     OclFile["System.out"].print("U") ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < tx - sx do (     OclFile["System.out"].print("R") ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < ty - sy do (     OclFile["System.out"].print("D") ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < tx - sx do (     OclFile["System.out"].print("L") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("L") ; 
        i := 0 ; while i <= ty - sy do (     OclFile["System.out"].print("U") ;  ;     i := i + 1 ) ; 
        i := 0 ; while i <= tx - sx do (     OclFile["System.out"].print("R") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("D") ; 
    OclFile["System.out"].print("R") ; 
        i := 0 ; while i <= ty - sy do (     OclFile["System.out"].print("D") ;  ;     i := i + 1 ) ; 
        i := 0 ; while i <= tx - sx do (     OclFile["System.out"].print("L") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("U") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.run();
  }
  public void run(){
    Scanner sc=new Scanner(System.in);
    int sx=sc.nextInt();
    int sy=sc.nextInt();
    int tx=sc.nextInt();
    int ty=sc.nextInt();
    int dx=tx-sx ;
    int dy=ty-sy ;
    f1(dx,dy);
    f2(dx,dy);
    System.out.print("L");
    System.out.print("U");
    f1(dx,dy);
    System.out.print("R");
    System.out.print("D");
    System.out.print("R");
    System.out.print("D");
    f2(dx,dy);
    System.out.print("L");
    System.out.print("U");
    System.out.println();
    sc.close();
  }
  private void f1(int dx,int dy){
    for(int i=0 ; i<dy ; i++){
      System.out.print("U");
    }
    for(int i=0 ; i<dx ; i++){
      System.out.print("R");
    }
  }
  private void f2(int dx,int dy){
    for(int i=0 ; i<dy ; i++){
      System.out.print("D");
    }
    for(int i=0 ; i<dx ; i++){
      System.out.print("L");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sx : int ; sx := sc.getCurrent()->toInteger() ;
    var sy : int ; sy := sc.getCurrent()->toInteger() ;
    var tx : int ; tx := sc.getCurrent()->toInteger() ;
    var ty : int ; ty := sc.getCurrent()->toInteger() ;
    var dx : int ; dx := tx - sx ;
    var dy : int ; dy := ty - sy ;
    execute f1(dx, dy) ; 
    execute f2(dx, dy) ; 
    OclFile["System.out"].print("L") ; 
    OclFile["System.out"].print("U") ; 
    execute f1(dx, dy) ; 
    OclFile["System.out"].print("R") ; 
    OclFile["System.out"].print("D") ; 
    OclFile["System.out"].print("R") ; 
    OclFile["System.out"].print("D") ; 
    execute f2(dx, dy) ; 
    OclFile["System.out"].print("L") ; 
    OclFile["System.out"].print("U") ; 
    OclFile["System.out"].println() ; 
    skip ; 
 );
   operation f1( dx : int, dy : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < dy do ( (     OclFile["System.out"].print("U") )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < dx do ( (     OclFile["System.out"].print("R") )  ;     i := i + 1 ) );
   operation f2( dx : int, dy : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < dy do ( (     OclFile["System.out"].print("D") )  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < dx do ( (     OclFile["System.out"].print("L") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void up(){
    System.out.print("U");
  }
  public static void down(){
    System.out.print("D");
  }
  public static void left(){
    System.out.print("L");
  }
  public static void right(){
    System.out.print("R");
  }
  public static void up(int N){
    for(int n=0 ; n<N ; n++)up();
  }
  public static void down(int N){
    for(int n=0 ; n<N ; n++)down();
  }
  public static void left(int N){
    for(int n=0 ; n<N ; n++)left();
  }
  public static void right(int N){
    for(int n=0 ; n<N ; n++)right();
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int sx=sc.nextInt();
    int sy=sc.nextInt();
    int tx=sc.nextInt();
    int ty=sc.nextInt();
    int dx=tx-sx ;
    int dy=ty-sy ;
    left();
    up(dy+1);
    right(dx+1);
    down();
    left(dx);
    down(dy);
    right(dx);
    up(dy);
    right();
    down(dy+1);
    left(dx+1);
    up();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation up() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("U") );
  static   operation down() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("D") );
  static   operation left() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("L") );
  static   operation right() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("R") );
  static   operation up( N : int) : void
  pre: true
  post: true
  activity: (         var n : int ; n := 0 ; while n < N do (     execute up() ;  ;     n := n + 1 ) );
  static   operation down( N : int) : void
  pre: true
  post: true
  activity: (         var n : int ; n := 0 ; while n < N do (     execute down() ;  ;     n := n + 1 ) );
  static   operation left( N : int) : void
  pre: true
  post: true
  activity: (         var n : int ; n := 0 ; while n < N do (     execute left() ;  ;     n := n + 1 ) );
  static   operation right( N : int) : void
  pre: true
  post: true
  activity: (         var n : int ; n := 0 ; while n < N do (     execute right() ;  ;     n := n + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sx : int ; sx := sc.getCurrent()->toInteger() ;
    var sy : int ; sy := sc.getCurrent()->toInteger() ;
    var tx : int ; tx := sc.getCurrent()->toInteger() ;
    var ty : int ; ty := sc.getCurrent()->toInteger() ;
    var dx : int ; dx := tx - sx ;
    var dy : int ; dy := ty - sy ;
    execute left() ; 
    execute up(dy + 1) ; 
    execute right(dx + 1) ; 
    execute down() ; 
    execute left(dx) ; 
    execute down(dy) ; 
    execute right(dx) ; 
    execute up(dy) ; 
    execute right() ; 
    execute down(dy + 1) ; 
    execute left(dx + 1) ; 
    execute up() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int sx=scan.nextInt();
    int sy=scan.nextInt();
    int tx=scan.nextInt();
    int ty=scan.nextInt();
    StringBuilder sb=new StringBuilder();
    for(int x=sx ; x<tx ; x++){
      sb.append('R');
    }
    for(int y=sy ; y<ty ; y++){
      sb.append('U');
    }
    for(int x=tx ; sx<x ; x--){
      sb.append('L');
    }
    for(int y=ty ; sy<y ; y--){
      sb.append('D');
    }
    sb.append('D');
    for(int x=sx ; x<tx+1 ; x++){
      sb.append('R');
    }
    for(int y=sy-1 ; y<ty ; y++){
      sb.append('U');
    }
    sb.append('L');
    sb.append('U');
    for(int x=tx ; sx-1<x ; x--){
      sb.append('L');
    }
    for(int y=ty+1 ; sy<y ; y--){
      sb.append('D');
    }
    sb.append('R');
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var sx : int ; sx := scan.getCurrent()->toInteger() ;
    var sy : int ; sy := scan.getCurrent()->toInteger() ;
    var tx : int ; tx := scan.getCurrent()->toInteger() ;
    var ty : int ; ty := scan.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        var x : int ; x := sx ; while x < tx do ( (     sb := sb + StringLib.newString('R') )  ;     x := x + 1 ) ; 
        var y : int ; y := sy ; while y < ty do ( (     sb := sb + StringLib.newString('U') )  ;     y := y + 1 ) ; 
        var x : int ; x := tx ; while sx < x do ( (     sb := sb + StringLib.newString('L') )  ;     x := x - 1 ) ; 
        var y : int ; y := ty ; while sy < y do ( (     sb := sb + StringLib.newString('D') )  ;     y := y - 1 ) ; 
    sb := sb + StringLib.newString('D') ; 
        var x : int ; x := sx ; while x < tx + 1 do ( (     sb := sb + StringLib.newString('R') )  ;     x := x + 1 ) ; 
        var y : int ; y := sy - 1 ; while y < ty do ( (     sb := sb + StringLib.newString('U') )  ;     y := y + 1 ) ; 
    sb := sb + StringLib.newString('L') ; 
    sb := sb + StringLib.newString('U') ; 
        var x : int ; x := tx ; while sx - 1 < x do ( (     sb := sb + StringLib.newString('L') )  ;     x := x - 1 ) ; 
        var y : int ; y := ty + 1 ; while sy < y do ( (     sb := sb + StringLib.newString('D') )  ;     y := y - 1 ) ; 
    sb := sb + StringLib.newString('R') ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int sx=Integer.parseInt(sc.next());
    int sy=Integer.parseInt(sc.next());
    int tx=Integer.parseInt(sc.next());
    int ty=Integer.parseInt(sc.next());
    sc.close();
    int w=tx-sx ;
    int h=ty-sy ;
    StringBuilder sb=new StringBuilder();
    sb.append(repeatStr("U",h));
    sb.append(repeatStr("R",w));
    sb.append(repeatStr("D",h));
    sb.append(repeatStr("L",w));
    sb.append("L");
    sb.append(repeatStr("U",h+1));
    sb.append(repeatStr("R",w+1));
    sb.append("DR");
    sb.append(repeatStr("D",h+1));
    sb.append(repeatStr("L",w+1));
    sb.append("U");
    String result=sb.toString();
    System.out.println(result);
  }
  public static String repeatStr(String s,int n){
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<n ; i++){
      sb.append(s);
    }
    return sb.toString();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sx : int ; sx := (sc.getCurrent())->toInteger() ;
    var sy : int ; sy := (sc.getCurrent())->toInteger() ;
    var tx : int ; tx := (sc.getCurrent())->toInteger() ;
    var ty : int ; ty := (sc.getCurrent())->toInteger() ;
    skip ; 
    var w : int ; w := tx - sx ;
    var h : int ; h := ty - sy ;
    var sb : String ; sb := StringLib.newString() ;
    sb := sb + StringLib.newString(repeatStr("U", h)) ; 
    sb := sb + StringLib.newString(repeatStr("R", w)) ; 
    sb := sb + StringLib.newString(repeatStr("D", h)) ; 
    sb := sb + StringLib.newString(repeatStr("L", w)) ; 
    sb := sb + StringLib.newString("L") ; 
    sb := sb + StringLib.newString(repeatStr("U", h + 1)) ; 
    sb := sb + StringLib.newString(repeatStr("R", w + 1)) ; 
    sb := sb + StringLib.newString("DR") ; 
    sb := sb + StringLib.newString(repeatStr("D", h + 1)) ; 
    sb := sb + StringLib.newString(repeatStr("L", w + 1)) ; 
    sb := sb + StringLib.newString("U") ; 
    var result : String ; result := sb+"" ;
    OclFile["System.out"].println(result) ; 
 );
  static   operation repeatStr( s : String, n : int) : String
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
         var i : int ; i := 0 ; while i < n do ( (     sb := sb + StringLib.newString(s) )  ;     i := i + 1 ) ; 
     return sb+"" );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p518 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p518().run());
  }
  private static final int LIMIT=Library.pow(10,8);
  public String run(){
    long sum=0 ;
    boolean[] isPrime=Library.listPrimality(LIMIT-1);
    for(int x=1 ; x<isPrime.length ; x++){
      for(int y=1 ; ; y++){
        long a=(long)x*y*y-1 ;
        if(a>=isPrime.length)break ;
        if(! isPrime[(int)a])continue ;
        for(int z=y+1 ; ; z++){
          if(Library.gcd(y,z)!=1)continue ;
          long b=(long)x*y*z-1 ;
          long c=(long)x*z*z-1 ;
          if(c>=isPrime.length)break ;
          if(isPrime[(int)b] && isPrime[(int)c]){
            long addend=a+b+c ;
            if(sum+addend<sum)throw new ArithmeticException("Overflow");
            sum+=addend ;
          }
        }
      }
    }
    return Long.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
class p518 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p518.newp518().run()) );
  static    attribute LIMIT : int := Library.pow(10, 8);
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
     var isPrime : Sequence(boolean) ; isPrime := Library.listPrimality(LIMIT - 1) ;
         var x : int ; x := 1 ; while x < isPrime->size() do ( (         var y : int ; y := 1 ; while true do ( (     var a : long ; a := x->oclAsType(long) * y * y - 1 ;
     if (a >= isPrime->size()) then     break else skip ; 
     if (not(isPrime[a->oclAsType(int)+1])) then     continue else skip ; 
         var z : int ; z := y + 1 ; while true do ( (     if (Library.gcd(y, z) /= 1) then     continue else skip ; 
     var b : long ; b := x->oclAsType(long) * y * z - 1 ;
    var c : long ; c := x->oclAsType(long) * z * z - 1 ;
    if (c >= isPrime->size()) then     break else skip ; 
    if (isPrime[b->oclAsType(int)+1] & isPrime[c->oclAsType(int)+1]) then (     var addend : long ; addend := a + b + c ;
     if (sum + addend < sum) then     error ArithmeticException("Overflow") ; else skip ; 
     sum := sum+(addend) ) else skip ; 
 )  ;     z := z + 1 ) )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
     return ((sum) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maxSubArraySum(int a[],int size){
    int max_so_far=Integer.MIN_VALUE,max_ending_here=0 ;
    for(int i=0 ; i<size ; i++){
      max_ending_here=max_ending_here+a[i];
      if(max_so_far<max_ending_here)max_so_far=max_ending_here ;
      if(max_ending_here<0)max_ending_here=0 ;
    }
    return max_so_far ;
  }
  static int maxSum(int a[],int n){
    int S=0 ;
    int S1=maxSubArraySum(a,n);
    for(int i=0 ; i<n ; i++)S+=a[i];
    return(2*S1-S);
  }
  public static void main(String[] args){
    int a[]={
-35,32,-24,0,27,-10,0,-19 };
      int n=a.length ;
      System.out.println(maxSum(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maxSubArraySum( a : Sequence(int), size : int) : int
  pre: true
  post: true
  activity: (     var max_so_far : int ; max_so_far := -2147483648 ;
    var max_ending_here : int ; max_ending_here := 0 ;
         var i : int ; i := 0 ; while i < size do ( (     max_ending_here := max_ending_here + a[i+1] ; 
     if (max_so_far < max_ending_here) then     max_so_far := max_ending_here ; else skip ; 
     if (max_ending_here < 0) then     max_ending_here := 0 ; else skip )  ;     i := i + 1 ) ; 
     return max_so_far );
  static   operation maxSum( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var S : int ; S := 0 ;
     var S1 : int ; S1 := maxSubArraySum(a, n) ;
         var i : int ; i := 0 ; while i < n do (     S := S+(a[i+1]) ;  ;     i := i + 1 ) ; 
     return (2 * S1 - S) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{-35,32,-24,0,27,-10,0,-19} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(maxSum(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isBinary(int number){
    while(number>0){
      int digit=number % 10 ;
      if(digit>1)return false ;
      number/=10 ;
    }
    return true ;
  }
  public static void main(String a[]){
    int n=1000111 ;
    System.out.println(isBinary(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isBinary( number : int) : boolean
  pre: true
  post: true
  activity: (     while (number > 0) do (     var digit : int ; digit := number mod 10 ;
     if (digit > 1) then     return false else skip ; 
     number := number/(10) ) ; 
     return true );
  static   operation main( a : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 1000111 ;
     OclFile["System.out"].println(isBinary(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int maxAreaOfIsland(int[][] grid){
    int[] dr=new int[] {
      1,-1,0,0 };
      int[] dc=new int[] {
        0,0,1,-1 };
        int ans=0 ;
        for(int r0=0 ; r0<grid.length ; r0++){
          for(int c0=0 ; c0<grid[0] .length ; c0++){
            if(grid[r0][c0]==1){
              int shape=0 ;
              Stack<int[]>stack=new Stack();
              stack.push(new int[] {
                r0,c0 }
);
                grid[r0][c0]=0 ;
                while(! stack.empty()){
                  int[] node=stack.pop();
                  int r=node[0],c=node[1];
                  shape++;
                  for(int k=0 ; k<4 ; k++){
                    int nr=r+dr[k];
                    int nc=c+dc[k];
                    if(0<=nr && nr<grid.length && 0<=nc && nc<grid[0] .length && grid[nr][nc]==1){
                      stack.push(new int[] {
                        nr,nc }
);
                        grid[nr][nc]=0 ;
                      }
                    }
                  }
                  ans=Math.max(ans,shape);
                }
              }
            }
            return ans ;
          }
        }

------------------------------------------------------------
OCL File:
---------
class Solution {
   operation maxAreaOfIsland( grid : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var dr : Sequence(int) ; dr := Sequence{1,-1,0,0} ;
     var dc : Sequence(int) ; dc := Sequence{0,0,1,-1} ;
    var ans : int ; ans := 0 ;
        var r0 : int ; r0 := 0 ; while r0 < grid->size() do ( (         var c0 : int ; c0 := 0 ; while c0 < grid[0+1]->size() do ( (     if (grid[r0+1][c0+1] = 1) then (     var shape : int ; shape := 0 ;
     var stack : Sequence(Sequence(int)) ; stack := Sequence{} ;
    stack := stack->append(Sequence{r0,c0}) ; 
    grid[r0+1][c0+1] := 0 ; 
    while (not(stack->isEmpty())) do (     var node : Sequence(int) ; node := stack->last() ;
     var r : int ; r := node[0+1] ;
    var c : int ; c := node[1+1] ;
     shape := shape + 1 ; 
         var k : int ; k := 0 ; while k < 4 do ( (     var nr : int ; nr := r + dr[k+1] ;
     var nc : int ; nc := c + dc[k+1] ;
     if (0 <= nr & nr < grid->size() & 0 <= nc & nc < grid[0+1]->size() & grid[nr+1][nc+1] = 1) then (     stack := stack->append(Sequence{nr,nc}) ; 
     grid[nr+1][nc+1] := 0 ) else skip )  ;     k := k + 1 ) ) ; 
    ans := Set{ans, shape}->max() ; 
 ) else skip )  ;     c0 := c0 + 1 ) )  ;     r0 := r0 + 1 ) ; 
    return ans 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printCollatz(int n){
    while(n!=1){
      System.out.print(n+" ");
      if((n & 1)==1)n=3*n+1 ;
      else n=n/2 ;
    }
    System.out.print(n);
  }
  public static void main(String[] args){
    printCollatz(6);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printCollatz( n : int) : void
  pre: true
  post: true
  activity: (     while (n /= 1) do (     OclFile["System.out"].print(n + " ") ; 
     if ((n & 1) = 1) then     n := 3 * n + 1 ; else     n := n / 2 ; ) ; 
     OclFile["System.out"].print(n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute printCollatz(6) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class pair {
    int first,second ;
    public pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  static pair countSum(int arr[],int n){
    int result=0 ;
    int count_odd,count_even ;
    count_odd=0 ;
    count_even=0 ;
    for(int i=1 ; i<=n ; i++){
      if(arr[i-1] % 2==0){
        count_even=count_even+count_even+1 ;
        count_odd=count_odd+count_odd ;
      }
      else {
        int temp=count_even ;
        count_even=count_even+count_odd ;
        count_odd=count_odd+temp+1 ;
      }
    }
    return new pair(count_even,count_odd);
  }
  public static void main(String[] args){
    int arr[]={
      1,2,2,3 };
      int n=arr.length ;
      pair ans=countSum(arr,n);
      System.out.print("EvenSum="+ans.first);
      System.out.print(" OddSum="+ans.second);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static class pair {
   attribute first : int;
   static operation newpair( first : int, second : int) : pair
  pre: true
  post: true
  activity:
  ( var self : pair ;
    self := createpair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation countSum( arr : Sequence(int), n : int) : pair
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     var count_odd : int ;
    var count_even : int ;
    count_odd := 0 ; 
    count_even := 0 ; 
        var i : int ; i := 1 ; while i <= n do ( (     if (arr[i - 1+1] mod 2 = 0) then (     count_even := count_even + count_even + 1 ; 
     count_odd := count_odd + count_odd ) else (     var temp : int ; temp := count_even ;
     count_even := count_even + count_odd ; 
     count_odd := count_odd + temp + 1 ) )  ;     i := i + 1 ) ; 
    return pair.newpair(count_even, count_odd) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,2,3} ;
     var n : int ; n := arr->size() ;
    var ans : pair ; ans := countSum(arr, n) ;
    OclFile["System.out"].print("EvenSum=" + ans->at("first")) ; 
    OclFile["System.out"].print(" OddSum=" + ans->at("second")) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int cmp(int a,int b){
    if(a>b)return 1 ;
    else if(a==b)return 0 ;
    else return-1 ;
  }
  static int maxSubarraySize(int[] arr,int n){
    int ans=1 ;
    int anchor=0 ;
    for(int i=1 ; i<n ; i++){
      int c=cmp(arr[i-1],arr[i]);
      if(c==0)anchor=i ;
      else if(i==n-1 || c*cmp(arr[i],arr[i+1])!=-1){
        ans=Math.max(ans,i-anchor+1);
        anchor=i ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    int[] arr={
      9,4,2,10,7,8,8,1,9 };
      int n=arr.length ;
      System.out.println(maxSubarraySize(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation cmp( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a > b) then     return 1 else     if (a = b) then     return 0 else     return -1 ;  );
  static   operation maxSubarraySize( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := 1 ;
     var anchor : int ; anchor := 0 ;
         var i : int ; i := 1 ; while i < n do ( (     var c : int ; c := cmp(arr[i - 1+1], arr[i+1]) ;
     if (c = 0) then     anchor := i ; else     if (i = n - 1 or c * cmp(arr[i+1], arr[i + 1+1]) /= -1) then (     ans := Set{ans, i - anchor + 1}->max() ; 
     anchor := i ) else skip ; )  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{9,4,2,10,7,8,8,1,9} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxSubarraySize(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPossible(int a[],int n){
    int cur=a[0];
    cur--;
    for(int i=1 ; i<n ; i++){
      int nxt=a[i];
      if(nxt>cur)nxt--;
      else if(nxt<cur)return false ;
      cur=nxt ;
    }
    return true ;
  }
  public static void main(String[] args){
    int a[]={
      1,2,1,2,3 };
      int n=a.length ;
      if(isPossible(a,n))System.out.printf("Yes");
      else System.out.printf("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPossible( a : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var cur : int ; cur := a[0+1] ;
     cur := cur - 1 ; 
         var i : int ; i := 1 ; while i < n do ( (     var nxt : int ; nxt := a[i+1] ;
     if (nxt > cur) then     nxt := nxt - 1 else     if (nxt < cur) then     return false else skip ; ;  
     cur := nxt )  ;     i := i + 1 ) ; 
     return true );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,1,2,3} ;
     var n : int ; n := a->size() ;
     if (isPossible(a, n)) then     OclFile["System.out"].printf("Yes") ; else     OclFile["System.out"].printf("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class x1183A {
  static int DigitsSum(int num){
    int digitsum=0 ;
    while(num>0){
      digitsum+=num % 10 ;
      num/=10 ;
    }
    return digitsum ;
  }
  public static void main(String[] args)throws IOException {
    InputStreamReader reader=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(reader);
    PrintWriter out=new PrintWriter(System.out);
    StringTokenizer token=new StringTokenizer("");
    InputReader scan=new InputReader(br,token);
    StringBuilder sb=new StringBuilder();
    int num=scan.nextInt();
    while(DigitsSum(num)% 4!=0)num++;
    sb.append(num);
    out.println(sb);
    out.flush();
    out.close();
  }
  static class InputReader {
    private BufferedReader readfile ;
    private StringTokenizer token ;
    InputReader(BufferedReader br,StringTokenizer st){
      this.readfile=br ;
      this.token=st ;
    }
    String next(){
      while(! this.token.hasMoreTokens()){
        try {
          token=new StringTokenizer(readfile.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return this.token.nextToken();
    }
    String nextLine()throws IOException {
      return readfile.readLine();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class x1183A {
  static   operation DigitsSum( num : int) : int
  pre: true
  post: true
  activity: (     var digitsum : int ; digitsum := 0 ;
     while (num > 0) do (     digitsum := digitsum+(num mod 10) ; 
     num := num/(10) ) ; 
     return digitsum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(reader) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var token : OclIterator ; token := OclIterator.newOclIterator_String("") ;
    var scan : InputReader ; scan := InputReader.newInputReader(br, token) ;
    var sb : String ; sb := StringLib.newString() ;
    var num : int ; num := scan.nextInt() ;
    while (DigitsSum(num) mod 4 /= 0) do     num := num + 1 ; ; 
    sb := sb + StringLib.newString(num) ; 
    skip ; 
    skip ; 
    skip ; 
 );
  static class InputReader {
   attribute readfile : OclFile;
   attribute token : OclIterator;
   static operation newInputReader( br : OclFile, st : OclIterator) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(br, st);
    return self );
  operation initialise( br : OclFile, st : OclIterator) : void
  pre: true  post: true
  activity: (     self.readfile := br ; 
     self.token := st );
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(self.token.hasNext())) do (     try (     token := OclIterator.newOclIterator_String(readfile.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return self.token.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return readfile.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class NearestInterestingNumber {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    while(true){
      int x=0 ;
      int m=n ;
      while(m>0){
        x+=m % 10 ;
        m/=10 ;
      }
      if(x % 4!=0){
        n++;
      }
      else {
        break ;
      }
    }
    System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class NearestInterestingNumber {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
     while (true) do (     var x : int ; x := 0 ;
     var m : int ; m := n ;
     while (m > 0) do (     x := x+(m mod 10) ; 
     m := m/(10) ) ; 
     if (x mod 4 /= 0) then (     n := n + 1 ) else (     break ) ) ; 
     OclFile["System.out"].println(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class NearestInterestingNumber {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    while(true){
      String S=String.valueOf(n);
      char[] A=S.toCharArray();
      int x=0 ;
      for(int i=0 ; i<A.length ; i++){
        x+=Character.getNumericValue(A[i]);
      }
      if(x % 4!=0){
        n++;
      }
      else {
        break ;
      }
    }
    System.out.println(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class NearestInterestingNumber {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
     while (true) do (     var S : String ; S := ((n) + "") ;
     var A : Sequence(String) ; A := S->characters() ;
    var x : int ; x := 0 ;
        var i : int ; i := 0 ; while i < A->size() do ( (     x := x+(("" + A[i+1])->toInteger()) )  ;     i := i + 1 ) ; 
    if (x mod 4 /= 0) then (     n := n + 1 ) else (     break ) ;  
 ) ; 
     OclFile["System.out"].println(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Test {
  static int sum_of_digit(int n){
    int sum=0 ;
    while(n>0){
      sum+=n % 10 ;
      n=n/10 ;
    }
    return sum ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    while(sum_of_digit(a)% 4!=0){
      a++;
    }
    System.out.println(a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Test {
  static   operation sum_of_digit( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n > 0) do (     sum := sum+(n mod 10) ; 
     n := n / 10 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     while (sum_of_digit(a) mod 4 /= 0) do (     a := a + 1 ) ; 
     OclFile["System.out"].println(a) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner s=new Scanner(System.in);
    int n=s.nextInt();
    boolean flag=true ;
    while(flag){
      int sum=sumf(n);
      if(sum % 4==0){
        flag=false ;
        System.out.println(n);
        break ;
      }
      n++;
    }
  }
  public static int sumf(int n){
    int sum=0 ;
    while(n>0){
      sum+=(n % 10);
      n/=10 ;
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := s.getCurrent()->toInteger() ;
     var flag : boolean ; flag := true ;
     while (flag) do (     var sum : int ; sum := sumf(n) ;
     if (sum mod 4 = 0) then (     flag := false ; 
     OclFile["System.out"].println(n) ; 
     break ) else skip ; 
     n := n + 1 ) );
  static   operation sumf( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n > 0) do (     sum := sum+((n mod 10)) ; 
     n := n/(10) ) ; 
     return sum );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] a=new int[n];
    boolean f=false ;
    boolean d=false ;
    boolean b=false ;
    int chest=0 ;
    int biceps=0 ;
    int back=0 ;
    for(int i=0 ; i<n ; i++){
      a[i]=in.nextInt();
      if(f==false){
        chest+=a[i];
        f=true ;
        d=true ;
      }
      else if(d==true){
        biceps+=a[i];
        b=true ;
        d=false ;
      }
      else if(b=true){
        back+=a[i];
        b=false ;
        f=false ;
      }
    }
    if(chest>biceps && chest>back){
      System.out.println("chest");
    }
    else if(biceps>chest && biceps>back){
      System.out.println("biceps");
    }
    else System.out.println("back");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var f : boolean ; f := false ;
    var d : boolean ; d := false ;
    var b : boolean ; b := false ;
    var chest : int ; chest := 0 ;
    var biceps : int ; biceps := 0 ;
    var back : int ; back := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() ; 
     if (f = false) then (     chest := chest+(a[i+1]) ; 
     f := true ; 
     d := true ) else     if (d = true) then (     biceps := biceps+(a[i+1]) ; 
     b := true ; 
     d := false ) else     if (b) then (     back := back+(a[i+1]) ; 
     b := false ; 
     f := false ) else skip ; ;  )  ;     i := i + 1 ) ; 
    if (chest > biceps & chest > back) then (     OclFile["System.out"].println("chest") ) else     if (biceps > chest & biceps > back) then (     OclFile["System.out"].println("biceps") ) else     OclFile["System.out"].println("back") ; ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int sum(int x,int y,int n){
    int sum1=(int)((Math.pow(x,2)*(Math.pow(x,2*n)-1))/(Math.pow(x,2)-1));
    int sum2=(int)((x*y*(Math.pow(x,n)*Math.pow(y,n)-1))/(x*y-1));
    return sum1+sum2 ;
  }
  public static void main(String args[]){
    int x=2,y=2,n=2 ;
    System.out.println(sum(x,y,n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sum( x : int, y : int, n : int) : int
  pre: true
  post: true
  activity: (     var sum1 : int ; sum1 := ((x->pow(2) * (x->pow(2 * n) - 1)) / (x->pow(2) - 1))->oclAsType(int) ;
     var sum2 : int ; sum2 := ((x * y * (x->pow(n) * y->pow(n) - 1)) / (x * y - 1))->oclAsType(int) ;
     return sum1 + sum2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 2 ;
    var y : int ; y := 2 ;
    var n : int ; n := 2 ;
     OclFile["System.out"].println(sum(x, y, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Problem_255A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int[] exercise=new int[3];
    int a ;
    for(int i=0 ; i<n ; i++){
      a=scanner.nextInt();
      exercise[i % 3]+=a ;
    }
    if(exercise[0]>exercise[1] && exercise[0]>exercise[2]){
      System.out.println("chest");
    }
    else if(exercise[1]>exercise[0] && exercise[1]>exercise[2]){
      System.out.println("biceps");
    }
    else {
      System.out.println("back");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Problem{
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var exercise : Sequence(int) ; exercise := Integer.subrange(1,3)->collect(0) ;
    var a : int ;
        var i : int ; i := 0 ; while i < n do ( (     a := scanner.getCurrent()->toInteger() ; 
     exercise[i mod 3+1] := exercise[i mod 3+1]+(a) )  ;     i := i + 1 ) ; 
    if (exercise[0+1] > exercise[1+1] & exercise[0+1] > exercise[2+1]) then (     OclFile["System.out"].println("chest") ) else     if (exercise[1+1] > exercise[0+1] & exercise[1+1] > exercise[2+1]) then (     OclFile["System.out"].println("biceps") ) else (     OclFile["System.out"].println("back") ) ;  ;  
 );
}
55A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var exercise : Sequence(int) ; exercise := Integer.subrange(1,3)->collect(0) ;
    var a : int ;
        var i : int ; i := 0 ; while i < n do ( (     a := scanner.getCurrent()->toInteger() ; 
     exercise[i mod 3+1] := exercise[i mod 3+1]+(a) )  ;     i := i + 1 ) ; 
    if (exercise[0+1] > exercise[1+1] & exercise[0+1] > exercise[2+1]) then (     OclFile["System.out"].println("chest") ) else     if (exercise[1+1] > exercise[0+1] & exercise[1+1] > exercise[2+1]) then (     OclFile["System.out"].println("biceps") ) else (     OclFile["System.out"].println("back") ) ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Solution {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a={
      0,0,0 };
      int max=a[0],maxI=0 ;
      String[] s={
        "chest","biceps","back" };
        for(int i=0 ; i<n ; i++){
          a[i % 3]+=sc.nextInt();
          if(a[i % 3]>max){
            max=a[i % 3];
            maxI=i % 3 ;
          }
        }
        System.out.println(s[maxI]);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Sequence{0,0,0} ;
    var max : int ; max := a[0+1] ;
    var maxI : int ; maxI := 0 ;
    var s : Sequence(String) ; s := Sequence{"chest","biceps","back"} ;
        var i : int ; i := 0 ; while i < n do ( (     a[i mod 3+1] := a[i mod 3+1]+(sc.getCurrent()->toInteger()) ; 
     if (a[i mod 3+1] > max) then (     max := a[i mod 3+1] ; 
     maxI := i mod 3 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(s[maxI+1]) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static void main(String[] args){
    final Scanner stdin=new Scanner(System.in);
    while(true){
      final int n=stdin.nextInt();
      if(n==0){
        break ;
      }
      final int[] val=new int[n];
      for(int i=0 ; i<n ; i++){
        val[i]=stdin.nextInt();
      }
      final int target=stdin.nextInt();
      int left=0 ;
      int right=n-1 ;
      int count=0 ;
      while(left<=right){
        final int middle=(left+right)/2 ;
        count++;
        if(target<val[middle]){
          right=middle-1 ;
        }
        else if(target>val[middle]){
          left=middle+1 ;
        }
        else {
          break ;
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := stdin.getCurrent()->toInteger() ;
     if (n = 0) then (     break ) else skip ; 
    var val : Sequence(int) ; val := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     val[i+1] := stdin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var target : int ; target := stdin.getCurrent()->toInteger() ;
    var left : int ; left := 0 ;
    var right : int ; right := n - 1 ;
    var count : int ; count := 0 ;
    while (left <= right) do (     var middle : int ; middle := (left + right) / 2 ;
     count := count + 1 ; 
     if (target < val[middle+1]) then (     right := middle - 1 ) else     if (target > val[middle+1]) then (     left := middle + 1 ) else (     break ) ;  ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test286 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    int c=0,bi=0,ba=0 ;
    for(int j=0 ; j<t ; j++){
      int x=in.nextInt();
      switch(j % 3){
        case 0 : c+=x ;
        break ;
        case 1 : bi+=x ;
        break ;
        default : ba+=x ;
      }
    }
    if(ba>bi){
      if(ba>c){
        System.out.println("back");
      }
      else {
        System.out.println("chest");
      }
    }
    else {
      if(bi>c){
        System.out.println("biceps");
      }
      else {
        System.out.println("chest");
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test286 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
    var c : int ; c := 0 ;
    var bi : int ; bi := 0 ;
    var ba : int ; ba := 0 ;
        var j : int ; j := 0 ; while j < t do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (j mod 3) ; 
       if _switchval = 0 then
     c := c+(x) ; 
    break 
   else skip ;
       if _switchval = 1 then
     bi := bi+(x) ; 
    break 
   else skip ;
       if true then
     ba := ba+(x) ; 
   else skip ;
 )
 )  ;     j := j + 1 ) ; 
    if (ba > bi) then (     if (ba > c) then (     OclFile["System.out"].println("back") ) else (     OclFile["System.out"].println("chest") ) ) else (     if (bi > c) then (     OclFile["System.out"].println("biceps") ) else (     OclFile["System.out"].println("chest") ) ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static String in ;
  public static void main(String[] args){
    while(read()){
      solve();
    }
  }
  static boolean read(){
    if(! sc.hasNext())return false ;
    in=sc.next();
    return true ;
  }
  static void solve(){
    StringBuffer sb=new StringBuffer(in);
    System.out.println(sb.reverse());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute in : String;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     while (read()) do (     execute solve() ) );
  static   operation read() : boolean
  pre: true
  post: true
  activity: (     if (not(sc.hasNext())) then     return false else skip ; 
     in := sc.getCurrent() ; 
     return true );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString(in) ;
     OclFile["System.out"].println(sb->reverse()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args){
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    String input ;
    try {
      input=reader.readLine();
      char[] inputCharArray=input.toCharArray();
      String out="" ;
      for(int i=0 ; i<inputCharArray.length ; i++){
        out+=inputCharArray[inputCharArray.length-1-i];
      }
      System.out.println(out);
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var input : String ;
     try (     input := reader.readLine() ; 
     var inputCharArray : Sequence(String) ; inputCharArray := input->characters() ;
    var out : String ; out := "" ;
        var i : int ; i := 0 ; while i < inputCharArray->size() do ( (     out := out+(inputCharArray[inputCharArray->size() - 1 - (i)->char2byte()+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(out) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  Scanner sc=new Scanner(in);
  String reverse(String s){
    String ans="" ;
    int len=s.length();
    for(int i=0 ; i<len ; i++)ans+=s.charAt(len-i-1);
    return ans ;
  }
  void run(){
    String s=sc.nextLine();
    out.println(reverse(s));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   operation reverse( s : String) : String
  pre: true
  post: true
  activity: (     var ans : String ; ans := "" ;
     var len : int ; len := s->size() ;
         var i : int ; i := 0 ; while i < len do (     ans := ans+(s->at((len)->char2byte() - i - 1+1)) ;  ;     i := i + 1 ) ; 
     return ans );
   operation run() : void
  pre: true
  post: true
  activity: (     var s : String ; s := sc.nextLine() ;
     out.println(reverse(s)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args)throws java.io.IOException {
    reverse();
  }
  public static void reverse()throws IOException {
    BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
    String str=input.readLine();
    String[] strs=str.split("\\B");
    String restr="" ;
    for(int i=(strs.length)-1 ; i>=0 ; i--){
      restr+=strs[i];
    }
    System.out.println(restr);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute reverse() );
  static   operation reverse() : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : String ; str := input.readLine() ;
    var strs : Sequence(String) ; strs := str->split("\\B") ;
    var restr : String ; restr := "" ;
        var i : int ; i := (strs->size()) - 1 ; while i >= 0 do ( (     restr := restr+(strs[i+1]) )  ;     i := i - 1 ) ; 
    OclFile["System.out"].println(restr) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.lang.StringBuilder ;
class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    final StringBuilder sb=new StringBuilder(sc.next());
    System.out.println(sb.reverse());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString(sc.getCurrent()) ;
     OclFile["System.out"].println(sb->reverse()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void findMajority(int arr[],int n){
    int maxCount=0 ;
    int index=-1 ;
    for(int i=0 ; i<n ; i++){
      int count=0 ;
      for(int j=0 ; j<n ; j++){
        if(arr[i]==arr[j])count++;
      }
      if(count>maxCount){
        maxCount=count ;
        index=i ;
      }
    }
    if(maxCount>n/2)System.out.println(arr[index]);
    else System.out.println("No Majority Element");
  }
  public static void main(String[] args){
    int arr[]={
      1,1,2,1,3,5,1 };
      int n=arr.length ;
      findMajority(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findMajority( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var maxCount : int ; maxCount := 0 ;
     var index : int ; index := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     var count : int ; count := 0 ;
         var j : int ; j := 0 ; while j < n do ( (     if (arr[i+1] = arr[j+1]) then     count := count + 1 ; else skip )  ;     j := j + 1 ) ; 
     if (count > maxCount) then (     maxCount := count ; 
     index := i ) else skip )  ;     i := i + 1 ) ; 
     if (maxCount > n / 2) then     OclFile["System.out"].println(arr[index+1]) ; else     OclFile["System.out"].println("No Majority Element") ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,2,1,3,5,1} ;
     var n : int ; n := arr->size() ;
     execute findMajority(arr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int findSum(int n){
    n--;
    int sum=0 ;
    sum+=(n*(n+1))/2 ;
    sum+=(n*(n+1)*(2*n+1))/6 ;
    return sum ;
  }
  static public void main(String[] args){
    int n=3 ;
    System.out.println(findSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findSum( n : int) : int
  pre: true
  post: true
  activity: (     n := n - 1 ; 
     var sum : int ; sum := 0 ;
    sum := sum+((n * (n + 1)) / 2) ; 
    sum := sum+((n * (n + 1) * (2 * n + 1)) / 6) ; 
    return sum 
 );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
     OclFile["System.out"].println(findSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int num=0 ;
    for(int i=0 ; i<4 ; i++){
      num+=sc.nextInt();
    }
    System.out.println(num/60);
    System.out.println(num % 60);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var num : int ; num := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     num := num+(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(num / 60) ; 
    OclFile["System.out"].println(num mod 60) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static int c ;
  static int[] a ;
  static int comp(int k,int x){
    c++;
    return a[k]-x ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      if(n==0)break ;
      a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      int x=sc.nextInt();
      c=0 ;
      int l=0 ;
      int r=n-1 ;
      int k=(l+r)/2 ;
      while(l<=r){
        int com=comp(k,x);
        if(r<=l)break ;
        if(com<0)l=k+1 ;
        else if(com>0)r=k-1 ;
        else break ;
        k=(l+r)/2 ;
      }
      System.out.println(c);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute c : int;
  static   attribute a : Sequence(int);
  static   operation comp( k : int, x : int) : int
  pre: true
  post: true
  activity: (     c := c + 1 ; 
     return a[k+1] - x );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    a := Integer.subrange(1,n)->collect(0) ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var x : int ; x := sc.getCurrent()->toInteger() ;
    c := 0 ; 
    var l : int ; l := 0 ;
    var r : int ; r := n - 1 ;
    var k : int ; k := (l + r) / 2 ;
    while (l <= r) do (     var com : int ; com := comp(k, x) ;
     if (r <= l) then     break else skip ; 
     if (com < 0) then     l := k + 1 else     if (com > 0) then     r := k - 1 else     break ;  ;  
     k := (l + r) / 2 ) ; 
    OclFile["System.out"].println(c) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.UncheckedIOException ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    SC sc=new SC(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    int C=sc.nextInt();
    int D=sc.nextInt();
    int sum=(A+B+C+D);
    pl(sum/60);
    pl(sum % 60);
  }
  public static void pl(Object o){
    System.out.println(o);
  }
  public static void pl(){
    System.out.println();
  }
  public static void p(Object o){
    System.out.print(o);
  }
  static class SC {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public SC(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String next(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      try {
        return reader.readLine();
      }
      catch(IOException e){
        throw new UncheckedIOException(e);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : SC ; sc := SC.newSC(OclFile["System.in"]) ;
     var A : int ; A := sc.nextInt() ;
    var B : int ; B := sc.nextInt() ;
    var C : int ; C := sc.nextInt() ;
    var D : int ; D := sc.nextInt() ;
    var sum : int ; sum := (A + B + C + D) ;
    execute pl(sum / 60) ; 
    execute pl(sum mod 60) ; 
 );
  static   operation pl( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(o) );
  static   operation pl() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println() );
  static   operation p( o : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print(o) );
  static class SC {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newSC( in : OclFile) : SC
  pre: true
  post: true
  activity:
  ( var self : SC ;
    self := createSC();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     try (     return reader.readLine() )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int t=0 ;
    for(; sc.hasNext(); )t+=sc.nextInt();
    out.printf("%d%n%d%n",t/60,t % 60);
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var t : int ; t := 0 ;
      while sc.hasNext() do (     t := t+(sc.nextInt()) ;  ) ; 
    out.printf("%d%n%d%n", t / 60, t mod 60) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  boolean main()throws IOException {
    int a=readIntArray()[0];
    int b=readIntArray()[0];
    int c=readIntArray()[0];
    int d=readIntArray()[0];
    int sum=a+b+c+d ;
    System.out.printf("%d\n%d\n",sum/60,sum % 60);
    return false ;
  }
  private final static boolean DEBUG=false ;
  public static void main(String[] args)throws IOException {
    if(DEBUG){
      log=System.out ;
      String inputStr="3:Cyan Yellow Red Magenta Green Blue:Cyan Yellow Red Magenta Green Blue:Red Yellow Magenta Blue Green Cyan:0:" ;
      inputStr=inputStr.replace(":","\n");
      reader=new BufferedReader(new StringReader(inputStr));
    }
    else {
      log=new PrintStream(new OutputStream(){
        public void write(int b){
        }
      }
);
      reader=new BufferedReader(new InputStreamReader(System.in));
    }
    int N=Integer.MAX_VALUE ;
    for(int i=0 ; i<N ; i++){
      boolean b=new Main().main();
      if(! b)break ;
    }
    reader.close();
  }
  static PrintStream log ;
  static BufferedReader reader ;
  private static int[] readIntArray()throws IOException {
    String s=null ;
    for(; ; ){
      s=reader.readLine();
      if(s==null)return null ;
      s=s.trim();
      if(s.length()!=0)break ;
    }
    String[] sp=s.split("[,] ");
    int[] a=new int[sp.length];
    for(int i=0 ; i<sp.length ; i++){
      a[i]=Integer.parseInt(sp[i]);
    }
    return a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main() : boolean
  pre: true
  post: true
  activity: (     var a : int ; a := readIntArray()[0+1] ;
     var b : int ; b := readIntArray()[0+1] ;
    var c : int ; c := readIntArray()[0+1] ;
    var d : int ; d := readIntArray()[0+1] ;
    var sum : int ; sum := a + b + c + d ;
    OclFile["System.out"].printf("%d\n%d\n", sum / 60, sum mod 60) ; 
    return false 
 );
  static   attribute DEBUG : boolean := false;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (DEBUG) then (     log := OclFile["System.out"] ; 
     var inputStr : String ; inputStr := "3:Cyan Yellow Red Magenta Green Blue:Cyan Yellow Red Magenta Green Blue:Red Yellow Magenta Blue Green Cyan:0:" ;
     inputStr := inputStr.replace(":", "\n") ; 
     reader := OclFile.newOclFile_Read(StringReader.newStringReader(inputStr)) ) else (     log := OclFile.newOclFile_Write(OclFile()) ; 
     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ) ;  
     var N : int ; N := 2147483647 ;
         var i : int ; i := 0 ; while i < N do ( (     var b : boolean ; b := Main.newMain().main() ;
     if (not(b)) then     break else skip )  ;     i := i + 1 ) ; 
     reader.close() );
  static   attribute log : OclFile;
  static   attribute reader : OclFile;
  static   operation readIntArray() : Sequence(int)
  pre: true
  post: true
  activity: (     var s : String ; s := null ;
       while true do ( (     s := reader.readLine() ; 
     if (s = null) then     return null else skip ; 
     s := s->trim() ; 
     if (s->size() /= 0) then     break else skip )  ) ; 
    var sp : Sequence(String) ; sp := s->split("[,] ") ;
    var a : Sequence(int) ; a := Integer.subrange(1,sp->size())->collect(0) ;
        var i : int ; i := 0 ; while i < sp->size() do ( (     a[i+1] := (sp[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    return a 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    try(Scanner scn=new Scanner(System.in)){
      int sum=scn.nextInt()+scn.nextInt()+scn.nextInt()+scn.nextInt();
      System.out.println(sum/60);
      System.out.println(sum % 60);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var scn : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var sum : int ; sum := scn.getCurrent()->toInteger() + scn.getCurrent()->toInteger() + scn.getCurrent()->toInteger() + scn.getCurrent()->toInteger() ;
     OclFile["System.out"].println(sum / 60) ; 
     OclFile["System.out"].println(sum mod 60) ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class B224 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    int K=in.nextInt();
    int[] A=new int[N];
    for(int n=0 ; n<N ; n++){
      A[n]=in.nextInt();
    }
    Set<Integer>set=new HashSet<>();
    int r=0 ;
    while(r<N && set.size()<K){
      set.add(A[r++]);
    }
    r--;
    if(set.size()==K){
      set.clear();
      int l=r ;
      while(set.size()<K){
        set.add(A[l--]);
      }
      l++;
      System.out.println((l+1)+" "+(r+1));
    }
    else {
      System.out.println("-1-1");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B224 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var K : int ; K := in.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     A[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var set : Set(int) ; set := Set{} ;
    var r : int ; r := 0 ;
    while (r < N & set->size() < K) do (     set := set->including(A[r+1]) ) ; 
    r := r - 1 ; 
    if (set->size() = K) then (     set := set->intersection(Set{}) ; 
     var l : int ; l := r ;
    while (set->size() < K) do (     set := set->including(A[l+1]) ) ; 
    l := l + 1 ; 
    OclFile["System.out"].println((l + 1) + " " + (r + 1)) ; 
 ) else (     OclFile["System.out"].println("-1-1") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.HashMap ;
import java.util.Map ;
public class Array {
  public static void main(String args[])throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    String ln1[]=reader.readLine().split(" ");
    String arr[]=reader.readLine().split(" ");
    int n=Integer.parseInt(ln1[0]);
    int k=Integer.parseInt(ln1[1]);
    Map<String,Integer>map=new HashMap<>();
    int i=0 ;
    while(i<n){
      map.put(arr[i],map.getOrDefault(arr[i],0)+1);
      i++;
    }
    if(map.size()>=k){
      int l=0 ;
      int r=n-1 ;
      while(true){
        if(map.get(arr[r]).compareTo(1)!=0 || map.size()>k){
          map.put(arr[r],map.get(arr[r])-1);
          if(map.get(arr[r]).compareTo(0)==0)map.remove(arr[r]);
          r--;
        }
        else if(map.get(arr[l]).compareTo(1)!=0 || map.size()>k){
          map.put(arr[l],map.get(arr[l])-1);
          if(map.get(arr[l]).compareTo(0)==0)map.remove(arr[l]);
          l++;
        }
        else {
          System.out.println((l+1)+" "+(r+1));
          break ;
        }
      }
    }
    else {
      System.out.println("-1-1 ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Array {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var ln1 : Sequence(String) ; ln1 := reader.readLine()->split(" ") ;
    var arr : Sequence(String) ; arr := reader.readLine()->split(" ") ;
    var n : int ; n := (ln1[0+1])->toInteger() ;
    var k : int ; k := (ln1[1+1])->toInteger() ;
    var map : Map(String,int) ; map := Map{} ;
    var i : int ; i := 0 ;
    while (i < n) do (     map := map->union(Map{arr[i+1] |-> (if map->keys()->contains(arr[i+1]) then map->at(arr[i+1]) else 0 endif) + 1}) ; 
     i := i + 1 ) ; 
    if (map.size() >= k) then (     var l : int ; l := 0 ;
     var r : int ; r := (n)->char2byte() - 1 ;
     while (true) do (     if (map->at(arr[r+1])->compareTo(1) /= 0 or map.size() > k) then (     map := map->union(Map{arr[r+1] |-> map->at(arr[r+1]) - 1}) ; 
     if (map->at(arr[r+1])->compareTo(0) = 0) then     map := map->antirestrict(Set{arr[r+1]}) ; else skip ; 
     r := r - 1 ) else     if (map->at(arr[l+1])->compareTo(1) /= 0 or map.size() > k) then (     map := map->union(Map{arr[l+1] |-> map->at(arr[l+1]) - 1}) ; 
     if (map->at(arr[l+1])->compareTo(0) = 0) then     map := map->antirestrict(Set{arr[l+1]}) ; else skip ; 
     l := l + 1 ) else (     OclFile["System.out"].println((l + 1) + " " + (r + 1)) ; 
     break ) ;  ) ) else (     OclFile["System.out"].println("-1-1 ") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int getSum(int n){
    int sum=0 ;
    while(n!=0){
      sum=sum+n % 10 ;
      n=n/10 ;
    }
    return sum ;
  }
  public static void main(String[] args){
    int n=687 ;
    System.out.println(getSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     while (n /= 0) do (     sum := sum + n mod 10 ; 
     n := n / 10 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 687 ;
     OclFile["System.out"].println(getSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Array {
  private static int[] a=new int[111111];
  private static int[] count=new int[111111];
  private static int cnt ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int j=0 ;
    int n=sc.nextInt();
    int k=sc.nextInt();
    for(int i=1 ; i<=n ; i++)a[i]=sc.nextInt();
    for(int i=1 ; i<=n ; i++){
      count[a[i] ]++;
      if(count[a[i] ]==1)cnt++;
      while(cnt==k){
        j++;
        count[a[j] ]--;
        if(count[a[j] ]==0){
          System.out.println(j+" "+i);
          return ;
        }
      }
    }
    if(cnt!=k)System.out.println("-1-1");
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Array {
  static   attribute a : Sequence(int) := Integer.subrange(1,111111)->collect(0);
  static   attribute count : Sequence(int) := Integer.subrange(1,111111)->collect(0);
  static   attribute cnt : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var j : int ; j := 0 ;
    var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= n do ( (     count[a[i+1]+1] := count[a[i+1]+1] + 1 ; 
     if (count[a[i+1]+1] = 1) then     cnt := cnt + 1 ; else skip ; 
     while (cnt = k) do (     j := j + 1 ; 
     count[a[j+1]+1] := count[a[j+1]+1] - 1 ; 
     if (count[a[j+1]+1] = 0) then (     OclFile["System.out"].println(j + " " + i) ; 
     return ) else skip ) )  ;     i := i + 1 ) ; 
    if (cnt /= k) then     OclFile["System.out"].println("-1-1") ; else skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet ;
import java.util.Scanner ;
public class Array {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    if(scanner.hasNext()){
      int n=scanner.nextInt();
      int k=scanner.nextInt();
      HashSet<Integer>set=new HashSet<>();
      HashSet<Integer>set2=new HashSet<>();
      int arr[]=new int[n];
      for(int i=0 ; i<n ; i++){
        arr[i]=scanner.nextInt();
      }
      int t=-2,x=-2 ;
      for(int i=0 ; i<n ; i++){
        set.add(arr[i]);
        if(set.size()==k){
          t=i ;
          break ;
        }
      }
      for(int j=t ; j>=0 ; j--){
        set2.add(arr[j]);
        if(set2.size()==k){
          x=j ;
          break ;
        }
      }
++x ;
++t ;
      System.out.println(x+" "+t);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Array {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     if (scanner.hasNext()) then (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var k : int ; k := scanner.getCurrent()->toInteger() ;
    var set : Set(int) ; set := Set{} ;
    var set2 : Set(int) ; set2 := Set{} ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var t : int ; t := -2 ;
    var x : int ; x := -2 ;
        var i : int ; i := 0 ; while i < n do ( (     set := set->including(arr[i+1]) ; 
     if (set->size() = k) then (     t := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
        var j : int ; j := t ; while j >= 0 do ( (     set2 := set2->including(arr[j+1]) ; 
     if (set2->size() = k) then (     x := j ; 
     break ) else skip )  ;     j := j - 1 ) ; 
    x := x + 1 ; 
    t := t + 1 ; 
    OclFile["System.out"].println(x + " " + t) ; 
 ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    solution(n,k,arr);
  }
  private static void solution(int n,int k,int[] arr){
    int[] freq=new int[100005];
    int numDiff=0 ;
    int left=-1 ;
    int right=-1 ;
    for(int i=0 ; i<n ; i++){
      freq[arr[i] ]+=1 ;
      if(freq[arr[i] ]==1){
        numDiff++;
      }
      if(numDiff==k){
        right=i ;
        for(left=0 ; left<=right ; left++){
          freq[arr[left] ]--;
          if(freq[arr[left] ]==0){
            System.out.println((left+1)+" "+(right+1));
            return ;
          }
        }
      }
    }
    System.out.println("-1-1");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    execute solution(n, k, arr) ; 
 );
  static   operation solution( n : int, k : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,100005)->collect(0) ;
     var numDiff : int ; numDiff := 0 ;
    var left : int ; left := -1 ;
    var right : int ; right := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     freq[arr[i+1]+1] := freq[arr[i+1]+1]+(1) ; 
     if (freq[arr[i+1]+1] = 1) then (     numDiff := numDiff + 1 ) else skip ; 
     if (numDiff = k) then (     right := i ; 
         left := 0 ; while left <= right do ( (     freq[arr[left+1]+1] := freq[arr[left+1]+1] - 1 ; 
     if (freq[arr[left+1]+1] = 0) then (     OclFile["System.out"].println((left + 1) + " " + (right + 1)) ; 
     return ) else skip )  ;     left := left + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("-1-1") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc ;
  int search(int[] array,int n,int l,int r,int d){
    if(l>r)return d ;
++d ;
    int m=(r+l)/2 ;
    if(array[m]>n)return search(array,n,l,m-1,d);
    else if(array[m]<n)return search(array,n,m+1,r,d);
    else return d ;
  }
  int ni(){
    return sc.nextInt();
  }
  void io(){
    sc=new Scanner(System.in);
    int[] array ;
    int n ;
    while((n=ni())!=0){
      array=new int[n];
      for(int i=0 ; i<n ; ++i){
        array[i]=ni();
      }
      int number=ni();
      System.out.println(search(array,number,0,n-1,0));
    }
    sc.close();
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().io();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile;
   operation search( array : Sequence(int), n : int, l : int, r : int, d : int) : int
  pre: true
  post: true
  activity: (     if (l > r) then     return d else skip ; 
     d := d + 1 ; 
     var m : int ; m := (r + l) / 2 ;
     if (array[m+1] > n) then     return search(array, n, l, m - 1, d) else     if (array[m+1] < n) then     return search(array, n, m + 1, r, d) else     return d ;  );
   operation ni() : int
  pre: true
  post: true
  activity: (     return sc.getCurrent()->toInteger() );
   operation io() : void
  pre: true
  post: true
  activity: (     sc := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var array : Sequence(int) ;
    var n : int ;
        n := ni() ;
    while ((n) /= 0) do (    skip ; (     array := Integer.subrange(1,n)->collect(0) ; 
         var i : int ; i := 0 ; while i < n do ( (     array[i+1] := ni() )  ;     i := i + 1 ) ; 
     var number : int ; number := ni() ;
     OclFile["System.out"].println(search(array, number, 0, n - 1, 0)) ) ;     n := ni() ;
 ) ;  
    skip ; 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().io() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  static int n ;
  public static void main(String args[])throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    n=Integer.parseInt(br.readLine());
    long edge[][]=new long[n][n];
    for(int i=0 ; i<n ; i++){
      String str[]=br.readLine().split(" ");
      for(int j=0 ; j<n ; j++){
        edge[i][j]=Long.parseLong(str[j]);
      }
    }
    for(int k=0 ; k<n ; k++){
      for(int i=0 ; i<n ; i++){
        if(edge[i][k]==0)continue ;
        for(int j=0 ; j<n ; j++){
          if(edge[j][k]==0)continue ;
          if(edge[i][k]+edge[k][j]<edge[i][j]){
            System.out.println(-1);
            return ;
          }
          if(edge[i][k]+edge[k][j]==edge[i][j]){
            edge[i][j]=0 ;
            edge[j][i]=0 ;
          }
        }
      }
    }
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        ans+=edge[i][j];
      }
    }
    System.out.println(ans/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute n : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     n := (br.readLine())->toInteger() ; 
    var edge : Sequence(Sequence(long)) ; edge := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
         var j : int ; j := 0 ; while j < n do ( (     edge[i+1][j+1] := (str[j+1])->toLong() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < n do ( (         var i : int ; i := 0 ; while i < n do ( (     if (edge[i+1][k+1] = 0) then     continue else skip ; 
         var j : int ; j := 0 ; while j < n do ( (     if (edge[j+1][k+1] = 0) then     continue else skip ; 
     if (edge[i+1][k+1] + edge[k+1][j+1] < edge[i+1][j+1]) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
     if (edge[i+1][k+1] + edge[k+1][j+1] = edge[i+1][j+1]) then (     edge[i+1][j+1] := 0 ; 
     edge[j+1][i+1] := 0 ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     ans := ans+(edge[i+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[][] iay=new long[n][n];
    HashSet<String>isyoul=new HashSet<String>();
    isyoul.add("end");
    long rt=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        iay[i][j]=sc.nextLong();
        rt+=iay[i][j];
      }
    }
    for(int x=0 ; x<n ; x++){
      for(int y=0 ; y<n ; y++){
        for(int z=0 ; z<n ; z++){
          if(x==y || y==z || x==z){
            continue ;
          }
          if(iay[y][z]>iay[y][x]+iay[x][z]){
            rt=-1 ;
            x=n ;
            y=n ;
            break ;
          }
          else if(iay[y][z]==iay[y][x]+iay[x][z]){
            isyoul.add(y+","+z);
          }
        }
      }
    }
    if(rt!=-1){
      ArrayList<String>iisyoul=new ArrayList<>(isyoul);
      Collections.sort(iisyoul);
      for(int k=0 ; ; k++){
        String ibx=iisyoul.get(k);
        if(ibx=="end"){
          break ;
        }
        String[] spsibx=new String[2];
        spsibx=ibx.split(",");
        rt-=iay[Integer.parseInt(spsibx[0])][Integer.parseInt(spsibx[1])];
      }
      rt/=2 ;
    }
    System.out.println(rt);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var iay : Sequence(Sequence(long)) ; iay := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var isyoul : Set(String) ; isyoul := Set{} ;
    isyoul := isyoul->including("end") ; 
    var rt : long ; rt := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     iay[i+1][j+1] := sc.getCurrent()->toLong() ; 
     rt := rt+(iay[i+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var x : int ; x := 0 ; while x < n do ( (         var y : int ; y := 0 ; while y < n do ( (         var z : int ; z := 0 ; while z < n do ( (     if (x = y or y = z or x = z) then (     continue ) else skip ; 
     if (iay[y+1][z+1] > iay[y+1][x+1] + iay[x+1][z+1]) then (     rt := -1 ; 
     x := n ; 
     y := n ; 
     break ) else     if (iay[y+1][z+1] = iay[y+1][x+1] + iay[x+1][z+1]) then (     isyoul := isyoul->including(y + "," + z) ) else skip ; )  ;     z := z + 1 ) )  ;     y := y + 1 ) )  ;     x := x + 1 ) ; 
    if (rt /= -1) then (     var iisyoul : Sequence(String) ; iisyoul := Sequence{}->union(isyoul) ;
     iisyoul := iisyoul->sort() ; 
         var k : int ; k := 0 ; while true do ( (     var ibx : String ; ibx := iisyoul->at(k+1) ;
     if (ibx = "end") then (     break ) else skip ; 
    var spsibx : Sequence(String) ; spsibx := Integer.subrange(1,2)->collect(null) ;
    spsibx := ibx->split(",") ; 
    rt := rt-(iay[(spsibx[0+1])->toInteger()+1][(spsibx[1+1])->toInteger()+1]) ; 
 )  ;     k := k + 1 ) ; 
     rt := rt/(2) ) else skip ; 
    OclFile["System.out"].println(rt) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public void main(Scanner sc){
    int n=sc.nextInt();
    long map[][]=new long[n][n];
    long minCost[][]=new long[n][n];
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        map[i][j]=sc.nextInt();
        minCost[i][j]=map[i][j];
      }
    }
    for(int k=0 ; k<n ; k++){
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          map[i][j]=Math.min(map[i][j],map[i][k]+map[k][j]);
        }
      }
    }
    long sum=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=i+1 ; j<n ; j++){
        if(map[i][j]!=minCost[i][j]){
          System.out.println(-1);
          System.exit(0);
        }
        boolean res=false ;
        for(int k=0 ; k<n ; k++){
          if(i==k || j==k){
            continue ;
          }
          if(map[i][j]==map[i][k]+map[k][j]){
            res=true ;
            break ;
          }
        }
        if(! res){
          sum+=map[i][j];
        }
      }
    }
    System.out.println(sum);
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    new Main().main(sc);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation main( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var map : Sequence(Sequence(long)) ; map := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
    var minCost : Sequence(Sequence(long)) ; minCost := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     map[i+1][j+1] := sc.nextInt() ; 
     minCost[i+1][j+1] := map[i+1][j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var k : int ; k := 0 ; while k < n do ( (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     map[i+1][j+1] := Set{map[i+1][j+1], map[i+1][k+1] + map[k+1][j+1]}->min() )  ;     j := j + 1 ) )  ;     i := i + 1 ) )  ;     k := k + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := i + 1 ; while j < n do ( (     if (map[i+1][j+1] /= minCost[i+1][j+1]) then (     OclFile["System.out"].println(-1) ; 
 OclProcess.exit(0) ) else skip ; 
     var res : boolean ; res := false ;
         var k : int ; k := 0 ; while k < n do ( (     if (i = k or j = k) then (     continue ) else skip ; 
     if (map[i+1][j+1] = map[i+1][k+1] + map[k+1][j+1]) then (     res := true ; 
     break ) else skip )  ;     k := k + 1 ) ; 
     if (not(res)) then (     sum := sum+(map[i+1][j+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Main.newMain().main(sc) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    long[][] A=new long[N][N];
    long[][] B=new long[N][N];
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        A[i][j]=sc.nextInt();
        B[i][j]=A[i][j];
      }
    }
    long ans=0 ;
    ;
    for(int i=0 ; i<N ; i++){
      for(int j=0 ; j<N ; j++){
        for(int k=0 ; k<N ; k++){
          if(A[i][j]+A[i][k]<A[j][k] || Math.abs(A[i][j]-A[i][k])>A[j][k]){
            ans=-1 ;
            break ;
          }
          else if(A[i][j]+A[j][k]==A[i][k] && j!=k && j!=i && i!=k){
            B[i][k]=0 ;
          }
        }
      }
    }
    if(ans==0){
      for(int i=0 ; i<N ; i++){
        for(int j=0 ; j<N ; j++){
          ans+=B[i][j];
        }
      }
      ans/=2 ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var A : Sequence(Sequence(long)) ; A := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
    var B : Sequence(Sequence(long)) ; B := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     A[i+1][j+1] := sc.getCurrent()->toInteger() ; 
     B[i+1][j+1] := A[i+1][j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (         var k : int ; k := 0 ; while k < N do ( (     if (A[i+1][j+1] + A[i+1][k+1] < A[j+1][k+1] or if A[i+1][j+1] - A[i+1][k+1] < 0 then -(A[i+1][j+1] - A[i+1][k+1]) else A[i+1][j+1] - A[i+1][k+1] endif > A[j+1][k+1]) then (     ans := -1 ; 
     break ) else     if (A[i+1][j+1] + A[j+1][k+1] = A[i+1][k+1] & j /= k & j /= i & i /= k) then (     B[i+1][k+1] := 0 ) else skip ; )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    if (ans = 0) then (         var i : int ; i := 0 ; while i < N do ( (         var j : int ; j := 0 ; while j < N do ( (     ans := ans+(B[i+1][j+1]) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     ans := ans/(2) ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public boolean Check_is_possible(int l,int r,int k){
    int count=0 ;
    for(int i=l ; i<=r ; i++){
      if(i % k==0){
        count++;
      }
    }
    return(count>1);
  }
  public static void main(String[] args){
    GFG g=new GFG();
    int l=4,r=12 ;
    int k=5 ;
    if(g.Check_is_possible(l,r,k)){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
   operation Check_is_possible( l : int, r : int, k : int) : boolean
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := l ; while i <= r do ( (     if (i mod k = 0) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
     return (count > 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var g : GFG ; g := GFG.newGFG() ;
     var l : int ; l := 4 ;
    var r : int ; r := 12 ;
     var k : int ; k := 5 ;
     if (g.Check_is_possible(l, r, k)) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int getSum(int n){
    int sum ;
    for(sum=0 ; n>0 ; sum+=n % 10,n/=10);
    return sum ;
  }
  public static void main(String[] args){
    int n=687 ;
    System.out.println(getSum(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation getSum( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ;
         sum := 0 ; while n > 0 do (   ;     sum := sum+(n mod 10) ;     n := n/(10) ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 687 ;
     OclFile["System.out"].println(getSum(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    sc.close();
    long[] num=new long[k];
    for(int i=1 ; i<=n ; i++){
      num[i % k]++;
    }
    long ans=0 ;
    for(int a=0 ; a<k ; a++){
      int b=(k-a)% k ;
      int c=(k-a)% k ;
      if((b+c)% k!=0){
        continue ;
      }
      ans+=num[a]*num[b]*num[c];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    skip ; 
    var num : Sequence(long) ; num := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     num[i mod k+1] := num[i mod k+1] + 1 )  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
        var a : int ; a := 0 ; while a < k do ( (     var b : int ; b := (k - a) mod k ;
     var c : int ; c := (k - a) mod k ;
     if ((b + c) mod k /= 0) then (     continue ) else skip ; 
     ans := ans+(num[a+1] * num[b+1] * num[c+1]) )  ;     a := a + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
class Main {
  public static void main(String...args){
    long N=IN.nextLong();
    long K=IN.nextLong();
    long num=N/K ;
    if(K % 2==1){
      puts(num*num*num);
    }
    else {
      long tmp=(N+K/2)/K ;
      puts(num*num*num+tmp*tmp*tmp);
    }
    flush();
  }
  static final Scanner IN=new Scanner(System.in);
  static final PrintWriter OUT=new PrintWriter(System.out);
  static<T>void puts(T arg){
    OUT.println(arg);
  }
  static void flush(){
    OUT.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := IN.nextLong() ;
     var K : long ; K := IN.nextLong() ;
    var num : long ; num := N / K ;
    if (K mod 2 = 1) then (     execute puts(num * num * num) ) else (     var tmp : long ; tmp := (N + K / 2) / K ;
     execute puts(num * num * num + tmp * tmp * tmp) ) ;  
    execute flush() ; 
 );
  static    attribute IN : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static    attribute OUT : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation puts<T>( arg : T) : void
  pre: true
  post: true
  activity: (     skip );
  static   operation flush() : void
  pre: true
  post: true
  activity: (     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    long n=sc.nextLong();
    long k=sc.nextLong();
    long ans=0L ;
    long kMulNum=n/k ;
    ans+=kMulNum*kMulNum*kMulNum ;
    if(k % 2L==0L){
      long rHalfKNum=(k*kMulNum+k/2<=n)? kMulNum : kMulNum-1 ;
      ans+=(rHalfKNum+1)*(rHalfKNum+1)*(rHalfKNum+1);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.getCurrent()->toLong() ;
     var k : long ; k := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 0L ;
    var kMulNum : long ; kMulNum := n / k ;
    ans := ans+(kMulNum * kMulNum * kMulNum) ; 
    if (k mod 2L = 0L) then (     var rHalfKNum : long ; rHalfKNum := if (k * kMulNum + k / 2 <= n) then kMulNum else kMulNum - 1 endif ;
     ans := ans+((rHalfKNum + 1) * (rHalfKNum + 1) * (rHalfKNum + 1)) ) else skip ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long n=scanner.nextLong();
    long k=scanner.nextLong();
    scanner.close();
    if(k % 2==0){
      System.out.println((n/k)*(n/k)*(n/k)+((n % k<k/2)? n/k : n/k+1)*((n % k<k/2)? n/k : n/k+1)*((n % k<k/2)? n/k : n/k+1));
    }
    else {
      System.out.println((n/k)*(n/k)*(n/k));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := scanner.getCurrent()->toLong() ;
    var k : long ; k := scanner.getCurrent()->toLong() ;
    skip ; 
    if (k mod 2 = 0) then (     OclFile["System.out"].println((n / k) * (n / k) * (n / k) + (if (n mod k < k / 2) then n / k else n / k + 1 endif) * (if (n mod k < k / 2) then n / k else n / k + 1 endif) * (if (n mod k < k / 2) then n / k else n / k + 1 endif)) ) else (     OclFile["System.out"].println((n / k) * (n / k) * (n / k)) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int k=scan.nextInt();
    long sum=0 ;
    for(int i=1 ; i<=k ; i++){
      int a=i ;
      int b=k-i ;
      if((((2*b)% k)!=0)||(b>n)||(b<0)){
        continue ;
      }
      if(b==0){
        b=a ;
      }
      sum+=(long)((long)find(a,n,k))*((long)find(b,n,k))*((long)find(b,n,k));
    }
    System.out.println(sum);
  }
  static int find(int start,int n,int k){
    int count=0 ;
    while(start<=n){
      start+=k ;
      count+=1 ;
    }
    return count ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var k : int ; k := scan.getCurrent()->toInteger() ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 1 ; while i <= k do ( (     var a : int ; a := i ;
     var b : int ; b := k - i ;
    if ((((2 * b) mod k) /= 0) or (b > n) or (b < 0)) then (     continue ) else skip ; 
    if (b = 0) then (     b := a ) else skip ; 
    sum := sum+((find(a, n, k)->oclAsType(long))->oclAsType(long) * (find(b, n, k)->oclAsType(long)) * (find(b, n, k)->oclAsType(long))) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
  static   operation find( start : int, n : int, k : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
     while (start <= n) do (     start := start+(k) ; 
     count := count+(1) ) ; 
     return count );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static BufferedReader br=null ;
  static {
    br=new BufferedReader(new InputStreamReader(System.in));
  }
  public static void main(String[] args){
    int[] tbl=new int[100+1];
    int num=0 ;
    while((num=parseNum())!=0){
      for(int i=0 ; i<=num ; i++){
        tbl[i]=parseNum();
      }
      solve(tbl,num);
    }
  }
  private static void solve(int[] tbl,int num){
    int key=tbl[num];
    int cmp=0 ;
    int l=0 ;
    int r=num-1 ;
    while(l<=r){
      int m=(l+r)/2 ;
      cmp++;
      if(key==tbl[m]){
        break ;
      }
      else if(key>tbl[m]){
        l=m+1 ;
      }
      else {
        r=m-1 ;
      }
    }
    System.out.println(cmp);
  }
  private static int parseNum(){
    int param=0 ;
    String strin=null ;
    if((strin=parseStdin())!=null){
      param=Integer.parseInt(strin);
    }
    return param ;
  }
  private static String parseStdin(){
    String stdin=null ;
    try {
      String tmp=br.readLine();
      if(tmp!=null){
        if(! tmp.isEmpty()){
          stdin=tmp ;
        }
      }
    }
    catch(IOException e){
    }
    return stdin ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := null;
  static operation initialiseClass()
  pre: true post: true
  activity:     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var tbl : Sequence(int) ; tbl := Integer.subrange(1,100 + 1)->collect(0) ;
     var num : int ; num := 0 ;
         num := parseNum() ;
    while ((num) /= 0) do (    skip ; (         var i : int ; i := 0 ; while i <= num do ( (     tbl[i+1] := parseNum() )  ;     i := i + 1 ) ; 
     execute solve(tbl, num) ) ;     num := parseNum() ;
 ) );
  static   operation solve( tbl : Sequence(int), num : int) : void
  pre: true
  post: true
  activity: (     var key : int ; key := tbl[num+1] ;
     var cmp : int ; cmp := 0 ;
    var l : int ; l := 0 ;
    var r : int ; r := num - 1 ;
    while (l <= r) do (     var m : int ; m := (l + r) / 2 ;
     cmp := cmp + 1 ; 
     if (key = tbl[m+1]) then (     break ) else     if (key > tbl[m+1]) then (     l := m + 1 ) else (     r := m - 1 ) ;  ) ; 
    OclFile["System.out"].println(cmp) ; 
 );
  static   operation parseNum() : int
  pre: true
  post: true
  activity: (     var param : int ; param := 0 ;
     var strin : String ; strin := null ;
     if ((strin) /= null) then (     param := (strin)->toInteger() ) else skip ; 
     return param );
  static   operation parseStdin() : String
  pre: true
  post: true
  activity: (     var stdin : String ; stdin := null ;
     try (     var tmp : String ; tmp := br.readLine() ;
     if (tmp /= null) then (     if (not(tmp->isEmpty())) then (     stdin := tmp ) else skip ) else skip )   catch (e : IOException) do skip
     return stdin );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    System.out.println(2*n-1+" "+2);
    System.out.println(1+" "+2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
     OclFile["System.out"].println(2 * n - 1 + " " + 2) ; 
     OclFile["System.out"].println(1 + " " + 2) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A865 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int A=in.nextInt();
    if(A==1){
      System.out.println("1 1");
      System.out.println("1");
    }
    else {
      System.out.println(2*(A-1)+" "+2);
      System.out.println("1 2");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A865 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := in.getCurrent()->toInteger() ;
     if (A = 1) then (     OclFile["System.out"].println("1 1") ; 
     OclFile["System.out"].println("1") ) else (     OclFile["System.out"].println(2 * (A - 1) + " " + 2) ; 
     OclFile["System.out"].println("1 2") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Save {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int a=sc.nextInt();
    if(a==1){
      System.out.println("1 1 \n1");
    }
    else {
      System.out.println((a-1)*2+" 2\n1 2");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Save {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (a = 1) then (     OclFile["System.out"].println("1 1 \n1") ) else (     OclFile["System.out"].println((a - 1) * 2 + " 2\n1 2") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
public class SaveTheProblem {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pr=new PrintWriter(System.out);
    solve(br,pr);
    pr.flush();
    pr.close();
  }
  public static void solve(BufferedReader br,PrintWriter pr)throws IOException {
    int a=Integer.parseInt(br.readLine());
    pr.println(2*a-1+" "+2);
    pr.println(1+" "+2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class SaveTheProblem {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    execute solve(br, pr) ; 
    skip ; 
    skip ; 
 );
  static   operation solve( br : OclFile, pr : OclFile) : void
  pre: true
  post: true
  activity: (     var a : int ; a := (br.readLine())->toInteger() ;
     skip ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static class Node {
    int data ;
    Node next ;
  };
  static Node push(Node head_ref,int new_data){
    Node new_node=new Node();
    new_node.data=new_data ;
    new_node.next=(head_ref);
(head_ref)=new_node ;
    return head_ref ;
  }
  static boolean isPrime(int n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static Node deleteNonPrimeNodes(Node head_ref){
    Node ptr=head_ref ;
    while(ptr!=null && ! isPrime(ptr.data)){
      Node temp=ptr ;
      ptr=ptr.next ;
    }
    head_ref=ptr ;
    if(ptr==null)return null ;
    Node curr=ptr.next ;
    while(curr!=null){
      if(! isPrime(curr.data)){
        ptr.next=curr.next ;
        curr=ptr.next ;
      }
      else {
        ptr=curr ;
        curr=curr.next ;
      }
    }
    return head_ref ;
  }
  static void printList(Node head){
    while(head!=null){
      System.out.print(head.data+" ");
      head=head.next ;
    }
  }
  public static void main(String args[]){
    Node head=null ;
    head=push(head,17);
    head=push(head,7);
    head=push(head,6);
    head=push(head,16);
    head=push(head,15);
    System.out.print("Original List: ");
    printList(head);
    head=deleteNonPrimeNodes(head);
    System.out.print("\nModified List: ");
    printList(head);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static class Node {
   attribute data : int;
   attribute next : Node;
}
  static   operation push( head_ref : Node, new_data : int) : Node
  pre: true
  post: true
  activity: (     var new_node : Node ; new_node := Node.newNode() ;
     new_node.data := new_data ; 
    new_node.next := (head_ref) ; 
    (head_ref) := new_node ; 
    return head_ref 
 );
  static   operation isPrime( n : int) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation deleteNonPrimeNodes( head_ref : Node) : Node
  pre: true
  post: true
  activity: (     var ptr : Node ; ptr := head_ref ;
     while (ptr /= null & not(isPrime(ptr.data))) do (     var temp : Node ; temp := ptr ;
     ptr := ptr.next ) ; 
    head_ref := ptr ; 
    if (ptr = null) then     return null else skip ; 
    var curr : Node ; curr := ptr.next ;
    while (curr /= null) do (     if (not(isPrime(curr.data))) then (     ptr.next := curr.next ; 
     curr := ptr.next ) else (     ptr := curr ; 
     curr := curr.next ) ) ; 
    return head_ref 
 );
  static   operation printList( head : Node) : void
  pre: true
  post: true
  activity: (     while (head /= null) do (     OclFile["System.out"].print(head.data + " ") ; 
     head := head.next ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var head : Node ; head := null ;
     head := push(head, 17) ; 
    head := push(head, 7) ; 
    head := push(head, 6) ; 
    head := push(head, 16) ; 
    head := push(head, 15) ; 
    OclFile["System.out"].print("Original List: ") ; 
    execute printList(head) ; 
    head := deleteNonPrimeNodes(head) ; 
    OclFile["System.out"].print("\nModified List: ") ; 
    execute printList(head) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static float circlearea(float R){
    if(R<0)return-1 ;
    float a=(float)((3.14*R*R)/4);
    return a ;
  }
  public static void main(String[] args){
    float R=2 ;
    System.out.println(circlearea(R));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation circlearea( R : double) : double
  pre: true
  post: true
  activity: (     if (R < 0) then     return -1 else skip ; 
     var a : double ; a := ((3.14 * R * R) / 4)->oclAsType(double) ;
     return a );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var R : double ; R := 2 ;
     OclFile["System.out"].println(circlearea(R)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.io.FileInputStream ;
import java.io.PrintStream ;
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static ArrayList<Point>delta ;
  static void start(){
    int x=0 ;
    int y=0 ;
    int max=0 ;
    int mx=0,my=0 ;
    for(Point d : delta){
      x+=d.x ;
      y+=d.y ;
      int len=x*x+y*y ;
      if(max<len){
        max=len ;
        mx=x ;
        my=y ;
      }
      else if(max==len){
        if(x>mx){
          mx=x ;
          my=y ;
        }
      }
    }
    System.out.printf("%d %d\n",mx,my);
  }
  public static void main(String[] args){
    Scanner sca=new Scanner(System.in);
    while(true){
      int n=sca.nextInt();
      for(; n>0 ; n--){
        delta=new ArrayList<Point>();
        while(true){
          int dx=sca.nextInt();
          int dy=sca.nextInt();
          if(dx==0 && dy==0)break ;
          delta.add(new Point(dx,dy));
        }
        start();
      }
      break ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute delta : Sequence(Point);
  static   operation start() : void
  pre: true
  post: true
  activity: (     var x : int ; x := 0 ;
     var y : int ; y := 0 ;
    var max : int ; max := 0 ;
    var mx : int ; mx := 0 ;
    var my : int ; my := 0 ;
    for (d : delta) do ( (     x := x+(d.x) ; 
     y := y+(d.y) ; 
     var len : int ; len := x * x + y * y ;
     if (max < len) then (     max := len ; 
     mx := x ; 
     my := y ) else     if (max = len) then (     if (x > mx) then (     mx := x ; 
     my := y ) else skip ) else skip ; )  ) ; 
    OclFile["System.out"].printf("%d %d\n", mx, my) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sca : OclFile ; sca := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sca.getCurrent()->toInteger() ;
       while n > 0 do ( (     delta := Sequence{} ; 
     while (true) do (     var dx : int ; dx := sca.getCurrent()->toInteger() ;
     var dy : int ; dy := sca.getCurrent()->toInteger() ;
     if (dx = 0 & dy = 0) then     break else skip ; 
     delta := delta->including(Point.newPoint(dx, dy)) ) ; 
     execute start() )  ;     n := n - 1 ) ; 
     break ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private void doit(){
    Scanner sc=new Scanner(System.in);
    int dataset=sc.nextInt();
    while(dataset-->0){
      int nowx=0,nowy=0 ;
      int maxdis=0,ansx=0,ansy=0 ;
      while(true){
        int x=sc.nextInt();
        int y=sc.nextInt();
        if((x | y)==0)break ;
        nowx+=x ;
        nowy+=y ;
        int dis=nowx*nowx+nowy*nowy ;
        if(maxdis<dis){
          maxdis=dis ;
          ansx=nowx ;
          ansy=nowy ;
        }
        else if(maxdis==dis &&(ansx<nowx)){
          ansx=nowx ;
          ansy=nowy ;
        }
      }
      System.out.println(ansx+" "+ansy);
    }
  }
  private void debug(Object...o){
    System.out.println("debug="+Arrays.deepToString(o));
  }
  public static void main(String[] args){
    new Main().doit();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation doit() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var dataset : int ; dataset := sc.getCurrent()->toInteger() ;
         while (dataset > 0) do (        dataset := dataset - 1 ;     skip ; (     var nowx : int ; nowx := 0 ;
    var nowy : int ; nowy := 0 ;
     var maxdis : int ; maxdis := 0 ;
    var ansx : int ; ansx := 0 ;
    var ansy : int ; ansy := 0 ;
     while (true) do (     var x : int ; x := sc.getCurrent()->toInteger() ;
     var y : int ; y := sc.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(x,y)) = 0) then     break else skip ; 
    nowx := nowx+(x) ; 
    nowy := nowy+(y) ; 
    var dis : int ; dis := nowx * nowx + nowy * nowy ;
    if (maxdis < dis) then (     maxdis := dis ; 
     ansx := nowx ; 
     ansy := nowy ) else     if (maxdis = dis & (ansx < nowx)) then (     ansx := nowx ; 
     ansy := nowy ) else skip ; ;  
 ) ; 
     OclFile["System.out"].println(ansx + " " + ansy) ) ;  ) );
   operation debug( o : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("debug=" + (o + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().doit() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.util.*;
import java.io.*;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int T=sc.nextInt();
    for(int t=0 ; t<T ; t++){
      P p=new P(0,0);
      P max=new P(0,0);
      for(; ; ){
        int dx=sc.nextInt(),dy=sc.nextInt();
        if((dx | dy)==0)break ;
        p.x+=dx ;
        p.y+=dy ;
        if(max.compareTo(p)<0)max=new P(p.x,p.y);
      }
      System.out.println(max.x+" "+max.y);
    }
  }
  class P implements Comparable<P>{
    int x,y ;
    P(int x,int y){
      this.x=x ;
      this.y=y ;
    }
    @ Override public int compareTo(P p){
      if(x*x+y*y-(p.x*p.x+p.y*p.y)!=0)return x*x+y*y-(p.x*p.x+p.y*p.y);
      return x-p.x ;
    }
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := sc.getCurrent()->toInteger() ;
         var t : int ; t := 0 ; while t < T do ( (     var p : P ; p := P.newP(0, 0) ;
     var max : P ; max := P.newP(0, 0) ;
       while true do ( (     var dx : int ; dx := sc.getCurrent()->toInteger() ;
    var dy : int ; dy := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseOr(dx,dy)) = 0) then     break else skip ; 
    p.x := p.x+(dx) ; 
    p.y := p.y+(dy) ; 
    if (max->compareTo(p) < 0) then     max := P.newP(p.x, p.y) ; else skip ; 
 )  ) ; 
     OclFile["System.out"].println(max.x + " " + max.y) )  ;     t := t + 1 ) );
 class P implements Comparable<P> {
   attribute x : int;
   static operation newP( x : int, y : int) : P
  pre: true
  post: true
  activity:
  ( var self : P ;
    self := createP();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
      operation compareTo( p : P) : int
  pre: true
  post: true
  activity: (     if (x * x + y * y - (p.x * p.x + p.y * p.y) /= 0) then     return x * x + y * y - (p.x * p.x + p.y * p.y) else skip ; 
     return x - p.x );
}
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int dx=sc.nextInt();
    int dy=sc.nextInt();
    while(n!=0){
      int posX=0 ;
      int posY=0 ;
      int maxX=0 ;
      int maxY=0 ;
      double max=0 ;
      for(; ; ){
        posX+=dx ;
        posY+=dy ;
        double dist=(posX*posX)+(posY*posY);
        if(dist>max){
          maxX=posX ;
          maxY=posY ;
          max=dist ;
        }
        if(dist==max && posX>maxX){
          maxX=posX ;
          maxY=posY ;
        }
        dx=sc.nextInt();
        dy=sc.nextInt();
        if(dx==0 && dy==0)break ;
      }
      System.out.println(maxX+" "+maxY);
      n--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var dx : int ; dx := sc.getCurrent()->toInteger() ;
    var dy : int ; dy := sc.getCurrent()->toInteger() ;
    while (n /= 0) do (     var posX : int ; posX := 0 ;
     var posY : int ; posY := 0 ;
    var maxX : int ; maxX := 0 ;
    var maxY : int ; maxY := 0 ;
    var max : double ; max := 0 ;
      while true do ( (     posX := posX+(dx) ; 
     posY := posY+(dy) ; 
    var dist : double ; dist := (posX * posX) + (posY * posY) ;
    if (dist > max) then (     maxX := posX ; 
     maxY := posY ; 
     max := dist ) else skip ; 
    if (dist = max & posX > maxX) then (     maxX := posX ; 
     maxY := posY ) else skip ; 
    dx := sc.getCurrent()->toInteger() ; 
    dy := sc.getCurrent()->toInteger() ; 
    if (dx = 0 & dy = 0) then     break else skip ; 
 )  ) ; 
    OclFile["System.out"].println(maxX + " " + maxY) ; 
    n := n - 1 ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner scan=new Scanner(System.in);
    int input1=scan.nextInt();
    for(int caves=0 ; caves<input1 ; caves++){
      int input2=scan.nextInt();
      int input3=scan.nextInt();
      ArrayList<Room>room=new ArrayList<>();
      int nowX=0 ;
      int nowY=0 ;
      while(!(input2==0 && input3==0)){
        nowX+=input2 ;
        nowY+=input3 ;
        boolean flag=true ;
        for(int i=0 ; i<room.size(); i++){
          Room r=room.get(i);
          if(nowX==r.x && nowY==r.y){
            flag=false ;
            break ;
          }
        }
        if(flag){
          room.add(new Room(nowX,nowY));
        }
        input2=scan.nextInt();
        input3=scan.nextInt();
      }
      int max=0 ;
      int maxX=0 ;
      int maxY=0 ;
      for(int i=0 ; i<room.size(); i++){
        Room r=room.get(i);
        int length=r.x*r.x+r.y*r.y ;
        if(max<length){
          max=length ;
          maxX=r.x ;
          maxY=r.y ;
        }
        else if(max==length){
          if(maxX<r.x){
            max=length ;
            maxX=r.x ;
            maxY=r.y ;
          }
        }
      }
      System.out.println(maxX+" "+maxY);
    }
  }
}
class Room {
  int x,y ;
  Room(int _x,int _y){
    x=_x ;
    y=_y ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var input1 : int ; input1 := scan.getCurrent()->toInteger() ;
         var caves : int ; caves := 0 ; while caves < input1 do ( (     var input2 : int ; input2 := scan.getCurrent()->toInteger() ;
     var input3 : int ; input3 := scan.getCurrent()->toInteger() ;
    var room : Sequence(Room) ; room := Sequence{} ;
    var nowX : int ; nowX := 0 ;
    var nowY : int ; nowY := 0 ;
    while (not((input2 = 0 & input3 = 0))) do (     nowX := nowX+(input2) ; 
     nowY := nowY+(input3) ; 
    var flag : boolean ; flag := true ;
        var i : int ; i := 0 ; while i < room->size() do ( (     var r : Room ; r := room->at(i+1) ;
     if (nowX = r.x & nowY = r.y) then (     flag := false ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (flag) then (     room := room->including(Room.newRoom(nowX, nowY)) ) else skip ; 
    input2 := scan.getCurrent()->toInteger() ; 
    input3 := scan.getCurrent()->toInteger() ; 
 ) ; 
    var max : int ; max := 0 ;
    var maxX : int ; maxX := 0 ;
    var maxY : int ; maxY := 0 ;
        var i : int ; i := 0 ; while i < room->size() do ( (     var r : Room ; r := room->at(i+1) ;
     var length : int ; length := r.x * r.x + r.y * r.y ;
     if (max < length) then (     max := length ; 
     maxX := r.x ; 
     maxY := r.y ) else     if (max = length) then (     if (maxX < r.x) then (     max := length ; 
     maxX := r.x ; 
     maxY := r.y ) else skip ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(maxX + " " + maxY) ; 
 )  ;     caves := caves + 1 ) );
}
class Room {
   attribute x : int;
   static operation newRoom( _x : int, _y : int) : Room
  pre: true
  post: true
  activity:
  ( var self : Room ;
    self := createRoom();
    self.initialise(_x, _y);
    return self );
  operation initialise( _x : int, _y : int) : void
  pre: true  post: true
  activity: (     x := _x ; 
     y := _y );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class Main {
  int INF=1<<28 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=sc.nextInt();
      }
      int s=sc.nextInt();
      System.out.println(binarySearch(a,s));
    }
  }
  int binarySearch(int[] a,int x){
    int cnt=0 ;
    int left=0 ;
    int right=a.length-1 ;
    int center=(left+right)/2 ;
    for(; left<=right ; ){
      cnt++;
      if(a[center]==x)break ;
      else if(a[center]>x)right=center-1 ;
      else left=center+1 ;
      center=(left+right)/2 ;
    }
    return cnt ;
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var s : int ; s := sc.getCurrent()->toInteger() ;
    OclFile["System.out"].println(binarySearch(a, s)) ; 
 )  ) );
   operation binarySearch( a : Sequence(int), x : int) : int
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
     var left : int ; left := 0 ;
    var right : int ; right := a->size() - 1 ;
    var center : int ; center := (left + right) / 2 ;
      while left <= right do ( (     cnt := cnt + 1 ; 
     if (a[center+1] = x) then     break else     if (a[center+1] > x) then     right := center - 1 else     left := center + 1 ; ;  ;  
     center := (left + right) / 2 )  ) ; 
    return cnt 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.Point ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class A763 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    Point[] edges=new Point[N-1];
    for(int n=0 ; n<N-1 ; n++){
      int u=in.nextInt()-1 ;
      int v=in.nextInt()-1 ;
      edges[n]=new Point(u,v);
    }
    int[] C=new int[N];
    for(int n=0 ; n<N ; n++){
      C[n]=in.nextInt();
    }
    List<Point>list=new ArrayList<>();
    for(Point edge : edges){
      if(C[edge.x]!=C[edge.y]){
        list.add(edge);
      }
    }
    boolean ok=true ;
    int vertex=-1 ;
    if(list.isEmpty()){
      vertex=1 ;
    }
    else {
      Point first=list.get(0);
      boolean x=true ;
      boolean y=true ;
      for(Point edge : list){
        if(edge.x!=first.x && edge.y!=first.x){
          x=false ;
        }
        if(edge.x!=first.y && edge.y!=first.y){
          y=false ;
        }
      }
      if(x){
        vertex=first.x+1 ;
      }
      else if(y){
        vertex=first.y+1 ;
      }
      else {
        ok=false ;
      }
    }
    if(ok){
      System.out.println("YES");
      System.out.println(vertex);
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A763 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var edges : Sequence(Point) ; edges := Integer.subrange(1,N - 1)->collect(null) ;
        var n : int ; n := 0 ; while n < N - 1 do ( (     var u : int ; u := in.getCurrent()->toInteger() - 1 ;
     var v : int ; v := in.getCurrent()->toInteger() - 1 ;
     edges[n+1] := Point.newPoint(u, v) )  ;     n := n + 1 ) ; 
    var C : Sequence(int) ; C := Integer.subrange(1,N)->collect(0) ;
        var n : int ; n := 0 ; while n < N do ( (     C[n+1] := in.getCurrent()->toInteger() )  ;     n := n + 1 ) ; 
    var list : Sequence(Point) ; list := Sequence{} ;
    for (edge : edges) do ( (     if (C[edge.x+1] /= C[edge.y+1]) then (     list := list->including(edge) ) else skip )  ) ; 
    var ok : boolean ; ok := true ;
    var vertex : int ; vertex := -1 ;
    if (list->isEmpty()) then (     vertex := 1 ) else (     var first : Point ; first := list->at(0+1) ;
     var x : boolean ; x := true ;
    var y : boolean ; y := true ;
    for (edge : list) do ( (     if (edge.x /= first.x & edge.y /= first.x) then (     x := false ) else skip ; 
     if (edge.x /= first.y & edge.y /= first.y) then (     y := false ) else skip )  ) ; 
    if (x) then (     vertex := first.x + 1 ) else     if (y) then (     vertex := first.y + 1 ) else (     ok := false ) ;  ;  
 ) ;  
    if (ok) then (     OclFile["System.out"].println("YES") ; 
     OclFile["System.out"].println(vertex) ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p028 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p028().run());
  }
  private static final int SIZE=1001 ;
  public String run(){
    long sum=1 ;
    for(int n=3 ; n<=SIZE ; n+=2)sum+=4*n*n-6*(n-1);
    return Long.toString(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
class p028 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p028.newp028().run()) );
  static    attribute SIZE : int := 1001;
   operation run() : String
  pre: true
  post: true
  activity: (     var sum : long ; sum := 1 ;
         var n : int ; n := 3 ; while n <= SIZE do (     sum := sum+(4 * n * n - 6 * (n - 1)) ;  ;     n := n+(2) ) ; 
     return ((sum) + "") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    List<Rectangle>rectangleList=new ArrayList<>();
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      int x1=scanner.nextInt();
      int y1=scanner.nextInt();
      int x2=scanner.nextInt();
      int y2=scanner.nextInt();
      Rectangle rectangle=Rectangle.of(Point.of(x1,y1),Point.of(x2,y2));
      sum+=rectangle.calculateSquare();
    }
    System.out.println(sum);
  }
}
class Point {
  private int x ;
  private int y ;
  public Point(int x,int y){
    this.x=x ;
    this.y=y ;
  }
  public int getX(){
    return x ;
  }
  public void setX(int x){
    this.x=x ;
  }
  public int getY(){
    return y ;
  }
  public void setY(int y){
    this.y=y ;
  }
  public static Point of(int x,int y){
    return new Point(x,y);
  }
}
class Rectangle {
  private Point downLeft ;
  private Point upRight ;
  public Rectangle(Point downLeft,Point upRight){
    this.downLeft=downLeft ;
    this.upRight=upRight ;
  }
  public Point getDownLeft(){
    return downLeft ;
  }
  public void setDownLeft(Point downLeft){
    this.downLeft=downLeft ;
  }
  public Point getUpRight(){
    return upRight ;
  }
  public void setUpRight(Point upRight){
    this.upRight=upRight ;
  }
  public static Rectangle of(Point downLeft,Point upRight){
    return new Rectangle(downLeft,upRight);
  }
  int calculateSquare(){
    return(upRight.getX()-downLeft.getX()+1)*(upRight.getY()-downLeft.getY()+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var rectangleList : Sequence(Rectangle) ; rectangleList := Sequence{} ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var x1 : int ; x1 := scanner.getCurrent()->toInteger() ;
     var y1 : int ; y1 := scanner.getCurrent()->toInteger() ;
    var x2 : int ; x2 := scanner.getCurrent()->toInteger() ;
    var y2 : int ; y2 := scanner.getCurrent()->toInteger() ;
    var rectangle : Rectangle ; rectangle := Rectangle.of(Point.of(x1, y1), Point.of(x2, y2)) ;
    sum := sum+(rectangle.calculateSquare()) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}
class Point {
   attribute x : int;
   attribute y : int;
   static operation newPoint( x : int, y : int) : Point
  pre: true
  post: true
  activity:
  ( var self : Point ;
    self := createPoint();
    self.initialise(x, y);
    return self );
  operation initialise( x : int, y : int) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   operation getX() : int
  pre: true
  post: true
  activity: (     return x );
   operation setX( x : int) : void
  pre: true
  post: true
  activity: (     self.x := x );
   operation getY() : int
  pre: true
  post: true
  activity: (     return y );
   operation setY( y : int) : void
  pre: true
  post: true
  activity: (     self.y := y );
  static   operation of( x : int, y : int) : Point
  pre: true
  post: true
  activity: (     return Point.newPoint(x, y) );
}
class Rectangle {
   attribute downLeft : Point;
   attribute upRight : Point;
   static operation newRectangle( downLeft : Point, upRight : Point) : Rectangle
  pre: true
  post: true
  activity:
  ( var self : Rectangle ;
    self := createRectangle();
    self.initialise(downLeft, upRight);
    return self );
  operation initialise( downLeft : Point, upRight : Point) : void
  pre: true  post: true
  activity: (     self.downLeft := downLeft ; 
     self.upRight := upRight );
   operation getDownLeft() : Point
  pre: true
  post: true
  activity: (     return downLeft );
   operation setDownLeft( downLeft : Point) : void
  pre: true
  post: true
  activity: (     self.downLeft := downLeft );
   operation getUpRight() : Point
  pre: true
  post: true
  activity: (     return upRight );
   operation setUpRight( upRight : Point) : void
  pre: true
  post: true
  activity: (     self.upRight := upRight );
  static   operation of( downLeft : Point, upRight : Point) : Rectangle
  pre: true
  post: true
  activity: (     return Rectangle.newRectangle(downLeft, upRight) );
   operation calculateSquare() : int
  pre: true
  post: true
  activity: (     return (upRight.getX() - downLeft.getX() + 1) * (upRight.getY() - downLeft.getY() + 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import org.w3c.dom.ls.LSInput ;
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.math.BigInteger ;
import java.util.*;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
import java.util.jar.Attributes ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskA solver=new TaskA();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskA {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int n=in.nextInt();
      int m=in.nextInt();
      int k=in.nextInt();
      int c=1 ;
      int s=m-n ;
      int l=k ;
      int r=k ;
      while(s>=r-l+1){
        s-=r-l+1 ;
        c++;
        if(l>1){
          l--;
        }
        if(r<n){
          r++;
        }
      }
      System.out.println(c);
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskA ; solver := TaskA.newTaskA() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskA {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var m : int ; m := in.nextInt() ;
    var k : int ; k := in.nextInt() ;
    var c : int ; c := 1 ;
    var s : int ; s := m - n ;
    var l : int ; l := k ;
    var r : int ; r := k ;
    while (s >= r - l + 1) do (     s := s-(r - l + 1) ; 
     c := c + 1 ; 
     if (l > 1) then (     l := l - 1 ) else skip ; 
     if (r < n) then (     r := r + 1 ) else skip ) ; 
    OclFile["System.out"].println(c) ; 
 );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int i,n,x1,x2,y1,y2,Area=0 ;
    n=sc.nextInt();
    for(i=0 ; i<n ; i++){
      x1=sc.nextInt();
      y1=sc.nextInt();
      x2=sc.nextInt();
      y2=sc.nextInt();
      Area+=(x2-x1+1)*(y2-y1+1);
    }
    System.out.println(Area);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var i : int ;
    var n : int ;
    var x1 : int ;
    var x2 : int ;
    var y1 : int ;
    var y2 : int ;
    var Area : int ; Area := 0 ;
    n := sc.getCurrent()->toInteger() ; 
        i := 0 ; while i < n do ( (     x1 := sc.getCurrent()->toInteger() ; 
     y1 := sc.getCurrent()->toInteger() ; 
    x2 := sc.getCurrent()->toInteger() ; 
    y2 := sc.getCurrent()->toInteger() ; 
    Area := Area+((x2 - x1 + 1) * (y2 - y1 + 1)) ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(Area) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void arrange(int arr[],int n,int x){
    for(int i=1 ; i<n ; i++){
      int diff=Math.abs(arr[i]-x);
      int j=i-1 ;
      if(Math.abs(arr[j]-x)>diff){
        int temp=arr[i];
        while(j>=0 && Math.abs(arr[j]-x)>diff){
          arr[j+1]=arr[j];
          j--;
        }
        arr[j+1]=temp ;
      }
    }
  }
  static void print(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  public static void main(String[] args){
    int arr[]={
      10,5,3,9,2 };
      int n=arr.length ;
      int x=7 ;
      arrange(arr,n,x);
      print(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation arrange( arr : Sequence(int), n : int, x : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 1 ; while i < n do ( (     var diff : int ; diff := if arr[i+1] - x < 0 then -(arr[i+1] - x) else arr[i+1] - x endif ;
     var j : int ; j := i - 1 ;
     if (if arr[j+1] - x < 0 then -(arr[j+1] - x) else arr[j+1] - x endif > diff) then (     var temp : int ; temp := arr[i+1] ;
     while (j >= 0 & if arr[j+1] - x < 0 then -(arr[j+1] - x) else arr[j+1] - x endif > diff) do (     arr[j + 1+1] := arr[j+1] ; 
     j := j - 1 ) ; 
     arr[j + 1+1] := temp ) else skip )  ;     i := i + 1 ) );
  static   operation print( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,5,3,9,2} ;
     var n : int ; n := arr->size() ;
    var x : int ; x := 7 ;
    execute arrange(arr, n, x) ; 
    execute print(arr, n) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GfG {
  static int MAX=101 ;
  static int dp[][]=new int[MAX][2];
  static int CountWays(int n,int flag){
    if(dp[n][flag]!=-1){
      return dp[n][flag];
    }
    if(n==0){
      return 1 ;
    }
    int sum=0 ;
    if(flag==0 && n>1){
      sum=sum+CountWays(n-1,0)+CountWays(n-2,1);
    }
    else {
      sum=sum+CountWays(n-1,0);
    }
    return dp[n][flag]=sum ;
  }
  public static void main(String[] args){
    int n=5 ;
    for(int i=0 ; i<MAX ; i++){
      Arrays.fill(dp[i],-1);
    }
    System.out.println(CountWays(n,0));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GfG {
  static   attribute MAX : int := 101;
  static   attribute dp : int := Integer.subrange(1,MAX)->collect(Integer.subrange(1,2)->collect(0));
  static   operation CountWays( n : int, flag : int) : int
  pre: true
  post: true
  activity: (     if (dp[n+1][flag+1] /= -1) then (     return dp[n+1][flag+1] ) else skip ; 
     if (n = 0) then (     return 1 ) else skip ; 
    var sum : int ; sum := 0 ;
    if (flag = 0 & n > 1) then (     sum := sum + CountWays(n - 1, 0) + CountWays(n - 2, 1) ) else (     sum := sum + CountWays(n - 1, 0) ) ;  
    return dp[n+1][flag+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
         var i : int ; i := 0 ; while i < MAX do ( (     dp[i+1] := dp[i+1]->collect(-1) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(CountWays(n, 0)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int N=gi();
    long[] a=new long[N];
    for(int i=0 ; i<N ; i++){
      a[i]=gl()-i-1 ;
    }
    Arrays.parallelSort(a);
    long b1=a[Math.floorDiv(N,2)];
    long ans=0 ;
    for(int i=0 ; i<N ; i++){
      ans+=Math.abs(a[i]-b1);
    }
    System.out.println(ans);
  }
  public static String gs(){
    return scanner.next();
  }
  public static int gi(){
    return Integer.parseInt(scanner.next());
  }
  public static long gl(){
    return Long.parseLong(scanner.next());
  }
  public static double gd(){
    return Double.parseDouble(scanner.next());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var N : int ; N := gi() ;
    var a : Sequence(long) ; a := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i+1] := gl() - i - 1 )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var b1 : long ; b1 := a[floorDiv(N, 2)+1] ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     ans := ans+(if a[i+1] - b1 < 0 then -(a[i+1] - b1) else a[i+1] - b1 endif) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation gs() : String
  pre: true
  post: true
  activity: (     return scanner.getCurrent() );
  static   operation gi() : int
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toInteger() );
  static   operation gl() : long
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toLong() );
  static   operation gd() : double
  pre: true
  post: true
  activity: (     return (scanner.getCurrent())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.*;
import java.math.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    int n=Integer.parseInt(bf.readLine());
    StringTokenizer st=new StringTokenizer(bf.readLine());
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=Integer.parseInt(st.nextToken());
    for(int i=0 ; i<n ; i++)a[i]-=(i+1);
    long sum=0 ;
    Arrays.sort(a);
    int median=a[n/2];
    long test1=0 ;
    for(int i=0 ; i<n ; i++){
      test1+=Math.abs(0L+a[i]-median);
    }
    out.println(test1);
    out.close();
    System.exit(0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := (bf.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(bf.readLine()) ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (st.next())->toInteger() ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     a[i+1] := a[i+1]-((i + 1)) ;  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    a := a->sort() ; 
    var median : int ; median := a[n / 2+1] ;
    var test1 : long ; test1 := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     test1 := test1+(if 0L + a[i+1] - median < 0 then -(0L + a[i+1] - median) else 0L + a[i+1] - median endif) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
OclProcess.exit(0) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    long c[]=new long[n];
    String str[]=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++){
      long a=Long.parseLong(str[i]);
      c[i]=a-(i+1);
    }
    Arrays.sort(c);
    long b=c[n/2];
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      ans+=Math.max(b-c[i],-b+c[i]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var c : Sequence(long) ; c := Integer.subrange(1,n)->collect(0) ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
        var i : int ; i := 0 ; while i < n do ( (     var a : long ; a := (str[i+1])->toLong() ;
     c[i+1] := a - (i + 1) )  ;     i := i + 1 ) ; 
    c := c->sort() ; 
    var b : long ; b := c[n / 2+1] ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     ans := ans+(Set{b - c[i+1], -b + c[i+1]}->max()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static int[] A ;
  static int N ;
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    N=sc.nextInt();
    A=new int[N];
    for(int i=0 ; i<N ; i++){
      A[i]=sc.nextInt();
    }
    int b=goldSectionSearchDeko((int)-1e9-9,(int)1e9+9);
    long res=solve(b);
    System.out.println(res);
  }
  public static long solve(int b){
    long res=0 ;
    for(int i=0 ; i<N ; i++){
      res+=(Math.abs(A[i]-b-i-1));
    }
    return res ;
  }
  public static int goldSectionSearchDeko(int left,int right){
    double GRATIO=1.6180339887498948482045868343656 ;
    int lm=left+(int)((right-left)/(GRATIO+1.0));
    int rm=lm+(int)((right-lm)/(GRATIO+1.0));
    long fl=solve(lm);
    long fr=solve(rm);
    while(right-left>10){
      if(fl<fr){
        right=rm ;
        rm=lm ;
        fr=fl ;
        lm=left+(int)((right-left)/(GRATIO+1.0));
        fl=solve(lm);
      }
      else {
        left=lm ;
        lm=rm ;
        fl=fr ;
        rm=lm+(int)((right-lm)/(GRATIO+1.0));
        fr=solve(rm);
      }
    }
    long minScore=Long.MAX_VALUE ;
    int resIndex=left ;
    for(int i=left ; i<right+1 ; i++){
      long score=solve(i);
      if(minScore>score){
        minScore=score ;
        resIndex=i ;
      }
    }
    return resIndex ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute A : Sequence(int);
  static   attribute N : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     N := sc.getCurrent()->toInteger() ; 
    A := Integer.subrange(1,N)->collect(0) ; 
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var b : int ; b := goldSectionSearchDeko(-1e9->oclAsType(int) - 9, 1e9->oclAsType(int) + 9) ;
    var res : long ; res := solve(b) ;
    OclFile["System.out"].println(res) ; 
 );
  static   operation solve( b : int) : long
  pre: true
  post: true
  activity: (     var res : long ; res := 0 ;
         var i : int ; i := 0 ; while i < N do ( (     res := res+((if A[i+1] - b - i - 1 < 0 then -(A[i+1] - b - i - 1) else A[i+1] - b - i - 1 endif)) )  ;     i := i + 1 ) ; 
     return res );
  static   operation goldSectionSearchDeko( left : int, right : int) : int
  pre: true
  post: true
  activity: (     var GRATIO : double ; GRATIO := 1.6180339887498948482045868343656 ;
     var lm : int ; lm := left + ((right - left) / (GRATIO + 1.0))->oclAsType(int) ;
    var rm : int ; rm := lm + ((right - lm) / (GRATIO + 1.0))->oclAsType(int) ;
    var fl : long ; fl := solve(lm) ;
    var fr : long ; fr := solve(rm) ;
    while (right - left > 10) do (     if (fl < fr) then (     right := rm ; 
     rm := lm ; 
    fr := fl ; 
    lm := left + ((right - left) / (GRATIO + 1.0))->oclAsType(int) ; 
    fl := solve(lm) ; 
 ) else (     left := lm ; 
     lm := rm ; 
    fl := fr ; 
    rm := lm + ((right - lm) / (GRATIO + 1.0))->oclAsType(int) ; 
    fr := solve(rm) ; 
 ) ) ; 
    var minScore : long ; minScore := "9223372036854775807"->toLong() ;
    var resIndex : int ; resIndex := left ;
        var i : int ; i := left ; while i < right + 1 do ( (     var score : long ; score := solve(i) ;
     if (minScore > score) then (     minScore := score ; 
     resIndex := i ) else skip )  ;     i := i + 1 ) ; 
    return resIndex 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int kthOdd(int arr[],int n,int k){
    for(int i=0 ; i<n ; i++){
      if(arr[i] % 2==1)k--;
      if(k==0)return arr[i];
    }
    return-1 ;
  }
  public static void main(String args[]){
    int arr[]={
      1,2,3,4,5 };
      int n=arr.length ;
      int k=2 ;
      System.out.print(kthOdd(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation kthOdd( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod 2 = 1) then     k := k - 1 ; else skip ; 
     if (k = 0) then     return arr[i+1] else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4,5} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].print(kthOdd(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int N=scan.nextInt();
    long[] X=new long[N];
    for(int i=0 ; i<N ; i++){
      X[i]=scan.nextLong()-i ;
    }
    Arrays.sort(X);
    System.out.println(solve(N,X));
  }
  public static long solve(int N,long[] X){
    long answer=(X[N-1]-X[0])*N/2 ;
    long left=X[0];
    long right=X[N-1];
    while(left+2<right){
      long first_candidate=(right-left)/3+left ;
      long second_candidate=(right-left)*2/3+left ;
      long first_answer=cal(N,X,first_candidate);
      long second_answer=cal(N,X,second_candidate);
      if(first_answer<second_answer){
        right=second_candidate ;
        answer=second_answer ;
      }
      else {
        left=first_candidate ;
        answer=first_answer ;
      }
    }
    answer=Math.min(answer,cal(N,X,left));
    answer=Math.min(answer,cal(N,X,left+1));
    answer=Math.min(answer,cal(N,X,left+2));
    return answer ;
  }
  private static long cal(int N,long[] X,long b){
    long answer=0 ;
    for(long x : X){
      answer+=Math.abs(x-b);
    }
    return answer ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var X : Sequence(long) ; X := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     X[i+1] := scan.getCurrent()->toLong() - i )  ;     i := i + 1 ) ; 
    X := X->sort() ; 
    OclFile["System.out"].println(solve(N, X)) ; 
 );
  static   operation solve( N : int, X : Sequence(long)) : long
  pre: true
  post: true
  activity: (     var answer : long ; answer := (X[N - 1+1] - X[0+1]) * N / 2 ;
     var left : long ; left := X[0+1] ;
    var right : long ; right := X[N - 1+1] ;
    while (left + 2 < right) do (     var first_candidate : long ; first_candidate := (right - left) / 3 + left ;
     var second_candidate : long ; second_candidate := (right - left) * 2 / 3 + left ;
    var first_answer : long ; first_answer := cal(N, X, first_candidate) ;
    var second_answer : long ; second_answer := cal(N, X, second_candidate) ;
    if (first_answer < second_answer) then (     right := second_candidate ; 
     answer := second_answer ) else (     left := first_candidate ; 
     answer := first_answer ) ;  
 ) ; 
    answer := Set{answer, cal(N, X, left)}->min() ; 
    answer := Set{answer, cal(N, X, left + 1)}->min() ; 
    answer := Set{answer, cal(N, X, left + 2)}->min() ; 
    return answer 
 );
  static   operation cal( N : int, X : Sequence(long), b : long) : long
  pre: true
  post: true
  activity: (     var answer : long ; answer := 0 ;
     for (x : X) do ( (     answer := answer+(if x - b < 0 then -(x - b) else x - b endif) )  ) ; 
     return answer );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int ack(int m,int n){
    if(m==0){
      return n+1 ;
    }
    else if((m>0)&&(n==0)){
      return ack(m-1,1);
    }
    else if((m>0)&&(n>0)){
      return ack(m-1,ack(m,n-1));
    }
    else return n+1 ;
  }
  public static void main(String args[]){
    System.out.println(ack(1,2));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation ack( m : int, n : int) : int
  pre: true
  post: true
  activity: (     if (m = 0) then (     return n + 1 ) else     if ((m > 0) & (n = 0)) then (     return ack(m - 1, 1) ) else     if ((m > 0) & (n > 0)) then (     return ack(m - 1, ack(m, n - 1)) ) else     return n + 1 ;  ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(ack(1, 2)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    int M=sc.nextInt();
    int L=sc.nextInt();
    ArrayList<ArrayList<Integer>>cs=new ArrayList<>();
    for(int i=0 ; i<N*M ; ++i){
      cs.add(new ArrayList<>());
    }
    for(int i=0 ; i<M ; ++i){
      int D=sc.nextInt();
      int A=sc.nextInt()-1 ;
      int K=sc.nextInt();
      int T=sc.nextInt();
      int start=D*N+A ;
      cs.get(start).add((K<<16)| T);
    }
    int[][] dp=new int[L+1][N*M+1];
    for(int i=0 ; i<N*M ; ++i){
      for(int j=0 ; j<L ; ++j){
        for(int c : cs.get(i)){
          int len=c>>16 ;
          int t=c & 0xFFFF ;
          dp[j+1][i+len]=Math.max(dp[j+1][i+len],dp[j][i]+t);
        }
      }
      for(int j=0 ; j<=L ; ++j){
        dp[j][i+1]=Math.max(dp[j][i+1],dp[j][i]);
      }
    }
    int ans=0 ;
    for(int i=0 ; i<=L ; ++i){
      ans=Math.max(ans,dp[i][N*M]);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var M : int ; M := sc.getCurrent()->toInteger() ;
    var L : int ; L := sc.getCurrent()->toInteger() ;
    var cs : Sequence(Sequence(int)) ; cs := Sequence{} ;
        var i : int ; i := 0 ; while i < N * M do ( (     cs := cs->including(Sequence{}) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var D : int ; D := sc.getCurrent()->toInteger() ;
     var A : int ; A := sc.getCurrent()->toInteger() - 1 ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    var T : int ; T := sc.getCurrent()->toInteger() ;
    var start : int ; start := D * N + A ;
    cs->at(start+1)->excludes(((K*(2->pow(16)))->oclAsType(long)) or T) ; 
 )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,L + 1)->collect(Integer.subrange(1,N * M + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < N * M do ( (         var j : int ; j := 0 ; while j < L do ( (     for (c : cs->at(i+1)) do ( (     var len : int ; len := (c/(2->pow(16)))->oclAsType(long) ;
     var t : int ; t := MathLib.bitwiseAnd(c,0xFFFF) ;
     dp[j + 1+1][i + len+1] := Set{dp[j + 1+1][i + len+1], dp[j+1][i+1] + t}->max() )  ) )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j <= L do ( (     dp[j+1][i + 1+1] := Set{dp[j+1][i + 1+1], dp[j+1][i+1]}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i <= L do ( (     ans := Set{ans, dp[i+1][N * M+1]}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  static int NumberOfRectangles(int n,int m){
    if(n % 2==0)return(n/2)*m ;
    else if(m % 2==0)return(m/2)*n ;
    return(n*m-1)/2 ;
  }
  public static void main(String args[]){
    int n=3,m=3 ;
    System.out.println(NumberOfRectangles(n,m));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation NumberOfRectangles( n : int, m : int) : int
  pre: true
  post: true
  activity: (     if (n mod 2 = 0) then     return (n / 2) * m else     if (m mod 2 = 0) then     return (m / 2) * n else skip ; ;  
     return (n * m - 1) / 2 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
    var m : int ; m := 3 ;
     OclFile["System.out"].println(NumberOfRectangles(n, m)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int centeredoctagonalNumber(int n){
    return 4*n*(n-1)+1 ;
  }
  public static void main(String args[]){
    int n=6 ;
    System.out.print(n+"th centered "+"octagonal number: ");
    System.out.println(centeredoctagonalNumber(n));
    n=11 ;
    System.out.print(n+"th centered "+"octagonal number: ");
    System.out.println(centeredoctagonalNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation centeredoctagonalNumber( n : int) : int
  pre: true
  post: true
  activity: (     return 4 * n * (n - 1) + 1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     OclFile["System.out"].print(n + "th centered " + "octagonal number: ") ; 
    OclFile["System.out"].println(centeredoctagonalNumber(n)) ; 
    n := 11 ; 
    OclFile["System.out"].print(n + "th centered " + "octagonal number: ") ; 
    OclFile["System.out"].println(centeredoctagonalNumber(n)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    long x=scanner.nextLong();
    if(x % 11==0){
      System.out.println(x/11*2);
    }
    else if(x % 11>6){
      System.out.println(x/11*2+2);
    }
    else {
      System.out.println(x/11*2+1);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := scanner.getCurrent()->toLong() ;
     if (x mod 11 = 0) then (     OclFile["System.out"].println(x / 11 * 2) ) else     if (x mod 11 > 6) then (     OclFile["System.out"].println(x / 11 * 2 + 2) ) else (     OclFile["System.out"].println(x / 11 * 2 + 1) ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    public String next(){
      try {
        while(st==null || ! st.hasMoreElements()){
          st=new StringTokenizer(br.readLine());
        }
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public String nextLine(){
      String s="" ;
      try {
        s=br.readLine();
      }
      catch(Exception e){
        e.printStackTrace();
      }
      return s ;
    }
  }
  public static void main(String[] args){
    FastReader in=new FastReader();
    PrintWriter out=new PrintWriter(System.out);
    long n=in.nextLong();
    long a=n/11 ;
    long rem=n % 11 ;
    long ans=0 ;
    if(rem==0)ans=0 ;
    else if(rem<7)ans++;
    else ans+=2 ;
    ans+=a*2 ;
    out.println(ans);
    out.flush();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     try (     while (st = null or not(st.hasNext())) do (     st := OclIterator.newOclIterator_String(br.readLine()) ) )   catch (e : ProgramException) do (     e.printStackTrace() )
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var s : String ; s := "" ;
     try (     s := br.readLine() )   catch (e : ProgramException) do (     e.printStackTrace() )
     return s );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastReader ; in := FastReader.newFastReader() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : long ; n := in.nextLong() ;
    var a : long ; a := n / 11 ;
    var rem : long ; rem := n mod 11 ;
    var ans : long ; ans := 0 ;
    if (rem = 0) then     ans := 0 else     if (rem < 7) then     ans := ans + 1 else     ans := ans+(2) ; ;  ;  
    ans := ans+(a * 2) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.FileInputStream ;
import java.util.NoSuchElementException ;
import java.util.Scanner ;
import java.io.IOException ;
import java.io.InputStream ;
import java.util.ArrayDeque ;
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.Comparator ;
import java.util.Deque ;
import java.util.HashMap ;
import java.util.List ;
import java.util.Map.Entry ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    long N=sc.nextLong();
    if(N<=6)System.out.println(1);
    else if(N<=11)System.out.println(2);
    else {
      System.out.println((N/11)*2+((N % 11==0)? 0 :(N % 11<=6 ? 1 : 2)));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : long ; N := sc.getCurrent()->toLong() ;
     if (N <= 6) then     OclFile["System.out"].println(1) ; else     if (N <= 11) then     OclFile["System.out"].println(2) else (     OclFile["System.out"].println((N / 11) * 2 + (if (N mod 11 = 0) then 0 else (if N mod 11 <= 6 then 1 else 2 endif) endif)) ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long x=sc.nextLong();
    long twi=x/11 ;
    x-=11*twi ;
    long ans=twi*2 ;
    if(x>6){
      ans+=2 ;
    }
    else if(x>0){
      ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : long ; x := sc.getCurrent()->toLong() ;
    var twi : long ; twi := x / 11 ;
    x := x-(11 * twi) ; 
    var ans : long ; ans := twi * 2 ;
    if (x > 6) then (     ans := ans+(2) ) else     if (x > 0) then (     ans := ans + 1 ) else skip ; ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static void myout(Object t){
    System.out.println(t);
  }
  static void myerr(Object t){
    System.err.println(t);
  }
  static String getStr(){
    return sc.next();
  }
  static int getInt(){
    return Integer.parseInt(getStr());
  }
  static long getLong(){
    return Long.parseLong(getStr());
  }
  static boolean isNext(){
    return sc.hasNext();
  }
  static String[] mySplit(String str){
    return str.split("");
  }
  public static void main(String[] args){
    long N=getLong();
    long output=(long)(Math.ceil((double)N/11))*2 ;
    long amari=N % 11 ;
    if(amari!=0 && amari<=6){
      output--;
    }
    myout(output);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation myout( t : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(t) );
  static   operation myerr( t : OclAny) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println(t) );
  static   operation getStr() : String
  pre: true
  post: true
  activity: (     return sc.getCurrent() );
  static   operation getInt() : int
  pre: true
  post: true
  activity: (     return (getStr())->toInteger() );
  static   operation getLong() : long
  pre: true
  post: true
  activity: (     return (getStr())->toLong() );
  static   operation isNext() : boolean
  pre: true
  post: true
  activity: (     return sc.hasNext() );
  static   operation mySplit( str : String) : Sequence(String)
  pre: true
  post: true
  activity: (     return str->split("") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : long ; N := getLong() ;
     var output : long ; output := ((N->oclAsType(double) / 11)->ceil())->oclAsType(long) * 2 ;
    var amari : long ; amari := N mod 11 ;
    if (amari /= 0 & amari <= 6) then (     output := output - 1 ) else skip ; 
    execute myout(output) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    TreeSet<Integer>set=new TreeSet<>();
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      set.add(in.nextInt());
    }
    int m=in.nextInt();
    for(int i=0 ; i<m ; i++){
      set.add(in.nextInt());
    }
    Iterator<Integer>itr=set.iterator();
    while(itr.hasNext()){
      System.out.println(itr.next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var set : Set(int) ; set := Set{} ;
    var n : int ; n := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     set := set->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var m : int ; m := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     set := set->including(in.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var itr : OclIterator ; itr := set->iterator() ;
    while (itr.hasNext()) do (     OclFile["System.out"].println(itr.next()) ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import com.sun.org.apache.bcel.internal.generic.FSUB ;
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    String s1=in.next();
    String s2=in.next();
    String s=s1.substring(0,1);
    char q1=s1.charAt(0);
    char q=s2.charAt(0);
    for(int i=1 ; i<s1.length(); i++){
      char q2=s1.charAt(i);
      if(q2>=q){
        break ;
      }
      else {
        s+=q2 ;
      }
    }
    s+=s2.substring(0,1);
    System.out.println(s);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := in.getCurrent() ;
    var s2 : String ; s2 := in.getCurrent() ;
    var s : String ; s := s1.subrange(0+1,1) ;
    var q1 : String ; q1 := s1->at(0+1) ;
    var q : String ; q := s2->at(0+1) ;
        var i : int ; i := 1 ; while i < s1->size() do ( (     var q2 : String ; q2 := s1->at(i+1) ;
     if (q2 >= q) then (     break ) else (     s := s+(q2) ) )  ;     i := i + 1 ) ; 
    s := s+(s2.subrange(0+1,1)) ; 
    OclFile["System.out"].println(s) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.TreeSet ;
public class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    TreeSet<Integer>set=new TreeSet<>();
    int a=scan.nextInt();
    for(int i=0 ; i<a ; i++){
      int num=scan.nextInt();
      set.add(num);
    }
    TreeSet<Integer>set2=new TreeSet<>();
    int b=scan.nextInt();
    for(int i=0 ; i<b ; i++){
      int num=scan.nextInt();
      set.add(num);
    }
    TreeSet<Integer>union=new TreeSet<>(set);
    union.addAll(set2);
    for(int j : union){
      System.out.println(j);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var set : Set(int) ; set := Set{} ;
    var a : int ; a := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < a do ( (     var num : int ; num := scan.getCurrent()->toInteger() ;
     set := set->including(num) )  ;     i := i + 1 ) ; 
    var set2 : Set(int) ; set2 := Set{} ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < b do ( (     var num : int ; num := scan.getCurrent()->toInteger() ;
     set := set->including(num) )  ;     i := i + 1 ) ; 
    var union : Set(int) ; union := Set{}->union(set) ;
    union := union->union(set2) ; 
    for (j : union) do ( (     OclFile["System.out"].println(j) )  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class Main {
  public static void main(String args[]){
    try {
      new Main();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  public Main()throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String line ;
    while((line=in.readLine())!=null){
      int size=Integer.parseInt(line);
      if(size==0)break ;
      int[][] data=new int[size][2];
      for(int n=0 ; n<size ; n++){
        line=in.readLine();
        String[] tmp=line.split(" ");
        data[n][0]=Integer.parseInt(tmp[0]);
        data[n][1]=Integer.parseInt(tmp[1]);
      }
      line=in.readLine();
      size=Integer.parseInt(line);
      for(int n=0 ; n<size ; n++){
        line=in.readLine();
        int num=Integer.parseInt(line);
        int[] N={
          0 };
          count(data,num,N,0,0);
          System.out.println(N[0]);
        }
      }
    }
    public void count(int[][] data,int ans,int[] N,int current,int depth){
      if(current>ans){
        return ;
      }
      if(depth!=data.length){
        for(int n=0 ; n<=data[depth][1]; n++){
          int cost=current+data[depth][0]*n ;
          count(data,ans,N,cost,depth+1);
        }
      }
      else {
        if(current==ans){
          N[0]++;
        }
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try ( Main.newMain() )   catch (e : IOException) do (     e.printStackTrace() )
 );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ;
         line := in.readLine() ;
    while ((line) /= null) do (    skip ; (     var size : int ; size := (line)->toInteger() ;
     if (size = 0) then     break else skip ; 
    var data : Sequence(Sequence(int)) ; data := Integer.subrange(1,size)->collect(Integer.subrange(1,2)->collect(0)) ;
        var n : int ; n := 0 ; while n < size do ( (     line := in.readLine() ; 
     var tmp : Sequence(String) ; tmp := line->split(" ") ;
     data[n+1][0+1] := (tmp[0+1])->toInteger() ; 
     data[n+1][1+1] := (tmp[1+1])->toInteger() )  ;     n := n + 1 ) ; 
    line := in.readLine() ; 
    size := (line)->toInteger() ; 
        var n : int ; n := 0 ; while n < size do ( (     line := in.readLine() ; 
     var num : int ; num := (line)->toInteger() ;
    var N : Sequence(int) ; N := Sequence{0} ;
    execute count(data, num, N, 0, 0) ; 
    OclFile["System.out"].println(N[0+1]) ; 
 )  ;     n := n + 1 ) ; 
 ) ;     line := in.readLine() ;
 ) );
   operation count( data : Sequence(Sequence(int)), ans : int, N : Sequence(int), current : int, depth : int) : void
  pre: true
  post: true
  activity: (     if (current > ans) then (     return ) else skip ; 
     if (depth /= data->size()) then (         var n : int ; n := 0 ; while n <= data[depth+1][1+1] do ( (     var cost : int ; cost := current + data[depth+1][0+1] * n ;
     execute count(data, ans, N, cost, depth + 1) )  ;     n := n + 1 ) ) else (     if (current = ans) then (     N[0+1] := N[0+1] + 1 ) else skip ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import static java.lang.System.in ;
class Main {
  int[][] rec=new int[1001][1001];
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    char[] s=sc.next().toCharArray();
    int x=sc.nextInt(),y=sc.nextInt();
    int start=0,n=s.length ;
    while(start<n && s[start]=='F')start++;
    ArrayList<Integer>hori=new ArrayList<>(),vert=new ArrayList<>();
    int parity=0 ;
    int i=start ;
    while(i<n){
      if(s[i]=='T'){
        parity=1-parity ;
        i++;
      }
      else {
        int j=i+1 ;
        while(j<n && s[j]=='F')j++;
        if(parity==0)hori.add(j-i);
        else vert.add(j-i);
        i=j ;
      }
    }
    String ans=help(x-start,hori)&& help(y,vert)? "Yes" : "No" ;
    System.out.println(ans);
  }
  static boolean help(int target,ArrayList<Integer>step){
    int sum=0 ;
    for(int w : step)sum+=w ;
    if(sum<Math.abs(target))return false ;
    if(sum==Math.abs(target))return true ;
    boolean[] cur=new boolean[2*sum+1],next=new boolean[2*sum+1];
    cur[sum]=true ;
    for(int w : step){
      for(int j=0 ; j<=2*sum ; j++){
        if(cur[j]){
          next[j-w]=true ;
          next[j+w]=true ;
        }
      }
      cur=next ;
      next=new boolean[2*sum+1];
    }
    return cur[target+sum];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute rec : Sequence(Sequence(int)) := Integer.subrange(1,1001)->collect(Integer.subrange(1,1001)->collect(0));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : Sequence(String) ; s := sc.getCurrent()->characters() ;
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var start : int ; start := 0 ;
    var n : int ; n := s->size() ;
    while (start < n & s[start+1] = 'F') do     start := start + 1 ; ; 
    var hori : Sequence(int) ; hori := Sequence{} ;
    var vert : Sequence(int) ; vert := Sequence{} ;
    var parity : int ; parity := 0 ;
    var i : int ; i := start ;
    while (i < n) do (     if (s[i+1] = 'T') then (     parity := 1 - parity ; 
     i := i + 1 ) else (     var j : int ; j := i + 1 ;
     while (j < n & s[j+1] = 'F') do     j := j + 1 ; ; 
     if (parity = 0) then     hori := hori->including(j - i) else     vert->excludes(j - i) ; ;  
     i := j ) ) ; 
    var ans : String ; ans := if help(x - start, hori) & help(y, vert) then "Yes" else "No" endif ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation help( target : int, step : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var sum : int ; sum := 0 ;
     for (w : step) do (     sum := sum+(w) ;  ) ; 
    if (sum < if target < 0 then -(target) else target endif) then     return false else skip ; 
    if (sum = if target < 0 then -(target) else target endif) then     return true else skip ; 
    var cur : Sequence(boolean) ; cur := Integer.subrange(1,2 * sum + 1)->collect(false) ;
    var next : Sequence(boolean) ; next := Integer.subrange(1,2 * sum + 1)->collect(false) ;
    cur[sum+1] := true ; 
    for (w : step) do ( (         var j : int ; j := 0 ; while j <= 2 * sum do ( (     if (cur[j+1]) then (     next[j - w+1] := true ; 
     next[j + w+1] := true ) else skip )  ;     j := j + 1 ) ; 
     cur := next ; 
     next := Integer.subrange(1,2 * sum + 1)->collect(false) )  ) ; 
    return cur[target + sum+1] 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    boolean[] array=new boolean[(int)(1e9+1)];
    for(int i=0 ; i<n ; ++i){
      array[sc.nextInt()]=true ;
    }
    int m=sc.nextInt();
    for(int i=0 ; i<m ; ++i){
      array[sc.nextInt()]=true ;
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<array.length ; i++){
      if(array[i]){
        sb.append(i);
        sb.append('\n');
      }
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var array : Sequence(boolean) ; array := Integer.subrange(1,(1e9 + 1)->oclAsType(int))->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     array[sc.getCurrent()->toInteger()+1] := true )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < m do ( (     array[sc.getCurrent()->toInteger()+1] := true )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < array->size() do ( (     if (array[i+1]) then (     sb := sb + StringLib.newString(i) ; 
     sb := sb + StringLib.newString('
') ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String[] str=br.readLine().split(" ");
    Set<Integer>S=new TreeSet<Integer>();
    for(int i=0 ; i<n ; i++){
      S.add(Integer.parseInt(str[i]));
    }
    int m=Integer.parseInt(br.readLine());
    str=br.readLine().split(" ");
    for(int i=0 ; i<m ; i++){
      S.add(Integer.parseInt(str[i]));
    }
    for(Integer num : S)System.out.println(num);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var S : Set(int) ; S := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     S := S->including((str[i+1])->toInteger()) )  ;     i := i + 1 ) ; 
    var m : int ; m := (br.readLine())->toInteger() ;
    str := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < m do ( (     S := S->including((str[i+1])->toInteger()) )  ;     i := i + 1 ) ; 
    for (num : S) do (     OclFile["System.out"].println(num) ;  ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
class Main {
  public static void main(final String[] args){
    final Scanner stdin=new Scanner(System.in);
    while(stdin.hasNextInt()){
      final int n=stdin.nextInt();
      int[] array=new int[n];
      for(int i=0 ; i<n ; i++){
        array[i]=stdin.nextInt();
      }
      Arrays.sort(array);
      int sum=0 ;
      int cum=0 ;
      for(int i=0 ; i<n ; i++){
        cum+=array[i];
        sum+=cum ;
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdin : OclFile ; stdin := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (stdin.hasNextInt()) do (     var n : int ; n := stdin.getCurrent()->toInteger() ;
     var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := stdin.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    array := array->sort() ; 
    var sum : int ; sum := 0 ;
    var cum : int ; cum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     cum := cum+(array[i+1]) ; 
     sum := sum+(cum) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
    try {
      String line ;
      while((line=r.readLine())!=null){
        if(line.length()<1)break ;
        int N=Integer.parseInt(line);
        String[] pline=r.readLine().split(" ");
        int[] p=new int[N];
        for(int i=0 ; i<N ; i++){
          p[i]=Integer.parseInt(pline[i]);
        }
        Arrays.sort(p);
        int time=0 ;
        for(int i=0 ; i<N ; i++){
          time+=p[i]*(N-i);
        }
        System.out.println(time);
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r : OclFile ; r := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var line : String ;
         line := r.readLine() ;
    while ((line) /= null) do (    skip ; (     if (line->size() < 1) then     break else skip ; 
     var N : int ; N := (line)->toInteger() ;
    var pline : Sequence(String) ; pline := r.readLine()->split(" ") ;
    var p : Sequence(int) ; p := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     p[i+1] := (pline[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    p := p->sort() ; 
    var time : int ; time := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     time := time+(p[i+1] * ((N)->char2byte() - i)) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(time) ; 
 ) ;     line := r.readLine() ;
 ) )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] arg)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    String is ;
    String[] ia ;
    while((is=in.readLine())!=null){
      int n=Integer.parseInt(is);
      ia=in.readLine().split(" ");
      ArrayList<Integer>al=new ArrayList<Integer>();
      for(int i=0 ; i<n ; ++i){
        al.add(Integer.parseInt(ia[i]));
      }
      Collections.sort(al);
      int p=0 ;
      int t=0 ;
      for(int i=0 ; i<n ; ++i){
        p+=al.get(i);
        t+=p ;
      }
      System.out.println(t);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( arg : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var is : String ;
     var ia : Sequence(String) ;
         is := in.readLine() ;
    while ((is) /= null) do (    skip ; (     var n : int ; n := (is)->toInteger() ;
     ia := in.readLine()->split(" ") ; 
    var al : Sequence(int) ; al := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     al := al->including((ia[i+1])->toInteger()) )  ;     i := i + 1 ) ; 
    al := al->sort() ; 
    var p : int ; p := 0 ;
    var t : int ; t := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     p := p+(al->at(i+1)) ; 
     t := t+(p) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(t) ; 
 ) ;     is := in.readLine() ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.ListIterator ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      final int n=sc.nextInt();
      int sum=0 ;
      int pre=0 ;
      int[] array=new int[n];
      for(int i=0 ; i<n ; i++){
        array[i]=sc.nextInt();
      }
      Arrays.sort(array);
      for(int i=0 ; i<n ; i++){
        sum+=pre+array[i];
        pre+=array[i];
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var sum : int ; sum := 0 ;
    var pre : int ; pre := 0 ;
    var array : Sequence(int) ; array := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     array[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    array := array->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     sum := sum+(pre + array[i+1]) ; 
     pre := pre+(array[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.StringTokenizer ;
import java.util.Arrays ;
class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String buf ;
    try {
      while((buf=br.readLine())!=null){
        int n=Integer.parseInt(buf);
        StringTokenizer st=new StringTokenizer(br.readLine());
        int p[]=new int[n];
        for(int i=0 ; i<n ; i++){
          p[i]=Integer.parseInt(st.nextToken());
        }
        Arrays.sort(p);
        int sum[]={
          0,0 };
          for(int i=0 ; i<n ; i++){
            sum[1]+=p[i];
            sum[0]+=sum[1];
          }
          System.out.println(sum[0]);
        }
      }
      catch(Exception e){
        e.printStackTrace();
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var buf : String ;
     try (         buf := br.readLine() ;
    while ((buf) /= null) do (    skip ; (     var n : int ; n := (buf)->toInteger() ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     p[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    p := p->sort() ; 
    var sum : Sequence(int) ; sum := Sequence{0,0} ;
        var i : int ; i := 0 ; while i < n do ( (     sum[1+1] := sum[1+1]+(p[i+1]) ; 
     sum[0+1] := sum[0+1]+(sum[1+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum[0+1]) ; 
 ) ;     buf := br.readLine() ;
 ) )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    for(int i=0 ; i<3 ; i++)System.out.print(sc.nextLine().charAt(i));
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
         var i : int ; i := 0 ; while i < 3 do (     OclFile["System.out"].print(sc.nextLine()->at(i+1)) ;  ;     i := i + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
      String a=in.next();
      String b=in.next();
      char[] a1=a.toCharArray();
      char[] b1=b.toCharArray();
      int n=a.length();
      String s=""+a1[0];
      for(int i=1 ; i<n ; i++){
        if(a1[i]<b1[0])s=s+a1[i];
        else break ;
      }
      s=s+b1[0];
      System.out.println(s);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (in.hasNext()) do (     var a : String ; a := in.getCurrent() ;
     var b : String ; b := in.getCurrent() ;
    var a1 : Sequence(String) ; a1 := a->characters() ;
    var b1 : Sequence(String) ; b1 := b->characters() ;
    var n : int ; n := a->size() ;
    var s : String ; s := "" + a1[0+1] ;
        var i : int ; i := 1 ; while i < n do ( (     if (a1[i+1] < b1[0+1]) then     s := s + a1[i+1] ; else     break )  ;     i := i + 1 ) ; 
    s := s + b1[0+1] ; 
    OclFile["System.out"].println(s) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    Main main=new Main();
    main.solveD();
  }
  private void solveD(){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    sc.nextLine();
    int x=sc.nextInt();
    int y=sc.nextInt();
    List<Integer>f_list=new ArrayList<>();
    {
      int f_count=0 ;
      for(int i=0 ; i<s.length(); i++){
        char c=s.charAt(i);
        if(c=='F'){
          f_count++;
        }
        if(c=='T'){
          f_list.add(f_count);
          f_count=0 ;
        }
      }
      f_list.add(f_count);
    }
    Set<Integer>x_set=new HashSet<>();
    Set<Integer>y_set=new HashSet<>();
    x_set.add(f_list.get(0));
    y_set.add(0);
    for(int index=1 ; index<f_list.size(); index++){
      Set<Integer>next_set=new HashSet<>();
      int f=f_list.get(index);
      if(index % 2==0){
        for(int tmp_x : x_set){
          next_set.add(tmp_x+f);
          next_set.add(tmp_x-f);
        }
        x_set=next_set ;
      }
      else {
        for(int tmp_y : y_set){
          next_set.add(tmp_y+f);
          next_set.add(tmp_y-f);
        }
        y_set=next_set ;
      }
    }
    if(x_set.contains(x)&& y_set.contains(y)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var main : Main ; main := Main.newMain() ;
     main.solveD() );
   operation solveD() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    skip ; 
    var x : int ; x := sc.getCurrent()->toInteger() ;
    var y : int ; y := sc.getCurrent()->toInteger() ;
    var f_list : Sequence(int) ; f_list := Sequence{} ;
(     var f_count : int ; f_count := 0 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     var c : String ; c := s->at(i+1) ;
     if (c = 'F') then (     f_count := f_count + 1 ) else skip ; 
     if (c = 'T') then (     f_list := f_list->including(f_count) ; 
     f_count := 0 ) else skip )  ;     i := i + 1 ) ; 
     f_list := f_list->including(f_count) ) 
    var x_set : Set(int) ; x_set := Set{} ;
    var y_set : Set(int) ; y_set := Set{} ;
    x_set := x_set->including(f_list->at(0+1)) ; 
    y_set := y_set->including(0) ; 
        var index : int ; index := 1 ; while index < f_list->size() do ( (     var next_set : Set(int) ; next_set := Set{} ;
     var f : int ; f := f_list->at(index+1) ;
     if (index mod 2 = 0) then (     for (tmp_x : x_set) do ( (     next_set := next_set->including(tmp_x + f) ; 
     next_set := next_set->including(tmp_x - f) )  ) ; 
     x_set := next_set ) else (     for (tmp_y : y_set) do ( (     next_set := next_set->including(tmp_y + f) ; 
     next_set := next_set->including(tmp_y - f) )  ) ; 
     y_set := next_set ) )  ;     index := index + 1 ) ; 
    if (x_set->includes(x) & y_set->includes(y)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static private Scanner scan=new Scanner(System.in);
  public static void main(String args[]){
    String str1=scan.next();
    String str2=scan.next();
    String str3=scan.next();
    int ans_int=0 ;
    PrintWriter out=new PrintWriter(System.out);
    out.println(str1.substring(0,1)+str2.substring(1,2)+str3.substring(2,3));
    out.flush();
    scan.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str1 : String ; str1 := scan.getCurrent() ;
     var str2 : String ; str2 := scan.getCurrent() ;
    var str3 : String ; str3 := scan.getCurrent() ;
    var ans_int : int ; ans_int := 0 ;
    var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String one=sc.next();
    String two=sc.next();
    String three=sc.next();
    System.out.println(one.substring(0,1)+two.substring(1,2)+three.substring(2,3));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var one : String ; one := sc.getCurrent() ;
    var two : String ; two := sc.getCurrent() ;
    var three : String ; three := sc.getCurrent() ;
    OclFile["System.out"].println(one.subrange(0+1,1) + two.subrange(1+1,2) + three.subrange(2+1,3)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    String C1=sc.next();
    String C2=sc.next();
    String C3=sc.next();
    System.out.println(""+C1.charAt(0)+C2.charAt(1)+C3.charAt(2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var C1 : String ; C1 := sc.getCurrent() ;
    var C2 : String ; C2 := sc.getCurrent() ;
    var C3 : String ; C3 := sc.getCurrent() ;
    OclFile["System.out"].println("" + C1->at(0+1) + C2->at(1+1) + C3->at(2+1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String[] A=new String[3];
    for(int i=0 ; i<3 ; i++){
      A[i]=sc.next();
    }
    System.out.println(ans(A));
  }
  public static String ans(String[] A){
    return String.valueOf(A[0] .charAt(0))+String.valueOf(A[1] .charAt(1))+String.valueOf(A[2] .charAt(2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : Sequence(String) ; A := Integer.subrange(1,3)->collect(null) ;
         var i : int ; i := 0 ; while i < 3 do ( (     A[i+1] := sc.getCurrent() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(ans(A)) );
  static   operation ans( A : Sequence(String)) : String
  pre: true
  post: true
  activity: (     return ((A[0+1]->at(0+1)) + "") + ((A[1+1]->at(1+1)) + "") + ((A[2+1]->at(2+1)) + "") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.HashSet ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args)throws IOException {
    new Main().run();
  }
  private void run()throws IOException {
    Scanner scanner=new Scanner(System.in);
    int y=501 ;
    int z=y*y ;
    while(true){
      int n=scanner.nextInt();
      int h=scanner.nextInt();
      if((n | h)==0)break ;
      Set<Integer>set=new HashSet<Integer>();
      while(h-->0){
        String s=scanner.next();
        int a=scanner.nextInt()-1 ;
        int b=scanner.nextInt()-1 ;
        if(s.equals("xy")){
          for(int i=0 ; i<n ; i++)set.add(a+y*b+i*z);
        }
        else if(s.equals("xz")){
          for(int i=0 ; i<n ; i++)set.add(a+i*y+b*z);
        }
        else {
          for(int i=0 ; i<n ; i++)set.add(i+a*y+b*z);
        }
      }
      System.out.println(n*n*n-set.size());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   operation run() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var y : int ; y := 501 ;
     var z : int ; z := y * y ;
     while (true) do (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var h : int ; h := scanner.getCurrent()->toInteger() ;
    if ((MathLib.bitwiseOr(n,h)) = 0) then     break else skip ; 
    var set : Set(int) ; set := Set{} ;
        while (h > 0) do (        h := h - 1 ;     skip ; (     var s : String ; s := scanner.getCurrent() ;
     var a : int ; a := scanner.getCurrent()->toInteger() - 1 ;
     var b : int ; b := scanner.getCurrent()->toInteger() - 1 ;
     if (s = "xy") then (         var i : int ; i := 0 ; while i < n do (     set := set->including(a + y * b + i * z) ;  ;     i := i + 1 ) ) else     if (s = "xz") then (         var i : int ; i := 0 ; while i < n do (     set := set->including(a + i * y + b * z) ;  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < n do (     set := set->including(i + a * y + b * z) ;  ;     i := i + 1 ) ) ;  ) ;  ) ;  
    OclFile["System.out"].println(n * n * n - set->size()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      String line ;
      while(true){
        line=br.readLine();
        int n=Integer.parseInt(line.split(" ")[0]),h=Integer.parseInt(line.split(" ")[1]);
        if(n==0 && h==0)return ;
        Set<Integer>s=new HashSet<Integer>();
        for(int i=0 ; i<h ; i++){
          line=br.readLine();
          String[] str=line.split(" ");
          String p=str[0];
          int a=Integer.parseInt(str[1])-1,b=Integer.parseInt(str[2])-1 ;
          if(p.equals("xy")){
            for(int j=0 ; j<n ; j++){
              s.add(1000000*a+1000*b+j);
            }
          }
          else if(p.equals("yz")){
            for(int j=0 ; j<n ; j++){
              s.add(1000000*j+1000*a+b);
            }
          }
          else {
            for(int j=0 ; j<n ; j++){
              s.add(1000000*a+1000*j+b);
            }
          }
        }
        System.out.println(n*n*n-s.size());
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     var line : String ;
     while (true) do (     line := br.readLine() ; 
     var n : int ; n := (line->split(" ")[0+1])->toInteger() ;
    var h : int ; h := (line->split(" ")[1+1])->toInteger() ;
    if (n = 0 & h = 0) then     return else skip ; 
    var s : Set(int) ; s := Set{} ;
        var i : int ; i := 0 ; while i < h do ( (     line := br.readLine() ; 
     var str : Sequence(String) ; str := line->split(" ") ;
    var p : String ; p := str[0+1] ;
    var a : int ; a := (str[1+1])->toInteger() - 1 ;
    var b : int ; b := (str[2+1])->toInteger() - 1 ;
    if (p = "xy") then (         var j : int ; j := 0 ; while j < n do ( (     s := s->including(1000000 * a + 1000 * b + j) )  ;     j := j + 1 ) ) else     if (p = "yz") then (         var j : int ; j := 0 ; while j < n do ( (     s := s->including(1000000 * j + 1000 * a + b) )  ;     j := j + 1 ) ) else (         var j : int ; j := 0 ; while j < n do ( (     s := s->including(1000000 * a + 1000 * j + b) )  ;     j := j + 1 ) ) ;  ;  
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n * n * n - s->size()) ; 
 ) )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String args[]){
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    try {
      while(true){
        String strs[]=br.readLine().split(" ");
        int n=Integer.parseInt(strs[0]);
        int h=Integer.parseInt(strs[1]);
        if(n==0)return ;
        boolean xy[][]=new boolean[n][n];
        boolean xz[][]=new boolean[n][n];
        boolean yz[][]=new boolean[n][n];
        int answer=n*n*n ;
        for(int i=0 ; i<h ; i++){
          strs=br.readLine().split(" ");
          int arg1=Integer.parseInt(strs[1])-1 ;
          int arg2=Integer.parseInt(strs[2])-1 ;
          if(strs[0] .equals("xy")){
            xy[arg1][arg2]=true ;
            for(int j=0 ; j<n ; j++){
              if(xz[arg1][j])continue ;
              if(yz[arg2][j])continue ;
              answer--;
            }
          }
          else if(strs[0] .equals("xz")){
            xz[arg1][arg2]=true ;
            for(int j=0 ; j<n ; j++){
              if(xy[arg1][j])continue ;
              if(yz[j][arg2])continue ;
              answer--;
            }
          }
          else {
            yz[arg1][arg2]=true ;
            for(int j=0 ; j<n ; j++){
              if(xy[j][arg1])continue ;
              if(xz[j][arg2])continue ;
              answer--;
            }
          }
        }
        System.out.println(answer);
      }
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     try (     while (true) do (     var strs : Sequence(String) ; strs := br.readLine()->split(" ") ;
     var n : int ; n := (strs[0+1])->toInteger() ;
    var h : int ; h := (strs[1+1])->toInteger() ;
    if (n = 0) then     return else skip ; 
    var xy : Sequence(Sequence(boolean)) ; xy := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ;
    var xz : Sequence(Sequence(boolean)) ; xz := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ;
    var yz : Sequence(Sequence(boolean)) ; yz := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ;
    var answer : int ; answer := n * n * n ;
        var i : int ; i := 0 ; while i < h do ( (     strs := br.readLine()->split(" ") ; 
     var arg1 : int ; arg1 := (strs[1+1])->toInteger() - 1 ;
     var arg2 : int ; arg2 := (strs[2+1])->toInteger() - 1 ;
     if (strs[0+1] = "xy") then (     xy[arg1+1][arg2+1] := true ; 
         var j : int ; j := 0 ; while j < n do ( (     if (xz[arg1+1][j+1]) then     continue else skip ; 
     if (yz[arg2+1][j+1]) then     continue else skip ; 
     answer := answer - 1 )  ;     j := j + 1 ) ) else     if (strs[0+1] = "xz") then (     xz[arg1+1][arg2+1] := true ; 
         var j : int ; j := 0 ; while j < n do ( (     if (xy[arg1+1][j+1]) then     continue else skip ; 
     if (yz[j+1][arg2+1]) then     continue else skip ; 
     answer := answer - 1 )  ;     j := j + 1 ) ) else (     yz[arg1+1][arg2+1] := true ; 
         var j : int ; j := 0 ; while j < n do ( (     if (xy[j+1][arg1+1]) then     continue else skip ; 
     if (xz[j+1][arg2+1]) then     continue else skip ; 
     answer := answer - 1 )  ;     j := j + 1 ) ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 ) )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    boolean[][][] check=new boolean[500][500][500];
    while(true){
      int n=sc.nextInt();
      int h=sc.nextInt();
      if(n==0 && h==0)break ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<n ; j++){
          Arrays.fill(check[i][j],false);
        }
      }
      int count=0 ;
      for(int i=0 ; i<h ; i++){
        String c=sc.next();
        int a=sc.nextInt()-1 ;
        int b=sc.nextInt()-1 ;
        if(c.equals("xy")){
          for(int j=0 ; j<n ; j++){
            if(check[a][b][j])continue ;
            check[a][b][j]=true ;
            count++;
          }
        }
        else if(c.equals("xz")){
          for(int j=0 ; j<n ; j++){
            if(check[a][j][b])continue ;
            check[a][j][b]=true ;
            count++;
          }
        }
        else {
          for(int j=0 ; j<n ; j++){
            if(check[j][a][b])continue ;
            check[j][a][b]=true ;
            count++;
          }
        }
      }
      System.out.println(n*n*n-count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var check : Sequence(Sequence(Sequence(boolean))) ; check := Integer.subrange(1,500)->collect(Integer.subrange(1,500)->collect(Integer.subrange(1,500)->collect(false))) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    if (n = 0 & h = 0) then     break else skip ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     check[i+1][j+1] := check[i+1][j+1]->collect(false) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < h do ( (     var c : String ; c := sc.getCurrent() ;
     var a : int ; a := sc.getCurrent()->toInteger() - 1 ;
     var b : int ; b := sc.getCurrent()->toInteger() - 1 ;
     if (c = "xy") then (         var j : int ; j := 0 ; while j < n do ( (     if (check[a+1][b+1][j+1]) then     continue else skip ; 
     check[a+1][b+1][j+1] := true ; 
     count := count + 1 )  ;     j := j + 1 ) ) else     if (c = "xz") then (         var j : int ; j := 0 ; while j < n do ( (     if (check[a+1][j+1][b+1]) then     continue else skip ; 
     check[a+1][j+1][b+1] := true ; 
     count := count + 1 )  ;     j := j + 1 ) ) else (         var j : int ; j := 0 ; while j < n do ( (     if (check[j+1][a+1][b+1]) then     continue else skip ; 
     check[j+1][a+1][b+1] := true ; 
     count := count + 1 )  ;     j := j + 1 ) ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n * n * n - count) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new AOJ1030().doIt();
  }
  class AOJ1030 {
    void doIt(){
      while(true){
        int n=in.nextInt();
        int h=in.nextInt();
        if(n+h==0)break ;
        int sum=0 ;
        boolean xy[][]=new boolean[n][n];
        boolean yz[][]=new boolean[n][n];
        boolean xz[][]=new boolean[n][n];
        for(int i=0 ; i<h ; i++){
          String command=in.next();
          int a=in.nextInt()-1 ;
          int b=in.nextInt()-1 ;
          if(command.equals("xy")){
            xy[a][b]=true ;
            for(int s=0 ; s<n ; s++)if(! yz[b][s])if(! xz[a][s])sum++;
          }
          else if(command.equals("yz")){
            yz[a][b]=true ;
            for(int s=0 ; s<n ; s++)if(! xy[s][a])if(! xz[s][b])sum++;
          }
          else if(command.equals("xz")){
            xz[a][b]=true ;
            for(int s=0 ; s<n ; s++)if(! yz[s][b])if(! xy[a][s])sum++;
          }
        }
        System.out.println(n*n*n-sum);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     AOJ1030.newAOJ1030().doIt() );
 class AOJ1030 {
   operation doIt() : void
  pre: true
  post: true
  activity: (     while (true) do (     var n : int ; n := in.getCurrent()->toInteger() ;
     var h : int ; h := in.getCurrent()->toInteger() ;
    if (n + h = 0) then     break else skip ; 
    var sum : int ; sum := 0 ;
    var xy : Sequence(Sequence(boolean)) ; xy := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ;
    var yz : Sequence(Sequence(boolean)) ; yz := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ;
    var xz : Sequence(Sequence(boolean)) ; xz := Integer.subrange(1,n)->collect(Integer.subrange(1,n)->collect(false)) ;
        var i : int ; i := 0 ; while i < h do ( (     var command : String ; command := in.getCurrent() ;
     var a : int ; a := in.getCurrent()->toInteger() - 1 ;
     var b : int ; b := in.getCurrent()->toInteger() - 1 ;
     if (command = "xy") then (     xy[a+1][b+1] := true ; 
         var s : int ; s := 0 ; while s < n do (     if (not(yz[b+1][s+1])) then     if (not(xz[a+1][s+1])) then     sum := sum + 1 ; else skip ; else skip ;  ;     s := s + 1 ) ) else     if (command = "yz") then (     yz[a+1][b+1] := true ; 
         var s : int ; s := 0 ; while s < n do (     if (not(xy[s+1][a+1])) then     if (not(xz[s+1][b+1])) then     sum := sum + 1 ; else skip ; else skip ;  ;     s := s + 1 ) ) else     if (command = "xz") then (     xz[a+1][b+1] := true ; 
         var s : int ; s := 0 ; while s < n do (     if (not(yz[s+1][b+1])) then     if (not(xy[a+1][s+1])) then     sum := sum + 1 ; else skip ; else skip ;  ;     s := s + 1 ) ) else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(n * n * n - sum) ; 
 ) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public final class p058 implements EulerSolution {
  public static void main(String[] args){
    System.out.println(new p058().run());
  }
  public String run(){
    int numPrimes=0 ;
    for(int n=1 ; ; n+=2){
      for(int i=0 ; i<4 ; i++){
        if(Library.isPrime(n*n-i*(n-1)))numPrimes++;
      }
      if(n>1 && numPrimes*10<n*2-1)return Integer.toString(n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class p058 implements EulerSolution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(p058.newp058().run()) );
   operation run() : String
  pre: true
  post: true
  activity: (     var numPrimes : int ; numPrimes := 0 ;
         var n : int ; n := 1 ; while true do ( (         var i : int ; i := 0 ; while i < 4 do ( (     if (Library.isPrime(n * n - i * (n - 1))) then     numPrimes := numPrimes + 1 ; else skip )  ;     i := i + 1 ) ; 
     if (n > 1 & numPrimes * 10 < n * 2 - 1) then     return ((n) + "") else skip )  ;     n := n+(2) ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  static int PLUS=10000 ;
  static boolean check(int start,int x,List<Integer>a){
    boolean[] dp=new boolean[20002];
    dp[start]=true ;
    for(int i=0 ; i<a.size(); i++){
      boolean[] next_dp=new boolean[20002];
      for(int j=0 ; j<20002 ; j++){
        if(! dp[j]){
          continue ;
        }
        next_dp[j+a.get(i)]=true ;
        next_dp[j-a.get(i)]=true ;
      }
      dp=Arrays.copyOf(next_dp,20002);
    }
    return dp[x];
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String s=sc.next();
      int x=sc.nextInt()+PLUS ;
      int y=sc.nextInt()+PLUS ;
      List<Integer>ax=new ArrayList<>();
      List<Integer>ay=new ArrayList<>();
      boolean isOdd=false ;
      for(int i=0 ; i<s.length(); i++){
        int cnt=0 ;
        while(i<s.length()&& s.charAt(i)=='F'){
          cnt++;
          i++;
        }
        if(isOdd){
          ay.add(cnt);
        }
        else {
          ax.add(cnt);
        }
        isOdd=! isOdd ;
      }
      int nowX=PLUS+ax.get(0);
      int nowY=PLUS ;
      if(check(nowX,x,ax.subList(1,ax.size()))&& check(nowY,y,ay)){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute PLUS : int := 10000;
  static   operation check( start : int, x : int, a : Sequence(int)) : boolean
  pre: true
  post: true
  activity: (     var dp : Sequence(boolean) ; dp := Integer.subrange(1,20002)->collect(false) ;
     dp[start+1] := true ; 
         var i : int ; i := 0 ; while i < a->size() do ( (     var next_dp : Sequence(boolean) ; next_dp := Integer.subrange(1,20002)->collect(false) ;
         var j : int ; j := 0 ; while j < 20002 do ( (     if (not(dp[j+1])) then (     continue ) else skip ; 
     next_dp[j + a->at(i+1)+1] := true ; 
     next_dp[j - a->at(i+1)+1] := true )  ;     j := j + 1 ) ; 
     dp := next_dp.subrange(1,20002) )  ;     i := i + 1 ) ; 
     return dp[x+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (sc.hasNext()) do (     var s : String ; s := sc.getCurrent() ;
     var x : int ; x := sc.getCurrent()->toInteger() + PLUS ;
    var y : int ; y := sc.getCurrent()->toInteger() + PLUS ;
    var ax : Sequence(int) ; ax := Sequence{} ;
    var ay : Sequence(int) ; ay := Sequence{} ;
    var isOdd : boolean ; isOdd := false ;
        var i : int ; i := 0 ; while i < s->size() do ( (     var cnt : int ; cnt := 0 ;
     while (i < s->size() & s->at(i+1) = 'F') do (     cnt := cnt + 1 ; 
     i := i + 1 ) ; 
     if (isOdd) then (     ay := ay->including(cnt) ) else (     ax := ax->including(cnt) ) ;  
     isOdd := not(isOdd) )  ;     i := i + 1 ) ; 
    var nowX : int ; nowX := PLUS + ax->at(0+1) ;
    var nowY : int ; nowY := PLUS ;
    if (check(nowX, x, ax.subrange(1+1,ax->size())) & check(nowY, y, ay)) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String s1=scanner.next();
    String s2=scanner.next();
    int left=0 ;
    int right=0 ;
    System.out.print(s1.charAt(left));
    left++;
    while(left<s1.length()){
      if(s1.charAt(left)<s2.charAt(right)){
        System.out.print(s1.charAt(left));
        left++;
      }
      else {
        break ;
      }
    }
    System.out.print(s2.charAt(right));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s1 : String ; s1 := scanner.getCurrent() ;
    var s2 : String ; s2 := scanner.getCurrent() ;
    var left : int ; left := 0 ;
    var right : int ; right := 0 ;
    OclFile["System.out"].print(s1->at(left+1)) ; 
    left := left + 1 ; 
    while (left < s1->size()) do (     if (s1->at(left+1) < s2->at(right+1)) then (     OclFile["System.out"].print(s1->at(left+1)) ; 
     left := left + 1 ) else (     break ) ) ; 
    OclFile["System.out"].print(s2->at(right+1)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    String[] line=scanner.nextLine().split(" ");
    int n=Integer.parseInt(line[0]);
    int m=Integer.parseInt(line[1]);
    long result=0 ;
    if(Math.abs(n-m)>1){
      result=0 ;
    }
    else if(Math.abs(n-m)==1){
      result=factorialsModBillion(n,m);
    }
    else {
      result=factorialsModBillion(n,m);
      result=(result*2)% 1000000007L ;
    }
    System.out.println(result);
  }
  private static long factorialsModBillion(int n,int m){
    long result=1 ;
    for(long i=1 ; i<=n ; i++){
      result=(result*i)% 1000000007L ;
    }
    for(long i=1 ; i<=m ; i++){
      result=(result*i)% 1000000007L ;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var line : Sequence(String) ; line := scanner.nextLine()->split(" ") ;
    var n : int ; n := (line[0+1])->toInteger() ;
    var m : int ; m := (line[1+1])->toInteger() ;
    var result : long ; result := 0 ;
    if (if n - m < 0 then -(n - m) else n - m endif > 1) then (     result := 0 ) else     if (if n - m < 0 then -(n - m) else n - m endif = 1) then (     result := factorialsModBillion(n, m) ) else (     result := factorialsModBillion(n, m) ; 
     result := (result * 2) mod 1000000007L ) ;  ;  
    OclFile["System.out"].println(result) ; 
 );
  static   operation factorialsModBillion( n : int, m : int) : long
  pre: true
  post: true
  activity: (     var result : long ; result := 1 ;
         var i : long ; i := 1 ; while i <= n do ( (     result := (result * i) mod 1000000007L )  ;     i := i + 1 ) ; 
         var i : long ; i := 1 ; while i <= m do ( (     result := (result * i) mod 1000000007L )  ;     i := i + 1 ) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.util.InputMismatchException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskC solver=new TaskC();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskC {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      long n=in.nextLong();
      long m=in.nextLong();
      if(Math.abs(n-m)>=2){
        out.println(0);
        return ;
      }
      long ans=1 ;
      long MOD=1_000_000_007 ;
      for(int i=1 ; i<=n ; i++){
        ans=(ans*i)% MOD ;
      }
      for(int i=1 ; i<=m ; i++){
        ans=(ans*i)% MOD ;
      }
      if(n==m)ans=(ans*2)% MOD ;
      out.println(ans);
    }
  }
  static class InputReader {
    BufferedReader in ;
    StringTokenizer tok ;
    public String nextString(){
      while(! tok.hasMoreTokens()){
        try {
          tok=new StringTokenizer(in.readLine()," ");
        }
        catch(IOException e){
          throw new InputMismatchException();
        }
      }
      return tok.nextToken();
    }
    public long nextLong(){
      return Long.parseLong(nextString());
    }
    public InputReader(InputStream inputStream){
      in=new BufferedReader(new InputStreamReader(inputStream));
      tok=new StringTokenizer("");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskC ; solver := TaskC.newTaskC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskC {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : long ; n := in.nextLong() ;
     var m : long ; m := in.nextLong() ;
    if (if n - m < 0 then -(n - m) else n - m endif >= 2) then (     skip ; 
     return ) else skip ; 
    var ans : long ; ans := 1 ;
    var MOD : long ; MOD := 1_000_000_007 ;
        var i : int ; i := 1 ; while i <= n do ( (     ans := (ans * i) mod MOD )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= m do ( (     ans := (ans * i) mod MOD )  ;     i := i + 1 ) ; 
    if (n = m) then     ans := (ans * 2) mod MOD ; else skip ; 
    skip ; 
 );
}
  static class InputReader {
   attribute in : OclFile;
   attribute tok : OclIterator;
   operation nextString() : String
  pre: true
  post: true
  activity: (     while (not(tok.hasNext())) do (     try (     tok := OclIterator.newOclIterator_String_String(in.readLine(), " ") )   catch (e : IOException) do (     error IncorrectElementException() )
 ) ; 
     return tok.next() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextString())->toLong() );
   static operation newInputReader( inputStream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) ; 
     tok := OclIterator.newOclIterator_String("") );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    Long facN=this.calcfac(N);
    Long facM=this.calcfac(M);
    if(N==M){
      System.out.println(2*facN*facM % 1000000007);
    }
    else if(N+1==M || N==M+1){
      System.out.println(facN*facM % 1000000007);
    }
    else {
      System.out.println(0);
    }
  }
  Long calcfac(int num){
    Long sum=new Long(1);
    for(int i=num ; i>0 ; i--){
      sum*=i ;
      sum %=1000000007 ;
    }
    return sum ;
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var facN : long ; facN := self.calcfac(N) ;
    var facM : long ; facM := self.calcfac(M) ;
    if (N = M) then (     OclFile["System.out"].println(2 * facN * facM mod 1000000007) ) else     if (N + 1 = M or N = M + 1) then (     OclFile["System.out"].println(facN * facM mod 1000000007) ) else (     OclFile["System.out"].println(0) ) ;  ;  
 );
   operation calcfac( num : int) : long
  pre: true
  post: true
  activity: (     var sum : long ; sum := ("" + (1))->toLong() ;
         var i : int ; i := num ; while i > 0 do ( (     sum := sum*(i) ; 
     sum := sum mod 1000000007 )  ;     i := i - 1 ) ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    int m=Integer.parseInt(str[1]);
    long base=(long)1e9+7 ;
    long ans=1 ;
    if(Math.abs(n-m)==0){
      ans*=2 ;
      ans %=base ;
    }
    else if(Math.abs(n-m)>1){
      System.out.println(0);
      System.exit(0);
    }
    for(int i=1 ; i<=n ; i++){
      ans*=i ;
      ans %=base ;
    }
    for(int i=1 ; i<=m ; i++){
      ans*=i ;
      ans %=base ;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    var m : int ; m := (str[1+1])->toInteger() ;
    var base : long ; base := 1e9->oclAsType(long) + 7 ;
    var ans : long ; ans := 1 ;
    if (if n - m < 0 then -(n - m) else n - m endif = 0) then (     ans := ans*(2) ; 
     ans := ans mod base ) else     if (if n - m < 0 then -(n - m) else n - m endif > 1) then (     OclFile["System.out"].println(0) ; 
 OclProcess.exit(0) ) else skip ; ;  
        var i : int ; i := 1 ; while i <= n do ( (     ans := ans*(i) ; 
     ans := ans mod base )  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= m do ( (     ans := ans*(i) ; 
     ans := ans mod base )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long k=sc.nextLong();
    System.out.println(50);
    long p=k/50 ;
    long q=k % 50 ;
    for(long i=0 ; i<q ; i++)System.out.print((49-(q-1)+p+50)+" ");
    for(long i=q ; i<50 ; i++)System.out.print((49-q+p)+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : long ; k := sc.getCurrent()->toLong() ;
    OclFile["System.out"].println(50) ; 
    var p : long ; p := k / 50 ;
    var q : long ; q := k mod 50 ;
        var i : long ; i := 0 ; while i < q do (     OclFile["System.out"].print((49 - (q - 1) + p + 50) + " ") ;  ;     i := i + 1 ) ; 
        var i : long ; i := q ; while i < 50 do (     OclFile["System.out"].print((49 - q + p) + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.io.BufferedInputStream ;
import java.lang.Math ;
public class Main {
  static long tmp=10000*10000 ;
  static long MAX_COUNT=tmp*tmp+999 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(new BufferedInputStream(System.in));
    long K=sc.nextLong();
    for(int N=2 ; N<=50 ; N++){
      if(solve(K,N)){
        break ;
      }
    }
  }
  static boolean solve(long K,int N){
    long C=K/N+N-1 ;
    long[] A=new long[N];
    for(int i=0 ; i<N ; i++){
      A[i]=C ;
    }
    for(int i=0 ; i<(K % N); i++){
      long max=0 ;
      int p=0 ;
      for(int j=0 ; j<N ; j++){
        if(A[j]>A[p]){
          p=j ;
          max=A[j];
        }
      }
      for(int j=0 ; j<N ; j++){
        if((A[j]+N+1>max)&&(A[j]<A[p])){
          p=j ;
        }
      }
      for(int j=0 ; j<N ; j++){
        A[j]=A[j]-1 ;
      }
      A[p]=A[p]+N+1 ;
    }
    for(int i=0 ; i<N ; i++){
      if(A[i]<0){
        return false ;
      }
      if(A[i]>MAX_COUNT){
        return false ;
      }
    }
    System.out.println(N);
    for(int i=0 ; i<N ; i++){
      System.out.println(A[i]+" ");
    }
    return true ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute tmp : long := 10000 * 10000;
  static   attribute MAX_COUNT : long := tmp * tmp + 999;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var K : long ; K := sc.getCurrent()->toLong() ;
         var N : int ; N := 2 ; while N <= 50 do ( (     if (solve(K, N)) then (     break ) else skip )  ;     N := N + 1 ) );
  static   operation solve( K : long, N : int) : boolean
  pre: true
  post: true
  activity: (     var C : long ; C := K / N + N - 1 ;
     var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := C )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < (K mod N) do ( (     var max : long ; max := 0 ;
     var p : int ; p := 0 ;
        var j : int ; j := 0 ; while j < N do ( (     if (A[j+1] > A[p+1]) then (     p := j ; 
     max := A[j+1] ) else skip )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < N do ( (     if ((A[j+1] + N + 1 > max) & (A[j+1] < A[p+1])) then (     p := j ) else skip )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < N do ( (     A[j+1] := A[j+1] - 1 )  ;     j := j + 1 ) ; 
    A[p+1] := A[p+1] + N + 1 ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (A[i+1] < 0) then (     return false ) else skip ; 
     if (A[i+1] > MAX_COUNT) then (     return false ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(N) ; 
        var i : int ; i := 0 ; while i < N do ( (     OclFile["System.out"].println(A[i+1] + " ") )  ;     i := i + 1 ) ; 
    return true 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner();
    PrintWriter out=new PrintWriter(System.out);
    long K=sc.nextLong();
    int n=50 ;
    long x=(K+n*n-n)/n ;
    long[] arr=new long[n];
    for(int i=0 ; i<n ; i++)arr[i]=x ;
    long rem=K-(x*n-n*n+n);
    for(int i=0 ; i<rem ; i++){
      arr[i]+=n ;
      for(int j=0 ; j<n ; j++)if(i!=j)arr[j]--;
    }
    out.println(n);
    for(long z : arr)out.println(z);
    out.close();
  }
  static class Scanner {
    BufferedReader br ;
    StringTokenizer st ;
    Scanner(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    Scanner(String fileName)throws FileNotFoundException {
      br=new BufferedReader(new FileReader(fileName));
    }
    String next()throws IOException {
      while(st==null || ! st.hasMoreTokens())st=new StringTokenizer(br.readLine());
      return st.nextToken();
    }
    String nextLine()throws IOException {
      return br.readLine();
    }
    int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    long nextLong()throws NumberFormatException,IOException {
      return Long.parseLong(next());
    }
    double nextDouble()throws NumberFormatException,IOException {
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := (arguments ( )) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var K : long ; K := sc.getCurrent()->toLong() ;
    var n : int ; n := 50 ;
    var x : long ; x := (K + n * n - n) / n ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := x ;  ;     i := i + 1 ) ; 
    var rem : long ; rem := K - (x * n - n * n + n) ;
        var i : int ; i := 0 ; while i < rem do ( (     arr[i+1] := arr[i+1]+(n) ; 
         var j : int ; j := 0 ; while j < n do (     if (i /= j) then     arr[j+1] := arr[j+1] - 1 ; else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    for (z : arr) do (     skip ;  ) ; 
    skip ; 
 );
  static class Scanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newScanner() : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   static operation newScanner( fileName : String) : Scanner
  pre: true
  post: true
  activity:
  ( var self : Scanner ;
    self := createScanner();
    self.initialise(fileName);
    return self );
  operation initialise( fileName : String) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(fileName)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static final int MAX_LEN=50 ;
  void run(){
    Scanner scan=new Scanner(System.in);
    long k=scan.nextLong();
    long[] a=new long[MAX_LEN];
    for(int i=0 ; i<MAX_LEN ; i++)a[i]=i ;
    long n=k/MAX_LEN ;
    for(int i=0 ; i<MAX_LEN ; i++)a[i]+=n ;
    n=k % MAX_LEN ;
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<MAX_LEN ; j++){
        if(j==i)a[j]+=MAX_LEN ;
        else a[j]-=1 ;
      }
    }
    System.out.println(MAX_LEN);
    for(int i=0 ; i<MAX_LEN-1 ; i++)System.out.print(a[i]+" ");
    System.out.println(a[MAX_LEN-1]);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX_LEN : int := 50;
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var k : long ; k := scan.getCurrent()->toLong() ;
    var a : Sequence(long) ; a := Integer.subrange(1,MAX_LEN)->collect(0) ;
        var i : int ; i := 0 ; while i < MAX_LEN do (     a[i+1] := i ;  ;     i := i + 1 ) ; 
    var n : long ; n := k / MAX_LEN ;
        var i : int ; i := 0 ; while i < MAX_LEN do (     a[i+1] := a[i+1]+(n) ;  ;     i := i + 1 ) ; 
    n := k mod MAX_LEN ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < MAX_LEN do ( (     if (j = i) then     a[j+1] := a[j+1]+(MAX_LEN) ; else     a[j+1] := a[j+1]-(1) ; )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(MAX_LEN) ; 
        var i : int ; i := 0 ; while i < MAX_LEN - 1 do (     OclFile["System.out"].print(a[i+1] + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a[MAX_LEN - 1+1]) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner s=new Scanner(System.in);
  static int gInt(){
    return Integer.parseInt(s.next());
  }
  public static void main(String[] $){
    String v=s.next();
    int x=gInt(),y=gInt();
    ArrayList<Integer>dx=new ArrayList<>(),dy=new ArrayList<>();
    boolean dir=true ;
    int d=0 ;
    for(int i=0 ; i<v.length(); i++){
      if(v.charAt(i)=='T'){
(dir ? dx : dy).add(d);
        d=0 ;
        dir ^=true ;
      }
      else {
        d++;
      }
    }
(dir ? dx : dy).add(d);
    x-=dx.remove(0);
    System.out.println(dp(dx,x)&& dp(dy,y)? "Yes" : "No");
  }
  static boolean dp(List<Integer>list,int goal){
    Set<Integer>set=new HashSet<>(),buf=new HashSet<>();
    set.add(0);
    for(int v : list){
      buf.clear();
      for(int base : set){
        buf.add(base+v);
        buf.add(base-v);
      }
      set.clear();
      set.addAll(buf);
    }
    return set.contains(goal);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute s : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation gInt() : int
  pre: true
  post: true
  activity: (     return (s.getCurrent())->toInteger() );
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var v : String ; v := s.getCurrent() ;
     var x : int ; x := gInt() ;
    var y : int ; y := gInt() ;
    var dx : Sequence(int) ; dx := Sequence{} ;
    var dy : Sequence(int) ; dy := Sequence{} ;
    var dir : boolean ; dir := true ;
    var d : int ; d := 0 ;
        var i : int ; i := 0 ; while i < v->size() do ( (     if (v->at(i+1) = 'T') then (     (if dir then dx else dy endif)->excludes(d) ; 
     d := 0 ; 
     dir := MathLib.bitwiseXor(dir,true) ) else (     d := d + 1 ) )  ;     i := i + 1 ) ; 
    (if dir then dx else dy endif)->excludes(d) ; 
    x := x - (dx->at(0+1)) ;     dx := dx->excludingAt(0+1) ; 
    OclFile["System.out"].println(if dp(dx, x) & dp(dy, y) then "Yes" else "No" endif) ; 
 );
  static   operation dp( list : Sequence(int), goal : int) : boolean
  pre: true
  post: true
  activity: (     var set : Set(int) ; set := Set{} ;
    var buf : Set(int) ; buf := Set{} ;
     set := set->including(0) ; 
     for (v : list) do ( (     buf := buf->intersection(Set{}) ; 
     for (base : set) do ( (     buf->excludes(base + v) ; 
     buf->excludes(base - (v)->char2byte()) )  ) ; 
     set := set->intersection(Set{}) ; 
     set := set->union(buf) )  ) ; 
     return set->includes(goal) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static final int MAX_N=50 ;
  public static void main(String[] args){
    final long K ;
    try(Scanner in=new Scanner(System.in)){
      K=in.nextLong();
    }
    long[] xs=new long[MAX_N];
    final int N=50 ;
    for(int i=0 ; i<N ; i++){
      if(i<K % N){
        xs[i]=i+(K/N+1)*(N+1)-K ;
      }
      else {
        xs[i]=i+K/N*(N+1)-K ;
      }
    }
    System.out.printf("%d\n",N);
    System.out.printf("%d",xs[0]);
    for(int i=1 ; i<N ; i++){
      System.out.printf(" %d",xs[i]);
    }
    System.out.printf("\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX_N : int := 50;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var K : long ;
     try (    var in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     K := in.getCurrent()->toLong() ))  
    var xs : Sequence(long) ; xs := Integer.subrange(1,MAX_N)->collect(0) ;
    var N : int ; N := 50 ;
        var i : int ; i := 0 ; while i < N do ( (     if (i < K mod N) then (     xs[i+1] := i + (K / N + 1) * (N + 1) - K ) else (     xs[i+1] := i + K / N * (N + 1) - K ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("%d\n", N) ; 
    OclFile["System.out"].printf("%d", xs[0+1]) ; 
        var i : int ; i := 1 ; while i < N do ( (     OclFile["System.out"].printf(" %d", xs[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].printf("\n") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void printPattern(int n){
    if(n==0 || n<0){
      System.out.print(n+" ");
      return ;
    }
    System.out.print(n+" ");
    printPattern(n-5);
    System.out.print(n+" ");
  }
  public static void main(String[] args){
    int n=16 ;
    printPattern(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printPattern( n : int) : void
  pre: true
  post: true
  activity: (     if (n = 0 or n < 0) then (     OclFile["System.out"].print(n + " ") ; 
     return ) else skip ; 
     OclFile["System.out"].print(n + " ") ; 
     execute printPattern(n - 5) ; 
     OclFile["System.out"].print(n + " ") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 16 ;
     execute printPattern(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class BS_TEST_2 {
  public static int minimum_binary_deci_number(String s){
    int m=Integer.MIN_VALUE ;
    for(int i=0 ; i<s.length(); i++){
      int temp=s.charAt(i)-'0' ;
      if(temp>m){
        m=temp ;
      }
    }
    return m ;
  }
  public static void main(String[] args){
    Integer tCase ;
    Scanner userInput=new Scanner(System.in);
    tCase=userInput.nextInt();
    userInput.nextLine();
    String[] values=new String[tCase];
    for(int i=0 ; i<tCase ; i++){
      values[i]=userInput.nextLine();
    }
    for(int j=0 ; j<values.length ; j++){
      System.out.println(minimum_binary_deci_number(values[j]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class BS_TEST{
  static   operation minimum_binary_deci_number( s : String) : int
  pre: true
  post: true
  activity: (     var m : int ; m := -2147483648 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     var temp : int ; temp := s->at(i+1) - ('0')->char2byte() ;
     if (temp > m) then (     m := temp ) else skip )  ;     i := i + 1 ) ; 
     return m );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var tCase : int ;
     var userInput : OclFile ; userInput := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    tCase := userInput.getCurrent()->toInteger() ; 
    skip ; 
    var values : Sequence(String) ; values := Integer.subrange(1,tCase)->collect(null) ;
        var i : int ; i := 0 ; while i < tCase do ( (     values[i+1] := userInput.nextLine() )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < values->size() do ( (     OclFile["System.out"].println(minimum_binary_deci_number(values[j+1])) )  ;     j := j + 1 ) ; 
 );
}
 {
  static   operation minimum_binary_deci_number( s : String) : int
  pre: true
  post: true
  activity: (     var m : int ; m := -2147483648 ;
         var i : int ; i := 0 ; while i < s->size() do ( (     var temp : int ; temp := s->at(i+1) - ('0')->char2byte() ;
     if (temp > m) then (     m := temp ) else skip )  ;     i := i + 1 ) ; 
     return m );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var tCase : int ;
     var userInput : OclFile ; userInput := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    tCase := userInput.getCurrent()->toInteger() ; 
    skip ; 
    var values : Sequence(String) ; values := Integer.subrange(1,tCase)->collect(null) ;
        var i : int ; i := 0 ; while i < tCase do ( (     values[i+1] := userInput.nextLine() )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < values->size() do ( (     OclFile["System.out"].println(minimum_binary_deci_number(values[j+1])) )  ;     j := j + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int invertBits(int n){
    int x=(int)(Math.log(n)/Math.log(2));
    int m=1<<x ;
    m=m | m-1 ;
    n=n ^ m ;
    return n ;
  }
  public static void main(String[] args){
    int n=20 ;
    System.out.print(invertBits(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation invertBits( n : int) : int
  pre: true
  post: true
  activity: (     var x : int ; x := ((n)->log() / (2)->log())->oclAsType(int) ;
     var m : int ; m := (1*(2->pow(x)))->oclAsType(long) ;
    m := MathLib.bitwiseOr(m,m - 1) ; 
    n := n xor m ; 
    return n 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 20 ;
     OclFile["System.out"].print(invertBits(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static int largestCoprime(int N){
    if(N==6)return 1 ;
    else if(N % 4==0)return(N/2)-1 ;
    else if(N % 2==0)return(N/2)-2 ;
    else return((N-1)/2);
  }
  public static void main(String[] args){
    int n=50 ;
    System.out.println(largestCoprime(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation largestCoprime( N : int) : int
  pre: true
  post: true
  activity: (     if (N = 6) then     return 1 else     if (N mod 4 = 0) then     return (N / 2) - 1 else     if (N mod 2 = 0) then     return (N / 2) - 2 else     return ((N - 1) / 2) ;  ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 50 ;
     OclFile["System.out"].println(largestCoprime(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int N=4 ;
  static void multiply(int mat1[][],int mat2[][],int res[][]){
    int i,j,k ;
    for(i=0 ; i<N ; i++){
      for(j=0 ; j<N ; j++){
        res[i][j]=0 ;
        for(k=0 ; k<N ; k++)res[i][j]+=mat1[i][k]*mat2[k][j];
      }
    }
  }
  public static void main(String[] args){
    int mat1[][]={
      {
        1,1,1,1 },{
          2,2,2,2 },{
            3,3,3,3 },{
              4,4,4,4 }
            };
            int mat2[][]={
              {
                1,1,1,1 },{
                  2,2,2,2 },{
                    3,3,3,3 },{
                      4,4,4,4 }
                    };
                    int res[][]=new int[N][N];
                    int i,j ;
                    multiply(mat1,mat2,res);
                    System.out.println("Result matrix"+" is ");
                    for(i=0 ; i<N ; i++){
                      for(j=0 ; j<N ; j++)System.out.print(res[i][j]+" ");
                      System.out.println();
                    }
                  }
                }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute N : int := 4;
  static   operation multiply( mat1 : Sequence(Sequence(int)), mat2 : Sequence(Sequence(int)), res : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
    var k : int ;
         i := 0 ; while i < N do ( (         j := 0 ; while j < N do ( (     res[i+1][j+1] := 0 ; 
         k := 0 ; while k < N do (     res[i+1][j+1] := res[i+1][j+1]+(mat1[i+1][k+1] * mat2[k+1][j+1]) ;  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat1 : Sequence(Sequence(int)) ; mat1 := Sequence{Sequence{1,1,1,1},Sequence{2,2,2,2},Sequence{3,3,3,3},Sequence{4,4,4,4}} ;
     var mat2 : Sequence(Sequence(int)) ; mat2 := Sequence{Sequence{1,1,1,1},Sequence{2,2,2,2},Sequence{3,3,3,3},Sequence{4,4,4,4}} ;
    var res : Sequence(Sequence(int)) ; res := Integer.subrange(1,N)->collect(Integer.subrange(1,N)->collect(0)) ;
    var i : int ;
    var j : int ;
    execute multiply(mat1, mat2, res) ; 
    OclFile["System.out"].println("Result matrix" + " is ") ; 
        i := 0 ; while i < N do ( (         j := 0 ; while j < N do (     OclFile["System.out"].print(res[i+1][j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    Set<String>a=new HashSet<>();
    for(int i=0 ; i<N ; i++){
      String di=sc.next();
      a.add(di);
    }
    System.out.println(a.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var a : Set(String) ; a := Set{} ;
        var i : int ; i := 0 ; while i < N do ( (     var di : String ; di := sc.getCurrent() ;
     a := a->including(di) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(a->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.HashSet ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    FastReader in=new FastReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CGacha solver=new CGacha();
    solver.solve(1,in,out);
    out.close();
  }
  static class CGacha {
    public void solve(int testNumber,FastReader in,PrintWriter out){
      int n=in.nextInt();
      HashSet<String>hs=new HashSet<>();
      for(int i=0 ; i<n ; i++){
        hs.add(in.nextLine().trim());
      }
      out.print(hs.size());
    }
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(InputStream inputStream){
      br=new BufferedReader(new InputStreamReader(inputStream));
    }
    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(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : FastReader ; in := FastReader.newFastReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CGacha ; solver := CGacha.newCGacha() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CGacha {
   operation solve( testNumber : int, in : FastReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.nextInt() ;
     var hs : Set(String) ; hs := Set{} ;
         var i : int ; i := 0 ; while i < n do ( (     hs := hs->including(in.nextLine()->trim()) )  ;     i := i + 1 ) ; 
     skip );
}
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader( inputStream : OclFile) : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise(inputStream);
    return self );
  operation initialise( inputStream : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputStream)) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.InputStreamReader ;
import java.io.OutputStreamWriter ;
import java.util.LinkedHashSet ;
import java.util.Set ;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    int n=Integer.parseInt(br.readLine());
    Set<String>set=new LinkedHashSet<>();
    for(int i=0 ; i<n ; i++){
      set.add(br.readLine());
    }
    br.close();
    bw.write(String.valueOf(set.size()));
    bw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := (br.readLine())->toInteger() ;
    var set : Set(String) ; set := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     set := set->including(br.readLine()) )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    String[] mozi=new String[n];
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      mozi[i]=scan.next();
    }
    List<String>listA=new ArrayList<String>(Arrays.asList(mozi));
    List<String>listB=new ArrayList<String>(new HashSet<>(listA));
    for(String s : listB){
      count++;
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var mozi : Sequence(String) ; mozi := Integer.subrange(1,n)->collect(null) ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     mozi[i+1] := scan.getCurrent() )  ;     i := i + 1 ) ; 
    var listA : Sequence(String) ; listA := Sequence{}->union(mozi) ;
    var listB : Sequence(String) ; listB := Sequence{}->union(Set{}->union(listA)) ;
    for (s : listB) do ( (     count := count + 1 )  ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner scanner=new Scanner(System.in);
  public static void main(String[] $){
    String[] s=scanner.next().split("T");
    int x=scanner.nextInt();
    int y=scanner.nextInt();
    List<Integer>xList=new ArrayList<>();
    List<Integer>yList=new ArrayList<>();
    int i=0 ;
    for(String t : s){
      if(i++% 2==0){
        xList.add(t.length());
      }
      else {
        yList.add(t.length());
      }
    }
    if(x<0 && xList.stream().mapToInt(Integer :: intValue).sum()<=-x && xList.get(0)!=0){
      System.out.println("No");
    }
    else {
      System.out.println(f(xList.toArray(new Integer[0]),x)&& f(yList.toArray(new Integer[0]),y)? "Yes" : "No");
    }
  }
  static boolean f(Integer[] a,int n){
    boolean[][] dp=new boolean[a.length+1][18000];
    dp[0][9000]=true ;
    for(int i=0 ; i<a.length ; i++){
      for(int j=0 ; j<18000 ; j++){
        if(0<=j-a[i]){
          dp[i+1][j] |=dp[i][j-a[i] ];
        }
        if(18000>j+a[i]){
          dp[i+1][j] |=dp[i][j+a[i] ];
        }
      }
    }
    return dp[a.length][n+9000];
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : Sequence(String) ; s := scanner.getCurrent()->split("T") ;
     var x : int ; x := scanner.getCurrent()->toInteger() ;
    var y : int ; y := scanner.getCurrent()->toInteger() ;
    var xList : Sequence(int) ; xList := Sequence{} ;
    var yList : Sequence(int) ; yList := Sequence{} ;
    var i : int ; i := 0 ;
    for (t : s) do ( (     if (i mod 2 = 0) then (     xList := xList->including(t->size()) ) else (     yList := yList->including(t->size()) ) )  ) ; 
    if (x < 0 & xList->collect( _x1 | (lambda _pars : OclAny in Integer.newInteger().intValue(_pars))->apply(_x1) )->sum() <= -x & xList->at(0+1) /= 0) then (     OclFile["System.out"].println("No") ) else (     OclFile["System.out"].println(if f(xList->asSequence(), x) & f(yList->asSequence(), y) then "Yes" else "No" endif) ) ;  
 );
  static   operation f( a : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var dp : Sequence(Sequence(boolean)) ; dp := Integer.subrange(1,a->size() + 1)->collect(Integer.subrange(1,18000)->collect(false)) ;
     dp[0+1][9000+1] := true ; 
         var i : int ; i := 0 ; while i < a->size() do ( (         var j : int ; j := 0 ; while j < 18000 do ( (     if (0 <= j - a[i+1]) then (     dp[i + 1+1][j+1] := MathLib.bitwiseOr(dp[i + 1+1][j+1], dp[i+1][j - a[i+1]+1]) ) else skip ; 
     if (18000 > j + a[i+1]) then (     dp[i + 1+1][j+1] := MathLib.bitwiseOr(dp[i + 1+1][j+1], dp[i+1][j + a[i+1]+1]) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return dp[a->size()+1][n + 9000+1] );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.math.RoundingMode ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    List<String>listA=new ArrayList<String>();
    for(int i=0 ; i<N ; i++){
      String s=sc.next();
      listA.add(s);
    }
    List<String>listB=new ArrayList<String>(new HashSet<>(listA));
    System.out.println(listB.size());
  }
  private static long gcd(long a,long b){
    if(b==0){
      return a ;
    }
    return gcd(b,a % b);
  }
  private static long gcdex(long param[]){
    long g=gcd(param[0],param[1]);
    for(int i=1 ; i<param.length-1 ; i++){
      g=gcd(g,param[i+1]);
    }
    return g ;
  }
  private static long lcm(long a,long b){
    return(a*b)/gcd(a,b);
  }
  private static long all(long n,long count,int N){
    if(count==N){
      return count ;
    }
    return all(1,count,N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var listA : Sequence(String) ; listA := Sequence{} ;
        var i : int ; i := 0 ; while i < N do ( (     var s : String ; s := sc.getCurrent() ;
     listA := listA->including(s) )  ;     i := i + 1 ) ; 
    var listB : Sequence(String) ; listB := Sequence{}->union(Set{}->union(listA)) ;
    OclFile["System.out"].println(listB->size()) ; 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (b = 0) then (     return a ) else skip ; 
     return gcd(b, a mod b) );
  static   operation gcdex( param : Sequence(long)) : long
  pre: true
  post: true
  activity: (     var g : long ; g := gcd(param[0+1], param[1+1]) ;
         var i : int ; i := 1 ; while i < param->size() - 1 do ( (     g := gcd(g, param[i + 1+1]) )  ;     i := i + 1 ) ; 
     return g );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a * b) / gcd(a, b) );
  static   operation all( n : long, count : long, N : int) : long
  pre: true
  post: true
  activity: (     if (count = N) then (     return count ) else skip ; 
     return all(1, count, N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedOutputStream ;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    MyScanner ms=new MyScanner();
    PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
    int girlLeftFingers=ms.nextInt();
    int girlRightFingers=ms.nextInt();
    int boyLeftFingers=ms.nextInt();
    int boyRightFingers=ms.nextInt();
    int GR_BL=girlRightFingers-boyLeftFingers ;
    int BL_GR=(boyLeftFingers/2);
    if(boyLeftFingers % 2==0){
      BL_GR--;
    }
    int GL_BR=girlLeftFingers-boyRightFingers ;
    int BR_GL=(boyRightFingers/2);
    if(boyRightFingers % 2==0){
      BR_GL--;
    }
    if((GR_BL>=2 ||(girlRightFingers<BL_GR))&&((girlLeftFingers<BR_GL)|| GL_BR>=2)){
      out.println("NO");
    }
    else {
      out.println("YES");
    }
    out.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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ms : MyScanner ; ms := MyScanner.newMyScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var girlLeftFingers : int ; girlLeftFingers := ms.nextInt() ;
    var girlRightFingers : int ; girlRightFingers := ms.nextInt() ;
    var boyLeftFingers : int ; boyLeftFingers := ms.nextInt() ;
    var boyRightFingers : int ; boyRightFingers := ms.nextInt() ;
    var GR_BL : int ; GR_BL := girlRightFingers - boyLeftFingers ;
    var BL_GR : int ; BL_GR := (boyLeftFingers / 2) ;
    if (boyLeftFingers mod 2 = 0) then (     BL_GR := BL_GR - 1 ) else skip ; 
    var GL_BR : int ; GL_BR := girlLeftFingers - boyRightFingers ;
    var BR_GL : int ; BR_GL := (boyRightFingers / 2) ;
    if (boyRightFingers mod 2 = 0) then (     BR_GL := BR_GL - 1 ) else skip ; 
    if ((GR_BL >= 2 or (girlRightFingers < BL_GR)) & ((girlLeftFingers < BR_GL) or GL_BR >= 2)) then (     skip ) else (     skip ) ;  
    skip ; 
 );
  static class MyScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.util.stream.*;
public class App {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  public static void main(String[] args)throws Exception {
    if(System.getProperty("ONLINE_JUDGE")==null){
      File inputFile=new File("/Users/vipinjain/self/cp/input.txt");
      File outputFile=new File("/Users/vipinjain/self/cp/output.txt");
      br=new BufferedReader(new FileReader(inputFile));
      bw=new BufferedWriter(new FileWriter(outputFile));
    }
    int tests ;
    tests=Integer.parseInt(br.readLine());
    while(tests-->0){
      solve();
    }
    bw.flush();
    bw.close();
    br.close();
  }
  static void solve()throws Exception {
    int n=Integer.parseInt(br.readLine());
    int ans=1 ;
    int maxDigit=0 ;
    while(n>0){
      int d=n % 10 ;
      maxDigit=Math.max(maxDigit,d);
      n/=10 ;
    }
    bw.write((maxDigit>1 ? maxDigit : 1)+"");
    bw.write("\n");
  }
  static void shuffleArray(int[] arr){
    int n=arr.length ;
    Random rnd=new Random();
    for(int i=0 ; i<n ; ++i){
      int tmp=arr[i];
      int randomPos=i+rnd.nextInt(n-i);
      arr[i]=arr[randomPos];
      arr[randomPos]=tmp ;
    }
  }
  static int gcd(int a,int b){
    if(a==0){
      return b ;
    }
    return gcd(b % a,a);
  }
  static boolean isPrime(long n){
    for(long i=2 ; i*i<=n ; i++){
      if(n % i==0){
        return false ;
      }
    }
    return true ;
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class App {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   attribute bw : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (OclProcess.getEnvironmentProperty("ONLINE_JUDGE") = null) then (     var inputFile : OclFile ; inputFile := OclFile("/Users/vipinjain/self/cp/input.txt") ;
     var outputFile : OclFile ; outputFile := OclFile("/Users/vipinjain/self/cp/output.txt") ;
     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(inputFile)) ; 
     bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(outputFile)) ) else skip ; 
     var tests : int ;
    tests := (br.readLine())->toInteger() ; 
        while (tests > 0) do (        tests := tests - 1 ;     skip ; (     execute solve() ) ;  ) ;  
    skip ; 
    skip ; 
    skip ; 
 );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := (br.readLine())->toInteger() ;
     var ans : int ; ans := 1 ;
    var maxDigit : int ; maxDigit := 0 ;
    while (n > 0) do (     var d : int ; d := n mod 10 ;
     maxDigit := Set{maxDigit, d}->max() ; 
     n := n/(10) ) ; 
    skip ; 
    skip ; 
 );
  static   operation shuffleArray( arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := arr->size() ;
     var rnd : OclRandom ; rnd := OclRandom.newOclRandom() ;
         var i : int ; i := 0 ; while i < n do ( (     var tmp : int ; tmp := arr[i+1] ;
     var randomPos : int ; randomPos := i + rnd.nextInt(n - i) ;
     arr[i+1] := arr[randomPos+1] ; 
     arr[randomPos+1] := tmp )  ;     i := i + 1 ) );
  static   operation gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then (     return b ) else skip ; 
     return gcd(b mod a, a) );
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (         var i : long ; i := 2 ; while i * i <= n do ( (     if (n mod i = 0) then (     return false ) else skip )  ;     i := i + 1 ) ; 
     return true );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A62 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int al=in.nextInt();
    int ar=in.nextInt();
    int bl=in.nextInt();
    int br=in.nextInt();
    boolean ok=(2*(al+1)>=br && br>=al-1)||(2*(ar+1)>=bl && bl>=ar-1);
    System.out.println(ok ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class A62 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var al : int ; al := in.getCurrent()->toInteger() ;
    var ar : int ; ar := in.getCurrent()->toInteger() ;
    var bl : int ; bl := in.getCurrent()->toInteger() ;
    var br : int ; br := in.getCurrent()->toInteger() ;
    var ok : boolean ; ok := (2 * (al + 1) >= br & br >= al - 1) or (2 * (ar + 1) >= bl & bl >= ar - 1) ;
    OclFile["System.out"].println(if ok then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class a62 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int gl=sc.nextInt();
    int gr=sc.nextInt();
    int bl=sc.nextInt();
    int br=sc.nextInt();
    if((br>=gl-1 && br<=2*gl+2)||(bl>=gr-1 && bl<=2*gr+2))System.out.println("YES");
    else System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class a62 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var gl : int ; gl := sc.getCurrent()->toInteger() ;
    var gr : int ; gr := sc.getCurrent()->toInteger() ;
    var bl : int ; bl := sc.getCurrent()->toInteger() ;
    var br : int ; br := sc.getCurrent()->toInteger() ;
    if ((br >= gl - 1 & br <= 2 * gl + 2) or (bl >= gr - 1 & bl <= 2 * gr + 2)) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public void run(){
    while(sc.hasNext()){
      int n=sc.nextInt();
      if(n==0)break ;
      else calc(n);
    }
  }
  public void calc(int n){
    int[] Is=new int[n];
    for(int i=0 ; i<n ; i++){
      Is[i]=sc.nextInt();
    }
    int m=256 ;
    int s=16 ;
    int a=16 ;
    int c=16 ;
    double minH=1000000000 ;
    for(int ns=0 ; ns<16 ; ns++){
      for(int na=0 ; na<16 ; na++){
        for(int nc=0 ; nc<16 ; nc++){
          int[] count=new int[257];
          int r=ns ;
          for(int i=0 ; i<n ; i++){
            r=(na*r+nc)% m ;
            int o=(Is[i]+r)% m ;
            count[o]+=1 ;
          }
          double h=0 ;
          for(int i=0 ; i<257 ; i++){
            if(count[i]!=0){
              double t=((double)count[i])/((double)n);
              h+=-1*t*Math.log(t);
            }
          }
          if(h+1e-10<minH){
            s=ns ;
            a=na ;
            c=nc ;
            minH=h ;
          }
          else if(h==minH &&(ns<s ||(s==ns && na<a)||(s==ns && a==na && nc<c))){
            s=ns ;
            a=na ;
            c=nc ;
          }
        }
      }
    }
    System.out.println(s+" "+a+" "+c);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else     execute calc(n) ; ) );
   operation calc( n : int) : void
  pre: true
  post: true
  activity: (     var Is : Sequence(int) ; Is := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     Is[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var m : int ; m := 256 ;
    var s : int ; s := 16 ;
    var a : int ; a := 16 ;
    var c : int ; c := 16 ;
    var minH : double ; minH := 1000000000 ;
        var ns : int ; ns := 0 ; while ns < 16 do ( (         var na : int ; na := 0 ; while na < 16 do ( (         var nc : int ; nc := 0 ; while nc < 16 do ( (     var count : Sequence(int) ; count := Integer.subrange(1,257)->collect(0) ;
     var r : int ; r := ns ;
        var i : int ; i := 0 ; while i < n do ( (     r := (na * r + nc) mod m ; 
     var o : int ; o := (Is[i+1] + r) mod m ;
     count[o+1] := count[o+1]+(1) )  ;     i := i + 1 ) ; 
    var h : double ; h := 0 ;
        var i : int ; i := 0 ; while i < 257 do ( (     if (count[i+1] /= 0) then (     var t : double ; t := (count[i+1]->oclAsType(double)) / (n->oclAsType(double)) ;
     h := h+(-1 * t * (t)->log()) ) else skip )  ;     i := i + 1 ) ; 
    if (h + 1e-10 < minH) then (     s := ns ; 
     a := na ; 
     c := nc ; 
     minH := h ) else     if (h = minH & (ns < s or (s = ns & na < a) or (s = ns & a = na & nc < c))) then (     s := ns ; 
     a := na ; 
     c := nc ) else skip ; ;  
 )  ;     nc := nc + 1 ) )  ;     na := na + 1 ) )  ;     ns := ns + 1 ) ; 
    OclFile["System.out"].println(s + " " + a + " " + c) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)break ;
      double min=1<<29 ;
      int S=0,A=0,C=0 ;
      int[] I=new int[n];
      for(int i=0 ; i<n ; i++)I[i]=sc.nextInt();
      for(int s=0 ; s<16 ; s++)for(int a=0 ; a<16 ; a++)for(int c=0 ; c<16 ; c++){
        int R=s ;
        int[] O=new int[256];
        for(int i=0 ; i<n ; i++){
          R=(a*R+c)% 256 ;
          O[(I[i]+R)% 256]++;
        }
        double H=0 ;
        for(int i=0 ; i<256 ; i++)if(O[i]>0)H-=O[i]*1.0/n*Math.log(O[i]*1.0/n);
        if(H+1e-10<min){
          min=H ;
          S=s ;
          A=a ;
          C=c ;
        }
      }
      System.out.println(S+" "+A+" "+C);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     break else skip ; 
    var min : double ; min := (1*(2->pow(29)))->oclAsType(long) ;
    var S : int ; S := 0 ;
    var A : int ; A := 0 ;
    var C : int ; C := 0 ;
    var I : Sequence(int) ; I := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     I[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var s : int ; s := 0 ; while s < 16 do (         var a : int ; a := 0 ; while a < 16 do (         var c : int ; c := 0 ; while c < 16 do ( (     var R : int ; R := s ;
     var O : Sequence(int) ; O := Integer.subrange(1,256)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     R := (a * R + c) mod 256 ; 
     O[(I[i+1] + R) mod 256+1] := O[(I[i+1] + R) mod 256+1] + 1 )  ;     i := i + 1 ) ; 
    var H : double ; H := 0 ;
        var i : int ; i := 0 ; while i < 256 do (     if (O[i+1] > 0) then     H := H-(O[i+1] * 1.0 / n * (O[i+1] * 1.0 / n)->log()) ; else skip ;  ;     i := i + 1 ) ; 
    if (H + 1e-10 < min) then (     min := H ; 
     S := s ; 
     A := a ; 
     C := c ) else skip ; 
 )  ;     c := c + 1 ) ;  ;     a := a + 1 ) ;  ;     s := s + 1 ) ; 
    OclFile["System.out"].println(S + " " + A + " " + C) ; 
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    while(true){
      final int N=sc.nextInt();
      if(N==0){
        break ;
      }
      int[] input=new int[N];
      for(int i=0 ; i<N ; i++){
        input[i]=sc.nextInt();
      }
      int[] rnd=new int[N+1];
      int[] output=new int[N];
      int[] alpha=new int[256];
      double min=Double.MAX_VALUE ;
      int min_S=-1,min_A=-1,min_C=-1 ;
      for(int S=0 ; S<=15 ; S++){
        for(int A=0 ; A<=15 ; A++){
          for(int C=0 ; C<=15 ; C++){
            rnd[0]=S ;
            Arrays.fill(alpha,0);
            for(int i=1 ; i<N+1 ; i++){
              rnd[i]=(A*rnd[i-1]+C)% 256 ;
            }
            for(int i=0 ; i<N ; i++){
              output[i]=(input[i]+rnd[i+1])% 256 ;
              alpha[output[i] ]++;
            }
            double score=0 ;
            for(int i=0 ; i<256 ; i++){
              if(alpha[i]==0){
                continue ;
              }
              score-=(alpha[i]/(double)(N))*Math.log(alpha[i]/(double)(N));
            }
            if(score<min-1e-9){
              min_A=A ;
              min_S=S ;
              min_C=C ;
              min=score ;
            }
          }
        }
      }
      System.out.println(min_S+" "+min_A+" "+min_C);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then (     break ) else skip ; 
    var input : Sequence(int) ; input := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     input[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var rnd : Sequence(int) ; rnd := Integer.subrange(1,N + 1)->collect(0) ;
    var output : Sequence(int) ; output := Integer.subrange(1,N)->collect(0) ;
    var alpha : Sequence(int) ; alpha := Integer.subrange(1,256)->collect(0) ;
    var min : double ; min := (2 - 2->pow(-52))*(2->pow(1023)) ;
    var min_S : int ; min_S := -1 ;
    var min_A : int ; min_A := -1 ;
    var min_C : int ; min_C := -1 ;
        var S : int ; S := 0 ; while S <= 15 do ( (         var A : int ; A := 0 ; while A <= 15 do ( (         var C : int ; C := 0 ; while C <= 15 do ( (     rnd[0+1] := S ; 
     alpha := alpha->collect(0) ; 
        var i : int ; i := 1 ; while i < N + 1 do ( (     rnd[i+1] := (A * rnd[i - 1+1] + C) mod 256 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     output[i+1] := (input[i+1] + rnd[i + 1+1]) mod 256 ; 
     alpha[output[i+1]+1] := alpha[output[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
    var score : double ; score := 0 ;
        var i : int ; i := 0 ; while i < 256 do ( (     if (alpha[i+1] = 0) then (     continue ) else skip ; 
     score := score-((alpha[i+1] / (N)->oclAsType(double)) * (alpha[i+1] / (N)->oclAsType(double))->log()) )  ;     i := i + 1 ) ; 
    if (score < min - 1e-9) then (     min_A := A ; 
     min_S := S ; 
     min_C := C ; 
     min := score ) else skip ; 
 )  ;     C := C + 1 ) )  ;     A := A + 1 ) )  ;     S := S + 1 ) ; 
    OclFile["System.out"].println(min_S + " " + min_A + " " + min_C) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  private class Box {
    int bolls ;
    boolean isRed ;
    public Box(){
      bolls=1 ;
      isRed=false ;
    }
    public void add(Box src){
      this.isRed |=src.isRed ;
      this.bolls+=1 ;
      src.bolls-=1 ;
      if(src.bolls==0){
        src.isRed=false ;
      }
    }
  }
  public void main(Scanner sc){
    int n=sc.nextInt();
    int m=sc.nextInt();
    Box boxs[]=new Box[n];
    for(int i=0 ; i<n ; i++){
      boxs[i]=new Box();
    }
    boxs[0] .isRed=true ;
    for(int i=0 ; i<m ; i++){
      int x=sc.nextInt();
      int y=sc.nextInt();
      boxs[y-1] .add(boxs[x-1]);
    }
    System.out.println(Arrays.stream(boxs).mapToInt(box->box.isRed ? 1 : 0).sum());
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    new Main().main(sc);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
 class Box {
   attribute bolls : int;
   attribute isRed : boolean;
   static operation newBox() : Box
  pre: true
  post: true
  activity:
  ( var self : Box ;
    self := createBox();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     bolls := 1 ; 
     isRed := false );
   operation add( src : Box) : void
  pre: true
  post: true
  activity: (     self.isRed := MathLib.bitwiseOr(self.isRed, src.isRed) ; 
     self.bolls := self.bolls+(1) ; 
     src.bolls := src.bolls-(1) ; 
     if (src.bolls = 0) then (     src.isRed := false ) else skip );
}
   operation main( sc : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.nextInt() ;
     var m : int ; m := sc.nextInt() ;
    var boxs : Sequence(Box) ; boxs := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     boxs[i+1] := Box.newBox() )  ;     i := i + 1 ) ; 
    boxs[0+1].isRed := true ; 
        var i : int ; i := 0 ; while i < m do ( (     var x : int ; x := sc.nextInt() ;
     var y : int ; y := sc.nextInt() ;
     boxs[y - 1+1]->excludes(boxs[x - 1+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(stream(boxs)->collect( _x1 | (lambda box : OclAny in if box.isRed then 1 else 0 endif)->apply(_x1) )->sum()) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     Main.newMain().main(sc) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int N=sc.nextInt();
      if(N==0)break ;
      int[] a=new int[N+1];
      for(int i=0 ; i<N ; i++){
        a[i+1]=sc.nextInt();
      }
      double min=1<<29 ;
      double e=1e-10 ;
      int x=0,y=0,z=0 ;
      for(int i=0 ; i<=15 ; i++){
        for(int j=0 ; j<=15 ; j++){
          for(int k=0 ; k<=15 ; k++){
            double H=calc(a,i,j,k);
            if(min>H+e){
              min=H ;
              x=i ;
              y=j ;
              z=k ;
            }
          }
        }
      }
      System.out.println(x+" "+y+" "+z);
    }
  }
  static int m=256 ;
  static double calc(int[] I,int s,int a,int c){
    double res=0.0 ;
    int[] o=new int[257];
    int[] r=new int[I.length];
    r[0]=s ;
    for(int j=1 ; j<r.length ; j++){
      r[j]=(a*r[j-1]+c)% m ;
    }
    for(int j=1 ; j<I.length ; j++){
      o[(I[j]+r[j])% m]++;
    }
    for(int j=0 ; j<o.length ; j++){
      if(o[j]!=0){
        double d=(double)o[j]/(I.length-1)*Math.log((double)o[j]/(I.length-1));
        res-=d ;
      }
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var N : int ; N := sc.getCurrent()->toInteger() ;
     if (N = 0) then     break else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,N + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     a[i + 1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var min : double ; min := (1*(2->pow(29)))->oclAsType(long) ;
    var e : double ; e := 1e-10 ;
    var x : int ; x := 0 ;
    var y : int ; y := 0 ;
    var z : int ; z := 0 ;
        var i : int ; i := 0 ; while i <= 15 do ( (         var j : int ; j := 0 ; while j <= 15 do ( (         var k : int ; k := 0 ; while k <= 15 do ( (     var H : double ; H := calc(a, i, j, k) ;
     if (min > H + e) then (     min := H ; 
     x := i ; 
     y := j ; 
     z := k ) else skip )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(x + " " + y + " " + z) ; 
 ) );
  static   attribute m : int := 256;
  static   operation calc( I : Sequence(int), s : int, a : int, c : int) : double
  pre: true
  post: true
  activity: (     var res : double ; res := 0.0 ;
     var o : Sequence(int) ; o := Integer.subrange(1,257)->collect(0) ;
    var r : Sequence(int) ; r := Integer.subrange(1,I->size())->collect(0) ;
    r[0+1] := s ; 
        var j : int ; j := 1 ; while j < r->size() do ( (     r[j+1] := (a * r[j - 1+1] + c) mod m )  ;     j := j + 1 ) ; 
        var j : int ; j := 1 ; while j < I->size() do ( (     o[(I[j+1] + r[j+1]) mod m+1] := o[(I[j+1] + r[j+1]) mod m+1] + 1 )  ;     j := j + 1 ) ; 
        var j : int ; j := 0 ; while j < o->size() do ( (     if (o[j+1] /= 0) then (     var d : double ; d := o[j+1]->oclAsType(double) / (I->size() - 1) * (o[j+1]->oclAsType(double) / (I->size() - 1))->log() ;
     res := res-(d) ) else skip )  ;     j := j + 1 ) ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class VilotileKite {
  public double findMaximumDistance(double[][] points){
    double distance=Double.MAX_VALUE ;
    int len=points.length ;
    for(int i=0 ; i<len ; i++){
      double ABx=points[(i+1)% len][0]-points[i % len][0];
      double ABy=points[(i+1)% len][1]-points[i % len][1];
      double ACx=points[(i+2)% len][0]-points[i % len][0];
      double ACy=points[(i+2)% len][1]-points[i % len][1];
      distance=Math.min(distance,Math.abs((ABx*ACy)-(ACx*ABy))/Math.sqrt(ACx*ACx+ACy*ACy)/2);
    }
    return distance ;
  }
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    VilotileKite vilotileKite=new VilotileKite();
    int pointsNum=Integer.parseInt(input.nextLine());
    double[][] points=new double[pointsNum][2];
    for(int i=0 ; i<pointsNum ; i++){
      String[] eles=input.nextLine().split(" ");
      points[i][0]=Double.parseDouble(eles[0]);
      points[i][1]=Double.parseDouble(eles[1]);
    }
    System.out.println(vilotileKite.findMaximumDistance(points));
  }
}
------------------------------------------------------------
OCL File:
---------
 class VilotileKite {
   operation findMaximumDistance( points : Sequence(Sequence(double))) : double
  pre: true
  post: true
  activity: (     var distance : double ; distance := (2 - 2->pow(-52))*(2->pow(1023)) ;
     var len : int ; len := points->size() ;
         var i : int ; i := 0 ; while i < len do ( (     var ABx : double ; ABx := points[(i + 1) mod len+1][0+1] - points[i mod len+1][0+1] ;
     var ABy : double ; ABy := points[(i + 1) mod len+1][1+1] - points[i mod len+1][1+1] ;
    var ACx : double ; ACx := points[(i + 2) mod len+1][0+1] - points[i mod len+1][0+1] ;
    var ACy : double ; ACy := points[(i + 2) mod len+1][1+1] - points[i mod len+1][1+1] ;
    distance := Set{distance, if (ABx * ACy) - (ACx * ABy) < 0 then -((ABx * ACy) - (ACx * ABy)) else (ABx * ACy) - (ACx * ABy) endif / (ACx * ACx + ACy * ACy)->sqrt() / 2}->min() ; 
 )  ;     i := i + 1 ) ; 
     return distance );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var vilotileKite : VilotileKite ; vilotileKite := VilotileKite.newVilotileKite() ;
    var pointsNum : int ; pointsNum := (input.nextLine())->toInteger() ;
    var points : Sequence(Sequence(double)) ; points := Integer.subrange(1,pointsNum)->collect(Integer.subrange(1,2)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < pointsNum do ( (     var eles : Sequence(String) ; eles := input.nextLine()->split(" ") ;
     points[i+1][0+1] := (eles[0+1])->toReal() ; 
     points[i+1][1+1] := (eles[1+1])->toReal() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(vilotileKite.findMaximumDistance(points)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class VilotileKite {
  public double findMaximumDistance(double[][] points){
    double distance=Double.MAX_VALUE ;
    int len=points.length ;
    for(int i=0 ; i<len ; i++){
      double ABx=points[(i+1)% len][0]-points[i % len][0];
      double ABy=points[(i+1)% len][1]-points[i % len][1];
      double ACx=points[(i+2)% len][0]-points[i % len][0];
      double ACy=points[(i+2)% len][1]-points[i % len][1];
      distance=Math.min(distance,Math.abs((ABx*ACy)-(ACx*ABy))/Math.sqrt(ACx*ACx+ACy*ACy)/2);
    }
    return distance ;
  }
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    VilotileKite vilotileKite=new VilotileKite();
    int pointsNum=Integer.parseInt(input.nextLine());
    double[][] points=new double[pointsNum][2];
    for(int i=0 ; i<pointsNum ; i++){
      String[] eles=input.nextLine().split(" ");
      points[i][0]=Double.parseDouble(eles[0]);
      points[i][1]=Double.parseDouble(eles[1]);
    }
    System.out.println(vilotileKite.findMaximumDistance(points));
  }
}
------------------------------------------------------------
OCL File:
---------
 class VilotileKite {
   operation findMaximumDistance( points : Sequence(Sequence(double))) : double
  pre: true
  post: true
  activity: (     var distance : double ; distance := (2 - 2->pow(-52))*(2->pow(1023)) ;
     var len : int ; len := points->size() ;
         var i : int ; i := 0 ; while i < len do ( (     var ABx : double ; ABx := points[(i + 1) mod len+1][0+1] - points[i mod len+1][0+1] ;
     var ABy : double ; ABy := points[(i + 1) mod len+1][1+1] - points[i mod len+1][1+1] ;
    var ACx : double ; ACx := points[(i + 2) mod len+1][0+1] - points[i mod len+1][0+1] ;
    var ACy : double ; ACy := points[(i + 2) mod len+1][1+1] - points[i mod len+1][1+1] ;
    distance := Set{distance, if (ABx * ACy) - (ACx * ABy) < 0 then -((ABx * ACy) - (ACx * ABy)) else (ABx * ACy) - (ACx * ABy) endif / (ACx * ACx + ACy * ACy)->sqrt() / 2}->min() ; 
 )  ;     i := i + 1 ) ; 
     return distance );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var vilotileKite : VilotileKite ; vilotileKite := VilotileKite.newVilotileKite() ;
    var pointsNum : int ; pointsNum := (input.nextLine())->toInteger() ;
    var points : Sequence(Sequence(double)) ; points := Integer.subrange(1,pointsNum)->collect(Integer.subrange(1,2)->collect(0.0)) ;
        var i : int ; i := 0 ; while i < pointsNum do ( (     var eles : Sequence(String) ; eles := input.nextLine()->split(" ") ;
     points[i+1][0+1] := (eles[0+1])->toReal() ; 
     points[i+1][1+1] := (eles[1+1])->toReal() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(vilotileKite.findMaximumDistance(points)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int minimumOperations(int arr[],int n){
    int brr[]={
      0,0,0,0 };
      for(int i=0 ; i<n ; i++)brr[arr[i] % 4]++;
      if((brr[1]+2*brr[2]+3*brr[3])% 4==0){
        int min_opr=Math.min(brr[3],brr[1]);
        brr[3]-=min_opr ;
        brr[1]-=min_opr ;
        min_opr+=brr[2]/2 ;
        brr[2] %=2 ;
        if(brr[2]==1){
          min_opr+=2 ;
          brr[2]=0 ;
          if(brr[3]==1)brr[3]-=2 ;
          if(brr[1]==1)brr[1]-=2 ;
        }
        if(brr[1]==1)min_opr+=(brr[1]/4)*3 ;
        if(brr[3]==1)min_opr+=(brr[3]/4)*3 ;
        return min_opr ;
      }
      return-1 ;
    }
    public static void main(String[] args){
      int arr[]={
        1,2,3,1,2,3,8 };
        int n=arr.length ;
        System.out.println(minimumOperations(arr,n));
      }
    }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minimumOperations( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var brr : Sequence(int) ; brr := Sequence{0,0,0,0} ;
         var i : int ; i := 0 ; while i < n do (     brr[arr[i+1] mod 4+1] := brr[arr[i+1] mod 4+1] + 1 ;  ;     i := i + 1 ) ; 
     if ((brr[1+1] + 2 * brr[2+1] + 3 * brr[3+1]) mod 4 = 0) then (     var min_opr : int ; min_opr := Set{brr[3+1], brr[1+1]}->min() ;
     brr[3+1] := brr[3+1]-(min_opr) ; 
    brr[1+1] := brr[1+1]-(min_opr) ; 
    min_opr := min_opr+(brr[2+1] / 2) ; 
    brr[2+1] := brr[2+1] mod 2 ; 
    if (brr[2+1] = 1) then (     min_opr := min_opr+(2) ; 
     brr[2+1] := 0 ; 
     if (brr[3+1] = 1) then     brr[3+1] := brr[3+1]-(2) ; else skip ; 
     if (brr[1+1] = 1) then     brr[1+1] := brr[1+1]-(2) ; else skip ) else skip ; 
    if (brr[1+1] = 1) then     min_opr := min_opr+((brr[1+1] / 4) * 3) ; else skip ; 
    if (brr[3+1] = 1) then     min_opr := min_opr+((brr[3+1] / 4) * 3) ; else skip ; 
    return min_opr 
 ) else skip ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,1,2,3,8} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(minimumOperations(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class codeHundredSixty {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=input.nextInt();
      int max=1 ;
      int rem ;
      while(n>0){
        rem=n % 10 ;
        if(rem>max){
          max=rem ;
        }
        n=n/10 ;
      }
      System.out.println(max);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var max : int ; max := 1 ;
    var rem : int ;
    while (n > 0) do (     rem := n mod 10 ; 
     if (rem > max) then (     max := rem ) else skip ; 
     n := n / 10 ) ; 
    OclFile["System.out"].println(max) ; 
 )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int progA[]=new int[n];
    int progB[]=new int[n];
    for(int i=0 ; i<n ; i++){
      progA[i]=sc.nextInt();
      progB[i]=progA[i];
    }
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      int b=sc.nextInt();
      int m=sc.nextInt();
      int e=sc.nextInt();
      for(int k=0 ; k<e-b ; k++){
        progB[b+((k+(e-m))%(e-b))]=progA[b+k];
      }
      for(int k=0 ; k<e-b ; k++){
        progA[b+k]=progB[b+k];
      }
    }
    for(int j=0 ; j<progB.length ; j++){
      if(j!=0)System.out.print(" ");
      System.out.print(progB[j]);
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var progA : Sequence(int) ; progA := Integer.subrange(1,n)->collect(0) ;
    var progB : Sequence(int) ; progB := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     progA[i+1] := sc.getCurrent()->toInteger() ; 
     progB[i+1] := progA[i+1] )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var b : int ; b := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var e : int ; e := sc.getCurrent()->toInteger() ;
        var k : int ; k := 0 ; while k < e - b do ( (     progB[b + ((k + (e - m)) mod (e - b))+1] := progA[b + k+1] )  ;     k := k + 1 ) ; 
        var k : int ; k := 0 ; while k < e - b do ( (     progA[b + k+1] := progB[b + k+1] )  ;     k := k + 1 ) ; 
 )  ;     i := i + 1 ) ; 
        var j : int ; j := 0 ; while j < progB->size() do ( (     if (j /= 0) then     OclFile["System.out"].print(" ") ; else skip ; 
     OclFile["System.out"].print(progB[j+1]) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int size=in.nextInt(),arr1[]=new int[size],arr2[]=new int[size];
    for(int i=0 ; i<size ; i++){
      arr1[i]=Integer.parseInt(in.next());
    }
    int query=in.nextInt();
    for(int i=0 ; i<query ; i++){
      int begin=Integer.parseInt(in.next()),middle=Integer.parseInt(in.next()),end=Integer.parseInt(in.next());
      int sta1=end-middle,sta2=end-begin ;
      for(int j=0 ; j<sta2 ; j++){
        arr2[begin+((j+sta1)% sta2)]=arr1[begin+j];
      }
      for(int j=0 ; j<sta2 ; j++){
        arr1[begin+j]=arr2[begin+j];
      }
    }
    for(int i=0 ; i<size ; i++){
      out.printf("%d%s",arr1[i],(i<size-1)? " " : "\n");
    }
    out.flush();
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var size : int ; size := in.getCurrent()->toInteger() ;
    var arr1 : Sequence(void) ; arr1 := Integer.subrange(1,size)->collect(0) ;
    var arr2 : Sequence(void) ; arr2 := Integer.subrange(1,size)->collect(0) ;
        var i : int ; i := 0 ; while i < size do ( (     arr1[i+1] := (in.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
    var query : int ; query := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < query do ( (     var begin : int ; begin := (in.getCurrent())->toInteger() ;
    var middle : int ; middle := (in.getCurrent())->toInteger() ;
    var end : int ; end := (in.getCurrent())->toInteger() ;
     var sta1 : int ; sta1 := end - middle ;
    var sta2 : int ; sta2 := end - begin ;
         var j : int ; j := 0 ; while j < sta2 do ( (     arr2[begin + ((j + sta1) mod sta2)+1] := arr1[begin + j+1] )  ;     j := j + 1 ) ; 
         var j : int ; j := 0 ; while j < sta2 do ( (     arr1[begin + j+1] := arr2[begin + j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < size do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
class Main {
  static int[] A,B ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String[] str=br.readLine().split(" ");
    int n=Integer.parseInt(str[0]);
    A=new int[n];
    str=br.readLine().split(" ");
    for(int i=0 ; i<n ; i++)A[i]=Integer.parseInt(str[i]);
    str=br.readLine().split(" ");
    int q=Integer.parseInt(str[0]);
    for(int i=0 ; i<q ; i++){
      str=br.readLine().split(" ");
      int b=Integer.parseInt(str[0]);
      int m=Integer.parseInt(str[1]);
      int e=Integer.parseInt(str[2]);
      B=A.clone();
      for(int j=0 ; j<e-b ; j++){
        B[b+((j+(e-m))%(e-b))]=A[b+j];
      }
      A=B.clone();
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(A[i]);
      if(i!=n-1)System.out.print(" ");
    }
    System.out.print("\n");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute A : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var str : Sequence(String) ; str := br.readLine()->split(" ") ;
    var n : int ; n := (str[0+1])->toInteger() ;
    A := Integer.subrange(1,n)->collect(0) ; 
    str := br.readLine()->split(" ") ; 
        var i : int ; i := 0 ; while i < n do (     A[i+1] := (str[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    str := br.readLine()->split(" ") ; 
    var q : int ; q := (str[0+1])->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     str := br.readLine()->split(" ") ; 
     var b : int ; b := (str[0+1])->toInteger() ;
    var m : int ; m := (str[1+1])->toInteger() ;
    var e : int ; e := (str[2+1])->toInteger() ;
    B := A->copy() ; 
        var j : int ; j := 0 ; while j < e - b do ( (     B[b + ((j + (e - m)) mod (e - b))+1] := A[b + j+1] )  ;     j := j + 1 ) ; 
    A := B->copy() ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(A[i+1]) ; 
     if (i /= n - 1) then     OclFile["System.out"].print(" ") ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("\n") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    StringBuilder sb=new StringBuilder();
    int num=sc.nextInt();
    ArrayList<Integer>array=new ArrayList<>();
    for(int i=0 ; i<num ; i++){
      int tmp=sc.nextInt();
      array.add(tmp);
    }
    int num_query=sc.nextInt();
    for(int i=0 ; i<num_query ; i++){
      int l=sc.nextInt();
      int m=sc.nextInt();
      int r=sc.nextInt();
      Collections.rotate(array.subList(l,r),l-m);
    }
    for(int i=0 ; i<array.size(); i++){
      sb.append(array.get(i));
      if(i!=array.size()-1)sb.append(' ');
    }
    System.out.println(sb);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sb : String ; sb := StringLib.newString() ;
    var num : int ; num := sc.getCurrent()->toInteger() ;
    var array : Sequence(int) ; array := Sequence{} ;
        var i : int ; i := 0 ; while i < num do ( (     var tmp : int ; tmp := sc.getCurrent()->toInteger() ;
     array := array->including(tmp) )  ;     i := i + 1 ) ; 
    var num_query : int ; num_query := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < num_query do ( (     var l : int ; l := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
     array.subrange(l+1,r) := Integer.subrange(1,array.subrange(l+1,r).size)->collect( x_ | array.subrange(l+1,r)->at(((x_-1-l - m) mod array.subrange(l+1,r).size) + 1) ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < array->size() do ( (     sb := sb + StringLib.newString(array->at(i+1)) ; 
     if (i /= array->size() - 1) then     sb := sb + StringLib.newString(' ') ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sb) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Integer>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      list.add(sc.nextInt());
    }
    int q=sc.nextInt();
    for(int i=0 ; i<q ; i++){
      int b=sc.nextInt();
      int m=sc.nextInt();
      int e=sc.nextInt();
      List<Integer>list2=new ArrayList<>();
      for(int j=0 ; j<b ; j++){
        list2.add(list.get(j));
      }
      for(int j=m ; j<e ; j++){
        list2.add(list.get(j));
      }
      for(int j=b ; j<m ; j++){
        list2.add(list.get(j));
      }
      for(int j=e ; j<list.size(); j++){
        list2.add(list.get(j));
      }
      list=list2 ;
    }
    StringBuilder sb=new StringBuilder();
    for(int num : list){
      sb.append(num+" ");
    }
    String str=sb.toString();
    str=str.substring(0,str.length()-1);
    System.out.println(str);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(sc.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < q do ( (     var b : int ; b := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var e : int ; e := sc.getCurrent()->toInteger() ;
    var list2 : Sequence(int) ; list2 := Sequence{} ;
        var j : int ; j := 0 ; while j < b do ( (     list2 := list2->including(list->at(j+1)) )  ;     j := j + 1 ) ; 
        var j : int ; j := m ; while j < e do ( (     list2 := list2->including(list->at(j+1)) )  ;     j := j + 1 ) ; 
        var j : int ; j := b ; while j < m do ( (     list2 := list2->including(list->at(j+1)) )  ;     j := j + 1 ) ; 
        var j : int ; j := e ; while j < list->size() do ( (     list2 := list2->including(list->at(j+1)) )  ;     j := j + 1 ) ; 
    list := list2 ; 
 )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
    for (num : list) do ( (     sb := sb + StringLib.newString(num + " ") )  ) ; 
    var str : String ; str := sb+"" ;
    str := str.subrange(0+1,str->size() - 1) ; 
    OclFile["System.out"].println(str) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws Exception {
    InputStreamReader is=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(is);
    String input[]=br.readLine().split(" ");
    int boxCount=Integer.parseInt(input[0]);
    int[][] box=new int[boxCount][3];
    for(int i=0 ; i<boxCount ; i++){
      for(int j=0 ; j<3 ; j++){
        box[i][j]=0 ;
      }
    }
    box[0][1]=1 ;
    box[0][2]=1 ;
    int order=Integer.parseInt(input[1]);
    while(br.ready()){
      String temp[]=br.readLine().split(" ");
      int before=Integer.parseInt(temp[0])-1 ;
      int after=Integer.parseInt(temp[1])-1 ;
      if(box[before][0]>=0){
        if(box[before][1]==1){
          box[before][1]=0 ;
          box[after][1]=1 ;
          box[after][2]=1 ;
        }
        if(box[before][2]==1){
          box[after][2]=1 ;
        }
        if(box[before][0]==0){
          box[before][2]=0 ;
        }
        box[before][0]--;
        box[after][0]++;
      }
    }
    int result=0 ;
    for(int i=0 ; i<boxCount ; i++){
      if(box[i][0]>=0){
        if(box[i][2]==1){
          result++;
        }
      }
    }
    if(result==0){
      System.out.println(1);
    }
    else {
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var is : OclFile ; is := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(is) ;
    var input : Sequence(String) ; input := br.readLine()->split(" ") ;
    var boxCount : int ; boxCount := (input[0+1])->toInteger() ;
    var box : Sequence(Sequence(int)) ; box := Integer.subrange(1,boxCount)->collect(Integer.subrange(1,3)->collect(0)) ;
        var i : int ; i := 0 ; while i < boxCount do ( (         var j : int ; j := 0 ; while j < 3 do ( (     box[i+1][j+1] := 0 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    box[0+1][1+1] := 1 ; 
    box[0+1][2+1] := 1 ; 
    var order : int ; order := (input[1+1])->toInteger() ;
    while (br.canRead()) do (     var temp : Sequence(String) ; temp := br.readLine()->split(" ") ;
     var before : int ; before := (temp[0+1])->toInteger() - 1 ;
     var after : int ; after := (temp[1+1])->toInteger() - 1 ;
     if (box[before+1][0+1] >= 0) then (     if (box[before+1][1+1] = 1) then (     box[before+1][1+1] := 0 ; 
     box[after+1][1+1] := 1 ; 
     box[after+1][2+1] := 1 ) else skip ; 
     if (box[before+1][2+1] = 1) then (     box[after+1][2+1] := 1 ) else skip ; 
    if (box[before+1][0+1] = 0) then (     box[before+1][2+1] := 0 ) else skip ; 
    box[before+1][0+1] := box[before+1][0+1] - 1 ; 
    box[after+1][0+1] := box[after+1][0+1] + 1 ; 
 ) else skip ) ; 
    var result : int ; result := 0 ;
        var i : int ; i := 0 ; while i < boxCount do ( (     if (box[i+1][0+1] >= 0) then (     if (box[i+1][2+1] = 1) then (     result := result + 1 ) else skip ) else skip )  ;     i := i + 1 ) ; 
    if (result = 0) then (     OclFile["System.out"].println(1) ) else (     OclFile["System.out"].println(result) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String s=sc.next();
    String a=s.substring(0,2);
    String b=s.substring(2,4);
    int ai=Integer.parseInt(a);
    int bi=Integer.parseInt(b);
    if(ai>=1 && ai<=12 && bi>=1 && bi<=12){
      System.out.println("AMBIGUOUS");
    }
    else if(ai>=1 && ai<=12){
      System.out.println("MMYY");
    }
    else if(bi>=1 && bi<=12){
      System.out.println("YYMM");
    }
    else {
      System.out.println("NA");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var s : String ; s := sc.getCurrent() ;
    var a : String ; a := s.subrange(0+1,2) ;
    var b : String ; b := s.subrange(2+1,4) ;
    var ai : int ; ai := (a)->toInteger() ;
    var bi : int ; bi := (b)->toInteger() ;
    if (ai >= 1 & ai <= 12 & bi >= 1 & bi <= 12) then (     OclFile["System.out"].println("AMBIGUOUS") ) else     if (ai >= 1 & ai <= 12) then (     OclFile["System.out"].println("MMYY") ) else     if (bi >= 1 & bi <= 12) then (     OclFile["System.out"].println("YYMM") ) else (     OclFile["System.out"].println("NA") ) ;  ;  ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static final String AMBIGUOUS="AMBIGUOUS" ;
  private static final String MMYY="MMYY" ;
  private static final String NA="NA" ;
  private static final String YYMM="YYMM" ;
  public static String process(String S){
    String firstPart=S.substring(0,2);
    String secondPart=S.substring(2);
    boolean isFirstPartValid=isValidMonth(firstPart);
    boolean isSecondPartValid=isValidMonth(secondPart);
    if(isFirstPartValid && isSecondPartValid){
      return AMBIGUOUS ;
    }
    else if(isFirstPartValid){
      return MMYY ;
    }
    else if(isSecondPartValid){
      return YYMM ;
    }
    else {
      return NA ;
    }
  }
  private static boolean isValidMonth(String part){
    try {
      Integer i=Integer.valueOf(part);
      return i>0 && i<=12 ;
    }
    catch(Exception e){
      return false ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String S=sc.next();
    final String result=process(S);
    output(result);
  }
  private static void output(String result){
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute AMBIGUOUS : String := "AMBIGUOUS";
  static    attribute MMYY : String := "MMYY";
  static    attribute NA : String := "NA";
  static    attribute YYMM : String := "YYMM";
  static   operation process( S : String) : String
  pre: true
  post: true
  activity: (     var firstPart : String ; firstPart := S.subrange(0+1,2) ;
     var secondPart : String ; secondPart := S.subrange(2+1,2) ;
    var isFirstPartValid : boolean ; isFirstPartValid := isValidMonth(firstPart) ;
    var isSecondPartValid : boolean ; isSecondPartValid := isValidMonth(secondPart) ;
    if (isFirstPartValid & isSecondPartValid) then (     return AMBIGUOUS ) else     if (isFirstPartValid) then (     return MMYY ) else     if (isSecondPartValid) then (     return YYMM ) else (     return NA ) ;  ;  ;  
 );
  static   operation isValidMonth( part : String) : boolean
  pre: true
  post: true
  activity: (     try (     var i : int ; i := (part)->toInteger() ;
     return i > 0 & i <= 12 )   catch (e : ProgramException) do (     return false )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var S : String ; S := sc.getCurrent() ;
     var result : String ; result := process(S) ;
     execute output(result) );
  static   operation output( result : String) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(result) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.math.BigInteger ;
import java.util.*;
import java.util.Stack ;
public class Main {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer root ;
    public FastReader(){
      br=new BufferedReader(new InputStreamReader(System.in));
    }
    String next(){
      while(root==null || ! root.hasMoreTokens()){
        try {
          root=new StringTokenizer(br.readLine());
        }
        catch(Exception r){
          r.printStackTrace();
        }
      }
      return root.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
    long nextLong(){
      return Long.parseLong(next());
    }
    String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(Exception r){
        r.printStackTrace();
      }
      return str ;
    }
  }
  public static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
  static int mod=(int)(1e9+7);
  static long cf=998244353 ;
  static final int MAX=(int)1e6 ;
  public static List<Integer>[] edges ;
  public static int[][] parent ;
  public static int col=20 ;
  public static long[] Bit ;
  public static long[] fac,inv ;
  public static int[] prime ;
  public static long[] dp ;
  public static FastReader sc=new FastReader();
  public static void main(String[] args){
    int a=sc.nextInt();
    int L=a/100 ;
    int R=a % 100 ;
    if(1<=L && L<=12){
      if(1<=R && R<=12)out.printf("AMBIGUOUS\n");
      else out.printf("MMYY\n");
    }
    else {
      if(1<=R && R<=12)out.printf("YYMM\n");
      else out.printf("NA\n");
    }
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static class FastReader {
   attribute br : OclFile;
   attribute root : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (root = null or not(root.hasNext())) do (     try (     root := OclIterator.newOclIterator_String(br.readLine()) )   catch (r : ProgramException) do (     r.printStackTrace() )
 ) ; 
     return root.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (r : ProgramException) do (     r.printStackTrace() )
     return str );
}
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   attribute mod : int := (1e9 + 7)->oclAsType(int);
  static   attribute cf : long := 998244353;
  static    attribute MAX : int := 1e6->oclAsType(int);
  static   attribute edges : Sequence(Sequence(int));
  static   attribute parent : Sequence(Sequence(int));
  static   attribute col : int := 20;
  static   attribute Bit : Sequence(long);
  static   attribute fac : Sequence(long);
  static   attribute prime : Sequence(int);
  static   attribute dp : Sequence(long);
  static   attribute sc : FastReader := FastReader.newFastReader();
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := sc.nextInt() ;
     var L : int ; L := a / 100 ;
    var R : int ; R := a mod 100 ;
    if (1 <= L & L <= 12) then (     if (1 <= R & R <= 12) then     skip ; else     skip ; ) else (     if (1 <= R & R <= 12) then     skip ; else     skip ; ) ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.OutputStream ;
import java.io.PrintWriter ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(in,out);
    out.close();
  }
  static class Task {
    String S ;
    int former,latter ;
    boolean canBeMonth(int n){
      return 1<=n && n<=12 ;
    }
    boolean canBeYear(int n){
      return 0<=n && n<=99 ;
    }
    void solve(InputReader in,PrintWriter out){
      S=in.next();
      former=Integer.parseInt(S.substring(0,2));
      latter=Integer.parseInt(S.substring(2,4));
      if(canBeMonth(former)&& canBeMonth(latter)){
        out.println("AMBIGUOUS");
      }
      else if(! canBeMonth(former)&& ! canBeMonth(latter)){
        out.println("NA");
      }
      else if(canBeMonth(former)){
        out.println("MMYY");
      }
      else if(canBeMonth(latter)){
        out.println("YYMM");
      }
      else {
        out.println("NA");
      }
    }
  }
  static class InputReader {
    BufferedReader reader ;
    StringTokenizer tokenizer ;
    InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream));
      tokenizer=null ;
    }
    String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    int nextInt(){
      return Integer.parseInt(next());
    }
    int[] nextIntArray(int size){
      int[] arr=new int[size];
      for(int i=0 ; i<size ; i++){
        arr[i]=nextInt();
      }
      return arr ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(in, out) ; 
    skip ; 
 );
  static class Task {
   attribute S : String;
   attribute former : int;
   operation canBeMonth( n : int) : boolean
  pre: true
  post: true
  activity: (     return 1 <= n & n <= 12 );
   operation canBeYear( n : int) : boolean
  pre: true
  post: true
  activity: (     return 0 <= n & n <= 99 );
   operation solve( in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     S := in.next() ; 
     former := (S.subrange(0+1,2))->toInteger() ; 
     latter := (S.subrange(2+1,4))->toInteger() ; 
     if (canBeMonth(former) & canBeMonth(latter)) then (     skip ) else     if (not(canBeMonth(former)) & not(canBeMonth(latter))) then (     skip ) else     if (canBeMonth(former)) then (     skip ) else     if (canBeMonth(latter)) then (     skip ) else (     skip ) ;  ;  ;  );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextIntArray( size : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < size do ( (     arr[i+1] := nextInt() )  ;     i := i + 1 ) ; 
     return arr );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    String S=br.readLine();
    String pre=String.valueOf(S.charAt(0))+String.valueOf(S.charAt(1));
    String rear=String.valueOf(S.charAt(2))+String.valueOf(S.charAt(3));
    String ans ;
    if(pre.equals("00")|| Integer.parseInt(pre)>12){
      if(rear.equals("00")|| Integer.parseInt(rear)>12){
        ans="NA" ;
      }
      else {
        ans="YYMM" ;
      }
    }
    else {
      if(rear.equals("00")|| Integer.parseInt(rear)>12){
        ans="MMYY" ;
      }
      else {
        ans="AMBIGUOUS" ;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var S : String ; S := br.readLine() ;
    var pre : String ; pre := ((S->at(0+1)) + "") + ((S->at(1+1)) + "") ;
    var rear : String ; rear := ((S->at(2+1)) + "") + ((S->at(3+1)) + "") ;
    var ans : String ;
    if (pre = "00" or (pre)->toInteger() > 12) then (     if (rear = "00" or (rear)->toInteger() > 12) then (     ans := "NA" ) else (     ans := "YYMM" ) ) else (     if (rear = "00" or (rear)->toInteger() > 12) then (     ans := "MMYY" ) else (     ans := "AMBIGUOUS" ) ) ;  
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    double debt=100000 ;
    debt*=0.001 ;
    while(sc.hasNext()){
      int n=sc.nextInt();
      for(int i=0 ; i<n ; i++){
        debt*=1.05 ;
        debt=Math.ceil(debt);
      }
      System.out.println((int)debt*1000);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var debt : double ; debt := 100000 ;
     debt := debt*(0.001) ; 
     while (sc.hasNext()) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     debt := debt*(1.05) ; 
     debt := (debt)->ceil() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(debt->oclAsType(int) * 1000) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void checksum(int n){
    if(n==0){
      System.out.println("-1 0 1");
      return ;
    }
    int inc ;
    if(n>0)inc=1 ;
    else inc=-1 ;
    for(int i=0 ; i<=n-2 ; i+=inc){
      if(i+i+1+i+2==n){
        System.out.println(i+" "+(i+1)+" "+(i+2));
        return ;
      }
    }
    System.out.println("-1");
  }
  public static void main(String[] args){
    int n=6 ;
    checksum(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checksum( n : int) : void
  pre: true
  post: true
  activity: (     if (n = 0) then (     OclFile["System.out"].println("-1 0 1") ; 
     return ) else skip ; 
     var inc : int ;
    if (n > 0) then     inc := 1 else     inc := -1 ; ;  
        var i : int ; i := 0 ; while i <= n - 2 do ( (     if (i + i + 1 + i + 2 = n) then (     OclFile["System.out"].println(i + " " + (i + 1) + " " + (i + 2)) ; 
     return ) else skip )  ;     i := i+(inc) ) ; 
    OclFile["System.out"].println("-1") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
     execute checksum(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void checksum(int n){
    if(n==0){
      System.out.println("-2-1 0 1 2");
      return ;
    }
    int inc ;
    if(n>0)inc=1 ;
    else inc=-1 ;
    for(int i=0 ; i<=n-4 ; i+=inc){
      if(i+i+1+i+2+i+3+i+4==n){
        System.out.print((i)+" "+(i+1)+" "+(i+2)+" "+(i+3)+" "+(i+4));
        return ;
      }
    }
    System.out.println("-1");
  }
  public static void main(String[] args){
    int n=15 ;
    checksum(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checksum( n : int) : void
  pre: true
  post: true
  activity: (     if (n = 0) then (     OclFile["System.out"].println("-2-1 0 1 2") ; 
     return ) else skip ; 
     var inc : int ;
    if (n > 0) then     inc := 1 else     inc := -1 ; ;  
        var i : int ; i := 0 ; while i <= n - 4 do ( (     if (i + i + 1 + i + 2 + i + 3 + i + 4 = n) then (     OclFile["System.out"].print((i) + " " + (i + 1) + " " + (i + 2) + " " + (i + 3) + " " + (i + 4)) ; 
     return ) else skip )  ;     i := i+(inc) ) ; 
    OclFile["System.out"].println("-1") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 15 ;
     execute checksum(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
import java.util.stream.IntStream ;
public class B_Motarack_s_Birthday {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int tc=0 ; tc<t ; ++tc){
      int n=sc.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<a.length ; ++i){
        a[i]=sc.nextInt();
      }
      System.out.println(solve(a));
    }
    sc.close();
  }
  static String solve(int[] a){
    int[] neighbors=IntStream.range(0,a.length).filter(i->a[i]!=-1 &&((i!=0 && a[i-1]==-1)||(i!=a.length-1 && a[i+1]==-1))).map(i->a[i]).toArray();
    if(neighbors.length==0){
      return "0 0" ;
    }
    int min=Arrays.stream(neighbors).min().getAsInt();
    int max=Arrays.stream(neighbors).max().getAsInt();
    int k=(min+max)/2 ;
    int[] filled=IntStream.range(0,a.length).map(i->(a[i]==-1)? k : a[i]).toArray();
    int m=IntStream.range(0,filled.length-1).map(i->Math.abs(filled[i]-filled[i+1])).max().getAsInt();
    return String.format("%d %d",m,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Motarack_s_Birthday {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var tc : int ; tc := 0 ; while tc < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
         var i : int ; i := 0 ; while i < a->size() do ( (     a[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(solve(a)) )  ;     tc := tc + 1 ) ; 
     skip );
  static   operation solve( a : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var neighbors : Sequence(int) ; neighbors := Integer.subrange(0, a->size()-1)->select( _x1 | (lambda i : OclAny in a[i+1] /= -1 & ((i /= 0 & a[i - 1+1] = -1) or (i /= a->size() - 1 & a[i + 1+1] = -1)))->apply(_x1) )->collect( _x1 | (lambda i : OclAny in a[i+1])->apply(_x1) )->asSequence() ;
     if (neighbors->size() = 0) then (     return "0 0" ) else skip ; 
    var min : int ; min := stream(neighbors).min().getAsInt() ;
    var max : int ; max := stream(neighbors).max().getAsInt() ;
    var k : int ; k := (min + max) / 2 ;
    var filled : Sequence(int) ; filled := Integer.subrange(0, a->size()-1)->collect( _x1 | (lambda i : OclAny in if (a[i+1] = -1) then k else a[i+1] endif)->apply(_x1) )->asSequence() ;
    var m : int ; m := Integer.subrange(0, filled->size() - 1-1)->collect( _x1 | (lambda i : OclAny in if filled[i+1] - filled[i + 1+1] < 0 then -(filled[i+1] - filled[i + 1+1]) else filled[i+1] - filled[i + 1+1] endif)->apply(_x1) ).max().getAsInt() ;
    return StringLib.format("%d %d",Sequence{m,k}) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import java.util.*;
import java.lang.Math ;
public class JvForces {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int cs=0 ; cs<t ; cs++){
      int n=sc.nextInt();
      long[] arr=new long[n];
      for(int i=0 ; i<n ; i++){
        long a=sc.nextLong();
        arr[i]=a ;
      }
      long diff=0 ;
      long mx=-2 ;
      long mn=1000000007 ;
      for(int i=0 ; i<n ; i++){
        if(i>0 && arr[i]==-1 && arr[i-1]!=-1){
          mn=Math.min(mn,arr[i-1]);
          mx=Math.max(mx,arr[i-1]);
        }
        if(i<n-1 && arr[i]==-1 && arr[i+1]!=-1){
          mn=Math.min(mn,arr[i+1]);
          mx=Math.max(mx,arr[i+1]);
        }
      }
      if(mx==-2 && mn==1000000007){
        System.out.println(0+" "+0);
      }
      else {
        diff=mx-mn ;
        long ans=mn+diff/2 ;
        long abdiff=0 ;
        if(arr[0]==-1){
          arr[0]=ans ;
        }
        for(int i=1 ; i<n ; i++){
          if(arr[i]==-1){
            arr[i]=ans ;
          }
          abdiff=Math.max(abdiff,Math.abs(arr[i]-arr[i-1]));
        }
        System.out.println(abdiff+" "+ans);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class JvForces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var cs : int ; cs := 0 ; while cs < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var a : long ; a := sc.getCurrent()->toLong() ;
     arr[i+1] := a )  ;     i := i + 1 ) ; 
    var diff : long ; diff := 0 ;
    var mx : long ; mx := -2 ;
    var mn : long ; mn := 1000000007 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i > 0 & arr[i+1] = -1 & arr[i - 1+1] /= -1) then (     mn := Set{mn, arr[i - 1+1]}->min() ; 
     mx := Set{mx, arr[i - 1+1]}->max() ) else skip ; 
     if (i < n - 1 & arr[i+1] = -1 & arr[i + 1+1] /= -1) then (     mn := Set{mn, arr[i + 1+1]}->min() ; 
     mx := Set{mx, arr[i + 1+1]}->max() ) else skip )  ;     i := i + 1 ) ; 
    if (mx = -2 & mn = 1000000007) then (     OclFile["System.out"].println(0 + " " + 0) ) else (     diff := mx - mn ; 
     var ans : long ; ans := mn + diff / 2 ;
    var abdiff : long ; abdiff := 0 ;
    if (arr[0+1] = -1) then (     arr[0+1] := ans ) else skip ; 
        var i : int ; i := 1 ; while i < n do ( (     if (arr[i+1] = -1) then (     arr[i+1] := ans ) else skip ; 
     abdiff := Set{abdiff, if arr[i+1] - arr[i - 1+1] < 0 then -(arr[i+1] - arr[i - 1+1]) else arr[i+1] - arr[i - 1+1] endif}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(abdiff + " " + ans) ; 
 ) ;  
 )  ;     cs := cs + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out=new PrintWriter(System.out);
    StringTokenizer tok=new StringTokenizer(in.readLine());
    int N=Integer.parseInt(tok.nextToken());
    int M=Integer.parseInt(tok.nextToken());
    boolean arr[]=new boolean[N+1];
    int arr2[]=new int[N+1];
    arr[1]=true ;
    Arrays.fill(arr2,1);
    int cont=0 ;
    for(int i=0 ; i<M ; i++){
      tok=new StringTokenizer(in.readLine());
      int x=Integer.parseInt(tok.nextToken());
      int y=Integer.parseInt(tok.nextToken());
      if(arr[x]){
        if(arr2[x]!=0){
          arr2[y]++;
          arr2[x]--;
          if(arr2[x]==0){
            arr[x]=false ;
          }
          arr[y]=true ;
        }
        else {
          arr2[y]++;
          arr2[x]--;
        }
      }
      else {
        arr2[y]++;
        arr2[x]--;
      }
    }
    for(int i=0 ; i<arr.length ; i++){
      if(arr[i])cont++;
    }
    System.out.println(cont);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var tok : OclIterator ; tok := OclIterator.newOclIterator_String(in.readLine()) ;
    var N : int ; N := (tok.next())->toInteger() ;
    var M : int ; M := (tok.next())->toInteger() ;
    var arr : Sequence(boolean) ; arr := Integer.subrange(1,N + 1)->collect(false) ;
    var arr2 : Sequence(int) ; arr2 := Integer.subrange(1,N + 1)->collect(0) ;
    arr[1+1] := true ; 
    arr2 := arr2->collect(1) ; 
    var cont : int ; cont := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     tok := OclIterator.newOclIterator_String(in.readLine()) ; 
     var x : int ; x := (tok.next())->toInteger() ;
     var y : int ; y := (tok.next())->toInteger() ;
     if (arr[x+1]) then (     if (arr2[x+1] /= 0) then (     arr2[y+1] := arr2[y+1] + 1 ; 
     arr2[x+1] := arr2[x+1] - 1 ; 
     if (arr2[x+1] = 0) then (     arr[x+1] := false ) else skip ; 
     arr[y+1] := true ) else (     arr2[y+1] := arr2[y+1] + 1 ; 
     arr2[x+1] := arr2[x+1] - 1 ) ) else (     arr2[y+1] := arr2[y+1] + 1 ; 
     arr2[x+1] := arr2[x+1] - 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < arr->size() do ( (     if (arr[i+1]) then     cont := cont + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(cont) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class vk18 {
  public static void main(String[] stp)throws Exception {
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt(),i,p ;
    long q=scan.nextLong(),l=scan.nextLong(),count=0,flag=0,c,d ;
    long a[]=new long[n+2];
    a[0]=0 ;
    a[n+1]=0 ;
    for(i=1 ; i<=n ; i++){
      a[i]=scan.nextLong();
      if(a[i]>l){
        if(flag==0){
          count++;
          flag=69 ;
        }
      }
      else {
        flag=0 ;
      }
    }
    while(q!=0){
      c=scan.nextLong();
      if(c==0)System.out.println(count);
      else {
        p=scan.nextInt();
        d=scan.nextLong();
        a[p]+=d ;
        if(a[p]-d<=l && a[p]>l){
          if(a[p-1]>l && a[p+1]>l){
            count--;
          }
          else if(a[p-1]<=l && a[p+1]<=l)count++;
        }
      }
      q--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class vk18 {
  static   operation main( stp : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var i : int ;
    var p : int ;
    var q : long ; q := scan.getCurrent()->toLong() ;
    var l : long ; l := scan.getCurrent()->toLong() ;
    var count : long ; count := 0 ;
    var flag : long ; flag := 0 ;
    var c : long ;
    var d : long ;
    var a : Sequence(long) ; a := Integer.subrange(1,n + 2)->collect(0) ;
    a[0+1] := 0 ; 
    a[n + 1+1] := 0 ; 
        i := 1 ; while i <= n do ( (     a[i+1] := scan.getCurrent()->toLong() ; 
     if (a[i+1] > l) then (     if (flag = 0) then (     count := count + 1 ; 
     flag := 69 ) else skip ) else (     flag := 0 ) )  ;     i := i + 1 ) ; 
    while (q /= 0) do (     c := scan.getCurrent()->toLong() ; 
     if (c = 0) then     OclFile["System.out"].println(count) else (     p := scan.getCurrent()->toInteger() ; 
     d := scan.getCurrent()->toLong() ; 
     a[p+1] := a[p+1]+(d) ; 
     if (a[p+1] - d <= l & a[p+1] > l) then (     if (a[p - 1+1] > l & a[p + 1+1] > l) then (     count := count - 1 ) else     if (a[p - 1+1] <= l & a[p + 1+1] <= l) then     count := count + 1 ; else skip ; ) else skip ) ;  
     q := q - 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.LinkedList ;
import java.util.Queue ;
import java.util.Scanner ;
public class Main {
  public static int maxn=100005 ;
  public static long a[]=new long[maxn];
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n,m,l ;
    n=sc.nextInt();
    m=sc.nextInt();
    l=sc.nextInt();
    for(int t=1 ; t<=n ; t++){
      a[t]=sc.nextLong();
    }
    int i=1 ;
    long ans=0 ;
    while(i<=n){
      if(a[i]>l){
        ans++;
        while(a[i]>l && i<=n){
          i++;
        }
      }
      i++;
    }
    int op ;
    for(int t=0 ; t<m ; t++){
      op=sc.nextInt();
      if(op==0)System.out.println(ans);
      else {
        int p ;
        long d ;
        p=sc.nextInt();
        d=sc.nextLong();
        if(a[p]+d>l && a[p]<=l){
          if(a[p-1]>l && a[p+1]>l){
            ans--;
          }
          if(a[p-1]<=l && a[p+1]<=l){
            ans++;
          }
        }
        a[p]+=d ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute maxn : int := 100005;
  static   attribute a : long := Integer.subrange(1,maxn)->collect(0);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ;
    var m : int ;
    var l : int ;
    n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
    l := sc.getCurrent()->toInteger() ; 
        var t : int ; t := 1 ; while t <= n do ( (     a[t+1] := sc.getCurrent()->toLong() )  ;     t := t + 1 ) ; 
    var i : int ; i := 1 ;
    var ans : long ; ans := 0 ;
    while (i <= n) do (     if (a[i+1] > l) then (     ans := ans + 1 ; 
     while (a[i+1] > l & i <= n) do (     i := i + 1 ) ) else skip ; 
     i := i + 1 ) ; 
    var op : int ;
        var t : int ; t := 0 ; while t < m do ( (     op := sc.getCurrent()->toInteger() ; 
     if (op = 0) then     OclFile["System.out"].println(ans) ; else (     var p : int ;
     var d : long ;
    p := sc.getCurrent()->toInteger() ; 
    d := sc.getCurrent()->toLong() ; 
    if (a[p+1] + d > l & a[p+1] <= l) then (     if (a[p - 1+1] > l & a[p + 1+1] > l) then (     ans := ans - 1 ) else skip ; 
     if (a[p - 1+1] <= l & a[p + 1+1] <= l) then (     ans := ans + 1 ) else skip ) else skip ; 
    a[p+1] := a[p+1]+(d) ; 
 ) )  ;     t := t + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findNums(int n){
    if(n<=11){
      if(n==8)System.out.print("4 4");
      if(n==10)System.out.print("4 6");
      else System.out.print("-1");
      return ;
    }
    if(n % 2==0)System.out.print("4 "+(n-4));
    else System.out.print("9 "+(n-9));
  }
  public static void main(String args[]){
    int n=13 ;
    findNums(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNums( n : int) : void
  pre: true
  post: true
  activity: (     if (n <= 11) then (     if (n = 8) then     OclFile["System.out"].print("4 4") ; else skip ; 
     if (n = 10) then     OclFile["System.out"].print("4 6") else     OclFile["System.out"].print("-1") ; ;  
     return ) else skip ; 
     if (n mod 2 = 0) then     OclFile["System.out"].print("4 " + (n - 4)) ; else     OclFile["System.out"].print("9 " + (n - 9)) ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 13 ;
     execute findNums(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    Scanner s=new Scanner(System.in);
    int size=s.nextInt();
    int[] a=new int[size];
    long count=0 ;
    for(int i=0 ; i<size ; i++){
      a[i]=s.nextInt();
    }
    for(int i=0 ; i<size ; i++){
      int b=s.nextInt();
      if(b>a[i]*2 || b<2){
        count--;
      }
      else {
        count+=(long)Math.pow(b,2)/4 ;
      }
    }
    System.out.println(count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var size : int ; size := s.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,size)->collect(0) ;
    var count : long ; count := 0 ;
        var i : int ; i := 0 ; while i < size do ( (     a[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < size do ( (     var b : int ; b := s.getCurrent()->toInteger() ;
     if (b > a[i+1] * 2 or b < 2) then (     count := count - 1 ) else (     count := count+(b->pow(2)->oclAsType(long) / 4) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CF229 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Long[] a=new Long[n];
    Long[] b=new Long[n];
    for(int i=0 ; i<n ; i++){
      a[i]=sc.nextLong();
    }
    for(int i=0 ; i<n ; i++){
      b[i]=sc.nextLong();
    }
    long total=0 ;
    for(int i=0 ; i<n ; i++){
      if(b[i]>1 && b[i]<=2*a[i]){
        total+=(b[i]/2)*(b[i]-(b[i]/2));
      }
      else {
--total ;
      }
    }
    System.out.println(total);
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF229 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(null) ;
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var total : long ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (b[i+1] > 1 & b[i+1] <= 2 * a[i+1]) then (     total := total+((b[i+1] / 2) * (b[i+1] - (b[i+1] / 2))) ) else (     total := total - 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Solutions {
  public static void main(String[] args)throws IOException {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Integer>ar=new ArrayList<Integer>(n);
    List<Integer>br=new ArrayList<Integer>(n);
    long res=0 ;
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      ar.add(new Integer(a));
    }
    for(int i=0 ; i<n ; i++){
      int b=sc.nextInt();
      br.add(new Integer(b));
    }
    for(int i=0 ; i<n ; i++){
      int a=ar.get(i).intValue();
      int b=br.get(i).intValue();
      if(2*a<b || b==1){
        res--;
      }
      else {
        long b1=(b/2);
        long b2=(b-b1);
        res+=b1*b2 ;
      }
    }
    System.out.println(res);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solutions {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ar : Sequence(int) ; ar := Sequence{} ;
    var br : Sequence(int) ; br := Sequence{} ;
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     ar := ar->including(("" + (a))->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var b : int ; b := sc.getCurrent()->toInteger() ;
     br := br->including(("" + (b))->toInteger()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := ar->at(i+1)->oclAsType(int) ;
     var b : int ; b := br->at(i+1)->oclAsType(int) ;
     if (2 * a < b or b = 1) then (     res := res - 1 ) else (     var b1 : long ; b1 := (b / 2) ;
     var b2 : long ; b2 := (b - b1) ;
     res := res+(b1 * b2) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws NumberFormatException,IOException {
    int period=Integer.parseInt(new BufferedReader(new InputStreamReader(System.in),512).readLine());
    int val=100 ;
    for(; 0<period ; period--){
      val=val*105 % 100==0 ?(int)(val*1.05):(int)(val*1.05)+1 ;
    }
    System.out.println(val*1000);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var period : int ; period := (OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]), 512).readLine())->toInteger() ;
     var val : int ; val := 100 ;
       while 0 < period do ( (     val := if val * 105 mod 100 = 0 then (val * 1.05)->oclAsType(int) else (val * 1.05)->oclAsType(int) + 1 endif )  ;     period := period - 1 ) ; 
     OclFile["System.out"].println(val * 1000) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Solution {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    long result=0 ;
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scanner.nextInt();
    }
    long[] b=new long[n];
    for(int i=0 ; i<n ; i++){
      b[i]=scanner.nextInt();
      if(b[i]<2){
        result--;
      }
      else if(b[i] % 2==0){
        if(b[i]/2<=a[i]){
          result+=(b[i]/2)*(b[i]/2);
        }
        else {
          result--;
        }
      }
      else {
        if(Math.max(((b[i]-1)/2),((b[i]+1)/2))<=a[i]){
          result+=((b[i]-1)/2)*((b[i]+1)/2);
        }
        else {
          result--;
        }
      }
    }
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Solution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var result : long ; result := 0 ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     b[i+1] := scanner.getCurrent()->toInteger() ; 
     if (b[i+1] < 2) then (     result := result - 1 ) else     if (b[i+1] mod 2 = 0) then (     if (b[i+1] / 2 <= a[i+1]) then (     result := result+((b[i+1] / 2) * (b[i+1] / 2)) ) else (     result := result - 1 ) ) else (     if (Set{((b[i+1] - 1) / 2), ((b[i+1] + 1) / 2)}->max() <= a[i+1]) then (     result := result+(((b[i+1] - 1) / 2) * ((b[i+1] + 1) / 2)) ) else (     result := result - 1 ) ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    int[] v=new int[n];
    for(int i=0 ; i<n ; i++)a[i]=sc.nextInt()*2 ;
    for(int i=0 ; i<n ; i++)v[i]=sc.nextInt();
    long ans=0,x,y ;
    for(int i=0 ; i<n ; i++){
      if(a[i]>=v[i]){
        if(v[i]==1){
          ans--;
          x=0 ;
          y=0 ;
        }
        else if(v[i] % 2==0){
          x=v[i]/2 ;
          y=v[i]/2 ;
        }
        else {
          x=v[i]/2 ;
          y=v[i]-x ;
        }
        ans+=x*y ;
      }
      else {
        ans--;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var v : Sequence(int) ; v := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() * 2 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     v[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : long ; ans := 0 ;
    var x : long ;
    var y : long ;
        var i : int ; i := 0 ; while i < n do ( (     if (a[i+1] >= v[i+1]) then (     if (v[i+1] = 1) then (     ans := ans - 1 ; 
     x := 0 ; 
     y := 0 ) else     if (v[i+1] mod 2 = 0) then (     x := v[i+1] / 2 ; 
     y := v[i+1] / 2 ) else (     x := v[i+1] / 2 ; 
     y := v[i+1] - x ) ;  ;  
     ans := ans+(x * y) ) else (     ans := ans - 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void radius(double n,double d){
    System.out.print("The side of each square is "+d/((n-1)*Math.sqrt(2)));
  }
  public static void main(String[] args){
    double d=42,n=4 ;
    radius(n,d);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation radius( n : double, d : double) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].print("The side of each square is " + d / ((n - 1) * (2)->sqrt())) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var d : double ; d := 42 ;
    var n : double ; n := 4 ;
     execute radius(n, d) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int M=sc.nextInt();
    Box[] B=new Box[N];
    B[0]=new Box(1,true);
    for(int i=1 ; i<N ; i++){
      B[i]=new Box(1,false);
    }
    for(int i=0 ; i<M ; i++){
      int x=sc.nextInt()-1 ;
      int y=sc.nextInt()-1 ;
      B[x] .moveTo(B[y]);
    }
    int counter=0 ;
    for(Box b : B){
      if(b.red){
        counter++;
      }
    }
    System.out.println(counter);
  }
}
class Box {
  public int num ;
  public boolean red ;
  public Box(int n,boolean r){
    num=n ;
    red=r ;
  }
  public void moveTo(Box other){
    if(num==0){
      return ;
    }
    else if(num==1){
      num=0 ;
      other.num++;
      if(red){
        other.red=true ;
      }
      red=false ;
    }
    else {
      num--;
      other.num++;
      if(red){
        other.red=true ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var M : int ; M := sc.getCurrent()->toInteger() ;
    var B : Sequence(Box) ; B := Integer.subrange(1,N)->collect(null) ;
    B[0+1] := Box.newBox(1, true) ; 
        var i : int ; i := 1 ; while i < N do ( (     B[i+1] := Box.newBox(1, false) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < M do ( (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
     var y : int ; y := sc.getCurrent()->toInteger() - 1 ;
     B[x+1].moveTo(B[y+1]) )  ;     i := i + 1 ) ; 
    var counter : int ; counter := 0 ;
    for (b : B) do ( (     if (b.red) then (     counter := counter + 1 ) else skip )  ) ; 
    OclFile["System.out"].println(counter) ; 
 );
}
class Box {
   attribute num : int;
   attribute red : boolean;
   static operation newBox( n : int, r : boolean) : Box
  pre: true
  post: true
  activity:
  ( var self : Box ;
    self := createBox();
    self.initialise(n, r);
    return self );
  operation initialise( n : int, r : boolean) : void
  pre: true  post: true
  activity: (     num := n ; 
     red := r );
   operation moveTo( other : Box) : void
  pre: true
  post: true
  activity: (     if (num = 0) then (     return ) else     if (num = 1) then (     num := 0 ; 
     other.num := other.num + 1 ; 
     if (red) then (     other.red := true ) else skip ; 
     red := false ) else (     num := num - 1 ; 
     other.num := other.num + 1 ; 
     if (red) then (     other.red := true ) else skip ) ;  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int Get_Minimum(int[] q){
    int minimum=0 ;
    int sum=0 ;
    for(int i=0 ; i<q.length-1 ; i++){
      sum+=q[i];
      if(sum<minimum)minimum=sum ;
    }
    return minimum ;
  }
  static int[] Find_Permutation(int[] q,int n){
    int[] p=new int[n];
    int min_value=Get_Minimum(q);
    p[0]=1-min_value ;
    for(int i=0 ; i<n-1 ; i++)p[i+1]=p[i]+q[i];
    boolean okay=true ;
    for(int i=0 ; i<n ; i++){
      if(p[i]<1 || p[i]>n)okay=false ;
      Set<Integer>w=new HashSet<>();
      if(w.size()!=n)okay=true ;
    }
    if(okay)return p ;
    else return new int[] {
-1 };
    }
    public static void main(String args[]){
      int[] q={
-2,1 };
        int n=q.length+1 ;
        System.out.print("[");
        for(int i : Find_Permutation(q,n))System.out.print(i+" ");
        System.out.print("] ");
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Get_Minimum( q : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var minimum : int ; minimum := 0 ;
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < q->size() - 1 do ( (     sum := sum+(q[i+1]) ; 
     if (sum < minimum) then     minimum := sum ; else skip )  ;     i := i + 1 ) ; 
     return minimum );
  static   operation Find_Permutation( q : Sequence(int), n : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var p : Sequence(int) ; p := Integer.subrange(1,n)->collect(0) ;
     var min_value : int ; min_value := Get_Minimum(q) ;
    p[0+1] := 1 - min_value ; 
        var i : int ; i := 0 ; while i < n - 1 do (     p[i + 1+1] := p[i+1] + q[i+1] ;  ;     i := i + 1 ) ; 
    var okay : boolean ; okay := true ;
        var i : int ; i := 0 ; while i < n do ( (     if (p[i+1] < 1 or p[i+1] > n) then     okay := false ; else skip ; 
     var w : Set(int) ; w := Set{} ;
     if (w->size() /= n) then     okay := true ; else skip )  ;     i := i + 1 ) ; 
    if (okay) then     return p else     return Sequence{-1} ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var q : Sequence(int) ; q := Sequence{-2,1} ;
     var n : int ; n := q->size() + 1 ;
    OclFile["System.out"].print("[") ; 
    for (i : Find_Permutation(q, n)) do (     OclFile["System.out"].print(i + " ") ;  ) ; 
    OclFile["System.out"].print("] ") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class mafia {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    int n=Integer.parseInt(st.nextToken());
    long[] a=new long[n+1];
    st=new StringTokenizer(br.readLine());
    for(int i=1 ; i<=n ; i++)a[i]=Long.parseLong(st.nextToken());
    long max=a[1];
    long s=a[1];
    for(int i=2 ; i<=n ; i++){
      max=Math.max(max,a[i]);
      s+=a[i];
    }
    long lo=max ;
    long hi=s ;
    while(lo!=hi){
      long mid=(lo+hi)/2 ;
      if(works(mid,n,s)){
        hi=mid ;
      }
      else {
        lo=mid+1 ;
      }
    }
    System.out.println(lo);
  }
  static boolean works(long mid,int n,long s){
    boolean res=false ;
    long ln=n ;
    if((ln-1)*mid>=s){
      res=true ;
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class mafia {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var n : int ; n := (st.next())->toInteger() ;
    var a : Sequence(long) ; a := Integer.subrange(1,n + 1)->collect(0) ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 1 ; while i <= n do (     a[i+1] := (st.next())->toLong() ;  ;     i := i + 1 ) ; 
    var max : long ; max := a[1+1] ;
    var s : long ; s := a[1+1] ;
        var i : int ; i := 2 ; while i <= n do ( (     max := Set{max, a[i+1]}->max() ; 
     s := s+(a[i+1]) )  ;     i := i + 1 ) ; 
    var lo : long ; lo := max ;
    var hi : long ; hi := s ;
    while (lo /= hi) do (     var mid : long ; mid := (lo + hi) / 2 ;
     if (works(mid, n, s)) then (     hi := mid ) else (     lo := mid + 1 ) ) ; 
    OclFile["System.out"].println(lo) ; 
 );
  static   operation works( mid : long, n : int, s : long) : boolean
  pre: true
  post: true
  activity: (     var res : boolean ; res := false ;
     var ln : long ; ln := n ;
     if ((ln - 1) * mid >= s) then (     res := true ) else skip ; 
     return res );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class codeforces348A {
  static long[] arr ;
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    arr=new long[n];
    StringTokenizer st=new StringTokenizer(br.readLine());
    long sum=0 ;
    long max=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=Long.parseLong(st.nextToken());
      sum+=arr[i];
      max=Math.max(max,arr[i]);
    }
    long l=max ;
    long r=(long)Math.pow(10,13);
    while(l<r){
      long mid=(l+r)/2 ;
      if(n*mid-sum>=mid){
        r=mid ;
      }
      else {
        l=mid+1 ;
      }
    }
    System.out.println(l);
  }
  static boolean check(long curr,int n){
    long sum=0 ;
    for(int i=0 ; i<arr.length ; i++){
      sum+=curr-arr[i];
    }
    return sum>=n ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces348A {
  static   attribute arr : Sequence(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    arr := Integer.subrange(1,n)->collect(0) ; 
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var sum : long ; sum := 0 ;
    var max : long ; max := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (st.next())->toLong() ; 
     sum := sum+(arr[i+1]) ; 
     max := Set{max, arr[i+1]}->max() )  ;     i := i + 1 ) ; 
    var l : long ; l := max ;
    var r : long ; r := 10->pow(13)->oclAsType(long) ;
    while (l < r) do (     var mid : long ; mid := (l + r) / 2 ;
     if (n * mid - sum >= mid) then (     r := mid ) else (     l := mid + 1 ) ) ; 
    OclFile["System.out"].println(l) ; 
 );
  static   operation check( curr : long, n : int) : boolean
  pre: true
  post: true
  activity: (     var sum : long ; sum := 0 ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     sum := sum+(curr - arr[i+1]) )  ;     i := i + 1 ) ; 
     return sum >= n );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    try(Scanner sc=new Scanner(System.in)){
      int N=sc.nextInt();
      int K=sc.nextInt();
      int Q=sc.nextInt();
      int[] points=new int[N];
      for(int i=0 ; i<Q ; i++){
        int pointGetter=sc.nextInt()-1 ;
        points[pointGetter]++;
      }
      for(int i=0 ; i<N ; i++){
        if(K-Q+points[i]>0){
          System.out.println("Yes");
        }
        else {
          System.out.println("No");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var K : int ; K := sc.getCurrent()->toInteger() ;
    var Q : int ; Q := sc.getCurrent()->toInteger() ;
    var points : Sequence(int) ; points := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < Q do ( (     var pointGetter : int ; pointGetter := sc.getCurrent()->toInteger() - 1 ;
     points[pointGetter+1] := points[pointGetter+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (K - Q + points[i+1] > 0) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) )  ;     i := i + 1 ) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    OutputStream outputStream=System.out ;
    PrintWriter out=new PrintWriter(outputStream);
    int i,n,m,k ;
    StringTokenizer st=new StringTokenizer(br.readLine());
    n=Integer.parseInt(st.nextToken());
    k=Integer.parseInt(st.nextToken());
    int q=Integer.parseInt(st.nextToken());
    HashMap<Integer,Integer>hp=new HashMap<>();
    int max=Integer.MIN_VALUE ;
    for(int j=1 ; j<=q ; j++){
      int tmp=Integer.parseInt(br.readLine());
      if(! hp.containsKey(tmp))hp.put(tmp,1);
      else hp.put(tmp,hp.get(tmp)+1);
    }
    for(i=1 ; i<=n ; i++){
      if(hp.containsKey(i)&& k-(q-hp.get(i))>0)out.println("Yes");
      else if(k-q>0)out.println("Yes");
      else out.println("No");
    }
    out.flush();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var i : int ;
    var n : int ;
    var m : int ;
    var k : int ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    n := (st.next())->toInteger() ; 
    k := (st.next())->toInteger() ; 
    var q : int ; q := (st.next())->toInteger() ;
    var hp : Map(int,int) ; hp := Map{} ;
    var max : int ; max := -2147483648 ;
        var j : int ; j := 1 ; while j <= q do ( (     var tmp : int ; tmp := (br.readLine())->toInteger() ;
     if (not(hp->keys()->includes(tmp))) then     hp := hp->union(Map{tmp |-> 1}) ; else     hp := hp->union(Map{tmp |-> hp->at(tmp) + 1}) ; )  ;     j := j + 1 ) ; 
        i := 1 ; while i <= n do ( (     if (hp->keys()->includes(i) & k - (q - hp->at(i)) > 0) then     skip ; else     if (k - q > 0) then     skip else     skip ; ;  )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String args[]){
    Scanner scan=new Scanner(System.in);
    Integer N=scan.nextInt();
    Long K=scan.nextLong();
    Integer Q=scan.nextInt();
    ArrayList<Integer>A=new ArrayList<Integer>();
    Integer array[]=new Integer[N];
    for(int i=0 ; i<Q ; i++)A.add(scan.nextInt());
    for(int i=0 ; i<N ; i++)array[i]=0 ;
    for(int i=0 ; i<Q ; i++){
      array[A.get(i)-1]++;
    }
    for(int i=0 ; i<N ; i++){
      if(Q-K>=array[i])System.out.println("No");
      else System.out.println("Yes");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scan.getCurrent()->toInteger() ;
    var K : long ; K := scan.getCurrent()->toLong() ;
    var Q : int ; Q := scan.getCurrent()->toInteger() ;
    var A : Sequence(int) ; A := Sequence{} ;
    var array : Sequence(int) ; array := Integer.subrange(1,N)->collect(null) ;
        var i : int ; i := 0 ; while i < Q do (     A := A->including(scan.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do (     array[i+1] := 0 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < Q do ( (     array[A->at(i+1) - 1+1] := array[A->at(i+1) - 1+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (Q - K >= array[i+1]) then     OclFile["System.out"].println("No") ; else     OclFile["System.out"].println("Yes") ; )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    int N=in.nextInt();
    long K=in.nextInt();
    int Q=in.nextInt();
    long[] counts=new long[N];
    Arrays.fill(counts,0);
    for(int i=0 ; i<Q ; i++)counts[in.nextInt()-1]++;
    for(int i=0 ; i<N ; i++){
      if(K-((long)Q-counts[i])>0L){
        System.out.println("Yes");
      }
      else {
        System.out.println("No");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := in.getCurrent()->toInteger() ;
     var K : long ; K := in.getCurrent()->toInteger() ;
    var Q : int ; Q := in.getCurrent()->toInteger() ;
    var counts : Sequence(long) ; counts := Integer.subrange(1,N)->collect(0) ;
    counts := counts->collect(0) ; 
        var i : int ; i := 0 ; while i < Q do (     counts[in.getCurrent()->toInteger() - 1+1] := counts[in.getCurrent()->toInteger() - 1+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < N do ( (     if (K - (Q->oclAsType(long) - counts[i+1]) > 0L) then (     OclFile["System.out"].println("Yes") ) else (     OclFile["System.out"].println("No") ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int debt=100000 ;
    final int n=scanner.nextInt();
    debt=calculateDebt(debt,n);
    System.out.println(debt);
  }
  static int calculateDebt(int debt){
    final double INTEREST=0.05 ;
    final int ROUNUD_UP_MONEY=1000 ;
    debt*=1+INTEREST ;
    final int fraction=debt % ROUNUD_UP_MONEY ;
    if(fraction>0){
      debt=debt-fraction+ROUNUD_UP_MONEY ;
    }
    return debt ;
  }
  static int calculateDebt(int debt,int time){
    for(int i=0 ; i<time ; i++){
      debt=calculateDebt(debt);
    }
    return debt ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var debt : int ; debt := 100000 ;
    var n : int ; n := scanner.getCurrent()->toInteger() ;
    debt := calculateDebt(debt, n) ; 
    OclFile["System.out"].println(debt) ; 
 );
  static   operation calculateDebt( debt : int) : int
  pre: true
  post: true
  activity: (     var INTEREST : double ; INTEREST := 0.05 ;
     var ROUNUD_UP_MONEY : int ; ROUNUD_UP_MONEY := 1000 ;
    debt := debt*(1 + INTEREST) ; 
    var fraction : int ; fraction := debt mod ROUNUD_UP_MONEY ;
    if (fraction > 0) then (     debt := debt - fraction + ROUNUD_UP_MONEY ) else skip ; 
    return debt 
 );
  static   operation calculateDebt( debt : int, time : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < time do ( (     debt := calculateDebt(debt) )  ;     i := i + 1 ) ; 
     return debt );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] $){
    Scanner s=new Scanner(System.in);
    int m=s.nextInt(),b=s.nextInt(),n=s.nextInt();
    int[] a=new int[m];
    for(int i=0 ; i<n ; ++i)++a[s.nextInt()-1];
    for(int i=0 ; i<m ; ++i)System.out.println(b-n+a[i]>0 ? "Yes" : "No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var m : int ; m := s.getCurrent()->toInteger() ;
    var b : int ; b := s.getCurrent()->toInteger() ;
    var n : int ; n := s.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,m)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[s.getCurrent()->toInteger() - 1+1] := a[s.getCurrent()->toInteger() - 1+1] + 1 ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < m do (     OclFile["System.out"].println(if b - n + a[i+1] > 0 then "Yes" else "No" endif) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int __gcd(int a,int b){
    if(a==0 || b==0)return 0 ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static int find_Gcd(int crr[],int n){
    int i ;
    int result=crr[0];
    for(i=1 ; i<n ; i++)result=__gcd(crr[i],result);
    return result ;
  }
  static void profitRatio(int amountArr[],int timeTrr[],int n){
    int i ;
    int crr[]=new int[n];
    for(i=0 ; i<n ; i++)crr[i]=amountArr[i]*timeTrr[i];
    int Share=find_Gcd(crr,n);
    for(i=0 ; i<n-1 ; i++)System.out.print(crr[i]/Share+" : ");
    System.out.print(crr[i]/Share);
  }
  public static void main(String[] args){
    int amountArr[]={
      5000,6000,1000 };
      int timeTrr[]={
        6,6,12 };
        int n=amountArr.length ;
        profitRatio(amountArr,timeTrr,n);
      }
    }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0 or b = 0) then     return 0 else skip ; 
     if (a = b) then     return a else skip ; 
     if (a > b) then     return __gcd(a - b, b) else skip ; 
     return __gcd(a, b - a) );
  static   operation find_Gcd( crr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
     var result : int ; result := crr[0+1] ;
         i := 1 ; while i < n do (     result := __gcd(crr[i+1], result) ;  ;     i := i + 1 ) ; 
     return result );
  static   operation profitRatio( amountArr : Sequence(int), timeTrr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
     var crr : Sequence(int) ; crr := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do (     crr[i+1] := amountArr[i+1] * timeTrr[i+1] ;  ;     i := i + 1 ) ; 
    var Share : int ; Share := find_Gcd(crr, n) ;
        i := 0 ; while i < n - 1 do (     OclFile["System.out"].print(crr[i+1] / Share + " : ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(crr[i+1] / Share) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var amountArr : Sequence(int) ; amountArr := Sequence{5000,6000,1000} ;
     var timeTrr : Sequence(int) ; timeTrr := Sequence{6,6,12} ;
     var n : int ; n := amountArr->size() ;
     execute profitRatio(amountArr, timeTrr, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B760 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int hobbits=in.nextInt();
    int pillows=in.nextInt();
    int frodo=in.nextInt();
    long low=1 ;
    long high=pillows ;
    while(low<high){
      long mid=(low+high+1)/2 ;
      long pillowsNeeded=0 ;
      long minBefore=mid-frodo+1 ;
      if(minBefore<1){
        pillowsNeeded+=mid*(mid+1)/2-minBefore+1 ;
      }
      else {
        pillowsNeeded+=(minBefore+mid)*frodo/2 ;
      }
      long after=hobbits-frodo+1 ;
      long minAfter=mid-after+1 ;
      if(minAfter<1){
        pillowsNeeded+=mid*(mid+1)/2-minAfter+1 ;
      }
      else {
        pillowsNeeded+=(minAfter+mid)*after/2 ;
      }
      pillowsNeeded-=mid ;
      if(pillowsNeeded>pillows){
        high=mid-1 ;
      }
      else {
        low=mid ;
      }
    }
    System.out.println(low);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B760 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var hobbits : int ; hobbits := in.getCurrent()->toInteger() ;
    var pillows : int ; pillows := in.getCurrent()->toInteger() ;
    var frodo : int ; frodo := in.getCurrent()->toInteger() ;
    var low : long ; low := 1 ;
    var high : long ; high := pillows ;
    while (low < high) do (     var mid : long ; mid := (low + high + 1) / 2 ;
     var pillowsNeeded : long ; pillowsNeeded := 0 ;
    var minBefore : long ; minBefore := mid - frodo + 1 ;
    if (minBefore < 1) then (     pillowsNeeded := pillowsNeeded+(mid * (mid + 1) / 2 - minBefore + 1) ) else (     pillowsNeeded := pillowsNeeded+((minBefore + mid) * frodo / 2) ) ;  
    var after : long ; after := hobbits - frodo + 1 ;
    var minAfter : long ; minAfter := mid - after + 1 ;
    if (minAfter < 1) then (     pillowsNeeded := pillowsNeeded+(mid * (mid + 1) / 2 - minAfter + 1) ) else (     pillowsNeeded := pillowsNeeded+((minAfter + mid) * after / 2) ) ;  
    pillowsNeeded := pillowsNeeded-(mid) ; 
    if (pillowsNeeded > pillows) then (     high := mid - 1 ) else (     low := mid ) ;  
 ) ; 
    OclFile["System.out"].println(low) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class G {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer(br.readLine());
    long a=Long.parseLong(st.nextToken());
    long b=Long.parseLong(st.nextToken());
    long t=Long.parseLong(st.nextToken());
    int n=Integer.parseInt(br.readLine());
    if(n==0){
      System.out.println(a);
      return ;
    }
    TreeMap<Long,Integer>map=new TreeMap<>();
    st=new StringTokenizer(br.readLine());
    for(int i=0 ; i<n ; i++){
      long k=Long.parseLong(st.nextToken());
      if(map.containsKey(k)){
        map.put(k,map.get(k)+1);
      }
      else {
        map.put(k,1);
      }
    }
    long currt=a ;
    long min=(long)1e12 ;
    long res=0 ;
    for(long k : map.keySet()){
      if(k>currt && k+t<=b){
        System.out.println(currt);
        return ;
      }
      else {
        if(currt-(k-1)<min){
          min=currt-(k-1);
          res=k-1 ;
        }
      }
      long m=map.get(k);
      if(m*t+currt>=b){
        System.out.println(res);
        return ;
      }
      else {
        currt+=m*t ;
      }
    }
    if(currt+t<=b){
      System.out.println(currt);
    }
    else {
      System.out.println(res);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class G {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var a : long ; a := (st.next())->toLong() ;
    var b : long ; b := (st.next())->toLong() ;
    var t : long ; t := (st.next())->toLong() ;
    var n : int ; n := (br.readLine())->toInteger() ;
    if (n = 0) then (     OclFile["System.out"].println(a) ; 
     return ) else skip ; 
    var map : Map(long,int) ; map := Map{} ;
    st := OclIterator.newOclIterator_String(br.readLine()) ; 
        var i : int ; i := 0 ; while i < n do ( (     var k : long ; k := (st.next())->toLong() ;
     if (map->keys()->includes(k)) then (     map := map->union(Map{k |-> map->at(k) + 1}) ) else (     map := map->union(Map{k |-> 1}) ) )  ;     i := i + 1 ) ; 
    var currt : long ; currt := a ;
    var min : long ; min := 1e12->oclAsType(long) ;
    var res : long ; res := 0 ;
    for (k : map->keys()) do ( (     if (k > currt & k + t <= b) then (     OclFile["System.out"].println(currt) ; 
     return ) else (     if (currt - (k - 1) < min) then (     min := currt - (k - 1) ; 
     res := k - 1 ) else skip ) ;  
     var m : long ; m := map->at(k) ;
     if (m * t + currt >= b) then (     OclFile["System.out"].println(res) ; 
     return ) else (     currt := currt+(m * t) ) )  ) ; 
    if (currt + t <= b) then (     OclFile["System.out"].println(currt) ) else (     OclFile["System.out"].println(res) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.List ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    MyScanner sc=new MyScanner();
    out=new PrintWriter(new BufferedOutputStream(System.out));
    int n=sc.nextInt();
    List<Integer>lst=new ArrayList<>();
    for(int i=0 ; i<2*n ; i++){
      lst.add(sc.nextInt());
    }
    Collections.sort(lst);
    int cnt=0 ;
    for(int i=0 ; i<lst.size(); i+=2){
      cnt+=Math.min(lst.get(i),lst.get(i+1));
    }
    out.println(cnt);
    out.close();
  }
  public static PrintWriter out ;
  private static class MyScanner {
    BufferedReader bufferedReader ;
    StringTokenizer stringTokenizer ;
    private MyScanner(){
      bufferedReader=new BufferedReader(new InputStreamReader(System.in));
    }
    private String next(){
      if(stringTokenizer==null || ! stringTokenizer.hasMoreElements()){
        try {
          stringTokenizer=new StringTokenizer(bufferedReader.readLine());
        }
        catch(IOException e){
          e.printStackTrace();
        }
      }
      return stringTokenizer.nextToken();
    }
    private int nextInt(){
      return Integer.parseInt(next());
    }
    private String nextLine(){
      String ret="" ;
      try {
        ret=bufferedReader.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return ret ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : MyScanner ; sc := MyScanner.newMyScanner() ;
     out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ; 
    var n : int ; n := sc.nextInt() ;
    var lst : Sequence(int) ; lst := Sequence{} ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     lst := lst->including(sc.nextInt()) )  ;     i := i + 1 ) ; 
    lst := lst->sort() ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := 0 ; while i < lst->size() do ( (     cnt := cnt+(Set{lst->at(i+1), lst->at(i + 1+1)}->min()) )  ;     i := i+(2) ) ; 
    out.println(cnt) ; 
    out.close() ; 
 );
  static   attribute out : OclFile;
  static class MyScanner {
   attribute bufferedReader : OclFile;
   attribute stringTokenizer : OclIterator;
   static operation newMyScanner() : MyScanner
  pre: true
  post: true
  activity:
  ( var self : MyScanner ;
    self := createMyScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     if (stringTokenizer = null or not(stringTokenizer.hasNext())) then (     try (     stringTokenizer := OclIterator.newOclIterator_String(bufferedReader.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) else skip ; 
     return stringTokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var ret : String ; ret := "" ;
     try (     ret := bufferedReader.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return ret );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] skewers=new int[n*2];
    for(int i=0 ; i<n*2 ; i++){
      skewers[i]=sc.nextInt();
    }
    Arrays.sort(skewers);
    int sum=0 ;
    for(int j=0 ; j<n ; j++){
      sum+=skewers[j*2];
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var skewers : Sequence(int) ; skewers := Integer.subrange(1,n * 2)->collect(0) ;
        var i : int ; i := 0 ; while i < n * 2 do ( (     skewers[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    skewers := skewers->sort() ; 
    var sum : int ; sum := 0 ;
        var j : int ; j := 0 ; while j < n do ( (     sum := sum+(skewers[j * 2+1]) )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.LinkedList ;
import java.util.PriorityQueue ;
import java.util.StringTokenizer ;
public class Main {
  private static final int MOD=(int)Math.pow(10,9);
  public static void main(String[] args){
    FastReader sc=new FastReader();
    int n=sc.nextInt();
    int res=0 ;
    PriorityQueue<Integer>pq=new PriorityQueue<>(Collections.reverseOrder());
    for(int i=0 ; i<2*n ; i++){
      pq.offer(sc.nextInt());
    }
    while(! pq.isEmpty()){
      int kushi1=pq.poll();
      int kushi2=pq.poll();
      res+=(Math.min(kushi1,kushi2));
    }
    System.out.println(res);
  }
  static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MOD : int := 10->pow(9)->oclAsType(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : FastReader ; sc := FastReader.newFastReader() ;
     var n : int ; n := sc.nextInt() ;
    var res : int ; res := 0 ;
    var pq : Sequence(int) ; pq := Sequence{}->union(reverseOrder()) ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     pq := pq->including(sc.nextInt()) )  ;     i := i + 1 ) ; 
    while (not(pq->isEmpty())) do (     var kushi1 : int ; kushi1 := pq->min() ;
     var kushi2 : int ; kushi2 := pq->min() ;
     res := res+((Set{kushi1, kushi2}->min())) ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    StringTokenizer st=new StringTokenizer(br.readLine());
    int[] a=new int[2*n];
    for(int i=0 ; i<2*n ; i++){
      a[i]=Integer.parseInt(st.nextToken());
    }
    Arrays.parallelSort(a);
    int sum=0 ;
    for(int i=0 ; i<2*n ; i+=2){
      sum+=a[i];
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var st : OclIterator ; st := OclIterator.newOclIterator_String(br.readLine()) ;
    var a : Sequence(int) ; a := Integer.subrange(1,2 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     a[i+1] := (st.next())->toInteger() )  ;     i := i + 1 ) ; 
    a := a->sort() ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 2 * n do ( (     sum := sum+(a[i+1]) )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main implements Comparable<Main>{
  int l ;
  public Main(int l){
    this.l=l ;
  }
  public int compareTo(Main o){
    if(l<o.l)return 1 ;
    else if(l>o.l)return-1 ;
    else return 0 ;
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int l[]=new int[2*n];
    for(int i=0 ; i<2*n ; ++i)l[i]=sc.nextInt();
    sc.close();
    Arrays.sort(l);
    int ans=0 ;
    for(int i=0 ; i<2*n-1 ; i+=2){
      ans+=l[i];
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main implements Comparable<Main> {
   attribute l : int;
   static operation newMain( l : int) : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise(l);
    return self );
  operation initialise( l : int) : void
  pre: true  post: true
  activity: (     self.l := l );
   operation compareTo( o : Main) : int
  pre: true
  post: true
  activity: (     if (l < o.l) then     return 1 else     if (l > o.l) then     return -1 else     return 0 ;  );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var l : Sequence(int) ; l := Integer.subrange(1,2 * n)->collect(0) ;
        var i : int ; i := 0 ; while i < 2 * n do (     l[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    skip ; 
    l := l->sort() ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 2 * n - 1 do ( (     ans := ans+(l[i+1]) )  ;     i := i+(2) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      int m=sc.nextInt();
      int K=sc.nextInt();
      if(n==0){
        break ;
      }
      int dp[][]=new int[n+1][m*n+1];
      for(int i=1 ; i<=m ; i++){
        dp[1][i]=1 ;
      }
      for(int i=2 ; i<=n ; i++){
        for(int j=i-1 ; j<=m*n ; j++){
          for(int k=1 ; k<=m ; k++){
            if(j+k>m*n){
              break ;
            }
            dp[i][j+k]+=dp[i-1][j];
          }
        }
      }
      double result=0 ;
      for(int i=n ; i<=m*n ; i++){
        if(i<=K){
          result+=dp[n][i];
        }
        else {
          result+=dp[n][i]*(i-K);
        }
      }
      result/=Math.pow(m,n);
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var K : int ; K := sc.getCurrent()->toInteger() ;
    if (n = 0) then (     break ) else skip ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,m * n + 1)->collect(0)) ;
        var i : int ; i := 1 ; while i <= m do ( (     dp[1+1][i+1] := 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 2 ; while i <= n do ( (         var j : int ; j := i - 1 ; while j <= m * n do ( (         var k : int ; k := 1 ; while k <= m do ( (     if (j + k > m * n) then (     break ) else skip ; 
     dp[i+1][j + k+1] := dp[i+1][j + k+1]+(dp[i - 1+1][j+1]) )  ;     k := k + 1 ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var result : double ; result := 0 ;
        var i : int ; i := n ; while i <= m * n do ( (     if (i <= K) then (     result := result+(dp[n+1][i+1]) ) else (     result := result+(dp[n+1][i+1] * (i - K)) ) )  ;     i := i + 1 ) ; 
    result := result/(m->pow(n)) ; 
    OclFile["System.out"].println(result) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
public class Main {
  Scanner sc=new Scanner(in);
  int[] num ;
  int[] dice ;
  int n,m ;
  void calc(int d){
    if(d==n){
      int sum=0 ;
      for(int i : dice)sum+=i ;
      num[sum]++;
    }
    else {
      for(int i=1 ; i<=m ; i++){
        dice[d]=i ;
        calc(d+1);
      }
    }
  }
  void run(){
    while(true){
      int k ;
      n=sc.nextInt();
      m=sc.nextInt();
      k=sc.nextInt();
      if(n==0 && m==0 && k==0)break ;
      double ans=0 ;
      num=new int[n*m+1];
      dice=new int[n];
      calc(0);
      for(int i=n ; i<=n*m ; i++){
        ans+=num[i]/Math.pow(m,n)*Math.max(1,i-k);
      }
      out.println(ans);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   attribute num : Sequence(int);
   attribute dice : Sequence(int);
   attribute n : int;
   operation calc( d : int) : void
  pre: true
  post: true
  activity: (     if (d = n) then (     var sum : int ; sum := 0 ;
     for (i : dice) do (     sum := sum+(i) ;  ) ; 
     num[sum+1] := num[sum+1] + 1 ) else (         var i : int ; i := 1 ; while i <= m do ( (     dice[d+1] := i ; 
     execute calc(d + 1) )  ;     i := i + 1 ) ) );
   operation run() : void
  pre: true
  post: true
  activity: (     while (true) do (     var k : int ;
     n := sc.getCurrent()->toInteger() ; 
    m := sc.getCurrent()->toInteger() ; 
    k := sc.getCurrent()->toInteger() ; 
    if (n = 0 & m = 0 & k = 0) then     break else skip ; 
    var ans : double ; ans := 0 ;
    num := Integer.subrange(1,n * m + 1)->collect(0) ; 
    dice := Integer.subrange(1,n)->collect(0) ; 
    execute calc(0) ; 
        var i : int ; i := n ; while i <= n * m do ( (     ans := ans+(num[i+1] / m->pow(n) * Set{1, i - k}->max()) )  ;     i := i + 1 ) ; 
    out.println(ans) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args){
    try {
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String line=br.readLine();
      int deptWeek=Integer.parseInt(line);
      int dept=100000 ;
      for(int i=0 ; i<deptWeek ; i++){
        int checkDept=(int)(dept*0.05);
        dept=dept+checkDept ;
        String strCheckDept=String.valueOf(dept);
        String num=strCheckDept.substring(strCheckDept.length()-3,strCheckDept.length());
        if(! num.equals("000")){
          int numnum=Integer.parseInt(num);
          dept=dept+1000-numnum ;
        }
      }
      System.out.println(dept);
    }
    catch(Exception e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var line : String ; line := br.readLine() ;
    var deptWeek : int ; deptWeek := (line)->toInteger() ;
    var dept : int ; dept := 100000 ;
        var i : int ; i := 0 ; while i < deptWeek do ( (     var checkDept : int ; checkDept := (dept * 0.05)->oclAsType(int) ;
     dept := dept + checkDept ; 
    var strCheckDept : String ; strCheckDept := ((dept) + "") ;
    var num : String ; num := strCheckDept.subrange(strCheckDept->size() - 3+1,strCheckDept->size()) ;
    if (not(num = "000")) then (     var numnum : int ; numnum := (num)->toInteger() ;
     dept := dept + 1000 - (numnum)->char2byte() ) else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dept) ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-9 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    for(; ; ){
      int n=sc.nextInt(),m=sc.nextInt(),k=sc.nextInt();
      if((n | m | k)==0)break ;
      long[][] pas=new long[2][n*m+1];
      pas[0][0]=1 ;
      int x=1 ;
      for(int i=0 ; i<n ; i++){
        fill(pas[x],0);
        for(int j=0 ; j<=n*m ; j++)if(pas[1-x][j]>0){
          for(int h=1 ; h<=m ; h++)pas[x][j+h]+=pas[1-x][j];
        }
        x=1-x ;
      }
      long sum=0 ;
      for(int i=0 ; i<=m*n ; i++)sum+=pas[1-x][i];
      double ex=0.0 ;
      for(int i=0 ; i<=n*m ; i++)ex+=1.0*max(i-k,1)*pas[1-x][i]/sum ;
      System.out.println(ex);
    }
  }
  void debug(Object...os){
    System.err.println(deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-9;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
    var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
     if ((MathLib.bitwiseOr(MathLib.bitwiseOr(n,m),k)) = 0) then     break else skip ; 
    var pas : Sequence(Sequence(long)) ; pas := Integer.subrange(1,2)->collect(Integer.subrange(1,n * m + 1)->collect(0)) ;
    pas[0+1][0+1] := 1 ; 
    var x : int ; x := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     execute fill(pas[x+1], 0) ; 
         var j : int ; j := 0 ; while j <= n * m do (     if (pas[1 - x+1][j+1] > 0) then (         var h : int ; h := 1 ; while h <= m do (     pas[x+1][j + h+1] := pas[x+1][j + h+1]+(pas[1 - x+1][j+1]) ;  ;     h := h + 1 ) ) else skip ;  ;     j := j + 1 ) ; 
     x := 1 - x )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i <= m * n do (     sum := sum+(pas[1 - x+1][i+1]) ;  ;     i := i + 1 ) ; 
    var ex : double ; ex := 0.0 ;
        var i : int ; i := 0 ; while i <= n * m do (     ex := ex+(1.0 * Set{i - k, 1}->max() * pas[1 - x+1][i+1] / sum) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ex) ; 
 )  ) );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    for(; ; ){
      int n=sc.nextInt();
      if(n==0)return ;
      int[][] c=new int[n][2];
      for(int i=0 ; i<n ; i++){
        c[i][0]=sc.nextInt();
        c[i][1]=sc.nextInt();
      }
      int[][] dp=new int[n+1][2001];
      dp[0][0]=1 ;
      for(int i=0 ; i<n ; i++){
        for(int j=0 ; j<=1000 ; j++){
          if(dp[i][j]!=0){
            dp[i+1][j]+=dp[i][j];
            for(int k=1 ; k<=c[i][1]; k++){
              if(j+k*c[i][0]<=1000)dp[i+1][j+k*c[i][0] ]+=dp[i][j];
            }
          }
        }
      }
      int m=sc.nextInt();
      while(m-->0){
        System.out.println(dp[n][sc.nextInt()]);
      }
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (       while true do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
     if (n = 0) then     return else skip ; 
    var c : Sequence(Sequence(int)) ; c := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     c[i+1][0+1] := sc.getCurrent()->toInteger() ; 
     c[i+1][1+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(int)) ; dp := Integer.subrange(1,n + 1)->collect(Integer.subrange(1,2001)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j <= 1000 do ( (     if (dp[i+1][j+1] /= 0) then (     dp[i + 1+1][j+1] := dp[i + 1+1][j+1]+(dp[i+1][j+1]) ; 
         var k : int ; k := 1 ; while k <= c[i+1][1+1] do ( (     if (j + k * c[i+1][0+1] <= 1000) then     dp[i + 1+1][j + k * c[i+1][0+1]+1] := dp[i + 1+1][j + k * c[i+1][0+1]+1]+(dp[i+1][j+1]) ; else skip )  ;     k := k + 1 ) ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var m : int ; m := sc.getCurrent()->toInteger() ;
        while (m > 0) do (        m := m - 1 ;     skip ; (     OclFile["System.out"].println(dp[n+1][sc.getCurrent()->toInteger()+1]) ) ;  ) ;  
 )  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  BufferedReader br ;
  PrintWriter out ;
  StringTokenizer st ;
  boolean eof ;
  void solve()throws IOException {
    int n=nextInt();
    int m=nextInt();
    int[] cnt=new int[n];
    Arrays.fill(cnt,1);
    boolean[] can=new boolean[n];
    can[0]=true ;
    for(int i=0 ; i<m ; i++){
      int from=nextInt()-1 ;
      int to=nextInt()-1 ;
      if(can[from]){
        can[to]=true ;
        if(cnt[from]==1){
          can[from]=false ;
        }
      }
      cnt[from]--;
      cnt[to]++;
    }
    int ret=0 ;
    for(boolean x : can){
      ret+=x ? 1 : 0 ;
    }
    out.println(ret);
  }
  Main()throws IOException {
    br=new BufferedReader(new InputStreamReader(System.in));
    out=new PrintWriter(System.out);
    solve();
    out.close();
  }
  public static void main(String[] args)throws IOException {
    new Main();
  }
  String nextToken(){
    while(st==null || ! st.hasMoreTokens()){
      try {
        st=new StringTokenizer(br.readLine());
      }
      catch(Exception e){
        eof=true ;
        return null ;
      }
    }
    return st.nextToken();
  }
  String nextString(){
    try {
      return br.readLine();
    }
    catch(IOException e){
      eof=true ;
      return null ;
    }
  }
  int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute br : OclFile;
   attribute out : OclFile;
   attribute st : OclIterator;
   attribute eof : boolean;
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var m : int ; m := nextInt() ;
    var cnt : Sequence(int) ; cnt := Integer.subrange(1,n)->collect(0) ;
    cnt := cnt->collect(1) ; 
    var can : Sequence(boolean) ; can := Integer.subrange(1,n)->collect(false) ;
    can[0+1] := true ; 
        var i : int ; i := 0 ; while i < m do ( (     var from : int ; from := nextInt() - 1 ;
     var to : int ; to := nextInt() - 1 ;
    if (can[from+1]) then (     can[to+1] := true ; 
     if (cnt[from+1] = 1) then (     can[from+1] := false ) else skip ) else skip ; 
    cnt[from+1] := cnt[from+1] - 1 ; 
    cnt[to+1] := cnt[to+1] + 1 ; 
 )  ;     i := i + 1 ) ; 
    var ret : int ; ret := 0 ;
    for (x : can) do ( (     ret := ret+(if x then 1 else 0 endif) )  ) ; 
    skip ; 
 );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
     execute solve() ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : ProgramException) do (     eof := true ; 
     return null )
 ) ; 
     return st.next() );
   operation nextString() : String
  pre: true
  post: true
  activity: (     try (     return br.readLine() )   catch (e : IOException) do (     eof := true ; 
     return null )
 );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Scanner ;
public class Main {
  private static int diceNum ;
  private static int sideNum ;
  private static int cutback ;
  public static void main(String[] args)throws IOException {
    Scanner scanner=new Scanner(System.in);
    while(true){
      diceNum=scanner.nextInt();
      sideNum=scanner.nextInt();
      cutback=scanner.nextInt();
      if(diceNum==0){
        scanner.close();
        break ;
      }
      int dfs=dfs(0,0);
      double ans=dfs/Math.pow(sideNum,diceNum);
      System.out.println(ans);
    }
  }
  static int dfs(int sum,int depth){
    if(depth<diceNum){
      int dfs=0 ;
      for(int i=1 ; i<=sideNum ; i++){
        dfs+=dfs(sum+i,depth+1);
      }
      return dfs ;
    }
    else {
      if(sum-cutback<1){
        return 1 ;
      }
      else {
        return sum-cutback ;
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute diceNum : int;
  static   attribute sideNum : int;
  static   attribute cutback : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     diceNum := scanner.getCurrent()->toInteger() ; 
     sideNum := scanner.getCurrent()->toInteger() ; 
    cutback := scanner.getCurrent()->toInteger() ; 
    if (diceNum = 0) then (     skip ; 
     break ) else skip ; 
    var dfs : int ; dfs := dfs(0, 0) ;
    var ans : double ; ans := dfs / sideNum->pow(diceNum) ;
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation dfs( sum : int, depth : int) : int
  pre: true
  post: true
  activity: (     if (depth < diceNum) then (     var dfs : int ; dfs := 0 ;
         var i : int ; i := 1 ; while i <= sideNum do ( (     dfs := dfs+(dfs(sum + i, depth + 1)) )  ;     i := i + 1 ) ; 
     return dfs ) else (     if (sum - cutback < 1) then (     return 1 ) else (     return sum - cutback ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static final int MAX=10000000 ;
  public static final int[] count=new int[MAX];
  public static void dps(int deep,int n,int cur,int m,int k){
    if(deep==n){
      count[Math.max(1,cur-k)-1]++;
    }
    else {
      for(int i=1 ; i<=m ; i++){
        dps(deep+1,n,cur+i,m,k);
      }
    }
  }
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    while(true){
      final int n=sc.nextInt();
      final int m=sc.nextInt();
      final int k=sc.nextInt();
      if(n==0 && m==0 && k==0){
        break ;
      }
      Arrays.fill(count,0);
      dps(0,n,0,m,k);
      double sum=0 ;
      double pow=Math.pow(m,n);
      for(int i=0 ; i<(n*m-k); i++){
        if(count[i]!=0){
          sum+=(double)(i+1)*count[i]/(pow);
        }
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute MAX : int := 10000000;
  static    attribute count : Sequence(int) := Integer.subrange(1,MAX)->collect(0);
  static   operation dps( deep : int, n : int, cur : int, m : int, k : int) : void
  pre: true
  post: true
  activity: (     if (deep = n) then (     count[Set{1, cur - k}->max() - 1+1] := count[Set{1, cur - k}->max() - 1+1] + 1 ) else (         var i : int ; i := 1 ; while i <= m do ( (     execute dps(deep + 1, n, cur + i, m, k) )  ;     i := i + 1 ) ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var m : int ; m := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    if (n = 0 & m = 0 & k = 0) then (     break ) else skip ; 
    count := count->collect(0) ; 
    execute dps(0, n, 0, m, k) ; 
    var sum : double ; sum := 0 ;
    var pow : double ; pow := m->pow(n) ;
        var i : int ; i := 0 ; while i < (n * m - k) do ( (     if (count[i+1] /= 0) then (     sum := sum+((i + 1)->oclAsType(double) * count[i+1] / (pow)) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int waysToArrange(int N,int K,int[] k){
    int[][] C=new int[N+1][N+1];
    int i,j ;
    for(i=0 ; i<=N ; i++){
      for(j=0 ; j<=i ; j++){
        if(j==0 || j==i){
          C[i][j]=1 ;
        }
        else {
          C[i][j]=(C[i-1][j-1]+C[i-1][j]);
        }
      }
    }
    int[] dp=new int[K+1];
    int count=0 ;
    dp[0]=1 ;
    for(i=0 ; i<K ; i++){
      dp[i+1]=(dp[i]*C[count+k[i]-1][k[i]-1]);
      count+=k[i];
    }
    return dp[K];
  }
  public static void main(String[] args){
    int N=4 ;
    int[] k=new int[] {
      2,2 };
      int K=k.length ;
      System.out.println(waysToArrange(N,K,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation waysToArrange( N : int, K : int, k : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var C : Sequence(Sequence(int)) ; C := Integer.subrange(1,N + 1)->collect(Integer.subrange(1,N + 1)->collect(0)) ;
     var i : int ;
    var j : int ;
        i := 0 ; while i <= N do ( (         j := 0 ; while j <= i do ( (     if (j = 0 or j = i) then (     C[i+1][j+1] := 1 ) else (     C[i+1][j+1] := (C[i - 1+1][j - 1+1] + C[i - 1+1][j+1]) ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var dp : Sequence(int) ; dp := Integer.subrange(1,K + 1)->collect(0) ;
    var count : int ; count := 0 ;
    dp[0+1] := 1 ; 
        i := 0 ; while i < K do ( (     dp[i + 1+1] := (dp[i+1] * C[count + k[i+1] - 1+1][k[i+1] - 1+1]) ; 
     count := count+(k[i+1]) )  ;     i := i + 1 ) ; 
    return dp[K+1] 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 4 ;
     var k : Sequence(int) ; k := Sequence{2,2} ;
     var K : int ; K := k->size() ;
     OclFile["System.out"].println(waysToArrange(N, K, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int power(int n,int r){
    int count=0 ;
    for(int i=r ; (n/i)>=1 ; i=i*r)count+=n/i ;
    return count ;
  }
  public static void main(String[] args){
    int n=6,r=3 ;
    System.out.print(power(n,r));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation power( n : int, r : int) : int
  pre: true
  post: true
  activity: (     var count : int ; count := 0 ;
         var i : int ; i := r ; while (n / i) >= 1 do (     count := count+(n / i) ;  ;     i := i * r ) ; 
     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 6 ;
    var r : int ; r := 3 ;
     OclFile["System.out"].print(power(n, r)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner input=new FastScanner();
    int tc=input.nextInt();
    work : while(tc-->0){
      int n=input.nextInt();
      int k=input.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=input.nextInt();
      }
      int count=0 ;
      for(int i=1 ; i<n-1 ; i++){
        if(a[i]>(a[i-1]+a[i+1])){
          count++;
        }
      }
      if(k==1){
        System.out.println((n-1)/2);
      }
      else {
        System.out.println(count);
      }
    }
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next(){
      while(! st.hasMoreTokens()){
        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()throws IOException {
      return br.readLine();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : FastScanner ; input := FastScanner.newFastScanner() ;
     var tc : int ; tc := input.nextInt() ;
         while (tc > 0) do (        tc := tc - 1 ;     skip ; (     var n : int ; n := input.nextInt() ;
     var k : int ; k := input.nextInt() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := input.nextInt() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 1 ; while i < n - 1 do ( (     if (a[i+1] > (a[i - 1+1] + a[i + 1+1])) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (k = 1) then (     OclFile["System.out"].println((n - 1) / 2) ) else (     OclFile["System.out"].println(count) ) ;  
 ) ;  ) ;  );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     return br.readLine() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static Scanner scanner ;
  public static void main(String[] args){
    scanner=new Scanner(System.in);
    int[] a=new int[200000];
    int T ;
    T=scanner.nextInt();
    int n,k ;
    while(T-->0){
      n=scanner.nextInt();
      k=scanner.nextInt();
      for(int i=0 ; i<n ; i++){
        a[i]=scanner.nextInt();
      }
      int ans=0 ;
      if(k==1)ans=(n-1)/2 ;
      else {
        for(int i=1 ; i<n-1 ; i++){
          if(a[i]>a[i-1]+a[i+1]){
            ans++;
          }
        }
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute scanner : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var a : Sequence(int) ; a := Integer.subrange(1,200000)->collect(0) ;
    var T : int ;
    T := scanner.getCurrent()->toInteger() ; 
    var n : int ;
    var k : int ;
        while (T > 0) do (        T := T - 1 ;     skip ; (     n := scanner.getCurrent()->toInteger() ; 
     k := scanner.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scanner.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
    if (k = 1) then     ans := (n - 1) / 2 else (         var i : int ; i := 1 ; while i < n - 1 do ( (     if (a[i+1] > a[i - 1+1] + a[i + 1+1]) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println(ans) ; 
 ) ;  ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int r=scan.nextInt();
    int c=scan.nextInt();
    int[][] array=new int[r+1][c+1];
    for(int i=0 ; i<r ; i++){
      for(int j=0 ; j<c ; j++){
        array[i][j]=scan.nextInt();
        array[r][j]+=array[i][j];
        array[i][c]+=array[i][j];
      }
      array[r][c]+=array[i][c];
    }
    for(int i=0 ; i<=r ; i++){
      for(int j=0 ; j<c ; j++){
        System.out.print(array[i][j]+" ");
      }
      System.out.println(array[i][c]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := scan.getCurrent()->toInteger() ;
    var c : int ; c := scan.getCurrent()->toInteger() ;
    var array : Sequence(Sequence(int)) ; array := Integer.subrange(1,r + 1)->collect(Integer.subrange(1,c + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < r do ( (         var j : int ; j := 0 ; while j < c do ( (     array[i+1][j+1] := scan.getCurrent()->toInteger() ; 
     array[r+1][j+1] := array[r+1][j+1]+(array[i+1][j+1]) ; 
     array[i+1][c+1] := array[i+1][c+1]+(array[i+1][j+1]) )  ;     j := j + 1 ) ; 
     array[r+1][c+1] := array[r+1][c+1]+(array[i+1][c+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i <= r do ( (         var j : int ; j := 0 ; while j < c do ( (     OclFile["System.out"].print(array[i+1][j+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(array[i+1][c+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
class Main {
  public static void main(String[] args){
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(isr);
    try {
      String[] inputList=br.readLine().split(" ");
      int r=Integer.parseInt(inputList[0]);
      int c=Integer.parseInt(inputList[1]);
      int[][] list=new int[r+1][c+1];
      int i,j,num,sum ;
      for(i=0 ; i<r ; i++){
        sum=0 ;
        String[] hoge=br.readLine().split(" ");
        for(j=0 ; j<c ; j++){
          num=Integer.parseInt(hoge[j]);
          list[i][j]=Integer.parseInt(hoge[j]);
          sum=sum+num ;
        }
        list[i][c]=sum ;
      }
      for(i=0 ; i<c+1 ; i++){
        sum=0 ;
        for(j=0 ; j<r+1 ; j++){
          sum=sum+list[j][i];
        }
        list[r][i]=sum ;
      }
      String output ;
      for(i=0 ; i<r+1 ; i++){
        output="" ;
        for(j=0 ; j<c+1 ; j++){
          output=output+list[i][j]+" " ;
        }
        System.out.println(output.substring(0,output.length()-1));
      }
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var isr : OclFile ; isr := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var br : OclFile ; br := OclFile.newOclFile_Read(isr) ;
     try (     var inputList : Sequence(String) ; inputList := br.readLine()->split(" ") ;
     var r : int ; r := (inputList[0+1])->toInteger() ;
    var c : int ; c := (inputList[1+1])->toInteger() ;
    var list : Sequence(Sequence(int)) ; list := Integer.subrange(1,r + 1)->collect(Integer.subrange(1,c + 1)->collect(0)) ;
    var i : int ;
    var j : int ;
    var num : int ;
    var sum : int ;
        i := 0 ; while i < r do ( (     sum := 0 ; 
     var hoge : Sequence(String) ; hoge := br.readLine()->split(" ") ;
         j := 0 ; while j < c do ( (     num := (hoge[j+1])->toInteger() ; 
     list[i+1][j+1] := (hoge[j+1])->toInteger() ; 
     sum := sum + num )  ;     j := j + 1 ) ; 
     list[i+1][c+1] := sum )  ;     i := i + 1 ) ; 
        i := 0 ; while i < c + 1 do ( (     sum := 0 ; 
         j := 0 ; while j < r + 1 do ( (     sum := sum + list[j+1][i+1] )  ;     j := j + 1 ) ; 
     list[r+1][i+1] := sum )  ;     i := i + 1 ) ; 
    var output : String ;
        i := 0 ; while i < r + 1 do ( (     output := "" ; 
         j := 0 ; while j < c + 1 do ( (     output := output + list[i+1][j+1] + " " )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println(output.subrange(0+1,output->size() - 1)) )  ;     i := i + 1 ) ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Main {
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb1=new StringBuilder();
    StringBuilder sb2=new StringBuilder();
    String b=" ",n="\n" ;
    String[] rc=br.readLine().split(b);
    int r=Integer.parseInt(rc[0]);
    int c=Integer.parseInt(rc[1]);
    int[][] h=new int[r+1][c+1];
    for(int i=0 ; i<r ; i++){
      String[] row=br.readLine().split(b);
      for(int j=0 ; j<c ; j++){
        h[i][j]=Integer.parseInt(row[j]);
        sb1.append(h[i][j]+b);
        h[i][c]+=h[i][j];
        h[r][j]+=h[i][j];
        h[r][c]+=h[i][j];
        if(i==r-1)sb2.append(h[r][j]+b);
      }
      sb1.append(h[i][c]+n);
    }
    sb2.append(h[r][c]);
    System.out.print(sb1);
    System.out.println(sb2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb1 : String ; sb1 := StringLib.newString() ;
    var sb2 : String ; sb2 := StringLib.newString() ;
    var b : String ; b := " " ;
    var n : String ; n := "\n" ;
    var rc : Sequence(String) ; rc := br.readLine()->split(b) ;
    var r : int ; r := (rc[0+1])->toInteger() ;
    var c : int ; c := (rc[1+1])->toInteger() ;
    var h : Sequence(Sequence(int)) ; h := Integer.subrange(1,r + 1)->collect(Integer.subrange(1,c + 1)->collect(0)) ;
        var i : int ; i := 0 ; while i < r do ( (     var row : Sequence(String) ; row := br.readLine()->split(b) ;
         var j : int ; j := 0 ; while j < c do ( (     h[i+1][j+1] := (row[j+1])->toInteger() ; 
     sb1 := sb1 + StringLib.newString(h[i+1][j+1] + b) ; 
    h[i+1][c+1] := h[i+1][c+1]+(h[i+1][j+1]) ; 
    h[r+1][j+1] := h[r+1][j+1]+(h[i+1][j+1]) ; 
    h[r+1][c+1] := h[r+1][c+1]+(h[i+1][j+1]) ; 
    if (i = r - 1) then     sb2 := sb2 + StringLib.newString(h[r+1][j+1] + b) ; else skip ; 
 )  ;     j := j + 1 ) ; 
     sb1 := sb1 + StringLib.newString(h[i+1][c+1] + n) )  ;     i := i + 1 ) ; 
    sb2 := sb2 + StringLib.newString(h[r+1][c+1]) ; 
    OclFile["System.out"].print(sb1) ; 
    OclFile["System.out"].println(sb2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    try(BufferedReader br=new BufferedReader(new InputStreamReader(System.in))){
      new Main().solution(br);
    }
  }
  private void solution(BufferedReader br)throws IOException {
    int base=100000 ;
    int ratio=5 ;
    int term=Integer.parseInt(br.readLine());
    int ans=calc(base,ratio,term);
    System.out.println(ans);
  }
  private int calc(int base,int ratio,int term){
    int result=base ;
    int interest ;
    int fraction ;
    for(int i=1 ; i<=term ; i++){
      interest=result/100*5 ;
      fraction=interest % 1000 ;
      if(fraction!=0){
        interest=interest-fraction+1000 ;
      }
      result+=interest ;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (    var br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
 (     Main.newMain().solution(br) ))  );
   operation solution( br : OclFile) : void
  pre: true
  post: true
  activity: (     var base : int ; base := 100000 ;
     var ratio : int ; ratio := 5 ;
    var term : int ; term := (br.readLine())->toInteger() ;
    var ans : int ; ans := calc(base, ratio, term) ;
    OclFile["System.out"].println(ans) ; 
 );
   operation calc( base : int, ratio : int, term : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := base ;
     var interest : int ;
    var fraction : int ;
        var i : int ; i := 1 ; while i <= term do ( (     interest := result / 100 * 5 ; 
     fraction := interest mod 1000 ; 
     if (fraction /= 0) then (     interest := interest - fraction + 1000 ) else skip ; 
     result := result+(interest) )  ;     i := i + 1 ) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int h=sc.nextInt();
    int w=sc.nextInt();
    ArrayList<Integer>list=new ArrayList<>();
    int max=0 ;
    for(int i=0 ; i<h ; i++){
      char[] arr=sc.next().toCharArray();
      for(int j=0 ; j<w ; j++){
        if(arr[j]=='.'){
          continue ;
        }
        for(int x : list){
          int hh=x/w ;
          int ww=x % w ;
          max=Math.max(max,Math.abs(i-hh)+Math.abs(j-ww));
        }
        list.add(i*w+j);
      }
    }
    System.out.println(max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var h : int ; h := sc.getCurrent()->toInteger() ;
    var w : int ; w := sc.getCurrent()->toInteger() ;
    var list : Sequence(int) ; list := Sequence{} ;
    var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < h do ( (     var arr : Sequence(String) ; arr := sc.getCurrent()->characters() ;
         var j : int ; j := 0 ; while j < w do ( (     if (arr[j+1] = '.') then (     continue ) else skip ; 
     for (x : list) do ( (     var hh : int ; hh := x / w ;
     var ww : int ; ww := x mod w ;
     max := Set{max, if i - hh < 0 then -(i - hh) else i - hh endif + if j - ww < 0 then -(j - ww) else j - ww endif}->max() )  ) ; 
     list := list->including(i * w + j) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int r,c ;
    String str=null ;
    str=scan.nextLine();
    String[] spl=str.split(" ");
    r=Integer.parseInt(spl[0]);
    c=Integer.parseInt(spl[1]);
    String[] input_data=new String[c];
    int[][] input_trans=new int[(r+1)][(c+1)];
    int i=0 ;
    int j=0 ;
    for(i=0 ; i<r ; i++){
      input_trans[i][c]=0 ;
    }
    for(j=0 ; j<c ; j++){
      input_trans[r][j]=0 ;
    }
    for(i=0 ; i<r ; i++){
      str=scan.nextLine();
      input_data=str.split(" ");
      for(j=0 ; j<c ; j++){
        input_trans[i][j]=Integer.parseInt(input_data[j]);
        input_trans[i][c]=input_trans[i][c]+input_trans[i][j];
        input_trans[r][j]=input_trans[r][j]+input_trans[i][j];
        input_trans[r][c]=input_trans[r][c]+input_trans[i][j];
      }
    }
    for(i=0 ; i<(r+1); i++){
      for(j=0 ; j<(c+1); j++){
        if(j==c){
          System.out.println(input_trans[i][j]);
        }
        else {
          System.out.print(input_trans[i][j]+" ");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ;
    var c : int ;
    var str : String ; str := null ;
    str := scan.nextLine() ; 
    var spl : Sequence(String) ; spl := str->split(" ") ;
    r := (spl[0+1])->toInteger() ; 
    c := (spl[1+1])->toInteger() ; 
    var input_data : Sequence(String) ; input_data := Integer.subrange(1,c)->collect(null) ;
    var input_trans : Sequence(Sequence(int)) ; input_trans := Integer.subrange(1,(r + 1))->collect(Integer.subrange(1,(c + 1))->collect(0)) ;
    var i : int ; i := 0 ;
    var j : int ; j := 0 ;
        i := 0 ; while i < r do ( (     input_trans[i+1][c+1] := 0 )  ;     i := i + 1 ) ; 
        j := 0 ; while j < c do ( (     input_trans[r+1][j+1] := 0 )  ;     j := j + 1 ) ; 
        i := 0 ; while i < r do ( (     str := scan.nextLine() ; 
     input_data := str->split(" ") ; 
         j := 0 ; while j < c do ( (     input_trans[i+1][j+1] := (input_data[j+1])->toInteger() ; 
     input_trans[i+1][c+1] := input_trans[i+1][c+1] + input_trans[i+1][j+1] ; 
     input_trans[r+1][j+1] := input_trans[r+1][j+1] + input_trans[i+1][j+1] ; 
     input_trans[r+1][c+1] := input_trans[r+1][c+1] + input_trans[i+1][j+1] )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        i := 0 ; while i < (r + 1) do ( (         j := 0 ; while j < (c + 1) do ( (     if (j = c) then (     OclFile["System.out"].println(input_trans[i+1][j+1]) ) else (     OclFile["System.out"].print(input_trans[i+1][j+1] + " ") ) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import static java.lang.System.*;
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int r=sc.nextInt();
    int c=sc.nextInt();
    int sum,total=0 ;
    int index[][]=new int[r+1][c+1];
    for(int a=0 ; a<r ; a++){
      sum=0 ;
      for(int b=0 ; b<c ; b++){
        int x=sc.nextInt();
        index[a][b]=x ;
        sum+=x ;
        if(b==c-1){
          index[a][c]=sum ;
          sum=0 ;
        }
      }
    }
    sum=0 ;
    for(int a=0 ; a<c ; a++){
      for(int b=0 ; b<r ; b++){
        sum+=index[b][a];
        if(b==r-1){
          index[b+1][a]=sum ;
          total+=sum ;
          sum=0 ;
        }
      }
    }
    index[r][c]=total ;
    for(int a=0 ; a<=r ; a++){
      for(int b=0 ; b<=c ; b++){
        if(b==c){
          out.println(index[a][b]);
        }
        else {
          out.print(index[a][b]+" ");
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var r : int ; r := sc.getCurrent()->toInteger() ;
    var c : int ; c := sc.getCurrent()->toInteger() ;
    var sum : int ;
    var total : int ; total := 0 ;
    var index : Sequence(Sequence(int)) ; index := Integer.subrange(1,r + 1)->collect(Integer.subrange(1,c + 1)->collect(0)) ;
        var a : int ; a := 0 ; while a < r do ( (     sum := 0 ; 
         var b : int ; b := 0 ; while b < c do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     index[a+1][b+1] := x ; 
     sum := sum+(x) ; 
     if (b = c - 1) then (     index[a+1][c+1] := sum ; 
     sum := 0 ) else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    sum := 0 ; 
        var a : int ; a := 0 ; while a < c do ( (         var b : int ; b := 0 ; while b < r do ( (     sum := sum+(index[b+1][a+1]) ; 
     if (b = r - 1) then (     index[b + 1+1][a+1] := sum ; 
     total := total+(sum) ; 
     sum := 0 ) else skip )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
    index[r+1][c+1] := total ; 
        var a : int ; a := 0 ; while a <= r do ( (         var b : int ; b := 0 ; while b <= c do ( (     if (b = c) then (     out.println(index[a+1][b+1]) ) else (     out.print(index[a+1][b+1] + " ") ) )  ;     b := b + 1 ) )  ;     a := a + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int right=2 ;
  static int left=4 ;
  static int[][] dp=new int[left][right];
  static int findSubarraySum(int ind,int flips,int n,int[] a,int k){
    if(flips>k)return(int)(-1e9);
    if(ind==n)return 0 ;
    if(dp[ind][flips]!=-1)return dp[ind][flips];
    int ans=0 ;
    ans=Math.max(0,a[ind]+findSubarraySum(ind+1,flips,n,a,k));
    ans=Math.max(ans,-a[ind]+findSubarraySum(ind+1,flips+1,n,a,k));
    return dp[ind][flips]=ans ;
  }
  static int findMaxSubarraySum(int[] a,int n,int k){
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<k+1 ; j++)dp[i][j]=-1 ;
    int ans=(int)(-1e9);
    for(int i=0 ; i<n ; i++)ans=Math.max(ans,findSubarraySum(i,0,n,a,k));
    return ans ;
  }
  public static void main(String[] args){
    int[] a={
-1,-2,-100,-10 };
      int n=a.length ;
      int k=1 ;
      System.out.println(findMaxSubarraySum(a,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute right : int := 2;
  static   attribute left : int := 4;
  static   attribute dp : Sequence(Sequence(int)) := Integer.subrange(1,left)->collect(Integer.subrange(1,right)->collect(0));
  static   operation findSubarraySum( ind : int, flips : int, n : int, a : Sequence(int), k : int) : int
  pre: true
  post: true
  activity: (     if (flips > k) then     return (-1e9)->oclAsType(int) else skip ; 
     if (ind = n) then     return 0 else skip ; 
    if (dp[ind+1][flips+1] /= -1) then     return dp[ind+1][flips+1] else skip ; 
    var ans : int ; ans := 0 ;
    ans := Set{0, a[ind+1] + findSubarraySum(ind + 1, flips, n, a, k)}->max() ; 
    ans := Set{ans, -a[ind+1] + findSubarraySum(ind + 1, flips + 1, n, a, k)}->max() ; 
    return dp[ind+1][flips+1] 
 );
  static   operation findMaxSubarraySum( a : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < k + 1 do (     dp[i+1][j+1] := -1 ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
     var ans : int ; ans := (-1e9)->oclAsType(int) ;
         var i : int ; i := 0 ; while i < n do (     ans := Set{ans, findSubarraySum(i, 0, n, a, k)}->max() ;  ;     i := i + 1 ) ; 
     return ans );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{-1,-2,-100,-10} ;
     var n : int ; n := a->size() ;
     var k : int ; k := 1 ;
     OclFile["System.out"].println(findMaxSubarraySum(a, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int maximumFixedPoints(int a[],int n){
    int i,count=0,swapped=0 ;
    int pos[]=new int[n];
    for(i=0 ; i<n ; i++)pos[a[i] ]=i ;
    for(i=0 ; i<n ; i++){
      if(a[i]==i)count++;
      else if(swapped==0 && pos[i]==a[i]){
        count+=2 ;
        swapped=1 ;
      }
    }
    if(swapped==0 && count<n-1)count++;
    return count ;
  }
  public static void main(String[] args){
    int[] a={
      0,1,3,4,2 };
      int n=a.length ;
      System.out.println(maximumFixedPoints(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation maximumFixedPoints( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var i : int ;
    var count : int ; count := 0 ;
    var swapped : int ; swapped := 0 ;
     var pos : Sequence(int) ; pos := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do (     pos[a[i+1]+1] := i ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do ( (     if (a[i+1] = i) then     count := count + 1 ; else     if (swapped = 0 & pos[i+1] = a[i+1]) then (     count := count+(2) ; 
     swapped := 1 ) else skip ; )  ;     i := i + 1 ) ; 
    if (swapped = 0 & count < n - 1) then     count := count + 1 ; else skip ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{0,1,3,4,2} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(maximumFixedPoints(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  private static String result(StringBuilder sb,int buy,int c10,int c50,int c100,int c500){
    int total=c10*10+c50*50+c100*100+c500*500 ;
    int rest=total-buy ;
    int x500=rest/500 ;
    int x100=(rest-x500*500)/100 ;
    int x50=(rest-x500*500-x100*100)/50 ;
    int x10=(rest-x500*500-x100*100-x50*50)/10 ;
    if(x10<c10){
      sb.append("10 ");
      sb.append(c10-x10);
      sb.append("\n");
    }
    if(x50<c50){
      sb.append("50 ");
      sb.append(c50-x50);
      sb.append("\n");
    }
    if(x100<c100){
      sb.append("100 ");
      sb.append(c100-x100);
      sb.append("\n");
    }
    if(x500<c500){
      sb.append("500 ");
      sb.append(c500-x500);
      sb.append("\n");
    }
    return sb.toString();
  }
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    while(true){
      String line1=reader.readLine();
      int buy=Integer.parseInt(line1);
      if(buy==0){
        break ;
      }
      if(sb.length()!=0){
        sb.append("\n");
      }
      String[] line2s=reader.readLine().split(" ");
      int counts[]=new int[4];
      for(int i=0 ; i<4 ; i++){
        counts[i]=Integer.parseInt(line2s[i]);
      }
      result(sb,buy,counts[0],counts[1],counts[2],counts[3]);
    }
    System.out.print(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation result( sb : String, buy : int, c10 : int, c50 : int, c100 : int, c500 : int) : String
  pre: true
  post: true
  activity: (     var total : int ; total := c10 * 10 + c50 * 50 + c100 * 100 + c500 * 500 ;
     var rest : int ; rest := total - buy ;
    var x500 : int ; x500 := rest / 500 ;
    var x100 : int ; x100 := (rest - x500 * 500) / 100 ;
    var x50 : int ; x50 := (rest - x500 * 500 - x100 * 100) / 50 ;
    var x10 : int ; x10 := (rest - x500 * 500 - x100 * 100 - x50 * 50) / 10 ;
    if (x10 < c10) then (     sb := sb + StringLib.newString("10 ") ; 
     sb := sb + StringLib.newString(c10 - x10) ; 
     sb := sb + StringLib.newString("\n") ) else skip ; 
    if (x50 < c50) then (     sb := sb + StringLib.newString("50 ") ; 
     sb := sb + StringLib.newString(c50 - x50) ; 
     sb := sb + StringLib.newString("\n") ) else skip ; 
    if (x100 < c100) then (     sb := sb + StringLib.newString("100 ") ; 
     sb := sb + StringLib.newString(c100 - x100) ; 
     sb := sb + StringLib.newString("\n") ) else skip ; 
    if (x500 < c500) then (     sb := sb + StringLib.newString("500 ") ; 
     sb := sb + StringLib.newString(c500 - x500) ; 
     sb := sb + StringLib.newString("\n") ) else skip ; 
    return sb+"" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
     while (true) do (     var line1 : String ; line1 := reader.readLine() ;
     var buy : int ; buy := (line1)->toInteger() ;
    if (buy = 0) then (     break ) else skip ; 
    if (sb->size() /= 0) then (     sb := sb + StringLib.newString("\n") ) else skip ; 
    var line2s : Sequence(String) ; line2s := reader.readLine()->split(" ") ;
    var counts : Sequence(int) ; counts := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     counts[i+1] := (line2s[i+1])->toInteger() )  ;     i := i + 1 ) ; 
    execute result(sb, buy, counts[0+1], counts[1+1], counts[2+1], counts[3+1]) ; 
 ) ; 
     OclFile["System.out"].print(sb+"") );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    new Main().run();
  }
  Scanner kbd=new Scanner(System.in);
  void run(){
    int data=0 ;
    while(kbd.hasNext()){
      int n=kbd.nextInt();
      if(n!=0){
        if(data>0)System.out.println();
        solve(n);
        data++;
      }
    }
  }
  void solve(int n){
    int[] first=new int[4];
    int[] last=new int[4];
    int sum=0 ;
    for(int i=0 ; i<4 ; i++){
      first[i]=kbd.nextInt();
      if(i==0)sum+=first[i]*10 ;
      else if(i==1)sum+=first[i]*50 ;
      else if(i==2)sum+=first[i]*100 ;
      else if(i==3)sum+=first[i]*500 ;
    }
    int change=sum-n ;
    while(change>=500){
      last[3]++;
      change-=500 ;
    }
    while(change>=100){
      last[2]++;
      change-=100 ;
    }
    while(change>=50){
      last[1]++;
      change-=50 ;
    }
    while(change>=10){
      last[0]++;
      change-=10 ;
    }
    int[] ans=new int[4];
    for(int i=0 ; i<4 ; i++){
      ans[i]=first[i]-last[i];
    }
    for(int i=0 ; i<4 ; i++){
      if(ans[i]>0){
        if(i==0)System.out.print("10 ");
        else if(i==1)System.out.print("50 ");
        else if(i==2)System.out.print("100 ");
        else if(i==3)System.out.print("500 ");
        System.out.println(ans[i]);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
   attribute kbd : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var data : int ; data := 0 ;
     while (kbd.hasNext()) do (     var n : int ; n := kbd.getCurrent()->toInteger() ;
     if (n /= 0) then (     if (data > 0) then     OclFile["System.out"].println() ; else skip ; 
     execute solve(n) ; 
     data := data + 1 ) else skip ) );
   operation solve( n : int) : void
  pre: true
  post: true
  activity: (     var first : Sequence(int) ; first := Integer.subrange(1,4)->collect(0) ;
     var last : Sequence(int) ; last := Integer.subrange(1,4)->collect(0) ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < 4 do ( (     first[i+1] := kbd.getCurrent()->toInteger() ; 
     if (i = 0) then     sum := sum+(first[i+1] * 10) ; else     if (i = 1) then     sum := sum+(first[i+1] * 50) else     if (i = 2) then     sum := sum+(first[i+1] * 100) else     if (i = 3) then     sum := sum+(first[i+1] * 500) ; else skip ; ;  ;  )  ;     i := i + 1 ) ; 
    var change : int ; change := sum - n ;
    while (change >= 500) do (     last[3+1] := last[3+1] + 1 ; 
     change := change-(500) ) ; 
    while (change >= 100) do (     last[2+1] := last[2+1] + 1 ; 
     change := change-(100) ) ; 
    while (change >= 50) do (     last[1+1] := last[1+1] + 1 ; 
     change := change-(50) ) ; 
    while (change >= 10) do (     last[0+1] := last[0+1] + 1 ; 
     change := change-(10) ) ; 
    var ans : Sequence(int) ; ans := Integer.subrange(1,4)->collect(0) ;
        var i : int ; i := 0 ; while i < 4 do ( (     ans[i+1] := first[i+1] - last[i+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 4 do ( (     if (ans[i+1] > 0) then (     if (i = 0) then     OclFile["System.out"].print("10 ") else     if (i = 1) then     OclFile["System.out"].print("50 ") else     if (i = 2) then     OclFile["System.out"].print("100 ") else     if (i = 3) then     OclFile["System.out"].print("500 ") ; else skip ; ;  ;  ;  
     OclFile["System.out"].println(ans[i+1]) ) else skip )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    solve();
  }
  private static void solve(){
    Scanner scn=new Scanner(System.in);
    PrintWriter pr=new PrintWriter(System.out);
    int cnt=0 ;
    while(true){
      int S=scn.nextInt();
      if(S==0)break ;
      if(cnt!=0)pr.println();
      cnt++;
      int[] c=new int[4];
      for(int k=0 ; k<4 ; k++){
        c[k]=scn.nextInt();
      }
      int M=c[3]*500+c[2]*100+c[1]*50+c[0]*10 ;
      S=M-S ;
      if(S/500>0){
        c[3]-=S/500 ;
        S=S % 500 ;
      }
      if(S/100>0){
        c[2]-=S/100 ;
        S=S % 100 ;
      }
      if(S/50>0){
        c[1]-=S/50 ;
        S=S % 50 ;
      }
      if(S/10>0){
        c[0]-=S/10 ;
        S=S % 10 ;
      }
      if(c[0]>0){
        pr.println(10+" "+c[0]);
      }
      if(c[1]>0){
        pr.println(50+" "+c[1]);
      }
      if(c[2]>0){
        pr.println(100+" "+c[2]);
      }
      if(c[3]>0){
        pr.println(500+" "+c[3]);
      }
    }
    pr.flush();
    scn.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve() );
  static   operation solve() : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pr : OclFile ; pr := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var cnt : int ; cnt := 0 ;
    while (true) do (     var S : int ; S := scn.getCurrent()->toInteger() ;
     if (S = 0) then     break else skip ; 
    if (cnt /= 0) then     skip ; else skip ; 
    cnt := cnt + 1 ; 
    var c : Sequence(int) ; c := Integer.subrange(1,4)->collect(0) ;
        var k : int ; k := 0 ; while k < 4 do ( (     c[k+1] := scn.getCurrent()->toInteger() )  ;     k := k + 1 ) ; 
    var M : int ; M := c[3+1] * 500 + c[2+1] * 100 + c[1+1] * 50 + c[0+1] * 10 ;
    S := M - S ; 
    if (S / 500 > 0) then (     c[3+1] := c[3+1]-(S / 500) ; 
     S := S mod 500 ) else skip ; 
    if (S / 100 > 0) then (     c[2+1] := c[2+1]-(S / 100) ; 
     S := S mod 100 ) else skip ; 
    if (S / 50 > 0) then (     c[1+1] := c[1+1]-(S / 50) ; 
     S := S mod 50 ) else skip ; 
    if (S / 10 > 0) then (     c[0+1] := c[0+1]-(S / 10) ; 
     S := S mod 10 ) else skip ; 
    if (c[0+1] > 0) then (     skip ) else skip ; 
    if (c[1+1] > 0) then (     skip ) else skip ; 
    if (c[2+1] > 0) then (     skip ) else skip ; 
    if (c[3+1] > 0) then (     skip ) else skip ; 
 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    System.out.println(a*b-a-b+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println(a * b - a - b + 1) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int H=sc.nextInt();
    int W=sc.nextInt();
    int[] left=new int[H];
    int[] right=new int[H];
    Arrays.fill(left,-1);
    Arrays.fill(right,-1);
    for(int i=0 ; i<H ; i++){
      char[] row=sc.next().toCharArray();
      for(int j=0 ; j<W ; j++){
        if(row[j]=='B'){
          if(left[i]==-1)left[i]=j ;
          right[i]=j ;
        }
      }
    }
    int ans=0 ;
    for(int i=0 ; i<H ; i++){
      if(left[i]==-1)continue ;
      for(int j=i ; j<H ; j++){
        if(left[j]==-1)continue ;
        ans=Math.max(ans,j-i+Math.abs(left[i]-right[j]));
        ans=Math.max(ans,j-i+Math.abs(right[i]-left[j]));
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var H : int ; H := sc.getCurrent()->toInteger() ;
     var W : int ; W := sc.getCurrent()->toInteger() ;
    var left : Sequence(int) ; left := Integer.subrange(1,H)->collect(0) ;
    var right : Sequence(int) ; right := Integer.subrange(1,H)->collect(0) ;
    left := left->collect(-1) ; 
    right := right->collect(-1) ; 
        var i : int ; i := 0 ; while i < H do ( (     var row : Sequence(String) ; row := sc.getCurrent()->characters() ;
         var j : int ; j := 0 ; while j < W do ( (     if (row[j+1] = 'B') then (     if (left[i+1] = -1) then     left[i+1] := j ; else skip ; 
     right[i+1] := j ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < H do ( (     if (left[i+1] = -1) then     continue else skip ; 
         var j : int ; j := i ; while j < H do ( (     if (left[j+1] = -1) then     continue else skip ; 
     ans := Set{ans, j - i + if left[i+1] - right[j+1] < 0 then -(left[i+1] - right[j+1]) else left[i+1] - right[j+1] endif}->max() ; 
     ans := Set{ans, j - i + if right[i+1] - left[j+1] < 0 then -(right[i+1] - left[j+1]) else right[i+1] - left[j+1] endif}->max() )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] sums=new int[100001];
    for(int i=2 ; i<sums.length ; i++){
      sums[i]=sums[i-1];
      int count=0 ;
      for(int j=2 ; j<=Math.sqrt(i)&& count<2 ; j++){
        if(i % j==0){
          count++;
        }
      }
      if(count>=2){
        sums[i]++;
      }
    }
    int q=sc.nextInt();
    StringBuilder sb=new StringBuilder();
    for(int i=0 ; i<q ; i++){
      sb.append(sums[sc.nextInt()]).append("\n");
    }
    System.out.print(sb);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var sums : Sequence(int) ; sums := Integer.subrange(1,100001)->collect(0) ;
        var i : int ; i := 2 ; while i < sums->size() do ( (     sums[i+1] := sums[i - 1+1] ; 
     var count : int ; count := 0 ;
         var j : int ; j := 2 ; while j <= (i)->sqrt() & count < 2 do ( (     if (i mod j = 0) then (     count := count + 1 ) else skip )  ;     j := j + 1 ) ; 
     if (count >= 2) then (     sums[i+1] := sums[i+1] + 1 ) else skip )  ;     i := i + 1 ) ; 
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 0 ; while i < q do ( (     sb := sb + StringLib.newString(sums[sc.getCurrent()->toInteger()+1]) + StringLib.newString("\n") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.lang.reflect.Array ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    InputReader in=new InputReader(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    Task solver=new Task();
    solver.solve(1,in,out);
    out.close();
  }
  static class Task {
    public void solve(int testNumber,InputReader in,PrintWriter out){
      int A=in.nextInt();
      int B=in.nextInt();
      out.println(A*B-(A+B-1));
    }
  }
  static class InputReader {
    public BufferedReader reader ;
    public StringTokenizer tokenizer ;
    public InputReader(InputStream stream){
      reader=new BufferedReader(new InputStreamReader(stream),32768);
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : InputReader ; in := InputReader.newInputReader(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : Task ; solver := Task.newTask() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class Task {
   operation solve( testNumber : int, in : InputReader, out : OclFile) : void
  pre: true
  post: true
  activity: (     var A : int ; A := in.nextInt() ;
     var B : int ; B := in.nextInt() ;
     skip );
}
  static class InputReader {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newInputReader( stream : OclFile) : InputReader
  pre: true
  post: true
  activity:
  ( var self : InputReader ;
    self := createInputReader();
    self.initialise(stream);
    return self );
  operation initialise( stream : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream), 32768) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    new Main().solveA();
  }
  private void solveA(){
    Scanner scanner=null ;
    int numA=0 ;
    int numB=0 ;
    try {
      scanner=new Scanner(System.in);
      numA=scanner.nextInt();
      numB=scanner.nextInt();
      System.out.println((numA-1)*(numB-1));
      System.out.println("");
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
  private void solveB(){
    Scanner scanner=null ;
    int numN=0 ;
    int numK=0 ;
    int numS=0 ;
    try {
      scanner=new Scanner(System.in);
      numN=scanner.nextInt();
      System.out.println("");
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
  private void solveC(){
    Scanner scanner=null ;
    int numN=0 ;
    int numK=0 ;
    int numS=0 ;
    try {
      scanner=new Scanner(System.in);
      numN=scanner.nextInt();
      System.out.println("");
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
  private void solveD(){
    Scanner scanner=null ;
    int numN=0 ;
    int numK=0 ;
    int numS=0 ;
    try {
      scanner=new Scanner(System.in);
      numN=scanner.nextInt();
      System.out.println("");
    }
    finally {
      if(scanner!=null){
        scanner.close();
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solveA() );
   operation solveA() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var numA : int ; numA := 0 ;
     var numB : int ; numB := 0 ;
     try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     numA := scanner.getCurrent()->toInteger() ; 
    numB := scanner.getCurrent()->toInteger() ; 
    OclFile["System.out"].println((numA - 1) * (numB - 1)) ; 
    OclFile["System.out"].println("") ; 
 )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
   operation solveB() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var numN : int ; numN := 0 ;
    var numK : int ; numK := 0 ;
    var numS : int ; numS := 0 ;
    try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     numN := scanner.getCurrent()->toInteger() ; 
     OclFile["System.out"].println("") )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
   operation solveC() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var numN : int ; numN := 0 ;
    var numK : int ; numK := 0 ;
    var numS : int ; numS := 0 ;
    try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     numN := scanner.getCurrent()->toInteger() ; 
     OclFile["System.out"].println("") )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
   operation solveD() : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := null ;
     var numN : int ; numN := 0 ;
    var numK : int ; numK := 0 ;
    var numS : int ; numS := 0 ;
    try (     scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     numN := scanner.getCurrent()->toInteger() ; 
     OclFile["System.out"].println("") )   finally (     if (scanner /= null) then (     skip ) else skip )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int A=sc.nextInt();
    int B=sc.nextInt();
    System.out.println((A-1)*(B-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := sc.getCurrent()->toInteger() ;
     var B : int ; B := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].println((A - 1) * (B - 1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner stdIn=new Scanner(System.in);
    int A=stdIn.nextInt();
    int B=stdIn.nextInt();
    System.out.println((A*B)-(A+B-1));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stdIn : OclFile ; stdIn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : int ; A := stdIn.getCurrent()->toInteger() ;
     var B : int ; B := stdIn.getCurrent()->toInteger() ;
     OclFile["System.out"].println((A * B) - (A + B - 1)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.ArrayList ;
import java.util.List ;
public class Replace {
  public static void main(String[] args)throws IOException {
    BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
    int t=Integer.valueOf(bf.readLine());
    for(int i=0 ; i<t ; i++){
      String[] arr=bf.readLine().split(" ");
      int k=Integer.valueOf(arr[1]);
      char[] chars=bf.readLine().toCharArray();
      List<Integer>list=new ArrayList<>();
      for(int j=0 ; j<chars.length ; j++){
        if(chars[j]=='*'){
          list.add(j);
        }
      }
      if(list.size()==1 || list.size()==2){
        System.out.println(list.size());
        continue ;
      }
      boolean flag=false ;
      int count=0 ;
      int tmp=0 ;
      for(int j=0 ; j<list.size()-1 ; j=tmp){
        if(flag){
          break ;
        }
        count++;
        for(int c=j+1 ; c<list.size(); c++){
          if(c>=list.size()){
            flag=true ;
            break ;
          }
          if(list.get(c)-list.get(j)<=k){
            tmp=c ;
          }
          else {
            break ;
          }
        }
      }
      if(tmp==list.size()-1){
        System.out.println(count+1);
      }
      else {
        System.out.println(count);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Replace {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ; bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var t : int ; t := (bf.readLine())->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var arr : Sequence(String) ; arr := bf.readLine()->split(" ") ;
     var k : int ; k := (arr[1+1])->toInteger() ;
    var chars : Sequence(String) ; chars := bf.readLine()->characters() ;
    var list : Sequence(int) ; list := Sequence{} ;
        var j : int ; j := 0 ; while j < chars->size() do ( (     if (chars[j+1] = '*') then (     list := list->including(j) ) else skip )  ;     j := j + 1 ) ; 
    if (list->size() = 1 or list->size() = 2) then (     OclFile["System.out"].println(list->size()) ; 
     continue ) else skip ; 
    var flag : boolean ; flag := false ;
    var count : int ; count := 0 ;
    var tmp : int ; tmp := 0 ;
        var j : int ; j := 0 ; while j < list->size() - 1 do ( (     if (flag) then (     break ) else skip ; 
     count := count + 1 ; 
         var c : int ; c := j + 1 ; while c < list->size() do ( (     if (c >= list->size()) then (     flag := true ; 
     break ) else skip ; 
     if (list->at(c+1) - list->at(j+1) <= k) then (     tmp := c ) else (     break ) )  ;     c := c + 1 ) )  ;     j := tmp ) ; 
    if (tmp = list->size() - 1) then (     OclFile["System.out"].println(count + 1) ) else (     OclFile["System.out"].println(count) ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class D {
  public static void main(String[] args){
    Scanner sca=new Scanner(System.in);
    int t=sca.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sca.nextInt();
      int k=sca.nextInt();
      sca.nextLine();
      String s=sca.nextLine();
      System.out.println(getResult(n,k,s));
    }
  }
  private static int getResult(int n,int k,String s){
    List<Integer>list=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      char c=s.charAt(i);
      if(c=='*'){
        list.add(i);
      }
    }
    if(list.size()==1){
      return 1 ;
    }
    if(list.size()==2){
      return 2 ;
    }
    int q=0 ;
    int step=0 ;
    for(int i=0 ; i<list.size(); i++){
      for(int j=i ; j<list.size(); j++){
        if(list.get(j)-list.get(i)>k){
          q++;
          step--;
          break ;
        }
        step++;
      }
      i=step-1 ;
    }
    return q+2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sca : OclFile ; sca := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sca.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sca.getCurrent()->toInteger() ;
     var k : int ; k := sca.getCurrent()->toInteger() ;
    skip ; 
    var s : String ; s := sca.nextLine() ;
    OclFile["System.out"].println(getResult(n, k, s)) ; 
 )  ;     i := i + 1 ) );
  static   operation getResult( n : int, k : int, s : String) : int
  pre: true
  post: true
  activity: (     var list : Sequence(int) ; list := Sequence{} ;
         var i : int ; i := 0 ; while i < n do ( (     var c : String ; c := s->at(i+1) ;
     if (c = '*') then (     list := list->including(i) ) else skip )  ;     i := i + 1 ) ; 
    if (list->size() = 1) then (     return 1 ) else skip ; 
    if (list->size() = 2) then (     return 2 ) else skip ; 
    var q : int ; q := 0 ;
    var step : int ; step := 0 ;
        var i : int ; i := 0 ; while i < list->size() do ( (         var j : int ; j := i ; while j < list->size() do ( (     if (list->at(j+1) - list->at(i+1) > k) then (     q := q + 1 ; 
     step := step - 1 ; 
     break ) else skip ; 
     step := step + 1 )  ;     j := j + 1 ) ; 
     i := step - 1 )  ;     i := i + 1 ) ; 
    return q + 2 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class D {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int testCases=in.nextInt();
    for(int testCase=0 ; testCase<testCases ; testCase++){
      int n=in.nextInt();
      int k=in.nextInt();
      char[] s=in.next().toCharArray();
      int sum=1 ;
      for(int i=0 ; i<n ; i++){
        if(s[i]=='*'){
          s[i]='x' ;
          int farestStarIndex=i ;
          for(int j=1 ; j<=k ; j++){
            int curIndex=i+j ;
            if(curIndex<n && s[curIndex]=='*'){
              farestStarIndex=curIndex ;
            }
          }
          if(farestStarIndex>i){
++sum ;
            i=farestStarIndex-1 ;
          }
          else {
            break ;
          }
        }
      }
      System.out.println(sum);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class D {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var testCases : int ; testCases := in.getCurrent()->toInteger() ;
         var testCase : int ; testCase := 0 ; while testCase < testCases do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var k : int ; k := in.getCurrent()->toInteger() ;
    var s : Sequence(String) ; s := in.getCurrent()->characters() ;
    var sum : int ; sum := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     if (s[i+1] = '*') then (     s[i+1] := 'x' ; 
     var farestStarIndex : int ; farestStarIndex := i ;
         var j : int ; j := 1 ; while j <= k do ( (     var curIndex : int ; curIndex := i + j ;
     if (curIndex < n & s[curIndex+1] = '*') then (     farestStarIndex := curIndex ) else skip )  ;     j := j + 1 ) ; 
     if (farestStarIndex > i) then (     sum := sum + 1 ; 
     i := farestStarIndex - 1 ) else (     break ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 )  ;     testCase := testCase + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int t=scanner.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=scanner.nextInt();
      int k=scanner.nextInt();
      String s=scanner.next();
      int count=2 ;
      int start=s.indexOf("*");
      int end=s.lastIndexOf("*");
      if(start==end){
        System.out.println(1);
      }
      else {
        while(start+k<end){
          for(int j=start+k ; j>start ; j--){
            if(s.charAt(j)=='*'){
              start=j ;
              count++;
            }
          }
        }
        System.out.println(count);
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := scanner.getCurrent()->toInteger() ;
     var k : int ; k := scanner.getCurrent()->toInteger() ;
    var s : String ; s := scanner.getCurrent() ;
    var count : int ; count := 2 ;
    var start : int ; start := s->indexOf("*")-1 ;
    var end : int ; end := s->lastIndexOf("*")-1 ;
    if (start = end) then (     OclFile["System.out"].println(1) ) else (     while (start + k < end) do (         var j : int ; j := start + k ; while j > start do ( (     if (s->at(j+1) = '*') then (     start := j ; 
     count := count + 1 ) else skip )  ;     j := j - 1 ) ) ; 
     OclFile["System.out"].println(count) ) ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static double Convert(double radian){
    double pi=3.14159 ;
    return(radian*(180/pi));
  }
  public static void main(String[] args){
    double radian=5.0 ;
    double degree=Convert(radian);
    System.out.println("degree="+degree);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Convert( radian : double) : double
  pre: true
  post: true
  activity: (     var pi : double ; pi := 3.14159 ;
     return (radian * (180 / pi)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var radian : double ; radian := 5.0 ;
     var degree : double ; degree := Convert(radian) ;
     OclFile["System.out"].println("degree=" + degree) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void minReplacement(String str){
    if(str.length()>26){
      System.out.println("IMPOSSIBLE");
    }
    else {
      int hash[]=new int[26];
      for(int i=0 ; i<str.length(); i++){
        hash[str.charAt(i)-'a']++;
      }
      int count=0 ;
      for(int i=0 ; i<str.length(); i++){
        if(hash[str.charAt(i)-'a']>1){
          for(int j=0 ; j<26 ; j++){
            if(hash[j]==0){
              hash[str.charAt(i)-'a']--;
              str=str.substring(0,i)+(char)(j+'a')+str.substring(i+1);
              hash[j]++;
              break ;
            }
          }
        }
      }
      System.out.println(str);
    }
  }
  public static void main(String[] args){
    String str="xxxxyyyy" ;
    minReplacement(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation minReplacement( str : String) : void
  pre: true
  post: true
  activity: (     if (str->size() > 26) then (     OclFile["System.out"].println("IMPOSSIBLE") ) else (     var hash : Sequence(int) ; hash := Integer.subrange(1,26)->collect(0) ;
         var i : int ; i := 0 ; while i < str->size() do ( (     hash[str->at(i+1) - ('a')->char2byte()+1] := hash[str->at(i+1) - ('a')->char2byte()+1] + 1 )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < str->size() do ( (     if (hash[str->at(i+1) - ('a')->char2byte()+1] > 1) then (         var j : int ; j := 0 ; while j < 26 do ( (     if (hash[j+1] = 0) then (     hash[str->at(i+1) - ('a')->char2byte()+1] := hash[str->at(i+1) - ('a')->char2byte()+1] - 1 ; 
     str := str.subrange(0+1,i) + (j + 'a')->oclAsType(String) + str.subrange(i + 1+1,i + 1) ; 
     hash[j+1] := hash[j+1] + 1 ; 
     break ) else skip )  ;     j := j + 1 ) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(str) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "xxxxyyyy" ;
     execute minReplacement(str) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPower(int x,int y){
    int res1=(int)Math.log(y)/(int)Math.log(x);
    double res2=Math.log(y)/Math.log(x);
    return(res1==res2);
  }
  public static void main(String args[]){
    if(isPower(27,729))System.out.println("1");
    else System.out.println("0");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPower( x : int, y : int) : boolean
  pre: true
  post: true
  activity: (     var res1 : int ; res1 := (y)->log()->oclAsType(int) / (x)->log()->oclAsType(int) ;
     var res2 : double ; res2 := (y)->log() / (x)->log() ;
     return (res1 = res2) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     if (isPower(27, 729)) then     OclFile["System.out"].println("1") ; else     OclFile["System.out"].println("0") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int[] acc=new int[100001];
    for(int i=2 ; i<acc.length ; i++){
      long j=2 ;
      long mul=1 ;
      while(j*j<i){
        if(i % j==0){
          mul*=i ;
          if(mul>=2*i)break ;
        }
        j++;
      }
      if(j*j==i){
        mul*=j ;
      }
      if(mul>=2*i)acc[i]=1 ;
      acc[i]+=acc[i-1];
    }
    int Q=sc.nextInt();
    PrintWriter writer=new PrintWriter(System.out);
    for(int i=0 ; i<Q ; i++){
      int N=Integer.parseInt(sc.next());
      writer.println(acc[N]);
    }
    writer.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var acc : Sequence(int) ; acc := Integer.subrange(1,100001)->collect(0) ;
         var i : int ; i := 2 ; while i < acc->size() do ( (     var j : long ; j := 2 ;
     var mul : long ; mul := 1 ;
    while (j * j < i) do (     if (i mod j = 0) then (     mul := mul*(i) ; 
     if (mul >= 2 * i) then     break else skip ) else skip ; 
     j := j + 1 ) ; 
    if (j * j = i) then (     mul := mul*(j) ) else skip ; 
    if (mul >= 2 * i) then     acc[i+1] := 1 ; else skip ; 
    acc[i+1] := acc[i+1]+(acc[i - 1+1]) ; 
 )  ;     i := i + 1 ) ; 
    var Q : int ; Q := sc.getCurrent()->toInteger() ;
    var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile["System.out"]) ;
        var i : int ; i := 0 ; while i < Q do ( (     var N : int ; N := (sc.getCurrent())->toInteger() ;
     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Application {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    long m=scan.nextLong();
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      String word=scan.next();
      int a=scan.nextInt();
      if(word.contains("+"))m+=a ;
      else if(word.contains("-")&& m-a<0){
        sum++;
      }
      else {
        m-=a ;
      }
    }
    System.out.println(m);
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Application {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var m : long ; m := scan.getCurrent()->toLong() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var word : String ; word := scan.getCurrent() ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
     if (word->includes("+")) then     m := m+(a) ; else     if (word->includes("-") & m - (a)->char2byte() < 0) then (     sum := sum + 1 ) else (     m := m-(a) ) ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(m) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long x=sc.nextInt();
    int dis_kids=0 ;
    for(int i=0 ; i<n ; i++){
      char sign=sc.next().charAt(0);
      int number=sc.nextInt();
      if(sign=='+'){
        x+=number ;
      }
      else {
        if(x<number){
          dis_kids++;
        }
        else {
          x-=number ;
        }
      }
    }
    System.out.println(x+" "+dis_kids);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var x : long ; x := sc.getCurrent()->toInteger() ;
    var dis_kids : int ; dis_kids := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var sign : String ; sign := sc.getCurrent()->at(0+1) ;
     var number : int ; number := sc.getCurrent()->toInteger() ;
     if (sign = '+') then (     x := x+(number) ) else (     if (x < number) then (     dis_kids := dis_kids + 1 ) else (     x := x-(number) ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(x + " " + dis_kids) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test202 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    long x=in.nextLong();
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      char c=in.next().charAt(0);
      long a=in.nextLong();
      if(c=='+'){
        x+=a ;
      }
      else {
        if(x>=a){
          x-=a ;
        }
        else {
          sum++;
        }
      }
    }
    System.out.println(x+" "+sum);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test202 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var x : long ; x := in.getCurrent()->toLong() ;
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var c : String ; c := in.getCurrent()->at(0+1) ;
     var a : long ; a := in.getCurrent()->toLong() ;
     if (c = '+') then (     x := x+(a) ) else (     if (x >= a) then (     x := x-(a) ) else (     sum := sum + 1 ) ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(x + " " + sum) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.function.IntPredicate ;
import org.omg.CORBA.Current ;
import static java.lang.Math.abs ;
public class omar {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int kids=input.nextInt();
    long sum=input.nextLong();
    int count=0 ;
    while(kids-->0){
      String s=input.next();
      long a=input.nextLong();
      if(s.equals("+")){
        sum+=a ;
      }
      else if(s.equals("-")){
        if(a>sum){
++count ;
        }
        else {
          sum-=a ;
        }
      }
    }
    System.out.println(sum+" "+count);
  }
}
------------------------------------------------------------
OCL File:
---------
 class omar {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var kids : int ; kids := input.getCurrent()->toInteger() ;
    var sum : long ; sum := input.getCurrent()->toLong() ;
    var count : int ; count := 0 ;
        while (kids > 0) do (        kids := kids - 1 ;     skip ; (     var s : String ; s := input.getCurrent() ;
     var a : long ; a := input.getCurrent()->toLong() ;
     if (s = "+") then (     sum := sum+(a) ) else     if (s = "-") then (     if (a > sum) then (     count := count + 1 ) else (     sum := sum-(a) ) ) else skip ; ) ;  ) ;  
    OclFile["System.out"].println(sum + " " + count) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  public Main(){
    String in=sc.nextLine();
    int n=Integer.parseInt(in.split(" ")[0]);
    long x=Long.parseLong(in.split(" ")[1]);
    long kids=0 ;
    for(int i=0 ; i<n ; i++){
      String in2=sc.nextLine();
      String op=in2.split(" ")[0];
      long qty=Long.parseLong(in2.split(" ")[1]);
      if(op.equals("+")){
        x+=qty ;
      }
      else if(op.equals("-")&& x>=qty){
        x-=qty ;
      }
      else if(op.equals("-")&& x<qty){
        kids++;
      }
    }
    System.out.println(x+" "+kids);
  }
  public static void main(String[] args){
    new Main();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var in : String ; in := sc.nextLine() ;
     var n : int ; n := (in->split(" ")[0+1])->toInteger() ;
    var x : long ; x := (in->split(" ")[1+1])->toLong() ;
    var kids : long ; kids := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var in2 : String ; in2 := sc.nextLine() ;
     var op : String ; op := in2->split(" ")[0+1] ;
     var qty : long ; qty := (in2->split(" ")[1+1])->toLong() ;
     if (op = "+") then (     x := x+(qty) ) else     if (op = "-" & x >= qty) then (     x := x-(qty) ) else     if (op = "-" & x < qty) then (     kids := kids + 1 ) else skip ; ;  )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(x + " " + kids) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.*;
import java.awt.geom.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[][] f=new int[n][5];
    double AM=-1 ;
    double BM=-1 ;
    double A=-1 ;
    double B=-1 ;
    for(int i=0 ; i<n ; i++)for(int j=0 ; j<5 ; j++)f[i][j]=sc.nextInt();
    for(int i=1 ; i<n ; i++){
      if(f[i-1][2]!=f[i][2] || f[i-1][1]==f[i][1])continue ;
      double d=Math.sqrt(Math.pow(f[i][3]-f[i-1][3],2)+Math.pow(f[i][4]-f[i-1][4],2));
      double time=f[i][0]-f[i-1][0];
      if(f[i][2]==0){
        if(d>AM ||(d==AM && time<A)){
          AM=d ;
          A=time ;
        }
      }
      else {
        if(d>BM ||(d==BM && time<B)){
          BM=d ;
          B=time ;
        }
      }
    }
    if(AM==-1)System.out.println(-1+" "+-1);
    else System.out.printf("%.9f %.9f\n",AM,A/60.0);
    if(BM==-1)System.out.println(-1+" "+-1);
    else System.out.printf("%.9f %.9f\n",BM,B/60.0);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var f : Sequence(Sequence(int)) ; f := Integer.subrange(1,n)->collect(Integer.subrange(1,5)->collect(0)) ;
    var AM : double ; AM := -1 ;
    var BM : double ; BM := -1 ;
    var A : double ; A := -1 ;
    var B : double ; B := -1 ;
        var i : int ; i := 0 ; while i < n do (         var j : int ; j := 0 ; while j < 5 do (     f[i+1][j+1] := sc.getCurrent()->toInteger() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i < n do ( (     if (f[i - 1+1][2+1] /= f[i+1][2+1] or f[i - 1+1][1+1] = f[i+1][1+1]) then     continue else skip ; 
     var d : double ; d := (f[i+1][3+1] - f[i - 1+1][3+1]->pow(2) + f[i+1][4+1] - f[i - 1+1][4+1]->pow(2))->sqrt() ;
     var time : double ; time := f[i+1][0+1] - f[i - 1+1][0+1] ;
     if (f[i+1][2+1] = 0) then (     if (d > AM or (d = AM & time < A)) then (     AM := d ; 
     A := time ) else skip ) else (     if (d > BM or (d = BM & time < B)) then (     BM := d ; 
     B := time ) else skip ) )  ;     i := i + 1 ) ; 
    if (AM = -1) then     OclFile["System.out"].println(-1 + " " + -1) else     OclFile["System.out"].printf("%.9f %.9f\n", AM, A / 60.0) ; ;  
    if (BM = -1) then     OclFile["System.out"].println(-1 + " " + -1) else     OclFile["System.out"].printf("%.9f %.9f\n", BM, B / 60.0) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void encode(String s,int k){
    String newS="" ;
    for(int i=0 ; i<s.length(); ++i){
      int val=s.charAt(i);
      int dup=k ;
      if(val+k>122){
        k-=(122-val);
        k=k % 26 ;
        newS+=(char)(96+k);
      }
      else {
        newS+=(char)(val+k);
      }
      k=dup ;
    }
    System.out.println(newS);
  }
  public static void main(String[] args){
    String str="abc" ;
    int k=28 ;
    encode(str,k);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation encode( s : String, k : int) : void
  pre: true
  post: true
  activity: (     var newS : String ; newS := "" ;
         var i : int ; i := 0 ; while i < s->size() do ( (     var val : int ; val := s->at(i+1) ;
     var dup : int ; dup := k ;
     if (val + k > 122) then (     k := k-((122 - val)) ; 
     k := k mod 26 ; 
     newS := newS+((96 + k)->oclAsType(String)) ) else (     newS := newS+((val + k)->oclAsType(String)) ) ;  
     k := dup )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(newS) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := "abc" ;
     var k : int ; k := 28 ;
     execute encode(str, k) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isPossible(int x,int y,int k){
    int minMoves=Math.abs(x)+Math.abs(y);
    if(k>=minMoves &&(k-minMoves)% 2==0)return true ;
    return false ;
  }
  public static void main(String[] args){
    int x=5,y=8,k=20 ;
    if(isPossible(x,y,k))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isPossible( x : int, y : int, k : int) : boolean
  pre: true
  post: true
  activity: (     var minMoves : int ; minMoves := if x < 0 then -(x) else x endif + if y < 0 then -(y) else y endif ;
     if (k >= minMoves & (k - minMoves) mod 2 = 0) then     return true else skip ; 
     return false );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x : int ; x := 5 ;
    var y : int ; y := 8 ;
    var k : int ; k := 20 ;
     if (isPossible(x, y, k)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static int longestSubseq(String s){
    int n=s.length();
    int[] pre_count_0=new int[n+2];
    int[] pre_count_1=new int[n+1];
    int[] post_count_0=new int[n+2];
    pre_count_0[0]=0 ;
    post_count_0[n+1]=0 ;
    pre_count_1[0]=0 ;
    for(int j=1 ; j<=n ; j++){
      pre_count_0[j]=pre_count_0[j-1];
      pre_count_1[j]=pre_count_1[j-1];
      post_count_0[n-j+1]=post_count_0[n-j+2];
      if(s.charAt(j-1)=='0')pre_count_0[j]++;
      else pre_count_1[j]++;
      if(s.charAt(n-j)=='0')post_count_0[n-j+1]++;
    }
    if(pre_count_0[n]==n || pre_count_0[n]==0)return n ;
    int ans=0 ;
    for(int i=1 ; i<=n ; i++)for(int j=i ; j<=n ; j++)ans=Math.max(pre_count_0[i-1]+pre_count_1[j]-pre_count_1[i-1]+post_count_0[j+1],ans);
    return ans ;
  }
  public static void main(String[] args){
    String s="000011100000" ;
    System.out.println(longestSubseq(s));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation longestSubseq( s : String) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     var pre_count_0 : Sequence(int) ; pre_count_0 := Integer.subrange(1,n + 2)->collect(0) ;
    var pre_count    var pre_countSequence(int) : Sequence(int) ; pre_countSequence(int) := Integer.subrange(1,n + 1)->collect(0) : Sequence(int) ; pre_count    var pre_countSequence(int) : Sequence(int) ; pre_countSequence(int) := Integer.subrange(1,n + 1)->collect(0) := Integer.subrange(1,n + 1)->collect(0) ;
    var post_count_0 : Sequence(int) ; post_count_0 := Integer.subrange(1,n + 2)->collect(0) ;
    pre_count_0[0+1] := 0 ; 
    post_count_0[n + 1+1] := 0 ; 
    pre_countpre_count_1[0+1][0+1] := 0 ; 
        var j : int ; j := 1 ; while j <= n do ( (     pre_count_0[j+1] := pre_count_0[j - 1+1] ; 
     pre_countpre_count_1[j+1][j+1] := pre_countpre_count_1[j+1][j - 1+1] ; 
    post_count_0[n - j + 1+1] := post_count_0[n - j + 2+1] ; 
    if (s->at(j - 1+1) = '0') then     pre_count_0[j+1] := pre_count_0[j+1] + 1 else     pre_countpre_countpre_countpre_count_1[j+1][j+1][j+1] := pre_countpre_countpre_countpre_count_1[j+1][j+1][j+1] + 1 ; ;  
    if (s->at(n - j+1) = '0') then     post_count_0[n - j + 1+1] := post_count_0[n - j + 1+1] + 1 ; else skip ; 
 )  ;     j := j + 1 ) ; 
    if (pre_count_0[n+1] = n or pre_count_0[n+1] = 0) then     return n else skip ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i <= n do (         var j : int ; j := i ; while j <= n do (     ans := Set{pre_count_0[i - 1+1] + pre_countpre_countpre_count_0[i - 1+1][j+1] - pre_countpre_countpre_count_0[i - 1+1] + pre_countSet{pre_count_0[i - 1+1] + pre_countpre_countpre_count_0[i - 1+1][j+1] - pre_countpre_countpre_count_0[i - 1+1] + pre_countans[j+1][i - 1+1] + post_count_0[j + 1+1], ans}->max()[j+1][i - 1+1] + post_count_0[j + 1+1], ans}->max() ;  ;     j := j + 1 ) ;  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "000011100000" ;
     OclFile["System.out"].println(longestSubseq(s)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void fill0X(int m,int n){
    int i,k=0,l=0 ;
    int r=m,c=n ;
    char a[][]=new char[m][n];
    char x='X' ;
    while(k<m && l<n){
      for(i=l ; i<n ; ++i)a[k][i]=x ;
      k++;
      for(i=k ; i<m ; ++i)a[i][n-1]=x ;
      n--;
      if(k<m){
        for(i=n-1 ; i>=l ; --i)a[m-1][i]=x ;
        m--;
      }
      if(l<n){
        for(i=m-1 ; i>=k ; --i)a[i][l]=x ;
        l++;
      }
      x=(x=='0')? 'X' : '0' ;
    }
    for(i=0 ; i<r ; i++){
      for(int j=0 ; j<c ; j++)System.out.print(a[i][j]+" ");
      System.out.println();
    }
  }
  public static void main(String[] args){
    System.out.println("Output for m=5,n=6");
    fill0X(5,6);
    System.out.println("Output for m=4,n=4");
    fill0X(4,4);
    System.out.println("Output for m=3,n=4");
    fill0X(3,4);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation fill0X( m : int, n : int) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var k : int ; k := 0 ;
    var l : int ; l := 0 ;
     var r : int ; r := m ;
    var c : int ; c := n ;
    var a : Sequence(Sequence(String)) ; a := Integer.subrange(1,m)->collect(Integer.subrange(1,n)->collect(0)) ;
    var x : String ; x := 'X' ;
    while (k < m & l < n) do (         i := l ; while i < n do (     a[k+1][i+1] := x ;  ;     i := i + 1 ) ; 
     k := k + 1 ; 
        i := k ; while i < m do (     a[i+1][n - 1+1] := x ;  ;     i := i + 1 ) ; 
    n := n - 1 ; 
    if (k < m) then (         i := n - 1 ; while i >= l do (     a[m - 1+1][i+1] := x ;  ;     i := i - 1 ) ; 
     m := m - 1 ) else skip ; 
    if (l < n) then (         i := m - 1 ; while i >= k do (     a[i+1][l+1] := x ;  ;     i := i - 1 ) ; 
     l := l + 1 ) else skip ; 
    x := if (x = '0') then 'X' else '0' endif ; 
 ) ; 
        i := 0 ; while i < r do ( (         var j : int ; j := 0 ; while j < c do (     OclFile["System.out"].print(a[i+1][j+1] + " ") ;  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Output for m=5,n=6") ; 
     execute fill0X(5, 6) ; 
    OclFile["System.out"].println("Output for m=4,n=4") ; 
    execute fill0X(4, 4) ; 
    OclFile["System.out"].println("Output for m=3,n=4") ; 
    execute fill0X(3, 4) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test204 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      int x=in.nextInt();
      if(x % 7==0){
        System.out.println(x);
      }
      else {
        x-=x % 10 ;
        for(int i=1 ; i<10 ; i++){
          x++;
          if(x % 7==0){
            break ;
          }
        }
        System.out.println(x);
      }
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test204 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var x : int ; x := in.getCurrent()->toInteger() ;
     if (x mod 7 = 0) then (     OclFile["System.out"].println(x) ) else (     x := x-(x mod 10) ; 
         var i : int ; i := 1 ; while i < 10 do ( (     x := x + 1 ; 
     if (x mod 7 = 0) then (     break ) else skip )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(x) ) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class codeforces {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    HashMap<Integer,Integer>hm=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      if(hm.containsKey(a))hm.put(a,hm.get(a)+1);
      else hm.put(a,1);
    }
    int max=Integer.MIN_VALUE ;
    for(int i : hm.values()){
      if(max<i)max=i ;
    }
    int sum=0 ;
    int x=(int)Math.ceil((double)max/k);
    int y=x*k ;
    for(int i : hm.values()){
      sum=sum+(y-i);
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var hm : Map(int,int) ; hm := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (hm->keys()->includes(a)) then     hm := hm->union(Map{a |-> hm->at(a) + 1}) ; else     hm := hm->union(Map{a |-> 1}) ; )  ;     i := i + 1 ) ; 
    var max : int ; max := -2147483648 ;
    for (i : hm->values()) do ( (     if (max < i) then     max := i ; else skip )  ) ; 
    var sum : int ; sum := 0 ;
    var x : int ; x := (max->oclAsType(double) / k)->ceil()->oclAsType(int) ;
    var y : int ; y := x * k ;
    for (i : hm->values()) do ( (     sum := sum + (y - i) )  ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void solve(int n){
    int n_2=n/2 ;
    String den ;
    den="1" ;
    while(n_2-->0)den+='0' ;
    System.out.println(1+"/"+den);
  }
  public static void main(String[] args){
    int N=5 ;
    solve(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation solve( n : int) : void
  pre: true
  post: true
  activity: (     var nn / 2 : int ; nn / 2 := n / 2 ;
     var den : String ;
    den := "1" ; 
        while (n0 > 0) do (        n0 := n0 - 1 ;     skip ;     den := den+('0') ; ;  ) ;  
    OclFile["System.out"].println(1 + "/" + den) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     execute solve(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class force {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t!=0){
      int x=sc.nextInt();
      if(x % 7==0){
        System.out.println(x);
      }
      else {
        String a=String.valueOf(x);
        char arr[]=a.toCharArray();
        boolean flag=true ;
        for(int i=arr.length-1 ; i>=0 ; i--){
          for(int j=0 ; j<10 ; j++){
            arr[i]=(char)(j+'0');
            String string=new String(arr);
            int ab=Integer.parseInt(string);
            if(ab % 7==0){
              System.out.println(ab);
              flag=false ;
              break ;
            }
          }
          if(flag==false){
            break ;
          }
        }
      }
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class force {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     while (t /= 0) do (     var x : int ; x := sc.getCurrent()->toInteger() ;
     if (x mod 7 = 0) then (     OclFile["System.out"].println(x) ) else (     var a : String ; a := ((x) + "") ;
     var arr : Sequence(String) ; arr := a->characters() ;
     var flag : boolean ; flag := true ;
         var i : int ; i := arr->size() - 1 ; while i >= 0 do ( (         var j : int ; j := 0 ; while j < 10 do ( (     arr[i+1] := (j + '0')->oclAsType(String) ; 
     var string : String ; string := StringLib.newString(arr) ;
     var ab : int ; ab := (string)->toInteger() ;
     if (ab mod 7 = 0) then (     OclFile["System.out"].println(ab) ; 
     flag := false ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (flag = false) then (     break ) else skip )  ;     i := i - 1 ) ) ;  
     t := t - 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class esep {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    while(n-->0){
      double x=sc.nextDouble();
      if(x % 7==0){
        System.out.println((int)x);
      }
      else {
        for(int i=0 ; i<=9 ; i++){
          if((x-x % 10+i)% 7==0){
            System.out.println((int)(x-x % 10+i));
            break ;
          }
        }
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class esep {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         while (n > 0) do (        n := n - 1 ;     skip ; (     var x : double ; x := sc.getCurrent()->toReal() ;
     if (x mod 7 = 0) then (     OclFile["System.out"].println(x->oclAsType(int)) ) else (         var i : int ; i := 0 ; while i <= 9 do ( (     if ((x - x mod 10 + i) mod 7 = 0) then (     OclFile["System.out"].println((x - x mod 10 + i)->oclAsType(int)) ; 
     break ) else skip )  ;     i := i + 1 ) ) ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    for(int i=0 ; i<t ; i++){
      int n=sc.nextInt();
      for(int j=0 ; j<10 ; j++){
        int rem=n % 10 ;
        if(n % 7==0){
          break ;
        }
        if(rem!=0){
          n=n-1 ;
        }
      }
      if(n % 7!=0){
        for(int j=0 ; j<10 ; j++){
          if(n % 7==0){
            break ;
          }
          n=n+1 ;
        }
      }
      System.out.println(n);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < t do ( (     var n : int ; n := sc.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < 10 do ( (     var rem : int ; rem := n mod 10 ;
     if (n mod 7 = 0) then (     break ) else skip ; 
     if (rem /= 0) then (     n := n - 1 ) else skip )  ;     j := j + 1 ) ; 
     if (n mod 7 /= 0) then (         var j : int ; j := 0 ; while j < 10 do ( (     if (n mod 7 = 0) then (     break ) else skip ; 
     n := n + 1 )  ;     j := j + 1 ) ) else skip ; 
     OclFile["System.out"].println(n) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  static List<Integer>v=new ArrayList<Integer>();
  static void printSequence(int n,int s,int k){
    if(s==0){
      for(int i=0 ; i<v.size(); i++)System.out.print(v.get(i)+" ");
      System.out.println();
      return ;
    }
    for(int i=0 ; i<k ; i++){
      v.add(n+i);
      printSequence(n+i,s-1,k);
      v.remove(v.size()-1);
    }
    for(int i=1 ; i<k ; i++){
      v.add(n-i);
      printSequence(n-i,s-1,k);
      v.remove(v.size()-1);
    }
  }
  static void wrapper(int n,int s,int k){
    v.add(n);
    printSequence(n,s-1,k);
  }
  public static void main(String args[]){
    int n=5,s=3,k=2 ;
    wrapper(n,s,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute v : Sequence(int) := Sequence{};
  static   operation printSequence( n : int, s : int, k : int) : void
  pre: true
  post: true
  activity: (     if (s = 0) then (         var i : int ; i := 0 ; while i < v->size() do (     OclFile["System.out"].print(v->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() ; 
     return ) else skip ; 
         var i : int ; i := 0 ; while i < k do ( (     v := v->including(n + i) ; 
     execute printSequence(n + i, s - 1, k) ; 
     v := v->excludingFirst(v->size() - 1) )  ;     i := i + 1 ) ; 
         var i : int ; i := 1 ; while i < k do ( (     v := v->including(n - i) ; 
     execute printSequence(n - i, s - 1, k) ; 
     v := v->excludingFirst(v->size() - 1) )  ;     i := i + 1 ) );
  static   operation wrapper( n : int, s : int, k : int) : void
  pre: true
  post: true
  activity: (     v := v->including(n) ; 
     execute printSequence(n, s - 1, k) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
    var s : int ; s := 3 ;
    var k : int ; k := 2 ;
     execute wrapper(n, s, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Gfg {
  static int cassini(int n){
    return(n & 1)!=0 ?-1 : 1 ;
  }
  public static void main(String args[]){
    int n=5 ;
    System.out.println(cassini(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class Gfg {
  static   operation cassini( n : int) : int
  pre: true
  post: true
  activity: (     return if (n & 1) /= 0 then -1 else 1 endif );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(cassini(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void sieveOfEratosthenes(int N,int s[]){
    boolean[] prime=new boolean[N+1];
    for(int i=2 ; i<=N ; i+=2)s[i]=2 ;
    for(int i=3 ; i<=N ; i+=2){
      if(prime[i]==false){
        s[i]=i ;
        for(int j=i ; j*i<=N ; j+=2){
          if(prime[i*j]==false){
            prime[i*j]=true ;
            s[i*j]=i ;
          }
        }
      }
    }
  }
  static void generatePrimeFactors(int N){
    int[] s=new int[N+1];
    sieveOfEratosthenes(N,s);
    System.out.println("Factor Power");
    int curr=s[N];
    int cnt=1 ;
    while(N>1){
      N/=s[N];
      if(curr==s[N]){
        cnt++;
        continue ;
      }
      System.out.println(curr+"\t"+cnt);
      curr=s[N];
      cnt=1 ;
    }
  }
  public static void main(String[] args){
    int N=360 ;
    generatePrimeFactors(N);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation sieveOfEratosthenes( N : int, s : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var prime : Sequence(boolean) ; prime := Integer.subrange(1,N + 1)->collect(false) ;
         var i : int ; i := 2 ; while i <= N do (     s[i+1] := 2 ;  ;     i := i+(2) ) ; 
         var i : int ; i := 3 ; while i <= N do ( (     if (prime[i+1] = false) then (     s[i+1] := i ; 
         var j : int ; j := i ; while j * i <= N do ( (     if (prime[i * j+1] = false) then (     prime[i * j+1] := true ; 
     s[i * j+1] := i ) else skip )  ;     j := j+(2) ) ) else skip )  ;     i := i+(2) ) );
  static   operation generatePrimeFactors( N : int) : void
  pre: true
  post: true
  activity: (     var s : Sequence(int) ; s := Integer.subrange(1,N + 1)->collect(0) ;
     execute sieveOfEratosthenes(N, s) ; 
    OclFile["System.out"].println("Factor Power") ; 
    var curr : int ; curr := s[N+1] ;
    var cnt : int ; cnt := 1 ;
    while (N > 1) do (     N := N/(s[N+1]) ; 
     if (curr = s[N+1]) then (     cnt := cnt + 1 ; 
     continue ) else skip ; 
    OclFile["System.out"].println(curr + "\t" + cnt) ; 
    curr := s[N+1] ; 
    cnt := 1 ; 
 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 360 ;
     execute generatePrimeFactors(N) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int binarySearchCount(int arr[],int n,int key){
    int left=0 ;
    int right=n-1 ;
    int count=0 ;
    while(left<=right){
      int mid=(right+left)/2 ;
      if(arr[mid]<=key){
        count=mid+1 ;
        left=mid+1 ;
      }
      else right=mid-1 ;
    }
    return count ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,4,11,11,16 };
      int key=11 ;
      int n=arr.length ;
      System.out.println(binarySearchCount(arr,n,key));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation binarySearchCount( arr : Sequence(int), n : int, key : int) : int
  pre: true
  post: true
  activity: (     var left : int ; left := 0 ;
     var right : int ; right := n - 1 ;
    var count : int ; count := 0 ;
    while (left <= right) do (     var mid : int ; mid := (right + left) / 2 ;
     if (arr[mid+1] <= key) then (     count := mid + 1 ; 
     left := mid + 1 ) else     right := mid - 1 ; ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,4,11,11,16} ;
     var key : int ; key := 11 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(binarySearchCount(arr, n, key)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    BigInteger n=sc.nextBigInteger();
    BigInteger modulo=new BigInteger("1000000007");
    BigInteger uno=new BigInteger("1");
    BigInteger dos=new BigInteger("2");
    BigInteger pot=dos.modPow(n,modulo);
    BigInteger sum=pot.add(uno);
    BigInteger mult=pot.multiply(sum);
    BigInteger div=mult.divide(dos);
    div=div.mod(modulo);
    System.out.println(div);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.nextBigInteger() ;
    var modulo : long ; modulo := long("1000000007") ;
    var uno : long ; uno := long("1") ;
    var dos : long ; dos := long("2") ;
    var pot : long ; pot := dos.modPow(n, modulo) ;
    var sum : long ; sum := pot->excludes(uno) ;
    var mult : long ; mult := pot.multiply(sum) ;
    var div : long ; div := mult.divide(dos) ;
    div := div.mod(modulo) ; 
    OclFile["System.out"].println(div) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class plant {
  static int mod=(int)1e9+7 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long ans1=pow(4,n-1);
    long ans2=pow(2,n-1);
    if(n==0){
      System.out.println(1);
      System.exit(0);
    }
    long ans=(2*ans1+ans2)% mod ;
    System.out.println(ans);
  }
  public static long pow(int x,long y){
    if(y==0){
      return 1 ;
    }
    if(y % 2==0){
      long temp=pow(x,y/2);
      return temp*temp % mod ;
    }
    else {
      long temp=pow(x,y/2);
      return(((temp*temp)% mod)*x)% mod ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class plant {
  static   attribute mod : int := 1e9->oclAsType(int) + 7;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var ans1 : long ; ans1 := pow(4, n - 1) ;
    var ans2 : long ; ans2 := pow(2, n - 1) ;
    if (n = 0) then (     OclFile["System.out"].println(1) ; 
 OclProcess.exit(0) ) else skip ; 
    var ans : long ; ans := (2 * ans1 + ans2) mod mod ;
    OclFile["System.out"].println(ans) ; 
 );
  static   operation pow( x : int, y : long) : long
  pre: true
  post: true
  activity: (     if (y = 0) then (     return 1 ) else skip ; 
     if (y mod 2 = 0) then (     var temp : long ; temp := pow(x, y / 2) ;
     return temp * temp mod mod ) else (     var temp : long ; temp := pow(x, y / 2) ;
     return (((temp * temp) mod mod) * x) mod mod ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner mi=new Scanner(System.in);
    long p=mi.nextLong();
    int k=mi.nextInt();
    long[] ans=new long[100000];
    int count=0 ;
    double kk=k ;
    long L=p ;
    while(L!=0){
      double LL=L ;
      long R=-(long)Math.floor(LL/kk);
      while(L+R*k<0)++R ;
      while(L+R*k>=k)--R ;
      ans[++count]=L+R*k ;
      L=R ;
    }
    while(ans[count]==0)--count ;
    System.out.println(count);
    for(int i=1 ; i<=count ; ++i)System.out.print(ans[i]+" ");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mi : OclFile ; mi := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : long ; p := mi.getCurrent()->toLong() ;
    var k : int ; k := mi.getCurrent()->toInteger() ;
    var ans : Sequence(long) ; ans := Integer.subrange(1,100000)->collect(0) ;
    var count : int ; count := 0 ;
    var kk : double ; kk := k ;
    var L : long ; L := p ;
    while (L /= 0) do (     var LL : double ; LL := L ;
     var R : long ; R := -(LL / kk)->floor()->oclAsType(long) ;
    while (L + R * k < 0) do     R := R + 1 ; ; 
    while (L + R * k >= k) do     R := R - 1 ; ; 
        count := count + 1 ;
 ans[count+1] := L + R * k  ; 
    L := R ; 
 ) ; 
    while (ans[count+1] = 0) do     count := count - 1 ; ; 
    OclFile["System.out"].println(count) ; 
        var i : int ; i := 1 ; while i <= count do (     OclFile["System.out"].print(ans[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class A {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int T=in.nextInt();
    for(int zz=1 ; zz<=T ; zz++){
      int N=in.nextInt();
      long[] M=new long[N];
      for(int i=0 ; i<N ; i++)M[i]=in.nextInt();
      long ans1=0 ;
      for(int i=0 ; i<N-1 ; i++){
        ans1+=max(0,M[i]-M[i+1]);
      }
      long max=0 ;
      for(int i=0 ; i<N-1 ; i++){
        max=max(max,M[i]-M[i+1]);
      }
      long ans2=0 ;
      for(int i=0 ; i<N-1 ; i++)ans2+=min(max,M[i]);
      System.out.format("Case #%d: %d %d\n",zz,ans1,ans2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var T : int ; T := in.getCurrent()->toInteger() ;
         var zz : int ; zz := 1 ; while zz <= T do ( (     var N : int ; N := in.getCurrent()->toInteger() ;
     var M : Sequence(long) ; M := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do (     M[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans1 : long ; ans1 := 0 ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     ans1 := ans1+(Set{0, M[i+1] - M[i + 1+1]}->max()) )  ;     i := i + 1 ) ; 
    var max : long ; max := 0 ;
        var i : int ; i := 0 ; while i < N - 1 do ( (     max := Set{max, M[i+1] - M[i + 1+1]}->max() )  ;     i := i + 1 ) ; 
    var ans2 : long ; ans2 := 0 ;
        var i : int ; i := 0 ; while i < N - 1 do (     ans2 := ans2+(Set{max, M[i+1]}->min()) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].format("Case #%d: %d %d\n", zz, ans1, ans2) ; 
 )  ;     zz := zz + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.List ;
import java.util.ArrayList ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    ArrayList<String[]>array=new ArrayList<String[]>();
    for(int i=0 ; i<n ; i++){
      String[] s=br.readLine().split(" ");
      array.add(s);
    }
    double ans=0 ;
    for(int i=0 ; i<n-1 ; i++){
      double xi=Double.parseDouble(array.get(i)[0]);
      double yi=Double.parseDouble(array.get(i)[1]);
      double xi1=Double.parseDouble(array.get(i+1)[0]);
      double yi1=Double.parseDouble(array.get(i+1)[1]);
      ans+=(xi*yi1-xi1*yi)/2 ;
    }
    double xn=Double.parseDouble(array.get(n-1)[0]);
    double yn=Double.parseDouble(array.get(n-1)[1]);
    double xn1=Double.parseDouble(array.get(0)[0]);
    double yn1=Double.parseDouble(array.get(0)[1]);
    ans+=(xn*yn1-xn1*yn)/2 ;
    System.out.printf("%.1f\n",ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (br.readLine())->toInteger() ;
    var array : Sequence(Sequence(String)) ; array := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var s : Sequence(String) ; s := br.readLine()->split(" ") ;
     array := array->including(s) )  ;     i := i + 1 ) ; 
    var ans : double ; ans := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var xi : double ; xi := (array->at(i+1)[0+1])->toReal() ;
     var yi : double ; yi := (array->at(i+1)[1+1])->toReal() ;
    var xi1 : double ; xi1 := (array->at(i + 1+1)[0+1])->toReal() ;
    var yi1 : double ; yi1 := (array->at(i + 1+1)[1+1])->toReal() ;
    ans := ans+((xi * yi1 - xi1 * yi) / 2) ; 
 )  ;     i := i + 1 ) ; 
    var xn : double ; xn := (array->at(n - 1+1)[0+1])->toReal() ;
    var yn : double ; yn := (array->at(n - 1+1)[1+1])->toReal() ;
    var xn1 : double ; xn1 := (array->at(0+1)[0+1])->toReal() ;
    var yn1 : double ; yn1 := (array->at(0+1)[1+1])->toReal() ;
    ans := ans+((xn * yn1 - xn1 * yn) / 2) ; 
    OclFile["System.out"].printf("%.1f\n", ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.awt.geom.Line2D ;
import java.awt.geom.Point2D ;
import java.lang.reflect.Array ;
import java.util.*;
public class Main {
  Scanner in=new Scanner(System.in);
  public static void main(String[] args){
    new Main();
  }
  public Main(){
    new CGL_2B().doIt();
  }
  class CGL_2B {
    double cross(Point2D p1,Point2D p2){
      return p1.getX()*p2.getY()-p1.getY()*p2.getX();
    }
    double area(ArrayList<Point2D>points){
      double ret=0.0 ;
      for(int i=0 ; i<points.size(); ++i){
        Point2D p1=points.get(i),p2=points.get((i+1)% points.size());
        ret+=cross(p1,p2);
      }
      return Math.abs(ret)/2.0 ;
    }
    void doIt(){
      int n=in.nextInt();
      ArrayList<Point2D>list=new ArrayList<Point2D>();
      for(int i=0 ; i<n ; i++)list.add(new Point2D.Double(in.nextDouble(),in.nextDouble()));
      System.out.printf("%.1f\n",area(list));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute in : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: ( Main.newMain() );
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     CGL()B.newCGL()B().doIt() );
 class CGL{
   operation cross( p1 : Point2D, p2 : Point2D) : double
  pre: true
  post: true
  activity: (     return p1.getX() * p2.getY() - p1.getY() * p2.getX() );
   operation area( points : Sequence(Point2D)) : double
  pre: true
  post: true
  activity: (     var ret : double ; ret := 0.0 ;
         var i : int ; i := 0 ; while i < points->size() do ( (     var p1 : Point2D ; p1 := points->at(i+1) ;
    var p2 : Point2D ; p2 := points->at((i + 1) mod points->size()+1) ;
     ret := ret+(cross(p1, p2)) )  ;     i := i + 1 ) ; 
     return if ret < 0 then -(ret) else ret endif / 2.0 );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var list : Sequence(Point2D) ; list := Sequence{} ;
         var i : int ; i := 0 ; while i < n do (     list := list->including(Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal())) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].printf("%.1f\n", area(list)) );
}
B {
   operation cross( p1 : Point2D, p2 : Point2D) : double
  pre: true
  post: true
  activity: (     return p1.getX() * p2.getY() - p1.getY() * p2.getX() );
   operation area( points : Sequence(Point2D)) : double
  pre: true
  post: true
  activity: (     var ret : double ; ret := 0.0 ;
         var i : int ; i := 0 ; while i < points->size() do ( (     var p1 : Point2D ; p1 := points->at(i+1) ;
    var p2 : Point2D ; p2 := points->at((i + 1) mod points->size()+1) ;
     ret := ret+(cross(p1, p2)) )  ;     i := i + 1 ) ; 
     return if ret < 0 then -(ret) else ret endif / 2.0 );
   operation doIt() : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.getCurrent()->toInteger() ;
     var list : Sequence(Point2D) ; list := Sequence{} ;
         var i : int ; i := 0 ; while i < n do (     list := list->including(Double.newDouble(in.getCurrent()->toReal(), in.getCurrent()->toReal())) ;  ;     i := i + 1 ) ; 
     OclFile["System.out"].printf("%.1f\n", area(list)) );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    List<Vector2d>p=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      double x=sc.nextDouble();
      double y=sc.nextDouble();
      p.add(new Vector2d(x,y));
    }
    sc.close();
    System.out.println(String.format("%1$.1f",solve(p)));
  }
  static class Vector2d {
    Vector2d(Double x,Double y){
      this.x=x ;
      this.y=y ;
    }
    Double x ;
    Double y ;
    public String toString(){
      return String.format("%1$.10f %2$.10f",x,y);
    }
  }
  public static Vector2d sub(Vector2d v1,Vector2d v2){
    return new Vector2d(v2.x-v1.x,v2.y-v1.y);
  }
  public static Double solve(List<Vector2d>p){
    Double v2times=0.0 ;
    int s=p.size();
    for(int i=0 ; i<s ; i++){
      v2times+=(p.get(i).x*p.get((i+1)% s).y-p.get(i).y*p.get((i+1)% s).x);
    }
    return v2times/2 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var p : Sequence(Vector2d) ; p := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : double ; x := sc.getCurrent()->toReal() ;
     var y : double ; y := sc.getCurrent()->toReal() ;
     p := p->including(Vector2d.newVector2d(x, y)) )  ;     i := i + 1 ) ; 
    skip ; 
    OclFile["System.out"].println(StringLib.format("%1$.1f",Sequence{solve(p)})) ; 
 );
  static class Vector2d {
   static operation newVector2d( x : double, y : double) : Vector2d
  pre: true
  post: true
  activity:
  ( var self : Vector2d ;
    self := createVector2d();
    self.initialise(x, y);
    return self );
  operation initialise( x : double, y : double) : void
  pre: true  post: true
  activity: (     self.x := x ; 
     self.y := y );
   attribute x : double;
   attribute y : double;
   operation toString() : String
  pre: true
  post: true
  activity: (     return StringLib.format("%1$.10f %2$.10f",Sequence{x,y}) );
}
  static   operation sub( v1 : Vector2d, v2 : Vector2d) : Vector2d
  pre: true
  post: true
  activity: (     return Vector2d.newVector2d(v2.x - v1.x, v2.y - v1.y) );
  static   operation solve( p : Sequence(Vector2d)) : double
  pre: true
  post: true
  activity: (     var v2times : double ; v2times := 0.0 ;
     var s : int ; s := p->size() ;
         var i : int ; i := 0 ; while i < s do ( (     v2times := v2times+((p->at(i+1).x * p->at((i + 1) mod s+1).y - p->at(i+1).y * p->at((i + 1) mod s+1).x)) )  ;     i := i + 1 ) ; 
     return v2times / 2 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal ;
import java.util.Scanner ;
class Main {
  static double area(double[] x,double[] y){
    double area=0 ;
    double crossp ;
    for(int i=0 ; i<x.length-1 ; i++){
      crossp=CrossPoint(x[i],y[i],x[i+1],y[i+1]);
      if(crossp==200000){
        area+=(y[i+1]+y[i])*(x[i+1]-x[i])/2.0 ;
      }
      else {
        area+=(crossp-x[i])*y[i]/2 ;
        area+=(x[i+1]-crossp)*y[i+1]/2 ;
      }
    }
    return Math.abs(area);
  }
  static double CrossPoint(double x0,double y0,double x1,double y1){
    if(y0*y1<0){
      if(y1==y0){
        return x0 ;
      }
      else {
        return x0-y0*(x1-x0)/(y1-y0);
      }
    }
    else {
      return 200000 ;
    }
  }
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    double[] x=new double[n+1];
    double[] y=new double[n+1];
    for(int i=0 ; i<n ; i++){
      x[i]=in.nextInt();
      y[i]=in.nextInt();
    }
    x[n]=x[0];
    y[n]=y[0];
    System.out.printf("%.1f\n",BigDecimal.valueOf(area(x,y)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation area( x : Sequence(double), y : Sequence(double)) : double
  pre: true
  post: true
  activity: (     var area : double ; area := 0 ;
     var crossp : double ;
         var i : int ; i := 0 ; while i < x->size() - 1 do ( (     crossp := CrossPoint(x[i+1], y[i+1], x[i + 1+1], y[i + 1+1]) ; 
     if (crossp = 200000) then (     area := area+((y[i + 1+1] + y[i+1]) * (x[i + 1+1] - x[i+1]) / 2.0) ) else (     area := area+((crossp - x[i+1]) * y[i+1] / 2) ; 
     area := area+((x[i + 1+1] - crossp) * y[i + 1+1] / 2) ) )  ;     i := i + 1 ) ; 
     return if area < 0 then -(area) else area endif );
  static   operation CrossPoint( x0 : double, y0 : double, x1 : double, y1 : double) : double
  pre: true
  post: true
  activity: (     if (y0 * y1 < 0) then (     if (y1 = y0) then (     return x0 ) else (     return x0 - y0 * (x1 - x0) / (y1 - y0) ) ) else (     return 200000 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var x : Sequence(double) ; x := Integer.subrange(1,n + 1)->collect(0.0) ;
    var y : Sequence(double) ; y := Integer.subrange(1,n + 1)->collect(0.0) ;
        var i : int ; i := 0 ; while i < n do ( (     x[i+1] := in.getCurrent()->toInteger() ; 
     y[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    x[n+1] := x[0+1] ; 
    y[n+1] := y[0+1] ; 
    OclFile["System.out"].printf("%.1f\n", (area(x, y) + "")->toReal()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.lang.*;
public class Main {
  static int INF=1000000000 ;
  static int MAXN=31 ;
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    int[][] point=new int[n][2];
    for(int i=0 ; i<n ; ++i){
      point[i][0]=input.nextInt();
      point[i][1]=input.nextInt();
    }
    double res=0 ;
    for(int i=0 ; i<n-1 ; ++i){
      res+=(point[i][0]-point[i+1][0])*(point[i][1]+point[i+1][1]);
    }
    res+=(point[n-1][0]-point[0][0])*(point[n-1][1]+point[0][1]);
    res=Math.abs(res)/2 ;
    System.out.printf("%.1f\n",res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute INF : int := 1000000000;
  static   attribute MAXN : int := 31;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var point : Sequence(Sequence(int)) ; point := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     point[i+1][0+1] := input.getCurrent()->toInteger() ; 
     point[i+1][1+1] := input.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var res : double ; res := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     res := res+((point[i+1][0+1] - point[i + 1+1][0+1]) * (point[i+1][1+1] + point[i + 1+1][1+1])) )  ;     i := i + 1 ) ; 
    res := res+((point[n - 1+1][0+1] - point[0+1][0+1]) * (point[n - 1+1][1+1] + point[0+1][1+1])) ; 
    res := if res < 0 then -(res) else res endif / 2 ; 
    OclFile["System.out"].printf("%.1f\n", res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int longestSubarray(int a[],int n){
    int hash[][]=new int[n][10];
    for(int i=0 ; i<n ; i++){
      int num=a[i];
      while(num!=0){
        hash[i][num % 10]=1 ;
        num/=10 ;
      }
    }
    int longest=Integer.MIN_VALUE ;
    int count=0 ;
    for(int i=0 ; i<n-1 ; i++){
      int j ;
      for(j=0 ; j<10 ; j++){
        if(hash[i][j]==1 & hash[i+1][j]==1){
          count++;
          break ;
        }
      }
      if(j==10){
        longest=Math.max(longest,count+1);
        count=0 ;
      }
    }
    longest=Math.max(longest,count+1);
    return longest ;
  }
  public static void main(String[] args){
    int a[]={
      11,22,33,44,54,56,63 };
      int n=a.length ;
      System.out.println(longestSubarray(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation longestSubarray( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var hash : Sequence(Sequence(int)) ; hash := Integer.subrange(1,n)->collect(Integer.subrange(1,10)->collect(0)) ;
         var i : int ; i := 0 ; while i < n do ( (     var num : int ; num := a[i+1] ;
     while (num /= 0) do (     hash[i+1][num mod 10+1] := 1 ; 
     num := num/(10) ) )  ;     i := i + 1 ) ; 
    var longest : int ; longest := -2147483648 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     var j : int ;
         j := 0 ; while j < 10 do ( (     if (hash[i+1][j+1] = 1 & hash[i + 1+1][j+1] = 1) then (     count := count + 1 ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (j = 10) then (     longest := Set{longest, count + 1}->max() ; 
     count := 0 ) else skip )  ;     i := i + 1 ) ; 
    longest := Set{longest, count + 1}->max() ; 
    return longest 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{11,22,33,44,54,56,63} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(longestSubarray(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
import static java.lang.Math.max ;
import static java.lang.Math.min ;
public class E {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    for(int i=0 ; i<n ; i++){
      long a=in.nextLong();
      long b=in.nextLong();
      long max=max(a,b);
      long min=min(a,b);
      if(max<min*2)System.out.println((max+min)/3);
      else System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class E {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var a : long ; a := in.getCurrent()->toLong() ;
     var b : long ; b := in.getCurrent()->toLong() ;
    var max : long ; max := max(a, b) ;
    var min : long ; min := min(a, b) ;
    if (max < min * 2) then     OclFile["System.out"].println((max + min) / 3) else     OclFile["System.out"].println(min) ; ;  
 )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Shovels_and_Swords {
  static Scanner sc=new Scanner(System.in);
  static PrintWriter pw=new PrintWriter(System.out);
  public static int min(int a,int b,int s){
    if(a>=b){
      if(b>=s)return s ;
      else {
        return b ;
      }
    }
    else {
      if(a>=s)return s ;
      return a ;
    }
  }
  public static void main(String[] args){
    int t=sc.nextInt();
    while(t-->0){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int s=(a+b)/3 ;
      pw.println(min(a,b,s));
    }
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Shovels_and_Swords {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation min( a : int, b : int, s : int) : int
  pre: true
  post: true
  activity: (     if (a >= b) then (     if (b >= s) then     return s else (     return b ) ) else (     if (a >= s) then     return s else skip ; 
     return a ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     var s : int ; s := (a + b) / 3 ;
     skip ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Shovels_and_Swords {
  static Scanner sc=new Scanner(System.in);
  static PrintWriter pw=new PrintWriter(System.out);
  public static void main(String[] args){
    int t=sc.nextInt();
    while(t-->0){
      int a=sc.nextInt();
      int b=sc.nextInt();
      int s=(a+b)/3 ;
      pw.println(Math.min(Math.min(a,b),s));
    }
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Shovels_and_Swords {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute pw : OclFile := OclFile.newOclFile_Write(OclFile["System.out"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var a : int ; a := sc.getCurrent()->toInteger() ;
     var b : int ; b := sc.getCurrent()->toInteger() ;
     var s : int ; s := (a + b) / 3 ;
     skip ) ;  ) ;  
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static boolean isVowel(char c){
    return(c=='A' || c=='E' || c=='I' || c=='O' || c=='U' || c=='a' || c=='e' || c=='i' || c=='o' || c=='u');
  }
  static String pigLatin(String s){
    int len=s.length();
    int index=-1 ;
    for(int i=0 ; i<len ; i++){
      if(isVowel(s.charAt(i))){
        index=i ;
        break ;
      }
    }
    if(index==-1)return "-1" ;
    return s.substring(index)+s.substring(0,index)+"ay" ;
  }
  public static void main(String[] args){
    String str=pigLatin("graphic");
    if(str=="-1")System.out.print("No vowels found."+"Pig Latin not possible");
    else System.out.print(str);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation isVowel( c : String) : boolean
  pre: true
  post: true
  activity: (     return (c = 'A' or c = 'E' or c = 'I' or c = 'O' or c = 'U' or c = 'a' or c = 'e' or c = 'i' or c = 'o' or c = 'u') );
  static   operation pigLatin( s : String) : String
  pre: true
  post: true
  activity: (     var len : int ; len := s->size() ;
     var index : int ; index := -1 ;
        var i : int ; i := 0 ; while i < len do ( (     if (isVowel(s->at(i+1))) then (     index := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (index = -1) then     return "-1" else skip ; 
    return s.subrange(index+1,index) + s.subrange(0+1,index) + "ay" 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : String ; str := pigLatin("graphic") ;
     if (str = "-1") then     OclFile["System.out"].print("No vowels found." + "Pig Latin not possible") ; else     OclFile["System.out"].print(str) ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findNumbers(int arr[],int n){
    int num[]=new int[n];
    int b_minus_a=arr[n-1]-arr[1];
    num[1]=(arr[0]+b_minus_a)/2 ;
    num[0]=arr[0]-num[1];
    for(int i=1 ; i<=(n-2); i++)num[i+1]=arr[i]-num[0];
    System.out.print("Numbers are: ");
    for(int i=0 ; i<n ; i++)System.out.print(num[i]+" ");
  }
  public static void main(String[] args){
    int arr[]={
      13,10,14,9,17,21,16,18,13,17 };
      int n=5 ;
      findNumbers(arr,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNumbers( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var num : Sequence(int) ; num := Integer.subrange(1,n)->collect(0) ;
     var b_minus_a : int ; b_minus_a := arr[n - 1+1] - arr[1+1] ;
    num[1+1] := (arr[0+1] + b_minus_a) / 2 ; 
    num[0+1] := arr[0+1] - num[1+1] ; 
        var i : int ; i := 1 ; while i <= (n - 2) do (     num[i + 1+1] := arr[i+1] - num[0+1] ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("Numbers are: ") ; 
        var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(num[i+1] + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{13,10,14,9,17,21,16,18,13,17} ;
     var n : int ; n := 5 ;
     execute findNumbers(arr, n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class taskA {
  PrintWriter out ;
  BufferedReader br ;
  StringTokenizer st ;
  String nextToken()throws IOException {
    while((st==null)||(! st.hasMoreTokens()))st=new StringTokenizer(br.readLine());
    return st.nextToken();
  }
  public int nextInt()throws IOException {
    return Integer.parseInt(nextToken());
  }
  public long nextLong()throws IOException {
    return Long.parseLong(nextToken());
  }
  public double nextDouble()throws IOException {
    return Double.parseDouble(nextToken());
  }
  public void solve()throws IOException {
    int n=nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=nextInt();
    }
    int y=0 ;
    int z=0 ;
    int minS=0 ;
    for(int i=1 ; i<n ; i++){
      if(a[i]<a[i-1]){
        y+=a[i-1]-a[i];
        minS=Math.max(minS,a[i-1]-a[i]);
      }
    }
    for(int i=0 ; i<n-1 ; i++){
      z+=Math.min(a[i],minS);
    }
    out.println(y+" "+z);
  }
  public void run(){
    try {
      br=new BufferedReader(new InputStreamReader(System.in));
      out=new PrintWriter(System.out);
      br=new BufferedReader(new FileReader("taskA.in"));
      out=new PrintWriter("taskA.out");
      int n=nextInt();
      for(int i=0 ; i<n ; i++){
        out.print("Case #"+(i+1)+": ");
        solve();
      }
      out.close();
    }
    catch(IOException e){
      e.printStackTrace();
    }
  }
  public static void main(String[] args){
    new taskA().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class taskA {
   attribute out : OclFile;
   attribute br : OclFile;
   attribute st : OclIterator;
   operation nextToken() : String
  pre: true
  post: true
  activity: (     while ((st = null) or (not(st.hasNext()))) do     st := OclIterator.newOclIterator_String(br.readLine()) ; ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (nextToken())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (nextToken())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (nextToken())->toReal() );
   operation solve() : void
  pre: true
  post: true
  activity: (     var n : int ; n := nextInt() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := nextInt() )  ;     i := i + 1 ) ; 
    var y : int ; y := 0 ;
    var z : int ; z := 0 ;
    var minS : int ; minS := 0 ;
        var i : int ; i := 1 ; while i < n do ( (     if (a[i+1] < a[i - 1+1]) then (     y := y+(a[i - 1+1] - a[i+1]) ; 
     minS := Set{minS, a[i - 1+1] - a[i+1]}->max() ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     z := z+(Set{a[i+1], minS}->min()) )  ;     i := i + 1 ) ; 
    skip ; 
 );
   operation run() : void
  pre: true
  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     out := OclFile.newOclFile_Write(OclFile["System.out"]) ; 
    br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("taskA.in"))) ; 
    out := OclFile.newOclFile_Write(OclFile.newOclFile("taskA.out")) ; 
    var n : int ; n := nextInt() ;
        var i : int ; i := 0 ; while i < n do ( (     skip ; 
     execute solve() )  ;     i := i + 1 ) ; 
    skip ; 
 )   catch (e : IOException) do (     e.printStackTrace() )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     taskA.newtaskA().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  static String line ;
  static int p ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      line=sc.next();
      p=0 ;
      System.out.println(dfs());
    }
  }
  static int dfs(){
    ArrayList<Integer>points=new ArrayList<>();
    while(true){
      if(p==line.length()|| line.charAt(p)==']'){
        break ;
      }
      if(line.charAt(p)=='['){
        p++;
        points.add(dfs());
        p++;
      }
      else {
        int n=0 ;
        while("1234567890".contains(line.charAt(p)+"")){
          n=n*10+Integer.parseInt(line.charAt(p)+"");
          p++;
        }
        return n/2+1 ;
      }
    }
    Collections.sort(points);
    int sum=0 ;
    for(int i=0 ; i<points.size()/2+1 ; i++){
      sum+=points.get(i);
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute line : String;
  static   attribute p : int;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     line := sc.getCurrent() ; 
     p := 0 ; 
     OclFile["System.out"].println(dfs()) )  ;     i := i + 1 ) );
  static   operation dfs() : int
  pre: true
  post: true
  activity: (     var points : Sequence(int) ; points := Sequence{} ;
     while (true) do (     if (p = line->size() or line->at(p+1) = ']') then (     break ) else skip ; 
     if (line->at(p+1) = '[') then (     p := p + 1 ; 
     points := points->including(dfs()) ; 
     p := p + 1 ) else (     var n : int ; n := 0 ;
     while ("1234567890"->includes(line->at(p+1) + "")) do (     n := n * 10 + (line->at(p+1) + "")->toInteger() ; 
     p := p + 1 ) ; 
     return n / 2 + 1 ) ) ; 
    points := points->sort() ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < points->size() / 2 + 1 do ( (     sum := sum+(points->at(i+1)) )  ;     i := i + 1 ) ; 
    return sum 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.Math.*;
public class Main {
  int INF=1<<28 ;
  double EPS=1e-10 ;
  void run(){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    for(; n>0 ; n--){
      l=sc.next()+".." ;
      p=0 ;
      System.out.println(solve());
    }
  }
  String l ;
  int p ;
  char next(){
    return l.charAt(p++);
  }
  int solve(){
    char c=next();
    if(c!='[')return val();
    ArrayList<Integer>l=new ArrayList<Integer>();
    while(c=='['){
      l.add(solve());
      c=next();
    }
    int n=l.size();
    sort(l);
    int ret=0 ;
    for(int i=0 ; i<n/2+1 ; i++)ret+=l.get(i);
    return ret ;
  }
  int val(){
    p--;
    char c=next();
    String v="" ;
    while('0'<=c && c<='9'){
      v+=c ;
      c=next();
    }
    return Integer.valueOf(v)/2+1 ;
  }
  void debug(Object...os){
    System.err.println(Arrays.deepToString(os));
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute INF : int := (1*(2->pow(28)))->oclAsType(long);
   attribute EPS : double := 1e-10;
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
       while n > 0 do ( (     l := sc.getCurrent() + ".." ; 
     p := 0 ; 
     OclFile["System.out"].println(solve()) )  ;     n := n - 1 ) );
   attribute l : String;
   attribute p : int;
   operation next() : String
  pre: true
  post: true
  activity: (     return l->at(p+1) );
   operation solve() : int
  pre: true
  post: true
  activity: (     var c : String ; c := next() ;
     if (c /= '[') then     return val() else skip ; 
    var l : Sequence(int) ; l := Sequence{} ;
    while (c = '[') do (     l := l->including(solve()) ; 
     c := next() ) ; 
    var n : int ; n := l->size() ;
    execute sort(l) ; 
    var ret : int ; ret := 0 ;
        var i : int ; i := 0 ; while i < n / 2 + 1 do (     ret := ret+(l->at(i+1)) ;  ;     i := i + 1 ) ; 
    return ret 
 );
   operation val() : int
  pre: true
  post: true
  activity: (     p := p - 1 ; 
     var c : String ; c := next() ;
    var v : String ; v := "" ;
    while ('0' <= c & c <= '9') do (     v := v+(c) ; 
     c := next() ) ; 
    return (v)->toInteger() / 2 + 1 
 );
   operation debug( os : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((os + "")) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(reader.readLine());
    for(int j=0 ; j<n ; j++){
      String input=reader.readLine();
      int i=0 ;
      while(input.charAt(i)=='[')i++;
      System.out.println(getMinCount(input.substring(i,input.length()-i),i));
    }
  }
  public static int getMinCount(String input,int hierarchy){
    if(hierarchy==0){
      return(Integer.parseInt(input)+2)/2 ;
    }
    String divider="" ;
    for(int i=0 ; i<hierarchy ; i++){
      divider="\\] "+divider+"\\[" ;
    }
    String[] inputs=input.split(divider);
    int[] mins=new int[inputs.length];
    for(int i=0 ; i<inputs.length ; i++){
      mins[i]=getMinCount(inputs[i],hierarchy-1);
    }
    Arrays.sort(mins);
    int sum=0 ;
    for(int i=0 ; i<(inputs.length+1)/2 ; i++){
      sum+=mins[i];
    }
    return sum ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var n : int ; n := (reader.readLine())->toInteger() ;
         var j : int ; j := 0 ; while j < n do ( (     var input : String ; input := reader.readLine() ;
     var i : int ; i := 0 ;
     while (input->at(i+1) = '[') do     i := i + 1 ; ; 
     OclFile["System.out"].println(getMinCount(input.subrange(i+1,input->size() - (i)->char2byte()), i)) )  ;     j := j + 1 ) );
  static   operation getMinCount( input : String, hierarchy : int) : int
  pre: true
  post: true
  activity: (     if (hierarchy = 0) then (     return ((input)->toInteger() + 2) / 2 ) else skip ; 
     var divider : String ; divider := "" ;
        var i : int ; i := 0 ; while i < hierarchy do ( (     divider := "\\] " + divider + "\\[" )  ;     i := i + 1 ) ; 
    var inputs : Sequence(String) ; inputs := input->split(divider) ;
    var mins : Sequence(int) ; mins := Integer.subrange(1,inputs->size())->collect(0) ;
        var i : int ; i := 0 ; while i < inputs->size() do ( (     mins[i+1] := getMinCount(inputs[i+1], hierarchy - 1) )  ;     i := i + 1 ) ; 
    mins := mins->sort() ; 
    var sum : int ; sum := 0 ;
        var i : int ; i := 0 ; while i < (inputs->size() + 1) / 2 do ( (     sum := sum+(mins[i+1]) )  ;     i := i + 1 ) ; 
    return sum 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
public class Main {
  public static int solve(char[] str,int start,int end){
    final boolean is_number=!(str[start+1]=='[' || str[start+1]==']');
    if(is_number){
      int num=0 ;
      for(int pos=start+1 ; pos<end-1 ; pos++){
        num*=10 ;
        num+=str[pos]-'0' ;
      }
      return num/2+1 ;
    }
    else {
      ArrayList<Integer>list=new ArrayList<Integer>();
      int depth=0 ;
      int d_start=-1 ;
      for(int pos=start ; pos<end ; pos++){
        if(str[pos]=='['){
          if(depth==1){
            d_start=pos ;
          }
          depth++;
        }
        else if(str[pos]==']'){
          depth--;
          if(depth==1){
            final int ret=solve(str,d_start,pos+1);
            list.add(ret);
          }
        }
      }
      Collections.sort(list);
      int size=list.size()/2+1 ;
      int ret=0 ;
      for(int i=0 ; i<size ; i++){
        ret+=list.get(i);
      }
      return ret ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    final int n=sc.nextInt();
    for(int tt=0 ; tt<n ; tt++){
      final char[] input=sc.next().toCharArray();
      System.out.println(solve(input,0,input.length));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solve( str : Sequence(String), start : int, end : int) : int
  pre: true
  post: true
  activity: (     var is_number : boolean ; is_number := not((str[start + 1+1] = '[' or str[start + 1+1] = ']')) ;
     if (is_number) then (     var num : int ; num := 0 ;
         var pos : int ; pos := start + 1 ; while pos < end - 1 do ( (     num := num*(10) ; 
     num := num+(str[pos+1] - ('0')->char2byte()) )  ;     pos := pos + 1 ) ; 
     return num / 2 + 1 ) else (     var list : Sequence(int) ; list := Sequence{} ;
     var depth : int ; depth := 0 ;
    var d_start : int ; d_start := -1 ;
        var pos : int ; pos := start ; while pos < end do ( (     if (str[pos+1] = '[') then (     if (depth = 1) then (     d_start := pos ) else skip ; 
     depth := depth + 1 ) else     if (str[pos+1] = ']') then (     depth := depth - 1 ; 
     if (depth = 1) then (     var ret : int ; ret := solve(str, d_start, pos + 1) ;
     list := list->including(ret) ) else skip ) else skip ; )  ;     pos := pos + 1 ) ; 
    list := list->sort() ; 
    var size : int ; size := list->size() / 2 + 1 ;
    var ret : int ; ret := 0 ;
        var i : int ; i := 0 ; while i < size do ( (     ret := ret+(list->at(i+1)) )  ;     i := i + 1 ) ; 
    return ret 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
         var tt : int ; tt := 0 ; while tt < n do ( (     var input : Sequence(String) ; input := sc.getCurrent()->characters() ;
     OclFile["System.out"].println(solve(input, 0, input->size())) )  ;     tt := tt + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Integer.parseInt ;
public class _1196A_ThreePilesOfCandies {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int test=parseInt(input.nextLine());
    while(test-->0){
      long a=input.nextLong();
      long b=input.nextLong();
      long c=input.nextLong();
      long result=(a+b+c)/2 ;
      System.out.println(result);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _1196A_ThreePilesOfCandies {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var test : int ; test := parseInt(input.nextLine()) ;
         while (test > 0) do (        test := test - 1 ;     skip ; (     var a : long ; a := input.getCurrent()->toLong() ;
     var b : long ; b := input.getCurrent()->toLong() ;
    var c : long ; c := input.getCurrent()->toLong() ;
    var result : long ; result := (a + b + c) / 2 ;
    OclFile["System.out"].println(result) ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.Math.*;
public class Main {
  final Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    new Main().init();
  }
  char[] c ;
  int p=0 ;
  void init(){
    int N=sc.nextInt();
    while(--N>=0){
      c=(sc.next()+"#").toCharArray();
      p=0 ;
      int ans=dfs();
      System.out.println(ans);
    }
  }
  int dfs(){
    if(c[p]=='['){
      int ret=0 ;
++p ;
      if(c[p]=='['){
        ArrayList<Integer>tmp=new ArrayList<Integer>();
        while(c[p]=='['){
          tmp.add(dfs());
        }
        Collections.sort(tmp);
        for(int i=0 ; i<(tmp.size()/2)+1 ; ++i)ret+=tmp.get(i);
++p ;
        return ret ;
      }
      else if(Character.isDigit(c[p])){
        ArrayList<Integer>tmp=new ArrayList<Integer>();
        while(Character.isDigit(c[p])){
          int n=c[p]-'0' ;
++p ;
          while(Character.isDigit(c[p])){
            n=n*10+(c[p]-'0');
++p ;
          }
          tmp.add(n);
++p ;
          if(c[p]=='[')++p ;
        }
        Collections.sort(tmp);
        for(int i=0 ; i<(tmp.size()/2)+1 ; ++i)ret+=tmp.get(i)/2+1 ;
        return ret ;
      }
    }
    return 0 ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().init() );
   attribute c : Sequence(String);
   attribute p : int := 0;
   operation init() : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
         N := N - 1 ;
    while ((N - 1) >= 0) do (        N := N - 1 ;     skip ; (     c := (sc.getCurrent() + "#")->characters() ; 
     p := 0 ; 
     var ans : int ; ans := dfs() ;
     OclFile["System.out"].println(ans) ) ;     N := N - 1 ;
 ) );
   operation dfs() : int
  pre: true
  post: true
  activity: (     if (c[p+1] = '[') then (     var ret : int ; ret := 0 ;
     p := p + 1 ; 
     if (c[p+1] = '[') then (     var tmp : Sequence(int) ; tmp := Sequence{} ;
     while (c[p+1] = '[') do (     tmp := tmp->including(dfs()) ) ; 
    tmp := tmp->sort() ; 
        var i : int ; i := 0 ; while i < (tmp->size() / 2) + 1 do (     ret := ret+(tmp->at(i+1)) ;  ;     i := i + 1 ) ; 
    p := p + 1 ; 
    return ret 
 ) else     if ((c[p+1] + "")->isMatch("[0-9]")) then (     var tmp : Sequence(int) ; tmp := Sequence{} ;
     while ((c[p+1] + "")->isMatch("[0-9]")) do (     var n : int ; n := c[p+1] - ('0')->char2byte() ;
     p := p + 1 ; 
    while ((c[p+1] + "")->isMatch("[0-9]")) do (     n := n * 10 + (c[p+1] - ('0')->char2byte()) ; 
     p := p + 1 ) ; 
    tmp := tmp->including(n) ; 
    p := p + 1 ; 
    if (c[p+1] = '[') then     p := p + 1 ; else skip ; 
 ) ; 
    tmp := tmp->sort() ; 
        var i : int ; i := 0 ; while i < (tmp->size() / 2) + 1 do (     ret := ret+(tmp->at(i+1) / 2 + 1) ;  ;     i := i + 1 ) ; 
    return ret 
 ) else skip ; ) else skip ; 
     return 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int m=6,n=4 ;
  static int compareRow(int a1[],int a2[]){
    for(int i=0 ; i<n ; i++){
      if(a1[i]<a2[i])return 1 ;
      else if(a1[i]>a2[i])return-1 ;
    }
    return 0 ;
  }
  static int binaryCheck(int ar[][],int arr[]){
    int l=0,r=m-1 ;
    while(l<=r){
      int mid=(l+r)/2 ;
      int temp=compareRow(ar[mid],arr);
      if(temp==0)return mid+1 ;
      else if(temp==1)l=mid+1 ;
      else r=mid-1 ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    int mat[][]={
      {
        0,0,1,0 },{
          10,9,22,23 },{
            40,40,40,40 },{
              43,44,55,68 },{
                81,73,100,132 },{
                  100,75,125,133 }
                };
                int row[]={
                  10,9,22,23 };
                  System.out.println(binaryCheck(mat,row));
                }
              }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute m : int := 6;
  static   operation compareRow( a1 : Sequence(int), a2 : Sequence(int)) : int
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (     if (a1[i+1] < a2[i+1]) then     return 1 else     if (a1[i+1] > a2[i+1]) then     return -1 else skip ; )  ;     i := i + 1 ) ; 
     return 0 );
  static   operation binaryCheck( ar : Sequence(Sequence(int)), arr : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var l : int ; l := 0 ;
    var r : int ; r := m - 1 ;
     while (l <= r) do (     var mid : int ; mid := (l + r) / 2 ;
     var temp : int ; temp := compareRow(ar[mid+1], arr) ;
     if (temp = 0) then     return mid + 1 else     if (temp = 1) then     l := mid + 1 else     r := mid - 1 ; ;  ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{0,0,1,0},Sequence{10,9,22,23},Sequence{40,40,40,40},Sequence{43,44,55,68},Sequence{81,73,100,132},Sequence{100,75,125,133}} ;
     var row : Sequence(int) ; row := Sequence{10,9,22,23} ;
     OclFile["System.out"].println(binaryCheck(mat, row)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static float area(int x1,int y1,int z1,int x2,int y2,int z2){
    double a=Math.pow((y1*z2-y2*z1),2)+Math.pow((x1*z2-x2*z1),2)+Math.pow((x1*y2-x2*y1),2);
    float area=(float)Math.sqrt(a);
    area=area/2 ;
    return area ;
  }
  public static void main(String arr[]){
    int x1=-2 ;
    int y1=0 ;
    int z1=-5 ;
    int x2=1 ;
    int y2=-2 ;
    int z2=-1 ;
    float a=area(x1,y1,z1,x2,y2,z2);
    System.out.println("Area="+a);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation area( x1 : int, y1 : int, z1 : int, x2 : int, y2 : int, z2 : int) : double
  pre: true
  post: true
  activity: (     var a : double ; a := (y1 * z2 - y2 * z1)->pow(2) + (x1 * z2 - x2 * z1)->pow(2) + (x1 * y2 - x2 * y1)->pow(2) ;
     var area : double ; area := (a)->sqrt()->oclAsType(double) ;
     area := area / 2 ; 
     return area );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x1 : int ; x1 := -2 ;
     var y1 : int ; y1 := 0 ;
    var z1 : int ; z1 := -5 ;
    var x2 : int ; x2 := 1 ;
    var y2 : int ; y2 := -2 ;
    var z2 : int ; z2 := -1 ;
    var a : double ; a := area(x1, y1, z1, x2, y2, z2) ;
    OclFile["System.out"].println("Area=" + a) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  public static void main(String args[]){
    int n=7,i,j ;
    for(i=0,j=0 ; i<n ; j++){
      if(j==n+i){
        j=-1 ;
++i ;
        System.out.print("\n");
      }
      else if((i+j)>=n-1){
        System.out.print("*");
      }
      else {
        System.out.print(" ");
      }
    }
    for(int k=0 ; k<3 ; k++){
      for(int l=0 ; l<n-1+i ; l++){
        if(l<=2 ||(l<=n-1+i && l>=n-4+i)){
          System.out.print("*");
        }
        else {
          System.out.print(" ");
        }
      }
      System.out.print("\n");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 7 ;
    var i : int ;
    var j : int ;
         i := 0 ;     j := 0 ; while i < n do ( (     if (j = n + i) then (     j := -1 ; 
     i := i + 1 ; 
     OclFile["System.out"].print("\n") ) else     if ((i + j) >= n - 1) then (     OclFile["System.out"].print("*") ) else (     OclFile["System.out"].print(" ") ) ;  )  ;     j := j + 1 ) ; 
         var k : int ; k := 0 ; while k < 3 do ( (         var l : int ; l := 0 ; while l < n - 1 + i do ( (     if (l <= 2 or (l <= n - 1 + i & l >= n - 4 + i)) then (     OclFile["System.out"].print("*") ) else (     OclFile["System.out"].print(" ") ) )  ;     l := l + 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     k := k + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GFG {
  final static int MAX=100000 ;
  static boolean prime[]=new boolean[MAX+1];
  static void sieve(){
    for(int i=0 ; i<=MAX ; i++)prime[i]=true ;
    for(int p=2 ; p*p<MAX ; p++)if(prime[p]==true)for(int i=p*2 ; i<MAX ; i+=p)prime[i]=false ;
  }
  static int divCount(int n){
    int total=1 ;
    for(int p=2 ; p<=n ; p++){
      if(prime[p]){
        int count=0 ;
        if(n % p==0){
          while(n % p==0){
            n=n/p ;
            count++;
          }
          total=total*(count+1);
        }
      }
    }
    return total ;
  }
  static int findNumber(int n){
    if(n==1)return 3 ;
    int i=2 ;
    int count=0 ;
    int second=1 ;
    int first=1 ;
    while(count<=n){
      if(i % 2==0){
        first=divCount(i+1);
        count=first*second ;
      }
      else {
        second=divCount((i+1)/2);
        count=first*second ;
      }
      i++;
    }
    return i*(i-1)/2 ;
  }
  public static void main(String args[]){
    int n=4 ;
    sieve();
    System.out.println(findNumber(n));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   attribute MAX : int := 100000;
  static   attribute prime : boolean := Integer.subrange(1,MAX + 1)->collect(false);
  static   operation sieve() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i <= MAX do (     prime[i+1] := true ;  ;     i := i + 1 ) ; 
         var p : int ; p := 2 ; while p * p < MAX do (     if (prime[p+1] = true) then         var i : int ; i := p * 2 ; while i < MAX do (     prime[i+1] := false ;  ;     i := i+(p) ) ; else skip ;  ;     p := p + 1 ) );
  static   operation divCount( n : int) : int
  pre: true
  post: true
  activity: (     var total : int ; total := 1 ;
         var p : int ; p := 2 ; while p <= n do ( (     if (prime[p+1]) then (     var count : int ; count := 0 ;
     if (n mod p = 0) then (     while (n mod p = 0) do (     n := n / p ; 
     count := count + 1 ) ; 
     total := total * (count + 1) ) else skip ) else skip )  ;     p := p + 1 ) ; 
     return total );
  static   operation findNumber( n : int) : int
  pre: true
  post: true
  activity: (     if (n = 1) then     return 3 else skip ; 
     var i : int ; i := 2 ;
    var count : int ; count := 0 ;
    var second : int ; second := 1 ;
    var first : int ; first := 1 ;
    while (count <= n) do (     if (i mod 2 = 0) then (     first := divCount(i + 1) ; 
     count := first * second ) else (     second := divCount((i + 1) / 2) ; 
     count := first * second ) ;  
     i := i + 1 ) ; 
    return i * (i - 1) / 2 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 4 ;
     execute sieve() ; 
     OclFile["System.out"].println(findNumber(n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String find_Square_369(String num){
    char a,b,c,d ;
    if(num.charAt(0)=='3'){
      a='1' ;
      b='0' ;
      c='8' ;
      d='9' ;
    }
    else if(num.charAt(0)=='6'){
      a='4' ;
      b='3' ;
      c='5' ;
      d='6' ;
    }
    else {
      a='9' ;
      b='8' ;
      c='0' ;
      d='1' ;
    }
    String result="" ;
    int size=num.length();
    for(int i=1 ; i<size ; i++)result+=a ;
    result+=b ;
    for(int i=1 ; i<size ; i++)result+=c ;
    result+=d ;
    return result ;
  }
  public static void main(String[] args){
    String num_3,num_6,num_9 ;
    num_3="3333" ;
    num_6="6666" ;
    num_9="9999" ;
    String result="" ;
    result=find_Square_369(num_3);
    System.out.println("Square of "+num_3+" is : "+result);
    result=find_Square_369(num_6);
    System.out.println("Square of "+num_9+" is : "+result);
    result=find_Square_369(num_9);
    System.out.println("Square of "+num_9+" is : "+result);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation find_Square( num : String)69( num : String) : String
  pre: true
  post: true
  activity: (     var a : String ;
    var b : String ;
    var c : String ;
    var d : String ;
     if (num->at(0+1) = '3') then (     a := '1' ; 
     b := '0' ; 
     c := '8' ; 
     d := '9' ) else     if (num->at(0+1) = '6') then (     a := '4' ; 
     b := '3' ; 
     c := '5' ; 
     d := '6' ) else (     a := '9' ; 
     b := '8' ; 
     c := '0' ; 
     d := '1' ) ;  ;  
    var result : String ; result := "" ;
    var size : int ; size := num->size() ;
        var i : int ; i := 1 ; while i < size do (     result := result+(a) ;  ;     i := i + 1 ) ; 
    result := result+(b) ; 
        var i : int ; i := 1 ; while i < size do (     result := result+(c) ;  ;     i := i + 1 ) ; 
    result := result+(d) ; 
    return result 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var num_3 : String ;
    var num_6 : String ;
    var num_9 : String ;
     num_3 := "3333" ; 
    num_6 := "6666" ; 
    num_9 := "9999" ; 
    var result : String ; result := "" ;
    result := find_Square_369(num_3) ; 
    OclFile["System.out"].println("Square of " + num_3 + " is : " + result) ; 
    result := find_Square_369(num_6) ; 
    OclFile["System.out"].println("Square of " + num_9 + " is : " + result) ; 
    result := find_Square_369(num_9) ; 
    OclFile["System.out"].println("Square of " + num_9 + " is : " + result) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package gcj2015.r1 ;
import java.io.*;
import java.util.Scanner ;
public class Mushroom {
  static PrintWriter out ;
  public static void main(String[] args)throws IOException {
    String name="gcj2015/r1/A-large" ;
    Scanner s=new Scanner(new File(name+".in"));
    int count=s.nextInt();
    out=new PrintWriter(new BufferedWriter(new FileWriter(name+".out")));
    for(int cc=1 ; cc<=count ; cc++){
      out.print("Case #"+cc+": ");
      int n=s.nextInt();
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=s.nextInt();
      }
      int res1=solve1(n,a);
      int res2=solve2(n,a);
      out.print(res1);
      out.print(' ');
      out.print(res2);
      out.println();
    }
    out.close();
  }
  static int solve1(int n,int[] a){
    int res=0 ;
    for(int i=0 ; i<n-1 ; i++){
      res+=Math.max(a[i]-a[i+1],0);
    }
    return res ;
  }
  static int solve2(int n,int[] a){
    int res=0 ;
    int max=0 ;
    for(int i=0 ; i<n-1 ; i++){
      max=Math.max(a[i]-a[i+1],max);
    }
    for(int i=0 ; i<n-1 ; i++){
      res+=Math.min(a[i],max);
    }
    return res ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Mushroom {
  static   attribute out : OclFile;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var name : String ; name := "gcj2015/r1/A-large" ;
     var s : OclFile ; s := OclFile.newOclFile_Read(OclFile(name + ".in")) ;
    var count : int ; count := s.getCurrent()->toInteger() ;
    out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(name + ".out"))) ; 
        var cc : int ; cc := 1 ; while cc <= count do ( (     skip ; 
     var n : int ; n := s.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := s.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var res1 : int ; res1 := solve1(n, a) ;
    var res2 : int ; res2 := solve2(n, a) ;
    skip ; 
    skip ; 
    skip ; 
    skip ; 
 )  ;     cc := cc + 1 ) ; 
    skip ; 
 );
  static   operation solve1( n : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
         var i : int ; i := 0 ; while i < n - 1 do ( (     res := res+(Set{a[i+1] - a[i + 1+1], 0}->max()) )  ;     i := i + 1 ) ; 
     return res );
  static   operation solve2( n : int, a : Sequence(int)) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     var max : int ; max := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     max := Set{a[i+1] - a[i + 1+1], max}->max() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n - 1 do ( (     res := res+(Set{a[i+1], max}->min()) )  ;     i := i + 1 ) ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=sc.nextInt();
    int[] L=new int[N*2];
    int all=0 ;
    for(int i=0 ; i<N*2 ; i++){
      L[i]=sc.nextInt();
      if(i % 2!=0){
        all+=L[i]-L[i-1]+1 ;
      }
    }
    System.out.println(all);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := sc.getCurrent()->toInteger() ;
    var L : Sequence(int) ; L := Integer.subrange(1,N * 2)->collect(0) ;
    var all : int ; all := 0 ;
        var i : int ; i := 0 ; while i < N * 2 do ( (     L[i+1] := sc.getCurrent()->toInteger() ; 
     if (i mod 2 /= 0) then (     all := all+(L[i+1] - L[i - 1+1] + 1) ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(all) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.InputStreamReader ;
import java.io.PrintWriter ;
import java.util.Scanner ;
import java.util.StringTokenizer ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt();
    long res=0 ;
    for(int i=0 ; i<n ; i++){
      int l=in.nextInt();
      int r=in.nextInt();
      res+=r-l+1 ;
    }
    System.out.println(res);
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(InputStream in){
      br=new BufferedReader(new InputStreamReader(in));
      st=new StringTokenizer("");
    }
    public String next()throws IOException {
      if(! st.hasMoreTokens()){
        st=new StringTokenizer(br.readLine());
        return next();
      }
      return st.nextToken();
    }
    public int nextInt()throws IOException {
      return Integer.parseInt(next());
    }
    public double nextDouble()throws NumberFormatException,IOException {
      return Double.parseDouble(next());
    }
    public long nextLong()throws IOException {
      return Long.parseLong(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var res : long ; res := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var l : int ; l := in.getCurrent()->toInteger() ;
     var r : int ; r := in.getCurrent()->toInteger() ;
     res := res+(r - l + 1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner( in : OclFile) : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) ; 
     st := OclIterator.newOclIterator_String("") );
   operation next() : String
  pre: true
  post: true
  activity: (     if (not(st.hasNext())) then (     st := OclIterator.newOclIterator_String(br.readLine()) ; 
     return next() ) else skip ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
public class Main {
  static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  public static void main(String[] args)throws Exception {
    int N=Integer.parseInt(br.readLine().trim());
    int total=0 ;
    int[] lr ;
    for(int i=0 ; i<N ; i++){
      lr=inputval();
      total+=lr[1]-lr[0]+1 ;
    }
    System.out.println(total);
  }
  static int[] inputval()throws Exception {
    String[] strarray=br.readLine().trim().split(" ");
    int[] intarray=new int[strarray.length];
    for(int i=0 ; i<intarray.length ; i++){
      intarray[i]=Integer.parseInt(strarray[i]);
    }
    return intarray ;
  }
  static void array_sout(int[][] array){
    for(int i=0 ; i<array.length ; i++){
      for(int j=0 ; j<array[0] .length ; j++){
        System.out.print(array[i][j]+" ");
      }
      System.out.println();
    }
  }
  static void array_sout(int[] array){
    for(int i=0 ; i<array.length ; i++){
      System.out.print(array[i]+" ");
    }
    System.out.println();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := (br.readLine()->trim())->toInteger() ;
     var total : int ; total := 0 ;
    var lr : Sequence(int) ;
        var i : int ; i := 0 ; while i < N do ( (     lr := inputval() ; 
     total := total+(lr[1+1] - lr[0+1] + 1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 );
  static   operation inputval() : Sequence(int)
  pre: true
  post: true
  activity: (     var strarray : Sequence(String) ; strarray := br.readLine()->trim()->split(" ") ;
     var intarray : Sequence(int) ; intarray := Integer.subrange(1,strarray->size())->collect(0) ;
         var i : int ; i := 0 ; while i < intarray->size() do ( (     intarray[i+1] := (strarray[i+1])->toInteger() )  ;     i := i + 1 ) ; 
     return intarray );
  static   operation array_sout( array : Sequence(Sequence(int))) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < array->size() do ( (         var j : int ; j := 0 ; while j < array[0+1]->size() do ( (     OclFile["System.out"].print(array[i+1][j+1] + " ") )  ;     j := j + 1 ) ; 
     OclFile["System.out"].println() )  ;     i := i + 1 ) );
  static   operation array_sout( array : Sequence(int)) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < array->size() do ( (     OclFile["System.out"].print(array[i+1] + " ") )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class ProblemB {
  static boolean vis[];
  static ArrayList<Integer>graph[];
  static int counter=0 ;
  public static void main(String[] args)throws Exception {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb=new StringBuilder();
    int test=Integer.parseInt(br.readLine());
    while(test-->0){
      String line[]=br.readLine().split(" ");
      long arr[]=new long[3];
      long sum=0 ;
      for(int i=0 ; i<3 ; i++){
        arr[i]=Long.parseLong(line[i]);
        sum+=arr[i];
      }
      System.out.println(sum/2);
    }
    System.out.println(sb);
  }
  public static void go(int root,int arr[]){
    if(vis[root]){
      arr[root]=counter ;
      return ;
    }
    vis[root]=true ;
    counter++;
    for(int i=0 ; i<graph[root] .size(); i++){
      int child=graph[root] .get(i);
      go(child,arr);
      arr[child]=counter ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class ProblemB {
  static   attribute vis : Sequence(boolean);
  static   attribute graph : Sequence(Sequence(int));
  static   attribute counter : int := 0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var sb : String ; sb := StringLib.newString() ;
    var test : int ; test := (br.readLine())->toInteger() ;
        while (test > 0) do (        test := test - 1 ;     skip ; (     var line : Sequence(String) ; line := br.readLine()->split(" ") ;
     var arr : Sequence(long) ; arr := Integer.subrange(1,3)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < 3 do ( (     arr[i+1] := (line[i+1])->toLong() ; 
     sum := sum+(arr[i+1]) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum / 2) ; 
 ) ;  ) ;  
    OclFile["System.out"].println(sb) ; 
 );
  static   operation go( root : int, arr : Sequence(int)) : void
  pre: true
  post: true
  activity: (     if (vis[root+1]) then (     arr[root+1] := counter ; 
     return ) else skip ; 
     vis[root+1] := true ; 
     counter := counter + 1 ; 
         var i : int ; i := 0 ; while i < graph[root+1]->size() do ( (     var child : int ; child := graph[root+1]->at(i+1) ;
     execute go(child, arr) ; 
     arr[child+1] := counter )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.BigInteger ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String nyuA=sc.nextLine();
    int n=Integer.parseInt(nyuA);
    boolean[] list=new boolean[100005];
    for(int i=0 ; i<n ; i++){
      String[] s=sc.nextLine().split(" ");
      int be=Integer.parseInt(s[0]);
      int ed=Integer.parseInt(s[1]);
      for(int j=be ; j<=ed ; j++)list[j]=true ;
    }
    int res=0 ;
    for(int i=0 ; i<list.length ; i++){
      if(list[i])res++;
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var nyuA : String ; nyuA := sc.nextLine() ;
    var n : int ; n := (nyuA)->toInteger() ;
    var list : Sequence(boolean) ; list := Integer.subrange(1,100005)->collect(false) ;
        var i : int ; i := 0 ; while i < n do ( (     var s : Sequence(String) ; s := sc.nextLine()->split(" ") ;
     var be : int ; be := (s[0+1])->toInteger() ;
     var ed : int ; ed := (s[1+1])->toInteger() ;
         var j : int ; j := be ; while j <= ed do (     list[j+1] := true ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
        var i : int ; i := 0 ; while i < list->size() do ( (     if (list[i+1]) then     res := res + 1 ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    boolean[] isSitting=new boolean[100001];
    for(int i=0 ; i<N ; i++){
      int l=Integer.parseInt(sc.next());
      int r=Integer.parseInt(sc.next());
      for(int j=l ; j<=r ; j++){
        if(isSitting[j]==false){
          isSitting[j]=true ;
        }
      }
    }
    int ans=0 ;
    for(int i=1 ; i<isSitting.length ; i++){
      if(isSitting[i]){
        ans++;
      }
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var isSitting : Sequence(boolean) ; isSitting := Integer.subrange(1,100001)->collect(false) ;
        var i : int ; i := 0 ; while i < N do ( (     var l : int ; l := (sc.getCurrent())->toInteger() ;
     var r : int ; r := (sc.getCurrent())->toInteger() ;
         var j : int ; j := l ; while j <= r do ( (     if (isSitting[j+1] = false) then (     isSitting[j+1] := true ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 1 ; while i < isSitting->size() do ( (     if (isSitting[i+1]) then (     ans := ans + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Ishu {
  static Scanner scan=new Scanner(System.in);
  static BufferedWriter output=new BufferedWriter(new OutputStreamWriter(System.out));
  static void tc()throws Exception {
    int n=scan.nextInt();
    long k=scan.nextLong();
    int i,j ;
    int LOG=0 ;
    while((1l<<(LOG+1))<k)++LOG ;
    if(LOG>n-1 ||(LOG==n-1 &&(1l<<LOG)<k)){
      output.write("-1\n");
      output.flush();
      return ;
    }
    int remain=n ;
    int next=1 ;
    int[] ans=new int[n];
    int pos=0 ;
    while(pos<n){
      int beg=next ;
      int cur_rem=remain-2 ;
      while(k>1){
        LOG=0 ;
        while((1l<<LOG)<k)++LOG ;
        if(LOG>cur_rem){
          k-=1l<<cur_rem ;
--cur_rem ;
++beg ;
        }
        else break ;
      }
      int next_next=beg+1 ;
      while(beg>=next){
        ans[pos++]=beg ;
--beg ;
--remain ;
      }
      next=next_next ;
    }
    for(i=0 ; i<n ; ++i)output.write(ans[i]+" ");
    output.write("\n");
    output.flush();
  }
  public static void main(String[] args)throws Exception {
    int t=1 ;
    t=scan.nextInt();
    while(t-->0)tc();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Ishu {
  static   attribute scan : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute output : OclFile := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"]));
  static   operation tc() : void
  pre: true
  post: true
  activity: (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var k : long ; k := scan.getCurrent()->toLong() ;
    var i : int ;
    var j : int ;
    var LOG : int ; LOG := 0 ;
    while (((1l*(2->pow((LOG + 1))))->oclAsType(long)) < k) do     LOG := LOG + 1 ; ; 
    if (LOG > n - 1 or (LOG = n - 1 & ((1l*(2->pow(LOG)))->oclAsType(long)) < k)) then (     skip ; 
     skip ; 
     return ) else skip ; 
    var remain : int ; remain := n ;
    var next : int ; next := 1 ;
    var ans : Sequence(int) ; ans := Integer.subrange(1,n)->collect(0) ;
    var pos : int ; pos := 0 ;
    while (pos < n) do (     var beg : int ; beg := next ;
     var cur_rem : int ; cur_rem := remain - 2 ;
    while (k > 1) do (     LOG := 0 ; 
     while (((1l*(2->pow(LOG)))->oclAsType(long)) < k) do     LOG := LOG + 1 ; ; 
     if (LOG > cur_rem) then (     k := k-((1l*(2->pow(cur_rem)))->oclAsType(long)) ; 
     cur_rem := cur_rem - 1 ; 
     beg := beg + 1 ) else     break ) ; 
    var next_next : int ; next_next := beg + 1 ;
    while (beg >= next) do (      ans[pos+1] := beg  ; pos := pos + 1 ; 
     beg := beg - 1 ; 
     remain := remain - 1 ) ; 
    next := next_next ; 
 ) ; 
        i := 0 ; while i < n do (     skip ;  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var t : int ; t := 1 ;
     t := scan.getCurrent()->toInteger() ; 
         while (t > 0) do (        t := t - 1 ;     skip ;     execute tc() ; ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
  public void run(java.io.InputStream in,java.io.PrintStream out){
    java.util.Scanner sc=new java.util.Scanner(in);
    int n ;
    int[] h ;
    int m,i,j ;
    long sum ;
    n=sc.nextInt();
    h=new int[n];
    for(i=0 ; i<n ; i++)h[i]=sc.nextInt();
    sum=1 ;
    m=n ;
    for(i=1 ; m>0 ; i++){
      if(m<=i*4)break ;
      else sum+=(long)(i*4);
      for(j=0 ; j<n ; j++)if(--h[j]==0)m--;
    }
    for(i=0 ; i<n ; i++)if(h[i]>0)sum+=(long)h[i];
    out.println(sum);
    sc.close();
  }
  public static void main(String[] args){
(new Main()).run(System.in,System.out);
  }
}
------------------------------------------------------------
OCL File:
---------
class Main {
   operation run( in : InputStream, out : PrintStream) : void
  pre: true
  post: true
  activity: (     var sc : Scanner ; sc := Scanner.newScanner(in) ;
     var n : int ;
    var h : Sequence(int) ;
    var m : int ;
    var i : int ;
    var j : int ;
    var sum : long ;
    n := sc.nextInt() ; 
    h := Integer.subrange(1,n)->collect(0) ; 
        i := 0 ; while i < n do (     h[i+1] := sc.nextInt() ;  ;     i := i + 1 ) ; 
    sum := 1 ; 
    m := n ; 
        i := 1 ; while m > 0 do ( (     if (m <= i * 4) then     break else     sum := sum+((i * 4)->oclAsType(long)) ; ;  
         j := 0 ; while j < n do (     if ((h[j+1] - 1) = 0) then     m := m - 1 ; else skip ;  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        i := 0 ; while i < n do (     if (h[i+1] > 0) then     sum := sum+(h[i+1]->oclAsType(long)) ; else skip ;  ;     i := i + 1 ) ; 
    out.println(sum) ; 
    sc.close() ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     (Main.newMain()).run(OclFile["System.in"], OclFile["System.out"]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
public class Main {
  Scanner sc=new Scanner(in);
  void reverse(long[] a){
    int i=0,j=a.length-1 ;
    long temp ;
    while(i<j){
      temp=a[i];
      a[i]=a[j];
      a[j]=temp ;
      i++;
      j--;
    }
  }
  void run(){
    int n=sc.nextInt();
    long[] h=new long[n];
    for(int i=0 ; i<n ; i++)h[i]=sc.nextLong();
    Arrays.sort(h);
    reverse(h);
    int count=-1 ;
    long ans=0 ;
    for(int i=0 ; i<n ; i++){
      if(i % 4==0)count++;
      ans+=h[i]-min(h[i],count);
    }
    out.println(ans+1);
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(in);
   operation reverse( a : Sequence(long)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var j : int ; j := a->size() - 1 ;
     var temp : long ;
     while (i < j) do (     temp := a[i+1] ; 
     a[i+1] := a[j+1] ; 
    a[j+1] := temp ; 
    i := i + 1 ; 
    j := j - 1 ; 
 ) );
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var h : Sequence(long) ; h := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     h[i+1] := sc.getCurrent()->toLong() ;  ;     i := i + 1 ) ; 
    h := h->sort() ; 
    execute reverse(h) ; 
    var count : int ; count := -1 ;
    var ans : long ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 4 = 0) then     count := count + 1 ; else skip ; 
     ans := ans+(h[i+1] - min(h[i+1], count)) )  ;     i := i + 1 ) ; 
    out.println(ans + 1) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.IOException ;
import java.util.Arrays ;
import java.util.Collections ;
import java.util.LinkedList ;
import java.util.List ;
import java.util.PriorityQueue ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    final Scanner sc=new Scanner(System.in);
    final int n=sc.nextInt();
    PriorityQueue<Long>queue=new PriorityQueue<Long>(n,Collections.reverseOrder());
    for(int i=0 ; i<n ; i++){
      queue.add(sc.nextLong());
    }
    int loss=0 ;
    int count=0 ;
    long sum=1 ;
    while(! queue.isEmpty()){
      final long hp=queue.poll();
      sum+=Math.max(0,hp-loss);
      count++;
      if(count>=4){
        loss++;
        count=0 ;
      }
    }
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var queue : Sequence(long) ; queue := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     queue := queue->including(sc.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    var loss : int ; loss := 0 ;
    var count : int ; count := 0 ;
    var sum : long ; sum := 1 ;
    while (not(queue->isEmpty())) do (     var hp : long ; hp := queue->min() ;
     sum := sum+(Set{0, hp - loss}->max()) ; 
     count := count + 1 ; 
     if (count >= 4) then (     loss := loss + 1 ; 
     count := 0 ) else skip ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Collections ;
import java.util.Scanner ;
class Main {
  public static void main(String[] args)throws java.lang.Exception {
    int n=0 ;
    long sum=1 ;
    ArrayList<Integer>h=new ArrayList<Integer>();
    Scanner scan=new Scanner(System.in);
    n=scan.nextInt();
    for(int i=0 ; i<n ; i++)h.add(scan.nextInt());
    scan.close();
    Collections.sort(h);
    Collections.reverse(h);
    for(int i=0 ; i<n ; i++)sum+=(long)Math.max((h.get(i)-i/4),0);
    System.out.println(sum);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 0 ;
     var sum : long ; sum := 1 ;
    var h : Sequence(int) ; h := Sequence{} ;
    var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    n := scan.getCurrent()->toInteger() ; 
        var i : int ; i := 0 ; while i < n do (     h := h->including(scan.getCurrent()->toInteger()) ;  ;     i := i + 1 ) ; 
    skip ; 
    h := h->sort() ; 
    h := h->reverse() ; 
        var i : int ; i := 0 ; while i < n do (     sum := sum+(Set{(h->at(i+1) - i / 4), 0}->max()->oclAsType(long)) ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(sum) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.BufferedWriter ;
import java.io.FileReader ;
import java.io.FileWriter ;
import java.io.IOException ;
import java.io.PrintWriter ;
public class mushroom {
  public static void main(String[] args)throws IOException {
    BufferedReader buf=new BufferedReader(new FileReader("mushroom.in"));
    PrintWriter out=new PrintWriter(new BufferedWriter(new FileWriter("mushroom.out")));
    Long n=Long.parseLong(buf.readLine());
    for(int i=1 ; i<=n ; i++){
      Long m=Long.parseLong(buf.readLine());
      String[] s=buf.readLine().split(" ");
      long fsum=0 ;
      long largest=0 ;
      for(int j=1 ; j<m ; j++){
        if(Long.parseLong(s[j])-Long.parseLong(s[j-1])<0){
          fsum=fsum+Long.parseLong(s[j-1])-Long.parseLong(s[j]);
          if(Long.parseLong(s[j-1])-Long.parseLong(s[j])>largest)largest=Long.parseLong(s[j-1])-Long.parseLong(s[j]);
        }
      }
      long nsum=0 ;
      for(int j=0 ; j<m-1 ; j++){
        nsum=nsum+Math.min(Long.parseLong(s[j]),largest);
      }
      out.println("Case #"+i+": "+fsum+" "+nsum);
    }
    buf.close();
    out.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class mushroom {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var buf : OclFile ; buf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("mushroom.in"))) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("mushroom.out")))) ;
    var n : long ; n := (buf.readLine())->toLong() ;
        var i : int ; i := 1 ; while i <= n do ( (     var m : long ; m := (buf.readLine())->toLong() ;
     var s : Sequence(String) ; s := buf.readLine()->split(" ") ;
    var fsum : long ; fsum := 0 ;
    var largest : long ; largest := 0 ;
        var j : int ; j := 1 ; while j < m do ( (     if ((s[j+1])->toLong() - (s[j - 1+1])->toLong() < 0) then (     fsum := fsum + (s[j - 1+1])->toLong() - (s[j+1])->toLong() ; 
     if ((s[j - 1+1])->toLong() - (s[j+1])->toLong() > largest) then     largest := (s[j - 1+1])->toLong() - (s[j+1])->toLong() ; else skip ) else skip )  ;     j := j + 1 ) ; 
    var nsum : long ; nsum := 0 ;
        var j : int ; j := 0 ; while j < m - 1 do ( (     nsum := nsum + Set{(s[j+1])->toLong(), largest}->min() )  ;     j := j + 1 ) ; 
    skip ; 
 )  ;     i := i + 1 ) ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    int N=sc.nextInt();
    int[] H=new int[N];
    for(int i=0 ; i<N ; ++i){
      H[i]=sc.nextInt();
    }
    Arrays.sort(H);
    long ans=1 ;
    int pos=0 ;
    for(int i=1 ; ; ++i){
      while(pos<N && H[pos]<i){
++pos ;
      }
      if(pos==N)break ;
      ans+=Math.min(N-pos,4*i);
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var H : Sequence(int) ; H := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     H[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    H := H->sort() ; 
    var ans : long ; ans := 1 ;
    var pos : int ; pos := 0 ;
        var i : int ; i := 1 ; while true do ( (     while (pos < N & H[pos+1] < i) do (     pos := pos + 1 ) ; 
     if (pos = N) then     break else skip ; 
     ans := ans+(Set{N - pos, 4 * i}->min()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printPath(Vector<Integer>res,int nThNode,int kThNode){
    if(kThNode>nThNode)return ;
    res.add(kThNode);
    for(int i=0 ; i<res.size(); i++)System.out.print(res.get(i)+" ");
    System.out.print("\n");
    printPath(res,nThNode,kThNode*2);
    printPath(res,nThNode,kThNode*2+1);
    res.remove(res.size()-1);
  }
  static void printPathToCoverAllNodeUtil(int nThNode){
    Vector<Integer>res=new Vector<Integer>();
    printPath(res,nThNode,1);
  }
  public static void main(String args[]){
    int nThNode=7 ;
    printPathToCoverAllNodeUtil(nThNode);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printPath( res : Sequence(int), nThNode : int, kThNode : int) : void
  pre: true
  post: true
  activity: (     if (kThNode > nThNode) then     return else skip ; 
     res->excludes(kThNode) ; 
        var i : int ; i := 0 ; while i < res->size() do (     OclFile["System.out"].print(res->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("\n") ; 
    execute printPath(res, nThNode, kThNode * 2) ; 
    execute printPath(res, nThNode, kThNode * 2 + 1) ; 
    res := res->excludingFirst(res->size() - 1) ; 
 );
  static   operation printPathToCoverAllNodeUtil( nThNode : int) : void
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Sequence{} ;
     execute printPath(res, nThNode, 1) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var nThNode : int ; nThNode := 7 ;
     execute printPathToCoverAllNodeUtil(nThNode) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class problem1196A {
  public static void main(String[] args){
    new problem1196A().solve();
  }
  Scanner in ;
  private void solve(){
    in=new Scanner(System.in);
    int q=in.nextInt();
    while(q-->0){
      long a=in.nextLong();
      long b=in.nextLong();
      long c=in.nextLong();
      findAlisasShare(a,b,c);
    }
  }
  private void findAlisasShare(long a,long b,long c){
    long both=Math.max(a,Math.max(b,c));
    long guy=Math.min(a,Math.min(b,c));
    long girl=a+b+c-both-guy ;
    if((both-(girl-guy))% 2!=0){
--both ;
    }
    System.out.println(girl+(both-girl+guy)/2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class problem1196A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     problem1196A.newproblem1196A().solve() );
   attribute in : OclFile;
   operation solve() : void
  pre: true
  post: true
  activity: (     in := OclFile.newOclFile_Read(OclFile["System.in"]) ; 
     var q : int ; q := in.getCurrent()->toInteger() ;
         while (q > 0) do (        q := q - 1 ;     skip ; (     var a : long ; a := in.getCurrent()->toLong() ;
     var b : long ; b := in.getCurrent()->toLong() ;
     var c : long ; c := in.getCurrent()->toLong() ;
     execute findAlisasShare(a, b, c) ) ;  ) );
   operation findAlisasShare( a : long, b : long, c : long) : void
  pre: true
  post: true
  activity: (     var both : long ; both := Set{a, Set{b, c}->max()}->max() ;
     var guy : long ; guy := Set{a, Set{b, c}->min()}->min() ;
    var girl : long ; girl := a + b + c - both - guy ;
    if ((both - (girl - guy)) mod 2 /= 0) then (     both := both - 1 ) else skip ; 
    OclFile["System.out"].println(girl + (both - girl + guy) / 2) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void printFactorialNums(int n){
    int fact=1 ;
    int x=2 ;
    while(fact<=n){
      System.out.print(fact+" ");
      fact=fact*x ;
      x++;
    }
  }
  public static void main(String[] args){
    int n=100 ;
    printFactorialNums(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation printFactorialNums( n : int) : void
  pre: true
  post: true
  activity: (     var fact : int ; fact := 1 ;
     var x : int ; x := 2 ;
     while (fact <= n) do (     OclFile["System.out"].print(fact + " ") ; 
     fact := fact * x ; 
     x := x + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 100 ;
     execute printFactorialNums(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void countPair(int arr[],int n,int k){
    int cnt=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=(arr[i]+k)% k ;
    }
    int hash[]=new int[k];
    for(int i=0 ; i<n ; i++){
      hash[arr[i] ]++;
    }
    for(int i=0 ; i<k ; i++){
      cnt+=(hash[i]*(hash[i]-1))/2 ;
    }
    System.out.print(cnt+"\n");
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,4 };
      int k=2 ;
      int n=arr.length ;
      countPair(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPair( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var cnt : int ; cnt := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := (arr[i+1] + k) mod k )  ;     i := i + 1 ) ; 
    var hash : Sequence(int) ; hash := Integer.subrange(1,k)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     hash[arr[i+1]+1] := hash[arr[i+1]+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < k do ( (     cnt := cnt+((hash[i+1] * (hash[i+1] - 1)) / 2) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(cnt + "\n") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,4} ;
     var k : int ; k := 2 ;
     var n : int ; n := arr->size() ;
     execute countPair(arr, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int maxSum(int arr[],int n,int k){
    int max_sum=Integer.MIN_VALUE ;
    for(int i=0 ; i<n-k+1 ; i++){
      int current_sum=0 ;
      for(int j=0 ; j<k ; j++)current_sum=current_sum+arr[i+j];
      max_sum=Math.max(current_sum,max_sum);
    }
    return max_sum ;
  }
  public static void main(String[] args){
    int arr[]={
      1,4,2,10,2,3,1,0,20 };
      int k=4 ;
      int n=arr.length ;
      System.out.println(maxSum(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation maxSum( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var max_sum : int ; max_sum := -2147483648 ;
         var i : int ; i := 0 ; while i < n - k + 1 do ( (     var current_sum : int ; current_sum := 0 ;
         var j : int ; j := 0 ; while j < k do (     current_sum := current_sum + arr[i + j+1] ;  ;     j := j + 1 ) ; 
     max_sum := Set{current_sum, max_sum}->max() )  ;     i := i + 1 ) ; 
     return max_sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,4,2,10,2,3,1,0,20} ;
     var k : int ; k := 4 ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(maxSum(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static String makePalindrome(char[] str){
    int i=0,j=str.length-1 ;
    while(i<=j){
      if(str[i]=='*' && str[j]=='*'){
        str[i]='a' ;
        str[j]='a' ;
      }
      else if(str[j]=='*')str[j]=str[i];
      else if(str[i]=='*')str[i]=str[j];
      else if(str[i]!=str[j])return "-1" ;
      i++;
      j--;
    }
    return String.valueOf(str);
  }
  public static void main(String[] args){
    char[] str="na*an".toCharArray();
    System.out.println(makePalindrome(str));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation makePalindrome( str : Sequence(String)) : String
  pre: true
  post: true
  activity: (     var i : int ; i := 0 ;
    var j : int ; j := str->size() - 1 ;
     while (i <= j) do (     if (str[i+1] = '*' & str[j+1] = '*') then (     str[i+1] := 'a' ; 
     str[j+1] := 'a' ) else     if (str[j+1] = '*') then     str[j+1] := str[i+1] else     if (str[i+1] = '*') then     str[i+1] := str[j+1] else     if (str[i+1] /= str[j+1]) then     return "-1" else skip ; ;  ;  ;  
     i := i + 1 ; 
     j := j - 1 ) ; 
     return ((str) + "") );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var str : Sequence(String) ; str := "na*an"->characters() ;
     OclFile["System.out"].println(makePalindrome(str)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class main {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      List<Long>list=new ArrayList<>();
      for(int i=0 ; i<n ; i++){
        list.add(sc.nextLong());
      }
      long total=0 ;
      for(int i=0 ; i<n ; i++){
        if(list.get(i)>0){
          total+=list.get(i);
        }
        else if(list.get(i)<0){
          long k=Math.min(total,Math.abs(list.get(i)));
          list.set(i,(list.get(i)+k));
          total-=k ;
        }
      }
      total=0 ;
      for(int i=0 ; i<n ; i++){
        if(list.get(i)<0){
          total=total+Math.abs(list.get(i));
        }
      }
      System.out.println(total);
    }
  }
  static boolean isPrime(long n){
    if(n<=1)return false ;
    if(n<=3)return true ;
    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 ;
  }
  static long gcd(long a,long b){
    if(a==0)return b ;
    return gcd(b % a,a);
  }
  static long lcm(long a,long b){
    return(a/gcd(a,b))*b ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var list : Sequence(long) ; list := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     list := list->including(sc.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
    var total : long ; total := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (list->at(i+1) > 0) then (     total := total+(list->at(i+1)) ) else     if (list->at(i+1) < 0) then (     var k : long ; k := Set{total, if list->at(i+1) < 0 then -(list->at(i+1)) else list->at(i+1) endif}->min() ;
     list := list.setAt(i+1,(list->at(i+1) + k)) ; 
     total := total-(k) ) else skip ; )  ;     i := i + 1 ) ; 
    total := 0 ; 
        var i : int ; i := 0 ; while i < n do ( (     if (list->at(i+1) < 0) then (     total := total + if list->at(i+1) < 0 then -(list->at(i+1)) else list->at(i+1) endif ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(total) ; 
 ) ;  ) );
  static   operation isPrime( n : long) : boolean
  pre: true
  post: true
  activity: (     if (n <= 1) then     return false else skip ; 
     if (n <= 3) then     return true else skip ; 
    if (n mod 2 = 0 or n mod 3 = 0) then     return false else skip ; 
        var i : int ; i := 5 ; while i * i <= n do (     if (n mod i = 0 or n mod (i + 2) = 0) then     return false else skip ;  ;     i := i + 6 ) ; 
    return true 
 );
  static   operation gcd( a : long, b : long) : long
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return gcd(b mod a, a) );
  static   operation lcm( a : long, b : long) : long
  pre: true
  post: true
  activity: (     return (a / gcd(a, b)) * b );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
import java.io.*;
public class codeHundredSixty {
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int t=input.nextInt();
    for(int o=0 ; o<t ; o++){
      int n=input.nextInt();
      int[] arrayOne=new int[n];
      long curr=0 ;
      for(int i=0 ; i<n ; i++){
        arrayOne[i]=input.nextInt();
        curr=Math.max(curr+arrayOne[i],0);
      }
      System.out.println(curr);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeHundredSixty {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := input.getCurrent()->toInteger() ;
         var o : int ; o := 0 ; while o < t do ( (     var n : int ; n := input.getCurrent()->toInteger() ;
     var arrayOne : Sequence(int) ; arrayOne := Integer.subrange(1,n)->collect(0) ;
    var curr : long ; curr := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arrayOne[i+1] := input.getCurrent()->toInteger() ; 
     curr := Set{curr + arrayOne[i+1], 0}->max() )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(curr) ; 
 )  ;     o := o + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter pw=new PrintWriter(System.out);
    int test=in.nextInt();
    for(int t=1 ; t<=test ; t++){
      int n=in.nextInt();
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      long sum=0 ;
      long max=Long.MIN_VALUE ;
      for(int i=n-1 ; i>=0 ; i--){
        sum+=a[i];
        max=Math.max(max,sum);
      }
      pw.println(max);
    }
    pw.close();
  }
  static void debug(Object...obj){
    System.err.println(Arrays.deepToString(obj));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var test : int ; test := in.getCurrent()->toInteger() ;
        var t : int ; t := 1 ; while t <= test do ( (     var n : int ; n := in.getCurrent()->toInteger() ;
     var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var sum : long ; sum := 0 ;
    var max : long ; max := "-9223372036854775808"->toLong() ;
        var i : int ; i := n - 1 ; while i >= 0 do ( (     sum := sum+(a[i+1]) ; 
     max := Set{max, sum}->max() )  ;     i := i - 1 ) ; 
    skip ; 
 )  ;     t := t + 1 ) ; 
    skip ; 
 );
  static   operation debug( obj : Sequence(OclAny)) : void
  pre: true
  post: true
  activity: (     OclFile["System.err"].println((obj + "")) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    long a=sc.nextLong();
    long b=sc.nextLong();
    long ret=0 ;
    if((b-a)% 2==0){
      ret=(b-a)/2 ;
    }
    else {
      ret=a-1<n-b ?(a-1)+1+(b-a-1)/2 :(n-b)+1+(b-a-1)/2 ;
    }
    System.out.println(ret);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var ret : long ; ret := 0 ;
    if ((b - a) mod 2 = 0) then (     ret := (b - a) / 2 ) else (     ret := if a - 1 < n - b then (a - 1) + 1 + (b - a - 1) / 2 else (n - b) + 1 + (b - a - 1) / 2 endif ) ;  
    OclFile["System.out"].println(ret) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Mushroom {
    final static String PROBLEM_NAME = "mushroom";
    final static String WORK_DIR = "D:\\GCJ\\" + PROBLEM_NAME + "\\";
    void solve(Scanner sc, PrintWriter pw) {
        int N = sc.nextInt();
        int[] A = new int[N];
        for (int i = 0; i < N; i++) {
            A[i] = sc.nextInt();
        }
        int ans1 = 0;
        int speed = 0;
        for (int i = 0; i + 1 < N; i++) {
            if (A[i + 1] < A[i]) {
                ans1 += A[i] - A[i + 1];
                speed = Math.max(speed, A[i] - A[i + 1]);
            }
        }
        int ans2 = 0;
        for (int i = 0; i + 1 < N; i++) {
            ans2 += Math.min(A[i], speed);
        }
        pw.println(ans1 + " " + ans2);
    }
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(new FileReader(WORK_DIR + "input.txt"));
        PrintWriter pw = new PrintWriter(new FileWriter(WORK_DIR + "output.txt"));
        int caseCnt = sc.nextInt();
        for (int caseNum = 0; caseNum < caseCnt; caseNum++) {
            System.out.println("Processing test case " + (caseNum + 1));
            pw.print("Case #" + (caseNum + 1) + ": ");
            new Mushroom().solve(sc, pw);
        }
        pw.flush();
        pw.close();
        sc.close();
    }
}

------------------------------------------------------------
OCL File:
---------
 class Mushroom {
  static   attribute PROBLEM_NAME : String := "mushroom";
  static   attribute WORK_DIR : String := "D:\\GCJ\\" + PROBLEM_NAME + "\\";
   operation solve( sc : OclFile, pw : OclFile) : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.nextInt() ;
     var A : Sequence(int) ; A := Integer.subrange(1,N)->collect(0) ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := sc.nextInt() )  ;     i := i + 1 ) ; 
    var ans1 : int ; ans1 := 0 ;
    var speed : int ; speed := 0 ;
        var i : int ; i := 0 ; while i + 1 < N do ( (     if (A[i + 1+1] < A[i+1]) then (     ans1 := ans1+(A[i+1] - A[i + 1+1]) ; 
     speed := Set{speed, A[i+1] - A[i + 1+1]}->max() ) else skip )  ;     i := i + 1 ) ; 
    var ans2 : int ; ans2 := 0 ;
        var i : int ; i := 0 ; while i + 1 < N do ( (     ans2 := ans2+(Set{A[i+1], speed}->min()) )  ;     i := i + 1 ) ; 
    pw.println(ans1 + " " + ans2) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile.newOclFile_Read(WORK_DIR + "input.txt")) ;
     var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(WORK_DIR + "output.txt")) ;
    var caseCnt : int ; caseCnt := sc.getCurrent()->toInteger() ;
        var caseNum : int ; caseNum := 0 ; while caseNum < caseCnt do ( (     OclFile["System.out"].println("Processing test case " + (caseNum + 1)) ; 
     skip ; 
     Mushroom.newMushroom().solve(sc, pw) )  ;     caseNum := caseNum + 1 ) ; 
    skip ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
  public static void main(String[] args)throws Exception {
    IO io=new IO();
    PrintWriter out=new PrintWriter(System.out);
    Solver sr=new Solver();
    sr.solve(io,out);
    out.flush();
    out.close();
  }
  static class Solver {
    void solve(IO io,PrintWriter out){
      int i,j ;
      long n=io.nextLong();
      long a=io.nextLong();
      long b=io.nextLong();
      long s=Long.MAX_VALUE ;
      if((b-a)% 2==0){
        s=(b-a)/2 ;
      }
      long n1=a-1 ;
      n1+=((b-a)-1)/2 ;
      n1+=1 ;
      long n2=n-b ;
      n2+=(n-(a+n-b+1))/2 ;
      n2+=1 ;
      s=Math.min(s,n1);
      out.print(Math.min(s,n2));
    }
  }
  static class IO {
    BufferedReader reader ;
    StringTokenizer tokenizer ;
    public IO(){
      reader=new BufferedReader(new InputStreamReader(System.in));
      tokenizer=null ;
    }
    public String next(){
      while(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public String nextLine(){
      String s="" ;
      try {
        s=reader.readLine();
      }
      catch(IOException e){
        throw new RuntimeException(e);
      }
      return s ;
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    double nextDouble(){
      return Double.parseDouble(next());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var io : IO ; io := IO.newIO() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var sr : Solver ; sr := Solver.newSolver() ;
    sr.solve(io, out) ; 
    skip ; 
    skip ; 
 );
  static class Solver {
   operation solve( io : IO, out : OclFile) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var j : int ;
     var n : long ; n := io.nextLong() ;
    var a : long ; a := io.nextLong() ;
    var b : long ; b := io.nextLong() ;
    var s : long ; s := "9223372036854775807"->toLong() ;
    if ((b - a) mod 2 = 0) then (     s := (b - a) / 2 ) else skip ; 
    var n1 : long ; n1 := a - 1 ;
    n1 := n1+(((b - a) - 1) / 2) ; 
    n1 := n1+(1) ; 
    var n2 : long ; n2 := n - b ;
    n2 := n2+((n - (a + n - b + 1)) / 2) ; 
    n2 := n2+(1) ; 
    s := Set{s, n1}->min() ; 
    skip ; 
 );
}
  static class IO {
   attribute reader : OclFile;
   attribute tokenizer : OclIterator;
   static operation newIO() : IO
  pre: true
  post: true
  activity:
  ( var self : IO ;
    self := createIO();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     tokenizer := null );
   operation next() : String
  pre: true
  post: true
  activity: (     while (tokenizer = null or not(tokenizer.hasNext())) do (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error ProgramException(e) )
 ) ; 
     return tokenizer.next() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var s : String ; s := "" ;
     try (     s := reader.readLine() )   catch (e : IOException) do (     error ProgramException(e) )
     return s );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GfG {
  static void findTime(String T,int K){
    int minutes=((T.charAt(0)-'0')*10+T.charAt(1)-'0')*60+((T.charAt(3)-'0')*10+T.charAt(4)-'0');
    minutes+=K ;
    int hour=(minutes/60)% 24 ;
    int min=minutes % 60 ;
    if(hour<10){
      System.out.print("0"+hour+":");
    }
    else {
      System.out.print(hour+":");
    }
    if(min<10){
      System.out.println("0"+min);
    }
    else {
      System.out.println(min);
    }
  }
  public static void main(String[] args){
    String T="21:39" ;
    int K=43 ;
    findTime(T,K);
  }
}
------------------------------------------------------------
OCL File:
---------
class GfG {
  static   operation findTime( T : String, K : int) : void
  pre: true
  post: true
  activity: (     var minutes : int ; minutes := ((T->at(0+1) - ('0')->char2byte()) * 10 + T->at(1+1) - ('0')->char2byte()) * 60 + ((T->at(3+1) - ('0')->char2byte()) * 10 + T->at(4+1) - ('0')->char2byte()) ;
     minutes := minutes+(K) ; 
    var hour : int ; hour := (minutes / 60) mod 24 ;
    var min : int ; min := minutes mod 60 ;
    if (hour < 10) then (     OclFile["System.out"].print("0" + hour + ":") ) else (     OclFile["System.out"].print(hour + ":") ) ;  
    if (min < 10) then (     OclFile["System.out"].println("0" + min) ) else (     OclFile["System.out"].println(min) ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var T : String ; T := "21:39" ;
     var K : int ; K := 43 ;
     execute findTime(T, K) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int N=Integer.parseInt(sc.next());
    int M=Integer.parseInt(sc.next());
    int[] k=new int[M];
    int[] p=new int[M];
    int[][] s=new int[M][];
    for(int i=0 ; i<M ; i++){
      k[i]=Integer.parseInt(sc.next());
      int[] S=new int[k[i] ];
      for(int j=0 ; j<k[i]; j++){
        S[j]=Integer.parseInt(sc.next());
      }
      s[i]=S ;
    }
    int ans=0 ;
    for(int i=0 ; i<M ; i++){
      p[i]=Integer.parseInt(sc.next());
    }
    for(int i=0 ; i<Math.pow(2,N); i++){
      int[] swit=new int[N];
      boolean hantei=true ;
      for(int j=0 ; j<N ; j++){
        if((1 & i>>j)==1){
          swit[j]+=1 ;
        }
        else {
          swit[j]+=0 ;
        }
      }
      for(int x=0 ; x<M ; x++){
        int count=0 ;
        for(int y=0 ; y<k[x]; y++){
          if(swit[s[x][y]-1]==1){
            count++;
          }
        }
        if(count % 2!=p[x]){
          hantei=false ;
        }
      }
      if(hantei)ans++;
    }
    System.out.println(ans);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := (sc.getCurrent())->toInteger() ;
    var M : int ; M := (sc.getCurrent())->toInteger() ;
    var k : Sequence(int) ; k := Integer.subrange(1,M)->collect(0) ;
    var p : Sequence(int) ; p := Integer.subrange(1,M)->collect(0) ;
    var s : Sequence(Sequence(int)) ; s := Integer.subrange(1,M)->collect(Sequence{}) ;
        var i : int ; i := 0 ; while i < M do ( (     k[i+1] := (sc.getCurrent())->toInteger() ; 
     var S : Sequence(int) ; S := Integer.subrange(1,k[i+1])->collect(0) ;
         var j : int ; j := 0 ; while j < k[i+1] do ( (     S[j+1] := (sc.getCurrent())->toInteger() )  ;     j := j + 1 ) ; 
     s[i+1] := S )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < M do ( (     p[i+1] := (sc.getCurrent())->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < 2->pow(N) do ( (     var swit : Sequence(int) ; swit := Integer.subrange(1,N)->collect(0) ;
     var hantei : boolean ; hantei := true ;
        var j : int ; j := 0 ; while j < N do ( (     if ((MathLib.bitwiseAnd(1,(i/(2->pow(j)))->oclAsType(long))) = 1) then (     swit[j+1] := swit[j+1]+(1) ) else (     swit[j+1] := swit[j+1]+(0) ) )  ;     j := j + 1 ) ; 
        var x : int ; x := 0 ; while x < M do ( (     var count : int ; count := 0 ;
         var y : int ; y := 0 ; while y < k[x+1] do ( (     if (swit[s[x+1][y+1] - 1+1] = 1) then (     count := count + 1 ) else skip )  ;     y := y + 1 ) ; 
     if (count mod 2 /= p[x+1]) then (     hantei := false ) else skip )  ;     x := x + 1 ) ; 
    if (hantei) then     ans := ans + 1 ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.InputStream ;
import java.io.PrintStream ;
import java.util.*;
public class Main {
  public static void main(String[] args){
    solve(System.in,System.out);
  }
  static void solve(InputStream is,PrintStream os){
    Scanner sc=new Scanner(is);
    long n=sc.nextLong();
    long a=sc.nextLong();
    long b=sc.nextLong();
    if(a>b){
      long tmp=a ;
      a=b ;
      b=tmp ;
    }
    long distance=b-a ;
    if(distance % 2==0){
      os.println(distance/2);
      return ;
    }
    if(a-1<n-b){
      os.println(((a-1)+(b-1)+1)/2);
    }
    else {
      os.println(((n-a)+(n-b)+1)/2);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute solve(OclFile["System.in"], OclFile["System.out"]) );
  static   operation solve( is : OclFile, os : OclFile) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(is) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    if (a > b) then (     var tmp : long ; tmp := a ;
     a := b ; 
     b := tmp ) else skip ; 
    var distance : long ; distance := b - a ;
    if (distance mod 2 = 0) then (     os.println(distance / 2) ; 
     return ) else skip ; 
    if (a - 1 < n - b) then (     os.println(((a - 1) + (b - 1) + 1) / 2) ) else (     os.println(((n - a) + (n - b) + 1) / 2) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayDeque ;
import java.util.Arrays ;
import java.util.Comparator ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.List ;
import java.util.Map ;
import java.util.Queue ;
import java.util.Scanner ;
import java.util.Set ;
public class Main {
  public static void main(String[] args){
    execute11_1();
  }
  private static void execute11_1(){
    try(Scanner sc=new Scanner(System.in)){
      long n=sc.nextLong();
      long a=sc.nextLong();
      long b=sc.nextLong();
      long ans=0 ;
      if((b-a)% 2!=0){
        if(a-1>n-b){
          long r=n-b+1 ;
          a+=r ;
          b=n ;
          ans=r+(b-a)/2 ;
        }
        else {
          long r=a ;
          b-=r ;
          a=1 ;
          ans=r+(b-a)/2 ;
        }
      }
      else {
        ans=(b-a)/2 ;
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute execute11execute11execute11    execute execute11execute11execute11    execute execute11execute11execute11_1()()() ; 
()()() ;()()() );
  static   operation execute11_1() : void
  pre: true
  post: true
  activity: (     try (    var sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]) ;
 (     var n : long ; n := sc.getCurrent()->toLong() ;
     var a : long ; a := sc.getCurrent()->toLong() ;
    var b : long ; b := sc.getCurrent()->toLong() ;
    var ans : long ; ans := 0 ;
    if ((b - a) mod 2 /= 0) then (     if (a - 1 > n - b) then (     var r : long ; r := n - b + 1 ;
     a := a+(r) ; 
     b := n ; 
     ans := r + (b - a) / 2 ) else (     var r : long ; r := a ;
     b := b-(r) ; 
     a := 1 ; 
     ans := r + (b - a) / 2 ) ) else (     ans := (b - a) / 2 ) ;  
    OclFile["System.out"].println(ans) ; 
 ))  );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  static Scanner sc=new Scanner(System.in);
  public static void main(String[] args){
    long n=sc.nextLong();
    long a=sc.nextLong();
    long b=sc.nextLong();
    if((b-a)% 2==0){
      System.out.println((b-a)/2);
    }
    else {
      long side1=a ;
      long aCopy=1 ;
      long bCopy=b-a ;
      side1+=(bCopy-aCopy)/2 ;
      long sideN=n-b+1 ;
      aCopy=a+(n-b+1);
      bCopy=n ;
      sideN+=(bCopy-aCopy)/2 ;
      System.out.println(Math.min(side1,sideN));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := sc.getCurrent()->toLong() ;
     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
     if ((b - a) mod 2 = 0) then (     OclFile["System.out"].println((b - a) / 2) ) else (     var side1 : long ; side1 := a ;
     var aCopy : long ; aCopy := 1 ;
    var bCopy : long ; bCopy := b - a ;
    side1 := side1+((bCopy - aCopy) / 2) ; 
    var sideN : long ; sideN := n - b + 1 ;
    aCopy := a + (n - b + 1) ; 
    bCopy := n ; 
    sideN := sideN+((bCopy - aCopy) / 2) ; 
    OclFile["System.out"].println(Set{side1, sideN}->min()) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static final long INF=(long)1e11 ;
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=Integer.parseInt(sc.next());
    int b=Integer.parseInt(sc.next());
    int q=Integer.parseInt(sc.next());
    TreeSet<Long>s=new TreeSet<>();
    TreeSet<Long>t=new TreeSet<>();
    s.add(INF);
    s.add(-INF);
    t.add(INF);
    t.add(-INF);
    for(int i=0 ; i<a ; i++){
      s.add(Long.parseLong(sc.next()));
    }
    for(int i=0 ; i<b ; i++){
      t.add(Long.parseLong(sc.next()));
    }
    long[] sa=new long[2];
    long[] ta=new long[2];
    for(int i=0 ; i<q ; i++){
      long x=Long.parseLong(sc.next());
      sa[0]=s.lower(x);
      sa[1]=s.higher(x);
      ta[0]=t.lower(x);
      ta[1]=t.higher(x);
      long ans=INF ;
      for(int j=0 ; j<4 ; j++){
        long jinja=sa[j & 1];
        long tera=ta[j>>1];
        long sum=Math.abs(jinja-tera)+Math.min(Math.abs(x-jinja),Math.abs(x-tera));
        ans=Math.min(ans,sum);
      }
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute INF : long := 1e11->oclAsType(long);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := (sc.getCurrent())->toInteger() ;
    var b : int ; b := (sc.getCurrent())->toInteger() ;
    var q : int ; q := (sc.getCurrent())->toInteger() ;
    var s : Set(long) ; s := Set{} ;
    var t : Set(long) ; t := Set{} ;
    s := s->including(INF) ; 
    s := s->including(-INF) ; 
    t := t->including(INF) ; 
    t := t->including(-INF) ; 
        var i : int ; i := 0 ; while i < a do ( (     s := s->including((sc.getCurrent())->toLong()) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < b do ( (     t := t->including((sc.getCurrent())->toLong()) )  ;     i := i + 1 ) ; 
    var sa : Sequence(long) ; sa := Integer.subrange(1,2)->collect(0) ;
    var ta : Sequence(long) ; ta := Integer.subrange(1,2)->collect(0) ;
        var i : int ; i := 0 ; while i < q do ( (     var x : long ; x := (sc.getCurrent())->toLong() ;
     sa[0+1] := s.lower(x) ; 
    sa[1+1] := s.higher(x) ; 
    ta[0+1] := t.lower(x) ; 
    ta[1+1] := t.higher(x) ; 
    var ans : long ; ans := INF ;
        var j : int ; j := 0 ; while j < 4 do ( (     var jinja : long ; jinja := sa[MathLib.bitwiseAnd(j,1)+1] ;
     var tera : long ; tera := ta[(j/(2->pow(1)))->oclAsType(long)+1] ;
     var sum : long ; sum := if jinja - tera < 0 then -(jinja - tera) else jinja - tera endif + Set{if x - jinja < 0 then -(x - jinja) else x - jinja endif, if x - tera < 0 then -(x - tera) else x - tera endif}->min() ;
     ans := Set{ans, sum}->min() )  ;     j := j + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int a=sc.nextInt();
    int b=sc.nextInt();
    int q=sc.nextInt();
    long[] s=new long[a];
    long[] t=new long[b];
    for(int i=0 ; i<a ; i++){
      s[i]=sc.nextLong();
    }
    for(int i=0 ; i<b ; i++){
      t[i]=sc.nextLong();
    }
    for(int i=0 ; i<q ; i++){
      long p=sc.nextLong();
      int si=-Arrays.binarySearch(s,p)-1 ;
      int ti=-Arrays.binarySearch(t,p)-1 ;
      long min=Long.MAX_VALUE ;
      if(si>0 && ti>0){
        min=Math.min(min,Math.max(p-s[si-1],p-t[ti-1]));
      }
      if(si>0 && ti<b){
        min=Math.min(min,p-s[si-1]+t[ti]-p+Math.min(p-s[si-1],t[ti]-p));
      }
      if(si<a && ti<b){
        min=Math.min(min,Math.max(s[si]-p,t[ti]-p));
      }
      if(si<a && ti>0){
        min=Math.min(min,s[si]-p+p-t[ti-1]+Math.min(s[si]-p,p-t[ti-1]));
      }
      System.out.println(min);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
    var q : int ; q := sc.getCurrent()->toInteger() ;
    var s : Sequence(long) ; s := Integer.subrange(1,a)->collect(0) ;
    var t : Sequence(long) ; t := Integer.subrange(1,b)->collect(0) ;
        var i : int ; i := 0 ; while i < a do ( (     s[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < b do ( (     t[i+1] := sc.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < q do ( (     var p : long ; p := sc.getCurrent()->toLong() ;
     var si : int ; si := -(s->indexOf(p) - 1) - 1 ;
    var ti : int ; ti := -(t->indexOf(p) - 1) - 1 ;
    var min : long ; min := "9223372036854775807"->toLong() ;
    if (si > 0 & ti > 0) then (     min := Set{min, Set{p - s[si - 1+1], p - t[ti - 1+1]}->max()}->min() ) else skip ; 
    if (si > 0 & ti < b) then (     min := Set{min, p - s[si - 1+1] + t[ti+1] - p + Set{p - s[si - 1+1], t[ti+1] - p}->min()}->min() ) else skip ; 
    if (si < a & ti < b) then (     min := Set{min, Set{s[si+1] - p, t[ti+1] - p}->max()}->min() ) else skip ; 
    if (si < a & ti > 0) then (     min := Set{min, s[si+1] - p + p - t[ti - 1+1] + Set{s[si+1] - p, p - t[ti - 1+1]}->min()}->min() ) else skip ; 
    OclFile["System.out"].println(min) ; 
 )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class gfg {
  static int findMinSwaps(int arr[],int n){
    int noOfZeroes[]=new int[n];
    int i,count=0 ;
    noOfZeroes[n-1]=1-arr[n-1];
    for(i=n-2 ; i>=0 ; i--){
      noOfZeroes[i]=noOfZeroes[i+1];
      if(arr[i]==0)noOfZeroes[i]++;
    }
    for(i=0 ; i<n ; i++){
      if(arr[i]==1)count+=noOfZeroes[i];
    }
    return count ;
  }
  public static void main(String args[]){
    int ar[]={
      0,0,1,0,1,0,1,1 };
      System.out.println(findMinSwaps(ar,ar.length));
    }
  }

------------------------------------------------------------
OCL File:
---------
class gfg {
  static   operation findMinSwaps( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var noOfZeroes : Sequence(int) ; noOfZeroes := Integer.subrange(1,n)->collect(0) ;
     var i : int ;
    var count : int ; count := 0 ;
    noOfZeroes[n - 1+1] := 1 - arr[n - 1+1] ; 
        i := n - 2 ; while i >= 0 do ( (     noOfZeroes[i+1] := noOfZeroes[i + 1+1] ; 
     if (arr[i+1] = 0) then     noOfZeroes[i+1] := noOfZeroes[i+1] + 1 ; else skip )  ;     i := i - 1 ) ; 
        i := 0 ; while i < n do ( (     if (arr[i+1] = 1) then     count := count+(noOfZeroes[i+1]) ; else skip )  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ar : Sequence(int) ; ar := Sequence{0,0,1,0,1,0,1,1} ;
     OclFile["System.out"].println(findMinSwaps(ar, ar->size())) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    int MOD=1000000007 ;
    Scanner sc=new Scanner(System.in);
    Long first_N=sc.nextLong();
    Long first_M=sc.nextLong();
    Long first_limit ;
    if(first_N==1){
      System.out.println((first_M+1)% MOD);
    }
    else {
      if((first_M+1)%(first_N-1)==0){
        first_limit=(first_M+1)/(first_N-1)-1 ;
      }
      else {
        first_limit=(first_M+1)/(first_N-1);
      }
      if(first_limit<=0){
        System.out.println((first_M+1)% MOD);
      }
      else {
        BigInteger bigMOD=BigInteger.valueOf(MOD);
        BigInteger limit=BigInteger.valueOf(first_limit);
        BigInteger A=BigInteger.valueOf(first_M+1);
        BigInteger B=BigInteger.valueOf(2*(first_M+1));
        B=B.multiply(limit);
        BigInteger C=BigInteger.valueOf(first_N-1);
        C=C.multiply(limit);
        C=C.multiply(BigInteger.valueOf(first_limit+1));
        A=A.add(B).subtract(C);
        System.out.println(A.remainder(bigMOD));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var MOD : int ; MOD := 1000000007 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var first_N : long ; first_N := sc.getCurrent()->toLong() ;
    var first_M : long ; first_M := sc.getCurrent()->toLong() ;
    var first_limit : long ;
    if (first_N = 1) then (     OclFile["System.out"].println((first_M + 1) mod MOD) ) else (     if ((first_M + 1) mod (first_N - 1) = 0) then (     first_limit := (first_M + 1) / (first_N - 1) - 1 ) else (     first_limit := (first_M + 1) / (first_N - 1) ) ;  
     if (first_limit <= 0) then (     OclFile["System.out"].println((first_M + 1) mod MOD) ) else (     var bigMOD : long ; bigMOD := (MOD + "")->toLong() ;
     var limit : long ; limit := (first_limit + "")->toLong() ;
    var A : long ; A := (first_M + 1 + "")->toLong() ;
    var B : long ; B := (2 * (first_M + 1) + "")->toLong() ;
    B := B.multiply(limit) ; 
    var C : long ; C := (first_N - 1 + "")->toLong() ;
    C := C.multiply(limit) ; 
    C := C.multiply((first_limit + 1 + "")->toLong()) ; 
    A := A->excludes(B).subtract(C) ; 
    OclFile["System.out"].println(A.remainder(bigMOD)) ; 
 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger ;
import java.util.Scanner ;
public class Main {
  public static void main(String args[]){
    int MOD=1000000007 ;
    Scanner sc=new Scanner(System.in);
    Long first_N=sc.nextLong();
    Long first_M=sc.nextLong();
    Long first_limit ;
    if(first_N==1){
      System.out.println((first_M+1)% MOD);
    }
    else {
      if((first_M+1)%(first_N-1)==0){
        first_limit=(first_M+1)/(first_N-1)-1 ;
      }
      else {
        first_limit=(first_M+1)/(first_N-1);
      }
      if(first_limit<=0){
        System.out.println((first_M+1)% MOD);
      }
      else {
        BigInteger bigMOD=BigInteger.valueOf(MOD);
        BigInteger limit=BigInteger.valueOf(first_limit);
        BigInteger A=BigInteger.valueOf(first_M+1);
        BigInteger B=BigInteger.valueOf(2*(first_M+1)).multiply(limit);
        BigInteger C=BigInteger.valueOf(first_N-1).multiply(limit);
        C=C.multiply(BigInteger.valueOf(first_limit+1));
        System.out.println((A.add(B).subtract(C)).remainder(bigMOD));
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var MOD : int ; MOD := 1000000007 ;
     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var first_N : long ; first_N := sc.getCurrent()->toLong() ;
    var first_M : long ; first_M := sc.getCurrent()->toLong() ;
    var first_limit : long ;
    if (first_N = 1) then (     OclFile["System.out"].println((first_M + 1) mod MOD) ) else (     if ((first_M + 1) mod (first_N - 1) = 0) then (     first_limit := (first_M + 1) / (first_N - 1) - 1 ) else (     first_limit := (first_M + 1) / (first_N - 1) ) ;  
     if (first_limit <= 0) then (     OclFile["System.out"].println((first_M + 1) mod MOD) ) else (     var bigMOD : long ; bigMOD := (MOD + "")->toLong() ;
     var limit : long ; limit := (first_limit + "")->toLong() ;
    var A : long ; A := (first_M + 1 + "")->toLong() ;
    var B : long ; B := (2 * (first_M + 1) + "")->toLong().multiply(limit) ;
    var C : long ; C := (first_N - 1 + "")->toLong().multiply(limit) ;
    C := C.multiply((first_limit + 1 + "")->toLong()) ; 
    OclFile["System.out"].println((A->excludes(B).subtract(C)).remainder(bigMOD)) ; 
 ) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printSeries(int N){
    int ith_term=0 ;
    for(int i=1 ; i<=N ; i++){
      ith_term=i % 2==0 ? 2*i*i+1 : 2*i*i-1 ;
      System.out.print(ith_term+",");
    }
  }
  public static void main(String[] args){
    int N=7 ;
    printSeries(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printSeries( N : int) : void
  pre: true
  post: true
  activity: (     var ith_term : int ; ith_term := 0 ;
         var i : int ; i := 1 ; while i <= N do ( (     ith_term := if i mod 2 = 0 then 2 * i * i + 1 else 2 * i * i - 1 endif ; 
     OclFile["System.out"].print(ith_term + ",") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 7 ;
     execute printSeries(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int __gcd(int a,int b){
    if(a==0)return b ;
    if(b==0)return a ;
    if(a==b)return a ;
    if(a>b)return __gcd(a-b,b);
    return __gcd(a,b-a);
  }
  static int MinSum(int[] a,int n){
    int gcd=a[0];
    for(int i=1 ; i<n ; i++)gcd=__gcd(a[i],gcd);
    return n*gcd ;
  }
  public static void main(String[] args){
    int a[]={
      20,14,6,8,15 };
      int n=a.length ;
      System.out.println(MinSum(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     if (b = 0) then     return a else skip ; 
    if (a = b) then     return a else skip ; 
    if (a > b) then     return __gcd(a - b, b) else skip ; 
    return __gcd(a, b - a) 
 );
  static   operation MinSum( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var gcd : int ; gcd := a[0+1] ;
         var i : int ; i := 1 ; while i < n do (     gcd := __gcd(a[i+1], gcd) ;  ;     i := i + 1 ) ; 
     return n * gcd );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{20,14,6,8,15} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(MinSum(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(--t>=0){
      long a=sc.nextLong();
      long b=sc.nextLong();
      long c=sc.nextLong();
      long ans=(a+b+c)/2 ;
      System.out.println(ans);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         t := t - 1 ;
    while ((t - 1) >= 0) do (        t := t - 1 ;     skip ; (     var a : long ; a := sc.getCurrent()->toLong() ;
     var b : long ; b := sc.getCurrent()->toLong() ;
    var c : long ; c := sc.getCurrent()->toLong() ;
    var ans : long ; ans := (a + b + c) / 2 ;
    OclFile["System.out"].println(ans) ; 
 ) ;     t := t - 1 ;
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int cntSubArrays(int[] arr,int n,int k){
    int res=0 ;
    int i=0 ;
    while(i<n){
      int j=i+1 ;
      while(j<n && arr[j]>=arr[j-1])j++;
      res+=Math.max(j-i-k+1,0);
      i=j ;
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      1,2,3,2,5 };
      int n=arr.length ;
      int k=2 ;
      System.out.println(cntSubArrays(arr,n,k));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation cntSubArrays( arr : Sequence(int), n : int, k : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 0 ;
     var i : int ; i := 0 ;
     while (i < n) do (     var j : int ; j := i + 1 ;
     while (j < n & arr[j+1] >= arr[j - 1+1]) do     j := j + 1 ; ; 
     res := res+(Set{j - i - k + 1, 0}->max()) ; 
     i := j ) ; 
     return res );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,2,5} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     OclFile["System.out"].println(cntSubArrays(arr, n, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static void digitsNum(int N){
    if(N==0)System.out.println("0");
    if(N % 9!=0)System.out.print((N % 9));
    for(int i=1 ; i<=(N/9); ++i)System.out.print("9");
    for(int i=1 ; i<=N ; ++i)System.out.print("0");
    System.out.print("");
  }
  public static void main(String[] args){
    int N=5 ;
    System.out.print("The number is : ");
    digitsNum(N);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation digitsNum( N : int) : void
  pre: true
  post: true
  activity: (     if (N = 0) then     OclFile["System.out"].println("0") ; else skip ; 
     if (N mod 9 /= 0) then     OclFile["System.out"].print((N mod 9)) ; else skip ; 
        var i : int ; i := 1 ; while i <= (N / 9) do (     OclFile["System.out"].print("9") ;  ;     i := i + 1 ) ; 
        var i : int ; i := 1 ; while i <= N do (     OclFile["System.out"].print("0") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 5 ;
     OclFile["System.out"].print("The number is : ") ; 
     execute digitsNum(N) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Solution {
  public int maximum69Number(int num){
    return Integer.valueOf(String.valueOf(num).replaceFirst("6","9"));
  }
}
------------------------------------------------------------
OCL File:
---------
class Solution {
   operation maximum69Number( num : int) : int
  pre: true
  post: true
  activity: (     return (((num) + "").replaceFirstMatch("6", "9"))->toInteger() );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int[] a=readArray(sc);
    int[] b=readArray(sc);
    System.out.println(solve(a,b));
    sc.close();
  }
  static int[] readArray(Scanner sc){
    int size=sc.nextInt();
    int[] result=new int[size];
    for(int i=0 ; i<result.length ; i++){
      result[i]=sc.nextInt();
    }
    return result ;
  }
  static String solve(int[] a,int[] b){
    return String.format("%d %d",Arrays.stream(a).max().getAsInt(),Arrays.stream(b).max().getAsInt());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : Sequence(int) ; a := readArray(sc) ;
    var b : Sequence(int) ; b := readArray(sc) ;
    OclFile["System.out"].println(solve(a, b)) ; 
    skip ; 
 );
  static   operation readArray( sc : OclFile) : Sequence(int)
  pre: true
  post: true
  activity: (     var size : int ; size := sc.getCurrent()->toInteger() ;
     var result : Sequence(int) ; result := Integer.subrange(1,size)->collect(0) ;
         var i : int ; i := 0 ; while i < result->size() do ( (     result[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
     return result );
  static   operation solve( a : Sequence(int), b : Sequence(int)) : String
  pre: true
  post: true
  activity: (     return StringLib.format("%d %d",Sequence{stream(a).max().getAsInt(),stream(b).max().getAsInt()}) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    String s=sc.next();
    char[] arr=s.toCharArray();
    Arrays.sort(arr);
    int result=arr[0]-'a'+1 ;
    char limit=(char)(arr[0]+1);
    int count=1 ;
    for(int i=1 ; i<n ; i++){
      if(k==count)break ;
      if(arr[i]>limit){
        result+=arr[i]-'a'+1 ;
        limit=(char)(arr[i]+1);
        count++;
      }
    }
    if(count<k)result=-1 ;
    System.out.println(result);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    var arr : Sequence(String) ; arr := s->characters() ;
    arr := arr->sort() ; 
    var result : int ; result := arr[0+1] - ('a')->char2byte() + 1 ;
    var limit : String ; limit := (arr[0+1] + 1)->oclAsType(String) ;
    var count : int ; count := 1 ;
        var i : int ; i := 1 ; while i < n do ( (     if (k = count) then     break else skip ; 
     if (arr[i+1] > limit) then (     result := result+(arr[i+1] - ('a')->char2byte() + 1) ; 
     limit := (arr[i+1] + 1)->oclAsType(String) ; 
     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    if (count < k) then     result := -1 ; else skip ; 
    OclFile["System.out"].println(result) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class A_Stages {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    sc.nextInt();
    int k=sc.nextInt();
    String s=sc.next();
    System.out.println(solve(s,k));
    sc.close();
  }
  static int solve(String s,int k){
    int[] sortedWeights=s.chars().map(ch->ch-'a'+1).sorted().toArray();
    int result=0 ;
    int prev=-1 ;
    int index=0 ;
    for(int i=0 ; i<k ; i++){
      while(index<sortedWeights.length && sortedWeights[index]-prev<=1){
        index++;
      }
      if(index==sortedWeights.length){
        return-1 ;
      }
      result+=sortedWeights[index];
      prev=sortedWeights[index];
      index++;
    }
    return result ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class A_Stages {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     skip ; 
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var s : String ; s := sc.getCurrent() ;
    OclFile["System.out"].println(solve(s, k)) ; 
    skip ; 
 );
  static   operation solve( s : String, k : int) : int
  pre: true
  post: true
  activity: (     var sortedWeights : Sequence(int) ; sortedWeights := s.chars()->collect( _x1 | (lambda ch : OclAny in ch - ('a')->char2byte() + 1)->apply(_x1) )->sort()->asSequence() ;
     var result : int ; result := 0 ;
    var prev : int ; prev := -1 ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < k do ( (     while (index < sortedWeights->size() & sortedWeights[index+1] - prev <= 1) do (     index := index + 1 ) ; 
     if (index = sortedWeights->size()) then (     return -1 ) else skip ; 
    result := result+(sortedWeights[index+1]) ; 
    prev := sortedWeights[index+1] ; 
    index := index + 1 ; 
 )  ;     i := i + 1 ) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
public class Solution2 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int k=in.nextInt();
    char[] alpha={
      'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z' };
      int[] arr=new int[n];
      String a=in.next();
      for(int i=0 ; i<a.length(); i++){
        int j ;
        for(j=0 ; j<alpha.length ; j++){
          if(a.charAt(i)==alpha[j]){
            arr[i]=j ;
            break ;
          }
        }
      }
      Arrays.sort(arr);
      int sum=arr[0];
      int count=1 ;
      int p=0 ;
      for(int i=0 ; i<n-1 ; i++){
        if(count==k){
          i=n-1 ;
          break ;
        }
        if(arr[p]+1==arr[i+1] || arr[p]==arr[i+1]){
          continue ;
        }
        else {
          sum=sum+arr[i+1];
          p=i+1 ;
          count++;
        }
      }
      if(count!=k){
        System.out.println(-1);
      }
      else {
        System.out.println(sum+k);
      }
    }
  }

------------------------------------------------------------
OCL File:
---------
 class Solution2 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var k : int ; k := in.getCurrent()->toInteger() ;
    var alpha : Sequence(String) ; alpha := Sequence{'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'} ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var a : String ; a := in.getCurrent() ;
        var i : int ; i := 0 ; while i < a->size() do ( (     var j : int ;
         j := 0 ; while j < alpha->size() do ( (     if (a->at(i+1) = alpha[j+1]) then (     arr[i+1] := j ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
    var sum : int ; sum := arr[0+1] ;
    var count : int ; count := 1 ;
    var p : int ; p := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (count = k) then (     i := n - 1 ; 
     break ) else skip ; 
     if (arr[p+1] + 1 = arr[i + 1+1] or arr[p+1] = arr[i + 1+1]) then (     continue ) else (     sum := sum + arr[i + 1+1] ; 
     p := i + 1 ; 
     count := count + 1 ) )  ;     i := i + 1 ) ; 
    if (count /= k) then (     OclFile["System.out"].println(-1) ) else (     OclFile["System.out"].println(sum + k) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner sc=new Scanner(System.in);
    while(true){
      double d=sc.nextDouble();
      if(d==0)break ;
      double px=sc.nextDouble();
      double py=sc.nextDouble();
      double vx=sc.nextDouble();
      double vy=sc.nextDouble();
      double x1=-px ;
      double y1=-py ;
      double x2=vx ;
      double y2=vy ;
      if(Math.abs(x1*y2-x2*y1)>1e-8){
        System.out.println("impossible");
        continue ;
      }
      double k=x2!=0 ? x1/x2 : y1/y2 ;
      double D=0 ;
      if(k>0)D=Math.hypot(px,py);
      else D=2-Math.hypot(px,py);
      System.out.println(D<=d ? D : "impossible");
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var d : double ; d := sc.getCurrent()->toReal() ;
     if (d = 0) then     break else skip ; 
    var px : double ; px := sc.getCurrent()->toReal() ;
    var py : double ; py := sc.getCurrent()->toReal() ;
    var vx : double ; vx := sc.getCurrent()->toReal() ;
    var vy : double ; vy := sc.getCurrent()->toReal() ;
    var x1 : double ; x1 := -px ;
    var y1 : double ; y1 := -py ;
    var x2 : double ; x2 := vx ;
    var y2 : double ; y2 := vy ;
    if (if x1 * y2 - x2 * y1 < 0 then -(x1 * y2 - x2 * y1) else x1 * y2 - x2 * y1 endif > 1e-8) then (     OclFile["System.out"].println("impossible") ; 
     continue ) else skip ; 
    var k : double ; k := if x2 /= 0 then x1 / x2 else y1 / y2 endif ;
    var D : double ; D := 0 ;
    if (k > 0) then     D := hypot(px, py) else     D := 2 - hypot(px, py) ; ;  
    OclFile["System.out"].println(if D <= d then D else "impossible" endif) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  static Scanner sc=new Scanner(System.in);
  static int[] leaf ;
  public static void main(String[] args)throws Exception {
    double EPS=1e-9 ;
    while(true){
      double D=sc.nextDouble();
      if(D==0)break ;
      double px=sc.nextDouble();
      double py=sc.nextDouble();
      double vx=sc.nextDouble();
      double vy=sc.nextDouble();
      if(Math.abs(px*vy-py*vx)>EPS){
        System.out.println("impossible");
        continue ;
      }
      double dist=Math.sqrt(px*px+py*py);
      double v=Math.sqrt(vx*vx+vy*vy);
      if(px*vx>=0 && py*vy>=0){
        dist=(2-dist);
      }
      double time=dist/v ;
      if(time<D){
        System.out.println(dist);
      }
      else {
        System.out.println("impossible");
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute leaf : Sequence(int);
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var EPS : double ; EPS := 1e-9 ;
     while (true) do (     var D : double ; D := sc.getCurrent()->toReal() ;
     if (D = 0) then     break else skip ; 
    var px : double ; px := sc.getCurrent()->toReal() ;
    var py : double ; py := sc.getCurrent()->toReal() ;
    var vx : double ; vx := sc.getCurrent()->toReal() ;
    var vy : double ; vy := sc.getCurrent()->toReal() ;
    if (if px * vy - py * vx < 0 then -(px * vy - py * vx) else px * vy - py * vx endif > EPS) then (     OclFile["System.out"].println("impossible") ; 
     continue ) else skip ; 
    var dist : double ; dist := (px * px + py * py)->sqrt() ;
    var v : double ; v := (vx * vx + vy * vy)->sqrt() ;
    if (px * vx >= 0 & py * vy >= 0) then (     dist := (2 - dist) ) else skip ; 
    var time : double ; time := dist / v ;
    if (time < D) then (     OclFile["System.out"].println(dist) ) else (     OclFile["System.out"].println("impossible") ) ;  
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int exponentMod(int A,int B,int C){
    if(A==0)return 0 ;
    if(B==0)return 1 ;
    long y ;
    if(B % 2==0){
      y=exponentMod(A,B/2,C);
      y=(y*y)% C ;
    }
    else {
      y=A % C ;
      y=(y*exponentMod(A,B-1,C)% C)% C ;
    }
    return(int)((y+C)% C);
  }
  public static void main(String args[]){
    int A=2,B=5,C=13 ;
    System.out.println("Power is "+exponentMod(A,B,C));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation exponentMod( A : int, B : int, C : int) : int
  pre: true
  post: true
  activity: (     if (A = 0) then     return 0 else skip ; 
     if (B = 0) then     return 1 else skip ; 
    var y : long ;
    if (B mod 2 = 0) then (     y := exponentMod(A, B / 2, C) ; 
     y := (y * y) mod C ) else (     y := A mod C ; 
     y := (y * exponentMod(A, B - 1, C) mod C) mod C ) ;  
    return ((y + C) mod C)->oclAsType(int) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var A : int ; A := 2 ;
    var B : int ; B := 5 ;
    var C : int ; C := 13 ;
     OclFile["System.out"].println("Power is " + exponentMod(A, B, C)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class test244 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int t=in.nextInt();
    for(int j=0 ; j<t ; j++){
      long sum=0 ;
      for(int i=0 ; i<3 ; i++){
        sum+=in.nextLong();
      }
      System.out.println(sum/2);
    }
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class test244 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := in.getCurrent()->toInteger() ;
         var j : int ; j := 0 ; while j < t do ( (     var sum : long ; sum := 0 ;
         var i : int ; i := 0 ; while i < 3 do ( (     sum := sum+(in.getCurrent()->toLong()) )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(sum / 2) )  ;     j := j + 1 ) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Comparator ;
class Interval {
  int start,end ;
  Interval(int start,int end){
    this.start=start ;
    this.end=end ;
  }
}
public class MergeOverlappingIntervals {
  public static void mergeIntervals(Interval arr[]){
    Arrays.sort(arr,new Comparator<Interval>(){
      public int compare(Interval i1,Interval i2){
        return i2.start-i1.start ;
      }
    }
);
    int index=0 ;
    for(int i=1 ; i<arr.length ; i++){
      if(arr[index] .end>=arr[i] .start){
        arr[index] .end=Math.max(arr[index] .end,arr[i] .end);
        arr[index] .start=Math.min(arr[index] .start,arr[i] .start);
      }
      else {
        arr[index]=arr[i];
        index++;
      }
    }
    System.out.print("The Merged Intervals are: ");
    for(int i=0 ; i<=index ; i++){
      System.out.print("["+arr[i] .start+","+arr[i] .end+"] ");
    }
  }
  public static void main(String args[]){
    Interval arr[]=new Interval[4];
    arr[0]=new Interval(6,8);
    arr[1]=new Interval(1,9);
    arr[2]=new Interval(2,4);
    arr[3]=new Interval(4,7);
    mergeIntervals(arr);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Interval {
   attribute start : int;
   static operation newInterval( start : int, end : int) : Interval
  pre: true
  post: true
  activity:
  ( var self : Interval ;
    self := createInterval();
    self.initialise(start, end);
    return self );
  operation initialise( start : int, end : int) : void
  pre: true  post: true
  activity: (     self.start := start ; 
     self.end := end );
}
class MergeOverlappingIntervals {
  static   operation mergeIntervals( arr : Sequence(Interval)) : void
  pre: true
  post: true
  activity: (     arr := OclComparator.sortWith(arr, OclComparator<Interval>.newOclComparator()) ; 
     var index : int ; index := 0 ;
        var i : int ; i := 1 ; while i < arr->size() do ( (     if (arr[index+1].end >= arr[i+1].start) then (     arr[index+1].end := Set{arr[index+1].end, arr[i+1].end}->max() ; 
     arr[index+1].start := Set{arr[index+1].start, arr[i+1].start}->min() ) else (     arr[index+1] := arr[i+1] ; 
     index := index + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print("The Merged Intervals are: ") ; 
        var i : int ; i := 0 ; while i <= index do ( (     OclFile["System.out"].print("[" + arr[i+1].start + "," + arr[i+1].end + "] ") )  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(Interval) ; arr := Integer.subrange(1,4)->collect(null) ;
     arr[0+1] := Interval.newInterval(6, 8) ; 
    arr[1+1] := Interval.newInterval(1, 9) ; 
    arr[2+1] := Interval.newInterval(2, 4) ; 
    arr[3+1] := Interval.newInterval(4, 7) ; 
    execute mergeIntervals(arr) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main extends PrintWriter {
  Main(){
    super(System.out);
  }
  Scanner sc=new Scanner(System.in);
  public static void main(String[] $){
    Main o=new Main();
    o.main();
    o.flush();
  }
  void main(){
    int n=sc.nextInt();
    int[] aa=new int[n+1];
    for(int i=1 ; i<=n ; i++)aa[i]=sc.nextInt();
    Integer[] ii=new Integer[n+1];
    for(int i=0 ; i<=n ; i++)ii[i]=i ;
    Arrays.sort(ii,(i,j)->aa[j]-aa[i]);
    long[] kk=new long[n+1];
    for(int h=0,h_,i=n,i_ ; h<n ; h=h_){
      int a=aa[ii[h] ];
      h_=h ;
      while(aa[i_=ii[h_] ]==a){
        i=Math.min(i,i_);
        h_++;
      }
      int b=aa[ii[h_] ];
      kk[i]+=(long)(a-b)*h_ ;
    }
    for(int i=1 ; i<=n ; i++)println(kk[i]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main extends OclFile {
   static operation newMain() : Main
  pre: true
  post: true
  activity:
  ( var self : Main ;
    self := createMain();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super(OclFile["System.out"]) );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   operation main( $ : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var o : Main ; o := Main.newMain() ;
     o.main() ; 
     o.flush() );
   operation main() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var aa : Sequence(int) ; aa := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do (     aa[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ii : Sequence(int) ; ii := Integer.subrange(1,n + 1)->collect(null) ;
        var i : int ; i := 0 ; while i <= n do (     ii[i+1] := i ;  ;     i := i + 1 ) ; 
    ii := OclComparator.sortWith(ii, lambda (i , j) : OclAny in aa[j+1] - aa[i+1]) ; 
    var kk : Sequence(long) ; kk := Integer.subrange(1,n + 1)->collect(0) ;
        var h : int ; h := 0 ;
    var h_ : int ;
    var i : int ; i := n ;
    var i_ : int ; while h < n do ( (     var a : int ; a := aa[ii[h+1]+1] ;
     h_ := h ; 
        i_ := ii[h_+1] ;
    while (aa[i_+1] = a) do (        skip ;     skip ; (     i := Set{i, i_}->min() ; 
     h_ := h_ + 1 ) ;     i_ := ii[h_+1] ;
 ) ;  
    var b : int ; b := aa[ii[h_+1]+1] ;
    kk[i+1] := kk[i+1]+((a - b)->oclAsType(long) * h_) ; 
 )  ;     h := h_ ) ; 
        var i : int ; i := 1 ; while i <= n do (     execute println(kk[i+1]) ;  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  Scanner sc=new Scanner(System.in);
  void run(){
    int n=sc.nextInt();
    Pair[] p=new Pair[n+1];
    for(int i=0 ; i<n ; i++)p[i]=new Pair(i+1,sc.nextLong());
    p[n]=new Pair(0,0);
    Arrays.sort(p);
    long[] res=new long[n+1];
    long cnt=0 ;
    int idmin=n+1 ;
    for(int i=0 ; i<n ; i++){
      Pair nowP=p[i];
      idmin=Math.min(idmin,nowP.id);
      cnt++;
      while(nowP.cnt==p[i+1] .cnt){
        i++;
        cnt++;
      }
      res[idmin]+=cnt*(nowP.cnt-p[i+1] .cnt);
    }
    StringBuilder sb=new StringBuilder();
    for(int i=1 ; i<n+1 ; i++)sb.append(res[i]+"\n");
    System.out.print(sb);
  }
  class Pair implements Comparable<Pair>{
    int id ;
    long cnt ;
    public Pair(int id,long cnt){
      super();
      this.id=id ;
      this.cnt=cnt ;
    }
    @ Override public int compareTo(Pair arg0){
      if(this.cnt==arg0.cnt){
        return this.id-arg0.id ;
      }
      return-Long.compare(this.cnt,arg0.cnt);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation run() : void
  pre: true
  post: true
  activity: (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var p : Sequence(Map) ; p := Integer.subrange(1,n + 1)->collect(null) ;
        var i : int ; i := 0 ; while i < n do (     p[i+1] := Map(i + 1, sc.getCurrent()->toLong()) ;  ;     i := i + 1 ) ; 
    p[n+1] := Map(0, 0) ; 
    p := p->sort() ; 
    var res : Sequence(long) ; res := Integer.subrange(1,n + 1)->collect(0) ;
    var cnt : long ; cnt := 0 ;
    var idmin : int ; idmin := n + 1 ;
        var i : int ; i := 0 ; while i < n do ( (     var nowP : Map ; nowP := p[i+1] ;
     idmin := Set{idmin, nowP.id}->min() ; 
    cnt := cnt + 1 ; 
    while (nowP.cnt = p[i + 1+1].cnt) do (     i := i + 1 ; 
     cnt := cnt + 1 ) ; 
    res[idmin+1] := res[idmin+1]+(cnt * (nowP.cnt - p[i + 1+1].cnt)) ; 
 )  ;     i := i + 1 ) ; 
    var sb : String ; sb := StringLib.newString() ;
        var i : int ; i := 1 ; while i < n + 1 do (     sb := sb.append(res[i+1] + "\n") ;  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(sb) ; 
 );
 class Pair implements Comparable<Map> {
   attribute id : int;
   attribute cnt : long;
   static operation newPair( id : int, cnt : long) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(id, cnt);
    return self );
  operation initialise( id : int, cnt : long) : void
  pre: true  post: true
  activity: (     execute super() ; 
     self.id := id ; 
     self.cnt := cnt );
      operation compareTo( arg0 : Map) : int
  pre: true
  post: true
  activity: (     if (self.cnt = arg0.cnt) then (     return self.id - arg0.id ) else skip ; 
     return -compare(self.cnt, arg0.cnt) );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args)throws Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    Obj[] arr=new Obj[n+1];
    for(int i=0 ; i<n ; i++){
      Obj o=new Obj();
      o.i=i ;
      o.a=sc.nextInt();
      arr[i]=o ;
    }
    sc.close();
    Obj o=new Obj();
    o.i=n ;
    o.a=0 ;
    arr[n]=o ;
    Arrays.sort(arr,(o1,o2)->{
      if(o1.a!=o2.a){
        return o2.a-o1.a ;
      }
      return o2.i-o1.i ;
    }
);
    long[] ans=new long[n];
    int idx=n ;
    int size=0 ;
    for(int i=0 ; i<arr.length-1 ; i++){
      size++;
      Obj o1=arr[i];
      Obj o2=arr[i+1];
      if(o1.a>o2.a){
        idx=Math.min(idx,o1.i);
        ans[idx]+=(long)(o1.a-o2.a)*size ;
      }
    }
    Arrays.sort(arr,(o1,o2)->o1.i-o2.i);
    PrintWriter pw=new PrintWriter(System.out);
    for(int i=0 ; i<n ; i++){
      pw.println(ans[i]);
    }
    pw.flush();
  }
  static class Obj {
    int i,a ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(Obj) ; arr := Integer.subrange(1,n + 1)->collect(null) ;
        var i : int ; i := 0 ; while i < n do ( (     var o : Obj ; o := Obj.newObj() ;
     o.i := i ; 
     o.a := sc.getCurrent()->toInteger() ; 
     arr[i+1] := o )  ;     i := i + 1 ) ; 
    skip ; 
    var o : Obj ; o := Obj.newObj() ;
    o.i := n ; 
    o.a := 0 ; 
    arr[n+1] := o ; 
    arr := OclComparator.sortWith(arr, lambda (o1 , o2) : OclAny in (     if (o1.a /= o2.a) then (     return o2.a - o1.a ) else skip ; 
     return o2.i - o1.i )) ; 
    var ans : Sequence(long) ; ans := Integer.subrange(1,n)->collect(0) ;
    var idx : int ; idx := n ;
    var size : int ; size := 0 ;
        var i : int ; i := 0 ; while i < arr->size() - 1 do ( (     size := size + 1 ; 
     var o1 : Obj ; o1 := arr[i+1] ;
     var o2 : Obj ; o2 := arr[i + 1+1] ;
     if (o1.a > o2.a) then (     idx := Set{idx, o1.i}->min() ; 
     ans[idx+1] := ans[idx+1]+((o1.a - o2.a)->oclAsType(long) * size) ) else skip )  ;     i := i + 1 ) ; 
    arr := OclComparator.sortWith(arr, lambda (o1 , o2) : OclAny in o1.i - o2.i) ; 
    var pw : OclFile ; pw := OclFile.newOclFile_Write(OclFile["System.out"]) ;
        var i : int ; i := 0 ; while i < n do ( (     skip )  ;     i := i + 1 ) ; 
    skip ; 
 );
  static class Obj {
   attribute i : int;
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.util.*;
public class Football_Kit {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int[][] arr=new int[n][2];
    int[] map=new int[100000+1];
    for(int i=0 ; i<n ; i++){
      arr[i][0]=scn.nextInt();
      arr[i][1]=scn.nextInt();
      map[arr[i][0] ]=map[arr[i][0] ]+1 ;
    }
    for(int i=0 ; i<n ; i++){
      System.out.println((n-1+map[arr[i][1] ])+" "+(n-1-map[arr[i][1] ]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Football_Kit {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
    var map : Sequence(int) ; map := Integer.subrange(1,100000 + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1][0+1] := scn.getCurrent()->toInteger() ; 
     arr[i+1][1+1] := scn.getCurrent()->toInteger() ; 
     map[arr[i+1][0+1]+1] := map[arr[i+1][0+1]+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println((n - 1 + map[arr[i+1][1+1]+1]) + " " + (n - 1 - map[arr[i+1][1+1]+1])) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.util.*;
public class Football_Kit {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int[][] arr=new int[n][2];
    int[] map=new int[100000+1];
    for(int i=0 ; i<n ; i++){
      arr[i][0]=scn.nextInt();
      arr[i][1]=scn.nextInt();
      map[arr[i][0] ]=map[arr[i][0] ]+1 ;
    }
    for(int i=0 ; i<n ; i++){
      System.out.println((n-1+map[arr[i][1] ])+" "+(n-1-map[arr[i][1] ]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Football_Kit {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
    var map : Sequence(int) ; map := Integer.subrange(1,100000 + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1][0+1] := scn.getCurrent()->toInteger() ; 
     arr[i+1][1+1] := scn.getCurrent()->toInteger() ; 
     map[arr[i+1][0+1]+1] := map[arr[i+1][0+1]+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println((n - 1 + map[arr[i+1][1+1]+1]) + " " + (n - 1 - map[arr[i+1][1+1]+1])) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.util.*;
public class Football_Kit {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int[][] arr=new int[n][2];
    int[] map=new int[100000+1];
    for(int i=0 ; i<n ; i++){
      arr[i][0]=scn.nextInt();
      arr[i][1]=scn.nextInt();
      map[arr[i][0] ]=map[arr[i][0] ]+1 ;
    }
    for(int i=0 ; i<n ; i++){
      System.out.println((n-1+map[arr[i][1] ])+" "+(n-1-map[arr[i][1] ]));
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Football_Kit {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
    var map : Sequence(int) ; map := Integer.subrange(1,100000 + 1)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1][0+1] := scn.getCurrent()->toInteger() ; 
     arr[i+1][1+1] := scn.getCurrent()->toInteger() ; 
     map[arr[i+1][0+1]+1] := map[arr[i+1][0+1]+1] + 1 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println((n - 1 + map[arr[i+1][1+1]+1]) + " " + (n - 1 - map[arr[i+1][1+1]+1])) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.lang.*;
import java.util.*;
public class Football_Kit {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner scn=new Scanner(System.in);
    int n=scn.nextInt();
    int[][] arr=new int[n][2];
    for(int i=0 ; i<n ; i++){
      arr[i][0]=scn.nextInt();
      arr[i][1]=scn.nextInt();
    }
    HashMap<Integer,Integer>map=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      map.put(arr[i][0],map.getOrDefault(arr[i][0],0)+1);
    }
    int[][] ans=new int[n][2];
    for(int i=0 ; i<n ; i++){
      if(map.get(arr[i][1])==null){
        ans[i][1]=n-1 ;
      }
      else {
        ans[i][1]=n-1-map.get(arr[i][1]);
      }
    }
    int power=2*(n-1);
    for(int i=0 ; i<n ; i++){
      ans[i][0]=power-ans[i][1];
    }
    for(int i=0 ; i<n ; i++){
      System.out.println(ans[i][0]+" "+ans[i][1]);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Football_Kit {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scn : OclFile ; scn := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scn.getCurrent()->toInteger() ;
    var arr : Sequence(Sequence(int)) ; arr := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1][0+1] := scn.getCurrent()->toInteger() ; 
     arr[i+1][1+1] := scn.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var map : Map(int,int) ; map := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     map := map->union(Map{arr[i+1][0+1] |-> (if map->keys()->contains(arr[i+1][0+1]) then map->at(arr[i+1][0+1]) else 0 endif) + 1}) )  ;     i := i + 1 ) ; 
    var ans : Sequence(Sequence(int)) ; ans := Integer.subrange(1,n)->collect(Integer.subrange(1,2)->collect(0)) ;
        var i : int ; i := 0 ; while i < n do ( (     if (map->at(arr[i+1][1+1]) = null) then (     ans[i+1][1+1] := n - 1 ) else (     ans[i+1][1+1] := n - 1 - map->at(arr[i+1][1+1]) ) )  ;     i := i + 1 ) ; 
    var power : int ; power := 2 * (n - 1) ;
        var i : int ; i := 0 ; while i < n do ( (     ans[i+1][0+1] := power - ans[i+1][1+1] )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].println(ans[i+1][0+1] + " " + ans[i+1][1+1]) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class C {
  public static void main(String...args){
    final Scanner sc=new Scanner(System.in);
    final char[] A=sc.next().toCharArray();
    final int N=A.length ;
    final int[] next=new int[N];
    final int[] min=new int[N+1];
    final int[] jump=new int[26];
    final char[] cs=new char[N];
    Arrays.fill(jump,N);
    for(int i=N-1 ; i>=0 ; i--){
      int m=Integer.MAX_VALUE ;
      int n=-1 ;
      for(int j=0 ; j<26 ; j++)if(min[jump[j] ]+1<m){
        n=j ;
        m=min[jump[j] ]+1 ;
      }
      next[i]=jump[n];
      min[i]=m ;
      jump[A[i]-'a']=i ;
      cs[i]=(char)(n+'a');
    }
    int m=Integer.MAX_VALUE ;
    int n=-1 ;
    for(int j=0 ; j<26 ; j++)if(min[jump[j] ]+1<m){
      n=j ;
      m=min[jump[j] ]+1 ;
    }
    final StringBuilder sb=new StringBuilder().appendCodePoint(n+'a');
    for(int i=jump[n]; i<N ; i=next[i])sb.append(cs[i]);
    System.out.println(sb);
  }
}
public class Main {
  public static void main(String...args){
    C.main(args);
  }
}
------------------------------------------------------------
OCL File:
---------
 class C {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var A : Sequence(String) ; A := sc.getCurrent()->characters() ;
    var N : int ; N := A->size() ;
    var next : Sequence(int) ; next := Integer.subrange(1,N)->collect(0) ;
    var min : Sequence(int) ; min := Integer.subrange(1,N + 1)->collect(0) ;
    var jump : Sequence(int) ; jump := Integer.subrange(1,26)->collect(0) ;
    var cs : Sequence(String) ; cs := Integer.subrange(1,N)->collect(0) ;
    jump := jump->collect(N) ; 
        var i : int ; i := N - 1 ; while i >= 0 do ( (     var m : int ; m := 2147483647 ;
     var n : int ; n := -1 ;
        var j : int ; j := 0 ; while j < 26 do (     if (min[jump[j+1]+1] + 1 < m) then (     n := j ; 
     m := min[jump[j+1]+1] + 1 ) else skip ;  ;     j := j + 1 ) ; 
    next[i+1] := jump[n+1] ; 
    min[i+1] := m ; 
    jump[A[i+1] - ('a')->char2byte()+1] := i ; 
    cs[i+1] := (n + 'a')->oclAsType(String) ; 
 )  ;     i := i - 1 ) ; 
    var m : int ; m := 2147483647 ;
    var n : int ; n := -1 ;
        var j : int ; j := 0 ; while j < 26 do (     if (min[jump[j+1]+1] + 1 < m) then (     n := j ; 
     m := min[jump[j+1]+1] + 1 ) else skip ;  ;     j := j + 1 ) ; 
    var sb : String ; sb := StringLib.newString().appendCodePoint(n + 'a') ;
        var i : int ; i := jump[n+1] ; while i < N do (     sb := sb + StringLib.newString(cs[i+1]) ;  ;     i := next[i+1] ) ; 
    OclFile["System.out"].println(sb) ; 
 );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     C.main(args) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    String a=sc.next();
    sc.close();
    final char[] chars="abcdefghijklmnopqrstuvwxyz".toCharArray();
    int[] rchars=new int[chars.length];
    Arrays.fill(rchars,0);
    char[] arr=a.toCharArray();
    int[] rarr=new int[arr.length];
    for(int i=arr.length ; i>0 ; i--){
      int rank=rchars[0];
      for(int j=1 ; j<rchars.length ; j++)rank=Math.min(rank,rchars[j]);
      int idx=i-1 ;
      char c=arr[idx];
      rchars[c-'a']=rank+1 ;
      rarr[idx]=rank+1 ;
    }
    int rank=rchars[0];
    for(int j=1 ; j<rchars.length ; j++)rank=Math.min(rank,rchars[j]);
    StringBuffer sb=new StringBuffer(rank+1);
    int idx=0 ;
    while(idx<arr.length){
      loop : for(int j=0 ;
      j<chars.length ;
      j++){
        char c=chars[j];
        boolean flag=true ;
        for(int i=idx ; i<arr.length ; i++){
          if(arr[i]==c){
            if(rarr[i]==rank){
              sb.append(c);
              rank--;
              idx=i+1 ;
              break loop ;
            }
            else {
              flag=false ;
              break ;
            }
          }
        }
        if(flag){
          sb.append(c);
          idx=arr.length ;
          break loop ;
        }
      }
    }
    System.out.println(sb.toString());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : String ; a := sc.getCurrent() ;
    skip ; 
    var chars : Sequence(String) ; chars := "abcdefghijklmnopqrstuvwxyz"->characters() ;
    var rchars : Sequence(int) ; rchars := Integer.subrange(1,chars->size())->collect(0) ;
    rchars := rchars->collect(0) ; 
    var arr : Sequence(String) ; arr := a->characters() ;
    var rarr : Sequence(int) ; rarr := Integer.subrange(1,arr->size())->collect(0) ;
        var i : int ; i := arr->size() ; while i > 0 do ( (     var rank : int ; rank := rchars[0+1] ;
         var j : int ; j := 1 ; while j < rchars->size() do (     rank := Set{rank, rchars[j+1]}->min() ;  ;     j := j + 1 ) ; 
    var idx : int ; idx := i - 1 ;
    var c : String ; c := arr[idx+1] ;
    rchars[(c)->char2byte() - ('a')->char2byte()+1] := rank + 1 ; 
    rarr[idx+1] := rank + 1 ; 
 )  ;     i := i - 1 ) ; 
    var rank : int ; rank := rchars[0+1] ;
        var j : int ; j := 1 ; while j < rchars->size() do (     rank := Set{rank, rchars[j+1]}->min() ;  ;     j := j + 1 ) ; 
    var sb : String ; sb := StringLib.newString(rank + 1) ;
    var idx : int ; idx := 0 ;
    while (idx < arr->size()) do (         var j : int ; j := 0 ; while j < chars->size() do ( (     var c : String ; c := chars[j+1] ;
     var flag : boolean ; flag := true ;
         var i : int ; i := idx ; while i < arr->size() do ( (     if (arr[i+1] = c) then (     if (rarr[i+1] = rank) then (     sb := sb + StringLib.newString(c) ; 
     rank := rank - 1 ; 
     idx := i + 1 ; 
     break ) else (     flag := false ; 
     break ) ) else skip )  ;     i := i + 1 ) ; 
     if (flag) then (     sb := sb + StringLib.newString(c) ; 
     idx := arr->size() ; 
     break ) else skip )  ;     j := j + 1 ) ; ) ; 
    OclFile["System.out"].println(sb+"") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector ;
class GFG {
  static Vector<Integer>Divisors(int x){
    int c=0 ;
    Vector<Integer>v=new Vector<Integer>();
    while(x % 2==0){
      c++;
      x/=2 ;
    }
    v.add(c);
    c=0 ;
    while(x % 3==0){
      c++;
      x/=3 ;
    }
    v.add(c);
    c=0 ;
    while(x % 7==0){
      c++;
      x/=7 ;
    }
    v.add(c);
    v.add(x);
    return v ;
  }
  static int MinOperations(int a,int b){
    Vector<Integer>va=Divisors(a);
    Vector<Integer>vb=Divisors(b);
    if(va.get(3)!=vb.get(3)){
      return-1 ;
    }
    int minOperations=Math.abs(va.get(0)-vb.get(0))+Math.abs(va.get(1)-vb.get(1))+Math.abs(va.get(2)-vb.get(2));
    return minOperations ;
  }
  public static void main(String[] args){
    int a=14,b=28 ;
    System.out.println(MinOperations(a,b));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation Divisors( x : int) : Sequence(int)
  pre: true
  post: true
  activity: (     var c : int ; c := 0 ;
     var v : Sequence(int) ; v := Sequence{} ;
    while (x mod 2 = 0) do (     c := c + 1 ; 
     x := x/(2) ) ; 
    v := v->including(c) ; 
    c := 0 ; 
    while (x mod 3 = 0) do (     c := c + 1 ; 
     x := x/(3) ) ; 
    v := v->including(c) ; 
    c := 0 ; 
    while (x mod 7 = 0) do (     c := c + 1 ; 
     x := x/(7) ) ; 
    v := v->including(c) ; 
    v := v->including(x) ; 
    return v 
 );
  static   operation MinOperations( a : int, b : int) : int
  pre: true
  post: true
  activity: (     var va : Sequence(int) ; va := Divisors(a) ;
     var vb : Sequence(int) ; vb := Divisors(b) ;
    if (va->at(3+1) /= vb->at(3+1)) then (     return -1 ) else skip ; 
    var minOperations : int ; minOperations := if va->at(0+1) - vb->at(0+1) < 0 then -(va->at(0+1) - vb->at(0+1)) else va->at(0+1) - vb->at(0+1) endif + if va->at(1+1) - vb->at(1+1) < 0 then -(va->at(1+1) - vb->at(1+1)) else va->at(1+1) - vb->at(1+1) endif + if va->at(2+1) - vb->at(2+1) < 0 then -(va->at(2+1) - vb->at(2+1)) else va->at(2+1) - vb->at(2+1) endif ;
    return minOperations 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : int ; a := 14 ;
    var b : int ; b := 28 ;
     OclFile["System.out"].println(MinOperations(a, b)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static final int R=3 ;
  static final int C=5 ;
  static int maxArea(int mat[][]){
    int hist[][]=new int[R+1][C+1];
    for(int i=0 ; i<C ; i++){
      hist[0][i]=mat[0][i];
      for(int j=1 ; j<R ; j++){
        hist[j][i]=(mat[j][i]==0)? 0 : hist[j-1][i]+1 ;
      }
    }
    for(int i=0 ; i<R ; i++){
      int count[]=new int[R+1];
      for(int j=0 ; j<C ; j++){
        count[hist[i][j] ]++;
      }
      int col_no=0 ;
      for(int j=R ; j>=0 ; j--){
        if(count[j]>0){
          for(int k=0 ; k<count[j]; k++){
            hist[i][col_no]=j ;
            col_no++;
          }
        }
      }
    }
    int curr_area,max_area=0 ;
    for(int i=0 ; i<R ; i++){
      for(int j=0 ; j<C ; j++){
        curr_area=(j+1)*hist[i][j];
        if(curr_area>max_area){
          max_area=curr_area ;
        }
      }
    }
    return max_area ;
  }
  public static void main(String[] args){
    int mat[][]={
      {
        0,1,0,1,0 },{
          0,1,0,1,1 },{
            1,1,0,1,0 }
          };
          System.out.println("Area of the largest rectangle is "+maxArea(mat));
        }
      }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static    attribute R : int := 3;
  static    attribute C : int := 5;
  static   operation maxArea( mat : Sequence(Sequence(int))) : int
  pre: true
  post: true
  activity: (     var hist : Sequence(Sequence(int)) ; hist := Integer.subrange(1,R + 1)->collect(Integer.subrange(1,C + 1)->collect(0)) ;
         var i : int ; i := 0 ; while i < C do ( (     hist[0+1][i+1] := mat[0+1][i+1] ; 
         var j : int ; j := 1 ; while j < R do ( (     hist[j+1][i+1] := if (mat[j+1][i+1] = 0) then 0 else hist[j - 1+1][i+1] + 1 endif )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < R do ( (     var count : Sequence(int) ; count := Integer.subrange(1,R + 1)->collect(0) ;
         var j : int ; j := 0 ; while j < C do ( (     count[hist[i+1][j+1]+1] := count[hist[i+1][j+1]+1] + 1 )  ;     j := j + 1 ) ; 
     var col_no : int ; col_no := 0 ;
         var j : int ; j := R ; while j >= 0 do ( (     if (count[j+1] > 0) then (         var k : int ; k := 0 ; while k < count[j+1] do ( (     hist[i+1][col_no+1] := j ; 
     col_no := col_no + 1 )  ;     k := k + 1 ) ) else skip )  ;     j := j - 1 ) )  ;     i := i + 1 ) ; 
    var curr_area : int ;
    var max_area : int ; max_area := 0 ;
        var i : int ; i := 0 ; while i < R do ( (         var j : int ; j := 0 ; while j < C do ( (     curr_area := (j + 1) * hist[i+1][j+1] ; 
     if (curr_area > max_area) then (     max_area := curr_area ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    return max_area 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var mat : Sequence(Sequence(int)) ; mat := Sequence{Sequence{0,1,0,1,0},Sequence{0,1,0,1,1},Sequence{1,1,0,1,0}} ;
     OclFile["System.out"].println("Area of the largest rectangle is " + maxArea(mat)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static void main(String[] args){
    long n=5 ;
    long fac1=1 ;
    for(int i=2 ; i<=n-1 ; i++)fac1=fac1*i ;
    long fac2=fac1*n ;
    long totalWays=fac1*fac2 ;
    System.out.println(totalWays);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 5 ;
     var fac1 : long ; fac1 := 1 ;
        var i : int ; i := 2 ; while i <= n - 1 do (     fac1 := fac1 * i ;  ;     i := i + 1 ) ; 
    var fac2 : long ; fac2 := fac1 * n ;
    var totalWays : long ; totalWays := fac1 * fac2 ;
    OclFile["System.out"].println(totalWays) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner a=new Scanner(System.in);
    int n=a.nextInt();
    int[] arr=new int[n];
    for(int i=0 ; i<arr.length ; i++)arr[i]=a.nextInt();
    if(check(0,arr,n,0))System.out.println("YES");
    else System.out.println("NO");
  }
  public static boolean check(int index,int[] arr,int n,int sum){
    if(index==n){
      if(sum % 360==0)return true ;
      else return false ;
    }
    return check(index+1,arr,n,sum+arr[index])|| check(index+1,arr,n,sum-arr[index]);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : OclFile ; a := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := a.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < arr->size() do (     arr[i+1] := a.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    if (check(0, arr, n, 0)) then     OclFile["System.out"].println("YES") else     OclFile["System.out"].println("NO") ; ;  
 );
  static   operation check( index : int, arr : Sequence(int), n : int, sum : int) : boolean
  pre: true
  post: true
  activity: (     if (index = n) then (     if (sum mod 360 = 0) then     return true else     return false ) else skip ; 
     return check(index + 1, arr, n, sum + arr[index+1]) or check(index + 1, arr, n, sum - arr[index+1]) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    int n=in.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; ++i)a[i]=in.nextInt();
    for(int mask=1 ; mask<(1<<n); ++mask){
      int sum=0 ;
      for(int i=0 ; i<n ; ++i){
        if((mask &(1<<i))>0)sum+=a[i];
        else sum-=a[i];
      }
      if(sum % 360==0){
        System.out.println("YES");
        return ;
      }
    }
    System.out.println("NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := in.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
        var mask : int ; mask := 1 ; while mask < ((1*(2->pow(n)))->oclAsType(long)) do ( (     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     if ((MathLib.bitwiseAnd(mask,((1*(2->pow(i)))->oclAsType(long)))) > 0) then     sum := sum+(a[i+1]) ; else     sum := sum-(a[i+1]) ; )  ;     i := i + 1 ) ; 
     if (sum mod 360 = 0) then (     OclFile["System.out"].println("YES") ; 
     return ) else skip )  ;     mask := mask + 1 ) ; 
    OclFile["System.out"].println("NO") ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.io.FileInputStream ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import java.io.*;
import java.io.FileInputStream ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.io.*;
import java.io.FileInputStream ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
import java.math.*;
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class codeforces {
  static boolean pos(int n,int sum,int[] ar,int i){
    if(i==n && sum % 360==0){
      return true ;
    }
    if(i==n)return false ;
    boolean p=pos(n,sum+ar[i],ar,i+1);
    int d=sum-ar[i];
    if(d<0)d*=-1 ;
    boolean q=pos(n,d,ar,i+1);
    return p || q ;
  }
  public static void main(String args[])throws IOException {
    BufferedReader ob=new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    int n=Integer.parseInt(ob.readLine());
    int[] ar=new int[n];
    for(int i=0 ; i<n ; i++){
      ar[i]=Integer.parseInt(ob.readLine());
    }
    boolean ans=pos(n,0,ar,0);
    System.out.println(ans==true ? "YES" : "NO");
  }
}
------------------------------------------------------------
OCL File:
---------
 class codeforces {
  static   operation pos( n : int, sum : int, ar : Sequence(int), i : int) : boolean
  pre: true
  post: true
  activity: (     if (i = n & sum mod 360 = 0) then (     return true ) else skip ; 
     if (i = n) then     return false else skip ; 
    var p : boolean ; p := pos(n, sum + ar[i+1], ar, i + 1) ;
    var d : int ; d := sum - ar[i+1] ;
    if (d < 0) then     d := d*(-1) ; else skip ; 
    var q : boolean ; q := pos(n, d, ar, i + 1) ;
    return p or q 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ob : OclFile ; ob := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ;
    var n : int ; n := (ob.readLine())->toInteger() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := (ob.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    var ans : boolean ; ans := pos(n, 0, ar, 0) ;
    OclFile["System.out"].println(if ans = true then "YES" else "NO" endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class PetrAndCombLock {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int n=scan.nextInt();
    int[] a=new int[n];
    for(int i=0 ; i<n ; i++){
      a[i]=scan.nextInt();
    }
    int[] result=new int[(int)Math.pow(2,n+1)-2];
    result[0]=a[0];
    result[1]=-a[0];
    int toFill=2 ;
    for(int i=1 ; i<n ; i++){
      for(int j=(int)Math.pow(2,i)-2 ; j<(int)Math.pow(2,i+1)-2 ; j++){
        result[toFill]=result[j]+a[i];
        toFill++;
        result[toFill]=result[j]-a[i];
        toFill++;
      }
    }
    boolean works=false ;
    for(int i=(int)Math.pow(2,n)-2 ; i<(int)Math.pow(2,n+1)-2 ; i++){
      if(Math.abs(result[i])% 360==0){
        works=true ;
      }
    }
    if(works){
      System.out.println("YES");
    }
    else {
      System.out.println("NO");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class PetrAndCombLock {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scan.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := scan.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var result : Sequence(int) ; result := Integer.subrange(1,2->pow(n + 1)->oclAsType(int) - 2)->collect(0) ;
    result[0+1] := a[0+1] ; 
    result[1+1] := -a[0+1] ; 
    var toFill : int ; toFill := 2 ;
        var i : int ; i := 1 ; while i < n do ( (         var j : int ; j := 2->pow(i)->oclAsType(int) - 2 ; while j < 2->pow(i + 1)->oclAsType(int) - 2 do ( (     result[toFill+1] := result[j+1] + a[i+1] ; 
     toFill := toFill + 1 ; 
     result[toFill+1] := result[j+1] - a[i+1] ; 
     toFill := toFill + 1 )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    var works : boolean ; works := false ;
        var i : int ; i := 2->pow(n)->oclAsType(int) - 2 ; while i < 2->pow(n + 1)->oclAsType(int) - 2 do ( (     if (if result[i+1] < 0 then -(result[i+1]) else result[i+1] endif mod 360 = 0) then (     works := true ) else skip )  ;     i := i + 1 ) ; 
    if (works) then (     OclFile["System.out"].println("YES") ) else (     OclFile["System.out"].println("NO") ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
import java.math.*;
public class Coder {
  static StringBuffer str=new StringBuffer();
  static int n ;
  static int a[];
  static int solve(){
    int pos[]=new int[20];
    int pre[]=new int[20];
    boolean vis[]=new boolean[1<<20];
    int ans=0 ;
    for(int i=0 ; i<n ; i++){
      for(int j=19 ; j>=0 ; j--)if((a[i] &(1<<j))>0)pre[j]=i ;
      int cur=a[i];
      if(! vis[cur])ans++;
      vis[cur]=true ;
      for(int j=0 ; j<=19 ; j++)pos[j]=pre[j];
      Arrays.sort(pos);
      for(int j=19 ; j>=0 ; j--){
        cur |=a[pos[j] ];
        if(! vis[cur])ans++;
        vis[cur]=true ;
      }
    }
    return ans ;
  }
  public static void main(String[] args)throws java.lang.Exception {
    BufferedReader bf ;
    PrintWriter pw ;
    boolean lenv=false ;
    if(lenv){
      bf=new BufferedReader(new FileReader("input.txt"));
      pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
    }
    else {
      bf=new BufferedReader(new InputStreamReader(System.in));
      pw=new PrintWriter(new OutputStreamWriter(System.out));
    }
    n=Integer.parseInt(bf.readLine().trim());
    a=new int[n];
    String s[]=bf.readLine().trim().split("\\s+");
    for(int i=0 ; i<n ; i++)a[i]=Integer.parseInt(s[i]);
    str.append(solve()).append("\n");
    pw.print(str);
    pw.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Coder {
  static   attribute str : String := StringLib.newString();
  static   attribute n : int;
  static   attribute a : Sequence(int);
  static   operation solve() : int
  pre: true
  post: true
  activity: (     var pos : Sequence(int) ; pos := Integer.subrange(1,20)->collect(0) ;
     var pre : Sequence(int) ; pre := Integer.subrange(1,20)->collect(0) ;
    var vis : Sequence(boolean) ; vis := Integer.subrange(1,(1*(2->pow(20)))->oclAsType(long))->collect(false) ;
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 19 ; while j >= 0 do (     if ((a[i+1] & ((1*(2->pow(j)))->oclAsType(long))) > 0) then     pre[j+1] := i ; else skip ;  ;     j := j - 1 ) ; 
     var cur : int ; cur := a[i+1] ;
    if (not(vis[cur+1])) then     ans := ans + 1 ; else skip ; 
    vis[cur+1] := true ; 
        var j : int ; j := 0 ; while j <= 19 do (     pos[j+1] := pre[j+1] ;  ;     j := j + 1 ) ; 
    pos := pos->sort() ; 
        var j : int ; j := 19 ; while j >= 0 do ( (     cur := MathLib.bitwiseOr(cur, a[pos[j+1]+1]) ; 
     if (not(vis[cur+1])) then     ans := ans + 1 ; else skip ; 
     vis[cur+1] := true )  ;     j := j - 1 ) ; 
 )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var bf : OclFile ;
     var pw : OclFile ;
    var lenv : boolean ; lenv := false ;
    if (lenv) then (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("input.txt"))) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt")))) ) else (     bf := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ; 
     pw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile["System.out"])) ) ;  
    n := (bf.readLine()->trim())->toInteger() ; 
    a := Integer.subrange(1,n)->collect(0) ; 
    var s : Sequence(String) ; s := bf.readLine()->trim()->split("\\s+") ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := (s[i+1])->toInteger() ;  ;     i := i + 1 ) ; 
    str := str + StringLib.newString(solve()) + StringLib.newString("\n") ; 
    skip ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class S243A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] ar=new int[n];
    HashSet<Integer>an=new HashSet<>();
    for(int i=0 ; i<n ; i++){
      ar[i]=sc.nextInt();
      an.add(ar[i]);
    }
    for(int i=0 ; i<n ; i++){
      int t1=ar[i];
      int t2=0 ;
      for(int j=i+1 ; j<n ; j++){
        t1=t1 | ar[j];
        t2=t2 | ar[j];
        an.add(t1);
        if(t1==t2)break ;
      }
    }
    System.out.println(an.size());
  }
}
------------------------------------------------------------
OCL File:
---------
 class S243A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var ar : Sequence(int) ; ar := Integer.subrange(1,n)->collect(0) ;
    var an : Set(int) ; an := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     ar[i+1] := sc.getCurrent()->toInteger() ; 
     an := an->including(ar[i+1]) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     var t1 : int ; t1 := ar[i+1] ;
     var t2 : int ; t2 := 0 ;
         var j : int ; j := i + 1 ; while j < n do ( (     t1 := MathLib.bitwiseOr(t1,ar[j+1]) ; 
     t2 := MathLib.bitwiseOr(t2,ar[j+1]) ; 
     an := an->including(t1) ; 
     if (t1 = t2) then     break else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(an->size()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Akisolution {
  public static Scanner sc=new Scanner(System.in);
  public static PrintWriter out=new PrintWriter(System.out,true);
  public static int n,q ;
  public static int[][] lava ;
  public static void Input(){
    n=sc.nextInt();
    q=sc.nextInt();
    lava=new int[2][n];
  }
  public static void Solve(){
    int blockedPair=0 ;
    while(q-->0){
      int x=sc.nextInt()-1,y=sc.nextInt()-1 ;
      int delta=(lava[x][y]==0)?+1 :-1 ;
      lava[x][y]=1-lava[x][y];
      for(int dy=-1 ; dy<=1 ; dy++){
        if(y+dy<0 || y+dy>=n)continue ;
        if(lava[1-x][y+dy]==1)blockedPair+=delta ;
      }
      if(blockedPair==0)out.println("Yes");
      else out.println("No");
    }
  }
  public static void main(String[] args){
    Input();
    Solve();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Akisolution {
  static   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
  static   attribute out : OclFile := OclFile.newOclFile_Write(OclFile["System.out"], true);
  static   attribute n : int;
  static   attribute lava : Sequence(Sequence(int));
  static   operation Input() : void
  pre: true
  post: true
  activity: (     n := sc.getCurrent()->toInteger() ; 
     q := sc.getCurrent()->toInteger() ; 
     lava := Integer.subrange(1,2)->collect(Integer.subrange(1,n)->collect(0)) );
  static   operation Solve() : void
  pre: true
  post: true
  activity: (     var blockedPair : int ; blockedPair := 0 ;
         while (q > 0) do (        q := q - 1 ;     skip ; (     var x : int ; x := sc.getCurrent()->toInteger() - 1 ;
    var y : int ; y := sc.getCurrent()->toInteger() - 1 ;
     var delta : int ; delta := if (lava[x+1][y+1] = 0) then 1 else -1 endif ;
    lava[x+1][y+1] := 1 - lava[x+1][y+1] ; 
        var dy : int ; dy := -1 ; while dy <= 1 do ( (     if (y + dy < 0 or y + dy >= n) then     continue else skip ; 
     if (lava[1 - x+1][y + dy+1] = 1) then     blockedPair := blockedPair+(delta) ; else skip )  ;     dy := dy + 1 ) ; 
    if (blockedPair = 0) then     skip else     skip ; ;  
 ) ;  ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     execute Input() ; 
     execute Solve() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  void run(){
    Scanner scan=new Scanner(System.in);
    while(true){
      int n=scan.nextInt();
      int l=scan.nextInt();
      int r=scan.nextInt();
      if(n+l+r==0)return ;
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=scan.nextInt();
      int ans=0 ;
      for(int year=l ; year<=r ; year++){
        int idx=1 ;
        for(int i=0 ; i<n ; i++){
          if(year % a[i]==0)break ;
          idx++;
        }
        if(idx==n && n % 2==1)ans++;
        else if(idx % 2==1)ans++;
      }
      System.out.println(ans);
    }
  }
  public static void main(String[] args){
    new Main().run();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
   operation run() : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := scan.getCurrent()->toInteger() ;
     var l : int ; l := scan.getCurrent()->toInteger() ;
    var r : int ; r := scan.getCurrent()->toInteger() ;
    if (n + l + r = 0) then     return else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := scan.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var year : int ; year := l ; while year <= r do ( (     var idx : int ; idx := 1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (year mod a[i+1] = 0) then     break else skip ; 
     idx := idx + 1 )  ;     i := i + 1 ) ; 
     if (idx = n & n mod 2 = 1) then     ans := ans + 1 ; else     if (idx mod 2 = 1) then     ans := ans + 1 ; else skip ; )  ;     year := year + 1 ) ; 
    OclFile["System.out"].println(ans) ; 
 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().run() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.PrintWriter ;
import java.util.ArrayList ;
import java.util.List ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    PrintWriter out=new PrintWriter(System.out);
    int n=in.nextInt(),l=in.nextInt(),r=in.nextInt();
    while(n!=0){
      int[] a=new int[n+1];
      for(int i=0 ; i<n ; i++){
        a[i]=in.nextInt();
      }
      a[n]=1 ;
      int cnt=0 ;
      for(int i=l ; i<=r ; i++){
        for(int j=0 ; j<=n ; j++){
          if(i % a[j]==0){
            if(j % 2==0)cnt++;
            break ;
          }
        }
      }
      out.println(cnt);
      n=in.nextInt();
      l=in.nextInt();
      r=in.nextInt();
    }
    out.flush();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var n : int ; n := in.getCurrent()->toInteger() ;
    var l : int ; l := in.getCurrent()->toInteger() ;
    var r : int ; r := in.getCurrent()->toInteger() ;
    while (n /= 0) do (     var a : Sequence(int) ; a := Integer.subrange(1,n + 1)->collect(0) ;
         var i : int ; i := 0 ; while i < n do ( (     a[i+1] := in.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    a[n+1] := 1 ; 
    var cnt : int ; cnt := 0 ;
        var i : int ; i := l ; while i <= r do ( (         var j : int ; j := 0 ; while j <= n do ( (     if (i mod a[j+1] = 0) then (     if (j mod 2 = 0) then     cnt := cnt + 1 ; else skip ; 
     break ) else skip )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
    skip ; 
    n := in.getCurrent()->toInteger() ; 
    l := in.getCurrent()->toInteger() ; 
    r := in.getCurrent()->toInteger() ; 
 ) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
public class Main {
  public static void main(String[] args)throws IOException {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    while(true){
      String[] tmpArray=br.readLine().split(" ");
      int n=Integer.parseInt(tmpArray[0]);
      int l=Integer.parseInt(tmpArray[1]);
      int r=Integer.parseInt(tmpArray[2]);
      if(n==0){
        break ;
      }
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=Integer.parseInt(br.readLine());
      }
      int count=0 ;
      for(int i=l ; i<=r ; i++){
        boolean hit=false ;
        for(int j=0 ; j<n ; j++){
          if(i % a[j]==0){
            hit=true ;
            if(j % 2==0){
              count++;
            }
            break ;
          }
        }
        if(! hit && n % 2==0){
          count++;
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     while (true) do (     var tmpArray : Sequence(String) ; tmpArray := br.readLine()->split(" ") ;
     var n : int ; n := (tmpArray[0+1])->toInteger() ;
    var l : int ; l := (tmpArray[1+1])->toInteger() ;
    var r : int ; r := (tmpArray[2+1])->toInteger() ;
    if (n = 0) then (     break ) else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := (br.readLine())->toInteger() )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := l ; while i <= r do ( (     var hit : boolean ; hit := false ;
         var j : int ; j := 0 ; while j < n do ( (     if (i mod a[j+1] = 0) then (     hit := true ; 
     if (j mod 2 = 0) then (     count := count + 1 ) else skip ; 
     break ) else skip )  ;     j := j + 1 ) ; 
     if (not(hit) & n mod 2 = 0) then (     count := count + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int longest_substring(String s,int k){
    int n=s.length();
    if(k>1){
      s+=s ;
      n*=2 ;
    }
    int ans=0 ;
    int i=0 ;
    while(i<n){
      int x=0 ;
      while(i<n && s.charAt(i)=='0'){
        x++;
        i++;
      }
      ans=Math.max(ans,x);
      i++;
    }
    if(k==1 || ans!=n)return ans ;
    else return(ans/2)*k ;
  }
  public static void main(String[] args){
    String s="010001000" ;
    int k=4 ;
    System.out.println(longest_substring(s,k));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation longest_substring( s : String, k : int) : int
  pre: true
  post: true
  activity: (     var n : int ; n := s->size() ;
     if (k > 1) then (     s := s+(s) ; 
     n := n*(2) ) else skip ; 
    var ans : int ; ans := 0 ;
    var i : int ; i := 0 ;
    while (i < n) do (     var x : int ; x := 0 ;
     while (i < n & s->at(i+1) = '0') do (     x := x + 1 ; 
     i := i + 1 ) ; 
     ans := Set{ans, x}->max() ; 
     i := i + 1 ) ; 
    if (k = 1 or ans /= n) then     return ans else     return (ans / 2) * k ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "010001000" ;
     var k : int ; k := 4 ;
     OclFile["System.out"].println(longest_substring(s, k)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.io.*;
public class Main {
  public static void main(String[] args){
    Scanner ir=new Scanner(System.in);
    for(; ; ){
      int n=ir.nextInt();
      int l=ir.nextInt();
      int r=ir.nextInt();
      if(n==0){
        return ;
      }
      int[] a=new int[n];
      for(int i=0 ; i<n ; i++){
        a[i]=ir.nextInt();
      }
      int ct=0 ;
      outer : for(int i=l ;
      i<=r ;
      i++){
        for(int j=0 ; j<n ; j++){
          if(i % a[j]==0){
            if(j % 2==0){
              ct++;
            }
            continue outer ;
          }
        }
        if(n % 2==0){
          ct++;
        }
      }
      System.out.println(ct);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var ir : OclFile ; ir := OclFile.newOclFile_Read(OclFile["System.in"]) ;
       while true do ( (     var n : int ; n := ir.getCurrent()->toInteger() ;
     var l : int ; l := ir.getCurrent()->toInteger() ;
    var r : int ; r := ir.getCurrent()->toInteger() ;
    if (n = 0) then (     return ) else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     a[i+1] := ir.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    var ct : int ; ct := 0 ;
        var i : int ; i := l ; while i <= r do ( (         var j : int ; j := 0 ; while j < n do ( (     if (i mod a[j+1] = 0) then (     if (j mod 2 = 0) then (     ct := ct + 1 ) else skip ; 
     continue ) else skip )  ;     j := j + 1 ) ; 
     if (n mod 2 = 0) then (     ct := ct + 1 ) else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(ct) ; 
 )  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class Main {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    while(true){
      int n=sc.nextInt();
      int l=sc.nextInt();
      int r=sc.nextInt();
      if(n==0)return ;
      int a[]=new int[n];
      for(int i=0 ; i<n ; i++)a[i]=sc.nextInt();
      int count=0 ;
      for(int x=l ; x<=r ; x++){
        for(int i=1 ; i<=n ; i++){
          if(x % a[i-1]==0){
            if(i % 2==1){
              count++;
              break ;
            }
            else break ;
          }
          else if(i==n){
            if(n % 2==0)count++;
          }
        }
      }
      System.out.println(count);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (true) do (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var l : int ; l := sc.getCurrent()->toInteger() ;
    var r : int ; r := sc.getCurrent()->toInteger() ;
    if (n = 0) then     return else skip ; 
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     a[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var x : int ; x := l ; while x <= r do ( (         var i : int ; i := 1 ; while i <= n do ( (     if (x mod a[i - 1+1] = 0) then (     if (i mod 2 = 1) then (     count := count + 1 ; 
     break ) else     break ) else     if (i = n) then (     if (n mod 2 = 0) then     count := count + 1 ; else skip ) else skip ; )  ;     i := i + 1 ) )  ;     x := x + 1 ) ; 
    OclFile["System.out"].println(count) ; 
 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Rough {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    Arrays.sort(arr);
    for(int i=0 ; i<n ; i++){
      System.out.print(arr[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Rough {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    arr := arr->sort() ; 
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(arr[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class Main {
  public static void main(String[] args){
    FastScanner in=new FastScanner();
    PrintWriter out=new PrintWriter(System.out);
    int numCubes=in.nextInt();
    Integer[] cubes=new Integer[numCubes];
    for(int i=0 ; i<numCubes ; i++){
      cubes[i]=in.nextInt();
    }
    Arrays.sort(cubes);
    for(Integer cube : cubes){
      out.print(cube+" ");
    }
    out.close();
  }
  static class FastScanner {
    BufferedReader br ;
    StringTokenizer st ;
    public FastScanner(){
      try {
        br=new BufferedReader(new FileReader("sub.in"));
      }
      catch(FileNotFoundException ex){
        br=new BufferedReader(new InputStreamReader(System.in));
      }
    }
    public String next(){
      while(st==null || ! st.hasMoreTokens()){
        try {
          st=new StringTokenizer(br.readLine());
        }
        catch(IOException ex){
        }
      }
      return st.nextToken();
    }
    public int nextInt(){
      return Integer.parseInt(next());
    }
    public long nextLong(){
      return Long.parseLong(next());
    }
    public double nextDouble(){
      return Double.parseDouble(next());
    }
    public float nextFloat(){
      return Float.parseFloat(next());
    }
    public String nextLine(){
      String str="" ;
      try {
        str=br.readLine();
      }
      catch(IOException ex){
      }
      return str ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : FastScanner ; in := FastScanner.newFastScanner() ;
     var out : OclFile ; out := OclFile.newOclFile_Write(OclFile["System.out"]) ;
    var numCubes : int ; numCubes := in.nextInt() ;
    var cubes : Sequence(int) ; cubes := Integer.subrange(1,numCubes)->collect(null) ;
        var i : int ; i := 0 ; while i < numCubes do ( (     cubes[i+1] := in.nextInt() )  ;     i := i + 1 ) ; 
    cubes := cubes->sort() ; 
    for (cube : cubes) do ( (     skip )  ) ; 
    skip ; 
 );
  static class FastScanner {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastScanner() : FastScanner
  pre: true
  post: true
  activity:
  ( var self : FastScanner ;
    self := createFastScanner();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile("sub.in"))) )   catch (ex : FileNotFoundException) do (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) )
 );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (ex : IOException) do skip
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextFloat() : double
  pre: true
  post: true
  activity: (     return parseFloat(next()) );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     str := br.readLine() )   catch (ex : IOException) do skip
     return str );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int p=sc.nextInt();
    int[] q=new int[p];
    for(int i=0 ; i<p ; i++){
      q[i]=sc.nextInt();
    }
    Arrays.sort(q);
    for(int i=0 ; i<p ; i++){
      System.out.print(q[i]+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var p : int ; p := sc.getCurrent()->toInteger() ;
    var q : Sequence(int) ; q := Integer.subrange(1,p)->collect(0) ;
        var i : int ; i := 0 ; while i < p do ( (     q[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
    q := q->sort() ; 
        var i : int ; i := 0 ; while i < p do ( (     OclFile["System.out"].print(q[i+1] + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static void printArr(int arr[],int n){
    for(int i=0 ; i<n ; i++)System.out.print(arr[i]+" ");
  }
  static void sortArr(int arr[],int n,int k){
    int prev=-1 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i] % k==0){
        if(prev!=-1)Arrays.sort(arr,prev+1,i);
        prev=i ;
      }
    }
    printArr(arr,n);
  }
  public static void main(String[] args){
    int arr[]={
      2,1,13,3,7,8,21,13,12 };
      int n=arr.length ;
      int k=2 ;
      sortArr(arr,n,k);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printArr( arr : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do (     OclFile["System.out"].print(arr[i+1] + " ") ;  ;     i := i + 1 ) );
  static   operation sortArr( arr : Sequence(int), n : int, k : int) : void
  pre: true
  post: true
  activity: (     var prev : int ; prev := -1 ;
         var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] mod k = 0) then (     if (prev /= -1) then     arr := arr.subrange(1,prev + 1)^(arr.subrange(prev + 1+1,i)->sort())^arr.subrange(i+1,arr.size) ; else skip ; 
     prev := i ) else skip )  ;     i := i + 1 ) ; 
     execute printArr(arr, n) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,1,13,3,7,8,21,13,12} ;
     var n : int ; n := arr->size() ;
     var k : int ; k := 2 ;
     execute sortArr(arr, n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.math.BigInteger ;
public class Main {
  public static String solution(int n,ArrayList<Integer>times){
    int min=1000000001 ;
    int index=0 ;
    int counter=0 ;
    for(int i=0 ; i<n ; i++){
      if(times.get(i)<min){
        min=times.get(i);
        index=i+1 ;
      }
    }
    for(int i=0 ; i<n ; i++){
      if(times.get(i)==min)counter++;
    }
    if(counter>1)return "Still Rozdil" ;
    else return Integer.toString(index);
  }
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    int n=input.nextInt();
    ArrayList<Integer>times=new ArrayList<>();
    for(int i=0 ; i<n ; i++){
      times.add(input.nextInt());
    }
    System.out.println(solution(n,times));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation solution( n : int, times : Sequence(int)) : String
  pre: true
  post: true
  activity: (     var min : int ; min := 1000000001 ;
     var index : int ; index := 0 ;
    var counter : int ; counter := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (times->at(i+1) < min) then (     min := times->at(i+1) ; 
     index := i + 1 ) else skip )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (times->at(i+1) = min) then     counter := counter + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (counter > 1) then     return "Still Rozdil" else     return ((index) + "") ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := input.getCurrent()->toInteger() ;
    var times : Sequence(int) ; times := Sequence{} ;
        var i : int ; i := 0 ; while i < n do ( (     times := times->including(input.getCurrent()->toInteger()) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(solution(n, times)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class B_Nirvana {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int num=reader.nextInt();
    long prod=1L ;
    long ans=prodOfDigits(num);
    while(num>9){
      prod*=9 ;
      int digit=num % 10 ;
      num=num/10 ;
      if(digit==9){
        ans=Math.max(ans,prodOfDigits((long)(num))*prod);
      }
      else {
        ans=Math.max(ans,prodOfDigits((long)(num-1))*prod);
        num=num-1 ;
      }
    }
    System.out.println(ans);
  }
  public static long prodOfDigits(long N){
    long prod=1L ;
    while(N!=0){
      int digit=(int)(N % 10);
      if(digit==0){
        return 0 ;
      }
      else {
        prod*=digit ;
        N/=10 ;
      }
    }
    return prod ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Nirvana {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var num : int ; num := reader.nextInt() ;
    var prod : long ; prod := 1L ;
    var ans : long ; ans := prodOfDigits(num) ;
    while (num > 9) do (     prod := prod*(9) ; 
     var digit : int ; digit := num mod 10 ;
     num := num / 10 ; 
     if (digit = 9) then (     ans := Set{ans, prodOfDigits((num)->oclAsType(long)) * prod}->max() ) else (     ans := Set{ans, prodOfDigits((num - 1)->oclAsType(long)) * prod}->max() ; 
     num := num - 1 ) ) ; 
    OclFile["System.out"].println(ans) ; 
 );
  static   operation prodOfDigits( N : long) : long
  pre: true
  post: true
  activity: (     var prod : long ; prod := 1L ;
     while (N /= 0) do (     var digit : int ; digit := (N mod 10)->oclAsType(int) ;
     if (digit = 0) then (     return 0 ) else (     prod := prod*(digit) ; 
     N := N/(10) ) ) ; 
     return prod );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class RozdilElephant {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int min=1000_000_001 ;
    int min_repeat=0 ;
    int idx=-1 ;
    for(int i=0 ; i<n ; i++){
      int k=sc.nextInt();
      if(k<min){
        min=k ;
        idx=i+1 ;
      }
      else if(k==min){
        min_repeat=k ;
      }
    }
    System.out.println(min==min_repeat ? "Still Rozdil" : idx);
  }
}
------------------------------------------------------------
OCL File:
---------
 class RozdilElephant {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var min : int ; min := 1000_000_001 ;
    var min_repeat : int ; min_repeat := 0 ;
    var idx : int ; idx := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var k : int ; k := sc.getCurrent()->toInteger() ;
     if (k < min) then (     min := k ; 
     idx := i + 1 ) else     if (k = min) then (     min_repeat := k ) else skip ; )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(if min = min_repeat then "Still Rozdil" else idx endif) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int arr[]=new int[n];
    for(int i=0 ; i<n ; i++)arr[i]=sc.nextInt();
    int min=Integer.MAX_VALUE ;
    int index=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]<min){
        min=arr[i];
        index=i ;
      }
    }
    int count=0 ;
    for(int i=0 ; i<n ; i++){
      if(arr[i]==min)count++;
    }
    if(count>1)System.out.print("Still Rozdil");
    else System.out.print(index+1);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
        var i : int ; i := 0 ; while i < n do (     arr[i+1] := sc.getCurrent()->toInteger() ;  ;     i := i + 1 ) ; 
    var min : int ; min := 2147483647 ;
    var index : int ; index := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] < min) then (     min := arr[i+1] ; 
     index := i ) else skip )  ;     i := i + 1 ) ; 
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (arr[i+1] = min) then     count := count + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (count > 1) then     OclFile["System.out"].print("Still Rozdil") else     OclFile["System.out"].print(index + 1) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class thirtyeight {
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int min=Integer.MAX_VALUE,minC=0,minI=-1 ;
    for(int i=0 ; i<n ; i++){
      int a=sc.nextInt();
      if(a<min){
        min=a ;
        minI=i ;
        minC=1 ;
      }
      else if(a==min)minC++;
    }
    if(minC>1)System.out.println("Still Rozdil");
    else System.out.println(minI+1);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class thirtyeight {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var min : int ; min := 2147483647 ;
    var minC : int ; minC := 0 ;
    var minI : int ; minI := -1 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (a < min) then (     min := a ; 
     minI := i ; 
     minC := 1 ) else     if (a = min) then     minC := minC + 1 ; else skip ; )  ;     i := i + 1 ) ; 
    if (minC > 1) then     OclFile["System.out"].println("Still Rozdil") else     OclFile["System.out"].println(minI + 1) ; ;  
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class KitchenUtensils {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    ArrayList l=new ArrayList();
    HashSet h=new HashSet();
    for(int i=0 ; i<n ; i++){
      int x=sc.nextInt();
      l.add(x);
      h.add(x);
    }
    Iterator itr=h.iterator();
    int x=0 ;
    while(itr.hasNext()){
      int y=Collections.frequency(l,itr.next());
      if(y>x)x=y ;
    }
    x=x % k==0 ? x/k : x/k+1 ;
    System.out.println(x*h.size()*k-n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class KitchenUtensils {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    var l : Sequence ; l := Sequence{} ;
    var h : Set ; h := Set{} ;
        var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := sc.getCurrent()->toInteger() ;
     l := l->including(x) ; 
     h := h->including(x) )  ;     i := i + 1 ) ; 
    var itr : OclIterator ; itr := h->iterator() ;
    var x : int ; x := 0 ;
    while (itr.hasNext()) do (     var y : int ; y := .frequency(l, itr.next()) ;
     if (y > x) then     x := y ; else skip ) ; 
    x := if x mod k = 0 then x / k else x / k + 1 endif ; 
    OclFile["System.out"].println(x * h->size() * k - n) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Arrays ;
class GFG {
  static int answer(int[] arr,int[][] ranges,int reversals,int index){
    for(int i=reversals-1 ; i>=0 ; i--){
      int left=ranges[i][0],right=ranges[i][1];
      if(left<=index && right>=index)index=right+left-index ;
    }
    return arr[index];
  }
  public static void main(String[] args){
    int[] arr={
      10,20,30,40,50 };
      int reversals=2 ;
      int[][] ranges={
        {
          1,4 },{
            0,2 }
          };
          int index=1 ;
          System.out.println(answer(arr,ranges,reversals,index));
        }
      }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation answer( arr : Sequence(int), ranges : Sequence(Sequence(int)), reversals : int, index : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := reversals - 1 ; while i >= 0 do ( (     var left : int ; left := ranges[i+1][0+1] ;
    var right : int ; right := ranges[i+1][1+1] ;
     if (left <= index & right >= index) then     index := right + left - index ; else skip )  ;     i := i - 1 ) ; 
     return arr[index+1] );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{10,20,30,40,50} ;
     var reversals : int ; reversals := 2 ;
    var ranges : Sequence(Sequence(int)) ; ranges := Sequence{Sequence{1,4},Sequence{0,2}} ;
    var index : int ; index := 1 ;
    OclFile["System.out"].println(answer(arr, ranges, reversals, index)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class code {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] arr=new int[n];
    int min=Integer.MAX_VALUE,index=0,count=0 ;
    for(int i=0 ; i<n ; i++){
      arr[i]=sc.nextInt();
    }
    for(int i=0 ; i<n ; i++){
      if(min>arr[i]){
        min=arr[i];
        index=i+1 ;
        count=1 ;
      }
      else if(min==arr[i]){
        count++;
      }
    }
    if(count>1){
      System.out.println("Still Rozdil");
    }
    else {
      System.out.println(index);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class code {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n)->collect(0) ;
    var min : int ; min := 2147483647 ;
    var index : int ; index := 0 ;
    var count : int ; count := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toInteger() )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (min > arr[i+1]) then (     min := arr[i+1] ; 
     index := i + 1 ; 
     count := 1 ) else     if (min = arr[i+1]) then (     count := count + 1 ) else skip ; )  ;     i := i + 1 ) ; 
    if (count > 1) then (     OclFile["System.out"].println("Still Rozdil") ) else (     OclFile["System.out"].println(index) ) ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class solution {
  static void section(double x1,double x2,double y1,double y2,double z1,double z2,double m,double n){
    double x=((m*x2)+(n*x1))/(m+n);
    double y=((m*y2)+(n*y1))/(m+n);
    double z=((m*z2)+(n*z1))/(m+n);
    System.out.print("("+x+",");
    System.out.print(y+",");
    System.out.println(z+")");
  }
  public static void main(String arr[]){
    double x1=2,x2=4,y1=-1,y2=3,z1=4,z2=2,m=2,n=3 ;
    section(x1,x2,y1,y2,z1,z2,m,n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class solution {
  static   operation section( x1 : double, x2 : double, y1 : double, y2 : double, z1 : double, z2 : double, m : double, n : double) : void
  pre: true
  post: true
  activity: (     var x : double ; x := ((m * x2) + (n * x1)) / (m + n) ;
     var y : double ; y := ((m * y2) + (n * y1)) / (m + n) ;
    var z : double ; z := ((m * z2) + (n * z1)) / (m + n) ;
    OclFile["System.out"].print("(" + x + ",") ; 
    OclFile["System.out"].print(y + ",") ; 
    OclFile["System.out"].println(z + ")") ; 
 );
  static   operation main( arr : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var x1 : double ; x1 := 2 ;
    var x2 : double ; x2 := 4 ;
    var y1 : double ; y1 := -1 ;
    var y2 : double ; y2 := 3 ;
    var z1 : double ; z1 := 4 ;
    var z2 : double ; z2 := 2 ;
    var m : double ; m := 2 ;
    var n : double ; n := 3 ;
     execute section(x1, x2, y1, y2, z1, z2, m, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void PrintBothArrays(int a[],int n){
    Vector<Integer>v1=new Vector<Integer>(),v2=new Vector<Integer>();
    HashMap<Integer,Integer>mpp=new HashMap<>();
    for(int i=0 ; i<n ; i++){
      mpp.put(a[i],(mpp.get(a[i])==null ? 0 : mpp.get(a[i]))+1);
      if(mpp.get(a[i])==1)v1.add(a[i]);
      else if(mpp.get(a[i])==2)v2.add(a[i]);
      else {
        System.out.println("Not possible");
        return ;
      }
    }
    Collections.sort(v1);
    System.out.println("Strictly increasing array is:");
    for(int i=0 ; i<v1.size(); i++)System.out.print(v1.get(i)+" ");
    Collections.sort(v2);
    Collections.reverse(v2);
    System.out.println("\nStrictly decreasing array is:");
    for(int i=0 ; i<v2.size(); i++)System.out.print(v2.get(i)+" ");
  }
  public static void main(String args[]){
    int a[]={
      7,2,7,3,3,1,4 };
      int n=a.length ;
      PrintBothArrays(a,n);
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation PrintBothArrays( a : Sequence(int), n : int) : void
  pre: true
  post: true
  activity: (     var v1 : Sequence(int) ; v1 := Sequence{} ;
    var v2 : Sequence(int) ; v2 := Sequence{} ;
     var mpp : Map(int,int) ; mpp := Map{} ;
        var i : int ; i := 0 ; while i < n do ( (     mpp := mpp->union(Map{a[i+1] |-> (if mpp->at(a[i+1]) = null then 0 else mpp->at(a[i+1]) endif) + 1}) ; 
     if (mpp->at(a[i+1]) = 1) then     v1 := v1->including(a[i+1]) ; else     if (mpp->at(a[i+1]) = 2) then     v2->excludes(a[i+1]) else (     OclFile["System.out"].println("Not possible") ; 
     return ) ;  )  ;     i := i + 1 ) ; 
    v1 := v1->sort() ; 
    OclFile["System.out"].println("Strictly increasing array is:") ; 
        var i : int ; i := 0 ; while i < v1->size() do (     OclFile["System.out"].print(v1->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
    v2 := v2->sort() ; 
    v2 := v2->reverse() ; 
    OclFile["System.out"].println("\nStrictly decreasing array is:") ; 
        var i : int ; i := 0 ; while i < v2->size() do (     OclFile["System.out"].print(v2->at(i+1) + " ") ;  ;     i := i + 1 ) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{7,2,7,3,3,1,4} ;
     var n : int ; n := a->size() ;
     execute PrintBothArrays(a, n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class C_MashmokhAndNumbers {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    if(((n/2)>k)||(n<2 && k!=0)){
      System.out.println(-1);
      return ;
    }
    if(n==1 && k==0){
      System.out.println(1);
      return ;
    }
    int j=1000000000 ;
    for(int i=0 ; i<(n/2)-1 ; i++){
      System.out.print((j--)+" "+(j--)+" ");
      k-=1 ;
    }
    System.out.print(k+" "+(k*2));
    if(n % 2!=0){
      System.out.print(" "+j);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class C_MashmokhAndNumbers {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var k : int ; k := sc.getCurrent()->toInteger() ;
    if (((n / 2) > k) or (n < 2 & k /= 0)) then (     OclFile["System.out"].println(-1) ; 
     return ) else skip ; 
    if (n = 1 & k = 0) then (     OclFile["System.out"].println(1) ; 
     return ) else skip ; 
    var j : int ; j := 1000000000 ;
        var i : int ; i := 0 ; while i < (n / 2) - 1 do ( (     OclFile["System.out"].print((j) + " " + (j) + " ") ; 
     k := k-(1) )  ;     i := i + 1 ) ; 
    OclFile["System.out"].print(k + " " + (k * 2)) ; 
    if (n mod 2 /= 0) then (     OclFile["System.out"].print(" " + j) ) else skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int k=sc.nextInt();
    if(n==1){
      System.out.println(k==0 ? "1" : "-1");
    }
    else {
      if(n/2>k){
        System.out.println(-1);
      }
      else {
        StringBuilder sb=new StringBuilder();
        int first=k-n/2+1 ;
        sb.append(first).append(" ");
        sb.append(first*2).append(" ");
        for(int i=0,j=first*2+1 ; i<n-2 ; i++,j++){
          sb.append(j).append(" ");
        }
        System.out.println(sb.toString().trim());
      }
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
     var k : int ; k := sc.getCurrent()->toInteger() ;
     if (n = 1) then (     OclFile["System.out"].println(if k = 0 then "1" else "-1" endif) ) else (     if (n / 2 > k) then (     OclFile["System.out"].println(-1) ) else (     var sb : String ; sb := StringLib.newString() ;
     var first : int ; first := k - n / 2 + 1 ;
    sb := sb + StringLib.newString(first) + StringLib.newString(" ") ; 
    sb := sb + StringLib.newString(first * 2) + StringLib.newString(" ") ; 
        var i : int ; i := 0 ;
    var j : int ; j := first * 2 + 1 ; while i < n - 2 do ( (     sb := sb + StringLib.newString(j) + StringLib.newString(" ") )  ;     i := i + 1 ;     j := j + 1 ) ; 
    OclFile["System.out"].println(sb+""->trim()) ; 
 ) ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.*;
public class B_Nirvana {
  public static class FastReader {
    BufferedReader br ;
    StringTokenizer st ;
    public FastReader(){
      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 {
        if(st.hasMoreTokens()){
          str=st.nextToken("\n");
        }
        else {
          str=br.readLine();
        }
      }
      catch(IOException e){
        e.printStackTrace();
      }
      return str ;
    }
  }
  public static void main(String[] args){
    FastReader reader=new FastReader();
    int num=reader.nextInt();
    long prod=1L ;
    if(num<10){
      System.out.println(num);
    }
    else {
      long ans=prodOfDigits(num);
      while(num>9){
        prod*=9 ;
        int digit=num % 10 ;
        num=num/10 ;
        if(digit==9){
          ans=Math.max(ans,prodOfDigits((long)(num))*prod);
        }
        else {
          ans=Math.max(ans,prodOfDigits((long)(num-1))*prod);
          num=num-1 ;
        }
      }
      System.out.println(ans);
    }
  }
  public static long prodOfDigits(long N){
    long prod=1L ;
    while(N!=0){
      int digit=(int)(N % 10);
      if(digit==0){
        return 0 ;
      }
      else {
        prod*=digit ;
        N/=10 ;
      }
    }
    return prod ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class B_Nirvana {
  static class FastReader {
   attribute br : OclFile;
   attribute st : OclIterator;
   static operation newFastReader() : FastReader
  pre: true
  post: true
  activity:
  ( var self : FastReader ;
    self := createFastReader();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) );
   operation next() : String
  pre: true
  post: true
  activity: (     while (st = null or not(st.hasNext())) do (     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ) ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextDouble() : double
  pre: true
  post: true
  activity: (     return (next())->toReal() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var str : String ; str := "" ;
     try (     if (st.hasNext()) then (     str := st.nextToken("\n") ) else (     str := br.readLine() ) )   catch (e : IOException) do (     e.printStackTrace() )
     return str );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : FastReader ; reader := FastReader.newFastReader() ;
     var num : int ; num := reader.nextInt() ;
     var prod : long ; prod := 1L ;
     if (num < 10) then (     OclFile["System.out"].println(num) ) else (     var ans : long ; ans := prodOfDigits(num) ;
     while (num > 9) do (     prod := prod*(9) ; 
     var digit : int ; digit := num mod 10 ;
     num := num / 10 ; 
     if (digit = 9) then (     ans := Set{ans, prodOfDigits((num)->oclAsType(long)) * prod}->max() ) else (     ans := Set{ans, prodOfDigits((num - 1)->oclAsType(long)) * prod}->max() ; 
     num := num - 1 ) ) ; 
     OclFile["System.out"].println(ans) ) );
  static   operation prodOfDigits( N : long) : long
  pre: true
  post: true
  activity: (     var prod : long ; prod := 1L ;
     while (N /= 0) do (     var digit : int ; digit := (N mod 10)->oclAsType(int) ;
     if (digit = 0) then (     return 0 ) else (     prod := prod*(digit) ; 
     N := N/(10) ) ) ; 
     return prod );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  public static boolean checkdigit(int n,int k){
    while(n!=0){
      int rem=n % 10 ;
      if(rem==k)return true ;
      n=n/10 ;
    }
    return false ;
  }
  public static int findNthNumber(int n,int k){
    for(int i=k+1,count=1 ; count<n ; i++){
      if(checkdigit(i,k)||(i % k==0))count++;
      if(count==n)return i ;
    }
    return-1 ;
  }
  public static void main(String[] args){
    int n=10,k=2 ;
    System.out.println(findNthNumber(n,k));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkdigit( n : int, k : int) : boolean
  pre: true
  post: true
  activity: (     while (n /= 0) do (     var rem : int ; rem := n mod 10 ;
     if (rem = k) then     return true else skip ; 
     n := n / 10 ) ; 
     return false );
  static   operation findNthNumber( n : int, k : int) : int
  pre: true
  post: true
  activity: (         var i : int ; i := k + 1 ;
    var count : int ; count := 1 ; while count < n do ( (     if (checkdigit(i, k) or (i mod k = 0)) then     count := count + 1 ; else skip ; 
     if (count = n) then     return i else skip )  ;     i := i + 1 ) ; 
     return -1 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 10 ;
    var k : int ; k := 2 ;
     OclFile["System.out"].println(findNthNumber(n, k)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class MyClass {
  public static void main(String args[]){
    int i,c,t,cc,r=0 ;
    long s ;
    Scanner sc=new Scanner(System.in);
    t=sc.nextInt();
    while(t!=0){
      s=0 ;
      int n=sc.nextInt();
      long l3,l4,l1,l2 ;
      int p ;
      long a[]=new long[n];
      long b[]=new long[n];
      for(i=0 ; i<n ; i++){
        a[i]=sc.nextLong();
        p=(int)(Math.log(a[i])/Math.log(2));
        p=(int)Math.pow(2,p);
        System.out.print(p+" ");
      }
      System.out.println();
      t--;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class MyClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var i : int ;
    var c : int ;
    var t : int ;
    var cc : int ;
    var r : int ; r := 0 ;
     var s : long ;
    var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    t := sc.getCurrent()->toInteger() ; 
    while (t /= 0) do (     s := 0 ; 
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var l3 : long ;
    var l4 : long ;
    var l1 : long ;
    var l2 : long ;
    var p : int ;
    var a : Sequence(long) ; a := Integer.subrange(1,n)->collect(0) ;
    var b : Sequence(long) ; b := Integer.subrange(1,n)->collect(0) ;
        i := 0 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toLong() ; 
     p := ((a[i+1])->log() / (2)->log())->oclAsType(int) ; 
     p := 2->pow(p)->oclAsType(int) ; 
     OclFile["System.out"].print(p + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println() ; 
    t := t - 1 ; 
 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class GFG {
  public static class Pair {
    int first ;
    int second ;
    Pair(int first,int second){
      this.first=first ;
      this.second=second ;
    }
  }
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    while(t-->0){
      int n=sc.nextInt();
      long[] arr=new long[n];
      long S=0 ;
      for(int i=0 ; i<n ; i++){
        arr[i]=sc.nextLong();
        S+=arr[i];
      }
      long[] left=new long[n];
      long[] right=new long[n];
      long suml=0,sumr=0 ;
      for(int i=0 ; i<n ; i++){
        if(i % 2==0)left[i]=1 ;
        else left[i]=arr[i];
        suml+=Math.abs(left[i]-arr[i]);
      }
      for(int i=0 ; i<n ; i++){
        if(i % 2==1)right[i]=1 ;
        else right[i]=arr[i];
        sumr+=Math.abs(right[i]-arr[i]);
      }
      if(2*suml<=S){
        for(int i=0 ; i<n ; i++){
          System.out.print(left[i]+" ");
        }
      }
      else {
        for(int i=0 ; i<n ; i++){
          System.out.print(right[i]+" ");
        }
      }
      System.out.println();
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static class Pair {
   attribute first : int;
   attribute second : int;
   static operation newPair( first : int, second : int) : Pair
  pre: true
  post: true
  activity:
  ( var self : Pair ;
    self := createPair();
    self.initialise(first, second);
    return self );
  operation initialise( first : int, second : int) : void
  pre: true  post: true
  activity: (     self->at("first") := first ; 
     self->at("second") := second );
}
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
         while (t > 0) do (        t := t - 1 ;     skip ; (     var n : int ; n := sc.getCurrent()->toInteger() ;
     var arr : Sequence(long) ; arr := Integer.subrange(1,n)->collect(0) ;
    var S : long ; S := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     arr[i+1] := sc.getCurrent()->toLong() ; 
     S := S+(arr[i+1]) )  ;     i := i + 1 ) ; 
    var left : Sequence(long) ; left := Integer.subrange(1,n)->collect(0) ;
    var right : Sequence(long) ; right := Integer.subrange(1,n)->collect(0) ;
    var suml : long ; suml := 0 ;
    var sumr : long ; sumr := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then     left[i+1] := 1 else     left[i+1] := arr[i+1] ; ;  
     suml := suml+(if left[i+1] - arr[i+1] < 0 then -(left[i+1] - arr[i+1]) else left[i+1] - arr[i+1] endif) )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 1) then     right[i+1] := 1 else     right[i+1] := arr[i+1] ; ;  
     sumr := sumr+(if right[i+1] - arr[i+1] < 0 then -(right[i+1] - arr[i+1]) else right[i+1] - arr[i+1] endif) )  ;     i := i + 1 ) ; 
    if (2 * suml <= S) then (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(left[i+1] + " ") )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(right[i+1] + " ") )  ;     i := i + 1 ) ) ;  
    OclFile["System.out"].println() ; 
 ) ;  ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    long[] arr=new long[n+1];
    for(int i=1 ; i<=n ; i++){
      arr[i]=sc.nextInt();
      arr[i]+=arr[i-1];
    }
    int left=2 ;
    int right=4 ;
    long min=Long.MAX_VALUE ;
    for(int center=3 ; center<=n-1 ; center++){
      while(left<center && Math.abs(arr[center-1]-2*arr[left-1])>Math.abs(arr[center-1]-2*arr[left])){
        left++;
      }
      while(center>=right){
        right++;
      }
      while(right<n && Math.abs(arr[n]-2*arr[right-1]+arr[center-1])>Math.abs(arr[n]-2*arr[right]+arr[center-1])){
        right++;
      }
      min=Math.min(min,getMax(arr[left-1],arr[center-1]-arr[left-1],arr[right-1]-arr[center-1],arr[n]-arr[right-1]));
    }
    System.out.println(min);
  }
  static long getMax(long a,long b,long c,long d){
    return Math.max(Math.max(a,b),Math.max(c,d))-Math.min(Math.min(a,b),Math.min(c,d));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var arr : Sequence(long) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := sc.getCurrent()->toInteger() ; 
     arr[i+1] := arr[i+1]+(arr[i - 1+1]) )  ;     i := i + 1 ) ; 
    var left : int ; left := 2 ;
    var right : int ; right := 4 ;
    var min : long ; min := "9223372036854775807"->toLong() ;
        var center : int ; center := 3 ; while center <= n - 1 do ( (     while (left < center & if arr[center - 1+1] - 2 * arr[left - 1+1] < 0 then -(arr[center - 1+1] - 2 * arr[left - 1+1]) else arr[center - 1+1] - 2 * arr[left - 1+1] endif > if arr[center - 1+1] - 2 * arr[left+1] < 0 then -(arr[center - 1+1] - 2 * arr[left+1]) else arr[center - 1+1] - 2 * arr[left+1] endif) do (     left := left + 1 ) ; 
     while (center >= right) do (     right := right + 1 ) ; 
     while (right < n & if arr[n+1] - 2 * arr[right - 1+1] + arr[center - 1+1] < 0 then -(arr[n+1] - 2 * arr[right - 1+1] + arr[center - 1+1]) else arr[n+1] - 2 * arr[right - 1+1] + arr[center - 1+1] endif > if arr[n+1] - 2 * arr[right+1] + arr[center - 1+1] < 0 then -(arr[n+1] - 2 * arr[right+1] + arr[center - 1+1]) else arr[n+1] - 2 * arr[right+1] + arr[center - 1+1] endif) do (     right := right + 1 ) ; 
     min := Set{min, getMax(arr[left - 1+1], arr[center - 1+1] - arr[left - 1+1], arr[right - 1+1] - arr[center - 1+1], arr[n+1] - arr[right - 1+1])}->min() )  ;     center := center + 1 ) ; 
    OclFile["System.out"].println(min) ; 
 );
  static   operation getMax( a : long, b : long, c : long, d : long) : long
  pre: true
  post: true
  activity: (     return Set{Set{a, b}->max(), Set{c, d}->max()}->max() - Set{Set{a, b}->min(), Set{c, d}->min()}->min() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int[] a=new int[n];
    long[] sum=new long[n];
    a[0]=sc.nextInt();
    sum[0]=a[0];
    for(int i=1 ; i<n ; i++){
      a[i]=sc.nextInt();
      sum[i]=sum[i-1]+a[i];
    }
    long minDiff=Long.MAX_VALUE ;
    int sep1=0 ;
    int sep3=2 ;
    for(int sep2=1 ; sep2<=n-3 ; sep2++){
      long minOfDiff=Long.MAX_VALUE ;
      for(int j=sep1 ; j<=sep2-1 ; j++){
        long diff=Math.abs((sum[sep2]-sum[j])-sum[j]);
        if(diff<minOfDiff){
          minOfDiff=diff ;
          sep1=j ;
        }
        else {
          break ;
        }
      }
      minOfDiff=Long.MAX_VALUE ;
      for(int j=sep3 ; j<=n-2 ; j++){
        long diff=Math.abs((sum[n-1]-sum[j])-(sum[j]-sum[sep2]));
        if(diff<minOfDiff){
          minOfDiff=diff ;
          sep3=j ;
        }
        else {
          break ;
        }
      }
      long b=sum[sep1];
      long c=sum[sep2]-sum[sep1];
      long d=sum[sep3]-sum[sep2];
      long e=sum[n-1]-sum[sep3];
      long max=Math.max(Math.max(b,c),Math.max(d,e));
      long min=Math.min(Math.min(b,c),Math.min(d,e));
      minDiff=max-min<minDiff ? max-min : minDiff ;
    }
    System.out.println(minDiff);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : Sequence(int) ; a := Integer.subrange(1,n)->collect(0) ;
    var sum : Sequence(long) ; sum := Integer.subrange(1,n)->collect(0) ;
    a[0+1] := sc.getCurrent()->toInteger() ; 
    sum[0+1] := a[0+1] ; 
        var i : int ; i := 1 ; while i < n do ( (     a[i+1] := sc.getCurrent()->toInteger() ; 
     sum[i+1] := sum[i - 1+1] + a[i+1] )  ;     i := i + 1 ) ; 
    var minDiff : long ; minDiff := "9223372036854775807"->toLong() ;
    var sep1 : int ; sep1 := 0 ;
    var sep3 : int ; sep3 := 2 ;
        var sep2 : int ; sep2 := 1 ; while sep2 <= n - 3 do ( (     var minOfDiff : long ; minOfDiff := "9223372036854775807"->toLong() ;
         var j : int ; j := sep1 ; while j <= sep2 - 1 do ( (     var diff : long ; diff := if (sum[sep2+1] - sum[j+1]) - sum[j+1] < 0 then -((sum[sep2+1] - sum[j+1]) - sum[j+1]) else (sum[sep2+1] - sum[j+1]) - sum[j+1] endif ;
     if (diff < minOfDiff) then (     minOfDiff := diff ; 
     sep1 := j ) else (     break ) )  ;     j := j + 1 ) ; 
    minOfDiff := "9223372036854775807"->toLong() ; 
        var j : int ; j := sep3 ; while j <= n - 2 do ( (     var diff : long ; diff := if (sum[n - 1+1] - sum[j+1]) - (sum[j+1] - sum[sep2+1]) < 0 then -((sum[n - 1+1] - sum[j+1]) - (sum[j+1] - sum[sep2+1])) else (sum[n - 1+1] - sum[j+1]) - (sum[j+1] - sum[sep2+1]) endif ;
     if (diff < minOfDiff) then (     minOfDiff := diff ; 
     sep3 := j ) else (     break ) )  ;     j := j + 1 ) ; 
    var b : long ; b := sum[sep1+1] ;
    var c : long ; c := sum[sep2+1] - sum[sep1+1] ;
    var d : long ; d := sum[sep3+1] - sum[sep2+1] ;
    var e : long ; e := sum[n - 1+1] - sum[sep3+1] ;
    var max : long ; max := Set{Set{b, c}->max(), Set{d, e}->max()}->max() ;
    var min : long ; min := Set{Set{b, c}->min(), Set{d, e}->min()}->min() ;
    minDiff := if max - min < minDiff then max - min else minDiff endif ; 
 )  ;     sep2 := sep2 + 1 ) ; 
    OclFile["System.out"].println(minDiff) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap ;
class GFG {
  static int countPairs(int arr[],int n){
    HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++)map.put(arr[i]-i,0);
    for(int i=0 ; i<n ; i++)map.put(arr[i]-i,map.get(arr[i]-i)+1);
    int res=0 ;
    for(int x : map.values()){
      int cnt=x ;
      res+=((cnt*(cnt-1))/2);
    }
    return res ;
  }
  public static void main(String[] args){
    int arr[]={
      1,5,6,7,9 };
      int n=arr.length ;
      System.out.println(countPairs(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPairs( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var map : Map(int,int) ; map := Map{} ;
         var i : int ; i := 0 ; while i < n do (     map := map->union(Map{arr[i+1] - i |-> 0}) ;  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < n do (     map := map->union(Map{arr[i+1] - i |-> map->at(arr[i+1] - i) + 1}) ;  ;     i := i + 1 ) ; 
    var res : int ; res := 0 ;
    for (x : map->values()) do ( (     var cnt : int ; cnt := x ;
     res := res+(((cnt * (cnt - 1)) / 2)) )  ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,5,6,7,9} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println(countPairs(arr, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.util.Arrays ;
import java.util.Scanner ;
public final class Main {
  public static void main(String[] args){
    final Scanner in=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    final int n=Integer.parseInt(in.nextLine());
    final int[] arr=new int[n+1];
    final long[] pre=new long[n+1];
    for(int i=1 ; i<=n ; i++){
      arr[i]=in.nextInt();
      pre[i]+=pre[i-1]+arr[i];
    }
    in.nextLine();
    long res=(long)1e16 ;
    final long[] diff=new long[4];
    int l=1,r=3 ;
    for(int mid=2 ; mid<=n-2 ; mid++){
      while(l<mid && Math.abs(pre[l]-(pre[mid]-pre[l]))>=Math.abs(pre[l+1]-(pre[mid]-pre[l+1]))){
        l++;
      }
      while(r<n && Math.abs(pre[r]-pre[mid]-(pre[n]-pre[r]))>=Math.abs(pre[r+1]-pre[mid]-(pre[n]-pre[r+1]))){
        r++;
      }
      diff[0]=pre[l];
      diff[1]=pre[mid]-pre[l];
      diff[2]=pre[r]-pre[mid];
      diff[3]=pre[n]-pre[r];
      Arrays.sort(diff);
      res=Math.min(res,diff[3]-diff[0]);
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]))) ;
     var n : int ; n := (in.nextLine())->toInteger() ;
    var arr : Sequence(int) ; arr := Integer.subrange(1,n + 1)->collect(0) ;
    var pre : Sequence(long) ; pre := Integer.subrange(1,n + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= n do ( (     arr[i+1] := in.getCurrent()->toInteger() ; 
     pre[i+1] := pre[i+1]+(pre[i - 1+1] + arr[i+1]) )  ;     i := i + 1 ) ; 
    skip ; 
    var res : long ; res := 1e16->oclAsType(long) ;
    var diff : Sequence(long) ; diff := Integer.subrange(1,4)->collect(0) ;
    var l : int ; l := 1 ;
    var r : int ; r := 3 ;
        var mid : int ; mid := 2 ; while mid <= n - 2 do ( (     while (l < mid & if pre[l+1] - (pre[mid+1] - pre[l+1]) < 0 then -(pre[l+1] - (pre[mid+1] - pre[l+1])) else pre[l+1] - (pre[mid+1] - pre[l+1]) endif >= if pre[l + 1+1] - (pre[mid+1] - pre[l + 1+1]) < 0 then -(pre[l + 1+1] - (pre[mid+1] - pre[l + 1+1])) else pre[l + 1+1] - (pre[mid+1] - pre[l + 1+1]) endif) do (     l := l + 1 ) ; 
     while (r < n & if pre[r+1] - pre[mid+1] - (pre[n+1] - pre[r+1]) < 0 then -(pre[r+1] - pre[mid+1] - (pre[n+1] - pre[r+1])) else pre[r+1] - pre[mid+1] - (pre[n+1] - pre[r+1]) endif >= if pre[r + 1+1] - pre[mid+1] - (pre[n+1] - pre[r + 1+1]) < 0 then -(pre[r + 1+1] - pre[mid+1] - (pre[n+1] - pre[r + 1+1])) else pre[r + 1+1] - pre[mid+1] - (pre[n+1] - pre[r + 1+1]) endif) do (     r := r + 1 ) ; 
    diff[0+1] := pre[l+1] ; 
    diff[1+1] := pre[mid+1] - pre[l+1] ; 
    diff[2+1] := pre[r+1] - pre[mid+1] ; 
    diff[3+1] := pre[n+1] - pre[r+1] ; 
    diff := diff->sort() ; 
    res := Set{res, diff[3+1] - diff[0+1]}->min() ; 
 )  ;     mid := mid + 1 ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(final String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int n=scanner.nextInt();
    final long[] cumulativeSum=new long[n];
    cumulativeSum[0]=scanner.nextLong();
    for(int i=1 ; i<n ; i++){
      cumulativeSum[i]=cumulativeSum[i-1]+scanner.nextLong();
    }
    int firstIndex=0 ;
    int thirdIndex=2 ;
    long answer=Integer.MAX_VALUE ;
    for(int secondIndex=1 ; secondIndex<n-2 ; secondIndex++){
      for(; firstIndex<secondIndex-1 ; firstIndex++){
        if(Math.abs(cumulativeSum[secondIndex]-cumulativeSum[firstIndex]*2)<=Math.abs((cumulativeSum[secondIndex]-cumulativeSum[firstIndex+1]*2))){
          break ;
        }
      }
      for(; thirdIndex<n-2 ; thirdIndex++){
        if(Math.abs(cumulativeSum[n-1]-cumulativeSum[thirdIndex]*2+cumulativeSum[secondIndex])<=Math.abs(cumulativeSum[n-1]-cumulativeSum[thirdIndex+1]*2+cumulativeSum[secondIndex])){
          break ;
        }
      }
      long a=cumulativeSum[firstIndex];
      long b=cumulativeSum[secondIndex]-cumulativeSum[firstIndex];
      long c=cumulativeSum[thirdIndex]-cumulativeSum[secondIndex];
      long d=cumulativeSum[n-1]-cumulativeSum[thirdIndex];
      long tmp=max(a,b,c,d)-min(a,b,c,d);
      answer=Math.min(tmp,answer);
    }
    System.out.println(answer);
  }
  private static long max(final long a,final long b,final long c,final long d){
    return Math.max(Math.max(a,b),Math.max(c,d));
  }
  private static long min(final long a,final long b,final long c,final long d){
    return Math.min(Math.min(a,b),Math.min(c,d));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var cumulativeSum : Sequence(long) ; cumulativeSum := Integer.subrange(1,n)->collect(0) ;
    cumulativeSum[0+1] := scanner.getCurrent()->toLong() ; 
        var i : int ; i := 1 ; while i < n do ( (     cumulativeSum[i+1] := cumulativeSum[i - 1+1] + scanner.getCurrent()->toLong() )  ;     i := i + 1 ) ; 
    var firstIndex : int ; firstIndex := 0 ;
    var thirdIndex : int ; thirdIndex := 2 ;
    var answer : long ; answer := 2147483647 ;
        var secondIndex : int ; secondIndex := 1 ; while secondIndex < n - 2 do ( (       while firstIndex < secondIndex - 1 do ( (     if (if cumulativeSum[secondIndex+1] - cumulativeSum[firstIndex+1] * 2 < 0 then -(cumulativeSum[secondIndex+1] - cumulativeSum[firstIndex+1] * 2) else cumulativeSum[secondIndex+1] - cumulativeSum[firstIndex+1] * 2 endif <= if (cumulativeSum[secondIndex+1] - cumulativeSum[firstIndex + 1+1] * 2) < 0 then -((cumulativeSum[secondIndex+1] - cumulativeSum[firstIndex + 1+1] * 2)) else (cumulativeSum[secondIndex+1] - cumulativeSum[firstIndex + 1+1] * 2) endif) then (     break ) else skip )  ;     firstIndex := firstIndex + 1 ) ; 
       while thirdIndex < n - 2 do ( (     if (if cumulativeSum[n - 1+1] - cumulativeSum[thirdIndex+1] * 2 + cumulativeSum[secondIndex+1] < 0 then -(cumulativeSum[n - 1+1] - cumulativeSum[thirdIndex+1] * 2 + cumulativeSum[secondIndex+1]) else cumulativeSum[n - 1+1] - cumulativeSum[thirdIndex+1] * 2 + cumulativeSum[secondIndex+1] endif <= if cumulativeSum[n - 1+1] - cumulativeSum[thirdIndex + 1+1] * 2 + cumulativeSum[secondIndex+1] < 0 then -(cumulativeSum[n - 1+1] - cumulativeSum[thirdIndex + 1+1] * 2 + cumulativeSum[secondIndex+1]) else cumulativeSum[n - 1+1] - cumulativeSum[thirdIndex + 1+1] * 2 + cumulativeSum[secondIndex+1] endif) then (     break ) else skip )  ;     thirdIndex := thirdIndex + 1 ) ; 
    var a : long ; a := cumulativeSum[firstIndex+1] ;
    var b : long ; b := cumulativeSum[secondIndex+1] - cumulativeSum[firstIndex+1] ;
    var c : long ; c := cumulativeSum[thirdIndex+1] - cumulativeSum[secondIndex+1] ;
    var d : long ; d := cumulativeSum[n - 1+1] - cumulativeSum[thirdIndex+1] ;
    var tmp : long ; tmp := max(a, b, c, d) - min(a, b, c, d) ;
    answer := Set{tmp, answer}->min() ; 
 )  ;     secondIndex := secondIndex + 1 ) ; 
    OclFile["System.out"].println(answer) ; 
 );
  static   operation max( a : long, b : long, c : long, d : long) : long
  pre: true
  post: true
  activity: (     return Set{Set{a, b}->max(), Set{c, d}->max()}->max() );
  static   operation min( a : long, b : long, c : long, d : long) : long
  pre: true
  post: true
  activity: (     return Set{Set{a, b}->min(), Set{c, d}->min()}->min() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int N=scanner.nextInt();
    long[] A=new long[N];
    long sum=0 ;
    for(int i=0 ; i<N ; i++){
      A[i]=scanner.nextInt();
      sum+=A[i];
    }
    int j=0,k=2 ;
    long p=A[0],q=0,r=A[1]+A[2],s=sum-A[0]-A[1]-A[2];
    long minMaxDiff=Long.MAX_VALUE ;
    for(int i=1 ; i<N-2 ; i++){
      q+=A[i];
      long diffPQ=Math.abs(p-q);
      while(j<i && Math.abs(p+A[j+1]-q+A[j+1])<diffPQ){
        j++;
        p+=A[j];
        q-=A[j];
        diffPQ=Math.abs(p-q);
      }
      r-=A[i];
      long diffRS=Math.abs(r-s);
      while(k<N-1 && Math.abs(r+A[k+1]-s+A[k+1])<diffRS){
        k++;
        r+=A[k];
        s-=A[k];
        diffRS=Math.abs(r-s);
      }
      long maxDiff=maxDiff(p,q,r,s);
      if(maxDiff<minMaxDiff)minMaxDiff=maxDiff ;
    }
    System.out.println(minMaxDiff);
  }
  static long maxDiff(long p,long q,long r,long s){
    if(p>q)return maxDiff(q,p,r,s);
    if(q>r)return maxDiff(p,r,q,s);
    if(r>s)return maxDiff(p,q,s,r);
    return s-p ;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := scanner.getCurrent()->toInteger() ;
    var A : Sequence(long) ; A := Integer.subrange(1,N)->collect(0) ;
    var sum : long ; sum := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     A[i+1] := scanner.getCurrent()->toInteger() ; 
     sum := sum+(A[i+1]) )  ;     i := i + 1 ) ; 
    var j : int ; j := 0 ;
    var k : int ; k := 2 ;
    var p : long ; p := A[0+1] ;
    var q : long ; q := 0 ;
    var r : long ; r := A[1+1] + A[2+1] ;
    var s : long ; s := sum - A[0+1] - A[1+1] - A[2+1] ;
    var minMaxDiff : long ; minMaxDiff := "9223372036854775807"->toLong() ;
        var i : int ; i := 1 ; while i < N - 2 do ( (     q := q+(A[i+1]) ; 
     var diffPQ : long ; diffPQ := if p - q < 0 then -(p - q) else p - q endif ;
    while (j < i & if p + A[j + 1+1] - q + A[j + 1+1] < 0 then -(p + A[j + 1+1] - q + A[j + 1+1]) else p + A[j + 1+1] - q + A[j + 1+1] endif < diffPQ) do (     j := j + 1 ; 
     p := p+(A[j+1]) ; 
     q := q-(A[j+1]) ; 
     diffPQ := if p - q < 0 then -(p - q) else p - q endif ) ; 
    r := r-(A[i+1]) ; 
    var diffRS : long ; diffRS := if r - s < 0 then -(r - s) else r - s endif ;
    while (k < N - 1 & if r + A[k + 1+1] - s + A[k + 1+1] < 0 then -(r + A[k + 1+1] - s + A[k + 1+1]) else r + A[k + 1+1] - s + A[k + 1+1] endif < diffRS) do (     k := k + 1 ; 
     r := r+(A[k+1]) ; 
     s := s-(A[k+1]) ; 
     diffRS := if r - s < 0 then -(r - s) else r - s endif ) ; 
    var maxDiff : long ; maxDiff := maxDiff(p, q, r, s) ;
    if (maxDiff < minMaxDiff) then     minMaxDiff := maxDiff ; else skip ; 
 )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(minMaxDiff) ; 
 );
  static   operation maxDiff( p : long, q : long, r : long, s : long) : long
  pre: true
  post: true
  activity: (     if (p > q) then     return maxDiff(q, p, r, s) else skip ; 
     if (q > r) then     return maxDiff(p, r, q, s) else skip ; 
     if (r > s) then     return maxDiff(p, q, s, r) else skip ; 
     return s - p );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean checkForElement(int array[],int n){
    Set<Integer>s=new LinkedHashSet<>();
    int sum=0 ;
    for(int i=0 ; i<n ; i++){
      sum+=array[i];
      s.add(array[i]);
    }
    if(sum % 2==0 && s.contains(sum/2)&&(sum/2)==s.stream().skip(s.size()-1).findFirst().get()){
      return true ;
    }
    else {
      return false ;
    }
  }
  public static void main(String[] args){
    int array[]={
      1,2,3 };
      int n=array.length ;
      System.out.println(checkForElement(array,n)? "Yes" : "No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation checkForElement( array : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var s : Set(int) ; s := Set{} ;
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < n do ( (     sum := sum+(array[i+1]) ; 
     s := s->including(array[i+1]) )  ;     i := i + 1 ) ; 
     if (sum mod 2 = 0 & s->includes(sum / 2) & (sum / 2) = s.subrange(s->size() - 1+1)->first().get()) then (     return true ) else (     return false ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var array : Sequence(int) ; array := Sequence{1,2,3} ;
     var n : int ; n := array->size() ;
     OclFile["System.out"].println(if checkForElement(array, n) then "Yes" else "No" endif) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long n=sc.nextLong();
    int len=(""+n).length();
    int[] bits=new int[len+1];
    for(int i=1 ; i<=len ; i++){
      bits[i]=(int)(n % 10);
      n/=10 ;
    }
    long[][] dp=new long[len+1][2];
    dp[0][0]=1 ;
    dp[0][1]=1 ;
    for(int i=1 ; i<=len ; i++){
      dp[i][0]=dp[i-1][0]*bits[i];
      if(i!=len || i==len && bits[i]!=1)dp[i][0]=Math.max(dp[i][0],dp[i-1][1]*Math.max(0,bits[i]-1));
      else dp[i][0]=Math.max(dp[i][0],dp[i-1][1]);
      dp[i][1]=dp[i-1][1]*9 ;
      if(bits[i]<9)dp[i][1]=Math.max(dp[i][1],dp[i-1][0]*9);
    }
    System.out.println(dp[len][0]);
    sc.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : long ; n := sc.getCurrent()->toLong() ;
    var len : int ; len := ("" + n)->size() ;
    var bits : Sequence(int) ; bits := Integer.subrange(1,len + 1)->collect(0) ;
        var i : int ; i := 1 ; while i <= len do ( (     bits[i+1] := (n mod 10)->oclAsType(int) ; 
     n := n/(10) )  ;     i := i + 1 ) ; 
    var dp : Sequence(Sequence(long)) ; dp := Integer.subrange(1,len + 1)->collect(Integer.subrange(1,2)->collect(0)) ;
    dp[0+1][0+1] := 1 ; 
    dp[0+1][1+1] := 1 ; 
        var i : int ; i := 1 ; while i <= len do ( (     dp[i+1][0+1] := dp[i - 1+1][0+1] * bits[i+1] ; 
     if (i /= len or i = len & bits[i+1] /= 1) then     dp[i+1][0+1] := Set{dp[i+1][0+1], dp[i - 1+1][1+1] * Set{0, bits[i+1] - 1}->max()}->max() else     dp[i+1][0+1] := Set{dp[i+1][0+1], dp[i - 1+1][1+1]}->max() ; ;  
     dp[i+1][1+1] := dp[i - 1+1][1+1] * 9 ; 
     if (bits[i+1] < 9) then     dp[i+1][1+1] := Set{dp[i+1][1+1], dp[i - 1+1][0+1] * 9}->max() ; else skip )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(dp[len+1][0+1]) ; 
    skip ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int __gcd(int a,int b){
    if(a==0)return b ;
    return __gcd(b % a,a);
  }
  static int minGCD(int arr[],int n){
    int minGCD=0 ;
    for(int i=0 ; i<n ; i++)minGCD=__gcd(minGCD,arr[i]);
    return minGCD ;
  }
  static int minLCM(int arr[],int n){
    int minLCM=arr[0];
    for(int i=1 ; i<n ; i++)minLCM=Math.min(minLCM,arr[i]);
    return minLCM ;
  }
  public static void main(String[] args){
    int arr[]={
      2,66,14,521 };
      int n=arr.length ;
      System.out.println("LCM="+minLCM(arr,n)+" GCD="+minGCD(arr,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation __gcd( a : int, b : int) : int
  pre: true
  post: true
  activity: (     if (a = 0) then     return b else skip ; 
     return __gcd(b mod a, a) );
  static   operation minGCD( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var minGCD : int ; minGCD := 0 ;
         var i : int ; i := 0 ; while i < n do (     minGCD := __gcd(minGCD, arr[i+1]) ;  ;     i := i + 1 ) ; 
     return minGCD );
  static   operation minLCM( arr : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var minLCM : int ; minLCM := arr[0+1] ;
         var i : int ; i := 1 ; while i < n do (     minLCM := Set{minLCM, arr[i+1]}->min() ;  ;     i := i + 1 ) ; 
     return minLCM );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{2,66,14,521} ;
     var n : int ; n := arr->size() ;
     OclFile["System.out"].println("LCM=" + minLCM(arr, n) + " GCD=" + minGCD(arr, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
public class file {
  public static void main(String[] args)throws java.lang.Exception {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int prev1=0,prev2=1,a=1 ;
    for(int i=0 ; i<n ; i++){
      a=prev1+prev2 ;
      if(a==n){
        break ;
      }
      prev1=prev2 ;
      prev2=a ;
    }
    if(n==0)System.out.println(0+" "+0+" "+0+" ");
    else System.out.println(0+" "+prev1+" "+prev2);
  }
}
------------------------------------------------------------
OCL File:
---------
 class file {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var prev1 : int ; prev1 := 0 ;
    var prev2 : int ; prev2 := 1 ;
    var a : int ; a := 1 ;
        var i : int ; i := 0 ; while i < n do ( (     a := prev1 + prev2 ; 
     if (a = n) then (     break ) else skip ; 
     prev1 := prev2 ; 
     prev2 := a )  ;     i := i + 1 ) ; 
    if (n = 0) then     OclFile["System.out"].println(0 + " " + 0 + " " + 0 + " ") else     OclFile["System.out"].println(0 + " " + prev1 + " " + prev2) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class sample {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    System.out.println("0 "+"0 "+n);
    in.close();
  }
}
------------------------------------------------------------
OCL File:
---------
 class sample {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
     OclFile["System.out"].println("0 " + "0 " + n) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader ;
import java.io.IOException ;
import java.io.InputStreamReader ;
import java.util.StringTokenizer ;
public class A {
  public static void main(String[] args){
    FastScanner fs=new FastScanner();
    long n=fs.nextLong();
    System.out.print(0+" "+0+" "+n);
  }
  static class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    public String next(){
      while(! 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());
    }
    public String nextLine(){
      String line="" ;
      if(st.hasMoreTokens())line=st.nextToken();
      else try {
        return br.readLine();
      }
      catch(IOException e){
        e.printStackTrace();
      }
      while(st.hasMoreTokens())line+=" "+st.nextToken();
      return line ;
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fs : FastScanner ; fs := FastScanner.newFastScanner() ;
     var n : long ; n := fs.nextLong() ;
     OclFile["System.out"].print(0 + " " + 0 + " " + n) );
  static class FastScanner {
   attribute br : OclFile := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"]));
   attribute st : OclIterator := OclIterator.newOclIterator_String("");
   operation next() : String
  pre: true
  post: true
  activity: (     while (not(st.hasNext())) do     try (     st := OclIterator.newOclIterator_String(br.readLine()) )   catch (e : IOException) do (     e.printStackTrace() )
 ; 
     return st.next() );
   operation nextInt() : int
  pre: true
  post: true
  activity: (     return (next())->toInteger() );
   operation nextLong() : long
  pre: true
  post: true
  activity: (     return (next())->toLong() );
   operation nextLine() : String
  pre: true
  post: true
  activity: (     var line : String ; line := "" ;
     if (st.hasNext()) then     line := st.next() else     try (     return br.readLine() )   catch (e : IOException) do (     e.printStackTrace() )
 ;  
     while (st.hasNext()) do     line := line+(" " + st.next()) ; ; 
     return line );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList ;
import java.util.Arrays ;
import java.util.HashMap ;
import java.util.HashSet ;
import java.util.Map ;
import java.util.Scanner ;
import java.util.Set ;
import java.util.TreeMap ;
public class Demo7 {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int x=sc.nextInt();
    System.out.printf("%d %d %d\n",0,0,x);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Demo7 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var x : int ; x := sc.getCurrent()->toInteger() ;
     OclFile["System.out"].printf("%d %d %d\n", 0, 0, x) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int findMaximumDiff(int[] a,int n){
    int ind1=0 ;
    for(int i=n-1 ; i>0 ; i--){
      if(a[0]!=a[i]){
        ind1=i ;
        break ;
      }
    }
    int ind2=0 ;
    for(int i=0 ; i<n-1 ; i++){
      if(a[n-1]!=a[i]){
        ind2=(n-1-i);
        break ;
      }
    }
    return Math.max(ind1,ind2);
  }
  public static void main(String args[]){
    int[] a={
      1,2,3,2,3 };
      int n=a.length ;
      System.out.println(findMaximumDiff(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findMaximumDiff( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var ind1 : int ; ind1 := 0 ;
         var i : int ; i := n - 1 ; while i > 0 do ( (     if (a[0+1] /= a[i+1]) then (     ind1 := i ; 
     break ) else skip )  ;     i := i - 1 ) ; 
    var ind2 : int ; ind2 := 0 ;
        var i : int ; i := 0 ; while i < n - 1 do ( (     if (a[n - 1+1] /= a[i+1]) then (     ind2 := (n - 1 - i) ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    return Set{ind1, ind2}->max() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,2,3} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(findMaximumDiff(a, n)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int summation(int n){
    int sum ;
    sum=(int)(Math.pow(10,n+1)-10-(9*n))/81 ;
    return sum ;
  }
  public static void main(String[] args){
    int n=5 ;
    System.out.println(summation(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation summation( n : int) : int
  pre: true
  post: true
  activity: (     var sum : int ;
     sum := (10->pow(n + 1) - 10 - (9 * n))->oclAsType(int) / 81 ; 
     return sum );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 5 ;
     OclFile["System.out"].println(summation(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.*;
class GFG {
  public static boolean ispalindrome(int x){
    int ans=0 ;
    int temp=x ;
    while(temp>0){
      ans=10*ans+temp % 10 ;
      temp=temp/10 ;
    }
    return ans==x ;
  }
  public static int SuperPalindromes(int L,int R){
    int LIMIT=100000 ;
    int ans=0 ;
    for(int i=0 ; i<LIMIT ; i++){
      String s=Integer.toString(i);
      StringBuilder rs=new StringBuilder();
      rs.append(s.substring(0,Math.max(1,s.length()-1)));
      String srs=rs.reverse().toString();
      String p=s+srs ;
      int p_sq=(int)(Math.pow(Integer.parseInt(p),2));
      if(p_sq>R){
        break ;
      }
      if(p_sq>=L && ispalindrome(p_sq)){
        ans=ans+1 ;
      }
    }
    for(int i=0 ; i<LIMIT ; i++){
      String s=Integer.toString(i);
      StringBuilder rs=new StringBuilder();
      rs.append(s);
      rs=rs.reverse();
      String p=s+rs ;
      int p_sq=(int)(Math.pow(Integer.parseInt(p),2));
      if(p_sq>R){
        break ;
      }
      if(p_sq>=L && ispalindrome(p_sq)){
        ans=ans+1 ;
      }
    }
    return ans ;
  }
  public static void main(String[] args){
    String L="4" ;
    String R="1000" ;
    System.out.println(SuperPalindromes(Integer.parseInt(L),Integer.parseInt(R)));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation ispalindrome( x : int) : boolean
  pre: true
  post: true
  activity: (     var ans : int ; ans := 0 ;
     var temp : int ; temp := x ;
     while (temp > 0) do (     ans := 10 * ans + temp mod 10 ; 
     temp := temp / 10 ) ; 
     return ans = x );
  static   operation SuperPalindromes( L : int, R : int) : int
  pre: true
  post: true
  activity: (     var LIMIT : int ; LIMIT := 100000 ;
     var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < LIMIT do ( (     var s : String ; s := ((i) + "") ;
     var rs : String ; rs := StringLib.newString() ;
    rs := rs + StringLib.newString(s.subrange(0+1,Set{1, s->size() - 1}->max())) ; 
    var srs : String ; srs := rs->reverse()+"" ;
    var p : String ; p := s + srs ;
    var p_sq : int ; p_sq := ((p)->toInteger()->pow(2))->oclAsType(int) ;
    if (p_sq > R) then (     break ) else skip ; 
    if (p_sq >= L & ispalindrome(p_sq)) then (     ans := ans + 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
        var i : int ; i := 0 ; while i < LIMIT do ( (     var s : String ; s := ((i) + "") ;
     var rs : String ; rs := StringLib.newString() ;
    rs := rs + StringLib.newString(s) ; 
    rs := rs->reverse() ;     rs := rs->reverse() ; 
    var p : String ; p := s + rs ;
    var p_sq : int ; p_sq := ((p)->toInteger()->pow(2))->oclAsType(int) ;
    if (p_sq > R) then (     break ) else skip ; 
    if (p_sq >= L & ispalindrome(p_sq)) then (     ans := ans + 1 ) else skip ; 
 )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var L : String ; L := "4" ;
     var R : String ; R := "1000" ;
     OclFile["System.out"].println(SuperPalindromes((L)->toInteger(), (R)->toInteger())) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static long removeRecur(long n){
    long prev_digit=n % 10 ;
    long pow=10 ;
    long res=prev_digit ;
    while(n>0){
      long curr_digit=n % 10 ;
      if(curr_digit!=prev_digit){
        res+=curr_digit*pow ;
        prev_digit=curr_digit ;
        pow*=10 ;
      }
      n=n/10 ;
    }
    return res ;
  }
  public static void main(String[] args){
    long n=12224 ;
    System.out.println(removeRecur(n));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation removeRecur( n : long) : long
  pre: true
  post: true
  activity: (     var prev_digit : long ; prev_digit := n mod 10 ;
     var pow : long ; pow := 10 ;
    var res : long ; res := prev_digit ;
    while (n > 0) do (     var curr_digit : long ; curr_digit := n mod 10 ;
     if (curr_digit /= prev_digit) then (     res := res+(curr_digit * pow) ; 
     prev_digit := curr_digit ; 
     pow := pow*(10) ) else skip ; 
     n := n / 10 ) ; 
    return res 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : long ; n := 12224 ;
     OclFile["System.out"].println(removeRecur(n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static void findNextNumber(int n){
    int h[]=new int[10];
    int i=0,msb=n,rem=0 ;
    int next_num=-1,count=0 ;
    while(msb>9){
      rem=msb % 10 ;
      h[rem]=1 ;
      msb/=10 ;
      count++;
    }
    h[msb]=1 ;
    count++;
    for(i=msb+1 ; i<10 ; i++){
      if(h[i]==0){
        next_num=i ;
        break ;
      }
    }
    if(next_num==-1){
      for(i=1 ; i<msb ; i++){
        if(h[i]==0){
          next_num=i ;
          count++;
          break ;
        }
      }
    }
    if(next_num>0){
      for(i=0 ; i<10 ; i++){
        if(h[i]==0){
          msb=i ;
          break ;
        }
      }
      for(i=1 ; i<count ; i++){
        next_num=((next_num*10)+msb);
      }
      if(next_num>n)System.out.print(next_num+"\n");
      else System.out.print("Not Possible \n");
    }
    else {
      System.out.print("Not Possible \n");
    }
  }
  public static void main(String[] args){
    int n=2019 ;
    findNextNumber(n);
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation findNextNumber( n : int) : void
  pre: true
  post: true
  activity: (     var h : Sequence(int) ; h := Integer.subrange(1,10)->collect(0) ;
     var i : int ; i := 0 ;
    var msb : int ; msb := n ;
    var rem : int ; rem := 0 ;
    var next_num : int ; next_num := -1 ;
    var count : int ; count := 0 ;
    while (msb > 9) do (     rem := msb mod 10 ; 
     h[rem+1] := 1 ; 
     msb := msb/(10) ; 
     count := count + 1 ) ; 
    h[msb+1] := 1 ; 
    count := count + 1 ; 
        i := msb + 1 ; while i < 10 do ( (     if (h[i+1] = 0) then (     next_num := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
    if (next_num = -1) then (         i := 1 ; while i < msb do ( (     if (h[i+1] = 0) then (     next_num := i ; 
     count := count + 1 ; 
     break ) else skip )  ;     i := i + 1 ) ) else skip ; 
    if (next_num > 0) then (         i := 0 ; while i < 10 do ( (     if (h[i+1] = 0) then (     msb := i ; 
     break ) else skip )  ;     i := i + 1 ) ; 
         i := 1 ; while i < count do ( (     next_num := ((next_num * 10) + msb) )  ;     i := i + 1 ) ; 
     if (next_num > n) then     OclFile["System.out"].print(next_num + "\n") ; else     OclFile["System.out"].print("Not Possible \n") ; ) else (     OclFile["System.out"].print("Not Possible \n") ) ;  
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 2019 ;
     execute findNextNumber(n) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class HelloWorld {
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int a=scan.nextInt();
    int b=scan.nextInt();
    int res=a ;
    while(a>=b){
      res+=(a/b);
      a=(a/b)+(a % b);
    }
    System.out.println(res);
  }
}
------------------------------------------------------------
OCL File:
---------
 class HelloWorld {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scan : OclFile ; scan := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var a : int ; a := scan.getCurrent()->toInteger() ;
    var b : int ; b := scan.getCurrent()->toInteger() ;
    var res : int ; res := a ;
    while (a >= b) do (     res := res+((a / b)) ; 
     a := (a / b) + (a mod b) ) ; 
    OclFile["System.out"].println(res) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static int countPairs(String s1,int n1,String s2,int n2){
    int[] freq1=new int[26];
    int[] freq2=new int[26];
    Arrays.fill(freq1,0);
    Arrays.fill(freq2,0);
    int i,count=0 ;
    for(i=0 ; i<n1 ; i++)freq1[s1.charAt(i)-'a']++;
    for(i=0 ; i<n2 ; i++)freq2[s2.charAt(i)-'a']++;
    for(i=0 ; i<26 ; i++)count+=(Math.min(freq1[i],freq2[i]));
    return count ;
  }
  public static void main(String args[]){
    String s1="geeksforgeeks",s2="platformforgeeks" ;
    int n1=s1.length(),n2=s2.length();
    System.out.println(countPairs(s1,n1,s2,n2));
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation countPairs( s1 : String, n1 : int, s2 : String, n2 : int) : int
  pre: true
  post: true
  activity: (     var freq1 : Sequence(int) ; freq1 := Integer.subrange(1,26)->collect(0) ;
     var freq2 : Sequence(int) ; freq2 := Integer.subrange(1,26)->collect(0) ;
    freq1 := freq1->collect(0) ; 
    freq2 := freq2->collect(0) ; 
    var i : int ;
    var count : int ; count := 0 ;
        i := 0 ; while i < n1 do (     freq1[s1->at(i+1) - ('a')->char2byte()+1] := freq1[s1->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < n2 do (     freq2[s2->at(i+1) - ('a')->char2byte()+1] := freq2[s2->at(i+1) - ('a')->char2byte()+1] + 1 ;  ;     i := i + 1 ) ; 
        i := 0 ; while i < 26 do (     count := count+((Set{freq1[i+1], freq2[i+1]}->min())) ;  ;     i := i + 1 ) ; 
    return count 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s1 : String ; s1 := "geeksforgeeks" ;
    var s2 : String ; s2 := "platformforgeeks" ;
     var n1 : int ; n1 := s1->size() ;
    var n2 : int ; n2 := s2->size() ;
     OclFile["System.out"].println(countPairs(s1, n1, s2, n2)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File ;
import java.io.IOException ;
import java.util.*;
import java.util.Map.Entry ;
public class Main {
  public static void main(String[] args)throws IOException {
    Scanner in=new Scanner(System.in);
    boolean[] c=new boolean[8];
    int t=0 ;
    int N=in.nextInt();
    for(int i=0 ; i<N ; i++){
      int r=in.nextInt();
      if(r>=3200)t++;
      if(r>=2800 && r<3200)c[7]=true ;
      if(r>=2400 && r<2800)c[6]=true ;
      if(r>=2000 && r<2400)c[5]=true ;
      if(r>=1600 && r<2000)c[4]=true ;
      if(r>=1200 && r<1600)c[3]=true ;
      if(r>=800 && r<1200)c[2]=true ;
      if(r>=400 && r<800)c[1]=true ;
      if(r>=1 && r<400)c[0]=true ;
    }
    int min=0 ;
    for(int i=0 ; i<8 ; i++)if(c[i])min++;
    if(min==0)System.out.println(1+" "+t);
    else System.out.println(min+" "+(min+t));
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var c : Sequence(boolean) ; c := Integer.subrange(1,8)->collect(false) ;
    var t : int ; t := 0 ;
    var N : int ; N := in.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < N do ( (     var r : int ; r := in.getCurrent()->toInteger() ;
     if (r >= 3200) then     t := t + 1 ; else skip ; 
    if (r >= 2800 & r < 3200) then     c[7+1] := true ; else skip ; 
    if (r >= 2400 & r < 2800) then     c[6+1] := true ; else skip ; 
    if (r >= 2000 & r < 2400) then     c[5+1] := true ; else skip ; 
    if (r >= 1600 & r < 2000) then     c[4+1] := true ; else skip ; 
    if (r >= 1200 & r < 1600) then     c[3+1] := true ; else skip ; 
    if (r >= 800 & r < 1200) then     c[2+1] := true ; else skip ; 
    if (r >= 400 & r < 800) then     c[1+1] := true ; else skip ; 
    if (r >= 1 & r < 400) then     c[0+1] := true ; else skip ; 
 )  ;     i := i + 1 ) ; 
    var min : int ; min := 0 ;
        var i : int ; i := 0 ; while i < 8 do (     if (c[i+1]) then     min := min + 1 ; else skip ;  ;     i := i + 1 ) ; 
    if (min = 0) then     OclFile["System.out"].println(1 + " " + t) else     OclFile["System.out"].println(min + " " + (min + t)) ; ;  
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.stream.IntStream ;
import java.io.UncheckedIOException ;
import java.util.Arrays ;
import java.util.StringTokenizer ;
import java.io.IOException ;
import java.io.BufferedReader ;
import java.io.InputStreamReader ;
import java.io.InputStream ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    LightScanner in=new LightScanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    CColorfulLeaderboard solver=new CColorfulLeaderboard();
    solver.solve(1,in,out);
    out.close();
  }
  static class CColorfulLeaderboard {
    public void solve(int testNumber,LightScanner in,PrintWriter out){
      int n=in.ints();
      int[] c=new int[8];
      int r=0 ;
      for(int i=0 ; i<n ; i++){
        int a=in.ints()/400 ;
        if(a<8){
          c[a]++;
        }
        else {
          r++;
        }
      }
      long ans=Arrays.stream(c).filter(i->i>0).count();
      out.print(Math.max(1,ans));
      out.print(' ');
      out.println(ans+r);
    }
  }
  static class LightScanner {
    private BufferedReader reader=null ;
    private StringTokenizer tokenizer=null ;
    public LightScanner(InputStream in){
      reader=new BufferedReader(new InputStreamReader(in));
    }
    public String string(){
      if(tokenizer==null || ! tokenizer.hasMoreTokens()){
        try {
          tokenizer=new StringTokenizer(reader.readLine());
        }
        catch(IOException e){
          throw new UncheckedIOException(e);
        }
      }
      return tokenizer.nextToken();
    }
    public int ints(){
      return Integer.parseInt(string());
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : LightScanner ; in := LightScanner.newLightScanner(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : CColorfulLeaderboard ; solver := CColorfulLeaderboard.newCColorfulLeaderboard() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class CColorfulLeaderboard {
   operation solve( testNumber : int, in : LightScanner, out : OclFile) : void
  pre: true
  post: true
  activity: (     var n : int ; n := in.ints() ;
     var c : Sequence(int) ; c := Integer.subrange(1,8)->collect(0) ;
    var r : int ; r := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := in.ints() / 400 ;
     if (a < 8) then (     c[a+1] := c[a+1] + 1 ) else (     r := r + 1 ) )  ;     i := i + 1 ) ; 
    var ans : long ; ans := stream(c)->select( _x1 | (lambda i : OclAny in i > 0)->apply(_x1) )->size() ;
    skip ; 
    skip ; 
    skip ; 
 );
}
  static class LightScanner {
   attribute reader : OclFile := null;
   attribute tokenizer : OclIterator := null;
   static operation newLightScanner( in : OclFile) : LightScanner
  pre: true
  post: true
  activity:
  ( var self : LightScanner ;
    self := createLightScanner();
    self.initialise(in);
    return self );
  operation initialise( in : OclFile) : void
  pre: true  post: true
  activity: (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(in)) );
   operation string() : String
  pre: true
  post: true
  activity: (     if (tokenizer = null or not(tokenizer.hasNext())) then (     try (     tokenizer := OclIterator.newOclIterator_String(reader.readLine()) )   catch (e : IOException) do (     error UncheckedIOException.newUncheckedIOException(e) )
 ) else skip ; 
     return tokenizer.next() );
   operation ints() : int
  pre: true
  post: true
  activity: (     return (string())->toInteger() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  private static final int GRAY=0 ;
  private static final int BROWN=1 ;
  private static final int GREEN=2 ;
  private static final int WATER=3 ;
  private static final int BLUE=4 ;
  private static final int YELLOW=5 ;
  private static final int ORANGE=6 ;
  private static final int RED=7 ;
  private static final int OTHERS=8 ;
  public static void main(final String[] args){
    final Scanner scanner=new Scanner(System.in);
    final int n=scanner.nextInt();
    final int[] colors=new int[9];
    for(int i=0 ; i<n ; i++){
      final int a=scanner.nextInt();
      if(a<400){
        colors[GRAY]++;
      }
      else if(a<800){
        colors[BROWN]++;
      }
      else if(a<1200){
        colors[GREEN]++;
      }
      else if(a<1600){
        colors[WATER]++;
      }
      else if(a<2000){
        colors[BLUE]++;
      }
      else if(a<2400){
        colors[YELLOW]++;
      }
      else if(a<2800){
        colors[ORANGE]++;
      }
      else if(a<3200){
        colors[RED]++;
      }
      else {
        colors[OTHERS]++;
      }
    }
    int min=0 ;
    int max ;
    for(int i=0 ; i<=RED ; i++){
      if(colors[i]>0){
        min++;
      }
    }
    max=min+colors[OTHERS];
    min=min==0 && colors[OTHERS]>0 ? 1 : min ;
    System.out.println(min+" "+max);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    attribute GRAY : int := 0;
  static    attribute BROWN : int := 1;
  static    attribute GREEN : int := 2;
  static    attribute WATER : int := 3;
  static    attribute BLUE : int := 4;
  static    attribute YELLOW : int := 5;
  static    attribute ORANGE : int := 6;
  static    attribute RED : int := 7;
  static    attribute OTHERS : int := 8;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var colors : Sequence(int) ; colors := Integer.subrange(1,9)->collect(0) ;
        var i : int ; i := 0 ; while i < n do ( (     var a : int ; a := scanner.getCurrent()->toInteger() ;
     if (a < 400) then (     colors[GRAY+1] := colors[GRAY+1] + 1 ) else     if (a < 800) then (     colors[BROWN+1] := colors[BROWN+1] + 1 ) else     if (a < 1200) then (     colors[GREEN+1] := colors[GREEN+1] + 1 ) else     if (a < 1600) then (     colors[WATER+1] := colors[WATER+1] + 1 ) else     if (a < 2000) then (     colors[BLUE+1] := colors[BLUE+1] + 1 ) else     if (a < 2400) then (     colors[YELLOW+1] := colors[YELLOW+1] + 1 ) else     if (a < 2800) then (     colors[ORANGE+1] := colors[ORANGE+1] + 1 ) else     if (a < 3200) then (     colors[RED+1] := colors[RED+1] + 1 ) else (     colors[OTHERS+1] := colors[OTHERS+1] + 1 ) ;  ;  ;  ;  ;  ;  ;  )  ;     i := i + 1 ) ; 
    var min : int ; min := 0 ;
    var max : int ;
        var i : int ; i := 0 ; while i <= RED do ( (     if (colors[i+1] > 0) then (     min := min + 1 ) else skip )  ;     i := i + 1 ) ; 
    max := min + colors[OTHERS+1] ; 
    min := if min = 0 & colors[OTHERS+1] > 0 then 1 else min endif ; 
    OclFile["System.out"].println(min + " " + max) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class Main {
  public static final void main(String[] args){
    new Main().solve();
  }
  private final Scanner sc=new Scanner(System.in);
  void solve(){
    int N=sc.nextInt();
    boolean[] used=new boolean[8];
    int joker=0 ;
    for(int i=0 ; i<N ; i++){
      int a=sc.nextInt();
      if(a<=399){
        used[0]=true ;
      }
      else if(a<=799){
        used[1]=true ;
      }
      else if(a<=1199){
        used[2]=true ;
      }
      else if(a<=1599){
        used[3]=true ;
      }
      else if(a<=1999){
        used[4]=true ;
      }
      else if(a<=2399){
        used[5]=true ;
      }
      else if(a<=2799){
        used[6]=true ;
      }
      else if(a<=3199){
        used[7]=true ;
      }
      else {
        joker++;
      }
    }
    int ans=0 ;
    for(int i=0 ; i<8 ; i++)if(used[i])ans++;
    if(ans==0){
      if(joker>0)System.out.println(1);
      else System.out.println(0);
    }
    else {
      System.out.println(ans);
    }
    System.out.println(ans+joker);
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     Main.newMain().solve() );
   attribute sc : OclFile := OclFile.newOclFile_Read(OclFile["System.in"]);
   operation solve() : void
  pre: true
  post: true
  activity: (     var N : int ; N := sc.getCurrent()->toInteger() ;
     var used : Sequence(boolean) ; used := Integer.subrange(1,8)->collect(false) ;
    var joker : int ; joker := 0 ;
        var i : int ; i := 0 ; while i < N do ( (     var a : int ; a := sc.getCurrent()->toInteger() ;
     if (a <= 399) then (     used[0+1] := true ) else     if (a <= 799) then (     used[1+1] := true ) else     if (a <= 1199) then (     used[2+1] := true ) else     if (a <= 1599) then (     used[3+1] := true ) else     if (a <= 1999) then (     used[4+1] := true ) else     if (a <= 2399) then (     used[5+1] := true ) else     if (a <= 2799) then (     used[6+1] := true ) else     if (a <= 3199) then (     used[7+1] := true ) else (     joker := joker + 1 ) ;  ;  ;  ;  ;  ;  ;  )  ;     i := i + 1 ) ; 
    var ans : int ; ans := 0 ;
        var i : int ; i := 0 ; while i < 8 do (     if (used[i+1]) then     ans := ans + 1 ; else skip ;  ;     i := i + 1 ) ; 
    if (ans = 0) then (     if (joker > 0) then     OclFile["System.out"].println(1) ; else     OclFile["System.out"].println(0) ; ) else (     OclFile["System.out"].println(ans) ) ;  
    OclFile["System.out"].println(ans + joker) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.OutputStream ;
import java.io.IOException ;
import java.io.InputStream ;
import java.io.PrintWriter ;
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    InputStream inputStream=System.in ;
    OutputStream outputStream=System.out ;
    Scanner in=new Scanner(inputStream);
    PrintWriter out=new PrintWriter(outputStream);
    TaskC solver=new TaskC();
    solver.solve(1,in,out);
    out.close();
  }
  static class TaskC {
    public void solve(int testNumber,Scanner in,PrintWriter out){
      int[] cnt=new int[9];
      int n=in.nextInt();
      int min=0 ;
      for(int i=0 ; i<n ; i++){
        int tmp=in.nextInt();
        int col=getColor(tmp);
++cnt[col];
        if(cnt[col]<=1 && col<8)++min ;
      }
      if(min==0){
        out.println(1+" "+cnt[8]);
        return ;
      }
      out.println(min+" "+(min+cnt[8]));
    }
    public int getColor(int a){
      int ret=a/400 ;
      return Math.min(8,ret);
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile["System.in"] ;
     var outputStream : OclFile ; outputStream := OclFile["System.out"] ;
    var in : OclFile ; in := OclFile.newOclFile_Read(inputStream) ;
    var out : OclFile ; out := OclFile.newOclFile_Write(outputStream) ;
    var solver : TaskC ; solver := TaskC.newTaskC() ;
    solver.solve(1, in, out) ; 
    skip ; 
 );
  static class TaskC {
   operation solve( testNumber : int, in : OclFile, out : OclFile) : void
  pre: true
  post: true
  activity: (     var cnt : Sequence(int) ; cnt := Integer.subrange(1,9)->collect(0) ;
     var n : int ; n := in.getCurrent()->toInteger() ;
    var min : int ; min := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     var tmp : int ; tmp := in.getCurrent()->toInteger() ;
     var col : int ; col := getColor(tmp) ;
     cnt[col+1] := cnt[col+1] + 1 ; 
     if (cnt[col+1] <= 1 & col < 8) then     min := min + 1 ; else skip )  ;     i := i + 1 ) ; 
    if (min = 0) then (     skip ; 
     return ) else skip ; 
    skip ; 
 );
   operation getColor( a : int) : int
  pre: true
  post: true
  activity: (     var ret : int ; ret := a / 400 ;
     return Set{8, ret}->min() );
}
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static boolean isPlusPossible(int arr[],int n){
    HashMap<Integer,Integer>mp=new HashMap<Integer,Integer>();
    for(int i=0 ; i<n ; i++){
      if(mp.containsKey(arr[i])){
        mp.put(arr[i],mp.get(arr[i])+1);
      }
      else {
        mp.put(arr[i],1);
      }
    }
    boolean foundModOne=false ;
    for(Map.Entry<Integer,Integer>x : mp.entrySet()){
      int element=x.getKey();
      int frequency=x.getValue();
      if(frequency % 4==0)continue ;
      if(frequency % 4==1){
        if(foundModOne)return false ;
        foundModOne=true ;
      }
      else return false ;
    }
    return true ;
  }
  public static void main(String[] args){
    int arr[]={
      1,1,1,1,2,2,2,3,2 };
      int n=arr.length ;
      if(isPlusPossible(arr,n))System.out.print("Yes");
      else System.out.print("No");
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation isPlusPossible( arr : Sequence(int), n : int) : boolean
  pre: true
  post: true
  activity: (     var mp : Map(int,int) ; mp := Map{} ;
         var i : int ; i := 0 ; while i < n do ( (     if (mp->keys()->includes(arr[i+1])) then (     mp := mp->union(Map{arr[i+1] |-> mp->at(arr[i+1]) + 1}) ) else (     mp := mp->union(Map{arr[i+1] |-> 1}) ) )  ;     i := i + 1 ) ; 
    var foundModOne : boolean ; foundModOne := false ;
    for (x : mp->asSet()) do ( (     var element : int ; element := x.getKey() ;
     var frequency : int ; frequency := x.getValue() ;
     if (frequency mod 4 = 0) then     continue else skip ; 
     if (frequency mod 4 = 1) then (     if (foundModOne) then     return false else skip ; 
     foundModOne := true ) else     return false )  ) ; 
    return true 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,1,1,1,2,2,2,3,2} ;
     var n : int ; n := arr->size() ;
     if (isPlusPossible(arr, n)) then     OclFile["System.out"].print("Yes") ; else     OclFile["System.out"].print("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void findNumbers(int n,int b){
    double even=0,odd=0 ;
    if(b % 2==0){
      even=Math.pow(b,n)-2 ;
      odd=Math.pow(b,n)-1 ;
    }
    else {
      even=Math.pow(b,n)-1 ;
      odd=Math.pow(b,n)-2 ;
    }
    System.out.println("Even Number="+(int)even);
    System.out.print("Odd Number="+(int)odd);
  }
  public static void main(String[] args){
    int N=2,B=5 ;
    findNumbers(N,B);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findNumbers( n : int, b : int) : void
  pre: true
  post: true
  activity: (     var even : double ; even := 0 ;
    var odd : double ; odd := 0 ;
     if (b mod 2 = 0) then (     even := b->pow(n) - 2 ; 
     odd := b->pow(n) - 1 ) else (     even := b->pow(n) - 1 ; 
     odd := b->pow(n) - 2 ) ;  
     OclFile["System.out"].println("Even Number=" + even->oclAsType(int)) ; 
     OclFile["System.out"].print("Odd Number=" + odd->oclAsType(int)) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 2 ;
    var B : int ; B := 5 ;
     execute findNumbers(N, B) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class GFG {
  static int largestSquareFactor(int num){
    int answer=1 ;
    for(int i=2 ; i<Math.sqrt(num); ++i){
      int cnt=0 ;
      int j=i ;
      while(num % j==0){
        cnt++;
        j*=i ;
      }
      if((cnt & 1)!=0){
        cnt--;
        answer*=Math.pow(i,cnt);
      }
      else {
        answer*=Math.pow(i,cnt);
      }
    }
    return answer ;
  }
  public static void main(String args[]){
    int N=420 ;
    System.out.println(largestSquareFactor(N));
  }
}
------------------------------------------------------------
OCL File:
---------
class GFG {
  static   operation largestSquareFactor( num : int) : int
  pre: true
  post: true
  activity: (     var answer : int ; answer := 1 ;
         var i : int ; i := 2 ; while i < (num)->sqrt() do ( (     var cnt : int ; cnt := 0 ;
     var j : int ; j := i ;
     while (num mod j = 0) do (     cnt := cnt + 1 ; 
     j := j*(i) ) ; 
     if ((MathLib.bitwiseAnd(cnt,1)) /= 0) then (     cnt := cnt - 1 ; 
     answer := answer*(i->pow(cnt)) ) else (     answer := answer*(i->pow(cnt)) ) )  ;     i := i + 1 ) ; 
     return answer );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var N : int ; N := 420 ;
     OclFile["System.out"].println(largestSquareFactor(N)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class b {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int a=sc.nextInt();
    int b=sc.nextInt();
    for(int i=0 ; i<n ; i++){
      long x=sc.nextInt();
      long z=((x*a)% b)/a ;
      System.out.print(z+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class b {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := sc.getCurrent()->toInteger() ;
    var a : int ; a := sc.getCurrent()->toInteger() ;
    var b : int ; b := sc.getCurrent()->toInteger() ;
        var i : int ; i := 0 ; while i < n do ( (     var x : long ; x := sc.getCurrent()->toInteger() ;
     var z : long ; z := ((x * a) mod b) / a ;
     OclFile["System.out"].print(z + " ") )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Candles {
  public Candles(){
  }
  static int count=0 ;
  public void inputAndCalc(int numberOne,int numberTwo){
    count=numberOne ;
    double number=(double)numberOne ;
    double calc=0.0 ;
    while(numberOne!=0){
      numberOne/=numberTwo ;
      number/=(double)numberTwo ;
      count+=numberOne ;
      calc+=(number-numberOne);
    }
    count+=(int)calc ;
  }
  public int getNumberHours(){
    return count ;
  }
  public static void main(String[] args){
    Scanner input=new Scanner(System.in);
    Candles instance=new Candles();
    int numberOne=input.nextInt();
    int numberTwo=input.nextInt();
    instance.inputAndCalc(numberOne,numberTwo);
    System.out.println(instance.getNumberHours());
  }
}
------------------------------------------------------------
OCL File:
---------
 class Candles {
   static operation newCandles() : Candles
  pre: true
  post: true
  activity:
  ( var self : Candles ;
    self := createCandles();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
  static   attribute count : int := 0;
   operation inputAndCalc( numberOne : int, numberTwo : int) : void
  pre: true
  post: true
  activity: (     count := numberOne ; 
     var number : double ; number := numberOne->oclAsType(double) ;
    var calc : double ; calc := 0.0 ;
    while (numberOne /= 0) do (     numberOne := numberOne/(numberTwo) ; 
     number := number/(numberTwo->oclAsType(double)) ; 
     count := count+(numberOne) ; 
     calc := calc+((number - numberOne)) ) ; 
    count := count+(calc->oclAsType(int)) ; 
 );
   operation getNumberHours() : int
  pre: true
  post: true
  activity: (     return count );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var input : OclFile ; input := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var instance : Candles ; instance := Candles.newCandles() ;
    var numberOne : int ; numberOne := input.getCurrent()->toInteger() ;
    var numberTwo : int ; numberTwo := input.getCurrent()->toInteger() ;
    instance.inputAndCalc(numberOne, numberTwo) ; 
    OclFile["System.out"].println(instance.getNumberHours()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
import java.util.*;
public class B {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt(),a=scanner.nextInt(),b=scanner.nextInt();
    for(int i=0 ; i<n ; i++){
      int x=scanner.nextInt();
      long ans=(((long)x*a)% b)/a ;
      System.out.print(ans+" ");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class B {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
    var a : int ; a := scanner.getCurrent()->toInteger() ;
    var b : int ; b := scanner.getCurrent()->toInteger() ;
         var i : int ; i := 0 ; while i < n do ( (     var x : int ; x := scanner.getCurrent()->toInteger() ;
     var ans : long ; ans := ((x->oclAsType(long) * a) mod b) / a ;
     OclFile["System.out"].print(ans + " ") )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class B415 {
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int N=in.nextInt();
    long A=in.nextInt();
    long B=in.nextInt();
    StringBuilder out=new StringBuilder();
    for(int n=0 ; n<N ; n++){
      long X=in.nextInt();
      long money=(X*A)/B ;
      long minX=(money*B+A-1)/A ;
      long diff=X-minX ;
      out.append(diff).append(' ');
    }
    System.out.println(out);
  }
}
------------------------------------------------------------
OCL File:
---------
 class B415 {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var in : OclFile ; in := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var N : int ; N := in.getCurrent()->toInteger() ;
    var A : long ; A := in.getCurrent()->toInteger() ;
    var B : long ; B := in.getCurrent()->toInteger() ;
    var out : String ; out := StringLib.newString() ;
        var n : int ; n := 0 ; while n < N do ( (     var X : long ; X := in.getCurrent()->toInteger() ;
     var money : long ; money := (X * A) / B ;
    var minX : long ; minX := (money * B + A - 1) / A ;
    var diff : long ; diff := X - minX ;
    out := out + StringLib.newString(diff) + StringLib.newString(' ') ; 
 )  ;     n := n + 1 ) ; 
    OclFile["System.out"].println(out) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
public class GFG {
  static int MAX_CHAR=256 ;
  static boolean isPresent(String s,String q){
    int[] freq=new int[MAX_CHAR];
    for(int i=0 ; i<s.length(); i++)freq[s.charAt(i)]++;
    for(int i=0 ; i<q.length(); i++){
      freq[q.charAt(i)]--;
      if(freq[q.charAt(i)]<0)return false ;
    }
    return true ;
  }
  static public void main(String[] args){
    String s="abctd" ;
    String q="cat" ;
    if(isPresent(s,q))System.out.println("Yes");
    else System.out.println("No");
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   attribute MAX_CHAR : int := 256;
  static   operation isPresent( s : String, q : String) : boolean
  pre: true
  post: true
  activity: (     var freq : Sequence(int) ; freq := Integer.subrange(1,MAX_CHAR)->collect(0) ;
         var i : int ; i := 0 ; while i < s->size() do (     freq[s->at(i+1)+1] := freq[s->at(i+1)+1] + 1 ;  ;     i := i + 1 ) ; 
         var i : int ; i := 0 ; while i < q->size() do ( (     freq[q->at(i+1)+1] := freq[q->at(i+1)+1] - 1 ; 
     if (freq[q->at(i+1)+1] < 0) then     return false else skip )  ;     i := i + 1 ) ; 
     return true );
  static    operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var s : String ; s := "abctd" ;
     var q : String ; q := "cat" ;
     if (isPresent(s, q)) then     OclFile["System.out"].println("Yes") ; else     OclFile["System.out"].println("No") ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class GFG {
  static void printMatrix(int n,int k){
    for(int i=0 ; i<n ; i++){
      for(int j=0 ; j<n ; j++){
        if(i==j)System.out.print(k+" ");
        else System.out.print("0 ");
      }
      System.out.print("\n");
    }
  }
  public static void main(String[] args){
    int n=3,k=7 ;
    printMatrix(n,k);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation printMatrix( n : int, k : int) : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < n do ( (         var j : int ; j := 0 ; while j < n do ( (     if (i = j) then     OclFile["System.out"].print(k + " ") ; else     OclFile["System.out"].print("0 ") ; )  ;     j := j + 1 ) ; 
     OclFile["System.out"].print("\n") )  ;     i := i + 1 ) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 3 ;
    var k : int ; k := 7 ;
     execute printMatrix(n, k) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class _765A {
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    int t=sc.nextInt();
    if(t % 2==0){
      System.out.println("home");
    }
    else {
      System.out.println("contest");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class _765A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     if (t mod 2 = 0) then (     OclFile["System.out"].println("home") ) else (     OclFile["System.out"].println("contest") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class Main {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    if(n % 2==0){
      System.out.printf("home");
    }
    else {
      System.out.printf("contest");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (     OclFile["System.out"].printf("home") ) else (     OclFile["System.out"].printf("contest") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Scanner ;
public class CF65A {
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    if(n % 2==0){
      System.out.printf("home");
    }
    else {
      System.out.printf("contest");
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class CF65A {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var n : int ; n := scanner.getCurrent()->toInteger() ;
     if (n mod 2 = 0) then (     OclFile["System.out"].printf("home") ) else (     OclFile["System.out"].printf("contest") ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger ;
public class Codechef {
  public static void main(String[] args)throws java.lang.Exception {
    try {
      Scanner sc=new Scanner(System.in);
      int t=sc.nextInt();
      if(t % 2==0)System.out.println("home");
      else System.out.println("contest");
    }
    catch(Exception e){
    }
  }
}
------------------------------------------------------------
OCL File:
---------
 class Codechef {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var sc : OclFile ; sc := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     var t : int ; t := sc.getCurrent()->toInteger() ;
     if (t mod 2 = 0) then     OclFile["System.out"].println("home") ; else     OclFile["System.out"].println("contest") ; )   catch (e : ProgramException) do skip
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector ;
class GFG {
  static void findPermutation(int n){
    Vector<Integer>res=new Vector<Integer>();
    int en=2,on=1 ;
    if(n % 2==0){
      for(int i=0 ; i<n ; i++){
        if(i % 2==0){
          res.add(en);
          en+=2 ;
        }
        else {
          res.add(on);
          on+=2 ;
        }
      }
    }
    else {
      for(int i=0 ; i<n-2 ; i++){
        if(i % 2==0){
          res.add(en);
          en+=2 ;
        }
        else {
          res.add(on);
          on+=2 ;
        }
      }
      res.add(n);
      res.add(n-2);
    }
    for(int i=0 ; i<n ; i++){
      System.out.print(res.get(i)+" ");
    }
    System.out.println("");
  }
  public static void main(String[] args){
    int n=9 ;
    findPermutation(n);
  }
}
------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation findPermutation( n : int) : void
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Sequence{} ;
     var en : int ; en := 2 ;
    var on : int ; on := 1 ;
    if (n mod 2 = 0) then (         var i : int ; i := 0 ; while i < n do ( (     if (i mod 2 = 0) then (     res := res->including(en) ; 
     en := en+(2) ) else (     res := res->including(on) ; 
     on := on+(2) ) )  ;     i := i + 1 ) ) else (         var i : int ; i := 0 ; while i < n - 2 do ( (     if (i mod 2 = 0) then (     res := res->including(en) ; 
     en := en+(2) ) else (     res := res->including(on) ; 
     on := on+(2) ) )  ;     i := i + 1 ) ; 
     res := res->including(n) ; 
     res := res->including(n - 2) ) ;  
        var i : int ; i := 0 ; while i < n do ( (     OclFile["System.out"].print(res->at(i+1) + " ") )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println("") ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var n : int ; n := 9 ;
     execute findPermutation(n) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class GFG {
  static int search(int searchspace[],int s,int e,int key){
    int ans=-1 ;
    while(s<=e){
      int mid=(s+e)/2 ;
      if(searchspace[mid]-key>=0){
        ans=mid ;
        e=mid-1 ;
      }
      else {
        s=mid+1 ;
      }
    }
    return ans ;
  }
  static int longestSubarray(int[] a,int n){
    int SuffixSum[]=new int[n+1];
    SuffixSum[n]=0 ;
    for(int i=n-1 ; i>=0 ; --i){
      SuffixSum[i]=SuffixSum[i+1]+a[i];
    }
    int ans=0 ;
    int searchspace[]=new int[n];
    int index[]=new int[n];
    int j=0 ;
    for(int i=0 ; i<n ; ++i){
      if((j==0)|| SuffixSum[i]>searchspace[j-1]){
        searchspace[j]=SuffixSum[i];
        index[j]=i ;
        j++;
      }
      int idx=search(searchspace,0,j-1,SuffixSum[i+1]);
      if(idx!=-1)ans=Math.max(ans,i-index[idx]+1);
    }
    return ans ;
  }
  public static void main(String[] args){
    int[] a={
-1,4,-2,-5,6,-8 };
      int n=a.length ;
      System.out.println(longestSubarray(a,n));
    }
  }

------------------------------------------------------------
OCL File:
---------
 class GFG {
  static   operation search( searchspace : Sequence(int), s : int, e : int, key : int) : int
  pre: true
  post: true
  activity: (     var ans : int ; ans := -1 ;
     while (s <= e) do (     var mid : int ; mid := (s + e) / 2 ;
     if (searchspace[mid+1] - key >= 0) then (     ans := mid ; 
     e := mid - 1 ) else (     s := mid + 1 ) ) ; 
     return ans );
  static   operation longestSubarray( a : Sequence(int), n : int) : int
  pre: true
  post: true
  activity: (     var SuffixSum : Sequence(int) ; SuffixSum := Integer.subrange(1,n + 1)->collect(0) ;
     SuffixSum[n+1] := 0 ; 
        var i : int ; i := n - 1 ; while i >= 0 do ( (     SuffixSum[i+1] := SuffixSum[i + 1+1] + a[i+1] )  ;     i := i - 1 ) ; 
    var ans : int ; ans := 0 ;
    var searchspace : Sequence(int) ; searchspace := Integer.subrange(1,n)->collect(0) ;
    var index : Sequence(int) ; index := Integer.subrange(1,n)->collect(0) ;
    var j : int ; j := 0 ;
        var i : int ; i := 0 ; while i < n do ( (     if ((j = 0) or SuffixSum[i+1] > searchspace[j - 1+1]) then (     searchspace[j+1] := SuffixSum[i+1] ; 
     index[j+1] := i ; 
     j := j + 1 ) else skip ; 
     var idx : int ; idx := search(searchspace, 0, j - 1, SuffixSum[i + 1+1]) ;
     if (idx /= -1) then     ans := Set{ans, i - index[idx+1] + 1}->max() ; else skip )  ;     i := i + 1 ) ; 
    return ans 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{-1,4,-2,-5,6,-8} ;
     var n : int ; n := a->size() ;
     OclFile["System.out"].println(longestSubarray(a, n)) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
    public static void main(String[] args) {
        int[] sourceArray = new int[5];
        int[] targetArray = new int[8];
        for (int i = 0; i < sourceArray.length; i++) {
            sourceArray[i] = i * 2;
        }
        System.arraycopy(sourceArray, 0, targetArray, 2, sourceArray.length);
        System.out.println(java.util.Arrays.toString(targetArray));
    }
}

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sourceArray : Sequence(int) ; sourceArray := Integer.subrange(1,5)->collect(0) ;
     var targetArray : Sequence(int) ; targetArray := Integer.subrange(1,8)->collect(0) ;
        var i : int ; i := 0 ; while i < sourceArray->size() do ( (     sourceArray[i+1] := i * 2 )  ;     i := i + 1 ) ; 
    for _x : Integer.subrange(1,sourceArray->size()) do targetArray[2 + _x] := sourceArray[0 + _x] ; 
    OclFile["System.out"].println(java.util.Arrays.toString(targetArray)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
    public static void main(String[] args) {
        double[] values = {1.5, 2.5, 3.5, 4.5, 5.5};
        int index = (int) (Math.random() * values.length);  
        System.out.println("Random index: " + index);
        System.out.println("Value at random index: " + values[index]);
    }
}

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var values : Sequence(double) ; values := Sequence{1.5,2.5,3.5,4.5,5.5} ;
     var index : int ; index := (MathLib.random() * values->size())->oclAsType(int) ;
     OclFile["System.out"].println("Random index: " + index) ; 
     OclFile["System.out"].println("Value at random index: " + values[index+1]) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
    public static void main(String[] args) {
        double basePrice = 50.0;
        double randomAdjustment = Math.random() * 10;  
        System.out.println("Base price: " + basePrice);
        System.out.println("Random adjustment: " + randomAdjustment);
        double finalPrice = basePrice + randomAdjustment;
        System.out.println("Final price after adjustment: " + finalPrice);
    }
}

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var basePrice : double ; basePrice := 50.0 ;
     var randomAdjustment : double ; randomAdjustment := MathLib.random() * 10 ;
    OclFile["System.out"].println("Base price: " + basePrice) ; 
    OclFile["System.out"].println("Random adjustment: " + randomAdjustment) ; 
    var finalPrice : double ; finalPrice := basePrice + randomAdjustment ;
    OclFile["System.out"].println("Final price after adjustment: " + finalPrice) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
    public static void main(String[] args) {
        double lowerBound = 10.0;
        double upperBound = 20.0;
        double randomValue = lowerBound + (Math.random() * (upperBound - lowerBound));
        System.out.println("Random value between " + lowerBound + " and " + upperBound + ": " + randomValue);
    }
}

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var lowerBound : double ; lowerBound := 10.0 ;
     var upperBound : double ; upperBound := 20.0 ;
     var randomValue : double ; randomValue := lowerBound + (MathLib.random() * (upperBound - lowerBound)) ;
     OclFile["System.out"].println("Random value between " + lowerBound + " and " + upperBound + ": " + randomValue) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
    public static void main(String[] args) {
        boolean flipCoin = Math.random() < 0.5;  
        System.out.println("Coin flip result: " + (flipCoin ? "Heads" : "Tails"));
    }
}

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var flipCoin : boolean ; flipCoin := MathLib.random() < 0.5 ;
     OclFile["System.out"].println("Coin flip result: " + (if flipCoin then "Heads" else "Tails" endif)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
    public static void main(String[] args) {
        double score = Math.random() * 100;  
        System.out.println("Random score: " + score);
        if (score > 50) {
            System.out.println("You passed!");
        } else {
            System.out.println("You failed.");
        }
    }
}

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var score : double ; score := MathLib.random() * 100 ;
     OclFile["System.out"].println("Random score: " + score) ; 
     if (score > 50) then (     OclFile["System.out"].println("You passed!") ) else (     OclFile["System.out"].println("You failed.") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
    public static void main(String[] args) {
        double weight = Math.random() * 50 + 100; 
        System.out.println("Generated random weight: " + weight);
        if (weight < 120) {
            System.out.println("Lightweight category.");
        } else {
            System.out.println("Heavyweight category.");
        }
    }
}

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var weight : double ; weight := MathLib.random() * 50 + 100 ;
     OclFile["System.out"].println("Generated random weight: " + weight) ; 
     if (weight < 120) then (     OclFile["System.out"].println("Lightweight category.") ) else (     OclFile["System.out"].println("Heavyweight category.") ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
    public static void main(String[] args) {
        double temperature = 20.0;  
        double fluctuation = Math.random() * 5 - 2.5;  
        System.out.println("Original temperature: " + temperature);
        System.out.println("Fluctuation: " + fluctuation);
        double newTemperature = temperature + fluctuation;
        System.out.println("New temperature: " + newTemperature);
    }
}

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var temperature : double ; temperature := 20.0 ;
     var fluctuation : double ; fluctuation := MathLib.random() * 5 - 2.5 ;
    OclFile["System.out"].println("Original temperature: " + temperature) ; 
    OclFile["System.out"].println("Fluctuation: " + fluctuation) ; 
    var newTemperature : double ; newTemperature := temperature + fluctuation ;
    OclFile["System.out"].println("New temperature: " + newTemperature) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
    public static void main(String[] args) {
        char[] sourceArray = {'a', 'b', 'c', 'd', 'e'};
        char[] targetArray = new char[5];
        System.arraycopy(sourceArray, 1, targetArray, 0, 3);
        targetArray[2] = 'z';  
        System.out.println(java.util.Arrays.toString(targetArray));
    }
}

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sourceArray : Sequence(String) ; sourceArray := Sequence{'a','b','c','d','e'} ;
     var targetArray : Sequence(String) ; targetArray := Integer.subrange(1,5)->collect(0) ;
    for _x : Integer.subrange(1,3) do targetArray[0 + _x] := sourceArray[1 + _x] ; 
    targetArray[2+1] := 'z' ; 
    OclFile["System.out"].println(java.util.Arrays.toString(targetArray)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
    public static void main(String[] args) {
        String[] sourceArray = {"apple", "banana", "cherry", "date"};
        String[] targetArray = new String[4];
        System.arraycopy(sourceArray, 1, targetArray, 0, 3);
        targetArray[1] = "orange";  
        System.out.println(java.util.Arrays.toString(targetArray));
    }
}

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sourceArray : Sequence(String) ; sourceArray := Sequence{"apple","banana","cherry","date"} ;
     var targetArray : Sequence(String) ; targetArray := Integer.subrange(1,4)->collect(null) ;
    for _x : Integer.subrange(1,3) do targetArray[0 + _x] := sourceArray[1 + _x] ; 
    targetArray[1+1] := "orange" ; 
    OclFile["System.out"].println(java.util.Arrays.toString(targetArray)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
    public static void main(String[] args) {
        int[] sourceArray = {1, 2, 3, 4, 5, 6};
        int[] targetArray = new int[3];
        System.arraycopy(sourceArray, 3, targetArray, 0, 3);
        for (int i = 0; i < targetArray.length / 2; i++) {
            int temp = targetArray[i];
            targetArray[i] = targetArray[targetArray.length - 1 - i];
            targetArray[targetArray.length - 1 - i] = temp;
        }
        System.out.println(java.util.Arrays.toString(targetArray));
    }
}

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sourceArray : Sequence(int) ; sourceArray := Sequence{1,2,3,4,5,6} ;
     var targetArray : Sequence(int) ; targetArray := Integer.subrange(1,3)->collect(0) ;
    for _x : Integer.subrange(1,3) do targetArray[0 + _x] := sourceArray[3 + _x] ; 
        var i : int ; i := 0 ; while i < targetArray->size() / 2 do ( (     var temp : int ; temp := targetArray[i+1] ;
     targetArray[i+1] := targetArray[targetArray->size() - 1 - i+1] ; 
     targetArray[targetArray->size() - 1 - i+1] := temp )  ;     i := i + 1 ) ; 
    OclFile["System.out"].println(java.util.Arrays.toString(targetArray)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
    public static void main(String[] args) {
        double[] sourceArray = new double[5];
        double[] targetArray = new double[5];
        for (int i = 0; i < sourceArray.length; i++) {
            sourceArray[i] = Math.random();
        }
        System.arraycopy(sourceArray, 0, targetArray, 0, sourceArray.length);
        System.out.println("Source array: " + java.util.Arrays.toString(sourceArray));
        System.out.println("Target array: " + java.util.Arrays.toString(targetArray));
    }
}

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sourceArray : Sequence(double) ; sourceArray := Integer.subrange(1,5)->collect(0.0) ;
     var targetArray : Sequence(double) ; targetArray := Integer.subrange(1,5)->collect(0.0) ;
        var i : int ; i := 0 ; while i < sourceArray->size() do ( (     sourceArray[i+1] := MathLib.random() )  ;     i := i + 1 ) ; 
    for _x : Integer.subrange(1,sourceArray->size()) do targetArray[0 + _x] := sourceArray[0 + _x] ; 
    OclFile["System.out"].println("Source array: " + java.util.Arrays.toString(sourceArray)) ; 
    OclFile["System.out"].println("Target array: " + java.util.Arrays.toString(targetArray)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
    public static void main(String[] args) {
        int[] sourceArray = {1, 2, 3, 4, 5};
        int[] targetArray = new int[6];
        System.arraycopy(sourceArray, 0, targetArray, 1, sourceArray.length);
        System.out.println(java.util.Arrays.toString(targetArray));
    }
}

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sourceArray : Sequence(int) ; sourceArray := Sequence{1,2,3,4,5} ;
     var targetArray : Sequence(int) ; targetArray := Integer.subrange(1,6)->collect(0) ;
     for _x : Integer.subrange(1,sourceArray->size()) do targetArray[1 + _x] := sourceArray[0 + _x] ; 
     OclFile["System.out"].println(java.util.Arrays.toString(targetArray)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
    public static void main(String[] args) {
        int[][] sourceArray = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        int[][] targetArray = new int[3][3];
        for (int i = 0; i < sourceArray.length; i++) {
            System.arraycopy(sourceArray[i], 0, targetArray[i], 0, sourceArray[i].length);
        }
        System.out.println(java.util.Arrays.deepToString(targetArray));
    }
}

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sourceArray : Sequence(Sequence(int)) ; sourceArray := Sequence{Sequence{1,2,3},Sequence{4,5,6},Sequence{7,8,9}} ;
     var targetArray : Sequence(Sequence(int)) ; targetArray := Integer.subrange(1,3)->collect(Integer.subrange(1,3)->collect(0)) ;
         var i : int ; i := 0 ; while i < sourceArray->size() do ( (     for _x : Integer.subrange(1,sourceArray[i+1]->size()) do targetArray[i+1][0 + _x] := sourceArray[i+1][0 + _x] )  ;     i := i + 1 ) ; 
     OclFile["System.out"].println(java.util.Arrays.deepToString(targetArray)) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
    public static void main(String[] args) {
        int[] firstArray = {1, 2, 3};
        int[] secondArray = {4, 5, 6};
        int[] resultArray = new int[firstArray.length + secondArray.length];
        System.arraycopy(firstArray, 0, resultArray, 0, firstArray.length);
        System.arraycopy(secondArray, 0, resultArray, firstArray.length, secondArray.length);
        System.out.println(java.util.Arrays.toString(resultArray));
    }
}

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var firstArray : Sequence(int) ; firstArray := Sequence{1,2,3} ;
     var secondArray : Sequence(int) ; secondArray := Sequence{4,5,6} ;
    var resultArray : Sequence(int) ; resultArray := Integer.subrange(1,firstArray->size() + secondArray->size())->collect(0) ;
    for _x : Integer.subrange(1,firstArray->size()) do resultArray[0 + _x] := firstArray[0 + _x] ; 
    for _x : Integer.subrange(1,secondArray->size()) do resultArray[firstArray->size() + _x] := secondArray[0 + _x] ; 
    OclFile["System.out"].println(java.util.Arrays.toString(resultArray)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main {
    public static void main(String[] args) {
        double randomValue = Math.random();
        System.out.println("Random value: " + randomValue);
        if (randomValue > 0.5) {
            randomValue += 0.1;
        } else {
            randomValue -= 0.1;
        }
        System.out.println("Modified random value: " + randomValue);
    }
}

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var randomValue : double ; randomValue := MathLib.random() ;
     OclFile["System.out"].println("Random value: " + randomValue) ; 
     if (randomValue > 0.5) then (     randomValue := randomValue+(0.1) ) else (     randomValue := randomValue-(0.1) ) ;  
     OclFile["System.out"].println("Modified random value: " + randomValue) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class KhOdCklOVaFG { 
  public KhOdCklOVaFG() { }
  String DEytSnYuC = "oSqENKAXMG";
  boolean BHptWq = true;
  ArrayList<Boolean> hmyMEYyFYO = new ArrayList<Boolean>();
  double vqERuxKJfAYNy = 14.97;
  boolean wYOH = false;
  long qgAGRfIr = 0;
  int DBkBJwTwMSea = 633;
  int eJn = 515;
}

------------------------------------------------------------
OCL File:
---------
 class KhOdCklOVaFG {
   static operation newKhOdCklOVaFG() : KhOdCklOVaFG
  pre: true
  post: true
  activity:
  ( var self : KhOdCklOVaFG ;
    self := createKhOdCklOVaFG();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute DEytSnYuC : String := "oSqENKAXMG";
   attribute BHptWq : boolean := true;
   attribute hmyMEYyFYO : Sequence(Boolean) := Sequence{};
   attribute vqERuxKJfAYNy : double := 14.97;
   attribute wYOH : boolean := false;
   attribute qgAGRfIr : long := 0;
   attribute DBkBJwTwMSea : int := 633;
   attribute eJn : int := 515;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class QCSzpQtRbfgEC { 
  public QCSzpQtRbfgEC() { }
  int mmpjqzd = 279;
  HashSet<String> acLlSIWrZg = new HashSet<String>();
  long zElouVUmpES = 0;
  boolean pJvFUBCORcGq = false;
  double tfgDOjzcB = 24.22;
  int HDQIU = 535;
  QCSzpQtRbfgEC BjzhPQTkD = null;
}
class nIztKviiOg { 
  public nIztKviiOg() { }
}
class IWfwo extends QCSzpQtRbfgEC {
  public IWfwo() { super(); }
}
class QKPkAr { 
  public QKPkAr() { }
  ArrayList<Double> wwyprIFnWB = new ArrayList<Double>();
  HashSet<Long> qBTDTvHWtB = new HashSet<Long>();
}
class Aqq { 
  public Aqq() { }
  int SnltRbzaS = 461;
  int ygOSKvjgdhU = 370;
  String yNaThfyxt = "SvvxhwO";
  nIztKviiOg XfAgwzR = null;
}
class ZQfwlqaI { 
  public ZQfwlqaI() { }
  long rAywUePVdOFT = 0;
  double uAccNMoIf = 98.63;
  String LGP = "EKxvJAbFbz";
  long uKhFbRX = 0;
  boolean fQachkjZU = false;
  QKPkAr WUFFvV = null;
  HashSet<QKPkAr> wTVGPWRkdt = new HashSet<QKPkAr>();
  ZQfwlqaI YLuFoIx = null;
}
class LRAyQw { 
  public LRAyQw() { }
  double wxw = 79.14;
  HashSet<ArrayList<HashSet<Double>>> dIulQHkcoS = new HashSet<ArrayList<HashSet<Double>>>();
  boolean iFxDmymcQPl = true;
}
class FYLy { 
  public FYLy() { }
  String NGUvQNoDadXcY = "ZEH";
  int apRzu = 651;
  long yvPhQsmKm = 0;
  boolean edkHqVj = true;
  int akMZ = 414;
  FYLy mOZ = null;
  ZQfwlqaI LHfN = null;
}
class dnTIBXwlGKf extends FYLy {
  public dnTIBXwlGKf() { super(); }
  boolean BlNWdGFTEVCrX = true;
  int ZTItkxZETaKQ = 234;
  String ITfMwWcgAmY = "yJKQJaxEYra";
  Aqq XzIkPDfEi = null;
  Aqq eFqaBO = null;
}
class sqGBIwvd { 
  public sqGBIwvd() { }
  long fdAP = 0;
}

------------------------------------------------------------
OCL File:
---------
 class QCSzpQtRbfgEC {
   static operation newQCSzpQtRbfgEC() : QCSzpQtRbfgEC
  pre: true
  post: true
  activity:
  ( var self : QCSzpQtRbfgEC ;
    self := createQCSzpQtRbfgEC();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute mmpjqzd : int := 279;
   attribute acLlSIWrZg : Set(String) := Set{};
   attribute zElouVUmpES : long := 0;
   attribute pJvFUBCORcGq : boolean := false;
   attribute tfgDOjzcB : double := 24.22;
   attribute HDQIU : int := 535;
   attribute BjzhPQTkD : QCSzpQtRbfgEC := null;
}
class nIztKviiOg {
   static operation newnIztKviiOg() : nIztKviiOg
  pre: true
  post: true
  activity:
  ( var self : nIztKviiOg ;
    self := createnIztKviiOg();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
}
class IWfwo extends QCSzpQtRbfgEC {
   static operation newIWfwo() : IWfwo
  pre: true
  post: true
  activity:
  ( var self : IWfwo ;
    self := createIWfwo();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super() );
}
class QKPkAr {
   static operation newQKPkAr() : QKPkAr
  pre: true
  post: true
  activity:
  ( var self : QKPkAr ;
    self := createQKPkAr();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute wwyprIFnWB : Sequence(double) := Sequence{};
   attribute qBTDTvHWtB : Set(long) := Set{};
}
class Aqq {
   static operation newAqq() : Aqq
  pre: true
  post: true
  activity:
  ( var self : Aqq ;
    self := createAqq();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute SnltRbzaS : int := 461;
   attribute ygOSKvjgdhU : int := 370;
   attribute yNaThfyxt : String := "SvvxhwO";
   attribute XfAgwzR : nIztKviiOg := null;
}
class ZQfwlqaI {
   static operation newZQfwlqaI() : ZQfwlqaI
  pre: true
  post: true
  activity:
  ( var self : ZQfwlqaI ;
    self := createZQfwlqaI();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute rAywUePVdOFT : long := 0;
   attribute uAccNMoIf : double := 98.63;
   attribute LGP : String := "EKxvJAbFbz";
   attribute uKhFbRX : long := 0;
   attribute fQachkjZU : boolean := false;
   attribute WUFFvV : QKPkAr := null;
   attribute wTVGPWRkdt : Set(QKPkAr) := Set{};
   attribute YLuFoIx : ZQfwlqaI := null;
}
class LRAyQw {
   static operation newLRAyQw() : LRAyQw
  pre: true
  post: true
  activity:
  ( var self : LRAyQw ;
    self := createLRAyQw();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute wxw : double := 79.14;
   attribute dIulQHkcoS : Set(Sequence(Set(double))) := Set{};
   attribute iFxDmymcQPl : boolean := true;
}
class FYLy {
   static operation newFYLy() : FYLy
  pre: true
  post: true
  activity:
  ( var self : FYLy ;
    self := createFYLy();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute NGUvQNoDadXcY : String := "ZEH";
   attribute apRzu : int := 651;
   attribute yvPhQsmKm : long := 0;
   attribute edkHqVj : boolean := true;
   attribute akMZ : int := 414;
   attribute mOZ : FYLy := null;
   attribute LHfN : ZQfwlqaI := null;
}
class dnTIBXwlGKf extends FYLy {
   static operation newdnTIBXwlGKf() : dnTIBXwlGKf
  pre: true
  post: true
  activity:
  ( var self : dnTIBXwlGKf ;
    self := creatednTIBXwlGKf();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super() );
   attribute BlNWdGFTEVCrX : boolean := true;
   attribute ZTItkxZETaKQ : int := 234;
   attribute ITfMwWcgAmY : String := "yJKQJaxEYra";
   attribute XzIkPDfEi : Aqq := null;
   attribute eFqaBO : Aqq := null;
}
class sqGBIwvd {
   static operation newsqGBIwvd() : sqGBIwvd
  pre: true
  post: true
  activity:
  ( var self : sqGBIwvd ;
    self := createsqGBIwvd();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute fdAP : long := 0;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class zCkEDsjL { 
  public zCkEDsjL() { }
  ArrayList<HashSet<String>> ylsRJzlKIj = new ArrayList<HashSet<String>>();
  String MXEiFyH = "mELssSUQiQX";
  zCkEDsjL QWB = null;
}
class GKUOZaYhFnpSr { 
  public GKUOZaYhFnpSr() { }
  HashSet<Long> hYyjWMeyjB = new HashSet<Long>();
  int CvpYYNCOPkkjL = 157;
  boolean sPWdWiUzHv = false;
  String Clz = "lWkmEBK";
  ArrayList<String> edSShCNXFZ = new ArrayList<String>();
  boolean lozqcluO = false;
}
class lwLrTz { 
  public lwLrTz() { }
  String GIvLhNdpqF = "CUFQjwYkJ";
  int TzSdFrE = 770;
  double eInPYetBeB = 12.04;
  String CtgIMFNQQ = "HWvRfIWSWuxa";
  ArrayList<HashSet<String>> awUMGMDMTt = new ArrayList<HashSet<String>>();
  double ZVyyxBDEMCI = 75.64;
  long OpahCzQkxL = 0;
  long LPgQv = 0;
  long xmZH = 0;
}
class wjqbyhynHCCML { 
  public wjqbyhynHCCML() { }
  String wGQBrsFr = "wnWgpgvsHr";
  double qNsQQl = 20.14;
  boolean rRxAqSh = true;
  int fMSL = 516;
  double YltiQLIzX = 78.45;
}
class IXgqkjRMN { 
  public IXgqkjRMN() { }
  ArrayList<String> zRkZTOybAF = new ArrayList<String>();
  HashSet<zCkEDsjL> vuALPeyFsB = new HashSet<zCkEDsjL>();
}
class fAYScBtkAmd { 
  public fAYScBtkAmd() { }
  boolean msxqFOxlc = false;
  HashSet<Long> tWYTGsApmh = new HashSet<Long>();
  String tXCsxE = "WzxeMbKRpfq";
  boolean cLDl = true;
  double cmIwH = 2.77;
  ArrayList<Integer> eKgdlEkxon = new ArrayList<Integer>();
  zCkEDsjL RUBTDdm = null;
  lwLrTz RqkITlmswrS = null;
  zCkEDsjL WRXS = null;
}
class khWI { 
  public khWI() { }
  String wpRXragSkr = "kxNqkzvtOps";
  ArrayList<Long> xOJXFxSxej = new ArrayList<Long>();
  String UuacKFF = "cpCnqve";
  long lREkXzyRHL = 0;
  HashSet<Boolean> qoFPgkfbHb = new HashSet<Boolean>();
}
class tSf { 
  public tSf() { }
  boolean TZilUqTCsEjut = false;
  String vMQaTEdmq = "PcadRLbDok";
  int PllUjIkAdtvbq = 966;
  double jDm = 59.08;
  long vYwhakGDFGDMA = 0;
  ArrayList<GKUOZaYhFnpSr> oEiLyiRTZD = new ArrayList<GKUOZaYhFnpSr>();
  GKUOZaYhFnpSr PWjBzKKeaVuJ = null;
}
class pEwwfZehhDB extends wjqbyhynHCCML {
  public pEwwfZehhDB() { super(); }
}
class WZrfrvcl { 
  public WZrfrvcl() { }
  boolean aEigGXIug = true;
  wjqbyhynHCCML bEW = null;
}
class SHEdnHqQMoP { 
  public SHEdnHqQMoP() { }
  double Pomu = 44.15;
  long SQrREYp = 0;
  HashSet<fAYScBtkAmd> dYSzQfAoCC = new HashSet<fAYScBtkAmd>();
}

------------------------------------------------------------
OCL File:
---------
 class zCkEDsjL {
   static operation newzCkEDsjL() : zCkEDsjL
  pre: true
  post: true
  activity:
  ( var self : zCkEDsjL ;
    self := createzCkEDsjL();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute ylsRJzlKIj : Sequence(Set(String)) := Sequence{};
   attribute MXEiFyH : String := "mELssSUQiQX";
   attribute QWB : zCkEDsjL := null;
}
class GKUOZaYhFnpSr {
   static operation newGKUOZaYhFnpSr() : GKUOZaYhFnpSr
  pre: true
  post: true
  activity:
  ( var self : GKUOZaYhFnpSr ;
    self := createGKUOZaYhFnpSr();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute hYyjWMeyjB : Set(long) := Set{};
   attribute CvpYYNCOPkkjL : int := 157;
   attribute sPWdWiUzHv : boolean := false;
   attribute Clz : String := "lWkmEBK";
   attribute edSShCNXFZ : Sequence(String) := Sequence{};
   attribute lozqcluO : boolean := false;
}
class lwLrTz {
   static operation newlwLrTz() : lwLrTz
  pre: true
  post: true
  activity:
  ( var self : lwLrTz ;
    self := createlwLrTz();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute GIvLhNdpqF : String := "CUFQjwYkJ";
   attribute TzSdFrE : int := 770;
   attribute eInPYetBeB : double := 12.04;
   attribute CtgIMFNQQ : String := "HWvRfIWSWuxa";
   attribute awUMGMDMTt : Sequence(Set(String)) := Sequence{};
   attribute ZVyyxBDEMCI : double := 75.64;
   attribute OpahCzQkxL : long := 0;
   attribute LPgQv : long := 0;
   attribute xmZH : long := 0;
}
class wjqbyhynHCCML {
   static operation newwjqbyhynHCCML() : wjqbyhynHCCML
  pre: true
  post: true
  activity:
  ( var self : wjqbyhynHCCML ;
    self := createwjqbyhynHCCML();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute wGQBrsFr : String := "wnWgpgvsHr";
   attribute qNsQQl : double := 20.14;
   attribute rRxAqSh : boolean := true;
   attribute fMSL : int := 516;
   attribute YltiQLIzX : double := 78.45;
}
class IXgqkjRMN {
   static operation newIXgqkjRMN() : IXgqkjRMN
  pre: true
  post: true
  activity:
  ( var self : IXgqkjRMN ;
    self := createIXgqkjRMN();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute zRkZTOybAF : Sequence(String) := Sequence{};
   attribute vuALPeyFsB : Set(zCkEDsjL) := Set{};
}
class fAYScBtkAmd {
   static operation newfAYScBtkAmd() : fAYScBtkAmd
  pre: true
  post: true
  activity:
  ( var self : fAYScBtkAmd ;
    self := createfAYScBtkAmd();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute msxqFOxlc : boolean := false;
   attribute tWYTGsApmh : Set(long) := Set{};
   attribute tXCsxE : String := "WzxeMbKRpfq";
   attribute cLDl : boolean := true;
   attribute cmIwH : double := 2.77;
   attribute eKgdlEkxon : Sequence(int) := Sequence{};
   attribute RUBTDdm : zCkEDsjL := null;
   attribute RqkITlmswrS : lwLrTz := null;
   attribute WRXS : zCkEDsjL := null;
}
class khWI {
   static operation newkhWI() : khWI
  pre: true
  post: true
  activity:
  ( var self : khWI ;
    self := createkhWI();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute wpRXragSkr : String := "kxNqkzvtOps";
   attribute xOJXFxSxej : Sequence(long) := Sequence{};
   attribute UuacKFF : String := "cpCnqve";
   attribute lREkXzyRHL : long := 0;
   attribute qoFPgkfbHb : Set(Boolean) := Set{};
}
class tSf {
   static operation newtSf() : tSf
  pre: true
  post: true
  activity:
  ( var self : tSf ;
    self := createtSf();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute TZilUqTCsEjut : boolean := false;
   attribute vMQaTEdmq : String := "PcadRLbDok";
   attribute PllUjIkAdtvbq : int := 966;
   attribute jDm : double := 59.08;
   attribute vYwhakGDFGDMA : long := 0;
   attribute oEiLyiRTZD : Sequence(GKUOZaYhFnpSr) := Sequence{};
   attribute PWjBzKKeaVuJ : GKUOZaYhFnpSr := null;
}
class pEwwfZehhDB extends wjqbyhynHCCML {
   static operation newpEwwfZehhDB() : pEwwfZehhDB
  pre: true
  post: true
  activity:
  ( var self : pEwwfZehhDB ;
    self := createpEwwfZehhDB();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super() );
}
class WZrfrvcl {
   static operation newWZrfrvcl() : WZrfrvcl
  pre: true
  post: true
  activity:
  ( var self : WZrfrvcl ;
    self := createWZrfrvcl();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute aEigGXIug : boolean := true;
   attribute bEW : wjqbyhynHCCML := null;
}
class SHEdnHqQMoP {
   static operation newSHEdnHqQMoP() : SHEdnHqQMoP
  pre: true
  post: true
  activity:
  ( var self : SHEdnHqQMoP ;
    self := createSHEdnHqQMoP();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute Pomu : double := 44.15;
   attribute SQrREYp : long := 0;
   attribute dYSzQfAoCC : Set(fAYScBtkAmd) := Set{};
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class SSbGJyhQHvO { 
  public SSbGJyhQHvO() { }
  int DBgdxCy = 756;
  SSbGJyhQHvO hMpveWnfUEcUU = null;
  ArrayList<SSbGJyhQHvO> dJUfQTirTk = new ArrayList<SSbGJyhQHvO>();
}
class qvaA { 
  public qvaA() { }
  ArrayList<qvaA> rtlFgXVSsb = new ArrayList<qvaA>();
}
class tdolMpx extends SSbGJyhQHvO {
  public tdolMpx() { super(); }
  double ideFOljxlapX = 80.05;
  ArrayList<ArrayList<String>> nuPsexhCrJ = new ArrayList<ArrayList<String>>();
  HashSet<HashSet<Boolean>> wyGOZOGIal = new HashSet<HashSet<Boolean>>();
}
class UMReWlL { 
  public UMReWlL() { }
}
class VSxGyMRbPh { 
  public VSxGyMRbPh() { }
  String foEYJuGVlO = "YOEBbAMm";
  long UFlCtQA = 0;
  String acGlNgBHxYn = "RRQeW";
}
class UynpDfkRPM { 
  public UynpDfkRPM() { }
}
class untDe { 
  public untDe() { }
  double wMMUtdmX = 53.05;
}
class bwMhqjKJn extends untDe {
  public bwMhqjKJn() { super(); }
  int ZssooyOvu = 495;
  int PzpmBRGyKBROn = 971;
}
class TjcEgZrFmphOB extends bwMhqjKJn {
  public TjcEgZrFmphOB() { super(); }
  int fQQGpS = 585;
  boolean hqcwPJM = true;
  long pCjDid = 0;
  boolean OGAYQgzqCE = false;
  ArrayList<HashSet<Long>> pvpInlIJRv = new ArrayList<HashSet<Long>>();
  long VgjMbG = 0;
  int VfUQeftqau = 978;
  int aoCUOwqBjT = 134;
}
class gxrDurUdTXn { 
  ArrayList<String> eVKJWIkWma = new ArrayList<String>();
  String vaxTZXm = "CDNTZcPxysci";
  boolean gKSSV = false;
  long TQN = 0;
  double xRFpFqQufRRU = 66.57;
  long tqevyrHpJIvB = 0;
  long WTnDRSE = 0;
}
class pcjzgAEFpTFG { 
  public pcjzgAEFpTFG() { }
  int aLTXJoZtHfzWM = 946;
  boolean tnwwoafcom = false;
  gxrDurUdTXn VOsSMkRPYLUwS = null;
}
class pVFxWLVMC { 
  public pVFxWLVMC() { }
  ArrayList<Boolean> wpdlDseFFf = new ArrayList<Boolean>();
  ArrayList<ArrayList<ArrayList<Integer>>> iPOXULVbjA = new ArrayList<ArrayList<ArrayList<Integer>>>();
}

------------------------------------------------------------
OCL File:
---------
 class SSbGJyhQHvO {
   static operation newSSbGJyhQHvO() : SSbGJyhQHvO
  pre: true
  post: true
  activity:
  ( var self : SSbGJyhQHvO ;
    self := createSSbGJyhQHvO();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute DBgdxCy : int := 756;
   attribute hMpveWnfUEcUU : SSbGJyhQHvO := null;
   attribute dJUfQTirTk : Sequence(SSbGJyhQHvO) := Sequence{};
}
class qvaA {
   static operation newqvaA() : qvaA
  pre: true
  post: true
  activity:
  ( var self : qvaA ;
    self := createqvaA();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute rtlFgXVSsb : Sequence(qvaA) := Sequence{};
}
class tdolMpx extends SSbGJyhQHvO {
   static operation newtdolMpx() : tdolMpx
  pre: true
  post: true
  activity:
  ( var self : tdolMpx ;
    self := createtdolMpx();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super() );
   attribute ideFOljxlapX : double := 80.05;
   attribute nuPsexhCrJ : Sequence(Sequence(String)) := Sequence{};
   attribute wyGOZOGIal : Set(Set(Boolean)) := Set{};
}
class UMReWlL {
   static operation newUMReWlL() : UMReWlL
  pre: true
  post: true
  activity:
  ( var self : UMReWlL ;
    self := createUMReWlL();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
}
class VSxGyMRbPh {
   static operation newVSxGyMRbPh() : VSxGyMRbPh
  pre: true
  post: true
  activity:
  ( var self : VSxGyMRbPh ;
    self := createVSxGyMRbPh();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute foEYJuGVlO : String := "YOEBbAMm";
   attribute UFlCtQA : long := 0;
   attribute acGlNgBHxYn : String := "RRQeW";
}
class UynpDfkRPM {
   static operation newUynpDfkRPM() : UynpDfkRPM
  pre: true
  post: true
  activity:
  ( var self : UynpDfkRPM ;
    self := createUynpDfkRPM();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
}
class untDe {
   static operation newuntDe() : untDe
  pre: true
  post: true
  activity:
  ( var self : untDe ;
    self := createuntDe();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute wMMUtdmX : double := 53.05;
}
class bwMhqjKJn extends untDe {
   static operation newbwMhqjKJn() : bwMhqjKJn
  pre: true
  post: true
  activity:
  ( var self : bwMhqjKJn ;
    self := createbwMhqjKJn();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super() );
   attribute ZssooyOvu : int := 495;
   attribute PzpmBRGyKBROn : int := 971;
}
class TjcEgZrFmphOB extends bwMhqjKJn {
   static operation newTjcEgZrFmphOB() : TjcEgZrFmphOB
  pre: true
  post: true
  activity:
  ( var self : TjcEgZrFmphOB ;
    self := createTjcEgZrFmphOB();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super() );
   attribute fQQGpS : int := 585;
   attribute hqcwPJM : boolean := true;
   attribute pCjDid : long := 0;
   attribute OGAYQgzqCE : boolean := false;
   attribute pvpInlIJRv : Sequence(Set(long)) := Sequence{};
   attribute VgjMbG : long := 0;
   attribute VfUQeftqau : int := 978;
   attribute aoCUOwqBjT : int := 134;
}
class gxrDurUdTXn {
   attribute eVKJWIkWma : Sequence(String) := Sequence{};
   attribute vaxTZXm : String := "CDNTZcPxysci";
   attribute gKSSV : boolean := false;
   attribute TQN : long := 0;
   attribute xRFpFqQufRRU : double := 66.57;
   attribute tqevyrHpJIvB : long := 0;
   attribute WTnDRSE : long := 0;
}
class pcjzgAEFpTFG {
   static operation newpcjzgAEFpTFG() : pcjzgAEFpTFG
  pre: true
  post: true
  activity:
  ( var self : pcjzgAEFpTFG ;
    self := createpcjzgAEFpTFG();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute aLTXJoZtHfzWM : int := 946;
   attribute tnwwoafcom : boolean := false;
   attribute VOsSMkRPYLUwS : gxrDurUdTXn := null;
}
class pVFxWLVMC {
   static operation newpVFxWLVMC() : pVFxWLVMC
  pre: true
  post: true
  activity:
  ( var self : pVFxWLVMC ;
    self := createpVFxWLVMC();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute wpdlDseFFf : Sequence(Boolean) := Sequence{};
   attribute iPOXULVbjA : Sequence(Sequence(Sequence(int))) := Sequence{};
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class WcpGeClI { 
  public WcpGeClI() { }
  int hKRc = 795;
  double QvBNhkpN = 41.21;
  HashSet<String> yjYodqDZzP = new HashSet<String>();
  HashSet<Long> ilqbJMbSfl = new HashSet<Long>();
  ArrayList<ArrayList<Double>> jyiGkARgVZ = new ArrayList<ArrayList<Double>>();
  int TatPrplE = 265;
  String XRcRlwXyaC = "KWghQktJJFoIq";
  int iLSjT = 843;
  WcpGeClI GiZWsAGYJNdiS = null;
}
class kYpOLfPUkqM { 
  public kYpOLfPUkqM() { }
  int JhDhbl = 209;
  boolean kZctuTFUuvkCz = false;
  long doARMIc = 0;
  boolean IwayrXiRzo = false;
  long czAbFnLC = 0;
  int IekbSayFMj = 40;
  kYpOLfPUkqM bpWwCD = null;
}
class UcfhFlhJh { 
  public UcfhFlhJh() { }
  boolean FIA = false;
  int sifDhy = 86;
  int fGDmBqE = 294;
  boolean dcILcofel = true;
  HashSet<String> lAsMAxEBnR = new HashSet<String>();
  long PcI = 0;
  HashSet<String> wFJLNtHgTN = new HashSet<String>();
  double qPBZMbdiiLT = 89.44;
  ArrayList<kYpOLfPUkqM> uQWCWimQVy = new ArrayList<kYpOLfPUkqM>();
}
class xMcO { 
  public xMcO() { }
  double HNUY = 72.46;
  double zpZuUJKGYz = 68.94;
  boolean zstVoWYTt = true;
}
class DSwCfKyQrQOaI { 
  public DSwCfKyQrQOaI() { }
  int kXZq = 415;
  boolean mACdaMz = true;
  int Dxk = 464;
  int TppCySUWoW = 63;
  long CCJaGrch = 0;
  String JBrIzfEzAtnBE = "HVZGXP";
  String GEmYx = "fGiNXeolzfO";
  ArrayList<Double> qQFxeppZYY = new ArrayList<Double>();
  WcpGeClI RpaGkcKCahB = null;
}
class ogXzbxZCW { 
  public ogXzbxZCW() { }
  int IodwRhVdCAE = 439;
  int AuKw = 57;
  HashSet<String> wmgdAykcxs = new HashSet<String>();
  String OXw = "QXeWD";
  double dbAZuqLrfnoG = 19.58;
  HashSet<Long> vjBBkCFfiR = new HashSet<Long>();
  double RmgZVFyUS = 69.75;
  ArrayList<Long> aDgGgfSDvy = new ArrayList<Long>();
}
class MsojzTqlTFJge { 
  public MsojzTqlTFJge() { }
  int ZbNttLEBpR = 762;
  boolean ykNlZRRIQH = false;
  String LzNwBqkzjUqs = "VjKgD";
  boolean omLZ = false;
  HashSet<String> iBkFPcozed = new HashSet<String>();
  long dqNVPbFsOPDK = 0;
  int aZOCRjwQ = 361;
}
class TfPrrxMZDjOHe { 
  public TfPrrxMZDjOHe() { }
  double EhZ = 57.65;
  String fxHY = "oJc";
  TfPrrxMZDjOHe XXbefNXvtI = null;
  TfPrrxMZDjOHe QmSqSrkbJIl = null;
}
class qALCtgKRS { 
  public qALCtgKRS() { }
  ArrayList<Long> yuYRLzffbd = new ArrayList<Long>();
  long cEF = 0;
  String qTL = "Dlc";
  String OUsrRIidceu = "UrVZIkS";
  boolean XnXsxGTMqrb = true;
  String zXnkxntYY = "hJSRnFQXqLlZ";
  boolean mYOcBEi = false;
  TfPrrxMZDjOHe rrrG = null;
  qALCtgKRS xAvMh = null;
}
class feexSznxqENd extends TfPrrxMZDjOHe {
  public feexSznxqENd() { super(); }
  long UkbplFFy = 0;
  HashSet<Long> xcjiGOmEey = new HashSet<Long>();
  String WZNfXflgJz = "SNh";
  long mXMlQZoY = 0;
  String KdBkDOV = "yNdERyWJmk";
  int IHamrHOxpk = 684;
}
class EEAJ extends TfPrrxMZDjOHe {
  public EEAJ() { super(); }
  boolean MwVfSWfG = true;
  boolean xBkKxYsMs = true;
  boolean UfUdr = true;
  ArrayList<ArrayList<feexSznxqENd>> njfZUlBbzM = new ArrayList<ArrayList<feexSznxqENd>>();
  long zseQsVTFHCr = 0;
  boolean RcoOGlnYQC = false;
  ArrayList<HashSet<Boolean>> vIHAumoASg = new ArrayList<HashSet<Boolean>>();
  int zKFNfBdgYvtja = 450;
}
class XJb { 
  public XJb() { }
  HashSet<ArrayList<Long>> jQztnvbGBV = new HashSet<ArrayList<Long>>();
  String uUZ = "MaJ";
  HashSet<String> wJOYHGMVjP = new HashSet<String>();
  boolean eOG = true;
  int afbjvaiTjG = 678;
  int DyGxmCjM = 510;
  String aveWHXD = "cJbjUpvB";
}
class aLZnU { 
  public aLZnU() { }
  double WdGF = 98.56;
  HashSet<Double> zeZhtIUwxc = new HashSet<Double>();
  boolean fiV = true;
  double AxFJikfnWH = 80.11;
  ArrayList<Long> uHgNAlVOQB = new ArrayList<Long>();
  aLZnU AdXSw = null;
}

------------------------------------------------------------
OCL File:
---------
 class WcpGeClI {
   static operation newWcpGeClI() : WcpGeClI
  pre: true
  post: true
  activity:
  ( var self : WcpGeClI ;
    self := createWcpGeClI();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute hKRc : int := 795;
   attribute QvBNhkpN : double := 41.21;
   attribute yjYodqDZzP : Set(String) := Set{};
   attribute ilqbJMbSfl : Set(long) := Set{};
   attribute jyiGkARgVZ : Sequence(Sequence(double)) := Sequence{};
   attribute TatPrplE : int := 265;
   attribute XRcRlwXyaC : String := "KWghQktJJFoIq";
   attribute iLSjT : int := 843;
   attribute GiZWsAGYJNdiS : WcpGeClI := null;
}
class kYpOLfPUkqM {
   static operation newkYpOLfPUkqM() : kYpOLfPUkqM
  pre: true
  post: true
  activity:
  ( var self : kYpOLfPUkqM ;
    self := createkYpOLfPUkqM();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute JhDhbl : int := 209;
   attribute kZctuTFUuvkCz : boolean := false;
   attribute doARMIc : long := 0;
   attribute IwayrXiRzo : boolean := false;
   attribute czAbFnLC : long := 0;
   attribute IekbSayFMj : int := 40;
   attribute bpWwCD : kYpOLfPUkqM := null;
}
class UcfhFlhJh {
   static operation newUcfhFlhJh() : UcfhFlhJh
  pre: true
  post: true
  activity:
  ( var self : UcfhFlhJh ;
    self := createUcfhFlhJh();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute FIA : boolean := false;
   attribute sifDhy : int := 86;
   attribute fGDmBqE : int := 294;
   attribute dcILcofel : boolean := true;
   attribute lAsMAxEBnR : Set(String) := Set{};
   attribute PcI : long := 0;
   attribute wFJLNtHgTN : Set(String) := Set{};
   attribute qPBZMbdiiLT : double := 89.44;
   attribute uQWCWimQVy : Sequence(kYpOLfPUkqM) := Sequence{};
}
class xMcO {
   static operation newxMcO() : xMcO
  pre: true
  post: true
  activity:
  ( var self : xMcO ;
    self := createxMcO();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute HNUY : double := 72.46;
   attribute zpZuUJKGYz : double := 68.94;
   attribute zstVoWYTt : boolean := true;
}
class DSwCfKyQrQOaI {
   static operation newDSwCfKyQrQOaI() : DSwCfKyQrQOaI
  pre: true
  post: true
  activity:
  ( var self : DSwCfKyQrQOaI ;
    self := createDSwCfKyQrQOaI();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute kXZq : int := 415;
   attribute mACdaMz : boolean := true;
   attribute Dxk : int := 464;
   attribute TppCySUWoW : int := 63;
   attribute CCJaGrch : long := 0;
   attribute JBrIzfEzAtnBE : String := "HVZGXP";
   attribute GEmYx : String := "fGiNXeolzfO";
   attribute qQFxeppZYY : Sequence(double) := Sequence{};
   attribute RpaGkcKCahB : WcpGeClI := null;
}
class ogXzbxZCW {
   static operation newogXzbxZCW() : ogXzbxZCW
  pre: true
  post: true
  activity:
  ( var self : ogXzbxZCW ;
    self := createogXzbxZCW();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute IodwRhVdCAE : int := 439;
   attribute AuKw : int := 57;
   attribute wmgdAykcxs : Set(String) := Set{};
   attribute OXw : String := "QXeWD";
   attribute dbAZuqLrfnoG : double := 19.58;
   attribute vjBBkCFfiR : Set(long) := Set{};
   attribute RmgZVFyUS : double := 69.75;
   attribute aDgGgfSDvy : Sequence(long) := Sequence{};
}
class MsojzTqlTFJge {
   static operation newMsojzTqlTFJge() : MsojzTqlTFJge
  pre: true
  post: true
  activity:
  ( var self : MsojzTqlTFJge ;
    self := createMsojzTqlTFJge();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute ZbNttLEBpR : int := 762;
   attribute ykNlZRRIQH : boolean := false;
   attribute LzNwBqkzjUqs : String := "VjKgD";
   attribute omLZ : boolean := false;
   attribute iBkFPcozed : Set(String) := Set{};
   attribute dqNVPbFsOPDK : long := 0;
   attribute aZOCRjwQ : int := 361;
}
class TfPrrxMZDjOHe {
   static operation newTfPrrxMZDjOHe() : TfPrrxMZDjOHe
  pre: true
  post: true
  activity:
  ( var self : TfPrrxMZDjOHe ;
    self := createTfPrrxMZDjOHe();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute EhZ : double := 57.65;
   attribute fxHY : String := "oJc";
   attribute XXbefNXvtI : TfPrrxMZDjOHe := null;
   attribute QmSqSrkbJIl : TfPrrxMZDjOHe := null;
}
class qALCtgKRS {
   static operation newqALCtgKRS() : qALCtgKRS
  pre: true
  post: true
  activity:
  ( var self : qALCtgKRS ;
    self := createqALCtgKRS();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute yuYRLzffbd : Sequence(long) := Sequence{};
   attribute cEF : long := 0;
   attribute qTL : String := "Dlc";
   attribute OUsrRIidceu : String := "UrVZIkS";
   attribute XnXsxGTMqrb : boolean := true;
   attribute zXnkxntYY : String := "hJSRnFQXqLlZ";
   attribute mYOcBEi : boolean := false;
   attribute rrrG : TfPrrxMZDjOHe := null;
   attribute xAvMh : qALCtgKRS := null;
}
class feexSznxqENd extends TfPrrxMZDjOHe {
   static operation newfeexSznxqENd() : feexSznxqENd
  pre: true
  post: true
  activity:
  ( var self : feexSznxqENd ;
    self := createfeexSznxqENd();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super() );
   attribute UkbplFFy : long := 0;
   attribute xcjiGOmEey : Set(long) := Set{};
   attribute WZNfXflgJz : String := "SNh";
   attribute mXMlQZoY : long := 0;
   attribute KdBkDOV : String := "yNdERyWJmk";
   attribute IHamrHOxpk : int := 684;
}
class EEAJ extends TfPrrxMZDjOHe {
   static operation newEEAJ() : EEAJ
  pre: true
  post: true
  activity:
  ( var self : EEAJ ;
    self := createEEAJ();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super() );
   attribute MwVfSWfG : boolean := true;
   attribute xBkKxYsMs : boolean := true;
   attribute UfUdr : boolean := true;
   attribute njfZUlBbzM : Sequence(Sequence(feexSznxqENd)) := Sequence{};
   attribute zseQsVTFHCr : long := 0;
   attribute RcoOGlnYQC : boolean := false;
   attribute vIHAumoASg : Sequence(Set(Boolean)) := Sequence{};
   attribute zKFNfBdgYvtja : int := 450;
}
class XJb {
   static operation newXJb() : XJb
  pre: true
  post: true
  activity:
  ( var self : XJb ;
    self := createXJb();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute jQztnvbGBV : Set(Sequence(long)) := Set{};
   attribute uUZ : String := "MaJ";
   attribute wJOYHGMVjP : Set(String) := Set{};
   attribute eOG : boolean := true;
   attribute afbjvaiTjG : int := 678;
   attribute DyGxmCjM : int := 510;
   attribute aveWHXD : String := "cJbjUpvB";
}
class aLZnU {
   static operation newaLZnU() : aLZnU
  pre: true
  post: true
  activity:
  ( var self : aLZnU ;
    self := createaLZnU();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute WdGF : double := 98.56;
   attribute zeZhtIUwxc : Set(double) := Set{};
   attribute fiV : boolean := true;
   attribute AxFJikfnWH : double := 80.11;
   attribute uHgNAlVOQB : Sequence(long) := Sequence{};
   attribute AdXSw : aLZnU := null;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class KXAnslJaVqlJ { 
  public KXAnslJaVqlJ() { }
  ArrayList<HashSet<KXAnslJaVqlJ>> lpeQwNBPvg = new ArrayList<HashSet<KXAnslJaVqlJ>>();
}
class XIRjqtl { 
  public XIRjqtl() { }
  ArrayList<ArrayList<ArrayList<HashSet<Integer>>>> fXvfAqnmdY = new ArrayList<ArrayList<ArrayList<HashSet<Integer>>>>();
  HashSet<Integer> hiTwafwBRQ = new HashSet<Integer>();
  double wlAD = 86.83;
  boolean bgQLqVsOJzjft = false;
  int oQjgZaXEDR = 558;
  boolean NfVhng = true;
}
class TJMWUQ { 
  public TJMWUQ() { }
  String PiteEom = "DEXgOXHMbL";
  long TXeQuFnSgCdB = 0;
  String BYBmeKrpI = "LhyH";
  XIRjqtl kbfnDQidLD = null;
  HashSet<TJMWUQ> hsaNNZYkfy = new HashSet<TJMWUQ>();
}
class AeBMPrUHlgit { 
  public AeBMPrUHlgit() { }
  boolean bJa = false;
  HashSet<HashSet<Long>> gWLOnoQLZl = new HashSet<HashSet<Long>>();
}
class OYaKiZbPXJUkf extends XIRjqtl {
  public OYaKiZbPXJUkf() { super(); }
  AeBMPrUHlgit dcocCc = null;
}
class sNr { 
  public sNr() { }
}
class STPVrB extends XIRjqtl {
  public STPVrB() { super(); }
}
class wnDhUfhscwv { 
  public wnDhUfhscwv() { }
  int POc = 695;
  double txnTT = 90.6;
  int pWwRa = 754;
  String rnmteovldhUEz = "ynhKFXSfwvtRD";
}
class nBVFMR { 
  public nBVFMR() { }
  String TzDSaA = "jXXpsj";
  double rXRbWjxrG = 24.77;
  int rlGYL = 220;
  double ITZxFCI = 8.92;
  wnDhUfhscwv igsXVWscwlL = null;
}
class zbSbpdekH { 
  public zbSbpdekH() { }
  long xiWRc = 0;
  boolean tfVQUJCjr = false;
  String iXpOoGvp = "crUs";
  double xscMIot = 27.98;
  HashSet<Double> sAhOHtUPoA = new HashSet<Double>();
  double inkguchqF = 99.59;
  int FiTEcWzF = 579;
}
class fwfQs { 
  public fwfQs() { }
  int OOlYaxde = 588;
  int HNLdXIltbnQTV = 508;
}
class YlHSQKS { 
  public YlHSQKS() { }
  int AHSv = 802;
  HashSet<HashSet<Integer>> wdDMLBflSH = new HashSet<HashSet<Integer>>();
  String cyPJaQevCLOif = "rsSAUv";
  long VrhOUAtAVXUDj = 0;
  YlHSQKS jUi = null;
}
class SOeZZuBeBEj { 
  public SOeZZuBeBEj() { }
  HashSet<Long> yBYveccgPe = new HashSet<Long>();
  HashSet<Integer> wbkpOJZTLz = new HashSet<Integer>();
}
class BsZtuPVb { 
  public BsZtuPVb() { }
  HashSet<String> fXJOHVhIEt = new HashSet<String>();
  double qMTDj = 14.28;
  int VSaFKcvIPIuq = 241;
  HashSet<HashSet<nBVFMR>> xIgTJWWivl = new HashSet<HashSet<nBVFMR>>();
  ArrayList<HashSet<fwfQs>> cckNAKynBS = new ArrayList<HashSet<fwfQs>>();
  wnDhUfhscwv vNPzNxcntTqO = null;
}

------------------------------------------------------------
OCL File:
---------
 class KXAnslJaVqlJ {
   static operation newKXAnslJaVqlJ() : KXAnslJaVqlJ
  pre: true
  post: true
  activity:
  ( var self : KXAnslJaVqlJ ;
    self := createKXAnslJaVqlJ();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute lpeQwNBPvg : Sequence(Set(KXAnslJaVqlJ)) := Sequence{};
}
class XIRjqtl {
   static operation newXIRjqtl() : XIRjqtl
  pre: true
  post: true
  activity:
  ( var self : XIRjqtl ;
    self := createXIRjqtl();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute fXvfAqnmdY : Sequence(Sequence(Sequence(Set(int)))) := Sequence{};
   attribute hiTwafwBRQ : Set(int) := Set{};
   attribute wlAD : double := 86.83;
   attribute bgQLqVsOJzjft : boolean := false;
   attribute oQjgZaXEDR : int := 558;
   attribute NfVhng : boolean := true;
}
class TJMWUQ {
   static operation newTJMWUQ() : TJMWUQ
  pre: true
  post: true
  activity:
  ( var self : TJMWUQ ;
    self := createTJMWUQ();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute PiteEom : String := "DEXgOXHMbL";
   attribute TXeQuFnSgCdB : long := 0;
   attribute BYBmeKrpI : String := "LhyH";
   attribute kbfnDQidLD : XIRjqtl := null;
   attribute hsaNNZYkfy : Set(TJMWUQ) := Set{};
}
class AeBMPrUHlgit {
   static operation newAeBMPrUHlgit() : AeBMPrUHlgit
  pre: true
  post: true
  activity:
  ( var self : AeBMPrUHlgit ;
    self := createAeBMPrUHlgit();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute bJa : boolean := false;
   attribute gWLOnoQLZl : Set(Set(long)) := Set{};
}
class OYaKiZbPXJUkf extends XIRjqtl {
   static operation newOYaKiZbPXJUkf() : OYaKiZbPXJUkf
  pre: true
  post: true
  activity:
  ( var self : OYaKiZbPXJUkf ;
    self := createOYaKiZbPXJUkf();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super() );
   attribute dcocCc : AeBMPrUHlgit := null;
}
class sNr {
   static operation newsNr() : sNr
  pre: true
  post: true
  activity:
  ( var self : sNr ;
    self := createsNr();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
}
class STPVrB extends XIRjqtl {
   static operation newSTPVrB() : STPVrB
  pre: true
  post: true
  activity:
  ( var self : STPVrB ;
    self := createSTPVrB();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super() );
}
class wnDhUfhscwv {
   static operation newwnDhUfhscwv() : wnDhUfhscwv
  pre: true
  post: true
  activity:
  ( var self : wnDhUfhscwv ;
    self := createwnDhUfhscwv();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute POc : int := 695;
   attribute txnTT : double := 90.6;
   attribute pWwRa : int := 754;
   attribute rnmteovldhUEz : String := "ynhKFXSfwvtRD";
}
class nBVFMR {
   static operation newnBVFMR() : nBVFMR
  pre: true
  post: true
  activity:
  ( var self : nBVFMR ;
    self := createnBVFMR();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute TzDSaA : String := "jXXpsj";
   attribute rXRbWjxrG : double := 24.77;
   attribute rlGYL : int := 220;
   attribute ITZxFCI : double := 8.92;
   attribute igsXVWscwlL : wnDhUfhscwv := null;
}
class zbSbpdekH {
   static operation newzbSbpdekH() : zbSbpdekH
  pre: true
  post: true
  activity:
  ( var self : zbSbpdekH ;
    self := createzbSbpdekH();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute xiWRc : long := 0;
   attribute tfVQUJCjr : boolean := false;
   attribute iXpOoGvp : String := "crUs";
   attribute xscMIot : double := 27.98;
   attribute sAhOHtUPoA : Set(double) := Set{};
   attribute inkguchqF : double := 99.59;
   attribute FiTEcWzF : int := 579;
}
class fwfQs {
   static operation newfwfQs() : fwfQs
  pre: true
  post: true
  activity:
  ( var self : fwfQs ;
    self := createfwfQs();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute OOlYaxde : int := 588;
   attribute HNLdXIltbnQTV : int := 508;
}
class YlHSQKS {
   static operation newYlHSQKS() : YlHSQKS
  pre: true
  post: true
  activity:
  ( var self : YlHSQKS ;
    self := createYlHSQKS();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute AHSv : int := 802;
   attribute wdDMLBflSH : Set(Set(int)) := Set{};
   attribute cyPJaQevCLOif : String := "rsSAUv";
   attribute VrhOUAtAVXUDj : long := 0;
   attribute jUi : YlHSQKS := null;
}
class SOeZZuBeBEj {
   static operation newSOeZZuBeBEj() : SOeZZuBeBEj
  pre: true
  post: true
  activity:
  ( var self : SOeZZuBeBEj ;
    self := createSOeZZuBeBEj();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute yBYveccgPe : Set(long) := Set{};
   attribute wbkpOJZTLz : Set(int) := Set{};
}
class BsZtuPVb {
   static operation newBsZtuPVb() : BsZtuPVb
  pre: true
  post: true
  activity:
  ( var self : BsZtuPVb ;
    self := createBsZtuPVb();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute fXJOHVhIEt : Set(String) := Set{};
   attribute qMTDj : double := 14.28;
   attribute VSaFKcvIPIuq : int := 241;
   attribute xIgTJWWivl : Set(Set(nBVFMR)) := Set{};
   attribute cckNAKynBS : Sequence(Set(fwfQs)) := Sequence{};
   attribute vNPzNxcntTqO : wnDhUfhscwv := null;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class ajqUXDZU { 
  public ajqUXDZU() { }
}
class iXBACQQPNoq { 
  public iXBACQQPNoq() { }
  boolean EfTYH = true;
  int XdQJyBrZp = 945;
  boolean RJHWEj = true;
  long ZrKMROnw = 0;
  String ZZXn = "DoUn";
  ArrayList<Double> zVGJAiVFsq = new ArrayList<Double>();
  ArrayList<HashSet<String>> tkjZkvCJre = new ArrayList<HashSet<String>>();
  int rBIZEe = 593;
  iXBACQQPNoq TjXQRhZlEP = null;
}

------------------------------------------------------------
OCL File:
---------
 class ajqUXDZU {
   static operation newajqUXDZU() : ajqUXDZU
  pre: true
  post: true
  activity:
  ( var self : ajqUXDZU ;
    self := createajqUXDZU();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
}
class iXBACQQPNoq {
   static operation newiXBACQQPNoq() : iXBACQQPNoq
  pre: true
  post: true
  activity:
  ( var self : iXBACQQPNoq ;
    self := createiXBACQQPNoq();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute EfTYH : boolean := true;
   attribute XdQJyBrZp : int := 945;
   attribute RJHWEj : boolean := true;
   attribute ZrKMROnw : long := 0;
   attribute ZZXn : String := "DoUn";
   attribute zVGJAiVFsq : Sequence(double) := Sequence{};
   attribute tkjZkvCJre : Sequence(Set(String)) := Sequence{};
   attribute rBIZEe : int := 593;
   attribute TjXQRhZlEP : iXBACQQPNoq := null;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class cCAfOoQV { 
  public cCAfOoQV() { }
}
class ByyoMYNL { 
  public ByyoMYNL() { }
  HashSet<String> oWnqfwrNBi = new HashSet<String>();
  HashSet<ArrayList<ArrayList<cCAfOoQV>>> tfCCokGwAY = new HashSet<ArrayList<ArrayList<cCAfOoQV>>>();
  ArrayList<Integer> lOhVfSCRPF = new ArrayList<Integer>();
  HashSet<String> jksAsIsnYi = new HashSet<String>();
  double WdijTdWTxUmDx = 60.39;
  HashSet<HashSet<ArrayList<ArrayList<Integer>>>> fjMookXCAK = new HashSet<HashSet<ArrayList<ArrayList<Integer>>>>();
  HashSet<ArrayList<Long>> tdowFAzbcj = new HashSet<ArrayList<Long>>();
  ArrayList<Boolean> aVuKtgJNVu = new ArrayList<Boolean>();
  cCAfOoQV TlOfnLBDG = null;
}
class YLOx { 
  public YLOx() { }
  double meeyzrAE = 94.91;
  int OKr = 692;
  long iorR = 0;
  ArrayList<Double> tqtaJSykzU = new ArrayList<Double>();
  long xmAPmXmdO = 0;
}

------------------------------------------------------------
OCL File:
---------
 class cCAfOoQV {
   static operation newcCAfOoQV() : cCAfOoQV
  pre: true
  post: true
  activity:
  ( var self : cCAfOoQV ;
    self := createcCAfOoQV();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
}
class ByyoMYNL {
   static operation newByyoMYNL() : ByyoMYNL
  pre: true
  post: true
  activity:
  ( var self : ByyoMYNL ;
    self := createByyoMYNL();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute oWnqfwrNBi : Set(String) := Set{};
   attribute tfCCokGwAY : Set(Sequence(Sequence(cCAfOoQV))) := Set{};
   attribute lOhVfSCRPF : Sequence(int) := Sequence{};
   attribute jksAsIsnYi : Set(String) := Set{};
   attribute WdijTdWTxUmDx : double := 60.39;
   attribute fjMookXCAK : Set(Set(Sequence(Sequence(int)))) := Set{};
   attribute tdowFAzbcj : Set(Sequence(long)) := Set{};
   attribute aVuKtgJNVu : Sequence(Boolean) := Sequence{};
   attribute TlOfnLBDG : cCAfOoQV := null;
}
class YLOx {
   static operation newYLOx() : YLOx
  pre: true
  post: true
  activity:
  ( var self : YLOx ;
    self := createYLOx();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute meeyzrAE : double := 94.91;
   attribute OKr : int := 692;
   attribute iorR : long := 0;
   attribute tqtaJSykzU : Sequence(double) := Sequence{};
   attribute xmAPmXmdO : long := 0;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class SNSorkByY { 
  public SNSorkByY() { }
}
class ZbDZvKBJ { 
  public ZbDZvKBJ() { }
  HashSet<String> bklQLzkWpF = new HashSet<String>();
  ArrayList<SNSorkByY> xyfNaNokSx = new ArrayList<SNSorkByY>();
}
class BvRuAQlao { 
  public BvRuAQlao() { }
  String XcnWj = "ChANGHsua";
  int LcKSpskAF = 53;
  boolean GydoIshIhRJOs = false;
  String osejNZObkbgK = "SmExxHD";
  long xxFePtmaroXY = 0;
  String hwKbrzqmtqxVX = "rmXWGbTuDTkZ";
  HashSet<String> trywqfJchA = new HashSet<String>();
  String GrsCxqCoLX = "pjVBJTmBgPzLv";
  ZbDZvKBJ JmuYEeRk = null;
}
class RgL { 
  public RgL() { }
  HashSet<Integer> pKfFLpXnNt = new HashSet<Integer>();
  String ZlK = "hMvvycqLFVC";
  String lhfJs = "ADroKrKxVP";
  boolean dFrsq = true;
}

------------------------------------------------------------
OCL File:
---------
 class SNSorkByY {
   static operation newSNSorkByY() : SNSorkByY
  pre: true
  post: true
  activity:
  ( var self : SNSorkByY ;
    self := createSNSorkByY();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
}
class ZbDZvKBJ {
   static operation newZbDZvKBJ() : ZbDZvKBJ
  pre: true
  post: true
  activity:
  ( var self : ZbDZvKBJ ;
    self := createZbDZvKBJ();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute bklQLzkWpF : Set(String) := Set{};
   attribute xyfNaNokSx : Sequence(SNSorkByY) := Sequence{};
}
class BvRuAQlao {
   static operation newBvRuAQlao() : BvRuAQlao
  pre: true
  post: true
  activity:
  ( var self : BvRuAQlao ;
    self := createBvRuAQlao();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute XcnWj : String := "ChANGHsua";
   attribute LcKSpskAF : int := 53;
   attribute GydoIshIhRJOs : boolean := false;
   attribute osejNZObkbgK : String := "SmExxHD";
   attribute xxFePtmaroXY : long := 0;
   attribute hwKbrzqmtqxVX : String := "rmXWGbTuDTkZ";
   attribute trywqfJchA : Set(String) := Set{};
   attribute GrsCxqCoLX : String := "pjVBJTmBgPzLv";
   attribute JmuYEeRk : ZbDZvKBJ := null;
}
class RgL {
   static operation newRgL() : RgL
  pre: true
  post: true
  activity:
  ( var self : RgL ;
    self := createRgL();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute pKfFLpXnNt : Set(int) := Set{};
   attribute ZlK : String := "hMvvycqLFVC";
   attribute lhfJs : String := "ADroKrKxVP";
   attribute dFrsq : boolean := true;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class ZClh { 
  int eomD = 117;
  double bjhtUDvNVPp = 78.57;
  double GNNPJMELeij = 61.89;
  String IQFYXIr = "ngjaS";
}
class PUBcMI { 
  public PUBcMI() { }
}
class OLgVbLNsks { 
}
class zOJZ { 
  public zOJZ() { }
  int VtL = 958;
  double rZHczW = 96.3;
  boolean lVoaKgUFLGoGA = false;
  double IesNEJIEar = 68.51;
  OLgVbLNsks vMEsRlZa = null;
  HashSet<PUBcMI> kVvXXHBxHe = new HashSet<PUBcMI>();
  PUBcMI OjUKgfIGFbcQJ = null;
}
class UIaC extends zOJZ {
  public UIaC() { super(); }
  ArrayList<Long> dcJCidYcSQ = new ArrayList<Long>();
  ArrayList<String> oJEhuEVpRF = new ArrayList<String>();
  String txIjMLMC = "jTWvkoW";
  ArrayList<Double> gRHQiilIxM = new ArrayList<Double>();
  double buClOPf = 64.0;
  ZClh qaCVDF = null;
  PUBcMI pCOwkfZV = null;
}

------------------------------------------------------------
OCL File:
---------
 class ZClh {
   attribute eomD : int := 117;
   attribute bjhtUDvNVPp : double := 78.57;
   attribute GNNPJMELeij : double := 61.89;
   attribute IQFYXIr : String := "ngjaS";
}
class PUBcMI {
   static operation newPUBcMI() : PUBcMI
  pre: true
  post: true
  activity:
  ( var self : PUBcMI ;
    self := createPUBcMI();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
}
class OLgVbLNsks { }
class zOJZ {
   static operation newzOJZ() : zOJZ
  pre: true
  post: true
  activity:
  ( var self : zOJZ ;
    self := createzOJZ();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute VtL : int := 958;
   attribute rZHczW : double := 96.3;
   attribute lVoaKgUFLGoGA : boolean := false;
   attribute IesNEJIEar : double := 68.51;
   attribute vMEsRlZa : OLgVbLNsks := null;
   attribute kVvXXHBxHe : Set(PUBcMI) := Set{};
   attribute OjUKgfIGFbcQJ : PUBcMI := null;
}
class UIaC extends zOJZ {
   static operation newUIaC() : UIaC
  pre: true
  post: true
  activity:
  ( var self : UIaC ;
    self := createUIaC();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super() );
   attribute dcJCidYcSQ : Sequence(long) := Sequence{};
   attribute oJEhuEVpRF : Sequence(String) := Sequence{};
   attribute txIjMLMC : String := "jTWvkoW";
   attribute gRHQiilIxM : Sequence(double) := Sequence{};
   attribute buClOPf : double := 64.0;
   attribute qaCVDF : ZClh := null;
   attribute pCOwkfZV : PUBcMI := null;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class JyvUjciSdNFbf { 
  public JyvUjciSdNFbf() { }
  double xCtFFHUq = 41.41;
  boolean laGTTMgqN = true;
  boolean AgIYkBOwiTGNi = false;
  long cFi = 0;
  String OxjZSgkeXnTW = "oSlObhqzjTxhX";
  String Cgv = "RMIukvzfK";
  long HBws = 0;
  JyvUjciSdNFbf IveorsKWK = null;
}
class yiOU { 
  public yiOU() { }
  HashSet<Double> kcRgHJNIJL = new HashSet<Double>();
  HashSet<String> qvsfOvtJrZ = new HashSet<String>();
  long QoSKyX = 0;
  boolean ajPfgZLBwGN = false;
  boolean ZgyGPvk = false;
  yiOU AIQLyWZhEsNAh = null;
}
class RztkYtyPHND { 
  public RztkYtyPHND() { }
  String xmMKDgcKktGx = "JtmI";
}
class vhLUzRYDvU { 
  public vhLUzRYDvU() { }
  boolean sIS = false;
  boolean gMoXENepVvs = true;
  String ZDkLz = "XHyqEuecebSi";
  HashSet<Long> mBzntLQlbA = new HashSet<Long>();
  String urTIUghAaLe = "KDjOIJRqcj";
  ArrayList<ArrayList<Double>> tIsKDqVYwP = new ArrayList<ArrayList<Double>>();
  double fzZaYZhajQnAS = 32.67;
  vhLUzRYDvU WYf = null;
  yiOU AWhrV = null;
}
class CsBTHADJpccFx { 
  public CsBTHADJpccFx() { }
  long NrNbtDGVsBh = 0;
  int dqABNx = 189;
  long hrdTxpPqW = 0;
  long VvXxBx = 0;
  ArrayList<Double> dyezAsFIRz = new ArrayList<Double>();
  int NNlkJ = 959;
  long cRDN = 0;
  HashSet<yiOU> djXEntMDIL = new HashSet<yiOU>();
  HashSet<yiOU> xdloRjoNpb = new HashSet<yiOU>();
}
class PgkuV { 
  public PgkuV() { }
  String rimLk = "AdNwVZMorkWf";
  HashSet<Long> gnzQrZYAWN = new HashSet<Long>();
  ArrayList<String> zOIChCWvYP = new ArrayList<String>();
  ArrayList<Integer> dJenZrviiH = new ArrayList<Integer>();
  double arvSccIPqI = 11.4;
  RztkYtyPHND jmvYz = null;
  ArrayList<CsBTHADJpccFx> mPqSipzvGF = new ArrayList<CsBTHADJpccFx>();
}

------------------------------------------------------------
OCL File:
---------
 class JyvUjciSdNFbf {
   static operation newJyvUjciSdNFbf() : JyvUjciSdNFbf
  pre: true
  post: true
  activity:
  ( var self : JyvUjciSdNFbf ;
    self := createJyvUjciSdNFbf();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute xCtFFHUq : double := 41.41;
   attribute laGTTMgqN : boolean := true;
   attribute AgIYkBOwiTGNi : boolean := false;
   attribute cFi : long := 0;
   attribute OxjZSgkeXnTW : String := "oSlObhqzjTxhX";
   attribute Cgv : String := "RMIukvzfK";
   attribute HBws : long := 0;
   attribute IveorsKWK : JyvUjciSdNFbf := null;
}
class yiOU {
   static operation newyiOU() : yiOU
  pre: true
  post: true
  activity:
  ( var self : yiOU ;
    self := createyiOU();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute kcRgHJNIJL : Set(double) := Set{};
   attribute qvsfOvtJrZ : Set(String) := Set{};
   attribute QoSKyX : long := 0;
   attribute ajPfgZLBwGN : boolean := false;
   attribute ZgyGPvk : boolean := false;
   attribute AIQLyWZhEsNAh : yiOU := null;
}
class RztkYtyPHND {
   static operation newRztkYtyPHND() : RztkYtyPHND
  pre: true
  post: true
  activity:
  ( var self : RztkYtyPHND ;
    self := createRztkYtyPHND();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute xmMKDgcKktGx : String := "JtmI";
}
class vhLUzRYDvU {
   static operation newvhLUzRYDvU() : vhLUzRYDvU
  pre: true
  post: true
  activity:
  ( var self : vhLUzRYDvU ;
    self := createvhLUzRYDvU();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute sIS : boolean := false;
   attribute gMoXENepVvs : boolean := true;
   attribute ZDkLz : String := "XHyqEuecebSi";
   attribute mBzntLQlbA : Set(long) := Set{};
   attribute urTIUghAaLe : String := "KDjOIJRqcj";
   attribute tIsKDqVYwP : Sequence(Sequence(double)) := Sequence{};
   attribute fzZaYZhajQnAS : double := 32.67;
   attribute WYf : vhLUzRYDvU := null;
   attribute AWhrV : yiOU := null;
}
class CsBTHADJpccFx {
   static operation newCsBTHADJpccFx() : CsBTHADJpccFx
  pre: true
  post: true
  activity:
  ( var self : CsBTHADJpccFx ;
    self := createCsBTHADJpccFx();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute NrNbtDGVsBh : long := 0;
   attribute dqABNx : int := 189;
   attribute hrdTxpPqW : long := 0;
   attribute VvXxBx : long := 0;
   attribute dyezAsFIRz : Sequence(double) := Sequence{};
   attribute NNlkJ : int := 959;
   attribute cRDN : long := 0;
   attribute djXEntMDIL : Set(yiOU) := Set{};
   attribute xdloRjoNpb : Set(yiOU) := Set{};
}
class PgkuV {
   static operation newPgkuV() : PgkuV
  pre: true
  post: true
  activity:
  ( var self : PgkuV ;
    self := createPgkuV();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute rimLk : String := "AdNwVZMorkWf";
   attribute gnzQrZYAWN : Set(long) := Set{};
   attribute zOIChCWvYP : Sequence(String) := Sequence{};
   attribute dJenZrviiH : Sequence(int) := Sequence{};
   attribute arvSccIPqI : double := 11.4;
   attribute jmvYz : RztkYtyPHND := null;
   attribute mPqSipzvGF : Sequence(CsBTHADJpccFx) := Sequence{};
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class QVCoXBZllgO { 
  public QVCoXBZllgO() { }
  HashSet<ArrayList<Integer>> eqIjMdoapf = new HashSet<ArrayList<Integer>>();
  boolean yMYnhXWusRf = false;
  ArrayList<HashSet<Integer>> iBsrVVFNBg = new ArrayList<HashSet<Integer>>();
  double vKEMDKsee = 67.49;
  String EMaZGtdmEqV = "lnlgTE";
}
class TWLmQ { 
  public TWLmQ() { }
  HashSet<ArrayList<Long>> cCpIrZKADY = new HashSet<ArrayList<Long>>();
  HashSet<HashSet<TWLmQ>> aJKzvKUSXo = new HashSet<HashSet<TWLmQ>>();
  String iUwSnEnpkVJOJ = "ixosvkRkaX";
  int bli = 963;
  String MURtpP = "YnjGlSHuB";
  TWLmQ murwW = null;
  QVCoXBZllgO lzAuaqlrGr = null;
}
class ppknCoxgBuuxs { 
  public ppknCoxgBuuxs() { }
  long iCgWfdraRUDD = 0;
  String ZIPeDZBeDqJh = "SdEWAsQ";
  int Inxq = 57;
  long qUbsFnJSp = 0;
  String tEWaknpypqG = "LeYDHGjaBKLMs";
  double AqwCWCFo = 74.63;
  ArrayList<Long> hZoXVglRKX = new ArrayList<Long>();
  int dwz = 190;
}
class gdwvwZPul { 
  public gdwvwZPul() { }
}
class KWxiYxjIERcgu { 
  public KWxiYxjIERcgu() { }
  boolean JARb = false;
  int Gqyb = 26;
  int nMcvUxeQmyII = 281;
  double tMgHXvqKe = 85.31;
  int QUJgW = 747;
  int RnjCcSJ = 743;
  ArrayList<Double> kLbcIJqPDc = new ArrayList<Double>();
  KWxiYxjIERcgu WMEdWhXFkLMZw = null;
  QVCoXBZllgO lVzFtnYAEi = null;
}
class NeZmqWWcGIlfn { 
  public NeZmqWWcGIlfn() { }
  double BftIb = 81.6;
  boolean IVCBpFOXXRZ = false;
  boolean UsnYhPkiFt = false;
  ArrayList<Double> yRpxMVoBYs = new ArrayList<Double>();
  HashSet<NeZmqWWcGIlfn> tgZZyNJVwF = new HashSet<NeZmqWWcGIlfn>();
}
class AsvOMMs { 
  public AsvOMMs() { }
  long HjM = 0;
  ArrayList<ArrayList<Double>> hgwlNoCqbC = new ArrayList<ArrayList<Double>>();
  double gts = 95.26;
  long jbBClCXLdckFX = 0;
  int Nbj = 77;
  boolean DbrsfLDJxSHQ = true;
  long RtEWY = 0;
  boolean ZyCDa = false;
  long VtVygEqkWPNh = 0;
}

------------------------------------------------------------
OCL File:
---------
 class QVCoXBZllgO {
   static operation newQVCoXBZllgO() : QVCoXBZllgO
  pre: true
  post: true
  activity:
  ( var self : QVCoXBZllgO ;
    self := createQVCoXBZllgO();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute eqIjMdoapf : Set(Sequence(int)) := Set{};
   attribute yMYnhXWusRf : boolean := false;
   attribute iBsrVVFNBg : Sequence(Set(int)) := Sequence{};
   attribute vKEMDKsee : double := 67.49;
   attribute EMaZGtdmEqV : String := "lnlgTE";
}
class TWLmQ {
   static operation newTWLmQ() : TWLmQ
  pre: true
  post: true
  activity:
  ( var self : TWLmQ ;
    self := createTWLmQ();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute cCpIrZKADY : Set(Sequence(long)) := Set{};
   attribute aJKzvKUSXo : Set(Set(TWLmQ)) := Set{};
   attribute iUwSnEnpkVJOJ : String := "ixosvkRkaX";
   attribute bli : int := 963;
   attribute MURtpP : String := "YnjGlSHuB";
   attribute murwW : TWLmQ := null;
   attribute lzAuaqlrGr : QVCoXBZllgO := null;
}
class ppknCoxgBuuxs {
   static operation newppknCoxgBuuxs() : ppknCoxgBuuxs
  pre: true
  post: true
  activity:
  ( var self : ppknCoxgBuuxs ;
    self := createppknCoxgBuuxs();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute iCgWfdraRUDD : long := 0;
   attribute ZIPeDZBeDqJh : String := "SdEWAsQ";
   attribute Inxq : int := 57;
   attribute qUbsFnJSp : long := 0;
   attribute tEWaknpypqG : String := "LeYDHGjaBKLMs";
   attribute AqwCWCFo : double := 74.63;
   attribute hZoXVglRKX : Sequence(long) := Sequence{};
   attribute dwz : int := 190;
}
class gdwvwZPul {
   static operation newgdwvwZPul() : gdwvwZPul
  pre: true
  post: true
  activity:
  ( var self : gdwvwZPul ;
    self := creategdwvwZPul();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
}
class KWxiYxjIERcgu {
   static operation newKWxiYxjIERcgu() : KWxiYxjIERcgu
  pre: true
  post: true
  activity:
  ( var self : KWxiYxjIERcgu ;
    self := createKWxiYxjIERcgu();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute JARb : boolean := false;
   attribute Gqyb : int := 26;
   attribute nMcvUxeQmyII : int := 281;
   attribute tMgHXvqKe : double := 85.31;
   attribute QUJgW : int := 747;
   attribute RnjCcSJ : int := 743;
   attribute kLbcIJqPDc : Sequence(double) := Sequence{};
   attribute WMEdWhXFkLMZw : KWxiYxjIERcgu := null;
   attribute lVzFtnYAEi : QVCoXBZllgO := null;
}
class NeZmqWWcGIlfn {
   static operation newNeZmqWWcGIlfn() : NeZmqWWcGIlfn
  pre: true
  post: true
  activity:
  ( var self : NeZmqWWcGIlfn ;
    self := createNeZmqWWcGIlfn();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute BftIb : double := 81.6;
   attribute IVCBpFOXXRZ : boolean := false;
   attribute UsnYhPkiFt : boolean := false;
   attribute yRpxMVoBYs : Sequence(double) := Sequence{};
   attribute tgZZyNJVwF : Set(NeZmqWWcGIlfn) := Set{};
}
class AsvOMMs {
   static operation newAsvOMMs() : AsvOMMs
  pre: true
  post: true
  activity:
  ( var self : AsvOMMs ;
    self := createAsvOMMs();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute HjM : long := 0;
   attribute hgwlNoCqbC : Sequence(Sequence(double)) := Sequence{};
   attribute gts : double := 95.26;
   attribute jbBClCXLdckFX : long := 0;
   attribute Nbj : int := 77;
   attribute DbrsfLDJxSHQ : boolean := true;
   attribute RtEWY : long := 0;
   attribute ZyCDa : boolean := false;
   attribute VtVygEqkWPNh : long := 0;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class HeuitgemcDgl { 
  public HeuitgemcDgl() { }
  ArrayList<HashSet<HeuitgemcDgl>> oPmiPhKkMV = new ArrayList<HashSet<HeuitgemcDgl>>();
  double kwbGv = 31.36;
  long pClcCMHj = 0;
  ArrayList<Boolean> deABTdDVGX = new ArrayList<Boolean>();
  String eLHE = "geWFZYvKgix";
  long CXinjFHiN = 0;
  HeuitgemcDgl ptvUchDswvU = null;
}
class nss { 
  public nss() { }
  boolean EgUH = false;
  double GqoFgpos = 17.7;
  int snAcnt = 929;
  ArrayList<HashSet<Double>> egNwXfPMOf = new ArrayList<HashSet<Double>>();
  double PDEXsFRDG = 29.76;
}
class GIgntpRzK { 
  public GIgntpRzK() { }
  long YYBfjlThsdHh = 0;
  int nAwSX = 173;
  double XxaHOuj = 48.53;
  String HqZQlYxk = "UmnrH";
  boolean QgGHxZWOT = false;
  long Wabrg = 0;
  HeuitgemcDgl fNrTSc = null;
}
class FgHvPTvgMztF { 
  public FgHvPTvgMztF() { }
  String JqafqSzXMuUsq = "eQJsoJUNGWn";
  ArrayList<Integer> piOLdDqHXv = new ArrayList<Integer>();
  long wkjRvV = 0;
}
class eIelM { 
  public eIelM() { }
  double JbQ = 25.21;
  int pUHMWORsVy = 153;
}
class ffmSgxH { 
  public ffmSgxH() { }
  HashSet<Long> vQjKXJRLTY = new HashSet<Long>();
  int nyfyHYrRSd = 648;
  HashSet<Integer> sVEwexOQEy = new HashSet<Integer>();
}
class VuKxrPvc extends nss {
  public VuKxrPvc() { super(); }
  ArrayList<Double> tOxqySaHVM = new ArrayList<Double>();
  int GOxQN = 250;
  boolean MgpBe = true;
  HashSet<Boolean> sutKlLSFjy = new HashSet<Boolean>();
  int bewSorfqJ = 546;
  String UUeuu = "buun";
  VuKxrPvc ZLLumT = null;
  eIelM ohPpkbzawYIP = null;
}
class UhPcgNl { 
  public UhPcgNl() { }
  ArrayList<HashSet<HashSet<Double>>> tvSJePDBmM = new ArrayList<HashSet<HashSet<Double>>>();
  boolean YCFvE = false;
  boolean gAAKrYPZq = false;
  String JSSUhXwvNXbPP = "IwKlowjfYfrVP";
  String RKbaUa = "jncoVWxq";
  HashSet<ArrayList<Long>> uDvCustWpS = new HashSet<ArrayList<Long>>();
  ffmSgxH VKv = null;
}

------------------------------------------------------------
OCL File:
---------
 class HeuitgemcDgl {
   static operation newHeuitgemcDgl() : HeuitgemcDgl
  pre: true
  post: true
  activity:
  ( var self : HeuitgemcDgl ;
    self := createHeuitgemcDgl();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute oPmiPhKkMV : Sequence(Set(HeuitgemcDgl)) := Sequence{};
   attribute kwbGv : double := 31.36;
   attribute pClcCMHj : long := 0;
   attribute deABTdDVGX : Sequence(Boolean) := Sequence{};
   attribute eLHE : String := "geWFZYvKgix";
   attribute CXinjFHiN : long := 0;
   attribute ptvUchDswvU : HeuitgemcDgl := null;
}
class nss {
   static operation newnss() : nss
  pre: true
  post: true
  activity:
  ( var self : nss ;
    self := createnss();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute EgUH : boolean := false;
   attribute GqoFgpos : double := 17.7;
   attribute snAcnt : int := 929;
   attribute egNwXfPMOf : Sequence(Set(double)) := Sequence{};
   attribute PDEXsFRDG : double := 29.76;
}
class GIgntpRzK {
   static operation newGIgntpRzK() : GIgntpRzK
  pre: true
  post: true
  activity:
  ( var self : GIgntpRzK ;
    self := createGIgntpRzK();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute YYBfjlThsdHh : long := 0;
   attribute nAwSX : int := 173;
   attribute XxaHOuj : double := 48.53;
   attribute HqZQlYxk : String := "UmnrH";
   attribute QgGHxZWOT : boolean := false;
   attribute Wabrg : long := 0;
   attribute fNrTSc : HeuitgemcDgl := null;
}
class FgHvPTvgMztF {
   static operation newFgHvPTvgMztF() : FgHvPTvgMztF
  pre: true
  post: true
  activity:
  ( var self : FgHvPTvgMztF ;
    self := createFgHvPTvgMztF();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute JqafqSzXMuUsq : String := "eQJsoJUNGWn";
   attribute piOLdDqHXv : Sequence(int) := Sequence{};
   attribute wkjRvV : long := 0;
}
class eIelM {
   static operation neweIelM() : eIelM
  pre: true
  post: true
  activity:
  ( var self : eIelM ;
    self := createeIelM();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute JbQ : double := 25.21;
   attribute pUHMWORsVy : int := 153;
}
class ffmSgxH {
   static operation newffmSgxH() : ffmSgxH
  pre: true
  post: true
  activity:
  ( var self : ffmSgxH ;
    self := createffmSgxH();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute vQjKXJRLTY : Set(long) := Set{};
   attribute nyfyHYrRSd : int := 648;
   attribute sVEwexOQEy : Set(int) := Set{};
}
class VuKxrPvc extends nss {
   static operation newVuKxrPvc() : VuKxrPvc
  pre: true
  post: true
  activity:
  ( var self : VuKxrPvc ;
    self := createVuKxrPvc();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super() );
   attribute tOxqySaHVM : Sequence(double) := Sequence{};
   attribute GOxQN : int := 250;
   attribute MgpBe : boolean := true;
   attribute sutKlLSFjy : Set(Boolean) := Set{};
   attribute bewSorfqJ : int := 546;
   attribute UUeuu : String := "buun";
   attribute ZLLumT : VuKxrPvc := null;
   attribute ohPpkbzawYIP : eIelM := null;
}
class UhPcgNl {
   static operation newUhPcgNl() : UhPcgNl
  pre: true
  post: true
  activity:
  ( var self : UhPcgNl ;
    self := createUhPcgNl();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute tvSJePDBmM : Sequence(Set(Set(double))) := Sequence{};
   attribute YCFvE : boolean := false;
   attribute gAAKrYPZq : boolean := false;
   attribute JSSUhXwvNXbPP : String := "IwKlowjfYfrVP";
   attribute RKbaUa : String := "jncoVWxq";
   attribute uDvCustWpS : Set(Sequence(long)) := Set{};
   attribute VKv : ffmSgxH := null;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class FbNwS { 
  public FbNwS() { }
  String MJB = "vcnxXk";
  int syKuiJ = 966;
  String fXgXs = "glAPmwLdr";
  int KnVzGxgrYNoSh = 595;
  FbNwS sJEX = null;
}
class kMju { 
  public kMju() { }
  boolean KbM = true;
  int ftEyTeFFSGd = 14;
  HashSet<Long> ueEYqgewaD = new HashSet<Long>();
  ArrayList<Integer> vmGiODwTfi = new ArrayList<Integer>();
  int GpwZJETor = 616;
  ArrayList<String> uxTZwusYrk = new ArrayList<String>();
  kMju ypBw = null;
}
class NhKHirqGmUuYH { 
  public NhKHirqGmUuYH() { }
}
class QBVymbAGIQzVX { 
  public QBVymbAGIQzVX() { }
  int RSuq = 357;
  double HOZbxZFantntn = 39.44;
  double HyVODr = 81.01;
  int wjN = 992;
  ArrayList<Boolean> tigsHwSjbE = new ArrayList<Boolean>();
  boolean yltF = false;
  ArrayList<QBVymbAGIQzVX> eLHKVKZxPt = new ArrayList<QBVymbAGIQzVX>();
  HashSet<QBVymbAGIQzVX> wdZdgMMFpN = new HashSet<QBVymbAGIQzVX>();
  QBVymbAGIQzVX dokQcwaDelRKG = null;
}
class CxIffcTh { 
  public CxIffcTh() { }
  ArrayList<Boolean> dBcxKGhlHO = new ArrayList<Boolean>();
  String AEoZtCdzPm = "lmyD";
  double CIn = 5.44;
  HashSet<NhKHirqGmUuYH> wEevSoDaRG = new HashSet<NhKHirqGmUuYH>();
}
class IOlJtVI extends CxIffcTh {
  public IOlJtVI() { super(); }
  long BdWPxdcjVuwO = 0;
  double vOqDdPxcg = 72.13;
  long pTlAT = 0;
  String oRPAv = "hhoYNiICH";
  String edKcUOefJfjE = "ezq";
}
class wJzCyPD { 
  public wJzCyPD() { }
  HashSet<Boolean> wQkRWjIGYN = new HashSet<Boolean>();
  boolean czynXV = true;
  int yhfqRAAWnfQH = 172;
  int eIU = 345;
  wJzCyPD orlNZo = null;
}
class JDLehnXz { 
  public JDLehnXz() { }
  double WKYluacfoii = 57.92;
  String KxhVE = "qBElYn";
  String xZBdzTkyQY = "PBaFcQD";
  boolean qER = false;
  boolean njTfgOZPKU = true;
  HashSet<String> mSwHXvRkOc = new HashSet<String>();
  HashSet<String> yYNZOiOwAV = new HashSet<String>();
  int JUijlKzIw = 287;
}
class CUeMnzddQsY { 
  public CUeMnzddQsY() { }
  String lSlY = "nkZrdqRXsXZIe";
  boolean oaR = true;
  long iFR = 0;
  String SKyIIMlnAsY = "mtR";
  long wywQ = 0;
  JDLehnXz QbutrqtVLHwUZ = null;
}

------------------------------------------------------------
OCL File:
---------
 class FbNwS {
   static operation newFbNwS() : FbNwS
  pre: true
  post: true
  activity:
  ( var self : FbNwS ;
    self := createFbNwS();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute MJB : String := "vcnxXk";
   attribute syKuiJ : int := 966;
   attribute fXgXs : String := "glAPmwLdr";
   attribute KnVzGxgrYNoSh : int := 595;
   attribute sJEX : FbNwS := null;
}
class kMju {
   static operation newkMju() : kMju
  pre: true
  post: true
  activity:
  ( var self : kMju ;
    self := createkMju();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute KbM : boolean := true;
   attribute ftEyTeFFSGd : int := 14;
   attribute ueEYqgewaD : Set(long) := Set{};
   attribute vmGiODwTfi : Sequence(int) := Sequence{};
   attribute GpwZJETor : int := 616;
   attribute uxTZwusYrk : Sequence(String) := Sequence{};
   attribute ypBw : kMju := null;
}
class NhKHirqGmUuYH {
   static operation newNhKHirqGmUuYH() : NhKHirqGmUuYH
  pre: true
  post: true
  activity:
  ( var self : NhKHirqGmUuYH ;
    self := createNhKHirqGmUuYH();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
}
class QBVymbAGIQzVX {
   static operation newQBVymbAGIQzVX() : QBVymbAGIQzVX
  pre: true
  post: true
  activity:
  ( var self : QBVymbAGIQzVX ;
    self := createQBVymbAGIQzVX();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute RSuq : int := 357;
   attribute HOZbxZFantntn : double := 39.44;
   attribute HyVODr : double := 81.01;
   attribute wjN : int := 992;
   attribute tigsHwSjbE : Sequence(Boolean) := Sequence{};
   attribute yltF : boolean := false;
   attribute eLHKVKZxPt : Sequence(QBVymbAGIQzVX) := Sequence{};
   attribute wdZdgMMFpN : Set(QBVymbAGIQzVX) := Set{};
   attribute dokQcwaDelRKG : QBVymbAGIQzVX := null;
}
class CxIffcTh {
   static operation newCxIffcTh() : CxIffcTh
  pre: true
  post: true
  activity:
  ( var self : CxIffcTh ;
    self := createCxIffcTh();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute dBcxKGhlHO : Sequence(Boolean) := Sequence{};
   attribute AEoZtCdzPm : String := "lmyD";
   attribute CIn : double := 5.44;
   attribute wEevSoDaRG : Set(NhKHirqGmUuYH) := Set{};
}
class IOlJtVI extends CxIffcTh {
   static operation newIOlJtVI() : IOlJtVI
  pre: true
  post: true
  activity:
  ( var self : IOlJtVI ;
    self := createIOlJtVI();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     execute super() );
   attribute BdWPxdcjVuwO : long := 0;
   attribute vOqDdPxcg : double := 72.13;
   attribute pTlAT : long := 0;
   attribute oRPAv : String := "hhoYNiICH";
   attribute edKcUOefJfjE : String := "ezq";
}
class wJzCyPD {
   static operation newwJzCyPD() : wJzCyPD
  pre: true
  post: true
  activity:
  ( var self : wJzCyPD ;
    self := createwJzCyPD();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute wQkRWjIGYN : Set(Boolean) := Set{};
   attribute czynXV : boolean := true;
   attribute yhfqRAAWnfQH : int := 172;
   attribute eIU : int := 345;
   attribute orlNZo : wJzCyPD := null;
}
class JDLehnXz {
   static operation newJDLehnXz() : JDLehnXz
  pre: true
  post: true
  activity:
  ( var self : JDLehnXz ;
    self := createJDLehnXz();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute WKYluacfoii : double := 57.92;
   attribute KxhVE : String := "qBElYn";
   attribute xZBdzTkyQY : String := "PBaFcQD";
   attribute qER : boolean := false;
   attribute njTfgOZPKU : boolean := true;
   attribute mSwHXvRkOc : Set(String) := Set{};
   attribute yYNZOiOwAV : Set(String) := Set{};
   attribute JUijlKzIw : int := 287;
}
class CUeMnzddQsY {
   static operation newCUeMnzddQsY() : CUeMnzddQsY
  pre: true
  post: true
  activity:
  ( var self : CUeMnzddQsY ;
    self := createCUeMnzddQsY();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   attribute lSlY : String := "nkZrdqRXsXZIe";
   attribute oaR : boolean := true;
   attribute iFR : long := 0;
   attribute SKyIIMlnAsY : String := "mtR";
   attribute wywQ : long := 0;
   attribute QbutrqtVLHwUZ : JDLehnXz := null;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class xxx {
  int MSMN() {
    int xx = 0;
    int yy=0;
    double rate = 0.05;
    double ii = 100.0;
    while (ii*Math.pow(3.4, xx) < 5*ii) 
    { 
       xx=xx+1;
       yy=yy+4; 
    } 
    return xx; 
 }
}
------------------------------------------------------------
OCL File:
---------
class xxx {
   operation MSMN() : int
  pre: true
  post: true
  activity: (     var xx : int ; xx := 0 ;
     var yy : int ; yy := 0 ;
    var rate : double ; rate := 0.05 ;
    var ii : double ; ii := 100.0 ;
    while (ii * 3.4->pow(xx) < 5 * ii) do (     xx := xx + 1 ; 
     yy := yy + 4 ) ; 
    return xx 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class gggggg {
 public void bb() { 
  Number uuu = new Number(); 
  byte rs = uuu.byteValue(); 
  throw new NoClassDefFoundError("error error"); 
 }
}

------------------------------------------------------------
OCL File:
---------
class gggggg {
   operation bb() : void
  pre: true
  post: true
  activity: (     var uuu : double ; uuu := 0.0 ;
     var rs : int ; rs := uuu->oclAsType(int) ;
     error AccessingException("error error") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Calculation {
    public int computeSum() {
        int[] numbers = { 4, 6, 8, 10, 12, 14, 16, 18 };
        int sum = 0;
        int index = 0;
        while (index < numbers.length) {
            sum += numbers[index++];
        }
        return sum;
    }
    public int findMax() {
        int[] values = { 21, 33, 19, 45, 57, 23 };
        int max = values[0];
        for (int num : values) {
            if (num > max) {
                max = num;
            }
        }
        return max;
    }
    public static void main(String[] args) {
        Calculation calc = new Calculation();
        int sumResult = calc.computeSum();
        System.out.println("Total sum is: " + sumResult);
        int maxResult = calc.findMax();
        System.out.println("Maximum value is: " + maxResult);
    }
}

------------------------------------------------------------
OCL File:
---------
class Calculation {
   operation computeSum() : int
  pre: true
  post: true
  activity: (     var numbers : Sequence(int) ; numbers := Sequence{4,6,8,10,12,14,16,18} ;
     var sum : int ; sum := 0 ;
    var index : int ; index := 0 ;
    while (index < numbers->size()) do (      sum := sum + numbers[index+1]  ; index := index + 1 ) ; 
    return sum 
 );
   operation findMax() : int
  pre: true
  post: true
  activity: (     var values : Sequence(int) ; values := Sequence{21,33,19,45,57,23} ;
     var max : int ; max := values[0+1] ;
     for (num : values) do ( (     if (num > max) then (     max := num ) else skip )  ) ; 
     return max );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var calc : Calculation ; calc := Calculation.newCalculation() ;
     var sumResult : int ; sumResult := calc.computeSum() ;
    OclFile["System.out"].println("Total sum is: " + sumResult) ; 
    var maxResult : int ; maxResult := calc.findMax() ;
    OclFile["System.out"].println("Maximum value is: " + maxResult) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
interface TimeProvider {
    long currentTime();
}
interface NameProvider {
    String fetchName();
}
interface AgeProvider {
    int fetchAge();
}
abstract class Base {
    protected String identifier;
}
class Derived extends Base implements TimeProvider, NameProvider {
    public long currentTime() {
        return System.currentTimeMillis();
    }
    public String fetchName() {
        return identifier;
    }
}
class ExtraDerived extends Base implements AgeProvider {
    protected int age;
    public int fetchAge() {
        return age;
    }
}
class AnotherDerived extends Base implements NameProvider, AgeProvider {
    protected int years;
    public String fetchName() {
        return identifier;
    }
    public int fetchAge() {
        return years;
    }
}
public class MainProgram {
    public static void main(String[] args) {
        Derived derivedInstance = new Derived();
        derivedInstance.identifier = "Alice";
        System.out.printf("%d  %s\n", derivedInstance.currentTime(), derivedInstance.fetchName());
        ExtraDerived extraInstance = new ExtraDerived();
        extraInstance.identifier = "Bob";
        extraInstance.age = 35;
        System.out.printf("Name: %s, Age: %d\n", extraInstance.identifier, extraInstance.fetchAge());
        AnotherDerived anotherInstance = new AnotherDerived();
        anotherInstance.identifier = "Charlie";
        anotherInstance.years = 28;
        System.out.printf("Name: %s, Age: %d\n", anotherInstance.fetchName(), anotherInstance.fetchAge());
    }
}

------------------------------------------------------------
OCL File:
---------
interface TimeProvider {
   operation currentTime() : long
  pre: true
  post: true;
}
 interface NameProvider {
   operation fetchName() : String
  pre: true
  post: true;
}
interface AgeProvider {
   operation fetchAge() : int
  pre: true
  post: true;
}
class Base {
     attribute identifier : String;
}
class Derived extends Base, TimeProvider, NameProvider {
   operation currentTime() : long
  pre: true
  post: true
  activity: (     return OclDate.getSystemTime() );
   operation fetchName() : String
  pre: true
  post: true
  activity: (     return identifier );
}
class ExtraDerived extends Base, AgeProvider {
     attribute age : int;
   operation fetchAge() : int
  pre: true
  post: true
  activity: (     return age );
}
class AnotherDerived extends Base, NameProvider, AgeProvider {
     attribute years : int;
   operation fetchName() : String
  pre: true
  post: true
  activity: (     return identifier );
   operation fetchAge() : int
  pre: true
  post: true
  activity: (     return years );
}
class MainProgram {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var derivedInstance : Derived ; derivedInstance := Derived.newDerived() ;
     derivedInstance.identifier := "Alice" ; 
    OclFile["System.out"].printf("%d  %s\n", derivedInstance.currentTime(), derivedInstance.fetchName()) ; 
    var extraInstance : ExtraDerived ; extraInstance := ExtraDerived.newExtraDerived() ;
    extraInstance.identifier := "Bob" ; 
    extraInstance.age := 35 ; 
    OclFile["System.out"].printf("Name: %s, Age: %d\n", extraInstance.identifier, extraInstance.fetchAge()) ; 
    var anotherInstance : AnotherDerived ; anotherInstance := AnotherDerived.newAnotherDerived() ;
    anotherInstance.identifier := "Charlie" ; 
    anotherInstance.years := 28 ; 
    OclFile["System.out"].printf("Name: %s, Age: %d\n", anotherInstance.fetchName(), anotherInstance.fetchAge()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class DocumentProcessor {
    public void processDocument() {
        File document = new File("document.txt");
        PrintStream outputStream = new PrintStream(new FileWriter(document));
        outputStream.print(false);
        outputStream.println(45.123);
        outputStream.println(90);
        char[] characters = {'x', 'y', 'z'};
        outputStream.println(characters);
        byte[] bytes = { 100, 101, 102, 103 };
        outputStream.write(bytes, 1, 3);
        String extraData = "example";
        int additionalNumber = 42;
    }
}

------------------------------------------------------------
OCL File:
---------
class DocumentProcessor {
   operation processDocument() : void
  pre: true
  post: true
  activity: (     var document : OclFile ; document := OclFile("document.txt") ;
     var outputStream : OclFile ; outputStream := OclFile.newOclFile_Write(OclFile.newOclFile_Write(document)) ;
    skip ; 
    skip ; 
    skip ; 
    var characters : Sequence(String) ; characters := Sequence{'x','y','z'} ;
    skip ; 
    var bytes : Sequence(int) ; bytes := Sequence{100,101,102,103} ;
    skip ; 
    var extraData : String ; extraData := "example" ;
    var additionalNumber : int ; additionalNumber := 42 ;
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Application {
    public static void main(String[] input) {
        PriorityQueue<String> queue = new PriorityQueue<String>();
        queue.offer("7");
        queue.offer("1");
        queue.offer("6");
        queue.offer("4");
        System.out.println(queue);
        System.out.println(queue.peek());
        while (queue.size() > 0) {
            String element = queue.poll();
            System.out.println(element);
        }
        String additionalString = "extra";
        int additionalValue = 25;
    }
}

------------------------------------------------------------
OCL File:
---------
class Application {
  static   operation main( input : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var queue : Sequence(String) ; queue := Sequence{} ;
     queue := queue->including("7") ; 
    queue := queue->including("1") ; 
    queue := queue->including("6") ; 
    queue := queue->including("4") ; 
    OclFile["System.out"].println(queue) ; 
    OclFile["System.out"].println(queue->min()) ; 
    while (queue->size() > 0) do (     var element : String ; element := queue->min() ;
     OclFile["System.out"].println(element) ) ; 
    var additionalString : String ; additionalString := "extra" ;
    var additionalValue : int ; additionalValue := 25 ;
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class DataFileHandler {
    public void writeData() {
        RandomAccessFile file = new RandomAccessFile("data.txt", "rw");
        file.writeBytes("Alpha line\n");
        file.writeBytes("Beta line\n");
        file.writeBytes("Gamma line\n");
        file.writeBytes("SSS line\n");
        file.close();
        String additionalText = "sample";
        int additionalNumber = 10;
    }
}

------------------------------------------------------------
OCL File:
---------
class DataFileHandler {
   operation writeData() : void
  pre: true
  post: true
  activity: (     var file : OclFile ; file := OclFile.newOclFile("data.txt", "rw") ;
     skip ; 
    skip ; 
    skip ; 
    skip ; 
    skip ; 
    var additionalText : String ; additionalText := "sample" ;
    var additionalNumber : int ; additionalNumber := 10 ;
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class FileReaderUtility {
    public void performOperation() {
        RandomAccessFile file = new RandomAccessFile("data.log", "rw");
        long position = file.getFilePointer();
        int byteValue = file.readByte();
        position = file.getFilePointer();
        byteValue = file.readByte();
        position = file.getFilePointer();
        file.close();
        String additionalInfo = "info";
        double extraValue = 3.14;
    }
}

------------------------------------------------------------
OCL File:
---------
class FileReaderUtility {
   operation performOperation() : void
  pre: true
  post: true
  activity: (     var file : OclFile ; file := OclFile.newOclFile("data.log", "rw") ;
     var position : long ; position := file.getPosition() ;
    var byteValue : int ; byteValue := file.readByte() ;
    position := file.getPosition() ; 
    byteValue := file.readByte() ; 
    position := file.getPosition() ; 
    skip ; 
    var additionalInfo : String ; additionalInfo := "info" ;
    var extraValue : double ; extraValue := 3.14 ;
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class RandomDemo {
    double execute() {
        Random generator = new Random();
        double value = generator.nextDouble();
        value = generator.nextGaussian();
        boolean flag = generator.nextBoolean();
        int number = generator.nextInt(500);
        number = generator.nextInt();
        generator.setSeed(1234567);
        value = generator.nextFloat();
        String additionalString = "test";
        long additionalLong = 9876543210L;
        return generator.nextGaussian();
    }
}

------------------------------------------------------------
OCL File:
---------
class RandomDemo {
   operation execute() : double
  pre: true
  post: true
  activity: (     var generator : OclRandom ; generator := OclRandom.newOclRandom() ;
     var value : double ; value := generator.nextDouble() ;
    value := generator.nextGaussian() ; 
    var flag : boolean ; flag := generator.nextBoolean() ;
    var number : int ; number := generator.nextInt(500) ;
    number := generator.nextInt() ; 
    generator.setSeed(1234567) ; 
    value := generator.nextFloat() ; 
    var additionalString : String ; additionalString := "test" ;
    var additionalLong : long ; additionalLong := 9876543210L ;
    return generator.nextGaussian() 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class ArrayManipulation {
    public static void exchange(int[] array1, int[] array2) {
        int temp = array1[0];
        array1[0] = array2[0];
        array2[0] = temp;
    }
    public static void main(String[] args) {
        int[] firstArray = {10, 20, 30, 40};
        int[] secondArray = {5, 15, 25, 35};
        exchange(firstArray, secondArray);
        System.out.println(firstArray[0] + " " + firstArray[1] + " " + firstArray[2] + " " + firstArray[3]);
        System.out.println(secondArray[0] + " " + secondArray[1] + " " + secondArray[2] + " " + secondArray[3]);
        String extraMessage = "Completed";
        double extraValue = 7.89;
    }
}

------------------------------------------------------------
OCL File:
---------
class ArrayManipulation {
  static   operation exchange( array1 : Sequence(int), array2 : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var temp : int ; temp := array1[0+1] ;
     array1[0+1] := array2[0+1] ; 
     array2[0+1] := temp );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var firstArray : Sequence(int) ; firstArray := Sequence{10,20,30,40} ;
     var secondArray : Sequence(int) ; secondArray := Sequence{5,15,25,35} ;
    execute exchange(firstArray, secondArray) ; 
    OclFile["System.out"].println(firstArray[0+1] + " " + firstArray[1+1] + " " + firstArray[2+1] + " " + firstArray[3+1]) ; 
    OclFile["System.out"].println(secondArray[0+1] + " " + secondArray[1+1] + " " + secondArray[2+1] + " " + secondArray[3+1]) ; 
    var extraMessage : String ; extraMessage := "Completed" ;
    var extraValue : double ; extraValue := 7.89 ;
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ArrayComparison {
    public void compare() {
        int[] array1 = {5, 10, 15, 20,5};
        int[] array2 = {1, 2, 3, 4, 8};
        boolean result = (array1 == array2);
        result = (array1.equals(array2));
        result = Arrays.equals(array1, array2);
        array1 = array2;
        String additionalString = "done";
        double additionalDouble = 42.0;
        result = Arrays.equals(array1, array2);
        result = (array1.equals(array2));
        result = (array1 == array2);
    }
}

------------------------------------------------------------
OCL File:
---------
class ArrayComparison {
   operation compare() : void
  pre: true
  post: true
  activity: (     var array1 : Sequence(int) ; array1 := Sequence{5,10,15,20,5} ;
     var array2 : Sequence(int) ; array2 := Sequence{1,2,3,4,8} ;
    var result : boolean ; result := (array1 = array2) ;
    result := (array1 = array2) ; 
    result := array1 = array2 ; 
    array1 := array2 ; 
    var additionalString : String ; additionalString := "done" ;
    var additionalDouble : double ; additionalDouble := 42.0 ;
    result := array1 = array2 ; 
    result := (array1 = array2) ; 
    result := (array1 = array2) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Term {
    public String partOfSpeech = "Verb";
    public String content = "";
    public Term() { }
    public Term(String value) {
        content = value;
    }
    public String getPartOfSpeech() {
        return partOfSpeech;
    }
}
class ForeignTerm extends Term {
    public String mode = "Indicative";
    public ForeignTerm(String value) {
        super(value);
    }
    public String getMode() {
        return mode;
    }
}
class Analyzer {
    public static void analyze() {
        Class clazz = ForeignTerm.class;
        Field[] fields = clazz.getFields();
        Method[] methods = clazz.getMethods();
        Constructor[] constructors = clazz.getConstructors();
        Class parentClass = clazz.getSuperclass();
        String additionalVariable = "example";
        int additionalNumber = 100;
    }
}

------------------------------------------------------------
OCL File:
---------
class Term {
   attribute partOfSpeech : String := "Verb";
   attribute content : String := "";
   static operation newTerm() : Term
  pre: true
  post: true
  activity:
  ( var self : Term ;
    self := createTerm();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   static operation newTerm( value : String) : Term
  pre: true
  post: true
  activity:
  ( var self : Term ;
    self := createTerm();
    self.initialise(value);
    return self );
  operation initialise( value : String) : void
  pre: true  post: true
  activity: (     content := value );
   operation getPartOfSpeech() : String
  pre: true
  post: true
  activity: (     return partOfSpeech );
}
 class ForeignTerm extends Term {
   attribute mode : String := "Indicative";
   static operation newForeignTerm( value : String) : ForeignTerm
  pre: true
  post: true
  activity:
  ( var self : ForeignTerm ;
    self := createForeignTerm();
    self.initialise(value);
    return self );
  operation initialise( value : String) : void
  pre: true  post: true
  activity: (     execute super(value) );
   operation getMode() : String
  pre: true
  post: true
  activity: (     return mode );
}
class Analyzer {
  static   operation analyze() : void
  pre: true
  post: true
  activity: (     var clazz : OclType ; clazz := OclType["ForeignTerm"] ;
     var fields : Sequence(OclAttribute) ; fields := clazz.getFields() ;
    var methods : Sequence(OclOperation) ; methods := clazz.getMethods() ;
    var constructors : Sequence(OclOperation) ; constructors := clazz.getConstructors() ;
    var parentClass : OclType ; parentClass := clazz.getSuperclass() ;
    var additionalVariable : String ; additionalVariable := "example" ;
    var additionalNumber : int ; additionalNumber := 100 ;
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
abstract class aaaa { 
    int aaa = 10; 
    abstract String xxxxx(); 
}

------------------------------------------------------------
OCL File:
---------
class aaaa {
   attribute aaa : int := 10;
     operation xxxxx() : String
  pre: true
  post: true;
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class DataManager {
    void process() {
        List<String> items = new ArrayList<String>();
        String additionalString = "complete";
        int additionalCount = 50;
        items.add("apple");
        items.add("banana");
        items.add("cherry");
        items.add("apple");
        items.add("kewi");
        additionalCount+=10;
        boolean removed = items.remove("kewi");
        removed = items.remove("date");
        removed = Collections.replaceAll(items, "apple", "date");
        System.out.println(items);
    }
}

------------------------------------------------------------
OCL File:
---------
 class DataManager {
   operation process() : void
  pre: true
  post: true
  activity: (     var items : Sequence(String) ; items := Sequence{} ;
     var additionalString : String ; additionalString := "complete" ;
    var additionalCount : int ; additionalCount := 50 ;
    items := items->including("apple") ; 
    items := items->including("banana") ; 
    items := items->including("cherry") ; 
    items := items->including("apple") ; 
    items := items->including("kewi") ; 
    additionalCount := additionalCount+(10) ; 
    var removed : boolean ; removed := items->includes("kewi") ;
    removed := items->includes("date") ;     items := items->excludingFirst("date") ; 
     removed := items->includes( "apple" )  ;     items := items->collect( x1 | if x1 = "apple" then "date" else x1 endif ) ; 
    OclFile["System.out"].println(items) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class TaskRunner implements Runnable {
    private String identifier;
    public TaskRunner(String name) {
        identifier = name;
    }
    public void run() {
        for (int index = 0; index < 15; index++) {
            System.out.println(">> iteration " + index + " of " + identifier);
        }
    }
}
public class Application {
    public static void main(String[] args) {
        String extraInfo = "sss ssss";
        TaskRunner task1 = new TaskRunner("A");
        TaskRunner task2 = new TaskRunner("B");
        Thread thread1 = new Thread(task1);
        Thread thread2 = new Thread(task2);
        int mm = 89;
        thread1.start();
        thread2.start();
        mm=mm*8;
    }
}

------------------------------------------------------------
OCL File:
---------
class TaskRunner implements Runnable {
   attribute identifier : String;
   static operation newTaskRunner( name : String) : TaskRunner
  pre: true
  post: true
  activity:
  ( var self : TaskRunner ;
    self := createTaskRunner();
    self.initialise(name);
    return self );
  operation initialise( name : String) : void
  pre: true  post: true
  activity: (     identifier := name );
   operation run() : void
  pre: true
  post: true
  activity: (         var index : int ; index := 0 ; while index < 15 do ( (     OclFile["System.out"].println(">> iteration " + index + " of " + identifier) )  ;     index := index + 1 ) );
}
 class Application {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var extraInfo : String ; extraInfo := "sss ssss" ;
     var task1 : TaskRunner ; task1 := TaskRunner.newTaskRunner("A") ;
    var task2 : TaskRunner ; task2 := TaskRunner.newTaskRunner("B") ;
    var thread1 : OclProcess ; thread1 := OclProcess.newOclProcess(task1) ;
    var thread2 : OclProcess ; thread2 := OclProcess.newOclProcess(task2) ;
    var mm : int ; mm := 89 ;
    thread1.start() ; 
    thread2.start() ; 
    mm := mm * 8 ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class CommandExecutor {
    int executeCommand() {
        Runtime runtime = Runtime.getRuntime();
        Process process = runtime.exec("C:/Program Files/Java/jdk-11.0.2/bin/java.exe");
        int exitCode = process.waitFor();
        String status = "executed";
        double version = 11.02;
        return exitCode;
    }
}

------------------------------------------------------------
OCL File:
---------
class CommandExecutor {
   operation executeCommand() : int
  pre: true
  post: true
  activity: (     var runtime : OclProcess ; runtime := Runtime.getRuntime() ;
     var process : OclProcess ; process := runtime.exec("C:/Program Files/Java/jdk-11.0.2/bin/java.exe") ;
    var exitCode : int ; exitCode := process.waitFor() ;
    var status : String ; status := "executed" ;
    var version : double ; version := 11.02 ;
    return exitCode 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class InputCollector {
    public ArrayList<Double> collectData() {
        ArrayList<Double> results = new ArrayList<Double>();
        Scanner scanner = new Scanner(System.in);
        String status = "data collected";
        int count = 10;
        while (scanner.hasNext()) {
            double value = scanner.nextDouble();
            results.add(value);
        }
        return results;
    }
}

------------------------------------------------------------
OCL File:
---------
class InputCollector {
   operation collectData() : Sequence(double)
  pre: true
  post: true
  activity: (     var results : Sequence(double) ; results := Sequence{} ;
     var scanner : OclFile ; scanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var status : String ; status := "data collected" ;
    var count : int ; count := 10 ;
    while (scanner.hasNext()) do (     var value : double ; value := scanner.getCurrent()->toReal() ;
     results := results->including(value) ) ; 
    return results 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet;
import java.util.TreeSet;
public class CollectionExample {
    public void demoMethod() {
        HashSet<String> hashSet = new HashSet<String>();
        hashSet = new HashSet<String>(50);
        String additionalText = "sample";
        int additionalNumber = 25;
        TreeSet<String> treeSet = new TreeSet<String>(hashSet);
        treeSet = new TreeSet<String>();
        String[][] stringArray = { { "x", "y" }, { "z", "w" } };
        stringArray[0][0] = "m";
    }
}

------------------------------------------------------------
OCL File:
---------
 class CollectionExample {
   operation demoMethod() : void
  pre: true
  post: true
  activity: (     var hashSet : Set(String) ; hashSet := Set{} ;
     hashSet := Set{} ; 
    var additionalText : String ; additionalText := "sample" ;
    var additionalNumber : int ; additionalNumber := 25 ;
    var treeSet : Set(String) ; treeSet := Set{}->union(hashSet) ;
    treeSet := Set{} ; 
    var stringArray : Sequence(Sequence(String)) ; stringArray := Sequence{Sequence{"x","y"},Sequence{"z","w"}} ;
    stringArray[0+1][0+1] := "m" ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class NumberProcessor {
    public int processNumbers() {
        Short number = new Short("127");
        short maxShort = Short.MAX_VALUE;
        String additionalString = "value";
        maxShort = Short.parseShort("128");
        float floatValue = number.floatValue();
        double additionalDouble = 12.34;
        int comparisonResult = number.compareTo(new Short((short) 50));
        return comparisonResult;
    }
}

------------------------------------------------------------
OCL File:
---------
class NumberProcessor {
   operation processNumbers() : int
  pre: true
  post: true
  activity: (     var number : int ; number := ("" + ("127"))->toInteger() ;
     var maxShort : int ; maxShort := 32767 ;
    var additionalString : String ; additionalString := "value" ;
    maxShort := ("128")->toInteger() ; 
    var floatValue : double ; floatValue := number->oclAsType(double) ;
    var additionalDouble : double ; additionalDouble := 12.34 ;
    var comparisonResult : int ; comparisonResult := number->compareTo(("" + ((50 mod 32768)))->toInteger()) ;
    return comparisonResult 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Counter {
    public int updateCount() {
        int counter = 20;
        counter--;
        counter = ++counter;
        counter = --counter;
        counter--;
        counter = counter++;
        counter = counter--;
        double additionalValue = 8.56;
        return counter;
    }
}

------------------------------------------------------------
OCL File:
---------
class Counter {
   operation updateCount() : int
  pre: true
  post: true
  activity: (     var counter : int ; counter := 20 ;
     counter := counter - 1 ; 
        counter := counter + 1 ;
 counter := counter  ; 
        counter := counter - 1 ;
 counter := counter  ; 
    counter := counter - 1 ; 
     counter := counter  ; counter := counter + 1 ; 
     counter := counter  ; counter := counter - 1 ; 
    var additionalValue : double ; additionalValue := 8.56 ;
    return counter 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.Socket;
public class NetworkClient {
    void sendMessage() {
        InetAddress address = InetAddress.getByName("192.168.1.1");
        String additionalInfo = "operation complete";
        Socket socket = new Socket(address, 54321);
        ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream());
        int additionalPort = 8080;
        outputStream.writeObject("Hello, server");
        outputStream.flush();
        outputStream.close();
        socket.close();
    }
}

------------------------------------------------------------
OCL File:
---------
 class NetworkClient {
   operation sendMessage() : void
  pre: true
  post: true
  activity: (     var address : String ; address := "192.168.1.1" ;
     var additionalInfo : String ; additionalInfo := "operation complete" ;
    var socket : OclDatasource ; socket := OclDatasource.newSocket(address, 54321) ;
    var outputStream : OclFile ; outputStream := OclFile.newOclFile_WriteB(OclFile.newOclFile(socket.getOutputStream())) ;
    var additionalPort : int ; additionalPort := 8080 ;
    skip ; 
    skip ; 
    skip ; 
    socket.close() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class CollectionHandler {
    public boolean operateStack() {
        String additionalString = "fruit";
        Stack stack = new Stack();
        stack.push("apple");
        stack.push("banana");
        stack.push("cherry");
        stack.push("cherry1");
        stack.push("cherry2");
        int additionalValue = 42;
        String topElement = (String) stack.peek();
        int position = stack.search("banana");
        topElement = (String) stack.pop();
        boolean isEmpty = stack.empty();
        return isEmpty;
    }
}

------------------------------------------------------------
OCL File:
---------
class CollectionHandler {
   operation operateStack() : boolean
  pre: true
  post: true
  activity: (     var additionalString : String ; additionalString := "fruit" ;
     var stack : Sequence ; stack := Sequence{} ;
    stack := stack->append("apple") ; 
    stack := stack->append("banana") ; 
    stack := stack->append("cherry") ; 
    stack := stack->append("cherry1") ; 
    stack := stack->append("cherry2") ; 
    var additionalValue : int ; additionalValue := 42 ;
    var topElement : String ; topElement := stack->min()->oclAsType(String) ;
    var position : int ; position := stack->reverse()->indexOf("banana")-1 ;
    topElement := stack->last()->oclAsType(String) ;     stack := stack->front() ; 
    var isEmpty : boolean ; isEmpty := stack->isEmpty() ;
    return isEmpty 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class InstanceTracker {
  static ArrayList<String> identifiers;  
  static int instanceCounter = 5;
  String additionalInfo = "initialization complete";
  static {
        identifiers = new ArrayList<String>();
        identifiers.add("apple");
        identifiers.add("banana");
        identifiers.add("jjjjjj");
        double additionalValue = 3.14;
    }
}

------------------------------------------------------------
OCL File:
---------
class InstanceTracker {
  static   attribute identifiers : Sequence(String);
  static   attribute instanceCounter : int := 5;
   attribute additionalInfo : String := "initialization complete";
  static operation initialiseClass()
  pre: true post: true
  activity:     identifiers := Sequence{} ; 
    identifiers := identifiers->including("apple") ; 
    identifiers := identifiers->including("banana") ; 
    identifiers := identifiers->including("jjjjjj") ; 
    var additionalValue : double ; additionalValue := 3.14 ;
;
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class mmm
{ @Nullable
  public String ss(@NonNull Object yy, int p, int e)
  { 
    String jjj = yy.getClass().getName() + p + e;
    return jjj;
  }
  public String xxx1(@Nullable Object ooo)
  { 
    return ooo; 
  }
}

------------------------------------------------------------
OCL File:
---------
class mmm {
      operation ss( yy : OclAny, p : int, e : int) : String
  pre: true
  post: true
  activity: (     var jjj : String ; jjj := yy->oclType().getName() + p + e ;
     return jjj );
   operation xxx1( ooo : OclAny) : String
  pre: true
  post: true
  activity: (     return ooo );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Tracker {
    static int instanceCount = 10;
    public Tracker() {
        Tracker.instanceCount++;
    }
    static int retrieveCount() {
        return Tracker.instanceCount;
    }
    public static void main(String[] args) {
        String additionalString = "completed";
        double additionalNumber = 5.67;
    }
}

------------------------------------------------------------
OCL File:
---------
class Tracker {
  static   attribute instanceCount : int := 10;
   static operation newTracker() : Tracker
  pre: true
  post: true
  activity:
  ( var self : Tracker ;
    self := createTracker();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     Tracker.instanceCount := Tracker.instanceCount + 1 );
  static   operation retrieveCount() : int
  pre: true
  post: true
  activity: (     return Tracker.instanceCount );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var additionalString : String ; additionalString := "completed" ;
     var additionalNumber : double ; additionalNumber := 5.67 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public interface CustomService {
  public <R> @WebService void sendData() { return; }
}

------------------------------------------------------------
OCL File:
---------
interface CustomService {
     operation sendData<R>() : void
  pre: true
  post: true
  activity: (     return );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class ServiceClass {
  public Handler<@WebAPI ? super ApiService> attribute;
  int newVariable = 10;
}

------------------------------------------------------------
OCL File:
---------
class ServiceClass {
   attribute attribute : Handler<ApiService>;
   attribute newVariable : int := 10;
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Token {
  String content = ""; 
  String type = "NN"; 
  int someValue = 5;
  String processTokens() {
    ArrayList<Token> tokenList = new ArrayList<Token>();
    Token token1 = new Token();
    token1.content = "xx";
    Token token2 = new Token();
    token2.content = "yy";
    Token token3 = new Token();
    token3.content = "zz";
    Token token4 = new Token();
    token4.content = "xx";
    token4.type = "VB";
    int anotherValue = 10;
    Token token5 = new Token();
    token5.content = "ff";
    tokenList.add(token1);
    tokenList.add(token2);
    tokenList.add(token3);
    tokenList.add(token4);
    tokenList.add(token5);
    Stream<String> uniqueContents = tokenList.stream().map(t -> t.content).distinct();
    long uniqueCount = uniqueContents.count();
    System.out.println(uniqueCount);
    boolean allMatchType = tokenList.stream().allMatch(t -> t.type.equals("NN"));
    return allMatchType + "";
  }
}

------------------------------------------------------------
OCL File:
---------
class Token {
   attribute content : String := "";
   attribute type : String := "NN";
   attribute someValue : int := 5;
   operation processTokens() : String
  pre: true
  post: true
  activity: (     var tokenList : Sequence(Token) ; tokenList := Sequence{} ;
     var token1 : Token ; token1 := Token.newToken() ;
    token1.content := "xx" ; 
    var token2 : Token ; token2 := Token.newToken() ;
    token2.content := "yy" ; 
    var token3 : Token ; token3 := Token.newToken() ;
    token3.content := "zz" ; 
    var token4 : Token ; token4 := Token.newToken() ;
    token4.content := "xx" ; 
    token4.type := "VB" ; 
    var anotherValue : int ; anotherValue := 10 ;
    var token5 : Token ; token5 := Token.newToken() ;
    token5.content := "ff" ; 
    tokenList := tokenList->including(token1) ; 
    tokenList := tokenList->including(token2) ; 
    tokenList := tokenList->including(token3) ; 
    tokenList := tokenList->including(token4) ; 
    tokenList := tokenList->including(token5) ; 
    var uniqueContents : Stream<String> ; uniqueContents := tokenList->collect( _x1 | (lambda t : OclAny in t.content)->apply(_x1) )->asOrderedSet() ;
    var uniqueCount : long ; uniqueCount := uniqueContents->size() ;
    OclFile["System.out"].println(uniqueCount) ; 
    var allMatchType : boolean ; allMatchType := tokenList->forAll( _x2 | (lambda t : OclAny in t.type = "NN")->apply(_x2) ) ;
    return allMatchType + "" 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class BufferHandler {
    public int handleBuffer() {
       StringBuffer buffer = new StringBuffer(); 
       buffer = new StringBuffer("example string"); 
       buffer = new StringBuffer(150); 
       buffer.append(1.23); 
       buffer.append('d'); 
       buffer.append("more text"); 
       char[] chars = {'x', 'y', 'z'}; 
       buffer.append(chars); 
       char firstChar = buffer.charAt(0); 
       buffer.delete(0, 4); 
       buffer.deleteCharAt(1); 
       buffer.ensureCapacity(250); 
       int newVariable = 42;
       return buffer.indexOf("a", 8); 
    }
}

------------------------------------------------------------
OCL File:
---------
class BufferHandler {
   operation handleBuffer() : int
  pre: true
  post: true
  activity: (     var buffer : String ; buffer := StringLib.newString() ;
     buffer := StringLib.newString("example string") ; 
    buffer := StringLib.newString(150) ; 
    buffer := buffer + StringLib.newString(1.23) ; 
    buffer := buffer + StringLib.newString('d') ; 
    buffer := buffer + StringLib.newString("more text") ; 
    var chars : Sequence(String) ; chars := Sequence{'x','y','z'} ;
    buffer := buffer + StringLib.newString(chars) ; 
    var firstChar : String ; firstChar := buffer->at(0+1) ;
    buffer := buffer->antirestrict( Integer.subrange(0+1,4) ) ; 
    buffer := buffer->excludingAt(1+1) ; 
    buffer.ensureCapacity(250) ; 
    var newVariable : int ; newVariable := 42 ;
    return buffer.subrange(8+1)->indexOf("a"+"") + 8 - 1  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class BufferExample {
    public String processBuffer() {
        StringBuffer buf = new StringBuffer("initial text"); 
        StringBuffer updatedBuf = buf.insert(6, false); 
        int mm = 4;
        buf.insert(6, 200); 
        buf.reverse(); 
        buf.setCharAt(1, 'y'); 
        CharSequence subSeq = buf.subSequence(2, 6); 
        String newString = buf.substring(4); 
        int additionalValue = 99;
        return newString; 
    }
}

------------------------------------------------------------
OCL File:
---------
class BufferExample {
   operation processBuffer() : String
  pre: true
  post: true
  activity: (     var buf : String ; buf := StringLib.newString("initial text") ;
     var updatedBuf : String ; updatedBuf := buf.insertAt(6+1, StringLib.newString(false)) ;
    var mm : int ; mm := 4 ;
    buf := buf.insertAt(6+1, StringLib.newString(200)) ; 
    buf := buf->reverse() ; 
    buf := buf.setAt(1+1, 'y') ; 
    var subSeq : String ; subSeq := buf.subrange(2+1,6) ;
    var newString : String ; newString := buf.subrange(4+1,4) ;
    var additionalValue : int ; additionalValue := 99 ;
    return newString 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class BuilderDemo {
    public int performOperation() {
        StringBuilder sb = new StringBuilder(); 
        sb = new StringBuilder(150);         
        sb = new StringBuilder("sample string"); 
        sb.append(1.75); 
        sb.append('d'); 
        sb.append('t'); 
        sb.append("additional text"); 
        char[] chars = {'x', 'y', 'z', 'o'}; 
        sb.append(chars); 
        char firstChar = sb.charAt(2); 
        sb.delete(1, 6); 
        sb.deleteCharAt(2); 
        sb.ensureCapacity(300); 
        int anotherVar = 7;
        return sb.indexOf("x", 5); 
    }
}

------------------------------------------------------------
OCL File:
---------
class BuilderDemo {
   operation performOperation() : int
  pre: true
  post: true
  activity: (     var sb : String ; sb := StringLib.newString() ;
     sb := StringLib.newString(150) ; 
    sb := StringLib.newString("sample string") ; 
    sb := sb + StringLib.newString(1.75) ; 
    sb := sb + StringLib.newString('d') ; 
    sb := sb + StringLib.newString('t') ; 
    sb := sb + StringLib.newString("additional text") ; 
    var chars : Sequence(String) ; chars := Sequence{'x','y','z','o'} ;
    sb := sb + StringLib.newString(chars) ; 
    var firstChar : String ; firstChar := sb->at(2+1) ;
    sb := sb->antirestrict( Integer.subrange(1+1,6) ) ; 
    sb := sb->excludingAt(2+1) ; 
    sb.ensureCapacity(300) ; 
    var anotherVar : int ; anotherVar := 7 ;
    return sb.subrange(5+1)->indexOf("x"+"") + 5 - 1  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
interface Role {
    void displayRole();
}
class Individual {
    String fullName = "";
    int yearsOld = 0;
    public Individual(String name) {
        fullName = name;
    }
}
class Learner extends Individual implements Role {
    String major = "";
    public Learner(String name, String subject) {
        super(name);
        major = subject;
    }
    @Override
    public void displayRole() {
        System.out.println("Role: Learner");
    }
}
class Teacher extends Individual {
    String department = "";
    public Teacher(String name, String dept) {
        super(name);
        department = dept;
    }
}
class Administrator extends Individual {
    String office = "";
    public Administrator(String name, String officeLocation) {
        super(name);
        office = officeLocation;
    }
}

------------------------------------------------------------
OCL File:
---------
interface Role {
   operation displayRole() : void
  pre: true
  post: true;
}
 class Individual {
   attribute fullName : String := "";
   attribute yearsOld : int := 0;
   static operation newIndividual( name : String) : Individual
  pre: true
  post: true
  activity:
  ( var self : Individual ;
    self := createIndividual();
    self.initialise(name);
    return self );
  operation initialise( name : String) : void
  pre: true  post: true
  activity: (     fullName := name );
}
class Learner extends Individual, Role {
   attribute major : String := "";
   static operation newLearner( name : String, subject : String) : Learner
  pre: true
  post: true
  activity:
  ( var self : Learner ;
    self := createLearner();
    self.initialise(name, subject);
    return self );
  operation initialise( name : String, subject : String) : void
  pre: true  post: true
  activity: (     execute super(name) ; 
     major := subject );
      operation displayRole() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Role: Learner") );
}
class Teacher extends Individual {
   attribute department : String := "";
   static operation newTeacher( name : String, dept : String) : Teacher
  pre: true
  post: true
  activity:
  ( var self : Teacher ;
    self := createTeacher();
    self.initialise(name, dept);
    return self );
  operation initialise( name : String, dept : String) : void
  pre: true  post: true
  activity: (     execute super(name) ; 
     department := dept );
}
class Administrator extends Individual {
   attribute office : String := "";
   static operation newAdministrator( name : String, officeLocation : String) : Administrator
  pre: true
  post: true
  activity:
  ( var self : Administrator ;
    self := createAdministrator();
    self.initialise(name, officeLocation);
    return self );
  operation initialise( name : String, officeLocation : String) : void
  pre: true  post: true
  activity: (     execute super(name) ; 
     office := officeLocation );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class DataHandler {
    public int analyzeData() { 
        int[] numbers = {88, 84, 77, 71, 67, 72, 69, 63, 58, 52, 49, 41, 33, 29, 25, 18, 12, 5}; 
        int evenCount = 0; 
        int oddCount = 0; 
        int divisibleByFive = 0;
        int totalCount = 0;  
        for (int i = 0; i < numbers.length; i++) { 
            switch (numbers[i] % 5) { 
                case 0: 
                    divisibleByFive++; 
                case 3:
                    evenCount++; 
                    totalCount++; 
                    break;  
                default: 
                    oddCount++;
                    totalCount++; 
            } 
        } 
        return totalCount; 
    } 
}

------------------------------------------------------------
OCL File:
---------
class DataHandler {
   operation analyzeData() : int
  pre: true
  post: true
  activity: (     var numbers : Sequence(int) ; numbers := Sequence{88,84,77,71,67,72,69,63,58,52,49,41,33,29,25,18,12,5} ;
     var evenCount : int ; evenCount := 0 ;
    var oddCount : int ; oddCount := 0 ;
    var divisibleByFive : int ; divisibleByFive := 0 ;
    var totalCount : int ; totalCount := 0 ;
        var i : int ; i := 0 ; while i < numbers->size() do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (numbers[i+1] mod 5) ; 
       if _switchval = 0 then
     divisibleByFive := divisibleByFive + 1 ; 
   else skip ;
       if _switchval = 3 then
     evenCount := evenCount + 1 ; 
    totalCount := totalCount + 1 ; 
    break 
   else skip ;
       if true then
     oddCount := oddCount + 1 ; 
    totalCount := totalCount + 1 ; 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    return totalCount 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class OperationHandler {
    void performTask() {
      int additionalValue = 100;
      String status = "Completed";    
      System.out.println(System.nanoTime());
      System.out.println(System.getProperty("java.version"));
      System.exit(0);
    }
}

------------------------------------------------------------
OCL File:
---------
class OperationHandler {
   operation performTask() : void
  pre: true
  post: true
  activity: (     var additionalValue : int ; additionalValue := 100 ;
     var status : String ; status := "Completed" ;
    OclFile["System.out"].println(nanoTime()) ; 
    OclFile["System.out"].println(OclProcess.getEnvironmentProperty("java.version")) ; 
OclProcess.exit(0) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class BMICalc
{ 
public static void main(String[] args) throws IOException { 
 BufferedReader
 uu = new BufferedReader(new InputStreamReader(System.in));
 double w = Double.parseDouble(uu.readLine());
 double h = Double.parseDouble(uu.readLine());
 double ccc = w/(h*h);
 System.out.println(ccc); 
  } 
}
------------------------------------------------------------
OCL File:
---------
class BMICalc {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var uu : OclFile ; uu := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var w : double ; w := (uu.readLine())->toReal() ;
    var h : double ; h := (uu.readLine())->toReal() ;
    var ccc : double ; ccc := w / (h * h) ;
    OclFile["System.out"].println(ccc) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class TaskExecutor implements Runnable {
    private String identifier;
    public TaskExecutor(String id) {
        identifier = id;
    }
    public void run() {
        for (int i = 0; i < 15; i++) {
            System.out.println("Processing step " + i + " for " + identifier);
        }
    }
}
class Helper {
    String helperName = "Default";
    int helperCount = 5;
    public Helper(String name) {
        helperName = name;
        helperCount = 10;
    }
    public void displayInfo() {
        System.out.println("Helper Name: " + helperName);
        System.out.println("Helper Count: " + helperCount);
    }
}
public class MainProgram {
    public static void main(String[] args) throws InterruptedException {
        TaskExecutor task1 = new TaskExecutor("Task1");
        Thread thread1 = new Thread(task1, "WorkerThread1");
        System.out.println(Thread.activeCount());
        System.out.println(Thread.currentThread());
        Thread.sleep(3000);
        System.out.println(thread1.getName());
        System.out.println(thread1.isAlive());
        System.out.println(thread1.isDaemon());
        // The destroy method is deprecated and should not be used
        thread1.destroy(); 
    }
}

------------------------------------------------------------
OCL File:
---------
class TaskExecutor implements Runnable {
   attribute identifier : String;
   static operation newTaskExecutor( id : String) : TaskExecutor
  pre: true
  post: true
  activity:
  ( var self : TaskExecutor ;
    self := createTaskExecutor();
    self.initialise(id);
    return self );
  operation initialise( id : String) : void
  pre: true  post: true
  activity: (     identifier := id );
   operation run() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 15 do ( (     OclFile["System.out"].println("Processing step " + i + " for " + identifier) )  ;     i := i + 1 ) );
}
 class Helper {
   attribute helperName : String := "Default";
   attribute helperCount : int := 5;
   static operation newHelper( name : String) : Helper
  pre: true
  post: true
  activity:
  ( var self : Helper ;
    self := createHelper();
    self.initialise(name);
    return self );
  operation initialise( name : String) : void
  pre: true  post: true
  activity: (     helperName := name ; 
     helperCount := 10 );
   operation displayInfo() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Helper Name: " + helperName) ; 
     OclFile["System.out"].println("Helper Count: " + helperCount) );
}
class MainProgram {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var task1 : TaskExecutor ; task1 := TaskExecutor.newTaskExecutor("Task1") ;
     var thread1 : OclProcess ; thread1 := OclProcess.newOclProcess(task1, "WorkerThread1") ;
    OclFile["System.out"].println(OclProcess.activeCount()) ; 
    OclFile["System.out"].println(OclProcess.currentThread()) ; 
    OclProcess.sleep(3000) ; 
    OclFile["System.out"].println(thread1.getName()) ; 
    OclFile["System.out"].println(thread1.isAlive()) ; 
    OclFile["System.out"].println(thread1.isDaemon()) ; 
    thread1.destroy() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Timer;
import java.util.TimerTask;
class TaskHandler extends TimerTask {
    public void run() {
        System.out.println("Task executed at " + System.currentTimeMillis());
    }
}
class SchedulerTest {
    public void executeScheduling() {
        int delay = 1000;
        TaskHandler task = new TaskHandler();
        Timer timer = new Timer();
        timer.schedule(task, 1500L);
        timer.scheduleAtFixedRate(task, 500L, 1500L);
        Thread thread = new Thread(task);
        thread.start();
        String status = "Scheduled";
    }
}

------------------------------------------------------------
OCL File:
---------
 class TaskHandler extends OclProcess {
   operation run() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Task executed at " + OclDate.getSystemTime()) );
}
class SchedulerTest {
   operation executeScheduling() : void
  pre: true
  post: true
  activity: (     var delay : int ; delay := 1000 ;
     var task : TaskHandler ; task := TaskHandler.newTaskHandler() ;
    var timer : OclProcess ; timer := OclProcess.newOclProcess("","TimerTask") ;
    timer.schedule(task, 1500L) ; 
    timer.scheduleAtFixedRate(task, 500L, 1500L) ; 
    var thread : OclProcess ; thread := OclProcess.newOclProcess(task) ;
    thread.start() ; 
    var status : String ; status := "Scheduled" ;
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.SortedMap;
import java.util.TreeMap;
public class DataManager {
    public int processSortedMap() {
        String status = "Active";
        SortedMap<String, String> sortedMap = new TreeMap<>();
        sortedMap.put("A", "alpha");
        sortedMap.put("C", "gamma");
        sortedMap.put("B", "beta");
        sortedMap.put("H", "ffff");
        int threshold = 10;
        String firstKey = sortedMap.firstKey();
        String lastKey = sortedMap.lastKey();
        SortedMap<String, String> headMap = sortedMap.headMap("C");
        SortedMap<String, String> subMap = sortedMap.subMap("A", "C");
        int count = subMap.size();
        return count;
    }
}

------------------------------------------------------------
OCL File:
---------
 class DataManager {
   operation processSortedMap() : int
  pre: true
  post: true
  activity: (     var status : String ; status := "Active" ;
     var sortedMap : Map(String,String) ; sortedMap := Map{} ;
    sortedMap := sortedMap->union(Map{"A" |-> "alpha"}) ; 
    sortedMap := sortedMap->union(Map{"C" |-> "gamma"}) ; 
    sortedMap := sortedMap->union(Map{"B" |-> "beta"}) ; 
    sortedMap := sortedMap->union(Map{"H" |-> "ffff"}) ; 
    var threshold : int ; threshold := 10 ;
    var firstKey : String ; firstKey := sortedMap->keys()->min() ;
    var lastKey : String ; lastKey := sortedMap->keys()->max() ;
    var headMap : Map(String,String) ; headMap := sortedMap->restrict( _key | _key < "C" ) ;
    var subMap : Map(String,String) ; subMap := sortedMap->restrict( _key | _key < "C" & _key >= "A" ) ;
    var count : int ; count := subMap.size() ;
    return count 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
public class CollectionManager {
    public int listOperation() {
        List<String> list = new ArrayList<>(20);
        String status = "Initialized";
        list.add("x");
        list.add("y");
        list.add("z");
        list.add("w");
        int size = 40;
        List<String> copiedList = new ArrayList<>(list);
        boolean containsAll = list.containsAll(copiedList);
        containsAll = list.contains("z");
        String element = list.get(2);
        Iterator<String> iterator = list.iterator();
        element = list.get(0);
        double ratio = 1.5;
        boolean removed = list.removeAll(copiedList);
        return list.indexOf("x");
    }
}

------------------------------------------------------------
OCL File:
---------
 class CollectionManager {
   operation listOperation() : int
  pre: true
  post: true
  activity: (     var list : Sequence(String) ; list := Sequence{} ;
     var status : String ; status := "Initialized" ;
    list := list->including("x") ; 
    list := list->including("y") ; 
    list := list->including("z") ; 
    list := list->including("w") ; 
    var size : int ; size := 40 ;
    var copiedList : Sequence(String) ; copiedList := Sequence{}->union(list) ;
    var containsAll : boolean ; containsAll := list->includesAll(copiedList) ;
    containsAll := list->includes("z") ; 
    var element : String ; element := list->at(2+1) ;
    var iterator : OclIterator ; iterator := list->iterator() ;
    element := list->at(0+1) ; 
    var ratio : double ; ratio := 1.5 ;
    var removed : boolean ; removed := list->intersection(copiedList)->notEmpty() ;
    return list->indexOf("x")-1 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class FaultDemo {
    public void handleFaults() {
        IllegalArgumentException iae = new IllegalArgumentException("invalid argument");
        String faultSeverity = "Major";
        String faultDescription = "Unhandled";
        iae = new IllegalArgumentException();
        int faultCode = 500;
        int retryCount = 3;
        boolean isFixed = false;
        double faultMargin = 0.25;
        Exception ex = new NumberFormatException("format issue");
        throw iae;
        UnsupportedOperationException uoe = new UnsupportedOperationException("operation not supported");
        uoe = new UnsupportedOperationException();
        throw new NumberFormatException("format problem");
    }
}

------------------------------------------------------------
OCL File:
---------
class FaultDemo {
   operation handleFaults() : void
  pre: true
  post: true
  activity: (     var iae : IllegalArgumentException ; iae := IllegalArgumentException.newIllegalArgumentException("invalid argument") ;
     var faultSeverity : String ; faultSeverity := "Major" ;
    var faultDescription : String ; faultDescription := "Unhandled" ;
    iae := IllegalArgumentException.newIllegalArgumentException() ; 
    var faultCode : int ; faultCode := 500 ;
    var retryCount : int ; retryCount := 3 ;
    var isFixed : boolean ; isFixed := false ;
    var faultMargin : double ; faultMargin := 0.25 ;
    var ex : ProgramException ; ex := IncorrectElementException("format issue") ;
    error iae ; 
    var uoe : IncorrectElementException ; uoe := IncorrectElementException("operation not supported") ;
    uoe := IncorrectElementException() ; 
    error IncorrectElementException("format problem") ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
import java.util.List;
class Learner {
    private String fullName;
    public Learner(String name) {
        fullName = name;
    }
}
class Course {
    List<Learner> participantList = new ArrayList<>();
    public void enrollStudent(String name) {
        Learner learner = new Learner(name);
        participantList.add(learner);
    }
    int maxParticipants = 30;
    String courseCode = "CS101";
}
class Instructor {
    private String instructorName;
    private String subjectSpecialization;
    public Instructor(String name, String specialization) {
        instructorName = name;
        subjectSpecialization = specialization;
    }
    public void displayInfo() {
        System.out.println("Instructor: " + instructorName);
        System.out.println("Specialization: " + subjectSpecialization);
    }
    int experienceYears = 10;
    String department = "Computer Science";
}
class School {
    List<Course> courses = new ArrayList<>();
    List<Instructor> staff = new ArrayList<>();
    public void addCourse(Course course) {
        courses.add(course);
    }
    public void addInstructor(Instructor instructor) {
        staff.add(instructor);
    }
    int totalCourses = 5;
    int totalInstructors = 20;
}

------------------------------------------------------------
OCL File:
---------
 class Learner {
   attribute fullName : String;
   static operation newLearner( name : String) : Learner
  pre: true
  post: true
  activity:
  ( var self : Learner ;
    self := createLearner();
    self.initialise(name);
    return self );
  operation initialise( name : String) : void
  pre: true  post: true
  activity: (     fullName := name );
}
class Course {
   attribute participantList : Sequence(Learner) := Sequence{};
   operation enrollStudent( name : String) : void
  pre: true
  post: true
  activity: (     var learner : Learner ; learner := Learner.newLearner(name) ;
     participantList := participantList->including(learner) );
   attribute maxParticipants : int := 30;
   attribute courseCode : String := "CS101";
}
class Instructor {
   attribute instructorName : String;
   attribute subjectSpecialization : String;
   static operation newInstructor( name : String, specialization : String) : Instructor
  pre: true
  post: true
  activity:
  ( var self : Instructor ;
    self := createInstructor();
    self.initialise(name, specialization);
    return self );
  operation initialise( name : String, specialization : String) : void
  pre: true  post: true
  activity: (     instructorName := name ; 
     subjectSpecialization := specialization );
   operation displayInfo() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Instructor: " + instructorName) ; 
     OclFile["System.out"].println("Specialization: " + subjectSpecialization) );
   attribute experienceYears : int := 10;
   attribute department : String := "Computer Science";
}
class School {
   attribute courses : Sequence(Course) := Sequence{};
   attribute staff : Sequence(Instructor) := Sequence{};
   operation addCourse( course : Course) : void
  pre: true
  post: true
  activity: (     courses := courses->including(course) );
   operation addInstructor( instructor : Instructor) : void
  pre: true
  post: true
  activity: (     staff := staff->including(instructor) );
   attribute totalCourses : int := 5;
   attribute totalInstructors : int := 20;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class C {
    int a = 7;
    int b = 14;
}
public class D {
    double alpha = 3.14;
    String message = "Hello World!";
}

------------------------------------------------------------
OCL File:
---------
class C {
   attribute a : int := 7;
   attribute b : int := 14;
}
 class D {
   attribute alpha : double := 3.14;
   attribute message : String := "Hello World!";
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class NumberValidator {
    public boolean evaluatePrimality() {
        {
            boolean[] status = new boolean[150]; 
            Arrays.fill(status, true); 
            for (int num = 2; num < 15; num++) { 
                for (int multiple = 2; multiple * num < 150; multiple++) { 
                    status[multiple * num] = false; 
                } 
            } 
            try { 
                return status[123]; 
            } catch (ArrayIndexOutOfBoundsException ex) { 
                return false; 
            } 
        }
    }
}

------------------------------------------------------------
OCL File:
---------
class NumberValidator {
   operation evaluatePrimality() : boolean
  pre: true
  post: true
  activity: ( (     var status : Sequence(boolean) ; status := Integer.subrange(1,150)->collect(false) ;
     status := status->collect(true) ; 
         var num : int ; num := 2 ; while num < 15 do ( (         var multiple : int ; multiple := 2 ; while multiple * num < 150 do ( (     status[multiple * num+1] := false )  ;     multiple := multiple + 1 ) )  ;     num := num + 1 ) ; 
     try (     return status[123+1] )   catch (ex : IndexingException) do (     return false )
 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class VectorOperations {
    public static double computeDistance(double[] x, double[] y) {
        double total = 0.0; 
        for (int index = 0; index < x.length && index < y.length; index++) { 
            double difference = x[index] - y[index]; 
            total += difference * difference; 
        }
        double factor = 1.0;
        return factor * Math.sqrt(total); 
    }
}

------------------------------------------------------------
OCL File:
---------
class VectorOperations {
  static   operation computeDistance( x : Sequence(double), y : Sequence(double)) : double
  pre: true
  post: true
  activity: (     var total : double ; total := 0.0 ;
         var index : int ; index := 0 ; while index < x->size() & index < y->size() do ( (     var difference : double ; difference := x[index+1] - y[index+1] ;
     total := total+(difference * difference) )  ;     index := index + 1 ) ; 
     var factor : double ; factor := 1.0 ;
     return factor * (total)->sqrt() );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class AAAAAAA
{ int A = 0; 
  int B = 0; 
  int C = 0; 
  int D = 0; 
  int F = 0; 
  AAAAAAA() { 
  } 
  public void Grades()
  { int[] fff = {55, 50, 48, 40, 36, 30, 22, 10}; 
    for (int i = 0; i < fff.length; i++) 
    { switch (fff[i]/10)
      { case 10: 
        case 9: 
        case 8: 
        case 7: 
             A++; 
             break; 
        case 6: 
             B++;
             break; 
        case 5: 
             C++;
             break;  
        case 4: 
             D++;
             break;  
        default: 
             F++;
      } 
    } 
  } 
} 
------------------------------------------------------------
OCL File:
---------
class AAAAAAA {
   attribute A : int := 0;
   attribute B : int := 0;
   attribute C : int := 0;
   attribute D : int := 0;
   attribute F : int := 0;
   static operation newAAAAAAA() : AAAAAAA
  pre: true
  post: true
  activity:
  ( var self : AAAAAAA ;
    self := createAAAAAAA();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   operation Grades() : void
  pre: true
  post: true
  activity: (     var fff : Sequence(int) ; fff := Sequence{55,50,48,40,36,30,22,10} ;
         var i : int ; i := 0 ; while i < fff->size() do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (fff[i+1] / 10) ; 
    if _switchval = 10 or _switchval = 9 or _switchval = 8 or _switchval = 7 then
    A := A + 1 ; 
    break 
   else skip ;
       if _switchval = 6 then
     B := B + 1 ; 
    break 
   else skip ;
       if _switchval = 5 then
     C := C + 1 ; 
    break 
   else skip ;
       if _switchval = 4 then
     D := D + 1 ; 
    break 
   else skip ;
       if true then
     F := F + 1 ; 
   else skip ;
 )
 )  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class rrr {
 public static boolean zxc() {
  ArrayList hhh = new ArrayList(); 
  hhh = new ArrayList(10); 
  hhh.add("aa"); 
  hhh.add("bb"); 
  hhh.add("cc");
  hhh.add("dd");  
  hhh.add(0,"ee"); 
  ArrayList tt = (ArrayList) hhh.clone();
  ArrayList tt2 = (ArrayList) hhh.clone(); 
  hhh.addAll(2,tt2); 
  String ss = (String) hhh.get(5); 
  return hhh.contains("bb");    
  }
}

------------------------------------------------------------
OCL File:
---------
class rrr {
  static   operation zxc() : boolean
  pre: true
  post: true
  activity: (     var hhh : Sequence ; hhh := Sequence{} ;
     hhh := Sequence{} ; 
    hhh := hhh->including("aa") ; 
    hhh := hhh->including("bb") ; 
    hhh := hhh->including("cc") ; 
    hhh := hhh->including("dd") ; 
    hhh := hhh.insertAt(0+1,"ee") ; 
    var tt : Sequence ; tt := hhh->copy()->oclAsType(Sequence) ;
    var tt2 : Sequence ; tt2 := hhh->copy()->oclAsType(Sequence) ;
    hhh := hhh.insertInto(2+1,tt2) ; 
    var ss : String ; ss := hhh->at(5+1)->oclAsType(String) ;
    return hhh->includes("bb") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class eeee {
 public static boolean hngb() { 
  HashSet yy = new HashSet(); 
  yy.add("aa"); 
  yy.add("bb"); 
  yy.add("cc"); 
  yy.add("dd"); 
  ArrayList ee = new ArrayList(yy); 
  ee.addAll(yy); 
  int ff = ee.lastIndexOf("hh"); 
  String str = (String) ee.remove(ff); 
  sq.set(0,"tt"); 
  ff = ee.size(); 
  ee.trimToSize(ff-1); 
  return ee.isEmpty(); 
}
}

------------------------------------------------------------
OCL File:
---------
class eeee {
  static   operation hngb() : boolean
  pre: true
  post: true
  activity: (     var yy : Set ; yy := Set{} ;
     yy := yy->including("aa") ; 
    yy := yy->including("bb") ; 
    yy := yy->including("cc") ; 
    yy := yy->including("dd") ; 
    var ee : Sequence ; ee := Sequence{}->union(yy) ;
    ee := ee->union(yy) ; 
    var ff : int ; ff := ee->lastIndexOf("hh")-1 ;
    var str : String ; str := ee->at(ff+1)->oclAsType(String) ;
    sq := sq.setAt(0+1, "tt") ; 
    ff := ee->size() ; 
    ee := ee.trimToSize(ff - 1) ; 
    return ee->isEmpty() 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class aaaaa {
    public static boolean opn() {
       String[] aaa = {"aaa", "bbb", "ccc"}; 
  List lll = Arrays.asList(aaa); 
  int ix = Arrays.binarySearch(aaa,"dd"); 
  byte[] ttt = {97, 98, 99, 100, 200, 500}; 
  Arrays.fill(ttt, 102); 
  Arrays.sort(aaa); 
  Arrays.sort(aaa,0,4); 
  return Arrays.equals(new String[7], aaa);
    }
}

------------------------------------------------------------
OCL File:
---------
class aaaaa {
  static   operation opn() : boolean
  pre: true
  post: true
  activity: (     var aaa : Sequence(String) ; aaa := Sequence{"aaa","bbb","ccc"} ;
     var lll : Sequence ; lll := aaa ;
    var ix : int ; ix := (aaa->indexOf("dd") - 1) ;
    var ttt : Sequence(int) ; ttt := Sequence{97,98,99,100,200,500} ;
    ttt := ttt->collect(102) ; 
    aaa := aaa->sort() ; 
    aaa := aaa.subrange(1,0)^(aaa.subrange(0+1,4)->sort())^aaa.subrange(4+1,aaa.size) ; 
    return Integer.subrange(1,7)->collect(null) = aaa 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class sssss {
    public BigInteger bbbb() {
        BigDecimal gg = new BigDecimal(999999.99);
        gg = new BigDecimal("99999999999.99");
        BigDecimal jj = gg.abs();
        gg = gg.add(jj);
        double rr = gg.doubleValue();
        double rrr = gg.doubleValue();
        gg = gg.min(jj);
        gg = jj.negate();
        return gg.toBigInteger();
    }
}

------------------------------------------------------------
OCL File:
---------
class sssss {
   operation bbbb() : long
  pre: true
  post: true
  activity: (     var gg : double ; gg := double(999999.99) ;
     gg := double("99999999999.99") ; 
    var jj : double ; jj := gg.abs() ;
    gg := gg->excludes(jj) ; 
    var rr : double ; rr := gg->oclAsType(double) ;
    var rrr : double ; rrr := gg->oclAsType(double) ;
    gg := gg->min() ; 
    gg := jj.negate() ; 
    return gg.toBigInteger() 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class bbbbbb {
    public void desf() {
        BigInteger ff = new BigInteger("10000000");
        BigInteger bx = BigInteger.valueOf(99999999);
        BigInteger zz = ff.add(bx);
        zz= ff.divide(BigInteger.ONE);
        double d = ff.doubleValue();
        zz = ff.gcd(bx);
        zz = ff.pow(5);
        zz = ff.subtract(bx);
    }
}

------------------------------------------------------------
OCL File:
---------
class bbbbbb {
   operation desf() : void
  pre: true
  post: true
  activity: (     var ff : long ; ff := long("10000000") ;
     var bx : long ; bx := (99999999 + "")->toLong() ;
    var zz : long ; zz := ff->excludes(bx) ;
    zz := ff.divide(1) ; 
    var d : double ; d := ff->oclAsType(double) ;
    zz := ff.gcd(bx) ; 
    zz := ff.pow(5) ; 
    zz := ff.subtract(bx) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class AMNHY {
    boolean DD() {
        AssertionError ss = new AssertionError();
        ss = new AssertionError(0.0);
        Boolean b = Boolean.FALSE;
        m = new Boolean("true");
        boolean x = m.booleanValue();
        return x == true;  }
}

------------------------------------------------------------
OCL File:
---------
class AMNHY {
   operation DD() : boolean
  pre: true
  post: true
  activity: (     var ss : AssertionException ; ss := AssertionException() ;
     ss := AssertionException(0.0) ; 
    var b : Boolean ; b := false ;
    m := ("" + ("true"))->toBoolean() ; 
    var x : boolean ; x := m ;
    return x = true 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class aaaaaaa {
    public void gggggg() {
        int x1 = 20;
        int y1 = 7;
        int z1 = (x1 & y1);
        int m1 = (x1 & y1);
        z1 = (x1 | y1);
        z1 = y1 << 1;
        z1 = x1 >> 1;
        m1 = y1 << 1;
    }
}

------------------------------------------------------------
OCL File:
---------
class aaaaaaa {
   operation gggggg() : void
  pre: true
  post: true
  activity: (     var x1 : int ; x1 := 20 ;
     var y1 : int ; y1 := 7 ;
    var z1 : int ; z1 := (MathLib.bitwiseAnd(x1,y1)) ;
    var m1 : int ; m1 := (MathLib.bitwiseAnd(x1,y1)) ;
    z1 := (MathLib.bitwiseOr(x1,y1)) ; 
    z1 := (y1*(2->pow(1)))->oclAsType(long) ; 
    z1 := (x1/(2->pow(1)))->oclAsType(long) ; 
    m1 := (y1*(2->pow(1)))->oclAsType(long) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class xxxxxxx {
void aaaa() {
 BitSet aa = new BitSet(4);
 aa.set(2);
 int j = aa.cardinality();
 int k;
 j = aa.size();
 j = aa.length();
 aa.flip(0,2);
 BitSet bb = new BitSet();
 k = bb.size();
 k = bb.length();
 bb.set(0,3);
 aa.or(bb);
 }
}

------------------------------------------------------------
OCL File:
---------
class xxxxxxx {
   operation aaaa() : void
  pre: true
  post: true
  activity: (     var aa : Sequence(boolean) ; aa := MathLib.toBitSequence(4) ;
     aa := aa.setAt(2+1, true) ; 
    var j : int ; j := aa.cardinality() ;
    var k : int ;
    j := aa->size() ; 
    j := aa->size() ; 
    aa := aa.flip(0, 2) ; 
    var bb : Sequence(boolean) ; bb := MathLib.toBitSequence() ;
    k := bb->size() ; 
    k := bb->size() ; 
    bb := bb.setAt(0+1,3) ; 
    aa := aa.or(bb) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class xxxx
{
  private double co = 0; 
  private double price = 0; 
  private int frr = 0; 
  private double irr = 0; 
  private double ion = 0; 
  private String name = ""; 
  private double term = 0; 
  public xxxx()
  {
    this.name = "";
    this.frr = 0;
    this.irr = 0.0;
    this.ion = 0.0;
    this.term = 0.0;
    this.co = 0.0;
    this.price = 0.0;
  }
  public double di(double ount,double r,double tt)
  { 
    double rrrr = 0;
    if (r <= -1 || tt < 0) 
    { 
      return rrrr; 
    } 
    rrrr = ount / Math.pow(( 1 + r ),tt);
    return rrrr;
  }
  public double value(double r)
  { 
    double rrrr = 0.0;
    if (r <= -1) 
    { 
      return rrrr; 
    } 
    final int upper = (int) Math.floor(term * frr); 
    final double c = co / frr; 
    final double period = 1.0 / frr;
    for (int i = 1; i <= upper; i++) 
    { 
     rrrr = rrrr + this.di(c,r,i * period); 
    } 
    rrrr = rrrr + this.di(100,r,term);
    return rrrr;
  }
   public double ttdi(double ount,double r,double tt)
   { 
    double rrrr = 0.0;
    if (r <= -1 || tt < 0) 
    { 
      return rrrr; 
    } 
    rrrr = ( ount * tt ) / Math.pow(( 1 + r ),tt);
    return rrrr;
  }
  public double macaulayion(double r)
  { 
    double rrrr = 0;
    if (r <= -1) 
    { 
     return rrrr; 
    } 
    final int upper = (int) Math.floor(term * frr); 
    final double c = co / frr; 
    final double period = 1.0 / frr; 
    for (int i = 1; i <= upper; i++) 
    { 
      rrrr = rrrr + this.ttdi(c,r,i * period); 
    } 
    rrrr = rrrr + this.ttdi(100,r,term); 
    rrrr = rrrr / this.value(r);
    return rrrr;
  }
  public double bisection(double r,double rl,double ru)
  { 
    double rrrr = 0;
    if (r <= -1 || rl <= -1 || ru <= -1) 
    { 
      return rrrr; 
    } 
    final double v = this.value(r); 
    rrrr = ((ru - rl < 0.001) ? (r) : (((v > price) ? (this.bisection(( ru + r ) / 2,r,ru)) : (this.bisection(( r + rl ) / 2,rl,r)))));
    return rrrr;
  }
}  
------------------------------------------------------------
OCL File:
---------
class xxxx {
   attribute co : double := 0;
   attribute price : double := 0;
   attribute frr : int := 0;
   attribute irr : double := 0;
   attribute ion : double := 0;
   attribute name : String := "";
   attribute term : double := 0;
   static operation newxxxx() : xxxx
  pre: true
  post: true
  activity:
  ( var self : xxxx ;
    self := createxxxx();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.name := "" ; 
     self.frr := 0 ; 
    self.irr := 0.0 ; 
    self.ion := 0.0 ; 
    self.term := 0.0 ; 
    self.co := 0.0 ; 
    self.price := 0.0 ; 
 );
   operation di( ount : double, r : double, tt : double) : double
  pre: true
  post: true
  activity: (     var rrrr : double ; rrrr := 0 ;
     if (r <= -1 or tt < 0) then (     return rrrr ) else skip ; 
     rrrr := ount / (1 + r)->pow(tt) ; 
     return rrrr );
   operation value( r : double) : double
  pre: true
  post: true
  activity: (     var rrrr : double ; rrrr := 0.0 ;
     if (r <= -1) then (     return rrrr ) else skip ; 
    var upper : int ; upper := (term * frr)->floor()->oclAsType(int) ;
    var c : double ; c := co / frr ;
    var period : double ; period := 1.0 / frr ;
        var i : int ; i := 1 ; while i <= upper do ( (     rrrr := rrrr + self.di(c, r, i * period) )  ;     i := i + 1 ) ; 
    rrrr := rrrr + self.di(100, r, term) ; 
    return rrrr 
 );
   operation ttdi( ount : double, r : double, tt : double) : double
  pre: true
  post: true
  activity: (     var rrrr : double ; rrrr := 0.0 ;
     if (r <= -1 or tt < 0) then (     return rrrr ) else skip ; 
     rrrr := (ount * tt) / (1 + r)->pow(tt) ; 
     return rrrr );
   operation macaulayion( r : double) : double
  pre: true
  post: true
  activity: (     var rrrr : double ; rrrr := 0 ;
     if (r <= -1) then (     return rrrr ) else skip ; 
    var upper : int ; upper := (term * frr)->floor()->oclAsType(int) ;
    var c : double ; c := co / frr ;
    var period : double ; period := 1.0 / frr ;
        var i : int ; i := 1 ; while i <= upper do ( (     rrrr := rrrr + self.ttdi(c, r, i * period) )  ;     i := i + 1 ) ; 
    rrrr := rrrr + self.ttdi(100, r, term) ; 
    rrrr := rrrr / self.value(r) ; 
    return rrrr 
 );
   operation bisection( r : double, rl : double, ru : double) : double
  pre: true
  post: true
  activity: (     var rrrr : double ; rrrr := 0 ;
     if (r <= -1 or rl <= -1 or ru <= -1) then (     return rrrr ) else skip ; 
    var v : double ; v := self.value(r) ;
    rrrr := (if (ru - rl < 0.001) then (r) else ((if (v > price) then (self.bisection((ru + r) / 2, r, ru)) else (self.bisection((r + rl) / 2, rl, r)) endif)) endif) ; 
    return rrrr 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class aaaaa {
 public String mm() 
 { File t = new File("fem.txt"); 
  BufferedReader yy = new BufferedReader(new FileReader(t)); 
  if (yy.ready()) 
  { 
    String sm = yy.readLine(); 
    yy.close(); 
    return sm; 
  } 
 }
}
------------------------------------------------------------
OCL File:
---------
class aaaaa {
   operation mm() : String
  pre: true
  post: true
  activity: (     var t : OclFile ; t := OclFile("fem.txt") ;
     var yy : OclFile ; yy := OclFile.newOclFile_Read(OclFile.newOclFile_Read(t)) ;
     if (yy.canRead()) then (     var sm : String ; sm := yy.readLine() ;
     skip ; 
     return sm ) else skip );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class mmmm {
  void tt() 
  { try {
    BufferedWriter ion = new BufferedWriter(new FileWriter("out.txt"));
    ion.write("Hi Hi Hi", 0, 10);
    ion.newLine();
    ion.newLine();
    char[] mmmm = {'x', 'y', 'z'};
    ion.write(mmmm, 0, 3);
    ion.flush();
    ion.close();
  } catch (Exception _e)
    { _e.printStackTrace(); } 
}
}

------------------------------------------------------------
OCL File:
---------
class mmmm {
   operation tt() : void
  pre: true
  post: true
  activity: (     try (     var ion : OclFile ; ion := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("out.txt"))) ;
     skip ; 
    skip ; 
    skip ; 
    var mmmm : Sequence(String) ; mmmm := Sequence{'x','y','z'} ;
    skip ; 
    skip ; 
    skip ; 
 )   catch (_e : ProgramException) do (     _e.printStackTrace() )
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class ggggg {
    public int hhhhh() {
      Byte m = new Byte(97); 
      m = new Byte("0xF"); 
      byte u = m.byteValue(); 
      u = Byte.parseByte("055",8); 
      u = Byte.decode("077"); 
      return m.compareTo(new Byte("0"));
    }
}

------------------------------------------------------------
OCL File:
---------
class ggggg {
   operation hhhhh() : int
  pre: true
  post: true
  activity: (     var m : int ; m := ("" + (97))->toInteger() ;
     m := ("" + ("0xF"))->toInteger() ; 
    var u : int ; u := m->oclAsType(int) ;
    u := ("055")->toInteger() ; 
    u := ("077")->toInteger() ; 
    return m->compareTo(("" + ("0"))->toInteger()) 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class fff
{ long mm()
  { Calendar u = new GregorianCalendar();
    long res = u.computeTime();
    res = u.getTimeInMillis();
    u.setTimeInMillis(30000000);
    Calendar d = new GregorianCalendar();
    boolean b = d.after(u);
    boolean bm = d.after(u);
    return d.computeTime();
  }
}

------------------------------------------------------------
OCL File:
---------
class fff {
   operation mm() : long
  pre: true
  post: true
  activity: (     var u : OclDate ; u := OclDate.newOclDate() ;
     var res : long ; res := u.time ;
    res := u.time ; 
    u.setTimeInMillis(30000000) ; 
    var d : OclDate ; d := OclDate.newOclDate() ;
    var b : boolean ; b := d.dateAfter(u) ;
    var bm : boolean ; bm := d.dateAfter(u) ;
    return d.time 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector;
import java.util.List; 
class MathFunctions
{
  public static int productRange(int start, int end)
  { int result = 1; 
    for (int i = start; i <= end; i++)
    { result = result * i; } 
    return result; 
  } 
  public static int combination(int total, int selection)
  { int output = 0;
    if (total < selection || selection < 0) 
    { return output; } 
    if (total - selection < selection) 
    { output = 
        MathFunctions.productRange(selection + 1, total) / MathFunctions.productRange(1, total - selection); 
    }
    else if (total - selection >= selection) 
    { output = 
        MathFunctions.productRange(total - selection + 1, total) / MathFunctions.productRange(1, selection); 
    }
    return output;
  }
}
class Division
{
  String title = "";
  int number = 0; 
  double probability = 0; 
  double impact = 0; 
  int level = 0; 
  double mean = 0; 
  List members = new Vector(); 
  public Division()
  {
    this.title = "";
    this.number = 0;
    this.probability = 0.0;
    this.impact = 0.0;
    this.level = 0;
    this.mean = 0.0;
  }
  public double noPropagation(int affected)
  { double result = 0.0;
    double unaffectedProbability = Math.pow(( 1 - probability ), number - affected); 
	double affectedProbability = Math.pow(probability, affected); 
	double noSpread = Math.pow(( 1 - impact ), affected * ( number - affected ));
    result = unaffectedProbability * affectedProbability * noSpread;
    return result;
  }
  public double propagation(int failed, int affected)
  { double result = 0;
    double unaffectedProbability = Math.pow(( 1 - probability ), number - failed); 
	double failedProbability = Math.pow(probability, failed); 
	double noInfectionProbability = Math.pow(( 1 - impact ), failed * ( number - affected )); 
	double infectionProbability = Math.pow(( 1 - Math.pow(( 1 - impact ), failed) ), affected - failed);  
    result = unaffectedProbability * failedProbability * noInfectionProbability * 
             infectionProbability * 
             MathFunctions.combination(affected, failed);
    return result;
  }
  public double memberLoss(int index)
  { double result = 0;
    MemberInDivision member = (MemberInDivision) members.get(index - 1);   
    result = member.ratio * member.entity.level;
    return result;
  }
}
class FinancialInstrument
{
  private double baseProbability = 0; 
  private List divisions = new Vector(); 
  public FinancialInstrument()
  {
    this.baseProbability = 0;
  }
  public double conditionalProbability(int index, int affected)
  { double result = 0;
    if (affected >= 1) 
    { Division division = (Division) divisions.get(index - 1); 
	  result = 1.0 / 
       ( 1 - Math.pow(( 1 - division.probability ), division.number) ); 
    }
    else if (affected < 1) { result = 0; }
    return result;
  }
}
class Entity
{
  String title = ""; 
  int level = 0;
  double probability = 0.0; 
  public Entity()
  {
    this.title = "";
    this.level = 0;
    this.probability = 0.0;
  }
}
class MemberInDivision
{
  double ratio = 0.0; 
  double proportion = 0.0; 
  Entity entity;
  public MemberInDivision(Entity entity)
  {
    this.ratio = 0.0;
    this.proportion = 0.0;
    this.entity = entity;
  }
  public MemberInDivision() { }
}

------------------------------------------------------------
OCL File:
---------
 class MathFunctions {
  static   operation productRange( start : int, end : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 1 ;
         var i : int ; i := start ; while i <= end do ( (     result := result * i )  ;     i := i + 1 ) ; 
     return result );
  static   operation combination( total : int, selection : int) : int
  pre: true
  post: true
  activity: (     var output : int ; output := 0 ;
     if (total < selection or selection < 0) then (     return output ) else skip ; 
     if (total - selection < selection) then (     output := MathFunctions.productRange(selection + 1, total) / MathFunctions.productRange(1, total - selection) ) else     if (total - selection >= selection) then (     output := MathFunctions.productRange(total - selection + 1, total) / MathFunctions.productRange(1, selection) ) else skip ; ;  
     return output );
}
class Division {
   attribute title : String := "";
   attribute number : int := 0;
   attribute probability : double := 0;
   attribute impact : double := 0;
   attribute level : int := 0;
   attribute mean : double := 0;
   attribute members : Sequence := Sequence{};
   static operation newDivision() : Division
  pre: true
  post: true
  activity:
  ( var self : Division ;
    self := createDivision();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.title := "" ; 
     self.number := 0 ; 
    self.probability := 0.0 ; 
    self.impact := 0.0 ; 
    self.level := 0 ; 
    self.mean := 0.0 ; 
 );
   operation noPropagation( affected : int) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0.0 ;
     var unaffectedProbability : double ; unaffectedProbability := (1 - probability)->pow(number - affected) ;
    var affectedProbability : double ; affectedProbability := probability->pow(affected) ;
    var noSpread : double ; noSpread := (1 - impact)->pow(affected * (number - affected)) ;
    result := unaffectedProbability * affectedProbability * noSpread ; 
    return result 
 );
   operation propagation( failed : int, affected : int) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
     var unaffectedProbability : double ; unaffectedProbability := (1 - probability)->pow(number - failed) ;
    var failedProbability : double ; failedProbability := probability->pow(failed) ;
    var noInfectionProbability : double ; noInfectionProbability := (1 - impact)->pow(failed * (number - affected)) ;
    var infectionProbability : double ; infectionProbability := (1 - (1 - impact)->pow(failed))->pow(affected - failed) ;
    result := unaffectedProbability * failedProbability * noInfectionProbability * infectionProbability * MathFunctions.combination(affected, failed) ; 
    return result 
 );
   operation memberLoss( index : int) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
     var member : MemberInDivision ; member := members->at(index - 1+1)->oclAsType(MemberInDivision) ;
     result := member.ratio * member.entity.level ; 
     return result );
}
class FinancialInstrument {
   attribute baseProbability : double := 0;
   attribute divisions : Sequence := Sequence{};
   static operation newFinancialInstrument() : FinancialInstrument
  pre: true
  post: true
  activity:
  ( var self : FinancialInstrument ;
    self := createFinancialInstrument();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.baseProbability := 0 );
   operation conditionalProbability( index : int, affected : int) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
     if (affected >= 1) then (     var division : Division ; division := divisions->at(index - 1+1)->oclAsType(Division) ;
     result := 1.0 / (1 - (1 - division.probability)->pow(division.number)) ) else     if (affected < 1) then (     result := 0 ) else skip ; ;  
     return result );
}
class Entity {
   attribute title : String := "";
   attribute level : int := 0;
   attribute probability : double := 0.0;
   static operation newEntity() : Entity
  pre: true
  post: true
  activity:
  ( var self : Entity ;
    self := createEntity();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.title := "" ; 
     self.level := 0 ; 
     self.probability := 0.0 );
}
class MemberInDivision {
   attribute ratio : double := 0.0;
   attribute proportion : double := 0.0;
   attribute entity : Entity;
   static operation newMemberInDivision( entity : Entity) : MemberInDivision
  pre: true
  post: true
  activity:
  ( var self : MemberInDivision ;
    self := createMemberInDivision();
    self.initialise(entity);
    return self );
  operation initialise( entity : Entity) : void
  pre: true  post: true
  activity: (     self.ratio := 0.0 ; 
     self.proportion := 0.0 ; 
     self.entity := entity );
   static operation newMemberInDivision() : MemberInDivision
  pre: true
  post: true
  activity:
  ( var self : MemberInDivision ;
    self := createMemberInDivision();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class CharacterUtils {
    public int performOperation() {
        int result = (int) 'A';   
        result = 'z' - 'a';       
        result = '8' - 48;        
        return result;            
    }
}

------------------------------------------------------------
OCL File:
---------
class CharacterUtils {
   operation performOperation() : int
  pre: true
  post: true
  activity: (     var result : int ; result := ('A')->char2byte() ;
     result := ('z')->char2byte() - ('a')->char2byte() ; 
     result := ('8')->char2byte() - 48 ; 
     return result );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class FieldLister {
    public void displayFieldNames() {
        Class clazz = Class.forName("String"); 
        Field[] fields = clazz.getFields(); 
        for (int index = 0; index < fields.length; index++) { 
            System.out.println(fields[index].getName()); 
        } 
    }
}

------------------------------------------------------------
OCL File:
---------
class FieldLister {
   operation displayFieldNames() : void
  pre: true
  post: true
  activity: (     var clazz : OclType ; clazz := OclType["String"] ;
     var fields : Sequence(OclAttribute) ; fields := clazz.getFields() ;
         var index : int ; index := 0 ; while index < fields->size() do ( (     OclFile["System.out"].println(fields[index+1].getName()) )  ;     index := index + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class uuuuuu {
    public int hyj() {
        int h=99;
        h += 8;
        h=h*5;
        h -= 3;
        return h+9;
    }
}

------------------------------------------------------------
OCL File:
---------
class uuuuuu {
   operation hyj() : int
  pre: true
  post: true
  activity: (     var h : int ; h := 99 ;
     h := h+(8) ; 
    h := h * 5 ; 
    h := h-(3) ; 
    return h + 9 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ListManipulator {
    public String manipulateCollections() {
      List emptyList = Collections.EMPTY_LIST;
      emptyList = Collections.nCopies(5, "fff");
      int index = Collections.binarySearch(emptyList, "tttt");
      List singleList = Collections.singletonList("ttt");
      index = Collections.lastIndexOfSubList(emptyList, singleList);
      Collections.replaceAll(emptyList, "yy", "uu");
      Collections.reverse(emptyList);
      return (String) Collections.max(emptyList);
    }
}

------------------------------------------------------------
OCL File:
---------
class ListManipulator {
   operation manipulateCollections() : String
  pre: true
  post: true
  activity: (     var emptyList : Sequence ; emptyList := Sequence{} ;
     emptyList := Integer.subrange(1,5)->collect("fff") ; 
    var index : int ; index := .binarySearch(emptyList, "tttt") ;
    var singleList : Sequence ; singleList := .singletonList("ttt") ;
    index := (emptyList->lastIndexOf(singleList)-1) ; 
    emptyList := emptyList->collect( x1 | if x1 = "yy" then "uu" else x1 endif ) ; 
    emptyList := emptyList->reverse() ; 
    return  emptyList->max()->oclAsType(String) 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class CollectionOperations {
    public void performOperations() {
        Vector vector = new Vector(10, 40); 
        ArrayList arrayList = new ArrayList(vector); 
        Hashtable hashtable = new Hashtable(5, 0.5); 
        arrayList.add("aaassa"); 
        vector = new Vector(); 
        hashtable = new Hashtable(); 
        hashtable = new Hashtable(1000); 
        Hashtable newHashtable = new Hashtable(hashtable); 
    }
}

------------------------------------------------------------
OCL File:
---------
class CollectionOperations {
   operation performOperations() : void
  pre: true
  post: true
  activity: (     var vector : Sequence ; vector := Sequence{} ;
     var arrayList : Sequence ; arrayList := Sequence{}->union(vector) ;
    var hashtable : Map ; hashtable := Map{} ;
    arrayList := arrayList->including("aaassa") ; 
    vector := Sequence{} ; 
    hashtable := Map{} ; 
    hashtable := Map{} ; 
    var newHashtable : Map ; newHashtable := Map{}->union(hashtable) ;
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Token
{ 
    String type = "NOUN";
    String content = "";
    public static int processStream()
    { 
        Token t1 = new Token();
        t1.content = "Bread";
        Token t2 = new Token();
        t2.content = "journey";
        t2.type = "VERB";
        Token t3 = new Token();
        t3.content = "taller";
        t3.type = "ADJ";
        ArrayList<Token> tokenList = new ArrayList<Token>();
        tokenList.add(t1);
        tokenList.add(t2);
        tokenList.add(t3);
        int lengthSum = tokenList.stream()
                                  .filter(t -> t.type.equals("NOUN"))
                                  .mapToInt(t -> t.content.length())
                                  .sum();
        return lengthSum;
    }
}

------------------------------------------------------------
OCL File:
---------
class Token {
   attribute type : String := "NOUN";
   attribute content : String := "";
  static   operation processStream() : int
  pre: true
  post: true
  activity: (     var t1 : Token ; t1 := Token.newToken() ;
     t1.content := "Bread" ; 
    var t2 : Token ; t2 := Token.newToken() ;
    t2.content := "journey" ; 
    t2.type := "VERB" ; 
    var t3 : Token ; t3 := Token.newToken() ;
    t3.content := "taller" ; 
    t3.type := "ADJ" ; 
    var tokenList : Sequence(Token) ; tokenList := Sequence{} ;
    tokenList := tokenList->including(t1) ; 
    tokenList := tokenList->including(t2) ; 
    tokenList := tokenList->including(t3) ; 
    var lengthSum : int ; lengthSum := tokenList->select( _x1 | (lambda t : OclAny in t.type = "NOUN")->apply(_x1) )->collect( _x1 | (lambda t : OclAny in t.content->size())->apply(_x1) )->sum() ;
    return lengthSum 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Message
{ 
/* comments */
  public Message() { }
  @Override
  public String toString() 
  { return "Message instance"; }
/* comment */
}

------------------------------------------------------------
OCL File:
---------
class Message {
   static operation newMessage() : Message
  pre: true
  post: true
  activity:
  ( var self : Message ;
    self := createMessage();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
      operation toString() : String
  pre: true
  post: true
  activity: (     return "Message instance" );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class CompareObjects {
    public int compare(Comparable obj1, Comparable obj2) {
        if (obj1 != null && obj2 != null) {
            return obj1.compareTo(obj2);
        }
        return 0;
    }
  }

------------------------------------------------------------
OCL File:
---------
class CompareObjects {
   operation compare( obj1 : OclAny, obj2 : OclAny) : int
  pre: true
  post: true
  activity: (     if (obj1 /= null & obj2 /= null) then (     return obj1->compareTo(obj2) ) else skip ; 
     return 0 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Individual {
    String identifier = "";
    int years = 5;
    Individual(String id) {
        identifier = id;
    }
    public String getIdentifier() {
        return identifier;
    }
    public int incrementAge() {
        years++;
        return years;
    }
    public static void main(String[] args) {
        Individual person = new Individual("John");
        System.out.println("Name: " + person.getIdentifier());
        System.out.println("New Age: " + person.incrementAge());
    }
}

------------------------------------------------------------
OCL File:
---------
class Individual {
   attribute identifier : String := "";
   attribute years : int := 5;
   static operation newIndividual( id : String) : Individual
  pre: true
  post: true
  activity:
  ( var self : Individual ;
    self := createIndividual();
    self.initialise(id);
    return self );
  operation initialise( id : String) : void
  pre: true  post: true
  activity: (     identifier := id );
   operation getIdentifier() : String
  pre: true
  post: true
  activity: (     return identifier );
   operation incrementAge() : int
  pre: true
  post: true
  activity: (     years := years + 1 ; 
     return years );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var person : Individual ; person := Individual.newIndividual("John") ;
     OclFile["System.out"].println("Name: " + person.getIdentifier()) ; 
     OclFile["System.out"].println("New Age: " + person.incrementAge()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class U {
    private Q<A>.S<B> attribute;
    public static void main(String[] args) {
        System.out.println("Program has been modified.");
    }
}

------------------------------------------------------------
OCL File:
---------
class U {
   attribute attribute : S<B>;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Program has been modified.") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.HashMap;
import java.util.Collection;
import java.util.List;
import java.util.ArrayList;
import java.util.Set;
import java.util.HashSet;
import java.util.TreeSet;
import java.util.Collections;
class Point {
    double a = 0.0;
    double b = 0.0;
    double abProduct = 0.0;
    double aSquaredDiff = 0.0;
    double bSquaredDiff = 0.0;
    public static double totalA(ArrayList<Point> points) {
        double result = 0;
        for (int i = 0; i < points.size(); i++) {
            result += points.get(i).a;
        }
        return result;
    }
    public static double totalB(ArrayList<Point> points) {
        double result = 0;
        for (int i = 0; i < points.size(); i++) {
            result += points.get(i).b;
        }
        return result;
    }
    public static double totalABProduct(ArrayList<Point> points) {
        double result = 0;
        for (int i = 0; i < points.size(); i++) {
            result += points.get(i).abProduct;
        }
        return result;
    }
    public static double totalBSquaredDiff(ArrayList<Point> points) {
        double result = 0;
        for (int i = 0; i < points.size(); i++) {
            result += points.get(i).bSquaredDiff;
        }
        return result;
    }
    public static double totalASquaredDiff(ArrayList<Point> points) {
        double result = 0;
        for (int i = 0; i < points.size(); i++) {
            result += points.get(i).aSquaredDiff;
        }
        return result;
    }
}
public class CorrelationAnalyzer {
    double averageA = 0.0;
    double averageB = 0.0;
    double totalProducts = 0.0;
    double totalASquaredDiff = 0.0;
    double totalBSquaredDiff = 0.0;
    double correlationCoefficient = 0.0;
    ArrayList<Point> pointsList = new ArrayList<Point>();
    public void compute() {
        averageA = Point.totalA(pointsList) / pointsList.size();
        averageB = Point.totalB(pointsList) / pointsList.size();
        for (Point p : pointsList) {
            p.abProduct = (p.a - averageA) * (p.b - averageB);
            p.aSquaredDiff = (p.a - averageA) * (p.a - averageA);
            p.bSquaredDiff = (p.b - averageB) * (p.b - averageB);
        }
        totalProducts = Point.totalABProduct(pointsList);
        totalASquaredDiff = Point.totalASquaredDiff(pointsList);
        totalBSquaredDiff = Point.totalBSquaredDiff(pointsList);
        if (totalASquaredDiff > 0 && totalBSquaredDiff > 0) {
            correlationCoefficient = totalProducts / Math.sqrt(totalASquaredDiff * totalBSquaredDiff);
        }
    }
    public static void main(String[] args) {
        Point pt1 = new Point();
        pt1.a = 1.0;
        pt1.b = 2.0;
        Point pt2 = new Point();
        pt2.a = 2.0;
        pt2.b = 4.0;
        Point pt3 = new Point();
        pt3.a = 3.0;
        pt3.b = 6.0;
        CorrelationAnalyzer analyzer = new CorrelationAnalyzer();
        analyzer.pointsList.add(pt1);
        analyzer.pointsList.add(pt2);
        analyzer.pointsList.add(pt3);
        analyzer.compute();
        System.out.println(analyzer.correlationCoefficient);
    }
}

------------------------------------------------------------
OCL File:
---------
 class Point {
   attribute a : double := 0.0;
   attribute b : double := 0.0;
   attribute abProduct : double := 0.0;
   attribute aSquaredDiff : double := 0.0;
   attribute bSquaredDiff : double := 0.0;
  static   operation totalA( points : Sequence(Point)) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
         var i : int ; i := 0 ; while i < points->size() do ( (     result := result+(points->at(i+1).a) )  ;     i := i + 1 ) ; 
     return result );
  static   operation totalB( points : Sequence(Point)) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
         var i : int ; i := 0 ; while i < points->size() do ( (     result := result+(points->at(i+1).b) )  ;     i := i + 1 ) ; 
     return result );
  static   operation totalABProduct( points : Sequence(Point)) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
         var i : int ; i := 0 ; while i < points->size() do ( (     result := result+(points->at(i+1).abProduct) )  ;     i := i + 1 ) ; 
     return result );
  static   operation totalBSquaredDiff( points : Sequence(Point)) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
         var i : int ; i := 0 ; while i < points->size() do ( (     result := result+(points->at(i+1).bSquaredDiff) )  ;     i := i + 1 ) ; 
     return result );
  static   operation totalASquaredDiff( points : Sequence(Point)) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
         var i : int ; i := 0 ; while i < points->size() do ( (     result := result+(points->at(i+1).aSquaredDiff) )  ;     i := i + 1 ) ; 
     return result );
}
class CorrelationAnalyzer {
   attribute averageA : double := 0.0;
   attribute averageB : double := 0.0;
   attribute totalProducts : double := 0.0;
   attribute totalASquaredDiff : double := 0.0;
   attribute totalBSquaredDiff : double := 0.0;
   attribute correlationCoefficient : double := 0.0;
   attribute pointsList : Sequence(Point) := Sequence{};
   operation compute() : void
  pre: true
  post: true
  activity: (     averageA := Point.totalA(pointsList) / pointsList->size() ; 
     averageB := Point.totalB(pointsList) / pointsList->size() ; 
    for (p : pointsList) do ( (     p.abProduct := (p.a - averageA) * (p.b - averageB) ; 
     p.aSquaredDiff := (p.a - averageA) * (p.a - averageA) ; 
     p.bSquaredDiff := (p.b - averageB) * (p.b - averageB) )  ) ; 
    totalProducts := Point.totalABProduct(pointsList) ; 
    totalASquaredDiff := Point.totalASquaredDiff(pointsList) ; 
    totalBSquaredDiff := Point.totalBSquaredDiff(pointsList) ; 
    if (totalASquaredDiff > 0 & totalBSquaredDiff > 0) then (     correlationCoefficient := totalProducts / (totalASquaredDiff * totalBSquaredDiff)->sqrt() ) else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var pt1 : Point ; pt1 := Point.newPoint() ;
     pt1.a := 1.0 ; 
    pt1.b := 2.0 ; 
    var pt2 : Point ; pt2 := Point.newPoint() ;
    pt2.a := 2.0 ; 
    pt2.b := 4.0 ; 
    var pt3 : Point ; pt3 := Point.newPoint() ;
    pt3.a := 3.0 ; 
    pt3.b := 6.0 ; 
    var analyzer : CorrelationAnalyzer ; analyzer := CorrelationAnalyzer.newCorrelationAnalyzer() ;
    analyzer.pointsList->excludes(pt1) ; 
    analyzer.pointsList->excludes(pt2) ; 
    analyzer.pointsList->excludes(pt3) ; 
    analyzer.compute() ; 
    OclFile["System.out"].println(analyzer.correlationCoefficient) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class DateComparison {
    public boolean checkTimestamps() {
        Date currentDate = new Date();
        long timestamp = currentDate.getTime();
        Date clonedDate = (Date) currentDate.clone();
        clonedDate.setTime(5000000);
        clonedDate = new Date(15000000);
        return currentDate.before(clonedDate);
    }
}

------------------------------------------------------------
OCL File:
---------
class DateComparison {
   operation checkTimestamps() : boolean
  pre: true
  post: true
  activity: (     var currentDate : OclDate ; currentDate := OclDate.newOclDate() ;
     var timestamp : long ; timestamp := currentDate.time ;
    var clonedDate : OclDate ; clonedDate := currentDate.clone()->oclAsType(OclDate) ;
    clonedDate.setTime(5000000) ; 
    clonedDate := OclDate.newOclDate(15000000) ; 
    return currentDate.dateBefore(clonedDate) 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class NumberProcessor {
    public boolean evaluateNumber() { 
        double value = Double.MIN_VALUE; 
        value = Double.POSITIVE_INFINITY; 
        int comparison = Double.compare(5.0, value); 
        Double number = new Double(2.0 / 5.0); 
        number = new Double("2.0"); 
        value = Double.parseDouble(number.toString()); 
        value = number.doubleValue(); 
        return Double.isInfinite(value); 
    }
}

------------------------------------------------------------
OCL File:
---------
class NumberProcessor {
   operation evaluateNumber() : boolean
  pre: true
  post: true
  activity: (     var value : double ; value := 2->pow(-1074) ;
     value := Math_PINFINITY ; 
    var comparison : int ; comparison := (5.0)->compareTo(value) ;
    var number : double ; number := ("" + (2.0 / 5.0))->toReal() ;
    number := ("" + ("2.0"))->toReal() ; 
    value := (number+"")->toReal() ; 
    value := number->oclAsType(double) ; 
    return ((value) = Math_PINFINITY or (value) = Math_NINFINITY) 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ttt {
    public boolean jjjjjjj() {
        Character yyy = new Character('%'); 
        char xc = Character.MAX_VALUE; 
        char mc = Character.MIN_VALUE; 
        Class tttt = Character.TYPE; 
        boolean b = Character.isDigit('8'); 
        h1 = Character.isLetter('$'); 
        char h3 = Character.toLowerCase('H'); 
        mmm = yyy.charValue(); 
        h2 = Character.isLowerCase('u'); 
        return Character.isJavaIdentifierPart('$');
    }
  }

------------------------------------------------------------
OCL File:
---------
class ttt {
   operation jjjjjjj() : boolean
  pre: true
  post: true
  activity: (     var yyy : String ; yyy := String('%') ;
     var xc : String ; xc := "\uFFFF" ;
    var mc : String ; mc := "\u0000" ;
    var tttt : OclType ; tttt := ""->oclType() ;
    var b : boolean ; b := ('8' + "")->isMatch("[0-9]") ;
    h1 := ('$' + "")->isMatch("[a-zA-Z]") ; 
    var h3 : String ; h3 := ('H' + "")->toLowerCase() ;
    mmm := yyy+"" ; 
    h2 := ('u'->toLowerCase() = 'u') ; 
    return ('$'->isMatch("[0-9a-zA-Z]") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class LoopExample {
    public int execute() {
        int index = 5;
        do {
            System.out.println("Index: " + index);
            index++;
        } while (index <= 15);
        return index;
    }
    public static void main(String[] args) {
        LoopExample example = new LoopExample();
        int result = example.execute();
        System.out.println("Final Index: " + result);
    }
}

------------------------------------------------------------
OCL File:
---------
class LoopExample {
   operation execute() : int
  pre: true
  post: true
  activity: (     var index : int ; index := 5 ;
   while true do ((     OclFile["System.out"].println("Index: " + index) ; 
     index := index + 1 ) ;
    if (index <= 15) then skip else break) ; 
     return index );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var example : LoopExample ; example := LoopExample.newLoopExample() ;
     var result : int ; result := example.execute() ;
     OclFile["System.out"].println("Final Index: " + result) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class bbbb {
    public int mm() {
        int[] hh = { 7, 8, 4, 10, 8, 7, 5, 9, 6, 7 };
        int su = 0;
        for (int n : hh) su += n;
        return su;
   }
 }

------------------------------------------------------------
OCL File:
---------
class bbbb {
   operation mm() : int
  pre: true
  post: true
  activity: (     var hh : Sequence(int) ; hh := Sequence{7,8,4,10,8,7,5,9,6,7} ;
     var su : int ; su := 0 ;
     for (n : hh) do (     su := su+(n) ;  ) ; 
     return su );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class MapProcessor {
    public String compute() {
        Hashtable mm = new Hashtable(10);
        mm.put("A", "hello");
        mm.put("B", "world");
        mm.put("C", "Hi");
        Enumeration elements = mm.elements();
        String result = "";
        while (elements.hasMoreElements()) {
            result =result+elements.nextElement();
        }
        return result;
    }
}

------------------------------------------------------------
OCL File:
---------
class MapProcessor {
   operation compute() : String
  pre: true
  post: true
  activity: (     var mm : Map ; mm := Map{} ;
     mm := mm->union(Map{"A" |-> "hello"}) ; 
    mm := mm->union(Map{"B" |-> "world"}) ; 
    mm := mm->union(Map{"C" |-> "Hi"}) ; 
    var elements : OclIterator ; elements := mm->values()->iterator() ;
    var result : String ; result := "" ;
    while (elements.hasMoreElements()) do (     result := result + elements.nextElement() ) ; 
    return result 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
enum Gender { male, female}
class Student 
{ private Gender gender = Gender.male; 
  String name = ""; 
  Student(String nme1) 
  { name = nme1; } 
}

------------------------------------------------------------
OCL File:
---------
  enumeration Gender {  literal male;  literal female }
 class Student {
   attribute gender : Gender := Gender.male;
   attribute name : String := "";
   static operation newStudent( nme1 : String) : Student
  pre: true
  post: true
  activity:
  ( var self : Student ;
    self := createStudent();
    self.initialise(nme1);
    return self );
  operation initialise( nme1 : String) : void
  pre: true  post: true
  activity: (     name := nme1 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
interface TimeProvider {
    long fetchTime();
}
abstract class Base {
    protected String identifier;
}
class Derived extends Base implements TimeProvider {
    public long fetchTime() {
        return 123456789L;
    }
    public static void main(String[] args) {
        Derived instance = new Derived();
        System.out.println("Time: " + instance.fetchTime());
    }
}

------------------------------------------------------------
OCL File:
---------
interface TimeProvider {
   operation fetchTime() : long
  pre: true
  post: true;
}
 class Base {
     attribute identifier : String;
}
class Derived extends Base, TimeProvider {
   operation fetchTime() : long
  pre: true
  post: true
  activity: (     return 123456789L );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var instance : Derived ; instance := Derived.newDerived() ;
     OclFile["System.out"].println("Time: " + instance.fetchTime()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File;
public class FileChecker {
    public String[] listFiles() {
        File file = new File("sample.txt");
        boolean isReadable = file.canRead();
        isReadable = file.exists();
        String fileName = file.getName();
        boolean isDirectory = file.isDirectory();
        boolean isRegularFile = file.isFile();
        long lastModifiedTime = file.lastModified();
        long fileSize = file.length();
        return file.list();
    }
    public static void main(String[] args) {
        FileChecker checker = new FileChecker();
        String[] files = checker.listFiles();
        if (files != null) {
            for (String file : files) {
                System.out.println("File: " + file);
            }
        }
    }
}

------------------------------------------------------------
OCL File:
---------
 class FileChecker {
   operation listFiles() : Sequence(String)
  pre: true
  post: true
  activity: (     var file : OclFile ; file := OclFile("sample.txt") ;
     var isReadable : boolean ; isReadable := file.canRead() ;
    isReadable := file.exists() ; 
    var fileName : String ; fileName := file.getName() ;
    var isDirectory : boolean ; isDirectory := file.isDirectory() ;
    var isRegularFile : boolean ; isRegularFile := file.isFile() ;
    var lastModifiedTime : long ; lastModifiedTime := file.lastModified() ;
    var fileSize : long ; fileSize := file.length() ;
    return file.list() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var checker : FileChecker ; checker := FileChecker.newFileChecker() ;
     var files : Sequence(String) ; files := checker.listFiles() ;
     if (files /= null) then (     for (file : files) do ( (     OclFile["System.out"].println("File: " + file) )  ) ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class TextFileReader {
    public void processFile() {
        BufferedReader reader = null;
        File file = new File("data.txt");
        try {
            reader = new BufferedReader(new FileReader(file));
            char[] buffer = new char[15];
            reader.read(buffer, 0, 15);
            System.out.println("Read content: " + new String(buffer));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (reader != null) {
                    reader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

------------------------------------------------------------
OCL File:
---------
class TextFileReader {
   operation processFile() : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := null ;
     var file : OclFile ; file := OclFile("data.txt") ;
     try (     reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) ; 
     var buffer : Sequence(String) ; buffer := Integer.subrange(1,15)->collect(0) ;
     skip ; 
     OclFile["System.out"].println("Read content: " + StringLib.newString(buffer)) )   catch (e : IOException) do (     e.printStackTrace() )
   finally (     try (     if (reader /= null) then (     skip ) else skip )   catch (e : IOException) do (     e.printStackTrace() )
 )
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class DecimalProcessor {
    public boolean handleDecimal() {
        Float number = new Float(0.001);
        number = new Float("0.001");
        float value = Float.MAX_VALUE;
        value = Float.NEGATIVE_INFINITY;
        long intValue = (long) value;
        return Float.isInfinite(value);
    }
}

------------------------------------------------------------
OCL File:
---------
class DecimalProcessor {
   operation handleDecimal() : boolean
  pre: true
  post: true
  activity: (     var number : double ; number := ("" + (0.001))->toReal() ;
     number := ("" + ("0.001"))->toReal() ; 
    var value : double ; value := 3.4028234663852886*(10->pow(38)) ;
    value := Math_NINFINITY ; 
    var intValue : long ; intValue := value->oclAsType(long) ;
    return ((value) = Math_PINFINITY or (value) = Math_NINFINITY) 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Formatter;
import java.io.IOException;
class LogWriter {
    private Formatter formatter;
    public LogWriter() {
        try {
            formatter = new Formatter("logfile.txt");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public void writeData() {
        formatter.format("%s %d %.2f\n", "SampleText", 2000, 7.89);
        formatter.close();
    }
}

------------------------------------------------------------
OCL File:
---------
 class LogWriter {
   attribute formatter : OclFile;
   static operation newLogWriter() : LogWriter
  pre: true
  post: true
  activity:
  ( var self : LogWriter ;
    self := createLogWriter();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     formatter := OclFile.newOclFile_Write(OclFile.newOclFile("logfile.txt")) )   catch (e : IOException) do (     e.printStackTrace() )
 );
   operation writeData() : void
  pre: true
  post: true
  activity: (     skip ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ArraySumCalculator {
    public int calculateSum() {
        int[] numbers = {2, 4, 6, 8, 10, 12, 14, 16, 18};
        int sum = 0;
        for (int i = 0; i < numbers.length; i++) {
            sum += numbers[i];
        }
        return sum;
    }
}

------------------------------------------------------------
OCL File:
---------
class ArraySumCalculator {
   operation calculateSum() : int
  pre: true
  post: true
  activity: (     var numbers : Sequence(int) ; numbers := Sequence{2,4,6,8,10,12,14,16,18} ;
     var sum : int ; sum := 0 ;
         var i : int ; i := 0 ; while i < numbers->size() do ( (     sum := sum+(numbers[i+1]) )  ;     i := i + 1 ) ; 
     return sum );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class jjjjjjjj {
    public int kkkkk() {
        byte[] bb = { 3,5,7,9 };
        String ddd = new String();
        String fff = new String(bb);
        byte[] bb = { 6,7, 8 };
        char[] cc = { '1', '3', '5' };
        fff = new String(cc);         
        char p = fff.charAt(1);
        return ddd.compareToIgnoreCase(fff);
    }
}

------------------------------------------------------------
OCL File:
---------
class jjjjjjjj {
   operation kkkkk() : int
  pre: true
  post: true
  activity: (     var bb : Sequence(int) ; bb := Sequence{3,5,7,9} ;
     var ddd : String ; ddd := StringLib.newString() ;
    var fff : String ; fff := StringLib.newString(bb) ;
    var bb : Sequence(int) ; bb := Sequence{6,7,8} ;
    var cc : Sequence(String) ; cc := Sequence{'1','3','5'} ;
    fff := StringLib.newString(cc) ; 
    var p : String ; p := fff->at(1+1) ;
    return ddd->toLowerCase()->compareTo(fff->toLowerCase()) 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
public class CustomStack<T> {
    private ArrayList<T> items;
    public CustomStack(int capacity) {
        items = new ArrayList<T>(capacity);
    }
    public T peekTop() {
        if (items.size() > 0) {
            return items.get(items.size() - 1);
        }
        return null;
    }
}

------------------------------------------------------------
OCL File:
---------
 class CustomStack<T> {
   attribute items : Sequence(T);
   static operation newCustomStack( capacity : int) : CustomStack
  pre: true
  post: true
  activity:
  ( var self : CustomStack ;
    self := createCustomStack();
    self.initialise(capacity);
    return self );
  operation initialise( capacity : int) : void
  pre: true  post: true
  activity: (     items := Sequence{}->union(capacity) );
   operation peekTop() : T
  pre: true
  post: true
  activity: (     if (items->size() > 0) then (     return items->at(items->size() - 1+1) ) else skip ; 
     return null );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ArrayPrinter
{ 
  public static void main(String[] args)
  { 
    Integer[] numbers = { 5, 10, 15, 20 };
    Double[] decimals = { 2.5, 5.5, 8.5 };
    Character[] letters = { 'X', 'Y', 'Z' };
    System.out.println(ArrayPrinter.displayArray(numbers));
    System.out.println(ArrayPrinter.displayArray(decimals));
    System.out.println(ArrayPrinter.displayArray(letters));
  }
  public static <T> String displayArray(T[] elements)
  { 
    String result = "";
    for (T item : elements)
    { 
      result += item + " "; 
    }
    return result;
  }
}

------------------------------------------------------------
OCL File:
---------
class ArrayPrinter {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var numbers : Sequence(int) ; numbers := Sequence{5,10,15,20} ;
     var decimals : Sequence(double) ; decimals := Sequence{2.5,5.5,8.5} ;
    var letters : Sequence(String) ; letters := Sequence{'X','Y','Z'} ;
    OclFile["System.out"].println(ArrayPrinter.displayArray(numbers)) ; 
    OclFile["System.out"].println(ArrayPrinter.displayArray(decimals)) ; 
    OclFile["System.out"].println(ArrayPrinter.displayArray(letters)) ; 
 );
  static   operation displayArray<T>( elements : Sequence(T)) : String
  pre: true
  post: true
  activity: (     var result : String ; result := "" ;
     for (item : elements) do ( (     result := result+(item + " ") )  ) ; 
     return result );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class CollectionDemo {
    public String process() {
        Set mySet = new HashSet();
        mySet.add("apple");
        mySet.add("banana");
        mySet.add("cherry");
        boolean contains = mySet.contains("date");
        Iterator iterator = mySet.iterator();
        String result = "";
        while (iterator.hasNext()) {
            result += iterator.next();
        }
        Set anotherSet = new HashSet();
        anotherSet.add("apple");
        contains = mySet.removeAll(anotherSet);
        contains = mySet.retainAll(anotherSet);
        return result;
    }
}

------------------------------------------------------------
OCL File:
---------
 class CollectionDemo {
   operation process() : String
  pre: true
  post: true
  activity: (     var mySet : Set ; mySet := Set{} ;
     mySet := mySet->including("apple") ; 
    mySet := mySet->including("banana") ; 
    mySet := mySet->including("cherry") ; 
    var contains : boolean ; contains := mySet->includes("date") ;
    var iterator : OclIterator ; iterator := mySet->iterator() ;
    var result : String ; result := "" ;
    while (iterator.hasNext()) do (     result := result+(iterator.next()) ) ; 
    var anotherSet : Set ; anotherSet := Set{} ;
    anotherSet := anotherSet->including("apple") ; 
    contains := mySet->intersection(anotherSet)->notEmpty() ;     mySet := mySet - anotherSet ; 
    contains := mySet /<: anotherSet ;     mySet := mySet->intersection(anotherSet) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Set;
import java.util.Enumeration;
public class DictionaryHandler {
    public int execute() { 
        Hashtable dictionary = new Hashtable();
        dictionary.put("A", "Alpha");
        dictionary.put("B", "Beta");
        Enumeration keys = dictionary.keys();
        Set keySet = dictionary.keySet();
        HashMap<String, String> tempMap = new HashMap<String,String>();
        tempMap.put("C", "Gamma");
        dictionary.putAll(tempMap);
        String removedValue = (String) dictionary.remove("A");
        return dictionary.size(); 
    }
}

------------------------------------------------------------
OCL File:
---------
 class DictionaryHandler {
   operation execute() : int
  pre: true
  post: true
  activity: (     var dictionary : Map ; dictionary := Map{} ;
     dictionary := dictionary->union(Map{"A" |-> "Alpha"}) ; 
    dictionary := dictionary->union(Map{"B" |-> "Beta"}) ; 
    var keys : OclIterator ; keys := dictionary->keys()->iterator() ;
    var keySet : Set ; keySet := dictionary->keys() ;
    var tempMap : Map(String,String) ; tempMap := Map{} ;
    tempMap := tempMap->union(Map{"C" |-> "Gamma"}) ; 
    dictionary := dictionary->union(tempMap) ; 
    var removedValue : String ; removedValue := dictionary->at("A")->oclAsType(String) ;
    return dictionary.size() 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class NumberEvaluator {
    public boolean evaluate() {
        int value = 8;
        if (value < 3) {
            return false;
        } else if (value == 3) {
            return true;
        }
        return false;
    }
}

------------------------------------------------------------
OCL File:
---------
class NumberEvaluator {
   operation evaluate() : boolean
  pre: true
  post: true
  activity: (     var value : int ; value := 8 ;
     if (value < 3) then (     return false ) else     if (value = 3) then (     return true ) else skip ; ;  
     return false );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector;
import java.util.List;
class Investment
{
  private String title = ""; 
  private double period = 0; 
  private double rate = 0; 
  private double value = 0; 
  private int intervals = 0; 
  private double interest = 0; 
  private double maturity = 0; 
  public Investment()
  {
    this.title = "";
    this.period = 0.0;
    this.rate = 0.0;
    this.value = 0.0;
    this.intervals = 0;
    this.interest = 0.0;
    this.maturity = 0.0;
  }
  public double calculateDiscount(double principal, double rateOfInterest, double duration)
  { 
    double discountedAmount = 0;
    if (rateOfInterest <= -1 || duration < 0) { return discountedAmount; } 
    discountedAmount = principal / Math.pow(( 1 + rateOfInterest ), duration);
    return discountedAmount;
  }
}

------------------------------------------------------------
OCL File:
---------
 class Investment {
   attribute title : String := "";
   attribute period : double := 0;
   attribute rate : double := 0;
   attribute value : double := 0;
   attribute intervals : int := 0;
   attribute interest : double := 0;
   attribute maturity : double := 0;
   static operation newInvestment() : Investment
  pre: true
  post: true
  activity:
  ( var self : Investment ;
    self := createInvestment();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.title := "" ; 
     self.period := 0.0 ; 
    self.rate := 0.0 ; 
    self.value := 0.0 ; 
    self.intervals := 0 ; 
    self.interest := 0.0 ; 
    self.maturity := 0.0 ; 
 );
   operation calculateDiscount( principal : double, rateOfInterest : double, duration : double) : double
  pre: true
  post: true
  activity: (     var discountedAmount : double ; discountedAmount := 0 ;
     if (rateOfInterest <= -1 or duration < 0) then (     return discountedAmount ) else skip ; 
     discountedAmount := principal / (1 + rateOfInterest)->pow(duration) ; 
     return discountedAmount );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
interface X
{ void performX(); }
interface Y
{ void performY(); }
class Alpha implements X
{ 
  public void performX() 
  { 
    System.out.println("performX"); 
  } 
}
class Beta implements Y
{ 
  public void performY() 
  { 
    System.out.println("performY"); 
  } 
}
class Gamma
{ 
  public void execute(Object obj)
  { 
    if (obj instanceof X) 
    { 
      obj.performX(); 
    }
    else if (obj instanceof Y) 
    { 
      obj.performY(); 
    }
  }
}

------------------------------------------------------------
OCL File:
---------
interface X {
   operation performX() : void
  pre: true
  post: true;
}
 interface Y {
   operation performY() : void
  pre: true
  post: true;
}
class Alpha implements X {
   operation performX() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("performX") );
}
class Beta implements Y {
   operation performY() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("performY") );
}
class Gamma {
   operation execute( obj : OclAny) : void
  pre: true
  post: true
  activity: (     if (obj->oclIsKindOf(X)) then (     obj.performX() ) else     if (obj->oclIsKindOf(Y)) then (     obj.performY() ) else skip ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class SampleClass {
  public String transformNumber() {
    Integer num = new Integer(3000);
    num = new Integer("0xABC");
    int val = num.intValue();
    val = Integer.MIN_VALUE;
    val = Integer.parseInt("0666");
    return Integer.toHexString(64);
  }
}

------------------------------------------------------------
OCL File:
---------
class SampleClass {
   operation transformNumber() : String
  pre: true
  post: true
  activity: (     var num : int ; num := ("" + (3000))->toInteger() ;
     num := ("" + ("0xABC"))->toInteger() ; 
    var val : int ; val := num->oclAsType(int) ;
    val := -2147483648 ; 
    val := ("0666")->toInteger() ; 
    return (MathLib.decimal2hex(64) + "") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
interface Viewable {
    String display();
}
class User implements Viewable {
    String identifier = "user123";
    int age = 30;
    public String display() {
        return identifier;
    }
}

------------------------------------------------------------
OCL File:
---------
interface Viewable {
   operation display() : String
  pre: true
  post: true;
}
 class User implements Viewable {
   attribute identifier : String := "user123";
   attribute age : int := 30;
   operation display() : String
  pre: true
  post: true
  activity: (     return identifier );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Operations {
  public void execute() {
    char firstChar = 'b';
    char secondChar = 'd';
    int product = firstChar * secondChar;
    int difference = secondChar - firstChar;
    int sum = firstChar + secondChar;
    double h=90;
    double result = h / 2.0;
  }
}

------------------------------------------------------------
OCL File:
---------
class Operations {
   operation execute() : void
  pre: true
  post: true
  activity: (     var firstChar : String ; firstChar := 'b' ;
     var secondChar : String ; secondChar := 'd' ;
    var product : int ; product := firstChar * secondChar ;
    var difference : int ; difference := (secondChar)->char2byte() - (firstChar)->char2byte() ;
    var sum : int ; sum := firstChar + secondChar ;
    var h : double ; h := 90 ;
    var result : double ; result := h / 2.0 ;
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class hhhh {
public String ggg() { 
  String fff = new String("Hi Hi"); 
  byte[] yyy = fff.getBytes(); 
  char[] hg = new char[3]; 
  ss.getChars(1,3,hg,0); 
  int i = fff.indexOf(" ");
  b = fff.length(); 
  a = fff.indexOf(' ', 5); 
  a = fff.lastIndexOf('p'); 
  a = fff.length(); 
  String r1 = fff.substring(5); 
  return fff.subSequence(0,5); 
}
}
------------------------------------------------------------
OCL File:
---------
class hhhh {
   operation ggg() : String
  pre: true
  post: true
  activity: (     var fff : String ; fff := StringLib.newString("Hi Hi") ;
     var yyy : Sequence(int) ; yyy := fff->characters()->collect( _c | _c->char2byte() ) ;
    var hg : Sequence(String) ; hg := Integer.subrange(1,3)->collect(0) ;
    ss.getChars(1, 3, hg, 0) ; 
    var i : int ; i := fff->indexOf(" ")-1 ;
    b := fff->size() ; 
    a := fff.subrange(5+1)->indexOf(' '+"") + 5 - 1  ; 
    a := fff->lastIndexOf('p')-1 ; 
    a := fff->size() ; 
    var r1 : String ; r1 := fff.subrange(5+1,5) ;
    return fff.subrange(0+1,5) 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Processor {
 public void compute() {
    short num1 = 2000;
    short num2 = (short) (num1 * num1);
    int additionalValue = 500;
    long result = num1 + additionalValue;
  }
}

------------------------------------------------------------
OCL File:
---------
class Processor {
   operation compute() : void
  pre: true
  post: true
  activity: (     var num1 : int ; num1 := 2000 ;
     var num2 : int ; num2 := ((num1 * num1) mod 32768) ;
     var additionalValue : int ; additionalValue := 500 ;
     var result : long ; result := num1 + additionalValue );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class DataCollection {
  public void process() {
    Set numbersSet = new HashSet();
    Iterator setIterator = numbersSet.iterator();
    Enumeration stringEnum = new StringTokenizer("another string example");
    Object firstElement = stringEnum.nextElement();
    Vector vector = new Vector(numbersSet);
    stringEnum = vector.elements();
    stringEnum = Collections.enumeration(numbersSet);
    List numberList = new ArrayList(numbersSet);
    ListIterator listIterator = numberList.listIterator(3);
    Map<String, Integer> sampleMap = new HashMap<>();
    sampleMap.put("one", 1);
  }
}

------------------------------------------------------------
OCL File:
---------
class DataCollection {
   operation process() : void
  pre: true
  post: true
  activity: (     var numbersSet : Set ; numbersSet := Set{} ;
     var setIterator : OclIterator ; setIterator := numbersSet->iterator() ;
    var stringEnum : OclIterator ; stringEnum := OclIterator.newOclIterator_String("another string example") ;
    var firstElement : OclAny ; firstElement := stringEnum.next() ;
    var vector : Sequence ; vector := Sequence{}->union(numbersSet) ;
    stringEnum := vector->iterator() ; 
    stringEnum := OclIterator.newOclIterator_Set(numbersSet) ; 
    var numberList : Sequence ; numberList := Sequence{}->union(numbersSet) ;
    var listIterator : OclIterator ; listIterator := numberList.subrange(3+1)->iterator() ;
    var sampleMap : Map(String,int) ; sampleMap := Map{} ;
    sampleMap := sampleMap->union(Map{"one" |-> 1}) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Container<@Marker E extends @Marker BaseClass> 
{
 int exampleValue = 42;
 String exampleString = "Example";
}

------------------------------------------------------------
OCL File:
---------
class Container<E> {
   attribute exampleValue : int := 42;
   attribute exampleString : String := "Example";
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Box<@Label U extends @Label BaseClass & List> 
{
  int quantity = 100;
  String description = "Sample Description";
  double price = 99.99;
}

------------------------------------------------------------
OCL File:
---------
class Box<U> {
   attribute quantity : int := 100;
   attribute description : String := "Sample Description";
   attribute price : double := 99.99;
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.List;
class Item {
    private double price;
    public Item(double price) {
        this.price = price;
    }
    public double getPrice() {
        return price;
    }
}
class Shopper {
    private List<Item> items;
    public Shopper(List<Item> items) {
        this.items = items;
    }
    public List<Item> getItems() {
        return items;
    }
}
class Calculation {
    public static void calculateTotal(Shopper shopper) {
        double totalCost = 0.0;
        double additionalFee = 5.0;
        totalCost = shopper.getItems().stream()
                           .mapToDouble(Item::getPrice)
                           .sum();
        totalCost += additionalFee;
        System.out.println("Total Cost including fee: " + totalCost);
    }
    public static void main(String[] args) {
        Item item1 = new Item(15.0);
        Item item2 = new Item(25.0);
        Shopper shopper = new Shopper(List.of(item1, item2, item3));
        calculateTotal(shopper);
    }
}

------------------------------------------------------------
OCL File:
---------
 class Item {
   attribute price : double;
   static operation newItem( price : double) : Item
  pre: true
  post: true
  activity:
  ( var self : Item ;
    self := createItem();
    self.initialise(price);
    return self );
  operation initialise( price : double) : void
  pre: true  post: true
  activity: (     self.price := price );
   operation getPrice() : double
  pre: true
  post: true
  activity: (     return price );
}
class Shopper {
   attribute items : Sequence(Item);
   static operation newShopper( items : Sequence(Item)) : Shopper
  pre: true
  post: true
  activity:
  ( var self : Shopper ;
    self := createShopper();
    self.initialise(items);
    return self );
  operation initialise( items : Sequence(Item)) : void
  pre: true  post: true
  activity: (     self.items := items );
   operation getItems() : Sequence(Item)
  pre: true
  post: true
  activity: (     return items );
}
class Calculation {
  static   operation calculateTotal( shopper : Shopper) : void
  pre: true
  post: true
  activity: (     var totalCost : double ; totalCost := 0.0 ;
     var additionalFee : double ; additionalFee := 5.0 ;
    totalCost := shopper.getItems()->collect( _x1 | (lambda _pars : OclAny in Item.newItem().getPrice(_pars))->apply(_x1) )->sum() ; 
    totalCost := totalCost+(additionalFee) ; 
    OclFile["System.out"].println("Total Cost including fee: " + totalCost) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var item1 : Item ; item1 := Item.newItem(15.0) ;
     var item2 : Item ; item2 := Item.newItem(25.0) ;
     var shopper : Shopper ; shopper := Shopper.newShopper(List.of(item1, item2, item3)) ;
     execute calculateTotal(shopper) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class QueueTest {
    public void execute() 
    {
     Deque<String> queue = new LinkedList<String>();
     queue.offerLast("item1");
     queue.addFirst("item2");
     queue.addFirst("item3");
     int counter = 5;
     double rate = 2.5;
     for (int j = 0; j < queue.size(); j++) 
     {
        System.out.println(queue.pollLast());
     }
    }
}

------------------------------------------------------------
OCL File:
---------
class QueueTest {
   operation execute() : void
  pre: true
  post: true
  activity: (     var queue : Sequence(String) ; queue := Sequence{} ;
     queue := queue->append("item1") ; 
    queue := queue->prepend("item2") ; 
    queue := queue->prepend("item3") ; 
    var counter : int ; counter := 5 ;
    var rate : double ; rate := 2.5 ;
        var j : int ; j := 0 ; while j < queue->size() do ( (     OclFile["System.out"].println(queue->last()) )  ;     j := j + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
enum Shades { crimson, amber, emerald, azure, indigo }
class ColorManager {
    public EnumSet getComplement() {
        return EnumSet.complementOf(EnumSet.range(Shades.emerald, Shades.indigo));
    }
    public EnumSet getSubset() {
        return EnumSet.of(Shades.crimson, Shades.emerald, Shades.azure);
    }
    public EnumSet getRange() {
        return EnumSet.copyOf(EnumSet.range(Shades.amber, Shades.azure));
    }
}

------------------------------------------------------------
OCL File:
---------
  enumeration Shades {  literal crimson;  literal amber;  literal emerald;  literal azure;  literal indigo }
 class ColorManager {
   operation getComplement() : Set
  pre: true
  post: true
  activity: (     return (((Shades.emerald->oclType()).allInstances()->select(_x | _x >= Shades.emerald & _x <= Shades.indigo)->any()->oclType()).allInstances() - (Shades.emerald->oclType()).allInstances()->select(_x | _x >= Shades.emerald & _x <= Shades.indigo)) );
   operation getSubset() : Set
  pre: true
  post: true
  activity: (     return Set{Shades.crimson, Shades.emerald, Shades.azure} );
   operation getRange() : Set
  pre: true
  post: true
  activity: (     return ((Shades.amber->oclType()).allInstances()->select(_x | _x >= Shades.amber & _x <= Shades.azure))->copy() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
enum Hues { magenta, cyan, yellow, black, white }
class ColorUtils {
    public int getSize() {
        return Hues.values().length;
    }
    public EnumSet getAllHues() {
        return EnumSet.allOf(Hues.class);
    }
    public EnumSet getRangeHues() {
        return EnumSet.range(Hues.cyan, Hues.black);
    }
}

------------------------------------------------------------
OCL File:
---------
  enumeration Hues {  literal magenta;  literal cyan;  literal yellow;  literal black;  literal white }
 class ColorUtils {
   operation getSize() : int
  pre: true
  post: true
  activity: (     return Hues.allInstances()->size() );
   operation getAllHues() : Set
  pre: true
  post: true
  activity: (     return OclType["Hues"].allInstances() );
   operation getRangeHues() : Set
  pre: true
  post: true
  activity: (     return (Hues.cyan->oclType()).allInstances()->select(_x | _x >= Hues.cyan & _x <= Hues.black) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileReader;
import java.text.SimpleDateFormat;
import java.util.*;
import java.sql.*;
class DataImporter {
    public void process() throws Exception {
        CSVReader csvReader = new CSVReader(new FileReader("financial_records.csv"));
        List<String[]> records = csvReader.readAll();
        SimpleDateFormat formatter = new SimpleDateFormat("MM-dd-yyyy");
        List<Payment> payments = new ArrayList<>();
        String fileName = "financial_records.csv";
        int recordCount = 0;
        double totalAmount = 0.0;
        for (String[] record : records) {
            Date date = formatter.parse(record[0]);
            Payment payment = new Payment(date, record[1], Double.parseDouble(record[2]));
            payments.add(payment);
            recordCount++;
            totalAmount += payment.getAmount();
        }
        Connection dbConnection = DriverManager.getConnection("jdbc:postgresql://localhost:5432/testdb", "admin", "admin123");
        String insertQuery = "INSERT INTO payments (transaction_date, description, amount) VALUES (?, ?, ?)";
        PreparedStatement pstmt = dbConnection.prepareStatement(insertQuery);
        for (Payment payment : payments) {
            pstmt.setDate(1, new java.sql.Date(payment.getDate().getTime()));
            pstmt.setString(2, payment.getDescription());
            pstmt.setDouble(3, payment.getAmount());
            pstmt.executeUpdate();
        }
        pstmt.close();
        dbConnection.close();
        System.out.println("Processed " + recordCount + " records with a total amount of $" + totalAmount);
    }
}

------------------------------------------------------------
OCL File:
---------
 class DataImporter {
   operation process() : void
  pre: true
  post: true
  activity: (     var csvReader : CSVReader ; csvReader := CSVReader.newCSVReader(OclFile.newOclFile_Read(OclFile.newOclFile("financial_records.csv"))) ;
     var records : Sequence(Sequence(String)) ; records := csvReader.readAll() ;
    var formatter : SimpleDateFormat ; formatter := SimpleDateFormat.newSimpleDateFormat("MM-dd-yyyy") ;
    var payments : Sequence(Payment) ; payments := Sequence{} ;
    var fileName : String ; fileName := "financial_records.csv" ;
    var recordCount : int ; recordCount := 0 ;
    var totalAmount : double ; totalAmount := 0.0 ;
    for (record : records) do ( (     var date : OclDate ; date := formatter.parse(record[0+1]) ;
     var payment : Payment ; payment := Payment.newPayment(date, record[1+1], (record[2+1])->toReal()) ;
    payments := payments->including(payment) ; 
    recordCount := recordCount + 1 ; 
    totalAmount := totalAmount+(payment.getAmount()) ; 
 )  ) ; 
    var dbConnection : OclDatasource ; dbConnection := DriverManager.getConnection("jdbc:postgresql://localhost:5432/testdb", "admin", "admin123") ;
    var insertQuery : String ; insertQuery := "INSERT INTO payments (transaction_date, description, amount) VALUES (?, ?, ?)" ;
    var pstmt : SQLStatement ; pstmt := dbConnection.prepareStatement(insertQuery) ;
    for (payment : payments) do ( (     pstmt.setDate(1, Date.newDate(payment.getDate().getTime())) ; 
     pstmt.setString(2, payment.getDescription()) ; 
     pstmt.setDouble(3, payment.getAmount()) ; 
     pstmt.executeUpdate() )  ) ; 
    pstmt.close() ; 
    dbConnection.close() ; 
    OclFile["System.out"].println("Processed " + recordCount + " records with a total amount of $" + totalAmount) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Processor {
    void execute() {
        int value = 10;
        int increment = 5;
        int multiplier = 2;
        int limit = 100;
        int totalSum = 0;
        loopStart: {
            value += increment;
            totalSum += value;
            value *= multiplier;
            if (value > limit) {
                break loopStart;
            }
            continue loopStart;
        }
        double average = (double) totalSum / 2;
        String status = "Completed";
        System.out.println("Final Value: " + value);
        System.out.println("Total Sum: " + totalSum);
        System.out.println("Average: " + average);
        System.out.println("Status: " + status);
    }
}

------------------------------------------------------------
OCL File:
---------
class Processor {
   operation execute() : void
  pre: true
  post: true
  activity: (     var value : int ; value := 10 ;
     var increment : int ; increment := 5 ;
    var multiplier : int ; multiplier := 2 ;
    var limit : int ; limit := 100 ;
    var totalSum : int ; totalSum := 0 ;
(     value := value+(increment) ; 
     totalSum := totalSum+(value) ; 
    value := value*(multiplier) ; 
    if (value > limit) then (     break ) else skip ; 
    continue 
 ) 
    var average : double ; average := totalSum->oclAsType(double) / 2 ;
    var status : String ; status := "Completed" ;
    OclFile["System.out"].println("Final Value: " + value) ; 
    OclFile["System.out"].println("Total Sum: " + totalSum) ; 
    OclFile["System.out"].println("Average: " + average) ; 
    OclFile["System.out"].println("Status: " + status) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class hhhh {
    public boolean stOp() {
        String rr = "asasa sddsds dsdsds";
        String ss3 = "exam";
        String hhhh1 = "asd asd asd";
        boolean b = rr.matches("[a-z]+");
        ooo = rr.regionMatches(5, ss3, 0, 4);
        String s2 = ss.replace('u', '%');
        sss2 = rr.replaceAll("[a-z]+", "+");
        String[] sq = rr.split(" ");
        return rr.startsWith("asasa");
    }
}

------------------------------------------------------------
OCL File:
---------
class hhhh {
   operation stOp() : boolean
  pre: true
  post: true
  activity: (     var rr : String ; rr := "asasa sddsds dsdsds" ;
     var ss3 : String ; ss3 := "exam" ;
    var hhhh1 : String ; hhhh1 := "asd asd asd" ;
    var b : boolean ; b := rr->isMatch("[a-z]+") ;
    ooo := rr.subrange(5+1,5+4) = ss3.subrange(0+1,0+4) ; 
    var s2 : String ; s2 := ss.replace('u', '%') ;
    sss2 := rr.replaceAllMatches("[a-z]+", "+" ) ; 
    var sq : Sequence(String) ; sq := rr->split(" ") ;
    return rr->hasPrefix("asasa") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class aaaaa {
    public void fffff() {
        outerLoop:
        for (String item : itemsList) {
            char[] characters = item.toCharArray();
            for (char character : characters) {
                if (character == '-') {
                    continue outerLoop;
                }
                handleCharacter(character);
            }
        }
        int itemCount = 0;
        double averageLength = 0.0;
        String status = "Processing completed";
    }
    private void handleCharacter(char character) {
        // Placeholder for character processing logic
    }
}

------------------------------------------------------------
OCL File:
---------
class aaaaa {
   operation fffff() : void
  pre: true
  post: true
  activity: (     for (item : itemsList) do ( (     var characters : Sequence(String) ; characters := item->characters() ;
     for (character : characters) do ( (     if (character = '-') then (     continue ) else skip ; 
     execute handleCharacter(character) )  ) )  ) ; 
     var itemCount : int ; itemCount := 0 ;
     var averageLength : double ; averageLength := 0.0 ;
     var status : String ; status := "Processing completed" );
   operation handleCharacter( character : String) : void
  pre: true
  post: true
  activity: skip;
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Wrapper
{ 
  int y = 5;
  double z = 2.5;
  String name = "example";
  class Contained
  { 
    int calculate() 
    { 
      return y * 15; 
    }
  }
}

------------------------------------------------------------
OCL File:
---------
class Wrapper {
   attribute y : int := 5;
   attribute z : double := 2.5;
   attribute name : String := "example";
 class Contained {
   operation calculate() : int
  pre: true
  post: true
  activity: (     return y * 15 );
}
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
class NetworkHandler
{ 
  public String retrieveContent(String urlString)
  { 
    String data = ""; 
    String additionalData = "Extra data for testing"; 
    URL url = new URL(urlString); 
    HttpURLConnection connection = (HttpURLConnection) url.openConnection(); 
    connection.setRequestMethod("GET"); 
    connection.connect(); 
    InputStream input = connection.getInputStream(); 
    BufferedReader reader = new BufferedReader(new InputStreamReader(input)); 
    String responseLine = reader.readLine(); 
    while (responseLine != null) 
    { 
      data += responseLine; 
      responseLine = reader.readLine(); 
    } 
    String result = data + additionalData;
    return result; 
  } 
}

------------------------------------------------------------
OCL File:
---------
 class NetworkHandler {
   operation retrieveContent( urlString : String) : String
  pre: true
  post: true
  activity: (     var data : String ; data := "" ;
     var additionalData : String ; additionalData := "Extra data for testing" ;
    var url : OclDatasource ; url := OclDatasource.newURL(urlString) ;
    var connection : OclDatasource ; connection := url.openConnection()->oclAsType(OclDatasource) ;
    connection.setRequestMethod("GET") ; 
    connection.connect() ; 
    var input : OclFile ; input := connection.getInputStream() ;
    var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(input)) ;
    var responseLine : String ; responseLine := reader.readLine() ;
    while (responseLine /= null) do (     data := data+(responseLine) ; 
     responseLine := reader.readLine() ) ; 
    var result : String ; result := data + additionalData ;
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class AuthorViewer
{ 
  static final String DATABASE_URL = "jdbc:mysql://localhost/library"; 
  public static void connectToDB()
  { 
    Connection connection = null; 
    Statement statement = null; 
    ResultSet resultSet = null; 
    String additionalInfo = "Fetching data from authors table"; 
    try { 
      connection = DriverManager.getConnection(DATABASE_URL, "admin", "1234"); 
      statement = connection.createStatement(); 
      resultSet = statement.executeQuery("SELECT AuthorID, FirstName, LastName FROM Authors"); 
      while (resultSet.next())
      { 
        System.out.println(resultSet.getString("FirstName") + " " + resultSet.getString("LastName")); 
      } 
    } catch (SQLException sqlException) { 
      sqlException.printStackTrace(); 
    } 
    finally 
    { 
      try {
        if (resultSet != null) resultSet.close();
        if (statement != null) statement.close();
        if (connection != null) connection.close();
      } catch (SQLException e) {
        e.printStackTrace();
      }
    } 
  }
}

------------------------------------------------------------
OCL File:
---------
 class AuthorViewer {
  static    attribute DATABASE_URL : String := "jdbc:mysql://localhost/library";
  static   operation connectToDB() : void
  pre: true
  post: true
  activity: (     var connection : OclDatasource ; connection := null ;
     var statement : SQLStatement ; statement := null ;
    var resultSet : OclIterator ; resultSet := null ;
    var additionalInfo : String ; additionalInfo := "Fetching data from authors table" ;
    try (     connection := DriverManager.getConnection(DATABASE_URL, "admin", "1234") ; 
     statement := connection.createStatement() ; 
     resultSet := statement.executeQuery("SELECT AuthorID, FirstName, LastName FROM Authors") ; 
     while (resultSet.next()) do (     OclFile["System.out"].println(resultSet.getCurrent()["FirstName"]->oclAsType(String) + " " + resultSet.getCurrent()["LastName"]->oclAsType(String)) ) )   catch (sqlException : IOException) do (     sqlException.printStackTrace() )
   finally (     try (     if (resultSet /= null) then     resultSet.close() ; else skip ; 
     if (statement /= null) then     statement.close() ; else skip ; 
     if (connection /= null) then     connection.close() ; else skip )   catch (e : IOException) do (     e.printStackTrace() )
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class DataProcessor {
  public static void processData() throws Exception { 
    Gson gson = new Gson();
    String data = Files.readString(Paths.get("data_file.json"));
    Type dataType = new TypeToken<List<Client>>() {}.getType();
    List<Client> clientList = gson.fromJson(data, dataType);
    List<ClientReport> reportList = new ArrayList<>();
    for (Client client : clientList) {
      double totalValue = 0;
      int purchaseCount = 0;
      for (Order order : client.getOrders()) {
        totalValue += order.getAmount();
        purchaseCount++;
      }
      reportList.add(new ClientReport(client.getClientName(), totalValue, purchaseCount));
    }
    Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/database", "username", "password123");
    PreparedStatement prepStmt = conn.prepareStatement("INSERT INTO client_reports (client_name, total_value, purchase_count) VALUES (?, ?, ?)");
    for (ClientReport report : reportList) {
      prepStmt.setString(1, report.getClientName());
      prepStmt.setDouble(2, report.getTotalValue());
      prepStmt.setInt(3, report.getPurchaseCount());
      prepStmt.executeUpdate();
    }
    prepStmt.close();
    conn.close();
  }
}
class Client {
  private String clientName;
  private List<Order> orders;
  public String getClientName() {
    return clientName;
  }
  public List<Order> getOrders() {
    return orders;
  }
}
class Order {
  private double amount;
  public double getAmount() {
    return amount;
  }
}
class ClientReport {
  private String clientName;
  private double totalValue;
  private int purchaseCount;
  public ClientReport(String clientName, double totalValue, int purchaseCount) {
    this.clientName = clientName;
    this.totalValue = totalValue;
    this.purchaseCount = purchaseCount;
  }
  public String getClientName() {
    return clientName;
  }
  public double getTotalValue() {
    return totalValue;
  }
  public int getPurchaseCount() {
    return purchaseCount;
  }
}

------------------------------------------------------------
OCL File:
---------
class DataProcessor {
  static   operation processData() : void
  pre: true
  post: true
  activity: (     var gson : Gson ; gson := Gson.newGson() ;
     var data : String ; data := OclFile.newOclFile("data_file.json").readLine() ;
    var dataType : Type ; dataType := TypeToken<Sequence(Client)>.newTypeToken().getType() ;
    var clientList : Sequence(Client) ; clientList := gson.fromJson(data, dataType) ;
    var reportList : Sequence(ClientReport) ; reportList := Sequence{} ;
    for (client : clientList) do ( (     var totalValue : double ; totalValue := 0 ;
     var purchaseCount : int ; purchaseCount := 0 ;
     for (order : client.getOrders()) do ( (     totalValue := totalValue+(order.getAmount()) ; 
     purchaseCount := purchaseCount + 1 )  ) ; 
     reportList := reportList->including(ClientReport.newClientReport(client.getClientName(), totalValue, purchaseCount)) )  ) ; 
    var conn : OclDatasource ; conn := OclDatasource.getConnection("jdbc:mysql://localhost:3306/database", "username", "password123") ;
    var prepStmt : SQLStatement ; prepStmt := conn.prepareStatement("INSERT INTO client_reports (client_name, total_value, purchase_count) VALUES (?, ?, ?)") ;
    for (report : reportList) do ( (     prepStmt.setString(1, report.getClientName()) ; 
     prepStmt.setDouble(2, report.getTotalValue()) ; 
     prepStmt.setInt(3, report.getPurchaseCount()) ; 
     prepStmt.executeUpdate() )  ) ; 
    prepStmt.close() ; 
    conn.close() ; 
 );
}
 class Client {
   attribute clientName : String;
   attribute orders : Sequence(Order);
   operation getClientName() : String
  pre: true
  post: true
  activity: (     return clientName );
   operation getOrders() : Sequence(Order)
  pre: true
  post: true
  activity: (     return orders );
}
class Order {
   attribute amount : double;
   operation getAmount() : double
  pre: true
  post: true
  activity: (     return amount );
}
class ClientReport {
   attribute clientName : String;
   attribute totalValue : double;
   attribute purchaseCount : int;
   static operation newClientReport( clientName : String, totalValue : double, purchaseCount : int) : ClientReport
  pre: true
  post: true
  activity:
  ( var self : ClientReport ;
    self := createClientReport();
    self.initialise(clientName, totalValue,purchaseCount);
    return self );
  operation initialise( clientName : String, totalValue : double, purchaseCount : int) : void
  pre: true  post: true
  activity: (     self.clientName := clientName ; 
     self.totalValue := totalValue ; 
     self.purchaseCount := purchaseCount );
   operation getClientName() : String
  pre: true
  post: true
  activity: (     return clientName );
   operation getTotalValue() : double
  pre: true
  post: true
  activity: (     return totalValue );
   operation getPurchaseCount() : int
  pre: true
  post: true
  activity: (     return purchaseCount );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class MatcherTest
{ private String res; 
  public static void op(String document)
  { 
    int jj=123;
    Pattern xx = Pattern.compile("[0-9]{4}.[0-9]{4}.[0-9]{4}.[0-9]{4}");  
    jj=jj+8;
    Matcher dd = xx.matcher(document); 
    int h;
    boolean ft = dd.find(); 
    h=90;
    if (ft)
    { 
      h=h+9;
      int aa = dd.start();
      h++;
      int bb = dd.end(); 
      res = document.substring(aa,bb); 
      hh--;
    } 
  }   
}

------------------------------------------------------------
OCL File:
---------
class MatcherTest {
   attribute res : String;
  static   operation op( document : String) : void
  pre: true
  post: true
  activity: (     var jj : int ; jj := 123 ;
     var xx : OclRegex ; xx := OclRegex.compile("[0-9]{4}.[0-9]{4}.[0-9]{4}.[0-9]{4}") ;
    jj := jj + 8 ; 
    var dd : OclRegex ; dd := xx.matcher(document) ;
    var h : int ;
    var ft : boolean ; ft := dd.nextMatch() ;
    h := 90 ; 
    if (ft) then (     h := h + 9 ; 
     var aa : int ; aa := dd.start() ;
    h := h + 1 ; 
    var bb : int ; bb := dd.end() ;
    res := document.subrange(aa+1,bb) ; 
    hh := hh - 1 ; 
 ) else skip ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
import java.util.List;
class ListHandler
{ 
  public List manipulateList()
  { 
    List alpha = new ArrayList();
    List beta = alpha;
    beta.add("x");
    beta.add("y");
    String additionalElement = "z";
    beta.add(additionalElement);
    return alpha;
  }
}

------------------------------------------------------------
OCL File:
---------
 class ListHandler {
   operation manipulateList() : Sequence
  pre: true
  post: true
  activity: (     var alpha : Sequence ; alpha := Sequence{} ;
     var beta : Sequence ; beta := alpha ;
    beta := beta->including("x") ; 
    beta := beta->including("y") ; 
    var additionalElement : String ; additionalElement := "z" ;
    beta := beta->including(additionalElement) ; 
    return alpha 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
enum BasicShades { yellow, orange, purple, red }
enum ExtendedShades implements BasicShades { yellow, orange, purple, cyan, magenta, red }

------------------------------------------------------------
OCL File:
---------
  enumeration BasicShades {  literal yellow;  literal orange;  literal purple;  literal red }
   enumeration ExtendedShades {  literal yellow;  literal orange;  literal purple;  literal cyan;  literal magenta;  literal red }

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.function.Function;
class Transformer
{ 
  public String applyTransformation()
  { 
    Function<String, String> transformer = 
      (input) -> { String result = input + "123"; return result; };
    String extraValue = "XYZ";
    return transformer.apply("example") + extraValue;
  }
}

------------------------------------------------------------
OCL File:
---------
 class Transformer {
   operation applyTransformation() : String
  pre: true
  post: true
  activity: (     var transformer : Function<String,String> ; transformer := lambda input : OclAny in (     var result : String ; result := input + "123" ;
     return result ) ;
     var extraValue : String ; extraValue := "XYZ" ;
     return transformer->apply("example") + extraValue );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
public class TextProcessor {
    String filterStrings() {
        ArrayList<String> stringList = new ArrayList<>();
        stringList.add("hello");
        stringList.add("world");
        stringList.add("!");
        stringList.add("z");
        String extraString = "extra extra";
        stringList.add(extraString);
        stringList.removeIf((str) -> (str.length() > 4));
        return stringList + "";
    }
}

------------------------------------------------------------
OCL File:
---------
 class TextProcessor {
   operation filterStrings() : String
  pre: true
  post: true
  activity: (     var stringList : Sequence(String) ; stringList := Sequence{} ;
     stringList := stringList->including("hello") ; 
    stringList := stringList->including("world") ; 
    stringList := stringList->including("!") ; 
    stringList := stringList->including("z") ; 
    var extraString : String ; extraString := "extra extra" ;
    stringList := stringList->including(extraString) ; 
    stringList := stringList->reject( _var | (lambda str : OclAny in (str->size() > 4))->apply(_var) ) ; 
    return stringList + "" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class method1 {
    public String fun_1() {
        String tt = "string string";
        char[] cccc = tt.toCharArray();
        String mm1 = tt.toUpperCase();
        String mm2 = tt.toUpperCase();
        CharSequence cs = tt.subSequence(4, 8);
        mm1 = mm1.toLowerCase();
        mm2 = mm2.toLowerCase();
        return tt.trim();
    }
}

------------------------------------------------------------
OCL File:
---------
class method1 {
   operation fun_1() : String
  pre: true
  post: true
  activity: (     var tt : String ; tt := "string string" ;
     var cccc : Sequence(String) ; cccc := tt->characters() ;
    var mm1 : String ; mm1 := tt->toUpperCase() ;
    var mm2 : String ; mm2 := tt->toUpperCase() ;
    var cs : String ; cs := tt.subrange(4+1,8) ;
    mm1 := mm1->toLowerCase() ; 
    mm2 := mm2->toLowerCase() ; 
    return tt->trim() 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList;
public class ListManager {
    int manageList() {
        LinkedList<String> items = new LinkedList<>();
        boolean isAdded = items.add("apple");
        items.add("banana");
        items.add("cherry");
        items.add("banana2");
        items.addFirst("kiwi");
        items.addLast("mango");
        String firstItem = items.getFirst();
        String lastItem = items.getLast();
        String removedFirst = (String) items.removeFirst();
        String removedLast = (String) items.removeLast();
        String additionalValue = "extra item";
        items.add(additionalValue);
        return items.size();
    }
}

------------------------------------------------------------
OCL File:
---------
 class ListManager {
   operation manageList() : int
  pre: true
  post: true
  activity: (     var items : Sequence(String) ; items := Sequence{} ;
     var isAdded : boolean ; isAdded := items->excludes("apple") ;
    items := items->including("banana") ; 
    items := items->including("cherry") ; 
    items := items->including("banana2") ; 
    items := items->prepend("kiwi") ; 
    items := items->append("mango") ; 
    var firstItem : String ; firstItem := items->first() ;
    var lastItem : String ; lastItem := items->last() ;
    var removedFirst : String ; removedFirst := items->first()->oclAsType(String) ;
    var removedLast : String ; removedLast := items->last()->oclAsType(String) ;
    var additionalValue : String ; additionalValue := "extra item" ;
    items := items->including(additionalValue) ; 
    return items->size() 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList;
import java.util.ListIterator;
public class CollectionProcessor {
    public String processList() { 
        LinkedList<String> elements = new LinkedList<>();
        elements.add("alpha");
        elements.add("beta");
        elements.add("beta5");
        elements.add(0, "gamma");
        ListIterator<String> iterator = elements.listIterator();
        StringBuilder result = new StringBuilder();
        while (iterator.hasNext()) {
            result.append(iterator.next());
        }
        String extraString = " finished";
        result.append(extraString);
        return result.toString();
    }
}

------------------------------------------------------------
OCL File:
---------
 class CollectionProcessor {
   operation processList() : String
  pre: true
  post: true
  activity: (     var elements : Sequence(String) ; elements := Sequence{} ;
     elements := elements->including("alpha") ; 
    elements := elements->including("beta") ; 
    elements := elements->including("beta5") ; 
    elements := elements.insertAt(0+1,"gamma") ; 
    var iterator : ListIterator<String> ; iterator := elements->iterator() ;
    var result : String ; result := StringLib.newString() ;
    while (iterator.hasNext()) do (     result := result + StringLib.newString(iterator.next()) ) ; 
    var extraString : String ; extraString := " finished" ;
    result := result + StringLib.newString(extraString) ; 
    return result+"" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList;
public class ListManipulator {
    public String executeTasks() { 
        LinkedList<String> items = new LinkedList<>();
        items.addLast("dog");
        items.addFirst("cat");
        items.addFirst("bird");
        items.addFirst("Coala");
        String lastItem = items.getLast();
        int index = items.indexOf("Coala");
        lastItem = items.removeFirst();
        items.set(0, "fish");
        String extraValue = " completed";
        items.add(extraValue);
        return items.toString(); 
    }
}

------------------------------------------------------------
OCL File:
---------
 class ListManipulator {
   operation executeTasks() : String
  pre: true
  post: true
  activity: (     var items : Sequence(String) ; items := Sequence{} ;
     items := items->append("dog") ; 
    items := items->prepend("cat") ; 
    items := items->prepend("bird") ; 
    items := items->prepend("Coala") ; 
    var lastItem : String ; lastItem := items->last() ;
    var index : int ; index := items->indexOf("Coala")-1 ;
    lastItem := items->first() ;     items := items->tail() ; 
    items := items.setAt(0+1,"fish") ; 
    var extraValue : String ; extraValue := " completed" ;
    items := items->including(extraValue) ; 
    return items+"" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class NumberProcessor {
    public String executeConversions() { 
        Long number = new Long("0xABCDEF"); 
        number = new Long(12345678); 
        number = Long.decode("12345"); 
        byte byteValue = number.byteValue(); 
        float floatValue = number.floatValue(); 
        long minValue = Long.MIN_VALUE; 
        long maxValue = Long.MAX_VALUE;
        String maxBinaryString = Long.toBinaryString(maxValue); 
        return maxBinaryString; 
    }
}

------------------------------------------------------------
OCL File:
---------
class NumberProcessor {
   operation executeConversions() : String
  pre: true
  post: true
  activity: (     var number : long ; number := ("" + ("0xABCDEF"))->toLong() ;
     number := ("" + (12345678))->toLong() ; 
    number := ("12345")->toLong() ; 
    var byteValue : int ; byteValue := number->oclAsType(int) ;
    var floatValue : double ; floatValue := number->oclAsType(double) ;
    var minValue : long ; minValue := "-9223372036854775808"->toLong() ;
    var maxValue : long ; maxValue := "9223372036854775807"->toLong() ;
    var maxBinaryString : String ; maxBinaryString := (MathLib.decimal2binary(maxValue) + "") ;
    return maxBinaryString 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class CalculationUtils {
    public void executeCalculations() {
        double eulerNumber = Math.E; 
        double piValue = Math.PI; 
        eulerNumber = Math.abs(-500.0); 
        eulerNumber = Math.sin(piValue);  
        double angle = Math.atan(1.0); 
        eulerNumber = Math.exp(50); 
        angle = Math.max(0.2, 0.3); 
        eulerNumber = Math.rint(20.5); 
        eulerNumber = Math.toDegrees(Math.PI); 
        String result = "Calculations complete";
    }
}

------------------------------------------------------------
OCL File:
---------
class CalculationUtils {
   operation executeCalculations() : void
  pre: true
  post: true
  activity: (     var eulerNumber : double ; eulerNumber := 2.718281828459045 ;
     var piValue : double ; piValue := 3.141592653589793 ;
    eulerNumber := if -500.0 < 0 then -(-500.0) else -500.0 endif ; 
    eulerNumber := (piValue)->sin() ; 
    var angle : double ; angle := (1.0)->atan() ;
    eulerNumber := (50)->exp() ; 
    angle := Set{0.2, 0.3}->max() ; 
    eulerNumber := (1.0*((20.5)->round())) ; 
    eulerNumber := (57.29577951308232*(3.141592653589793)) ; 
    var result : String ; result := "Calculations complete" ;
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap;
import java.util.Map;
public class DataOrganizer {
    public void manageData() {
        Map<String, Map<String, String>> nestedMap = new HashMap<>();
        Map<String, String> innerMap1 = new HashMap<>();
        innerMap1.put("one", "apple");
        innerMap1.put("two", "banana");
        innerMap1.put("three", "cherry");
        Map<String, String> innerMap2 = new HashMap<>();
        innerMap2.put("one", "date");
        innerMap2.put("two", "elderberry");
        innerMap2.put("three", "fig");
        nestedMap.put("fruit", innerMap1);
        nestedMap.put("berry", innerMap2);
        nestedMap.put("aaaaa", innerMap2);
        String extraInfo = "Maps populated";
    }
}

------------------------------------------------------------
OCL File:
---------
 class DataOrganizer {
   operation manageData() : void
  pre: true
  post: true
  activity: (     var nestedMap : Map(String,Map(String,String)) ; nestedMap := Map{} ;
     var innerMap1 : Map(String,String) ; innerMap1 := Map{} ;
    innerMap1 := innerMap1->union(Map{"one" |-> "apple"}) ; 
    innerMap1 := innerMap1->union(Map{"two" |-> "banana"}) ; 
    innerMap1 := innerMap1->union(Map{"three" |-> "cherry"}) ; 
    var innerMap2 : Map(String,String) ; innerMap2 := Map{} ;
    innerMap2 := innerMap2->union(Map{"one" |-> "date"}) ; 
    innerMap2 := innerMap2->union(Map{"two" |-> "elderberry"}) ; 
    innerMap2 := innerMap2->union(Map{"three" |-> "fig"}) ; 
    nestedMap := nestedMap->union(Map{"fruit" |-> innerMap1}) ; 
    nestedMap := nestedMap->union(Map{"berry" |-> innerMap2}) ; 
    nestedMap := nestedMap->union(Map{"aaaaa" |-> innerMap2}) ; 
    var extraInfo : String ; extraInfo := "Maps populated" ;
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
interface ActionX {
    void executeX();
}
interface ActionY {
    void executeY();
}
class Handler implements ActionX, ActionY {
    public void executeX() {
        System.out.println("Execute X");
    }
    public void executeY() {
        System.out.println("Execute Y");
    }
}
class Processor {
    public void performAction() {
        ActionX actionX = new Handler();
        ActionY actionY = actionX; 
        actionX.executeX();
        actionY.executeY();
    }
}
class Utility {
    public void displayMessage() {
        System.out.println("Utility class in action.");
    }
}
class Manager {
    public void manage() {
        Utility util = new Utility();
        util.displayMessage();
    }
}
class Coordinator {
    public void coordinate() {
        Manager manager = new Manager();
        manager.manage();
    }
}

------------------------------------------------------------
OCL File:
---------
interface ActionX {
   operation executeX() : void
  pre: true
  post: true;
}
 interface ActionY {
   operation executeY() : void
  pre: true
  post: true;
}
class Handler implements ActionX, ActionY {
   operation executeX() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Execute X") );
   operation executeY() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Execute Y") );
}
class Processor {
   operation performAction() : void
  pre: true
  post: true
  activity: (     var actionX : ActionX ; actionX := Handler.newHandler() ;
     var actionY : ActionY ; actionY := actionX ;
     actionX.executeX() ; 
     actionY.executeY() );
}
class Utility {
   operation displayMessage() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Utility class in action.") );
}
class Manager {
   operation manage() : void
  pre: true
  post: true
  activity: (     var util : Utility ; util := Utility.newUtility() ;
     util.displayMessage() );
}
class Coordinator {
   operation coordinate() : void
  pre: true
  post: true
  activity: (     var manager : Manager ; manager := Manager.newManager() ;
     manager.manage() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.function.Function;
class Processor {
    public void execute() {
        Function<String, String> concatFunction = (input) -> { return input + input; };
        Function<Integer, Integer> cubeFunction = (number) -> { return number * number * number; };
        String resultString = concatFunction.apply("hello");
        Integer resultNumber = cubeFunction.apply(3);
        String additionalMessage = "Operation complete";
    }
}

------------------------------------------------------------
OCL File:
---------
 class Processor {
   operation execute() : void
  pre: true
  post: true
  activity: (     var concatFunction : Function<String,String> ; concatFunction := lambda input : OclAny in (     return input + input ) ;
     var cubeFunction : Function<int,int> ; cubeFunction := lambda number : OclAny in (     return number * number * number ) ;
    var resultString : String ; resultString := concatFunction->apply("hello") ;
    var resultNumber : int ; resultNumber := cubeFunction->apply(3) ;
    var additionalMessage : String ; additionalMessage := "Operation complete" ;
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.function.Function;
class Calculator {
    public void compute() {
        Function<Integer, Integer> signFunction = 
            (number) -> { 
                if (number > 0) {
                    return 1; 
                } else if (number < 0) {
                    return -1; 
                } 
                return 0; 
            };
        int positiveSign = signFunction.apply(42);
        int negativeSign = signFunction.apply(-15);
        int zeroSign = signFunction.apply(0);
        String resultMessage = "Calculation complete";
    }
}

------------------------------------------------------------
OCL File:
---------
 class Calculator {
   operation compute() : void
  pre: true
  post: true
  activity: (     var signFunction : Function<int,int> ; signFunction := lambda number : OclAny in (     if (number > 0) then (     return 1 ) else     if (number < 0) then (     return -1 ) else skip ; ;  
     return 0 ) ;
     var positiveSign : int ; positiveSign := signFunction->apply(42) ;
    var negativeSign : int ; negativeSign := signFunction->apply(-15) ;
    var zeroSign : int ; zeroSign := signFunction->apply(0) ;
    var resultMessage : String ; resultMessage := "Calculation complete" ;
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.function.Function;
class Comparator {
    public void compareValues() {
        Function<Integer, Function<Integer, Integer>> comparisonFunction = 
            (a) -> (b) -> { 
                if (a < b) { 
                    return -1; 
                } else if (a > b) { 
                    return 1; 
                } 
                return 0; 
            };
        Function<Integer, Integer> compareWithTen = comparisonFunction.apply(10);
        int result1 = compareWithTen.apply(5);
        int result2 = compareWithTen.apply(15);
        int result3 = compareWithTen.apply(10);
        String statusMessage = "Comparison completed";
    }
}

------------------------------------------------------------
OCL File:
---------
 class Comparator {
   operation compareValues() : void
  pre: true
  post: true
  activity: (     var comparisonFunction : Function<int,Function<int,int>> ; comparisonFunction := lambda a : OclAny in lambda b : OclAny in (     if (a < b) then (     return -1 ) else     if (a > b) then (     return 1 ) else skip ; ;  
     return 0 ) ;
     var compareWithTen : Function<int,int> ; compareWithTen := comparisonFunction->apply(10) ;
    var result1 : int ; result1 := compareWithTen->apply(5) ;
    var result2 : int ; result2 := compareWithTen->apply(15) ;
    var result3 : int ; result3 := compareWithTen->apply(10) ;
    var statusMessage : String ; statusMessage := "Comparison completed" ;
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class aaa
{
  public void nnnnn()
  { String hhh = "aa"; 
    int i=8;
    String mm = "aabb".substring(0,2); 
    i=i+5; 
    System.out.println(hhh == mm); 
    System.out.println(hhh.equals(mm));  
  } 
}

------------------------------------------------------------
OCL File:
---------
class aaa {
   operation nnnnn() : void
  pre: true
  post: true
  activity: (     var hhh : String ; hhh := "aa" ;
     var i : int ; i := 8 ;
    var mm : String ; mm := "aabb".subrange(0+1,2) ;
    i := i + 5 ; 
    OclFile["System.out"].println(hhh = mm) ; 
    OclFile["System.out"].println(hhh = mm) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class MathOperations {
    public void performCalculations() { 
        int baseValue = 3;
        Object squareFunction = (Integer num) -> (num * num);
        Object productFunction = (x, y) -> (x * x * y);
        Object detailedProductFunction = (int a, int b) -> (a * a * b);
        Integer result1 = ((Function<Integer, Integer>) squareFunction).apply(baseValue);
        Integer result2 = ((BiFunction<Integer, Integer, Integer>) productFunction).apply(4, 5);
        Integer result3 = ((BiFunction<Integer, Integer, Integer>) detailedProductFunction).apply(6, 7);
        String status = "Calculations executed";
    }
}

------------------------------------------------------------
OCL File:
---------
class MathOperations {
   operation performCalculations() : void
  pre: true
  post: true
  activity: (     var baseValue : int ; baseValue := 3 ;
     var squareFunction : OclAny ; squareFunction := lambda  num : int : OclAny in (num * num) ;
    var productFunction : OclAny ; productFunction := lambda (x , y) : OclAny in (x * x * y) ;
    var detailedProductFunction : OclAny ; detailedProductFunction := lambda  a : int, b : int : OclAny in (a * a * b) ;
    var result1 : int ; result1 := (squareFunction->oclAsType(Function<int,int>))->apply(baseValue) ;
    var result2 : int ; result2 := (productFunction->oclAsType(BiFunction<int,int,int>))->apply(4, 5) ;
    var result3 : int ; result3 := (detailedProductFunction->oclAsType(BiFunction<int,int,int>))->apply(6, 7) ;
    var status : String ; status := "Calculations executed" ;
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class OperationDemo {
    public void performOperation() {
        int firstValue = 5;
        int secondValue = 0;
        secondValue = (++firstValue) + (firstValue++);
        int additionalResult = firstValue * secondValue;
        String resultMessage = "Operation executed with new values";
        int xx = firstValue + secondValue;
    }
}

------------------------------------------------------------
OCL File:
---------
class OperationDemo {
   operation performOperation() : void
  pre: true
  post: true
  activity: (     var firstValue : int ; firstValue := 5 ;
     var secondValue : int ; secondValue := 0 ;
        firstValue := firstValue + 1 ;
 secondValue := (firstValue) + (firstValue)  ; firstValue := firstValue + 1 ; 
    var additionalResult : int ; additionalResult := firstValue * secondValue ;
    var resultMessage : String ; resultMessage := "Operation executed with new values" ;
    var xx : int ; xx := firstValue + secondValue ;
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
abstract class Individual {
    String fullName = "";
    public Individual(String name) {
        fullName = name;
    }
    public String getFullName() {
        return fullName;
    }
}
class Member extends Individual {
    String memberId = "1234";
    public Member(String name, String id) {
        super(name);
        memberId = id;
    }
}
class Employee extends Individual {
    int employeeNumber = 100;
    public Employee(String name, int number) {
        super(name);
        employeeNumber = number;
    }
    public void setEmployeeNumber(int number) {
        employeeNumber = number;
    }
}
class Visitor extends Individual {
    String visitorPass = "VP001";
    public Visitor(String name, String pass) {
        super(name);
        visitorPass = pass;
    }
}
class Manager extends Individual {
    int managerId = 200;
    public Manager(String name, int id) {
        super(name);
        managerId = id;
    }
}
class Intern extends Individual {
    String internId = "INT123";
    public Intern(String name, String id) {
        super(name);
        internId = id;
    }
}

------------------------------------------------------------
OCL File:
---------
class Individual {
   attribute fullName : String := "";
   static operation newIndividual( name : String) : Individual
  pre: true
  post: true
  activity:
  ( var self : Individual ;
    self := createIndividual();
    self.initialise(name);
    return self );
  operation initialise( name : String) : void
  pre: true  post: true
  activity: (     fullName := name );
   operation getFullName() : String
  pre: true
  post: true
  activity: (     return fullName );
}
 class Member extends Individual {
   attribute memberId : String := "1234";
   static operation newMember( name : String, id : String) : Member
  pre: true
  post: true
  activity:
  ( var self : Member ;
    self := createMember();
    self.initialise(name, id);
    return self );
  operation initialise( name : String, id : String) : void
  pre: true  post: true
  activity: (     execute super(name) ; 
     memberId := id );
}
class Employee extends Individual {
   attribute employeeNumber : int := 100;
   static operation newEmployee( name : String, number : int) : Employee
  pre: true
  post: true
  activity:
  ( var self : Employee ;
    self := createEmployee();
    self.initialise(name, number);
    return self );
  operation initialise( name : String, number : int) : void
  pre: true  post: true
  activity: (     execute super(name) ; 
     employeeNumber := number );
   operation setEmployeeNumber( number : int) : void
  pre: true
  post: true
  activity: (     employeeNumber := number );
}
class Visitor extends Individual {
   attribute visitorPass : String := "VP001";
   static operation newVisitor( name : String, pass : String) : Visitor
  pre: true
  post: true
  activity:
  ( var self : Visitor ;
    self := createVisitor();
    self.initialise(name, pass);
    return self );
  operation initialise( name : String, pass : String) : void
  pre: true  post: true
  activity: (     execute super(name) ; 
     visitorPass := pass );
}
class Manager extends Individual {
   attribute managerId : int := 200;
   static operation newManager( name : String, id : int) : Manager
  pre: true
  post: true
  activity:
  ( var self : Manager ;
    self := createManager();
    self.initialise(name, id);
    return self );
  operation initialise( name : String, id : int) : void
  pre: true  post: true
  activity: (     execute super(name) ; 
     managerId := id );
}
class Intern extends Individual {
   attribute internId : String := "INT123";
   static operation newIntern( name : String, id : String) : Intern
  pre: true
  post: true
  activity:
  ( var self : Intern ;
    self := createIntern();
    self.initialise(name, id);
    return self );
  operation initialise( name : String, id : String) : void
  pre: true  post: true
  activity: (     execute super(name) ; 
     internId := id );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class SumCalculator {
    public int calculateSum() {
        int[] totalSums = new int[15];
        for (int outer = 0; outer < 15; outer++) {
            for (int inner = 1; inner <= outer; inner++) {
                totalSums[outer] += inner;
            }
        }
        int finalSum = totalSums[14];
        int additionalValue = finalSum * 2;
        return finalSum;
    }
}

------------------------------------------------------------
OCL File:
---------
class SumCalculator {
   operation calculateSum() : int
  pre: true
  post: true
  activity: (     var totalSums : Sequence(int) ; totalSums := Integer.subrange(1,15)->collect(0) ;
         var outer : int ; outer := 0 ; while outer < 15 do ( (         var inner : int ; inner := 1 ; while inner <= outer do ( (     totalSums[outer+1] := totalSums[outer+1]+(inner) )  ;     inner := inner + 1 ) )  ;     outer := outer + 1 ) ; 
    var finalSum : int ; finalSum := totalSums[14+1] ;
    var additionalValue : int ; additionalValue := finalSum * 2 ;
    return finalSum 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class RateCalculator {
    double duration = 0.0;
    double interestRate = 0.0;
    String rateId = "";
    public static double calculateNelsonSiegel(double time, double param1, double param2, double param3, double lambda) {
        double result = 0.0;
        double scaledTime = 0.0;
        scaledTime = time / lambda;
        double expScaledTime = 0.0;
        expScaledTime = Math.exp(-scaledTime);
        double ratio = 0.0;
        ratio = (1 - expScaledTime) / scaledTime;
        result = param1 + param2 * ratio + param3 * (ratio - expScaledTime);
        return result;
    }
    public static double calculateNelsonSiegelSvensson(double time, double param1, double param2, double param3, double param4, double lambda1, double lambda2) {
        double result = 0.0;
        double scaledTime1 = 0.0;
        scaledTime1 = time / lambda1;
        double scaledTime2 = 0.0;
        scaledTime2 = time / lambda2;
        double expScaledTime1 = 0.0;
        expScaledTime1 = Math.exp(-scaledTime1);
        double expScaledTime2 = 0.0;
        expScaledTime2 = Math.exp(-scaledTime2);
        double ratio1 = 0.0;
        ratio1 = (1 - expScaledTime1) / scaledTime1;
        double ratio2 = 0.0;
        ratio2 = (1 - expScaledTime2) / scaledTime2;
        result = param1 + param2 * ratio1 + param3 * (ratio1 - expScaledTime1) + param4 * (ratio2 - expScaledTime2);
        return result;
    }
    public static double computeNS(double time, double param1, double param2, double param3, double lambda) {
        double result = 0.0;
        if (time == 0) {
            result = param1 + param2;
        } else {
            if (time > 0) {
                result = RateCalculator.calculateNelsonSiegel(time, param1, param2, param3, lambda);
            } else {
                System.out.println("Negative time value");
            }
        }
        return result;
    }
    public static double computeNSS(double time, double param1, double param2, double param3, double param4, double lambda1, double lambda2) {
        double result = 0.0;
        if (time == 0) {
            result = param1 + param2;
        } else {
            if (time > 0) {
                result = RateCalculator.calculateNelsonSiegelSvensson(time, param1, param2, param3, param4, lambda1, lambda2);
            } else {
                System.out.println("Negative time value");
            }
        }
        return result;
    }
    public static void main(String[] args) {
        RateCalculator calculator = new RateCalculator();
        double nelsonSiegelResult = calculator.computeNS(5, 0.02, 0.03, 0.04, 1.5);
        double nelsonSiegelSvenssonResult = calculator.computeNSS(5, 0.02, 0.03, 0.04, 0.05, 1.5, 2.0);
        System.out.println("Nelson-Siegel Result: " + nelsonSiegelResult);
        System.out.println("Nelson-Siegel-Svensson Result: " + nelsonSiegelSvenssonResult);
    }
}

------------------------------------------------------------
OCL File:
---------
 class RateCalculator {
   attribute duration : double := 0.0;
   attribute interestRate : double := 0.0;
   attribute rateId : String := "";
  static   operation calculateNelsonSiegel( time : double, param1 : double, param2 : double, param3 : double, lambda : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0.0 ;
     var scaledTime : double ; scaledTime := 0.0 ;
    scaledTime := time / lambda ; 
    var expScaledTime : double ; expScaledTime := 0.0 ;
    expScaledTime := (-scaledTime)->exp() ; 
    var ratio : double ; ratio := 0.0 ;
    ratio := (1 - expScaledTime) / scaledTime ; 
    result := param1 + param2 * ratio + param3 * (ratio - expScaledTime) ; 
    return result 
 );
  static   operation calculateNelsonSiegelSvensson( time : double, param1 : double, param2 : double, param3 : double, param4 : double, lambda1 : double, lambda2 : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0.0 ;
     var scaledTime1 : double ; scaledTime1 := 0.0 ;
    scaledTime1 := time / lambda1 ; 
    var scaledTime2 : double ; scaledTime2 := 0.0 ;
    scaledTime2 := time / lambda2 ; 
    var expScaledTime1 : double ; expScaledTime1 := 0.0 ;
    expScaledTime1 := (-scaledTime1)->exp() ; 
    var expScaledTime2 : double ; expScaledTime2 := 0.0 ;
    expScaledTime2 := (-scaledTime2)->exp() ; 
    var ratio1 : double ; ratio1 := 0.0 ;
    ratio1 := (1 - expScaledTime1) / scaledTime1 ; 
    var ratio2 : double ; ratio2 := 0.0 ;
    ratio2 := (1 - expScaledTime2) / scaledTime2 ; 
    result := param1 + param2 * ratio1 + param3 * (ratio1 - expScaledTime1) + param4 * (ratio2 - expScaledTime2) ; 
    return result 
 );
  static   operation computeNS( time : double, param1 : double, param2 : double, param3 : double, lambda : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0.0 ;
     if (time = 0) then (     result := param1 + param2 ) else (     if (time > 0) then (     result := RateCalculator.calculateNelsonSiegel(time, param1, param2, param3, lambda) ) else (     OclFile["System.out"].println("Negative time value") ) ) ;  
     return result );
  static   operation computeNSS( time : double, param1 : double, param2 : double, param3 : double, param4 : double, lambda1 : double, lambda2 : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0.0 ;
     if (time = 0) then (     result := param1 + param2 ) else (     if (time > 0) then (     result := RateCalculator.calculateNelsonSiegelSvensson(time, param1, param2, param3, param4, lambda1, lambda2) ) else (     OclFile["System.out"].println("Negative time value") ) ) ;  
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var calculator : RateCalculator ; calculator := RateCalculator.newRateCalculator() ;
     var nelsonSiegelResult : double ; nelsonSiegelResult := calculator.computeNS(5, 0.02, 0.03, 0.04, 1.5) ;
    var nelsonSiegelSvenssonResult : double ; nelsonSiegelSvenssonResult := calculator.computeNSS(5, 0.02, 0.03, 0.04, 0.05, 1.5, 2.0) ;
    OclFile["System.out"].println("Nelson-Siegel Result: " + nelsonSiegelResult) ; 
    OclFile["System.out"].println("Nelson-Siegel-Svensson Result: " + nelsonSiegelSvenssonResult) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Individual implements Serializable {
    String fullName = "";
    double years = 0.0;
    String address = "unknown";
    public Individual(String name, double age, String addr) {
        fullName = name;
        years = age;
        address = addr;
    }
}
class ObjectReader {
    void loadObject() throws IOException, ClassNotFoundException {
        ObjectInputStream objStream = new ObjectInputStream(new FileInputStream("input.dat"));
        Individual ind = (Individual) objStream.readObject();
        System.out.println(ind.fullName + " " + ind.years + " " + ind.address);
        objStream.close();
    }
    public static void main(String[] args) {
        try {
            ObjectReader reader = new ObjectReader();
            reader.loadObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

------------------------------------------------------------
OCL File:
---------
 class Individual implements OclAny {
   attribute fullName : String := "";
   attribute years : double := 0.0;
   attribute address : String := "unknown";
   static operation newIndividual( name : String, age : double, addr : String) : Individual
  pre: true
  post: true
  activity:
  ( var self : Individual ;
    self := createIndividual();
    self.initialise(name, age,addr);
    return self );
  operation initialise( name : String, age : double, addr : String) : void
  pre: true  post: true
  activity: (     fullName := name ; 
     years := age ; 
     address := addr );
}
class ObjectReader {
   operation loadObject() : void
  pre: true
  post: true
  activity: (     var objStream : OclFile ; objStream := OclFile.newOclFile_ReadB(OclFile.newOclFile_Read(OclFile.newOclFile("input.dat"))) ;
     var ind : Individual ; ind := objStream.readObject()->oclAsType(Individual) ;
     OclFile["System.out"].println(ind.fullName + " " + ind.years + " " + ind.address) ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var reader : ObjectReader ; reader := ObjectReader.newObjectReader() ;
     reader.loadObject() )   catch (e : OclException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Human implements Serializable
{ 
  String identifier = "";
  double years = 0.0;
  public Human(String id, double yr)
  { 
    identifier = id; 
    years = yr; 
  }
}
class SaveObject
{ 
  void saveToFile()
  { 
    Human individual = new Human("Alice", 30);
    ObjectOutputStream outStream = new ObjectOutputStream(new FileOutputStream("output.bin"));
    outStream.writeObject(individual);
    outStream.close();
  }
}
class AdditionalClass
{ 
  void displayMessage()
  { 
    System.out.println("This is an additional method with new functionality.");
  }
}
public class MainClass
{
  public static void main(String[] args)
  {
    SaveObject saver = new SaveObject();
    saver.saveToFile();
    AdditionalClass additional = new AdditionalClass();
    additional.displayMessage();
  }
}

------------------------------------------------------------
OCL File:
---------
 class Human implements OclAny {
   attribute identifier : String := "";
   attribute years : double := 0.0;
   static operation newHuman( id : String, yr : double) : Human
  pre: true
  post: true
  activity:
  ( var self : Human ;
    self := createHuman();
    self.initialise(id, yr);
    return self );
  operation initialise( id : String, yr : double) : void
  pre: true  post: true
  activity: (     identifier := id ; 
     years := yr );
}
class SaveObject {
   operation saveToFile() : void
  pre: true
  post: true
  activity: (     var individual : Human ; individual := Human.newHuman("Alice", 30) ;
     var outStream : OclFile ; outStream := OclFile.newOclFile_WriteB(OclFile.newOclFile(OclFile.newOclFile_Write(OclFile.newOclFile("output.bin")))) ;
     skip ; 
     skip );
}
class AdditionalClass {
   operation displayMessage() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("This is an additional method with new functionality.") );
}
class MainClass {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var saver : SaveObject ; saver := SaveObject.newSaveObject() ;
     saver.saveToFile() ; 
     var additional : AdditionalClass ; additional := AdditionalClass.newAdditionalClass() ;
     additional.displayMessage() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class EntityHandler {
    public boolean processEntity() {
        Object entity1 = "text data"; 
        Object entity2 = new Object(); 
        entity2 = (String) entity1.toString(); 
        entity1.hashCode(); 
        Class cls = entity2.getClass(); 
        try {
            entity2.wait(500); 
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return entity2.equals(null); 
    }
}
class MainProcess {
    public static void main(String[] args) {
        EntityHandler handler = new EntityHandler();
        boolean result = handler.processEntity();
        System.out.println("Processing result: " + result);
    }
}

------------------------------------------------------------
OCL File:
---------
class EntityHandler {
   operation processEntity() : boolean
  pre: true
  post: true
  activity: (     var entity1 : OclAny ; entity1 := "text data" ;
     var entity2 : OclAny ; entity2 := Map{} ;
    entity2 := entity1+""->oclAsType(String) ; 
    entity1.hashCode() ; 
    var cls : OclType ; cls := entity2->oclType() ;
    try (     entity2.wait(500) )   catch (e : ProgramException) do (     e.printStackTrace() )
    return entity2 = null 
 );
}
 class MainProcess {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var handler : EntityHandler ; handler := EntityHandler.newEntityHandler() ;
     var result : boolean ; result := handler.processEntity() ;
     OclFile["System.out"].println("Processing result: " + result) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Individual {
    String identifier = "";
    int years = 0;
    public Individual(String id) {
        identifier = id;
    }
    public int celebrateBirthday() {
        ++years;
        return years;
    }
}
class Learner extends Individual {
    String course = "";
    public Learner(String id, String subject) {
        super(id);
        course = subject;
    }
}
class Worker extends Individual {
    String profession = "";
    public Worker(String id, String job) {
        super(id);
        profession = job;
    }
}
class ObjectHandler {
    public boolean modifyObject() {
        Object obj1 = "example text"; 
        Object obj2 = new Object(); 
        obj2 = (String) obj1.toString(); 
        obj1.hashCode(); 
        Class cls = obj2.getClass(); 
        try {
            obj2.wait(200); 
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return obj2.equals(null); 
    }
}
class MainOperation {
    public static void main(String[] args) {
        ObjectHandler handler = new ObjectHandler();
        boolean result = handler.modifyObject();
        System.out.println("Modification result: " + result);
        Individual individual = new Individual("John");
        individual.celebrateBirthday();
        Learner learner = new Learner("Alice", "Physics");
        Worker worker = new Worker("Bob", "Engineer");
        System.out.println("Individual: " + individual.identifier + ", Age: " + individual.years);
        System.out.println("Learner: " + learner.identifier + ", Course: " + learner.course);
        System.out.println("Worker: " + worker.identifier + ", Profession: " + worker.profession);
    }
}

------------------------------------------------------------
OCL File:
---------
class Individual {
   attribute identifier : String := "";
   attribute years : int := 0;
   static operation newIndividual( id : String) : Individual
  pre: true
  post: true
  activity:
  ( var self : Individual ;
    self := createIndividual();
    self.initialise(id);
    return self );
  operation initialise( id : String) : void
  pre: true  post: true
  activity: (     identifier := id );
   operation celebrateBirthday() : int
  pre: true
  post: true
  activity: (     years := years + 1 ; 
     return years );
}
 class Learner extends Individual {
   attribute course : String := "";
   static operation newLearner( id : String, subject : String) : Learner
  pre: true
  post: true
  activity:
  ( var self : Learner ;
    self := createLearner();
    self.initialise(id, subject);
    return self );
  operation initialise( id : String, subject : String) : void
  pre: true  post: true
  activity: (     execute super(id) ; 
     course := subject );
}
class Worker extends Individual {
   attribute profession : String := "";
   static operation newWorker( id : String, job : String) : Worker
  pre: true
  post: true
  activity:
  ( var self : Worker ;
    self := createWorker();
    self.initialise(id, job);
    return self );
  operation initialise( id : String, job : String) : void
  pre: true  post: true
  activity: (     execute super(id) ; 
     profession := job );
}
class ObjectHandler {
   operation modifyObject() : boolean
  pre: true
  post: true
  activity: (     var obj1 : OclAny ; obj1 := "example text" ;
     var obj2 : OclAny ; obj2 := Map{} ;
    obj2 := obj1+""->oclAsType(String) ; 
    obj1.hashCode() ; 
    var cls : OclType ; cls := obj2->oclType() ;
    try (     obj2.wait(200) )   catch (e : ProgramException) do (     e.printStackTrace() )
    return obj2 = null 
 );
}
class MainOperation {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var handler : ObjectHandler ; handler := ObjectHandler.newObjectHandler() ;
     var result : boolean ; result := handler.modifyObject() ;
    OclFile["System.out"].println("Modification result: " + result) ; 
    var individual : Individual ; individual := Individual.newIndividual("John") ;
    individual.celebrateBirthday() ; 
    var learner : Learner ; learner := Learner.newLearner("Alice", "Physics") ;
    var worker : Worker ; worker := Worker.newWorker("Bob", "Engineer") ;
    OclFile["System.out"].println("Individual: " + individual.identifier + ", Age: " + individual.years) ; 
    OclFile["System.out"].println("Learner: " + learner.identifier + ", Course: " + learner.course) ; 
    OclFile["System.out"].println("Worker: " + worker.identifier + ", Profession: " + worker.profession) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package p2;
interface OperationA {
    int executeA();
    double executeB();
}
interface OperationB {
    String performA();
    boolean performB();
}
class Alpha implements OperationA {
    int executeA() {
        return 10;
    }
    double executeB() {
        return 20.5;
    }
}
class Beta implements OperationA {
    int executeA() {
        return 30;
    }
    double executeB() {
        return 40.75;
    }
}
class Gamma implements OperationB {
    String performA() {
        return "Hello";
    }
    boolean performB() {
        return true;
    }
}
class Delta implements OperationB {
    String performA() {
        return "World";
    }
    boolean performB() {
        return false;
    }
}
class Entity {
    String id = "";
    int count = 0;
    public Entity(String identifier) {
        id = identifier;
    }
    public int incrementCount() {
        ++count;
        return count;
    }
}
class Scholar extends Entity {
    String subject = "";
    public Scholar(String identifier, String field) {
        super(identifier);
        subject = field;
    }
}
class Professional extends Entity {
    String occupation = "";
    public Professional(String identifier, String job) {
        super(identifier);
        occupation = job;
    }
}
class ObjectManipulator {
    public boolean handleObject() {
        Object data1 = "sample text"; 
        Object data2 = new Object(); 
        data2 = (String) data1.toString(); 
        data1.hashCode(); 
        Class cls = data2.getClass(); 
        try {
            data2.wait(250); 
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return data2.equals(null); 
    }
}
class CoreOperation {
    public static void main(String[] args) {
        ObjectManipulator manipulator = new ObjectManipulator();
        boolean result = manipulator.handleObject();
        System.out.println("Handle result: " + result);
        Entity entity = new Entity("Michael");
        entity.incrementCount();
        Scholar scholar = new Scholar("Eve", "Mathematics");
        Professional professional = new Professional("Adam", "Architect");
        System.out.println("Entity: " + entity.id + ", Count: " + entity.count);
        System.out.println("Scholar: " + scholar.id + ", Subject: " + scholar.subject);
        System.out.println("Professional: " + professional.id + ", Occupation: " + professional.occupation);
        Alpha alpha = new Alpha();
        Beta beta = new Beta();
        Gamma gamma = new Gamma();
        Delta delta = new Delta();
        System.out.println("Alpha: " + alpha.executeA() + ", " + alpha.executeB());
        System.out.println("Beta: " + beta.executeA() + ", " + beta.executeB());
        System.out.println("Gamma: " + gamma.performA() + ", " + gamma.performB());
        System.out.println("Delta: " + delta.performA() + ", " + delta.performB());
    }
}

------------------------------------------------------------
OCL File:
---------
 interface OperationA {
   operation executeA() : int
  pre: true
  post: true;
   operation executeB() : double
  pre: true
  post: true;
}
interface OperationB {
   operation performA() : String
  pre: true
  post: true;
   operation performB() : boolean
  pre: true
  post: true;
}
class Alpha implements OperationA {
   operation executeA() : int
  pre: true
  post: true
  activity: (     return 10 );
   operation executeB() : double
  pre: true
  post: true
  activity: (     return 20.5 );
}
class Beta implements OperationA {
   operation executeA() : int
  pre: true
  post: true
  activity: (     return 30 );
   operation executeB() : double
  pre: true
  post: true
  activity: (     return 40.75 );
}
class Gamma implements OperationB {
   operation performA() : String
  pre: true
  post: true
  activity: (     return "Hello" );
   operation performB() : boolean
  pre: true
  post: true
  activity: (     return true );
}
class Delta implements OperationB {
   operation performA() : String
  pre: true
  post: true
  activity: (     return "World" );
   operation performB() : boolean
  pre: true
  post: true
  activity: (     return false );
}
class Entity {
   attribute id : String := "";
   attribute count : int := 0;
   static operation newEntity( identifier : String) : Entity
  pre: true
  post: true
  activity:
  ( var self : Entity ;
    self := createEntity();
    self.initialise(identifier);
    return self );
  operation initialise( identifier : String) : void
  pre: true  post: true
  activity: (     id := identifier );
   operation incrementCount() : int
  pre: true
  post: true
  activity: (     count := count + 1 ; 
     return count );
}
class Scholar extends Entity {
   attribute subject : String := "";
   static operation newScholar( identifier : String, field : String) : Scholar
  pre: true
  post: true
  activity:
  ( var self : Scholar ;
    self := createScholar();
    self.initialise(identifier, field);
    return self );
  operation initialise( identifier : String, field : String) : void
  pre: true  post: true
  activity: (     execute super(identifier) ; 
     subject := field );
}
class Professional extends Entity {
   attribute occupation : String := "";
   static operation newProfessional( identifier : String, job : String) : Professional
  pre: true
  post: true
  activity:
  ( var self : Professional ;
    self := createProfessional();
    self.initialise(identifier, job);
    return self );
  operation initialise( identifier : String, job : String) : void
  pre: true  post: true
  activity: (     execute super(identifier) ; 
     occupation := job );
}
class ObjectManipulator {
   operation handleObject() : boolean
  pre: true
  post: true
  activity: (     var data1 : OclAny ; data1 := "sample text" ;
     var data2 : OclAny ; data2 := Map{} ;
    data2 := data1+""->oclAsType(String) ; 
    data1.hashCode() ; 
    var cls : OclType ; cls := data2->oclType() ;
    try (     data2.wait(250) )   catch (e : ProgramException) do (     e.printStackTrace() )
    return data2 = null 
 );
}
class CoreOperation {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var manipulator : ObjectManipulator ; manipulator := ObjectManipulator.newObjectManipulator() ;
     var result : boolean ; result := manipulator.handleObject() ;
    OclFile["System.out"].println("Handle result: " + result) ; 
    var entity : Entity ; entity := Entity.newEntity("Michael") ;
    entity.incrementCount() ; 
    var scholar : Scholar ; scholar := Scholar.newScholar("Eve", "Mathematics") ;
    var professional : Professional ; professional := Professional.newProfessional("Adam", "Architect") ;
    OclFile["System.out"].println("Entity: " + entity.id + ", Count: " + entity.count) ; 
    OclFile["System.out"].println("Scholar: " + scholar.id + ", Subject: " + scholar.subject) ; 
    OclFile["System.out"].println("Professional: " + professional.id + ", Occupation: " + professional.occupation) ; 
    var alpha : Alpha ; alpha := Alpha.newAlpha() ;
    var beta : Beta ; beta := Beta.newBeta() ;
    var gamma : Gamma ; gamma := Gamma.newGamma() ;
    var delta : Delta ; delta := Delta.newDelta() ;
    OclFile["System.out"].println("Alpha: " + alpha.executeA() + ", " + alpha.executeB()) ; 
    OclFile["System.out"].println("Beta: " + beta.executeA() + ", " + beta.executeB()) ; 
    OclFile["System.out"].println("Gamma: " + gamma.performA() + ", " + gamma.performB()) ; 
    OclFile["System.out"].println("Delta: " + delta.performA() + ", " + delta.performB()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class FinancialCalculator {
  int calculateGrowthPeriod() {
    double interestRate = 0.07;
    double initialAmount = 200.0;
    int period = 0;
    int increase = 0;
    while (initialAmount * Math.pow(2.8, period) < 10 * initialAmount) {
      period = period + 1;
      increase = increase + 3;
    }
    return period;
  }
}

------------------------------------------------------------
OCL File:
---------
class FinancialCalculator {
   operation calculateGrowthPeriod() : int
  pre: true
  post: true
  activity: (     var interestRate : double ; interestRate := 0.07 ;
     var initialAmount : double ; initialAmount := 200.0 ;
    var period : int ; period := 0 ;
    var increase : int ; increase := 0 ;
    while (initialAmount * 2.8->pow(period) < 10 * initialAmount) do (     period := period + 1 ; 
     increase := increase + 3 ) ; 
    return period 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ErrorGenerator {
  public void triggerException() { 
    Number num = new Integer(42); 
    byte byteValue = num.byteValue(); 
    throw new UnsupportedOperationException("operation not supported"); 
  }
}

------------------------------------------------------------
OCL File:
---------
class ErrorGenerator {
   operation triggerException() : void
  pre: true
  post: true
  activity: (     var num : double ; num := ("" + (42))->toInteger() ;
     var byteValue : int ; byteValue := num->oclAsType(int) ;
     error IncorrectElementException("operation not supported") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class MathOperations {
    public int calculateTotal() {
        int[] items = { 5, 7, 9, 11, 13, 15, 17, 19, 55,88 };
        int total = 0;
        int idx = 0;
        while (idx < items.length) {
            total += items[idx++];
        }
        return total;
    }
    public int getMaxValue() {
        int[] numbers = { 25, 40, 22, 50, 60, 30,77,55,44 };
        int maxVal = numbers[0];
        for (int value : numbers) {
            if (value > maxVal) {
                maxVal = value;
            }
        }
        return maxVal;
    }
    public static void main(String[] args) {
        MathOperations operations = new MathOperations();
        double y;
        int totalResult = operations.calculateTotal();
        y=80.4;
        System.out.println("Total sum is: " + totalResult);
        int y=10; 
        int maxResult = operations.getMaxValue();
        System.out.println("Maximum value is: " + maxResult);
    }
}

------------------------------------------------------------
OCL File:
---------
class MathOperations {
   operation calculateTotal() : int
  pre: true
  post: true
  activity: (     var items : Sequence(int) ; items := Sequence{5,7,9,11,13,15,17,19,55,88} ;
     var total : int ; total := 0 ;
    var idx : int ; idx := 0 ;
    while (idx < items->size()) do (      total := total + items[idx+1]  ; idx := idx + 1 ) ; 
    return total 
 );
   operation getMaxValue() : int
  pre: true
  post: true
  activity: (     var numbers : Sequence(int) ; numbers := Sequence{25,40,22,50,60,30,77,55,44} ;
     var maxVal : int ; maxVal := numbers[0+1] ;
     for (value : numbers) do ( (     if (value > maxVal) then (     maxVal := value ) else skip )  ) ; 
     return maxVal );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var operations : MathOperations ; operations := MathOperations.newMathOperations() ;
     var y : double ;
    var totalResult : int ; totalResult := operations.calculateTotal() ;
    y := 80.4 ; 
    OclFile["System.out"].println("Total sum is: " + totalResult) ; 
    var y : int ; y := 10 ;
    var maxResult : int ; maxResult := operations.getMaxValue() ;
    OclFile["System.out"].println("Maximum value is: " + maxResult) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
interface TimeService {
    long getCurrentTime();
}
interface NameService {
    String getName();
}
interface AgeService {
    int getAge();
}
abstract class AbstractEntity {
    protected String name;
}
class TimeEntity extends AbstractEntity implements TimeService, NameService {
    public long getCurrentTime() {
        return System.nanoTime();
    }
    public String getName() {
        return name;
    }
}
class AgeEntity extends AbstractEntity implements AgeService {
    protected int ageValue;
    public int getAge() {
        return ageValue;
    }
}
class ProfileEntity extends AbstractEntity implements NameService, AgeService {
    protected int ageYears;
    public String getName() {
        return name;
    }
    public int getAge() {
        return ageYears;
    }
}
public class MainApp {
    public static void main(String[] args) {
        TimeEntity timeEntity = new TimeEntity();
        timeEntity.name = "Emma";
        System.out.printf("%d  %s\n", timeEntity.getCurrentTime(), timeEntity.getName());
        AgeEntity ageEntity = new AgeEntity();
        ageEntity.name = "Oliver";
        ageEntity.ageValue = 42;
        System.out.printf("Name: %s, Age: %d\n", ageEntity.name, ageEntity.getAge());
        ProfileEntity profileEntity = new ProfileEntity();
        profileEntity.name = "Sophia";
        profileEntity.ageYears = 30;
        System.out.printf("Name: %s, Age: %d\n", profileEntity.getName(), profileEntity.getAge());
    }
}

------------------------------------------------------------
OCL File:
---------
interface TimeService {
   operation getCurrentTime() : long
  pre: true
  post: true;
}
 interface NameService {
   operation getName() : String
  pre: true
  post: true;
}
interface AgeService {
   operation getAge() : int
  pre: true
  post: true;
}
class AbstractEntity {
     attribute name : String;
}
class TimeEntity extends AbstractEntity, TimeService, NameService {
   operation getCurrentTime() : long
  pre: true
  post: true
  activity: (     return nanoTime() );
   operation getName() : String
  pre: true
  post: true
  activity: (     return name );
}
class AgeEntity extends AbstractEntity, AgeService {
     attribute ageValue : int;
   operation getAge() : int
  pre: true
  post: true
  activity: (     return ageValue );
}
class ProfileEntity extends AbstractEntity, NameService, AgeService {
     attribute ageYears : int;
   operation getName() : String
  pre: true
  post: true
  activity: (     return name );
   operation getAge() : int
  pre: true
  post: true
  activity: (     return ageYears );
}
class MainApp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var timeEntity : TimeEntity ; timeEntity := TimeEntity.newTimeEntity() ;
     timeEntity.name := "Emma" ; 
    OclFile["System.out"].printf("%d  %s\n", timeEntity.getCurrentTime(), timeEntity.getName()) ; 
    var ageEntity : AgeEntity ; ageEntity := AgeEntity.newAgeEntity() ;
    ageEntity.name := "Oliver" ; 
    ageEntity.ageValue := 42 ; 
    OclFile["System.out"].printf("Name: %s, Age: %d\n", ageEntity.name, ageEntity.getAge()) ; 
    var profileEntity : ProfileEntity ; profileEntity := ProfileEntity.newProfileEntity() ;
    profileEntity.name := "Sophia" ; 
    profileEntity.ageYears := 30 ; 
    OclFile["System.out"].printf("Name: %s, Age: %d\n", profileEntity.getName(), profileEntity.getAge()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class FileHandler {
    public void handleFile() {
        File file = new File("datafile.txt");
        PrintStream writer = new PrintStream(new FileWriter(file));
        int eee;
        writer.print(true);
        writer.println(78.456);
        writer.println(123);
        char[] symbols = {'a', 'b', 'c','f','y','i'};
        writer.println(symbols);
        byte[] buffer = { 110, 111, 112, 113, 444, 777,333 };
        double y;
        writer.write(buffer, 0, 2);
        String supplementaryInfo = "sample";
        y=134.445;
        int extraValue = 99;
        double t=99.04;
    }
}

------------------------------------------------------------
OCL File:
---------
class FileHandler {
   operation handleFile() : void
  pre: true
  post: true
  activity: (     var file : OclFile ; file := OclFile("datafile.txt") ;
     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(file)) ;
    var eee : int ;
    skip ; 
    skip ; 
    skip ; 
    var symbols : Sequence(String) ; symbols := Sequence{'a','b','c','f','y','i'} ;
    skip ; 
    var buffer : Sequence(int) ; buffer := Sequence{110,111,112,113,444,777,333} ;
    var y : double ;
    skip ; 
    var supplementaryInfo : String ; supplementaryInfo := "sample" ;
    y := 134.445 ; 
    var extraValue : int ; extraValue := 99 ;
    var t : double ; t := 99.04 ;
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class AppRunner {
    public static void main(String[] args) {
        PriorityQueue<String> priorityQueue = new PriorityQueue<String>();
        priorityQueue.offer("5");
        System.out.println(priorityQueue);
        System.out.println(priorityQueue.peek());
        while (!priorityQueue.isEmpty()) {
            String item = priorityQueue.poll();
            System.out.println(item);
        }
        double uu=3223.55;
        int y=9;
        String extraString = "supplement";
        int extraValue = 50;
        double ytr=978.444;
    }
}

------------------------------------------------------------
OCL File:
---------
class AppRunner {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var priorityQueue : Sequence(String) ; priorityQueue := Sequence{} ;
     priorityQueue := priorityQueue->including("5") ; 
    OclFile["System.out"].println(priorityQueue) ; 
    OclFile["System.out"].println(priorityQueue->min()) ; 
    while (not(priorityQueue->isEmpty())) do (     var item : String ; item := priorityQueue->min() ;
     OclFile["System.out"].println(item) ) ; 
    var uu : double ; uu := 3223.55 ;
    var y : int ; y := 9 ;
    var extraString : String ; extraString := "supplement" ;
    var extraValue : int ; extraValue := 50 ;
    var ytr : double ; ytr := 978.444 ;
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class FileManager {
    public void saveRecords() {
        String extraText = "example";
        RandomAccessFile recordFile = new RandomAccessFile("records.dat", "rw");
        int extraNumber = 20;
        recordFile.writeBytes("First entry\n");
        recordFile.writeBytes("Second entry\n");
        int gg = 4520;
        recordFile.close();
    }
}

------------------------------------------------------------
OCL File:
---------
class FileManager {
   operation saveRecords() : void
  pre: true
  post: true
  activity: (     var extraText : String ; extraText := "example" ;
     var recordFile : OclFile ; recordFile := OclFile.newOclFile("records.dat", "rw") ;
    var extraNumber : int ; extraNumber := 20 ;
    skip ; 
    skip ; 
    var gg : int ; gg := 4520 ;
    skip ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class LogFileHandler {
    public void executeTask() {
        double ee=5435.6546;
        RandomAccessFile logFile = new RandomAccessFile("logfile.dat", "rw");
        long currentPosition = logFile.getFilePointer();
        int byteRead = logFile.readByte();
        int k=10;
        currentPosition = logFile.getFilePointer();
        byteRead = logFile.readByte();
        currentPosition = logFile.getFilePointer();
        double aaa;
        logFile.close();
        double bbb;
        double additionalValue = 6.28;
        String extraDetail = "details";
    }
}

------------------------------------------------------------
OCL File:
---------
class LogFileHandler {
   operation executeTask() : void
  pre: true
  post: true
  activity: (     var ee : double ; ee := 5435.6546 ;
     var logFile : OclFile ; logFile := OclFile.newOclFile("logfile.dat", "rw") ;
    var currentPosition : long ; currentPosition := logFile.getPosition() ;
    var byteRead : int ; byteRead := logFile.readByte() ;
    var k : int ; k := 10 ;
    currentPosition := logFile.getPosition() ; 
    byteRead := logFile.readByte() ; 
    currentPosition := logFile.getPosition() ; 
    var aaa : double ;
    skip ; 
    var bbb : double ;
    var additionalValue : double ; additionalValue := 6.28 ;
    var extraDetail : String ; extraDetail := "details" ;
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class RandomExample {
    double generateValues() {
        double fdfdfd;
        Random randomizer = new Random();
        double result = randomizer.nextDouble();
        result = randomizer.nextGaussian();
        String extraString = "sample";
        long extraLong = 1234567890L;
        int randomNumber = randomizer.nextInt(1000);
        randomNumber = randomizer.nextInt(100);
        randomizer.setSeed(7654321);
        result = randomizer.nextFloat();
        boolean status = randomizer.nextBoolean();
        int i=10;       
        return randomizer.nextGaussian();
    }
}

------------------------------------------------------------
OCL File:
---------
class RandomExample {
   operation generateValues() : double
  pre: true
  post: true
  activity: (     var fdfdfd : double ;
     var randomizer : OclRandom ; randomizer := OclRandom.newOclRandom() ;
    var result : double ; result := randomizer.nextDouble() ;
    result := randomizer.nextGaussian() ; 
    var extraString : String ; extraString := "sample" ;
    var extraLong : long ; extraLong := 1234567890L ;
    var randomNumber : int ; randomNumber := randomizer.nextInt(1000) ;
    randomNumber := randomizer.nextInt(100) ; 
    randomizer.setSeed(7654321) ; 
    result := randomizer.nextFloat() ; 
    var status : boolean ; status := randomizer.nextBoolean() ;
    var i : int ; i := 10 ;
    return randomizer.nextGaussian() 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class DataSwitcher {
    public static void swapValues(int[] arrayA, int[] arrayB) {
        int i=10; 
        int tempValue = arrayA[1];
        arrayA[1] = arrayB[1];
        arrayB[1] = tempValue;
    }
    public static void main(String[] args) {
        int[] primaryArray = {50, 60, 70, 80,555,787};
        int[] secondaryArray = {25, 35, 45, 55,444,333};
        swapValues(primaryArray, secondaryArray);
        System.out.println(primaryArray[0] + " " + primaryArray[1] + " " + primaryArray[2] + " " + primaryArray[3]);
        System.out.println(secondaryArray[0] + " " + secondaryArray[1] + " " + secondaryArray[2] + " " + secondaryArray[3]);
        float statusValue = 12.34f; 
        String statusMessage = "Finished";
    }
}

------------------------------------------------------------
OCL File:
---------
class DataSwitcher {
  static   operation swapValues( arrayA : Sequence(int), arrayB : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var i : int ; i := 10 ;
     var tempValue : int ; tempValue := arrayA[1+1] ;
     arrayA[1+1] := arrayB[1+1] ; 
     arrayB[1+1] := tempValue );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var primaryArray : Sequence(int) ; primaryArray := Sequence{50,60,70,80,555,787} ;
     var secondaryArray : Sequence(int) ; secondaryArray := Sequence{25,35,45,55,444,333} ;
    execute swapValues(primaryArray, secondaryArray) ; 
    OclFile["System.out"].println(primaryArray[0+1] + " " + primaryArray[1+1] + " " + primaryArray[2+1] + " " + primaryArray[3+1]) ; 
    OclFile["System.out"].println(secondaryArray[0+1] + " " + secondaryArray[1+1] + " " + secondaryArray[2+1] + " " + secondaryArray[3+1]) ; 
    var statusValue : double ; statusValue := 12.34f ;
    var statusMessage : String ; statusMessage := "Finished" ;
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ListEvaluator {
    public void assess() {
        int[] listA = {7, 14, 21, 28, 7,44,55};
        int[] listB = {9, 18, 27, 36, 9,77,88};
        boolean comparisonResult = (listA == listB);
        comparisonResult = (listA.equals(listB));
        double yyy=99.99;
        comparisonResult = Arrays.equals(listA, listB);
        listA = listB;
        String statusMessage = "completed";
        float statusNumber = 56.78f;
        comparisonResult = Arrays.equals(listA, listB);
        int k=10;
        comparisonResult = (listA.equals(listB));
        k++;
        comparisonResult = (listA == listB);
    }
}

------------------------------------------------------------
OCL File:
---------
class ListEvaluator {
   operation assess() : void
  pre: true
  post: true
  activity: (     var listA : Sequence(int) ; listA := Sequence{7,14,21,28,7,44,55} ;
     var listB : Sequence(int) ; listB := Sequence{9,18,27,36,9,77,88} ;
    var comparisonResult : boolean ; comparisonResult := (listA = listB) ;
    comparisonResult := (listA = listB) ; 
    var yyy : double ; yyy := 99.99 ;
    comparisonResult := listA = listB ; 
    listA := listB ; 
    var statusMessage : String ; statusMessage := "completed" ;
    var statusNumber : double ; statusNumber := 56.78f ;
    comparisonResult := listA = listB ; 
    var k : int ; k := 10 ;
    comparisonResult := (listA = listB) ; 
    k := k + 1 ; 
    comparisonResult := (listA = listB) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class LexicalItem {
    public String category = "Adjective";
    public String text = "";
    public LexicalItem() { }
    public LexicalItem(String textValue) {
        text = textValue;
    }
    public String getCategory() {
        return category;
    }
}
class LanguageItem extends LexicalItem {
    public String tense = "Past";
    public LanguageItem(String textValue) {
        super(textValue);
    }
    public String getTense() {
        return tense;
    }
}
class Inspector {
    public static void inspect() {
        Class itemClass = LanguageItem.class;
        Field[] itemFields = itemClass.getDeclaredFields();
        Constructor[] itemConstructors = itemClass.getDeclaredConstructors();
        double i=198.33;
        Method[] itemMethods = itemClass.getDeclaredMethods();
        Class parentItemClass = itemClass.getSuperclass();
        double extraValue = 99.99;
        String extraText = "sample";
    }
}

------------------------------------------------------------
OCL File:
---------
class LexicalItem {
   attribute category : String := "Adjective";
   attribute text : String := "";
   static operation newLexicalItem() : LexicalItem
  pre: true
  post: true
  activity:
  ( var self : LexicalItem ;
    self := createLexicalItem();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   static operation newLexicalItem( textValue : String) : LexicalItem
  pre: true
  post: true
  activity:
  ( var self : LexicalItem ;
    self := createLexicalItem();
    self.initialise(textValue);
    return self );
  operation initialise( textValue : String) : void
  pre: true  post: true
  activity: (     text := textValue );
   operation getCategory() : String
  pre: true
  post: true
  activity: (     return category );
}
 class LanguageItem extends LexicalItem {
   attribute tense : String := "Past";
   static operation newLanguageItem( textValue : String) : LanguageItem
  pre: true
  post: true
  activity:
  ( var self : LanguageItem ;
    self := createLanguageItem();
    self.initialise(textValue);
    return self );
  operation initialise( textValue : String) : void
  pre: true  post: true
  activity: (     execute super(textValue) );
   operation getTense() : String
  pre: true
  post: true
  activity: (     return tense );
}
class Inspector {
  static   operation inspect() : void
  pre: true
  post: true
  activity: (     var itemClass : OclType ; itemClass := OclType["LanguageItem"] ;
     var itemFields : Sequence(OclAttribute) ; itemFields := itemClass.getDeclaredFields() ;
    var itemConstructors : Sequence(OclOperation) ; itemConstructors := itemClass.getDeclaredConstructors() ;
    var i : double ; i := 198.33 ;
    var itemMethods : Sequence(OclOperation) ; itemMethods := itemClass.getDeclaredMethods() ;
    var parentItemClass : OclType ; parentItemClass := itemClass.getSuperclass() ;
    var extraValue : double ; extraValue := 99.99 ;
    var extraText : String ; extraText := "sample" ;
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
abstract class AbstractBase { 
    int value = 25; 
    int m=9;
    abstract String fetchData(); 
}

------------------------------------------------------------
OCL File:
---------
class AbstractBase {
   attribute value : int := 25;
   attribute m : int := 9;
     operation fetchData() : String
  pre: true
  post: true;
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class InventoryManager {
    void handle() {
        List<String> products = new ArrayList<String>();
        String statusMessage = "processed";
        int itemCount = 75;
        products.add("tttt");
        products.add("yyyy");
        itemCount += 15;
        wasRemoved = products.remove("aaa");
        boolean wasRemoved = products.remove("vvvv");
        wasRemoved = Collections.replaceAll(products, "bbbbb", "uuuu");
        System.out.println(products);
        String finalStatus = "completed";
        double newValue = 33.5;
    }
}

------------------------------------------------------------
OCL File:
---------
 class InventoryManager {
   operation handle() : void
  pre: true
  post: true
  activity: (     var products : Sequence(String) ; products := Sequence{} ;
     var statusMessage : String ; statusMessage := "processed" ;
    var itemCount : int ; itemCount := 75 ;
    products := products->including("tttt") ; 
    products := products->including("yyyy") ; 
    itemCount := itemCount+(15) ; 
    wasRemoved := products->includes("aaa") ;     products := products->excludingFirst("aaa") ; 
    var wasRemoved : boolean ; wasRemoved := products->includes("vvvv") ;
     wasRemoved := products->includes( "bbbbb" )  ;     products := products->collect( x1 | if x1 = "bbbbb" then "uuuu" else x1 endif ) ; 
    OclFile["System.out"].println(products) ; 
    var finalStatus : String ; finalStatus := "completed" ;
    var newValue : double ; newValue := 33.5 ;
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class JobExecutor implements Runnable {
    private String label;
    public JobExecutor(String tag) {
        label = tag;
    }
    public void run() {
        for (int count = 0; count < 20; count++) {
            System.out.println(">> round " + count + " of " + label);
        }
    }
}
public class MainApp {
    public static void main(String[] args) {
        int y=66;
        String infoMessage = "initial data";
        JobExecutor job1 = new JobExecutor("X");
        JobExecutor job2 = new JobExecutor("Y");
        double hh=9998.6; 
        Thread threadA = new Thread(job1);
        Thread threadB = new Thread(job2);
        int number = 72;
        threadA.start();
        threadB.start();
        number = number + 45;
        double yyy;
    }
}

------------------------------------------------------------
OCL File:
---------
class JobExecutor implements Runnable {
   attribute label : String;
   static operation newJobExecutor( tag : String) : JobExecutor
  pre: true
  post: true
  activity:
  ( var self : JobExecutor ;
    self := createJobExecutor();
    self.initialise(tag);
    return self );
  operation initialise( tag : String) : void
  pre: true  post: true
  activity: (     label := tag );
   operation run() : void
  pre: true
  post: true
  activity: (         var count : int ; count := 0 ; while count < 20 do ( (     OclFile["System.out"].println(">> round " + count + " of " + label) )  ;     count := count + 1 ) );
}
 class MainApp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var y : int ; y := 66 ;
     var infoMessage : String ; infoMessage := "initial data" ;
    var job1 : JobExecutor ; job1 := JobExecutor.newJobExecutor("X") ;
    var job2 : JobExecutor ; job2 := JobExecutor.newJobExecutor("Y") ;
    var hh : double ; hh := 9998.6 ;
    var threadA : OclProcess ; threadA := OclProcess.newOclProcess(job1) ;
    var threadB : OclProcess ; threadB := OclProcess.newOclProcess(job2) ;
    var number : int ; number := 72 ;
    threadA.start() ; 
    threadB.start() ; 
    number := number + 45 ; 
    var yyy : double ;
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class TaskProcessor {
    int runTask() {
        Runtime systemRuntime = Runtime.getRuntime();
        Process systemProcess = systemRuntime.exec("C:/Program Files/Java/jdk-17.0.1/bin/java.exe");
        int resultCode = systemProcess.waitFor();
        String resultStatus = "completed";
        float javaVersion = 17.0f;
        return resultCode;
    }
}

------------------------------------------------------------
OCL File:
---------
class TaskProcessor {
   operation runTask() : int
  pre: true
  post: true
  activity: (     var systemRuntime : OclProcess ; systemRuntime := Runtime.getRuntime() ;
     var systemProcess : OclProcess ; systemProcess := systemRuntime.exec("C:/Program Files/Java/jdk-17.0.1/bin/java.exe") ;
    var resultCode : int ; resultCode := systemProcess.waitFor() ;
    var resultStatus : String ; resultStatus := "completed" ;
    var javaVersion : double ; javaVersion := 17.0f ;
    return resultCode 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
import java.util.Scanner;
public class DataFetcher {
    public ArrayList<Float> gatherInputs() {
        ArrayList<Float> valuesList = new ArrayList<Float>();
        Scanner inputScanner = new Scanner(System.in);
        String message = "inputs gathered";
        double iii=98.55;
        int numberOfEntries = 5;
        while (inputScanner.hasNext()) {
            float data = inputScanner.nextFloat();
            valuesList.add(data);
        }
        return valuesList;
    }
}

------------------------------------------------------------
OCL File:
---------
 class DataFetcher {
   operation gatherInputs() : Sequence(double)
  pre: true
  post: true
  activity: (     var valuesList : Sequence(double) ; valuesList := Sequence{} ;
     var inputScanner : OclFile ; inputScanner := OclFile.newOclFile_Read(OclFile["System.in"]) ;
    var message : String ; message := "inputs gathered" ;
    var iii : double ; iii := 98.55 ;
    var numberOfEntries : int ; numberOfEntries := 5 ;
    while (inputScanner.hasNext()) do (     var data : double ; data := inputScanner.nextFloat() ;
     valuesList := valuesList->including(data) ) ; 
    return valuesList 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet;
import java.util.TreeSet;
public class CollectionDemo {
    public void testMethod() {
        String[][] array2D = { { "a", "b" }, { "c", "d" } };
        array2D[1][1] = "e";
        HashSet<String> setA = new HashSet<String>();
        setA = new HashSet<String>(100);
        String extraString = "example";
        int extraValue = 40;
        double hh=6776.888; 
        TreeSet<String> setB = new TreeSet<String>(setA);
        setB = new TreeSet<String>();
    }
}

------------------------------------------------------------
OCL File:
---------
 class CollectionDemo {
   operation testMethod() : void
  pre: true
  post: true
  activity: (     var array2D : Sequence(Sequence(String)) ; array2D := Sequence{Sequence{"a","b"},Sequence{"c","d"}} ;
     array2D[1+1][1+1] := "e" ; 
    var setA : Set(String) ; setA := Set{} ;
    setA := Set{} ; 
    var extraString : String ; extraString := "example" ;
    var extraValue : int ; extraValue := 40 ;
    var hh : double ; hh := 6776.888 ;
    var setB : Set(String) ; setB := Set{}->union(setA) ;
    setB := Set{} ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class IntegerHandler {
    public int handleIntegers() {
        String extraInfo = "data";
        Integer num = new Integer("255");
        int maxInt = Integer.MAX_VALUE;
        float extraFloat = 56.78f;
        maxInt = Integer.parseInt("256");
        double doubleValue = num.doubleValue();
        double kkk=999.098;
        int compareResult = num.compareTo(new Integer(100));
        return compareResult;
    }
}

------------------------------------------------------------
OCL File:
---------
class IntegerHandler {
   operation handleIntegers() : int
  pre: true
  post: true
  activity: (     var extraInfo : String ; extraInfo := "data" ;
     var num : int ; num := ("" + ("255"))->toInteger() ;
    var maxInt : int ; maxInt := 2147483647 ;
    var extraFloat : double ; extraFloat := 56.78f ;
    maxInt := ("256")->toInteger() ; 
    var doubleValue : double ; doubleValue := num->oclAsType(double) ;
    var kkk : double ; kkk := 999.098 ;
    var compareResult : int ; compareResult := num->compareTo(("" + (100))->toInteger()) ;
    return compareResult 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Tracker {
    public int adjustValue() {
        double kkk=5445.8;   
        int tally = 50;
        float extraNumber = 14.32f;
        tally++;
        tally++;
        tally = ++tally;
        tally = --tally;
        tally = tally++;
        tally = tally--;
        return tally;
    }
}

------------------------------------------------------------
OCL File:
---------
class Tracker {
   operation adjustValue() : int
  pre: true
  post: true
  activity: (     var kkk : double ; kkk := 5445.8 ;
     var tally : int ; tally := 50 ;
    var extraNumber : double ; extraNumber := 14.32f ;
    tally := tally + 1 ; 
    tally := tally + 1 ; 
        tally := tally + 1 ;
 tally := tally  ; 
        tally := tally - 1 ;
 tally := tally  ; 
     tally := tally  ; tally := tally + 1 ; 
     tally := tally  ; tally := tally - 1 ; 
    return tally 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.Socket;
public class RemoteClient {
    void transmitData() {
        double dataSize = 256.75;
        boolean isSuccess = true;
        InetAddress serverAddress = InetAddress.getByName("10.0.0.1");
        String statusMessage = "transfer complete";
        double dataSize34 = 256.75;
        boolean isSuccess33 = false;
        Socket connection = new Socket(serverAddress, 65432);
        ObjectOutputStream stream = new ObjectOutputStream(connection.getOutputStream());
        int serverPort = 9090;
        stream.writeObject("Greetings, server");
        stream.flush();
        stream.close();
        connection.close();
     }
}

------------------------------------------------------------
OCL File:
---------
 class RemoteClient {
   operation transmitData() : void
  pre: true
  post: true
  activity: (     var dataSize : double ; dataSize := 256.75 ;
     var isSuccess : boolean ; isSuccess := true ;
    var serverAddress : String ; serverAddress := "10.0.0.1" ;
    var statusMessage : String ; statusMessage := "transfer complete" ;
    var dataSize34 : double ; dataSize34 := 256.75 ;
    var isSuccess33 : boolean ; isSuccess33 := false ;
    var connection : OclDatasource ; connection := OclDatasource.newSocket(serverAddress, 65432) ;
    var stream : OclFile ; stream := OclFile.newOclFile_WriteB(OclFile.newOclFile(connection.getOutputStream())) ;
    var serverPort : int ; serverPort := 9090 ;
    skip ; 
    skip ; 
    skip ; 
    connection.close() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Stack;
public class DataProcessor {
    public boolean manageStack() {
        String extraLabel = "vegetable";
        Stack myStack = new Stack();
        myStack.push("carrot");
        myStack.push("broccoli");
        int extraNumber = 56;
        int addValue = 425;
        String topItem = myStack.peek();
        int positionIndex = myStack.search("broccoli");
        double stackSize = myStack.size();
        String finalStatus = "fdfdfd";
        topItem = myStack.pop();
        boolean isEmpty = myStack.empty();
        return isEmpty;
    }
}

------------------------------------------------------------
OCL File:
---------
 class DataProcessor {
   operation manageStack() : boolean
  pre: true
  post: true
  activity: (     var extraLabel : String ; extraLabel := "vegetable" ;
     var myStack : Sequence ; myStack := Sequence{} ;
    myStack := myStack->append("carrot") ; 
    myStack := myStack->append("broccoli") ; 
    var extraNumber : int ; extraNumber := 56 ;
    var addValue : int ; addValue := 425 ;
    var topItem : String ; topItem := myStack->min() ;
    var positionIndex : int ; positionIndex := myStack->reverse()->indexOf("broccoli")-1 ;
    var stackSize : double ; stackSize := myStack->size() ;
    var finalStatus : String ; finalStatus := "fdfdfd" ;
    topItem := myStack->last() ;     myStack := myStack->front() ; 
    var isEmpty : boolean ; isEmpty := myStack->isEmpty() ;
    return isEmpty 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
public class ObjectMonitor {
  static ArrayList<String> labels;  
  static int count = 18;
  String statusMessage = "setup successful";
  static {
        labels = new ArrayList<String>();
        labels.add("orange");
        labels.add("grape");
        labels.add("kiwi");
        float extraNumber = 7.62f;
        labels.add("gggg");
        labels.add("hhhhh");
        labels.add("yyyyy");
    }
}

------------------------------------------------------------
OCL File:
---------
 class ObjectMonitor {
  static   attribute labels : Sequence(String);
  static   attribute count : int := 18;
   attribute statusMessage : String := "setup successful";
  static operation initialiseClass()
  pre: true post: true
  activity:     labels := Sequence{} ; 
    labels := labels->including("orange") ; 
    labels := labels->including("grape") ; 
    labels := labels->including("kiwi") ; 
    var extraNumber : double ; extraNumber := 7.62f ;
    labels := labels->including("gggg") ; 
    labels := labels->including("hhhhh") ; 
    labels := labels->including("yyyyy") ; 
;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class DataHandler {
  @Nullable
  public String formatDetails(@NonNull Object item, int start, int end) { 
    String result = item.getClass().getSimpleName() + start + end;
    return result;
  }
  public String retrieveInfo(@Nullable Object data) { 
    return data != null ? data.toString() : "No Data";
  }
}

------------------------------------------------------------
OCL File:
---------
class DataHandler {
      operation formatDetails( item : OclAny, start : int, end : int) : String
  pre: true
  post: true
  activity: (     var result : String ; result := item->oclType().getSimpleName() + start + end ;
     return result );
   operation retrieveInfo( data : OclAny) : String
  pre: true
  post: true
  activity: (     return if data /= null then data+"" else "No Data" endif );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Monitor {
    static int totalInstances = 12;
    public Monitor() {
        Monitor.totalInstances++;
    }
    static int getInstanceTotal() {
        return Monitor.totalInstances;
    }
    public static void main(String[] args) {
        String statusMessage = "finished";
        float statusValue = 8.34f;
        int ggg=99;
        Monitor instance1 = new Monitor();
        Monitor instance2 = new Monitor();
        double hgf=554.78;
    }
}

------------------------------------------------------------
OCL File:
---------
class Monitor {
  static   attribute totalInstances : int := 12;
   static operation newMonitor() : Monitor
  pre: true
  post: true
  activity:
  ( var self : Monitor ;
    self := createMonitor();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     Monitor.totalInstances := Monitor.totalInstances + 1 );
  static   operation getInstanceTotal() : int
  pre: true
  post: true
  activity: (     return Monitor.totalInstances );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var statusMessage : String ; statusMessage := "finished" ;
     var statusValue : double ; statusValue := 8.34f ;
    var ggg : int ; ggg := 99 ;
    var instance1 : Monitor ; instance1 := Monitor.newMonitor() ;
    var instance2 : Monitor ; instance2 := Monitor.newMonitor() ;
    var hgf : double ; hgf := 554.78 ;
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public interface DataService {
    public <T> @ServiceMethod void transmitInfo(){ return; }
}

------------------------------------------------------------
OCL File:
---------
interface DataService {
     operation transmitInfo<T>() : void
  pre: true
  post: true
  activity: (     return );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class ProcessorUnit {
    public Handler<@ServiceInterface ? super DataProcessor> config;
    int updatedValue = 20;
    double fdfdf=767676.898;
}

------------------------------------------------------------
OCL File:
---------
class ProcessorUnit {
   attribute config : Handler<DataProcessor>;
   attribute updatedValue : int := 20;
   attribute fdfdf : double := 767676.898;
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
import java.util.stream.Stream;
class Element {
    String value = "";
    String category = "ADJ";
    int number = 7;
    String analyzeElements() {
        ArrayList<Element> elements = new ArrayList<Element>();
        Element elem1 = new Element();
        elem1.value = "aa";
        Element elem2 = new Element();
        elem2.value = "bb";
        elements.add(elem1);
        elements.add(elem2); 
        Stream<String> distinctValues = elements.stream().map(e -> e.value).distinct();
        long countDistinct = distinctValues.count();
        System.out.println(countDistinct);
        boolean allMatchCategory = elements.stream().allMatch(e -> e.category.equals("ADJ"));
        double dfdfd=67767.7676; 
        return allMatchCategory + "";
    }
}

------------------------------------------------------------
OCL File:
---------
 class Element {
   attribute value : String := "";
   attribute category : String := "ADJ";
   attribute number : int := 7;
   operation analyzeElements() : String
  pre: true
  post: true
  activity: (     var elements : Sequence(Element) ; elements := Sequence{} ;
     var elem1 : Element ; elem1 := Element.newElement() ;
    elem1.value := "aa" ; 
    var elem2 : Element ; elem2 := Element.newElement() ;
    elem2.value := "bb" ; 
    elements := elements->including(elem1) ; 
    elements := elements->including(elem2) ; 
    var distinctValues : Stream<String> ; distinctValues := elements->collect( _x1 | (lambda e : OclAny in e.value)->apply(_x1) )->asOrderedSet() ;
    var countDistinct : long ; countDistinct := distinctValues->size() ;
    OclFile["System.out"].println(countDistinct) ; 
    var allMatchCategory : boolean ; allMatchCategory := elements->forAll( _x2 | (lambda e : OclAny in e.category = "ADJ")->apply(_x2) ) ;
    var dfdfd : double ; dfdfd := 67767.7676 ;
    return allMatchCategory + "" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class StringManager {
    public int processString() {
        StringBuilder builder = new StringBuilder();
        builder = new StringBuilder("sample text");
        builder = new StringBuilder(200);
        builder.append(4.56);
        builder.append('e');
        builder.append("additional data");
        builder.append(44.456);
        builder.append('u');
        builder.append("fdfsf fsdfs");
        char[] letters = {'a', 'b', 'c','g','j','k'};
        builder.append(letters);
        char firstCharacter = builder.charAt(0);
        double ddd=5454.54545;
        builder.delete(0, 5);
        ddd++;
        builder.deleteCharAt(2);
        builder.ensureCapacity(300);
        int newValue = 78;
        return builder.indexOf("e", 10);
    }
}

------------------------------------------------------------
OCL File:
---------
class StringManager {
   operation processString() : int
  pre: true
  post: true
  activity: (     var builder : String ; builder := StringLib.newString() ;
     builder := StringLib.newString("sample text") ; 
    builder := StringLib.newString(200) ; 
    builder := builder + StringLib.newString(4.56) ; 
    builder := builder + StringLib.newString('e') ; 
    builder := builder + StringLib.newString("additional data") ; 
    builder := builder + StringLib.newString(44.456) ; 
    builder := builder + StringLib.newString('u') ; 
    builder := builder + StringLib.newString("fdfsf fsdfs") ; 
    var letters : Sequence(String) ; letters := Sequence{'a','b','c','g','j','k'} ;
    builder := builder + StringLib.newString(letters) ; 
    var firstCharacter : String ; firstCharacter := builder->at(0+1) ;
    var ddd : double ; ddd := 5454.54545 ;
    builder := builder->antirestrict( Integer.subrange(0+1,5) ) ; 
    ddd := ddd + 1 ; 
    builder := builder->excludingAt(2+1) ; 
    builder.ensureCapacity(300) ; 
    var newValue : int ; newValue := 78 ;
    return builder.subrange(10+1)->indexOf("e"+"") + 10 - 1  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class TextManipulator {
    public String modifyText() {
        int extraValue = 88;
        StringBuilder builder = new StringBuilder("starting point");
        StringBuilder modifiedBuilder = builder.insert(7, true);
        int count = 3;
        int Value = 44;
        builder.insert(7, 300);
        builder.reverse();
        builder.setCharAt(2, 'z');
        int Valueee = 8;
        CharSequence sequence = builder.subSequence(3, 8);
        String resultString = builder.substring(5);        
        return resultString;
    }
}

------------------------------------------------------------
OCL File:
---------
class TextManipulator {
   operation modifyText() : String
  pre: true
  post: true
  activity: (     var extraValue : int ; extraValue := 88 ;
     var builder : String ; builder := StringLib.newString("starting point") ;
    var modifiedBuilder : String ; modifiedBuilder := builder.insertAt(7+1, StringLib.newString(true)) ;
    var count : int ; count := 3 ;
    var Value : int ; Value := 44 ;
    builder := builder.insertAt(7+1, StringLib.newString(300)) ; 
    builder := builder->reverse() ; 
    builder := builder.setAt(2+1, 'z') ; 
    var Valueee : int ; Valueee := 8 ;
    var sequence : String ; sequence := builder.subrange(3+1,8) ;
    var resultString : String ; resultString := builder.subrange(5+1,5) ;
    return resultString 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class StringBuilderExample {
    public int executeTask() {
        char[] symbols = {'a', 'b', 'c', 'd'};
        StringBuilder builder = new StringBuilder();
        builder = new StringBuilder(200);
        builder = new StringBuilder("example text");
        builder.append(2.45);
        builder.append("extra content");
        builder.append(symbols);
        char thirdChar = builder.charAt(3);
        builder.delete(2, 7);
        builder.deleteCharAt(4);
        builder.ensureCapacity(400);
        int sss2 = 40;
        int rr = 510;
        int sss = 810;
        return builder.indexOf("b", 6);
    }
}

------------------------------------------------------------
OCL File:
---------
class StringBuilderExample {
   operation executeTask() : int
  pre: true
  post: true
  activity: (     var symbols : Sequence(String) ; symbols := Sequence{'a','b','c','d'} ;
     var builder : String ; builder := StringLib.newString() ;
    builder := StringLib.newString(200) ; 
    builder := StringLib.newString("example text") ; 
    builder := builder + StringLib.newString(2.45) ; 
    builder := builder + StringLib.newString("extra content") ; 
    builder := builder + StringLib.newString(symbols) ; 
    var thirdChar : String ; thirdChar := builder->at(3+1) ;
    builder := builder->antirestrict( Integer.subrange(2+1,7) ) ; 
    builder := builder->excludingAt(4+1) ; 
    builder.ensureCapacity(400) ; 
    var sss2 : int ; sss2 := 40 ;
    var rr : int ; rr := 510 ;
    var sss : int ; sss := 810 ;
    return builder.subrange(6+1)->indexOf("b"+"") + 6 - 1  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
interface Function1 {
    void showRole();
}
class Person {
    String name = "";
    int age = 0;
    public Person(String personName) {
        name = personName;
    }
}
class Student extends Person implements Function1 {
    String fieldOfStudy = "";
    public Student(String personName, String subject) {
        super(personName);
        fieldOfStudy = subject;
    }
    @Override
    public void showRole() {
        System.out.println("Role: Student");
    }
}
class Educator extends Person {
    String faculty = "";
    public Educator(String personName, String facultyName) {
        super(personName);
        faculty = facultyName;
    }
}
class Manager extends Person {
    String location = "";
    public Manager(String personName, String officeLocation) {
        super(personName);
        location = officeLocation;
    }
}
class Coordinator extends Person {
    String team = "";
    public Coordinator(String personName, String teamName) {
        super(personName);
        team = teamName;
    }
}

------------------------------------------------------------
OCL File:
---------
interface Function1 {
   operation showRole() : void
  pre: true
  post: true;
}
 class Person {
   attribute name : String := "";
   attribute age : int := 0;
   static operation newPerson( personName : String) : Person
  pre: true
  post: true
  activity:
  ( var self : Person ;
    self := createPerson();
    self.initialise(personName);
    return self );
  operation initialise( personName : String) : void
  pre: true  post: true
  activity: (     name := personName );
}
class Student extends Person, Function1 {
   attribute fieldOfStudy : String := "";
   static operation newStudent( personName : String, subject : String) : Student
  pre: true
  post: true
  activity:
  ( var self : Student ;
    self := createStudent();
    self.initialise(personName, subject);
    return self );
  operation initialise( personName : String, subject : String) : void
  pre: true  post: true
  activity: (     execute super(personName) ; 
     fieldOfStudy := subject );
      operation showRole() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Role: Student") );
}
class Educator extends Person {
   attribute faculty : String := "";
   static operation newEducator( personName : String, facultyName : String) : Educator
  pre: true
  post: true
  activity:
  ( var self : Educator ;
    self := createEducator();
    self.initialise(personName, facultyName);
    return self );
  operation initialise( personName : String, facultyName : String) : void
  pre: true  post: true
  activity: (     execute super(personName) ; 
     faculty := facultyName );
}
class Manager extends Person {
   attribute location : String := "";
   static operation newManager( personName : String, officeLocation : String) : Manager
  pre: true
  post: true
  activity:
  ( var self : Manager ;
    self := createManager();
    self.initialise(personName, officeLocation);
    return self );
  operation initialise( personName : String, officeLocation : String) : void
  pre: true  post: true
  activity: (     execute super(personName) ; 
     location := officeLocation );
}
class Coordinator extends Person {
   attribute team : String := "";
   static operation newCoordinator( personName : String, teamName : String) : Coordinator
  pre: true
  post: true
  activity:
  ( var self : Coordinator ;
    self := createCoordinator();
    self.initialise(personName, teamName);
    return self );
  operation initialise( personName : String, teamName : String) : void
  pre: true  post: true
  activity: (     execute super(personName) ; 
     team := teamName );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class InfoProcessor {
    public int evaluateNumbers() {
        int[] values = {92, 77, 68, 84, 54, 72, 56, 68, 74, 81, 95};
        int countEven = 0;
        int countOdd = 0;
        int countDivisibleBySeven = 0;
        int totalElements = 0;
        int totalSum = 0;
        for (int i = 0; i < values.length; i++) {
            totalSum += values[i];
            switch (values[i] % 7) {
                case 0:
                    countDivisibleBySeven++;
                case 5:
                    countEven++;
                    totalElements++;
                    break;
                default:
                    countOdd++;
                    totalElements++;
            }
        }
        return totalElements;
    }
}

------------------------------------------------------------
OCL File:
---------
class InfoProcessor {
   operation evaluateNumbers() : int
  pre: true
  post: true
  activity: (     var values : Sequence(int) ; values := Sequence{92,77,68,84,54,72,56,68,74,81,95} ;
     var countEven : int ; countEven := 0 ;
    var countOdd : int ; countOdd := 0 ;
    var countDivisibleBySeven : int ; countDivisibleBySeven := 0 ;
    var totalElements : int ; totalElements := 0 ;
    var totalSum : int ; totalSum := 0 ;
        var i : int ; i := 0 ; while i < values->size() do ( (     totalSum := totalSum+(values[i+1]) ; 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (values[i+1] mod 7) ; 
       if _switchval = 0 then
     countDivisibleBySeven := countDivisibleBySeven + 1 ; 
   else skip ;
       if _switchval = 5 then
     countEven := countEven + 1 ; 
    totalElements := totalElements + 1 ; 
    break 
   else skip ;
       if true then
     countOdd := countOdd + 1 ; 
    totalElements := totalElements + 1 ; 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    return totalElements 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class TaskExecutor {
    void executeAction() {
        boolean isSuccessful = true;
        int extraAmount = 250;
        String result = "Finished";
        double executionTime = 15.78;
        System.out.println(System.currentTimeMillis());
        System.out.println(System.getProperty("os.name"));
        System.exit(1);
    }
}

------------------------------------------------------------
OCL File:
---------
class TaskExecutor {
   operation executeAction() : void
  pre: true
  post: true
  activity: (     var isSuccessful : boolean ; isSuccessful := true ;
     var extraAmount : int ; extraAmount := 250 ;
    var result : String ; result := "Finished" ;
    var executionTime : double ; executionTime := 15.78 ;
    OclFile["System.out"].println(OclDate.getSystemTime()) ; 
    OclFile["System.out"].println(OclProcess.getEnvironmentProperty("os.name")) ; 
OclProcess.exit(1) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class HealthMetrics {
  public static void main(String[] args) throws IOException { 
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    double height = Double.parseDouble(reader.readLine());
    double weight = Double.parseDouble(reader.readLine());
    int x=10;
    double g=9.9;
    g=g+9;
    double bmi = weight / (height * height);
    System.out.println(bmi); 
  } 
}

------------------------------------------------------------
OCL File:
---------
class HealthMetrics {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var height : double ; height := (reader.readLine())->toReal() ;
    var weight : double ; weight := (reader.readLine())->toReal() ;
    var x : int ; x := 10 ;
    var g : double ; g := 9.9 ;
    g := g + 9 ; 
    var bmi : double ; bmi := weight / (height * height) ;
    OclFile["System.out"].println(bmi) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class JobHandler implements Runnable {
    private String jobId;
    public JobHandler(String id) {
        jobId = id;
    }
    public void run() {
        for (int j = 0; j < 20; j++) {
            System.out.println("Executing step " + j + " for " + jobId);
        }
    }
}
class Assistant {
    int y=8;
    String name = "Basic";
    int count = 7;
    public Assistant(String name) {
        this.name = name;
        this.count = 12;
    }
    public void showDetails() {
        double uuuu=999.88;
        System.out.println("Assistant Name: " + name);
        System.out.println("Assistant Count: " + count);
    }
}
public class MainApp {
    public static void main(String[] args) throws InterruptedException {
        JobHandler job1 = new JobHandler("Job1");
        Thread thread1 = new Thread(job1, "TaskThread1");
        System.out.println(Thread.activeCount());
        System.out.println(Thread.currentThread());
        Thread.sleep(2000);
        System.out.println(thread1.getName());
        System.out.println(thread1.isAlive());
        System.out.println(thread1.isDaemon());
    }
}

------------------------------------------------------------
OCL File:
---------
class JobHandler implements Runnable {
   attribute jobId : String;
   static operation newJobHandler( id : String) : JobHandler
  pre: true
  post: true
  activity:
  ( var self : JobHandler ;
    self := createJobHandler();
    self.initialise(id);
    return self );
  operation initialise( id : String) : void
  pre: true  post: true
  activity: (     jobId := id );
   operation run() : void
  pre: true
  post: true
  activity: (         var j : int ; j := 0 ; while j < 20 do ( (     OclFile["System.out"].println("Executing step " + j + " for " + jobId) )  ;     j := j + 1 ) );
}
 class Assistant {
   attribute y : int := 8;
   attribute name : String := "Basic";
   attribute count : int := 7;
   static operation newAssistant( name : String) : Assistant
  pre: true
  post: true
  activity:
  ( var self : Assistant ;
    self := createAssistant();
    self.initialise(name);
    return self );
  operation initialise( name : String) : void
  pre: true  post: true
  activity: (     self.name := name ; 
     self.count := 12 );
   operation showDetails() : void
  pre: true
  post: true
  activity: (     var uuuu : double ; uuuu := 999.88 ;
     OclFile["System.out"].println("Assistant Name: " + name) ; 
     OclFile["System.out"].println("Assistant Count: " + count) );
}
class MainApp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var job1 : JobHandler ; job1 := JobHandler.newJobHandler("Job1") ;
     var thread1 : OclProcess ; thread1 := OclProcess.newOclProcess(job1, "TaskThread1") ;
    OclFile["System.out"].println(OclProcess.activeCount()) ; 
    OclFile["System.out"].println(OclProcess.currentThread()) ; 
    OclProcess.sleep(2000) ; 
    OclFile["System.out"].println(thread1.getName()) ; 
    OclFile["System.out"].println(thread1.isAlive()) ; 
    OclFile["System.out"].println(thread1.isDaemon()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Timer;
import java.util.TimerTask;
class JobExecutor extends TimerTask {
    public void run() {
        int i=10;
        System.out.println("Job performed at " + System.currentTimeMillis());
    }
}
class TimerManager {
    public void initiateScheduling() {
        String status = "Running";
        long executionInterval = 10000L;
        int initialDelay = 2000;
        JobExecutor job = new JobExecutor();
        Timer scheduler = new Timer();
        scheduler.schedule(job, 2500L);
        scheduler.scheduleAtFixedRate(job, 1000L, 2000L);
        Thread backgroundThread = new Thread(job);
        backgroundThread.start();
    }
}

------------------------------------------------------------
OCL File:
---------
 class JobExecutor extends OclProcess {
   operation run() : void
  pre: true
  post: true
  activity: (     var i : int ; i := 10 ;
     OclFile["System.out"].println("Job performed at " + OclDate.getSystemTime()) );
}
class TimerManager {
   operation initiateScheduling() : void
  pre: true
  post: true
  activity: (     var status : String ; status := "Running" ;
     var executionInterval : long ; executionInterval := 10000L ;
    var initialDelay : int ; initialDelay := 2000 ;
    var job : JobExecutor ; job := JobExecutor.newJobExecutor() ;
    var scheduler : OclProcess ; scheduler := OclProcess.newOclProcess("","TimerTask") ;
    scheduler.schedule(job, 2500L) ; 
    scheduler.scheduleAtFixedRate(job, 1000L, 2000L) ; 
    var backgroundThread : OclProcess ; backgroundThread := OclProcess.newOclProcess(job) ;
    backgroundThread.start() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.SortedMap;
import java.util.TreeMap;
public class DataProcessor {
    public int handleSortedMap() {
        int limit = 20;
        String state = "Initialized";
        SortedMap<String, String> treeMap = new TreeMap<>();
        treeMap.put("Y", "yellow");
        treeMap.put("M", "mango");
        int limit33 = 24;
        String firstEntry = treeMap.firstKey();
        String lastEntry = treeMap.lastKey();
        SortedMap<String, String> tailMap = treeMap.tailMap("Y");
        SortedMap<String, String> rangeMap = treeMap.subMap("X", "Z");
        int size = rangeMap.size();
        double averageSize = 5678.888;
        double mngyu= averageSize / 2.0;
        return size;
    }
}

------------------------------------------------------------
OCL File:
---------
 class DataProcessor {
   operation handleSortedMap() : int
  pre: true
  post: true
  activity: (     var limit : int ; limit := 20 ;
     var state : String ; state := "Initialized" ;
    var treeMap : Map(String,String) ; treeMap := Map{} ;
    treeMap := treeMap->union(Map{"Y" |-> "yellow"}) ; 
    treeMap := treeMap->union(Map{"M" |-> "mango"}) ; 
    var limit33 : int ; limit33 := 24 ;
    var firstEntry : String ; firstEntry := treeMap->keys()->min() ;
    var lastEntry : String ; lastEntry := treeMap->keys()->max() ;
    var tailMap : Map(String,String) ; tailMap := treeMap->restrict( _key | _key >= "Y" ) ;
    var rangeMap : Map(String,String) ; rangeMap := treeMap->restrict( _key | _key < "Z" & _key >= "X" ) ;
    var size : int ; size := rangeMap.size() ;
    var averageSize : double ; averageSize := 5678.888 ;
    var mngyu : double ; mngyu := averageSize / 2.0 ;
    return size 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
public class ListManager {
    public int manageList() {
        double proportion = 23.75;
        List<String> items = new ArrayList<>(30);
        String state = "Ready";
        items.add("apple");
        items.add("banana");
        items.add("cherry");
        items.add("date");
        items.add("apple2");
        items.add("banana2");
        items.add("cherry2");
        items.add("date2");
        int capacity = 57;
        double proportion2 = 25.75;
        List<String> duplicateItems = new ArrayList<>(items);
        boolean allPresent = items.containsAll(duplicateItems);
        allPresent = items.contains("cherry");
        String currentItem = items.get(1);
        Iterator<String> itemIterator = items.iterator();
        currentItem = items.get(3);
        double proportion3 = 5.75;
        boolean cleared = items.removeAll(duplicateItems);
        return items.indexOf("banana");
    }
}

------------------------------------------------------------
OCL File:
---------
 class ListManager {
   operation manageList() : int
  pre: true
  post: true
  activity: (     var proportion : double ; proportion := 23.75 ;
     var items : Sequence(String) ; items := Sequence{} ;
    var state : String ; state := "Ready" ;
    items := items->including("apple") ; 
    items := items->including("banana") ; 
    items := items->including("cherry") ; 
    items := items->including("date") ; 
    items := items->including("apple2") ; 
    items := items->including("banana2") ; 
    items := items->including("cherry2") ; 
    items := items->including("date2") ; 
    var capacity : int ; capacity := 57 ;
    var proportion2 : double ; proportion2 := 25.75 ;
    var duplicateItems : Sequence(String) ; duplicateItems := Sequence{}->union(items) ;
    var allPresent : boolean ; allPresent := items->includesAll(duplicateItems) ;
    allPresent := items->includes("cherry") ; 
    var currentItem : String ; currentItem := items->at(1+1) ;
    var itemIterator : OclIterator ; itemIterator := items->iterator() ;
    currentItem := items->at(3+1) ; 
    var proportion3 : double ; proportion3 := 5.75 ;
    var cleared : boolean ; cleared := items->intersection(duplicateItems)->notEmpty() ;
    return items->indexOf("banana")-1 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ErrorHandler {
    public void processErrors() {
        int errorCode = 404;
        int retryAttempts = 5;        
        NullPointerException npe = new NullPointerException("null reference");
        String errorSeverity = "Critical";
        String errorDetail = "Unexpected";
        npe = new NullPointerException();
        double errorThreshold = 0.15;      
        boolean resolved = false;
        Exception numberEx = new IllegalArgumentException("invalid input");
        throw npe;
        UnsupportedOperationException unsupportedEx = new UnsupportedOperationException("feature not available");
        unsupportedEx = new UnsupportedOperationException();
        throw new IllegalArgumentException("input error");
    }
}

------------------------------------------------------------
OCL File:
---------
class ErrorHandler {
   operation processErrors() : void
  pre: true
  post: true
  activity: (     var errorCode : int ; errorCode := 404 ;
     var retryAttempts : int ; retryAttempts := 5 ;
    var npe : NullAccessException ; npe := NullAccessException("null reference") ;
    var errorSeverity : String ; errorSeverity := "Critical" ;
    var errorDetail : String ; errorDetail := "Unexpected" ;
    npe := NullAccessException() ; 
    var errorThreshold : double ; errorThreshold := 0.15 ;
    var resolved : boolean ; resolved := false ;
    var numberEx : ProgramException ; numberEx := IllegalArgumentException.newIllegalArgumentException("invalid input") ;
    error npe ; 
    var unsupportedEx : IncorrectElementException ; unsupportedEx := IncorrectElementException("feature not available") ;
    unsupportedEx := IncorrectElementException() ; 
    error IllegalArgumentException.newIllegalArgumentException("input error") ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
import java.util.List;
interface Member {
    void displayDetails();
}
class Student {
    private String name;
    public Student(String studentName) {
        name = studentName;
    }
}
class Subject {
    List<Student> enrolledStudents = new ArrayList<>();
    public void registerStudent(String studentName) {
        Student student = new Student(studentName);
        enrolledStudents.add(student);
    }
    int maxCapacity = 25;
    String subjectId = "MTH202";
}
class Educator implements Member {
    private String name;
    private String fieldExpertise;
    public Educator(String educatorName, String expertise) {
        name = educatorName;
        fieldExpertise = expertise;
    }
    @Override
    public void displayDetails() {
        System.out.println("Educator: " + name);
        System.out.println("Expertise: " + fieldExpertise);
    }
    int yearsOfExperience = 12;
    String faculty = "Mathematics";
}
class Institute {
    List<Subject> subjects = new ArrayList<>();
    List<Educator> educators = new ArrayList<>();
    public void addSubject(Subject subject) {
        subjects.add(subject);
    }
    public void addEducator(Educator educator) {
        educators.add(educator);
    }
    int totalSubjects = 8;
    int totalEducators = 15;
}
class Administrator {
    private String adminName;
    private String role;
    public Administrator(String name, String adminRole) {
        adminName = name;
        role = adminRole;
    }
    public void showAdminInfo() {
        System.out.println("Administrator: " + adminName);
        System.out.println("Role: " + role);
    }
    int yearsInRole = 5;
    String officeLocation = "Main Building";
}
class Registrar {
    public void manageEnrollment() {
        System.out.println("Managing student enrollments.");
        // Additional functionality could be added here
    }
    int processedApplications = 100;
    String officeHours = "9 AM - 5 PM";
}

------------------------------------------------------------
OCL File:
---------
 interface Member {
   operation displayDetails() : void
  pre: true
  post: true;
}
class Student {
   attribute name : String;
   static operation newStudent( studentName : String) : Student
  pre: true
  post: true
  activity:
  ( var self : Student ;
    self := createStudent();
    self.initialise(studentName);
    return self );
  operation initialise( studentName : String) : void
  pre: true  post: true
  activity: (     name := studentName );
}
class Subject {
   attribute enrolledStudents : Sequence(Student) := Sequence{};
   operation registerStudent( studentName : String) : void
  pre: true
  post: true
  activity: (     var student : Student ; student := Student.newStudent(studentName) ;
     enrolledStudents := enrolledStudents->including(student) );
   attribute maxCapacity : int := 25;
   attribute subjectId : String := "MTH202";
}
class Educator implements Member {
   attribute name : String;
   attribute fieldExpertise : String;
   static operation newEducator( educatorName : String, expertise : String) : Educator
  pre: true
  post: true
  activity:
  ( var self : Educator ;
    self := createEducator();
    self.initialise(educatorName, expertise);
    return self );
  operation initialise( educatorName : String, expertise : String) : void
  pre: true  post: true
  activity: (     name := educatorName ; 
     fieldExpertise := expertise );
      operation displayDetails() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Educator: " + name) ; 
     OclFile["System.out"].println("Expertise: " + fieldExpertise) );
   attribute yearsOfExperience : int := 12;
   attribute faculty : String := "Mathematics";
}
class Institute {
   attribute subjects : Sequence(Subject) := Sequence{};
   attribute educators : Sequence(Educator) := Sequence{};
   operation addSubject( subject : Subject) : void
  pre: true
  post: true
  activity: (     subjects := subjects->including(subject) );
   operation addEducator( educator : Educator) : void
  pre: true
  post: true
  activity: (     educators := educators->including(educator) );
   attribute totalSubjects : int := 8;
   attribute totalEducators : int := 15;
}
class Administrator {
   attribute adminName : String;
   attribute role : String;
   static operation newAdministrator( name : String, adminRole : String) : Administrator
  pre: true
  post: true
  activity:
  ( var self : Administrator ;
    self := createAdministrator();
    self.initialise(name, adminRole);
    return self );
  operation initialise( name : String, adminRole : String) : void
  pre: true  post: true
  activity: (     adminName := name ; 
     role := adminRole );
   operation showAdminInfo() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Administrator: " + adminName) ; 
     OclFile["System.out"].println("Role: " + role) );
   attribute yearsInRole : int := 5;
   attribute officeLocation : String := "Main Building";
}
class Registrar {
   operation manageEnrollment() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Managing student enrollments.") );
   attribute processedApplications : int := 100;
   attribute officeHours : String := "9 AM - 5 PM";
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class X {
    int primaryValue = 12;
    int secondaryValue = 24;
}
public class Y {
    double piApproximation = 3.1415;
    String greeting = "Welcome!";
    boolean status = true;
    int code = 2024;
}

------------------------------------------------------------
OCL File:
---------
class X {
   attribute primaryValue : int := 12;
   attribute secondaryValue : int := 24;
}
 class Y {
   attribute piApproximation : double := 3.1415;
   attribute greeting : String := "Welcome!";
   attribute status : boolean := true;
   attribute code : int := 2024;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class PrimeChecker {
    public boolean checkPrimeStatus() {
        {
            double hh=878.8787;
            boolean[] flags = new boolean[200];
            Arrays.fill(flags, true);
            int i=15;
            for (int number = 2; number < 20; number++) {
                for (int multiplier = 2; multiplier * number < 200; multiplier++) {
                    flags[multiplier * number] = false;
                }
            }
            try {
                return flags[157];
            } catch (ArrayIndexOutOfBoundsException ex) {
                return false;
            }
        }
    }
}

------------------------------------------------------------
OCL File:
---------
class PrimeChecker {
   operation checkPrimeStatus() : boolean
  pre: true
  post: true
  activity: ( (     var hh : double ; hh := 878.8787 ;
     var flags : Sequence(boolean) ; flags := Integer.subrange(1,200)->collect(false) ;
    flags := flags->collect(true) ; 
    var i : int ; i := 15 ;
        var number : int ; number := 2 ; while number < 20 do ( (         var multiplier : int ; multiplier := 2 ; while multiplier * number < 200 do ( (     flags[multiplier * number+1] := false )  ;     multiplier := multiplier + 1 ) )  ;     number := number + 1 ) ; 
    try (     return flags[157+1] )   catch (ex : IndexingException) do (     return false )
 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class VectorMetrics {
    public static double calculateMagnitude(double[] vectorA, double[] vectorB) {
        int eee=80;
        double sum = 0.0;
        for (int i = 0; i < vectorA.length && i < vectorB.length; i++) {
            double diff = vectorA[i] - vectorB[i];
            sum += diff * diff;
        }
        int yyyy=98;
        double multiplier = 1.5;
        return multiplier * Math.sqrt(sum);
    }
}

------------------------------------------------------------
OCL File:
---------
class VectorMetrics {
  static   operation calculateMagnitude( vectorA : Sequence(double), vectorB : Sequence(double)) : double
  pre: true
  post: true
  activity: (     var eee : int ; eee := 80 ;
     var sum : double ; sum := 0.0 ;
        var i : int ; i := 0 ; while i < vectorA->size() & i < vectorB->size() do ( (     var diff : double ; diff := vectorA[i+1] - vectorB[i+1] ;
     sum := sum+(diff * diff) )  ;     i := i + 1 ) ; 
    var yyyy : int ; yyyy := 98 ;
    var multiplier : double ; multiplier := 1.5 ;
    return multiplier * (sum)->sqrt() 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class ScoreTracker {
  int excellent = 0; 
  int good = 0; 
  int average = 0; 
  int belowAverage = 0; 
  int failing = 0; 
  ScoreTracker() { 
  } 
  public void categorizeScores() { 
    int[] scores = {62, 58, 54, 45, 40, 32, 25, 15, 100,53,66}; 
    for (int i = 0; i < scores.length; i++) { 
      switch (scores[i] / 10) { 
        case 9: 
        case 8: 
        case 7: 
        case 6: 
          excellent++; 
          break; 
        case 5: 
          good++;
          break; 
        case 4: 
          average++;
          break;  
        case 3: 
          belowAverage++;
          break;  
        default: 
          failing++;
      } 
    } 
  } 
}

------------------------------------------------------------
OCL File:
---------
class ScoreTracker {
   attribute excellent : int := 0;
   attribute good : int := 0;
   attribute average : int := 0;
   attribute belowAverage : int := 0;
   attribute failing : int := 0;
   static operation newScoreTracker() : ScoreTracker
  pre: true
  post: true
  activity:
  ( var self : ScoreTracker ;
    self := createScoreTracker();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   operation categorizeScores() : void
  pre: true
  post: true
  activity: (     var scores : Sequence(int) ; scores := Sequence{62,58,54,45,40,32,25,15,100,53,66} ;
         var i : int ; i := 0 ; while i < scores->size() do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (scores[i+1] / 10) ; 
    if _switchval = 9 or _switchval = 8 or _switchval = 7 or _switchval = 6 then
    excellent := excellent + 1 ; 
    break 
   else skip ;
       if _switchval = 5 then
     good := good + 1 ; 
    break 
   else skip ;
       if _switchval = 4 then
     average := average + 1 ; 
    break 
   else skip ;
       if _switchval = 3 then
     belowAverage := belowAverage + 1 ; 
    break 
   else skip ;
       if true then
     failing := failing + 1 ; 
   else skip ;
 )
 )  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ListManager {
  public static boolean verifyList() {
    ArrayList<String> list = new ArrayList<>(15); 
    list.add("apple"); 
    list.add("banana"); 
    list.add("cherry"); 
    list.add("date"); 
    list.add("kewi"); 
    int x=10; 
    list.add(0, "avocado"); 
    ArrayList<String> clone1 = (ArrayList<String>) list.clone();
    ArrayList<String> clone2 = (ArrayList<String>) list.clone(); 
    list.addAll(3, clone2);
    x=x+10; 
    String item = list.get(6); 
    return list.contains("banana");    
  }
}

------------------------------------------------------------
OCL File:
---------
class ListManager {
  static   operation verifyList() : boolean
  pre: true
  post: true
  activity: (     var list : Sequence(String) ; list := Sequence{} ;
     list := list->including("apple") ; 
    list := list->including("banana") ; 
    list := list->including("cherry") ; 
    list := list->including("date") ; 
    list := list->including("kewi") ; 
    var x : int ; x := 10 ;
    list := list.insertAt(0+1,"avocado") ; 
    var clone1 : Sequence(String) ; clone1 := list->copy()->oclAsType(Sequence(String)) ;
    var clone2 : Sequence(String) ; clone2 := list->copy()->oclAsType(Sequence(String)) ;
    list := list.insertInto(3+1,clone2) ; 
    x := x + 10 ; 
    var item : String ; item := list->at(6+1) ;
    return list->includes("banana") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class CollectionHandler {
  public static boolean validateSet() { 
    HashSet<String> set = new HashSet<>(); 
    set.add("one"); 
    set.add("two"); 
    set.add("three"); 
    set.add("four"); 
    set.add("five"); 
    ArrayList<String> list = new ArrayList<>(set); 
    list.addAll(set); 
    int index = list.lastIndexOf("seven"); 
    String removedItem = list.remove(index); 
    list.set(0, "new"); 
    index = list.size(); 
    list.trimToSize(index - 1); 
    float y=3.5;
    y+=3.3; 
    return list.isEmpty(); 
  }
}

------------------------------------------------------------
OCL File:
---------
class CollectionHandler {
  static   operation validateSet() : boolean
  pre: true
  post: true
  activity: (     var set : Set(String) ; set := Set{} ;
     set := set->including("one") ; 
    set := set->including("two") ; 
    set := set->including("three") ; 
    set := set->including("four") ; 
    set := set->including("five") ; 
    var list : Sequence(String) ; list := Sequence{}->union(set) ;
    list := list->union(set) ; 
    var index : int ; index := list->lastIndexOf("seven")-1 ;
    var removedItem : String ; removedItem := list->at(index+1) ;
    list := list.setAt(0+1,"new") ; 
    index := list->size() ; 
    list := list.trimToSize(index - 1) ; 
    var y : double ; y := 3.5 ;
    y := y+(3.3) ; 
    return list->isEmpty() 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ArrayProcessor {
    public static boolean checkArrays() {
        String[] elements = {"red", "blue", "green"};
        List<String> list = Arrays.asList(elements);
        int index = Arrays.binarySearch(elements, "yellow");
        byte[] values = {65, 66, 67, 68, 255, 300,100,380};
        Arrays.fill(values, (byte) 100);
        double x=9.7;
        Arrays.sort(elements);
        Arrays.sort(elements, 0, 3);
        x=x+9.8;
        return Arrays.equals(new String[3], elements);
    }
}

------------------------------------------------------------
OCL File:
---------
class ArrayProcessor {
  static   operation checkArrays() : boolean
  pre: true
  post: true
  activity: (     var elements : Sequence(String) ; elements := Sequence{"red","blue","green"} ;
     var list : Sequence(String) ; list := elements ;
    var index : int ; index := (elements->indexOf("yellow") - 1) ;
    var values : Sequence(int) ; values := Sequence{65,66,67,68,255,300,100,380} ;
    values := values->collect((100 mod 128)) ; 
    var x : double ; x := 9.7 ;
    elements := elements->sort() ; 
    elements := elements.subrange(1,0)^(elements.subrange(0+1,3)->sort())^elements.subrange(3+1,elements.size) ; 
    x := x + 9.8 ; 
    return Integer.subrange(1,3)->collect(null) = elements 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class FinancialCalculator {
    public BigInteger calculateTotal() {
        BigDecimal amount = new BigDecimal("1234567.89");
        amount = new BigDecimal("9876543210.12");
        BigDecimal positiveAmount = amount.abs();
        int hh;
        amount = amount.add(positiveAmount);
        hh=10;
        double decimalValue1 = amount.doubleValue();
        double decimalValue2 = amount.doubleValue();
        hh=hh*5;
        amount = amount.min(positiveAmount);
        amount = positiveAmount.negate();
        return amount.toBigInteger();
    }
}

------------------------------------------------------------
OCL File:
---------
class FinancialCalculator {
   operation calculateTotal() : long
  pre: true
  post: true
  activity: (     var amount : double ; amount := double("1234567.89") ;
     amount := double("9876543210.12") ; 
    var positiveAmount : double ; positiveAmount := amount.abs() ;
    var hh : int ;
    amount := amount->excludes(positiveAmount) ; 
    hh := 10 ; 
    var decimalValue1 : double ; decimalValue1 := amount->oclAsType(double) ;
    var decimalValue2 : double ; decimalValue2 := amount->oclAsType(double) ;
    hh := hh * 5 ; 
    amount := amount->min() ; 
    amount := positiveAmount.negate() ; 
    return amount.toBigInteger() 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class NumberOperations {
    public void computeValues() {
        BigInteger baseValue = new BigInteger("20000000");
        BigInteger multiplier = BigInteger.valueOf(88888888);
        BigInteger result = baseValue.add(multiplier);
        result = baseValue.divide(BigInteger.TEN);
        double decimalValue = baseValue.doubleValue();
        result = baseValue.pow(3);
        result = baseValue.gcd(multiplier);
        int m=9;
        result = baseValue.subtract(multiplier);
        m=m+5;
        m=98;
    }
}

------------------------------------------------------------
OCL File:
---------
class NumberOperations {
   operation computeValues() : void
  pre: true
  post: true
  activity: (     var baseValue : long ; baseValue := long("20000000") ;
     var multiplier : long ; multiplier := (88888888 + "")->toLong() ;
    var result : long ; result := baseValue->excludes(multiplier) ;
    result := baseValue.divide(10) ; 
    var decimalValue : double ; decimalValue := baseValue->oclAsType(double) ;
    result := baseValue.pow(3) ; 
    result := baseValue.gcd(multiplier) ; 
    var m : int ; m := 9 ;
    result := baseValue.subtract(multiplier) ; 
    m := m + 5 ; 
    m := 98 ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class DataValidator {
    boolean isValid() {
        RuntimeException exception = new RuntimeException();
        exception = new RuntimeException("Error occurred");
        Boolean status = Boolean.TRUE;
        Boolean flag = new Boolean("false");
        boolean result = flag.booleanValue();
        return result != status.booleanValue();
    }
}

------------------------------------------------------------
OCL File:
---------
class DataValidator {
   operation isValid() : boolean
  pre: true
  post: true
  activity: (     var exception : ProgramException ; exception := ProgramException() ;
     exception := ProgramException("Error occurred") ; 
    var status : Boolean ; status := true ;
    var flag : Boolean ; flag := ("" + ("false"))->toBoolean() ;
    var result : boolean ; result := flag ;
    return result /= status 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class BitwiseOperations {
    public void performCalculations() {
        int num1 = 30;
        int num2 = 12;
        int result1 = (num1 & num2);
        int result2 = (num1 & num2);
        int result3 = (num2 & num1);
        result1 = (num1 | num2);
        result1 = num1 >> 2;
        result1 = num2 << 2;
        result1 = num1 >> 2;
        result2 = num2 << 2;
    }
}

------------------------------------------------------------
OCL File:
---------
class BitwiseOperations {
   operation performCalculations() : void
  pre: true
  post: true
  activity: (     var num1 : int ; num1 := 30 ;
     var num2 : int ; num2 := 12 ;
    var result1 : int ; result1 := (MathLib.bitwiseAnd(num1,num2)) ;
    var result2 : int ; result2 := (MathLib.bitwiseAnd(num1,num2)) ;
    var result3 : int ; result3 := (MathLib.bitwiseAnd(num2,num1)) ;
    result1 := (MathLib.bitwiseOr(num1,num2)) ; 
    result1 := (num1/(2->pow(2)))->oclAsType(long) ; 
    result1 := (num2*(2->pow(2)))->oclAsType(long) ; 
    result1 := (num1/(2->pow(2)))->oclAsType(long) ; 
    result2 := (num2*(2->pow(2)))->oclAsType(long) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class BitSetOperations {
    void processBits() {
        BitSet bitSet1 = new BitSet(5);
        int x;
        x=10;
        bitSet1.set(3);
        int count = bitSet1.cardinality();
        int size;
        float hh;
        count = bitSet1.size();
        count = bitSet1.length();
        hh=9.9;
        bitSet1.flip(1, 4);
        BitSet bitSet2 = new BitSet();
        size = bitSet2.size();
        size = bitSet2.length();
        bitSet2.set(2, 5);
        bitSet1.or(bitSet2);
    }
}

------------------------------------------------------------
OCL File:
---------
class BitSetOperations {
   operation processBits() : void
  pre: true
  post: true
  activity: (     var bitSet1 : Sequence(boolean) ; bitSet1 := MathLib.toBitSequence(5) ;
     var x : int ;
    x := 10 ; 
    bitSet1 := bitSet1.setAt(3+1, true) ; 
    var count : int ; count := bitSet1.cardinality() ;
    var size : int ;
    var hh : double ;
    count := bitSet1->size() ; 
    count := bitSet1->size() ; 
    hh := 9.9 ; 
    bitSet1 := bitSet1.flip(1, 4) ; 
    var bitSet2 : Sequence(boolean) ; bitSet2 := MathLib.toBitSequence() ;
    size := bitSet2->size() ; 
    size := bitSet2->size() ; 
    bitSet2 := bitSet2.setAt(2+1,5) ; 
    bitSet1 := bitSet1.or(bitSet2) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class FinancialCalculator {
    private double cost = 0; 
    private double amount = 0; 
    private int frequency = 0; 
    private double rate = 0; 
    private double duration = 0; 
    private String identifier = ""; 
    private double termLength = 0; 
    public FinancialCalculator() {
        this.identifier = "";
        this.frequency = 0;
        this.rate = 0.0;
        this.duration = 0.0;
        this.termLength = 0.0;
        this.cost = 0.0;
        this.amount = 0.0;
    }
    public double discount(double principal, double interestRate, double time) { 
        double result = 0;
        if (interestRate <= -1 || time < 0) { 
            return result; 
        } 
        result = principal / Math.pow((1 + interestRate), time);
        return result;
    }
    public double calculateValue(double interestRate) { 
        double result = 0.0;
        if (interestRate <= -1) { 
            return result; 
        } 
        final int upperLimit = (int) Math.floor(termLength * frequency); 
        final double coupon = cost / frequency; 
        final double period = 1.0 / frequency;
        for (int i = 1; i <= upperLimit; i++) { 
            result = result + this.discount(coupon, interestRate, i * period); 
        } 
        result = result + this.discount(100, interestRate, termLength);
        return result;
    }
    public double totalDiscount(double principal, double interestRate, double time) { 
        double result = 0.0;
        if (interestRate <= -1 || time < 0) { 
            return result; 
        } 
        result = (principal * time) / Math.pow((1 + interestRate), time);
        return result;
    }
    public double macaulayDuration(double interestRate) { 
        double result = 0;
        if (interestRate <= -1) { 
            return result; 
        } 
        final int upperLimit = (int) Math.floor(termLength * frequency); 
        final double coupon = cost / frequency; 
        final double period = 1.0 / frequency;
        for (int i = 1; i <= upperLimit; i++) { 
            result = result + this.totalDiscount(coupon, interestRate, i * period); 
        } 
        result = result + this.totalDiscount(100, interestRate, termLength); 
        result = result / this.calculateValue(interestRate);
        return result;
    }
    public double findInterestRate(double interestRate, double lowerBound, double upperBound) { 
        double result = 0;
        if (interestRate <= -1 || lowerBound <= -1 || upperBound <= -1) { 
            return result; 
        } 
        final double value = this.calculateValue(interestRate); 
        result = ((upperBound - lowerBound < 0.001) ? (interestRate) : 
                  ((value > amount) ? (this.findInterestRate((upperBound + interestRate) / 2, interestRate, upperBound)) : 
                                      (this.findInterestRate((interestRate + lowerBound) / 2, lowerBound, interestRate))));
        return result;
    }
}

------------------------------------------------------------
OCL File:
---------
class FinancialCalculator {
   attribute cost : double := 0;
   attribute amount : double := 0;
   attribute frequency : int := 0;
   attribute rate : double := 0;
   attribute duration : double := 0;
   attribute identifier : String := "";
   attribute termLength : double := 0;
   static operation newFinancialCalculator() : FinancialCalculator
  pre: true
  post: true
  activity:
  ( var self : FinancialCalculator ;
    self := createFinancialCalculator();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.identifier := "" ; 
     self.frequency := 0 ; 
    self.rate := 0.0 ; 
    self.duration := 0.0 ; 
    self.termLength := 0.0 ; 
    self.cost := 0.0 ; 
    self.amount := 0.0 ; 
 );
   operation discount( principal : double, interestRate : double, time : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
     if (interestRate <= -1 or time < 0) then (     return result ) else skip ; 
     result := principal / (1 + interestRate)->pow(time) ; 
     return result );
   operation calculateValue( interestRate : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0.0 ;
     if (interestRate <= -1) then (     return result ) else skip ; 
    var upperLimit : int ; upperLimit := (termLength * frequency)->floor()->oclAsType(int) ;
    var coupon : double ; coupon := cost / frequency ;
    var period : double ; period := 1.0 / frequency ;
        var i : int ; i := 1 ; while i <= upperLimit do ( (     result := result + self.discount(coupon, interestRate, i * period) )  ;     i := i + 1 ) ; 
    result := result + self.discount(100, interestRate, termLength) ; 
    return result 
 );
   operation totalDiscount( principal : double, interestRate : double, time : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0.0 ;
     if (interestRate <= -1 or time < 0) then (     return result ) else skip ; 
     result := (principal * time) / (1 + interestRate)->pow(time) ; 
     return result );
   operation macaulayDuration( interestRate : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
     if (interestRate <= -1) then (     return result ) else skip ; 
    var upperLimit : int ; upperLimit := (termLength * frequency)->floor()->oclAsType(int) ;
    var coupon : double ; coupon := cost / frequency ;
    var period : double ; period := 1.0 / frequency ;
        var i : int ; i := 1 ; while i <= upperLimit do ( (     result := result + self.totalDiscount(coupon, interestRate, i * period) )  ;     i := i + 1 ) ; 
    result := result + self.totalDiscount(100, interestRate, termLength) ; 
    result := result / self.calculateValue(interestRate) ; 
    return result 
 );
   operation findInterestRate( interestRate : double, lowerBound : double, upperBound : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
     if (interestRate <= -1 or lowerBound <= -1 or upperBound <= -1) then (     return result ) else skip ; 
    var value : double ; value := self.calculateValue(interestRate) ;
    result := (if (upperBound - lowerBound < 0.001) then (interestRate) else (if (value > amount) then (self.findInterestRate((upperBound + interestRate) / 2, interestRate, upperBound)) else (self.findInterestRate((interestRate + lowerBound) / 2, lowerBound, interestRate)) endif) endif) ; 
    return result 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class FileReaderUtil {
    public String readFile() { 
        File file = new File("data.txt"); 
        BufferedReader reader = new BufferedReader(new FileReader(file)); 
        int a=10;
        if (reader.ready()) { 
            String content = reader.readLine(); 
            reader.close();
            a+=1;  
            return content; 
        } 
        return null;
    }
}

------------------------------------------------------------
OCL File:
---------
class FileReaderUtil {
   operation readFile() : String
  pre: true
  post: true
  activity: (     var file : OclFile ; file := OclFile("data.txt") ;
     var reader : OclFile ; reader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(file)) ;
    var a : int ; a := 10 ;
    if (reader.canRead()) then (     var content : String ; content := reader.readLine() ;
     skip ; 
     a := a+(1) ; 
     return content ) else skip ; 
    return null 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class FileWriterDemo {
    void writeToFile() { 
        try {
            BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"));
            writer.write("Hello World!", 0, 12);
            writer.newLine();
            writer.newLine();
            double t=9.7;
            char[] chars = {'a', 'b', 'c','u','o'};
            writer.write(chars, 0, 3);
            writer.flush();
            writer.close();
        } catch (Exception e) {
            e.printStackTrace(); 
        } 
    }
}

------------------------------------------------------------
OCL File:
---------
class FileWriterDemo {
   operation writeToFile() : void
  pre: true
  post: true
  activity: (     try (     var writer : OclFile ; writer := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("output.txt"))) ;
     skip ; 
    skip ; 
    skip ; 
    var t : double ; t := 9.7 ;
    var chars : Sequence(String) ; chars := Sequence{'a','b','c','u','o'} ;
    skip ; 
    skip ; 
    skip ; 
 )   catch (e : ProgramException) do (     e.printStackTrace() )
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class ByteOperations {
    public int compareBytes() {
        Byte byteValue = new Byte((byte) 123); 
        byteValue = new Byte("0x7F"); 
        byte u = byteValue.byteValue(); 
        u = Byte.parseByte("100", 10); 
        u = Byte.decode("0x4B"); 
        return byteValue.compareTo(new Byte("10"));
    }
}

------------------------------------------------------------
OCL File:
---------
class ByteOperations {
   operation compareBytes() : int
  pre: true
  post: true
  activity: (     var byteValue : int ; byteValue := ("" + ((123 mod 128)))->toInteger() ;
     byteValue := ("" + ("0x7F"))->toInteger() ; 
    var u : int ; u := byteValue->oclAsType(int) ;
    u := ("100")->toInteger() ; 
    u := ("0x4B")->toInteger() ; 
    return byteValue->compareTo(("" + ("10"))->toInteger()) 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class TimeHandler {
    long getCurrentTime() {
        Calendar calendar = new GregorianCalendar();
        int m;
        long result = calendar.getTimeInMillis();
        calendar.setTimeInMillis(50000000);
        m=10;
        Calendar newCalendar = new GregorianCalendar();
        boolean isAfter = newCalendar.after(calendar);
        boolean isStillAfter = newCalendar.after(calendar);
        m=m*9;
        return newCalendar.getTimeInMillis();
    }
}

------------------------------------------------------------
OCL File:
---------
class TimeHandler {
   operation getCurrentTime() : long
  pre: true
  post: true
  activity: (     var calendar : OclDate ; calendar := OclDate.newOclDate() ;
     var m : int ;
    var result : long ; result := calendar.time ;
    calendar.setTimeInMillis(50000000) ; 
    m := 10 ; 
    var newCalendar : OclDate ; newCalendar := OclDate.newOclDate() ;
    var isAfter : boolean ; isAfter := newCalendar.dateAfter(calendar) ;
    var isStillAfter : boolean ; isStillAfter := newCalendar.dateAfter(calendar) ;
    m := m * 9 ; 
    return newCalendar.time 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector;
import java.util.List;
class Combinatorics {
    public static int calculateProduct(int start, int end) {
        int result = 1;
        for (int i = start; i <= end; i++) {
            result = result * i;
        }
        return result;
    }
    public static int calculateCombination(int total, int selection) {
        int result = 0;
        if (total < selection || selection < 0) {
            return result;
        }
        if (total - selection < selection) {
            result = 
                Combinatorics.calculateProduct(selection + 1, total) / 
                Combinatorics.calculateProduct(1, total - selection);
        } else {
            result = 
                Combinatorics.calculateProduct(total - selection + 1, total) / 
                Combinatorics.calculateProduct(1, selection);
        }
        return result;
    }
}
class Department {
    String name = "";
    int count = 0;
    double chance = 0;
    double effect = 0;
    int rank = 0;
    double average = 0;
    List teamMembers = new Vector();
    public Department() {
        this.name = "";
        this.count = 0;
        this.chance = 0.0;
        this.effect = 0.0;
        this.rank = 0;
        this.average = 0.0;
    }
    public double calculateNonPropagation(int affected) {
        double result = 0.0;
        double unaffectedChance = Math.pow((1 - chance), count - affected);
        double affectedChance = Math.pow(chance, affected);
        double noSpread = Math.pow((1 - effect), affected * (count - affected));
        result = unaffectedChance * affectedChance * noSpread;
        return result;
    }
    public double calculatePropagation(int failed, int affected) {
        double result = 0;
        double unaffectedChance = Math.pow((1 - chance), count - failed);
        double failedChance = Math.pow(chance, failed);
        double noInfectionChance = Math.pow((1 - effect), failed * (count - affected));
        double infectionChance = Math.pow((1 - Math.pow((1 - effect), failed)), affected - failed);
        result = unaffectedChance * failedChance * noInfectionChance * 
                 infectionChance * 
                 Combinatorics.calculateCombination(affected, failed);
        return result;
    }
    public double calculateMemberLoss(int index) {
        double result = 0;
        TeamMember member = (TeamMember) teamMembers.get(index - 1);
        result = member.ratio * member.entity.rank;
        return result;
    }
}
class Investment {
    private double baseChance = 0;
    private List departments = new Vector();
    public Investment() {
        this.baseChance = 0;
    }
    public double computeConditionalChance(int index, int affected) {
        double result = 0;
        if (affected >= 1) {
            Department department = (Department) departments.get(index - 1);
            result = 1.0 / 
                (1 - Math.pow((1 - department.chance), department.count));
        } else {
            result = 0;
        }
        return result;
    }
}
class Entity {
    String title = "";
    int rank = 0;
    double probability = 0.0;
    public Entity() {
        this.title = "";
        this.rank = 0;
        this.probability = 0.0;
    }
}
class TeamMember {
    double ratio = 0.0;
    double portion = 0.0;
    Entity entity;
    public TeamMember(Entity entity) {
        this.ratio = 0.0;
        this.portion = 0.0;
        this.entity = entity;
    }
    public TeamMember() { }
}

------------------------------------------------------------
OCL File:
---------
 class Combinatorics {
  static   operation calculateProduct( start : int, end : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 1 ;
         var i : int ; i := start ; while i <= end do ( (     result := result * i )  ;     i := i + 1 ) ; 
     return result );
  static   operation calculateCombination( total : int, selection : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     if (total < selection or selection < 0) then (     return result ) else skip ; 
     if (total - selection < selection) then (     result := Combinatorics.calculateProduct(selection + 1, total) / Combinatorics.calculateProduct(1, total - selection) ) else (     result := Combinatorics.calculateProduct(total - selection + 1, total) / Combinatorics.calculateProduct(1, selection) ) ;  
     return result );
}
class Department {
   attribute name : String := "";
   attribute count : int := 0;
   attribute chance : double := 0;
   attribute effect : double := 0;
   attribute rank : int := 0;
   attribute average : double := 0;
   attribute teamMembers : Sequence := Sequence{};
   static operation newDepartment() : Department
  pre: true
  post: true
  activity:
  ( var self : Department ;
    self := createDepartment();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.name := "" ; 
     self.count := 0 ; 
    self.chance := 0.0 ; 
    self.effect := 0.0 ; 
    self.rank := 0 ; 
    self.average := 0.0 ; 
 );
   operation calculateNonPropagation( affected : int) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0.0 ;
     var unaffectedChance : double ; unaffectedChance := (1 - chance)->pow(count - affected) ;
    var affectedChance : double ; affectedChance := chance->pow(affected) ;
    var noSpread : double ; noSpread := (1 - effect)->pow(affected * (count - affected)) ;
    result := unaffectedChance * affectedChance * noSpread ; 
    return result 
 );
   operation calculatePropagation( failed : int, affected : int) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
     var unaffectedChance : double ; unaffectedChance := (1 - chance)->pow(count - failed) ;
    var failedChance : double ; failedChance := chance->pow(failed) ;
    var noInfectionChance : double ; noInfectionChance := (1 - effect)->pow(failed * (count - affected)) ;
    var infectionChance : double ; infectionChance := (1 - (1 - effect)->pow(failed))->pow(affected - failed) ;
    result := unaffectedChance * failedChance * noInfectionChance * infectionChance * Combinatorics.calculateCombination(affected, failed) ; 
    return result 
 );
   operation calculateMemberLoss( index : int) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
     var member : TeamMember ; member := teamMembers->at(index - 1+1)->oclAsType(TeamMember) ;
     result := member.ratio * member.entity.rank ; 
     return result );
}
class Investment {
   attribute baseChance : double := 0;
   attribute departments : Sequence := Sequence{};
   static operation newInvestment() : Investment
  pre: true
  post: true
  activity:
  ( var self : Investment ;
    self := createInvestment();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.baseChance := 0 );
   operation computeConditionalChance( index : int, affected : int) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
     if (affected >= 1) then (     var department : Department ; department := departments->at(index - 1+1)->oclAsType(Department) ;
     result := 1.0 / (1 - (1 - department.chance)->pow(department.count)) ) else (     result := 0 ) ;  
     return result );
}
class Entity {
   attribute title : String := "";
   attribute rank : int := 0;
   attribute probability : double := 0.0;
   static operation newEntity() : Entity
  pre: true
  post: true
  activity:
  ( var self : Entity ;
    self := createEntity();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.title := "" ; 
     self.rank := 0 ; 
     self.probability := 0.0 );
}
class TeamMember {
   attribute ratio : double := 0.0;
   attribute portion : double := 0.0;
   attribute entity : Entity;
   static operation newTeamMember( entity : Entity) : TeamMember
  pre: true
  post: true
  activity:
  ( var self : TeamMember ;
    self := createTeamMember();
    self.initialise(entity);
    return self );
  operation initialise( entity : Entity) : void
  pre: true  post: true
  activity: (     self.ratio := 0.0 ; 
     self.portion := 0.0 ; 
     self.entity := entity );
   static operation newTeamMember() : TeamMember
  pre: true
  post: true
  activity:
  ( var self : TeamMember ;
    self := createTeamMember();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class CharHelper {
    public int executeCalculation() {
        int outcome = (int) 'G';
        outcome = 'm' - 'b';
        outcome = '9' - 49;
        int adjustment = 3;
        outcome += adjustment;
        return outcome;
    }
}

------------------------------------------------------------
OCL File:
---------
class CharHelper {
   operation executeCalculation() : int
  pre: true
  post: true
  activity: (     var outcome : int ; outcome := ('G')->char2byte() ;
     outcome := ('m')->char2byte() - ('b')->char2byte() ; 
    outcome := ('9')->char2byte() - 49 ; 
    var adjustment : int ; adjustment := 3 ;
    outcome := outcome+(adjustment) ; 
    return outcome 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Field;
public class ClassInspector {
    public void showFieldNames() throws ClassNotFoundException {
        Class<?> myClass = Class.forName("java.util.ArrayList");
        int x=9;
        double g=5.5;
        Field[] classFields = myClass.getDeclaredFields();
        for (int i = 0; i < classFields.length; i++) {
            System.out.println(classFields[i].getName());
        }
    }
}

------------------------------------------------------------
OCL File:
---------
 class ClassInspector {
   operation showFieldNames() : void
  pre: true
  post: true
  activity: (     var myClass : OclType ; myClass := OclType["java.util.ArrayList"] ;
     var x : int ; x := 9 ;
    var g : double ; g := 5.5 ;
    var classFields : Sequence(OclAttribute) ; classFields := myClass.getDeclaredFields() ;
        var i : int ; i := 0 ; while i < classFields->size() do ( (     OclFile["System.out"].println(classFields[i+1].getName()) )  ;     i := i + 1 ) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class CalculationEngine {
    public int computeResult() {
        int value = 50;
        value = value * 7;
        value -= 6;
        value += 12;        
        return value + 15;
    }
}

------------------------------------------------------------
OCL File:
---------
class CalculationEngine {
   operation computeResult() : int
  pre: true
  post: true
  activity: (     var value : int ; value := 50 ;
     value := value * 7 ; 
    value := value-(6) ; 
    value := value+(12) ; 
    return value + 15 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CollectionHandler {
    public String processCollections() {
        int a=10;
        List<String> myList = Collections.emptyList();
        myList = Collections.nCopies(7, "abc");
        double y=9.99; 
        int pos = Collections.binarySearch(myList, "xyz");
        List<String> singleElementList = Collections.singletonList("xyz");
        pos = Collections.lastIndexOfSubList(myList, singleElementList);
        Collections.replaceAll(myList, "abc", "def");
        Collections.reverse(myList);
        y=y+y;
        return (String) Collections.max(myList);
    }
}

------------------------------------------------------------
OCL File:
---------
 class CollectionHandler {
   operation processCollections() : String
  pre: true
  post: true
  activity: (     var a : int ; a := 10 ;
     var myList : Sequence(String) ; myList := .emptyList() ;
    myList := Integer.subrange(1,7)->collect("abc") ; 
    var y : double ; y := 9.99 ;
    var pos : int ; pos := .binarySearch(myList, "xyz") ;
    var singleElementList : Sequence(String) ; singleElementList := .singletonList("xyz") ;
    pos := (myList->lastIndexOf(singleElementList)-1) ; 
    myList := myList->collect( x1 | if x1 = "abc" then "def" else x1 endif ) ; 
    myList := myList->reverse() ; 
    y := y + y ; 
    return  myList->max()->oclAsType(String) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class CollectionOperations {
    public void performOperations() {
        Vector v = new Vector(10, 40); 
        ArrayList a = new ArrayList(v); 
        Hashtable h = new Hashtable(5, 0.5); 
        a.add("jjjjjjj"); 
        v = new Vector(); 
        int x=10;
        h = new Hashtable();
        x=x+10; 
        x++;
        h = new Hashtable(2000); 
        Hashtable newHashtable = new Hashtable(h); 
    }
}
------------------------------------------------------------
OCL File:
---------
class CollectionOperations {
   operation performOperations() : void
  pre: true
  post: true
  activity: (     var v : Sequence ; v := Sequence{} ;
     var a : Sequence ; a := Sequence{}->union(v) ;
    var h : Map ; h := Map{} ;
    a := a->including("jjjjjjj") ; 
    v := Sequence{} ; 
    var x : int ; x := 10 ;
    h := Map{} ; 
    x := x + 10 ; 
    x := x + 1 ; 
    h := Map{} ; 
    var newHashtable : Map ; newHashtable := Map{}->union(h) ;
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Symbol
{
    String category = "NOUN";
    String value = "";
    public static int calculateLengthSum()
    {
        Symbol s1 = new Symbol();
        s1.value = "Apple";
        Symbol s2 = new Symbol();
        s2.value = "exploration";
        s2.category = "ACTION";
        Symbol s3 = new Symbol();
        s3.value = "bigger";
        s3.category = "DESCRIPTOR";
        Symbol s4 = new Symbol();
        s4.value = "rrrrrrr";
        ArrayList<Symbol> symbolList = new ArrayList<Symbol>();
        symbolList.add(s1);
        symbolList.add(s2);
        symbolList.add(s3);
        symbolList.add(s4); 
        int totalLength = symbolList.stream()
                                    .filter(s -> s.category.equals("NOUN"))
                                    .mapToInt(s -> s.value.length())
                                    .sum();
        return totalLength;
    }
}

------------------------------------------------------------
OCL File:
---------
class Symbol {
   attribute category : String := "NOUN";
   attribute value : String := "";
  static   operation calculateLengthSum() : int
  pre: true
  post: true
  activity: (     var s1 : Symbol ; s1 := Symbol.newSymbol() ;
     s1.value := "Apple" ; 
    var s2 : Symbol ; s2 := Symbol.newSymbol() ;
    s2.value := "exploration" ; 
    s2.category := "ACTION" ; 
    var s3 : Symbol ; s3 := Symbol.newSymbol() ;
    s3.value := "bigger" ; 
    s3.category := "DESCRIPTOR" ; 
    var s4 : Symbol ; s4 := Symbol.newSymbol() ;
    s4.value := "rrrrrrr" ; 
    var symbolList : Sequence(Symbol) ; symbolList := Sequence{} ;
    symbolList := symbolList->including(s1) ; 
    symbolList := symbolList->including(s2) ; 
    symbolList := symbolList->including(s3) ; 
    symbolList := symbolList->including(s4) ; 
    var totalLength : int ; totalLength := symbolList->select( _x1 | (lambda s : OclAny in s.category = "NOUN")->apply(_x1) )->collect( _x1 | (lambda s : OclAny in s.value->size())->apply(_x1) )->sum() ;
    return totalLength 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Notification
{
  public Notification() { }
  /*  ssasa sasa sasa sasa  */
  @Override
  public String toString() 
  { return "Notification object"; }
/* fdg fggf ghgh hjjjh */
}

------------------------------------------------------------
OCL File:
---------
class Notification {
   static operation newNotification() : Notification
  pre: true
  post: true
  activity:
  ( var self : Notification ;
    self := createNotification();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
      operation toString() : String
  pre: true
  post: true
  activity: (     return "Notification object" );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class EvaluateEntities {
    public int evaluate(Sortable item1, Sortable item2) {
        int x = 5;
        double y = 3.14;
        if (item1 != null && item2 != null) {
            return item1.compareTo(item2);
        }
        return 1;
    }
}

------------------------------------------------------------
OCL File:
---------
class EvaluateEntities {
   operation evaluate( item1 : Sortable, item2 : Sortable) : int
  pre: true
  post: true
  activity: (     var x : int ; x := 5 ;
     var y : double ; y := 3.14 ;
     if (item1 /= null & item2 /= null) then (     return item1->compareTo(item2) ) else skip ; 
     return 1 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Person {
    String id = "";
    int age = 10;
    double height = 5.9;
    Person(String newId) {
        id = newId;
    }
    public String getId() {
        return id;
    }
    public int increaseYears() {
        age += 2;
        return age;
    }
    public static void main(String[] args) {
        Person individual = new Person("Alice");
        System.out.println("ID: " + individual.getId());
        System.out.println("Updated Age: " + individual.increaseYears());
    }
}

------------------------------------------------------------
OCL File:
---------
class Person {
   attribute id : String := "";
   attribute age : int := 10;
   attribute height : double := 5.9;
   static operation newPerson( newId : String) : Person
  pre: true
  post: true
  activity:
  ( var self : Person ;
    self := createPerson();
    self.initialise(newId);
    return self );
  operation initialise( newId : String) : void
  pre: true  post: true
  activity: (     id := newId );
   operation getId() : String
  pre: true
  post: true
  activity: (     return id );
   operation increaseYears() : int
  pre: true
  post: true
  activity: (     age := age+(2) ; 
     return age );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var individual : Person ; individual := Person.newPerson("Alice") ;
     OclFile["System.out"].println("ID: " + individual.getId()) ; 
     OclFile["System.out"].println("Updated Age: " + individual.increaseYears()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class X {
    private Y<M>.Z<N> property;
    int count = 42;
    String message = "Hello, World!";
    public static void main(String[] args) {
        X instance = new X();
        System.out.println("Program has been updated.");
        System.out.println("Count: " + instance.count);
        System.out.println("Message: " + instance.message);
    }
}

------------------------------------------------------------
OCL File:
---------
class X {
   attribute property : Z<N>;
   attribute count : int := 42;
   attribute message : String := "Hello, World!";
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var instance : X ; instance := X.newX() ;
     OclFile["System.out"].println("Program has been updated.") ; 
     OclFile["System.out"].println("Count: " + instance.count) ; 
     OclFile["System.out"].println("Message: " + instance.message) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Coordinate {
    double x = 1.0;
    double y = 2.0;
    double xySum = 0.0;
    double xDiffSquared = 0.0;
    double yDiffSquared = 0.0;
    double z = 3.0;
    public static double sumX(ArrayList<Coordinate> coordinates) {
        double sum = 0;
        for (int i = 0; i < coordinates.size(); i++) {
            sum += coordinates.get(i).x;
        }
        return sum;
    }
    public static double sumY(ArrayList<Coordinate> coordinates) {
        double sum = 0;
        for (int i = 0; i < coordinates.size(); i++) {
            sum += coordinates.get(i).y;
        }
        return sum;
    }
    public static double sumXYProduct(ArrayList<Coordinate> coordinates) {
        double sum = 0;
        for (int i = 0; i < coordinates.size(); i++) {
            sum += coordinates.get(i).xySum;
        }
        return sum;
    }
    public static double sumYDiffSquared(ArrayList<Coordinate> coordinates) {
        double sum = 0;
        for (int i = 0; i < coordinates.size(); i++) {
            sum += coordinates.get(i).yDiffSquared;
        }
        return sum;
    }
}

------------------------------------------------------------
OCL File:
---------
class Coordinate {
   attribute x : double := 1.0;
   attribute y : double := 2.0;
   attribute xySum : double := 0.0;
   attribute xDiffSquared : double := 0.0;
   attribute yDiffSquared : double := 0.0;
   attribute z : double := 3.0;
  static   operation sumX( coordinates : Sequence(Coordinate)) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
         var i : int ; i := 0 ; while i < coordinates->size() do ( (     sum := sum+(coordinates->at(i+1).x) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation sumY( coordinates : Sequence(Coordinate)) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
         var i : int ; i := 0 ; while i < coordinates->size() do ( (     sum := sum+(coordinates->at(i+1).y) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation sumXYProduct( coordinates : Sequence(Coordinate)) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
         var i : int ; i := 0 ; while i < coordinates->size() do ( (     sum := sum+(coordinates->at(i+1).xySum) )  ;     i := i + 1 ) ; 
     return sum );
  static   operation sumYDiffSquared( coordinates : Sequence(Coordinate)) : double
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0 ;
         var i : int ; i := 0 ; while i < coordinates->size() do ( (     sum := sum+(coordinates->at(i+1).yDiffSquared) )  ;     i := i + 1 ) ; 
     return sum );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class TimeValidator {
    public boolean validateTimes() {
        Date now = new Date();
        long currentMillis = now.getTime();
        Date newDate = (Date) now.clone();
        newDate.setTime(10000000);
        newDate = new Date(20000000);
        long additionalValue = 30000000;
        return now.before(newDate);
    }
    public static void main(String[] args) {
        TimeValidator validator = new TimeValidator();
        System.out.println("Timestamp comparison result: " + validator.validateTimes());
    }
}

------------------------------------------------------------
OCL File:
---------
class TimeValidator {
   operation validateTimes() : boolean
  pre: true
  post: true
  activity: (     var now : OclDate ; now := OclDate.newOclDate() ;
     var currentMillis : long ; currentMillis := now.time ;
    var newDate : OclDate ; newDate := now.clone()->oclAsType(OclDate) ;
    newDate.setTime(10000000) ; 
    newDate := OclDate.newOclDate(20000000) ; 
    var additionalValue : long ; additionalValue := 30000000 ;
    return now.dateBefore(newDate) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var validator : TimeValidator ; validator := TimeValidator.newTimeValidator() ;
     OclFile["System.out"].println("Timestamp comparison result: " + validator.validateTimes()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ValueEvaluator {
    public boolean analyzeValue() {
        double initial = Double.MAX_VALUE;
        initial = Double.NEGATIVE_INFINITY;
        int result = Double.compare(10.0, initial);
        Double fraction = new Double(4.0 / 7.0);
        fraction = new Double("3.5");
        initial = Double.parseDouble(fraction.toString());
        initial = fraction.doubleValue();
        int extra = 100;
        return Double.isInfinite(initial);
    }
    public static void main(String[] args) {
        ValueEvaluator evaluator = new ValueEvaluator();
        System.out.println("Infinite check result: " + evaluator.analyzeValue());
    }
}

------------------------------------------------------------
OCL File:
---------
class ValueEvaluator {
   operation analyzeValue() : boolean
  pre: true
  post: true
  activity: (     var initial : double ; initial := (2 - 2->pow(-52))*(2->pow(1023)) ;
     initial := Math_NINFINITY ; 
    var result : int ; result := (10.0)->compareTo(initial) ;
    var fraction : double ; fraction := ("" + (4.0 / 7.0))->toReal() ;
    fraction := ("" + ("3.5"))->toReal() ; 
    initial := (fraction+"")->toReal() ; 
    initial := fraction->oclAsType(double) ; 
    var extra : int ; extra := 100 ;
    return ((initial) = Math_PINFINITY or (initial) = Math_NINFINITY) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var evaluator : ValueEvaluator ; evaluator := ValueEvaluator.newValueEvaluator() ;
     OclFile["System.out"].println("Infinite check result: " + evaluator.analyzeValue()) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class CharAnalyzer {
    public boolean analyzeCharacters() {
        Character specialChar = new Character('#');
        Class charClass = Character.TYPE;
        boolean isDigit = Character.isDigit('5');
        boolean isLetter = Character.isLetter('&');
        char maxChar = Character.MAX_VALUE;
        char minChar = Character.MIN_VALUE;
        char lowerChar = Character.toLowerCase('G');
        char charValue = specialChar.charValue();
        boolean isLowerCase = Character.isLowerCase('T');
        return Character.isJavaIdentifierPart('#');
    }
}

------------------------------------------------------------
OCL File:
---------
class CharAnalyzer {
   operation analyzeCharacters() : boolean
  pre: true
  post: true
  activity: (     var specialChar : String ; specialChar := String('#') ;
     var charClass : OclType ; charClass := ""->oclType() ;
    var isDigit : boolean ; isDigit := ('5' + "")->isMatch("[0-9]") ;
    var isLetter : boolean ; isLetter := ('&' + "")->isMatch("[a-zA-Z]") ;
    var maxChar : String ; maxChar := "\uFFFF" ;
    var minChar : String ; minChar := "\u0000" ;
    var lowerChar : String ; lowerChar := ('G' + "")->toLowerCase() ;
    var charValue : String ; charValue := specialChar+"" ;
    var isLowerCase : boolean ; isLowerCase := ('T'->toLowerCase() = 'T') ;
    return ('#'->isMatch("[0-9a-zA-Z]") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class IterationDemo {
    public int runLoop() {
        int counter = 3;
        do {
            System.out.println("Counter: " + counter);
            counter += 2;
        } while (counter <= 20);
        double extraValue = 4.5;
        return counter;
    }
    public static void main(String[] args) {
        IterationDemo demo = new IterationDemo();
        int finalValue = demo.runLoop();
        System.out.println("Final Counter: " + finalValue);
    }
}

------------------------------------------------------------
OCL File:
---------
class IterationDemo {
   operation runLoop() : int
  pre: true
  post: true
  activity: (     var counter : int ; counter := 3 ;
   while true do ((     OclFile["System.out"].println("Counter: " + counter) ; 
     counter := counter+(2) ) ;
    if (counter <= 20) then skip else break) ; 
     var extraValue : double ; extraValue := 4.5 ;
     return counter );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var demo : IterationDemo ; demo := IterationDemo.newIterationDemo() ;
     var finalValue : int ; finalValue := demo.runLoop() ;
     OclFile["System.out"].println("Final Counter: " + finalValue) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ArraySum {
    public int calculateSum() {
        int[] numbers = { 3, 6, 2, 12, 7, 8, 10, 5, 4, 11,10,4, 6 };
        int total = 0;
        for (int value : numbers) total += value;
        int extra = 50;
        return total + extra;
    }
    public static void main(String[] args) {
        ArraySum sumCalculator = new ArraySum();
        int result = sumCalculator.calculateSum();
        System.out.println("Total Sum: " + result);
    }
}

------------------------------------------------------------
OCL File:
---------
class ArraySum {
   operation calculateSum() : int
  pre: true
  post: true
  activity: (     var numbers : Sequence(int) ; numbers := Sequence{3,6,2,12,7,8,10,5,4,11,10,4,6} ;
     var total : int ; total := 0 ;
    for (value : numbers) do (     total := total+(value) ;  ) ; 
    var extra : int ; extra := 50 ;
    return total + extra 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sumCalculator : ArraySum ; sumCalculator := ArraySum.newArraySum() ;
     var result : int ; result := sumCalculator.calculateSum() ;
     OclFile["System.out"].println("Total Sum: " + result) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Hashtable;
import java.util.Enumeration;
public class DictionaryProcessor {
    public String generateResult() {
        Hashtable<String, String> table = new Hashtable<>(20);
        table.put("X", "apple");
        table.put("Y", "banana");
        table.put("Z", "cherry");
        Enumeration<String> values = table.elements();
        String combinedResult = "Fruits: ";
        while (values.hasMoreElements()) {
            combinedResult += values.nextElement() + " ";
        }
        String additionalText = "List end.";
        return combinedResult + additionalText;
    }
    public static void main(String[] args) {
        DictionaryProcessor processor = new DictionaryProcessor();
        String output = processor.generateResult();
        System.out.println(output);
    }
}

------------------------------------------------------------
OCL File:
---------
 class DictionaryProcessor {
   operation generateResult() : String
  pre: true
  post: true
  activity: (     var table : Map(String,String) ; table := Map{} ;
     table := table->union(Map{"X" |-> "apple"}) ; 
    table := table->union(Map{"Y" |-> "banana"}) ; 
    table := table->union(Map{"Z" |-> "cherry"}) ; 
    var values : Enumeration<String> ; values := table->values()->iterator() ;
    var combinedResult : String ; combinedResult := "Fruits: " ;
    while (values.hasNext()) do (     combinedResult := combinedResult+(values.next() + " ") ) ; 
    var additionalText : String ; additionalText := "List end." ;
    return combinedResult + additionalText 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var processor : DictionaryProcessor ; processor := DictionaryProcessor.newDictionaryProcessor() ;
     var output : String ; output := processor.generateResult() ;
     OclFile["System.out"].println(output) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
enum Category { CAT1, CAT2 }
class Member {
    private Category category = Category.CAT2;
    String identifier = "default";
    Member(String id) {
        identifier = id;
    }
    public static void main(String[] args) {
        Member member = new Member("ID123");
        System.out.println("Identifier: " + member.identifier);
    }
}

------------------------------------------------------------
OCL File:
---------
  enumeration Category {  literal CAT1;  literal CAT2 }
 class Member {
   attribute category : Category := Category.CAT2;
   attribute identifier : String := "default";
   static operation newMember( id : String) : Member
  pre: true
  post: true
  activity:
  ( var self : Member ;
    self := createMember();
    self.initialise(id);
    return self );
  operation initialise( id : String) : void
  pre: true  post: true
  activity: (     identifier := id );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var member : Member ; member := Member.newMember("ID123") ;
     OclFile["System.out"].println("Identifier: " + member.identifier) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
interface TimestampGenerator {
    long getTimestamp();
}
abstract class Entity {
    protected String idCode;
}
class SpecificEntity extends Entity implements TimestampGenerator {
    public long getTimestamp() {
        return 987654321L;
    }
    public static void main(String[] args) {
        SpecificEntity entity = new SpecificEntity();
        System.out.println("Timestamp: " + entity.getTimestamp());
    }
}

------------------------------------------------------------
OCL File:
---------
interface TimestampGenerator {
   operation getTimestamp() : long
  pre: true
  post: true;
}
 class Entity {
     attribute idCode : String;
}
class SpecificEntity extends Entity, TimestampGenerator {
   operation getTimestamp() : long
  pre: true
  post: true
  activity: (     return 987654321L );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var entity : SpecificEntity ; entity := SpecificEntity.newSpecificEntity() ;
     OclFile["System.out"].println("Timestamp: " + entity.getTimestamp()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.File;
public class DirectoryInspector {
    public String[] getFiles() {
        File directory = new File("example_dir");
        boolean canAccess = directory.canRead();
        boolean exists = directory.exists();
        String dirName = directory.getName();
        int x=10;
        boolean isFolder = directory.isDirectory();
        boolean isFile = directory.isFile();
        x=x+40;
        long modifiedTime = directory.lastModified();
        long size = directory.length();
        return directory.list();
    }
    public static void main(String[] args) {
        DirectoryInspector inspector = new DirectoryInspector();
        String[] files = inspector.getFiles();
        if (files != null) {
            for (String file : files) {
                System.out.println("File: " + file);
            }
        }
    }
}

------------------------------------------------------------
OCL File:
---------
 class DirectoryInspector {
   operation getFiles() : Sequence(String)
  pre: true
  post: true
  activity: (     var directory : OclFile ; directory := OclFile("example_dir") ;
     var canAccess : boolean ; canAccess := directory.canRead() ;
    var exists : boolean ; exists := directory.exists() ;
    var dirName : String ; dirName := directory.getName() ;
    var x : int ; x := 10 ;
    var isFolder : boolean ; isFolder := directory.isDirectory() ;
    var isFile : boolean ; isFile := directory.isFile() ;
    x := x + 40 ; 
    var modifiedTime : long ; modifiedTime := directory.lastModified() ;
    var size : long ; size := directory.length() ;
    return directory.list() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var inspector : DirectoryInspector ; inspector := DirectoryInspector.newDirectoryInspector() ;
     var files : Sequence(String) ; files := inspector.getFiles() ;
     if (files /= null) then (     for (file : files) do ( (     OclFile["System.out"].println("File: " + file) )  ) ) else skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class DocumentHandler {
    public void readFile() {
        BufferedReader fileReader = null;
        File docFile = new File("info.txt");
        try {
            fileReader = new BufferedReader(new FileReader(docFile));
            char[] dataBuffer = new char[20];
            fileReader.read(dataBuffer, 0, 20);
            System.out.println("File Content: " + new String(dataBuffer).trim());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileReader != null) {
                    fileReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        DocumentHandler handler = new DocumentHandler();
        handler.readFile();
    }
}

------------------------------------------------------------
OCL File:
---------
 class DocumentHandler {
   operation readFile() : void
  pre: true
  post: true
  activity: (     var fileReader : OclFile ; fileReader := null ;
     var docFile : OclFile ; docFile := OclFile("info.txt") ;
     try (     fileReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(docFile)) ; 
     var dataBuffer : Sequence(String) ; dataBuffer := Integer.subrange(1,20)->collect(0) ;
     skip ; 
     OclFile["System.out"].println("File Content: " + StringLib.newString(dataBuffer)->trim()) )   catch (e : IOException) do (     e.printStackTrace() )
   finally (     try (     if (fileReader /= null) then (     skip ) else skip )   catch (e : IOException) do (     e.printStackTrace() )
 )
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var handler : DocumentHandler ; handler := DocumentHandler.newDocumentHandler() ;
     handler.readFile() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class FloatHandler {
    public boolean processFloat() {
        Float decimal = new Float(0.125);
        decimal = new Float("0.125");
        float maxValue = Float.MAX_VALUE;
        maxValue = Float.POSITIVE_INFINITY;
        long roundedValue = (long) maxValue;
        double additionalValue = 9.99;
        return Float.isInfinite(maxValue);
    }
    public static void main(String[] args) {
        FloatHandler handler = new FloatHandler();
        boolean result = handler.processFloat();
        System.out.println("Is the value infinite? " + result);
    }
}

------------------------------------------------------------
OCL File:
---------
class FloatHandler {
   operation processFloat() : boolean
  pre: true
  post: true
  activity: (     var decimal : double ; decimal := ("" + (0.125))->toReal() ;
     decimal := ("" + ("0.125"))->toReal() ; 
    var maxValue : double ; maxValue := 3.4028234663852886*(10->pow(38)) ;
    maxValue := Math_PINFINITY ; 
    var roundedValue : long ; roundedValue := maxValue->oclAsType(long) ;
    var additionalValue : double ; additionalValue := 9.99 ;
    return ((maxValue) = Math_PINFINITY or (maxValue) = Math_NINFINITY) 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var handler : FloatHandler ; handler := FloatHandler.newFloatHandler() ;
     var result : boolean ; result := handler.processFloat() ;
     OclFile["System.out"].println("Is the value infinite? " + result) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Formatter;
import java.io.IOException;
class ReportLogger {
    private Formatter formatter;
    public ReportLogger() {
        try {
            formatter = new Formatter("reportfile.txt");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public void logInformation() {
        formatter.format("%s %d %.3f\n", "DataEntry", 1500, 12.345);
        formatter.close();
    }
    public static void main(String[] args) {
        ReportLogger logger = new ReportLogger();
        logger.logInformation();
    }
}

------------------------------------------------------------
OCL File:
---------
 class ReportLogger {
   attribute formatter : OclFile;
   static operation newReportLogger() : ReportLogger
  pre: true
  post: true
  activity:
  ( var self : ReportLogger ;
    self := createReportLogger();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     formatter := OclFile.newOclFile_Write(OclFile.newOclFile("reportfile.txt")) )   catch (e : IOException) do (     e.printStackTrace() )
 );
   operation logInformation() : void
  pre: true
  post: true
  activity: (     skip ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var logger : ReportLogger ; logger := ReportLogger.newReportLogger() ;
     logger.logInformation() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class TotalSumFinder {
    public int computeTotal() {
        int[] values = {3, 5, 7, 9, 11, 13, 15, 17, 19, 55, 33,22};
        int total = 0;
        for (int index = 0; index < values.length; index++) {
            total += values[index];
        }
        int additional = 25;
        return total + additional;
    }
    public static void main(String[] args) {
        TotalSumFinder finder = new TotalSumFinder();
        int result = finder.computeTotal();
        System.out.println("Total Sum: " + result);
    }
}

------------------------------------------------------------
OCL File:
---------
class TotalSumFinder {
   operation computeTotal() : int
  pre: true
  post: true
  activity: (     var values : Sequence(int) ; values := Sequence{3,5,7,9,11,13,15,17,19,55,33,22} ;
     var total : int ; total := 0 ;
        var index : int ; index := 0 ; while index < values->size() do ( (     total := total+(values[index+1]) )  ;     index := index + 1 ) ; 
    var additional : int ; additional := 25 ;
    return total + additional 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var finder : TotalSumFinder ; finder := TotalSumFinder.newTotalSumFinder() ;
     var result : int ; result := finder.computeTotal() ;
     OclFile["System.out"].println("Total Sum: " + result) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class DataTransformer {
    public int transformData() {
    char[] digits = { '2', '4', '6', '8' };        
    byte[] numbers = { 4, 6, 8, 10,67 };
    String emptyString = new String();
    String numString = new String(numbers, 0, numbers.length);
    byte[] newNumbers = { 2, 4, 6, 8 };
    numString = new String(digits);
    char secondChar = numString.charAt(1);
    return emptyString.compareToIgnoreCase(numString);
    }
}

------------------------------------------------------------
OCL File:
---------
class DataTransformer {
   operation transformData() : int
  pre: true
  post: true
  activity: (     var digits : Sequence(String) ; digits := Sequence{'2','4','6','8'} ;
     var numbers : Sequence(int) ; numbers := Sequence{4,6,8,10,67} ;
    var emptyString : String ; emptyString := StringLib.newString() ;
    var numString : String ; numString := StringLib.newString(numbers, 0, numbers->size()) ;
    var newNumbers : Sequence(int) ; newNumbers := Sequence{2,4,6,8} ;
    numString := StringLib.newString(digits) ; 
    var secondChar : String ; secondChar := numString->at(1+1) ;
    return emptyString->toLowerCase()->compareTo(numString->toLowerCase()) 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
public class GenericStack<E> {
    private ArrayList<E> elements;
    public GenericStack(int size) {
        elements = new ArrayList<E>(size);
    }
    public E topElement() {
        if (elements.size() > 0) {
            return elements.get(elements.size() - 1);
        }
        return null;
    }
    public void push(E item) {
        elements.add(item);
    }
    public E pop() {
        if (elements.size() > 0) {
            return elements.remove(elements.size() - 1);
        }
        return null;
    }
    public static void main(String[] args) {
        GenericStack<String> stack = new GenericStack<>(10);
        stack.push("First");
        stack.push("Second");
        System.out.println("Top Element: " + stack.topElement());
        System.out.println("Popped Element: " + stack.pop());
        System.out.println("New Top Element: " + stack.topElement());
    }
}

------------------------------------------------------------
OCL File:
---------
 class GenericStack<E> {
   attribute elements : Sequence(E);
   static operation newGenericStack( size : int) : GenericStack
  pre: true
  post: true
  activity:
  ( var self : GenericStack ;
    self := createGenericStack();
    self.initialise(size);
    return self );
  operation initialise( size : int) : void
  pre: true  post: true
  activity: (     elements := Sequence{}->union(size) );
   operation topElement() : E
  pre: true
  post: true
  activity: (     if (elements->size() > 0) then (     return elements->at(elements->size() - 1+1) ) else skip ; 
     return null );
   operation push( item : E) : void
  pre: true
  post: true
  activity: (     elements := elements->including(item) );
   operation pop() : E
  pre: true
  post: true
  activity: (     if (elements->size() > 0) then (     return elements->includes(elements->size() - 1) ) else skip ; 
     return null );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var stack : GenericStack<String> ; stack := GenericStack<OclAny>.newGenericStack(10) ;
     stack := stack->append("First") ; 
    stack := stack->append("Second") ; 
    OclFile["System.out"].println("Top Element: " + stack.topElement()) ; 
    OclFile["System.out"].println("Popped Element: " + stack->last()) ; 
    OclFile["System.out"].println("New Top Element: " + stack.topElement()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ListViewer {
    public static void main(String[] args) {
        Integer[] integers = { 7, 14, 21, 28 };
        Double[] floats = { 3.5, 6.5, 9.5 };
        Character[] symbols = { 'A', 'B', 'C' };
        System.out.println(ListViewer.showList(integers));
        System.out.println(ListViewer.showList(floats));
        System.out.println(ListViewer.showList(symbols));
    }
    public static <T> String showList(T[] items) {
        StringBuilder result = new StringBuilder();
        for (T item : items) {
            result.append(item).append(" ");
        }
        return result.toString().trim();
    }
}

------------------------------------------------------------
OCL File:
---------
class ListViewer {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var integers : Sequence(int) ; integers := Sequence{7,14,21,28} ;
     var floats : Sequence(double) ; floats := Sequence{3.5,6.5,9.5} ;
    var symbols : Sequence(String) ; symbols := Sequence{'A','B','C'} ;
    OclFile["System.out"].println(ListViewer.showList(integers)) ; 
    OclFile["System.out"].println(ListViewer.showList(floats)) ; 
    OclFile["System.out"].println(ListViewer.showList(symbols)) ; 
 );
  static   operation showList<T>( items : Sequence(T)) : String
  pre: true
  post: true
  activity: (     var result : String ; result := StringLib.newString() ;
     for (item : items) do ( (     result := result + StringLib.newString(item) + StringLib.newString(" ") )  ) ; 
     return result+""->trim() );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class UniqueCollection {
    public String manageSet() {
        Set<String> fruitSet = new HashSet<>();
        fruitSet.add("mango");
        fruitSet.add("kiwi");
        fruitSet.add("pineapple");
        boolean hasOrange = fruitSet.contains("orange");
        Iterator<String> iter = fruitSet.iterator();
        StringBuilder result = new StringBuilder();
        while (iter.hasNext()) {
            result.append(iter.next()).append(" ");
        }
        Set<String> anotherFruitSet = new HashSet<>();
        anotherFruitSet.add("mango");
        hasOrange = fruitSet.removeAll(anotherFruitSet);
        hasOrange = fruitSet.retainAll(anotherFruitSet);
        return result.toString().trim();
    }
    public static void main(String[] args) {
        UniqueCollection collection = new UniqueCollection();
        String output = collection.manageSet();
        System.out.println("Set contents: " + output);
    }
}

------------------------------------------------------------
OCL File:
---------
 class UniqueCollection {
   operation manageSet() : String
  pre: true
  post: true
  activity: (     var fruitSet : Set(String) ; fruitSet := Set{} ;
     fruitSet := fruitSet->including("mango") ; 
    fruitSet := fruitSet->including("kiwi") ; 
    fruitSet := fruitSet->including("pineapple") ; 
    var hasOrange : boolean ; hasOrange := fruitSet->includes("orange") ;
    var iter : OclIterator ; iter := fruitSet->iterator() ;
    var result : String ; result := StringLib.newString() ;
    while (iter.hasNext()) do (     result := result + StringLib.newString(iter.next()) + StringLib.newString(" ") ) ; 
    var anotherFruitSet : Set(String) ; anotherFruitSet := Set{} ;
    anotherFruitSet := anotherFruitSet->including("mango") ; 
    hasOrange := fruitSet->intersection(anotherFruitSet)->notEmpty() ;     fruitSet := fruitSet - anotherFruitSet ; 
    hasOrange := fruitSet /<: anotherFruitSet ;     fruitSet := fruitSet->intersection(anotherFruitSet) ; 
    return result+""->trim() 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var collection : UniqueCollection ; collection := UniqueCollection.newUniqueCollection() ;
     var output : String ; output := collection.manageSet() ;
     OclFile["System.out"].println("Set contents: " + output) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Set;
import java.util.Enumeration;
public class MapManager {
    public int process() {
        Hashtable<String, String> dataMap = new Hashtable<>();
        dataMap.put("1", "One");
        dataMap.put("2", "Two");
        Enumeration<String> keyEnumeration = dataMap.keys();
        Set<String> keySet = dataMap.keySet();
        HashMap<String, String> additionalMap = new HashMap<>();
        additionalMap.put("3", "Three");
        dataMap.putAll(additionalMap);
        String deletedValue = dataMap.remove("1");
        int mapSize = dataMap.size();
        return mapSize;
    }
    public static void main(String[] args) {
        MapManager manager = new MapManager();
        int size = manager.process();
        System.out.println("Map size: " + size);
    }
}

------------------------------------------------------------
OCL File:
---------
 class MapManager {
   operation process() : int
  pre: true
  post: true
  activity: (     var dataMap : Map(String,String) ; dataMap := Map{} ;
     dataMap := dataMap->union(Map{"1" |-> "One"}) ; 
    dataMap := dataMap->union(Map{"2" |-> "Two"}) ; 
    var keyEnumeration : Enumeration<String> ; keyEnumeration := dataMap->keys()->iterator() ;
    var keySet : Set(String) ; keySet := dataMap->keys() ;
    var additionalMap : Map(String,String) ; additionalMap := Map{} ;
    additionalMap := additionalMap->union(Map{"3" |-> "Three"}) ; 
    dataMap := dataMap->union(additionalMap) ; 
    var deletedValue : String ; deletedValue := dataMap->at("1") ;
    var mapSize : int ; mapSize := dataMap.size() ;
    return mapSize 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var manager : MapManager ; manager := MapManager.newMapManager() ;
     var size : int ; size := manager.process() ;
     OclFile["System.out"].println("Map size: " + size) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ValueAnalyzer {
    public boolean assess() {
        int number = 10;
        if (number < 5) {
            return false;
        } else if (number == 5) {
            return true;
        }
        return number > 5;
    }
    public static void main(String[] args) {
        ValueAnalyzer analyzer = new ValueAnalyzer();
        boolean result = analyzer.assess();
        System.out.println("Assessment Result: " + result);
    }
}

------------------------------------------------------------
OCL File:
---------
class ValueAnalyzer {
   operation assess() : boolean
  pre: true
  post: true
  activity: (     var number : int ; number := 10 ;
     if (number < 5) then (     return false ) else     if (number = 5) then (     return true ) else skip ; ;  
     return number > 5 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var analyzer : ValueAnalyzer ; analyzer := ValueAnalyzer.newValueAnalyzer() ;
     var result : boolean ; result := analyzer.assess() ;
     OclFile["System.out"].println("Assessment Result: " + result) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
import java.util.List;
class FinancialInstrument {
    private String name = "";
    private double term = 0;
    private double annualRate = 0;
    private double initialValue = 0;
    private int numPayments = 0;
    private double earnings = 0;
    private double finalValue = 0;
    public FinancialInstrument() {
        this.name = "";
        this.term = 0.0;
        this.annualRate = 0.0;
        this.initialValue = 0.0;
        this.numPayments = 0;
        this.earnings = 0.0;
        this.finalValue = 0.0;
    }
    public double computePresentValue(double futureValue, double discountRate, double periods) {
        double presentValue = 0;
        if (discountRate <= -1 || periods < 0) { return presentValue; }
        presentValue = futureValue / Math.pow((1 + discountRate), periods);
        return presentValue;
    }
    public static void main(String[] args) {
        FinancialInstrument instrument = new FinancialInstrument();
        double pv = instrument.computePresentValue(10000, 0.05, 10);
        System.out.println("Present Value: " + pv);
    }
}

------------------------------------------------------------
OCL File:
---------
 class FinancialInstrument {
   attribute name : String := "";
   attribute term : double := 0;
   attribute annualRate : double := 0;
   attribute initialValue : double := 0;
   attribute numPayments : int := 0;
   attribute earnings : double := 0;
   attribute finalValue : double := 0;
   static operation newFinancialInstrument() : FinancialInstrument
  pre: true
  post: true
  activity:
  ( var self : FinancialInstrument ;
    self := createFinancialInstrument();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.name := "" ; 
     self.term := 0.0 ; 
    self.annualRate := 0.0 ; 
    self.initialValue := 0.0 ; 
    self.numPayments := 0 ; 
    self.earnings := 0.0 ; 
    self.finalValue := 0.0 ; 
 );
   operation computePresentValue( futureValue : double, discountRate : double, periods : double) : double
  pre: true
  post: true
  activity: (     var presentValue : double ; presentValue := 0 ;
     if (discountRate <= -1 or periods < 0) then (     return presentValue ) else skip ; 
     presentValue := futureValue / (1 + discountRate)->pow(periods) ; 
     return presentValue );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var instrument : FinancialInstrument ; instrument := FinancialInstrument.newFinancialInstrument() ;
     var pv : double ; pv := instrument.computePresentValue(10000, 0.05, 10) ;
     OclFile["System.out"].println("Present Value: " + pv) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
interface OperationA {
    void executeA();
}
interface OperationB {
    void executeB();
}
class TaskOne implements OperationA {
    public void executeA() {
        System.out.println("executeA");
    }
}
class TaskTwo implements OperationB {
    public void executeB() {
        System.out.println("executeB");
    }
}
class TaskHandler {
    public void handle(Object task) {
        if (task instanceof OperationA) {
            ((OperationA) task).executeA();
        } else if (task instanceof OperationB) {
            ((OperationB) task).executeB();
        }
    }
    public static void main(String[] args) {
        TaskHandler handler = new TaskHandler();
        TaskOne taskOne = new TaskOne();
        TaskTwo taskTwo = new TaskTwo();
        handler.handle(taskOne);
        handler.handle(taskTwo);
    }
}

------------------------------------------------------------
OCL File:
---------
interface OperationA {
   operation executeA() : void
  pre: true
  post: true;
}
 interface OperationB {
   operation executeB() : void
  pre: true
  post: true;
}
class TaskOne implements OperationA {
   operation executeA() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("executeA") );
}
class TaskTwo implements OperationB {
   operation executeB() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("executeB") );
}
class TaskHandler {
   operation handle( task : OclAny) : void
  pre: true
  post: true
  activity: (     if (task->oclIsKindOf(OperationA)) then (     (task->oclAsType(OperationA)).executeA() ) else     if (task->oclIsKindOf(OperationB)) then (     (task->oclAsType(OperationB)).executeB() ) else skip ; );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var handler : TaskHandler ; handler := TaskHandler.newTaskHandler() ;
     var taskOne : TaskOne ; taskOne := TaskOne.newTaskOne() ;
    var taskTwo : TaskTwo ; taskTwo := TaskTwo.newTaskTwo() ;
    handler.handle(taskOne) ; 
    handler.handle(taskTwo) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ConversionExample {
    public String convertValue() {
        Integer number = new Integer(5000);
        number = new Integer("0x7F");
        int value = number.intValue();
        value = Integer.MAX_VALUE;
        value = Integer.parseInt("0777");
        return Integer.toBinaryString(128);
    }
    public static void main(String[] args) {
        ConversionExample example = new ConversionExample();
        String result = example.convertValue();
        System.out.println("Binary Representation: " + result);
    }
}

------------------------------------------------------------
OCL File:
---------
class ConversionExample {
   operation convertValue() : String
  pre: true
  post: true
  activity: (     var number : int ; number := ("" + (5000))->toInteger() ;
     number := ("" + ("0x7F"))->toInteger() ; 
    var value : int ; value := number->oclAsType(int) ;
    value := 2147483647 ; 
    value := ("0777")->toInteger() ; 
    return (MathLib.decimal2binary(128) + "") 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var example : ConversionExample ; example := ConversionExample.newConversionExample() ;
     var result : String ; result := example.convertValue() ;
     OclFile["System.out"].println("Binary Representation: " + result) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
interface Displayable {
    String show();
}
class Member implements Displayable {
    String userId = "member456";
    int years = 25;
    public String show() {
        return userId;
    }
    public static void main(String[] args) {
        Member member = new Member();
        System.out.println("User ID: " + member.show());
    }
}

------------------------------------------------------------
OCL File:
---------
interface Displayable {
   operation show() : String
  pre: true
  post: true;
}
 class Member implements Displayable {
   attribute userId : String := "member456";
   attribute years : int := 25;
   operation show() : String
  pre: true
  post: true
  activity: (     return userId );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var member : Member ; member := Member.newMember() ;
     OclFile["System.out"].println("User ID: " + member.show()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Calculations {
    public void perform() {
        char letterA = 'x';
        char letterB = 'y';
        int multiplication = letterA * letterB;
        int y;
        int division = letterB / letterA;
        int subtraction = letterB - letterA;
        int addition = letterA + letterB;
        y=y*100;
        double average = addition / 2.0;
        System.out.println("Multiplication: " + multiplication);
        System.out.println("Division: " + division);
        System.out.println("Subtraction: " + subtraction);
        System.out.println("Addition: " + addition);
        System.out.println("Average: " + average);
    }
    public static void main(String[] args) {
        Calculations calc = new Calculations();
        calc.perform();
    }
}

------------------------------------------------------------
OCL File:
---------
class Calculations {
   operation perform() : void
  pre: true
  post: true
  activity: (     var letterA : String ; letterA := 'x' ;
     var letterB : String ; letterB := 'y' ;
    var multiplication : int ; multiplication := letterA * letterB ;
    var y : int ;
    var division : int ; division := letterB / letterA ;
    var subtraction : int ; subtraction := (letterB)->char2byte() - (letterA)->char2byte() ;
    var addition : int ; addition := letterA + letterB ;
    y := y * 100 ; 
    var average : double ; average := addition / 2.0 ;
    OclFile["System.out"].println("Multiplication: " + multiplication) ; 
    OclFile["System.out"].println("Division: " + division) ; 
    OclFile["System.out"].println("Subtraction: " + subtraction) ; 
    OclFile["System.out"].println("Addition: " + addition) ; 
    OclFile["System.out"].println("Average: " + average) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var calc : Calculations ; calc := Calculations.newCalculations() ;
     calc.perform() );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class TextProcessor {
    public String processText() { 
        String message = new String("Hello World"); 
        byte[] byteArray = message.getBytes(); 
        char[] charArray = new char[4]; 
        message.getChars(2, 6, charArray, 0); 
        int firstSpaceIndex = message.indexOf(" ");
        int messageLength = message.length(); 
        int secondSpaceIndex = message.indexOf(' ', 6); 
        int lastPIndex = message.lastIndexOf('p'); 
        int totalLength = message.length(); 
        String substring = message.substring(6); 
        return message.subSequence(0, 6).toString(); 
    }
}

------------------------------------------------------------
OCL File:
---------
class TextProcessor {
   operation processText() : String
  pre: true
  post: true
  activity: (     var message : String ; message := StringLib.newString("Hello World") ;
     var byteArray : Sequence(int) ; byteArray := message->characters()->collect( _c | _c->char2byte() ) ;
    var charArray : Sequence(String) ; charArray := Integer.subrange(1,4)->collect(0) ;
    message.getChars(2, 6, charArray, 0) ; 
    var firstSpaceIndex : int ; firstSpaceIndex := message->indexOf(" ")-1 ;
    var messageLength : int ; messageLength := message->size() ;
    var secondSpaceIndex : int ; secondSpaceIndex := message.subrange(6+1)->indexOf(' '+"") + 6 - 1  ;
    var lastPIndex : int ; lastPIndex := message->lastIndexOf('p')-1 ;
    var totalLength : int ; totalLength := message->size() ;
    var substring : String ; substring := message.subrange(6+1,6) ;
    return message.subrange(0+1,6)+"" 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Calculator {
    public void calculate() {
        short value1 = 3000;
        short value2 = (short) (value1 * 2);
        int extraAmount = 1000;
        long total = value1 + extraAmount;
        System.out.println("Value2: " + value2);
        System.out.println("Total: " + total);
    }
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        calc.calculate();
    }
}

------------------------------------------------------------
OCL File:
---------
class Calculator {
   operation calculate() : void
  pre: true
  post: true
  activity: (     var value1 : int ; value1 := 3000 ;
     var value2 : int ; value2 := ((value1 * 2) mod 32768) ;
    var extraAmount : int ; extraAmount := 1000 ;
    var total : long ; total := value1 + extraAmount ;
    OclFile["System.out"].println("Value2: " + value2) ; 
    OclFile["System.out"].println("Total: " + total) ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var calc : Calculator ; calc := Calculator.newCalculator() ;
     calc.calculate() );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class DataOrganizer {
  public void execute() {
    Set<Integer> uniqueNumbers = new HashSet<>();
    Iterator<Integer> numbersIterator = uniqueNumbers.iterator();
    Enumeration<String> wordEnumeration = new StringTokenizer("sample text demo");
    Object initialElement = wordEnumeration.nextElement();
    Vector<Integer> numberVector = new Vector<>(uniqueNumbers);
    wordEnumeration = numberVector.elements();
    wordEnumeration = Collections.enumeration(uniqueNumbers);
    List<Integer> numberArrayList = new ArrayList<>(uniqueNumbers);
    ListIterator<Integer> listIndexIterator = numberArrayList.listIterator(5);
    Map<String, Integer> keyValueMap = new HashMap<>();
    keyValueMap.put("two", 2);
    keyValueMap.put("three", 3);
    keyValueMap.put("four", 4);
  }
}

------------------------------------------------------------
OCL File:
---------
class DataOrganizer {
   operation execute() : void
  pre: true
  post: true
  activity: (     var uniqueNumbers : Set(int) ; uniqueNumbers := Set{} ;
     var numbersIterator : OclIterator ; numbersIterator := uniqueNumbers->iterator() ;
    var wordEnumeration : Enumeration<String> ; wordEnumeration := OclIterator.newOclIterator_String("sample text demo") ;
    var initialElement : OclAny ; initialElement := wordEnumeration.next() ;
    var numberVector : Sequence(int) ; numberVector := Sequence{}->union(uniqueNumbers) ;
    wordEnumeration := numberVector->iterator() ; 
    wordEnumeration := OclIterator.newOclIterator_Set(uniqueNumbers) ; 
    var numberArrayList : Sequence(int) ; numberArrayList := Sequence{}->union(uniqueNumbers) ;
    var listIndexIterator : ListIterator<int> ; listIndexIterator := numberArrayList.subrange(5+1)->iterator() ;
    var keyValueMap : Map(String,int) ; keyValueMap := Map{} ;
    keyValueMap := keyValueMap->union(Map{"two" |-> 2}) ; 
    keyValueMap := keyValueMap->union(Map{"three" |-> 3}) ; 
    keyValueMap := keyValueMap->union(Map{"four" |-> 4}) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Holder<T extends Base> {
  int value = 99;
  String text = "Sample";
  double additionalValue = 3.14;
  boolean isActive = true;
}

------------------------------------------------------------
OCL File:
---------
class Holder<T> {
   attribute value : int := 99;
   attribute text : String := "Sample";
   attribute additionalValue : double := 3.14;
   attribute isActive : boolean := true;
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Container<V extends BaseClass & Collection> {
  int count = 150;
  String info = "Description Info";
  double cost = 49.99;
  boolean available = false;
}

------------------------------------------------------------
OCL File:
---------
class Container<V> {
   attribute count : int := 150;
   attribute info : String := "Description Info";
   attribute cost : double := 49.99;
   attribute available : boolean := false;
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.List;
class Product {
    private double amount;
    public Product(double amount) {
        this.amount = amount;
    }
    public double getAmount() {
        return amount;
    }
}
class Buyer {
    private List<Product> productList;
    public Buyer(List<Product> productList) {
        this.productList = productList;
    }
    public List<Product> getProductList() {
        return productList;
    }
}
class TotalCalculator {
    public static void displayTotal(Buyer buyer) {
        double sum = 0.0;
        sum = buyer.getProductList().stream()
                   .mapToDouble(Product::getAmount)
                   .sum();
        System.out.println("Sum of All Product Amounts: " + sum);
    }
    public static void main(String[] args) {
        Product product1 = new Product(50.0);
        Product product2 = new Product(75.0);
        Product product3 = new Product(100.0);
        Buyer buyer = new Buyer(List.of(product1, product2, product3));
        displayTotal(buyer);
    }
}

------------------------------------------------------------
OCL File:
---------
 class Product {
   attribute amount : double;
   static operation newProduct( amount : double) : Product
  pre: true
  post: true
  activity:
  ( var self : Product ;
    self := createProduct();
    self.initialise(amount);
    return self );
  operation initialise( amount : double) : void
  pre: true  post: true
  activity: (     self.amount := amount );
   operation getAmount() : double
  pre: true
  post: true
  activity: (     return amount );
}
class Buyer {
   attribute productList : Sequence(Product);
   static operation newBuyer( productList : Sequence(Product)) : Buyer
  pre: true
  post: true
  activity:
  ( var self : Buyer ;
    self := createBuyer();
    self.initialise(productList);
    return self );
  operation initialise( productList : Sequence(Product)) : void
  pre: true  post: true
  activity: (     self.productList := productList );
   operation getProductList() : Sequence(Product)
  pre: true
  post: true
  activity: (     return productList );
}
class TotalCalculator {
  static   operation displayTotal( buyer : Buyer) : void
  pre: true
  post: true
  activity: (     var sum : double ; sum := 0.0 ;
     sum := buyer.getProductList()->collect( _x1 | (lambda _pars : OclAny in Product.newProduct().getAmount(_pars))->apply(_x1) )->sum() ; 
     OclFile["System.out"].println("Sum of All Product Amounts: " + sum) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var product1 : Product ; product1 := Product.newProduct(50.0) ;
     var product2 : Product ; product2 := Product.newProduct(75.0) ;
    var product3 : Product ; product3 := Product.newProduct(100.0) ;
    var buyer : Buyer ; buyer := Buyer.newBuyer(List.of(product1, product2, product3)) ;
    execute displayTotal(buyer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class StackDemo {
    public void run() {
        Deque<String> stack = new LinkedList<>();
        stack.offerFirst("elementA");
        stack.addLast("elementB");
        stack.addLast("elementC");
        int index = 7;
        double factor = 4.0;
        boolean isActive = true;
        while (!stack.isEmpty()) {
            System.out.println(stack.pollFirst());
        }
    }
}

------------------------------------------------------------
OCL File:
---------
class StackDemo {
   operation run() : void
  pre: true
  post: true
  activity: (     var stack : Sequence(String) ; stack := Sequence{} ;
     stack := stack->prepend("elementA") ; 
    stack := stack->append("elementB") ; 
    stack := stack->append("elementC") ; 
    var index : int ; index := 7 ;
    var factor : double ; factor := 4.0 ;
    var isActive : boolean ; isActive := true ;
    while (not(stack->isEmpty())) do (     OclFile["System.out"].println(stack->first()) ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
enum Tones { maroon, gold, jade, sky, violet }
class PaletteController {
    public EnumSet<Tones> fetchComplement() {
        return EnumSet.complementOf(EnumSet.range(Tones.jade, Tones.violet));
    }
    public EnumSet<Tones> fetchSubset() {
        return EnumSet.of(Tones.maroon, Tones.jade, Tones.sky);
    }
    public EnumSet<Tones> fetchRange() {
        return EnumSet.copyOf(EnumSet.range(Tones.gold, Tones.sky));
    }
    public EnumSet<Tones> fetchAll() {
        return EnumSet.allOf(Tones.class);
    }
}

------------------------------------------------------------
OCL File:
---------
  enumeration Tones {  literal maroon;  literal gold;  literal jade;  literal sky;  literal violet }
 class PaletteController {
   operation fetchComplement() : Set(Tones)
  pre: true
  post: true
  activity: (     return (((Tones.jade->oclType()).allInstances()->select(_x | _x >= Tones.jade & _x <= Tones.violet)->any()->oclType()).allInstances() - (Tones.jade->oclType()).allInstances()->select(_x | _x >= Tones.jade & _x <= Tones.violet)) );
   operation fetchSubset() : Set(Tones)
  pre: true
  post: true
  activity: (     return Set{Tones.maroon, Tones.jade, Tones.sky} );
   operation fetchRange() : Set(Tones)
  pre: true
  post: true
  activity: (     return ((Tones.gold->oclType()).allInstances()->select(_x | _x >= Tones.gold & _x <= Tones.sky))->copy() );
   operation fetchAll() : Set(Tones)
  pre: true
  post: true
  activity: (     return OclType["Tones"].allInstances() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
enum Colors { scarlet, teal, lime, charcoal, ivory }
class PaletteUtils {
    public int fetchSize() {
        return Colors.values().length;
    }
    public EnumSet<Colors> fetchAllColors() {
        return EnumSet.allOf(Colors.class);
    }
    public EnumSet<Colors> fetchColorRange() {
        return EnumSet.range(Colors.teal, Colors.charcoal);
    }
    public Colors getFirstColor() {
        return Colors.scarlet;
    }
}

------------------------------------------------------------
OCL File:
---------
  enumeration Colors {  literal scarlet;  literal teal;  literal lime;  literal charcoal;  literal ivory }
 class PaletteUtils {
   operation fetchSize() : int
  pre: true
  post: true
  activity: (     return Colors.allInstances()->size() );
   operation fetchAllColors() : Set(Colors)
  pre: true
  post: true
  activity: (     return OclType["Colors"].allInstances() );
   operation fetchColorRange() : Set(Colors)
  pre: true
  post: true
  activity: (     return (Colors.teal->oclType()).allInstances()->select(_x | _x >= Colors.teal & _x <= Colors.charcoal) );
   operation getFirstColor() : Colors
  pre: true
  post: true
  activity: (     return Colors.scarlet );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.FileReader;
import java.text.SimpleDateFormat;
import java.util.*;
import java.sql.*;
class RecordProcessor {
    public void execute() throws Exception {
        CSVReader reader = new CSVReader(new FileReader("sales_data.csv"));
        List<String[]> dataRecords = reader.readAll();
        SimpleDateFormat dateFormatter = new SimpleDateFormat("dd-MM-yyyy");
        List<Transaction> transactions = new ArrayList<>();
        String sourceFile = "sales_data.csv";
        int entryCount = 0;
        double aggregateAmount = 0.0;
        String currency = "USD";
        for (String[] data : dataRecords) {
            Date transactionDate = dateFormatter.parse(data[0]);
            Transaction transaction = new Transaction(transactionDate, data[1], Double.parseDouble(data[2]));
            transactions.add(transaction);
            entryCount++;
            aggregateAmount += transaction.getAmount();
        }
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/financialdb", "root", "password");
        String sqlQuery = "INSERT INTO transactions (date, detail, value) VALUES (?, ?, ?)";
        PreparedStatement preparedStatement = connection.prepareStatement(sqlQuery);
        for (Transaction transaction : transactions) {
            preparedStatement.setDate(1, new java.sql.Date(transaction.getDate().getTime()));
            preparedStatement.setString(2, transaction.getDetail());
            preparedStatement.setDouble(3, transaction.getValue());
            preparedStatement.executeUpdate();
        }
        preparedStatement.close();
        connection.close();
        System.out.println("Handled " + entryCount + " entries with an aggregate amount of $" + aggregateAmount + " " + currency);
    }
}

------------------------------------------------------------
OCL File:
---------
 class RecordProcessor {
   operation execute() : void
  pre: true
  post: true
  activity: (     var reader : CSVReader ; reader := CSVReader.newCSVReader(OclFile.newOclFile_Read(OclFile.newOclFile("sales_data.csv"))) ;
     var dataRecords : Sequence(Sequence(String)) ; dataRecords := reader.readAll() ;
    var dateFormatter : SimpleDateFormat ; dateFormatter := SimpleDateFormat.newSimpleDateFormat("dd-MM-yyyy") ;
    var transactions : Sequence(Transaction) ; transactions := Sequence{} ;
    var sourceFile : String ; sourceFile := "sales_data.csv" ;
    var entryCount : int ; entryCount := 0 ;
    var aggregateAmount : double ; aggregateAmount := 0.0 ;
    var currency : String ; currency := "USD" ;
    for (data : dataRecords) do ( (     var transactionDate : OclDate ; transactionDate := dateFormatter.parse(data[0+1]) ;
     var transaction : Transaction ; transaction := Transaction.newTransaction(transactionDate, data[1+1], (data[2+1])->toReal()) ;
    transactions := transactions->including(transaction) ; 
    entryCount := entryCount + 1 ; 
    aggregateAmount := aggregateAmount+(transaction.getAmount()) ; 
 )  ) ; 
    var connection : OclDatasource ; connection := DriverManager.getConnection("jdbc:mysql://localhost:3306/financialdb", "root", "password") ;
    var sqlQuery : String ; sqlQuery := "INSERT INTO transactions (date, detail, value) VALUES (?, ?, ?)" ;
    var preparedStatement : SQLStatement ; preparedStatement := connection.prepareStatement(sqlQuery) ;
    for (transaction : transactions) do ( (     preparedStatement.setDate(1, Date.newDate(transaction.getDate().getTime())) ; 
     preparedStatement.setString(2, transaction.getDetail()) ; 
     preparedStatement.setDouble(3, transaction.getValue()) ; 
     preparedStatement.executeUpdate() )  ) ; 
    preparedStatement.close() ; 
    connection.close() ; 
    OclFile["System.out"].println("Handled " + entryCount + " entries with an aggregate amount of $" + aggregateAmount + " " + currency) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class TaskRunner {
    void perform() {
        int initial = 20;
        int step = 3;
        int factor = 4;
        int threshold = 50;
        int cumulativeSum = 0;
        boolean finished = false;
        calculationLoop: {
            initial += step;
            cumulativeSum += initial;
            initial *= factor;
            if (initial > threshold) {
                break calculationLoop;
            }
            continue calculationLoop;
        }
        double mean = (double) cumulativeSum / 3;
        String outcome = "Done";
        boolean isSuccessful = true;
        System.out.println("Final Value: " + initial);
        System.out.println("Cumulative Sum: " + cumulativeSum);
        System.out.println("Mean: " + mean);
        System.out.println("Outcome: " + outcome);
    }
}

------------------------------------------------------------
OCL File:
---------
class TaskRunner {
   operation perform() : void
  pre: true
  post: true
  activity: (     var initial : int ; initial := 20 ;
     var step : int ; step := 3 ;
    var factor : int ; factor := 4 ;
    var threshold : int ; threshold := 50 ;
    var cumulativeSum : int ; cumulativeSum := 0 ;
    var finished : boolean ; finished := false ;
(     initial := initial+(step) ; 
     cumulativeSum := cumulativeSum+(initial) ; 
    initial := initial*(factor) ; 
    if (initial > threshold) then (     break ) else skip ; 
    continue 
 ) 
    var mean : double ; mean := cumulativeSum->oclAsType(double) / 3 ;
    var outcome : String ; outcome := "Done" ;
    var isSuccessful : boolean ; isSuccessful := true ;
    OclFile["System.out"].println("Final Value: " + initial) ; 
    OclFile["System.out"].println("Cumulative Sum: " + cumulativeSum) ; 
    OclFile["System.out"].println("Mean: " + mean) ; 
    OclFile["System.out"].println("Outcome: " + outcome) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class StringManipulator {
    public boolean checkPatterns() {
        String text = "hello world example";
        String keyword = "test";
        String sampleText = "foo bar baz";
        boolean isMatch = text.matches("[a-z\\s]+");
        boolean regionMatch = text.regionMatches(6, keyword, 0, 4);
        String replacedChar = keyword.replace('e', '#');
        String replacedAll = text.replaceAll("[a-z]+", "*");
        String[] words = text.split(" ");
        return text.startsWith("hello");
    }
}

------------------------------------------------------------
OCL File:
---------
class StringManipulator {
   operation checkPatterns() : boolean
  pre: true
  post: true
  activity: (     var text : String ; text := "hello world example" ;
     var keyword : String ; keyword := "test" ;
    var sampleText : String ; sampleText := "foo bar baz" ;
    var isMatch : boolean ; isMatch := text->isMatch("[a-z\\s]+") ;
    var regionMatch : boolean ; regionMatch := text.subrange(6+1,6+4) = keyword.subrange(0+1,0+4) ;
    var replacedChar : String ; replacedChar := keyword.replace('e', '#') ;
    var replacedAll : String ; replacedAll := text.replaceAllMatches("[a-z]+", "*" ) ;
    var words : Sequence(String) ; words := text->split(" ") ;
    return text->hasPrefix("hello") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Processor {
    public void process() {
        outer:
        for (String element : elementsList) {
            char[] chars = element.toCharArray();
            for (char ch : chars) {
                if (ch == '*') {
                    continue outer;
                }
                processCharacter(ch);
            }
        }
        int elementCount = 10;
        double avgLength = 5.5;
        String result = "Task finished";
        boolean success = true;
    }
    private void processCharacter(char ch) {
        int i;
        i=i+1;
        // Placeholder for character handling logic
    }
}

------------------------------------------------------------
OCL File:
---------
class Processor {
   operation process() : void
  pre: true
  post: true
  activity: (     for (element : elementsList) do ( (     var chars : Sequence(String) ; chars := element->characters() ;
     for (ch : chars) do ( (     if (ch = '*') then (     continue ) else skip ; 
     execute processCharacter(ch) )  ) )  ) ; 
     var elementCount : int ; elementCount := 10 ;
    var avgLength : double ; avgLength := 5.5 ;
    var result : String ; result := "Task finished" ;
    var success : boolean ; success := true ;
 );
   operation processCharacter( ch : String) : void
  pre: true
  post: true
  activity: (     var i : int ;
     i := i + 1 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Container {
    int value = 12;
    double rate = 3.7;
    String title = "sample";
    class Nested {
        int compute() {
            int i=10;
            i=i*9;
            return value * 20;
        }
    }
}

------------------------------------------------------------
OCL File:
---------
class Container {
   attribute value : int := 12;
   attribute rate : double := 3.7;
   attribute title : String := "sample";
 class Nested {
   operation compute() : int
  pre: true
  post: true
  activity: (     var i : int ; i := 10 ;
     i := i * 9 ; 
     return value * 20 );
}
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
class WebFetcher {
    public String fetchContent(String link) {
        String content = "";
        String extraContent = "Supplementary information";
        URL website = new URL(link);
        HttpURLConnection httpConnection = (HttpURLConnection) website.openConnection();
        httpConnection.setRequestMethod("GET");
        httpConnection.connect();
        int y=10;
        InputStream stream = httpConnection.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(stream));
        String line = bufferedReader.readLine();
        y=y*8;
        while (line != null) {
            content += line;
            line = bufferedReader.readLine();
        }
        String finalContent = content + extraContent;
        return finalContent;
    }
}

------------------------------------------------------------
OCL File:
---------
 class WebFetcher {
   operation fetchContent( link : String) : String
  pre: true
  post: true
  activity: (     var content : String ; content := "" ;
     var extraContent : String ; extraContent := "Supplementary information" ;
    var website : OclDatasource ; website := OclDatasource.newURL(link) ;
    var httpConnection : OclDatasource ; httpConnection := website.openConnection()->oclAsType(OclDatasource) ;
    httpConnection.setRequestMethod("GET") ; 
    httpConnection.connect() ; 
    var y : int ; y := 10 ;
    var stream : OclFile ; stream := httpConnection.getInputStream() ;
    var bufferedReader : OclFile ; bufferedReader := OclFile.newOclFile_Read(OclFile.newOclFile_Read(stream)) ;
    var line : String ; line := bufferedReader.readLine() ;
    y := y * 8 ; 
    while (line /= null) do (     content := content+(line) ; 
     line := bufferedReader.readLine() ) ; 
    var finalContent : String ; finalContent := content + extraContent ;
    return finalContent 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class BookDatabase {
    static final String DB_URL = "jdbc:mysql://localhost/bookstore";
    public static void fetchAuthors() {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        String note = "Accessing authors' information";
        try {
            conn = DriverManager.getConnection(DB_URL, "root", "password");
            stmt = conn.createStatement();
            rs = stmt.executeQuery("SELECT AuthorID, FirstName, LastName FROM Authors");
            while (rs.next()) {
                System.out.println(rs.getString("FirstName") + " " + rs.getString("LastName"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (rs != null) rs.close();
                if (stmt != null) stmt.close();
                if (conn != null) conn.close();
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        }
    }
}

------------------------------------------------------------
OCL File:
---------
 class BookDatabase {
  static    attribute DB_URL : String := "jdbc:mysql://localhost/bookstore";
  static   operation fetchAuthors() : void
  pre: true
  post: true
  activity: (     var conn : OclDatasource ; conn := null ;
     var stmt : SQLStatement ; stmt := null ;
    var rs : OclIterator ; rs := null ;
    var note : String ; note := "Accessing authors' information" ;
    try (     conn := DriverManager.getConnection(DB_URL, "root", "password") ; 
     stmt := conn.createStatement() ; 
     rs := stmt.executeQuery("SELECT AuthorID, FirstName, LastName FROM Authors") ; 
     while (rs.next()) do (     OclFile["System.out"].println(rs.getCurrent()["FirstName"]->oclAsType(String) + " " + rs.getCurrent()["LastName"]->oclAsType(String)) ) )   catch (e : IOException) do (     e.printStackTrace() )
   finally (     try (     if (rs /= null) then     rs.close() ; else skip ; 
     if (stmt /= null) then     stmt.close() ; else skip ; 
     if (conn /= null) then     conn.close() ; else skip )   catch (ex : IOException) do (     ex.printStackTrace() )
 )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class SimpleApp {
  public static void main(String[] args) throws Exception {
    Gson gson = new Gson();
    String data = Files.readString(Paths.get("data.json"));
    Type type = new TypeToken<List<User>>() {}.getType();
    List<User> users = gson.fromJson(data, type);
    try (Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/testdb", "admin", "admin123");
         PreparedStatement stmt = conn.prepareStatement("INSERT INTO user_summaries (name, total) VALUES (?, ?)")) {
      for (User user : users) {
        double total = user.getItems().stream().mapToDouble(Item::getPrice).sum();
        stmt.setString(1, user.getName());
        stmt.setDouble(2, total);
        stmt.executeUpdate();
      }
    }
  }
}
class User {
  private String name;
  private List<Item> items;
  public String getName() {
    return name;
  }
  public List<Item> getItems() {
    return items;
  }
}
class Item {
  private double price;
  public double getPrice() {
    return price;
  }
}

------------------------------------------------------------
OCL File:
---------
class SimpleApp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var gson : Gson ; gson := Gson.newGson() ;
     var data : String ; data := OclFile.newOclFile("data.json").readLine() ;
    var type : Type ; type := TypeToken<Sequence(User)>.newTypeToken().getType() ;
    var users : Sequence(User) ; users := gson.fromJson(data, type) ;
    try (    var conn : OclDatasource := OclDatasource.getConnection("jdbc:mysql://localhost:3306/testdb", "admin", "admin123") ;
     var stmt : SQLStatement := conn.prepareStatement("INSERT INTO user_summaries (name, total) VALUES (?, ?)") ;
 (     for (user : users) do ( (     var total : double ; total := user.getItems()->collect( _x1 | ((lambda _pars : OclAny in (Item.newItem().getPrice(_pars))))->apply(_x1) )->sum() ;
     stmt.setString(1, user.getName()) ; 
     stmt.setDouble(2, total) ; 
     stmt.executeUpdate() )  ) ))  
 );
}
 class User {
   attribute name : String;
   attribute items : Sequence(Item);
   operation getName() : String
  pre: true
  post: true
  activity: (     return name );
   operation getItems() : Sequence(Item)
  pre: true
  post: true
  activity: (     return items );
}
class Item {
   attribute price : double;
   operation getPrice() : double
  pre: true
  post: true
  activity: (     return price );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class MatcherTest
{ 
  private int tyuk; 
  private String kkk; 
  public static void jjjj(String gg)
  { 
    int gy=80;
    Pattern ee = Pattern.compile("[0-9]{4}.[0-9]{4}.[0-9]{4}.[0-9]{4}");  
    gy=gy+5;
    Matcher uu = ee.matcher(gg); 
    boolean fe = uu.find(); 
    gy++;
    if (fe)
    { 
      int qq = uu.start();
      int pp = uu.end(); 
      float ghj=9.9; 
      kkk = gg.substring(qq,pp); 
      ghj+=9.8;
    } 
  }   
}

------------------------------------------------------------
OCL File:
---------
class MatcherTest {
   attribute tyuk : int;
   attribute kkk : String;
  static   operation jjjj( gg : String) : void
  pre: true
  post: true
  activity: (     var gy : int ; gy := 80 ;
     var ee : OclRegex ; ee := OclRegex.compile("[0-9]{4}.[0-9]{4}.[0-9]{4}.[0-9]{4}") ;
    gy := gy + 5 ; 
    var uu : OclRegex ; uu := ee.matcher(gg) ;
    var fe : boolean ; fe := uu.nextMatch() ;
    gy := gy + 1 ; 
    if (fe) then (     var qq : int ; qq := uu.start() ;
     var pp : int ; pp := uu.end() ;
    var ghj : double ; ghj := 9.9 ;
    kkk := gg.subrange(qq+1,pp) ; 
    ghj := ghj+(9.8) ; 
 ) else skip ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
import java.util.List;
class CollectionManager {
    public List modifyCollection() {
        double xx=9.999;
        List primaryList = new ArrayList();
        List secondaryList = primaryList;
        secondaryList.add("A");
        secondaryList.add("B");
        xx=xx*8;
        String extraItem = "C";
        secondaryList.add(extraItem);
        return primaryList;
    }
}

------------------------------------------------------------
OCL File:
---------
 class CollectionManager {
   operation modifyCollection() : Sequence
  pre: true
  post: true
  activity: (     var xx : double ; xx := 9.999 ;
     var primaryList : Sequence ; primaryList := Sequence{} ;
    var secondaryList : Sequence ; secondaryList := primaryList ;
    secondaryList := secondaryList->including("A") ; 
    secondaryList := secondaryList->including("B") ; 
    xx := xx * 8 ; 
    var extraItem : String ; extraItem := "C" ;
    secondaryList := secondaryList->including(extraItem) ; 
    return primaryList 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
enum PrimaryColors { blue, green, red, yellow, black }
enum ExpandedColors implements PrimaryColors { blue, green, red, purple, teal, yellow, grey }

------------------------------------------------------------
OCL File:
---------
  enumeration PrimaryColors {  literal blue;  literal green;  literal red;  literal yellow;  literal black }
   enumeration ExpandedColors {  literal blue;  literal green;  literal red;  literal purple;  literal teal;  literal yellow;  literal grey }

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.function.Function;
class Converter {
    public String executeConversion() {
        Function<String, String> converter =
            (text) -> { String output = text + "456"; return output; };
        int u=99;
        String additionalValue = "ABC";
        return converter.apply("sample") + additionalValue;
    }
}

------------------------------------------------------------
OCL File:
---------
 class Converter {
   operation executeConversion() : String
  pre: true
  post: true
  activity: (     var converter : Function<String,String> ; converter := lambda text : OclAny in (     var output : String ; output := text + "456" ;
     return output ) ;
     var u : int ; u := 99 ;
     var additionalValue : String ; additionalValue := "ABC" ;
     return converter->apply("sample") + additionalValue );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
public class DataHandler {
    String processItems() {
        ArrayList<String> items = new ArrayList<>();
        items.add("aaaa");
        items.add("bbbb");
        items.add("cccc");
        items.add("dddd");
        items.add("yyyyy");
        double t=987.567;
        String additionalItem = "bbbb";
        items.add(additionalItem);
        items.removeIf((item) -> (item.length() < 5));
        return items.toString();
    }
}

------------------------------------------------------------
OCL File:
---------
 class DataHandler {
   operation processItems() : String
  pre: true
  post: true
  activity: (     var items : Sequence(String) ; items := Sequence{} ;
     items := items->including("aaaa") ; 
    items := items->including("bbbb") ; 
    items := items->including("cccc") ; 
    items := items->including("dddd") ; 
    items := items->including("yyyyy") ; 
    var t : double ; t := 987.567 ;
    var additionalItem : String ; additionalItem := "bbbb" ;
    items := items->including(additionalItem) ; 
    items := items->reject( _var | (lambda item : OclAny in (item->size() < 5))->apply(_var) ) ; 
    return items+"" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class TextUtility {
    public String processText() {
        String text = "example text";
        char[] charArray = text.toCharArray();
        String upperText1 = text.toUpperCase();
        String upperText2 = text.toUpperCase();
        String upperText3 = text.toUpperCase();
        CharSequence subText = text.subSequence(3, 7);
        upperText1 = upperText1.toLowerCase();
        upperText2 = upperText2.toLowerCase();
        upperText3 = upperText3.toLowerCase();
        return text.trim();
    }
}

------------------------------------------------------------
OCL File:
---------
class TextUtility {
   operation processText() : String
  pre: true
  post: true
  activity: (     var text : String ; text := "example text" ;
     var charArray : Sequence(String) ; charArray := text->characters() ;
    var upperText1 : String ; upperText1 := text->toUpperCase() ;
    var upperText2 : String ; upperText2 := text->toUpperCase() ;
    var upperText3 : String ; upperText3 := text->toUpperCase() ;
    var subText : String ; subText := text.subrange(3+1,7) ;
    upperText1 := upperText1->toLowerCase() ; 
    upperText2 := upperText2->toLowerCase() ; 
    upperText3 := upperText3->toLowerCase() ; 
    return text->trim() 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.LinkedList;
public class CollectionManager {
    int processQueue() {
        LinkedList<String> elements = new LinkedList<>();
        boolean wasAdded = elements.add("orange");
        elements.add("grape");
        elements.add("melon");
        elements.add("berry");
        elements.add("ggggg");
        elements.addFirst("pineapple");
        elements.addLast("peach");
        int f=10;
        String topElement = elements.getFirst();
        String endElement = elements.getLast();
        String removedStart = (String) elements.removeFirst();
        f=f+8;
        String removedEnd = (String) elements.removeLast();
        String extraElement = "bonus";
        elements.add(extraElement);
        return elements.size();
    }
}

------------------------------------------------------------
OCL File:
---------
 class CollectionManager {
   operation processQueue() : int
  pre: true
  post: true
  activity: (     var elements : Sequence(String) ; elements := Sequence{} ;
     var wasAdded : boolean ; wasAdded := elements->excludes("orange") ;
    elements := elements->including("grape") ; 
    elements := elements->including("melon") ; 
    elements := elements->including("berry") ; 
    elements := elements->including("ggggg") ; 
    elements := elements->prepend("pineapple") ; 
    elements := elements->append("peach") ; 
    var f : int ; f := 10 ;
    var topElement : String ; topElement := elements->first() ;
    var endElement : String ; endElement := elements->last() ;
    var removedStart : String ; removedStart := elements->first()->oclAsType(String) ;
    f := f + 8 ; 
    var removedEnd : String ; removedEnd := elements->last()->oclAsType(String) ;
    var extraElement : String ; extraElement := "bonus" ;
    elements := elements->including(extraElement) ; 
    return elements->size() 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
import java.util.ListIterator;
public class DataProcessor {
    public String manipulateList() { 
        ArrayList<String> data = new ArrayList<>();
        data.add("delta");
        data.add("epsilon");
        data.add("epsilon7");
        data.add("aaaaaaa");
        data.add("fffffff");
        data.add(0, "zeta");
        ListIterator<String> listIterator = data.listIterator();
        int x=10;
        StringBuilder output = new StringBuilder();
        while (listIterator.hasNext()) {
            output.append(listIterator.next());
        }
        String additionalText = " completed";
        output.append(additionalText);
        return output.toString();
    }
}

------------------------------------------------------------
OCL File:
---------
 class DataProcessor {
   operation manipulateList() : String
  pre: true
  post: true
  activity: (     var data : Sequence(String) ; data := Sequence{} ;
     data := data->including("delta") ; 
    data := data->including("epsilon") ; 
    data := data->including("epsilon7") ; 
    data := data->including("aaaaaaa") ; 
    data := data->including("fffffff") ; 
    data := data.insertAt(0+1,"zeta") ; 
    var listIterator : ListIterator<String> ; listIterator := data->iterator() ;
    var x : int ; x := 10 ;
    var output : String ; output := StringLib.newString() ;
    while (listIterator.hasNext()) do (     output := output + StringLib.newString(listIterator.next()) ) ; 
    var additionalText : String ; additionalText := " completed" ;
    output := output + StringLib.newString(additionalText) ; 
    return output+"" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
public class ItemHandler {
    public String runOperations() { 
        ArrayList<String> elements = new ArrayList<>();
        elements.add("apple");
        elements.add("orange");
        elements.add("banana");
        elements.add("dddddd");
        elements.add("iiiiiii");
        elements.add("aaaaaaa");
        elements.add(0, "grape");
        String firstElement = elements.get(0);
        int position = elements.indexOf("orange");
        elements.remove(0);
        elements.set(1, "kiwi");
        double ii=9876.77;
        String appendedText = " finished";
        elements.add(appendedText);
        return elements.toString(); 
    }
}

------------------------------------------------------------
OCL File:
---------
 class ItemHandler {
   operation runOperations() : String
  pre: true
  post: true
  activity: (     var elements : Sequence(String) ; elements := Sequence{} ;
     elements := elements->including("apple") ; 
    elements := elements->including("orange") ; 
    elements := elements->including("banana") ; 
    elements := elements->including("dddddd") ; 
    elements := elements->including("iiiiiii") ; 
    elements := elements->including("aaaaaaa") ; 
    elements := elements.insertAt(0+1,"grape") ; 
    var firstElement : String ; firstElement := elements->at(0+1) ;
    var position : int ; position := elements->indexOf("orange")-1 ;
    elements := elements->excludingAt(0+1) ; 
    elements := elements.setAt(1+1,"kiwi") ; 
    var ii : double ; ii := 9876.77 ;
    var appendedText : String ; appendedText := " finished" ;
    elements := elements->including(appendedText) ; 
    return elements+"" 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ValueTransformer {
    public String performConversions() { 
        Long integerValue = new Long("0x123456"); 
        double tt=999.67; 
        integerValue = new Long(98765432); 
        integerValue = Long.decode("54321"); 
        int x=5;
        byte smallValue = integerValue.byteValue(); 
        double largeValue = integerValue.doubleValue(); 
        long minimumValue = Long.MIN_VALUE; 
        long maximumValue = Long.MAX_VALUE;
        x++;
        String binaryRepresentation = Long.toBinaryString(maximumValue); 
        int y=10;
        return binaryRepresentation; 
    }
}

------------------------------------------------------------
OCL File:
---------
class ValueTransformer {
   operation performConversions() : String
  pre: true
  post: true
  activity: (     var integerValue : long ; integerValue := ("" + ("0x123456"))->toLong() ;
     var tt : double ; tt := 999.67 ;
    integerValue := ("" + (98765432))->toLong() ; 
    integerValue := ("54321")->toLong() ; 
    var x : int ; x := 5 ;
    var smallValue : int ; smallValue := integerValue->oclAsType(int) ;
    var largeValue : double ; largeValue := integerValue->oclAsType(double) ;
    var minimumValue : long ; minimumValue := "-9223372036854775808"->toLong() ;
    var maximumValue : long ; maximumValue := "9223372036854775807"->toLong() ;
    x := x + 1 ; 
    var binaryRepresentation : String ; binaryRepresentation := (MathLib.decimal2binary(maximumValue) + "") ;
    var y : int ; y := 10 ;
    return binaryRepresentation 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class MathOperations {
    public void performCalculations() {
        int d=10;
        double naturalLogBase = Math.E; 
        d++;
        double circleConstant = Math.PI; 
        naturalLogBase = Math.abs(-600.0); 
        naturalLogBase = Math.cos(circleConstant);  
        double yy=4567.7;
        double angleInRadians = Math.atan(0.5); 
        naturalLogBase = Math.exp(30); 
        angleInRadians = Math.min(0.4, 0.6); 
        yy=yy+8.6;
        naturalLogBase = Math.rint(15.7); 
        naturalLogBase = Math.toDegrees(Math.PI / 2); 
        String status = "Operations complete";
    }
}

------------------------------------------------------------
OCL File:
---------
class MathOperations {
   operation performCalculations() : void
  pre: true
  post: true
  activity: (     var d : int ; d := 10 ;
     var naturalLogBase : double ; naturalLogBase := 2.718281828459045 ;
    d := d + 1 ; 
    var circleConstant : double ; circleConstant := 3.141592653589793 ;
    naturalLogBase := if -600.0 < 0 then -(-600.0) else -600.0 endif ; 
    naturalLogBase := (circleConstant)->cos() ; 
    var yy : double ; yy := 4567.7 ;
    var angleInRadians : double ; angleInRadians := (0.5)->atan() ;
    naturalLogBase := (30)->exp() ; 
    angleInRadians := Set{0.4, 0.6}->min() ; 
    yy := yy + 8.6 ; 
    naturalLogBase := (1.0*((15.7)->round())) ; 
    naturalLogBase := (57.29577951308232*(3.141592653589793 / 2)) ; 
    var status : String ; status := "Operations complete" ;
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap;
import java.util.Map;
public class InventoryManager {
    public void handleInventory() {
        Map<String, Map<String, String>> itemCollections = new HashMap<>();
        int x;
        x=60;
        Map<String, String> collectionA = new HashMap<>();
        collectionA.put("first", "grape");
        collectionA.put("second", "kiwi");
        collectionA.put("third", "lemon");
        Map<String, String> collectionB = new HashMap<>();
        collectionB.put("first", "mango");
        collectionB.put("second", "nectarine");
        x=x+5;
        collectionB.put("third", "orange");
        double z; 
        itemCollections.put("citrus", collectionA);
        z=20;
        z++;  
        itemCollections.put("tropical", collectionB);
        itemCollections.put("exotic", collectionB);
        String statusMessage = "Collections updated";
    }
}

------------------------------------------------------------
OCL File:
---------
 class InventoryManager {
   operation handleInventory() : void
  pre: true
  post: true
  activity: (     var itemCollections : Map(String,Map(String,String)) ; itemCollections := Map{} ;
     var x : int ;
    x := 60 ; 
    var collectionA : Map(String,String) ; collectionA := Map{} ;
    collectionA := collectionA->union(Map{"first" |-> "grape"}) ; 
    collectionA := collectionA->union(Map{"second" |-> "kiwi"}) ; 
    collectionA := collectionA->union(Map{"third" |-> "lemon"}) ; 
    var collectionB : Map(String,String) ; collectionB := Map{} ;
    collectionB := collectionB->union(Map{"first" |-> "mango"}) ; 
    collectionB := collectionB->union(Map{"second" |-> "nectarine"}) ; 
    x := x + 5 ; 
    collectionB := collectionB->union(Map{"third" |-> "orange"}) ; 
    var z : double ;
    itemCollections := itemCollections->union(Map{"citrus" |-> collectionA}) ; 
    z := 20 ; 
    z := z + 1 ; 
    itemCollections := itemCollections->union(Map{"tropical" |-> collectionB}) ; 
    itemCollections := itemCollections->union(Map{"exotic" |-> collectionB}) ; 
    var statusMessage : String ; statusMessage := "Collections updated" ;
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashMap;
import java.util.Map;
interface TaskX {
    void executeTaskX();
}
interface TaskY {
    void executeTaskY();
}
class Executor implements TaskX, TaskY {
    public void executeTaskX() {
        System.out.println("Executing Task X");
    }
    public void executeTaskY() {
        System.out.println("Executing Task Y");
    }
}
class Processor {
    public void performTasks() {
        TaskX taskX = new Executor();
        TaskY taskY = taskX;
        taskX.executeTaskX();
        taskY.executeTaskY();
    }
}
class Operations {
    public void showAction() {
        System.out.println("Operations class in action.");
    }
}
class Controller {
    public void handleOperations() {
        Operations ops = new Operations();
        ops.showAction();
    }
}
class Organizer {
    public void arrange() {
        Controller ctrl = new Controller();
        ctrl.handleOperations();
    }
}

------------------------------------------------------------
OCL File:
---------
 interface TaskX {
   operation executeTaskX() : void
  pre: true
  post: true;
}
interface TaskY {
   operation executeTaskY() : void
  pre: true
  post: true;
}
class Executor implements TaskX, TaskY {
   operation executeTaskX() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Executing Task X") );
   operation executeTaskY() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Executing Task Y") );
}
class Processor {
   operation performTasks() : void
  pre: true
  post: true
  activity: (     var taskX : TaskX ; taskX := Executor.newExecutor() ;
     var taskY : TaskY ; taskY := taskX ;
     taskX.executeTaskX() ; 
     taskY.executeTaskY() );
}
class Operations {
   operation showAction() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Operations class in action.") );
}
class Controller {
   operation handleOperations() : void
  pre: true
  post: true
  activity: (     var ops : Operations ; ops := Operations.newOperations() ;
     ops.showAction() );
}
class Organizer {
   operation arrange() : void
  pre: true
  post: true
  activity: (     var ctrl : Controller ; ctrl := Controller.newController() ;
     ctrl.handleOperations() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.function.Function;
class TaskExecutor {
    public void runTasks() {
        Function<String, String> repeatFunction = (text) -> { return text + text; };
        Function<Double, Double> squareFunction = (value) -> { return value * value; };
        double dd=43545.6565;
        String processedText = repeatFunction.apply("world");
        Double processedNumber = squareFunction.apply(4.5);
        String statusMessage = "Tasks executed successfully";
    }
}

------------------------------------------------------------
OCL File:
---------
 class TaskExecutor {
   operation runTasks() : void
  pre: true
  post: true
  activity: (     var repeatFunction : Function<String,String> ; repeatFunction := lambda text : OclAny in (     return text + text ) ;
     var squareFunction : Function<double,double> ; squareFunction := lambda value : OclAny in (     return value * value ) ;
    var dd : double ; dd := 43545.6565 ;
    var processedText : String ; processedText := repeatFunction->apply("world") ;
    var processedNumber : double ; processedNumber := squareFunction->apply(4.5) ;
    var statusMessage : String ; statusMessage := "Tasks executed successfully" ;
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.function.Function;
class Evaluator {
    public void calculate() {
        Function<Double, Integer> categorizeFunction = 
            (value) -> { 
                if (value > 0) {
                    return 2; 
                } else if (value < 0) {
                    return -2; 
                } 
                return 0; 
            };
        int positiveCategory = categorizeFunction.apply(9.8);
        int negativeCategory = categorizeFunction.apply(-4.3);
        int neutralCategory = categorizeFunction.apply(0.0);
        String completionMessage = "Evaluation finished";
    }
}

------------------------------------------------------------
OCL File:
---------
 class Evaluator {
   operation calculate() : void
  pre: true
  post: true
  activity: (     var categorizeFunction : Function<double,int> ; categorizeFunction := lambda value : OclAny in (     if (value > 0) then (     return 2 ) else     if (value < 0) then (     return -2 ) else skip ; ;  
     return 0 ) ;
     var positiveCategory : int ; positiveCategory := categorizeFunction->apply(9.8) ;
    var negativeCategory : int ; negativeCategory := categorizeFunction->apply(-4.3) ;
    var neutralCategory : int ; neutralCategory := categorizeFunction->apply(0.0) ;
    var completionMessage : String ; completionMessage := "Evaluation finished" ;
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.function.Function;
class Analyzer {
    public void assessValues() {
        Function<Double, Function<Double, Integer>> assessmentFunction = 
            (x) -> (y) -> { 
                if (x < y) { 
                    return -10; 
                } else if (x > y) { 
                    return 10; 
                } 
                return 0; 
            };
        Function<Double, Integer> compareWithFive = assessmentFunction.apply(5.0);
        int resultA = compareWithFive.apply(3.0);
        int resultB = compareWithFive.apply(7.0);
    }
}

------------------------------------------------------------
OCL File:
---------
 class Analyzer {
   operation assessValues() : void
  pre: true
  post: true
  activity: (     var assessmentFunction : Function<double,Function<double,int>> ; assessmentFunction := lambda x : OclAny in lambda y : OclAny in (     if (x < y) then (     return -10 ) else     if (x > y) then (     return 10 ) else skip ; ;  
     return 0 ) ;
     var compareWithFive : Function<double,int> ; compareWithFive := assessmentFunction->apply(5.0) ;
     var resultA : int ; resultA := compareWithFive->apply(3.0) ;
     var resultB : int ; resultB := compareWithFive->apply(7.0) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class StringComparer {
  public void compareStrings() { 
    int number = 12;
    String str1 = "bb"; 
    String subStr = "ccdd".substring(1, 3); 
    number = number + 17; 
    System.out.println(number); 
    System.out.println(str1 == subStr); 
    System.out.println(str1.equals(subStr));  
  } 
}

------------------------------------------------------------
OCL File:
---------
class StringComparer {
   operation compareStrings() : void
  pre: true
  post: true
  activity: (     var number : int ; number := 12 ;
     var str1 : String ; str1 := "bb" ;
    var subStr : String ; subStr := "ccdd".subrange(1+1,3) ;
    number := number + 17 ; 
    OclFile["System.out"].println(number) ; 
    OclFile["System.out"].println(str1 = subStr) ; 
    OclFile["System.out"].println(str1 = subStr) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.function.Function;
import java.util.function.BiFunction;
class CalculationEngine {
    public void executeOperations() {
        int initialValue = 4;
        Object doubleFunction = (Integer value) -> (value * 2);
        Object combinedProductFunction = (a, b) -> (a * a * b);
        Object advancedProductFunction = (int x, int y) -> (x * x * y);
        int oo=10;
        Integer output1 = ((Function<Integer, Integer>) doubleFunction).apply(initialValue);
        Integer output2 = ((BiFunction<Integer, Integer, Integer>) combinedProductFunction).apply(5, 6);
        Integer output3 = ((BiFunction<Integer, Integer, Integer>) advancedProductFunction).apply(7, 8);
        oo++;
        String completionStatus = "Operations completed successfully";
        oo=oo+9;
    }
}

------------------------------------------------------------
OCL File:
---------
 class CalculationEngine {
   operation executeOperations() : void
  pre: true
  post: true
  activity: (     var initialValue : int ; initialValue := 4 ;
     var doubleFunction : OclAny ; doubleFunction := lambda  value : int : OclAny in (value * 2) ;
    var combinedProductFunction : OclAny ; combinedProductFunction := lambda (a , b) : OclAny in (a * a * b) ;
    var advancedProductFunction : OclAny ; advancedProductFunction := lambda  x : int, y : int : OclAny in (x * x * y) ;
    var oo : int ; oo := 10 ;
    var output1 : int ; output1 := (doubleFunction->oclAsType(Function<int,int>))->apply(initialValue) ;
    var output2 : int ; output2 := (combinedProductFunction->oclAsType(BiFunction<int,int,int>))->apply(5, 6) ;
    var output3 : int ; output3 := (advancedProductFunction->oclAsType(BiFunction<int,int,int>))->apply(7, 8) ;
    oo := oo + 1 ; 
    var completionStatus : String ; completionStatus := "Operations completed successfully" ;
    oo := oo + 9 ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class TaskExample {
    public void executeTask() {
        int initialNumber = 7;
        int subsequentNumber = 0;
        subsequentNumber = (initialNumber++)+(++initialNumber);
        int finalResult = initialNumber * subsequentNumber;
        double rr=5556.777;
        int totalSum = initialNumber + subsequentNumber;
        String statusUpdate = "Task completed with updated numbers";
    }
}

------------------------------------------------------------
OCL File:
---------
class TaskExample {
   operation executeTask() : void
  pre: true
  post: true
  activity: (     var initialNumber : int ; initialNumber := 7 ;
     var subsequentNumber : int ; subsequentNumber := 0 ;
        initialNumber := initialNumber + 1 ;
 subsequentNumber := (initialNumber) + (initialNumber)  ; initialNumber := initialNumber + 1 ; 
    var finalResult : int ; finalResult := initialNumber * subsequentNumber ;
    var rr : double ; rr := 5556.777 ;
    var totalSum : int ; totalSum := initialNumber + subsequentNumber ;
    var statusUpdate : String ; statusUpdate := "Task completed with updated numbers" ;
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
abstract class Person {
    String name = "";
    public Person(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}
class Client extends Person {
    String clientCode = "5678";
    public Client(String name, String code) {
        super(name);
        clientCode = code;
    }
}
class Manager extends Person {
    int managerId = 500;
    public Manager(String name, int id) {
        super(name);
        managerId = id;
    }
    public void setManagerId(int id) {
        managerId = id;
    }
}
class Contractor extends Person {
    String contractorTag = "CT001";
    public Contractor(String name, String tag) {
        super(name);
        contractorTag = tag;
    }
}
class Supervisor extends Person {
    int supervisorNumber = 300;
    public Supervisor(String name, int number) {
        super(name);
        supervisorNumber = number;
    }
}
class Trainee extends Person {
    String traineeCode = "TR456";
    public Trainee(String name, String code) {
        super(name);
        traineeCode = code;
    }
}
class Consultant extends Person {
    String consultantId = "CON789";
    public Consultant(String name, String id) {
        super(name);
        consultantId = id;
    }
}

------------------------------------------------------------
OCL File:
---------
class Person {
   attribute name : String := "";
   static operation newPerson( name : String) : Person
  pre: true
  post: true
  activity:
  ( var self : Person ;
    self := createPerson();
    self.initialise(name);
    return self );
  operation initialise( name : String) : void
  pre: true  post: true
  activity: (     self.name := name );
   operation getName() : String
  pre: true
  post: true
  activity: (     return name );
}
 class Client extends Person {
   attribute clientCode : String := "5678";
   static operation newClient( name : String, code : String) : Client
  pre: true
  post: true
  activity:
  ( var self : Client ;
    self := createClient();
    self.initialise(name, code);
    return self );
  operation initialise( name : String, code : String) : void
  pre: true  post: true
  activity: (     execute super(name) ; 
     clientCode := code );
}
class Manager extends Person {
   attribute managerId : int := 500;
   static operation newManager( name : String, id : int) : Manager
  pre: true
  post: true
  activity:
  ( var self : Manager ;
    self := createManager();
    self.initialise(name, id);
    return self );
  operation initialise( name : String, id : int) : void
  pre: true  post: true
  activity: (     execute super(name) ; 
     managerId := id );
   operation setManagerId( id : int) : void
  pre: true
  post: true
  activity: (     managerId := id );
}
class Contractor extends Person {
   attribute contractorTag : String := "CT001";
   static operation newContractor( name : String, tag : String) : Contractor
  pre: true
  post: true
  activity:
  ( var self : Contractor ;
    self := createContractor();
    self.initialise(name, tag);
    return self );
  operation initialise( name : String, tag : String) : void
  pre: true  post: true
  activity: (     execute super(name) ; 
     contractorTag := tag );
}
class Supervisor extends Person {
   attribute supervisorNumber : int := 300;
   static operation newSupervisor( name : String, number : int) : Supervisor
  pre: true
  post: true
  activity:
  ( var self : Supervisor ;
    self := createSupervisor();
    self.initialise(name, number);
    return self );
  operation initialise( name : String, number : int) : void
  pre: true  post: true
  activity: (     execute super(name) ; 
     supervisorNumber := number );
}
class Trainee extends Person {
   attribute traineeCode : String := "TR456";
   static operation newTrainee( name : String, code : String) : Trainee
  pre: true
  post: true
  activity:
  ( var self : Trainee ;
    self := createTrainee();
    self.initialise(name, code);
    return self );
  operation initialise( name : String, code : String) : void
  pre: true  post: true
  activity: (     execute super(name) ; 
     traineeCode := code );
}
class Consultant extends Person {
   attribute consultantId : String := "CON789";
   static operation newConsultant( name : String, id : String) : Consultant
  pre: true
  post: true
  activity:
  ( var self : Consultant ;
    self := createConsultant();
    self.initialise(name, id);
    return self );
  operation initialise( name : String, id : String) : void
  pre: true  post: true
  activity: (     execute super(name) ; 
     consultantId := id );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class TotalAdder {
    public int computeTotal() {
        int[] accumulatedTotals = new int[20];
        for (int outerIndex = 0; outerIndex < 20; outerIndex++) {
            for (int innerIndex = 1; innerIndex <= outerIndex; innerIndex++) {
                accumulatedTotals[outerIndex] += innerIndex;
            }
        }
        double k=90;
        k*=5;
        int ultimateTotal = accumulatedTotals[19];
        int extraAmount = ultimateTotal + 100;
        return ultimateTotal;
    }
}

------------------------------------------------------------
OCL File:
---------
class TotalAdder {
   operation computeTotal() : int
  pre: true
  post: true
  activity: (     var accumulatedTotals : Sequence(int) ; accumulatedTotals := Integer.subrange(1,20)->collect(0) ;
         var outerIndex : int ; outerIndex := 0 ; while outerIndex < 20 do ( (         var innerIndex : int ; innerIndex := 1 ; while innerIndex <= outerIndex do ( (     accumulatedTotals[outerIndex+1] := accumulatedTotals[outerIndex+1]+(innerIndex) )  ;     innerIndex := innerIndex + 1 ) )  ;     outerIndex := outerIndex + 1 ) ; 
    var k : double ; k := 90 ;
    k := k*(5) ; 
    var ultimateTotal : int ; ultimateTotal := accumulatedTotals[19+1] ;
    var extraAmount : int ; extraAmount := ultimateTotal + 100 ;
    return ultimateTotal 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
class DiscountCalculator {
    String calculationId = "";
    double period = 0.0;
    double baseRate = 0.0;
    public static void main(String[] args) {
        DiscountCalculator calculator = new DiscountCalculator();
        double extDiscountResult = calculator.calculateExtendedDiscount(7, 0.05, 0.04, 0.03, 0.06, 2.0, 3.0);
        double expDiscountResult = calculator.calculateDiscount(7, 0.05, 0.04, 0.03, 2.0);
        System.out.println("Extended Discount Result: " + extDiscountResult);
        System.out.println("Exponential Discount Result: " + expDiscountResult);
    }
    public static double computeExponentialDiscount(double time, double alpha, double beta, double gamma, double decay) {
        double outcome = 0.0;
        double adjustedTime = time / decay;
        double expAdjustedTime = Math.exp(-adjustedTime);
        double fraction = (1 - expAdjustedTime) / adjustedTime;
        outcome = alpha + beta * fraction + gamma * (fraction - expAdjustedTime);
        return outcome;
    }
    public static double computeExtendedDiscount(double time, double alpha, double beta, double gamma, double delta, double decay1, double decay2) {
        double outcome = 0.0;
        double adjustedTime1 = time / decay1;
        double adjustedTime2 = time / decay2;
        double expAdjustedTime1 = Math.exp(-adjustedTime1);
        double expAdjustedTime2 = Math.exp(-adjustedTime2);
        double fraction1 = (1 - expAdjustedTime1) / adjustedTime1;
        double fraction2 = (1 - expAdjustedTime2) / adjustedTime2;
        outcome = alpha + beta * fraction1 + gamma * (fraction1 - expAdjustedTime1) + delta * (fraction2 - expAdjustedTime2);
        return outcome;
    }
    public double calculateDiscount(double time, double alpha, double beta, double gamma, double decay) {
        double outcome = 0.0;
        if (time == 0) {
            outcome = alpha + beta;
        } else if (time > 0) {
            outcome = DiscountCalculator.computeExponentialDiscount(time, alpha, beta, gamma, decay);
        } else {
            System.out.println("Invalid time value");
        }
        return outcome;
    }
    public double calculateExtendedDiscount(double time, double alpha, double beta, double gamma, double delta, double decay1, double decay2) {
        double outcome = 0.0;
        if (time == 0) {
            outcome = alpha + beta;
        } else if (time > 0) {
            outcome = DiscountCalculator.computeExtendedDiscount(time, alpha, beta, gamma, delta, decay1, decay2);
        } else {
            System.out.println("Invalid time value");
        }
        return outcome;
    }
}

------------------------------------------------------------
OCL File:
---------
 class DiscountCalculator {
   attribute calculationId : String := "";
   attribute period : double := 0.0;
   attribute baseRate : double := 0.0;
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var calculator : DiscountCalculator ; calculator := DiscountCalculator.newDiscountCalculator() ;
     var extDiscountResult : double ; extDiscountResult := calculator.calculateExtendedDiscount(7, 0.05, 0.04, 0.03, 0.06, 2.0, 3.0) ;
    var expDiscountResult : double ; expDiscountResult := calculator.calculateDiscount(7, 0.05, 0.04, 0.03, 2.0) ;
    OclFile["System.out"].println("Extended Discount Result: " + extDiscountResult) ; 
    OclFile["System.out"].println("Exponential Discount Result: " + expDiscountResult) ; 
 );
  static   operation computeExponentialDiscount( time : double, alpha : double, beta : double, gamma : double, decay : double) : double
  pre: true
  post: true
  activity: (     var outcome : double ; outcome := 0.0 ;
     var adjustedTime : double ; adjustedTime := time / decay ;
    var expAdjustedTime : double ; expAdjustedTime := (-adjustedTime)->exp() ;
    var fraction : double ; fraction := (1 - expAdjustedTime) / adjustedTime ;
    outcome := alpha + beta * fraction + gamma * (fraction - expAdjustedTime) ; 
    return outcome 
 );
  static   operation computeExtendedDiscount( time : double, alpha : double, beta : double, gamma : double, delta : double, decay1 : double, decay2 : double) : double
  pre: true
  post: true
  activity: (     var outcome : double ; outcome := 0.0 ;
     var adjustedTime1 : double ; adjustedTime1 := time / decay1 ;
    var adjustedTime2 : double ; adjustedTime2 := time / decay2 ;
    var expAdjustedTime1 : double ; expAdjustedTime1 := (-adjustedTime1)->exp() ;
    var expAdjustedTime2 : double ; expAdjustedTime2 := (-adjustedTime2)->exp() ;
    var fraction1 : double ; fraction1 := (1 - expAdjustedTime1) / adjustedTime1 ;
    var fraction2 : double ; fraction2 := (1 - expAdjustedTime2) / adjustedTime2 ;
    outcome := alpha + beta * fraction1 + gamma * (fraction1 - expAdjustedTime1) + delta * (fraction2 - expAdjustedTime2) ; 
    return outcome 
 );
   operation calculateDiscount( time : double, alpha : double, beta : double, gamma : double, decay : double) : double
  pre: true
  post: true
  activity: (     var outcome : double ; outcome := 0.0 ;
     if (time = 0) then (     outcome := alpha + beta ) else     if (time > 0) then (     outcome := DiscountCalculator.computeExponentialDiscount(time, alpha, beta, gamma, decay) ) else (     OclFile["System.out"].println("Invalid time value") ) ;  ;  
     return outcome );
   operation calculateExtendedDiscount( time : double, alpha : double, beta : double, gamma : double, delta : double, decay1 : double, decay2 : double) : double
  pre: true
  post: true
  activity: (     var outcome : double ; outcome := 0.0 ;
     if (time = 0) then (     outcome := alpha + beta ) else     if (time > 0) then (     outcome := DiscountCalculator.computeExtendedDiscount(time, alpha, beta, gamma, delta, decay1, decay2) ) else (     OclFile["System.out"].println("Invalid time value") ) ;  ;  
     return outcome );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Person implements Serializable {
    String name = "";
    double age = 0.0;
    String location = "not specified";
    public Person(String name, double age, String location) {
        this.name = name;
        this.age = age;
        this.location = location;
    }
}
class DataLoader {
    void readData() throws IOException, ClassNotFoundException {
        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("data.dat"));
        Person person = (Person) inputStream.readObject();
        System.out.println(person.name + " " + person.age + " " + person.location);
        inputStream.close();
    }
    public static void main(String[] args) {
        try {
            DataLoader loader = new DataLoader();
            loader.readData();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
class FileSaver {
    void saveData(Person person) throws IOException {
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("data.dat"));
        outputStream.writeObject(person);
        outputStream.close();
    }
}
class UserProfile {
    String username = "";
    String email = "";
    public UserProfile(String username, String email) {
        this.username = username;
        this.email = email;
    }
    public void displayProfile() {
        System.out.println("Username: " + username);
        System.out.println("Email: " + email);
    }
}
class ProfileManager {
    public static void main(String[] args) {
        try {
            UserProfile profile = new UserProfile("john_doe", "john@example.com");
            FileSaver saver = new FileSaver();
            saver.saveData(new Person("John Doe", 30, "New York"));
            DataLoader loader = new DataLoader();
            loader.readData();
            profile.displayProfile();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

------------------------------------------------------------
OCL File:
---------
 class Person implements OclAny {
   attribute name : String := "";
   attribute age : double := 0.0;
   attribute location : String := "not specified";
   static operation newPerson( name : String, age : double, location : String) : Person
  pre: true
  post: true
  activity:
  ( var self : Person ;
    self := createPerson();
    self.initialise(name, age,location);
    return self );
  operation initialise( name : String, age : double, location : String) : void
  pre: true  post: true
  activity: (     self.name := name ; 
     self.age := age ; 
     self.location := location );
}
class DataLoader {
   operation readData() : void
  pre: true
  post: true
  activity: (     var inputStream : OclFile ; inputStream := OclFile.newOclFile_ReadB(OclFile.newOclFile_Read(OclFile.newOclFile("data.dat"))) ;
     var person : Person ; person := inputStream.readObject()->oclAsType(Person) ;
     OclFile["System.out"].println(person.name + " " + person.age + " " + person.location) ; 
     skip );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var loader : DataLoader ; loader := DataLoader.newDataLoader() ;
     loader.readData() )   catch (e : OclException) do (     e.printStackTrace() )
 );
}
class FileSaver {
   operation saveData( person : Person) : void
  pre: true
  post: true
  activity: (     var outputStream : OclFile ; outputStream := OclFile.newOclFile_WriteB(OclFile.newOclFile(OclFile.newOclFile_Write(OclFile.newOclFile("data.dat")))) ;
     skip ; 
     skip );
}
class UserProfile {
   attribute username : String := "";
   attribute email : String := "";
   static operation newUserProfile( username : String, email : String) : UserProfile
  pre: true
  post: true
  activity:
  ( var self : UserProfile ;
    self := createUserProfile();
    self.initialise(username, email);
    return self );
  operation initialise( username : String, email : String) : void
  pre: true  post: true
  activity: (     self.username := username ; 
     self.email := email );
   operation displayProfile() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Username: " + username) ; 
     OclFile["System.out"].println("Email: " + email) );
}
class ProfileManager {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     try (     var profile : UserProfile ; profile := UserProfile.newUserProfile("john_doe", "john@example.com") ;
     var saver : FileSaver ; saver := FileSaver.newFileSaver() ;
    saver.saveData(Person.newPerson("John Doe", 30, "New York")) ; 
    var loader : DataLoader ; loader := DataLoader.newDataLoader() ;
    loader.readData() ; 
    profile.displayProfile() ; 
 )   catch (e : OclException) do (     e.printStackTrace() )
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.*;
class Person implements Serializable {
    String id = "";
    double age = 0.0;
    public Person(String id, double age) {
        this.id = id;
        this.age = age;
    }
}
class FileSaver {
    void writeToFile() {
        Person user = new Person("Bob", 25);
        try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("data.bin"))) {
            outputStream.writeObject(user);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
class ExtraFunctionality {
    void showInfo() {
        System.out.println("This class provides additional functionality.");
    }
}
class DataProcessor {
    void processData() {
        System.out.println("Processing data...");
    }
}
public class MainApplication {
    public static void main(String[] args) {
        FileSaver fileSaver = new FileSaver();
        fileSaver.writeToFile();
        ExtraFunctionality extra = new ExtraFunctionality();
        extra.showInfo();
        DataProcessor processor = new DataProcessor();
        processor.processData();
    }
}

------------------------------------------------------------
OCL File:
---------
 class Person implements OclAny {
   attribute id : String := "";
   attribute age : double := 0.0;
   static operation newPerson( id : String, age : double) : Person
  pre: true
  post: true
  activity:
  ( var self : Person ;
    self := createPerson();
    self.initialise(id, age);
    return self );
  operation initialise( id : String, age : double) : void
  pre: true  post: true
  activity: (     self.id := id ; 
     self.age := age );
}
class FileSaver {
   operation writeToFile() : void
  pre: true
  post: true
  activity: (     var user : Person ; user := Person.newPerson("Bob", 25) ;
     try (    var outputStream : OclFile := OclFile.newOclFile_WriteB(OclFile.newOclFile(OclFile.newOclFile_Write(OclFile.newOclFile("data.bin")))) ;
 (     skip ))   catch (e : IOException) do (     e.printStackTrace() )
  );
}
class ExtraFunctionality {
   operation showInfo() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("This class provides additional functionality.") );
}
class DataProcessor {
   operation processData() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Processing data...") );
}
class MainApplication {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var fileSaver : FileSaver ; fileSaver := FileSaver.newFileSaver() ;
     fileSaver.writeToFile() ; 
    var extra : ExtraFunctionality ; extra := ExtraFunctionality.newExtraFunctionality() ;
    extra.showInfo() ; 
    var processor : DataProcessor ; processor := DataProcessor.newDataProcessor() ;
    processor.processData() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class DataProcessor {
    public boolean handleData() {
        int s;
        s=80;
        Object item1 = "example text";
        Object item2 = new Object();
        item2 = (String) item1.toString();
        s=s-9; 
        item1.hashCode();
        Class type = item2.getClass();
        try {
            item2.wait(300);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        boolean status = item2.equals("example text");
        return status;
    }
}
class ApplicationRunner {
    public static void main(String[] args) {
        DataProcessor processor = new DataProcessor();
        boolean outcome = processor.handleData();
        System.out.println("Result of handling: " + outcome);
    }
}

------------------------------------------------------------
OCL File:
---------
class DataProcessor {
   operation handleData() : boolean
  pre: true
  post: true
  activity: (     var s : int ;
     s := 80 ; 
    var item1 : OclAny ; item1 := "example text" ;
    var item2 : OclAny ; item2 := Map{} ;
    item2 := item1+""->oclAsType(String) ; 
    s := s - 9 ; 
    item1.hashCode() ; 
    var type : OclType ; type := item2->oclType() ;
    try (     item2.wait(300) )   catch (ex : ProgramException) do (     ex.printStackTrace() )
    var status : boolean ; status := item2 = "example text" ;
    return status 
 );
}
 class ApplicationRunner {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var processor : DataProcessor ; processor := DataProcessor.newDataProcessor() ;
     var outcome : boolean ; outcome := processor.handleData() ;
     OclFile["System.out"].println("Result of handling: " + outcome) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class User {
    String username = "";
    int age = 0;
    public User(String username) {
        this.username = username;
    }
    public int celebrateAnniversary() {
        ++age;
        return age;
    }
}
class Scholar extends User {
    String fieldOfStudy = "";
    public Scholar(String username, String fieldOfStudy) {
        super(username);
        this.fieldOfStudy = fieldOfStudy;
    }
}
class Professional extends User {
    String jobTitle = "";
    public Professional(String username, String jobTitle) {
        super(username);
        this.jobTitle = jobTitle;
    }
}
class DataProcessor {
    public boolean transformData() {
        Object item1 = "example value";
        Object item2 = new Object();
        item2 = (String) item1.toString();
        item1.hashCode();
        Class type = item2.getClass();
        try {
            item2.wait(100);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        return item2.equals("example value");
    }
}
class MainApp {
    public static void main(String[] args) {
        DataProcessor processor = new DataProcessor();
        boolean result = processor.transformData();
        System.out.println("Data transformation result: " + result);
        User user = new User("Alex");
        user.celebrateAnniversary();
        Scholar scholar = new Scholar("Taylor", "Engineering");
        Professional professional = new Professional("Jordan", "Developer");
        System.out.println("User: " + user.username + ", Age: " + user.age);
        System.out.println("Scholar: " + scholar.username + ", Field of Study: " + scholar.fieldOfStudy);
        System.out.println("Professional: " + professional.username + ", Job Title: " + professional.jobTitle);
    }
}

------------------------------------------------------------
OCL File:
---------
class User {
   attribute username : String := "";
   attribute age : int := 0;
   static operation newUser( username : String) : User
  pre: true
  post: true
  activity:
  ( var self : User ;
    self := createUser();
    self.initialise(username);
    return self );
  operation initialise( username : String) : void
  pre: true  post: true
  activity: (     self.username := username );
   operation celebrateAnniversary() : int
  pre: true
  post: true
  activity: (     age := age + 1 ; 
     return age );
}
 class Scholar extends User {
   attribute fieldOfStudy : String := "";
   static operation newScholar( username : String, fieldOfStudy : String) : Scholar
  pre: true
  post: true
  activity:
  ( var self : Scholar ;
    self := createScholar();
    self.initialise(username, fieldOfStudy);
    return self );
  operation initialise( username : String, fieldOfStudy : String) : void
  pre: true  post: true
  activity: (     execute super(username) ; 
     self.fieldOfStudy := fieldOfStudy );
}
class Professional extends User {
   attribute jobTitle : String := "";
   static operation newProfessional( username : String, jobTitle : String) : Professional
  pre: true
  post: true
  activity:
  ( var self : Professional ;
    self := createProfessional();
    self.initialise(username, jobTitle);
    return self );
  operation initialise( username : String, jobTitle : String) : void
  pre: true  post: true
  activity: (     execute super(username) ; 
     self.jobTitle := jobTitle );
}
class DataProcessor {
   operation transformData() : boolean
  pre: true
  post: true
  activity: (     var item1 : OclAny ; item1 := "example value" ;
     var item2 : OclAny ; item2 := Map{} ;
    item2 := item1+""->oclAsType(String) ; 
    item1.hashCode() ; 
    var type : OclType ; type := item2->oclType() ;
    try (     item2.wait(100) )   catch (ex : ProgramException) do (     ex.printStackTrace() )
    return item2 = "example value" 
 );
}
class MainApp {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var processor : DataProcessor ; processor := DataProcessor.newDataProcessor() ;
     var result : boolean ; result := processor.transformData() ;
    OclFile["System.out"].println("Data transformation result: " + result) ; 
    var user : User ; user := User.newUser("Alex") ;
    user.celebrateAnniversary() ; 
    var scholar : Scholar ; scholar := Scholar.newScholar("Taylor", "Engineering") ;
    var professional : Professional ; professional := Professional.newProfessional("Jordan", "Developer") ;
    OclFile["System.out"].println("User: " + user.username + ", Age: " + user.age) ; 
    OclFile["System.out"].println("Scholar: " + scholar.username + ", Field of Study: " + scholar.fieldOfStudy) ; 
    OclFile["System.out"].println("Professional: " + professional.username + ", Job Title: " + professional.jobTitle) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package p2;
interface TaskX {
    int computeX();
    double computeY();
}
interface TaskY {
    String generateX();
    boolean generateY();
}
class Widget implements TaskX {
    int computeX() {
        return 15;
    }
    double computeY() {
        return 25.5;
    }
}
class Gadget implements TaskX {
    int computeX() {
        return 45;
    }
    double computeY() {
        return 35.25;
    }
}
class Tool implements TaskY {
    String generateX() {
        return "Greetings";
    }
    boolean generateY() {
        return false;
    }
}
class Instrument implements TaskY {
    String generateX() {
        return "Universe";
    }
    boolean generateY() {
        return true;
    }
}
class ObjectDetail {
    String name = "";
    int value = 0;
    public ObjectDetail(String name) {
        this.name = name;
    }
    public int incrementValue() {
        ++value;
        return value;
    }
}
class Researcher extends ObjectDetail {
    String area = "";
    public Researcher(String name, String area) {
        super(name);
        this.area = area;
    }
}
class Worker extends ObjectDetail {
    String role = "";
    public Worker(String name, String role) {
        super(name);
        this.role = role;
    }
}
class DataHandler {
    public boolean processData() {
        Object item1 = "text example";
        Object item2 = new Object();
        item2 = (String) item1.toString();
        item1.hashCode();
        Class type = item2.getClass();
        try {
            item2.wait(300);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        return item2.equals("text example");
    }
}
class MainExecution {
    public static void main(String[] args) {
        DataHandler handler = new DataHandler();
        boolean outcome = handler.processData();
        System.out.println("Data processing result: " + outcome);
        ObjectDetail detail = new ObjectDetail("Sophia");
        detail.incrementValue();
        Researcher researcher = new Researcher("John", "Physics");
        Worker worker = new Worker("Alice", "Designer");
        System.out.println("ObjectDetail: " + detail.name + ", Value: " + detail.value);
        System.out.println("Researcher: " + researcher.name + ", Area: " + researcher.area);
        System.out.println("Worker: " + worker.name + ", Role: " + worker.role);
        Widget widget = new Widget();
        Gadget gadget = new Gadget();
        Tool tool = new Tool();
        Instrument instrument = new Instrument();
        System.out.println("Widget: " + widget.computeX() + ", " + widget.computeY());
        System.out.println("Gadget: " + gadget.computeX() + ", " + gadget.computeY());
        System.out.println("Tool: " + tool.generateX() + ", " + tool.generateY());
        System.out.println("Instrument: " + instrument.generateX() + ", " + instrument.generateY());
    }
}

------------------------------------------------------------
OCL File:
---------
 interface TaskX {
   operation computeX() : int
  pre: true
  post: true;
   operation computeY() : double
  pre: true
  post: true;
}
interface TaskY {
   operation generateX() : String
  pre: true
  post: true;
   operation generateY() : boolean
  pre: true
  post: true;
}
class Widget implements TaskX {
   operation computeX() : int
  pre: true
  post: true
  activity: (     return 15 );
   operation computeY() : double
  pre: true
  post: true
  activity: (     return 25.5 );
}
class Gadget implements TaskX {
   operation computeX() : int
  pre: true
  post: true
  activity: (     return 45 );
   operation computeY() : double
  pre: true
  post: true
  activity: (     return 35.25 );
}
class Tool implements TaskY {
   operation generateX() : String
  pre: true
  post: true
  activity: (     return "Greetings" );
   operation generateY() : boolean
  pre: true
  post: true
  activity: (     return false );
}
class Instrument implements TaskY {
   operation generateX() : String
  pre: true
  post: true
  activity: (     return "Universe" );
   operation generateY() : boolean
  pre: true
  post: true
  activity: (     return true );
}
class ObjectDetail {
   attribute name : String := "";
   attribute value : int := 0;
   static operation newObjectDetail( name : String) : ObjectDetail
  pre: true
  post: true
  activity:
  ( var self : ObjectDetail ;
    self := createObjectDetail();
    self.initialise(name);
    return self );
  operation initialise( name : String) : void
  pre: true  post: true
  activity: (     self.name := name );
   operation incrementValue() : int
  pre: true
  post: true
  activity: (     value := value + 1 ; 
     return value );
}
class Researcher extends ObjectDetail {
   attribute area : String := "";
   static operation newResearcher( name : String, area : String) : Researcher
  pre: true
  post: true
  activity:
  ( var self : Researcher ;
    self := createResearcher();
    self.initialise(name, area);
    return self );
  operation initialise( name : String, area : String) : void
  pre: true  post: true
  activity: (     execute super(name) ; 
     self.area := area );
}
class Worker extends ObjectDetail {
   attribute role : String := "";
   static operation newWorker( name : String, role : String) : Worker
  pre: true
  post: true
  activity:
  ( var self : Worker ;
    self := createWorker();
    self.initialise(name, role);
    return self );
  operation initialise( name : String, role : String) : void
  pre: true  post: true
  activity: (     execute super(name) ; 
     self.role := role );
}
class DataHandler {
   operation processData() : boolean
  pre: true
  post: true
  activity: (     var item1 : OclAny ; item1 := "text example" ;
     var item2 : OclAny ; item2 := Map{} ;
    item2 := item1+""->oclAsType(String) ; 
    item1.hashCode() ; 
    var type : OclType ; type := item2->oclType() ;
    try (     item2.wait(300) )   catch (ex : ProgramException) do (     ex.printStackTrace() )
    return item2 = "text example" 
 );
}
class MainExecution {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var handler : DataHandler ; handler := DataHandler.newDataHandler() ;
     var outcome : boolean ; outcome := handler.processData() ;
    OclFile["System.out"].println("Data processing result: " + outcome) ; 
    var detail : ObjectDetail ; detail := ObjectDetail.newObjectDetail("Sophia") ;
    detail.incrementValue() ; 
    var researcher : Researcher ; researcher := Researcher.newResearcher("John", "Physics") ;
    var worker : Worker ; worker := Worker.newWorker("Alice", "Designer") ;
    OclFile["System.out"].println("ObjectDetail: " + detail.name + ", Value: " + detail.value) ; 
    OclFile["System.out"].println("Researcher: " + researcher.name + ", Area: " + researcher.area) ; 
    OclFile["System.out"].println("Worker: " + worker.name + ", Role: " + worker.role) ; 
    var widget : Widget ; widget := Widget.newWidget() ;
    var gadget : Gadget ; gadget := Gadget.newGadget() ;
    var tool : Tool ; tool := Tool.newTool() ;
    var instrument : Instrument ; instrument := Instrument.newInstrument() ;
    OclFile["System.out"].println("Widget: " + widget.computeX() + ", " + widget.computeY()) ; 
    OclFile["System.out"].println("Gadget: " + gadget.computeX() + ", " + gadget.computeY()) ; 
    OclFile["System.out"].println("Tool: " + tool.generateX() + ", " + tool.generateY()) ; 
    OclFile["System.out"].println("Instrument: " + instrument.generateX() + ", " + instrument.generateY()) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class WTest {
    public int op() {
        double investment = 100.0;
        double rate = 0.05;
        int years = 0;
        while (investment*Math.pow(1.05,years) < 2*investment) 
        { years++; } 
        return years; 
    }
}
------------------------------------------------------------
OCL File:
---------
class WTest {
   operation op() : int
  pre: true
  post: true
  activity: (     var investment : double ; investment := 100.0 ;
     var rate : double ; rate := 0.05 ;
    var years : int ; years := 0 ;
    while (investment * 1.05->pow(years) < 2 * investment) do (     years := years + 1 ) ; 
    return years 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class aaa {
 public void op() { 
  Number nn = new Number(); 
  byte bb = nn.byteValue(); 
  throw new NoClassDefFoundError("message"); 
 }
}

------------------------------------------------------------
OCL File:
---------
class aaa {
   operation op() : void
  pre: true
  post: true
  activity: (     var nn : double ; nn := 0.0 ;
     var bb : int ; bb := nn->oclAsType(int) ;
     error AccessingException("message") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class MyClass {
    public int op() {
        int[] x = { 1, 2, 3, 5, 7, 11, 13, 17 };
        int total = 0;
        int i = 0;
        while (i < x.length) {
            total += x[i++];
        }
        return total;
    }
}

------------------------------------------------------------
OCL File:
---------
class MyClass {
   operation op() : int
  pre: true
  post: true
  activity: (     var x : Sequence(int) ; x := Sequence{1,2,3,5,7,11,13,17} ;
     var total : int ; total := 0 ;
    var i : int ; i := 0 ;
    while (i < x->size()) do (      total := total + x[i+1]  ; i := i + 1 ) ; 
    return total 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
interface IA 
{ long getTime(); }
interface IB 
{ String getName(); } 
abstract class Sup 
{ protected String name; }
class Sub extends Sup implements IA, IB
{ public long getTime() 
  { return 0; } 
  public String getName()
  { return name; } 
}
public class Main
{ public static void main(String[] args) 
  { Sub sb = new Sub(); 
    sb.name = "Tom"; 
    System.out.printf("%d  %s\n", sb.getTime(), sb.getName()); 
  } 
}

------------------------------------------------------------
OCL File:
---------
interface IA {
   operation getTime() : long
  pre: true
  post: true;
}
 interface IB {
   operation getName() : String
  pre: true
  post: true;
}
class Sup {
     attribute name : String;
}
class Sub extends Sup, IA, IB {
   operation getTime() : long
  pre: true
  post: true
  activity: (     return 0 );
   operation getName() : String
  pre: true
  post: true
  activity: (     return name );
}
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var sb : Sub ; sb := Sub.newSub() ;
     sb.name := "Tom" ; 
     OclFile["System.out"].printf("%d  %s\n", sb.getTime(), sb.getName()) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class FileManipulator {
    public void manipulateFile() {
      File f = new File("f.txt"); 
      PrintStream ps = new PrintStream(new FileWriter(f)); 
      ps.print(true); ps.println(77.098); 
      ps.println(55); 
      char[] cs = {'a', 'b', 'c'}; 
      ps.println(cs); 
      byte[] bs = { 97, 98, 99 }; 
      ps.write(bs,0,2); 
    }
}

------------------------------------------------------------
OCL File:
---------
class FileManipulator {
   operation manipulateFile() : void
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile("f.txt") ;
     var ps : OclFile ; ps := OclFile.newOclFile_Write(OclFile.newOclFile_Write(f)) ;
    skip ; 
    skip ; 
    skip ; 
    var cs : Sequence(String) ; cs := Sequence{'a','b','c'} ;
    skip ; 
    var bs : Sequence(int) ; bs := Sequence{97,98,99} ;
    skip ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Main
{ public static void main(String[] args)
  { PriorityQueue<String> q = new PriorityQueue<String>();
    q.offer("3");
    q.offer("2");
    q.offer("8");
    q.offer("5");
    System.out.println(q);
    System.out.println(q.peek());
    while (q.size() > 0)
    { String s = q.poll();
      System.out.println(s);
    }
  }
}

------------------------------------------------------------
OCL File:
---------
class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var q : Sequence(String) ; q := Sequence{} ;
     q := q->including("3") ; 
    q := q->including("2") ; 
    q := q->including("8") ; 
    q := q->including("5") ; 
    OclFile["System.out"].println(q) ; 
    OclFile["System.out"].println(q->min()) ; 
    while (q->size() > 0) do (     var s : String ; s := q->min() ;
     OclFile["System.out"].println(s) ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class RAFile
{ public void raop()
  { RandomAccessFile ff = new RandomAccessFile("ff.txt", "rw"); 
    ff.writeBytes("First line\n"); 
    ff.writeBytes("Second line\n");  
    ff.writeBytes("Third line\n"); 
    ff.close();
  } 
} 
------------------------------------------------------------
OCL File:
---------
class RAFile {
   operation raop() : void
  pre: true
  post: true
  activity: (     var ff : OclFile ; ff := OclFile.newOclFile("ff.txt", "rw") ;
     skip ; 
    skip ; 
    skip ; 
    skip ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class RAF2
{ public void op2()
  { RandomAccessFile ff = new RandomAccessFile("ff.txt", "rw");
    long ptr = ff.getFilePointer();
    int x = ff.readByte();
    ptr = ff.getFilePointer();
    x = ff.readByte();
    ptr = ff.getFilePointer();
    ff.close();
  }
}

------------------------------------------------------------
OCL File:
---------
class RAF2 {
   operation op2() : void
  pre: true
  post: true
  activity: (     var ff : OclFile ; ff := OclFile.newOclFile("ff.txt", "rw") ;
     var ptr : long ; ptr := ff.getPosition() ;
    var x : int ; x := ff.readByte() ;
    ptr := ff.getPosition() ; 
    x := ff.readByte() ; 
    ptr := ff.getPosition() ; 
    skip ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class RTest
{ double op()
  { Random rr = new Random();
    double dd = rr.nextDouble();
    dd = rr.nextGaussian();
    boolean bb = rr.nextBoolean();
    int ii = rr.nextInt(1000);
    ii = rr.nextInt();
    rr.setSeed(3000000);
    dd = rr.nextFloat();
    return rr.nextGaussian();
  }
}

------------------------------------------------------------
OCL File:
---------
class RTest {
   operation op() : double
  pre: true
  post: true
  activity: (     var rr : OclRandom ; rr := OclRandom.newOclRandom() ;
     var dd : double ; dd := rr.nextDouble() ;
    dd := rr.nextGaussian() ; 
    var bb : boolean ; bb := rr.nextBoolean() ;
    var ii : int ; ii := rr.nextInt(1000) ;
    ii := rr.nextInt() ; 
    rr.setSeed(3000000) ; 
    dd := rr.nextFloat() ; 
    return rr.nextGaussian() 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class ArrayOps {
  public static void swap(int[] x, int[] y)
  { int z = x[0];
    x[0] = y[0];
    y[0] = z;
  }
  public static void main(String[] args)
  { int[] a = {1,2,3,4};
    int[] b = {2,4,6,8};
    swap(a,b);
    System.out.println(a[0] + " " + a[1] + " " + a[2] + " " + a[3]);
    System.out.println(b[0] + " " + b[1] + " " + b[2] + " " + b[3]);
  }
}

------------------------------------------------------------
OCL File:
---------
class ArrayOps {
  static   operation swap( x : Sequence(int), y : Sequence(int)) : void
  pre: true
  post: true
  activity: (     var z : int ; z := x[0+1] ;
     x[0+1] := y[0+1] ; 
     y[0+1] := z );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,4} ;
     var b : Sequence(int) ; b := Sequence{2,4,6,8} ;
    execute swap(a, b) ; 
    OclFile["System.out"].println(a[0+1] + " " + a[1+1] + " " + a[2+1] + " " + a[3+1]) ; 
    OclFile["System.out"].println(b[0+1] + " " + b[1+1] + " " + b[2+1] + " " + b[3+1]) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class RT {
    public void op() { 
      int[] a = {1,2,3,4}; 
      int[] b = {2,4,6,8}; 
      boolean tst = (a == b); 
      tst = (a.equals(b)); 
      tst = Arrays.equals(a,b); 
      a = b; 
      tst = (a == b); 
      tst = (a.equals(b)); 
      tst = Arrays.equals(a,b); 
}
}

------------------------------------------------------------
OCL File:
---------
class RT {
   operation op() : void
  pre: true
  post: true
  activity: (     var a : Sequence(int) ; a := Sequence{1,2,3,4} ;
     var b : Sequence(int) ; b := Sequence{2,4,6,8} ;
    var tst : boolean ; tst := (a = b) ;
    tst := (a = b) ; 
    tst := a = b ; 
    a := b ; 
    tst := (a = b) ; 
    tst := (a = b) ; 
    tst := a = b ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Word
{ public String pos = "NN";
  public String text = "";
  public Word() { }
  public Word(String txt)
  { text = txt; }
  public String getPos()
  { return pos; }
}
class EnglishWord extends Word
{ public String tense = "Present";
  public EnglishWord(String txt)
  { super(txt); }
  public String getTense()
  { return tense; }
}
class Controller
{ public static void op()
  { Class t = EnglishWord.class;
    Field[] attrs = t.getFields();
    Method[] mets = t.getMethods();
    Constructor[] cons = t.getConstructors();
    Class sp = t.getSuperclass();
  }
}

------------------------------------------------------------
OCL File:
---------
class Word {
   attribute pos : String := "NN";
   attribute text : String := "";
   static operation newWord() : Word
  pre: true
  post: true
  activity:
  ( var self : Word ;
    self := createWord();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   static operation newWord( txt : String) : Word
  pre: true
  post: true
  activity:
  ( var self : Word ;
    self := createWord();
    self.initialise(txt);
    return self );
  operation initialise( txt : String) : void
  pre: true  post: true
  activity: (     text := txt );
   operation getPos() : String
  pre: true
  post: true
  activity: (     return pos );
}
 class EnglishWord extends Word {
   attribute tense : String := "Present";
   static operation newEnglishWord( txt : String) : EnglishWord
  pre: true
  post: true
  activity:
  ( var self : EnglishWord ;
    self := createEnglishWord();
    self.initialise(txt);
    return self );
  operation initialise( txt : String) : void
  pre: true  post: true
  activity: (     execute super(txt) );
   operation getTense() : String
  pre: true
  post: true
  activity: (     return tense );
}
class Controller {
  static   operation op() : void
  pre: true
  post: true
  activity: (     var t : OclType ; t := OclType["EnglishWord"] ;
     var attrs : Sequence(OclAttribute) ; attrs := t.getFields() ;
    var mets : Sequence(OclOperation) ; mets := t.getMethods() ;
    var cons : Sequence(OclOperation) ; cons := t.getConstructors() ;
    var sp : OclType ; sp := t.getSuperclass() ;
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class ATest 
{ abstract String getName(); }
------------------------------------------------------------
OCL File:
---------
class ATest {
     operation getName() : String
  pre: true
  post: true;
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class MyClass {
  void op() 
  { List<String> slist = new ArrayList<String>(); 
    slist.add("aa"); 
    slist.add("bb"); 
    slist.add("cc");
    slist.add("aa");  
    boolean b = slist.remove("bb"); 
    b = slist.remove("dd"); 
    b = Collections.replaceAll(slist, "aa", "dd"); 
    System.out.println(slist); 
  } 
}

------------------------------------------------------------
OCL File:
---------
 class MyClass {
   operation op() : void
  pre: true
  post: true
  activity: (     var slist : Sequence(String) ; slist := Sequence{} ;
     slist := slist->including("aa") ; 
    slist := slist->including("bb") ; 
    slist := slist->including("cc") ; 
    slist := slist->including("aa") ; 
    var b : boolean ; b := slist->includes("bb") ;
    b := slist->includes("dd") ;     slist := slist->excludingFirst("dd") ; 
     b := slist->includes( "aa" )  ;     slist := slist->collect( x1 | if x1 = "aa" then "dd" else x1 endif ) ; 
    OclFile["System.out"].println(slist) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class RunTest implements Runnable
{ private String inst;
  public RunTest(String nme)
  { inst = nme; }
  public void run()
  { for (int i = 0; i < 20; i++)
    { System.out.println(">> step " + i + " of " + inst); }
  }
}
public class Main
{ public static void main(String[] args)
  {  RunTest r1 = new RunTest("1");
    RunTest r2 = new RunTest("2");
    Thread t1 = new Thread(r1);
    Thread t2 = new Thread(r2);
    t1.start();
    t2.start();
  }
}

------------------------------------------------------------
OCL File:
---------
class RunTest implements Runnable {
   attribute inst : String;
   static operation newRunTest( nme : String) : RunTest
  pre: true
  post: true
  activity:
  ( var self : RunTest ;
    self := createRunTest();
    self.initialise(nme);
    return self );
  operation initialise( nme : String) : void
  pre: true  post: true
  activity: (     inst := nme );
   operation run() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 20 do ( (     OclFile["System.out"].println(">> step " + i + " of " + inst) )  ;     i := i + 1 ) );
}
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r1 : RunTest ; r1 := RunTest.newRunTest("1") ;
     var r2 : RunTest ; r2 := RunTest.newRunTest("2") ;
    var t1 : OclProcess ; t1 := OclProcess.newOclProcess(r1) ;
    var t2 : OclProcess ; t2 := OclProcess.newOclProcess(r2) ;
    t1.start() ; 
    t2.start() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class RTest
{ int op()
  { Runtime rt = Runtime.getRuntime();
    Process p = rt.exec("C:/Users/klano/AppData/Local/Programs/Python/Python37-32/python.exe");
    int ec = p.waitFor();
    return ec;
  }
}

------------------------------------------------------------
OCL File:
---------
class RTest {
   operation op() : int
  pre: true
  post: true
  activity: (     var rt : OclProcess ; rt := Runtime.getRuntime() ;
     var p : OclProcess ; p := rt.exec("C:/Users/klano/AppData/Local/Programs/Python/Python37-32/python.exe") ;
     var ec : int ; ec := p.waitFor() ;
     return ec );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class DataReader {
    public ArrayList<Integer> readData() {
        ArrayList<Integer> res = new ArrayList<Integer>();
        Scanner f = new Scanner(System.in);
        while (f.hasNext())
        { int p = f.nextInt();
          res.add(p);
        }
        return res;
    }
}

------------------------------------------------------------
OCL File:
---------
class DataReader {
   operation readData() : Sequence(int)
  pre: true
  post: true
  activity: (     var res : Sequence(int) ; res := Sequence{} ;
     var f : OclFile ; f := OclFile.newOclFile_Read(OclFile["System.in"]) ;
     while (f.hasNext()) do (     var p : int ; p := f.getCurrent()->toInteger() ;
     res := res->including(p) ) ; 
     return res );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet;
import java.util.TreeSet;
public class MyClass {
    public void exampleMethod() 
    { HashSet<String> st = new HashSet<String>();  
      st = new HashSet<String>(100); 
      TreeSet<String> tst = new TreeSet<String>(st); 
      tst = new TreeSet<String>(); 
      String[][] sarr = { { "a", "b" }, { "c", "d" } }; 
      sarr[0][0] = "e"; 
    }
}

------------------------------------------------------------
OCL File:
---------
 class MyClass {
   operation exampleMethod() : void
  pre: true
  post: true
  activity: (     var st : Set(String) ; st := Set{} ;
     st := Set{} ; 
    var tst : Set(String) ; tst := Set{}->union(st) ;
    tst := Set{} ; 
    var sarr : Sequence(Sequence(String)) ; sarr := Sequence{Sequence{"a","b"},Sequence{"c","d"}} ;
    sarr[0+1][0+1] := "e" ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ShortManipulator {
    public int manipulateShorts() {
      Short st = new Short("0xFF"); 
      short x = Short.MAX_VALUE; 
      x = Short.parseShort("077"); 
      float ff = st.floatValue(); 
      return st.compareTo(new Short(99));
    }
}

------------------------------------------------------------
OCL File:
---------
class ShortManipulator {
   operation manipulateShorts() : int
  pre: true
  post: true
  activity: (     var st : int ; st := ("" + ("0xFF"))->toInteger() ;
     var x : int ; x := 32767 ;
    x := ("077")->toInteger() ; 
    var ff : double ; ff := st->oclAsType(double) ;
    return st->compareTo(("" + (99))->toInteger()) 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class IncrementDecrement {
    public int op() {
     int x = 10; 
     x++; 
     x = x++; 
     x = x--; 
     x = ++x; 
     x = --x; 
     x--; 
     return x; 
    }
}

------------------------------------------------------------
OCL File:
---------
class IncrementDecrement {
   operation op() : int
  pre: true
  post: true
  activity: (     var x : int ; x := 10 ;
     x := x + 1 ; 
     x := x  ; x := x + 1 ; 
     x := x  ; x := x - 1 ; 
        x := x + 1 ;
 x := x  ; 
        x := x - 1 ;
 x := x  ; 
    x := x - 1 ; 
    return x 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.Socket;
public class MyClass {
void socketOp()
{ InetAddress addr = InetAddress.getByName("localhost");
  Socket skt = new Socket(addr, 12345);
  ObjectOutputStream stream = new ObjectOutputStream(skt.getOutputStream());
  stream.writeObject("Message to server");
  stream.flush();
  stream.close();
  skt.close();
}
}

------------------------------------------------------------
OCL File:
---------
 class MyClass {
   operation socketOp() : void
  pre: true
  post: true
  activity: (     var addr : String ; addr := "localhost" ;
     var skt : OclDatasource ; skt := OclDatasource.newSocket(addr, 12345) ;
    var stream : OclFile ; stream := OclFile.newOclFile_WriteB(OclFile.newOclFile(skt.getOutputStream())) ;
    skip ; 
    skip ; 
    skip ; 
    skt.close() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class STest
{ static int objCount = 0;
  static ArrayList<String> ids;
  static
  { ids = new ArrayList<String>();
    ids.add("aa");
    ids.add("bb");
  }
}

------------------------------------------------------------
OCL File:
---------
class STest {
  static   attribute objCount : int := 0;
  static   attribute ids : Sequence(String);
  static operation initialiseClass()
  pre: true post: true
  activity:     ids := Sequence{} ; 
    ids := ids->including("aa") ; 
    ids := ids->including("bb") ; 
;
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class NClass
{ @Nullable
  public String op(@NonNull Object obj, int x)
  { String res = obj.getClass().getName() + x;
    return res;
  }
  public String op1(@Nullable Object obj)
  { return "" + obj; }
}

------------------------------------------------------------
OCL File:
---------
class NClass {
      operation op( obj : OclAny, x : int) : String
  pre: true
  post: true
  activity: (     var res : String ; res := obj->oclType().getName() + x ;
     return res );
   operation op1( obj : OclAny) : String
  pre: true
  post: true
  activity: (     return "" + obj );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class A
{ static int count = 0;
  public A() 
  { A.count++; } 
  static int getCount() 
  { return A.count; } 
}

------------------------------------------------------------
OCL File:
---------
class A {
  static   attribute count : int := 0;
   static operation newA() : A
  pre: true
  post: true
  activity:
  ( var self : A ;
    self := createA();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     A.count := A.count + 1 );
  static   operation getCount() : int
  pre: true
  post: true
  activity: (     return A.count );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public interface MWS {
  public <T> @WS void response() { return; }
}

------------------------------------------------------------
OCL File:
---------
interface MWS {
     operation response<T>() : void
  pre: true
  post: true
  activity: (     return );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class CC {
  public C<@WS ? super WebService> att;
}

------------------------------------------------------------
OCL File:
---------
class CC {
   attribute att : C<WebService>;
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Word
{ String text = ""; 
  String pos = "NN"; 
  String streamOp3()
  {
    ArrayList<Word> words = new ArrayList<Word>();
    Word w1 = new Word();
    w1.text = "aa";
    Word w2 = new Word();
    w2.text = "bb";
    Word w3 = new Word();
    w3.text = "cc";
    Word w4 = new Word();
    w4.text = "aa";
    w4.pos = "VB";
    words.add(w1);
    words.add(w2);
    words.add(w3);
    words.add(w4);
    Stream<String> strm = words.stream().map(w -> w.text).distinct();
    long x = strm.count();
    System.out.println(x);
    boolean total = words.stream().allMatch(s -> s.pos.equals("NN"));
    return total + "";
  }
}

------------------------------------------------------------
OCL File:
---------
class Word {
   attribute text : String := "";
   attribute pos : String := "NN";
   operation streamOp3() : String
  pre: true
  post: true
  activity: (     var words : Sequence(Word) ; words := Sequence{} ;
     var w1 : Word ; w1 := Word.newWord() ;
    w1.text := "aa" ; 
    var w2 : Word ; w2 := Word.newWord() ;
    w2.text := "bb" ; 
    var w3 : Word ; w3 := Word.newWord() ;
    w3.text := "cc" ; 
    var w4 : Word ; w4 := Word.newWord() ;
    w4.text := "aa" ; 
    w4.pos := "VB" ; 
    words := words->including(w1) ; 
    words := words->including(w2) ; 
    words := words->including(w3) ; 
    words := words->including(w4) ; 
    var strm : Stream<String> ; strm := words->collect( _x1 | (lambda w : OclAny in w.text)->apply(_x1) )->asOrderedSet() ;
    var x : long ; x := strm->size() ;
    OclFile["System.out"].println(x) ; 
    var total : boolean ; total := words->forAll( _x2 | (lambda s : OclAny in s.pos = "NN")->apply(_x2) ) ;
    return total + "" 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class StringBufferManipulator {
    public int manipulateStringBuffer() {
       StringBuffer b = new StringBuffer(); 
       b = new StringBuffer("a long string"); 
       b = new StringBuffer(100); 
       b.append(0.5); 
       b.append('c'); 
       b.append("text"); 
       char[] cc = {'a', 'b', 'c'}; 
       b.append(cc); 
       char x = b.charAt(0); 
       b.delete(0,5); 
       b.deleteCharAt(0); 
       b.ensureCapacity(200); 
       return b.indexOf('a',10); 
    }
}

------------------------------------------------------------
OCL File:
---------
class StringBufferManipulator {
   operation manipulateStringBuffer() : int
  pre: true
  post: true
  activity: (     var b : String ; b := StringLib.newString() ;
     b := StringLib.newString("a long string") ; 
    b := StringLib.newString(100) ; 
    b := b + StringLib.newString(0.5) ; 
    b := b + StringLib.newString('c') ; 
    b := b + StringLib.newString("text") ; 
    var cc : Sequence(String) ; cc := Sequence{'a','b','c'} ;
    b := b + StringLib.newString(cc) ; 
    var x : String ; x := b->at(0+1) ;
    b := b->antirestrict( Integer.subrange(0+1,5) ) ; 
    b := b->excludingAt(0+1) ; 
    b.ensureCapacity(200) ; 
    return b.subrange(10+1)->indexOf('a'+"") + 10 - 1  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class StringBufferExample {
    public String manipulateStringBuffer() {
        StringBuffer bf = new StringBuffer("a long string"); 
        StringBuffer b1 = bf.insert(5,true); 
        bf.insert(5,100); 
        bf.reverse(); 
        bf.setCharAt(0,'x'); 
        CharSequence cs = bf.subSequence(0,4); 
        return bf.substring(5); 
    }
}

------------------------------------------------------------
OCL File:
---------
class StringBufferExample {
   operation manipulateStringBuffer() : String
  pre: true
  post: true
  activity: (     var bf : String ; bf := StringLib.newString("a long string") ;
     var b1 : String ; b1 := bf.insertAt(5+1, StringLib.newString(true)) ;
    bf := bf.insertAt(5+1, StringLib.newString(100)) ; 
    bf := bf->reverse() ; 
    bf := bf.setAt(0+1, 'x') ; 
    var cs : String ; cs := bf.subrange(0+1,4) ;
    return bf.subrange(5+1,5) 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class StringBuilderExample 
{
    public int op() 
    { StringBuilder b = new StringBuilder(); 
      b = new StringBuilder("a long string"); 
      b = new StringBuilder(100); 
      b.append(0.5); 
      b.append('c'); 
      b.append("text"); 
      char[] cc = {'a', 'b', 'c'}; 
      b.append(cc); 
      char x = b.charAt(0); 
      b.delete(0,5); 
      b.deleteCharAt(0); 
      b.ensureCapacity(200); 
      return b.indexOf('a',10); 
    }
}

------------------------------------------------------------
OCL File:
---------
class StringBuilderExample {
   operation op() : int
  pre: true
  post: true
  activity: (     var b : String ; b := StringLib.newString() ;
     b := StringLib.newString("a long string") ; 
    b := StringLib.newString(100) ; 
    b := b + StringLib.newString(0.5) ; 
    b := b + StringLib.newString('c') ; 
    b := b + StringLib.newString("text") ; 
    var cc : Sequence(String) ; cc := Sequence{'a','b','c'} ;
    b := b + StringLib.newString(cc) ; 
    var x : String ; x := b->at(0+1) ;
    b := b->antirestrict( Integer.subrange(0+1,5) ) ; 
    b := b->excludingAt(0+1) ; 
    b.ensureCapacity(200) ; 
    return b.subrange(10+1)->indexOf('a'+"") + 10 - 1  
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Person
{ String name = "";
  int age = 0;
  public Person(String nme) 
  { name = nme; }
}
class Student extends Person
{ String studying = "";
  public Student(String nme, String course)
  { super(nme); 
    studying = course; 
  }
}

------------------------------------------------------------
OCL File:
---------
class Person {
   attribute name : String := "";
   attribute age : int := 0;
   static operation newPerson( nme : String) : Person
  pre: true
  post: true
  activity:
  ( var self : Person ;
    self := createPerson();
    self.initialise(nme);
    return self );
  operation initialise( nme : String) : void
  pre: true  post: true
  activity: (     name := nme );
}
 class Student extends Person {
   attribute studying : String := "";
   static operation newStudent( nme : String, course : String) : Student
  pre: true
  post: true
  activity:
  ( var self : Student ;
    self := createStudent();
    self.initialise(nme, course);
    return self );
  operation initialise( nme : String, course : String) : void
  pre: true  post: true
  activity: (     execute super(nme) ; 
     studying := course );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ArrayProcessor {
    public int processValues()  { 
      int[] values = {99, 95, 78, 72, 76, 72, 70, 66, 61, 60, 55, 50, 48, 40, 36, 30, 22, 10}; 
      int evens = 0; 
      int odds = 0; 
      int leap = 0;
      int total = 0;  
      for (int i = 0; i < values.length; i++) 
      { switch (values[i] % 4)
        { case 0: 
            leap++; 
          case 2:
            evens++; 
            total++; 
            break;  
          default: 
            odds++;
            total++; 
        } 
      } 
      return total; 
  } 
}

------------------------------------------------------------
OCL File:
---------
class ArrayProcessor {
   operation processValues() : int
  pre: true
  post: true
  activity: (     var values : Sequence(int) ; values := Sequence{99,95,78,72,76,72,70,66,61,60,55,50,48,40,36,30,22,10} ;
     var evens : int ; evens := 0 ;
    var odds : int ; odds := 0 ;
    var leap : int ; leap := 0 ;
    var total : int ; total := 0 ;
        var i : int ; i := 0 ; while i < values->size() do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (values[i+1] mod 4) ; 
       if _switchval = 0 then
     leap := leap + 1 ; 
   else skip ;
       if _switchval = 2 then
     evens := evens + 1 ; 
    total := total + 1 ; 
    break 
   else skip ;
       if true then
     odds := odds + 1 ; 
    total := total + 1 ; 
   else skip ;
 )
 )  ;     i := i + 1 ) ; 
    return total 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class MyClass {
    void systemOp() {
        System.out.println(System.currentTimeMillis());
        System.out.println(System.getProperty("os.name"));
        System.exit(1);
    }
}

------------------------------------------------------------
OCL File:
---------
class MyClass {
   operation systemOp() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(OclDate.getSystemTime()) ; 
     OclFile["System.out"].println(OclProcess.getEnvironmentProperty("os.name")) ; 
 OclProcess.exit(1) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class BMICalc
{ public static void main(String[] args) throws IOException { BufferedReader
 br = new BufferedReader(new InputStreamReader(System.in));
 double weight = Double.parseDouble(br.readLine());
 double height = Double.parseDouble(br.readLine());
 double bmi = weight/(height*height);
 System.out.println(bmi); } }
------------------------------------------------------------
OCL File:
---------
class BMICalc {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(OclFile["System.in"])) ;
     var weight : double ; weight := (br.readLine())->toReal() ;
    var height : double ; height := (br.readLine())->toReal() ;
    var bmi : double ; bmi := weight / (height * height) ;
    OclFile["System.out"].println(bmi) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class RunTest implements Runnable
{ private String inst;
  public RunTest(String nme)
  { inst = nme; }
  public void run()
  { for (int i = 0; i < 20; i++)
    { System.out.println(">> step " + i + " of " + inst); }
  }
}
public class Main
{ public static void main(String[] args)
  {  RunTest r1 = new RunTest("1");
    Thread t1 = new Thread(r1, "thread1");
    System.out.println(Thread.activeCount());
    System.out.println(Thread.currentThread());
    Thread.sleep(2000);
    System.out.println(t1.getName());
    System.out.println(t1.isAlive());
    System.out.println(t1.isDaemon());
    t1.destroy();
  }
}

------------------------------------------------------------
OCL File:
---------
class RunTest implements Runnable {
   attribute inst : String;
   static operation newRunTest( nme : String) : RunTest
  pre: true
  post: true
  activity:
  ( var self : RunTest ;
    self := createRunTest();
    self.initialise(nme);
    return self );
  operation initialise( nme : String) : void
  pre: true  post: true
  activity: (     inst := nme );
   operation run() : void
  pre: true
  post: true
  activity: (         var i : int ; i := 0 ; while i < 20 do ( (     OclFile["System.out"].println(">> step " + i + " of " + inst) )  ;     i := i + 1 ) );
}
 class Main {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var r1 : RunTest ; r1 := RunTest.newRunTest("1") ;
     var t1 : OclProcess ; t1 := OclProcess.newOclProcess(r1, "thread1") ;
    OclFile["System.out"].println(OclProcess.activeCount()) ; 
    OclFile["System.out"].println(OclProcess.currentThread()) ; 
    OclProcess.sleep(2000) ; 
    OclFile["System.out"].println(t1.getName()) ; 
    OclFile["System.out"].println(t1.isAlive()) ; 
    OclFile["System.out"].println(t1.isDaemon()) ; 
    t1.destroy() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class R extends TimerTask
{ public void run()
  { System.out.println("Run at " + System.currentTimeMillis()); }
}
class TimerTest
{ public void timerop()
  { R tsk = new R();
    Timer tt = new Timer();
    tt.schedule(tsk, 1000L);
    tt.scheduleAtFixedRate(tsk, 500L, 1000L);
    Thread thrd = new Thread(tsk);
    thrd.start();
  }
}

------------------------------------------------------------
OCL File:
---------
class R extends OclProcess {
   operation run() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Run at " + OclDate.getSystemTime()) );
}
 class TimerTest {
   operation timerop() : void
  pre: true
  post: true
  activity: (     var tsk : R ; tsk := R.newR() ;
     var tt : OclProcess ; tt := OclProcess.newOclProcess("","TimerTask") ;
    tt.schedule(tsk, 1000L) ; 
    tt.scheduleAtFixedRate(tsk, 500L, 1000L) ; 
    var thrd : OclProcess ; thrd := OclProcess.newOclProcess(tsk) ;
    thrd.start() ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.SortedMap;
import java.util.TreeMap;
public class MyClass {
 public int sortedMapOp() 
 { SortedMap tm = new TreeMap(); 
   tm.put("1", "aa"); 
   tm.put("3", "cc"); 
   tm.put("2", "bb"); 
   String fk = (String) tm.firstKey(); 
   fk = (String) tm.lastKey(); 
   SortedMap sm = tm.headMap("3"); 
   sm = tm.subMap("1", "3"); 
   return sm.size();
 }
}

------------------------------------------------------------
OCL File:
---------
 class MyClass {
   operation sortedMapOp() : int
  pre: true
  post: true
  activity: (     var tm : Map ; tm := Map{} ;
     tm := tm->union(Map{"1" |-> "aa"}) ; 
    tm := tm->union(Map{"3" |-> "cc"}) ; 
    tm := tm->union(Map{"2" |-> "bb"}) ; 
    var fk : String ; fk := tm->keys()->min()->oclAsType(String) ;
    fk := tm->keys()->max()->oclAsType(String) ; 
    var sm : Map ; sm := tm->restrict( _key | _key < "3" ) ;
    sm := tm->restrict( _key | _key < "3" & _key >= "1" ) ; 
    return sm.size() 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector;
import java.util.Enumeration;
public class MyClass {
public int vectorOp() 
{ Vector vv = new Vector(10,50); 
  vv.addElement("aa"); 
  vv.addElement("bb"); 
  vv.addElement("cc"); 
  Vector ww = (Vector) vv.clone(); 
  boolean t = vv.containsAll(ww); 
  t = vv.contains("cc"); 
  String p = (String) vv.elementAt(1); 
  Enumeration en = vv.elements(); 
  p = (String) vv.firstElement(); 
  t = vv.removeAll(ww); 
  return vv.indexOf("aa"); 
}
}

------------------------------------------------------------
OCL File:
---------
 class MyClass {
   operation vectorOp() : int
  pre: true
  post: true
  activity: (     var vv : Sequence ; vv := Sequence{} ;
     vv := vv->append("aa") ; 
    vv := vv->append("bb") ; 
    vv := vv->append("cc") ; 
    var ww : Sequence ; ww := vv->copy()->oclAsType(Sequence) ;
    var t : boolean ; t := vv->includesAll(ww) ;
    t := vv->includes("cc") ; 
    var p : String ; p := vv->at(1+1)->oclAsType(String) ;
    var en : OclIterator ; en := vv->iterator() ;
    p := vv->first()->oclAsType(String) ; 
    t := vv->intersection(ww)->notEmpty() ;     vv := vv - ww ; 
    return vv->indexOf("aa")-1 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ExceptionExample {
    public void demonstrateExceptions() {
      ArithmeticException ax = new ArithmeticException("mess"); 
      ax = new ArithmeticException(); 
      Exception ex = new ArrayIndexOutOfBoundsException(2); 
      throw ax; 
      ArrayStoreException ase = new ArrayStoreException("mesg"); 
      ase = new ArrayStoreException(); 
      throw new ArrayIndexOutOfBoundsException();
    }
}

------------------------------------------------------------
OCL File:
---------
class ExceptionExample {
   operation demonstrateExceptions() : void
  pre: true
  post: true
  activity: (     var ax : ArithmeticException ; ax := ArithmeticException("mess") ;
     ax := ArithmeticException() ; 
    var ex : ProgramException ; ex := IndexingException(2) ;
    error ax ; 
    var ase : IndexingException ; ase := IndexingException("mesg") ;
    ase := IndexingException() ; 
    error IndexingException() ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Student 
{ private String name;  
  public Student(String nme) 
  { name = nme; } 
} 
class Module 
{ Vector students = new Vector(); 
  public void addStudent(String x) 
  { Student sx = new Student(x); 
    students.add(sx); } 
}

------------------------------------------------------------
OCL File:
---------
class Student {
   attribute name : String;
   static operation newStudent( nme : String) : Student
  pre: true
  post: true
  activity:
  ( var self : Student ;
    self := createStudent();
    self.initialise(nme);
    return self );
  operation initialise( nme : String) : void
  pre: true  post: true
  activity: (     name := nme );
}
 class Module {
   attribute students : Sequence := Sequence{};
   operation addStudent( x : String) : void
  pre: true
  post: true
  activity: (     var sx : Student ; sx := Student.newStudent(x) ;
     students := students->including(sx) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class C 
{ int x = 5, y = 10; } 
------------------------------------------------------------
OCL File:
---------
class C {
   attribute x : int := 5;
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class PrimeChecker {
    public boolean checkPrimes() {
        {
            boolean[] primes = new boolean[100]; 
            Arrays.fill(primes, true); 
            for (int i = 2; i < 11; i++) { 
                for (int p = 2; p * i < 100; p++) { 
                    primes[p * i] = false; 
                } 
            } 
            try { 
                return primes[91]; 
            } catch (IllegalAccessException ex) { 
                return false; 
            } 
        }
    }
}

------------------------------------------------------------
OCL File:
---------
class PrimeChecker {
   operation checkPrimes() : boolean
  pre: true
  post: true
  activity: ( (     var primes : Sequence(boolean) ; primes := Integer.subrange(1,100)->collect(false) ;
     primes := primes->collect(true) ; 
         var i : int ; i := 2 ; while i < 11 do ( (         var p : int ; p := 2 ; while p * i < 100 do ( (     primes[p * i+1] := false )  ;     p := p + 1 ) )  ;     i := i + 1 ) ; 
     try (     return primes[91+1] )   catch (ex : AccessingException) do (     return false )
 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ArrayMath {
    public static double sumSqDiffs(double[] v, double[] w) {
        double res = 0.0; 
        for (int i = 0; i < v.length && i < w.length; i++) { 
            double diff = v[i] - w[i]; 
            res = res + diff * diff; 
        }
        return Math.sqrt(res); 
    }
}

------------------------------------------------------------
OCL File:
---------
class ArrayMath {
  static   operation sumSqDiffs( v : Sequence(double), w : Sequence(double)) : double
  pre: true
  post: true
  activity: (     var res : double ; res := 0.0 ;
         var i : int ; i := 0 ; while i < v->size() & i < w->size() do ( (     var diff : double ; diff := v[i+1] - w[i+1] ;
     res := res + diff * diff )  ;     i := i + 1 ) ; 
     return (res)->sqrt() );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class StudentGrades
{ int agrades = 0; 
  int bgrades = 0; 
  int cgrades = 0; 
  int dgrades = 0; 
  int fails = 0; 
  StudentGrades() { } 
  public void countGrades()
  { int[] grades = {99, 95, 88, 82, 76, 72, 70, 66, 61, 60, 55, 50, 48, 40, 36, 30, 22, 10}; 
    for (int i = 0; i < grades.length; i++) 
    { switch (grades[i]/10)
      { case 10: 
        case 9: 
        case 8: 
        case 7: 
             agrades++; 
             break; 
        case 6: 
             bgrades++;
             break; 
        case 5: 
             cgrades++;
             break;  
        case 4: 
             dgrades++;
             break;  
        default: 
             fails++;
      } 
    } 
  } 
} 
------------------------------------------------------------
OCL File:
---------
class StudentGrades {
   attribute agrades : int := 0;
   attribute bgrades : int := 0;
   attribute cgrades : int := 0;
   attribute dgrades : int := 0;
   attribute fails : int := 0;
   static operation newStudentGrades() : StudentGrades
  pre: true
  post: true
  activity:
  ( var self : StudentGrades ;
    self := createStudentGrades();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
   operation countGrades() : void
  pre: true
  post: true
  activity: (     var grades : Sequence(int) ; grades := Sequence{99,95,88,82,76,72,70,66,61,60,55,50,48,40,36,30,22,10} ;
         var i : int ; i := 0 ; while i < grades->size() do ( ( 
    for _x : Integer.subrange(1,1) do
      ( var _switchval : OclAny ;
        _switchval := (grades[i+1] / 10) ; 
    if _switchval = 10 or _switchval = 9 or _switchval = 8 or _switchval = 7 then
    agrades := agrades + 1 ; 
    break 
   else skip ;
       if _switchval = 6 then
     bgrades := bgrades + 1 ; 
    break 
   else skip ;
       if _switchval = 5 then
     cgrades := cgrades + 1 ; 
    break 
   else skip ;
       if _switchval = 4 then
     dgrades := dgrades + 1 ; 
    break 
   else skip ;
       if true then
     fails := fails + 1 ; 
   else skip ;
 )
 )  ;     i := i + 1 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ssss {
 public static boolean mm() {
  ArrayList sq = new ArrayList(); 
  sq = new ArrayList(10); 
  sq.add("aa"); 
  sq.add("bb"); 
  sq.add(0,"cc"); 
  ArrayList sq1 = (ArrayList) sq.clone(); 
  sq.addAll(2,sq1); 
  String ss = (String) sq.get(5); 
  return sq.contains("bb");    
  }
}

------------------------------------------------------------
OCL File:
---------
class ssss {
  static   operation mm() : boolean
  pre: true
  post: true
  activity: (     var sq : Sequence ; sq := Sequence{} ;
     sq := Sequence{} ; 
    sq := sq->including("aa") ; 
    sq := sq->including("bb") ; 
    sq := sq.insertAt(0+1,"cc") ; 
    var sq1 : Sequence ; sq1 := sq->copy()->oclAsType(Sequence) ;
    sq := sq.insertInto(2+1,sq1) ; 
    var ss : String ; ss := sq->at(5+1)->oclAsType(String) ;
    return sq->includes("bb") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class aaa {
 public static boolean oiu() { 
  HashSet st = new HashSet(); 
  st.add("aa"); 
  st.add("bb"); 
  ArrayList sq = new ArrayList(st); 
  sq.addAll(st); 
  int i = sq.lastIndexOf("bb"); 
  String s = (String) sq.remove(i); 
  sq.set(0,"xx"); 
  i = sq.size(); 
  sq.trimToSize(i-1); 
  return sq.isEmpty(); 
}
}

------------------------------------------------------------
OCL File:
---------
class aaa {
  static   operation oiu() : boolean
  pre: true
  post: true
  activity: (     var st : Set ; st := Set{} ;
     st := st->including("aa") ; 
    st := st->including("bb") ; 
    var sq : Sequence ; sq := Sequence{}->union(st) ;
    sq := sq->union(st) ; 
    var i : int ; i := sq->lastIndexOf("bb")-1 ;
    var s : String ; s := sq->at(i+1)->oclAsType(String) ;
    sq := sq.setAt(0+1,"xx") ; 
    i := sq->size() ; 
    sq := sq.trimToSize(i - 1) ; 
    return sq->isEmpty() 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class hhhh {
    public static boolean performArrayOperations() {
       String[] strs = {"aa", "bb", "cc", "dd", "ee"}; 
  List lst = Arrays.asList(strs); 
  int i = Arrays.binarySearch(strs,"dd"); 
  byte[] barr = {97, 98, 99, 100}; 
  Arrays.fill(barr, 102); 
  Arrays.sort(strs); 
  Arrays.sort(strs,0,3); 
  return Arrays.equals(new String[5], strs);
    }
}

------------------------------------------------------------
OCL File:
---------
class hhhh {
  static   operation performArrayOperations() : boolean
  pre: true
  post: true
  activity: (     var strs : Sequence(String) ; strs := Sequence{"aa","bb","cc","dd","ee"} ;
     var lst : Sequence ; lst := strs ;
    var i : int ; i := (strs->indexOf("dd") - 1) ;
    var barr : Sequence(int) ; barr := Sequence{97,98,99,100} ;
    barr := barr->collect(102) ; 
    strs := strs->sort() ; 
    strs := strs.subrange(1,0)^(strs.subrange(0+1,3)->sort())^strs.subrange(3+1,strs.size) ; 
    return Integer.subrange(1,5)->collect(null) = strs 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigDecimal;
import java.math.BigInteger;
public class BigDecimalOperations {
    public BigInteger bigDecimalOp() {
        BigDecimal dd = new BigDecimal(999999.99);
        dd = new BigDecimal("99999999999.99");
        BigDecimal da = dd.abs();
        dd = dd.add(da);
        double dv = dd.doubleValue();
        dd = dd.min(da);
        dd = da.negate();
        return dd.toBigInteger();
    }
}

------------------------------------------------------------
OCL File:
---------
 class BigDecimalOperations {
   operation bigDecimalOp() : long
  pre: true
  post: true
  activity: (     var dd : double ; dd := double(999999.99) ;
     dd := double("99999999999.99") ; 
    var da : double ; da := dd.abs() ;
    dd := dd->excludes(da) ; 
    var dv : double ; dv := dd->oclAsType(double) ;
    dd := dd->min() ; 
    dd := da.negate() ; 
    return dd.toBigInteger() 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.math.BigInteger;
public class BigIntegerOperations {
    public void bigIntegerOp() {
        BigInteger bb = new BigInteger("10000000");
        BigInteger bx = BigInteger.valueOf(99999999);
        BigInteger x = bb.add(bx);
        x = bb.divide(BigInteger.ONE);
        double d = bb.doubleValue();
        x = bb.gcd(bx);
        x = bb.pow(5);
        x = bb.subtract(bx);
    }
}

------------------------------------------------------------
OCL File:
---------
 class BigIntegerOperations {
   operation bigIntegerOp() : void
  pre: true
  post: true
  activity: (     var bb : long ; bb := long("10000000") ;
     var bx : long ; bx := (99999999 + "")->toLong() ;
    var x : long ; x := bb->excludes(bx) ;
    x := bb.divide(1) ; 
    var d : double ; d := bb->oclAsType(double) ;
    x := bb.gcd(bx) ; 
    x := bb.pow(5) ; 
    x := bb.subtract(bx) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class WTest {
    public boolean op() {
        AssertionError er = new AssertionError();
        er = new AssertionError(0.0);
        er = new AssertionError(10000000L);
        Boolean b = Boolean.FALSE;
        b = new Boolean("true");
        b = new Boolean(true);
        boolean x = b.booleanValue();
        return x == false;
    }
}

------------------------------------------------------------
OCL File:
---------
class WTest {
   operation op() : boolean
  pre: true
  post: true
  activity: (     var er : AssertionException ; er := AssertionException() ;
     er := AssertionException(0.0) ; 
    er := AssertionException(10000000L) ; 
    var b : Boolean ; b := false ;
    b := ("" + ("true"))->toBoolean() ; 
    b := ("" + (true))->toBoolean() ; 
    var x : boolean ; x := b ;
    return x = false 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class BitwiseOperations {
    public void bitwiseOp() {
        int x = 14;
        int y = 9;
        int z = (x & y);
        z = (x | y);
        z = x >> 1;
        z = y << 1;
    }
}

------------------------------------------------------------
OCL File:
---------
class BitwiseOperations {
   operation bitwiseOp() : void
  pre: true
  post: true
  activity: (     var x : int ; x := 14 ;
     var y : int ; y := 9 ;
    var z : int ; z := (MathLib.bitwiseAnd(x,y)) ;
    z := (MathLib.bitwiseOr(x,y)) ; 
    z := (x/(2->pow(1)))->oclAsType(long) ; 
    z := (y*(2->pow(1)))->oclAsType(long) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.BitSet;
public class BitSetOperations {
    public void bitSetOp() {
      BitSet bs = new BitSet(4);
      bs.set(0);
      bs.set(2);
      bs.flip(1);
      int i = bs.cardinality();
      i = bs.size();
      i = bs.length();
      bs.flip(0,2);
      BitSet bs1 = new BitSet();
      i = bs1.size();
      bs1.set(0,3);
      bs.or(bs1);
    }
}

------------------------------------------------------------
OCL File:
---------
 class BitSetOperations {
   operation bitSetOp() : void
  pre: true
  post: true
  activity: (     var bs : Sequence(boolean) ; bs := MathLib.toBitSequence(4) ;
     bs := bs.setAt(0+1, true) ; 
    bs := bs.setAt(2+1, true) ; 
    bs := bs.flip(1) ; 
    var i : int ; i := bs.cardinality() ;
    i := bs->size() ; 
    i := bs->size() ; 
    bs := bs.flip(0, 2) ; 
    var bs1 : Sequence(boolean) ; bs1 := MathLib.toBitSequence() ;
    i := bs1->size() ; 
    bs1 := bs1.setAt(0+1,3) ; 
    bs := bs.or(bs1) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector;
import java.util.List; 
class Bond
{
  private String name = ""; 
  private double term = 0; 
  private double coupon = 0; 
  private double price = 0; 
  private int frequency = 0; 
  private double irr = 0; 
  private double duration = 0; 
  public Bond()
  {
    this.name = "";
    this.term = 0.0;
    this.coupon = 0.0;
    this.price = 0.0;
    this.frequency = 0;
    this.irr = 0.0;
    this.duration = 0.0;
  }
  public double discount(double amount,double r,double time)
  { double result = 0;
    if (r <= -1 || time < 0) { return result; } 
    result = amount / Math.pow(( 1 + r ),time);
    return result;
  }
  public double value(double r)
  { double result = 0.0;
    if (r <= -1) { return result; } 
    final int upper = (int) Math.floor(term * frequency); 
    final double c = coupon / frequency; 
    final double period = 1.0 / frequency;
    for (int i = 1; i <= upper; i++) 
    { result = result + this.discount(c,r,i * period); } 
    result = result + this.discount(100,r,term);
    return result;
  }
   public double timeDiscount(double amount,double r,double time)
  { double result = 0.0;
    if (r <= -1 || time < 0) { return result; } 
    result = ( amount * time ) / Math.pow(( 1 + r ),time);
    return result;
  }
  public double macaulayDuration(double r)
  { double result = 0;
    if (r <= -1) { return result; } 
    final int upper = (int) Math.floor(term * frequency); 
    final double c = coupon / frequency; 
    final double period = 1.0 / frequency; 
    for (int i = 1; i <= upper; i++) 
    { result = result + this.timeDiscount(c,r,i * period); } 
    result = result + this.timeDiscount(100,r,term); 
    result = result / this.value(r);
    return result;
  }
  public double bisection(double r,double rl,double ru)
  { double result = 0;
    if (r <= -1 || rl <= -1 || ru <= -1) { return result; } 
    final double v = this.value(r); 
    result = ((ru - rl < 0.001) ? (r) : (((v > price) ? (this.bisection(( ru + r ) / 2,r,ru)) : (this.bisection(( r + rl ) / 2,rl,r)))));
    return result;
  }
}  
------------------------------------------------------------
OCL File:
---------
 class Bond {
   attribute name : String := "";
   attribute term : double := 0;
   attribute coupon : double := 0;
   attribute price : double := 0;
   attribute frequency : int := 0;
   attribute irr : double := 0;
   attribute duration : double := 0;
   static operation newBond() : Bond
  pre: true
  post: true
  activity:
  ( var self : Bond ;
    self := createBond();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.name := "" ; 
     self.term := 0.0 ; 
    self.coupon := 0.0 ; 
    self.price := 0.0 ; 
    self.frequency := 0 ; 
    self.irr := 0.0 ; 
    self.duration := 0.0 ; 
 );
   operation discount( amount : double, r : double, time : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
     if (r <= -1 or time < 0) then (     return result ) else skip ; 
     result := amount / (1 + r)->pow(time) ; 
     return result );
   operation value( r : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0.0 ;
     if (r <= -1) then (     return result ) else skip ; 
    var upper : int ; upper := (term * frequency)->floor()->oclAsType(int) ;
    var c : double ; c := coupon / frequency ;
    var period : double ; period := 1.0 / frequency ;
        var i : int ; i := 1 ; while i <= upper do ( (     result := result + self.discount(c, r, i * period) )  ;     i := i + 1 ) ; 
    result := result + self.discount(100, r, term) ; 
    return result 
 );
   operation timeDiscount( amount : double, r : double, time : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0.0 ;
     if (r <= -1 or time < 0) then (     return result ) else skip ; 
     result := (amount * time) / (1 + r)->pow(time) ; 
     return result );
   operation macaulayDuration( r : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
     if (r <= -1) then (     return result ) else skip ; 
    var upper : int ; upper := (term * frequency)->floor()->oclAsType(int) ;
    var c : double ; c := coupon / frequency ;
    var period : double ; period := 1.0 / frequency ;
        var i : int ; i := 1 ; while i <= upper do ( (     result := result + self.timeDiscount(c, r, i * period) )  ;     i := i + 1 ) ; 
    result := result + self.timeDiscount(100, r, term) ; 
    result := result / self.value(r) ; 
    return result 
 );
   operation bisection( r : double, rl : double, ru : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
     if (r <= -1 or rl <= -1 or ru <= -1) then (     return result ) else skip ; 
    var v : double ; v := self.value(r) ;
    result := (if (ru - rl < 0.001) then (r) else ((if (v > price) then (self.bisection((ru + r) / 2, r, ru)) else (self.bisection((r + rl) / 2, rl, r)) endif)) endif) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class FTest {
 public static String op() 
 { File f = new File("f.txt"); 
  BufferedReader br = new BufferedReader(new FileReader(f)); 
  if (br.ready()) 
  { String s = br.readLine(); 
    br.close(); 
    return s; 
  } 
 }
}
------------------------------------------------------------
OCL File:
---------
class FTest {
  static   operation op() : String
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile("f.txt") ;
     var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(f)) ;
     if (br.canRead()) then (     var s : String ; s := br.readLine() ;
     skip ; 
     return s ) else skip );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class BWTest {
  void op() 
  { try {
    BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
    bw.write("a long string", 0, 10);
    bw.newLine();
    bw.newLine();
    char[] chrs = {'x', 'y', 'z'};
    bw.write(chrs, 0, 3);
    bw.flush();
    bw.close();
  } catch (Exception _e)
    { _e.printStackTrace(); } 
}
}

------------------------------------------------------------
OCL File:
---------
class BWTest {
   operation op() : void
  pre: true
  post: true
  activity: (     try (     var bw : OclFile ; bw := OclFile.newOclFile_Write(OclFile.newOclFile_Write(OclFile.newOclFile("out.txt"))) ;
     skip ; 
    skip ; 
    skip ; 
    var chrs : Sequence(String) ; chrs := Sequence{'x','y','z'} ;
    skip ; 
    skip ; 
    skip ; 
 )   catch (_e : ProgramException) do (     _e.printStackTrace() )
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class hhhh {
    public int sss() {
        Byte b = new Byte(97); 
        b = new Byte("0xF"); 
        byte x = b.byteValue(); 
        x = Byte.decode("077"); 
        x = Byte.parseByte("055",8); 
        return b.compareTo(new Byte("0"));
    }
}

------------------------------------------------------------
OCL File:
---------
class hhhh {
   operation sss() : int
  pre: true
  post: true
  activity: (     var b : int ; b := ("" + (97))->toInteger() ;
     b := ("" + ("0xF"))->toInteger() ; 
    var x : int ; x := b->oclAsType(int) ;
    x := ("077")->toInteger() ; 
    x := ("055")->toInteger() ; 
    return b->compareTo(("" + ("0"))->toInteger()) 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class CTest
{ long caltest()
  { Calendar c = new GregorianCalendar();
    long res = c.computeTime();
    res = c.getTimeInMillis();
    c.setTimeInMillis(30000000);
    Calendar d = new GregorianCalendar();
    boolean b = d.after(c);
    return d.computeTime();
  }
}

------------------------------------------------------------
OCL File:
---------
class CTest {
   operation caltest() : long
  pre: true
  post: true
  activity: (     var c : OclDate ; c := OclDate.newOclDate() ;
     var res : long ; res := c.time ;
    res := c.time ; 
    c.setTimeInMillis(30000000) ; 
    var d : OclDate ; d := OclDate.newOclDate() ;
    var b : boolean ; b := d.dateAfter(c) ;
    return d.time 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector;
import java.util.List; 
class StatFunc
{
  public static int multiplyRange(int st, int en)
  { int res = 1; 
    for (int i = st; i <= en; i++)
    { res = res*i; } 
    return res; 
  } 
  public static int comb(int n,int m)
  { int result = 0;
    if (n < m || m < 0) 
    { return result; } 
    if (n - m < m) 
    { result = 
        StatFunc.multiplyRange(m + 1,n)/StatFunc.multiplyRange(1,n - m); 
    }
    else if (n - m >= m) 
    { result = 
        StatFunc.multiplyRange(n - m + 1,n)/StatFunc.multiplyRange(1,m); 
    }
    return result;
  }
}
class Sector
{
  String name = "";
  int n = 0; 
  double p = 0; 
  double q = 0; 
  int L = 0; 
  double mu = 0; 
  List borrowers = new Vector(); 
  public Sector()
  {
    this.name = "";
    this.n = 0;
    this.p = 0.0;
    this.q = 0.0;
    this.L = 0;
    this.mu = 0.0;
  }
  public double nocontagion(int m)
  { double result = 0.0;
    double othersNotfailedProb = Math.pow(( 1 - p ),n - m); 
	double mFailedProb = Math.pow(p,m); 
	double noinfections = Math.pow(( 1 - q ),m * ( n - m ));
    result = othersNotfailedProb * mFailedProb * noinfections;
    return result;
  }
  public double contagion(int i,int m)
  { double result = 0;
    double othersNotfailedProb = Math.pow(( 1 - p ),n - i); 
	double iFailedProb = Math.pow(p,i); 
	double notInfectedProb = Math.pow(( 1 - q ),i * ( n - m )); 
	double infectionProb = Math.pow(( 1 - Math.pow(( 1 - q ),i) ),m - i);  
    result = othersNotfailedProb * iFailedProb * notInfectedProb * 
             infectionProb * 
             StatFunc.comb(m,i);
    return result;
  }
  public double borrowerLoss(int i)
  { double result = 0;
    BorrowerInSector bs = (BorrowerInSector) borrowers.get(i - 1);   
    result = bs.omega * bs.borrower.L;
    return result;
  }
}
class CDO
{
  private double ps0 = 0; 
  private List sectors = new Vector(); 
  public CDO()
  {
    this.ps0 = 0;
  }
  public double PCond(int k,int m)
  { double result = 0;
    if (m >= 1) 
    { Sector sk = (Sector) sectors.get(k - 1); 
	  result = 1.0 / 
       ( 1 - Math.pow(( 1 - sk.p ), sk.n) ); 
    }
    else if (m < 1) { result = 0; }
    return result;
  }
}
class Borrower
{
  String name = ""; 
  int L = 0;
  double p = 0.0; 
  public Borrower()
  {
    this.name = "";
    this.L = 0;
    this.p = 0.0;
  }
}
class BorrowerInSector
{
  double omega = 0.0; 
  double theta = 0.0; 
  Borrower borrower;
  public BorrowerInSector(Borrower borrower)
  {
    this.omega = 0.0;
    this.theta = 0.0;
    this.borrower = borrower;
  }
  public BorrowerInSector() { }
}

------------------------------------------------------------
OCL File:
---------
 class StatFunc {
  static   operation multiplyRange( st : int, en : int) : int
  pre: true
  post: true
  activity: (     var res : int ; res := 1 ;
         var i : int ; i := st ; while i <= en do ( (     res := res * i )  ;     i := i + 1 ) ; 
     return res );
  static   operation comb( n : int, m : int) : int
  pre: true
  post: true
  activity: (     var result : int ; result := 0 ;
     if (n < m or m < 0) then (     return result ) else skip ; 
     if (n - m < m) then (     result := StatFunc.multiplyRange(m + 1, n) / StatFunc.multiplyRange(1, n - m) ) else     if (n - m >= m) then (     result := StatFunc.multiplyRange(n - m + 1, n) / StatFunc.multiplyRange(1, m) ) else skip ; ;  
     return result );
}
class Sector {
   attribute name : String := "";
   attribute n : int := 0;
   attribute p : double := 0;
   attribute q : double := 0;
   attribute L : int := 0;
   attribute mu : double := 0;
   attribute borrowers : Sequence := Sequence{};
   static operation newSector() : Sector
  pre: true
  post: true
  activity:
  ( var self : Sector ;
    self := createSector();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.name := "" ; 
     self.n := 0 ; 
    self.p := 0.0 ; 
    self.q := 0.0 ; 
    self.L := 0 ; 
    self.mu := 0.0 ; 
 );
   operation nocontagion( m : int) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0.0 ;
     var othersNotfailedProb : double ; othersNotfailedProb := (1 - p)->pow(n - m) ;
    var mFailedProb : double ; mFailedProb := p->pow(m) ;
    var noinfections : double ; noinfections := (1 - q)->pow(m * (n - m)) ;
    result := othersNotfailedProb * mFailedProb * noinfections ; 
    return result 
 );
   operation contagion( i : int, m : int) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
     var othersNotfailedProb : double ; othersNotfailedProb := (1 - p)->pow(n - i) ;
    var iFailedProb : double ; iFailedProb := p->pow(i) ;
    var notInfectedProb : double ; notInfectedProb := (1 - q)->pow(i * (n - m)) ;
    var infectionProb : double ; infectionProb := (1 - (1 - q)->pow(i))->pow(m - i) ;
    result := othersNotfailedProb * iFailedProb * notInfectedProb * infectionProb * StatFunc.comb(m, i) ; 
    return result 
 );
   operation borrowerLoss( i : int) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
     var bs : BorrowerInSector ; bs := borrowers->at(i - 1+1)->oclAsType(BorrowerInSector) ;
     result := bs.omega * bs.borrower.L ; 
     return result );
}
class CDO {
   attribute ps0 : double := 0;
   attribute sectors : Sequence := Sequence{};
   static operation newCDO() : CDO
  pre: true
  post: true
  activity:
  ( var self : CDO ;
    self := createCDO();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.ps0 := 0 );
   operation PCond( k : int, m : int) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
     if (m >= 1) then (     var sk : Sector ; sk := sectors->at(k - 1+1)->oclAsType(Sector) ;
     result := 1.0 / (1 - (1 - sk.p)->pow(sk.n)) ) else     if (m < 1) then (     result := 0 ) else skip ; ;  
     return result );
}
class Borrower {
   attribute name : String := "";
   attribute L : int := 0;
   attribute p : double := 0.0;
   static operation newBorrower() : Borrower
  pre: true
  post: true
  activity:
  ( var self : Borrower ;
    self := createBorrower();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.name := "" ; 
     self.L := 0 ; 
     self.p := 0.0 );
}
class BorrowerInSector {
   attribute omega : double := 0.0;
   attribute theta : double := 0.0;
   attribute borrower : Borrower;
   static operation newBorrowerInSector( borrower : Borrower) : BorrowerInSector
  pre: true
  post: true
  activity:
  ( var self : BorrowerInSector ;
    self := createBorrowerInSector();
    self.initialise(borrower);
    return self );
  operation initialise( borrower : Borrower) : void
  pre: true  post: true
  activity: (     self.omega := 0.0 ; 
     self.theta := 0.0 ; 
     self.borrower := borrower );
   static operation newBorrowerInSector() : BorrowerInSector
  pre: true
  post: true
  activity:
  ( var self : BorrowerInSector ;
    self := createBorrowerInSector();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class CharOperations {
    public int op() {
        int res = (int) 'A';   
        res = 'z' - 'a';       
        res = '8' - 48;        
        return res;            
    }
}

------------------------------------------------------------
OCL File:
---------
class CharOperations {
   operation op() : int
  pre: true
  post: true
  activity: (     var res : int ; res := ('A')->char2byte() ;
     res := ('z')->char2byte() - ('a')->char2byte() ; 
     res := ('8')->char2byte() - 48 ; 
     return res );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.lang.reflect.Field;
public class Example {
    public void listFields() {
       Class x = Class.forName("String"); 
       Field[] fs = x.getFields(); 
       for (int i = 0; i < fs.length; i++)  
       { System.out.println(fs[i].getName()); } 
   }
}

------------------------------------------------------------
OCL File:
---------
 class Example {
   operation listFields() : void
  pre: true
  post: true
  activity: (     var x : OclType ; x := OclType["String"] ;
     var fs : Sequence(OclAttribute) ; fs := x.getFields() ;
         var i : int ; i := 0 ; while i < fs->size() do ( (     OclFile["System.out"].println(fs[i+1].getName()) )  ;     i := i + 1 ) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Operation {
    public int op() {
        int x = 10;
        x += 5;
        x -= 7;
        x *= 8;
        return ++x;
    }
}

------------------------------------------------------------
OCL File:
---------
class Operation {
   operation op() : int
  pre: true
  post: true
  activity: (     var x : int ; x := 10 ;
     x := x+(5) ; 
    x := x-(7) ; 
    x := x*(8) ; 
    return (x + 1) 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Collections;
import java.util.List;
import java.util.ArrayList;
public class CollectionsExample {
    public String collectionsOp() {
        List lst0 = Collections.EMPTY_LIST;
        lst0 = Collections.nCopies(5, "aa");
        int i = Collections.binarySearch(lst0, "bb");
        List lst1 = Collections.singletonList("bb");
        i = Collections.lastIndexOfSubList(lst0, lst1);
        Collections.replaceAll(lst0, "aa", "cc");
        Collections.reverse(lst0);
        return (String) Collections.max(lst0);
    }
}

------------------------------------------------------------
OCL File:
---------
 class CollectionsExample {
   operation collectionsOp() : String
  pre: true
  post: true
  activity: (     var lst0 : Sequence ; lst0 := Sequence{} ;
     lst0 := Integer.subrange(1,5)->collect("aa") ; 
    var i : int ; i := .binarySearch(lst0, "bb") ;
    var lst1 : Sequence ; lst1 := .singletonList("bb") ;
    i := (lst0->lastIndexOf(lst1)-1) ; 
    lst0 := lst0->collect( x1 | if x1 = "aa" then "cc" else x1 endif ) ; 
    lst0 := lst0->reverse() ; 
    return  lst0->max()->oclAsType(String) 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Vector;
public class CollectionExample {
    public void collectionOp() {
     Vector vv = new Vector(10,50); 
     ArrayList ww = new ArrayList(vv); 
     Hashtable mm = new Hashtable(5,0.5); 
     ww.add("aa"); 
     vv = new Vector(); 
     mm = new Hashtable(); 
     mm = new Hashtable(1000); 
     Hashtable nn = new Hashtable(mm); 
    }
}

------------------------------------------------------------
OCL File:
---------
 class CollectionExample {
   operation collectionOp() : void
  pre: true
  post: true
  activity: (     var vv : Sequence ; vv := Sequence{} ;
     var ww : Sequence ; ww := Sequence{}->union(vv) ;
    var mm : Map ; mm := Map{} ;
    ww := ww->including("aa") ; 
    vv := Sequence{} ; 
    mm := Map{} ; 
    mm := Map{} ; 
    var nn : Map ; nn := Map{}->union(mm) ;
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Word
{ String pos = "NN";
  String text = "";
  public static int streamOp()
  { Word w1 = new Word();
    w1.text = "Toast";
    Word w2 = new Word();
    w2.text = "travel";
    w2.pos = "VB";
    Word w3 = new Word();
    w3.text = "higher";
    w3.pos = "JJR";
    ArrayList<Word> words = new ArrayList<Word>();
    words.add(w1);
    words.add(w2);
    words.add(w3);
    int total = words.stream()
                      .filter(w -> w.pos.equals("NN"))
                      .mapToInt(w -> w.text.length())
                      .sum();
    return total;
  }
}

------------------------------------------------------------
OCL File:
---------
class Word {
   attribute pos : String := "NN";
   attribute text : String := "";
  static   operation streamOp() : int
  pre: true
  post: true
  activity: (     var w1 : Word ; w1 := Word.newWord() ;
     w1.text := "Toast" ; 
    var w2 : Word ; w2 := Word.newWord() ;
    w2.text := "travel" ; 
    w2.pos := "VB" ; 
    var w3 : Word ; w3 := Word.newWord() ;
    w3.text := "higher" ; 
    w3.pos := "JJR" ; 
    var words : Sequence(Word) ; words := Sequence{} ;
    words := words->including(w1) ; 
    words := words->including(w2) ; 
    words := words->including(w3) ; 
    var total : int ; total := words->select( _x1 | (lambda w : OclAny in w.pos = "NN")->apply(_x1) )->collect( _x1 | (lambda w : OclAny in w.text->size())->apply(_x1) )->sum() ;
    return total 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Comms
{ /* This class is a test of comments */
  public Comms() { }
  @Override
  public String toString() 
  { return ""; }
  /* another comment */
}

------------------------------------------------------------
OCL File:
---------
class Comms {
   static operation newComms() : Comms
  pre: true
  post: true
  activity:
  ( var self : Comms ;
    self := createComms();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: skip;
      operation toString() : String
  pre: true
  post: true
  activity: (     return "" );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ComparisonExample {
    public int op(Comparable cmp, Comparable c2) {
      if (cmp != null && c2 != null) 
      { return cmp.compareTo(c2); } 
      return 0; 
    }
}

------------------------------------------------------------
OCL File:
---------
class ComparisonExample {
   operation op( cmp : OclAny, c2 : OclAny) : int
  pre: true
  post: true
  activity: (     if (cmp /= null & c2 /= null) then (     return cmp->compareTo(c2) ) else skip ; 
     return 0 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Person { 
  String name = ""; 
  int age = 0;
  Person(String nme) 
  { name = nme; }
  public String getName() 
  { return name; }
  public int birthday() 
  { age++; 
    return age; 
  }
}

------------------------------------------------------------
OCL File:
---------
class Person {
   attribute name : String := "";
   attribute age : int := 0;
   static operation newPerson( nme : String) : Person
  pre: true
  post: true
  activity:
  ( var self : Person ;
    self := createPerson();
    self.initialise(nme);
    return self );
  operation initialise( nme : String) : void
  pre: true  post: true
  activity: (     name := nme );
   operation getName() : String
  pre: true
  post: true
  activity: (     return name );
   operation birthday() : int
  pre: true
  post: true
  activity: (     age := age + 1 ; 
     return age );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class T {
  private P<X>.R<Y> att;
}

------------------------------------------------------------
OCL File:
---------
class T {
   attribute att : R<Y>;
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.HashMap;
import java.util.Collection;
import java.util.List;
import java.util.ArrayList;
import java.util.Set;
import java.util.HashSet;
import java.util.TreeSet;
import java.util.Collections;
class DataPoint { 
  double x = 0.0;
  double y = 0.0;
  double prodxy = 0.0;
  double diffxsq = 0.0;
  double diffysq = 0.0;
  public static double sumx(ArrayList<DataPoint> dps)
  { double res = 0; 
    for (int i = 0; i < dps.size(); i++) 
    { res = res + dps.get(i).x; } 
    return res; 
  } 
  public static double sumy(ArrayList<DataPoint> dps)
  { double res = 0; 
    for (int i = 0; i < dps.size(); i++) 
    { res = res + dps.get(i).y; } 
    return res; 
  } 
  public static double sumprodxy(ArrayList<DataPoint> dps)
  { double res = 0; 
    for (int i = 0; i < dps.size(); i++) 
    { res = res + dps.get(i).prodxy; } 
    return res; 
  } 
  public static double sumdiffysq(ArrayList<DataPoint> dps)
  { double res = 0; 
    for (int i = 0; i < dps.size(); i++) 
    { res = res + dps.get(i).diffysq; } 
    return res; 
  } 
  public static double sumdiffxsq(ArrayList<DataPoint> dps)
  { double res = 0; 
    for (int i = 0; i < dps.size(); i++) 
    { res = res + dps.get(i).diffxsq; } 
    return res; 
  } 
}
public class CorrelationCalculator { 
  double meanx = 0.0;
  double meany = 0.0;
  double sumprods = 0.0;
  double sumdiffxsq = 0.0;
  double sumdiffysq = 0.0;
  double correlation = 0.0;
  ArrayList<DataPoint> datapoints = new ArrayList<DataPoint>();
  public void calc()
  { meanx = DataPoint.sumx(datapoints) / datapoints.size();
    meany = DataPoint.sumy(datapoints) / datapoints.size();
    for (DataPoint d : datapoints)
    {
      d.prodxy = (d.x - meanx) * (d.y - meany);
      d.diffxsq = (d.x - meanx) * (d.x - meanx);
      d.diffysq = (d.y - meany) * (d.y - meany);
    }
    sumprods = DataPoint.sumprodxy(datapoints);
    sumdiffxsq = DataPoint.sumdiffxsq(datapoints);
    sumdiffysq = DataPoint.sumdiffysq(datapoints); 
    if (sumdiffxsq > 0 && sumdiffysq > 0)
    {
      correlation = sumprods / Math.sqrt((sumdiffxsq * sumdiffysq));
    }
  }
public static void main(String[] args)
{ DataPoint p1 = new DataPoint();
  p1.x = 0.0; 
  p1.y = -1.0; 
  DataPoint p2 = new DataPoint();
  p2.x = 0.5; 
  p2.y = -1.5; 
  DataPoint p3 = new DataPoint();
  p3.x = 1.0; 
  p3.y = -2.0; 
  CorrelationCalculator cc = new CorrelationCalculator(); 
  cc.datapoints.add(p1); 
  cc.datapoints.add(p2); 
  cc.datapoints.add(p3);
  cc.calc(); 
  System.out.println(cc.correlation);  
}
} 
------------------------------------------------------------
OCL File:
---------
 class DataPoint {
   attribute x : double := 0.0;
   attribute y : double := 0.0;
   attribute prodxy : double := 0.0;
   attribute diffxsq : double := 0.0;
   attribute diffysq : double := 0.0;
  static   operation sumx( dps : Sequence(DataPoint)) : double
  pre: true
  post: true
  activity: (     var res : double ; res := 0 ;
         var i : int ; i := 0 ; while i < dps->size() do ( (     res := res + dps->at(i+1).x )  ;     i := i + 1 ) ; 
     return res );
  static   operation sumy( dps : Sequence(DataPoint)) : double
  pre: true
  post: true
  activity: (     var res : double ; res := 0 ;
         var i : int ; i := 0 ; while i < dps->size() do ( (     res := res + dps->at(i+1).y )  ;     i := i + 1 ) ; 
     return res );
  static   operation sumprodxy( dps : Sequence(DataPoint)) : double
  pre: true
  post: true
  activity: (     var res : double ; res := 0 ;
         var i : int ; i := 0 ; while i < dps->size() do ( (     res := res + dps->at(i+1).prodxy )  ;     i := i + 1 ) ; 
     return res );
  static   operation sumdiffysq( dps : Sequence(DataPoint)) : double
  pre: true
  post: true
  activity: (     var res : double ; res := 0 ;
         var i : int ; i := 0 ; while i < dps->size() do ( (     res := res + dps->at(i+1).diffysq )  ;     i := i + 1 ) ; 
     return res );
  static   operation sumdiffxsq( dps : Sequence(DataPoint)) : double
  pre: true
  post: true
  activity: (     var res : double ; res := 0 ;
         var i : int ; i := 0 ; while i < dps->size() do ( (     res := res + dps->at(i+1).diffxsq )  ;     i := i + 1 ) ; 
     return res );
}
class CorrelationCalculator {
   attribute meanx : double := 0.0;
   attribute meany : double := 0.0;
   attribute sumprods : double := 0.0;
   attribute sumdiffxsq : double := 0.0;
   attribute sumdiffysq : double := 0.0;
   attribute correlation : double := 0.0;
   attribute datapoints : Sequence(DataPoint) := Sequence{};
   operation calc() : void
  pre: true
  post: true
  activity: (     meanx := DataPoint.sumx(datapoints) / datapoints->size() ; 
     meany := DataPoint.sumy(datapoints) / datapoints->size() ; 
    for (d : datapoints) do ( (     d.prodxy := (d.x - meanx) * (d.y - meany) ; 
     d.diffxsq := (d.x - meanx) * (d.x - meanx) ; 
     d.diffysq := (d.y - meany) * (d.y - meany) )  ) ; 
    sumprods := DataPoint.sumprodxy(datapoints) ; 
    sumdiffxsq := DataPoint.sumdiffxsq(datapoints) ; 
    sumdiffysq := DataPoint.sumdiffysq(datapoints) ; 
    if (sumdiffxsq > 0 & sumdiffysq > 0) then (     correlation := sumprods / ((sumdiffxsq * sumdiffysq))->sqrt() ) else skip ; 
 );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p1 : DataPoint ; p1 := DataPoint.newDataPoint() ;
     p1.x := 0.0 ; 
    p1.y := -1.0 ; 
    var p2 : DataPoint ; p2 := DataPoint.newDataPoint() ;
    p2.x := 0.5 ; 
    p2.y := -1.5 ; 
    var p3 : DataPoint ; p3 := DataPoint.newDataPoint() ;
    p3.x := 1.0 ; 
    p3.y := -2.0 ; 
    var cc : CorrelationCalculator ; cc := CorrelationCalculator.newCorrelationCalculator() ;
    cc.datapoints->excludes(p1) ; 
    cc.datapoints->excludes(p2) ; 
    cc.datapoints->excludes(p3) ; 
    cc.calc() ; 
    OclFile["System.out"].println(cc.correlation) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class DTest {
public boolean compareDates() {
  Date d = new Date(); 
  long x = d.getTime(); 
  Date d1 = (Date) d.clone(); 
  d1.setTime(10000000); 
  d1 = new Date(30000000); 
  return d.after(d1); 
}
}
------------------------------------------------------------
OCL File:
---------
class DTest {
   operation compareDates() : boolean
  pre: true
  post: true
  activity: (     var d : OclDate ; d := OclDate.newOclDate() ;
     var x : long ; x := d.time ;
    var d1 : OclDate ; d1 := d.clone()->oclAsType(OclDate) ;
    d1.setTime(10000000) ; 
    d1 := OclDate.newOclDate(30000000) ; 
    return d.dateAfter(d1) 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class DoubleOperations {
public boolean processDouble() { 
  double dd = Double.MAX_VALUE; 
  dd = Double.NaN; 
  int p = Double.compare(0.0,dd); 
  Double xx = new Double(1.0/3.0); 
  xx = new Double("1.0"); 
  dd = Double.parseDouble(xx); 
  dd = xx.doubleValue(); 
  return dd.isNaN(); 
}
}

------------------------------------------------------------
OCL File:
---------
class DoubleOperations {
   operation processDouble() : boolean
  pre: true
  post: true
  activity: (     var dd : double ; dd := (2 - 2->pow(-52))*(2->pow(1023)) ;
     dd := Math_NaN ; 
    var p : int ; p := (0.0)->compareTo(dd) ;
    var xx : double ; xx := ("" + (1.0 / 3.0))->toReal() ;
    xx := ("" + ("1.0"))->toReal() ; 
    dd := (xx)->toReal() ; 
    dd := xx->oclAsType(double) ; 
    return dd->oclIsInvalid() 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class xx {
    public boolean operation1() {
        Character cc = new Character('$'); 
        char mc = Character.MIN_VALUE; 
        char xc = Character.MAX_VALUE; 
        Class t = Character.TYPE; 
        boolean b = Character.isDigit('9'); 
        b = Character.isLetter('$'); 
        b = Character.isLowerCase('c'); 
        char h = Character.toLowerCase('P'); 
        xc = cc.charValue(); 
        return Character.isJavaIdentifierPart('$');
    }
  }

------------------------------------------------------------
OCL File:
---------
class xx {
   operation operation1() : boolean
  pre: true
  post: true
  activity: (     var cc : String ; cc := String('$') ;
     var mc : String ; mc := "\u0000" ;
    var xc : String ; xc := "\uFFFF" ;
    var t : OclType ; t := ""->oclType() ;
    var b : boolean ; b := ('9' + "")->isMatch("[0-9]") ;
    b := ('$' + "")->isMatch("[a-zA-Z]") ; 
    b := ('c'->toLowerCase() = 'c') ; 
    var h : String ; h := ('P' + "")->toLowerCase() ;
    xc := cc+"" ; 
    return ('$'->isMatch("[0-9a-zA-Z]") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class DWTest {
    public int op() {
        int counter = 1;
        do {
            System.out.println("Counter: " + counter);
            counter++;
        } while (counter <= 10);
        return counter;
    }
}
------------------------------------------------------------
OCL File:
---------
class DWTest {
   operation op() : int
  pre: true
  post: true
  activity: (     var counter : int ; counter := 1 ;
   while true do ((     OclFile["System.out"].println("Counter: " + counter) ; 
     counter := counter + 1 ) ;
    if (counter <= 10) then skip else break) ; 
     return counter );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class EFTest {
    public int op() {
        int[] arr = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };
        int total = 0;
        for (int num : arr) total += num;
        return total;
   }
 }

------------------------------------------------------------
OCL File:
---------
class EFTest {
   operation op() : int
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{87,68,94,100,83,78,85,91,76,87} ;
     var total : int ; total := 0 ;
     for (num : arr) do (     total := total+(num) ;  ) ; 
     return total );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Enumeration;
import java.util.Hashtable;
public class HashtableExample {
    public String op() {
      Hashtable ht = new Hashtable(20); 
      ht.put("1", "aa"); 
      ht.put("2", "bb"); 
      Enumeration en = ht.elements(); 
      String result = ""; 
      while (en.hasMoreElements()) 
      { result = result + en.nextElement(); } 
      return result; 
    }
}

------------------------------------------------------------
OCL File:
---------
 class HashtableExample {
   operation op() : String
  pre: true
  post: true
  activity: (     var ht : Map ; ht := Map{} ;
     ht := ht->union(Map{"1" |-> "aa"}) ; 
    ht := ht->union(Map{"2" |-> "bb"}) ; 
    var en : OclIterator ; en := ht->values()->iterator() ;
    var result : String ; result := "" ;
    while (en.hasMoreElements()) do (     result := result + en.nextElement() ) ; 
    return result 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
enum Gender { male, female, other }
class Person 
{ private Gender gender = Gender.male; 
  String name = ""; 
  Person(String nme) 
  { name = nme; } 
}

------------------------------------------------------------
OCL File:
---------
  enumeration Gender {  literal male;  literal female;  literal other }
 class Person {
   attribute gender : Gender := Gender.male;
   attribute name : String := "";
   static operation newPerson( nme : String) : Person
  pre: true
  post: true
  activity:
  ( var self : Person ;
    self := createPerson();
    self.initialise(nme);
    return self );
  operation initialise( nme : String) : void
  pre: true  post: true
  activity: (     name := nme );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
interface IA { long getTime(); }
abstract class Sup 
{ protected String name; }
class Sub extends Sup implements IA 
{ long getTime() 
  { return 0; } 
}

------------------------------------------------------------
OCL File:
---------
interface IA {
   operation getTime() : long
  pre: true
  post: true;
}
 class Sup {
     attribute name : String;
}
class Sub extends Sup, IA {
   operation getTime() : long
  pre: true
  post: true
  activity: (     return 0 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class FTest {
    public String[] op() {
        File f = new File("f.txt");
        boolean b = f.canRead();
        b = f.exists();
        String n = f.getName();
        b = f.isDirectory();
        b = f.isFile();
        long x = f.lastModified();
        x = f.length();
        return f.list();
    }
}

------------------------------------------------------------
OCL File:
---------
class FTest {
   operation op() : Sequence(String)
  pre: true
  post: true
  activity: (     var f : OclFile ; f := OclFile("f.txt") ;
     var b : boolean ; b := f.canRead() ;
    b := f.exists() ; 
    var n : String ; n := f.getName() ;
    b := f.isDirectory() ; 
    b := f.isFile() ; 
    var x : long ; x := f.lastModified() ;
    x := f.length() ; 
    return f.list() 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class FileRead
{ public void readop()
  { BufferedReader br = null;
    File f = new File("ff.txt");
    br = new BufferedReader(new FileReader(f)); 
    char[] arr = new char[10]; 
    br.read(arr,0,10);
    br.close();  
  }
} 

------------------------------------------------------------
OCL File:
---------
class FileRead {
   operation readop() : void
  pre: true
  post: true
  activity: (     var br : OclFile ; br := null ;
     var f : OclFile ; f := OclFile("ff.txt") ;
    br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(f)) ; 
    var arr : Sequence(String) ; arr := Integer.subrange(1,10)->collect(0) ;
    skip ; 
    skip ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class FloatOperations {
    public boolean processFloat() 
    { 
      Float f = new Float(0.0001); 
      f = new Float("0.0001"); 
      float x = Float.MIN_VALUE; 
      x = Float.POSITIVE_INFINITY; 
      long p = x.longValue(); 
      return x.isInfinite(); 
    }
}

------------------------------------------------------------
OCL File:
---------
class FloatOperations {
   operation processFloat() : boolean
  pre: true
  post: true
  activity: (     var f : double ; f := ("" + (0.0001))->toReal() ;
     f := ("" + ("0.0001"))->toReal() ; 
    var x : double ; x := 2->pow(-149) ;
    x := Math_PINFINITY ; 
    var p : long ; p := x->oclAsType(long) ;
    return x->abs() = Math_PINFINITY 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class C
{ private Formatter fx;
  public C() 
  { try 
    { fx = new Formatter("f.txt"); } 
    catch (Exception _e) 
    { } 
  }
  public void op()
  { fx.format("%s %d %f\n", "String", 1000, 5.5); 
    fx.close(); 
  }
}

------------------------------------------------------------
OCL File:
---------
class C {
   attribute fx : OclFile;
   static operation newC() : C
  pre: true
  post: true
  activity:
  ( var self : C ;
    self := createC();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     try (     fx := OclFile.newOclFile_Write(OclFile.newOclFile("f.txt")) )   catch (_e : ProgramException) do skip
 );
   operation op() : void
  pre: true
  post: true
  activity: (     skip ; 
     skip );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class FTest {
    public int op() {
      int[] arr = {1, 2, 3, 5, 7, 11, 13, 17, 19};
      int total = 0; 
      for (int i = 0; i < arr.length; i++)
      { total += arr[i]; }
      return total;
    }
}

------------------------------------------------------------
OCL File:
---------
class FTest {
   operation op() : int
  pre: true
  post: true
  activity: (     var arr : Sequence(int) ; arr := Sequence{1,2,3,5,7,11,13,17,19} ;
     var total : int ; total := 0 ;
         var i : int ; i := 0 ; while i < arr->size() do ( (     total := total+(arr[i+1]) )  ;     i := i + 1 ) ; 
     return total );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class StringOperation {
    public int stringOp() {
        String s0 = new String();
        byte[] bb = { 97, 98, 99 };
        String s1 = new String(bb);
        char[] cc = { 'x', 'y', 'z' };
        s1 = new String(cc);
        char p = s1.charAt(1);
        return s0.compareToIgnoreCase(s1);
    }
}

------------------------------------------------------------
OCL File:
---------
class StringOperation {
   operation stringOp() : int
  pre: true
  post: true
  activity: (     var s0 : String ; s0 := StringLib.newString() ;
     var bb : Sequence(int) ; bb := Sequence{97,98,99} ;
    var s1 : String ; s1 := StringLib.newString(bb) ;
    var cc : Sequence(String) ; cc := Sequence{'x','y','z'} ;
    s1 := StringLib.newString(cc) ; 
    var p : String ; p := s1->at(1+1) ;
    return s0->toLowerCase()->compareTo(s1->toLowerCase()) 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class StackLike<T>
{ private ArrayList<T> elems;
  public StackLike(int cap)
  { elems = new ArrayList<T>(cap); }
  public T headElement()
  { if (elems.size() > 0) 
    { return elems.get(0); }
    return null;
  }
}

------------------------------------------------------------
OCL File:
---------
class StackLike<T> {
   attribute elems : Sequence(T);
   static operation newStackLike( cap : int) : StackLike
  pre: true
  post: true
  activity:
  ( var self : StackLike ;
    self := createStackLike();
    self.initialise(cap);
    return self );
  operation initialise( cap : int) : void
  pre: true  post: true
  activity: (     elems := Sequence{}->union(cap) );
   operation headElement() : T
  pre: true
  post: true
  activity: (     if (elems->size() > 0) then (     return elems->at(0+1) ) else skip ; 
     return null );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class GTest
{ public static void main(String[] args)
  { Integer[] iarr = { 1, 2, 3, 4 };
   Double[] darr = { 1.0, 2.0, 3.0 };
   Character[] sarr = { 'A', 'B', 'C' };
   System.out.println(GTest.printArray(iarr));
  System.out.println(GTest.printArray(darr));
  System.out.println(GTest.printArray(sarr));
  }
  public static <T> String printArray(T[] arr)
  { String res = "";
    for (T elem : arr)
    { res = res + elem + " "; }
    return res;
  }
}

------------------------------------------------------------
OCL File:
---------
class GTest {
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var iarr : Sequence(int) ; iarr := Sequence{1,2,3,4} ;
     var darr : Sequence(double) ; darr := Sequence{1.0,2.0,3.0} ;
    var sarr : Sequence(String) ; sarr := Sequence{'A','B','C'} ;
    OclFile["System.out"].println(GTest.printArray(iarr)) ; 
    OclFile["System.out"].println(GTest.printArray(darr)) ; 
    OclFile["System.out"].println(GTest.printArray(sarr)) ; 
 );
  static   operation printArray<T>( arr : Sequence(T)) : String
  pre: true
  post: true
  activity: (     var res : String ; res := "" ;
     for (elem : arr) do ( (     res := res + elem + " " )  ) ; 
     return res );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class SetExample {
    public String op() {
     Set st = new HashSet(); 
     st.add("aa"); 
     st.add("bb"); 
     st.add("cc"); 
     boolean b = st.contains("dd"); 
     Iterator it = st.iterator(); 
     String res = "";  
     while (it.hasNext()) 
     { res = res + it.next(); } 
     Set st1 = new HashSet(); 
     st1.add("aa"); 
     b = st.removeAll(st1); 
     b = st.retainAll(st1); 
     return res; 
    }
}

------------------------------------------------------------
OCL File:
---------
 class SetExample {
   operation op() : String
  pre: true
  post: true
  activity: (     var st : Set ; st := Set{} ;
     st := st->including("aa") ; 
    st := st->including("bb") ; 
    st := st->including("cc") ; 
    var b : boolean ; b := st->includes("dd") ;
    var it : OclIterator ; it := st->iterator() ;
    var res : String ; res := "" ;
    while (it.hasNext()) do (     res := res + it.next() ) ; 
    var st1 : Set ; st1 := Set{} ;
    st1 := st1->including("aa") ; 
    b := st->intersection(st1)->notEmpty() ;     st := st - st1 ; 
    b := st /<: st1 ;     st := st->intersection(st1) ; 
    return res 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class HashtableOperations {
    public int processHashtable() { 
     Hashtable ht = new Hashtable(); 
     ht.put("1", "aa"); 
     ht.put("2", "bb"); 
     Enumeration ks = ht.keys(); 
     Set st = ht.keySet(); 
     HashMap<String,String> m = new HashMap<String,String>(); 
     m.put("3", "cc"); 
     ht.putAll(m); 
     String ss = (String) ht.remove("1"); 
     return ht.size(); 
  }
}

------------------------------------------------------------
OCL File:
---------
class HashtableOperations {
   operation processHashtable() : int
  pre: true
  post: true
  activity: (     var ht : Map ; ht := Map{} ;
     ht := ht->union(Map{"1" |-> "aa"}) ; 
    ht := ht->union(Map{"2" |-> "bb"}) ; 
    var ks : OclIterator ; ks := ht->keys()->iterator() ;
    var st : Set ; st := ht->keys() ;
    var m : Map(String,String) ; m := Map{} ;
    m := m->union(Map{"3" |-> "cc"}) ; 
    ht := ht->union(m) ; 
    var ss : String ; ss := ht->at("1")->oclAsType(String) ;
    return ht.size() 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class IfTest {
    public boolean checkValue() {
      int x = 5; 
      if (x < 0) 
      { return true; } 
      else if (x == 0) 
      { return false; } 
      return true; 
    }
 }

------------------------------------------------------------
OCL File:
---------
class IfTest {
   operation checkValue() : boolean
  pre: true
  post: true
  activity: (     var x : int ; x := 5 ;
     if (x < 0) then (     return true ) else     if (x = 0) then (     return false ) else skip ; ;  
     return true );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.Vector;
import java.util.List; 
class Bond
{
  private String name = ""; 
  private double term = 0; 
  private double coupon = 0; 
  private double price = 0; 
  private int frequency = 0; 
  private double yield = 0; 
  private double duration = 0; 
  public Bond()
  {
    this.name = "";
    this.term = 0.0;
    this.coupon = 0.0;
    this.price = 0.0;
    this.frequency = 0;
    this.yield = 0.0;
    this.duration = 0.0;
  }
  public double discount(double amount,double r,double time)
  { double result = 0;
    if (r <= -1 || time < 0) { return result; } 
    result = amount / Math.pow(( 1 + r ),time);
    return result;
  }
}
------------------------------------------------------------
OCL File:
---------
 class Bond {
   attribute name : String := "";
   attribute term : double := 0;
   attribute coupon : double := 0;
   attribute price : double := 0;
   attribute frequency : int := 0;
   attribute yield : double := 0;
   attribute duration : double := 0;
   static operation newBond() : Bond
  pre: true
  post: true
  activity:
  ( var self : Bond ;
    self := createBond();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     self.name := "" ; 
     self.term := 0.0 ; 
    self.coupon := 0.0 ; 
    self.price := 0.0 ; 
    self.frequency := 0 ; 
    self.yield := 0.0 ; 
    self.duration := 0.0 ; 
 );
   operation discount( amount : double, r : double, time : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0 ;
     if (r <= -1 or time < 0) then (     return result ) else skip ; 
     result := amount / (1 + r)->pow(time) ; 
     return result );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
interface IA
{ void opA(); }
interface IB
{ void opB(); }
class A implements IA
{ public void opA() 
  { System.out.println("opA"); } 
}
class B implements IB
{ public void opB() 
  { System.out.println("opB"); } 
}
class D
{ public void op(Object x)
  { if (x instanceof IA) 
    { x.opA(); }
    else if (x instanceof IB) 
    { x.opB(); }
  }
}

------------------------------------------------------------
OCL File:
---------
interface IA {
   operation opA() : void
  pre: true
  post: true;
}
 interface IB {
   operation opB() : void
  pre: true
  post: true;
}
class A implements IA {
   operation opA() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("opA") );
}
class B implements IB {
   operation opB() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("opB") );
}
class D {
   operation op( x : OclAny) : void
  pre: true
  post: true
  activity: (     if (x->oclIsKindOf(IA)) then (     x.opA() ) else     if (x->oclIsKindOf(IB)) then (     x.opB() ) else skip ; );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class Example {
    public String processInteger() {
      Integer ix = new Integer(2000); 
      ix = new Integer("0xFFF"); 
      int p = ix.intValue(); 
      p = Integer.MAX_VALUE; 
      p = Integer.parseInt("0777"); 
      return Integer.toHexString(32);
    }
}

------------------------------------------------------------
OCL File:
---------
class Example {
   operation processInteger() : String
  pre: true
  post: true
  activity: (     var ix : int ; ix := ("" + (2000))->toInteger() ;
     ix := ("" + ("0xFFF"))->toInteger() ; 
    var p : int ; p := ix->oclAsType(int) ;
    p := 2147483647 ; 
    p := ("0777")->toInteger() ; 
    return (MathLib.decimal2hex(32) + "") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
interface Readable 
{ String read(); }
class Person implements Readable
{ String name = "";
  public String read() { return name; } 
}

------------------------------------------------------------
OCL File:
---------
interface Readable {
   operation read() : String
  pre: true
  post: true;
}
 class Person implements Readable {
   attribute name : String := "";
   operation read() : String
  pre: true
  post: true
  activity: (     return name );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class CC
{ public void op()
  { char a = 'a'; char c = 'c';
    int x = a*c;
    int y = c/a;
    int z = c - a;
  }
}

------------------------------------------------------------
OCL File:
---------
class CC {
   operation op() : void
  pre: true
  post: true
  activity: (     var a : String ; a := 'a' ;
     var c : String ; c := 'c' ;
    var x : int ; x := a * c ;
    var y : int ; y := c / a ;
    var z : int ; z := (c)->char2byte() - (a)->char2byte() ;
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class S2Test {
public String op() { 
  String ss = new String("test string"); 
  byte[] bb = ss.getBytes(); 
  char[] cc = new char[3]; 
  ss.getChars(1,3,cc,0); 
  int i = ss.indexOf(" "); 
  i = ss.indexOf(' ', 5); 
  i = ss.lastIndexOf('s'); 
  i = ss.length(); 
  String pp = ss.substring(5); 
  return ss.subSequence(0,5); 
}
}
------------------------------------------------------------
OCL File:
---------
class S2Test {
   operation op() : String
  pre: true
  post: true
  activity: (     var ss : String ; ss := StringLib.newString("test string") ;
     var bb : Sequence(int) ; bb := ss->characters()->collect( _c | _c->char2byte() ) ;
    var cc : Sequence(String) ; cc := Integer.subrange(1,3)->collect(0) ;
    ss.getChars(1, 3, cc, 0) ; 
    var i : int ; i := ss->indexOf(" ")-1 ;
    i := ss.subrange(5+1)->indexOf(' '+"") + 5 - 1  ; 
    i := ss->lastIndexOf('s')-1 ; 
    i := ss->size() ; 
    var pp : String ; pp := ss.subrange(5+1,5) ;
    return ss.subrange(0+1,5) 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class X {
  public void op()
  { short x = 1000;
    short y = (short) (x*x);
  }
}

------------------------------------------------------------
OCL File:
---------
class X {
   operation op() : void
  pre: true
  post: true
  activity: (     var x : int ; x := 1000 ;
     var y : int ; y := ((x * x) mod 32768) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
public class CollectionExample {
    public void op() 
    { Set ss = new HashSet(); 
      Iterator ot = ss.iterator(); 
      Enumeration en = new StringTokenizer("a long string"); 
      Object ob = en.nextElement(); 
      Vector vv = new Vector(ss); 
      en = vv.elements(); 
      en = Collections.enumeration(ss); 
      List pp = new ArrayList(ss); 
      ListIterator lp = pp.listIterator(2); 
    }
}

------------------------------------------------------------
OCL File:
---------
 class CollectionExample {
   operation op() : void
  pre: true
  post: true
  activity: (     var ss : Set ; ss := Set{} ;
     var ot : OclIterator ; ot := ss->iterator() ;
    var en : OclIterator ; en := OclIterator.newOclIterator_String("a long string") ;
    var ob : OclAny ; ob := en.next() ;
    var vv : Sequence ; vv := Sequence{}->union(ss) ;
    en := vv->iterator() ; 
    en := OclIterator.newOclIterator_Set(ss) ; 
    var pp : Sequence ; pp := Sequence{}->union(ss) ;
    var lp : OclIterator ; lp := pp.subrange(2+1)->iterator() ;
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class C<@WS T extends @WS AWS> { }

------------------------------------------------------------
OCL File:
---------
class C<T> { }
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class C<@WS T extends @WS AWS & List> { }

------------------------------------------------------------
OCL File:
---------
class C<T> { }
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.List;
class Purchase {
    private double value;
    public Purchase(double value) {
        this.value = value;
    }
    public double getValue() {
        return value;
    }
}
class Customer {
    private List<Purchase> purchases;
    public Customer(List<Purchase> purchases) {
        this.purchases = purchases;
    }
    public List<Purchase> getPurchases() {
        return purchases;
    }
}
class CSS {
    public static void op(Customer customer) {
        double totalPurchaseValue = 0.0;
        totalPurchaseValue = customer.getPurchases().stream()
                                    .mapToDouble(Purchase::getValue)
                                    .sum();
        System.out.println("Total Purchase Value: " + totalPurchaseValue);
    }
    public static void main(String[] args) {
        Purchase p1 = new Purchase(10.0);
        Purchase p2 = new Purchase(20.0);
        Purchase p3 = new Purchase(30.0);
        Customer customer = new Customer(List.of(p1, p2, p3));
        op(customer);
    }
}

------------------------------------------------------------
OCL File:
---------
 class Purchase {
   attribute value : double;
   static operation newPurchase( value : double) : Purchase
  pre: true
  post: true
  activity:
  ( var self : Purchase ;
    self := createPurchase();
    self.initialise(value);
    return self );
  operation initialise( value : double) : void
  pre: true  post: true
  activity: (     self.value := value );
   operation getValue() : double
  pre: true
  post: true
  activity: (     return value );
}
class Customer {
   attribute purchases : Sequence(Purchase);
   static operation newCustomer( purchases : Sequence(Purchase)) : Customer
  pre: true
  post: true
  activity:
  ( var self : Customer ;
    self := createCustomer();
    self.initialise(purchases);
    return self );
  operation initialise( purchases : Sequence(Purchase)) : void
  pre: true  post: true
  activity: (     self.purchases := purchases );
   operation getPurchases() : Sequence(Purchase)
  pre: true
  post: true
  activity: (     return purchases );
}
class CSS {
  static   operation op( customer : Customer) : void
  pre: true
  post: true
  activity: (     var totalPurchaseValue : double ; totalPurchaseValue := 0.0 ;
     totalPurchaseValue := customer.getPurchases()->collect( _x1 | (lambda _pars : OclAny in Purchase.newPurchase().getValue(_pars))->apply(_x1) )->sum() ; 
     OclFile["System.out"].println("Total Purchase Value: " + totalPurchaseValue) );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     var p1 : Purchase ; p1 := Purchase.newPurchase(10.0) ;
     var p2 : Purchase ; p2 := Purchase.newPurchase(20.0) ;
    var p3 : Purchase ; p3 := Purchase.newPurchase(30.0) ;
    var customer : Customer ; customer := Customer.newCustomer(List.of(p1, p2, p3)) ;
    execute op(customer) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class DTest {
  public void op()
  { Deque<String> dd = new LinkedList<String>();
    dd.offerLast("aa"); dd.addFirst("bb"); dd.addFirst("cc");
    for (int i = 0; i < dd.size(); i++)
    { System.out.println(dd.pollLast()); }
  }
}

------------------------------------------------------------
OCL File:
---------
class DTest {
   operation op() : void
  pre: true
  post: true
  activity: (     var dd : Sequence(String) ; dd := Sequence{} ;
     dd := dd->append("aa") ; 
    dd := dd->prepend("bb") ; 
    dd := dd->prepend("cc") ; 
        var i : int ; i := 0 ; while i < dd->size() do ( (     OclFile["System.out"].println(dd->last()) )  ;     i := i + 1 ) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.EnumSet;
enum Colors { red, orange, green, blue, violet }
class ET2 {
  public EnumSet compl()
  { return EnumSet.complementOf(EnumSet.range(Colors.green,Colors.violet)); }
  public EnumSet cset()
  { return EnumSet.of(Colors.red,Colors.green,Colors.blue); }
  public EnumSet rset()
  { return EnumSet.copyOf(EnumSet.range(Colors.orange,Colors.blue)); }
}

------------------------------------------------------------
OCL File:
---------
   enumeration Colors {  literal red;  literal orange;  literal green;  literal blue;  literal violet }
class ET2 {
   operation compl() : Set
  pre: true
  post: true
  activity: (     return (((Colors.green->oclType()).allInstances()->select(_x | _x >= Colors.green & _x <= Colors.violet)->any()->oclType()).allInstances() - (Colors.green->oclType()).allInstances()->select(_x | _x >= Colors.green & _x <= Colors.violet)) );
   operation cset() : Set
  pre: true
  post: true
  activity: (     return Set{Colors.red, Colors.green, Colors.blue} );
   operation rset() : Set
  pre: true
  post: true
  activity: (     return ((Colors.orange->oclType()).allInstances()->select(_x | _x >= Colors.orange & _x <= Colors.blue))->copy() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
enum Colors { red, orange, green, blue, violet }
class ET {
  public int csize()
  { return Colors.values().length; }
  public EnumSet cset()
  { return EnumSet.allOf(Colors.class); }
  public EnumSet rset()
  { return EnumSet.range(Colors.orange,Colors.blue); }
}

------------------------------------------------------------
OCL File:
---------
  enumeration Colors {  literal red;  literal orange;  literal green;  literal blue;  literal violet }
 class ET {
   operation csize() : int
  pre: true
  post: true
  activity: (     return Colors.allInstances()->size() );
   operation cset() : Set
  pre: true
  post: true
  activity: (     return OclType["Colors"].allInstances() );
   operation rset() : Set
  pre: true
  post: true
  activity: (     return (Colors.orange->oclType()).allInstances()->select(_x | _x >= Colors.orange & _x <= Colors.blue) );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Test { 
  public void op()
  { CSVReader reader = new CSVReader(new FileReader("banking_transactions.csv"));
    List<String[]> rows = reader.readAll();
    SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
    List<Transaction> transactions = new ArrayList<>();
  for (String[] row : rows) {
    Date date = dateFormat.parse(row[0]);
    Transaction transaction = new Transaction(date, row[1], Double.parseDouble(row[2]));
    transactions.add(transaction);
  }
  Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "user", "password");
  PreparedStatement statement = connection.prepareStatement("INSERT INTO transactions (date, description, amount) VALUES (?, ?, ?)");
  for (Transaction transaction : transactions) {
    statement.setDate(1, new java.sql.Date(transaction.getDate().getTime()));
    statement.setString(2, transaction.getDescription());
    statement.setDouble(3, transaction.getAmount());
    statement.executeUpdate();
  }
  statement.close();
  connection.close();
} 
}

------------------------------------------------------------
OCL File:
---------
class Test {
   operation op() : void
  pre: true
  post: true
  activity: (     var reader : CSVReader ; reader := CSVReader.newCSVReader(OclFile.newOclFile_Read(OclFile.newOclFile("banking_transactions.csv"))) ;
     var rows : Sequence(Sequence(String)) ; rows := reader.readAll() ;
    var dateFormat : SimpleDateFormat ; dateFormat := SimpleDateFormat.newSimpleDateFormat("dd/MM/yyyy") ;
    var transactions : Sequence(Transaction) ; transactions := Sequence{} ;
    for (row : rows) do ( (     var date : OclDate ; date := dateFormat.parse(row[0+1]) ;
     var transaction : Transaction ; transaction := Transaction.newTransaction(date, row[1+1], (row[2+1])->toReal()) ;
     transactions := transactions->including(transaction) )  ) ; 
    var connection : OclDatasource ; connection := DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "user", "password") ;
    var statement : SQLStatement ; statement := connection.prepareStatement("INSERT INTO transactions (date, description, amount) VALUES (?, ?, ?)") ;
    for (transaction : transactions) do ( (     statement.setDate(1, Date.newDate(transaction.getDate().getTime())) ; 
     statement.setString(2, transaction.getDescription()) ; 
     statement.setDouble(3, transaction.getAmount()) ; 
     statement.executeUpdate() )  ) ; 
    statement.close() ; 
    connection.close() ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class CC
{ void op() 
  { int x = 0; 
    lab : x++; 
    x *= x; 
    continue lab; 
  } 
}

------------------------------------------------------------
OCL File:
---------
class CC {
   operation op() : void
  pre: true
  post: true
  activity: (     var x : int ; x := 0 ;
     x := x + 1 ; 
     x := x*(x) ; 
     continue );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class StringOperations {
    public boolean stringOp() {
        String str = "long test string";
        boolean b = str.matches("[a-z]+");
        String ss = "test";
        b = str.regionMatches(5, ss, 0, 4);
        String s2 = ss.replace('t', '$');
        s2 = str.replaceAll("[a-z]+", "*");
        String[] sq = str.split(" ");
        return str.startsWith("long");
    }
}

------------------------------------------------------------
OCL File:
---------
class StringOperations {
   operation stringOp() : boolean
  pre: true
  post: true
  activity: (     var str : String ; str := "long test string" ;
     var b : boolean ; b := str->isMatch("[a-z]+") ;
    var ss : String ; ss := "test" ;
    b := str.subrange(5+1,5+4) = ss.subrange(0+1,0+4) ; 
    var s2 : String ; s2 := ss.replace('t', '$') ;
    s2 := str.replaceAllMatches("[a-z]+", "*" ) ; 
    var sq : Sequence(String) ; sq := str->split(" ") ;
    return str->hasPrefix("long") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class CC {
  public void op()
  {   outer:
        for (String str : stringsArr) {
            char[] strChars = str.toCharArray();
            for (char ch : strChars) {
                if (ch == ' ') {
                    /* Continues the outer cycle and the next
                    string is retrieved from stringsArr */
                    continue outer;
                }
                doSomething(ch);
            }
        }
  }
}
------------------------------------------------------------
OCL File:
---------
class CC {
   operation op() : void
  pre: true
  post: true
  activity: (     for (str : stringsArr) do ( (     var strChars : Sequence(String) ; strChars := str->characters() ;
     for (ch : strChars) do ( (     if (ch = ' ') then (     continue ) else skip ; 
     execute doSomething(ch) )  ) )  ) ; );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Outer
{ int x = 0;
  class Inner
  { int op() 
    { return x*10; }
  }
}

------------------------------------------------------------
OCL File:
---------
class Outer {
   attribute x : int := 0;
 class Inner {
   operation op() : int
  pre: true
  post: true
  activity: (     return x * 10 );
}
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class WebClass
{ public String fetchURL(String u)
  { String content = ""; 
    URL uri = new URL(u); 
    HttpURLConnection conn = 
      (HttpURLConnection) uri.openConnection(); 
    conn.setRequestMethod("GET"); 
    conn.connect(); 
    InputStream mystream = conn.getInputStream(); 
    BufferedReader br = new BufferedReader(new InputStreamReader(mystream)); 
    String line = br.readLine(); 
    while (line != null) 
    { content = content + line; 
      line = br.readLine(); 
    } 
    return content; 
  } 
} 

------------------------------------------------------------
OCL File:
---------
class WebClass {
   operation fetchURL( u : String) : String
  pre: true
  post: true
  activity: (     var content : String ; content := "" ;
     var uri : OclDatasource ; uri := OclDatasource.newURL(u) ;
    var conn : OclDatasource ; conn := uri.openConnection()->oclAsType(OclDatasource) ;
    conn.setRequestMethod("GET") ; 
    conn.connect() ; 
    var mystream : OclFile ; mystream := conn.getInputStream() ;
    var br : OclFile ; br := OclFile.newOclFile_Read(OclFile.newOclFile_Read(mystream)) ;
    var line : String ; line := br.readLine() ;
    while (line /= null) do (     content := content + line ; 
     line := br.readLine() ) ; 
    return content 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class DisplayAuthors
{ static final String DBURL = "jdbc:mysql://localhost/books"; 
  public static void openDB()
  { Connection conn = null; 
    Statement stat = null; 
    ResultSet res = null; 
    try { 
      conn = DriverManager.getConnection(DBURL, "user", "passwd"); 
      stat = conn.createStatement(); 
      res = stat.executeQuery(
              "SELECT AuthorID, FirstName, LastName FROM Authors"); 
      while (res.next())
      { System.out.println(res.getString("FirstName") + " " + res.getString("LastName")); } 
    } catch (SQLException e) { } 
    finally 
    { res.close(); 
      stat.close(); 
      conn.close(); 
    } 
  }
}

------------------------------------------------------------
OCL File:
---------
class DisplayAuthors {
  static    attribute DBURL : String := "jdbc:mysql://localhost/books";
  static   operation openDB() : void
  pre: true
  post: true
  activity: (     var conn : OclDatasource ; conn := null ;
     var stat : SQLStatement ; stat := null ;
     var res : OclIterator ; res := null ;
     try (     conn := DriverManager.getConnection(DBURL, "user", "passwd") ; 
     stat := conn.createStatement() ; 
     res := stat.executeQuery("SELECT AuthorID, FirstName, LastName FROM Authors") ; 
     while (res.next()) do (     OclFile["System.out"].println(res.getCurrent()["FirstName"]->oclAsType(String) + " " + res.getCurrent()["LastName"]->oclAsType(String)) ) )   catch (e : IOException) do skip
   finally (     res.close() ; 
     stat.close() ; 
     conn.close() )
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class MatcherTest
{ private String res; 
  public static void op(String document)
  { 
    Pattern pt = Pattern.compile("[0-9]{4}.[0-9]{4}.[0-9]{4}.[0-9]{4}");  
    Matcher mm = pt.matcher(document); 
    boolean found = mm.find(); 
    if (found)
    { int st = mm.start();
      int en = mm.end(); 
      res = document.substring(st,en); 
    } 
  }   
}

------------------------------------------------------------
OCL File:
---------
class MatcherTest {
   attribute res : String;
  static   operation op( document : String) : void
  pre: true
  post: true
  activity: (     var pt : OclRegex ; pt := OclRegex.compile("[0-9]{4}.[0-9]{4}.[0-9]{4}.[0-9]{4}") ;
     var mm : OclRegex ; mm := pt.matcher(document) ;
     var found : boolean ; found := mm.nextMatch() ;
     if (found) then (     var st : int ; st := mm.start() ;
     var en : int ; en := mm.end() ;
     res := document.subrange(st+1,en) ) else skip );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class RefTest
{ public List refop()
  { List x = new ArrayList();
    List y = x;
    y.add("a"); y.add("b");
    return x;
  }
}

------------------------------------------------------------
OCL File:
---------
class RefTest {
   operation refop() : Sequence
  pre: true
  post: true
  activity: (     var x : Sequence ; x := Sequence{} ;
     var y : Sequence ; y := x ;
    y := y->including("a") ; 
    y := y->including("b") ; 
    return x 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
enum AbstractColors { red, green, blue }
enum Colors implements AbstractColors { red, green, blue, mauve, black }

------------------------------------------------------------
OCL File:
---------
  enumeration AbstractColors {  literal red;  literal green;  literal blue }
   enumeration Colors {  literal red;  literal green;  literal blue;  literal mauve;  literal black }

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Lambda2
{ public String opLambda2()
  { Function<String,String> f = 
      (x) -> { String y = x + "Id"; return y; };
    return f.apply("test");
  }
} 

------------------------------------------------------------
OCL File:
---------
class Lambda2 {
   operation opLambda2() : String
  pre: true
  post: true
  activity: (     var f : Function<String,String> ; f := lambda x : OclAny in (     var y : String ; y := x + "Id" ;
     return y ) ;
     return f->apply("test") );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class StringOperations {
String lambdaOp()
{ ArrayList<String> arr = new ArrayList<String>();
  arr.add("aa");
  arr.add("bbb");
  arr.add("c");
  arr.removeIf((s) -> (s.length() > 1));
  return arr + "";
}    
}

------------------------------------------------------------
OCL File:
---------
class StringOperations {
   operation lambdaOp() : String
  pre: true
  post: true
  activity: (     var arr : Sequence(String) ; arr := Sequence{} ;
     arr := arr->including("aa") ; 
    arr := arr->including("bbb") ; 
    arr := arr->including("c") ; 
    arr := arr->reject( _var | (lambda s : OclAny in (s->size() > 1))->apply(_var) ) ; 
    return arr + "" 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class StringOperations {
    public String stringOp() {
        String ss = "a long string";
        char[] chrs = ss.toCharArray();
        String s1 = ss.toUpperCase();
        CharSequence cs = ss.subSequence(5, 7);
        s1 = s1.toLowerCase();
        return ss.trim();
    }
}

------------------------------------------------------------
OCL File:
---------
class StringOperations {
   operation stringOp() : String
  pre: true
  post: true
  activity: (     var ss : String ; ss := "a long string" ;
     var chrs : Sequence(String) ; chrs := ss->characters() ;
    var s1 : String ; s1 := ss->toUpperCase() ;
    var cs : String ; cs := ss.subrange(5+1,7) ;
    s1 := s1->toLowerCase() ; 
    return ss->trim() 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class LinkedListOperations {
int linkedListOp() 
{ LinkedList lst = new LinkedList(); 
  boolean b = lst.add("aa"); 
  lst.add("bb"); 
  lst.add("cc"); 
  lst.addFirst("xx"); 
  lst.addLast("yy"); 
  String str = (String) lst.getFirst();
  str = (String) lst.getLast(); 
  Object obj = lst.removeFirst(); 
  obj = lst.removeLast(); 
  return lst.size(); 
} 
}

------------------------------------------------------------
OCL File:
---------
class LinkedListOperations {
   operation linkedListOp() : int
  pre: true
  post: true
  activity: (     var lst : Sequence ; lst := Sequence{} ;
     var b : boolean ; b := lst->excludes("aa") ;
    lst := lst->including("bb") ; 
    lst := lst->including("cc") ; 
    lst := lst->prepend("xx") ; 
    lst := lst->append("yy") ; 
    var str : String ; str := lst->first()->oclAsType(String) ;
    str := lst->last()->oclAsType(String) ; 
    var obj : OclAny ; obj := lst->first() ;
    obj := lst->last() ;     lst := lst->front() ; 
    return lst->size() 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class LinkedListOperations {
    public String linkedListIteration() { 
      LinkedList lt = new LinkedList(); 
      lt.add("aa"); 
      lt.add("bb"); 
      lt.add(0,"cc"); 
      ListIterator en = lt.listIterator(); 
      String res = ""; 
      while (en.hasNext()) 
      { res = res + en.next(); } 
      return res; 
  }
}

------------------------------------------------------------
OCL File:
---------
class LinkedListOperations {
   operation linkedListIteration() : String
  pre: true
  post: true
  activity: (     var lt : Sequence ; lt := Sequence{} ;
     lt := lt->including("aa") ; 
    lt := lt->including("bb") ; 
    lt := lt.insertAt(0+1,"cc") ; 
    var en : OclIterator ; en := lt->iterator() ;
    var res : String ; res := "" ;
    while (en.hasNext()) do (     res := res + en.next() ) ; 
    return res 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class LongOperations {
    public String performOperations() { 
      Long lx = new Long("0xFFFFFF"); 
      lx = new Long(4000000); 
      lx = Long.decode("07777"); 
      byte b = lx.byteValue(); 
      float f = lx.floatValue(); 
      long lv = Long.MIN_VALUE; 
      return Long.toBinaryString(lv); 
   }
}

------------------------------------------------------------
OCL File:
---------
class LongOperations {
   operation performOperations() : String
  pre: true
  post: true
  activity: (     var lx : long ; lx := ("" + ("0xFFFFFF"))->toLong() ;
     lx := ("" + (4000000))->toLong() ; 
    lx := ("07777")->toLong() ; 
    var b : int ; b := lx->oclAsType(int) ;
    var f : double ; f := lx->oclAsType(double) ;
    var lv : long ; lv := "-9223372036854775808"->toLong() ;
    return (MathLib.decimal2binary(lv) + "") 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class MathOperations {
    public void performOperations() {
      double ee = Math.E; 
      double pp = Math.PI; 
      ee = Math.abs(-1000.0); 
      ee = Math.cos(pp);  
      double xx = Math.atan(0.5); 
      ee = Math.exp(100); 
      xx = Math.max(0.1,0.15); 
      ee = Math.rint(10.1); 
      ee = Math.toDegrees(Math.PI/2); 
    }
}

------------------------------------------------------------
OCL File:
---------
class MathOperations {
   operation performOperations() : void
  pre: true
  post: true
  activity: (     var ee : double ; ee := 2.718281828459045 ;
     var pp : double ; pp := 3.141592653589793 ;
    ee := if -1000.0 < 0 then -(-1000.0) else -1000.0 endif ; 
    ee := (pp)->cos() ; 
    var xx : double ; xx := (0.5)->atan() ;
    ee := (100)->exp() ; 
    xx := Set{0.1, 0.15}->max() ; 
    ee := (1.0*((10.1)->round())) ; 
    ee := (57.29577951308232*(3.141592653589793 / 2)) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ExampleClass {
    public void op() {
        Map<String,Map<String,String>> mmap = new HashMap<String,Map<String,String>>(); 
        Map<String,String> m1 = new HashMap<String,String>(); 
        m1.put("a","aa"); 
        m1.put("b","ab"); 
        m1.put("c","ac"); 
        Map<String,String> m2 = new HashMap<String,String>(); 
        m2.put("a","ba"); 
        m2.put("b","bb"); 
        m2.put("c","bc"); 
        mmap.put("a", m1); 
        mmap.put("b", m2); 
    }
}

------------------------------------------------------------
OCL File:
---------
class ExampleClass {
   operation op() : void
  pre: true
  post: true
  activity: (     var mmap : Map(String,Map(String,String)) ; mmap := Map{} ;
     var m1 : Map(String,String) ; m1 := Map{} ;
    m1 := m1->union(Map{"a" |-> "aa"}) ; 
    m1 := m1->union(Map{"b" |-> "ab"}) ; 
    m1 := m1->union(Map{"c" |-> "ac"}) ; 
    var m2 : Map(String,String) ; m2 := Map{} ;
    m2 := m2->union(Map{"a" |-> "ba"}) ; 
    m2 := m2->union(Map{"b" |-> "bb"}) ; 
    m2 := m2->union(Map{"c" |-> "bc"}) ; 
    mmap := mmap->union(Map{"a" |-> m1}) ; 
    mmap := mmap->union(Map{"b" |-> m2}) ; 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
interface IA 
{ void opA(); }
interface IB 
{ void opB(); } 
class C implements IA, IB
{ public void opA()
  { System.out.println("Operation A"); } 
  public void opB() 
  { System.out.println("Operation B"); } 
} 
public class D
{ public D()
  { IA ax = new C(); 
    IB bx = ax; 
    ax.opA(); 
    bx.opB(); 
  } 
}

------------------------------------------------------------
OCL File:
---------
interface IA {
   operation opA() : void
  pre: true
  post: true;
}
 interface IB {
   operation opB() : void
  pre: true
  post: true;
}
class C implements IA, IB {
   operation opA() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Operation A") );
   operation opB() : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println("Operation B") );
}
class D {
   static operation newD() : D
  pre: true
  post: true
  activity:
  ( var self : D ;
    self := createD();
    self.initialise();
    return self );
  operation initialise() : void
  pre: true  post: true
  activity: (     var ax : IA ; ax := C.newC() ;
     var bx : IB ; bx := ax ;
     ax.opA() ; 
     bx.opB() );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class L2
{ public void op()
  { Function<String,String> f = (String x)->{ return x+x; };
    Function<int,int> g = (x)->{ return x*x*x; };
  }
}

------------------------------------------------------------
OCL File:
---------
class L2 {
   operation op() : void
  pre: true
  post: true
  activity: (     var f : Function<String,String> ; f := lambda  x : String : OclAny in (     return x + x ) ;
     var g : Function<int,int> ; g := lambda x : OclAny in (     return x * x * x ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class LL
{ public void op()
  { Function<int,int> f = 
       (int x)->{ if (x > 0) 
                  { return 1; } 
                  else if (x < 0) 
                  { return -1; } 
                  return 0; }; 
  }
}

------------------------------------------------------------
OCL File:
---------
class LL {
   operation op() : void
  pre: true
  post: true
  activity: (     var f : Function<int,int> ; f := lambda  x : int : OclAny in (     if (x > 0) then (     return 1 ) else     if (x < 0) then (     return -1 ) else skip ; ;  
     return 0 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class FF
{ public void op()
  { Function<int, Function<int,int>> cmp = 
      (int x, int y)->{ if (x < y) { return -1; } 
                        if (x > y) { return 1; } 
                        return 0;
                      };
  }
}

------------------------------------------------------------
OCL File:
---------
class FF {
   operation op() : void
  pre: true
  post: true
  activity: (     var cmp : Function<int,Function<int,int>> ; cmp := lambda  x : int, y : int : OclAny in (     if (x < y) then (     return -1 ) else skip ; 
     if (x > y) then (     return 1 ) else skip ; 
     return 0 ) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Controller
{
  public static void maine()
  { String x = "aa"; 
    String y = "aabb".substring(0,2); 
    System.out.println(x == y); 
    System.out.println(x.equals(y));  
  } 
}

------------------------------------------------------------
OCL File:
---------
class Controller {
  static   operation maine() : void
  pre: true
  post: true
  activity: (     var x : String ; x := "aa" ;
     var y : String ; y := "aabb".subrange(0+1,2) ;
     OclFile["System.out"].println(x = y) ; 
     OclFile["System.out"].println(x = y) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class LT
{ public void op() { 
    int x = 2;
    Object lam1 = x->(x*x);
    Object lam2 = (x,y)->(x*x*y);
    Object lam3 = (int x, int y)->(x*x*y);
  }
}

------------------------------------------------------------
OCL File:
---------
class LT {
   operation op() : void
  pre: true
  post: true
  activity: (     var x : int ; x := 2 ;
     var lam1 : OclAny ; lam1 := lambda x : OclAny in (x * x) ;
     var lam2 : OclAny ; lam2 := lambda (x , y) : OclAny in (x * x * y) ;
     var lam3 : OclAny ; lam3 := lambda  x : int, y : int : OclAny in (x * x * y) );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ExampleClass {
    public void op() {
      int x = 1;
      int y = 0;
      y = (++x) + (x++); 
    }
}

------------------------------------------------------------
OCL File:
---------
class ExampleClass {
   operation op() : void
  pre: true
  post: true
  activity: (     var x : int ; x := 1 ;
     var y : int ; y := 0 ;
         x := x + 1 ;
 y := (x) + (x)  ; x := x + 1 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
abstract class Person
{ String name = "";
  public Person(String nme)
  { name = nme; }
  public String getName() { return name; }
}
class User extends Person
{ String userId = "0000";
  public User(String nme, String uId)
  { super(nme);
    userId = uId;
  }
}
class Staff extends Person
{ int staffNo = 0;
  public Staff(String nme, int sNo)
  { super(nme);
    staffNo = sNo;
  }
  public void setStaffNo(int x) { staffNo = x; }
}

------------------------------------------------------------
OCL File:
---------
class Person {
   attribute name : String := "";
   static operation newPerson( nme : String) : Person
  pre: true
  post: true
  activity:
  ( var self : Person ;
    self := createPerson();
    self.initialise(nme);
    return self );
  operation initialise( nme : String) : void
  pre: true  post: true
  activity: (     name := nme );
   operation getName() : String
  pre: true
  post: true
  activity: (     return name );
}
 class User extends Person {
   attribute userId : String := "0000";
   static operation newUser( nme : String, uId : String) : User
  pre: true
  post: true
  activity:
  ( var self : User ;
    self := createUser();
    self.initialise(nme, uId);
    return self );
  operation initialise( nme : String, uId : String) : void
  pre: true  post: true
  activity: (     execute super(nme) ; 
     userId := uId );
}
class Staff extends Person {
   attribute staffNo : int := 0;
   static operation newStaff( nme : String, sNo : int) : Staff
  pre: true
  post: true
  activity:
  ( var self : Staff ;
    self := createStaff();
    self.initialise(nme, sNo);
    return self );
  operation initialise( nme : String, sNo : int) : void
  pre: true  post: true
  activity: (     execute super(nme) ; 
     staffNo := sNo );
   operation setStaffNo( x : int) : void
  pre: true
  post: true
  activity: (     staffNo := x );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class NFTest {
    public int op() { 
     int[] sums = new int[10]; 
     for (int i = 0; i < 10; i++) 
     { for (int j = 1; j <= i; j++) 
       { sums[i] += j; } 
     }
     return sums[9]; 
   }
}

------------------------------------------------------------
OCL File:
---------
class NFTest {
   operation op() : int
  pre: true
  post: true
  activity: (     var sums : Sequence(int) ; sums := Integer.subrange(1,10)->collect(0) ;
         var i : int ; i := 0 ; while i < 10 do ( (         var j : int ; j := 1 ; while j <= i do ( (     sums[i+1] := sums[i+1]+(j) )  ;     j := j + 1 ) )  ;     i := i + 1 ) ; 
     return sums[9+1] );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
import java.util.*;
import java.util.HashMap;
import java.util.Collection;
import java.util.List;
import java.util.ArrayList;
import java.util.Set;
import java.util.HashSet;
import java.util.TreeSet;
import java.util.Collections;
class InterestRate 
{ 
   double maturity = 0.0;
   double rate = 0.0;
   String interestrateId = ""; 
  public static double nelsonseigal( double t,  
                             double v1,  double v2,  double v3,  double lambda)
  {
     double result = 0.0;
     double tscaled = 0.0;
    tscaled = t / lambda;
     double exptscaled = 0.0;
    exptscaled = Math.exp((-tscaled));
     double expratio = 0.0;
    expratio = (1 - exptscaled) / tscaled;
    result = v1 + v2 * expratio + v3 * (expratio - exptscaled);
    return result;
  }
  public static  double nelsonseigalsvensson( double t,  
                           double v1,  double v2,  double v3,  double v4,  
						   double lambda1,  double lambda2)
  {
     double result = 0.0;
     double tscaled1 = 0.0;
    tscaled1 = t / lambda1;
     double tscaled2 = 0.0;
    tscaled2 = t / lambda2;
     double exptscaled1 = 0.0;
    exptscaled1 = Math.exp((-tscaled1));
     double exptscaled2 = 0.0;
    exptscaled2 = Math.exp((-tscaled2));
     double expratio1 = 0.0;
    expratio1 = (1 - exptscaled1) / tscaled1;
     double expratio2 = 0.0;
    expratio2 = (1 - exptscaled2) / tscaled2;
    result = v1 + v2 * expratio1 + v3 * (expratio1 - exptscaled1) + v4 * (expratio2 - exptscaled2);
    return result;
  }
  public static  double ns( double t,  double v1,  double v2,  double v3,  double lambda)
  {
     double result = 0.0;
    if (t == 0)
    {
      result = v1 + v2;
    }
    else {
      if (t > 0)
    {
      result = InterestRate.nelsonseigal(t, v1, v2, v3, lambda);
    }
    else {
      }
    }
    return result;
  }
  public static  double nss( double t,  double v1,  double v2,  double v3,  double v4,  
                             double lambda1,  double lambda2)
  {
     double result = 0.0;
    if (t == 0)
    {
      result = v1 + v2;
    }
    else {
      if (t > 0)
    {
      result = InterestRate.nelsonseigalsvensson(t, v1, v2, v3, v4, lambda1, lambda2);
    }
    else {
      }
    }
    return result;
  }
  public static void main(String[] args) 
  { System.out.println(InterestRate.ns(0.0, 1.0, -2.0, 3.0, 4.0));
    System.out.println(InterestRate.ns(2.5, 1.0, -2.0, 3.0, 4.0));
    System.out.println(InterestRate.ns(5.0, 1.0, -2.0, 3.0, 4.0));
    System.out.println(InterestRate.ns(7.5, 1.0, -2.0, 3.0, 4.0));
    System.out.println(InterestRate.ns(10.0, 1.0, -2.0, 3.0, 4.0));
    System.out.println(InterestRate.ns(12.5, 1.0, -2.0, 3.0, 4.0));
    System.out.println(InterestRate.ns(15.0, 1.0, -2.0, 3.0, 4.0));
	/* Identical results in Java and Python: 
	   -1.0
       0.13779742881264467
       0.7112817719312776
       0.9914791171479194
       1.120911004678744
       1.1741293803702872
       1.1898420302037036
    */ 
	System.out.println(InterestRate.nss(0.0, 1.0, -2.0, 3.0, 4.0, 8.0, 10.0));
    System.out.println(InterestRate.nss(2.5, 1.0, -2.0, 3.0, 4.0, 8.0, 10.0));
    System.out.println(InterestRate.nss(5.0, 1.0, -2.0, 3.0, 4.0, 8.0, 10.0));
    System.out.println(InterestRate.nss(7.5, 1.0, -2.0, 3.0, 4.0, 8.0, 10.0));
    System.out.println(InterestRate.nss(10.0, 1.0, -2.0, 3.0, 4.0, 8.0, 10.0));
    System.out.println(InterestRate.nss(12.5, 1.0, -2.0, 3.0, 4.0, 8.0, 10.0));
    System.out.println(InterestRate.nss(15.0, 1.0, -2.0, 3.0, 4.0, 8.0, 10.0));
    /* Identical results in Java and Python: 
	-1.0
    0.08796743910272342
    0.8594295122610436
    1.3987159592648803
    1.768246242559739
    2.014180013376635
    2.170611382825054
     */ 
  }
}

------------------------------------------------------------
OCL File:
---------
 class InterestRate {
   attribute maturity : double := 0.0;
   attribute rate : double := 0.0;
   attribute interestrateId : String := "";
  static   operation nelsonseigal( t : double, v1 : double, v2 : double, v3 : double, lambda : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0.0 ;
     var tscaled : double ; tscaled := 0.0 ;
    tscaled := t / lambda ; 
    var exptscaled : double ; exptscaled := 0.0 ;
    exptscaled := ((-tscaled))->exp() ; 
    var expratio : double ; expratio := 0.0 ;
    expratio := (1 - exptscaled) / tscaled ; 
    result := v1 + v2 * expratio + v3 * (expratio - exptscaled) ; 
    return result 
 );
  static   operation nelsonseigalsvensson( t : double, v1 : double, v2 : double, v3 : double, v4 : double, lambda1 : double, lambda2 : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0.0 ;
     var tscaled1 : double ; tscaled1 := 0.0 ;
    tscaled1 := t / lambda1 ; 
    var tscaled2 : double ; tscaled2 := 0.0 ;
    tscaled2 := t / lambda2 ; 
    var exptscaled1 : double ; exptscaled1 := 0.0 ;
    exptscaled1 := ((-tscaled1))->exp() ; 
    var exptscaled2 : double ; exptscaled2 := 0.0 ;
    exptscaled2 := ((-tscaled2))->exp() ; 
    var expratio1 : double ; expratio1 := 0.0 ;
    expratio1 := (1 - exptscaled1) / tscaled1 ; 
    var expratio2 : double ; expratio2 := 0.0 ;
    expratio2 := (1 - exptscaled2) / tscaled2 ; 
    result := v1 + v2 * expratio1 + v3 * (expratio1 - exptscaled1) + v4 * (expratio2 - exptscaled2) ; 
    return result 
 );
  static   operation ns( t : double, v1 : double, v2 : double, v3 : double, lambda : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0.0 ;
     if (t = 0) then (     result := v1 + v2 ) else (     if (t > 0) then (     result := InterestRate.nelsonseigal(t, v1, v2, v3, lambda) ) else skip ) ;  
     return result );
  static   operation nss( t : double, v1 : double, v2 : double, v3 : double, v4 : double, lambda1 : double, lambda2 : double) : double
  pre: true
  post: true
  activity: (     var result : double ; result := 0.0 ;
     if (t = 0) then (     result := v1 + v2 ) else (     if (t > 0) then (     result := InterestRate.nelsonseigalsvensson(t, v1, v2, v3, v4, lambda1, lambda2) ) else skip ) ;  
     return result );
  static   operation main( args : Sequence(String)) : void
  pre: true
  post: true
  activity: (     OclFile["System.out"].println(InterestRate.ns(0.0, 1.0, -2.0, 3.0, 4.0)) ; 
     OclFile["System.out"].println(InterestRate.ns(2.5, 1.0, -2.0, 3.0, 4.0)) ; 
    OclFile["System.out"].println(InterestRate.ns(5.0, 1.0, -2.0, 3.0, 4.0)) ; 
    OclFile["System.out"].println(InterestRate.ns(7.5, 1.0, -2.0, 3.0, 4.0)) ; 
    OclFile["System.out"].println(InterestRate.ns(10.0, 1.0, -2.0, 3.0, 4.0)) ; 
    OclFile["System.out"].println(InterestRate.ns(12.5, 1.0, -2.0, 3.0, 4.0)) ; 
    OclFile["System.out"].println(InterestRate.ns(15.0, 1.0, -2.0, 3.0, 4.0)) ; 
    OclFile["System.out"].println(InterestRate.nss(0.0, 1.0, -2.0, 3.0, 4.0, 8.0, 10.0)) ; 
    OclFile["System.out"].println(InterestRate.nss(2.5, 1.0, -2.0, 3.0, 4.0, 8.0, 10.0)) ; 
    OclFile["System.out"].println(InterestRate.nss(5.0, 1.0, -2.0, 3.0, 4.0, 8.0, 10.0)) ; 
    OclFile["System.out"].println(InterestRate.nss(7.5, 1.0, -2.0, 3.0, 4.0, 8.0, 10.0)) ; 
    OclFile["System.out"].println(InterestRate.nss(10.0, 1.0, -2.0, 3.0, 4.0, 8.0, 10.0)) ; 
    OclFile["System.out"].println(InterestRate.nss(12.5, 1.0, -2.0, 3.0, 4.0, 8.0, 10.0)) ; 
    OclFile["System.out"].println(InterestRate.nss(15.0, 1.0, -2.0, 3.0, 4.0, 8.0, 10.0)) ; 
 );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Person implements Serializable
{ String name = "";
  double age = 0.0;
  public Person(String nme, double ag)
  { name = nme;
    age = ag;
  }
}
class ReadObject
{ void readObj()
  { ObjectInputStream instream = new ObjectInputStream(new FileInputStream("out.dat"));
    Person pp = (Person) instream.readObject();
    System.out.println(pp.name + " " + pp.age);
    instream.close();
  }
}

------------------------------------------------------------
OCL File:
---------
class Person implements OclAny {
   attribute name : String := "";
   attribute age : double := 0.0;
   static operation newPerson( nme : String, ag : double) : Person
  pre: true
  post: true
  activity:
  ( var self : Person ;
    self := createPerson();
    self.initialise(nme, ag);
    return self );
  operation initialise( nme : String, ag : double) : void
  pre: true  post: true
  activity: (     name := nme ; 
     age := ag );
}
 class ReadObject {
   operation readObj() : void
  pre: true
  post: true
  activity: (     var instream : OclFile ; instream := OclFile.newOclFile_ReadB(OclFile.newOclFile_Read(OclFile.newOclFile("out.dat"))) ;
     var pp : Person ; pp := instream.readObject()->oclAsType(Person) ;
     OclFile["System.out"].println(pp.name + " " + pp.age) ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Person implements Serializable
{ String name = "";
  double age = 0.0;
  public Person(String nme, double ag)
  { name = nme; 
    age = ag; 
  }
}
class WriteObject
{ void writeObj()
  { Person p = new Person("Tom", 55);
    ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("out.dat"));
    os.writeObject(p);
    os.close();
  }
}
------------------------------------------------------------
OCL File:
---------
class Person implements OclAny {
   attribute name : String := "";
   attribute age : double := 0.0;
   static operation newPerson( nme : String, ag : double) : Person
  pre: true
  post: true
  activity:
  ( var self : Person ;
    self := createPerson();
    self.initialise(nme, ag);
    return self );
  operation initialise( nme : String, ag : double) : void
  pre: true  post: true
  activity: (     name := nme ; 
     age := ag );
}
 class WriteObject {
   operation writeObj() : void
  pre: true
  post: true
  activity: (     var p : Person ; p := Person.newPerson("Tom", 55) ;
     var os : OclFile ; os := OclFile.newOclFile_WriteB(OclFile.newOclFile(OclFile.newOclFile_Write(OclFile.newOclFile("out.dat")))) ;
     skip ; 
     skip );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
public class ObjectManipulator {
    public boolean manipulateObject() {
     Object s = "string object"; 
     Object r = new Object(); 
     r = (String) s.clone(); 
     s.finalize(); 
     Class cx = r.getClass(); 
     r.wait(1000); 
     return r.equals(null); 
    }
}

------------------------------------------------------------
OCL File:
---------
class ObjectManipulator {
   operation manipulateObject() : boolean
  pre: true
  post: true
  activity: (     var s : OclAny ; s := "string object" ;
     var r : OclAny ; r := Map{} ;
    r := s->copy()->oclAsType(String) ; 
    s->isDeleted() ; 
    var cx : OclType ; cx := r->oclType() ;
    r.wait(1000) ; 
    return r = null 
 );
}
 <EOF>

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
class Person
{ String name = "";
  int age = 0;
  public Person(String nme) { name = nme; }
  public int birthday()
  { ++age; 
    return age; 
  }
}
class Student extends Person
{ String studying = "";
  public Student(String nme, String course)
  { super(nme); 
    studying = course; 
  }
}

------------------------------------------------------------
OCL File:
---------
class Person {
   attribute name : String := "";
   attribute age : int := 0;
   static operation newPerson( nme : String) : Person
  pre: true
  post: true
  activity:
  ( var self : Person ;
    self := createPerson();
    self.initialise(nme);
    return self );
  operation initialise( nme : String) : void
  pre: true  post: true
  activity: (     name := nme );
   operation birthday() : int
  pre: true
  post: true
  activity: (     age := age + 1 ; 
     return age );
}
 class Student extends Person {
   attribute studying : String := "";
   static operation newStudent( nme : String, course : String) : Student
  pre: true
  post: true
  activity:
  ( var self : Student ;
    self := createStudent();
    self.initialise(nme, course);
    return self );
  operation initialise( nme : String, course : String) : void
  pre: true  post: true
  activity: (     execute super(nme) ; 
     studying := course );
}

------------------------------------------------------------
------------------------------------------------------------
Java Program:
-------------
package p1;
interface IX 
{ int op1(); 
  double op2(); 
}
class A implements IX
{ int op1() 
  { return 1; }
  double op2() 
  { return 2.0; }
}
class B implements IX
{ int op1() 
  { return 2; }
  double op2() 
  { return 3.0; }
}

------------------------------------------------------------
OCL File:
---------
 interface IX {
   operation op1() : int
  pre: true
  post: true;
   operation op2() : double
  pre: true
  post: true;
}
class A implements IX {
   operation op1() : int
  pre: true
  post: true
  activity: (     return 1 );
   operation op2() : double
  pre: true
  post: true
  activity: (     return 2.0 );
}
class B implements IX {
   operation op1() : int
  pre: true
  post: true
  activity: (     return 2 );
   operation op2() : double
  pre: true
  post: true
  activity: (     return 3.0 );
}

------------------------------------------------------------
------------------------------------------------------------